diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 282589148..3d0966da1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -339,41 +339,21 @@ jobs:
           bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_MODULE
           bake rebuild --strict --cfg release -D FLECS_CUSTOM_BUILD -D FLECS_MODULE
 
-      - name: FLECS_SNAPSHOT
-        run: |
-          bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_SNAPSHOT
-          bake rebuild --strict --cfg release -D FLECS_CUSTOM_BUILD -D FLECS_SNAPSHOT
-
       - name: FLECS_STATS
         run: |
           bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_STATS
           bake rebuild --strict --cfg release -D FLECS_CUSTOM_BUILD -D FLECS_STATS
 
-      - name: FLECS_PARSER
-        run: |
-          bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_PARSER
-          bake rebuild --strict --cfg release -D FLECS_CUSTOM_BUILD -D FLECS_PARSER
-
-      - name: FLECS_PLECS
+      - name: FLECS_SCRIPT
         run: |
-          bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_PLECS
-          bake rebuild --strict --cfg release -D FLECS_CUSTOM_BUILD -D FLECS_PLECS
+          bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_SCRIPT
+          bake rebuild --strict --cfg release -D FLECS_CUSTOM_BUILD -D FLECS_SCRIPT
 
       - name: FLECS_META
         run: |
           bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_META
           bake rebuild --strict --cfg release -D FLECS_CUSTOM_BUILD -D FLECS_META
 
-      - name: FLECS_META_C
-        run: |
-          bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_META_C
-          bake rebuild --strict --cfg release -D FLECS_CUSTOM_BUILD -D FLECS_META_C
-
-      - name: FLECS_EXPR
-        run: |
-          bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_EXPR
-          bake rebuild --strict --cfg release -D FLECS_CUSTOM_BUILD -D FLECS_EXPR
-
       - name: FLECS_JSON
         run: |
           bake rebuild --strict -D FLECS_CUSTOM_BUILD -D FLECS_JSON
@@ -488,8 +468,11 @@ jobs:
       - name: build flecs
         run: bake --strict
 
-      - name: test api
-        run: bake run test/api -- -j 8
+      - name: test core
+        run: bake run test/core -- -j 8
+
+      - name: test query
+        run: bake run test/query -- -j 8
 
       - name: test addons
         run: bake run test/addons -- -j 8
@@ -497,6 +480,9 @@ jobs:
       - name: test meta
         run: bake run test/meta -- -j 8
 
+      - name: test script
+        run: bake run test/script -- -j 8
+
       - name: test collections
         run: bake run test/collections -- -j 8
 
@@ -550,7 +536,7 @@ jobs:
         run: bake --strict
 
       - name: test c++
-        run: bake run test/cpp_api -- -j 8
+        run: bake run test/cpp -- -j 8
 
   test-cpp-macos:
     needs: [build-macos]
@@ -590,7 +576,7 @@ jobs:
         run: bake --strict
 
       - name: test c++
-        run: bake run test/cpp_api -- -j 8
+        run: bake run test/cpp -- -j 8
 
   test-windows:
     needs: build-windows
@@ -613,8 +599,8 @@ jobs:
       - name: build flecs
         run: bake/bake
 
-      - name: test api
-        run: bake/bake run test\api -- -j 8
+      - name: test core
+        run: bake/bake run test\core -- -j 8
 
       - name: test addons
         run: bake/bake run test\addons -- -j 8
@@ -622,11 +608,14 @@ jobs:
       - name: test meta
         run: bake/bake run test\meta -- -j 8
 
+      - name: test script
+        run: bake/bake run test\script -- -j 8
+
       - name: test collections
         run: bake/bake run test\collections -- -j 8
 
       - name: test c++
-        run: bake/bake run test\cpp_api -- -j 8
+        run: bake/bake run test\cpp -- -j 8
 
   test-msys:
     runs-on: windows-latest
@@ -669,10 +658,13 @@ jobs:
           bake/bake setup
 
       - name: build flecs
-        run: bake/bake --strict
+        run: bake/bake --strict --trace
+
+      - name: test core
+        run: bake/bake run test/core -- -j 8
 
-      - name: test api
-        run: bake/bake run test/api -- -j 8
+      - name: test query
+        run: bake/bake run test/query -- -j 8
 
       - name: test addons
         run: bake/bake run test/addons -- -j 8
@@ -680,13 +672,16 @@ jobs:
       - name: test meta
         run: bake/bake run test/meta -- -j 8
 
+      - name: test script
+        run: bake/bake run test/script -- -j 8
+
       - name: test collections
         run: bake/bake run test/collections -- -j 8
 
       - name: test c++
-        run: bake/bake run test/cpp_api -- -j 8
+        run: bake/bake run test/cpp -- -j 8
 
-  test-sanitized-api:
+  test-sanitized-core:
     needs: [ build-linux ]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 30
@@ -708,7 +703,31 @@ jobs:
 
       - name: run tests
         run: |
-          bake run test/api --cfg sanitize -- -j 8
+          bake run test/core --cfg sanitize -- -j 8
+
+  test-sanitized-query:
+    needs: [ build-linux ]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-20.04 ]
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: install bake
+        run: |
+          git clone https://github.com/SanderMertens/bake
+          make -C bake/build-$(uname)
+          bake/bake setup
+
+      - name: build flecs
+        run: bake --strict
+
+      - name: run tests
+        run: |
+          bake run test/query --cfg sanitize -- -j 8
 
   test-sanitized-addons:
     needs: [ build-linux ]
@@ -758,6 +777,30 @@ jobs:
         run: |
           bake run test/meta --cfg sanitize -- -j 8
 
+  test-sanitized-script:
+    needs: [ build-linux ]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-20.04 ]
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: install bake
+        run: |
+          git clone https://github.com/SanderMertens/bake
+          make -C bake/build-$(uname)
+          bake/bake setup
+
+      - name: build flecs
+        run: bake --strict
+
+      - name: run tests
+        run: |
+          bake run test/script --cfg sanitize -- -j 8
+
   test-sanitized-collections:
     needs: [ build-linux ]
     runs-on: ${{ matrix.os }}
@@ -782,7 +825,7 @@ jobs:
         run: |
           bake run test/collections --cfg sanitize -- -j 8
 
-  test-sanitized-cpp_api:
+  test-sanitized-cpp:
     needs: [ build-linux ]
     runs-on: ${{ matrix.os }}
     timeout-minutes: 30
@@ -804,7 +847,7 @@ jobs:
 
       - name: run tests
         run: |
-          bake run test/cpp_api --cfg sanitize -- -j 8
+          bake run test/cpp --cfg sanitize -- -j 8
 
   test-cmake:
     needs: [ build-linux, build-macos ]
diff --git a/README.md b/README.md
index 8bd399a60..fa367434e 100644
--- a/README.md
+++ b/README.md
@@ -62,8 +62,8 @@ typedef struct {
 } Position, Velocity;
 
 void Move(ecs_iter_t *it) {
-  Position *p = ecs_field(it, Position, 1);
-  Velocity *v = ecs_field(it, Velocity, 2);
+  Position *p = ecs_field(it, Position, 0);
+  Velocity *v = ecs_field(it, Velocity, 1);
 
   for (int i = 0; i < it->count; i++) {
     p[i].x += v[i].x;
@@ -79,7 +79,7 @@ int main(int argc, char *argv[]) {
 
   ECS_SYSTEM(ecs, Move, EcsOnUpdate, Position, Velocity);
 
-  ecs_entity_t e = ecs_new_id(ecs);
+  ecs_entity_t e = ecs_new(ecs);
   ecs_set(ecs, e, Position, {10, 20});
   ecs_set(ecs, e, Velocity, {1, 2});
 
@@ -108,7 +108,7 @@ int main(int argc, char *argv[]) {
     });
 
   auto e = ecs.entity()
-    .set([](Position& p, Velocity& v) {
+    .insert([](Position& p, Velocity& v) {
       p = {10, 20};
       v = {1, 2};
     });
diff --git a/docs/DesignWithFlecs.md b/docs/DesignWithFlecs.md
index be8ed14d9..b45c60f4a 100644
--- a/docs/DesignWithFlecs.md
+++ b/docs/DesignWithFlecs.md
@@ -44,7 +44,7 @@ There is a misconception that ECS components can only be plain data types, and s
 Queries are the primary method in Flecs for finding the entities for a set of components (or more specifically: a component expression). Queries are easy to use, but there a few things to keep in mind.
 
 ### Use the right query
-Flecs has cached queries and uncached queries. Cached queries (`ecs_query_t` and `flecs::query`) are expensive to create but very cheap to iterate. Uncached queries (`ecs_filter_t`, `flecs::filter`) are fast to create, but more expensive to iterate. If you need to do a quick ad-hoc query for which you couldn't know in advance what you had to query for, an uncached query is the best option. If you have a query that you know in advance and need to iterate many times, a cached query is preferred.
+Flecs has cached queries and uncached queries. Cached queries (`ecs_query_cache_t` and `flecs::query`) are expensive to create but very cheap to iterate. Uncached queries (`ecs_query_t`, `flecs::query`) are fast to create, but more expensive to iterate. If you need to do a quick ad-hoc query for which you couldn't know in advance what you had to query for, an uncached query is the best option. If you have a query that you know in advance and need to iterate many times, a cached query is preferred.
 
 Another difference is that uncached queries can be created from systems, while cached queries cannot. If you need a cached query in a system, it has to be created in advance and passed into the system, either by setting it as system context, adding a component to the system with the query, or passing it in the lambda capture list (C++ only). Systems themselves use cached queries.
 
diff --git a/docs/FlecsScriptManual.md b/docs/FlecsScriptManual.md
new file mode 100644
index 000000000..82c83f528
--- /dev/null
+++ b/docs/FlecsScriptManual.md
@@ -0,0 +1,708 @@
+# Flecs Script
+
+## Introduction
+Flecs Script is a runtime interpreted DSL for creating entities and components that is optimized for defining scenes, assets and configuration. In a nutshell, Flecs Script is to ECS what HTML/JSX is to a browser.
+
+Some of the features of Flecs Script are:
+
+- Native support for named entities, hierarchies and inheritance
+- Assign component values
+- Expressions and variables (`$var + 10`)
+- Conditionals (`if $var > 10`)
+- Native integration with assemblies (procedural assets)
+
+To learn Flecs Script, check out the [Tutorial](FlecsScriptTutorial.md)!
+
+## Example
+
+```c
+using flecs.meta
+
+struct MaxSpeed {
+  value = f32
+}
+
+struct Position {
+  x = f32
+  y = f32
+}
+
+Prefab SpaceShip {
+  MaxSpeed: {value: 100}
+
+  cockpit {
+    Position: {x: -10, y: 0}
+  }
+}
+
+my_spaceship : SpaceShip {
+  Position: {x: 10, y: 20}
+}
+```
+
+## The Basics
+This section goes over the basic syntax over Flecs Script.
+
+### Entities
+An entity is created by specifying an identifier followed by a scope. Example:
+
+```c
+my_entity {}
+```
+
+An entity scope can contain components and child entities. The following example shows how to add a child entity:
+
+```c
+my_parent {
+  my_child {}
+}
+```
+
+Note how a scope is also added to the child entity.
+
+So far these examples show how to create named entities. To create anonymous entities, use the `_` identifier:
+
+```c
+_ {
+  my_child {} // named child with anonymous parent
+}
+```
+
+### Tags
+A tag can be added to an entity by simply specifying the tag's identifier in an entity scope. Example:
+
+```c
+my_entity {
+  SpaceShip // SpaceShip tag
+}
+```
+
+If a tag didn't exist yet, it will be automatically created in the script root. The following example is equivalent to the previous one:
+
+```c
+SpaceShip
+
+my_entity {
+  SpaceShip // Now resolves to the existing SpaceShip tag
+}
+```
+
+### Pairs
+Pairs are added to entities by adding them to an entity scope, just like tags:
+
+```c
+my_entity {
+  (Likes, Pizza)
+}
+```
+
+Just like with tags, if the entities in the pair did not yet exist, they will be created in the script root.
+
+### Components
+Components are specified like tags, but with an additional value:
+
+```c
+my_entity {
+  Position: {x: 10, y: 20}
+}
+```
+
+A component must exist before it can be used. Furthermore, for it to be assigneable with a value, it also needs to be described in the reflection framework.
+
+A component can also be added without a value. This will create a default constructed component. Example:
+
+```c
+my_entity {
+  Position
+}
+```
+
+Components can be defined in a script:
+
+```c
+using flecs.meta
+
+struct Position {
+  x = f32
+  y = f32
+}
+
+my_entity {
+  Position: {x: 10, y: 20}
+}
+```
+
+Components can be pairs:
+
+```c
+my_entity {
+  (Start, Position): {x: 0,  y: 0}
+  (Stop,  Position): {x: 10, y: 20}
+}
+```
+
+### Entity kinds
+An entity can be created with a "kind", which is a component specified before the entity name. This is similar to adding a tag or component in a scope, but can provide a more natural way to describe things. For example:
+
+```c
+SpaceShip my_spaceship {}
+```
+
+This is equivalent to doing:
+
+```c
+my_spaceship {
+  SpaceShip
+}
+```
+
+When using the entity kind syntax, the scope is optional:
+
+```c
+SpaceShip my_spaceship // no {}
+```
+
+If the specified kind is a component, a value can be specified between parentheses:
+
+```c
+CheckBox my_checkbox(checked: true)
+```
+
+When the entity kind is a component, a value will always be assigned even if none is specified. This is different from component assignments in a scope. Example:
+
+```c
+CheckBox my_checkbox(checked: true)
+
+// is equivalent to
+
+my_checkbox {
+  CheckBox: {checked: true}
+}
+```
+
+```c
+CheckBox my_checkbox
+
+// is equivalent to
+
+my_checkbox {
+  CheckBox: {}
+}
+```
+
+### Inheritance
+Scripts can natively specify inheritance relationships between entities, which is useful in particular for prefabs. Example:
+
+```c
+Prefab SpaceShip {
+  MaxSpeed: {value: 100}
+}
+
+my_spaceship : SpaceShip {}
+```
+
+When specifying inheritance, the scope is optional:
+
+```c
+my_spaceship : SpaceShip // no {}
+```
+
+This is equivalent to doing:
+
+```c
+my_spaceship {
+  (IsA, SpaceShip)
+}
+```
+
+### Relationship hierarchies
+By default entity hierarchies are created with the `ChildOf` relationship. Other relationships can also be used to create hierarchies by combining a pair with a scope. Example:
+
+```c
+(IsA, Thing) {
+  (IsA, Organism) {
+    (IsA, Plant) {
+      Tree
+    }
+    (IsA, Animal) {
+      Human
+    }
+  }
+}
+```
+
+## Advanced Features
+
+### Module statement
+The `module` statement puts all contents of a script in a module. Example:
+
+```c
+module components.transform
+
+// Creates components.transform.Position
+struct Position {
+  x = f32
+  y = f32
+}
+```
+
+The `components.transform` entity will be created with the `Module` tag.
+
+### Using statement
+The `using` keyword imports a namespace into the current namespace. Example:
+
+```c
+// Without using
+flecs.meta.struct Position {
+  x = flecs.meta.f32
+  y = flecs.meta.f32
+}
+```
+```c
+// With using
+using flecs.meta
+
+struct Position {
+  x = f32
+  y = f32
+}
+```
+
+The `using` keyword only applies to the scope in which it is specified. Example:
+
+```c
+// Scope without using
+my_engine {
+  game.engines.FtlEngine: {active: true}
+}
+```
+```c
+// Scope with using
+my_spaceship {
+  using game.engines
+
+  FtlEngine: {active: true}
+}
+```
+
+A `using` statement may end with a wildcard (`*`). This will import all namespaces matching the path. Example:
+
+```c
+using flecs.*
+
+struct Position {
+  x = f32
+  y = f32
+}
+```
+
+### With statement
+When you're buildin a scene or asset you may find yourself often repeating the same components for multiple entities. To avoid this, a `with` statement can be used. For example:
+
+```c
+with SpaceShip {
+  MilleniumFalcon {}
+  UssEnterprise {}
+  UssVoyager {}
+  Rocinante {}
+}
+```
+
+This is equivalent to doing:
+
+```c
+MilleniumFalcon {
+  SpaceShip
+}
+
+UssEnterprise {
+  SpaceShip
+}
+
+UssVoyager {
+  SpaceShip
+}
+
+Rocinante {
+  SpaceShip
+}
+```
+
+With statements can contain multiple tags:
+
+```c
+with SpaceShip, HasWeapons {
+  MilleniumFalcon {}
+  UssEnterprise {}
+  UssVoyager {}
+  Rocinante {}
+}
+```
+
+With statements can contain component values, specified between parentheses:
+
+```c
+with Color(38, 25, 13) {
+  pillar_1 {}
+  pillar_2 {}
+  pillar_3 {}
+}
+```
+
+### Variables
+Scripts can contain variables, which are useful for often repeated values. Variables are created with the `const` keyworld. Example:
+
+```c
+const pi = 3.1415926
+
+my_entity {
+  Rotation: {angle: $pi}
+}
+```
+
+Variables can be combined with expressions:
+
+```c
+const pi = 3.1415926
+const pi_2 = $pi * 2
+
+my_entity {
+  Rotation: {angle: $pi / 2}
+}
+```
+
+In the above examples, the type of the variable is inferred. Variables can also be provided with an explicit type:
+
+```c
+const wood = Color: {38, 25, 13}
+```
+
+Variables can be used in component values as shown in the previous examples, or can be used directly as component. Example:
+
+```c
+const wood = Color: {38, 25, 13}
+
+my_entity {
+  $wood
+}
+
+// is equivalent to
+
+my_entity {
+  Color: {38, 25, 13}
+}
+```
+
+Additionally, variables can also be used in combination with `with` statements:
+
+```c
+const wood = Color: {38, 25, 13}
+
+with $color {
+  pillar_1 {}
+  pillar_2 {}
+  pillar_3 {}
+}
+```
+
+### If statement
+Parts of a script can be conditionally executed with an if statement. Example:
+
+```c
+const daytime = bool: false
+
+lantern {
+  Color: {210, 255, 200}
+
+  if $daytime {
+    Emissive: {value: 0}
+  } else {
+    Emissive: {value: 1}
+  }
+}
+```
+
+### Default components
+A scope can have a default component, which means entities in that scope can assign values of that component without having to specify the component name. 
+
+There are different ways to specify a default component. One way is to use a `with` statement. Default component values are assigned with the `=` operator, and don't need a `{}` surrounding the value. Example:
+
+```c
+with Position {
+  ent_a = 10, 20
+  ent_b = 20, 30
+}
+```
+
+Another way a default components are derived is from the entity kind. If an entity is specified with a kind, a `DefaultChildComponent` component will be looked up on the kind to find the default component for the scope, if any. For example:
+
+```c
+// Create a PositionList tag with a DefaultChildComponent
+PositionList {
+  DefaultChildComponent: {Position}
+}
+
+// Derive default component for scope from PositionList
+PositionList plist {
+  ent_a = 10, 20
+  ent_b = 10, 20
+  ent_c = 10, 20
+}
+```
+
+A common use of default components is when creating structs. `struct` is a component with `member` as default child component. Example:
+
+```c
+struct Position {
+  x = f32
+  y = f32
+}
+
+// is equivalent to
+
+struct Position {
+  member x(f32)
+  member y(f32)
+}
+```
+
+Note how `member` is also used as kind for the children. This means that children of `x` and `y` derive their default child component from `member`, which is set to `member`. This makes it easy to create nested members:
+
+```c
+struct Line {
+  start {
+    x = f32
+    y = f32
+  }
+  stop {
+    x = f32
+    y = f32
+  }
+}
+
+// is equivalent to
+
+struct Line {
+  member start {
+    member x(f32)
+    member y(f32)
+  }
+  member stop {
+    member x(f32)
+    member y(f32)
+  }
+}
+```
+
+### Semicolon operator
+Multiple statements can be combined on a single line when using the semicolon operator. Example:
+
+```c
+my_spaceship {
+  SpaceShip; HasFtl
+}
+```
+
+## Comma operator
+The comma operator can be used as a shortcut to create multiple entities in a scope. Example:
+
+```c
+my_spaceship {
+  pilot_a,
+  pilot_b,
+  pilot_c
+}
+
+// is equivalent to
+
+my_spaceship {
+  pilot_a {}
+  pilot_b {}
+  pilot_c {}
+}
+```
+
+This allows for a more natural way to describe things like enum types:
+
+```c
+enum Color {
+  Red,
+  Green,
+  Blue
+}
+
+// is equivalent to
+
+enum Color {
+  constant Red
+  constant Green
+  constant Blue
+}
+```
+
+## Assemblies
+Assemblies are parametrizable scripts that can be used to create procedural assets. Assemblies can be created with the `assembly` keyword. Example:
+
+```c
+assembly Square {
+  Color: {255, 0, 0}
+  Rectangle: {width: 100, height: 100}
+}
+```
+
+The script contents of an assembly are not ran immediately. Instead they are ran whenever an assembly is _instantiated_. To instantiate an assembly, add it as a regular component to an entity:
+
+```c
+my_entity {
+  Square
+}
+
+// is equivalent to
+
+my_entity {
+  Color: {255, 0, 0}
+  Rectangle: {width: 100, height: 100}
+}
+```
+
+Assemblies are commonly used in combination with the kind syntax:
+
+```c
+Square my_entity
+```
+
+Assemblies can be parametrized with properties. Properties are variables that are exposed as component members. To create a property, use the `prop` keyword. Example:
+
+```c
+assembly Square {
+  prop size = i32: 10
+  prop color = Color: {255, 0, 0}
+
+  $color
+  Rectangle: {width: $size, height: $size}
+}
+
+Square my_entity(size: 20, color: {38, 25, 13})
+```
+
+Assembly scripts can do anything a regular script can do, including creating child entities. The following example shows how to create an assembly that uses a nested assembly to create children:
+
+```c
+assembly Tree {
+  prop height = f32: 10
+
+  const wood_color = Color: {38, 25, 13}
+  const leaves_color = Color: {51, 76, 38}
+
+  const canopy_height = 2
+  const trunk_height = $height - $canopy_height
+  const trunk_width = 2
+
+  Trunk {
+    Position: {0, ($height / 2), 0}
+    Rectangle: {$trunk_width, $trunk_height}
+    $wood_color
+  }
+
+  Canopy {
+    const canopy_y = $trunk_height + ($canopy_height / 2)
+
+    Position3: {0, $canopy_y, 0}
+    Box: {$canopy_width, $canopy_height}
+    $leaves_color
+  }
+}
+
+assembly Forest {
+  Tree(height: 5) {
+    Position: {x: -10}
+  }
+
+  Tree(height: 10) {
+    Position: {x: 0}
+  }
+
+  Tree(height: 7) {
+    Position: {x: 10}
+  }
+}
+
+Forest my_forest
+```
+
+## API
+This section goes over how to run scripts in an application.
+
+### Run once
+To run a script once, use the `ecs_script_run` function. Example:
+
+```c
+const char *code = "my_spaceship {}";
+
+if (ecs_script_run(world, "my_script_name", code)) {
+  // error
+}
+```
+
+Alternatively a script can be ran directly from a file:
+
+```c
+if (ecs_script_run_file(world, "my_script.flecs")) {
+  // error
+}
+```
+
+If a script fails, the entities created by the script will not be automatically deleted. When a script contains assemblies, script resources will not get cleaned up until the entities associated with the assemblies are deleted.
+
+### Run multiple times
+A script can be ran multiple times by using the `ecs_script_parse` and `ecs_script_eval` functions. Example:
+
+```c
+const char *code = "my_spaceship {}";
+
+ecs_script_t *script = ecs_script_parse(
+  world, "my_script_name", code); 
+if (!script) {
+  // error
+}
+
+if (ecs_script_eval(script)) {
+  // error
+}
+
+// Run again
+if (ecs_script_eval(script)) {
+}
+
+// Free script resources
+ecs_script_free(script);
+```
+
+If a script fails, the entities created by the script will not be automatically deleted. When a script contains assemblies, script resources will not get cleaned up until the entities associated with the assemblies are deleted.
+
+### Managed script
+Managed scripts are scripts that are associated with an entity, and can be ran multiple times. Entities created by a managed script are tagged with the script. When script execution fails, the entities associated with the script will be deleted. Additionally, if after executing the script again an entity is no longer created by the script, it will also be deleted.
+
+To run a managed script, do:
+
+```c
+const char *code = "my_spaceship {}";
+
+ecs_entity_t s = ecs_script(world, {
+  .code = code
+});
+
+if (!s) {
+  // error
+}
+```
+
+To update the code of a managed script, use the `ecs_script_update` function:
+
+```c
+if (ecs_script_update(world, s, 0, new_code)) {
+  // error
+}
+```
+
+When a script contains assemblies, script resources will not get cleaned up until the entities associated with the assemblies are deleted.
diff --git a/docs/FlecsScriptTutorial.md b/docs/FlecsScriptTutorial.md
index 601ecc6af..e2c8e6674 100644
--- a/docs/FlecsScriptTutorial.md
+++ b/docs/FlecsScriptTutorial.md
@@ -5,7 +5,7 @@ In this tutorial we will be designing a simple fence asset from scratch, and mak
 
 [![preview of fence asset](img/script_tutorial/tut_playground_preview.png)](https://www.flecs.dev/explorer/?local=true&wasm=https://www.flecs.dev/explorer/playground.js&script=using%20flecs.components.*%0Ausing%20flecs.meta%0Ausing%20flecs.game%0A%0Aconst%20PI%20%3D%203.1415926%0A%0Aplane%20%7B%0A%20%20-%20Position3%7B%7D%0A%20%20-%20Rotation3%7B%24PI%20%2F%202%7D%0A%20%20-%20Rectangle%7B10000%2C%2010000%7D%0A%20%20-%20Rgb%7B0.9%2C%200.9%2C%200.9%7D%0A%7D%0A%0Aassembly%20Fence%20%7B%0A%20%20%2F%2F%20Fence%20parameters%0A%20%20prop%20width%20%3A%20f32%20%3D%2040%0A%20%20prop%20height%20%3A%20f32%20%3D%2020%0A%20%20prop%20color%20%3A%20Rgb%20%3D%20%7B0.15%2C%200.1%2C%200.05%7D%0A%0A%20%20%2F%2F%20Pillar%20parameters%0A%20%20const%20pillar_width%20%3D%202%0A%20%20const%20pillar_spacing%20%3D%2010%0A%20%20const%20pillar_count%20%3D%20%24width%20%2F%20%24pillar_spacing%0A%20%20const%20p_grid_spacing%20%3D%20%24width%20%2F%20(%24pillar_count%20-%201)%0A%20%0A%20%20%2F%2F%20Bar%20parameters%0A%20%20const%20bar_spacing%20%3D%203%0A%20%20const%20bar_height%20%3D%202%0A%20%20const%20bar_depth%20%3D%20%24pillar_width%20%2F%202%0A%20%20const%20bar_count%20%3D%20%24height%20%2F%20%24bar_spacing%0A%20%20const%20b_grid_spacing%20%3D%20%24height%20%2F%20%24bar_count%0A%20%20%20%0A%20%20with%20Prefab%2C%20%24color%20%7B%0A%20%20%20%20Pillar%20%3A-%20Box%20%7B%0A%20%20%20%20%20%20%24pillar_width%2C%20%24height%2C%20%24pillar_width%0A%20%20%20%20%7D%0A%20%20%20%20Bar%20%3A-%20Box%20%7B%24width%2C%20%24bar_height%2C%20%24bar_depth%7D%0A%20%20%7D%20%20%20%20%0A%20%20%0A%20%20%2F%2F%20Pillars%0A%20%20pillars%20%7B%0A%20%20%20%20-%20Position3%7By%3A%20%24height%2F2%7D%0A%20%20%20%20-%20Grid%7B%0A%20%20%20%20%20%20x.count%3A%20%24pillar_count%2C%0A%20%20%20%20%20%20x.spacing%3A%20%24p_grid_spacing%0A%20%20%20%20%20%20prefab%3A%20Pillar%20%20%20%20%0A%20%20%20%20%7D%0A%20%20%7D%0A%0A%20%20%2F%2F%20Bars%0A%20%20bars%20%7B%0A%20%20%20%20-%20Position3%7By%3A%20%24height%2F2%7D%0A%20%20%20%20-%20Grid%7B%0A%20%20%20%20%20%20y.count%3A%20%24bar_count%2C%0A%20%20%20%20%20%20y.spacing%3A%20%24b_grid_spacing%0A%20%20%20%20%20%20prefab%3A%20Bar%20%20%20%20%0A%20%20%20%20%7D%0A%20%20%7D%0A%7D%20%2F%2F%20assembly%20Fence%0A%0A%0Aassembly%20Enclosing%20%7B%0A%20%20prop%20width%3A%20f32%20%3D%2040%0A%20%20prop%20height%3A%20f32%20%3D%2010%0A%20%20prop%20depth%3A%20f32%20%3D%2040%0A%20%20prop%20color%3A%20Rgb%20%3D%20%7B0.15%2C%200.1%2C%200.05%7D%0A%20%20%0A%20%20const%20width_half%20%3D%20%24width%20%2F%202%0A%20%20const%20depth_half%20%3D%20%24depth%20%2F%202%0A%20%20const%20PI%20%3D%203.1415926%0A%0A%20%20left%20%7B%0A%20%20%20%20-%20Position3%7Bx%3A%20-%24width_half%7D%0A%20%20%20%20-%20Rotation3%7By%3A%20%24PI%20%2F%202%7D%0A%20%20%20%20-%20Fence%7Bwidth%3A%20%24depth%2C%20height%3A%24%2C%20color%3A%24%7D%0A%20%20%7D%0A%20%20right%20%7B%0A%20%20%20%20-%20Position3%7Bx%3A%20%24width_half%7D%0A%20%20%20%20-%20Rotation3%7By%3A%20%24PI%20%2F%202%7D%0A%20%20%20%20-%20Fence%7Bwidth%3A%20%24depth%2C%20height%3A%24%2C%20color%3A%24%7D%0A%20%20%7D%0A%20%20back%20%7B%0A%20%20%20%20-%20Position3%7Bz%3A%20-%24depth_half%7D%0A%20%20%20%20-%20Fence%7Bwidth%3A%20%24width%2C%20height%3A%24%2C%20color%3A%24%7D%0A%20%20%7D%0A%20%20front%20%7B%0A%20%20%20%20-%20Position3%7Bz%3A%20%24depth_half%7D%0A%20%20%20%20-%20Fence%7Bwidth%3A%20%24width%2C%20height%3A%24%2C%20color%3A%24%7D%0A%20%20%7D%0A%7D%20%2F%2F%20assembly%20Enclosing%0A%0Afence_a%20%7B%0A%20%20-%20Enclosing%7B%7D%0A%7D%0A%0Acamera%20%7B%0A%20%20-%20Position3%7B21%2C%2019%2C%20-37%7D%0A%20%20-%20Rotation3%7B-0.42%2C%20-0.52%7D%0A%7D%0A)
 
-Note: in order to use Flecs script an app needs to be built with the `FLECS_PLECS` addon.
+Note: in order to use Flecs script an app needs to be built with the `FLECS_SCRIPT` addon.
 
 ## Getting Started with the Explorer
 The Flecs explorer is a web-based application that lets us write scripts and see the results directly. In the tutorial we will use the explorer in combination with the Flecs playground, which has a rendering canvas and comes preloaded with a number of modules and assets.
@@ -145,7 +145,7 @@ Now add these lines into the editor to create our ground `plane`:
 ```js
 plane {
   - Position3{}
-  - Rectangle{100, 100}
+  Rectangle: {100, 100}
   - Rgb{0.9, 0.9, 0.9}
 }
 ```
@@ -181,8 +181,8 @@ Let's now add a cube to the scene. The code for this looks similar to the plane:
 ```js
 box {
   - Position3{}
-  - Box{10, 10, 10}
-  - Rgb{1, 0, 0}
+  Box: {10, 10, 10}
+  Rgb: {1, 0, 0}
 }
 ```
 
@@ -195,8 +195,8 @@ To fix this, we can move it up by setting the `y` member of `Position3` to half
 ```js
 box {
   - Position3{y: 5}
-  - Box{10, 10, 10}
-  - Rgb{1, 0, 0}
+  Box: {10, 10, 10}
+  Rgb: {1, 0, 0}
 }
 ```
 
@@ -223,11 +223,11 @@ Inside the `with` statement we can now create two box entities for the left and
 with Rgb{0.15, 0.1, 0.05} {
   left_pillar {
     - Position3{x: -10, y: 5}
-    - Box{2, 10, 2}
+    Box: {2, 10, 2}
   }
   right_pillar {
     - Position3{x: 10, y: 5}
-    - Box{2, 10, 2}
+    Box: {2, 10, 2}
   }
 }
 ```
@@ -241,7 +241,7 @@ That works, but the code is starting to look a bit unwieldy. There are lots of m
 First lets define two variables for the color and box shape of the pillars. We already saw an example of a variable when we defined `PI`. These looks similar, except that because they are composite values, we also define their type:
 
 ```js
-const color : Rgb = {0.15, 0.1, 0.05}
+const color = Rgb: {0.15, 0.1, 0.05}
 const pillar_box : Box = {2, 10, 2}
 ```
 
@@ -249,7 +249,7 @@ This is better, but `pillar_box` still contains values that we have to update ea
 
 ```js
 const height = 10
-const color : Rgb = {0.15, 0.1, 0.05}
+const color = Rgb: {0.15, 0.1, 0.05}
 
 const pillar_width = 2
 const pillar_box : Box = {
@@ -287,7 +287,7 @@ This is no fence yet. We're still missing the crossbars. Let's add another entit
 ```js
 bar {
   - Position3{y: $height / 2}
-  - Box{$width, 2, 1}
+  Box: {$width, 2, 1}
   - $color  
 }
 ```
@@ -299,12 +299,12 @@ Let's add a second entity and space the two entities out a bit so they don't ove
 ```js
 top_bar {
   - Position3{y: $height/2 + 2}
-  - Box{$width, 2, 1}
+  Box: {$width, 2, 1}
   - $color  
 }
 bottom_bar {
   - Position3{y: $height/2 - 2}
-  - Box{$width, 2, 1}
+  Box: {$width, 2, 1}
   - $color  
 }
 ```
@@ -411,7 +411,7 @@ We could save this script as is, load it into our game, and instantiate the pref
 
 ```c
 // In C
-ecs_plecs_from_file(world, "fence.flecs");
+ecs_script_run_file(world, "fence.flecs");
 
 ecs_entity_t fence = ecs_lookup(world, "Fence");
 ecs_entity_t fence_a = ecs_new_w_pair(world, EcsIsA, fence);
@@ -424,7 +424,7 @@ ecs_set(world, fence_b, EcsPosition3, {10});
 // In C++
 using namespace flecs::components::transform;
 
-ecs_plecs_from_file(world, "fence.flecs");
+ecs_script_run_file(world, "fence.flecs");
 
 auto fence = world.lookup("Fence");
 auto fence_a = world.entity().is_a(fence);
@@ -473,9 +473,9 @@ Let's take the existing `width`, `height` and `color` variables, and change them
 
 ```js
 assembly Fence {
-  prop width : flecs.meta.f32 = 20
-  prop height : flecs.meta.f32 = 10
-  prop color : Rgb = {0.15, 0.1, 0.05}
+  prop width = flecs.meta.f32: 20
+  prop height = flecs.meta.f32: 10
+  prop color = Rgb: {0.15, 0.1, 0.05}
 
   // fence code
 }
@@ -491,9 +491,9 @@ The code can now be changed to this:
 
 ```js
 assembly Fence {
-  prop width : f32 = 20
-  prop height : f32 = 10
-  prop color : Rgb = {0.15, 0.1, 0.05}
+  prop width = f32: 20
+  prop height = f32: 10
+  prop color = Rgb: {0.15, 0.1, 0.05}
 
   // fence code
 }
@@ -516,11 +516,11 @@ The fences are back, with the default values we provided to our props. But we no
 
 ```js
 fence_a {
-  - Fence{width: 10, height: 20}
+  Fence: {width: 10, height: 20}
   - Position3{-10}
 }
 fence_b {
-  - Fence{width: 25, height: 10}
+  Fence: {width: 25, height: 10}
   - Position3{10}
 }
 ```
@@ -544,11 +544,11 @@ ECS_COMPONENT(world, Fence);
 
 // Because the Fence assembly has the same name as the
 // component it will "bind" to it.
-ecs_plecs_from_file(world, "fence.flecs");
+ecs_script_run_file(world, "fence.flecs");
 
 // Set the component as usual
-ecs_entity_t fence_a = ecs_set(world, 0, Fence, {10, 20});
-ecs_entity_t fence_b = ecs_set(world, 0, Fence, {25, 10});
+ecs_entity_t fence_a = ecs_insert(world, ecs_value(Fence, {10, 20}));
+ecs_entity_t fence_b = ecs_insert(world, ecs_value(Fence, {25, 10}));
 
 ecs_set(world, fence_a, EcsPosition3, {-10});
 ecs_set(world, fence_b, EcsPosition3, {10});
@@ -565,7 +565,7 @@ struct Fence {
 
 // Because the Fence assembly has the same name as the
 // component it will "bind" to it.
-ecs_plecs_from_file(world, "fence.flecs");
+ecs_script_run_file(world, "fence.flecs");
 
 auto fence_a = world.entity().set<Fence>({10, 20});
 auto fence_b = world.entity().set<Fence>({25, 10});
@@ -644,7 +644,7 @@ fence :- Fence{}
 And increase the `width` of the fence to `60`:
 
 ```js
-  prop width : f32 = 60
+  prop width = f32: 60
 ```
 
 We now get a number of pillars that matches the fence length:
@@ -679,10 +679,10 @@ When put together, this is what it looks like:
 
 ```js
 assembly Enclosing {
-  prop width: f32 = 40
-  prop height: f32 = 10
-  prop depth: f32 = 40
-  prop color: Rgb = {0.15, 0.1, 0.05}
+  prop width = f32: 40
+  prop height = f32: 10
+  prop depth = f32: 40
+  prop color = Rgb: {0.15, 0.1, 0.05}
   
   // enclosing code goes here
 }
@@ -699,20 +699,20 @@ up writing the same divisions multiple times.
   left {
     - Position3{x: -$width_half}
     - Rotation3{y: $PI/2}
-    - Fence{width: $depth, height:$, color:$}
+    Fence: {width: $depth, height:$, color:$}
   }
   right {
     - Position3{x: $width_half}
     - Rotation3{y: $PI/2}
-    - Fence{width: $depth, height:$, color:$}
+    Fence: {width: $depth, height:$, color:$}
   }
   back {
     - Position3{z: -$depth_half}
-    - Fence{width: $width, height:$, color:$}
+    Fence: {width: $width, height:$, color:$}
   }
   front {
     - Position3{z: $depth_half}
-    - Fence{width: $width, height:$, color:$}
+    Fence: {width: $width, height:$, color:$}
   }
 ```
 
@@ -737,7 +737,7 @@ Here is what that looks like. You might need to zoom out a bit with the camera t
 We can now easily modify our enclosing by passing in parameters for width and height:
 
 ```
-enclosing :- Enclosing{width: 100, height: 30}
+enclosing { Enclosing: {width: 100, height: 30} }
 ```
 
 [![a tall enclosing](img/script_tutorial/tut_playground_pasture_2.png)](https://www.flecs.dev/explorer/?local=true&wasm=https://www.flecs.dev/explorer/playground.js&script=using%20flecs.components.*%0Ausing%20flecs.meta%0Ausing%20flecs.game%0A%0Aconst%20PI%20%3D%203.1415926%0A%0A%2F%2F%20The%20ground%20plane%0Aplane%20%7B%0A%20%20-%20Position3%7B%7D%0A%20%20-%20Rotation3%7B%24PI%2F2%7D%0A%20%20-%20Rectangle%7B10000%2C%2010000%7D%0A%20%20-%20Rgb%7B0.9%2C%200.9%2C%200.9%7D%0A%7D%0A%0Aassembly%20Fence%20%7B%0A%20%20%2F%2F%20Fence%20parameters%0A%20%20prop%20width%20%3A%20f32%20%3D%2040%0A%20%20prop%20height%20%3A%20f32%20%3D%2020%0A%20%20const%20color%20%3A%20Rgb%20%3D%20%7B0.15%2C%200.1%2C%200.05%7D%0A%0A%20%20%2F%2F%20Pillar%20parameters%0A%20%20const%20pillar_width%20%3D%202%0A%20%20const%20pillar_spacing%20%3D%2010%0A%20%20const%20pillar_count%20%3D%20%24width%20%2F%20%24pillar_spacing%0A%20%20const%20p_grid_spacing%20%3D%20%24width%20%2F%20(%24pillar_count%20-%201)%0A%20%0A%20%20%2F%2F%20Bar%20parameters%0A%20%20const%20bar_spacing%20%3D%203%0A%20%20const%20bar_height%20%3D%202%0A%20%20const%20bar_depth%20%3D%20%24pillar_width%20%2F%202%0A%20%20const%20bar_count%20%3D%20%24height%20%2F%20%24bar_spacing%0A%20%20const%20b_grid_spacing%20%3D%20%24height%20%2F%20%24bar_count%0A%20%20%20%0A%20%20with%20Prefab%2C%20%24color%20%7B%0A%20%20%20%20Pillar%20%3A-%20Box%20%7B%0A%20%20%20%20%20%20%24pillar_width%2C%20%24height%2C%20%24pillar_width%0A%20%20%20%20%7D%0A%20%20%20%20Bar%20%3A-%20Box%20%7B%24width%2C%20%24bar_height%2C%20%24bar_depth%7D%0A%20%20%7D%20%20%20%20%0A%20%20%0A%20%20%2F%2F%20Pillars%0A%20%20pillars%20%7B%0A%20%20%20%20-%20Position3%7By%3A%20%24height%2F2%7D%0A%20%20%20%20-%20Grid%7B%0A%20%20%20%20%20%20x.count%3A%20%24pillar_count%2C%0A%20%20%20%20%20%20x.spacing%3A%20%24p_grid_spacing%0A%20%20%20%20%20%20prefab%3A%20Pillar%20%20%20%20%0A%20%20%20%20%7D%0A%20%20%7D%0A%0A%20%20%2F%2F%20Bars%0A%20%20bars%20%7B%0A%20%20%20%20-%20Position3%7By%3A%20%24height%2F2%7D%0A%20%20%20%20-%20Grid%7B%0A%20%20%20%20%20%20y.count%3A%20%24bar_count%2C%0A%20%20%20%20%20%20y.spacing%3A%20%24b_grid_spacing%0A%20%20%20%20%20%20prefab%3A%20Bar%20%20%20%20%0A%20%20%20%20%7D%0A%20%20%7D%0A%7D%20%2F%2F%20Prefab%20Fence%0A%0Aassembly%20Enclosing%20%7B%0A%20%20prop%20width%3A%20f32%20%3D%2040%0A%20%20prop%20height%3A%20f32%20%3D%2010%0A%20%20prop%20depth%3A%20f32%20%3D%2040%0A%20%20prop%20color%3A%20Rgb%20%3D%20%7B0.15%2C%200.1%2C%200.05%7D%0A%20%20%0A%20%20const%20width_half%20%3D%20%24width%20%2F%202%0A%20%20const%20depth_half%20%3D%20%24depth%20%2F%202%0A%20%20const%20PI%20%3D%203.1415926%0A%0A%20%20left%20%7B%0A%20%20%20%20-%20Position3%7Bx%3A%20-%24width_half%7D%0A%20%20%20%20-%20Rotation3%7By%3A%20%24PI%20%2F%202%7D%0A%20%20%20%20-%20Fence%7Bwidth%3A%20%24depth%2C%20height%3A%24%7D%0A%20%20%7D%0A%20%20right%20%7B%0A%20%20%20%20-%20Position3%7Bx%3A%20%24width_half%7D%0A%20%20%20%20-%20Rotation3%7By%3A%20%24PI%20%2F%202%7D%0A%20%20%20%20-%20Fence%7Bwidth%3A%20%24depth%2C%20height%3A%24%7D%0A%20%20%7D%0A%20%20back%20%7B%0A%20%20%20%20-%20Position3%7Bz%3A%20-%24depth_half%7D%0A%20%20%20%20-%20Fence%7Bwidth%3A%20%24width%2C%20height%3A%24%7D%0A%20%20%7D%0A%20%20front%20%7B%0A%20%20%20%20-%20Position3%7Bz%3A%20%24depth_half%7D%0A%20%20%20%20-%20Fence%7Bwidth%3A%20%24width%2C%20height%3A%24%7D%0A%20%20%7D%0A%7D%0A%0Apasture%20%3A-%20Enclosing%7B%0A%20%20width%3A%20100%2C%20%0A%20%20depth%3A%20100%0A%20%20height%3A%2030%0A%7D%0A%0Acamera%20%7B%0A%20%20-%20Position3%7B52%2C%2041%2C%20-82%7D%0A%20%20-%20Rotation3%7B-0.45%2C%20-0.54%7D%0A%7D%0A)
@@ -757,7 +757,7 @@ const PI = 3.1415926
 plane {
   - Position3{}
   - Rotation3{$PI / 2}
-  - Rectangle{10000, 10000}
+  Rectangle: {10000, 10000}
   - Rgb{0.9, 0.9, 0.9}
 }
 
diff --git a/docs/Manual.md b/docs/Manual.md
index c66b0f308..31f742786 100644
--- a/docs/Manual.md
+++ b/docs/Manual.md
@@ -60,8 +60,8 @@ typedef struct Velocity {
 // System names ('Move') use PascalCase. API types use snake_case_t
 void Move(ecs_iter_t *it) {
     // Functions use snake_case
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i++) {
         p[i].x += v[i].x;
@@ -83,7 +83,7 @@ int main(int argc, char *argv[]) {
     ECS_SYSTEM(world, Move, EcsOnUpdate, Position, Velocity);
 
     // Function wrapper macros use snake_case
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     // Builtin entities use PascalCase
     ecs_add(world, EcsWorld, Position);
@@ -206,7 +206,7 @@ ecs_entity_t e = ecs_lookup(world, "MyEntity");
 When an entity is part of a hierarchy, names can be used to form a path:
 
 ```c
-ecs_entity_t parent = ecs_new_id(world);
+ecs_entity_t parent = ecs_new(world);
 ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
 ecs_entity_t grandchild = ecs_new_w_pair(world, EcsChildOf, child);
 
@@ -250,7 +250,7 @@ typedef struct Position {
 
 ECS_COMPONENT(world, Position);
 
-ecs_entity_t e = ecs_new(world, Position);
+ecs_entity_t e = ecs_new_w(world, Position);
 ```
 
 From a readability perspective this code looks fine as we can easily tell what is happening here. Though if we take a closer look, we can see that a typename is used where we expect an expression, and that is not possible in plain C. So what is going on?
@@ -314,7 +314,7 @@ typedef uint64_t ecs_entity_t;
 Zero indicates an invalid entity. Applications can create new entities with the `ecs_new` operation:
 
 ```c
-ecs_entity_t e = ecs_new(world, 0);
+ecs_entity_t e = ecs_new(world);
 ```
 
 This operation guarantees to return an unused entity identifier. The first entity returned is not 1, as Flecs creates a number of builtin entities during the initialization of the world. The identifier of the first returned entity is stored in the `EcsFirstUserEntityId` constant.
@@ -330,10 +330,10 @@ When using multiple threads, the `ecs_new` operation guarantees that the returne
 When an entity is deleted, the generation count for that entity id is increased. The entity generation count enables an application to test whether an entity is still alive or whether it has been deleted, even after the id has been recycled. Consider:
 
 ```c
-ecs_entity_t e = ecs_new(world, 0);
+ecs_entity_t e = ecs_new(world);
 ecs_delete(world, e); // Increases generation
 
-e = ecs_new(world, 0); // Recycles id, but with new generation
+e = ecs_new(world); // Recycles id, but with new generation
 ```
 
 The generation is encoded in the entity id, which means that even though the base id is the same in the above example, the value returned by the second `ecs_new` is different than the first.
@@ -341,10 +341,10 @@ The generation is encoded in the entity id, which means that even though the bas
 To test whether an entity is alive, an application can use the `ecs_is_alive` call:
 
 ```c
-ecs_entity_t e1 = ecs_new(world, 0);
+ecs_entity_t e1 = ecs_new(world);
 ecs_delete(world, e1);
 
-ecs_entity_t e2 = ecs_new(world, 0);
+ecs_entity_t e2 = ecs_new(world);
 ecs_is_alive(world, e1); // false
 ecs_is_alive(world, e2); // true
 ```
@@ -400,7 +400,7 @@ A type is typically used to describe the contents (components) of an entity. A s
 
 ```c
 // Create entity with type Position
-ecs_entity_t e = ecs_new(world, Position);
+ecs_entity_t e = ecs_new_w(world, Position);
 
 // Add Velocity to the entity
 ecs_add(world, e, Velocity);
@@ -430,10 +430,10 @@ typedef vector<ecs_entity_t> ecs_type_t;
 As a result, an application is able to do this:
 
 ```c
-ecs_entity_t tag_1 = ecs_new(world, 0);
-ecs_entity_t tag_2 = ecs_new(world, 0);
+ecs_entity_t tag_1 = ecs_new(world);
+ecs_entity_t tag_2 = ecs_new(world);
 
-ecs_entity_t e = ecs_new(world, 0);
+ecs_entity_t e = ecs_new(world);
 ecs_add_id(world, e, tag_1);
 ecs_add_id(world, e, tag_2);
 ```
@@ -473,7 +473,7 @@ int main() {
     ECS_COMPONENT(world, Position);
 
     // Create a new entity with the component
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     // Remove the component from the entity
     ecs_remove(world, e, Position);
@@ -517,7 +517,7 @@ ECS_COMPONENT_DECLARE(Position);
 
 // Function that uses the global component variable
 ecs_entity_t create_entity(ecs_world_t *world) {
-    return ecs_new(world, Position);
+    return ecs_new_w(world, Position);
 }
 
 int main(int argc, char *argv[]) {
@@ -554,7 +554,7 @@ typedef struct Position {
 
 void new_w_position(ecs_world_t *t, ecs_id_t ecs_id(Position)) {
     // ecs_new uses an ecs_id_t
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 }
 
 int main() {
@@ -606,7 +606,7 @@ int main() {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     /* Component is enabled by default */
 
@@ -614,7 +614,7 @@ int main() {
     ecs_enable_component(world, e, Position, false);
 
     /* Will return false */
-    printf("%d\n", ecs_is_enabled_component(world, e, Position));
+    printf("%d\n", ecs_is_enabled(world, e, Position));
 
     /* Re-enable the component */
     ecs_enable_component(world, e, Position, true);
@@ -660,7 +660,7 @@ Just like components, the API needs a handle to a tag before it can use it, and
 ```c
 void new_w_tag(ecs_world_t *t, ecs_type_t ecs_type(Tag)) {
     // ecs_new uses an ecs_type_t
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 }
 
 int main() {
@@ -686,7 +686,7 @@ int main() {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     add_tag(world, e, Tag);
 
     ecs_fini(world);
@@ -710,7 +710,7 @@ The implementation of the observer looks similar to a system:
 
 ```c
 void AddPosition(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     for (int i = 0; i < it->count; i++) {
         p[i].x = 10;
@@ -784,7 +784,7 @@ ecs_world_t *world = ecs_init();
 ECS_IMPORT(world, Vehicles);
 
 /* The module contents can now be used */
-ecs_entity_t e = ecs_new(world, Car);
+ecs_entity_t e = ecs_new_w(world, Car);
 ```
 
 Module contents are namespaced, which means that the identifiers of the content of the module (components, tags, systems) are stored in the scope of the module. For the above example module, everything would be stored in the `vehicles` scope. To resolve the `Car` component by name, an application would have to do:
@@ -829,7 +829,7 @@ world.import<vehicles>();
 Entities in Flecs can be organized in hierarchies, which is useful when for example constructing a scene graph. To create hierarchies, applications can add `ChildOf` relationships to entities. This creates a relationship between a parent entity and a child entity that the application can later traverse. This is an example of a simple hierarchy:
 
 ```c
-ecs_entity_t parent = ecs_new(world, 0);
+ecs_entity_t parent = ecs_new(world);
 ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
 ```
 
@@ -876,14 +876,14 @@ Queries and systems can request data from parents of the entity being iterated o
 
 ```c
 // Iterate all entities with Position that have a parent that also has Position
-ecs_query_t *q = ecs_query_new(world, "Position(parent), Position");
+ecs_query_t *q = ecs_query(world, { .expr = "Position(parent), Position" });
 ```
 
 Additionally, a query can iterate the hierarchy in breadth-first order by providing the `cascade` modifier:
 
 ```c
 // Iterate all entities with Position that have a parent that also has Position
-ecs_query_t *q = ecs_query_new(world, "Position(parent|cascade), Position");
+ecs_query_t *q = ecs_query(world, { .expr = "Position(cascade), Position" });
 ```
 
 This does two things. First, it will iterate over all entities that have Position and that _optionally_ have a parent that has `Position`. By making the parent component optional, it is ensured that if an application is iterating a tree of entities, the root is also included. Secondly, the query iterates over the children in breadth-first order. This is particularly useful when writing transform systems, as they require parent entities to be transformed before child entities.
@@ -891,7 +891,7 @@ This does two things. First, it will iterate over all entities that have Positio
 The above query does not match root entities, as they do not have a parent with `Position`. To also match root entities, add `?` to make the term optional:
 
 ```c
-ecs_query_t *q = ecs_query_new(world, "?Position(parent|cascade), Position");
+ecs_query_t *q = ecs_query(world, { .expr = "?Position(cascade), Position" });
 ```
 
 See the [query manual](Queries.md) section for more details.
@@ -937,13 +937,13 @@ Note that the path separator is provided twice, once for the prefix and once for
 Applications can set a default scope with the `ecs_set_scope` function, so that all operations are evaluated relative to a scope. The scope is set on a stage, which makes it thread safe when executed from within a flecs worker thread. This example shows how to set the scope:
 
 ```c
-ecs_entity_t parent = ecs_new(world, 0);
+ecs_entity_t parent = ecs_new(world);
 
 // Set the current scope to the parent
 ecs_entity_t prev_scope = ecs_set_scope(world, parent);
 
 // This entity is created as child of parent
-ecs_entity_t child = ecs_new(world, 0);
+ecs_entity_t child = ecs_new(world);
 
 // Look for "child" relative to parent
 ecs_entity_t e = ecs_lookup(world, "child");
@@ -990,7 +990,7 @@ Inheritance is the ability to share components between entities by _inheriting_
 
 ```c
 // Create a base entity
-ecs_entity_t base = ecs_new(world, 0);
+ecs_entity_t base = ecs_new(world);
 ecs_set(world, base, Position, {10, 20});
 
 // Derive from base
@@ -1017,7 +1017,7 @@ ECS_ENTITY(world, e, (IsA, base));
 `IsA` relationships can be nested:
 
 ```c
-ecs_entity_t base = ecs_new(world, 0);
+ecs_entity_t base = ecs_new(world);
 ecs_set(world, base, Position, {10, 20});
 
 ecs_entity_t derived = ecs_new_w_pair(world, EcsIsA, base);
@@ -1035,7 +1035,7 @@ Derived entities can override components from their base by adding the component
 
 ```c
 // Shortcut for creating a base entity and setting Position
-ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
 
 // Derive from the base
 ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
@@ -1067,7 +1067,7 @@ Overrides work with nested `IsA` relationships:
 
 ```c
 // Shortcut for creating a base entity and setting Position
-ecs_entity_t base = ecs_new(world, 0);
+ecs_entity_t base = ecs_new(world);
 ecs_set(world, base, Position, {10, 20});
 ecs_set(world, base, Velocity, {1, 1});
 
@@ -1086,7 +1086,7 @@ In some scenarios it is desirable that an entity is initialized with a specific
 
 ```c
 // Create a base. Simply deriving the base will share the component, but not override it.
-ecs_entity_t Base = ecs_set(world, 0, Position, {10, 20});
+ecs_entity_t Base = ecs_insert(world, ecs_value(Position, {10, 20}));
 
 // Mark as OVERRIDE. This ensures that when base is derived from, Position is overridden
 ecs_add_id(world, world, Base, ECS_OVERRIDE | ecs_id(Position));
@@ -1110,7 +1110,7 @@ ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, Base);
 If a base entity has children, derived entities of that base entity will, when the `IsA` relationship is added, acquire the same set of children. Take this example:
 
 ```c
-ecs_entity_t parent = ecs_new(world, 0);
+ecs_entity_t parent = ecs_new(world);
 ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent);
 ecs_entity_t child_2 = ecs_new_w_pair(world, EcsChildOf, parent);
 
@@ -1121,7 +1121,7 @@ ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, parent);
 The children that are copied to the entity will have exactly the same set of components as the children of the base. For example, if the base child has components `Position, Velocity`, the derived child will also have `Position, Velocity`. Furthermore, the values of the base child components will be copied to the entity child:
 
 ```c
-ecs_entity_t parent = ecs_new(world, 0);
+ecs_entity_t parent = ecs_new(world);
 ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
 ecs_set_name(world, child, "Child"); // Give child a name, so we can look it up
 ecs_set(world, child, Position, {10, 20});
@@ -1139,10 +1139,10 @@ ecs_get(world, child, Position) != ecs_get(world, e_child, Position); // 1
 Since the children of the derived entity have the exact same components as the base children, their components are not shared. Component sharing between children is possible however, as `IsA` relationships are also copied over to the child of the derived entity:
 
 ```c
-ecs_entity_t parent = ecs_new(world, 0);
+ecs_entity_t parent = ecs_new(world);
 
 // Create child base from which we will share components
-ecs_entity_t child_base = ecs_new(world, 0);
+ecs_entity_t child_base = ecs_new(world);
 ecs_set(world, child_base, Position, {10, 20});
 ecs_set_name(world, child, "Child");
 
@@ -1202,7 +1202,7 @@ Applications can defer entity with the `ecs_defer_begin` and `ecs_defer_end` fun
 
 ```c
 ecs_defer_begin(world);
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Position);
     ecs_set(world, e, Velocity, {1, 1});
 ecs_defer_end(world);
diff --git a/docs/Queries.md b/docs/Queries.md
index a614a5103..d92884bc3 100644
--- a/docs/Queries.md
+++ b/docs/Queries.md
@@ -55,20 +55,20 @@ https://github.com/SanderMertens/flecs/tree/master/examples
 ## Types
 Flecs has different query types, which are optimized for different kinds of use cases. This section provides a brief overview of each kind:
 
- ### Filters
- Filters are cheap to create, low overhead, reasonably efficient to iterate. They are good for ad-hoc queries with runtime-defined conditions. An example:
+ ### Querys
+ Querys are cheap to create, low overhead, reasonably efficient to iterate. They are good for ad-hoc queries with runtime-defined conditions. An example:
  
  ```c
- ecs_filter_t *f = ecs_filter(world, {
+ ecs_query_t *f = ecs_query(world, {
     .terms = {
         { ecs_id(Position) }, { ecs_id(Velocity) }
     }
 });
 
-ecs_iter_t it = ecs_filter_iter(world, f);
-while (ecs_filter_next(&it)) {
-    Position *p = ecs_field(&it, Position, 1);
-    Velocity *v = ecs_field(&it, Velocity, 2);
+ecs_iter_t it = ecs_query_iter(world, f);
+while (ecs_query_next(&it)) {
+    Position *p = ecs_field(&it, Position, 0);
+    Velocity *v = ecs_field(&it, Velocity, 1);
 
     for (int i = 0; i < it.count; i ++) {
         p[i].x += v[i].x;
@@ -77,8 +77,8 @@ while (ecs_filter_next(&it)) {
 }
 ```
 ```cpp
-flecs::filter<Position, Velocity> f = 
-    world.filter<Position, Velocity>();
+flecs::query<Position, Velocity> f = 
+    world.query<Position, Velocity>();
 
 f.each([](Position& p, Velocity& v) {
     p.x += v.x;
@@ -91,15 +91,15 @@ Cached queries cache the output of a filter. They are more expensive to create a
 
 ```c
 ecs_query_t *q = ecs_query(world, {
-    .filter.terms = {
+    .terms = {
         { ecs_id(Position) }, { ecs_id(Velocity) }
     }
 });
 
 ecs_iter_t it = ecs_query_iter(world, q);
 while (ecs_query_next(&it)) {
-    Position *p = ecs_field(&it, Position, 1);
-    Velocity *v = ecs_field(&it, Velocity, 2);
+    Position *p = ecs_field(&it, Position, 0);
+    Velocity *v = ecs_field(&it, Velocity, 1);
 
     for (int i = 0; i < it.count; i ++) {
         p[i].x += v[i].x;
@@ -121,16 +121,16 @@ q.each([](Position& p, Velocity& v) {
 Rules are a constraint-based query engine capable of traversing graphs. They are more expensive to create than filters, have low overhead, and their iteration performance depends on query complexity. An example:
 
 ```c
-ecs_rule_t *r = ecs_rule(world, {
+ecs_query_impl_t *r = ecs_query(world, {
     .terms = {
         { ecs_id(Position) }, { ecs_id(Velocity) }
     }
 });
 
-ecs_iter_t it = ecs_rule_iter(world, r);
-while (ecs_rule_next(&it)) {
-    Position *p = ecs_field(&it, Position, 1);
-    Velocity *v = ecs_field(&it, Velocity, 2);
+ecs_iter_t it = ecs_query_iter(world, r);
+while (ecs_query_next(&it)) {
+    Position *p = ecs_field(&it, Position, 0);
+    Velocity *v = ecs_field(&it, Velocity, 1);
 
     for (int i = 0; i < it.count; i ++) {
         p[i].x += v[i].x;
@@ -139,8 +139,8 @@ while (ecs_rule_next(&it)) {
 }
 ```
 ```cpp
-flecs::rule<Position, Velocity> r = 
-    world.rule<Position, Velocity>();
+flecs::query<Position, Velocity> r = 
+    world.query<Position, Velocity>();
 
 r.each([](Position& p, Velocity& v) {
     p.x += v.x;
@@ -154,10 +154,10 @@ For more information on how each implementation performs, see [Performance](#per
 This section explains how to create queries in the different language bindings and the flecs query DSL.
 
 ### Query Descriptors (C)
-Query descriptors are the C API for creating queries. The API uses a type called `ecs_filter_desc_t`, to describe the structure of a query. This type is used to create all query kinds (`ecs_filter_t`, `ecs_query_t`, `ecs_rule_t`). An example:
+Query descriptors are the C API for creating queries. The API uses a type called `ecs_query_desc_t`, to describe the structure of a query. This type is used to create all query kinds (`ecs_query_t`, `ecs_query_cache_t`, `ecs_query_impl_t`). An example:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }, { ecs_id(Velocity) },
   }
@@ -167,7 +167,7 @@ ecs_filter_t *f = ecs_filter(world, {
 The example shows the short notation, which looks like this when expanded:
 
 ```c
-ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+ecs_query_t *f = ecs_query_init(world, &(ecs_query_desc_t){
   .terms = {
     { ecs_id(Position) }, { ecs_id(Velocity) },
   }
@@ -177,28 +177,28 @@ ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
 Query descriptors can also be used by the C++ API. However because C++ does not support taking the address of a temporary, and not all language revisions support designated initializers, query descriptors in C++ should be used like this:
 
 ```c
-ecs_filter_desc_t desc = {}; // Zero-initialize the struct
+ecs_query_desc_t desc = {}; // Zero-initialize the struct
 desc.terms[0].id = ecs_id(Position);
 desc.terms[1].id = ecs_id(Velocity);
-ecs_filter_t *f = ecs_filter_init(world, &desc);
+ecs_query_t *f = ecs_query_init(world, &desc);
 ```
 
 The following table provides an overview of the query types with the init/fini functions:
 
 | Kind   | Type           | Init              | Fini              | Descriptor type     |
 |--------|----------------|-------------------|-------------------|---------------------|
-| Filter | `ecs_filter_t` | `ecs_filter_init` | `ecs_filter_fini` | `ecs_filter_desc_t` |
-| Query  | `ecs_query_t`  | `ecs_query_init`  | `ecs_query_fini`  | `ecs_query_desc_t`  |
-| Rule   | `ecs_rule_t`   | `ecs_rule_init`   | `ecs_rule_fini`   | `ecs_filter_desc_t` |
+| Query | `ecs_query_t` | `ecs_query_init` | `ecs_query_fini` | `ecs_query_desc_t` |
+| Query  | `ecs_query_cache_t`  | `ecs_query_cache_init`  | `ecs_query_fini`  | `ecs_query_desc_t`  |
+| Rule   | `ecs_query_impl_t`   | `ecs_query_init`   | `ecs_query_fini`   | `ecs_query_desc_t` |
 
-Additionally the descriptor types for systems (`ecs_system_desc_t`) and observers (`ecs_observer_desc_t`) embed the `ecs_filter_desc_t` descriptor type.
+Additionally the descriptor types for systems (`ecs_system_desc_t`) and observers (`ecs_observer_desc_t`) embed the `ecs_query_desc_t` descriptor type.
 
 ### Query Builder (C++)
 Query builders are the C++ API for creating queries. The builder API is built on top of the descriptor API, and adds a layer of convenience and type safety that matches modern idiomatic C++. The builder API is implemented for all query kinds (filters, cached queries, rules). An example of a simple query:
 
 ```cpp
-flecs::filter<Position, const Velocity> f = 
-    world.filter<Position, const Velocity>();
+flecs::query<Position, const Velocity> f = 
+    world.query<Position, const Velocity>();
 ```
 
 Queries created with template arguments provide a type safe way to iterate components:
@@ -213,7 +213,7 @@ f.each([](Position& p, const Velocity& v) {
 The builder API allows for incrementally constructing queries:
 
 ```cpp
-flecs::filter<Position> q = world.filter_builder<Position>();
+flecs::query<Position> q = world.query_builder<Position>();
 f.term<const Velocity>();
 
 if (add_npc) {
@@ -227,9 +227,9 @@ The following table provides an overview of the query types with the factory fun
 
 | Kind   | Type            | Factory                 |
 |--------|-----------------|-------------------------|
-| Filter | `flecs::filter` | `world::filter_builder` |
+| Query | `flecs::query` | `world::filter_builder` |
 | Query  | `flecs::query`  | `world::query_builder`  |
-| Rule   | `flecs::rule`   | `world::rule_builder`   |
+| Rule   | `flecs::query`   | `world::rule_builder`   |
 
 Additional helper methods have been added to the C++ API to replace combinations of the `term` method with other methods. They are the following:
 
@@ -256,41 +256,39 @@ ECS_SYSTEM(world, Move, EcsOnUpdate, Position, [in] Velocity);
 Queries can be created from expressions with both the descriptor and builder APIs:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .expr = "Position, [in] Velocity"
 });
 ```
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   .expr("Position, [in] Velocity")
   .build();
 ```
 
-The query DSL requires the `FLECS_PARSER` addon to be included in a build.
-
 ## Iteration
 This section describes the different ways queries can be iterated. The code examples use filters, but also apply to cached queries and rules.
 
 ### Iterators (C)
-In the C API an iterator object of type `ecs_iter_t` can be created for each of the query kinds, using the `ecs_filter_iter`, `ecs_query_iter` and `ecs_rule_iter` functions. This iterator can then be iterated with the respective `next` functions: `ecs_filter_next`, `ecs_query_next` and `ecs_rule_next`.
+In the C API an iterator object of type `ecs_iter_t` can be created for each of the query kinds, using the `ecs_query_iter`, `ecs_query_iter` and `ecs_query_iter` functions. This iterator can then be iterated with the respective `next` functions: `ecs_query_next`, `ecs_query_next` and `ecs_query_next`.
 
 An iterator can also be iterated with the `ecs_iter_next` function which is slightly slower, but does not require knowledge about the source the iterator was created for.
 
 An example:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }, { ecs_id(Velocity) },
   }
 });
 
-ecs_iter_t it = ecs_filter_iter(world, f);
+ecs_iter_t it = ecs_query_iter(world, f);
 
 // Outer loop: matching tables
-while (ecs_filter_next(&it)) {
-  Position *p = ecs_field(&it, Position, 1); // 1st term
-  Velocity *v = ecs_field(&it, Velocity, 2); // 2nd term
+while (ecs_query_next(&it)) {
+  Position *p = ecs_field(&it, Position, 0); // 1st term
+  Velocity *v = ecs_field(&it, Velocity, 1); // 2nd term
 
   // Inner loop: entities in table
   for (int i = 0; i < it.count; i ++) {
@@ -305,10 +303,10 @@ Iteration is split up into two loops: the outer loop which iterates tables, and
 The indices provided to the `ecs_field` function must correspond with the order in which terms have been specified in the query. This index starts counting from `1`, with index `0` reserved for the array containing entity ids.
 
 ### Each (C++)
-The `each` function is the default and often fastest approach for iterating a query in C++. `each` can be called directly on a `flecs::filter`, `flecs::query` and `flecs::rule`. An example:
+The `each` function is the default and often fastest approach for iterating a query in C++. `each` can be called directly on a `flecs::query`, `flecs::query` and `flecs::query`. An example:
 
 ```cpp
-auto f = world.filter<Position, const Velocity>();
+auto f = world.query<Position, const Velocity>();
 
 f.each([](Position& p, const Velocity& v) {
     p.x += v.x;
@@ -319,7 +317,7 @@ f.each([](Position& p, const Velocity& v) {
 A `flecs::entity` can be added as first argument:
 
 ```cpp
-auto f = world.filter<Position>();
+auto f = world.query<Position>();
 
 f.each([](flecs::entity e, Position& p) {
     std::cout << e.name() << ": " 
@@ -331,14 +329,14 @@ f.each([](flecs::entity e, Position& p) {
 A `flecs::iter` and `size_t` argument can be added as first arguments. This variant of `each` provides access to the `flecs::iter` object, which contains more information about the object being iterated. The `size_t` argument contains the index of the entity being iterated, which can be used to obtain entity-specific data from the `flecs::iter` object. An example:
 
 ```cpp
-auto f = world.filter_builder<Position>()
+auto f = world.query_builder<Position>()
   .term(Likes, flecs::Wildcard)
   .build();
 
 f.each([](flecs::iter& it, size_t index, Position& p) {
     flecs::entity e = it.entity(index);
     std::cout << e.name() << ": " 
-              << it.id(2).str() // prints pair
+              << it.id(1).str() // prints pair
               << std::endl;
 });
 ```
@@ -348,7 +346,7 @@ When a query contains a template argument that is an empty type (a struct withou
 ```cpp
 struct Tag { };
 
-auto f = world.filter<Tag>();
+auto f = world.query<Tag>();
 
 f.each([](flecs::entity e, Tag) {
     std::cout << e.name() << std::endl;
@@ -360,7 +358,7 @@ Alternatively an empty type can be specified outside of the query type, which re
 ```cpp
 struct Tag { };
 
-auto f = world.filter_builder()
+auto f = world.query_builder()
   .term<Tag>()
   .build();
 
@@ -375,7 +373,7 @@ The `iter` function has an outer and inner loop (similar to C iterators) which p
 An example:
 
 ```cpp
-auto f = world.filter<Position, const Velocity>();
+auto f = world.query<Position, const Velocity>();
 
 f.iter([](flecs::iter& it, Position *p, Velocity *v) {
     // Inner loop
@@ -403,11 +401,11 @@ f.iter([](flecs::iter& it, Position *p, Velocity *v) {
 The component arguments may be omitted, and can be obtained from the iterator object:
 
 ```cpp
-auto f = world.filter<Position, const Velocity>();
+auto f = world.query<Position, const Velocity>();
 
 f.iter([](flecs::iter& it) {
-    auto p = it.field<Position>(1);
-    auto v = it.field<const Velocity>(2);
+    auto p = it.field<Position>(0);
+    auto v = it.field<const Velocity>(1);
 
     for (auto i : it) {
         p[i].x += v[i].x;
@@ -419,11 +417,11 @@ f.iter([](flecs::iter& it) {
 This can be combined with an untyped variant of the `field` method to access component data without having to know component types at compile time. This can be useful for generic code, like serializers:
 
 ```cpp
-auto f = world.filter<Position, const Velocity>();
+auto f = world.query<Position, const Velocity>();
 
 f.iter([](flecs::iter& it) {
-    void *ptr = it.field(1);
-    flecs::id type_id = it.id(1);
+    void *ptr = it.field(0);
+    flecs::id type_id = it.id(0);
 
     // ...
 });
@@ -435,7 +433,7 @@ Entities can be moved between tables when components are added or removed. This
 When an application attempts to add or remove components to an entity in a table being iterated over, this can throw a runtime assert. An example:
 
 ```cpp
-auto f = world.filter<Position>();
+auto f = world.query<Position>();
 
 f.each([](flecs::entity e, Position&) {
     e.add<Velocity>(); // throws locked table assert
@@ -445,7 +443,7 @@ f.each([](flecs::entity e, Position&) {
 This can be addressed by deferring operations while the query is being iterated:
 
 ```cpp
-auto f = world.filter<Position>();
+auto f = world.query<Position>();
 
 world.defer([&]{
     f.each([](flecs::entity e, Position&) {
@@ -457,7 +455,7 @@ world.defer([&]{
 An application can also use the `defer_begin` and `defer_end` functions which achieve the same goal:
 
 ```cpp
-auto f = world.filter<Position>();
+auto f = world.query<Position>();
 
 world.defer_begin();
 
@@ -505,7 +503,7 @@ To query for a component in C, the `id` field of a term can be set:
 ECS_COMPONENT(world, Position);
 ECS_COMPONENT(world, Velocity);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { .id = ecs_id(Position) }, 
     { .id = ecs_id(Velocity) }
@@ -516,7 +514,7 @@ ecs_filter_t *f = ecs_filter(world, {
 The `id` field is guaranteed to be the first member of a term, which allows the previous code to be rewritten in this shorter form:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }, 
     { ecs_id(Velocity) }
@@ -528,9 +526,9 @@ The `ecs_id` macro converts the component typename into the variable name that h
 
 ```c
 ECS_TAG(world, Npc);
-ecs_entity_t Platoon_01 = ecs_new_id(world);
+ecs_entity_t Platoon_01 = ecs_new(world);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { Npc }, 
     { Platoon_01 }
@@ -544,7 +542,7 @@ Components can also be queried for by name by setting the `.first.name` member i
 ECS_COMPONENT(world, Position);
 ECS_COMPONENT(world, Velocity);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { .first.name = "Position" }, 
     { .first.name = "Velocity" }
@@ -556,8 +554,8 @@ ecs_filter_t *f = ecs_filter(world, {
 An easy way to query for components in C++ is to pass them as template arguments to the query factory function:
 
 ```cpp
-flecs::filter<Position, const Velocity> f = 
-    world.filter<Position, const Velocity>();
+flecs::query<Position, const Velocity> f = 
+    world.query<Position, const Velocity>();
 ```
 
 This changes the returned query type, which determines the type of the function used to iterate the query:
@@ -569,8 +567,8 @@ f.each([](Position& p, const Velocity& v) { });
 The builder API makes it possible to add components to a query without modifying the query type:
 
 ```cpp
-flecs::filter<Position> f = 
-  world.filter_builder<Position>()
+flecs::query<Position> f = 
+  world.query_builder<Position>()
     .term<const Velocity>()
     .build();
 ```
@@ -583,7 +581,7 @@ The builder API makes it possible to query for regular entity ids created at run
 flecs::entity Npc = world.entity();
 flecs::entity Platoon_01 = world.entity();
 
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   .term(Npc)
   .term(Platoon_01)
   .build();
@@ -598,7 +596,7 @@ world.component<Position>();
 // Create entity with name so we can look it up
 flecs::entity Npc = world.entity("Npc");
 
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   .term("Position")
   .term("Npc")
   .build();
@@ -656,11 +654,11 @@ The `Wildcard` wildcard returns an individual result for anything that it matche
 ECS_COMPONENT(world, Position);
 ECS_COMPONENT(world, Velocity);
 
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 ecs_add(world, e, Position);
 ecs_add(world, e, Velocity);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { EcsWildcard }
   }
@@ -671,7 +669,7 @@ flecs::entity e = world.entity()
     .add<Position>()
     .add<Velocity>();
 
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term(flecs::Wildcard)
     .build();
 ```
@@ -682,11 +680,11 @@ The `Any` wildcard returns a single result for the first component that it match
 ECS_COMPONENT(world, Position);
 ECS_COMPONENT(world, Velocity);
 
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 ecs_add(world, e, Position);
 ecs_add(world, e, Velocity);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { EcsAny }
   }
@@ -697,7 +695,7 @@ flecs::entity e = world.entity()
     .add<Position>()
     .add<Velocity>();
 
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term(flecs::Any)
     .build();
 ```
@@ -719,10 +717,10 @@ The following sections describe how to create queries for pairs in the different
 To query for a pair in C, the `id` field of a term can be set to a pair using the `ecs_pair` macro:
 
 ```c
-ecs_entity_t Likes = ecs_new_id(world);
-ecs_entity_t Bob = ecs_new_id(world);
+ecs_entity_t Likes = ecs_new(world);
+ecs_entity_t Bob = ecs_new(world);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { .id = ecs_pair(Likes, Bob) }
   }
@@ -732,10 +730,10 @@ ecs_filter_t *f = ecs_filter(world, {
 The `id` field is guaranteed to be the first member of a term, which allows the previous code to be rewritten in this shorter form:
 
 ```c
-ecs_entity_t Likes = ecs_new_id(world);
-ecs_entity_t Bob = ecs_new_id(world);
+ecs_entity_t Likes = ecs_new(world);
+ecs_entity_t Bob = ecs_new(world);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_pair(Likes, Bob) }
   }
@@ -746,9 +744,9 @@ When an element of the pair is a component type, use the `ecs_id` macro to obtai
 
 ```c
 ECS_COMPONENT(world, Eats);
-ecs_entity_t Apples = ecs_new_id(world);
+ecs_entity_t Apples = ecs_new(world);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_pair(ecs_id(Eats), Apples) }
   }
@@ -758,13 +756,13 @@ ecs_filter_t *f = ecs_filter(world, {
 The `ecs_isa`, `ecs_childof` and `ecs_dependson` convenience macros can be used to create pairs for builtin relationships. The two queries in the next example are equivalent:
 
 ```c
-ecs_filter_t *f_1 = ecs_filter(world, {
+ecs_query_t *f_1 = ecs_query(world, {
   .terms = {
     { ecs_pair(EcsChildOf, parent) }
   }
 });
 
-ecs_filter_t *f_2 = ecs_filter(world, {
+ecs_query_t *f_2 = ecs_query(world, {
   .terms = {
     { ecs_childof(parent) }
   }
@@ -774,7 +772,7 @@ ecs_filter_t *f_2 = ecs_filter(world, {
 Pair queries can be created by setting their individual elements in the `first.id` and `second.id` members of a term:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { .first.id = Eats, .second.id = Apples }
   }
@@ -788,13 +786,13 @@ Alternatively, one or both elements of a pair can be resolved by name. The two q
 ECS_TAG(world, Eats);
 ECS_TAG(world, Apples);
 
-ecs_filter_t *f_1 = ecs_filter(world, {
+ecs_query_t *f_1 = ecs_query(world, {
   .terms = {
     { .first.name = "Eats", .second.id = Apples }
   }
 });
 
-ecs_filter_t *f_2 = ecs_filter(world, {
+ecs_query_t *f_2 = ecs_query(world, {
   .terms = {
     { .first.name = "Eats", .second.name = "Apples" }
   }
@@ -804,15 +802,15 @@ ecs_filter_t *f_2 = ecs_filter(world, {
 When a query pair contains a wildcard, the `ecs_field_id` function can be used to determine the id of the pair element that matched the query:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_pair(Likes, EcsWildcard) }
   }
 });
 
-ecs_iter_t it = ecs_filter_iter(world, f);
-while (ecs_filter_next(&it)) {
-    ecs_id_t id = ecs_field_id(&it, 1);
+ecs_iter_t it = ecs_query_iter(world, f);
+while (ecs_query_next(&it)) {
+    ecs_id_t id = ecs_field_id(&it, 0);
     ecs_entity_t second = ecs_pair_second(world, id);
 
     for (int i = 0; i < it.count; i ++) {
@@ -832,8 +830,8 @@ struct Apples { };
 // Alias to save typing
 using EatsApples = flecs::pair<Eats, Apples>;
 
-flecs::filter<EatsApples> f = 
-    world.filter<EatsApples>();
+flecs::query<EatsApples> f = 
+    world.query<EatsApples>();
 
 // Do not use reference argument for pair
 f.each([](EatsApples v) {
@@ -845,8 +843,8 @@ f.each([](EatsApples v) {
 When using the `iter` function to iterate a query with a pair template, the argument type assumes the type of the pair. This is required as the component array being passed directly to the `iter` function. An example:
 
 ```cpp
-flecs::filter<EatsApples> f = 
-    world.filter<EatsApples>();
+flecs::query<EatsApples> f = 
+    world.query<EatsApples>();
 
 f.iter([](flecs::iter& it, Eats *v) {
     for (auto i : it) {
@@ -864,15 +862,15 @@ struct Apples { };
 flecs::entity eats = world.component<Eats>();
 flecs::entity apples = world.component<Apples>();
 
-flecs::filter<> f_1 = world.filter_builder()
+flecs::query<> f_1 = world.query_builder()
     .term<Eats, Apples>()
     .build();
 
-flecs::filter<> f_2 = world.filter_builder()
+flecs::query<> f_2 = world.query_builder()
     .term<Eats>(apples)
     .build();
 
-flecs::filter<> f_3 = world.filter_builder()
+flecs::query<> f_3 = world.query_builder()
     .term(eats, apples)
     .build();
 ```
@@ -880,7 +878,7 @@ flecs::filter<> f_3 = world.filter_builder()
 Individual elements of a pair can be specified with the `first` and `second` methods. The methods apply to the last added term. An example:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term().first<Eats>().second(apples)
     .build();
 ```
@@ -888,7 +886,7 @@ flecs::filter<> f = world.filter_builder()
 Individual elements of a pair can be resolved by name by using the `first` and `second` methods:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term().first("Eats").second("Apples")
     .build();
 ```
@@ -896,12 +894,12 @@ flecs::filter<> f = world.filter_builder()
 When a query pair contains a wildcard, the `flecs::iter::pair` method can be used to determine the id of the pair element that matched the query:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Eats>(flecs::Wildcard)
     .build();
 
 f.each([](flecs::iter& it, size_t index) {
-    flecs::entity second = it.pair(1).second();
+    flecs::entity second = it.pair(0).second();
     flecs::entity e = it.entity(index);
     
     std::cout << "entity " << e.name() 
@@ -969,7 +967,7 @@ The following sections show how to use access modifiers in the different languag
 Access modifiers can be set using the `inout` member:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }, 
     { ecs_id(Velocity), .inout = EcsIn }
@@ -981,7 +979,7 @@ ecs_filter_t *f = ecs_filter(world, {
 Access modifiers can be set using the `inout` method:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>()
     .term<Velocity>().inout(flecs::In)
     .build();
@@ -991,14 +989,14 @@ When the `const` modifier is added to a type, the `flecs::In` modifier is automa
 
 ```c
 // Velocity term will be added with flecs::In modifier
-flecs::filter<Position, const Velocity> f = 
-    world.filter<Position, const Velocity>();
+flecs::query<Position, const Velocity> f = 
+    world.query<Position, const Velocity>();
 ```
 
 This also applies to types added with `term`:
 
 ```c
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>()
     .term<const Velocity>() // uses flecs::In modifier
     .build();
@@ -1007,23 +1005,23 @@ flecs::filter<> f = world.filter_builder()
 When a component is added by the `term` method and retrieved from a `flecs::iter` object during iteration, it must meet the constraints of the access modifiers. If the constraints are not met, a runtime assert may be thrown:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>()
     .term<Velocity>().inout(flecs::In)
     .build();
 
 f.iter([](flecs::iter& it) {
-    auto p = it.field<Position>(1);       // OK
-    auto p = it.field<const Position>(1); // OK
-    auto v = it.field<const Velocity>(2); // OK
-    auto v = it.field<Velocity>(2);       // Throws assert
+    auto p = it.field<Position>(0);       // OK
+    auto p = it.field<const Position>(0); // OK
+    auto v = it.field<const Velocity>(1); // OK
+    auto v = it.field<Velocity>(1);       // Throws assert
 });
 ```
 
 The builder API has `in()`, `inout()`, `out()` and `inout_none()` convenience methods:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>().inout()
     .term<Velocity>().in()
     .build();
@@ -1063,14 +1061,14 @@ The `And` operator is used when no other operators are specified. The following
 When no operator is specified, `And` is assumed. The following two queries are equivalent:
 
 ```c
-ecs_filter_t *f_1 = ecs_filter(world, {
+ecs_query_t *f_1 = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }, 
     { ecs_id(Velocity) }
   }
 });
 
-ecs_filter_t *f_2 = ecs_filter(world, {
+ecs_query_t *f_2 = ecs_query(world, {
   .terms = {
     { ecs_id(Position), .oper = EcsAnd }, 
     { ecs_id(Velocity), .oper = EcsAnd }
@@ -1082,14 +1080,14 @@ ecs_filter_t *f_2 = ecs_filter(world, {
 When no operator is specified, `And` is assumed. The following two queries are equivalent:
 
 ```cpp
-flecs::filter<Position, Velocity> f_1 = world.filter<Position, Velocity>();
+flecs::query<Position, Velocity> f_1 = world.query<Position, Velocity>();
 
-flecs::filter<> f_2 = world.filter_builder()
+flecs::query<> f_2 = world.query_builder()
     .term<Position>()
     .term<Velocity>()
     .build();
 
-flecs::filter<> f_2 = world.filter_builder()
+flecs::query<> f_2 = world.query_builder()
     .term<Position>().oper(flecs::And)
     .term<Velocity>().oper(flecs::And)
     .build();
@@ -1098,7 +1096,7 @@ flecs::filter<> f_2 = world.filter_builder()
 The builder API has a `and_` convenience method:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>().and_(); // note escaping, 'and' is a C++ keyword
     .term<Velocity>().and_();
     .build();
@@ -1131,7 +1129,7 @@ To create a query with `Or` terms, set `oper` to `EcsOr`:
 
 ```c
 // Position, Velocity || Speed, Mass
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }, 
     { ecs_id(Velocity), .oper = EcsOr },
@@ -1140,12 +1138,12 @@ ecs_filter_t *f = ecs_filter(world, {
   }
 });
 
-ecs_iter_t it = ecs_filter_iter(world, f);
-while (ecs_filter_next(&it)) {
-  Position *p = ecs_field(&it, Position, 1);
-  Mass *m = ecs_field(&it, Mass, 3); // not 4, because of the Or expression
+ecs_iter_t it = ecs_query_iter(world, f);
+while (ecs_query_next(&it)) {
+  Position *p = ecs_field(&it, Position, 0);
+  Mass *m = ecs_field(&it, Mass, 2); // not 4, because of the Or expression
 
-  ecs_id_t vs_id = ecs_field_id(&it, 2);
+  ecs_id_t vs_id = ecs_field_id(&it, 1);
   if (vs_id == ecs_id(Velocity)) {
     // We can only use ecs_field if the field type is the same for all results,
     // but we can get the table column directly.
@@ -1163,7 +1161,7 @@ To create a query with `Or` terms, use the `oper` method with `flecs::Or`:
 
 ```cpp
 // Position, Velocity || Speed, Mass
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>()
     .term<Velocity>().oper(flecs::Or)
     .term<Speed>()
@@ -1171,10 +1169,10 @@ flecs::filter<> f = world.filter_builder()
     .build();
 
 f.iter([&](flecs::iter& it) {
-  auto p = it.field<Position>(1);
-  auto v = it.field<Mass>(3); // not 4, because of the Or expression
+  auto p = it.field<Position>(0);
+  auto v = it.field<Mass>(2); // not 4, because of the Or expression
   
-  flecs::id vs_id = it.id(2);
+  flecs::id vs_id = it.id(1);
   if (vs_id == world.id<Velocity>()) {
     // We can only use ecs_field if the field type is the same for all results,
     // but we can use range() to get the table column directly.
@@ -1190,7 +1188,7 @@ f.iter([&](flecs::iter& it) {
 The builder API has a `or_` convenience method:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>() 
     .term<Velocity>().or_(); // note escaping, 'or' is a C++ keyword
     .term<Speed>()
@@ -1218,7 +1216,7 @@ The following sections show how to use the `Not` operator in the different langu
 To create a query with `Not` terms, set `oper` to `EcsNot`:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }, 
     { ecs_id(Velocity), .oper = EcsNot }
@@ -1230,7 +1228,7 @@ ecs_filter_t *f = ecs_filter(world, {
 To create a query with `Not` terms, use the `oper` method with `flecs::Not`:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>()
     .term<Velocity>().oper(flecs::Not)
     .build();
@@ -1239,7 +1237,7 @@ flecs::filter<> f = world.filter_builder()
 The builder API has a `not_` convenience method:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>() 
     .term<Velocity>().not_(); // note escaping, 'not' is a C++ keyword
     .build();
@@ -1273,18 +1271,18 @@ The following sections show how to use the `Optional` operator in the different
 To create a query with `Optional` terms, set `oper` to `EcsOptional`:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }, 
     { ecs_id(Velocity), .oper = EcsOptional }
   }
 });
 
-ecs_iter_t it = ecs_filter_iter(world, f);
-while (ecs_filter_next(&it)) {
-  Position *p = ecs_field(&it, Position, 1);
-  if (ecs_field_is_set(&it, 2)) {
-    Velocity *v = ecs_field(&it, Velocity, 2);
+ecs_iter_t it = ecs_query_iter(world, f);
+while (ecs_query_next(&it)) {
+  Position *p = ecs_field(&it, Position, 0);
+  if (ecs_field_is_set(&it, 1)) {
+    Velocity *v = ecs_field(&it, Velocity, 1);
     // iterate as usual
   } else {
     // iterate as usual
@@ -1296,16 +1294,16 @@ while (ecs_filter_next(&it)) {
 To create a query with `Optional` terms, call the `oper` method with `flecs::Optional`:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>()
     .term<Velocity>().oper(flecs::Optional)
     .build();
 
 f.iter([&](flecs::iter& it) {
-  auto p = it.field<Position>(1);
+  auto p = it.field<Position>(0);
   
-  if (it.is_set(2)) {
-    auto v = it.field<Velocity>(2);
+  if (it.is_set(1)) {
+    auto v = it.field<Velocity>(1);
     // iterate as usual
   } else if (vs_id == world.id<Speed>()) {
     // iterate as usual
@@ -1316,7 +1314,7 @@ f.iter([&](flecs::iter& it) {
 The builder API has an `optional` convenience method:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term<Position>() 
     .term<Velocity>().optional();
     .build();
@@ -1362,7 +1360,7 @@ Terms with equality operators return no data.
 
 #### Query Descriptor (C)
 ```c
-ecs_rule_t *r = ecs_rule(world, {
+ecs_query_impl_t *r = ecs_query(world, {
   .terms = {
     // $this == Foo
     { .first.id = EcsPredEq, .second.id = Foo }, 
@@ -1378,7 +1376,7 @@ ecs_rule_t *r = ecs_rule(world, {
 
 #### Query Builder (C++)
 ```cpp
-world.rule_builder()
+world.query_builder()
   // $this == Foo
   .with(flecs::PredEq, Foo)
   // $this != Foo
@@ -1419,7 +1417,7 @@ ecs_entity_t type_list = ecs_new_w_id(world, EcsPrefab);
 ecs_add(world, type_list, Position);
 ecs_add(world, type_list, Velocity);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { type_list, .oper = EcsAndFrom }, // match Position, Velocity
     { type_list, .oper = EcsOrFrom },  // match Position || Velocity
@@ -1436,7 +1434,7 @@ flecs::entity type_list = world.prefab()
   .add<Position>()
   .add<Velocity>();
 
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term(type_list).oper(flecs::AndFrom) // match Position, Velocity
     .term(type_list).oper(flecs::OrFrom)  // match Position || Velocity
     .term(type_list).oper(flecs::NotFrom) // match !Position, !Velocity
@@ -1446,7 +1444,7 @@ flecs::filter<> f = world.filter_builder()
 The builder API has the `and_from`, `or_from` and `not_from` convenience methods:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
     .term(type_list).and_from()
     .term(type_list).or_from()
     .term(type_list).not_from()
@@ -1504,7 +1502,7 @@ The following examples show how to use scopes in the different language bindings
 
 #### Query Descriptor (C)
 ```c
-ecs_rule_t *r = ecs_rule(world, {
+ecs_query_impl_t *r = ecs_query(world, {
   .terms = {
     // Position, !{ Velocity || Speed }
     { .id = ecs_id(Position) },
@@ -1518,7 +1516,7 @@ ecs_rule_t *r = ecs_rule(world, {
 
 #### Query Builder (C++)
 ```cpp
-world.rule_builder()
+world.query_builder()
   // Position, !{ Velocity || Speed }
   .with<Position>()
   .scope_open().not_()
@@ -1536,7 +1534,7 @@ Position, !{ Velocity || Speed }
 ### Source
 > *Supported by: filters, cached queries, rules*
 
-Source is a property of a term that specifies the entity on which the term should be matched. Queries support two kinds of sources: static and variable. A static source is known when the query is created (for example: match `SimTime` on entity `Game`), whereas a variable source is resolved while the query is evaluated. When no explicit source is specified, a default variable source called `$This` is used (see [Variables](#variables)). 
+Source is a property of a term that specifies the entity on which the term should be matched. Queries support two kinds of sources: static and variable. A static source is known when the query is created (for example: match `SimTime` on entity `Game`), whereas a variable source is resolved while the query is evaluated. When no explicit source is specified, a default variable source called `$this` is used (see [Variables](#variables)). 
 
 When a query only has terms with fixed sources, iterating the query will return a result at least once when it matches, and at most once if the query terms do not match wildcards. If a query has one or more terms with a fixed source that do not match the entity, the query will return no results. A source does not need to match the query when the query is created.
 
@@ -1548,22 +1546,22 @@ The following sections show how to use variable and fixed sources with the diffe
 To specify a fixed source, set the `src.id` member to the entity to match. The following example shows how to set a source, and how to access the value provided by a term with a fixed source:
 
 ```c
-ecs_entity_t Game = ecs_new_id(world);
+ecs_entity_t Game = ecs_new(world);
 ecs_add(world, Game, SimTime);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
-    { ecs_id(Position) }, // normal term, uses $This source
-    { ecs_id(Velocity) },  // normal term, also uses $This source
+    { ecs_id(Position) }, // normal term, uses $this source
+    { ecs_id(Velocity) },  // normal term, also uses $this source
     { ecs_id(SimTime), .src.id = Game } // fixed source, match SimTime on Game
   }
 });
 
-ecs_iter_t it = ecs_filter_iter(world, f);
-while (ecs_filter_next(&it)) {
-  Position *p = ecs_field(&it, Position, 1);
-  Velocity *v = ecs_field(&it, Velocity, 2);
-  SimTime *st = ecs_field(&it, SimTime, 3);
+ecs_iter_t it = ecs_query_iter(world, f);
+while (ecs_query_next(&it)) {
+  Position *p = ecs_field(&it, Position, 0);
+  Velocity *v = ecs_field(&it, Velocity, 1);
+  SimTime *st = ecs_field(&it, SimTime, 2);
   
   for (int i = 0; i < it.count; i ++) {
     p[i].x += v[i].x * st[i].value;
@@ -1582,36 +1580,36 @@ A source may also be specified by name by setting the `src.name` member:
 ecs_entity_t Game = ecs_entity(world, { .name = "Game" });
 ecs_add(world, Game, SimTime);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(SimTime), .src.name = "Game" }
   }
 });
 ```
 
-This examples shows how to access the entities matched by the default `$This` source and a fixed source:
+This examples shows how to access the entities matched by the default `$this` source and a fixed source:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
-    { ecs_id(Position) }, // normal term, uses $This source
+    { ecs_id(Position) }, // normal term, uses $this source
     { ecs_id(SimTime), .src.id = Game } // fixed source, match SimTime on Game
   }
 });
 
-while (ecs_filter_next(&it)) {
-  ecs_entity_t src_1 = ecs_field_src(&it, 1); // Returns 0, meaning entity is stored in it.entities
-  ecs_entity_t src_2 = ecs_field_src(&it, 2); // Returns Game
+while (ecs_query_next(&it)) {
+  ecs_entity_t src_1 = ecs_field_src(&it, 0); // Returns 0, meaning entity is stored in it.entities
+  ecs_entity_t src_2 = ecs_field_src(&it, 1); // Returns Game
 
   for (int i = 0; i < it.count; i ++) {
-    printf("$This = %s, src_2 = %s\n", 
+    printf("$this = %s, src_2 = %s\n", 
       ecs_get_name(world, it.entities[i]),
       ecs_get_name(world, src_2));
   }
 }
 ```
 
-The `entities` and `count` member are solely populated by the number of entities matched by the default `$This` source. If a query only contains fixed sources, `count` will be set to 0. This is important to keep in mind, as the inner for loop from the last example would never be iterated for a query that only has fixed sources.
+The `entities` and `count` member are solely populated by the number of entities matched by the default `$this` source. If a query only contains fixed sources, `count` will be set to 0. This is important to keep in mind, as the inner for loop from the last example would never be iterated for a query that only has fixed sources.
 
 #### Query Builder (C++)
 To specify a fixed source, call the `src` method to the entity to match. The following example shows how to set a source, and how to access the value provided by a term with a fixed source:
@@ -1620,16 +1618,16 @@ To specify a fixed source, call the `src` method to the entity to match. The fol
 flecs::entity Game = world.entity()
   .add<SimTime>();
 
-flecs::filter<> f = world.filter_builder()
-  .term<Position>()  // normal term, uses $This source
-  .term<Velocity>()  // normal term, also uses $This source
+flecs::query<> f = world.query_builder()
+  .term<Position>()  // normal term, uses $this source
+  .term<Velocity>()  // normal term, also uses $this source
   .term<SimTime>().src(Game) // fixed source, match SimTime on Game
   .build();
 
 f.iter([](flecs::iter& it) {
-  auto p = it.field<Position>(1);
-  auto v = it.field<Velocity>(2);
-  auto st = it.field<SimTime>(3);
+  auto p = it.field<Position>(0);
+  auto v = it.field<Velocity>(1);
+  auto st = it.field<SimTime>(2);
   
   for (auto i : it) {
     p[i].x += v[i].x * st[i].value;
@@ -1642,12 +1640,12 @@ Note how in this example all components can be accessed as arrays. When a query
 
 Returning entities one at a time can negatively affect performance, especially for large tables. To learn more about why this behavior exists and how to ensure that mixed results use table-based iteration, see [Instancing](#instancing). 
 
-The next example shows how queries with mixed `$This` and fixed sources can be iterated with `each`. The `each` function does not have the performance drawback of the last `iter` example, as it uses [instancing](#instancing) by default.
+The next example shows how queries with mixed `$this` and fixed sources can be iterated with `each`. The `each` function does not have the performance drawback of the last `iter` example, as it uses [instancing](#instancing) by default.
 
 ```cpp
-flecs::filter<Position, Velocity, SimTime> f = 
-  world.filter_builder<Position, Velocity, SimTime>()
-    .arg(3).src(Game) // set fixed source for 3rd template argument (SimTime)
+flecs::query<Position, Velocity, SimTime> f = 
+  world.query_builder<Position, Velocity, SimTime>()
+    .term_at(2).src(Game) // set fixed source for 3rd template argument (SimTime)
     .build();
 
 // Because all components are now part of the filter type, we can use each
@@ -1657,13 +1655,13 @@ f.each([](flecs::entity e, Position& p, Velocity& v, SimTime& st) {
 });
 ```
 
-When a query has no terms for the `$This` source, it must be iterated with the `iter` function or with a variant of `each` that does not have a signature with `flecs::entity` as first argument:
+When a query has no terms for the `$this` source, it must be iterated with the `iter` function or with a variant of `each` that does not have a signature with `flecs::entity` as first argument:
 
 ```cpp
-flecs::filter<SimConfig, SimTime> f = 
-  world.filter_builder<SimConfig, SimTime>()
-    .arg(1).src(Cfg)
-    .arg(2).src(Game)
+flecs::query<SimConfig, SimTime> f = 
+  world.query_builder<SimConfig, SimTime>()
+    .term_at(0).src(Cfg)
+    .term_at(1).src(Game)
     .build();
 
 // Ok (note that it.count() will be 0)
@@ -1690,15 +1688,15 @@ f.each([](flecs::entity e, SimConfig& sc, SimTime& st) {
 A source may also be specified by name:
 
 ```cpp
-flecs::filter<SimConfig, SimTime> f = 
-  world.filter_builder<SimConfig, SimTime>()
-    .arg(1).src("Cfg")
-    .arg(2).src("Game")
+flecs::query<SimConfig, SimTime> f = 
+  world.query_builder<SimConfig, SimTime>()
+    .term_at(0).src("Cfg")
+    .term_at(1).src("Game")
     .build();
 ```
 
 #### Query DSL
-To specify a source in the DSL, use parenthesis after the component identifier. The following example uses the default `$This` source for `Position` and `Velocity`, and `Game` as source for `SimTime`.
+To specify a source in the DSL, use parenthesis after the component identifier. The following example uses the default `$this` source for `Position` and `Velocity`, and `Game` as source for `SimTime`.
 
 ```
 Position, Velocity, SimTime(Game)
@@ -1707,10 +1705,10 @@ Position, Velocity, SimTime(Game)
 In the previous example the source for `Position` and `Velocity` is implicit. The following example shows the same query with explicit sources for all terms:
 
 ```
-Position($This), Velocity($This), SimTime(Game)
+Position($this), Velocity($this), SimTime(Game)
 ```
 
-To specify a source for a pair, the second element of the pair is placed inside the parenthesis after the source. The following query uses the default `$This` source for the `(Color, Diffuse)` pair, and `Game` as source for the  `(Color, Sky)` pair.
+To specify a source for a pair, the second element of the pair is placed inside the parenthesis after the source. The following query uses the default `$this` source for the `(Color, Diffuse)` pair, and `Game` as source for the  `(Color, Sky)` pair.
 
 ```
 (Color, Diffuse), Color(Game, Sky)
@@ -1719,7 +1717,7 @@ To specify a source for a pair, the second element of the pair is placed inside
 In the previous example the source for `(Color, Diffuse)` is implicit. The following example shows the same query with explicit sources for all terms:
 
 ```
-Color($This, Diffuse), Color(Game, Sky)
+Color($this, Diffuse), Color(Game, Sky)
 ```
 
 ### Singletons
@@ -1733,7 +1731,7 @@ The following sections show how to use singletons in the different language bind
 A singleton query is created by specifying the same id as component and source:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { Player },
     { ecs_id(Position) },
@@ -1748,7 +1746,7 @@ The singleton component data is accessed in the same way a component from a stat
 A singleton query can be created by specifying the same id as component and source:
 
 ```cpp
-flecs::filter<Player, Position> f = world.filter_builder<Player, Position>()
+flecs::query<Player, Position> f = world.query_builder<Player, Position>()
   .term<Input>().src<Input>() // match Input on itself
   .build();
 ```
@@ -1756,7 +1754,7 @@ flecs::filter<Player, Position> f = world.filter_builder<Player, Position>()
 The builder API provides a `singleton` convenience function:
 
 ```cpp
-flecs::filter<Player, Position> f = world.filter_builder<Player, Position>()
+flecs::query<Player, Position> f = world.query_builder<Player, Position>()
   .term<Input>().singleton() // match Input on itself
   .build();
 ```
@@ -1800,8 +1798,6 @@ Traversal behavior can be customized with the following bitflags, in addition to
 |----------|----------------|---------------|-------------------|-------------|
 | Self     | `self`         | `EcsSelf`     | `flecs::Self`     | Match self |
 | Up       | `up`           | `EcsUp`       | `flecs::Up`       | Match by traversing upwards |
-| Down     | `down`         | `EcsDown`     | `flecs::Down`     | Match by traversing downwards (derived, cannot be set) |
-| Parent   | `parent`       | `EcsParent`   | `flecs::Parent`   | Short for up(ChildOf) |
 | Cascade  | `cascade`      | `EcsCascade`  | `flecs::Cascade`  | Same as Up, but iterate in breadth-first order |
 | Desc     | `desc`         | `EcsDesc`     | `flecs::Desc`     | Combine with Cascade to iterate hierarchy bottom to top |
 
@@ -1820,7 +1816,7 @@ flecs::entity child = world.entity()
   .add(flecs::ChildOf, parent);
 
 // This filter matches 'child', because it has a parent that inherits Mass
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   .term<Mass>().up(flecs::ChildOf)
   .build();
 ```
@@ -1850,10 +1846,10 @@ The following sections show how to use traversal in the different language bindi
 By default queries traverse the `IsA` relationship if a component cannot be found on the matched entity. In the following example, both `base` and `inst` match the query:
 
 ```c
-ecs_entity_t base = ecs_new(world, Position);
+ecs_entity_t base = ecs_new_w(world, Position);
 ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base); // Inherits Position
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }
   }
@@ -1863,7 +1859,7 @@ ecs_filter_t *f = ecs_filter(world, {
 Implicit traversal can be disabled by setting the `flags` member to `EcsSelf`. The following example only matches `base`:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position), .src.flags = EcsSelf }
   }
@@ -1873,12 +1869,12 @@ ecs_filter_t *f = ecs_filter(world, {
 To use a different relationship for traversal, use the `trav` member in combination with the `EcsUp` flag. The following example only matches `child`:
 
 ```c
-ecs_entity_t parent = ecs_new(world, Position);
-ecs_entity_t child = ecs_new(world, Position);
+ecs_entity_t parent = ecs_new_w(world, Position);
+ecs_entity_t child = ecs_new_w(world, Position);
 
 ecs_add_pair(world, child, EcsChildOf, parent);
 
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     // term matches parent & child
     { ecs_id(Position) },
@@ -1891,7 +1887,7 @@ ecs_filter_t *f = ecs_filter(world, {
 The `EcsParent` flag can be used which is shorthand for `EcsUp` with `EcsChildOf`. The query in the following example is equivalent to the one in the previous example:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) },
     { ecs_id(Position), .src.flags = EcsParent }
@@ -1902,7 +1898,7 @@ ecs_filter_t *f = ecs_filter(world, {
 If a query needs to match a component from both child and parent, but must also include the root of the tree, the term that traverses the relationship can be made optional. The following example matches both `parent` and `child`. The second term is not set for the result that contains `parent`.
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position) },
     { ecs_id(Position), .src.flags = EcsParent, .oper = EcsOptional }
@@ -1914,7 +1910,7 @@ By adding the `EcsCascade` flag, a query will iterate the hierarchy top-down. Th
 
 ```c
 ecs_query_t *q = ecs_query(world, {
-  .filter.terms = {
+  .terms = {
     { ecs_id(Position) },
     { ecs_id(Position), .src.flags = EcsCascade|EcsParent, .oper = EcsOptional }
   }
@@ -1924,7 +1920,7 @@ ecs_query_t *q = ecs_query(world, {
 Relationship traversal can be combined with fixed [source](#source) terms. The following query matches if the `my_widget` entity has a parent with the `Window` component:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Window), .src.flags = EcsParent, .src.id = my_widget }
   }
@@ -1934,17 +1930,17 @@ ecs_filter_t *f = ecs_filter(world, {
 The two queries in the following example are equivalent, and show how the implicit traversal of the `IsA` relationship is implemented:
 
 ```cpp
-ecs_filter_t *f_1 = ecs_filter(world, {
+ecs_query_t *f_1 = ecs_query(world, {
   .terms = {
     { ecs_id(Position) }
   }
 });
 
-ecs_filter_t *f_2 = ecs_filter(world, {
+ecs_query_t *f_2 = ecs_query(world, {
   .terms = {{
     .id = ecs_id(Position),       // match Position
     .src.flags = EcsSelf | EcsUp  // first match self, traverse upwards while not found
-    .src.trav = EcsIsA,           // traverse using the IsA relationship
+    .trav = EcsIsA,           // traverse using the IsA relationship
   }}
 });
 ```
@@ -1959,13 +1955,13 @@ flecs::entity base = world.entity()
 flecs::entity inst = world.entity()
   .is_a(base); // short for .add(flecs::IsA, base)
 
-flecs::filter<> f = world.filter<Position>();
+flecs::query<> f = world.query<Position>();
 ```
 
 Implicit traversal can be disabled by calling the `self` method for the term. The following example only matches `base`:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   .term<Position>().self()
   .build();
 ```
@@ -1979,7 +1975,7 @@ flecs::entity parent = world.entity()
 flecs::entity child = world.entity()
   .child_of(parent);  // short for .add(flecs::ChildOf, parent)
 
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   // term matches parent & child
   .term<Position>()
   // term just matches child, parent does not have a parent with Position
@@ -1990,7 +1986,7 @@ flecs::filter<> f = world.filter_builder()
 The `parent` method can be used which is shorthand for `up(flecs::ChildOf)`. The query in the following example is equivalent to the one in the previous example:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   .term<Position>()
   .term<Position>().parent()
   .build();
@@ -1999,7 +1995,7 @@ flecs::filter<> f = world.filter_builder()
 If a query needs to match a component from both child and parent, but must also include the root of the tree, the term that traverses the relationship can be made optional. The following example matches both `parent` and `child`. The second term is not set for the result that contains `parent`.
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   .term<Position>()
   .term<Position>().parent().optional()
   .build();
@@ -2017,7 +2013,7 @@ flecs::query<> q = world.query_builder()
 Relationship traversal can be combined with fixed [source](#source) terms. The following query matches if the `my_widget` entity has a parent with the `Window` component:
 
 ```cpp
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   .term<Window>().src(my_widget).parent()
   .build();
 ```
@@ -2025,9 +2021,9 @@ flecs::filter<> f = world.filter_builder()
 The two queries in the following example are equivalent, and show how the implicit traversal of the `IsA` relationship is implemented:
 
 ```cpp
-flecs::filter<> f = world.filter<Position>();
+flecs::query<> f = world.query<Position>();
 
-flecs::filter<> f = world.filter_builder()
+flecs::query<> f = world.query_builder()
   .term<Position>() // match Position
     .self()         // first match self
     .up(flecs::IsA) // traverse IsA upwards while not found
@@ -2068,7 +2064,7 @@ Position, ?Position(parent)
 By adding the `cascade` keyword, a query will iterate the `ChildOf` hierarchy top-down. The `cascade` feature is only supported by cached queries:
 
 ```
-Position, ?Position(parent|cascade)
+Position, ?Position(cascade)
 ```
 
 Relationship traversal can be combined with fixed [source](#source) terms, by using a colon (`:`) to separate the traversal flags and the source identifier. The following query matches if the `my_widget` entity has a parent with the `Window` component:
@@ -2121,7 +2117,7 @@ flecs::entity ent_2 = world.entity("ent_2")
   .set<Mass>({30})
   .set<Position>({50, 60});
 
-flecs::filter<Position, Mass> f = world.filter<Position, Mass>();
+flecs::query<Position, Mass> f = world.query<Position, Mass>();
 ```
 
 The filter in this example will match both `inst_1`, `inst_2` because they inherit `Mass`, and `ent_1` and `ent_2` because they own `Mass`. The following example shows an example of code that iterates the filter:
@@ -2199,7 +2195,7 @@ The following sections show how to use instancing in the different language bind
 Queries can be instanced by setting the `instanced` member to true:
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms = {
     { ecs_id(Position), src.flags = EcsSelf }, // Never inherit Position
     { ecs_id(Mass) }
@@ -2210,13 +2206,13 @@ ecs_filter_t *f = ecs_filter(world, {
   .instanced = true
 });
 
-ecs_iter_t it = ecs_filter_iter(world, &it);
-while (ecs_filter_next(&it)) {
+ecs_iter_t it = ecs_query_iter(world, &it);
+while (ecs_query_next(&it)) {
   // Fetch components as usual
-  Position *p = ecs_field(&it, Position, 1);
-  Mass *m = ecs_field(&it, Mass, 2);
+  Position *p = ecs_field(&it, Position, 0);
+  Mass *m = ecs_field(&it, Mass, 1);
 
-  if (ecs_field_is_self(&it, 2)) {
+  if (ecs_field_is_self(&it, 1)) {
     // Mass is matched on self, access as array
     for (int i = 0; i < it.count; i ++) {
       p[i].x += 1.0 / m[i].value;
@@ -2238,16 +2234,16 @@ Note how the `ecs_field_is_self` test is moved outside of the for loops. This ke
 Queries can be instanced by calling the `instanced` method:
 
 ```cpp
-flecs::filter<Position, Mass> f = world.filter_builder<Position, Mass>()
+flecs::query<Position, Mass> f = world.query_builder<Position, Mass>()
   // Never inherit Position
-  .arg(1).self()
+  .term_at(0).self()
   // Instancing is a property of the iterator, but by setting it on the query
   // all iterators created for the query will be instanced.
   .instanced()
   .build();
 
 f.iter([](flecs::iter& it, Position *p, Mass *v) {
-  if (it.is_self(2)) {
+  if (it.is_self(1)) {
     // Mass is matched on self, access as array
     for (auto i : it) {
       p[i].x += 1.0 / m[i].value;
@@ -2273,12 +2269,12 @@ Query variables represent the state of a query while it is being evaluated. The
 Consider this query example, written down with explicit term [sources](#source):
 
 ```
-Position($This), Velocity($This)
+Position($this), Velocity($this)
 ```
 
 The first term to encounter a variable is usually the one to populate it with all candidates that could match that term. Subsequent terms then use the already populated variable to test if it matches. If the condition matches, the query moves on to the next term. If the condition fails, the query moves back to the previous term and, if necessary, populates the variable with the next candidate. These kinds of conditions are usually referred to as [predicates](https://en.wikipedia.org/wiki/Predicate_(mathematical_logic)), and this evaluation process is called [backtracking](https://en.wikipedia.org/wiki/Backtracking).
 
-This process effectively _constrains_ the possible results that a term could yield. By itself, the `Velocity` term would return all entities with the `Velocity` component, but because `$This` has been assigned already with entities that have `Position`, the term only feeds forward entities that have both `Position` and `Velocity`.
+This process effectively _constrains_ the possible results that a term could yield. By itself, the `Velocity` term would return all entities with the `Velocity` component, but because `$this` has been assigned already with entities that have `Position`, the term only feeds forward entities that have both `Position` and `Velocity`.
 
 While using variables as [source](#source) is the most common application for variables, variables can be used in any part of the term. Consider constructing a query for all spaceships that are docked to a planet. A first attempt could look like this:
 
@@ -2289,24 +2285,24 @@ SpaceShip, (DockedTo, *)
 When rewritten with explicit sources, the query looks like this:
 
 ```
-SpaceShip($This), DockedTo($This, *)
+SpaceShip($this), DockedTo($this, *)
 ```
 
 This returns all spaceships that are docked to _anything_, instead of docked to planets. To constrain the result of this query, the wildcard used as target for the `DockedTo` relationship can be replaced with a variable. An example:
 
 ```
-SpaceShip($This), DockedTo($This, $Location)
+SpaceShip($this), DockedTo($this, $Location)
 ```
 
 When the second term is evaluated for the first time, `$Location` will not yet be populated. This causes the term to do two things:
 
-1. Test if the entity/table populated in `$This` has `(DockedTo, *)`
+1. Test if the entity/table populated in `$this` has `(DockedTo, *)`
 2. If so, populate `$Location` with the id matched by `*`.
 
 After evaluating the second term, the `$Location` variable is populated with the location the spaceship is docked to. We can now use this variable in a new term, that constrains the location to only entities that have `Planet`:
 
 ```
-SpaceShip($This), DockedTo($This, $Location), Planet($Location)
+SpaceShip($this), DockedTo($this, $Location), Planet($Location)
 ```
 
 This query returns the desired result ("return all spaceships docked to a planet").
@@ -2314,7 +2310,7 @@ This query returns the desired result ("return all spaceships docked to a planet
 Variables can also be used to constrain matched components. Consider the following example query:
 
 ```
-Serializable($Component), $Component($This)
+Serializable($Component), $Component($this)
 ```
 
 This query returns serializable components for all entities that have at least one.
@@ -2323,19 +2319,19 @@ This query returns serializable components for all entities that have at least o
 By default variables are assigned while the query is being iterated, but variables can be set before query iteration to constrain the results of a query. Consider the previous example:
 
 ```
-SpaceShip($This), DockedTo($This, $Location)
+SpaceShip($this), DockedTo($this, $Location)
 ```
 
-An application can set the `$This` variable or `$Location` variables, or both, before starting iteration to constrain the results returned by the query. This makes it possible to reuse a single query for multiple purposes, which provides better performance when compared to creating multiple queries.
+An application can set the `$this` variable or `$Location` variables, or both, before starting iteration to constrain the results returned by the query. This makes it possible to reuse a single query for multiple purposes, which provides better performance when compared to creating multiple queries.
 
-The following sections show how to use queries in the different language bindings. The code examples use rules queries, which currently are the only queries that support using variables other than `$This`.
+The following sections show how to use queries in the different language bindings. The code examples use rules queries, which currently are the only queries that support using variables other than `$this`.
 
 #### Query Descriptor (C)
 Query variables can be specified by setting the `name` member in combination with setting the `EcsIsVariable` bit in the `flags` member:
 
 ```c
 // SpaceShip, (DockedTo, $Location), Planet($Location)
-ecs_rule_t *r = ecs_rule(world, {
+ecs_query_impl_t *r = ecs_query(world, {
   .terms = {
     { .id = SpaceShip },
     {
@@ -2359,13 +2355,13 @@ ecs_rule_t *r = ecs_rule(world, {
 An application can constrain the results of the query by setting the variable before starting iteration:
 
 ```c
-ecs_entity_t earth = ecs_new(world, Planet);
+ecs_entity_t earth = ecs_new_w(world, Planet);
 
 // Find index for Location variable
-int32_t location_var = ecs_rule_find_var(r, "Location");
+int32_t location_var = ecs_query_find_var(r, "Location");
 
 // Constrain results of iterator to return spaceships docked to Earth
-ecs_iter_t it = ecs_rule_iter(world, r);
+ecs_iter_t it = ecs_query_iter(world, r);
 ecs_iter_set_var(&it, location_var, earth);
 
 // Iterate as usual
@@ -2375,7 +2371,7 @@ ecs_iter_set_var(&it, location_var, earth);
 Query variables can be specified by specifying a name with a `$` prefix:
 
 ```cpp
-auto r = world.rule_builder()
+auto r = world.query_builder()
   .term<SpaceShip>()
   .term<DockedTo>().second("$Location")
   .term<Planet>().src("$Location")
@@ -2385,7 +2381,7 @@ auto r = world.rule_builder()
 Alternatively, variables can also be specified using the `var` method:
 
 ```cpp
-auto r = world.rule_builder()
+auto r = world.query_builder()
   .term<SpaceShip>()
   .term<DockedTo>().second().var("Location")
   .term<Planet>().src().var("Location")
@@ -2450,13 +2446,13 @@ The following example shows how the change detection API is used in C:
 ```c
 // Query used for change detection. Note that change detection is not enabled on
 // the query itself, but by calling change detection functions for the query.
-ecs_query_t *q_read = ecs_query(world, {
-    .filter.terms = {{ .id = ecs_id(Position), .inout = EcsIn }}
+ecs_query_cache_t *q_read = ecs_query(world, {
+    .terms = {{ .id = ecs_id(Position), .inout = EcsIn }}
 });
 
 // Query used to create changes
-ecs_query_t *q_write = ecs_query(world, {
-    .filter.terms = {{ .id = ecs_id(Position) }} // defaults to inout
+ecs_query_cache_t *q_write = ecs_query(world, {
+    .terms = {{ .id = ecs_id(Position) }} // defaults to inout
 });
 
 // Test if changes have occurred for anything matching the query. If this is the
@@ -2464,7 +2460,7 @@ ecs_query_t *q_write = ecs_query(world, {
 bool changed = ecs_query_changed(q_read, NULL);
 
 // Setting a component will update the changed state
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 ecs_set(world, e, Position, {10, 20});
 
 // Iterating a query with inout/out terms will update the change state
@@ -2473,7 +2469,7 @@ while (ecs_query_next(&it)) {
   if (dont_change) {
     // If no changes are made to the iterated table, the skip function can be
     // called to prevent marking the matched components as dirty.
-    ecs_query_skip(&it);
+    ecs_iter_skip(&it);
   } else {
     // Iterate as usual. It does not matter whether the code actually writes the
     // components or not: when a table is not skipped, components matched with
@@ -2579,12 +2575,12 @@ The following example shows how to use sorted queries in C:
 
 ```c
 ecs_query_t *q = ecs_query(world, {
-    .filter.terms = {
+    .terms = {
       // Use readonly term for component used for sorting
       { ecs_id(Depth), .inout = EcsIn }
     },
-    .order_by_component = ecs_id(Depth), // The component to use for sorting
-    .order_by = compare_depth,
+    .order_by = ecs_id(Position), // The component to use for sorting
+    .order_by_callback = compare_position,
 });
 ```
 
@@ -2598,14 +2594,14 @@ int compare_depth(ecs_entity_t e1, const void *v1, ecs_entity_t e2, const void *
 }
 ```
 
-A query may only use entity identifiers to sort by not setting the `order_by_component` member:
+A query may only use entity identifiers to sort by not setting the `order_by` member:
 
 ```c
 ecs_query_t *q = ecs_query(world, {
-    .filter.terms = {
+    .terms = {
       { ecs_id(Position) },
     },
-    .order_by = compare_entity,
+    .order_by_callback = compare_entity,
 });
 ```
 
@@ -2680,11 +2676,11 @@ The following sections show how to use sorting in the different language binding
 The following example shows how grouping can be used to group entities that are in the same game region.
 
 ```c
-ecs_entity_t Region = ecs_new_id(world);
-ecs_entity_t Unit = ecs_new_id(world);
+ecs_entity_t Region = ecs_new(world);
+ecs_entity_t Unit = ecs_new(world);
 
-ecs_entity_t Region_01 = ecs_new_id(world);
-ecs_entity_t Region_02 = ecs_new_id(world);
+ecs_entity_t Region_01 = ecs_new(world);
+ecs_entity_t Region_02 = ecs_new(world);
 
 // Example of entities created in different regions
 ecs_entity_t unit_01 = ecs_new_w_id(world, Unit);
@@ -2695,9 +2691,9 @@ ecs_add_pair(world, unit_02, Region, Region_02);
 
 // Create query that groups entities that are in the same region
 ecs_query(world, {
-  .filter.terms = {{ Unit }},
-  .group_by = group_by_target, // function that groups by relationship target
-  .group_by_id = Region // optional, passed to group_by function
+  .terms = {{ Unit }},
+  .group_by_callback = group_by_target, // function that groups by relationship target
+  .group_by = Region // optional, passed to group_by function
 });
 ```
 
@@ -2773,7 +2769,7 @@ The following sections show how to use component inheritance in the different la
 The following example shows a rule that uses component inheritance to match entities:
 
 ```c
-ecs_entity_t Unit = ecs_new_id(world);
+ecs_entity_t Unit = ecs_new(world);
 ecs_entity_t MeleeUnit = ecs_new_w_pair(world, EcsIsA, Unit);
 ecs_entity_t RangedUnit = ecs_new_w_pair(world, EcsIsA, Unit);
 
@@ -2781,7 +2777,7 @@ ecs_entity_t unit_01 = ecs_new_w_id(world, MeleeUnit);
 ecs_entity_t unit_02 = ecs_new_w_id(world, RangedUnit);
 
 // Matches entities with Unit, MeleeUnit and RangedUnit
-ecs_rule_t *r = ecs_rule(world, {
+ecs_query_impl_t *r = ecs_query(world, {
   .terms = {{ Unit }}
 });
 
@@ -2792,7 +2788,7 @@ ecs_rule_t *r = ecs_rule(world, {
 The following example shows a rule that uses component inheritance to match entities:
 
 ```cpp
-flecs::entity Unit = ecs_new_id(world);
+flecs::entity Unit = ecs_new(world);
 flecs::entity MeleeUnit = world.entity().is_a(Unit);
 flecs::entity RangedUnit = world.entity().is_a(Unit);
 
@@ -2800,7 +2796,7 @@ flecs::entity unit_01 = world.entity().add(MeleeUnit);
 flecs::entity unit_02 = world.entity().add(RangedUnit);
 
 // Matches entities with Unit, MeleeUnit and RangedUnit
-flecs::rule<Unit> r = world.rule<Unit>();
+flecs::query<Unit> r = world.query<Unit>();
 
 // Iterate as usual
 ```
@@ -2827,13 +2823,13 @@ The following example shows a rule that uses transitivity to match entities that
 // Create LocatedIn relationship with transitive property
 ecs_entity_t LocatedIn = ecs_new_w_id(world, EcsTransitive);
 
-ecs_entity_t NewYork = ecs_new_id(world);
+ecs_entity_t NewYork = ecs_new(world);
 ecs_entity_t Manhattan = ecs_new_w_pair(world, LocatedIn, NewYork);
 ecs_entity_t CentralPark = ecs_new_w_pair(world, LocatedIn, Manhattan);
 ecs_entity_t Bob = ecs_new_w_pair(world, LocatedIn, CentralPark);
 
 // Matches ManHattan, CentralPark, Bob
-ecs_rule_t *r = ecs_rule(world, {
+ecs_query_impl_t *r = ecs_query(world, {
   .terms = {{ ecs_pair(LocatedIn, NewYork) }}
 });
 
@@ -2847,7 +2843,7 @@ Queries for transitive relationships can be compared with variables. This query
 //  - ManHattan (Place = NewYork)
 //  - CentralPark (Place = ManHattan, NewYork)
 //  - Bob (Place = CentralPark, ManHattan, NewYork)
-ecs_rule_t *r = ecs_rule(world, {
+ecs_query_impl_t *r = ecs_query(world, {
   .terms = {{ .first.id = LocatedIn, .second.name = "Place", .second.flags = EcsIsVariable }}
 });
 ```
@@ -2856,14 +2852,14 @@ Variables can be used to constrain the results of a transitive query. The follow
 
 ```c
 // Add City property to NewYork
-ecs_entity_t City = ecs_new_id(world);
+ecs_entity_t City = ecs_new(world);
 ecs_add_id(world, NewYork, City);
 
 // Matches:
 //  - ManHattan (Place = NewYork)
 //  - CentralPark (Place = NewYork)
 //  - Bob (Place = NewYork)
-ecs_rule_t *r = ecs_rule(world, {
+ecs_query_impl_t *r = ecs_query(world, {
   .terms = {
     { .first.id = LocatedIn, .second.name = "Place", .second.flags = EcsIsVariable },
     { .id = City, .src.name = "Place", .src.flags = EcsIsVariable }
@@ -2886,7 +2882,7 @@ flecs::entity CentralPark = world.entity().add<LocatedIn>(Manhattan);
 flecs::entity Bob = world.entity().add<LocatedIn>(CentralPark);
 
 // Matches ManHattan, CentralPark, Bob
-flecs::rule<> r = world.rule_builder()
+flecs::query<> r = world.query_builder()
   .term<LocatedIn>(NewYork)
   .build();
 
@@ -2900,7 +2896,7 @@ Queries for transitive relationships can be compared with variables. This query
 //  - ManHattan (Place = NewYork)
 //  - CentralPark (Place = ManHattan, NewYork)
 //  - Bob (Place = CentralPark, ManHattan, NewYork)
-flecs::rule<> r = world.rule_builder()
+flecs::query<> r = world.query_builder()
   .term<LocatedIn>().second("$Place")
   .build();
 ```
@@ -2917,7 +2913,7 @@ NewYork.add(City);
 //  - ManHattan (Place = NewYork)
 //  - CentralPark (Place = NewYork)
 //  - Bob (Place = NewYork)
-flecs::rule<> r = world.rule_builder()
+flecs::query<> r = world.query_builder()
   .term<LocatedIn>().second("$Place")
   .term<City>().src("$Place")
   .build();
@@ -2959,11 +2955,11 @@ The following sections show how to use transitive relationships in the different
 The following example shows a rule that uses the `IsA` reflexive relationship:
 
 ```c
-ecs_entity_t Tree = ecs_new_id(world);
+ecs_entity_t Tree = ecs_new(world);
 ecs_entity_t Oak = ecs_new_w_pair(world, EcsIsA, Tree);
 
 // Matches Tree, Oak
-ecs_rule_t *r = ecs_rule(world, {
+ecs_query_impl_t *r = ecs_query(world, {
   .terms = {{ ecs_pair(EcsIsA, Tree )}}
 });
 ```
@@ -2976,7 +2972,7 @@ flecs::entity Tree = world.entity();
 flecs::entity Oak = world.entity().is_a(Tree);
 
 // Matches Tree, Oak
-flecs::rule<> r = world.rule_builder()
+flecs::query<> r = world.query_builder()
   .term(flecs::IsA, Tree)
   .build();
 ```
@@ -2991,10 +2987,10 @@ Reflexivity in a query is enabled by adding the `Reflexive` property to a relati
 ## Performance
 This section describes performance characteristics for each query type.
 
-### Filter
-A filter is a data type that describes the structure of a query in Flecs. Filters are the cheapest to create, as creating one just requires initializing the value of the filter object.
+### Query
+A filter is a data type that describes the structure of a query in Flecs. Querys are the cheapest to create, as creating one just requires initializing the value of the filter object.
 
-Filters can serve different purposes, like iterating all matching entities, or testing if a specific entity matches with a filter. Filters can also be used to filter the output of other queries, including other filters.
+Querys can serve different purposes, like iterating all matching entities, or testing if a specific entity matches with a filter. Querys can also be used to filter the output of other queries, including other filters.
 
 While the exact way a filter is evaluated depends on what kind of filter it is, almost all filter evaluation follows steps similar to the ones in this diagram:
 
@@ -3017,24 +3013,24 @@ When a table reaches the `yield` node it means that it matched all parts of the
 Because filters are fast to create, have low overhead, and are reasonably efficient to iterate, they are the goto solution for when an application cannot know in advance what it needs to query for, like finding all children for a specific entity:
 
 ```c
-ecs_filter_f fs = ECS_FILTER_INIT;
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_f fs = ECS_FILTER_INIT;
+ecs_query_t *f = ecs_query(world, {
     .storage = &fs, // optional, but prevents allocation
     .terms = {{ ecs_childof(e) }}
 });
 
-ecs_iter_t child_it = ecs_filter_iter(f);
-while (ecs_filter_next(&child_it)) {
+ecs_iter_t child_it = ecs_query_iter(f);
+while (ecs_query_next(&child_it)) {
     for (int c = 0; c < child_it.count; c ++) {
         printf("child %s\n", ecs_get_name(world, 
             child_it.entities[c]));
     }
 }
 
-ecs_filter_fini(f);
+ecs_query_fini(f);
 ```
 ```cpp
-auto f = world.filter_builder()
+auto f = world.query_builder()
   .term(flecs::ChildOf, e)
   .build();
 
@@ -3063,22 +3059,22 @@ The following example shows how cached queries are used:
 ```c
 // Creates query, populates the cache with existing tables
 ecs_query_t *q = ecs_query(world, {
-    .filter.terms = {
+    .terms = {
         { ecs_id(Position) }, { ecs_id(Velocity) }
     }
 });
 
 // When a new table is created that matches the query, it is
 // added to the cache
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 ecs_add(world, e, Position);
 ecs_add(world, e, Velocity);
 
 // Iterate the tables in the cache
 ecs_iter_t it = ecs_query_iter(world, q);
 while (ecs_query_next(&it)) {
-    Position *p = ecs_field(&it, Position, 1);
-    Velocity *v = ecs_field(&it, Velocity, 2);
+    Position *p = ecs_field(&it, Position, 0);
+    Velocity *v = ecs_field(&it, Velocity, 1);
 
     for (int i = 0; i < it.count; i ++) {
         p[i].x += v[i].x;
diff --git a/docs/Quickstart.md b/docs/Quickstart.md
index 065996d44..be2bf0878 100644
--- a/docs/Quickstart.md
+++ b/docs/Quickstart.md
@@ -114,17 +114,13 @@ Addon         | Description                                      | Define
 [Pipeline](/flecs/group__c__addons__pipeline.html)         | Automatically schedule & multithread systems     | FLECS_PIPELINE      |
 [Timer](/flecs/group__c__addons__timer.html)               | Run systems at time intervals or at a rate       | FLECS_TIMER         |
 [Meta](/flecs/group__c__addons__meta.html)                 | Flecs reflection system                          | FLECS_META          |
-[Meta_C](/flecs/group__c__addons__meta__c.html)            | (C) Utilities for auto-inserting reflection data | FLECS_META_C        |
 [Units](/flecs/group__c__addons__units.html)               | Builtin unit types                               | FLECS_UNITS         |
-[Expr](/flecs/group__c__addons__expr.html)                 | String format optimized for ECS data             | FLECS_EXPR          |
 [JSON](/flecs/group__c__addons__json.html)                 | JSON format                                      | FLECS_JSON          |
 [Doc](/flecs/group__c__addons__doc.html)                   | Add documentation to components, systems & more  | FLECS_DOC           |
 [Http](/flecs/group__c__addons__http.html)                 | Tiny HTTP server for processing simple requests  | FLECS_HTTP          |
 [Rest](/flecs/group__c__addons__rest.html)                 | REST API for showing entities in the browser     | FLECS_REST          |
-[Parser](/flecs/group__c__addons__parser.html)             | Create entities & queries from strings           | FLECS_PARSER        |
-[Plecs](/flecs/group__c__addons__plecs.html)               | Small utility language for asset/scene loading   | FLECS_PLECS         |
+[Script](/flecs/group__c__addons__script.html)             | DSL for assets, scenes and configuration         | FLECS_SCRIPT         |
 [Rules](/flecs/group__c__addons__rules.html)               | Powerful prolog-like query language              | FLECS_RULES         |
-[Snapshot](/flecs/group__c__addons__snapshot.html)         | Take snapshots of the world & restore them       | FLECS_SNAPSHOT      |
 [Stats](/flecs/group__c__addons__stats.html)               | Functions for collecting statistics              | FLECS_STATS         |
 [Monitor](/flecs/group__c__addons__monitor.html)           | Periodically collect & store flecs statistics    | FLECS_MONITOR       |
 [Metrics](/flecs/group__c__addons__metrics.html)           | Create metrics from user-defined components      | FLECS_METRICS       |
@@ -179,7 +175,7 @@ An entity is a unique thing in the world, and is represented by a 64 bit id. Ent
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 ecs_is_alive(world, e); // true!
 
 ecs_delete(world, e);
@@ -279,7 +275,7 @@ A component is a type of which instances can be added and removed to entities. E
 ECS_COMPONENT(world, Position);
 ECS_COMPONENT(world, Velocity);
 
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 
 // Add a component. This creates the component in the ECS storage, but does not
 // assign it with a value.
@@ -428,10 +424,10 @@ A tag is a component that does not have any data. In Flecs tags can be either em
 
 ```c
 // Create Enemy tag
-ecs_entity_t Enemy = ecs_new_id(world);
+ecs_entity_t Enemy = ecs_new(world);
 
 // Create entity, add Enemy tag
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 
 ecs_add_id(world, e, Enemy);
 ecs_has_id(world, e, Enemy); // true!
@@ -505,11 +501,11 @@ A pair is a combination of two entity ids. Pairs can be used to store entity rel
 
 ```c
 // Create Likes relationship
-ecs_entity_t Likes = ecs_new_id(world);
+ecs_entity_t Likes = ecs_new(world);
 
 // Create a small graph with two entities that like each other
-ecs_entity_t Bob = ecs_new_id(world);
-ecs_entity_t Alice = ecs_new_id(world);
+ecs_entity_t Bob = ecs_new(world);
+ecs_entity_t Alice = ecs_new(world);
 
 ecs_add_pair(world, Bob, Likes, Alice); // Bob likes Alice
 ecs_add_pair(world, Alice, Likes, Bob); // Alice likes Bob
@@ -697,7 +693,7 @@ Flecs has builtin support for hierarchies with the builtin `EcsChildOf` (or `fle
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t parent = ecs_new_id(world);
+ecs_entity_t parent = ecs_new(world);
 
 // ecs_new_w_pair is the same as ecs_new_id + ecs_add_pair
 ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -784,8 +780,8 @@ Queries (see below) can use hierarchies to order data breadth-first, which can c
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-    .filter.terms = {
+ecs_query_t *q = ecs_query(world, {
+    .terms = {
         { ecs_id(Position) },
         { ecs_id(Position), .src = {
             .flags = EcsCascade,       // Breadth-first order
@@ -796,8 +792,8 @@ ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
 
 ecs_iter_t it = ecs_query_iter(world, q);
 while (ecs_query_next(&it)) {
-    Position *p = ecs_field(&it, Position, 1);
-    Position *p_parent = ecs_field(&it, Position, 2);
+    Position *p = ecs_field(&it, Position, 0);
+    Position *p_parent = ecs_field(&it, Position, 1);
     for (int i = 0; i < it.count; i++) {
         // Do the thing
     }
@@ -808,7 +804,7 @@ while (ecs_query_next(&it)) {
 
 ```cpp
 auto q = world.query_builder<Position, Position>()
-    .term_at(2).parent().cascade()
+    .term_at(1).parent().cascade()
     .build();
 
 q.each([](Position& p, Position& p_parent) {
@@ -840,7 +836,7 @@ Flecs has builtin support for instancing (sharing a single component with multip
 
 ```c
 // Shortcut to create entity & set a component
-ecs_entity_t base = ecs_set(world, 0, Triangle, {{0, 0}, {1, 1}, {-1, -1}});
+ecs_entity_t base = ecs_insert(world, ecs_value(Triangle, {{0, 0}, {1, 1}, {-1, -1}}));
 
 // Create entity that shares components with base
 ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
@@ -909,7 +905,7 @@ The type (often referred to as "archetype") is the list of ids an entity has. Ty
 ECS_COMPONENT(world, Position);
 ECS_COMPONENT(world, Velocity);
 
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 ecs_add(world, e, Position);
 ecs_add(world, e, Velocity);
 
@@ -1060,7 +1056,7 @@ The following examples show how to query for a singleton component:
 ```c
 // Create query that matches Gravity as singleton
 ecs_query_t *q = ecs_query(ecs, {
-    .filter.terms = {
+    .terms = {
         // Regular component
         { .id = ecs_id(Velocity) },
         // A singleton is a component matched on itself
@@ -1076,7 +1072,7 @@ ECS_SYSTEM(world, ApplyGravity, EcsOnUpdate, Velocity, Gravity($));
 
 ```cpp
 world.query_builder<Velocity, Gravity>()
-    .term_at(2).singleton()
+    .term_at(1).singleton()
     .build();
 ```
 </li>
@@ -1091,15 +1087,20 @@ world.QueryBuilder<Velocity, Gravity>()
 </ul>
 </div>
 
+<<<<<<< HEAD
 ### Filter
-Filters are a kind of uncached query that are cheap to create. This makes them a good fit for scenarios where an application doesn't know in advance what it has to query for, like when finding the children for a parent. The following example shows a simple filter:
+Queries are a kind of uncached query that are cheap to create. This makes them a good fit for scenarios where an application doesn't know in advance what it has to query for, like when finding the children for a parent. The following example shows a simple filter:
 <div class="flecs-snippet-tabs">
 <ul>
 <li><b class="tab-title">C</b>
+=======
+### Query
+Querys are a kind of uncached query that are cheap to create. This makes them a good fit for scenarios where an application doesn't know in advance what it has to query for, like when finding the children for a parent. The following example shows a simple filter:
+>>>>>>> 45a6e85b8 (v4)
 
 ```c
 // Initialize a filter with 2 terms on the stack
-ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+ecs_query_t *f = ecs_query_init(world, &(ecs_query_desc_t){
     .terms = {
         { ecs_id(Position) },
         { ecs_pair(EcsChildOf, parent) }
@@ -1109,10 +1110,10 @@ ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
 // Iterate the filter results. Because entities are grouped by their type there
 // are two loops: an outer loop for the type, and an inner loop for the entities
 // for that type.
-ecs_iter_t it = ecs_filter_iter(world, f);
-while (ecs_filter_next(&it)) {
+ecs_iter_t it = ecs_query_iter(world, f);
+while (ecs_query_next(&it)) {
     // Each type has its own set of component arrays
-    Position *p = ecs_field(&it, Position, 1);
+    Position *p = ecs_field(&it, Position, 0);
 
     // Iterate all entities for the type
     for (int i = 0; i < it.count; i++) {
@@ -1121,7 +1122,7 @@ while (ecs_filter_next(&it)) {
     }
 }
 
-ecs_filter_fini(f);
+ecs_query_fini(f);
 ```
 </li>
 <li><b class="tab-title">C++</b>
@@ -1134,7 +1135,7 @@ world.each([](Position& p, Velocity& v) { // flecs::entity argument is optional
 });
 
 // More complex filters can first be created, then iterated
-auto f = world.filter_builder<Position>()
+auto f = world.query_builder<Position>()
     .term(flecs::ChildOf, parent)
     .build();
 
@@ -1184,7 +1185,7 @@ f.Iter((Iter it, Field<Position> p) =>
 </ul>
 </div>
 
-Filters can use operators to exclude components, optionally match components or match one out of a list of components. Additionally filters may contain wildcards for terms which is especially useful when combined with pairs.
+Querys can use operators to exclude components, optionally match components or match one out of a list of components. Additionally filters may contain wildcards for terms which is especially useful when combined with pairs.
 
 The following example shows a filter that matches all entities with a parent that do not have `Position`:
 <div class="flecs-snippet-tabs">
@@ -1192,7 +1193,7 @@ The following example shows a filter that matches all entities with a parent tha
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+ecs_query_t *f = ecs_query_init(world, &(ecs_query_desc_t){
     .terms = {
         { ecs_pair(EcsChildOf, EcsWildcard) }
         { ecs_id(Position), .oper = EcsNot },
@@ -1205,7 +1206,7 @@ ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
 <li><b class="tab-title">C++</b>
 
 ```cpp
-auto f = world.filter_builder<>()
+auto f = world.query_builder<>()
     .term(flecs::ChildOf, flecs::Wildcard)
     .term<Position>().oper(flecs::Not)
     .build();
@@ -1237,8 +1238,8 @@ The API for queries is similar to filters:
 
 ```c
 // Create a query with 2 terms
-ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-    .filter.terms = {
+ecs_query_t *q = ecs_query(world, {
+    .terms = {
         { ecs_id(Position) },
         { ecs_pair(EcsChildOf, EcsWildcard) }
     }
@@ -1292,7 +1293,7 @@ ecs_run(world, Move, delta_time, NULL); // Run system
 
 // Option 2, use the ecs_system_init function/ecs_system macro
 ecs_entity_t move_sys = ecs_system(world, {
-    .query.filter.terms = {
+    .query.terms = {
         {ecs_id(Position)},
         {ecs_id(Velocity)},
     },
@@ -1303,8 +1304,8 @@ ecs_run(world, move_sys, delta_time, NULL); // Run system
 
 // The callback code (same for both options)
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i++) {
         p[i].x += v[i].x * it->delta_time;
@@ -1507,14 +1508,14 @@ An example of an observer with two components:
 
 ```c
 ecs_observer(world, {
-    .filter.terms = { { ecs_id(Position) }, { ecs_id(Velocity) }},
+    .terms = { { ecs_id(Position) }, { ecs_id(Velocity) }},
     .event = EcsOnSet,
     .callback = OnSetPosition
 });
 
 // Callback code is same as system
 
-ecs_entity_t e = ecs_new_id(world);    // Doesn't invoke the observer
+ecs_entity_t e = ecs_new(world);    // Doesn't invoke the observer
 ecs_set(world, e, Position, {10, 20}); // Doesn't invoke the observer
 ecs_set(world, e, Velocity, {1, 2});   // Invokes the observer
 ecs_set(world, e, Position, {20, 40}); // Invokes the observer
diff --git a/docs/Relationships.md b/docs/Relationships.md
index b535b50c5..47676754f 100644
--- a/docs/Relationships.md
+++ b/docs/Relationships.md
@@ -32,9 +32,9 @@ The following code is a simple example that uses relationships:
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Likes = ecs_new_id(world);
-ecs_entity_t Bob = ecs_new_id(world);
-ecs_entity_t Alice = ecs_new_id(world);
+ecs_entity_t Likes = ecs_new(world);
+ecs_entity_t Bob = ecs_new(world);
+ecs_entity_t Alice = ecs_new(world);
 
 // Bob Likes Alice
 ecs_add_pair(world, Bob, Likes, Alice);
@@ -86,10 +86,10 @@ The same relationship can be added multiple times to an entity, as long as its t
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Bob = ecs_new_id(world);
-ecs_entity_t Eats = ecs_new_id(world);
-ecs_entity_t Apples = ecs_new_id(world);
-ecs_entity_t Pears = ecs_new_id(world);
+ecs_entity_t Bob = ecs_new(world);
+ecs_entity_t Eats = ecs_new(world);
+ecs_entity_t Apples = ecs_new(world);
+ecs_entity_t Pears = ecs_new(world);
 
 ecs_add_pair(world, Bob, Eats, Apples);
 ecs_add_pair(world, Bob, Eats, Pears);
@@ -142,14 +142,14 @@ An application can query for relationships with the `(Relationship, Target)` not
 
 ```c
 // Find all entities that eat apples
-ecs_query_t *q = ecs_query_new(world, "(Eats, Apples)");
+ecs_query_t *q = ecs_query(world, { .expr = "(Eats, Apples)" });
 
 // Find all entities that eat anything
-ecs_query_t *q = ecs_query_new(world, "(Eats, *)");
+ecs_query_t *q = ecs_query(world, { .expr = "(Eats, *)" });
 
-// Or with the ecs_query_init function:
-ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-    .filter.terms = {{ecs_pair(Eats, Apples)}}
+// Or with the ecs_query_cache_init function:
+ecs_query_t *q = ecs_query(world, {
+    .terms = {{ecs_pair(Eats, Apples)}}
 });
 ```
 
@@ -437,25 +437,25 @@ Bob.Each((Id id) =>
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms[0] = ecs_pair(Eats, Apples)
 });
 
-ecs_iter_t it = ecs_filter_iter(world, f);
-while (ecs_filter_next(&it)) {
+ecs_iter_t it = ecs_query_iter(world, f);
+while (ecs_query_next(&it)) {
   for (int i = 0; i < it.count; i ++) {
     // Iterate as usual
   }
 }
 
-ecs_filter_fini(f);
+ecs_query_fini(f);
 ```
 
 </li>
 <li><b class="tab-title">C++</b>
 
 ```cpp
-world.filter_builder()
+world.query_builder()
   .term(Eats, Apples)
   .build()
   .each([](flecs::entity e) {
@@ -487,30 +487,30 @@ world.FilterBuilder()
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_filter_t *f = ecs_filter(world, {
+ecs_query_t *f = ecs_query(world, {
   .terms[0] = ecs_pair(Eats, EcsWildcard)
 });
 
-ecs_iter_t it = ecs_filter_iter(world, f);
-while (ecs_filter_next(&it)) {
-  ecs_id_t pair_id = ecs_field_id(&it, 1);
+ecs_iter_t it = ecs_query_iter(world, f);
+while (ecs_query_next(&it)) {
+  ecs_id_t pair_id = ecs_field_id(&it, 0);
   ecs_entity_t food = ecs_pair_second(world, pair_id); // Apples, ...
   for (int i = 0; i < it.count; i ++) {
     // Iterate as usual
   }
 }
-ecs_filter_fini(f);
+ecs_query_fini(f);
 ```
 
 </li>
 <li><b class="tab-title">C++</b>
 
 ```cpp
-world.filter_builder()
+world.query_builder()
   .term(Eats, flecs::Wildcard)
   .build()
   .each([](flecs::iter& it, size_t i) {
-    flecs::entity food = it.pair(1).second(); // Apples, ...
+    flecs::entity food = it.pair(0).second(); // Apples, ...
     flecs::entity e = it.entity(i);
     // Iterate as usual
   });
@@ -604,12 +604,12 @@ ECS_COMPONENT(world, Position);
 ECS_COMPONENT(world, Eats);
 
 // Tags
-ecs_entity_t Likes = ecs_new_id(world);
-ecs_entity_t Begin = ecs_new_id(world);
-ecs_entity_t End = ecs_new_id(world);
-ecs_entity_t Apples = ecs_new_id(world);
+ecs_entity_t Likes = ecs_new(world);
+ecs_entity_t Begin = ecs_new(world);
+ecs_entity_t End = ecs_new(world);
+ecs_entity_t Apples = ecs_new(world);
 
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 
 // Both Likes and Apples are tags, so (Likes, Apples) is a tag
 ecs_add_pair(world, e, Likes, Apples);
@@ -712,11 +712,11 @@ typedef struct {
   float y;
 } Position;
 
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 
-ecs_entity_t first = ecs_new_id(world);
-ecs_entity_t second = ecs_new_id(world);
-ecs_entity_t third = ecs_new_id(world);
+ecs_entity_t first = ecs_new(world);
+ecs_entity_t second = ecs_new(world);
+ecs_entity_t third = ecs_new(world);
 
 // Add component position 3 times, for 3 different objects
 ecs_add_pair(world, e, Position, first, {1, 2});
@@ -775,8 +775,8 @@ When querying for relationship pairs, it is often useful to be able to find all
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-  .filter.terms = {
+ecs_query_t *q = ecs_query(world, {
+  .terms = {
     {ecs_pair(Likes, EcsWildcard)}
   }
 });
@@ -784,7 +784,7 @@ ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
 ecs_iter_t it = ecs_query_iter(world, q);
 
 while (ecs_query_next(&it)) {
-  ecs_id_t id = ecs_field_id(&it, 1); // Obtain pair id
+  ecs_id_t id = ecs_field_id(&it, 0); // Obtain pair id
 
   // Get relationship & target
   ecs_entity_t rel = ecs_pair_first(world, id);
@@ -808,7 +808,7 @@ auto q = world.query_builder()
   .build();
 
 q.iter([](flecs::iter& it) {
-  auto id = it.pair(1);
+  auto id = it.pair(0);
 
   for (auto i : it) {
     cout << "entity " << it.entity(i) << " has relationship "
@@ -846,8 +846,8 @@ Wildcards may appear in query expressions, using the `*` character:
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-  .filter.expr = "(Likes, *)"
+ecs_query_t *q = ecs_query(world, {
+  .query.expr = "(Likes, *)"
 });
 ```
 
@@ -886,11 +886,11 @@ An application can use pair wildcard expressions to find all instances of a rela
 
 ```c
 // Bob eats apples and pears
-ecs_entity_t Eats = ecs_new_entity(world, "Eats");
-ecs_entity_t Apples = ecs_new_entity(world, "Apples");
-ecs_entity_t Pears = ecs_new_entity(world, "Pears");
+ecs_entity_t Eats = ecs_entity(world, { .name = "Eats" });
+ecs_entity_t Apples = ecs_entity(world, { .name = "Apples" });
+ecs_entity_t Pears = ecs_entity(world, { .name = "Pears" });
 
-ecs_entity_t Bob = ecs_new_id(world);
+ecs_entity_t Bob = ecs_new(world);
 ecs_add_pair(world, Bob, Eats, Apples);
 ecs_add_pair(world, Bob, Eats, Pears);
 
@@ -966,8 +966,8 @@ The `IsA` relationship is a builtin relationship that allows applications to exp
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Apple = ecs_new_id(world);
-ecs_entity_t Fruit = ecs_new_id(world);
+ecs_entity_t Apple = ecs_new(world);
+ecs_entity_t Fruit = ecs_new(world);
 ecs_add_pair(world, Apple, EcsIsA, Fruit);
 ```
 
@@ -1023,7 +1023,7 @@ We can also add `IsA` relationships to `Apple`:
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t GrannySmith = ecs_new_id(world);
+ecs_entity_t GrannySmith = ecs_new(world);
 ecs_add_pair(world, GrannySmith, EcsIsA, Apple);
 ```
 
@@ -1057,11 +1057,11 @@ An entity with an `IsA` relationship to another entity is equivalent to the othe
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Spaceship = ecs_new_id(world);
+ecs_entity_t Spaceship = ecs_new(world);
 ecs_set(world, Spaceship, MaxSpeed, {100});
 ecs_set(world, SpaceShip, Defense, {50});
 
-ecs_entity_t Frigate = ecs_new_id(world);
+ecs_entity_t Frigate = ecs_new(world);
 ecs_add(world, Frigate, EcsIsA, Spaceship);
 ecs_set(world, Frigate, Defense, {100});
 ```
@@ -1170,7 +1170,7 @@ The ability to share components is also applied transitively, so `Frigate` could
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t FastFrigate = ecs_new_id(world);
+ecs_entity_t FastFrigate = ecs_new(world);
 ecs_add(world, FastFrigate, EcsIsA, Frigate);
 ecs_set(world, FastFrigate, MaxSpeed, {200});
 
@@ -1231,8 +1231,8 @@ The `ChildOf` relationship is the builtin relationship that allows for the creat
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Spaceship = ecs_new_id(world);
-ecs_entity_t Cockpit = ecs_new_id(world);
+ecs_entity_t Spaceship = ecs_new(world);
+ecs_entity_t Cockpit = ecs_new(world);
 
 ecs_add_pair(world, Cockpit, EcsChildOf, Spaceship);
 ```
@@ -1346,13 +1346,13 @@ In some scenarios a number of entities all need to be created with the same pare
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t parent = ecs_new_id(world);
+ecs_entity_t parent = ecs_new(world);
 ecs_entity_t prev = ecs_set_scope(world, parent);
 
 // Note that we're not using the ecs_new_id function for the children. This
 // function only generates a new id, and does not add the scope to the entity.
-ecs_entity_t child_a = ecs_new(world, 0);
-ecs_entity_t child_b = ecs_new(world, 0);
+ecs_entity_t child_a = ecs_new(world);
+ecs_entity_t child_b = ecs_new(world);
 
 // Restore the previous scope
 ecs_set_scope(world, prev);
@@ -1663,7 +1663,7 @@ world.Component<Archer>().Entity.Destruct();
 ECS_TAG(world, ChildOf);
 ecs_add_pair(world, ChildOf, EcsOnDeleteTarget, EcsDelete);
 
-ecs_entity_t p = ecs_new_id(world);
+ecs_entity_t p = ecs_new(world);
 ecs_entity_t e = ecs_new_w_pair(world, ChildOf, p);
 
 // This will delete both p and e
@@ -1760,10 +1760,10 @@ To understand why some ways to organize entities work better than others, having
 1. **Find all root entities**
 World teardown starts by finding all root entities, which are entities that do not have the builtin `ChildOf` relationship. Note that empty entities (entities without any components) are not found during this step.
 
-2. **Filter out modules, components, observers and systems**
+2. **Query out modules, components, observers and systems**
 This ensures that components are not cleaned up before the entities that use them, and triggers, observers and systems are not cleaned up while there are still conditions under which they could be invoked.
 
-3. **Filter out entities that have no children**
+3. **Query out entities that have no children**
 If entities have no children they cannot cause complex cleanup logic. This also decreases the likelihood of initiating cleanup actions that could impact other entities.
 
 4. **Delete root entities**
@@ -1947,9 +1947,8 @@ Entity e = ecs.Entity()
 </ul>
 </div>
 
-
-### Tag property
-A relationship can be marked as a tag in which case it will never contain data. By default the data associated with a pair is determined by whether either the relationship or target are components. For some relationships however, even if the target is a component, no data should be added to the relationship. Consider the following example:
+### PairIsTag property
+A relationship can be marked with PairIsTag in which case a pair with the relationship will never contain data. By default the data associated with a pair is determined by whether either the relationship or target are components. For some relationships however, even if the target is a component, no data should be added to the relationship. Consider the following example:
 
 <div class="flecs-snippet-tabs">
 <ul>
@@ -1964,7 +1963,7 @@ typedef struct {
 ECS_TAG(world, Serializable);
 ECS_COMPONENT(world, Position);
 
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 ecs_set(world, e, Position, {10, 20});
 ecs_add_pair(world, e, Serializable, ecs_id(Position));
 
@@ -1972,7 +1971,7 @@ ecs_add_pair(world, e, Serializable, ecs_id(Position));
 const Position *p = ecs_get(world, e, Position);
 
 // Gets (unintended) value from (Serializable, Position) pair
-const Position *p = ecs_get_pair_object(world, e, Serializable, Position);
+const Position *p = ecs_get_pair_second(world, e, Serializable, Position);
 ```
 
 </li>
@@ -2029,7 +2028,7 @@ To prevent data from being associated with pairs that can apply to components, t
 
 ```c
 // Ensure that Serializable never contains data
-ecs_add_id(world, Serializable, EcsTag);
+ecs_add_id(world, Serializable, EcsPairIsTag);
 
 // Because Serializable is marked as a Tag, no data is added for the pair
 // even though Position is a component
@@ -2039,7 +2038,7 @@ ecs_add_pair(world, e, Serializable, ecs_id(Position));
 const Position *p = ecs_get(world, e, Position);
 
 // This no longer works, the pair has no data
-const Position *p = ecs_get_pair_object(world, e, Serializable, Position);
+const Position *p = ecs_get_pair_second(world, e, Serializable, Position);
 ```
 
 </li>
@@ -2048,7 +2047,7 @@ const Position *p = ecs_get_pair_object(world, e, Serializable, Position);
 ```cpp
 // Ensure that Serializable never contains data
 ecs.component<Serializable>()
-  .add<flecs::Tag>();
+  .add<flecs::PairIsTag>();
 
 auto e = ecs.entity()
   .set<Position>({10, 20})
@@ -2098,10 +2097,10 @@ Entities can be annotated with the `Final` property, which prevents using them w
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 ecs_add_id(world, e, EcsFinal);
 
-ecs_entity_t i = ecs_new_id(world);
+ecs_entity_t i = ecs_new(world);
 ecs_add_pair(world, e, i, EcsIsA, e); // not allowed
 ```
 
@@ -2141,11 +2140,11 @@ The `DontInherit` property prevents inheriting a component from a base entity (`
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t TagA = ecs_new_id(world);
-ecs_entity_t TagB = ecs_new_id(world);
+ecs_entity_t TagA = ecs_new(world);
+ecs_entity_t TagB = ecs_new(world);
 ecs_add_id(world, TagB, EcsDontInherit);
 
-ecs_entity_t base = ecs_new_id(world);
+ecs_entity_t base = ecs_new(world);
 ecs_add_id(world, base, TagA);
 ecs_add_id(world, base, TagB);
 
@@ -2209,7 +2208,7 @@ ECS_COMPONENT(world, Velocity);
 
 ecs_add_id(world, ecs_id(Position), EcsAlwaysOverride);
 
-ecs_entity_t base = ecs_new_id(world);
+ecs_entity_t base = ecs_new(world);
 ecs_set(world, base, Position, {10, 20});
 ecs_set(world, base, Velocity, {1, 2});
 
@@ -2286,10 +2285,10 @@ When relationships in Flecs are marked as transitive, queries can follow the tra
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t LocatedIn = ecs_new_id(world);
-ecs_entity_t Manhattan = ecs_new_id(world);
-ecs_entity_t NewYork = ecs_new_id(world);
-ecs_entity_t USA = ecs_new_id(world);
+ecs_entity_t LocatedIn = ecs_new(world);
+ecs_entity_t Manhattan = ecs_new(world);
+ecs_entity_t NewYork = ecs_new(world);
+ecs_entity_t USA = ecs_new(world);
 
 ecs_add_pair(world, Manhattan, LocatedIn, NewYork);
 ecs_add_pair(world, NewYork, LocatedIn, USA);
@@ -2438,7 +2437,7 @@ To create a custom exclusive relationship, add the `Exclusive` property:
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t MarriedTo = ecs_new_id(world);
+ecs_entity_t MarriedTo = ecs_new(world);
 ecs_add_id(world, MarriedTo, EcsExclusive);
 ```
 
@@ -2472,13 +2471,13 @@ The API for using the `Union` property is similar to regular relationships, as t
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Movement = ecs_new_id(world);
+ecs_entity_t Movement = ecs_new(world);
 ecs_add_id(world, Movement, EcsUnion);
 
-ecs_entity_t Walking = ecs_new_id(world);
-ecs_entity_t Running = ecs_new_id(world);
+ecs_entity_t Walking = ecs_new(world);
+ecs_entity_t Running = ecs_new(world);
 
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 ecs_add_pair(world, e, Movement, Running);
 ecs_add_pair(world, e, Movement, Walking); // replaces (Movement, Running)
 ```
@@ -2514,7 +2513,7 @@ e.Add(Movement, Walking); // replaces (Movement, Running)
 When compared to regular relationships, union relationships have some differences and limitations:
 - Relationship cleanup does not work yet for union relationships
 - Removing a union relationship removes any target, even if the specified target is different
-- Filters and rules do not support union relationships
+- Querys and rules do not support union relationships
 - Union relationships cannot have data
 - Union relationship query terms can use only the `And` operator
 - Queries with a `(R, *)` term will return `(R, *)` as term id for each entity
@@ -2530,8 +2529,8 @@ The symmetric property is useful for relationships that do not make sense unless
 
 ```c
 ecs_entity_t MarriedTo = ecs_new_w_id(world, EcsSymmetric);
-ecs_entity_t Bob = ecs_new_id(world);
-ecs_entity_t Alice = ecs_new_id(world);
+ecs_entity_t Bob = ecs_new(world);
+ecs_entity_t Alice = ecs_new(world);
 ecs_add_pair(world, Bob, MarriedTo, Alice); // Also adds (MarriedTo, Bob) to Alice
 ```
 
@@ -2567,7 +2566,7 @@ The `With` relationship can be added to components to indicate that it must alwa
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Responsibility = ecs_new_id(world);
+ecs_entity_t Responsibility = ecs_new(world);
 ecs_entity_t Power = ecs_new_w_pair(world, EcsWith, Responsibility);
 
 // Create new entity that has both Power and Responsibility
@@ -2607,9 +2606,9 @@ When the `With` relationship is added to a relationship, the additional id added
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Likes = ecs_new_id(world);
+ecs_entity_t Likes = ecs_new(world);
 ecs_entity_t Loves = ecs_new_w_pair(world, EcsWith, Likes);
-ecs_entity_t Pears = ecs_new_id(world);
+ecs_entity_t Pears = ecs_new(world);
 
 // Create new entity with both (Loves, Pears) and (Likes, Pears)
 ecs_entity_t e = ecs_new_w_pair(world, Loves, Pears);
@@ -2653,13 +2652,13 @@ The following example shows how to constrain the relationship target to a child
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Food = ecs_new_id(world);
+ecs_entity_t Food = ecs_new(world);
 
 // Enforce that target of relationship is child of Food
 ecs_add_id(world, Food, EcsOneOf);
 
 ecs_entity_t Apples = ecs_new_w_pair(world, EcsChildOf, Food);
-ecs_entity_t Fork = ecs_new_id(world);
+ecs_entity_t Fork = ecs_new(world);
 
 // This is ok, Apples is a child of Food
 ecs_entity_t a = ecs_new_w_pair(world, Food, Apples);
@@ -2711,14 +2710,14 @@ The following example shows how `OneOf` can be used to enforce that the relation
 <li><b class="tab-title">C</b>
 
 ```c
-ecs_entity_t Food = ecs_new_id(world);
-ecs_entity_t Eats = ecs_new_id(world);
+ecs_entity_t Food = ecs_new(world);
+ecs_entity_t Eats = ecs_new(world);
 
 // Enforce that target of relationship is child of Food
 ecs_add_pair(world, Eats, EcsOneOf, Food);
 
 ecs_entity_t Apples = ecs_new_w_pair(world, EcsChildOf, Food);
-ecs_entity_t Fork = ecs_new_id(world);
+ecs_entity_t Fork = ecs_new(world);
 
 // This is ok, Apples is a child of Food
 ecs_entity_t a = ecs_new_w_pair(world, Eats, Apples);
@@ -2786,11 +2785,11 @@ Because of this, adding/removing relationships to entities has the same performa
 ECS_COMPONENT(world, Position);
 
 // Tags
-ecs_entity_t Likes = ecs_new_id(world);
-ecs_entity_t Apples = ecs_new_id(world);
-ecs_entity_t Npc = ecs_new_id(world);
+ecs_entity_t Likes = ecs_new(world);
+ecs_entity_t Apples = ecs_new(world);
+ecs_entity_t Npc = ecs_new(world);
 
-ecs_entity_t e = ecs_new_id(world);
+ecs_entity_t e = ecs_new(world);
 
 // The ecs_add_id function can be used to add one id to another
 ecs_add_id(world, e, Npc);
diff --git a/docs/RestApi.md b/docs/RestApi.md
index fc7e6a7d9..ed3a8162a 100644
--- a/docs/RestApi.md
+++ b/docs/RestApi.md
@@ -185,7 +185,7 @@ In C this is done by setting the `.entity` field to a named entity:
 ```c
 ecs_query_t *q = ecs_query(world, {
   .entity = ecs_entity(world, { .name = "Move" }),
-  .filter.terms = {
+  .terms = {
     { ecs_id(Position) },
     { ecs_id(Velocity) },
   }
@@ -215,14 +215,14 @@ This also works for filters and rules. Because systems are queries, the name of
 
 ![Remote Explorer](img/explorer-system.png)
 
-When a named rule query has variables, variables can be optionally provided as arguments to the query. The following example provides the value `Apples` to the query variable `food` for query `eats_query`, which constrains the results to only show results with `Apples`:
+When a named query has variables, variables can be optionally provided as arguments to the query. The following example provides the value `Apples` to the query variable `food` for query `eats_query`, which constrains the results to only show results with `Apples`:
 
 ![Remote Explorer](img/explorer-arguments.png)
 
 The underlying query that was used for this screenshot was created like this:
 
 ```c
-ecs_rule(world, {
+ecs_query(world, {
     .entity = ecs_entity(world, { .name = "eats_query" }),
     .expr = "(Eats, $food)"
 });
diff --git a/docs/Systems.md b/docs/Systems.md
index 0c1470edb..8cfffa73e 100644
--- a/docs/Systems.md
+++ b/docs/Systems.md
@@ -10,8 +10,8 @@ An example of a simple system:
 // System implementation
 void Move(ecs_iter_t *it) {
     // Get fields from system query
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     // Iterate matched entities
     for (int i = 0; i < it->count, i++) {
@@ -30,9 +30,9 @@ In C, a system can also be created with the `ecs_system_init` function / `ecs_sy
 ecs_entity_t ecs_id(Move) = ecs_system(world, {
     .entity = ecs_entity(world, { /* ecs_entity_desc_t */
         .name = "Move",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
-    .query.filter.terms = { /* ecs_filter_desc_t::terms */
+    .query.terms = { /* ecs_query_desc_t::terms */
         { ecs_id(Position) },
         { ecs_id(Velocity), .inout = EcsIn }
     }
@@ -161,8 +161,8 @@ ecs_iter_t it = ecs_query_iter(world, q);
 // Iterate tables matched by query
 while (ecs_query_next(&it)) {
     // Get fields from query
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     // Iterate matched entities
     for (int i = 0; i < it->count, i++) {
@@ -174,8 +174,8 @@ while (ecs_query_next(&it)) {
 // System code
 void Move(ecs_iter_t *it) {
     // Get fields from system query
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     // Iterate matched entities
     for (int i = 0; i < it->count, i++) {
@@ -265,8 +265,8 @@ A system provides a `delta_time` which contains the time passed since the last f
 <li><b class="tab-title">C</b>
 
 ```c
-Position *p = ecs_field(it, Position, 1);
-Velocity *v = ecs_field(it, Velocity, 2);
+Position *p = ecs_field(it, Position, 0);
+Velocity *v = ecs_field(it, Velocity, 1);
 
 for (int i = 0; i < it->count, i++) {
     p[i].x += v[i].x * it->delta_time;
@@ -385,7 +385,7 @@ ECS_SYSTEM(world, PrintTime, EcsOnUpdate, 0);
 ecs_system(world, {
     .entity = ecs_entity(world, {
         .name = "PrintTime",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
     .callback = PrintTime
 });
@@ -433,7 +433,7 @@ Tasks may query for components from a fixed source or singleton:
 // System function
 void PrintTime(ecs_iter_t *it) {
     // Get singleton component
-    Game *g = ecs_field(it, Game, 1);
+    Game *g = ecs_field(it, Game, 0);
 
     printf("Time: %f\n", g->time);
 }
@@ -445,9 +445,9 @@ ECS_SYSTEM(world, PrintTime, EcsOnUpdate, Game($));
 ecs_system(world, {
     .entity = ecs_entity(world, {
         .name = "PrintTime",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
-    .query.filter.terms = {
+    .query.terms = {
         { .id = ecs_id(Game), .src.id = ecs_id(Game) } // Singleton source
     },
     .callback = PrintTime
@@ -458,7 +458,7 @@ ecs_system(world, {
 
 ```cpp
 world.system<Game>("PrintTime")
-    .term_at(1).singleton()
+    .term_at(0).singleton()
     .kind(flecs::OnUpdate)
     .iter([](flecs::iter& it, Game *g) {
         printf("Time: %f\n", g->time);
@@ -608,11 +608,11 @@ The builtin pipeline query looks like this:
 
 ```c
 ecs_pipeline_init(world, &(ecs_pipeline_desc_t){
-    .query.filter.terms = {
+    .query.terms = {
         { .id = EcsSystem },
-        { .id = EcsPhase, .src.flags = EcsCascade, .src.trav = EcsDependsOn },
-        { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsDependsOn, .oper = EcsNot },
-        { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsChildOf, .oper = EcsNot }
+        { .id = EcsPhase, .src.flags = EcsCascade, .trav = EcsDependsOn },
+        { .id = EcsDisabled, .src.flags = EcsUp, .trav = EcsDependsOn, .oper = EcsNot },
+        { .id = EcsDisabled, .src.flags = EcsUp, .trav = EcsChildOf, .oper = EcsNot }
     }
 });
 ```
@@ -659,7 +659,7 @@ ECS_TAG(world, Foo);
 
 // Create custom pipeline
 ecs_entity_t pipeline = ecs_pipeline_init(world, &(ecs_pipeline_desc_t){
-    .query.filter.terms = {
+    .query.terms = {
         { .id = EcsSystem }, // mandatory
         { .id = Foo }
     }
@@ -840,7 +840,7 @@ There are a number of things applications can do to force merging of operations,
 1. Commands to be merged before another system
 2. Operations not to be enqueued as commands.
 
-The mechanisms to accomplish this are sync points for 1), and `no_readonly` systems for 2).
+The mechanisms to accomplish this are sync points for 1), and `immediate` systems for 2).
 
 ### Sync points
 Sync points are moments during the frame where all commands are flushed to the storage. Systems that run after a sync point will be able to see all operations that happened up until the sync point. Sync points are inserted automatically by analyzing which commands could have been inserted and which components are being read by systems.
@@ -868,7 +868,7 @@ ECS_SYSTEM(world, SetTransform, EcsOnUpdate, Position, [out] Transform());
 // When using the descriptor API for creating the system, set the EcsIsEntity
 // flag while leaving the id field to 0. This is equivalent to doing `()` in the DSL.
 ecs_system(world, {
-    .query.filter.terms = {
+    .query.terms = {
         { ecs_id(Position) },
         {
             .inout = EcsOut,
@@ -912,7 +912,7 @@ ECS_SYSTEM(world, SetTransform, EcsOnUpdate, Position, [in] Transform());
 ```
 ```c
 ecs_system(world, {
-    .query.filter.terms = {
+    .query.terms = {
         { ecs_id(Position) },
         {
             .inout = EcsIn,
@@ -951,14 +951,14 @@ By default systems are ran while the world is in "readonly" mode, where all ECS
 
 In some cases however, operations need to be immediately visible to a system. A typical example is a system that assigns tasks to resources, like assigning plates to a waiter. A system should only assign plates to a waiter that hasn't been assigned any plates yet, but to know which waiters are free, the operation that assigns a plate to a waiter must be immediately visible.
 
-To accomplish this, systems can be marked with the `no_readonly` flag, which signals that a system should be ran while the world is not in readonly mode. This causes ECS operations to not get enqueued, and allows the system to directly see the results of operations. There are a few limitations to `no_readonly` systems:
+To accomplish this, systems can be marked with the `immediate` flag, which signals that a system should be ran while the world is not in readonly mode. This causes ECS operations to not get enqueued, and allows the system to directly see the results of operations. There are a few limitations to `immediate` systems:
 
-- `no_readonly` systems are always single threaded
+- `immediate` systems are always single threaded
 - operations on the iterated over entity must still be deferred
 
 The reason for the latter limitation is that allowing for operations on the iterated over entity would cause the system to modify the storage it is iterating, which could cause undefined behavior similar to what you'd see when changing a vector while iterating it.
 
-The following example shows how to create a `no_readonly` system:
+The following example shows how to create a `immediate` system:
 <div class="flecs-snippet-tabs">
 <ul>
 <li><b class="tab-title">C</b>
@@ -967,13 +967,13 @@ The following example shows how to create a `no_readonly` system:
 ecs_system(ecs, {
     .entity = ecs_entity(ecs, {
         .name = "AssignPlate",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
-    .query.filter.terms = {
+    .query.terms = {
         { .id = Plate },
     },
     .callback = AssignPlate,
-    .no_readonly = true // disable readonly mode for this system
+    .immediate = true // disable readonly mode for this system
 });
 ```
 </li>
@@ -982,7 +982,7 @@ ecs_system(ecs, {
 ```cpp
     ecs.system("AssignPlate")
         .with<Plate>()
-        .no_readonly() // disable readonly mode for this system
+        .immediate() // disable readonly mode for this system
         .iter([&](flecs::iter& it) { /* ... */ })
 ```
 </li>
@@ -1048,7 +1048,7 @@ void AssignPlate(ecs_iter_t *it) {
 </ul>
 </div>
 
-Note that `defer_suspend` and `defer_resume` may only be called from within a `no_readonly` system.
+Note that `defer_suspend` and `defer_resume` may only be called from within a `immediate` system.
 
 ### Threading
 Systems in Flecs can be multithreaded. This requires both the system to be created as a multithreaded system, as well as configuring the world to have a number of worker threads. To create worker threads, use the `set_threads` function:
@@ -1083,9 +1083,9 @@ To create a multithreaded system, use the `multi_threaded` flag:
 ```c
 ecs_system(ecs, {
     .entity = ecs_entity(ecs, {
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
-    .query.filter.terms = {
+    .query.terms = {
         { .id = ecs_id(Position) }
     },
     .callback = Dummy,
@@ -1168,9 +1168,9 @@ ecs_set_interval(world, ecs_id(Move), 1.0); // Run at 1Hz
 ecs_system(world, {
     .entity = ecs_entity(world, {
         .name = "Move",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
-    .query.filter.terms = {
+    .query.terms = {
         { ecs_id(Position) }, 
         { ecs_id(Velocity), .inout = EcsIn }
     },
@@ -1214,9 +1214,9 @@ ecs_set_rate(world, ecs_id(Move), 2); // Run every other frame
 ecs_system(world, {
     .entity = ecs_entity(world, {
         .name = "Move",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
-    .query.filter.terms = {
+    .query.terms = {
         { ecs_id(Position) }, 
         { ecs_id(Velocity), .inout = EcsIn }
     },
@@ -1270,9 +1270,9 @@ ecs_entity_t tick_source = ecs_set_interval(world, 0, 1.0);
 ecs_system(world, {
     .entity = ecs_entity(world, {
         .name = "Move",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
-    .query.filter.terms = {
+    .query.terms = {
         { ecs_id(Position) }, 
         { ecs_id(Velocity), .inout = EcsIn }
     },
@@ -1410,7 +1410,7 @@ Systems can also act as each others tick source:
 ecs_entity_t each_second = ecs_system(world, {
     .entity = ecs_entity(world, {
         .name = "EachSecond",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
     .callback = Dummy,
     .interval = 1.0
@@ -1420,7 +1420,7 @@ ecs_entity_t each_second = ecs_system(world, {
 ecs_entity_t each_minute = ecs_system(world, {
     .entity = ecs_entity(world, {
         .name = "EachMinute",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
     .callback = Dummy,
     .tick_source = each_second,
@@ -1431,7 +1431,7 @@ ecs_entity_t each_minute = ecs_system(world, {
 ecs_entity_t each_hour = ecs_system(world, {
     .entity = ecs_entity(world, {
         .name = "EachHour",
-        .add = { ecs_dependson(EcsOnUpdate) }
+        .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
     }),
     .callback = Dummy,
     .tick_source = each_minute,
diff --git a/docs/cfg/Doxyfile b/docs/cfg/Doxyfile
index f7c2f8de2..ce9cc480a 100644
--- a/docs/cfg/Doxyfile
+++ b/docs/cfg/Doxyfile
@@ -1650,7 +1650,7 @@ QHP_VIRTUAL_FOLDER     = doc
 
 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
 # filter to add. For more information please see Qt Help Project / Custom
-# Filters (see:
+# Querys (see:
 # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1658,14 +1658,14 @@ QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see:
+# Querys (see:
 # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_ATTRS  =
 
 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
-# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# project's filter section matches. Qt Help Project / Query Attributes (see:
 # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -2428,22 +2428,18 @@ INCLUDE_FILE_PATTERNS  =
 
 PREDEFINED             = FLECS_APP \
                          FLECS_DOC \
-                         FLECS_EXPR \
                          FLECS_HTTP \
                          FLECS_JOURNAL \
                          FLECS_JSON \
                          FLECS_LOG \
                          FLECS_META \
-                         FLECS_META_C \
                          FLECS_MODULE \
                          FLECS_MONITOR \
                          FLECS_OS_API_IMPL \
-                         FLECS_PARSER \
                          FLECS_PIPELINE \
-                         FLECS_PLECS \
+                         FLECS_SCRIPT \
                          FLECS_REST \
                          FLECS_RULES \
-                         FLECS_SNAPSHOT \
                          FLECS_STATS \
                          FLECS_SYSTEM \
                          FLECS_TIMER \
diff --git a/examples/c/entities/basics/include/basics/bake_config.h b/examples/c/entities/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/c/entities/basics/include/basics/bake_config.h
+++ b/examples/c/entities/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/entities/basics/src/main.c b/examples/c/entities/basics/src/main.c
index 4db7f4c1f..bd97625d6 100644
--- a/examples/c/entities/basics/src/main.c
+++ b/examples/c/entities/basics/src/main.c
@@ -42,9 +42,9 @@ int main(int argc, char *argv[]) {
     ecs_remove(ecs, alice, Walking);
 
     // Iterate all entities with Position
-    ecs_iter_t it = ecs_term_iter(ecs, &(ecs_term_t){ .id = ecs_id(Position) });
-    while (ecs_term_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+    ecs_iter_t it = ecs_each(ecs, Position);
+    while (ecs_each_next(&it)) {
+        Position *p = ecs_field(&it, Position, 0);
         for (int i = 0; i < it.count; i ++) {
             printf("%s: {%f, %f}\n", ecs_get_name(ecs, it.entities[i]),
                 p[i].x, p[i].y);
diff --git a/examples/c/entities/fwd_declare_component/include/fwd_declare_component/bake_config.h b/examples/c/entities/fwd_declare_component/include/fwd_declare_component/bake_config.h
index 8ebd1e8e5..600e6da4b 100644
--- a/examples/c/entities/fwd_declare_component/include/fwd_declare_component/bake_config.h
+++ b/examples/c/entities/fwd_declare_component/include/fwd_declare_component/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef FWD_DECLARE_COMPONENT_BAKE_CONFIG_H
-#define FWD_DECLARE_COMPONENT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef FWD_DECLARE_COMPONENT_BAKE_CONFIG_H
+#define FWD_DECLARE_COMPONENT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/entities/fwd_declare_component/src/main.c b/examples/c/entities/fwd_declare_component/src/main.c
index 0c12fa8a8..469caba20 100644
--- a/examples/c/entities/fwd_declare_component/src/main.c
+++ b/examples/c/entities/fwd_declare_component/src/main.c
@@ -38,7 +38,7 @@ ECS_DECLARE(Wizard);
 ecs_entity_t Platoon_1;
 
 ecs_entity_t create_npc(ecs_world_t *world) {
-    ecs_entity_t result = ecs_new(world, 0);
+    ecs_entity_t result = ecs_new(world);
     
     // Without the forward declaration, this would have thrown a compiler error
     ecs_set(world, result, Position, {10, 20});
@@ -62,7 +62,7 @@ int main(int argc, char *argv[]) {
     ECS_TAG_DEFINE(world, Wizard);
 
     // A forward declared entity can be assigned as any variable
-    Platoon_1 = ecs_new_id(world);
+    Platoon_1 = ecs_new(world);
 
     // Create new entity with Position
     ecs_entity_t e = create_npc(world);
diff --git a/examples/c/entities/hierarchy/include/hierarchy/bake_config.h b/examples/c/entities/hierarchy/include/hierarchy/bake_config.h
index 1e21b3812..6b3d117ad 100644
--- a/examples/c/entities/hierarchy/include/hierarchy/bake_config.h
+++ b/examples/c/entities/hierarchy/include/hierarchy/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HIERARCHY_BAKE_CONFIG_H
-#define HIERARCHY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HIERARCHY_BAKE_CONFIG_H
+#define HIERARCHY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/entities/hierarchy/src/main.c b/examples/c/entities/hierarchy/src/main.c
index 552dd86e9..baa226559 100644
--- a/examples/c/entities/hierarchy/src/main.c
+++ b/examples/c/entities/hierarchy/src/main.c
@@ -44,26 +44,26 @@ int main(int argc, char *argv[]) {
     // Hierarchies use ECS relationships and the builtin flecs::ChildOf relationship to
     // create entities as children of other entities.
 
-    ecs_entity_t sun = ecs_new_entity(ecs, "Sun");
+    ecs_entity_t sun = ecs_entity(ecs, { .name = "Sun" });
     ecs_add(ecs, sun, Star);
     ecs_set(ecs, sun, Position, {1, 1});
 
-        ecs_entity_t mercury = ecs_new_entity(ecs, "Mercury");
+        ecs_entity_t mercury = ecs_entity(ecs, { .name = "Mercury" });
         ecs_add_pair(ecs, mercury, EcsChildOf, sun);
         ecs_add(ecs, mercury, Planet);
         ecs_set(ecs, mercury, Position, {1, 1});
 
-        ecs_entity_t venus = ecs_new_entity(ecs, "Venus");
+        ecs_entity_t venus = ecs_entity(ecs, { .name = "Venus" });
         ecs_add_pair(ecs, venus, EcsChildOf, sun);
         ecs_add(ecs, venus, Planet);
         ecs_set(ecs, venus, Position, {2, 2});
 
-        ecs_entity_t earth = ecs_new_entity(ecs, "Earth");
+        ecs_entity_t earth = ecs_entity(ecs, { .name = "Earth" });
         ecs_add_pair(ecs, earth, EcsChildOf, sun);
         ecs_add(ecs, earth, Planet);
         ecs_set(ecs, earth, Position, {3, 3});
 
-            ecs_entity_t moon = ecs_new_entity(ecs, "Moon");
+            ecs_entity_t moon = ecs_entity(ecs, { .name = "Moon" });
             ecs_add_pair(ecs, moon, EcsChildOf, earth);
             ecs_add(ecs, moon, Moon);
             ecs_set(ecs, moon, Position, {0.1, 0.1});
diff --git a/examples/c/entities/hooks/include/hooks/bake_config.h b/examples/c/entities/hooks/include/hooks/bake_config.h
index bb272e239..e670a0dc2 100644
--- a/examples/c/entities/hooks/include/hooks/bake_config.h
+++ b/examples/c/entities/hooks/include/hooks/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HOOKS_BAKE_CONFIG_H
-#define HOOKS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HOOKS_BAKE_CONFIG_H
+#define HOOKS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/entities/hooks/src/main.c b/examples/c/entities/hooks/src/main.c
index 18513f533..68716242c 100644
--- a/examples/c/entities/hooks/src/main.c
+++ b/examples/c/entities/hooks/src/main.c
@@ -75,7 +75,7 @@ int main(int argc, char *argv[]) {
 
     ecs_log_set_level(0);
 
-    ecs_entity_t e = ecs_new_entity(world, "Entity");
+    ecs_entity_t e = ecs_entity(world, { .name = "Entity" });
 
     ecs_trace("ecs_add(world, e, String)");
     ecs_log_push();
diff --git a/examples/c/entities/iterate_components/include/iterate_components/bake_config.h b/examples/c/entities/iterate_components/include/iterate_components/bake_config.h
index 979ffc5d0..e64a5d8fa 100644
--- a/examples/c/entities/iterate_components/include/iterate_components/bake_config.h
+++ b/examples/c/entities/iterate_components/include/iterate_components/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef ITERATE_COMPONENTS_BAKE_CONFIG_H
-#define ITERATE_COMPONENTS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef ITERATE_COMPONENTS_BAKE_CONFIG_H
+#define ITERATE_COMPONENTS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/entities/iterate_components/src/main.c b/examples/c/entities/iterate_components/src/main.c
index 054ac25db..09fdfe142 100644
--- a/examples/c/entities/iterate_components/src/main.c
+++ b/examples/c/entities/iterate_components/src/main.c
@@ -66,7 +66,7 @@ int main(int argc, char *argv[]) {
     ECS_TAG(ecs, Apples);
 
     // Create an entity which all of the above
-    ecs_entity_t Bob = ecs_new_id(ecs);
+    ecs_entity_t Bob = ecs_new(ecs);
 
     ecs_set(ecs, Bob, Position, {10, 20});
     ecs_set(ecs, Bob, Velocity, {1, 1});
diff --git a/examples/c/explorer/include/explorer/bake_config.h b/examples/c/explorer/include/explorer/bake_config.h
index 546657fd5..aa6ff5edc 100644
--- a/examples/c/explorer/include/explorer/bake_config.h
+++ b/examples/c/explorer/include/explorer/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef EXPLORER_BAKE_CONFIG_H
-#define EXPLORER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef EXPLORER_BAKE_CONFIG_H
+#define EXPLORER_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/explorer/src/main.c b/examples/c/explorer/src/main.c
index 7f6417a6b..0dcb3d4fc 100644
--- a/examples/c/explorer/src/main.c
+++ b/examples/c/explorer/src/main.c
@@ -23,15 +23,15 @@ int main(int argc, char *argv[]) {
     });
 
     // Simple hierarchy
-    ecs_entity_t Sun = ecs_new_entity(world, "Sun");
+    ecs_entity_t Sun = ecs_entity(world, { .name = "Sun" });
     ecs_set(world, Sun, Mass, {1.988500e31});
 
     ecs_set_scope(world, Sun);
-    ecs_entity_t Earth = ecs_new_entity(world, "Earth");
+    ecs_entity_t Earth = ecs_entity(world, { .name = "Earth" });
     ecs_set(world, Earth, Mass, {5.9722e24});
 
     ecs_set_scope(world, Earth);
-    ecs_entity_t Moon = ecs_new_entity(world, "Moon");
+    ecs_entity_t Moon = ecs_entity(world, { .name = "Moon" });
     ecs_set(world, Moon, Mass, {7.34767309e22});
 
     // Restore default hierarchy scope to root
diff --git a/examples/c/hello_world/include/hello_world/bake_config.h b/examples/c/hello_world/include/hello_world/bake_config.h
index d149f44bd..3f4db37d0 100644
--- a/examples/c/hello_world/include/hello_world/bake_config.h
+++ b/examples/c/hello_world/include/hello_world/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HELLO_WORLD_BAKE_CONFIG_H
-#define HELLO_WORLD_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HELLO_WORLD_BAKE_CONFIG_H
+#define HELLO_WORLD_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/hello_world/src/main.c b/examples/c/hello_world/src/main.c
index 812c420d5..97d6c14f8 100644
--- a/examples/c/hello_world/src/main.c
+++ b/examples/c/hello_world/src/main.c
@@ -10,8 +10,8 @@ typedef struct {
  * as entities are grouped in tables by which components they have, and each 
  * table has its own set of component arrays. */
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     /* Print the set of components for the iterated over entities */
     char *type_str = ecs_table_str(it->world, it->table);
@@ -42,7 +42,7 @@ int main(int argc, char *argv[]) {
     ECS_TAG(world, Pears);
 
     /* Create an entity with name Bob, add Position and food preference */
-    ecs_entity_t Bob = ecs_new_entity(world, "Bob");
+    ecs_entity_t Bob = ecs_entity(world, { .name = "Bob" });
     ecs_set(world, Bob, Position, {0, 0});
     ecs_set(world, Bob, Velocity, {1, 2});
     ecs_add_pair(world, Bob, Eats, Apples);
diff --git a/examples/c/modules/simple_module/include/simple_module/bake_config.h b/examples/c/modules/simple_module/include/simple_module/bake_config.h
index e7f8f4730..bf3bba212 100644
--- a/examples/c/modules/simple_module/include/simple_module/bake_config.h
+++ b/examples/c/modules/simple_module/include/simple_module/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SIMPLE_MODULE_BAKE_CONFIG_H
-#define SIMPLE_MODULE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SIMPLE_MODULE_BAKE_CONFIG_H
+#define SIMPLE_MODULE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/modules/simple_module/src/main.c b/examples/c/modules/simple_module/src/main.c
index 6ee2b169d..642ecf930 100644
--- a/examples/c/modules/simple_module/src/main.c
+++ b/examples/c/modules/simple_module/src/main.c
@@ -2,7 +2,7 @@
 #include <stdio.h>
 
 void PrintPosition(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     for (int i = 0; i < it->count; i ++) {
         printf("p = {%f, %f} (system)\n", p[i].x, p[i].y);
@@ -20,7 +20,7 @@ int main(int argc, char *argv[]) {
     ECS_SYSTEM(world, PrintPosition, EcsOnUpdate, simple.module.Position);
 
     // Create entity with components imported from module
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
                      ecs_set(world, e, Velocity, {1, 2});
 
     // Call progress which runs imported Move system
diff --git a/examples/c/modules/simple_module/src/simple_module.c b/examples/c/modules/simple_module/src/simple_module.c
index 2c1dbf3ad..1d48babaa 100644
--- a/examples/c/modules/simple_module/src/simple_module.c
+++ b/examples/c/modules/simple_module/src/simple_module.c
@@ -4,8 +4,8 @@ ECS_COMPONENT_DECLARE(Position);
 ECS_COMPONENT_DECLARE(Velocity);
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i ++) {
         p[i].x += v[i].x;
diff --git a/examples/c/observers/basics/include/basics/bake_config.h b/examples/c/observers/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/c/observers/basics/include/basics/bake_config.h
+++ b/examples/c/observers/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/observers/basics/src/main.c b/examples/c/observers/basics/src/main.c
index 0b6f12699..6be125aa7 100644
--- a/examples/c/observers/basics/src/main.c
+++ b/examples/c/observers/basics/src/main.c
@@ -37,7 +37,7 @@ void Observer(ecs_iter_t *it) {
     ecs_entity_t event_id = it->event_id;
 
     // Get component values as usual
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     for (int i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
@@ -68,8 +68,8 @@ int main(int argc, char *argv[]) {
     // The ecs_observer macro (which calls the ecs_observer_init function) can
     // be used to create an observer.
     ecs_observer(ecs, {
-        // Observer filter. Uses same ecs_filter_desc_t as systems/queries
-        .filter = { .terms = {{ .id = ecs_id(Position) }}},
+        // Observer filter. Uses same ecs_query_desc_t as systems/queries
+        .query  = { .terms = {{ .id = ecs_id(Position) }}},
         // Events the observer will listen for. Can contain multiple events
         .events = { EcsOnAdd, EcsOnRemove },
         // Observer callback
@@ -80,7 +80,7 @@ int main(int argc, char *argv[]) {
     ECS_OBSERVER(ecs, Observer, EcsOnSet, Position);
 
     // Create entity
-    ecs_entity_t e = ecs_new_entity(ecs, "e");
+    ecs_entity_t e = ecs_entity(ecs, { .name = "e" });
     
     // Set Position (emits EcsOnAdd and EcsOnSet)
     ecs_set(ecs, e, Position, {10, 20});
diff --git a/examples/c/observers/custom_event/include/custom_event/bake_config.h b/examples/c/observers/custom_event/include/custom_event/bake_config.h
index a98c60c99..03a1113e1 100644
--- a/examples/c/observers/custom_event/include/custom_event/bake_config.h
+++ b/examples/c/observers/custom_event/include/custom_event/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef CUSTOM_EVENT_BAKE_CONFIG_H
-#define CUSTOM_EVENT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CUSTOM_EVENT_BAKE_CONFIG_H
+#define CUSTOM_EVENT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/observers/custom_event/src/main.c b/examples/c/observers/custom_event/src/main.c
index f46c40ac6..8eb98db73 100644
--- a/examples/c/observers/custom_event/src/main.c
+++ b/examples/c/observers/custom_event/src/main.c
@@ -39,13 +39,13 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(ecs, Position);
 
     // Create custom event
-    ecs_entity_t MyEvent = ecs_new_entity(ecs, "MyEvent");
+    ecs_entity_t MyEvent = ecs_entity(ecs, { .name = "MyEvent" });
 
     // Create observer for custom event
     ECS_OBSERVER(ecs, Observer, MyEvent, Position);
 
     // Create entity
-    ecs_entity_t e = ecs_new_entity(ecs, "e");
+    ecs_entity_t e = ecs_entity(ecs, { .name = "e" });
     
     // The observer filter can be matched against the entity, so make sure it
     // has the Position component before emitting the event. This does not 
diff --git a/examples/c/observers/enqueue_entity_event/src/main.c b/examples/c/observers/enqueue_entity_event/src/main.c
index acb60702a..901e4643e 100644
--- a/examples/c/observers/enqueue_entity_event/src/main.c
+++ b/examples/c/observers/enqueue_entity_event/src/main.c
@@ -19,7 +19,7 @@ ECS_COMPONENT_DECLARE(Resize);
 void OnClick(ecs_iter_t *it) {
     // The event source can be obtained with ecs_field_src(1). This allows the
     // same event function to be used for different entities.
-    char *path = ecs_get_fullpath(it->world, ecs_field_src(it, 1));
+    char *path = ecs_get_fullpath(it->world, ecs_field_src(it, 0));
     printf("clicked on %s!\n", path);
     ecs_os_free(path);
 }
@@ -27,7 +27,7 @@ void OnClick(ecs_iter_t *it) {
 void OnResize(ecs_iter_t *it) {
     // Event payload can be obtained from the it->param member
     Resize *p = it->param;
-    char *path = ecs_get_fullpath(it->world, ecs_field_src(it, 1));
+    char *path = ecs_get_fullpath(it->world, ecs_field_src(it, 0));
     printf("resized %s to {%.0f, %.0f}!\n", path, p->width, p->height);
     ecs_os_free(path);
 }
@@ -39,19 +39,19 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT_DEFINE(ecs, Resize);
 
     // Create a widget entity
-    ecs_entity_t widget = ecs_new_entity(ecs, "MyWidget");
+    ecs_entity_t widget = ecs_entity(ecs, { .name = "MyWidget" });
 
     // Create entity observer. Use EcsAny to indicate we're not interested in
     // matching specific components.
     ecs_observer(ecs, {
-        .filter.terms = {{ .id = EcsAny, .src.id = widget }},
+        .query.terms = {{ .id = EcsAny, .src.id = widget }},
         .events = { Click },
         .callback = OnClick
     });
 
     // Create another one for the Resize event
     ecs_observer(ecs, {
-        .filter.terms = {{ .id = EcsAny, .src.id = widget }},
+        .query.terms = {{ .id = EcsAny, .src.id = widget }},
         .events = { ecs_id(Resize) },
         .callback = OnResize
     });
diff --git a/examples/c/observers/enqueue_event/src/main.c b/examples/c/observers/enqueue_event/src/main.c
index e528ba060..c2e58fc27 100644
--- a/examples/c/observers/enqueue_event/src/main.c
+++ b/examples/c/observers/enqueue_event/src/main.c
@@ -35,13 +35,13 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(ecs, Position);
 
     // Create custom event
-    ecs_entity_t MyEvent = ecs_new_entity(ecs, "MyEvent");
+    ecs_entity_t MyEvent = ecs_entity(ecs, { .name = "MyEvent" });
 
     // Create observer for custom event
     ECS_OBSERVER(ecs, Observer, MyEvent, Position);
 
     // Create entity
-    ecs_entity_t e = ecs_new_entity(ecs, "e");
+    ecs_entity_t e = ecs_entity(ecs, { .name = "e" });
     
     // The observer filter can be matched against the entity, so make sure it
     // has the Position component before emitting the event. This does not 
diff --git a/examples/c/observers/entity_event/src/main.c b/examples/c/observers/entity_event/src/main.c
index f4205c515..7c3388491 100644
--- a/examples/c/observers/entity_event/src/main.c
+++ b/examples/c/observers/entity_event/src/main.c
@@ -26,7 +26,7 @@ ECS_COMPONENT_DECLARE(Resize);
 void OnClick(ecs_iter_t *it) {
     // The event source can be obtained with ecs_field_src(1). This allows the
     // same event function to be used for different entities.
-    char *path = ecs_get_fullpath(it->world, ecs_field_src(it, 1));
+    char *path = ecs_get_fullpath(it->world, ecs_field_src(it, 0));
     printf("clicked on %s!\n", path);
     ecs_os_free(path);
 }
@@ -34,7 +34,7 @@ void OnClick(ecs_iter_t *it) {
 void OnResize(ecs_iter_t *it) {
     // Event payload can be obtained from the it->param member
     Resize *p = it->param;
-    char *path = ecs_get_fullpath(it->world, ecs_field_src(it, 1));
+    char *path = ecs_get_fullpath(it->world, ecs_field_src(it, 0));
     printf("resized %s to {%.0f, %.0f}!\n", path, p->width, p->height);
     ecs_os_free(path);
 }
@@ -46,19 +46,19 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT_DEFINE(ecs, Resize);
 
     // Create a widget entity
-    ecs_entity_t widget = ecs_new_entity(ecs, "MyWidget");
+    ecs_entity_t widget = ecs_entity(ecs, { .name = "MyWidget" });
 
     // Create entity observer. Use EcsAny to indicate we're not interested in
     // matching specific components.
     ecs_observer(ecs, {
-        .filter.terms = {{ .id = EcsAny, .src.id = widget }},
+        .query.terms = {{ .id = EcsAny, .src.id = widget }},
         .events = { Click },
         .callback = OnClick
     });
 
     // Create another one for the Resize event
     ecs_observer(ecs, {
-        .filter.terms = {{ .id = EcsAny, .src.id = widget }},
+        .query.terms = {{ .id = EcsAny, .src.id = widget }},
         .events = { ecs_id(Resize) },
         .callback = OnResize
     });
diff --git a/examples/c/observers/monitor/include/monitor/bake_config.h b/examples/c/observers/monitor/include/monitor/bake_config.h
index 42149bc48..5a94a9c5a 100644
--- a/examples/c/observers/monitor/include/monitor/bake_config.h
+++ b/examples/c/observers/monitor/include/monitor/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef MONITOR_BAKE_CONFIG_H
-#define MONITOR_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef MONITOR_BAKE_CONFIG_H
+#define MONITOR_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/observers/monitor/src/main.c b/examples/c/observers/monitor/src/main.c
index 9113b7f36..d1b52ac17 100644
--- a/examples/c/observers/monitor/src/main.c
+++ b/examples/c/observers/monitor/src/main.c
@@ -42,13 +42,13 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(ecs, Velocity);
 
     ecs_observer(ecs, {
-        .filter = { .terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }}},
+        .query  = { .terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }}},
         .events = { EcsMonitor }, // Monitor entities entering/leaving the query
         .callback = Observer,
     });
 
     // Create entity
-    ecs_entity_t e = ecs_new_entity(ecs, "e");
+    ecs_entity_t e = ecs_entity(ecs, { .name = "e" });
 
     // This does not yet trigger the monitor, as the entity does not yet match.
     ecs_set(ecs, e, Position, {10, 20});
diff --git a/examples/c/observers/propagate/include/propagate/bake_config.h b/examples/c/observers/propagate/include/propagate/bake_config.h
index 9ffb6a9c4..63d2accda 100644
--- a/examples/c/observers/propagate/include/propagate/bake_config.h
+++ b/examples/c/observers/propagate/include/propagate/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef PROPAGATE_BAKE_CONFIG_H
-#define PROPAGATE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef PROPAGATE_BAKE_CONFIG_H
+#define PROPAGATE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/observers/propagate/src/main.c b/examples/c/observers/propagate/src/main.c
index 530335306..bb016e8b6 100644
--- a/examples/c/observers/propagate/src/main.c
+++ b/examples/c/observers/propagate/src/main.c
@@ -26,8 +26,8 @@ void Observer(ecs_iter_t *it) {
     ecs_entity_t event_id = it->event_id;
 
     // Grab Position from self and parent
-    Position *p_self = ecs_field(it, Position, 1);
-    Position *p_parent = ecs_field(it, Position, 2);
+    Position *p_self = ecs_field(it, Position, 0);
+    Position *p_parent = ecs_field(it, Position, 1);
 
     for (int i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
@@ -48,19 +48,19 @@ int main(int argc, char *argv[]) {
 
     // Create observer that listens for events from both self and parent
     ecs_observer(ecs, {
-        .filter = { .terms = {
+        .query = { .terms = {
             // Listen for Position events from self
             { .id = ecs_id(Position) },
             // Listen for Position events from parent
-            { .id = ecs_id(Position), .src.flags = EcsUp, .src.trav = EcsChildOf }
+            { .id = ecs_id(Position), .src.id = EcsUp, .trav = EcsChildOf }
         }},
         .events = { EcsOnSet },
         .callback = Observer
     });
 
     // Create entity and parent
-    ecs_entity_t p = ecs_new_entity(ecs, "p");
-    ecs_entity_t e = ecs_new_entity(ecs, "p.e"); // Create as child of p
+    ecs_entity_t p = ecs_entity(ecs, { .name = "p" });
+    ecs_entity_t e = ecs_entity(ecs, { .name = "p.e" }); // Create as child of p
 
     // Set Position on entity. This doesn't trigger the observer yet, since the
     // parent doesn't have Position yet.
diff --git a/examples/c/observers/two_components/include/two_components/bake_config.h b/examples/c/observers/two_components/include/two_components/bake_config.h
index 963e5122b..26b905068 100644
--- a/examples/c/observers/two_components/include/two_components/bake_config.h
+++ b/examples/c/observers/two_components/include/two_components/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef TWO_COMPONENTS_BAKE_CONFIG_H
-#define TWO_COMPONENTS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef TWO_COMPONENTS_BAKE_CONFIG_H
+#define TWO_COMPONENTS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/observers/two_components/src/main.c b/examples/c/observers/two_components/src/main.c
index 214ea4c57..0131dd2dc 100644
--- a/examples/c/observers/two_components/src/main.c
+++ b/examples/c/observers/two_components/src/main.c
@@ -15,8 +15,8 @@ void Observer(ecs_iter_t *it) {
     ecs_entity_t event = it->event;
     ecs_entity_t event_id = it->event_id;
 
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
@@ -38,7 +38,7 @@ int main(int argc, char *argv[]) {
     ECS_OBSERVER(ecs, Observer, EcsOnSet, Position, Velocity);
 
     // Create entity
-    ecs_entity_t e = ecs_new_entity(ecs, "e");
+    ecs_entity_t e = ecs_entity(ecs, { .name = "e" });
     
     // Set Position (emits EcsOnSet, does not yet match observer)
     ecs_set(ecs, e, Position, {10, 20});
diff --git a/examples/c/observers/yield_existing/include/yield_existing/bake_config.h b/examples/c/observers/yield_existing/include/yield_existing/bake_config.h
index c774d0730..75dd5d86b 100644
--- a/examples/c/observers/yield_existing/include/yield_existing/bake_config.h
+++ b/examples/c/observers/yield_existing/include/yield_existing/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef YIELD_EXISTING_BAKE_CONFIG_H
-#define YIELD_EXISTING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef YIELD_EXISTING_BAKE_CONFIG_H
+#define YIELD_EXISTING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/observers/yield_existing/src/main.c b/examples/c/observers/yield_existing/src/main.c
index 5cd79d9b4..38ffd509d 100644
--- a/examples/c/observers/yield_existing/src/main.c
+++ b/examples/c/observers/yield_existing/src/main.c
@@ -17,7 +17,7 @@ void Observer(ecs_iter_t *it) {
 
     ecs_entity_t event = it->event;
     ecs_entity_t event_id = it->event_id;
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     for (int i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
@@ -35,13 +35,13 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(ecs, Position);
 
     // Create existing entities with Position component
-    ecs_entity_t e1 = ecs_new_entity(ecs, "e1");
+    ecs_entity_t e1 = ecs_entity(ecs, { .name = "e1" });
     ecs_set(ecs, e1, Position, {10, 20});
-    ecs_entity_t e2 = ecs_new_entity(ecs, "e2");
+    ecs_entity_t e2 = ecs_entity(ecs, { .name = "e2" });
     ecs_set(ecs, e2, Position, {20, 30});
 
     ecs_observer(ecs, {
-        .filter = { .terms = {{ .id = ecs_id(Position) }}},
+        .query.terms = {{ .id = ecs_id(Position) }},
         .events = { EcsOnSet },
         .callback = Observer,
         .yield_existing = true // Trigger for existing matching entities
diff --git a/examples/c/prefabs/basics/include/basics/bake_config.h b/examples/c/prefabs/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/c/prefabs/basics/include/basics/bake_config.h
+++ b/examples/c/prefabs/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/prefabs/basics/src/main.c b/examples/c/prefabs/basics/src/main.c
index d51c4308a..925fa986b 100644
--- a/examples/c/prefabs/basics/src/main.c
+++ b/examples/c/prefabs/basics/src/main.c
@@ -28,11 +28,11 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(ecs, Defense);
 
     // Create a SpaceShip prefab with a Defense component.
-    ecs_entity_t SpaceShip = ecs_new_prefab(ecs, "SpaceShip");
+    ecs_entity_t SpaceShip = ecs_entity(ecs, { .name = "SpaceShip", .add = ecs_ids( EcsPrefab ) });
     ecs_set(ecs, SpaceShip, Defense, {50});
 
     // Create a prefab instance
-    ecs_entity_t inst = ecs_new_entity(ecs, "my_spaceship");
+    ecs_entity_t inst = ecs_entity(ecs, { .name = "my_spaceship" });
     ecs_add_pair(ecs, inst, EcsIsA, SpaceShip);
 
     // Because of the IsA relationship, the instance now shares the Defense
@@ -47,14 +47,14 @@ int main(int argc, char *argv[]) {
 
     // Prefab components can be iterated like regular components:
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_id(Defense) }
         }
     });
 
     ecs_iter_t it = ecs_query_iter(ecs, q);
     while (ecs_query_next(&it)) {
-        Defense *d = ecs_field(&it, Defense, 1);
+        Defense *d = ecs_field(&it, Defense, 0);
         for (int i = 0; i < it.count; i ++) {
             printf("%s: defense: %f\n", 
                 ecs_get_name(ecs, it.entities[i]), d[i].value);
diff --git a/examples/c/prefabs/hierarchy/include/hierarchy/bake_config.h b/examples/c/prefabs/hierarchy/include/hierarchy/bake_config.h
index 1e21b3812..6b3d117ad 100644
--- a/examples/c/prefabs/hierarchy/include/hierarchy/bake_config.h
+++ b/examples/c/prefabs/hierarchy/include/hierarchy/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HIERARCHY_BAKE_CONFIG_H
-#define HIERARCHY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HIERARCHY_BAKE_CONFIG_H
+#define HIERARCHY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/prefabs/hierarchy/src/main.c b/examples/c/prefabs/hierarchy/src/main.c
index 2e8648acc..d7c3f8750 100644
--- a/examples/c/prefabs/hierarchy/src/main.c
+++ b/examples/c/prefabs/hierarchy/src/main.c
@@ -8,16 +8,16 @@ int main(int argc, char *argv[]) {
     ecs_world_t *ecs = ecs_init_w_args(argc, argv);
 
     // Create a prefab hierarchy.
-    ecs_entity_t SpaceShip = ecs_new_prefab(ecs, "SpaceShip");
-        ecs_entity_t SpaceShipEngine = ecs_new_prefab(ecs, "Engine");
+    ecs_entity_t SpaceShip = ecs_entity(ecs, { .name = "SpaceShip", .add = ecs_ids( EcsPrefab ) });
+        ecs_entity_t SpaceShipEngine = ecs_entity(ecs, { .name = "Engine", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, SpaceShipEngine, EcsChildOf, SpaceShip);
     
-        ecs_entity_t SpaceShipCockpit = ecs_new_prefab(ecs, "Cockpit");
+        ecs_entity_t SpaceShipCockpit = ecs_entity(ecs, { .name = "Cockpit", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, SpaceShipCockpit, EcsChildOf, SpaceShip);
 
     // Instantiate the prefab. This also creates an Engine and Cockpit child
     // for the instance.
-    ecs_entity_t inst = ecs_new_entity(ecs, "my_spaceship");
+    ecs_entity_t inst = ecs_entity(ecs, { .name = "my_spaceship" });
     ecs_add_pair(ecs, inst, EcsIsA, SpaceShip);
     ecs_entity_t inst_engine = ecs_lookup_child(ecs, inst, "Engine");
     ecs_entity_t inst_cockpit = ecs_lookup_child(ecs, inst, "Cockpit");
diff --git a/examples/c/prefabs/nested_prefabs/include/nested_prefabs/bake_config.h b/examples/c/prefabs/nested_prefabs/include/nested_prefabs/bake_config.h
index 38d688c1e..d59120217 100644
--- a/examples/c/prefabs/nested_prefabs/include/nested_prefabs/bake_config.h
+++ b/examples/c/prefabs/nested_prefabs/include/nested_prefabs/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef NESTED_PREFABS_BAKE_CONFIG_H
-#define NESTED_PREFABS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef NESTED_PREFABS_BAKE_CONFIG_H
+#define NESTED_PREFABS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/prefabs/nested_prefabs/src/main.c b/examples/c/prefabs/nested_prefabs/src/main.c
index 23eefeb08..d91440606 100644
--- a/examples/c/prefabs/nested_prefabs/src/main.c
+++ b/examples/c/prefabs/nested_prefabs/src/main.c
@@ -30,28 +30,28 @@ int main(int argc, char *argv[]) {
 
     // Create a Wheel prefab, make sure each instantiated wheel has a private
     // copy of the TirePressure component.
-    ecs_entity_t Wheel = ecs_new_prefab(ecs, "Wheel");
+    ecs_entity_t Wheel = ecs_entity(ecs, { .name = "Wheel", .add = ecs_ids( EcsPrefab ) });
     ecs_set(ecs, Wheel, TirePressure, { 32 });
     ecs_override(ecs, Wheel, TirePressure);
 
     // Create a Car prefab with four wheels. Note how the wheel names are
     // prefixed with 'Car.', this is has the same effect as adding the
     // (ChildOf, Car) relationship.
-    ecs_entity_t Car = ecs_new_prefab(ecs, "Car");
-        ecs_entity_t WheelFrontLeft = ecs_new_prefab(ecs, "Car.FrontLeft");
+    ecs_entity_t Car = ecs_entity(ecs, { .name = "Car", .add = ecs_ids( EcsPrefab ) });
+        ecs_entity_t WheelFrontLeft = ecs_entity(ecs, { .name = "Car.FrontLeft", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, WheelFrontLeft, EcsIsA, Wheel);
 
-        ecs_entity_t WheelFrontRight = ecs_new_prefab(ecs, "Car.FrontRight");
+        ecs_entity_t WheelFrontRight = ecs_entity(ecs, { .name = "Car.FrontRight", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, WheelFrontRight, EcsIsA, Wheel);
 
-        ecs_entity_t WheelBackLeft = ecs_new_prefab(ecs, "Car.BackLeft");
+        ecs_entity_t WheelBackLeft = ecs_entity(ecs, { .name = "Car.BackLeft", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, WheelBackLeft, EcsIsA, Wheel);
 
-        ecs_entity_t WheelBackRight = ecs_new_prefab(ecs, "Car.BackRight");
+        ecs_entity_t WheelBackRight = ecs_entity(ecs, { .name = "Car.BackRight", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, WheelBackRight, EcsIsA, Wheel);
 
     // Create a prefab instance.
-    ecs_entity_t inst = ecs_new_entity(ecs, "my_car");
+    ecs_entity_t inst = ecs_entity(ecs, { .name = "my_car" });
     ecs_add_pair(ecs, inst, EcsIsA, Car);
 
     // Lookup one of the wheels
diff --git a/examples/c/prefabs/override/include/override/bake_config.h b/examples/c/prefabs/override/include/override/bake_config.h
index 4f099477c..b96f6d316 100644
--- a/examples/c/prefabs/override/include/override/bake_config.h
+++ b/examples/c/prefabs/override/include/override/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef OVERRIDE_BAKE_CONFIG_H
-#define OVERRIDE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef OVERRIDE_BAKE_CONFIG_H
+#define OVERRIDE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/prefabs/override/src/main.c b/examples/c/prefabs/override/src/main.c
index 020439a9a..28064a33b 100644
--- a/examples/c/prefabs/override/src/main.c
+++ b/examples/c/prefabs/override/src/main.c
@@ -22,7 +22,7 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(ecs, Defense);
     ECS_COMPONENT(ecs, Damage);
 
-    ecs_entity_t SpaceShip = ecs_new_prefab(ecs, "SpaceShip");
+    ecs_entity_t SpaceShip = ecs_entity(ecs, { .name = "SpaceShip", .add = ecs_ids( EcsPrefab ) });
 
     // Attack and Defense are properties that can be shared across many 
     // spaceships. This saves memory, and speeds up prefab creation as we don't
@@ -37,7 +37,7 @@ int main(int argc, char *argv[]) {
     ecs_override(ecs, SpaceShip, Damage);
 
     // Create a prefab instance.
-    ecs_entity_t inst = ecs_new_entity(ecs, "my_instance");
+    ecs_entity_t inst = ecs_entity(ecs, { .name = "my_instance" });
     ecs_add_pair(ecs, inst, EcsIsA, SpaceShip);
     
     // The entity will now have a private copy of the Damage component, but not
diff --git a/examples/c/prefabs/slots/include/slots/bake_config.h b/examples/c/prefabs/slots/include/slots/bake_config.h
index ef3f7b1fa..2f17cf648 100644
--- a/examples/c/prefabs/slots/include/slots/bake_config.h
+++ b/examples/c/prefabs/slots/include/slots/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SLOTS_BAKE_CONFIG_H
-#define SLOTS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SLOTS_BAKE_CONFIG_H
+#define SLOTS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/prefabs/slots/src/main.c b/examples/c/prefabs/slots/src/main.c
index 9a541f5cc..5fddbe8c9 100644
--- a/examples/c/prefabs/slots/src/main.c
+++ b/examples/c/prefabs/slots/src/main.c
@@ -29,12 +29,12 @@ int main(int argc, char *argv[]) {
 
     // Create the same prefab hierarchy as from the hierarchy example, but now
     // with the SlotOf relationship.
-    ecs_entity_t SpaceShip = ecs_new_prefab(ecs, "SpaceShip");
-        ecs_entity_t Engine = ecs_new_prefab(ecs, "Engine");
+    ecs_entity_t SpaceShip = ecs_entity(ecs, { .name = "SpaceShip", .add = ecs_ids( EcsPrefab ) });
+        ecs_entity_t Engine = ecs_entity(ecs, { .name = "Engine", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, Engine, EcsChildOf, SpaceShip);
         ecs_add_pair(ecs, Engine, EcsSlotOf, SpaceShip);
     
-        ecs_entity_t Cockpit = ecs_new_prefab(ecs, "Cockpit");
+        ecs_entity_t Cockpit = ecs_entity(ecs, { .name = "Cockpit", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, Cockpit, EcsChildOf, SpaceShip);
         ecs_add_pair(ecs, Cockpit, EcsSlotOf, SpaceShip);
 
@@ -42,12 +42,12 @@ int main(int argc, char *argv[]) {
         // slots can be different from the parent. This slot could have been
         // added to the Cockpit prefab, but instead we register it on the top
         // level SpaceShip prefab.
-        ecs_entity_t PilotSeat = ecs_new_prefab(ecs, "PilotSeat");
+        ecs_entity_t PilotSeat = ecs_entity(ecs, { .name = "PilotSeat", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, PilotSeat, EcsChildOf, Cockpit);
         ecs_add_pair(ecs, PilotSeat, EcsSlotOf, SpaceShip);
 
     // Create a prefab instance.
-    ecs_entity_t inst = ecs_new_entity(ecs, "my_spaceship");
+    ecs_entity_t inst = ecs_entity(ecs, { .name = "my_spaceship" });
     ecs_add_pair(ecs, inst, EcsIsA, SpaceShip);
 
     // Get the instantiated entities for the prefab slots
diff --git a/examples/c/prefabs/variant/include/variant/bake_config.h b/examples/c/prefabs/variant/include/variant/bake_config.h
index c9fe9d02c..c735c4dee 100644
--- a/examples/c/prefabs/variant/include/variant/bake_config.h
+++ b/examples/c/prefabs/variant/include/variant/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef VARIANT_BAKE_CONFIG_H
-#define VARIANT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef VARIANT_BAKE_CONFIG_H
+#define VARIANT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/prefabs/variant/src/main.c b/examples/c/prefabs/variant/src/main.c
index b21359464..d35c8000b 100644
--- a/examples/c/prefabs/variant/src/main.c
+++ b/examples/c/prefabs/variant/src/main.c
@@ -25,23 +25,23 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(ecs, ImpulseSpeed);
 
     // Create a base prefab for SpaceShips.
-    ecs_entity_t SpaceShip = ecs_new_prefab(ecs, "SpaceShip");
+    ecs_entity_t SpaceShip = ecs_entity(ecs, { .name = "SpaceShip", .add = ecs_ids( EcsPrefab ) });
     ecs_set(ecs, SpaceShip, ImpulseSpeed, {50});
     ecs_set(ecs, SpaceShip, Defense, {25});
 
         // Create a Freighter variant which inherits from SpaceShip
-        ecs_entity_t Freighter = ecs_new_prefab(ecs, "Freighter");
+        ecs_entity_t Freighter = ecs_entity(ecs, { .name = "Freighter", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, Freighter, EcsIsA, SpaceShip);
         ecs_set(ecs, Freighter, FreightCapacity, {100});
         ecs_set(ecs, Freighter, Defense, {50});
 
             // Create a MammothFreighter variant which inherits from Freighter
-            ecs_entity_t MammothFreighter = ecs_new_prefab(ecs, "MammothFreighter");
+            ecs_entity_t MammothFreighter = ecs_entity(ecs, { .name = "MammothFreighter", .add = ecs_ids( EcsPrefab ) });
             ecs_add_pair(ecs, MammothFreighter, EcsIsA, Freighter);
             ecs_set(ecs, MammothFreighter, FreightCapacity, {500});
 
         // Create a Frigate variant which inherits from SpaceShip
-        ecs_entity_t Frigate = ecs_new_prefab(ecs, "Frigate");
+        ecs_entity_t Frigate = ecs_entity(ecs, { .name = "Frigate", .add = ecs_ids( EcsPrefab ) });
         ecs_add_pair(ecs, Frigate, EcsIsA, SpaceShip);
         ecs_set(ecs, Frigate, Attack, {100});
         ecs_set(ecs, Frigate, Defense, {75});
@@ -51,7 +51,7 @@ int main(int argc, char *argv[]) {
     // Create an instance of the MammothFreighter. This entity will inherit the
     // ImpulseSpeed from SpaceShip, Defense from Freighter and FreightCapacity
     // from MammothFreighter.
-    ecs_entity_t inst = ecs_new_entity(ecs, "my_freighter");
+    ecs_entity_t inst = ecs_entity(ecs, { .name = "my_freighter" });
     ecs_add_pair(ecs, inst, EcsIsA, MammothFreighter);
 
     // Add a private Position component.
@@ -63,7 +63,7 @@ int main(int argc, char *argv[]) {
 
     // Queries can match components from multiple levels of inheritance
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(ImpulseSpeed) }, 
             { .id = ecs_id(Defense) }, 
@@ -73,10 +73,10 @@ int main(int argc, char *argv[]) {
 
     ecs_iter_t it = ecs_query_iter(ecs, q);
     while (ecs_query_next(&it)) {
-        Position  *p = ecs_field(&it, Position, 1);
-        ImpulseSpeed *s = ecs_field(&it, ImpulseSpeed, 2);
-        Defense *d = ecs_field(&it, Defense, 3);
-        FreightCapacity *c = ecs_field(&it, FreightCapacity, 4);
+        Position  *p = ecs_field(&it, Position, 0);
+        ImpulseSpeed *s = ecs_field(&it, ImpulseSpeed, 1);
+        Defense *d = ecs_field(&it, Defense, 2);
+        FreightCapacity *c = ecs_field(&it, FreightCapacity, 3);
 
         for (int i = 0; i < it.count; i ++) {
             printf("%s:\n", ecs_get_name(ecs, it.entities[i]));
diff --git a/examples/c/queries/basics/include/basics/bake_config.h b/examples/c/queries/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/c/queries/basics/include/basics/bake_config.h
+++ b/examples/c/queries/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/basics/src/main.c b/examples/c/queries/basics/src/main.c
index 55e78999f..d5244c76b 100644
--- a/examples/c/queries/basics/src/main.c
+++ b/examples/c/queries/basics/src/main.c
@@ -15,23 +15,23 @@ int main(int argc, char *argv[]) {
     // Create a query for Position, Velocity. Queries are the fastest way to
     // iterate entities as they cache results.
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_id(Position) }, 
             { .id = ecs_id(Velocity), .inout = EcsIn}
         }
     });
 
     // Create a few test entities for a Position, Velocity query
-    ecs_entity_t e1 = ecs_new_entity(ecs, "e1");
+    ecs_entity_t e1 = ecs_entity(ecs, { .name = "e1" });
     ecs_set(ecs, e1, Position, {10, 20});
     ecs_set(ecs, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_entity(ecs, "e2");
+    ecs_entity_t e2 = ecs_entity(ecs, { .name = "e2" });
     ecs_set(ecs, e2, Position, {10, 20});
     ecs_set(ecs, e2, Velocity, {3, 4});
 
     // This entity will not match as it does not have Position, Velocity
-    ecs_entity_t e3 = ecs_new_entity(ecs, "e3");
+    ecs_entity_t e3 = ecs_entity(ecs, { .name = "e3" });
     ecs_set(ecs, e3, Position, {10, 20});
 
     // Iterate entities matching the query
@@ -39,8 +39,8 @@ int main(int argc, char *argv[]) {
 
     // Outer loop, iterates archetypes
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
-        const Velocity *v = ecs_field(&it, Velocity, 2);
+        Position *p = ecs_field(&it, Position, 0);
+        const Velocity *v = ecs_field(&it, Velocity, 1);
 
         // Inner loop, iterates entities in archetype
         for (int i = 0; i < it.count; i ++) {
@@ -51,21 +51,21 @@ int main(int argc, char *argv[]) {
         }
     }
 
-    // Filters are uncached queries. They are a bit slower to iterate but faster
+    // Querys are uncached queries. They are a bit slower to iterate but faster
     // to create & have lower overhead as they don't have to maintain a cache.
-    ecs_filter_t *f = ecs_filter(ecs, {
+    ecs_query_t *f = ecs_query(ecs, {
         .terms = {
             { .id = ecs_id(Position) }, 
             { .id = ecs_id(Velocity), .inout = EcsIn}
         }
     });
 
-    // Filter iteration looks the same as query iteration
-    it = ecs_filter_iter(ecs, f);
+    // Query iteration looks the same as query iteration
+    it = ecs_query_iter(ecs, f);
 
-    while (ecs_filter_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
-        const Velocity *v = ecs_field(&it, Velocity, 2);
+    while (ecs_query_next(&it)) {
+        Position *p = ecs_field(&it, Position, 0);
+        const Velocity *v = ecs_field(&it, Velocity, 1);
 
         for (int i = 0; i < it.count; i ++) {
             p[i].x += v[i].x;
@@ -75,11 +75,11 @@ int main(int argc, char *argv[]) {
         }
     }
 
-    // Cleanup filter. Filters can allocate memory if the number of terms 
+    // Cleanup filter. Querys can allocate memory if the number of terms 
     // exceeds their internal buffer, or when terms have names. In this case the
     // filter didn't allocate, so while fini isn't strictly necessary here, it's
     // still good practice to add it.
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     return ecs_fini(ecs);
 }
diff --git a/examples/c/queries/change_tracking/include/change_tracking/bake_config.h b/examples/c/queries/change_tracking/include/change_tracking/bake_config.h
index 70674c95e..102f0f38c 100644
--- a/examples/c/queries/change_tracking/include/change_tracking/bake_config.h
+++ b/examples/c/queries/change_tracking/include/change_tracking/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef CHANGE_TRACKING_BAKE_CONFIG_H
-#define CHANGE_TRACKING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CHANGE_TRACKING_BAKE_CONFIG_H
+#define CHANGE_TRACKING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/change_tracking/src/main.c b/examples/c/queries/change_tracking/src/main.c
index 4ece6726c..68764a9a0 100644
--- a/examples/c/queries/change_tracking/src/main.c
+++ b/examples/c/queries/change_tracking/src/main.c
@@ -29,48 +29,47 @@ int main(int argc, char *argv[]) {
     // Each query has its own private dirty state which is reset only when the
     // query is iterated.
     ecs_query_t *q_read = ecs_query(world, {
-        .filter.terms = {{ .id = ecs_id(Position), .inout = EcsIn }}
+        .terms = {{ .id = ecs_id(Position), .inout = EcsIn }}
     });
 
     // Create a query that writes the component based on a Dirty state.
     ecs_query_t *q_write = ecs_query(world, {
-        .filter = {
-            .terms = {
-                // Only match if Dirty is shared from prefab
-                { 
-                    .id = ecs_id(Dirty), 
-                    .inout = EcsIn,
-                    .src.flags = EcsUp 
-                },
-                { .id = ecs_id(Position) }
+        .terms = {
+            // Only match if Dirty is shared from prefab
+            { 
+                .id = ecs_id(Dirty), 
+                .inout = EcsIn,
+                .src.id = EcsUp,
+                .trav = EcsIsA
             },
-            .instanced = true // Instanced iteration is faster (see example)
-        }
+            { .id = ecs_id(Position) }
+        },
+        .flags = EcsQueryIsInstanced // Instanced iteration is faster (see example)
     });
 
     // Create two prefabs with a Dirty component. We can use this to share a
     // single Dirty value for all entities in a table.
-    ecs_entity_t p1 = ecs_new_prefab(world, "p1");
+    ecs_entity_t p1 = ecs_entity(world, { .name = "p1", .add = ecs_ids( EcsPrefab ) });
     ecs_set(world, p1, Dirty, {false});
 
-    ecs_entity_t p2 = ecs_new_prefab(world, "p2");
+    ecs_entity_t p2 = ecs_entity(world, { .name = "p2", .add = ecs_ids( EcsPrefab ) });
     ecs_set(world, p2, Dirty, {true});
 
     // Create instances of p1 and p2. Because the entities have different
     // prefabs, they end up in different tables.
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add_pair(world, e1, EcsIsA, p1);
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_pair(world, e2, EcsIsA, p1);
     ecs_set(world, e2, Position, {30, 40});
 
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_pair(world, e3, EcsIsA, p2);
     ecs_set(world, e3, Position, {50, 60});
 
-    ecs_entity_t e4 = ecs_new_entity(world, "e4");
+    ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
     ecs_add_pair(world, e4, EcsIsA, p2);
     ecs_set(world, e4, Position, {70, 80});
 
@@ -78,7 +77,7 @@ int main(int argc, char *argv[]) {
     // tables it is matched with has changed. Since this is the first time that
     // we check this and the query is matched with the tables we just created,
     // the function will return true.
-    printf("q_read changed: %d\n", ecs_query_changed(q_read, NULL));
+    printf("q_read changed: %d\n", ecs_query_changed(q_read));
 
     // The changed state will remain true until we have iterated each table.
     ecs_iter_t it = ecs_query_iter(world, q_read);
@@ -89,18 +88,18 @@ int main(int argc, char *argv[]) {
         // will show up as changed.
         char *table_str = ecs_table_str(world, it.table);
         printf("it.changed for table [%s]: %d\n", table_str,
-            ecs_query_changed(q_read, &it));
+            ecs_iter_changed(&it));
         ecs_os_free(table_str);
     }
 
     // Now that we have iterated all tables, the dirty state is reset.
-    printf("q_read changed: %d\n\n", ecs_query_changed(q_read, NULL));
+    printf("q_read changed: %d\n\n", ecs_query_changed(q_read));
 
     // Iterate the write query. Because the Position term is InOut (default)
     // iterating the query will write to the dirty state of iterated tables.
     it = ecs_query_iter(world, q_write);
     while (ecs_query_next(&it)) {
-        Dirty *dirty = ecs_field(&it, Dirty, 1);
+        Dirty *dirty = ecs_field(&it, Dirty, 0);
 
         char *table_str = ecs_table_str(world, it.table);
         printf("iterate table [%s]\n", table_str);
@@ -109,14 +108,14 @@ int main(int argc, char *argv[]) {
         // Because we enforced that Dirty is a shared component, we can check
         // a single value for the entire table.
         if (!dirty->value) {
-            ecs_query_skip(&it);
+            ecs_iter_skip(&it);
             table_str = ecs_table_str(world, it.table);
             printf("it.skip for table [%s]\n", table_str);
             ecs_os_free(table_str);
             continue;
         }
 
-        Position *p = ecs_field(&it, Position, 2);
+        Position *p = ecs_field(&it, Position, 1);
 
         // For all other tables the dirty state will be set.
         for (int i = 0; i < it.count; i ++) {
@@ -126,14 +125,14 @@ int main(int argc, char *argv[]) {
     }
 
     // One of the tables has changed, so q_read.changed() will return true
-    printf("\nq_read changed: %d\n", ecs_query_changed(q_read, NULL));
+    printf("\nq_read changed: %d\n", ecs_query_changed(q_read));
 
     // When we iterate the read query, we'll see that one table has changed.
     it = ecs_query_iter(world, q_read);
     while (ecs_query_next(&it)) {
         char *table_str = ecs_table_str(world, it.table);
         printf("it.changed for table [%s]: %d\n", table_str,
-            ecs_query_changed(q_read, &it));
+            ecs_iter_changed(&it));
         ecs_os_free(table_str);
     }
 
diff --git a/examples/c/rules/component_inheritance/include/component_inheritance.h b/examples/c/queries/component_inheritance/include/component_inheritance.h
similarity index 100%
rename from examples/c/rules/component_inheritance/include/component_inheritance.h
rename to examples/c/queries/component_inheritance/include/component_inheritance.h
diff --git a/examples/cpp/rules/component_inheritance/include/component_inheritance/bake_config.h b/examples/c/queries/component_inheritance/include/component_inheritance/bake_config.h
similarity index 100%
rename from examples/cpp/rules/component_inheritance/include/component_inheritance/bake_config.h
rename to examples/c/queries/component_inheritance/include/component_inheritance/bake_config.h
diff --git a/examples/c/rules/component_inheritance/project.json b/examples/c/queries/component_inheritance/project.json
similarity index 100%
rename from examples/c/rules/component_inheritance/project.json
rename to examples/c/queries/component_inheritance/project.json
diff --git a/examples/c/rules/component_inheritance/src/main.c b/examples/c/queries/component_inheritance/src/main.c
similarity index 66%
rename from examples/c/rules/component_inheritance/src/main.c
rename to examples/c/queries/component_inheritance/src/main.c
index ba4c1563e..d4c8e887f 100644
--- a/examples/c/rules/component_inheritance/src/main.c
+++ b/examples/c/queries/component_inheritance/src/main.c
@@ -23,40 +23,40 @@ int main(int argc, char *argv[]) {
     ECS_ENTITY(ecs, Builder,    (IsA, Unit));
 
     // Create a few units
-    ecs_entity_t warrior_1 = ecs_new_entity(ecs, "warrior_1");
+    ecs_entity_t warrior_1 = ecs_entity(ecs, { .name = "warrior_1" });
     ecs_add(ecs, warrior_1, Warrior);
-    ecs_entity_t warrior_2 = ecs_new_entity(ecs, "warrior_2");
+    ecs_entity_t warrior_2 = ecs_entity(ecs, { .name = "warrior_2" });
     ecs_add(ecs, warrior_2, Warrior);
 
-    ecs_entity_t marksman_1 = ecs_new_entity(ecs, "marksman_1");
+    ecs_entity_t marksman_1 = ecs_entity(ecs, { .name = "marksman_1" });
     ecs_add(ecs, marksman_1, Marksman);
-    ecs_entity_t marksman_2 = ecs_new_entity(ecs, "marksman_2");
+    ecs_entity_t marksman_2 = ecs_entity(ecs, { .name = "marksman_2" });
     ecs_add(ecs, marksman_2, Marksman);
 
-    ecs_entity_t wizard_1 = ecs_new_entity(ecs, "wizard_1");
+    ecs_entity_t wizard_1 = ecs_entity(ecs, { .name = "wizard_1" });
     ecs_add(ecs, wizard_1, Wizard);
-    ecs_entity_t wizard_2 = ecs_new_entity(ecs, "wizard_2");
+    ecs_entity_t wizard_2 = ecs_entity(ecs, { .name = "wizard_2" });
     ecs_add(ecs, wizard_2, Wizard);
 
-    ecs_entity_t builder_1 = ecs_new_entity(ecs, "builder_1");
+    ecs_entity_t builder_1 = ecs_entity(ecs, { .name = "builder_1" });
     ecs_add(ecs, builder_1, Builder);
-    ecs_entity_t builder_2 = ecs_new_entity(ecs, "builder_2");
+    ecs_entity_t builder_2 = ecs_entity(ecs, { .name = "builder_2" });
     ecs_add(ecs, builder_2, Builder);
 
-    // Create a rule to find all ranged units
-    ecs_rule_t *r = ecs_rule(ecs, {
+    // Create a query to find all ranged units
+    ecs_query_t *q = ecs_query(ecs, {
         .terms = {{ .id = RangedUnit }}
     });
 
-    // Iterate the rule
-    ecs_iter_t it = ecs_rule_iter(ecs, r);
-    while (ecs_rule_next(&it)) {
+    // Iterate the query
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    while (ecs_query_next(&it)) {
         for (int i = 0; i < it.count; i ++) {
             printf("Unit %s found\n", ecs_get_name(ecs, it.entities[i]));
         }
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     // Output
     //  Unit wizard_1 found
diff --git a/examples/c/rules/cyclic_variables/.gitignore b/examples/c/queries/cyclic_variables/.gitignore
similarity index 100%
rename from examples/c/rules/cyclic_variables/.gitignore
rename to examples/c/queries/cyclic_variables/.gitignore
diff --git a/examples/c/rules/cyclic_variables/include/cyclic_variables.h b/examples/c/queries/cyclic_variables/include/cyclic_variables.h
similarity index 100%
rename from examples/c/rules/cyclic_variables/include/cyclic_variables.h
rename to examples/c/queries/cyclic_variables/include/cyclic_variables.h
diff --git a/examples/cpp/rules/cyclic_variables/include/cyclic_variables/bake_config.h b/examples/c/queries/cyclic_variables/include/cyclic_variables/bake_config.h
similarity index 100%
rename from examples/cpp/rules/cyclic_variables/include/cyclic_variables/bake_config.h
rename to examples/c/queries/cyclic_variables/include/cyclic_variables/bake_config.h
diff --git a/examples/c/rules/cyclic_variables/project.json b/examples/c/queries/cyclic_variables/project.json
similarity index 100%
rename from examples/c/rules/cyclic_variables/project.json
rename to examples/c/queries/cyclic_variables/project.json
diff --git a/examples/c/rules/cyclic_variables/src/main.c b/examples/c/queries/cyclic_variables/src/main.c
similarity index 53%
rename from examples/c/rules/cyclic_variables/src/main.c
rename to examples/c/queries/cyclic_variables/src/main.c
index 3d3c78d18..11cd63fb7 100644
--- a/examples/c/rules/cyclic_variables/src/main.c
+++ b/examples/c/queries/cyclic_variables/src/main.c
@@ -1,7 +1,7 @@
 #include <cyclic_variables.h>
 #include <stdio.h>
 
-// This example shows how a rule may have terms with cyclic dependencies on
+// This example shows how a query may have terms with cyclic dependencies on
 // variables.
 
 int main(int argc, char *argv[]) {
@@ -9,10 +9,10 @@ int main(int argc, char *argv[]) {
 
     ECS_TAG(ecs, Likes); // Likes relationship
 
-    ecs_entity_t bob = ecs_new_entity(ecs, "Bob");
-    ecs_entity_t alice = ecs_new_entity(ecs, "Alice");
-    ecs_entity_t john = ecs_new_entity(ecs, "John");
-    ecs_entity_t jane = ecs_new_entity(ecs, "Jane");
+    ecs_entity_t bob = ecs_entity(ecs, { .name = "Bob" });
+    ecs_entity_t alice = ecs_entity(ecs, { .name = "Alice" });
+    ecs_entity_t john = ecs_entity(ecs, { .name = "John" });
+    ecs_entity_t jane = ecs_entity(ecs, { .name = "Jane" });
 
     ecs_add_pair(ecs, bob, Likes, alice);
     ecs_add_pair(ecs, alice, Likes, bob);
@@ -20,49 +20,41 @@ int main(int argc, char *argv[]) {
     ecs_add_pair(ecs, jane, Likes, john);
     ecs_add_pair(ecs, bob, Likes, jane); // inserting a bit of drama
 
-    // The following rule will only return entities that have a cyclic Likes
+    // The following query will only return entities that have a cyclic Likes
     // relationship- that is they must both like each other.
     //
     // The equivalent query in the DSL is:
     //   Likes($X, $Y), Likes($Y, $X)
     //
     // This is also an example of a query where all sources are variables. By
-    // default queries use the builtin "This" variable as subject, which is what
+    // default queries use the builtin "this" variable as subject, which is what
     // populates the entities array in the query result (accessed by the
     // iter::entity function).
     //
     // Because this query does not use This at all, the entities array will not
     // be populated, and it.count() will always be 0.
-    // Create a rule to find all ranged units
-    ecs_rule_t *r = ecs_rule(ecs, {
+    // Create a query to find all ranged units
+    ecs_query_t *q = ecs_query(ecs, {
         .terms = {
-            { 
-                .first.id = Likes, 
-                .src = { .name = "X", .flags = EcsIsVariable },
-                .second = { .name = "Y", .flags = EcsIsVariable }
-            },
-            { 
-                .first.id = Likes, 
-                .src = { .name = "Y", .flags = EcsIsVariable },
-                .second = { .name = "X", .flags = EcsIsVariable }
-            }
+            { .first.id = Likes, .src.name = "$x", .second.name = "$y" },
+            { .first.id = Likes, .src.name = "$y", .second.name = "$x" }
         }
     });
 
     // Lookup the index of the variables. This will let us quickly lookup their
     // values while we're iterating.
-    int x_var = ecs_rule_find_var(r, "X");
-    int y_var = ecs_rule_find_var(r, "Y");
+    int x_var = ecs_query_find_var(q, "x");
+    int y_var = ecs_query_find_var(q, "y");
 
-    // Iterate the rule
-    ecs_iter_t it = ecs_rule_iter(ecs, r);
-    while (ecs_rule_next(&it)) {
+    // Iterate the query
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    while (ecs_query_next(&it)) {
         ecs_entity_t x = ecs_iter_get_var(&it, x_var);
         ecs_entity_t y = ecs_iter_get_var(&it, y_var);
         printf("%s likes %s\n", ecs_get_name(ecs, x), ecs_get_name(ecs, y));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     // Output
     //  Bob likes Alice
@@ -70,10 +62,10 @@ int main(int argc, char *argv[]) {
     //  John likes Jane
     //  Alice likes Bob
 
-    // Note that the rule returns each pair twice. The reason for this is that
-    // the goal of the rule engine is to return all "facts" that are true
+    // Note that the query returns each pair twice. The reason for this is that
+    // the goal of the query engine is to return all "facts" that are true
     // within the given constraints. Since we did not give it any constraints
-    // that would favor a person being matched by X or Y, the rule engine
+    // that would favor a person being matched by X or Y, the query
     // returns both.
 
     return ecs_fini(ecs);
diff --git a/examples/c/rules/facts/include/facts.h b/examples/c/queries/facts/include/facts.h
similarity index 100%
rename from examples/c/rules/facts/include/facts.h
rename to examples/c/queries/facts/include/facts.h
diff --git a/examples/cpp/rules/facts/include/facts/bake_config.h b/examples/c/queries/facts/include/facts/bake_config.h
similarity index 100%
rename from examples/cpp/rules/facts/include/facts/bake_config.h
rename to examples/c/queries/facts/include/facts/bake_config.h
diff --git a/examples/c/rules/facts/project.json b/examples/c/queries/facts/project.json
similarity index 100%
rename from examples/c/rules/facts/project.json
rename to examples/c/queries/facts/project.json
diff --git a/examples/c/rules/facts/src/main.c b/examples/c/queries/facts/src/main.c
similarity index 56%
rename from examples/c/rules/facts/src/main.c
rename to examples/c/queries/facts/src/main.c
index 0bbcc24c4..ce7a25781 100644
--- a/examples/c/rules/facts/src/main.c
+++ b/examples/c/queries/facts/src/main.c
@@ -1,14 +1,14 @@
 #include <facts.h>
 #include <stdio.h>
 
-// This example shows how to use rules for testing facts. A fact is a query that
-// has no variable elements. Consider a regular ECS query like this:
+// This example shows how to use queries for testing facts. A fact is a query 
+// that has no variable elements. Consider a regular ECS query like this:
 //   Position, Velocity
 //
 // When written out in full, this query looks like:
-//   Position($This), Velocity($This)
+//   Position($this), Velocity($this)
 //
-// "This" is a (builtin) query variable that is unknown before we evaluate the 
+// "this" is a (builtin) query variable that is unknown before we evaluate the 
 // query. Therefore this query does not test a fact, we can't know which values
 // This will assume.
 //
@@ -16,7 +16,7 @@
 //   IsA(Cat, Animal)
 //
 // This is a fact: the query has no elements that are unknown before evaluating
-// the query. A rule that checks a fact does not return entities, but will
+// the query. A query that checks a fact does not return entities, but will
 // instead return the reasons why a fact is true (if it is true).
 
 int main(int argc, char *argv[]) {
@@ -24,10 +24,10 @@ int main(int argc, char *argv[]) {
 
     ECS_TAG(ecs, Likes); // Likes relationship
 
-    ecs_entity_t bob = ecs_new_entity(ecs, "Bob");
-    ecs_entity_t alice = ecs_new_entity(ecs, "Alice");
-    ecs_entity_t john = ecs_new_entity(ecs, "John");
-    ecs_entity_t jane = ecs_new_entity(ecs, "Jane");
+    ecs_entity_t bob = ecs_entity(ecs, { .name = "Bob" });
+    ecs_entity_t alice = ecs_entity(ecs, { .name = "Alice" });
+    ecs_entity_t john = ecs_entity(ecs, { .name = "John" });
+    ecs_entity_t jane = ecs_entity(ecs, { .name = "Jane" });
 
     ecs_add_pair(ecs, bob, Likes, alice);
     ecs_add_pair(ecs, alice, Likes, bob);
@@ -35,50 +35,42 @@ int main(int argc, char *argv[]) {
     ecs_add_pair(ecs, jane, Likes, john);
     ecs_add_pair(ecs, bob, Likes, jane); // inserting a bit of drama
 
-    // Create a rule that checks if two entities like each other. By itself this
-    // rule is not a fact, but we can use it to check facts by populating both
+    // Create a query that checks if two entities like each other. By itself this
+    // query is not a fact, but we can use it to check facts by populating both
     // of its variables.
     //
     // The equivalent of this query in the DSL is:
     //   Likes($X, $Y), Likes($Y, $X)
     //
-    // Instead of using variables we could have created a rule that referred the
-    // entities directly, but then we would have to create a rule for each
-    // fact, vs reusing a single rule for multiple facts.
+    // Instead of using variables we could have created a query that referred the
+    // entities directly, but then we would have to create a query for each
+    // fact, vs reusing a single query for multiple facts.
     //
     // See the setting_variables example for more details
-    ecs_rule_t *friends = ecs_rule(ecs, {
+    ecs_query_t *friends = ecs_query(ecs, {
         .terms = {
-            { 
-                .first.id = Likes, 
-                .src = { .name = "X", .flags = EcsIsVariable },
-                .second = { .name = "Y", .flags = EcsIsVariable }
-            },
-            { 
-                .first.id = Likes, 
-                .src = { .name = "Y", .flags = EcsIsVariable },
-                .second = { .name = "X", .flags = EcsIsVariable }
-            }
+            { .first.id = Likes, .src.name = "$x", .second.name = "$y" },
+            { .first.id = Likes, .src.name = "$x", .second.name = "$x" }
         }
     });
 
     // Lookup the index of the variables.
-    int x_var = ecs_rule_find_var(friends, "X");
-    int y_var = ecs_rule_find_var(friends, "Y");
+    int x_var = ecs_query_find_var(friends, "x");
+    int y_var = ecs_query_find_var(friends, "y");
 
-    ecs_iter_t it = ecs_rule_iter(ecs, friends);
+    ecs_iter_t it = ecs_query_iter(ecs, friends);
     ecs_iter_set_var(&it, x_var, bob);
     ecs_iter_set_var(&it, y_var, alice);
     printf("Are Bob and Alice friends? %s\n",
         ecs_iter_is_true(&it) ? "Yes" : "No");
 
-    it = ecs_rule_iter(ecs, friends);
+    it = ecs_query_iter(ecs, friends);
     ecs_iter_set_var(&it, x_var, bob);
     ecs_iter_set_var(&it, y_var, john);
     printf("Are Bob and John friends? %s\n",
         ecs_iter_is_true(&it) ? "Yes" : "No");
 
-    it = ecs_rule_iter(ecs, friends);
+    it = ecs_query_iter(ecs, friends);
     ecs_iter_set_var(&it, x_var, jane);
     ecs_iter_set_var(&it, y_var, john);
     printf("Are Jane and John friends? %s\n",
@@ -86,13 +78,13 @@ int main(int argc, char *argv[]) {
 
     // It doesn't matter who we assign to X or Y. After the variables are 
     // substituted, either yields a fact that is true.
-    it = ecs_rule_iter(ecs, friends);
+    it = ecs_query_iter(ecs, friends);
     ecs_iter_set_var(&it, x_var, john);
     ecs_iter_set_var(&it, y_var, jane);
     printf("Are John and Jane friends? %s\n",
         ecs_iter_is_true(&it) ? "Yes" : "No"); 
 
-    ecs_rule_fini(friends);
+    ecs_query_fini(friends);
 
     // Output
     //  Are Bob and Alice friends? Yes
diff --git a/examples/c/queries/group_by/include/group_by/bake_config.h b/examples/c/queries/group_by/include/group_by/bake_config.h
index ad8665017..838f2c63e 100644
--- a/examples/c/queries/group_by/include/group_by/bake_config.h
+++ b/examples/c/queries/group_by/include/group_by/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef GROUP_BY_BAKE_CONFIG_H
-#define GROUP_BY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef GROUP_BY_BAKE_CONFIG_H
+#define GROUP_BY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/group_by/src/main.c b/examples/c/queries/group_by/src/main.c
index acd4647ad..236f1d9e7 100644
--- a/examples/c/queries/group_by/src/main.c
+++ b/examples/c/queries/group_by/src/main.c
@@ -40,13 +40,13 @@ int main(int argc, char *argv[]) {
 
     // Grouped query
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_id(Position) }
         },
         // Group tables by the relationship target of the "Group" relationship.
         // A custom group_by function can be provided to derive a group id from
         // a table, see the group_by_custom example for more details.
-        .group_by_id = Group
+        .group_by = Group
     });
 
     // Create entities in 6 different tables with 3 group ids
@@ -88,7 +88,7 @@ int main(int argc, char *argv[]) {
     // Iterate query, print position & table components
     ecs_iter_t it = ecs_query_iter(ecs, q);
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
         char *table_str = ecs_table_str(ecs, it.table);
         char *group_str = ecs_get_fullpath(ecs, it.group_id);
 
diff --git a/examples/c/queries/group_by_callbacks/include/group_by_callbacks/bake_config.h b/examples/c/queries/group_by_callbacks/include/group_by_callbacks/bake_config.h
index 3d1e038c3..463c93238 100644
--- a/examples/c/queries/group_by_callbacks/include/group_by_callbacks/bake_config.h
+++ b/examples/c/queries/group_by_callbacks/include/group_by_callbacks/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef GROUP_BY_CALLBACKS_BAKE_CONFIG_H
-#define GROUP_BY_CALLBACKS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef GROUP_BY_CALLBACKS_BAKE_CONFIG_H
+#define GROUP_BY_CALLBACKS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/group_by_callbacks/src/main.c b/examples/c/queries/group_by_callbacks/src/main.c
index 2aaafb56f..0b26afd5a 100644
--- a/examples/c/queries/group_by_callbacks/src/main.c
+++ b/examples/c/queries/group_by_callbacks/src/main.c
@@ -62,10 +62,10 @@ int main(int argc, char *argv[]) {
 
     // Grouped query
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_id(Position) }
         },
-        .group_by_id = Group,
+        .group_by = Group,
         .on_group_create = on_group_create,
         .on_group_delete = on_group_delete
     });
@@ -111,7 +111,7 @@ int main(int argc, char *argv[]) {
     // Iterate query, print position & table components
     ecs_iter_t it = ecs_query_iter(ecs, q);
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
         char *table_str = ecs_table_str(ecs, it.table);
         char *group_str = ecs_get_fullpath(ecs, it.group_id);
         group_ctx *ctx = ecs_query_get_group_ctx(q, it.group_id);
diff --git a/examples/c/queries/group_by_custom/include/group_by_custom/bake_config.h b/examples/c/queries/group_by_custom/include/group_by_custom/bake_config.h
index 65b630337..2413007d2 100644
--- a/examples/c/queries/group_by_custom/include/group_by_custom/bake_config.h
+++ b/examples/c/queries/group_by_custom/include/group_by_custom/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef GROUP_BY_CUSTOM_BAKE_CONFIG_H
-#define GROUP_BY_CUSTOM_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef GROUP_BY_CUSTOM_BAKE_CONFIG_H
+#define GROUP_BY_CUSTOM_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/group_by_custom/src/main.c b/examples/c/queries/group_by_custom/src/main.c
index fe36ec469..aa3e4a8be 100644
--- a/examples/c/queries/group_by_custom/src/main.c
+++ b/examples/c/queries/group_by_custom/src/main.c
@@ -40,11 +40,11 @@ int main(int argc, char *argv[]) {
 
     // Grouped query
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_id(Position) }
         },
-        .group_by = group_by_relation,
-        .group_by_id = Group // Passed to id argument of group_by function
+        .group_by_callback = group_by_relation,
+        .group_by = Group // Passed to id argument of group_by function
     });
 
     // Create entities in 6 different tables with 3 group ids
@@ -86,7 +86,7 @@ int main(int argc, char *argv[]) {
     // Iterate query, print position & table components
     ecs_iter_t it = ecs_query_iter(ecs, q);
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
         char *table_str = ecs_table_str(ecs, it.table);
         char *group_str = ecs_get_fullpath(ecs, it.group_id);
 
diff --git a/examples/c/queries/group_iter/include/group_iter/bake_config.h b/examples/c/queries/group_iter/include/group_iter/bake_config.h
index bde625a5c..0f67f72d6 100644
--- a/examples/c/queries/group_iter/include/group_iter/bake_config.h
+++ b/examples/c/queries/group_iter/include/group_iter/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef GROUP_ITER_BAKE_CONFIG_H
-#define GROUP_ITER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef GROUP_ITER_BAKE_CONFIG_H
+#define GROUP_ITER_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/group_iter/src/main.c b/examples/c/queries/group_iter/src/main.c
index f596769fb..5ba2734c5 100644
--- a/examples/c/queries/group_iter/src/main.c
+++ b/examples/c/queries/group_iter/src/main.c
@@ -77,11 +77,11 @@ int main(int argc, char *argv[]) {
 
     // Create a query that matches all Npc's, grouped by WorldCell
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = Npc }
         },
-        .group_by = group_by_relation,
-        .group_by_id = WorldCell
+        .group_by_callback = group_by_relation,
+        .group_by = WorldCell
     });
 
     // Iterate all tables
@@ -104,7 +104,7 @@ int main(int argc, char *argv[]) {
     // Only iterate entities in cell 1_0
     printf("Tables for cell 1_0:\n");
     it = ecs_query_iter(ecs, q);
-    ecs_query_set_group(&it, Cell_1_0);
+    ecs_iter_set_group(&it, Cell_1_0);
     while (ecs_query_next(&it)) {
         char *table_str = ecs_table_str(ecs, it.table);
         char *group_str = ecs_get_fullpath(ecs, it.group_id);
diff --git a/examples/c/queries/hierarchies/include/hierarchies/bake_config.h b/examples/c/queries/hierarchies/include/hierarchies/bake_config.h
index 1bee040d0..9cd0466d3 100644
--- a/examples/c/queries/hierarchies/include/hierarchies/bake_config.h
+++ b/examples/c/queries/hierarchies/include/hierarchies/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HIERARCHIES_BAKE_CONFIG_H
-#define HIERARCHIES_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HIERARCHIES_BAKE_CONFIG_H
+#define HIERARCHIES_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/hierarchies/src/main.c b/examples/c/queries/hierarchies/src/main.c
index 0be14962a..f7be591f2 100644
--- a/examples/c/queries/hierarchies/src/main.c
+++ b/examples/c/queries/hierarchies/src/main.c
@@ -16,26 +16,26 @@ int main(int argc, char *argv[]) {
     ECS_TAG(ecs, World);
 
     // Create a hierarchy. For an explanation see the entities/hierarchy example
-    ecs_entity_t sun = ecs_new_entity(ecs, "Sun");
+    ecs_entity_t sun = ecs_entity(ecs, { .name = "Sun" });
     ecs_add_pair(ecs, sun, ecs_id(Position), World);
     ecs_set_pair(ecs, sun, Position, Local, {1, 1});
 
-        ecs_entity_t mercury = ecs_new_entity(ecs, "Mercury");
+        ecs_entity_t mercury = ecs_entity(ecs, { .name = "Mercury" });
         ecs_add_pair(ecs, mercury, EcsChildOf, sun);
         ecs_add_pair(ecs, mercury, ecs_id(Position), World);
         ecs_set_pair(ecs, mercury, Position, Local, {1, 1});
 
-        ecs_entity_t venus = ecs_new_entity(ecs, "Venus");
+        ecs_entity_t venus = ecs_entity(ecs, { .name = "Venus" });
         ecs_add_pair(ecs, venus, EcsChildOf, sun);
         ecs_add_pair(ecs, venus, ecs_id(Position), World);
         ecs_set_pair(ecs, venus, Position, Local, {2, 2});
 
-        ecs_entity_t earth = ecs_new_entity(ecs, "Earth");
+        ecs_entity_t earth = ecs_entity(ecs, { .name = "Earth" });
         ecs_add_pair(ecs, earth, EcsChildOf, sun);
         ecs_add_pair(ecs, earth, ecs_id(Position), World);
         ecs_set_pair(ecs, earth, Position, Local, {3, 3});
 
-            ecs_entity_t moon = ecs_new_entity(ecs, "Moon");
+            ecs_entity_t moon = ecs_entity(ecs, { .name = "Moon" });
             ecs_add_pair(ecs, moon, EcsChildOf, earth);
             ecs_add_pair(ecs, moon, ecs_id(Position), World);
             ecs_set_pair(ecs, moon, Position, Local, {0.1, 0.1});
@@ -43,7 +43,7 @@ int main(int argc, char *argv[]) {
     // Create a hierarchical query to compute the global position from the
     // local position and the parent position.
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             // Read from entity's Local position
             { .id = ecs_pair(ecs_id(Position), Local), .inout = EcsIn }, 
             // Write to entity's World position
@@ -53,8 +53,8 @@ int main(int argc, char *argv[]) {
             {
                 .id = ecs_pair(ecs_id(Position), World), 
                 .inout = EcsIn,
-                // Get from the parent, in breadth-first order (cascade)
-                .src.flags = EcsParent | EcsCascade,
+                // Get from the parent in breadth-first order (cascade)
+                .src.id = EcsCascade,
                 // Make parent term optional so we also match the root (sun)
                 .oper = EcsOptional
             }
@@ -64,9 +64,9 @@ int main(int argc, char *argv[]) {
     // Do the transform
     ecs_iter_t it = ecs_query_iter(ecs, q);
     while (ecs_query_next(&it)) {
-        const Position *p = ecs_field(&it, Position, 1);
-        Position *p_out = ecs_field(&it, Position, 2);
-        const Position *p_parent = ecs_field(&it, Position, 3);
+        const Position *p = ecs_field(&it, Position, 0);
+        Position *p_out = ecs_field(&it, Position, 1);
+        const Position *p_parent = ecs_field(&it, Position, 2);
         
         // Inner loop, iterates entities in archetype
         for (int i = 0; i < it.count; i ++) {
@@ -80,12 +80,9 @@ int main(int argc, char *argv[]) {
     }
 
     // Print ecs positions
-    it = ecs_term_iter(ecs, &(ecs_term_t) {
-        .id = ecs_pair(ecs_id(Position), World)
-    });
-
-    while (ecs_term_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+    it = ecs_each_pair_t(ecs, Position, World);
+    while (ecs_each_next(&it)) {
+        Position *p = ecs_field(&it, Position, 0);
         for (int i = 0; i < it.count; i ++) {
             printf("%s: {%f, %f}\n", ecs_get_name(ecs, it.entities[i]),
                 p[i].x, p[i].y);
diff --git a/examples/c/queries/instancing/include/instancing/bake_config.h b/examples/c/queries/instancing/include/instancing/bake_config.h
index 8a716585a..f1866b26b 100644
--- a/examples/c/queries/instancing/include/instancing/bake_config.h
+++ b/examples/c/queries/instancing/include/instancing/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef INSTANCING_BAKE_CONFIG_H
-#define INSTANCING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef INSTANCING_BAKE_CONFIG_H
+#define INSTANCING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/instancing/src/main.c b/examples/c/queries/instancing/src/main.c
index 887a98cfd..530129164 100644
--- a/examples/c/queries/instancing/src/main.c
+++ b/examples/c/queries/instancing/src/main.c
@@ -40,35 +40,33 @@ int main(int argc, char *argv[]) {
     // Create a query for Position, Velocity. We'll create a few entities that
     // have Velocity as owned and shared component.
     ecs_query_t *q = ecs_query(world, {
-        .filter = {
-            .terms = {
-                // Position must always be owned by the entity
-                { .id = ecs_id(Position), .src.flags = EcsSelf }, 
-                { .id = ecs_id(Velocity) } // Velocity may be shared (default)
-            },
-            .instanced = true
-        }
+        .terms = {
+            // Position must always be owned by the entity
+            { .id = ecs_id(Position), .src.id = EcsSelf }, 
+            { .id = ecs_id(Velocity) } // Velocity may be shared (default)
+        },
+        .flags = EcsQueryIsInstanced
     });
 
     // Create a prefab with Velocity. Prefabs are not matched with queries.
-    ecs_entity_t prefab = ecs_new_prefab(world, "p");
+    ecs_entity_t prefab = ecs_entity(world, { .name = "p", .add = ecs_ids( EcsPrefab ) });
     ecs_set(world, prefab, Velocity, {1, 2});
 
     // Create a few entities that own Position & share Velocity from the prefab.
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add_pair(world, e1, EcsIsA, prefab);
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_pair(world, e2, EcsIsA, prefab);
     ecs_set(world, e2, Position, {10, 20});
 
     // Create a few entities that own all components
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_set(world, e3, Position, {10, 20});
     ecs_set(world, e3, Velocity, {3, 4});
 
-    ecs_entity_t e4 = ecs_new_entity(world, "e4");
+    ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
     ecs_set(world, e4, Position, {10, 20});
     ecs_set(world, e4, Velocity, {4, 5});
 
@@ -78,12 +76,12 @@ int main(int argc, char *argv[]) {
     // in the case of a shared field, it is accessed as a pointer.
     ecs_iter_t it = ecs_query_iter(world, q);
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
 
         // Check if Velocity is owned, in which case it's accessed as array.
         // Position will always be owned, since we set the term to Self.
-        if (ecs_field_is_self(&it, 2)) { // Velocity is term 2
+        if (ecs_field_is_self(&it, 1)) { // Velocity is term 2
             printf("Velocity is owned\n");
             for (int i = 0; i < it.count; i ++) {
                 // If Velocity is shared, access the field as an array.
diff --git a/examples/c/rules/setting_variables/.gitignore b/examples/c/queries/setting_variables/.gitignore
similarity index 100%
rename from examples/c/rules/setting_variables/.gitignore
rename to examples/c/queries/setting_variables/.gitignore
diff --git a/examples/c/rules/setting_variables/include/setting_variables.h b/examples/c/queries/setting_variables/include/setting_variables.h
similarity index 100%
rename from examples/c/rules/setting_variables/include/setting_variables.h
rename to examples/c/queries/setting_variables/include/setting_variables.h
diff --git a/examples/cpp/rules/setting_variables/include/setting_variables/bake_config.h b/examples/c/queries/setting_variables/include/setting_variables/bake_config.h
similarity index 100%
rename from examples/cpp/rules/setting_variables/include/setting_variables/bake_config.h
rename to examples/c/queries/setting_variables/include/setting_variables/bake_config.h
diff --git a/examples/c/rules/setting_variables/project.json b/examples/c/queries/setting_variables/project.json
similarity index 100%
rename from examples/c/rules/setting_variables/project.json
rename to examples/c/queries/setting_variables/project.json
diff --git a/examples/c/rules/setting_variables/src/main.c b/examples/c/queries/setting_variables/src/main.c
similarity index 71%
rename from examples/c/rules/setting_variables/src/main.c
rename to examples/c/queries/setting_variables/src/main.c
index 9a5b04e77..77ef071d3 100644
--- a/examples/c/rules/setting_variables/src/main.c
+++ b/examples/c/queries/setting_variables/src/main.c
@@ -2,7 +2,7 @@
 #include <stdio.h>
 
 // This example extends the component_inheritance example, and shows how
-// we can use a single rule to match units from different players and platoons
+// we can use a single query to match units from different players and platoons
 // by setting query variables before we iterate.
 //
 // The units in this example belong to a platoon, with the platoons belonging
@@ -35,9 +35,9 @@ int main(int argc, char *argv[]) {
 
         // Give first player a name so we can look it up later
         if (p == 0) {
-            player = ecs_new_entity(ecs, "MyPlayer");
+            player = ecs_entity(ecs, { .name = "MyPlayer" });
         } else {
-            player = ecs_new_id(ecs);
+            player = ecs_new(ecs);
         }
 
         // Add player tag so we can query for all players if we want to
@@ -50,56 +50,49 @@ int main(int argc, char *argv[]) {
             ecs_add(ecs, platoon, Platoon);
 
             // Add warriors, wizards and marksmen to the platoon
-            ecs_entity_t warrior = ecs_new(ecs, Warrior);
+            ecs_entity_t warrior = ecs_new_w(ecs, Warrior);
             ecs_add_pair(ecs, warrior, Platoon, platoon);
 
-            ecs_entity_t marksman = ecs_new(ecs, Marksman);
+            ecs_entity_t marksman = ecs_new_w(ecs, Marksman);
             ecs_add_pair(ecs, marksman, Platoon, platoon);
 
-            ecs_entity_t wizard = ecs_new(ecs, Wizard);
+            ecs_entity_t wizard = ecs_new_w(ecs, Wizard);
             ecs_add_pair(ecs, wizard, Platoon, platoon);
         }
     }
 
-    // Create a rule to find all RangedUnits for a platoon/player. The 
+    // Create a query to find all RangedUnits for a platoon/player. The 
     // equivalent query in the query DSL would look like this:
     //   (Platoon, $Platoon), Player($Platoon, $Player)
     //
     // The way to read how this query is evaluated is:
-    // - find all entities with (Platoon, *), store * in _Platoon
-    // - check if _Platoon has (Player, *), store * in _Player
-    ecs_rule_t *r = ecs_rule(ecs, {
+    // - find all entities with (Platoon, *), store * in $platoon
+    // - check if $platoon has (Player, *), store * in $player
+    ecs_query_t *q = ecs_query(ecs, {
         .terms = {
             { .first.id = RangedUnit },
-            {
-                .first.id = Platoon, 
-                .second = { .name = "Platoon", .flags = EcsIsVariable },
-            },
-            { 
-                .first.id = Player, 
-                .src = { .name = "Platoon", .flags = EcsIsVariable },
-                .second = { .name = "Player", .flags = EcsIsVariable },
-            }
+            { .first.id = Platoon, .second.name = "$platoon" },
+            { .first.id = Player,  .src.name     = "$platoon", .second.name = "$player" }
         }
     });
 
-    // If we would iterate this rule it would return all ranged units for all
+    // If we would iterate this query it would return all ranged units for all
     // platoons & for all players. We can limit the results to just a single
     // platoon or a single player setting a variable beforehand. In this example
     // we'll just find all platoons & ranged units for a single player.
 
-    int player_var = ecs_rule_find_var(r, "Player");
-    int platoon_var = ecs_rule_find_var(r, "Platoon");
+    int player_var = ecs_query_find_var(q, "player");
+    int platoon_var = ecs_query_find_var(q, "platoon");
 
-    // Iterate rule, limit the results to units of MyPlayer
-    ecs_iter_t it = ecs_rule_iter(ecs, r);
+    // Iterate query, limit the results to units of MyPlayer
+    ecs_iter_t it = ecs_query_iter(ecs, q);
     ecs_iter_set_var(&it, player_var, ecs_lookup(ecs, "MyPlayer"));
 
-    while (ecs_rule_next(&it)) {
+    while (ecs_query_next(&it)) {
         ecs_entity_t player = ecs_iter_get_var(&it, player_var);
         ecs_entity_t platoon = ecs_iter_get_var(&it, platoon_var);
         char *platoon_str = ecs_get_fullpath(ecs, platoon);
-        char *class_str = ecs_id_str(ecs, ecs_field_id(&it, 1));
+        char *class_str = ecs_id_str(ecs, ecs_field_id(&it, 0));
 
         for (int i = 0; i < it.count; i ++) {
             char *unit_str = ecs_get_fullpath(ecs, it.entities[i]);
@@ -113,7 +106,7 @@ int main(int argc, char *argv[]) {
         ecs_os_free(platoon_str);
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     // Output
     //  Unit 513 of class Wizard in platoon 510 for player MyPlayer
diff --git a/examples/c/queries/singleton/include/singleton/bake_config.h b/examples/c/queries/singleton/include/singleton/bake_config.h
index 0e7de1e5e..4d158e277 100644
--- a/examples/c/queries/singleton/include/singleton/bake_config.h
+++ b/examples/c/queries/singleton/include/singleton/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SINGLETON_BAKE_CONFIG_H
-#define SINGLETON_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SINGLETON_BAKE_CONFIG_H
+#define SINGLETON_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/singleton/src/main.c b/examples/c/queries/singleton/src/main.c
index 49ec36acb..196e02672 100644
--- a/examples/c/queries/singleton/src/main.c
+++ b/examples/c/queries/singleton/src/main.c
@@ -22,9 +22,9 @@ int main(int argc, char *argv[]) {
     // Set singleton
     ecs_singleton_set(ecs, Gravity, { 9.81 });
 
-    ecs_entity_t e1 = ecs_new_entity(ecs, "e1");
-    ecs_entity_t e2 = ecs_new_entity(ecs, "e2");
-    ecs_entity_t e3 = ecs_new_entity(ecs, "e3");
+    ecs_entity_t e1 = ecs_entity(ecs, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(ecs, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(ecs, { .name = "e3" });
 
     // Set Velocity
     ecs_set(ecs, e1, Velocity, {0, 0});
@@ -33,7 +33,7 @@ int main(int argc, char *argv[]) {
 
     // Create query that matches Gravity as singleton
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_id(Velocity) },
             // A singleton is a component matched on itself
             { .id = ecs_id(Gravity), .src.id =  ecs_id(Gravity) }
@@ -41,7 +41,7 @@ int main(int argc, char *argv[]) {
 
         // Optional, but lets us iterate entities in bulk even though the query
         // returns fields with mixed counts (see query manual).
-        .filter.instanced = true
+        .flags = EcsQueryIsInstanced
     });
 
     // In a query string expression you can use the $ shortcut for singletons:
@@ -49,8 +49,8 @@ int main(int argc, char *argv[]) {
 
     ecs_iter_t it = ecs_query_iter(ecs, q);
     while (ecs_query_next(&it)) {
-        Velocity *v = ecs_field(&it, Velocity, 1);
-        Gravity *g = ecs_field(&it, Gravity, 2);
+        Velocity *v = ecs_field(&it, Velocity, 0);
+        Gravity *g = ecs_field(&it, Gravity, 1);
 
         for (int i = 0; i < it.count; i ++) {
             // Make sure to access g as a pointer, as we only have a single
diff --git a/examples/c/queries/sorting/include/sorting/bake_config.h b/examples/c/queries/sorting/include/sorting/bake_config.h
index 1f6db54b3..5b9002713 100644
--- a/examples/c/queries/sorting/include/sorting/bake_config.h
+++ b/examples/c/queries/sorting/include/sorting/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SORTING_BAKE_CONFIG_H
-#define SORTING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SORTING_BAKE_CONFIG_H
+#define SORTING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/sorting/src/main.c b/examples/c/queries/sorting/src/main.c
index 7d771d5cf..aa6f2be8e 100644
--- a/examples/c/queries/sorting/src/main.c
+++ b/examples/c/queries/sorting/src/main.c
@@ -18,7 +18,7 @@ int compare_position(
 }
 
 void print_position(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     for (int i = 0; i < it->count; i ++) {
         printf("{%.1f, %.1f}\n", p[i].x, p[i].y);
     }
@@ -37,27 +37,27 @@ int main(int argc, char *argv[]) {
 
     ECS_COMPONENT(ecs, Position);
 
-    ecs_entity_t e = ecs_set(ecs, 0, Position, {1, 0});
-    ecs_set(ecs, 0, Position, {6, 0});
-    ecs_set(ecs, 0, Position, {2, 0});
-    ecs_set(ecs, 0, Position, {5, 0});
-    ecs_set(ecs, 0, Position, {4, 0});
+    ecs_entity_t e = ecs_insert(ecs, ecs_value(Position, {1, 0}));
+    ecs_insert(ecs, ecs_value(Position, {6, 0}));
+    ecs_insert(ecs, ecs_value(Position, {2, 0}));
+    ecs_insert(ecs, ecs_value(Position, {5, 0}));
+    ecs_insert(ecs, ecs_value(Position, {4, 0}));
 
     // Create a sorted system
     ecs_entity_t sys = ecs_system(ecs, {
         .query = {
-            .filter.terms = {{ .id = ecs_id(Position) }},
-            .order_by = (ecs_order_by_action_t)compare_position,
-            .order_by_component = ecs_id(Position) 
+            .terms = {{ .id = ecs_id(Position) }},
+            .order_by_callback = (ecs_order_by_action_t)compare_position,
+            .order_by = ecs_id(Position) 
         },
         .callback = print_position
     });
 
     // Create sorted query
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {{ .id = ecs_id(Position) }},
-        .order_by = (ecs_order_by_action_t)compare_position,
-        .order_by_component = ecs_id(Position)
+        .terms = {{ .id = ecs_id(Position) }},
+        .order_by_callback = (ecs_order_by_action_t)compare_position,
+        .order_by = ecs_id(Position)
     });
 
     // Iterate query, print values of Position
diff --git a/examples/c/rules/transitive_queries/include/transitive_queries.h b/examples/c/queries/transitive_queries/include/transitive_queries.h
similarity index 100%
rename from examples/c/rules/transitive_queries/include/transitive_queries.h
rename to examples/c/queries/transitive_queries/include/transitive_queries.h
diff --git a/examples/cpp/rules/transitive_queries/include/transitive_queries/bake_config.h b/examples/c/queries/transitive_queries/include/transitive_queries/bake_config.h
similarity index 100%
rename from examples/cpp/rules/transitive_queries/include/transitive_queries/bake_config.h
rename to examples/c/queries/transitive_queries/include/transitive_queries/bake_config.h
diff --git a/examples/c/rules/transitive_queries/project.json b/examples/c/queries/transitive_queries/project.json
similarity index 100%
rename from examples/c/rules/transitive_queries/project.json
rename to examples/c/queries/transitive_queries/project.json
diff --git a/examples/c/rules/transitive_queries/src/main.c b/examples/c/queries/transitive_queries/src/main.c
similarity index 67%
rename from examples/c/rules/transitive_queries/src/main.c
rename to examples/c/queries/transitive_queries/src/main.c
index 122aee7dd..57ff2596a 100644
--- a/examples/c/rules/transitive_queries/src/main.c
+++ b/examples/c/queries/transitive_queries/src/main.c
@@ -18,7 +18,7 @@ int main(int argc, char *argv[]) {
     ecs_world_t *ecs = ecs_init_w_args(argc, argv);
 
     // LocatedIn relationship
-    ecs_entity_t LocatedIn = ecs_new_id(ecs);
+    ecs_entity_t LocatedIn = ecs_new(ecs);
     ecs_add_id(ecs, LocatedIn, EcsTransitive);
 
     // Tags
@@ -30,94 +30,88 @@ int main(int argc, char *argv[]) {
     ECS_TAG(ecs, Person);
 
     // Populate the store with locations
-    ecs_entity_t earth = ecs_new_entity(ecs, "Earth");
+    ecs_entity_t earth = ecs_entity(ecs, { .name = "Earth" });
     ecs_add(ecs, earth, Planet);
 
     // Continents
-    ecs_entity_t north_america = ecs_new_entity(ecs, "NorthAmerica");
+    ecs_entity_t north_america = ecs_entity(ecs, { .name = "NorthAmerica" });
     ecs_add(ecs, north_america, Continent);
     ecs_add_pair(ecs, north_america, LocatedIn, earth);
 
-    ecs_entity_t europe = ecs_new_entity(ecs, "Europe");
+    ecs_entity_t europe = ecs_entity(ecs, { .name = "Europe" });
     ecs_add(ecs, europe, Continent);
     ecs_add_pair(ecs, europe, LocatedIn, earth);
 
     // Countries
-    ecs_entity_t united_states = ecs_new_entity(ecs, "UnitedStates");
+    ecs_entity_t united_states = ecs_entity(ecs, { .name = "UnitedStates" });
     ecs_add(ecs, united_states, Country);
     ecs_add_pair(ecs, united_states, LocatedIn, north_america);
 
-    ecs_entity_t netherlands = ecs_new_entity(ecs, "Netherlands");
+    ecs_entity_t netherlands = ecs_entity(ecs, { .name = "Netherlands" });
     ecs_add(ecs, netherlands, Country);
     ecs_add_pair(ecs, netherlands, LocatedIn, europe);
 
     // States
-    ecs_entity_t california = ecs_new_entity(ecs, "California");
+    ecs_entity_t california = ecs_entity(ecs, { .name = "California" });
     ecs_add(ecs, california, State);
     ecs_add_pair(ecs, california, LocatedIn, united_states);
 
-    ecs_entity_t washington = ecs_new_entity(ecs, "Washington");
+    ecs_entity_t washington = ecs_entity(ecs, { .name = "Washington" });
     ecs_add(ecs, washington, State);
     ecs_add_pair(ecs, washington, LocatedIn, united_states);
 
-    ecs_entity_t noord_holland = ecs_new_entity(ecs, "NoordHolland");
+    ecs_entity_t noord_holland = ecs_entity(ecs, { .name = "NoordHolland" });
     ecs_add(ecs, noord_holland, State);
     ecs_add_pair(ecs, noord_holland, LocatedIn, netherlands);
 
     // Cities
-    ecs_entity_t san_francisco = ecs_new_entity(ecs, "SanFrancisco");
+    ecs_entity_t san_francisco = ecs_entity(ecs, { .name = "SanFrancisco" });
     ecs_add(ecs, san_francisco, City);
     ecs_add_pair(ecs, san_francisco, LocatedIn, california);
 
-    ecs_entity_t seattle = ecs_new_entity(ecs, "Seattle");
+    ecs_entity_t seattle = ecs_entity(ecs, { .name = "Seattle" });
     ecs_add(ecs, seattle, City);
     ecs_add_pair(ecs, seattle, LocatedIn, washington);
 
-    ecs_entity_t amsterdam = ecs_new_entity(ecs, "Amsterdam");
+    ecs_entity_t amsterdam = ecs_entity(ecs, { .name = "Amsterdam" });
     ecs_add(ecs, amsterdam, City);
     ecs_add_pair(ecs, amsterdam, LocatedIn, noord_holland);
 
     // Inhabitants
-    ecs_entity_t bob = ecs_new_entity(ecs, "Bob");
+    ecs_entity_t bob = ecs_entity(ecs, { .name = "Bob" });
     ecs_add(ecs, bob, Person);
     ecs_add_pair(ecs, bob, LocatedIn, san_francisco);
 
-    ecs_entity_t alice = ecs_new_entity(ecs, "Alice");
+    ecs_entity_t alice = ecs_entity(ecs, { .name = "Alice" });
     ecs_add(ecs, alice, Person);
     ecs_add_pair(ecs, alice, LocatedIn, seattle);
 
-    ecs_entity_t job = ecs_new_entity(ecs, "Job");
+    ecs_entity_t job = ecs_entity(ecs, { .name = "Job" });
     ecs_add(ecs, job, Person);
     ecs_add_pair(ecs, job, LocatedIn, amsterdam);
 
     // Create a query that finds the countries persons live in. Note that these
     // have not been explicitly added to the Person entities, but because the
-    // LocatedIn is transitive, the rule engine will traverse the relationship
+    // LocatedIn is transitive, the query engine will traverse the relationship
     // until it found something that is a country.
     // 
     // The equivalent of this query in the DSL is:
-    //   Person, (LocatedIn, $Location), Country($Location)
-    ecs_rule_t *r = ecs_rule(ecs, {
+    //   Person, (LocatedIn, $location), Country($location)
+    ecs_query_t *q = ecs_query(ecs, {
         .terms = {
             { .id = Person },
-            { 
-                .first.id = LocatedIn, 
-                .second = { .name = "Location", .flags = EcsIsVariable },
-            },
-            {
-                .first.id = Country, 
-                .src = { .name = "Location", .flags = EcsIsVariable },
-            },
+            { .first.id = LocatedIn, .second.name = "$location" },
+            { .first.id = Country, .src.name = "$location" }
         }
     });
 
     // Lookup the index of the variable. This will let us quickly lookup its
     // value while we're iterating.
-    int location_var = ecs_rule_find_var(r, "Location");
+    int location_var = ecs_query_find_var(q, "location");
 
-    // Iterate the rule
-    ecs_iter_t it = ecs_rule_iter(ecs, r);
-    while (ecs_rule_next(&it)) {
+    // Iterate the query
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    while (ecs_query_next(&it)) {
         ecs_entity_t location = ecs_iter_get_var(&it, location_var);
         for (int i = 0; i < it.count; i ++) {
             printf("%s lives in %s\n",
@@ -126,7 +120,7 @@ int main(int argc, char *argv[]) {
         }
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     // Output:
     //   Bob lives in UnitedStates
diff --git a/examples/c/rules/basics/include/basics.h b/examples/c/queries/variables/include/variables.h
similarity index 66%
rename from examples/c/rules/basics/include/basics.h
rename to examples/c/queries/variables/include/variables.h
index 25fdbeffa..7d3167254 100644
--- a/examples/c/rules/basics/include/basics.h
+++ b/examples/c/queries/variables/include/variables.h
@@ -1,8 +1,8 @@
-#ifndef BASICS_H
-#define BASICS_H
+#ifndef VARIABLES_H
+#define VARIABLES_H
 
 /* This generated file contains includes for project dependencies */
-#include "basics/bake_config.h"
+#include "variables/bake_config.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/examples/cpp/rules/basics/include/basics/bake_config.h b/examples/c/queries/variables/include/variables/bake_config.h
similarity index 91%
rename from examples/cpp/rules/basics/include/basics/bake_config.h
rename to examples/c/queries/variables/include/variables/bake_config.h
index 0fcd5d6e7..f4997a774 100644
--- a/examples/cpp/rules/basics/include/basics/bake_config.h
+++ b/examples/c/queries/variables/include/variables/bake_config.h
@@ -14,8 +14,8 @@
  * dependencies will automatically show up in this file. Include bake_config.h
  * in your main project file. Do not edit! */
 
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
+#ifndef VARIABLES_BAKE_CONFIG_H
+#define VARIABLES_BAKE_CONFIG_H
 
 /* Headers of public dependencies */
 #include <flecs.h>
diff --git a/examples/c/rules/basics/project.json b/examples/c/queries/variables/project.json
similarity index 84%
rename from examples/c/rules/basics/project.json
rename to examples/c/queries/variables/project.json
index bfc33fb8f..8f6803c21 100644
--- a/examples/c/rules/basics/project.json
+++ b/examples/c/queries/variables/project.json
@@ -1,5 +1,5 @@
 {
-    "id": "basics",
+    "id": "variables",
     "type": "application",
     "value": {
         "use": [
diff --git a/examples/c/rules/basics/src/main.c b/examples/c/queries/variables/src/main.c
similarity index 59%
rename from examples/c/rules/basics/src/main.c
rename to examples/c/queries/variables/src/main.c
index c33c928f6..01b7451ab 100644
--- a/examples/c/rules/basics/src/main.c
+++ b/examples/c/queries/variables/src/main.c
@@ -1,4 +1,4 @@
-#include <basics.h>
+#include <variables.h>
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
@@ -7,31 +7,31 @@ int main(int argc, char *argv[]) {
     ECS_TAG(ecs, Eats);
     ECS_TAG(ecs, Healthy);
 
-    ecs_entity_t Apples = ecs_new_entity(ecs, "Apples");
-    ecs_entity_t Salad = ecs_new_entity(ecs, "Salad");
-    ecs_entity_t Burgers = ecs_new_entity(ecs, "Burgers");
-    ecs_entity_t Pizza = ecs_new_entity(ecs, "Pizza");
-    ecs_entity_t Chocolate = ecs_new_entity(ecs, "Chocolate");
+    ecs_entity_t Apples = ecs_entity(ecs, { .name = "Apples" });
+    ecs_entity_t Salad = ecs_entity(ecs, { .name = "Salad" });
+    ecs_entity_t Burgers = ecs_entity(ecs, { .name = "Burgers" });
+    ecs_entity_t Pizza = ecs_entity(ecs, { .name = "Pizza" });
+    ecs_entity_t Chocolate = ecs_entity(ecs, { .name = "Chocolate" });
 
     ecs_add(ecs, Apples, Healthy);
     ecs_add(ecs, Salad, Healthy);
 
-    ecs_entity_t bob = ecs_new_entity(ecs, "Bob");
+    ecs_entity_t bob = ecs_entity(ecs, { .name = "Bob" });
     ecs_add_pair(ecs, bob, Eats, Apples);
     ecs_add_pair(ecs, bob, Eats, Burgers);
     ecs_add_pair(ecs, bob, Eats, Pizza);
 
-    ecs_entity_t alice = ecs_new_entity(ecs, "Alice");
+    ecs_entity_t alice = ecs_entity(ecs, { .name = "Alice" });
     ecs_add_pair(ecs, alice, Eats, Salad);
     ecs_add_pair(ecs, alice, Eats, Chocolate);
     ecs_add_pair(ecs, alice, Eats, Apples);
 
-    // Here we're creating a rule that in the query DSL would look like this:
-    //   Eats($This, $Food), Healthy($Food)
+    // Here we're creating a query that in the query DSL would look like this:
+    //   Eats($this, $Food), Healthy($Food)
     //
     // Rules are similar to queries, but support more advanced features. This
     // example shows how the basics of how to use rules & variables.
-    ecs_rule_t *r = ecs_rule(ecs, {
+    ecs_query_t *q = ecs_query(ecs, {
         .terms = {
             // Query variables are like wildcards, but enforce that the entity
             // substituted by the wildcard is the same across terms.
@@ -40,24 +40,20 @@ int main(int argc, char *argv[]) {
             // substituted by the * for Eats is the same as for Healthy:
             //   (Eats, *), Healthy(*)
             //
-            // By replacing * with _Food, both terms are constrained to use the
-            // same entity.
-            { .first.id = Eats, .second = { 
-                .name = "Food", .flags = EcsIsVariable },
-            },
-            { .first.id = Healthy, .src = {
-                .name = "Food", .flags = EcsIsVariable }
-            }
+            // By replacing * with $food, both terms will be constrained to
+            // match the same entity for the wildcard.
+            { .first.id = Eats,    .second.name = "$food" },
+            { .first.id = Healthy, .src.name    = "$food" }
         }
     });
 
     // Lookup the index of the variable. This will let us quickly lookup its
     // value while we're iterating.
-    int food_var = ecs_rule_find_var(r, "Food");
+    int food_var = ecs_query_find_var(q, "food");
 
-    // Iterate the rule
-    ecs_iter_t it = ecs_rule_iter(ecs, r);
-    while (ecs_rule_next(&it)) {
+    // Iterate the query
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    while (ecs_query_next(&it)) {
         ecs_entity_t food = ecs_iter_get_var(&it, food_var);
         for (int i = 0; i < it.count; i ++) {
             printf("%s eats %s\n", ecs_get_name(ecs, it.entities[i]),
@@ -66,7 +62,7 @@ int main(int argc, char *argv[]) {
     }
 
     // Rules need to be explicitly deleted
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     // Output
     //  Bob eats Apples
diff --git a/examples/c/queries/wildcards/include/wildcards/bake_config.h b/examples/c/queries/wildcards/include/wildcards/bake_config.h
index 9a809e64c..6c570d770 100644
--- a/examples/c/queries/wildcards/include/wildcards/bake_config.h
+++ b/examples/c/queries/wildcards/include/wildcards/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef WILDCARDS_BAKE_CONFIG_H
-#define WILDCARDS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef WILDCARDS_BAKE_CONFIG_H
+#define WILDCARDS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/queries/wildcards/src/main.c b/examples/c/queries/wildcards/src/main.c
index e48cb20ae..ded606147 100644
--- a/examples/c/queries/wildcards/src/main.c
+++ b/examples/c/queries/wildcards/src/main.c
@@ -17,22 +17,22 @@ int main(int argc, char *argv[]) {
 
     // Create a query that matches edible components
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {{ .id = ecs_pair(ecs_id(Eats), EcsWildcard ) }}
+        .terms = {{ .id = ecs_pair(ecs_id(Eats), EcsWildcard ) }}
     });
 
     // Create a few entities that match the query
-    ecs_entity_t bob = ecs_new_entity(ecs, "Bob");
+    ecs_entity_t bob = ecs_entity(ecs, { .name = "Bob" });
     ecs_set_pair(ecs, bob, Eats, Apples, {10});
     ecs_set_pair(ecs, bob, Eats, Pears, {5});
 
-    ecs_entity_t alice = ecs_new_entity(ecs, "Alice");
+    ecs_entity_t alice = ecs_entity(ecs, { .name = "Alice" });
     ecs_set_pair(ecs, alice, Eats, Apples, {4});
 
     // Iterate the query
     ecs_iter_t it = ecs_query_iter(ecs, q);
     while (ecs_query_next(&it)) {
-        Eats *eats = ecs_field(&it, Eats, 1);
-        ecs_id_t pair = ecs_field_id(&it, 1);
+        Eats *eats = ecs_field(&it, Eats, 0);
+        ecs_id_t pair = ecs_field_id(&it, 0);
         ecs_entity_t food = ecs_pair_second(ecs, pair);
 
         for (int i = 0; i < it.count; i ++) {
diff --git a/examples/c/reflection/auto_define_enum/include/auto_define_enum/bake_config.h b/examples/c/reflection/auto_define_enum/include/auto_define_enum/bake_config.h
index 1b52ab05b..a1ea1c5c8 100644
--- a/examples/c/reflection/auto_define_enum/include/auto_define_enum/bake_config.h
+++ b/examples/c/reflection/auto_define_enum/include/auto_define_enum/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef AUTO_DEFINE_ENUM_BAKE_CONFIG_H
-#define AUTO_DEFINE_ENUM_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef AUTO_DEFINE_ENUM_BAKE_CONFIG_H
+#define AUTO_DEFINE_ENUM_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/auto_define_nested_struct/include/auto_define_nested_struct/bake_config.h b/examples/c/reflection/auto_define_nested_struct/include/auto_define_nested_struct/bake_config.h
index 6659cb909..c8c939683 100644
--- a/examples/c/reflection/auto_define_nested_struct/include/auto_define_nested_struct/bake_config.h
+++ b/examples/c/reflection/auto_define_nested_struct/include/auto_define_nested_struct/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef AUTO_DEFINE_NESTED_STRUCT_BAKE_CONFIG_H
-#define AUTO_DEFINE_NESTED_STRUCT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef AUTO_DEFINE_NESTED_STRUCT_BAKE_CONFIG_H
+#define AUTO_DEFINE_NESTED_STRUCT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/auto_define_struct/include/auto_define_struct/bake_config.h b/examples/c/reflection/auto_define_struct/include/auto_define_struct/bake_config.h
index 2ce1aa881..782281d8d 100644
--- a/examples/c/reflection/auto_define_struct/include/auto_define_struct/bake_config.h
+++ b/examples/c/reflection/auto_define_struct/include/auto_define_struct/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef AUTO_DEFINE_STRUCT_BAKE_CONFIG_H
-#define AUTO_DEFINE_STRUCT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef AUTO_DEFINE_STRUCT_BAKE_CONFIG_H
+#define AUTO_DEFINE_STRUCT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/basics/include/basics/bake_config.h b/examples/c/reflection/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/c/reflection/basics/include/basics/bake_config.h
+++ b/examples/c/reflection/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/basics/src/main.c b/examples/c/reflection/basics/src/main.c
index 9c5899942..65d5db73b 100644
--- a/examples/c/reflection/basics/src/main.c
+++ b/examples/c/reflection/basics/src/main.c
@@ -21,7 +21,7 @@ int main(int argc, char *argv[]) {
     });
 
     // Create entity with Position as usual
-    ecs_entity_t ent = ecs_new_id(ecs);
+    ecs_entity_t ent = ecs_new(ecs);
     ecs_set(ecs, ent, Position, {10, 20});
 
     // Convert position component to flecs expression string
diff --git a/examples/c/reflection/basics_bitmask/include/basics_bitmask/bake_config.h b/examples/c/reflection/basics_bitmask/include/basics_bitmask/bake_config.h
index 5d8bdb70c..1883b0a80 100644
--- a/examples/c/reflection/basics_bitmask/include/basics_bitmask/bake_config.h
+++ b/examples/c/reflection/basics_bitmask/include/basics_bitmask/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BITMASK_BAKE_CONFIG_H
-#define BASICS_BITMASK_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BITMASK_BAKE_CONFIG_H
+#define BASICS_BITMASK_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/basics_bitmask/src/main.c b/examples/c/reflection/basics_bitmask/src/main.c
index 80bca89ed..d92bb98ca 100644
--- a/examples/c/reflection/basics_bitmask/src/main.c
+++ b/examples/c/reflection/basics_bitmask/src/main.c
@@ -35,7 +35,7 @@ int main(int argc, char *argv[]) {
     });
 
     // Create entity with Sandwich as usual
-    ecs_entity_t ent = ecs_new_id(ecs);
+    ecs_entity_t ent = ecs_new(ecs);
     ecs_set(ecs, ent, Sandwich, {Bacon | Lettuce});
 
     // Convert Sandwich component to flecs expression string
diff --git a/examples/c/reflection/basics_deserialize/include/basics_deserialize/bake_config.h b/examples/c/reflection/basics_deserialize/include/basics_deserialize/bake_config.h
index a96ae6452..f3468a5eb 100644
--- a/examples/c/reflection/basics_deserialize/include/basics_deserialize/bake_config.h
+++ b/examples/c/reflection/basics_deserialize/include/basics_deserialize/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_DESERIALIZE_BAKE_CONFIG_H
-#define BASICS_DESERIALIZE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_DESERIALIZE_BAKE_CONFIG_H
+#define BASICS_DESERIALIZE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/basics_deserialize/src/main.c b/examples/c/reflection/basics_deserialize/src/main.c
index 08d7f4104..c7741593c 100644
--- a/examples/c/reflection/basics_deserialize/src/main.c
+++ b/examples/c/reflection/basics_deserialize/src/main.c
@@ -21,7 +21,7 @@ int main(int argc, char *argv[]) {
     });
 
     // Create entity, set value of position using reflection API
-    ecs_entity_t ent = ecs_new_entity(ecs, "ent");
+    ecs_entity_t ent = ecs_entity(ecs, { .name = "ent" });
     Position *ptr = ecs_ensure(ecs, ent, Position);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(ecs, ecs_id(Position), ptr);
diff --git a/examples/c/reflection/basics_enum/include/basics_enum/bake_config.h b/examples/c/reflection/basics_enum/include/basics_enum/bake_config.h
index 0efb351d7..c4008dcd0 100644
--- a/examples/c/reflection/basics_enum/include/basics_enum/bake_config.h
+++ b/examples/c/reflection/basics_enum/include/basics_enum/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_ENUM_BAKE_CONFIG_H
-#define BASICS_ENUM_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_ENUM_BAKE_CONFIG_H
+#define BASICS_ENUM_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/basics_enum/src/main.c b/examples/c/reflection/basics_enum/src/main.c
index aee2cc328..368fb6fbe 100644
--- a/examples/c/reflection/basics_enum/src/main.c
+++ b/examples/c/reflection/basics_enum/src/main.c
@@ -36,7 +36,7 @@ int main(int argc, char *argv[]) {
     });
 
     // Create entity with TypeWithEnum as usual
-    ecs_entity_t ent = ecs_new_id(ecs);
+    ecs_entity_t ent = ecs_new(ecs);
     ecs_set(ecs, ent, TypeWithEnum, {Green});
 
     // Convert TypeWithEnum component to flecs expression string
diff --git a/examples/c/reflection/basics_json/include/basics_json/bake_config.h b/examples/c/reflection/basics_json/include/basics_json/bake_config.h
index f27b048c9..10688523d 100644
--- a/examples/c/reflection/basics_json/include/basics_json/bake_config.h
+++ b/examples/c/reflection/basics_json/include/basics_json/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_JSON_BAKE_CONFIG_H
-#define BASICS_JSON_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_JSON_BAKE_CONFIG_H
+#define BASICS_JSON_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/basics_json/src/main.c b/examples/c/reflection/basics_json/src/main.c
index e755e92ae..d8315ba17 100644
--- a/examples/c/reflection/basics_json/src/main.c
+++ b/examples/c/reflection/basics_json/src/main.c
@@ -21,7 +21,7 @@ int main(int argc, char *argv[]) {
     });
 
     // Create entity with Position as usual
-    ecs_entity_t ent = ecs_new_entity(ecs, "ent");
+    ecs_entity_t ent = ecs_entity(ecs, { .name = "ent" });
     ecs_set(ecs, ent, Position, {10, 20});
 
     // Convert position component to JSON
diff --git a/examples/c/reflection/entity_type/include/entity_type/bake_config.h b/examples/c/reflection/entity_type/include/entity_type/bake_config.h
index d3135506b..5772c9aca 100644
--- a/examples/c/reflection/entity_type/include/entity_type/bake_config.h
+++ b/examples/c/reflection/entity_type/include/entity_type/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef ENTITY_TYPE_BAKE_CONFIG_H
-#define ENTITY_TYPE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef ENTITY_TYPE_BAKE_CONFIG_H
+#define ENTITY_TYPE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/entity_type/src/main.c b/examples/c/reflection/entity_type/src/main.c
index 9c1e5c9c4..2d8ef0cfa 100644
--- a/examples/c/reflection/entity_type/src/main.c
+++ b/examples/c/reflection/entity_type/src/main.c
@@ -11,7 +11,7 @@ int main(int argc, char *argv[]) {
     ECS_META_COMPONENT(ecs, TypeWithEntity);
 
     ecs_entity_t foo = ecs_set_name(ecs, 0, "Foo");
-    ecs_entity_t e = ecs_set(ecs, 0, TypeWithEntity, {foo});
+    ecs_entity_t e = ecs_insert(ecs, ecs_value(TypeWithEntity, {foo}));
 
     // Convert component to flecs expression string
     const TypeWithEntity *ptr = ecs_get(ecs, e, TypeWithEntity);
diff --git a/examples/c/reflection/member_ranges/include/member_ranges/bake_config.h b/examples/c/reflection/member_ranges/include/member_ranges/bake_config.h
index 17e8e58c9..41cbd6815 100644
--- a/examples/c/reflection/member_ranges/include/member_ranges/bake_config.h
+++ b/examples/c/reflection/member_ranges/include/member_ranges/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef MEMBER_RANGES_BAKE_CONFIG_H
-#define MEMBER_RANGES_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef MEMBER_RANGES_BAKE_CONFIG_H
+#define MEMBER_RANGES_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/member_ranges/src/main.c b/examples/c/reflection/member_ranges/src/main.c
index 8b8f6ffa4..d112cecbc 100644
--- a/examples/c/reflection/member_ranges/src/main.c
+++ b/examples/c/reflection/member_ranges/src/main.c
@@ -23,13 +23,13 @@ int main(int argc, char *argv[]) {
         }}
     });
 
-    ecs_entity_t m1 = ecs_new_entity(ecs, "MachineA");
+    ecs_entity_t m1 = ecs_entity(ecs, { .name = "MachineA" });
     ecs_set(ecs, m1, CpuUtilization, {50});
 
-    ecs_entity_t m2 = ecs_new_entity(ecs, "MachineB");
+    ecs_entity_t m2 = ecs_entity(ecs, { .name = "MachineB" });
     ecs_set(ecs, m2, CpuUtilization, {75});
 
-    ecs_entity_t m3 = ecs_new_entity(ecs, "MachineC");
+    ecs_entity_t m3 = ecs_entity(ecs, { .name = "MachineC" });
     ecs_set(ecs, m3, CpuUtilization, {90});
 
     // Open https://www.flecs.dev/explorer?show=query&query=CpuUtilization to 
diff --git a/examples/c/reflection/nested_set_member/include/nested_set_member/bake_config.h b/examples/c/reflection/nested_set_member/include/nested_set_member/bake_config.h
index 36a49027c..a2eb4bf87 100644
--- a/examples/c/reflection/nested_set_member/include/nested_set_member/bake_config.h
+++ b/examples/c/reflection/nested_set_member/include/nested_set_member/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef NESTED_SET_MEMBER_BAKE_CONFIG_H
-#define NESTED_SET_MEMBER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef NESTED_SET_MEMBER_BAKE_CONFIG_H
+#define NESTED_SET_MEMBER_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/nested_set_member/src/main.c b/examples/c/reflection/nested_set_member/src/main.c
index b2c836ff4..d286d6646 100644
--- a/examples/c/reflection/nested_set_member/src/main.c
+++ b/examples/c/reflection/nested_set_member/src/main.c
@@ -17,7 +17,7 @@ int main(int argc, char *argv[]) {
     ECS_META_COMPONENT(ecs, Point);
     ECS_META_COMPONENT(ecs, Line);
 
-    ecs_entity_t ent = ecs_new_id(ecs);
+    ecs_entity_t ent = ecs_new(ecs);
     Line *ptr = ecs_ensure(ecs, ent, Line);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(ecs, ecs_id(Line), ptr);
diff --git a/examples/c/reflection/nested_struct/include/nested_struct/bake_config.h b/examples/c/reflection/nested_struct/include/nested_struct/bake_config.h
index ea48200ef..eae36efe1 100644
--- a/examples/c/reflection/nested_struct/include/nested_struct/bake_config.h
+++ b/examples/c/reflection/nested_struct/include/nested_struct/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef NESTED_STRUCT_BAKE_CONFIG_H
-#define NESTED_STRUCT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef NESTED_STRUCT_BAKE_CONFIG_H
+#define NESTED_STRUCT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/nested_struct/src/main.c b/examples/c/reflection/nested_struct/src/main.c
index e314d5b8f..9d23ba7c5 100644
--- a/examples/c/reflection/nested_struct/src/main.c
+++ b/examples/c/reflection/nested_struct/src/main.c
@@ -31,7 +31,7 @@ int main(int argc, char *argv[]) {
         }
     });
 
-    ecs_entity_t ent = ecs_new_id(ecs);
+    ecs_entity_t ent = ecs_new(ecs);
     ecs_set(ecs, ent, Line, {{10, 20}, {30, 40}});
 
     const Line *ptr = ecs_get(ecs, ent, Line);
diff --git a/examples/c/reflection/query_to_custom_json/include/query_to_custom_json/bake_config.h b/examples/c/reflection/query_to_custom_json/include/query_to_custom_json/bake_config.h
index 5d4990d7e..74205bc6b 100644
--- a/examples/c/reflection/query_to_custom_json/include/query_to_custom_json/bake_config.h
+++ b/examples/c/reflection/query_to_custom_json/include/query_to_custom_json/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef QUERY_TO_CUSTOM_JSON_BAKE_CONFIG_H
-#define QUERY_TO_CUSTOM_JSON_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef QUERY_TO_CUSTOM_JSON_BAKE_CONFIG_H
+#define QUERY_TO_CUSTOM_JSON_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/query_to_custom_json/src/main.c b/examples/c/reflection/query_to_custom_json/src/main.c
index 34c3ac080..d6c69cc76 100644
--- a/examples/c/reflection/query_to_custom_json/src/main.c
+++ b/examples/c/reflection/query_to_custom_json/src/main.c
@@ -63,7 +63,7 @@ int main(int argc, char *argv[]) {
 
     // Query for components
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }
         }
     });
@@ -76,7 +76,7 @@ int main(int argc, char *argv[]) {
         .serialize_entities = true,
         .serialize_values = true
     };
-    char *json = ecs_iter_to_json(ecs, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     printf("%s\n", json);
     ecs_os_free(json);
 
diff --git a/examples/c/reflection/query_to_json/include/query_to_json/bake_config.h b/examples/c/reflection/query_to_json/include/query_to_json/bake_config.h
index ee7b7b2d1..93ad4446e 100644
--- a/examples/c/reflection/query_to_json/include/query_to_json/bake_config.h
+++ b/examples/c/reflection/query_to_json/include/query_to_json/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef QUERY_TO_JSON_BAKE_CONFIG_H
-#define QUERY_TO_JSON_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef QUERY_TO_JSON_BAKE_CONFIG_H
+#define QUERY_TO_JSON_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/query_to_json/src/main.c b/examples/c/reflection/query_to_json/src/main.c
index ba6bf8dc5..0dca033f1 100644
--- a/examples/c/reflection/query_to_json/src/main.c
+++ b/examples/c/reflection/query_to_json/src/main.c
@@ -61,7 +61,7 @@ int main(int argc, char *argv[]) {
 
     // Query for components
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }
         }
     });
@@ -69,7 +69,7 @@ int main(int argc, char *argv[]) {
     // Serialize query to JSON. Note that this works for iterators from any
     // source, including filters & rules.
     ecs_iter_t it = ecs_query_iter(ecs, q);
-    char *json = ecs_iter_to_json(ecs, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     printf("%s\n", json);
     ecs_os_free(json);
 
diff --git a/examples/c/reflection/runtime_component/include/runtime_component/bake_config.h b/examples/c/reflection/runtime_component/include/runtime_component/bake_config.h
index 07b203365..ff4d4c766 100644
--- a/examples/c/reflection/runtime_component/include/runtime_component/bake_config.h
+++ b/examples/c/reflection/runtime_component/include/runtime_component/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef RUNTIME_COMPONENT_BAKE_CONFIG_H
-#define RUNTIME_COMPONENT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef RUNTIME_COMPONENT_BAKE_CONFIG_H
+#define RUNTIME_COMPONENT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/runtime_component/src/main.c b/examples/c/reflection/runtime_component/src/main.c
index 86595a693..df7620e6f 100644
--- a/examples/c/reflection/runtime_component/src/main.c
+++ b/examples/c/reflection/runtime_component/src/main.c
@@ -13,7 +13,7 @@ int main(int argc, char *argv[]) {
     });
 
     // Create entity, set value of position using reflection API
-    ecs_entity_t ent = ecs_new_entity(ecs, "ent");
+    ecs_entity_t ent = ecs_entity(ecs, { .name = "ent" });
     void *ptr = ecs_ensure_id(ecs, ent, Position);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(ecs, Position, ptr);
diff --git a/examples/c/reflection/runtime_nested_component/include/runtime_nested_component/bake_config.h b/examples/c/reflection/runtime_nested_component/include/runtime_nested_component/bake_config.h
index 1f5d9cde8..2af8c03e9 100644
--- a/examples/c/reflection/runtime_nested_component/include/runtime_nested_component/bake_config.h
+++ b/examples/c/reflection/runtime_nested_component/include/runtime_nested_component/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef RUNTIME_NESTED_COMPONENT_BAKE_CONFIG_H
-#define RUNTIME_NESTED_COMPONENT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef RUNTIME_NESTED_COMPONENT_BAKE_CONFIG_H
+#define RUNTIME_NESTED_COMPONENT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/runtime_nested_component/src/main.c b/examples/c/reflection/runtime_nested_component/src/main.c
index 7997f8641..26b878b07 100644
--- a/examples/c/reflection/runtime_nested_component/src/main.c
+++ b/examples/c/reflection/runtime_nested_component/src/main.c
@@ -20,7 +20,7 @@ int main(int argc, char *argv[]) {
     });
 
     // Create entity, set value of position using reflection API
-    ecs_entity_t ent = ecs_new_entity(ecs, "ent");
+    ecs_entity_t ent = ecs_entity(ecs, { .name = "ent" });
     void *ptr = ecs_ensure_id(ecs, ent, Line);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(ecs, Line, ptr);
diff --git a/examples/c/reflection/ser_opaque_string/include/ser_opaque_string/bake_config.h b/examples/c/reflection/ser_opaque_string/include/ser_opaque_string/bake_config.h
index a22174f3c..2a60c8b60 100644
--- a/examples/c/reflection/ser_opaque_string/include/ser_opaque_string/bake_config.h
+++ b/examples/c/reflection/ser_opaque_string/include/ser_opaque_string/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SER_OPAQUE_STRING_BAKE_CONFIG_H
-#define SER_OPAQUE_STRING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SER_OPAQUE_STRING_BAKE_CONFIG_H
+#define SER_OPAQUE_STRING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/ser_opaque_type/include/ser_opaque_type/bake_config.h b/examples/c/reflection/ser_opaque_type/include/ser_opaque_type/bake_config.h
index 3bcf12d9f..4c371421a 100644
--- a/examples/c/reflection/ser_opaque_type/include/ser_opaque_type/bake_config.h
+++ b/examples/c/reflection/ser_opaque_type/include/ser_opaque_type/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SER_OPAQUE_TYPE_BAKE_CONFIG_H
-#define SER_OPAQUE_TYPE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SER_OPAQUE_TYPE_BAKE_CONFIG_H
+#define SER_OPAQUE_TYPE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/ser_opaque_vector/include/ser_opaque_vector/bake_config.h b/examples/c/reflection/ser_opaque_vector/include/ser_opaque_vector/bake_config.h
index 4d9bf1dcb..e633b7851 100644
--- a/examples/c/reflection/ser_opaque_vector/include/ser_opaque_vector/bake_config.h
+++ b/examples/c/reflection/ser_opaque_vector/include/ser_opaque_vector/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SER_OPAQUE_VECTOR_BAKE_CONFIG_H
-#define SER_OPAQUE_VECTOR_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SER_OPAQUE_VECTOR_BAKE_CONFIG_H
+#define SER_OPAQUE_VECTOR_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/units/include/units/bake_config.h b/examples/c/reflection/units/include/units/bake_config.h
index e3d1af491..e58d87018 100644
--- a/examples/c/reflection/units/include/units/bake_config.h
+++ b/examples/c/reflection/units/include/units/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef UNITS_BAKE_CONFIG_H
-#define UNITS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef UNITS_BAKE_CONFIG_H
+#define UNITS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/units/src/main.c b/examples/c/reflection/units/src/main.c
index 4434aa8a1..6f55bd761 100644
--- a/examples/c/reflection/units/src/main.c
+++ b/examples/c/reflection/units/src/main.c
@@ -48,7 +48,7 @@ int main(int argc, char *argv[]) {
         }
     });
 
-    ecs_entity_t e = ecs_set(ecs, 0, WeatherStation, {24, 1.2, 0.5});
+    ecs_entity_t e = ecs_insert(ecs, ecs_value(WeatherStation, {24, 1.2, 0.5}));
 
     // Use cursor API to print values with units
     WeatherStation *ptr = ecs_ensure(ecs, e, WeatherStation);
diff --git a/examples/c/reflection/world_ser_deser/include/world_ser_deser/bake_config.h b/examples/c/reflection/world_ser_deser/include/world_ser_deser/bake_config.h
index ee1a659f7..9f0eab598 100644
--- a/examples/c/reflection/world_ser_deser/include/world_ser_deser/bake_config.h
+++ b/examples/c/reflection/world_ser_deser/include/world_ser_deser/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef WORLD_SER_DESER_BAKE_CONFIG_H
-#define WORLD_SER_DESER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef WORLD_SER_DESER_BAKE_CONFIG_H
+#define WORLD_SER_DESER_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/reflection/world_ser_deser/src/main.c b/examples/c/reflection/world_ser_deser/src/main.c
index bbb79c9cf..b4e00bb29 100644
--- a/examples/c/reflection/world_ser_deser/src/main.c
+++ b/examples/c/reflection/world_ser_deser/src/main.c
@@ -9,8 +9,8 @@ ECS_COMPONENT_DECLARE(Position);
 ECS_COMPONENT_DECLARE(Velocity);
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    const Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    const Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i ++) {
         p[i].x += v[i].x;
@@ -52,8 +52,8 @@ int main(int argc, char *argv[]) {
         ECS_IMPORT(world_a, MoveModule); // put in a scope so variable doens't overlap
     }
 
-    ecs_entity_t ent_1 = ecs_new_entity(world_a, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world_a, "ent_2");
+    ecs_entity_t ent_1 = ecs_entity(world_a, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world_a, { .name = "ent_2" });
     ecs_set(world_a, ent_1, Position, {10, 20});
     ecs_set(world_a, ent_2, Position, {30, 40});
     ecs_set(world_a, ent_1, Velocity, {1, -1});
diff --git a/examples/c/relationships/basics/include/basics/bake_config.h b/examples/c/relationships/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/c/relationships/basics/include/basics/bake_config.h
+++ b/examples/c/relationships/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/relationships/basics/src/main.c b/examples/c/relationships/basics/src/main.c
index c352e905c..77f7e473a 100644
--- a/examples/c/relationships/basics/src/main.c
+++ b/examples/c/relationships/basics/src/main.c
@@ -7,15 +7,15 @@ int main(int argc, char *argv[]) {
     ECS_TAG(ecs, Eats);
 
     // Entity used for Grows relationship
-    ecs_entity_t grows = ecs_new_entity(ecs, "Grows");
+    ecs_entity_t grows = ecs_entity(ecs, { .name = "Grows" });
 
     // Relationship objects
-    ecs_entity_t apples = ecs_new_entity(ecs, "Apples");
-    ecs_entity_t pears = ecs_new_entity(ecs, "Pears");
+    ecs_entity_t apples = ecs_entity(ecs, { .name = "Apples" });
+    ecs_entity_t pears = ecs_entity(ecs, { .name = "Pears" });
 
     // Create an entity with 3 relationships. Relationships are like regular components,
     // but combine two types/identifiers into an (relationship, object) pair.
-    ecs_entity_t bob = ecs_new_entity(ecs, "Bob");
+    ecs_entity_t bob = ecs_entity(ecs, { .name = "Bob" });
     // Pairs can be constructed from a type and entity
     ecs_add_pair(ecs, bob, Eats, apples);
     ecs_add_pair(ecs, bob, Eats, pears);
diff --git a/examples/c/relationships/exclusive_relations/include/exclusive_relations/bake_config.h b/examples/c/relationships/exclusive_relations/include/exclusive_relations/bake_config.h
index 744b6789b..0a2e35c61 100644
--- a/examples/c/relationships/exclusive_relations/include/exclusive_relations/bake_config.h
+++ b/examples/c/relationships/exclusive_relations/include/exclusive_relations/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef EXCLUSIVE_RELATIONS_BAKE_CONFIG_H
-#define EXCLUSIVE_RELATIONS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef EXCLUSIVE_RELATIONS_BAKE_CONFIG_H
+#define EXCLUSIVE_RELATIONS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/relationships/exclusive_relations/src/main.c b/examples/c/relationships/exclusive_relations/src/main.c
index 4b268c71d..e63d93f43 100644
--- a/examples/c/relationships/exclusive_relations/src/main.c
+++ b/examples/c/relationships/exclusive_relations/src/main.c
@@ -11,11 +11,11 @@ int main(int argc, char *argv[]) {
     ecs_add_id(ecs, Platoon, EcsExclusive);
 
     // Create two platoons
-    ecs_entity_t platoon_1 = ecs_new_id(ecs);
-    ecs_entity_t platoon_2 = ecs_new_id(ecs);
+    ecs_entity_t platoon_1 = ecs_new(ecs);
+    ecs_entity_t platoon_2 = ecs_new(ecs);
 
     // Create a unit
-    ecs_entity_t unit = ecs_new_id(ecs);
+    ecs_entity_t unit = ecs_new(ecs);
 
     // Add unit to platoon 1
     ecs_add_pair(ecs, unit, Platoon, platoon_1);
diff --git a/examples/c/relationships/relation_component/include/relation_component/bake_config.h b/examples/c/relationships/relation_component/include/relation_component/bake_config.h
index 8093c2aa4..ad3d8ba04 100644
--- a/examples/c/relationships/relation_component/include/relation_component/bake_config.h
+++ b/examples/c/relationships/relation_component/include/relation_component/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef RELATION_COMPONENT_BAKE_CONFIG_H
-#define RELATION_COMPONENT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef RELATION_COMPONENT_BAKE_CONFIG_H
+#define RELATION_COMPONENT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/relationships/relation_component/src/main.c b/examples/c/relationships/relation_component/src/main.c
index 0fedfd11a..0ca9e7d84 100644
--- a/examples/c/relationships/relation_component/src/main.c
+++ b/examples/c/relationships/relation_component/src/main.c
@@ -31,13 +31,13 @@ int main(int argc, char *argv[]) {
 
     // When one element of a pair is a component and the other element is a tag, 
     // the pair assumes the type of the component. 
-    ecs_entity_t e1 = ecs_new_id(ecs);
+    ecs_entity_t e1 = ecs_new(ecs);
     ecs_set_pair(ecs, e1, Requires, Gigawatts, {1.21});
     const Requires *r = ecs_get_pair(ecs, e1, Requires, Gigawatts);
     printf("requires: %.2f\n", r->amount);
 
     // The component can be either the first or second part of a pair:
-    ecs_entity_t e2 = ecs_new_id(ecs);
+    ecs_entity_t e2 = ecs_new(ecs);
     ecs_set_pair_second(ecs, e2, Gigawatts, Requires, {1.21});
     r = ecs_get_pair_second(ecs, e2, Gigawatts, Requires);
     printf("requires: %.2f\n", r->amount);
@@ -47,14 +47,14 @@ int main(int argc, char *argv[]) {
 
     // If both parts of a pair are components, the pair assumes the type of
     // the first element:
-    ecs_entity_t e3 = ecs_new_id(ecs);
+    ecs_entity_t e3 = ecs_new(ecs);
     ecs_set_pair(ecs, e3, Expires, ecs_id(Position), {0.5});
     const Expires *e = ecs_get_pair(ecs, e3, Expires, ecs_id(Position));
     printf("expires: %.1f\n", e->timeout);
 
     // You can prevent a pair from assuming the type of a component by adding
     // the Tag property to a relationship:
-    ecs_add_id(ecs, MustHave, EcsTag);
+    ecs_add_id(ecs, MustHave, EcsPairIsTag);
 
     // Even though Position is a component, <MustHave, Position> contains no
     // data because MustHave has the Tag property.
@@ -86,7 +86,7 @@ int main(int argc, char *argv[]) {
 
     // When querying for a relationship, provide both parts of the pair:
     ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_pair(ecs_id(Requires), Gigawatts) }
         }
     });
@@ -94,7 +94,7 @@ int main(int argc, char *argv[]) {
     // When iterating, always use the pair type:
     ecs_iter_t it = ecs_query_iter(ecs, q);
     while (ecs_query_next(&it)) {
-        r = ecs_field(&it, Requires, 1);
+        r = ecs_field(&it, Requires, 0);
         for (int i = 0; i < it.count; i ++) {
             printf("requires %.2f gigawatts\n", r[i].amount);
         }
diff --git a/examples/c/relationships/symmetric_relations/include/symmetric_relations/bake_config.h b/examples/c/relationships/symmetric_relations/include/symmetric_relations/bake_config.h
index 0f074ec2b..38157ba88 100644
--- a/examples/c/relationships/symmetric_relations/include/symmetric_relations/bake_config.h
+++ b/examples/c/relationships/symmetric_relations/include/symmetric_relations/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SYMMETRIC_RELATIONS_BAKE_CONFIG_H
-#define SYMMETRIC_RELATIONS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SYMMETRIC_RELATIONS_BAKE_CONFIG_H
+#define SYMMETRIC_RELATIONS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/relationships/symmetric_relations/src/main.c b/examples/c/relationships/symmetric_relations/src/main.c
index 1fead29ad..8aa06869d 100644
--- a/examples/c/relationships/symmetric_relations/src/main.c
+++ b/examples/c/relationships/symmetric_relations/src/main.c
@@ -11,8 +11,8 @@ int main(int argc, char *argv[]) {
     ecs_add_id(ecs, TradesWith, EcsSymmetric);
 
     // Create two players
-    ecs_entity_t player_1 = ecs_new_id(ecs);
-    ecs_entity_t player_2 = ecs_new_id(ecs);
+    ecs_entity_t player_1 = ecs_new(ecs);
+    ecs_entity_t player_2 = ecs_new(ecs);
 
     // Add (TradesWith, player_2) to player_1. This also adds 
     // (TradesWith, player_1) to player_2.
diff --git a/examples/c/relationships/union/include/union/bake_config.h b/examples/c/relationships/union/include/union/bake_config.h
index b2063054f..ce47b9e82 100644
--- a/examples/c/relationships/union/include/union/bake_config.h
+++ b/examples/c/relationships/union/include/union/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef UNION_BAKE_CONFIG_H
-#define UNION_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef UNION_BAKE_CONFIG_H
+#define UNION_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/relationships/union/src/main.c b/examples/c/relationships/union/src/main.c
index 21ba924a8..b6ceb8c60 100644
--- a/examples/c/relationships/union/src/main.c
+++ b/examples/c/relationships/union/src/main.c
@@ -32,22 +32,22 @@ int main(int argc, char *argv[]) {
     // Create a query that subscribers for all entities that have a Direction
     // and that are walking.
     ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
+        .terms = {
             { .id = ecs_pair(Movement, Walking) },
             { .id = ecs_pair(Direction, EcsWildcard) }
         }
     });
 
     // Create a few entities with various state combinations
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add_pair(world, e1, Movement, Walking);
     ecs_add_pair(world, e1, Direction, Front);
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_pair(world, e2, Movement, Running);
     ecs_add_pair(world, e2, Direction, Left);
 
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_pair(world, e3, Movement, Running);
     ecs_add_pair(world, e3, Direction, Right);
 
@@ -57,8 +57,8 @@ int main(int argc, char *argv[]) {
     // Iterate query as usual
     ecs_iter_t it = ecs_query_iter(world, q);
     while (ecs_iter_next(&it)) {
-        ecs_entity_t *movement = ecs_field(&it, ecs_entity_t, 1);
-        ecs_entity_t *direction = ecs_field(&it, ecs_entity_t, 2);
+        ecs_entity_t *movement = ecs_field(&it, ecs_entity_t, 0);
+        ecs_entity_t *direction = ecs_field(&it, ecs_entity_t, 1);
 
         for (int i = 0; i < it.count; i ++) {
             printf("%s: Movement: %s, Direction: %s\n",
diff --git a/examples/c/rules/basics/include/basics/bake_config.h b/examples/c/rules/basics/include/basics/bake_config.h
deleted file mode 100644
index dde057bed..000000000
--- a/examples/c/rules/basics/include/basics/bake_config.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
diff --git a/examples/c/systems/basics/include/basics/bake_config.h b/examples/c/systems/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/c/systems/basics/include/basics/bake_config.h
+++ b/examples/c/systems/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/basics/src/main.c b/examples/c/systems/basics/src/main.c
index c9d644a2b..73fc4d23a 100644
--- a/examples/c/systems/basics/src/main.c
+++ b/examples/c/systems/basics/src/main.c
@@ -6,8 +6,8 @@ typedef struct {
 } Position, Velocity;
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    const Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    const Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i ++) {
         p[i].x += v[i].x;
@@ -32,7 +32,7 @@ int main(int argc, char *argv[]) {
         .entity = ecs_entity(ecs, {
             .name = "Move" 
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity), .inout = EcsIn }
         },
@@ -43,16 +43,16 @@ int main(int argc, char *argv[]) {
     // ECS_SYSTEM(ecs, Move, 0, Position, [in] Velocity);
 
     // Create a few test entities for a Position, Velocity query
-    ecs_entity_t e1 = ecs_new_entity(ecs, "e1");
+    ecs_entity_t e1 = ecs_entity(ecs, { .name = "e1" });
     ecs_set(ecs, e1, Position, {10, 20});
     ecs_set(ecs, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_entity(ecs, "e2");
+    ecs_entity_t e2 = ecs_entity(ecs, { .name = "e2" });
     ecs_set(ecs, e2, Position, {10, 20});
     ecs_set(ecs, e2, Velocity, {3, 4});
 
     // This entity will not match as it does not have Position, Velocity
-    ecs_entity_t e3 = ecs_new_entity(ecs, "e3");
+    ecs_entity_t e3 = ecs_entity(ecs, { .name = "e3" });
     ecs_set(ecs, e3, Position, {10, 20});
 
     // Run the system
diff --git a/examples/c/systems/custom_phases/include/custom_phases/bake_config.h b/examples/c/systems/custom_phases/include/custom_phases/bake_config.h
index c3cfe1dcc..bc8444c70 100644
--- a/examples/c/systems/custom_phases/include/custom_phases/bake_config.h
+++ b/examples/c/systems/custom_phases/include/custom_phases/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef CUSTOM_PHASES_BAKE_CONFIG_H
-#define CUSTOM_PHASES_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CUSTOM_PHASES_BAKE_CONFIG_H
+#define CUSTOM_PHASES_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/custom_phases/src/main.c b/examples/c/systems/custom_phases/src/main.c
index 938f85167..7637a1cb8 100644
--- a/examples/c/systems/custom_phases/src/main.c
+++ b/examples/c/systems/custom_phases/src/main.c
@@ -25,7 +25,7 @@ int main(int argc, char *argv[]) {
     ecs_system(ecs, {
         .entity = ecs_entity(ecs, {
             .name = "CollisionSystem",
-            .add = { ecs_dependson(Collisions) }
+            .add = ecs_ids( ecs_dependson(Collisions) )
         }),
         .callback = Sys
     });
@@ -33,7 +33,7 @@ int main(int argc, char *argv[]) {
     ecs_system(ecs, {
         .entity = ecs_entity(ecs, {
             .name = "PhysicsSystem",
-            .add = { ecs_dependson(Physics) }
+            .add = ecs_ids( ecs_dependson(Physics) )
         }),
         .callback = Sys
     });
@@ -41,7 +41,7 @@ int main(int argc, char *argv[]) {
     ecs_system(ecs, {
         .entity = ecs_entity(ecs, {
             .name = "GameSystem",
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
         .callback = Sys
     });
diff --git a/examples/c/systems/custom_phases_no_builtin/include/custom_phases_no_builtin/bake_config.h b/examples/c/systems/custom_phases_no_builtin/include/custom_phases_no_builtin/bake_config.h
index b96b2231c..17ac550af 100644
--- a/examples/c/systems/custom_phases_no_builtin/include/custom_phases_no_builtin/bake_config.h
+++ b/examples/c/systems/custom_phases_no_builtin/include/custom_phases_no_builtin/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef CUSTOM_PHASES_NO_BUILTIN_BAKE_CONFIG_H
-#define CUSTOM_PHASES_NO_BUILTIN_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CUSTOM_PHASES_NO_BUILTIN_BAKE_CONFIG_H
+#define CUSTOM_PHASES_NO_BUILTIN_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/custom_phases_no_builtin/src/main.c b/examples/c/systems/custom_phases_no_builtin/src/main.c
index bf26b21a1..c9d04ee08 100644
--- a/examples/c/systems/custom_phases_no_builtin/src/main.c
+++ b/examples/c/systems/custom_phases_no_builtin/src/main.c
@@ -26,7 +26,7 @@ int main(int argc, char *argv[]) {
     ecs_system(ecs, {
         .entity = ecs_entity(ecs, {
             .name = "CollisionSystem",
-            .add = { ecs_dependson(Collisions) }
+            .add = ecs_ids( ecs_dependson(Collisions) )
         }),
         .callback = Sys
     });
@@ -34,7 +34,7 @@ int main(int argc, char *argv[]) {
     ecs_system(ecs, {
         .entity = ecs_entity(ecs, {
             .name = "PhysicsSystem",
-            .add = { ecs_dependson(Physics) }
+            .add = ecs_ids( ecs_dependson(Physics) )
         }),
         .callback = Sys
     });
@@ -42,7 +42,7 @@ int main(int argc, char *argv[]) {
     ecs_system(ecs, {
         .entity = ecs_entity(ecs, {
             .name = "GameSystem",
-            .add = { ecs_dependson(Update) }
+            .add = ecs_ids( ecs_dependson(Update) )
         }),
         .callback = Sys
     });
diff --git a/examples/c/systems/custom_pipeline/include/custom_pipeline/bake_config.h b/examples/c/systems/custom_pipeline/include/custom_pipeline/bake_config.h
index 1ef79c702..8b3d68a78 100644
--- a/examples/c/systems/custom_pipeline/include/custom_pipeline/bake_config.h
+++ b/examples/c/systems/custom_pipeline/include/custom_pipeline/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef CUSTOM_PIPELINE_BAKE_CONFIG_H
-#define CUSTOM_PIPELINE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CUSTOM_PIPELINE_BAKE_CONFIG_H
+#define CUSTOM_PIPELINE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/custom_pipeline/src/main.c b/examples/c/systems/custom_pipeline/src/main.c
index b678ef94d..968394f27 100644
--- a/examples/c/systems/custom_pipeline/src/main.c
+++ b/examples/c/systems/custom_pipeline/src/main.c
@@ -25,7 +25,7 @@ int main(int argc, char *argv[]) {
     // pipeline does not require the use of phases (see custom_phases) or of the
     // DependsOn relationship. 
     ecs_entity_t pipeline = ecs_pipeline(ecs, {
-        .query.filter.terms = {
+        .query.terms = {
             { .id = EcsSystem }, // Mandatory, must always match systems
             { .id = Physics }
         }
diff --git a/examples/c/systems/custom_runner/include/custom_runner/bake_config.h b/examples/c/systems/custom_runner/include/custom_runner/bake_config.h
index eaa40449b..36d3e729e 100644
--- a/examples/c/systems/custom_runner/include/custom_runner/bake_config.h
+++ b/examples/c/systems/custom_runner/include/custom_runner/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef CUSTOM_RUNNER_BAKE_CONFIG_H
-#define CUSTOM_RUNNER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CUSTOM_RUNNER_BAKE_CONFIG_H
+#define CUSTOM_RUNNER_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/custom_runner/src/main.c b/examples/c/systems/custom_runner/src/main.c
index 156d41fcb..3afb02cd0 100644
--- a/examples/c/systems/custom_runner/src/main.c
+++ b/examples/c/systems/custom_runner/src/main.c
@@ -19,8 +19,8 @@ void Move(ecs_iter_t *it) {
     // Note that this code looks the same as iterating a query.
     while (ecs_query_next(it)) {
         // Inside the loop the code looks the same as for a regular system
-        Position *p = ecs_field(it, Position, 1);
-        const Velocity *v = ecs_field(it, Velocity, 2);
+        Position *p = ecs_field(it, Position, 0);
+        const Velocity *v = ecs_field(it, Velocity, 1);
 
         for (int i = 0; i < it->count; i ++) {
             p[i].x += v[i].x;
@@ -41,7 +41,7 @@ int main(int argc, char *argv[]) {
 
     // Create a system for Position, Velocity
     ecs_entity_t move = ecs_system(ecs, {
-        .query.filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity), .inout = EcsIn }
         },
@@ -52,16 +52,16 @@ int main(int argc, char *argv[]) {
     // ECS_SYSTEM(ecs, Move, 0, Position, [in] Velocity);
 
     // Create a few test entities for a Position, Velocity query
-    ecs_entity_t e1 = ecs_new_entity(ecs, "e1");
+    ecs_entity_t e1 = ecs_entity(ecs, { .name = "e1" });
     ecs_set(ecs, e1, Position, {10, 20});
     ecs_set(ecs, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_entity(ecs, "e2");
+    ecs_entity_t e2 = ecs_entity(ecs, { .name = "e2" });
     ecs_set(ecs, e2, Position, {10, 20});
     ecs_set(ecs, e2, Velocity, {3, 4});
 
     // This entity will not match as it does not have Position, Velocity
-    ecs_entity_t e3 = ecs_new_entity(ecs, "e3");
+    ecs_entity_t e3 = ecs_entity(ecs, { .name = "e3" });
     ecs_set(ecs, e3, Position, {10, 20});
 
     // Run the system
diff --git a/examples/c/systems/delta_time/include/delta_time/bake_config.h b/examples/c/systems/delta_time/include/delta_time/bake_config.h
index 2f7cc721c..db5c45b6a 100644
--- a/examples/c/systems/delta_time/include/delta_time/bake_config.h
+++ b/examples/c/systems/delta_time/include/delta_time/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef DELTA_TIME_BAKE_CONFIG_H
-#define DELTA_TIME_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef DELTA_TIME_BAKE_CONFIG_H
+#define DELTA_TIME_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/test/custom_builds/c/meta_c/include/meta_c.h b/examples/c/systems/immediate/include/immediate.h
similarity index 66%
rename from test/custom_builds/c/meta_c/include/meta_c.h
rename to examples/c/systems/immediate/include/immediate.h
index 683c0b3d4..1aecd4de2 100644
--- a/test/custom_builds/c/meta_c/include/meta_c.h
+++ b/examples/c/systems/immediate/include/immediate.h
@@ -1,8 +1,8 @@
-#ifndef META_C_H
-#define META_C_H
+#ifndef IMMEDIATE_H
+#define IMMEDIATE_H
 
 /* This generated file contains includes for project dependencies */
-#include "meta_c/bake_config.h"
+#include "immediate/bake_config.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/examples/cpp/systems/no_readonly/include/no_readonly/bake_config.h b/examples/c/systems/immediate/include/immediate/bake_config.h
similarity index 91%
rename from examples/cpp/systems/no_readonly/include/no_readonly/bake_config.h
rename to examples/c/systems/immediate/include/immediate/bake_config.h
index 8e0ab56ea..25f8e5513 100644
--- a/examples/cpp/systems/no_readonly/include/no_readonly/bake_config.h
+++ b/examples/c/systems/immediate/include/immediate/bake_config.h
@@ -14,8 +14,8 @@
  * dependencies will automatically show up in this file. Include bake_config.h
  * in your main project file. Do not edit! */
 
-#ifndef NO_READONLY_BAKE_CONFIG_H
-#define NO_READONLY_BAKE_CONFIG_H
+#ifndef IMMEDIATE_BAKE_CONFIG_H
+#define IMMEDIATE_BAKE_CONFIG_H
 
 /* Headers of public dependencies */
 #include <flecs.h>
diff --git a/examples/c/systems/immediate/include/no_readonly/bake_config.h b/examples/c/systems/immediate/include/no_readonly/bake_config.h
new file mode 100644
index 000000000..25f8e5513
--- /dev/null
+++ b/examples/c/systems/immediate/include/no_readonly/bake_config.h
@@ -0,0 +1,24 @@
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef IMMEDIATE_BAKE_CONFIG_H
+#define IMMEDIATE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/no_readonly/project.json b/examples/c/systems/immediate/project.json
similarity index 83%
rename from examples/c/systems/no_readonly/project.json
rename to examples/c/systems/immediate/project.json
index 8a3386207..2253884c3 100644
--- a/examples/c/systems/no_readonly/project.json
+++ b/examples/c/systems/immediate/project.json
@@ -1,5 +1,5 @@
 {
-    "id": "no_readonly",
+    "id": "immediate",
     "type": "application",
     "value": {
         "use": [
diff --git a/examples/c/systems/no_readonly/src/main.c b/examples/c/systems/immediate/src/main.c
similarity index 85%
rename from examples/c/systems/no_readonly/src/main.c
rename to examples/c/systems/immediate/src/main.c
index 7942f81ed..244bf437e 100644
--- a/examples/c/systems/no_readonly/src/main.c
+++ b/examples/c/systems/immediate/src/main.c
@@ -1,4 +1,4 @@
-#include <no_readonly.h>
+#include <immediate.h>
 #include <stdio.h>
 
 // When an application calls ecs_progress(), the world is put in readonly mode.
@@ -8,16 +8,16 @@
 // or removing components) are not visible until the end of the frame (see the
 // sync_point example for more details).
 // Sometimes this is not what you want, and you need a change to be visible
-// immediately. For these use cases, applications can use a no_readonly system.
+// immediately. For these use cases, applications can use a immediate system.
 // This temporarily takes the world out of readonly mode, so a system can make
 // changes that are directly visible.
-// Because they mutate the world directly, no_readonly systems are never ran on
+// Because they mutate the world directly, immediate systems are never ran on
 // more than one thread, and no other systems are ran at the same time.
 
 ECS_DECLARE(Waiter);
 ECS_DECLARE(Plate);
 
-// System that assigns plates to waiter. By making this system no_readonly
+// System that assigns plates to waiter. By making this system immediate
 // plate assignments are assigned directly (not deferred) to waiters, which 
 // ensures that we won't assign plates to the same waiter more than once.
 void AssignPlate(ecs_iter_t *it) {
@@ -36,7 +36,7 @@ void AssignPlate(ecs_iter_t *it) {
             // next plate will no longer find it.
             // The defer_suspend function temporarily suspends deferring 
             // operations, which ensures that our plate is assigned immediately.
-            // Even though this is a no_readonly system, defering is still 
+            // Even though this is a immediate system, defering is still 
             // enabled by default, as adding/removing components to the entities
             // being iterated would intefere with the system iterator.
             ecs_defer_suspend(ecs);
@@ -71,7 +71,7 @@ int main(int argc, char *argv[]) {
 
     // Create query to find all waiters without a plate
     ecs_query_t *q_waiter = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { .id = Waiter },
             { .id = ecs_pair(Plate, EcsWildcard), .oper = EcsNot }
         }
@@ -81,42 +81,42 @@ int main(int argc, char *argv[]) {
     ecs_system(ecs, {
         .entity = ecs_entity(ecs, {
             .name = "AssignPlate",
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { .id = Plate },
             { .id = ecs_pair(Waiter, EcsWildcard), .oper = EcsNot }
         },
         .callback = AssignPlate,
         .ctx = q_waiter,
-        .no_readonly = true // disable readonly mode for this system
+        .immediate = true // disable readonly mode for this system
     });
 
     // Create a few plates and waiters
     ecs_entity_t waiter_1 = ecs_entity(ecs, {
         .name = "waiter_1",
-        .add = { Waiter }
+        .add = ecs_ids( Waiter )
     });
     /* ecs_entity_t waiter_2 = */ ecs_entity(ecs, { // silence unused warning
         .name = "waiter_2",
-        .add = { Waiter }
+        .add = ecs_ids( Waiter )
     });
     /* ecs_entity_t waiter_3 = */ ecs_entity(ecs, {
         .name = "waiter_3",
-        .add = { Waiter }
+        .add = ecs_ids( Waiter )
     });
 
     /* ecs_entity_t plate_1 = */ ecs_entity(ecs, {
         .name = "plate_1",
-        .add = { Plate }
+        .add = ecs_ids( Plate )
     });
     ecs_entity_t plate_2 = ecs_entity(ecs, {
         .name = "plate_2",
-        .add = { Plate, ecs_pair(Waiter, waiter_1) } // already assigned
+        .add = ecs_ids( Plate, ecs_pair(Waiter, waiter_1) ) // already assigned
     });
     /* ecs_entity_t plate_3 = */ ecs_entity(ecs, {
         .name = "plate_3",
-        .add = { Plate }
+        .add = ecs_ids( Plate )
     });
 
     // Also assign plate_2 to waiter_1
diff --git a/examples/c/systems/mutate_entity/include/mutate_entity/bake_config.h b/examples/c/systems/mutate_entity/include/mutate_entity/bake_config.h
index e07ba8011..8532ca2b3 100644
--- a/examples/c/systems/mutate_entity/include/mutate_entity/bake_config.h
+++ b/examples/c/systems/mutate_entity/include/mutate_entity/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef MUTATE_ENTITY_BAKE_CONFIG_H
-#define MUTATE_ENTITY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef MUTATE_ENTITY_BAKE_CONFIG_H
+#define MUTATE_ENTITY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/mutate_entity/src/main.c b/examples/c/systems/mutate_entity/src/main.c
index e3e8e154f..119128de6 100644
--- a/examples/c/systems/mutate_entity/src/main.c
+++ b/examples/c/systems/mutate_entity/src/main.c
@@ -7,7 +7,7 @@ typedef struct {
 
 // System that deletes an entity after a timeout expires
 void Expire(ecs_iter_t *it) {
-    Timeout *t = ecs_field(it, Timeout, 1);
+    Timeout *t = ecs_field(it, Timeout, 0);
 
     for (int i = 0; i < it->count; i ++) {
         t[i].value -= (double)it->delta_time;
@@ -31,7 +31,7 @@ void Expire(ecs_iter_t *it) {
 
 // System that prints remaining expiry time
 void PrintExpire(ecs_iter_t *it) {
-    Timeout *t = ecs_field(it, Timeout, 1);
+    Timeout *t = ecs_field(it, Timeout, 0);
 
     for (int i = 0; i < it->count; i ++) {
         printf("PrintExpire: %s has %.2f seconds left\n", ecs_get_name(
diff --git a/examples/c/systems/no_readonly/include/no_readonly.h b/examples/c/systems/no_readonly/include/no_readonly.h
deleted file mode 100644
index 6aee24f3e..000000000
--- a/examples/c/systems/no_readonly/include/no_readonly.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef NO_READONLY_H
-#define NO_READONLY_H
-
-/* This generated file contains includes for project dependencies */
-#include "no_readonly/bake_config.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
diff --git a/examples/c/systems/no_readonly/include/no_readonly/bake_config.h b/examples/c/systems/no_readonly/include/no_readonly/bake_config.h
deleted file mode 100644
index e6fc40dfd..000000000
--- a/examples/c/systems/no_readonly/include/no_readonly/bake_config.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef NO_READONLY_BAKE_CONFIG_H
-#define NO_READONLY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
diff --git a/examples/c/systems/pipeline/include/pipeline/bake_config.h b/examples/c/systems/pipeline/include/pipeline/bake_config.h
index 88d7dcb4a..fbf8d9fda 100644
--- a/examples/c/systems/pipeline/include/pipeline/bake_config.h
+++ b/examples/c/systems/pipeline/include/pipeline/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef PIPELINE_BAKE_CONFIG_H
-#define PIPELINE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef PIPELINE_BAKE_CONFIG_H
+#define PIPELINE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/pipeline/src/main.c b/examples/c/systems/pipeline/src/main.c
index 70092c789..fdc18b780 100644
--- a/examples/c/systems/pipeline/src/main.c
+++ b/examples/c/systems/pipeline/src/main.c
@@ -6,7 +6,7 @@ typedef struct {
 } Position, Velocity;
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     const Velocity *v = ecs_field(it, const Velocity, 2);
 
     for (int i = 0; i < it->count; i ++) {
@@ -37,11 +37,11 @@ int main(int argc, char *argv[]) {
     ECS_SYSTEM(ecs, PrintPosition, EcsPostUpdate, [in] Position);
 
     // Create a few test entities for a Position, Velocity query
-    ecs_entity_t e1 = ecs_new_entity(ecs, "e1");
+    ecs_entity_t e1 = ecs_entity(ecs, { .name = "e1" });
     ecs_set(ecs, e1, Position, {10, 20});
     ecs_set(ecs, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_entity(ecs, "e2");
+    ecs_entity_t e2 = ecs_entity(ecs, { .name = "e2" });
     ecs_set(ecs, e2, Position, {10, 20});
     ecs_set(ecs, e2, Velocity, {3, 4});
 
diff --git a/examples/c/systems/startup_system/include/startup_system/bake_config.h b/examples/c/systems/startup_system/include/startup_system/bake_config.h
index 5e75d76c6..e98c08d08 100644
--- a/examples/c/systems/startup_system/include/startup_system/bake_config.h
+++ b/examples/c/systems/startup_system/include/startup_system/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef STARTUP_SYSTEM_BAKE_CONFIG_H
-#define STARTUP_SYSTEM_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef STARTUP_SYSTEM_BAKE_CONFIG_H
+#define STARTUP_SYSTEM_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/sync_point/include/sync_point/bake_config.h b/examples/c/systems/sync_point/include/sync_point/bake_config.h
index 04a288b86..7b7496af4 100644
--- a/examples/c/systems/sync_point/include/sync_point/bake_config.h
+++ b/examples/c/systems/sync_point/include/sync_point/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SYNC_POINT_BAKE_CONFIG_H
-#define SYNC_POINT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SYNC_POINT_BAKE_CONFIG_H
+#define SYNC_POINT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/sync_point/src/main.c b/examples/c/systems/sync_point/src/main.c
index a092848dc..7f7be0a80 100644
--- a/examples/c/systems/sync_point/src/main.c
+++ b/examples/c/systems/sync_point/src/main.c
@@ -16,7 +16,7 @@ void SetVelocity(ecs_iter_t *it) {
 }
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     const Velocity *v = ecs_field(it, const Velocity, 2);
 
     for (int i = 0; i < it->count; i ++) {
@@ -67,11 +67,11 @@ int main(int argc, char *argv[]) {
     ECS_SYSTEM(ecs, PrintPosition, EcsPostUpdate, [in] Position);
 
     // Create a few test entities for a Position, Velocity query
-    ecs_entity_t e1 = ecs_new_entity(ecs, "e1");
+    ecs_entity_t e1 = ecs_entity(ecs, { .name = "e1" });
     ecs_set(ecs, e1, Position, {10, 20});
     ecs_set(ecs, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_entity(ecs, "e2");
+    ecs_entity_t e2 = ecs_entity(ecs, { .name = "e2" });
     ecs_set(ecs, e2, Position, {10, 20});
     ecs_set(ecs, e2, Velocity, {3, 4});
 
@@ -99,7 +99,7 @@ int main(int argc, char *argv[]) {
     //
     // To create the same system with ecs_system_init, do:
     //  ecs_system_init(ecs, &(ecs_system_desc_t){
-    //      .query.filter.terms = {
+    //      .query.terms = {
     //          { 
     //              .id = ecs_id(Position), 
     //              .inout = EcsInOutNone 
@@ -107,12 +107,12 @@ int main(int argc, char *argv[]) {
     //          { 
     //              .id = ecs_id(Velocity), 
     //              .inout = EcsOut, 
-    //              .src.flags = EcsIsEntity 
+    //              .src.id = EcsIsEntity 
     //          }
     //      },
     //      .entity = {
     //          .name = "SetVelocity",
-    //          .add = {ecs_dependson(EcsOnUpdate)}
+    //          .add = ecs_ids(ecs_dependson(EcsOnUpdate))
     //      },
     //      .callback = SetVelocity
     //  });
diff --git a/examples/c/systems/sync_point_delete/include/sync_point_delete/bake_config.h b/examples/c/systems/sync_point_delete/include/sync_point_delete/bake_config.h
index 6b49886bb..0d2e1f6ec 100644
--- a/examples/c/systems/sync_point_delete/include/sync_point_delete/bake_config.h
+++ b/examples/c/systems/sync_point_delete/include/sync_point_delete/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SYNC_POINT_DELETE_BAKE_CONFIG_H
-#define SYNC_POINT_DELETE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SYNC_POINT_DELETE_BAKE_CONFIG_H
+#define SYNC_POINT_DELETE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/sync_point_delete/src/main.c b/examples/c/systems/sync_point_delete/src/main.c
index 857e95e2d..3bf9dedbf 100644
--- a/examples/c/systems/sync_point_delete/src/main.c
+++ b/examples/c/systems/sync_point_delete/src/main.c
@@ -6,7 +6,7 @@ typedef struct {
 } Position, Velocity;
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     const Velocity *v = ecs_field(it, const Velocity, 2);
 
     for (int i = 0; i < it->count; i ++) {
@@ -16,7 +16,7 @@ void Move(ecs_iter_t *it) {
 }
 
 void DeleteEntity(ecs_iter_t *it) {
-    const Position *p = ecs_field(it, Position, 1);
+    const Position *p = ecs_field(it, Position, 0);
 
     for (int i = 0; i < it->count; i ++) {
         if (p[i].x >= 3) {
@@ -69,11 +69,11 @@ int main(int argc, char *argv[]) {
     ECS_SYSTEM(ecs, PrintPosition, EcsPostUpdate, [in] Position);
 
     // Create a few test entities for a Position, Velocity query
-    ecs_entity_t e1 = ecs_new_entity(ecs, "e1");
+    ecs_entity_t e1 = ecs_entity(ecs, { .name = "e1" });
     ecs_set(ecs, e1, Position, {0, 0});
     ecs_set(ecs, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_entity(ecs, "e2");
+    ecs_entity_t e2 = ecs_entity(ecs, { .name = "e2" });
     ecs_set(ecs, e2, Position, {1, 2});
     ecs_set(ecs, e2, Velocity, {1, 2});
 
@@ -114,7 +114,7 @@ int main(int argc, char *argv[]) {
     //
     // To create the same system with ecs_system_init, do:
     //  ecs_system_init(ecs, &(ecs_system_desc_t){
-    //      .query.filter.terms = {
+    //      .query.terms = {
     //          { 
     //              .id = ecs_id(Position), 
     //              .inout = EcsIn
@@ -122,12 +122,12 @@ int main(int argc, char *argv[]) {
     //          { 
     //              .id = EcsWildcard, 
     //              .inout = EcsOut, 
-    //              .src.flags = EcsIsEntity 
+    //              .src.id = EcsIsEntity 
     //          }
     //      },
     //      .entity = {
     //          .name = "DeleteEntity",
-    //          .add = {ecs_dependson(EcsOnUpdate)}
+    //          .add = ecs_ids(ecs_dependson(EcsOnUpdate))
     //      },
     //      .callback = DeleteEntity
     //  });
diff --git a/examples/c/systems/system_ctx/include/system_ctx/bake_config.h b/examples/c/systems/system_ctx/include/system_ctx/bake_config.h
index 341e9155b..7b3ab046d 100644
--- a/examples/c/systems/system_ctx/include/system_ctx/bake_config.h
+++ b/examples/c/systems/system_ctx/include/system_ctx/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SYSTEM_CTX_BAKE_CONFIG_H
-#define SYSTEM_CTX_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SYSTEM_CTX_BAKE_CONFIG_H
+#define SYSTEM_CTX_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/system_ctx/src/main.c b/examples/c/systems/system_ctx/src/main.c
index 78c6dc0ee..14f9064dd 100644
--- a/examples/c/systems/system_ctx/src/main.c
+++ b/examples/c/systems/system_ctx/src/main.c
@@ -26,8 +26,8 @@ double distance_sqr(const Position *p1, const Position *p2) {
 
 void Collide(ecs_iter_t *it) {
     ecs_query_t *q_collide = it->ctx; // Get query from system context
-    const Position *p1 = ecs_field(it, Position, 1);
-    const Radius *r1 = ecs_field(it, Radius, 2);
+    const Position *p1 = ecs_field(it, Position, 0);
+    const Radius *r1 = ecs_field(it, Radius, 1);
 
     for (int i = 0; i < it->count; i ++) {
         ecs_entity_t e1 = it->entities[i];
@@ -35,8 +35,8 @@ void Collide(ecs_iter_t *it) {
         // For each matching entity, iterate the query
         ecs_iter_t qit = ecs_query_iter(it->world, q_collide);
         while (ecs_query_next(&qit)) {
-            const Position *p2 = ecs_field(&qit, Position, 1);
-            const Radius *r2 = ecs_field(&qit, Radius, 2);
+            const Position *p2 = ecs_field(&qit, Position, 0);
+            const Radius *r2 = ecs_field(&qit, Radius, 1);
             for (int j = 0; j < qit.count; j ++) {
                 ecs_entity_t e2 = qit.entities[j];
                 if (e1 == e2) {
@@ -70,7 +70,7 @@ int main(int argc, char *argv[]) {
     // Create a query for Position that we can use inside the collide system to
     // check each entity with each other entity.
     ecs_query_t  *q_position = ecs_query(ecs, {
-        .filter.terms = {
+        .terms = {
             { ecs_id(Position), .inout = EcsIn },
             { ecs_id(Radius), .inout = EcsIn }
         }
@@ -78,7 +78,7 @@ int main(int argc, char *argv[]) {
 
     // Create collide system that passes query as context
     ecs_entity_t collide = ecs_system(ecs, {
-        .query.filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position), .inout = EcsIn },
             { ecs_id(Radius), .inout = EcsIn }
         },
@@ -88,7 +88,7 @@ int main(int argc, char *argv[]) {
 
     // Create a few test entities
     for (int i = 0; i < 10; i ++) {
-        ecs_entity_t e = ecs_new_id(ecs);
+        ecs_entity_t e = ecs_new(ecs);
         ecs_set(ecs, e, Position, { .x = rand() % 100, .y = rand() % 100 });
         ecs_set(ecs, e, Radius, { rand() % 10 + 1 });
     }
diff --git a/examples/c/systems/target_fps/include/target_fps/bake_config.h b/examples/c/systems/target_fps/include/target_fps/bake_config.h
index fa03707b4..ccb3034bd 100644
--- a/examples/c/systems/target_fps/include/target_fps/bake_config.h
+++ b/examples/c/systems/target_fps/include/target_fps/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef TARGET_FPS_BAKE_CONFIG_H
-#define TARGET_FPS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef TARGET_FPS_BAKE_CONFIG_H
+#define TARGET_FPS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/time_interval/include/time_interval/bake_config.h b/examples/c/systems/time_interval/include/time_interval/bake_config.h
index 34a1b9e5b..b4f4ef143 100644
--- a/examples/c/systems/time_interval/include/time_interval/bake_config.h
+++ b/examples/c/systems/time_interval/include/time_interval/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef TIME_INTERVAL_BAKE_CONFIG_H
-#define TIME_INTERVAL_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef TIME_INTERVAL_BAKE_CONFIG_H
+#define TIME_INTERVAL_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/c/systems/time_interval/src/main.c b/examples/c/systems/time_interval/src/main.c
index e324f8981..cc9b9d802 100644
--- a/examples/c/systems/time_interval/src/main.c
+++ b/examples/c/systems/time_interval/src/main.c
@@ -14,7 +14,7 @@ int main(int argc, char *argv[]) {
     ecs_system(ecs, {
         .entity = ecs_entity(ecs, { 
             .name = "Tick",
-            .add = { ecs_dependson(EcsOnUpdate) } // run in OnUpdate phase
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) ) // run in OnUpdate phase
         }),
         .callback = Tick,
         .interval = 1.0  // time in seconds
@@ -23,7 +23,7 @@ int main(int argc, char *argv[]) {
     ecs_system(ecs, {
         .entity = ecs_entity(ecs, { 
             .name = "FastTick",
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
         .callback = Tick,
         .interval = 0.5
diff --git a/examples/cpp/entities/basics/include/basics/bake_config.h b/examples/cpp/entities/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/cpp/entities/basics/include/basics/bake_config.h
+++ b/examples/cpp/entities/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/entities/emplace/include/emplace/bake_config.h b/examples/cpp/entities/emplace/include/emplace/bake_config.h
index d46d6c849..984c64a05 100644
--- a/examples/cpp/entities/emplace/include/emplace/bake_config.h
+++ b/examples/cpp/entities/emplace/include/emplace/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef EMPLACE_BAKE_CONFIG_H
-#define EMPLACE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef EMPLACE_BAKE_CONFIG_H
+#define EMPLACE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/entities/hierarchy/include/hierarchy/bake_config.h b/examples/cpp/entities/hierarchy/include/hierarchy/bake_config.h
index 1e21b3812..6b3d117ad 100644
--- a/examples/cpp/entities/hierarchy/include/hierarchy/bake_config.h
+++ b/examples/cpp/entities/hierarchy/include/hierarchy/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HIERARCHY_BAKE_CONFIG_H
-#define HIERARCHY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HIERARCHY_BAKE_CONFIG_H
+#define HIERARCHY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/entities/hooks/include/hooks/bake_config.h b/examples/cpp/entities/hooks/include/hooks/bake_config.h
index bb272e239..e670a0dc2 100644
--- a/examples/cpp/entities/hooks/include/hooks/bake_config.h
+++ b/examples/cpp/entities/hooks/include/hooks/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HOOKS_BAKE_CONFIG_H
-#define HOOKS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HOOKS_BAKE_CONFIG_H
+#define HOOKS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/entities/iterate_components/include/iterate_components/bake_config.h b/examples/cpp/entities/iterate_components/include/iterate_components/bake_config.h
index 979ffc5d0..e64a5d8fa 100644
--- a/examples/cpp/entities/iterate_components/include/iterate_components/bake_config.h
+++ b/examples/cpp/entities/iterate_components/include/iterate_components/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef ITERATE_COMPONENTS_BAKE_CONFIG_H
-#define ITERATE_COMPONENTS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef ITERATE_COMPONENTS_BAKE_CONFIG_H
+#define ITERATE_COMPONENTS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/entities/multi_set_get/include/multi_set_get/bake_config.h b/examples/cpp/entities/multi_set_get/include/multi_set_get/bake_config.h
index d7b3e3a99..ae0b95229 100644
--- a/examples/cpp/entities/multi_set_get/include/multi_set_get/bake_config.h
+++ b/examples/cpp/entities/multi_set_get/include/multi_set_get/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef MULTI_SET_GET_BAKE_CONFIG_H
-#define MULTI_SET_GET_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef MULTI_SET_GET_BAKE_CONFIG_H
+#define MULTI_SET_GET_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/entities/multi_set_get/src/main.cpp b/examples/cpp/entities/multi_set_get/src/main.cpp
index 2f0b03c9e..2a73cd9a2 100644
--- a/examples/cpp/entities/multi_set_get/src/main.cpp
+++ b/examples/cpp/entities/multi_set_get/src/main.cpp
@@ -16,7 +16,7 @@ int main(int, char *[]) {
 
     // Create new entity, set Position and Mass component
     flecs::entity e = ecs.entity()
-        .set([](Position& p, Mass& m) {
+        .insert([](Position& p, Mass& m) {
             p.x = 10;
             p.y = 20;
             m.value = 100;
diff --git a/examples/cpp/entities/prefab/include/prefab/bake_config.h b/examples/cpp/entities/prefab/include/prefab/bake_config.h
index 1d0530592..d091f5b8c 100644
--- a/examples/cpp/entities/prefab/include/prefab/bake_config.h
+++ b/examples/cpp/entities/prefab/include/prefab/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef PREFAB_BAKE_CONFIG_H
-#define PREFAB_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef PREFAB_BAKE_CONFIG_H
+#define PREFAB_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/explorer/include/explorer/bake_config.h b/examples/cpp/explorer/include/explorer/bake_config.h
index 546657fd5..aa6ff5edc 100644
--- a/examples/cpp/explorer/include/explorer/bake_config.h
+++ b/examples/cpp/explorer/include/explorer/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef EXPLORER_BAKE_CONFIG_H
-#define EXPLORER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef EXPLORER_BAKE_CONFIG_H
+#define EXPLORER_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/game_mechanics/factory/resources.flecs b/examples/cpp/game_mechanics/factory/resources.flecs
index e20bb17a7..1b5469e1e 100644
--- a/examples/cpp/game_mechanics/factory/resources.flecs
+++ b/examples/cpp/game_mechanics/factory/resources.flecs
@@ -10,44 +10,44 @@ resources {
 
     Steel {
       - Requires[{Iron, 1}]
-      - TimeToProduce{2}
-      - StackCount{50}
+      TimeToProduce: {2}
+      StackCount: {50}
     }
   }
 
   Gear {
     - Requires[{Iron, 1}]
-    - TimeToProduce{1}
-    - StackCount{100}
+    TimeToProduce: {1}
+    StackCount: {100}
   }
 
   Circuit {
     - Requires[{Iron, 1}, {Copper, 3}]
-    - TimeToProduce{2}
-    - StackCount{100}
+    TimeToProduce: {2}
+    StackCount: {100}
   }
 
   SolarPanel {
     - Requires[{Copper, 5}, {Circuit, 15}, {Steel, 5}]
-    - TimeToProduce{10}
-    - StackCount{20}
+    TimeToProduce: {10}
+    StackCount: {20}
   }
 
   HullMaterial {
     - Requires[{Aluminium, 10}, {Copper, 5}, {Steel, 20}]
-    - TimeToProduce{10}
-    - StackCount{20}
+    TimeToProduce: {10}
+    StackCount: {20}
   }
 
   Radar {
     - Requires[{Gear, 5}, {Circuit, 5}, {Iron, 10}]
-    - TimeToProduce{20}
-    - StackCount{1}
+    TimeToProduce: {20}
+    StackCount: {1}
   }
 
   Satellite {
     - Requires[{HullMaterial, 10}, {SolarPanel, 5}, {Radar, 1}]
-    - TimeToProduce{30}
-    - StackCount{1}
+    TimeToProduce: {30}
+    StackCount: {1}
   }
 }
diff --git a/examples/cpp/game_mechanics/factory/src/main.cpp b/examples/cpp/game_mechanics/factory/src/main.cpp
index a2536b673..e4490aade 100644
--- a/examples/cpp/game_mechanics/factory/src/main.cpp
+++ b/examples/cpp/game_mechanics/factory/src/main.cpp
@@ -199,7 +199,7 @@ struct factories {
 
     // System that transfers resource and resets factory for next item
     world.system<FactorySupply, FactoryProduction, Stores>("Transfer")
-      .term_at(3).second(Wildcard)
+      .term_at(2).second(Wildcard)
       .with(FactoryState::TransferResource)
       .interval(1.0f)
       .each([](entity factory, FactorySupply& s, FactoryProduction& p, Stores& out) {
@@ -289,7 +289,7 @@ struct factories {
         factory.add(FactoryState::WaitingForResources);
 
         // Initialize supply component
-        factory.set([&](FactorySupply& s) {
+        factory.insert([&](FactorySupply& s) {
           for (int i = 0; i < MaxInputs; i ++) {
             entity resource = world.entity(r.items[i].resource);
             entity input = world.entity(config.inputs[i]);
@@ -332,8 +332,8 @@ int main(int argc, char *argv[]) {
 
   world.import<factories>();
 
-  ecs_plecs_from_file(world, "resources.flecs");
-  ecs_plecs_from_file(world, "scene.flecs");
+  ecs_script_run_file(world, "resources.flecs");
+  ecs_script_run_file(world, "scene.flecs");
 
   return world.app()
     .enable_rest()
diff --git a/examples/cpp/game_mechanics/inventory_system/include/inventory_system/bake_config.h b/examples/cpp/game_mechanics/inventory_system/include/inventory_system/bake_config.h
index bc513f353..37d83b1db 100644
--- a/examples/cpp/game_mechanics/inventory_system/include/inventory_system/bake_config.h
+++ b/examples/cpp/game_mechanics/inventory_system/include/inventory_system/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef INVENTORY_SYSTEM_BAKE_CONFIG_H
-#define INVENTORY_SYSTEM_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef INVENTORY_SYSTEM_BAKE_CONFIG_H
+#define INVENTORY_SYSTEM_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/game_mechanics/inventory_system/src/main.cpp b/examples/cpp/game_mechanics/inventory_system/src/main.cpp
index 75d5ac36e..858e01217 100644
--- a/examples/cpp/game_mechanics/inventory_system/src/main.cpp
+++ b/examples/cpp/game_mechanics/inventory_system/src/main.cpp
@@ -98,9 +98,8 @@ flecs::entity get_container(flecs::entity container) {
 // Iterate all items in an inventory
 template <typename Func>
 void for_each_item(flecs::entity container, const Func& func) {
-    container.world().filter_builder()
+    container.world().query_builder()
         .with<ContainedBy>(container)
-        .build()
         .each(func);
 }
 
diff --git a/examples/cpp/game_mechanics/scene_management/include/scene_management/bake_config.h b/examples/cpp/game_mechanics/scene_management/include/scene_management/bake_config.h
index a217ffbe1..f9744660d 100644
--- a/examples/cpp/game_mechanics/scene_management/include/scene_management/bake_config.h
+++ b/examples/cpp/game_mechanics/scene_management/include/scene_management/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SCENE_MANAGEMENT_BAKE_CONFIG_H
-#define SCENE_MANAGEMENT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SCENE_MANAGEMENT_BAKE_CONFIG_H
+#define SCENE_MANAGEMENT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/hello_world/include/hello_world/bake_config.h b/examples/cpp/hello_world/include/hello_world/bake_config.h
index d149f44bd..3f4db37d0 100644
--- a/examples/cpp/hello_world/include/hello_world/bake_config.h
+++ b/examples/cpp/hello_world/include/hello_world/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HELLO_WORLD_BAKE_CONFIG_H
-#define HELLO_WORLD_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HELLO_WORLD_BAKE_CONFIG_H
+#define HELLO_WORLD_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/modules/simple_module/include/simple_module/bake_config.h b/examples/cpp/modules/simple_module/include/simple_module/bake_config.h
index e7f8f4730..bf3bba212 100644
--- a/examples/cpp/modules/simple_module/include/simple_module/bake_config.h
+++ b/examples/cpp/modules/simple_module/include/simple_module/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SIMPLE_MODULE_BAKE_CONFIG_H
-#define SIMPLE_MODULE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SIMPLE_MODULE_BAKE_CONFIG_H
+#define SIMPLE_MODULE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/observers/basics/include/basics/bake_config.h b/examples/cpp/observers/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/cpp/observers/basics/include/basics/bake_config.h
+++ b/examples/cpp/observers/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/observers/custom_event/include/custom_event/bake_config.h b/examples/cpp/observers/custom_event/include/custom_event/bake_config.h
index a98c60c99..03a1113e1 100644
--- a/examples/cpp/observers/custom_event/include/custom_event/bake_config.h
+++ b/examples/cpp/observers/custom_event/include/custom_event/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef CUSTOM_EVENT_BAKE_CONFIG_H
-#define CUSTOM_EVENT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CUSTOM_EVENT_BAKE_CONFIG_H
+#define CUSTOM_EVENT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/observers/monitor/include/monitor/bake_config.h b/examples/cpp/observers/monitor/include/monitor/bake_config.h
index 42149bc48..5a94a9c5a 100644
--- a/examples/cpp/observers/monitor/include/monitor/bake_config.h
+++ b/examples/cpp/observers/monitor/include/monitor/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef MONITOR_BAKE_CONFIG_H
-#define MONITOR_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef MONITOR_BAKE_CONFIG_H
+#define MONITOR_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/observers/propagate/include/propagate/bake_config.h b/examples/cpp/observers/propagate/include/propagate/bake_config.h
index 9ffb6a9c4..63d2accda 100644
--- a/examples/cpp/observers/propagate/include/propagate/bake_config.h
+++ b/examples/cpp/observers/propagate/include/propagate/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef PROPAGATE_BAKE_CONFIG_H
-#define PROPAGATE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef PROPAGATE_BAKE_CONFIG_H
+#define PROPAGATE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/observers/propagate/src/main.cpp b/examples/cpp/observers/propagate/src/main.cpp
index 77d6ee2ba..419c909e2 100644
--- a/examples/cpp/observers/propagate/src/main.cpp
+++ b/examples/cpp/observers/propagate/src/main.cpp
@@ -21,7 +21,7 @@ int main(int, char *[]) {
 
     // Create observer that listens for events from both self and parent
     ecs.observer<Position, Position>()
-        .term_at(2).parent() // select 2nd Position from parent
+        .term_at(1).parent() // select 2nd Position from parent
         .event(flecs::OnSet)
         .each([](flecs::iter& it, size_t i, Position& p_self, Position& p_parent) {
             std::cout << " - " << it.event().name() << ": " 
diff --git a/examples/cpp/observers/two_components/include/two_components/bake_config.h b/examples/cpp/observers/two_components/include/two_components/bake_config.h
index 963e5122b..26b905068 100644
--- a/examples/cpp/observers/two_components/include/two_components/bake_config.h
+++ b/examples/cpp/observers/two_components/include/two_components/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef TWO_COMPONENTS_BAKE_CONFIG_H
-#define TWO_COMPONENTS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef TWO_COMPONENTS_BAKE_CONFIG_H
+#define TWO_COMPONENTS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/observers/yield_existing/include/yield_existing/bake_config.h b/examples/cpp/observers/yield_existing/include/yield_existing/bake_config.h
index c774d0730..75dd5d86b 100644
--- a/examples/cpp/observers/yield_existing/include/yield_existing/bake_config.h
+++ b/examples/cpp/observers/yield_existing/include/yield_existing/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef YIELD_EXISTING_BAKE_CONFIG_H
-#define YIELD_EXISTING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef YIELD_EXISTING_BAKE_CONFIG_H
+#define YIELD_EXISTING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/prefabs/basics/include/basics/bake_config.h b/examples/cpp/prefabs/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/cpp/prefabs/basics/include/basics/bake_config.h
+++ b/examples/cpp/prefabs/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/prefabs/hierarchy/include/hierarchy/bake_config.h b/examples/cpp/prefabs/hierarchy/include/hierarchy/bake_config.h
index 1e21b3812..6b3d117ad 100644
--- a/examples/cpp/prefabs/hierarchy/include/hierarchy/bake_config.h
+++ b/examples/cpp/prefabs/hierarchy/include/hierarchy/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HIERARCHY_BAKE_CONFIG_H
-#define HIERARCHY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HIERARCHY_BAKE_CONFIG_H
+#define HIERARCHY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/prefabs/nested_prefabs/include/nested_prefabs/bake_config.h b/examples/cpp/prefabs/nested_prefabs/include/nested_prefabs/bake_config.h
index 38d688c1e..d59120217 100644
--- a/examples/cpp/prefabs/nested_prefabs/include/nested_prefabs/bake_config.h
+++ b/examples/cpp/prefabs/nested_prefabs/include/nested_prefabs/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef NESTED_PREFABS_BAKE_CONFIG_H
-#define NESTED_PREFABS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef NESTED_PREFABS_BAKE_CONFIG_H
+#define NESTED_PREFABS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/prefabs/override/include/override/bake_config.h b/examples/cpp/prefabs/override/include/override/bake_config.h
index 4f099477c..b96f6d316 100644
--- a/examples/cpp/prefabs/override/include/override/bake_config.h
+++ b/examples/cpp/prefabs/override/include/override/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef OVERRIDE_BAKE_CONFIG_H
-#define OVERRIDE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef OVERRIDE_BAKE_CONFIG_H
+#define OVERRIDE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/prefabs/slots/include/slots/bake_config.h b/examples/cpp/prefabs/slots/include/slots/bake_config.h
index ef3f7b1fa..2f17cf648 100644
--- a/examples/cpp/prefabs/slots/include/slots/bake_config.h
+++ b/examples/cpp/prefabs/slots/include/slots/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SLOTS_BAKE_CONFIG_H
-#define SLOTS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SLOTS_BAKE_CONFIG_H
+#define SLOTS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/prefabs/typed_prefabs/include/typed_prefabs/bake_config.h b/examples/cpp/prefabs/typed_prefabs/include/typed_prefabs/bake_config.h
index c20ff091a..ad73c0019 100644
--- a/examples/cpp/prefabs/typed_prefabs/include/typed_prefabs/bake_config.h
+++ b/examples/cpp/prefabs/typed_prefabs/include/typed_prefabs/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef TYPED_PREFABS_BAKE_CONFIG_H
-#define TYPED_PREFABS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef TYPED_PREFABS_BAKE_CONFIG_H
+#define TYPED_PREFABS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/prefabs/variant/include/variant/bake_config.h b/examples/cpp/prefabs/variant/include/variant/bake_config.h
index c9fe9d02c..c735c4dee 100644
--- a/examples/cpp/prefabs/variant/include/variant/bake_config.h
+++ b/examples/cpp/prefabs/variant/include/variant/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef VARIANT_BAKE_CONFIG_H
-#define VARIANT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef VARIANT_BAKE_CONFIG_H
+#define VARIANT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/basics/include/basics/bake_config.h b/examples/cpp/queries/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/cpp/queries/basics/include/basics/bake_config.h
+++ b/examples/cpp/queries/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/change_tracking/include/change_tracking/bake_config.h b/examples/cpp/queries/change_tracking/include/change_tracking/bake_config.h
index 70674c95e..102f0f38c 100644
--- a/examples/cpp/queries/change_tracking/include/change_tracking/bake_config.h
+++ b/examples/cpp/queries/change_tracking/include/change_tracking/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef CHANGE_TRACKING_BAKE_CONFIG_H
-#define CHANGE_TRACKING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CHANGE_TRACKING_BAKE_CONFIG_H
+#define CHANGE_TRACKING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/change_tracking/src/main.cpp b/examples/cpp/queries/change_tracking/src/main.cpp
index 096bca59a..06f7d33fc 100644
--- a/examples/cpp/queries/change_tracking/src/main.cpp
+++ b/examples/cpp/queries/change_tracking/src/main.cpp
@@ -30,7 +30,7 @@ int main(int, char *[]) {
     // Create a query that writes the component based on a Dirty state.
     flecs::query<const Dirty, Position> q_write = 
         ecs.query_builder<const Dirty, Position>()
-            .term_at(1).up()     // Only match Dirty from prefab
+            .term_at(0).up()     // Only match Dirty from prefab
             .instanced()         // Instanced iteration is faster (see example)
             .build();
 
diff --git a/examples/cpp/rules/component_inheritance/include/component_inheritance.h b/examples/cpp/queries/component_inheritance/include/component_inheritance.h
similarity index 100%
rename from examples/cpp/rules/component_inheritance/include/component_inheritance.h
rename to examples/cpp/queries/component_inheritance/include/component_inheritance.h
diff --git a/examples/c/rules/component_inheritance/include/component_inheritance/bake_config.h b/examples/cpp/queries/component_inheritance/include/component_inheritance/bake_config.h
similarity index 97%
rename from examples/c/rules/component_inheritance/include/component_inheritance/bake_config.h
rename to examples/cpp/queries/component_inheritance/include/component_inheritance/bake_config.h
index e92172cbe..96e8e5dc8 100644
--- a/examples/c/rules/component_inheritance/include/component_inheritance/bake_config.h
+++ b/examples/cpp/queries/component_inheritance/include/component_inheritance/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef COMPONENT_INHERITANCE_BAKE_CONFIG_H
-#define COMPONENT_INHERITANCE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef COMPONENT_INHERITANCE_BAKE_CONFIG_H
+#define COMPONENT_INHERITANCE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/rules/component_inheritance/project.json b/examples/cpp/queries/component_inheritance/project.json
similarity index 100%
rename from examples/cpp/rules/component_inheritance/project.json
rename to examples/cpp/queries/component_inheritance/project.json
diff --git a/examples/cpp/rules/component_inheritance/src/main.cpp b/examples/cpp/queries/component_inheritance/src/main.cpp
similarity index 88%
rename from examples/cpp/rules/component_inheritance/src/main.cpp
rename to examples/cpp/queries/component_inheritance/src/main.cpp
index 2b6d718ad..1362478af 100644
--- a/examples/cpp/rules/component_inheritance/src/main.cpp
+++ b/examples/cpp/queries/component_inheritance/src/main.cpp
@@ -40,16 +40,14 @@ int main(int, char *[]) {
     ecs.entity("builder_1").add<Builder>();
     ecs.entity("builder_2").add<Builder>();
 
-    // Create a rule to find all ranged units
-    flecs::rule<RangedUnit> r = ecs.rule<RangedUnit>();
+    // Create a query to find all ranged units
+    flecs::query<RangedUnit> q = ecs.query<RangedUnit>();
 
-    // Iterate the rule
-    r.each([](flecs::entity e, RangedUnit) {
+    // Iterate the query
+    q.each([](flecs::entity e, RangedUnit) {
         std::cout << "Unit " << e.name() << " found\n";
     });
 
-    r.destruct();
-
     // Output:
     //   Unit wizard_1 found
     //   Unit wizard_2 found
diff --git a/examples/cpp/rules/cyclic_variables/include/cyclic_variables.h b/examples/cpp/queries/cyclic_variables/include/cyclic_variables.h
similarity index 100%
rename from examples/cpp/rules/cyclic_variables/include/cyclic_variables.h
rename to examples/cpp/queries/cyclic_variables/include/cyclic_variables.h
diff --git a/examples/c/rules/cyclic_variables/include/cyclic_variables/bake_config.h b/examples/cpp/queries/cyclic_variables/include/cyclic_variables/bake_config.h
similarity index 96%
rename from examples/c/rules/cyclic_variables/include/cyclic_variables/bake_config.h
rename to examples/cpp/queries/cyclic_variables/include/cyclic_variables/bake_config.h
index d7a1d7a12..369568295 100644
--- a/examples/c/rules/cyclic_variables/include/cyclic_variables/bake_config.h
+++ b/examples/cpp/queries/cyclic_variables/include/cyclic_variables/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef CYCLIC_VARIABLES_BAKE_CONFIG_H
-#define CYCLIC_VARIABLES_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CYCLIC_VARIABLES_BAKE_CONFIG_H
+#define CYCLIC_VARIABLES_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/rules/cyclic_variables/project.json b/examples/cpp/queries/cyclic_variables/project.json
similarity index 100%
rename from examples/cpp/rules/cyclic_variables/project.json
rename to examples/cpp/queries/cyclic_variables/project.json
diff --git a/examples/cpp/rules/cyclic_variables/src/main.cpp b/examples/cpp/queries/cyclic_variables/src/main.cpp
similarity index 73%
rename from examples/cpp/rules/cyclic_variables/src/main.cpp
rename to examples/cpp/queries/cyclic_variables/src/main.cpp
index 6817ccb56..0b54193b3 100644
--- a/examples/cpp/rules/cyclic_variables/src/main.cpp
+++ b/examples/cpp/queries/cyclic_variables/src/main.cpp
@@ -1,7 +1,7 @@
 #include <cyclic_variables.h>
 #include <iostream>
 
-// This example shows how a rule may have terms with cyclic dependencies on
+// This example shows how a query may have terms with cyclic dependencies on
 // variables.
 
 struct Likes { };
@@ -20,32 +20,32 @@ int main(int, char *[]) {
     jane.add<Likes>(john);
     bob.add<Likes>(jane); // inserting a bit of drama
 
-    // The following rule will only return entities that have a cyclic Likes
+    // The following query will only return entities that have a cyclic Likes
     // relationship- that is they must both like each other.
     //
     // The equivalent query in the DSL is:
     //   Likes($X, $Y), Likes($Y, $X)
     //
     // This is also an example of a query where all sources are variables. By
-    // default queries use the builtin "This" variable as subject, which is what
+    // default queries use the builtin "this" variable as subject, which is what
     // populates the entities array in the query result (accessed by the
     // iter::entity function). 
     //
     // Because this query does not use This at all, the entities array will not
     // be populated, and it.count() will always be 0.
-    flecs::rule<> r = ecs.rule_builder()
+    flecs::query<> q = ecs.query_builder()
         .with<Likes>("$Y").src("$X")
         .with<Likes>("$X").src("$Y")
         .build();
 
     // Lookup the index of the variables. This will let us quickly lookup their
     // values while we're iterating.
-    int x_var = r.find_var("X");
-    int y_var = r.find_var("Y");
+    int x_var = q.find_var("X");
+    int y_var = q.find_var("Y");
 
     // Because the query doesn't use the This variable we cannot use "each"
     // which iterates the entities array. Instead we can use iter like this:
-    r.iter([&](flecs::iter& it) {
+    q.iter([&](flecs::iter& it) {
         flecs::entity x = it.get_var(x_var);
         flecs::entity y = it.get_var(y_var);
         std::cout << x.name() << " likes " << y.name() << "\n";
@@ -57,11 +57,9 @@ int main(int, char *[]) {
     //  Jane likes John
     //  John likes Jane
 
-    // Note that the rule returns each pair twice. The reason for this is that
-    // the goal of the rule engine is to return all "facts" that are true
+    // Note that the query returns each pair twice. The reason for this is that
+    // the goal of the query engine is to return all "facts" that are true
     // within the given constraints. Since we did not give it any constraints
-    // that would favor a person being matched by X or Y, the rule engine
+    // that would favor a person being matched by X or Y, the query engine
     // returns both.
-
-    r.destruct();
 }
diff --git a/examples/cpp/rules/facts/.gitignore b/examples/cpp/queries/facts/.gitignore
similarity index 100%
rename from examples/cpp/rules/facts/.gitignore
rename to examples/cpp/queries/facts/.gitignore
diff --git a/examples/cpp/rules/facts/include/facts.h b/examples/cpp/queries/facts/include/facts.h
similarity index 100%
rename from examples/cpp/rules/facts/include/facts.h
rename to examples/cpp/queries/facts/include/facts.h
diff --git a/examples/c/rules/facts/include/facts/bake_config.h b/examples/cpp/queries/facts/include/facts/bake_config.h
similarity index 96%
rename from examples/c/rules/facts/include/facts/bake_config.h
rename to examples/cpp/queries/facts/include/facts/bake_config.h
index 8a85668d7..4eaf7b969 100644
--- a/examples/c/rules/facts/include/facts/bake_config.h
+++ b/examples/cpp/queries/facts/include/facts/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef FACTS_BAKE_CONFIG_H
-#define FACTS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef FACTS_BAKE_CONFIG_H
+#define FACTS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/rules/facts/project.json b/examples/cpp/queries/facts/project.json
similarity index 100%
rename from examples/cpp/rules/facts/project.json
rename to examples/cpp/queries/facts/project.json
diff --git a/examples/cpp/rules/facts/src/main.cpp b/examples/cpp/queries/facts/src/main.cpp
similarity index 73%
rename from examples/cpp/rules/facts/src/main.cpp
rename to examples/cpp/queries/facts/src/main.cpp
index 910d9a9d8..42623f25f 100644
--- a/examples/cpp/rules/facts/src/main.cpp
+++ b/examples/cpp/queries/facts/src/main.cpp
@@ -6,9 +6,9 @@
 //   Position, Velocity
 //
 // When written out in full, this query looks like:
-//   Position($This), Velocity($This)
+//   Position($this), Velocity($this)
 //
-// "This" is a (builtin) query variable that is unknown before we evaluate the 
+// "this" is a (builtin) query variable that is unknown before we evaluate the 
 // query. Therefore this query does not test a fact, we can't know which values
 // This will assume.
 //
@@ -16,7 +16,7 @@
 //   IsA(Cat, Animal)
 //
 // This is a fact: the query has no elements that are unknown before evaluating
-// the query. A rule that checks a fact does not return entities, but will
+// the query. A query that checks a fact does not return entities, but will
 // instead return the reasons why a fact is true (if it is true).
 
 struct Likes { };
@@ -36,23 +36,23 @@ int main(int, char *[]) {
 
     bob.add<Likes>(john); // bit of drama
 
-    // Create a rule that checks if two entities like each other. By itself this
-    // rule is not a fact, but we can use it to check facts by populating both
+    // Create a query that checks if two entities like each other. By itself this
+    // query is not a fact, but we can use it to check facts by populating both
     // of its variables.
     //
     // The equivalent query in the DSL is:
-    //  Likes($X, $Y), Likes($Y, $X)
+    //  Likes($x, $y), Likes($y, $x)
     //
-    // Instead of using variables we could have created a rule that referred the
-    // entities directly, but then we would have to create a rule for each
-    // fact, vs reusing a single rule for multiple facts.
-    flecs::rule<> friends = ecs.rule_builder()
-        .with<Likes>("$Y").src("$X")
-        .with<Likes>("$X").src("$Y")
+    // Instead of using variables we could have created a query that referred the
+    // entities directly, but then we would have to create a query for each
+    // fact, vs reusing a single query for multiple facts.
+    flecs::query<> friends = ecs.query_builder()
+        .with<Likes>("$y").src("$x")
+        .with<Likes>("$x").src("$y")
         .build();
 
-    int x_var = friends.find_var("X");
-    int y_var = friends.find_var("Y");
+    int x_var = friends.find_var("x");
+    int y_var = friends.find_var("y");
 
     // Check a few facts
 
diff --git a/examples/cpp/queries/group_by/include/group_by/bake_config.h b/examples/cpp/queries/group_by/include/group_by/bake_config.h
index ad8665017..838f2c63e 100644
--- a/examples/cpp/queries/group_by/include/group_by/bake_config.h
+++ b/examples/cpp/queries/group_by/include/group_by/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef GROUP_BY_BAKE_CONFIG_H
-#define GROUP_BY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef GROUP_BY_BAKE_CONFIG_H
+#define GROUP_BY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/group_by_callbacks/include/group_by_callbacks/bake_config.h b/examples/cpp/queries/group_by_callbacks/include/group_by_callbacks/bake_config.h
index 3d1e038c3..463c93238 100644
--- a/examples/cpp/queries/group_by_callbacks/include/group_by_callbacks/bake_config.h
+++ b/examples/cpp/queries/group_by_callbacks/include/group_by_callbacks/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef GROUP_BY_CALLBACKS_BAKE_CONFIG_H
-#define GROUP_BY_CALLBACKS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef GROUP_BY_CALLBACKS_BAKE_CONFIG_H
+#define GROUP_BY_CALLBACKS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/group_by_custom/include/group_by_custom/bake_config.h b/examples/cpp/queries/group_by_custom/include/group_by_custom/bake_config.h
index 65b630337..2413007d2 100644
--- a/examples/cpp/queries/group_by_custom/include/group_by_custom/bake_config.h
+++ b/examples/cpp/queries/group_by_custom/include/group_by_custom/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef GROUP_BY_CUSTOM_BAKE_CONFIG_H
-#define GROUP_BY_CUSTOM_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef GROUP_BY_CUSTOM_BAKE_CONFIG_H
+#define GROUP_BY_CUSTOM_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/group_iter/include/group_iter/bake_config.h b/examples/cpp/queries/group_iter/include/group_iter/bake_config.h
index bde625a5c..0f67f72d6 100644
--- a/examples/cpp/queries/group_iter/include/group_iter/bake_config.h
+++ b/examples/cpp/queries/group_iter/include/group_iter/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef GROUP_ITER_BAKE_CONFIG_H
-#define GROUP_ITER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef GROUP_ITER_BAKE_CONFIG_H
+#define GROUP_ITER_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/group_iter/src/main.cpp b/examples/cpp/queries/group_iter/src/main.cpp
index 3ab78a75f..0050598a1 100644
--- a/examples/cpp/queries/group_iter/src/main.cpp
+++ b/examples/cpp/queries/group_iter/src/main.cpp
@@ -77,7 +77,7 @@ int main() {
 
     // Only iterate entities in cell 1_0
     std::cout << "Tables for cell 1_0:\n";
-    q.iter().set_group<Cell_1_0>().iter([&](flecs::iter& it) {
+    q.set_group<Cell_1_0>().iter([&](flecs::iter& it) {
         flecs::entity group = ecs.entity(it.group_id());
         std::cout << " - group " << group.path() << ": table ["
             << it.table().str() << "]\n";
diff --git a/examples/cpp/queries/hierarchy/include/hierarchy/bake_config.h b/examples/cpp/queries/hierarchy/include/hierarchy/bake_config.h
index 1e21b3812..6b3d117ad 100644
--- a/examples/cpp/queries/hierarchy/include/hierarchy/bake_config.h
+++ b/examples/cpp/queries/hierarchy/include/hierarchy/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef HIERARCHY_BAKE_CONFIG_H
-#define HIERARCHY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef HIERARCHY_BAKE_CONFIG_H
+#define HIERARCHY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/hierarchy/src/main.cpp b/examples/cpp/queries/hierarchy/src/main.cpp
index 3f454705a..2c8bb1893 100644
--- a/examples/cpp/queries/hierarchy/src/main.cpp
+++ b/examples/cpp/queries/hierarchy/src/main.cpp
@@ -43,12 +43,12 @@ int main(int, char *[]) {
         ecs.query_builder<const Position, const Position, Position>()
             // Modify terms from template to make sure the query selects the
             // local, world and parent position components.
-            .term_at(1).second<Local>()
+            .term_at(0).second<Local>()
+            .term_at(1).second<World>()
             .term_at(2).second<World>()
-            .term_at(3).second<World>()
 
             // Extend the 2nd query argument to select it from the parent
-            .term_at(2)
+            .term_at(1)
                 // Get from the parent, in breadth-first order (cascade)
                 .parent().cascade()
                 // Make term component optional so we also match the root (sun)
diff --git a/examples/cpp/queries/instancing/include/instancing/bake_config.h b/examples/cpp/queries/instancing/include/instancing/bake_config.h
index 8a716585a..f1866b26b 100644
--- a/examples/cpp/queries/instancing/include/instancing/bake_config.h
+++ b/examples/cpp/queries/instancing/include/instancing/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef INSTANCING_BAKE_CONFIG_H
-#define INSTANCING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef INSTANCING_BAKE_CONFIG_H
+#define INSTANCING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/instancing/src/main.cpp b/examples/cpp/queries/instancing/src/main.cpp
index a153d495a..9eb4d9a6b 100644
--- a/examples/cpp/queries/instancing/src/main.cpp
+++ b/examples/cpp/queries/instancing/src/main.cpp
@@ -42,7 +42,7 @@ int main(int, char *[]) {
     // have Velocity as owned and shared component.
     flecs::query<Position, const Velocity> q = 
         ecs.query_builder<Position, const Velocity>()
-            .term_at(1).self()   // Position must always be owned by the entity
+            .term_at(0).self()   // Position must always be owned by the entity
             .instanced()         // create instanced query
             .build();
 
@@ -75,7 +75,7 @@ int main(int, char *[]) {
 
         // Check if Velocity is owned, in which case it's accessed as array.
         // Position will always be owned, since we set the term to Self.
-        if (it.is_self(2)) { // Velocity is term 2
+        if (it.is_self(1)) { // Velocity is term 2
             std::cout << "Velocity is owned\n";
             for (auto i : it) {
                 p[i].x += v[i].x;
diff --git a/examples/cpp/queries/iter/include/iter/bake_config.h b/examples/cpp/queries/iter/include/iter/bake_config.h
index 7a0a1be88..4852734b6 100644
--- a/examples/cpp/queries/iter/include/iter/bake_config.h
+++ b/examples/cpp/queries/iter/include/iter/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef ITER_BAKE_CONFIG_H
-#define ITER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef ITER_BAKE_CONFIG_H
+#define ITER_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/rules/setting_variables/include/setting_variables.h b/examples/cpp/queries/setting_variables/include/setting_variables.h
similarity index 100%
rename from examples/cpp/rules/setting_variables/include/setting_variables.h
rename to examples/cpp/queries/setting_variables/include/setting_variables.h
diff --git a/examples/c/rules/setting_variables/include/setting_variables/bake_config.h b/examples/cpp/queries/setting_variables/include/setting_variables/bake_config.h
similarity index 96%
rename from examples/c/rules/setting_variables/include/setting_variables/bake_config.h
rename to examples/cpp/queries/setting_variables/include/setting_variables/bake_config.h
index 4adefc218..26adb5490 100644
--- a/examples/c/rules/setting_variables/include/setting_variables/bake_config.h
+++ b/examples/cpp/queries/setting_variables/include/setting_variables/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SETTING_VARIABLES_BAKE_CONFIG_H
-#define SETTING_VARIABLES_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SETTING_VARIABLES_BAKE_CONFIG_H
+#define SETTING_VARIABLES_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/rules/setting_variables/project.json b/examples/cpp/queries/setting_variables/project.json
similarity index 100%
rename from examples/cpp/rules/setting_variables/project.json
rename to examples/cpp/queries/setting_variables/project.json
diff --git a/examples/cpp/rules/setting_variables/src/main.cpp b/examples/cpp/queries/setting_variables/src/main.cpp
similarity index 80%
rename from examples/cpp/rules/setting_variables/src/main.cpp
rename to examples/cpp/queries/setting_variables/src/main.cpp
index b33fe7129..726ac3d1e 100644
--- a/examples/cpp/rules/setting_variables/src/main.cpp
+++ b/examples/cpp/queries/setting_variables/src/main.cpp
@@ -2,7 +2,7 @@
 #include <iostream>
 
 // This example extends the component_inheritance example, and shows how
-// we can use a single rule to match units from different players and platoons
+// we can use a single query to match units from different players and platoons
 // by setting query variables before we iterate.
 //
 // The units in this example belong to a platoon, with the platoons belonging
@@ -63,38 +63,36 @@ int main(int, char *[]) {
         }
     }
 
-    // Create a rule to find all RangedUnits for a platoon/player. The 
+    // Create a query to find all RangedUnits for a platoon/player. The 
     // equivalent query in the query DSL would look like this:
-    //   (Platoon, $Platoon), Player($Platoon, $Player)
+    //   (Platoon, $platoon), Player($platoon, $player)
     //
     // The way to read how this query is evaluated is:
-    // - find all entities with (Platoon, *), store * in _Platoon
-    // - check if _Platoon has (Player, *), store * in _Player
-    flecs::rule<RangedUnit> r = ecs.rule_builder<RangedUnit>()
-        .with<Platoon>().second("$Platoon")
-        .with<Player>("$Player").src("$Platoon")
+    // - find all entities with (Platoon, *), store * in $platoon
+    // - check if _Platoon has (Player, *), store * in $player
+    flecs::query<RangedUnit> q = ecs.query_builder<RangedUnit>()
+        .with<Platoon>("$platoon")
+        .with<Player>("$player").src("$platoon")
         .build();
 
-    // If we would iterate this rule it would return all ranged units for all
+    // If we would iterate this query it would return all ranged units for all
     // platoons & for all players. We can limit the results to just a single
     // platoon or a single player setting a variable beforehand. In this example
     // we'll just find all platoons & ranged units for a single player.
 
-    int player_var = r.find_var("Player");
-    int platoon_var = r.find_var("Platoon");
+    int player_var = q.find_var("Player");
+    int platoon_var = q.find_var("Platoon");
 
-    // Iterate rule, limit the results to units of MyPlayer
-    r.iter().set_var(player_var, ecs.lookup("MyPlayer")) 
+    // Iterate query, limit the results to units of MyPlayer
+    q.set_var(player_var, ecs.lookup("MyPlayer")) 
         .each([&](flecs::iter& it, size_t index, RangedUnit) {
             flecs::entity unit = it.entity(index);
             std::cout << "Unit " << unit.path() << " of class " 
-                      << it.id(1).str() << " in platoon "
+                      << it.id(0).str() << " in platoon "
                       << it.get_var(platoon_var).path() << " for player "
                       << it.get_var(player_var).path() << "\n";
         });
 
-    r.destruct();
-
     // Output:
     //  Unit ::499 of class Wizard in platoon ::496 for player ::MyPlayer
     //  Unit ::503 of class Wizard in platoon ::500 for player ::MyPlayer
diff --git a/examples/cpp/queries/singleton/include/singleton/bake_config.h b/examples/cpp/queries/singleton/include/singleton/bake_config.h
index 0e7de1e5e..4d158e277 100644
--- a/examples/cpp/queries/singleton/include/singleton/bake_config.h
+++ b/examples/cpp/queries/singleton/include/singleton/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SINGLETON_BAKE_CONFIG_H
-#define SINGLETON_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SINGLETON_BAKE_CONFIG_H
+#define SINGLETON_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/singleton/src/main.cpp b/examples/cpp/queries/singleton/src/main.cpp
index 0746458d0..84d893e11 100644
--- a/examples/cpp/queries/singleton/src/main.cpp
+++ b/examples/cpp/queries/singleton/src/main.cpp
@@ -28,7 +28,7 @@ int main(int, char *[]) {
     // Create query that matches Gravity as singleton
     flecs::query<Velocity, const Gravity> q = 
         world.query_builder<Velocity, const Gravity>()
-            .term_at(2).singleton()
+            .term_at(1).singleton()
             .build();
 
     // In a query string expression you can use the $ shortcut for singletons:
diff --git a/examples/cpp/queries/sorting/include/sorting/bake_config.h b/examples/cpp/queries/sorting/include/sorting/bake_config.h
index 1f6db54b3..5b9002713 100644
--- a/examples/cpp/queries/sorting/include/sorting/bake_config.h
+++ b/examples/cpp/queries/sorting/include/sorting/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SORTING_BAKE_CONFIG_H
-#define SORTING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SORTING_BAKE_CONFIG_H
+#define SORTING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/rules/transitive_queries/include/transitive_queries.h b/examples/cpp/queries/transitive_queries/include/transitive_queries.h
similarity index 100%
rename from examples/cpp/rules/transitive_queries/include/transitive_queries.h
rename to examples/cpp/queries/transitive_queries/include/transitive_queries.h
diff --git a/examples/c/rules/transitive_queries/include/transitive_queries/bake_config.h b/examples/cpp/queries/transitive_queries/include/transitive_queries/bake_config.h
similarity index 96%
rename from examples/c/rules/transitive_queries/include/transitive_queries/bake_config.h
rename to examples/cpp/queries/transitive_queries/include/transitive_queries/bake_config.h
index c43d0ea6e..c42959d0c 100644
--- a/examples/c/rules/transitive_queries/include/transitive_queries/bake_config.h
+++ b/examples/cpp/queries/transitive_queries/include/transitive_queries/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef TRANSITIVE_QUERIES_BAKE_CONFIG_H
-#define TRANSITIVE_QUERIES_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef TRANSITIVE_QUERIES_BAKE_CONFIG_H
+#define TRANSITIVE_QUERIES_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/rules/transitive_queries/project.json b/examples/cpp/queries/transitive_queries/project.json
similarity index 100%
rename from examples/cpp/rules/transitive_queries/project.json
rename to examples/cpp/queries/transitive_queries/project.json
diff --git a/examples/cpp/rules/transitive_queries/src/main.cpp b/examples/cpp/queries/transitive_queries/src/main.cpp
similarity index 88%
rename from examples/cpp/rules/transitive_queries/src/main.cpp
rename to examples/cpp/queries/transitive_queries/src/main.cpp
index 58437443e..5ea522837 100644
--- a/examples/cpp/rules/transitive_queries/src/main.cpp
+++ b/examples/cpp/queries/transitive_queries/src/main.cpp
@@ -91,32 +91,29 @@ int main(int, char *[]) {
 
     // Create a query that finds the countries persons live in. Note that these
     // have not been explicitly added to the Person entities, but because the
-    // LocatedIn is transitive, the rule engine will traverse the relationship
+    // LocatedIn is transitive, the query engine will traverse the relationship
     // until it found something that is a country.
     // 
     // The equivalent of this query in the DSL is:
-    //   Person, (LocatedIn, $Location), Country($Location)
-    flecs::rule<> r = ecs.rule_builder()
+    //   Person, (LocatedIn, $location), Country($location)
+    flecs::query<> q = ecs.query_builder()
         .with<Person>()
-        .with<LocatedIn>("$Location")
-        .with<Country>().src("$Location")
+        .with<LocatedIn>("$location")
+        .with<Country>().src("$location")
         .build();
     
     // Lookup the index of the variable. This will let us quickly lookup its
     // value while we're iterating.
-    int location_var = r.find_var("Location");
+    int location_var = q.find_var("location");
 
-    // Iterate the rule
-    r.each([&](flecs::iter& it, size_t index) {
+    // Iterate the query
+    q.each([&](flecs::iter& it, size_t index) {
         std::cout 
             << it.entity(index).name()
             << " lives in " << it.get_var(location_var).name()
             << "\n";
     });
 
-    // Rules need to be explicitly deleted.
-    r.destruct();
-
     // Output:
     //   Bob lives in UnitedStates
     //   Alice lives in UnitedStates
diff --git a/examples/cpp/rules/basics/include/basics.h b/examples/cpp/queries/variables/include/variables.h
similarity index 66%
rename from examples/cpp/rules/basics/include/basics.h
rename to examples/cpp/queries/variables/include/variables.h
index 25fdbeffa..7d3167254 100644
--- a/examples/cpp/rules/basics/include/basics.h
+++ b/examples/cpp/queries/variables/include/variables.h
@@ -1,8 +1,8 @@
-#ifndef BASICS_H
-#define BASICS_H
+#ifndef VARIABLES_H
+#define VARIABLES_H
 
 /* This generated file contains includes for project dependencies */
-#include "basics/bake_config.h"
+#include "variables/bake_config.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/examples/cpp/queries/variables/include/variables/bake_config.h b/examples/cpp/queries/variables/include/variables/bake_config.h
new file mode 100644
index 000000000..f4997a774
--- /dev/null
+++ b/examples/cpp/queries/variables/include/variables/bake_config.h
@@ -0,0 +1,24 @@
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef VARIABLES_BAKE_CONFIG_H
+#define VARIABLES_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/rules/basics/project.json b/examples/cpp/queries/variables/project.json
similarity index 86%
rename from examples/cpp/rules/basics/project.json
rename to examples/cpp/queries/variables/project.json
index 12fa5ded8..665330200 100644
--- a/examples/cpp/rules/basics/project.json
+++ b/examples/cpp/queries/variables/project.json
@@ -1,5 +1,5 @@
 {
-    "id": "basics",
+    "id": "variables",
     "type": "application",
     "value": {
         "use": [
diff --git a/examples/cpp/rules/basics/src/main.cpp b/examples/cpp/queries/variables/src/main.cpp
similarity index 71%
rename from examples/cpp/rules/basics/src/main.cpp
rename to examples/cpp/queries/variables/src/main.cpp
index df065589d..8611e63c9 100644
--- a/examples/cpp/rules/basics/src/main.cpp
+++ b/examples/cpp/queries/variables/src/main.cpp
@@ -1,4 +1,4 @@
-#include <basics.h>
+#include <variables.h>
 #include <iostream>
 
 struct Eats { };
@@ -23,13 +23,13 @@ int main(int, char *[]) {
         .add<Eats>(Chocolate)
         .add<Eats>(Apples);
 
-    // Here we're creating a rule that in the query DSL would look like this:
-    //   Eats($This, $Food), Healthy($Food)
+    // Here we're creating a query that in the query DSL would look like this:
+    //   Eats($this, $Food), Healthy($Food)
     //
     // Rules are similar to queries, but support more advanced features. This
     // example shows how the basics of how to use rules & variables.
-    flecs::rule<> r = ecs.rule_builder()
-        // Identifiers that start with _ are query variables. Query variables
+    flecs::query<> q = ecs.query_builder()
+        // Identifiers that start with $ are query variables. Query variables
         // are like wildcards, but enforce that the entity substituted by the
         // wildcard is the same across terms.
         //
@@ -37,27 +37,24 @@ int main(int, char *[]) {
         // substituted by the * for Eats is the same as for Healthy:
         //   (Eats, *), Healthy(*)
         //
-        // By replacing * with _Food, both terms are constrained to use the
-        // same entity.
-        .with<Eats>("$Food")
-        .with<Healthy>().src("$Food")
+        // By replacing * with $food, both terms will be constrained to
+        // match the same entity for the wildcard.
+        .with<Eats>("$food")
+        .with<Healthy>().src("$food")
         .build();
 
     // Lookup the index of the variable. This will let us quickly lookup its
     // value while we're iterating.
-    int food_var = r.find_var("Food");
+    int food_var = q.find_var("food");
 
-    // Iterate the rule
-    r.each([&](flecs::iter& it, size_t index) {
+    // Iterate the query
+    q.each([&](flecs::iter& it, size_t index) {
         std::cout 
             << it.entity(index).name()
             << " eats " << it.get_var(food_var).name()
             << "\n";
     });
 
-    // Rules need to be explicitly deleted.
-    r.destruct();
-
     // Output:
     //  Bob eats Apples
     //  Alice eats Apples
diff --git a/examples/cpp/queries/wildcards/include/wildcards/bake_config.h b/examples/cpp/queries/wildcards/include/wildcards/bake_config.h
index 9a809e64c..6c570d770 100644
--- a/examples/cpp/queries/wildcards/include/wildcards/bake_config.h
+++ b/examples/cpp/queries/wildcards/include/wildcards/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef WILDCARDS_BAKE_CONFIG_H
-#define WILDCARDS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef WILDCARDS_BAKE_CONFIG_H
+#define WILDCARDS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/wildcards/src/main.cpp b/examples/cpp/queries/wildcards/src/main.cpp
index 7a767980f..a37801ed7 100644
--- a/examples/cpp/queries/wildcards/src/main.cpp
+++ b/examples/cpp/queries/wildcards/src/main.cpp
@@ -16,7 +16,7 @@ int main(int, char *[]) {
 
     // Create a query that matches edible components
     flecs::query<Eats> q = ecs.query_builder<Eats>()
-        .term_at(1).second(flecs::Wildcard) // Change first argument to (Eats, *)
+        .term_at(0).second(flecs::Wildcard) // Change first argument to (Eats, *)
         .build();
 
     // Create a few entities that match the query
@@ -31,7 +31,7 @@ int main(int, char *[]) {
     // the pair that we are currently matched with.
     q.each([](flecs::iter& it, size_t index, Eats& eats) {
         flecs::entity e = it.entity(index);
-        flecs::entity food = it.pair(1).second();
+        flecs::entity food = it.pair(0).second();
 
         std::cout << e.name() << " eats " 
             << eats.amount << " " << food.name() << std::endl;
diff --git a/examples/cpp/queries/with/include/with/bake_config.h b/examples/cpp/queries/with/include/with/bake_config.h
index 0cfca607f..0fab56ac6 100644
--- a/examples/cpp/queries/with/include/with/bake_config.h
+++ b/examples/cpp/queries/with/include/with/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef WITH_BAKE_CONFIG_H
-#define WITH_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef WITH_BAKE_CONFIG_H
+#define WITH_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/without/include/without/bake_config.h b/examples/cpp/queries/without/include/without/bake_config.h
index 0da8aaa2b..e1164c9ef 100644
--- a/examples/cpp/queries/without/include/without/bake_config.h
+++ b/examples/cpp/queries/without/include/without/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef WITHOUT_BAKE_CONFIG_H
-#define WITHOUT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef WITHOUT_BAKE_CONFIG_H
+#define WITHOUT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/world_query/include/world_query/bake_config.h b/examples/cpp/queries/world_query/include/world_query/bake_config.h
index 4c3083bd3..ec9c20cb5 100644
--- a/examples/cpp/queries/world_query/include/world_query/bake_config.h
+++ b/examples/cpp/queries/world_query/include/world_query/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef WORLD_QUERY_BAKE_CONFIG_H
-#define WORLD_QUERY_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef WORLD_QUERY_BAKE_CONFIG_H
+#define WORLD_QUERY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/queries/world_query/src/main.cpp b/examples/cpp/queries/world_query/src/main.cpp
index d7574d71f..3f0a9eba9 100644
--- a/examples/cpp/queries/world_query/src/main.cpp
+++ b/examples/cpp/queries/world_query/src/main.cpp
@@ -25,10 +25,7 @@ int main(int, char *[]) {
     ecs.entity("e3")
         .set<Position>({10, 20});
 
-    // Ad hoc queries are bit slower to iterate than flecs::query, but are 
-    // faster to create, and in most cases require no allocations. Under the
-    // hood this API uses flecs::filter, which can be used directly for more
-    // complex queries.
+    // world::each is a quick way to run simple component queries.
     ecs.each([](flecs::entity e, Position& p, Velocity& v) {
         p.x += v.x;
         p.y += v.y;
diff --git a/examples/cpp/reflection/basics/include/basics/bake_config.h b/examples/cpp/reflection/basics/include/basics/bake_config.h
index dde057bed..0fcd5d6e7 100644
--- a/examples/cpp/reflection/basics/include/basics/bake_config.h
+++ b/examples/cpp/reflection/basics/include/basics/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BAKE_CONFIG_H
-#define BASICS_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BAKE_CONFIG_H
+#define BASICS_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/basics_bitmask/include/basics_bitmask/bake_config.h b/examples/cpp/reflection/basics_bitmask/include/basics_bitmask/bake_config.h
index 5d8bdb70c..1883b0a80 100644
--- a/examples/cpp/reflection/basics_bitmask/include/basics_bitmask/bake_config.h
+++ b/examples/cpp/reflection/basics_bitmask/include/basics_bitmask/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_BITMASK_BAKE_CONFIG_H
-#define BASICS_BITMASK_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_BITMASK_BAKE_CONFIG_H
+#define BASICS_BITMASK_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/basics_deserialize/include/basics_deserialize/bake_config.h b/examples/cpp/reflection/basics_deserialize/include/basics_deserialize/bake_config.h
index a96ae6452..f3468a5eb 100644
--- a/examples/cpp/reflection/basics_deserialize/include/basics_deserialize/bake_config.h
+++ b/examples/cpp/reflection/basics_deserialize/include/basics_deserialize/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_DESERIALIZE_BAKE_CONFIG_H
-#define BASICS_DESERIALIZE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_DESERIALIZE_BAKE_CONFIG_H
+#define BASICS_DESERIALIZE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/basics_enum/include/basics_enum/bake_config.h b/examples/cpp/reflection/basics_enum/include/basics_enum/bake_config.h
index 0efb351d7..c4008dcd0 100644
--- a/examples/cpp/reflection/basics_enum/include/basics_enum/bake_config.h
+++ b/examples/cpp/reflection/basics_enum/include/basics_enum/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_ENUM_BAKE_CONFIG_H
-#define BASICS_ENUM_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_ENUM_BAKE_CONFIG_H
+#define BASICS_ENUM_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/basics_json/include/basics_json/bake_config.h b/examples/cpp/reflection/basics_json/include/basics_json/bake_config.h
index f27b048c9..10688523d 100644
--- a/examples/cpp/reflection/basics_json/include/basics_json/bake_config.h
+++ b/examples/cpp/reflection/basics_json/include/basics_json/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef BASICS_JSON_BAKE_CONFIG_H
-#define BASICS_JSON_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef BASICS_JSON_BAKE_CONFIG_H
+#define BASICS_JSON_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/entity_type/include/entity_type/bake_config.h b/examples/cpp/reflection/entity_type/include/entity_type/bake_config.h
index d3135506b..5772c9aca 100644
--- a/examples/cpp/reflection/entity_type/include/entity_type/bake_config.h
+++ b/examples/cpp/reflection/entity_type/include/entity_type/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef ENTITY_TYPE_BAKE_CONFIG_H
-#define ENTITY_TYPE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef ENTITY_TYPE_BAKE_CONFIG_H
+#define ENTITY_TYPE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/member_ranges/include/member_ranges/bake_config.h b/examples/cpp/reflection/member_ranges/include/member_ranges/bake_config.h
index 17e8e58c9..41cbd6815 100644
--- a/examples/cpp/reflection/member_ranges/include/member_ranges/bake_config.h
+++ b/examples/cpp/reflection/member_ranges/include/member_ranges/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef MEMBER_RANGES_BAKE_CONFIG_H
-#define MEMBER_RANGES_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef MEMBER_RANGES_BAKE_CONFIG_H
+#define MEMBER_RANGES_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/nested_set_member/include/nested_set_member/bake_config.h b/examples/cpp/reflection/nested_set_member/include/nested_set_member/bake_config.h
index 36a49027c..a2eb4bf87 100644
--- a/examples/cpp/reflection/nested_set_member/include/nested_set_member/bake_config.h
+++ b/examples/cpp/reflection/nested_set_member/include/nested_set_member/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef NESTED_SET_MEMBER_BAKE_CONFIG_H
-#define NESTED_SET_MEMBER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef NESTED_SET_MEMBER_BAKE_CONFIG_H
+#define NESTED_SET_MEMBER_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/nested_struct/include/nested_struct/bake_config.h b/examples/cpp/reflection/nested_struct/include/nested_struct/bake_config.h
index ea48200ef..eae36efe1 100644
--- a/examples/cpp/reflection/nested_struct/include/nested_struct/bake_config.h
+++ b/examples/cpp/reflection/nested_struct/include/nested_struct/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef NESTED_STRUCT_BAKE_CONFIG_H
-#define NESTED_STRUCT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef NESTED_STRUCT_BAKE_CONFIG_H
+#define NESTED_STRUCT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/portable_type/include/portable_type/bake_config.h b/examples/cpp/reflection/portable_type/include/portable_type/bake_config.h
index 2de649d0e..11b944c8a 100644
--- a/examples/cpp/reflection/portable_type/include/portable_type/bake_config.h
+++ b/examples/cpp/reflection/portable_type/include/portable_type/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef PORTABLE_TYPE_BAKE_CONFIG_H
-#define PORTABLE_TYPE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef PORTABLE_TYPE_BAKE_CONFIG_H
+#define PORTABLE_TYPE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/query_to_custom_json/include/query_to_custom_json/bake_config.h b/examples/cpp/reflection/query_to_custom_json/include/query_to_custom_json/bake_config.h
index 5d4990d7e..74205bc6b 100644
--- a/examples/cpp/reflection/query_to_custom_json/include/query_to_custom_json/bake_config.h
+++ b/examples/cpp/reflection/query_to_custom_json/include/query_to_custom_json/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef QUERY_TO_CUSTOM_JSON_BAKE_CONFIG_H
-#define QUERY_TO_CUSTOM_JSON_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef QUERY_TO_CUSTOM_JSON_BAKE_CONFIG_H
+#define QUERY_TO_CUSTOM_JSON_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/query_to_json/include/query_to_json/bake_config.h b/examples/cpp/reflection/query_to_json/include/query_to_json/bake_config.h
index ee7b7b2d1..93ad4446e 100644
--- a/examples/cpp/reflection/query_to_json/include/query_to_json/bake_config.h
+++ b/examples/cpp/reflection/query_to_json/include/query_to_json/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef QUERY_TO_JSON_BAKE_CONFIG_H
-#define QUERY_TO_JSON_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef QUERY_TO_JSON_BAKE_CONFIG_H
+#define QUERY_TO_JSON_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/runtime_component/include/runtime_component/bake_config.h b/examples/cpp/reflection/runtime_component/include/runtime_component/bake_config.h
index 07b203365..ff4d4c766 100644
--- a/examples/cpp/reflection/runtime_component/include/runtime_component/bake_config.h
+++ b/examples/cpp/reflection/runtime_component/include/runtime_component/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef RUNTIME_COMPONENT_BAKE_CONFIG_H
-#define RUNTIME_COMPONENT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef RUNTIME_COMPONENT_BAKE_CONFIG_H
+#define RUNTIME_COMPONENT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/runtime_nested_component/include/runtime_nested_component/bake_config.h b/examples/cpp/reflection/runtime_nested_component/include/runtime_nested_component/bake_config.h
index 1f5d9cde8..2af8c03e9 100644
--- a/examples/cpp/reflection/runtime_nested_component/include/runtime_nested_component/bake_config.h
+++ b/examples/cpp/reflection/runtime_nested_component/include/runtime_nested_component/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef RUNTIME_NESTED_COMPONENT_BAKE_CONFIG_H
-#define RUNTIME_NESTED_COMPONENT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef RUNTIME_NESTED_COMPONENT_BAKE_CONFIG_H
+#define RUNTIME_NESTED_COMPONENT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/ser_opaque_type/include/ser_opaque_type/bake_config.h b/examples/cpp/reflection/ser_opaque_type/include/ser_opaque_type/bake_config.h
index 3bcf12d9f..4c371421a 100644
--- a/examples/cpp/reflection/ser_opaque_type/include/ser_opaque_type/bake_config.h
+++ b/examples/cpp/reflection/ser_opaque_type/include/ser_opaque_type/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SER_OPAQUE_TYPE_BAKE_CONFIG_H
-#define SER_OPAQUE_TYPE_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SER_OPAQUE_TYPE_BAKE_CONFIG_H
+#define SER_OPAQUE_TYPE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/ser_std_string/include/ser_std_string/bake_config.h b/examples/cpp/reflection/ser_std_string/include/ser_std_string/bake_config.h
index 8c4bd7eec..7a9d59c4a 100644
--- a/examples/cpp/reflection/ser_std_string/include/ser_std_string/bake_config.h
+++ b/examples/cpp/reflection/ser_std_string/include/ser_std_string/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SER_STD_STRING_BAKE_CONFIG_H
-#define SER_STD_STRING_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SER_STD_STRING_BAKE_CONFIG_H
+#define SER_STD_STRING_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/reflection/ser_std_vector/include/ser_std_vector/bake_config.h b/examples/cpp/reflection/ser_std_vector/include/ser_std_vector/bake_config.h
index 21cb5f932..be7c97875 100644
--- a/examples/cpp/reflection/ser_std_vector/include/ser_std_vector/bake_config.h
+++ b/examples/cpp/reflection/ser_std_vector/include/ser_std_vector/bake_config.h
@@ -1,24 +1,24 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SER_STD_VECTOR_BAKE_CONFIG_H
-#define SER_STD_VECTOR_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SER_STD_VECTOR_BAKE_CONFIG_H
+#define SER_STD_VECTOR_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/relationships/enum_relations/src/main.cpp b/examples/cpp/relationships/enum_relations/src/main.cpp
index b65cbf289..97073eeb7 100644
--- a/examples/cpp/relationships/enum_relations/src/main.cpp
+++ b/examples/cpp/relationships/enum_relations/src/main.cpp
@@ -58,11 +58,11 @@ int main(int, char *[]) {
     ecs.entity().add(Tile::Sand).add(TileStatus::Occupied);
 
     // Iterate all entities with a Tile relationship
-    ecs.filter_builder()
+    ecs.query_builder()
         .with<Tile>(flecs::Wildcard)
         .build()
         .each([&](flecs::iter& it, size_t) {
-            flecs::entity tile_constant = it.pair(1).second();
+            flecs::entity tile_constant = it.pair(0).second();
             printf("%s\n", tile_constant.path().c_str());
         });
 
@@ -72,12 +72,12 @@ int main(int, char *[]) {
     //  ::Tile::Sand
 
     // Iterate only occupied tiles
-    ecs.filter_builder()
+    ecs.query_builder()
         .with<Tile>(flecs::Wildcard)
         .with(TileStatus::Occupied)
         .build()
         .each([&](flecs::iter& it, size_t) {
-            flecs::entity tile_constant = it.pair(1).second();
+            flecs::entity tile_constant = it.pair(0).second();
             printf("%s\n", tile_constant.path().c_str());
         });
 
diff --git a/examples/cpp/relationships/relation_component/src/main.cpp b/examples/cpp/relationships/relation_component/src/main.cpp
index 73d61c044..c5ecc5960 100644
--- a/examples/cpp/relationships/relation_component/src/main.cpp
+++ b/examples/cpp/relationships/relation_component/src/main.cpp
@@ -48,7 +48,7 @@ int main(int, char*[]) {
 
     // You can prevent a pair from assuming the type of a component by adding
     // the Tag property to a relationship:
-    ecs.component<MustHave>().add(flecs::Tag);
+    ecs.component<MustHave>().add(flecs::PairIsTag);
 
     // Even though Position is a component, <MustHave, Position> contains no
     // data because MustHave has the Tag property.
@@ -63,7 +63,7 @@ int main(int, char*[]) {
     // When querying for a relationship component, add the pair type as template
     // argument to the builder:
     flecs::query<Requires> q = ecs.query_builder<Requires>()
-        .term_at(1).second<Gigawatts>() // set second part of pair for first term
+        .term_at(0).second<Gigawatts>() // set second part of pair for first term
         .build();
     
     // When iterating, always use the pair type:
diff --git a/examples/cpp/relationships/union/src/main.cpp b/examples/cpp/relationships/union/src/main.cpp
index 791b73135..d37692dc7 100644
--- a/examples/cpp/relationships/union/src/main.cpp
+++ b/examples/cpp/relationships/union/src/main.cpp
@@ -31,8 +31,9 @@ enum Direction {
 int main(int argc, char *argv[]) {
     flecs::world ecs(argc, argv);
 
-    ecs.component<Movement>().add(flecs::Union);
-    ecs.component<Direction>().add(flecs::Union);
+    // TODO
+    // ecs.component<Movement>().add(flecs::Union);
+    // ecs.component<Direction>().add(flecs::Union);
 
     // Create a query that subscribes for all entities that have a Direction
     // and that are walking.
@@ -63,8 +64,8 @@ int main(int argc, char *argv[]) {
     q.iter([&](const flecs::iter& it) {
         // Get the column with direction states. This is stored as an array
         // with identifiers to the individual states
-        auto movement = it.field<const flecs::entity_t>(1);
-        auto direction = it.field<const flecs::entity_t>(2);
+        auto movement = it.field<const flecs::entity_t>(0);
+        auto direction = it.field<const flecs::entity_t>(1);
 
         for (auto i : it) {
             // Movement will always be Walking, Direction can be any state
diff --git a/test/custom_builds/cpp/snapshot/include/snapshot.h b/examples/cpp/systems/immediate/include/immediate.h
similarity index 66%
rename from test/custom_builds/cpp/snapshot/include/snapshot.h
rename to examples/cpp/systems/immediate/include/immediate.h
index 5a1b0ca48..1aecd4de2 100644
--- a/test/custom_builds/cpp/snapshot/include/snapshot.h
+++ b/examples/cpp/systems/immediate/include/immediate.h
@@ -1,8 +1,8 @@
-#ifndef SNAPSHOT_H
-#define SNAPSHOT_H
+#ifndef IMMEDIATE_H
+#define IMMEDIATE_H
 
 /* This generated file contains includes for project dependencies */
-#include "snapshot/bake_config.h"
+#include "immediate/bake_config.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/examples/cpp/systems/immediate/include/immediate/bake_config.h b/examples/cpp/systems/immediate/include/immediate/bake_config.h
new file mode 100644
index 000000000..25f8e5513
--- /dev/null
+++ b/examples/cpp/systems/immediate/include/immediate/bake_config.h
@@ -0,0 +1,24 @@
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef IMMEDIATE_BAKE_CONFIG_H
+#define IMMEDIATE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+#endif
+
diff --git a/examples/cpp/systems/no_readonly/project.json b/examples/cpp/systems/immediate/project.json
similarity index 85%
rename from examples/cpp/systems/no_readonly/project.json
rename to examples/cpp/systems/immediate/project.json
index 47e026263..c6708e2ed 100644
--- a/examples/cpp/systems/no_readonly/project.json
+++ b/examples/cpp/systems/immediate/project.json
@@ -1,5 +1,5 @@
 {
-    "id": "no_readonly",
+    "id": "immediate",
     "type": "application",
     "value": {
         "use": [
diff --git a/examples/cpp/systems/no_readonly/src/main.cpp b/examples/cpp/systems/immediate/src/main.cpp
similarity index 92%
rename from examples/cpp/systems/no_readonly/src/main.cpp
rename to examples/cpp/systems/immediate/src/main.cpp
index dd4f3b75d..957c60952 100644
--- a/examples/cpp/systems/no_readonly/src/main.cpp
+++ b/examples/cpp/systems/immediate/src/main.cpp
@@ -1,4 +1,4 @@
-#include <no_readonly.h>
+#include <immediate.h>
 #include <iostream>
 
 // When an application calls world.progress(), the world is put in readonly mode.
@@ -8,10 +8,10 @@
 // or removing components) are not visible until the end of the frame (see the
 // sync_point example for more details).
 // Sometimes this is not what you want, and you need a change to be visible
-// immediately. For these use cases, applications can use a no_readonly system.
+// immediately. For these use cases, applications can use a immediate system.
 // This temporarily takes the world out of readonly mode, so a system can make
 // changes that are directly visible.
-// Because they mutate the world directly, no_readonly systems are never ran on
+// Because they mutate the world directly, immediate systems are never ran on
 // more than one thread, and no other systems are ran at the same time.
 
 struct Waiter { };
@@ -26,13 +26,13 @@ int main(int, char *[]) {
         .without<Plate>(flecs::Wildcard)
         .build();
 
-    // System that assigns plates to waiter. By making this system no_readonly
+    // System that assigns plates to waiter. By making this system immediate
     // plate assignments are assigned directly (not deferred) to waiters, which 
     // ensures that we won't assign plates to the same waiter more than once.
     ecs.system("AssignPlate")
         .with<Plate>()
         .without<Waiter>(flecs::Wildcard)
-        .no_readonly()
+        .immediate()
         .iter([&](flecs::iter& it) {
             for (auto i : it) {
                 flecs::entity plate = it.entity(i);
@@ -44,7 +44,7 @@ int main(int, char *[]) {
                     // that the next plate will no longer find it.
                     // The defer_suspend function temporarily suspends deferring 
                     // operations, which ensures that our plate is assigned 
-                    // immediately. Even though this is a no_readonly system, 
+                    // immediately. Even though this is a immediate system, 
                     // defering is still enabled by default, as adding/removing 
                     // components to the entities being iterated would intefere 
                     // with the system iterator.
diff --git a/examples/cpp/systems/no_readonly/include/no_readonly.h b/examples/cpp/systems/no_readonly/include/no_readonly.h
deleted file mode 100644
index 6aee24f3e..000000000
--- a/examples/cpp/systems/no_readonly/include/no_readonly.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef NO_READONLY_H
-#define NO_READONLY_H
-
-/* This generated file contains includes for project dependencies */
-#include "no_readonly/bake_config.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
diff --git a/examples/os_api/stdcpp/include/flecs-os_api-stdcpp/bake_config.h b/examples/os_api/stdcpp/include/flecs-os_api-stdcpp/bake_config.h
index 9256812d9..8b35da367 100644
--- a/examples/os_api/stdcpp/include/flecs-os_api-stdcpp/bake_config.h
+++ b/examples/os_api/stdcpp/include/flecs-os_api-stdcpp/bake_config.h
@@ -1,39 +1,39 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef FLECS_OS_API_STDCPP_BAKE_CONFIG_H
-#define FLECS_OS_API_STDCPP_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include <flecs.h>
-
-/* Convenience macro for exporting symbols */
-#ifndef flecs_os_api_stdcpp_STATIC
-#if defined(flecs_os_api_stdcpp_EXPORTS) && (defined(_MSC_VER) || defined(__MINGW32__))
-  #define FLECS_OS_API_STDCPP_API __declspec(dllexport)
-#elif defined(flecs_os_api_stdcpp_EXPORTS)
-  #define FLECS_OS_API_STDCPP_API __attribute__((__visibility__("default")))
-#elif defined(_MSC_VER)
-  #define FLECS_OS_API_STDCPP_API __declspec(dllimport)
-#else
-  #define FLECS_OS_API_STDCPP_API
-#endif
-#else
-  #define FLECS_OS_API_STDCPP_API
-#endif
-
-#endif
-
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef FLECS_OS_API_STDCPP_BAKE_CONFIG_H
+#define FLECS_OS_API_STDCPP_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+
+/* Convenience macro for exporting symbols */
+#ifndef flecs_os_api_stdcpp_STATIC
+#if defined(flecs_os_api_stdcpp_EXPORTS) && (defined(_MSC_VER) || defined(__MINGW32__))
+  #define FLECS_OS_API_STDCPP_API __declspec(dllexport)
+#elif defined(flecs_os_api_stdcpp_EXPORTS)
+  #define FLECS_OS_API_STDCPP_API __attribute__((__visibility__("default")))
+#elif defined(_MSC_VER)
+  #define FLECS_OS_API_STDCPP_API __declspec(dllimport)
+#else
+  #define FLECS_OS_API_STDCPP_API
+#endif
+#else
+  #define FLECS_OS_API_STDCPP_API
+#endif
+
+#endif
+
diff --git a/examples/plecs/anonymous_entity.flecs b/examples/script/anonymous_entity.flecs
similarity index 83%
rename from examples/plecs/anonymous_entity.flecs
rename to examples/script/anonymous_entity.flecs
index cf8913ef9..80b796e41 100644
--- a/examples/plecs/anonymous_entity.flecs
+++ b/examples/script/anonymous_entity.flecs
@@ -1,7 +1,7 @@
 // To see what the result of parsing this file looks like, copy the code and
 // paste it into the editor at https://flecs.dev/explorer
 //
-// To load this file yourself, call ecs_plecs_from_file("anonymous_entity.flecs");
+// To load this file yourself, call ecs_script_run_file("anonymous_entity.flecs");
 
 // To create an entity without a name, use the _ character
 _ :- SpaceShip
diff --git a/examples/plecs/docs.flecs b/examples/script/docs.flecs
similarity index 90%
rename from examples/plecs/docs.flecs
rename to examples/script/docs.flecs
index 264feb6ff..d65439ced 100644
--- a/examples/plecs/docs.flecs
+++ b/examples/script/docs.flecs
@@ -1,7 +1,7 @@
 // To see what the result of parsing this file looks like, copy the code and
 // paste it into the editor at https://flecs.dev/explorer
 //
-// To load this file yourself, call ecs_plecs_from_file("docs.flecs");
+// To load this file yourself, call ecs_script_run_file("docs.flecs");
 
 // Plecs files can be used to annotate entities and components with 
 // documentation. These annotations use the flecs.doc addon.
diff --git a/examples/plecs/expressions.flecs b/examples/script/expressions.flecs
similarity index 73%
rename from examples/plecs/expressions.flecs
rename to examples/script/expressions.flecs
index e2c2c1f24..a95794e45 100644
--- a/examples/plecs/expressions.flecs
+++ b/examples/script/expressions.flecs
@@ -1,19 +1,19 @@
 // To see what the result of parsing this file looks like, copy the code and
 // paste it into the editor at https://flecs.dev/explorer
 //
-// To load this file yourself, call ecs_plecs_from_file("expressions.flecs");
+// To load this file yourself, call ecs_script_run_file("expressions.flecs");
 
 using flecs.meta
 
 // Create component types, see reflection example
-Struct Position {
-  x :- {f32}
-  y :- {f32}
+struct Position {
+  x : f32
+  y : f32
 }
 
-Struct Rectangle {
-  width :- {f32}
-  height :- {f32}
+struct Rectangle {
+  width : f32
+  height : f32
 }
 
 // Plecs files can contain variables that can be referenced later on when 
@@ -26,5 +26,5 @@ const height = $width * 2
 
 e {
   - Position{0, -($height / 2)}
-  - Rectangle{$width, $height}
+  Rectangle: {$width, $height}
 }
diff --git a/examples/plecs/hello_world.flecs b/examples/script/hello_world.flecs
similarity index 96%
rename from examples/plecs/hello_world.flecs
rename to examples/script/hello_world.flecs
index 2b430859f..2b9af780b 100644
--- a/examples/plecs/hello_world.flecs
+++ b/examples/script/hello_world.flecs
@@ -10,7 +10,7 @@
 // To see what the result of parsing this file looks like, copy the code and
 // paste it into the editor at https://flecs.dev/explorer
 //
-// To load this file yourself, call ecs_plecs_from_file("hello_world.flecs");
+// To load this file yourself, call ecs_script_run_file("hello_world.flecs");
 
 // This creates an entity my_spaceship with the SpaceShip tag. Note how neither
 // the entity nor tag need to be defined in advance, if an entity did not yet
diff --git a/examples/plecs/prefabs.flecs b/examples/script/prefabs.flecs
similarity index 74%
rename from examples/plecs/prefabs.flecs
rename to examples/script/prefabs.flecs
index 30dd727e1..5c1552b76 100644
--- a/examples/plecs/prefabs.flecs
+++ b/examples/script/prefabs.flecs
@@ -1,17 +1,17 @@
 // To see what the result of parsing this file looks like, copy the code and
 // paste it into the editor at https://flecs.dev/explorer
 //
-// To load this file yourself, call ecs_plecs_from_file("prefabs.flecs");
+// To load this file yourself, call ecs_script_run_file("prefabs.flecs");
 
 // Create a component types (see reflection.flecs example)
 using flecs.meta
 
-Struct Attack {
-  value :- {f32}
+struct Attack {
+  value : f32
 }
 
-Struct Defense {
-  value :- {f32}
+struct Defense {
+  value : f32
 }
 
 // To create a prefab, you can create an entity with the Prefab tag:
@@ -20,16 +20,16 @@ SpaceShip :- Prefab
 // Alternatively you can use the shorthand declaration syntax which has the same
 // result, and allows you to open a scope after the statement:
 Prefab SpaceShip {
-  - Attack{50}
-  - Defense{50}
+  Attack: {50}
+  Defense: {50}
 }
 
 // To create a prefab that inherits from SpaceShip, we can use the : operator
 Prefab Freighter : SpaceShip {
-  - Defense{100}
+  Defense: {100}
 }
 
 // We can create a prefab instance with the same : operator.
 my_spaceship : Freighter {
-  - Attack{75} // Override component from SpaceShip
+  Attack: {75} // Override component from SpaceShip
 }
diff --git a/examples/plecs/reflection.flecs b/examples/script/reflection.flecs
similarity index 87%
rename from examples/plecs/reflection.flecs
rename to examples/script/reflection.flecs
index c07afa28e..43d8baffa 100644
--- a/examples/plecs/reflection.flecs
+++ b/examples/script/reflection.flecs
@@ -1,7 +1,7 @@
 // To see what the result of parsing this file looks like, copy the code and
 // paste it into the editor at https://flecs.dev/explorer
 //
-// To load this file yourself, call ecs_plecs_from_file("reflection.flecs");
+// To load this file yourself, call ecs_script_run_file("reflection.flecs");
 
 // It is possible to set component values in a plecs file as long as the 
 // component is described with reflection data. Since we don't have a component
@@ -18,23 +18,23 @@ using flecs.meta
 // We can now create a struct like this. "Struct Position" is the shorthand
 // declaration syntax for "Position :- Struct", and has as benefit that we can
 // open a scope after the statement
-Struct Position {
+struct Position {
   // Add two child entities with the Member component
-  x :- Member{type: f32}
-  y :- Member{type: f32}
+  x { member: {type: f32} }
+  y { member: {type: f32} }
 }
 
 // Plecs has a feature which makes it possible to specify a default type for a
 // scope. The Struct component has Member as default type. This means we can
 // also create a type like this, which is a bit shorter:
-Struct Mass {
-  value :- {f32} // 'type' can be ommitted since it's the first member
+struct Mass {
+  value : f32 // 'type' can be ommitted since it's the first member
 }
 
 // Similarly we can also define an enumeration type. The default scope type for
 // Enum is Constant, which ensures amongst others that the child entities will
 // be assigned with an incremenenting constant value automatically.
-Enum Color {
+enum Color {
   Red
   Green
   Blue
diff --git a/examples/plecs/strings.flecs b/examples/script/strings.flecs
similarity index 84%
rename from examples/plecs/strings.flecs
rename to examples/script/strings.flecs
index aea4b147f..5679905e0 100644
--- a/examples/plecs/strings.flecs
+++ b/examples/script/strings.flecs
@@ -1,15 +1,15 @@
 // To see what the result of parsing this file looks like, copy the code and
 // paste it into the editor at https://flecs.dev/explorer
 //
-// To load this file yourself, call ecs_plecs_from_file("strings.flecs");
+// To load this file yourself, call ecs_script_run_file("strings.flecs");
 
 // Plecs component values can be populated with strings. To see how this works,
 // we first need to create a component type (see reflection example).
 using flecs.meta
 
-Struct Shader {
-  filename :- {string}
-  code :- {string}
+struct Shader {
+  filename : string
+  code : string
 }
 
 // Create component values with strings
diff --git a/examples/plecs/with.flecs b/examples/script/with.flecs
similarity index 92%
rename from examples/plecs/with.flecs
rename to examples/script/with.flecs
index b40e368e6..4b2b4780f 100644
--- a/examples/plecs/with.flecs
+++ b/examples/script/with.flecs
@@ -1,7 +1,7 @@
 // To see what the result of parsing this file looks like, copy the code and
 // paste it into the editor at https://flecs.dev/explorer
 //
-// To load this file yourself, call ecs_plecs_from_file("with.flecs");
+// To load this file yourself, call ecs_script_run_file("with.flecs");
 
 // Sometimes you want to add the same component to a lot of entities. To avoid
 // repeating yourself, you can use the "with" keyword:
diff --git a/flecs.c b/flecs.c
index 12608dcf6..2af28ca35 100644
--- a/flecs.c
+++ b/flecs.c
@@ -202,90 +202,6 @@ void flecs_entity_index_restore(
 
 #endif
 
-/**
- * @file datastructures/stack_allocator.h
- * @brief Stack allocator.
- */
-
-#ifndef FLECS_STACK_ALLOCATOR_H
-#define FLECS_STACK_ALLOCATOR_H
-
-/** Stack allocator for quick allocation of small temporary values */
-#define ECS_STACK_PAGE_SIZE (4096)
-
-typedef struct ecs_stack_page_t {
-    void *data;
-    struct ecs_stack_page_t *next;
-    int16_t sp;
-    uint32_t id;
-} ecs_stack_page_t;
-
-typedef struct ecs_stack_t {
-    ecs_stack_page_t first;
-    ecs_stack_page_t *tail_page;
-    ecs_stack_cursor_t *tail_cursor;
-#ifdef FLECS_DEBUG
-    int32_t cursor_count;
-#endif
-} ecs_stack_t;
-
-FLECS_DBG_API
-void flecs_stack_init(
-    ecs_stack_t *stack);
-
-FLECS_DBG_API
-void flecs_stack_fini(
-    ecs_stack_t *stack);
-
-FLECS_DBG_API
-void* flecs_stack_alloc(
-    ecs_stack_t *stack, 
-    ecs_size_t size,
-    ecs_size_t align);
-
-#define flecs_stack_alloc_t(stack, T)\
-    flecs_stack_alloc(stack, ECS_SIZEOF(T), ECS_ALIGNOF(T))
-
-#define flecs_stack_alloc_n(stack, T, count)\
-    flecs_stack_alloc(stack, ECS_SIZEOF(T) * count, ECS_ALIGNOF(T))
-
-FLECS_DBG_API
-void* flecs_stack_calloc(
-    ecs_stack_t *stack, 
-    ecs_size_t size,
-    ecs_size_t align);
-
-#define flecs_stack_calloc_t(stack, T)\
-    flecs_stack_calloc(stack, ECS_SIZEOF(T), ECS_ALIGNOF(T))
-
-#define flecs_stack_calloc_n(stack, T, count)\
-    flecs_stack_calloc(stack, ECS_SIZEOF(T) * count, ECS_ALIGNOF(T))
-
-FLECS_DBG_API
-void flecs_stack_free(
-    void *ptr,
-    ecs_size_t size);
-
-#define flecs_stack_free_t(ptr, T)\
-    flecs_stack_free(ptr, ECS_SIZEOF(T))
-
-#define flecs_stack_free_n(ptr, T, count)\
-    flecs_stack_free(ptr, ECS_SIZEOF(T) * count)
-
-void flecs_stack_reset(
-    ecs_stack_t *stack);
-
-FLECS_DBG_API
-ecs_stack_cursor_t* flecs_stack_get_cursor(
-    ecs_stack_t *stack);
-
-FLECS_DBG_API
-void flecs_stack_restore_cursor(
-    ecs_stack_t *stack,
-    ecs_stack_cursor_t *cursor);
-
-#endif
-
 /**
  * @file bitset.h
  * @brief Bitset data structure.
@@ -364,135 +280,6 @@ void flecs_bitset_swap(
 
 #endif
 
-/**
- * @file switch_list.h
- * @brief Interleaved linked list for storing mutually exclusive values.
- */
-
-#ifndef FLECS_SWITCH_LIST_H
-#define FLECS_SWITCH_LIST_H
-
-
-typedef struct ecs_switch_header_t {
-    int32_t element;    /* First element for value */
-    int32_t count;      /* Number of elements for value */
-} ecs_switch_header_t;
-
-typedef struct ecs_switch_node_t {
-    int32_t next;       /* Next node in list */
-    int32_t prev;       /* Prev node in list */
-} ecs_switch_node_t;
-
-struct ecs_switch_t {    
-    ecs_map_t hdrs;     /* map<uint64_t, ecs_switch_header_t> */
-    ecs_vec_t nodes;    /* vec<ecs_switch_node_t> */
-    ecs_vec_t values;   /* vec<uint64_t> */
-};
-
-/** Init new switch. */
-FLECS_DBG_API
-void flecs_switch_init(
-    ecs_switch_t* sw,
-    ecs_allocator_t *allocator,
-    int32_t elements);
-
-/** Fini switch. */
-FLECS_DBG_API
-void flecs_switch_fini(
-    ecs_switch_t *sw);
-
-/** Remove all values. */
-FLECS_DBG_API
-void flecs_switch_clear(
-    ecs_switch_t *sw);
-
-/** Add element to switch, initialize value to 0 */
-FLECS_DBG_API
-void flecs_switch_add(
-    ecs_switch_t *sw);
-
-/** Set number of elements in switch list */
-FLECS_DBG_API
-void flecs_switch_set_count(
-    ecs_switch_t *sw,
-    int32_t count);
-
-/** Get number of elements */
-FLECS_DBG_API
-int32_t flecs_switch_count(
-    ecs_switch_t *sw);
-
-/** Ensure that element exists. */
-FLECS_DBG_API
-void flecs_switch_ensure(
-    ecs_switch_t *sw,
-    int32_t count);
-
-/** Add n elements. */
-FLECS_DBG_API
-void flecs_switch_addn(
-    ecs_switch_t *sw,
-    int32_t count);    
-
-/** Set value of element. */
-FLECS_DBG_API
-void flecs_switch_set(
-    ecs_switch_t *sw,
-    int32_t element,
-    uint64_t value);
-
-/** Remove element. */
-FLECS_DBG_API
-void flecs_switch_remove(
-    ecs_switch_t *sw,
-    int32_t element);
-
-/** Get value for element. */
-FLECS_DBG_API
-uint64_t flecs_switch_get(
-    const ecs_switch_t *sw,
-    int32_t element);
-
-/** Swap element. */
-FLECS_DBG_API
-void flecs_switch_swap(
-    ecs_switch_t *sw,
-    int32_t elem_1,
-    int32_t elem_2);
-
-/** Get vector with all values. Use together with count(). */
-FLECS_DBG_API
-ecs_vec_t* flecs_switch_values(
-    const ecs_switch_t *sw);    
-
-/** Return number of different values. */
-FLECS_DBG_API
-int32_t flecs_switch_case_count(
-    const ecs_switch_t *sw,
-    uint64_t value);
-
-/** Return first element for value. */
-FLECS_DBG_API
-int32_t flecs_switch_first(
-    const ecs_switch_t *sw,
-    uint64_t value);
-
-/** Return next element for value. Use with first(). */
-FLECS_DBG_API
-int32_t flecs_switch_next(
-    const ecs_switch_t *sw,
-    int32_t elem);
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
 /**
  * @file table.h
  * @brief Table storage implementation.
@@ -616,9 +403,6 @@ typedef enum ecs_table_eventkind_t {
 typedef struct ecs_table_event_t {
     ecs_table_eventkind_t kind;
 
-    /* Query event */
-    ecs_query_t *query;
-
     /* Component info event */
     ecs_entity_t component;
 
@@ -641,10 +425,7 @@ typedef struct ecs_table__t {
     struct ecs_table_record_t *records; /* Array with table records */
     ecs_hashmap_t *name_index;       /* Cached pointer to name index */
 
-    ecs_switch_t *sw_columns;        /* Switch columns */
     ecs_bitset_t *bs_columns;        /* Bitset columns */
-    int16_t sw_count;
-    int16_t sw_offset;
     int16_t bs_count;
     int16_t bs_offset;
     int16_t ft_offset;
@@ -727,12 +508,6 @@ void flecs_table_clear_entities_silent(
     ecs_world_t *world,
     ecs_table_t *table);
 
-/* Clear table data. Don't call OnRemove handlers. */
-void flecs_table_clear_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data);    
-
 /* Return number of entities in data */
 int32_t flecs_table_data_count(
     const ecs_data_t *data);
@@ -803,7 +578,7 @@ void flecs_table_remove_actions(
     ecs_table_t *table);
 
 /* Free table */
-void flecs_table_free(
+void flecs_table_fini(
     ecs_world_t *world,
     ecs_table_t *table); 
 
@@ -811,20 +586,12 @@ void flecs_table_free(
 void flecs_table_free_type(
     ecs_world_t *world,
     ecs_table_t *table);     
-    
-/* Replace data */
-void flecs_table_replace_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data);
 
 /* Merge data of one table into another table */
 void flecs_table_merge(
     ecs_world_t *world,
     ecs_table_t *new_table,
-    ecs_table_t *old_table,
-    ecs_data_t *new_data,
-    ecs_data_t *old_data);
+    ecs_table_t *old_table);
 
 void flecs_table_swap(
     ecs_world_t *world,
@@ -846,10 +613,6 @@ void flecs_table_delete_entities(
     ecs_world_t *world,
     ecs_table_t *table);
 
-int32_t flecs_table_column_to_union_index(
-    const ecs_table_t *table,
-    int32_t column);
-
 /* Increase observer count of table */
 void flecs_table_traversable_add(
     ecs_table_t *table,
@@ -861,6 +624,19 @@ ecs_vec_t* flecs_table_entities(
 ecs_entity_t* flecs_table_entities_array(
     ecs_table_t *table);
 
+void flecs_table_emit(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_entity_t event);
+
+int32_t flecs_table_get_toggle_column(
+    ecs_table_t *table,
+    ecs_id_t id);
+
+ecs_bitset_t* flecs_table_get_toggle(
+    ecs_table_t *table,
+    ecs_id_t id);
+
 #endif
 
 
@@ -877,9 +653,6 @@ extern const ecs_entity_t EcsFlag;
 #define ecs_world_t_tag     invalid
 #define ecs_stage_t_tag     invalid
 #define ecs_query_t_tag     EcsQuery
-#define ecs_rule_t_tag      EcsQuery
-#define ecs_table_t_tag     invalid
-#define ecs_filter_t_tag    EcsQuery
 #define ecs_observer_t_tag  EcsObserver
 
 /* Mixin kinds */
@@ -887,7 +660,6 @@ typedef enum ecs_mixin_kind_t {
     EcsMixinWorld,
     EcsMixinEntity,
     EcsMixinObservable,
-    EcsMixinIterable,
     EcsMixinDtor,
     EcsMixinMax
 } ecs_mixin_kind_t;
@@ -904,9 +676,7 @@ struct ecs_mixins_t {
 /* Mixin tables */
 extern ecs_mixins_t ecs_world_t_mixins;
 extern ecs_mixins_t ecs_stage_t_mixins;
-extern ecs_mixins_t ecs_filter_t_mixins;
 extern ecs_mixins_t ecs_query_t_mixins;
-extern ecs_mixins_t ecs_trigger_t_mixins;
 extern ecs_mixins_t ecs_observer_t_mixins;
 
 /* Types that have no mixins */
@@ -944,194 +714,6 @@ typedef struct ecs_table_cache_t {
     ecs_table_cache_list_t empty_tables;
 } ecs_table_cache_t;
 
-/* Sparse query term */
-typedef struct flecs_switch_term_t {
-    ecs_switch_t *sw_column;
-    ecs_entity_t sw_case; 
-    int32_t signature_column_index;
-} flecs_switch_term_t;
-
-/* Bitset query term */
-typedef struct flecs_bitset_term_t {
-    ecs_bitset_t *bs_column;
-    int32_t column_index;
-} flecs_bitset_term_t;
-
-typedef struct flecs_flat_monitor_t {
-    int32_t table_state;
-    int32_t monitor;
-} flecs_flat_monitor_t;
-
-/* Flat table term */
-typedef struct flecs_flat_table_term_t {
-    int32_t field_index; /* Iterator field index */
-    ecs_term_t *term;
-    ecs_vec_t monitor;
-} flecs_flat_table_term_t;
-
-/* Entity filter. This filters the entities of a matched table, for example when
- * it has disabled components or union relationships (switch). */
-typedef struct ecs_entity_filter_t {
-    ecs_vec_t sw_terms;              /* Terms with switch (union) entity filter */
-    ecs_vec_t bs_terms;              /* Terms with bitset (toggle) entity filter */
-    ecs_vec_t ft_terms;              /* Terms with components from flattened tree */
-    int32_t flat_tree_column;
-} ecs_entity_filter_t;
-
-typedef struct ecs_entity_filter_iter_t {
-    ecs_entity_filter_t *entity_filter;
-    ecs_iter_t *it;
-    int32_t *columns;
-    ecs_table_t *prev;
-    ecs_table_range_t range;
-    int32_t bs_offset;
-    int32_t sw_offset;
-    int32_t sw_smallest;
-    int32_t flat_tree_offset;
-    int32_t target_count;
-} ecs_entity_filter_iter_t;
-
-/** Table match data.
- * Each table matched by the query is represented by a ecs_query_table_match_t
- * instance, which are linked together in a list. A table may match a query
- * multiple times (due to wildcard queries) with different columns being matched
- * by the query. */
-struct ecs_query_table_match_t {
-    ecs_query_table_match_t *next, *prev;
-    ecs_table_t *table;              /* The current table. */
-    int32_t offset;                  /* Starting point in table  */
-    int32_t count;                   /* Number of entities to iterate in table */
-    int32_t *columns;                /* Mapping from query fields to table columns */
-    int32_t *storage_columns;        /* Mapping from query fields to storage columns */
-    ecs_id_t *ids;                   /* Resolved (component) ids for current table */
-    ecs_entity_t *sources;           /* Subjects (sources) of ids */
-    ecs_vec_t refs;                  /* Cached components for non-this terms */
-    uint64_t group_id;               /* Value used to organize tables in groups */
-    int32_t *monitor;                /* Used to monitor table for changes */
-    ecs_entity_filter_t *entity_filter; /* Entity specific filters */
-
-    /* Next match in cache for same table (includes empty tables) */
-    ecs_query_table_match_t *next_match;
-};
-
-/** Table record type for query table cache. A query only has one per table. */
-typedef struct ecs_query_table_t {
-    ecs_table_cache_hdr_t hdr;       /* Header for ecs_table_cache_t */
-    ecs_query_table_match_t *first;  /* List with matches for table */
-    ecs_query_table_match_t *last;   /* Last discovered match for table */
-    uint64_t table_id;
-    int32_t rematch_count;           /* Track whether table was rematched */
-} ecs_query_table_t;
-
-/** Points to the beginning & ending of a query group */
-typedef struct ecs_query_table_list_t {
-    ecs_query_table_match_t *first;
-    ecs_query_table_match_t *last;
-    ecs_query_group_info_t info;
-} ecs_query_table_list_t;
-
-/* Query event type for notifying queries of world events */
-typedef enum ecs_query_eventkind_t {
-    EcsQueryTableMatch,
-    EcsQueryTableRematch,
-    EcsQueryTableUnmatch,
-    EcsQueryOrphan
-} ecs_query_eventkind_t;
-
-typedef struct ecs_query_event_t {
-    ecs_query_eventkind_t kind;
-    ecs_table_t *table;
-    ecs_query_t *parent_query;
-} ecs_query_event_t;
-
-/* Query level block allocators have sizes that depend on query field count */
-typedef struct ecs_query_allocators_t {
-    ecs_block_allocator_t columns;
-    ecs_block_allocator_t ids;
-    ecs_block_allocator_t sources;
-    ecs_block_allocator_t monitors;
-} ecs_query_allocators_t;
-
-/** Query that is automatically matched against tables */
-struct ecs_query_t {
-    ecs_header_t hdr;
-
-    /* Query filter */
-    ecs_filter_t filter;
-
-    /* Tables matched with query */
-    ecs_table_cache_t cache;
-
-    /* Linked list with all matched non-empty tables, in iteration order */
-    ecs_query_table_list_t list;
-
-    /* Contains head/tail to nodes of query groups (if group_by is used) */
-    ecs_map_t groups;
-
-    /* Table sorting */
-    ecs_entity_t order_by_component;
-    ecs_order_by_action_t order_by;
-    ecs_sort_table_action_t sort_table;
-    ecs_vec_t table_slices;
-    int32_t order_by_term;
-
-    /* Table grouping */
-    ecs_entity_t group_by_id;
-    ecs_group_by_action_t group_by;
-    ecs_group_create_action_t on_group_create;
-    ecs_group_delete_action_t on_group_delete;
-    void *group_by_ctx;
-    ecs_ctx_free_t group_by_ctx_free;
-
-    /* Subqueries */
-    ecs_query_t *parent;
-    ecs_vec_t subqueries;
-
-    /* Flags for query properties */
-    ecs_flags32_t flags;
-
-    /* Monitor generation */
-    int32_t monitor_generation;
-
-    int32_t cascade_by;              /* Identify cascade term */
-    int32_t match_count;             /* How often have tables been (un)matched */
-    int32_t prev_match_count;        /* Track if sorting is needed */
-    int32_t rematch_count;           /* Track which tables were added during rematch */
-
-    /* User context */
-    void *ctx;                       /* User context to pass to callback */
-    void *binding_ctx;               /* Context to be used for language bindings */
-     
-    ecs_ctx_free_t ctx_free;         /** Callback to free ctx */
-    ecs_ctx_free_t binding_ctx_free; /** Callback to free binding_ctx */
-
-    /* Mixins */
-    ecs_iterable_t iterable;
-    ecs_poly_dtor_t dtor;
-
-    /* Query-level allocators */
-    ecs_query_allocators_t allocators;
-};
-
-/** All observers for a specific (component) id */
-typedef struct ecs_event_id_record_t {
-    /* Triggers for Self */
-    ecs_map_t self;                  /* map<trigger_id, trigger_t> */
-    ecs_map_t self_up;               /* map<trigger_id, trigger_t> */
-    ecs_map_t up;                    /* map<trigger_id, trigger_t> */
-
-    ecs_map_t observers;             /* map<trigger_id, trigger_t> */
-
-    /* Triggers for SuperSet, SubSet */
-    ecs_map_t set_observers;         /* map<trigger_id, trigger_t> */
-
-    /* Triggers for Self with non-This subject */
-    ecs_map_t entity_observers;      /* map<trigger_id, trigger_t> */
-
-    /* Number of active observers for (component) id */
-    int32_t observer_count;
-} ecs_event_id_record_t;
-
 /* World level allocators are for operations that are not multithreaded */
 typedef struct ecs_world_allocators_t {
     ecs_map_params_t ptr;
@@ -1155,6 +737,8 @@ typedef struct ecs_stage_allocators_t {
     ecs_stack_t iter_stack;
     ecs_stack_t deser_stack;
     ecs_block_allocator_t cmd_entry_chunk;
+    ecs_block_allocator_t query_impl;
+    ecs_block_allocator_t query_cache;
 } ecs_stage_allocators_t;
 
 /** Types for deferred operations */
@@ -1228,7 +812,13 @@ typedef void (*ecs_on_commands_action_t)(
 /** A stage is a context that allows for safely using the API from multiple 
  * threads. Stage pointers can be passed to the world argument of API 
  * operations, which causes the operation to be ran on the stage instead of the
- * world. */
+ * world. The features provided by a stage are:
+ * 
+ *  - A command queue for deferred ECS operations and events
+ *  - Thread specific allocators
+ *  - Thread specific world state (like current scope, with, current system)
+ *  - Thread specific buffers for preventing allocations
+ */
 struct ecs_stage_t {
     ecs_header_t hdr;
 
@@ -1260,22 +850,23 @@ struct ecs_stage_t {
     /* Running system */
     ecs_entity_t system;
 
-    /* Properties */
-    bool auto_merge;                 /* Should this stage automatically merge? */
-    bool async;                      /* Is stage asynchronous? (write only) */
-
     /* Thread specific allocators */
     ecs_stage_allocators_t allocators;
     ecs_allocator_t allocator;
 
-    /* Caches for rule creation */
+    /* Caches for query creation */
     ecs_vec_t variables;
     ecs_vec_t operations;
+
+    /* Temporary token storage for DSL parser. This allows for parsing and 
+     * interpreting a term without having to do allocations. */
+    char parser_tokens[1024];
+    char *parser_token; /* Pointer to next token */
 };
 
 /* Component monitor */
 typedef struct ecs_monitor_t {
-    ecs_vec_t queries;               /* vector<ecs_query_t*> */
+    ecs_vec_t queries;               /* vector<ecs_query_cache_t*> */
     bool is_dirty;                   /* Should queries be rematched? */
 } ecs_monitor_t;
 
@@ -1297,7 +888,7 @@ typedef struct ecs_store_t {
     /* Entity lookup */
     ecs_entity_index_t entity_index;
 
-    /* Table lookup by id */
+    /* Tables */
     ecs_sparse_t tables;             /* sparse<table_id, ecs_table_t> */
 
     /* Table lookup by hash */
@@ -1306,6 +897,9 @@ typedef struct ecs_store_t {
     /* Root table */
     ecs_table_t root;
 
+    /* Observers */
+    ecs_sparse_t observers;          /* sparse<table_id, ecs_table_t> */
+
     /* Records cache */
     ecs_vec_t records;
 
@@ -1347,7 +941,6 @@ struct ecs_world_t {
     /* -- Mixins -- */
     ecs_world_t *self;
     ecs_observable_t observable;
-    ecs_iterable_t iterable;
 
     /* Unique id per generated event used to prevent duplicate notifications */
     int32_t event_id;
@@ -1373,7 +966,7 @@ struct ecs_world_t {
     ecs_hashmap_t symbols;
 
     /* -- Staging -- */
-    ecs_stage_t *stages;             /* Stages */
+    ecs_stage_t **stages;            /* Stages */
     int32_t stage_count;             /* Number of stages */
 
     /* Internal callback for command inspection. Only one callback can be set at
@@ -1467,6 +1060,7 @@ bool ecs_table_cache_is_empty(
 
 #define flecs_table_cache_count(cache) (cache)->tables.count
 #define flecs_table_cache_empty_count(cache) (cache)->empty_tables.count
+#define flecs_table_cache_all_count(cache) ((cache)->tables.count + (cache)->empty_tables.count)
 
 bool flecs_table_cache_iter(
     ecs_table_cache_t *cache,
@@ -1568,13 +1162,6 @@ ecs_id_record_t* flecs_id_record_get(
     const ecs_world_t *world,
     ecs_id_t id);
 
-/* Get id record for id for searching.
- * Same as flecs_id_record_get, but replaces (R, *) with (Union, R) if R is a
- * union relationship. */
-ecs_id_record_t* flecs_query_id_record_get(
-    const ecs_world_t *world,
-    ecs_id_t id);
-
 /* Ensure id record for id */
 ecs_id_record_t* flecs_id_record_ensure(
     ecs_world_t *world,
@@ -1636,219 +1223,1160 @@ void flecs_fini_id_records(
 
 #endif
 
-/**
- * @file observable.h
- * @brief Functions for sending events.
+ /**
+ * @file query/query.h
+ * @brief Query implementation.
  */
 
-#ifndef FLECS_OBSERVABLE_H
-#define FLECS_OBSERVABLE_H
+/**
+ * @file query/compiler.h
+ * @brief Query compiler functions.
+ */
 
-ecs_event_record_t* flecs_event_record_get(
-    const ecs_observable_t *o,
-    ecs_entity_t event);
+ /**
+ * @file query/types.h
+ * @brief Internal types and functions for queries.
+ */
 
-ecs_event_record_t* flecs_event_record_ensure(
-    ecs_observable_t *o,
-    ecs_entity_t event);
+#ifndef FLECS_QUERY_TYPES
+#define FLECS_QUERY_TYPES
 
-ecs_event_id_record_t* flecs_event_id_record_get(
-    const ecs_event_record_t *er,
-    ecs_id_t id);
+typedef struct ecs_query_impl_t ecs_query_impl_t;
+typedef uint8_t ecs_var_id_t;
+typedef int16_t ecs_query_lbl_t;
+typedef ecs_flags64_t ecs_write_flags_t;
 
-ecs_event_id_record_t* flecs_event_id_record_ensure(
-    ecs_world_t *world,
-    ecs_event_record_t *er,
-    ecs_id_t id);
+#define flecs_query_impl(query) (ECS_CONST_CAST(ecs_query_impl_t*, query))
 
-void flecs_event_id_record_remove(
-    ecs_event_record_t *er,
-    ecs_id_t id);
+#define EcsQueryMaxVarCount     (64)
+#define EcsVarNone              ((ecs_var_id_t)-1)
+#define EcsThisName             "this"
 
-void flecs_observable_init(
-    ecs_observable_t *observable);
+/* -- Variable types -- */
+typedef enum {
+    EcsVarEntity,          /* Variable that stores an entity id */
+    EcsVarTable,           /* Variable that stores a table */
+    EcsVarAny              /* Used when requesting either entity or table var */
+} ecs_var_kind_t;
 
-void flecs_observable_fini(
-    ecs_observable_t *observable);
+typedef struct ecs_query_var_t {
+    int8_t kind;           /* variable kind (EcsVarEntity or EcsVarTable) */
+    bool anonymous;        /* variable is anonymous */
+    ecs_var_id_t id;       /* variable id */
+    ecs_var_id_t table_id; /* id to table variable, if any */
+    ecs_var_id_t base_id;  /* id to base entity variable, for lookups */
+    const char *name;      /* variable name */
+    const char *lookup;    /* Lookup string for variable */
+#ifdef FLECS_DEBUG
+    const char *label;     /* for debugging */
+#endif
+} ecs_query_var_t;
 
-bool flecs_observers_exist(
-    ecs_observable_t *observable,
-    ecs_id_t id,
-    ecs_entity_t event);
+/* -- Instruction kinds -- */
+typedef enum {
+    EcsQueryAnd,            /* And operator: find or match id against variable source */
+    EcsQueryAndId,          /* And operator for fixed id (no wildcards/variables) */
+    EcsQueryAndAny,         /* And operator with support for matching Any src/id */
+    EcsQuerySelectAny,      /* Dedicated instruction for _ queries where the src is unknown */
+    EcsQueryTriv,           /* Trivial search (batches multiple terms) */
+    EcsQueryTrivData,       /* Trivial search with setting data fields */
+    EcsQueryTrivWildcard,   /* Trivial search with (exclusive) wildcard ids */
+    EcsQueryCache,          /* Cached search */
+    EcsQueryCacheData,      /* Cached search with setting data fields */
+    EcsQueryIsCache,        /* Cached search for queries that are entirely cached */
+    EcsQueryIsCacheData,    /* Same as EcsQueryIsCache with data fields */
+    EcsQueryUp,             /* Up traversal */
+    EcsQueryUpId,           /* Up traversal for fixed id (like AndId) */
+    EcsQuerySelfUp,         /* Self|up traversal */
+    EcsQuerySelfUpId,       /* Self|up traversal for fixed id (like AndId) */
+    EcsQueryWith,           /* Match id against fixed or variable source */
+    EcsQueryTrav,           /* Support for transitive/reflexive queries */
+    EcsQueryAndFrom,        /* AndFrom operator */
+    EcsQueryOrFrom,         /* OrFrom operator */
+    EcsQueryNotFrom,        /* NotFrom operator */
+    EcsQueryIds,            /* Test for existence of ids matching wildcard */
+    EcsQueryIdsRight,       /* Find ids in use that match (R, *) wildcard */
+    EcsQueryIdsLeft,        /* Find ids in use that match (*, T) wildcard */
+    EcsQueryEach,           /* Iterate entities in table, populate entity variable */
+    EcsQueryStore,          /* Store table or entity in variable */
+    EcsQueryReset,          /* Reset value of variable to wildcard (*) */
+    EcsQueryOr,             /* Or operator */
+    EcsQueryOptional,       /* Optional operator */
+    EcsQueryIfVar,          /* Conditional execution on whether variable is set */
+    EcsQueryIfSet,          /* Conditional execution on whether term is set */
+    EcsQueryNot,            /* Sets iterator state after term was not matched */
+    EcsQueryEnd,            /* End of control flow block */
+    EcsQueryPredEq,         /* Test if variable is equal to, or assign to if not set */
+    EcsQueryPredNeq,        /* Test if variable is not equal to */
+    EcsQueryPredEqName,     /* Same as EcsQueryPredEq but with matching by name */
+    EcsQueryPredNeqName,    /* Same as EcsQueryPredNeq but with matching by name */
+    EcsQueryPredEqMatch,    /* Same as EcsQueryPredEq but with fuzzy matching by name */
+    EcsQueryPredNeqMatch,   /* Same as EcsQueryPredNeq but with fuzzy matching by name */
+    EcsQueryMemberEq,       /* Compare member value */
+    EcsQueryMemberNeq,      /* Compare member value */
+    EcsQueryToggle,         /* Evaluate toggle bitset, if present */
+    EcsQueryToggleOption,   /* Toggle for optional terms */
+    EcsQueryLookup,         /* Lookup relative to variable */
+    EcsQuerySetVars,        /* Populate it.sources from variables */
+    EcsQuerySetThis,        /* Populate This entity variable */
+    EcsQuerySetFixed,       /* Set fixed source entity ids */
+    EcsQuerySetIds,         /* Set fixed (component) ids */
+    EcsQuerySetId,          /* Set id if not set */
+    EcsQueryContain,        /* Test if table contains entity */
+    EcsQueryPairEq,         /* Test if both elements of pair are the same */
+    EcsQueryPopulate,       /* Populate any data fields */
+    EcsQueryPopulateSelf,   /* Populate only self (owned) data fields */
+    EcsQueryYield,          /* Yield result back to application */
+    EcsQueryNothing         /* Must be last */
+} ecs_query_op_kind_t;
+
+/* Op flags to indicate if ecs_query_ref_t is entity or variable */
+#define EcsQueryIsEntity  (1 << 0)
+#define EcsQueryIsVar     (1 << 1)
+#define EcsQueryIsSelf    (1 << 6)
+
+/* Op flags used to shift EcsQueryIsEntity and EcsQueryIsVar */
+#define EcsQuerySrc     0
+#define EcsQueryFirst   2
+#define EcsQuerySecond  4
 
-void flecs_observer_fini(
-    ecs_observer_t *observer);
+/* References to variable or entity */
+typedef union {
+    ecs_var_id_t var;
+    ecs_entity_t entity;
+} ecs_query_ref_t;
 
-void flecs_emit( 
-    ecs_world_t *world,
-    ecs_world_t *stage,
-    ecs_event_desc_t *desc);
+/* Query instruction */
+typedef struct ecs_query_op_t {
+    uint8_t kind;              /* Instruction kind */
+    ecs_flags8_t flags;        /* Flags storing whether 1st/2nd are variables */
+    int8_t field_index;        /* Query field corresponding with operation */
+    int8_t term_index;         /* Query term corresponding with operation */
+    ecs_query_lbl_t prev;      /* Backtracking label (no data) */
+    ecs_query_lbl_t next;      /* Forwarding label. Must come after prev */
+    ecs_query_lbl_t other;     /* Misc register used for control flow */
+    ecs_flags16_t match_flags; /* Flags that modify matching behavior */
+    ecs_query_ref_t src;
+    ecs_query_ref_t first;
+    ecs_query_ref_t second;
+    ecs_flags64_t written;     /* Bitset with variables written by op */
+} ecs_query_op_t;
 
-bool flecs_default_observer_next_callback(
-    ecs_iter_t *it);
+ /* And context */
+typedef struct {
+    ecs_id_record_t *idr;
+    ecs_table_cache_iter_t it;
+    int16_t column;
+    int16_t remaining;
+} ecs_query_and_ctx_t;
 
-void flecs_observers_invoke(
-    ecs_world_t *world,
-    ecs_map_t *observers,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_entity_t trav);
+/* Down traversal cache (for resolving up queries w/unknown source) */
+typedef struct {
+    ecs_table_t *table;
+    bool leaf; /* Table owns and inherits id (for Up queries without Self) */
+} ecs_trav_down_elem_t;
 
-void flecs_emit_propagate_invalidate(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    int32_t offset,
-    int32_t count);
+typedef struct {
+    ecs_vec_t elems;      /* vector<ecs_trav_down_elem_t> */
+    bool ready;
+} ecs_trav_down_t;
 
-#endif
+typedef struct {
+    ecs_entity_t src;
+    ecs_id_t id;
+    int32_t column;
+    bool ready;
+} ecs_trav_up_t;
 
-/**
- * @file iter.h
- * @brief Iterator utilities.
- */
+typedef enum {
+    EcsTravUp = 1,
+    EcsTravDown = 2
+} ecs_trav_direction_t;
 
-#ifndef FLECS_ITER_H
-#define FLECS_ITER_H
+typedef struct {
+    ecs_map_t src;        /* map<entity, trav_down_t> or map<table_id, trav_up_t> */
+    ecs_id_t with;
+    ecs_trav_direction_t dir;
+} ecs_trav_up_cache_t;
 
-void flecs_iter_init(
-    const ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_flags8_t fields);
+/* And up context */
+typedef struct {
+    ecs_query_and_ctx_t and;
+    ecs_table_t *table;
+    int32_t row;
+    int32_t end;
+    ecs_entity_t trav;
+    ecs_id_t with;
+    ecs_id_t matched;
+    ecs_id_record_t *idr_with;
+    ecs_id_record_t *idr_trav;
+    ecs_trav_down_t *down;
+    int32_t cache_elem;
+    ecs_trav_up_cache_t cache;
+} ecs_query_up_ctx_t;
 
-void flecs_iter_validate(
-    ecs_iter_t *it);
+/* Cache for storing results of upward/downward "all" traversal. This type of 
+ * traversal iterates and caches the entire tree. */
+typedef struct {
+    ecs_entity_t entity;
+    ecs_id_record_t *idr;
+    int32_t column;
+} ecs_trav_elem_t;
 
-void flecs_iter_populate_data(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    int32_t offset,
-    int32_t count,
-    void **ptrs);
+typedef struct {
+    ecs_id_t id;
+    ecs_id_record_t *idr;
+    ecs_vec_t entities;
+    bool up;
+} ecs_trav_cache_t;
 
-bool flecs_iter_next_row(
-    ecs_iter_t *it);
+/* Trav context */
+typedef struct {
+    ecs_query_and_ctx_t and;
+    int32_t index;
+    int32_t offset;
+    int32_t count;
+    ecs_trav_cache_t cache;
+    bool yield_reflexive;
+} ecs_query_trav_ctx_t;
 
-bool flecs_iter_next_instanced(
-    ecs_iter_t *it,
-    bool result);
+ /* Eq context */
+typedef struct {
+    ecs_table_range_t range;
+    int32_t index;
+    int16_t name_col;
+    bool redo;
+} ecs_query_eq_ctx_t;
 
-void* flecs_iter_calloc(
-    ecs_iter_t *it,
-    ecs_size_t size,
-    ecs_size_t align);
+ /* Each context */
+typedef struct {
+    int32_t row;
+} ecs_query_each_ctx_t;
 
-#define flecs_iter_calloc_t(it, T)\
-    flecs_iter_calloc(it, ECS_SIZEOF(T), ECS_ALIGNOF(T))
+ /* Setthis context */
+typedef struct {
+    ecs_table_range_t range;
+} ecs_query_setthis_ctx_t;
 
-#define flecs_iter_calloc_n(it, T, count)\
-    flecs_iter_calloc(it, ECS_SIZEOF(T) * count, ECS_ALIGNOF(T))
+/* Ids context */
+typedef struct {
+    ecs_id_record_t *cur;
+} ecs_query_ids_ctx_t;
 
-void flecs_iter_free(
-    void *ptr,
-    ecs_size_t size);
+/* Control flow context */
+typedef struct {
+    ecs_query_lbl_t op_index;
+    ecs_id_t field_id;
+    bool is_set;
+} ecs_query_ctrl_ctx_t;
 
-#define flecs_iter_free_t(ptr, T)\
-    flecs_iter_free(ptr, ECS_SIZEOF(T))
+/* Trivial iterator context */
+typedef struct {
+    ecs_table_cache_iter_t it;
+    const ecs_table_record_t *tr;
+    int32_t first_to_eval;
+} ecs_query_trivial_ctx_t;
 
-#define flecs_iter_free_n(ptr, T, count)\
-    flecs_iter_free(ptr, ECS_SIZEOF(T) * count)
+/* *From operator iterator context */
+typedef struct {
+    ecs_query_and_ctx_t and;
+    ecs_type_t *type;
+    int32_t first_id_index;
+    int32_t cur_id_index;
+} ecs_query_xfrom_ctx_t;
 
-#endif
+/* Member equality context */
+typedef struct {
+    ecs_query_each_ctx_t each;
+    void *data;
+} ecs_query_membereq_ctx_t;
 
-/**
- * @file poly.h
- * @brief Functions for managing poly objects.
- */
+/* Toggle context */
+typedef struct {
+    ecs_table_range_t range;
+    int32_t cur;
+    int32_t block_index;
+    ecs_flags64_t block;
+    ecs_termset_t prev_set_fields;
+    bool optional_not;
+    bool has_bitset;
+} ecs_query_toggle_ctx_t;
+
+typedef struct ecs_query_op_ctx_t {
+    union {
+        ecs_query_and_ctx_t and;
+        ecs_query_xfrom_ctx_t xfrom;
+        ecs_query_up_ctx_t up;
+        ecs_query_trav_ctx_t trav;
+        ecs_query_ids_ctx_t ids;
+        ecs_query_eq_ctx_t eq;
+        ecs_query_each_ctx_t each;
+        ecs_query_setthis_ctx_t setthis;
+        ecs_query_ctrl_ctx_t ctrl;
+        ecs_query_trivial_ctx_t trivial;
+        ecs_query_membereq_ctx_t membereq;
+        ecs_query_toggle_ctx_t toggle;
+    } is;
+} ecs_query_op_ctx_t;
 
-#ifndef FLECS_POLY_H
-#define FLECS_POLY_H
+typedef struct {
+    /* Labels used for control flow */
+    ecs_query_lbl_t lbl_query; /* Used to find the op that does the actual searching */
+    ecs_query_lbl_t lbl_begin;
+    ecs_query_lbl_t lbl_cond_eval;
+    ecs_write_flags_t written_or; /* Cond written flags at start of or chain */
+    ecs_write_flags_t cond_written_or; /* Cond written flags at start of or chain */
+    ecs_query_ref_t src_or;  /* Source for terms in current or chain */
+    bool src_written_or; /* Was src populated before OR chain */
+    bool in_or; /* Whether we're in an or chain */
+} ecs_query_compile_ctrlflow_t;
 
-#include <stddef.h>
+/* Query compiler state */
+typedef struct {
+    ecs_vec_t *ops;
+    ecs_write_flags_t written; /* Bitmask to check which variables have been written */
+    ecs_write_flags_t cond_written; /* Track conditional writes (optional operators) */
 
-/* Initialize poly */
-void* ecs_poly_init_(
-    ecs_poly_t *object,
-    int32_t kind,
-    ecs_size_t size,
-    ecs_mixins_t *mixins);
+    /* Maintain control flow per scope */
+    ecs_query_compile_ctrlflow_t ctrlflow[FLECS_QUERY_SCOPE_NESTING_MAX];
+    ecs_query_compile_ctrlflow_t *cur; /* Current scope */
 
-#define ecs_poly_init(object, type)\
-    ecs_poly_init_(object, type##_magic, sizeof(type), &type##_mixins)
+    int32_t scope; /* Nesting level of query scopes */
+    ecs_flags32_t scope_is_not; /* Whether scope is prefixed with not */
+    ecs_oper_kind_t oper; /* Temp storage to track current operator for term */
+    int32_t skipped; /* Term skipped during compilation */
+} ecs_query_compile_ctx_t;    
 
-/* Deinitialize object for specified type */
-void ecs_poly_fini_(
-    ecs_poly_t *object,
-    int32_t kind);
+/* Query run state */
+typedef struct {
+    uint64_t *written;                 /* Bitset to check which variables have been written */
+    ecs_query_lbl_t op_index;          /* Currently evaluated operation */
+    ecs_var_t *vars;                   /* Variable storage */
+    ecs_iter_t *it;                    /* Iterator */
+    ecs_query_op_ctx_t *op_ctx;        /* Operation context (stack) */
+    ecs_world_t *world;                /* Reference to world */
+    const ecs_query_impl_t *query;     /* Reference to query */
+    const ecs_query_var_t *query_vars; /* Reference to query variable array */
+    ecs_query_iter_t *qit;
+} ecs_query_run_ctx_t;
 
-#define ecs_poly_fini(object, type)\
-    ecs_poly_fini_(object, type##_magic)
+typedef struct {
+    ecs_query_var_t var;
+    const char *name;
+} ecs_query_var_cache_t;
 
-/* Utility functions for creating an object on the heap */
-#define ecs_poly_new(type)\
-    (type*)ecs_poly_init(ecs_os_calloc_t(type), type)
+struct ecs_query_impl_t {
+    ecs_query_t pub;              /* Public query data */
 
-#define ecs_poly_free(obj, type)\
-    ecs_poly_fini(obj, type);\
-    ecs_os_free(obj)
+    /* Variables */
+    ecs_query_var_t *vars;        /* Variables */
+    int32_t var_count;            /* Number of variables */
+    int32_t var_pub_count;        /* Number of public variables */
+    int32_t var_size;             /* Size of variable array */
+    bool has_table_this;          /* Does query have [$this] */
+    ecs_hashmap_t tvar_index;     /* Name index for table variables */
+    ecs_hashmap_t evar_index;     /* Name index for entity variables */
+    ecs_query_var_cache_t vars_cache; /* For trivial queries with only This variables */
+    char **var_names;             /* Array with variable names for iterator */
+    ecs_var_id_t *src_vars;       /* Array with ids to source variables for fields */
 
-/* Get or create poly component for an entity */
-EcsPoly* ecs_poly_bind_(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t tag);
+    /* Query plan */
+    ecs_query_op_t *ops;          /* Operations */
+    int32_t op_count;             /* Number of operations */
 
-#define ecs_poly_bind(world, entity, T) \
-    ecs_poly_bind_(world, entity, T##_tag)
+    /* Query cache */
+    struct ecs_query_cache_t *cache; /* Cache, if query contains cached terms */
+    int8_t *field_map;            /* Map field indices from cache to query */
 
-void ecs_poly_modified_(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t tag);
+    /* Change detection */
+    int32_t *monitor;             /* Change monitor for fields with fixed src */
 
-#define ecs_poly_modified(world, entity, T) \
-    ecs_poly_modified_(world, entity, T##_tag)
+    /* Misc */
+    int16_t tokens_len;           /* Length of tokens buffer */
+    char *tokens;                 /* Buffer with string tokens used by terms */
 
-/* Get poly component for an entity */
-const EcsPoly* ecs_poly_bind_get_(
-    const ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t tag);
+    /* User context */
+    ecs_ctx_free_t ctx_free;         /* Callback to free ctx */
+    ecs_ctx_free_t binding_ctx_free; /* Callback to free binding_ctx */
 
-#define ecs_poly_bind_get(world, entity, T) \
-    ecs_poly_bind_get_(world, entity, T##_tag)
+    /* Mixins */
+    flecs_poly_dtor_t dtor;
+};
 
-ecs_poly_t* ecs_poly_get_(
-    const ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t tag);
 
-#define ecs_poly_get(world, entity, T) \
-    ((T*)ecs_poly_get_(world, entity, T##_tag))
+/* Query cache types */
 
-/* Utilities for testing/asserting an object type */
-#ifndef FLECS_NDEBUG
-#define ecs_poly_assert(object, ty)\
-    do {\
-        ecs_assert(object != NULL, ECS_INVALID_PARAMETER, NULL);\
-        const ecs_header_t *hdr = (const ecs_header_t *)object;\
-        const char *type_name = hdr->mixins->type_name;\
-        ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, type_name);\
-        ecs_assert(hdr->type == ty##_magic, ECS_INVALID_PARAMETER, type_name);\
-    } while (0)
+/** Table match data.
+ * Each table matched by the query is represented by a ecs_query_cache_table_match_t
+ * instance, which are linked together in a list. A table may match a query
+ * multiple times (due to wildcard queries) with different columns being matched
+ * by the query. */
+struct ecs_query_cache_table_match_t {
+    ecs_query_cache_table_match_t *next, *prev;
+    ecs_table_t *table;              /* The current table. */
+    int32_t offset;                  /* Starting point in table  */
+    int32_t count;                   /* Number of entities to iterate in table */
+    int32_t *columns;                /* Mapping from query fields to table columns */
+    int32_t *storage_columns;        /* Mapping from query fields to storage columns */
+    ecs_id_t *ids;                   /* Resolved (component) ids for current table */
+    ecs_entity_t *sources;           /* Subjects (sources) of ids */
+    ecs_vec_t refs;                  /* Cached components for non-this terms */
+    ecs_termset_t set_fields;        /* Fields that are set */
+    ecs_termset_t up_fields;         /* Fields that are matched through traversal */
+    uint64_t group_id;               /* Value used to organize tables in groups */
+    int32_t *monitor;                /* Used to monitor table for changes */
+
+    /* Next match in cache for same table (includes empty tables) */
+    ecs_query_cache_table_match_t *next_match;
+};
+
+/** Table record type for query table cache. A query only has one per table. */
+typedef struct ecs_query_cache_table_t {
+    ecs_table_cache_hdr_t hdr;       /* Header for ecs_table_cache_t */
+    ecs_query_cache_table_match_t *first;  /* List with matches for table */
+    ecs_query_cache_table_match_t *last;   /* Last discovered match for table */
+    uint64_t table_id;
+    int32_t rematch_count;           /* Track whether table was rematched */
+} ecs_query_cache_table_t;
+
+/** Points to the beginning & ending of a query group */
+typedef struct ecs_query_cache_table_list_t {
+    ecs_query_cache_table_match_t *first;
+    ecs_query_cache_table_match_t *last;
+    ecs_query_group_info_t info;
+} ecs_query_cache_table_list_t;
+
+/* Query event type for notifying queries of world events */
+typedef enum ecs_query_cache_eventkind_t {
+    EcsQueryTableMatch,
+    EcsQueryTableRematch,
+    EcsQueryTableUnmatch,
+} ecs_query_cache_eventkind_t;
+
+typedef struct ecs_query_cache_event_t {
+    ecs_query_cache_eventkind_t kind;
+    ecs_table_t *table;
+} ecs_query_cache_event_t;
+
+/* Query level block allocators have sizes that depend on query field count */
+typedef struct ecs_query_cache_allocators_t {
+    ecs_block_allocator_t columns;
+    ecs_block_allocator_t ids;
+    ecs_block_allocator_t sources;
+    ecs_block_allocator_t monitors;
+} ecs_query_cache_allocators_t;
+
+/** Query that is automatically matched against tables */
+typedef struct ecs_query_cache_t {
+    /* Uncached query used to populate the cache */
+    ecs_query_t *query;
+
+    /* Observer to keep the cache in sync */
+    ecs_observer_t *observer;
+
+    /* Tables matched with query */
+    ecs_table_cache_t cache;
+
+    /* Linked list with all matched non-empty tables, in iteration order */
+    ecs_query_cache_table_list_t list;
+
+    /* Contains head/tail to nodes of query groups (if group_by is used) */
+    ecs_map_t groups;
+
+    /* Table sorting */
+    ecs_entity_t order_by;
+    ecs_order_by_action_t order_by_callback;
+    ecs_sort_table_action_t order_by_table_callback;
+    ecs_vec_t table_slices;
+    int32_t order_by_term;
+
+    /* Table grouping */
+    ecs_entity_t group_by;
+    ecs_group_by_action_t group_by_callback;
+    ecs_group_create_action_t on_group_create;
+    ecs_group_delete_action_t on_group_delete;
+    void *group_by_ctx;
+    ecs_ctx_free_t group_by_ctx_free;
+
+    /* Monitor generation */
+    int32_t monitor_generation;
+
+    int32_t cascade_by;              /* Identify cascade term */
+    int32_t match_count;             /* How often have tables been (un)matched */
+    int32_t prev_match_count;        /* Track if sorting is needed */
+    int32_t rematch_count;           /* Track which tables were added during rematch */
+    
+    ecs_entity_t entity;
+
+    /* Query-level allocators */
+    ecs_query_cache_allocators_t allocators;
+} ecs_query_cache_t;
+
+#endif
+
+
+/* Compile query to list of operations */
+int flecs_query_compile(
+    ecs_world_t *world,
+    ecs_stage_t *stage,
+    ecs_query_impl_t *query);
+
+/* Compile single term */
+int flecs_query_compile_term(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_term_t *term,
+    ecs_flags64_t *populated,
+    ecs_query_compile_ctx_t *ctx);
+
+/* Compile term ref (first, second or src) */
+void flecs_query_compile_term_ref(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_term_ref_t *term_ref,
+    ecs_query_ref_t *ref,
+    ecs_flags8_t ref_kind,
+    ecs_var_kind_t kind,
+    ecs_query_compile_ctx_t *ctx,
+    bool create_wildcard_vars);
+
+/* Mark variable as written */
+void flecs_query_write(
+    ecs_var_id_t var_id,
+    uint64_t *written);
+
+/* Mark variable as written in compiler context */
+void flecs_query_write_ctx(
+    ecs_var_id_t var_id,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write);
+
+/* Add operation to query plan */
+ecs_query_lbl_t flecs_query_op_insert(
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx);
+
+/* Insert each instruction */
+void flecs_query_insert_each(
+    ecs_var_id_t tvar,
+    ecs_var_id_t evar,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write);
+
+/* Insert instruction that populates field */
+void flecs_query_insert_populate(
+    ecs_query_impl_t *query,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_flags64_t populated);
+
+/* Add discovered variable */
+ecs_var_id_t flecs_query_add_var(
+    ecs_query_impl_t *query,
+    const char *name,
+    ecs_vec_t *vars,
+    ecs_var_kind_t kind);
+
+/* Find variable by name/kind */
+ecs_var_id_t flecs_query_find_var_id(
+    const ecs_query_impl_t *query,
+    const char *name,
+    ecs_var_kind_t kind);
+
+ecs_query_op_t* flecs_query_begin_block(
+    ecs_query_op_kind_t kind,
+    ecs_query_compile_ctx_t *ctx);
+
+void flecs_query_end_block(
+    ecs_query_compile_ctx_t *ctx,
+    bool reset);
+
+
+ /**
+ * @file query/cache.h
+ * @brief Query cache functions.
+ */
+
+/* Create query cache */
+ecs_query_cache_t* flecs_query_cache_init(
+    ecs_query_impl_t *impl,
+    const ecs_query_desc_t *desc);
+
+/* Destroy query cache */
+void flecs_query_cache_fini(
+    ecs_query_impl_t *impl);
+
+/* Notify query cache of event (separate from query observer) */
+void flecs_query_cache_notify(
+    ecs_world_t *world,
+    ecs_query_t *q,
+    ecs_query_cache_event_t *event);
+
+/* Get cache entry for table */
+ecs_query_cache_table_t* flecs_query_cache_get_table(
+    ecs_query_cache_t *query,
+    ecs_table_t *table);
+
+/* Sort tables (order_by implementation) */
+void flecs_query_cache_sort_tables(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl);
+
+void flecs_query_cache_build_sorted_tables(
+    ecs_query_cache_t *cache);
+
+/* Return number of tables in cache */
+int32_t flecs_query_cache_table_count(
+    ecs_query_cache_t *cache);
+
+/* Return number of empty tables in cache */
+int32_t flecs_query_cache_empty_table_count(
+    ecs_query_cache_t *cache);
+
+/* Return number of entities in cache (requires iterating tables) */
+int32_t flecs_query_cache_entity_count(
+    const ecs_query_cache_t *cache);
+
+/**
+ * @file query/cache_iter.h
+ * @brief Cache iterator functions.
+ */
+
+
+/* Cache search without data */
+bool flecs_query_cache_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx);
+
+/* Cache search with data */
+bool flecs_query_cache_data_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx);
+
+/* Cache search without data where entire query is cached */
+bool flecs_query_is_cache_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx);
+
+/* Cache search with data where entire query is cached */
+bool flecs_query_is_cache_data_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx);
+
+/* Cache test without data */
+bool flecs_query_cache_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first);
+
+/* Cache test without data where entire query is cached */
+bool flecs_query_is_cache_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first);
+
+/* Cache test with data */
+bool flecs_query_cache_data_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first);
+
+/* Cache test with data where entire query is cached */
+bool flecs_query_is_cache_data_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first);
+
+/**
+ * @file query/change_detection.h
+ * @brief Query change detection functions.
+ */
+
+
+/* Sychronize cache monitor with table dirty state */
+void flecs_query_sync_match_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match);
+
+/* Mark iterated out fields dirty */
+void flecs_query_mark_fields_dirty(
+    ecs_query_impl_t *impl,
+    ecs_iter_t *it);
+
+/* Compare cache monitor with table dirty state to detect changes */
+bool flecs_query_check_table_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_t *table,
+    int32_t term);
+
+/* Mark out fields with fixed source dirty */
+void flecs_query_mark_fixed_fields_dirty(
+    ecs_query_impl_t *impl,
+    ecs_iter_t *it);
+
+/* Synchronize fixed source monitor */
+bool flecs_query_update_fixed_monitor(
+    ecs_query_impl_t *impl);
+
+/* Compare fixed source monitor */
+bool flecs_query_check_fixed_monitor(
+    ecs_query_impl_t *impl);
+
+/**
+ * @file query/trav_cache.h
+ * @brief Traversal cache functions
+ */
+
+
+/* Traversal cache for transitive queries. Finds all reachable entities by
+ * following a relationship */
+
+/* Find all entities when traversing downwards */
+void flecs_query_get_trav_down_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_entity_t entity);
+
+/* Find all entities when traversing upwards */
+void flecs_query_get_trav_up_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_table_t *table);
+
+/* Free traversal cache */
+void flecs_query_trav_cache_fini(
+    ecs_allocator_t *a,
+    ecs_trav_cache_t *cache);
+
+/* Traversal caches for up traversal. Enables searching upwards until an entity
+ * with the queried for id has been found. */
+
+/* Traverse downwards from starting entity to find all tables for which the 
+ * specified entity is the source of the queried for id ('with'). */
+ecs_trav_down_t* flecs_query_get_down_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_up_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_entity_t entity,
+    ecs_id_record_t *idr_with,
+    bool self,
+    bool empty);
+
+/* Free down traversal cache */
+void flecs_query_down_cache_fini(
+    ecs_allocator_t *a,
+    ecs_trav_up_cache_t *cache);
+
+ecs_trav_up_t* flecs_query_get_up_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_up_cache_t *cache,
+    ecs_table_t *table,
+    ecs_id_t with,
+    ecs_entity_t trav,
+    ecs_id_record_t *idr_with,
+    ecs_id_record_t *idr_trav);
+
+/* Free up traversal cache */
+void flecs_query_up_cache_fini(
+    ecs_trav_up_cache_t *cache);
+
+/**
+ * @file query/trivial_iter.h
+ * @brief Trivial iterator functions.
+ */
+
+
+/* Iterator for trivial queries. */
+bool flecs_query_trivial_search(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t field_set);
+
+/* Iterator for trivial queries. */
+bool flecs_query_trivial_search_nodata(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t field_set);
+
+/* Iterator for trivial queries with wildcard matching. */
+bool flecs_query_trivial_search_w_wildcards(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t field_set);
+
+/* Trivial test for constrained $this. */
+bool flecs_query_trivial_test(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    bool first,
+    ecs_flags64_t field_set);
+
+/* Trivial test for constrained $this with wildcard matching. */
+bool flecs_query_trivial_test_w_wildcards(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    bool first,
+    ecs_flags64_t field_set);
+
+/**
+ * @file query/util.h
+ * @brief Utility functions
+ */
+
+
+/* Helper type for passing around context required for error messages */
+typedef struct {
+    const ecs_world_t *world;
+    ecs_query_t *query;
+    ecs_term_t *term;
+    int32_t term_index;
+} ecs_query_validator_ctx_t;
+
+/* Convert integer to label */
+ecs_query_lbl_t flecs_itolbl(
+    int64_t val);
+
+/* Convert integer to variable id */
+ecs_var_id_t flecs_itovar(
+    int64_t val);
+
+/* Convert unsigned integer to variable id */
+ecs_var_id_t flecs_utovar(
+    uint64_t val);
+
+/* Get name for term ref */
+const char* flecs_term_ref_var_name(
+    ecs_term_ref_t *ref);
+
+/* Is term ref wildcard */
+bool flecs_term_ref_is_wildcard(
+    ecs_term_ref_t *ref);
+
+/* Does term use builtin predicates (eq, neq, ...)*/
+bool flecs_term_is_builtin_pred(
+    ecs_term_t *term);
+
+/* Does term have fixed id */
+bool flecs_term_is_fixed_id(
+    ecs_query_t *q,
+    ecs_term_t *term);
+
+/* Is term part of OR chain */
+bool flecs_term_is_or(
+    const ecs_query_t *q,
+    const ecs_term_t *term);
+
+/* Get ref flags (IsEntity) or IsVar) for ref (Src, First, Second) */
+ecs_flags16_t flecs_query_ref_flags(
+    ecs_flags16_t flags,
+    ecs_flags16_t kind);
+
+/* Check if variable is written */
+bool flecs_query_is_written(
+    ecs_var_id_t var_id,
+    uint64_t written);
+
+/* Check if ref is written (calls flecs_query_is_written)*/
+bool flecs_ref_is_written(
+    const ecs_query_op_t *op,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t kind,
+    uint64_t written);
+
+/* Get allocator from iterator */
+ecs_allocator_t* flecs_query_get_allocator(
+    const ecs_iter_t *it);
+
+/* Convert query to string */
+char* flecs_query_str(
+    const ecs_world_t *world,
+    const ecs_query_t *query,
+    const ecs_query_validator_ctx_t *ctx,
+    int32_t *term_start_out);
+
+/* Convert instruction kind to string */
+const char* flecs_query_op_str(
+    uint16_t kind);
+
+
+#ifdef FLECS_DEBUG
+#define flecs_set_var_label(var, lbl) (var)->label = lbl
 #else
-#define ecs_poly_assert(object, ty)
+#define flecs_set_var_label(var, lbl)
+#endif
+
+/* Finalize query data & validate */
+int flecs_query_finalize_query(
+    ecs_world_t *world,
+    ecs_query_t *q,
+    const ecs_query_desc_t *desc);
+
+/* Internal function for creating iterator, doesn't run aperiodic tasks */
+ecs_iter_t flecs_query_iter(
+    const ecs_world_t *world,
+    const ecs_query_t *q);
+
+/**
+ * @file observable.h
+ * @brief Functions for sending events.
+ */
+
+#ifndef FLECS_OBSERVABLE_H
+#define FLECS_OBSERVABLE_H
+
+/** All observers for a specific (component) id */
+typedef struct ecs_event_id_record_t {
+    /* Triggers for Self */
+    ecs_map_t self;                  /* map<trigger_id, trigger_t> */
+    ecs_map_t self_up;               /* map<trigger_id, trigger_t> */
+    ecs_map_t up;                    /* map<trigger_id, trigger_t> */
+
+    ecs_map_t observers;             /* map<trigger_id, trigger_t> */
+
+    /* Triggers for SuperSet, SubSet */
+    ecs_map_t set_observers;         /* map<trigger_id, trigger_t> */
+
+    /* Triggers for Self with non-This subject */
+    ecs_map_t entity_observers;      /* map<trigger_id, trigger_t> */
+
+    /* Number of active observers for (component) id */
+    int32_t observer_count;
+} ecs_event_id_record_t;
+
+typedef struct ecs_observer_impl_t {
+    ecs_observer_t pub;
+
+    int32_t *last_event_id;     /**< Last handled event id */
+    int32_t last_event_id_storage;
+
+    ecs_id_t register_id;       /**< Id observer is registered with (single term observers only) */
+    int32_t term_index;         /**< Index of the term in parent observer (single term observers only) */
+
+    ecs_flags32_t flags;        /**< Observer flags */
+    uint64_t id;                /**< Internal id (not entity id) */
+    ecs_vec_t children;         /**< If multi observer, vector stores child observers */
+
+    ecs_query_t *not_query;     /**< Query used to populate observer data when a
+                                     term with a not operator triggers. */
+
+    /* Mixins */
+    flecs_poly_dtor_t dtor;
+} ecs_observer_impl_t;
+
+#define flecs_observer_impl(observer) (ECS_CONST_CAST(ecs_observer_impl_t*, observer))
+
+ecs_event_record_t* flecs_event_record_get(
+    const ecs_observable_t *o,
+    ecs_entity_t event);
+
+ecs_event_record_t* flecs_event_record_ensure(
+    ecs_observable_t *o,
+    ecs_entity_t event);
+
+ecs_event_id_record_t* flecs_event_id_record_get(
+    const ecs_event_record_t *er,
+    ecs_id_t id);
+
+ecs_event_id_record_t* flecs_event_id_record_ensure(
+    ecs_world_t *world,
+    ecs_event_record_t *er,
+    ecs_id_t id);
+
+void flecs_event_id_record_remove(
+    ecs_event_record_t *er,
+    ecs_id_t id);
+
+void flecs_observable_init(
+    ecs_observable_t *observable);
+
+void flecs_observable_fini(
+    ecs_observable_t *observable);
+
+bool flecs_observers_exist(
+    ecs_observable_t *observable,
+    ecs_id_t id,
+    ecs_entity_t event);
+
+ecs_observer_t* flecs_observer_init(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const ecs_observer_desc_t *desc);
+
+void flecs_observer_fini(
+    ecs_observer_t *observer);
+
+void flecs_emit( 
+    ecs_world_t *world,
+    ecs_world_t *stage,
+    ecs_event_desc_t *desc);
+
+bool flecs_default_observer_next_callback(
+    ecs_iter_t *it);
+
+void flecs_observers_invoke(
+    ecs_world_t *world,
+    ecs_map_t *observers,
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    ecs_entity_t trav);
+
+void flecs_emit_propagate_invalidate(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    int32_t offset,
+    int32_t count);
+
+void flecs_observer_set_disable_bit(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    ecs_flags32_t bit,
+    bool cond);
+
+#endif
+
+/**
+ * @file iter.h
+ * @brief Iterator utilities.
+ */
+
+#ifndef FLECS_ITER_H
+#define FLECS_ITER_H
+
+void flecs_iter_init(
+    const ecs_world_t *world,
+    ecs_iter_t *it,
+    ecs_flags8_t fields);
+
+void flecs_iter_validate(
+    ecs_iter_t *it);
+
+bool flecs_iter_next_row(
+    ecs_iter_t *it);
+
+bool flecs_iter_next_instanced(
+    ecs_iter_t *it,
+    bool result);
+
+void* flecs_iter_calloc(
+    ecs_iter_t *it,
+    ecs_size_t size,
+    ecs_size_t align);
+
+#define flecs_iter_calloc_t(it, T)\
+    flecs_iter_calloc(it, ECS_SIZEOF(T), ECS_ALIGNOF(T))
+
+#define flecs_iter_calloc_n(it, T, count)\
+    flecs_iter_calloc(it, ECS_SIZEOF(T) * count, ECS_ALIGNOF(T))
+
+void flecs_iter_free(
+    void *ptr,
+    ecs_size_t size);
+
+#define flecs_iter_free_t(ptr, T)\
+    flecs_iter_free(ptr, ECS_SIZEOF(T))
+
+#define flecs_iter_free_n(ptr, T, count)\
+    flecs_iter_free(ptr, ECS_SIZEOF(T) * count)
+
 #endif
 
-/* Utility functions for getting a mixin from an object */
-ecs_iterable_t* ecs_get_iterable(
-    const ecs_poly_t *poly);
+/**
+ * @file poly.h
+ * @brief Functions for managing poly objects.
+ */
+
+#ifndef FLECS_POLY_H
+#define FLECS_POLY_H
+
+#include <stddef.h>
+
+/* Initialize poly */
+void* flecs_poly_init_(
+    flecs_poly_t *object,
+    int32_t kind,
+    ecs_size_t size,
+    ecs_mixins_t *mixins);
+
+#define flecs_poly_init(object, type)\
+    flecs_poly_init_(object, type##_magic, sizeof(type), &type##_mixins)
+
+/* Deinitialize object for specified type */
+void flecs_poly_fini_(
+    flecs_poly_t *object,
+    int32_t kind);
+
+#define flecs_poly_fini(object, type)\
+    flecs_poly_fini_(object, type##_magic)
+
+/* Utility functions for creating an object on the heap */
+#define flecs_poly_new(type)\
+    (type*)flecs_poly_init(ecs_os_calloc_t(type), type)
+
+#define flecs_poly_free(obj, type)\
+    flecs_poly_fini(obj, type);\
+    ecs_os_free(obj)
+
+/* Get or create poly component for an entity */
+EcsPoly* flecs_poly_bind_(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t tag);
+
+#define flecs_poly_bind(world, entity, T) \
+    flecs_poly_bind_(world, entity, T##_tag)
+
+void flecs_poly_modified_(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t tag);
+
+#define flecs_poly_modified(world, entity, T) \
+    flecs_poly_modified_(world, entity, T##_tag)
+
+/* Get poly component for an entity */
+const EcsPoly* flecs_poly_bind_get_(
+    const ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t tag);
+
+#define flecs_poly_bind_get(world, entity, T) \
+    flecs_poly_bind_get_(world, entity, T##_tag)
+
+flecs_poly_t* flecs_poly_get_(
+    const ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t tag);
+
+#define flecs_poly_get(world, entity, T) \
+    ((T*)flecs_poly_get_(world, entity, T##_tag))
+
+/* Utilities for testing/asserting an object type */
+#ifndef FLECS_NDEBUG
+#define flecs_poly_assert(object, ty)\
+    do {\
+        ecs_assert(object != NULL, ECS_INVALID_PARAMETER, NULL);\
+        const ecs_header_t *hdr = (const ecs_header_t *)object;\
+        const char *type_name = hdr->mixins->type_name;\
+        ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, type_name);\
+        ecs_assert(hdr->type == ty##_magic, ECS_INVALID_PARAMETER, type_name);\
+    } while (0)
+#else
+#define flecs_poly_assert(object, ty)
+#endif
 
 ecs_observable_t* ecs_get_observable(
-    const ecs_poly_t *object);
+    const flecs_poly_t *object);
 
-ecs_poly_dtor_t* ecs_get_dtor(
-    const ecs_poly_t *poly);
+flecs_poly_dtor_t* ecs_get_dtor(
+    const flecs_poly_t *poly);
 
 #endif
 
@@ -1860,16 +2388,6 @@ ecs_poly_dtor_t* ecs_get_dtor(
 #ifndef FLECS_STAGE_H
 #define FLECS_STAGE_H
 
-/* Initialize stage data structures */
-void flecs_stage_init(
-    ecs_world_t *world,
-    ecs_stage_t *stage);
-
-/* Deinitialize stage */
-void flecs_stage_fini(
-    ecs_world_t *world,
-    ecs_stage_t *stage);
-
 /* Post-frame merge actions */
 void flecs_stage_merge_post_frame(
     ecs_world_t *world,
@@ -1942,7 +2460,8 @@ void* flecs_defer_set(
     ecs_entity_t entity,
     ecs_entity_t component,
     ecs_size_t size,
-    void *value);
+    void *value,
+    bool *is_new);
 
 bool flecs_defer_end(
     ecs_world_t *world,
@@ -1967,6 +2486,12 @@ ecs_entity_t flecs_stage_set_system(
     ecs_stage_t *stage,
     ecs_entity_t system);
 
+ecs_allocator_t* flecs_stage_get_allocator(
+    ecs_world_t *world);
+
+ecs_stack_t* flecs_stage_get_stack_allocator(
+    ecs_world_t *world);
+
 #endif
 
 /**
@@ -1982,7 +2507,7 @@ ecs_stage_t* flecs_stage_from_world(
     ecs_world_t **world_ptr);
 
 /* Get current thread-specific stage from readonly world */
-const ecs_stage_t* flecs_stage_from_readonly_world(
+ecs_stage_t* flecs_stage_from_readonly_world(
     const ecs_world_t *world);
 
 /* Get component callbacks */
@@ -2054,37 +2579,6 @@ void flecs_delete_table(
 void flecs_process_pending_tables(
     const ecs_world_t *world);
 
-/* Suspend/resume readonly state. To fully support implicit registration of
- * components, it should be possible to register components while the world is
- * in readonly mode. It is not uncommon that a component is used first from
- * within a system, which are often ran while in readonly mode.
- * 
- * Suspending readonly mode is only allowed when the world is not multithreaded.
- * When a world is multithreaded, it is not safe to (even temporarily) leave
- * readonly mode, so a multithreaded application should always explicitly
- * register components in advance. 
- * 
- * These operations also suspend deferred mode.
- */
-typedef struct ecs_suspend_readonly_state_t {
-    bool is_readonly;
-    bool is_deferred;
-    int32_t defer_count;
-    ecs_entity_t scope;
-    ecs_entity_t with;
-    ecs_vec_t commands;
-    ecs_stack_t defer_stack;
-    ecs_stage_t *stage;
-} ecs_suspend_readonly_state_t;
-
-ecs_world_t* flecs_suspend_readonly(
-    const ecs_world_t *world,
-    ecs_suspend_readonly_state_t *state);
-
-void flecs_resume_readonly(
-    ecs_world_t *world,
-    ecs_suspend_readonly_state_t *state);
-
 /* Convenience macro's for world allocator */
 #define flecs_walloc(world, size)\
     flecs_alloc(&world->allocator, size)
@@ -2281,52 +2775,9 @@ void flecs_invoke_hook(
 //// Query API
 ////////////////////////////////////////////////////////////////////////////////
 
-/* Match table with term */
-bool flecs_term_match_table(
-    ecs_world_t *world,
-    const ecs_term_t *term,
-    const ecs_table_t *table,
-    ecs_id_t *id_out,
-    int32_t *column_out,
-    ecs_entity_t *subject_out,
-    int32_t *match_indices,
-    bool first,
-    ecs_flags32_t iter_flags);
-
-/* Match table with filter */
-bool flecs_filter_match_table(
-    ecs_world_t *world,
-    const ecs_filter_t *filter,
-    const ecs_table_t *table,
-    ecs_id_t *ids,
-    int32_t *columns,
-    ecs_entity_t *sources,
-    int32_t *match_indices,
-    int32_t *matches_left,
-    bool first,
-    int32_t skip_term,
-    ecs_flags32_t iter_flags);
-
-ecs_iter_t flecs_filter_iter_w_flags(
-    const ecs_world_t *stage,
-    const ecs_filter_t *filter,
-    ecs_flags32_t flags);
-
-void flecs_query_notify(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_event_t *event);
-
-ecs_id_t flecs_to_public_id(
-    ecs_id_t id);
-
-ecs_id_t flecs_from_public_id(
-    ecs_world_t *world,
-    ecs_id_t id);
-
-void flecs_filter_apply_iter_flags(
+void flecs_query_apply_iter_flags(
     ecs_iter_t *it,
-    const ecs_filter_t *filter);
+    const ecs_query_t *query);
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Safe(r) integer casting
@@ -2386,25 +2837,6 @@ uint64_t flecs_ito_(
 #define flecs_itoi16(value) flecs_ito(int16_t, (value))
 #define flecs_itoi32(value) flecs_ito(int32_t, (value))
 
-////////////////////////////////////////////////////////////////////////////////
-//// Entity filter
-////////////////////////////////////////////////////////////////////////////////
-
-void flecs_entity_filter_init(
-    ecs_world_t *world,
-    ecs_entity_filter_t **entity_filter,
-    const ecs_filter_t *filter,
-    const ecs_table_t *table,
-    ecs_id_t *ids,
-    int32_t *columns);
-
-void flecs_entity_filter_fini(
-    ecs_world_t *world,
-    ecs_entity_filter_t *entity_filter);
-
-int flecs_entity_filter_next(
-    ecs_entity_filter_iter_t *it);
-
 ////////////////////////////////////////////////////////////////////////////////
 //// Utilities
 ////////////////////////////////////////////////////////////////////////////////
@@ -2476,13 +2908,9 @@ void flecs_colorize_buf(
     bool enable_colors,
     ecs_strbuf_t *buf);
 
-bool flecs_isident(
-    char ch);
-
 int32_t flecs_search_w_idr(
     const ecs_world_t *world,
     const ecs_table_t *table,
-    ecs_id_t id,
     ecs_id_t *id_out,
     ecs_id_record_t *idr);
 
@@ -2492,7 +2920,7 @@ int32_t flecs_search_relation_w_idr(
     int32_t offset,
     ecs_id_t id,
     ecs_entity_t rel,
-    ecs_flags32_t flags,
+    ecs_flags64_t flags,
     ecs_entity_t *subject_out,
     ecs_id_t *id_out,
     struct ecs_table_record_t **tr_out,
@@ -2504,6 +2932,14 @@ bool flecs_type_can_inherit_id(
     const ecs_id_record_t *idr,
     ecs_id_t id);
 
+int ecs_term_finalize(
+    const ecs_world_t *world,
+    ecs_term_t *term);
+
+int32_t flecs_query_pivot_term(
+    const ecs_world_t *world,
+    const ecs_query_t *query);
+
 #endif
 
 
@@ -2537,7 +2973,7 @@ static ECS_MOVE(EcsIdentifier, dst, src, {
 
 static
 void ecs_on_set(EcsIdentifier)(ecs_iter_t *it) {
-    EcsIdentifier *ptr = ecs_field(it, EcsIdentifier, 1);
+    EcsIdentifier *ptr = ecs_field(it, EcsIdentifier, 0);
     
     ecs_world_t *world = it->real_world;
     ecs_entity_t evt = it->event;
@@ -2619,7 +3055,7 @@ static ECS_COPY(EcsPoly, dst, src, {
 
 static ECS_MOVE(EcsPoly, dst, src, {
     if (dst->poly && (dst->poly != src->poly)) {
-        ecs_poly_dtor_t *dtor = ecs_get_dtor(dst->poly);
+        flecs_poly_dtor_t *dtor = ecs_get_dtor(dst->poly);
         ecs_assert(dtor != NULL, ECS_INTERNAL_ERROR, NULL);
         dtor[0](dst->poly);
     }
@@ -2630,7 +3066,7 @@ static ECS_MOVE(EcsPoly, dst, src, {
 
 static ECS_DTOR(EcsPoly, ptr, {
     if (ptr->poly) {
-        ecs_poly_dtor_t *dtor = ecs_get_dtor(ptr->poly);
+        flecs_poly_dtor_t *dtor = ecs_get_dtor(ptr->poly);
         ecs_assert(dtor != NULL, ECS_INTERNAL_ERROR, NULL);
         dtor[0](ptr->poly);
     }
@@ -2661,9 +3097,7 @@ void flecs_assert_relation_unused(
     }
 
     bool in_use = ecs_id_in_use(world, ecs_pair(rel, EcsWildcard));
-    if (property != EcsUnion) {
-        in_use |= ecs_id_in_use(world, rel);
-    }
+    in_use |= ecs_id_in_use(world, rel);
     if (in_use) {
         char *r_str = ecs_get_fullpath(world, rel);
         char *p_str = ecs_get_fullpath(world, property);
@@ -2772,7 +3206,7 @@ void flecs_register_final(ecs_iter_t *it) {
 
 static
 void flecs_register_on_delete(ecs_iter_t *it) {
-    ecs_id_t id = ecs_field_id(it, 1);
+    ecs_id_t id = ecs_field_id(it, 0);
     flecs_register_id_flag_for_relation(it, EcsOnDelete, 
         ECS_ID_ON_DELETE_FLAG(ECS_PAIR_SECOND(id)),
         EcsIdOnDeleteMask,
@@ -2781,7 +3215,7 @@ void flecs_register_on_delete(ecs_iter_t *it) {
 
 static
 void flecs_register_on_delete_object(ecs_iter_t *it) {
-    ecs_id_t id = ecs_field_id(it, 1);
+    ecs_id_t id = ecs_field_id(it, 0);
     flecs_register_id_flag_for_relation(it, EcsOnDeleteTarget, 
         ECS_ID_ON_DELETE_TARGET_FLAG(ECS_PAIR_SECOND(id)),
         EcsIdOnDeleteObjectMask,
@@ -2796,7 +3230,7 @@ void flecs_register_traversable(ecs_iter_t *it) {
 
 static
 void flecs_register_tag(ecs_iter_t *it) {
-    flecs_register_id_flag_for_relation(it, EcsTag, EcsIdTag, ~EcsIdTag, 0);
+    flecs_register_id_flag_for_relation(it, EcsPairIsTag, EcsIdTag, ~EcsIdTag, 0);
 
     /* Ensure that all id records for tag have type info set to NULL */
     ecs_world_t *world = it->real_world;
@@ -2810,7 +3244,7 @@ void flecs_register_tag(ecs_iter_t *it) {
             ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
             do {
                 if (idr->type_info != NULL) {
-                    flecs_assert_relation_unused(world, e, EcsTag);
+                    flecs_assert_relation_unused(world, e, EcsPairIsTag);
                 }
                 idr->type_info = NULL;
             } while ((idr = idr->first.next));
@@ -2837,26 +3271,19 @@ void flecs_register_always_override(ecs_iter_t *it) {
 }
 
 static
-void flecs_register_with(ecs_iter_t *it) {
-    flecs_register_id_flag_for_relation(it, EcsWith, EcsIdWith, 0, 0);
+void flecs_register_can_toggle(ecs_iter_t *it) {
+    flecs_register_id_flag_for_relation(it, EcsCanToggle, 
+        EcsIdCanToggle, EcsIdCanToggle, 0);
 }
 
 static
-void flecs_register_union(ecs_iter_t *it) {
-    flecs_register_id_flag_for_relation(it, EcsUnion, EcsIdUnion, 0, 0);
-}
-
-static
-void flecs_register_slot_of(ecs_iter_t *it) {
-    int i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_add_id(it->world, it->entities[i], EcsUnion);
-    }
+void flecs_register_with(ecs_iter_t *it) {
+    flecs_register_id_flag_for_relation(it, EcsWith, EcsIdWith, 0, 0);
 }
 
 static
 void flecs_on_symmetric_add_remove(ecs_iter_t *it) {
-    ecs_entity_t pair = ecs_field_id(it, 1);
+    ecs_entity_t pair = ecs_field_id(it, 0);
 
     if (!ECS_HAS_ID_FLAG(pair, PAIR)) {
         /* If relationship was not added as a pair, there's nothing to do */
@@ -2895,8 +3322,8 @@ void flecs_register_symmetric(ecs_iter_t *it) {
         /* Create observer that adds the reverse relationship when R(X, Y) is
          * added, or remove the reverse relationship when R(X, Y) is removed. */
         ecs_observer(world, {
-            .entity = ecs_entity(world, {.add = {ecs_childof(r)}}),
-            .filter.terms[0] = { .id = ecs_pair(r, EcsWildcard) },
+            .entity = ecs_entity(world, { .parent = r }),
+            .query.terms[0] = { .id = ecs_pair(r, EcsWildcard) },
             .callback = flecs_on_symmetric_add_remove,
             .events = {EcsOnAdd, EcsOnRemove}
         });
@@ -2906,7 +3333,7 @@ void flecs_register_symmetric(ecs_iter_t *it) {
 static
 void flecs_on_component(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsComponent *c = ecs_field(it, EcsComponent, 1);
+    EcsComponent *c = ecs_field(it, EcsComponent, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -2950,40 +3377,6 @@ void flecs_ensure_module_tag(ecs_iter_t *it) {
     }
 }
 
-static
-void flecs_observer_set_disable_bit(
-    ecs_world_t *world,
-    ecs_entity_t e,
-    ecs_flags32_t bit,
-    bool cond)
-{
-    const EcsPoly *poly = ecs_get_pair(world, e, EcsPoly, EcsObserver);
-    if (!poly || !poly->poly) {
-        return;
-    }
-
-    ecs_observer_t *o = poly->poly;
-    if (o->flags & EcsObserverIsMulti) {
-        /* If this is a multi-component observer, set flag on single-term
-         * observer children. */
-        ecs_iter_t child_it = ecs_children(world, e);
-        while (ecs_children_next(&child_it)) {
-            ecs_table_t *table = child_it.table;
-            if (ecs_table_has_id(world, table, EcsObserver)) {
-                int32_t i;
-                for (i = 0; i < child_it.count; i ++) {
-                    flecs_observer_set_disable_bit(
-                        world, child_it.entities[i], bit, cond);
-
-                }
-            }
-        }
-    } else {
-        ecs_poly_assert(o, ecs_observer_t);
-        ECS_BIT_COND(o->flags, bit, cond);
-    }
-}
-
 static
 void flecs_disable_observer(
     ecs_iter_t *it) 
@@ -3040,18 +3433,6 @@ void flecs_disable_module(ecs_iter_t *it) {
     }
 }
 
-/* -- Iterable mixins -- */
-
-static
-void flecs_on_event_iterable_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly, /* Observable */
-    ecs_iter_t *it,
-    ecs_term_t *filter)
-{
-    ecs_iter_poly(world, poly, it, filter);
-}
-
 /* -- Bootstrapping -- */
 
 #define flecs_bootstrap_builtin_t(world, table, name)\
@@ -3210,17 +3591,21 @@ void flecs_bootstrap(
     ecs_make_alive(world, EcsIsA);
     ecs_make_alive(world, EcsWildcard);
     ecs_make_alive(world, EcsAny);
-    ecs_make_alive(world, EcsTag);
+    ecs_make_alive(world, EcsPairIsTag);
+    ecs_make_alive(world, EcsCanToggle);
+    ecs_make_alive(world, EcsTrait);
+    ecs_make_alive(world, EcsRelationship);
+    ecs_make_alive(world, EcsTarget);
 
     /* Register type information for builtin components */
     flecs_type_info_init(world, EcsComponent, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .on_set = flecs_on_component,
         .on_remove = flecs_on_component
     });
 
     flecs_type_info_init(world, EcsIdentifier, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(EcsIdentifier),
         .copy = ecs_copy(EcsIdentifier),
         .move = ecs_move(EcsIdentifier),
@@ -3229,14 +3614,15 @@ void flecs_bootstrap(
     });
 
     flecs_type_info_init(world, EcsPoly, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .copy = ecs_copy(EcsPoly),
         .move = ecs_move(EcsPoly),
         .dtor = ecs_dtor(EcsPoly)
     });
 
-    flecs_type_info_init(world, EcsIterable, { 0 });
-    flecs_type_info_init(world, EcsFlattenTarget, { 0 });
+    flecs_type_info_init(world, EcsDefaultChildComponent, { 
+        .ctor = flecs_default_ctor,
+    });
 
     /* Create and cache often used id records on world */
     flecs_init_id_records(world);
@@ -3250,28 +3636,19 @@ void flecs_bootstrap(
     /* Bootstrap builtin components */
     flecs_bootstrap_builtin_t(world, table, EcsIdentifier);
     flecs_bootstrap_builtin_t(world, table, EcsComponent);
-    flecs_bootstrap_builtin_t(world, table, EcsIterable);
     flecs_bootstrap_builtin_t(world, table, EcsPoly);
-    flecs_bootstrap_builtin_t(world, table, EcsFlattenTarget);
-
-    /* Patch up symbol of EcsIterable. The type is a typedef, which causes a
-     * symbol mismatch when registering the type with the C++ API. */
-    ecs_set_symbol(world, ecs_id(EcsIterable), "ecs_iterable_t");
+    flecs_bootstrap_builtin_t(world, table, EcsDefaultChildComponent);
 
     /* Initialize default entity id range */
     world->info.last_component_id = EcsFirstUserComponentId;
     flecs_entities_max_id(world) = EcsFirstUserEntityId;
     world->info.min_id = 0;
     world->info.max_id = 0;
-
-    /* Make EcsOnAdd, EcsOnSet events iterable to enable .yield_existing */
-    ecs_set(world, EcsOnAdd, EcsIterable, { .init = flecs_on_event_iterable_init });
-    ecs_set(world, EcsOnSet, EcsIterable, { .init = flecs_on_event_iterable_init });
-
-    /* Register observer for tag property before adding EcsTag */
+    
+    /* Register observer for tag property before adding EcsPairIsTag */
     ecs_observer(world, {
-        .entity = ecs_entity(world, {.add = { ecs_childof(EcsFlecsInternals)}}),
-        .filter.terms[0] = { .id = EcsTag, .src.flags = EcsSelf },
+        .entity = ecs_entity(world, { .parent = EcsFlecsInternals }),
+        .query.terms[0] = { .id = EcsPairIsTag, .src.id = EcsSelf },
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_tag,
         .yield_existing = true
@@ -3292,6 +3669,7 @@ void flecs_bootstrap(
     flecs_bootstrap_tag(world, EcsPrefab);
     flecs_bootstrap_tag(world, EcsSlotOf);
     flecs_bootstrap_tag(world, EcsDisabled);
+    flecs_bootstrap_tag(world, EcsNotQueryable);
     flecs_bootstrap_tag(world, EcsEmpty);
 
     /* Initialize builtin modules */
@@ -3329,27 +3707,23 @@ void flecs_bootstrap(
     flecs_bootstrap_trait(world, EcsFinal);
     flecs_bootstrap_trait(world, EcsDontInherit);
     flecs_bootstrap_trait(world, EcsAlwaysOverride);
-    flecs_bootstrap_trait(world, EcsTag);
-    flecs_bootstrap_trait(world, EcsUnion);
+    flecs_bootstrap_trait(world, EcsPairIsTag);
     flecs_bootstrap_trait(world, EcsExclusive);
     flecs_bootstrap_trait(world, EcsAcyclic);
     flecs_bootstrap_trait(world, EcsTraversable);
     flecs_bootstrap_trait(world, EcsWith);
     flecs_bootstrap_trait(world, EcsOneOf);
+    flecs_bootstrap_trait(world, EcsCanToggle);
     flecs_bootstrap_trait(world, EcsTrait);
     flecs_bootstrap_trait(world, EcsRelationship);
     flecs_bootstrap_trait(world, EcsTarget);
     flecs_bootstrap_trait(world, EcsOnDelete);
     flecs_bootstrap_trait(world, EcsOnDeleteTarget);
-    ecs_add_id(world, ecs_id(EcsFlattenTarget), EcsTrait);
 
     flecs_bootstrap_tag(world, EcsRemove);
     flecs_bootstrap_tag(world, EcsDelete);
     flecs_bootstrap_tag(world, EcsPanic);
 
-    flecs_bootstrap_tag(world, EcsFlatten);
-    flecs_bootstrap_tag(world, EcsDefaultChildComponent);
-
     /* Builtin predicates */
     flecs_bootstrap_tag(world, EcsPredEq);
     flecs_bootstrap_tag(world, EcsPredMatch);
@@ -3373,22 +3747,23 @@ void flecs_bootstrap(
     flecs_bootstrap_entity(world, EcsOnTableEmpty, "OnTableEmpty", EcsFlecsCore);
     flecs_bootstrap_entity(world, EcsOnTableFill, "OnTableFilled", EcsFlecsCore);
 
+    /* Unqueryable entities */
+    ecs_add_id(world, EcsThis, EcsNotQueryable);
+    ecs_add_id(world, EcsWildcard, EcsNotQueryable);
+    ecs_add_id(world, EcsAny, EcsNotQueryable);
+
     /* Tag relationships (relationships that should never have data) */
-    ecs_add_id(world, EcsIsA, EcsTag);
-    ecs_add_id(world, EcsChildOf, EcsTag);
-    ecs_add_id(world, EcsSlotOf, EcsTag);
-    ecs_add_id(world, EcsDependsOn, EcsTag);
-    ecs_add_id(world, EcsFlatten, EcsTag);
-    ecs_add_id(world, EcsDefaultChildComponent, EcsTag);
-    ecs_add_id(world, EcsUnion, EcsTag);
-    ecs_add_id(world, EcsFlag, EcsTag);
-    ecs_add_id(world, EcsWith, EcsTag);
+    ecs_add_id(world, EcsIsA, EcsPairIsTag);
+    ecs_add_id(world, EcsChildOf, EcsPairIsTag);
+    ecs_add_id(world, EcsSlotOf, EcsPairIsTag);
+    ecs_add_id(world, EcsDependsOn, EcsPairIsTag);
+    ecs_add_id(world, EcsFlag, EcsPairIsTag);
+    ecs_add_id(world, EcsWith, EcsPairIsTag);
 
     /* Exclusive properties */
     ecs_add_id(world, EcsChildOf, EcsExclusive);
     ecs_add_id(world, EcsOnDelete, EcsExclusive);
     ecs_add_id(world, EcsOnDeleteTarget, EcsExclusive);
-    ecs_add_id(world, EcsDefaultChildComponent, EcsExclusive);
 
     /* Relationships */
     ecs_add_id(world, EcsChildOf, EcsRelationship);
@@ -3402,6 +3777,7 @@ void flecs_bootstrap(
 
     /* Sync properties of ChildOf and Identifier with bootstrapped flags */
     ecs_add_pair(world, EcsChildOf, EcsOnDeleteTarget, EcsDelete);
+    ecs_add_id(world, EcsChildOf, EcsTrait);
     ecs_add_id(world, EcsChildOf, EcsAcyclic);
     ecs_add_id(world, EcsChildOf, EcsTraversable);
     ecs_add_id(world, EcsChildOf, EcsDontInherit);
@@ -3410,112 +3786,99 @@ void flecs_bootstrap(
     /* Create triggers in internals scope */
     ecs_set_scope(world, EcsFlecsInternals);
 
-    /* Term used to also match prefabs */
-    ecs_term_t match_prefab = { 
-        .id = EcsPrefab, 
-        .oper = EcsOptional,
-        .src.flags = EcsSelf 
-    };
-
     /* Register observers for components/relationship properties. Most observers
      * set flags on an id record when a property is added to a component, which
      * allows for quick property testing in various operations. */
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsFinal, .src.flags = EcsSelf }, match_prefab },
+        .query.terms = {{ .id = EcsFinal, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_register_final
     });
 
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(EcsOnDelete, EcsWildcard), .src.flags = EcsSelf },
-            match_prefab
+        .query.terms = {
+            { .id = ecs_pair(EcsOnDelete, EcsWildcard), .src.id = EcsSelf }
         },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_on_delete
     });
 
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(EcsOnDeleteTarget, EcsWildcard), .src.flags = EcsSelf },
-            match_prefab
+        .query.terms = {
+            { .id = ecs_pair(EcsOnDeleteTarget, EcsWildcard), .src.id = EcsSelf }
         },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_on_delete_object
     });
 
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = EcsTraversable, .src.flags = EcsSelf },
-            match_prefab
-        },
+        .query.terms = { { .id = EcsTraversable, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_traversable
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsExclusive, .src.flags = EcsSelf  }, match_prefab },
+        .query.terms = {{ .id = EcsExclusive, .src.id = EcsSelf  } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_exclusive
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsSymmetric, .src.flags = EcsSelf  }, match_prefab },
+        .query.terms = {{ .id = EcsSymmetric, .src.id = EcsSelf  } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_register_symmetric
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsDontInherit, .src.flags = EcsSelf }, match_prefab },
+        .query.terms = {{ .id = EcsDontInherit, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_register_dont_inherit
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAlwaysOverride, .src.flags = EcsSelf } },
+        .query.terms = {{ .id = EcsAlwaysOverride, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_register_always_override
     });
 
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(EcsWith, EcsWildcard), .src.flags = EcsSelf },
-            match_prefab
-        },
+        .query.terms = {{ .id = EcsCanToggle, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
-        .callback = flecs_register_with
-    });
-
-    ecs_observer(world, {
-        .filter.terms = {{ .id = EcsUnion, .src.flags = EcsSelf }, match_prefab },
-        .events = {EcsOnAdd},
-        .callback = flecs_register_union
+        .callback = flecs_register_can_toggle
     });
 
-    /* Entities used as slot are marked as exclusive to ensure a slot can always
-     * only point to a single entity. */
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(EcsSlotOf, EcsWildcard), .src.flags = EcsSelf },
-            match_prefab
+        .query.terms = {
+            { .id = ecs_pair(EcsWith, EcsWildcard), .src.id = EcsSelf },
         },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
-        .callback = flecs_register_slot_of
+        .callback = flecs_register_with
     });
 
     /* Define observer to make sure that adding a module to a child entity also
      * adds it to the parent. */
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsModule, .src.flags = EcsSelf }, match_prefab},
+        .query.terms = {{ .id = EcsModule, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_ensure_module_tag
     });
 
     /* Observer that tracks whether observers are disabled */
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = EcsObserver, .src.flags = EcsSelf|EcsFilter },
-            { .id = EcsDisabled, .src.flags = EcsSelf },
+        .query.terms = {
+            { .id = EcsObserver, .src.id = EcsSelf, .inout = EcsInOutFilter },
+            { .id = EcsDisabled, .src.id = EcsSelf },
         },
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_disable_observer
@@ -3523,9 +3886,9 @@ void flecs_bootstrap(
 
     /* Observer that tracks whether modules are disabled */
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = EcsModule, .src.flags = EcsSelf|EcsFilter },
-            { .id = EcsDisabled, .src.flags = EcsSelf },
+        .query.terms = {
+            { .id = EcsModule, .src.id = EcsSelf, .inout = EcsInOutFilter },
+            { .id = EcsDisabled, .src.id = EcsSelf },
         },
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_disable_module
@@ -3557,7 +3920,6 @@ void flecs_bootstrap(
     /* Exclusive properties */
     ecs_add_id(world, EcsSlotOf, EcsExclusive);
     ecs_add_id(world, EcsOneOf, EcsExclusive);
-    ecs_add_id(world, EcsFlatten, EcsExclusive);
 
     /* Private properties */
     ecs_add_id(world, ecs_id(EcsPoly), EcsPrivate);
@@ -3578,6 +3940,93 @@ void flecs_bootstrap(
     ecs_log_pop();
 }
 
+/**
+ * @file query/each.c
+ * @brief Simple iterator for a single component id.
+ */
+
+
+ecs_iter_t ecs_each_id(
+    const ecs_world_t *stage,
+    ecs_id_t id)
+{
+    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(id != 0, ECS_INVALID_PARAMETER, NULL);
+
+    const ecs_world_t *world = ecs_get_world(stage);
+
+    flecs_process_pending_tables(world);
+
+    ecs_iter_t it = {
+        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
+        .world = ECS_CONST_CAST(ecs_world_t*, stage),
+        .field_count = 1,
+        .next = ecs_each_next
+    };
+
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return it;
+    }
+
+    ecs_each_iter_t *each_iter = &it.priv_.iter.each;
+    each_iter->ids = id;
+    each_iter->sizes = 0;
+    if (idr->type_info) {
+        each_iter->sizes = idr->type_info->size;
+    }
+
+    each_iter->sources = 0;
+    flecs_table_cache_iter((ecs_table_cache_t*)idr, &each_iter->it);
+
+    return it;
+error:
+    return (ecs_iter_t){0};
+}
+
+bool ecs_each_next(
+    ecs_iter_t *it)
+{
+    ecs_each_iter_t *each_iter = &it->priv_.iter.each;
+    ecs_table_record_t *next = flecs_table_cache_next(
+        &each_iter->it, ecs_table_record_t);
+    it->flags |= EcsIterIsValid;
+    if (next) {
+        ecs_table_t *table = next->hdr.table;
+        it->table = table;
+        it->count = ecs_table_count(table);
+        it->entities = flecs_table_entities_array(table);
+        it->ids = &table->type.array[next->index];
+        it->columns = &each_iter->columns;
+        it->sources = &each_iter->sources;
+        it->sizes = &each_iter->sizes;
+        it->ptrs = &each_iter->ptrs;
+        it->set_fields = 1;
+        each_iter->columns = next->index;
+
+        if (next->column != -1) {
+            each_iter->ptrs = ecs_vec_first(
+                &it->table->data.columns[next->column].data);
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+ecs_iter_t ecs_children(
+    const ecs_world_t *stage,
+    ecs_entity_t parent)
+{
+    return ecs_each_id(stage, ecs_childof(parent));
+}
+
+bool ecs_children_next(
+    ecs_iter_t *it)
+{
+    return ecs_each_next(it);
+}
+
 /**
  * @file entity.c
  * @brief Entity API.
@@ -3592,6 +4041,551 @@ void flecs_bootstrap(
 
 #include <ctype.h>
 
+#ifdef FLECS_SCRIPT
+/**
+ * @file addons/script/script.h
+ * @brief Flecs script implementation.
+ */
+
+#ifndef FLECS_SCRIPT_PRIVATE_H
+#define FLECS_SCRIPT_PRIVATE_H
+
+
+#ifdef FLECS_SCRIPT
+
+#include <ctype.h>
+
+typedef struct ecs_script_scope_t ecs_script_scope_t;
+typedef struct ecs_script_entity_t ecs_script_entity_t;
+
+struct ecs_script_t {
+    ecs_world_t *world;
+    const char *name;
+    const char *code;
+    ecs_allocator_t allocator;
+    ecs_script_scope_t *root;
+    char *token_buffer;
+    int32_t token_buffer_size;
+    int32_t refcount;
+};
+
+typedef struct ecs_script_parser_t ecs_script_parser_t;
+
+/**
+ * @file addons/script/tokenizer.h
+ * @brief Script tokenizer.
+ */
+
+#ifndef FLECS_SCRIPT_TOKENIZER_H
+#define FLECS_SCRIPT_TOKENIZER_H
+
+/* Tokenizer */
+typedef enum ecs_script_token_kind_t {
+    EcsTokEnd = '\0',
+    EcsTokUnknown,
+    EcsTokScopeOpen = '{',
+    EcsTokScopeClose = '}',
+    EcsTokParenOpen = '(',
+    EcsTokParenClose = ')',
+    EcsTokBracketOpen = '[',
+    EcsTokBracketClose = ']',
+    EcsTokMul = '*',
+    EcsTokComma = ',',
+    EcsTokSemiColon = ';',
+    EcsTokColon = ':',
+    EcsTokAssign = '=',
+    EcsTokBitwiseOr = '|',
+    EcsTokNot = '!',
+    EcsTokOptional = '?',
+    EcsTokAnnotation = '@',
+    EcsTokNewline = '\n',
+    EcsTokEq,
+    EcsTokNeq,
+    EcsTokMatch,
+    EcsTokOr,
+    EcsTokIdentifier,
+    EcsTokString,
+    EcsTokNumber,
+    EcsTokKeywordModule,
+    EcsTokKeywordUsing,
+    EcsTokKeywordWith,
+    EcsTokKeywordIf,
+    EcsTokKeywordElse,
+    EcsTokKeywordAssembly,
+    EcsTokKeywordProp,
+    EcsTokKeywordConst,
+} ecs_script_token_kind_t;
+
+typedef struct ecs_script_token_t {
+    const char *value;
+    ecs_script_token_kind_t kind;
+} ecs_script_token_t;
+
+typedef struct ecs_script_tokens_t {
+    int32_t count;
+    ecs_script_token_t tokens[256];
+} ecs_script_tokens_t;
+
+const char* flecs_script_expr(
+    ecs_script_parser_t *parser,
+    const char *ptr,
+    ecs_script_token_t *out,
+    char until);
+
+const char* flecs_script_until(
+    ecs_script_parser_t *parser,
+    const char *ptr,
+    ecs_script_token_t *out,
+    char until);
+
+const char* flecs_script_token_kind_str(
+    ecs_script_token_kind_t kind);
+
+const char* flecs_script_token(
+    ecs_script_parser_t *parser,
+    const char *ptr,
+    ecs_script_token_t *out,
+    bool is_lookahead);
+
+const char* flecs_scan_whitespace(
+    ecs_script_parser_t *parser,
+    const char *pos);
+
+#endif
+
+
+struct ecs_script_parser_t {
+    ecs_script_t *script;
+    ecs_script_scope_t *scope;
+    const char *pos;
+    char *token_cur;
+    bool significant_newline;
+
+    /* For term parser */
+    ecs_term_t *term;
+    ecs_oper_kind_t extra_oper;
+    ecs_term_ref_t *extra_args;
+};
+
+/**
+ * @file addons/script/ast.h
+ * @brief Script AST.
+ */
+
+#ifndef FLECS_SCRIPT_AST_H
+#define FLECS_SCRIPT_AST_H
+
+typedef enum ecs_script_node_kind_t {
+    EcsAstScope,
+    EcsAstTag,
+    EcsAstComponent,
+    EcsAstDefaultComponent,
+    EcsAstVarComponent,
+    EcsAstWithVar,
+    EcsAstWithTag,
+    EcsAstWithComponent,
+    EcsAstWith,
+    EcsAstUsing,
+    EcsAstModule,
+    EcsAstAnnotation,
+    EcsAstAssembly,
+    EcsAstProp,
+    EcsAstConst,
+    EcsAstEntity,
+    EcsAstPairScope,
+    EcsAstIf,
+} ecs_script_node_kind_t;
+
+typedef struct ecs_script_node_t {
+    ecs_script_node_kind_t kind;
+    const char *pos;
+} ecs_script_node_t;
+
+struct ecs_script_scope_t {
+    ecs_script_node_t node;
+    ecs_vec_t stmts;
+    ecs_script_scope_t *parent;
+    ecs_id_t default_component_eval;
+};
+
+typedef struct ecs_script_id_t {
+    const char *first;
+    const char *second;
+    ecs_id_t eval;
+} ecs_script_id_t;
+
+typedef struct ecs_script_tag_t {
+    ecs_script_node_t node;
+    ecs_script_id_t id;
+} ecs_script_tag_t;
+
+typedef struct ecs_script_component_t {
+    ecs_script_node_t node;
+    ecs_script_id_t id;
+    const char *expr;
+    ecs_value_t eval;
+    bool is_collection;
+} ecs_script_component_t;
+
+typedef struct ecs_script_default_component_t {
+    ecs_script_node_t node;
+    const char *expr;
+    ecs_value_t eval;
+} ecs_script_default_component_t;
+
+typedef struct ecs_script_var_component_t {
+    ecs_script_node_t node;
+    const char *name;
+} ecs_script_var_component_t;
+
+struct ecs_script_entity_t {
+    ecs_script_node_t node;
+    const char *kind;
+    const char *name;
+    bool name_is_var;
+    bool kind_w_expr;
+    ecs_script_scope_t *scope;
+
+    // Populated during eval
+    ecs_script_entity_t *parent;
+    ecs_entity_t eval;
+    ecs_entity_t eval_kind;
+};
+
+typedef struct ecs_script_with_t {
+    ecs_script_node_t node;
+    ecs_script_scope_t *expressions;
+    ecs_script_scope_t *scope;
+} ecs_script_with_t;
+
+typedef struct ecs_script_inherit_t {
+    ecs_script_node_t node;
+    ecs_script_scope_t *base_list;
+} ecs_script_inherit_t;
+
+typedef struct ecs_script_pair_scope_t {
+    ecs_script_node_t node;
+    ecs_script_id_t id;
+    ecs_script_scope_t *scope;
+} ecs_script_pair_scope_t;
+
+typedef struct ecs_script_using_t {
+    ecs_script_node_t node;
+    const char *name;
+} ecs_script_using_t;
+
+typedef struct ecs_script_module_t {
+    ecs_script_node_t node;
+    const char *name;
+} ecs_script_module_t;
+
+typedef struct ecs_script_annot_t {
+    ecs_script_node_t node;
+    const char *name;
+    const char *expr;
+} ecs_script_annot_t;
+
+typedef struct ecs_script_assembly_node_t {
+    ecs_script_node_t node;
+    const char *name;
+    ecs_script_scope_t* scope;
+} ecs_script_assembly_node_t;
+
+typedef struct ecs_script_var_node_t {
+    ecs_script_node_t node;
+    const char *name;
+    const char *type;
+    const char *expr;
+} ecs_script_var_node_t;
+
+typedef struct ecs_script_if_t {
+    ecs_script_node_t node;
+    ecs_script_scope_t *if_true;
+    ecs_script_scope_t *if_false;
+    const char *expr;
+} ecs_script_if_t;
+
+#define ecs_script_node(kind, node)\
+    ((ecs_script_##kind##_t*)node)
+
+bool flecs_scope_is_empty(
+    ecs_script_scope_t *scope);
+
+ecs_script_scope_t* flecs_script_insert_scope(
+    ecs_script_parser_t *parser);
+
+ecs_script_entity_t* flecs_script_insert_entity(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_pair_scope_t* flecs_script_insert_pair_scope(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second);
+
+ecs_script_with_t* flecs_script_insert_with(
+    ecs_script_parser_t *parser);
+
+ecs_script_using_t* flecs_script_insert_using(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_module_t* flecs_script_insert_module(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_assembly_node_t* flecs_script_insert_assembly(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_annot_t* flecs_script_insert_annot(
+    ecs_script_parser_t *parser,
+    const char *name,
+    const char *expr);
+
+ecs_script_var_node_t* flecs_script_insert_var(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_tag_t* flecs_script_insert_tag(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_tag_t* flecs_script_insert_pair_tag(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second);
+
+ecs_script_component_t* flecs_script_insert_component(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_component_t* flecs_script_insert_pair_component(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second);
+
+ecs_script_default_component_t* flecs_script_insert_default_component(
+    ecs_script_parser_t *parser);
+
+ecs_script_var_component_t* flecs_script_insert_var_component(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_if_t* flecs_script_insert_if(
+    ecs_script_parser_t *parser);
+
+#endif
+
+/**
+ * @file addons/script/visit.h
+ * @brief Script AST visitor utilities.
+ */
+
+#ifndef FLECS_SCRIPT_VISIT_H
+#define FLECS_SCRIPT_VISIT_H
+
+typedef struct ecs_script_visit_t ecs_script_visit_t;
+
+typedef int (*ecs_visit_action_t)(
+    ecs_script_visit_t *visitor, 
+    ecs_script_node_t *node);
+
+struct ecs_script_visit_t {
+    ecs_script_t *script;
+    ecs_visit_action_t visit;
+    ecs_script_node_t* nodes[256];
+    ecs_script_node_t *prev, *next;
+    int32_t depth;
+};
+
+int ecs_script_visit_(
+    ecs_script_visit_t *visitor,
+    ecs_visit_action_t visit,
+    ecs_script_t *script);
+
+#define ecs_script_visit(script, visitor, visit) \
+    ecs_script_visit_((ecs_script_visit_t*)visitor,\
+        (ecs_visit_action_t)visit,\
+        script)
+
+int ecs_script_visit_node_(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *node);
+
+#define ecs_script_visit_node(visitor, node) \
+    ecs_script_visit_node_((ecs_script_visit_t*)visitor, \
+        (ecs_script_node_t*)node)
+
+int ecs_script_visit_scope_(
+    ecs_script_visit_t *v,
+    ecs_script_scope_t *node);
+
+#define ecs_script_visit_scope(visitor, node) \
+    ecs_script_visit_scope_((ecs_script_visit_t*)visitor, node)
+
+ecs_script_node_t* ecs_script_parent_node_(
+    ecs_script_visit_t *v);
+
+#define ecs_script_parent_node(visitor) \
+    ecs_script_parent_node_((ecs_script_visit_t*)visitor)
+
+ecs_script_scope_t* ecs_script_current_scope_(
+    ecs_script_visit_t *v);
+
+#define ecs_script_current_scope(visitor) \
+    ecs_script_current_scope_((ecs_script_visit_t*)visitor)
+
+ecs_script_node_t* ecs_script_parent_(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *node);
+
+#define ecs_script_parent(visitor, node) \
+    ecs_script_parent_((ecs_script_visit_t*)visitor, (ecs_script_node_t*)node)
+
+ecs_script_node_t* ecs_script_next_node_(
+    ecs_script_visit_t *v);
+
+#define ecs_script_next_node(visitor) \
+    ecs_script_next_node_((ecs_script_visit_t*)visitor)
+
+int32_t ecs_script_node_line_number_(
+    ecs_script_t *script,
+    ecs_script_node_t *node);
+
+#define ecs_script_node_line_number(script, node) \
+    ecs_script_node_line_number_(script, (ecs_script_node_t*)node)
+
+#endif
+
+/**
+ * @file addons/script/visit_eval.h
+ * @brief Script evaluation visitor.
+ */
+
+#ifndef FLECS_SCRIPT_VISIT_EVAL_H
+#define FLECS_SCRIPT_VISIT_EVAL_H
+
+typedef struct ecs_script_eval_visitor_t {
+    ecs_script_visit_t base;
+    ecs_world_t *world;
+    ecs_allocator_t *allocator;
+    ecs_script_assembly_t *assembly;
+    ecs_entity_t module;
+    ecs_entity_t parent;
+    ecs_script_entity_t *entity;
+    ecs_vec_t using;
+    ecs_vec_t with;
+    ecs_vec_t annot;
+    ecs_entity_t with_relationship;
+    int32_t with_relationship_sp;
+    ecs_script_vars_t *vars;
+    ecs_stack_t stack;
+} ecs_script_eval_visitor_t;
+
+void flecs_script_eval_error_(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node,
+    const char *fmt,
+    ...);
+
+#define flecs_script_eval_error(v, node, ...)\
+    flecs_script_eval_error_(v, (ecs_script_node_t*)node, __VA_ARGS__)
+
+ecs_entity_t flecs_script_find_entity(
+    ecs_script_eval_visitor_t *v,
+    ecs_entity_t from,
+    const char *path);
+
+ecs_entity_t flecs_script_create_entity(
+    ecs_script_eval_visitor_t *v,
+    const char *name);
+
+const ecs_type_info_t* flecs_script_get_type_info(
+    ecs_script_eval_visitor_t *v,
+    void *node,
+    ecs_id_t id);
+
+int flecs_script_eval_expr(
+    ecs_script_eval_visitor_t *v,
+    const char *expr,
+    ecs_value_t *value);
+
+int flecs_script_eval_assembly(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_assembly_node_t *assembly);
+
+ecs_script_assembly_t* flecs_script_assembly_init(
+    ecs_script_t *script);
+
+void flecs_script_assembly_fini(
+    ecs_script_t *script,
+    ecs_script_assembly_t *assembly);
+
+void flecs_script_eval_visit_init(
+    ecs_script_t *script,
+    ecs_script_eval_visitor_t *v);
+
+void flecs_script_eval_visit_fini(
+    ecs_script_eval_visitor_t *v);
+
+int flecs_script_eval_node(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node);
+
+#endif
+
+
+struct ecs_script_assembly_t {
+    /* Assembly handle */
+    ecs_entity_t entity;
+
+    /* Assembly AST node */
+    ecs_script_assembly_node_t *node;
+
+    /* Hoisted using statements */
+    ecs_vec_t using_;
+
+    /* Hoisted variables */
+    ecs_vec_t vars;
+
+    /* Default values for props */
+    ecs_vec_t prop_defaults;
+
+    /* Type info for assembly component */
+    const ecs_type_info_t *type_info;
+};
+
+ecs_script_t* flecs_script_new(
+    ecs_world_t *world);
+
+ecs_script_scope_t* flecs_script_scope_new(
+    ecs_script_parser_t *parser);
+
+int flecs_script_visit_free(
+    ecs_script_t *script);
+
+ecs_script_vars_t* flecs_script_vars_push(
+    ecs_script_vars_t *parent,
+    ecs_stack_t *stack,
+    ecs_allocator_t *allocator);
+
+int flecs_terms_parse(
+    ecs_script_t *script,
+    ecs_term_t *terms,
+    int32_t *term_count_out);
+
+const char* flecs_id_parse(
+    const ecs_world_t *world,
+    const char *name,
+    const char *expr,
+    ecs_id_t *id);
+
+#endif // FLECS_SCRIPT
+#endif // FLECS_SCRIPT_PRIVATE_H
+
+#endif
+
 static
 const ecs_entity_t* flecs_bulk_new(
     ecs_world_t *world,
@@ -3637,7 +4631,10 @@ flecs_component_ptr_t flecs_get_component_ptr(
 
     ecs_table_record_t *tr = flecs_table_record_get(world, table, id);
     if (!tr || (tr->column == -1)) {
-        ecs_check(tr == NULL, ECS_NOT_A_COMPONENT, NULL);
+        char *idstr = ecs_id_str(world, id);
+        ecs_check(tr == NULL, ECS_NOT_A_COMPONENT, 
+            "cannot get '%s' as a component", idstr);
+        ecs_os_free(idstr);
         return (flecs_component_ptr_t){0};
     }
 
@@ -3663,8 +4660,8 @@ void* flecs_get_base_component(
     ecs_id_record_t *table_index,
     int32_t recur_depth)
 {
-    /* Cycle detected in IsA relationship */
-    ecs_check(recur_depth < ECS_MAX_RECURSION, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(recur_depth < ECS_MAX_RECURSION, ECS_INVALID_PARAMETER,
+        "cycle detected in IsA relationship");
 
     /* Table (and thus entity) does not have component, look for base */
     if (!(table->flags & EcsTableHasIsA)) {
@@ -3901,16 +4898,6 @@ void flecs_instantiate_children(
         if ((id != ecs_pair(ecs_id(EcsIdentifier), EcsName)) &&
             ECS_PAIR_FIRST(id) != EcsChildOf) 
         {
-            if (id == EcsUnion) {
-                /* This should eventually be handled by the DontInherit property
-                 * but right now there is no way to selectively apply it to
-                 * EcsUnion itself: it would also apply to (Union, *) pairs,
-                 * which would make all union relationships uninheritable. 
-                 * 
-                 * The reason this is explicitly skipped is so that slot 
-                 * instances don't all end up with the Union property. */
-                continue;
-            }
             ecs_table_record_t *tr = &child_table->_->records[i];
             ecs_id_record_t *idr = (ecs_id_record_t*)tr->hdr.cache;
             if (idr->flags & EcsIdDontInherit) {
@@ -3964,7 +4951,6 @@ void flecs_instantiate_children(
     /* Instantiate the prefab child table for each new instance */
     ecs_entity_t *instances = ecs_vec_first(&table->data.entities);
     int32_t child_count = ecs_vec_count(&child_data->entities);
-    bool has_union = child_table->flags & EcsTableHasUnion;
 
     for (i = row; i < count + row; i ++) {
         ecs_entity_t instance = instances[i];
@@ -3988,7 +4974,8 @@ void flecs_instantiate_children(
 #ifdef FLECS_DEBUG
         for (j = 0; j < child_count; j ++) {
             ecs_entity_t child = children[j];        
-            ecs_check(child != instance, ECS_INVALID_PARAMETER, NULL);
+            ecs_check(child != instance, ECS_INVALID_PARAMETER, 
+                "cycle detected in IsA relationship");
         }
 #else
         /* Bit of boilerplate to ensure that we don't get warnings about the
@@ -4001,25 +4988,6 @@ void flecs_instantiate_children(
         const ecs_entity_t *i_children = flecs_bulk_new(world, i_table, NULL, 
             &diff.added, child_count, component_data, false, &child_row, &diff);
 
-        /* If children have union relationships, initialize */
-        if (has_union) {
-            ecs_table__t *meta = child_table->_;
-            ecs_assert(meta != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(i_table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-            int32_t u, u_count = meta->sw_count;
-            for (u = 0; u < u_count; u ++) {
-                ecs_switch_t *src_sw = &meta->sw_columns[i];
-                ecs_switch_t *dst_sw = &i_table->_->sw_columns[i];
-                ecs_vec_t *v_src_values = flecs_switch_values(src_sw);
-                ecs_vec_t *v_dst_values = flecs_switch_values(dst_sw);
-                uint64_t *src_values = ecs_vec_first(v_src_values);
-                uint64_t *dst_values = ecs_vec_first(v_dst_values);
-                for (j = 0; j < child_count; j ++) {
-                    dst_values[j] = src_values[j];
-                }
-            }
-        }
-
         /* If children are slots, add slot relationships to parent */
         if (slot_of) {
             for (j = 0; j < child_count; j ++) {
@@ -4065,43 +5033,6 @@ void flecs_instantiate(
     }
 }
 
-static
-void flecs_set_union(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    int32_t row,
-    int32_t count,    
-    const ecs_type_t *ids)
-{
-    ecs_id_t *array = ids->array;
-    int32_t i, id_count = ids->count;
-
-    for (i = 0; i < id_count; i ++) {
-        ecs_id_t id = array[i];
-
-        if (ECS_HAS_ID_FLAG(id, PAIR)) {
-            ecs_id_record_t *idr = flecs_id_record_get(world, 
-                ecs_pair(EcsUnion, ECS_PAIR_FIRST(id)));
-            if (!idr) {
-                continue;
-            }
-
-            ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-            ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-            int32_t column = tr->index - table->_->sw_offset;
-            ecs_switch_t *sw = &table->_->sw_columns[column];
-            ecs_entity_t union_case = 0;
-            union_case = ecs_pair_second(world, id);
-
-            int32_t r;
-            for (r = 0; r < count; r ++) {
-                flecs_switch_set(sw, row + r, union_case);
-            }
-        }
-    }
-}
-
 static
 void flecs_notify_on_add(
     ecs_world_t *world,
@@ -4117,10 +5048,6 @@ void flecs_notify_on_add(
     if (added->count) {
         ecs_flags32_t table_flags = table->flags;
 
-        if (table_flags & EcsTableHasUnion) {
-            flecs_set_union(world, table, row, count, added);
-        }
-
         if (table_flags & (EcsTableHasOnAdd|EcsTableHasIsA|EcsTableHasTraversable)) {
             flecs_emit(world, world, &(ecs_event_desc_t){
                 .event = EcsOnAdd,
@@ -4456,7 +5383,7 @@ const ecs_entity_t* flecs_bulk_new(
         r->row = ECS_ROW_TO_RECORD(row + i, 0);
     }
 
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
 
     flecs_notify_on_add(world, table, NULL, row, count, &diff->added, 
         (component_data == NULL) ? 0 : EcsEventNoOnSet);
@@ -4509,7 +5436,7 @@ const ecs_entity_t* flecs_bulk_new(
         }
     }
 
-    flecs_defer_end(world, &world->stages[0]);
+    flecs_defer_end(world, world->stages[0]);
 
     if (row_out) {
         *row_out = row;
@@ -4597,11 +5524,12 @@ flecs_component_ptr_t flecs_ensure(
 {
     flecs_component_ptr_t dst = {0};
 
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(id != 0, ECS_INVALID_PARAMETER, NULL);
     ecs_check(r != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check((id & ECS_COMPONENT_MASK) == id || 
-        ECS_HAS_ID_FLAG(id, PAIR), ECS_INVALID_PARAMETER, NULL);
+        ECS_HAS_ID_FLAG(id, PAIR), ECS_INVALID_PARAMETER,
+            "invalid component id specified for ensure");
 
     if (r->table) {
         dst = flecs_get_component_ptr(
@@ -4615,8 +5543,8 @@ flecs_component_ptr_t flecs_ensure(
     flecs_add_id_w_record(world, entity, r, id, true);
 
     /* Flush commands so the pointer we're fetching is stable */
-    flecs_defer_end(world, &world->stages[0]);
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_end(world, world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
 
     ecs_assert(r->table != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(r->table->column_count != 0, ECS_INTERNAL_ERROR, NULL);
@@ -4638,9 +5566,9 @@ void flecs_invoke_hook(
     ecs_entity_t event,
     ecs_iter_action_t hook)
 {
-    int32_t defer = world->stages[0].defer;
+    int32_t defer = world->stages[0]->defer;
     if (defer < 0) {
-        world->stages[0].defer *= -1;
+        world->stages[0]->defer *= -1;
     }
 
     ecs_iter_t it = { .field_count = 1};
@@ -4663,7 +5591,7 @@ void flecs_invoke_hook(
     hook(&it);
     ecs_iter_fini(&it);
 
-    world->stages[0].defer = defer;
+    world->stages[0]->defer = defer;
 }
 
 void flecs_notify_on_set(
@@ -4755,7 +5683,8 @@ bool ecs_commit(
     const ecs_type_t *removed)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!ecs_is_deferred(world), ECS_INVALID_OPERATION, NULL);
+    ecs_check(!ecs_is_deferred(world), ECS_INVALID_OPERATION, 
+        "commit cannot be called on stage or while world is deferred");
 
     ecs_table_t *src_table = NULL;
     if (!record) {
@@ -4804,13 +5733,11 @@ ecs_id_t ecs_get_with(
     return 0;
 }
 
-ecs_entity_t ecs_new_id(
+ecs_entity_t ecs_new(
     ecs_world_t *world)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    const ecs_stage_t *stage = flecs_stage_from_readonly_world(world);
-
     /* It is possible that the world passed to this function is a stage, so
      * make sure we have the actual world. Cast away const since this is one of
      * the few functions that may modify the world while it is in readonly mode,
@@ -4819,14 +5746,15 @@ ecs_entity_t ecs_new_id(
         ECS_CONST_CAST(ecs_world_t*, ecs_get_world(world));
 
     ecs_entity_t entity;
-    if (stage->async || (unsafe_world->flags & EcsWorldMultiThreaded)) {
-        /* When using an async stage or world is in multithreading mode, make
-         * sure OS API has threading functions initialized */
-        ecs_assert(ecs_os_has_threading(), ECS_INVALID_OPERATION, NULL);
+    if (unsafe_world->flags & EcsWorldMultiThreaded) {
+        /* When world is in multithreading mode, make sure OS API has threading 
+         * functions initialized */
+        ecs_assert(ecs_os_has_threading(), ECS_INVALID_OPERATION, 
+            "thread safe id creation unavailable: threading API not available");
 
         /* Can't atomically increase number above max int */
         ecs_assert(flecs_entities_max_id(unsafe_world) < UINT_MAX, 
-            ECS_INVALID_OPERATION, NULL);
+            ECS_INVALID_OPERATION, "thread safe ids exhausted");
         entity = (ecs_entity_t)ecs_os_ainc(
             (int32_t*)&flecs_entities_max_id(unsafe_world));
     } else {
@@ -4870,7 +5798,7 @@ ecs_entity_t ecs_new_low_id(
 
     if (!id || id >= FLECS_HI_COMPONENT_ID) {
         /* If the low component ids are depleted, return a regular entity id */
-        id = ecs_new_id(unsafe_world);
+        id = ecs_new(unsafe_world);
     } else {
         flecs_entities_ensure(world, id);
     }
@@ -4887,60 +5815,27 @@ ecs_entity_t ecs_new_w_id(
     ecs_id_t id)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!id || ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);    
-    ecs_entity_t entity = ecs_new_id(world);
-
-    ecs_id_t ids[3];
-    ecs_type_t to_add = { .array = ids, .count = 0 };
+    ecs_entity_t entity = ecs_new(world);
 
-    if (id) {
-        ids[to_add.count ++] = id;
-    }
-
-    ecs_id_t with = stage->with;
-    if (with) {
-        ids[to_add.count ++] = with;
-    }
-
-    ecs_entity_t scope = stage->scope;
-    if (scope) {
-        if (!id || !ECS_HAS_RELATION(id, EcsChildOf)) {
-            ids[to_add.count ++] = ecs_pair(EcsChildOf, scope);
-        }
+    if (flecs_defer_add(stage, entity, id)) {
+        return entity;
     }
-    if (to_add.count) {
-        if (flecs_defer_add(stage, entity, to_add.array[0])) {
-            int i;
-            for (i = 1; i < to_add.count; i ++) {
-                flecs_defer_add(stage, entity, to_add.array[i]);
-            }
-            return entity;
-        }
 
-        int32_t i, count = to_add.count;
-        ecs_table_t *table = &world->store.root;
-        
-        ecs_table_diff_builder_t diff = ECS_TABLE_DIFF_INIT;
-        flecs_table_diff_builder_init(world, &diff);
-        for (i = 0; i < count; i ++) {
-            table = flecs_find_table_add(
-                world, table, to_add.array[i], &diff);
-        }
+    ecs_table_diff_builder_t diff_builder = ECS_TABLE_DIFF_INIT;
+    flecs_table_diff_builder_init(world, &diff_builder);
+    ecs_table_t *table = flecs_find_table_add(
+        world, &world->store.root, id, &diff_builder);
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        ecs_table_diff_t table_diff;
-        flecs_table_diff_build_noalloc(&diff, &table_diff);
-        ecs_record_t *r = flecs_entities_get(world, entity);
-        flecs_new_entity(world, entity, r, table, &table_diff, true, true);
-        flecs_table_diff_builder_fini(world, &diff);
-    } else {
-        if (flecs_defer_cmd(stage)) {
-            return entity;
-        }
+    ecs_table_diff_t diff;
+    flecs_table_diff_build_noalloc(&diff_builder, &diff);
+    ecs_record_t *r = flecs_entities_get(world, entity);
+    flecs_new_entity(world, entity, r, table, &diff, true, 0);
+    flecs_table_diff_builder_fini(world, &diff_builder);
 
-        flecs_entities_ensure(world, entity);
-    }
     flecs_defer_end(world, stage);
 
     return entity;
@@ -4955,82 +5850,83 @@ ecs_entity_t ecs_new_w_table(
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
     flecs_stage_from_world(&world);    
-    ecs_entity_t entity = ecs_new_id(world);
+    ecs_entity_t entity = ecs_new(world);
     ecs_record_t *r = flecs_entities_get(world, entity);
 
     ecs_table_diff_t table_diff = { .added = table->type };
-    flecs_new_entity(world, entity, r, table, &table_diff, true, true);
+    flecs_new_entity(world, entity, r, table, &table_diff, true, 0);
     return entity;
 error:
     return 0;
 }
 
-#ifdef FLECS_PARSER
+static
+void flecs_copy_id(
+    ecs_world_t *world,
+    ecs_record_t *r,
+    ecs_id_t id,
+    size_t size,
+    void *dst_ptr,
+    void *src_ptr,
+    const ecs_type_info_t *ti)
+{
+    ecs_check(dst_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(src_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    ecs_copy_t copy = ti->hooks.copy;
+    if (copy) {
+        copy(dst_ptr, src_ptr, 1, ti);
+    } else {
+        ecs_os_memcpy(dst_ptr, src_ptr, flecs_utosize(size));
+    }
+
+    flecs_table_mark_dirty(world, r->table, id);
+
+    ecs_table_t *table = r->table;
+    if (table->flags & EcsTableHasOnSet || ti->hooks.on_set) {
+        ecs_type_t ids = { .array = &id, .count = 1 };
+        flecs_notify_on_set(
+            world, table, ECS_RECORD_TO_ROW(r->row), 1, &ids, true);
+    }
+error:
+    return;
+}
 
 /* Traverse table graph by either adding or removing identifiers parsed from the
  * passed in expression. */
 static
-ecs_table_t *flecs_traverse_from_expr(
+int flecs_traverse_from_expr(
     ecs_world_t *world,
-    ecs_table_t *table,
     const char *name,
     const char *expr,
-    ecs_table_diff_builder_t *diff,
-    bool replace_and,
-    bool *error)
+    ecs_vec_t *ids)
 {
+#ifdef FLECS_SCRIPT
     const char *ptr = expr;
     if (ptr) {
-        ecs_term_t term = {0};
-        while (ptr[0] && (ptr = ecs_parse_term(
-            world, name, expr, ptr, &term, NULL, NULL, false)))
-        {
-            if (!ecs_term_is_initialized(&term)) {
+        ecs_id_t id = 0;
+        while (ptr[0] && (ptr = flecs_id_parse(world, name, ptr, &id))) {
+            if (!id) {
                 break;
             }
-
-            if (!(term.first.flags & (EcsSelf|EcsUp))) {
-                term.first.flags = EcsSelf;
-            }
-            if (!(term.second.flags & (EcsSelf|EcsUp))) {
-                term.second.flags = EcsSelf;
-            }
-            if (!(term.src.flags & (EcsSelf|EcsUp))) {
-                term.src.flags = EcsSelf;
-            }
-
-            if (ecs_term_finalize(world, &term)) {
-                ecs_term_fini(&term);
-                if (error) {
-                    *error = true;
-                }
-                return NULL;
-            }
-
-            if (!ecs_id_is_valid(world, term.id)) {
-                ecs_term_fini(&term);
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "invalid term for add expression");
-                return NULL;
-            }
-
-            if (term.oper == EcsAnd || !replace_and) {
-                /* Regular AND expression */
-                table = flecs_find_table_add(world, table, term.id, diff);
-            }
-
-            ecs_term_fini(&term);
+            ecs_vec_append_t(&world->allocator, ids, ecs_id_t)[0] = id;
         }
 
         if (!ptr) {
-            if (error) {
-                *error = true;
-            }
-            return NULL;
+            goto error;
         }
     }
-
-    return table;
+    return 0;
+#else
+    (void)world;
+    (void)name;
+    (void)expr;
+    (void)ids;
+    ecs_err("cannot parse component expression: script addon required");
+    goto error;
+#endif
+error:
+    return -1;
 }
 
 /* Add/remove components based on the parsed expression. This operation is 
@@ -5040,45 +5936,27 @@ void flecs_defer_from_expr(
     ecs_world_t *world,
     ecs_entity_t entity,
     const char *name,
-    const char *expr,
-    bool is_add,
-    bool replace_and)
+    const char *expr)
 {
+#ifdef FLECS_SCRIPT
     const char *ptr = expr;
     if (ptr) {
-        ecs_term_t term = {0};
-        while (ptr[0] && (ptr = ecs_parse_term(world, name, expr, ptr, &term, 
-            NULL, NULL, false))) 
-        {
-            if (!ecs_term_is_initialized(&term)) {
+        ecs_id_t id = 0;
+        while (ptr[0] && (ptr = flecs_id_parse(world, name, ptr, &id))) {
+            if (!id) {
                 break;
             }
-
-            if (ecs_term_finalize(world, &term)) {
-                return;
-            }
-
-            if (!ecs_id_is_valid(world, term.id)) {
-                ecs_term_fini(&term);
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "invalid term for add expression");
-                return;
-            }
-
-            if (term.oper == EcsAnd || !replace_and) {
-                /* Regular AND expression */
-                if (is_add) {
-                    ecs_add_id(world, entity, term.id);
-                } else {
-                    ecs_remove_id(world, entity, term.id);
-                }
-            }
-
-            ecs_term_fini(&term);
+            ecs_add_id(world, entity, id);
         }
     }
-}
+#else
+    (void)world;
+    (void)entity;
+    (void)name;
+    (void)expr;
+    ecs_err("cannot parse component expression: script addon required");
 #endif
+}
 
 /* If operation is not deferred, add components by finding the target
  * table and moving the entity towards it. */
@@ -5090,51 +5968,70 @@ int flecs_traverse_add(
     const ecs_entity_desc_t *desc,
     ecs_entity_t scope,
     ecs_id_t with,
-    bool flecs_new_entity,
+    bool new_entity,
     bool name_assigned)
 {
     const char *sep = desc->sep;
     const char *root_sep = desc->root_sep;
     ecs_table_diff_builder_t diff = ECS_TABLE_DIFF_INIT;
     flecs_table_diff_builder_init(world, &diff);
+    ecs_vec_t ids;
+
+    /* Add components from the 'add_expr' expression. Look up before naming 
+     * entity, so that expression can't resolve to self. */
+    ecs_vec_init_t(&world->allocator, &ids, ecs_id_t, 0);
+    if (desc->add_expr && ecs_os_strcmp(desc->add_expr, "0")) {
+        if (flecs_traverse_from_expr(world, name, desc->add_expr, &ids)) {
+            goto error;
+        }
+    }
+
+    /* If a name is provided but not yet assigned, add the Name component */
+    if (name && !name_assigned) {
+        ecs_add_path_w_sep(world, result, scope, name, sep, root_sep);
+    } else if (new_entity && scope) {
+        ecs_add_pair(world, result, EcsChildOf, scope);
+    }
 
     /* Find existing table */
     ecs_table_t *src_table = NULL, *table = NULL;
     ecs_record_t *r = flecs_entities_get(world, result);
     table = r->table;
 
-    /* If a name is provided but not yet assigned, add the Name component */
-    if (name && !name_assigned) {
-        table = flecs_find_table_add(world, table, 
-            ecs_pair(ecs_id(EcsIdentifier), EcsName), &diff);
+    /* Add components from the 'add' array */
+    if (desc->add) {
+        int32_t i = 0;
+        ecs_id_t id;
+
+        while ((id = desc->add[i ++])) {
+            table = flecs_find_table_add(world, table, id, &diff);
+        }
     }
 
-    /* Add components from the 'add' id array */
-    int32_t i = 0;
-    ecs_id_t id;
-    const ecs_id_t *ids = desc->add;
-    while ((i < FLECS_ID_DESC_MAX) && (id = ids[i ++])) {
-        bool should_add = true;
-        if (ECS_HAS_ID_FLAG(id, PAIR) && ECS_PAIR_FIRST(id) == EcsChildOf) {
-            scope = ECS_PAIR_SECOND(id);
-            if ((!desc->id && desc->name) || (name && !name_assigned)) {
-                /* If name is added to entity, pass scope to add_path instead
-                 * of adding it to the table. The provided name may have nested
-                 * elements, in which case the parent provided here is not the
-                 * parent the entity will end up with. */
-                should_add = false;
-            }
-        }
-        if (should_add) {
+    /* Add components from the 'set' array */
+    if (desc->set) {
+        int32_t i = 0;
+        ecs_id_t id;
+
+        while ((id = desc->set[i ++].type)) {
             table = flecs_find_table_add(world, table, id, &diff);
         }
     }
 
+    /* Add ids from .expr */
+    {
+        int32_t i, count = ecs_vec_count(&ids);
+        ecs_id_t *expr_ids = ecs_vec_first(&ids);
+        for (i = 0; i < count; i ++) {
+            table = flecs_find_table_add(world, table, expr_ids[i], &diff);
+        }
+    }
+
     /* Find destination table */
     /* If this is a new entity without a name, add the scope. If a name is
      * provided, the scope will be added by the add_path_w_sep function */
-    if (flecs_new_entity) {
-        if (flecs_new_entity && scope && !name && !name_assigned) {
+    if (new_entity) {
+        if (new_entity && scope && !name && !name_assigned) {
             table = flecs_find_table_add(
                 world, table, ecs_pair(EcsChildOf, scope), &diff);
         }
@@ -5143,38 +6040,17 @@ int flecs_traverse_add(
         }
     }
 
-    /* Add components from the 'add_expr' expression */
-    if (desc->add_expr && ecs_os_strcmp(desc->add_expr, "0")) {
-#ifdef FLECS_PARSER
-        bool error = false;
-        table = flecs_traverse_from_expr(
-            world, table, name, desc->add_expr, &diff, true, &error);
-        if (error) {
-            flecs_table_diff_builder_fini(world, &diff);
-            return -1;
-        }
-#else
-        ecs_abort(ECS_UNSUPPORTED, "parser addon is not available");
-#endif
-    }
-
     /* Commit entity to destination table */
     if (src_table != table) {
-        flecs_defer_begin(world, &world->stages[0]);
+        flecs_defer_begin(world, world->stages[0]);
         ecs_table_diff_t table_diff;
         flecs_table_diff_build_noalloc(&diff, &table_diff);
         flecs_commit(world, result, r, table, &table_diff, true, 0);
         flecs_table_diff_builder_fini(world, &diff);
-        flecs_defer_end(world, &world->stages[0]);
-    }
-
-    /* Set name */
-    if (name && !name_assigned) {
-        ecs_add_path_w_sep(world, result, scope, name, sep, root_sep);
-        ecs_assert(ecs_get_name(world, result) != NULL,
-            ECS_INTERNAL_ERROR, NULL);
+        flecs_defer_end(world, world->stages[0]);
     }
 
+    /* Set symbol */
     if (desc->symbol && desc->symbol[0]) {
         const char *sym = ecs_get_symbol(world, result);
         if (sym) {
@@ -5185,8 +6061,36 @@ int flecs_traverse_add(
         }
     }
 
+    /* Set component values */
+    if (desc->set) {
+        table = r->table;
+        ecs_assert(r->table != NULL, ECS_INTERNAL_ERROR, NULL);
+        int32_t i = 0, row = ECS_RECORD_TO_ROW(r->row);
+        const ecs_value_t *v;
+        
+        flecs_defer_begin(world, world->stages[0]);
+
+        while ((void)(v = &desc->set[i ++]), v->type) {
+            if (!v->ptr) {
+                continue;
+            }
+            ecs_assert(ECS_RECORD_TO_ROW(r->row) == row, ECS_INTERNAL_ERROR, NULL);
+            flecs_component_ptr_t ptr = flecs_get_component_ptr(
+                world, table, row, v->type);
+            ecs_check(ptr.ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+            flecs_copy_id(world, r, v->type, 
+                flecs_itosize(ptr.ti->size), ptr.ptr, v->ptr, ptr.ti);
+        }
+
+        flecs_defer_end(world, world->stages[0]);
+    }
+
     flecs_table_diff_builder_fini(world, &diff);
+    ecs_vec_fini_t(&world->allocator, &ids, ecs_id_t);
     return 0;
+error:
+    ecs_vec_fini_t(&world->allocator, &ids, ecs_id_t);
+    return -1;
 }
 
 /* When in deferred mode, we need to add/remove components one by one using
@@ -5218,31 +6122,42 @@ void flecs_deferred_add_remove(
     }
 
     /* Add components from the 'add' id array */
-    int32_t i = 0;
-    ecs_id_t id;
-    const ecs_id_t *ids = desc->add;
-    while ((i < FLECS_ID_DESC_MAX) && (id = ids[i ++])) {
-        bool defer = true;
-        if (ECS_HAS_ID_FLAG(id, PAIR) && ECS_PAIR_FIRST(id) == EcsChildOf) {
-            scope = ECS_PAIR_SECOND(id);
-            if (name && (!desc->id || !name_assigned)) {
-                /* New named entities are created by temporarily going out of
-                 * readonly mode to ensure no duplicates are created. */
-                defer = false;
-            }
-        }
-        if (defer) {
-            ecs_add_id(world, entity, id);
+    if (desc->add) {
+        int32_t i = 0;
+        ecs_id_t id;
+
+        while ((id = desc->add[i ++])) {
+            bool defer = true;
+            if (ECS_HAS_ID_FLAG(id, PAIR) && ECS_PAIR_FIRST(id) == EcsChildOf) {
+                scope = ECS_PAIR_SECOND(id);
+                if (name && (!desc->id || !name_assigned)) {
+                    /* New named entities are created by temporarily going out of
+                     * readonly mode to ensure no duplicates are created. */
+                    defer = false;
+                }
+            }
+            if (defer) {
+                ecs_add_id(world, entity, id);
+            }
+        }
+    }
+
+    /* Set component values */
+    if (desc->set) {
+        int32_t i = 0;
+        const ecs_value_t *v;
+        while ((void)(v = &desc->set[i ++]), v->type) {
+            if (v->ptr) {
+                ecs_set_id(world, entity, v->type, 0, v->ptr);
+            } else {
+                ecs_add_id(world, entity, v->type);
+            }
         }
     }
 
     /* Add components from the 'add_expr' expression */
     if (desc->add_expr) {
-#ifdef FLECS_PARSER
-        flecs_defer_from_expr(world, entity, name, desc->add_expr, true, true);
-#else
-        ecs_abort(ECS_UNSUPPORTED, "parser addon is not available");
-#endif
+        flecs_defer_from_expr(world, entity, name, desc->add_expr);
     }
 
     int32_t thread_count = ecs_get_stage_count(world);
@@ -5274,13 +6189,35 @@ ecs_entity_t ecs_entity_init(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_entity_desc_t was not initialized to zero");
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
     ecs_entity_t scope = stage->scope;
     ecs_id_t with = ecs_get_with(world);
     ecs_entity_t result = desc->id;
 
+#ifdef FLECS_DEBUG
+    if (desc->add) {
+        ecs_id_t id;
+        int32_t i = 0;
+        while ((id = desc->add[i ++])) {
+            if (ECS_HAS_ID_FLAG(id, PAIR) && 
+                (ECS_PAIR_FIRST(id) == EcsChildOf))
+            {
+                if (desc->name) {
+                    ecs_check(false, ECS_INVALID_PARAMETER, "%s: cannot set parent in "
+                        "ecs_entity_desc_t::add, use ecs_entity_desc_t::parent",
+                            desc->name);
+                } else {
+                    ecs_check(false, ECS_INVALID_PARAMETER, "cannot set parent in "
+                        "ecs_entity_desc_t::add, use ecs_entity_desc_t::parent");
+                }
+            }
+        }
+    }
+#endif
+
     const char *name = desc->name;
     const char *sep = desc->sep;
     if (!sep) {
@@ -5329,21 +6266,15 @@ ecs_entity_t ecs_entity_init(
         }
     }
 
+    /* Parent field takes precedence over scope */
+    if (desc->parent) {
+        scope = desc->parent;
+    }
+
     /* Find or create entity */
     if (!result) {
         if (name) {
             /* If add array contains a ChildOf pair, use it as scope instead */
-            const ecs_id_t *ids = desc->add;
-            ecs_id_t id;
-            int32_t i = 0;
-            while ((i < FLECS_ID_DESC_MAX) && (id = ids[i ++])) {
-                if (ECS_HAS_ID_FLAG(id, PAIR) && 
-                    (ECS_PAIR_FIRST(id) == EcsChildOf))
-                {
-                    scope = ECS_PAIR_SECOND(id);
-                }
-            }
-
             result = ecs_lookup_path_w_sep(
                 world, scope, name, sep, root_sep, false);
             if (result) {
@@ -5355,7 +6286,7 @@ ecs_entity_t ecs_entity_init(
             if (desc->use_low_id) {
                 result = ecs_new_low_id(world);
             } else {
-                result = ecs_new_id(world);
+                result = ecs_new(world);
             }
             flecs_new_entity = true;
             ecs_assert(ecs_get_type(world, result) == NULL,
@@ -5428,10 +6359,11 @@ const ecs_entity_t* ecs_bulk_init(
     ecs_world_t *world,
     const ecs_bulk_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INTERNAL_ERROR, NULL);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_bulk_desc_t was not initialized to zero");
 
     const ecs_entity_t *entities = desc->entities;
     int32_t count = desc->count;
@@ -5516,7 +6448,8 @@ ecs_entity_t ecs_component_init(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_component_desc_t was not initialized to 0");
 
     /* If existing entity is provided, check if it is already registered as a
      * component and matches the size/alignment. This can prevent having to
@@ -5579,9 +6512,6 @@ ecs_entity_t ecs_component_init(
         world->info.last_component_id = result + 1;
     }
 
-    /* Ensure components cannot be deleted */
-    ecs_add_pair(world, result, EcsOnDelete, EcsPanic);
-
     flecs_resume_readonly(world, &readonly_state);
     
     ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL);
@@ -5970,8 +6900,7 @@ void flecs_remove_from_table(
                 ecs_log_pop_3();
             }
 
-            flecs_table_merge(world, dst_table, table, 
-                &dst_table->data, &table->data);
+            flecs_table_merge(world, dst_table, table);
         }
     }
 
@@ -6013,9 +6942,9 @@ bool flecs_on_delete_clear_tables(
             }
 
             /* Run commands so children get notified before parent is deleted */
-            if (world->stages[0].defer) {
-                flecs_defer_end(world, &world->stages[0]);
-                flecs_defer_begin(world, &world->stages[0]);
+            if (world->stages[0]->defer) {
+                flecs_defer_end(world, world->stages[0]);
+                flecs_defer_begin(world, world->stages[0]);
             }
 
             /* User code (from triggers) could have enqueued more ids to delete,
@@ -6287,7 +7216,7 @@ ecs_entity_t ecs_clone(
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
     if (!dst) {
-        dst = ecs_new_id(world);
+        dst = ecs_new(world);
     }
 
     if (flecs_defer_clone(stage, dst, src, copy_value)) {
@@ -6310,7 +7239,7 @@ ecs_entity_t ecs_clone(
     ecs_type_t dst_type = dst_table->type;
     ecs_table_diff_t diff = { .added = dst_type };
     ecs_record_t *dst_r = flecs_entities_get(world, dst);
-    flecs_new_entity(world, dst, dst_r, dst_table, &diff, true, true);
+    flecs_new_entity(world, dst, dst_r, dst_table, &diff, true, 0);
     int32_t row = ECS_RECORD_TO_ROW(dst_r->row);
 
     if (copy_value) {
@@ -6340,8 +7269,6 @@ const void* ecs_get_id(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(flecs_stage_from_readonly_world(world)->async == false, 
-        ECS_INVALID_PARAMETER, NULL);
 
     world = ecs_get_world(world);
 
@@ -6378,8 +7305,6 @@ void* ecs_get_mut_id(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(flecs_stage_from_readonly_world(world)->async == false, 
-        ECS_INVALID_PARAMETER, NULL);
 
     world = ecs_get_world(world);
 
@@ -6418,7 +7343,8 @@ void* ecs_ensure_id(
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
     if (flecs_defer_cmd(stage)) {
-        return flecs_defer_set(world, stage, EcsCmdEnsure, entity, id, 0, NULL);
+        return flecs_defer_set(
+            world, stage, EcsCmdEnsure, entity, id, 0, NULL, NULL);
     }
 
     ecs_record_t *r = flecs_entities_get(world, entity);
@@ -6444,7 +7370,7 @@ void* ecs_ensure_modified_id(
     ecs_stage_t *stage = flecs_stage_from_world(&world);
     ecs_check(flecs_defer_cmd(stage), ECS_INVALID_PARAMETER, NULL);
 
-    return flecs_defer_set(world, stage, EcsCmdSet, entity, id, 0, NULL);
+    return flecs_defer_set(world, stage, EcsCmdSet, entity, id, 0, NULL, NULL);
 error:
     return NULL;
 }
@@ -6606,7 +7532,7 @@ bool flecs_ref_needs_sync(
 {
     ecs_assert(ref != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    return !tr || tr->hdr.table != table || ref->table_id != table->id;
+    return !tr || ref->table_id != table->id || tr->hdr.table != table;
 }
 
 void ecs_ref_update(
@@ -6646,10 +7572,10 @@ void* ecs_ref_get_id(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ref != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ref->entity != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ref->id != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ref->record != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(id == ref->id, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ref->entity != 0, ECS_INVALID_PARAMETER, "ref not initialized");
+    ecs_check(ref->id != 0, ECS_INVALID_PARAMETER, "ref not initialized");
+    ecs_check(ref->record != NULL, ECS_INVALID_PARAMETER, "ref not initialized");
+    ecs_check(id == ref->id, ECS_INVALID_PARAMETER, "ref not initialized");
 
     ecs_record_t *r = ref->record;
     ecs_table_t *table = r->table;
@@ -6681,26 +7607,35 @@ void* ecs_ref_get_id(
 void* ecs_emplace_id(
     ecs_world_t *world,
     ecs_entity_t entity,
-    ecs_id_t id)
+    ecs_id_t id,
+    bool *is_new)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!ecs_has_id(world, entity, id), ECS_INVALID_PARAMETER, 
+    ecs_check(is_new || !ecs_has_id(world, entity, id), ECS_INVALID_PARAMETER, 
         "cannot emplace a component the entity already has");
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
 
     if (flecs_defer_cmd(stage)) {
-        return flecs_defer_set(world, stage, EcsCmdEmplace, entity, id, 0, NULL);
+        return flecs_defer_set(
+            world, stage, EcsCmdEmplace, entity, id, 0, NULL, is_new);
     }
 
     ecs_record_t *r = flecs_entities_get(world, entity);
+    ecs_table_t *table = r->table;
     flecs_add_id_w_record(world, entity, r, id, false /* Add without ctor */);
     flecs_defer_end(world, stage);
 
     void *ptr = flecs_get_component(world, r->table, ECS_RECORD_TO_ROW(r->row), id);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, 
+        "emplaced component was removed during operation, make sure to not "
+        "remove component T in on_add(T) hook/OnAdd(T) observer");
+
+    if (is_new) {
+        *is_new = table != r->table;
+    }
 
     return ptr;
 error:
@@ -6773,7 +7708,7 @@ void ecs_modified_id(
 }
 
 static
-void flecs_copy_ptr_w_id(
+void flecs_set_id_copy(
     ecs_world_t *world,
     ecs_stage_t *stage,
     ecs_entity_t entity,
@@ -6783,42 +7718,20 @@ void flecs_copy_ptr_w_id(
 {
     if (flecs_defer_cmd(stage)) {
         flecs_defer_set(world, stage, EcsCmdSet, entity, id, 
-            flecs_utosize(size), ptr);
+            flecs_utosize(size), ptr, NULL);
         return;
     }
 
     ecs_record_t *r = flecs_entities_get(world, entity);
     flecs_component_ptr_t dst = flecs_ensure(world, entity, id, r);
-    const ecs_type_info_t *ti = dst.ti;
-    ecs_check(dst.ptr != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (ptr) {
-        ecs_copy_t copy = ti->hooks.copy;
-        if (copy) {
-            copy(dst.ptr, ptr, 1, ti);
-        } else {
-            ecs_os_memcpy(dst.ptr, ptr, flecs_utosize(size));
-        }
-    } else {
-        ecs_os_memset(dst.ptr, 0, size);
-    }
-
-    flecs_table_mark_dirty(world, r->table, id);
-
-    ecs_table_t *table = r->table;
-    if (table->flags & EcsTableHasOnSet || ti->hooks.on_set) {
-        ecs_type_t ids = { .array = &id, .count = 1 };
-        flecs_notify_on_set(
-            world, table, ECS_RECORD_TO_ROW(r->row), 1, &ids, true);
-    }
+    flecs_copy_id(world, r, id, size, dst.ptr, ptr, dst.ti);
 
     flecs_defer_end(world, stage);
-error:
-    return;
 }
 
 static
-void flecs_move_ptr_w_id(
+void flecs_set_id_move(
     ecs_world_t *world,
     ecs_stage_t *stage,
     ecs_entity_t entity,
@@ -6829,7 +7742,7 @@ void flecs_move_ptr_w_id(
 {
     if (flecs_defer_cmd(stage)) {
         flecs_defer_set(world, stage, cmd_kind, entity, id, 
-            flecs_utosize(size), ptr);
+            flecs_utosize(size), ptr, NULL);
         return;
     }
 
@@ -6868,7 +7781,7 @@ void flecs_move_ptr_w_id(
     return;
 }
 
-ecs_entity_t ecs_set_id(
+void ecs_set_id(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_id_t id,
@@ -6876,27 +7789,33 @@ ecs_entity_t ecs_set_id(
     const void *ptr)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!entity || ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
 
-    if (!entity) {
-        entity = ecs_new_id(world);
-        ecs_entity_t scope = stage->scope;
-        if (scope) {
-            ecs_add_pair(world, entity, EcsChildOf, scope);
-        }
-    }
-
     /* Safe to cast away const: function won't modify if move arg is false */
-    flecs_copy_ptr_w_id(world, stage, entity, id, size, 
+    flecs_set_id_copy(world, stage, entity, id, size, 
         ECS_CONST_CAST(void*, ptr));
-    return entity;
 error:
-    return 0;
+    return;
 }
 
+#if defined(FLECS_DEBUG) || defined(FLECS_KEEP_ASSERT)
+static
+bool flecs_can_toggle(
+    ecs_world_t *world,
+    ecs_id_t id)
+{
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return false;
+    }
+
+    return (idr->flags & EcsIdCanToggle) != 0;
+}
+#endif
+
 void ecs_enable_id(
     ecs_world_t *world,
     ecs_entity_t entity,
@@ -6906,6 +7825,8 @@ void ecs_enable_id(
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_is_valid(world, entity), ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(flecs_can_toggle(world, id), ECS_INVALID_OPERATION, 
+        "add CanToggle trait to component");
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
 
@@ -6935,7 +7856,7 @@ void ecs_enable_id(
     index -= table->_->bs_offset;
     ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
 
-    /* Data cannot be NULl, since entity is stored in the table */
+    /* Data cannot be NULL, since entity is stored in the table */
     ecs_bitset_t *bs = &table->_->bs_columns[index];
     ecs_assert(bs != NULL, ECS_INTERNAL_ERROR, NULL);
 
@@ -7009,7 +7930,7 @@ bool ecs_has_id(
         }
     }
 
-    if (!(table->flags & (EcsTableHasUnion|EcsTableHasIsA))) {
+    if (!(table->flags & EcsTableHasIsA)) {
         return false;
     }
 
@@ -7020,20 +7941,6 @@ bool ecs_has_id(
         return false;
     }
 
-    table = tr->hdr.table;
-    if ((table->flags & EcsTableHasUnion) && ECS_HAS_ID_FLAG(id, PAIR) &&
-        ECS_PAIR_SECOND(id) != EcsWildcard) 
-    {
-        if (ECS_PAIR_FIRST(table->type.array[column]) == EcsUnion) {
-            ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_switch_t *sw = &table->_->sw_columns[
-                column - table->_->sw_offset];
-            int32_t row = ECS_RECORD_TO_ROW(r->row);
-            uint64_t value = flecs_switch_get(sw, row);
-            return value == ecs_pair_second(world, id);
-        }
-    }
-    
     return true;
 error:
     return false;
@@ -7073,30 +7980,11 @@ ecs_entity_t ecs_get_target(
         tr = flecs_id_record_get_table(idr, table);
     }
     if (!tr) {
-        if (table->flags & EcsTableHasUnion) {
-            wc = ecs_pair(EcsUnion, rel);
-            tr = flecs_table_record_get(world, table, wc);
-            if (tr) {
-                ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-                ecs_switch_t *sw = &table->_->sw_columns[
-                    tr->index - table->_->sw_offset];
-                int32_t row = ECS_RECORD_TO_ROW(r->row);
-                return flecs_switch_get(sw, row);
-                
-            }
-        }
-
         if (!idr || !(idr->flags & EcsIdDontInherit)) {
             goto look_in_base;
         } else {
             return 0;
         }
-    } else if (table->flags & EcsTableHasTarget) {
-        EcsFlattenTarget *tf = ecs_table_get_id(world, table, 
-            ecs_pair_t(EcsFlattenTarget, rel), ECS_RECORD_TO_ROW(r->row));
-        if (tf) {
-            return ecs_record_get_entity(tf->target);
-        }
     }
 
     if (index >= tr->count) {
@@ -7197,7 +8085,9 @@ int32_t ecs_get_depth(
     ecs_entity_t rel)
 {
     ecs_check(ecs_is_valid(world, rel), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_has_id(world, rel, EcsAcyclic), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_has_id(world, rel, EcsAcyclic), ECS_INVALID_PARAMETER, 
+        "cannot safely determine depth for relationship that is not acyclic "
+            "(add Acyclic property to relationship)");
 
     ecs_table_t *table = ecs_get_table(world, entity);
     if (table) {
@@ -7209,195 +8099,6 @@ int32_t ecs_get_depth(
     return -1;
 }
 
-static
-ecs_entity_t flecs_id_for_depth(
-    ecs_world_t *world,
-    int32_t depth)
-{
-    ecs_vec_t *depth_ids = &world->store.depth_ids;
-    int32_t i, count = ecs_vec_count(depth_ids);
-    for (i = count; i <= depth; i ++) {
-        ecs_entity_t *el = ecs_vec_append_t(
-            &world->allocator, depth_ids, ecs_entity_t);
-        el[0] = ecs_new_w_pair(world, EcsChildOf, EcsFlecsInternals);
-        ecs_map_val_t *v = ecs_map_ensure(&world->store.entity_to_depth, el[0]);
-        v[0] = flecs_ito(uint64_t, i);
-    }
-
-    return ecs_vec_get_t(&world->store.depth_ids, ecs_entity_t, depth)[0];
-}
-
-static
-int32_t flecs_depth_for_id(
-    ecs_world_t *world,
-    ecs_entity_t id)
-{
-    ecs_map_val_t *v = ecs_map_get(&world->store.entity_to_depth, id);
-    ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL);
-    return flecs_uto(int32_t, v[0]);
-}
-
-static
-int32_t flecs_depth_for_flat_table(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    ecs_assert(table->flags & EcsTableHasTarget, ECS_INTERNAL_ERROR, NULL);
-    ecs_id_t id;
-    int32_t col = ecs_search(world, table, 
-        ecs_pair(EcsFlatten, EcsWildcard), &id);
-    ecs_assert(col != -1, ECS_INTERNAL_ERROR, NULL);
-    (void)col;
-    return flecs_depth_for_id(world, ECS_PAIR_SECOND(id));
-}
-
-static
-void flecs_flatten(
-    ecs_world_t *world,
-    ecs_entity_t root,
-    ecs_id_t pair,
-    int32_t depth,
-    const ecs_flatten_desc_t *desc)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, pair);
-    if (!idr) {
-        return;
-    }
-
-    ecs_entity_t depth_id = flecs_id_for_depth(world, depth);
-    ecs_id_t root_pair = ecs_pair(EcsChildOf, root);
-    ecs_id_t tgt_pair = ecs_pair_t(EcsFlattenTarget, EcsChildOf);
-    ecs_id_t depth_pair = ecs_pair(EcsFlatten, depth_id);
-    ecs_id_t name_pair = ecs_pair_t(EcsIdentifier, EcsName);
-
-    ecs_entity_t rel = ECS_PAIR_FIRST(pair);
-    ecs_table_cache_iter_t it;
-    if (idr && flecs_table_cache_iter((ecs_table_cache_t*)idr, &it)) {
-        const ecs_table_record_t *tr;
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            ecs_table_t *table = tr->hdr.table;
-            int32_t i, count = ecs_table_count(table);
-            bool has_tgt = table->flags & EcsTableHasTarget;
-            flecs_emit_propagate_invalidate(world, table, 0, count);
-
-            ecs_entity_t *entities = table->data.entities.array;
-            for (i = 0; i < count; i ++) {
-                ecs_record_t *record = flecs_entities_get(world, entities[i]);
-                ecs_flags32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
-                if (flags & EcsEntityIsTarget) {
-                    flecs_flatten(world, root, ecs_pair(rel, entities[i]), 
-                        depth + 1, desc);
-                }
-            }
-
-            ecs_table_diff_t tmpdiff;
-            ecs_table_diff_builder_t diff = ECS_TABLE_DIFF_INIT;
-            flecs_table_diff_builder_init(world, &diff);
-            ecs_table_t *dst;
-
-            dst = flecs_table_traverse_add(world, table, &root_pair, &tmpdiff);
-            flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-
-            dst = flecs_table_traverse_add(world, dst, &tgt_pair, &tmpdiff);
-            flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-
-            if (!desc->lose_depth) {
-                if (!has_tgt) {
-                    dst = flecs_table_traverse_add(world, dst, &depth_pair, &tmpdiff);
-                    flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-                } else {
-                    int32_t cur_depth = flecs_depth_for_flat_table(world, table);
-                    cur_depth += depth;
-                    ecs_entity_t e_depth = flecs_id_for_depth(world, cur_depth);
-                    ecs_id_t p_depth = ecs_pair(EcsFlatten, e_depth);
-                    dst = flecs_table_traverse_add(world, dst, &p_depth, &tmpdiff);
-                    flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-                }
-            }
-
-            if (!desc->keep_names) {
-                dst = flecs_table_traverse_remove(world, dst, &name_pair, &tmpdiff);
-                flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-            }
-
-            int32_t dst_count = ecs_table_count(dst);
-
-            ecs_table_diff_t td;
-            flecs_table_diff_build_noalloc(&diff, &td);
-            flecs_notify_on_remove(world, table, NULL, 0, count, &td.removed);
-            flecs_table_merge(world, dst, table, &dst->data, &table->data);
-            flecs_notify_on_add(world, dst, NULL, dst_count, count,
-                &td.added, 0);
-            flecs_table_diff_builder_fini(world, &diff);
-
-            EcsFlattenTarget *fh = ecs_table_get_id(world, dst, tgt_pair, 0);
-            ecs_assert(fh != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(count != 0, ECS_INTERNAL_ERROR, NULL);
-            int32_t remain = count;
-
-            for (i = dst_count; i < (dst_count + count); i ++) {
-                if (!has_tgt) {
-                    fh[i].target = flecs_entities_get_any(world, 
-                        ECS_PAIR_SECOND(pair));
-                    fh[i].count = remain;
-                    remain --;
-                }
-                ecs_assert(fh[i].target != NULL, ECS_INTERNAL_ERROR, NULL);
-            }
-        }
-    }
-
-    ecs_delete_with(world, pair);
-    flecs_id_record_release(world, idr);
-}
-
-void ecs_flatten(
-    ecs_world_t *world,
-    ecs_id_t pair,
-    const ecs_flatten_desc_t *desc)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_entity_t rel = ECS_PAIR_FIRST(pair);
-    ecs_entity_t root = ecs_pair_second(world, pair);
-    ecs_flatten_desc_t private_desc = {0};
-    if (desc) {
-        private_desc = *desc;
-    }
-    
-    ecs_run_aperiodic(world, 0);
-    ecs_defer_begin(world);
-
-    ecs_id_record_t *idr = flecs_id_record_get(world, pair);
-
-    ecs_table_cache_iter_t it;
-    if (idr && flecs_table_cache_iter((ecs_table_cache_t*)idr, &it)) {
-        const ecs_table_record_t *tr;
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            ecs_table_t *table = tr->hdr.table;
-            if (!table->_->traversable_count) {
-                continue;
-            }
-
-            if (table->flags & EcsTableIsPrefab) {
-                continue;
-            }
-
-            int32_t i, count = ecs_table_count(table);
-            ecs_entity_t *entities = table->data.entities.array;
-            for (i = 0; i < count; i ++) {
-                ecs_record_t *record = flecs_entities_get(world, entities[i]);
-                ecs_flags32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
-                if (flags & EcsEntityIsTarget) {
-                    flecs_flatten(world, root, ecs_pair(rel, entities[i]), 1, 
-                        &private_desc);
-                }
-            }
-        }
-    }
-
-    ecs_defer_end(world);
-}
-
 static
 const char* flecs_get_identifier(
     const ecs_world_t *world,
@@ -7450,7 +8151,7 @@ ecs_entity_t flecs_set_identifier(
     ecs_check(entity != 0 || name != NULL, ECS_INVALID_PARAMETER, NULL);
 
     if (!entity) {
-        entity = ecs_new_id(world);
+        entity = ecs_new(world);
     }
 
     if (!name) {
@@ -7624,7 +8325,8 @@ void ecs_make_alive(
     /* The entity index can be mutated while in staged/readonly mode, as long as
      * the world is not multithreaded. */
     ecs_assert(!(world->flags & EcsWorldMultiThreaded), 
-        ECS_INVALID_OPERATION, NULL);
+        ECS_INVALID_OPERATION, 
+            "cannot make entity alive while world is in multithreaded mode");
 
     /* Check if a version of the provided id is alive */
     ecs_entity_t any = ecs_get_alive(world, (uint32_t)entity);
@@ -7634,7 +8336,8 @@ void ecs_make_alive(
     }
 
     /* If the id is currently alive but did not match the argument, fail */
-    ecs_check(!any, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!any, ECS_INVALID_PARAMETER, 
+        "entity is alive with different generation");
 
     /* Set generation if not alive. The sparse set checks if the provided
      * id matches its own generation which is necessary for alive ids. This
@@ -7657,7 +8360,7 @@ void ecs_make_alive_id(
     ecs_world_t *world,
     ecs_id_t id)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     if (ECS_HAS_ID_FLAG(id, PAIR)) {
         ecs_entity_t r = ECS_PAIR_FIRST(id);
         ecs_entity_t o = ECS_PAIR_SECOND(id);
@@ -7696,6 +8399,26 @@ bool ecs_exists(
     return false;
 }
 
+void ecs_set_generation(
+    ecs_world_t *world,
+    ecs_entity_t entity_with_generation)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION,
+        "cannot change entity generation when world is in readonly mode");
+    ecs_assert(!(ecs_is_deferred(world)), ECS_INVALID_OPERATION, 
+        "cannot change entity generation while world is deferred");
+
+    flecs_entities_make_alive(world, entity_with_generation);
+
+    ecs_record_t *r = flecs_entities_get(world, entity_with_generation);
+    if (r && r->table) {
+        int32_t row = ECS_RECORD_TO_ROW(r->row);
+        ecs_entity_t *entities = r->table->data.entities.array;
+        entities[row] = entity_with_generation;
+    }
+}
+
 ecs_table_t* ecs_get_table(
     const ecs_world_t *world,
     ecs_entity_t entity)
@@ -7742,7 +8465,7 @@ const ecs_type_info_t* ecs_get_type_info(
         }
         if (!idr) {
             ecs_entity_t first = ecs_pair_first(world, id);
-            if (!first || !ecs_has_id(world, first, EcsTag)) {
+            if (!first || !ecs_has_id(world, first, EcsPairIsTag)) {
                 idr = flecs_id_record_get(world, 
                     ecs_pair(EcsWildcard, ECS_PAIR_SECOND(id)));
                 if (!idr || !idr->type_info) {
@@ -7786,7 +8509,7 @@ bool ecs_id_is_tag(
             if (ECS_PAIR_FIRST(id) != EcsWildcard) {
                 ecs_entity_t rel = ecs_pair_first(world, id);
                 if (ecs_is_valid(world, rel)) {
-                    if (ecs_has_id(world, rel, EcsTag)) {
+                    if (ecs_has_id(world, rel, EcsPairIsTag)) {
                         return true;
                     }
                 } else {
@@ -7812,24 +8535,6 @@ bool ecs_id_is_tag(
     return false;
 }
 
-bool ecs_id_is_union(
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    if (!ECS_IS_PAIR(id)) {
-        return false;
-    } else if (ECS_PAIR_FIRST(id) == EcsUnion) {
-        return true;
-    } else {
-        ecs_entity_t first = ecs_pair_first(world, id);
-        if (ecs_has_id(world, first, EcsUnion)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
 int32_t ecs_count_id(
     const ecs_world_t *world,
     ecs_entity_t id)
@@ -7841,16 +8546,8 @@ int32_t ecs_count_id(
     }
 
     int32_t count = 0;
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t) { 
-        .id = id,
-        .src.flags = EcsSelf,
-        .flags = EcsTermMatchDisabled|EcsTermMatchPrefab
-    });
-
-    it.flags |= EcsIterNoData;
-    it.flags |= EcsIterEvalTables;
-
-    while (ecs_term_next(&it)) {
+    ecs_iter_t it = ecs_each_id(world, id);
+    while (ecs_each_next(&it)) {
         count += it.count;
     }
 
@@ -7910,9 +8607,11 @@ void ecs_defer_suspend(
     ecs_world_t *world)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_is_deferred(world), ECS_INVALID_OPERATION, NULL);
+    ecs_check(ecs_is_deferred(world), ECS_INVALID_OPERATION, 
+        "world/stage must be deferred before it can be suspended");
     ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_check(stage->defer > 0, ECS_INVALID_OPERATION, NULL);
+    ecs_check(stage->defer > 0, ECS_INVALID_OPERATION, 
+        "world/stage is already suspended");
     stage->defer = -stage->defer;
 error:
     return;
@@ -7923,7 +8622,8 @@ void ecs_defer_resume(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_check(stage->defer < 0, ECS_INVALID_OPERATION, NULL);
+    ecs_check(stage->defer < 0, ECS_INVALID_OPERATION,
+        "world/stage must be suspended before it can be resumed");
     stage->defer = -stage->defer;
 error:
     return;
@@ -7938,9 +8638,6 @@ const char* ecs_id_flag_str(
     if (ECS_HAS_ID_FLAG(entity, TOGGLE)) {
         return "TOGGLE";
     } else
-    if (ECS_HAS_ID_FLAG(entity, AND)) {
-        return "AND";
-    } else
     if (ECS_HAS_ID_FLAG(entity, OVERRIDE)) {
         return "OVERRIDE";
     } else {
@@ -7967,11 +8664,6 @@ void ecs_id_str_buf(
         ecs_strbuf_appendch(buf, '|');
     }
 
-    if (ECS_HAS_ID_FLAG(id, AND)) {
-        ecs_strbuf_appendstr(buf, ecs_id_flag_str(ECS_AND));
-        ecs_strbuf_appendch(buf, '|');
-    }
-
     if (ECS_HAS_ID_FLAG(id, PAIR)) {
         ecs_entity_t rel = ECS_PAIR_FIRST(id);
         ecs_entity_t obj = ECS_PAIR_SECOND(id);
@@ -8397,9 +9089,9 @@ void flecs_cmd_batch_for_entity(
 
     /* Move entity to destination table in single operation */
     flecs_table_diff_build_noalloc(diff, &table_diff);
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
     flecs_commit(world, entity, r, table, &table_diff, true, 0);
-    flecs_defer_end(world, &world->stages[0]);
+    flecs_defer_end(world, world->stages[0]);
     flecs_table_diff_builder_clear(diff);
 
     /* If the batch contains set commands, copy the component value from the 
@@ -8488,8 +9180,8 @@ bool flecs_defer_end(
     ecs_world_t *world,
     ecs_stage_t *stage)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_assert(stage, ecs_stage_t);
+    flecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(stage, ecs_stage_t);
 
     if (stage->defer < 0) {
         /* Defer suspending makes it possible to do operations on the storage
@@ -8503,8 +9195,8 @@ bool flecs_defer_end(
         /* Test whether we're flushing to another queue or whether we're 
          * flushing to the storage */
         bool merge_to_world = false;
-        if (ecs_poly_is(world, ecs_world_t)) {
-            merge_to_world = world->stages[0].defer == 0;
+        if (flecs_poly_is(world, ecs_world_t)) {
+            merge_to_world = world->stages[0]->defer == 0;
         }
 
         ecs_stage_t *dst_stage = flecs_stage_from_world(&world);
@@ -8581,22 +9273,26 @@ bool flecs_defer_end(
                     world->info.cmd.other_count ++;
                     break;
                 case EcsCmdSet:
-                    flecs_move_ptr_w_id(world, dst_stage, e, 
+                    flecs_set_id_move(world, dst_stage, e, 
                         cmd->id, flecs_itosize(cmd->is._1.size), 
                         cmd->is._1.value, kind);
                     world->info.cmd.set_count ++;
                     break;
                 case EcsCmdEmplace:
                     if (merge_to_world) {
-                        ecs_emplace_id(world, e, id);
+                        bool is_new;
+                        ecs_emplace_id(world, e, id, &is_new);
+                        if (!is_new) {
+                            kind = EcsCmdEnsure;
+                        }
                     }
-                    flecs_move_ptr_w_id(world, dst_stage, e, 
+                    flecs_set_id_move(world, dst_stage, e, 
                         cmd->id, flecs_itosize(cmd->is._1.size), 
                         cmd->is._1.value, kind);
                     world->info.cmd.ensure_count ++;
                     break;
                 case EcsCmdEnsure:
-                    flecs_move_ptr_w_id(world, dst_stage, e, 
+                    flecs_set_id_move(world, dst_stage, e, 
                         cmd->id, flecs_itosize(cmd->is._1.size), 
                         cmd->is._1.value, kind);
                     world->info.cmd.ensure_count ++;
@@ -8728,656 +9424,6 @@ bool flecs_defer_purge(
     return false;
 }
 
-/**
- * @file entity_filter.c
- * @brief Filters that are applied to entities in a table.
- * 
- * After a table has been matched by a query, additional filters may have to
- * be applied before returning entities to the application. The two scenarios
- * under which this happens are queries for union relationship pairs (entities
- * for multiple targets are stored in the same table) and toggles (components 
- * that are enabled/disabled with a bitset).
- */
-
-
-static
-int flecs_entity_filter_find_smallest_term(
-    ecs_table_t *table,
-    ecs_entity_filter_iter_t *iter)
-{
-    ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-    flecs_switch_term_t *sw_terms = ecs_vec_first(&iter->entity_filter->sw_terms);
-    int32_t i, count = ecs_vec_count(&iter->entity_filter->sw_terms);
-    int32_t min = INT_MAX, index = 0;
-
-    for (i = 0; i < count; i ++) {
-        /* The array with sparse queries for the matched table */
-        flecs_switch_term_t *sparse_column = &sw_terms[i];
-
-        /* Pointer to the switch column struct of the table */
-        ecs_switch_t *sw = sparse_column->sw_column;
-
-        /* If the sparse column pointer hadn't been retrieved yet, do it now */
-        if (!sw) {
-            /* Get the table column index from the signature column index */
-            int32_t table_column_index = iter->columns[
-                sparse_column->signature_column_index];
-
-            /* Translate the table column index to switch column index */
-            table_column_index -= table->_->sw_offset;
-            ecs_assert(table_column_index >= 1, ECS_INTERNAL_ERROR, NULL);
-
-            /* Get the sparse column */
-            sw = sparse_column->sw_column = 
-                &table->_->sw_columns[table_column_index - 1];
-        }
-
-        /* Find the smallest column */
-        int32_t case_count = flecs_switch_case_count(sw, sparse_column->sw_case);
-        if (case_count < min) {
-            min = case_count;
-            index = i + 1;
-        }
-    }
-
-    return index;
-}
-
-static
-int flecs_entity_filter_switch_next(
-    ecs_table_t *table,
-    ecs_entity_filter_iter_t *iter,
-    bool filter)
-{
-    bool first_iteration = false;
-    int32_t switch_smallest;
-
-    if (!(switch_smallest = iter->sw_smallest)) {
-        switch_smallest = iter->sw_smallest = 
-            flecs_entity_filter_find_smallest_term(table, iter);
-        first_iteration = true;
-    }
-
-    switch_smallest -= 1;
-
-    flecs_switch_term_t *columns = ecs_vec_first(&iter->entity_filter->sw_terms);
-    flecs_switch_term_t *column = &columns[switch_smallest];
-    ecs_switch_t *sw, *sw_smallest = column->sw_column;
-    ecs_entity_t case_smallest = column->sw_case;
-
-    /* Find next entity to iterate in sparse column */
-    int32_t first, sparse_first = iter->sw_offset;
-
-    if (!filter) {
-        if (first_iteration) {
-            first = flecs_switch_first(sw_smallest, case_smallest);
-        } else {
-            first = flecs_switch_next(sw_smallest, sparse_first);
-        }
-    } else {
-        int32_t cur_first = iter->range.offset, cur_count = iter->range.count;
-        first = cur_first;
-        while (flecs_switch_get(sw_smallest, first) != case_smallest) {
-            first ++;
-            if (first >= (cur_first + cur_count)) {
-                first = -1;
-                break;
-            }
-        }
-    }
-
-    if (first == -1) {
-        goto done;
-    }
-
-    /* Check if entity matches with other sparse columns, if any */
-    int32_t i, count = ecs_vec_count(&iter->entity_filter->sw_terms);
-    do {
-        for (i = 0; i < count; i ++) {
-            if (i == switch_smallest) {
-                /* Already validated this one */
-                continue;
-            }
-
-            column = &columns[i];
-            sw = column->sw_column;
-
-            if (flecs_switch_get(sw, first) != column->sw_case) {
-                first = flecs_switch_next(sw_smallest, first);
-                if (first == -1) {
-                    goto done;
-                }
-            }
-        }
-    } while (i != count);
-
-    iter->range.offset = iter->sw_offset = first;
-    iter->range.count = 1;
-
-    return 0;
-done:
-    /* Iterated all elements in the sparse list, we should move to the
-     * next matched table. */
-    iter->sw_smallest = 0;
-    iter->sw_offset = 0;
-
-    return -1;
-}
-
-#define BS_MAX ((uint64_t)0xFFFFFFFFFFFFFFFF)
-
-static
-int flecs_entity_filter_bitset_next(
-    ecs_table_t *table,
-    ecs_entity_filter_iter_t *iter)
-{
-    /* Precomputed single-bit test */
-    static const uint64_t bitmask[64] = {
-    (uint64_t)1 << 0, (uint64_t)1 << 1, (uint64_t)1 << 2, (uint64_t)1 << 3,
-    (uint64_t)1 << 4, (uint64_t)1 << 5, (uint64_t)1 << 6, (uint64_t)1 << 7,
-    (uint64_t)1 << 8, (uint64_t)1 << 9, (uint64_t)1 << 10, (uint64_t)1 << 11,
-    (uint64_t)1 << 12, (uint64_t)1 << 13, (uint64_t)1 << 14, (uint64_t)1 << 15,
-    (uint64_t)1 << 16, (uint64_t)1 << 17, (uint64_t)1 << 18, (uint64_t)1 << 19,
-    (uint64_t)1 << 20, (uint64_t)1 << 21, (uint64_t)1 << 22, (uint64_t)1 << 23,
-    (uint64_t)1 << 24, (uint64_t)1 << 25, (uint64_t)1 << 26, (uint64_t)1 << 27,  
-    (uint64_t)1 << 28, (uint64_t)1 << 29, (uint64_t)1 << 30, (uint64_t)1 << 31,
-    (uint64_t)1 << 32, (uint64_t)1 << 33, (uint64_t)1 << 34, (uint64_t)1 << 35,  
-    (uint64_t)1 << 36, (uint64_t)1 << 37, (uint64_t)1 << 38, (uint64_t)1 << 39,
-    (uint64_t)1 << 40, (uint64_t)1 << 41, (uint64_t)1 << 42, (uint64_t)1 << 43,
-    (uint64_t)1 << 44, (uint64_t)1 << 45, (uint64_t)1 << 46, (uint64_t)1 << 47,  
-    (uint64_t)1 << 48, (uint64_t)1 << 49, (uint64_t)1 << 50, (uint64_t)1 << 51,
-    (uint64_t)1 << 52, (uint64_t)1 << 53, (uint64_t)1 << 54, (uint64_t)1 << 55,  
-    (uint64_t)1 << 56, (uint64_t)1 << 57, (uint64_t)1 << 58, (uint64_t)1 << 59,
-    (uint64_t)1 << 60, (uint64_t)1 << 61, (uint64_t)1 << 62, (uint64_t)1 << 63
-    };
-
-    /* Precomputed test to verify if remainder of block is set (or not) */
-    static const uint64_t bitmask_remain[64] = {
-    BS_MAX, BS_MAX - (BS_MAX >> 63), BS_MAX - (BS_MAX >> 62),
-    BS_MAX - (BS_MAX >> 61), BS_MAX - (BS_MAX >> 60), BS_MAX - (BS_MAX >> 59),
-    BS_MAX - (BS_MAX >> 58), BS_MAX - (BS_MAX >> 57), BS_MAX - (BS_MAX >> 56), 
-    BS_MAX - (BS_MAX >> 55), BS_MAX - (BS_MAX >> 54), BS_MAX - (BS_MAX >> 53), 
-    BS_MAX - (BS_MAX >> 52), BS_MAX - (BS_MAX >> 51), BS_MAX - (BS_MAX >> 50), 
-    BS_MAX - (BS_MAX >> 49), BS_MAX - (BS_MAX >> 48), BS_MAX - (BS_MAX >> 47), 
-    BS_MAX - (BS_MAX >> 46), BS_MAX - (BS_MAX >> 45), BS_MAX - (BS_MAX >> 44), 
-    BS_MAX - (BS_MAX >> 43), BS_MAX - (BS_MAX >> 42), BS_MAX - (BS_MAX >> 41), 
-    BS_MAX - (BS_MAX >> 40), BS_MAX - (BS_MAX >> 39), BS_MAX - (BS_MAX >> 38), 
-    BS_MAX - (BS_MAX >> 37), BS_MAX - (BS_MAX >> 36), BS_MAX - (BS_MAX >> 35), 
-    BS_MAX - (BS_MAX >> 34), BS_MAX - (BS_MAX >> 33), BS_MAX - (BS_MAX >> 32), 
-    BS_MAX - (BS_MAX >> 31), BS_MAX - (BS_MAX >> 30), BS_MAX - (BS_MAX >> 29), 
-    BS_MAX - (BS_MAX >> 28), BS_MAX - (BS_MAX >> 27), BS_MAX - (BS_MAX >> 26), 
-    BS_MAX - (BS_MAX >> 25), BS_MAX - (BS_MAX >> 24), BS_MAX - (BS_MAX >> 23), 
-    BS_MAX - (BS_MAX >> 22), BS_MAX - (BS_MAX >> 21), BS_MAX - (BS_MAX >> 20), 
-    BS_MAX - (BS_MAX >> 19), BS_MAX - (BS_MAX >> 18), BS_MAX - (BS_MAX >> 17), 
-    BS_MAX - (BS_MAX >> 16), BS_MAX - (BS_MAX >> 15), BS_MAX - (BS_MAX >> 14), 
-    BS_MAX - (BS_MAX >> 13), BS_MAX - (BS_MAX >> 12), BS_MAX - (BS_MAX >> 11), 
-    BS_MAX - (BS_MAX >> 10), BS_MAX - (BS_MAX >> 9), BS_MAX - (BS_MAX >> 8), 
-    BS_MAX - (BS_MAX >> 7), BS_MAX - (BS_MAX >> 6), BS_MAX - (BS_MAX >> 5), 
-    BS_MAX - (BS_MAX >> 4), BS_MAX - (BS_MAX >> 3), BS_MAX - (BS_MAX >> 2),
-    BS_MAX - (BS_MAX >> 1)
-    };
-
-    int32_t i, count = ecs_vec_count(&iter->entity_filter->bs_terms);
-    flecs_bitset_term_t *terms = ecs_vec_first(&iter->entity_filter->bs_terms);
-    int32_t bs_offset = table->_->bs_offset;
-    int32_t first = iter->bs_offset;
-    int32_t last = 0;
-
-    for (i = 0; i < count; i ++) {
-        flecs_bitset_term_t *column = &terms[i];
-        ecs_bitset_t *bs = terms[i].bs_column;
-
-        if (!bs) {
-            int32_t index = column->column_index;
-            ecs_assert((index - bs_offset >= 0), ECS_INTERNAL_ERROR, NULL);
-            bs = &table->_->bs_columns[index - bs_offset];
-            terms[i].bs_column = bs;
-        }
-        
-        int32_t bs_elem_count = bs->count;
-        int32_t bs_block = first >> 6;
-        int32_t bs_block_count = ((bs_elem_count - 1) >> 6) + 1;
-
-        if (bs_block >= bs_block_count) {
-            goto done;
-        }
-
-        uint64_t *data = bs->data;
-        int32_t bs_start = first & 0x3F;
-
-        /* Step 1: find the first non-empty block */
-        uint64_t v = data[bs_block];
-        uint64_t remain = bitmask_remain[bs_start];
-        while (!(v & remain)) {
-            /* If no elements are remaining, move to next block */
-            if ((++bs_block) >= bs_block_count) {
-                /* No non-empty blocks left */
-                goto done;
-            }
-
-            bs_start = 0;
-            remain = BS_MAX; /* Test the full block */
-            v = data[bs_block];
-        }
-
-        /* Step 2: find the first non-empty element in the block */
-        while (!(v & bitmask[bs_start])) {
-            bs_start ++;
-
-            /* Block was not empty, so bs_start must be smaller than 64 */
-            ecs_assert(bs_start < 64, ECS_INTERNAL_ERROR, NULL);
-        }
-
-        /* Step 3: Find number of contiguous enabled elements after start */
-        int32_t bs_end = bs_start, bs_block_end = bs_block;
-
-        remain = bitmask_remain[bs_end];
-        while ((v & remain) == remain) {
-            bs_end = 0;
-            bs_block_end ++;
-
-            if (bs_block_end == bs_block_count) {
-                break;
-            }
-
-            v = data[bs_block_end];
-            remain = BS_MAX; /* Test the full block */
-        }
-
-        /* Step 4: find remainder of enabled elements in current block */
-        if (bs_block_end != bs_block_count) {
-            while ((v & bitmask[bs_end])) {
-                bs_end ++;
-            }
-        }
-
-        /* Block was not 100% occupied, so bs_start must be smaller than 64 */
-        ecs_assert(bs_end < 64, ECS_INTERNAL_ERROR, NULL);
-
-        /* Step 5: translate to element start/end and make sure that each column
-         * range is a subset of the previous one. */
-        first = bs_block * 64 + bs_start;
-        int32_t cur_last = bs_block_end * 64 + bs_end;
-        
-        /* No enabled elements found in table */
-        if (first == cur_last) {
-            goto done;
-        }
-
-        /* If multiple bitsets are evaluated, make sure each subsequent range
-         * is equal or a subset of the previous range */
-        if (i) {
-            /* If the first element of a subsequent bitset is larger than the
-             * previous last value, start over. */
-            if (first >= last) {
-                i = -1;
-                continue;
-            }
-
-            /* Make sure the last element of the range doesn't exceed the last
-             * element of the previous range. */
-            if (cur_last > last) {
-                cur_last = last;
-            }
-        }
-
-        last = cur_last;
-        int32_t elem_count = last - first;
-
-        /* Make sure last element doesn't exceed total number of elements in 
-         * the table */
-        if (elem_count > (bs_elem_count - first)) {
-            elem_count = (bs_elem_count - first);
-            if (!elem_count) {
-                iter->bs_offset = 0;
-                goto done;
-            }
-        }
-        
-        iter->range.offset = first;
-        iter->range.count = elem_count;
-        iter->bs_offset = first;
-    }
-
-    /* Keep track of last processed element for iteration */ 
-    iter->bs_offset = last;
-
-    return 0;
-done:
-    iter->sw_smallest = 0;
-    iter->sw_offset = 0;
-    return -1;
-}
-
-#undef BS_MAX
-
-static
-int32_t flecs_get_flattened_target(
-    ecs_world_t *world,
-    EcsFlattenTarget *cur,
-    ecs_entity_t rel,
-    ecs_id_t id,
-    ecs_entity_t *src_out,
-    ecs_table_record_t **tr_out)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return -1;
-    }
-
-    ecs_record_t *r = cur->target;
-    ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_table_t *table = r->table;
-    if (!table) {
-        return -1;
-    }
-
-    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-    if (tr) {
-        *src_out = ecs_record_get_entity(r);
-        *tr_out = tr;
-        return tr->index;
-    }
-
-    if (table->flags & EcsTableHasTarget) {
-        int32_t col = table->column_map[table->_->ft_offset];
-        ecs_assert(col != -1, ECS_INTERNAL_ERROR, NULL);
-        EcsFlattenTarget *next = table->data.columns[col].data.array;
-        next = ECS_ELEM_T(next, EcsFlattenTarget, ECS_RECORD_TO_ROW(r->row));
-        return flecs_get_flattened_target(
-            world, next, rel, id, src_out, tr_out);
-    }
-
-    return ecs_search_relation(
-        world, table, 0, id, rel, EcsSelf|EcsUp, src_out, NULL, tr_out);
-}
-
-void flecs_entity_filter_init(
-    ecs_world_t *world,
-    ecs_entity_filter_t **entity_filter,
-    const ecs_filter_t *filter,
-    const ecs_table_t *table,
-    ecs_id_t *ids,
-    int32_t *columns)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(entity_filter != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(filter != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(ids != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(columns != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_allocator_t *a = &world->allocator;
-    ecs_entity_filter_t ef;
-    ecs_os_zeromem(&ef);
-    ecs_vec_t *sw_terms = &ef.sw_terms;
-    ecs_vec_t *bs_terms = &ef.bs_terms;
-    ecs_vec_t *ft_terms = &ef.ft_terms;
-    if (*entity_filter) {
-        ef.sw_terms = (*entity_filter)->sw_terms;
-        ef.bs_terms = (*entity_filter)->bs_terms;
-        ef.ft_terms = (*entity_filter)->ft_terms;
-    }
-    ecs_vec_reset_t(a, sw_terms, flecs_switch_term_t);
-    ecs_vec_reset_t(a, bs_terms, flecs_bitset_term_t);
-    ecs_vec_reset_t(a, ft_terms, flecs_flat_table_term_t);
-    ecs_term_t *terms = filter->terms;
-    int32_t i, term_count = filter->term_count;
-    bool has_filter = false;
-    ef.flat_tree_column = -1;
-
-    /* Look for union fields */
-    if (table->flags & EcsTableHasUnion) {
-        for (i = 0; i < term_count; i ++) {
-            if (ecs_term_match_0(&terms[i])) {
-                continue;
-            }
-
-            ecs_id_t id = terms[i].id;
-            if (ECS_HAS_ID_FLAG(id, PAIR) && ECS_PAIR_SECOND(id) == EcsWildcard) {
-                continue;
-            }
-            
-            int32_t field = terms[i].field_index;
-            int32_t column = columns[field];
-            if (column <= 0) {
-                continue;
-            }
-
-            ecs_id_t table_id = table->type.array[column - 1];
-            if (ECS_PAIR_FIRST(table_id) != EcsUnion) {
-                continue;
-            }
-
-            flecs_switch_term_t *el = ecs_vec_append_t(a, sw_terms, 
-                flecs_switch_term_t);
-            el->signature_column_index = field;
-            el->sw_case = ecs_pair_second(world, id);
-            el->sw_column = NULL;
-            ids[field] = id;
-            has_filter = true;
-        }
-    }
-
-    /* Look for disabled fields */
-    if (table->flags & EcsTableHasToggle) {
-        for (i = 0; i < term_count; i ++) {
-            if (ecs_term_match_0(&terms[i])) {
-                continue;
-            }
-
-            int32_t field = terms[i].field_index;
-            ecs_id_t id = ids[field];
-            ecs_id_t bs_id = ECS_TOGGLE | id;
-            int32_t bs_index = ecs_table_get_type_index(world, table, bs_id);
-
-            if (bs_index != -1) {
-                flecs_bitset_term_t *bc = ecs_vec_append_t(a, bs_terms, 
-                    flecs_bitset_term_t);
-                bc->column_index = bs_index;
-                bc->bs_column = NULL;
-                has_filter = true;
-            }
-        }
-    }
-
-    /* Look for flattened fields */
-    if (table->flags & EcsTableHasTarget) {
-        const ecs_table_record_t *tr = flecs_table_record_get(world, table, 
-            ecs_pair_t(EcsFlattenTarget, EcsWildcard));
-        ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-        int32_t column = tr->index;
-        ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL);
-        ecs_entity_t rel = ecs_pair_second(world, table->type.array[column]);
-
-        for (i = 0; i < term_count; i ++) {
-            if (ecs_term_match_0(&terms[i])) {
-                continue;
-            }
-
-            if (terms[i].src.trav == rel) {
-                ef.flat_tree_column = table->column_map[column];
-                ecs_assert(ef.flat_tree_column != -1, 
-                    ECS_INTERNAL_ERROR, NULL);
-                has_filter = true;
-                
-                flecs_flat_table_term_t *term = ecs_vec_append_t(
-                    a, ft_terms, flecs_flat_table_term_t);
-                term->field_index = terms[i].field_index;
-                term->term = &terms[i];
-                ecs_os_zeromem(&term->monitor);
-            }
-        }
-    }
-
-    if (has_filter) {
-        if (!*entity_filter) {
-            *entity_filter = ecs_os_malloc_t(ecs_entity_filter_t);
-        }
-        ecs_assert(*entity_filter != NULL, ECS_OUT_OF_MEMORY, NULL);
-        **entity_filter = ef;
-    }
-}
-
-void flecs_entity_filter_fini(
-    ecs_world_t *world,
-    ecs_entity_filter_t *ef)
-{
-    if (!ef) {
-        return;
-    }
-
-    ecs_allocator_t *a = &world->allocator;
-
-    flecs_flat_table_term_t *fields = ecs_vec_first(&ef->ft_terms);
-    int32_t i, term_count = ecs_vec_count(&ef->ft_terms);
-    for (i = 0; i < term_count; i ++) {
-        ecs_vec_fini_t(NULL, &fields[i].monitor, flecs_flat_monitor_t);
-    }
-
-    ecs_vec_fini_t(a, &ef->sw_terms, flecs_switch_term_t);
-    ecs_vec_fini_t(a, &ef->bs_terms, flecs_bitset_term_t);
-    ecs_vec_fini_t(a, &ef->ft_terms, flecs_flat_table_term_t);
-    ecs_os_free(ef);
-}
-
-int flecs_entity_filter_next(
-    ecs_entity_filter_iter_t *it)
-{
-    ecs_table_t *table = it->range.table;
-    flecs_switch_term_t *sw_terms = ecs_vec_first(&it->entity_filter->sw_terms);
-    flecs_bitset_term_t *bs_terms = ecs_vec_first(&it->entity_filter->bs_terms);
-    ecs_entity_filter_t *ef = it->entity_filter;
-    int32_t flat_tree_column = ef->flat_tree_column;
-    ecs_table_range_t *range = &it->range;
-    int32_t range_end = range->offset + range->count;
-    int result = EcsIterNext;
-    bool found = false;
-
-    do {
-        found = false;
-
-        if (bs_terms) {
-            if (flecs_entity_filter_bitset_next(table, it) == -1) {
-                /* No more enabled components for table */
-                it->bs_offset = 0;
-                break;
-            } else {
-                result = EcsIterYield;
-                found = true;
-            }
-        }
-
-        if (sw_terms) {
-            if (flecs_entity_filter_switch_next(table, it, found) == -1) {
-                /* No more elements in sparse column */
-                if (found) {
-                    /* Try again */
-                    result = EcsIterNext;
-                    found = false;
-                } else {
-                    /* Nothing found */
-                    it->bs_offset = 0;
-                    break;
-                }
-            } else {
-                result = EcsIterYield;
-                found = true;
-                it->bs_offset = range->offset + range->count;
-            }
-        }
-
-        if (flat_tree_column != -1) {
-            bool first_for_table = it->prev != table;
-            ecs_iter_t *iter = it->it;
-            ecs_world_t *world = iter->real_world;
-            EcsFlattenTarget *ft = table->data.columns[flat_tree_column].data.array;
-            int32_t ft_offset;
-            int32_t ft_count;
-
-            if (first_for_table) {
-                ft_offset = it->flat_tree_offset = range->offset;
-                it->target_count = 1;
-            } else {
-                it->flat_tree_offset += ft[it->flat_tree_offset].count;
-                ft_offset = it->flat_tree_offset;
-                it->target_count ++;
-            }
-
-            ecs_assert(ft_offset < ecs_table_count(table), 
-                ECS_INTERNAL_ERROR, NULL);
-
-            EcsFlattenTarget *cur = &ft[ft_offset];
-            ft_count = cur->count;
-            bool is_last = (ft_offset + ft_count) >= range_end;
-
-            int32_t i, field_count = ecs_vec_count(&ef->ft_terms);
-            flecs_flat_table_term_t *fields = ecs_vec_first(&ef->ft_terms);
-            for (i = 0; i < field_count; i ++) {
-                flecs_flat_table_term_t *field = &fields[i];
-                ecs_vec_init_if_t(&field->monitor, flecs_flat_monitor_t);
-                int32_t field_index = field->field_index;
-                ecs_id_t id = it->it->ids[field_index];
-                ecs_id_t flat_pair = table->type.array[flat_tree_column];
-                ecs_entity_t rel = ECS_PAIR_FIRST(flat_pair);
-                ecs_entity_t tgt;
-                ecs_table_record_t *tr;
-                int32_t tgt_col = flecs_get_flattened_target(
-                    world, cur, rel, id, &tgt, &tr);
-                if (tgt_col != -1) {
-                    iter->sources[field_index] = tgt;
-                    iter->columns[field_index] = /* encode flattened field */
-                        -(iter->field_count + tgt_col + 1);
-                    ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-
-                    /* Keep track of maximum value encountered in target table
-                     * dirty state so this doesn't have to be recomputed when
-                     * synchronizing the query monitor. */
-                    ecs_vec_set_min_count_zeromem_t(NULL, &field->monitor, 
-                        flecs_flat_monitor_t, it->target_count);
-                    ecs_table_t *tgt_table = tr->hdr.table;
-                    int32_t *ds = flecs_table_get_dirty_state(world, tgt_table);
-                    ecs_assert(ds != NULL, ECS_INTERNAL_ERROR, NULL);
-                    ecs_vec_get_t(&field->monitor, flecs_flat_monitor_t, 
-                        it->target_count - 1)->table_state = ds[tgt_col + 1];
-                } else {
-                    if (field->term->oper == EcsOptional) {
-                        iter->columns[field_index] = 0;
-                        iter->ptrs[field_index] = NULL;
-                    } else {
-                        it->prev = NULL;
-                        break;
-                    }
-                }
-            }
-            if (i != field_count) {
-                if (is_last) {
-                    break;
-                }
-            } else {
-                found = true;
-                if ((ft_offset + ft_count) == range_end) {
-                    result = EcsIterNextYield;
-                } else {
-                    result = EcsIterYield;
-                }
-            }
-
-            range->offset = ft_offset;
-            range->count = ft_count;
-            it->prev = table;
-        }
-    } while (!found);
-
-    it->prev = table;
-
-    if (!found) {
-        return EcsIterNext;
-    } else {
-        return result;
-    }
-}
-
 /**
  * @file entity_name.c
  * @brief Functions for working with named entities.
@@ -9396,7 +9442,7 @@ bool flecs_path_append(
     const char *prefix,
     ecs_strbuf_t *buf)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(sep[0] != 0, ECS_INVALID_PARAMETER, NULL);
 
     ecs_entity_t cur = 0;
@@ -9591,7 +9637,7 @@ ecs_entity_t flecs_get_parent_from_path(
 
 static
 void flecs_on_set_symbol(ecs_iter_t *it) {
-    EcsIdentifier *n = ecs_field(it, EcsIdentifier, 1);
+    EcsIdentifier *n = ecs_field(it, EcsIdentifier, 0);
     ecs_world_t *world = it->world;
 
     int i;
@@ -9604,10 +9650,10 @@ void flecs_on_set_symbol(ecs_iter_t *it) {
 
 void flecs_bootstrap_hierarchy(ecs_world_t *world) {
     ecs_observer(world, {
-        .entity = ecs_entity(world, {.add = {ecs_childof(EcsFlecsInternals)}}),
-        .filter.terms[0] = {
+        .entity = ecs_entity(world, { .parent = EcsFlecsInternals }),
+        .query.terms[0] = {
             .id = ecs_pair(ecs_id(EcsIdentifier), EcsSymbol), 
-            .src.flags = EcsSelf 
+            .src.id = EcsSelf 
         },
         .callback = flecs_on_set_symbol,
         .events = {EcsOnSet},
@@ -9889,7 +9935,7 @@ const char* ecs_set_name_prefix(
     ecs_world_t *world,
     const char *prefix)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     const char *old_prefix = world->info.name_prefix;
     world->info.name_prefix = prefix;
     return old_prefix;
@@ -9939,7 +9985,7 @@ ecs_entity_t ecs_add_path_w_sep(
 
     if (!path) {
         if (!entity) {
-            entity = ecs_new_id(world);
+            entity = ecs_new(world);
         }
 
         if (parent) {
@@ -10002,10 +10048,10 @@ ecs_entity_t ecs_add_path_w_sep(
                 if (!e) {
                     if (last_elem) {
                         ecs_entity_t prev = ecs_set_scope(world, 0);
-                        e = ecs_new(world, 0);
+                        e = ecs_entity(world, {0});
                         ecs_set_scope(world, prev);
                     } else {
-                        e = ecs_new_id(world);
+                        e = ecs_new(world);
                     }
                 }
 
@@ -10050,44390 +10096,44049 @@ ecs_entity_t ecs_new_from_path_w_sep(
 }
 
 /**
- * @file filter.c
- * @brief Uncached query implementation.
- * 
- * Uncached queries (filters) are stateless objects that do not cache their 
- * results. This file contains the creation and validation of uncached queries
- * and code for query iteration.
- * 
- * There file contains the implementation for term queries and filters. Term 
- * queries are uncached queries that only apply to a single term. Filters are
- * uncached queries that support multiple terms. Filters are built on top of
- * term queries: before iteration a filter will first find a "pivot" term (the
- * term with the smallest number of elements), and create a term iterator for
- * it. The output of that term iterator is then evaluated against the rest of
- * the terms of the filter.
- * 
- * Cached queries and observers are built using filters.
+ * @file id.c
+ * @brief Id utilities.
  */
 
-#include <ctype.h>
-
-ecs_filter_t ECS_FILTER_INIT = { .hdr = { .magic = ecs_filter_t_magic }};
 
-/* Helper type for passing around context required for error messages */
-typedef struct {
-    const ecs_world_t *world;
-    ecs_filter_t *filter;
-    ecs_term_t *term;
-    int32_t term_index;
-} ecs_filter_finalize_ctx_t;
+bool ecs_id_match(
+    ecs_id_t id,
+    ecs_id_t pattern)
+{
+    if (id == pattern) {
+        return true;
+    }
 
-static
-char* flecs_filter_str(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter,
-    const ecs_filter_finalize_ctx_t *ctx,
-    int32_t *term_start_out);
+    if (ECS_HAS_ID_FLAG(pattern, PAIR)) {
+        if (!ECS_HAS_ID_FLAG(id, PAIR)) {
+            return false;
+        }
 
-static
-void flecs_filter_error(
-    const ecs_filter_finalize_ctx_t *ctx,
-    const char *fmt,
-    ...)
-{
-    va_list args;
-    va_start(args, fmt);
+        ecs_entity_t id_first = ECS_PAIR_FIRST(id);
+        ecs_entity_t id_second = ECS_PAIR_SECOND(id);
+        ecs_entity_t pattern_first = ECS_PAIR_FIRST(pattern);
+        ecs_entity_t pattern_second = ECS_PAIR_SECOND(pattern);
 
-    int32_t term_start = 0;
+        ecs_check(id_first != 0, ECS_INVALID_PARAMETER, 
+            "first element of pair cannot be 0");
+        ecs_check(id_second != 0, ECS_INVALID_PARAMETER, 
+            "second element of pair cannot be 0");
 
-    char *expr = NULL;
-    if (ctx->filter) {
-        expr = flecs_filter_str(ctx->world, ctx->filter, ctx, &term_start);
+        ecs_check(pattern_first != 0, ECS_INVALID_PARAMETER,
+            "first element of pair cannot be 0");
+        ecs_check(pattern_second != 0, ECS_INVALID_PARAMETER,
+            "second element of pair cannot be 0");
+        
+        if (pattern_first == EcsWildcard) {
+            if (pattern_second == EcsWildcard || pattern_second == id_second) {
+                return true;
+            }
+        } else if (pattern_first == EcsFlag) {
+            /* Used for internals, helps to keep track of which ids are used in
+             * pairs that have additional flags (like OVERRIDE and TOGGLE) */
+            if (ECS_HAS_ID_FLAG(id, PAIR) && !ECS_IS_PAIR(id)) {
+                if (ECS_PAIR_FIRST(id) == pattern_second) {
+                    return true;
+                }
+                if (ECS_PAIR_SECOND(id) == pattern_second) {
+                    return true;
+                }
+            }
+        } else if (pattern_second == EcsWildcard) {
+            if (pattern_first == id_first) {
+                return true;
+            }
+        }
     } else {
-        expr = ecs_term_str(ctx->world, ctx->term);
-    }
-    const char *name = NULL;
-    if (ctx->filter && ctx->filter->entity) {
-        name = ecs_get_name(ctx->filter->world, ctx->filter->entity);
+        if ((id & ECS_ID_FLAGS_MASK) != (pattern & ECS_ID_FLAGS_MASK)) {
+            return false;
+        }
+
+        if ((ECS_COMPONENT_MASK & pattern) == EcsWildcard) {
+            return true;
+        }
     }
-    ecs_parser_errorv(name, expr, term_start, fmt, args);
-    ecs_os_free(expr);
 
-    va_end(args);
+error:
+    return false;
 }
 
-static
-int flecs_term_id_finalize_flags(
-    ecs_term_id_t *term_id,
-    ecs_filter_finalize_ctx_t *ctx)
+bool ecs_id_is_pair(
+    ecs_id_t id)
 {
-    if ((term_id->flags & EcsIsEntity) && (term_id->flags & EcsIsVariable)) {
-        flecs_filter_error(ctx, "cannot set both IsEntity and IsVariable");
-        return -1;
-    }
+    return ECS_HAS_ID_FLAG(id, PAIR);
+}
 
-    if (term_id->name && term_id->name[0] == '$' && term_id->name[1]) {
-        term_id->flags |= EcsIsVariable;
+bool ecs_id_is_wildcard(
+    ecs_id_t id)
+{
+    if ((id == EcsWildcard) || (id == EcsAny)) {
+        return true;
     }
 
-    if (!(term_id->flags & (EcsIsEntity|EcsIsVariable|EcsIsName))) {
-        if (term_id->id || term_id->name) {
-            if (term_id->id == EcsThis || 
-                term_id->id == EcsWildcard || 
-                term_id->id == EcsAny || 
-                term_id->id == EcsVariable) 
-            {
-                /* Builtin variable ids default to variable */
-                term_id->flags |= EcsIsVariable;
-            } else {
-                term_id->flags |= EcsIsEntity;
-            }
-        }
+    bool is_pair = ECS_IS_PAIR(id);
+    if (!is_pair) {
+        return false;
     }
 
-    if (term_id->flags & EcsParent) {
-        term_id->flags |= EcsUp;
-        term_id->trav = EcsChildOf;
-    }
+    ecs_entity_t first = ECS_PAIR_FIRST(id);
+    ecs_entity_t second = ECS_PAIR_SECOND(id);
 
-    if ((term_id->flags & EcsCascade) && !(term_id->flags & (EcsUp|EcsDown))) {
-        term_id->flags |= EcsUp;
-    }
+    return (first == EcsWildcard) || (second == EcsWildcard) ||
+           (first == EcsAny) || (second == EcsAny);
+}
 
-    if ((term_id->flags & (EcsUp|EcsDown)) && !term_id->trav) {
-        term_id->trav = EcsIsA;
+bool ecs_id_is_valid(
+    const ecs_world_t *world,
+    ecs_id_t id)
+{
+    if (!id) {
+        return false;
+    }
+    if (ecs_id_is_wildcard(id)) {
+        return false;
     }
 
-    if (term_id->trav && !(term_id->flags & EcsTraverseFlags)) {
-        term_id->flags |= EcsUp;
+    if (ECS_HAS_ID_FLAG(id, PAIR)) {
+        if (!ECS_PAIR_FIRST(id)) {
+            return false;
+        }
+        if (!ECS_PAIR_SECOND(id)) {
+            return false;
+        }
+    } else if (id & ECS_ID_FLAGS_MASK) {
+        if (!ecs_is_valid(world, id & ECS_COMPONENT_MASK)) {
+            return false;
+        }
     }
 
-    return 0;
+    return true;
 }
 
-static
-int flecs_term_id_lookup(
+ecs_flags32_t ecs_id_get_flags(
     const ecs_world_t *world,
-    ecs_entity_t scope,
-    ecs_term_id_t *term_id,
-    bool free_name,
-    ecs_filter_finalize_ctx_t *ctx)
+    ecs_id_t id)
 {
-    const char *name = term_id->name;
-    if (!name) {
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (idr) {
+        return idr->flags;
+    } else {
         return 0;
     }
+}
 
-    if (term_id->flags & EcsIsVariable) {
-        if (!ecs_os_strcmp(name, "This") || !ecs_os_strcmp(name, "this")) {
-            term_id->id = EcsThis;
-            if (free_name) {
-                /* Safe, if free_name is true the filter owns the name */
-                ecs_os_free(ECS_CONST_CAST(char*, term_id->name));
-            }
-            term_id->name = NULL;
-        }
-        return 0;
-    } else if (term_id->flags & EcsIsName) {
-        return 0;
-    }
+/**
+ * @file iter.c
+ * @brief Iterator API.
+ * 
+ * The iterator API contains functions that apply to all iterators, such as
+ * resource management, or fetching resources for a matched table. The API also
+ * contains functions for generic iterators, which make it possible to iterate
+ * an iterator without needing to know what created the iterator.
+ */
 
-    ecs_assert(term_id->flags & EcsIsEntity, ECS_INTERNAL_ERROR, NULL);
+#include <stddef.h>
 
-    if (ecs_identifier_is_0(name)) {
-        if (term_id->id) {
-            flecs_filter_error(ctx, "name '0' does not match entity id");
-            return -1;
-        }
-        return 0;
-    }
+/* Utility macros to enforce consistency when initializing iterator fields */
 
-    ecs_entity_t e;
-    if (scope) {
-        e = ecs_lookup_child(world, scope, name);
-        if (!e) {
-            /* Support wildcards and fully qualified paths */
-            e = ecs_lookup_symbol(world, name, true, true);
-        }
-    } else {
-        e = ecs_lookup_symbol(world, name, true, true);
+/* If term count is smaller than cache size, initialize with inline array,
+ * otherwise allocate. */
+#define INIT_CACHE(it, stack, fields, f, T, count)\
+    if (!it->f && (fields & flecs_iter_cache_##f) && count) {\
+        it->f = flecs_stack_calloc_n(stack, T, count);\
+        it->priv_.cache.used |= flecs_iter_cache_##f;\
     }
 
-    if (!e) {
-        if (ctx->filter && (ctx->filter->flags & EcsFilterUnresolvedByName)) {
-            term_id->flags |= EcsIsName;
-            term_id->flags &= ~EcsIsEntity;
-        } else {
-            flecs_filter_error(ctx, "unresolved identifier '%s'", name);
-            return -1;
-        }
+/* If array is allocated, free it when finalizing the iterator */
+#define FINI_CACHE(it, f, T, count)\
+    if (it->priv_.cache.used & flecs_iter_cache_##f) {\
+        flecs_stack_free_n((void*)it->f, T, count);\
     }
 
-    if (term_id->id && term_id->id != e) {
-        char *e_str = ecs_get_fullpath(world, term_id->id);
-        flecs_filter_error(ctx, "name '%s' does not match term.id '%s'", 
-            name, e_str);
-        ecs_os_free(e_str);
-        return -1;
-    }
+void* flecs_iter_calloc(
+    ecs_iter_t *it,
+    ecs_size_t size,
+    ecs_size_t align)
+{
+    ecs_world_t *world = it->world;
+    ecs_stage_t *stage = flecs_stage_from_world((ecs_world_t**)&world);
+    ecs_stack_t *stack = &stage->allocators.iter_stack;
+    return flecs_stack_calloc(stack, size, align); 
+}
 
-    term_id->id = e;
+void flecs_iter_free(
+    void *ptr,
+    ecs_size_t size)
+{
+    flecs_stack_free(ptr, size);
+}
 
-    if (!ecs_os_strcmp(name, "*") || !ecs_os_strcmp(name, "_") || 
-        !ecs_os_strcmp(name, "$")) 
-    {
-        term_id->flags &= ~EcsIsEntity;
-        term_id->flags |= EcsIsVariable;
-    }
+void flecs_iter_init(
+    const ecs_world_t *world,
+    ecs_iter_t *it,
+    ecs_flags8_t fields)
+{
+    ecs_assert(!ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
+        ECS_INTERNAL_ERROR, NULL);
 
-    /* Check if looked up id is alive (relevant for numerical ids) */
-    if (!(term_id->flags & EcsIsName)) {
-        if (!ecs_is_alive(world, term_id->id)) {
-            flecs_filter_error(ctx, "identifier '%s' is not alive", term_id->name);
-            return -1;
-        }
+    ecs_stage_t *stage = flecs_stage_from_world(
+        ECS_CONST_CAST(ecs_world_t**, &world));
+    ecs_stack_t *stack = &stage->allocators.iter_stack;
 
-        if (free_name) {
-            /* Safe, if free_name is true, the filter owns the name */
-            ecs_os_free(ECS_CONST_CAST(char*, name));
-        }
+    it->priv_.cache.used = 0;
+    it->priv_.cache.allocated = 0;
+    it->priv_.cache.stack_cursor = flecs_stack_get_cursor(stack);
 
-        term_id->name = NULL;
-    }
+    INIT_CACHE(it, stack, fields, ids, ecs_id_t, it->field_count);
+    INIT_CACHE(it, stack, fields, sources, ecs_entity_t, it->field_count);
+    INIT_CACHE(it, stack, fields, columns, int32_t, it->field_count);
+    INIT_CACHE(it, stack, fields, variables, ecs_var_t, it->variable_count);
+    INIT_CACHE(it, stack, fields, ptrs, void*, it->field_count);
+}
 
-    return 0;
+void flecs_iter_validate(
+    ecs_iter_t *it)
+{
+    ECS_BIT_SET(it->flags, EcsIterIsValid);
+
+    /* Make sure multithreaded iterator isn't created for real world */
+    ecs_world_t *world = it->real_world;
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(!(world->flags & EcsWorldMultiThreaded) || it->world != it->real_world,
+        ECS_INVALID_PARAMETER, 
+            "create iterator for stage when world is in multithreaded mode");
+    (void)world;
+error:
+    return;
 }
 
-static
-int flecs_term_ids_finalize(
-    const ecs_world_t *world,
-    ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
+void ecs_iter_fini(
+    ecs_iter_t *it)
 {
-    ecs_term_id_t *src = &term->src;
-    ecs_term_id_t *first = &term->first;
-    ecs_term_id_t *second = &term->second;
+    ECS_BIT_CLEAR(it->flags, EcsIterIsValid);
 
-    /* Include inherited components (like from prefabs) by default for src */
-    if (!(src->flags & EcsTraverseFlags)) {
-        src->flags |= EcsSelf | EcsUp;
+    if (it->fini) {
+        it->fini(it);
     }
 
-    /* Include subsets for component by default, to support inheritance */
-    if (!(first->flags & EcsTraverseFlags)) {
-        first->flags |= EcsSelf;
-        if (first->id && first->flags & EcsIsEntity) {
-            if (flecs_id_record_get(world, ecs_pair(EcsIsA, first->id))) {
-                first->flags |= EcsDown;
-            }
-        }
+    ecs_world_t *world = it->world;
+    if (!world) {
+        return;
     }
 
-    /* Traverse Self by default for pair target */
-    if (!(second->flags & EcsTraverseFlags)) {
-        second->flags |= EcsSelf;
-    }
+    FINI_CACHE(it, ids, ecs_id_t, it->field_count);
+    FINI_CACHE(it, sources, ecs_entity_t, it->field_count);
+    FINI_CACHE(it, columns, int32_t, it->field_count);
+    FINI_CACHE(it, variables, ecs_var_t, it->variable_count);
+    FINI_CACHE(it, ptrs, void*, it->field_count);
 
-    /* Source defaults to This */
-    if ((src->id == 0) && (src->name == NULL) && !(src->flags & EcsIsEntity)) {
-        src->id = EcsThis;
-        src->flags |= EcsIsVariable;
-    }
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
+    flecs_stack_restore_cursor(&stage->allocators.iter_stack, 
+        it->priv_.cache.stack_cursor);
+}
 
-    /* Initialize term identifier flags */
-    if (flecs_term_id_finalize_flags(src, ctx)) {
-        return -1;
-    }
-    if (flecs_term_id_finalize_flags(first, ctx)) {
-        return -1;
-    }
+bool flecs_iter_next_row(
+    ecs_iter_t *it)
+{
+    ecs_assert(it != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    if (flecs_term_id_finalize_flags(second, ctx)) {
-        return -1;
-    }
+    bool is_instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
+    if (!is_instanced) {
+        int32_t instance_count = it->instance_count;
+        int32_t count = it->count;
+        int32_t offset = it->offset;
 
-    /* Lookup term identifiers by name */
-    if (flecs_term_id_lookup(world, 0, src, term->move, ctx)) {
-        return -1;
-    }
-    if (flecs_term_id_lookup(world, 0, first, term->move, ctx)) {
-        return -1;
-    }
+        if (instance_count > count && offset < (instance_count - 1)) {
+            ecs_assert(count == 1, ECS_INTERNAL_ERROR, NULL);
+            int t, field_count = it->field_count;
 
-    ecs_entity_t first_id = 0;
-    ecs_entity_t oneof = 0;
-    if (first->flags & EcsIsEntity) {
-        first_id = first->id;
+            for (t = 0; t < field_count; t ++) {
+                ecs_entity_t src = it->sources[t];
+                if (!src) {
+                    void *ptr = it->ptrs[t];
+                    if (ptr) {
+                        it->ptrs[t] = ECS_OFFSET(ptr, it->sizes[t]);
+                    }
+                }
+            }
 
-        /* If first element of pair has OneOf property, lookup second element of
-         * pair in the value of the OneOf property */
-        oneof = flecs_get_oneof(world, first_id);
-    }
+            if (it->entities) {
+                it->entities ++;
+            }
+            it->offset ++;
 
-    if (flecs_term_id_lookup(world, oneof, &term->second, term->move, ctx)) {
-        return -1;
+            return true;
+        }
     }
 
-    /* If source is 0, reset traversal flags */
-    if (src->id == 0 && src->flags & EcsIsEntity) {
-        src->flags &= ~EcsTraverseFlags;
-        src->trav = 0;
-    }
-    /* If second is 0, reset traversal flags */
-    if (second->id == 0 && second->flags & EcsIsEntity) {
-        second->flags &= ~EcsTraverseFlags;
-        second->trav = 0;
-    }
+    return false;
+}
 
-    /* If source is wildcard, term won't return any data */
-    if ((src->flags & EcsIsVariable) && ecs_id_is_wildcard(src->id)) {
-        term->inout = EcsInOutNone;
+bool flecs_iter_next_instanced(
+    ecs_iter_t *it,
+    bool result)
+{
+    it->instance_count = it->count;
+    bool is_instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
+
+    if (result && !is_instanced && it->count && it->shared_fields) {
+        it->count = 1;
     }
 
-    return 0;
+    return result;
 }
 
-static
-ecs_entity_t flecs_term_id_get_entity(
-    const ecs_term_id_t *term_id)
+/* --- Public API --- */
+
+void* ecs_field_w_size(
+    const ecs_iter_t *it,
+    size_t size,
+    int32_t index)
 {
-    if (term_id->flags & EcsIsEntity) {
-        return term_id->id; /* Id is known */
-    } else if (term_id->flags & EcsIsVariable) {
-        /* Return wildcard for variables, as they aren't known yet */
-        if (term_id->id != EcsAny) {
-            /* Any variable should not use wildcard, as this would return all
-             * ids matching a wildcard, whereas Any returns the first match */
-            return EcsWildcard;
-        } else {
-            return EcsAny;
+    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER,
+        "operation invalid before calling next()");
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+    ecs_check(!size || ecs_field_size(it, index) == size ||
+        (!ecs_field_size(it, index) && (!it->ptrs[index])),
+            ECS_INVALID_PARAMETER, "mismatching size for field %d", index);
+    (void)size;
+
+    return it->ptrs[index];
+error:
+    return NULL;
+}
+
+bool ecs_field_is_readonly(
+    const ecs_iter_t *it,
+    int32_t index)
+{
+    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER,
+        "operation invalid before calling next()");
+    ecs_check(it->query != NULL, ECS_INVALID_PARAMETER,
+        "operation only valid for query iterators");
+    ecs_check(it->query->terms != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+    const ecs_term_t *term = &it->query->terms[index];
+
+    if (term->inout == EcsIn) {
+        return true;
+    } else if (term->inout == EcsInOutDefault) {
+        if (!ecs_term_match_this(term)) {
+            return true;
+        }
+
+        const ecs_term_ref_t *src = &term->src;
+        if (!(src->id & EcsSelf)) {
+            return true;
         }
-    } else {
-        return 0; /* Term id is uninitialized */
     }
+error:
+    return false;
 }
 
-static
-int flecs_term_populate_id(
-    ecs_term_t *term)
+bool ecs_field_is_writeonly(
+    const ecs_iter_t *it,
+    int32_t index)
+{
+    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER,
+        "operation invalid before calling next()");
+    ecs_check(it->query != NULL, ECS_INVALID_PARAMETER,
+        "operation only valid for query iterators");
+    ecs_check(it->query->terms != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
+    const ecs_term_t *term = &it->query->terms[index];
+    return term->inout == EcsOut;
+error:
+    return false;
+}
+
+bool ecs_field_is_set(
+    const ecs_iter_t *it,
+    int32_t index)
 {
-    ecs_entity_t first = flecs_term_id_get_entity(&term->first);
-    ecs_entity_t second = flecs_term_id_get_entity(&term->second);
-    ecs_id_t role = term->id_flags;
+    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER,
+        "operation invalid before calling next()");
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
 
-    if (first & ECS_ID_FLAGS_MASK) {
-        return -1;
-    }
-    if (second & ECS_ID_FLAGS_MASK) {
-        return -1;
-    }
+    return it->set_fields & (1llu << (index));
+error:
+    return false;
+}
 
-    if ((second || term->second.flags == EcsIsEntity)) {
-        role = term->id_flags |= ECS_PAIR;
-    }
+bool ecs_field_is_self(
+    const ecs_iter_t *it,
+    int32_t index)
+{
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
 
-    if (!second && !ECS_HAS_ID_FLAG(role, PAIR)) {
-        term->id = first | role;
-    } else {
-        term->id = ecs_pair(first, second) | role;
-    }
+    return it->sources == NULL || it->sources[index] == 0;
+error:
+    return false;
+}
+
+ecs_id_t ecs_field_id(
+    const ecs_iter_t *it,
+    int32_t index)
+{
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
 
+    return it->ids[index];
+error:
     return 0;
 }
 
-static
-int flecs_term_populate_from_id(
-    const ecs_world_t *world,
-    ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
+int32_t ecs_field_column(
+    const ecs_iter_t *it,
+    int32_t index)
 {
-    ecs_entity_t first = 0;
-    ecs_entity_t second = 0;
-    ecs_id_t role = term->id & ECS_ID_FLAGS_MASK;
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
+    return it->columns[index];
+error:
+    return 0;
+}
+
+ecs_entity_t ecs_field_src(
+    const ecs_iter_t *it,
+    int32_t index)
+{
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
 
-    if (!role && term->id_flags) {
-        role = term->id_flags;
-        term->id |= role;
+    if (it->sources) {
+        return it->sources[index];
+    } else {
+        return 0;
     }
+error:
+    return 0;
+}
 
-    if (term->id_flags && term->id_flags != role) {
-        flecs_filter_error(ctx, "mismatch between term.id & term.id_flags");
-        return -1;
+size_t ecs_field_size(
+    const ecs_iter_t *it,
+    int32_t index)
+{
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
+    return (size_t)it->sizes[index];
+error:
+    return 0;
+}
+
+char* ecs_iter_str(
+    const ecs_iter_t *it)
+{
+    if (!(it->flags & EcsIterIsValid)) {
+        return NULL;
     }
 
-    term->id_flags = role;
+    ecs_world_t *world = it->world;
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    int i;
 
-    if (ECS_HAS_ID_FLAG(term->id, PAIR)) {
-        first = ECS_PAIR_FIRST(term->id);
-        second = ECS_PAIR_SECOND(term->id);
+    if (it->field_count) {
+        ecs_strbuf_list_push(&buf, "id:  ", ",");
+        for (i = 0; i < it->field_count; i ++) {
+            ecs_id_t id = ecs_field_id(it, i);
+            char *str = ecs_id_str(world, id);
+            ecs_strbuf_list_appendstr(&buf, str);
+            ecs_os_free(str);
+        }
+        ecs_strbuf_list_pop(&buf, "\n");
 
-        if (!first) {
-            flecs_filter_error(ctx, "missing first element in term.id");
-            return -1;
+        ecs_strbuf_list_push(&buf, "src: ", ",");
+        for (i = 0; i < it->field_count; i ++) {
+            ecs_entity_t subj = ecs_field_src(it, i);
+            char *str = ecs_get_fullpath(world, subj);
+            ecs_strbuf_list_appendstr(&buf, str);
+            ecs_os_free(str);
         }
-        if (!second) {
-            if (first != EcsChildOf) {
-                flecs_filter_error(ctx, "missing second element in term.id");
-                return -1;
+        ecs_strbuf_list_pop(&buf, "\n");
+
+        ecs_strbuf_list_push(&buf, "set: ", ",");
+        for (i = 0; i < it->field_count; i ++) {
+            if (ecs_field_is_set(it, i)) {
+                ecs_strbuf_list_appendlit(&buf, "true");
             } else {
-                /* (ChildOf, 0) is allowed so filter can be used to efficiently
-                 * query for root entities */
+                ecs_strbuf_list_appendlit(&buf, "false");
             }
         }
-    } else {
-        first = term->id & ECS_COMPONENT_MASK;
-        if (!first) {
-            flecs_filter_error(ctx, "missing first element in term.id");
-            return -1;
-        }
+        ecs_strbuf_list_pop(&buf, "\n");
     }
 
-    ecs_entity_t term_first = flecs_term_id_get_entity(&term->first);
-    if (term_first) {
-        if ((uint32_t)term_first != (uint32_t)first) {
-            flecs_filter_error(ctx, "mismatch between term.id and term.first");
-            return -1;
+    if (it->variable_count && it->variable_names) {
+        int32_t actual_count = 0;
+        for (i = 0; i < it->variable_count; i ++) {
+            const char *var_name = it->variable_names[i];
+            if (!var_name || var_name[0] == '_' || !strcmp(var_name, "this")) {
+                /* Skip anonymous variables */
+                continue;
+            }
+
+            ecs_var_t var = it->variables[i];
+            if (!var.entity) {
+                /* Skip table variables */
+                continue;
+            }
+
+            if (!actual_count) {
+                ecs_strbuf_list_push(&buf, "var: ", ",");
+            }
+
+            char *str = ecs_get_fullpath(world, var.entity);
+            ecs_strbuf_list_append(&buf, "%s=%s", var_name, str);
+            ecs_os_free(str);
+
+            actual_count ++;
         }
-    } else {
-        if (!(term->first.id = ecs_get_alive(world, first))) {
-            term->first.id = first;
+        if (actual_count) {
+            ecs_strbuf_list_pop(&buf, "\n");
         }
     }
 
-    ecs_entity_t term_second = flecs_term_id_get_entity(&term->second);
-    if (term_second) {
-        if ((uint32_t)term_second != second) {
-            flecs_filter_error(ctx, "mismatch between term.id and term.second");
-            return -1;
-        }
-    } else if (second) {
-        if (!(term->second.id = ecs_get_alive(world, second))) {
-            term->second.id = second;
+    if (it->count) {
+        ecs_strbuf_appendlit(&buf, "this:\n");
+        for (i = 0; i < it->count; i ++) {
+            ecs_entity_t e = it->entities[i];
+            char *str = ecs_get_fullpath(world, e);
+            ecs_strbuf_appendlit(&buf, "    - ");
+            ecs_strbuf_appendstr(&buf, str);
+            ecs_strbuf_appendch(&buf, '\n');
+            ecs_os_free(str);
         }
     }
 
-    return 0;
+    return ecs_strbuf_get(&buf);
 }
 
-static
-int flecs_term_verify_eq_pred(
-    const ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
+bool ecs_iter_next(
+    ecs_iter_t *iter)
 {
-    ecs_entity_t first_id = term->first.id;
-    const ecs_term_id_t *second = &term->second;
-    const ecs_term_id_t *src = &term->src;
-
-    if (term->oper != EcsAnd && term->oper != EcsNot && term->oper != EcsOr) {
-        flecs_filter_error(ctx, "invalid operator combination");
-        goto error;
-    }
-
-    if ((src->flags & EcsIsName) && (second->flags & EcsIsName)) {
-        flecs_filter_error(ctx, "both sides of operator cannot be a name");
-        goto error;
-    }
-
-    if ((src->flags & EcsIsEntity) && (second->flags & EcsIsEntity)) {
-        flecs_filter_error(ctx, "both sides of operator cannot be an entity");
-        goto error;
-    }
-
-    if (!(src->flags & EcsIsVariable)) {
-        flecs_filter_error(ctx, "left-hand of operator must be a variable");
-        goto error;
-    }
-
-    if (first_id == EcsPredMatch && !(second->flags & EcsIsName)) {
-        flecs_filter_error(ctx, "right-hand of match operator must be a string");
-        goto error;
-    }
-
-    if ((src->flags & EcsIsVariable) && (second->flags & EcsIsVariable)) {
-        if (src->id && src->id == second->id) {
-            flecs_filter_error(ctx, "both sides of operator are equal");
-            goto error;
-        }
-        if (src->name && second->name && !ecs_os_strcmp(src->name, second->name)) {
-            flecs_filter_error(ctx, "both sides of operator are equal");
-            goto error;
-        }
-    }
-
-    return 0;
+    ecs_check(iter != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(iter->next != NULL, ECS_INVALID_PARAMETER, NULL);
+    return iter->next(iter);
 error:
-    return -1;
+    return false;
 }
 
-static
-int flecs_term_verify(
-    const ecs_world_t *world,
-    const ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
+int32_t ecs_iter_count(
+    ecs_iter_t *it)
 {
-    const ecs_term_id_t *first = &term->first;
-    const ecs_term_id_t *second = &term->second;
-    const ecs_term_id_t *src = &term->src;
-    ecs_entity_t first_id = 0, second_id = 0;
-    ecs_id_t role = term->id_flags;
-    ecs_id_t id = term->id;
-
-    if ((src->flags & EcsIsName) && (second->flags & EcsIsName)) {
-        flecs_filter_error(ctx, "mismatch between term.id_flags & term.id");
-        return -1;
-    }
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (first->flags & EcsIsEntity) {
-        first_id = first->id;
-    }
-    if (second->flags & EcsIsEntity) {
-        second_id = second->id;
-    }
+    ECS_BIT_SET(it->flags, EcsIterNoData);
+    ECS_BIT_SET(it->flags, EcsIterIsInstanced);
 
-    if (first_id == EcsPredEq || first_id == EcsPredMatch || first_id == EcsPredLookup) {
-        return flecs_term_verify_eq_pred(term, ctx);
+    int32_t count = 0;
+    while (ecs_iter_next(it)) {
+        count += it->count;
     }
+    return count;
+error:
+    return 0;
+}
 
-    if (role != (id & ECS_ID_FLAGS_MASK)) {
-        flecs_filter_error(ctx, "mismatch between term.id_flags & term.id");
-        return -1;
-    }
+ecs_entity_t ecs_iter_first(
+    ecs_iter_t *it)
+{
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (ecs_term_id_is_set(second) && !ECS_HAS_ID_FLAG(role, PAIR)) {
-        flecs_filter_error(ctx, "expected PAIR flag for term with pair");
-        return -1;
-    } else if (!ecs_term_id_is_set(second) && ECS_HAS_ID_FLAG(role, PAIR)) {
-        if (first_id != EcsChildOf) {
-            flecs_filter_error(ctx, "unexpected PAIR flag for term without pair");
-            return -1;
-        } else {
-            /* Exception is made for ChildOf so we can use (ChildOf, 0) to match
-             * all entities in the root */
-        }
-    }
+    ECS_BIT_SET(it->flags, EcsIterNoData);
+    ECS_BIT_SET(it->flags, EcsIterIsInstanced);
 
-    if (!ecs_term_id_is_set(src)) {
-        flecs_filter_error(ctx, "term.src is not initialized");
-        return -1;
+    ecs_entity_t result = 0;
+    if (ecs_iter_next(it)) {
+        result = it->entities[0];
+        ecs_iter_fini(it);
     }
 
-    if (!ecs_term_id_is_set(first)) {
-        flecs_filter_error(ctx, "term.first is not initialized");
-        return -1;
-    }
+    return result;
+error:
+    return 0;
+}
 
-    if (ECS_HAS_ID_FLAG(role, PAIR)) {
-        if (!ECS_PAIR_FIRST(id)) {
-            flecs_filter_error(ctx, "invalid 0 for first element in pair id");
-            return -1;
-        }
-        if ((ECS_PAIR_FIRST(id) != EcsChildOf) && !ECS_PAIR_SECOND(id)) {
-            flecs_filter_error(ctx, "invalid 0 for second element in pair id");
-            return -1;
-        }
+bool ecs_iter_is_true(
+    ecs_iter_t *it)
+{
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
 
-        if ((first->flags & EcsIsEntity) && 
-            (ecs_entity_t_lo(first_id) != ECS_PAIR_FIRST(id))) 
-        {
-            flecs_filter_error(ctx, "mismatch between term.id and term.first");
-            return -1;
-        }
-        if ((first->flags & EcsIsVariable) && 
-            !ecs_id_is_wildcard(ECS_PAIR_FIRST(id)))
-        {
-            char *id_str = ecs_id_str(world, id);
-            flecs_filter_error(ctx, 
-                "expected wildcard for variable term.first (got %s)", id_str);
-            ecs_os_free(id_str);
-            return -1;
-        }
+    ECS_BIT_SET(it->flags, EcsIterNoData);
+    ECS_BIT_SET(it->flags, EcsIterIsInstanced);
 
-        if ((second->flags & EcsIsEntity) && 
-            (ecs_entity_t_lo(second_id) != ECS_PAIR_SECOND(id))) 
-        {
-            flecs_filter_error(ctx, "mismatch between term.id and term.second");
-            return -1;
-        }
-        if ((second->flags & EcsIsVariable) && 
-            !ecs_id_is_wildcard(ECS_PAIR_SECOND(id))) 
-        {
-            char *id_str = ecs_id_str(world, id);
-            flecs_filter_error(ctx, 
-                "expected wildcard for variable term.second (got %s)", id_str);
-            ecs_os_free(id_str);
-            return -1;
-        }
-    } else {
-        ecs_entity_t component = id & ECS_COMPONENT_MASK;
-        if (!component) {
-            flecs_filter_error(ctx, "missing component id");
-            return -1;
-        }
-        if ((first->flags & EcsIsEntity) && 
-            (ecs_entity_t_lo(first_id) != ecs_entity_t_lo(component))) 
-        {
-            flecs_filter_error(ctx, "mismatch between term.id and term.first");
-            return -1;
-        }
-        if ((first->flags & EcsIsVariable) && !ecs_id_is_wildcard(component)) {
-            char *id_str = ecs_id_str(world, id);
-            flecs_filter_error(ctx, 
-                "expected wildcard for variable term.first (got %s)", id_str);
-            ecs_os_free(id_str);
-            return -1;
-        }
+    bool result = ecs_iter_next(it);
+    if (result) {
+        ecs_iter_fini(it);
     }
+    return result;
+error:
+    return false;
+}
 
-    if (first_id) {
-        if (ecs_term_id_is_set(second)) {
-            ecs_flags32_t mask = EcsIsEntity | EcsIsVariable;
-            if ((src->flags & mask) == (second->flags & mask)) {
-                bool is_same = false;
-                if (src->flags & EcsIsEntity) {
-                    is_same = src->id == second->id;
-                } else if (src->name && second->name) {
-                    is_same = !ecs_os_strcmp(src->name, second->name);
-                }
+ecs_entity_t ecs_iter_get_var(
+    ecs_iter_t *it,
+    int32_t var_id)
+{
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER,
+        "variable index %d out of bounds", var_id);
+    ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL);
 
-                if (is_same && ecs_has_id(world, first_id, EcsAcyclic)
-                    && !(term->flags & EcsTermReflexive)) 
-                {
-                    char *pred_str = ecs_get_fullpath(world, term->first.id);
-                    flecs_filter_error(ctx, "term with acyclic relationship"
-                        " '%s' cannot have same subject and object",
-                            pred_str);
-                    ecs_os_free(pred_str);
-                    return -1;
-                }
-            }
+    ecs_var_t *var = &it->variables[var_id];
+    ecs_entity_t e = var->entity;
+    if (!e) {
+        ecs_table_t *table = var->range.table;
+        if (!table && !var_id) {
+            table = it->table;
         }
-
-        if (second_id && !ecs_id_is_wildcard(second_id)) {
-            ecs_entity_t oneof = flecs_get_oneof(world, first_id);
-            if (oneof) {
-                if (!ecs_has_pair(world, second_id, EcsChildOf, oneof)) {
-                    char *second_str = ecs_get_fullpath(world, second_id);
-                    char *oneof_str = ecs_get_fullpath(world, oneof);
-                    char *id_str = ecs_id_str(world, term->id);
-                    flecs_filter_error(ctx, 
-                        "invalid target '%s' for %s: must be child of '%s'",
-                            second_str, id_str, oneof_str);
-                    ecs_os_free(second_str);
-                    ecs_os_free(oneof_str);
-                    ecs_os_free(id_str);
-                    return -1;
-                }
+        if (table) {
+            if ((var->range.count == 1) || (ecs_table_count(table) == 1)) {
+                ecs_assert(ecs_table_count(table) > var->range.offset,
+                    ECS_INTERNAL_ERROR, NULL);
+                e = ecs_vec_get_t(&table->data.entities, ecs_entity_t,
+                    var->range.offset)[0];
             }
         }
+    } else {
+        ecs_assert(ecs_is_valid(it->real_world, e), ECS_INTERNAL_ERROR, NULL);
     }
 
-    if (term->src.trav) {
-        if (!ecs_has_id(world, term->src.trav, EcsTraversable)) {
-            char *r_str = ecs_get_fullpath(world, term->src.trav);
-            flecs_filter_error(ctx, 
-                "cannot traverse non-traversable relationship '%s'", r_str);
-            ecs_os_free(r_str);
-            return -1;
-        }
-    }
-
+    return e;
+error:
     return 0;
 }
 
-static
-int flecs_term_finalize(
-    const ecs_world_t *world,
-    ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
+ecs_table_t* ecs_iter_get_var_as_table(
+    ecs_iter_t *it,
+    int32_t var_id)
 {
-    ctx->term = term;
-
-    ecs_term_id_t *src = &term->src;
-    ecs_term_id_t *first = &term->first;
-    ecs_term_id_t *second = &term->second;
-    ecs_flags32_t first_flags = first->flags;
-    ecs_flags32_t src_flags = src->flags;
-    ecs_flags32_t second_flags = second->flags;
-
-    if (term->id) {
-        if (flecs_term_populate_from_id(world, term, ctx)) {
-            return -1;
-        }
-    }
-
-    if (flecs_term_ids_finalize(world, term, ctx)) {
-        return -1;
-    }
-
-    if ((first->flags & EcsIsVariable) && (term->first.id == EcsAny)) {
-        term->flags |= EcsTermMatchAny;
-    }
-    if ((second->flags & EcsIsVariable) && (term->second.id == EcsAny)) {
-        term->flags |= EcsTermMatchAny;
-    }
-    if ((src->flags & EcsIsVariable) && (term->src.id == EcsAny)) {
-        term->flags |= EcsTermMatchAnySrc;
-    }
-
-    /* If EcsVariable is used by itself, assign to predicate (singleton) */
-    if ((src->id == EcsVariable) && (src->flags & EcsIsVariable)) {
-        src->id = first->id;
-        src->flags &= ~(EcsIsVariable | EcsIsEntity);
-        src->flags |= first->flags & (EcsIsVariable | EcsIsEntity);
-    }
-    if ((second->id == EcsVariable) && (second->flags & EcsIsVariable)) {
-        second->id = first->id;
-        second->flags &= ~(EcsIsVariable | EcsIsEntity);
-        second->flags |= first->flags & (EcsIsVariable | EcsIsEntity);
-    }
-
-    ecs_flags32_t mask = EcsIsEntity | EcsIsVariable;
-    if ((src->flags & mask) == (second->flags & mask)) {
-        bool is_same = false;
-        if (src->flags & EcsIsEntity) {
-            is_same = src->id == second->id;
-        } else if (src->name && second->name) {
-            is_same = !ecs_os_strcmp(src->name, second->name);
-        }
-        if (is_same) {
-            term->flags |= EcsTermSrcSecondEq;
-        }
-    }
-    if ((src->flags & mask) == (first->flags & mask)) {
-        bool is_same = false;
-        if (src->flags & EcsIsEntity) {
-            is_same = src->id == first->id;
-        } else if (src->name && first->name) {
-            is_same = !ecs_os_strcmp(src->name, first->name);
-        }
-        if (is_same) {
-            term->flags |= EcsTermSrcFirstEq;
-        }
-    }
-
-    if (!term->id) {
-        if (flecs_term_populate_id(term)) {
-            return -1;
-        }
-    }
-
-    /* If term queries for !(ChildOf, _), translate it to the builtin 
-     * (ChildOf, 0) index which is a cheaper way to find root entities */
-    if (term->oper == EcsNot && term->id == ecs_pair(EcsChildOf, EcsAny)) {
-        /* Only if the source is not EcsAny */
-        if (!(term->src.id == EcsAny && (term->src.flags & EcsIsVariable))) {
-            term->oper = EcsAnd;
-            term->id = ecs_pair(EcsChildOf, 0);
-            second->id = 0;
-            second->flags |= EcsIsEntity;
-            second->flags &= ~EcsIsVariable;
-        }
-    }
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, 
+        "variable index %d out of bounds", var_id);
+    ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_entity_t first_id = 0;
-    if (first->flags & EcsIsEntity) {
-        first_id = first->id;
+    ecs_var_t *var = &it->variables[var_id];
+    ecs_table_t *table = var->range.table;
+    if (!table && !var_id) {
+        table = it->table;
     }
 
-    term->idr = flecs_query_id_record_get(world, term->id);
-    ecs_flags32_t id_flags = term->idr ? term->idr->flags : 0;
-
-    if (first_id) {
-        ecs_entity_t first_trav = first->trav;
-
-        /* If component is inherited from, set correct traversal flags */
-        ecs_flags32_t first_trav_flags = first_flags & EcsTraverseFlags;
-        if (!first_trav && first_trav_flags != EcsSelf) {
-            /* Inheritance uses IsA by default, but can use any relationship */
-            first_trav = EcsIsA;
-        }
-
-        ecs_record_t *trav_record = NULL;
-        ecs_table_t *trav_table = NULL;
-        if (first_trav) {
-            trav_record = flecs_entities_get(world, first_trav);
-            trav_table = trav_record ? trav_record->table : NULL;
-            if (first_trav != EcsIsA) {
-                if (!trav_table || !ecs_table_has_id(world, trav_table, EcsTraversable)) {
-                    flecs_filter_error(ctx, "first.trav is not traversable");
-                    return -1;
-                }
-            }
-        }
-
-        /* Only enable inheritance for ids which are inherited from at the time
-         * of filter creation. To force component inheritance to be evaluated,
-         * an application can explicitly set traversal flags. */
-        if ((first_trav_flags & EcsDown) || 
-            flecs_id_record_get(world, ecs_pair(first_trav, first->id))) 
-        {
-            if (first_trav_flags == EcsSelf) {
-                flecs_filter_error(ctx, "first.trav specified with self");
-                return -1;
-            }
-
-            if (!first_trav_flags || (first_trav_flags & EcsDown)) {
-                term->flags |= EcsTermIdInherited;
-                first->trav = first_trav;
-                if (!first_trav_flags) {
-                    first->flags &= ~EcsTraverseFlags;
-                    first->flags |= EcsDown;
-                    ecs_assert(trav_table != NULL, ECS_INTERNAL_ERROR, NULL);
-                    if ((first_trav == EcsIsA) || ecs_table_has_id(
-                        world, trav_table, EcsReflexive)) 
-                    {
-                        first->flags |= EcsSelf;
-                    }
+    if (!table) {
+        /* If table is not set, try to get table from entity */
+        ecs_entity_t e = var->entity;
+        if (e) {
+            ecs_record_t *r = flecs_entities_get(it->real_world, e);
+            if (r) {
+                table = r->table;
+                if (ecs_table_count(table) != 1) {
+                    /* If table contains more than the entity, make sure not to
+                     * return a partial table. */
+                    return NULL;
                 }
             }
         }
+    }
 
-        /* Don't traverse ids that cannot be inherited */
-        if ((id_flags & EcsIdDontInherit) && (src->trav == EcsIsA)) {
-            if (src_flags & (EcsUp | EcsDown)) {
-                flecs_filter_error(ctx, 
-                    "traversing not allowed for id that can't be inherited");
-                return -1;
-            }
-            src->flags &= ~(EcsUp | EcsDown);
-            src->trav = 0;
+    if (table) {
+        if (var->range.offset) {
+            /* Don't return whole table if only partial table is matched */
+            return NULL;
         }
 
-        /* If component id is final, don't attempt component inheritance */
-        ecs_record_t *first_record = flecs_entities_get(world, first_id);
-        ecs_table_t *first_table = first_record ? first_record->table : NULL;
-        if (first_table) {
-            if (ecs_table_has_id(world, first_table, EcsFinal)) {
-                if (first_flags & EcsDown) {
-                    flecs_filter_error(ctx, "final id cannot be traversed down");
-                    return -1;
-                }
-            }
-
-            /* Add traversal flags for transitive relationships */
-            if (!(second_flags & EcsTraverseFlags) && ecs_term_id_is_set(second)) {
-                if (!((src->flags & EcsIsVariable) && (src->id == EcsAny))) {
-                    if (!((second->flags & EcsIsVariable) && (second->id == EcsAny))) {
-                        if (ecs_table_has_id(world, first_table, EcsTransitive)) {
-                            second->flags |= EcsSelf|EcsUp|EcsTraverseAll;
-                            second->trav = first_id;
-                            term->flags |= EcsTermTransitive;
-                        }
-                    }
-                }
-            }
-
-            if (ecs_table_has_id(world, first_table, EcsReflexive)) {
-                term->flags |= EcsTermReflexive;
-            }
+        if (!var->range.count || ecs_table_count(table) == var->range.count) {
+            /* Return table if count matches */
+            return table;
         }
     }
 
-    if (first->id == EcsVariable) {
-        flecs_filter_error(ctx, "invalid $ for term.first");
-        return -1;
-    }
+error:
+    return NULL;
+}
 
-    if (term->id_flags & ECS_AND) {
-        term->oper = EcsAndFrom;
-        term->id &= ECS_COMPONENT_MASK;
-        term->id_flags = 0;
-    }
+ecs_table_range_t ecs_iter_get_var_as_range(
+    ecs_iter_t *it,
+    int32_t var_id)
+{
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, 
+        "variable index %d out of bounds", var_id);
+    ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (term->oper == EcsAndFrom || term->oper == EcsOrFrom || term->oper == EcsNotFrom) {
-        if (term->inout != EcsInOutDefault && term->inout != EcsInOutNone) {
-            flecs_filter_error(ctx, 
-                "invalid inout value for AndFrom/OrFrom/NotFrom term");
-            return -1;
-        }
-    }
+    ecs_table_range_t result = { 0 };
 
-    /* Is term trivial */
-    bool trivial_term = true;
-    if (term->oper != EcsAnd) {
-        trivial_term = false;
+    ecs_var_t *var = &it->variables[var_id];
+    ecs_table_t *table = var->range.table;
+    if (!table && !var_id) {
+        table = it->table;
     }
-    if (ecs_id_is_wildcard(term->id)) {
-        if (!(term->idr && term->idr->flags & EcsIdExclusive)) {
-            trivial_term = false;
-        }
-        if (first->flags & EcsIsVariable) {
-            if (!ecs_id_is_wildcard(first->id) || first->id == EcsAny) {
-                trivial_term = false;
+   
+    if (!table) {
+        ecs_entity_t e = var->entity;
+        if (e) {
+            ecs_record_t *r = flecs_entities_get(it->real_world, e);
+            if (r) {
+                result.table = r->table;
+                result.offset = ECS_RECORD_TO_ROW(r->row);
+                result.count = 1;
             }
         }
-        if (second->flags & EcsIsVariable) {
-            if (!ecs_id_is_wildcard(second->id) || second->id == EcsAny) {
-                trivial_term = false;
-            }
+    } else {
+        result.table = table;
+        result.offset = var->range.offset;
+        result.count = var->range.count;
+        if (!result.count) {
+            result.count = ecs_table_count(table);
         }
     }
-    if (!ecs_term_match_this(term)) {
-        trivial_term = false;
-    }
-    if (term->flags & EcsTermIdInherited) {
-        trivial_term = false;
-    }
-    if (src->trav && src->trav != EcsIsA) {
-        trivial_term = false;
-    }
-    if (first->trav && first->trav != EcsIsA) {
-        trivial_term = false;
-    }
-    if (second->trav && second->trav != EcsIsA) {
-        trivial_term = false;
-    }
-    if (!(src->flags & EcsSelf)) {
-        trivial_term = false;
-    }
-    if (((term->first.id == EcsPredEq) || (term->first.id == EcsPredMatch)) && 
-        (term->first.flags & EcsIsEntity)) 
-    {
-        trivial_term = false;
-    }
-
-    if (trivial_term) {
-        ECS_BIT_SET(term->flags, EcsTermIsTrivial);
-    }
-
-    if (flecs_term_verify(world, term, ctx)) {
-        return -1;
-    }
 
-    return 0;
+    return result;
+error:
+    return (ecs_table_range_t){0};
 }
 
-ecs_id_t flecs_to_public_id(
-    ecs_id_t id)
+void ecs_iter_set_var(
+    ecs_iter_t *it,
+    int32_t var_id,
+    ecs_entity_t entity)
 {
-    if (ECS_PAIR_FIRST(id) == EcsUnion) {
-        return ecs_pair(ECS_PAIR_SECOND(id), EcsWildcard);
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < FLECS_QUERY_VARIABLE_COUNT_MAX, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, 
+        "variable index %d out of bounds", var_id);
+    ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_PARAMETER,
+        "cannot constrain variable while iterating");
+    ecs_check(it->variables != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_var_t *var = &it->variables[var_id];
+    var->entity = entity;
+
+    ecs_record_t *r = flecs_entities_get(it->real_world, entity);
+    if (r) {
+        var->range.table = r->table;
+        var->range.offset = ECS_RECORD_TO_ROW(r->row);
+        var->range.count = 1;
     } else {
-        return id;
+        var->range.table = NULL;
+        var->range.offset = 0;
+        var->range.count = 0;
     }
-}
 
-ecs_id_t flecs_from_public_id(
-    ecs_world_t *world,
-    ecs_id_t id)
-{
-    if (ECS_HAS_ID_FLAG(id, PAIR)) {
-        ecs_entity_t first = ECS_PAIR_FIRST(id);
-        ecs_id_record_t *idr = flecs_id_record_ensure(world, 
-            ecs_pair(first, EcsWildcard));
-        if (idr->flags & EcsIdUnion) {
-            return ecs_pair(EcsUnion, first);
-        }
-    }
+    it->constrained_vars |= flecs_ito(uint64_t, 1 << var_id);
 
-    return id;
+error:
+    return;
 }
 
-bool ecs_identifier_is_0(
-    const char *id)
+void ecs_iter_set_var_as_table(
+    ecs_iter_t *it,
+    int32_t var_id,
+    const ecs_table_t *table)
 {
-    return id[0] == '0' && !id[1];
+    ecs_table_range_t range = { .table = ECS_CONST_CAST(ecs_table_t*, table) };
+    ecs_iter_set_var_as_range(it, var_id, &range);
 }
 
-bool ecs_id_match(
-    ecs_id_t id,
-    ecs_id_t pattern)
+void ecs_iter_set_var_as_range(
+    ecs_iter_t *it,
+    int32_t var_id,
+    const ecs_table_range_t *range)
 {
-    if (id == pattern) {
-        return true;
-    }
-
-    if (ECS_HAS_ID_FLAG(pattern, PAIR)) {
-        if (!ECS_HAS_ID_FLAG(id, PAIR)) {
-            return false;
-        }
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, 
+        "variable index %d out of bounds", var_id);
+    ecs_check(range != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(range->table != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!range->offset || range->offset < ecs_table_count(range->table), 
+        ECS_INVALID_PARAMETER, NULL);
+    ecs_check((range->offset + range->count) <= ecs_table_count(range->table), 
+        ECS_INVALID_PARAMETER, NULL);
 
-        ecs_entity_t id_rel = ECS_PAIR_FIRST(id);
-        ecs_entity_t id_obj = ECS_PAIR_SECOND(id);
-        ecs_entity_t pattern_rel = ECS_PAIR_FIRST(pattern);
-        ecs_entity_t pattern_obj = ECS_PAIR_SECOND(pattern);
+    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_OPERATION, 
+        "cannot set query variables while iterating");
 
-        ecs_check(id_rel != 0, ECS_INVALID_PARAMETER, NULL);
-        ecs_check(id_obj != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_var_t *var = &it->variables[var_id];
+    var->range = *range;
 
-        ecs_check(pattern_rel != 0, ECS_INVALID_PARAMETER, NULL);
-        ecs_check(pattern_obj != 0, ECS_INVALID_PARAMETER, NULL);
-        
-        if (pattern_rel == EcsWildcard) {
-            if (pattern_obj == EcsWildcard || pattern_obj == id_obj) {
-                return true;
-            }
-        } else if (pattern_rel == EcsFlag) {
-            /* Used for internals, helps to keep track of which ids are used in
-             * pairs that have additional flags (like OVERRIDE and TOGGLE) */
-            if (ECS_HAS_ID_FLAG(id, PAIR) && !ECS_IS_PAIR(id)) {
-                if (ECS_PAIR_FIRST(id) == pattern_obj) {
-                    return true;
-                }
-                if (ECS_PAIR_SECOND(id) == pattern_obj) {
-                    return true;
-                }
-            }
-        } else if (pattern_obj == EcsWildcard) {
-            if (pattern_rel == id_rel) {
-                return true;
-            }
-        }
+    if (range->count == 1) {
+        ecs_table_t *table = range->table;
+        var->entity = ecs_vec_get_t(
+            &table->data.entities, ecs_entity_t, range->offset)[0];
     } else {
-        if ((id & ECS_ID_FLAGS_MASK) != (pattern & ECS_ID_FLAGS_MASK)) {
-            return false;
-        }
-
-        if ((ECS_COMPONENT_MASK & pattern) == EcsWildcard) {
-            return true;
-        }
+        var->entity = 0;
     }
 
+    it->constrained_vars |= flecs_uto(uint64_t, 1 << var_id);
+
 error:
-    return false;
+    return;
 }
 
-bool ecs_id_is_pair(
-    ecs_id_t id)
+bool ecs_iter_var_is_constrained(
+    ecs_iter_t *it,
+    int32_t var_id)
 {
-    return ECS_HAS_ID_FLAG(id, PAIR);
+    return (it->constrained_vars & (flecs_uto(uint64_t, 1 << var_id))) != 0;
 }
 
-bool ecs_id_is_wildcard(
-    ecs_id_t id)
+static
+void ecs_chained_iter_fini(
+    ecs_iter_t *it)
 {
-    if ((id == EcsWildcard) || (id == EcsAny)) {
-        return true;
-    }
-
-    bool is_pair = ECS_IS_PAIR(id);
-    if (!is_pair) {
-        return false;
-    }
+    ecs_assert(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_entity_t first = ECS_PAIR_FIRST(id);
-    ecs_entity_t second = ECS_PAIR_SECOND(id);
+    ecs_iter_fini(it->chain_it);
 
-    return (first == EcsWildcard) || (second == EcsWildcard) ||
-           (first == EcsAny) || (second == EcsAny);
+    it->chain_it = NULL;
 }
 
-bool ecs_id_is_valid(
-    const ecs_world_t *world,
-    ecs_id_t id)
+ecs_iter_t ecs_page_iter(
+    const ecs_iter_t *it,
+    int32_t offset,
+    int32_t limit)
 {
-    if (!id) {
-        return false;
-    }
-    if (ecs_id_is_wildcard(id)) {
-        return false;
-    }
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (ECS_HAS_ID_FLAG(id, PAIR)) {
-        if (!ECS_PAIR_FIRST(id)) {
-            return false;
-        }
-        if (!ECS_PAIR_SECOND(id)) {
-            return false;
-        }
-    } else if (id & ECS_ID_FLAGS_MASK) {
-        if (!ecs_is_valid(world, id & ECS_COMPONENT_MASK)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-ecs_flags32_t ecs_id_get_flags(
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (idr) {
-        return idr->flags;
-    } else {
-        return 0;
-    }
-}
-
-bool ecs_term_id_is_set(
-    const ecs_term_id_t *id)
-{
-    return id->id != 0 || id->name != NULL || id->flags & EcsIsEntity;
-}
+    ecs_iter_t result = *it;
+    result.priv_.cache.stack_cursor = NULL; /* Don't copy allocator cursor */
 
-bool ecs_term_is_initialized(
-    const ecs_term_t *term)
-{
-    return term->id != 0 || ecs_term_id_is_set(&term->first);
-}
+    result.priv_.iter.page = (ecs_page_iter_t){
+        .offset = offset,
+        .limit = limit,
+        .remaining = limit
+    };
+    result.next = ecs_page_next;
+    result.fini = ecs_chained_iter_fini;
+    result.chain_it = ECS_CONST_CAST(ecs_iter_t*, it);
 
-bool ecs_term_match_this(
-    const ecs_term_t *term)
-{
-    return (term->src.flags & EcsIsVariable) && (term->src.id == EcsThis);
+    return result;
+error:
+    return (ecs_iter_t){ 0 };
 }
 
-bool ecs_term_match_0(
-    const ecs_term_t *term)
+static
+void flecs_offset_iter(
+    ecs_iter_t *it,
+    int32_t offset)
 {
-    return (term->src.id == 0) && (term->src.flags & EcsIsEntity);
-}
+    it->entities = &it->entities[offset];
 
-int ecs_term_finalize(
-    const ecs_world_t *world,
-    ecs_term_t *term)
-{
-    ecs_filter_finalize_ctx_t ctx = {0};
-    ctx.world = world;
-    ctx.term = term;
-    return flecs_term_finalize(world, term, &ctx);
-}
+    int32_t t, field_count = it->field_count;
+    void **it_ptrs = it->ptrs;
+    if (it_ptrs) {
+        for (t = 0; t < field_count; t ++) {
+            void *ptrs = it_ptrs[t];
+            if (!ptrs) {
+                continue;
+            }
 
-ecs_term_t ecs_term_copy(
-    const ecs_term_t *src)
-{
-    ecs_term_t dst = *src;
-    dst.name = ecs_os_strdup(src->name);
-    dst.first.name = ecs_os_strdup(src->first.name);
-    dst.src.name = ecs_os_strdup(src->src.name);
-    dst.second.name = ecs_os_strdup(src->second.name);
-    return dst;
-}
+            if (it->sources[t]) {
+                continue;
+            }
 
-ecs_term_t ecs_term_move(
-    ecs_term_t *src)
-{
-    if (src->move) {
-        ecs_term_t dst = *src;
-        src->name = NULL;
-        src->first.name = NULL;
-        src->src.name = NULL;
-        src->second.name = NULL;
-        dst.move = false;
-        return dst;
-    } else {
-        ecs_term_t dst = ecs_term_copy(src);
-        dst.move = false;
-        return dst;
+            it->ptrs[t] = ECS_OFFSET(ptrs, offset * it->sizes[t]);
+        }
     }
 }
 
-void ecs_term_fini(
-    ecs_term_t *term)
+static
+bool ecs_page_next_instanced(
+    ecs_iter_t *it)
 {
-    /* Safe, values are owned by term */
-    ecs_os_free(ECS_CONST_CAST(char*, term->first.name));
-    ecs_os_free(ECS_CONST_CAST(char*, term->src.name));
-    ecs_os_free(ECS_CONST_CAST(char*, term->second.name));
-    ecs_os_free(term->name);
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_page_next, ECS_INVALID_PARAMETER, NULL);
 
-    term->first.name = NULL;
-    term->src.name = NULL;
-    term->second.name = NULL;
-    term->name = NULL;
-}
+    ecs_iter_t *chain_it = it->chain_it;
+    bool instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
 
-static
-ecs_term_t* flecs_filter_or_other_type(
-    ecs_filter_t *f,
-    int32_t t)
-{
-    ecs_term_t *term = &f->terms[t];
-    ecs_term_t *first = NULL;
-    while (t--) {
-        if (f->terms[t].oper != EcsOr) {
-            break;
+    do {
+        if (!ecs_iter_next(chain_it)) {
+            goto depleted;
         }
 
-        first = &f->terms[t];
-    }
+        ecs_page_iter_t *iter = &it->priv_.iter.page;
+        
+        /* Copy everything up to the private iterator data */
+        ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv_));
 
-    if (first) {
-        ecs_world_t *world = f->world;
-        const ecs_type_info_t *first_type;
+        /* Keep instancing setting from original iterator */
+        ECS_BIT_COND(it->flags, EcsIterIsInstanced, instanced);
 
-        if (first->idr) {
-            first_type = first->idr->type_info;
-        } else {
-            first_type = ecs_get_type_info(world, first->id);
+        if (!chain_it->table) {
+            goto yield; /* Task query */
         }
 
-        const ecs_type_info_t *term_type;
-        if (term->idr) {
-            term_type = term->idr->type_info;
-        } else {
-            term_type = ecs_get_type_info(world, term->id);
+        int32_t offset = iter->offset;
+        int32_t limit = iter->limit;
+        if (!(offset || limit)) {
+            if (it->count) {
+                goto yield;
+            } else {
+                goto depleted;
+            }
         }
 
-        if (first_type == term_type) {
-            return NULL;
+        int32_t count = it->count;
+        int32_t remaining = iter->remaining;
+
+        if (offset) {
+            if (offset > count) {
+                /* No entities to iterate in current table */
+                iter->offset -= count;
+                it->count = 0;
+                continue;
+            } else {
+                it->offset += offset;
+                count = it->count -= offset;
+                iter->offset = 0;
+                flecs_offset_iter(it, offset);
+            }
         }
 
-        return first;
-    } else {
-        return NULL;
+        if (remaining) {
+            if (remaining > count) {
+                iter->remaining -= count;
+            } else {
+                it->count = remaining;
+                iter->remaining = 0;
+            }
+        } else if (limit) {
+            /* Limit hit: no more entities left to iterate */
+            goto done;
+        }
+    } while (it->count == 0);
+
+yield:
+    if (!ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced)) {
+        it->offset = 0;
     }
+
+    return true;
+done:
+    /* Cleanup iterator resources if it wasn't yet depleted */
+    ecs_iter_fini(chain_it);
+depleted:
+error:
+    return false;
 }
 
-int ecs_filter_finalize(
-    const ecs_world_t *world,
-    ecs_filter_t *f)
+bool ecs_page_next(
+    ecs_iter_t *it)
 {
-    int32_t i, term_count = f->term_count, field_count = 0;
-    ecs_term_t *terms = f->terms;
-    int32_t filter_terms = 0, scope_nesting = 0;
-    bool cond_set = false;
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_page_next, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_filter_finalize_ctx_t ctx = {0};
-    ctx.world = world;
-    ctx.filter = f;
+    ECS_BIT_SET(it->chain_it->flags, EcsIterIsInstanced);
 
-    f->flags |= EcsFilterMatchOnlyThis;
+    if (flecs_iter_next_row(it)) {
+        return true;
+    }
 
-    for (i = 0; i < term_count; i ++) {
-        bool filter_term = false;
-        ecs_term_t *term = &terms[i];
-        ctx.term_index = i;
-        if (flecs_term_finalize(world, term, &ctx)) {
-            return -1;
-        }
+    return flecs_iter_next_instanced(it, ecs_page_next_instanced(it));
+error:
+    return false;
+}
 
-        if (i && term[-1].oper == EcsOr) {
-            if (term[-1].src.id != term->src.id) {
-                flecs_filter_error(&ctx, "mismatching src.id for OR terms");
-                return -1;
-            }
-            if (term->oper != EcsOr && term->oper != EcsAnd) {
-                flecs_filter_error(&ctx, 
-                    "term after OR operator must use AND operator");
-                return -1;
-            }
-        } else {
-            field_count ++;
-        }
+ecs_iter_t ecs_worker_iter(
+    const ecs_iter_t *it,
+    int32_t index,
+    int32_t count)
+{
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(count > 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < count, ECS_INVALID_PARAMETER, NULL);
 
-        term->field_index = field_count - 1;
+    ecs_iter_t result = *it;
+    result.priv_.cache.stack_cursor = NULL; /* Don't copy allocator cursor */
+    
+    result.priv_.iter.worker = (ecs_worker_iter_t){
+        .index = index,
+        .count = count
+    };
+    result.next = ecs_worker_next;
+    result.fini = ecs_chained_iter_fini;
+    result.chain_it = ECS_CONST_CAST(ecs_iter_t*, it);
 
-        if (ecs_id_is_wildcard(term->id)) {
-            f->flags |= EcsFilterHasWildcards;
-        }
+    return result;
+error:
+    return (ecs_iter_t){ 0 };
+}
 
-        if (ecs_term_match_this(term)) {
-            ECS_BIT_SET(f->flags, EcsFilterMatchThis);
-        } else {
-            ECS_BIT_CLEAR(f->flags, EcsFilterMatchOnlyThis);
-        }
+static
+bool ecs_worker_next_instanced(
+    ecs_iter_t *it)
+{
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_worker_next, ECS_INVALID_PARAMETER, NULL);
 
-        if (term->id == EcsPrefab) {
-            ECS_BIT_SET(f->flags, EcsFilterMatchPrefab);
-        }
-        if (term->id == EcsDisabled && (term->src.flags & EcsSelf)) {
-            ECS_BIT_SET(f->flags, EcsFilterMatchDisabled);
-        }
+    bool instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
 
-        if (ECS_BIT_IS_SET(f->flags, EcsFilterNoData)) {
-            term->inout = EcsInOutNone;
-        }
-        
-        if (term->oper == EcsNot && term->inout == EcsInOutDefault) {
-            term->inout = EcsInOutNone;
-        }
+    ecs_iter_t *chain_it = it->chain_it;
+    ecs_worker_iter_t *iter = &it->priv_.iter.worker;
+    int32_t res_count = iter->count, res_index = iter->index;
+    int32_t per_worker, instances_per_worker, first;
 
-        if ((term->id == EcsWildcard) || (term->id == 
-            ecs_pair(EcsWildcard, EcsWildcard))) 
-        {
-            /* If term type is unknown beforehand, default the inout type to
-             * none. This prevents accidentally requesting lots of components,
-             * which can put stress on serializer code. */
-            if (term->inout == EcsInOutDefault) {
-                term->inout = EcsInOutNone;
-            }
+    do {
+        if (!ecs_iter_next(chain_it)) {
+            return false;
         }
 
-        if (term->inout == EcsInOutNone) {
-            filter_term = true;
-        } else if (term->idr) {
-            if (!term->idr->type_info && !(term->idr->flags & EcsIdUnion)) {
-                filter_term = true;
-            }
-        } else if (!ecs_id_is_union(world, term->id)) {
-            /* Union ids aren't filters because they return their target
-             * as component value with type ecs_entity_t */
-            if (ecs_id_is_tag(world, term->id)) {
-                filter_term = true;
-            } else if ((ECS_PAIR_SECOND(term->id) == EcsWildcard) ||
-                       (ECS_PAIR_SECOND(term->id) == EcsAny)) 
-            {
-                /* If the second element of a pair is a wildcard and the first
-                 * element is not a type, we can't know in advance what the
-                 * type of the term is, so it can't provide data. */
-                if (!ecs_get_type_info(world, ecs_pair_first(world, term->id))) {
-                    filter_term = true;
-                }
-            }
-        }
-    
-        if (!filter_term) {
-            if (term->oper == EcsOr || (i && term[-1].oper == EcsOr)) {
-                ecs_term_t *first = flecs_filter_or_other_type(f, i);
-                if (first) {
-                    if (first == &term[-1]) {
-                        if (!(term[-1].flags & EcsTermNoData)) {
-                            filter_terms ++;
-                        }
-                    }
-                    filter_term = true;
-                }
-            }
-        }
+        /* Copy everything up to the private iterator data */
+        ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv_));
 
-        if (filter_term) {
-            filter_terms ++;
-            term->flags |= EcsTermNoData;
-        } else {
-            f->data_fields |= (1llu << term->field_index);
-        }
+        /* Keep instancing setting from original iterator */
+        ECS_BIT_COND(it->flags, EcsIterIsInstanced, instanced);
 
-        if (term->oper != EcsNot || !ecs_term_match_this(term)) {
-            ECS_BIT_CLEAR(f->flags, EcsFilterMatchAnything);
-        }
+        int32_t count = it->count;
+        int32_t instance_count = it->instance_count;
+        per_worker = count / res_count;
+        instances_per_worker = instance_count / res_count;
+        first = per_worker * res_index;
+        count -= per_worker * res_count;
 
-        if (term->idr) {
-            if (ecs_os_has_threading()) {
-                ecs_os_ainc(&term->idr->keep_alive);
+        if (count) {
+            if (res_index < count) {
+                per_worker ++;
+                first += res_index;
             } else {
-                term->idr->keep_alive ++;
+                first += count;
             }
         }
 
-        if (term->oper == EcsOptional || term->oper == EcsNot) {
-            cond_set = true;
-        }
-
-        if (term->first.id == EcsPredEq || term->first.id == EcsPredMatch ||
-            term->first.id == EcsPredLookup)
-        {
-            f->flags |= EcsFilterHasPred;
-        }
-
-        if (term->first.id == EcsScopeOpen) {
-            f->flags |= EcsFilterHasScopes;
-            scope_nesting ++;
-        }
-
-        if (term->first.id == EcsScopeClose) {
-            if (i && terms[i - 1].first.id == EcsScopeOpen) {
-                flecs_filter_error(&ctx, "invalid empty scope");
-                return -1;
+        if (!per_worker && it->table == NULL) {
+            if (res_index == 0) {
+                return true;
+            } else {
+                // chained iterator was not yet cleaned up
+                // since it returned true from ecs_iter_next, so clean it up here.
+                ecs_iter_fini(chain_it);
+                return false;
             }
-
-            f->flags |= EcsFilterHasScopes;
-            scope_nesting --;
-        }
-        if (scope_nesting < 0) {
-            flecs_filter_error(&ctx, "'}' without matching '{'");
         }
-    }
+    } while (!per_worker);
 
-    if (scope_nesting != 0) {
-        flecs_filter_error(&ctx, "missing '}'");
-        return -1;
-    }
+    it->instance_count = instances_per_worker;
+    it->frame_offset += first;
 
-    if (term_count && (terms[term_count - 1].oper == EcsOr)) {
-        flecs_filter_error(&ctx, "last term of filter can't have OR operator");
-        return -1;
+    flecs_offset_iter(it, it->offset + first);
+    it->count = per_worker;
+
+    if (ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced)) {
+        it->offset += first;
+    } else {
+        it->offset = 0;
     }
 
-    f->field_count = flecs_ito(int8_t, field_count);
+    return true;
+error:
+    return false;
+}
 
-    if (field_count) {
-        for (i = 0; i < term_count; i ++) {
-            ecs_term_t *term = &terms[i];
-            ecs_id_record_t *idr = term->idr;
-            int32_t field = term->field_index;
-            f->ids[field] = term->id;
+bool ecs_worker_next(
+    ecs_iter_t *it)
+{
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_worker_next, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
 
-            if (term->oper == EcsOr || (i && (term[-1].oper == EcsOr))) {
-                if (flecs_filter_or_other_type(f, i)) {
-                    f->sizes[field] = 0;
-                    f->ids[field] = 0;
-                    continue;
-                }
-            }
+    ECS_BIT_SET(it->chain_it->flags, EcsIterIsInstanced);
 
-            if (idr) {
-                if (!ECS_IS_PAIR(idr->id) || ECS_PAIR_FIRST(idr->id) != EcsWildcard) {
-                    if (idr->flags & EcsIdUnion) {
-                        f->sizes[field] = ECS_SIZEOF(ecs_entity_t);
-#ifdef FLECS_META
-                        f->ids[field] = ecs_id(ecs_entity_t);
-#endif
-                    } else if (idr->type_info) {
-                        f->sizes[field] = idr->type_info->size;
-                        f->ids[field] = idr->id;
-                    }
-                }
-            } else {
-                bool is_union = false;
-                if (ECS_IS_PAIR(term->id)) {
-                    ecs_entity_t first = ecs_pair_first(world, term->id);
-                    if (ecs_has_id(world, first, EcsUnion)) {
-                        is_union = true;
-                    }
-                }
-                if (is_union) {
-                    f->sizes[field] = ECS_SIZEOF(ecs_entity_t);
-#ifdef FLECS_META
-                    f->ids[field] = ecs_id(ecs_entity_t);
-#endif
-                } else {
-                    const ecs_type_info_t *ti = ecs_get_type_info(
-                        world, term->id);
-                    if (ti) {
-                        f->sizes[field] = ti->size;
-                        f->ids[field] = term->id;
-                    }
-                }
-            }
-        }
-    } else {
-        f->sizes = NULL;
-        f->ids = NULL;
+    if (flecs_iter_next_row(it)) {
+        return true;
     }
 
-    ecs_assert(filter_terms <= term_count, ECS_INTERNAL_ERROR, NULL);
-    if (filter_terms == term_count) {
-        ECS_BIT_SET(f->flags, EcsFilterNoData);
-    }
+    return flecs_iter_next_instanced(it, ecs_worker_next_instanced(it));
+error:
+    return false;
+}
 
-    ECS_BIT_COND(f->flags, EcsFilterHasCondSet, cond_set);
+/**
+ * @file misc.c
+ * @brief Miscellaneous functions.
+ */
 
-    /* Check if this is a trivial filter */
-    if ((f->flags & EcsFilterMatchOnlyThis)) {
-        if (!(f->flags & 
-            (EcsFilterHasPred|EcsFilterMatchDisabled|EcsFilterMatchPrefab))) 
-        {
-            ECS_BIT_SET(f->flags, EcsFilterMatchOnlySelf);
+#include <time.h>
+#include <ctype.h>
 
-            for (i = 0; i < term_count; i ++) {
-                ecs_term_t *term = &terms[i];
-                ecs_term_id_t *src = &term->src;
+#ifndef FLECS_NDEBUG
+static int64_t flecs_s_min[] = { 
+    [1] = INT8_MIN, [2] = INT16_MIN, [4] = INT32_MIN, [8] = INT64_MIN };
+static int64_t flecs_s_max[] = { 
+    [1] = INT8_MAX, [2] = INT16_MAX, [4] = INT32_MAX, [8] = INT64_MAX };
+static uint64_t flecs_u_max[] = { 
+    [1] = UINT8_MAX, [2] = UINT16_MAX, [4] = UINT32_MAX, [8] = UINT64_MAX };
 
-                if (src->flags & EcsUp) {
-                    ECS_BIT_CLEAR(f->flags, EcsFilterMatchOnlySelf);
-                }
+uint64_t flecs_ito_(
+    size_t size,
+    bool is_signed,
+    bool lt_zero,
+    uint64_t u,
+    const char *err)
+{
+    union {
+        uint64_t u;
+        int64_t s;
+    } v;
 
-                if (!(term->flags & EcsTermIsTrivial)) {
-                    break;
-                }
+    v.u = u;
 
-                if (!(f->flags & EcsFilterNoData)) {
-                    if (term->inout == EcsInOutNone) {
-                        break;
-                    }
-                }
-            }
-            if (term_count && (i == term_count)) {
-                ECS_BIT_SET(f->flags, EcsFilterIsTrivial);
-            }
-        }
+    if (is_signed) {
+        ecs_assert(v.s >= flecs_s_min[size], ECS_INVALID_CONVERSION, err);
+        ecs_assert(v.s <= flecs_s_max[size], ECS_INVALID_CONVERSION, err);
+    } else {
+        ecs_assert(lt_zero == false, ECS_INVALID_CONVERSION, err);
+        ecs_assert(u <= flecs_u_max[size], ECS_INVALID_CONVERSION, err);
     }
 
-    return 0;
+    return u;
 }
+#endif
 
-/* Implementation for iterable mixin */
-static
-void flecs_filter_iter_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter)
+int32_t flecs_next_pow_of_2(
+    int32_t n)
 {
-    ecs_poly_assert(poly, ecs_filter_t);
+    n --;
+    n |= n >> 1;
+    n |= n >> 2;
+    n |= n >> 4;
+    n |= n >> 8;
+    n |= n >> 16;
+    n ++;
 
-    if (filter) {
-        iter[1] = ecs_filter_iter(world, ECS_CONST_CAST(ecs_filter_t*, poly));
-        iter[0] = ecs_term_chain_iter(&iter[1], filter);
-    } else {
-        iter[0] = ecs_filter_iter(world, ECS_CONST_CAST(ecs_filter_t*, poly));
-    }
+    return n;
 }
 
-/* Implementation for dtor mixin */
-static
-void flecs_filter_fini(
-    ecs_filter_t *filter)
+/** Convert time to double */
+double ecs_time_to_double(
+    ecs_time_t t)
 {
-    if (filter->terms) {
-        int i, count = filter->term_count;
-        for (i = 0; i < count; i ++) {
-            ecs_term_t *term = &filter->terms[i];
-            if (term->idr) {
-                if (!(filter->world->flags & EcsWorldQuit)) {
-                    if (ecs_os_has_threading()) {
-                        ecs_os_adec(&term->idr->keep_alive);
-                    } else {
-                        term->idr->keep_alive --;
-                    }
-                }
-            }
-            ecs_term_fini(&filter->terms[i]);
-        }
+    double result;
+    result = t.sec;
+    return result + (double)t.nanosec / (double)1000000000;
+}
 
-        if (filter->flags & EcsFilterOwnsTermsStorage) {
-            /* Memory allocated for both terms & sizes */
-            ecs_os_free(filter->terms);
-        } else {
-            ecs_os_free(filter->sizes);
-            ecs_os_free(filter->ids);
-        }
+ecs_time_t ecs_time_sub(
+    ecs_time_t t1,
+    ecs_time_t t2)
+{
+    ecs_time_t result;
+
+    if (t1.nanosec >= t2.nanosec) {
+        result.nanosec = t1.nanosec - t2.nanosec;
+        result.sec = t1.sec - t2.sec;
+    } else {
+        result.nanosec = t1.nanosec - t2.nanosec + 1000000000;
+        result.sec = t1.sec - t2.sec - 1;
     }
 
-    filter->terms = NULL;
+    return result;
+}
 
-    if (filter->flags & EcsFilterOwnsStorage) {
-        ecs_os_free(filter);
+void ecs_sleepf(
+    double t)
+{
+    if (t > 0) {
+        int sec = (int)t;
+        int nsec = (int)((t - sec) * 1000000000);
+        ecs_os_sleep(sec, nsec);
     }
 }
 
-void ecs_filter_fini(
-    ecs_filter_t *filter) 
+double ecs_time_measure(
+    ecs_time_t *start)
 {
-    if ((filter->flags & EcsFilterOwnsStorage) && filter->entity) {
-        /* If filter is associated with entity, use poly dtor path */
-        ecs_delete(filter->world, filter->entity);
-    } else {
-        flecs_filter_fini(filter);
-    }
+    ecs_time_t stop, temp;
+    ecs_os_get_time(&stop);
+    temp = stop;
+    stop = ecs_time_sub(stop, *start);
+    *start = temp;
+    return ecs_time_to_double(stop);
 }
 
-static
-void flecs_normalize_term_name(
-    ecs_term_id_t *ref) 
+void* ecs_os_memdup(
+    const void *src, 
+    ecs_size_t size) 
 {
-    if (ref->name && ref->name[0] == '$' && ref->name[1]) {
-        ecs_assert(ref->flags & EcsIsVariable, ECS_INTERNAL_ERROR, NULL);
-        const char *old = ref->name;
-        ref->name = ecs_os_strdup(&old[1]);
-        ecs_os_free(ECS_CONST_CAST(char*, old)); /* safe, filter owns name */
+    if (!src) {
+        return NULL;
     }
+        
+    void *dst = ecs_os_malloc(size);
+    ecs_assert(dst != NULL, ECS_OUT_OF_MEMORY, NULL);
+    ecs_os_memcpy(dst, src, size);  
+    return dst;  
 }
 
-ecs_filter_t* ecs_filter_init(
-    ecs_world_t *world,
-    const ecs_filter_desc_t *desc)    
+int flecs_entity_compare(
+    ecs_entity_t e1, 
+    const void *ptr1, 
+    ecs_entity_t e2, 
+    const void *ptr2) 
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    flecs_stage_from_world(&world);
+    (void)ptr1;
+    (void)ptr2;
+    return (e1 > e2) - (e1 < e2);
+}
 
-    ecs_filter_t *f = desc->storage;
-    int32_t i, term_count = desc->terms_buffer_count, storage_count = 0, expr_count = 0;
-    const ecs_term_t *terms = desc->terms_buffer;
-    ecs_term_t *storage_terms = NULL, *expr_terms = NULL;
+int flecs_id_qsort_cmp(const void *a, const void *b) {
+    ecs_id_t id_a = *(const ecs_id_t*)a;
+    ecs_id_t id_b = *(const ecs_id_t*)b;
+    return (id_a > id_b) - (id_a < id_b);
+}
 
-    if (f) {
-        ecs_check(f->hdr.magic == ecs_filter_t_magic, 
-            ECS_INVALID_PARAMETER, NULL);
-        storage_count = f->term_count;
-        storage_terms = f->terms;
-        ecs_poly_init(f, ecs_filter_t);
-    } else {
-        f = ecs_poly_new(ecs_filter_t);
-        f->flags |= EcsFilterOwnsStorage;
-    }
-    if (!storage_terms) {
-        f->flags |= EcsFilterOwnsTermsStorage;
-    }
+uint64_t flecs_string_hash(
+    const void *ptr)
+{
+    const ecs_hashed_string_t *str = ptr;
+    ecs_assert(str->hash != 0, ECS_INTERNAL_ERROR, NULL);
+    return str->hash;
+}
 
-    ECS_BIT_COND(f->flags, EcsFilterIsInstanced, desc->instanced);
-    ECS_BIT_SET(f->flags, EcsFilterMatchAnything);
-    f->flags |= desc->flags;
-    f->world = world;
+char* flecs_vasprintf(
+    const char *fmt,
+    va_list args)
+{
+    ecs_size_t size = 0;
+    char *result  = NULL;
+    va_list tmpa;
 
-    /* If terms_buffer was not set, count number of initialized terms in
-     * static desc::terms array */
-    if (!terms) {
-        ecs_check(term_count == 0, ECS_INVALID_PARAMETER, NULL);
-        terms = desc->terms;
-        for (i = 0; i < FLECS_TERM_DESC_MAX; i ++) {
-            if (!ecs_term_is_initialized(&terms[i])) {
-                break;
-            }
-            term_count ++;
-        }
-    } else {
-        ecs_check(term_count != 0, ECS_INVALID_PARAMETER, NULL);
-    }
+    va_copy(tmpa, args);
 
-    /* If expr is set, parse query expression */
-    const char *expr = desc->expr;
-    ecs_entity_t entity = desc->entity;
-    if (expr) {
-#ifdef FLECS_PARSER
-        const char *name = NULL;
-        const char *ptr = desc->expr;
-        ecs_term_t term = {0};
-        ecs_term_id_t extra_args[ECS_PARSER_MAX_ARGS];
-        ecs_oper_kind_t extra_oper = 0;
-        int32_t expr_size = 0;
+    size = vsnprintf(result, 0, fmt, tmpa);
 
-        ecs_os_zeromem(extra_args);
+    va_end(tmpa);
 
-        if (entity) {
-            name = ecs_get_name(world, entity);
-        }
+    if ((int32_t)size < 0) { 
+        return NULL; 
+    }
 
-        while (ptr[0] && (ptr = ecs_parse_term(
-            world, name, expr, ptr, &term, &extra_oper, extra_args, true)))
-        {
-            if (!ecs_term_is_initialized(&term)) {
-                break;
-            }
+    result = (char *) ecs_os_malloc(size + 1);
 
-            int32_t arg = 0;
+    if (!result) { 
+        return NULL; 
+    }
 
-            do {
-                ecs_assert(arg <= ECS_PARSER_MAX_ARGS, ECS_INTERNAL_ERROR, NULL);
+    ecs_os_vsprintf(result, fmt, args);
 
-                if (expr_count == expr_size) {
-                    expr_size = expr_size ? expr_size * 2 : 8;
-                    expr_terms = ecs_os_realloc_n(expr_terms, ecs_term_t, expr_size);
-                }
+    return result;
+}
 
-                ecs_term_t *expr_term = &expr_terms[expr_count ++];
-                *expr_term = term;
-
-                if (arg) {
-                    if (extra_oper == EcsAnd) {
-                        expr_term->src = expr_term[-1].second;
-                        expr_term->second = extra_args[arg - 1];
-                    } else if (extra_oper == EcsOr) {
-                        expr_term->src = expr_term[-1].src;
-                        expr_term->second = extra_args[arg - 1];
-                        expr_term[-1].oper = EcsOr;
-                    }
-                    if (expr_term->first.name != NULL) {
-                        expr_term->first.name = ecs_os_strdup(
-                            expr_term->first.name);
-                    }
-                    if (expr_term->src.name != NULL) {
-                        expr_term->src.name = ecs_os_strdup(
-                            expr_term->src.name);
-                    }
-                }
-            } while (ecs_term_id_is_set(&extra_args[arg ++]));
+char* flecs_asprintf(
+    const char *fmt,
+    ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    char *result = flecs_vasprintf(fmt, args);
+    va_end(args);
+    return result;
+}
 
-            if (ptr[0] == '\n') {
-                break;
-            }
+char* flecs_to_snake_case(const char *str) {
+    int32_t upper_count = 0, len = 1;
+    const char *ptr = str;
+    char ch, *out, *out_ptr;
 
-            ecs_os_zeromem(extra_args);
+    for (ptr = &str[1]; (ch = *ptr); ptr ++) {
+        if (isupper(ch)) {
+            upper_count ++;
         }
+        len ++;
+    }
 
-        if (!ptr) {
-            /* Set terms in filter object to make sur they get cleaned up */
-            f->terms = expr_terms;
-            f->term_count = flecs_ito(int8_t, expr_count);
-            f->flags |= EcsFilterOwnsTermsStorage;
-            goto error;
+    out = out_ptr = ecs_os_malloc_n(char, len + upper_count + 1);
+    for (ptr = str; (ch = *ptr); ptr ++) {
+        if (isupper(ch)) {
+            if ((ptr != str) && (out_ptr[-1] != '_')) {
+                out_ptr[0] = '_';
+                out_ptr ++;
+            }
+            out_ptr[0] = (char)tolower(ch);
+            out_ptr ++;
+        } else {
+            out_ptr[0] = ch;
+            out_ptr ++;
         }
-#else
-        (void)expr;
-        ecs_abort(ECS_UNSUPPORTED, "parser addon is not available");
-#endif
     }
 
-    /* If storage is provided, make sure it's large enough */
-    ecs_check(!storage_terms || storage_count >= (term_count + expr_count),
-        ECS_INVALID_PARAMETER, NULL);
+    out_ptr[0] = '\0';
 
-    if (term_count || expr_count) {
-        /* Allocate storage for terms and sizes array */
-        if (!storage_terms) {
-            ecs_assert(f->flags & EcsFilterOwnsTermsStorage, 
-                ECS_INTERNAL_ERROR, NULL);
-            f->term_count = flecs_ito(int8_t, term_count + expr_count);
-            ecs_size_t terms_size = ECS_SIZEOF(ecs_term_t) * f->term_count;
-            ecs_size_t ids_size = ECS_SIZEOF(ecs_id_t) * f->term_count;
-            ecs_size_t sizes_size = ECS_SIZEOF(int32_t) * f->term_count;
-            f->terms = ecs_os_calloc(terms_size + sizes_size + ids_size);
-            f->ids = ECS_OFFSET(f->terms, terms_size);
-            f->sizes = ECS_OFFSET(f->terms, terms_size + ids_size);
-        } else {
-            f->terms = storage_terms;
-            f->term_count = flecs_ito(int8_t, storage_count);
-            f->sizes = ecs_os_calloc_n(ecs_size_t, term_count);
-            f->ids = ecs_os_calloc_n(ecs_id_t, term_count);
-        }
+    return out;
+}
 
-        /* Copy terms to filter storage */
-        for (i = 0; i < term_count; i ++) {
-            f->terms[i] = ecs_term_copy(&terms[i]);
-            /* Allow freeing resources from expr parser during finalization */
-            f->terms[i].move = true;
-        }
+char* flecs_load_from_file(
+    const char *filename)
+{
+    FILE* file;
+    char* content = NULL;
+    int32_t bytes;
+    size_t size;
 
-        /* Move expr terms to filter storage */
-        for (i = 0; i < expr_count; i ++) {
-            f->terms[i + term_count] = ecs_term_move(&expr_terms[i]);
-            /* Allow freeing resources from expr parser during finalization */
-            f->terms[i + term_count].move = true;
-        }
-        ecs_os_free(expr_terms);
+    /* Open file for reading */
+    ecs_os_fopen(&file, filename, "r");
+    if (!file) {
+        ecs_err("%s (%s)", ecs_os_strerror(errno), filename);
+        goto error;
     }
 
-    /* Ensure all fields are consistent and properly filled out */
-    if (ecs_filter_finalize(world, f)) {
+    /* Determine file size */
+    fseek(file, 0, SEEK_END);
+    bytes = (int32_t)ftell(file);
+    if (bytes == -1) {
         goto error;
     }
+    fseek(file, 0, SEEK_SET);
 
-    /* Any allocated resources remaining in terms are now owned by filter */
-    for (i = 0; i < f->term_count; i ++) {
-        ecs_term_t *term = &f->terms[i];
-        /* Post process term names in case they were used to create variables */
-        flecs_normalize_term_name(&term->first);
-        flecs_normalize_term_name(&term->second);
-        flecs_normalize_term_name(&term->src);
-        term->move = false;
+    /* Load contents in memory */
+    content = ecs_os_malloc(bytes + 1);
+    size = (size_t)bytes;
+    if (!(size = fread(content, 1, size, file)) && bytes) {
+        ecs_err("%s: read zero bytes instead of %d", filename, size);
+        ecs_os_free(content);
+        content = NULL;
+        goto error;
+    } else {
+        content[size] = '\0';
     }
 
-    f->variable_names[0] = NULL;
-    f->iterable.init = flecs_filter_iter_init;
-    f->dtor = (ecs_poly_dtor_t)flecs_filter_fini;
-    f->entity = entity;
-    f->eval_count = 0;
-
-    if (entity && (f->flags & EcsFilterOwnsStorage)) {
-        EcsPoly *poly = ecs_poly_bind(world, entity, ecs_filter_t);
-        poly->poly = f;
-        ecs_poly_modified(world, entity, ecs_filter_t);
-    }
+    fclose(file);
 
-    return f;
+    return content;
 error:
-    ecs_filter_fini(f);
+    ecs_os_free(content);
     return NULL;
 }
 
-void ecs_filter_copy(
-    ecs_filter_t *dst,
-    const ecs_filter_t *src)   
+char* flecs_chresc(
+    char *out, 
+    char in, 
+    char delimiter) 
 {
-    if (src == dst) {
-        return;
+    char *bptr = out;
+    switch(in) {
+    case '\a':
+        *bptr++ = '\\';
+        *bptr = 'a';
+        break;
+    case '\b':
+        *bptr++ = '\\';
+        *bptr = 'b';
+        break;
+    case '\f':
+        *bptr++ = '\\';
+        *bptr = 'f';
+        break;
+    case '\n':
+        *bptr++ = '\\';
+        *bptr = 'n';
+        break;
+    case '\r':
+        *bptr++ = '\\';
+        *bptr = 'r';
+        break;
+    case '\t':
+        *bptr++ = '\\';
+        *bptr = 't';
+        break;
+    case '\v':
+        *bptr++ = '\\';
+        *bptr = 'v';
+        break;
+    case '\\':
+        *bptr++ = '\\';
+        *bptr = '\\';
+        break;
+    case '\033':
+        *bptr = '['; /* Used for terminal colors */
+        break;
+    default:
+        if (in == delimiter) {
+            *bptr++ = '\\';
+            *bptr = delimiter;
+        } else {
+            *bptr = in;
+        }
+        break;
     }
 
-    if (src) {
-        *dst = *src;
-
-        int32_t i, term_count = src->term_count;
-        ecs_size_t terms_size = ECS_SIZEOF(ecs_term_t) * term_count;
-        ecs_size_t sizes_size = ECS_SIZEOF(int32_t) * term_count;
-        ecs_size_t ids_size = ECS_SIZEOF(ecs_id_t) * term_count;
-        dst->terms = ecs_os_malloc(terms_size + sizes_size + ids_size);
-        dst->ids = ECS_OFFSET(dst->terms, terms_size);
-        dst->sizes = ECS_OFFSET(dst->terms, terms_size + ids_size);
-        dst->flags |= EcsFilterOwnsTermsStorage;
-        ecs_os_memcpy_n(dst->sizes, src->sizes, int32_t, term_count);
-        ecs_os_memcpy_n(dst->ids, src->ids, int32_t, term_count);
+    *(++bptr) = '\0';
 
-        for (i = 0; i < term_count; i ++) {
-            dst->terms[i] = ecs_term_copy(&src->terms[i]);
-        }
-    } else {
-        ecs_os_memset_t(dst, 0, ecs_filter_t);
-    }
+    return bptr;
 }
 
-void ecs_filter_move(
-    ecs_filter_t *dst,
-    ecs_filter_t *src)   
+const char* flecs_chrparse(
+    const char *in, 
+    char *out) 
 {
-    if (src == dst) {
-        return;
-    }
+    const char *result = in + 1;
+    char ch;
 
-    if (src) {
-        *dst = *src;
-        if (src->flags & EcsFilterOwnsTermsStorage) {
-            dst->terms = src->terms;
-            dst->sizes = src->sizes;
-            dst->ids = src->ids;
-            dst->flags |= EcsFilterOwnsTermsStorage;
-        } else {
-            ecs_filter_copy(dst, src);
+    if (in[0] == '\\') {
+        result ++;
+
+        switch(in[1]) {
+        case 'a':
+            ch = '\a';
+            break;
+        case 'b':
+            ch = '\b';
+            break;
+        case 'f':
+            ch = '\f';
+            break;
+        case 'n':
+            ch = '\n';
+            break;
+        case 'r':
+            ch = '\r';
+            break;
+        case 't':
+            ch = '\t';
+            break;
+        case 'v':
+            ch = '\v';
+            break;
+        case '\\':
+            ch = '\\';
+            break;
+        case '"':
+            ch = '"';
+            break;
+        case '0':
+            ch = '\0';
+            break;
+        case ' ':
+            ch = ' ';
+            break;
+        case '$':
+            ch = '$';
+            break;
+        default:
+            goto error;
         }
-        src->terms = NULL;
-        src->sizes = NULL;
-        src->ids = NULL;
-        src->term_count = 0;
     } else {
-        ecs_os_memset_t(dst, 0, ecs_filter_t);
+        ch = in[0];
     }
-}
 
-static
-void flecs_filter_str_add_id(
-    const ecs_world_t *world,
-    ecs_strbuf_t *buf,
-    const ecs_term_id_t *id,
-    bool is_subject,
-    ecs_flags32_t default_traverse_flags)
-{
-    bool is_added = false;
-    if (!is_subject || id->id != EcsThis) {
-        if (id->flags & EcsIsVariable && !ecs_id_is_wildcard(id->id)) {
-            ecs_strbuf_appendlit(buf, "$");
-        }
-        if (id->id) {
-            char *path = ecs_get_fullpath(world, id->id);
-            ecs_strbuf_appendstr(buf, path);
-            ecs_os_free(path);
-        } else if (id->name) {
-            ecs_strbuf_appendstr(buf, id->name);
-        } else {
-            ecs_strbuf_appendlit(buf, "0");
-        }
-        is_added = true;
+    if (out) {
+        *out = ch;
     }
 
-    ecs_flags32_t flags = id->flags;
-    if (!(flags & EcsTraverseFlags)) {
-        /* If flags haven't been set yet, initialize with defaults. This can
-         * happen if an error is thrown while the term is being finalized */
-        flags |= default_traverse_flags;
-    }
+    return result;
+error:
+    return NULL;
+}
 
-    if ((flags & EcsTraverseFlags) != default_traverse_flags) {
-        if (is_added) {
-            ecs_strbuf_list_push(buf, ":", "|");
-        } else {
-            ecs_strbuf_list_push(buf, "", "|");
-        }
-        if (id->flags & EcsSelf) {
-            ecs_strbuf_list_appendstr(buf, "self");
-        }
-        if (id->flags & EcsUp) {
-            ecs_strbuf_list_appendstr(buf, "up");
-        }
-        if (id->flags & EcsDown) {
-            ecs_strbuf_list_appendstr(buf, "down");
+ecs_size_t flecs_stresc(
+    char *out, 
+    ecs_size_t n, 
+    char delimiter, 
+    const char *in) 
+{
+    const char *ptr = in;
+    char ch, *bptr = out, buff[3];
+    ecs_size_t written = 0;
+    while ((ch = *ptr++)) {
+        if ((written += (ecs_size_t)(flecs_chresc(
+            buff, ch, delimiter) - buff)) <= n) 
+        {
+            /* If size != 0, an out buffer must be provided. */
+            ecs_check(out != NULL, ECS_INVALID_PARAMETER, NULL);
+            *bptr++ = buff[0];
+            if ((ch = buff[1])) {
+                *bptr = ch;
+                bptr++;
+            }
         }
+    }
 
-        if (id->trav && (id->trav != EcsIsA)) {
-            ecs_strbuf_list_push(buf, "(", "");
-
-            char *rel_path = ecs_get_fullpath(world, id->trav);
-            ecs_strbuf_appendstr(buf, rel_path);
-            ecs_os_free(rel_path);
-
-            ecs_strbuf_list_pop(buf, ")");
+    if (bptr) {
+        while (written < n) {
+            *bptr = '\0';
+            bptr++;
+            written++;
         }
-
-        ecs_strbuf_list_pop(buf, "");
     }
+    return written;
+error:
+    return 0;
 }
 
-static
-void flecs_term_str_w_strbuf(
-    const ecs_world_t *world,
-    const ecs_term_t *term,
-    ecs_strbuf_t *buf,
-    int32_t t)
+char* flecs_astresc(
+    char delimiter, 
+    const char *in)
 {
-    const ecs_term_id_t *src = &term->src;
-    const ecs_term_id_t *second = &term->second;
+    if (!in) {
+        return NULL;
+    }
 
-    uint8_t def_src_mask = EcsSelf|EcsUp;
-    uint8_t def_first_mask = EcsSelf;
-    uint8_t def_second_mask = EcsSelf;
+    ecs_size_t len = flecs_stresc(NULL, 0, delimiter, in);
+    char *out = ecs_os_malloc_n(char, len + 1);
+    flecs_stresc(out, len, delimiter, in);
+    out[len] = '\0';
+    return out;
+}
 
-    bool pred_set = ecs_term_id_is_set(&term->first);
-    bool subj_set = !ecs_term_match_0(term);
-    bool obj_set = ecs_term_id_is_set(second);
+const char* flecs_parse_digit(
+    const char *ptr,
+    char *token)
+{
+    char *tptr = token;
+    char ch = ptr[0];
 
-    if (term->first.id == EcsScopeOpen) {
-        ecs_strbuf_appendlit(buf, "{");
-        return;
-    } else if (term->first.id == EcsScopeClose) {
-        ecs_strbuf_appendlit(buf, "}");
-        return;
+    if (!isdigit(ch) && ch != '-') {
+        ecs_parser_error(NULL, NULL, 0, "invalid start of number '%s'", ptr);
+        return NULL;
     }
 
-    if (((term->first.id == EcsPredEq) || (term->first.id == EcsPredMatch)) && 
-        (term->first.flags & EcsIsEntity)) 
-    {
-        ecs_strbuf_appendlit(buf, "$");
-        if (term->src.id == EcsThis && term->src.flags & EcsIsVariable) {
-            ecs_strbuf_appendlit(buf, "this");
-        } else if (term->src.flags & EcsIsVariable) {
-            ecs_strbuf_appendstr(buf, term->src.name);
-        } else {
-            /* Shouldn't happen */
-        }
-
-        if (term->first.id == EcsPredEq) {
-            if (term->oper == EcsNot) {
-                ecs_strbuf_appendlit(buf, " != ");
-            } else {
-                ecs_strbuf_appendlit(buf, " == ");
-            }
-        } else if (term->first.id == EcsPredMatch) {
-            ecs_strbuf_appendlit(buf, " ~= ");
-        }
+    tptr[0] = ch;
+    tptr ++;
+    ptr ++;
 
-        if (term->second.flags & EcsIsEntity) {
-            if (term->second.id != 0) {
-                ecs_get_path_w_sep_buf(
-                    world, 0, term->second.id, ".", NULL, buf);
-            }
-        } else {
-            if (term->second.flags & EcsIsVariable) {
-                ecs_strbuf_appendlit(buf, "$");
-                if (term->second.name) {
-                    ecs_strbuf_appendstr(buf, term->second.name);
-                } else if (term->second.id == EcsThis) {
-                    ecs_strbuf_appendlit(buf, "this");
-                }
-            } else if (term->second.flags & EcsIsName) {
-                ecs_strbuf_appendlit(buf, "\"");
-                if (term->first.id == EcsPredMatch && term->oper == EcsNot) {
-                    ecs_strbuf_appendlit(buf, "!");
-                }
-                ecs_strbuf_appendstr(buf, term->second.name);
-                ecs_strbuf_appendlit(buf, "\"");
-            }
+    for (; (ch = *ptr); ptr ++) {
+        if (!isdigit(ch) && (ch != '.') && (ch != 'e')) {
+            break;
         }
 
-        return;
+        tptr[0] = ch;
+        tptr ++;
     }
 
-    if (!t || !(term[-1].oper == EcsOr)) {
-        if (term->inout == EcsIn) {
-            ecs_strbuf_appendlit(buf, "[in] ");
-        } else if (term->inout == EcsInOut) {
-            ecs_strbuf_appendlit(buf, "[inout] ");
-        } else if (term->inout == EcsOut) {
-            ecs_strbuf_appendlit(buf, "[out] ");
-        } else if (term->inout == EcsInOutNone && term->oper != EcsNot) {
-            ecs_strbuf_appendlit(buf, "[none] ");
-        }
-    }
+    tptr[0] = '\0';
+    
+    return ptr;
+}
 
-    if (term->first.flags & EcsIsEntity && term->first.id != 0) {
-        if (ecs_has_id(world, term->first.id, EcsDontInherit)) {
-            def_src_mask = EcsSelf;
-        }
+const char* flecs_parse_ws_eol(
+    const char *ptr)
+{
+    while (isspace(*ptr)) {
+        ptr ++;
     }
 
-    if (term->oper == EcsNot) {
-        ecs_strbuf_appendlit(buf, "!");
-    } else if (term->oper == EcsOptional) {
-        ecs_strbuf_appendlit(buf, "?");
-    }
+    return ptr;
+}
 
-    if (!subj_set) {
-        flecs_filter_str_add_id(world, buf, &term->first, false, 
-            def_first_mask);
-        if (!obj_set) {
-            ecs_strbuf_appendlit(buf, "()");
-        } else {
-            ecs_strbuf_appendlit(buf, "(0,");
-            flecs_filter_str_add_id(world, buf, &term->second, false, 
-                def_second_mask);
-            ecs_strbuf_appendlit(buf, ")");
-        }
-    } else if (ecs_term_match_this(term) && 
-        (src->flags & EcsTraverseFlags) == def_src_mask)
-    {
-        if (pred_set) {
-            if (obj_set) {
-                ecs_strbuf_appendlit(buf, "(");
-            }
-            flecs_filter_str_add_id(world, buf, &term->first, false, def_first_mask);   
-            if (obj_set) {
-                ecs_strbuf_appendlit(buf, ",");
-                flecs_filter_str_add_id(
-                    world, buf, &term->second, false, def_second_mask);
-                ecs_strbuf_appendlit(buf, ")");
-            }
-        } else if (term->id) {
-            char *str = ecs_id_str(world, term->id);
-            ecs_strbuf_appendstr(buf, str);
-            ecs_os_free(str);
-        }
-    } else {
-        if (term->id_flags && !ECS_HAS_ID_FLAG(term->id_flags, PAIR)) {
-            ecs_strbuf_appendstr(buf, ecs_id_flag_str(term->id_flags));
-            ecs_strbuf_appendch(buf, '|');
-        }
+/**
+ * @file observable.c
+ * @brief Observable implementation.
+ * 
+ * The observable implementation contains functions that find the set of 
+ * observers to invoke for an event. The code also contains the implementation
+ * of a reachable id cache, which is used to speedup event propagation when
+ * relationships are added/removed to/from entities.
+ */
 
-        flecs_filter_str_add_id(world, buf, &term->first, false, def_first_mask);
-        ecs_strbuf_appendlit(buf, "(");
-        if (term->src.flags & EcsIsEntity && term->src.id == term->first.id) {
-            ecs_strbuf_appendlit(buf, "$");
-        } else {
-            flecs_filter_str_add_id(world, buf, &term->src, true, def_src_mask);
-        }
-        if (obj_set) {
-            ecs_strbuf_appendlit(buf, ",");
-            flecs_filter_str_add_id(world, buf, &term->second, false, def_second_mask);
-        }
-        ecs_strbuf_appendlit(buf, ")");
-    }
-}
 
-char* ecs_term_str(
-    const ecs_world_t *world,
-    const ecs_term_t *term)
+void flecs_observable_init(
+    ecs_observable_t *observable)
 {
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
-    flecs_term_str_w_strbuf(world, term, &buf, 0);
-    return ecs_strbuf_get(&buf);
+    flecs_sparse_init_t(&observable->events, NULL, NULL, ecs_event_record_t);
+    observable->on_add.event = EcsOnAdd;
+    observable->on_remove.event = EcsOnRemove;
+    observable->on_set.event = EcsOnSet;
+    observable->un_set.event = EcsUnSet;
 }
 
-static
-char* flecs_filter_str(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter,
-    const ecs_filter_finalize_ctx_t *ctx,
-    int32_t *term_start_out)
+void flecs_observable_fini(
+    ecs_observable_t *observable)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
-    ecs_term_t *terms = filter->terms;
-    int32_t i, count = filter->term_count;
+    ecs_assert(!ecs_map_is_init(&observable->on_add.event_ids), 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!ecs_map_is_init(&observable->on_remove.event_ids), 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!ecs_map_is_init(&observable->on_set.event_ids), 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!ecs_map_is_init(&observable->un_set.event_ids), 
+        ECS_INTERNAL_ERROR, NULL);
 
+    ecs_sparse_t *events = &observable->events;
+    int32_t i, count = flecs_sparse_count(events);
     for (i = 0; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-
-        if (term_start_out && ctx) {
-            if (ctx->term_index == i) {
-                term_start_out[0] = ecs_strbuf_written(&buf);
-                if (i) {
-                    term_start_out[0] += 2; /* whitespace  + , */
-                }
-            }
-        }
-
-        flecs_term_str_w_strbuf(world, term, &buf, i);
+        ecs_event_record_t *er = 
+            flecs_sparse_get_dense_t(events, ecs_event_record_t, i);
+        ecs_assert(er != NULL, ECS_INTERNAL_ERROR, NULL);
+        (void)er;
 
-        if (i != (count - 1)) {
-            if (term->oper == EcsOr) {
-                ecs_strbuf_appendlit(&buf, " || ");
-            } else {
-                if (term->first.id != EcsScopeOpen) {
-                    if (term[1].first.id != EcsScopeClose) {
-                        ecs_strbuf_appendlit(&buf, ", ");
-                    }
-                }
-            }
-        }
+        /* All observers should've unregistered by now */
+        ecs_assert(!ecs_map_is_init(&er->event_ids), 
+            ECS_INTERNAL_ERROR, NULL);
     }
 
-    return ecs_strbuf_get(&buf);
-error:
-    return NULL;
+    flecs_sparse_fini(&observable->events);
 }
 
-char* ecs_filter_str(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter)
+ecs_event_record_t* flecs_event_record_get(
+    const ecs_observable_t *o,
+    ecs_entity_t event)
 {
-    return flecs_filter_str(world, filter, NULL, NULL);
+    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
+    
+    /* Builtin events*/
+    if      (event == EcsOnAdd)     return ECS_CONST_CAST(ecs_event_record_t*, &o->on_add);
+    else if (event == EcsOnRemove)  return ECS_CONST_CAST(ecs_event_record_t*, &o->on_remove);
+    else if (event == EcsOnSet)     return ECS_CONST_CAST(ecs_event_record_t*, &o->on_set);
+    else if (event == EcsUnSet)     return ECS_CONST_CAST(ecs_event_record_t*, &o->un_set);
+    else if (event == EcsWildcard)  return ECS_CONST_CAST(ecs_event_record_t*, &o->on_wildcard);
+
+    /* User events */
+    return flecs_sparse_try_t(&o->events, ecs_event_record_t, event);
 }
 
-int32_t ecs_filter_find_this_var(
-    const ecs_filter_t *filter)
+ecs_event_record_t* flecs_event_record_ensure(
+    ecs_observable_t *o,
+    ecs_entity_t event)
 {
-    ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL);
-    
-    if (ECS_BIT_IS_SET(filter->flags, EcsFilterMatchThis)) {
-        /* Filters currently only support the This variable at index 0. Only
-         * return 0 if filter actually has terms for the This variable. */
-        return 0;
-    }
+    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
 
-error:
-    return -1;
+    ecs_event_record_t *er = flecs_event_record_get(o, event);
+    if (er) {
+        return er;
+    }
+    er = flecs_sparse_ensure_t(&o->events, ecs_event_record_t, event);
+    er->event = event;
+    return er;
 }
 
-/* Check if the id is a pair that has Any as first or second element. Any 
- * pairs behave just like Wildcard pairs and reuses the same data structures,
- * with as only difference that the number of results returned for an Any pair
- * is never more than one. This function is used to tell the difference. */
 static
-bool is_any_pair(
-    ecs_id_t id)
+const ecs_event_record_t* flecs_event_record_get_if(
+    const ecs_observable_t *o,
+    ecs_entity_t event)
 {
-    if (!ECS_HAS_ID_FLAG(id, PAIR)) {
-        return false;
-    }
+    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    if (ECS_PAIR_FIRST(id) == EcsAny) {
-        return true;
-    }
-    if (ECS_PAIR_SECOND(id) == EcsAny) {
-        return true;
+    const ecs_event_record_t *er = flecs_event_record_get(o, event);
+    if (er) {
+        if (ecs_map_is_init(&er->event_ids)) {
+            return er;
+        }
+        if (er->any) {
+            return er;
+        }
+        if (er->wildcard) {
+            return er;
+        }
+        if (er->wildcard_pair) {
+            return er;
+        }
     }
 
-    return false;
+    return NULL;
 }
 
-static
-bool flecs_n_term_match_table(
-    ecs_world_t *world,
-    const ecs_term_t *term,
-    const ecs_table_t *table,
-    ecs_entity_t type_id,
-    ecs_oper_kind_t oper,
-    ecs_id_t *id_out,
-    int32_t *column_out,
-    ecs_entity_t *subject_out,
-    int32_t *match_index_out,
-    bool first,
-    ecs_flags32_t iter_flags)
+ecs_event_id_record_t* flecs_event_id_record_get(
+    const ecs_event_record_t *er,
+    ecs_id_t id)
 {
-    (void)column_out;
-
-    const ecs_type_t *type = ecs_get_type(world, type_id);
-    ecs_assert(type != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_id_t *ids = type->array;
-    int32_t i, count = type->count;
-    ecs_term_t temp = *term;
-    temp.oper = EcsAnd;
+    if (!er) {
+        return NULL;
+    }
 
-    for (i = 0; i < count; i ++) {
-        ecs_id_t id = ids[i];
-        if (ecs_id_get_flags(world, id) & EcsIdDontInherit) {
-            continue;
-        }
-        bool result;
-        if (ECS_HAS_ID_FLAG(id, AND)) {
-            ecs_oper_kind_t id_oper = EcsAndFrom;
-            result = flecs_n_term_match_table(world, term, table, 
-                id & ECS_COMPONENT_MASK, id_oper, id_out, column_out, 
-                subject_out, match_index_out, first, iter_flags);
-        } else {
-            temp.id = id;
-            result = flecs_term_match_table(world, &temp, table, id_out, 
-                0, subject_out, match_index_out, first, iter_flags);
-        }
-        if (!result && oper == EcsAndFrom) {
-            return false;
-        } else
-        if (result && oper == EcsOrFrom) {
-            return true;
+    if (id == EcsAny)                                  return er->any;
+    else if (id == EcsWildcard)                        return er->wildcard;
+    else if (id == ecs_pair(EcsWildcard, EcsWildcard)) return er->wildcard_pair;
+    else {
+        if (ecs_map_is_init(&er->event_ids)) {
+            return ecs_map_get_deref(&er->event_ids, ecs_event_id_record_t, id);
         }
+        return NULL;
     }
+}
 
-    if (oper == EcsAndFrom) {
-        if (id_out) {
-            id_out[0] = type_id;
-        }
-        return true;
-    } else
-    if (oper == EcsOrFrom) {
-        return false;
+static
+ecs_event_id_record_t* flecs_event_id_record_get_if(
+    const ecs_event_record_t *er,
+    ecs_id_t id)
+{
+    ecs_event_id_record_t *ider = flecs_event_id_record_get(er, id);
+    if (!ider) {
+        return NULL;
     }
 
-    return false;
+    if (ider->observer_count) {
+        return ider;
+    }
+
+    return NULL;
 }
 
-bool flecs_term_match_table(
+ecs_event_id_record_t* flecs_event_id_record_ensure(
     ecs_world_t *world,
-    const ecs_term_t *term,
-    const ecs_table_t *table,
-    ecs_id_t *id_out,
-    int32_t *column_out,
-    ecs_entity_t *subject_out,
-    int32_t *match_index_out,
-    bool first,
-    ecs_flags32_t iter_flags)
+    ecs_event_record_t *er,
+    ecs_id_t id)
 {
-    ecs_assert(term != NULL, ECS_INTERNAL_ERROR, NULL);
-    const ecs_term_id_t *src = &term->src;
-    ecs_oper_kind_t oper = term->oper;
-    const ecs_table_t *match_table = table;
-    ecs_id_t id = term->id;
-
-    ecs_entity_t src_id = src->id;
-    if (ecs_term_match_0(term)) {
-        if (id_out) {
-            id_out[0] = id; /* If no entity is matched, just set id */
-        }
-        return true;
+    ecs_event_id_record_t *ider = flecs_event_id_record_get(er, id);
+    if (ider) {
+        return ider;
     }
 
-    if (oper == EcsAndFrom || oper == EcsOrFrom) {
-        return flecs_n_term_match_table(world, term, table, term->id, 
-            term->oper, id_out, column_out, subject_out, match_index_out, first, 
-            iter_flags);
+    ider = ecs_os_calloc_t(ecs_event_id_record_t);
+
+    if (id == EcsAny) {
+        return er->any = ider;
+    } else if (id == EcsWildcard) {
+        return er->wildcard = ider;
+    } else if (id == ecs_pair(EcsWildcard, EcsWildcard)) {
+        return er->wildcard_pair = ider;
     }
 
-    /* If source is not This, search in table of source */
-    if (!ecs_term_match_this(term)) {
-        if (iter_flags & EcsIterEntityOptional) {
-            /* Treat entity terms as optional */
-            oper = EcsOptional;
-        }
+    ecs_map_init_w_params_if(&er->event_ids, &world->allocators.ptr);
+    ecs_map_insert_ptr(&er->event_ids, id, ider);
+    return ider;
+}
 
-        if (ecs_is_alive(world, src_id)) {
-            match_table = ecs_get_table(world, src_id);
-        } else {
-            match_table = NULL;
+void flecs_event_id_record_remove(
+    ecs_event_record_t *er,
+    ecs_id_t id)
+{
+    if (id == EcsAny) {
+        er->any = NULL;
+    } else if (id == EcsWildcard) {
+        er->wildcard = NULL;
+    } else if (id == ecs_pair(EcsWildcard, EcsWildcard)) {
+        er->wildcard_pair = NULL;
+    } else {
+        ecs_map_remove(&er->event_ids, id);
+        if (!ecs_map_count(&er->event_ids)) {
+            ecs_map_fini(&er->event_ids);
         }
+    }
+}
 
-        if (match_table) {
-        } else if (oper != EcsOptional) {
-            return false;
-        }
-    } else {
-        /* If filter contains This terms, a table must be provided */
-        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+static
+int32_t flecs_event_observers_get(
+    const ecs_event_record_t *er,
+    ecs_id_t id,
+    ecs_event_id_record_t **iders)
+{
+    if (!er) {
+        return 0;
     }
 
-    if (!match_table) {
-        return false;
+    /* Populate array with observer sets matching the id */
+    int32_t count = 0;
+
+    if (id != EcsAny) {
+        iders[0] = flecs_event_id_record_get_if(er, EcsAny);
+        count += iders[count] != 0;
     }
 
-    ecs_entity_t source = 0;
+    iders[count] = flecs_event_id_record_get_if(er, id);
+    count += iders[count] != 0;
 
-    /* If first = false, we're searching from an offset. This supports returning
-     * multiple results when using wildcard filters. */
-    int32_t column = 0;
-    if (!first && column_out && column_out[0] != 0) {
-        column = column_out[0];
-        if (column < 0) {
-            /* In case column is not from This, flip sign */
-            column = -column;
+    if (id != EcsAny) {
+        if (ECS_IS_PAIR(id)) {
+            ecs_id_t id_fwc = ecs_pair(EcsWildcard, ECS_PAIR_SECOND(id));
+            ecs_id_t id_swc = ecs_pair(ECS_PAIR_FIRST(id), EcsWildcard);
+            ecs_id_t id_pwc = ecs_pair(EcsWildcard, EcsWildcard);
+            iders[count] = flecs_event_id_record_get_if(er, id_fwc);
+            count += iders[count] != 0;
+            iders[count] = flecs_event_id_record_get_if(er, id_swc);
+            count += iders[count] != 0;
+            iders[count] = flecs_event_id_record_get_if(er, id_pwc);
+            count += iders[count] != 0;
+        } else {
+            iders[count] = flecs_event_id_record_get_if(er, EcsWildcard);
+            count += iders[count] != 0;
         }
+    }
 
-        /* Remove base 1 offset */
-        column --;
+    return count;
+}
+
+bool flecs_observers_exist(
+    ecs_observable_t *observable,
+    ecs_id_t id,
+    ecs_entity_t event)
+{
+    const ecs_event_record_t *er = flecs_event_record_get_if(observable, event);
+    if (!er) {
+        return false;
     }
 
-    /* Find location, source and id of match in table type */
-    ecs_table_record_t *tr = 0;
-    bool is_any = is_any_pair(id);
+    return flecs_event_id_record_get_if(er, id) != NULL;
+}
 
-    ecs_id_record_t *idr = term->idr;
-    if (world->flags & EcsWorldQuit) {
-        /* During world cleanup the keep_alive assert for id records is no 
-         * longer enforced */
-        idr = NULL;
+static
+void flecs_emit_propagate(
+    ecs_world_t *world,
+    ecs_iter_t *it,
+    ecs_id_record_t *idr,
+    ecs_id_record_t *tgt_idr,
+    ecs_entity_t trav,
+    ecs_event_id_record_t **iders,
+    int32_t ider_count);
+
+static
+void flecs_emit_propagate_id(
+    ecs_world_t *world,
+    ecs_iter_t *it,
+    ecs_id_record_t *idr,
+    ecs_id_record_t *cur,
+    ecs_entity_t trav,
+    ecs_event_id_record_t **iders,
+    int32_t ider_count)
+{
+    ecs_table_cache_iter_t idt;
+    if (!flecs_table_cache_all_iter(&cur->cache, &idt)) {
+        return;
     }
-    column = flecs_search_relation_w_idr(world, match_table,
-        column, id, src->trav, src->flags, &source, id_out, &tr, idr);
 
-    if (tr && match_index_out) {
-        if (!is_any) {
-            match_index_out[0] = tr->count;
-        } else {
-            match_index_out[0] = 1;
+    const ecs_table_record_t *tr;
+    int32_t event_cur = it->event_cur;
+    while ((tr = flecs_table_cache_next(&idt, ecs_table_record_t))) {
+        ecs_table_t *table = tr->hdr.table;
+        if (!ecs_table_count(table)) {
+            continue;
         }
-    }
 
-    bool result = column != -1;
+        bool owned = flecs_id_record_get_table(idr, table) != NULL;
 
-    if (oper == EcsNot) {
-        if (match_index_out) {
-            match_index_out[0] = 1;
+        int32_t e, entity_count = ecs_table_count(table);
+        it->table = table;
+        it->other_table = NULL;
+        it->offset = 0;
+        it->count = entity_count;
+        if (entity_count) {
+            it->entities = ecs_vec_first(&table->data.entities);
         }
-        result = !result;
-    }
 
-    if (oper == EcsOptional) {
-        result = true;
-    }
+        /* Treat as new event as this could invoke observers again for
+         * different tables. */
+        it->event_cur = ++ world->event_id;
 
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    if ((column == -1) && (src->flags & EcsUp) && (table->flags & EcsTableHasTarget)) {
-        ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_id_t rel = ECS_PAIR_SECOND(table->type.array[table->_->ft_offset]);
-        if (rel == (uint32_t)src->trav) {
-            result = true;
+        int32_t ider_i;
+        for (ider_i = 0; ider_i < ider_count; ider_i ++) {
+            ecs_event_id_record_t *ider = iders[ider_i];
+            flecs_observers_invoke(world, &ider->up, it, table, trav);
+
+            if (!owned) {
+                /* Owned takes precedence */
+                flecs_observers_invoke(world, &ider->self_up, it, table, trav);
+            }
         }
-    }
 
-    if (!result) {
-        if (iter_flags & EcsFilterPopulate) {
-            column = 0;
-        } else {
-            return false;
+        if (!table->_->traversable_count) {
+            continue;
         }
-    }
 
-    if (!ecs_term_match_this(term)) {
-        if (!source) {
-            source = src_id;
+        ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
+        for (e = 0; e < entity_count; e ++) {
+            ecs_record_t *r = flecs_entities_get(world, entities[e]);
+            ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_id_record_t *idr_t = r->idr;
+            if (idr_t) {
+                /* Only notify for entities that are used in pairs with
+                 * traversable relationships */
+                flecs_emit_propagate(world, it, idr, idr_t, trav,
+                    iders, ider_count);
+            }
         }
     }
 
-    if (id_out && column < 0) {
-        id_out[0] = id;
+    it->event_cur = event_cur;
+}
+
+static
+void flecs_emit_propagate(
+    ecs_world_t *world,
+    ecs_iter_t *it,
+    ecs_id_record_t *idr,
+    ecs_id_record_t *tgt_idr,
+    ecs_entity_t propagate_trav,
+    ecs_event_id_record_t **iders,
+    int32_t ider_count)
+{
+    ecs_assert(tgt_idr != NULL, ECS_INTERNAL_ERROR, NULL);    
+
+    if (ecs_should_log_3()) {
+        char *idstr = ecs_id_str(world, tgt_idr->id);
+        ecs_dbg_3("propagate events/invalidate cache for %s", idstr);
+        ecs_os_free(idstr);
     }
+    ecs_log_push_3();
+
+    /* Propagate to records of traversable relationships */
+    ecs_id_record_t *cur = tgt_idr;
+    while ((cur = cur->trav.next)) {
+        cur->reachable.generation ++; /* Invalidate cache */
 
-    if (column_out) {
-        if (column >= 0) {
-            column ++;
-            if (source != 0) {
-                column *= -1; 
+        /* Get traversed relationship */
+        ecs_entity_t trav = ECS_PAIR_FIRST(cur->id);
+        if (propagate_trav && propagate_trav != trav) {
+            if (propagate_trav != EcsIsA) {
+                continue;
             }
-            column_out[0] = column;
-        } else {
-            column_out[0] = 0;
         }
-    }
 
-    if (subject_out) {
-        subject_out[0] = source;
+        flecs_emit_propagate_id(
+            world, it, idr, cur, trav, iders, ider_count);
     }
 
-    return result;
+    ecs_log_pop_3();
 }
 
-bool flecs_filter_match_table(
+static
+void flecs_emit_propagate_invalidate_tables(
     ecs_world_t *world,
-    const ecs_filter_t *filter,
-    const ecs_table_t *table,
-    ecs_id_t *ids,
-    int32_t *columns,
-    ecs_entity_t *sources,
-    int32_t *match_indices,
-    int32_t *matches_left,
-    bool first,
-    int32_t skip_term,
-    ecs_flags32_t iter_flags)
+    ecs_id_record_t *tgt_idr)
 {
-    ecs_term_t *terms = filter->terms;
-    int32_t i, count = filter->term_count;
-    int32_t match_count = 1;
-    bool result = true;
+    ecs_assert(tgt_idr != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    if (matches_left) {
-        match_count = *matches_left;
+    if (ecs_should_log_3()) {
+        char *idstr = ecs_id_str(world, tgt_idr->id);
+        ecs_dbg_3("invalidate reachable cache for %s", idstr);
+        ecs_os_free(idstr);
     }
 
-    for (i = 0; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-        ecs_oper_kind_t oper = term->oper;
-        if (i == skip_term) {
-            if (oper != EcsAndFrom && oper != EcsOrFrom && oper != EcsNotFrom) {
-                continue;
-            }
+    /* Invalidate records of traversable relationships */
+    ecs_id_record_t *cur = tgt_idr;
+    while ((cur = cur->trav.next)) {
+        ecs_reachable_cache_t *rc = &cur->reachable;
+        if (rc->current != rc->generation) {
+            /* Subtree is already marked invalid */
+            continue;
         }
 
-        ecs_term_id_t *src = &term->src;
-        const ecs_table_t *match_table = table;
-        int32_t t_i = term->field_index;
+        rc->generation ++;
 
-        ecs_entity_t src_id = src->id;
-        if (!src_id) {
-            if (ids) {
-                ids[t_i] = term->id;
-            }
+        ecs_table_cache_iter_t idt;
+        if (!flecs_table_cache_all_iter(&cur->cache, &idt)) {
             continue;
         }
 
-        if (!ecs_term_match_this(term)) {
-            if (ecs_is_alive(world, src_id)) {
-                match_table = ecs_get_table(world, src_id);
-            } else {
-                match_table = NULL;
-            }
-        } else {
-            if (ECS_BIT_IS_SET(iter_flags, EcsIterIgnoreThis)) {
+        const ecs_table_record_t *tr;
+        while ((tr = flecs_table_cache_next(&idt, ecs_table_record_t))) {
+            ecs_table_t *table = tr->hdr.table;
+            if (!table->_->traversable_count) {
                 continue;
             }
-            
-            /* If filter contains This terms, table must be provided */
-            ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-        }
-
-        int32_t match_index = 0;
-        if (!i || term[-1].oper != EcsOr) {
-            result = false;
-        } else {
-            if (result) {
-                continue; /* Already found matching OR term */
-            }
-        }
-
-        bool term_result = flecs_term_match_table(world, term, match_table,
-            ids ? &ids[t_i] : NULL, 
-            columns ? &columns[t_i] : NULL, 
-            sources ? &sources[t_i] : NULL, 
-            &match_index,
-            first,
-            iter_flags);
 
-        if (i && term[-1].oper == EcsOr) {
-            result |= term_result;
-        } else {
-            result = term_result;
-        }
+            int32_t e, entity_count = ecs_table_count(table);
+            ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
 
-        if (oper != EcsOr && !result) {
-            return false;
+            for (e = 0; e < entity_count; e ++) {
+                ecs_record_t *r = flecs_entities_get(world, entities[e]);
+                ecs_id_record_t *idr_t = r->idr;
+                if (idr_t) {
+                    /* Only notify for entities that are used in pairs with
+                     * traversable relationships */
+                    flecs_emit_propagate_invalidate_tables(world, idr_t);
+                }
+            }
         }
+    }
+}
 
-        if (first && match_index) {
-            match_count *= match_index;
+void flecs_emit_propagate_invalidate(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    int32_t offset,
+    int32_t count)
+{
+    ecs_entity_t *entities = ecs_vec_get_t(&table->data.entities, 
+        ecs_entity_t, offset);
+    int32_t i;
+    for (i = 0; i < count; i ++) {
+        ecs_record_t *record = flecs_entities_get(world, entities[i]);
+        if (!record) {
+            /* If the event is emitted after a bulk operation, it's possible
+             * that it hasn't been populated with entities yet. */
+            continue;
         }
 
-        if (match_indices) {
-            match_indices[t_i] = match_index;
+        ecs_id_record_t *idr_t = record->idr;
+        if (idr_t) {
+            /* Event is used as target in traversable relationship, propagate */
+            flecs_emit_propagate_invalidate_tables(world, idr_t);
         }
     }
-
-    if (matches_left) {
-        *matches_left = match_count;
-    }
-
-    return true;
 }
 
 static
-void term_iter_init_no_data(
-    ecs_term_iter_t *iter)
+void flecs_propagate_entities(
+    ecs_world_t *world,
+    ecs_iter_t *it,
+    ecs_id_record_t *idr,
+    ecs_entity_t *entities,
+    int32_t count,
+    ecs_entity_t src,
+    ecs_event_id_record_t **iders,
+    int32_t ider_count)
 {
-    iter->term = (ecs_term_t){ .field_index = -1 };
-    iter->self_index = NULL;
-    iter->index = 0;
+    if (!count) {
+        return;
+    }
+
+    ecs_entity_t old_src = it->sources[0];
+    ecs_table_t *old_table = it->table;
+    ecs_table_t *old_other_table = it->other_table;
+    ecs_entity_t *old_entities = it->entities;
+    int32_t old_count = it->count;
+    int32_t old_offset = it->offset;
+
+    int32_t i;
+    for (i = 0; i < count; i ++) {
+        ecs_record_t *record = flecs_entities_get(world, entities[i]);
+        if (!record) {
+            /* If the event is emitted after a bulk operation, it's possible
+             * that it hasn't been populated with entities yet. */
+            continue;
+        }
+
+        ecs_id_record_t *idr_t = record->idr;
+        if (idr_t) {
+            /* Entity is used as target in traversable pairs, propagate */
+            ecs_entity_t e = src ? src : entities[i];
+            it->sources[0] = e;
+            flecs_emit_propagate(
+                world, it, idr, idr_t, 0, iders, ider_count);
+        }
+    }
+    
+    it->table = old_table;
+    it->other_table = old_other_table;
+    it->entities = old_entities;
+    it->count = old_count;
+    it->offset = old_offset;
+    it->sources[0] = old_src;
 }
 
 static
-void term_iter_init_w_idr(
-    const ecs_term_t *term,
-    ecs_term_iter_t *iter, 
-    ecs_id_record_t *idr, 
-    bool empty_tables)
+void flecs_override_copy(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    const ecs_type_info_t *ti,
+    void *dst,
+    const void *src,
+    int32_t offset,
+    int32_t count)
 {
-    if (idr) {
-        if (empty_tables) {
-            flecs_table_cache_all_iter(&idr->cache, &iter->it);
-        } else {
-            flecs_table_cache_iter(&idr->cache, &iter->it);
+    void *ptr = dst;
+    ecs_copy_t copy = ti->hooks.copy;
+    ecs_size_t size = ti->size;
+    int32_t i;
+    if (copy) {
+        for (i = 0; i < count; i ++) {
+            copy(ptr, src, 1, ti);
+            ptr = ECS_OFFSET(ptr, size);
         }
     } else {
-        term_iter_init_no_data(iter);
+        for (i = 0; i < count; i ++) {
+            ecs_os_memcpy(ptr, src, size);
+            ptr = ECS_OFFSET(ptr, size);
+        }
     }
 
-    iter->index = 0;
-    iter->empty_tables = empty_tables;
-    iter->size = 0;
-    if (term && term->idr && term->idr->type_info) {
-        iter->size = term->idr->type_info->size;
+    ecs_iter_action_t on_set = ti->hooks.on_set;
+    if (on_set) {
+        ecs_entity_t *entities = ecs_vec_get_t(
+            &table->data.entities, ecs_entity_t, offset);
+        flecs_invoke_hook(world, table, count, offset, entities,
+            dst, ti->component, ti, EcsOnSet, on_set);
     }
 }
 
 static
-void term_iter_init_wildcard(
-    const ecs_world_t *world,
-    ecs_term_iter_t *iter,
-    bool empty_tables)
+void* flecs_override(
+    ecs_iter_t *it, 
+    const ecs_type_t *emit_ids,
+    ecs_id_t id,
+    ecs_table_t *table,
+    ecs_id_record_t *idr)
 {
-    iter->term = (ecs_term_t){ .field_index = -1 };
-    iter->self_index = flecs_id_record_get(world, EcsAny);
-    ecs_id_record_t *idr = iter->cur = iter->self_index;
-    term_iter_init_w_idr(NULL, iter, idr, empty_tables);
-}
+    if (it->event != EcsOnAdd || (it->flags & EcsEventNoOnSet)) {
+        return NULL;
+    }
 
-static
-void term_iter_init(
-    const ecs_world_t *world,
-    ecs_term_t *term,
-    ecs_term_iter_t *iter,
-    bool empty_tables)
-{    
-    const ecs_term_id_t *src = &term->src;
+    int32_t i = 0, count = emit_ids->count;
+    ecs_id_t *ids = emit_ids->array;
+    for (i = 0; i < count; i ++) {
+        if (ids[i] == id) {
+            /* If an id was both inherited and overridden in the same event
+             * (like what happens during an auto override), we need to copy the
+             * value of the inherited component to the new component.
+             * Also flag to the callee that this component was overridden, so
+             * that an OnSet event can be emmitted for it.
+             * Note that this is different from a component that was overridden
+             * after it was inherited, as this does not change the actual value
+             * of the component for the entity (it is copied from the existing
+             * overridden component), and does not require an OnSet event. */
+            ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+            if (!tr) {
+                continue;
+            }
 
-    iter->term = *term;
+            int32_t index = tr->column;
+            ecs_assert(index != -1, ECS_INTERNAL_ERROR, NULL);
 
-    if (src->flags & EcsSelf) {
-        iter->self_index = term->idr;
-        if (!iter->self_index) {
-            iter->self_index = flecs_query_id_record_get(world, term->id);
+            ecs_column_t *column = &table->data.columns[index];
+            ecs_size_t size = column->ti->size;
+            return ecs_vec_get(&column->data, size, it->offset);
         }
     }
 
-    if (src->flags & EcsUp) {
-        iter->set_index = flecs_id_record_get(world, 
-            ecs_pair(src->trav, EcsWildcard));
-    }
-
-    ecs_id_record_t *idr;
-    if (iter->self_index) {
-        idr = iter->cur = iter->self_index;
-    } else {
-        idr = iter->cur = iter->set_index;
-    }
-
-    term_iter_init_w_idr(term, iter, idr, empty_tables);
+    return NULL;
 }
 
-ecs_iter_t ecs_term_iter(
-    const ecs_world_t *stage,
-    ecs_term_t *term)
-{
-    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    const ecs_world_t *world = ecs_get_world(stage);
-
-    flecs_process_pending_tables(world);
-
-    if (ecs_term_finalize(world, term)) {
-        ecs_throw(ECS_INVALID_PARAMETER, NULL);
-    }
-
-    ecs_iter_t it = {
-        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .field_count = 1,
-        .next = ecs_term_next
-    };
-
-    /* Term iter populates the iterator with arrays from its own cache, ensure 
-     * they don't get overwritten by flecs_iter_validate.
-     *
-     * Note: the reason the term iterator doesn't use the iterator cache itself
-     * (which could easily accommodate a single term) is that the filter iterator
-     * is built on top of the term iterator. The private cache of the term
-     * iterator keeps the filter iterator code simple, as it doesn't need to
-     * worry about the term iter overwriting the iterator fields. */
-    flecs_iter_init(stage, &it, 0);
-    term_iter_init(world, term, &it.priv.iter.term, false);
-    ECS_BIT_COND(it.flags, EcsIterNoData, it.priv.iter.term.size == 0);
-
-    return it;
-error:
-    return (ecs_iter_t){ 0 };
-}
+static
+void flecs_emit_forward_up(
+    ecs_world_t *world,
+    const ecs_event_record_t *er,
+    const ecs_event_record_t *er_onset,
+    const ecs_type_t *emit_ids,
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    ecs_id_record_t *idr,
+    ecs_vec_t *stack,
+    ecs_vec_t *reachable_ids);
 
-ecs_iter_t ecs_term_chain_iter(
-    const ecs_iter_t *chain_it,
-    ecs_term_t *term)
+static
+void flecs_emit_forward_id(
+    ecs_world_t *world,
+    const ecs_event_record_t *er,
+    const ecs_event_record_t *er_onset,
+    const ecs_type_t *emit_ids,
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    ecs_id_record_t *idr,
+    ecs_entity_t tgt,
+    ecs_table_t *tgt_table,
+    int32_t column,
+    int32_t offset,
+    ecs_entity_t trav)
 {
-    ecs_check(chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_id_t id = idr->id;
+    ecs_entity_t event = er ? er->event : 0;
+    bool inherit = trav == EcsIsA;
+    bool may_override = inherit && (event == EcsOnAdd) && (emit_ids->count > 1);
+    ecs_event_id_record_t *iders[5];
+    ecs_event_id_record_t *iders_onset[5];
 
-    ecs_world_t *world = chain_it->real_world;
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    /* Skip id if there are no observers for it */
+    int32_t ider_i, ider_count = flecs_event_observers_get(er, id, iders);
+    int32_t ider_onset_i, ider_onset_count = 0;
+    if (er_onset) {
+        ider_onset_count = flecs_event_observers_get(
+            er_onset, id, iders_onset);
+    }
 
-    if (ecs_term_finalize(world, term)) {
-        ecs_throw(ECS_INVALID_PARAMETER, NULL);
+    if (!may_override && (!ider_count && !ider_onset_count)) {
+        return;
     }
 
-    ecs_iter_t it = {
-        .real_world = world,
-        .world = chain_it->world,
-        .terms = term,
-        .field_count = 1,
-        .chain_it = ECS_CONST_CAST(ecs_iter_t*, chain_it),
-        .next = ecs_term_next
-    };
+    it->ids[0] = id;
+    it->sources[0] = tgt;
+    it->event_id = id;
+    it->ptrs[0] = NULL;
+    ECS_CONST_CAST(int32_t*, it->sizes)[0] = 0; /* safe, owned by observer */
 
-    flecs_iter_init(chain_it->world, &it, flecs_iter_cache_all);
+    int32_t storage_i = ecs_table_type_to_column_index(tgt_table, column);
+    if (storage_i != -1) {
+        ecs_assert(idr->type_info != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_column_t *c = &tgt_table->data.columns[storage_i];
+        it->ptrs[0] = ecs_vec_get(&c->data, c->ti->size, offset);
+        ECS_CONST_CAST(int32_t*, it->sizes)[0] = c->ti->size; /* safe, see above */
+    }
 
-    term_iter_init(world, term, &it.priv.iter.term, false);
+    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+    bool owned = tr != NULL;
 
-    return it;
-error:
-    return (ecs_iter_t){ 0 };
-}
+    for (ider_i = 0; ider_i < ider_count; ider_i ++) {
+        ecs_event_id_record_t *ider = iders[ider_i];
+        flecs_observers_invoke(world, &ider->up, it, table, trav);
 
-ecs_iter_t flecs_children(
-    const ecs_world_t *stage,
-    ecs_entity_t rel,
-    ecs_entity_t parent)
-{
-    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
+        /* Owned takes precedence */
+        if (!owned) {
+            flecs_observers_invoke(world, &ider->self_up, it, table, trav);
+        }
+    }
 
-    const ecs_world_t *world = ecs_get_world(stage);
+    /* Emit OnSet events for newly inherited components */
+    if (storage_i != -1) {
+        bool override = false;
 
-    flecs_process_pending_tables(world);
+        /* If component was added together with IsA relationship, still emit
+         * OnSet event, as it's a new value for the entity. */
+        void *base_ptr = it->ptrs[0];
+        void *ptr = flecs_override(it, emit_ids, id, table, idr);
+        if (ptr) {
+            override = true;
+            it->ptrs[0] = ptr;
+        }
 
-    ecs_iter_t it = {
-        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .field_count = 1,
-        .next = ecs_children_next
-    };
-    
-    ecs_id_t id = ecs_pair(rel, parent);
+        if (ider_onset_count) {
+            it->event = er_onset->event;
 
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return it;
-    }
+            for (ider_onset_i = 0; ider_onset_i < ider_onset_count; ider_onset_i ++) {
+                ecs_event_id_record_t *ider = iders_onset[ider_onset_i];
+                flecs_observers_invoke(world, &ider->up, it, table, trav);
 
-    ecs_term_iter_t *each_iter = &it.priv.iter.term;
-    each_iter->id = id;
-    each_iter->subject = 0;
-    each_iter->size = 0;
-    flecs_table_cache_iter((ecs_table_cache_t*)idr, &each_iter->it);
+                /* Owned takes precedence */
+                if (!owned) {
+                    flecs_observers_invoke(
+                        world, &ider->self_up, it, table, trav);
+                } else if (override) {
+                    ecs_entity_t src = it->sources[0];
+                    it->sources[0] = 0;
+                    flecs_observers_invoke(world, &ider->self, it, table, 0);
+                    flecs_observers_invoke(world, &ider->self_up, it, table, 0);
+                    it->sources[0] = src;
+                }
+            }
 
-    return it;
-error:
-    return (ecs_iter_t){0};
+            it->event = event;
+            it->ptrs[0] = base_ptr;
+        }
+    }
 }
 
-ecs_iter_t ecs_children(
-    const ecs_world_t *stage,
-    ecs_entity_t parent)
+static
+void flecs_emit_forward_and_cache_id(
+    ecs_world_t *world,
+    const ecs_event_record_t *er,
+    const ecs_event_record_t *er_onset,
+    const ecs_type_t *emit_ids,
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    ecs_id_record_t *idr,
+    ecs_entity_t tgt,
+    ecs_record_t *tgt_record,
+    ecs_table_t *tgt_table,
+    const ecs_table_record_t *tgt_tr,
+    int32_t column,
+    int32_t offset,
+    ecs_vec_t *reachable_ids,
+    ecs_entity_t trav)
 {
-    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    const ecs_world_t *world = ecs_get_world(stage);
+    /* Cache forwarded id for (rel, tgt) pair */
+    ecs_reachable_elem_t *elem = ecs_vec_append_t(&world->allocator,
+        reachable_ids, ecs_reachable_elem_t);
+    elem->tr = tgt_tr;
+    elem->record = tgt_record;
+    elem->src = tgt;
+    elem->id = idr->id;
+#ifndef NDEBUG
+    elem->table = tgt_table;
+#endif
+    ecs_assert(tgt_table == tgt_record->table, ECS_INTERNAL_ERROR, NULL);
 
-    flecs_process_pending_tables(world);
+    flecs_emit_forward_id(world, er, er_onset, emit_ids, it, table, idr,
+        tgt, tgt_table, column, offset, trav);
+}
 
-    ecs_iter_t it = {
-        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .field_count = 1,
-        .next = ecs_children_next
-    };
-    
-    ecs_id_t id = ecs_childof(parent);
+static
+int32_t flecs_emit_stack_at(
+    ecs_vec_t *stack,
+    ecs_id_record_t *idr)
+{
+    int32_t sp = 0, stack_count = ecs_vec_count(stack);
+    ecs_table_t **stack_elems = ecs_vec_first(stack);
 
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return it;
+    for (sp = 0; sp < stack_count; sp ++) {
+        ecs_table_t *elem = stack_elems[sp];
+        if (flecs_id_record_get_table(idr, elem)) {
+            break;
+        }
     }
 
-    ecs_term_iter_t *each_iter = &it.priv.iter.term;
-    each_iter->id = id;
-    each_iter->subject = 0;
-    each_iter->size = 0;
-    flecs_table_cache_iter((ecs_table_cache_t*)idr, &each_iter->it);
-
-    return it;
-error:
-    return (ecs_iter_t){0};
+    return sp;
 }
 
-bool ecs_children_next(
-    ecs_iter_t *it)
+static
+bool flecs_emit_stack_has(
+    ecs_vec_t *stack,
+    ecs_id_record_t *idr)
 {
-    ecs_term_iter_t *each_iter = &it->priv.iter.term;
-    ecs_table_record_t *next = flecs_table_cache_next(
-        &each_iter->it, ecs_table_record_t);
-    it->flags |= EcsIterIsValid;
-    if (next) {
-        ecs_table_t *table = next->hdr.table;
-        it->table = table;
-        it->count = ecs_table_count(table);
-        it->entities = flecs_table_entities_array(table);
-        it->ids = &table->type.array[next->index];
-        it->sources = &each_iter->subject;
-        it->sizes = &each_iter->size;
-        it->columns = NULL;
-        it->ptrs = NULL;
-        return true;
-    } else {
-        return false;
-    }
+    return flecs_emit_stack_at(stack, idr) != ecs_vec_count(stack);
 }
 
 static
-const ecs_table_record_t *flecs_term_iter_next_table(
-    ecs_term_iter_t *iter)
+void flecs_emit_forward_cached_ids(
+    ecs_world_t *world,
+    const ecs_event_record_t *er,
+    const ecs_event_record_t *er_onset,
+    const ecs_type_t *emit_ids,
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    ecs_reachable_cache_t *rc,
+    ecs_vec_t *reachable_ids,
+    ecs_vec_t *stack,
+    ecs_entity_t trav)
 {
-    ecs_id_record_t *idr = iter->cur;
-    if (!idr) {
-        return NULL;
-    }
+    ecs_reachable_elem_t *elems = ecs_vec_first_t(&rc->ids, 
+        ecs_reachable_elem_t);
+    int32_t i, count = ecs_vec_count(&rc->ids);
+    for (i = 0; i < count; i ++) {
+        ecs_reachable_elem_t *rc_elem = &elems[i];
+        const ecs_table_record_t *rc_tr = rc_elem->tr;
+        ecs_assert(rc_tr != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_id_record_t *rc_idr = (ecs_id_record_t*)rc_tr->hdr.cache;
+        ecs_record_t *rc_record = rc_elem->record;
+
+        ecs_assert(rc_idr->id == rc_elem->id, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(rc_record != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(flecs_entities_get(world, rc_elem->src) == 
+            rc_record, ECS_INTERNAL_ERROR, NULL);
+        ecs_dbg_assert(rc_record->table == rc_elem->table, 
+            ECS_INTERNAL_ERROR, NULL);
+
+        if (flecs_emit_stack_has(stack, rc_idr)) {
+            continue;
+        }
 
-    return flecs_table_cache_next(&iter->it, ecs_table_record_t);
+        int32_t rc_offset = ECS_RECORD_TO_ROW(rc_record->row);
+        flecs_emit_forward_and_cache_id(world, er, er_onset, emit_ids,
+            it, table, rc_idr, rc_elem->src,
+                rc_record, rc_record->table, rc_tr, rc_tr->index,
+                    rc_offset, reachable_ids, trav);
+    }
 }
 
 static
-bool flecs_term_iter_find_superset(
-    ecs_world_t *world, 
-    ecs_table_t *table, 
-    ecs_term_t *term, 
-    ecs_entity_t *source, 
-    ecs_id_t *id, 
-    int32_t *column)
+void flecs_emit_dump_cache(
+    ecs_world_t *world,
+    const ecs_vec_t *vec)
 {
-    ecs_term_id_t *src = &term->src;
-
-    /* Test if following the relationship finds the id */
-    ecs_id_record_t *idr = term->idr;
-    if (world->flags & EcsWorldQuit) {
-        /* During world cleanup the keep_alive assert for id records is no 
-         * longer enforced */
-        idr = NULL;
+    ecs_reachable_elem_t *elems = ecs_vec_first_t(vec, ecs_reachable_elem_t);
+    for (int i = 0; i < ecs_vec_count(vec); i ++) {
+        ecs_reachable_elem_t *elem = &elems[i];
+        char *idstr = ecs_id_str(world, elem->id);
+        char *estr = ecs_id_str(world, elem->src);
+        ecs_dbg_3("- id: %s (%u), src: %s (%u), table: %p", 
+            idstr, (uint32_t)elem->id,
+            estr, (uint32_t)elem->src,
+            elem->table);
+        ecs_os_free(idstr);
+        ecs_os_free(estr);
     }
-    int32_t index = flecs_search_relation_w_idr(world, table, 0, 
-        term->id, src->trav, src->flags, source, id, 0, idr);
-
-    if (index == -1) {
-        *source = 0;
-        return false;
+    if (!ecs_vec_count(vec)) {
+        ecs_dbg_3("- no entries");
     }
-
-    ecs_assert(*source != 0, ECS_INTERNAL_ERROR, NULL);
-
-    *column = (index + 1) * -1;
-
-    return true;
 }
 
 static
-bool flecs_term_iter_next(
+void flecs_emit_forward_table_up(
     ecs_world_t *world,
-    ecs_term_iter_t *iter,
-    bool match_prefab,
-    bool match_disabled)
+    const ecs_event_record_t *er,
+    const ecs_event_record_t *er_onset,
+    const ecs_type_t *emit_ids,
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    ecs_entity_t tgt,
+    ecs_table_t *tgt_table,
+    ecs_record_t *tgt_record,
+    ecs_id_record_t *tgt_idr,
+    ecs_vec_t *stack,
+    ecs_vec_t *reachable_ids)
 {
-    ecs_table_t *table = iter->table;
-    ecs_entity_t source = 0;
-    const ecs_table_record_t *tr;
-    ecs_term_t *term = &iter->term;
-
-    do {
-        if (table) {
-            iter->cur_match ++;
-            if (iter->cur_match >= iter->match_count) {
-                table = NULL;
-            } else {
-                iter->last_column = ecs_search_offset(
-                    world, table, iter->last_column + 1, term->id, 0);
-                iter->column = iter->last_column + 1;
-                if (iter->last_column >= 0) {
-                    iter->id = table->type.array[iter->last_column];
-                }
-            }
-        }
-
-        if (!table) {
-            if (!(tr = flecs_term_iter_next_table(iter))) {
-                if (iter->cur != iter->set_index && iter->set_index != NULL) {
-                    if (iter->observed_table_count != 0) {
-                        iter->cur = iter->set_index;
-                        if (iter->empty_tables) {
-                            flecs_table_cache_all_iter(
-                                &iter->set_index->cache, &iter->it);
-                        } else {
-                            flecs_table_cache_iter(
-                                &iter->set_index->cache, &iter->it);
-                        }
-                        iter->index = 0;
-                        tr = flecs_term_iter_next_table(iter);
-                    }
-                }
-
-                if (!tr) {
-                    return false;
-                }
-            }
-
-            table = tr->hdr.table;
-            if (table->_->traversable_count) {
-                iter->observed_table_count ++;
-            }
+    ecs_allocator_t *a = &world->allocator;
+    int32_t i, id_count = tgt_table->type.count;
+    ecs_id_t *ids = tgt_table->type.array;
+    int32_t offset = ECS_RECORD_TO_ROW(tgt_record->row);
+    int32_t rc_child_offset = ecs_vec_count(reachable_ids);
+    int32_t stack_count = ecs_vec_count(stack);
 
-            if (!match_prefab && (table->flags & EcsTableIsPrefab)) {
-                continue;
-            }
+    /* If tgt_idr is out of sync but is not the current id record being updated,
+     * keep track so that we can update two records for the cost of one. */
+    ecs_reachable_cache_t *rc = &tgt_idr->reachable;
+    bool parent_revalidate = (reachable_ids != &rc->ids) && 
+        (rc->current != rc->generation);
+    if (parent_revalidate) {
+        ecs_vec_reset_t(a, &rc->ids, ecs_reachable_elem_t);
+    }
 
-            if (!match_disabled && (table->flags & EcsTableIsDisabled)) {
-                continue;
-            }
+    if (ecs_should_log_3()) {
+        char *idstr = ecs_id_str(world, tgt_idr->id);
+        ecs_dbg_3("forward events from %s", idstr);
+        ecs_os_free(idstr);
+    }
+    ecs_log_push_3();
 
-            iter->table = table;
-            iter->match_count = tr->count;
-            if (is_any_pair(term->id)) {
-                iter->match_count = 1;
-            }
+    /* Function may have to copy values from overridden components if an IsA
+     * relationship was added together with other components. */
+    ecs_entity_t trav = ECS_PAIR_FIRST(tgt_idr->id);
+    bool inherit = trav == EcsIsA;
 
-            iter->cur_match = 0;
-            iter->last_column = tr->index;
-            iter->column = tr->index + 1;
-            iter->id = flecs_to_public_id(table->type.array[tr->index]);
+    for (i = 0; i < id_count; i ++) {
+        ecs_id_t id = ids[i];
+        ecs_table_record_t *tgt_tr = &tgt_table->_->records[i];
+        ecs_id_record_t *idr = (ecs_id_record_t*)tgt_tr->hdr.cache;
+        if (inherit && (idr->flags & EcsIdDontInherit)) {
+            continue;
         }
 
-        if (iter->cur == iter->set_index) {
-            if (iter->self_index) {
-                if (flecs_id_record_get_table(iter->self_index, table) != NULL) {
-                    /* If the table has the id itself and this term matched Self
-                     * we already matched it */
-                    continue;
+        /* Id has the same relationship, traverse to find ids for forwarding */
+        if (ECS_PAIR_FIRST(id) == trav || ECS_PAIR_FIRST(id) == EcsIsA) {
+            ecs_table_t **t = ecs_vec_append_t(&world->allocator, stack, 
+                ecs_table_t*);
+            t[0] = tgt_table;
+
+            ecs_reachable_cache_t *idr_rc = &idr->reachable;
+            if (idr_rc->current == idr_rc->generation) {
+                /* Cache hit, use cached ids to prevent traversing the same
+                 * hierarchy multiple times. This especially speeds up code 
+                 * where (deep) hierarchies are created. */
+                if (ecs_should_log_3()) {
+                    char *idstr = ecs_id_str(world, id);
+                    ecs_dbg_3("forward cached for %s", idstr);
+                    ecs_os_free(idstr);
                 }
-            }
+                ecs_log_push_3();
+                flecs_emit_forward_cached_ids(world, er, er_onset, emit_ids, it,
+                    table, idr_rc, reachable_ids, stack, trav);
+                ecs_log_pop_3();
+            } else {
+                /* Cache is dirty, traverse upwards */
+                do {
+                    flecs_emit_forward_up(world, er, er_onset, emit_ids, it, 
+                        table, idr, stack, reachable_ids);
+                    if (++i >= id_count) {
+                        break;
+                    }
 
-            if (!flecs_term_iter_find_superset(
-                world, table, term, &source, &iter->id, &iter->column)) 
-            {
-                continue;
+                    id = ids[i];
+                    if (ECS_PAIR_FIRST(id) != trav) {
+                        break;
+                    }
+                } while (true);
             }
 
-            /* The tr->count field refers to the number of relationship instances,
-             * not to the number of matches. Superset terms can only yield a
-             * single match. */
-            iter->match_count = 1;
+            ecs_vec_remove_last(stack);
+            continue;
         }
 
-        break;
-    } while (true);
-
-    iter->subject = source;
-
-    return true;
-}
-
-static
-bool flecs_term_iter_set_table(
-    ecs_world_t *world,
-    ecs_term_iter_t *iter,
-    ecs_table_t *table)
-{
-    const ecs_table_record_t *tr = NULL;
-    const ecs_id_record_t *idr = iter->self_index;
-    if (idr) {
-        tr = ecs_table_cache_get(&idr->cache, table);
-        if (tr) {
-            iter->match_count = tr->count;
-            iter->last_column = tr->index;
-            iter->column = tr->index + 1;
-            iter->id = flecs_to_public_id(table->type.array[tr->index]);
+        int32_t stack_at = flecs_emit_stack_at(stack, idr);
+        if (parent_revalidate && (stack_at == (stack_count - 1))) {
+            /* If parent id record needs to be revalidated, add id */
+            ecs_reachable_elem_t *elem = ecs_vec_append_t(a, &rc->ids, 
+                ecs_reachable_elem_t);
+            elem->tr = tgt_tr;
+            elem->record = tgt_record;
+            elem->src = tgt;
+            elem->id = idr->id;
+#ifndef NDEBUG
+            elem->table = tgt_table;
+#endif
         }
-    }
 
-    if (!tr) {
-        idr = iter->set_index;
-        if (idr) {
-            tr = ecs_table_cache_get(&idr->cache, table);
-            if (!flecs_term_iter_find_superset(world, table, &iter->term, 
-                &iter->subject, &iter->id, &iter->column)) 
-            {
-                return false;
-            }
-            iter->match_count = 1;
+        /* Skip id if it's masked by a lower table in the tree */
+        if (stack_at != stack_count) {
+            continue;
         }
-    }
 
-    if (!tr) {
-        return false;
+        flecs_emit_forward_and_cache_id(world, er, er_onset, emit_ids, it,
+            table, idr, tgt, tgt_record, tgt_table, tgt_tr, i, 
+                offset, reachable_ids, trav);
     }
 
-    /* Populate fields as usual */
-    iter->table = table;
-    iter->cur_match = 0;
-
-    return true;
-}
-
-bool ecs_term_next(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_term_next, ECS_INVALID_PARAMETER, NULL);
-
-    flecs_iter_validate(it);
-
-    ecs_term_iter_t *iter = &it->priv.iter.term;
-    ecs_term_t *term = &iter->term;
-    ecs_world_t *world = it->real_world;
-    ecs_table_t *table;
-
-    it->ids = &iter->id;
-    it->sources = &iter->subject;
-    it->columns = &iter->column;
-    it->terms = &iter->term;
-    it->sizes = &iter->size;
-    it->ptrs = &iter->ptr;
-
-    ecs_iter_t *chain_it = it->chain_it;
-    if (chain_it) {
-        ecs_iter_next_action_t next = chain_it->next;
-        bool match;
-
-        do {
-            if (!next(chain_it)) {
-                goto done;
-            }
+    if (parent_revalidate) {
+        /* If this is not the current cache being updated, but it's marked
+         * as out of date, use intermediate results to populate cache. */
+        int32_t rc_parent_offset = ecs_vec_count(&rc->ids);
 
-            table = chain_it->table;
-            match = flecs_term_match_table(world, term, table,
-                it->ids, it->columns, it->sources, it->match_indices, true,
-                it->flags);
-        } while (!match);
-        goto yield;
+        /* Only add ids that were added for this table */
+        int32_t count = ecs_vec_count(reachable_ids);
+        count -= rc_child_offset;
 
-    } else {
-        if (!flecs_term_iter_next(world, iter, 
-                (term->flags & EcsTermMatchPrefab) != 0, 
-                (term->flags & EcsTermMatchDisabled) != 0)) 
-        {
-            goto done;
+        /* Append ids to any ids that already were added /*/
+        if (count) {
+            ecs_vec_grow_t(a, &rc->ids, ecs_reachable_elem_t, count);
+            ecs_reachable_elem_t *dst = ecs_vec_get_t(&rc->ids, 
+                ecs_reachable_elem_t, rc_parent_offset);
+            ecs_reachable_elem_t *src = ecs_vec_get_t(reachable_ids,
+                ecs_reachable_elem_t, rc_child_offset);
+            ecs_os_memcpy_n(dst, src, ecs_reachable_elem_t, count);
         }
 
-        table = iter->table;
+        rc->current = rc->generation;
 
-        /* Source must either be 0 (EcsThis) or nonzero in case of substitution */
-        ecs_assert(iter->subject || iter->cur != iter->set_index, 
-            ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(iter->table != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (ecs_should_log_3()) {
+            char *idstr = ecs_id_str(world, tgt_idr->id);
+            ecs_dbg_3("cache revalidated for %s:", idstr);
+            ecs_os_free(idstr);
+            flecs_emit_dump_cache(world, &rc->ids);
+        }
     }
 
-yield:
-    flecs_iter_populate_data(world, it, table, 0, ecs_table_count(table), 
-        it->ptrs);
-    ECS_BIT_SET(it->flags, EcsIterIsValid);
-    return true;
-done:
-    ecs_iter_fini(it);
-error:
-    return false;
+    ecs_log_pop_3();
 }
 
 static
-void flecs_init_filter_iter(
+void flecs_emit_forward_up(
+    ecs_world_t *world,
+    const ecs_event_record_t *er,
+    const ecs_event_record_t *er_onset,
+    const ecs_type_t *emit_ids,
     ecs_iter_t *it,
-    const ecs_filter_t *filter)
+    ecs_table_t *table,
+    ecs_id_record_t *idr,
+    ecs_vec_t *stack,
+    ecs_vec_t *reachable_ids)
 {
-    ecs_assert(filter != NULL, ECS_INTERNAL_ERROR, NULL);
-    it->priv.iter.filter.filter = filter;
-    it->field_count = filter->field_count;
+    ecs_id_t id = idr->id;
+    ecs_entity_t tgt = ECS_PAIR_SECOND(id);
+    tgt = flecs_entities_get_alive(world, tgt);
+    ecs_assert(tgt != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_record_t *tgt_record = flecs_entities_try(world, tgt);
+    ecs_table_t *tgt_table;
+    if (!tgt_record || !(tgt_table = tgt_record->table)) {
+        return;
+    }
+
+    flecs_emit_forward_table_up(world, er, er_onset, emit_ids, it, table, 
+        tgt, tgt_table, tgt_record, idr, stack, reachable_ids);
 }
 
-int32_t ecs_filter_pivot_term(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter)
+static
+void flecs_emit_forward(
+    ecs_world_t *world,
+    const ecs_event_record_t *er,
+    const ecs_event_record_t *er_onset,
+    const ecs_type_t *emit_ids,
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    ecs_id_record_t *idr)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_reachable_cache_t *rc = &idr->reachable;
 
-    ecs_term_t *terms = filter->terms;
-    int32_t i, term_count = filter->term_count;
-    int32_t pivot_term = -1, min_count = -1, self_pivot_term = -1;
+    if (rc->current != rc->generation) {
+        /* Cache miss, iterate the tree to find ids to forward */
+        if (ecs_should_log_3()) {
+            char *idstr = ecs_id_str(world, idr->id);
+            ecs_dbg_3("reachable cache miss for %s", idstr);
+            ecs_os_free(idstr);
+        }
+        ecs_log_push_3();
 
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        ecs_id_t id = term->id;
+        ecs_vec_t stack;
+        ecs_vec_init_t(&world->allocator, &stack, ecs_table_t*, 0);
+        ecs_vec_reset_t(&world->allocator, &rc->ids, ecs_reachable_elem_t);
+        flecs_emit_forward_up(world, er, er_onset, emit_ids, it, table, 
+            idr, &stack, &rc->ids);
+        it->sources[0] = 0;
+        ecs_vec_fini_t(&world->allocator, &stack, ecs_table_t*);
 
-        if ((term->oper != EcsAnd) || (i && (term[-1].oper == EcsOr))) {
-            continue;
+        if (it->event == EcsOnAdd || it->event == EcsOnRemove) {
+            /* Only OnAdd/OnRemove events can validate top-level cache, which
+             * is for the id for which the event is emitted. 
+             * The reason for this is that we don't want to validate the cache
+             * while the administration for the mutated entity isn't up to 
+             * date yet. */
+            rc->current = rc->generation;
         }
 
-        if (!ecs_term_match_this(term)) {
-            continue;
+        if (ecs_should_log_3()) {
+            ecs_dbg_3("cache after rebuild:");
+            flecs_emit_dump_cache(world, &rc->ids);
         }
 
-        ecs_id_record_t *idr = flecs_query_id_record_get(world, id);
-        if (!idr) {
-            /* If one of the terms does not match with any data, iterator 
-             * should not return anything */
-            return -2; /* -2 indicates filter doesn't match anything */
+        ecs_log_pop_3();
+    } else {
+        /* Cache hit, use cached values instead of walking the tree */
+        if (ecs_should_log_3()) {
+            char *idstr = ecs_id_str(world, idr->id);
+            ecs_dbg_3("reachable cache hit for %s", idstr);
+            ecs_os_free(idstr);
+            flecs_emit_dump_cache(world, &rc->ids);
         }
 
-        int32_t table_count = flecs_table_cache_count(&idr->cache);
-        if (min_count == -1 || table_count < min_count) {
-            min_count = table_count;
-            pivot_term = i;
-            if ((term->src.flags & EcsTraverseFlags) == EcsSelf) {
-                self_pivot_term = i;
-            }
-        }
-    }
+        ecs_entity_t trav = ECS_PAIR_FIRST(idr->id);
+        ecs_reachable_elem_t *elems = ecs_vec_first_t(&rc->ids, 
+            ecs_reachable_elem_t);
+        int32_t i, count = ecs_vec_count(&rc->ids);
+        for (i = 0; i < count; i ++) {
+            ecs_reachable_elem_t *elem = &elems[i];
+            const ecs_table_record_t *tr = elem->tr;
+            ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_id_record_t *rc_idr = (ecs_id_record_t*)tr->hdr.cache;
+            ecs_record_t *r = elem->record;
 
-    if (self_pivot_term != -1) {
-        pivot_term = self_pivot_term;
+            ecs_assert(rc_idr->id == elem->id, ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(flecs_entities_get(world, elem->src) == r,
+                ECS_INTERNAL_ERROR, NULL);
+            ecs_dbg_assert(r->table == elem->table, ECS_INTERNAL_ERROR, NULL);
+
+            int32_t offset = ECS_RECORD_TO_ROW(r->row);
+            flecs_emit_forward_id(world, er, er_onset, emit_ids, it, table,
+                rc_idr, elem->src, r->table, tr->index, offset, trav);
+        }
     }
 
-    return pivot_term;
-error:
-    return -2;
-}
+    /* Propagate events for new reachable ids downwards */
+    if (table->_->traversable_count) {
+        int32_t i;
+        ecs_entity_t *entities = flecs_table_entities_array(table);
+        entities = ECS_ELEM_T(entities, ecs_entity_t, it->offset);
+        for (i = 0; i < it->count; i ++) {
+            ecs_record_t *r = flecs_entities_get(world, entities[i]);
+            if (r->idr) {
+                break;
+            }
+        }
 
-void flecs_filter_apply_iter_flags(
-    ecs_iter_t *it,
-    const ecs_filter_t *filter)
-{
-    ECS_BIT_COND(it->flags, EcsIterIsInstanced, 
-        ECS_BIT_IS_SET(filter->flags, EcsFilterIsInstanced));
-    ECS_BIT_COND(it->flags, EcsIterNoData,
-        ECS_BIT_IS_SET(filter->flags, EcsFilterNoData));
-    ECS_BIT_COND(it->flags, EcsIterHasCondSet, 
-        ECS_BIT_IS_SET(filter->flags, EcsFilterHasCondSet));
-}
+        if (i != it->count) {
+            ecs_reachable_elem_t *elems = ecs_vec_first_t(&rc->ids, 
+                ecs_reachable_elem_t);
+            int32_t count = ecs_vec_count(&rc->ids);
+            for (i = 0; i < count; i ++) {
+                ecs_reachable_elem_t *elem = &elems[i];
+                const ecs_table_record_t *tr = elem->tr;
+                ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
+                ecs_id_record_t *rc_idr = (ecs_id_record_t*)tr->hdr.cache;
+                ecs_record_t *r = elem->record;
 
-ecs_iter_t flecs_filter_iter_w_flags(
-    const ecs_world_t *stage,
-    const ecs_filter_t *filter,
-    ecs_flags32_t flags)
-{
-    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(filter->flags & (EcsFilterHasPred|EcsFilterHasScopes)),
-        ECS_UNSUPPORTED, NULL);
-    const ecs_world_t *world = ecs_get_world(stage);
-    
-    if (!(flags & EcsIterMatchVar)) {
-        flecs_process_pending_tables(world);
-    }
+                ecs_assert(rc_idr->id == elem->id, ECS_INTERNAL_ERROR, NULL);
+                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
+                ecs_assert(flecs_entities_get(world, elem->src) == r,
+                    ECS_INTERNAL_ERROR, NULL);
+                ecs_dbg_assert(r->table == elem->table, ECS_INTERNAL_ERROR, NULL);
+                (void)r;
 
-    ecs_iter_t it = {
-        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .query = filter,
-        .terms = filter ? filter->terms : NULL,
-        .next = ecs_filter_next,
-        .flags = flags,
-        .sizes = filter->sizes,
-        .system = filter->entity
-    };
+                ecs_event_id_record_t *iders[5] = {0};
+                int32_t ider_count = flecs_event_observers_get(
+                    er, rc_idr->id, iders);
 
-    ecs_filter_iter_t *iter = &it.priv.iter.filter;
-    iter->pivot_term = -1;
-
-    flecs_init_filter_iter(&it, filter);
-    flecs_filter_apply_iter_flags(&it, filter);
-
-    /* Find term that represents smallest superset */
-    if (ECS_BIT_IS_SET(flags, EcsIterIgnoreThis)) {
-        term_iter_init_no_data(&iter->term_iter);
-    } else if (ECS_BIT_IS_SET(filter->flags, EcsFilterMatchThis)) {
-        ecs_term_t *terms = filter->terms;
-        int32_t pivot_term = -1;
-        ecs_check(terms != NULL, ECS_INVALID_PARAMETER, NULL);
-
-        pivot_term = ecs_filter_pivot_term(world, filter);
-        iter->kind = EcsIterEvalTables;
-        iter->pivot_term = pivot_term;
-
-        if (pivot_term == -2) {
-            /* One or more terms have no matching results */
-            term_iter_init_no_data(&iter->term_iter);
-        } else if (pivot_term == -1) {
-            /* No terms meet the criteria to be a pivot term, evaluate filter
-             * against all tables */
-            term_iter_init_wildcard(world, &iter->term_iter, 
-                ECS_BIT_IS_SET(filter->flags, EcsFilterMatchEmptyTables));
-        } else {
-            ecs_assert(pivot_term >= 0, ECS_INTERNAL_ERROR, NULL);
-            term_iter_init(world, &terms[pivot_term], &iter->term_iter,
-                ECS_BIT_IS_SET(filter->flags, EcsFilterMatchEmptyTables));
-        }
-    } else {
-        if (!ECS_BIT_IS_SET(filter->flags, EcsFilterMatchAnything)) {
-            term_iter_init_no_data(&iter->term_iter);
-        } else {
-            iter->kind = EcsIterEvalNone;
+                flecs_propagate_entities(world, it, rc_idr, it->entities, 
+                    it->count, elem->src, iders, ider_count);
+            }
         }
     }
+}
 
-    ECS_BIT_COND(it.flags, EcsIterNoData, 
-        ECS_BIT_IS_SET(filter->flags, EcsFilterNoData));
-
-    if (ECS_BIT_IS_SET(filter->flags, EcsFilterMatchThis)) {
-        /* Make space for one variable if the filter has terms for This var */ 
-        it.variable_count = 1;
+/* The emit function is responsible for finding and invoking the observers 
+ * matching the emitted event. The function is also capable of forwarding events
+ * for newly reachable ids (after adding a relationship) and propagating events
+ * downwards. Both capabilities are not just useful in application logic, but
+ * are also an important building block for keeping query caches in sync. */
+void flecs_emit(
+    ecs_world_t *world,
+    ecs_world_t *stage,
+    ecs_event_desc_t *desc)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->event != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->event != EcsWildcard, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->ids != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->ids->count != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->table != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->observable != NULL, ECS_INVALID_PARAMETER, NULL);
 
-        /* Set variable name array */
-        it.variable_names = ECS_CONST_CAST(char**, filter->variable_names);
+    ecs_time_t t = {0};
+    bool measure_time = world->flags & EcsWorldMeasureSystemTime;
+    if (measure_time) {
+        ecs_time_measure(&t);
     }
 
-    flecs_iter_init(stage, &it, flecs_iter_cache_all);
+    const ecs_type_t *ids = desc->ids;
+    ecs_entity_t event = desc->event;
+    ecs_table_t *table = desc->table, *other_table = desc->other_table;
+    int32_t offset = desc->offset;
+    int32_t i, count = desc->count;
+    ecs_flags32_t table_flags = table->flags;
 
-    return it;
-error:
-    return (ecs_iter_t){ 0 };
-}
+    /* Deferring cannot be suspended for observers */
+    int32_t defer = world->stages[0]->defer;
+    if (defer < 0) {
+        world->stages[0]->defer *= -1;
+    }
 
-ecs_iter_t ecs_filter_iter(
-    const ecs_world_t *stage,
-    const ecs_filter_t *filter)
-{
-    if (filter) {
-        // Ok, only for stats
-        ECS_CONST_CAST(ecs_filter_t*, filter)->eval_count ++;
+    /* Table events are emitted for internal table operations only, and do not
+     * provide component data and/or entity ids. */
+    bool table_event = desc->flags & EcsEventTableOnly;
+    if (!count && !table_event) {
+        /* If no count is provided, forward event for all entities in table */
+        count = ecs_table_count(table) - offset;
     }
 
-    return flecs_filter_iter_w_flags(stage, filter, 0);
-}
+    /* When the NoOnSet flag is provided, no OnSet/UnSet events should be 
+     * generated when new components are inherited. */
+    bool no_on_set = desc->flags & EcsEventNoOnSet;
 
-ecs_iter_t ecs_filter_chain_iter(
-    const ecs_iter_t *chain_it,
-    const ecs_filter_t *filter)
-{
-    ecs_iter_t it = {
-        .query = filter,
-        .terms = filter->terms,
-        .field_count = filter->field_count,
-        .world = chain_it->world,
-        .real_world = chain_it->real_world,
-        .chain_it = ECS_CONST_CAST(ecs_iter_t*, chain_it),
-        .next = ecs_filter_next,
-        .sizes = filter->sizes,
-        .system = filter->entity
-    };
+    /* The world event id is used to determine if an observer has already been
+     * triggered for an event. Observers for multiple components are split up
+     * into multiple observers for a single component, and this counter is used
+     * to make sure a multi observer only triggers once, even if multiple of its
+     * single-component observers trigger. */
+    int32_t evtx = ++world->event_id;
 
-    flecs_iter_init(chain_it->world, &it, flecs_iter_cache_all);
-    ecs_filter_iter_t *iter = &it.priv.iter.filter;
-    flecs_init_filter_iter(&it, filter);
+    ecs_id_t ids_cache = 0;
+    void *ptrs_cache = NULL;
+    ecs_size_t sizes_cache = 0;
+    int32_t columns_cache = 0;
+    ecs_entity_t sources_cache = 0;
 
-    iter->kind = EcsIterEvalChain;
+    ecs_iter_t it = {
+        .world = stage,
+        .real_world = world,
+        .event = event,
+        .event_cur = evtx,
+        .table = table,
+        .field_count = 1,
+        .ids = &ids_cache,
+        .ptrs = &ptrs_cache,
+        .sizes = &sizes_cache,
+        .columns = &columns_cache,
+        .sources = &sources_cache,
+        .other_table = other_table,
+        .offset = offset,
+        .count = count,
+        .param = ECS_CONST_CAST(void*, desc->param),
+        .flags = desc->flags | EcsIterIsValid
+    };
 
-    return it;
-}
+    ecs_observable_t *observable = ecs_get_observable(desc->observable);
+    ecs_check(observable != NULL, ECS_INVALID_PARAMETER, NULL);
 
-bool ecs_filter_next(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_filter_next, ECS_INVALID_PARAMETER, NULL);
+    /* Event records contain all observers for a specific event. In addition to
+     * the emitted event, also request data for the Wildcard event (for 
+     * observers subscribing to the wildcard event), OnSet and UnSet events. The
+     * latter to are used for automatically emitting OnSet/UnSet events for 
+     * inherited components, for example when an IsA relationship is added to an
+     * entity. This doesn't add much overhead, as fetching records is cheap for
+     * builtin event types. */
+    const ecs_event_record_t *er = flecs_event_record_get_if(observable, event);
+    const ecs_event_record_t *wcer = flecs_event_record_get_if(observable, EcsWildcard);
+    const ecs_event_record_t *er_onset = flecs_event_record_get_if(observable, EcsOnSet);
+    const ecs_event_record_t *er_unset = flecs_event_record_get_if(observable, EcsUnSet);
 
-    if (flecs_iter_next_row(it)) {
-        return true;
+    ecs_data_t *storage = NULL;
+    ecs_column_t *columns = NULL;
+    if (count) {
+        storage = &table->data;
+        columns = storage->columns;
+        it.entities = ecs_vec_get_t(&storage->entities, ecs_entity_t, offset);
     }
 
-    return flecs_iter_next_instanced(it, ecs_filter_next_instanced(it));
-error:
-    return false;
-}
-
-bool ecs_filter_next_instanced(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_filter_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->chain_it != it, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_filter_iter_t *iter = &it->priv.iter.filter;
-    const ecs_filter_t *filter = iter->filter;
-    ecs_world_t *world = it->real_world;
-    ecs_table_t *table = NULL;
-    bool match;
-
-    flecs_iter_validate(it);
-
-    ecs_iter_t *chain_it = it->chain_it;
-    ecs_iter_kind_t kind = iter->kind;
-
-    if (chain_it) {
-        ecs_assert(kind == EcsIterEvalChain, ECS_INVALID_PARAMETER, NULL);
-        
-        ecs_iter_next_action_t next = chain_it->next;
-        do {
-            if (!next(chain_it)) {
-                goto done;
-            }
+    int32_t id_count = ids->count;
+    ecs_id_t *id_array = ids->array;
 
-            table = chain_it->table;
-            match = flecs_filter_match_table(world, filter, table,
-                it->ids, it->columns, it->sources, it->match_indices, NULL, 
-                true, -1, it->flags);
-        } while (!match);
+    /* If a table has IsA relationships, OnAdd/OnRemove events can trigger 
+     * (un)overriding a component. When a component is overridden its value is
+     * initialized with the value of the overridden component. */
+    bool can_override = count && (table_flags & EcsTableHasIsA) && (
+        (event == EcsOnAdd) || (event == EcsOnRemove));
 
-        goto yield;
-    } else if (kind == EcsIterEvalTables || kind == EcsIterEvalCondition) {
-        ecs_term_iter_t *term_iter = &iter->term_iter;
-        ecs_term_t *term = &term_iter->term;
-        int32_t pivot_term = iter->pivot_term;
-        bool first;
+    /* When a new (traversable) relationship is added (emitting an OnAdd/OnRemove
+     * event) this will cause the components of the target entity to be 
+     * propagated to the source entity. This makes it possible for observers to
+     * get notified of any new reachable components though the relationship. */
+    bool can_forward = event != EcsOnSet;
 
-        /* Check if the This variable has been set on the iterator. If set,
-         * the filter should only be applied to the variable value */
-        ecs_var_t *this_var = NULL;
-        ecs_table_t *this_table = NULL;
-        if (it->variable_count) {
-            if (ecs_iter_var_is_constrained(it, 0)) {
-                this_var = it->variables;
-                this_table = this_var->range.table;
+    /* Does table has observed entities */
+    bool has_observed = table_flags & EcsTableHasTraversable;
 
-                /* If variable is constrained, make sure it's a value that's
-                 * pointing to a table, as a filter can't iterate single
-                 * entities (yet) */
-                ecs_assert(this_table != NULL, ECS_INVALID_OPERATION, NULL);
+    /* When a relationship is removed, the events reachable through that 
+     * relationship should emit UnSet events. This is part of the behavior that
+     * allows observers to be agnostic of whether a component is inherited. */
+    bool can_unset = count && (event == EcsOnRemove) && !no_on_set;
 
-                /* Can't set variable for filter that does not iterate tables */
-                ecs_assert(kind == EcsIterEvalTables, 
-                    ECS_INVALID_OPERATION, NULL);
-            }
-        }
+    ecs_event_id_record_t *iders[5] = {0};
+    int32_t unset_count = 0;
 
-        do {
-            /* If there are no matches left for the previous table, this is the
-             * first match of the next table. */
-            first = iter->matches_left == 0;
-
-            if (first) {
-                if (kind != EcsIterEvalCondition) {
-                    /* Check if this variable was constrained */
-                    if (this_table != NULL) {                        
-                        /* If this is the first match of a new result and the
-                         * previous result was equal to the value of a 
-                         * constrained var, there's nothing left to iterate */
-                        if (it->table == this_table) {
-                            goto done;
-                        }
+    if (count && can_forward && has_observed) {
+        flecs_emit_propagate_invalidate(world, table, offset, count);
+    }
 
-                        /* If table doesn't match term iterator, it doesn't
-                         * match filter. */
-                        if (!flecs_term_iter_set_table(
-                            world, term_iter, this_table))
-                        {
-                            goto done;
-                        }
+repeat_event:
+    /* This is the core event logic, which is executed for each event. By 
+     * default this is just the event kind from the ecs_event_desc_t struct, but
+     * can also include the Wildcard and UnSet events. The latter is emitted as
+     * counterpart to OnSet, for any removed ids associated with data. */
+    for (i = 0; i < id_count; i ++) {
+        /* Emit event for each id passed to the function. In most cases this 
+         * will just be one id, like a component that was added, removed or set.
+         * In some cases events are emitted for multiple ids.
+         * 
+         * One example is when an id was added with a "With" property, or 
+         * inheriting from a prefab with overrides. In these cases an entity is 
+         * moved directly to the archetype with the additional components. */
+        ecs_id_record_t *idr = NULL;
+        const ecs_type_info_t *ti = NULL;
+        ecs_id_t id = id_array[i];
+        int32_t ider_i, ider_count = 0;
+        bool is_pair = ECS_IS_PAIR(id);
+        void *override_ptr = NULL;
+        ecs_entity_t base = 0;
 
-                        it->offset = this_var->range.offset;
-                        it->count = this_var->range.count;
+        /* Check if this id is a pair of an traversable relationship. If so, we 
+         * may have to forward ids from the pair's target. */
+        if ((can_forward && is_pair) || can_override) {
+            idr = flecs_id_record_get(world, id);
+            ecs_flags32_t idr_flags = idr->flags;
 
-                        /* But if it does, forward it to filter matching */
-                        ecs_assert(term_iter->table == this_table,
-                            ECS_INTERNAL_ERROR, NULL);
+            if (is_pair && (idr_flags & EcsIdTraversable)) {
+                const ecs_event_record_t *er_fwd = NULL;
+                if (ECS_PAIR_FIRST(id) == EcsIsA) {
+                    if (event == EcsOnAdd) {
+                        if (!world->stages[0]->base) {
+                            /* Adding an IsA relationship can trigger prefab
+                             * instantiation, which can instantiate prefab 
+                             * hierarchies for the entity to which the 
+                             * relationship was added. */
+                            ecs_entity_t tgt = ECS_PAIR_SECOND(id);
 
-                    /* If This variable is not constrained, iterate as usual */
-                    } else {
-                        it->offset = 0;
-                        it->count = 0;
-
-                        /* Find new match, starting with the leading term */
-                        if (!flecs_term_iter_next(world, term_iter, 
-                            ECS_BIT_IS_SET(filter->flags, 
-                                EcsFilterMatchPrefab), 
-                            ECS_BIT_IS_SET(filter->flags, 
-                                EcsFilterMatchDisabled))) 
-                        {
-                            goto done;
+                            /* Setting this value prevents flecs_instantiate 
+                             * from being called recursively, in case prefab
+                             * children also have IsA relationships. */
+                            world->stages[0]->base = tgt;
+                            flecs_instantiate(world, tgt, table, offset, count);
+                            world->stages[0]->base = 0;
                         }
-                    }
-
-                    ecs_assert(term_iter->match_count != 0, 
-                        ECS_INTERNAL_ERROR, NULL);
 
-                    if (pivot_term == -1) {
-                        /* Without a pivot term, we're iterating all tables with
-                         * a wildcard, so the match count is meaningless. */
-                        term_iter->match_count = 1;
-                    } else {
-                        it->match_indices[pivot_term] = term_iter->match_count;
+                        /* Adding an IsA relationship will emit OnSet events for
+                         * any new reachable components. */
+                        er_fwd = er_onset;
+                    } else if (event == EcsOnRemove) {
+                        /* Vice versa for removing an IsA relationship. */
+                        er_fwd = er_unset;
                     }
+                }
 
-                    iter->matches_left = term_iter->match_count;
-
-                    /* Filter iterator takes control over iterating all the
-                     * permutations that match the wildcard. */
-                    term_iter->match_count = 1;
-
-                    table = term_iter->table;
+                /* Forward events for components from pair target */
+                flecs_emit_forward(world, er, er_fwd, ids, &it, table, idr);
+                ecs_assert(it.event_cur == evtx, ECS_INTERNAL_ERROR, NULL);
+            }
 
-                    if (pivot_term != -1) {
-                        int32_t index = term->field_index;
-                        it->ids[index] = term_iter->id;
-                        it->sources[index] = term_iter->subject;
-                        it->columns[index] = term_iter->column;
-                    }
-                } else {
-                    /* Progress iterator to next match for table, if any */
-                    table = it->table;
-                    if (term_iter->index == 0) {
-                        iter->matches_left = 1;
-                        term_iter->index = 1; /* prevents looping again */
-                    } else {
-                        goto done;
+            if (can_override && (!(idr_flags & EcsIdDontInherit))) {
+                /* Initialize overridden components with value from base */
+                ti = idr->type_info;
+                if (ti) {
+                    ecs_table_record_t *base_tr = NULL;
+                    int32_t base_column = ecs_search_relation(world, table, 
+                        0, id, EcsIsA, EcsUp, &base, NULL, &base_tr);
+                    if (base_column != -1) {
+                        /* Base found with component */
+                        ecs_table_t *base_table = base_tr->hdr.table;
+                        base_column = base_tr->column;
+                        ecs_assert(base_column != -1, ECS_INTERNAL_ERROR, NULL);
+                        ecs_record_t *base_r = flecs_entities_get(world, base);
+                        ecs_assert(base_r != NULL, ECS_INTERNAL_ERROR, NULL);
+                        int32_t base_row = ECS_RECORD_TO_ROW(base_r->row);
+                        ecs_vec_t *base_v = &base_table->data.columns[base_column].data;
+                        override_ptr = ecs_vec_get(base_v, ti->size, base_row);
                     }
                 }
+            }
+        }
 
-                /* Match the remainder of the terms */
-                int32_t skip_term = pivot_term;
-                if (pivot_term != -1) {
-                    if (ecs_id_is_wildcard(filter->terms[pivot_term].id)) {
-                        skip_term = -1;
-                        iter->matches_left = 1;
-                    }
-                }
+        if (er) {
+            /* Get observer sets for id. There can be multiple sets of matching
+             * observers, in case an observer matches for wildcard ids. For
+             * example, both observers for (ChildOf, p) and (ChildOf, *) would
+             * match an event for (ChildOf, p). */
+            ider_count = flecs_event_observers_get(er, id, iders);
+            idr = idr ? idr : flecs_id_record_get(world, id);
+            ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+        }
 
-                match = flecs_filter_match_table(world, filter, table,
-                    it->ids, it->columns, it->sources,
-                    it->match_indices, &iter->matches_left, first, 
-                    skip_term, it->flags);
-                if (!match) {
-                    it->table = table;
-                    iter->matches_left = 0;
-                    continue;
-                }
+        if (can_unset) {
+            /* Increase UnSet count in case this is a component (has data). This
+             * will cause the event loop to be ran again as UnSet event. */
+            idr = idr ? idr : flecs_id_record_get(world, id);
+            ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+            unset_count += (idr->type_info != NULL);
+        }
 
-                /* Table got matched, set This variable */
-                if (table) {
-                    ecs_assert(it->variable_count == 1, ECS_INTERNAL_ERROR, NULL);
-                    ecs_assert(it->variables != NULL, ECS_INTERNAL_ERROR, NULL);
-                    it->variables[0].range.table = table;
-                }
+        if (!ider_count && !override_ptr) {
+            /* If nothing more to do for this id, early out */
+            continue;
+        }
 
-                ecs_assert(iter->matches_left != 0, ECS_INTERNAL_ERROR, NULL);
-            }
+        ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+        if (tr == NULL) {
+            /* When a single batch contains multiple add's for an exclusive
+             * relationship, it's possible that an id was in the added list
+             * that is no longer available for the entity. */
+            continue;
+        }
+
+        int32_t column = tr->index, storage_i;
+        it.columns[0] = column + 1;
+        it.ptrs[0] = NULL;
+        ECS_CONST_CAST(int32_t*, it.sizes)[0] = 0; /* safe, owned by observer */
+        it.event_id = id;
+        it.ids[0] = id;
 
-            /* If this is not the first result for the table, and the table
-             * is matched more than once, iterate remaining matches */
-            if (!first && (iter->matches_left > 0)) {
-                table = it->table;
+        if (count) {
+            storage_i = tr->column;
+            if (storage_i != -1) {
+                /* If this is a component, fetch pointer & size */
+                ecs_assert(idr->type_info != NULL, ECS_INTERNAL_ERROR, NULL);
+                ecs_column_t *c = &columns[storage_i];
+                ecs_size_t size = c->ti->size;
+                void *ptr = ecs_vec_get(&c->data, size, offset);
+                /* safe, owned by observer */
+                ECS_CONST_CAST(int32_t*, it.sizes)[0] = size;
 
-                /* Find first term that still has matches left */
-                int32_t i, j, count = it->field_count;
-                for (i = count - 1; i >= 0; i --) {
-                    int32_t mi = -- it->match_indices[i];
-                    if (mi) {
-                        if (mi < 0) {
-                            continue;
+                if (override_ptr) {
+                    if (event == EcsOnAdd) {
+                        /* If this is a new override, initialize the component
+                         * with the value of the overridden component. */
+                        flecs_override_copy(
+                            world, table, ti, ptr, override_ptr, offset, count);
+                    } else if (er_onset) {
+                        /* If an override was removed, this re-exposes the
+                         * overridden component. Because this causes the actual
+                         * (now inherited) value of the component to change, an
+                         * OnSet event must be emitted for the base component.*/
+                        ecs_assert(event == EcsOnRemove, ECS_INTERNAL_ERROR, NULL);
+                        ecs_event_id_record_t *iders_set[5] = {0};
+                        int32_t ider_set_i, ider_set_count = 
+                            flecs_event_observers_get(er_onset, id, iders_set);
+                        if (ider_set_count) {
+                            /* Set the source temporarily to the base and base
+                             * component pointer. */
+                            it.sources[0] = base;
+                            it.ptrs[0] = ptr;
+                            for (ider_set_i = 0; ider_set_i < ider_set_count; ider_set_i ++) {
+                                ecs_event_id_record_t *ider = iders_set[ider_set_i];
+                                flecs_observers_invoke(
+                                    world, &ider->self_up, &it, table, EcsIsA);
+                                ecs_assert(it.event_cur == evtx, 
+                                    ECS_INTERNAL_ERROR, NULL);
+                                flecs_observers_invoke(
+                                    world, &ider->up, &it, table, EcsIsA);
+                                ecs_assert(it.event_cur == evtx, 
+                                    ECS_INTERNAL_ERROR, NULL);
+                            }
+                            it.sources[0] = 0;
                         }
-                        break;
                     }
                 }
 
-                /* If matches_left > 0 we should've found at least one match */
-                ecs_assert(i >= 0, ECS_INTERNAL_ERROR, NULL);
-
-                /* Progress first term to next match (must be at least one) */
-                int32_t column = it->columns[i];
-                if (column < 0) {
-                    /* If this term was matched on a non-This entity, reconvert
-                     * the column back to a positive value */
-                    column = -column;
-                }
-
-                int32_t t, term_count = filter->term_count;
-                ecs_term_t *cur_term = NULL;
-                for (t = 0; t < term_count; t ++) {
-                    if (filter->terms[t].field_index == i) {
-                        cur_term = &filter->terms[t];
-                        break;
-                    }
+                it.ptrs[0] = ptr;
+            } else {
+                if (it.event == EcsUnSet) {
+                    /* Only valid for components, not tags */
+                    continue;
                 }
+            }
+        }
 
-                ecs_assert(term != NULL, ECS_INTERNAL_ERROR, NULL);
+        /* Actually invoke observers for this event/id */
+        for (ider_i = 0; ider_i < ider_count; ider_i ++) {
+            ecs_event_id_record_t *ider = iders[ider_i];
+            flecs_observers_invoke(world, &ider->self, &it, table, 0);
+            ecs_assert(it.event_cur == evtx, ECS_INTERNAL_ERROR, NULL);
+            flecs_observers_invoke(world, &ider->self_up, &it, table, 0);
+            ecs_assert(it.event_cur == evtx, ECS_INTERNAL_ERROR, NULL);
+        }
 
-                it->columns[i] = column + 1;
-                flecs_term_match_table(world, cur_term, table, 
-                    &it->ids[i], &it->columns[i], &it->sources[i],
-                    &it->match_indices[i], false, it->flags);
+        if (!ider_count || !count || !has_observed) {
+            continue;
+        }
 
-                /* Reset remaining terms (if any) to first match */
-                for (j = i + 1; j < count; j ++) {
-                    flecs_term_match_table(world, &filter->terms[j], table, 
-                        &it->ids[j], &it->columns[j], &it->sources[j], 
-                        &it->match_indices[j], true, it->flags);
-                }
-            }
+        /* The table->traversable_count value indicates if the table contains any
+         * entities that are used as targets of traversable relationships. If the
+         * entity/entities for which the event was generated is used as such a
+         * target, events must be propagated downwards. */
+        flecs_propagate_entities(
+            world, &it, idr, it.entities, count, 0, iders, ider_count);
+    }
 
-            match = iter->matches_left != 0;
-            iter->matches_left --;
+    can_override = false; /* Don't override twice */
+    can_unset = false; /* Don't unset twice */
+    can_forward = false; /* Don't forward twice */
 
-            ecs_assert(iter->matches_left >= 0, ECS_INTERNAL_ERROR, NULL);
-        } while (!match);
+    if (unset_count && er_unset && (er != er_unset)) {
+        /* Repeat event loop for UnSet event */
+        unset_count = 0;
+        er = er_unset;
+        it.event = EcsUnSet;
+        goto repeat_event;
+    }
 
-        goto yield;
+    if (wcer && er != wcer) {
+        /* Repeat event loop for Wildcard event */
+        er = wcer;
+        it.event = event;
+        goto repeat_event;
     }
 
-done:
 error:
-    ecs_iter_fini(it);
-    return false;
+    world->stages[0]->defer = defer;
 
-yield:
-    if (!it->count && table) {
-        it->count = ecs_table_count(table);
+    if (measure_time) {
+        world->info.emit_time_total += (ecs_ftime_t)ecs_time_measure(&t);
     }
-    flecs_iter_populate_data(world, it, table, it->offset, it->count, it->ptrs);
-    ECS_BIT_SET(it->flags, EcsIterIsValid);
-    return true;    
+    return;
 }
 
-/**
- * @file iter.c
- * @brief Iterator API.
- * 
- * The iterator API contains functions that apply to all iterators, such as
- * resource management, or fetching resources for a matched table. The API also
- * contains functions for generic iterators, which make it possible to iterate
- * an iterator without needing to know what created the iterator.
- */
-
-#include <stddef.h>
-
-/* Utility macros to enforce consistency when initializing iterator fields */
+void ecs_emit(
+    ecs_world_t *stage,
+    ecs_event_desc_t *desc)
+{
+    ecs_world_t *world = ECS_CONST_CAST(ecs_world_t*, ecs_get_world(stage));
+    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!(desc->param && desc->const_param), ECS_INVALID_PARAMETER, 
+        "cannot set param and const_param at the same time");
 
-/* If term count is smaller than cache size, initialize with inline array,
- * otherwise allocate. */
-#define INIT_CACHE(it, stack, fields, f, T, count)\
-    if (!it->f && (fields & flecs_iter_cache_##f) && count) {\
-        it->f = flecs_stack_calloc_n(stack, T, count);\
-        it->priv.cache.used |= flecs_iter_cache_##f;\
+    if (desc->entity) {
+        ecs_assert(desc->table == NULL, ECS_INVALID_PARAMETER, NULL);
+        ecs_assert(desc->offset == 0, ECS_INVALID_PARAMETER, NULL);
+        ecs_assert(desc->count == 0, ECS_INVALID_PARAMETER, NULL);
+        ecs_record_t *r = flecs_entities_get(world, desc->entity);
+        ecs_table_t *table;
+        if (!r || !(table = r->table)) {
+            /* Empty entities can't trigger observers */
+            return;
+        }
+        desc->table = table;
+        desc->offset = ECS_RECORD_TO_ROW(r->row);
+        desc->count = 1;
     }
 
-/* If array is allocated, free it when finalizing the iterator */
-#define FINI_CACHE(it, f, T, count)\
-    if (it->priv.cache.used & flecs_iter_cache_##f) {\
-        flecs_stack_free_n((void*)it->f, T, count);\
+    if (!desc->observable) {
+        desc->observable = world;
     }
 
-void* flecs_iter_calloc(
-    ecs_iter_t *it,
-    ecs_size_t size,
-    ecs_size_t align)
-{
-    ecs_world_t *world = it->world;
-    ecs_stage_t *stage = flecs_stage_from_world((ecs_world_t**)&world);
-    ecs_stack_t *stack = &stage->allocators.iter_stack;
-    return flecs_stack_calloc(stack, size, align); 
-}
-
-void flecs_iter_free(
-    void *ptr,
-    ecs_size_t size)
-{
-    flecs_stack_free(ptr, size);
-}
+    ecs_type_t default_ids = (ecs_type_t){ 
+        .count = 1, 
+        .array = (ecs_id_t[]){ EcsAny }
+    };
 
-void flecs_iter_init(
-    const ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_flags8_t fields)
-{
-    ecs_assert(!ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
-        ECS_INTERNAL_ERROR, NULL);
+    if (!desc->ids || !desc->ids->count) {
+        desc->ids = &default_ids;
+    }
 
-    ecs_stage_t *stage = flecs_stage_from_world(
-        ECS_CONST_CAST(ecs_world_t**, &world));
-    ecs_stack_t *stack = &stage->allocators.iter_stack;
+    if (desc->const_param) {
+        desc->param = ECS_CONST_CAST(void*, desc->const_param);
+        desc->const_param = NULL;
+    }
 
-    it->priv.cache.used = 0;
-    it->priv.cache.allocated = 0;
-    it->priv.cache.stack_cursor = flecs_stack_get_cursor(stack);
-    it->priv.entity_iter = flecs_stack_calloc_t(
-        stack, ecs_entity_filter_iter_t);
+    flecs_emit(world, stage, desc);
 
-    INIT_CACHE(it, stack, fields, ids, ecs_id_t, it->field_count);
-    INIT_CACHE(it, stack, fields, sources, ecs_entity_t, it->field_count);
-    INIT_CACHE(it, stack, fields, match_indices, int32_t, it->field_count);
-    INIT_CACHE(it, stack, fields, columns, int32_t, it->field_count);
-    INIT_CACHE(it, stack, fields, variables, ecs_var_t, it->variable_count);
-    INIT_CACHE(it, stack, fields, ptrs, void*, it->field_count);
+    if (desc->ids == &default_ids) {
+        desc->ids = NULL;
+    }
+error:
+    return;
 }
 
-void flecs_iter_validate(
-    ecs_iter_t *it)
+void ecs_enqueue(
+    ecs_world_t *world,
+    ecs_event_desc_t *desc)
 {
-    ECS_BIT_SET(it->flags, EcsIterIsValid);
+    ecs_check(ecs_is_deferred(world), ECS_INVALID_PARAMETER, 
+        "can't enqueue if not in deferred mode");
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
 
-    /* Make sure multithreaded iterator isn't created for real world */
-    ecs_world_t *world = it->real_world;
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(!(world->flags & EcsWorldMultiThreaded) || it->world != it->real_world,
-        ECS_INVALID_PARAMETER, 
-            "create iterator for stage when world is in multithreaded mode");
-    (void)world;
+    flecs_enqueue(world, stage, desc);
 error:
     return;
 }
 
-void ecs_iter_fini(
-    ecs_iter_t *it)
-{
-    ECS_BIT_CLEAR(it->flags, EcsIterIsValid);
+/**
+ * @file observer.c
+ * @brief Observer implementation.
+ * 
+ * The observer implementation contains functions for creating, deleting and
+ * invoking observers. The code is split up into single-term observers and 
+ * multi-term observers. Multi-term observers are created from multiple single-
+ * term observers.
+ */
 
-    if (it->fini) {
-        it->fini(it);
-    }
+#include <stddef.h>
 
-    ecs_world_t *world = it->world;
-    if (!world) {
-        return;
+static
+ecs_entity_t flecs_get_observer_event(
+    ecs_term_t *term,
+    ecs_entity_t event)
+{
+    /* If operator is Not, reverse the event */
+    if (term->oper == EcsNot) {
+        if (event == EcsOnAdd) {
+            event = EcsOnRemove;
+        } else if (event == EcsOnRemove) {
+            event = EcsOnAdd;
+        }
     }
 
-    FINI_CACHE(it, ids, ecs_id_t, it->field_count);
-    FINI_CACHE(it, sources, ecs_entity_t, it->field_count);
-    FINI_CACHE(it, match_indices, int32_t, it->field_count);
-    FINI_CACHE(it, columns, int32_t, it->field_count);
-    FINI_CACHE(it, variables, ecs_var_t, it->variable_count);
-    FINI_CACHE(it, ptrs, void*, it->field_count);
-    flecs_stack_free_t(it->priv.entity_iter, ecs_entity_filter_iter_t);
-
-    ecs_stage_t *stage = flecs_stage_from_world(&world);
-    flecs_stack_restore_cursor(&stage->allocators.iter_stack, 
-        it->priv.cache.stack_cursor);
+    return event;
 }
 
 static
-bool flecs_iter_populate_term_data(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    int32_t t,
-    int32_t column,
-    void **ptr_out)
+ecs_flags32_t flecs_id_flag_for_event(
+    ecs_entity_t e)
 {
-    bool is_shared = false;
-    ecs_table_t *table;
-    void *data;
-    int32_t row, u_index;
-
-    if (!column) {
-        /* Term has no data. This includes terms that have Not operators. */
-        goto no_data;
+    if (e == EcsOnAdd) {
+        return EcsIdHasOnAdd;
     }
-
-    /* Filter terms may match with data but don't return it */
-    if (it->terms[t].inout == EcsInOutNone) {
-        goto no_data;
+    if (e == EcsOnRemove) {
+        return EcsIdHasOnRemove;
     }
-
-    ecs_assert(it->sizes != NULL, ECS_INTERNAL_ERROR, NULL);
-    int32_t size = it->sizes[t];
-    if (!size) {
-        goto no_data;
+    if (e == EcsOnSet) {
+        return EcsIdHasOnSet;
     }
+    if (e == EcsUnSet) {
+        return EcsIdHasUnSet;
+    }
+    if (e == EcsOnTableFill) {
+        return EcsIdHasOnTableFill;
+    }
+    if (e == EcsOnTableEmpty) {
+        return EcsIdHasOnTableEmpty;
+    }
+    if (e == EcsOnTableCreate) {
+        return EcsIdHasOnTableCreate;
+    }
+    if (e == EcsOnTableDelete) {
+        return EcsIdHasOnTableDelete;
+    }
+    return 0;
+}
 
-    if (column < 0) {
-        table = it->table;
-        is_shared = true;
-
-        /* Data is not from This */
-        if (it->references && (!table || !(table->flags & EcsTableHasTarget))) {
-            /* The reference array is used only for components matched on a
-             * table (vs. individual entities). Remaining components should be
-             * assigned outside of this function */
-            if (ecs_term_match_this(&it->terms[t])) {
-
-                /* Iterator provides cached references for non-This terms */
-                ecs_ref_t *ref = &it->references[-column - 1];
-                if (ptr_out) {
-                    if (ref->id) {
-                        ptr_out[0] = (void*)ecs_ref_get_id(world, ref, ref->id);
-                    } else {
-                        ptr_out[0] = NULL;
-                    }
-                }
-
-                if (!ref->id) {
-                    is_shared = false;
-                }
-
-                return is_shared;
-            }
-
-            return true;
-        } else {
-            ecs_entity_t subj = it->sources[t];
-            ecs_assert(subj != 0, ECS_INTERNAL_ERROR, NULL);
-
-            /* Don't use ecs_get_id directly. Instead, go directly to the
-             * storage so that we can get both the pointer and size */
-            ecs_record_t *r = flecs_entities_get(world, subj);
-            ecs_assert(r != NULL && r->table != NULL, ECS_INTERNAL_ERROR, NULL);
-
-            row = ECS_RECORD_TO_ROW(r->row);
-            table = r->table;
-
-            ecs_id_t id = it->ids[t];
-            ecs_table_record_t *tr;
+static
+void flecs_inc_observer_count(
+    ecs_world_t *world,
+    ecs_entity_t event,
+    ecs_event_record_t *evt,
+    ecs_id_t id,
+    int32_t value)
+{
+    ecs_event_id_record_t *idt = flecs_event_id_record_ensure(world, evt, id);
+    ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL);
+    
+    int32_t result = idt->observer_count += value;
+    if (result == 1) {
+        /* Notify framework that there are observers for the event/id. This 
+         * allows parts of the code to skip event evaluation early */
+        flecs_notify_tables(world, id, &(ecs_table_event_t){
+            .kind = EcsTableTriggersForId,
+            .event = event
+        });
 
-            if (!(tr = flecs_table_record_get(world, table, id)) || (tr->column == -1)) {
-                u_index = flecs_table_column_to_union_index(table, -column - 1);
-                if (u_index != -1) {
-                    goto has_union;
-                }
-                goto no_data;
+        ecs_flags32_t flags = flecs_id_flag_for_event(event);
+        if (flags) {
+            ecs_id_record_t *idr = flecs_id_record_get(world, id);
+            if (idr) {
+                idr->flags |= flags;
             }
-
-            /* We now have row and column, so we can get the storage for the id
-             * which gives us the pointer and size */
-            column = tr->column;
-            ecs_vec_t *s = &table->data.columns[column].data;
-            data = ecs_vec_first(s);
-            /* Fallthrough to has_data */
         }
-    } else {
-        /* Data is from This, use table from iterator */
-        table = it->table;
-        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        row = it->offset;
+    } else if (result == 0) {
+        /* Ditto, but the reverse */
+        flecs_notify_tables(world, id, &(ecs_table_event_t){
+            .kind = EcsTableNoTriggersForId,
+            .event = event
+        });
 
-        int32_t storage_column = ecs_table_type_to_column_index(
-            table, column - 1);
-        if (storage_column == -1) {
-            u_index = flecs_table_column_to_union_index(table, column - 1);
-            if (u_index != -1) {
-                goto has_union;
+        ecs_flags32_t flags = flecs_id_flag_for_event(event);
+        if (flags) {
+            ecs_id_record_t *idr = flecs_id_record_get(world, id);
+            if (idr) {
+                idr->flags &= ~flags;
             }
-            goto no_data;
-        }
-
-        if (!it->count) {
-            goto no_data;
         }
 
-        ecs_vec_t *s = &table->data.columns[storage_column].data;
-        data = ecs_vec_first(s);
-
-        /* Fallthrough to has_data */
-    }
-
-has_data:
-    if (ptr_out) ptr_out[0] = ECS_ELEM(data, size, row);
-    return is_shared;
-
-has_union: {
-        /* Edge case: if column is a switch we should return the vector with case
-         * identifiers. Will be replaced in the future with pluggable storage */
-        ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_switch_t *sw = &table->_->sw_columns[u_index];
-        data = ecs_vec_first(flecs_switch_values(sw));
-        goto has_data;
+        flecs_event_id_record_remove(evt, id);
+        ecs_os_free(idt);
     }
-
-no_data:
-    if (ptr_out) ptr_out[0] = NULL;
-    return false;
 }
 
-void flecs_iter_populate_data(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    int32_t offset,
-    int32_t count,
-    void **ptrs)
+static
+ecs_id_t flecs_observer_id(
+    ecs_id_t id)
 {
-    ecs_table_t *prev_table = it->table;
-    if (prev_table) {
-        it->frame_offset += ecs_table_count(prev_table);
-    }
-
-    it->table = table;
-    it->offset = offset;
-    it->count = count;
-    if (table) {
-        ecs_assert(count != 0 || !ecs_table_count(table) || (it->flags & EcsIterTableOnly), 
-            ECS_INTERNAL_ERROR, NULL);
-        if (count) {
-            it->entities = ecs_vec_get_t(
-                &table->data.entities, ecs_entity_t, offset);
-        } else {
-            it->entities = NULL;
+    if (ECS_IS_PAIR(id)) {
+        if (ECS_PAIR_FIRST(id) == EcsAny) {
+            id = ecs_pair(EcsWildcard, ECS_PAIR_SECOND(id));
         }
-    }
-
-    int t, field_count = it->field_count;
-    if (ECS_BIT_IS_SET(it->flags, EcsIterNoData)) {
-        ECS_BIT_CLEAR(it->flags, EcsIterHasShared);
-        return;
-    }
-
-    bool has_shared = false;
-    if (ptrs) {
-        for (t = 0; t < field_count; t ++) {
-            int32_t column = it->columns[t];
-            has_shared |= flecs_iter_populate_term_data(world, it, t, column,
-                &ptrs[t]);
+        if (ECS_PAIR_SECOND(id) == EcsAny) {
+            id = ecs_pair(ECS_PAIR_FIRST(id), EcsWildcard);
         }
     }
 
-    ECS_BIT_COND(it->flags, EcsIterHasShared, has_shared);
+    return id;
 }
 
-bool flecs_iter_next_row(
-    ecs_iter_t *it)
+static
+void flecs_register_observer_for_id(
+    ecs_world_t *world,
+    ecs_observable_t *observable,
+    ecs_observer_t *o,
+    size_t offset)
 {
-    ecs_assert(it != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    ecs_id_t term_id = flecs_observer_id(impl->register_id);
+    ecs_term_t *term = &o->query->terms[0];
+    ecs_entity_t trav = term->trav;
 
-    bool is_instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
-    if (!is_instanced) {
-        int32_t instance_count = it->instance_count;
-        int32_t count = it->count;
-        int32_t offset = it->offset;
+    int i;
+    for (i = 0; i < o->event_count; i ++) {
+        ecs_entity_t event = flecs_get_observer_event(
+            term, o->events[i]);
 
-        if (instance_count > count && offset < (instance_count - 1)) {
-            ecs_assert(count == 1, ECS_INTERNAL_ERROR, NULL);
-            int t, field_count = it->field_count;
+        /* Get observers for event */
+        ecs_event_record_t *er = flecs_event_record_ensure(observable, event);
+        ecs_assert(er != NULL, ECS_INTERNAL_ERROR, NULL);
 
-            for (t = 0; t < field_count; t ++) {
-                ecs_entity_t src = it->sources[t];
-                if (!src) {
-                    void *ptr = it->ptrs[t];
-                    if (ptr) {
-                        it->ptrs[t] = ECS_OFFSET(ptr, it->sizes[t]);
-                    }
-                }
-            }
+        /* Get observers for (component) id for event */
+        ecs_event_id_record_t *idt = flecs_event_id_record_ensure(
+            world, er, term_id);
+        ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL);
 
-            if (it->entities) {
-                it->entities ++;
-            }
-            it->offset ++;
+        ecs_map_t *observers = ECS_OFFSET(idt, offset);
+        ecs_map_init_w_params_if(observers, &world->allocators.ptr);
+        ecs_map_insert_ptr(observers, impl->id, o);
 
-            return true;
+        flecs_inc_observer_count(world, event, er, term_id, 1);
+        if (trav) {
+            flecs_inc_observer_count(world, event, er, 
+                ecs_pair(trav, EcsWildcard), 1);
         }
     }
-
-    return false;
 }
 
-bool flecs_iter_next_instanced(
-    ecs_iter_t *it,
-    bool result)
+static
+void flecs_uni_observer_register(
+    ecs_world_t *world,
+    ecs_observable_t *observable,
+    ecs_observer_t *o)
 {
-    it->instance_count = it->count;
-    bool is_instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
-    bool has_shared = ECS_BIT_IS_SET(it->flags, EcsIterHasShared);
-    if (result && !is_instanced && it->count && has_shared) {
-        it->count = 1;
-    }
+    ecs_term_t *term = &o->query->terms[0];
+    ecs_flags64_t flags = ECS_TERM_REF_FLAGS(&term->src);
 
-    return result;
+    if ((flags & (EcsSelf|EcsUp)) == (EcsSelf|EcsUp)) {
+        flecs_register_observer_for_id(world, observable, o,
+            offsetof(ecs_event_id_record_t, self_up));
+    } else if (flags & EcsSelf) {
+        flecs_register_observer_for_id(world, observable, o,
+            offsetof(ecs_event_id_record_t, self));
+    } else if (flags & EcsUp) {
+        ecs_assert(term->trav != 0, ECS_INTERNAL_ERROR, NULL);
+        flecs_register_observer_for_id(world, observable, o,
+            offsetof(ecs_event_id_record_t, up));
+    }
 }
 
-/* --- Public API --- */
-
-void* ecs_field_w_size(
-    const ecs_iter_t *it,
-    size_t size,
-    int32_t index)
+static
+void flecs_unregister_observer_for_id(
+    ecs_world_t *world,
+    ecs_observable_t *observable,
+    ecs_observer_t *o,
+    size_t offset)
 {
-    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    ecs_id_t term_id = flecs_observer_id(impl->register_id);
+    ecs_term_t *term = &o->query->terms[0];
+    ecs_entity_t trav = term->trav;
 
-    ecs_check(!size || ecs_field_size(it, index) == size ||
-        (!ecs_field_size(it, index) && (!it->ptrs[index - 1])),
-            ECS_INVALID_PARAMETER, NULL);
-    (void)size;
+    int i;
+    for (i = 0; i < o->event_count; i ++) {
+        ecs_entity_t event = flecs_get_observer_event(
+            term, o->events[i]);
 
-    return it->ptrs[index - 1];
-error:
-    return NULL;
-}
+        /* Get observers for event */
+        ecs_event_record_t *er = flecs_event_record_get(observable, event);
+        ecs_assert(er != NULL, ECS_INTERNAL_ERROR, NULL);
 
-bool ecs_field_is_readonly(
-    const ecs_iter_t *it,
-    int32_t index)
-{
-    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    ecs_term_t *term = &it->terms[index - 1];
+        /* Get observers for (component) id */
+        ecs_event_id_record_t *idt = flecs_event_id_record_get(er, term_id);
+        ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    if (term->inout == EcsIn) {
-        return true;
-    } else if (term->inout == EcsInOutDefault) {
-        if (!ecs_term_match_this(term)) {
-            return true;
+        ecs_map_t *id_observers = ECS_OFFSET(idt, offset);
+        ecs_map_remove(id_observers, impl->id);
+        if (!ecs_map_count(id_observers)) {
+            ecs_map_fini(id_observers);
         }
 
-        ecs_term_id_t *src = &term->src;
-        if (!(src->flags & EcsSelf)) {
-            return true;
+        flecs_inc_observer_count(world, event, er, term_id, -1);
+        if (trav) {
+            flecs_inc_observer_count(world, event, er, 
+                ecs_pair(trav, EcsWildcard), -1);
         }
     }
-error:
-    return false;
-}
-
-bool ecs_field_is_writeonly(
-    const ecs_iter_t *it,
-    int32_t index)
-{
-    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    ecs_term_t *term = &it->terms[index - 1];
-    return term->inout == EcsOut;
-error:
-    return false;
 }
 
-bool ecs_field_is_set(
-    const ecs_iter_t *it,
-    int32_t index)
+static
+void flecs_unregister_observer(
+    ecs_world_t *world,
+    ecs_observable_t *observable,
+    ecs_observer_t *o)
 {
-    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    int32_t column = it->columns[index - 1];
-    if (!column) {
-        return false;
-    } else if (column < 0) {
-        if (it->references) {
-            column = -column - 1;
-            ecs_ref_t *ref = &it->references[column];
-            return ref->entity != 0;
-        } else {
-            return true;
-        }
+    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (o->query->term_count == 0) {
+        return;
     }
-    return true;
-error:
-    return false;
-}
 
-bool ecs_field_is_self(
-    const ecs_iter_t *it,
-    int32_t index)
-{
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    return it->sources == NULL || it->sources[index - 1] == 0;
-}
+    ecs_term_t *term = &o->query->terms[0];
+    ecs_flags64_t flags = ECS_TERM_REF_FLAGS(&term->src);
 
-ecs_id_t ecs_field_id(
-    const ecs_iter_t *it,
-    int32_t index)
-{
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    return it->ids[index - 1];
+    if ((flags & (EcsSelf|EcsUp)) == (EcsSelf|EcsUp)) {
+        flecs_unregister_observer_for_id(world, observable, o,
+            offsetof(ecs_event_id_record_t, self_up));
+    } else if (flags & EcsSelf) {
+        flecs_unregister_observer_for_id(world, observable, o,
+            offsetof(ecs_event_id_record_t, self));
+    } else if (flags & EcsUp) {
+        flecs_unregister_observer_for_id(world, observable, o,
+            offsetof(ecs_event_id_record_t, up));
+    }
 }
 
-int32_t ecs_field_column_index(
-    const ecs_iter_t *it,
-    int32_t index)
+static
+bool flecs_ignore_observer(
+    ecs_observer_t *o,
+    ecs_table_t *table,
+    ecs_iter_t *it)
 {
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    int32_t result = it->columns[index - 1];
-    if (result <= 0) {
-        return -1;
-    } else {
-        return result - 1;
+    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    int32_t *last_event_id = impl->last_event_id;
+    if (last_event_id && last_event_id[0] == it->event_cur) {
+        return true;
     }
-}
 
-ecs_entity_t ecs_field_src(
-    const ecs_iter_t *it,
-    int32_t index)
-{
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    if (it->sources) {
-        return it->sources[index - 1];
-    } else {
-        return 0;
+    if (impl->flags & (EcsObserverIsDisabled|EcsObserverIsParentDisabled)) {
+        return true;
     }
+
+    ecs_flags32_t table_flags = table->flags, query_flags = o->query->flags;
+
+    bool result = (table_flags & EcsTableIsPrefab) &&
+        !(query_flags & EcsQueryMatchPrefab);
+    result = result || ((table_flags & EcsTableIsDisabled) &&
+        !(query_flags & EcsQueryMatchDisabled));
+
+    return result;
 }
 
-size_t ecs_field_size(
-    const ecs_iter_t *it,
-    int32_t index)
+static
+bool flecs_is_simple_result(
+    ecs_iter_t *it)
 {
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    return (size_t)it->sizes[index - 1];
+    return (it->count == 1) || (it->sizes[0] == 0) || (it->sources[0] == 0);
 }
 
-char* ecs_iter_str(
-    const ecs_iter_t *it)
+static
+void flecs_observer_invoke(
+    ecs_world_t *world,
+    ecs_iter_t *it,
+    ecs_observer_t *o,
+    ecs_iter_action_t callback,
+    int32_t term_index,
+    bool simple_result) 
 {
-    if (!(it->flags & EcsIterIsValid)) {
-        return NULL;
+    ecs_assert(it->callback != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    if (ecs_should_log_3()) {
+        char *path = ecs_get_fullpath(world, it->system);
+        ecs_dbg_3("observer: invoke %s", path);
+        ecs_os_free(path);
     }
 
-    ecs_world_t *world = it->world;
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
-    int i;
+    ecs_log_push_3();
 
-    if (it->field_count) {
-        ecs_strbuf_list_push(&buf, "id:  ", ",");
-        for (i = 0; i < it->field_count; i ++) {
-            ecs_id_t id = ecs_field_id(it, i + 1);
-            char *str = ecs_id_str(world, id);
-            ecs_strbuf_list_appendstr(&buf, str);
-            ecs_os_free(str);
-        }
-        ecs_strbuf_list_pop(&buf, "\n");
+    ecs_entity_t old_system = flecs_stage_set_system(
+        world->stages[0], o->entity);
+    world->info.observers_ran_frame ++;
 
-        ecs_strbuf_list_push(&buf, "src: ", ",");
-        for (i = 0; i < it->field_count; i ++) {
-            ecs_entity_t subj = ecs_field_src(it, i + 1);
-            char *str = ecs_get_fullpath(world, subj);
-            ecs_strbuf_list_appendstr(&buf, str);
-            ecs_os_free(str);
+    ecs_query_t *query = o->query;
+    ecs_assert(term_index < query->term_count, ECS_INTERNAL_ERROR, NULL);
+    ecs_term_t *term = &query->terms[term_index];
+    if (it->table && (term->oper != EcsNot)) {
+        ecs_assert((it->offset + it->count) <= ecs_table_count(it->table), 
+            ECS_INTERNAL_ERROR, NULL);
+    }
+
+    bool instanced = query->flags & EcsQueryIsInstanced;
+    bool match_this = query->flags & EcsQueryMatchThis;
+    bool table_only = it->flags & EcsIterTableOnly;
+
+    if (match_this && (simple_result || instanced || table_only)) {
+        callback(it);
+        query->eval_count ++;
+    } else {
+        ecs_entity_t observer_src = ECS_TERM_REF_ID(&term->src);
+        if (observer_src && !(term->src.id & EcsIsEntity)) {
+            observer_src = 0;
         }
-        ecs_strbuf_list_pop(&buf, "\n");
 
-        ecs_strbuf_list_push(&buf, "set: ", ",");
-        for (i = 0; i < it->field_count; i ++) {
-            if (ecs_field_is_set(it, i + 1)) {
-                ecs_strbuf_list_appendlit(&buf, "true");
-            } else {
-                ecs_strbuf_list_appendlit(&buf, "false");
-            }
-        }
-        ecs_strbuf_list_pop(&buf, "\n");
-    }
-
-    if (it->variable_count && it->variable_names) {
-        int32_t actual_count = 0;
-        for (i = 0; i < it->variable_count; i ++) {
-            const char *var_name = it->variable_names[i];
-            if (!var_name || var_name[0] == '_' || !strcmp(var_name, "This")) {
-                /* Skip anonymous variables */
-                continue;
-            }
-
-            ecs_var_t var = it->variables[i];
-            if (!var.entity) {
-                /* Skip table variables */
-                continue;
-            }
+        ecs_entity_t *entities = it->entities;
+        int32_t i, count = it->count;
+        ecs_entity_t src = it->sources[0];
+        it->count = 1;
+        for (i = 0; i < count; i ++) {
+            ecs_entity_t e = entities[i];
+            it->entities = &e;
+            if (!observer_src) {
+                callback(it);
+                query->eval_count ++;
+            } else if (observer_src == e) {
+                ecs_entity_t dummy = 0;
+                it->entities = &dummy;
+                if (!src) {
+                    it->sources[0] = e;
+                }
 
-            if (!actual_count) {
-                ecs_strbuf_list_push(&buf, "var: ", ",");
+                callback(it);
+                query->eval_count ++;
+                it->sources[0] = src;
+                break;
             }
-
-            char *str = ecs_get_fullpath(world, var.entity);
-            ecs_strbuf_list_append(&buf, "%s=%s", var_name, str);
-            ecs_os_free(str);
-
-            actual_count ++;
-        }
-        if (actual_count) {
-            ecs_strbuf_list_pop(&buf, "\n");
         }
+        it->entities = entities;
+        it->count = count;
     }
 
-    if (it->count) {
-        ecs_strbuf_appendlit(&buf, "this:\n");
-        for (i = 0; i < it->count; i ++) {
-            ecs_entity_t e = it->entities[i];
-            char *str = ecs_get_fullpath(world, e);
-            ecs_strbuf_appendlit(&buf, "    - ");
-            ecs_strbuf_appendstr(&buf, str);
-            ecs_strbuf_appendch(&buf, '\n');
-            ecs_os_free(str);
-        }
-    }
+    flecs_stage_set_system(world->stages[0], old_system);
 
-    return ecs_strbuf_get(&buf);
+    ecs_log_pop_3();
 }
 
-void ecs_iter_poly(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter_out,
-    ecs_term_t *filter)
-{
-    ecs_iterable_t *iterable = ecs_get_iterable(poly);
-    iterable->init(world, poly, iter_out, filter);
-}
+static
+void flecs_default_uni_observer_run_callback(ecs_iter_t *it) {
+    ecs_observer_t *o = it->ctx;
+    it->ctx = o->ctx;
+    it->callback = o->callback;
 
-bool ecs_iter_next(
-    ecs_iter_t *iter)
-{
-    ecs_check(iter != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(iter->next != NULL, ECS_INVALID_PARAMETER, NULL);
-    return iter->next(iter);
-error:
-    return false;
+    if (ecs_should_log_3()) {
+        char *path = ecs_get_fullpath(it->world, it->system);
+        ecs_dbg_3("observer %s", path);
+        ecs_os_free(path);
+    }
+
+    ecs_log_push_3();
+    flecs_observer_invoke(it->real_world, it, o, o->callback, 0,
+        flecs_is_simple_result(it));
+    ecs_log_pop_3();
 }
 
-int32_t ecs_iter_count(
-    ecs_iter_t *it)
+static
+void flecs_uni_observer_invoke(
+    ecs_world_t *world,
+    ecs_observer_t *o,
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    ecs_entity_t trav,
+    bool simple_result)
 {
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ECS_BIT_SET(it->flags, EcsIterNoData);
-    ECS_BIT_SET(it->flags, EcsIterIsInstanced);
+    ecs_query_t *query = o->query;
+    ecs_term_t *term = &query->terms[0];
+    if (flecs_ignore_observer(o, table, it)) {
+        return;
+    }
 
-    int32_t count = 0;
-    while (ecs_iter_next(it)) {
-        count += it->count;
+    ecs_assert(trav == 0 || it->sources[0] != 0, ECS_INTERNAL_ERROR, NULL);
+    if (trav && term->trav != trav) {
+        return;
     }
-    return count;
-error:
-    return 0;
-}
 
-ecs_entity_t ecs_iter_first(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    bool is_filter = term->inout == EcsInOutNone;
+    ECS_BIT_COND(it->flags, EcsIterNoData, is_filter);
+    it->system = o->entity;
+    it->ctx = o->ctx;
+    it->binding_ctx = o->binding_ctx;
+    it->term_index = impl->term_index;
+    it->query = o->query;
 
-    ECS_BIT_SET(it->flags, EcsIterNoData);
-    ECS_BIT_SET(it->flags, EcsIterIsInstanced);
+    ecs_entity_t event = it->event;
+    int32_t event_cur = it->event_cur;
+    it->event = flecs_get_observer_event(term, event);
 
-    ecs_entity_t result = 0;
-    if (ecs_iter_next(it)) {
-        result = it->entities[0];
-        ecs_iter_fini(it);
+    if (o->run) {
+        it->next = flecs_default_observer_next_callback;
+        it->callback = flecs_default_uni_observer_run_callback;
+        it->ctx = o;
+        o->run(it);
+    } else {
+        ecs_iter_action_t callback = o->callback;
+        it->callback = callback;
+        flecs_observer_invoke(world, it, o, callback, 0, simple_result);
     }
 
-    return result;
-error:
-    return 0;
+    it->event = event;
+    it->event_cur = event_cur;
 }
 
-bool ecs_iter_is_true(
-    ecs_iter_t *it)
+void flecs_observers_invoke(
+    ecs_world_t *world,
+    ecs_map_t *observers,
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    ecs_entity_t trav)
 {
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    if (ecs_map_is_init(observers)) {
+        ecs_table_lock(it->world, table);
 
-    ECS_BIT_SET(it->flags, EcsIterNoData);
-    ECS_BIT_SET(it->flags, EcsIterIsInstanced);
+        bool simple_result = flecs_is_simple_result(it);
+        ecs_map_iter_t oit = ecs_map_iter(observers);
+        while (ecs_map_next(&oit)) {
+            ecs_observer_t *o = ecs_map_ptr(&oit);
+            ecs_assert(it->table == table, ECS_INTERNAL_ERROR, NULL);
+            flecs_uni_observer_invoke(
+                world, o, it, table, trav, simple_result);
+        }
 
-    bool result = ecs_iter_next(it);
-    if (result) {
-        ecs_iter_fini(it);
+        ecs_table_unlock(it->world, table);
     }
-    return result;
-error:
-    return false;
 }
 
-ecs_entity_t ecs_iter_get_var(
-    ecs_iter_t *it,
-    int32_t var_id)
+static
+bool flecs_multi_observer_invoke(
+    ecs_iter_t *it) 
 {
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_var_t *var = &it->variables[var_id];
-    ecs_entity_t e = var->entity;
-    if (!e) {
-        ecs_table_t *table = var->range.table;
-        if (!table && !var_id) {
-            table = it->table;
-        }
-        if (table) {
-            if ((var->range.count == 1) || (ecs_table_count(table) == 1)) {
-                ecs_assert(ecs_table_count(table) > var->range.offset,
-                    ECS_INTERNAL_ERROR, NULL);
-                e = ecs_vec_get_t(&table->data.entities, ecs_entity_t,
-                    var->range.offset)[0];
-            }
-        }
-    } else {
-        ecs_assert(ecs_is_valid(it->real_world, e), ECS_INTERNAL_ERROR, NULL);
+    ecs_observer_t *o = it->ctx;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    ecs_world_t *world = it->real_world;
+    
+    if (impl->last_event_id[0] == it->event_cur) {
+        /* Already handled this event */
+        return false;
     }
 
-    return e;
-error:
-    return 0;
-}
+    impl->last_event_id[0] = world->event_id;
 
-ecs_table_t* ecs_iter_get_var_as_table(
-    ecs_iter_t *it,
-    int32_t var_id)
-{
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_table_t *table = it->table;
+    ecs_table_t *prev_table = it->other_table;
+    int32_t pivot_term = it->term_index;
+    ecs_term_t *term = &o->query->terms[pivot_term];
 
-    ecs_var_t *var = &it->variables[var_id];
-    ecs_table_t *table = var->range.table;
-    if (!table && !var_id) {
-        table = it->table;
+    bool is_not = term->oper == EcsNot;
+    if (is_not) {
+        table = it->other_table;
+        prev_table = it->table;
     }
 
-    if (!table) {
-        /* If table is not set, try to get table from entity */
-        ecs_entity_t e = var->entity;
-        if (e) {
-            ecs_record_t *r = flecs_entities_get(it->real_world, e);
-            if (r) {
-                table = r->table;
-                if (ecs_table_count(table) != 1) {
-                    /* If table contains more than the entity, make sure not to
-                     * return a partial table. */
-                    return NULL;
-                }
-            }
-        }
-    }
+    table = table ? table : &world->store.root;
+    prev_table = prev_table ? prev_table : &world->store.root;
 
-    if (table) {
-        if (var->range.offset) {
-            /* Don't return whole table if only partial table is matched */
-            return NULL;
-        }
+    ecs_iter_t user_it;
 
-        if (!var->range.count || ecs_table_count(table) == var->range.count) {
-            /* Return table if count matches */
-            return table;
+    bool match;
+    if (is_not) {
+        match = ecs_query_has_table(o->query, table, &user_it);
+        if (match) {
+            /* The target table matches but the entity hasn't moved to it yet. 
+             * Now match the not_query, which will populate the iterator with
+             * data from the table the entity is still stored in. */
+            ecs_iter_fini(&user_it);
+            match = ecs_query_has_table(impl->not_query, prev_table, &user_it);
+
+            /* A not query replaces Not terms with Optional terms, so if the 
+             * regular query matches, the not_query should also match. */
+            ecs_assert(match, ECS_INTERNAL_ERROR, NULL);
         }
+    } else {
+        ecs_table_range_t range = {
+            .table = table,
+            .offset = it->offset,
+            .count = it->count
+        };
+        match = ecs_query_has_range(o->query, &range, &user_it);
     }
 
-error:
-    return NULL;
-}
+    if (match) {
+        /* Monitor observers only invoke when the query matches for the first
+         * time with an entity */
+        if (impl->flags & EcsObserverIsMonitor) {
+            ecs_iter_t table_it;
+            if (ecs_query_has_table(o->query, prev_table, &table_it)) {
+                ecs_iter_fini(&table_it);
+                ecs_iter_fini(&user_it);
+                goto done;
+            }
+        }
 
-ecs_table_range_t ecs_iter_get_var_as_range(
-    ecs_iter_t *it,
-    int32_t var_id)
-{
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL);
+        ECS_BIT_COND(user_it.flags, EcsIterNoData,    
+            ECS_BIT_IS_SET(o->query->flags, EcsQueryNoData));
 
-    ecs_table_range_t result = { 0 };
+        /* Patch data from original iterator. If the observer query has 
+         * wildcards which triggered the original event, the component id that
+         * got matched by ecs_query_has_range may not be the same as the one
+         * that caused the event. We need to make sure to communicate the
+         * component id that actually triggered the observer. */
+        int32_t pivot_field = term->field_index;
+        ecs_assert(pivot_field >= 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(pivot_field < user_it.field_count, ECS_INTERNAL_ERROR, NULL);
+        user_it.ids[pivot_field] = it->event_id;
+        user_it.ptrs[pivot_field] = it->ptrs[0];
+        user_it.columns[pivot_field] = it->columns[0];
+        user_it.term_index = pivot_term;
 
-    ecs_var_t *var = &it->variables[var_id];
-    ecs_table_t *table = var->range.table;
-    if (!table && !var_id) {
-        table = it->table;
-    }
-   
-    if (!table) {
-        ecs_entity_t e = var->entity;
-        if (e) {
-            ecs_record_t *r = flecs_entities_get(it->real_world, e);
-            if (r) {
-                result.table = r->table;
-                result.offset = ECS_RECORD_TO_ROW(r->row);
-                result.count = 1;
-            }
-        }
-    } else {
-        result.table = table;
-        result.offset = var->range.offset;
-        result.count = var->range.count;
-        if (!result.count) {
-            result.count = ecs_table_count(table);
-        }
-    }
+        user_it.ctx = o->ctx;
+        user_it.binding_ctx = o->binding_ctx;
+        user_it.param = it->param;
+        user_it.callback = o->callback;
+        user_it.system = o->entity;
+        user_it.event = it->event;
+        user_it.event_id = it->event_id;
+        user_it.other_table = it->other_table;
 
-    return result;
-error:
-    return (ecs_table_range_t){0};
-}
+        ecs_entity_t old_system = flecs_stage_set_system(
+            world->stages[0], o->entity);
+        ecs_table_lock(it->world, table);
 
-void ecs_iter_set_var(
-    ecs_iter_t *it,
-    int32_t var_id,
-    ecs_entity_t entity)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < FLECS_VARIABLE_COUNT_MAX, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
-    /* Can't set variable while iterating */
-    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->variables != NULL, ECS_INTERNAL_ERROR, NULL);
+        user_it.callback(&user_it);
 
-    ecs_var_t *var = &it->variables[var_id];
-    var->entity = entity;
+        ecs_table_unlock(it->world, table);
+        flecs_stage_set_system(world->stages[0], old_system);
 
-    ecs_record_t *r = flecs_entities_get(it->real_world, entity);
-    if (r) {
-        var->range.table = r->table;
-        var->range.offset = ECS_RECORD_TO_ROW(r->row);
-        var->range.count = 1;
+        ecs_iter_fini(&user_it);
+        return true;
     } else {
-        var->range.table = NULL;
-        var->range.offset = 0;
-        var->range.count = 0;
+        /* While the observer query was strictly speaking evaluated, it's more
+         * useful to measure how often the observer was actually invoked. */
+        o->query->eval_count --;
     }
 
-    it->constrained_vars |= flecs_ito(uint64_t, 1 << var_id);
+done:
+    return false;
+}
 
-    if (it->set_var) {
-        it->set_var(it);
+bool ecs_observer_default_run_action(ecs_iter_t *it) {
+    ecs_observer_t *o = it->ctx;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    if (impl->flags & EcsObserverIsMulti) {
+        return flecs_multi_observer_invoke(it);
+    } else {
+        it->ctx = o->ctx;
+        ecs_table_lock(it->world, it->table);
+        flecs_observer_invoke(it->real_world, it, o, o->callback, 0,
+            flecs_is_simple_result(it));
+        ecs_table_unlock(it->world, it->table);
+        return true;
     }
-
-error:
-    return;
 }
 
-void ecs_iter_set_var_as_table(
-    ecs_iter_t *it,
-    int32_t var_id,
-    const ecs_table_t *table)
+static
+void flecs_default_multi_observer_run_callback(
+    ecs_iter_t *it) 
 {
-    ecs_table_range_t range = { .table = ECS_CONST_CAST(ecs_table_t*, table) };
-    ecs_iter_set_var_as_range(it, var_id, &range);
+    flecs_multi_observer_invoke(it);
 }
 
-void ecs_iter_set_var_as_range(
-    ecs_iter_t *it,
-    int32_t var_id,
-    const ecs_table_range_t *range)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < FLECS_VARIABLE_COUNT_MAX, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(range != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(range->table != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!range->offset || range->offset < ecs_table_count(range->table), 
-        ECS_INVALID_PARAMETER, NULL);
-    ecs_check((range->offset + range->count) <= ecs_table_count(range->table), 
-        ECS_INVALID_PARAMETER, NULL);
-
-    /* Can't set variable while iterating */
-    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_OPERATION, NULL);
-
-    ecs_var_t *var = &it->variables[var_id];
-    var->range = *range;
-
-    if (range->count == 1) {
-        ecs_table_t *table = range->table;
-        var->entity = ecs_vec_get_t(
-            &table->data.entities, ecs_entity_t, range->offset)[0];
+/* For convenience, so applications can (in theory) use a single run callback 
+ * that uses ecs_iter_next to iterate results */
+bool flecs_default_observer_next_callback(ecs_iter_t *it) {
+    if (it->interrupted_by) {
+        return false;
     } else {
-        var->entity = 0;
+        /* Use interrupted_by to signal the next iteration must return false */
+        ecs_assert(it->system != 0, ECS_INTERNAL_ERROR, NULL);
+        it->interrupted_by = it->system;
+        return true;
     }
-
-    it->constrained_vars |= flecs_uto(uint64_t, 1 << var_id);
-
-error:
-    return;
-}
-
-bool ecs_iter_var_is_constrained(
-    ecs_iter_t *it,
-    int32_t var_id)
-{
-    return (it->constrained_vars & (flecs_uto(uint64_t, 1 << var_id))) != 0;
 }
 
+/* Run action for children of multi observer */
 static
-void ecs_chained_iter_fini(
-    ecs_iter_t *it)
-{
-    ecs_assert(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_iter_fini(it->chain_it);
+void flecs_multi_observer_builtin_run(ecs_iter_t *it) {
+    ecs_observer_t *o = it->ctx;
+    ecs_run_action_t run = o->run;
 
-    it->chain_it = NULL;
+    if (run) {
+        it->next = flecs_default_observer_next_callback;
+        it->callback = flecs_default_multi_observer_run_callback;
+        it->interrupted_by = 0;
+        run(it);
+    } else {
+        flecs_multi_observer_invoke(it);
+    }
 }
 
-ecs_iter_t ecs_page_iter(
-    const ecs_iter_t *it,
-    int32_t offset,
-    int32_t limit)
+static
+void flecs_observer_yield_existing(
+    ecs_world_t *world,
+    ecs_observer_t *o)
 {
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_run_action_t run = o->run;
+    if (!run) {
+        run = flecs_default_multi_observer_run_callback;
+    }
 
-    ecs_iter_t result = *it;
-    result.priv.cache.stack_cursor = NULL; /* Don't copy allocator cursor */
+    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
 
-    result.priv.iter.page = (ecs_page_iter_t){
-        .offset = offset,
-        .limit = limit,
-        .remaining = limit
-    };
-    result.next = ecs_page_next;
-    result.fini = ecs_chained_iter_fini;
-    result.chain_it = ECS_CONST_CAST(ecs_iter_t*, it);
+    ecs_defer_begin(world);
 
-    return result;
-error:
-    return (ecs_iter_t){ 0 };
+    /* If yield existing is enabled, invoke for each thing that matches
+     * the event, if the event is iterable. */
+    int i, count = o->event_count;
+    for (i = 0; i < count; i ++) {
+        ecs_iter_t it = ecs_query_iter(world, o->query);
+        it.system = o->entity;
+        it.ctx = o;
+        it.binding_ctx = o->binding_ctx;
+        it.event = o->events[i];;
+        while (ecs_query_next(&it)) {
+            it.event_id = it.ids[0];
+            it.event_cur = ++ world->event_id;
+            run(&it);
+        }
+    }
+
+    ecs_defer_end(world);
 }
 
 static
-void flecs_offset_iter(
-    ecs_iter_t *it,
-    int32_t offset)
+int flecs_uni_observer_init(
+    ecs_world_t *world,
+    ecs_observer_t *o,
+    const ecs_observer_desc_t *desc)
 {
-    it->entities = &it->entities[offset];
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    ecs_term_t *term = &o->query->terms[0];
+    impl->last_event_id = desc->last_event_id;    
+    if (!impl->last_event_id) {
+        impl->last_event_id = &impl->last_event_id_storage;
+    }
+    impl->register_id = term->id;
+    term->field_index = flecs_ito(int16_t, desc->term_index);
 
-    int32_t t, field_count = it->field_count;
-    void **it_ptrs = it->ptrs;
-    if (it_ptrs) {
-        for (t = 0; t < field_count; t ++) {
-            void *ptrs = it_ptrs[t];
-            if (!ptrs) {
-                continue;
+    if (ecs_id_is_tag(world, term->id)) {
+        /* If id is a tag, downgrade OnSet/UnSet to OnAdd/OnRemove. */
+        int32_t e, count = o->event_count;
+        bool has_on_add = false;
+        bool has_on_remove = false;
+        for (e = 0; e < count; e ++) {
+            if (o->events[e] == EcsOnAdd) {
+                has_on_add = true;
             }
-
-            if (it->sources[t]) {
-                continue;
+            if (o->events[e] == EcsOnRemove) {
+                has_on_remove = true;
             }
+        }
 
-            it->ptrs[t] = ECS_OFFSET(ptrs, offset * it->sizes[t]);
+        for (e = 0; e < count; e ++) {
+            if (o->events[e] == EcsOnSet) {
+                if (has_on_add) {
+                    /* Already registered */
+                    o->events[e] = 0;
+                } else {
+                    o->events[e] = EcsOnAdd;
+                }
+            } else
+            if (o->events[e] == EcsUnSet) {
+                if (has_on_remove) {
+                    /* Already registered */
+                    o->events[e] = 0;
+                } else {
+                    o->events[e] = EcsOnRemove;
+                }
+            }
         }
     }
+
+    flecs_uni_observer_register(world, o->observable, o);
+
+    return 0;
 }
 
 static
-bool ecs_page_next_instanced(
-    ecs_iter_t *it)
+int flecs_observer_add_child(
+    ecs_world_t *world,
+    ecs_observer_t *o,
+    const ecs_observer_desc_t *child_desc)
 {
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_page_next, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_iter_t *chain_it = it->chain_it;
-    bool instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
+    ecs_observer_t *child_observer = flecs_observer_init(
+        world, 0, child_desc);
+    if (!child_observer) {
+        return -1;
+    }
 
-    do {
-        if (!ecs_iter_next(chain_it)) {
-            goto depleted;
-        }
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    ecs_vec_append_t(&world->allocator, &impl->children, 
+        ecs_observer_t*)[0] = child_observer;
+    child_observer->entity = o->entity;
+    return 0;
+}
 
-        ecs_page_iter_t *iter = &it->priv.iter.page;
-        
-        /* Copy everything up to the private iterator data */
-        ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv));
+static
+int flecs_multi_observer_init(
+    ecs_world_t *world,
+    ecs_observer_t *o,
+    const ecs_observer_desc_t *desc)
+{
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
 
-        /* Keep instancing setting from original iterator */
-        ECS_BIT_COND(it->flags, EcsIterIsInstanced, instanced);
+    /* Create last event id for filtering out the same event that arrives from
+     * more than one term */
+    impl->last_event_id = ecs_os_calloc_t(int32_t);
+    
+    /* Mark observer as multi observer */
+    impl->flags |= EcsObserverIsMulti;
 
-        if (!chain_it->table) {
-            goto yield; /* Task query */
-        }
+    /* Vector that stores a single-component observer for each query term */
+    ecs_vec_init_t(&world->allocator, &impl->children, ecs_observer_t*, 2);
 
-        int32_t offset = iter->offset;
-        int32_t limit = iter->limit;
-        if (!(offset || limit)) {
-            if (it->count) {
-                goto yield;
-            } else {
-                goto depleted;
+    /* Create a child observer for each term in the query */
+    ecs_query_t *query = o->query;
+    ecs_observer_desc_t child_desc = *desc;
+    child_desc.last_event_id = impl->last_event_id;
+    child_desc.run = NULL;
+    child_desc.callback = flecs_multi_observer_builtin_run;
+    child_desc.ctx = o;
+    child_desc.ctx_free = NULL;
+    child_desc.query.expr = NULL;
+    child_desc.binding_ctx = NULL;
+    child_desc.binding_ctx_free = NULL;
+    child_desc.yield_existing = false;
+    ecs_os_zeromem(&child_desc.entity);
+    ecs_os_zeromem(&child_desc.query.terms);
+    ecs_os_zeromem(&child_desc.query);
+    ecs_os_memcpy_n(child_desc.events, o->events, 
+        ecs_entity_t, o->event_count);
+
+    int i, term_count = query->term_count;
+    bool optional_only = query->flags & EcsQueryMatchThis;
+    bool has_not = false;
+    for (i = 0; i < term_count; i ++) {
+        if (query->terms[i].oper != EcsOptional) {
+            if (ecs_term_match_this(&query->terms[i])) {
+                optional_only = false;
             }
         }
 
-        int32_t count = it->count;
-        int32_t remaining = iter->remaining;
+        if ((query->terms[i].oper == EcsNot) && 
+            (query->terms[i].inout != EcsInOutFilter)) 
+        {
+            has_not = true;
+        }
+    }
 
-        if (offset) {
-            if (offset > count) {
-                /* No entities to iterate in current table */
-                iter->offset -= count;
-                it->count = 0;
+    if (query->flags & EcsQueryMatchPrefab) {
+        child_desc.query.flags |= EcsQueryMatchPrefab;
+    }
+
+    if (query->flags & EcsQueryMatchDisabled) {
+        child_desc.query.flags |= EcsQueryMatchDisabled;
+    }
+
+    for (i = 0; i < term_count; i ++) {
+        if (query->terms[i].inout == EcsInOutFilter) {
+            continue;
+        }
+
+        ecs_term_t *term = &child_desc.query.terms[0];
+        child_desc.term_index = query->terms[i].field_index;
+        *term = query->terms[i];
+
+        int16_t oper = term->oper;
+        ecs_id_t id = term->id;
+
+        /* AndFrom & OrFrom terms insert multiple observers */
+        if (oper == EcsAndFrom || oper == EcsOrFrom) {
+            const ecs_type_t *type = ecs_get_type(world, id);
+            if (!type) {
                 continue;
-            } else {
-                it->offset += offset;
-                count = it->count -= offset;
-                iter->offset = 0;
-                flecs_offset_iter(it, offset);
             }
-        }
 
-        if (remaining) {
-            if (remaining > count) {
-                iter->remaining -= count;
-            } else {
-                it->count = remaining;
-                iter->remaining = 0;
+            int32_t ti, ti_count = type->count;
+            ecs_id_t *ti_ids = type->array;
+
+            /* Correct operator will be applied when an event occurs, and
+             * the observer is evaluated on the observer source */
+            term->oper = EcsAnd;
+            for (ti = 0; ti < ti_count; ti ++) {
+                ecs_id_t ti_id = ti_ids[ti];
+                ecs_id_record_t *idr = flecs_id_record_get(world, ti_id);
+                if (idr->flags & EcsIdDontInherit) {
+                    continue;
+                }
+
+                term->first.name = NULL;
+                term->first.id = ti_ids[ti];
+                term->id = ti_ids[ti];
+
+                if (flecs_observer_add_child(world, o, &child_desc)) {
+                    goto error;
+                }
             }
-        } else if (limit) {
-            /* Limit hit: no more entities left to iterate */
-            goto done;
+            continue;
         }
-    } while (it->count == 0);
-
-yield:
-    if (!ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced)) {
-        it->offset = 0;
-    }
 
-    return true;
-done:
-    /* Cleanup iterator resources if it wasn't yet depleted */
-    ecs_iter_fini(chain_it);
-depleted:
-error:
-    return false;
-}
+        /* Single component observers never use OR */
+        if (oper == EcsOr) {
+            term->oper = EcsAnd;
+        }
 
-bool ecs_page_next(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_page_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
+        /* If observer only contains optional terms, match everything */
+        if (optional_only) {
+            term->id = EcsAny;
+            term->first.id = EcsAny;
+            term->src.id = EcsThis | EcsIsVariable;
+            term->second.id = 0;
+        } else if (term->oper == EcsOptional) {
+            continue;
+        }
 
-    ECS_BIT_SET(it->chain_it->flags, EcsIterIsInstanced);
+        if (flecs_observer_add_child(world, o, &child_desc)) {
+            goto error;
+        }
 
-    if (flecs_iter_next_row(it)) {
-        return true;
+        if (optional_only) {
+            break;
+        }
     }
 
-    return flecs_iter_next_instanced(it, ecs_page_next_instanced(it));
-error:
-    return false;
-}
+    /* If observer has Not terms, we need to create a query that replaces Not
+     * with Optional which we can use to populate the observer data for the 
+     * table that the entity moved away from (or to, if it's an OnRemove 
+     * observer). */
+    if (has_not) {
+        ecs_query_desc_t not_desc = desc->query;
+        not_desc.expr = NULL;
 
-ecs_iter_t ecs_worker_iter(
-    const ecs_iter_t *it,
-    int32_t index,
-    int32_t count)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(count > 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(index >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(index < count, ECS_INVALID_PARAMETER, NULL);
+        ecs_os_memcpy_n(not_desc.terms, o->query->terms, 
+            ecs_term_t, term_count); /* cast suppresses warning */
+  
+        for (i = 0; i < term_count; i ++) {
+            if (not_desc.terms[i].oper == EcsNot) {
+                not_desc.terms[i].oper = EcsOptional;
+            }
+        }
 
-    ecs_iter_t result = *it;
-    result.priv.cache.stack_cursor = NULL; /* Don't copy allocator cursor */
-    
-    result.priv.iter.worker = (ecs_worker_iter_t){
-        .index = index,
-        .count = count
-    };
-    result.next = ecs_worker_next;
-    result.fini = ecs_chained_iter_fini;
-    result.chain_it = ECS_CONST_CAST(ecs_iter_t*, it);
+        flecs_observer_impl(o)->not_query = 
+            ecs_query_init(world, &not_desc);
+    }
 
-    return result;
+    return 0; 
 error:
-    return (ecs_iter_t){ 0 };
+    return -1;
 }
 
-static
-bool ecs_worker_next_instanced(
-    ecs_iter_t *it)
+ecs_observer_t* flecs_observer_init(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const ecs_observer_desc_t *desc)
 {
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_worker_next, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->callback != NULL || desc->run != NULL, 
+        ECS_INVALID_OPERATION,
+            "cannot create observer: must at least specify callback or run");
+
+    ecs_observer_impl_t *impl = flecs_sparse_add_t(
+        &world->store.observers, ecs_observer_impl_t);
+    ecs_assert(impl != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_init(impl, ecs_observer_t);
+    ecs_observer_t *o = &impl->pub;
+    impl->id = flecs_sparse_last_id(&world->store.observers);
+    impl->dtor = (flecs_poly_dtor_t)flecs_observer_fini;
+
+    /* Make writeable copy of query desc so that we can set name. This will
+     * make debugging easier, as any error messages related to creating the
+     * query will have the name of the observer. */
+    ecs_query_desc_t query_desc = desc->query;
+    query_desc.entity = 0;
+    query_desc.cache_kind = EcsQueryCacheNone;
+
+    /* Create query */
+    ecs_query_t *query = o->query = ecs_query_init(
+        world, &query_desc);
+    if (query == NULL) {
+        flecs_observer_fini(o);
+        return 0;
+    }
 
-    bool instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
+    flecs_poly_assert(query, ecs_query_t);
 
-    ecs_iter_t *chain_it = it->chain_it;
-    ecs_worker_iter_t *iter = &it->priv.iter.worker;
-    int32_t res_count = iter->count, res_index = iter->index;
-    int32_t per_worker, instances_per_worker, first;
+    ecs_check(o->query->term_count > 0, ECS_INVALID_PARAMETER,
+        "observer must have at least one term");
 
-    do {
-        if (!ecs_iter_next(chain_it)) {
-            return false;
-        }
+    ecs_observable_t *observable = desc->observable;
+    if (!observable) {
+        observable = ecs_get_observable(world);
+    }
 
-        /* Copy everything up to the private iterator data */
-        ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv));
+    o->run = desc->run;
+    o->callback = desc->callback;
+    o->ctx = desc->ctx;
+    o->binding_ctx = desc->binding_ctx;
+    o->ctx_free = desc->ctx_free;
+    o->binding_ctx_free = desc->binding_ctx_free;
+    o->observable = observable;
+    o->entity = entity;
+    impl->term_index = desc->term_index;
 
-        /* Keep instancing setting from original iterator */
-        ECS_BIT_COND(it->flags, EcsIterIsInstanced, instanced);
+    /* Check if observer is monitor. Monitors are created as multi observers
+     * since they require pre/post checking of the filter to test if the
+     * entity is entering/leaving the monitor. */
+    int i;
+    for (i = 0; i < FLECS_EVENT_DESC_MAX; i ++) {
+        ecs_entity_t event = desc->events[i];
+        if (!event) {
+            break;
+        }
 
-        int32_t count = it->count;
-        int32_t instance_count = it->instance_count;
-        per_worker = count / res_count;
-        instances_per_worker = instance_count / res_count;
-        first = per_worker * res_index;
-        count -= per_worker * res_count;
+        if (event == EcsMonitor) {
+            ecs_check(i == 0, ECS_INVALID_PARAMETER,
+                "monitor observers can only have a single Monitor event");
 
-        if (count) {
-            if (res_index < count) {
-                per_worker ++;
-                first += res_index;
-            } else {
-                first += count;
-            }
+            o->events[0] = EcsOnAdd;
+            o->events[1] = EcsOnRemove;
+            o->event_count ++;
+            impl->flags |= EcsObserverIsMonitor;
+        } else {
+            o->events[i] = event;
         }
 
-        if (!per_worker && it->table == NULL) {
-            if (res_index == 0) {
-                return true;
-            } else {
-                // chained iterator was not yet cleaned up
-                // since it returned true from ecs_iter_next, so clean it up here.
-                ecs_iter_fini(chain_it);
-                return false;
-            }
-        }
-    } while (!per_worker);
+        o->event_count ++;
+    }
 
-    it->instance_count = instances_per_worker;
-    it->frame_offset += first;
+    /* Observer must have at least one event */
+    ecs_check(o->event_count != 0, ECS_INVALID_PARAMETER,
+        "observer must have at least one event");
 
-    flecs_offset_iter(it, it->offset + first);
-    it->count = per_worker;
+    bool multi = false;
 
-    if (ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced)) {
-        it->offset += first;
-    } else {
-        it->offset = 0;
+    if (query->term_count == 1 && !desc->last_event_id) {
+        ecs_term_t *term = &query->terms[0];
+        /* If the query has a single term but it is a *From operator, we
+         * need to create a multi observer */
+        multi |= (term->oper == EcsAndFrom) || (term->oper == EcsOrFrom);
+        
+        /* An observer with only optional terms is a special case that is
+         * only handled by multi observers */
+        multi |= term->oper == EcsOptional;
     }
 
-    return true;
-error:
-    return false;
-}
-
-bool ecs_worker_next(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_worker_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ECS_BIT_SET(it->chain_it->flags, EcsIterIsInstanced);
+    bool is_monitor = impl->flags & EcsObserverIsMonitor;
+    if (query->term_count == 1 && !is_monitor && !multi) {
+        if (flecs_uni_observer_init(world, o, desc)) {
+            goto error;
+        }
+    } else {
+        if (flecs_multi_observer_init(world, o, desc)) {
+            goto error;
+        }
+    }
 
-    if (flecs_iter_next_row(it)) {
-        return true;
+    if (desc->yield_existing) {
+        flecs_observer_yield_existing(world, o);
     }
 
-    return flecs_iter_next_instanced(it, ecs_worker_next_instanced(it));
+    return o;
 error:
-    return false;
+    return NULL;
 }
 
-/**
- * @file misc.c
- * @brief Miscellaneous functions.
- */
+ecs_entity_t ecs_observer_init(
+    ecs_world_t *world,
+    const ecs_observer_desc_t *desc)
+{
+    ecs_entity_t entity = 0;
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_observer_desc_t was not initialized to zero");
+    ecs_check(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, 
+        "cannot create observer while world is being deleted");
 
-#include <time.h>
-#include <ctype.h>
+    entity = desc->entity;
+    if (!entity) {
+        entity = ecs_entity(world, {0});
+    }
 
-#ifndef FLECS_NDEBUG
-static int64_t flecs_s_min[] = { 
-    [1] = INT8_MIN, [2] = INT16_MIN, [4] = INT32_MIN, [8] = INT64_MIN };
-static int64_t flecs_s_max[] = { 
-    [1] = INT8_MAX, [2] = INT16_MAX, [4] = INT32_MAX, [8] = INT64_MAX };
-static uint64_t flecs_u_max[] = { 
-    [1] = UINT8_MAX, [2] = UINT16_MAX, [4] = UINT32_MAX, [8] = UINT64_MAX };
+    EcsPoly *poly = flecs_poly_bind(world, entity, ecs_observer_t);
+    if (!poly->poly) {
+        ecs_observer_t *o = flecs_observer_init(world, entity, desc);
+        ecs_assert(o->entity == entity, ECS_INTERNAL_ERROR, NULL);
+        poly->poly = o;
 
-uint64_t flecs_ito_(
-    size_t size,
-    bool is_signed,
-    bool lt_zero,
-    uint64_t u,
-    const char *err)
-{
-    union {
-        uint64_t u;
-        int64_t s;
-    } v;
+        if (ecs_get_name(world, entity)) {
+            ecs_trace("#[green]observer#[reset] %s created", 
+                ecs_get_name(world, entity));
+        }
+    } else {
+        flecs_poly_assert(poly->poly, ecs_observer_t);
+        ecs_observer_t *o = (ecs_observer_t*)poly->poly;
 
-    v.u = u;
+        if (desc->run) {
+            o->run = desc->run;
+        }
 
-    if (is_signed) {
-        ecs_assert(v.s >= flecs_s_min[size], ECS_INVALID_CONVERSION, err);
-        ecs_assert(v.s <= flecs_s_max[size], ECS_INVALID_CONVERSION, err);
-    } else {
-        ecs_assert(lt_zero == false, ECS_INVALID_CONVERSION, err);
-        ecs_assert(u <= flecs_u_max[size], ECS_INVALID_CONVERSION, err);
-    }
+        if (desc->callback) {
+            o->callback = desc->callback;
+        }
 
-    return u;
-}
-#endif
+        if (o->ctx_free) {
+            if (o->ctx && o->ctx != desc->ctx) {
+                o->ctx_free(o->ctx);
+            }
+        }
 
-int32_t flecs_next_pow_of_2(
-    int32_t n)
-{
-    n --;
-    n |= n >> 1;
-    n |= n >> 2;
-    n |= n >> 4;
-    n |= n >> 8;
-    n |= n >> 16;
-    n ++;
+        if (o->binding_ctx_free) {
+            if (o->binding_ctx && 
+                o->binding_ctx != desc->binding_ctx) 
+            {
+                o->binding_ctx_free(o->binding_ctx);
+            }
+        }
 
-    return n;
-}
+        if (desc->ctx) {
+            o->ctx = desc->ctx;
+        }
 
-/** Convert time to double */
-double ecs_time_to_double(
-    ecs_time_t t)
-{
-    double result;
-    result = t.sec;
-    return result + (double)t.nanosec / (double)1000000000;
-}
+        if (desc->binding_ctx) {
+            o->binding_ctx = desc->binding_ctx;
+        }
 
-ecs_time_t ecs_time_sub(
-    ecs_time_t t1,
-    ecs_time_t t2)
-{
-    ecs_time_t result;
+        if (desc->ctx_free) {
+            o->ctx_free = desc->ctx_free;
+        }
 
-    if (t1.nanosec >= t2.nanosec) {
-        result.nanosec = t1.nanosec - t2.nanosec;
-        result.sec = t1.sec - t2.sec;
-    } else {
-        result.nanosec = t1.nanosec - t2.nanosec + 1000000000;
-        result.sec = t1.sec - t2.sec - 1;
+        if (desc->binding_ctx_free) {
+            o->binding_ctx_free = desc->binding_ctx_free;
+        }
     }
 
-    return result;
-}
+    flecs_poly_modified(world, entity, ecs_observer_t);
 
-void ecs_sleepf(
-    double t)
-{
-    if (t > 0) {
-        int sec = (int)t;
-        int nsec = (int)((t - sec) * 1000000000);
-        ecs_os_sleep(sec, nsec);
+    return entity;
+error:
+    if (entity) {
+        ecs_delete(world, entity);
     }
+    return 0;
 }
 
-double ecs_time_measure(
-    ecs_time_t *start)
+void* ecs_observer_get_ctx(
+    const ecs_world_t *world,
+    ecs_entity_t observer)
 {
-    ecs_time_t stop, temp;
-    ecs_os_get_time(&stop);
-    temp = stop;
-    stop = ecs_time_sub(stop, *start);
-    *start = temp;
-    return ecs_time_to_double(stop);
+    const EcsPoly *o = flecs_poly_bind_get(world, observer, ecs_observer_t);
+    if (o) {
+        flecs_poly_assert(o->poly, ecs_observer_t);
+        return ((ecs_observer_t*)o->poly)->ctx;
+    } else {
+        return NULL;
+    }     
 }
 
-void* ecs_os_memdup(
-    const void *src, 
-    ecs_size_t size) 
+void* ecs_observer_get_binding_ctx(
+    const ecs_world_t *world,
+    ecs_entity_t observer)
 {
-    if (!src) {
+    const EcsPoly *o = flecs_poly_bind_get(world, observer, ecs_observer_t);
+    if (o) {
+        flecs_poly_assert(o->poly, ecs_observer_t);
+        return ((ecs_observer_t*)o->poly)->binding_ctx;
+    } else {
         return NULL;
-    }
-        
-    void *dst = ecs_os_malloc(size);
-    ecs_assert(dst != NULL, ECS_OUT_OF_MEMORY, NULL);
-    ecs_os_memcpy(dst, src, size);  
-    return dst;  
+    }      
 }
 
-int flecs_entity_compare(
-    ecs_entity_t e1, 
-    const void *ptr1, 
-    ecs_entity_t e2, 
-    const void *ptr2) 
+const ecs_query_t* ecs_observer_get_query(
+    const ecs_world_t *world,
+    ecs_entity_t observer)
 {
-    (void)ptr1;
-    (void)ptr2;
-    return (e1 > e2) - (e1 < e2);
-}
-
-int flecs_id_qsort_cmp(const void *a, const void *b) {
-    ecs_id_t id_a = *(const ecs_id_t*)a;
-    ecs_id_t id_b = *(const ecs_id_t*)b;
-    return (id_a > id_b) - (id_a < id_b);
+    const EcsPoly *o = flecs_poly_bind_get(world, observer, ecs_observer_t);
+    if (o) {
+        flecs_poly_assert(o->poly, ecs_observer_t);
+        return ((ecs_observer_t*)o->poly)->query;
+    } else {
+        return NULL;
+    }   
 }
 
-uint64_t flecs_string_hash(
-    const void *ptr)
+void flecs_observer_fini(
+    ecs_observer_t *o)
 {
-    const ecs_hashed_string_t *str = ptr;
-    ecs_assert(str->hash != 0, ECS_INTERNAL_ERROR, NULL);
-    return str->hash;
-}
+    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(o->query != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_world_t *world = o->query->world;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
 
-char* ecs_vasprintf(
-    const char *fmt,
-    va_list args)
-{
-    ecs_size_t size = 0;
-    char *result  = NULL;
-    va_list tmpa;
+    if (impl->flags & EcsObserverIsMulti) {
+        ecs_observer_t **children = ecs_vec_first(&impl->children);
+        int32_t i, children_count = ecs_vec_count(&impl->children);
 
-    va_copy(tmpa, args);
+        for (i = 0; i < children_count; i ++) {
+            flecs_observer_fini(children[i]);
+        }
 
-    size = vsnprintf(result, 0, fmt, tmpa);
+        ecs_os_free(impl->last_event_id);
+    } else {
+        if (o->query->term_count) {
+            flecs_unregister_observer(world, o->observable, o);
+        } else {
+            /* Observer creation failed while creating query */
+        }
+    }
 
-    va_end(tmpa);
+    ecs_vec_fini_t(&world->allocator, &impl->children, ecs_observer_t*);
 
-    if ((int32_t)size < 0) { 
-        return NULL; 
+    /* Cleanup queries */
+    ecs_query_fini(o->query);
+    if (impl->not_query) {
+        ecs_query_fini(impl->not_query);
     }
 
-    result = (char *) ecs_os_malloc(size + 1);
-
-    if (!result) { 
-        return NULL; 
+    /* Cleanup context */
+    if (o->ctx_free) {
+        o->ctx_free(o->ctx);
     }
 
-    ecs_os_vsprintf(result, fmt, args);
+    if (o->binding_ctx_free) {
+        o->binding_ctx_free(o->binding_ctx);
+    }
 
-    return result;
+    flecs_poly_fini(o, ecs_observer_t);
+    flecs_sparse_remove_t(
+        &world->store.observers, ecs_observer_impl_t, impl->id);
 }
 
-char* ecs_asprintf(
-    const char *fmt,
-    ...)
+void flecs_observer_set_disable_bit(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    ecs_flags32_t bit,
+    bool cond)
 {
-    va_list args;
-    va_start(args, fmt);
-    char *result = ecs_vasprintf(fmt, args);
-    va_end(args);
-    return result;
-}
-
-char* flecs_to_snake_case(const char *str) {
-    int32_t upper_count = 0, len = 1;
-    const char *ptr = str;
-    char ch, *out, *out_ptr;
-
-    for (ptr = &str[1]; (ch = *ptr); ptr ++) {
-        if (isupper(ch)) {
-            upper_count ++;
-        }
-        len ++;
+    const EcsPoly *poly = ecs_get_pair(world, e, EcsPoly, EcsObserver);
+    if (!poly || !poly->poly) {
+        return;
     }
 
-    out = out_ptr = ecs_os_malloc_n(char, len + upper_count + 1);
-    for (ptr = str; (ch = *ptr); ptr ++) {
-        if (isupper(ch)) {
-            if ((ptr != str) && (out_ptr[-1] != '_')) {
-                out_ptr[0] = '_';
-                out_ptr ++;
+    ecs_observer_t *o = poly->poly;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    if (impl->flags & EcsObserverIsMulti) {
+        ecs_observer_t **children = ecs_vec_first(&impl->children);
+        int32_t i, children_count = ecs_vec_count(&impl->children);
+        if (children_count) {
+            for (i = 0; i < children_count; i ++) {
+                ECS_BIT_COND(flecs_observer_impl(children[i])->flags, bit, cond);
             }
-            out_ptr[0] = (char)tolower(ch);
-            out_ptr ++;
-        } else {
-            out_ptr[0] = ch;
-            out_ptr ++;
         }
+    } else {
+        flecs_poly_assert(o, ecs_observer_t);
+        ECS_BIT_COND(impl->flags, bit, cond);
     }
+}
 
-    out_ptr[0] = '\0';
+/**
+ * @file os_api.c
+ * @brief Operating system abstraction API.
+ * 
+ * The OS API implements an overridable interface for implementing functions 
+ * that are operating system specific, in addition to a number of hooks which
+ * allow for customization by the user, like logging.
+ */
 
-    return out;
-}
+#include <ctype.h>
+#include <time.h>
 
-char* flecs_load_from_file(
-    const char *filename)
-{
-    FILE* file;
-    char* content = NULL;
-    int32_t bytes;
-    size_t size;
+void ecs_os_api_impl(ecs_os_api_t *api);
 
-    /* Open file for reading */
-    ecs_os_fopen(&file, filename, "r");
-    if (!file) {
-        ecs_err("%s (%s)", ecs_os_strerror(errno), filename);
-        goto error;
-    }
+static bool ecs_os_api_initialized = false;
+static bool ecs_os_api_initializing = false;
+static int ecs_os_api_init_count = 0;
 
-    /* Determine file size */
-    fseek(file, 0, SEEK_END);
-    bytes = (int32_t)ftell(file);
-    if (bytes == -1) {
-        goto error;
-    }
-    fseek(file, 0, SEEK_SET);
+ecs_os_api_t ecs_os_api = {
+    .flags_ = EcsOsApiHighResolutionTimer | EcsOsApiLogWithColors,
+    .log_level_ = -1 /* Disable tracing by default, but log warnings/errors */
+};
 
-    /* Load contents in memory */
-    content = ecs_os_malloc(bytes + 1);
-    size = (size_t)bytes;
-    if (!(size = fread(content, 1, size, file)) && bytes) {
-        ecs_err("%s: read zero bytes instead of %d", filename, size);
-        ecs_os_free(content);
-        content = NULL;
-        goto error;
-    } else {
-        content[size] = '\0';
+int64_t ecs_os_api_malloc_count = 0;
+int64_t ecs_os_api_realloc_count = 0;
+int64_t ecs_os_api_calloc_count = 0;
+int64_t ecs_os_api_free_count = 0;
+
+void ecs_os_set_api(
+    ecs_os_api_t *os_api)
+{
+    if (!ecs_os_api_initialized) {
+        ecs_os_api = *os_api;
+        ecs_os_api_initialized = true;
     }
+}
 
-    fclose(file);
+ecs_os_api_t ecs_os_get_api(void) {
+    return ecs_os_api;
+}
 
-    return content;
-error:
-    ecs_os_free(content);
-    return NULL;
+void ecs_os_init(void)
+{
+    if (!ecs_os_api_initialized) {
+        ecs_os_set_api_defaults();
+    }
+    
+    if (!(ecs_os_api_init_count ++)) {
+        if (ecs_os_api.init_) {
+            ecs_os_api.init_();
+        }
+    }
 }
 
-/**
- * @file observable.c
- * @brief Observable implementation.
- * 
- * The observable implementation contains functions that find the set of 
- * observers to invoke for an event. The code also contains the implementation
- * of a reachable id cache, which is used to speedup event propagation when
- * relationships are added/removed to/from entities.
- */
+void ecs_os_fini(void) {
+    if (!--ecs_os_api_init_count) {
+        if (ecs_os_api.fini_) {
+            ecs_os_api.fini_();
+        }
+    }
+}
 
+/* Assume every non-glibc Linux target has no execinfo.
+   This mainly fixes musl support, as musl doesn't define any preprocessor macro specifying its presence. */ 
+#if defined(ECS_TARGET_LINUX) && !defined(__GLIBC__)
+#define HAVE_EXECINFO 0
+#elif !defined(ECS_TARGET_WINDOWS) && !defined(ECS_TARGET_EM) && !defined(ECS_TARGET_ANDROID)
+#define HAVE_EXECINFO 1
+#else
+#define HAVE_EXECINFO 0
+#endif
 
-void flecs_observable_init(
-    ecs_observable_t *observable)
-{
-    flecs_sparse_init_t(&observable->events, NULL, NULL, ecs_event_record_t);
-    observable->on_add.event = EcsOnAdd;
-    observable->on_remove.event = EcsOnRemove;
-    observable->on_set.event = EcsOnSet;
-    observable->un_set.event = EcsUnSet;
-}
+#if HAVE_EXECINFO
+#include <execinfo.h>
+#define ECS_BT_BUF_SIZE 100
 
-void flecs_observable_fini(
-    ecs_observable_t *observable)
+void flecs_dump_backtrace(
+    void *stream) 
 {
-    ecs_assert(!ecs_map_is_init(&observable->on_add.event_ids), 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!ecs_map_is_init(&observable->on_remove.event_ids), 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!ecs_map_is_init(&observable->on_set.event_ids), 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!ecs_map_is_init(&observable->un_set.event_ids), 
-        ECS_INTERNAL_ERROR, NULL);
+    int nptrs;
+    void *buffer[ECS_BT_BUF_SIZE];
+    char **strings;
 
-    ecs_sparse_t *events = &observable->events;
-    int32_t i, count = flecs_sparse_count(events);
-    for (i = 0; i < count; i ++) {
-        ecs_event_record_t *er = 
-            flecs_sparse_get_dense_t(events, ecs_event_record_t, i);
-        ecs_assert(er != NULL, ECS_INTERNAL_ERROR, NULL);
-        (void)er;
+    nptrs = backtrace(buffer, ECS_BT_BUF_SIZE);
 
-        /* All triggers should've unregistered by now */
-        ecs_assert(!ecs_map_is_init(&er->event_ids), 
-            ECS_INTERNAL_ERROR, NULL);
+    strings = backtrace_symbols(buffer, nptrs);
+    if (strings == NULL) {
+        return;
     }
 
-    flecs_sparse_fini(&observable->events);
+    for (int j = 1; j < nptrs; j++) {
+        fprintf(stream, "%s\n", strings[j]);
+    }
+
+    free(strings);
+}
+#else
+void flecs_dump_backtrace(
+    void *stream)
+{ 
+    (void)stream;
 }
+#endif
+#undef HAVE_EXECINFO_H
 
-ecs_event_record_t* flecs_event_record_get(
-    const ecs_observable_t *o,
-    ecs_entity_t event)
+static
+void flecs_log_msg(
+    int32_t level,
+    const char *file, 
+    int32_t line,  
+    const char *msg)
 {
-    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
-    
-    /* Builtin events*/
-    if      (event == EcsOnAdd)     return ECS_CONST_CAST(ecs_event_record_t*, &o->on_add);
-    else if (event == EcsOnRemove)  return ECS_CONST_CAST(ecs_event_record_t*, &o->on_remove);
-    else if (event == EcsOnSet)     return ECS_CONST_CAST(ecs_event_record_t*, &o->on_set);
-    else if (event == EcsUnSet)     return ECS_CONST_CAST(ecs_event_record_t*, &o->un_set);
-    else if (event == EcsWildcard)  return ECS_CONST_CAST(ecs_event_record_t*, &o->on_wildcard);
+    FILE *stream = ecs_os_api.log_out_;
+    if (!stream) {
+        stream = stdout;
+    }
 
-    /* User events */
-    return flecs_sparse_try_t(&o->events, ecs_event_record_t, event);
-}
+    bool use_colors = ecs_os_api.flags_ & EcsOsApiLogWithColors;
+    bool timestamp = ecs_os_api.flags_ & EcsOsApiLogWithTimeStamp;
+    bool deltatime = ecs_os_api.flags_ & EcsOsApiLogWithTimeDelta;
 
-ecs_event_record_t* flecs_event_record_ensure(
-    ecs_observable_t *o,
-    ecs_entity_t event)
-{
-    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
+    time_t now = 0;
 
-    ecs_event_record_t *er = flecs_event_record_get(o, event);
-    if (er) {
-        return er;
+    if (deltatime) {
+        now = time(NULL);
+        int64_t delta = 0;
+        if (ecs_os_api.log_last_timestamp_) {
+            delta = now - ecs_os_api.log_last_timestamp_;
+        }
+        ecs_os_api.log_last_timestamp_ = (int64_t)now;
+
+        if (delta) {
+            if (delta < 10) {
+                fputs(" ", stream);
+            }
+            if (delta < 100) {
+                fputs(" ", stream);
+            }
+            char time_buf[20];
+            ecs_os_sprintf(time_buf, "%u", (uint32_t)delta);
+            fputs("+", stream);
+            fputs(time_buf, stream);
+            fputs(" ", stream);
+        } else {
+            fputs("     ", stream);
+        }
     }
-    er = flecs_sparse_ensure_t(&o->events, ecs_event_record_t, event);
-    er->event = event;
-    return er;
-}
 
-static
-const ecs_event_record_t* flecs_event_record_get_if(
-    const ecs_observable_t *o,
-    ecs_entity_t event)
-{
-    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (timestamp) {
+        if (!now) {
+            now = time(NULL);
+        }
+        char time_buf[20];
+        ecs_os_sprintf(time_buf, "%u", (uint32_t)now);
+        fputs(time_buf, stream);
+        fputs(" ", stream);
+    }
 
-    const ecs_event_record_t *er = flecs_event_record_get(o, event);
-    if (er) {
-        if (ecs_map_is_init(&er->event_ids)) {
-            return er;
+    if (level >= 4) {
+        if (use_colors) fputs(ECS_NORMAL, stream);
+        fputs("jrnl", stream);
+    } else if (level >= 0) {
+        if (level == 0) {
+            if (use_colors) fputs(ECS_MAGENTA, stream);
+        } else {
+            if (use_colors) fputs(ECS_GREY, stream);
         }
-        if (er->any) {
-            return er;
+        fputs("info", stream);
+    } else if (level == -2) {
+        if (use_colors) fputs(ECS_YELLOW, stream);
+        fputs("warning", stream);
+    } else if (level == -3) {
+        if (use_colors) fputs(ECS_RED, stream);
+        fputs("error", stream);
+    } else if (level == -4) {
+        if (use_colors) fputs(ECS_RED, stream);
+        fputs("fatal", stream);
+    }
+
+    if (use_colors) fputs(ECS_NORMAL, stream);
+    fputs(": ", stream);
+
+    if (level >= 0) {
+        if (ecs_os_api.log_indent_) {
+            char indent[32];
+            int i, indent_count = ecs_os_api.log_indent_;
+            if (indent_count > 15) indent_count = 15;
+
+            for (i = 0; i < indent_count; i ++) {
+                indent[i * 2] = '|';
+                indent[i * 2 + 1] = ' ';
+            }
+
+            if (ecs_os_api.log_indent_ != indent_count) {
+                indent[i * 2 - 2] = '+';
+            }
+
+            indent[i * 2] = '\0';
+
+            fputs(indent, stream);
         }
-        if (er->wildcard) {
-            return er;
+    }
+
+    if (level < 0) {
+        if (file) {
+            const char *file_ptr = strrchr(file, '/');
+            if (!file_ptr) {
+                file_ptr = strrchr(file, '\\');
+            }
+
+            if (file_ptr) {
+                file = file_ptr + 1;
+            }
+
+            fputs(file, stream);
+            fputs(": ", stream);
         }
-        if (er->wildcard_pair) {
-            return er;
+
+        if (line) {
+            fprintf(stream, "%d: ", line);
         }
     }
 
-    return NULL;
+    fputs(msg, stream);
+
+    fputs("\n", stream);
+
+    if (level == -4) {
+        flecs_dump_backtrace(stream);
+    }
 }
 
-ecs_event_id_record_t* flecs_event_id_record_get(
-    const ecs_event_record_t *er,
-    ecs_id_t id)
+void ecs_os_dbg(
+    const char *file,
+    int32_t line, 
+    const char *msg)
 {
-    if (!er) {
-        return NULL;
+    if (ecs_os_api.log_) {
+        ecs_os_api.log_(1, file, line, msg);
     }
+}
 
-    if (id == EcsAny)                                  return er->any;
-    else if (id == EcsWildcard)                        return er->wildcard;
-    else if (id == ecs_pair(EcsWildcard, EcsWildcard)) return er->wildcard_pair;
-    else {
-        if (ecs_map_is_init(&er->event_ids)) {
-            return ecs_map_get_deref(&er->event_ids, ecs_event_id_record_t, id);
-        }
-        return NULL;
+void ecs_os_trace(
+    const char *file, 
+    int32_t line, 
+    const char *msg) 
+{
+    if (ecs_os_api.log_) {
+        ecs_os_api.log_(0, file, line, msg);
     }
 }
 
-static
-ecs_event_id_record_t* flecs_event_id_record_get_if(
-    const ecs_event_record_t *er,
-    ecs_id_t id)
+void ecs_os_warn(
+    const char *file, 
+    int32_t line, 
+    const char *msg) 
 {
-    ecs_event_id_record_t *ider = flecs_event_id_record_get(er, id);
-    if (!ider) {
-        return NULL;
+    if (ecs_os_api.log_) {
+        ecs_os_api.log_(-2, file, line, msg);
     }
+}
 
-    if (ider->observer_count) {
-        return ider;
+void ecs_os_err(
+    const char *file, 
+    int32_t line, 
+    const char *msg) 
+{
+    if (ecs_os_api.log_) {
+        ecs_os_api.log_(-3, file, line, msg);
     }
-
-    return NULL;
 }
 
-ecs_event_id_record_t* flecs_event_id_record_ensure(
-    ecs_world_t *world,
-    ecs_event_record_t *er,
-    ecs_id_t id)
+void ecs_os_fatal(
+    const char *file, 
+    int32_t line, 
+    const char *msg) 
 {
-    ecs_event_id_record_t *ider = flecs_event_id_record_get(er, id);
-    if (ider) {
-        return ider;
+    if (ecs_os_api.log_) {
+        ecs_os_api.log_(-4, file, line, msg);
     }
+}
 
-    ider = ecs_os_calloc_t(ecs_event_id_record_t);
+static
+void ecs_os_gettime(ecs_time_t *time) {
+    ecs_assert(ecs_os_has_time() == true, ECS_MISSING_OS_API, NULL);
+    
+    uint64_t now = ecs_os_now();
+    uint64_t sec = now / 1000000000;
 
-    if (id == EcsAny) {
-        return er->any = ider;
-    } else if (id == EcsWildcard) {
-        return er->wildcard = ider;
-    } else if (id == ecs_pair(EcsWildcard, EcsWildcard)) {
-        return er->wildcard_pair = ider;
-    }
+    assert(sec < UINT32_MAX);
+    assert((now - sec * 1000000000) < UINT32_MAX);
 
-    ecs_map_init_w_params_if(&er->event_ids, &world->allocators.ptr);
-    ecs_map_insert_ptr(&er->event_ids, id, ider);
-    return ider;
+    time->sec = (uint32_t)sec;
+    time->nanosec = (uint32_t)(now - sec * 1000000000);
 }
 
-void flecs_event_id_record_remove(
-    ecs_event_record_t *er,
-    ecs_id_t id)
-{
-    if (id == EcsAny) {
-        er->any = NULL;
-    } else if (id == EcsWildcard) {
-        er->wildcard = NULL;
-    } else if (id == ecs_pair(EcsWildcard, EcsWildcard)) {
-        er->wildcard_pair = NULL;
-    } else {
-        ecs_map_remove(&er->event_ids, id);
-        if (!ecs_map_count(&er->event_ids)) {
-            ecs_map_fini(&er->event_ids);
-        }
-    }
+static
+void* ecs_os_api_malloc(ecs_size_t size) {
+    ecs_os_linc(&ecs_os_api_malloc_count);
+    ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL);
+    return malloc((size_t)size);
 }
 
 static
-int32_t flecs_event_observers_get(
-    const ecs_event_record_t *er,
-    ecs_id_t id,
-    ecs_event_id_record_t **iders)
-{
-    if (!er) {
-        return 0;
-    }
+void* ecs_os_api_calloc(ecs_size_t size) {
+    ecs_os_linc(&ecs_os_api_calloc_count);
+    ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL);
+    return calloc(1, (size_t)size);
+}
 
-    /* Populate array with observer sets matching the id */
-    int32_t count = 0;
+static
+void* ecs_os_api_realloc(void *ptr, ecs_size_t size) {
+    ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL);
 
-    if (id != EcsAny) {
-        iders[0] = flecs_event_id_record_get_if(er, EcsAny);
-        count += iders[count] != 0;
+    if (ptr) {
+        ecs_os_linc(&ecs_os_api_realloc_count);
+    } else {
+        /* If not actually reallocing, treat as malloc */
+        ecs_os_linc(&ecs_os_api_malloc_count);
     }
+    
+    return realloc(ptr, (size_t)size);
+}
 
-    iders[count] = flecs_event_id_record_get_if(er, id);
-    count += iders[count] != 0;
+static
+void ecs_os_api_free(void *ptr) {
+    if (ptr) {
+        ecs_os_linc(&ecs_os_api_free_count);
+    }
+    free(ptr);
+}
 
-    if (id != EcsAny) {
-        if (ECS_IS_PAIR(id)) {
-            ecs_id_t id_fwc = ecs_pair(EcsWildcard, ECS_PAIR_SECOND(id));
-            ecs_id_t id_swc = ecs_pair(ECS_PAIR_FIRST(id), EcsWildcard);
-            ecs_id_t id_pwc = ecs_pair(EcsWildcard, EcsWildcard);
-            iders[count] = flecs_event_id_record_get_if(er, id_fwc);
-            count += iders[count] != 0;
-            iders[count] = flecs_event_id_record_get_if(er, id_swc);
-            count += iders[count] != 0;
-            iders[count] = flecs_event_id_record_get_if(er, id_pwc);
-            count += iders[count] != 0;
-        } else {
-            iders[count] = flecs_event_id_record_get_if(er, EcsWildcard);
-            count += iders[count] != 0;
-        }
+static
+char* ecs_os_api_strdup(const char *str) {
+    if (str) {
+        int len = ecs_os_strlen(str);
+        char *result = ecs_os_malloc(len + 1);
+        ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL);
+        ecs_os_strcpy(result, str);
+        return result;
+    } else {
+        return NULL;
     }
+}
 
-    return count;
+void ecs_os_strset(char **str, const char *value) {
+    char *old = str[0];
+    str[0] = ecs_os_strdup(value);
+    ecs_os_free(old);
 }
 
-bool flecs_observers_exist(
-    ecs_observable_t *observable,
-    ecs_id_t id,
-    ecs_entity_t event)
-{
-    const ecs_event_record_t *er = flecs_event_record_get_if(observable, event);
-    if (!er) {
-        return false;
+/* Replace dots with underscores */
+static
+char *module_file_base(const char *module, char sep) {
+    char *base = ecs_os_strdup(module);
+    ecs_size_t i, len = ecs_os_strlen(base);
+    for (i = 0; i < len; i ++) {
+        if (base[i] == '.') {
+            base[i] = sep;
+        }
     }
 
-    return flecs_event_id_record_get_if(er, id) != NULL;
+    return base;
 }
 
 static
-void flecs_emit_propagate(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_id_record_t *idr,
-    ecs_id_record_t *tgt_idr,
-    ecs_entity_t trav,
-    ecs_event_id_record_t **iders,
-    int32_t ider_count);
+char* ecs_os_api_module_to_dl(const char *module) {
+    ecs_strbuf_t lib = ECS_STRBUF_INIT;
 
-static
-void flecs_emit_propagate_id(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_id_record_t *idr,
-    ecs_id_record_t *cur,
-    ecs_entity_t trav,
-    ecs_event_id_record_t **iders,
-    int32_t ider_count)
-{
-    ecs_table_cache_iter_t idt;
-    if (!flecs_table_cache_all_iter(&cur->cache, &idt)) {
-        return;
-    }
+    /* Best guess, use module name with underscores + OS library extension */
+    char *file_base = module_file_base(module, '_');
 
-    const ecs_table_record_t *tr;
-    int32_t event_cur = it->event_cur;
-    while ((tr = flecs_table_cache_next(&idt, ecs_table_record_t))) {
-        ecs_table_t *table = tr->hdr.table;
-        if (!ecs_table_count(table)) {
-            continue;
-        }
+#   if defined(ECS_TARGET_LINUX) || defined(ECS_TARGET_FREEBSD)
+    ecs_strbuf_appendlit(&lib, "lib");
+    ecs_strbuf_appendstr(&lib, file_base);
+    ecs_strbuf_appendlit(&lib, ".so");
+#   elif defined(ECS_TARGET_DARWIN)
+    ecs_strbuf_appendlit(&lib, "lib");
+    ecs_strbuf_appendstr(&lib, file_base);
+    ecs_strbuf_appendlit(&lib, ".dylib");
+#   elif defined(ECS_TARGET_WINDOWS)
+    ecs_strbuf_appendstr(&lib, file_base);
+    ecs_strbuf_appendlit(&lib, ".dll");
+#   endif
 
-        bool owned = flecs_id_record_get_table(idr, table) != NULL;
+    ecs_os_free(file_base);
 
-        int32_t e, entity_count = ecs_table_count(table);
-        it->table = table;
-        it->other_table = NULL;
-        it->offset = 0;
-        it->count = entity_count;
-        if (entity_count) {
-            it->entities = ecs_vec_first(&table->data.entities);
-        }
-
-        /* Treat as new event as this could invoke observers again for
-         * different tables. */
-        it->event_cur = ++ world->event_id;
+    return ecs_strbuf_get(&lib);
+}
 
-        int32_t ider_i;
-        for (ider_i = 0; ider_i < ider_count; ider_i ++) {
-            ecs_event_id_record_t *ider = iders[ider_i];
-            flecs_observers_invoke(world, &ider->up, it, table, trav);
+static
+char* ecs_os_api_module_to_etc(const char *module) {
+    ecs_strbuf_t lib = ECS_STRBUF_INIT;
 
-            if (!owned) {
-                /* Owned takes precedence */
-                flecs_observers_invoke(world, &ider->self_up, it, table, trav);
-            }
-        }
+    /* Best guess, use module name with dashes + /etc */
+    char *file_base = module_file_base(module, '-');
 
-        if (!table->_->traversable_count) {
-            continue;
-        }
+    ecs_strbuf_appendstr(&lib, file_base);
+    ecs_strbuf_appendlit(&lib, "/etc");
 
-        ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
-        for (e = 0; e < entity_count; e ++) {
-            ecs_record_t *r = flecs_entities_get(world, entities[e]);
-            ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_id_record_t *idr_t = r->idr;
-            if (idr_t) {
-                /* Only notify for entities that are used in pairs with
-                 * traversable relationships */
-                flecs_emit_propagate(world, it, idr, idr_t, trav,
-                    iders, ider_count);
-            }
-        }
-    }
+    ecs_os_free(file_base);
 
-    it->event_cur = event_cur;
+    return ecs_strbuf_get(&lib);
 }
 
-static
-void flecs_emit_propagate(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_id_record_t *idr,
-    ecs_id_record_t *tgt_idr,
-    ecs_entity_t propagate_trav,
-    ecs_event_id_record_t **iders,
-    int32_t ider_count)
+void ecs_os_set_api_defaults(void)
 {
-    ecs_assert(tgt_idr != NULL, ECS_INTERNAL_ERROR, NULL);    
+    /* Don't overwrite if already initialized */
+    if (ecs_os_api_initialized != 0) {
+        return;
+    }
 
-    if (ecs_should_log_3()) {
-        char *idstr = ecs_id_str(world, tgt_idr->id);
-        ecs_dbg_3("propagate events/invalidate cache for %s", idstr);
-        ecs_os_free(idstr);
+    if (ecs_os_api_initializing != 0) {
+        return;
     }
-    ecs_log_push_3();
 
-    /* Propagate to records of traversable relationships */
-    ecs_id_record_t *cur = tgt_idr;
-    while ((cur = cur->trav.next)) {
-        cur->reachable.generation ++; /* Invalidate cache */
+    ecs_os_api_initializing = true;
+    
+    /* Memory management */
+    ecs_os_api.malloc_ = ecs_os_api_malloc;
+    ecs_os_api.free_ = ecs_os_api_free;
+    ecs_os_api.realloc_ = ecs_os_api_realloc;
+    ecs_os_api.calloc_ = ecs_os_api_calloc;
 
-        /* Get traversed relationship */
-        ecs_entity_t trav = ECS_PAIR_FIRST(cur->id);
-        if (propagate_trav && propagate_trav != trav) {
-            if (propagate_trav != EcsIsA) {
-                continue;
-            }
-        }
+    /* Strings */
+    ecs_os_api.strdup_ = ecs_os_api_strdup;
 
-        flecs_emit_propagate_id(
-            world, it, idr, cur, trav, iders, ider_count);
+    /* Time */
+    ecs_os_api.get_time_ = ecs_os_gettime;
+
+    /* Logging */
+    ecs_os_api.log_ = flecs_log_msg;
+
+    /* Modules */
+    if (!ecs_os_api.module_to_dl_) {
+        ecs_os_api.module_to_dl_ = ecs_os_api_module_to_dl;
     }
 
-    ecs_log_pop_3();
+    if (!ecs_os_api.module_to_etc_) {
+        ecs_os_api.module_to_etc_ = ecs_os_api_module_to_etc;
+    }
+
+    ecs_os_api.abort_ = abort;
+
+#   ifdef FLECS_OS_API_IMPL
+    /* Initialize defaults to OS API IMPL addon, but still allow for overriding
+     * by the application */
+    ecs_set_os_api_impl();
+    ecs_os_api_initialized = false;
+#   endif
+
+    ecs_os_api_initializing = false;
 }
 
-static
-void flecs_emit_propagate_invalidate_tables(
-    ecs_world_t *world,
-    ecs_id_record_t *tgt_idr)
-{
-    ecs_assert(tgt_idr != NULL, ECS_INTERNAL_ERROR, NULL);
+bool ecs_os_has_heap(void) {
+    return 
+        (ecs_os_api.malloc_ != NULL) &&
+        (ecs_os_api.calloc_ != NULL) &&
+        (ecs_os_api.realloc_ != NULL) &&
+        (ecs_os_api.free_ != NULL);
+}
 
-    if (ecs_should_log_3()) {
-        char *idstr = ecs_id_str(world, tgt_idr->id);
-        ecs_dbg_3("invalidate reachable cache for %s", idstr);
-        ecs_os_free(idstr);
-    }
+bool ecs_os_has_threading(void) {
+    return
+        (ecs_os_api.mutex_new_ != NULL) &&
+        (ecs_os_api.mutex_free_ != NULL) &&
+        (ecs_os_api.mutex_lock_ != NULL) &&
+        (ecs_os_api.mutex_unlock_ != NULL) &&
+        (ecs_os_api.cond_new_ != NULL) &&
+        (ecs_os_api.cond_free_ != NULL) &&
+        (ecs_os_api.cond_wait_ != NULL) &&
+        (ecs_os_api.cond_signal_ != NULL) &&
+        (ecs_os_api.cond_broadcast_ != NULL) &&
+        (ecs_os_api.thread_new_ != NULL) &&
+        (ecs_os_api.thread_join_ != NULL) &&
+        (ecs_os_api.thread_self_ != NULL);
+}
 
-    /* Invalidate records of traversable relationships */
-    ecs_id_record_t *cur = tgt_idr;
-    while ((cur = cur->trav.next)) {
-        ecs_reachable_cache_t *rc = &cur->reachable;
-        if (rc->current != rc->generation) {
-            /* Subtree is already marked invalid */
-            continue;
-        }
+bool ecs_os_has_task_support(void) {
+    return
+        (ecs_os_api.mutex_new_ != NULL) &&
+        (ecs_os_api.mutex_free_ != NULL) &&
+        (ecs_os_api.mutex_lock_ != NULL) &&
+        (ecs_os_api.mutex_unlock_ != NULL) &&
+        (ecs_os_api.cond_new_ != NULL) &&
+        (ecs_os_api.cond_free_ != NULL) &&
+        (ecs_os_api.cond_wait_ != NULL) &&
+        (ecs_os_api.cond_signal_ != NULL) &&
+        (ecs_os_api.cond_broadcast_ != NULL) &&
+        (ecs_os_api.task_new_ != NULL) &&
+        (ecs_os_api.task_join_ != NULL);
+}
 
-        rc->generation ++;
+bool ecs_os_has_time(void) {
+    return 
+        (ecs_os_api.get_time_ != NULL) &&
+        (ecs_os_api.sleep_ != NULL) &&
+        (ecs_os_api.now_ != NULL);
+}
 
-        ecs_table_cache_iter_t idt;
-        if (!flecs_table_cache_all_iter(&cur->cache, &idt)) {
-            continue;
-        }
+bool ecs_os_has_logging(void) {
+    return (ecs_os_api.log_ != NULL);
+}
 
-        const ecs_table_record_t *tr;
-        while ((tr = flecs_table_cache_next(&idt, ecs_table_record_t))) {
-            ecs_table_t *table = tr->hdr.table;
-            if (!table->_->traversable_count) {
-                continue;
-            }
+bool ecs_os_has_dl(void) {
+    return 
+        (ecs_os_api.dlopen_ != NULL) &&
+        (ecs_os_api.dlproc_ != NULL) &&
+        (ecs_os_api.dlclose_ != NULL);  
+}
 
-            int32_t e, entity_count = ecs_table_count(table);
-            ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
+bool ecs_os_has_modules(void) {
+    return 
+        (ecs_os_api.module_to_dl_ != NULL) &&
+        (ecs_os_api.module_to_etc_ != NULL);
+}
 
-            for (e = 0; e < entity_count; e ++) {
-                ecs_record_t *r = flecs_entities_get(world, entities[e]);
-                ecs_id_record_t *idr_t = r->idr;
-                if (idr_t) {
-                    /* Only notify for entities that are used in pairs with
-                     * traversable relationships */
-                    flecs_emit_propagate_invalidate_tables(world, idr_t);
-                }
-            }
-        }
-    }
+#if defined(ECS_TARGET_WINDOWS)
+static char error_str[255];
+#endif
+
+const char* ecs_os_strerror(int err) {
+#   if defined(ECS_TARGET_WINDOWS)
+    strerror_s(error_str, 255, err);
+    return error_str;
+#   else
+    return strerror(err);
+#   endif
 }
 
-void flecs_emit_propagate_invalidate(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    int32_t offset,
-    int32_t count)
-{
-    ecs_entity_t *entities = ecs_vec_get_t(&table->data.entities, 
-        ecs_entity_t, offset);
-    int32_t i;
-    for (i = 0; i < count; i ++) {
-        ecs_record_t *record = flecs_entities_get(world, entities[i]);
-        if (!record) {
-            /* If the event is emitted after a bulk operation, it's possible
-             * that it hasn't been populated with entities yet. */
-            continue;
-        }
+/**
+ * @file poly.c
+ * @brief Functions for managing poly objects.
+ * 
+ * The poly framework makes it possible to generalize common functionality for
+ * different kinds of API objects, as well as improved type safety checks. Poly
+ * objects have a header that identifiers what kind of object it is. This can
+ * then be used to discover a set of "mixins" implemented by the type.
+ * 
+ * Mixins are like a vtable, but for members. Each type populates the table with
+ * offsets to the members that correspond with the mixin. If an entry in the
+ * mixin table is not set, the type does not support the mixin.
+ */
 
-        ecs_id_record_t *idr_t = record->idr;
-        if (idr_t) {
-            /* Event is used as target in traversable relationship, propagate */
-            flecs_emit_propagate_invalidate_tables(world, idr_t);
-        }
+
+static const char* mixin_kind_str[] = {
+    [EcsMixinWorld] = "world",
+    [EcsMixinEntity] = "entity",
+    [EcsMixinObservable] = "observable",
+    [EcsMixinDtor] = "dtor",
+    [EcsMixinMax] = "max (should never be requested by application)"
+};
+
+ecs_mixins_t ecs_world_t_mixins = {
+    .type_name = "ecs_world_t",
+    .elems = {
+        [EcsMixinWorld] = offsetof(ecs_world_t, self),
+        [EcsMixinObservable] = offsetof(ecs_world_t, observable),
     }
-}
+};
+
+ecs_mixins_t ecs_stage_t_mixins = {
+    .type_name = "ecs_stage_t",
+    .elems = {
+        [EcsMixinWorld] = offsetof(ecs_stage_t, world)
+    }
+};
+
+ecs_mixins_t ecs_observer_t_mixins = {
+    .type_name = "ecs_observer_t",
+    .elems = {
+        [EcsMixinWorld] = offsetof(ecs_observer_t, world),
+        [EcsMixinEntity] = offsetof(ecs_observer_t, entity),
+        [EcsMixinDtor] = offsetof(ecs_observer_impl_t, dtor)
+    }
+};
 
 static
-void flecs_propagate_entities(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_id_record_t *idr,
-    ecs_entity_t *entities,
-    int32_t count,
-    ecs_entity_t src,
-    ecs_event_id_record_t **iders,
-    int32_t ider_count)
+void* assert_mixin(
+    const flecs_poly_t *poly,
+    ecs_mixin_kind_t kind)
 {
-    if (!count) {
-        return;
-    }
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(kind < EcsMixinMax, ECS_INVALID_PARAMETER, NULL);
+    
+    const ecs_header_t *hdr = poly;
+    ecs_assert(hdr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
 
-    ecs_entity_t old_src = it->sources[0];
-    ecs_table_t *old_table = it->table;
-    ecs_table_t *old_other_table = it->other_table;
-    ecs_entity_t *old_entities = it->entities;
-    int32_t old_count = it->count;
-    int32_t old_offset = it->offset;
+    const ecs_mixins_t *mixins = hdr->mixins;
+    ecs_assert(mixins != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    int32_t i;
-    for (i = 0; i < count; i ++) {
-        ecs_record_t *record = flecs_entities_get(world, entities[i]);
-        if (!record) {
-            /* If the event is emitted after a bulk operation, it's possible
-             * that it hasn't been populated with entities yet. */
-            continue;
-        }
+    ecs_size_t offset = mixins->elems[kind];
+    ecs_assert(offset != 0, ECS_INVALID_PARAMETER, 
+        "mixin %s not available for type %s",
+            mixin_kind_str[kind], mixins ? mixins->type_name : "unknown");
+    (void)mixin_kind_str;
 
-        ecs_id_record_t *idr_t = record->idr;
-        if (idr_t) {
-            /* Entity is used as target in traversable pairs, propagate */
-            ecs_entity_t e = src ? src : entities[i];
-            it->sources[0] = e;
-            flecs_emit_propagate(
-                world, it, idr, idr_t, 0, iders, ider_count);
-        }
-    }
-    
-    it->table = old_table;
-    it->other_table = old_other_table;
-    it->entities = old_entities;
-    it->count = old_count;
-    it->offset = old_offset;
-    it->sources[0] = old_src;
+    /* Object has mixin, return its address */
+    return ECS_OFFSET(hdr, offset);
 }
 
-static
-void flecs_override_copy(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    const ecs_type_info_t *ti,
-    void *dst,
-    const void *src,
-    int32_t offset,
-    int32_t count)
+void* flecs_poly_init_(
+    flecs_poly_t *poly,
+    int32_t type,
+    ecs_size_t size,
+    ecs_mixins_t *mixins)
 {
-    void *ptr = dst;
-    ecs_copy_t copy = ti->hooks.copy;
-    ecs_size_t size = ti->size;
-    int32_t i;
-    if (copy) {
-        for (i = 0; i < count; i ++) {
-            copy(ptr, src, 1, ti);
-            ptr = ECS_OFFSET(ptr, size);
-        }
-    } else {
-        for (i = 0; i < count; i ++) {
-            ecs_os_memcpy(ptr, src, size);
-            ptr = ECS_OFFSET(ptr, size);
-        }
-    }
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_iter_action_t on_set = ti->hooks.on_set;
-    if (on_set) {
-        ecs_entity_t *entities = ecs_vec_get_t(
-            &table->data.entities, ecs_entity_t, offset);
-        flecs_invoke_hook(world, table, count, offset, entities,
-            dst, ti->component, ti, EcsOnSet, on_set);
-    }
+    ecs_header_t *hdr = poly;
+    ecs_os_memset(poly, 0, size);
+
+    hdr->magic = ECS_OBJECT_MAGIC;
+    hdr->type = type;
+    hdr->refcount = 1;
+    hdr->mixins = mixins;
+
+    return poly;
 }
 
-static
-void* flecs_override(
-    ecs_iter_t *it, 
-    const ecs_type_t *emit_ids,
-    ecs_id_t id,
-    ecs_table_t *table,
-    ecs_id_record_t *idr)
+void flecs_poly_fini_(
+    flecs_poly_t *poly,
+    int32_t type)
 {
-    if (it->event != EcsOnAdd || (it->flags & EcsEventNoOnSet)) {
-        return NULL;
-    }
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    (void)type;
 
-    int32_t i = 0, count = emit_ids->count;
-    ecs_id_t *ids = emit_ids->array;
-    for (i = 0; i < count; i ++) {
-        if (ids[i] == id) {
-            /* If an id was both inherited and overridden in the same event
-             * (like what happens during an auto override), we need to copy the
-             * value of the inherited component to the new component.
-             * Also flag to the callee that this component was overridden, so
-             * that an OnSet event can be emmitted for it.
-             * Note that this is different from a component that was overridden
-             * after it was inherited, as this does not change the actual value
-             * of the component for the entity (it is copied from the existing
-             * overridden component), and does not require an OnSet event. */
-            ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-            if (!tr) {
-                continue;
-            }
+    ecs_header_t *hdr = poly;
 
-            int32_t index = tr->column;
-            ecs_assert(index != -1, ECS_INTERNAL_ERROR, NULL);
+    /* Don't deinit poly that wasn't initialized */
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
+    ecs_assert(hdr->type == type, ECS_INVALID_PARAMETER,
+        "incorrect function called to free flecs object");
+    hdr->magic = 0;
+}
 
-            ecs_column_t *column = &table->data.columns[index];
-            ecs_size_t size = column->ti->size;
-            return ecs_vec_get(&column->data, size, it->offset);
-        }
+int32_t flecs_poly_claim_(
+    flecs_poly_t *poly)
+{
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_header_t *hdr = poly;
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
+    if (ecs_os_has_threading()) {
+        return ecs_os_ainc(&hdr->refcount);
+    } else {
+        return ++hdr->refcount;
     }
+}
 
-    return NULL;
+int32_t flecs_poly_release_(
+    flecs_poly_t *poly)
+{
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_header_t *hdr = poly;
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
+    if (ecs_os_has_threading()) {
+        return ecs_os_adec(&hdr->refcount);
+    } else {
+        return --hdr->refcount;
+    }
 }
 
-static
-void flecs_emit_forward_up(
-    ecs_world_t *world,
-    const ecs_event_record_t *er,
-    const ecs_event_record_t *er_onset,
-    const ecs_type_t *emit_ids,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_id_record_t *idr,
-    ecs_vec_t *stack,
-    ecs_vec_t *reachable_ids);
+int32_t flecs_poly_refcount(
+    flecs_poly_t *poly)
+{
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_header_t *hdr = poly;
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
+    return hdr->refcount;
+}
 
-static
-void flecs_emit_forward_id(
+EcsPoly* flecs_poly_bind_(
     ecs_world_t *world,
-    const ecs_event_record_t *er,
-    const ecs_event_record_t *er_onset,
-    const ecs_type_t *emit_ids,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_id_record_t *idr,
-    ecs_entity_t tgt,
-    ecs_table_t *tgt_table,
-    int32_t column,
-    int32_t offset,
-    ecs_entity_t trav)
+    ecs_entity_t entity,
+    ecs_entity_t tag)
 {
-    ecs_id_t id = idr->id;
-    ecs_entity_t event = er ? er->event : 0;
-    bool inherit = trav == EcsIsA;
-    bool may_override = inherit && (event == EcsOnAdd) && (emit_ids->count > 1);
-    ecs_event_id_record_t *iders[5];
-    ecs_event_id_record_t *iders_onset[5];
-
-    /* Skip id if there are no observers for it */
-    int32_t ider_i, ider_count = flecs_event_observers_get(er, id, iders);
-    int32_t ider_onset_i, ider_onset_count = 0;
-    if (er_onset) {
-        ider_onset_count = flecs_event_observers_get(
-            er_onset, id, iders_onset);
+    /* Add tag to the entity for easy querying. This will make it possible to
+     * query for `Query` instead of `(Poly, Query) */
+    if (!ecs_has_id(world, entity, tag)) {
+        ecs_add_id(world, entity, tag);
     }
 
-    if (!may_override && (!ider_count && !ider_onset_count)) {
-        return;
+    /* Never defer creation of a poly object */
+    bool deferred = false;
+    if (ecs_is_deferred(world)) {
+        deferred = true;
+        ecs_defer_suspend(world);
     }
 
-    it->ids[0] = id;
-    it->sources[0] = tgt;
-    it->event_id = id;
-    it->ptrs[0] = NULL;
-    it->sizes[0] = 0;
+    /* If this is a new poly, leave the actual creation up to the caller so they
+     * call tell the difference between a create or an update */
+    EcsPoly *result = ecs_ensure_pair(world, entity, EcsPoly, tag);
 
-    int32_t storage_i = ecs_table_type_to_column_index(tgt_table, column);
-    if (storage_i != -1) {
-        ecs_assert(idr->type_info != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_column_t *c = &tgt_table->data.columns[storage_i];
-        it->ptrs[0] = ecs_vec_get(&c->data, c->ti->size, offset);
-        it->sizes[0] = c->ti->size;
+    if (deferred) {
+        ecs_defer_resume(world);
     }
 
-    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-    bool owned = tr != NULL;
-
-    for (ider_i = 0; ider_i < ider_count; ider_i ++) {
-        ecs_event_id_record_t *ider = iders[ider_i];
-        flecs_observers_invoke(world, &ider->up, it, table, trav);
+    return result;
+}
 
-        /* Owned takes precedence */
-        if (!owned) {
-            flecs_observers_invoke(world, &ider->self_up, it, table, trav);
-        }
-    }
+void flecs_poly_modified_(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t tag)
+{
+    ecs_modified_pair(world, entity, ecs_id(EcsPoly), tag);
+}
 
-    /* Emit OnSet events for newly inherited components */
-    if (storage_i != -1) {
-        bool override = false;
+const EcsPoly* flecs_poly_bind_get_(
+    const ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t tag)
+{
+    return ecs_get_pair(world, entity, EcsPoly, tag);
+}
 
-        /* If component was added together with IsA relationship, still emit
-         * OnSet event, as it's a new value for the entity. */
-        void *base_ptr = it->ptrs[0];
-        void *ptr = flecs_override(it, emit_ids, id, table, idr);
-        if (ptr) {
-            override = true;
-            it->ptrs[0] = ptr;
-        }
+flecs_poly_t* flecs_poly_get_(
+    const ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t tag)
+{
+    const EcsPoly *p = flecs_poly_bind_get_(world, entity, tag);
+    if (p) {
+        return p->poly;
+    }
+    return NULL;
+}
 
-        if (ider_onset_count) {
-            it->event = er_onset->event;
+bool flecs_poly_is_(
+    const flecs_poly_t *poly,
+    int32_t type)
+{
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
 
-            for (ider_onset_i = 0; ider_onset_i < ider_onset_count; ider_onset_i ++) {
-                ecs_event_id_record_t *ider = iders_onset[ider_onset_i];
-                flecs_observers_invoke(world, &ider->up, it, table, trav);
+    const ecs_header_t *hdr = poly;
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
+    return hdr->type == type;    
+}
 
-                /* Owned takes precedence */
-                if (!owned) {
-                    flecs_observers_invoke(
-                        world, &ider->self_up, it, table, trav);
-                } else if (override) {
-                    ecs_entity_t src = it->sources[0];
-                    it->sources[0] = 0;
-                    flecs_observers_invoke(world, &ider->self, it, table, 0);
-                    flecs_observers_invoke(world, &ider->self_up, it, table, 0);
-                    it->sources[0] = src;
-                }
-            }
+ecs_observable_t* ecs_get_observable(
+    const flecs_poly_t *poly)
+{
+    return (ecs_observable_t*)assert_mixin(poly, EcsMixinObservable);
+}
 
-            it->event = event;
-            it->ptrs[0] = base_ptr;
-        }
+const ecs_world_t* ecs_get_world(
+    const flecs_poly_t *poly)
+{
+    if (((const ecs_header_t*)poly)->type == ecs_world_t_magic) {
+        return poly;
     }
+    return *(ecs_world_t**)assert_mixin(poly, EcsMixinWorld);
 }
 
-static
-void flecs_emit_forward_and_cache_id(
-    ecs_world_t *world,
-    const ecs_event_record_t *er,
-    const ecs_event_record_t *er_onset,
-    const ecs_type_t *emit_ids,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_id_record_t *idr,
-    ecs_entity_t tgt,
-    ecs_record_t *tgt_record,
-    ecs_table_t *tgt_table,
-    const ecs_table_record_t *tgt_tr,
-    int32_t column,
-    int32_t offset,
-    ecs_vec_t *reachable_ids,
-    ecs_entity_t trav)
+ecs_entity_t ecs_get_entity(
+    const flecs_poly_t *poly)
 {
-    /* Cache forwarded id for (rel, tgt) pair */
-    ecs_reachable_elem_t *elem = ecs_vec_append_t(&world->allocator,
-        reachable_ids, ecs_reachable_elem_t);
-    elem->tr = tgt_tr;
-    elem->record = tgt_record;
-    elem->src = tgt;
-    elem->id = idr->id;
-#ifndef NDEBUG
-    elem->table = tgt_table;
-#endif
-    ecs_assert(tgt_table == tgt_record->table, ECS_INTERNAL_ERROR, NULL);
-
-    flecs_emit_forward_id(world, er, er_onset, emit_ids, it, table, idr,
-        tgt, tgt_table, column, offset, trav);
+    return *(ecs_entity_t*)assert_mixin(poly, EcsMixinEntity);
 }
 
-static
-int32_t flecs_emit_stack_at(
-    ecs_vec_t *stack,
-    ecs_id_record_t *idr)
+flecs_poly_dtor_t* ecs_get_dtor(
+    const flecs_poly_t *poly)
 {
-    int32_t sp = 0, stack_count = ecs_vec_count(stack);
-    ecs_table_t **stack_elems = ecs_vec_first(stack);
+    return (flecs_poly_dtor_t*)assert_mixin(poly, EcsMixinDtor);
+}
 
-    for (sp = 0; sp < stack_count; sp ++) {
-        ecs_table_t *elem = stack_elems[sp];
-        if (flecs_id_record_get_table(idr, elem)) {
-            break;
-        }
-    }
+/**
+ * @file search.c
+ * @brief Search functions to find (component) ids in table types.
+ * 
+ * Search functions are used to find the column index of a (component) id in a
+ * table. Additionally, search functions implement the logic for finding a
+ * component id by following a relationship upwards.
+ */
 
-    return sp;
-}
 
 static
-bool flecs_emit_stack_has(
-    ecs_vec_t *stack,
-    ecs_id_record_t *idr)
+int32_t flecs_type_search(
+    const ecs_table_t *table,
+    ecs_id_record_t *idr,
+    ecs_id_t *ids,
+    ecs_id_t *id_out,
+    ecs_table_record_t **tr_out)
 {
-    return flecs_emit_stack_at(stack, idr) != ecs_vec_count(stack);
+    ecs_table_record_t *tr = ecs_table_cache_get(&idr->cache, table);
+    if (tr) {
+        int32_t r = tr->index;
+        if (tr_out) tr_out[0] = tr;
+        if (id_out) {
+            id_out[0] = ids[r];
+        }
+        return r;
+    }
+
+    return -1;
 }
 
 static
-void flecs_emit_forward_cached_ids(
-    ecs_world_t *world,
-    const ecs_event_record_t *er,
-    const ecs_event_record_t *er_onset,
-    const ecs_type_t *emit_ids,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_reachable_cache_t *rc,
-    ecs_vec_t *reachable_ids,
-    ecs_vec_t *stack,
-    ecs_entity_t trav)
+int32_t flecs_type_offset_search(
+    int32_t offset,
+    ecs_id_t id,
+    ecs_id_t *ids,
+    int32_t count,
+    ecs_id_t *id_out)
 {
-    ecs_reachable_elem_t *elems = ecs_vec_first_t(&rc->ids, 
-        ecs_reachable_elem_t);
-    int32_t i, count = ecs_vec_count(&rc->ids);
-    for (i = 0; i < count; i ++) {
-        ecs_reachable_elem_t *rc_elem = &elems[i];
-        const ecs_table_record_t *rc_tr = rc_elem->tr;
-        ecs_assert(rc_tr != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_id_record_t *rc_idr = (ecs_id_record_t*)rc_tr->hdr.cache;
-        ecs_record_t *rc_record = rc_elem->record;
-
-        ecs_assert(rc_idr->id == rc_elem->id, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(rc_record != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(flecs_entities_get(world, rc_elem->src) == 
-            rc_record, ECS_INTERNAL_ERROR, NULL);
-        ecs_dbg_assert(rc_record->table == rc_elem->table, 
-            ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(ids != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(count > 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(offset > 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
 
-        if (flecs_emit_stack_has(stack, rc_idr)) {
-            continue;
+    while (offset < count) {
+        ecs_id_t type_id = ids[offset ++];
+        if (ecs_id_match(type_id, id)) {
+            if (id_out) {
+                id_out[0] = type_id;
+            }
+            return offset - 1;
         }
-
-        int32_t rc_offset = ECS_RECORD_TO_ROW(rc_record->row);
-        flecs_emit_forward_and_cache_id(world, er, er_onset, emit_ids,
-            it, table, rc_idr, rc_elem->src,
-                rc_record, rc_record->table, rc_tr, rc_tr->index,
-                    rc_offset, reachable_ids, trav);
     }
+
+    return -1;
 }
 
-static
-void flecs_emit_dump_cache(
-    ecs_world_t *world,
-    const ecs_vec_t *vec)
+bool flecs_type_can_inherit_id(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    const ecs_id_record_t *idr,
+    ecs_id_t id)
 {
-    ecs_reachable_elem_t *elems = ecs_vec_first_t(vec, ecs_reachable_elem_t);
-    for (int i = 0; i < ecs_vec_count(vec); i ++) {
-        ecs_reachable_elem_t *elem = &elems[i];
-        char *idstr = ecs_id_str(world, elem->id);
-        char *estr = ecs_id_str(world, elem->src);
-        ecs_dbg_3("- id: %s (%u), src: %s (%u), table: %p", 
-            idstr, (uint32_t)elem->id,
-            estr, (uint32_t)elem->src,
-            elem->table);
-        ecs_os_free(idstr);
-        ecs_os_free(estr);
+    ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (idr->flags & EcsIdDontInherit) {
+        return false;
     }
-    if (!ecs_vec_count(vec)) {
-        ecs_dbg_3("- no entries");
+    if (idr->flags & EcsIdExclusive) {
+        if (ECS_HAS_ID_FLAG(id, PAIR)) {
+            ecs_entity_t er = ECS_PAIR_FIRST(id);
+            if (flecs_table_record_get(
+                world, table, ecs_pair(er, EcsWildcard))) 
+            {
+                return false;
+            }
+        }
     }
+    return true;
 }
 
 static
-void flecs_emit_forward_table_up(
-    ecs_world_t *world,
-    const ecs_event_record_t *er,
-    const ecs_event_record_t *er_onset,
-    const ecs_type_t *emit_ids,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_entity_t tgt,
-    ecs_table_t *tgt_table,
-    ecs_record_t *tgt_record,
-    ecs_id_record_t *tgt_idr,
-    ecs_vec_t *stack,
-    ecs_vec_t *reachable_ids)
+int32_t flecs_type_search_relation(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    int32_t offset,
+    ecs_id_t id,
+    ecs_id_record_t *idr,
+    ecs_id_t rel,
+    ecs_id_record_t *idr_r,
+    bool self,
+    ecs_entity_t *subject_out,
+    ecs_id_t *id_out,
+    ecs_table_record_t **tr_out)
 {
-    ecs_allocator_t *a = &world->allocator;
-    int32_t i, id_count = tgt_table->type.count;
-    ecs_id_t *ids = tgt_table->type.array;
-    int32_t offset = ECS_RECORD_TO_ROW(tgt_record->row);
-    int32_t rc_child_offset = ecs_vec_count(reachable_ids);
-    int32_t stack_count = ecs_vec_count(stack);
+    ecs_type_t type = table->type;
+    ecs_id_t *ids = type.array;
+    int32_t count = type.count;
 
-    /* If tgt_idr is out of sync but is not the current id record being updated,
-     * keep track so that we can update two records for the cost of one. */
-    ecs_reachable_cache_t *rc = &tgt_idr->reachable;
-    bool parent_revalidate = (reachable_ids != &rc->ids) && 
-        (rc->current != rc->generation);
-    if (parent_revalidate) {
-        ecs_vec_reset_t(a, &rc->ids, ecs_reachable_elem_t);
+    if (self) {
+        if (offset) {
+            int32_t r = flecs_type_offset_search(offset, id, ids, count, id_out);
+            if (r != -1) {
+                return r;
+            }
+        } else {
+            int32_t r = flecs_type_search(table, idr, ids, id_out, tr_out);
+            if (r != -1) {
+                return r;
+            }
+        }
     }
 
-    if (ecs_should_log_3()) {
-        char *idstr = ecs_id_str(world, tgt_idr->id);
-        ecs_dbg_3("forward events from %s", idstr);
-        ecs_os_free(idstr);
-    }
-    ecs_log_push_3();
+    ecs_flags32_t flags = table->flags;
+    if ((flags & EcsTableHasPairs) && rel) {
+        bool is_a = rel == ecs_pair(EcsIsA, EcsWildcard);
+        if (is_a) {
+            if (!(flags & EcsTableHasIsA)) {
+                return -1;
+            }
+            idr_r = world->idr_isa_wildcard;
 
-    /* Function may have to copy values from overridden components if an IsA
-     * relationship was added together with other components. */
-    ecs_entity_t trav = ECS_PAIR_FIRST(tgt_idr->id);
-    bool inherit = trav == EcsIsA;
+            if (!flecs_type_can_inherit_id(world, table, idr, id)) {
+                return -1;
+            }
+        }
 
-    for (i = 0; i < id_count; i ++) {
-        ecs_id_t id = ids[i];
-        ecs_table_record_t *tgt_tr = &tgt_table->_->records[i];
-        ecs_id_record_t *idr = (ecs_id_record_t*)tgt_tr->hdr.cache;
-        if (inherit && (idr->flags & EcsIdDontInherit)) {
-            continue;
+        if (!idr_r) {
+            idr_r = flecs_id_record_get(world, rel);
+            if (!idr_r) {
+                return -1;
+            }
         }
 
-        /* Id has the same relationship, traverse to find ids for forwarding */
-        if (ECS_PAIR_FIRST(id) == trav || ECS_PAIR_FIRST(id) == EcsIsA) {
-            ecs_table_t **t = ecs_vec_append_t(&world->allocator, stack, 
-                ecs_table_t*);
-            t[0] = tgt_table;
+        ecs_id_t id_r;
+        int32_t r, r_column;
+        if (offset) {
+            r_column = flecs_type_offset_search(offset, rel, ids, count, &id_r);
+        } else {
+            r_column = flecs_type_search(table, idr_r, ids, &id_r, 0);
+        }
+        while (r_column != -1) {
+            ecs_entity_t obj = ECS_PAIR_SECOND(id_r);
+            ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL);
 
-            ecs_reachable_cache_t *idr_rc = &idr->reachable;
-            if (idr_rc->current == idr_rc->generation) {
-                /* Cache hit, use cached ids to prevent traversing the same
-                 * hierarchy multiple times. This especially speeds up code 
-                 * where (deep) hierarchies are created. */
-                if (ecs_should_log_3()) {
-                    char *idstr = ecs_id_str(world, id);
-                    ecs_dbg_3("forward cached for %s", idstr);
-                    ecs_os_free(idstr);
-                }
-                ecs_log_push_3();
-                flecs_emit_forward_cached_ids(world, er, er_onset, emit_ids, it,
-                    table, idr_rc, reachable_ids, stack, trav);
-                ecs_log_pop_3();
-            } else {
-                /* Cache is dirty, traverse upwards */
-                do {
-                    flecs_emit_forward_up(world, er, er_onset, emit_ids, it, 
-                        table, idr, stack, reachable_ids);
-                    if (++i >= id_count) {
-                        break;
+            ecs_record_t *rec = flecs_entities_get_any(world, obj);
+            ecs_assert(rec != NULL, ECS_INTERNAL_ERROR, NULL);
+
+            ecs_table_t *obj_table = rec->table;
+            if (obj_table) {
+                ecs_assert(obj_table != table, ECS_CYCLE_DETECTED, NULL);
+                
+                r = flecs_type_search_relation(world, obj_table, 0, id, idr, 
+                    rel, idr_r, true, subject_out, id_out, tr_out);
+                if (r != -1) {
+                    if (subject_out && !subject_out[0]) {
+                        subject_out[0] = ecs_get_alive(world, obj);
                     }
+                    return r_column;
+                }
 
-                    id = ids[i];
-                    if (ECS_PAIR_FIRST(id) != trav) {
-                        break;
+                if (!is_a) {
+                    r = flecs_type_search_relation(world, obj_table, 0, id, idr, 
+                        ecs_pair(EcsIsA, EcsWildcard), world->idr_isa_wildcard, 
+                            true, subject_out, id_out, tr_out);
+                    if (r != -1) {
+                        if (subject_out && !subject_out[0]) {
+                            subject_out[0] = ecs_get_alive(world, obj);
+                        }
+                        return r_column;
                     }
-                } while (true);
+                }
             }
 
-            ecs_vec_remove_last(stack);
-            continue;
-        }
-
-        int32_t stack_at = flecs_emit_stack_at(stack, idr);
-        if (parent_revalidate && (stack_at == (stack_count - 1))) {
-            /* If parent id record needs to be revalidated, add id */
-            ecs_reachable_elem_t *elem = ecs_vec_append_t(a, &rc->ids, 
-                ecs_reachable_elem_t);
-            elem->tr = tgt_tr;
-            elem->record = tgt_record;
-            elem->src = tgt;
-            elem->id = idr->id;
-#ifndef NDEBUG
-            elem->table = tgt_table;
-#endif
+            r_column = flecs_type_offset_search(
+                r_column + 1, rel, ids, count, &id_r);
         }
+    }
 
-        /* Skip id if it's masked by a lower table in the tree */
-        if (stack_at != stack_count) {
-            continue;
-        }
+    return -1;
+}
 
-        flecs_emit_forward_and_cache_id(world, er, er_onset, emit_ids, it,
-            table, idr, tgt, tgt_record, tgt_table, tgt_tr, i, 
-                offset, reachable_ids, trav);
-    }
+int32_t flecs_search_relation_w_idr(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    int32_t offset,
+    ecs_id_t id,
+    ecs_entity_t rel,
+    ecs_flags64_t flags,
+    ecs_entity_t *subject_out,
+    ecs_id_t *id_out,
+    struct ecs_table_record_t **tr_out,
+    ecs_id_record_t *idr)
+{
+    if (!table) return -1;
 
-    if (parent_revalidate) {
-        /* If this is not the current cache being updated, but it's marked
-         * as out of date, use intermediate results to populate cache. */
-        int32_t rc_parent_offset = ecs_vec_count(&rc->ids);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
 
-        /* Only add ids that were added for this table */
-        int32_t count = ecs_vec_count(reachable_ids);
-        count -= rc_child_offset;
+    flags = flags ? flags : (EcsSelf|EcsUp);
 
-        /* Append ids to any ids that already were added /*/
-        if (count) {
-            ecs_vec_grow_t(a, &rc->ids, ecs_reachable_elem_t, count);
-            ecs_reachable_elem_t *dst = ecs_vec_get_t(&rc->ids, 
-                ecs_reachable_elem_t, rc_parent_offset);
-            ecs_reachable_elem_t *src = ecs_vec_get_t(reachable_ids,
-                ecs_reachable_elem_t, rc_child_offset);
-            ecs_os_memcpy_n(dst, src, ecs_reachable_elem_t, count);
+    if (!idr) {
+        idr = flecs_id_record_get(world, id);
+        if (!idr) {
+            return -1;
         }
+    }
 
-        rc->current = rc->generation;
-
-        if (ecs_should_log_3()) {
-            char *idstr = ecs_id_str(world, tgt_idr->id);
-            ecs_dbg_3("cache revalidated for %s:", idstr);
-            ecs_os_free(idstr);
-            flecs_emit_dump_cache(world, &rc->ids);
+    if (subject_out) subject_out[0] = 0;
+    if (!(flags & EcsUp)) {
+        if (offset) {
+            return ecs_search_offset(world, table, offset, id, id_out);
+        } else {
+            return flecs_type_search(
+                table, idr, table->type.array, id_out, tr_out);
         }
     }
 
-    ecs_log_pop_3();
+    int32_t result = flecs_type_search_relation(world, table, offset, id, idr, 
+        ecs_pair(rel, EcsWildcard), NULL, flags & EcsSelf, subject_out, 
+            id_out, tr_out);
+
+    return result;
 }
 
-static
-void flecs_emit_forward_up(
-    ecs_world_t *world,
-    const ecs_event_record_t *er,
-    const ecs_event_record_t *er_onset,
-    const ecs_type_t *emit_ids,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_id_record_t *idr,
-    ecs_vec_t *stack,
-    ecs_vec_t *reachable_ids)
+int32_t ecs_search_relation(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    int32_t offset,
+    ecs_id_t id,
+    ecs_entity_t rel,
+    ecs_flags64_t flags,
+    ecs_entity_t *subject_out,
+    ecs_id_t *id_out,
+    struct ecs_table_record_t **tr_out)
 {
-    ecs_id_t id = idr->id;
-    ecs_entity_t tgt = ECS_PAIR_SECOND(id);
-    tgt = flecs_entities_get_alive(world, tgt);
-    ecs_assert(tgt != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_record_t *tgt_record = flecs_entities_try(world, tgt);
-    ecs_table_t *tgt_table;
-    if (!tgt_record || !(tgt_table = tgt_record->table)) {
-        return;
-    }
+    if (!table) return -1;
 
-    flecs_emit_forward_table_up(world, er, er_onset, emit_ids, it, table, 
-        tgt, tgt_table, tgt_record, idr, stack, reachable_ids);
-}
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
 
-static
-void flecs_emit_forward(
-    ecs_world_t *world,
-    const ecs_event_record_t *er,
-    const ecs_event_record_t *er_onset,
-    const ecs_type_t *emit_ids,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_id_record_t *idr)
-{
-    ecs_reachable_cache_t *rc = &idr->reachable;
-
-    if (rc->current != rc->generation) {
-        /* Cache miss, iterate the tree to find ids to forward */
-        if (ecs_should_log_3()) {
-            char *idstr = ecs_id_str(world, idr->id);
-            ecs_dbg_3("reachable cache miss for %s", idstr);
-            ecs_os_free(idstr);
-        }
-        ecs_log_push_3();
+    flags = flags ? flags : (EcsSelf|EcsUp);
 
-        ecs_vec_t stack;
-        ecs_vec_init_t(&world->allocator, &stack, ecs_table_t*, 0);
-        ecs_vec_reset_t(&world->allocator, &rc->ids, ecs_reachable_elem_t);
-        flecs_emit_forward_up(world, er, er_onset, emit_ids, it, table, 
-            idr, &stack, &rc->ids);
-        it->sources[0] = 0;
-        ecs_vec_fini_t(&world->allocator, &stack, ecs_table_t*);
+    if (subject_out) subject_out[0] = 0;
+    if (!(flags & EcsUp)) {
+        return ecs_search_offset(world, table, offset, id, id_out);
+    }
 
-        if (it->event == EcsOnAdd || it->event == EcsOnRemove) {
-            /* Only OnAdd/OnRemove events can validate top-level cache, which
-             * is for the id for which the event is emitted. 
-             * The reason for this is that we don't want to validate the cache
-             * while the administration for the mutated entity isn't up to 
-             * date yet. */
-            rc->current = rc->generation;
-        }
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return -1;
+    }
 
-        if (ecs_should_log_3()) {
-            ecs_dbg_3("cache after rebuild:");
-            flecs_emit_dump_cache(world, &rc->ids);
-        }
+    int32_t result = flecs_type_search_relation(world, table, offset, id, idr, 
+        ecs_pair(rel, EcsWildcard), NULL, flags & EcsSelf, subject_out, 
+            id_out, tr_out);
 
-        ecs_log_pop_3();
-    } else {
-        /* Cache hit, use cached values instead of walking the tree */
-        if (ecs_should_log_3()) {
-            char *idstr = ecs_id_str(world, idr->id);
-            ecs_dbg_3("reachable cache hit for %s", idstr);
-            ecs_os_free(idstr);
-            flecs_emit_dump_cache(world, &rc->ids);
-        }
+    return result;
+}
 
-        ecs_entity_t trav = ECS_PAIR_FIRST(idr->id);
-        ecs_reachable_elem_t *elems = ecs_vec_first_t(&rc->ids, 
-            ecs_reachable_elem_t);
-        int32_t i, count = ecs_vec_count(&rc->ids);
-        for (i = 0; i < count; i ++) {
-            ecs_reachable_elem_t *elem = &elems[i];
-            const ecs_table_record_t *tr = elem->tr;
-            ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_id_record_t *rc_idr = (ecs_id_record_t*)tr->hdr.cache;
-            ecs_record_t *r = elem->record;
+int32_t flecs_search_w_idr(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    ecs_id_t *id_out,
+    ecs_id_record_t *idr)
+{
+    if (!table) return -1;
 
-            ecs_assert(rc_idr->id == elem->id, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(flecs_entities_get(world, elem->src) == r,
-                ECS_INTERNAL_ERROR, NULL);
-            ecs_dbg_assert(r->table == elem->table, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    (void)world;
 
-            int32_t offset = ECS_RECORD_TO_ROW(r->row);
-            flecs_emit_forward_id(world, er, er_onset, emit_ids, it, table,
-                rc_idr, elem->src, r->table, tr->index, offset, trav);
-        }
-    }
+    ecs_type_t type = table->type;
+    ecs_id_t *ids = type.array;
+    return flecs_type_search(table, idr, ids, id_out, 0);
+}
 
-    /* Propagate events for new reachable ids downwards */
-    if (table->_->traversable_count) {
-        int32_t i;
-        ecs_entity_t *entities = flecs_table_entities_array(table);
-        entities = ECS_ELEM_T(entities, ecs_entity_t, it->offset);
-        for (i = 0; i < it->count; i ++) {
-            ecs_record_t *r = flecs_entities_get(world, entities[i]);
-            if (r->idr) {
-                break;
-            }
-        }
+int32_t ecs_search(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    ecs_id_t id,
+    ecs_id_t *id_out)
+{
+    if (!table) return -1;
 
-        if (i != it->count) {
-            ecs_reachable_elem_t *elems = ecs_vec_first_t(&rc->ids, 
-                ecs_reachable_elem_t);
-            int32_t count = ecs_vec_count(&rc->ids);
-            for (i = 0; i < count; i ++) {
-                ecs_reachable_elem_t *elem = &elems[i];
-                const ecs_table_record_t *tr = elem->tr;
-                ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-                ecs_id_record_t *rc_idr = (ecs_id_record_t*)tr->hdr.cache;
-                ecs_record_t *r = elem->record;
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
 
-                ecs_assert(rc_idr->id == elem->id, ECS_INTERNAL_ERROR, NULL);
-                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-                ecs_assert(flecs_entities_get(world, elem->src) == r,
-                    ECS_INTERNAL_ERROR, NULL);
-                ecs_dbg_assert(r->table == elem->table, ECS_INTERNAL_ERROR, NULL);
-                (void)r;
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return -1;
+    }
 
-                ecs_event_id_record_t *iders[5] = {0};
-                int32_t ider_count = flecs_event_observers_get(
-                    er, rc_idr->id, iders);
+    ecs_type_t type = table->type;
+    ecs_id_t *ids = type.array;
+    return flecs_type_search(table, idr, ids, id_out, 0);
+}
 
-                flecs_propagate_entities(world, it, rc_idr, it->entities, 
-                    it->count, elem->src, iders, ider_count);
-            }
-        }
+int32_t ecs_search_offset(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    int32_t offset,
+    ecs_id_t id,
+    ecs_id_t *id_out)
+{
+    if (!offset) {
+        flecs_poly_assert(world, ecs_world_t);
+        return ecs_search(world, table, id, id_out);
     }
+
+    if (!table) return -1;
+
+    ecs_type_t type = table->type;
+    ecs_id_t *ids = type.array;
+    int32_t count = type.count;
+    return flecs_type_offset_search(offset, id, ids, count, id_out);
 }
 
-/* The emit function is responsible for finding and invoking the observers 
- * matching the emitted event. The function is also capable of forwarding events
- * for newly reachable ids (after adding a relationship) and propagating events
- * downwards. Both capabilities are not just useful in application logic, but
- * are also an important building block for keeping query caches in sync. */
-void flecs_emit(
-    ecs_world_t *world,
-    ecs_world_t *stage,
-    ecs_event_desc_t *desc)
+static
+int32_t flecs_relation_depth_walk(
+    const ecs_world_t *world,
+    const ecs_id_record_t *idr,
+    const ecs_table_t *first,
+    const ecs_table_t *table)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->event != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->event != EcsWildcard, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->ids != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->ids->count != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->table != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->observable != NULL, ECS_INVALID_PARAMETER, NULL);
+    int32_t result = 0;
 
-    ecs_time_t t = {0};
-    bool measure_time = world->flags & EcsWorldMeasureSystemTime;
-    if (measure_time) {
-        ecs_time_measure(&t);
+    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+    if (!tr) {
+        return 0;
     }
 
-    const ecs_type_t *ids = desc->ids;
-    ecs_entity_t event = desc->event;
-    ecs_table_t *table = desc->table, *other_table = desc->other_table;
-    int32_t offset = desc->offset;
-    int32_t i, count = desc->count;
-    ecs_flags32_t table_flags = table->flags;
+    int32_t i = tr->index, end = i + tr->count;
+    for (; i != end; i ++) {
+        ecs_entity_t o = ecs_pair_second(world, table->type.array[i]);
+        ecs_assert(o != 0, ECS_INTERNAL_ERROR, NULL);
 
-    /* Deferring cannot be suspended for observers */
-    int32_t defer = world->stages[0].defer;
-    if (defer < 0) {
-        world->stages[0].defer *= -1;
+        ecs_table_t *ot = ecs_get_table(world, o);
+        if (!ot) {
+            continue;
+        }
+        
+        ecs_assert(ot != first, ECS_CYCLE_DETECTED, NULL);
+        int32_t cur = flecs_relation_depth_walk(world, idr, first, ot);
+        if (cur > result) {
+            result = cur;
+        }
     }
+    
+    return result + 1;
+}
 
-    /* Table events are emitted for internal table operations only, and do not
-     * provide component data and/or entity ids. */
-    bool table_event = desc->flags & EcsEventTableOnly;
-    if (!count && !table_event) {
-        /* If no count is provided, forward event for all entities in table */
-        count = ecs_table_count(table) - offset;
+int32_t flecs_relation_depth(
+    const ecs_world_t *world,
+    ecs_entity_t r,
+    const ecs_table_t *table)
+{
+    ecs_id_record_t *idr = flecs_id_record_get(world, ecs_pair(r, EcsWildcard));
+    if (!idr) {
+        return 0;
     }
 
-    /* When the NoOnSet flag is provided, no OnSet/UnSet events should be 
-     * generated when new components are inherited. */
-    bool no_on_set = desc->flags & EcsEventNoOnSet;
-
-    /* The world event id is used to determine if an observer has already been
-     * triggered for an event. Observers for multiple components are split up
-     * into multiple observers for a single component, and this counter is used
-     * to make sure a multi observer only triggers once, even if multiple of its
-     * single-component observers trigger. */
-    int32_t evtx = ++world->event_id;
+    return flecs_relation_depth_walk(world, idr, table, table);
+}
 
-    ecs_id_t ids_cache = 0;
-    void *ptrs_cache = NULL;
-    ecs_size_t sizes_cache = 0;
-    int32_t columns_cache = 0;
-    ecs_entity_t sources_cache = 0;
+/**
+ * @file stage.c
+ * @brief Staging implementation.
+ * 
+ * A stage is an object that can be used to temporarily store mutations to a
+ * world while a world is in readonly mode. ECS operations that are invoked on
+ * a stage are stored in a command buffer, which is flushed during sync points,
+ * or manually by the user.
+ * 
+ * Stages contain additional state to enable other API functionality without
+ * having to mutate the world, such as setting the current scope, and allocators
+ * that are local to a stage.
+ * 
+ * In a multi threaded application, each thread has its own stage which allows
+ * threads to insert mutations without having to lock administration.
+ */
 
-    ecs_iter_t it = {
-        .world = stage,
-        .real_world = world,
-        .event = event,
-        .event_cur = evtx,
-        .table = table,
-        .field_count = 1,
-        .ids = &ids_cache,
-        .ptrs = &ptrs_cache,
-        .sizes = &sizes_cache,
-        .columns = &columns_cache,
-        .sources = &sources_cache,
-        .other_table = other_table,
-        .offset = offset,
-        .count = count,
-        .param = ECS_CONST_CAST(void*, desc->param),
-        .flags = desc->flags | EcsIterIsValid
-    };
 
-    ecs_observable_t *observable = ecs_get_observable(desc->observable);
-    ecs_check(observable != NULL, ECS_INVALID_PARAMETER, NULL);
+static
+ecs_cmd_t* flecs_cmd_new(
+    ecs_stage_t *stage)
+{
+    ecs_cmd_t *cmd = ecs_vec_append_t(&stage->allocator, &stage->cmd->queue, 
+        ecs_cmd_t);
+    cmd->is._1.value = NULL;
+    cmd->next_for_entity = 0;
+    cmd->entry = NULL;
+    cmd->system = stage->system;
+    return cmd;
+}
 
-    /* Event records contain all observers for a specific event. In addition to
-     * the emitted event, also request data for the Wildcard event (for 
-     * observers subscribing to the wildcard event), OnSet and UnSet events. The
-     * latter to are used for automatically emitting OnSet/UnSet events for 
-     * inherited components, for example when an IsA relationship is added to an
-     * entity. This doesn't add much overhead, as fetching records is cheap for
-     * builtin event types. */
-    const ecs_event_record_t *er = flecs_event_record_get_if(observable, event);
-    const ecs_event_record_t *wcer = flecs_event_record_get_if(observable, EcsWildcard);
-    const ecs_event_record_t *er_onset = flecs_event_record_get_if(observable, EcsOnSet);
-    const ecs_event_record_t *er_unset = flecs_event_record_get_if(observable, EcsUnSet);
+static
+ecs_cmd_t* flecs_cmd_new_batched(
+    ecs_stage_t *stage, 
+    ecs_entity_t e)
+{
+    ecs_vec_t *cmds = &stage->cmd->queue;
+    ecs_cmd_entry_t *entry = flecs_sparse_get_any_t(
+        &stage->cmd->entries, ecs_cmd_entry_t, e);
 
-    ecs_data_t *storage = NULL;
-    ecs_column_t *columns = NULL;
-    if (count) {
-        storage = &table->data;
-        columns = storage->columns;
-        it.entities = ecs_vec_get_t(&storage->entities, ecs_entity_t, offset);
+    int32_t cur = ecs_vec_count(cmds);
+    ecs_cmd_t *cmd = flecs_cmd_new(stage);
+    if (entry) {
+        if (entry->first == -1) {
+            /* Existing but invalidated entry */
+            entry->first = cur;
+            cmd->entry = entry;
+        } else {
+            int32_t last = entry->last;
+            ecs_cmd_t *arr = ecs_vec_first_t(cmds, ecs_cmd_t);
+            ecs_assert(arr[last].entity == e, ECS_INTERNAL_ERROR, NULL);
+            ecs_cmd_t *last_op = &arr[last];
+            last_op->next_for_entity = cur;
+            if (last == entry->first) {
+                /* Flip sign bit so flush logic can tell which command
+                 * is the first for an entity */
+                last_op->next_for_entity *= -1;
+            }
+        }
+    } else {
+        cmd->entry = entry = flecs_sparse_ensure_fast_t(
+            &stage->cmd->entries, ecs_cmd_entry_t, e);
+        entry->first = cur;
     }
 
-    int32_t id_count = ids->count;
-    ecs_id_t *id_array = ids->array;
+    entry->last = cur;
 
-    /* If a table has IsA relationships, OnAdd/OnRemove events can trigger 
-     * (un)overriding a component. When a component is overridden its value is
-     * initialized with the value of the overridden component. */
-    bool can_override = count && (table_flags & EcsTableHasIsA) && (
-        (event == EcsOnAdd) || (event == EcsOnRemove));
+    return cmd;
+}
 
-    /* When a new (traversable) relationship is added (emitting an OnAdd/OnRemove
-     * event) this will cause the components of the target entity to be 
-     * propagated to the source entity. This makes it possible for observers to
-     * get notified of any new reachable components though the relationship. */
-    bool can_forward = event != EcsOnSet;
+static
+void flecs_stage_merge(
+    ecs_world_t *world)
+{
+    bool is_stage = flecs_poly_is(world, ecs_stage_t);
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
 
-    /* Does table has observed entities */
-    bool has_observed = table_flags & EcsTableHasTraversable;
+    bool measure_frame_time = ECS_BIT_IS_SET(world->flags, 
+        EcsWorldMeasureFrameTime);
 
-    /* When a relationship is removed, the events reachable through that 
-     * relationship should emit UnSet events. This is part of the behavior that
-     * allows observers to be agnostic of whether a component is inherited. */
-    bool can_unset = count && (event == EcsOnRemove) && !no_on_set;
+    ecs_time_t t_start = {0};
+    if (measure_frame_time) {
+        ecs_os_get_time(&t_start);
+    }
 
-    ecs_event_id_record_t *iders[5] = {0};
-    int32_t unset_count = 0;
+    ecs_dbg_3("#[magenta]merge");
+    ecs_log_push_3();
 
-    if (count && can_forward && has_observed) {
-        flecs_emit_propagate_invalidate(world, table, offset, count);
+    if (is_stage) {
+        /* Check for consistency if force_merge is enabled. In practice this
+         * function will never get called with force_merge disabled for just
+         * a single stage. */
+        ecs_assert(stage->defer == 1, ECS_INVALID_OPERATION, 
+            "mismatching defer_begin/defer_end detected");
+        flecs_defer_end(world, stage);
+    } else {
+        /* Merge stages. Only merge if the stage has auto_merging turned on, or 
+         * if this is a forced merge (like when ecs_merge is called) */
+        int32_t i, count = ecs_get_stage_count(world);
+        for (i = 0; i < count; i ++) {
+            ecs_stage_t *s = (ecs_stage_t*)ecs_get_stage(world, i);
+            flecs_poly_assert(s, ecs_stage_t);
+            flecs_defer_end(world, s);
+        }
     }
 
-repeat_event:
-    /* This is the core event logic, which is executed for each event. By 
-     * default this is just the event kind from the ecs_event_desc_t struct, but
-     * can also include the Wildcard and UnSet events. The latter is emitted as
-     * counterpart to OnSet, for any removed ids associated with data. */
-    for (i = 0; i < id_count; i ++) {
-        /* Emit event for each id passed to the function. In most cases this 
-         * will just be one id, like a component that was added, removed or set.
-         * In some cases events are emitted for multiple ids.
-         * 
-         * One example is when an id was added with a "With" property, or 
-         * inheriting from a prefab with overrides. In these cases an entity is 
-         * moved directly to the archetype with the additional components. */
-        ecs_id_record_t *idr = NULL;
-        const ecs_type_info_t *ti = NULL;
-        ecs_id_t id = id_array[i];
-        int32_t ider_i, ider_count = 0;
-        bool is_pair = ECS_IS_PAIR(id);
-        void *override_ptr = NULL;
-        ecs_entity_t base = 0;
-
-        /* Check if this id is a pair of an traversable relationship. If so, we 
-         * may have to forward ids from the pair's target. */
-        if ((can_forward && is_pair) || can_override) {
-            idr = flecs_query_id_record_get(world, id);
-            ecs_flags32_t idr_flags = idr->flags;
+    flecs_eval_component_monitors(world);
 
-            if (is_pair && (idr_flags & EcsIdTraversable)) {
-                const ecs_event_record_t *er_fwd = NULL;
-                if (ECS_PAIR_FIRST(id) == EcsIsA) {
-                    if (event == EcsOnAdd) {
-                        if (!world->stages[0].base) {
-                            /* Adding an IsA relationship can trigger prefab
-                             * instantiation, which can instantiate prefab 
-                             * hierarchies for the entity to which the 
-                             * relationship was added. */
-                            ecs_entity_t tgt = ECS_PAIR_SECOND(id);
+    if (measure_frame_time) {
+        world->info.merge_time_total += (ecs_ftime_t)ecs_time_measure(&t_start);
+    }
 
-                            /* Setting this value prevents flecs_instantiate 
-                             * from being called recursively, in case prefab
-                             * children also have IsA relationships. */
-                            world->stages[0].base = tgt;
-                            flecs_instantiate(world, tgt, table, offset, count);
-                            world->stages[0].base = 0;
-                        }
+    world->info.merge_count_total ++; 
 
-                        /* Adding an IsA relationship will emit OnSet events for
-                         * any new reachable components. */
-                        er_fwd = er_onset;
-                    } else if (event == EcsOnRemove) {
-                        /* Vice versa for removing an IsA relationship. */
-                        er_fwd = er_unset;
-                    }
-                }
+    /* If stage is unmanaged, deferring is always enabled */
+    if (stage->id == -1) {
+        flecs_defer_begin(world, stage);
+    }
+    
+    ecs_log_pop_3();
+}
 
-                /* Forward events for components from pair target */
-                flecs_emit_forward(world, er, er_fwd, ids, &it, table, idr);
-                ecs_assert(it.event_cur == evtx, ECS_INTERNAL_ERROR, NULL);
-            }
+bool flecs_defer_begin(
+    ecs_world_t *world,
+    ecs_stage_t *stage)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(stage, ecs_stage_t);
+    (void)world;
+    if (stage->defer < 0) return false;
+    return (++ stage->defer) == 1;
+}
 
-            if (can_override && (!(idr_flags & EcsIdDontInherit))) {
-                /* Initialize overridden components with value from base */
-                ti = idr->type_info;
-                if (ti) {
-                    ecs_table_record_t *base_tr = NULL;
-                    int32_t base_column = ecs_search_relation(world, table, 
-                        0, id, EcsIsA, EcsUp, &base, NULL, &base_tr);
-                    if (base_column != -1) {
-                        /* Base found with component */
-                        ecs_table_t *base_table = base_tr->hdr.table;
-                        base_column = base_tr->column;
-                        ecs_assert(base_column != -1, ECS_INTERNAL_ERROR, NULL);
-                        ecs_record_t *base_r = flecs_entities_get(world, base);
-                        ecs_assert(base_r != NULL, ECS_INTERNAL_ERROR, NULL);
-                        int32_t base_row = ECS_RECORD_TO_ROW(base_r->row);
-                        ecs_vec_t *base_v = &base_table->data.columns[base_column].data;
-                        override_ptr = ecs_vec_get(base_v, ti->size, base_row);
-                    }
-                }
-            }
-        }
+bool flecs_defer_cmd(
+    ecs_stage_t *stage)
+{
+    if (stage->defer) {
+        return (stage->defer > 0);
+    }
 
-        if (er) {
-            /* Get observer sets for id. There can be multiple sets of matching
-             * observers, in case an observer matches for wildcard ids. For
-             * example, both observers for (ChildOf, p) and (ChildOf, *) would
-             * match an event for (ChildOf, p). */
-            ider_count = flecs_event_observers_get(er, id, iders);
-            idr = idr ? idr : flecs_query_id_record_get(world, id);
-            ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-        }
+    stage->defer ++;
+    return false;
+}
 
-        if (can_unset) {
-            /* Increase UnSet count in case this is a component (has data). This
-             * will cause the event loop to be ran again as UnSet event. */
-            idr = idr ? idr : flecs_query_id_record_get(world, id);
-            ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-            unset_count += (idr->type_info != NULL);
+bool flecs_defer_modified(
+    ecs_stage_t *stage,
+    ecs_entity_t entity,
+    ecs_id_t id)
+{
+    if (flecs_defer_cmd(stage)) {
+        ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity);
+        if (cmd) {
+            cmd->kind = EcsCmdModified;
+            cmd->id = id;
+            cmd->entity = entity;
         }
+        return true;
+    }
+    return false;
+}
 
-        if (!ider_count && !override_ptr) {
-            /* If nothing more to do for this id, early out */
-            continue;
-        }
-
-        ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-        if (tr == NULL) {
-            /* When a single batch contains multiple add's for an exclusive
-             * relationship, it's possible that an id was in the added list
-             * that is no longer available for the entity. */
-            continue;
-        }
-
-        int32_t column = tr->index, storage_i;
-        it.columns[0] = column + 1;
-        it.ptrs[0] = NULL;
-        it.sizes[0] = 0;
-        it.event_id = id;
-        it.ids[0] = id;
-
-        if (count) {
-            storage_i = tr->column;
-            if (storage_i != -1) {
-                /* If this is a component, fetch pointer & size */
-                ecs_assert(idr->type_info != NULL, ECS_INTERNAL_ERROR, NULL);
-                ecs_column_t *c = &columns[storage_i];
-                ecs_size_t size = c->ti->size;
-                void *ptr = ecs_vec_get(&c->data, size, offset);
-                it.sizes[0] = size;
-
-                if (override_ptr) {
-                    if (event == EcsOnAdd) {
-                        /* If this is a new override, initialize the component
-                         * with the value of the overridden component. */
-                        flecs_override_copy(
-                            world, table, ti, ptr, override_ptr, offset, count);
-                    } else if (er_onset) {
-                        /* If an override was removed, this re-exposes the
-                         * overridden component. Because this causes the actual
-                         * (now inherited) value of the component to change, an
-                         * OnSet event must be emitted for the base component.*/
-                        ecs_assert(event == EcsOnRemove, ECS_INTERNAL_ERROR, NULL);
-                        ecs_event_id_record_t *iders_set[5] = {0};
-                        int32_t ider_set_i, ider_set_count = 
-                            flecs_event_observers_get(er_onset, id, iders_set);
-                        if (ider_set_count) {
-                            /* Set the source temporarily to the base and base
-                             * component pointer. */
-                            it.sources[0] = base;
-                            it.ptrs[0] = ptr;
-                            for (ider_set_i = 0; ider_set_i < ider_set_count; ider_set_i ++) {
-                                ecs_event_id_record_t *ider = iders_set[ider_set_i];
-                                flecs_observers_invoke(
-                                    world, &ider->self_up, &it, table, EcsIsA);
-                                ecs_assert(it.event_cur == evtx, 
-                                    ECS_INTERNAL_ERROR, NULL);
-                                flecs_observers_invoke(
-                                    world, &ider->up, &it, table, EcsIsA);
-                                ecs_assert(it.event_cur == evtx, 
-                                    ECS_INTERNAL_ERROR, NULL);
-                            }
-                            it.sources[0] = 0;
-                        }
-                    }
-                }
-
-                it.ptrs[0] = ptr;
-            } else {
-                if (it.event == EcsUnSet) {
-                    /* Only valid for components, not tags */
-                    continue;
-                }
-            }
-        }
-
-        /* Actually invoke observers for this event/id */
-        for (ider_i = 0; ider_i < ider_count; ider_i ++) {
-            ecs_event_id_record_t *ider = iders[ider_i];
-            flecs_observers_invoke(world, &ider->self, &it, table, 0);
-            ecs_assert(it.event_cur == evtx, ECS_INTERNAL_ERROR, NULL);
-            flecs_observers_invoke(world, &ider->self_up, &it, table, 0);
-            ecs_assert(it.event_cur == evtx, ECS_INTERNAL_ERROR, NULL);
-        }
-
-        if (!ider_count || !count || !has_observed) {
-            continue;
-        }
-
-        /* The table->traversable_count value indicates if the table contains any
-         * entities that are used as targets of traversable relationships. If the
-         * entity/entities for which the event was generated is used as such a
-         * target, events must be propagated downwards. */
-        flecs_propagate_entities(
-            world, &it, idr, it.entities, count, 0, iders, ider_count);
-    }
-
-    can_override = false; /* Don't override twice */
-    can_unset = false; /* Don't unset twice */
-    can_forward = false; /* Don't forward twice */
-
-    if (unset_count && er_unset && (er != er_unset)) {
-        /* Repeat event loop for UnSet event */
-        unset_count = 0;
-        er = er_unset;
-        it.event = EcsUnSet;
-        goto repeat_event;
-    }
-
-    if (wcer && er != wcer) {
-        /* Repeat event loop for Wildcard event */
-        er = wcer;
-        it.event = event;
-        goto repeat_event;
-    }
-
-error:
-    world->stages[0].defer = defer;
-
-    if (measure_time) {
-        world->info.emit_time_total += (ecs_ftime_t)ecs_time_measure(&t);
+bool flecs_defer_clone(
+    ecs_stage_t *stage,
+    ecs_entity_t entity,
+    ecs_entity_t src,
+    bool clone_value)
+{   
+    if (flecs_defer_cmd(stage)) {
+        ecs_cmd_t *cmd = flecs_cmd_new(stage);
+        cmd->kind = EcsCmdClone;
+        cmd->id = src;
+        cmd->entity = entity;
+        cmd->is._1.clone_value = clone_value;
+        return true;
     }
-    return;
+    return false;   
 }
 
-void ecs_emit(
-    ecs_world_t *stage,
-    ecs_event_desc_t *desc)
+bool flecs_defer_path(
+    ecs_stage_t *stage,
+    ecs_entity_t parent,
+    ecs_entity_t entity,
+    const char *name)
 {
-    ecs_world_t *world = ECS_CONST_CAST(ecs_world_t*, ecs_get_world(stage));
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(desc->param && desc->const_param), ECS_INVALID_PARAMETER, 
-        "cannot set param and const_param at the same time");
-
-    if (desc->entity) {
-        ecs_assert(desc->table == NULL, ECS_INVALID_PARAMETER, NULL);
-        ecs_assert(desc->offset == 0, ECS_INVALID_PARAMETER, NULL);
-        ecs_assert(desc->count == 0, ECS_INVALID_PARAMETER, NULL);
-        ecs_record_t *r = flecs_entities_get(world, desc->entity);
-        ecs_table_t *table;
-        if (!r || !(table = r->table)) {
-            /* Empty entities can't trigger observers */
-            return;
-        }
-        desc->table = table;
-        desc->offset = ECS_RECORD_TO_ROW(r->row);
-        desc->count = 1;
-    }
-
-    if (!desc->observable) {
-        desc->observable = world;
-    }
-
-    ecs_type_t default_ids = (ecs_type_t){ 
-        .count = 1, 
-        .array = (ecs_id_t[]){ EcsAny }
-    };
-
-    if (!desc->ids || !desc->ids->count) {
-        desc->ids = &default_ids;
-    }
-
-    if (desc->const_param) {
-        desc->param = ECS_CONST_CAST(void*, desc->const_param);
-        desc->const_param = NULL;
+    if (stage->defer > 0) {
+        ecs_cmd_t *cmd = flecs_cmd_new(stage);
+        cmd->kind = EcsCmdPath;
+        cmd->entity = entity;
+        cmd->id = parent;
+        cmd->is._1.value = ecs_os_strdup(name);
+        return true;
     }
+    return false;
+}
 
-    flecs_emit(world, stage, desc);
-
-    if (desc->ids == &default_ids) {
-        desc->ids = NULL;
+bool flecs_defer_delete(
+    ecs_stage_t *stage,
+    ecs_entity_t entity)
+{
+    if (flecs_defer_cmd(stage)) {
+        ecs_cmd_t *cmd = flecs_cmd_new(stage);
+        cmd->kind = EcsCmdDelete;
+        cmd->entity = entity;
+        return true;
     }
-error:
-    return;
+    return false;
 }
 
-void ecs_enqueue(
-    ecs_world_t *world,
-    ecs_event_desc_t *desc)
+bool flecs_defer_clear(
+    ecs_stage_t *stage,
+    ecs_entity_t entity)
 {
-    ecs_check(ecs_is_deferred(world), ECS_INVALID_PARAMETER, 
-        "can't enqueue if not in deferred mode");
-    ecs_stage_t *stage = flecs_stage_from_world(&world);
-
-    flecs_enqueue(world, stage, desc);
-error:
-    return;
+    if (flecs_defer_cmd(stage)) {
+        ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity);
+        cmd->kind = EcsCmdClear;
+        cmd->entity = entity;
+        return true;
+    }
+    return false;
 }
 
-/**
- * @file observer.c
- * @brief Observer implementation.
- * 
- * The observer implementation contains functions for creating, deleting and
- * invoking observers. The code is split up into single-term observers and 
- * multi-term observers. Multi-term observers are created from multiple single-
- * term observers.
- */
-
-#include <stddef.h>
-
-static
-ecs_entity_t flecs_get_observer_event(
-    ecs_term_t *term,
-    ecs_entity_t event)
+bool flecs_defer_on_delete_action(
+    ecs_stage_t *stage,
+    ecs_id_t id,
+    ecs_entity_t action)
 {
-    /* If operator is Not, reverse the event */
-    if (term->oper == EcsNot) {
-        if (event == EcsOnAdd) {
-            event = EcsOnRemove;
-        } else if (event == EcsOnRemove) {
-            event = EcsOnAdd;
-        }
+    if (flecs_defer_cmd(stage)) {
+        ecs_cmd_t *cmd = flecs_cmd_new(stage);
+        cmd->kind = EcsCmdOnDeleteAction;
+        cmd->id = id;
+        cmd->entity = action;
+        return true;
     }
-
-    return event;
+    return false;
 }
 
-static
-ecs_flags32_t flecs_id_flag_for_event(
-    ecs_entity_t e)
+bool flecs_defer_enable(
+    ecs_stage_t *stage,
+    ecs_entity_t entity,
+    ecs_id_t id,
+    bool enable)
 {
-    if (e == EcsOnAdd) {
-        return EcsIdHasOnAdd;
-    }
-    if (e == EcsOnRemove) {
-        return EcsIdHasOnRemove;
-    }
-    if (e == EcsOnSet) {
-        return EcsIdHasOnSet;
-    }
-    if (e == EcsUnSet) {
-        return EcsIdHasUnSet;
-    }
-    if (e == EcsOnTableFill) {
-        return EcsIdHasOnTableFill;
-    }
-    if (e == EcsOnTableEmpty) {
-        return EcsIdHasOnTableEmpty;
-    }
-    if (e == EcsOnTableCreate) {
-        return EcsIdHasOnTableCreate;
-    }
-    if (e == EcsOnTableDelete) {
-        return EcsIdHasOnTableDelete;
+    if (flecs_defer_cmd(stage)) {
+        ecs_cmd_t *cmd = flecs_cmd_new(stage);
+        cmd->kind = enable ? EcsCmdEnable : EcsCmdDisable;
+        cmd->entity = entity;
+        cmd->id = id;
+        return true;
     }
-    return 0;
+    return false;
 }
 
-static
-void flecs_inc_observer_count(
+bool flecs_defer_bulk_new(
     ecs_world_t *world,
-    ecs_entity_t event,
-    ecs_event_record_t *evt,
+    ecs_stage_t *stage,
+    int32_t count,
     ecs_id_t id,
-    int32_t value)
+    const ecs_entity_t **ids_out)
 {
-    ecs_event_id_record_t *idt = flecs_event_id_record_ensure(world, evt, id);
-    ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL);
-    
-    int32_t result = idt->observer_count += value;
-    if (result == 1) {
-        /* Notify framework that there are observers for the event/id. This 
-         * allows parts of the code to skip event evaluation early */
-        flecs_notify_tables(world, id, &(ecs_table_event_t){
-            .kind = EcsTableTriggersForId,
-            .event = event
-        });
+    if (flecs_defer_cmd(stage)) {
+        ecs_entity_t *ids = ecs_os_malloc(count * ECS_SIZEOF(ecs_entity_t));
 
-        ecs_flags32_t flags = flecs_id_flag_for_event(event);
-        if (flags) {
-            ecs_id_record_t *idr = flecs_id_record_get(world, id);
-            if (idr) {
-                idr->flags |= flags;
-            }
+        /* Use ecs_new_id as this is thread safe */
+        int i;
+        for (i = 0; i < count; i ++) {
+            ids[i] = ecs_new(world);
         }
-    } else if (result == 0) {
-        /* Ditto, but the reverse */
-        flecs_notify_tables(world, id, &(ecs_table_event_t){
-            .kind = EcsTableNoTriggersForId,
-            .event = event
-        });
 
-        ecs_flags32_t flags = flecs_id_flag_for_event(event);
-        if (flags) {
-            ecs_id_record_t *idr = flecs_id_record_get(world, id);
-            if (idr) {
-                idr->flags &= ~flags;
-            }
-        }
+        *ids_out = ids;
 
-        flecs_event_id_record_remove(evt, id);
-        ecs_os_free(idt);
+        /* Store data in op */
+        ecs_cmd_t *cmd = flecs_cmd_new(stage);
+        cmd->kind = EcsCmdBulkNew;
+        cmd->id = id;
+        cmd->is._n.entities = ids;
+        cmd->is._n.count = count;
+        cmd->entity = 0;
+        return true;
     }
+    return false;
 }
 
-static
-ecs_id_t flecs_observer_id(
+bool flecs_defer_add(
+    ecs_stage_t *stage,
+    ecs_entity_t entity,
     ecs_id_t id)
 {
-    if (ECS_IS_PAIR(id)) {
-        if (ECS_PAIR_FIRST(id) == EcsAny) {
-            id = ecs_pair(EcsWildcard, ECS_PAIR_SECOND(id));
-        }
-        if (ECS_PAIR_SECOND(id) == EcsAny) {
-            id = ecs_pair(ECS_PAIR_FIRST(id), EcsWildcard);
-        }
+    if (flecs_defer_cmd(stage)) {
+        ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity);
+        cmd->kind = EcsCmdAdd;
+        cmd->id = id;
+        cmd->entity = entity;
+        return true;
     }
-
-    return id;
+    return false;
 }
 
-static
-void flecs_register_observer_for_id(
-    ecs_world_t *world,
-    ecs_observable_t *observable,
-    ecs_observer_t *observer,
-    size_t offset)
+bool flecs_defer_remove(
+    ecs_stage_t *stage,
+    ecs_entity_t entity,
+    ecs_id_t id)
 {
-    ecs_id_t term_id = flecs_observer_id(observer->register_id);
-    ecs_term_t *term = &observer->filter.terms[0];
-    ecs_entity_t trav = term->src.trav;
-
-    int i;
-    for (i = 0; i < observer->event_count; i ++) {
-        ecs_entity_t event = flecs_get_observer_event(
-            term, observer->events[i]);
-
-        /* Get observers for event */
-        ecs_event_record_t *er = flecs_event_record_ensure(observable, event);
-        ecs_assert(er != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        /* Get observers for (component) id for event */
-        ecs_event_id_record_t *idt = flecs_event_id_record_ensure(
-            world, er, term_id);
-        ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        ecs_map_t *observers = ECS_OFFSET(idt, offset);
-        ecs_map_init_w_params_if(observers, &world->allocators.ptr);
-        ecs_map_insert_ptr(observers, observer->filter.entity, observer);
-
-        flecs_inc_observer_count(world, event, er, term_id, 1);
-        if (trav) {
-            flecs_inc_observer_count(world, event, er, 
-                ecs_pair(trav, EcsWildcard), 1);
-        }
+    if (flecs_defer_cmd(stage)) {
+        ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity); 
+        cmd->kind = EcsCmdRemove;
+        cmd->id = id;
+        cmd->entity = entity;
+        return true;
     }
+    return false;
 }
 
-static
-void flecs_uni_observer_register(
+void* flecs_defer_set(
     ecs_world_t *world,
-    ecs_observable_t *observable,
-    ecs_observer_t *observer)
+    ecs_stage_t *stage,
+    ecs_cmd_kind_t cmd_kind,
+    ecs_entity_t entity,
+    ecs_id_t id,
+    ecs_size_t size,
+    void *value,
+    bool *is_new)
 {
-    ecs_term_t *term = &observer->filter.terms[0];
-    ecs_flags32_t flags = term->src.flags;
+    ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity);
 
-    if ((flags & (EcsSelf|EcsUp)) == (EcsSelf|EcsUp)) {
-        flecs_register_observer_for_id(world, observable, observer,
-            offsetof(ecs_event_id_record_t, self_up));
-    } else if (flags & EcsSelf) {
-        flecs_register_observer_for_id(world, observable, observer,
-            offsetof(ecs_event_id_record_t, self));
-    } else if (flags & EcsUp) {
-        ecs_assert(term->src.trav != 0, ECS_INTERNAL_ERROR, NULL);
-        flecs_register_observer_for_id(world, observable, observer,
-            offsetof(ecs_event_id_record_t, up));
+    /* Find type info for id */
+    const ecs_type_info_t *ti = NULL;
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        /* If idr doesn't exist yet, create it but only if the 
+         * application is not multithreaded. */
+        if (world->flags & EcsWorldMultiThreaded) {
+            ti = ecs_get_type_info(world, id);
+        } else {
+            /* When not in multi threaded mode, it's safe to find or 
+             * create the id record. */
+            idr = flecs_id_record_ensure(world, id);
+            ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+            
+            /* Get type_info from id record. We could have called 
+             * ecs_get_type_info directly, but since this function can be
+             * expensive for pairs, creating the id record ensures we can
+             * find the type_info quickly for subsequent operations. */
+            ti = idr->type_info;
+        }
+    } else {
+        ti = idr->type_info;
     }
-}
 
-static
-void flecs_unregister_observer_for_id(
-    ecs_world_t *world,
-    ecs_observable_t *observable,
-    ecs_observer_t *observer,
-    size_t offset)
-{
-    ecs_id_t term_id = flecs_observer_id(observer->register_id);
-    ecs_term_t *term = &observer->filter.terms[0];
-    ecs_entity_t trav = term->src.trav;
-
-    int i;
-    for (i = 0; i < observer->event_count; i ++) {
-        ecs_entity_t event = flecs_get_observer_event(
-            term, observer->events[i]);
-
-        /* Get observers for event */
-        ecs_event_record_t *er = flecs_event_record_get(observable, event);
-        ecs_assert(er != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        /* Get observers for (component) id */
-        ecs_event_id_record_t *idt = flecs_event_id_record_get(er, term_id);
-        ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL);
+    /* If the id isn't associated with a type, we can't set anything */
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, 
+        "provided component is not a type");
 
-        ecs_map_t *id_observers = ECS_OFFSET(idt, offset);
-        ecs_map_remove(id_observers, observer->filter.entity);
-        if (!ecs_map_count(id_observers)) {
-            ecs_map_fini(id_observers);
-        }
+    /* Make sure the size of the value equals the type size */
+    ecs_assert(!size || size == ti->size, ECS_INVALID_PARAMETER,
+        "mismatching size specified for component in ensure/emplace/set");
+    size = ti->size;
 
-        flecs_inc_observer_count(world, event, er, term_id, -1);
-        if (trav) {
-            flecs_inc_observer_count(world, event, er, 
-                ecs_pair(trav, EcsWildcard), -1);
+    /* Find existing component. Make sure it's owned, so that we won't use the
+     * component of a prefab. */
+    void *existing = NULL;
+    ecs_table_t *table = NULL;
+    if (idr) {
+        /* Entity can only have existing component if id record exists */
+        ecs_record_t *r = flecs_entities_get(world, entity);
+        table = r->table;
+        if (r && table) {
+            const ecs_table_record_t *tr = flecs_id_record_get_table(
+                idr, table);
+            if (tr) {
+                ecs_assert(tr->column != -1, ECS_NOT_A_COMPONENT, NULL);
+                /* Entity has the component */
+                ecs_vec_t *column = &table->data.columns[tr->column].data;
+                existing = ecs_vec_get(column, size, ECS_RECORD_TO_ROW(r->row));
+            }
         }
     }
-}
 
-static
-void flecs_unregister_observer(
-    ecs_world_t *world,
-    ecs_observable_t *observable,
-    ecs_observer_t *observer)
-{
-    ecs_assert(observer != NULL, ECS_INTERNAL_ERROR, NULL);
-    if (!observer->filter.terms) {
-        ecs_assert(observer->filter.term_count == 0, ECS_INTERNAL_ERROR, NULL);
-        return;
-    }
+    /* Get existing value from storage */
+    void *cmd_value = existing;
+    bool emplace = cmd_kind == EcsCmdEmplace;
 
-    ecs_term_t *term = &observer->filter.terms[0];
-    ecs_flags32_t flags = term->src.flags;
+    /* If the component does not yet exist, create a temporary value. This is
+     * necessary so we can store a component value in the deferred command,
+     * without adding the component to the entity which is not allowed in 
+     * deferred mode. */
+    if (!existing) {
+        ecs_stack_t *stack = &stage->cmd->stack;
+        cmd_value = flecs_stack_alloc(stack, size, ti->alignment);
 
-    if ((flags & (EcsSelf|EcsUp)) == (EcsSelf|EcsUp)) {
-        flecs_unregister_observer_for_id(world, observable, observer,
-            offsetof(ecs_event_id_record_t, self_up));
-    } else if (flags & EcsSelf) {
-        flecs_unregister_observer_for_id(world, observable, observer,
-            offsetof(ecs_event_id_record_t, self));
-    } else if (flags & EcsUp) {
-        flecs_unregister_observer_for_id(world, observable, observer,
-            offsetof(ecs_event_id_record_t, up));
-    }
-}
+        /* If the component doesn't yet exist, construct it and move the 
+         * provided value into the component, if provided. Don't construct if
+         * this is an emplace operation, in which case the application is
+         * responsible for constructing. */
+        if (value) {
+            if (emplace) {
+                ecs_move_t move = ti->hooks.move_ctor;
+                if (move) {
+                    move(cmd_value, value, 1, ti);
+                } else {
+                    ecs_os_memcpy(cmd_value, value, size);
+                }
+            } else {
+                ecs_copy_t copy = ti->hooks.copy_ctor;
+                if (copy) {
+                    copy(cmd_value, value, 1, ti);
+                } else {
+                    ecs_os_memcpy(cmd_value, value, size);
+                }
+            }
+        } else if (!emplace) {
+            /* If the command is not an emplace, construct the temp storage */
 
-static
-bool flecs_ignore_observer(
-    ecs_observer_t *observer,
-    ecs_table_t *table,
-    ecs_iter_t *it)
-{
-    ecs_assert(observer != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+            /* Check if entity inherits component */
+            void *base = NULL;
+            if (table && (table->flags & EcsTableHasIsA)) {
+                base = flecs_get_base_component(world, table, id, idr, 0);
+            }
 
-    int32_t *last_event_id = observer->last_event_id;
-    if (last_event_id && last_event_id[0] == it->event_cur) {
-        return true;
+            if (!base) {
+                /* Normal ctor */
+                ecs_xtor_t ctor = ti->hooks.ctor;
+                if (ctor) {
+                    ctor(cmd_value, 1, ti);
+                }
+            } else {
+                /* Override */
+                ecs_copy_t copy = ti->hooks.copy_ctor;
+                if (copy) {
+                    copy(cmd_value, base, 1, ti);
+                } else {
+                    ecs_os_memcpy(cmd_value, base, size);
+                }
+            }
+        }
+    } else if (value) {
+        /* If component exists and value is provided, copy */
+        ecs_copy_t copy = ti->hooks.copy;
+        if (copy) {
+            copy(existing, value, 1, ti);
+        } else {
+            ecs_os_memcpy(existing, value, size);
+        }
     }
 
-    if (observer->flags & (EcsObserverIsDisabled|EcsObserverIsParentDisabled)) {
-        return true;
+    if (!cmd) {
+        /* If cmd is NULL, entity was already deleted. Check if we need to
+         * insert a command into the queue. */
+        if (!ti->hooks.dtor) {
+            /* If temporary memory does not need to be destructed, it'll get 
+             * freed when the stack allocator is reset. This prevents us
+             * from having to insert a command when the entity was 
+             * already deleted. */
+            return cmd_value;
+        }
+        cmd = flecs_cmd_new(stage);
     }
 
-    ecs_flags32_t table_flags = table->flags, filter_flags = observer->filter.flags;
+    if (!existing) {
+        /* If component didn't exist yet, insert command that will create it */
+        cmd->kind = cmd_kind;
+        cmd->id = id;
+        cmd->idr = idr;
+        cmd->entity = entity;
+        cmd->is._1.size = size;
+        cmd->is._1.value = cmd_value;
 
-    bool result = (table_flags & EcsTableIsPrefab) &&
-        !(filter_flags & EcsFilterMatchPrefab);
-    result = result || ((table_flags & EcsTableIsDisabled) &&
-        !(filter_flags & EcsFilterMatchDisabled));
+        if (is_new) {
+            *is_new = true;
+        }
+    } else {
+        /* If component already exists, still insert an Add command to ensure
+         * that any preceding remove commands won't remove the component. If the
+         * operation is a set, also insert a Modified command. */
+        if (cmd_kind == EcsCmdSet) {
+            cmd->kind = EcsCmdAddModified; 
+        } else {
+            cmd->kind = EcsCmdAdd;
+        }
+        cmd->id = id;
+        cmd->entity = entity;
 
-    return result;
-}
+        if (is_new) {
+            *is_new = false;
+        }
+    }
 
-static
-bool flecs_is_simple_result(
-    ecs_iter_t *it)
-{
-    return (it->count == 1) || (it->sizes[0] == 0) || (it->sources[0] == 0);
+    return cmd_value;
+error:
+    return NULL;
 }
 
-static
-void flecs_observer_invoke(
+void flecs_enqueue(
     ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_observer_t *observer,
-    ecs_iter_action_t callback,
-    int32_t term_index,
-    bool simple_result) 
+    ecs_stage_t *stage,
+    ecs_event_desc_t *desc)
 {
-    ecs_assert(it->callback != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_cmd_t *cmd = flecs_cmd_new(stage);
+    cmd->kind = EcsCmdEvent;
+    cmd->entity = desc->entity;
 
-    if (ecs_should_log_3()) {
-        char *path = ecs_get_fullpath(world, it->system);
-        ecs_dbg_3("observer: invoke %s", path);
-        ecs_os_free(path);
+    ecs_stack_t *stack = &stage->cmd->stack;
+    ecs_event_desc_t *desc_cmd = flecs_stack_alloc_t(stack, ecs_event_desc_t);
+    ecs_os_memcpy_t(desc_cmd, desc, ecs_event_desc_t);
+
+    if (desc->ids && desc->ids->count != 0) {
+        ecs_type_t *type_cmd = flecs_stack_alloc_t(stack, ecs_type_t);
+        int32_t id_count = desc->ids->count;
+        type_cmd->count = id_count;
+        type_cmd->array = flecs_stack_alloc_n(stack, ecs_id_t, id_count);
+        ecs_os_memcpy_n(type_cmd->array, desc->ids->array, ecs_id_t, id_count);
+        desc_cmd->ids = type_cmd;
+    } else {
+        desc_cmd->ids = NULL;
     }
 
-    ecs_log_push_3();
+    cmd->is._1.value = desc_cmd;
+    cmd->is._1.size = ECS_SIZEOF(ecs_event_desc_t);
 
-    ecs_entity_t old_system = flecs_stage_set_system(
-        &world->stages[0], observer->filter.entity);
-    world->info.observers_ran_frame ++;
+    if (desc->param || desc->const_param) {
+        ecs_assert(!(desc->const_param && desc->param), ECS_INVALID_PARAMETER, 
+            "cannot set param and const_param at the same time");
 
-    ecs_filter_t *filter = &observer->filter;
-    ecs_assert(term_index < filter->term_count, ECS_INTERNAL_ERROR, NULL);
-    ecs_term_t *term = &filter->terms[term_index];
-    if (term->oper != EcsNot) {
-        ecs_assert((it->offset + it->count) <= ecs_table_count(it->table), 
-            ECS_INTERNAL_ERROR, NULL);
-    }
+        const ecs_type_info_t *ti = ecs_get_type_info(world, desc->event);
+        ecs_assert(ti != NULL, ECS_INVALID_PARAMETER, 
+            "can only enqueue events with data for events that are components");
 
-    bool instanced = filter->flags & EcsFilterIsInstanced;
-    bool match_this = filter->flags & EcsFilterMatchThis;
-    bool table_only = it->flags & EcsIterTableOnly;
-    if (match_this && (simple_result || instanced || table_only)) {
-        callback(it);
-        filter->eval_count ++;
-    } else {
-        ecs_entity_t observer_src = term->src.id;
-        if (observer_src && !(term->src.flags & EcsIsEntity)) {
-            observer_src = 0;
+        void *param_cmd = flecs_stack_alloc(stack, ti->size, ti->alignment);
+        ecs_assert(param_cmd != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (desc->param) {
+            if (ti->hooks.move_ctor) {
+                ti->hooks.move_ctor(param_cmd, desc->param, 1, ti);
+            } else {
+                ecs_os_memcpy(param_cmd, desc->param, ti->size);
+            }
+        } else {
+            if (ti->hooks.copy_ctor) {
+                ti->hooks.copy_ctor(param_cmd, desc->const_param, 1, ti);
+            } else {
+                ecs_os_memcpy(param_cmd, desc->const_param, ti->size);
+            }
         }
 
-        ecs_entity_t *entities = it->entities;
-        int32_t i, count = it->count;
-        ecs_entity_t src = it->sources[0];
-        it->count = 1;
-        for (i = 0; i < count; i ++) {
-            ecs_entity_t e = entities[i];
-            it->entities = &e;
-            if (!observer_src) {
-                callback(it);
-                filter->eval_count ++;
-            } else if (observer_src == e) {
-                ecs_entity_t dummy = 0;
-                it->entities = &dummy;
-                if (!src) {
-                    it->sources[0] = e;
-                }
+        desc_cmd->param = param_cmd;
+        desc_cmd->const_param = NULL;
+    }
+}
 
-                callback(it);
-                filter->eval_count ++;
-                it->sources[0] = src;
-                break;
-            }
-        }
-        it->entities = entities;
-        it->count = count;
+void flecs_stage_merge_post_frame(
+    ecs_world_t *world,
+    ecs_stage_t *stage)
+{
+    /* Execute post frame actions */
+    int32_t i, count = ecs_vec_count(&stage->post_frame_actions);
+    ecs_action_elem_t *elems = ecs_vec_first(&stage->post_frame_actions);
+    for (i = 0; i < count; i ++) {
+        elems[i].action(world, elems[i].ctx);
     }
 
-    flecs_stage_set_system(&world->stages[0], old_system);
+    ecs_vec_clear(&stage->post_frame_actions);
+}
 
-    ecs_log_pop_3();
+static
+void flecs_commands_init(
+    ecs_stage_t *stage,
+    ecs_commands_t *cmd)
+{
+    flecs_stack_init(&cmd->stack);
+    ecs_vec_init_t(&stage->allocator, &cmd->queue, ecs_cmd_t, 0);
+    flecs_sparse_init_t(&cmd->entries, &stage->allocator,
+        &stage->allocators.cmd_entry_chunk, ecs_cmd_entry_t);
 }
 
 static
-void flecs_default_uni_observer_run_callback(ecs_iter_t *it) {
-    ecs_observer_t *o = it->ctx;
-    it->ctx = o->ctx;
-    it->callback = o->callback;
+void flecs_commands_fini(
+    ecs_stage_t *stage,
+    ecs_commands_t *cmd)
+{
+    /* Make sure stage has no unmerged data */
+    ecs_assert(ecs_vec_count(&stage->cmd->queue) == 0, ECS_INTERNAL_ERROR, NULL);
 
-    if (ecs_should_log_3()) {
-        char *path = ecs_get_fullpath(it->world, it->system);
-        ecs_dbg_3("observer %s", path);
-        ecs_os_free(path);
-    }
+    flecs_stack_fini(&cmd->stack);
+    ecs_vec_fini_t(&stage->allocator, &cmd->queue, ecs_cmd_t);
+    flecs_sparse_fini(&cmd->entries);
+}
 
-    ecs_log_push_3();
-    flecs_observer_invoke(it->real_world, it, o, o->callback, 0,
-        flecs_is_simple_result(it));
-    ecs_log_pop_3();
+void flecs_commands_push(
+    ecs_stage_t *stage)
+{
+    int32_t sp = ++ stage->cmd_sp;
+    ecs_assert(sp < ECS_MAX_DEFER_STACK, ECS_INTERNAL_ERROR, NULL);
+    stage->cmd = &stage->cmd_stack[sp];
+}
+
+void flecs_commands_pop(
+    ecs_stage_t *stage)
+{
+    int32_t sp = -- stage->cmd_sp;
+    ecs_assert(sp >= 0, ECS_INTERNAL_ERROR, NULL);
+    stage->cmd = &stage->cmd_stack[sp];
+}
+
+ecs_entity_t flecs_stage_set_system(
+    ecs_stage_t *stage,
+    ecs_entity_t system)
+{
+    ecs_entity_t old = stage->system;
+    stage->system = system;
+    return old;
 }
 
 static
-void flecs_uni_observer_invoke(
-    ecs_world_t *world,
-    ecs_observer_t *observer,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_entity_t trav,
-    bool simple_result)
+ecs_stage_t* flecs_stage_new(
+    ecs_world_t *world)
 {
-    ecs_filter_t *filter = &observer->filter;
-    ecs_term_t *term = &filter->terms[0];
-    if (flecs_ignore_observer(observer, table, it)) {
-        return;
-    }
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_stage_t *stage = ecs_os_calloc(sizeof(ecs_stage_t));
+    flecs_poly_init(stage, ecs_stage_t);
 
-    ecs_assert(trav == 0 || it->sources[0] != 0, ECS_INTERNAL_ERROR, NULL);
-    if (trav && term->src.trav != trav) {
-        return;
-    }
+    stage->world = world;
+    stage->thread_ctx = world;
 
-    bool is_filter = term->inout == EcsInOutNone;
-    ECS_BIT_COND(it->flags, EcsIterNoData, is_filter);
-    it->system = observer->filter.entity;
-    it->ctx = observer->ctx;
-    it->binding_ctx = observer->binding_ctx;
-    it->term_index = observer->term_index;
-    it->query = &observer->filter;
-    it->terms = observer->filter.terms;
+    flecs_stack_init(&stage->allocators.iter_stack);
+    flecs_stack_init(&stage->allocators.deser_stack);
+    flecs_allocator_init(&stage->allocator);
+    flecs_ballocator_init_n(&stage->allocators.cmd_entry_chunk, ecs_cmd_entry_t,
+        FLECS_SPARSE_PAGE_SIZE);
+    flecs_ballocator_init_t(&stage->allocators.query_impl, ecs_query_impl_t);
+    flecs_ballocator_init_t(&stage->allocators.query_cache, ecs_query_cache_t);
 
-    ecs_entity_t event = it->event;
-    int32_t event_cur = it->event_cur;
-    it->event = flecs_get_observer_event(term, event);
+    ecs_allocator_t *a = &stage->allocator;
+    ecs_vec_init_t(a, &stage->post_frame_actions, ecs_action_elem_t, 0);
 
-    if (observer->run) {
-        it->next = flecs_default_observer_next_callback;
-        it->callback = flecs_default_uni_observer_run_callback;
-        it->ctx = observer;
-        observer->run(it);
-    } else {
-        ecs_iter_action_t callback = observer->callback;
-        it->callback = callback;
-        flecs_observer_invoke(world, it, observer, callback, 0, simple_result);
+    int32_t i;
+    for (i = 0; i < ECS_MAX_DEFER_STACK; i ++) {
+        flecs_commands_init(stage, &stage->cmd_stack[i]);
     }
 
-    it->event = event;
-    it->event_cur = event_cur;
+    stage->cmd = &stage->cmd_stack[0];
+    return stage;
 }
 
-void flecs_observers_invoke(
+static
+void flecs_stage_free(
     ecs_world_t *world,
-    ecs_map_t *observers,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    ecs_entity_t trav)
+    ecs_stage_t *stage)
 {
-    if (ecs_map_is_init(observers)) {
-        ecs_table_lock(it->world, table);
+    (void)world;
+    flecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(stage, ecs_stage_t);
 
-        bool simple_result = flecs_is_simple_result(it);
-        ecs_map_iter_t oit = ecs_map_iter(observers);
-        while (ecs_map_next(&oit)) {
-            ecs_observer_t *o = ecs_map_ptr(&oit);
-            ecs_assert(it->table == table, ECS_INTERNAL_ERROR, NULL);
-            flecs_uni_observer_invoke(
-                world, o, it, table, trav, simple_result);
-        }
+    flecs_poly_fini(stage, ecs_stage_t);
 
-        ecs_table_unlock(it->world, table);
+    ecs_allocator_t *a = &stage->allocator;
+    
+    ecs_vec_fini_t(a, &stage->post_frame_actions, ecs_action_elem_t);
+    ecs_vec_fini(NULL, &stage->variables, 0);
+    ecs_vec_fini(NULL, &stage->operations, 0);
+
+    int32_t i;
+    for (i = 0; i < ECS_MAX_DEFER_STACK; i ++) {
+        flecs_commands_fini(stage, &stage->cmd_stack[i]);
     }
+
+    flecs_stack_fini(&stage->allocators.iter_stack);
+    flecs_stack_fini(&stage->allocators.deser_stack);
+    flecs_ballocator_fini(&stage->allocators.cmd_entry_chunk);
+    flecs_ballocator_fini(&stage->allocators.query_impl);
+    flecs_ballocator_fini(&stage->allocators.query_cache);
+    flecs_allocator_fini(&stage->allocator);
+
+    ecs_os_free(stage);
 }
 
-static
-bool flecs_multi_observer_invoke(
-    ecs_iter_t *it) 
+ecs_allocator_t* flecs_stage_get_allocator(
+    ecs_world_t *world)
 {
-    ecs_observer_t *o = it->ctx;
-    ecs_world_t *world = it->real_world;
+    ecs_stage_t *stage = flecs_stage_from_world(
+        ECS_CONST_CAST(ecs_world_t**, &world));
+    return &stage->allocator;
+}
 
-    if (o->last_event_id[0] == it->event_cur) {
-        /* Already handled this event */
-        return false;
-    }
+ecs_stack_t* flecs_stage_get_stack_allocator(
+    ecs_world_t *world)
+{
+    ecs_stage_t *stage = flecs_stage_from_world(
+        ECS_CONST_CAST(ecs_world_t**, &world));
+    return &stage->allocators.iter_stack;
+}
 
-    o->last_event_id[0] = world->event_id;
+ecs_world_t* ecs_stage_new(
+    ecs_world_t *world)
+{
+    ecs_stage_t *stage = flecs_stage_new(world);
+    stage->id = -1;
 
-    ecs_iter_t user_it = *it;
-    user_it.field_count = o->filter.field_count;
-    user_it.query = &o->filter;
-    user_it.terms = o->filter.terms;
-    user_it.flags = 0;
-    ECS_BIT_COND(user_it.flags, EcsIterNoData,    
-        ECS_BIT_IS_SET(o->filter.flags, EcsFilterNoData));
-    user_it.ids = NULL;
-    user_it.columns = NULL;
-    user_it.sources = NULL;
-    user_it.sizes = NULL;
-    user_it.ptrs = NULL;
+    flecs_defer_begin(world, stage);
 
-    flecs_iter_init(it->world, &user_it, flecs_iter_cache_all);
-    user_it.flags |= (it->flags & EcsIterTableOnly);
+    return (ecs_world_t*)stage;
+}
 
-    ecs_table_t *table = it->table;
-    ecs_table_t *prev_table = it->other_table;
-    int32_t pivot_term = it->term_index;
-    ecs_term_t *term = &o->filter.terms[pivot_term];
+void ecs_stage_free(
+    ecs_world_t *world)
+{
+    flecs_poly_assert(world, ecs_stage_t);
+    ecs_stage_t *stage = (ecs_stage_t*)world;
+    ecs_check(stage->id == -1, ECS_INVALID_PARAMETER, 
+        "cannot free stage that's owned by world");
+    flecs_stage_free(stage->world, stage);
+error:
+    return;
+}
 
-    int32_t column = it->columns[0];
-    if (term->oper == EcsNot) {
-        table = it->other_table;
-        prev_table = it->table;
-    }
+void ecs_set_stage_count(
+    ecs_world_t *world,
+    int32_t stage_count)
+{
+    flecs_poly_assert(world, ecs_world_t);
 
-    if (!table) {
-        table = &world->store.root;
-    }
-    if (!prev_table) {
-        prev_table = &world->store.root;
-    }
+    /* World must have at least one default stage */
+    ecs_assert(stage_count >= 1 || (world->flags & EcsWorldFini), 
+        ECS_INTERNAL_ERROR, NULL);
 
-    if (column < 0) {
-        column = -column;
+    const ecs_entity_t *lookup_path = NULL;
+    if (world->stage_count >= 1) {
+        lookup_path = world->stages[0]->lookup_path;
     }
 
-    user_it.columns[0] = 0;
-    user_it.columns[pivot_term] = column;
-    user_it.sources[pivot_term] = it->sources[0];
-    user_it.sizes = o->filter.sizes;
-
-    if (flecs_filter_match_table(world, &o->filter, table, user_it.ids, 
-        user_it.columns, user_it.sources, NULL, NULL, false, pivot_term, 
-        user_it.flags))
-    {
-        /* Monitor observers only invoke when the filter matches for the first
-         * time with an entity */
-        if (o->flags & EcsObserverIsMonitor) {
-            if (flecs_filter_match_table(world, &o->filter, prev_table, 
-                NULL, NULL, NULL, NULL, NULL, true, -1, user_it.flags)) 
-            {
-                goto done;
-            }
+    int32_t i, count = world->stage_count;
+    if (stage_count < count) {
+        for (i = stage_count; i < count; i ++) {
+            /* If stage contains a thread handle, ecs_set_threads was used to
+             * create the stages. ecs_set_threads and ecs_set_stage_count should 
+             * not be mixed. */
+            ecs_stage_t *stage = world->stages[i];
+            flecs_poly_assert(stage, ecs_stage_t);
+            ecs_check(stage->thread == 0, ECS_INVALID_OPERATION, 
+                "cannot mix using set_stage_count and set_threads");
+            flecs_stage_free(world, stage);
         }
+    }
 
-        /* While filter matching needs to be reversed for a Not term, the
-         * component data must be fetched from the table we got notified for.
-         * Repeat the matching process for the non-matching table so we get the
-         * correct column ids and sources, which we need for populate_data */
-        if (term->oper == EcsNot) {
-            flecs_filter_match_table(world, &o->filter, prev_table, user_it.ids, 
-                user_it.columns, user_it.sources, NULL, NULL, false, -1, 
-                user_it.flags | EcsFilterPopulate);
-        }
+    if (stage_count) {
+        world->stages = ecs_os_realloc_n(
+            world->stages, ecs_stage_t*, stage_count);
 
-        flecs_iter_populate_data(world, &user_it, it->table, it->offset, 
-            it->count, user_it.ptrs);
+        for (i = count; i < stage_count; i ++) {
+            ecs_stage_t *stage = world->stages[i] = flecs_stage_new(world);
+            stage->id = i;
 
-        user_it.ptrs[pivot_term] = it->ptrs[0];
-        user_it.ids[pivot_term] = it->event_id;
-        user_it.system = o->filter.entity;
-        user_it.term_index = pivot_term;
-        user_it.ctx = o->ctx;
-        user_it.binding_ctx = o->binding_ctx;
-        user_it.field_count = o->filter.field_count;
-        user_it.callback = o->callback;
+            /* Set thread_ctx to stage, as this stage might be used in a
+             * multithreaded context */
+            stage->thread_ctx = (ecs_world_t*)stage;
+            stage->thread = 0;
+        }
+    } else {
+        /* Set to NULL to prevent double frees */
+        ecs_os_free(world->stages);
+        world->stages = NULL;
+    }
 
-        flecs_iter_validate(&user_it);
-        ecs_table_lock(it->world, table);
-        flecs_observer_invoke(world, &user_it, o, o->callback, 
-            pivot_term, flecs_is_simple_result(&user_it));
-        ecs_table_unlock(it->world, table);
-        ecs_iter_fini(&user_it);
-        return true;
+    /* Regardless of whether the stage was just initialized or not, when the
+     * ecs_set_stage_count function is called, all stages inherit the auto_merge
+     * property from the world */
+    for (i = 0; i < stage_count; i ++) {
+        world->stages[i]->lookup_path = lookup_path;
     }
 
-done:
-    ecs_iter_fini(&user_it);
-    return false;
+    world->stage_count = stage_count;
+error:
+    return;
 }
 
-bool ecs_observer_default_run_action(ecs_iter_t *it) {
-    ecs_observer_t *o = it->ctx;
-    if (o->flags & EcsObserverIsMulti) {
-        return flecs_multi_observer_invoke(it);
-    } else {
-        it->ctx = o->ctx;
-        ecs_table_lock(it->world, it->table);
-        flecs_observer_invoke(it->real_world, it, o, o->callback, 0,
-            flecs_is_simple_result(it));
-        ecs_table_unlock(it->world, it->table);
-        return true;
-    }
+int32_t ecs_get_stage_count(
+    const ecs_world_t *world)
+{
+    world = ecs_get_world(world);
+    return world->stage_count;
 }
 
-static
-void flecs_default_multi_observer_run_callback(
-    ecs_iter_t *it) 
+int32_t ecs_stage_get_id(
+    const ecs_world_t *world)
 {
-    flecs_multi_observer_invoke(it);
-}
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-/* For convenience, so applications can (in theory) use a single run callback 
- * that uses ecs_iter_next to iterate results */
-bool flecs_default_observer_next_callback(ecs_iter_t *it) {
-    if (it->interrupted_by) {
-        return false;
+    if (flecs_poly_is(world, ecs_stage_t)) {
+        ecs_stage_t *stage = ECS_CONST_CAST(ecs_stage_t*, world);
+
+        /* Index 0 is reserved for main stage */
+        return stage->id;
+    } else if (flecs_poly_is(world, ecs_world_t)) {
+        return 0;
     } else {
-        /* Use interrupted_by to signal the next iteration must return false */
-        it->interrupted_by = it->system;
-        return true;
+        ecs_throw(ECS_INTERNAL_ERROR, NULL);
     }
+error:
+    return 0;
 }
 
-/* Run action for children of multi observer */
-static
-void flecs_multi_observer_builtin_run(ecs_iter_t *it) {
-    ecs_observer_t *observer = it->ctx;
-    ecs_run_action_t run = observer->run;
-
-    if (run) {
-        it->next = flecs_default_observer_next_callback;
-        it->callback = flecs_default_multi_observer_run_callback;
-        it->interrupted_by = 0;
-        run(it);
-    } else {
-        flecs_multi_observer_invoke(it);
-    }
+ecs_world_t* ecs_get_stage(
+    const ecs_world_t *world,
+    int32_t stage_id)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(world->stage_count > stage_id, ECS_INVALID_PARAMETER, NULL);
+    return (ecs_world_t*)world->stages[stage_id];
+error:
+    return NULL;
 }
 
-static
-void flecs_uni_observer_yield_existing(
+bool ecs_readonly_begin(
     ecs_world_t *world,
-    ecs_observer_t *observer)
+    bool multi_threaded)
 {
-    ecs_iter_action_t callback = observer->callback;
-
-    ecs_defer_begin(world);
+    flecs_poly_assert(world, ecs_world_t);
 
-    /* If yield existing is enabled, observer for each thing that matches
-     * the event, if the event is iterable. */
-    int i, count = observer->event_count;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t evt = observer->events[i];
-        const EcsIterable *iterable = ecs_get(world, evt, EcsIterable);
-        if (!iterable) {
-            continue;
-        }
+    flecs_process_pending_tables(world);
 
-        ecs_iter_t it;
-        iterable->init(world, &observer->filter, &it, NULL);
-        it.system = observer->filter.entity;
-        it.ctx = observer->ctx;
-        it.binding_ctx = observer->binding_ctx;
-        it.event = evt;
+    ecs_dbg_3("#[bold]readonly");
+    ecs_log_push_3();
 
-        ecs_iter_next_action_t next = it.next;
-        ecs_assert(next != NULL, ECS_INTERNAL_ERROR, NULL);
-        while (next(&it)) {
-            it.event_id = it.ids[0];
-            it.event_cur = ++ world->event_id;
-            callback(&it);
-        }
+    int32_t i, count = ecs_get_stage_count(world);
+    for (i = 0; i < count; i ++) {
+        ecs_stage_t *stage = world->stages[i];
+        stage->lookup_path = world->stages[0]->lookup_path;
+        ecs_assert(stage->defer == 0, ECS_INVALID_OPERATION, 
+            "deferred mode cannot be enabled when entering readonly mode");
+        flecs_defer_begin(world, stage);
     }
 
-    ecs_defer_end(world);
-}
+    bool is_readonly = ECS_BIT_IS_SET(world->flags, EcsWorldReadonly);
 
-static
-void flecs_multi_observer_yield_existing(
-    ecs_world_t *world,
-    ecs_observer_t *observer)
-{
-    ecs_run_action_t run = observer->run;
-    if (!run) {
-        run = flecs_default_multi_observer_run_callback;
-    }
-
-    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
-
-    ecs_defer_begin(world);
-
-    int32_t pivot_term = ecs_filter_pivot_term(world, &observer->filter);
-    if (pivot_term < 0) {
-        pivot_term = 0; /* Observer has no this terms */
-    }
-
-    /* If yield existing is enabled, invoke for each thing that matches
-     * the event, if the event is iterable. */
-    int i, count = observer->event_count;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t evt = observer->events[i];
-        const EcsIterable *iterable = ecs_get(world, evt, EcsIterable);
-        if (!iterable) {
-            continue;
-        }
-
-        ecs_iter_t it;
-        iterable->init(world, world, &it, &observer->filter.terms[pivot_term]);
-        it.query = &observer->filter;
-        it.terms = observer->filter.terms;
-        it.field_count = 1;
-        it.term_index = pivot_term;
-        it.system = observer->filter.entity;
-        it.ctx = observer;
-        it.binding_ctx = observer->binding_ctx;
-        it.event = evt;
-
-        ecs_iter_next_action_t next = it.next;
-        ecs_assert(next != NULL, ECS_INTERNAL_ERROR, NULL);
-        while (next(&it)) {
-            it.event_id = it.ids[0];
-            it.event_cur = ++ world->event_id;
-            run(&it);
-        }
-    }
+    /* From this point on, the world is "locked" for mutations, and it is only 
+     * allowed to enqueue commands from stages */
+    ECS_BIT_SET(world->flags, EcsWorldReadonly);
+    ECS_BIT_COND(world->flags, EcsWorldMultiThreaded, multi_threaded);
 
-    ecs_defer_end(world);
+    return is_readonly;
 }
 
-static
-int flecs_uni_observer_init(
-    ecs_world_t *world,
-    ecs_observer_t *observer,
-    const ecs_observer_desc_t *desc)
+void ecs_readonly_end(
+    ecs_world_t *world)
 {
-    ecs_term_t *term = &observer->filter.terms[0];
-    observer->last_event_id = desc->last_event_id;    
-    if (!observer->last_event_id) {
-        observer->last_event_id = &observer->last_event_id_storage;
-    }
-    observer->register_id = flecs_from_public_id(world, term->id);
-    term->field_index = desc->term_index;
-
-    if (ecs_id_is_tag(world, term->id)) {
-        /* If id is a tag, downgrade OnSet/UnSet to OnAdd/OnRemove. */
-        int32_t e, count = observer->event_count;
-        bool has_on_add = false;
-        bool has_on_remove = false;
-        for (e = 0; e < count; e ++) {
-            if (observer->events[e] == EcsOnAdd) {
-                has_on_add = true;
-            }
-            if (observer->events[e] == EcsOnRemove) {
-                has_on_remove = true;
-            }
-        }
-
-        for (e = 0; e < count; e ++) {
-            if (observer->events[e] == EcsOnSet) {
-                if (has_on_add) {
-                    /* Already registered */
-                    observer->events[e] = 0;
-                } else {
-                    observer->events[e] = EcsOnAdd;
-                }
-            } else
-            if (observer->events[e] == EcsUnSet) {
-                if (has_on_remove) {
-                    /* Already registered */
-                    observer->events[e] = 0;
-                } else {
-                    observer->events[e] = EcsOnRemove;
-                }
-            }
-        }
-    }
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(world->flags & EcsWorldReadonly, ECS_INVALID_OPERATION,
+        "world is not in readonly mode");
 
-    flecs_uni_observer_register(world, observer->observable, observer);
+    /* After this it is safe again to mutate the world directly */
+    ECS_BIT_CLEAR(world->flags, EcsWorldReadonly);
+    ECS_BIT_CLEAR(world->flags, EcsWorldMultiThreaded);
 
-    if (desc->yield_existing) {
-        flecs_uni_observer_yield_existing(world, observer);
-    }
+    ecs_log_pop_3();
 
-    return 0;
+    flecs_stage_merge(world);
+error:
+    return;
 }
 
-static
-int flecs_multi_observer_init(
-    ecs_world_t *world,
-    ecs_observer_t *observer,
-    const ecs_observer_desc_t *desc)
+void ecs_merge(
+    ecs_world_t *world)
 {
-    /* Create last event id for filtering out the same event that arrives from
-     * more than one term */
-    observer->last_event_id = ecs_os_calloc_t(int32_t);
-    
-    /* Mark observer as multi observer */
-    observer->flags |= EcsObserverIsMulti;
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(flecs_poly_is(world, ecs_world_t) || 
+               flecs_poly_is(world, ecs_stage_t), ECS_INVALID_PARAMETER, NULL);
+    flecs_stage_merge(world);
+error:
+    return;
+}
 
-    /* Create a child observer for each term in the filter */
-    ecs_filter_t *filter = &observer->filter;
-    ecs_observer_desc_t child_desc = *desc;
-    child_desc.last_event_id = observer->last_event_id;
-    child_desc.run = NULL;
-    child_desc.callback = flecs_multi_observer_builtin_run;
-    child_desc.ctx = observer;
-    child_desc.ctx_free = NULL;
-    child_desc.filter.expr = NULL;
-    child_desc.filter.terms_buffer = NULL;
-    child_desc.filter.terms_buffer_count = 0;
-    child_desc.binding_ctx = NULL;
-    child_desc.binding_ctx_free = NULL;
-    child_desc.yield_existing = false;
-    ecs_os_zeromem(&child_desc.entity);
-    ecs_os_zeromem(&child_desc.filter.terms);
-    ecs_os_memcpy_n(child_desc.events, observer->events, 
-        ecs_entity_t, observer->event_count);
+bool ecs_stage_is_readonly(
+    const ecs_world_t *stage)
+{
+    const ecs_world_t *world = ecs_get_world(stage);
 
-    int i, term_count = filter->term_count;
-    bool optional_only = filter->flags & EcsFilterMatchThis;
-    for (i = 0; i < term_count; i ++) {
-        if (filter->terms[i].oper != EcsOptional) {
-            if (ecs_term_match_this(&filter->terms[i])) {
-                optional_only = false;
-            }
+    if (flecs_poly_is(stage, ecs_stage_t)) {
+        if (((const ecs_stage_t*)stage)->id == -1) {
+            /* Stage is not owned by world, so never readonly */
+            return false;
         }
     }
 
-    if (filter->flags & EcsFilterMatchPrefab) {
-        child_desc.filter.flags |= EcsFilterMatchPrefab;
-    }
-    if (filter->flags & EcsFilterMatchDisabled) {
-        child_desc.filter.flags |= EcsFilterMatchDisabled;
-    }
-
-    /* Create observers as children of observer */
-    ecs_entity_t old_scope = ecs_set_scope(world, observer->filter.entity);
-
-    for (i = 0; i < term_count; i ++) {
-        if (filter->terms[i].src.flags & EcsFilter) {
-            continue;
+    if (world->flags & EcsWorldReadonly) {
+        if (flecs_poly_is(stage, ecs_world_t)) {
+            return true;
         }
+    } else {
+        if (flecs_poly_is(stage, ecs_stage_t)) {
+            return true;
+        }
+    }
 
-        ecs_term_t *term = &child_desc.filter.terms[0];
-        child_desc.term_index = filter->terms[i].field_index;
-        *term = filter->terms[i];
-
-        ecs_oper_kind_t oper = term->oper;
-        ecs_id_t id = term->id;
-
-        /* AndFrom & OrFrom terms insert multiple observers */
-        if (oper == EcsAndFrom || oper == EcsOrFrom) {
-            const ecs_type_t *type = ecs_get_type(world, id);
-            int32_t ti, ti_count = type->count;
-            ecs_id_t *ti_ids = type->array;
-
-            /* Correct operator will be applied when an event occurs, and
-             * the observer is evaluated on the observer source */
-            term->oper = EcsAnd;
-            for (ti = 0; ti < ti_count; ti ++) {
-                ecs_id_t ti_id = ti_ids[ti];
-                ecs_id_record_t *idr = flecs_id_record_get(world, ti_id);
-                if (idr->flags & EcsIdDontInherit) {
-                    continue;
-                }
+    return false;
+}
 
-                term->first.name = NULL;
-                term->first.id = ti_ids[ti];
-                term->id = ti_ids[ti];
+bool ecs_is_deferred(
+    const ecs_world_t *world)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    const ecs_stage_t *stage = flecs_stage_from_readonly_world(world);
+    return stage->defer > 0;
+error:
+    return false;
+}
 
-                if (ecs_observer_init(world, &child_desc) == 0) {
-                    goto error;
-                }
-            }
-            continue;
-        }
+/**
+ * @file value.c
+ * @brief Utility functions to work with non-trivial pointers of user types.
+ */
 
-        /* Single component observers never use OR */
-        if (oper == EcsOr) {
-            term->oper = EcsAnd;
-        }
 
-        /* If observer only contains optional terms, match everything */
-        if (optional_only) {
-            term->id = EcsAny;
-            term->first.id = EcsAny;
-            term->src.id = EcsThis;
-            term->src.flags = EcsIsVariable;
-            term->second.id = 0;
-        } else if (term->oper == EcsOptional) {
-            continue;
-        }
-        if (ecs_observer_init(world, &child_desc) == 0) {
-            goto error;
-        }
+int ecs_value_init_w_type_info(
+    const ecs_world_t *world,
+    const ecs_type_info_t *ti,
+    void *ptr)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
+    (void)world;
 
-        if (optional_only) {
-            break;
-        }
+    ecs_xtor_t ctor;
+    if ((ctor = ti->hooks.ctor)) {
+        ctor(ptr, 1, ti);
+    } else {
+        ecs_os_memset(ptr, 0, ti->size);
     }
 
-    ecs_set_scope(world, old_scope);
-
-    if (desc->yield_existing) {
-        flecs_multi_observer_yield_existing(world, observer);
-    }
+    return 0;
+error:
+    return -1;
+}
 
-    return 0; 
+int ecs_value_init(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    void *ptr)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
+    return ecs_value_init_w_type_info(world, ti, ptr);
 error:
     return -1;
 }
 
-ecs_entity_t ecs_observer_init(
+void* ecs_value_new_w_type_info(
     ecs_world_t *world,
-    const ecs_observer_desc_t *desc)
+    const ecs_type_info_t *ti)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
+    (void)world;
 
-    ecs_entity_t entity = desc->entity;
-    if (!entity) {
-        entity = ecs_new(world, 0);
+    void *result = flecs_alloc(&world->allocator, ti->size);
+    if (ecs_value_init_w_type_info(world, ti, result) != 0) {
+        flecs_free(&world->allocator, ti->size, result);
+        goto error;
     }
 
-    EcsPoly *poly = ecs_poly_bind(world, entity, ecs_observer_t);
-    if (!poly->poly) {
-        ecs_check(desc->callback != NULL || desc->run != NULL, 
-            ECS_INVALID_OPERATION, NULL);
-
-        ecs_observer_t *observer = ecs_poly_new(ecs_observer_t);
-        ecs_assert(observer != NULL, ECS_INTERNAL_ERROR, NULL);
-        observer->dtor = (ecs_poly_dtor_t)flecs_observer_fini;
-
-        /* Make writeable copy of filter desc so that we can set name. This will
-         * make debugging easier, as any error messages related to creating the
-         * filter will have the name of the observer. */
-        ecs_filter_desc_t filter_desc = desc->filter;
-        filter_desc.entity = entity;
-        ecs_filter_t *filter = filter_desc.storage = &observer->filter;
-        *filter = ECS_FILTER_INIT;
-
-        /* Parse filter */
-        if (ecs_filter_init(world, &filter_desc) == NULL) {
-            flecs_observer_fini(observer);
-            return 0;
-        }
-
-        /* Observer must have at least one term */
-        ecs_check(observer->filter.term_count > 0, ECS_INVALID_PARAMETER, NULL);
-
-        poly->poly = observer;
+    return result;
+error:
+    return NULL;
+}
 
-        ecs_observable_t *observable = desc->observable;
-        if (!observable) {
-            observable = ecs_get_observable(world);
-        }
+void* ecs_value_new(
+    ecs_world_t *world,
+    ecs_entity_t type)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
 
-        observer->run = desc->run;
-        observer->callback = desc->callback;
-        observer->ctx = desc->ctx;
-        observer->binding_ctx = desc->binding_ctx;
-        observer->ctx_free = desc->ctx_free;
-        observer->binding_ctx_free = desc->binding_ctx_free;
-        observer->term_index = desc->term_index;
-        observer->observable = observable;
+    return ecs_value_new_w_type_info(world, ti);
+error:
+    return NULL;
+}
 
-        /* Check if observer is monitor. Monitors are created as multi observers
-         * since they require pre/post checking of the filter to test if the
-         * entity is entering/leaving the monitor. */
-        int i;
-        for (i = 0; i < FLECS_EVENT_DESC_MAX; i ++) {
-            ecs_entity_t event = desc->events[i];
-            if (!event) {
-                break;
-            }
+int ecs_value_fini_w_type_info(
+    const ecs_world_t *world,
+    const ecs_type_info_t *ti,
+    void *ptr)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
+    (void)world;
 
-            if (event == EcsMonitor) {
-                /* Monitor event must be first and last event */
-                ecs_check(i == 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_xtor_t dtor;
+    if ((dtor = ti->hooks.dtor)) {
+        dtor(ptr, 1, ti);
+    }
 
-                observer->events[0] = EcsOnAdd;
-                observer->events[1] = EcsOnRemove;
-                observer->event_count ++;
-                observer->flags |= EcsObserverIsMonitor;
-            } else {
-                observer->events[i] = event;
-            }
+    return 0;
+error:
+    return -1;
+}
 
-            observer->event_count ++;
-        }
+int ecs_value_fini(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    void* ptr)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    (void)world;
+    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
+    return ecs_value_fini_w_type_info(world, ti, ptr);
+error:
+    return -1;
+}
 
-        /* Observer must have at least one event */
-        ecs_check(observer->event_count != 0, ECS_INVALID_PARAMETER, NULL);
+int ecs_value_free(
+    ecs_world_t *world,
+    ecs_entity_t type,
+    void* ptr)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
+    if (ecs_value_fini_w_type_info(world, ti, ptr) != 0) {
+        goto error;
+    }
 
-        bool multi = false;
+    flecs_free(&world->allocator, ti->size, ptr);
 
-        if (filter->term_count == 1 && !desc->last_event_id) {
-            ecs_term_t *term = &filter->terms[0];
-            /* If the filter has a single term but it is a *From operator, we
-             * need to create a multi observer */
-            multi |= (term->oper == EcsAndFrom) || (term->oper == EcsOrFrom);
-            
-            /* An observer with only optional terms is a special case that is
-             * only handled by multi observers */
-            multi |= term->oper == EcsOptional;
-        }
+    return 0;
+error:
+    return -1;
+}
 
-        bool is_monitor = observer->flags & EcsObserverIsMonitor;
-        if (filter->term_count == 1 && !is_monitor && !multi) {
-            if (flecs_uni_observer_init(world, observer, desc)) {
-                goto error;
-            }
-        } else {
-            if (flecs_multi_observer_init(world, observer, desc)) {
-                goto error;
-            }
-        }
+int ecs_value_copy_w_type_info(
+    const ecs_world_t *world,
+    const ecs_type_info_t *ti,
+    void* dst,
+    const void *src)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
+    (void)world;
 
-        if (ecs_get_name(world, entity)) {
-            ecs_trace("#[green]observer#[reset] %s created", 
-                ecs_get_name(world, entity));
-        }
+    ecs_copy_t copy;
+    if ((copy = ti->hooks.copy)) {
+        copy(dst, src, 1, ti);
     } else {
-        ecs_poly_assert(poly->poly, ecs_observer_t);
-        ecs_observer_t *observer = (ecs_observer_t*)poly->poly;
-
-        if (desc->run) {
-            observer->run = desc->run;
-        }
-        if (desc->callback) {
-            observer->callback = desc->callback;
-        }
-
-        if (observer->ctx_free) {
-            if (observer->ctx && observer->ctx != desc->ctx) {
-                observer->ctx_free(observer->ctx);
-            }
-        }
-        if (observer->binding_ctx_free) {
-            if (observer->binding_ctx && observer->binding_ctx != desc->binding_ctx) {
-                observer->binding_ctx_free(observer->binding_ctx);
-            }
-        }
-
-        if (desc->ctx) {
-            observer->ctx = desc->ctx;
-        }
-        if (desc->binding_ctx) {
-            observer->binding_ctx = desc->binding_ctx;
-        }
-        if (desc->ctx_free) {
-            observer->ctx_free = desc->ctx_free;
-        }
-        if (desc->binding_ctx_free) {
-            observer->binding_ctx_free = desc->binding_ctx_free;
-        }
+        ecs_os_memcpy(dst, src, ti->size);
     }
 
-    ecs_poly_modified(world, entity, ecs_observer_t);
-
-    return entity;
-error:
-    ecs_delete(world, entity);
     return 0;
+error:
+    return -1;
 }
 
-void* ecs_observer_get_ctx(
+int ecs_value_copy(
     const ecs_world_t *world,
-    ecs_entity_t observer)
+    ecs_entity_t type,
+    void* dst,
+    const void *src)
 {
-    const EcsPoly *o = ecs_poly_bind_get(world, observer, ecs_observer_t);
-    if (o) {
-        ecs_poly_assert(o->poly, ecs_observer_t);
-        return ((ecs_observer_t*)o->poly)->ctx;
-    } else {
-        return NULL;
-    }     
+    flecs_poly_assert(world, ecs_world_t);
+    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
+    return ecs_value_copy_w_type_info(world, ti, dst, src);
+error:
+    return -1;
 }
 
-void* ecs_observer_get_binding_ctx(
+int ecs_value_move_w_type_info(
     const ecs_world_t *world,
-    ecs_entity_t observer)
+    const ecs_type_info_t *ti,
+    void* dst,
+    void *src)
 {
-    const EcsPoly *o = ecs_poly_bind_get(world, observer, ecs_observer_t);
-    if (o) {
-        ecs_poly_assert(o->poly, ecs_observer_t);
-        return ((ecs_observer_t*)o->poly)->binding_ctx;
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
+    (void)world;
+
+    ecs_move_t move;
+    if ((move = ti->hooks.move)) {
+        move(dst, src, 1, ti);
     } else {
-        return NULL;
-    }      
+        ecs_os_memcpy(dst, src, ti->size);
+    }
+
+    return 0;
+error:
+    return -1;
 }
 
-const ecs_filter_t* ecs_observer_get_filter(
+int ecs_value_move(
     const ecs_world_t *world,
-    ecs_entity_t observer)
+    ecs_entity_t type,
+    void* dst,
+    void *src)
 {
-    const EcsPoly *o = ecs_poly_bind_get(world, observer, ecs_observer_t);
-    if (o) {
-        ecs_poly_assert(o->poly, ecs_observer_t);
-        return &((ecs_observer_t*)o->poly)->filter;
-    } else {
-        return NULL;
-    }   
+    flecs_poly_assert(world, ecs_world_t);
+    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
+    return ecs_value_move_w_type_info(world, ti, dst, src);
+error:
+    return -1;
 }
 
-void flecs_observer_fini(
-    ecs_observer_t *observer)
+int ecs_value_move_ctor_w_type_info(
+    const ecs_world_t *world,
+    const ecs_type_info_t *ti,
+    void* dst,
+    void *src)
 {
-    if (observer->flags & EcsObserverIsMulti) {
-        ecs_os_free(observer->last_event_id);
-    } else {
-        if (observer->filter.term_count) {
-            flecs_unregister_observer(
-                observer->filter.world, observer->observable, observer);
-        } else {
-            /* Observer creation failed while creating filter */
-        }
-    }
-
-    /* Cleanup filters */
-    ecs_filter_fini(&observer->filter);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
+    (void)world;
 
-    /* Cleanup context */
-    if (observer->ctx_free) {
-        observer->ctx_free(observer->ctx);
+    ecs_move_t move;
+    if ((move = ti->hooks.move_ctor)) {
+        move(dst, src, 1, ti);
+    } else {
+        ecs_os_memcpy(dst, src, ti->size);
     }
 
-    if (observer->binding_ctx_free) {
-        observer->binding_ctx_free(observer->binding_ctx);
-    }
+    return 0;
+error:
+    return -1;
+}
 
-    ecs_poly_free(observer, ecs_observer_t);
+int ecs_value_move_ctor(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    void* dst,
+    void *src)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
+    return ecs_value_move_w_type_info(world, ti, dst, src);
+error:
+    return -1;
 }
 
 /**
- * @file os_api.c
- * @brief Operating system abstraction API.
- * 
- * The OS API implements an overridable interface for implementing functions 
- * that are operating system specific, in addition to a number of hooks which
- * allow for customization by the user, like logging.
+ * @file world.c
+ * @brief World-level API.
  */
 
-#include <ctype.h>
-#include <time.h>
-
-void ecs_os_api_impl(ecs_os_api_t *api);
 
-static bool ecs_os_api_initialized = false;
-static bool ecs_os_api_initializing = false;
-static int ecs_os_api_init_count = 0;
+/* Id flags */
+const ecs_id_t ECS_PAIR =                                          (1ull << 63);
+const ecs_id_t ECS_OVERRIDE =                                      (1ull << 62);
+const ecs_id_t ECS_TOGGLE =                                        (1ull << 61);
 
-ecs_os_api_t ecs_os_api = {
-    .flags_ = EcsOsApiHighResolutionTimer | EcsOsApiLogWithColors,
-    .log_level_ = -1 /* Disable tracing by default, but log warnings/errors */
-};
+/** Builtin component ids */
+const ecs_entity_t ecs_id(EcsComponent) =                                   1;
+const ecs_entity_t ecs_id(EcsIdentifier) =                                  2;
+const ecs_entity_t ecs_id(EcsPoly) =                                        3;
 
-int64_t ecs_os_api_malloc_count = 0;
-int64_t ecs_os_api_realloc_count = 0;
-int64_t ecs_os_api_calloc_count = 0;
-int64_t ecs_os_api_free_count = 0;
+/* Poly target components */
+const ecs_entity_t EcsQuery =                                               5;
+const ecs_entity_t EcsObserver =                                            6;
+const ecs_entity_t EcsSystem =                                              7;
 
-void ecs_os_set_api(
-    ecs_os_api_t *os_api)
-{
-    if (!ecs_os_api_initialized) {
-        ecs_os_api = *os_api;
-        ecs_os_api_initialized = true;
-    }
-}
+/* Core scopes & entities */
+const ecs_entity_t EcsWorld =                       FLECS_HI_COMPONENT_ID + 0;
+const ecs_entity_t EcsFlecs =                       FLECS_HI_COMPONENT_ID + 1;
+const ecs_entity_t EcsFlecsCore =                   FLECS_HI_COMPONENT_ID + 2;
+const ecs_entity_t EcsFlecsInternals =              FLECS_HI_COMPONENT_ID + 3;
+const ecs_entity_t EcsModule =                      FLECS_HI_COMPONENT_ID + 4;
+const ecs_entity_t EcsPrivate =                     FLECS_HI_COMPONENT_ID + 5;
+const ecs_entity_t EcsPrefab =                      FLECS_HI_COMPONENT_ID + 6;
+const ecs_entity_t EcsDisabled =                    FLECS_HI_COMPONENT_ID + 7;
+const ecs_entity_t EcsNotQueryable =                FLECS_HI_COMPONENT_ID + 8;
+
+const ecs_entity_t EcsSlotOf =                      FLECS_HI_COMPONENT_ID + 9;
+const ecs_entity_t EcsFlag =                        FLECS_HI_COMPONENT_ID + 10;
+
+/* Marker entities for query encoding */
+const ecs_entity_t EcsWildcard =                    FLECS_HI_COMPONENT_ID + 11;
+const ecs_entity_t EcsAny =                         FLECS_HI_COMPONENT_ID + 12;
+const ecs_entity_t EcsThis =                        FLECS_HI_COMPONENT_ID + 13;
+const ecs_entity_t EcsVariable =                    FLECS_HI_COMPONENT_ID + 14;
+
+/* Traits */
+const ecs_entity_t EcsTransitive =                  FLECS_HI_COMPONENT_ID + 15;
+const ecs_entity_t EcsReflexive =                   FLECS_HI_COMPONENT_ID + 16;
+const ecs_entity_t EcsSymmetric =                   FLECS_HI_COMPONENT_ID + 17;
+const ecs_entity_t EcsFinal =                       FLECS_HI_COMPONENT_ID + 18;
+const ecs_entity_t EcsDontInherit =                 FLECS_HI_COMPONENT_ID + 19;
+const ecs_entity_t EcsAlwaysOverride =              FLECS_HI_COMPONENT_ID + 20;
+const ecs_entity_t EcsPairIsTag =                   FLECS_HI_COMPONENT_ID + 21;
+const ecs_entity_t EcsExclusive =                   FLECS_HI_COMPONENT_ID + 22;
+const ecs_entity_t EcsAcyclic =                     FLECS_HI_COMPONENT_ID + 23;
+const ecs_entity_t EcsTraversable =                 FLECS_HI_COMPONENT_ID + 24;
+const ecs_entity_t EcsWith =                        FLECS_HI_COMPONENT_ID + 25;
+const ecs_entity_t EcsOneOf =                       FLECS_HI_COMPONENT_ID + 26;
+const ecs_entity_t EcsCanToggle =                   FLECS_HI_COMPONENT_ID + 27;
+const ecs_entity_t EcsTrait =                       FLECS_HI_COMPONENT_ID + 28;
+const ecs_entity_t EcsRelationship =                FLECS_HI_COMPONENT_ID + 29;
+const ecs_entity_t EcsTarget =                      FLECS_HI_COMPONENT_ID + 30;
 
-ecs_os_api_t ecs_os_get_api(void) {
-    return ecs_os_api;
-}
 
-void ecs_os_init(void)
-{
-    if (!ecs_os_api_initialized) {
-        ecs_os_set_api_defaults();
-    }
-    
-    if (!(ecs_os_api_init_count ++)) {
-        if (ecs_os_api.init_) {
-            ecs_os_api.init_();
-        }
-    }
-}
+/* Builtin relationships */
+const ecs_entity_t EcsChildOf =                     FLECS_HI_COMPONENT_ID + 31;
+const ecs_entity_t EcsIsA =                         FLECS_HI_COMPONENT_ID + 32;
+const ecs_entity_t EcsDependsOn =                   FLECS_HI_COMPONENT_ID + 33;
 
-void ecs_os_fini(void) {
-    if (!--ecs_os_api_init_count) {
-        if (ecs_os_api.fini_) {
-            ecs_os_api.fini_();
-        }
-    }
-}
+/* Identifier tags */
+const ecs_entity_t EcsName =                        FLECS_HI_COMPONENT_ID + 34;
+const ecs_entity_t EcsSymbol =                      FLECS_HI_COMPONENT_ID + 35;
+const ecs_entity_t EcsAlias =                       FLECS_HI_COMPONENT_ID + 36;
 
-/* Assume every non-glibc Linux target has no execinfo.
-   This mainly fixes musl support, as musl doesn't define any preprocessor macro specifying its presence. */ 
-#if defined(ECS_TARGET_LINUX) && !defined(__GLIBC__)
-#define HAVE_EXECINFO 0
-#elif !defined(ECS_TARGET_WINDOWS) && !defined(ECS_TARGET_EM) && !defined(ECS_TARGET_ANDROID)
-#define HAVE_EXECINFO 1
-#else
-#define HAVE_EXECINFO 0
-#endif
+/* Events */
+const ecs_entity_t EcsOnAdd =                       FLECS_HI_COMPONENT_ID + 37;
+const ecs_entity_t EcsOnRemove =                    FLECS_HI_COMPONENT_ID + 38;
+const ecs_entity_t EcsOnSet =                       FLECS_HI_COMPONENT_ID + 39;
+const ecs_entity_t EcsUnSet =                       FLECS_HI_COMPONENT_ID + 40;
+const ecs_entity_t EcsOnDelete =                    FLECS_HI_COMPONENT_ID + 41;
+const ecs_entity_t EcsOnDeleteTarget =              FLECS_HI_COMPONENT_ID + 42;
+const ecs_entity_t EcsOnTableCreate =               FLECS_HI_COMPONENT_ID + 43;
+const ecs_entity_t EcsOnTableDelete =               FLECS_HI_COMPONENT_ID + 44;
+const ecs_entity_t EcsOnTableEmpty =                FLECS_HI_COMPONENT_ID + 45;
+const ecs_entity_t EcsOnTableFill =                 FLECS_HI_COMPONENT_ID + 46;
 
-#if HAVE_EXECINFO
-#include <execinfo.h>
-#define ECS_BT_BUF_SIZE 100
+/* Timers */
+const ecs_entity_t ecs_id(EcsTickSource) =          FLECS_HI_COMPONENT_ID + 47;
+const ecs_entity_t ecs_id(EcsTimer) =               FLECS_HI_COMPONENT_ID + 48;
+const ecs_entity_t ecs_id(EcsRateFilter) =          FLECS_HI_COMPONENT_ID + 49;
 
-void flecs_dump_backtrace(
-    void *stream) 
-{
-    int nptrs;
-    void *buffer[ECS_BT_BUF_SIZE];
-    char **strings;
+/* Actions */
+const ecs_entity_t EcsRemove =                      FLECS_HI_COMPONENT_ID + 50;
+const ecs_entity_t EcsDelete =                      FLECS_HI_COMPONENT_ID + 51;
+const ecs_entity_t EcsPanic =                       FLECS_HI_COMPONENT_ID + 52;
 
-    nptrs = backtrace(buffer, ECS_BT_BUF_SIZE);
+/* Misc */
+const ecs_entity_t ecs_id(EcsDefaultChildComponent) = FLECS_HI_COMPONENT_ID + 55;
 
-    strings = backtrace_symbols(buffer, nptrs);
-    if (strings == NULL) {
-        return;
-    }
+/* Builtin predicate ids (used by query engine) */
+const ecs_entity_t EcsPredEq =                      FLECS_HI_COMPONENT_ID + 56;
+const ecs_entity_t EcsPredMatch =                   FLECS_HI_COMPONENT_ID + 57;
+const ecs_entity_t EcsPredLookup =                  FLECS_HI_COMPONENT_ID + 58;
+const ecs_entity_t EcsScopeOpen =                   FLECS_HI_COMPONENT_ID + 59;
+const ecs_entity_t EcsScopeClose =                  FLECS_HI_COMPONENT_ID + 60;
 
-    for (int j = 1; j < nptrs; j++) {
-        fprintf(stream, "%s\n", strings[j]);
-    }
+/* Systems */
+const ecs_entity_t EcsMonitor =                     FLECS_HI_COMPONENT_ID + 61;
+const ecs_entity_t EcsEmpty =                       FLECS_HI_COMPONENT_ID + 62;
+const ecs_entity_t ecs_id(EcsPipeline) =            FLECS_HI_COMPONENT_ID + 63;
+const ecs_entity_t EcsOnStart =                     FLECS_HI_COMPONENT_ID + 64;
+const ecs_entity_t EcsPreFrame =                    FLECS_HI_COMPONENT_ID + 65;
+const ecs_entity_t EcsOnLoad =                      FLECS_HI_COMPONENT_ID + 66;
+const ecs_entity_t EcsPostLoad =                    FLECS_HI_COMPONENT_ID + 67;
+const ecs_entity_t EcsPreUpdate =                   FLECS_HI_COMPONENT_ID + 68;
+const ecs_entity_t EcsOnUpdate =                    FLECS_HI_COMPONENT_ID + 69;
+const ecs_entity_t EcsOnValidate =                  FLECS_HI_COMPONENT_ID + 70;
+const ecs_entity_t EcsPostUpdate =                  FLECS_HI_COMPONENT_ID + 71;
+const ecs_entity_t EcsPreStore =                    FLECS_HI_COMPONENT_ID + 72;
+const ecs_entity_t EcsOnStore =                     FLECS_HI_COMPONENT_ID + 73;
+const ecs_entity_t EcsPostFrame =                   FLECS_HI_COMPONENT_ID + 74;
+const ecs_entity_t EcsPhase =                       FLECS_HI_COMPONENT_ID + 75;
 
-    free(strings);
-}
-#else
-void flecs_dump_backtrace(
-    void *stream)
-{ 
-    (void)stream;
-}
+/* Meta primitive components (don't use low ids to save id space) */
+#ifdef FLECS_META
+const ecs_entity_t ecs_id(ecs_bool_t) =             FLECS_HI_COMPONENT_ID + 80;
+const ecs_entity_t ecs_id(ecs_char_t) =             FLECS_HI_COMPONENT_ID + 81;
+const ecs_entity_t ecs_id(ecs_byte_t) =             FLECS_HI_COMPONENT_ID + 82;
+const ecs_entity_t ecs_id(ecs_u8_t) =               FLECS_HI_COMPONENT_ID + 83;
+const ecs_entity_t ecs_id(ecs_u16_t) =              FLECS_HI_COMPONENT_ID + 84;
+const ecs_entity_t ecs_id(ecs_u32_t) =              FLECS_HI_COMPONENT_ID + 85;
+const ecs_entity_t ecs_id(ecs_u64_t) =              FLECS_HI_COMPONENT_ID + 86;
+const ecs_entity_t ecs_id(ecs_uptr_t) =             FLECS_HI_COMPONENT_ID + 87;
+const ecs_entity_t ecs_id(ecs_i8_t) =               FLECS_HI_COMPONENT_ID + 88;
+const ecs_entity_t ecs_id(ecs_i16_t) =              FLECS_HI_COMPONENT_ID + 89;
+const ecs_entity_t ecs_id(ecs_i32_t) =              FLECS_HI_COMPONENT_ID + 90;
+const ecs_entity_t ecs_id(ecs_i64_t) =              FLECS_HI_COMPONENT_ID + 91;
+const ecs_entity_t ecs_id(ecs_iptr_t) =             FLECS_HI_COMPONENT_ID + 92;
+const ecs_entity_t ecs_id(ecs_f32_t) =              FLECS_HI_COMPONENT_ID + 93;
+const ecs_entity_t ecs_id(ecs_f64_t) =              FLECS_HI_COMPONENT_ID + 94;
+const ecs_entity_t ecs_id(ecs_string_t) =           FLECS_HI_COMPONENT_ID + 95;
+const ecs_entity_t ecs_id(ecs_entity_t) =           FLECS_HI_COMPONENT_ID + 96;
+const ecs_entity_t ecs_id(ecs_id_t) =               FLECS_HI_COMPONENT_ID + 97;
+
+/** Meta module component ids */
+const ecs_entity_t ecs_id(EcsType) =                FLECS_HI_COMPONENT_ID + 98;
+const ecs_entity_t ecs_id(EcsTypeSerializer) =      FLECS_HI_COMPONENT_ID + 99;
+const ecs_entity_t ecs_id(EcsPrimitive) =           FLECS_HI_COMPONENT_ID + 100;
+const ecs_entity_t ecs_id(EcsEnum) =                FLECS_HI_COMPONENT_ID + 101;
+const ecs_entity_t ecs_id(EcsBitmask) =             FLECS_HI_COMPONENT_ID + 102;
+const ecs_entity_t ecs_id(EcsMember) =              FLECS_HI_COMPONENT_ID + 103;
+const ecs_entity_t ecs_id(EcsMemberRanges) =        FLECS_HI_COMPONENT_ID + 104;
+const ecs_entity_t ecs_id(EcsStruct) =              FLECS_HI_COMPONENT_ID + 105;
+const ecs_entity_t ecs_id(EcsArray) =               FLECS_HI_COMPONENT_ID + 106;
+const ecs_entity_t ecs_id(EcsVector) =              FLECS_HI_COMPONENT_ID + 107;
+const ecs_entity_t ecs_id(EcsOpaque) =              FLECS_HI_COMPONENT_ID + 108;
+const ecs_entity_t ecs_id(EcsUnit) =                FLECS_HI_COMPONENT_ID + 109;
+const ecs_entity_t ecs_id(EcsUnitPrefix) =          FLECS_HI_COMPONENT_ID + 110;
+const ecs_entity_t EcsConstant =                    FLECS_HI_COMPONENT_ID + 111;
+const ecs_entity_t EcsQuantity =                    FLECS_HI_COMPONENT_ID + 112;
 #endif
-#undef HAVE_EXECINFO_H
 
-static
-void flecs_log_msg(
-    int32_t level,
-    const char *file, 
-    int32_t line,  
-    const char *msg)
-{
-    FILE *stream = ecs_os_api.log_out_;
-    if (!stream) {
-        stream = stdout;
-    }
+/* Doc module components */
+#ifdef FLECS_DOC
+const ecs_entity_t ecs_id(EcsDocDescription) =      FLECS_HI_COMPONENT_ID + 113;
+const ecs_entity_t EcsDocBrief =                    FLECS_HI_COMPONENT_ID + 114;
+const ecs_entity_t EcsDocDetail =                   FLECS_HI_COMPONENT_ID + 115;
+const ecs_entity_t EcsDocLink =                     FLECS_HI_COMPONENT_ID + 116;
+const ecs_entity_t EcsDocColor =                    FLECS_HI_COMPONENT_ID + 117;
+#endif
 
-    bool use_colors = ecs_os_api.flags_ & EcsOsApiLogWithColors;
-    bool timestamp = ecs_os_api.flags_ & EcsOsApiLogWithTimeStamp;
-    bool deltatime = ecs_os_api.flags_ & EcsOsApiLogWithTimeDelta;
+/* REST module components */
+#ifdef FLECS_REST
+const ecs_entity_t ecs_id(EcsRest) =                FLECS_HI_COMPONENT_ID + 118;
+#endif
 
-    time_t now = 0;
+/* Default lookup path */
+static ecs_entity_t ecs_default_lookup_path[2] = { 0, 0 };
 
-    if (deltatime) {
-        now = time(NULL);
-        int64_t delta = 0;
-        if (ecs_os_api.log_last_timestamp_) {
-            delta = now - ecs_os_api.log_last_timestamp_;
-        }
-        ecs_os_api.log_last_timestamp_ = (int64_t)now;
+/* Declarations for addons. Located in world.c to avoid issues during linking of
+ * static library */
 
-        if (delta) {
-            if (delta < 10) {
-                fputs(" ", stream);
-            }
-            if (delta < 100) {
-                fputs(" ", stream);
-            }
-            char time_buf[20];
-            ecs_os_sprintf(time_buf, "%u", (uint32_t)delta);
-            fputs("+", stream);
-            fputs(time_buf, stream);
-            fputs(" ", stream);
-        } else {
-            fputs("     ", stream);
-        }
-    }
+#ifdef FLECS_ALERTS
+ECS_COMPONENT_DECLARE(EcsAlert);
+ECS_COMPONENT_DECLARE(EcsAlertInstance);
+ECS_COMPONENT_DECLARE(EcsAlertsActive);
+ECS_TAG_DECLARE(EcsAlertInfo);
+ECS_TAG_DECLARE(EcsAlertWarning);
+ECS_TAG_DECLARE(EcsAlertError);
+ECS_TAG_DECLARE(EcsAlertCritical);
+#endif
+#ifdef FLECS_UNITS
+ECS_DECLARE(EcsUnitPrefixes);
 
-    if (timestamp) {
-        if (!now) {
-            now = time(NULL);
-        }
-        char time_buf[20];
-        ecs_os_sprintf(time_buf, "%u", (uint32_t)now);
-        fputs(time_buf, stream);
-        fputs(" ", stream);
-    }
+ECS_DECLARE(EcsYocto);
+ECS_DECLARE(EcsZepto);
+ECS_DECLARE(EcsAtto);
+ECS_DECLARE(EcsFemto);
+ECS_DECLARE(EcsPico);
+ECS_DECLARE(EcsNano);
+ECS_DECLARE(EcsMicro);
+ECS_DECLARE(EcsMilli);
+ECS_DECLARE(EcsCenti);
+ECS_DECLARE(EcsDeci);
+ECS_DECLARE(EcsDeca);
+ECS_DECLARE(EcsHecto);
+ECS_DECLARE(EcsKilo);
+ECS_DECLARE(EcsMega);
+ECS_DECLARE(EcsGiga);
+ECS_DECLARE(EcsTera);
+ECS_DECLARE(EcsPeta);
+ECS_DECLARE(EcsExa);
+ECS_DECLARE(EcsZetta);
+ECS_DECLARE(EcsYotta);
 
-    if (level >= 4) {
-        if (use_colors) fputs(ECS_NORMAL, stream);
-        fputs("jrnl", stream);
-    } else if (level >= 0) {
-        if (level == 0) {
-            if (use_colors) fputs(ECS_MAGENTA, stream);
-        } else {
-            if (use_colors) fputs(ECS_GREY, stream);
-        }
-        fputs("info", stream);
-    } else if (level == -2) {
-        if (use_colors) fputs(ECS_YELLOW, stream);
-        fputs("warning", stream);
-    } else if (level == -3) {
-        if (use_colors) fputs(ECS_RED, stream);
-        fputs("error", stream);
-    } else if (level == -4) {
-        if (use_colors) fputs(ECS_RED, stream);
-        fputs("fatal", stream);
-    }
+ECS_DECLARE(EcsKibi);
+ECS_DECLARE(EcsMebi);
+ECS_DECLARE(EcsGibi);
+ECS_DECLARE(EcsTebi);
+ECS_DECLARE(EcsPebi);
+ECS_DECLARE(EcsExbi);
+ECS_DECLARE(EcsZebi);
+ECS_DECLARE(EcsYobi);
 
-    if (use_colors) fputs(ECS_NORMAL, stream);
-    fputs(": ", stream);
+ECS_DECLARE(EcsDuration);
+    ECS_DECLARE(EcsPicoSeconds);
+    ECS_DECLARE(EcsNanoSeconds);
+    ECS_DECLARE(EcsMicroSeconds);
+    ECS_DECLARE(EcsMilliSeconds);
+    ECS_DECLARE(EcsSeconds);
+    ECS_DECLARE(EcsMinutes);
+    ECS_DECLARE(EcsHours);
+    ECS_DECLARE(EcsDays);
 
-    if (level >= 0) {
-        if (ecs_os_api.log_indent_) {
-            char indent[32];
-            int i, indent_count = ecs_os_api.log_indent_;
-            if (indent_count > 15) indent_count = 15;
+ECS_DECLARE(EcsTime);
+    ECS_DECLARE(EcsDate);
 
-            for (i = 0; i < indent_count; i ++) {
-                indent[i * 2] = '|';
-                indent[i * 2 + 1] = ' ';
-            }
+ECS_DECLARE(EcsMass);
+    ECS_DECLARE(EcsGrams);
+    ECS_DECLARE(EcsKiloGrams);
 
-            if (ecs_os_api.log_indent_ != indent_count) {
-                indent[i * 2 - 2] = '+';
-            }
+ECS_DECLARE(EcsElectricCurrent);
+    ECS_DECLARE(EcsAmpere);
 
-            indent[i * 2] = '\0';
+ECS_DECLARE(EcsAmount);
+    ECS_DECLARE(EcsMole);
 
-            fputs(indent, stream);
-        }
-    }
+ECS_DECLARE(EcsLuminousIntensity);
+    ECS_DECLARE(EcsCandela);
 
-    if (level < 0) {
-        if (file) {
-            const char *file_ptr = strrchr(file, '/');
-            if (!file_ptr) {
-                file_ptr = strrchr(file, '\\');
-            }
+ECS_DECLARE(EcsForce);
+    ECS_DECLARE(EcsNewton);
 
-            if (file_ptr) {
-                file = file_ptr + 1;
-            }
+ECS_DECLARE(EcsLength);
+    ECS_DECLARE(EcsMeters);
+        ECS_DECLARE(EcsPicoMeters);
+        ECS_DECLARE(EcsNanoMeters);
+        ECS_DECLARE(EcsMicroMeters);
+        ECS_DECLARE(EcsMilliMeters);
+        ECS_DECLARE(EcsCentiMeters);
+        ECS_DECLARE(EcsKiloMeters);
+    ECS_DECLARE(EcsMiles);
+    ECS_DECLARE(EcsPixels);
 
-            fputs(file, stream);
-            fputs(": ", stream);
-        }
+ECS_DECLARE(EcsPressure);
+    ECS_DECLARE(EcsPascal);
+    ECS_DECLARE(EcsBar);
 
-        if (line) {
-            fprintf(stream, "%d: ", line);
-        }
-    }
+ECS_DECLARE(EcsSpeed);
+    ECS_DECLARE(EcsMetersPerSecond);
+    ECS_DECLARE(EcsKiloMetersPerSecond);
+    ECS_DECLARE(EcsKiloMetersPerHour);
+    ECS_DECLARE(EcsMilesPerHour);
 
-    fputs(msg, stream);
+ECS_DECLARE(EcsAcceleration);
 
-    fputs("\n", stream);
+ECS_DECLARE(EcsTemperature);
+    ECS_DECLARE(EcsKelvin);
+    ECS_DECLARE(EcsCelsius);
+    ECS_DECLARE(EcsFahrenheit);
 
-    if (level == -4) {
-        flecs_dump_backtrace(stream);
-    }
-}
+ECS_DECLARE(EcsData);
+    ECS_DECLARE(EcsBits);
+        ECS_DECLARE(EcsKiloBits);
+        ECS_DECLARE(EcsMegaBits);
+        ECS_DECLARE(EcsGigaBits);
+    ECS_DECLARE(EcsBytes);
+        ECS_DECLARE(EcsKiloBytes);
+        ECS_DECLARE(EcsMegaBytes);
+        ECS_DECLARE(EcsGigaBytes);
+        ECS_DECLARE(EcsKibiBytes);
+        ECS_DECLARE(EcsGibiBytes);
+        ECS_DECLARE(EcsMebiBytes);
 
-void ecs_os_dbg(
-    const char *file, 
-    int32_t line, 
-    const char *msg)
-{
-    if (ecs_os_api.log_) {
-        ecs_os_api.log_(1, file, line, msg);
-    }
-}
+ECS_DECLARE(EcsDataRate);
+    ECS_DECLARE(EcsBitsPerSecond);
+    ECS_DECLARE(EcsKiloBitsPerSecond);
+    ECS_DECLARE(EcsMegaBitsPerSecond);
+    ECS_DECLARE(EcsGigaBitsPerSecond);
+    ECS_DECLARE(EcsBytesPerSecond);
+    ECS_DECLARE(EcsKiloBytesPerSecond);
+    ECS_DECLARE(EcsMegaBytesPerSecond);
+    ECS_DECLARE(EcsGigaBytesPerSecond);
 
-void ecs_os_trace(
-    const char *file, 
-    int32_t line, 
-    const char *msg) 
-{
-    if (ecs_os_api.log_) {
-        ecs_os_api.log_(0, file, line, msg);
-    }
-}
+ECS_DECLARE(EcsPercentage);
 
-void ecs_os_warn(
-    const char *file, 
-    int32_t line, 
-    const char *msg) 
+ECS_DECLARE(EcsAngle);
+    ECS_DECLARE(EcsRadians);
+    ECS_DECLARE(EcsDegrees);
+
+ECS_DECLARE(EcsBel);
+ECS_DECLARE(EcsDeciBel);
+
+ECS_DECLARE(EcsFrequency);
+    ECS_DECLARE(EcsHertz);
+    ECS_DECLARE(EcsKiloHertz);
+    ECS_DECLARE(EcsMegaHertz);
+    ECS_DECLARE(EcsGigaHertz);
+
+ECS_DECLARE(EcsUri);
+    ECS_DECLARE(EcsUriHyperlink);
+    ECS_DECLARE(EcsUriImage);
+    ECS_DECLARE(EcsUriFile);
+#endif
+
+/* -- Private functions -- */
+
+ecs_stage_t* flecs_stage_from_readonly_world(
+    const ecs_world_t *world)
 {
-    if (ecs_os_api.log_) {
-        ecs_os_api.log_(-2, file, line, msg);
+    ecs_assert(flecs_poly_is(world, ecs_world_t) ||
+               flecs_poly_is(world, ecs_stage_t),
+               ECS_INTERNAL_ERROR,
+               NULL);
+
+    if (flecs_poly_is(world, ecs_world_t)) {
+        return ECS_CONST_CAST(ecs_stage_t*, world->stages[0]);
+    } else if (flecs_poly_is(world, ecs_stage_t)) {
+        return ECS_CONST_CAST(ecs_stage_t*, world);
     }
+
+    return NULL;
 }
 
-void ecs_os_err(
-    const char *file, 
-    int32_t line, 
-    const char *msg) 
+ecs_stage_t* flecs_stage_from_world(
+    ecs_world_t **world_ptr)
 {
-    if (ecs_os_api.log_) {
-        ecs_os_api.log_(-3, file, line, msg);
+    ecs_world_t *world = *world_ptr;
+
+    ecs_assert(flecs_poly_is(world, ecs_world_t) ||
+               flecs_poly_is(world, ecs_stage_t),
+               ECS_INTERNAL_ERROR,
+               NULL);
+
+    if (flecs_poly_is(world, ecs_world_t)) {
+        return world->stages[0];
     }
+
+    *world_ptr = ((ecs_stage_t*)world)->world;
+    return ECS_CONST_CAST(ecs_stage_t*, world);
 }
 
-void ecs_os_fatal(
-    const char *file, 
-    int32_t line, 
-    const char *msg) 
+ecs_world_t* flecs_suspend_readonly(
+    const ecs_world_t *stage_world,
+    ecs_suspend_readonly_state_t *state)
 {
-    if (ecs_os_api.log_) {
-        ecs_os_api.log_(-4, file, line, msg);
+    ecs_assert(stage_world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(state != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_world_t *world =
+        ECS_CONST_CAST(ecs_world_t*, ecs_get_world(stage_world));
+    flecs_poly_assert(world, ecs_world_t);
+
+    bool is_readonly = ECS_BIT_IS_SET(world->flags, EcsWorldReadonly);
+    ecs_world_t *temp_world = world;
+    ecs_stage_t *stage = flecs_stage_from_world(&temp_world);
+
+    if (!is_readonly && !stage->defer) {
+        state->is_readonly = false;
+        state->is_deferred = false;
+        return world;
     }
-}
 
-static
-void ecs_os_gettime(ecs_time_t *time) {
-    ecs_assert(ecs_os_has_time() == true, ECS_MISSING_OS_API, NULL);
-    
-    uint64_t now = ecs_os_now();
-    uint64_t sec = now / 1000000000;
+    ecs_dbg_3("suspending readonly mode");
 
-    assert(sec < UINT32_MAX);
-    assert((now - sec * 1000000000) < UINT32_MAX);
+    /* Cannot suspend when running with multiple threads */
+    ecs_assert(!(world->flags & EcsWorldReadonly) ||
+        (ecs_get_stage_count(world) <= 1), ECS_INVALID_WHILE_READONLY, NULL);
 
-    time->sec = (uint32_t)sec;
-    time->nanosec = (uint32_t)(now - sec * 1000000000);
-}
+    state->is_readonly = is_readonly;
+    state->is_deferred = stage->defer != 0;
 
-static
-void* ecs_os_api_malloc(ecs_size_t size) {
-    ecs_os_linc(&ecs_os_api_malloc_count);
-    ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL);
-    return malloc((size_t)size);
-}
+    /* Silence readonly checks */
+    world->flags &= ~EcsWorldReadonly;
 
-static
-void* ecs_os_api_calloc(ecs_size_t size) {
-    ecs_os_linc(&ecs_os_api_calloc_count);
-    ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL);
-    return calloc(1, (size_t)size);
+    /* Hack around safety checks (this ought to look ugly) */
+    state->defer_count = stage->defer;
+    state->commands = stage->cmd->queue;
+    state->defer_stack = stage->cmd->stack;
+    flecs_stack_init(&stage->cmd->stack);
+    state->scope = stage->scope;
+    state->with = stage->with;
+    stage->defer = 0;
+    ecs_vec_init_t(NULL, &stage->cmd->queue, ecs_cmd_t, 0);
+
+    return world;
 }
 
-static
-void* ecs_os_api_realloc(void *ptr, ecs_size_t size) {
-    ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL);
+void flecs_resume_readonly(
+    ecs_world_t *world,
+    ecs_suspend_readonly_state_t *state)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(state != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    if (ptr) {
-        ecs_os_linc(&ecs_os_api_realloc_count);
-    } else {
-        /* If not actually reallocing, treat as malloc */
-        ecs_os_linc(&ecs_os_api_malloc_count);
-    }
-    
-    return realloc(ptr, (size_t)size);
-}
+    ecs_world_t *temp_world = world;
+    ecs_stage_t *stage = flecs_stage_from_world(&temp_world);
 
-static
-void ecs_os_api_free(void *ptr) {
-    if (ptr) {
-        ecs_os_linc(&ecs_os_api_free_count);
+    if (state->is_readonly || state->is_deferred) {
+        ecs_dbg_3("resuming readonly mode");
+
+        ecs_run_aperiodic(world, 0);
+
+        /* Restore readonly state / defer count */
+        ECS_BIT_COND(world->flags, EcsWorldReadonly, state->is_readonly);
+        stage->defer = state->defer_count;
+        ecs_vec_fini_t(&stage->allocator, &stage->cmd->queue, ecs_cmd_t);
+        stage->cmd->queue = state->commands;
+        flecs_stack_fini(&stage->cmd->stack);
+        stage->cmd->stack = state->defer_stack;
+        stage->scope = state->scope;
+        stage->with = state->with;
     }
-    free(ptr);
 }
 
+/* Evaluate component monitor. If a monitored entity changed it will have set a
+ * flag in one of the world's component monitors. Queries can register
+ * themselves with component monitors to determine whether they need to rematch
+ * with tables. */
 static
-char* ecs_os_api_strdup(const char *str) {
-    if (str) {
-        int len = ecs_os_strlen(str);
-        char *result = ecs_os_malloc(len + 1);
-        ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL);
-        ecs_os_strcpy(result, str);
-        return result;
-    } else {
-        return NULL;
+void flecs_eval_component_monitor(
+    ecs_world_t *world)
+{
+    flecs_poly_assert(world, ecs_world_t);
+
+    if (!world->monitors.is_dirty) {
+        return;
     }
-}
 
-void ecs_os_strset(char **str, const char *value) {
-    char *old = str[0];
-    str[0] = ecs_os_strdup(value);
-    ecs_os_free(old);
-}
+    world->monitors.is_dirty = false;
 
-/* Replace dots with underscores */
-static
-char *module_file_base(const char *module, char sep) {
-    char *base = ecs_os_strdup(module);
-    ecs_size_t i, len = ecs_os_strlen(base);
-    for (i = 0; i < len; i ++) {
-        if (base[i] == '.') {
-            base[i] = sep;
+    ecs_map_iter_t it = ecs_map_iter(&world->monitors.monitors);
+    while (ecs_map_next(&it)) {
+        ecs_monitor_t *m = ecs_map_ptr(&it);
+        if (!m->is_dirty) {
+            continue;
         }
-    }
-
-    return base;
-}
-
-static
-char* ecs_os_api_module_to_dl(const char *module) {
-    ecs_strbuf_t lib = ECS_STRBUF_INIT;
-
-    /* Best guess, use module name with underscores + OS library extension */
-    char *file_base = module_file_base(module, '_');
-
-#   if defined(ECS_TARGET_LINUX) || defined(ECS_TARGET_FREEBSD)
-    ecs_strbuf_appendlit(&lib, "lib");
-    ecs_strbuf_appendstr(&lib, file_base);
-    ecs_strbuf_appendlit(&lib, ".so");
-#   elif defined(ECS_TARGET_DARWIN)
-    ecs_strbuf_appendlit(&lib, "lib");
-    ecs_strbuf_appendstr(&lib, file_base);
-    ecs_strbuf_appendlit(&lib, ".dylib");
-#   elif defined(ECS_TARGET_WINDOWS)
-    ecs_strbuf_appendstr(&lib, file_base);
-    ecs_strbuf_appendlit(&lib, ".dll");
-#   endif
-
-    ecs_os_free(file_base);
-
-    return ecs_strbuf_get(&lib);
-}
-
-static
-char* ecs_os_api_module_to_etc(const char *module) {
-    ecs_strbuf_t lib = ECS_STRBUF_INIT;
-
-    /* Best guess, use module name with dashes + /etc */
-    char *file_base = module_file_base(module, '-');
-
-    ecs_strbuf_appendstr(&lib, file_base);
-    ecs_strbuf_appendlit(&lib, "/etc");
 
-    ecs_os_free(file_base);
+        m->is_dirty = false;
 
-    return ecs_strbuf_get(&lib);
+        int32_t i, count = ecs_vec_count(&m->queries);
+        ecs_query_t **elems = ecs_vec_first(&m->queries);
+        for (i = 0; i < count; i ++) {
+            ecs_query_t *q = elems[i];
+            flecs_poly_assert(q, ecs_query_t);
+            flecs_query_cache_notify(world, q, &(ecs_query_cache_event_t) {
+                .kind = EcsQueryTableRematch
+            });
+        }
+    }
 }
 
-void ecs_os_set_api_defaults(void)
+void flecs_monitor_mark_dirty(
+    ecs_world_t *world,
+    ecs_entity_t id)
 {
-    /* Don't overwrite if already initialized */
-    if (ecs_os_api_initialized != 0) {
-        return;
-    }
-
-    if (ecs_os_api_initializing != 0) {
-        return;
-    }
-
-    ecs_os_api_initializing = true;
-    
-    /* Memory management */
-    ecs_os_api.malloc_ = ecs_os_api_malloc;
-    ecs_os_api.free_ = ecs_os_api_free;
-    ecs_os_api.realloc_ = ecs_os_api_realloc;
-    ecs_os_api.calloc_ = ecs_os_api_calloc;
-
-    /* Strings */
-    ecs_os_api.strdup_ = ecs_os_api_strdup;
-
-    /* Time */
-    ecs_os_api.get_time_ = ecs_os_gettime;
-
-    /* Logging */
-    ecs_os_api.log_ = flecs_log_msg;
-
-    /* Modules */
-    if (!ecs_os_api.module_to_dl_) {
-        ecs_os_api.module_to_dl_ = ecs_os_api_module_to_dl;
-    }
+    ecs_map_t *monitors = &world->monitors.monitors;
 
-    if (!ecs_os_api.module_to_etc_) {
-        ecs_os_api.module_to_etc_ = ecs_os_api_module_to_etc;
+    /* Only flag if there are actually monitors registered, so that we
+     * don't waste cycles evaluating monitors if there's no interest */
+    if (ecs_map_is_init(monitors)) {
+        ecs_monitor_t *m = ecs_map_get_deref(monitors, ecs_monitor_t, id);
+        if (m) {
+            if (!world->monitors.is_dirty) {
+                world->monitor_generation ++;
+            }
+            m->is_dirty = true;
+            world->monitors.is_dirty = true;
+        }
     }
-
-    ecs_os_api.abort_ = abort;
-
-#   ifdef FLECS_OS_API_IMPL
-    /* Initialize defaults to OS API IMPL addon, but still allow for overriding
-     * by the application */
-    ecs_set_os_api_impl();
-    ecs_os_api_initialized = false;
-#   endif
-
-    ecs_os_api_initializing = false;
-}
-
-bool ecs_os_has_heap(void) {
-    return 
-        (ecs_os_api.malloc_ != NULL) &&
-        (ecs_os_api.calloc_ != NULL) &&
-        (ecs_os_api.realloc_ != NULL) &&
-        (ecs_os_api.free_ != NULL);
-}
-
-bool ecs_os_has_threading(void) {
-    return
-        (ecs_os_api.mutex_new_ != NULL) &&
-        (ecs_os_api.mutex_free_ != NULL) &&
-        (ecs_os_api.mutex_lock_ != NULL) &&
-        (ecs_os_api.mutex_unlock_ != NULL) &&
-        (ecs_os_api.cond_new_ != NULL) &&
-        (ecs_os_api.cond_free_ != NULL) &&
-        (ecs_os_api.cond_wait_ != NULL) &&
-        (ecs_os_api.cond_signal_ != NULL) &&
-        (ecs_os_api.cond_broadcast_ != NULL) &&
-        (ecs_os_api.thread_new_ != NULL) &&
-        (ecs_os_api.thread_join_ != NULL) &&
-        (ecs_os_api.thread_self_ != NULL);
-}
-
-bool ecs_os_has_task_support(void) {
-    return
-        (ecs_os_api.mutex_new_ != NULL) &&
-        (ecs_os_api.mutex_free_ != NULL) &&
-        (ecs_os_api.mutex_lock_ != NULL) &&
-        (ecs_os_api.mutex_unlock_ != NULL) &&
-        (ecs_os_api.cond_new_ != NULL) &&
-        (ecs_os_api.cond_free_ != NULL) &&
-        (ecs_os_api.cond_wait_ != NULL) &&
-        (ecs_os_api.cond_signal_ != NULL) &&
-        (ecs_os_api.cond_broadcast_ != NULL) &&
-        (ecs_os_api.task_new_ != NULL) &&
-        (ecs_os_api.task_join_ != NULL);
-}
-
-bool ecs_os_has_time(void) {
-    return 
-        (ecs_os_api.get_time_ != NULL) &&
-        (ecs_os_api.sleep_ != NULL) &&
-        (ecs_os_api.now_ != NULL);
-}
-
-bool ecs_os_has_logging(void) {
-    return (ecs_os_api.log_ != NULL);
-}
-
-bool ecs_os_has_dl(void) {
-    return 
-        (ecs_os_api.dlopen_ != NULL) &&
-        (ecs_os_api.dlproc_ != NULL) &&
-        (ecs_os_api.dlclose_ != NULL);  
 }
 
-bool ecs_os_has_modules(void) {
-    return 
-        (ecs_os_api.module_to_dl_ != NULL) &&
-        (ecs_os_api.module_to_etc_ != NULL);
-}
-
-#if defined(ECS_TARGET_WINDOWS)
-static char error_str[255];
-#endif
+void flecs_monitor_register(
+    ecs_world_t *world,
+    ecs_entity_t id,
+    ecs_query_t *query)
+{
+    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(query, ecs_query_t);
 
-const char* ecs_os_strerror(int err) {
-#   if defined(ECS_TARGET_WINDOWS)
-    strerror_s(error_str, 255, err);
-    return error_str;
-#   else
-    return strerror(err);
-#   endif
+    ecs_map_t *monitors = &world->monitors.monitors;
+    ecs_map_init_if(monitors, &world->allocator);
+    ecs_monitor_t *m = ecs_map_ensure_alloc_t(monitors, ecs_monitor_t, id);
+    ecs_vec_init_if_t(&m->queries, ecs_query_t*);
+    ecs_query_t **q = ecs_vec_append_t(
+        &world->allocator, &m->queries, ecs_query_t*);
+    *q = query;
 }
 
-/**
- * @file poly.c
- * @brief Functions for managing poly objects.
- * 
- * The poly framework makes it possible to generalize common functionality for
- * different kinds of API objects, as well as improved type safety checks. Poly
- * objects have a header that identifiers what kind of object it is. This can
- * then be used to discover a set of "mixins" implemented by the type.
- * 
- * Mixins are like a vtable, but for members. Each type populates the table with
- * offsets to the members that correspond with the mixin. If an entry in the
- * mixin table is not set, the type does not support the mixin.
- * 
- * An example is the Iterable mixin, which makes it possible to create an 
- * iterator for any poly object (like filters, queries, the world) that 
- * implements the Iterable mixin.
- */
-
-
-static const char* mixin_kind_str[] = {
-    [EcsMixinWorld] = "world",
-    [EcsMixinEntity] = "entity",
-    [EcsMixinObservable] = "observable",
-    [EcsMixinIterable] = "iterable",
-    [EcsMixinDtor] = "dtor",
-    [EcsMixinMax] = "max (should never be requested by application)"
-};
+void flecs_monitor_unregister(
+    ecs_world_t *world,
+    ecs_entity_t id,
+    ecs_query_t *query)
+{
+    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(query, ecs_query_t);
 
-ecs_mixins_t ecs_world_t_mixins = {
-    .type_name = "ecs_world_t",
-    .elems = {
-        [EcsMixinWorld] = offsetof(ecs_world_t, self),
-        [EcsMixinObservable] = offsetof(ecs_world_t, observable),
-        [EcsMixinIterable] = offsetof(ecs_world_t, iterable)
+    ecs_map_t *monitors = &world->monitors.monitors;
+    if (!ecs_map_is_init(monitors)) {
+        return;
     }
-};
 
-ecs_mixins_t ecs_stage_t_mixins = {
-    .type_name = "ecs_stage_t",
-    .elems = {
-        [EcsMixinWorld] = offsetof(ecs_stage_t, world)
+    ecs_monitor_t *m = ecs_map_get_deref(monitors, ecs_monitor_t, id);
+    if (!m) {
+        return;
     }
-};
 
-ecs_mixins_t ecs_query_t_mixins = {
-    .type_name = "ecs_query_t",
-    .elems = {
-        [EcsMixinWorld] = offsetof(ecs_query_t, filter.world),
-        [EcsMixinEntity] = offsetof(ecs_query_t, filter.entity),
-        [EcsMixinIterable] = offsetof(ecs_query_t, iterable),
-        [EcsMixinDtor] = offsetof(ecs_query_t, dtor)
+    int32_t i, count = ecs_vec_count(&m->queries);
+    ecs_query_t **queries = ecs_vec_first(&m->queries);
+    for (i = 0; i < count; i ++) {
+        if (queries[i] == query) {
+            ecs_vec_remove_t(&m->queries, ecs_query_t*, i);
+            count --;
+            break;
+        }
     }
-};
 
-ecs_mixins_t ecs_observer_t_mixins = {
-    .type_name = "ecs_observer_t",
-    .elems = {
-        [EcsMixinWorld] = offsetof(ecs_observer_t, filter.world),
-        [EcsMixinEntity] = offsetof(ecs_observer_t, filter.entity),
-        [EcsMixinDtor] = offsetof(ecs_observer_t, dtor)
+    if (!count) {
+        ecs_vec_fini_t(&world->allocator, &m->queries, ecs_query_t*);
+        ecs_map_remove_free(monitors, id);
     }
-};
 
-ecs_mixins_t ecs_filter_t_mixins = {
-    .type_name = "ecs_filter_t",
-    .elems = {
-        [EcsMixinWorld] = offsetof(ecs_filter_t, world),
-        [EcsMixinEntity] = offsetof(ecs_filter_t, entity),
-        [EcsMixinIterable] = offsetof(ecs_filter_t, iterable),
-        [EcsMixinDtor] = offsetof(ecs_filter_t, dtor)
+    if (!ecs_map_count(monitors)) {
+        ecs_map_fini(monitors);
     }
-};
+}
 
 static
-void* assert_mixin(
-    const ecs_poly_t *poly,
-    ecs_mixin_kind_t kind)
+void flecs_init_store(
+    ecs_world_t *world)
 {
-    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(kind < EcsMixinMax, ECS_INVALID_PARAMETER, NULL);
-    
-    const ecs_header_t *hdr = poly;
-    ecs_assert(hdr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL);
-
-    const ecs_mixins_t *mixins = hdr->mixins;
-    ecs_assert(mixins != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_os_memset(&world->store, 0, ECS_SIZEOF(ecs_store_t));
 
-    ecs_size_t offset = mixins->elems[kind];
-    ecs_assert(offset != 0, ECS_INVALID_PARAMETER, 
-        "mixin %s not available for type %s",
-            mixin_kind_str[kind], mixins ? mixins->type_name : "unknown");
-    (void)mixin_kind_str;
+    ecs_allocator_t *a = &world->allocator;
+    ecs_vec_init_t(a, &world->store.records, ecs_table_record_t, 0);
+    ecs_vec_init_t(a, &world->store.marked_ids, ecs_marked_id_t, 0);
+    ecs_vec_init_t(a, &world->store.depth_ids, ecs_entity_t, 0);
+    ecs_map_init(&world->store.entity_to_depth, &world->allocator);
 
-    /* Object has mixin, return its address */
-    return ECS_OFFSET(hdr, offset);
-}
+    /* Initialize entity index */
+    flecs_entities_init(world);
 
-void* ecs_poly_init_(
-    ecs_poly_t *poly,
-    int32_t type,
-    ecs_size_t size,
-    ecs_mixins_t *mixins)
-{
-    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    /* Initialize table sparse set */
+    flecs_sparse_init_t(&world->store.tables, 
+        a, &world->allocators.sparse_chunk, ecs_table_t);
 
-    ecs_header_t *hdr = poly;
-    ecs_os_memset(poly, 0, size);
+    /* Initialize table map */
+    flecs_table_hashmap_init(world, &world->store.table_map);
 
-    hdr->magic = ECS_OBJECT_MAGIC;
-    hdr->type = type;
-    hdr->mixins = mixins;
+    /* Initialize root table */
+    flecs_init_root_table(world);
 
-    return poly;
+    /* Initilaize observer sparse set */
+    flecs_sparse_init_t(&world->store.observers,
+        a, &world->allocators.sparse_chunk, ecs_observer_impl_t);
 }
 
-void ecs_poly_fini_(
-    ecs_poly_t *poly,
-    int32_t type)
+static
+void flecs_clean_tables(
+    ecs_world_t *world)
 {
-    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
-    (void)type;
-
-    ecs_header_t *hdr = poly;
+    int32_t i, count = flecs_sparse_count(&world->store.tables);
 
-    /* Don't deinit poly that wasn't initialized */
-    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(hdr->type == type, ECS_INVALID_PARAMETER, NULL);
-    hdr->magic = 0;
-}
+    /* Ensure that first table in sparse set has id 0. This is a dummy table
+     * that only exists so that there is no table with id 0 */
+    ecs_table_t *first = flecs_sparse_get_dense_t(&world->store.tables,
+        ecs_table_t, 0);
+    (void)first;
 
-EcsPoly* ecs_poly_bind_(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t tag)
-{
-    /* Add tag to the entity for easy querying. This will make it possible to
-     * query for `Query` instead of `(Poly, Query) */
-    if (!ecs_has_id(world, entity, tag)) {
-        ecs_add_id(world, entity, tag);
+    for (i = 1; i < count; i ++) {
+        ecs_table_t *t = flecs_sparse_get_dense_t(&world->store.tables,
+            ecs_table_t, i);
+        flecs_table_fini(world, t);
     }
 
-    /* Never defer creation of a poly object */
-    bool deferred = false;
-    if (ecs_is_deferred(world)) {
-        deferred = true;
-        ecs_defer_suspend(world);
+    /* Free table types separately so that if application destructors rely on
+     * a type it's still valid. */
+    for (i = 1; i < count; i ++) {
+        ecs_table_t *t = flecs_sparse_get_dense_t(&world->store.tables,
+            ecs_table_t, i);
+        flecs_table_free_type(world, t);
     }
 
-    /* If this is a new poly, leave the actual creation up to the caller so they
-     * call tell the difference between a create or an update */
-    EcsPoly *result = ecs_ensure_pair(world, entity, EcsPoly, tag);
-
-    if (deferred) {
-        ecs_defer_resume(world);
+    /* Clear the root table */
+    if (count) {
+        flecs_table_reset(world, &world->store.root);
     }
-
-    return result;
 }
 
-void ecs_poly_modified_(
+static
+void flecs_fini_root_tables(
     ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t tag)
+    ecs_id_record_t *idr,
+    bool fini_targets)
 {
-    ecs_modified_pair(world, entity, ecs_id(EcsPoly), tag);
-}
+    ecs_table_cache_iter_t it;
 
-const EcsPoly* ecs_poly_bind_get_(
-    const ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t tag)
-{
-    return ecs_get_pair(world, entity, EcsPoly, tag);
-}
+    bool has_roots = flecs_table_cache_iter(&idr->cache, &it);
+    ecs_assert(has_roots == true, ECS_INTERNAL_ERROR, NULL);
+    (void)has_roots;
 
-ecs_poly_t* ecs_poly_get_(
-    const ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t tag)
-{
-    const EcsPoly *p = ecs_poly_bind_get_(world, entity, tag);
-    if (p) {
-        return p->poly;
+    const ecs_table_record_t *tr;
+    while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+        ecs_table_t *table = tr->hdr.table;
+        if (table->flags & EcsTableHasBuiltins) {
+            continue; /* Query out modules */
+        }
+
+        int32_t i, count = table->data.entities.count;
+        ecs_entity_t *entities = table->data.entities.array;
+
+        if (fini_targets) {
+            /* Only delete entities that are used as pair target. Iterate
+             * backwards to minimize moving entities around in table. */
+            for (i = count - 1; i >= 0; i --) {
+                ecs_record_t *r = flecs_entities_get(world, entities[i]);
+                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
+                if (ECS_RECORD_TO_ROW_FLAGS(r->row) & EcsEntityIsTarget) {
+                    ecs_delete(world, entities[i]);
+                }
+            }
+        } else {
+            /* Delete remaining entities that are not in use (added to another
+             * entity). This limits table moves during cleanup and delays
+             * cleanup of tags. */
+            for (i = count - 1; i >= 0; i --) {
+                ecs_record_t *r = flecs_entities_get(world, entities[i]);
+                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
+                if (!ECS_RECORD_TO_ROW_FLAGS(r->row)) {
+                    ecs_delete(world, entities[i]);
+                }
+            }
+        }
     }
-    return NULL;
 }
 
-bool ecs_poly_is_(
-    const ecs_poly_t *poly,
-    int32_t type)
+static
+void flecs_fini_roots(
+    ecs_world_t *world)
 {
-    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_id_record_t *idr = flecs_id_record_get(world, ecs_pair(EcsChildOf, 0));
 
-    const ecs_header_t *hdr = poly;
-    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL);
-    return hdr->type == type;    
-}
+    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
 
-ecs_iterable_t* ecs_get_iterable(
-    const ecs_poly_t *poly)
-{
-    return (ecs_iterable_t*)assert_mixin(poly, EcsMixinIterable);
-}
+    /* Delete root entities that are not modules. This prioritizes deleting
+     * regular entities first, which reduces the chance of components getting
+     * destructed in random order because it got deleted before entities,
+     * thereby bypassing the OnDeleteTarget policy. */
+    flecs_defer_begin(world, world->stages[0]);
+    flecs_fini_root_tables(world, idr, true);
+    flecs_defer_end(world, world->stages[0]);
 
-ecs_observable_t* ecs_get_observable(
-    const ecs_poly_t *poly)
-{
-    return (ecs_observable_t*)assert_mixin(poly, EcsMixinObservable);
+    flecs_defer_begin(world, world->stages[0]);
+    flecs_fini_root_tables(world, idr, false);
+    flecs_defer_end(world, world->stages[0]);
 }
 
-const ecs_world_t* ecs_get_world(
-    const ecs_poly_t *poly)
-{
-    if (((const ecs_header_t*)poly)->type == ecs_world_t_magic) {
-        return poly;
-    }
-    return *(ecs_world_t**)assert_mixin(poly, EcsMixinWorld);
-}
+static
+void flecs_fini_store(ecs_world_t *world) {
+    flecs_clean_tables(world);
+    flecs_sparse_fini(&world->store.tables);
+    flecs_table_fini(world, &world->store.root);
+    flecs_entities_clear(world);
+    flecs_hashmap_fini(&world->store.table_map);
 
-ecs_entity_t ecs_get_entity(
-    const ecs_poly_t *poly)
-{
-    return *(ecs_entity_t*)assert_mixin(poly, EcsMixinEntity);
+    ecs_assert(flecs_sparse_count(&world->store.observers) == 0, 
+        ECS_INTERNAL_ERROR, NULL);
+    flecs_sparse_fini(&world->store.observers);
+
+    ecs_allocator_t *a = &world->allocator;
+    ecs_vec_fini_t(a, &world->store.records, ecs_table_record_t);
+    ecs_vec_fini_t(a, &world->store.marked_ids, ecs_marked_id_t);
+    ecs_vec_fini_t(a, &world->store.depth_ids, ecs_entity_t);
+    ecs_map_fini(&world->store.entity_to_depth);
 }
 
-ecs_poly_dtor_t* ecs_get_dtor(
-    const ecs_poly_t *poly)
+static 
+void flecs_world_allocators_init(
+    ecs_world_t *world)
 {
-    return (ecs_poly_dtor_t*)assert_mixin(poly, EcsMixinDtor);
-}
+    ecs_world_allocators_t *a = &world->allocators;
 
-/**
- * @file query.c
- * @brief Cached query implementation.
- * 
- * Cached queries store a list of matched tables. The inputs for a cached query
- * are a filter and an observer. The filter is used to initially populate the
- * cache, and an observer is used to keep the cacne up to date.
- * 
- * Cached queries additionally support features like sorting and grouping. 
- * With sorting, an application can iterate over entities that can be sorted by
- * a component. Grouping allows an application to group matched tables, which is
- * used internally to implement the cascade feature, and can additionally be 
- * used to implement things like world cells.
- */
+    flecs_allocator_init(&world->allocator);
 
+    ecs_map_params_init(&a->ptr, &world->allocator);
+    ecs_map_params_init(&a->query_table_list, &world->allocator);
 
-static
-uint64_t flecs_query_get_group_id(
-    ecs_query_t *query,
-    ecs_table_t *table)
-{
-    if (query->group_by) {
-        return query->group_by(query->filter.world, table, 
-            query->group_by_id, query->group_by_ctx);
-    } else {
-        return 0;
-    }
+    flecs_ballocator_init_t(&a->query_table, ecs_query_cache_table_t);
+    flecs_ballocator_init_t(&a->query_table_match, ecs_query_cache_table_match_t);
+    flecs_ballocator_init_n(&a->graph_edge_lo, ecs_graph_edge_t, FLECS_HI_COMPONENT_ID);
+    flecs_ballocator_init_t(&a->graph_edge, ecs_graph_edge_t);
+    flecs_ballocator_init_t(&a->id_record, ecs_id_record_t);
+    flecs_ballocator_init_n(&a->id_record_chunk, ecs_id_record_t, FLECS_SPARSE_PAGE_SIZE);
+    flecs_ballocator_init_t(&a->table_diff, ecs_table_diff_t);
+    flecs_ballocator_init_n(&a->sparse_chunk, int32_t, FLECS_SPARSE_PAGE_SIZE);
+    flecs_ballocator_init_t(&a->hashmap, ecs_hashmap_t);
+    flecs_table_diff_builder_init(world, &world->allocators.diff_builder);
 }
 
 static
-void flecs_query_compute_group_id(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
+void flecs_world_allocators_fini(
+    ecs_world_t *world)
 {
-    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    if (query->group_by) {
-        ecs_table_t *table = match->table;
-        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_world_allocators_t *a = &world->allocators;
 
-        match->group_id = flecs_query_get_group_id(query, table);
-    } else {
-        match->group_id = 0;
-    }
-}
+    ecs_map_params_fini(&a->ptr);
+    ecs_map_params_fini(&a->query_table_list);
+    flecs_ballocator_fini(&a->query_table);
+    flecs_ballocator_fini(&a->query_table_match);
+    flecs_ballocator_fini(&a->graph_edge_lo);
+    flecs_ballocator_fini(&a->graph_edge);
+    flecs_ballocator_fini(&a->id_record);
+    flecs_ballocator_fini(&a->id_record_chunk);
+    flecs_ballocator_fini(&a->table_diff);
+    flecs_ballocator_fini(&a->sparse_chunk);
+    flecs_ballocator_fini(&a->hashmap);
+    flecs_table_diff_builder_fini(world, &world->allocators.diff_builder);
 
-static
-ecs_query_table_list_t* flecs_query_get_group(
-    const ecs_query_t *query,
-    uint64_t group_id)
-{
-    return ecs_map_get_deref(&query->groups, ecs_query_table_list_t, group_id);
+    flecs_allocator_fini(&world->allocator);
 }
 
-static
-ecs_query_table_list_t* flecs_query_ensure_group(
-    ecs_query_t *query,
-    uint64_t id)
-{
-    ecs_query_table_list_t *group = ecs_map_get_deref(&query->groups, 
-        ecs_query_table_list_t, id);
-
-    if (!group) {
-        group = ecs_map_insert_alloc_t(&query->groups, 
-            ecs_query_table_list_t, id);
-        ecs_os_zeromem(group);
-        if (query->on_group_create) {
-            group->info.ctx = query->on_group_create(
-                query->filter.world, id, query->group_by_ctx);
-        }
-    }
+#define ECS_STRINGIFY_INNER(x) #x
+#define ECS_STRINGIFY(x) ECS_STRINGIFY_INNER(x)
 
-    return group;
-}
+static const char flecs_compiler_info[]
+#if defined(__clang__)
+    = "clang " __clang_version__;
+#elif defined(__GNUC__)
+    = "gcc " ECS_STRINGIFY(__GNUC__) "." ECS_STRINGIFY(__GNUC_MINOR__);
+#elif defined(_MSC_VER)
+    = "msvc " ECS_STRINGIFY(_MSC_VER);
+#elif defined(__TINYC__)
+    = "tcc " ECS_STRINGIFY(__TINYC__);
+#else
+    = "unknown compiler";
+#endif
 
-static
-void flecs_query_remove_group(
-    ecs_query_t *query,
-    uint64_t id)
-{
-    if (query->on_group_delete) {
-        ecs_query_table_list_t *group = ecs_map_get_deref(&query->groups, 
-            ecs_query_table_list_t, id);
-        if (group) {
-            query->on_group_delete(query->filter.world, id, 
-                group->info.ctx, query->group_by_ctx);
-        }
-    }
+static const char *flecs_addons_info[] = {
+#ifdef FLECS_CPP
+    "FLECS_CPP",
+#endif
+#ifdef FLECS_MODULE
+    "FLECS_MODULE",
+#endif
+#ifdef FLECS_SCRIPT
+    "FLECS_SCRIPT",
+#endif
+#ifdef FLECS_RULES
+    "FLECS_RULES",
+#endif
+#ifdef FLECS_STATS
+    "FLECS_STATS",
+#endif
+#ifdef FLECS_MONITOR
+    "FLECS_MONITOR",
+#endif
+#ifdef FLECS_METRICS
+    "FLECS_METRICS",
+#endif
+#ifdef FLECS_ALERTS
+    "FLECS_ALERTS",
+#endif
+#ifdef FLECS_SYSTEM
+    "FLECS_SYSTEM",
+#endif
+#ifdef FLECS_PIPELINE
+    "FLECS_PIPELINE",
+#endif
+#ifdef FLECS_TIMER
+    "FLECS_TIMER",
+#endif
+#ifdef FLECS_META
+    "FLECS_META",
+#endif
+#ifdef FLECS_UNITS
+    "FLECS_UNITS",
+#endif
+#ifdef FLECS_JSON
+    "FLECS_JSON",
+#endif
+#ifdef FLECS_DOC
+    "FLECS_DOC",
+#endif
+#ifdef FLECS_LOG
+    "FLECS_LOG",
+#endif
+#ifdef FLECS_JOURNAL
+    "FLECS_JOURNAL",
+#endif
+#ifdef FLECS_APP
+    "FLECS_APP",
+#endif
+#ifdef FLECS_OS_API_IMPL
+    "FLECS_OS_API_IMPL",
+#endif
+#ifdef FLECS_SCRIPT
+    "FLECS_SCRIPT",
+#endif
+#ifdef FLECS_HTTP
+    "FLECS_HTTP",
+#endif
+#ifdef FLECS_REST
+    "FLECS_REST",
+#endif
+NULL
+};
 
-    ecs_map_remove_free(&query->groups, id);
-}
+static const ecs_build_info_t flecs_build_info = {
+    .compiler = flecs_compiler_info,
+    .addons = flecs_addons_info,
+#ifdef FLECS_DEBUG
+    .debug = true,
+#endif
+#ifdef FLECS_SANITIZE
+    .sanitize = true,
+#endif
+#ifdef FLECS_PERF_TRACE
+    .perf_trace = true,
+#endif
+    .version = FLECS_VERSION,
+    .version_major = FLECS_VERSION_MAJOR,
+    .version_minor = FLECS_VERSION_MINOR,
+    .version_patch = FLECS_VERSION_PATCH
+};
 
 static
-uint64_t flecs_query_default_group_by(
-    ecs_world_t *world, 
-    ecs_table_t *table, 
-    ecs_id_t id, 
-    void *ctx) 
-{
-    (void)ctx;
+void flecs_log_build_info(void) {
+    const ecs_build_info_t *bi = ecs_get_build_info();
+    ecs_assert(bi != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_id_t match;
-    if (ecs_search(world, table, ecs_pair(id, EcsWildcard), &match) != -1) {
-        return ecs_pair_second(world, match);
-    }
-    return 0;
-}
+    ecs_trace("flecs version %s", bi->version);
 
-/* Find the last node of the group after which this group should be inserted */
-static
-ecs_query_table_match_t* flecs_query_find_group_insertion_node(
-    ecs_query_t *query,
-    uint64_t group_id)
-{
-    /* Grouping must be enabled */
-    ecs_assert(query->group_by != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_trace("addons included in build:");
+    ecs_log_push();
 
-    ecs_map_iter_t it = ecs_map_iter(&query->groups);
-    ecs_query_table_list_t *list, *closest_list = NULL;
-    uint64_t id, closest_id = 0;
-    
-    bool desc = false;
+    const char **addon = bi->addons;
+    do {
+        ecs_trace(addon[0]);
+    } while ((++ addon)[0]);
+    ecs_log_pop();
 
-    if (query->cascade_by) {
-        desc = (query->filter.terms[
-            query->cascade_by - 1].src.flags & EcsDesc) != 0;
+    if (bi->sanitize) {
+        ecs_trace("sanitize build, rebuild without FLECS_SANITIZE for (much) "
+            "improved performance");
+    } else if (bi->debug) {
+        ecs_trace("debug build, rebuild with NDEBUG or FLECS_NDEBUG for "
+            "improved performance");
+    } else {
+        ecs_trace("#[green]release#[reset] build");
     }
 
-    /* Find closest smaller group id */
-    while (ecs_map_next(&it)) {
-        id = ecs_map_key(&it);
-
-        if (!desc) {
-            if (id >= group_id) {
-                continue;
-            }
-        } else {
-            if (id <= group_id) {
-                continue;
-            }
-        }
-
-        list = ecs_map_ptr(&it);
-        if (!list->last) {
-            ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL);
-            continue;
-        }
-
-        bool comp;
-        if (!desc) {
-            comp = ((group_id - id) < (group_id - closest_id));
-        } else {
-            comp = ((group_id - id) > (group_id - closest_id));
-        }
+    ecs_trace("compiled with %s", bi->compiler);
+}
 
-        if (!closest_list || comp) {
-            closest_id = id;
-            closest_list = list;
-        }
-    }
+/* -- Public functions -- */
 
-    if (closest_list) {
-        return closest_list->last;
-    } else {
-        return NULL; /* Group should be first in query */
-    }
+const ecs_build_info_t* ecs_get_build_info(void) {
+    return &flecs_build_info;
 }
 
-/* Initialize group with first node */
-static
-void flecs_query_create_group(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
+const ecs_world_info_t* ecs_get_world_info(
+    const ecs_world_t *world)
 {
-    uint64_t group_id = match->group_id;
+    world = ecs_get_world(world);
+    return &world->info;
+}
 
-    /* If query has grouping enabled & this is a new/empty group, find
-     * the insertion point for the group */
-    ecs_query_table_match_t *insert_after = flecs_query_find_group_insertion_node(
-        query, group_id);
+ecs_world_t *ecs_mini(void) {
+#ifdef FLECS_OS_API_IMPL
+    ecs_set_os_api_impl();
+#endif
+    ecs_os_init();
 
-    if (!insert_after) {
-        /* This group should appear first in the query list */
-        ecs_query_table_match_t *query_first = query->list.first;
-        if (query_first) {
-            /* If this is not the first match for the query, insert before it */
-            match->next = query_first;
-            query_first->prev = match;
-            query->list.first = match;
-        } else {
-            /* If this is the first match of the query, initialize its list */
-            ecs_assert(query->list.last == NULL, ECS_INTERNAL_ERROR, NULL);
-            query->list.first = match;
-            query->list.last = match;
-        }
-    } else {
-        ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_trace("#[bold]bootstrapping world");
+    ecs_log_push();
 
-        /* This group should appear after another group */
-        ecs_query_table_match_t *insert_before = insert_after->next;
-        match->prev = insert_after;
-        insert_after->next = match;
-        match->next = insert_before;
-        if (insert_before) {
-            insert_before->prev = match;
-        } else {
-            ecs_assert(query->list.last == insert_after, 
-                ECS_INTERNAL_ERROR, NULL);
-                
-            /* This group should appear last in the query list */
-            query->list.last = match;
-        }
+    ecs_trace("tracing enabled, call ecs_log_set_level(-1) to disable");
+
+    if (!ecs_os_has_heap()) {
+        ecs_abort(ECS_MISSING_OS_API, NULL);
     }
-}
 
-/* Find the list the node should be part of */
-static
-ecs_query_table_list_t* flecs_query_get_node_list(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    if (query->group_by) {
-        return flecs_query_get_group(query, match->group_id);
-    } else {
-        return &query->list;
+    if (!ecs_os_has_threading()) {
+        ecs_trace("threading unavailable, to use threads set OS API first (see examples)");
     }
-}
 
-/* Find or create the list the node should be part of */
-static
-ecs_query_table_list_t* flecs_query_ensure_node_list(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    if (query->group_by) {
-        return flecs_query_ensure_group(query, match->group_id);
-    } else {
-        return &query->list;
+    if (!ecs_os_has_time()) {
+        ecs_trace("time management not available");
     }
-}
 
-/* Remove node from list */
-static
-void flecs_query_remove_table_node(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    ecs_query_table_match_t *prev = match->prev;
-    ecs_query_table_match_t *next = match->next;
+    flecs_log_build_info();
 
-    ecs_assert(prev != match, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(next != match, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!prev || prev != next, ECS_INTERNAL_ERROR, NULL);
+    ecs_world_t *world = ecs_os_calloc_t(ecs_world_t);
+    ecs_assert(world != NULL, ECS_OUT_OF_MEMORY, NULL);
+    flecs_poly_init(world, ecs_world_t);
 
-    ecs_query_table_list_t *list = flecs_query_get_node_list(query, match);
+    world->flags |= EcsWorldInit;
 
-    if (!list || !list->first) {
-        /* If list contains no matches, the match must be empty */
-        ecs_assert(!list || list->last == NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL);
-        return;
-    }
+    flecs_world_allocators_init(world);
+    ecs_allocator_t *a = &world->allocator;
 
-    ecs_assert(prev != NULL || query->list.first == match, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(next != NULL || query->list.last == match, 
-        ECS_INTERNAL_ERROR, NULL);
+    world->self = world;
+    flecs_sparse_init_t(&world->type_info, a,
+        &world->allocators.sparse_chunk, ecs_type_info_t);
+    ecs_map_init_w_params(&world->id_index_hi, &world->allocators.ptr);
+    world->id_index_lo = ecs_os_calloc_n(ecs_id_record_t, FLECS_HI_ID_RECORD_ID);
+    flecs_observable_init(&world->observable);
 
-    if (prev) {
-        prev->next = next;
-    }
-    if (next) {
-        next->prev = prev;
-    }
+    world->pending_tables = ecs_os_calloc_t(ecs_sparse_t);
+    flecs_sparse_init_t(world->pending_tables, a,
+        &world->allocators.sparse_chunk, ecs_table_t*);
+    world->pending_buffer = ecs_os_calloc_t(ecs_sparse_t);
+    flecs_sparse_init_t(world->pending_buffer, a,
+        &world->allocators.sparse_chunk, ecs_table_t*);
 
-    ecs_assert(list->info.table_count > 0, ECS_INTERNAL_ERROR, NULL);
-    list->info.table_count --;
+    flecs_name_index_init(&world->aliases, a);
+    flecs_name_index_init(&world->symbols, a);
+    ecs_vec_init_t(a, &world->fini_actions, ecs_action_elem_t, 0);
 
-    if (query->group_by) {
-        uint64_t group_id = match->group_id;
+    world->info.time_scale = 1.0;
+    if (ecs_os_has_time()) {
+        ecs_os_get_time(&world->world_start_time);
+    }
 
-        /* Make sure query.list is updated if this is the first or last group */
-        if (query->list.first == match) {
-            ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL);
-            query->list.first = next;
-            prev = next;
-        }
-        if (query->list.last == match) {
-            ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL);
-            query->list.last = prev;
-            next = prev;
-        }
+    ecs_set_stage_count(world, 1);
+    ecs_default_lookup_path[0] = EcsFlecsCore;
+    ecs_set_lookup_path(world, ecs_default_lookup_path);
+    flecs_init_store(world);
 
-        ecs_assert(query->list.info.table_count > 0, ECS_INTERNAL_ERROR, NULL);
-        query->list.info.table_count --;
-        list->info.match_count ++;
+    flecs_bootstrap(world);
 
-        /* Make sure group list only contains nodes that belong to the group */
-        if (prev && prev->group_id != group_id) {
-            /* The previous node belonged to another group */
-            prev = next;
-        }
-        if (next && next->group_id != group_id) {
-            /* The next node belonged to another group */
-            next = prev;
-        }
+    world->flags &= ~EcsWorldInit;
 
-        /* Do check again, in case both prev & next belonged to another group */
-        if ((!prev && !next) || (prev && prev->group_id != group_id)) {
-            /* There are no more matches left in this group */
-            flecs_query_remove_group(query, group_id);
-            list = NULL;
-        }
-    }
+    ecs_trace("world ready!");
+    ecs_log_pop();
 
-    if (list) {
-        if (list->first == match) {
-            list->first = next;
-        }
-        if (list->last == match) {
-            list->last = prev;
-        }
-    }
+    return world;
+}
 
-    match->prev = NULL;
-    match->next = NULL;
+ecs_world_t *ecs_init(void) {
+    ecs_world_t *world = ecs_mini();
 
-    query->match_count ++;
+#ifdef FLECS_MODULE_H
+    ecs_trace("#[bold]import addons");
+    ecs_log_push();
+    ecs_trace("use ecs_mini to create world without importing addons");
+#ifdef FLECS_SYSTEM
+    ECS_IMPORT(world, FlecsSystem);
+#endif
+#ifdef FLECS_PIPELINE
+    ECS_IMPORT(world, FlecsPipeline);
+#endif
+#ifdef FLECS_TIMER
+    ECS_IMPORT(world, FlecsTimer);
+#endif
+#ifdef FLECS_META
+    ECS_IMPORT(world, FlecsMeta);
+#endif
+#ifdef FLECS_DOC
+    ECS_IMPORT(world, FlecsDoc);
+#endif
+#ifdef FLECS_SCRIPT
+    ECS_IMPORT(world, FlecsScript);
+#endif
+#ifdef FLECS_REST
+    ECS_IMPORT(world, FlecsRest);
+#endif
+#ifdef FLECS_UNITS
+    ecs_trace("#[green]module#[reset] flecs.units is not automatically imported");
+#endif
+    ecs_trace("addons imported!");
+    ecs_log_pop();
+#endif
+    return world;
 }
 
-/* Add node to list */
-static
-void flecs_query_insert_table_node(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
+ecs_world_t* ecs_init_w_args(
+    int argc,
+    char *argv[])
 {
-    /* Node should not be part of an existing list */
-    ecs_assert(match->prev == NULL && match->next == NULL, 
-        ECS_INTERNAL_ERROR, NULL);
+    ecs_world_t *world = ecs_init();
 
-    /* If this is the first match, activate system */
-    if (!query->list.first && query->filter.entity) {
-        ecs_remove_id(query->filter.world, query->filter.entity, EcsEmpty);
+    (void)argc;
+    (void)argv;
+
+#ifdef FLECS_DOC
+    if (argc) {
+        char *app = argv[0];
+        char *last_elem = strrchr(app, '/');
+        if (!last_elem) {
+            last_elem = strrchr(app, '\\');
+        }
+        if (last_elem) {
+            app = last_elem + 1;
+        }
+        ecs_set_pair(world, EcsWorld, EcsDocDescription, EcsName, {app});
     }
+#endif
 
-    flecs_query_compute_group_id(query, match);
+    return world;
+}
 
-    ecs_query_table_list_t *list = flecs_query_ensure_node_list(query, match);
-    if (list->last) {
-        ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL);
+void ecs_quit(
+    ecs_world_t *world)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    flecs_stage_from_world(&world);
+    world->flags |= EcsWorldQuit;
+error:
+    return;
+}
 
-        ecs_query_table_match_t *last = list->last;
-        ecs_query_table_match_t *last_next = last->next;
+bool ecs_should_quit(
+    const ecs_world_t *world)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    world = ecs_get_world(world);
+    return ECS_BIT_IS_SET(world->flags, EcsWorldQuit);
+error:
+    return true;
+}
 
-        match->prev = last;
-        match->next = last_next;
-        last->next = match;
+void flecs_notify_tables(
+    ecs_world_t *world,
+    ecs_id_t id,
+    ecs_table_event_t *event)
+{
+    flecs_poly_assert(world, ecs_world_t);
 
-        if (last_next) {
-            last_next->prev = match;
+    /* If no id is specified, broadcast to all tables */
+    if (!id) {
+        ecs_sparse_t *tables = &world->store.tables;
+        int32_t i, count = flecs_sparse_count(tables);
+        for (i = 0; i < count; i ++) {
+            ecs_table_t *table = flecs_sparse_get_dense_t(tables, ecs_table_t, i);
+            flecs_table_notify(world, table, event);
         }
 
-        list->last = match;
-
-        if (query->group_by) {
-            /* Make sure to update query list if this is the last group */
-            if (query->list.last == last) {
-                query->list.last = match;
-            }
-        }
+    /* If id is specified, only broadcast to tables with id */
     } else {
-        ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_id_record_t *idr = flecs_id_record_get(world, id);
+        if (!idr) {
+            return;
+        }
 
-        list->first = match;
-        list->last = match;
+        ecs_table_cache_iter_t it;
+        const ecs_table_record_t *tr;
 
-        if (query->group_by) {
-            /* Initialize group with its first node */
-            flecs_query_create_group(query, match);
+        flecs_table_cache_all_iter(&idr->cache, &it);
+        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+            flecs_table_notify(world, tr->hdr.table, event);
         }
     }
+}
 
-    if (query->group_by) {
-        list->info.table_count ++;
-        list->info.match_count ++;
-    }
-
-    query->list.info.table_count ++;
-    query->match_count ++;
-
-    ecs_assert(match->prev != match, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(match->next != match, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(list->last != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(list->last == match, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query->list.first->prev == NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query->list.last->next == NULL, ECS_INTERNAL_ERROR, NULL);
+void flecs_default_ctor(
+    void *ptr, 
+    int32_t count, 
+    const ecs_type_info_t *ti)
+{
+    ecs_os_memset(ptr, 0, ti->size * count);
 }
 
 static
-ecs_query_table_match_t* flecs_query_cache_add(
-    ecs_world_t *world,
-    ecs_query_table_t *elem)
+void flecs_default_copy_ctor(void *dst_ptr, const void *src_ptr,
+    int32_t count, const ecs_type_info_t *ti)
 {
-    ecs_query_table_match_t *result = 
-        flecs_bcalloc(&world->allocators.query_table_match);
-
-    if (!elem->first) {
-        elem->first = result;
-        elem->last = result;
-    } else {
-        ecs_assert(elem->last != NULL, ECS_INTERNAL_ERROR, NULL);
-        elem->last->next_match = result;
-        elem->last = result;
-    }
+    const ecs_type_hooks_t *cl = &ti->hooks;
+    cl->ctor(dst_ptr, count, ti);
+    cl->copy(dst_ptr, src_ptr, count, ti);
+}
 
-    return result;
+static
+void flecs_default_move_ctor(void *dst_ptr, void *src_ptr,
+    int32_t count, const ecs_type_info_t *ti)
+{
+    const ecs_type_hooks_t *cl = &ti->hooks;
+    cl->ctor(dst_ptr, count, ti);
+    cl->move(dst_ptr, src_ptr, count, ti);
 }
 
-typedef struct {
-    ecs_table_t *table;
-    int32_t column;
-} flecs_table_column_t;
+static
+void flecs_default_ctor_w_move_w_dtor(void *dst_ptr, void *src_ptr,
+    int32_t count, const ecs_type_info_t *ti)
+{
+    const ecs_type_hooks_t *cl = &ti->hooks;
+    cl->ctor(dst_ptr, count, ti);
+    cl->move(dst_ptr, src_ptr, count, ti);
+    cl->dtor(src_ptr, count, ti);
+}
 
 static
-void flecs_query_get_column_for_term(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match,
-    int32_t t,
-    flecs_table_column_t *out)
+void flecs_default_move_ctor_w_dtor(void *dst_ptr, void *src_ptr,
+    int32_t count, const ecs_type_info_t *ti)
 {
-    const ecs_filter_t *filter = &query->filter;
-    ecs_world_t *world = filter->world;
-    ecs_term_t *term = &filter->terms[t];
-    int32_t field = term->field_index;
-    ecs_entity_t src = match->sources[field];
-    ecs_table_t *table = NULL;
-    int32_t column = -1;
+    const ecs_type_hooks_t *cl = &ti->hooks;
+    cl->move_ctor(dst_ptr, src_ptr, count, ti);
+    cl->dtor(src_ptr, count, ti);
+}
 
-    if (term->oper != EcsNot) {
-        if (!src) {
-            if (term->src.flags != EcsIsEntity) {
-                table = match->table;
-                column = match->storage_columns[field];
-                if (column == -2) {
-                    /* Shared field */
-                    column = -1;
-                }
-            }
-        } else {
-            table = ecs_get_table(world, src);
-            if (ecs_term_match_this(term)) {
-                int32_t ref_index = -match->columns[field] - 1;
-                ecs_ref_t *ref = ecs_vec_get_t(&match->refs, ecs_ref_t, ref_index);
-                if (ref->id != 0) {
-                    ecs_ref_update(world, ref);
-                    column = ref->tr->column;
-                }
-            } else {
-                column = -(match->columns[field] + 1);
-            }
-        }
-    }
+static
+void flecs_default_move(void *dst_ptr, void *src_ptr,
+    int32_t count, const ecs_type_info_t *ti)
+{
+    const ecs_type_hooks_t *cl = &ti->hooks;
+    cl->move(dst_ptr, src_ptr, count, ti);
+}
 
-    out->table = table;
-    out->column = column;
+static
+void flecs_default_dtor(void *dst_ptr, void *src_ptr,
+    int32_t count, const ecs_type_info_t *ti)
+{
+    /* When there is no move, destruct the destination component & memcpy the
+     * component to dst. The src component does not have to be destructed when
+     * a component has a trivial move. */
+    const ecs_type_hooks_t *cl = &ti->hooks;
+    cl->dtor(dst_ptr, count, ti);
+    ecs_os_memcpy(dst_ptr, src_ptr, flecs_uto(ecs_size_t, ti->size) * count);
 }
 
-/* Get match monitor. Monitors are used to keep track of whether components 
- * matched by the query in a table have changed. */
 static
-bool flecs_query_get_match_monitor(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
+void flecs_default_move_w_dtor(void *dst_ptr, void *src_ptr,
+    int32_t count, const ecs_type_info_t *ti)
 {
-    if (match->monitor) {
-        return false;
-    }
+    /* If a component has a move, the move will take care of memcpying the data
+     * and destroying any data in dst. Because this is not a trivial move, the
+     * src component must also be destructed. */
+    const ecs_type_hooks_t *cl = &ti->hooks;
+    cl->move(dst_ptr, src_ptr, count, ti);
+    cl->dtor(src_ptr, count, ti);
+}
 
-    int32_t *monitor = flecs_balloc(&query->allocators.monitors);
-    monitor[0] = 0;
+void ecs_set_hooks_id(
+    ecs_world_t *world,
+    ecs_entity_t component,
+    const ecs_type_hooks_t *h)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    /* Mark terms that don't need to be monitored. This saves time when reading
-     * and/or updating the monitor. */
-    const ecs_filter_t *f = &query->filter;
-    int32_t i, field = -1, term_count = f->term_count;
-    flecs_table_column_t tc;
+    flecs_stage_from_world(&world);
 
-    for (i = 0; i < term_count; i ++) {
-        if (field == f->terms[i].field_index) {
-            if (monitor[field + 1] != -1) {
-                continue;
-            }
-        }
+    /* Ensure that no tables have yet been created for the component */
+    ecs_assert( ecs_id_in_use(world, component) == false,
+        ECS_ALREADY_IN_USE, ecs_get_name(world, component));
+    ecs_assert( ecs_id_in_use(world, ecs_pair(component, EcsWildcard)) == false,
+        ECS_ALREADY_IN_USE, ecs_get_name(world, component));
 
-        field = f->terms[i].field_index;
-        monitor[field + 1] = -1;
+    ecs_type_info_t *ti = flecs_type_info_ensure(world, component);
+    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        if (f->terms[i].inout != EcsIn && 
-            f->terms[i].inout != EcsInOut &&
-            f->terms[i].inout != EcsInOutDefault) {
-            continue; /* If term isn't read, don't monitor */
-        }
+    ecs_check(!ti->component || ti->component == component,
+        ECS_INCONSISTENT_COMPONENT_ACTION, NULL);
 
-        int32_t column = match->columns[field];
-        if (column == 0) {
-            continue; /* Don't track terms that aren't matched */
-        }
+    if (!ti->size) {
+        const EcsComponent *component_ptr = ecs_get(
+            world, component, EcsComponent);
 
-        flecs_query_get_column_for_term(query, match, i, &tc);
-        if (tc.column == -1) {
-            continue; /* Don't track terms that aren't stored */
-        }
+        /* Cannot register lifecycle actions for things that aren't a component */
+        ecs_check(component_ptr != NULL, ECS_INVALID_PARAMETER, 
+            "provided entity is not a component");
+        ecs_check(component_ptr->size != 0, ECS_INVALID_PARAMETER,
+            "cannot register type hooks for type with size 0");
 
-        monitor[field + 1] = 0;
+        ti->size = component_ptr->size;
+        ti->alignment = component_ptr->alignment;
     }
 
-    /* If matched table needs entity filter, make sure to test fields that could
-     * be matched by flattened parents. */
-    ecs_entity_filter_t *ef = match->entity_filter;
-    if (ef && ef->flat_tree_column != -1) {
-        int32_t *fields = ecs_vec_first(&ef->ft_terms);
-        int32_t field_count = ecs_vec_count(&ef->ft_terms);
-        for (i = 0; i < field_count; i ++) {
-            monitor[fields[i] + 1] = 0;
-        }
-    }
+    if (h->ctor) ti->hooks.ctor = h->ctor;
+    if (h->dtor) ti->hooks.dtor = h->dtor;
+    if (h->copy) ti->hooks.copy = h->copy;
+    if (h->move) ti->hooks.move = h->move;
+    if (h->copy_ctor) ti->hooks.copy_ctor = h->copy_ctor;
+    if (h->move_ctor) ti->hooks.move_ctor = h->move_ctor;
+    if (h->ctor_move_dtor) ti->hooks.ctor_move_dtor = h->ctor_move_dtor;
+    if (h->move_dtor) ti->hooks.move_dtor = h->move_dtor;
 
-    match->monitor = monitor;
+    if (h->on_add) ti->hooks.on_add = h->on_add;
+    if (h->on_remove) ti->hooks.on_remove = h->on_remove;
+    if (h->on_set) ti->hooks.on_set = h->on_set;
 
-    query->flags |= EcsQueryHasMonitor;
+    if (h->ctx) ti->hooks.ctx = h->ctx;
+    if (h->binding_ctx) ti->hooks.binding_ctx = h->binding_ctx;
+    if (h->ctx_free) ti->hooks.ctx_free = h->ctx_free;
+    if (h->binding_ctx_free) ti->hooks.binding_ctx_free = h->binding_ctx_free;
 
-    return true;
-}
+    /* If no constructor is set, invoking any of the other lifecycle actions
+     * is not safe as they will potentially access uninitialized memory. For
+     * ease of use, if no constructor is specified, set a default one that
+     * initializes the component to 0. */
+    if (!h->ctor && (h->dtor || h->copy || h->move)) {
+        ti->hooks.ctor = flecs_default_ctor;   
+    }
 
-/* Synchronize match monitor with table dirty state */
-static
-void flecs_query_sync_match_monitor(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
-    if (!match->monitor) {
-        if (query->flags & EcsQueryHasMonitor) {
-            flecs_query_get_match_monitor(query, match);
-        } else {
-            return;
-        }
+    /* Set default copy ctor, move ctor and merge */
+    if (h->copy && !h->copy_ctor) {
+        ti->hooks.copy_ctor = flecs_default_copy_ctor;
     }
 
-    int32_t *monitor = match->monitor;
-    ecs_table_t *table = match->table;
-    if (table) {
-        int32_t *dirty_state = flecs_table_get_dirty_state(
-            query->filter.world, table);
-        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
-        monitor[0] = dirty_state[0]; /* Did table gain/lose entities */
+    if (h->move && !h->move_ctor) {
+        ti->hooks.move_ctor = flecs_default_move_ctor;
     }
 
-    ecs_filter_t *filter = &query->filter;
-    {
-        flecs_table_column_t tc;
-        int32_t t, term_count = filter->term_count;
-        for (t = 0; t < term_count; t ++) {
-            int32_t field = filter->terms[t].field_index;
-            if (monitor[field + 1] == -1) {
-                continue;
+    if (!h->ctor_move_dtor) {
+        if (h->move) {
+            if (h->dtor) {
+                if (h->move_ctor) {
+                    /* If an explicit move ctor has been set, use callback
+                     * that uses the move ctor vs. using a ctor+move */
+                    ti->hooks.ctor_move_dtor = flecs_default_move_ctor_w_dtor;
+                } else {
+                    /* If no explicit move_ctor has been set, use
+                     * combination of ctor + move + dtor */
+                    ti->hooks.ctor_move_dtor = flecs_default_ctor_w_move_w_dtor;
+                }
+            } else {
+                /* If no dtor has been set, this is just a move ctor */
+                ti->hooks.ctor_move_dtor = ti->hooks.move_ctor;
+            }
+        } else {
+            /* If move is not set but move_ctor and dtor is, we can still set
+             * ctor_move_dtor. */
+            if (h->move_ctor) {
+                if (h->dtor) {
+                    ti->hooks.ctor_move_dtor = flecs_default_move_ctor_w_dtor;
+                } else {
+                    ti->hooks.ctor_move_dtor = ti->hooks.move_ctor;
+                }
             }
-
-            flecs_query_get_column_for_term(query, match, t, &tc);
-
-            monitor[field + 1] = flecs_table_get_dirty_state(
-                filter->world, tc.table)[tc.column + 1];
         }
     }
 
-    ecs_entity_filter_t *ef = match->entity_filter;
-    if (ef && ef->flat_tree_column != -1) {
-        flecs_flat_table_term_t *fields = ecs_vec_first(&ef->ft_terms);
-        int32_t f, field_count = ecs_vec_count(&ef->ft_terms);
-        for (f = 0; f < field_count; f ++) {
-            flecs_flat_table_term_t *field = &fields[f];
-            flecs_flat_monitor_t *tgt_mon = ecs_vec_first(&field->monitor);
-            int32_t tgt, tgt_count = ecs_vec_count(&field->monitor);
-            for (tgt = 0; tgt < tgt_count; tgt ++) {
-                tgt_mon[tgt].monitor = tgt_mon[tgt].table_state;
+    if (!h->move_dtor) {
+        if (h->move) {
+            if (h->dtor) {
+                ti->hooks.move_dtor = flecs_default_move_w_dtor;
+            } else {
+                ti->hooks.move_dtor = flecs_default_move;
+            }
+        } else {
+            if (h->dtor) {
+                ti->hooks.move_dtor = flecs_default_dtor;
             }
         }
     }
 
-    query->prev_match_count = query->match_count;
+error:
+    return;
 }
 
-/* Check if single match term has changed */
-static
-bool flecs_query_check_match_monitor_term(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match,
-    int32_t term)
+const ecs_type_hooks_t* ecs_get_hooks_id(
+    ecs_world_t *world,
+    ecs_entity_t id)
 {
-    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    if (flecs_query_get_match_monitor(query, match)) {
-        return true;
-    }
-    
-    int32_t *monitor = match->monitor;
-    int32_t state = monitor[term];
-    if (state == -1) {
-        return false;
-    }
-
-    ecs_table_t *table = match->table;
-    if (table) {
-        int32_t *dirty_state = flecs_table_get_dirty_state(
-            query->filter.world, table);
-        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
-        if (!term) {
-            return monitor[0] != dirty_state[0];
-        }
-    } else if (!term) {
-        return false;
+    const ecs_type_info_t *ti = ecs_get_type_info(world, id);
+    if (ti) {
+        return &ti->hooks;
     }
-
-    flecs_table_column_t cur;
-    flecs_query_get_column_for_term(query, match, term - 1, &cur);
-    ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL);
-
-    return monitor[term] != flecs_table_get_dirty_state(
-        query->filter.world, cur.table)[cur.column + 1];
+    return NULL;
 }
 
-/* Check if any term for match has changed */
-static
-bool flecs_query_check_match_monitor(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match,
-    const ecs_iter_t *it)
+void ecs_atfini(
+    ecs_world_t *world,
+    ecs_fini_action_t action,
+    void *ctx)
 {
-    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    if (flecs_query_get_match_monitor(query, match)) {
-        return true;
-    }
-
-    int32_t *monitor = match->monitor;
-    ecs_table_t *table = match->table;
-    int32_t *dirty_state = NULL;
-    if (table) {
-        dirty_state = flecs_table_get_dirty_state(
-            query->filter.world, table);
-        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
-        if (monitor[0] != dirty_state[0]) {
-            return true;
-        }
-    }
-
-    bool has_flat = false, is_this = false;
-    const ecs_filter_t *filter = &query->filter;
-    ecs_world_t *world = filter->world;
-    int32_t i, j, field_count = filter->field_count;
-    int32_t *storage_columns = match->storage_columns;
-    int32_t *columns = it ? it->columns : NULL;
-    if (!columns) {
-        columns = match->columns;
-    }
-    ecs_vec_t *refs = &match->refs;
-    for (i = 0; i < field_count; i ++) {
-        int32_t mon = monitor[i + 1];
-        if (mon == -1) {
-            continue;
-        }
-
-        int32_t column = storage_columns[i];
-        if (columns[i] >= 0) {
-            /* owned component */
-            ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
-            if (mon != dirty_state[column + 1]) {
-                return true;
-            }
-            continue;
-        } else if (column == -1) {
-            continue; /* owned but not a component */
-        }
-
-        column = columns[i];
-        if (!column) {
-            /* Not matched */
-            continue;
-        }
-
-        ecs_assert(column < 0, ECS_INTERNAL_ERROR, NULL);
-        column = -column;
-
-        /* Find term index from field index, which differ when using || */
-        int32_t term_index = i;
-        if (filter->terms[i].field_index != i) {
-            for (j = i; j < filter->term_count; j ++) {
-                if (filter->terms[j].field_index == i) {
-                    term_index = j;
-                    break;
-                }
-            }
-        }
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(action != NULL, ECS_INVALID_PARAMETER, NULL);
 
-        is_this = ecs_term_match_this(&filter->terms[term_index]);
+    ecs_action_elem_t *elem = ecs_vec_append_t(NULL, &world->fini_actions,
+        ecs_action_elem_t);
+    ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        /* Flattened fields are encoded by adding field_count to the column
-         * index of the parent component. */
-        if (is_this && it && (column > field_count)) {
-            has_flat = true;
-        } else {
-            if (is_this) {
-                /* Component reached through traversal from this */
-                int32_t ref_index = column - 1;
-                ecs_ref_t *ref = ecs_vec_get_t(refs, ecs_ref_t, ref_index);
-                if (ref->id != 0) {
-                    ecs_ref_update(world, ref);
-                    ecs_table_record_t *tr = ref->tr;
-                    ecs_table_t *src_table = tr->hdr.table;
-                    column = tr->index;
-                    column = ecs_table_type_to_column_index(src_table, column);
-                    int32_t *src_dirty_state = flecs_table_get_dirty_state(
-                        world, src_table);
-                    if (mon != src_dirty_state[column + 1]) {
-                        return true;
-                    }
-                }
-            } else {
-                /* Component from static source */
-                ecs_entity_t src = match->sources[i];
-                ecs_table_t *src_table = ecs_get_table(world, src);
-                ecs_assert(src_table != NULL, ECS_INTERNAL_ERROR, NULL);
-                column = ecs_table_type_to_column_index(src_table, column - 1);
-                int32_t *src_dirty_state = flecs_table_get_dirty_state(
-                    world, src_table);
-                if (mon != src_dirty_state[column + 1]) {
-                    return true;
-                }
-            }
-        }
-    }
+    elem->action = action;
+    elem->ctx = ctx;
+error:
+    return;
+}
 
-    if (has_flat) {
-        ecs_entity_filter_t *ef = match->entity_filter;
-        flecs_flat_table_term_t *fields = ecs_vec_first(&ef->ft_terms);
-        ecs_entity_filter_iter_t *ent_it = it->priv.entity_iter;
-        int32_t cur_tgt = ent_it->target_count - 1;
-        field_count = ecs_vec_count(&ef->ft_terms);
+void ecs_run_post_frame(
+    ecs_world_t *world,
+    ecs_fini_action_t action,
+    void *ctx)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(action != NULL, ECS_INVALID_PARAMETER, NULL);
 
-        for (i = 0; i < field_count; i ++) {
-            flecs_flat_table_term_t *field = &fields[i];
-            flecs_flat_monitor_t *fmon = ecs_vec_get_t(&field->monitor, 
-                flecs_flat_monitor_t, cur_tgt);
-            if (fmon->monitor != fmon->table_state) {
-                return true;
-            }
-        }
-    }
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
+    ecs_action_elem_t *elem = ecs_vec_append_t(&stage->allocator,
+        &stage->post_frame_actions, ecs_action_elem_t);
+    ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    return false;
+    elem->action = action;
+    elem->ctx = ctx;
+error:
+    return;
 }
 
-/* Check if any term for matched table has changed */
+/* Unset data in tables */
 static
-bool flecs_query_check_table_monitor(
-    ecs_query_t *query,
-    ecs_query_table_t *table,
-    int32_t term)
+void flecs_fini_unset_tables(
+    ecs_world_t *world)
 {
-    ecs_query_table_match_t *cur, *end = table->last->next;
+    ecs_sparse_t *tables = &world->store.tables;
+    int32_t i, count = flecs_sparse_count(tables);
 
-    for (cur = table->first; cur != end; cur = cur->next) {
-        ecs_query_table_match_t *match = (ecs_query_table_match_t*)cur;
-        if (term == -1) {
-            if (flecs_query_check_match_monitor(query, match, NULL)) {
-                return true;
-            }
-        } else {
-            if (flecs_query_check_match_monitor_term(query, match, term)) {
-                return true;
-            } 
-        }
+    for (i = 0; i < count; i ++) {
+        ecs_table_t *table = flecs_sparse_get_dense_t(tables, ecs_table_t, i);
+        flecs_table_remove_actions(world, table);
     }
-
-    return false;
 }
 
+/* Invoke fini actions */
 static
-bool flecs_query_check_query_monitor(
-    ecs_query_t *query)
+void flecs_fini_actions(
+    ecs_world_t *world)
 {
-    ecs_table_cache_iter_t it;
-    if (flecs_table_cache_iter(&query->cache, &it)) {
-        ecs_query_table_t *qt;
-        while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) {
-            if (flecs_query_check_table_monitor(query, qt, -1)) {
-                return true;
-            }
-        }
+    int32_t i, count = ecs_vec_count(&world->fini_actions);
+    ecs_action_elem_t *elems = ecs_vec_first(&world->fini_actions);
+    for (i = 0; i < count; i ++) {
+        elems[i].action(world, elems[i].ctx);
     }
 
-    return false;
+    ecs_vec_fini_t(NULL, &world->fini_actions, ecs_action_elem_t);
 }
 
+/* Cleanup remaining type info elements */
 static
-void flecs_query_init_query_monitors(
-    ecs_query_t *query)
+void flecs_fini_type_info(
+    ecs_world_t *world)
 {
-    ecs_query_table_match_t *cur = query->list.first;
-
-    /* Ensure each match has a monitor */
-    for (; cur != NULL; cur = cur->next) {
-        ecs_query_table_match_t *match = (ecs_query_table_match_t*)cur;
-        flecs_query_get_match_monitor(query, match);
+    int32_t i, count = flecs_sparse_count(&world->type_info);
+    ecs_sparse_t *type_info = &world->type_info;
+    for (i = 0; i < count; i ++) {
+        ecs_type_info_t *ti = flecs_sparse_get_dense_t(type_info,
+            ecs_type_info_t, i);
+        flecs_type_info_fini(ti);
     }
+    flecs_sparse_fini(&world->type_info);
 }
 
-/* The group by function for cascade computes the tree depth for the table type.
- * This causes tables in the query cache to be ordered by depth, which ensures
- * breadth-first iteration order. */
-static
-uint64_t flecs_query_group_by_cascade(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_id_t id,
-    void *ctx)
-{
-    (void)id;
-    ecs_term_t *term = ctx;
-    ecs_entity_t rel = term->src.trav;
-    int32_t depth = flecs_relation_depth(world, rel, table);
-    return flecs_ito(uint64_t, depth);
-}
-
-static
-void flecs_query_add_ref(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_table_match_t *qm,
-    ecs_entity_t component,
-    ecs_entity_t entity,
-    ecs_size_t size)
+ecs_entity_t flecs_get_oneof(
+    const ecs_world_t *world,
+    ecs_entity_t e)
 {
-    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_ref_t *ref = ecs_vec_append_t(&world->allocator, &qm->refs, ecs_ref_t);
-    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
-    
-    if (size) {
-        *ref = ecs_ref_init_id(world, entity, component);
+    if (ecs_is_alive(world, e)) {
+        if (ecs_has_id(world, e, EcsOneOf)) {
+            return e;
+        } else {
+            return ecs_get_target(world, e, EcsOneOf, 0);
+        }
     } else {
-        *ref = (ecs_ref_t){
-            .entity = entity,
-            .id = 0
-        };
+        return 0;
     }
-
-    query->flags |= EcsQueryHasRefs;
 }
 
-static
-ecs_query_table_match_t* flecs_query_add_table_match(
-    ecs_query_t *query,
-    ecs_query_table_t *qt,
-    ecs_table_t *table)
+/* The destroyer of worlds */
+int ecs_fini(
+    ecs_world_t *world)
 {
-    /* Add match for table. One table can have more than one match, if
-     * the query contains wildcards. */
-    ecs_query_table_match_t *qm = flecs_query_cache_add(query->filter.world, qt);
-    qm->table = table;
-
-    qm->columns = flecs_balloc(&query->allocators.columns);
-    qm->storage_columns = flecs_balloc(&query->allocators.columns);
-    qm->ids = flecs_balloc(&query->allocators.ids);
-    qm->sources = flecs_balloc(&query->allocators.sources);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION,
+        "cannot fini world while it is in readonly mode");
+    ecs_assert(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION,
+        "cannot fini world when it is already being deleted");
+    ecs_assert(world->stages[0]->defer == 0, ECS_INVALID_OPERATION, 
+        "call defer_end before destroying world");
 
-    /* Insert match to iteration list if table is not empty */
-    if (!table || ecs_table_count(table) != 0) {
-        flecs_query_insert_table_node(query, qm);
-    }
+    ecs_trace("#[bold]shutting down world");
+    ecs_log_push();
 
-    return qm;
-}
+    world->flags |= EcsWorldQuit;
 
-static
-void flecs_query_set_table_match(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_table_match_t *qm,
-    ecs_table_t *table,
-    ecs_iter_t *it)
-{
-    ecs_allocator_t *a = &world->allocator;
-    ecs_filter_t *filter = &query->filter;
-    int32_t i, term_count = filter->term_count;
-    int32_t field_count = filter->field_count;
-    ecs_term_t *terms = filter->terms;
+    /* Delete root entities first using regular APIs. This ensures that cleanup
+     * policies get a chance to execute. */
+    ecs_dbg_1("#[bold]cleanup root entities");
+    ecs_log_push_1();
+    flecs_fini_roots(world);
+    ecs_log_pop_1();
 
-    /* Reset resources in case this is an existing record */
-    ecs_vec_reset_t(a, &qm->refs, ecs_ref_t);
-    ecs_os_memcpy_n(qm->columns, it->columns, int32_t, field_count);
-    ecs_os_memcpy_n(qm->ids, it->ids, ecs_id_t, field_count);
-    ecs_os_memcpy_n(qm->sources, it->sources, ecs_entity_t, field_count);
+    world->flags |= EcsWorldFini;
 
-    if (table) {
-        /* Initialize storage columns for faster access to component storage */
-        for (i = 0; i < field_count; i ++) {
-            if (terms[i].inout == EcsInOutNone) {
-                qm->storage_columns[i] = -1;
-                continue;
-            }
+    /* Run fini actions (simple callbacks ran when world is deleted) before
+     * destroying the storage */
+    ecs_dbg_1("#[bold]run fini actions");
+    ecs_log_push_1();
+    flecs_fini_actions(world);
+    ecs_log_pop_1();
 
-            int32_t column = qm->columns[i];
-            if (column > 0) {
-                qm->storage_columns[i] = ecs_table_type_to_column_index(table,
-                    qm->columns[i] - 1);
-            } else {
-                /* Shared field (not from table) */
-                qm->storage_columns[i] = -2;
-            }
-        }
+    ecs_dbg_1("#[bold]cleanup remaining entities");
+    ecs_log_push_1();
 
-        flecs_entity_filter_init(world, &qm->entity_filter, filter, 
-            table, qm->ids, qm->columns);
+    /* Operations invoked during UnSet/OnRemove/destructors are deferred and
+     * will be discarded after world cleanup */
+    flecs_defer_begin(world, world->stages[0]);
 
-        if (qm->entity_filter) {
-            query->flags &= ~EcsQueryTrivialIter;
-        }
-        if (table->flags & EcsTableHasUnion) {
-            query->flags &= ~EcsQueryTrivialIter;
-        }
-    }
+    /* Run UnSet/OnRemove actions for components while the store is still
+     * unmodified by cleanup. */
+    flecs_fini_unset_tables(world);
 
-    /* Add references for substituted terms */
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (!ecs_term_match_this(term)) {
-            /* non-This terms are set during iteration */
-            continue;
-        }
+    /* This will destroy all entities and components. */
+    flecs_fini_store(world);
 
-        int32_t field = terms[i].field_index;
-        ecs_entity_t src = it->sources[field];
-        ecs_size_t size = 0;
-        if (it->sizes) {
-            size = it->sizes[field];
-        }
-        if (src) {
-            ecs_id_t id = it->ids[field];
-            ecs_assert(ecs_is_valid(world, src), ECS_INTERNAL_ERROR, NULL);
+    /* Purge deferred operations from the queue. This discards operations but
+     * makes sure that any resources in the queue are freed */
+    flecs_defer_purge(world, world->stages[0]);
+    ecs_log_pop_1();
 
-            if (id) {
-                flecs_query_add_ref(world, query, qm, id, src, size);
+    /* All queries are cleaned up, so monitors should've been cleaned up too */
+    ecs_assert(!ecs_map_is_init(&world->monitors.monitors),
+        ECS_INTERNAL_ERROR, NULL);
 
-                /* Use column index to bind term and ref */
-                if (qm->columns[field] != 0) {
-                    qm->columns[field] = -ecs_vec_count(&qm->refs);
-                }
-            }
-        }
+    /* Cleanup world ctx and binding_ctx */
+    if (world->ctx_free) {
+        world->ctx_free(world->ctx);
+    }
+    if (world->binding_ctx_free) {
+        world->binding_ctx_free(world->binding_ctx);
     }
+
+    /* After this point no more user code is invoked */
+
+    ecs_dbg_1("#[bold]cleanup world data structures");
+    ecs_log_push_1();
+    flecs_entities_fini(world);
+    flecs_sparse_fini(world->pending_tables);
+    flecs_sparse_fini(world->pending_buffer);
+    ecs_os_free(world->pending_tables);
+    ecs_os_free(world->pending_buffer);
+    flecs_fini_id_records(world);
+    flecs_fini_type_info(world);
+    flecs_observable_fini(&world->observable);
+    flecs_name_index_fini(&world->aliases);
+    flecs_name_index_fini(&world->symbols);
+    ecs_set_stage_count(world, 0);
+    ecs_log_pop_1();
+
+    flecs_world_allocators_fini(world);
+
+    /* End of the world */
+    flecs_poly_free(world, ecs_world_t);
+    ecs_os_fini();
+
+    ecs_trace("world destroyed, bye!");
+    ecs_log_pop();
+
+    return 0;
 }
 
-static
-ecs_query_table_t* flecs_query_table_insert(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_table_t *table)
+bool ecs_is_fini(
+    const ecs_world_t *world)
 {
-    ecs_query_table_t *qt = flecs_bcalloc(&world->allocators.query_table);
-    if (table) {
-        qt->table_id = table->id;
-    } else {
-        qt->table_id = 0;
-    }
-    ecs_table_cache_insert(&query->cache, table, &qt->hdr);
-    return qt;
+    ecs_assert(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    world = ecs_get_world(world);
+    return ECS_BIT_IS_SET(world->flags, EcsWorldFini);
 }
 
-/** Populate query cache with tables */
-static
-void flecs_query_match_tables(
+void ecs_dim(
     ecs_world_t *world,
-    ecs_query_t *query)
+    int32_t entity_count)
 {
-    ecs_table_t *table = NULL;
-    ecs_query_table_t *qt = NULL;
+    flecs_poly_assert(world, ecs_world_t);
+    flecs_entities_set_size(world, entity_count + FLECS_HI_COMPONENT_ID);
+}
 
-    ecs_iter_t it = flecs_filter_iter_w_flags(world, &query->filter, 0);
-    ECS_BIT_SET(it.flags, EcsIterIsInstanced);
-    ECS_BIT_SET(it.flags, EcsIterNoData);
-    ECS_BIT_SET(it.flags, EcsIterTableOnly);
-    ECS_BIT_SET(it.flags, EcsIterEntityOptional);
+void flecs_eval_component_monitors(
+    ecs_world_t *world)
+{
+    flecs_poly_assert(world, ecs_world_t); 
+    flecs_process_pending_tables(world);  
+    flecs_eval_component_monitor(world);
+}
 
-    while (ecs_filter_next(&it)) {
-        if ((table != it.table) || (!it.table && !qt)) {
-            /* New table matched, add record to cache */
-            table = it.table;
-            qt = flecs_query_table_insert(world, query, table);
-        }
+void ecs_measure_frame_time(
+    ecs_world_t *world,
+    bool enable)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL);
 
-        ecs_query_table_match_t *qm = flecs_query_add_table_match(query, qt, table);
-        flecs_query_set_table_match(world, query, qm, table, &it);
+    if (ECS_EQZERO(world->info.target_fps) || enable) {
+        ECS_BIT_COND(world->flags, EcsWorldMeasureFrameTime, enable);
     }
+error:
+    return;
 }
 
-static
-bool flecs_query_match_table(
+void ecs_measure_system_time(
     ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_table_t *table)
+    bool enable)
 {
-    if (!ecs_map_is_init(&query->cache.index)) {
-        return false;
-    }
-
-    ecs_query_table_t *qt = NULL;
-    ecs_filter_t *filter = &query->filter;
-    int var_id = ecs_filter_find_this_var(filter);
-    if (var_id == -1) {
-        /* If query doesn't match with This term, it can't match with tables */
-        return false;
-    }
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL);
+    ECS_BIT_COND(world->flags, EcsWorldMeasureSystemTime, enable);
+error:
+    return;
+}
 
-    ecs_iter_t it = flecs_filter_iter_w_flags(world, filter, EcsIterMatchVar|
-        EcsIterIsInstanced|EcsIterNoData|EcsIterEntityOptional);
-    ecs_iter_set_var_as_table(&it, var_id, table);
+void ecs_set_target_fps(
+    ecs_world_t *world,
+    ecs_ftime_t fps)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL);
 
-    while (ecs_filter_next(&it)) {
-        ecs_assert(it.table == table, ECS_INTERNAL_ERROR, NULL);
-        if (qt == NULL) {
-            table = it.table;
-            qt = flecs_query_table_insert(world, query, table);
-        }
+    ecs_measure_frame_time(world, true);
+    world->info.target_fps = fps;
+error:
+    return;
+}
 
-        ecs_query_table_match_t *qm = flecs_query_add_table_match(query, qt, table);
-        flecs_query_set_table_match(world, query, qm, table, &it);
-    }
+void* ecs_get_ctx(
+    const ecs_world_t *world)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    world = ecs_get_world(world);
+    return world->ctx;
+error:
+    return NULL;
+}
 
-    return qt != NULL;
+void* ecs_get_binding_ctx(
+    const ecs_world_t *world)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    world = ecs_get_world(world);
+    return world->binding_ctx;
+error:
+    return NULL;
 }
 
-ECS_SORT_TABLE_WITH_COMPARE(_, flecs_query_sort_table_generic, order_by, static)
+void ecs_set_ctx(
+    ecs_world_t *world,
+    void *ctx,
+    ecs_ctx_free_t ctx_free)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    world->ctx = ctx;
+    world->ctx_free = ctx_free;
+}
 
-static
-void flecs_query_sort_table(
+void ecs_set_binding_ctx(
     ecs_world_t *world,
-    ecs_table_t *table,
-    int32_t column_index,
-    ecs_order_by_action_t compare,
-    ecs_sort_table_action_t sort)
+    void *ctx,
+    ecs_ctx_free_t ctx_free)
 {
-    ecs_data_t *data = &table->data;
-    if (!ecs_vec_count(&data->entities)) {
-        /* Nothing to sort */
-        return;
-    }
+    flecs_poly_assert(world, ecs_world_t);
+    world->binding_ctx = ctx;
+    world->binding_ctx_free = ctx_free;
+}
 
-    int32_t count = flecs_table_data_count(data);
-    if (count < 2) {
-        return;
-    }
+void ecs_set_entity_range(
+    ecs_world_t *world,
+    ecs_entity_t id_start,
+    ecs_entity_t id_end)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(!id_end || id_end > id_start, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!id_end || id_end > flecs_entities_max_id(world),
+        ECS_INVALID_PARAMETER, NULL);
 
-    ecs_entity_t *entities = ecs_vec_first(&data->entities);
+    uint32_t start = (uint32_t)id_start;
+    uint32_t end = (uint32_t)id_end;
 
-    void *ptr = NULL;
-    int32_t size = 0;
-    if (column_index != -1) {
-        ecs_column_t *column = &data->columns[column_index];
-        ecs_type_info_t *ti = column->ti;
-        size = ti->size;
-        ptr = ecs_vec_first(&column->data);
+    if (flecs_entities_max_id(world) < start) {
+        flecs_entities_max_id(world) = start - 1;
     }
 
-    if (sort) {
-        sort(world, table, entities, ptr, size, 0, count - 1, compare);
-    } else {
-        flecs_query_sort_table_generic(world, table, entities, ptr, size, 0, count - 1, compare);
-    }
+    world->info.min_id = start;
+    world->info.max_id = end;
+error:
+    return;
 }
 
-/* Helper struct for building sorted table ranges */
-typedef struct sort_helper_t {
-    ecs_query_table_match_t *match;
-    ecs_entity_t *entities;
-    const void *ptr;
-    int32_t row;
-    int32_t elem_size;
-    int32_t count;
-    bool shared;
-} sort_helper_t;
-
-static
-const void* ptr_from_helper(
-    sort_helper_t *helper)
+bool ecs_enable_range_check(
+    ecs_world_t *world,
+    bool enable)
 {
-    ecs_assert(helper->row < helper->count, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(helper->elem_size >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(helper->row >= 0, ECS_INTERNAL_ERROR, NULL);
-    if (helper->shared) {
-        return helper->ptr;
-    } else {
-        return ECS_ELEM(helper->ptr, helper->elem_size, helper->row);
-    }
+    flecs_poly_assert(world, ecs_world_t);    
+    bool old_value = world->range_check_enabled;
+    world->range_check_enabled = enable;
+    return old_value;
 }
 
-static
-ecs_entity_t e_from_helper(
-    sort_helper_t *helper)
+ecs_entity_t ecs_get_max_id(
+    const ecs_world_t *world)
 {
-    if (helper->row < helper->count) {
-        return helper->entities[helper->row];
-    } else {
-        return 0;
-    }
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    world = ecs_get_world(world);
+    return flecs_entities_max_id(world);
+error:
+    return 0;
 }
 
-static
-void flecs_query_build_sorted_table_range(
-    ecs_query_t *query,
-    ecs_query_table_list_t *list)
+const ecs_type_info_t* flecs_type_info_get(
+    const ecs_world_t *world,
+    ecs_entity_t component)
 {
-    ecs_world_t *world = query->filter.world;
-    ecs_assert(!(world->flags & EcsWorldMultiThreaded), ECS_UNSUPPORTED,
-        "cannot sort query in multithreaded mode");
-
-    ecs_entity_t id = query->order_by_component;
-    ecs_order_by_action_t compare = query->order_by;
-    int32_t table_count = list->info.table_count;
-    if (!table_count) {
-        return;
-    }
-
-    ecs_vec_init_if_t(&query->table_slices, ecs_query_table_match_t);
-    int32_t to_sort = 0;
-    int32_t order_by_term = query->order_by_term;
+    flecs_poly_assert(world, ecs_world_t);   
 
-    sort_helper_t *helper = flecs_alloc_n(
-        &world->allocator, sort_helper_t, table_count);
-    ecs_query_table_match_t *cur, *end = list->last->next;
-    for (cur = list->first; cur != end; cur = cur->next) {
-        ecs_table_t *table = cur->table;
-        ecs_data_t *data = &table->data;
+    ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!(component & ECS_ID_FLAGS_MASK), ECS_INTERNAL_ERROR, NULL);
 
-        ecs_assert(ecs_table_count(table) != 0, ECS_INTERNAL_ERROR, NULL);
+    return flecs_sparse_try_t(&world->type_info, ecs_type_info_t, component);
+}
 
-        if (id) {
-            const ecs_term_t *term = &query->filter.terms[order_by_term];
-            int32_t field = term->field_index;
-            int32_t column = cur->columns[field];
-            ecs_size_t size = query->filter.sizes[field];
-            ecs_assert(column != 0, ECS_INTERNAL_ERROR, NULL);
-            if (column >= 0) {
-                column = table->column_map[column - 1];
-                ecs_vec_t *vec = &data->columns[column].data;
-                helper[to_sort].ptr = ecs_vec_first(vec);
-                helper[to_sort].elem_size = size;
-                helper[to_sort].shared = false;
-            } else {
-                ecs_entity_t src = cur->sources[field];
-                ecs_assert(src != 0, ECS_INTERNAL_ERROR, NULL);
-                ecs_record_t *r = flecs_entities_get(world, src);
-                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-                ecs_assert(r->table != NULL, ECS_INTERNAL_ERROR, NULL);
+ecs_type_info_t* flecs_type_info_ensure(
+    ecs_world_t *world,
+    ecs_entity_t component)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL);
 
-                if (term->src.flags & EcsUp) {
-                    ecs_entity_t base = 0;
-                    ecs_search_relation(world, r->table, 0, id, 
-                        EcsIsA, term->src.flags & EcsTraverseFlags, &base, 0, 0);
-                    if (base && base != src) { /* Component could be inherited */
-                        r = flecs_entities_get(world, base);
-                    }
-                }
+    const ecs_type_info_t *ti = flecs_type_info_get(world, component);
+    ecs_type_info_t *ti_mut = NULL;
+    if (!ti) {
+        ti_mut = flecs_sparse_ensure_t(
+            &world->type_info, ecs_type_info_t, component);
+        ecs_assert(ti_mut != NULL, ECS_INTERNAL_ERROR, NULL);
+        ti_mut->component = component;
+    } else {
+        ti_mut = ECS_CONST_CAST(ecs_type_info_t*, ti);
+    }
 
-                helper[to_sort].ptr = ecs_table_get_id(
-                    world, r->table, id, ECS_RECORD_TO_ROW(r->row));
-                helper[to_sort].elem_size = size;
-                helper[to_sort].shared = true;
-            }
-            ecs_assert(helper[to_sort].ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(helper[to_sort].elem_size != 0, ECS_INTERNAL_ERROR, NULL);
+    if (!ti_mut->name) {
+        const char *sym = ecs_get_symbol(world, component);
+        if (sym) {
+            ti_mut->name = ecs_os_strdup(sym);
         } else {
-            helper[to_sort].ptr = NULL;
-            helper[to_sort].elem_size = 0;
-            helper[to_sort].shared = false;
+            const char *name = ecs_get_name(world, component);
+            if (name) {
+                ti_mut->name = ecs_os_strdup(name);
+            }
         }
-
-        helper[to_sort].match = cur;
-        helper[to_sort].entities = ecs_vec_first(&data->entities);
-        helper[to_sort].row = 0;
-        helper[to_sort].count = ecs_table_count(table);
-        to_sort ++;      
     }
 
-    ecs_assert(to_sort != 0, ECS_INTERNAL_ERROR, NULL);
+    return ti_mut;
+}
 
-    bool proceed;
-    do {
-        int32_t j, min = 0;
-        proceed = true;
+bool flecs_type_info_init_id(
+    ecs_world_t *world,
+    ecs_entity_t component,
+    ecs_size_t size,
+    ecs_size_t alignment,
+    const ecs_type_hooks_t *li)
+{
+    bool changed = false;
 
-        ecs_entity_t e1;
-        while (!(e1 = e_from_helper(&helper[min]))) {
-            min ++;
-            if (min == to_sort) {
-                proceed = false;
-                break;
-            }
-        }
+    flecs_entities_ensure(world, component);
 
-        if (!proceed) {
-            break;
+    ecs_type_info_t *ti = NULL;
+    if (!size || !alignment) {
+        ecs_assert(size == 0 && alignment == 0,
+            ECS_INVALID_COMPONENT_SIZE, NULL);
+        ecs_assert(li == NULL, ECS_INCONSISTENT_COMPONENT_ACTION, NULL);
+        flecs_sparse_remove_t(&world->type_info, ecs_type_info_t, component);
+    } else {
+        ti = flecs_type_info_ensure(world, component);
+        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+        changed |= ti->size != size;
+        changed |= ti->alignment != alignment;
+        ti->size = size;
+        ti->alignment = alignment;
+        if (li) {
+            ecs_set_hooks_id(world, component, li);
         }
+    }
 
-        for (j = min + 1; j < to_sort; j++) {
-            ecs_entity_t e2 = e_from_helper(&helper[j]);
-            if (!e2) {
-                continue;
-            }
-
-            const void *ptr1 = ptr_from_helper(&helper[min]);
-            const void *ptr2 = ptr_from_helper(&helper[j]);
+    /* Set type info for id record of component */
+    ecs_id_record_t *idr = flecs_id_record_ensure(world, component);
+    changed |= flecs_id_record_set_type_info(world, idr, ti);
+    bool is_tag = idr->flags & EcsIdTag;
 
-            if (compare(e1, ptr1, e2, ptr2) > 0) {
-                min = j;
-                e1 = e_from_helper(&helper[min]);
-            }
+    /* All id records with component as relationship inherit type info */
+    idr = flecs_id_record_ensure(world, ecs_pair(component, EcsWildcard));
+    do {
+        if (is_tag) {
+            changed |= flecs_id_record_set_type_info(world, idr, NULL);
+        } else if (ti) {
+            changed |= flecs_id_record_set_type_info(world, idr, ti);
+        } else if ((idr->type_info != NULL) &&
+            (idr->type_info->component == component))
+        {
+            changed |= flecs_id_record_set_type_info(world, idr, NULL);
         }
+    } while ((idr = idr->first.next));
 
-        sort_helper_t *cur_helper = &helper[min];
-        if (!cur || cur->columns != cur_helper->match->columns) {
-            cur = ecs_vec_append_t(NULL, &query->table_slices, 
-                ecs_query_table_match_t);
-            *cur = *(cur_helper->match);
-            cur->offset = cur_helper->row;
-            cur->count = 1;
-        } else {
-            cur->count ++;
+    /* All non-tag id records with component as object inherit type info,
+     * if relationship doesn't have type info */
+    idr = flecs_id_record_ensure(world, ecs_pair(EcsWildcard, component));
+    do {
+        if (!(idr->flags & EcsIdTag) && !idr->type_info) {
+            changed |= flecs_id_record_set_type_info(world, idr, ti);
         }
+    } while ((idr = idr->first.next));
 
-        cur_helper->row ++;
-    } while (proceed);
-
-    /* Iterate through the vector of slices to set the prev/next ptrs. This
-     * can't be done while building the vector, as reallocs may occur */
-    int32_t i, count = ecs_vec_count(&query->table_slices);    
-    ecs_query_table_match_t *nodes = ecs_vec_first(&query->table_slices);
-    for (i = 0; i < count; i ++) {
-        nodes[i].prev = &nodes[i - 1];
-        nodes[i].next = &nodes[i + 1];
-    }
-
-    nodes[0].prev = NULL;
-    nodes[i - 1].next = NULL;
+    /* Type info of (*, component) should always point to component */
+    ecs_assert(flecs_id_record_get(world, ecs_pair(EcsWildcard, component))->
+        type_info == ti, ECS_INTERNAL_ERROR, NULL);
 
-    flecs_free_n(&world->allocator, sort_helper_t, table_count, helper);
+    return changed;
 }
 
-static
-void flecs_query_build_sorted_tables(
-    ecs_query_t *query)
+void flecs_type_info_fini(
+    ecs_type_info_t *ti)
 {
-    ecs_vec_clear(&query->table_slices);
-
-    if (query->group_by) {
-        /* Populate sorted node list in grouping order */
-        ecs_query_table_match_t *cur = query->list.first;
-        if (cur) {
-            do {
-                /* Find list for current group */
-                uint64_t group_id = cur->group_id;
-                ecs_query_table_list_t *list = ecs_map_get_deref(
-                    &query->groups, ecs_query_table_list_t, group_id);
-                ecs_assert(list != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (ti->hooks.ctx_free) {
+        ti->hooks.ctx_free(ti->hooks.ctx);
+    }
+    if (ti->hooks.binding_ctx_free) {
+        ti->hooks.binding_ctx_free(ti->hooks.binding_ctx);
+    }
+    if (ti->name) {
+        /* Safe to cast away const, world has ownership over string */
+        ecs_os_free(ECS_CONST_CAST(char*, ti->name));
+        ti->name = NULL;
+    }
+}
 
-                /* Sort tables in current group */
-                flecs_query_build_sorted_table_range(query, list);
+void flecs_type_info_free(
+    ecs_world_t *world,
+    ecs_entity_t component)
+{
+    if (world->flags & EcsWorldQuit) {
+        /* If world is in the final teardown stages, cleanup policies are no
+         * longer applied and it can't be guaranteed that a component is not
+         * deleted before entities that use it. The remaining type info elements
+         * will be deleted after the store is finalized. */
+        return;
+    }
 
-                /* Find next group to sort */
-                cur = list->last->next;
-            } while (cur);
-        }
-    } else {
-        flecs_query_build_sorted_table_range(query, &query->list);
+    ecs_type_info_t *ti = flecs_sparse_try_t(&world->type_info,
+        ecs_type_info_t, component);
+    if (ti) {
+        flecs_type_info_fini(ti);
+        flecs_sparse_remove_t(&world->type_info, ecs_type_info_t, component);
     }
 }
 
 static
-void flecs_query_sort_tables(
+ecs_ftime_t flecs_insert_sleep(
     ecs_world_t *world,
-    ecs_query_t *query)
+    ecs_time_t *stop)
 {
-    ecs_order_by_action_t compare = query->order_by;
-    if (!compare) {
-        return;
-    }
+    flecs_poly_assert(world, ecs_world_t);  
 
-    ecs_sort_table_action_t sort = query->sort_table;
-    ecs_entity_t order_by_component = query->order_by_component;
-    int32_t order_by_term = query->order_by_term;
+    ecs_time_t start = *stop, now = start;
+    ecs_ftime_t delta_time = (ecs_ftime_t)ecs_time_measure(stop);
 
-    /* Iterate over non-empty tables. Don't bother with empty tables as they
-     * have nothing to sort */
+    if (ECS_EQZERO(world->info.target_fps)) {
+        return delta_time;
+    }
 
-    bool tables_sorted = false;
+    ecs_ftime_t target_delta_time =
+        ((ecs_ftime_t)1.0 / (ecs_ftime_t)world->info.target_fps);
 
-    ecs_id_record_t *idr = flecs_id_record_get(world, order_by_component);
-    ecs_table_cache_iter_t it;
-    ecs_query_table_t *qt;
-    flecs_table_cache_iter(&query->cache, &it);
+    /* Calculate the time we need to sleep by taking the measured delta from the
+     * previous frame, and subtracting it from target_delta_time. */
+    ecs_ftime_t sleep = target_delta_time - delta_time;
 
-    while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) {
-        ecs_table_t *table = qt->hdr.table;
-        bool dirty = false;
+    /* Pick a sleep interval that is 4 times smaller than the time one frame
+     * should take. */
+    ecs_ftime_t sleep_time = sleep / (ecs_ftime_t)4.0;
 
-        if (flecs_query_check_table_monitor(query, qt, 0)) {
-            tables_sorted = true; /* Ensure ranges are rebuilt */
-            dirty = true;
+    do {
+        /* Only call sleep when sleep_time is not 0. On some platforms, even
+         * a sleep with a timeout of 0 can cause stutter. */
+        if (ECS_NEQZERO(sleep_time)) {
+            ecs_sleepf((double)sleep_time);
         }
 
-        int32_t column = -1;
-        if (order_by_component) {
-            if (flecs_query_check_table_monitor(query, qt, order_by_term + 1)) {
-                dirty = true;
-            }
+        now = start;
+        delta_time = (ecs_ftime_t)ecs_time_measure(&now);
+    } while ((target_delta_time - delta_time) >
+        (sleep_time / (ecs_ftime_t)2.0));
 
-            if (dirty) {
-                column = -1;
+    *stop = now;
+    return delta_time;
+}
 
-                const ecs_table_record_t *tr = flecs_id_record_get_table(
-                    idr, table);
-                if (tr) {
-                    column = tr->column;
-                }
+static
+ecs_ftime_t flecs_start_measure_frame(
+    ecs_world_t *world,
+    ecs_ftime_t user_delta_time)
+{
+    flecs_poly_assert(world, ecs_world_t);  
 
-                if (column == -1) {
-                    /* Component is shared, no sorting is needed */
-                    dirty = false;
+    ecs_ftime_t delta_time = 0;
+
+    if ((world->flags & EcsWorldMeasureFrameTime) ||
+        (ECS_EQZERO(user_delta_time)))
+    {
+        ecs_time_t t = world->frame_start_time;
+        do {
+            if (world->frame_start_time.nanosec || world->frame_start_time.sec){
+                delta_time = flecs_insert_sleep(world, &t);
+            } else {
+                ecs_time_measure(&t);
+                if (ECS_NEQZERO(world->info.target_fps)) {
+                    delta_time = (ecs_ftime_t)1.0 / world->info.target_fps;
+                } else {
+                    /* Best guess */
+                    delta_time = (ecs_ftime_t)1.0 / (ecs_ftime_t)60.0;
+
+                    if (ECS_EQZERO(delta_time)) {
+                        delta_time = user_delta_time;
+                        break;
+                    }
                 }
             }
-        }
-
-        if (!dirty) {
-            continue;
-        }
 
-        /* Something has changed, sort the table. Prefers using 
-         * flecs_query_sort_table when available */
-        flecs_query_sort_table(world, table, column, compare, sort);
-        tables_sorted = true;
-    }
+        /* Keep trying while delta_time is zero */
+        } while (ECS_EQZERO(delta_time));
 
-    if (tables_sorted || query->match_count != query->prev_match_count) {
-        flecs_query_build_sorted_tables(query);
-        query->match_count ++; /* Increase version if tables changed */
-    }
-}
+        world->frame_start_time = t;
 
-static
-bool flecs_query_has_refs(
-    ecs_query_t *query)
-{
-    ecs_term_t *terms = query->filter.terms;
-    int32_t i, count = query->filter.term_count;
-    for (i = 0; i < count; i ++) {
-        if (terms[i].src.flags & (EcsUp | EcsIsEntity)) {
-            return true;
-        }
+        /* Keep track of total time passed in world */
+        world->info.world_time_total_raw += (ecs_ftime_t)delta_time;
     }
 
-    return false;
+    return (ecs_ftime_t)delta_time;
 }
 
 static
-void flecs_query_for_each_component_monitor(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    void(*callback)(
-        ecs_world_t* world,
-        ecs_id_t id,
-        ecs_query_t *query))
+void flecs_stop_measure_frame(
+    ecs_world_t* world)
 {
-    ecs_term_t *terms = query->filter.terms;
-    int32_t i, count = query->filter.term_count;
+    flecs_poly_assert(world, ecs_world_t);  
 
-    for (i = 0; i < count; i++) {
-        ecs_term_t *term = &terms[i];
-        ecs_term_id_t *src = &term->src;
-
-        if (src->flags & EcsUp) {
-            callback(world, ecs_pair(src->trav, EcsWildcard), query);
-            if (src->trav != EcsIsA) {
-                callback(world, ecs_pair(EcsIsA, EcsWildcard), query);
-            }
-            callback(world, term->id, query);
-
-        } else if (src->flags & EcsSelf && !ecs_term_match_this(term)) {
-            callback(world, term->id, query);
-        }
-    }
-}
-
-static
-bool flecs_query_is_term_id_supported(
-    ecs_term_id_t *term_id)
-{
-    if (!(term_id->flags & EcsIsVariable)) {
-        return true;
-    }
-    if (ecs_id_is_wildcard(term_id->id)) {
-        return true;
+    if (world->flags & EcsWorldMeasureFrameTime) {
+        ecs_time_t t = world->frame_start_time;
+        world->info.frame_time_total += (ecs_ftime_t)ecs_time_measure(&t);
     }
-    return false;
 }
 
-static
-int flecs_query_process_signature(
+ecs_ftime_t ecs_frame_begin(
     ecs_world_t *world,
-    ecs_query_t *query)
+    ecs_ftime_t user_delta_time)
 {
-    ecs_term_t *terms = query->filter.terms;
-    int32_t i, count = query->filter.term_count;
-
-    for (i = 0; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-        ecs_term_id_t *first = &term->first;
-        ecs_term_id_t *src = &term->src;
-        ecs_term_id_t *second = &term->second;
-        ecs_inout_kind_t inout = term->inout;
-
-        bool is_src_ok = flecs_query_is_term_id_supported(src);
-        bool is_first_ok = flecs_query_is_term_id_supported(first);
-        bool is_second_ok = flecs_query_is_term_id_supported(second);
-
-        (void)first;
-        (void)second;
-        (void)is_src_ok;
-        (void)is_first_ok;
-        (void)is_second_ok;
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, 
+        "cannot begin frame while world is in readonly mode");
+    ecs_check(ECS_NEQZERO(user_delta_time) || ecs_os_has_time(), 
+        ECS_MISSING_OS_API, "get_time");
 
-        /* Queries do not support named variables */
-        ecs_check(is_src_ok || ecs_term_match_this(term),
-            ECS_UNSUPPORTED, NULL);
-        ecs_check(is_first_ok, ECS_UNSUPPORTED, NULL);
-        ecs_check(is_second_ok,  ECS_UNSUPPORTED, NULL);
-        ecs_check(!(src->flags & EcsFilter), ECS_INVALID_PARAMETER,
-            "invalid usage of Filter for query");
+    /* Start measuring total frame time */
+    ecs_ftime_t delta_time = flecs_start_measure_frame(world, user_delta_time);
+    if (ECS_EQZERO(user_delta_time)) {
+        user_delta_time = delta_time;
+    }
 
-        if (inout != EcsIn && inout != EcsInOutNone) {
-            /* Non-this terms default to EcsIn */
-            if (ecs_term_match_this(term) || inout != EcsInOutDefault) {
-                query->flags |= EcsQueryHasOutTerms;
-            }
+    world->info.delta_time_raw = user_delta_time;
+    world->info.delta_time = user_delta_time * world->info.time_scale;
 
-            bool match_non_this = !ecs_term_match_this(term) || 
-                (term->src.flags & EcsUp);
-            if (match_non_this && inout != EcsInOutDefault) {
-                query->flags |= EcsQueryHasNonThisOutTerms;
-            }
-        }
+    /* Keep track of total scaled time passed in world */
+    world->info.world_time_total += world->info.delta_time;
 
-        if (src->flags & EcsCascade) {
-            /* Query can only have one cascade column */
-            ecs_assert(query->cascade_by == 0, ECS_INVALID_PARAMETER, NULL);
-            query->cascade_by = i + 1;
-        }
-    }
+    /* Command buffer capturing */
+    world->on_commands_active = world->on_commands;
+    world->on_commands = NULL;
 
-    query->flags |= (ecs_flags32_t)(flecs_query_has_refs(query) * EcsQueryHasRefs);
+    world->on_commands_ctx_active = world->on_commands_ctx;
+    world->on_commands_ctx = NULL;
 
-    if (!(query->flags & EcsQueryIsSubquery)) {
-        flecs_query_for_each_component_monitor(world, query, flecs_monitor_register);
-    }
+    ecs_run_aperiodic(world, 0);
 
-    return 0;
+    return world->info.delta_time;
 error:
-    return -1;
+    return (ecs_ftime_t)0;
 }
 
-/** When a table becomes empty remove it from the query list, or vice versa. */
-static
-void flecs_query_update_table(
-    ecs_query_t *query,
-    ecs_table_t *table,
-    bool empty)
+void ecs_frame_end(
+    ecs_world_t *world)
 {
-    int32_t prev_count = ecs_query_table_count(query);
-    ecs_table_cache_set_empty(&query->cache, table, empty);
-    int32_t cur_count = ecs_query_table_count(query);
-
-    if (prev_count != cur_count) {
-        ecs_query_table_t *qt = ecs_table_cache_get(&query->cache, table);
-        ecs_assert(qt != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_query_table_match_t *cur, *next;
-
-        for (cur = qt->first; cur != NULL; cur = next) {
-            next = cur->next_match;
-
-            if (empty) {
-                ecs_assert(ecs_table_count(table) == 0, 
-                    ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, 
+        "cannot end frame while world is in readonly mode");
 
-                flecs_query_remove_table_node(query, cur);
-            } else {
-                ecs_assert(ecs_table_count(table) != 0, 
-                    ECS_INTERNAL_ERROR, NULL);
-                flecs_query_insert_table_node(query, cur);
-            }
-        }
+    world->info.frame_count_total ++;
+    
+    int32_t i, count = world->stage_count;
+    for (i = 0; i < count; i ++) {
+        flecs_stage_merge_post_frame(world, world->stages[i]);
     }
 
-    ecs_assert(cur_count || query->list.first == NULL, 
-        ECS_INTERNAL_ERROR, NULL);
-}
-
-static
-void flecs_query_add_subquery(
-    ecs_world_t *world, 
-    ecs_query_t *parent, 
-    ecs_query_t *subquery) 
-{
-    ecs_vec_init_if_t(&parent->subqueries, ecs_query_t*);
-    ecs_query_t **elem = ecs_vec_append_t(
-        NULL, &parent->subqueries, ecs_query_t*);
-    *elem = subquery;
+    flecs_stop_measure_frame(world);
 
-    ecs_table_cache_t *cache = &parent->cache;
-    ecs_table_cache_iter_t it;
-    ecs_query_table_t *qt;
-    flecs_table_cache_all_iter(cache, &it);
-    while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) {
-        flecs_query_match_table(world, subquery, qt->hdr.table);
-    }
+    /* Reset command handler each frame */
+    world->on_commands_active = NULL;
+    world->on_commands_ctx_active = NULL;
+error:
+    return;
 }
 
-static
-void flecs_query_notify_subqueries(
+void flecs_delete_table(
     ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_event_t *event)
+    ecs_table_t *table)
 {
-    if (query->subqueries.array) {
-        ecs_query_t **queries = ecs_vec_first(&query->subqueries);
-        int32_t i, count = ecs_vec_count(&query->subqueries);
-
-        ecs_query_event_t sub_event = *event;
-        sub_event.parent_query = query;
-
-        for (i = 0; i < count; i ++) {
-            ecs_query_t *sub = queries[i];
-            flecs_query_notify(world, sub, &sub_event);
-        }
-    }
+    flecs_poly_assert(world, ecs_world_t); 
+    flecs_table_fini(world, table);
 }
 
-/* Remove table */
 static
-void flecs_query_table_match_free(
-    ecs_query_t *query,
-    ecs_query_table_t *elem,
-    ecs_query_table_match_t *first)
+void flecs_process_empty_queries(
+    ecs_world_t *world)
 {
-    ecs_query_table_match_t *cur, *next;
-    ecs_world_t *world = query->filter.world;
+    flecs_poly_assert(world, ecs_world_t); 
 
-    for (cur = first; cur != NULL; cur = next) {
-        flecs_bfree(&query->allocators.columns, cur->columns);
-        flecs_bfree(&query->allocators.columns, cur->storage_columns);
-        flecs_bfree(&query->allocators.ids, cur->ids);
-        flecs_bfree(&query->allocators.sources, cur->sources);
+    ecs_id_record_t *idr = flecs_id_record_get(world,
+        ecs_pair(ecs_id(EcsPoly), EcsQuery));
+    if (!idr) {
+        return;
+    }
 
-        if (cur->monitor) {
-            flecs_bfree(&query->allocators.monitors, cur->monitor);
-        }
-        if (!elem->hdr.empty) {
-            flecs_query_remove_table_node(query, cur);
-        }
-        
-        ecs_vec_fini_t(&world->allocator, &cur->refs, ecs_ref_t);
-        flecs_entity_filter_fini(world, cur->entity_filter);
+    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
 
-        next = cur->next_match;
+    /* Make sure that we defer adding the inactive tags until after iterating
+     * the query */
+    flecs_defer_begin(world, world->stages[0]);
 
-        flecs_bfree(&world->allocators.query_table_match, cur);
+    ecs_table_cache_iter_t it;
+    const ecs_table_record_t *tr;
+    if (flecs_table_cache_iter(&idr->cache, &it)) {
+        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+            ecs_table_t *table = tr->hdr.table;
+            EcsPoly *queries = ecs_table_get_column(table, tr->column, 0);
+            int32_t i, count = ecs_table_count(table);
+
+            for (i = 0; i < count; i ++) {
+                ecs_query_t *query = queries[i].poly;
+                ecs_entity_t *entities = table->data.entities.array;
+                if (!ecs_query_is_true(query)) {
+                    ecs_add_id(world, entities[i], EcsEmpty);
+                }
+            }
+        }
     }
-}
 
-static
-void flecs_query_table_free(
-    ecs_query_t *query,
-    ecs_query_table_t *elem)
-{
-    flecs_query_table_match_free(query, elem, elem->first);
-    flecs_bfree(&query->filter.world->allocators.query_table, elem);
+    flecs_defer_end(world, world->stages[0]);
 }
 
-static
-void flecs_query_unmatch_table(
-    ecs_query_t *query,
-    ecs_table_t *table,
-    ecs_query_table_t *elem)
+/** Walk over tables that had a state change which requires bookkeeping */
+void flecs_process_pending_tables(
+    const ecs_world_t *world_r)
 {
-    if (!elem) {
-        elem = ecs_table_cache_get(&query->cache, table);
-    }
-    if (elem) {
-        ecs_table_cache_remove(&query->cache, elem->table_id, &elem->hdr);
-        flecs_query_table_free(query, elem);
+    flecs_poly_assert(world_r, ecs_world_t);
+
+    /* We can't update the administration while in readonly mode, but we can
+     * ensure that when this function is called there are no pending events. */
+    if (world_r->flags & EcsWorldReadonly) {
+        ecs_assert(flecs_sparse_count(world_r->pending_tables) == 0,
+            ECS_INTERNAL_ERROR, NULL);
+        return;
     }
-}
 
-/* Rematch system with tables after a change happened to a watched entity */
-static
-void flecs_query_rematch_tables(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_t *parent_query)
-{
-    ecs_iter_t it, parent_it;
-    ecs_table_t *table = NULL;
-    ecs_query_table_t *qt = NULL;
-    ecs_query_table_match_t *qm = NULL;
+    /* Safe to cast, world is not readonly */
+    ecs_world_t *world = ECS_CONST_CAST(ecs_world_t*, world_r);
 
-    if (query->monitor_generation == world->monitor_generation) {
+    /* If pending buffer is NULL there already is a stackframe that's iterating
+     * the table list. This can happen when an observer for a table event results
+     * in a mutation that causes another table to change state. A typical
+     * example of this is a system that becomes active/inactive as the result of
+     * a query (and as a result, its matched tables) becoming empty/non empty */
+    if (!world->pending_buffer) {
         return;
     }
 
-    query->monitor_generation = world->monitor_generation;
-
-    if (parent_query) {
-        parent_it = ecs_query_iter(world, parent_query);
-        it = ecs_filter_chain_iter(&parent_it, &query->filter);
-    } else {
-        it = flecs_filter_iter_w_flags(world, &query->filter, 0);
+    /* Swap buffer. The logic could in theory have been implemented with a
+     * single sparse set, but that would've complicated (and slowed down) the
+     * iteration. Additionally, by using a double buffer approach we can still
+     * keep most of the original ordering of events intact, which is desirable
+     * as it means that the ordering of tables in the internal data structures is
+     * more predictable. */
+    int32_t i, count = flecs_sparse_count(world->pending_tables);
+    if (!count) {
+        return;
     }
 
-    ECS_BIT_SET(it.flags, EcsIterIsInstanced);
-    ECS_BIT_SET(it.flags, EcsIterNoData);
-    ECS_BIT_SET(it.flags, EcsIterEntityOptional);
+    flecs_journal_begin(world, EcsJournalTableEvents, 0, 0, 0);
 
-    world->info.rematch_count_total ++;
-    int32_t rematch_count = ++ query->rematch_count;
+    do {
+        ecs_sparse_t *pending_tables = world->pending_tables;
+        world->pending_tables = world->pending_buffer;
+        world->pending_buffer = NULL;
 
-    ecs_time_t t = {0};
-    if (world->flags & EcsWorldMeasureFrameTime) {
-        ecs_time_measure(&t);
-    }
+        /* Make sure that any ECS operations that occur while delivering the
+         * events does not cause inconsistencies, like sending an Empty
+         * notification for a table that just became non-empty. */
+        flecs_defer_begin(world, world->stages[0]);
 
-    while (ecs_filter_next(&it)) {
-        if ((table != it.table) || (!it.table && !qt)) {
-            if (qm && qm->next_match) {
-                flecs_query_table_match_free(query, qt, qm->next_match);
-                qm->next_match = NULL;
+        for (i = 0; i < count; i ++) {
+            ecs_table_t *table = flecs_sparse_get_dense_t(
+                pending_tables, ecs_table_t*, i)[0];
+            if (!table->id) {
+                /* Table is being deleted, ignore empty events */
+                continue;
             }
 
-            table = it.table;
-
-            qt = ecs_table_cache_get(&query->cache, table);
-            if (!qt) {
-                qt = flecs_query_table_insert(world, query, table);
-            }
+            /* For each id in the table, add it to the empty/non empty list
+             * based on its current state */
+            if (flecs_table_records_update_empty(table)) {
+                int32_t table_count = ecs_table_count(table);
+                if (table->flags & (EcsTableHasOnTableFill|EcsTableHasOnTableEmpty)) {
+                    /* Only emit an event when there was a change in the
+                    * administration. It is possible that a table ended up in the
+                    * pending_tables list by going from empty->non-empty, but then
+                    * became empty again. By the time we run this code, no changes
+                    * in the administration would actually be made. */
+                    ecs_entity_t evt = table_count ? EcsOnTableFill : EcsOnTableEmpty;
+                    if (ecs_should_log_3()) {
+                        ecs_dbg_3("table %u state change (%s)",
+                            (uint32_t)table->id,
+                            table_count ? "non-empty" : "empty");
+                    }
 
-            ecs_assert(qt->hdr.table == table, ECS_INTERNAL_ERROR, NULL);
-            qt->rematch_count = rematch_count;
-            qm = NULL;
-        }
-        if (!qm) {
-            qm = qt->first;
-        } else {
-            qm = qm->next_match;
-        }
-        if (!qm) {
-            qm = flecs_query_add_table_match(query, qt, table);
-        }
+                    ecs_log_push_3();
 
-        flecs_query_set_table_match(world, query, qm, table, &it);
+                    flecs_table_emit(world, table, evt);
 
-        if (table && ecs_table_count(table) && query->group_by) {
-            if (flecs_query_get_group_id(query, table) != qm->group_id) {
-                /* Update table group */
-                flecs_query_remove_table_node(query, qm);
-                flecs_query_insert_table_node(query, qm);
+                    ecs_log_pop_3();
+                }
+                world->info.empty_table_count += (table_count == 0) * 2 - 1;
             }
         }
-    }
 
-    if (qm && qm->next_match) {
-        flecs_query_table_match_free(query, qt, qm->next_match);
-        qm->next_match = NULL;
-    }
+        flecs_sparse_clear(pending_tables);
+        ecs_defer_end(world);
 
-    /* Iterate all tables in cache, remove ones that weren't just matched */
-    ecs_table_cache_iter_t cache_it;
-    if (flecs_table_cache_all_iter(&query->cache, &cache_it)) {
-        while ((qt = flecs_table_cache_next(&cache_it, ecs_query_table_t))) {
-            if (qt->rematch_count != rematch_count) {
-                flecs_query_unmatch_table(query, qt->hdr.table, qt);
-            }
-        }
-    }
+        world->pending_buffer = pending_tables;
+    } while ((count = flecs_sparse_count(world->pending_tables)));
 
-    if (world->flags & EcsWorldMeasureFrameTime) {
-        world->info.rematch_time_total += (ecs_ftime_t)ecs_time_measure(&t);
-    }
+    flecs_journal_end();
 }
 
-static
-void flecs_query_remove_subquery(
-    ecs_query_t *parent, 
-    ecs_query_t *sub)
+void flecs_table_set_empty(
+    ecs_world_t *world,
+    ecs_table_t *table)
 {
-    ecs_assert(parent != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(sub != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(parent->subqueries.array, ECS_INTERNAL_ERROR, NULL);
-
-    int32_t i, count = ecs_vec_count(&parent->subqueries);
-    ecs_query_t **sq = ecs_vec_first(&parent->subqueries);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    for (i = 0; i < count; i ++) {
-        if (sq[i] == sub) {
-            break;
-        }
+    if (ecs_table_count(table)) {
+        table->_->generation = 0;
     }
 
-    ecs_vec_remove_t(&parent->subqueries, ecs_query_t*, i);
+    flecs_sparse_ensure_fast_t(world->pending_tables, ecs_table_t*,
+        (uint32_t)table->id)[0] = table;
 }
 
-/* -- Private API -- */
+bool ecs_id_in_use(
+    const ecs_world_t *world,
+    ecs_id_t id)
+{
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return false;
+    }
+    return (flecs_table_cache_count(&idr->cache) != 0) ||
+        (flecs_table_cache_empty_count(&idr->cache) != 0);
+}
 
-void flecs_query_notify(
+void ecs_run_aperiodic(
     ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_event_t *event)
+    ecs_flags32_t flags)
 {
-    bool notify = true;
+    flecs_poly_assert(world, ecs_world_t);
+    
+    if (!flags || (flags & EcsAperiodicEmptyTables)) {
+        flecs_process_pending_tables(world);
+    }
 
-    switch(event->kind) {
-    case EcsQueryTableMatch:
-        /* Creation of new table */
-        if (flecs_query_match_table(world, query, event->table)) {
-            if (query->subqueries.array) {
-                flecs_query_notify_subqueries(world, query, event);
-            }
-        }
-        notify = false;
-        break;
-    case EcsQueryTableUnmatch:
-        /* Deletion of table */
-        flecs_query_unmatch_table(query, event->table, NULL);
-        break;
-    case EcsQueryTableRematch:
-        /* Rematch tables of query */
-        flecs_query_rematch_tables(world, query, event->parent_query);
-        break;        
-    case EcsQueryOrphan:
-        ecs_assert(query->flags & EcsQueryIsSubquery, ECS_INTERNAL_ERROR, NULL);
-        query->flags |= EcsQueryIsOrphaned;
-        query->parent = NULL;
-        break;
+    if ((flags & EcsAperiodicEmptyQueries)) {
+        flecs_process_empty_queries(world);
     }
 
-    if (notify) {
-        flecs_query_notify_subqueries(world, query, event);
+    if (!flags || (flags & EcsAperiodicComponentMonitors)) {
+        flecs_eval_component_monitors(world);
     }
 }
 
-static
-void flecs_query_order_by(
+int32_t ecs_delete_empty_tables(
     ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_entity_t order_by_component,
-    ecs_order_by_action_t order_by,
-    ecs_sort_table_action_t action)
+    ecs_id_t id,
+    uint16_t clear_generation,
+    uint16_t delete_generation,
+    int32_t min_id_count,
+    double time_budget_seconds)
 {
-    ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(query->flags & EcsQueryIsOrphaned), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!ecs_id_is_wildcard(order_by_component), 
-        ECS_INVALID_PARAMETER, NULL);
+    flecs_poly_assert(world, ecs_world_t);
 
-    /* Find order_by_component term & make sure it is queried for */
-    const ecs_filter_t *filter = &query->filter;
-    int32_t i, count = filter->term_count;
-    int32_t order_by_term = -1;
+    /* Make sure empty tables are in the empty table lists */
+    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
 
-    if (order_by_component) {
-        for (i = 0; i < count; i ++) {
-            ecs_term_t *term = &filter->terms[i];
-            
-            /* Only And terms are supported */
-            if (term->id == order_by_component && term->oper == EcsAnd) {
-                order_by_term = i;
-                break;
-            }
-        }
+    ecs_time_t start = {0}, cur = {0};
+    int32_t delete_count = 0, clear_count = 0;
+    bool time_budget = false;
 
-        ecs_check(order_by_term != -1, ECS_INVALID_PARAMETER, 
-            "sorted component not is queried for");
+    if (ECS_NEQZERO(time_budget_seconds) || (ecs_should_log_1() && ecs_os_has_time())) {
+        ecs_time_measure(&start);
     }
 
-    query->order_by_component = order_by_component;
-    query->order_by = order_by;
-    query->order_by_term = order_by_term;
-    query->sort_table = action;
-
-    ecs_vec_fini_t(NULL, &query->table_slices, ecs_query_table_match_t);
-    flecs_query_sort_tables(world, query);  
-
-    if (!query->table_slices.array) {
-        flecs_query_build_sorted_tables(query);
+    if (ECS_NEQZERO(time_budget_seconds)) {
+        time_budget = true;
     }
 
-    query->flags &= ~EcsQueryTrivialIter;
-error:
-    return;
-}
-
-static
-void flecs_query_group_by(
-    ecs_query_t *query,
-    ecs_entity_t sort_component,
-    ecs_group_by_action_t group_by)
-{   
-    /* Cannot change grouping once a query has been created */
-    ecs_check(query->group_by_id == 0, ECS_INVALID_OPERATION, NULL);
-    ecs_check(query->group_by == 0, ECS_INVALID_OPERATION, NULL);
-
-    if (!group_by) {
-        /* Builtin function that groups by relationship */
-        group_by = flecs_query_default_group_by;   
+    if (!id) {
+        id = EcsAny; /* Iterate all empty tables */
     }
 
-    query->group_by_id = sort_component;
-    query->group_by = group_by;
-
-    ecs_map_init_w_params(&query->groups, 
-        &query->filter.world->allocators.query_table_list);
-error:
-    return;
-}
-
-/* Implementation for iterable mixin */
-static
-void flecs_query_iter_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter)
-{
-    ecs_poly_assert(poly, ecs_query_t);
-
-    if (filter) {
-        iter[1] = ecs_query_iter(world, ECS_CONST_CAST(ecs_query_t*, poly));
-        iter[0] = ecs_term_chain_iter(&iter[1], filter);
-    } else {
-        iter[0] = ecs_query_iter(world, ECS_CONST_CAST(ecs_query_t*, poly));
-    }
-}
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    ecs_table_cache_iter_t it;
+    if (idr && flecs_table_cache_empty_iter((ecs_table_cache_t*)idr, &it)) {
+        ecs_table_record_t *tr;
+        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+            if (time_budget) {
+                cur = start;
+                if (ecs_time_measure(&cur) > time_budget_seconds) {
+                    goto done;
+                }
+            }
 
-static
-void flecs_query_on_event(
-    ecs_iter_t *it)
-{
-    /* Because this is the observer::run callback, checking if this is event is
-     * already handled is not done for us. */
-    ecs_world_t *world = it->world;
-    ecs_observer_t *o = it->ctx;
-    if (o->last_event_id) {
-        if (o->last_event_id[0] == world->event_id) {
-            return;
-        }
-        o->last_event_id[0] = world->event_id;
-    }
+            ecs_table_t *table = tr->hdr.table;
+            ecs_assert(ecs_table_count(table) == 0, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_query_t *query = o->ctx;
-    ecs_table_t *table = it->table;
-    ecs_entity_t event = it->event;
+            if (table->type.count < min_id_count) {
+                continue;
+            }
 
-    if (event == EcsOnTableCreate) {
-        /* Creation of new table */
-        if (flecs_query_match_table(world, query, table)) {
-            if (query->subqueries.array) {
-                ecs_query_event_t evt = {
-                    .kind = EcsQueryTableMatch,
-                    .table = table,
-                    .parent_query = query
-                };
-                flecs_query_notify_subqueries(world, query, &evt);
+            uint16_t gen = ++ table->_->generation;
+            if (delete_generation && (gen > delete_generation)) {
+                flecs_table_fini(world, table);
+                delete_count ++;
+            } else if (clear_generation && (gen > clear_generation)) {
+                if (flecs_table_shrink(world, table)) {
+                    clear_count ++;
+                }
             }
         }
-        return;
-    }
-
-    ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    /* The observer isn't doing the matching because the query can do it more
-     * efficiently by checking the table with the query cache. */
-    if (ecs_table_cache_get(&query->cache, table) == NULL) {
-        return;
     }
 
-    if (event == EcsOnTableEmpty) {
-        flecs_query_update_table(query, table, true);
-    } else
-    if (event == EcsOnTableFill) {
-        flecs_query_update_table(query, table, false);
-    } else if (event == EcsOnTableDelete) {
-        /* Deletion of table */
-        flecs_query_unmatch_table(query, table, NULL);
-        if (query->subqueries.array) {
-                ecs_query_event_t evt = {
-                    .kind = EcsQueryTableUnmatch,
-                    .table = table,
-                    .parent_query = query
-                };
-                flecs_query_notify_subqueries(world, query, &evt);
+done:
+    if (ecs_should_log_1() && ecs_os_has_time()) {
+        if (delete_count) {
+            ecs_dbg_1("#[red]deleted#[normal] %d empty tables in %.2fs",
+                delete_count, ecs_time_measure(&start));
         }
-        return;
-    }
-}
-
-static
-void flecs_query_table_cache_free(
-    ecs_query_t *query)
-{
-    ecs_table_cache_iter_t it;
-    ecs_query_table_t *qt;
-
-    if (flecs_table_cache_all_iter(&query->cache, &it)) {
-        while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) {
-            flecs_query_table_free(query, qt);
+        if (clear_count) {
+            ecs_dbg_1("#[red]cleared#[normal] %d empty tables in %.2fs",
+                clear_count, ecs_time_measure(&start));
         }
     }
 
-    ecs_table_cache_fini(&query->cache);
+    return delete_count;
 }
 
-static
-void flecs_query_allocators_init(
-    ecs_query_t *query)
-{
-    int32_t field_count = query->filter.field_count;
-    if (field_count) {
-        flecs_ballocator_init(&query->allocators.columns, 
-            field_count * ECS_SIZEOF(int32_t));
-        flecs_ballocator_init(&query->allocators.ids, 
-            field_count * ECS_SIZEOF(ecs_id_t));
-        flecs_ballocator_init(&query->allocators.sources,
-            field_count * ECS_SIZEOF(ecs_entity_t));
-        flecs_ballocator_init(&query->allocators.monitors,
-            (1 + field_count) * ECS_SIZEOF(int32_t));
-    }
-}
-
-static
-void flecs_query_allocators_fini(
-    ecs_query_t *query)
-{
-    int32_t field_count = query->filter.field_count;
-    if (field_count) {
-        flecs_ballocator_fini(&query->allocators.columns);
-        flecs_ballocator_fini(&query->allocators.ids);
-        flecs_ballocator_fini(&query->allocators.sources);
-        flecs_ballocator_fini(&query->allocators.monitors);
-    }
-}
-
-static
-void flecs_query_fini(
-    ecs_query_t *query)
-{
-    ecs_world_t *world = query->filter.world;
+/**
+ * @file addons/alerts.c
+ * @brief Alerts addon.
+ */
 
-    ecs_group_delete_action_t on_delete = query->on_group_delete;
-    if (on_delete) {
-        ecs_map_iter_t it = ecs_map_iter(&query->groups);
-        while (ecs_map_next(&it)) {
-            ecs_query_table_list_t *group = ecs_map_ptr(&it);
-            uint64_t group_id = ecs_map_key(&it);
-            on_delete(world, group_id, group->info.ctx, query->group_by_ctx);
-        }
-        query->on_group_delete = NULL;
-    }
 
-    if (query->group_by_ctx_free) {
-        if (query->group_by_ctx) {
-            query->group_by_ctx_free(query->group_by_ctx);
-        }
-    }
+#ifdef FLECS_ALERTS
 
-    if ((query->flags & EcsQueryIsSubquery) &&
-        !(query->flags & EcsQueryIsOrphaned))
-    {
-        flecs_query_remove_subquery(query->parent, query);
-    }
+ECS_COMPONENT_DECLARE(FlecsAlerts);
 
-    flecs_query_notify_subqueries(world, query, &(ecs_query_event_t){
-        .kind = EcsQueryOrphan
-    });
+typedef struct EcsAlert {
+    char *message;
+    ecs_map_t instances;        /* Active instances for metric */
+    ecs_ftime_t retain_period;  /* How long to retain the alert */
+    ecs_vec_t severity_filters; /* Severity filters */
+    
+    /* Member range monitoring */
+    ecs_id_t id;                /* (Component) id that contains to monitor member */
+    ecs_entity_t member;        /* Member to monitor */
+    int32_t offset;             /* Offset of member in component */
+    int32_t size;               /* Size of component */
+    ecs_primitive_kind_t kind;  /* Primitive type kind */
+    ecs_ref_t ranges;           /* Reference to ranges component */
+    int32_t var_id;             /* Variable from which to obtain data (0 = $this) */
+} EcsAlert;
 
-    flecs_query_for_each_component_monitor(world, query, 
-        flecs_monitor_unregister);
-    flecs_query_table_cache_free(query);
+typedef struct EcsAlertTimeout {
+    ecs_ftime_t inactive_time; /* Time the alert has been inactive */
+    ecs_ftime_t expire_time;   /* Expiration duration */
+} EcsAlertTimeout;
 
-    ecs_map_fini(&query->groups);
+ECS_COMPONENT_DECLARE(EcsAlertTimeout);
 
-    ecs_vec_fini_t(NULL, &query->subqueries, ecs_query_t*);
-    ecs_vec_fini_t(NULL, &query->table_slices, ecs_query_table_match_t);
-    ecs_filter_fini(&query->filter);
+static
+ECS_CTOR(EcsAlert, ptr, {
+    ecs_os_zeromem(ptr);
+    ecs_map_init(&ptr->instances, NULL);
+    ecs_vec_init_t(NULL, &ptr->severity_filters, ecs_alert_severity_filter_t, 0);
+})
 
-    flecs_query_allocators_fini(query);
+static
+ECS_DTOR(EcsAlert, ptr, {
+    ecs_os_free(ptr->message);
+    ecs_map_fini(&ptr->instances);
+    ecs_vec_fini_t(NULL, &ptr->severity_filters, ecs_alert_severity_filter_t);
+})
 
-    if (query->ctx_free) {
-        query->ctx_free(query->ctx);
-    }
-    if (query->binding_ctx_free) {
-        query->binding_ctx_free(query->binding_ctx);
-    }
+static
+ECS_MOVE(EcsAlert, dst, src, {
+    ecs_os_free(dst->message);
+    dst->message = src->message;
+    src->message = NULL;
 
-    ecs_poly_free(query, ecs_query_t);
-}
+    ecs_map_fini(&dst->instances);
+    dst->instances = src->instances;
+    src->instances = (ecs_map_t){0};
 
-/* -- Public API -- */
+    ecs_vec_fini_t(NULL, &dst->severity_filters, ecs_alert_severity_filter_t);
+    dst->severity_filters = src->severity_filters;
+    src->severity_filters = (ecs_vec_t){0};
 
-ecs_query_t* ecs_query_init(
-    ecs_world_t *world,
-    const ecs_query_desc_t *desc)
-{
-    ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, NULL);
+    dst->retain_period = src->retain_period;
+    dst->id = src->id;
+    dst->member = src->member;
+    dst->offset = src->offset;
+    dst->size = src->size;
+    dst->kind = src->kind;
+    dst->ranges = src->ranges;
+    dst->var_id = src->var_id;
+})
 
-    ecs_query_t *result = ecs_poly_new(ecs_query_t);
-    ecs_observer_desc_t observer_desc = { .filter = desc->filter };
-    ecs_entity_t entity = desc->filter.entity;
+static
+ECS_CTOR(EcsAlertsActive, ptr, {
+    ecs_map_init(&ptr->alerts, NULL);
+    ptr->info_count = 0;
+    ptr->warning_count = 0;
+    ptr->error_count = 0;
+})
 
-    observer_desc.filter.flags = EcsFilterMatchEmptyTables;
-    observer_desc.filter.storage = &result->filter;
-    result->filter = ECS_FILTER_INIT;
+static
+ECS_DTOR(EcsAlertsActive, ptr, {
+    ecs_map_fini(&ptr->alerts);
+})
 
-    if (ecs_filter_init(world, &observer_desc.filter) == NULL) {
-        goto error;
-    }
+static
+ECS_MOVE(EcsAlertsActive, dst, src, {
+    ecs_map_fini(&dst->alerts);
+    dst->alerts = src->alerts;
+    dst->info_count = src->info_count;
+    dst->warning_count = src->warning_count;
+    dst->error_count = src->error_count;
+    src->alerts = (ecs_map_t){0};
+})
 
-    ECS_BIT_COND(result->flags, EcsQueryTrivialIter, 
-        !!(result->filter.flags & EcsFilterMatchOnlyThis));
+static
+ECS_DTOR(EcsAlertInstance, ptr, {
+    ecs_os_free(ptr->message);
+})
 
-    flecs_query_allocators_init(result);
+static
+ECS_MOVE(EcsAlertInstance, dst, src, {
+    ecs_os_free(dst->message);
+    dst->message = src->message;
+    src->message = NULL;
+})
 
-    if (result->filter.term_count) {
-        observer_desc.entity = entity;
-        observer_desc.run = flecs_query_on_event;
-        observer_desc.ctx = result;
-        observer_desc.events[0] = EcsOnTableEmpty;
-        observer_desc.events[1] = EcsOnTableFill;
-        if (!desc->parent) {
-            observer_desc.events[2] = EcsOnTableCreate;
-            observer_desc.events[3] = EcsOnTableDelete;
-        }
-        observer_desc.filter.flags |= EcsFilterNoData;
-        observer_desc.filter.instanced = true;
+static
+ECS_COPY(EcsAlertInstance, dst, src, {
+    ecs_os_free(dst->message);
+    dst->message = ecs_os_strdup(src->message);
+})
 
-        /* ecs_filter_init could have moved away resources from the terms array
-         * in the descriptor, so use the terms array from the filter. */
-        observer_desc.filter.terms_buffer = result->filter.terms;
-        observer_desc.filter.terms_buffer_count = result->filter.term_count;
-        observer_desc.filter.expr = NULL; /* Already parsed */
+static
+void flecs_alerts_add_alert_to_src(
+    ecs_world_t *world,
+    ecs_entity_t source,
+    ecs_entity_t alert,
+    ecs_entity_t alert_instance)
+{
+    EcsAlertsActive *active = ecs_ensure(
+        world, source, EcsAlertsActive);
+    ecs_assert(active != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        entity = ecs_observer_init(world, &observer_desc);
-        if (!entity) {
-            goto error;
-        }
+    ecs_entity_t severity = ecs_get_target(world, alert, ecs_id(EcsAlert), 0);
+    if (severity == EcsAlertInfo) {
+        active->info_count ++;
+    } else if (severity == EcsAlertWarning) {
+        active->warning_count ++;
+    } else if (severity == EcsAlertError) {
+        active->error_count ++;
     }
 
-    result->iterable.init = flecs_query_iter_init;
-    result->dtor = (ecs_poly_dtor_t)flecs_query_fini;
-    result->prev_match_count = -1;
-
-    result->ctx = desc->ctx;
-    result->binding_ctx = desc->binding_ctx;
-    result->ctx_free = desc->ctx_free;
-    result->binding_ctx_free = desc->binding_ctx_free;
-
-    if (ecs_should_log_1()) {
-        char *filter_expr = ecs_filter_str(world, &result->filter);
-        ecs_dbg_1("#[green]query#[normal] [%s] created", 
-            filter_expr ? filter_expr : "");
-        ecs_os_free(filter_expr);
-    }
+    ecs_entity_t *ptr = ecs_map_ensure(&active->alerts, alert);
+    ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ptr[0] = alert_instance;
+    ecs_modified(world, source, EcsAlertsActive);
+}
 
-    ecs_log_push_1();
+static
+void flecs_alerts_remove_alert_from_src(
+    ecs_world_t *world,
+    ecs_entity_t source,
+    ecs_entity_t alert)
+{
+    EcsAlertsActive *active = ecs_ensure(
+        world, source, EcsAlertsActive);
+    ecs_assert(active != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_map_remove(&active->alerts, alert);
 
-    if (flecs_query_process_signature(world, result)) {
-        goto error;
+    ecs_entity_t severity = ecs_get_target(world, alert, ecs_id(EcsAlert), 0);
+    if (severity == EcsAlertInfo) {
+        active->info_count --;
+    } else if (severity == EcsAlertWarning) {
+        active->warning_count --;
+    } else if (severity == EcsAlertError) {
+        active->error_count --;
     }
 
-    /* Group before matching so we won't have to move tables around later */
-    int32_t cascade_by = result->cascade_by;
-    if (cascade_by) {
-        flecs_query_group_by(result, result->filter.terms[cascade_by - 1].id,
-            flecs_query_group_by_cascade);
-        result->group_by_ctx = &result->filter.terms[cascade_by - 1];
+    if (!ecs_map_count(&active->alerts)) {
+        ecs_remove(world, source, EcsAlertsActive);
+    } else {
+        ecs_modified(world, source, EcsAlertsActive);
     }
+}
 
-    if (desc->group_by || desc->group_by_id) {
-        /* Can't have a cascade term and group by at the same time, as cascade
-         * uses the group_by mechanism */
-        ecs_check(!result->cascade_by, ECS_INVALID_PARAMETER, NULL);
-        flecs_query_group_by(result, desc->group_by_id, desc->group_by);
-        result->group_by_ctx = desc->group_by_ctx;
-        result->on_group_create = desc->on_group_create;
-        result->on_group_delete = desc->on_group_delete;
-        result->group_by_ctx_free = desc->group_by_ctx_free;
+static
+ecs_entity_t flecs_alert_get_severity(
+    ecs_world_t *world,
+    ecs_iter_t *it,
+    EcsAlert *alert)
+{
+    int32_t i, filter_count = ecs_vec_count(&alert->severity_filters);
+    ecs_alert_severity_filter_t *filters = 
+        ecs_vec_first(&alert->severity_filters);
+    for (i = 0; i < filter_count; i ++) {
+        ecs_alert_severity_filter_t *filter = &filters[i];
+        if (!filter->var) {
+            if (ecs_table_has_id(world, it->table, filters[i].with)) {
+                return filters[i].severity;
+            }
+        } else {
+            ecs_entity_t src = ecs_iter_get_var(it, filter->_var_index);
+            if (src && src != EcsWildcard) {
+                if (ecs_has_id(world, src, filters[i].with)) {
+                    return filters[i].severity;
+                }
+            }
+        }
     }
 
-    if (desc->parent != NULL) {
-        result->flags |= EcsQueryIsSubquery;
-    }
+    return 0;
+}
 
-    /* If the query refers to itself, add the components that were queried for
-     * to the query itself. */
-    if (entity)  {
-        int32_t t, term_count = result->filter.term_count;
-        ecs_term_t *terms = result->filter.terms;
+static
+ecs_entity_t flecs_alert_out_of_range_kind(
+    EcsAlert *alert,
+    const EcsMemberRanges *ranges,
+    const void *value_ptr)
+{
+    double value = 0;
 
-        for (t = 0; t < term_count; t ++) {
-            ecs_term_t *term = &terms[t];
-            if (term->src.id == entity) {
-                ecs_add_id(world, entity, term->id);
-            }
-        }        
+    switch(alert->kind) {
+    case EcsU8: value = *(const uint8_t*)value_ptr; break;
+    case EcsU16: value = *(const uint16_t*)value_ptr; break;
+    case EcsU32: value = *(const uint32_t*)value_ptr; break;
+    case EcsU64: value = (double)*(const uint64_t*)value_ptr; break;
+    case EcsI8: value = *(const int8_t*)value_ptr; break;
+    case EcsI16: value = *(const int16_t*)value_ptr; break;
+    case EcsI32: value = *(const int32_t*)value_ptr; break;
+    case EcsI64: value = (double)*(const int64_t*)value_ptr; break;
+    case EcsF32: value = (double)*(const float*)value_ptr; break;
+    case EcsF64: value = *(const double*)value_ptr; break;
+    case EcsBool:
+    case EcsChar:
+    case EcsByte:
+    case EcsUPtr:
+    case EcsIPtr:
+    case EcsString:
+    case EcsEntity:
+    case EcsId:
+        return 0;
     }
 
-    if (!entity) {
-        entity = ecs_new_id(world);
-    }
+    bool has_error = ECS_NEQ(ranges->error.min, ranges->error.max);
+    bool has_warning = ECS_NEQ(ranges->warning.min, ranges->warning.max);
 
-    EcsPoly *poly = ecs_poly_bind(world, entity, ecs_query_t);
-    if (poly->poly) {
-        /* If entity already had poly query, delete previous */
-        flecs_query_fini(poly->poly);
+    if (has_error && (value < ranges->error.min || value > ranges->error.max)) {
+        return EcsAlertError;
+    } else if (has_warning && 
+        (value < ranges->warning.min || value > ranges->warning.max)) 
+    {
+        return EcsAlertWarning;
+    } else {
+        return 0;
     }
-    poly->poly = result;
-    result->filter.entity = entity;
+}
 
-    /* Ensure that while initially populating the query with tables, they are
-     * in the right empty/non-empty list. This ensures the query won't miss
-     * empty/non-empty events for tables that are currently out of sync, but
-     * change back to being in sync before processing pending events. */
-    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
+static
+void MonitorAlerts(ecs_iter_t *it) {
+    ecs_world_t *world = it->real_world;
+    EcsAlert *alert = ecs_field(it, EcsAlert, 0);
+    EcsPoly *poly = ecs_field(it, EcsPoly, 1);
 
-    ecs_table_cache_init(world, &result->cache);
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_entity_t a = it->entities[i]; /* Alert entity */
+        ecs_entity_t default_severity = ecs_get_target(
+            world, a, ecs_id(EcsAlert), 0);
+        ecs_query_t *q = poly[i].poly;
+        if (!q) {
+            continue;
+        }
 
-    if (!desc->parent) {
-        flecs_query_match_tables(world, result);
-    } else {
-        flecs_query_add_subquery(world, desc->parent, result);
-        result->parent = desc->parent;
-    }
+        flecs_poly_assert(q, ecs_query_t);
 
-    if (desc->order_by) {
-        flecs_query_order_by(
-            world, result, desc->order_by_component, desc->order_by,
-            desc->sort_table);
-    }
+        ecs_id_t member_id = alert[i].id;
+        const EcsMemberRanges *ranges = NULL;
+        if (member_id) {
+            ranges = ecs_ref_get(world, &alert[i].ranges, EcsMemberRanges);
+        }
 
-    if (!ecs_query_table_count(result) && result->filter.term_count) {
-        ecs_add_id(world, entity, EcsEmpty);
-    }
+        ecs_iter_t rit = ecs_query_iter(world, q);
+        rit.flags |= EcsIterNoData;
+        rit.flags |= EcsIterIsInstanced;
 
-    ecs_poly_modified(world, entity, ecs_query_t);
+        while (ecs_query_next(&rit)) {
+            ecs_entity_t severity = flecs_alert_get_severity(
+                world, &rit, &alert[i]);
+            if (!severity) {
+                severity = default_severity;
+            }
 
-    ecs_log_pop_1();
+            const void *member_data = NULL;
+            ecs_entity_t member_src = 0;
+            if (ranges) {
+                if (alert[i].var_id) {
+                    member_src = ecs_iter_get_var(&rit, alert[i].var_id);
+                    if (!member_src || member_src == EcsWildcard) {
+                        continue;
+                    }
+                }
+                if (!member_src) {
+                    member_data = ecs_table_get_id(
+                        world, rit.table, member_id, rit.offset);
+                } else {
+                    member_data = ecs_get_id(world, member_src, member_id);
+                }
+                if (!member_data) {
+                    continue;
+                }
+                member_data = ECS_OFFSET(member_data, alert[i].offset);
+            }
 
-    return result;
-error:
-    if (result) {
-        ecs_filter_fini(&result->filter);
-        ecs_os_free(result);
-    }
-    return NULL;
-}
+            int32_t j, alert_src_count = rit.count;
+            for (j = 0; j < alert_src_count; j ++) {
+                ecs_entity_t src_severity = severity;
+                ecs_entity_t e = rit.entities[j];
+                if (member_data) {
+                    ecs_entity_t range_severity = flecs_alert_out_of_range_kind(
+                        &alert[i], ranges, member_data);
+                    if (!member_src) {
+                        member_data = ECS_OFFSET(member_data, alert[i].size);
+                    }
+                    if (!range_severity) {
+                        continue;
+                    }
+                    if (range_severity < src_severity) {
+                        /* Range severity should not exceed alert severity */
+                        src_severity = range_severity;
+                    }
+                }
 
-void ecs_query_fini(
-    ecs_query_t *query)
-{
-    ecs_poly_assert(query, ecs_query_t);
-    ecs_delete(query->filter.world, query->filter.entity);
-}
+                ecs_entity_t *aptr = ecs_map_ensure(&alert[i].instances, e);
+                ecs_assert(aptr != NULL, ECS_INTERNAL_ERROR, NULL);
+                if (!aptr[0]) {
+                    /* Alert does not yet exist for entity */
+                    ecs_entity_t ai = ecs_new_w_pair(world, EcsChildOf, a);
+                    ecs_set(world, ai, EcsAlertInstance, { .message = NULL });
+                    ecs_set(world, ai, EcsMetricSource, { .entity = e });
+                    ecs_set(world, ai, EcsMetricValue, { .value = 0 });
+                    ecs_add_pair(world, ai, ecs_id(EcsAlert), src_severity);
+                    if (ECS_NEQZERO(alert[i].retain_period)) {
+                        ecs_set(world, ai, EcsAlertTimeout, {
+                            .inactive_time = 0,
+                            .expire_time = alert[i].retain_period
+                        });
+                    }
 
-const ecs_filter_t* ecs_query_get_filter(
-    const ecs_query_t *query)
-{
-    ecs_poly_assert(query, ecs_query_t);
-    return &query->filter;
+                    ecs_defer_suspend(it->world);
+                    flecs_alerts_add_alert_to_src(world, e, a, ai);
+                    ecs_defer_resume(it->world);
+                    aptr[0] = ai;
+                } else {
+                    /* Make sure alert severity is up to date */
+                    if (ecs_vec_count(&alert[i].severity_filters) || member_data) {
+                        ecs_entity_t cur_severity = ecs_get_target(
+                            world, aptr[0], ecs_id(EcsAlert), 0);
+                        if (cur_severity != src_severity) {
+                            ecs_add_pair(world, aptr[0], ecs_id(EcsAlert), 
+                                src_severity);
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 static
-void flecs_query_set_var(
-    ecs_iter_t *it)
-{
-    ecs_check(it->constrained_vars == 1, ECS_INVALID_OPERATION, 
-        "can only set $this variable for queries");
+void MonitorAlertInstances(ecs_iter_t *it) {
+    ecs_world_t *world = it->real_world;
+    EcsAlertInstance *alert_instance = ecs_field(it, EcsAlertInstance, 0);
+    EcsMetricSource *source = ecs_field(it, EcsMetricSource, 1);
+    EcsMetricValue *value = ecs_field(it, EcsMetricValue, 2);
+    EcsAlertTimeout *timeout = ecs_field(it, EcsAlertTimeout, 3);
 
-    ecs_var_t *var = &it->variables[0];
-    ecs_table_t *table = var->range.table;
-    if (!table) {
-        goto nodata;
+    /* Get alert component from alert instance parent (the alert) */
+    ecs_id_t childof_pair;
+    if (ecs_search(world, it->table, ecs_childof(EcsWildcard), &childof_pair) == -1) {
+        ecs_err("alert instances must be a child of an alert");
+        return;
     }
 
-    ecs_query_iter_t *qit = &it->priv.iter.query;
-    ecs_query_t *query = qit->query;
-    ecs_query_table_t *qt = ecs_table_cache_get(&query->cache, table);
-    if (!qt) {
-        goto nodata;
+    ecs_entity_t parent = ecs_pair_second(world, childof_pair);
+    ecs_assert(parent != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(ecs_has(world, parent, EcsAlert), ECS_INVALID_OPERATION,
+        "alert entity does not have Alert component");
+
+    EcsAlert *alert = ecs_ensure(world, parent, EcsAlert);
+    const EcsPoly *poly = ecs_get_pair(world, parent, EcsPoly, EcsQuery);
+    ecs_assert(poly != NULL, ECS_INVALID_OPERATION, 
+        "alert entity does not have (Poly, Query) component");
+
+    ecs_query_t *query = poly->poly;
+    if (!query) {
+        return;
     }
 
-    qit->node = qt->first;
-    qit->last = qt->last->next_match;
-    it->offset = var->range.offset;
-    it->count = var->range.count;
-    return;
-error:
-nodata:
-    it->priv.iter.query.node = NULL;
-    it->priv.iter.query.last = NULL;
-    return;
-}
+    flecs_poly_assert(query, ecs_query_t);
 
-ecs_iter_t ecs_query_iter(
-    const ecs_world_t *stage,
-    ecs_query_t *query)
-{
-    ecs_poly_assert(query, ecs_query_t);
-    ecs_check(!(query->flags & EcsQueryIsOrphaned),
-        ECS_INVALID_PARAMETER, NULL);
+    ecs_id_t member_id = alert->id;
+    const EcsMemberRanges *ranges = NULL;
+    if (member_id) {
+        ranges = ecs_ref_get(world, &alert->ranges, EcsMemberRanges);
+    }
 
-    ecs_world_t *world = query->filter.world;
-    ecs_poly_assert(world, ecs_world_t);
+    ecs_script_vars_t *vars = ecs_script_vars_init(it->world);
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_entity_t ai = it->entities[i];
+        ecs_entity_t e = source[i].entity;
 
-    query->filter.eval_count ++;
+        /* If source of alert is no longer alive, delete alert instance even if
+         * the alert has a retain period. */
+        if (!ecs_is_alive(world, e)) {
+            ecs_delete(world, ai);
+            continue;
+        }
 
-    /* Process table events to ensure that the list of iterated tables doesn't
-     * contain empty tables. */
-    flecs_process_pending_tables(world);
+        /* Check if alert instance still matches query */
+        ecs_iter_t rit = ecs_query_iter(world, query);
+        rit.flags |= EcsIterNoData;
+        rit.flags |= EcsIterIsInstanced;
+        ecs_iter_set_var(&rit, 0, e);
 
-    /* If query has order_by, apply sort */
-    flecs_query_sort_tables(world, query);
+        if (ecs_query_next(&rit)) {
+            bool match = true;
 
-    /* If monitors changed, do query rematching */
-    if (!(world->flags & EcsWorldReadonly) && query->flags & EcsQueryHasRefs) {
-        flecs_eval_component_monitors(world);
-    }
+            /* If alert is monitoring member range, test value against range */
+            if (ranges) {
+                ecs_entity_t member_src = e;
+                if (alert->var_id) {
+                    member_src = ecs_iter_get_var(&rit, alert->var_id);
+                }
 
-    /* Prepare iterator */
+                const void *member_data = ecs_get_id(
+                    world, member_src, member_id);
+                if (!member_data) {
+                    match = false;
+                } else {
+                    member_data = ECS_OFFSET(member_data, alert->offset);
+                    if (flecs_alert_out_of_range_kind(
+                        alert, ranges, member_data) == 0) 
+                    {
+                        match = false;
+                    }
+                }
+            }
 
-    int32_t table_count;
-    if (ecs_vec_count(&query->table_slices)) {
-        table_count = ecs_vec_count(&query->table_slices);
-    } else {
-        table_count = ecs_query_table_count(query);
-    }
+            if (match) {
+                /* Only increase alert duration if the alert was active */
+                value[i].value += (double)it->delta_system_time;
 
-    ecs_query_iter_t it = {
-        .query = query,
-        .node = query->list.first,
-        .last = NULL
-    };
+                bool generate_message = alert->message;
+                if (generate_message) {
+                    if (alert_instance[i].message) {
+                        /* If a message was already generated, only regenerate if
+                        * query has multiple variables. Variable values could have 
+                        * changed, this ensures the message remains up to date. */
+                        generate_message = rit.variable_count > 1;
+                    }
+                }
 
-    if (query->order_by && query->list.info.table_count) {
-        it.node = ecs_vec_first(&query->table_slices);
-    }
+                if (generate_message) {
+                    if (alert_instance[i].message) {
+                        ecs_os_free(alert_instance[i].message);
+                    }
 
-    ecs_iter_t result = {
-        .real_world = world,
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .query = &query->filter,
-        .terms = query->filter.terms,
-        .field_count = query->filter.field_count,
-        .table_count = table_count,
-        .variable_count = 1,
-        .priv.iter.query = it,
-        .next = ecs_query_next,
-        .set_var = flecs_query_set_var,
-        .system = query->filter.entity
-    };
+                    ecs_script_vars_from_iter(&rit, vars, 0);
+                    alert_instance[i].message = ecs_script_string_interpolate(
+                        world, alert->message, vars);
+                }
 
-    flecs_filter_apply_iter_flags(&result, &query->filter);
+                if (timeout) {
+                    if (ECS_NEQZERO(timeout[i].inactive_time)) {
+                        /* The alert just became active. Remove Disabled tag */
+                        flecs_alerts_add_alert_to_src(world, e, parent, ai);
+                        ecs_remove_id(world, ai, EcsDisabled);
+                    }
+                    timeout[i].inactive_time = 0;
+                }
 
-    ecs_filter_t *filter = &query->filter;
-    ecs_iter_t fit;
-    if (!(query->flags & EcsQueryTrivialIter)) {
-        /* Check if non-This terms (like singleton terms) still match */
-        if (!(filter->flags & EcsFilterMatchOnlyThis)) {
-            fit = flecs_filter_iter_w_flags(ECS_CONST_CAST(ecs_world_t*, stage),
-                &query->filter, EcsIterIgnoreThis);
-            if (!ecs_filter_next(&fit)) {
-                /* No match, so return nothing */
-                goto noresults;
+                /* Alert instance still matches query, keep it alive */
+                ecs_iter_fini(&rit);
+                continue;
             }
-        }
 
-        flecs_iter_init(stage, &result, flecs_iter_cache_all);
+            ecs_iter_fini(&rit);
+        }
 
-        /* Copy the data */
-        if (!(filter->flags & EcsFilterMatchOnlyThis)) {
-            int32_t field_count = filter->field_count;
-            if (field_count) {
-                if (result.ptrs) {
-                    ecs_os_memcpy_n(result.ptrs, fit.ptrs, void*, field_count);
-                }
-                ecs_os_memcpy_n(result.ids, fit.ids, ecs_id_t, field_count);
-                ecs_os_memcpy_n(result.columns, fit.columns, int32_t, field_count);
-                ecs_os_memcpy_n(result.sources, fit.sources, int32_t, field_count);
+        /* Alert instance is no longer active */
+        if (timeout) {
+            if (ECS_EQZERO(timeout[i].inactive_time)) {
+                /* The alert just became inactive. Add Disabled tag */
+                flecs_alerts_remove_alert_from_src(world, e, parent);
+                ecs_add_id(world, ai, EcsDisabled);
+            }
+            ecs_ftime_t t = timeout[i].inactive_time;
+            timeout[i].inactive_time += it->delta_system_time;
+            if (t < timeout[i].expire_time) {
+                /* Alert instance no longer matches query, but is still
+                    * within the timeout period. Keep it alive. */
+                continue;
             }
-            ecs_iter_fini(&fit);
         }
-    } else {
-        /* Trivial iteration, use arrays from query cache */
-        flecs_iter_init(stage, &result, 
-            flecs_iter_cache_ptrs|flecs_iter_cache_variables);
+
+        /* Alert instance no longer matches query, remove it */ 
+        flecs_alerts_remove_alert_from_src(world, e, parent);
+        ecs_map_remove(&alert->instances, e);
+        ecs_delete(world, ai);
     }
 
-    result.sizes = query->filter.sizes;
-
-    return result;
-error:
-noresults:
-    result.priv.iter.query.node = NULL;
-    return result;
+    ecs_script_vars_fini(vars);
 }
 
-void ecs_query_set_group(
-    ecs_iter_t *it,
-    uint64_t group_id)
+ecs_entity_t ecs_alert_init(
+    ecs_world_t *world,
+    const ecs_alert_desc_t *desc)
 {
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_PARAMETER, NULL);
-
-    ecs_query_iter_t *qit = &it->priv.iter.query;
-    ecs_query_t *q = qit->query;
-    ecs_check(q != NULL, ECS_INVALID_PARAMETER, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_alert_desc_t was not initialized to zero");
+    ecs_check(!desc->query.entity || desc->entity == desc->query.entity, 
+        ECS_INVALID_PARAMETER, NULL);
 
-    ecs_query_table_list_t *node = flecs_query_get_group(q, group_id);
-    if (!node) {
-        qit->node = NULL;
-        return;
+    ecs_entity_t result = desc->entity;
+    if (!result) {
+        result = ecs_new(world);
     }
 
-    ecs_query_table_match_t *first = node->first;
-    if (first) {
-        qit->node = node->first;
-        qit->last = node->last->next;
-    } else {
-        qit->node = NULL;
-        qit->last = NULL;
-    }
-    
-error:
-    return;
-}
+    ecs_query_desc_t private_desc = desc->query;
+    private_desc.entity = result;
 
-const ecs_query_group_info_t* ecs_query_get_group_info(
-    const ecs_query_t *query,
-    uint64_t group_id)
-{
-    ecs_query_table_list_t *node = flecs_query_get_group(query, group_id);
-    if (!node) {
-        return NULL;
+    ecs_query_t *q = ecs_query_init(world, &private_desc);
+    if (!q) {
+        ecs_err("failed to create alert filter");
+        return 0;
     }
-    
-    return &node->info;
-}
 
-void* ecs_query_get_group_ctx(
-    const ecs_query_t *query,
-    uint64_t group_id)
-{
-    const ecs_query_group_info_t *info = 
-        ecs_query_get_group_info(query, group_id);
-    if (!info) {
-        return NULL;
-    } else {
-        return info->ctx;
+    if (!(q->flags & EcsQueryMatchThis)) {
+        ecs_err("alert filter must have at least one '$this' term");
+        ecs_query_fini(q);
+        return 0;
     }
-}
-
-static
-void flecs_query_mark_columns_dirty(
-    ecs_query_t *query,
-    ecs_query_table_match_t *qm)
-{
-    ecs_table_t *table = qm->table;
-    ecs_filter_t *filter = &query->filter;
-    if ((table && table->dirty_state) || (query->flags & EcsQueryHasNonThisOutTerms)) {
-        ecs_term_t *terms = filter->terms;
-        int32_t i, count = filter->term_count;
-
-        for (i = 0; i < count; i ++) {
-            ecs_term_t *term = &terms[i];
-            ecs_inout_kind_t inout = term->inout;
-            if (inout == EcsIn || inout == EcsInOutNone) {
-                /* Don't mark readonly terms dirty */
-                continue;
-            }
 
-            flecs_table_column_t tc;
-            flecs_query_get_column_for_term(query, qm, i, &tc);
-
-            if (tc.column == -1) {
-                continue;
-            }
+    /* Initialize Alert component which identifiers entity as alert */
+    EcsAlert *alert = ecs_ensure(world, result, EcsAlert);
+    ecs_assert(alert != NULL, ECS_INTERNAL_ERROR, NULL);
+    alert->message = ecs_os_strdup(desc->message);
+    alert->retain_period = desc->retain_period;
 
-            ecs_assert(tc.table != NULL, ECS_INTERNAL_ERROR, NULL);
-            int32_t *dirty_state = tc.table->dirty_state;
-            if (!dirty_state) {
-                continue;
+    /* Initialize severity filters */
+    int32_t i;
+    for (i = 0; i < 4; i ++) {
+        if (desc->severity_filters[i].with) {
+            if (!desc->severity_filters[i].severity) {
+                ecs_err("severity filter must have severity");
+                goto error;
             }
-
-            if (table != tc.table) {
-                if (inout == EcsInOutDefault) {
-                    continue;
+            ecs_alert_severity_filter_t *sf = ecs_vec_append_t(NULL, 
+                &alert->severity_filters, ecs_alert_severity_filter_t);
+            *sf = desc->severity_filters[i];
+            if (sf->var) {
+                sf->_var_index = ecs_query_find_var(q, sf->var);
+                if (sf->_var_index == -1) {
+                    ecs_err("unresolved variable '%s' in alert severity filter", 
+                        sf->var);
+                    goto error;
                 }
             }
-
-            ecs_assert(tc.column >= 0, ECS_INTERNAL_ERROR, NULL);
-
-            dirty_state[tc.column + 1] ++;
         }
     }
-}
 
-bool ecs_query_next_table(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+    /* Fetch data for member monitoring */
+    if (desc->member) {
+        alert->member = desc->member;
+        if (!desc->id) {
+            alert->id = ecs_get_parent(world, desc->member);
+            if (!alert->id) {
+                ecs_err("ecs_alert_desc_t::member is not a member");
+                goto error;
+            }
+            ecs_check(alert->id != 0, ECS_INVALID_PARAMETER, NULL);
+        } else {
+            alert->id = desc->id;
+        }
 
-    flecs_iter_validate(it);
+        ecs_id_record_t *idr = flecs_id_record_ensure(world, alert->id);
+        ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (!idr->type_info) {
+            ecs_err("ecs_alert_desc_t::id must be a component");
+            goto error;
+        }
 
-    ecs_query_iter_t *iter = &it->priv.iter.query;
-    ecs_query_table_match_t *node = iter->node;
-    ecs_query_t *query = iter->query;
+        ecs_entity_t type = idr->type_info->component;
+        if (type != ecs_get_parent(world, desc->member)) {
+            char *type_name = ecs_get_fullpath(world, type);
+            ecs_err("member '%s' is not a member of '%s'", 
+                ecs_get_name(world, desc->member), type_name);
+            ecs_os_free(type_name);
+            goto error;
+        }
 
-    ecs_query_table_match_t *prev = iter->prev;
-    if (prev) {
-        if (query->flags & EcsQueryHasMonitor) {
-            flecs_query_sync_match_monitor(query, prev);
+        const EcsMember *member = ecs_get(world, alert->member, EcsMember);
+        if (!member) {
+            ecs_err("ecs_alert_desc_t::member is not a member");
+            goto error;
         }
-        if (query->flags & EcsQueryHasOutTerms) {
-            if (it->count) {
-                flecs_query_mark_columns_dirty(query, prev);
+        if (!member->type) {
+            ecs_err("ecs_alert_desc_t::member must have a type");
+            goto error;
+        }
+        
+        const EcsPrimitive *pr = ecs_get(world, member->type, EcsPrimitive);
+        if (!pr) {
+            ecs_err("ecs_alert_desc_t::member must be of a primitive type");
+            goto error;
+        }
+
+        if (!ecs_has(world, desc->member, EcsMemberRanges)) {
+            ecs_err("ecs_alert_desc_t::member must have warning/error ranges");
+            goto error;
+        }
+
+        int32_t var_id = 0;
+        if (desc->var) {
+            var_id = ecs_query_find_var(q, desc->var);
+            if (var_id == -1) {
+                ecs_err("unresolved variable '%s' in alert member", desc->var);
+                goto error;
             }
         }
-    }
 
-    if (node != iter->last) {
-        it->table = node->table;
-        it->group_id = node->group_id;
-        it->count = 0;
-        iter->node = node->next;
-        iter->prev = node;
-        return true;
+        alert->offset = member->offset;
+        alert->size = idr->type_info->size;
+        alert->kind = pr->kind;
+        alert->ranges = ecs_ref_init(world, desc->member, EcsMemberRanges);
+        alert->var_id = var_id;
     }
 
-error:
-    query->match_count = query->prev_match_count;
-    ecs_iter_fini(it);
-    return false;
-}
+    ecs_modified(world, result, EcsAlert);
 
-static
-void flecs_query_populate_trivial(
-    ecs_iter_t *it,
-    ecs_query_table_match_t *match)
-{;
-    ecs_table_t *table = match->table;
-    int32_t offset, count;
-    if (!it->constrained_vars) {
-        it->offset = offset = 0;
-        it->count = count = ecs_table_count(table);
-    } else {
-        offset = it->offset;
-        count = it->count;
-    }
+    /* Register alert as metric */
+    ecs_add(world, result, EcsMetric);
+    ecs_add_pair(world, result, EcsMetric, EcsCounter);
 
-    it->ids = match->ids;
-    it->sources = match->sources;
-    it->columns = match->columns;
-    it->group_id = match->group_id;
-    it->instance_count = 0;
-    it->references = ecs_vec_first(&match->refs);
+    /* Add severity to alert */
+    ecs_entity_t severity = desc->severity;
+    if (!severity) {
+        severity = EcsAlertError;
+    }
 
-    if (!it->references) {
-        ecs_data_t *data = &table->data;
-        if (!(it->flags & EcsIterNoData)) {
-            int32_t i;
-            for (i = 0; i < it->field_count; i ++) {
-                int32_t column = match->storage_columns[i];
-                if (column < 0) {
-                    it->ptrs[i] = NULL;
-                    continue;
-                }
+    ecs_add_pair(world, result, ecs_id(EcsAlert), severity);
 
-                ecs_size_t size = it->sizes[i];
-                if (!size) {
-                    it->ptrs[i] = NULL;
-                    continue;
-                }
+    if (desc->doc_name) {
+#ifdef FLECS_DOC
+        ecs_doc_set_name(world, result, desc->doc_name);
+#else
+        ecs_err("cannot set doc_name for alert, requires FLECS_DOC addon");
+        goto error;
+#endif
+    }
 
-                it->ptrs[i] = ecs_vec_get(&data->columns[column].data,
-                    it->sizes[i], offset);
-            }
-        }
+    if (desc->brief) {
+#ifdef FLECS_DOC
+        ecs_doc_set_brief(world, result, desc->brief);
+#else
+        ecs_err("cannot set brief for alert, requires FLECS_DOC addon");
+        goto error;
+#endif
+    }
 
-        it->frame_offset += it->table ? ecs_table_count(it->table) : 0;
-        it->table = table;
-        it->entities = ecs_vec_get_t(&data->entities, ecs_entity_t, offset);
-    } else {
-        flecs_iter_populate_data(
-            it->real_world, it, table, offset, count, it->ptrs);
+    return result;
+error:
+    if (result) {
+        ecs_delete(world, result);
     }
+    return 0;
 }
 
-int ecs_query_populate(
-    ecs_iter_t *it,
-    bool when_changed)
+int32_t ecs_get_alert_count(
+    const ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t alert)
 {
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!alert || ecs_has(world, alert, EcsAlert), 
         ECS_INVALID_PARAMETER, NULL);
 
-    ecs_query_iter_t *iter = &it->priv.iter.query;
-    ecs_query_t *query = iter->query;
-    ecs_query_table_match_t *match = iter->prev;
-    ecs_assert(match != NULL, ECS_INVALID_OPERATION, NULL);
-    if (query->flags & EcsQueryTrivialIter) {
-        flecs_query_populate_trivial(it, match);
-        return EcsIterNextYield;
+    const EcsAlertsActive *active = ecs_get(world, entity, EcsAlertsActive);
+    if (!active) {
+        return 0;
     }
 
-    ecs_table_t *table = match->table;
-    ecs_world_t *world = query->filter.world;
-    const ecs_filter_t *filter = &query->filter;
-    ecs_entity_filter_iter_t *ent_it = it->priv.entity_iter;
-    ecs_assert(ent_it != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_table_range_t *range = &ent_it->range;
-    int32_t t, term_count = filter->term_count;
-    int result;
-
-repeat:
-    result = EcsIterNextYield;
-
-    ecs_os_memcpy_n(it->sources, match->sources, ecs_entity_t, 
-        filter->field_count);
-
-    for (t = 0; t < term_count; t ++) {
-        ecs_term_t *term = &filter->terms[t];
-        int32_t field = term->field_index;
-        if (!ecs_term_match_this(term)) {
-            continue;
-        }
-
-        it->ids[field] = match->ids[field];
-        it->columns[field] = match->columns[field];
+    if (alert) {
+        return ecs_map_get(&active->alerts, alert) != NULL;
     }
 
-    if (table) {
-        range->offset = match->offset;
-        range->count = match->count;
-        if (!range->count) {
-            range->count = ecs_table_count(table);
-            ecs_assert(range->count != 0, ECS_INTERNAL_ERROR, NULL);
-        }
+    return ecs_map_count(&active->alerts);
+error:
+    return 0;
+}
 
-        if (match->entity_filter) {
-            ent_it->entity_filter = match->entity_filter;
-            ent_it->columns = match->columns;
-            ent_it->range.table = table;
-            ent_it->it = it;
-            result = flecs_entity_filter_next(ent_it);
-            if (result == EcsIterNext) {
-                goto done;
-            }
-        }
+ecs_entity_t ecs_get_alert(
+    const ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t alert)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(alert != 0, ECS_INVALID_PARAMETER, NULL);
 
-        it->group_id = match->group_id;
-    } else {
-        range->offset = 0;
-        range->count = 0;
+    const EcsAlertsActive *active = ecs_get(world, entity, EcsAlertsActive);
+    if (!active) {
+        return 0;
     }
 
-    if (when_changed) {
-        if (!ecs_query_changed(NULL, it)) {
-            if (result == EcsIterYield) {
-                goto repeat;
-            } else {
-                result = EcsIterNext;
-                goto done;
-            }
-        }
+    ecs_entity_t *ptr = ecs_map_get(&active->alerts, alert);
+    if (ptr) {
+        return ptr[0];
     }
 
-    it->references = ecs_vec_first(&match->refs);
-    it->instance_count = 0;
-
-    flecs_iter_populate_data(world, it, table, range->offset, range->count,
-        it->ptrs);
-
 error:
-done:
-    return result;
+    return 0;
 }
 
-bool ecs_query_next(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+void FlecsAlertsImport(ecs_world_t *world) {
+    ECS_MODULE_DEFINE(world, FlecsAlerts);
 
-    if (flecs_iter_next_row(it)) {
-        return true;
-    }
+    ECS_IMPORT(world, FlecsPipeline);
+    ECS_IMPORT(world, FlecsTimer);
+    ECS_IMPORT(world, FlecsMetrics);
+#ifdef FLECS_DOC
+    ECS_IMPORT(world, FlecsDoc);
+#endif
 
-    return flecs_iter_next_instanced(it, ecs_query_next_instanced(it));
-error:
-    return false;
-}
+    ecs_set_name_prefix(world, "Ecs");
+    ECS_COMPONENT_DEFINE(world, EcsAlert);
+    ecs_remove_pair(world, ecs_id(EcsAlert), ecs_id(EcsIdentifier), EcsSymbol);
+    ECS_COMPONENT_DEFINE(world, EcsAlertsActive);
 
-bool ecs_query_next_instanced(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+    ecs_set_name_prefix(world, "EcsAlert");
+    ECS_COMPONENT_DEFINE(world, EcsAlertInstance);
+    ECS_COMPONENT_DEFINE(world, EcsAlertTimeout);
+
+    ECS_TAG_DEFINE(world, EcsAlertInfo);
+    ECS_TAG_DEFINE(world, EcsAlertWarning);
+    ECS_TAG_DEFINE(world, EcsAlertError);
+    ECS_TAG_DEFINE(world, EcsAlertCritical);
 
-    ecs_query_iter_t *iter = &it->priv.iter.query;
-    ecs_query_t *query = iter->query;
-    ecs_flags32_t flags = query->flags;
+    ecs_add_id(world, ecs_id(EcsAlert), EcsPairIsTag);
+    ecs_add_id(world, ecs_id(EcsAlert), EcsExclusive);
+    ecs_add_id(world, ecs_id(EcsAlertsActive), EcsPrivate);
 
-    ecs_query_table_match_t *prev, *next, *cur = iter->node, *last = iter->last;
-    if ((prev = iter->prev)) {
-        /* Match has been iterated, update monitor for change tracking */
-        if (flags & EcsQueryHasMonitor) {
-            flecs_query_sync_match_monitor(query, prev);
-        }
-        if (flags & EcsQueryHasOutTerms) {
-            flecs_query_mark_columns_dirty(query, prev);
+    ecs_struct(world, {
+        .entity = ecs_id(EcsAlertInstance),
+        .members = {
+            { .name = "message", .type = ecs_id(ecs_string_t) }
         }
-    }
+    });
 
-    flecs_iter_validate(it);
-    iter->skip_count = 0;
+    ecs_set_hooks(world, EcsAlert, {
+        .ctor = ecs_ctor(EcsAlert),
+        .dtor = ecs_dtor(EcsAlert),
+        .move = ecs_move(EcsAlert)
+    });
 
-    /* Trivial iteration: each entry in the cache is a full match and ids are
-     * only matched on $this or through traversal starting from $this. */
-    if (flags & EcsQueryTrivialIter) {
-        if (cur == last) {
-            goto done;
-        }
-        iter->node = cur->next;
-        iter->prev = cur;
-        flecs_query_populate_trivial(it, cur);
-        return true;
-    }
+    ecs_set_hooks(world, EcsAlertsActive, {
+        .ctor = ecs_ctor(EcsAlertsActive),
+        .dtor = ecs_dtor(EcsAlertsActive),
+        .move = ecs_move(EcsAlertsActive)
+    });
 
-    /* Non-trivial iteration: query matches with static sources, or matches with
-     * tables that require per-entity filtering. */
-    for (; cur != last; cur = next) {
-        next = cur->next;
-        iter->prev = cur;
-        switch(ecs_query_populate(it, false)) {
-        case EcsIterNext: iter->node = next; continue;
-        case EcsIterYield: next = cur; /* fall through */
-        case EcsIterNextYield: goto yield;
-        default: ecs_abort(ECS_INTERNAL_ERROR, NULL);
-        }
-    }
+    ecs_set_hooks(world, EcsAlertInstance, {
+        .ctor = flecs_default_ctor,
+        .dtor = ecs_dtor(EcsAlertInstance),
+        .move = ecs_move(EcsAlertInstance),
+        .copy = ecs_copy(EcsAlertInstance)
+    });
 
-done: error:
-    query->match_count = query->prev_match_count;
-    ecs_iter_fini(it);
-    return false;
+    ecs_struct(world, {
+        .entity = ecs_id(EcsAlertsActive),
+        .members = {
+            { .name = "info_count", .type = ecs_id(ecs_i32_t) },
+            { .name = "warning_count", .type = ecs_id(ecs_i32_t) },
+            { .name = "error_count", .type = ecs_id(ecs_i32_t) }
+        }
+    });
 
-yield:
-    iter->node = next;
-    iter->prev = cur;
-    return true;
-}
+    ECS_SYSTEM(world, MonitorAlerts, EcsPreStore, 
+        Alert, 
+        (Poly, Query));
 
-bool ecs_query_changed(
-    ecs_query_t *query,
-    const ecs_iter_t *it)
-{
-    if (it) {
-        ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-        ecs_check(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
-            ECS_INVALID_PARAMETER, NULL);
+    ECS_SYSTEM(world, MonitorAlertInstances, EcsOnStore, Instance, 
+        flecs.metrics.Source, 
+        flecs.metrics.Value, 
+        ?Timeout,
+        ?Disabled);
 
-        ecs_query_table_match_t *qm = 
-            (ecs_query_table_match_t*)it->priv.iter.query.prev;
-        ecs_assert(qm != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_system(world, {
+        .entity = ecs_id(MonitorAlerts),
+        .immediate = true,
+        .interval = (ecs_ftime_t)0.5
+    });
 
-        if (!query) {
-            query = it->priv.iter.query.query;
-        } else {
-            ecs_check(query == it->priv.iter.query.query, 
-                ECS_INVALID_PARAMETER, NULL);
-        }
+    ecs_system(world, {
+        .entity = ecs_id(MonitorAlertInstances),
+        .interval = (ecs_ftime_t)0.5
+    });
+}
 
-        ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
-        ecs_poly_assert(query, ecs_query_t);
+#endif
 
-        return flecs_query_check_match_monitor(query, qm, it);
-    }
+/**
+ * @file addons/app.c
+ * @brief App addon.
+ */
 
-    ecs_poly_assert(query, ecs_query_t);
-    ecs_check(!(query->flags & EcsQueryIsOrphaned), 
-        ECS_INVALID_PARAMETER, NULL);
 
-    flecs_process_pending_tables(query->filter.world);
+#ifdef FLECS_APP
 
-    if (!(query->flags & EcsQueryHasMonitor)) {
-        query->flags |= EcsQueryHasMonitor;
-        flecs_query_init_query_monitors(query);
-        return true; /* Monitors didn't exist yet */
+static
+int flecs_default_run_action(
+    ecs_world_t *world,
+    ecs_app_desc_t *desc)
+{
+    if (desc->init) {
+        desc->init(world);
     }
 
-    if (query->match_count != query->prev_match_count) {
-        return true;
+    int result = 0;
+    if (desc->frames) {
+        int32_t i;
+        for (i = 0; i < desc->frames; i ++) {
+            if ((result = ecs_app_run_frame(world, desc)) != 0) {
+                break;
+            }
+        }
+    } else {
+        while ((result = ecs_app_run_frame(world, desc)) == 0) { }
     }
 
-    return flecs_query_check_query_monitor(query);
-error:
-    return false;
-}
-
-void ecs_query_skip(
-    ecs_iter_t *it)
-{
-    ecs_assert(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
-        ECS_INVALID_PARAMETER, NULL);
+    /* Ensure quit flag is set on world, which can be used to determine if
+     * world needs to be cleaned up. */
+#ifndef __EMSCRIPTEN__
+    ecs_quit(world);
+#endif
 
-    if (it->instance_count > it->count) {
-        it->priv.iter.query.skip_count ++;
-        if (it->priv.iter.query.skip_count == it->instance_count) {
-            /* For non-instanced queries, make sure all entities are skipped */
-            it->priv.iter.query.prev = NULL;
-        }
+    if (result == 1) {
+        return 0; /* Normal exit */
     } else {
-        it->priv.iter.query.prev = NULL;
+        return result; /* Error code */
     }
 }
 
-bool ecs_query_orphaned(
-    const ecs_query_t *query)
+static
+int flecs_default_frame_action(
+    ecs_world_t *world,
+    const ecs_app_desc_t *desc)
 {
-    ecs_poly_assert(query, ecs_query_t);
-    return query->flags & EcsQueryIsOrphaned;
+    return !ecs_progress(world, desc->delta_time);
 }
 
-char* ecs_query_str(
-    const ecs_query_t *query)
-{
-    return ecs_filter_str(query->filter.world, &query->filter);
-}
+static ecs_app_run_action_t run_action = flecs_default_run_action;
+static ecs_app_frame_action_t frame_action = flecs_default_frame_action;
+static ecs_app_desc_t ecs_app_desc;
 
-int32_t ecs_query_table_count(
-    const ecs_query_t *query)
-{
-    ecs_run_aperiodic(query->filter.world, EcsAperiodicEmptyTables);
-    return query->cache.tables.count;
-}
+/* Serve REST API from wasm image when running in emscripten */
+#ifdef ECS_TARGET_EM
+#include <emscripten.h>
 
-int32_t ecs_query_empty_table_count(
-    const ecs_query_t *query)
-{
-    ecs_run_aperiodic(query->filter.world, EcsAperiodicEmptyTables);
-    return query->cache.empty_tables.count;
+ecs_http_server_t *flecs_wasm_rest_server;
+
+EMSCRIPTEN_KEEPALIVE
+char* flecs_explorer_request(const char *method, char *request) {
+    ecs_http_reply_t reply = ECS_HTTP_REPLY_INIT;
+    ecs_http_server_request(flecs_wasm_rest_server, method, request, &reply);
+    if (reply.code == 200) {
+        return ecs_strbuf_get(&reply.body);
+    } else {
+        char *body = ecs_strbuf_get(&reply.body);
+        if (body) {
+            return body;
+        } else {
+            return flecs_asprintf(
+                "{\"error\": \"bad request (code %d)\"}", reply.code);
+        }
+    }
 }
+#endif
 
-int32_t ecs_query_entity_count(
-    const ecs_query_t *query)
+int ecs_app_run(
+    ecs_world_t *world,
+    ecs_app_desc_t *desc)
 {
-    ecs_run_aperiodic(query->filter.world, EcsAperiodicEmptyTables);
-    
-    int32_t result = 0;
-    ecs_table_cache_hdr_t *cur, *last = query->cache.tables.last;
-    if (!last) {
-        return 0;
+    ecs_app_desc = *desc;
+
+    /* Don't set FPS & threads if custom run action is set, as the platform on
+     * which the app is running may not support it. */
+    if (run_action == flecs_default_run_action) {
+        if (ECS_NEQZERO(ecs_app_desc.target_fps)) {
+            ecs_set_target_fps(world, ecs_app_desc.target_fps);
+        }
+        if (ecs_app_desc.threads) {
+            ecs_set_threads(world, ecs_app_desc.threads);
+        }
     }
 
-    for (cur = query->cache.tables.first; cur != NULL; cur = cur->next) {
-        result += ecs_table_count(cur->table);
+    /* REST server enables connecting to app with explorer */
+    if (desc->enable_rest) {
+#ifdef FLECS_REST
+#ifdef ECS_TARGET_EM
+        flecs_wasm_rest_server = ecs_rest_server_init(world, NULL);
+#else
+        ecs_set(world, EcsWorld, EcsRest, {.port = desc->port });
+#endif
+#else
+        ecs_warn("cannot enable remote API, REST addon not available");
+#endif
     }
 
-    return result;
+    /* Monitoring periodically collects statistics */
+    if (desc->enable_monitor) {
+#ifdef FLECS_MONITOR
+        ECS_IMPORT(world, FlecsMonitor);
+#else
+        ecs_warn("cannot enable monitoring, MONITOR addon not available");
+#endif
+    }
+
+    return run_action(world, &ecs_app_desc);
 }
 
-void* ecs_query_get_ctx(
-    const ecs_query_t *query)
+int ecs_app_run_frame(
+    ecs_world_t *world,
+    const ecs_app_desc_t *desc)
 {
-    return query->ctx;
+    return frame_action(world, desc);
 }
 
-void* ecs_query_get_binding_ctx(
-    const ecs_query_t *query)
+int ecs_app_set_run_action(
+    ecs_app_run_action_t callback)
 {
-    return query->binding_ctx;
+    if (run_action != flecs_default_run_action && run_action != callback) {
+        ecs_err("run action already set");
+        return -1;
+    }
+
+    run_action = callback;
+
+    return 0;
 }
 
-/**
- * @file search.c
- * @brief Search functions to find (component) ids in table types.
- * 
- * Search functions are used to find the column index of a (component) id in a
- * table. Additionally, search functions implement the logic for finding a
- * component id by following a relationship upwards.
- */
-
-
-static
-int32_t flecs_type_search(
-    const ecs_table_t *table,
-    ecs_id_t search_id,
-    ecs_id_record_t *idr,
-    ecs_id_t *ids,
-    ecs_id_t *id_out,
-    ecs_table_record_t **tr_out)
-{
-    ecs_table_record_t *tr = ecs_table_cache_get(&idr->cache, table);
-    if (tr) {
-        int32_t r = tr->index;
-        if (tr_out) tr_out[0] = tr;
-        if (id_out) {
-            if (ECS_PAIR_FIRST(search_id) == EcsUnion) {
-                id_out[0] = ids[r];
-            } else {
-                id_out[0] = flecs_to_public_id(ids[r]);
-            }
-        }
-        return r;
-    }
-
-    return -1;
-}
-
-static
-int32_t flecs_type_offset_search(
-    int32_t offset,
-    ecs_id_t id,
-    ecs_id_t *ids,
-    int32_t count,
-    ecs_id_t *id_out)
+int ecs_app_set_frame_action(
+    ecs_app_frame_action_t callback)
 {
-    ecs_assert(ids != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(count > 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(offset > 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
-
-    while (offset < count) {
-        ecs_id_t type_id = ids[offset ++];
-        if (ecs_id_match(type_id, id)) {
-            if (id_out) {
-                id_out[0] = flecs_to_public_id(type_id);
-            }
-            return offset - 1;
-        }
+    if (frame_action != flecs_default_frame_action && frame_action != callback) {
+        ecs_err("frame action already set");
+        return -1;
     }
 
-    return -1;
-}
+    frame_action = callback;
 
-bool flecs_type_can_inherit_id(
-    const ecs_world_t *world,
-    const ecs_table_t *table,
-    const ecs_id_record_t *idr,
-    ecs_id_t id)
-{
-    ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-    if (idr->flags & EcsIdDontInherit) {
-        return false;
-    }
-    if (idr->flags & EcsIdExclusive) {
-        if (ECS_HAS_ID_FLAG(id, PAIR)) {
-            ecs_entity_t er = ECS_PAIR_FIRST(id);
-            if (flecs_table_record_get(
-                world, table, ecs_pair(er, EcsWildcard))) 
-            {
-                return false;
-            }
-        }
-    }
-    return true;
+    return 0;
 }
 
-static
-int32_t flecs_type_search_relation(
-    const ecs_world_t *world,
-    const ecs_table_t *table,
-    int32_t offset,
-    ecs_id_t id,
-    ecs_id_record_t *idr,
-    ecs_id_t rel,
-    ecs_id_record_t *idr_r,
-    bool self,
-    ecs_entity_t *subject_out,
-    ecs_id_t *id_out,
-    ecs_table_record_t **tr_out)
-{
-    ecs_type_t type = table->type;
-    ecs_id_t *ids = type.array;
-    int32_t count = type.count;
-
-    if (self) {
-        if (offset) {
-            int32_t r = flecs_type_offset_search(offset, id, ids, count, id_out);
-            if (r != -1) {
-                return r;
-            }
-        } else {
-            int32_t r = flecs_type_search(table, id, idr, ids, id_out, tr_out);
-            if (r != -1) {
-                return r;
-            }
-        }
-    }
+#endif
 
-    ecs_flags32_t flags = table->flags;
-    if ((flags & EcsTableHasPairs) && rel) {
-        bool is_a = rel == ecs_pair(EcsIsA, EcsWildcard);
-        if (is_a) {
-            if (!(flags & EcsTableHasIsA)) {
-                return -1;
-            }
-            idr_r = world->idr_isa_wildcard;
+/**
+ * @file addons/doc.c
+ * @brief Doc addon.
+ */
 
-            if (!flecs_type_can_inherit_id(world, table, idr, id)) {
-                return -1;
-            }
-        }
 
-        if (!idr_r) {
-            idr_r = flecs_id_record_get(world, rel);
-            if (!idr_r) {
-                return -1;
-            }
-        }
+#ifdef FLECS_DOC
 
-        ecs_id_t id_r;
-        int32_t r, r_column;
-        if (offset) {
-            r_column = flecs_type_offset_search(offset, rel, ids, count, &id_r);
-        } else {
-            r_column = flecs_type_search(table, id, idr_r, ids, &id_r, 0);
-        }
-        while (r_column != -1) {
-            ecs_entity_t obj = ECS_PAIR_SECOND(id_r);
-            ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL);
+static ECS_COPY(EcsDocDescription, dst, src, {
+    ecs_os_strset((char**)&dst->value, src->value);
 
-            ecs_record_t *rec = flecs_entities_get_any(world, obj);
-            ecs_assert(rec != NULL, ECS_INTERNAL_ERROR, NULL);
+})
 
-            ecs_table_t *obj_table = rec->table;
-            if (obj_table) {
-                ecs_assert(obj_table != table, ECS_CYCLE_DETECTED, NULL);
-                
-                r = flecs_type_search_relation(world, obj_table, 0, id, idr, 
-                    rel, idr_r, true, subject_out, id_out, tr_out);
-                if (r != -1) {
-                    if (subject_out && !subject_out[0]) {
-                        subject_out[0] = ecs_get_alive(world, obj);
-                    }
-                    return r_column;
-                }
+static ECS_MOVE(EcsDocDescription, dst, src, {
+    ecs_os_free((char*)dst->value);
+    dst->value = src->value;
+    src->value = NULL;
+})
 
-                if (!is_a) {
-                    r = flecs_type_search_relation(world, obj_table, 0, id, idr, 
-                        ecs_pair(EcsIsA, EcsWildcard), world->idr_isa_wildcard, 
-                            true, subject_out, id_out, tr_out);
-                    if (r != -1) {
-                        if (subject_out && !subject_out[0]) {
-                            subject_out[0] = ecs_get_alive(world, obj);
-                        }
-                        return r_column;
-                    }
-                }
-            }
+static ECS_DTOR(EcsDocDescription, ptr, { 
+    ecs_os_free((char*)ptr->value);
+})
 
-            r_column = flecs_type_offset_search(
-                r_column + 1, rel, ids, count, &id_r);
-        }
+static
+void flecs_doc_set(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    ecs_entity_t kind,
+    const char *value)
+{
+    if (value) {
+        ecs_set_pair(world, entity, EcsDocDescription, kind, {
+            /* Safe, value gets copied by copy hook */
+            .value = ECS_CONST_CAST(char*, value)
+        });
+    } else {
+        ecs_remove_pair(world, entity, ecs_id(EcsDocDescription), kind);
     }
-
-    return -1;
 }
 
-int32_t flecs_search_relation_w_idr(
-    const ecs_world_t *world,
-    const ecs_table_t *table,
-    int32_t offset,
-    ecs_id_t id,
-    ecs_entity_t rel,
-    ecs_flags32_t flags,
-    ecs_entity_t *subject_out,
-    ecs_id_t *id_out,
-    struct ecs_table_record_t **tr_out,
-    ecs_id_record_t *idr)
+void ecs_doc_set_name(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *name)
 {
-    if (!table) return -1;
-
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
-
-    flags = flags ? flags : (EcsSelf|EcsUp);
+    flecs_doc_set(world, entity, EcsName, name);
+}
 
-    if (!idr) {
-        idr = flecs_query_id_record_get(world, id);
-        if (!idr) {
-            return -1;
-        }
-    }
+void ecs_doc_set_brief(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *brief)
+{
+    flecs_doc_set(world, entity, EcsDocBrief, brief);
+}
 
-    if (subject_out) subject_out[0] = 0;
-    if (!(flags & EcsUp)) {
-        if (offset) {
-            return ecs_search_offset(world, table, offset, id, id_out);
-        } else {
-            return flecs_type_search(
-                table, id, idr, table->type.array, id_out, tr_out);
-        }
-    }
+void ecs_doc_set_detail(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *detail)
+{
+    flecs_doc_set(world, entity, EcsDocDetail, detail);
+}
 
-    int32_t result = flecs_type_search_relation(world, table, offset, id, idr, 
-        ecs_pair(rel, EcsWildcard), NULL, flags & EcsSelf, subject_out, 
-            id_out, tr_out);
+void ecs_doc_set_link(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *link)
+{
+    flecs_doc_set(world, entity, EcsDocLink, link);
+}
 
-    return result;
+void ecs_doc_set_color(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *color)
+{
+    flecs_doc_set(world, entity, EcsDocColor, color);
 }
 
-int32_t ecs_search_relation(
+const char* ecs_doc_get_name(
     const ecs_world_t *world,
-    const ecs_table_t *table,
-    int32_t offset,
-    ecs_id_t id,
-    ecs_entity_t rel,
-    ecs_flags32_t flags,
-    ecs_entity_t *subject_out,
-    ecs_id_t *id_out,
-    struct ecs_table_record_t **tr_out)
+    ecs_entity_t entity)
 {
-    if (!table) return -1;
-
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
-
-    flags = flags ? flags : (EcsSelf|EcsUp);
-
-    if (subject_out) subject_out[0] = 0;
-    if (!(flags & EcsUp)) {
-        return ecs_search_offset(world, table, offset, id, id_out);
+    const EcsDocDescription *ptr = ecs_get_pair(
+        world, entity, EcsDocDescription, EcsName);
+    if (ptr) {
+        return ptr->value;
+    } else {
+        return ecs_get_name(world, entity);
     }
+}
 
-    ecs_id_record_t *idr = flecs_query_id_record_get(world, id);
-    if (!idr) {
-        return -1;
+const char* ecs_doc_get_brief(
+    const ecs_world_t *world,
+    ecs_entity_t entity)
+{
+    const EcsDocDescription *ptr = ecs_get_pair(
+        world, entity, EcsDocDescription, EcsDocBrief);
+    if (ptr) {
+        return ptr->value;
+    } else {
+        return NULL;
     }
-
-    int32_t result = flecs_type_search_relation(world, table, offset, id, idr, 
-        ecs_pair(rel, EcsWildcard), NULL, flags & EcsSelf, subject_out, 
-            id_out, tr_out);
-
-    return result;
 }
 
-int32_t flecs_search_w_idr(
+const char* ecs_doc_get_detail(
     const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_id_t id,
-    ecs_id_t *id_out,
-    ecs_id_record_t *idr)
+    ecs_entity_t entity)
 {
-    if (!table) return -1;
-
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
-    (void)world;
-
-    ecs_type_t type = table->type;
-    ecs_id_t *ids = type.array;
-    return flecs_type_search(table, id, idr, ids, id_out, 0);
+    const EcsDocDescription *ptr = ecs_get_pair(
+        world, entity, EcsDocDescription, EcsDocDetail);
+    if (ptr) {
+        return ptr->value;
+    } else {
+        return NULL;
+    }
 }
 
-int32_t ecs_search(
+const char* ecs_doc_get_link(
     const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_id_t id,
-    ecs_id_t *id_out)
+    ecs_entity_t entity)
 {
-    if (!table) return -1;
-
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_id_record_t *idr = flecs_query_id_record_get(world, id);
-    if (!idr) {
-        return -1;
+    const EcsDocDescription *ptr = ecs_get_pair(
+        world, entity, EcsDocDescription, EcsDocLink);
+    if (ptr) {
+        return ptr->value;
+    } else {
+        return NULL;
     }
-
-    ecs_type_t type = table->type;
-    ecs_id_t *ids = type.array;
-    return flecs_type_search(table, id, idr, ids, id_out, 0);
 }
 
-int32_t ecs_search_offset(
+const char* ecs_doc_get_color(
     const ecs_world_t *world,
-    const ecs_table_t *table,
-    int32_t offset,
-    ecs_id_t id,
-    ecs_id_t *id_out)
+    ecs_entity_t entity)
 {
-    if (!offset) {
-        ecs_poly_assert(world, ecs_world_t);
-        return ecs_search(world, table, id, id_out);
+    const EcsDocDescription *ptr = ecs_get_pair(
+        world, entity, EcsDocDescription, EcsDocColor);
+    if (ptr) {
+        return ptr->value;
+    } else {
+        return NULL;
     }
-
-    if (!table) return -1;
-
-    ecs_type_t type = table->type;
-    ecs_id_t *ids = type.array;
-    int32_t count = type.count;
-    return flecs_type_offset_search(offset, id, ids, count, id_out);
 }
 
+/* Doc definitions for core components */
 static
-int32_t flecs_relation_depth_walk(
-    const ecs_world_t *world,
-    const ecs_id_record_t *idr,
-    const ecs_table_t *first,
-    const ecs_table_t *table)
+void flecs_doc_import_core_definitions(
+    ecs_world_t *world)
 {
-    int32_t result = 0;
+    ecs_doc_set_brief(world, EcsFlecs, "Flecs root module");
+    ecs_doc_set_link(world, EcsFlecs, "https://github.com/SanderMertens/flecs");
+    ecs_doc_set_brief(world, EcsFlecsCore, "Module with builtin components");
+    ecs_doc_set_brief(world, EcsFlecsInternals, "Module with internal entities");
 
-    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-    if (!tr) {
-        return 0;
-    }
+    ecs_doc_set_brief(world, EcsWorld, "Entity associated with world");
 
-    int32_t i = tr->index, end = i + tr->count;
-    for (; i != end; i ++) {
-        ecs_entity_t o = ecs_pair_second(world, table->type.array[i]);
-        ecs_assert(o != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_doc_set_brief(world, ecs_id(EcsComponent), "Component that is added to components");
+    ecs_doc_set_brief(world, EcsModule, "Tag that is added to modules");
+    ecs_doc_set_brief(world, EcsPrefab, "Tag that is added to prefabs");
+    ecs_doc_set_brief(world, EcsDisabled, "Tag that is added to disabled entities");
+    ecs_doc_set_brief(world, EcsPrivate, "Tag that is added to private components");
+    ecs_doc_set_brief(world, EcsFlag, "Internal tag for tracking ids with special id flags");
+    ecs_doc_set_brief(world, ecs_id(EcsPoly), "Internal component that stores pointer to poly objects");
 
-        ecs_table_t *ot = ecs_get_table(world, o);
-        if (!ot) {
-            continue;
-        }
-        
-        ecs_assert(ot != first, ECS_CYCLE_DETECTED, NULL);
-        int32_t cur = flecs_relation_depth_walk(world, idr, first, ot);
-        if (cur > result) {
-            result = cur;
-        }
-    }
+    ecs_doc_set_brief(world, ecs_id(EcsIdentifier), "Component used for entity names");
+    ecs_doc_set_brief(world, EcsName, "Tag used with EcsIdentifier to store entity name");
+    ecs_doc_set_brief(world, EcsSymbol, "Tag used with EcsIdentifier to store entity symbol");
+    ecs_doc_set_brief(world, EcsAlias, "Tag used with EcsIdentifier to store entity alias");
     
-    return result + 1;
+    ecs_doc_set_brief(world, EcsQuery, "Tag added to query entities");
+    ecs_doc_set_brief(world, EcsObserver, "Tag added to observer entities");
+
+    ecs_doc_set_brief(world, EcsTransitive, "Trait that enables transitive evaluation of relationships");
+    ecs_doc_set_brief(world, EcsReflexive, "Trait that enables reflexive evaluation of relationships");
+    ecs_doc_set_brief(world, EcsFinal, "Trait that indicates an entity cannot be inherited from");
+    ecs_doc_set_brief(world, EcsDontInherit, "Trait that indicates it should not be inherited");
+    ecs_doc_set_brief(world, EcsPairIsTag, "Trait that ensures a pair cannot contain a value");
+    ecs_doc_set_brief(world, EcsAcyclic, "Trait that indicates a relationship is acyclic");
+    ecs_doc_set_brief(world, EcsTraversable, "Trait that indicates a relationship is traversable");
+    ecs_doc_set_brief(world, EcsExclusive, "Trait that ensures a relationship can only have one target");
+    ecs_doc_set_brief(world, EcsSymmetric, "Trait that causes a relationship to be two-way");
+    ecs_doc_set_brief(world, EcsWith, "Trait for adding additional components when a component is added");
+    ecs_doc_set_brief(world, EcsAlwaysOverride, "Trait that indicates a component should always be overridden");
+    ecs_doc_set_brief(world, EcsOneOf, "Trait that enforces target of relationship is a child of <specified>");
+    ecs_doc_set_brief(world, EcsOnDelete, "Cleanup trait for specifying what happens when component is deleted");
+    ecs_doc_set_brief(world, EcsOnDeleteTarget, "Cleanup trait for specifying what happens when pair target is deleted");
+    ecs_doc_set_brief(world, EcsRemove, "Cleanup action used with OnDelete/OnDeleteTarget");
+    ecs_doc_set_brief(world, EcsDelete, "Cleanup action used with OnDelete/OnDeleteTarget");
+    ecs_doc_set_brief(world, EcsPanic, "Cleanup action used with OnDelete/OnDeleteTarget");
+    ecs_doc_set_brief(world, ecs_id(EcsDefaultChildComponent), "Sets default component hint for children of entity");
+    ecs_doc_set_brief(world, EcsIsA, "Relationship used for expressing inheritance");
+    ecs_doc_set_brief(world, EcsChildOf, "Relationship used for expressing hierarchies");
+    ecs_doc_set_brief(world, EcsDependsOn, "Relationship used for expressing dependencies");
+    ecs_doc_set_brief(world, EcsSlotOf, "Relationship used for expressing prefab slots");
+    ecs_doc_set_brief(world, EcsOnAdd, "Event emitted when component is added");
+    ecs_doc_set_brief(world, EcsOnRemove, "Event emitted when component is removed");
+    ecs_doc_set_brief(world, EcsOnSet, "Event emitted when component is set");
+    ecs_doc_set_brief(world, EcsUnSet, "Event emitted when component is unset");
+    ecs_doc_set_brief(world, EcsMonitor, "Marker used to create monitor observers");
+    ecs_doc_set_brief(world, EcsOnTableFill, "Event emitted when table becomes non-empty");
+    ecs_doc_set_brief(world, EcsOnTableEmpty, "Event emitted when table becomes empty");
+    ecs_doc_set_brief(world, EcsOnTableCreate, "Event emitted when table is created");
+    ecs_doc_set_brief(world, EcsOnTableDelete, "Event emitted when table is deleted");
+
+    ecs_doc_set_brief(world, EcsThis, "Query marker to express $this variable");
+    ecs_doc_set_brief(world, EcsWildcard, "Query marker to express match all wildcard");
+    ecs_doc_set_brief(world, EcsAny, "Query marker to express match at least one wildcard");
+
+    ecs_doc_set_brief(world, EcsPredEq, "Query marker to express == operator");
+    ecs_doc_set_brief(world, EcsPredMatch, "Query marker to express ~= operator");
+    ecs_doc_set_brief(world, EcsPredLookup, "Query marker to express by-name lookup");
+    ecs_doc_set_brief(world, EcsScopeOpen, "Query marker to express scope open");
+    ecs_doc_set_brief(world, EcsScopeClose, "Query marker to express scope close");
+    ecs_doc_set_brief(world, EcsEmpty, "Tag used to indicate a query has no results");
 }
 
-int32_t flecs_relation_depth(
-    const ecs_world_t *world,
-    ecs_entity_t r,
-    const ecs_table_t *table)
+/* Doc definitions for doc components */
+static
+void flecs_doc_import_doc_definitions(
+    ecs_world_t *world)
 {
-    ecs_id_record_t *idr = flecs_id_record_get(world, ecs_pair(r, EcsWildcard));
-    if (!idr) {
-        return 0;
-    }
-
-    int32_t depth_offset = 0;
-    if (table->flags & EcsTableHasTarget) {
-        if (ecs_table_get_type_index(world, table, 
-            ecs_pair_t(EcsFlattenTarget, r)) != -1)
-        {
-            ecs_id_t id;
-            int32_t col = ecs_search(world, table, 
-                ecs_pair(EcsFlatten, EcsWildcard), &id);
-            if (col == -1) {
-                return 0;
-            }
+    ecs_entity_t doc = ecs_lookup(world, "flecs.doc");
+    ecs_doc_set_brief(world, doc, "Flecs module with documentation components");
 
-            ecs_entity_t did = ecs_pair_second(world, id);
-            ecs_assert(did != 0, ECS_INTERNAL_ERROR, NULL);
-            uint64_t *val = ecs_map_get(&world->store.entity_to_depth, did);
-            ecs_assert(val != NULL, ECS_INTERNAL_ERROR, NULL);
-            depth_offset = flecs_uto(int32_t, val[0]);
-        }
-    }
+    ecs_doc_set_brief(world, EcsDocBrief, "Brief description");
+    ecs_doc_set_brief(world, EcsDocDetail, "Detailed description");
+    ecs_doc_set_brief(world, EcsDocLink, "Link to additional documentation");
+    ecs_doc_set_brief(world, EcsDocColor, "Color hint for entity");   
 
-    return flecs_relation_depth_walk(world, idr, table, table) + depth_offset;
+    ecs_doc_set_brief(world, ecs_id(EcsDocDescription), "Component used to add documentation");
+    ecs_doc_set_brief(world, EcsDocBrief, "Used as (Description, Brief) to add a brief description");
+    ecs_doc_set_brief(world, EcsDocDetail, "Used as (Description, Detail) to add a detailed description");
+    ecs_doc_set_brief(world, EcsDocLink, "Used as (Description, Link) to add a link");
 }
 
-/**
- * @file stage.c
- * @brief Staging implementation.
- * 
- * A stage is an object that can be used to temporarily store mutations to a
- * world while a world is in readonly mode. ECS operations that are invoked on
- * a stage are stored in a command buffer, which is flushed during sync points,
- * or manually by the user.
- * 
- * Stages contain additional state to enable other API functionality without
- * having to mutate the world, such as setting the current scope, and allocators
- * that are local to a stage.
- * 
- * In a multi threaded application, each thread has its own stage which allows
- * threads to insert mutations without having to lock administration.
- */
+void FlecsDocImport(
+    ecs_world_t *world)
+{    
+    ECS_MODULE(world, FlecsDoc);
 
+    ecs_set_name_prefix(world, "EcsDoc");
 
-static
-ecs_cmd_t* flecs_cmd_new(
-    ecs_stage_t *stage)
-{
-    ecs_cmd_t *cmd = ecs_vec_append_t(&stage->allocator, &stage->cmd->queue, 
-        ecs_cmd_t);
-    cmd->is._1.value = NULL;
-    cmd->next_for_entity = 0;
-    cmd->entry = NULL;
-    cmd->system = stage->system;
-    return cmd;
-}
-
-static
-ecs_cmd_t* flecs_cmd_new_batched(
-    ecs_stage_t *stage, 
-    ecs_entity_t e)
-{
-    ecs_vec_t *cmds = &stage->cmd->queue;
-    ecs_cmd_entry_t *entry = flecs_sparse_get_any_t(
-        &stage->cmd->entries, ecs_cmd_entry_t, e);
+    flecs_bootstrap_component(world, EcsDocDescription);
+    flecs_bootstrap_tag(world, EcsDocBrief);
+    flecs_bootstrap_tag(world, EcsDocDetail);
+    flecs_bootstrap_tag(world, EcsDocLink);
+    flecs_bootstrap_tag(world, EcsDocColor);
 
-    int32_t cur = ecs_vec_count(cmds);
-    ecs_cmd_t *cmd = flecs_cmd_new(stage);
-    if (entry) {
-        if (entry->first == -1) {
-            /* Existing but invalidated entry */
-            entry->first = cur;
-            cmd->entry = entry;
-        } else {
-            int32_t last = entry->last;
-            ecs_cmd_t *arr = ecs_vec_first_t(cmds, ecs_cmd_t);
-            ecs_assert(arr[last].entity == e, ECS_INTERNAL_ERROR, NULL);
-            ecs_cmd_t *last_op = &arr[last];
-            last_op->next_for_entity = cur;
-            if (last == entry->first) {
-                /* Flip sign bit so flush logic can tell which command
-                 * is the first for an entity */
-                last_op->next_for_entity *= -1;
-            }
-        }
-    } else {
-        cmd->entry = entry = flecs_sparse_ensure_fast_t(
-            &stage->cmd->entries, ecs_cmd_entry_t, e);
-        entry->first = cur;
-    }
+    ecs_set_hooks(world, EcsDocDescription, { 
+        .ctor = flecs_default_ctor,
+        .move = ecs_move(EcsDocDescription),
+        .copy = ecs_copy(EcsDocDescription),
+        .dtor = ecs_dtor(EcsDocDescription)
+    });
 
-    entry->last = cur;
+    ecs_add_id(world, ecs_id(EcsDocDescription), EcsDontInherit);
+    ecs_add_id(world, ecs_id(EcsDocDescription), EcsPrivate);
 
-    return cmd;
+    flecs_doc_import_core_definitions(world);
+    flecs_doc_import_doc_definitions(world);
 }
 
-static
-void flecs_stages_merge(
-    ecs_world_t *world,
-    bool force_merge)
-{
-    bool is_stage = ecs_poly_is(world, ecs_stage_t);
-    ecs_stage_t *stage = flecs_stage_from_world(&world);
-
-    bool measure_frame_time = ECS_BIT_IS_SET(world->flags, 
-        EcsWorldMeasureFrameTime);
+#endif
 
-    ecs_time_t t_start = {0};
-    if (measure_frame_time) {
-        ecs_os_get_time(&t_start);
-    }
+/**
+ * @file addons/flecs_cpp.c
+ * @brief Utilities for C++ addon.
+ */
 
-    ecs_dbg_3("#[magenta]merge");
-    ecs_log_push_3();
+#include <ctype.h>
 
-    if (is_stage) {
-        /* Check for consistency if force_merge is enabled. In practice this
-         * function will never get called with force_merge disabled for just
-         * a single stage. */
-        if (force_merge || stage->auto_merge) {
-            ecs_assert(stage->defer == 1, ECS_INVALID_OPERATION, 
-                "mismatching defer_begin/defer_end detected");
-            flecs_defer_end(world, stage);
-        }
-    } else {
-        /* Merge stages. Only merge if the stage has auto_merging turned on, or 
-         * if this is a forced merge (like when ecs_merge is called) */
-        int32_t i, count = ecs_get_stage_count(world);
-        for (i = 0; i < count; i ++) {
-            ecs_stage_t *s = (ecs_stage_t*)ecs_get_stage(world, i);
-            ecs_poly_assert(s, ecs_stage_t);
-            if (force_merge || s->auto_merge) {
-                flecs_defer_end(world, s);
-            }
-        }
-    }
+/* Utilities for C++ API */
 
-    flecs_eval_component_monitors(world);
+#ifdef FLECS_CPP
 
-    if (measure_frame_time) {
-        world->info.merge_time_total += (ecs_ftime_t)ecs_time_measure(&t_start);
-    }
+/* Convert compiler-specific typenames extracted from __PRETTY_FUNCTION__ to
+ * a uniform identifier */
 
-    world->info.merge_count_total ++; 
+#define ECS_CONST_PREFIX "const "
+#define ECS_STRUCT_PREFIX "struct "
+#define ECS_CLASS_PREFIX "class "
+#define ECS_ENUM_PREFIX "enum "
 
-    /* If stage is asynchronous, deferring is always enabled */
-    if (stage->async) {
-        flecs_defer_begin(world, stage);
-    }
-    
-    ecs_log_pop_3();
-}
+#define ECS_CONST_LEN (-1 + (ecs_size_t)sizeof(ECS_CONST_PREFIX))
+#define ECS_STRUCT_LEN (-1 + (ecs_size_t)sizeof(ECS_STRUCT_PREFIX))
+#define ECS_CLASS_LEN (-1 + (ecs_size_t)sizeof(ECS_CLASS_PREFIX))
+#define ECS_ENUM_LEN (-1 + (ecs_size_t)sizeof(ECS_ENUM_PREFIX))
 
 static
-void flecs_stage_auto_merge(
-    ecs_world_t *world)
+ecs_size_t ecs_cpp_strip_prefix(
+    char *typeName,
+    ecs_size_t len,
+    const char *prefix,
+    ecs_size_t prefix_len)
 {
-    flecs_stages_merge(world, false);
+    if ((len > prefix_len) && !ecs_os_strncmp(typeName, prefix, prefix_len)) {
+        ecs_os_memmove(typeName, typeName + prefix_len, len - prefix_len);
+        typeName[len - prefix_len] = '\0';
+        len -= prefix_len;
+    }
+    return len;
 }
 
-static
-void flecs_stage_manual_merge(
-    ecs_world_t *world)
+static 
+void ecs_cpp_trim_type_name(
+    char *typeName) 
 {
-    flecs_stages_merge(world, true);
-}
+    ecs_size_t len = ecs_os_strlen(typeName);
 
-bool flecs_defer_begin(
-    ecs_world_t *world,
-    ecs_stage_t *stage)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_assert(stage, ecs_stage_t);
-    (void)world;
-    if (stage->defer < 0) return false;
-    return (++ stage->defer) == 1;
-}
+    len = ecs_cpp_strip_prefix(typeName, len, ECS_CONST_PREFIX, ECS_CONST_LEN);
+    len = ecs_cpp_strip_prefix(typeName, len, ECS_STRUCT_PREFIX, ECS_STRUCT_LEN);
+    len = ecs_cpp_strip_prefix(typeName, len, ECS_CLASS_PREFIX, ECS_CLASS_LEN);
+    len = ecs_cpp_strip_prefix(typeName, len, ECS_ENUM_PREFIX, ECS_ENUM_LEN);
 
-bool flecs_defer_cmd(
-    ecs_stage_t *stage)
-{
-    if (stage->defer) {
-        return (stage->defer > 0);
+    while (typeName[len - 1] == ' ' ||
+            typeName[len - 1] == '&' ||
+            typeName[len - 1] == '*') 
+    {
+        len --;
+        typeName[len] = '\0';
     }
 
-    stage->defer ++;
-    return false;
-}
-
-bool flecs_defer_modified(
-    ecs_stage_t *stage,
-    ecs_entity_t entity,
-    ecs_id_t id)
-{
-    if (flecs_defer_cmd(stage)) {
-        ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity);
-        if (cmd) {
-            cmd->kind = EcsCmdModified;
-            cmd->id = id;
-            cmd->entity = entity;
+    /* Remove const at end of string */
+    if (len > ECS_CONST_LEN) {
+        if (!ecs_os_strncmp(&typeName[len - ECS_CONST_LEN], " const", ECS_CONST_LEN)) {
+            typeName[len - ECS_CONST_LEN] = '\0';
         }
-        return true;
+        len -= ECS_CONST_LEN;
     }
-    return false;
-}
 
-bool flecs_defer_clone(
-    ecs_stage_t *stage,
-    ecs_entity_t entity,
-    ecs_entity_t src,
-    bool clone_value)
-{   
-    if (flecs_defer_cmd(stage)) {
-        ecs_cmd_t *cmd = flecs_cmd_new(stage);
-        cmd->kind = EcsCmdClone;
-        cmd->id = src;
-        cmd->entity = entity;
-        cmd->is._1.clone_value = clone_value;
-        return true;
+    /* Check if there are any remaining "struct " strings, which can happen
+     * if this is a template type on msvc. */
+    if (len > ECS_STRUCT_LEN) {
+        char *ptr = typeName;
+        while ((ptr = strstr(ptr + 1, ECS_STRUCT_PREFIX)) != 0) {
+            /* Make sure we're not matched with part of a longer identifier
+             * that contains 'struct' */
+            if (ptr[-1] == '<' || ptr[-1] == ',' || isspace(ptr[-1])) {
+                ecs_os_memmove(ptr, ptr + ECS_STRUCT_LEN, 
+                    ecs_os_strlen(ptr + ECS_STRUCT_LEN) + 1);
+                len -= ECS_STRUCT_LEN;
+            }
+        }
     }
-    return false;   
 }
 
-bool flecs_defer_path(
-    ecs_stage_t *stage,
-    ecs_entity_t parent,
-    ecs_entity_t entity,
-    const char *name)
+char* ecs_cpp_get_type_name(
+    char *type_name, 
+    const char *func_name,
+    size_t len,
+    size_t front_len)
 {
-    if (stage->defer > 0) {
-        ecs_cmd_t *cmd = flecs_cmd_new(stage);
-        cmd->kind = EcsCmdPath;
-        cmd->entity = entity;
-        cmd->id = parent;
-        cmd->is._1.value = ecs_os_strdup(name);
-        return true;
-    }
-    return false;
+    memcpy(type_name, func_name + front_len, len);
+    type_name[len] = '\0';
+    ecs_cpp_trim_type_name(type_name);
+    return type_name;
 }
 
-bool flecs_defer_delete(
-    ecs_stage_t *stage,
-    ecs_entity_t entity)
+char* ecs_cpp_get_symbol_name(
+    char *symbol_name,
+    const char *type_name,
+    size_t len)
 {
-    if (flecs_defer_cmd(stage)) {
-        ecs_cmd_t *cmd = flecs_cmd_new(stage);
-        cmd->kind = EcsCmdDelete;
-        cmd->entity = entity;
-        return true;
+    // Symbol is same as name, but with '::' replaced with '.'
+    ecs_os_strcpy(symbol_name, type_name);
+
+    char *ptr;
+    size_t i;
+    for (i = 0, ptr = symbol_name; i < len && *ptr; i ++, ptr ++) {
+        if (*ptr == ':') {
+            symbol_name[i] = '.';
+            ptr ++;
+        } else {
+            symbol_name[i] = *ptr;
+        }
     }
-    return false;
+
+    symbol_name[i] = '\0';
+
+    return symbol_name;
 }
 
-bool flecs_defer_clear(
-    ecs_stage_t *stage,
-    ecs_entity_t entity)
+static
+const char* flecs_cpp_func_rchr(
+    const char *func_name,
+    ecs_size_t func_name_len,
+    ecs_size_t func_back_len,
+    char ch)
 {
-    if (flecs_defer_cmd(stage)) {
-        ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity);
-        cmd->kind = EcsCmdClear;
-        cmd->entity = entity;
-        return true;
+    const char *r = strrchr(func_name, ch);
+    if ((r - func_name) >= (func_name_len - flecs_uto(ecs_size_t, func_back_len))) {
+        return NULL;
     }
-    return false;
+    return r;
 }
 
-bool flecs_defer_on_delete_action(
-    ecs_stage_t *stage,
-    ecs_id_t id,
-    ecs_entity_t action)
+static
+const char* flecs_cpp_func_max(
+    const char *a,
+    const char *b)
 {
-    if (flecs_defer_cmd(stage)) {
-        ecs_cmd_t *cmd = flecs_cmd_new(stage);
-        cmd->kind = EcsCmdOnDeleteAction;
-        cmd->id = id;
-        cmd->entity = action;
-        return true;
-    }
-    return false;
+    if (a > b) return a;
+    return b;
 }
 
-bool flecs_defer_enable(
-    ecs_stage_t *stage,
-    ecs_entity_t entity,
-    ecs_id_t id,
-    bool enable)
+char* ecs_cpp_get_constant_name(
+    char *constant_name,
+    const char *func_name,
+    size_t func_name_len,
+    size_t func_back_len)
 {
-    if (flecs_defer_cmd(stage)) {
-        ecs_cmd_t *cmd = flecs_cmd_new(stage);
-        cmd->kind = enable ? EcsCmdEnable : EcsCmdDisable;
-        cmd->entity = entity;
-        cmd->id = id;
-        return true;
-    }
-    return false;
+    ecs_size_t f_len = flecs_uto(ecs_size_t, func_name_len);
+    ecs_size_t fb_len = flecs_uto(ecs_size_t, func_back_len);
+    const char *start = flecs_cpp_func_rchr(func_name, f_len, fb_len, ' ');
+    start = flecs_cpp_func_max(start, flecs_cpp_func_rchr(
+        func_name, f_len, fb_len, ')'));
+    start = flecs_cpp_func_max(start, flecs_cpp_func_rchr(
+        func_name, f_len, fb_len, ':'));
+    start = flecs_cpp_func_max(start, flecs_cpp_func_rchr(
+        func_name, f_len, fb_len, ','));
+    ecs_assert(start != NULL, ECS_INVALID_PARAMETER, func_name);
+    start ++;
+    
+    ecs_size_t len = flecs_uto(ecs_size_t, 
+        (f_len - (start - func_name) - fb_len));
+    ecs_os_memcpy_n(constant_name, start, char, len);
+    constant_name[len] = '\0';
+    return constant_name;
 }
 
-bool flecs_defer_bulk_new(
+// Names returned from the name_helper class do not start with ::
+// but are relative to the root. If the namespace of the type
+// overlaps with the namespace of the current module, strip it from
+// the implicit identifier.
+// This allows for registration of component types that are not in the 
+// module namespace to still be registered under the module scope.
+const char* ecs_cpp_trim_module(
     ecs_world_t *world,
-    ecs_stage_t *stage,
-    int32_t count,
-    ecs_id_t id,
-    const ecs_entity_t **ids_out)
+    const char *type_name)
 {
-    if (flecs_defer_cmd(stage)) {
-        ecs_entity_t *ids = ecs_os_malloc(count * ECS_SIZEOF(ecs_entity_t));
-
-        /* Use ecs_new_id as this is thread safe */
-        int i;
-        for (i = 0; i < count; i ++) {
-            ids[i] = ecs_new_id(world);
-        }
+    ecs_entity_t scope = ecs_get_scope(world);
+    if (!scope) {
+        return type_name;
+    }
 
-        *ids_out = ids;
+    char *path = ecs_get_path_w_sep(world, 0, scope, "::", NULL);
+    if (path) {
+        ecs_size_t len = ecs_os_strlen(path);
+        if (!ecs_os_strncmp(path, type_name, len)) {
+            // Type is a child of current parent, trim name of parent
+            type_name += len;
+            ecs_assert(type_name[0], ECS_INVALID_PARAMETER, 
+                "invalid C++ type name");
+            ecs_assert(type_name[0] == ':', ECS_INVALID_PARAMETER,
+                "invalid C++ type name");
+            ecs_assert(type_name[1] == ':', ECS_INVALID_PARAMETER,
+                "invalid C++ type name");
+            type_name += 2;
+        } else {
+            // Type is not a child of current parent, trim entire path
+            char *ptr = strrchr(type_name, ':');
+            if (ptr) {
+                type_name = ptr + 1;
+            }
 
-        /* Store data in op */
-        ecs_cmd_t *cmd = flecs_cmd_new(stage);
-        cmd->kind = EcsCmdBulkNew;
-        cmd->id = id;
-        cmd->is._n.entities = ids;
-        cmd->is._n.count = count;
-        cmd->entity = 0;
-        return true;
+        }
     }
-    return false;
-}
+    ecs_os_free(path);
 
-bool flecs_defer_add(
-    ecs_stage_t *stage,
-    ecs_entity_t entity,
-    ecs_id_t id)
-{
-    if (flecs_defer_cmd(stage)) {
-        ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
-        ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity);
-        cmd->kind = EcsCmdAdd;
-        cmd->id = id;
-        cmd->entity = entity;
-        return true;
-    }
-    return false;
+    return type_name;
 }
 
-bool flecs_defer_remove(
-    ecs_stage_t *stage,
-    ecs_entity_t entity,
-    ecs_id_t id)
+// Validate registered component
+void ecs_cpp_component_validate(
+    ecs_world_t *world,
+    ecs_entity_t id,
+    const char *name,
+    const char *symbol,
+    size_t size,
+    size_t alignment,
+    bool implicit_name)
 {
-    if (flecs_defer_cmd(stage)) {
-        ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
-        ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity); 
-        cmd->kind = EcsCmdRemove;
-        cmd->id = id;
-        cmd->entity = entity;
-        return true;
+    /* If entity has a name check if it matches */
+    if (ecs_is_valid(world, id) && ecs_get_name(world, id) != NULL) {
+        if (!implicit_name && id >= EcsFirstUserComponentId) {
+#ifndef FLECS_NDEBUG
+            char *path = ecs_get_path_w_sep(
+                world, 0, id, "::", NULL);
+            if (ecs_os_strcmp(path, name)) {
+                ecs_abort(ECS_INCONSISTENT_NAME,
+                    "component '%s' already registered with name '%s'",
+                    name, path);
+            }
+            ecs_os_free(path);
+#endif
+        }
+
+        if (symbol) {
+            const char *existing_symbol = ecs_get_symbol(world, id);
+            if (existing_symbol) {
+                if (ecs_os_strcmp(symbol, existing_symbol)) {
+                    ecs_abort(ECS_INCONSISTENT_NAME,
+                        "component '%s' with symbol '%s' already registered with symbol '%s'",
+                        name, symbol, existing_symbol);
+                }
+            }
+        }
+    } else {
+        /* Ensure that the entity id valid */
+        if (!ecs_is_alive(world, id)) {
+            ecs_make_alive(world, id);
+        }
+
+        /* Register name with entity, so that when the entity is created the
+        * correct id will be resolved from the name. Only do this when the
+        * entity is empty. */
+        ecs_add_path_w_sep(world, id, 0, name, "::", "::");
     }
-    return false;
+
+    /* If a component was already registered with this id but with a 
+     * different size, the ecs_component_init function will fail. */
+
+    /* We need to explicitly call ecs_component_init here again. Even though
+     * the component was already registered, it may have been registered
+     * with a different world. This ensures that the component is registered
+     * with the same id for the current world. 
+     * If the component was registered already, nothing will change. */
+    ecs_entity_t ent = ecs_component_init(world, &(ecs_component_desc_t){
+        .entity = id,
+        .type.size = flecs_uto(int32_t, size),
+        .type.alignment = flecs_uto(int32_t, alignment)
+    });
+    (void)ent;
+    ecs_assert(ent == id, ECS_INTERNAL_ERROR, NULL);
 }
 
-void* flecs_defer_set(
+ecs_entity_t ecs_cpp_component_register(
     ecs_world_t *world,
-    ecs_stage_t *stage,
-    ecs_cmd_kind_t cmd_kind,
-    ecs_entity_t entity,
-    ecs_id_t id,
+    ecs_entity_t id,
+    const char *name,
+    const char *symbol,
     ecs_size_t size,
-    void *value)
+    ecs_size_t alignment,
+    bool implicit_name,
+    bool *existing_out)
 {
-    ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity);
+    (void)size;
+    (void)alignment;
 
-    /* Find type info for id */
-    const ecs_type_info_t *ti = NULL;
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        /* If idr doesn't exist yet, create it but only if the 
-         * application is not multithreaded. */
-        if (stage->async || (world->flags & EcsWorldMultiThreaded)) {
-            ti = ecs_get_type_info(world, id);
-            ecs_assert(ti != NULL, ECS_INVALID_PARAMETER, NULL);
-        } else {
-            /* When not in multi threaded mode, it's safe to find or 
-             * create the id record. */
-            idr = flecs_id_record_ensure(world, id);
-            ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-            
-            /* Get type_info from id record. We could have called 
-             * ecs_get_type_info directly, but since this function can be
-             * expensive for pairs, creating the id record ensures we can
-             * find the type_info quickly for subsequent operations. */
-            ti = idr->type_info;
-        }
+    /* If the component is not yet registered, ensure no other component
+     * or entity has been registered with this name. Ensure component is 
+     * looked up from root. */
+    bool existing = false;
+    ecs_entity_t prev_scope = ecs_set_scope(world, 0);
+    ecs_entity_t ent;
+    if (id) {
+        ent = id;
     } else {
-        ti = idr->type_info;
+        ent = ecs_lookup_path_w_sep(world, 0, name, "::", "::", false);
+        existing = ent != 0 && ecs_has(world, ent, EcsComponent);
     }
+    ecs_set_scope(world, prev_scope);
 
-    /* If the id isn't associated with a type, we can't set anything */
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    /* Make sure the size of the value equals the type size */
-    ecs_assert(!size || size == ti->size, ECS_INVALID_PARAMETER, NULL);
-    size = ti->size;
-
-    /* Find existing component. Make sure it's owned, so that we won't use the
-     * component of a prefab. */
-    void *existing = NULL;
-    ecs_table_t *table = NULL;
-    if (idr) {
-        /* Entity can only have existing component if id record exists */
-        ecs_record_t *r = flecs_entities_get(world, entity);
-        table = r->table;
-        if (r && table) {
-            const ecs_table_record_t *tr = flecs_id_record_get_table(
-                idr, table);
-            if (tr) {
-                ecs_assert(tr->column != -1, ECS_NOT_A_COMPONENT, NULL);
-                /* Entity has the component */
-                ecs_vec_t *column = &table->data.columns[tr->column].data;
-                existing = ecs_vec_get(column, size, ECS_RECORD_TO_ROW(r->row));
+    /* If entity exists, compare symbol name to ensure that the component
+     * we are trying to register under this name is the same */
+    if (ent) {
+        const EcsComponent *component = ecs_get(world, ent, EcsComponent);
+        if (component != NULL) {
+            const char *sym = ecs_get_symbol(world, ent);
+            if (sym && ecs_os_strcmp(sym, symbol)) {
+                /* Application is trying to register a type with an entity that
+                 * was already associated with another type. In most cases this
+                 * is an error, with the exception of a scenario where the
+                 * application is wrapping a C type with a C++ type.
+                 * 
+                 * In this case the C++ type typically inherits from the C type,
+                 * and adds convenience methods to the derived class without
+                 * changing anything that would change the size or layout.
+                 * 
+                 * To meet this condition, the new type must have the same size
+                 * and alignment as the existing type, and the name of the type
+                 * type must be equal to the registered name (not symbol).
+                 * 
+                 * The latter ensures that it was the intent of the application
+                 * to alias the type, vs. accidentally registering an unrelated
+                 * type with the same size/alignment. */
+                char *type_path = ecs_get_fullpath(world, ent);
+                if (ecs_os_strcmp(type_path, symbol) || 
+                    component->size != size || 
+                    component->alignment != alignment) 
+                {
+                    ecs_err(
+                        "component with name '%s' is already registered for"\
+                        " type '%s' (trying to register for type '%s')",
+                            name, sym, symbol);
+                    ecs_abort(ECS_NAME_IN_USE, NULL);
+                }
+                ecs_os_free(type_path);
+            } else if (!sym) {
+                ecs_set_symbol(world, ent, symbol);
             }
         }
-    }
 
-    /* Get existing value from storage */
-    void *cmd_value = existing;
-    bool emplace = cmd_kind == EcsCmdEmplace;
+    /* If no entity is found, lookup symbol to check if the component was
+     * registered under a different name. */
+    } else if (!implicit_name) {
+        ent = ecs_lookup_symbol(world, symbol, false, false);
+        ecs_assert(ent == 0 || (ent == id), ECS_INCONSISTENT_COMPONENT_ID, symbol);
+    }
 
-    /* If the component does not yet exist, create a temporary value. This is
-     * necessary so we can store a component value in the deferred command,
-     * without adding the component to the entity which is not allowed in 
-     * deferred mode. */
-    if (!existing) {
-        ecs_stack_t *stack = &stage->cmd->stack;
-        cmd_value = flecs_stack_alloc(stack, size, ti->alignment);
+    if (existing_out) {
+        *existing_out = existing;
+    }
 
-        /* If the component doesn't yet exist, construct it and move the 
-         * provided value into the component, if provided. Don't construct if
-         * this is an emplace operation, in which case the application is
-         * responsible for constructing. */
-        if (value) {
-            if (emplace) {
-                ecs_move_t move = ti->hooks.move_ctor;
-                if (move) {
-                    move(cmd_value, value, 1, ti);
-                } else {
-                    ecs_os_memcpy(cmd_value, value, size);
-                }
-            } else {
-                ecs_copy_t copy = ti->hooks.copy_ctor;
-                if (copy) {
-                    copy(cmd_value, value, 1, ti);
-                } else {
-                    ecs_os_memcpy(cmd_value, value, size);
-                }
-            }
-        } else if (!emplace) {
-            /* If the command is not an emplace, construct the temp storage */
+    return ent;
+}
 
-            /* Check if entity inherits component */
-            void *base = NULL;
-            if (table && (table->flags & EcsTableHasIsA)) {
-                base = flecs_get_base_component(world, table, id, idr, 0);
-            }
+ecs_entity_t ecs_cpp_component_register_explicit(
+    ecs_world_t *world,
+    ecs_entity_t s_id,
+    ecs_entity_t id,
+    const char *name,
+    const char *type_name,
+    const char *symbol,
+    size_t size,
+    size_t alignment,
+    bool is_component,
+    bool *existing_out)
+{
+    char *existing_name = NULL;
+    if (existing_out) *existing_out = false;
 
-            if (!base) {
-                /* Normal ctor */
-                ecs_xtor_t ctor = ti->hooks.ctor;
-                if (ctor) {
-                    ctor(cmd_value, 1, ti);
-                }
+    // If an explicit id is provided, it is possible that the symbol and
+    // name differ from the actual type, as the application may alias
+    // one type to another.
+    if (!id) {
+        if (!name) {
+            // If no name was provided first check if a type with the provided
+            // symbol was already registered.
+            id = ecs_lookup_symbol(world, symbol, false, false);
+            if (id) {
+                existing_name = ecs_get_path_w_sep(world, 0, id, "::", "::");
+                name = existing_name;
+                if (existing_out) *existing_out = true;
             } else {
-                /* Override */
-                ecs_copy_t copy = ti->hooks.copy_ctor;
-                if (copy) {
-                    copy(cmd_value, base, 1, ti);
-                } else {
-                    ecs_os_memcpy(cmd_value, base, size);
-                }
+                // If type is not yet known, derive from type name
+                name = ecs_cpp_trim_module(world, type_name);
             }
         }
-    } else if (value) {
-        /* If component exists and value is provided, copy */
-        ecs_copy_t copy = ti->hooks.copy;
-        if (copy) {
-            copy(existing, value, 1, ti);
-        } else {
-            ecs_os_memcpy(existing, value, size);
+    } else {
+        // If an explicit id is provided but it has no name, inherit
+        // the name from the type.
+        if (!ecs_is_valid(world, id) || !ecs_get_name(world, id)) {
+            name = ecs_cpp_trim_module(world, type_name);
         }
     }
 
-    if (!cmd) {
-        /* If cmd is NULL, entity was already deleted. Check if we need to
-         * insert a command into the queue. */
-        if (!ti->hooks.dtor) {
-            /* If temporary memory does not need to be destructed, it'll get 
-             * freed when the stack allocator is reset. This prevents us
-             * from having to insert a command when the entity was 
-             * already deleted. */
-            return cmd_value;
-        }
-        cmd = flecs_cmd_new(stage);
-    }
+    ecs_entity_t entity;
+    if (is_component || size != 0) {
+        entity = ecs_entity(world, {
+            .id = s_id,
+            .name = name,
+            .sep = "::",
+            .root_sep = "::",
+            .symbol = symbol,
+            .use_low_id = true
+        });
+        ecs_assert(entity != 0, ECS_INVALID_OPERATION, 
+            "registration failed for component %s", name);
 
-    if (!existing) {
-        /* If component didn't exist yet, insert command that will create it */
-        cmd->kind = cmd_kind;
-        cmd->id = id;
-        cmd->idr = idr;
-        cmd->entity = entity;
-        cmd->is._1.size = size;
-        cmd->is._1.value = cmd_value;
+        entity = ecs_component_init(world, &(ecs_component_desc_t){
+            .entity = entity,
+            .type.size = flecs_uto(int32_t, size),
+            .type.alignment = flecs_uto(int32_t, alignment)
+        });
+        ecs_assert(entity != 0, ECS_INVALID_OPERATION, 
+            "registration failed for component %s", name);
     } else {
-        /* If component already exists, still insert an Add command to ensure
-         * that any preceding remove commands won't remove the component. If the
-         * operation is a set, also insert a Modified command. */
-        if (cmd_kind == EcsCmdSet) {
-            cmd->kind = EcsCmdAddModified; 
-        } else {
-            cmd->kind = EcsCmdAdd;
-        }
-        cmd->id = id;
-        cmd->entity = entity;
+        entity = ecs_entity(world, {
+            .id = s_id,
+            .name = name,
+            .sep = "::",
+            .root_sep = "::",
+            .symbol = symbol,
+            .use_low_id = true
+        });
     }
 
-    return cmd_value;
-error:
-    return NULL;
+    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!s_id || s_id == entity, ECS_INTERNAL_ERROR, NULL);
+    ecs_os_free(existing_name);
+
+    return entity;
 }
 
-void flecs_enqueue(
+void ecs_cpp_enum_init(
     ecs_world_t *world,
-    ecs_stage_t *stage,
-    ecs_event_desc_t *desc)
+    ecs_entity_t id)
 {
-    ecs_cmd_t *cmd = flecs_cmd_new(stage);
-    cmd->kind = EcsCmdEvent;
-    cmd->entity = desc->entity;
+    (void)world;
+    (void)id;
+#ifdef FLECS_META
+    ecs_suspend_readonly_state_t readonly_state;
+    world = flecs_suspend_readonly(world, &readonly_state);
+    ecs_set(world, id, EcsEnum, {0});
+    flecs_resume_readonly(world, &readonly_state);
+#endif
+}
 
-    ecs_stack_t *stack = &stage->cmd->stack;
-    ecs_event_desc_t *desc_cmd = flecs_stack_alloc_t(stack, ecs_event_desc_t);
-    ecs_os_memcpy_t(desc_cmd, desc, ecs_event_desc_t);
+ecs_entity_t ecs_cpp_enum_constant_register(
+    ecs_world_t *world,
+    ecs_entity_t parent,
+    ecs_entity_t id,
+    const char *name,
+    int value)
+{
+    ecs_suspend_readonly_state_t readonly_state;
+    world = flecs_suspend_readonly(world, &readonly_state);
 
-    if (desc->ids && desc->ids->count != 0) {
-        ecs_type_t *type_cmd = flecs_stack_alloc_t(stack, ecs_type_t);
-        int32_t id_count = desc->ids->count;
-        type_cmd->count = id_count;
-        type_cmd->array = flecs_stack_alloc_n(stack, ecs_id_t, id_count);
-        ecs_os_memcpy_n(type_cmd->array, desc->ids->array, ecs_id_t, id_count);
-        desc_cmd->ids = type_cmd;
-    } else {
-        desc_cmd->ids = NULL;
+    const char *parent_name = ecs_get_name(world, parent);
+    ecs_size_t parent_name_len = ecs_os_strlen(parent_name);
+    if (!ecs_os_strncmp(name, parent_name, parent_name_len)) {
+        name += parent_name_len;
+        if (name[0] == '_') {
+            name ++;
+        }
     }
 
-    cmd->is._1.value = desc_cmd;
-    cmd->is._1.size = ECS_SIZEOF(ecs_event_desc_t);
+    ecs_entity_t prev = ecs_set_scope(world, parent);
+    id = ecs_entity(world, {
+        .id = id,
+        .name = name
+    });
+    ecs_assert(id != 0, ECS_INVALID_OPERATION, name);
+    ecs_set_scope(world, prev);
 
-    if (desc->param || desc->const_param) {
-        ecs_assert(!(desc->const_param && desc->param), ECS_INVALID_PARAMETER, 
-            "cannot set param and const_param at the same time");
+    #ifdef FLECS_DEBUG
+    const EcsComponent *cptr = ecs_get(world, parent, EcsComponent);
+    ecs_assert(cptr != NULL, ECS_INVALID_PARAMETER, "enum is not a component");
+    ecs_assert(cptr->size == ECS_SIZEOF(int32_t), ECS_UNSUPPORTED,
+        "enum component must have 32bit size");
+    #endif
 
-        const ecs_type_info_t *ti = ecs_get_type_info(world, desc->event);
-        ecs_assert(ti != NULL, ECS_INVALID_PARAMETER, 
-            "can only enqueue events with data for events that are components");
+#ifdef FLECS_META
+    ecs_set_id(world, id, ecs_pair(EcsConstant, ecs_id(ecs_i32_t)), 
+        sizeof(ecs_i32_t), &value);
+#endif
 
-        void *param_cmd = flecs_stack_alloc(stack, ti->size, ti->alignment);
-        ecs_assert(param_cmd != NULL, ECS_INTERNAL_ERROR, NULL);
-        if (desc->param) {
-            if (ti->hooks.move_ctor) {
-                ti->hooks.move_ctor(param_cmd, desc->param, 1, ti);
-            } else {
-                ecs_os_memcpy(param_cmd, desc->param, ti->size);
-            }
-        } else {
-            if (ti->hooks.copy_ctor) {
-                ti->hooks.copy_ctor(param_cmd, desc->const_param, 1, ti);
-            } else {
-                ecs_os_memcpy(param_cmd, desc->const_param, ti->size);
-            }
-        }
+    flecs_resume_readonly(world, &readonly_state);
 
-        desc_cmd->param = param_cmd;
-        desc_cmd->const_param = NULL;
-    }
+    ecs_trace("#[green]constant#[reset] %s.%s created with value %d", 
+        ecs_get_name(world, parent), name, value);
+
+    return id;
 }
 
-void flecs_stage_merge_post_frame(
-    ecs_world_t *world,
-    ecs_stage_t *stage)
-{
-    /* Execute post frame actions */
-    int32_t i, count = ecs_vec_count(&stage->post_frame_actions);
-    ecs_action_elem_t *elems = ecs_vec_first(&stage->post_frame_actions);
-    for (i = 0; i < count; i ++) {
-        elems[i].action(world, elems[i].ctx);
-    }
+static int32_t flecs_reset_count = 0;
 
-    ecs_vec_clear(&stage->post_frame_actions);
+int32_t ecs_cpp_reset_count_get(void) {
+    return flecs_reset_count;
 }
 
-static
-void flecs_commands_init(
-    ecs_stage_t *stage,
-    ecs_commands_t *cmd)
-{
-    flecs_stack_init(&cmd->stack);
-    ecs_vec_init_t(&stage->allocator, &cmd->queue, ecs_cmd_t, 0);
-    flecs_sparse_init_t(&cmd->entries, &stage->allocator,
-        &stage->allocators.cmd_entry_chunk, ecs_cmd_entry_t);
+int32_t ecs_cpp_reset_count_inc(void) {
+    return ++flecs_reset_count;
 }
 
-static
-void flecs_commands_fini(
-    ecs_stage_t *stage,
-    ecs_commands_t *cmd)
+#ifdef FLECS_META
+const ecs_member_t* ecs_cpp_last_member(
+    const ecs_world_t *world, 
+    ecs_entity_t type)
 {
-    /* Make sure stage has no unmerged data */
-    ecs_assert(ecs_vec_count(&stage->cmd->queue) == 0, ECS_INTERNAL_ERROR, NULL);
+    const EcsStruct *st = ecs_get(world, type, EcsStruct);
+    if (!st) {
+        char *type_str = ecs_get_fullpath(world, type);
+        ecs_err("entity '%s' is not a struct", type_str);
+        ecs_os_free(type_str);
+        return 0;
+    }
 
-    flecs_stack_fini(&cmd->stack);
-    ecs_vec_fini_t(&stage->allocator, &cmd->queue, ecs_cmd_t);
-    flecs_sparse_fini(&cmd->entries);
-}
+    ecs_member_t *m = ecs_vec_get_t(&st->members, ecs_member_t, 
+        ecs_vec_count(&st->members) - 1);
+    ecs_assert(m != NULL, ECS_INTERNAL_ERROR, NULL);
 
-void flecs_commands_push(
-    ecs_stage_t *stage)
-{
-    int32_t sp = ++ stage->cmd_sp;
-    ecs_assert(sp < ECS_MAX_DEFER_STACK, ECS_INTERNAL_ERROR, NULL);
-    stage->cmd = &stage->cmd_stack[sp];
+    return m;
 }
+#endif
 
-void flecs_commands_pop(
-    ecs_stage_t *stage)
-{
-    int32_t sp = -- stage->cmd_sp;
-    ecs_assert(sp >= 0, ECS_INTERNAL_ERROR, NULL);
-    stage->cmd = &stage->cmd_stack[sp];
-}
+#endif
 
-void flecs_stage_init(
-    ecs_world_t *world,
-    ecs_stage_t *stage)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_init(stage, ecs_stage_t);
+/**
+ * @file addons/http.c
+ * @brief HTTP addon.
+ *
+ * This is a heavily modified version of the EmbeddableWebServer (see copyright
+ * below). This version has been stripped from everything not strictly necessary
+ * for receiving/replying to simple HTTP requests, and has been modified to use
+ * the Flecs OS API.
+ *
+ * EmbeddableWebServer Copyright (c) 2016, 2019, 2020 Forrest Heller, and 
+ * CONTRIBUTORS (see below) - All rights reserved.
+ *
+ * CONTRIBUTORS:
+ * Martin Pulec - bug fixes, warning fixes, IPv6 support
+ * Daniel Barry - bug fix (ifa_addr != NULL)
+ * 
+ * Released under the BSD 2-clause license:
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice, 
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice, 
+ * this list of conditions and the following disclaimer in the documentation 
+ * and/or other materials provided with the distribution. THIS SOFTWARE IS 
+ * PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS 
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN 
+ * NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY 
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
 
-    stage->world = world;
-    stage->thread_ctx = world;
-    stage->auto_merge = true;
-    stage->async = false;
 
-    flecs_stack_init(&stage->allocators.iter_stack);
-    flecs_stack_init(&stage->allocators.deser_stack);
-    flecs_allocator_init(&stage->allocator);
-    flecs_ballocator_init_n(&stage->allocators.cmd_entry_chunk, ecs_cmd_entry_t,
-        FLECS_SPARSE_PAGE_SIZE);
+#ifdef FLECS_HTTP
 
-    ecs_allocator_t *a = &stage->allocator;
-    ecs_vec_init_t(a, &stage->post_frame_actions, ecs_action_elem_t, 0);
+#ifdef ECS_TARGET_MSVC
+#pragma comment(lib, "Ws2_32.lib")
+#endif
 
-    int32_t i;
-    for (i = 0; i < ECS_MAX_DEFER_STACK; i ++) {
-        flecs_commands_init(stage, &stage->cmd_stack[i]);
-    }
+#if defined(ECS_TARGET_WINDOWS)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+typedef SOCKET ecs_http_socket_t;
+#else
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netdb.h>
+#include <strings.h>
+#include <signal.h>
+#include <fcntl.h>
+#ifdef __FreeBSD__
+#include <netinet/in.h>
+#endif
+typedef int ecs_http_socket_t;
 
-    stage->cmd = &stage->cmd_stack[0];
-}
+#if !defined(MSG_NOSIGNAL)
+#define MSG_NOSIGNAL (0)
+#endif
 
-void flecs_stage_fini(
-    ecs_world_t *world,
-    ecs_stage_t *stage)
-{
-    (void)world;
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_assert(stage, ecs_stage_t);
+#endif
 
-    ecs_poly_fini(stage, ecs_stage_t);
+/* Max length of request method */
+#define ECS_HTTP_METHOD_LEN_MAX (8) 
 
-    ecs_allocator_t *a = &stage->allocator;
-    
-    ecs_vec_fini_t(a, &stage->post_frame_actions, ecs_action_elem_t);
-    ecs_vec_fini(NULL, &stage->variables, 0);
-    ecs_vec_fini(NULL, &stage->operations, 0);
+/* Timeout (s) before connection purge */
+#define ECS_HTTP_CONNECTION_PURGE_TIMEOUT (1.0)
 
-    int32_t i;
-    for (i = 0; i < ECS_MAX_DEFER_STACK; i ++) {
-        flecs_commands_fini(stage, &stage->cmd_stack[i]);
-    }
+/* Number of dequeues before purging */
+#define ECS_HTTP_CONNECTION_PURGE_RETRY_COUNT (5)
 
-    flecs_stack_fini(&stage->allocators.iter_stack);
-    flecs_stack_fini(&stage->allocators.deser_stack);
-    flecs_ballocator_fini(&stage->allocators.cmd_entry_chunk);
-    flecs_allocator_fini(&stage->allocator);
-}
+/* Number of retries receiving request */
+#define ECS_HTTP_REQUEST_RECV_RETRY (10)
 
-void ecs_set_stage_count(
-    ecs_world_t *world,
-    int32_t stage_count)
-{
-    ecs_poly_assert(world, ecs_world_t);
+/* Minimum interval between dequeueing requests (ms) */
+#define ECS_HTTP_MIN_DEQUEUE_INTERVAL (50)
 
-    /* World must have at least one default stage */
-    ecs_assert(stage_count >= 1 || (world->flags & EcsWorldFini), 
-        ECS_INTERNAL_ERROR, NULL);
+/* Minimum interval between printing statistics (ms) */
+#define ECS_HTTP_MIN_STATS_INTERVAL (10 * 1000)
 
-    bool auto_merge = true;
-    const ecs_entity_t *lookup_path = NULL;
-    ecs_entity_t scope = 0;
-    ecs_entity_t with = 0;
-    if (world->stage_count >= 1) {
-        auto_merge = world->stages[0].auto_merge;
-        lookup_path = world->stages[0].lookup_path;
-        scope = world->stages[0].scope;
-        with = world->stages[0].with;
-    }
+/* Receive buffer size */
+#define ECS_HTTP_SEND_RECV_BUFFER_SIZE (16 * 1024)
 
-    int32_t i, count = world->stage_count;
-    if (count && count != stage_count) {
-        ecs_stage_t *stages = world->stages;
+/* Max length of request (path + query + headers + body) */
+#define ECS_HTTP_REQUEST_LEN_MAX (10 * 1024 * 1024)
 
-        for (i = 0; i < count; i ++) {
-            /* If stage contains a thread handle, ecs_set_threads was used to
-             * create the stages. ecs_set_threads and ecs_set_stage_count should not
-             * be mixed. */
-            ecs_poly_assert(&stages[i], ecs_stage_t);
-            ecs_check(stages[i].thread == 0, ECS_INVALID_OPERATION, NULL);
-            flecs_stage_fini(world, &stages[i]);
-        }
-
-        ecs_os_free(world->stages);
-    }
-
-    if (stage_count) {
-        world->stages = ecs_os_malloc_n(ecs_stage_t, stage_count);
+/* Total number of outstanding send requests */
+#define ECS_HTTP_SEND_QUEUE_MAX (256)
 
-        for (i = 0; i < stage_count; i ++) {
-            ecs_stage_t *stage = &world->stages[i];
-            flecs_stage_init(world, stage);
-            stage->id = i;
+/* Global statistics */
+int64_t ecs_http_request_received_count = 0;
+int64_t ecs_http_request_invalid_count = 0;
+int64_t ecs_http_request_handled_ok_count = 0;
+int64_t ecs_http_request_handled_error_count = 0;
+int64_t ecs_http_request_not_handled_count = 0;
+int64_t ecs_http_request_preflight_count = 0;
+int64_t ecs_http_send_ok_count = 0;
+int64_t ecs_http_send_error_count = 0;
+int64_t ecs_http_busy_count = 0;
 
-            /* Set thread_ctx to stage, as this stage might be used in a
-             * multithreaded context */
-            stage->thread_ctx = (ecs_world_t*)stage;
-            stage->thread = 0;
-        }
-    } else {
-        /* Set to NULL to prevent double frees */
-        world->stages = NULL;
-    }
+/* Send request queue */
+typedef struct ecs_http_send_request_t {
+    ecs_http_socket_t sock;
+    char *headers;
+    int32_t header_length;
+    char *content;
+    int32_t content_length;
+} ecs_http_send_request_t;
 
-    /* Regardless of whether the stage was just initialized or not, when the
-     * ecs_set_stage_count function is called, all stages inherit the auto_merge
-     * property from the world */
-    for (i = 0; i < stage_count; i ++) {
-        world->stages[i].auto_merge = auto_merge;
-        world->stages[i].lookup_path = lookup_path;
-        world->stages[0].scope = scope;
-        world->stages[0].with = with;
-    }
+typedef struct ecs_http_send_queue_t {
+    ecs_http_send_request_t requests[ECS_HTTP_SEND_QUEUE_MAX];
+    int32_t head;
+    int32_t tail;
+    ecs_os_thread_t thread;
+    int32_t wait_ms;
+} ecs_http_send_queue_t;
 
-    world->stage_count = stage_count;
-error:
-    return;
-}
+typedef struct ecs_http_request_key_t {
+    const char *array;
+    ecs_size_t count;
+} ecs_http_request_key_t;
 
-int32_t ecs_get_stage_count(
-    const ecs_world_t *world)
-{
-    world = ecs_get_world(world);
-    return world->stage_count;
-}
+typedef struct ecs_http_request_entry_t {
+    char *content;
+    int32_t content_length;
+    int code;
+    double time;
+} ecs_http_request_entry_t;
 
-int32_t ecs_get_stage_id(
-    const ecs_world_t *world)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+/* HTTP server struct */
+struct ecs_http_server_t {
+    bool should_run;
+    bool running;
 
-    if (ecs_poly_is(world, ecs_stage_t)) {
-        ecs_stage_t *stage = ECS_CONST_CAST(ecs_stage_t*, world);
+    ecs_http_socket_t sock;
+    ecs_os_mutex_t lock;
+    ecs_os_thread_t thread;
 
-        /* Index 0 is reserved for main stage */
-        return stage->id;
-    } else if (ecs_poly_is(world, ecs_world_t)) {
-        return 0;
-    } else {
-        ecs_throw(ECS_INTERNAL_ERROR, NULL);
-    }
-error:
-    return 0;
-}
+    ecs_http_reply_action_t callback;
+    void *ctx;
 
-ecs_world_t* ecs_get_stage(
-    const ecs_world_t *world,
-    int32_t stage_id)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(world->stage_count > stage_id, ECS_INVALID_PARAMETER, NULL);
-    return (ecs_world_t*)&world->stages[stage_id];
-error:
-    return NULL;
-}
+    double cache_timeout;
+    double cache_purge_timeout;
 
-bool ecs_readonly_begin(
-    ecs_world_t *world,
-    bool multi_threaded)
-{
-    ecs_poly_assert(world, ecs_world_t);
+    ecs_sparse_t connections; /* sparse<http_connection_t> */
+    ecs_sparse_t requests; /* sparse<http_request_t> */
 
-    flecs_process_pending_tables(world);
+    bool initialized;
 
-    ecs_dbg_3("#[bold]readonly");
-    ecs_log_push_3();
+    uint16_t port;
+    const char *ipaddr;
 
-    int32_t i, count = ecs_get_stage_count(world);
-    for (i = 0; i < count; i ++) {
-        ecs_stage_t *stage = &world->stages[i];
-        stage->lookup_path = world->stages[0].lookup_path;
-        ecs_assert(stage->defer == 0, ECS_INVALID_OPERATION, 
-            "deferred mode cannot be enabled when entering readonly mode");
-        flecs_defer_begin(world, stage);
-    }
+    double dequeue_timeout; /* used to not lock request queue too often */
+    double stats_timeout; /* used for periodic reporting of statistics */
 
-    bool is_readonly = ECS_BIT_IS_SET(world->flags, EcsWorldReadonly);
+    double request_time; /* time spent on requests in last stats interval */
+    double request_time_total; /* total time spent on requests */
+    int32_t requests_processed; /* requests processed in last stats interval */
+    int32_t requests_processed_total; /* total requests processed */
+    int32_t dequeue_count; /* number of dequeues in last stats interval */ 
+    ecs_http_send_queue_t send_queue;
 
-    /* From this point on, the world is "locked" for mutations, and it is only 
-     * allowed to enqueue commands from stages */
-    ECS_BIT_SET(world->flags, EcsWorldReadonly);
-    ECS_BIT_COND(world->flags, EcsWorldMultiThreaded, multi_threaded);
+    ecs_hashmap_t request_cache;
+};
 
-    return is_readonly;
-}
+/** Fragment state, used by HTTP request parser */
+typedef enum  {
+    HttpFragStateBegin,
+    HttpFragStateMethod,
+    HttpFragStatePath,
+    HttpFragStateVersion,
+    HttpFragStateHeaderStart,
+    HttpFragStateHeaderName,
+    HttpFragStateHeaderValueStart,
+    HttpFragStateHeaderValue,
+    HttpFragStateCR,
+    HttpFragStateCRLF,
+    HttpFragStateCRLFCR,
+    HttpFragStateBody,
+    HttpFragStateDone
+} HttpFragState;
 
-void ecs_readonly_end(
-    ecs_world_t *world)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(world->flags & EcsWorldReadonly, ECS_INVALID_OPERATION, NULL);
+/** A fragment is a partially received HTTP request */
+typedef struct {
+    HttpFragState state;
+    ecs_strbuf_t buf;
+    ecs_http_method_t method;
+    int32_t body_offset;
+    int32_t query_offset;
+    int32_t header_offsets[ECS_HTTP_HEADER_COUNT_MAX];
+    int32_t header_value_offsets[ECS_HTTP_HEADER_COUNT_MAX];
+    int32_t header_count;
+    int32_t param_offsets[ECS_HTTP_QUERY_PARAM_COUNT_MAX];
+    int32_t param_value_offsets[ECS_HTTP_QUERY_PARAM_COUNT_MAX];
+    int32_t param_count;
+    int32_t content_length;
+    char *header_buf_ptr;
+    char header_buf[32];
+    bool parse_content_length;
+    bool invalid;
+} ecs_http_fragment_t;
 
-    /* After this it is safe again to mutate the world directly */
-    ECS_BIT_CLEAR(world->flags, EcsWorldReadonly);
-    ECS_BIT_CLEAR(world->flags, EcsWorldMultiThreaded);
+/** Extend public connection type with fragment data */
+typedef struct {
+    ecs_http_connection_t pub;
+    ecs_http_socket_t sock;
 
-    ecs_log_pop_3();
+    /* Connection is purged after both timeout expires and connection has
+     * exceeded retry count. This ensures that a connection does not immediately
+     * timeout when a frame takes longer than usual */
+    double dequeue_timeout;
+    int32_t dequeue_retries;    
+} ecs_http_connection_impl_t;
 
-    flecs_stage_auto_merge(world);
-error:
-    return;
-}
+typedef struct {
+    ecs_http_request_t pub;
+    uint64_t conn_id; /* for sanity check */
+    char *res;
+    int32_t req_len;
+} ecs_http_request_impl_t;
 
-void ecs_merge(
-    ecs_world_t *world)
+static
+ecs_size_t http_send(
+    ecs_http_socket_t sock, 
+    const void *buf, 
+    ecs_size_t size, 
+    int flags)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_poly_is(world, ecs_world_t) || 
-               ecs_poly_is(world, ecs_stage_t), ECS_INVALID_PARAMETER, NULL);
-    flecs_stage_manual_merge(world);
-error:
-    return;
+    ecs_assert(size >= 0, ECS_INTERNAL_ERROR, NULL);
+#ifdef ECS_TARGET_POSIX
+    ssize_t send_bytes = send(sock, buf, flecs_itosize(size), 
+        flags | MSG_NOSIGNAL);
+    return flecs_itoi32(send_bytes);
+#else
+    int send_bytes = send(sock, buf, size, flags);
+    return flecs_itoi32(send_bytes);
+#endif
 }
 
-void ecs_set_automerge(
-    ecs_world_t *world,
-    bool auto_merge)
+static
+ecs_size_t http_recv(
+    ecs_http_socket_t sock,
+    void *buf,
+    ecs_size_t size,
+    int flags)
 {
-    /* If a world is provided, set auto_merge globally for the world. This
-     * doesn't actually do anything (the main stage never merges) but it serves
-     * as the default for when stages are created. */
-    if (ecs_poly_is(world, ecs_world_t)) {
-        world->stages[0].auto_merge = auto_merge;
+    ecs_size_t ret;
+#ifdef ECS_TARGET_POSIX
+    ssize_t recv_bytes = recv(sock, buf, flecs_itosize(size), flags);
+    ret = flecs_itoi32(recv_bytes);
+#else
+    int recv_bytes = recv(sock, buf, size, flags);
+    ret = flecs_itoi32(recv_bytes);
+#endif
+    if (ret == -1) {
+        ecs_dbg("recv failed: %s (sock = %d)", ecs_os_strerror(errno), sock);
+    } else if (ret == 0) {
+        ecs_dbg("recv: received 0 bytes (sock = %d)", sock);
+    }
 
-        /* Propagate change to all stages */
-        int i, stage_count = ecs_get_stage_count(world);
-        for (i = 0; i < stage_count; i ++) {
-            ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i);
-            stage->auto_merge = auto_merge;
-        }
+    return ret;
+}
 
-    /* If a stage is provided, override the auto_merge value for the individual
-     * stage. This allows an application to control per-stage which stage should
-     * be automatically merged and which one shouldn't */
-    } else {
-        ecs_poly_assert(world, ecs_stage_t);
-        ecs_stage_t *stage = (ecs_stage_t*)world;
-        stage->auto_merge = auto_merge;
+static
+void http_sock_set_timeout(
+    ecs_http_socket_t sock,
+    int32_t timeout_ms)
+{
+    int r;
+#ifdef ECS_TARGET_POSIX
+    struct timeval tv;
+    tv.tv_sec = timeout_ms * 1000;
+    tv.tv_usec = 0;
+    r = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv);
+#else
+    DWORD t = (DWORD)timeout_ms;
+    r = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&t, sizeof t);
+#endif
+    if (r) {
+        ecs_warn("http: failed to set socket timeout: %s", 
+            ecs_os_strerror(errno));
     }
 }
 
-bool ecs_stage_is_readonly(
-    const ecs_world_t *stage)
+static
+void http_sock_keep_alive(
+    ecs_http_socket_t sock)
 {
-    const ecs_world_t *world = ecs_get_world(stage);
-
-    if (ecs_poly_is(stage, ecs_stage_t)) {
-        if (((const ecs_stage_t*)stage)->async) {
-            return false;
-        }
+    int v = 1;
+    if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (const char*)&v, sizeof v)) {
+        ecs_warn("http: failed to set socket KEEPALIVE: %s",
+            ecs_os_strerror(errno));
     }
+}
 
-    if (world->flags & EcsWorldReadonly) {
-        if (ecs_poly_is(stage, ecs_world_t)) {
-            return true;
-        }
+static
+void http_sock_nonblock(ecs_http_socket_t sock, bool enable) {
+    (void)sock;
+    (void)enable;
+#ifdef ECS_TARGET_POSIX
+    int flags;
+    flags = fcntl(sock,F_GETFL,0);
+    if (flags == -1) {
+        ecs_warn("http: failed to set socket NONBLOCK: %s",
+            ecs_os_strerror(errno));
+        return;
+    }
+    if (enable) {
+        flags = fcntl(sock, F_SETFL, flags | O_NONBLOCK);
     } else {
-        if (ecs_poly_is(stage, ecs_stage_t)) {
-            return true;
-        }
+        flags = fcntl(sock, F_SETFL, flags & ~O_NONBLOCK);
     }
-
-    return false;
+    if (flags == -1) {
+        ecs_warn("http: failed to set socket NONBLOCK: %s",
+            ecs_os_strerror(errno));
+        return;
+    }
+#endif
 }
 
-ecs_world_t* ecs_async_stage_new(
-    ecs_world_t *world)
+static
+int http_getnameinfo(
+    const struct sockaddr* addr,
+    ecs_size_t addr_len,
+    char *host,
+    ecs_size_t host_len,
+    char *port,
+    ecs_size_t port_len,
+    int flags)
 {
-    ecs_stage_t *stage = ecs_os_calloc(sizeof(ecs_stage_t));
-    flecs_stage_init(world, stage);
-
-    stage->id = -1;
-    stage->auto_merge = false;
-    stage->async = true;
-
-    flecs_defer_begin(world, stage);
-
-    return (ecs_world_t*)stage;
+    ecs_assert(addr_len > 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(host_len > 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(port_len > 0, ECS_INTERNAL_ERROR, NULL);
+#if defined(ECS_TARGET_WINDOWS)
+    return getnameinfo(addr, addr_len, host, 
+        flecs_ito(uint32_t, host_len), port, flecs_ito(uint32_t, port_len), 
+        flags);
+#else
+    return getnameinfo(addr, flecs_ito(uint32_t, addr_len), host, 
+        flecs_ito(uint32_t, host_len), port, flecs_ito(uint32_t, port_len), 
+        flags);
+#endif
 }
 
-void ecs_async_stage_free(
-    ecs_world_t *world)
+static
+int http_bind(
+    ecs_http_socket_t sock,
+    const struct sockaddr* addr,
+    ecs_size_t addr_len)
 {
-    ecs_poly_assert(world, ecs_stage_t);
-    ecs_stage_t *stage = (ecs_stage_t*)world;
-    ecs_check(stage->async == true, ECS_INVALID_PARAMETER, NULL);
-    flecs_stage_fini(stage->world, stage);
-    ecs_os_free(stage);
-error:
-    return;
+    ecs_assert(addr_len > 0, ECS_INTERNAL_ERROR, NULL);
+#if defined(ECS_TARGET_WINDOWS)
+    return bind(sock, addr, addr_len);
+#else
+    return bind(sock, addr, flecs_ito(uint32_t, addr_len));
+#endif
 }
 
-bool ecs_stage_is_async(
-    ecs_world_t *stage)
+static
+bool http_socket_is_valid(
+    ecs_http_socket_t sock)
 {
-    if (!stage) {
-        return false;
-    }
-    
-    if (!ecs_poly_is(stage, ecs_stage_t)) {
-        return false;
-    }
-
-    return ((ecs_stage_t*)stage)->async;
+#if defined(ECS_TARGET_WINDOWS)
+    return sock != INVALID_SOCKET;
+#else
+    return sock >= 0;
+#endif
 }
 
-bool ecs_is_deferred(
-    const ecs_world_t *world)
+#if defined(ECS_TARGET_WINDOWS)
+#define HTTP_SOCKET_INVALID INVALID_SOCKET
+#else
+#define HTTP_SOCKET_INVALID (-1)
+#endif
+
+static
+void http_close(
+    ecs_http_socket_t *sock)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    const ecs_stage_t *stage = flecs_stage_from_readonly_world(world);
-    return stage->defer > 0;
-error:
-    return false;
+    ecs_assert(sock != NULL, ECS_INTERNAL_ERROR, NULL);
+
+#if defined(ECS_TARGET_WINDOWS)
+    closesocket(*sock);
+#else
+    ecs_dbg_2("http: closing socket %u", *sock);
+    shutdown(*sock, SHUT_RDWR);
+    close(*sock);
+#endif
+    *sock = HTTP_SOCKET_INVALID;
 }
 
-ecs_entity_t flecs_stage_set_system(
-    ecs_stage_t *stage,
-    ecs_entity_t system)
+static
+ecs_http_socket_t http_accept(
+    ecs_http_socket_t sock,
+    struct sockaddr* addr,
+    ecs_size_t *addr_len)
 {
-    ecs_entity_t old = stage->system;
-    stage->system = system;
-    return old;
+    socklen_t len = (socklen_t)addr_len[0];
+    ecs_http_socket_t result = accept(sock, addr, &len);
+    addr_len[0] = (ecs_size_t)len;
+    return result;
 }
 
-/**
- * @file value.c
- * @brief Utility functions to work with non-trivial pointers of user types.
- */
+static
+void http_reply_fini(ecs_http_reply_t* reply) {
+    ecs_assert(reply != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_os_free(reply->body.content);
+}
 
+static
+void http_request_fini(ecs_http_request_impl_t *req) {
+    ecs_assert(req != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(req->pub.conn != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(req->pub.conn->server != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(req->pub.conn->id == req->conn_id, ECS_INTERNAL_ERROR, NULL);
+    ecs_os_free(req->res);
+    flecs_sparse_remove_t(&req->pub.conn->server->requests, 
+        ecs_http_request_impl_t, req->pub.id);
+}
 
-int ecs_value_init_w_type_info(
-    const ecs_world_t *world,
-    const ecs_type_info_t *ti,
-    void *ptr)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
-    (void)world;
+static
+void http_connection_free(ecs_http_connection_impl_t *conn) {
+    ecs_assert(conn != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(conn->pub.id != 0, ECS_INTERNAL_ERROR, NULL);
+    uint64_t conn_id = conn->pub.id;
 
-    ecs_xtor_t ctor;
-    if ((ctor = ti->hooks.ctor)) {
-        ctor(ptr, 1, ti);
-    } else {
-        ecs_os_memset(ptr, 0, ti->size);
+    if (http_socket_is_valid(conn->sock)) {
+        http_close(&conn->sock);
     }
 
-    return 0;
-error:
-    return -1;
+    flecs_sparse_remove_t(&conn->pub.server->connections, 
+        ecs_http_connection_impl_t, conn_id);
 }
 
-int ecs_value_init(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    void *ptr)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
-    return ecs_value_init_w_type_info(world, ti, ptr);
-error:
-    return -1;
+// https://stackoverflow.com/questions/10156409/convert-hex-string-char-to-int
+static
+char http_hex_2_int(char a, char b){
+    a = (a <= '9') ? (char)(a - '0') : (char)((a & 0x7) + 9);
+    b = (b <= '9') ? (char)(b - '0') : (char)((b & 0x7) + 9);
+    return (char)((a << 4) + b);
 }
 
-void* ecs_value_new_w_type_info(
-    ecs_world_t *world,
-    const ecs_type_info_t *ti)
+static
+void http_decode_url_str(
+    char *str) 
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
-    (void)world;
-
-    void *result = flecs_alloc(&world->allocator, ti->size);
-    if (ecs_value_init_w_type_info(world, ti, result) != 0) {
-        flecs_free(&world->allocator, ti->size, result);
-        goto error;
+    char ch, *ptr, *dst = str;
+    for (ptr = str; (ch = *ptr); ptr++) {
+        if (ch == '%') {
+            dst[0] = http_hex_2_int(ptr[1], ptr[2]);
+            dst ++;
+            ptr += 2;
+        } else {
+            dst[0] = ptr[0];
+            dst ++;
+        }
     }
-
-    return result;
-error:
-    return NULL;
+    dst[0] = '\0';
 }
 
-void* ecs_value_new(
-    ecs_world_t *world,
-    ecs_entity_t type)
+static
+void http_parse_method(
+    ecs_http_fragment_t *frag)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
-
-    return ecs_value_new_w_type_info(world, ti);
-error:
-    return NULL;
+    char *method = ecs_strbuf_get_small(&frag->buf);
+    if (!ecs_os_strcmp(method, "GET")) frag->method = EcsHttpGet;
+    else if (!ecs_os_strcmp(method, "POST")) frag->method = EcsHttpPost;
+    else if (!ecs_os_strcmp(method, "PUT")) frag->method = EcsHttpPut;
+    else if (!ecs_os_strcmp(method, "DELETE")) frag->method = EcsHttpDelete;
+    else if (!ecs_os_strcmp(method, "OPTIONS")) frag->method = EcsHttpOptions;
+    else {
+        frag->method = EcsHttpMethodUnsupported;
+        frag->invalid = true;
+    }
+    ecs_strbuf_reset(&frag->buf);
 }
 
-int ecs_value_fini_w_type_info(
-    const ecs_world_t *world,
-    const ecs_type_info_t *ti,
-    void *ptr)
+static
+bool http_header_writable(
+    ecs_http_fragment_t *frag)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
-    (void)world;
-
-    ecs_xtor_t dtor;
-    if ((dtor = ti->hooks.dtor)) {
-        dtor(ptr, 1, ti);
-    }
-
-    return 0;
-error:
-    return -1;
+    return frag->header_count < ECS_HTTP_HEADER_COUNT_MAX;
 }
 
-int ecs_value_fini(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    void* ptr)
+static
+void http_header_buf_reset(
+    ecs_http_fragment_t *frag)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    (void)world;
-    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
-    return ecs_value_fini_w_type_info(world, ti, ptr);
-error:
-    return -1;
+    frag->header_buf[0] = '\0';
+    frag->header_buf_ptr = frag->header_buf;
 }
 
-int ecs_value_free(
-    ecs_world_t *world,
-    ecs_entity_t type,
-    void* ptr)
+static
+void http_header_buf_append(
+    ecs_http_fragment_t *frag,
+    char ch)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
-    if (ecs_value_fini_w_type_info(world, ti, ptr) != 0) {
-        goto error;
+    if ((frag->header_buf_ptr - frag->header_buf) < 
+        ECS_SIZEOF(frag->header_buf)) 
+    {
+        frag->header_buf_ptr[0] = ch;
+        frag->header_buf_ptr ++;
+    } else {
+        frag->header_buf_ptr[0] = '\0';
     }
+}
 
-    flecs_free(&world->allocator, ti->size, ptr);
-
-    return 0;
-error:
-    return -1;
+static
+uint64_t http_request_key_hash(const void *ptr) {
+    const ecs_http_request_key_t *key = ptr;
+    const char *array = key->array;
+    int32_t count = key->count;
+    return flecs_hash(array, count * ECS_SIZEOF(char));
 }
 
-int ecs_value_copy_w_type_info(
-    const ecs_world_t *world,
-    const ecs_type_info_t *ti,
-    void* dst,
-    const void *src)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
-    (void)world;
+static
+int http_request_key_compare(const void *ptr_1, const void *ptr_2) {
+    const ecs_http_request_key_t *type_1 = ptr_1;
+    const ecs_http_request_key_t *type_2 = ptr_2;
 
-    ecs_copy_t copy;
-    if ((copy = ti->hooks.copy)) {
-        copy(dst, src, 1, ti);
-    } else {
-        ecs_os_memcpy(dst, src, ti->size);
+    int32_t count_1 = type_1->count;
+    int32_t count_2 = type_2->count;
+
+    if (count_1 != count_2) {
+        return (count_1 > count_2) - (count_1 < count_2);
     }
 
-    return 0;
-error:
-    return -1;
+    return ecs_os_memcmp(type_1->array, type_2->array, count_1);
 }
 
-int ecs_value_copy(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    void* dst,
-    const void *src)
+static
+ecs_http_request_entry_t* http_find_request_entry(
+    ecs_http_server_t *srv,
+    const char *array,
+    int32_t count)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
-    return ecs_value_copy_w_type_info(world, ti, dst, src);
-error:
-    return -1;
+    ecs_http_request_key_t key;
+    key.array = array;
+    key.count = count;
+
+    ecs_time_t t = {0, 0};
+    ecs_http_request_entry_t *entry = flecs_hashmap_get(
+        &srv->request_cache, &key, ecs_http_request_entry_t);
+
+    if (entry) {
+        double tf = ecs_time_measure(&t);
+        if ((tf - entry->time) < srv->cache_timeout) {
+            return entry;
+        }
+    }
+    return NULL;
 }
 
-int ecs_value_move_w_type_info(
-    const ecs_world_t *world,
-    const ecs_type_info_t *ti,
-    void* dst,
-    void *src)
+static
+void http_insert_request_entry(
+    ecs_http_server_t *srv,
+    ecs_http_request_impl_t *req,
+    ecs_http_reply_t *reply)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
-    (void)world;
+    int32_t content_length = ecs_strbuf_written(&reply->body);
+    if (!content_length) {
+        return;
+    }
 
-    ecs_move_t move;
-    if ((move = ti->hooks.move)) {
-        move(dst, src, 1, ti);
+    ecs_http_request_key_t key;
+    key.array = req->res;
+    key.count = req->req_len;
+    ecs_http_request_entry_t *entry = flecs_hashmap_get(
+        &srv->request_cache, &key, ecs_http_request_entry_t);
+    if (!entry) {
+        flecs_hashmap_result_t elem = flecs_hashmap_ensure(
+            &srv->request_cache, &key, ecs_http_request_entry_t);
+        ecs_http_request_key_t *elem_key = elem.key;
+        elem_key->array = ecs_os_memdup_n(key.array, char, key.count);
+        entry = elem.value;
     } else {
-        ecs_os_memcpy(dst, src, ti->size);
+        ecs_os_free(entry->content);
     }
 
-    return 0;
-error:
-    return -1;
+    ecs_time_t t = {0, 0};
+    entry->time = ecs_time_measure(&t);
+    entry->content_length = ecs_strbuf_written(&reply->body);
+    entry->content = ecs_strbuf_get(&reply->body);
+    entry->code = reply->code;
+    ecs_strbuf_appendstrn(&reply->body, 
+            entry->content, entry->content_length);
 }
 
-int ecs_value_move(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    void* dst,
-    void *src)
+static
+char* http_decode_request(
+    ecs_http_request_impl_t *req,
+    ecs_http_fragment_t *frag)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
-    return ecs_value_move_w_type_info(world, ti, dst, src);
-error:
-    return -1;
-}
+    ecs_os_zeromem(req);
 
-int ecs_value_move_ctor_w_type_info(
-    const ecs_world_t *world,
-    const ecs_type_info_t *ti,
-    void* dst,
-    void *src)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
-    (void)world;
+    ecs_size_t req_len = frag->buf.length;
+    char *res = ecs_strbuf_get(&frag->buf);
+    if (!res) {
+        return NULL;
+    }
 
-    ecs_move_t move;
-    if ((move = ti->hooks.move_ctor)) {
-        move(dst, src, 1, ti);
-    } else {
-        ecs_os_memcpy(dst, src, ti->size);
+    req->pub.method = frag->method;
+    req->pub.path = res + 1;
+    http_decode_url_str(req->pub.path);
+
+    if (frag->body_offset) {
+        req->pub.body = &res[frag->body_offset];
+    }
+    int32_t i, count = frag->header_count;
+    for (i = 0; i < count; i ++) {
+        req->pub.headers[i].key = &res[frag->header_offsets[i]];
+        req->pub.headers[i].value = &res[frag->header_value_offsets[i]];
+    }
+    count = frag->param_count;
+    for (i = 0; i < count; i ++) {
+        req->pub.params[i].key = &res[frag->param_offsets[i]];
+        req->pub.params[i].value = &res[frag->param_value_offsets[i]];
+        /* Safe, member is only const so that end-user can't change it */
+        http_decode_url_str(ECS_CONST_CAST(char*, req->pub.params[i].value));
     }
 
-    return 0;
-error:
-    return -1;
+    req->pub.header_count = frag->header_count;
+    req->pub.param_count = frag->param_count;
+    req->res = res;
+    req->req_len = frag->header_offsets[0];
+    if (!req->req_len) {
+        req->req_len = req_len;
+    }
+
+    return res;
 }
 
-int ecs_value_move_ctor(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    void* dst,
-    void *src)
+static
+ecs_http_request_entry_t* http_enqueue_request(
+    ecs_http_connection_impl_t *conn,
+    uint64_t conn_id,
+    ecs_http_fragment_t *frag)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    const ecs_type_info_t *ti = ecs_get_type_info(world, type);
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
-    return ecs_value_move_w_type_info(world, ti, dst, src);
-error:
-    return -1;
-}
+    ecs_http_server_t *srv = conn->pub.server;
 
-/**
- * @file world.c
- * @brief World-level API.
- */
+    ecs_os_mutex_lock(srv->lock);
+    bool is_alive = conn->pub.id == conn_id;
 
+    if (!is_alive || frag->invalid) { 
+        /* Don't enqueue invalid requests or requests for purged connections */
+        ecs_strbuf_reset(&frag->buf);
+    } else {
+        ecs_http_request_impl_t req;
+        char *res = http_decode_request(&req, frag);
+        if (res) {
+            req.pub.conn = (ecs_http_connection_t*)conn;
 
-/* Id flags */
-const ecs_id_t ECS_PAIR =                                          (1ull << 63);
-const ecs_id_t ECS_OVERRIDE =                                      (1ull << 62);
-const ecs_id_t ECS_TOGGLE =                                        (1ull << 61);
-const ecs_id_t ECS_AND =                                           (1ull << 60);
+            /* Check cache for GET requests */
+            if (frag->method == EcsHttpGet) {
+                ecs_http_request_entry_t *entry = 
+                    http_find_request_entry(srv, res, frag->header_offsets[0]);
+                if (entry) {
+                    /* If an entry is found, don't enqueue a request. Instead
+                     * return the cached response immediately. */
+                    ecs_os_free(res);
+                    return entry;
+                }
+            }
 
-/** Builtin component ids */
-const ecs_entity_t ecs_id(EcsComponent) =                                   1;
-const ecs_entity_t ecs_id(EcsIdentifier) =                                  2;
-const ecs_entity_t ecs_id(EcsIterable) =                                    3;
-const ecs_entity_t ecs_id(EcsPoly) =                                        4;
+            ecs_http_request_impl_t *req_ptr = flecs_sparse_add_t(
+                &srv->requests, ecs_http_request_impl_t);
+            *req_ptr = req;
+            req_ptr->pub.id = flecs_sparse_last_id(&srv->requests);
+            req_ptr->conn_id = conn->pub.id;
+            ecs_os_linc(&ecs_http_request_received_count);
+        }
+    }
 
-/* Poly target components */
-const ecs_entity_t EcsQuery =                                               5;
-const ecs_entity_t EcsObserver =                                            6;
-const ecs_entity_t EcsSystem =                                              7;
+    ecs_os_mutex_unlock(srv->lock);
+    return NULL;
+}
 
-/* Core scopes & entities */
-const ecs_entity_t EcsWorld =                       FLECS_HI_COMPONENT_ID + 0;
-const ecs_entity_t EcsFlecs =                       FLECS_HI_COMPONENT_ID + 1;
-const ecs_entity_t EcsFlecsCore =                   FLECS_HI_COMPONENT_ID + 2;
-const ecs_entity_t EcsFlecsInternals =              FLECS_HI_COMPONENT_ID + 3;
-const ecs_entity_t EcsModule =                      FLECS_HI_COMPONENT_ID + 4;
-const ecs_entity_t EcsPrivate =                     FLECS_HI_COMPONENT_ID + 5;
-const ecs_entity_t EcsPrefab =                      FLECS_HI_COMPONENT_ID + 6;
-const ecs_entity_t EcsDisabled =                    FLECS_HI_COMPONENT_ID + 7;
+static
+bool http_parse_request(
+    ecs_http_fragment_t *frag,
+    const char* req_frag, 
+    ecs_size_t req_frag_len) 
+{
+    int32_t i;
+    for (i = 0; i < req_frag_len; i++) {
+        char c = req_frag[i];
+        switch (frag->state) {
+        case HttpFragStateBegin:
+            ecs_os_memset_t(frag, 0, ecs_http_fragment_t);
+            frag->state = HttpFragStateMethod;
+            frag->header_buf_ptr = frag->header_buf;
 
-const ecs_entity_t EcsSlotOf =                      FLECS_HI_COMPONENT_ID + 8;
-const ecs_entity_t EcsFlag =                        FLECS_HI_COMPONENT_ID + 9;
-
-/* Relationship properties */
-const ecs_entity_t EcsWildcard =                    FLECS_HI_COMPONENT_ID + 10;
-const ecs_entity_t EcsAny =                         FLECS_HI_COMPONENT_ID + 11;
-const ecs_entity_t EcsThis =                        FLECS_HI_COMPONENT_ID + 12;
-const ecs_entity_t EcsVariable =                    FLECS_HI_COMPONENT_ID + 13;
-const ecs_entity_t EcsTransitive =                  FLECS_HI_COMPONENT_ID + 14;
-const ecs_entity_t EcsReflexive =                   FLECS_HI_COMPONENT_ID + 15;
-const ecs_entity_t EcsSymmetric =                   FLECS_HI_COMPONENT_ID + 16;
-const ecs_entity_t EcsFinal =                       FLECS_HI_COMPONENT_ID + 17;
-const ecs_entity_t EcsDontInherit =                 FLECS_HI_COMPONENT_ID + 18;
-const ecs_entity_t EcsAlwaysOverride =              FLECS_HI_COMPONENT_ID + 19;
-const ecs_entity_t EcsTag =                         FLECS_HI_COMPONENT_ID + 20;
-const ecs_entity_t EcsUnion =                       FLECS_HI_COMPONENT_ID + 21;
-const ecs_entity_t EcsExclusive =                   FLECS_HI_COMPONENT_ID + 22;
-const ecs_entity_t EcsAcyclic =                     FLECS_HI_COMPONENT_ID + 23;
-const ecs_entity_t EcsTraversable =                 FLECS_HI_COMPONENT_ID + 24;
-const ecs_entity_t EcsWith =                        FLECS_HI_COMPONENT_ID + 25;
-const ecs_entity_t EcsOneOf =                       FLECS_HI_COMPONENT_ID + 26;
-const ecs_entity_t EcsTrait =                       FLECS_HI_COMPONENT_ID + 27;
-const ecs_entity_t EcsRelationship =            FLECS_HI_COMPONENT_ID + 28;
-const ecs_entity_t EcsTarget =                  FLECS_HI_COMPONENT_ID + 29;
+            /* fall through */
+        case HttpFragStateMethod:
+            if (c == ' ') {
+                http_parse_method(frag);
+                ecs_strbuf_reset(&frag->buf);
+                frag->state = HttpFragStatePath;
+                frag->buf.content = NULL;
+            } else {
+                ecs_strbuf_appendch(&frag->buf, c);
+            }
+            break;
+        case HttpFragStatePath:
+            if (c == ' ') {
+                frag->state = HttpFragStateVersion;
+                ecs_strbuf_appendch(&frag->buf, '\0');
+            } else {
+                if (c == '?' || c == '=' || c == '&') {
+                    ecs_strbuf_appendch(&frag->buf, '\0');
+                    int32_t offset = ecs_strbuf_written(&frag->buf);
+                    if (c == '?' || c == '&') {
+                        frag->param_offsets[frag->param_count] = offset;
+                    } else {
+                        frag->param_value_offsets[frag->param_count] = offset;
+                        frag->param_count ++;
+                    }
+                } else {
+                    ecs_strbuf_appendch(&frag->buf, c);
+                }
+            }
+            break;
+        case HttpFragStateVersion:
+            if (c == '\r') {
+                frag->state = HttpFragStateCR;
+            } /* version is not stored */
+            break;
+        case HttpFragStateHeaderStart:
+            if (http_header_writable(frag)) {
+                frag->header_offsets[frag->header_count] = 
+                    ecs_strbuf_written(&frag->buf);
+            }
+            http_header_buf_reset(frag);
+            frag->state = HttpFragStateHeaderName;
 
-/* Builtin relationships */
-const ecs_entity_t EcsChildOf =                     FLECS_HI_COMPONENT_ID + 30;
-const ecs_entity_t EcsIsA =                         FLECS_HI_COMPONENT_ID + 31;
-const ecs_entity_t EcsDependsOn =                   FLECS_HI_COMPONENT_ID + 32;
+            /* fall through */
+        case HttpFragStateHeaderName:
+            if (c == ':') {
+                frag->state = HttpFragStateHeaderValueStart;
+                http_header_buf_append(frag, '\0');
+                frag->parse_content_length = !ecs_os_strcmp(
+                    frag->header_buf, "Content-Length");
 
-/* Identifier tags */
-const ecs_entity_t EcsName =                        FLECS_HI_COMPONENT_ID + 33;
-const ecs_entity_t EcsSymbol =                      FLECS_HI_COMPONENT_ID + 34;
-const ecs_entity_t EcsAlias =                       FLECS_HI_COMPONENT_ID + 35;
+                if (http_header_writable(frag)) {
+                    ecs_strbuf_appendch(&frag->buf, '\0');
+                    frag->header_value_offsets[frag->header_count] =
+                        ecs_strbuf_written(&frag->buf);
+                }
+            } else if (c == '\r') {
+                frag->state = HttpFragStateCR;
+            } else  {
+                http_header_buf_append(frag, c);
+                if (http_header_writable(frag)) {
+                    ecs_strbuf_appendch(&frag->buf, c);
+                }
+            }
+            break;
+        case HttpFragStateHeaderValueStart:
+            http_header_buf_reset(frag);
+            frag->state = HttpFragStateHeaderValue;
+            if (c == ' ') { /* skip first space */
+                break;
+            }
 
-/* Events */
-const ecs_entity_t EcsOnAdd =                       FLECS_HI_COMPONENT_ID + 36;
-const ecs_entity_t EcsOnRemove =                    FLECS_HI_COMPONENT_ID + 37;
-const ecs_entity_t EcsOnSet =                       FLECS_HI_COMPONENT_ID + 38;
-const ecs_entity_t EcsUnSet =                       FLECS_HI_COMPONENT_ID + 39;
-const ecs_entity_t EcsOnDelete =                    FLECS_HI_COMPONENT_ID + 40;
-const ecs_entity_t EcsOnTableCreate =               FLECS_HI_COMPONENT_ID + 41;
-const ecs_entity_t EcsOnTableDelete =               FLECS_HI_COMPONENT_ID + 42;
-const ecs_entity_t EcsOnTableEmpty =                FLECS_HI_COMPONENT_ID + 43;
-const ecs_entity_t EcsOnTableFill =                 FLECS_HI_COMPONENT_ID + 44;
-const ecs_entity_t EcsOnDeleteTarget =              FLECS_HI_COMPONENT_ID + 46;
+            /* fall through */
+        case HttpFragStateHeaderValue:
+            if (c == '\r') {
+                if (frag->parse_content_length) {
+                    http_header_buf_append(frag, '\0');
+                    int32_t len = atoi(frag->header_buf);
+                    if (len < 0) {
+                        frag->invalid = true;
+                    } else {
+                        frag->content_length = len;
+                    }
+                    frag->parse_content_length = false;
+                }
+                if (http_header_writable(frag)) {
+                    int32_t cur = ecs_strbuf_written(&frag->buf);
+                    if (frag->header_offsets[frag->header_count] < cur &&
+                        frag->header_value_offsets[frag->header_count] < cur)
+                    {
+                        ecs_strbuf_appendch(&frag->buf, '\0');
+                        frag->header_count ++;
+                    }
+                }
+                frag->state = HttpFragStateCR;
+            } else {
+                if (frag->parse_content_length) {
+                    http_header_buf_append(frag, c);
+                }
+                if (http_header_writable(frag)) {
+                    ecs_strbuf_appendch(&frag->buf, c);
+                }
+            }
+            break;
+        case HttpFragStateCR:
+            if (c == '\n') {
+                frag->state = HttpFragStateCRLF;
+            } else {
+                frag->state = HttpFragStateHeaderStart;
+            }
+            break;
+        case HttpFragStateCRLF:
+            if (c == '\r') {
+                frag->state = HttpFragStateCRLFCR;
+            } else {
+                frag->state = HttpFragStateHeaderStart;
+                i--;
+            }
+            break;
+        case HttpFragStateCRLFCR:
+            if (c == '\n') {
+                if (frag->content_length != 0) {
+                    frag->body_offset = ecs_strbuf_written(&frag->buf);
+                    frag->state = HttpFragStateBody;
+                } else {
+                    frag->state = HttpFragStateDone;
+                }
+            } else {
+                frag->state = HttpFragStateHeaderStart;
+            }
+            break;
+        case HttpFragStateBody: {
+                ecs_strbuf_appendch(&frag->buf, c);
+                if ((ecs_strbuf_written(&frag->buf) - frag->body_offset) == 
+                    frag->content_length) 
+                {
+                    frag->state = HttpFragStateDone;
+                }
+            }
+            break;
+        case HttpFragStateDone:
+            break;
+        }
+    }
 
-/* Timers */
-const ecs_entity_t ecs_id(EcsTickSource) =          FLECS_HI_COMPONENT_ID + 47;
-const ecs_entity_t ecs_id(EcsTimer) =               FLECS_HI_COMPONENT_ID + 48;
-const ecs_entity_t ecs_id(EcsRateFilter) =          FLECS_HI_COMPONENT_ID + 49;
+    if (frag->state == HttpFragStateDone) {
+        return true;
+    } else {
+        return false;
+    }
+}
 
-/* Actions */
-const ecs_entity_t EcsRemove =                      FLECS_HI_COMPONENT_ID + 50;
-const ecs_entity_t EcsDelete =                      FLECS_HI_COMPONENT_ID + 51;
-const ecs_entity_t EcsPanic =                       FLECS_HI_COMPONENT_ID + 52;
+static
+ecs_http_send_request_t* http_send_queue_post(
+    ecs_http_server_t *srv)
+{
+    /* This function should only be called while the server is locked. Before 
+     * the lock is released, the returned element should be populated. */
+    ecs_http_send_queue_t *sq = &srv->send_queue;
+    int32_t next = (sq->head + 1) % ECS_HTTP_SEND_QUEUE_MAX;
+    if (next == sq->tail) {
+        return NULL;
+    }
 
-/* Misc */
-const ecs_entity_t ecs_id(EcsFlattenTarget) =       FLECS_HI_COMPONENT_ID + 53;
-const ecs_entity_t EcsFlatten =                     FLECS_HI_COMPONENT_ID + 54;
-const ecs_entity_t EcsDefaultChildComponent =       FLECS_HI_COMPONENT_ID + 55;
+    /* Don't enqueue new requests if server is shutting down */
+    if (!srv->should_run) {
+        return NULL;
+    }
 
-/* Builtin predicate ids (used by rule engine) */
-const ecs_entity_t EcsPredEq =                      FLECS_HI_COMPONENT_ID + 56;
-const ecs_entity_t EcsPredMatch =                   FLECS_HI_COMPONENT_ID + 57;
-const ecs_entity_t EcsPredLookup =                  FLECS_HI_COMPONENT_ID + 58;
-const ecs_entity_t EcsScopeOpen =                   FLECS_HI_COMPONENT_ID + 59;
-const ecs_entity_t EcsScopeClose =                  FLECS_HI_COMPONENT_ID + 60;
+    /* Return element at end of the queue */
+    ecs_http_send_request_t *result = &sq->requests[sq->head];
+    sq->head = next;
+    return result;
+}
 
-/* Systems */
-const ecs_entity_t EcsMonitor =                     FLECS_HI_COMPONENT_ID + 61;
-const ecs_entity_t EcsEmpty =                       FLECS_HI_COMPONENT_ID + 62;
-const ecs_entity_t ecs_id(EcsPipeline) =            FLECS_HI_COMPONENT_ID + 63;
-const ecs_entity_t EcsOnStart =                     FLECS_HI_COMPONENT_ID + 64;
-const ecs_entity_t EcsPreFrame =                    FLECS_HI_COMPONENT_ID + 65;
-const ecs_entity_t EcsOnLoad =                      FLECS_HI_COMPONENT_ID + 66;
-const ecs_entity_t EcsPostLoad =                    FLECS_HI_COMPONENT_ID + 67;
-const ecs_entity_t EcsPreUpdate =                   FLECS_HI_COMPONENT_ID + 68;
-const ecs_entity_t EcsOnUpdate =                    FLECS_HI_COMPONENT_ID + 69;
-const ecs_entity_t EcsOnValidate =                  FLECS_HI_COMPONENT_ID + 70;
-const ecs_entity_t EcsPostUpdate =                  FLECS_HI_COMPONENT_ID + 71;
-const ecs_entity_t EcsPreStore =                    FLECS_HI_COMPONENT_ID + 72;
-const ecs_entity_t EcsOnStore =                     FLECS_HI_COMPONENT_ID + 73;
-const ecs_entity_t EcsPostFrame =                   FLECS_HI_COMPONENT_ID + 74;
-const ecs_entity_t EcsPhase =                       FLECS_HI_COMPONENT_ID + 75;
-
-/* Meta primitive components (don't use low ids to save id space) */
-const ecs_entity_t ecs_id(ecs_bool_t) =             FLECS_HI_COMPONENT_ID + 80;
-const ecs_entity_t ecs_id(ecs_char_t) =             FLECS_HI_COMPONENT_ID + 81;
-const ecs_entity_t ecs_id(ecs_byte_t) =             FLECS_HI_COMPONENT_ID + 82;
-const ecs_entity_t ecs_id(ecs_u8_t) =               FLECS_HI_COMPONENT_ID + 83;
-const ecs_entity_t ecs_id(ecs_u16_t) =              FLECS_HI_COMPONENT_ID + 84;
-const ecs_entity_t ecs_id(ecs_u32_t) =              FLECS_HI_COMPONENT_ID + 85;
-const ecs_entity_t ecs_id(ecs_u64_t) =              FLECS_HI_COMPONENT_ID + 86;
-const ecs_entity_t ecs_id(ecs_uptr_t) =             FLECS_HI_COMPONENT_ID + 87;
-const ecs_entity_t ecs_id(ecs_i8_t) =               FLECS_HI_COMPONENT_ID + 88;
-const ecs_entity_t ecs_id(ecs_i16_t) =              FLECS_HI_COMPONENT_ID + 89;
-const ecs_entity_t ecs_id(ecs_i32_t) =              FLECS_HI_COMPONENT_ID + 90;
-const ecs_entity_t ecs_id(ecs_i64_t) =              FLECS_HI_COMPONENT_ID + 91;
-const ecs_entity_t ecs_id(ecs_iptr_t) =             FLECS_HI_COMPONENT_ID + 92;
-const ecs_entity_t ecs_id(ecs_f32_t) =              FLECS_HI_COMPONENT_ID + 93;
-const ecs_entity_t ecs_id(ecs_f64_t) =              FLECS_HI_COMPONENT_ID + 94;
-const ecs_entity_t ecs_id(ecs_string_t) =           FLECS_HI_COMPONENT_ID + 95;
-const ecs_entity_t ecs_id(ecs_entity_t) =           FLECS_HI_COMPONENT_ID + 96;
-const ecs_entity_t ecs_id(ecs_id_t) =               FLECS_HI_COMPONENT_ID + 97;
-
-/** Meta module component ids */
-const ecs_entity_t ecs_id(EcsMetaType) =            FLECS_HI_COMPONENT_ID + 98;
-const ecs_entity_t ecs_id(EcsMetaTypeSerialized) =  FLECS_HI_COMPONENT_ID + 99;
-const ecs_entity_t ecs_id(EcsPrimitive) =           FLECS_HI_COMPONENT_ID + 100;
-const ecs_entity_t ecs_id(EcsEnum) =                FLECS_HI_COMPONENT_ID + 101;
-const ecs_entity_t ecs_id(EcsBitmask) =             FLECS_HI_COMPONENT_ID + 102;
-const ecs_entity_t ecs_id(EcsMember) =              FLECS_HI_COMPONENT_ID + 103;
-const ecs_entity_t ecs_id(EcsMemberRanges) =        FLECS_HI_COMPONENT_ID + 104;
-const ecs_entity_t ecs_id(EcsStruct) =              FLECS_HI_COMPONENT_ID + 105;
-const ecs_entity_t ecs_id(EcsArray) =               FLECS_HI_COMPONENT_ID + 106;
-const ecs_entity_t ecs_id(EcsVector) =              FLECS_HI_COMPONENT_ID + 107;
-const ecs_entity_t ecs_id(EcsOpaque) =              FLECS_HI_COMPONENT_ID + 108;
-const ecs_entity_t ecs_id(EcsUnit) =                FLECS_HI_COMPONENT_ID + 109;
-const ecs_entity_t ecs_id(EcsUnitPrefix) =          FLECS_HI_COMPONENT_ID + 110;
-const ecs_entity_t EcsConstant =                    FLECS_HI_COMPONENT_ID + 111;
-const ecs_entity_t EcsQuantity =                    FLECS_HI_COMPONENT_ID + 112;
-
-/* Doc module components */
-const ecs_entity_t ecs_id(EcsDocDescription) =      FLECS_HI_COMPONENT_ID + 113;
-const ecs_entity_t EcsDocBrief =                    FLECS_HI_COMPONENT_ID + 114;
-const ecs_entity_t EcsDocDetail =                   FLECS_HI_COMPONENT_ID + 115;
-const ecs_entity_t EcsDocLink =                     FLECS_HI_COMPONENT_ID + 116;
-const ecs_entity_t EcsDocColor =                    FLECS_HI_COMPONENT_ID + 117;
-
-/* REST module components */
-const ecs_entity_t ecs_id(EcsRest) =                FLECS_HI_COMPONENT_ID + 118;
-
-/* Default lookup path */
-static ecs_entity_t ecs_default_lookup_path[2] = { 0, 0 };
+static
+ecs_http_send_request_t* http_send_queue_get(
+    ecs_http_server_t *srv)
+{
+    ecs_os_mutex_lock(srv->lock);
+    ecs_http_send_queue_t *sq = &srv->send_queue;
+    if (sq->tail == sq->head) {
+        return NULL;
+    }
 
-/* Declarations for addons. Located in world.c to avoid issues during linking of
- * static library */
+    int32_t next = (sq->tail + 1) % ECS_HTTP_SEND_QUEUE_MAX;
+    ecs_http_send_request_t *result = &sq->requests[sq->tail];
+    sq->tail = next;
+    return result;
+}
 
-#ifdef FLECS_ALERTS
-ECS_COMPONENT_DECLARE(EcsAlert);
-ECS_COMPONENT_DECLARE(EcsAlertInstance);
-ECS_COMPONENT_DECLARE(EcsAlertsActive);
-ECS_TAG_DECLARE(EcsAlertInfo);
-ECS_TAG_DECLARE(EcsAlertWarning);
-ECS_TAG_DECLARE(EcsAlertError);
-ECS_TAG_DECLARE(EcsAlertCritical);
-#endif
-#ifdef FLECS_UNITS
-ECS_DECLARE(EcsUnitPrefixes);
+static
+void* http_server_send_queue(void* arg) {
+    ecs_http_server_t *srv = arg;
+    int32_t wait_ms = srv->send_queue.wait_ms;
 
-ECS_DECLARE(EcsYocto);
-ECS_DECLARE(EcsZepto);
-ECS_DECLARE(EcsAtto);
-ECS_DECLARE(EcsFemto);
-ECS_DECLARE(EcsPico);
-ECS_DECLARE(EcsNano);
-ECS_DECLARE(EcsMicro);
-ECS_DECLARE(EcsMilli);
-ECS_DECLARE(EcsCenti);
-ECS_DECLARE(EcsDeci);
-ECS_DECLARE(EcsDeca);
-ECS_DECLARE(EcsHecto);
-ECS_DECLARE(EcsKilo);
-ECS_DECLARE(EcsMega);
-ECS_DECLARE(EcsGiga);
-ECS_DECLARE(EcsTera);
-ECS_DECLARE(EcsPeta);
-ECS_DECLARE(EcsExa);
-ECS_DECLARE(EcsZetta);
-ECS_DECLARE(EcsYotta);
+    /* Run for as long as the server is running or there are messages. When the
+     * server is stopping, no new messages will be enqueued */
+    while (srv->should_run || (srv->send_queue.head != srv->send_queue.tail)) {
+        ecs_http_send_request_t* r = http_send_queue_get(srv);
+        if (!r) {
+            ecs_os_mutex_unlock(srv->lock);
+            /* If the queue is empty, wait so we don't run too fast */
+            if (srv->should_run) {
+                ecs_os_sleep(0, wait_ms * 1000 * 1000);
+            }
+        } else {
+            ecs_http_socket_t sock = r->sock;
+            char *headers = r->headers;
+            int32_t headers_length = r->header_length;
+            char *content = r->content;
+            int32_t content_length = r->content_length;
+            ecs_os_mutex_unlock(srv->lock);
 
-ECS_DECLARE(EcsKibi);
-ECS_DECLARE(EcsMebi);
-ECS_DECLARE(EcsGibi);
-ECS_DECLARE(EcsTebi);
-ECS_DECLARE(EcsPebi);
-ECS_DECLARE(EcsExbi);
-ECS_DECLARE(EcsZebi);
-ECS_DECLARE(EcsYobi);
+            if (http_socket_is_valid(sock)) {
+                bool error = false;
 
-ECS_DECLARE(EcsDuration);
-    ECS_DECLARE(EcsPicoSeconds);
-    ECS_DECLARE(EcsNanoSeconds);
-    ECS_DECLARE(EcsMicroSeconds);
-    ECS_DECLARE(EcsMilliSeconds);
-    ECS_DECLARE(EcsSeconds);
-    ECS_DECLARE(EcsMinutes);
-    ECS_DECLARE(EcsHours);
-    ECS_DECLARE(EcsDays);
+                http_sock_nonblock(sock, false);
 
-ECS_DECLARE(EcsTime);
-    ECS_DECLARE(EcsDate);
+                /* Write headers */
+                ecs_size_t written = http_send(sock, headers, headers_length, 0);
+                if (written != headers_length) {
+                    ecs_err("http: failed to write HTTP response headers: %s",
+                        ecs_os_strerror(errno));
+                    ecs_os_linc(&ecs_http_send_error_count);
+                    error = true;
+                } else if (content_length >= 0) {
+                    /* Write content */
+                    written = http_send(sock, content, content_length, 0);
+                    if (written != content_length) {
+                        ecs_err("http: failed to write HTTP response body: %s",
+                            ecs_os_strerror(errno));
+                        ecs_os_linc(&ecs_http_send_error_count);
+                        error = true;
+                    }
+                }
+                if (!error) {
+                    ecs_os_linc(&ecs_http_send_ok_count);
+                }
 
-ECS_DECLARE(EcsMass);
-    ECS_DECLARE(EcsGrams);
-    ECS_DECLARE(EcsKiloGrams);
+                http_close(&sock);
+            } else {
+                ecs_err("http: invalid socket\n");
+            }
 
-ECS_DECLARE(EcsElectricCurrent);
-    ECS_DECLARE(EcsAmpere);
+            ecs_os_free(content);
+            ecs_os_free(headers);
+        }
+    }
+    return NULL;
+}
 
-ECS_DECLARE(EcsAmount);
-    ECS_DECLARE(EcsMole);
+static
+void http_append_send_headers(
+    ecs_strbuf_t *hdrs,
+    int code, 
+    const char* status, 
+    const char* content_type,  
+    ecs_strbuf_t *extra_headers,
+    ecs_size_t content_len,
+    bool preflight)
+{
+    ecs_strbuf_appendlit(hdrs, "HTTP/1.1 ");
+    ecs_strbuf_appendint(hdrs, code);
+    ecs_strbuf_appendch(hdrs, ' ');
+    ecs_strbuf_appendstr(hdrs, status);
+    ecs_strbuf_appendlit(hdrs, "\r\n");
 
-ECS_DECLARE(EcsLuminousIntensity);
-    ECS_DECLARE(EcsCandela);
+    if (content_type) {
+        ecs_strbuf_appendlit(hdrs, "Content-Type: ");
+        ecs_strbuf_appendstr(hdrs, content_type);
+        ecs_strbuf_appendlit(hdrs, "\r\n");
+    }
 
-ECS_DECLARE(EcsForce);
-    ECS_DECLARE(EcsNewton);
+    if (content_len >= 0) {
+        ecs_strbuf_appendlit(hdrs, "Content-Length: ");
+        ecs_strbuf_append(hdrs, "%d", content_len);
+        ecs_strbuf_appendlit(hdrs, "\r\n");
+    }
 
-ECS_DECLARE(EcsLength);
-    ECS_DECLARE(EcsMeters);
-        ECS_DECLARE(EcsPicoMeters);
-        ECS_DECLARE(EcsNanoMeters);
-        ECS_DECLARE(EcsMicroMeters);
-        ECS_DECLARE(EcsMilliMeters);
-        ECS_DECLARE(EcsCentiMeters);
-        ECS_DECLARE(EcsKiloMeters);
-    ECS_DECLARE(EcsMiles);
-    ECS_DECLARE(EcsPixels);
+    ecs_strbuf_appendlit(hdrs, "Access-Control-Allow-Origin: *\r\n");
+    if (preflight) {
+        ecs_strbuf_appendlit(hdrs, "Access-Control-Allow-Private-Network: true\r\n");
+        ecs_strbuf_appendlit(hdrs, "Access-Control-Allow-Methods: GET, PUT, OPTIONS\r\n");
+        ecs_strbuf_appendlit(hdrs, "Access-Control-Max-Age: 600\r\n");
+    }
 
-ECS_DECLARE(EcsPressure);
-    ECS_DECLARE(EcsPascal);
-    ECS_DECLARE(EcsBar);
+    ecs_strbuf_mergebuff(hdrs, extra_headers);
 
-ECS_DECLARE(EcsSpeed);
-    ECS_DECLARE(EcsMetersPerSecond);
-    ECS_DECLARE(EcsKiloMetersPerSecond);
-    ECS_DECLARE(EcsKiloMetersPerHour);
-    ECS_DECLARE(EcsMilesPerHour);
+    ecs_strbuf_appendlit(hdrs, "\r\n");
+}
 
-ECS_DECLARE(EcsAcceleration);
+static
+void http_send_reply(
+    ecs_http_connection_impl_t* conn, 
+    ecs_http_reply_t* reply,
+    bool preflight) 
+{
+    ecs_strbuf_t hdrs = ECS_STRBUF_INIT;
+    int32_t content_length = reply->body.length;
+    char *content = ecs_strbuf_get(&reply->body);
 
-ECS_DECLARE(EcsTemperature);
-    ECS_DECLARE(EcsKelvin);
-    ECS_DECLARE(EcsCelsius);
-    ECS_DECLARE(EcsFahrenheit);
+    /* Use asynchronous send queue for outgoing data so send operations won't
+     * hold up main thread */
+    ecs_http_send_request_t *req = NULL;
 
-ECS_DECLARE(EcsData);
-    ECS_DECLARE(EcsBits);
-        ECS_DECLARE(EcsKiloBits);
-        ECS_DECLARE(EcsMegaBits);
-        ECS_DECLARE(EcsGigaBits);
-    ECS_DECLARE(EcsBytes);
-        ECS_DECLARE(EcsKiloBytes);
-        ECS_DECLARE(EcsMegaBytes);
-        ECS_DECLARE(EcsGigaBytes);
-        ECS_DECLARE(EcsKibiBytes);
-        ECS_DECLARE(EcsGibiBytes);
-        ECS_DECLARE(EcsMebiBytes);
+    if (!preflight) {
+        req = http_send_queue_post(conn->pub.server);
+        if (!req) {
+            reply->code = 503; /* queue full, server is busy */
+            ecs_os_linc(&ecs_http_busy_count);
+        }
+    }
 
-ECS_DECLARE(EcsDataRate);
-    ECS_DECLARE(EcsBitsPerSecond);
-    ECS_DECLARE(EcsKiloBitsPerSecond);
-    ECS_DECLARE(EcsMegaBitsPerSecond);
-    ECS_DECLARE(EcsGigaBitsPerSecond);
-    ECS_DECLARE(EcsBytesPerSecond);
-    ECS_DECLARE(EcsKiloBytesPerSecond);
-    ECS_DECLARE(EcsMegaBytesPerSecond);
-    ECS_DECLARE(EcsGigaBytesPerSecond);
+    http_append_send_headers(&hdrs, reply->code, reply->status, 
+        reply->content_type, &reply->headers, content_length, preflight);
+    ecs_size_t headers_length = ecs_strbuf_written(&hdrs);
+    char *headers = ecs_strbuf_get(&hdrs);
 
-ECS_DECLARE(EcsPercentage);
+    if (!req) {
+        ecs_size_t written = http_send(conn->sock, headers, headers_length, 0);
+        if (written != headers_length) {
+            ecs_err("http: failed to send reply to '%s:%s': %s",
+                conn->pub.host, conn->pub.port, ecs_os_strerror(errno));
+            ecs_os_linc(&ecs_http_send_error_count);
+        }
+        ecs_os_free(content);
+        ecs_os_free(headers);
+        http_close(&conn->sock);
+        return;
+    }
 
-ECS_DECLARE(EcsAngle);
-    ECS_DECLARE(EcsRadians);
-    ECS_DECLARE(EcsDegrees);
+    /* Second, enqueue send request for response body */
+    req->sock = conn->sock;
+    req->headers = headers;
+    req->header_length = headers_length;
+    req->content = content;
+    req->content_length = content_length;
 
-ECS_DECLARE(EcsBel);
-ECS_DECLARE(EcsDeciBel);
+    /* Take ownership of values */
+    reply->body.content = NULL;
+    conn->sock = HTTP_SOCKET_INVALID;
+}
 
-ECS_DECLARE(EcsFrequency);
-    ECS_DECLARE(EcsHertz);
-    ECS_DECLARE(EcsKiloHertz);
-    ECS_DECLARE(EcsMegaHertz);
-    ECS_DECLARE(EcsGigaHertz);
+static
+void http_recv_connection(
+    ecs_http_server_t *srv,
+    ecs_http_connection_impl_t *conn, 
+    uint64_t conn_id,
+    ecs_http_socket_t sock)
+{
+    ecs_size_t bytes_read;
+    char recv_buf[ECS_HTTP_SEND_RECV_BUFFER_SIZE];
+    ecs_http_fragment_t frag = {0};
+    int32_t retries = 0;
 
-ECS_DECLARE(EcsUri);
-    ECS_DECLARE(EcsUriHyperlink);
-    ECS_DECLARE(EcsUriImage);
-    ECS_DECLARE(EcsUriFile);
-#endif
+    do {
+        if ((bytes_read = http_recv(
+            sock, recv_buf, ECS_SIZEOF(recv_buf), 0)) > 0) 
+        {
+            bool is_alive = conn->pub.id == conn_id;
+            if (!is_alive) {
+                /* Connection has been purged by main thread */
+                goto done;
+            }
 
-/* -- Private functions -- */
+            if (http_parse_request(&frag, recv_buf, bytes_read)) {
+                if (frag.method == EcsHttpOptions) {
+                    ecs_http_reply_t reply;
+                    reply.body = ECS_STRBUF_INIT;
+                    reply.code = 200;
+                    reply.content_type = NULL;
+                    reply.headers = ECS_STRBUF_INIT;
+                    reply.status = "OK";
+                    http_send_reply(conn, &reply, true);
+                    ecs_os_linc(&ecs_http_request_preflight_count);
+                } else {
+                    ecs_http_request_entry_t *entry =
+                        http_enqueue_request(conn, conn_id, &frag);
+                    if (entry) {
+                        ecs_http_reply_t reply;
+                        reply.body = ECS_STRBUF_INIT;
+                        reply.code = entry->code;
+                        reply.content_type = "application/json";
+                        reply.headers = ECS_STRBUF_INIT;
+                        reply.status = "OK";
+                        ecs_strbuf_appendstrn(&reply.body, 
+                            entry->content, entry->content_length);
+                        http_send_reply(conn, &reply, false);
+                        http_connection_free(conn);
 
-const ecs_stage_t* flecs_stage_from_readonly_world(
-    const ecs_world_t *world)
-{
-    ecs_assert(ecs_poly_is(world, ecs_world_t) ||
-               ecs_poly_is(world, ecs_stage_t),
-               ECS_INTERNAL_ERROR,
-               NULL);
+                        /* Lock was transferred from enqueue_request */
+                        ecs_os_mutex_unlock(srv->lock);
+                    }
+                }
+            } else {
+                ecs_os_linc(&ecs_http_request_invalid_count);
+            }
+        }
 
-    if (ecs_poly_is(world, ecs_world_t)) {
-        return &world->stages[0];
+        ecs_os_sleep(0, 10 * 1000 * 1000);
+    } while ((bytes_read == -1) && (++retries < ECS_HTTP_REQUEST_RECV_RETRY));
 
-    } else if (ecs_poly_is(world, ecs_stage_t)) {
-        return ECS_CONST_CAST(ecs_stage_t*, world);
+    if (retries == ECS_HTTP_REQUEST_RECV_RETRY) {
+        http_close(&sock);
     }
 
-    return NULL;
+done:
+    ecs_strbuf_reset(&frag.buf);
 }
 
-ecs_stage_t* flecs_stage_from_world(
-    ecs_world_t **world_ptr)
+typedef struct {
+    ecs_http_connection_impl_t *conn;
+    uint64_t id;
+} http_conn_res_t;
+
+static
+http_conn_res_t http_init_connection(
+    ecs_http_server_t *srv, 
+    ecs_http_socket_t sock_conn,
+    struct sockaddr_storage *remote_addr, 
+    ecs_size_t remote_addr_len) 
 {
-    ecs_world_t *world = *world_ptr;
+    http_sock_set_timeout(sock_conn, 100);
+    http_sock_keep_alive(sock_conn);
+    http_sock_nonblock(sock_conn, true);
 
-    ecs_assert(ecs_poly_is(world, ecs_world_t) ||
-               ecs_poly_is(world, ecs_stage_t),
-               ECS_INTERNAL_ERROR,
-               NULL);
+    /* Create new connection */
+    ecs_os_mutex_lock(srv->lock);
+    ecs_http_connection_impl_t *conn = flecs_sparse_add_t(
+        &srv->connections, ecs_http_connection_impl_t);
+    uint64_t conn_id = conn->pub.id = flecs_sparse_last_id(&srv->connections);
+    conn->pub.server = srv;
+    conn->sock = sock_conn;
+    ecs_os_mutex_unlock(srv->lock);
+
+    char *remote_host = conn->pub.host;
+    char *remote_port = conn->pub.port;
 
-    if (ecs_poly_is(world, ecs_world_t)) {
-        return &world->stages[0];
+    /* Fetch name & port info */
+    if (http_getnameinfo((struct sockaddr*) remote_addr, remote_addr_len,
+        remote_host, ECS_SIZEOF(conn->pub.host),
+        remote_port, ECS_SIZEOF(conn->pub.port),
+            NI_NUMERICHOST | NI_NUMERICSERV))
+    {
+        ecs_os_strcpy(remote_host, "unknown");
+        ecs_os_strcpy(remote_port, "unknown");
     }
 
-    *world_ptr = ((ecs_stage_t*)world)->world;
-    return ECS_CONST_CAST(ecs_stage_t*, world);
+    ecs_dbg_2("http: connection established from '%s:%s' (socket %u)", 
+        remote_host, remote_port, sock_conn);
+    
+    return (http_conn_res_t){ .conn = conn, .id = conn_id };
 }
 
-ecs_world_t* flecs_suspend_readonly(
-    const ecs_world_t *stage_world,
-    ecs_suspend_readonly_state_t *state)
+static
+void http_accept_connections(
+    ecs_http_server_t* srv, 
+    const struct sockaddr* addr, 
+    ecs_size_t addr_len) 
 {
-    ecs_assert(stage_world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(state != NULL, ECS_INTERNAL_ERROR, NULL);
+#ifdef ECS_TARGET_WINDOWS
+    /* If on Windows, test if winsock needs to be initialized */
+    SOCKET testsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (INVALID_SOCKET == testsocket && WSANOTINITIALISED == WSAGetLastError()){
+        WSADATA data = { 0 };
+        int result = WSAStartup(MAKEWORD(2, 2), &data);
+        if (result) {
+            ecs_warn("http: WSAStartup failed with GetLastError = %d\n", 
+                GetLastError());
+            return;
+        }
+    } else {
+        http_close(&testsocket);
+    }
+#endif
 
-    ecs_world_t *world =
-        ECS_CONST_CAST(ecs_world_t*, ecs_get_world(stage_world));
-    ecs_poly_assert(world, ecs_world_t);
+    /* Resolve name + port (used for logging) */
+    char addr_host[256];
+    char addr_port[20];
 
-    bool is_readonly = ECS_BIT_IS_SET(world->flags, EcsWorldReadonly);
-    ecs_world_t *temp_world = world;
-    ecs_stage_t *stage = flecs_stage_from_world(&temp_world);
+    ecs_http_socket_t sock = HTTP_SOCKET_INVALID;
+    ecs_assert(srv->sock == HTTP_SOCKET_INVALID, ECS_INTERNAL_ERROR, NULL);
 
-    if (!is_readonly && !stage->defer) {
-        state->is_readonly = false;
-        state->is_deferred = false;
-        return world;
+    if (http_getnameinfo(
+        addr, addr_len, addr_host, ECS_SIZEOF(addr_host), addr_port, 
+        ECS_SIZEOF(addr_port), NI_NUMERICHOST | NI_NUMERICSERV))
+    {
+        ecs_os_strcpy(addr_host, "unknown");
+        ecs_os_strcpy(addr_port, "unknown");
     }
 
-    ecs_dbg_3("suspending readonly mode");
+    ecs_os_mutex_lock(srv->lock);
+    if (srv->should_run) {
+        ecs_dbg_2("http: initializing connection socket");
 
-    /* Cannot suspend when running with multiple threads */
-    ecs_assert(!(world->flags & EcsWorldReadonly) ||
-        (ecs_get_stage_count(world) <= 1), ECS_INVALID_WHILE_READONLY, NULL);
+        sock = socket(addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
+        if (!http_socket_is_valid(sock)) {
+            ecs_err("http: unable to create new connection socket: %s", 
+                ecs_os_strerror(errno));
+            ecs_os_mutex_unlock(srv->lock);
+            goto done;
+        }
 
-    state->is_readonly = is_readonly;
-    state->is_deferred = stage->defer != 0;
+        int reuse = 1, result;
+        result = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 
+            (char*)&reuse, ECS_SIZEOF(reuse)); 
+        if (result) {
+            ecs_warn("http: failed to setsockopt: %s", ecs_os_strerror(errno));
+        }
 
-    /* Silence readonly checks */
-    world->flags &= ~EcsWorldReadonly;
+        if (addr->sa_family == AF_INET6) {
+            int ipv6only = 0;
+            if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, 
+                (char*)&ipv6only, ECS_SIZEOF(ipv6only)))
+            {
+                ecs_warn("http: failed to setsockopt: %s", 
+                    ecs_os_strerror(errno));
+            }
+        }
 
-    /* Hack around safety checks (this ought to look ugly) */
-    state->defer_count = stage->defer;
-    state->commands = stage->cmd->queue;
-    state->defer_stack = stage->cmd->stack;
-    flecs_stack_init(&stage->cmd->stack);
-    state->scope = stage->scope;
-    state->with = stage->with;
-    stage->defer = 0;
-    ecs_vec_init_t(NULL, &stage->cmd->queue, ecs_cmd_t, 0);
+        result = http_bind(sock, addr, addr_len);
+        if (result) {
+            ecs_err("http: failed to bind to '%s:%s': %s", 
+                addr_host, addr_port, ecs_os_strerror(errno));
+            ecs_os_mutex_unlock(srv->lock);
+            goto done;
+        }
 
-    return world;
-}
+        http_sock_set_timeout(sock, 1000);
 
-void flecs_resume_readonly(
-    ecs_world_t *world,
-    ecs_suspend_readonly_state_t *state)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(state != NULL, ECS_INTERNAL_ERROR, NULL);
+        srv->sock = sock;
 
-    ecs_world_t *temp_world = world;
-    ecs_stage_t *stage = flecs_stage_from_world(&temp_world);
+        result = listen(srv->sock, SOMAXCONN);
+        if (result) {
+            ecs_warn("http: could not listen for SOMAXCONN (%d) connections: %s", 
+                SOMAXCONN, ecs_os_strerror(errno));
+        }
 
-    if (state->is_readonly || state->is_deferred) {
-        ecs_dbg_3("resuming readonly mode");
+        ecs_trace("http: listening for incoming connections on '%s:%s'",
+            addr_host, addr_port);
+    } else {
+        ecs_dbg_2("http: server shut down while initializing");
+    }
+    ecs_os_mutex_unlock(srv->lock);
 
-        ecs_run_aperiodic(world, 0);
+    struct sockaddr_storage remote_addr;
+    ecs_size_t remote_addr_len = 0;
 
-        /* Restore readonly state / defer count */
-        ECS_BIT_COND(world->flags, EcsWorldReadonly, state->is_readonly);
-        stage->defer = state->defer_count;
-        ecs_vec_fini_t(&stage->allocator, &stage->cmd->queue, ecs_cmd_t);
-        stage->cmd->queue = state->commands;
-        flecs_stack_fini(&stage->cmd->stack);
-        stage->cmd->stack = state->defer_stack;
-        stage->scope = state->scope;
-        stage->with = state->with;
-    }
-}
+    while (srv->should_run) {
+        remote_addr_len = ECS_SIZEOF(remote_addr);
+        ecs_http_socket_t sock_conn = http_accept(srv->sock, (struct sockaddr*) &remote_addr, 
+            &remote_addr_len);
 
-/* Evaluate component monitor. If a monitored entity changed it will have set a
- * flag in one of the world's component monitors. Queries can register
- * themselves with component monitors to determine whether they need to rematch
- * with tables. */
-static
-void flecs_eval_component_monitor(
-    ecs_world_t *world)
-{
-    ecs_poly_assert(world, ecs_world_t);
+        if (!http_socket_is_valid(sock_conn)) {
+            if (srv->should_run) {
+                ecs_dbg("http: connection attempt failed: %s", 
+                    ecs_os_strerror(errno));
+            }
+            continue;
+        }
 
-    if (!world->monitors.is_dirty) {
-        return;
+        http_conn_res_t conn = http_init_connection(srv, sock_conn, &remote_addr, remote_addr_len);
+        http_recv_connection(srv, conn.conn, conn.id, sock_conn);
     }
 
-    world->monitors.is_dirty = false;
+done:
+    ecs_os_mutex_lock(srv->lock);
+    if (http_socket_is_valid(sock) && errno != EBADF) {
+        http_close(&sock);
+        srv->sock = sock;
+    }
+    ecs_os_mutex_unlock(srv->lock);
 
-    ecs_map_iter_t it = ecs_map_iter(&world->monitors.monitors);
-    while (ecs_map_next(&it)) {
-        ecs_monitor_t *m = ecs_map_ptr(&it);
-        if (!m->is_dirty) {
-            continue;
-        }
+    ecs_trace("http: no longer accepting connections on '%s:%s'",
+        addr_host, addr_port);
+}
 
-        m->is_dirty = false;
+static
+void* http_server_thread(void* arg) {
+    ecs_http_server_t *srv = arg;
+    struct sockaddr_in addr;
+    ecs_os_zeromem(&addr);
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(srv->port);
 
-        int32_t i, count = ecs_vec_count(&m->queries);
-        ecs_query_t **elems = ecs_vec_first(&m->queries);
-        for (i = 0; i < count; i ++) {
-            ecs_query_t *q = elems[i];
-            flecs_query_notify(world, q, &(ecs_query_event_t) {
-                .kind = EcsQueryTableRematch
-            });
-        }
+    if (!srv->ipaddr) {
+        addr.sin_addr.s_addr = htonl(INADDR_ANY);
+    } else {
+        inet_pton(AF_INET, srv->ipaddr, &(addr.sin_addr));
     }
+
+    http_accept_connections(srv, (struct sockaddr*)&addr, ECS_SIZEOF(addr));
+    return NULL;
 }
 
-void flecs_monitor_mark_dirty(
-    ecs_world_t *world,
-    ecs_entity_t id)
+static
+void http_do_request(
+    ecs_http_server_t *srv,
+    ecs_http_reply_t *reply,
+    const ecs_http_request_impl_t *req)
 {
-    ecs_map_t *monitors = &world->monitors.monitors;
+    ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(srv->callback != NULL, ECS_INVALID_OPERATION, 
+        "missing request handler for server");
 
-    /* Only flag if there are actually monitors registered, so that we
-     * don't waste cycles evaluating monitors if there's no interest */
-    if (ecs_map_is_init(monitors)) {
-        ecs_monitor_t *m = ecs_map_get_deref(monitors, ecs_monitor_t, id);
-        if (m) {
-            if (!world->monitors.is_dirty) {
-                world->monitor_generation ++;
-            }
-            m->is_dirty = true;
-            world->monitors.is_dirty = true;
+    if (srv->callback(ECS_CONST_CAST(ecs_http_request_t*, req), reply, 
+        srv->ctx) == false) 
+    {
+        reply->code = 404;
+        reply->status = "Resource not found";
+        ecs_os_linc(&ecs_http_request_not_handled_count);
+    } else {
+        if (reply->code >= 400) {
+            ecs_os_linc(&ecs_http_request_handled_error_count);
+        } else {
+            ecs_os_linc(&ecs_http_request_handled_ok_count);
         }
     }
+error:
+    return;
 }
 
-void flecs_monitor_register(
-    ecs_world_t *world,
-    ecs_entity_t id,
-    ecs_query_t *query)
+static
+void http_handle_request(
+    ecs_http_server_t *srv,
+    ecs_http_request_impl_t *req)
 {
-    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_http_reply_t reply = ECS_HTTP_REPLY_INIT;
+    ecs_http_connection_impl_t *conn = 
+        (ecs_http_connection_impl_t*)req->pub.conn;
 
-    ecs_map_t *monitors = &world->monitors.monitors;
-    ecs_map_init_if(monitors, &world->allocator);
-    ecs_monitor_t *m = ecs_map_ensure_alloc_t(monitors, ecs_monitor_t, id);
-    ecs_vec_init_if_t(&m->queries, ecs_query_t*);
-    ecs_query_t **q = ecs_vec_append_t(
-        &world->allocator, &m->queries, ecs_query_t*);
-    *q = query;
-}
+    if (req->pub.method != EcsHttpOptions) {
+        if (srv->callback((ecs_http_request_t*)req, &reply, srv->ctx) == false) {
+            reply.code = 404;
+            reply.status = "Resource not found";
+            ecs_os_linc(&ecs_http_request_not_handled_count);
+        } else {
+            if (reply.code >= 400) {
+                ecs_os_linc(&ecs_http_request_handled_error_count);
+            } else {
+                ecs_os_linc(&ecs_http_request_handled_ok_count);
+            }
+        }
 
-void flecs_monitor_unregister(
-    ecs_world_t *world,
-    ecs_entity_t id,
-    ecs_query_t *query)
-{
-    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (req->pub.method == EcsHttpGet) {
+            http_insert_request_entry(srv, req, &reply);
+        }
 
-    ecs_map_t *monitors = &world->monitors.monitors;
-    if (!ecs_map_is_init(monitors)) {
-        return;
+        http_send_reply(conn, &reply, false);
+        ecs_dbg_2("http: reply sent to '%s:%s'", conn->pub.host, conn->pub.port);
+    } else {
+        /* Already taken care of */
     }
 
-    ecs_monitor_t *m = ecs_map_get_deref(monitors, ecs_monitor_t, id);
-    if (!m) {
-        return;
-    }
+    http_reply_fini(&reply);
+    http_request_fini(req);
+    http_connection_free(conn);
+}
 
-    int32_t i, count = ecs_vec_count(&m->queries);
-    ecs_query_t **queries = ecs_vec_first(&m->queries);
-    for (i = 0; i < count; i ++) {
-        if (queries[i] == query) {
-            ecs_vec_remove_t(&m->queries, ecs_query_t*, i);
-            count --;
-            break;
+static
+void http_purge_request_cache(
+    ecs_http_server_t *srv,
+    bool fini)
+{
+    ecs_time_t t = {0, 0};
+    double time = ecs_time_measure(&t);
+    ecs_map_iter_t it = ecs_map_iter(&srv->request_cache.impl);
+    while (ecs_map_next(&it)) {
+        ecs_hm_bucket_t *bucket = ecs_map_ptr(&it);
+        int32_t i, count = ecs_vec_count(&bucket->values);
+        ecs_http_request_key_t *keys = ecs_vec_first(&bucket->keys);
+        ecs_http_request_entry_t *entries = ecs_vec_first(&bucket->values);
+        for (i = count - 1; i >= 0; i --) {
+            ecs_http_request_entry_t *entry = &entries[i];
+            if (fini || ((time - entry->time) > srv->cache_purge_timeout)) {
+                ecs_http_request_key_t *key = &keys[i];
+                /* Safe, code owns the value */
+                ecs_os_free(ECS_CONST_CAST(char*, key->array));
+                ecs_os_free(entry->content);
+                flecs_hm_bucket_remove(&srv->request_cache, bucket, 
+                    ecs_map_key(&it), i);
+            }
         }
     }
 
-    if (!count) {
-        ecs_vec_fini_t(&world->allocator, &m->queries, ecs_query_t*);
-        ecs_map_remove_free(monitors, id);
-    }
-
-    if (!ecs_map_count(monitors)) {
-        ecs_map_fini(monitors);
+    if (fini) {
+        flecs_hashmap_fini(&srv->request_cache);
     }
 }
 
 static
-void flecs_init_store(
-    ecs_world_t *world)
+int32_t http_dequeue_requests(
+    ecs_http_server_t *srv,
+    double delta_time)
 {
-    ecs_os_memset(&world->store, 0, ECS_SIZEOF(ecs_store_t));
+    ecs_os_mutex_lock(srv->lock);
 
-    ecs_allocator_t *a = &world->allocator;
-    ecs_vec_init_t(a, &world->store.records, ecs_table_record_t, 0);
-    ecs_vec_init_t(a, &world->store.marked_ids, ecs_marked_id_t, 0);
-    ecs_vec_init_t(a, &world->store.depth_ids, ecs_entity_t, 0);
-    ecs_map_init(&world->store.entity_to_depth, &world->allocator);
+    int32_t i, request_count = flecs_sparse_count(&srv->requests);
+    for (i = request_count - 1; i >= 1; i --) {
+        ecs_http_request_impl_t *req = flecs_sparse_get_dense_t(
+            &srv->requests, ecs_http_request_impl_t, i);
+        http_handle_request(srv, req);
+    }
 
-    /* Initialize entity index */
-    flecs_entities_init(world);
+    int32_t connections_count = flecs_sparse_count(&srv->connections);
+    for (i = connections_count - 1; i >= 1; i --) {
+        ecs_http_connection_impl_t *conn = flecs_sparse_get_dense_t(
+            &srv->connections, ecs_http_connection_impl_t, i);
 
-    /* Initialize root table */
-    flecs_sparse_init_t(&world->store.tables,
-        a, &world->allocators.sparse_chunk, ecs_table_t);
+        conn->dequeue_timeout += delta_time;
+        conn->dequeue_retries ++;
+        
+        if ((conn->dequeue_timeout > 
+            (double)ECS_HTTP_CONNECTION_PURGE_TIMEOUT) &&
+             (conn->dequeue_retries > ECS_HTTP_CONNECTION_PURGE_RETRY_COUNT)) 
+        {
+            ecs_dbg("http: purging connection '%s:%s' (sock = %d)", 
+                conn->pub.host, conn->pub.port, conn->sock);
+            http_connection_free(conn);
+        }
+    }
 
-    /* Initialize table map */
-    flecs_table_hashmap_init(world, &world->store.table_map);
+    http_purge_request_cache(srv, false);
+    ecs_os_mutex_unlock(srv->lock);
 
-    /* Initialize one root table per stage */
-    flecs_init_root_table(world);
+    return request_count - 1;
 }
 
-static
-void flecs_clean_tables(
-    ecs_world_t *world)
+const char* ecs_http_get_header(
+    const ecs_http_request_t* req,
+    const char* name) 
 {
-    int32_t i, count = flecs_sparse_count(&world->store.tables);
-
-    /* Ensure that first table in sparse set has id 0. This is a dummy table
-     * that only exists so that there is no table with id 0 */
-    ecs_table_t *first = flecs_sparse_get_dense_t(&world->store.tables,
-        ecs_table_t, 0);
-    (void)first;
-
-    for (i = 1; i < count; i ++) {
-        ecs_table_t *t = flecs_sparse_get_dense_t(&world->store.tables,
-            ecs_table_t, i);
-        flecs_table_free(world, t);
-    }
-
-    /* Free table types separately so that if application destructors rely on
-     * a type it's still valid. */
-    for (i = 1; i < count; i ++) {
-        ecs_table_t *t = flecs_sparse_get_dense_t(&world->store.tables,
-            ecs_table_t, i);
-        flecs_table_free_type(world, t);
+    for (ecs_size_t i = 0; i < req->header_count; i++) {
+        if (!ecs_os_strcmp(req->headers[i].key, name)) {
+            return req->headers[i].value;
+        }
     }
+    return NULL;
+}
 
-    /* Clear the root table */
-    if (count) {
-        flecs_table_reset(world, &world->store.root);
+const char* ecs_http_get_param(
+    const ecs_http_request_t* req,
+    const char* name) 
+{
+    for (ecs_size_t i = 0; i < req->param_count; i++) {
+        if (!ecs_os_strcmp(req->params[i].key, name)) {
+            return req->params[i].value;
+        }
     }
+    return NULL;
 }
 
-static
-void flecs_fini_root_tables(
-    ecs_world_t *world,
-    ecs_id_record_t *idr,
-    bool fini_targets)
+ecs_http_server_t* ecs_http_server_init(
+    const ecs_http_server_desc_t *desc) 
 {
-    ecs_table_cache_iter_t it;
+    ecs_check(ecs_os_has_threading(), ECS_UNSUPPORTED, 
+        "missing OS API implementation");
 
-    bool has_roots = flecs_table_cache_iter(&idr->cache, &it);
-    ecs_assert(has_roots == true, ECS_INTERNAL_ERROR, NULL);
-    (void)has_roots;
+    ecs_http_server_t* srv = ecs_os_calloc_t(ecs_http_server_t);
+    srv->lock = ecs_os_mutex_new();
+    srv->sock = HTTP_SOCKET_INVALID;
 
-    const ecs_table_record_t *tr;
-    while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-        ecs_table_t *table = tr->hdr.table;
-        if (table->flags & EcsTableHasBuiltins) {
-            continue; /* Filter out modules */
-        }
+    srv->should_run = false;
+    srv->initialized = true;
 
-        int32_t i, count = table->data.entities.count;
-        ecs_entity_t *entities = table->data.entities.array;
+    srv->cache_timeout = desc->cache_timeout;
+    srv->cache_purge_timeout = desc->cache_purge_timeout;
 
-        if (fini_targets) {
-            /* Only delete entities that are used as pair target. Iterate
-             * backwards to minimize moving entities around in table. */
-            for (i = count - 1; i >= 0; i --) {
-                ecs_record_t *r = flecs_entities_get(world, entities[i]);
-                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-                if (ECS_RECORD_TO_ROW_FLAGS(r->row) & EcsEntityIsTarget) {
-                    ecs_delete(world, entities[i]);
-                }
-            }
-        } else {
-            /* Delete remaining entities that are not in use (added to another
-             * entity). This limits table moves during cleanup and delays
-             * cleanup of tags. */
-            for (i = count - 1; i >= 0; i --) {
-                ecs_record_t *r = flecs_entities_get(world, entities[i]);
-                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-                if (!ECS_RECORD_TO_ROW_FLAGS(r->row)) {
-                    ecs_delete(world, entities[i]);
-                }
-            }
-        }
+    if (!ECS_EQZERO(srv->cache_timeout) && 
+         ECS_EQZERO(srv->cache_purge_timeout)) 
+    {
+        srv->cache_purge_timeout = srv->cache_timeout * 10;
     }
-}
 
-static
-void flecs_fini_roots(
-    ecs_world_t *world)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, ecs_pair(EcsChildOf, 0));
+    srv->callback = desc->callback;
+    srv->ctx = desc->ctx;
+    srv->port = desc->port;
+    srv->ipaddr = desc->ipaddr;
+    srv->send_queue.wait_ms = desc->send_queue_wait_ms;
+    if (!srv->send_queue.wait_ms) {
+        srv->send_queue.wait_ms = 1;
+    }
 
-    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
+    flecs_sparse_init_t(&srv->connections, NULL, NULL, ecs_http_connection_impl_t);
+    flecs_sparse_init_t(&srv->requests, NULL, NULL, ecs_http_request_impl_t);
 
-    /* Delete root entities that are not modules. This prioritizes deleting
-     * regular entities first, which reduces the chance of components getting
-     * destructed in random order because it got deleted before entities,
-     * thereby bypassing the OnDeleteTarget policy. */
-    flecs_defer_begin(world, &world->stages[0]);
-    flecs_fini_root_tables(world, idr, true);
-    flecs_defer_end(world, &world->stages[0]);
+    /* Start at id 1 */
+    flecs_sparse_new_id(&srv->connections);
+    flecs_sparse_new_id(&srv->requests);
 
-    flecs_defer_begin(world, &world->stages[0]);
-    flecs_fini_root_tables(world, idr, false);
-    flecs_defer_end(world, &world->stages[0]);
-}
+    /* Initialize request cache */
+    flecs_hashmap_init(&srv->request_cache, 
+        ecs_http_request_key_t, ecs_http_request_entry_t,
+        http_request_key_hash, http_request_key_compare, NULL);
 
-static
-void flecs_fini_store(ecs_world_t *world) {
-    flecs_clean_tables(world);
-    flecs_sparse_fini(&world->store.tables);
-    flecs_table_free(world, &world->store.root);
-    flecs_entities_clear(world);
-    flecs_hashmap_fini(&world->store.table_map);
+#ifndef ECS_TARGET_WINDOWS
+    /* Ignore pipe signal. SIGPIPE can occur when a message is sent to a client
+     * but te client already disconnected. */
+    signal(SIGPIPE, SIG_IGN);
+#endif
 
-    ecs_allocator_t *a = &world->allocator;
-    ecs_vec_fini_t(a, &world->store.records, ecs_table_record_t);
-    ecs_vec_fini_t(a, &world->store.marked_ids, ecs_marked_id_t);
-    ecs_vec_fini_t(a, &world->store.depth_ids, ecs_entity_t);
-    ecs_map_fini(&world->store.entity_to_depth);
+    return srv;
+error:
+    return NULL;
 }
 
-/* Implementation for iterable mixin */
-static
-bool flecs_world_iter_next(
-    ecs_iter_t *it)
+void ecs_http_server_fini(
+    ecs_http_server_t* srv) 
 {
-    if (ECS_BIT_IS_SET(it->flags, EcsIterIsValid)) {
-        ECS_BIT_CLEAR(it->flags, EcsIterIsValid);
-        ecs_iter_fini(it);
-        return false;
+    if (srv->should_run) {
+        ecs_http_server_stop(srv);
     }
-
-    ecs_world_t *world = it->real_world;
-    it->entities = ECS_CONST_CAST(ecs_entity_t*, flecs_entities_ids(world));
-    it->count = flecs_entities_count(world);
-    flecs_iter_validate(it);
-
-    return true;
+    ecs_os_mutex_free(srv->lock);
+    http_purge_request_cache(srv, true);
+    flecs_sparse_fini(&srv->requests);
+    flecs_sparse_fini(&srv->connections);
+    ecs_os_free(srv);
 }
 
-static
-void flecs_world_iter_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter)
+int ecs_http_server_start(
+    ecs_http_server_t *srv)
 {
-    ecs_poly_assert(poly, ecs_world_t);
-    (void)poly;
+    ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(srv->initialized, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!srv->should_run, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!srv->thread, ECS_INVALID_PARAMETER, NULL);
 
-    if (filter) {
-        iter[0] = ecs_term_iter(world, filter);
-    } else {
-        iter[0] = (ecs_iter_t){
-            .world = ECS_CONST_CAST(ecs_world_t*, world),
-            .real_world = ECS_CONST_CAST(ecs_world_t*, ecs_get_world(world)),
-            .next = flecs_world_iter_next
-        };
-    }
-}
+    srv->should_run = true;
 
-static
-void flecs_world_allocators_init(
-    ecs_world_t *world)
-{
-    ecs_world_allocators_t *a = &world->allocators;
+    ecs_dbg("http: starting server thread");
 
-    flecs_allocator_init(&world->allocator);
+    srv->thread = ecs_os_thread_new(http_server_thread, srv);
+    if (!srv->thread) {
+        goto error;
+    }
 
-    ecs_map_params_init(&a->ptr, &world->allocator);
-    ecs_map_params_init(&a->query_table_list, &world->allocator);
+    srv->send_queue.thread = ecs_os_thread_new(http_server_send_queue, srv);
+    if (!srv->send_queue.thread) {
+        goto error;
+    }
 
-    flecs_ballocator_init_t(&a->query_table, ecs_query_table_t);
-    flecs_ballocator_init_t(&a->query_table_match, ecs_query_table_match_t);
-    flecs_ballocator_init_n(&a->graph_edge_lo, ecs_graph_edge_t, FLECS_HI_COMPONENT_ID);
-    flecs_ballocator_init_t(&a->graph_edge, ecs_graph_edge_t);
-    flecs_ballocator_init_t(&a->id_record, ecs_id_record_t);
-    flecs_ballocator_init_n(&a->id_record_chunk, ecs_id_record_t, FLECS_SPARSE_PAGE_SIZE);
-    flecs_ballocator_init_t(&a->table_diff, ecs_table_diff_t);
-    flecs_ballocator_init_n(&a->sparse_chunk, int32_t, FLECS_SPARSE_PAGE_SIZE);
-    flecs_ballocator_init_t(&a->hashmap, ecs_hashmap_t);
-    flecs_table_diff_builder_init(world, &world->allocators.diff_builder);
+    return 0;
+error:
+    return -1;
 }
 
-static
-void flecs_world_allocators_fini(
-    ecs_world_t *world)
+void ecs_http_server_stop(
+    ecs_http_server_t* srv) 
 {
-    ecs_world_allocators_t *a = &world->allocators;
+    ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(srv->initialized, ECS_INVALID_OPERATION, 
+        "cannot stop HTTP server: not initialized");
+    ecs_check(srv->should_run, ECS_INVALID_PARAMETER, 
+        "cannot stop HTTP server: already stopped/stopping");
 
-    ecs_map_params_fini(&a->ptr);
-    ecs_map_params_fini(&a->query_table_list);
+    /* Stop server thread */
+    ecs_dbg("http: shutting down server thread");
 
-    flecs_ballocator_fini(&a->query_table);
-    flecs_ballocator_fini(&a->query_table_match);
-    flecs_ballocator_fini(&a->graph_edge_lo);
-    flecs_ballocator_fini(&a->graph_edge);
-    flecs_ballocator_fini(&a->id_record);
-    flecs_ballocator_fini(&a->id_record_chunk);
-    flecs_ballocator_fini(&a->table_diff);
-    flecs_ballocator_fini(&a->sparse_chunk);
-    flecs_ballocator_fini(&a->hashmap);
-    flecs_table_diff_builder_fini(world, &world->allocators.diff_builder);
-
-    flecs_allocator_fini(&world->allocator);
-}
-
-#define ECS_STRINGIFY_INNER(x) #x
-#define ECS_STRINGIFY(x) ECS_STRINGIFY_INNER(x)
+    ecs_os_mutex_lock(srv->lock);
+    srv->should_run = false;
+    if (http_socket_is_valid(srv->sock)) {
+        http_close(&srv->sock);
+    }
+    ecs_os_mutex_unlock(srv->lock);
 
-static const char flecs_compiler_info[]
-#if defined(__clang__)
-    = "clang " __clang_version__;
-#elif defined(__GNUC__)
-    = "gcc " ECS_STRINGIFY(__GNUC__) "." ECS_STRINGIFY(__GNUC_MINOR__);
-#elif defined(_MSC_VER)
-    = "msvc " ECS_STRINGIFY(_MSC_VER);
-#elif defined(__TINYC__)
-    = "tcc " ECS_STRINGIFY(__TINYC__);
-#else
-    = "unknown compiler";
-#endif
+    ecs_os_thread_join(srv->thread);
+    ecs_os_thread_join(srv->send_queue.thread);
+    ecs_trace("http: server threads shut down");
 
-static const char *flecs_addons_info[] = {
-#ifdef FLECS_CPP
-    "FLECS_CPP",
-#endif
-#ifdef FLECS_MODULE
-    "FLECS_MODULE",
-#endif
-#ifdef FLECS_PARSER
-    "FLECS_PARSER",
-#endif
-#ifdef FLECS_PLECS
-    "FLECS_PLECS",
-#endif
-#ifdef FLECS_RULES
-    "FLECS_RULES",
-#endif
-#ifdef FLECS_SNAPSHOT
-    "FLECS_SNAPSHOT",
-#endif
-#ifdef FLECS_STATS
-    "FLECS_STATS",
-#endif
-#ifdef FLECS_MONITOR
-    "FLECS_MONITOR",
-#endif
-#ifdef FLECS_METRICS
-    "FLECS_METRICS",
-#endif
-#ifdef FLECS_ALERTS
-    "FLECS_ALERTS",
-#endif
-#ifdef FLECS_SYSTEM
-    "FLECS_SYSTEM",
-#endif
-#ifdef FLECS_PIPELINE
-    "FLECS_PIPELINE",
-#endif
-#ifdef FLECS_TIMER
-    "FLECS_TIMER",
-#endif
-#ifdef FLECS_META
-    "FLECS_META",
-#endif
-#ifdef FLECS_META_C
-    "FLECS_META_C",
-#endif
-#ifdef FLECS_UNITS
-    "FLECS_UNITS",
-#endif
-#ifdef FLECS_EXPR
-    "FLECS_EXPR",
-#endif
-#ifdef FLECS_JSON
-    "FLECS_JSON",
-#endif
-#ifdef FLECS_DOC
-    "FLECS_DOC",
-#endif
-#ifdef FLECS_LOG
-    "FLECS_LOG",
-#endif
-#ifdef FLECS_JOURNAL
-    "FLECS_JOURNAL",
-#endif
-#ifdef FLECS_APP
-    "FLECS_APP",
-#endif
-#ifdef FLECS_OS_API_IMPL
-    "FLECS_OS_API_IMPL",
-#endif
-#ifdef FLECS_SCRIPT
-    "FLECS_SCRIPT",
-#endif
-#ifdef FLECS_HTTP
-    "FLECS_HTTP",
-#endif
-#ifdef FLECS_REST
-    "FLECS_REST",
-#endif
-NULL
-};
+    /* Cleanup all outstanding requests */
+    int i, count = flecs_sparse_count(&srv->requests);
+    for (i = count - 1; i >= 1; i --) {
+        http_request_fini(flecs_sparse_get_dense_t(
+            &srv->requests, ecs_http_request_impl_t, i));
+    }
 
-static const ecs_build_info_t flecs_build_info = {
-    .compiler = flecs_compiler_info,
-    .addons = flecs_addons_info,
-#ifdef FLECS_DEBUG
-    .debug = true,
-#endif
-#ifdef FLECS_SANITIZE
-    .sanitize = true,
-#endif
-#ifdef FLECS_PERF_TRACE
-    .perf_trace = true,
-#endif
-    .version = FLECS_VERSION,
-    .version_major = FLECS_VERSION_MAJOR,
-    .version_minor = FLECS_VERSION_MINOR,
-    .version_patch = FLECS_VERSION_PATCH
-};
+    /* Close all connections */
+    count = flecs_sparse_count(&srv->connections);
+    for (i = count - 1; i >= 1; i --) {
+        http_connection_free(flecs_sparse_get_dense_t(
+            &srv->connections, ecs_http_connection_impl_t, i));
+    }
 
-static
-void flecs_log_build_info(void) {
-    const ecs_build_info_t *bi = ecs_get_build_info();
-    ecs_assert(bi != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(flecs_sparse_count(&srv->connections) == 1, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(flecs_sparse_count(&srv->requests) == 1,
+        ECS_INTERNAL_ERROR, NULL);
 
-    ecs_trace("flecs version %s", bi->version);
+    srv->thread = 0;
+error:
+    return;
+}
 
-    ecs_trace("addons included in build:");
-    ecs_log_push();
+void ecs_http_server_dequeue(
+    ecs_http_server_t* srv,
+    ecs_ftime_t delta_time)
+{
+    ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(srv->initialized, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(srv->should_run, ECS_INVALID_PARAMETER, NULL);
+    
+    srv->dequeue_timeout += (double)delta_time;
+    srv->stats_timeout += (double)delta_time;
 
-    const char **addon = bi->addons;
-    do {
-        ecs_trace(addon[0]);
-    } while ((++ addon)[0]);
-    ecs_log_pop();
+    if ((1000 * srv->dequeue_timeout) > (double)ECS_HTTP_MIN_DEQUEUE_INTERVAL) {
+        srv->dequeue_timeout = 0;
 
-    if (bi->sanitize) {
-        ecs_trace("sanitize build, rebuild without FLECS_SANITIZE for (much) "
-            "improved performance");
-    } else if (bi->debug) {
-        ecs_trace("debug build, rebuild with NDEBUG or FLECS_NDEBUG for "
-            "improved performance");
-    } else {
-        ecs_trace("#[green]release#[reset] build");
+        ecs_time_t t = {0};
+        ecs_time_measure(&t);
+        int32_t request_count = http_dequeue_requests(srv, srv->dequeue_timeout);
+        srv->requests_processed += request_count;
+        srv->requests_processed_total += request_count;
+        double time_spent = ecs_time_measure(&t);
+        srv->request_time += time_spent;
+        srv->request_time_total += time_spent;
+        srv->dequeue_count ++;
     }
 
-    ecs_trace("compiled with %s", bi->compiler);
-}
-
-/* -- Public functions -- */
+    if ((1000 * srv->stats_timeout) > (double)ECS_HTTP_MIN_STATS_INTERVAL) {
+        srv->stats_timeout = 0;
+        ecs_dbg("http: processed %d requests in %.3fs (avg %.3fs / dequeue)",
+            srv->requests_processed, srv->request_time, 
+            (srv->request_time / (double)srv->dequeue_count));
+        srv->requests_processed = 0;
+        srv->request_time = 0;
+        srv->dequeue_count = 0;
+    }
 
-const ecs_build_info_t* ecs_get_build_info(void) {
-    return &flecs_build_info;
+error:
+    return;
 }
 
-const ecs_world_info_t* ecs_get_world_info(
-    const ecs_world_t *world)
+int ecs_http_server_http_request(
+    ecs_http_server_t* srv,
+    const char *req,
+    ecs_size_t len,
+    ecs_http_reply_t *reply_out)
 {
-    world = ecs_get_world(world);
-    return &world->info;
-}
-
-ecs_world_t *ecs_mini(void) {
-#ifdef FLECS_OS_API_IMPL
-    ecs_set_os_api_impl();
-#endif
-    ecs_os_init();
-
-    ecs_trace("#[bold]bootstrapping world");
-    ecs_log_push();
-
-    ecs_trace("tracing enabled, call ecs_log_set_level(-1) to disable");
-
-    if (!ecs_os_has_heap()) {
-        ecs_abort(ECS_MISSING_OS_API, NULL);
+    if (!len) {
+        len = ecs_os_strlen(req);
     }
 
-    if (!ecs_os_has_threading()) {
-        ecs_trace("threading unavailable, to use threads set OS API first (see examples)");
+    ecs_http_fragment_t frag = {0};
+    if (!http_parse_request(&frag, req, len)) {
+        ecs_strbuf_reset(&frag.buf);
+        reply_out->code = 400;
+        return -1;
     }
 
-    if (!ecs_os_has_time()) {
-        ecs_trace("time management not available");
+    ecs_http_request_impl_t request;
+    char *res = http_decode_request(&request, &frag);
+    if (!res) {
+        reply_out->code = 400;
+        return -1;
     }
 
-    flecs_log_build_info();
-
-    ecs_world_t *world = ecs_os_calloc_t(ecs_world_t);
-    ecs_assert(world != NULL, ECS_OUT_OF_MEMORY, NULL);
-    ecs_poly_init(world, ecs_world_t);
-
-    world->flags |= EcsWorldInit;
-
-    flecs_world_allocators_init(world);
-    ecs_allocator_t *a = &world->allocator;
-
-    world->self = world;
-    flecs_sparse_init_t(&world->type_info, a,
-        &world->allocators.sparse_chunk, ecs_type_info_t);
-    ecs_map_init_w_params(&world->id_index_hi, &world->allocators.ptr);
-    world->id_index_lo = ecs_os_calloc_n(ecs_id_record_t, FLECS_HI_ID_RECORD_ID);
-    flecs_observable_init(&world->observable);
-    world->iterable.init = flecs_world_iter_init;
-
-    world->pending_tables = ecs_os_calloc_t(ecs_sparse_t);
-    flecs_sparse_init_t(world->pending_tables, a,
-        &world->allocators.sparse_chunk, ecs_table_t*);
-    world->pending_buffer = ecs_os_calloc_t(ecs_sparse_t);
-    flecs_sparse_init_t(world->pending_buffer, a,
-        &world->allocators.sparse_chunk, ecs_table_t*);
-
-    flecs_name_index_init(&world->aliases, a);
-    flecs_name_index_init(&world->symbols, a);
-    ecs_vec_init_t(a, &world->fini_actions, ecs_action_elem_t, 0);
+    ecs_http_request_entry_t *entry = 
+        http_find_request_entry(srv, request.res, request.req_len);
+    if (entry) {
+        reply_out->body = ECS_STRBUF_INIT;
+        reply_out->code = entry->code;
+        reply_out->content_type = "application/json";
+        reply_out->headers = ECS_STRBUF_INIT;
+        reply_out->status = "OK";
+        ecs_strbuf_appendstrn(&reply_out->body, 
+            entry->content, entry->content_length);
+    } else {
+        http_do_request(srv, reply_out, &request);
 
-    world->info.time_scale = 1.0;
-    if (ecs_os_has_time()) {
-        ecs_os_get_time(&world->world_start_time);
+        if (request.pub.method == EcsHttpGet) {
+            http_insert_request_entry(srv, &request, reply_out);
+        }
     }
 
-    ecs_set_stage_count(world, 1);
-    ecs_default_lookup_path[0] = EcsFlecsCore;
-    ecs_set_lookup_path(world, ecs_default_lookup_path);
-    flecs_init_store(world);
-
-    flecs_bootstrap(world);
-
-    world->flags &= ~EcsWorldInit;
-
-    ecs_trace("world ready!");
-    ecs_log_pop();
-
-    return world;
-}
+    ecs_os_free(res);
 
-ecs_world_t *ecs_init(void) {
-    ecs_world_t *world = ecs_mini();
+    http_purge_request_cache(srv, false);
 
-#ifdef FLECS_MODULE_H
-    ecs_trace("#[bold]import addons");
-    ecs_log_push();
-    ecs_trace("use ecs_mini to create world without importing addons");
-#ifdef FLECS_SYSTEM
-    ECS_IMPORT(world, FlecsSystem);
-#endif
-#ifdef FLECS_PIPELINE
-    ECS_IMPORT(world, FlecsPipeline);
-#endif
-#ifdef FLECS_TIMER
-    ECS_IMPORT(world, FlecsTimer);
-#endif
-#ifdef FLECS_META
-    ECS_IMPORT(world, FlecsMeta);
-#endif
-#ifdef FLECS_DOC
-    ECS_IMPORT(world, FlecsDoc);
-#endif
-#ifdef FLECS_SCRIPT
-    ECS_IMPORT(world, FlecsScript);
-#endif
-#ifdef FLECS_REST
-    ECS_IMPORT(world, FlecsRest);
-#endif
-#ifdef FLECS_UNITS
-    ecs_trace("#[green]module#[reset] flecs.units is not automatically imported");
-#endif
-    ecs_trace("addons imported!");
-    ecs_log_pop();
-#endif
-    return world;
+    return (reply_out->code >= 400) ? -1 : 0;
 }
 
-ecs_world_t* ecs_init_w_args(
-    int argc,
-    char *argv[])
+int ecs_http_server_request(
+    ecs_http_server_t* srv,
+    const char *method,
+    const char *req,
+    ecs_http_reply_t *reply_out)
 {
-    ecs_world_t *world = ecs_init();
-
-    (void)argc;
-    (void)argv;
+    const char *http_ver = " HTTP/1.1\r\n\r\n";
+    int32_t method_len = ecs_os_strlen(method);
+    int32_t req_len = ecs_os_strlen(req);
+    int32_t http_ver_len = ecs_os_strlen(http_ver);
 
-#ifdef FLECS_DOC
-    if (argc) {
-        char *app = argv[0];
-        char *last_elem = strrchr(app, '/');
-        if (!last_elem) {
-            last_elem = strrchr(app, '\\');
-        }
-        if (last_elem) {
-            app = last_elem + 1;
-        }
-        ecs_set_pair(world, EcsWorld, EcsDocDescription, EcsName, {app});
+    int32_t len = method_len + req_len + http_ver_len + 1;
+    if (method_len + req_len + http_ver_len >= 1024) {
+        ecs_err("HTTP request too long");
+        return -1;
     }
-#endif
 
-    return world;
-}
+    char reqstr[1024];
+    char *ptr = reqstr;
+    ecs_os_memcpy(ptr, method, method_len); ptr += method_len;
+    ptr[0] = ' '; ptr ++;
+    ecs_os_memcpy(ptr, req, req_len); ptr += req_len;
+    ecs_os_memcpy(ptr, http_ver, http_ver_len); ptr += http_ver_len;
+    ptr[0] = '\n';
 
-void ecs_quit(
-    ecs_world_t *world)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    flecs_stage_from_world(&world);
-    world->flags |= EcsWorldQuit;
-error:
-    return;
+    return ecs_http_server_http_request(srv, reqstr, len, reply_out);
 }
 
-bool ecs_should_quit(
-    const ecs_world_t *world)
+void* ecs_http_server_ctx(
+    ecs_http_server_t* srv)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    world = ecs_get_world(world);
-    return ECS_BIT_IS_SET(world->flags, EcsWorldQuit);
-error:
-    return true;
+    return srv->ctx;
 }
 
-void flecs_notify_tables(
-    ecs_world_t *world,
-    ecs_id_t id,
-    ecs_table_event_t *event)
-{
-    ecs_poly_assert(world, ecs_world_t);
-
-    /* If no id is specified, broadcast to all tables */
-    if (!id) {
-        ecs_sparse_t *tables = &world->store.tables;
-        int32_t i, count = flecs_sparse_count(tables);
-        for (i = 0; i < count; i ++) {
-            ecs_table_t *table = flecs_sparse_get_dense_t(tables, ecs_table_t, i);
-            flecs_table_notify(world, table, event);
-        }
-
-    /* If id is specified, only broadcast to tables with id */
-    } else {
-        ecs_id_record_t *idr = flecs_id_record_get(world, id);
-        if (!idr) {
-            return;
-        }
+#endif
 
-        ecs_table_cache_iter_t it;
-        const ecs_table_record_t *tr;
+/**
+ * @file addons/journal.c
+ * @brief Journal addon.
+ */
 
-        flecs_table_cache_all_iter(&idr->cache, &it);
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            flecs_table_notify(world, tr->hdr.table, event);
-        }
-    }
-}
 
-void ecs_default_ctor(
-    void *ptr,
-    int32_t count,
-    const ecs_type_info_t *ti)
-{
-    ecs_os_memset(ptr, 0, ti->size * count);
-}
+#ifdef FLECS_JOURNAL
 
 static
-void flecs_default_copy_ctor(void *dst_ptr, const void *src_ptr,
-    int32_t count, const ecs_type_info_t *ti)
+char* flecs_journal_entitystr(
+    ecs_world_t *world,
+    ecs_entity_t entity)
 {
-    const ecs_type_hooks_t *cl = &ti->hooks;
-    cl->ctor(dst_ptr, count, ti);
-    cl->copy(dst_ptr, src_ptr, count, ti);
+    char *path;
+    const char *_path = ecs_get_symbol(world, entity);
+    if (_path && !strchr(_path, '.')) {
+        path = flecs_asprintf("#[blue]%s", _path);
+    } else {
+        uint32_t gen = entity >> 32;
+        if (gen) {
+            path = flecs_asprintf("#[normal]_%u_%u", (uint32_t)entity, gen);
+        } else {
+            path = flecs_asprintf("#[normal]_%u", (uint32_t)entity);
+        }
+    }
+    return path;
 }
 
 static
-void flecs_default_move_ctor(void *dst_ptr, void *src_ptr,
-    int32_t count, const ecs_type_info_t *ti)
+char* flecs_journal_idstr(
+    ecs_world_t *world,
+    ecs_id_t id)
 {
-    const ecs_type_hooks_t *cl = &ti->hooks;
-    cl->ctor(dst_ptr, count, ti);
-    cl->move(dst_ptr, src_ptr, count, ti);
+    if (ECS_IS_PAIR(id)) {
+        char *first_path = flecs_journal_entitystr(world, 
+            ecs_pair_first(world, id));
+        char *second_path = flecs_journal_entitystr(world, 
+            ecs_pair_second(world, id));
+        char *result = flecs_asprintf("#[cyan]ecs_pair#[normal](%s, %s)",
+            first_path, second_path);
+        ecs_os_free(first_path);
+        ecs_os_free(second_path);
+        return result;
+    } else if (!(id & ECS_ID_FLAGS_MASK)) {
+        return flecs_journal_entitystr(world, id);
+    } else {
+        return ecs_id_str(world, id);
+    }
 }
 
-static
-void flecs_default_ctor_w_move_w_dtor(void *dst_ptr, void *src_ptr,
-    int32_t count, const ecs_type_info_t *ti)
-{
-    const ecs_type_hooks_t *cl = &ti->hooks;
-    cl->ctor(dst_ptr, count, ti);
-    cl->move(dst_ptr, src_ptr, count, ti);
-    cl->dtor(src_ptr, count, ti);
-}
+static int flecs_journal_sp = 0;
 
-static
-void flecs_default_move_ctor_w_dtor(void *dst_ptr, void *src_ptr,
-    int32_t count, const ecs_type_info_t *ti)
+void flecs_journal_begin(
+    ecs_world_t *world,
+    ecs_journal_kind_t kind,
+    ecs_entity_t entity,
+    ecs_type_t *add,
+    ecs_type_t *remove)
 {
-    const ecs_type_hooks_t *cl = &ti->hooks;
-    cl->move_ctor(dst_ptr, src_ptr, count, ti);
-    cl->dtor(src_ptr, count, ti);
-}
+    flecs_journal_sp ++;
 
-static
-void flecs_default_move(void *dst_ptr, void *src_ptr,
-    int32_t count, const ecs_type_info_t *ti)
-{
-    const ecs_type_hooks_t *cl = &ti->hooks;
-    cl->move(dst_ptr, src_ptr, count, ti);
-}
+    if (ecs_os_api.log_level_ < FLECS_JOURNAL_LOG_LEVEL) {
+        return;
+    }
 
-static
-void flecs_default_dtor(void *dst_ptr, void *src_ptr,
-    int32_t count, const ecs_type_info_t *ti)
-{
-    /* When there is no move, destruct the destination component & memcpy the
-     * component to dst. The src component does not have to be destructed when
-     * a component has a trivial move. */
-    const ecs_type_hooks_t *cl = &ti->hooks;
-    cl->dtor(dst_ptr, count, ti);
-    ecs_os_memcpy(dst_ptr, src_ptr, flecs_uto(ecs_size_t, ti->size) * count);
-}
+    char *path = NULL; 
+    char *var_id = NULL; 
+    if (entity) {
+        if (kind != EcsJournalDeleteWith && kind != EcsJournalRemoveAll) {
+            path = ecs_get_fullpath(world, entity);
+            var_id = flecs_journal_entitystr(world, entity);
+        } else {
+            path = ecs_id_str(world, entity);
+            var_id = flecs_journal_idstr(world, entity);
+        }
+    }
 
-static
-void flecs_default_move_w_dtor(void *dst_ptr, void *src_ptr,
-    int32_t count, const ecs_type_info_t *ti)
-{
-    /* If a component has a move, the move will take care of memcpying the data
-     * and destroying any data in dst. Because this is not a trivial move, the
-     * src component must also be destructed. */
-    const ecs_type_hooks_t *cl = &ti->hooks;
-    cl->move(dst_ptr, src_ptr, count, ti);
-    cl->dtor(src_ptr, count, ti);
+    if (kind == EcsJournalNew) {
+        ecs_print(4, "#[magenta]#ifndef #[normal]_var_%s", var_id);
+        ecs_print(4, "#[magenta]#define #[normal]_var_%s", var_id);
+        ecs_print(4, "#[green]ecs_entity_t %s;", var_id);
+        ecs_print(4, "#[magenta]#endif");
+        ecs_print(4, "%s = #[cyan]ecs_new_id#[reset](world); "
+            "#[grey] // %s = new()", var_id, path);
+    }
+    if (add) {
+        for (int i = 0; i < add->count; i ++) {
+            char *jidstr = flecs_journal_idstr(world, add->array[i]);
+            char *idstr = ecs_id_str(world, add->array[i]);
+            ecs_print(4, "#[cyan]ecs_add_id#[reset](world, %s, %s); "
+                "#[grey] // add(%s, %s)", var_id, jidstr, 
+                    path, idstr);
+            ecs_os_free(idstr);
+            ecs_os_free(jidstr);
+        }
+    }
+    if (remove) {
+        for (int i = 0; i < remove->count; i ++) {
+            char *jidstr = flecs_journal_idstr(world, remove->array[i]);
+            char *idstr = ecs_id_str(world, remove->array[i]);
+            ecs_print(4, "#[cyan]ecs_remove_id#[reset](world, %s, %s); "
+                "#[grey] // remove(%s, %s)", var_id, jidstr, 
+                    path, idstr);
+            ecs_os_free(idstr);
+            ecs_os_free(jidstr);
+        }
+    }
+    if (kind == EcsJournalClear) {
+        ecs_print(4, "#[cyan]ecs_clear#[reset](world, %s); "
+            "#[grey] // clear(%s)", var_id, path);
+    } else if (kind == EcsJournalDelete) {
+        ecs_print(4, "#[cyan]ecs_delete#[reset](world, %s); "
+            "#[grey] // delete(%s)", var_id, path);
+    } else if (kind == EcsJournalDeleteWith) {
+        ecs_print(4, "#[cyan]ecs_delete_with#[reset](world, %s); "
+            "#[grey] // delete_with(%s)", var_id, path);
+    } else if (kind == EcsJournalRemoveAll) {
+        ecs_print(4, "#[cyan]ecs_remove_all#[reset](world, %s); "
+            "#[grey] // remove_all(%s)", var_id, path);
+    } else if (kind == EcsJournalTableEvents) {
+        ecs_print(4, "#[cyan]ecs_run_aperiodic#[reset](world, "
+            "EcsAperiodicEmptyTables);");
+    }
+    ecs_os_free(var_id);
+    ecs_os_free(path);
+    ecs_log_push();
 }
 
-void ecs_set_hooks_id(
-    ecs_world_t *world,
-    ecs_entity_t component,
-    const ecs_type_hooks_t *h)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+void flecs_journal_end(void) {
+    flecs_journal_sp --;
+    ecs_assert(flecs_journal_sp >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_log_pop();
+}
 
-    flecs_stage_from_world(&world);
+#endif
 
-    /* Ensure that no tables have yet been created for the component */
-    ecs_assert( ecs_id_in_use(world, component) == false,
-        ECS_ALREADY_IN_USE, ecs_get_name(world, component));
-    ecs_assert( ecs_id_in_use(world, ecs_pair(component, EcsWildcard)) == false,
-        ECS_ALREADY_IN_USE, ecs_get_name(world, component));
+/**
+ * @file addons/log.c
+ * @brief Log addon.
+ */
 
-    ecs_type_info_t *ti = flecs_type_info_ensure(world, component);
-    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_check(!ti->component || ti->component == component,
-        ECS_INCONSISTENT_COMPONENT_ACTION, NULL);
+#ifdef FLECS_LOG
 
-    if (!ti->size) {
-        const EcsComponent *component_ptr = ecs_get(
-            world, component, EcsComponent);
+#include <ctype.h>
 
-        /* Cannot register lifecycle actions for things that aren't a component */
-        ecs_check(component_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-        /* Cannot register lifecycle actions for components with size 0 */
-        ecs_check(component_ptr->size != 0, ECS_INVALID_PARAMETER, NULL);
+void flecs_colorize_buf(
+    char *msg,
+    bool enable_colors,
+    ecs_strbuf_t *buf)
+{
+    ecs_assert(msg != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(buf != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        ti->size = component_ptr->size;
-        ti->alignment = component_ptr->alignment;
-    }
+    char *ptr, ch, prev = '\0';
+    bool isNum = false;
+    char isStr = '\0';
+    bool isVar = false;
+    bool overrideColor = false;
+    bool autoColor = true;
+    bool dontAppend = false;
 
-    if (h->ctor) ti->hooks.ctor = h->ctor;
-    if (h->dtor) ti->hooks.dtor = h->dtor;
-    if (h->copy) ti->hooks.copy = h->copy;
-    if (h->move) ti->hooks.move = h->move;
-    if (h->copy_ctor) ti->hooks.copy_ctor = h->copy_ctor;
-    if (h->move_ctor) ti->hooks.move_ctor = h->move_ctor;
-    if (h->ctor_move_dtor) ti->hooks.ctor_move_dtor = h->ctor_move_dtor;
-    if (h->move_dtor) ti->hooks.move_dtor = h->move_dtor;
+    for (ptr = msg; (ch = *ptr); ptr++) {
+        dontAppend = false;
 
-    if (h->on_add) ti->hooks.on_add = h->on_add;
-    if (h->on_remove) ti->hooks.on_remove = h->on_remove;
-    if (h->on_set) ti->hooks.on_set = h->on_set;
+        if (!overrideColor) {
+            if (isNum && !isdigit(ch) && !isalpha(ch) && (ch != '.') && (ch != '%')) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
+                isNum = false;
+            }
+            if (isStr && (isStr == ch) && prev != '\\') {
+                isStr = '\0';
+            } else if (((ch == '\'') || (ch == '"')) && !isStr &&
+                !isalpha(prev) && (prev != '\\'))
+            {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_CYAN);
+                isStr = ch;
+            }
 
-    if (h->ctx) ti->hooks.ctx = h->ctx;
-    if (h->binding_ctx) ti->hooks.binding_ctx = h->binding_ctx;
-    if (h->ctx_free) ti->hooks.ctx_free = h->ctx_free;
-    if (h->binding_ctx_free) ti->hooks.binding_ctx_free = h->binding_ctx_free;
+            if ((isdigit(ch) || (ch == '%' && isdigit(prev)) ||
+                (ch == '-' && isdigit(ptr[1]))) && !isNum && !isStr && !isVar &&
+                 !isalpha(prev) && !isdigit(prev) && (prev != '_') &&
+                 (prev != '.'))
+            {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_GREEN);
+                isNum = true;
+            }
 
-    /* If no constructor is set, invoking any of the other lifecycle actions
-     * is not safe as they will potentially access uninitialized memory. For
-     * ease of use, if no constructor is specified, set a default one that
-     * initializes the component to 0. */
-    if (!h->ctor && (h->dtor || h->copy || h->move)) {
-        ti->hooks.ctor = ecs_default_ctor;
-    }
+            if (isVar && !isalpha(ch) && !isdigit(ch) && ch != '_') {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
+                isVar = false;
+            }
 
-    /* Set default copy ctor, move ctor and merge */
-    if (h->copy && !h->copy_ctor) {
-        ti->hooks.copy_ctor = flecs_default_copy_ctor;
-    }
+            if (!isStr && !isVar && ch == '$' && isalpha(ptr[1])) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_CYAN);
+                isVar = true;
+            }
+        }
 
-    if (h->move && !h->move_ctor) {
-        ti->hooks.move_ctor = flecs_default_move_ctor;
-    }
+        if (!isVar && !isStr && !isNum && ch == '#' && ptr[1] == '[') {
+            bool isColor = true;
+            overrideColor = true;
 
-    if (!h->ctor_move_dtor) {
-        if (h->move) {
-            if (h->dtor) {
-                if (h->move_ctor) {
-                    /* If an explicit move ctor has been set, use callback
-                     * that uses the move ctor vs. using a ctor+move */
-                    ti->hooks.ctor_move_dtor = flecs_default_move_ctor_w_dtor;
-                } else {
-                    /* If no explicit move_ctor has been set, use
-                     * combination of ctor + move + dtor */
-                    ti->hooks.ctor_move_dtor = flecs_default_ctor_w_move_w_dtor;
-                }
+            /* Custom colors */
+            if (!ecs_os_strncmp(&ptr[2], "]", ecs_os_strlen("]"))) {
+                autoColor = false;
+            } else if (!ecs_os_strncmp(&ptr[2], "green]", ecs_os_strlen("green]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_GREEN);
+            } else if (!ecs_os_strncmp(&ptr[2], "red]", ecs_os_strlen("red]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_RED);
+            } else if (!ecs_os_strncmp(&ptr[2], "blue]", ecs_os_strlen("red]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_BLUE);
+            } else if (!ecs_os_strncmp(&ptr[2], "magenta]", ecs_os_strlen("magenta]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_MAGENTA);
+            } else if (!ecs_os_strncmp(&ptr[2], "cyan]", ecs_os_strlen("cyan]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_CYAN);
+            } else if (!ecs_os_strncmp(&ptr[2], "yellow]", ecs_os_strlen("yellow]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_YELLOW);
+            } else if (!ecs_os_strncmp(&ptr[2], "grey]", ecs_os_strlen("grey]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_GREY);
+            } else if (!ecs_os_strncmp(&ptr[2], "white]", ecs_os_strlen("white]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
+            } else if (!ecs_os_strncmp(&ptr[2], "bold]", ecs_os_strlen("bold]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_BOLD);
+            } else if (!ecs_os_strncmp(&ptr[2], "normal]", ecs_os_strlen("normal]"))) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
+            } else if (!ecs_os_strncmp(&ptr[2], "reset]", ecs_os_strlen("reset]"))) {
+                overrideColor = false;
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
             } else {
-                /* If no dtor has been set, this is just a move ctor */
-                ti->hooks.ctor_move_dtor = ti->hooks.move_ctor;
+                isColor = false;
+                overrideColor = false;
             }
-        } else {
-            /* If move is not set but move_ctor and dtor is, we can still set
-             * ctor_move_dtor. */
-            if (h->move_ctor) {
-                if (h->dtor) {
-                    ti->hooks.ctor_move_dtor = flecs_default_move_ctor_w_dtor;
-                } else {
-                    ti->hooks.ctor_move_dtor = ti->hooks.move_ctor;
-                }
+
+            if (isColor) {
+                ptr += 2;
+                while ((ch = *ptr) != ']') ptr ++;
+                dontAppend = true;
+            }
+            if (!autoColor) {
+                overrideColor = true;
             }
         }
-    }
 
-    if (!h->move_dtor) {
-        if (h->move) {
-            if (h->dtor) {
-                ti->hooks.move_dtor = flecs_default_move_w_dtor;
-            } else {
-                ti->hooks.move_dtor = flecs_default_move;
+        if (ch == '\n') {
+            if (isNum || isStr || isVar || overrideColor) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
+                overrideColor = false;
+                isNum = false;
+                isStr = false;
+                isVar = false;
             }
-        } else {
-            if (h->dtor) {
-                ti->hooks.move_dtor = flecs_default_dtor;
+        }
+
+        if (!dontAppend) {
+            ecs_strbuf_appendstrn(buf, ptr, 1);
+        }
+
+        if (!overrideColor) {
+            if (((ch == '\'') || (ch == '"')) && !isStr) {
+                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
             }
         }
-    }
 
-error:
-    return;
-}
+        prev = ch;
+    }
 
-const ecs_type_hooks_t* ecs_get_hooks_id(
-    ecs_world_t *world,
-    ecs_entity_t id)
-{
-    const ecs_type_info_t *ti = ecs_get_type_info(world, id);
-    if (ti) {
-        return &ti->hooks;
+    if (isNum || isStr || isVar || overrideColor) {
+        if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
     }
-    return NULL;
 }
 
-void ecs_atfini(
-    ecs_world_t *world,
-    ecs_fini_action_t action,
-    void *ctx)
+void ecs_printv_(
+    int level,
+    const char *file,
+    int32_t line,
+    const char *fmt,
+    va_list args)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(action != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_action_elem_t *elem = ecs_vec_append_t(NULL, &world->fini_actions,
-        ecs_action_elem_t);
-    ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL);
+    (void)level;
+    (void)line;
 
-    elem->action = action;
-    elem->ctx = ctx;
-error:
-    return;
-}
+    ecs_strbuf_t msg_buf = ECS_STRBUF_INIT;
 
-void ecs_run_post_frame(
-    ecs_world_t *world,
-    ecs_fini_action_t action,
-    void *ctx)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(action != NULL, ECS_INVALID_PARAMETER, NULL);
+    /* Apply color. Even if we don't want color, we still need to call the
+     * colorize function to get rid of the color tags (e.g. #[green]) */
+    char *msg_nocolor = flecs_vasprintf(fmt, args);
+    flecs_colorize_buf(msg_nocolor, 
+        ecs_os_api.flags_ & EcsOsApiLogWithColors, &msg_buf);
+    ecs_os_free(msg_nocolor);
 
-    ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_action_elem_t *elem = ecs_vec_append_t(&stage->allocator,
-        &stage->post_frame_actions, ecs_action_elem_t);
-    ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL);
+    char *msg = ecs_strbuf_get(&msg_buf);
 
-    elem->action = action;
-    elem->ctx = ctx;
-error:
-    return;
+    if (msg) {
+        ecs_os_api.log_(level, file, line, msg);
+        ecs_os_free(msg);
+    } else {
+        ecs_os_api.log_(level, file, line, "");
+    }
 }
 
-/* Unset data in tables */
-static
-void flecs_fini_unset_tables(
-    ecs_world_t *world)
+void ecs_print_(
+    int level,
+    const char *file,
+    int32_t line,
+    const char *fmt,
+    ...)
 {
-    ecs_sparse_t *tables = &world->store.tables;
-    int32_t i, count = flecs_sparse_count(tables);
+    va_list args;
+    va_start(args, fmt);
+    ecs_printv_(level, file, line, fmt, args);
+    va_end(args);    
+}
 
-    for (i = 0; i < count; i ++) {
-        ecs_table_t *table = flecs_sparse_get_dense_t(tables, ecs_table_t, i);
-        flecs_table_remove_actions(world, table);
+void ecs_logv_(
+    int level,
+    const char *file,
+    int32_t line,
+    const char *fmt,
+    va_list args)
+{
+    if (level > ecs_os_api.log_level_) {
+        return;
     }
+
+    ecs_printv_(level, file, line, fmt, args);
 }
 
-/* Invoke fini actions */
-static
-void flecs_fini_actions(
-    ecs_world_t *world)
+void ecs_log_(
+    int level,
+    const char *file,
+    int32_t line,
+    const char *fmt,
+    ...)
 {
-    int32_t i, count = ecs_vec_count(&world->fini_actions);
-    ecs_action_elem_t *elems = ecs_vec_first(&world->fini_actions);
-    for (i = 0; i < count; i ++) {
-        elems[i].action(world, elems[i].ctx);
+    if (level > ecs_os_api.log_level_) {
+        return;
     }
 
-    ecs_vec_fini_t(NULL, &world->fini_actions, ecs_action_elem_t);
+    va_list args;
+    va_start(args, fmt);
+    ecs_printv_(level, file, line, fmt, args);
+    va_end(args);    
 }
 
-/* Cleanup remaining type info elements */
-static
-void flecs_fini_type_info(
-    ecs_world_t *world)
+
+void ecs_log_push_(
+    int32_t level) 
 {
-    int32_t i, count = flecs_sparse_count(&world->type_info);
-    ecs_sparse_t *type_info = &world->type_info;
-    for (i = 0; i < count; i ++) {
-        ecs_type_info_t *ti = flecs_sparse_get_dense_t(type_info,
-            ecs_type_info_t, i);
-        flecs_type_info_fini(ti);
+    if (level <= ecs_os_api.log_level_) {
+        ecs_os_api.log_indent_ ++;
     }
-    flecs_sparse_fini(&world->type_info);
 }
 
-ecs_entity_t flecs_get_oneof(
-    const ecs_world_t *world,
-    ecs_entity_t e)
+void ecs_log_pop_(
+    int32_t level)
 {
-    if (ecs_is_alive(world, e)) {
-        if (ecs_has_id(world, e, EcsOneOf)) {
-            return e;
-        } else {
-            return ecs_get_target(world, e, EcsOneOf, 0);
-        }
-    } else {
-        return 0;
+    if (level <= ecs_os_api.log_level_) {
+        ecs_os_api.log_indent_ --;
+        ecs_assert(ecs_os_api.log_indent_ >= 0, ECS_INTERNAL_ERROR, NULL);
     }
 }
 
-/* The destroyer of worlds */
-int ecs_fini(
-    ecs_world_t *world)
+void ecs_parser_errorv_(
+    const char *name,
+    const char *expr, 
+    int64_t column_arg,
+    const char *fmt,
+    va_list args)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
-    ecs_assert(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, NULL);
-    ecs_assert(world->stages[0].defer == 0, ECS_INVALID_OPERATION,
-        "call defer_end before destroying world");
-
-    ecs_trace("#[bold]shutting down world");
-    ecs_log_push();
+    if (column_arg > 65536) {
+        /* Limit column size, which prevents the code from throwing up when the
+         * function is called with (expr - ptr), and expr is NULL. */
+        column_arg = 0;
+    }
+    
+    int32_t column = flecs_itoi32(column_arg);
 
-    world->flags |= EcsWorldQuit;
+    if (ecs_os_api.log_level_ >= -2) {
+        ecs_strbuf_t msg_buf = ECS_STRBUF_INIT;
 
-    /* Delete root entities first using regular APIs. This ensures that cleanup
-     * policies get a chance to execute. */
-    ecs_dbg_1("#[bold]cleanup root entities");
-    ecs_log_push_1();
-    flecs_fini_roots(world);
-    ecs_log_pop_1();
+        /* Count number of newlines up until column_arg */
+        int32_t i, line = 1;
+        if (expr) {
+            for (i = 0; i < column; i ++) {
+                if (expr[i] == '\n') {
+                    line ++;
+                }
+            }
+            
+            ecs_strbuf_append(&msg_buf, "%d: ", line);
+        }
 
-    world->flags |= EcsWorldFini;
+        ecs_strbuf_vappend(&msg_buf, fmt, args);
 
-    /* Run fini actions (simple callbacks ran when world is deleted) before
-     * destroying the storage */
-    ecs_dbg_1("#[bold]run fini actions");
-    ecs_log_push_1();
-    flecs_fini_actions(world);
-    ecs_log_pop_1();
+        if (expr) {
+            ecs_strbuf_appendch(&msg_buf, '\n');
 
-    ecs_dbg_1("#[bold]cleanup remaining entities");
-    ecs_log_push_1();
+            /* Find start of line by taking column and looking for the
+             * last occurring newline */
+            if (column != -1) {
+                const char *ptr = &expr[column];
+                if (ptr[0] == '\n') {
+                    ptr --;
+                }
 
-    /* Operations invoked during UnSet/OnRemove/destructors are deferred and
-     * will be discarded after world cleanup */
-    flecs_defer_begin(world, &world->stages[0]);
+                while (ptr[0] != '\n' && ptr > expr) {
+                    ptr --;
+                }
+                
+                if (ptr[0] == '\n') {
+                    ptr ++;
+                }
 
-    /* Run UnSet/OnRemove actions for components while the store is still
-     * unmodified by cleanup. */
-    flecs_fini_unset_tables(world);
+                if (ptr == expr) {
+                    /* ptr is already at start of line */
+                } else {
+                    column -= (int32_t)(ptr - expr);
+                    expr = ptr;
+                }
+            }
 
-    /* This will destroy all entities and components. */
-    flecs_fini_store(world);
+            /* Strip newlines from current statement, if any */            
+            char *newline_ptr = strchr(expr, '\n');
+            if (newline_ptr) {
+                /* Strip newline from expr */
+                ecs_strbuf_appendstrn(&msg_buf, expr, 
+                    (int32_t)(newline_ptr - expr));
+            } else {
+                ecs_strbuf_appendstr(&msg_buf, expr);
+            }
 
-    /* Purge deferred operations from the queue. This discards operations but
-     * makes sure that any resources in the queue are freed */
-    flecs_defer_purge(world, &world->stages[0]);
-    ecs_log_pop_1();
+            ecs_strbuf_appendch(&msg_buf, '\n');
 
-    /* All queries are cleaned up, so monitors should've been cleaned up too */
-    ecs_assert(!ecs_map_is_init(&world->monitors.monitors),
-        ECS_INTERNAL_ERROR, NULL);
+            if (column != -1) {
+                int32_t c;
+                for (c = 0; c < column; c ++) {
+                    ecs_strbuf_appendch(&msg_buf, ' ');
+                }
+                ecs_strbuf_appendch(&msg_buf, '^');
+            }
+        }
 
-    /* Cleanup world ctx and binding_ctx */
-    if (world->ctx_free) {
-        world->ctx_free(world->ctx);
-    }
-    if (world->binding_ctx_free) {
-        world->binding_ctx_free(world->binding_ctx);
+        char *msg = ecs_strbuf_get(&msg_buf);
+        ecs_os_err(name, 0, msg);
+        ecs_os_free(msg);
     }
-
-    /* After this point no more user code is invoked */
-
-    ecs_dbg_1("#[bold]cleanup world data structures");
-    ecs_log_push_1();
-    flecs_entities_fini(world);
-    flecs_sparse_fini(world->pending_tables);
-    flecs_sparse_fini(world->pending_buffer);
-    ecs_os_free(world->pending_tables);
-    ecs_os_free(world->pending_buffer);
-    flecs_fini_id_records(world);
-    flecs_fini_type_info(world);
-    flecs_observable_fini(&world->observable);
-    flecs_name_index_fini(&world->aliases);
-    flecs_name_index_fini(&world->symbols);
-    ecs_set_stage_count(world, 0);
-    ecs_log_pop_1();
-
-    flecs_world_allocators_fini(world);
-
-    /* End of the world */
-    ecs_poly_free(world, ecs_world_t);
-    ecs_os_fini();
-
-    ecs_trace("world destroyed, bye!");
-    ecs_log_pop();
-
-    return 0;
 }
 
-bool ecs_is_fini(
-    const ecs_world_t *world)
+void ecs_parser_error_(
+    const char *name,
+    const char *expr, 
+    int64_t column,
+    const char *fmt,
+    ...)
 {
-    ecs_assert(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    world = ecs_get_world(world);
-    return ECS_BIT_IS_SET(world->flags, EcsWorldFini);
+    if (ecs_os_api.log_level_  >= -2) {
+        va_list args;
+        va_start(args, fmt);
+        ecs_parser_errorv_(name, expr, column, fmt, args);
+        va_end(args);
+    }
 }
 
-void ecs_dim(
-    ecs_world_t *world,
-    int32_t entity_count)
+void ecs_abort_(
+    int32_t err,
+    const char *file,
+    int32_t line,
+    const char *fmt,
+    ...)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    flecs_entities_set_size(world, entity_count + FLECS_HI_COMPONENT_ID);
+    if (fmt) {
+        va_list args;
+        va_start(args, fmt);
+        char *msg = flecs_vasprintf(fmt, args);
+        va_end(args);
+        ecs_fatal_(file, line, "%s (%s)", msg, ecs_strerror(err));
+        ecs_os_free(msg);
+    } else {
+        ecs_fatal_(file, line, "%s", ecs_strerror(err));
+    }
+    ecs_os_api.log_last_error_ = err;
 }
 
-void flecs_eval_component_monitors(
-    ecs_world_t *world)
+void ecs_assert_log_(
+    int32_t err,
+    const char *cond_str,
+    const char *file,
+    int32_t line,
+    const char *fmt,
+    ...)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    flecs_process_pending_tables(world);
-    flecs_eval_component_monitor(world);
+    if (fmt) {
+        va_list args;
+        va_start(args, fmt);
+        char *msg = flecs_vasprintf(fmt, args);
+        va_end(args);
+        ecs_fatal_(file, line, "assert: %s %s (%s)",
+            cond_str, msg, ecs_strerror(err));
+        ecs_os_free(msg);
+    } else {
+        ecs_fatal_(file, line, "assert: %s %s",
+            cond_str, ecs_strerror(err));
+    }
+    ecs_os_api.log_last_error_ = err;
 }
 
-void ecs_measure_frame_time(
-    ecs_world_t *world,
-    bool enable)
+void ecs_deprecated_(
+    const char *file,
+    int32_t line,
+    const char *msg)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL);
+    ecs_err_(file, line, "%s", msg);
+}
 
-    if (ECS_EQZERO(world->info.target_fps) || enable) {
-        ECS_BIT_COND(world->flags, EcsWorldMeasureFrameTime, enable);
+bool ecs_should_log(int32_t level) {
+#   if !defined(FLECS_LOG_3)
+    if (level == 3) {
+        return false;
     }
-error:
-    return;
-}
+#   endif
+#   if !defined(FLECS_LOG_2)
+    if (level == 2) {
+        return false;
+    }
+#   endif
+#   if !defined(FLECS_LOG_1)
+    if (level == 1) {
+        return false;
+    }
+#   endif
 
-void ecs_measure_system_time(
-    ecs_world_t *world,
-    bool enable)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL);
-    ECS_BIT_COND(world->flags, EcsWorldMeasureSystemTime, enable);
-error:
-    return;
+    return level <= ecs_os_api.log_level_;
 }
 
-void ecs_set_target_fps(
-    ecs_world_t *world,
-    ecs_ftime_t fps)
+#define ECS_ERR_STR(code) case code: return &(#code[4])
+
+const char* ecs_strerror(
+    int32_t error_code)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL);
+    switch (error_code) {
+    ECS_ERR_STR(ECS_INVALID_PARAMETER);
+    ECS_ERR_STR(ECS_NOT_A_COMPONENT);
+    ECS_ERR_STR(ECS_INTERNAL_ERROR);
+    ECS_ERR_STR(ECS_ALREADY_DEFINED);
+    ECS_ERR_STR(ECS_INVALID_COMPONENT_SIZE);
+    ECS_ERR_STR(ECS_INVALID_COMPONENT_ALIGNMENT);
+    ECS_ERR_STR(ECS_NAME_IN_USE);
+    ECS_ERR_STR(ECS_OUT_OF_MEMORY);
+    ECS_ERR_STR(ECS_DOUBLE_FREE);
+    ECS_ERR_STR(ECS_OPERATION_FAILED);
+    ECS_ERR_STR(ECS_INVALID_CONVERSION);
+    ECS_ERR_STR(ECS_MODULE_UNDEFINED);
+    ECS_ERR_STR(ECS_MISSING_SYMBOL);
+    ECS_ERR_STR(ECS_ALREADY_IN_USE);
+    ECS_ERR_STR(ECS_CYCLE_DETECTED);
+    ECS_ERR_STR(ECS_LEAK_DETECTED);
+    ECS_ERR_STR(ECS_COLUMN_INDEX_OUT_OF_RANGE);
+    ECS_ERR_STR(ECS_COLUMN_IS_NOT_SHARED);
+    ECS_ERR_STR(ECS_COLUMN_IS_SHARED);
+    ECS_ERR_STR(ECS_COLUMN_TYPE_MISMATCH);
+    ECS_ERR_STR(ECS_INVALID_WHILE_READONLY);
+    ECS_ERR_STR(ECS_INVALID_FROM_WORKER);
+    ECS_ERR_STR(ECS_OUT_OF_RANGE);
+    ECS_ERR_STR(ECS_MISSING_OS_API);
+    ECS_ERR_STR(ECS_UNSUPPORTED);
+    ECS_ERR_STR(ECS_ACCESS_VIOLATION);
+    ECS_ERR_STR(ECS_COMPONENT_NOT_REGISTERED);
+    ECS_ERR_STR(ECS_INCONSISTENT_COMPONENT_ID);
+    ECS_ERR_STR(ECS_INCONSISTENT_NAME);
+    ECS_ERR_STR(ECS_INCONSISTENT_COMPONENT_ACTION);
+    ECS_ERR_STR(ECS_INVALID_OPERATION);
+    ECS_ERR_STR(ECS_CONSTRAINT_VIOLATED);
+    ECS_ERR_STR(ECS_LOCKED_STORAGE);
+    ECS_ERR_STR(ECS_ID_IN_USE);
+    }
 
-    ecs_measure_frame_time(world, true);
-    world->info.target_fps = fps;
-error:
-    return;
+    return "unknown error code";
 }
 
-void* ecs_get_ctx(
-    const ecs_world_t *world)
+#else
+
+/* Empty bodies for when logging is disabled */
+
+void ecs_log_(
+    int32_t level,
+    const char *file,
+    int32_t line,
+    const char *fmt,
+    ...)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    world = ecs_get_world(world);
-    return world->ctx;
-error:
-    return NULL;
+    (void)level;
+    (void)file;
+    (void)line;
+    (void)fmt;
 }
 
-void* ecs_get_binding_ctx(
-    const ecs_world_t *world)
+void ecs_parser_error_(
+    const char *name,
+    const char *expr, 
+    int64_t column,
+    const char *fmt,
+    ...)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    world = ecs_get_world(world);
-    return world->binding_ctx;
-error:
-    return NULL;
+    (void)name;
+    (void)expr;
+    (void)column;
+    (void)fmt;
 }
 
-void ecs_set_ctx(
-    ecs_world_t *world,
-    void *ctx,
-    ecs_ctx_free_t ctx_free)
+void ecs_parser_errorv_(
+    const char *name,
+    const char *expr, 
+    int64_t column,
+    const char *fmt,
+    va_list args)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    world->ctx = ctx;
-    world->ctx_free = ctx_free;
+    (void)name;
+    (void)expr;
+    (void)column;
+    (void)fmt;
+    (void)args;
 }
 
-void ecs_set_binding_ctx(
-    ecs_world_t *world,
-    void *ctx,
-    ecs_ctx_free_t ctx_free)
+void ecs_abort_(
+    int32_t error_code,
+    const char *file,
+    int32_t line,
+    const char *fmt,
+    ...)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    world->binding_ctx = ctx;
-    world->binding_ctx_free = ctx_free;
+    (void)error_code;
+    (void)file;
+    (void)line;
+    (void)fmt;
 }
 
-void ecs_set_entity_range(
-    ecs_world_t *world,
-    ecs_entity_t id_start,
-    ecs_entity_t id_end)
+void ecs_assert_log_(
+    int32_t error_code,
+    const char *condition_str,
+    const char *file,
+    int32_t line,
+    const char *fmt,
+    ...)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(!id_end || id_end > id_start, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!id_end || id_end > flecs_entities_max_id(world),
-        ECS_INVALID_PARAMETER, NULL);
-
-    uint32_t start = (uint32_t)id_start;
-    uint32_t end = (uint32_t)id_end;
+    (void)error_code;
+    (void)condition_str;
+    (void)file;
+    (void)line;
+    (void)fmt;
+}
 
-    if (flecs_entities_max_id(world) < start) {
-        flecs_entities_max_id(world) = start - 1;
-    }
+#endif
 
-    world->info.min_id = start;
-    world->info.max_id = end;
-error:
-    return;
+int ecs_log_get_level(void) {
+    return ecs_os_api.log_level_;
 }
 
-bool ecs_enable_range_check(
-    ecs_world_t *world,
-    bool enable)
+int ecs_log_set_level(
+    int level)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    bool old_value = world->range_check_enabled;
-    world->range_check_enabled = enable;
-    return old_value;
+    int prev = level;
+    ecs_os_api.log_level_ = level;
+    return prev;
 }
 
-ecs_entity_t ecs_get_max_id(
-    const ecs_world_t *world)
+bool ecs_log_enable_colors(
+    bool enabled)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    world = ecs_get_world(world);
-    return flecs_entities_max_id(world);
-error:
-    return 0;
+    bool prev = ecs_os_api.flags_ & EcsOsApiLogWithColors;
+    ECS_BIT_COND(ecs_os_api.flags_, EcsOsApiLogWithColors, enabled);
+    return prev;
 }
 
-void ecs_set_entity_generation(
-    ecs_world_t *world,
-    ecs_entity_t entity_with_generation)
+bool ecs_log_enable_timestamp(
+    bool enabled)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
-    ecs_assert(!(ecs_is_deferred(world)), ECS_INVALID_OPERATION, NULL);
-
-    flecs_entities_make_alive(world, entity_with_generation);
-
-    ecs_record_t *r = flecs_entities_get(world, entity_with_generation);
-    if (r && r->table) {
-        int32_t row = ECS_RECORD_TO_ROW(r->row);
-        ecs_entity_t *entities = r->table->data.entities.array;
-        entities[row] = entity_with_generation;
-    }
+    bool prev = ecs_os_api.flags_ & EcsOsApiLogWithTimeStamp;
+    ECS_BIT_COND(ecs_os_api.flags_, EcsOsApiLogWithTimeStamp, enabled);
+    return prev;
 }
 
-const ecs_type_info_t* flecs_type_info_get(
-    const ecs_world_t *world,
-    ecs_entity_t component)
+bool ecs_log_enable_timedelta(
+    bool enabled)
 {
-    ecs_poly_assert(world, ecs_world_t);
-
-    ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!(component & ECS_ID_FLAGS_MASK), ECS_INTERNAL_ERROR, NULL);
-
-    return flecs_sparse_try_t(&world->type_info, ecs_type_info_t, component);
+    bool prev = ecs_os_api.flags_ & EcsOsApiLogWithTimeDelta;
+    ECS_BIT_COND(ecs_os_api.flags_, EcsOsApiLogWithTimeDelta, enabled);
+    return prev;
 }
 
-ecs_type_info_t* flecs_type_info_ensure(
-    ecs_world_t *world,
-    ecs_entity_t component)
+int ecs_log_last_error(void)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL);
+    int result = ecs_os_api.log_last_error_;
+    ecs_os_api.log_last_error_ = 0;
+    return result;
+}
 
-    const ecs_type_info_t *ti = flecs_type_info_get(world, component);
-    ecs_type_info_t *ti_mut = NULL;
-    if (!ti) {
-        ti_mut = flecs_sparse_ensure_t(
-            &world->type_info, ecs_type_info_t, component);
-        ecs_assert(ti_mut != NULL, ECS_INTERNAL_ERROR, NULL);
-        ti_mut->component = component;
-    } else {
-        ti_mut = ECS_CONST_CAST(ecs_type_info_t*, ti);
-    }
+/**
+ * @file addons/metrics.c
+ * @brief Metrics addon.
+ */
 
-    if (!ti_mut->name) {
-        const char *sym = ecs_get_symbol(world, component);
-        if (sym) {
-            ti_mut->name = ecs_os_strdup(sym);
-        } else {
-            const char *name = ecs_get_name(world, component);
-            if (name) {
-                ti_mut->name = ecs_os_strdup(name);
-            }
-        }
-    }
 
-    return ti_mut;
-}
+#ifdef FLECS_METRICS
 
-bool flecs_type_info_init_id(
-    ecs_world_t *world,
-    ecs_entity_t component,
-    ecs_size_t size,
-    ecs_size_t alignment,
-    const ecs_type_hooks_t *li)
-{
-    bool changed = false;
+/* Public components */
+ECS_COMPONENT_DECLARE(FlecsMetrics);
+ECS_TAG_DECLARE(EcsMetricInstance);
+ECS_COMPONENT_DECLARE(EcsMetricValue);
+ECS_COMPONENT_DECLARE(EcsMetricSource);
+ECS_TAG_DECLARE(EcsMetric);
+ECS_TAG_DECLARE(EcsCounter);
+ECS_TAG_DECLARE(EcsCounterIncrement);
+ECS_TAG_DECLARE(EcsCounterId);
+ECS_TAG_DECLARE(EcsGauge);
 
-    flecs_entities_ensure(world, component);
+/* Internal components */
+static ECS_COMPONENT_DECLARE(EcsMetricMember);
+static ECS_COMPONENT_DECLARE(EcsMetricId);
+static ECS_COMPONENT_DECLARE(EcsMetricOneOf);
+static ECS_COMPONENT_DECLARE(EcsMetricCountIds);
+static ECS_COMPONENT_DECLARE(EcsMetricCountTargets);
+static ECS_COMPONENT_DECLARE(EcsMetricMemberInstance);
+static ECS_COMPONENT_DECLARE(EcsMetricIdInstance);
+static ECS_COMPONENT_DECLARE(EcsMetricOneOfInstance);
 
-    ecs_type_info_t *ti = NULL;
-    if (!size || !alignment) {
-        ecs_assert(size == 0 && alignment == 0,
-            ECS_INVALID_COMPONENT_SIZE, NULL);
-        ecs_assert(li == NULL, ECS_INCONSISTENT_COMPONENT_ACTION, NULL);
-        flecs_sparse_remove_t(&world->type_info, ecs_type_info_t, component);
-    } else {
-        ti = flecs_type_info_ensure(world, component);
-        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
-        changed |= ti->size != size;
-        changed |= ti->alignment != alignment;
-        ti->size = size;
-        ti->alignment = alignment;
-        if (li) {
-            ecs_set_hooks_id(world, component, li);
-        }
-    }
+/** Context for metric */
+typedef struct {
+    ecs_entity_t metric;              /**< Metric entity */
+    ecs_entity_t kind;                /**< Metric kind (gauge, counter) */
+} ecs_metric_ctx_t;
 
-    /* Set type info for id record of component */
-    ecs_id_record_t *idr = flecs_id_record_ensure(world, component);
-    changed |= flecs_id_record_set_type_info(world, idr, ti);
-    bool is_tag = idr->flags & EcsIdTag;
+/** Context for metric that monitors member */
+typedef struct {
+    ecs_metric_ctx_t metric;
+    ecs_primitive_kind_t type_kind;  /**< Primitive type kind of member */
+    uint16_t offset;                 /**< Offset of member in component */
+} ecs_member_metric_ctx_t;
 
-    /* All id records with component as relationship inherit type info */
-    idr = flecs_id_record_ensure(world, ecs_pair(component, EcsWildcard));
-    do {
-        if (is_tag) {
-            changed |= flecs_id_record_set_type_info(world, idr, NULL);
-        } else if (ti) {
-            changed |= flecs_id_record_set_type_info(world, idr, ti);
-        } else if ((idr->type_info != NULL) &&
-            (idr->type_info->component == component))
-        {
-            changed |= flecs_id_record_set_type_info(world, idr, NULL);
-        }
-    } while ((idr = idr->first.next));
+/** Context for metric that monitors whether entity has id */
+typedef struct {
+    ecs_metric_ctx_t metric;
+    ecs_id_record_t *idr;            /**< Id record for monitored component */
+} ecs_id_metric_ctx_t;
 
-    /* All non-tag id records with component as object inherit type info,
-     * if relationship doesn't have type info */
-    idr = flecs_id_record_ensure(world, ecs_pair(EcsWildcard, component));
-    do {
-        if (!(idr->flags & EcsIdTag) && !idr->type_info) {
-            changed |= flecs_id_record_set_type_info(world, idr, ti);
-        }
-    } while ((idr = idr->first.next));
+/** Context for metric that monitors whether entity has pair target */
+typedef struct {
+    ecs_metric_ctx_t metric;
+    ecs_id_record_t *idr;            /**< Id record for monitored component */
+    ecs_size_t size;                 /**< Size of metric type */
+    ecs_map_t target_offset;         /**< Pair target to metric type offset */
+} ecs_oneof_metric_ctx_t;
 
-    /* Type info of (*, component) should always point to component */
-    ecs_assert(flecs_id_record_get(world, ecs_pair(EcsWildcard, component))->
-        type_info == ti, ECS_INTERNAL_ERROR, NULL);
+/** Context for metric that monitors how many entities have a pair target */
+typedef struct {
+    ecs_metric_ctx_t metric;
+    ecs_id_record_t *idr;            /**< Id record for monitored component */
+    ecs_map_t targets;               /**< Map of counters for each target */
+} ecs_count_targets_metric_ctx_t;
 
-    return changed;
-}
+/** Stores context shared for all instances of member metric */
+typedef struct {
+    ecs_member_metric_ctx_t *ctx;
+} EcsMetricMember;
 
-void flecs_type_info_fini(
-    ecs_type_info_t *ti)
-{
-    if (ti->hooks.ctx_free) {
-        ti->hooks.ctx_free(ti->hooks.ctx);
-    }
-    if (ti->hooks.binding_ctx_free) {
-        ti->hooks.binding_ctx_free(ti->hooks.binding_ctx);
-    }
-    if (ti->name) {
-        /* Safe to cast away const, world has ownership over string */
-        ecs_os_free(ECS_CONST_CAST(char*, ti->name));
-        ti->name = NULL;
-    }
-}
+/** Stores context shared for all instances of id metric */
+typedef struct {
+    ecs_id_metric_ctx_t *ctx;
+} EcsMetricId;
 
-void flecs_type_info_free(
-    ecs_world_t *world,
-    ecs_entity_t component)
-{
-    if (world->flags & EcsWorldQuit) {
-        /* If world is in the final teardown stages, cleanup policies are no
-         * longer applied and it can't be guaranteed that a component is not
-         * deleted before entities that use it. The remaining type info elements
-         * will be deleted after the store is finalized. */
-        return;
-    }
+/** Stores context shared for all instances of oneof metric */
+typedef struct {
+    ecs_oneof_metric_ctx_t *ctx;
+} EcsMetricOneOf;
 
-    ecs_type_info_t *ti = flecs_sparse_try_t(&world->type_info,
-        ecs_type_info_t, component);
-    if (ti) {
-        flecs_type_info_fini(ti);
-        flecs_sparse_remove_t(&world->type_info, ecs_type_info_t, component);
-    }
-}
+/** Stores context shared for all instances of id counter metric */
+typedef struct {
+    ecs_id_t id;
+} EcsMetricCountIds;
 
-static
-ecs_ftime_t flecs_insert_sleep(
-    ecs_world_t *world,
-    ecs_time_t *stop)
-{
-    ecs_poly_assert(world, ecs_world_t);
+/** Stores context shared for all instances of target counter metric */
+typedef struct {
+    ecs_count_targets_metric_ctx_t *ctx;
+} EcsMetricCountTargets;
 
-    ecs_time_t start = *stop, now = start;
-    ecs_ftime_t delta_time = (ecs_ftime_t)ecs_time_measure(stop);
+/** Instance of member metric */
+typedef struct {
+    ecs_ref_t ref;
+    ecs_member_metric_ctx_t *ctx;
+} EcsMetricMemberInstance;
 
-    if (ECS_EQZERO(world->info.target_fps)) {
-        return delta_time;
-    }
+/** Instance of id metric */
+typedef struct {
+    ecs_record_t *r;
+    ecs_id_metric_ctx_t *ctx;
+} EcsMetricIdInstance;
 
-    ecs_ftime_t target_delta_time =
-        ((ecs_ftime_t)1.0 / (ecs_ftime_t)world->info.target_fps);
+/** Instance of oneof metric */
+typedef struct {
+    ecs_record_t *r;
+    ecs_oneof_metric_ctx_t *ctx;
+} EcsMetricOneOfInstance;
 
-    /* Calculate the time we need to sleep by taking the measured delta from the
-     * previous frame, and subtracting it from target_delta_time. */
-    ecs_ftime_t sleep = target_delta_time - delta_time;
+/** Component lifecycle */
 
-    /* Pick a sleep interval that is 4 times smaller than the time one frame
-     * should take. */
-    ecs_ftime_t sleep_time = sleep / (ecs_ftime_t)4.0;
+static ECS_DTOR(EcsMetricMember, ptr, {
+    ecs_os_free(ptr->ctx);
+})
 
-    do {
-        /* Only call sleep when sleep_time is not 0. On some platforms, even
-         * a sleep with a timeout of 0 can cause stutter. */
-        if (ECS_NEQZERO(sleep_time)) {
-            ecs_sleepf((double)sleep_time);
-        }
+static ECS_MOVE(EcsMetricMember, dst, src, {
+    *dst = *src;
+    src->ctx = NULL;
+})
 
-        now = start;
-        delta_time = (ecs_ftime_t)ecs_time_measure(&now);
-    } while ((target_delta_time - delta_time) >
-        (sleep_time / (ecs_ftime_t)2.0));
+static ECS_DTOR(EcsMetricId, ptr, {
+    ecs_os_free(ptr->ctx);
+})
 
-    *stop = now;
-    return delta_time;
-}
+static ECS_MOVE(EcsMetricId, dst, src, {
+    *dst = *src;
+    src->ctx = NULL;
+})
 
-static
-ecs_ftime_t flecs_start_measure_frame(
-    ecs_world_t *world,
-    ecs_ftime_t user_delta_time)
-{
-    ecs_poly_assert(world, ecs_world_t);
+static ECS_DTOR(EcsMetricOneOf, ptr, {
+    if (ptr->ctx) {
+        ecs_map_fini(&ptr->ctx->target_offset);
+        ecs_os_free(ptr->ctx);
+    }
+})
 
-    ecs_ftime_t delta_time = 0;
+static ECS_MOVE(EcsMetricOneOf, dst, src, {
+    *dst = *src;
+    src->ctx = NULL;
+})
 
-    if ((world->flags & EcsWorldMeasureFrameTime) ||
-        (ECS_EQZERO(user_delta_time)))
-    {
-        ecs_time_t t = world->frame_start_time;
-        do {
-            if (world->frame_start_time.nanosec || world->frame_start_time.sec){
-                delta_time = flecs_insert_sleep(world, &t);
-            } else {
-                ecs_time_measure(&t);
-                if (ECS_NEQZERO(world->info.target_fps)) {
-                    delta_time = (ecs_ftime_t)1.0 / world->info.target_fps;
-                } else {
-                    /* Best guess */
-                    delta_time = (ecs_ftime_t)1.0 / (ecs_ftime_t)60.0;
+static ECS_DTOR(EcsMetricCountTargets, ptr, {
+    if (ptr->ctx) {
+        ecs_map_fini(&ptr->ctx->targets);
+        ecs_os_free(ptr->ctx);
+    }
+})
 
-                    if (ECS_EQZERO(delta_time)) {
-                        delta_time = user_delta_time;
-                        break;
-                    }
-                }
-            }
+static ECS_MOVE(EcsMetricCountTargets, dst, src, {
+    *dst = *src;
+    src->ctx = NULL;
+})
 
-        /* Keep trying while delta_time is zero */
-        } while (ECS_EQZERO(delta_time));
+/** Observer used for creating new instances of member metric */
+static void flecs_metrics_on_member_metric(ecs_iter_t *it) {
+    ecs_world_t *world = it->world;
+    ecs_member_metric_ctx_t *ctx = it->ctx;
+    ecs_id_t id = ecs_field_id(it, 0);
 
-        world->frame_start_time = t;
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_entity_t e = it->entities[i];
+        ecs_entity_t m = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
 
-        /* Keep track of total time passed in world */
-        world->info.world_time_total_raw += (ecs_ftime_t)delta_time;
+        EcsMetricMemberInstance *src = ecs_emplace(
+            world, m, EcsMetricMemberInstance, NULL);
+        src->ref = ecs_ref_init_id(world, e, id);
+        src->ctx = ctx;
+        ecs_modified(world, m, EcsMetricMemberInstance);
+        ecs_set(world, m, EcsMetricValue, { 0 });
+        ecs_set(world, m, EcsMetricSource, { e });
+        ecs_add(world, m, EcsMetricInstance);
+        ecs_add_pair(world, m, EcsMetric, ctx->metric.kind);
     }
-
-    return (ecs_ftime_t)delta_time;
 }
 
-static
-void flecs_stop_measure_frame(
-    ecs_world_t* world)
-{
-    ecs_poly_assert(world, ecs_world_t);
+/** Observer used for creating new instances of id metric */
+static void flecs_metrics_on_id_metric(ecs_iter_t *it) {
+    ecs_world_t *world = it->world;
+    ecs_id_metric_ctx_t *ctx = it->ctx;
 
-    if (world->flags & EcsWorldMeasureFrameTime) {
-        ecs_time_t t = world->frame_start_time;
-        world->info.frame_time_total += (ecs_ftime_t)ecs_time_measure(&t);
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_entity_t e = it->entities[i];
+        ecs_entity_t m = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
+
+        EcsMetricIdInstance *src = ecs_emplace(
+            world, m, EcsMetricIdInstance, NULL);
+        src->r = ecs_record_find(world, e);
+        src->ctx = ctx;
+        ecs_modified(world, m, EcsMetricIdInstance);
+        ecs_set(world, m, EcsMetricValue, { 0 });
+        ecs_set(world, m, EcsMetricSource, { e });
+        ecs_add(world, m, EcsMetricInstance);
+        ecs_add_pair(world, m, EcsMetric, ctx->metric.kind);
     }
 }
 
-ecs_ftime_t ecs_frame_begin(
-    ecs_world_t *world,
-    ecs_ftime_t user_delta_time)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
-    ecs_check(ECS_NEQZERO(user_delta_time) || ecs_os_has_time(),
-        ECS_MISSING_OS_API, "get_time");
-
-    /* Start measuring total frame time */
-    ecs_ftime_t delta_time = flecs_start_measure_frame(world, user_delta_time);
-    if (ECS_EQZERO(user_delta_time)) {
-        user_delta_time = delta_time;
+/** Observer used for creating new instances of oneof metric */
+static void flecs_metrics_on_oneof_metric(ecs_iter_t *it) {
+    if (it->event == EcsOnRemove) {
+        return;
     }
 
-    world->info.delta_time_raw = user_delta_time;
-    world->info.delta_time = user_delta_time * world->info.time_scale;
-
-    /* Keep track of total scaled time passed in world */
-    world->info.world_time_total += world->info.delta_time;
+    ecs_world_t *world = it->world;
+    ecs_oneof_metric_ctx_t *ctx = it->ctx;
 
-    /* Command buffer capturing */
-    world->on_commands_active = world->on_commands;
-    world->on_commands = NULL;
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_entity_t e = it->entities[i];
+        ecs_entity_t m = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
 
-    world->on_commands_ctx_active = world->on_commands_ctx;
-    world->on_commands_ctx = NULL;
+        EcsMetricOneOfInstance *src = ecs_emplace(
+            world, m, EcsMetricOneOfInstance, NULL);
+        src->r = ecs_record_find(world, e);
+        src->ctx = ctx;
+        ecs_modified(world, m, EcsMetricOneOfInstance);
+        ecs_add_pair(world, m, ctx->metric.metric, ecs_id(EcsMetricValue));
+        ecs_set(world, m, EcsMetricSource, { e });
+        ecs_add(world, m, EcsMetricInstance);
+        ecs_add_pair(world, m, EcsMetric, ctx->metric.kind);
+    }
+}
 
-    ecs_run_aperiodic(world, 0);
+/** Set doc name of metric instance to name of source entity */
+#ifdef FLECS_DOC
+static void SetMetricDocName(ecs_iter_t *it) {
+    ecs_world_t *world = it->world;
+    EcsMetricSource *src = ecs_field(it, EcsMetricSource, 0);
 
-    return world->info.delta_time;
-error:
-    return (ecs_ftime_t)0;
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_entity_t src_e = src[i].entity;
+        const char *name = ecs_get_name(world, src_e);
+        if (name) {
+            ecs_doc_set_name(world, it->entities[i], name);
+        }
+    }
 }
+#endif
 
-void ecs_frame_end(
-    ecs_world_t *world)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
-
-    world->info.frame_count_total ++;
+/** Delete metric instances for entities that are no longer alive */
+static void ClearMetricInstance(ecs_iter_t *it) {
+    ecs_world_t *world = it->world;
+    EcsMetricSource *src = ecs_field(it, EcsMetricSource, 0);
 
-    ecs_stage_t *stages = world->stages;
-    int32_t i, count = world->stage_count;
+    int32_t i, count = it->count;
     for (i = 0; i < count; i ++) {
-        flecs_stage_merge_post_frame(world, &stages[i]);
+        ecs_entity_t src_e = src[i].entity;
+        if (!ecs_is_alive(world, src_e)) {
+            ecs_delete(world, it->entities[i]);
+        }
     }
+}
 
-    flecs_stop_measure_frame(world);
+/** Update member metric */
+static void UpdateMemberInstance(ecs_iter_t *it, bool counter) {
+    ecs_world_t *world = it->real_world;
+    EcsMetricValue *m = ecs_field(it, EcsMetricValue, 0);
+    EcsMetricMemberInstance *mi = ecs_field(it, EcsMetricMemberInstance, 1);
+    ecs_ftime_t dt = it->delta_time;
 
-    /* Reset command handler each frame */
-    world->on_commands_active = NULL;
-    world->on_commands_ctx_active = NULL;
-error:
-    return;
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_member_metric_ctx_t *ctx = mi[i].ctx;
+        ecs_ref_t *ref = &mi[i].ref;
+        if (!ref->entity) {
+            continue;
+        }
+
+        const void *ptr = ecs_ref_get_id(world, ref, ref->id);
+        if (ptr) {
+            ptr = ECS_OFFSET(ptr, ctx->offset);
+            if (!counter) {
+                m[i].value = ecs_meta_ptr_to_float(ctx->type_kind, ptr);
+            } else {
+                m[i].value += 
+                    ecs_meta_ptr_to_float(ctx->type_kind, ptr) * (double)dt;
+            }
+        } else {
+            ecs_delete(it->world, it->entities[i]);
+        }
+    }
 }
 
-void flecs_delete_table(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    flecs_table_free(world, table);
+static void UpdateGaugeMemberInstance(ecs_iter_t *it) {
+    UpdateMemberInstance(it, false);
 }
 
-static
-void flecs_process_empty_queries(
-    ecs_world_t *world)
-{
-    ecs_poly_assert(world, ecs_world_t);
+static void UpdateCounterMemberInstance(ecs_iter_t *it) {
+    UpdateMemberInstance(it, false);
+}
 
-    ecs_id_record_t *idr = flecs_id_record_get(world,
-        ecs_pair(ecs_id(EcsPoly), EcsQuery));
-    if (!idr) {
-        return;
-    }
+static void UpdateCounterIncrementMemberInstance(ecs_iter_t *it) {
+    UpdateMemberInstance(it, true);
+}
 
-    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
+/** Update id metric */
+static void UpdateIdInstance(ecs_iter_t *it, bool counter) {
+    ecs_world_t *world = it->real_world;
+    EcsMetricValue *m = ecs_field(it, EcsMetricValue, 0);
+    EcsMetricIdInstance *mi = ecs_field(it, EcsMetricIdInstance, 1);
+    ecs_ftime_t dt = it->delta_time;
 
-    /* Make sure that we defer adding the inactive tags until after iterating
-     * the query */
-    flecs_defer_begin(world, &world->stages[0]);
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_record_t *r = mi[i].r;
+        if (!r) {
+            continue;
+        }
 
-    ecs_table_cache_iter_t it;
-    const ecs_table_record_t *tr;
-    if (flecs_table_cache_iter(&idr->cache, &it)) {
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            ecs_table_t *table = tr->hdr.table;
-            EcsPoly *queries = ecs_table_get_column(table, tr->column, 0);
-            int32_t i, count = ecs_table_count(table);
+        ecs_table_t *table = r->table;
+        if (!table) {
+            ecs_delete(it->world, it->entities[i]);
+            continue;
+        }
 
-            for (i = 0; i < count; i ++) {
-                ecs_query_t *query = queries[i].poly;
-                ecs_entity_t *entities = table->data.entities.array;
-                if (!ecs_query_table_count(query)) {
-                    ecs_add_id(world, entities[i], EcsEmpty);
-                }
+        ecs_id_metric_ctx_t *ctx = mi[i].ctx;
+        ecs_id_record_t *idr = ctx->idr;
+        if (flecs_search_w_idr(world, table, NULL, idr) != -1) {
+            if (!counter) {
+                m[i].value = 1.0;
+            } else {
+                m[i].value += 1.0 * (double)dt;
             }
+        } else {
+            ecs_delete(it->world, it->entities[i]);
         }
     }
+}
 
-    flecs_defer_end(world, &world->stages[0]);
+static void UpdateGaugeIdInstance(ecs_iter_t *it) {
+    UpdateIdInstance(it, false);
 }
 
-/** Walk over tables that had a state change which requires bookkeeping */
-void flecs_process_pending_tables(
-    const ecs_world_t *world_r)
-{
-    ecs_poly_assert(world_r, ecs_world_t);
+static void UpdateCounterIdInstance(ecs_iter_t *it) {
+    UpdateIdInstance(it, true);
+}
 
-    /* We can't update the administration while in readonly mode, but we can
-     * ensure that when this function is called there are no pending events. */
-    if (world_r->flags & EcsWorldReadonly) {
-        ecs_assert(flecs_sparse_count(world_r->pending_tables) == 0,
-            ECS_INTERNAL_ERROR, NULL);
-        return;
-    }
+/** Update oneof metric */
+static void UpdateOneOfInstance(ecs_iter_t *it, bool counter) {
+    ecs_world_t *world = it->real_world;
+    ecs_table_t *table = it->table;
+    void *m = ecs_table_get_column(table, 
+        ecs_table_type_to_column_index(table, it->columns[0]), it->offset);
+    EcsMetricOneOfInstance *mi = ecs_field(it, EcsMetricOneOfInstance, 1);
+    ecs_ftime_t dt = it->delta_time;
 
-    /* Safe to cast, world is not readonly */
-    ecs_world_t *world = ECS_CONST_CAST(ecs_world_t*, world_r);
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_oneof_metric_ctx_t *ctx = mi[i].ctx;
+        ecs_record_t *r = mi[i].r;
+        if (!r) {
+            continue;
+        }
 
-    /* If pending buffer is NULL there already is a stackframe that's iterating
-     * the table list. This can happen when an observer for a table event results
-     * in a mutation that causes another table to change state. A typical
-     * example of this is a system that becomes active/inactive as the result of
-     * a query (and as a result, its matched tables) becoming empty/non empty */
-    if (!world->pending_buffer) {
-        return;
-    }
+        ecs_table_t *mtable = r->table;
 
-    /* Swap buffer. The logic could in theory have been implemented with a
-     * single sparse set, but that would've complicated (and slowed down) the
-     * iteration. Additionally, by using a double buffer approach we can still
-     * keep most of the original ordering of events intact, which is desirable
-     * as it means that the ordering of tables in the internal data structures is
-     * more predictable. */
-    int32_t i, count = flecs_sparse_count(world->pending_tables);
-    if (!count) {
-        return;
-    }
+        double *value = ECS_ELEM(m, ctx->size, i);
+        if (!counter) {
+            ecs_os_memset(value, 0, ctx->size);
+        }
 
-    flecs_journal_begin(world, EcsJournalTableEvents, 0, 0, 0);
+        if (!mtable) {
+            ecs_delete(it->world, it->entities[i]);
+            continue;
+        }
 
-    do {
-        ecs_sparse_t *pending_tables = world->pending_tables;
-        world->pending_tables = world->pending_buffer;
-        world->pending_buffer = NULL;
+        ecs_id_record_t *idr = ctx->idr;
+        ecs_id_t id;
+        if (flecs_search_w_idr(world, mtable, &id, idr) == -1) {
+            ecs_delete(it->world, it->entities[i]);
+            continue;
+        }
 
-        /* Make sure that any ECS operations that occur while delivering the
-         * events does not cause inconsistencies, like sending an Empty
-         * notification for a table that just became non-empty. */
-        flecs_defer_begin(world, &world->stages[0]);
+        ecs_entity_t tgt = ECS_PAIR_SECOND(id);
+        uint64_t *offset = ecs_map_get(&ctx->target_offset, tgt);
+        if (!offset) {
+            ecs_err("unexpected relationship target for metric");
+            continue;
+        }
 
-        for (i = 0; i < count; i ++) {
-            ecs_table_t *table = flecs_sparse_get_dense_t(
-                pending_tables, ecs_table_t*, i)[0];
-            if (!table->id) {
-                /* Table is being deleted, ignore empty events */
-                continue;
-            }
+        value = ECS_OFFSET(value, *offset);
 
-            /* For each id in the table, add it to the empty/non empty list
-             * based on its current state */
-            if (flecs_table_records_update_empty(table)) {
-                int32_t table_count = ecs_table_count(table);
-                if (table->flags & (EcsTableHasOnTableFill|EcsTableHasOnTableEmpty)) {
-                    /* Only emit an event when there was a change in the
-                    * administration. It is possible that a table ended up in the
-                    * pending_tables list by going from empty->non-empty, but then
-                    * became empty again. By the time we run this code, no changes
-                    * in the administration would actually be made. */
-                    ecs_entity_t evt = table_count ? EcsOnTableFill : EcsOnTableEmpty;
-                    if (ecs_should_log_3()) {
-                        ecs_dbg_3("table %u state change (%s)",
-                            (uint32_t)table->id,
-                            table_count ? "non-empty" : "empty");
-                    }
+        if (!counter) {
+            *value = 1.0;
+        } else {
+            *value += 1.0 * (double)dt;
+        }
+    }
+}
 
-                    ecs_log_push_3();
+static void UpdateGaugeOneOfInstance(ecs_iter_t *it) {
+    UpdateOneOfInstance(it, false);
+}
 
-                    flecs_emit(world, world, &(ecs_event_desc_t){
-                        .event = evt,
-                        .table = table,
-                        .ids = &table->type,
-                        .observable = world,
-                        .flags = EcsEventTableOnly
-                    });
+static void UpdateCounterOneOfInstance(ecs_iter_t *it) {
+    UpdateOneOfInstance(it, true);
+}
 
-                    ecs_log_pop_3();
+static void UpdateCountTargets(ecs_iter_t *it) {
+    ecs_world_t *world = it->real_world;
+    EcsMetricCountTargets *m = ecs_field(it, EcsMetricCountTargets, 0);
+
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        ecs_count_targets_metric_ctx_t *ctx = m[i].ctx;
+        ecs_id_record_t *cur = ctx->idr;
+        while ((cur = cur->first.next)) {
+            ecs_id_t id = cur->id;
+            ecs_entity_t *mi = ecs_map_ensure(&ctx->targets, id);
+            if (!mi[0]) {
+                mi[0] = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
+                ecs_entity_t tgt = ecs_pair_second(world, cur->id);
+                const char *name = ecs_get_name(world, tgt);
+                if (name) {
+                    ecs_set_name(world, mi[0], name);
                 }
-                world->info.empty_table_count += (table_count == 0) * 2 - 1;
+
+                EcsMetricSource *source = ecs_ensure(
+                    world, mi[0], EcsMetricSource);
+                source->entity = tgt;
             }
-        }
 
-        flecs_sparse_clear(pending_tables);
-        ecs_defer_end(world);
+            EcsMetricValue *value = ecs_ensure(world, mi[0], EcsMetricValue);
+            value->value += (double)ecs_count_id(world, cur->id) * 
+                (double)it->delta_system_time;
+        }
+    }
+}
 
-        world->pending_buffer = pending_tables;
-    } while ((count = flecs_sparse_count(world->pending_tables)));
+static void UpdateCountIds(ecs_iter_t *it) {
+    ecs_world_t *world = it->real_world;
+    EcsMetricCountIds *m = ecs_field(it, EcsMetricCountIds, 0);
+    EcsMetricValue *v = ecs_field(it, EcsMetricValue, 1);
 
-    flecs_journal_end();
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        v[i].value += (double)ecs_count_id(world, m[i].id) * 
+            (double)it->delta_system_time;
+    }
 }
 
-void flecs_table_set_empty(
+/** Initialize member metric */
+static
+int flecs_member_metric_init(
     ecs_world_t *world,
-    ecs_table_t *table)
+    ecs_entity_t metric,
+    const ecs_metric_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    if (ecs_table_count(table)) {
-        table->_->generation = 0;
-    }
-
-    flecs_sparse_ensure_fast_t(world->pending_tables, ecs_table_t*,
-        (uint32_t)table->id)[0] = table;
-}
-
-bool ecs_id_in_use(
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return false;
-    }
-    return (flecs_table_cache_count(&idr->cache) != 0) ||
-        (flecs_table_cache_empty_count(&idr->cache) != 0);
-}
+    ecs_entity_t type = 0, member_type = 0, member = 0, id = 0;
+    uintptr_t offset = 0;
 
-void ecs_run_aperiodic(
-    ecs_world_t *world,
-    ecs_flags32_t flags)
-{
-    ecs_poly_assert(world, ecs_world_t);
+    if (desc->dotmember) {
+        if (!desc->id) {
+            char *metric_name = ecs_get_fullpath(world, metric);
+            ecs_err("missing id for metric '%s' with member '%s",
+                metric_name, desc->dotmember);
+            ecs_os_free(metric_name);
+            goto error;
+        }
 
-    if (!flags || (flags & EcsAperiodicEmptyTables)) {
-        flecs_process_pending_tables(world);
-    }
-    if ((flags & EcsAperiodicEmptyQueries)) {
-        flecs_process_empty_queries(world);
-    }
-    if (!flags || (flags & EcsAperiodicComponentMonitors)) {
-        flecs_eval_component_monitors(world);
-    }
-}
+        if (desc->member) {
+            char *metric_name = ecs_get_fullpath(world, metric);
+            ecs_err("cannot set both member and dotmember for metric '%s'",
+                metric_name);
+            ecs_os_free(metric_name);
+            goto error;
+        }
 
-int32_t ecs_delete_empty_tables(
-    ecs_world_t *world,
-    ecs_id_t id,
-    uint16_t clear_generation,
-    uint16_t delete_generation,
-    int32_t min_id_count,
-    double time_budget_seconds)
-{
-    ecs_poly_assert(world, ecs_world_t);
+        type = ecs_get_typeid(world, desc->id);
 
-    /* Make sure empty tables are in the empty table lists */
-    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
+        ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, NULL);
+        if (ecs_meta_push(&cur)) {
+            char *metric_name = ecs_get_fullpath(world, metric);
+            ecs_err("invalid type for metric '%s'", metric_name);
+            ecs_os_free(metric_name);
+            goto error;
+        }
+        if (ecs_meta_dotmember(&cur, desc->dotmember)) {
+            char *metric_name = ecs_get_fullpath(world, metric);
+            ecs_err("invalid dotmember '%s' for metric '%s'",
+                desc->dotmember, metric_name);
+            ecs_os_free(metric_name);
+            goto error;
+        }
 
-    ecs_time_t start = {0}, cur = {0};
-    int32_t delete_count = 0, clear_count = 0;
-    bool time_budget = false;
+        id = desc->id;
+        member_type = ecs_meta_get_type(&cur);
+        offset = (uintptr_t)ecs_meta_get_ptr(&cur);
+        member = ecs_meta_get_member_id(&cur);
+    } else {    
+        const EcsMember *m = ecs_get(world, desc->member, EcsMember);
+        if (!m) {
+            char *metric_name = ecs_get_fullpath(world, metric);
+            char *member_name = ecs_get_fullpath(world, desc->member);
+            ecs_err("entity '%s' provided for metric '%s' is not a member",
+                member_name, metric_name);
+            ecs_os_free(member_name);
+            ecs_os_free(metric_name);
+            goto error;
+        }
 
-    if (ECS_NEQZERO(time_budget_seconds) || (ecs_should_log_1() && ecs_os_has_time())) {
-        ecs_time_measure(&start);
-    }
+        type = ecs_get_parent(world, desc->member);
+        if (!type) {
+            char *metric_name = ecs_get_fullpath(world, metric);
+            char *member_name = ecs_get_fullpath(world, desc->member);
+            ecs_err("member '%s' provided for metric '%s' is not part of a type",
+                member_name, metric_name);
+            ecs_os_free(member_name);
+            ecs_os_free(metric_name);
+            goto error;
+        }
+        
+        id = type;
+        if (desc->id) {
+            if (type != ecs_get_typeid(world, desc->id)) {
+                char *metric_name = ecs_get_fullpath(world, metric);
+                char *member_name = ecs_get_fullpath(world, desc->member);
+                char *id_name = ecs_get_fullpath(world, desc->id);
+                ecs_err("member '%s' for metric '%s' is not of type '%s'",
+                    member_name, metric_name, id_name);
+                ecs_os_free(id_name);
+                ecs_os_free(member_name);
+                ecs_os_free(metric_name);
+                goto error;
+            }
+            id = desc->id;
+        }
 
-    if (ECS_NEQZERO(time_budget_seconds)) {
-        time_budget = true;
+        member = desc->member;
+        member_type = m->type;
+        offset = flecs_ito(uintptr_t, m->offset);
     }
 
-    if (!id) {
-        id = EcsAny; /* Iterate all empty tables */
+    const EcsPrimitive *p = ecs_get(world, member_type, EcsPrimitive);
+    if (!p) {
+        char *metric_name = ecs_get_fullpath(world, metric);
+        char *member_name = ecs_get_fullpath(world, desc->member);
+        ecs_err("member '%s' provided for metric '%s' must have primitive type",
+            member_name, metric_name);
+        ecs_os_free(member_name);
+        ecs_os_free(metric_name);
+        goto error;
     }
 
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    ecs_table_cache_iter_t it;
-    if (idr && flecs_table_cache_empty_iter((ecs_table_cache_t*)idr, &it)) {
-        ecs_table_record_t *tr;
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            if (time_budget) {
-                cur = start;
-                if (ecs_time_measure(&cur) > time_budget_seconds) {
-                    goto done;
-                }
-            }
-
-            ecs_table_t *table = tr->hdr.table;
-            ecs_assert(ecs_table_count(table) == 0, ECS_INTERNAL_ERROR, NULL);
-
-            if (table->type.count < min_id_count) {
-                continue;
-            }
-
-            uint16_t gen = ++ table->_->generation;
-            if (delete_generation && (gen > delete_generation)) {
-                flecs_table_free(world, table);
-                delete_count ++;
-            } else if (clear_generation && (gen > clear_generation)) {
-                if (flecs_table_shrink(world, table)) {
-                    clear_count ++;
-                }
-            }
-        }
+    const EcsType *mt = ecs_get(world, type, EcsType);
+    if (!mt) {
+        char *metric_name = ecs_get_fullpath(world, metric);
+        char *member_name = ecs_get_fullpath(world, desc->member);
+        ecs_err("parent of member '%s' for metric '%s' is not a type",
+            member_name, metric_name);
+        ecs_os_free(member_name);
+        ecs_os_free(metric_name);
+        goto error;
     }
 
-done:
-    if (ecs_should_log_1() && ecs_os_has_time()) {
-        if (delete_count) {
-            ecs_dbg_1("#[red]deleted#[normal] %d empty tables in %.2fs",
-                delete_count, ecs_time_measure(&start));
-        }
-        if (clear_count) {
-            ecs_dbg_1("#[red]cleared#[normal] %d empty tables in %.2fs",
-                clear_count, ecs_time_measure(&start));
-        }
+    if (mt->kind != EcsStructType) {
+        char *metric_name = ecs_get_fullpath(world, metric);
+        char *member_name = ecs_get_fullpath(world, desc->member);
+        ecs_err("parent of member '%s' for metric '%s' is not a struct",
+            member_name, metric_name);
+        ecs_os_free(member_name);
+        ecs_os_free(metric_name);
+        goto error;
     }
 
-    return delete_count;
-}
+    ecs_member_metric_ctx_t *ctx = ecs_os_calloc_t(ecs_member_metric_ctx_t);
+    ctx->metric.metric = metric;
+    ctx->metric.kind = desc->kind;
+    ctx->type_kind = p->kind;
+    ctx->offset = flecs_uto(uint16_t, offset);
 
-/**
- * @file addons/alerts.c
- * @brief Alerts addon.
- */
+    ecs_observer(world, {
+        .entity = metric,
+        .events = { EcsOnAdd },
+        .query.terms[0] = {
+            .id = id,
+            .src.id = EcsSelf,
+            .inout = EcsInOutNone
+        },
+        .callback = flecs_metrics_on_member_metric,
+        .yield_existing = true,
+        .ctx = ctx
+    });
 
+    ecs_set_pair(world, metric, EcsMetricMember, member, { .ctx = ctx });
+    ecs_add_pair(world, metric, EcsMetric, desc->kind);
+    ecs_add_id(world, metric, EcsMetric);
 
-#ifdef FLECS_ALERTS
+    return 0;
+error:
+    return -1;
+}
 
-ECS_COMPONENT_DECLARE(FlecsAlerts);
+/** Update id metric */
+static
+int flecs_id_metric_init(
+    ecs_world_t *world,
+    ecs_entity_t metric,
+    const ecs_metric_desc_t *desc)
+{
+    ecs_id_metric_ctx_t *ctx = ecs_os_calloc_t(ecs_id_metric_ctx_t);
+    ctx->metric.metric = metric;
+    ctx->metric.kind = desc->kind;
+    ctx->idr = flecs_id_record_ensure(world, desc->id);
+    ecs_check(ctx->idr != NULL, ECS_INTERNAL_ERROR, NULL);
 
-typedef struct EcsAlert {
-    char *message;
-    ecs_map_t instances;        /* Active instances for metric */
-    ecs_ftime_t retain_period;  /* How long to retain the alert */
-    ecs_vec_t severity_filters; /* Severity filters */
-    
-    /* Member range monitoring */
-    ecs_id_t id;                /* (Component) id that contains to monitor member */
-    ecs_entity_t member;        /* Member to monitor */
-    int32_t offset;             /* Offset of member in component */
-    int32_t size;               /* Size of component */
-    ecs_primitive_kind_t kind;  /* Primitive type kind */
-    ecs_ref_t ranges;           /* Reference to ranges component */
-    int32_t var_id;             /* Variable from which to obtain data (0 = $this) */
-} EcsAlert;
+    ecs_observer(world, {
+        .entity = metric,
+        .events = { EcsOnAdd },
+        .query.terms[0] = {
+            .id = desc->id,
+            .src.id = EcsSelf,
+            .inout = EcsInOutNone
+        },
+        .callback = flecs_metrics_on_id_metric,
+        .yield_existing = true,
+        .ctx = ctx
+    });
 
-typedef struct EcsAlertTimeout {
-    ecs_ftime_t inactive_time; /* Time the alert has been inactive */
-    ecs_ftime_t expire_time;   /* Expiration duration */
-} EcsAlertTimeout;
+    ecs_set(world, metric, EcsMetricId, { .ctx = ctx });
+    ecs_add_pair(world, metric, EcsMetric, desc->kind);
+    ecs_add_id(world, metric, EcsMetric);
 
-ECS_COMPONENT_DECLARE(EcsAlertTimeout);
+    return 0;
+error:
+    return -1;
+}
 
+/** Update oneof metric */
 static
-ECS_CTOR(EcsAlert, ptr, {
-    ecs_os_zeromem(ptr);
-    ecs_map_init(&ptr->instances, NULL);
-    ecs_vec_init_t(NULL, &ptr->severity_filters, ecs_alert_severity_filter_t, 0);
-})
+int flecs_oneof_metric_init(
+    ecs_world_t *world,
+    ecs_entity_t metric,
+    ecs_entity_t scope,
+    const ecs_metric_desc_t *desc)
+{
+    ecs_oneof_metric_ctx_t *ctx = ecs_os_calloc_t(ecs_oneof_metric_ctx_t);
+    ctx->metric.metric = metric;
+    ctx->metric.kind = desc->kind;
+    ctx->idr = flecs_id_record_ensure(world, desc->id);
+    ecs_check(ctx->idr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_map_init(&ctx->target_offset, NULL);
 
-static
-ECS_DTOR(EcsAlert, ptr, {
-    ecs_os_free(ptr->message);
-    ecs_map_fini(&ptr->instances);
-    ecs_vec_fini_t(NULL, &ptr->severity_filters, ecs_alert_severity_filter_t);
-})
+    /* Add member for each child of oneof to metric, so it can be used as metric
+     * instance type that holds values for all targets */
+    ecs_iter_t it = ecs_children(world, scope);
+    uint64_t offset = 0;
+    while (ecs_children_next(&it)) {
+        int32_t i, count = it.count;
+        for (i = 0; i < count; i ++) {
+            ecs_entity_t tgt = it.entities[i];
+            const char *name = ecs_get_name(world, tgt);
+            if (!name) {
+                /* Member must have name */
+                continue;
+            }
 
-static
-ECS_MOVE(EcsAlert, dst, src, {
-    ecs_os_free(dst->message);
-    dst->message = src->message;
-    src->message = NULL;
+            char *to_snake_case = flecs_to_snake_case(name);
 
-    ecs_map_fini(&dst->instances);
-    dst->instances = src->instances;
-    src->instances = (ecs_map_t){0};
+            ecs_entity_t mbr = ecs_entity(world, {
+                .name = to_snake_case,
+                .parent = ecs_childof(metric)
+            });
 
-    ecs_vec_fini_t(NULL, &dst->severity_filters, ecs_alert_severity_filter_t);
-    dst->severity_filters = src->severity_filters;
-    src->severity_filters = (ecs_vec_t){0};
+            ecs_os_free(to_snake_case);
 
-    dst->retain_period = src->retain_period;
-    dst->id = src->id;
-    dst->member = src->member;
-    dst->offset = src->offset;
-    dst->size = src->size;
-    dst->kind = src->kind;
-    dst->ranges = src->ranges;
-    dst->var_id = src->var_id;
-})
+            ecs_set(world, mbr, EcsMember, {
+                .type = ecs_id(ecs_f64_t),
+                .unit = EcsSeconds
+            });
 
-static
-ECS_CTOR(EcsAlertsActive, ptr, {
-    ecs_map_init(&ptr->alerts, NULL);
-    ptr->info_count = 0;
-    ptr->warning_count = 0;
-    ptr->error_count = 0;
-})
+            /* Truncate upper 32 bits of target so we can lookup the offset
+             * with the id we get from the pair */
+            ecs_map_ensure(&ctx->target_offset, (uint32_t)tgt)[0] = offset;
 
-static
-ECS_DTOR(EcsAlertsActive, ptr, {
-    ecs_map_fini(&ptr->alerts);
-})
+            offset += sizeof(double);
+        }
+    }
 
-static
-ECS_MOVE(EcsAlertsActive, dst, src, {
-    ecs_map_fini(&dst->alerts);
-    dst->alerts = src->alerts;
-    dst->info_count = src->info_count;
-    dst->warning_count = src->warning_count;
-    dst->error_count = src->error_count;
-    src->alerts = (ecs_map_t){0};
-})
+    ctx->size = flecs_uto(ecs_size_t, offset);
 
-static
-ECS_DTOR(EcsAlertInstance, ptr, {
-    ecs_os_free(ptr->message);
-})
+    ecs_observer(world, {
+        .entity = metric,
+        .events = { EcsMonitor },
+        .query.terms[0] = {
+            .id = desc->id,
+            .src.id = EcsSelf,
+            .inout = EcsInOutNone
+        },
+        .callback = flecs_metrics_on_oneof_metric,
+        .yield_existing = true,
+        .ctx = ctx
+    });
 
-static
-ECS_MOVE(EcsAlertInstance, dst, src, {
-    ecs_os_free(dst->message);
-    dst->message = src->message;
-    src->message = NULL;
-})
+    ecs_set(world, metric, EcsMetricOneOf, { .ctx = ctx });
+    ecs_add_pair(world, metric, EcsMetric, desc->kind);
+    ecs_add_id(world, metric, EcsMetric);
 
-static
-ECS_COPY(EcsAlertInstance, dst, src, {
-    ecs_os_free(dst->message);
-    dst->message = ecs_os_strdup(src->message);
-})
+    return 0;
+error:
+    return -1;
+}
 
 static
-void flecs_alerts_add_alert_to_src(
+int flecs_count_id_targets_metric_init(
     ecs_world_t *world,
-    ecs_entity_t source,
-    ecs_entity_t alert,
-    ecs_entity_t alert_instance)
+    ecs_entity_t metric,
+    const ecs_metric_desc_t *desc)
 {
-    EcsAlertsActive *active = ecs_ensure(
-        world, source, EcsAlertsActive);
-    ecs_assert(active != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_count_targets_metric_ctx_t *ctx = ecs_os_calloc_t(ecs_count_targets_metric_ctx_t);
+    ctx->metric.metric = metric;
+    ctx->metric.kind = desc->kind;
+    ctx->idr = flecs_id_record_ensure(world, desc->id);
+    ecs_check(ctx->idr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_map_init(&ctx->targets, NULL);
 
-    ecs_entity_t severity = ecs_get_target(world, alert, ecs_id(EcsAlert), 0);
-    if (severity == EcsAlertInfo) {
-        active->info_count ++;
-    } else if (severity == EcsAlertWarning) {
-        active->warning_count ++;
-    } else if (severity == EcsAlertError) {
-        active->error_count ++;
-    }
+    ecs_set(world, metric, EcsMetricCountTargets, { .ctx = ctx });
+    ecs_add_pair(world, metric, EcsMetric, desc->kind);
+    ecs_add_id(world, metric, EcsMetric); 
 
-    ecs_entity_t *ptr = ecs_map_ensure(&active->alerts, alert);
-    ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-    ptr[0] = alert_instance;
-    ecs_modified(world, source, EcsAlertsActive);
+    return 0;
+error:
+    return -1;
 }
 
 static
-void flecs_alerts_remove_alert_from_src(
+int flecs_count_ids_metric_init(
     ecs_world_t *world,
-    ecs_entity_t source,
-    ecs_entity_t alert)
+    ecs_entity_t metric,
+    const ecs_metric_desc_t *desc)
 {
-    EcsAlertsActive *active = ecs_ensure(
-        world, source, EcsAlertsActive);
-    ecs_assert(active != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_map_remove(&active->alerts, alert);
+    ecs_set(world, metric, EcsMetricCountIds, { .id = desc->id });
+    ecs_set(world, metric, EcsMetricValue, { .value = 0 });
+    return 0;
+}
 
-    ecs_entity_t severity = ecs_get_target(world, alert, ecs_id(EcsAlert), 0);
-    if (severity == EcsAlertInfo) {
-        active->info_count --;
-    } else if (severity == EcsAlertWarning) {
-        active->warning_count --;
-    } else if (severity == EcsAlertError) {
-        active->error_count --;
+ecs_entity_t ecs_metric_init(
+    ecs_world_t *world,
+    const ecs_metric_desc_t *desc)
+{
+    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_metric_desc_t was not initialized to zero");
+    flecs_poly_assert(world, ecs_world_t);
+
+    ecs_entity_t result = desc->entity;
+    if (!result) {
+        result = ecs_new(world);
     }
 
-    if (!ecs_map_count(&active->alerts)) {
-        ecs_remove(world, source, EcsAlertsActive);
-    } else {
-        ecs_modified(world, source, EcsAlertsActive);
+    ecs_entity_t kind = desc->kind;
+    if (!kind) {
+        ecs_err("missing metric kind");
+        goto error;
     }
-}
 
-static
-ecs_entity_t flecs_alert_get_severity(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    EcsAlert *alert)
-{
-    int32_t i, filter_count = ecs_vec_count(&alert->severity_filters);
-    ecs_alert_severity_filter_t *filters = 
-        ecs_vec_first(&alert->severity_filters);
-    for (i = 0; i < filter_count; i ++) {
-        ecs_alert_severity_filter_t *filter = &filters[i];
-        if (!filter->var) {
-            if (ecs_table_has_id(world, it->table, filters[i].with)) {
-                return filters[i].severity;
-            }
-        } else {
-            ecs_entity_t src = ecs_iter_get_var(it, filter->_var_index);
-            if (src && src != EcsWildcard) {
-                if (ecs_has_id(world, src, filters[i].with)) {
-                    return filters[i].severity;
-                }
-            }
-        }
+    if (kind != EcsGauge && 
+        kind != EcsCounter && 
+        kind != EcsCounterId &&
+        kind != EcsCounterIncrement) 
+    {
+        ecs_err("invalid metric kind %s", ecs_get_fullpath(world, kind));
+        goto error;
     }
 
-    return 0;
-}
+    if (kind == EcsCounterIncrement && !desc->member && !desc->dotmember) {
+        ecs_err("CounterIncrement can only be used in combination with member");
+        goto error;
+    }
 
-static
-ecs_entity_t flecs_alert_out_of_range_kind(
-    EcsAlert *alert,
-    const EcsMemberRanges *ranges,
-    const void *value_ptr)
-{
-    double value = 0;
+    if (kind == EcsCounterId && (desc->member || desc->dotmember)) {
+        ecs_err("CounterId cannot be used in combination with member");
+        goto error;
+    }
 
-    switch(alert->kind) {
-    case EcsU8: value = *(const uint8_t*)value_ptr; break;
-    case EcsU16: value = *(const uint16_t*)value_ptr; break;
-    case EcsU32: value = *(const uint32_t*)value_ptr; break;
-    case EcsU64: value = (double)*(const uint64_t*)value_ptr; break;
-    case EcsI8: value = *(const int8_t*)value_ptr; break;
-    case EcsI16: value = *(const int16_t*)value_ptr; break;
-    case EcsI32: value = *(const int32_t*)value_ptr; break;
-    case EcsI64: value = (double)*(const int64_t*)value_ptr; break;
-    case EcsF32: value = (double)*(const float*)value_ptr; break;
-    case EcsF64: value = *(const double*)value_ptr; break;
-    case EcsBool:
-    case EcsChar:
-    case EcsByte:
-    case EcsUPtr:
-    case EcsIPtr:
-    case EcsString:
-    case EcsEntity:
-    case EcsId:
-        return 0;
-    }
-
-    bool has_error = ECS_NEQ(ranges->error.min, ranges->error.max);
-    bool has_warning = ECS_NEQ(ranges->warning.min, ranges->warning.max);
-
-    if (has_error && (value < ranges->error.min || value > ranges->error.max)) {
-        return EcsAlertError;
-    } else if (has_warning && 
-        (value < ranges->warning.min || value > ranges->warning.max)) 
-    {
-        return EcsAlertWarning;
-    } else {
-        return 0;
+    if (desc->brief) {
+#ifdef FLECS_DOC
+        ecs_doc_set_brief(world, result, desc->brief);
+#else
+        ecs_warn("FLECS_DOC is not enabled, ignoring metrics brief");
+#endif        
     }
-}
-
-static
-void MonitorAlerts(ecs_iter_t *it) {
-    ecs_world_t *world = it->real_world;
-    EcsAlert *alert = ecs_field(it, EcsAlert, 1);
-    EcsPoly *poly = ecs_field(it, EcsPoly, 2);
-
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t a = it->entities[i]; /* Alert entity */
-        ecs_entity_t default_severity = ecs_get_target(
-            world, a, ecs_id(EcsAlert), 0);
-        ecs_rule_t *rule = poly[i].poly;
-        if (!rule) {
-            continue;
-        }
 
-        ecs_poly_assert(rule, ecs_rule_t);
-
-        ecs_id_t member_id = alert[i].id;
-        const EcsMemberRanges *ranges = NULL;
-        if (member_id) {
-            ranges = ecs_ref_get(world, &alert[i].ranges, EcsMemberRanges);
+    if (desc->member || desc->dotmember) {
+        if (flecs_member_metric_init(world, result, desc)) {
+            goto error;
         }
-
-        ecs_iter_t rit = ecs_rule_iter(world, rule);
-        rit.flags |= EcsIterNoData;
-        rit.flags |= EcsIterIsInstanced;
-
-        while (ecs_rule_next(&rit)) {
-            ecs_entity_t severity = flecs_alert_get_severity(
-                world, &rit, &alert[i]);
-            if (!severity) {
-                severity = default_severity;
+    } else if (desc->id) {
+        if (desc->targets) {
+            if (!ecs_id_is_pair(desc->id)) {
+                ecs_err("cannot specify targets for id that is not a pair");
+                goto error;
+            }
+            if (ECS_PAIR_FIRST(desc->id) == EcsWildcard) {
+                ecs_err("first element of pair cannot be wildcard with "
+                    " targets enabled");
+                goto error;
+            }
+            if (ECS_PAIR_SECOND(desc->id) != EcsWildcard) {
+                ecs_err("second element of pair must be wildcard with "
+                    " targets enabled");
+                goto error;
             }
 
-            const void *member_data = NULL;
-            ecs_entity_t member_src = 0;
-            if (ranges) {
-                if (alert[i].var_id) {
-                    member_src = ecs_iter_get_var(&rit, alert[i].var_id);
-                    if (!member_src || member_src == EcsWildcard) {
-                        continue;
-                    }
+            if (kind == EcsCounterId) {
+                if (flecs_count_id_targets_metric_init(world, result, desc)) {
+                    goto error;
                 }
-                if (!member_src) {
-                    member_data = ecs_table_get_id(
-                        world, rit.table, member_id, rit.offset);
-                } else {
-                    member_data = ecs_get_id(world, member_src, member_id);
+            } else {
+                ecs_entity_t first = ecs_pair_first(world, desc->id);
+                ecs_entity_t scope = flecs_get_oneof(world, first);
+                if (!scope) {
+                    ecs_err("first element of pair must have OneOf with "
+                        " targets enabled");
+                    goto error;
                 }
-                if (!member_data) {
-                    continue;
+
+                if (flecs_oneof_metric_init(world, result, scope, desc)) {
+                    goto error;
                 }
-                member_data = ECS_OFFSET(member_data, alert[i].offset);
             }
-
-            int32_t j, alert_src_count = rit.count;
-            for (j = 0; j < alert_src_count; j ++) {
-                ecs_entity_t src_severity = severity;
-                ecs_entity_t e = rit.entities[j];
-                if (member_data) {
-                    ecs_entity_t range_severity = flecs_alert_out_of_range_kind(
-                        &alert[i], ranges, member_data);
-                    if (!member_src) {
-                        member_data = ECS_OFFSET(member_data, alert[i].size);
-                    }
-                    if (!range_severity) {
-                        continue;
-                    }
-                    if (range_severity < src_severity) {
-                        /* Range severity should not exceed alert severity */
-                        src_severity = range_severity;
-                    }
+        } else {
+            if (kind == EcsCounterId) {
+                if (flecs_count_ids_metric_init(world, result, desc)) {
+                    goto error;
                 }
-
-                ecs_entity_t *aptr = ecs_map_ensure(&alert[i].instances, e);
-                ecs_assert(aptr != NULL, ECS_INTERNAL_ERROR, NULL);
-                if (!aptr[0]) {
-                    /* Alert does not yet exist for entity */
-                    ecs_entity_t ai = ecs_new_w_pair(world, EcsChildOf, a);
-                    ecs_set(world, ai, EcsAlertInstance, { .message = NULL });
-                    ecs_set(world, ai, EcsMetricSource, { .entity = e });
-                    ecs_set(world, ai, EcsMetricValue, { .value = 0 });
-                    ecs_add_pair(world, ai, ecs_id(EcsAlert), src_severity);
-                    if (ECS_NEQZERO(alert[i].retain_period)) {
-                        ecs_set(world, ai, EcsAlertTimeout, {
-                            .inactive_time = 0,
-                            .expire_time = alert[i].retain_period
-                        });
-                    }
-
-                    ecs_defer_suspend(it->world);
-                    flecs_alerts_add_alert_to_src(world, e, a, ai);
-                    ecs_defer_resume(it->world);
-                    aptr[0] = ai;
-                } else {
-                    /* Make sure alert severity is up to date */
-                    if (ecs_vec_count(&alert[i].severity_filters) || member_data) {
-                        ecs_entity_t cur_severity = ecs_get_target(
-                            world, aptr[0], ecs_id(EcsAlert), 0);
-                        if (cur_severity != src_severity) {
-                            ecs_add_pair(world, aptr[0], ecs_id(EcsAlert), 
-                                src_severity);
-                        }
-                    }
+            } else {
+                if (flecs_id_metric_init(world, result, desc)) {
+                    goto error;
                 }
             }
         }
+    } else {
+        ecs_err("missing source specified for metric");
+        goto error;
+    }
+
+    return result;
+error:
+    if (result && result != desc->entity) {
+        ecs_delete(world, result);
     }
+    return 0;
 }
 
-static
-void MonitorAlertInstances(ecs_iter_t *it) {
-    ecs_world_t *world = it->real_world;
-    EcsAlertInstance *alert_instance = ecs_field(it, EcsAlertInstance, 1);
-    EcsMetricSource *source = ecs_field(it, EcsMetricSource, 2);
-    EcsMetricValue *value = ecs_field(it, EcsMetricValue, 3);
-    EcsAlertTimeout *timeout = ecs_field(it, EcsAlertTimeout, 4);
+void FlecsMetricsImport(ecs_world_t *world) {
+    ECS_MODULE_DEFINE(world, FlecsMetrics);
 
-    /* Get alert component from alert instance parent (the alert) */
-    ecs_id_t childof_pair;
-    if (ecs_search(world, it->table, ecs_childof(EcsWildcard), &childof_pair) == -1) {
-        ecs_err("alert instances must be a child of an alert");
-        return;
-    }
-    ecs_entity_t parent = ecs_pair_second(world, childof_pair);
-    ecs_assert(parent != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(ecs_has(world, parent, EcsAlert), ECS_INVALID_OPERATION,
-        "alert entity does not have Alert component");
-    EcsAlert *alert = ecs_ensure(world, parent, EcsAlert);
-    const EcsPoly *poly = ecs_get_pair(world, parent, EcsPoly, EcsQuery);
-    ecs_assert(poly != NULL, ECS_INVALID_OPERATION, 
-        "alert entity does not have (Poly, Query) component");
-    ecs_rule_t *rule = poly->poly;
-    if (!rule) {
-        return;
-    }
+    ECS_IMPORT(world, FlecsPipeline);
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_IMPORT(world, FlecsUnits);
 
-    ecs_poly_assert(rule, ecs_rule_t);
+    ecs_set_name_prefix(world, "Ecs");
+    ECS_TAG_DEFINE(world, EcsMetric);
+    ecs_entity_t old_scope = ecs_set_scope(world, EcsMetric);
+    ECS_TAG_DEFINE(world, EcsCounter);
+    ECS_TAG_DEFINE(world, EcsCounterIncrement);
+    ECS_TAG_DEFINE(world, EcsCounterId);
+    ECS_TAG_DEFINE(world, EcsGauge);
+    ecs_set_scope(world, old_scope);
 
-    ecs_id_t member_id = alert->id;
-    const EcsMemberRanges *ranges = NULL;
-    if (member_id) {
-        ranges = ecs_ref_get(world, &alert->ranges, EcsMemberRanges);
-    }
+    ecs_set_name_prefix(world, "EcsMetric");
+    ECS_TAG_DEFINE(world, EcsMetricInstance);
+    ECS_COMPONENT_DEFINE(world, EcsMetricValue);
+    ECS_COMPONENT_DEFINE(world, EcsMetricSource);
+    ECS_COMPONENT_DEFINE(world, EcsMetricMemberInstance);
+    ECS_COMPONENT_DEFINE(world, EcsMetricIdInstance);
+    ECS_COMPONENT_DEFINE(world, EcsMetricOneOfInstance);
+    ECS_COMPONENT_DEFINE(world, EcsMetricMember);
+    ECS_COMPONENT_DEFINE(world, EcsMetricId);
+    ECS_COMPONENT_DEFINE(world, EcsMetricOneOf);
+    ECS_COMPONENT_DEFINE(world, EcsMetricCountIds);
+    ECS_COMPONENT_DEFINE(world, EcsMetricCountTargets);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_add_id(world, ecs_id(EcsMetricMemberInstance), EcsPrivate);
+    ecs_add_id(world, ecs_id(EcsMetricIdInstance), EcsPrivate);
+    ecs_add_id(world, ecs_id(EcsMetricOneOfInstance), EcsPrivate);
 
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t ai = it->entities[i];
-        ecs_entity_t e = source[i].entity;
+    ecs_struct(world, {
+        .entity = ecs_id(EcsMetricValue),
+        .members = {
+            { .name = "value", .type = ecs_id(ecs_f64_t) }
+        }
+    });
 
-        /* If source of alert is no longer alive, delete alert instance even if
-         * the alert has a retain period. */
-        if (!ecs_is_alive(world, e)) {
-            ecs_delete(world, ai);
-            continue;
+    ecs_struct(world, {
+        .entity = ecs_id(EcsMetricSource),
+        .members = {
+            { .name = "entity", .type = ecs_id(ecs_entity_t) }
         }
+    });
 
-        /* Check if alert instance still matches rule */
-        ecs_iter_t rit = ecs_rule_iter(world, rule);
-        rit.flags |= EcsIterNoData;
-        rit.flags |= EcsIterIsInstanced;
-        ecs_iter_set_var(&rit, 0, e);
+    ecs_set_hooks(world, EcsMetricMember, {
+        .ctor = flecs_default_ctor,
+        .dtor = ecs_dtor(EcsMetricMember),
+        .move = ecs_move(EcsMetricMember)
+    });
 
-        if (ecs_rule_next(&rit)) {
-            bool match = true;
+    ecs_set_hooks(world, EcsMetricId, {
+        .ctor = flecs_default_ctor,
+        .dtor = ecs_dtor(EcsMetricId),
+        .move = ecs_move(EcsMetricId)
+    });
 
-            /* If alert is monitoring member range, test value against range */
-            if (ranges) {
-                ecs_entity_t member_src = e;
-                if (alert->var_id) {
-                    member_src = ecs_iter_get_var(&rit, alert->var_id);
-                }
+    ecs_set_hooks(world, EcsMetricOneOf, {
+        .ctor = flecs_default_ctor,
+        .dtor = ecs_dtor(EcsMetricOneOf),
+        .move = ecs_move(EcsMetricOneOf)
+    });
 
-                const void *member_data = ecs_get_id(
-                    world, member_src, member_id);
-                if (!member_data) {
-                    match = false;
-                } else {
-                    member_data = ECS_OFFSET(member_data, alert->offset);
-                    if (flecs_alert_out_of_range_kind(
-                        alert, ranges, member_data) == 0) 
-                    {
-                        match = false;
-                    }
-                }
-            }
+    ecs_set_hooks(world, EcsMetricCountTargets, {
+        .ctor = flecs_default_ctor,
+        .dtor = ecs_dtor(EcsMetricCountTargets),
+        .move = ecs_move(EcsMetricCountTargets)
+    });
 
-            if (match) {
-                /* Only increase alert duration if the alert was active */
-                value[i].value += (double)it->delta_system_time;
+    ecs_add_id(world, EcsMetric, EcsOneOf);
 
-                bool generate_message = alert->message;
-                if (generate_message) {
-                    if (alert_instance[i].message) {
-                        /* If a message was already generated, only regenerate if
-                        * rule has multiple variables. Variable values could have 
-                        * changed, this ensures the message remains up to date. */
-                        generate_message = rit.variable_count > 1;
-                    }
-                }
+#ifdef FLECS_DOC
+    ECS_OBSERVER(world, SetMetricDocName, EcsOnSet, 
+        Source);
+#endif
 
-                if (generate_message) {
-                    if (alert_instance[i].message) {
-                        ecs_os_free(alert_instance[i].message);
-                    }
+    ECS_SYSTEM(world, ClearMetricInstance, EcsPreStore,
+        [in] Source);
 
-                    ecs_iter_to_vars(&rit, &vars, 0);
-                    alert_instance[i].message = ecs_interpolate_string(
-                        world, alert->message, &vars);
-                }
+    ECS_SYSTEM(world, UpdateGaugeMemberInstance, EcsPreStore, 
+        [out]  Value, 
+        [in]   MemberInstance,
+        [none] (Metric, Gauge));
 
-                if (timeout) {
-                    if (ECS_NEQZERO(timeout[i].inactive_time)) {
-                        /* The alert just became active. Remove Disabled tag */
-                        flecs_alerts_add_alert_to_src(world, e, parent, ai);
-                        ecs_remove_id(world, ai, EcsDisabled);
-                    }
-                    timeout[i].inactive_time = 0;
-                }
+    ECS_SYSTEM(world, UpdateCounterMemberInstance, EcsPreStore, 
+        [out]  Value, 
+        [in]   MemberInstance,
+        [none] (Metric, Counter));
 
-                /* Alert instance still matches rule, keep it alive */
-                ecs_iter_fini(&rit);
-                continue;
-            }
+    ECS_SYSTEM(world, UpdateCounterIncrementMemberInstance, EcsPreStore, 
+        [out]  Value, 
+        [in]   MemberInstance,
+        [none] (Metric, CounterIncrement));
 
-            ecs_iter_fini(&rit);
-        }
+    ECS_SYSTEM(world, UpdateGaugeIdInstance, EcsPreStore, 
+        [out]  Value, 
+        [in]   IdInstance,
+        [none] (Metric, Gauge));
 
-        /* Alert instance is no longer active */
+    ECS_SYSTEM(world, UpdateCounterIdInstance, EcsPreStore, 
+        [inout] Value, 
+        [in]    IdInstance,
+        [none]  (Metric, Counter));
 
-        if (timeout) {
-            if (ECS_EQZERO(timeout[i].inactive_time)) {
-                /* The alert just became inactive. Add Disabled tag */
-                flecs_alerts_remove_alert_from_src(world, e, parent);
-                ecs_add_id(world, ai, EcsDisabled);
-            }
-            ecs_ftime_t t = timeout[i].inactive_time;
-            timeout[i].inactive_time += it->delta_system_time;
-            if (t < timeout[i].expire_time) {
-                /* Alert instance no longer matches rule, but is still
-                    * within the timeout period. Keep it alive. */
-                continue;
-            }
-        }
+    ECS_SYSTEM(world, UpdateGaugeOneOfInstance, EcsPreStore, 
+        [none] (_, Value), 
+        [in]   OneOfInstance,
+        [none] (Metric, Gauge));
 
-        /* Alert instance no longer matches rule, remove it */        
-        flecs_alerts_remove_alert_from_src(world, e, parent);
-        ecs_map_remove(&alert->instances, e);
-        ecs_delete(world, ai);
-    }
+    ECS_SYSTEM(world, UpdateCounterOneOfInstance, EcsPreStore, 
+        [none] (_, Value), 
+        [in]   OneOfInstance,
+        [none] (Metric, Counter));
+
+    ECS_SYSTEM(world, UpdateCountIds, EcsPreStore, 
+        [inout] CountIds, Value);
 
-    ecs_vars_fini(&vars);
+    ECS_SYSTEM(world, UpdateCountTargets, EcsPreStore, 
+        [inout] CountTargets);
 }
 
-ecs_entity_t ecs_alert_init(
-    ecs_world_t *world,
-    const ecs_alert_desc_t *desc)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!desc->filter.entity || desc->entity == desc->filter.entity, 
-        ECS_INVALID_PARAMETER, NULL);
+#endif
 
-    ecs_entity_t result = desc->entity;
-    if (!result) {
-        result = ecs_new(world, 0);
-    }
+/**
+ * @file addons/module.c
+ * @brief Module addon.
+ */
 
-    ecs_filter_desc_t private_desc = desc->filter;
-    private_desc.entity = result;
 
-    ecs_rule_t *rule = ecs_rule_init(world, &private_desc);
-    if (!rule) {
-        ecs_err("failed to create alert filter");
-        return 0;
-    }
+#ifdef FLECS_MODULE
 
-    const ecs_filter_t *filter = ecs_rule_get_filter(rule);
-    if (!(filter->flags & EcsFilterMatchThis)) {
-        ecs_err("alert filter must have at least one '$this' term");
-        ecs_rule_fini(rule);
-        return 0;
-    }
+#include <ctype.h>
 
-    /* Initialize Alert component which identifiers entity as alert */
-    EcsAlert *alert = ecs_ensure(world, result, EcsAlert);
-    ecs_assert(alert != NULL, ECS_INTERNAL_ERROR, NULL);
-    alert->message = ecs_os_strdup(desc->message);
-    alert->retain_period = desc->retain_period;
+char* flecs_module_path_from_c(
+    const char *c_name)
+{
+    ecs_strbuf_t str = ECS_STRBUF_INIT;
+    const char *ptr;
+    char ch;
 
-    /* Initialize severity filters */
-    int32_t i;
-    for (i = 0; i < 4; i ++) {
-        if (desc->severity_filters[i].with) {
-            if (!desc->severity_filters[i].severity) {
-                ecs_err("severity filter must have severity");
-                goto error;
-            }
-            ecs_alert_severity_filter_t *sf = ecs_vec_append_t(NULL, 
-                &alert->severity_filters, ecs_alert_severity_filter_t);
-            *sf = desc->severity_filters[i];
-            if (sf->var) {
-                sf->_var_index = ecs_rule_find_var(rule, sf->var);
-                if (sf->_var_index == -1) {
-                    ecs_err("unresolved variable '%s' in alert severity filter", 
-                        sf->var);
-                    goto error;
-                }
+    for (ptr = c_name; (ch = *ptr); ptr++) {
+        if (isupper(ch)) {
+            ch = flecs_ito(char, tolower(ch));
+            if (ptr != c_name) {
+                ecs_strbuf_appendstrn(&str, ".", 1);
             }
         }
+
+        ecs_strbuf_appendstrn(&str, &ch, 1);
     }
 
-    /* Fetch data for member monitoring */
-    if (desc->member) {
-        alert->member = desc->member;
-        if (!desc->id) {
-            alert->id = ecs_get_parent(world, desc->member);
-            if (!alert->id) {
-                ecs_err("ecs_alert_desc_t::member is not a member");
-                goto error;
-            }
-            ecs_check(alert->id != 0, ECS_INVALID_PARAMETER, NULL);
-        } else {
-            alert->id = desc->id;
-        }
+    return ecs_strbuf_get(&str);
+}
 
-        ecs_id_record_t *idr = flecs_id_record_ensure(world, alert->id);
-        ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-        if (!idr->type_info) {
-            ecs_err("ecs_alert_desc_t::id must be a component");
-            goto error;
-        }
+ecs_entity_t ecs_import(
+    ecs_world_t *world,
+    ecs_module_action_t module,
+    const char *module_name)
+{
+    ecs_check(!(world->flags & EcsWorldReadonly), 
+        ECS_INVALID_WHILE_READONLY, NULL);
 
-        ecs_entity_t type = idr->type_info->component;
-        if (type != ecs_get_parent(world, desc->member)) {
-            char *type_name = ecs_get_fullpath(world, type);
-            ecs_err("member '%s' is not a member of '%s'", 
-                ecs_get_name(world, desc->member), type_name);
-            ecs_os_free(type_name);
-            goto error;
-        }
+    ecs_entity_t old_scope = ecs_set_scope(world, 0);
+    const char *old_name_prefix = world->info.name_prefix;
 
-        const EcsMember *member = ecs_get(world, alert->member, EcsMember);
-        if (!member) {
-            ecs_err("ecs_alert_desc_t::member is not a member");
-            goto error;
-        }
-        if (!member->type) {
-            ecs_err("ecs_alert_desc_t::member must have a type");
-            goto error;
-        }
-        
-        const EcsPrimitive *pr = ecs_get(world, member->type, EcsPrimitive);
-        if (!pr) {
-            ecs_err("ecs_alert_desc_t::member must be of a primitive type");
-            goto error;
-        }
+    char *path = flecs_module_path_from_c(module_name);
+    ecs_entity_t e = ecs_lookup(world, path);
+    ecs_os_free(path);
+    
+    if (!e) {
+        ecs_trace("#[magenta]import#[reset] %s", module_name);
+        ecs_log_push();
 
-        if (!ecs_has(world, desc->member, EcsMemberRanges)) {
-            ecs_err("ecs_alert_desc_t::member must have warning/error ranges");
-            goto error;
-        }
+        /* Load module */
+        module(world);
 
-        int32_t var_id = 0;
-        if (desc->var) {
-            var_id = ecs_rule_find_var(rule, desc->var);
-            if (var_id == -1) {
-                ecs_err("unresolved variable '%s' in alert member", desc->var);
-                goto error;
-            }
-        }
+        /* Lookup module entity (must be registered by module) */
+        e = ecs_lookup(world, module_name);
+        ecs_check(e != 0, ECS_MODULE_UNDEFINED, module_name);
 
-        alert->offset = member->offset;
-        alert->size = idr->type_info->size;
-        alert->kind = pr->kind;
-        alert->ranges = ecs_ref_init(world, desc->member, EcsMemberRanges);
-        alert->var_id = var_id;
+        ecs_log_pop();
     }
 
-    ecs_modified(world, result, EcsAlert);
+    /* Restore to previous state */
+    ecs_set_scope(world, old_scope);
+    world->info.name_prefix = old_name_prefix;
 
-    /* Register alert as metric */
-    ecs_add(world, result, EcsMetric);
-    ecs_add_pair(world, result, EcsMetric, EcsCounter);
+    return e;
+error:
+    return 0;
+}
 
-    /* Add severity to alert */
-    ecs_entity_t severity = desc->severity;
-    if (!severity) {
-        severity = EcsAlertError;
-    }
+ecs_entity_t ecs_import_c(
+    ecs_world_t *world,
+    ecs_module_action_t module,
+    const char *c_name)
+{
+    char *name = flecs_module_path_from_c(c_name);
+    ecs_entity_t e = ecs_import(world, module, name);
+    ecs_os_free(name);
+    return e;
+}
 
-    ecs_add_pair(world, result, ecs_id(EcsAlert), severity);
+ecs_entity_t ecs_import_from_library(
+    ecs_world_t *world,
+    const char *library_name,
+    const char *module_name)
+{
+    ecs_check(library_name != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (desc->doc_name) {
-#ifdef FLECS_DOC
-        ecs_doc_set_name(world, result, desc->doc_name);
-#else
-        ecs_err("cannot set doc_name for alert, requires FLECS_DOC addon");
-        goto error;
-#endif
+    char *import_func = ECS_CONST_CAST(char*, module_name);
+    char *module = ECS_CONST_CAST(char*, module_name);
+
+    if (!ecs_os_has_modules() || !ecs_os_has_dl()) {
+        ecs_err(
+            "library loading not supported, set module_to_dl, dlopen, dlclose "
+            "and dlproc os API callbacks first");
+        return 0;
     }
 
-    if (desc->brief) {
-#ifdef FLECS_DOC
-        ecs_doc_set_brief(world, result, desc->brief);
-#else
-        ecs_err("cannot set brief for alert, requires FLECS_DOC addon");
-        goto error;
-#endif
+    /* If no module name is specified, try default naming convention for loading
+     * the main module from the library */
+    if (!import_func) {
+        import_func = ecs_os_malloc(ecs_os_strlen(library_name) + ECS_SIZEOF("Import"));
+        ecs_assert(import_func != NULL, ECS_OUT_OF_MEMORY, NULL);
+        
+        const char *ptr;
+        char ch, *bptr = import_func;
+        bool capitalize = true;
+        for (ptr = library_name; (ch = *ptr); ptr ++) {
+            if (ch == '.') {
+                capitalize = true;
+            } else {
+                if (capitalize) {
+                    *bptr = flecs_ito(char, toupper(ch));
+                    bptr ++;
+                    capitalize = false;
+                } else {
+                    *bptr = flecs_ito(char, tolower(ch));
+                    bptr ++;
+                }
+            }
+        }
+
+        *bptr = '\0';
+
+        module = ecs_os_strdup(import_func);
+        ecs_assert(module != NULL, ECS_OUT_OF_MEMORY, NULL);
+
+        ecs_os_strcat(bptr, "Import");
     }
 
-    return result;
-error:
-    if (result) {
-        ecs_delete(world, result);
+    char *library_filename = ecs_os_module_to_dl(library_name);
+    if (!library_filename) {
+        ecs_err("failed to find library file for '%s'", library_name);
+        if (module != module_name) {
+            ecs_os_free(module);
+        }
+        return 0;
+    } else {
+        ecs_trace("found file '%s' for library '%s'", 
+            library_filename, library_name);
     }
-    return 0;
-}
 
-int32_t ecs_get_alert_count(
-    const ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t alert)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!alert || ecs_has(world, alert, EcsAlert), 
-        ECS_INVALID_PARAMETER, NULL);
+    ecs_os_dl_t dl = ecs_os_dlopen(library_filename);
+    if (!dl) {
+        ecs_err("failed to load library '%s' ('%s')", 
+            library_name, library_filename);
+        
+        ecs_os_free(library_filename);
+
+        if (module != module_name) {
+            ecs_os_free(module);
+        }    
 
-    const EcsAlertsActive *active = ecs_get(world, entity, EcsAlertsActive);
-    if (!active) {
         return 0;
+    } else {
+        ecs_trace("library '%s' ('%s') loaded", 
+            library_name, library_filename);
     }
 
-    if (alert) {
-        return ecs_map_get(&active->alerts, alert) != NULL;
+    ecs_module_action_t action = (ecs_module_action_t)
+        ecs_os_dlproc(dl, import_func);
+    if (!action) {
+        ecs_err("failed to load import function %s from library %s",
+            import_func, library_name);
+        ecs_os_free(library_filename);
+        ecs_os_dlclose(dl);            
+        return 0;
+    } else {
+        ecs_trace("found import function '%s' in library '%s' for module '%s'",
+            import_func, library_name, module);
     }
 
-    return ecs_map_count(&active->alerts);
+    /* Do not free id, as it will be stored as the component identifier */
+    ecs_entity_t result = ecs_import(world, action, module);
+
+    if (import_func != module_name) {
+        ecs_os_free(import_func);
+    }
+
+    if (module != module_name) {
+        ecs_os_free(module);
+    }
+
+    ecs_os_free(library_filename);
+
+    return result;
 error:
     return 0;
 }
 
-ecs_entity_t ecs_get_alert(
-    const ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t alert)
+ecs_entity_t ecs_module_init(
+    ecs_world_t *world,
+    const char *c_name,
+    const ecs_component_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(alert != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    flecs_poly_assert(world, ecs_world_t);
 
-    const EcsAlertsActive *active = ecs_get(world, entity, EcsAlertsActive);
-    if (!active) {
-        return 0;
+    ecs_entity_t old_scope = ecs_set_scope(world, 0);
+
+    ecs_entity_t e = desc->entity;
+    if (!e) {
+        char *module_path = flecs_module_path_from_c(c_name);
+        e = ecs_entity(world, { .name = module_path });
+        ecs_set_symbol(world, e, module_path);
+        ecs_os_free(module_path);
+    } else if (!ecs_exists(world, e)) {
+        char *module_path = flecs_module_path_from_c(c_name);
+        ecs_make_alive(world, e);
+        ecs_add_fullpath(world, e, module_path);
+        ecs_set_symbol(world, e, module_path);
+        ecs_os_free(module_path);
     }
+    
+    ecs_add_id(world, e, EcsModule);
 
-    ecs_entity_t *ptr = ecs_map_get(&active->alerts, alert);
-    if (ptr) {
-        return ptr[0];
+    ecs_component_desc_t private_desc = *desc;
+    private_desc.entity = e;
+
+    if (desc->type.size) {
+        ecs_entity_t result = ecs_component_init(world, &private_desc);
+        ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(result == e, ECS_INTERNAL_ERROR, NULL);
+        (void)result;
     }
 
+    ecs_set_scope(world, old_scope);
+
+    return e;
 error:
     return 0;
 }
 
-void FlecsAlertsImport(ecs_world_t *world) {
-    ECS_MODULE_DEFINE(world, FlecsAlerts);
-
-    ECS_IMPORT(world, FlecsPipeline);
-    ECS_IMPORT(world, FlecsTimer);
-    ECS_IMPORT(world, FlecsMetrics);
-#ifdef FLECS_DOC
-    ECS_IMPORT(world, FlecsDoc);
 #endif
 
-    ecs_set_name_prefix(world, "Ecs");
-    ECS_COMPONENT_DEFINE(world, EcsAlert);
-    ecs_remove_pair(world, ecs_id(EcsAlert), ecs_id(EcsIdentifier), EcsSymbol);
-    ECS_COMPONENT_DEFINE(world, EcsAlertsActive);
+/**
+ * @file addons/monitor.c
+ * @brief Monitor addon.
+ */
 
-    ecs_set_name_prefix(world, "EcsAlert");
-    ECS_COMPONENT_DEFINE(world, EcsAlertInstance);
-    ECS_COMPONENT_DEFINE(world, EcsAlertTimeout);
 
-    ECS_TAG_DEFINE(world, EcsAlertInfo);
-    ECS_TAG_DEFINE(world, EcsAlertWarning);
-    ECS_TAG_DEFINE(world, EcsAlertError);
-    ECS_TAG_DEFINE(world, EcsAlertCritical);
+#ifdef FLECS_MONITOR
 
-    ecs_add_id(world, ecs_id(EcsAlert), EcsTag);
-    ecs_add_id(world, ecs_id(EcsAlert), EcsExclusive);
-    ecs_add_id(world, ecs_id(EcsAlertsActive), EcsPrivate);
+ECS_COMPONENT_DECLARE(FlecsMonitor);
+ECS_COMPONENT_DECLARE(EcsWorldStats);
+ECS_COMPONENT_DECLARE(EcsWorldSummary);
+ECS_COMPONENT_DECLARE(EcsPipelineStats);
 
-    ecs_struct(world, {
-        .entity = ecs_id(EcsAlertInstance),
-        .members = {
-            { .name = "message", .type = ecs_id(ecs_string_t) }
-        }
-    });
+ecs_entity_t EcsPeriod1s = 0;
+ecs_entity_t EcsPeriod1m = 0;
+ecs_entity_t EcsPeriod1h = 0;
+ecs_entity_t EcsPeriod1d = 0;
+ecs_entity_t EcsPeriod1w = 0;
 
-    ecs_set_hooks(world, EcsAlert, {
-        .ctor = ecs_ctor(EcsAlert),
-        .dtor = ecs_dtor(EcsAlert),
-        .move = ecs_move(EcsAlert)
-    });
+static int32_t flecs_day_interval_count = 24;
+static int32_t flecs_week_interval_count = 168;
 
-    ecs_set_hooks(world, EcsAlertsActive, {
-        .ctor = ecs_ctor(EcsAlertsActive),
-        .dtor = ecs_dtor(EcsAlertsActive),
-        .move = ecs_move(EcsAlertsActive)
-    });
+static
+ECS_COPY(EcsPipelineStats, dst, src, {
+    (void)dst;
+    (void)src;
+    ecs_abort(ECS_INVALID_OPERATION, "cannot copy pipeline stats component");
+})
 
-    ecs_set_hooks(world, EcsAlertInstance, {
-        .ctor = ecs_default_ctor,
-        .dtor = ecs_dtor(EcsAlertInstance),
-        .move = ecs_move(EcsAlertInstance),
-        .copy = ecs_copy(EcsAlertInstance)
-    });
+static
+ECS_MOVE(EcsPipelineStats, dst, src, {
+    ecs_os_memcpy_t(dst, src, EcsPipelineStats);
+    ecs_os_zeromem(src);
+})
 
-    ecs_struct(world, {
-        .entity = ecs_id(EcsAlertsActive),
-        .members = {
-            { .name = "info_count", .type = ecs_id(ecs_i32_t) },
-            { .name = "warning_count", .type = ecs_id(ecs_i32_t) },
-            { .name = "error_count", .type = ecs_id(ecs_i32_t) }
-        }
-    });
+static
+ECS_DTOR(EcsPipelineStats, ptr, {
+    ecs_pipeline_stats_fini(&ptr->stats);
+})
 
-    ECS_SYSTEM(world, MonitorAlerts, EcsPreStore, Alert, (Poly, Query));
-    ECS_SYSTEM(world, MonitorAlertInstances, EcsOnStore, Instance, 
-        flecs.metrics.Source, flecs.metrics.Value, ?EcsAlertTimeout, ?Disabled);
+static
+void UpdateWorldSummary(ecs_iter_t *it) {
+    EcsWorldSummary *summary = ecs_field(it, EcsWorldSummary, 0);
 
-    ecs_system(world, {
-        .entity = ecs_id(MonitorAlerts),
-        .no_readonly = true,
-        .interval = (ecs_ftime_t)0.5
-    });
+    const ecs_world_info_t *info = ecs_get_world_info(it->world);
 
-    ecs_system(world, {
-        .entity = ecs_id(MonitorAlertInstances),
-        .interval = (ecs_ftime_t)0.5
-    });
-}
+    int32_t i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        summary[i].target_fps = (double)info->target_fps;
 
-#endif
+        summary[i].frame_time_last = (double)info->frame_time_total - summary[i].frame_time_total;
+        summary[i].system_time_last = (double)info->system_time_total - summary[i].system_time_total;
+        summary[i].merge_time_last = (double)info->merge_time_total - summary[i].merge_time_total;
 
-/**
- * @file addons/app.c
- * @brief App addon.
- */
+        summary[i].frame_time_total = (double)info->frame_time_total;
+        summary[i].system_time_total = (double)info->system_time_total;
+        summary[i].merge_time_total = (double)info->merge_time_total;
 
+        summary[i].frame_count ++;
+        summary[i].command_count +=
+            info->cmd.add_count +
+            info->cmd.remove_count +
+            info->cmd.delete_count +
+            info->cmd.clear_count +
+            info->cmd.set_count +
+            info->cmd.ensure_count +
+            info->cmd.modified_count +
+            info->cmd.discard_count +
+            info->cmd.event_count +
+            info->cmd.other_count;
 
-#ifdef FLECS_APP
+        summary[i].build_info = *ecs_get_build_info();
+    }
+}
 
 static
-int flecs_default_run_action(
-    ecs_world_t *world,
-    ecs_app_desc_t *desc)
-{
-    if (desc->init) {
-        desc->init(world);
+void MonitorStats(ecs_iter_t *it) {
+    ecs_world_t *world = it->real_world;
+
+    EcsStatsHeader *hdr = ecs_field_w_size(it, 0, 0);
+    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 0));
+    void *stats = ECS_OFFSET_T(hdr, EcsStatsHeader);
+
+    ecs_ftime_t elapsed = hdr->elapsed;
+    hdr->elapsed += it->delta_time;
+
+    int32_t t_last = (int32_t)(elapsed * 60);
+    int32_t t_next = (int32_t)(hdr->elapsed * 60);
+    int32_t i, dif = t_last - t_next;
+
+    ecs_world_stats_t last_world = {0};
+    ecs_pipeline_stats_t last_pipeline = {0};
+    void *last = NULL;
+
+    if (!dif) {
+        /* Copy last value so we can pass it to reduce_last */
+        if (kind == ecs_id(EcsWorldStats)) {
+            last = &last_world;
+            ecs_world_stats_copy_last(&last_world, stats);
+        } else if (kind == ecs_id(EcsPipelineStats)) {
+            last = &last_pipeline;
+            ecs_pipeline_stats_copy_last(&last_pipeline, stats);
+        }
     }
 
-    int result = 0;
-    if (desc->frames) {
-        int32_t i;
-        for (i = 0; i < desc->frames; i ++) {
-            if ((result = ecs_app_run_frame(world, desc)) != 0) {
-                break;
+    if (kind == ecs_id(EcsWorldStats)) {
+        ecs_world_stats_get(world, stats);
+    } else if (kind == ecs_id(EcsPipelineStats)) {
+        ecs_pipeline_stats_get(world, ecs_get_pipeline(world), stats);
+    }
+
+    if (!dif) {
+        /* Still in same interval, combine with last measurement */
+        hdr->reduce_count ++;
+        if (kind == ecs_id(EcsWorldStats)) {
+            ecs_world_stats_reduce_last(stats, last, hdr->reduce_count);
+        } else if (kind == ecs_id(EcsPipelineStats)) {
+            ecs_pipeline_stats_reduce_last(stats, last, hdr->reduce_count);
+        }
+    } else if (dif > 1) {
+        /* More than 16ms has passed, backfill */
+        for (i = 1; i < dif; i ++) {
+            if (kind == ecs_id(EcsWorldStats)) {
+                ecs_world_stats_repeat_last(stats);
+            } else if (kind == ecs_id(EcsPipelineStats)) {
+                ecs_world_stats_repeat_last(stats);
             }
         }
-    } else {
-        while ((result = ecs_app_run_frame(world, desc)) == 0) { }
+        hdr->reduce_count = 0;
     }
 
-    /* Ensure quit flag is set on world, which can be used to determine if
-     * world needs to be cleaned up. */
-#ifndef __EMSCRIPTEN__
-    ecs_quit(world);
-#endif
-
-    if (result == 1) {
-        return 0; /* Normal exit */
-    } else {
-        return result; /* Error code */
+    if (last && kind == ecs_id(EcsPipelineStats)) {
+        ecs_pipeline_stats_fini(last);
     }
 }
 
 static
-int flecs_default_frame_action(
-    ecs_world_t *world,
-    const ecs_app_desc_t *desc)
-{
-    return !ecs_progress(world, desc->delta_time);
+void ReduceStats(ecs_iter_t *it) {
+    void *dst = ecs_field_w_size(it, 0, 0);
+    void *src = ecs_field_w_size(it, 0, 1);
+
+    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 0));
+
+    dst = ECS_OFFSET_T(dst, EcsStatsHeader);
+    src = ECS_OFFSET_T(src, EcsStatsHeader);
+
+    if (kind == ecs_id(EcsWorldStats)) {
+        ecs_world_stats_reduce(dst, src);
+    } else if (kind == ecs_id(EcsPipelineStats)) {
+        ecs_pipeline_stats_reduce(dst, src);
+    }
 }
 
-static ecs_app_run_action_t run_action = flecs_default_run_action;
-static ecs_app_frame_action_t frame_action = flecs_default_frame_action;
-static ecs_app_desc_t ecs_app_desc;
+static
+void AggregateStats(ecs_iter_t *it) {
+    int32_t interval = *(int32_t*)it->ctx;
 
-/* Serve REST API from wasm image when running in emscripten */
-#ifdef ECS_TARGET_EM
-#include <emscripten.h>
+    EcsStatsHeader *dst_hdr = ecs_field_w_size(it, 0, 0);
+    EcsStatsHeader *src_hdr = ecs_field_w_size(it, 0, 1);
 
-ecs_http_server_t *flecs_wasm_rest_server;
+    void *dst = ECS_OFFSET_T(dst_hdr, EcsStatsHeader);
+    void *src = ECS_OFFSET_T(src_hdr, EcsStatsHeader);
 
-EMSCRIPTEN_KEEPALIVE
-char* flecs_explorer_request(const char *method, char *request) {
-    ecs_http_reply_t reply = ECS_HTTP_REPLY_INIT;
-    ecs_http_server_request(flecs_wasm_rest_server, method, request, &reply);
-    if (reply.code == 200) {
-        return ecs_strbuf_get(&reply.body);
-    } else {
-        char *body = ecs_strbuf_get(&reply.body);
-        if (body) {
-            return body;
-        } else {
-            return ecs_asprintf(
-                "{\"error\": \"bad request (code %d)\"}", reply.code);
+    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 0));
+
+    ecs_world_stats_t last_world = {0};
+    ecs_pipeline_stats_t last_pipeline = {0};
+    void *last = NULL;
+
+    if (dst_hdr->reduce_count != 0) {
+        /* Copy last value so we can pass it to reduce_last */
+        if (kind == ecs_id(EcsWorldStats)) {
+            last_world.t = 0;
+            ecs_world_stats_copy_last(&last_world, dst);
+            last = &last_world;
+        } else if (kind == ecs_id(EcsPipelineStats)) {
+            last_pipeline.t = 0;
+            ecs_pipeline_stats_copy_last(&last_pipeline, dst);
+            last = &last_pipeline;
         }
     }
-}
-#endif
 
-int ecs_app_run(
-    ecs_world_t *world,
-    ecs_app_desc_t *desc)
-{
-    ecs_app_desc = *desc;
+    /* Reduce from minutes to the current day */
+    if (kind == ecs_id(EcsWorldStats)) {
+        ecs_world_stats_reduce(dst, src);
+    } else if (kind == ecs_id(EcsPipelineStats)) {
+        ecs_pipeline_stats_reduce(dst, src);
+    }
 
-    /* Don't set FPS & threads if custom run action is set, as the platform on
-     * which the app is running may not support it. */
-    if (run_action == flecs_default_run_action) {
-        if (ECS_NEQZERO(ecs_app_desc.target_fps)) {
-            ecs_set_target_fps(world, ecs_app_desc.target_fps);
-        }
-        if (ecs_app_desc.threads) {
-            ecs_set_threads(world, ecs_app_desc.threads);
+    if (dst_hdr->reduce_count != 0) {
+        if (kind == ecs_id(EcsWorldStats)) {
+            ecs_world_stats_reduce_last(dst, last, dst_hdr->reduce_count);
+        } else if (kind == ecs_id(EcsPipelineStats)) {
+            ecs_pipeline_stats_reduce_last(dst, last, dst_hdr->reduce_count);
         }
     }
 
-    /* REST server enables connecting to app with explorer */
-    if (desc->enable_rest) {
-#ifdef FLECS_REST
-#ifdef ECS_TARGET_EM
-        flecs_wasm_rest_server = ecs_rest_server_init(world, NULL);
-#else
-        ecs_set(world, EcsWorld, EcsRest, {.port = desc->port });
-#endif
-#else
-        ecs_warn("cannot enable remote API, REST addon not available");
-#endif
+    /* A day has 60 24 minute intervals */
+    dst_hdr->reduce_count ++;
+    if (dst_hdr->reduce_count >= interval) {
+        dst_hdr->reduce_count = 0;
     }
 
-    /* Monitoring periodically collects statistics */
-    if (desc->enable_monitor) {
-#ifdef FLECS_MONITOR
-        ECS_IMPORT(world, FlecsMonitor);
-#else
-        ecs_warn("cannot enable monitoring, MONITOR addon not available");
-#endif
+    if (last && kind == ecs_id(EcsPipelineStats)) {
+        ecs_pipeline_stats_fini(last);
     }
-
-    return run_action(world, &ecs_app_desc);
 }
 
-int ecs_app_run_frame(
+static
+void flecs_stats_monitor_import(
     ecs_world_t *world,
-    const ecs_app_desc_t *desc)
-{
-    return frame_action(world, desc);
-}
-
-int ecs_app_set_run_action(
-    ecs_app_run_action_t callback)
+    ecs_id_t kind)
 {
-    if (run_action != flecs_default_run_action && run_action != callback) {
-        ecs_err("run action already set");
-        return -1;
-    }
+    ecs_entity_t prev = ecs_set_scope(world, kind);
 
-    run_action = callback;
+    // Called each frame, collects 60 measurements per second
+    ecs_system(world, {
+        .entity = ecs_entity(world, { .name = "Monitor1s", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
+            .id = ecs_pair(kind, EcsPeriod1s),
+            .src.id = EcsWorld 
+        }},
+        .callback = MonitorStats
+    });
 
-    return 0;
+    // Called each second, reduces into 60 measurements per minute
+    ecs_entity_t mw1m = ecs_system(world, {
+        .entity = ecs_entity(world, { .name = "Monitor1m", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
+            .id = ecs_pair(kind, EcsPeriod1m),
+            .src.id = EcsWorld 
+        }, {
+            .id = ecs_pair(kind, EcsPeriod1s),
+            .src.id = EcsWorld 
+        }},
+        .callback = ReduceStats,
+        .interval = 1.0
+    });
+
+    // Called each minute, reduces into 60 measurements per hour
+    ecs_system(world, {
+        .entity = ecs_entity(world, { .name = "Monitor1h", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
+            .id = ecs_pair(kind, EcsPeriod1h),
+            .src.id = EcsWorld 
+        }, {
+            .id = ecs_pair(kind, EcsPeriod1m),
+            .src.id = EcsWorld 
+        }},
+        .callback = ReduceStats,
+        .rate = 60,
+        .tick_source = mw1m
+    });
+
+    // Called each minute, reduces into 60 measurements per day
+    ecs_system(world, {
+        .entity = ecs_entity(world, { .name = "Monitor1d", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
+            .id = ecs_pair(kind, EcsPeriod1d),
+            .src.id = EcsWorld 
+        }, {
+            .id = ecs_pair(kind, EcsPeriod1m),
+            .src.id = EcsWorld 
+        }},
+        .callback = AggregateStats,
+        .rate = 60,
+        .tick_source = mw1m,
+        .ctx = &flecs_day_interval_count
+    });
+
+    // Called each hour, reduces into 60 measurements per week
+    ecs_system(world, {
+        .entity = ecs_entity(world, { .name = "Monitor1w", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
+            .id = ecs_pair(kind, EcsPeriod1w),
+            .src.id = EcsWorld 
+        }, {
+            .id = ecs_pair(kind, EcsPeriod1h),
+            .src.id = EcsWorld 
+        }},
+        .callback = AggregateStats,
+        .rate = 60,
+        .tick_source = mw1m,
+        .ctx = &flecs_week_interval_count
+    });
+
+    ecs_set_scope(world, prev);
+
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1s);
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1m);
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1h);
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1d);
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1w);
 }
 
-int ecs_app_set_frame_action(
-    ecs_app_frame_action_t callback)
+static
+void flecs_world_monitor_import(
+    ecs_world_t *world)
 {
-    if (frame_action != flecs_default_frame_action && frame_action != callback) {
-        ecs_err("frame action already set");
-        return -1;
-    }
+    ECS_COMPONENT_DEFINE(world, EcsWorldStats);
 
-    frame_action = callback;
+    ecs_set_hooks(world, EcsWorldStats, {
+        .ctor = flecs_default_ctor
+    });
 
-    return 0;
+    flecs_stats_monitor_import(world, ecs_id(EcsWorldStats));
+}
+
+static
+void flecs_pipeline_monitor_import(
+    ecs_world_t *world)
+{
+    ECS_COMPONENT_DEFINE(world, EcsPipelineStats);
+
+    ecs_set_hooks(world, EcsPipelineStats, {
+        .ctor = flecs_default_ctor,
+        .copy = ecs_copy(EcsPipelineStats),
+        .move = ecs_move(EcsPipelineStats),
+        .dtor = ecs_dtor(EcsPipelineStats)
+    });
+
+    flecs_stats_monitor_import(world, ecs_id(EcsPipelineStats));
+}
+
+void FlecsMonitorImport(
+    ecs_world_t *world)
+{
+    ECS_MODULE_DEFINE(world, FlecsMonitor);
+    ECS_IMPORT(world, FlecsPipeline);
+    ECS_IMPORT(world, FlecsTimer);
+#ifdef FLECS_META
+    ECS_IMPORT(world, FlecsMeta);
+#endif
+#ifdef FLECS_UNITS
+    ECS_IMPORT(world, FlecsUnits);
+#endif
+#ifdef FLECS_DOC
+    ECS_IMPORT(world, FlecsDoc);
+    ecs_doc_set_brief(world, ecs_id(FlecsMonitor), 
+        "Module that automatically monitors statistics for the world & systems");
+#endif
+
+    ecs_set_name_prefix(world, "Ecs");
+
+    EcsPeriod1s = ecs_entity(world, { .name = "EcsPeriod1s" });
+    EcsPeriod1m = ecs_entity(world, { .name = "EcsPeriod1m" });
+    EcsPeriod1h = ecs_entity(world, { .name = "EcsPeriod1h" });
+    EcsPeriod1d = ecs_entity(world, { .name = "EcsPeriod1d" });
+    EcsPeriod1w = ecs_entity(world, { .name = "EcsPeriod1w" });
+
+    ECS_COMPONENT_DEFINE(world, EcsWorldSummary);
+
+#if defined(FLECS_META) && defined(FLECS_UNITS) 
+    ecs_entity_t build_info = ecs_lookup(world, "flecs.core.build_info_t");
+    ecs_struct(world, {
+        .entity = ecs_id(EcsWorldSummary),
+        .members = {
+            { .name = "target_fps", .type = ecs_id(ecs_f64_t), .unit = EcsHertz },
+            { .name = "frame_time_total", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds },
+            { .name = "system_time_total", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
+            { .name = "merge_time_total", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
+            { .name = "frame_time_last", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
+            { .name = "system_time_last", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
+            { .name = "merge_time_last", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
+            { .name = "frame_count", .type = ecs_id(ecs_u64_t) },
+            { .name = "command_count", .type = ecs_id(ecs_u64_t) },
+            { .name = "build_info", .type = build_info }
+        }
+    });
+#endif
+
+    ecs_system(world, {
+        .entity = ecs_entity(world, { 
+            .name = "UpdateWorldSummary", 
+            .add = ecs_ids(ecs_dependson(EcsPreFrame)) 
+        }),
+        .query.terms[0] = { .id = ecs_id(EcsWorldSummary) },
+        .callback = UpdateWorldSummary
+    });
+
+    ECS_SYSTEM(world, UpdateWorldSummary, EcsPreFrame, WorldSummary);
+    ecs_set(world, EcsWorld, EcsWorldSummary, {0});
+
+    flecs_world_monitor_import(world);
+    flecs_pipeline_monitor_import(world);
+    
+    if (ecs_os_has_time()) {
+        ecs_measure_frame_time(world, true);
+        ecs_measure_system_time(world, true);
+    }
 }
 
 #endif
 
 /**
- * @file addons/doc.c
- * @brief Doc addon.
+ * @file addons/rest.c
+ * @brief Rest addon.
  */
 
 
-#ifdef FLECS_DOC
+#ifdef FLECS_REST
 
-static ECS_COPY(EcsDocDescription, dst, src, {
-    ecs_os_strset((char**)&dst->value, src->value);
+/* Retain captured commands for one minute at 60 FPS */
+#define FLECS_REST_COMMAND_RETAIN_COUNT (60 * 60)
+
+static ECS_TAG_DECLARE(EcsRestPlecs);
+
+typedef struct {
+    ecs_world_t *world;
+    ecs_http_server_t *srv;
+    int32_t rc;
+    ecs_map_t cmd_captures;
+} ecs_rest_ctx_t;
+
+typedef struct {
+    char *cmds;
+    ecs_time_t start_time;
+    ecs_strbuf_t buf;
+} ecs_rest_cmd_sync_capture_t;
 
+typedef struct {
+    ecs_vec_t syncs;
+} ecs_rest_cmd_capture_t;
+
+static ECS_COPY(EcsRest, dst, src, {
+    ecs_rest_ctx_t *impl = src->impl;
+    if (impl) {
+        impl->rc ++;
+    }
+
+    ecs_os_strset(&dst->ipaddr, src->ipaddr);
+    dst->port = src->port;
+    dst->impl = impl;
 })
 
-static ECS_MOVE(EcsDocDescription, dst, src, {
-    ecs_os_free((char*)dst->value);
-    dst->value = src->value;
-    src->value = NULL;
+static ECS_MOVE(EcsRest, dst, src, {
+    *dst = *src;
+    src->ipaddr = NULL;
+    src->impl = NULL;
 })
 
-static ECS_DTOR(EcsDocDescription, ptr, { 
-    ecs_os_free((char*)ptr->value);
+static ECS_DTOR(EcsRest, ptr, { 
+    ecs_rest_ctx_t *impl = ptr->impl;
+    if (impl) {
+        impl->rc --;
+        if (!impl->rc) {
+            ecs_rest_server_fini(impl->srv);
+        }
+    }
+    ecs_os_free(ptr->ipaddr);
 })
 
-static
-void flecs_doc_set(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_entity_t kind,
-    const char *value)
+static char *rest_last_err;
+static ecs_os_api_log_t rest_prev_log;
+
+static 
+void flecs_rest_capture_log(
+    int32_t level, 
+    const char *file,
+    int32_t line, 
+    const char *msg)
 {
-    if (value) {
-        ecs_set_pair(world, entity, EcsDocDescription, kind, {
-            /* Safe, value gets copied by copy hook */
-            .value = ECS_CONST_CAST(char*, value)
-        });
-    } else {
-        ecs_remove_pair(world, entity, ecs_id(EcsDocDescription), kind);
+    (void)file; (void)line;
+
+#ifdef FLECS_DEBUG
+    if (level < 0) {
+        /* Also log to previous log function in debug mode */
+        if (rest_prev_log) {
+            ecs_log_enable_colors(true);
+            rest_prev_log(level, file, line, msg);
+            ecs_log_enable_colors(false);
+        }
+    }
+#endif
+
+    if (!rest_last_err && level < 0) {
+        rest_last_err = ecs_os_strdup(msg);
     }
 }
 
-void ecs_doc_set_name(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *name)
-{
-    flecs_doc_set(world, entity, EcsName, name);
+static
+char* flecs_rest_get_captured_log(void) {
+    char *result = rest_last_err;
+    rest_last_err = NULL;
+    return result;
 }
 
-void ecs_doc_set_brief(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *brief)
+static
+void flecs_reply_verror(
+    ecs_http_reply_t *reply,
+    const char *fmt,
+    va_list args)
 {
-    flecs_doc_set(world, entity, EcsDocBrief, brief);
+    ecs_strbuf_appendlit(&reply->body, "{\"error\":\"");
+    ecs_strbuf_vappend(&reply->body, fmt, args);
+    ecs_strbuf_appendlit(&reply->body, "\"}");
 }
 
-void ecs_doc_set_detail(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *detail)
+static
+void flecs_reply_error(
+    ecs_http_reply_t *reply,
+    const char *fmt,
+    ...)
 {
-    flecs_doc_set(world, entity, EcsDocDetail, detail);
+    va_list args;
+    va_start(args, fmt);
+    flecs_reply_verror(reply, fmt, args);
+    va_end(args);
 }
 
-void ecs_doc_set_link(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *link)
+static
+void flecs_rest_bool_param(
+    const ecs_http_request_t *req,
+    const char *name,
+    bool *value_out)
 {
-    flecs_doc_set(world, entity, EcsDocLink, link);
+    const char *value = ecs_http_get_param(req, name);
+    if (value) {
+        if (!ecs_os_strcmp(value, "true")) {
+            value_out[0] = true;
+        } else {
+            value_out[0] = false;
+        }
+    }
 }
 
-void ecs_doc_set_color(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *color)
+static
+void flecs_rest_int_param(
+    const ecs_http_request_t *req,
+    const char *name,
+    int32_t *value_out)
 {
-    flecs_doc_set(world, entity, EcsDocColor, color);
+    const char *value = ecs_http_get_param(req, name);
+    if (value) {
+        *value_out = atoi(value);
+    }
 }
 
-const char* ecs_doc_get_name(
-    const ecs_world_t *world,
-    ecs_entity_t entity)
+static
+void flecs_rest_string_param(
+    const ecs_http_request_t *req,
+    const char *name,
+    char **value_out)
 {
-    const EcsDocDescription *ptr = ecs_get_pair(
-        world, entity, EcsDocDescription, EcsName);
-    if (ptr) {
-        return ptr->value;
-    } else {
-        return ecs_get_name(world, entity);
+    const char *value = ecs_http_get_param(req, name);
+    if (value) {
+        *value_out = ECS_CONST_CAST(char*, value);
     }
 }
 
-const char* ecs_doc_get_brief(
-    const ecs_world_t *world,
-    ecs_entity_t entity)
+static
+void flecs_rest_parse_json_ser_entity_params(
+    ecs_world_t *world,
+    ecs_entity_to_json_desc_t *desc,
+    const ecs_http_request_t *req)
 {
-    const EcsDocDescription *ptr = ecs_get_pair(
-        world, entity, EcsDocDescription, EcsDocBrief);
-    if (ptr) {
-        return ptr->value;
-    } else {
-        return NULL;
+    flecs_rest_bool_param(req, "path", &desc->serialize_path);
+    flecs_rest_bool_param(req, "label", &desc->serialize_label);
+    flecs_rest_bool_param(req, "brief", &desc->serialize_brief);
+    flecs_rest_bool_param(req, "link", &desc->serialize_link);
+    flecs_rest_bool_param(req, "color", &desc->serialize_color);
+    flecs_rest_bool_param(req, "ids", &desc->serialize_ids);
+    flecs_rest_bool_param(req, "id_labels", &desc->serialize_id_labels);
+    flecs_rest_bool_param(req, "base", &desc->serialize_base);
+    flecs_rest_bool_param(req, "values", &desc->serialize_values);
+    flecs_rest_bool_param(req, "private", &desc->serialize_private);
+    flecs_rest_bool_param(req, "type_info", &desc->serialize_type_info);
+    flecs_rest_bool_param(req, "matches", &desc->serialize_matches);
+    flecs_rest_bool_param(req, "alerts", &desc->serialize_alerts);
+
+    char *rel = NULL;
+    flecs_rest_string_param(req, "refs", &rel);
+    if (rel) {
+        desc->serialize_refs = ecs_lookup(world, rel);
     }
 }
 
-const char* ecs_doc_get_detail(
-    const ecs_world_t *world,
-    ecs_entity_t entity)
+static
+void flecs_rest_parse_json_ser_iter_params(
+    ecs_iter_to_json_desc_t *desc,
+    const ecs_http_request_t *req)
 {
-    const EcsDocDescription *ptr = ecs_get_pair(
-        world, entity, EcsDocDescription, EcsDocDetail);
-    if (ptr) {
-        return ptr->value;
-    } else {
-        return NULL;
-    }
+    flecs_rest_bool_param(req, "term_ids", &desc->serialize_term_ids);
+    flecs_rest_bool_param(req, "term_labels", &desc->serialize_term_labels);
+    flecs_rest_bool_param(req, "ids", &desc->serialize_ids);
+    flecs_rest_bool_param(req, "id_labels", &desc->serialize_id_labels);
+    flecs_rest_bool_param(req, "sources", &desc->serialize_sources);
+    flecs_rest_bool_param(req, "variables", &desc->serialize_variables);
+    flecs_rest_bool_param(req, "is_set", &desc->serialize_is_set);
+    flecs_rest_bool_param(req, "values", &desc->serialize_values);
+    flecs_rest_bool_param(req, "private", &desc->serialize_private);
+    flecs_rest_bool_param(req, "entities", &desc->serialize_entities);
+    flecs_rest_bool_param(req, "entity_labels", &desc->serialize_entity_labels);
+    flecs_rest_bool_param(req, "variable_labels", &desc->serialize_variable_labels);
+    flecs_rest_bool_param(req, "variable_ids", &desc->serialize_variable_ids);
+    flecs_rest_bool_param(req, "colors", &desc->serialize_colors);
+    flecs_rest_bool_param(req, "duration", &desc->measure_eval_duration);
+    flecs_rest_bool_param(req, "type_info", &desc->serialize_type_info);
+    flecs_rest_bool_param(req, "field_info", &desc->serialize_field_info);
+    flecs_rest_bool_param(req, "query_info", &desc->serialize_query_info);
+    flecs_rest_bool_param(req, "query_plan", &desc->serialize_query_plan);
+    flecs_rest_bool_param(req, "query_profile", &desc->serialize_query_profile);
+    flecs_rest_bool_param(req, "table", &desc->serialize_table);
+    flecs_rest_bool_param(req, "rows", &desc->serialize_rows);
+    bool results = true;
+    flecs_rest_bool_param(req, "results", &results);
+    desc->dont_serialize_results = !results;
 }
 
-const char* ecs_doc_get_link(
-    const ecs_world_t *world,
-    ecs_entity_t entity)
+static
+bool flecs_rest_reply_entity(
+    ecs_world_t *world,
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply)
 {
-    const EcsDocDescription *ptr = ecs_get_pair(
-        world, entity, EcsDocDescription, EcsDocLink);
-    if (ptr) {
-        return ptr->value;
-    } else {
-        return NULL;
+    char *path = &req->path[7];
+    ecs_dbg_2("rest: request entity '%s'", path);
+
+    ecs_entity_t e = ecs_lookup_path_w_sep(
+        world, 0, path, "/", NULL, false);
+    if (!e) {
+        ecs_dbg_2("rest: entity '%s' not found", path);
+        flecs_reply_error(reply, "entity '%s' not found", path);
+        reply->code = 404;
+        return true;
+    }
+
+    ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
+    flecs_rest_parse_json_ser_entity_params(world, &desc, req);
+    if (ecs_entity_to_json_buf(world, e, &reply->body, &desc) != 0) {
+        ecs_strbuf_reset(&reply->body);
+        reply->code = 500;
+        reply->status = "Internal server error";
+        return true;
     }
+    return true;
 }
 
-const char* ecs_doc_get_color(
-    const ecs_world_t *world,
-    ecs_entity_t entity)
+static
+bool flecs_rest_reply_world(
+    ecs_world_t *world,
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply)
 {
-    const EcsDocDescription *ptr = ecs_get_pair(
-        world, entity, EcsDocDescription, EcsDocColor);
-    if (ptr) {
-        return ptr->value;
-    } else {
-        return NULL;
+    (void)req;
+    if (ecs_world_to_json_buf(world, &reply->body, NULL) != 0) {
+        ecs_strbuf_reset(&reply->body);
+        reply->code = 500;
+        reply->status = "Internal server error";
+        return true;
     }
+    return true;
 }
 
-/* Doc definitions for core components */
 static
-void flecs_doc_import_core_definitions(
-    ecs_world_t *world)
+ecs_entity_t flecs_rest_entity_from_path(
+    ecs_world_t *world,
+    ecs_http_reply_t *reply,
+    const char *path)
 {
-    ecs_doc_set_brief(world, EcsFlecs, "Flecs root module");
-    ecs_doc_set_link(world, EcsFlecs, "https://github.com/SanderMertens/flecs");
-    ecs_doc_set_brief(world, EcsFlecsCore, "Module with builtin components");
-    ecs_doc_set_brief(world, EcsFlecsInternals, "Module with internal entities");
+    ecs_entity_t e = ecs_lookup_path_w_sep(
+        world, 0, path, "/", NULL, false);
+    if (!e) {
+        flecs_reply_error(reply, "entity '%s' not found", path);
+        reply->code = 404;
+    }
+    return e;
+}
 
-    ecs_doc_set_brief(world, EcsWorld, "Entity associated with world");
+static
+bool flecs_rest_set(
+    ecs_world_t *world,
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply,
+    const char *path)
+{
+    ecs_entity_t e;
+    if (!(e = flecs_rest_entity_from_path(world, reply, path))) {
+        return true;
+    }
 
-    ecs_doc_set_brief(world, ecs_id(EcsComponent), "Component that is added to components");
-    ecs_doc_set_brief(world, EcsModule, "Tag that is added to modules");
-    ecs_doc_set_brief(world, EcsPrefab, "Tag that is added to prefabs");
-    ecs_doc_set_brief(world, EcsDisabled, "Tag that is added to disabled entities");
-    ecs_doc_set_brief(world, EcsPrivate, "Tag that is added to private components");
-    ecs_doc_set_brief(world, EcsFlag, "Internal tag for tracking ids with special id flags");
-    ecs_doc_set_brief(world, ecs_id(EcsIterable), "Internal component to make (query) entities iterable");
-    ecs_doc_set_brief(world, ecs_id(EcsPoly), "Internal component that stores pointer to poly objects");
+    const char *data = ecs_http_get_param(req, "data");
+    ecs_from_json_desc_t desc = {0};
+    desc.expr = data;
+    desc.name = path;
+    if (ecs_entity_from_json(world, e, data, &desc) == NULL) {
+        flecs_reply_error(reply, "invalid request");
+        reply->code = 400;
+        return true;
+    }
     
-    ecs_doc_set_brief(world, ecs_id(EcsFlattenTarget), "Internal component that stores information for flattened trees");
-    ecs_doc_set_brief(world, EcsFlatten, "Tag that when added to assembly automatically flattens tree");
+    return true;
+}
 
-    ecs_doc_set_brief(world, ecs_id(EcsIdentifier), "Component used for entity names");
-    ecs_doc_set_brief(world, EcsName, "Tag used with EcsIdentifier to store entity name");
-    ecs_doc_set_brief(world, EcsSymbol, "Tag used with EcsIdentifier to store entity symbol");
-    ecs_doc_set_brief(world, EcsAlias, "Tag used with EcsIdentifier to store entity alias");
-    
-    ecs_doc_set_brief(world, EcsQuery, "Tag added to query entities");
-    ecs_doc_set_brief(world, EcsObserver, "Tag added to observer entities");
-
-    ecs_doc_set_brief(world, EcsTransitive, "Trait that enables transitive evaluation of relationships");
-    ecs_doc_set_brief(world, EcsReflexive, "Trait that enables reflexive evaluation of relationships");
-    ecs_doc_set_brief(world, EcsFinal, "Trait that indicates an entity cannot be inherited from");
-    ecs_doc_set_brief(world, EcsDontInherit, "Trait that indicates it should not be inherited");
-    ecs_doc_set_brief(world, EcsTag, "Trait that ensures a pair cannot contain a value");
-    ecs_doc_set_brief(world, EcsAcyclic, "Trait that indicates a relationship is acyclic");
-    ecs_doc_set_brief(world, EcsTraversable, "Trait that indicates a relationship is traversable");
-    ecs_doc_set_brief(world, EcsExclusive, "Trait that ensures a relationship can only have one target");
-    ecs_doc_set_brief(world, EcsSymmetric, "Trait that causes a relationship to be two-way");
-    ecs_doc_set_brief(world, EcsWith, "Trait for adding additional components when a component is added");
-    ecs_doc_set_brief(world, EcsAlwaysOverride, "Trait that indicates a component should always be overridden");
-    ecs_doc_set_brief(world, EcsUnion, "Trait for creating a non-fragmenting relationship");
-    ecs_doc_set_brief(world, EcsOneOf, "Trait that enforces target of relationship is a child of <specified>");
-    ecs_doc_set_brief(world, EcsOnDelete, "Cleanup trait for specifying what happens when component is deleted");
-    ecs_doc_set_brief(world, EcsOnDeleteTarget, "Cleanup trait for specifying what happens when pair target is deleted");
-    ecs_doc_set_brief(world, EcsRemove, "Cleanup action used with OnDelete/OnDeleteTarget");
-    ecs_doc_set_brief(world, EcsDelete, "Cleanup action used with OnDelete/OnDeleteTarget");
-    ecs_doc_set_brief(world, EcsPanic, "Cleanup action used with OnDelete/OnDeleteTarget");
-    ecs_doc_set_brief(world, EcsDefaultChildComponent, "Sets default component hint for children of entity");
-    ecs_doc_set_brief(world, EcsIsA, "Relationship used for expressing inheritance");
-    ecs_doc_set_brief(world, EcsChildOf, "Relationship used for expressing hierarchies");
-    ecs_doc_set_brief(world, EcsDependsOn, "Relationship used for expressing dependencies");
-    ecs_doc_set_brief(world, EcsSlotOf, "Relationship used for expressing prefab slots");
-    ecs_doc_set_brief(world, EcsOnAdd, "Event emitted when component is added");
-    ecs_doc_set_brief(world, EcsOnRemove, "Event emitted when component is removed");
-    ecs_doc_set_brief(world, EcsOnSet, "Event emitted when component is set");
-    ecs_doc_set_brief(world, EcsUnSet, "Event emitted when component is unset");
-    ecs_doc_set_brief(world, EcsMonitor, "Marker used to create monitor observers");
-    ecs_doc_set_brief(world, EcsOnTableFill, "Event emitted when table becomes non-empty");
-    ecs_doc_set_brief(world, EcsOnTableEmpty, "Event emitted when table becomes empty");
-    ecs_doc_set_brief(world, EcsOnTableCreate, "Event emitted when table is created");
-    ecs_doc_set_brief(world, EcsOnTableDelete, "Event emitted when table is deleted");
-
-    ecs_doc_set_brief(world, EcsThis, "Query marker to express $this variable");
-    ecs_doc_set_brief(world, EcsWildcard, "Query marker to express match all wildcard");
-    ecs_doc_set_brief(world, EcsAny, "Query marker to express match at least one wildcard");
+static
+bool flecs_rest_delete(
+    ecs_world_t *world,
+    ecs_http_reply_t *reply,
+    const char *path)
+{
+    ecs_entity_t e;
+    if (!(e = flecs_rest_entity_from_path(world, reply, path))) {
+        return true;
+    }
 
-    ecs_doc_set_brief(world, EcsPredEq, "Query marker to express == operator");
-    ecs_doc_set_brief(world, EcsPredMatch, "Query marker to express ~= operator");
-    ecs_doc_set_brief(world, EcsPredLookup, "Query marker to express by-name lookup");
-    ecs_doc_set_brief(world, EcsScopeOpen, "Query marker to express scope open");
-    ecs_doc_set_brief(world, EcsScopeClose, "Query marker to express scope close");
-    ecs_doc_set_brief(world, EcsEmpty, "Tag used to indicate a query has no results");
+    ecs_delete(world, e);
+    
+    return true;
 }
 
-/* Doc definitions for doc components */
 static
-void flecs_doc_import_doc_definitions(
-    ecs_world_t *world)
+bool flecs_rest_enable(
+    ecs_world_t *world,
+    ecs_http_reply_t *reply,
+    const char *path,
+    bool enable)
 {
-    ecs_entity_t doc = ecs_lookup(world, "flecs.doc");
-    ecs_doc_set_brief(world, doc, "Flecs module with documentation components");
-
-    ecs_doc_set_brief(world, EcsDocBrief, "Brief description");
-    ecs_doc_set_brief(world, EcsDocDetail, "Detailed description");
-    ecs_doc_set_brief(world, EcsDocLink, "Link to additional documentation");
-    ecs_doc_set_brief(world, EcsDocColor, "Color hint for entity");   
+    ecs_entity_t e;
+    if (!(e = flecs_rest_entity_from_path(world, reply, path))) {
+        return true;
+    }
 
-    ecs_doc_set_brief(world, ecs_id(EcsDocDescription), "Component used to add documentation");
-    ecs_doc_set_brief(world, EcsDocBrief, "Used as (Description, Brief) to add a brief description");
-    ecs_doc_set_brief(world, EcsDocDetail, "Used as (Description, Detail) to add a detailed description");
-    ecs_doc_set_brief(world, EcsDocLink, "Used as (Description, Link) to add a link");
+    ecs_enable(world, e, enable);
+    
+    return true;
 }
 
-void FlecsDocImport(
-    ecs_world_t *world)
-{    
-    ECS_MODULE(world, FlecsDoc);
-
-    ecs_set_name_prefix(world, "EcsDoc");
+static
+bool flecs_rest_script(
+    ecs_world_t *world,
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply)
+{
+    (void)world;
+    (void)req;
+    (void)reply;
+#ifdef FLECS_SCRIPT
+    const char *data = ecs_http_get_param(req, "data");
+    if (!data) {
+        flecs_reply_error(reply, "missing data parameter");
+        return true;
+    }
 
-    flecs_bootstrap_component(world, EcsDocDescription);
-    flecs_bootstrap_tag(world, EcsDocBrief);
-    flecs_bootstrap_tag(world, EcsDocDetail);
-    flecs_bootstrap_tag(world, EcsDocLink);
-    flecs_bootstrap_tag(world, EcsDocColor);
+    bool prev_color = ecs_log_enable_colors(false);
+    rest_prev_log = ecs_os_api.log_;
+    ecs_os_api.log_ = flecs_rest_capture_log;
 
-    ecs_set_hooks(world, EcsDocDescription, { 
-        .ctor = ecs_default_ctor,
-        .move = ecs_move(EcsDocDescription),
-        .copy = ecs_copy(EcsDocDescription),
-        .dtor = ecs_dtor(EcsDocDescription)
+    ecs_entity_t script = ecs_script(world, {
+        .entity = ecs_entity(world, { .name = "scripts.main" }),
+        .code = data
     });
 
-    ecs_add_id(world, ecs_id(EcsDocDescription), EcsDontInherit);
-    ecs_add_id(world, ecs_id(EcsDocDescription), EcsPrivate);
+    if (!script) {
+        char *err = flecs_rest_get_captured_log();
+        char *escaped_err = flecs_astresc('"', err);
+        if (escaped_err) {
+            flecs_reply_error(reply, escaped_err);
+        } else {
+            flecs_reply_error(reply, "error parsing script");
+        }
+        reply->code = 400; /* bad request */
+        ecs_os_free(escaped_err);
+        ecs_os_free(err);
+    }
 
-    flecs_doc_import_core_definitions(world);
-    flecs_doc_import_doc_definitions(world);
-}
+    ecs_os_api.log_ = rest_prev_log;
+    ecs_log_enable_colors(prev_color);
 
+    return true;
+#else
+    return false;
 #endif
-
-/**
- * @file addons/flecs_cpp.c
- * @brief Utilities for C++ addon.
- */
-
-#include <ctype.h>
-
-/* Utilities for C++ API */
-
-#ifdef FLECS_CPP
-
-/* Convert compiler-specific typenames extracted from __PRETTY_FUNCTION__ to
- * a uniform identifier */
-
-#define ECS_CONST_PREFIX "const "
-#define ECS_STRUCT_PREFIX "struct "
-#define ECS_CLASS_PREFIX "class "
-#define ECS_ENUM_PREFIX "enum "
-
-#define ECS_CONST_LEN (-1 + (ecs_size_t)sizeof(ECS_CONST_PREFIX))
-#define ECS_STRUCT_LEN (-1 + (ecs_size_t)sizeof(ECS_STRUCT_PREFIX))
-#define ECS_CLASS_LEN (-1 + (ecs_size_t)sizeof(ECS_CLASS_PREFIX))
-#define ECS_ENUM_LEN (-1 + (ecs_size_t)sizeof(ECS_ENUM_PREFIX))
+}
 
 static
-ecs_size_t ecs_cpp_strip_prefix(
-    char *typeName,
-    ecs_size_t len,
-    const char *prefix,
-    ecs_size_t prefix_len)
+void flecs_rest_reply_set_captured_log(
+    ecs_http_reply_t *reply)
 {
-    if ((len > prefix_len) && !ecs_os_strncmp(typeName, prefix, prefix_len)) {
-        ecs_os_memmove(typeName, typeName + prefix_len, len - prefix_len);
-        typeName[len - prefix_len] = '\0';
-        len -= prefix_len;
+    char *err = flecs_rest_get_captured_log();
+    if (err) {
+        char *escaped_err = flecs_astresc('"', err);
+        flecs_reply_error(reply, escaped_err);
+        ecs_os_free(escaped_err);
+        ecs_os_free(err);
     }
-    return len;
+
+    reply->code = 400;
 }
 
-static 
-void ecs_cpp_trim_type_name(
-    char *typeName) 
+static
+void flecs_rest_iter_to_reply(
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply,
+    flecs_poly_t *query,
+    ecs_iter_t *it)
 {
-    ecs_size_t len = ecs_os_strlen(typeName);
+    ecs_iter_to_json_desc_t desc = {0};
+    desc.serialize_entities = true;
+    desc.serialize_variables = true;
+    flecs_rest_parse_json_ser_iter_params(&desc, req);
+    desc.query = query;
 
-    len = ecs_cpp_strip_prefix(typeName, len, ECS_CONST_PREFIX, ECS_CONST_LEN);
-    len = ecs_cpp_strip_prefix(typeName, len, ECS_STRUCT_PREFIX, ECS_STRUCT_LEN);
-    len = ecs_cpp_strip_prefix(typeName, len, ECS_CLASS_PREFIX, ECS_CLASS_LEN);
-    len = ecs_cpp_strip_prefix(typeName, len, ECS_ENUM_PREFIX, ECS_ENUM_LEN);
+    int32_t offset = 0;
+    int32_t limit = 1000;
 
-    while (typeName[len - 1] == ' ' ||
-            typeName[len - 1] == '&' ||
-            typeName[len - 1] == '*') 
-    {
-        len --;
-        typeName[len] = '\0';
-    }
+    flecs_rest_int_param(req, "offset", &offset);
+    flecs_rest_int_param(req, "limit", &limit);
 
-    /* Remove const at end of string */
-    if (len > ECS_CONST_LEN) {
-        if (!ecs_os_strncmp(&typeName[len - ECS_CONST_LEN], " const", ECS_CONST_LEN)) {
-            typeName[len - ECS_CONST_LEN] = '\0';
-        }
-        len -= ECS_CONST_LEN;
+    if (offset < 0 || limit < 0) {
+        flecs_reply_error(reply, "invalid offset/limit parameter");
+        return;
     }
 
-    /* Check if there are any remaining "struct " strings, which can happen
-     * if this is a template type on msvc. */
-    if (len > ECS_STRUCT_LEN) {
-        char *ptr = typeName;
-        while ((ptr = strstr(ptr + 1, ECS_STRUCT_PREFIX)) != 0) {
-            /* Make sure we're not matched with part of a longer identifier
-             * that contains 'struct' */
-            if (ptr[-1] == '<' || ptr[-1] == ',' || isspace(ptr[-1])) {
-                ecs_os_memmove(ptr, ptr + ECS_STRUCT_LEN, 
-                    ecs_os_strlen(ptr + ECS_STRUCT_LEN) + 1);
-                len -= ECS_STRUCT_LEN;
-            }
-        }
+    ecs_iter_t pit = ecs_page_iter(it, offset, limit);
+    if (ecs_iter_to_json_buf(&pit, &reply->body, &desc)) {
+        flecs_rest_reply_set_captured_log(reply);
     }
-}
 
-char* ecs_cpp_get_type_name(
-    char *type_name, 
-    const char *func_name,
-    size_t len,
-    size_t front_len)
-{
-    memcpy(type_name, func_name + front_len, len);
-    type_name[len] = '\0';
-    ecs_cpp_trim_type_name(type_name);
-    return type_name;
+    flecs_rest_int_param(req, "offset", &offset);
 }
 
-char* ecs_cpp_get_symbol_name(
-    char *symbol_name,
-    const char *type_name,
-    size_t len)
+static
+bool flecs_rest_reply_existing_query(
+    ecs_world_t *world,
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply,
+    const char *name)
 {
-    // Symbol is same as name, but with '::' replaced with '.'
-    ecs_os_strcpy(symbol_name, type_name);
+    ecs_entity_t qe = ecs_lookup(world, name);
+    if (!qe) {
+        flecs_reply_error(reply, "unresolved identifier '%s'", name);
+        reply->code = 404;
+        return true;
+    }
 
-    char *ptr;
-    size_t i;
-    for (i = 0, ptr = symbol_name; i < len && *ptr; i ++, ptr ++) {
-        if (*ptr == ':') {
-            symbol_name[i] = '.';
-            ptr ++;
+    ecs_query_t *q = NULL;
+    const EcsPoly *poly_comp = ecs_get_pair(world, qe, EcsPoly, EcsQuery);
+    if (!poly_comp) {
+        poly_comp = ecs_get_pair(world, qe, EcsPoly, EcsObserver);
+        if (poly_comp) {
+            q = ((ecs_observer_t*)poly_comp->poly)->query;
         } else {
-            symbol_name[i] = *ptr;
+            flecs_reply_error(reply, 
+                "resolved identifier '%s' is not a query", name);
+            reply->code = 400;
+            return true;
         }
+    } else {
+        q = poly_comp->poly;
     }
 
-    symbol_name[i] = '\0';
+    if (!q) {
+        flecs_reply_error(reply, "query '%s' is not initialized", name);
+        reply->code = 400;
+        return true;
+    }
 
-    return symbol_name;
-}
+    ecs_iter_t it = ecs_query_iter(world, q);
 
-static
-const char* flecs_cpp_func_rchr(
-    const char *func_name,
-    ecs_size_t func_name_len,
-    ecs_size_t func_back_len,
-    char ch)
-{
-    const char *r = strrchr(func_name, ch);
-    if ((r - func_name) >= (func_name_len - flecs_uto(ecs_size_t, func_back_len))) {
-        return NULL;
+    ecs_dbg_2("rest: request query '%s'", name);
+    bool prev_color = ecs_log_enable_colors(false);
+    rest_prev_log = ecs_os_api.log_;
+    ecs_os_api.log_ = flecs_rest_capture_log;
+
+    const char *vars = ecs_http_get_param(req, "vars");
+    if (vars) {
+    #ifdef FLECS_SCRIPT
+        if (ecs_query_args_parse(q, &it, vars) == NULL) {
+            flecs_rest_reply_set_captured_log(reply);
+            return true;
+        }
+    #else
+        flecs_reply_error(reply,
+            "cannot parse query arg expression: script addon required");
+        reply->code = 400;
+        return true;
+    #endif
     }
-    return r;
-}
 
-static
-const char* flecs_cpp_func_max(
-    const char *a,
-    const char *b)
-{
-    if (a > b) return a;
-    return b;
-}
+    flecs_rest_iter_to_reply(req, reply, q, &it);
 
-char* ecs_cpp_get_constant_name(
-    char *constant_name,
-    const char *func_name,
-    size_t func_name_len,
-    size_t func_back_len)
-{
-    ecs_size_t f_len = flecs_uto(ecs_size_t, func_name_len);
-    ecs_size_t fb_len = flecs_uto(ecs_size_t, func_back_len);
-    const char *start = flecs_cpp_func_rchr(func_name, f_len, fb_len, ' ');
-    start = flecs_cpp_func_max(start, flecs_cpp_func_rchr(
-        func_name, f_len, fb_len, ')'));
-    start = flecs_cpp_func_max(start, flecs_cpp_func_rchr(
-        func_name, f_len, fb_len, ':'));
-    start = flecs_cpp_func_max(start, flecs_cpp_func_rchr(
-        func_name, f_len, fb_len, ','));
-    ecs_assert(start != NULL, ECS_INVALID_PARAMETER, func_name);
-    start ++;
-    
-    ecs_size_t len = flecs_uto(ecs_size_t, 
-        (f_len - (start - func_name) - fb_len));
-    ecs_os_memcpy_n(constant_name, start, char, len);
-    constant_name[len] = '\0';
-    return constant_name;
+    ecs_os_api.log_ = rest_prev_log;
+    ecs_log_enable_colors(prev_color);    
+
+    return true;
 }
 
-// Names returned from the name_helper class do not start with ::
-// but are relative to the root. If the namespace of the type
-// overlaps with the namespace of the current module, strip it from
-// the implicit identifier.
-// This allows for registration of component types that are not in the 
-// module namespace to still be registered under the module scope.
-const char* ecs_cpp_trim_module(
+static
+bool flecs_rest_reply_query(
     ecs_world_t *world,
-    const char *type_name)
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply)
 {
-    ecs_entity_t scope = ecs_get_scope(world);
-    if (!scope) {
-        return type_name;
+    const char *q_name = ecs_http_get_param(req, "name");
+    if (q_name) {
+        return flecs_rest_reply_existing_query(world, req, reply, q_name);
     }
 
-    char *path = ecs_get_path_w_sep(world, 0, scope, "::", NULL);
-    if (path) {
-        ecs_size_t len = ecs_os_strlen(path);
-        if (!ecs_os_strncmp(path, type_name, len)) {
-            // Type is a child of current parent, trim name of parent
-            type_name += len;
-            ecs_assert(type_name[0], ECS_INVALID_PARAMETER, NULL);
-            ecs_assert(type_name[0] == ':', ECS_INVALID_PARAMETER, NULL);
-            ecs_assert(type_name[1] == ':', ECS_INVALID_PARAMETER, NULL);
-            type_name += 2;
-        } else {
-            // Type is not a child of current parent, trim entire path
-            char *ptr = strrchr(type_name, ':');
-            if (ptr) {
-                type_name = ptr + 1;
-            }
-
-        }
+    const char *expr = ecs_http_get_param(req, "q");
+    if (!expr) {
+        ecs_strbuf_appendlit(&reply->body, "Missing parameter 'q'");
+        reply->code = 400; /* bad request */
+        return true;
     }
-    ecs_os_free(path);
 
-    return type_name;
-}
+    bool try = false;
+    flecs_rest_bool_param(req, "try", &try);
 
-// Validate registered component
-void ecs_cpp_component_validate(
-    ecs_world_t *world,
-    ecs_entity_t id,
-    const char *name,
-    const char *symbol,
-    size_t size,
-    size_t alignment,
-    bool implicit_name)
-{
-    /* If entity has a name check if it matches */
-    if (ecs_is_valid(world, id) && ecs_get_name(world, id) != NULL) {
-        if (!implicit_name && id >= EcsFirstUserComponentId) {
-#ifndef FLECS_NDEBUG
-            char *path = ecs_get_path_w_sep(
-                world, 0, id, "::", NULL);
-            if (ecs_os_strcmp(path, name)) {
-                ecs_abort(ECS_INCONSISTENT_NAME,
-                    "component '%s' already registered with name '%s'",
-                    name, path);
-            }
-            ecs_os_free(path);
-#endif
-        }
+    ecs_dbg_2("rest: request query '%s'", expr);
+    bool prev_color = ecs_log_enable_colors(false);
+    rest_prev_log = ecs_os_api.log_;
+    ecs_os_api.log_ = flecs_rest_capture_log;
 
-        if (symbol) {
-            const char *existing_symbol = ecs_get_symbol(world, id);
-            if (existing_symbol) {
-                if (ecs_os_strcmp(symbol, existing_symbol)) {
-                    ecs_abort(ECS_INCONSISTENT_NAME,
-                        "component '%s' with symbol '%s' already registered with symbol '%s'",
-                        name, symbol, existing_symbol);
-                }
-            }
+    ecs_query_t *q = ecs_query(world, { .expr = expr });
+    if (!q) {
+        flecs_rest_reply_set_captured_log(reply);
+        if (try) {
+            /* If client is trying queries, don't spam console with errors */
+            reply->code = 200;
         }
     } else {
-        /* Ensure that the entity id valid */
-        if (!ecs_is_alive(world, id)) {
-            ecs_make_alive(world, id);
-        }
-
-        /* Register name with entity, so that when the entity is created the
-        * correct id will be resolved from the name. Only do this when the
-        * entity is empty. */
-        ecs_add_path_w_sep(world, id, 0, name, "::", "::");
+        ecs_iter_t it = ecs_query_iter(world, q);
+        flecs_rest_iter_to_reply(req, reply, q, &it);
+        ecs_query_fini(q);
     }
 
-    /* If a component was already registered with this id but with a 
-     * different size, the ecs_component_init function will fail. */
+    ecs_os_api.log_ = rest_prev_log;
+    ecs_log_enable_colors(prev_color);
 
-    /* We need to explicitly call ecs_component_init here again. Even though
-     * the component was already registered, it may have been registered
-     * with a different world. This ensures that the component is registered
-     * with the same id for the current world. 
-     * If the component was registered already, nothing will change. */
-    ecs_entity_t ent = ecs_component_init(world, &(ecs_component_desc_t){
-        .entity = id,
-        .type.size = flecs_uto(int32_t, size),
-        .type.alignment = flecs_uto(int32_t, alignment)
-    });
-    (void)ent;
-    ecs_assert(ent == id, ECS_INTERNAL_ERROR, NULL);
+    return true;
 }
 
-ecs_entity_t ecs_cpp_component_register(
-    ecs_world_t *world,
-    ecs_entity_t id,
-    const char *name,
-    const char *symbol,
-    ecs_size_t size,
-    ecs_size_t alignment,
-    bool implicit_name,
-    bool *existing_out)
+#ifdef FLECS_MONITOR
+
+static
+void flecs_rest_array_append_(
+    ecs_strbuf_t *reply,
+    const char *field,
+    int32_t field_len,
+    const ecs_float_t *values,
+    int32_t t)
 {
-    (void)size;
-    (void)alignment;
+    ecs_strbuf_list_appendch(reply, '"');
+    ecs_strbuf_appendstrn(reply, field, field_len);
+    ecs_strbuf_appendlit(reply, "\":");
+    ecs_strbuf_list_push(reply, "[", ",");
 
-    /* If the component is not yet registered, ensure no other component
-     * or entity has been registered with this name. Ensure component is 
-     * looked up from root. */
-    bool existing = false;
-    ecs_entity_t prev_scope = ecs_set_scope(world, 0);
-    ecs_entity_t ent;
-    if (id) {
-        ent = id;
-    } else {
-        ent = ecs_lookup_path_w_sep(world, 0, name, "::", "::", false);
-        existing = ent != 0 && ecs_has(world, ent, EcsComponent);
+    int32_t i;
+    for (i = t + 1; i <= (t + ECS_STAT_WINDOW); i ++) {
+        int32_t index = i % ECS_STAT_WINDOW;
+        ecs_strbuf_list_next(reply);
+        ecs_strbuf_appendflt(reply, (double)values[index], '"');
     }
-    ecs_set_scope(world, prev_scope);
 
-    /* If entity exists, compare symbol name to ensure that the component
-     * we are trying to register under this name is the same */
-    if (ent) {
-        const EcsComponent *component = ecs_get(world, ent, EcsComponent);
-        if (component != NULL) {
-            const char *sym = ecs_get_symbol(world, ent);
-            if (sym && ecs_os_strcmp(sym, symbol)) {
-                /* Application is trying to register a type with an entity that
-                 * was already associated with another type. In most cases this
-                 * is an error, with the exception of a scenario where the
-                 * application is wrapping a C type with a C++ type.
-                 * 
-                 * In this case the C++ type typically inherits from the C type,
-                 * and adds convenience methods to the derived class without
-                 * changing anything that would change the size or layout.
-                 * 
-                 * To meet this condition, the new type must have the same size
-                 * and alignment as the existing type, and the name of the type
-                 * type must be equal to the registered name (not symbol).
-                 * 
-                 * The latter ensures that it was the intent of the application
-                 * to alias the type, vs. accidentally registering an unrelated
-                 * type with the same size/alignment. */
-                char *type_path = ecs_get_fullpath(world, ent);
-                if (ecs_os_strcmp(type_path, symbol) || 
-                    component->size != size || 
-                    component->alignment != alignment) 
-                {
-                    ecs_err(
-                        "component with name '%s' is already registered for"\
-                        " type '%s' (trying to register for type '%s')",
-                            name, sym, symbol);
-                    ecs_abort(ECS_NAME_IN_USE, NULL);
-                }
-                ecs_os_free(type_path);
-            } else if (!sym) {
-                ecs_set_symbol(world, ent, symbol);
-            }
-        }
-
-    /* If no entity is found, lookup symbol to check if the component was
-     * registered under a different name. */
-    } else if (!implicit_name) {
-        ent = ecs_lookup_symbol(world, symbol, false, false);
-        ecs_assert(ent == 0 || (ent == id), ECS_INCONSISTENT_COMPONENT_ID, symbol);
-    }
-
-    if (existing_out) {
-        *existing_out = existing;
-    }
-
-    return ent;
+    ecs_strbuf_list_pop(reply, "]");
 }
 
-ecs_entity_t ecs_cpp_component_register_explicit(
-    ecs_world_t *world,
-    ecs_entity_t s_id,
-    ecs_entity_t id,
-    const char *name,
-    const char *type_name,
-    const char *symbol,
-    size_t size,
-    size_t alignment,
-    bool is_component,
-    bool *existing_out)
-{
-    char *existing_name = NULL;
-    if (existing_out) *existing_out = false;
+#define flecs_rest_array_append(reply, field, values, t)\
+    flecs_rest_array_append_(reply, field, sizeof(field) - 1, values, t)
 
-    // If an explicit id is provided, it is possible that the symbol and
-    // name differ from the actual type, as the application may alias
-    // one type to another.
-    if (!id) {
-        if (!name) {
-            // If no name was provided first check if a type with the provided
-            // symbol was already registered.
-            id = ecs_lookup_symbol(world, symbol, false, false);
-            if (id) {
-                existing_name = ecs_get_path_w_sep(world, 0, id, "::", "::");
-                name = existing_name;
-                if (existing_out) *existing_out = true;
-            } else {
-                // If type is not yet known, derive from type name
-                name = ecs_cpp_trim_module(world, type_name);
-            }
-        }
-    } else {
-        // If an explicit id is provided but it has no name, inherit
-        // the name from the type.
-        if (!ecs_is_valid(world, id) || !ecs_get_name(world, id)) {
-            name = ecs_cpp_trim_module(world, type_name);
-        }
-    }
+static
+void flecs_rest_gauge_append(
+    ecs_strbuf_t *reply,
+    const ecs_metric_t *m,
+    const char *field,
+    int32_t field_len,
+    int32_t t,
+    const char *brief,
+    int32_t brief_len)
+{
+    ecs_strbuf_list_appendch(reply, '"');
+    ecs_strbuf_appendstrn(reply, field, field_len);
+    ecs_strbuf_appendlit(reply, "\":");
+    ecs_strbuf_list_push(reply, "{", ",");
 
-    ecs_entity_t entity;
-    if (is_component || size != 0) {
-        entity = ecs_entity(world, {
-            .id = s_id,
-            .name = name,
-            .sep = "::",
-            .root_sep = "::",
-            .symbol = symbol,
-            .use_low_id = true
-        });
-        ecs_assert(entity != 0, ECS_INVALID_OPERATION, NULL);
+    flecs_rest_array_append(reply, "avg", m->gauge.avg, t);
+    flecs_rest_array_append(reply, "min", m->gauge.min, t);
+    flecs_rest_array_append(reply, "max", m->gauge.max, t);
 
-        entity = ecs_component_init(world, &(ecs_component_desc_t){
-            .entity = entity,
-            .type.size = flecs_uto(int32_t, size),
-            .type.alignment = flecs_uto(int32_t, alignment)
-        });
-        ecs_assert(entity != 0, ECS_INVALID_OPERATION, NULL);
-    } else {
-        entity = ecs_entity(world, {
-            .id = s_id,
-            .name = name,
-            .sep = "::",
-            .root_sep = "::",
-            .symbol = symbol,
-            .use_low_id = true
-        });
+    if (brief) {
+        ecs_strbuf_list_appendlit(reply, "\"brief\":\"");
+        ecs_strbuf_appendstrn(reply, brief, brief_len);
+        ecs_strbuf_appendch(reply, '"');
     }
 
-    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!s_id || s_id == entity, ECS_INTERNAL_ERROR, NULL);
-    ecs_os_free(existing_name);
-
-    return entity;
+    ecs_strbuf_list_pop(reply, "}");
 }
 
-void ecs_cpp_enum_init(
-    ecs_world_t *world,
-    ecs_entity_t id)
+static
+void flecs_rest_counter_append(
+    ecs_strbuf_t *reply,
+    const ecs_metric_t *m,
+    const char *field,
+    int32_t field_len,
+    int32_t t,
+    const char *brief,
+    int32_t brief_len)
 {
-    (void)world;
-    (void)id;
-#ifdef FLECS_META
-    ecs_suspend_readonly_state_t readonly_state;
-    world = flecs_suspend_readonly(world, &readonly_state);
-    ecs_set(world, id, EcsEnum, {0});
-    flecs_resume_readonly(world, &readonly_state);
-#endif
+    flecs_rest_gauge_append(reply, m, field, field_len, t, brief, brief_len);
 }
 
-ecs_entity_t ecs_cpp_enum_constant_register(
-    ecs_world_t *world,
-    ecs_entity_t parent,
-    ecs_entity_t id,
-    const char *name,
-    int value)
+#define ECS_GAUGE_APPEND_T(reply, s, field, t, brief)\
+    flecs_rest_gauge_append(reply, &(s)->field, #field, sizeof(#field) - 1, t, brief, sizeof(brief) - 1)
+
+#define ECS_COUNTER_APPEND_T(reply, s, field, t, brief)\
+    flecs_rest_counter_append(reply, &(s)->field, #field, sizeof(#field) - 1, t, brief, sizeof(brief) - 1)
+
+#define ECS_GAUGE_APPEND(reply, s, field, brief)\
+    ECS_GAUGE_APPEND_T(reply, s, field, (s)->t, brief)
+
+#define ECS_COUNTER_APPEND(reply, s, field, brief)\
+    ECS_COUNTER_APPEND_T(reply, s, field, (s)->t, brief)
+
+static
+void flecs_world_stats_to_json(
+    ecs_strbuf_t *reply,
+    const EcsWorldStats *monitor_stats)
 {
-    ecs_suspend_readonly_state_t readonly_state;
-    world = flecs_suspend_readonly(world, &readonly_state);
+    const ecs_world_stats_t *stats = &monitor_stats->stats;
 
-    const char *parent_name = ecs_get_name(world, parent);
-    ecs_size_t parent_name_len = ecs_os_strlen(parent_name);
-    if (!ecs_os_strncmp(name, parent_name, parent_name_len)) {
-        name += parent_name_len;
-        if (name[0] == '_') {
-            name ++;
-        }
-    }
+    ecs_strbuf_list_push(reply, "{", ",");
+    ECS_GAUGE_APPEND(reply, stats, entities.count, "Alive entity ids in the world");
+    ECS_GAUGE_APPEND(reply, stats, entities.not_alive_count, "Not alive entity ids in the world");
 
-    ecs_entity_t prev = ecs_set_scope(world, parent);
-    id = ecs_entity(world, {
-        .id = id,
-        .name = name
-    });
-    ecs_assert(id != 0, ECS_INVALID_OPERATION, name);
-    ecs_set_scope(world, prev);
+    ECS_GAUGE_APPEND(reply, stats, performance.fps, "Frames per second");
+    ECS_COUNTER_APPEND(reply, stats, performance.frame_time, "Time spent in frame");
+    ECS_COUNTER_APPEND(reply, stats, performance.system_time, "Time spent on running systems in frame");
+    ECS_COUNTER_APPEND(reply, stats, performance.emit_time, "Time spent on notifying observers in frame");
+    ECS_COUNTER_APPEND(reply, stats, performance.merge_time, "Time spent on merging commands in frame");
+    ECS_COUNTER_APPEND(reply, stats, performance.rematch_time, "Time spent on revalidating query caches in frame");
 
-    #ifdef FLECS_DEBUG
-    const EcsComponent *cptr = ecs_get(world, parent, EcsComponent);
-    ecs_assert(cptr != NULL, ECS_INVALID_PARAMETER, "enum is not a component");
-    ecs_assert(cptr->size == ECS_SIZEOF(int32_t), ECS_UNSUPPORTED,
-        "enum component must have 32bit size");
-    #endif
+    ECS_COUNTER_APPEND(reply, stats, commands.add_count, "Add commands executed");
+    ECS_COUNTER_APPEND(reply, stats, commands.remove_count, "Remove commands executed");
+    ECS_COUNTER_APPEND(reply, stats, commands.delete_count, "Delete commands executed");
+    ECS_COUNTER_APPEND(reply, stats, commands.clear_count, "Clear commands executed");
+    ECS_COUNTER_APPEND(reply, stats, commands.set_count, "Set commands executed");
+    ECS_COUNTER_APPEND(reply, stats, commands.ensure_count, "Get_mut commands executed");
+    ECS_COUNTER_APPEND(reply, stats, commands.modified_count, "Modified commands executed");
+    ECS_COUNTER_APPEND(reply, stats, commands.other_count, "Misc commands executed");
+    ECS_COUNTER_APPEND(reply, stats, commands.discard_count, "Commands for already deleted entities");
+    ECS_COUNTER_APPEND(reply, stats, commands.batched_entity_count, "Entities with batched commands");
+    ECS_COUNTER_APPEND(reply, stats, commands.batched_count, "Number of commands batched");
 
-#ifdef FLECS_META
-    ecs_set_id(world, id, ecs_pair(EcsConstant, ecs_id(ecs_i32_t)), 
-        sizeof(ecs_i32_t), &value);
-#endif
+    ECS_COUNTER_APPEND(reply, stats, frame.merge_count, "Number of merges (sync points)");
+    ECS_COUNTER_APPEND(reply, stats, frame.pipeline_build_count, "Pipeline rebuilds (happen when systems become active/enabled)");
+    ECS_COUNTER_APPEND(reply, stats, frame.systems_ran, "Systems ran in frame");
+    ECS_COUNTER_APPEND(reply, stats, frame.observers_ran, "Number of times an observer was invoked in frame");
+    ECS_COUNTER_APPEND(reply, stats, frame.event_emit_count, "Events emitted in frame");
+    ECS_COUNTER_APPEND(reply, stats, frame.rematch_count, "Number of query cache revalidations");
 
-    flecs_resume_readonly(world, &readonly_state);
+    ECS_GAUGE_APPEND(reply, stats, tables.count, "Tables in the world (including empty)");
+    ECS_GAUGE_APPEND(reply, stats, tables.empty_count, "Empty tables in the world");
+    ECS_COUNTER_APPEND(reply, stats, tables.create_count, "Number of new tables created");
+    ECS_COUNTER_APPEND(reply, stats, tables.delete_count, "Number of tables deleted");
 
-    ecs_trace("#[green]constant#[reset] %s.%s created with value %d", 
-        ecs_get_name(world, parent), name, value);
+    ECS_GAUGE_APPEND(reply, stats, components.tag_count, "Tag ids in use");
+    ECS_GAUGE_APPEND(reply, stats, components.component_count, "Component ids in use");
+    ECS_GAUGE_APPEND(reply, stats, components.pair_count, "Pair ids in use");
+    ECS_GAUGE_APPEND(reply, stats, components.type_count, "Registered component types");
+    ECS_COUNTER_APPEND(reply, stats, components.create_count, "Number of new component, tag and pair ids created");
+    ECS_COUNTER_APPEND(reply, stats, components.delete_count, "Number of component, pair and tag ids deleted");
 
-    return id;
-}
+    ECS_GAUGE_APPEND(reply, stats, queries.query_count, "Queries in the world");
+    ECS_GAUGE_APPEND(reply, stats, queries.observer_count, "Observers in the world");
+    ECS_GAUGE_APPEND(reply, stats, queries.system_count, "Systems in the world");
 
-static int32_t flecs_reset_count = 0;
+    ECS_COUNTER_APPEND(reply, stats, memory.alloc_count, "Allocations by OS API");
+    ECS_COUNTER_APPEND(reply, stats, memory.realloc_count, "Reallocs by OS API");
+    ECS_COUNTER_APPEND(reply, stats, memory.free_count, "Frees by OS API");
+    ECS_GAUGE_APPEND(reply, stats, memory.outstanding_alloc_count, "Outstanding allocations by OS API");
+    ECS_COUNTER_APPEND(reply, stats, memory.block_alloc_count, "Blocks allocated by block allocators");
+    ECS_COUNTER_APPEND(reply, stats, memory.block_free_count, "Blocks freed by block allocators");
+    ECS_GAUGE_APPEND(reply, stats, memory.block_outstanding_alloc_count, "Outstanding block allocations");
+    ECS_COUNTER_APPEND(reply, stats, memory.stack_alloc_count, "Pages allocated by stack allocators");
+    ECS_COUNTER_APPEND(reply, stats, memory.stack_free_count, "Pages freed by stack allocators");
+    ECS_GAUGE_APPEND(reply, stats, memory.stack_outstanding_alloc_count, "Outstanding page allocations");
 
-int32_t ecs_cpp_reset_count_get(void) {
-    return flecs_reset_count;
-}
+    ECS_COUNTER_APPEND(reply, stats, http.request_received_count, "Received requests");
+    ECS_COUNTER_APPEND(reply, stats, http.request_invalid_count, "Received invalid requests");
+    ECS_COUNTER_APPEND(reply, stats, http.request_handled_ok_count, "Requests handled successfully");
+    ECS_COUNTER_APPEND(reply, stats, http.request_handled_error_count, "Requests handled with error code");
+    ECS_COUNTER_APPEND(reply, stats, http.request_not_handled_count, "Requests not handled (unknown endpoint)");
+    ECS_COUNTER_APPEND(reply, stats, http.request_preflight_count, "Preflight requests received");
+    ECS_COUNTER_APPEND(reply, stats, http.send_ok_count, "Successful replies");
+    ECS_COUNTER_APPEND(reply, stats, http.send_error_count, "Unsuccessful replies");
+    ECS_COUNTER_APPEND(reply, stats, http.busy_count, "Dropped requests due to full send queue (503)");
 
-int32_t ecs_cpp_reset_count_inc(void) {
-    return ++flecs_reset_count;
+    ecs_strbuf_list_pop(reply, "}");
 }
 
-#ifdef FLECS_META
-const ecs_member_t* ecs_cpp_last_member(
-    const ecs_world_t *world, 
-    ecs_entity_t type)
+static
+void flecs_system_stats_to_json(
+    ecs_world_t *world,
+    ecs_strbuf_t *reply,
+    ecs_entity_t system,
+    const ecs_system_stats_t *stats)
 {
-    const EcsStruct *st = ecs_get(world, type, EcsStruct);
-    if (!st) {
-        char *type_str = ecs_get_fullpath(world, type);
-        ecs_err("entity '%s' is not a struct", type_str);
-        ecs_os_free(type_str);
-        return 0;
-    }
+    ecs_strbuf_list_push(reply, "{", ",");
+    ecs_strbuf_list_appendlit(reply, "\"name\":\"");
+    ecs_get_path_w_sep_buf(world, 0, system, ".", NULL, reply);
+    ecs_strbuf_appendch(reply, '"');
 
-    ecs_member_t *m = ecs_vec_get_t(&st->members, ecs_member_t, 
-        ecs_vec_count(&st->members) - 1);
-    ecs_assert(m != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (!stats->task) {
+        ECS_GAUGE_APPEND(reply, &stats->query, matched_table_count, "");
+        ECS_GAUGE_APPEND(reply, &stats->query, matched_entity_count, "");
+    }
 
-    return m;
+    ECS_COUNTER_APPEND_T(reply, stats, time_spent, stats->query.t, "");
+    ecs_strbuf_list_pop(reply, "}");
 }
-#endif
 
-#endif
+static
+void flecs_pipeline_stats_to_json(
+    ecs_world_t *world,
+    ecs_strbuf_t *reply,
+    const EcsPipelineStats *stats)
+{
+    ecs_strbuf_list_push(reply, "[", ",");
 
-/**
- * @file addons/http.c
- * @brief HTTP addon.
- *
- * This is a heavily modified version of the EmbeddableWebServer (see copyright
- * below). This version has been stripped from everything not strictly necessary
- * for receiving/replying to simple HTTP requests, and has been modified to use
- * the Flecs OS API.
- *
- * EmbeddableWebServer Copyright (c) 2016, 2019, 2020 Forrest Heller, and 
- * CONTRIBUTORS (see below) - All rights reserved.
- *
- * CONTRIBUTORS:
- * Martin Pulec - bug fixes, warning fixes, IPv6 support
- * Daniel Barry - bug fix (ifa_addr != NULL)
- * 
- * Released under the BSD 2-clause license:
- * Redistribution and use in source and binary forms, with or without 
- * modification, are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice, 
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice, 
- * this list of conditions and the following disclaimer in the documentation 
- * and/or other materials provided with the distribution. THIS SOFTWARE IS 
- * PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS 
- * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN 
- * NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY 
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
+    int32_t i, count = ecs_vec_count(&stats->stats.systems), sync_cur = 0;
+    ecs_entity_t *ids = ecs_vec_first_t(&stats->stats.systems, ecs_entity_t);
+    for (i = 0; i < count; i ++) {
+        ecs_entity_t id = ids[i];
+        
+        ecs_strbuf_list_next(reply);
 
+        if (id) {
+            ecs_system_stats_t *sys_stats = ecs_map_get_deref(
+                &stats->stats.system_stats, ecs_system_stats_t, id);
+            flecs_system_stats_to_json(world, reply, id, sys_stats);
+        } else {
+            /* Sync point */
+            ecs_strbuf_list_push(reply, "{", ",");
+            ecs_sync_stats_t *sync_stats = ecs_vec_get_t(
+                &stats->stats.sync_points, ecs_sync_stats_t, sync_cur);
 
-#ifdef FLECS_HTTP
+            ecs_strbuf_list_appendlit(reply, "\"system_count\":");
+            ecs_strbuf_appendint(reply, sync_stats->system_count);
 
-#ifdef ECS_TARGET_MSVC
-#pragma comment(lib, "Ws2_32.lib")
-#endif
+            ecs_strbuf_list_appendlit(reply, "\"multi_threaded\":");
+            ecs_strbuf_appendbool(reply, sync_stats->multi_threaded);
 
-#if defined(ECS_TARGET_WINDOWS)
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#include <windows.h>
-typedef SOCKET ecs_http_socket_t;
-#else
-#include <unistd.h>
-#include <arpa/inet.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <netdb.h>
-#include <strings.h>
-#include <signal.h>
-#include <fcntl.h>
-#ifdef __FreeBSD__
-#include <netinet/in.h>
-#endif
-typedef int ecs_http_socket_t;
+            ecs_strbuf_list_appendlit(reply, "\"immediate\":");
+            ecs_strbuf_appendbool(reply, sync_stats->immediate);
 
-#if !defined(MSG_NOSIGNAL)
-#define MSG_NOSIGNAL (0)
-#endif
+            ECS_GAUGE_APPEND_T(reply, sync_stats, 
+                time_spent, stats->stats.t, "");
+            ECS_GAUGE_APPEND_T(reply, sync_stats, 
+                commands_enqueued, stats->stats.t, "");
 
-#endif
+            ecs_strbuf_list_pop(reply, "}");
+            sync_cur ++;
+        }
+    }
 
-/* Max length of request method */
-#define ECS_HTTP_METHOD_LEN_MAX (8) 
+    ecs_strbuf_list_pop(reply, "]");
+}
 
-/* Timeout (s) before connection purge */
-#define ECS_HTTP_CONNECTION_PURGE_TIMEOUT (1.0)
+static
+bool flecs_rest_reply_stats(
+    ecs_world_t *world,
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply)
+{
+    char *period_str = NULL;
+    flecs_rest_string_param(req, "period", &period_str);
+    char *category = &req->path[6];
 
-/* Number of dequeues before purging */
-#define ECS_HTTP_CONNECTION_PURGE_RETRY_COUNT (5)
+    ecs_entity_t period = EcsPeriod1s;
+    if (period_str) {
+        char *period_name = flecs_asprintf("Period%s", period_str);
+        period = ecs_lookup_child(world, ecs_id(FlecsMonitor), period_name);
+        ecs_os_free(period_name);
+        if (!period) {
+            flecs_reply_error(reply, "bad request (invalid period string)");
+            reply->code = 400;
+            return false;
+        }
+    }
 
-/* Number of retries receiving request */
-#define ECS_HTTP_REQUEST_RECV_RETRY (10)
+    if (!ecs_os_strcmp(category, "world")) {
+        const EcsWorldStats *stats = ecs_get_pair(world, EcsWorld, 
+            EcsWorldStats, period);
+        flecs_world_stats_to_json(&reply->body, stats);
+        return true;
 
-/* Minimum interval between dequeueing requests (ms) */
-#define ECS_HTTP_MIN_DEQUEUE_INTERVAL (50)
+    } else if (!ecs_os_strcmp(category, "pipeline")) {
+        const EcsPipelineStats *stats = ecs_get_pair(world, EcsWorld, 
+            EcsPipelineStats, period);
+        flecs_pipeline_stats_to_json(world, &reply->body, stats);
+        return true;
 
-/* Minimum interval between printing statistics (ms) */
-#define ECS_HTTP_MIN_STATS_INTERVAL (10 * 1000)
+    } else {
+        flecs_reply_error(reply, "bad request (unsupported category)");
+        reply->code = 400;
+        return false;
+    }
+}
+#else
+static
+bool flecs_rest_reply_stats(
+    ecs_world_t *world,
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply)
+{
+    (void)world;
+    (void)req;
+    (void)reply;
+    return false;
+}
+#endif
 
-/* Receive buffer size */
-#define ECS_HTTP_SEND_RECV_BUFFER_SIZE (16 * 1024)
+static
+void flecs_rest_reply_table_append_type(
+    ecs_world_t *world,
+    ecs_strbuf_t *reply,
+    const ecs_table_t *table)
+{
+    ecs_strbuf_list_push(reply, "[", ",");
+    int32_t i, count = table->type.count;
+    ecs_id_t *ids = table->type.array;
+    for (i = 0; i < count; i ++) {
+        ecs_strbuf_list_next(reply);
+        ecs_strbuf_appendch(reply, '"');
+        ecs_id_str_buf(world, ids[i], reply);
+        ecs_strbuf_appendch(reply, '"');
+    }
+    ecs_strbuf_list_pop(reply, "]");
+}
 
-/* Max length of request (path + query + headers + body) */
-#define ECS_HTTP_REQUEST_LEN_MAX (10 * 1024 * 1024)
+static
+void flecs_rest_reply_table_append_memory(
+    ecs_strbuf_t *reply,
+    const ecs_table_t *table)
+{
+    int32_t used = 0, allocated = 0;
 
-/* Total number of outstanding send requests */
-#define ECS_HTTP_SEND_QUEUE_MAX (256)
+    used += table->data.entities.count * ECS_SIZEOF(ecs_entity_t);
+    allocated += table->data.entities.size * ECS_SIZEOF(ecs_entity_t);
 
-/* Global statistics */
-int64_t ecs_http_request_received_count = 0;
-int64_t ecs_http_request_invalid_count = 0;
-int64_t ecs_http_request_handled_ok_count = 0;
-int64_t ecs_http_request_handled_error_count = 0;
-int64_t ecs_http_request_not_handled_count = 0;
-int64_t ecs_http_request_preflight_count = 0;
-int64_t ecs_http_send_ok_count = 0;
-int64_t ecs_http_send_error_count = 0;
-int64_t ecs_http_busy_count = 0;
+    int32_t i, storage_count = table->column_count;
+    ecs_column_t *columns = table->data.columns;
 
-/* Send request queue */
-typedef struct ecs_http_send_request_t {
-    ecs_http_socket_t sock;
-    char *headers;
-    int32_t header_length;
-    char *content;
-    int32_t content_length;
-} ecs_http_send_request_t;
+    for (i = 0; i < storage_count; i ++) {
+        used += columns[i].data.count * columns[i].ti->size;
+        allocated += columns[i].data.size * columns[i].ti->size;
+    }
 
-typedef struct ecs_http_send_queue_t {
-    ecs_http_send_request_t requests[ECS_HTTP_SEND_QUEUE_MAX];
-    int32_t head;
-    int32_t tail;
-    ecs_os_thread_t thread;
-    int32_t wait_ms;
-} ecs_http_send_queue_t;
-
-typedef struct ecs_http_request_key_t {
-    const char *array;
-    ecs_size_t count;
-} ecs_http_request_key_t;
-
-typedef struct ecs_http_request_entry_t {
-    char *content;
-    int32_t content_length;
-    int code;
-    double time;
-} ecs_http_request_entry_t;
-
-/* HTTP server struct */
-struct ecs_http_server_t {
-    bool should_run;
-    bool running;
-
-    ecs_http_socket_t sock;
-    ecs_os_mutex_t lock;
-    ecs_os_thread_t thread;
-
-    ecs_http_reply_action_t callback;
-    void *ctx;
-
-    double cache_timeout;
-    double cache_purge_timeout;
-
-    ecs_sparse_t connections; /* sparse<http_connection_t> */
-    ecs_sparse_t requests; /* sparse<http_request_t> */
-
-    bool initialized;
-
-    uint16_t port;
-    const char *ipaddr;
-
-    double dequeue_timeout; /* used to not lock request queue too often */
-    double stats_timeout; /* used for periodic reporting of statistics */
-
-    double request_time; /* time spent on requests in last stats interval */
-    double request_time_total; /* total time spent on requests */
-    int32_t requests_processed; /* requests processed in last stats interval */
-    int32_t requests_processed_total; /* total requests processed */
-    int32_t dequeue_count; /* number of dequeues in last stats interval */ 
-    ecs_http_send_queue_t send_queue;
-
-    ecs_hashmap_t request_cache;
-};
-
-/** Fragment state, used by HTTP request parser */
-typedef enum  {
-    HttpFragStateBegin,
-    HttpFragStateMethod,
-    HttpFragStatePath,
-    HttpFragStateVersion,
-    HttpFragStateHeaderStart,
-    HttpFragStateHeaderName,
-    HttpFragStateHeaderValueStart,
-    HttpFragStateHeaderValue,
-    HttpFragStateCR,
-    HttpFragStateCRLF,
-    HttpFragStateCRLFCR,
-    HttpFragStateBody,
-    HttpFragStateDone
-} HttpFragState;
-
-/** A fragment is a partially received HTTP request */
-typedef struct {
-    HttpFragState state;
-    ecs_strbuf_t buf;
-    ecs_http_method_t method;
-    int32_t body_offset;
-    int32_t query_offset;
-    int32_t header_offsets[ECS_HTTP_HEADER_COUNT_MAX];
-    int32_t header_value_offsets[ECS_HTTP_HEADER_COUNT_MAX];
-    int32_t header_count;
-    int32_t param_offsets[ECS_HTTP_QUERY_PARAM_COUNT_MAX];
-    int32_t param_value_offsets[ECS_HTTP_QUERY_PARAM_COUNT_MAX];
-    int32_t param_count;
-    int32_t content_length;
-    char *header_buf_ptr;
-    char header_buf[32];
-    bool parse_content_length;
-    bool invalid;
-} ecs_http_fragment_t;
-
-/** Extend public connection type with fragment data */
-typedef struct {
-    ecs_http_connection_t pub;
-    ecs_http_socket_t sock;
-
-    /* Connection is purged after both timeout expires and connection has
-     * exceeded retry count. This ensures that a connection does not immediately
-     * timeout when a frame takes longer than usual */
-    double dequeue_timeout;
-    int32_t dequeue_retries;    
-} ecs_http_connection_impl_t;
-
-typedef struct {
-    ecs_http_request_t pub;
-    uint64_t conn_id; /* for sanity check */
-    char *res;
-    int32_t req_len;
-} ecs_http_request_impl_t;
+    ecs_strbuf_list_push(reply, "{", ",");
+    ecs_strbuf_list_append(reply, "\"used\":%d", used);
+    ecs_strbuf_list_append(reply, "\"allocated\":%d", allocated);
+    ecs_strbuf_list_pop(reply, "}");
+}
 
 static
-ecs_size_t http_send(
-    ecs_http_socket_t sock, 
-    const void *buf, 
-    ecs_size_t size, 
-    int flags)
+void flecs_rest_reply_table_append(
+    ecs_world_t *world,
+    ecs_strbuf_t *reply,
+    const ecs_table_t *table)
 {
-    ecs_assert(size >= 0, ECS_INTERNAL_ERROR, NULL);
-#ifdef ECS_TARGET_POSIX
-    ssize_t send_bytes = send(sock, buf, flecs_itosize(size), 
-        flags | MSG_NOSIGNAL);
-    return flecs_itoi32(send_bytes);
-#else
-    int send_bytes = send(sock, buf, size, flags);
-    return flecs_itoi32(send_bytes);
-#endif
+    ecs_strbuf_list_next(reply);
+    ecs_strbuf_list_push(reply, "{", ",");
+    ecs_strbuf_list_append(reply, "\"id\":%u", (uint32_t)table->id);
+    ecs_strbuf_list_appendstr(reply, "\"type\":");
+    flecs_rest_reply_table_append_type(world, reply, table);
+    ecs_strbuf_list_append(reply, "\"count\":%d", ecs_table_count(table));
+    ecs_strbuf_list_append(reply, "\"memory\":");
+    flecs_rest_reply_table_append_memory(reply, table);
+    ecs_strbuf_list_pop(reply, "}");
 }
 
 static
-ecs_size_t http_recv(
-    ecs_http_socket_t sock,
-    void *buf,
-    ecs_size_t size,
-    int flags)
+bool flecs_rest_reply_tables(
+    ecs_world_t *world,
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply)
 {
-    ecs_size_t ret;
-#ifdef ECS_TARGET_POSIX
-    ssize_t recv_bytes = recv(sock, buf, flecs_itosize(size), flags);
-    ret = flecs_itoi32(recv_bytes);
-#else
-    int recv_bytes = recv(sock, buf, size, flags);
-    ret = flecs_itoi32(recv_bytes);
-#endif
-    if (ret == -1) {
-        ecs_dbg("recv failed: %s (sock = %d)", ecs_os_strerror(errno), sock);
-    } else if (ret == 0) {
-        ecs_dbg("recv: received 0 bytes (sock = %d)", sock);
+    (void)req;
+
+    ecs_strbuf_list_push(&reply->body, "[", ",");
+    ecs_sparse_t *tables = &world->store.tables;
+    int32_t i, count = flecs_sparse_count(tables);
+    for (i = 0; i < count; i ++) {
+        ecs_table_t *table = flecs_sparse_get_dense_t(tables, ecs_table_t, i);
+        flecs_rest_reply_table_append(world, &reply->body, table);
     }
+    ecs_strbuf_list_pop(&reply->body, "]");
 
-    return ret;
+    return true;
 }
 
 static
-void http_sock_set_timeout(
-    ecs_http_socket_t sock,
-    int32_t timeout_ms)
+const char* flecs_rest_cmd_kind_to_str(
+    ecs_cmd_kind_t kind)
 {
-    int r;
-#ifdef ECS_TARGET_POSIX
-    struct timeval tv;
-    tv.tv_sec = timeout_ms * 1000;
-    tv.tv_usec = 0;
-    r = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv);
-#else
-    DWORD t = (DWORD)timeout_ms;
-    r = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&t, sizeof t);
-#endif
-    if (r) {
-        ecs_warn("http: failed to set socket timeout: %s", 
-            ecs_os_strerror(errno));
+    switch(kind) {
+    case EcsCmdClone: return "Clone";
+    case EcsCmdBulkNew: return "BulkNew";
+    case EcsCmdAdd: return "Add";
+    case EcsCmdRemove: return "Remove";
+    case EcsCmdSet: return "Set";
+    case EcsCmdEmplace: return "Emplace";
+    case EcsCmdEnsure: return "Ensure";
+    case EcsCmdModified: return "Modified";
+    case EcsCmdModifiedNoHook: return "ModifiedNoHook";
+    case EcsCmdAddModified: return "AddModified";
+    case EcsCmdPath: return "Path";
+    case EcsCmdDelete: return "Delete";
+    case EcsCmdClear: return "Clear";
+    case EcsCmdOnDeleteAction: return "OnDeleteAction";
+    case EcsCmdEnable: return "Enable";
+    case EcsCmdDisable: return "Disable";
+    case EcsCmdEvent: return "Event";
+    case EcsCmdSkip: return "Skip";
+    default: return "Unknown";
     }
 }
 
 static
-void http_sock_keep_alive(
-    ecs_http_socket_t sock)
+bool flecs_rest_cmd_has_id(
+    const ecs_cmd_t *cmd)
 {
-    int v = 1;
-    if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (const char*)&v, sizeof v)) {
-        ecs_warn("http: failed to set socket KEEPALIVE: %s",
-            ecs_os_strerror(errno));
-    }
-}
-
-static
-void http_sock_nonblock(ecs_http_socket_t sock, bool enable) {
-    (void)sock;
-    (void)enable;
-#ifdef ECS_TARGET_POSIX
-    int flags;
-    flags = fcntl(sock,F_GETFL,0);
-    if (flags == -1) {
-        ecs_warn("http: failed to set socket NONBLOCK: %s",
-            ecs_os_strerror(errno));
-        return;
-    }
-    if (enable) {
-        flags = fcntl(sock, F_SETFL, flags | O_NONBLOCK);
-    } else {
-        flags = fcntl(sock, F_SETFL, flags & ~O_NONBLOCK);
-    }
-    if (flags == -1) {
-        ecs_warn("http: failed to set socket NONBLOCK: %s",
-            ecs_os_strerror(errno));
-        return;
+    switch(cmd->kind) {
+    case EcsCmdClear:
+    case EcsCmdDelete:
+    case EcsCmdClone:
+    case EcsCmdDisable:
+    case EcsCmdPath:
+        return false;
+    case EcsCmdBulkNew:
+    case EcsCmdAdd:
+    case EcsCmdRemove:
+    case EcsCmdSet:
+    case EcsCmdEmplace:
+    case EcsCmdEnsure:
+    case EcsCmdModified:
+    case EcsCmdModifiedNoHook:
+    case EcsCmdAddModified:
+    case EcsCmdOnDeleteAction:
+    case EcsCmdEnable:
+    case EcsCmdEvent:
+    case EcsCmdSkip:
+    default:
+        return true;
     }
-#endif
 }
 
 static
-int http_getnameinfo(
-    const struct sockaddr* addr,
-    ecs_size_t addr_len,
-    char *host,
-    ecs_size_t host_len,
-    char *port,
-    ecs_size_t port_len,
-    int flags)
+void flecs_rest_server_garbage_collect_all(
+    ecs_rest_ctx_t *impl)
 {
-    ecs_assert(addr_len > 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(host_len > 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(port_len > 0, ECS_INTERNAL_ERROR, NULL);
-#if defined(ECS_TARGET_WINDOWS)
-    return getnameinfo(addr, addr_len, host, 
-        flecs_ito(uint32_t, host_len), port, flecs_ito(uint32_t, port_len), 
-        flags);
-#else
-    return getnameinfo(addr, flecs_ito(uint32_t, addr_len), host, 
-        flecs_ito(uint32_t, host_len), port, flecs_ito(uint32_t, port_len), 
-        flags);
-#endif
-}
+    ecs_map_iter_t it = ecs_map_iter(&impl->cmd_captures);
 
-static
-int http_bind(
-    ecs_http_socket_t sock,
-    const struct sockaddr* addr,
-    ecs_size_t addr_len)
-{
-    ecs_assert(addr_len > 0, ECS_INTERNAL_ERROR, NULL);
-#if defined(ECS_TARGET_WINDOWS)
-    return bind(sock, addr, addr_len);
-#else
-    return bind(sock, addr, flecs_ito(uint32_t, addr_len));
-#endif
+    while (ecs_map_next(&it)) {
+        ecs_rest_cmd_capture_t *capture = ecs_map_ptr(&it);
+        int32_t i, count = ecs_vec_count(&capture->syncs);
+        ecs_rest_cmd_sync_capture_t *syncs = ecs_vec_first(&capture->syncs);
+        for (i = 0; i < count; i ++) {
+            ecs_rest_cmd_sync_capture_t *sync = &syncs[i];
+            ecs_os_free(sync->cmds);
+        }
+        ecs_vec_fini_t(NULL, &capture->syncs, ecs_rest_cmd_sync_capture_t);
+        ecs_os_free(capture);
+    }
+
+    ecs_map_fini(&impl->cmd_captures);
 }
 
 static
-bool http_socket_is_valid(
-    ecs_http_socket_t sock)
+void flecs_rest_server_garbage_collect(
+    ecs_world_t *world,
+    ecs_rest_ctx_t *impl)
 {
-#if defined(ECS_TARGET_WINDOWS)
-    return sock != INVALID_SOCKET;
-#else
-    return sock >= 0;
-#endif
-}
+    const ecs_world_info_t *wi = ecs_get_world_info(world);
+    ecs_map_iter_t it = ecs_map_iter(&impl->cmd_captures);
+    ecs_vec_t removed_frames = {0};
 
-#if defined(ECS_TARGET_WINDOWS)
-#define HTTP_SOCKET_INVALID INVALID_SOCKET
-#else
-#define HTTP_SOCKET_INVALID (-1)
-#endif
+    while (ecs_map_next(&it)) {
+        int64_t frame = flecs_uto(int64_t, ecs_map_key(&it));
+        if ((wi->frame_count_total - frame) > FLECS_REST_COMMAND_RETAIN_COUNT) {
+            ecs_rest_cmd_capture_t *capture = ecs_map_ptr(&it);
+            int32_t i, count = ecs_vec_count(&capture->syncs);
+            ecs_rest_cmd_sync_capture_t *syncs = ecs_vec_first(&capture->syncs);
+            for (i = 0; i < count; i ++) {
+                ecs_rest_cmd_sync_capture_t *sync = &syncs[i];
+                ecs_os_free(sync->cmds);
+            }
+            ecs_vec_fini_t(NULL, &capture->syncs, ecs_rest_cmd_sync_capture_t);
+            ecs_os_free(capture);
 
-static
-void http_close(
-    ecs_http_socket_t *sock)
-{
-    ecs_assert(sock != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_vec_init_if_t(&removed_frames, int64_t);
+            ecs_vec_append_t(NULL, &removed_frames, int64_t)[0] = frame;
+        }
+    }
 
-#if defined(ECS_TARGET_WINDOWS)
-    closesocket(*sock);
-#else
-    ecs_dbg_2("http: closing socket %u", *sock);
-    shutdown(*sock, SHUT_RDWR);
-    close(*sock);
-#endif
-    *sock = HTTP_SOCKET_INVALID;
+    int32_t i, count = ecs_vec_count(&removed_frames);
+    if (count) {
+        int64_t *frames = ecs_vec_first(&removed_frames);
+        if (count) {
+            for (i = 0; i < count; i ++) {
+                ecs_map_remove(&impl->cmd_captures, 
+                    flecs_ito(uint64_t, frames[i]));
+            }
+        }
+        ecs_vec_fini_t(NULL, &removed_frames, int64_t);
+    }
 }
 
 static
-ecs_http_socket_t http_accept(
-    ecs_http_socket_t sock,
-    struct sockaddr* addr,
-    ecs_size_t *addr_len)
+void flecs_rest_cmd_to_json(
+    ecs_world_t *world,
+    ecs_strbuf_t *buf,
+    ecs_cmd_t *cmd)
 {
-    socklen_t len = (socklen_t)addr_len[0];
-    ecs_http_socket_t result = accept(sock, addr, &len);
-    addr_len[0] = (ecs_size_t)len;
-    return result;
-}
-
-static
-void http_reply_fini(ecs_http_reply_t* reply) {
-    ecs_assert(reply != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_os_free(reply->body.content);
-}
+    ecs_strbuf_list_push(buf, "{", ",");
 
-static
-void http_request_fini(ecs_http_request_impl_t *req) {
-    ecs_assert(req != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(req->pub.conn != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(req->pub.conn->server != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(req->pub.conn->id == req->conn_id, ECS_INTERNAL_ERROR, NULL);
-    ecs_os_free(req->res);
-    flecs_sparse_remove_t(&req->pub.conn->server->requests, 
-        ecs_http_request_impl_t, req->pub.id);
-}
+    ecs_strbuf_list_appendlit(buf, "\"kind\":\"");
+        ecs_strbuf_appendstr(buf, flecs_rest_cmd_kind_to_str(cmd->kind));
+        ecs_strbuf_appendlit(buf, "\"");
 
-static
-void http_connection_free(ecs_http_connection_impl_t *conn) {
-    ecs_assert(conn != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(conn->pub.id != 0, ECS_INTERNAL_ERROR, NULL);
-    uint64_t conn_id = conn->pub.id;
+    if (flecs_rest_cmd_has_id(cmd)) {
+        ecs_strbuf_list_appendlit(buf, "\"id\":\"");
+            char *idstr = ecs_id_str(world, cmd->id);
+            ecs_strbuf_appendstr(buf, idstr);
+            ecs_strbuf_appendlit(buf, "\"");
+            ecs_os_free(idstr);
+    }
 
-    if (http_socket_is_valid(conn->sock)) {
-        http_close(&conn->sock);
+    if (cmd->system) {
+        ecs_strbuf_list_appendlit(buf, "\"system\":\"");
+            char *sysstr = ecs_get_fullpath(world, cmd->system);
+            ecs_strbuf_appendstr(buf, sysstr);
+            ecs_strbuf_appendlit(buf, "\"");
+            ecs_os_free(sysstr); 
     }
 
-    flecs_sparse_remove_t(&conn->pub.server->connections, 
-        ecs_http_connection_impl_t, conn_id);
-}
+    if (cmd->kind == EcsCmdBulkNew) {
+        /* Todo */
+    } else if (cmd->kind == EcsCmdEvent) {
+        /* Todo */
+    } else {
+        if (cmd->entity) {
+            ecs_strbuf_list_appendlit(buf, "\"entity\":\"");
+                char *path = ecs_get_path_w_sep(world, 0, cmd->entity, ".", "");
+                ecs_strbuf_appendstr(buf, path);
+                ecs_strbuf_appendlit(buf, "\"");
+                ecs_os_free(path);
 
-// https://stackoverflow.com/questions/10156409/convert-hex-string-char-to-int
-static
-char http_hex_2_int(char a, char b){
-    a = (a <= '9') ? (char)(a - '0') : (char)((a & 0x7) + 9);
-    b = (b <= '9') ? (char)(b - '0') : (char)((b & 0x7) + 9);
-    return (char)((a << 4) + b);
-}
+            ecs_strbuf_list_appendlit(buf, "\"is_alive\":\"");
+                if (ecs_is_alive(world, cmd->entity)) {
+                    ecs_strbuf_appendlit(buf, "true");
+                } else {
+                    ecs_strbuf_appendlit(buf, "false");
+                }
+                ecs_strbuf_appendlit(buf, "\"");
 
-static
-void http_decode_url_str(
-    char *str) 
-{
-    char ch, *ptr, *dst = str;
-    for (ptr = str; (ch = *ptr); ptr++) {
-        if (ch == '%') {
-            dst[0] = http_hex_2_int(ptr[1], ptr[2]);
-            dst ++;
-            ptr += 2;
-        } else {
-            dst[0] = ptr[0];
-            dst ++;
+            ecs_strbuf_list_appendlit(buf, "\"next_for_entity\":");
+                ecs_strbuf_appendint(buf, cmd->next_for_entity);
         }
     }
-    dst[0] = '\0';
-}
 
-static
-void http_parse_method(
-    ecs_http_fragment_t *frag)
-{
-    char *method = ecs_strbuf_get_small(&frag->buf);
-    if (!ecs_os_strcmp(method, "GET")) frag->method = EcsHttpGet;
-    else if (!ecs_os_strcmp(method, "POST")) frag->method = EcsHttpPost;
-    else if (!ecs_os_strcmp(method, "PUT")) frag->method = EcsHttpPut;
-    else if (!ecs_os_strcmp(method, "DELETE")) frag->method = EcsHttpDelete;
-    else if (!ecs_os_strcmp(method, "OPTIONS")) frag->method = EcsHttpOptions;
-    else {
-        frag->method = EcsHttpMethodUnsupported;
-        frag->invalid = true;
-    }
-    ecs_strbuf_reset(&frag->buf);
+    ecs_strbuf_list_pop(buf, "}");
 }
 
 static
-bool http_header_writable(
-    ecs_http_fragment_t *frag)
+void flecs_rest_on_commands(
+    const ecs_stage_t *stage,
+    const ecs_vec_t *commands,
+    void *ctx)
 {
-    return frag->header_count < ECS_HTTP_HEADER_COUNT_MAX;
-}
+    ecs_world_t *world = stage->world;
+    ecs_rest_cmd_capture_t *capture = ctx;
+    ecs_assert(capture != NULL, ECS_INTERNAL_ERROR, NULL);
 
-static
-void http_header_buf_reset(
-    ecs_http_fragment_t *frag)
-{
-    frag->header_buf[0] = '\0';
-    frag->header_buf_ptr = frag->header_buf;
-}
+    if (commands) {
+        ecs_vec_init_if_t(&capture->syncs, ecs_rest_cmd_sync_capture_t);
+        ecs_rest_cmd_sync_capture_t *sync = ecs_vec_append_t(
+            NULL, &capture->syncs, ecs_rest_cmd_sync_capture_t);
 
-static
-void http_header_buf_append(
-    ecs_http_fragment_t *frag,
-    char ch)
-{
-    if ((frag->header_buf_ptr - frag->header_buf) < 
-        ECS_SIZEOF(frag->header_buf)) 
-    {
-        frag->header_buf_ptr[0] = ch;
-        frag->header_buf_ptr ++;
-    } else {
-        frag->header_buf_ptr[0] = '\0';
-    }
-}
-
-static
-uint64_t http_request_key_hash(const void *ptr) {
-    const ecs_http_request_key_t *key = ptr;
-    const char *array = key->array;
-    int32_t count = key->count;
-    return flecs_hash(array, count * ECS_SIZEOF(char));
-}
+        int32_t i, count = ecs_vec_count(commands);
+        ecs_cmd_t *cmds = ecs_vec_first(commands);
+        sync->buf = ECS_STRBUF_INIT;
+        ecs_strbuf_list_push(&sync->buf, "{", ",");
+        ecs_strbuf_list_appendlit(&sync->buf, "\"commands\":");
+            ecs_strbuf_list_push(&sync->buf, "[", ",");
+            for (i = 0; i < count; i ++) {
+                ecs_strbuf_list_next(&sync->buf);
+                flecs_rest_cmd_to_json(world, &sync->buf, &cmds[i]);
+            }
+            ecs_strbuf_list_pop(&sync->buf, "]");
 
-static
-int http_request_key_compare(const void *ptr_1, const void *ptr_2) {
-    const ecs_http_request_key_t *type_1 = ptr_1;
-    const ecs_http_request_key_t *type_2 = ptr_2;
+        /* Measure how long it takes to process queue */
+        sync->start_time = (ecs_time_t){0};
+        ecs_time_measure(&sync->start_time);
+    } else {
+        /* Finished processing queue, measure duration */
+        ecs_rest_cmd_sync_capture_t *sync = ecs_vec_last_t(
+            &capture->syncs, ecs_rest_cmd_sync_capture_t);
+        double duration = ecs_time_measure(&sync->start_time);
 
-    int32_t count_1 = type_1->count;
-    int32_t count_2 = type_2->count;
+        ecs_strbuf_list_appendlit(&sync->buf, "\"duration\":");
+        ecs_strbuf_appendflt(&sync->buf, duration, '"');
+        ecs_strbuf_list_pop(&sync->buf, "}");
 
-    if (count_1 != count_2) {
-        return (count_1 > count_2) - (count_1 < count_2);
+        sync->cmds = ecs_strbuf_get(&sync->buf);
     }
-
-    return ecs_os_memcmp(type_1->array, type_2->array, count_1);
 }
 
 static
-ecs_http_request_entry_t* http_find_request_entry(
-    ecs_http_server_t *srv,
-    const char *array,
-    int32_t count)
+bool flecs_rest_reply_commands_capture(
+    ecs_world_t *world,
+    ecs_rest_ctx_t *impl,
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply)
 {
-    ecs_http_request_key_t key;
-    key.array = array;
-    key.count = count;
+    (void)req;
+    const ecs_world_info_t *wi = ecs_get_world_info(world);
+    ecs_strbuf_appendstr(&reply->body, "{");
+    ecs_strbuf_append(&reply->body, "\"frame\":%u", wi->frame_count_total);
+    ecs_strbuf_appendstr(&reply->body, "}");
+    
+    ecs_map_init_if(&impl->cmd_captures, &world->allocator);
+    ecs_rest_cmd_capture_t *capture = ecs_map_ensure_alloc_t(
+        &impl->cmd_captures, ecs_rest_cmd_capture_t, 
+        flecs_ito(uint64_t, wi->frame_count_total));
 
-    ecs_time_t t = {0, 0};
-    ecs_http_request_entry_t *entry = flecs_hashmap_get(
-        &srv->request_cache, &key, ecs_http_request_entry_t);
+    world->on_commands = flecs_rest_on_commands;
+    world->on_commands_ctx = capture;
 
-    if (entry) {
-        double tf = ecs_time_measure(&t);
-        if ((tf - entry->time) < srv->cache_timeout) {
-            return entry;
-        }
-    }
-    return NULL;
+    /* Run garbage collection so that requests don't linger */
+    flecs_rest_server_garbage_collect(world, impl);
+
+    return true;
 }
 
 static
-void http_insert_request_entry(
-    ecs_http_server_t *srv,
-    ecs_http_request_impl_t *req,
+bool flecs_rest_reply_commands_request(
+    ecs_world_t *world,
+    ecs_rest_ctx_t *impl,
+    const ecs_http_request_t* req,
     ecs_http_reply_t *reply)
 {
-    int32_t content_length = ecs_strbuf_written(&reply->body);
-    if (!content_length) {
-        return;
-    }
+    (void)world;
+    char *frame_str = &req->path[15];
+    int32_t frame = atoi(frame_str);
+    
+    ecs_map_init_if(&impl->cmd_captures, &world->allocator);
+    const ecs_rest_cmd_capture_t *capture = ecs_map_get_deref(
+        &impl->cmd_captures, ecs_rest_cmd_capture_t, 
+        flecs_ito(uint64_t, frame));
 
-    ecs_http_request_key_t key;
-    key.array = req->res;
-    key.count = req->req_len;
-    ecs_http_request_entry_t *entry = flecs_hashmap_get(
-        &srv->request_cache, &key, ecs_http_request_entry_t);
-    if (!entry) {
-        flecs_hashmap_result_t elem = flecs_hashmap_ensure(
-            &srv->request_cache, &key, ecs_http_request_entry_t);
-        ecs_http_request_key_t *elem_key = elem.key;
-        elem_key->array = ecs_os_memdup_n(key.array, char, key.count);
-        entry = elem.value;
-    } else {
-        ecs_os_free(entry->content);
+    if (!capture) {
+        ecs_strbuf_appendstr(&reply->body, "{");
+        ecs_strbuf_append(&reply->body, 
+            "\"error\": \"no capture for frame %u\"", frame);
+        ecs_strbuf_appendstr(&reply->body, "}"); 
+        reply->code = 404;
+        return true;
     }
 
-    ecs_time_t t = {0, 0};
-    entry->time = ecs_time_measure(&t);
-    entry->content_length = ecs_strbuf_written(&reply->body);
-    entry->content = ecs_strbuf_get(&reply->body);
-    entry->code = reply->code;
-    ecs_strbuf_appendstrn(&reply->body, 
-            entry->content, entry->content_length);
-}
-
-static
-char* http_decode_request(
-    ecs_http_request_impl_t *req,
-    ecs_http_fragment_t *frag)
-{
-    ecs_os_zeromem(req);
-
-    ecs_size_t req_len = frag->buf.length;
-    char *res = ecs_strbuf_get(&frag->buf);
-    if (!res) {
-        return NULL;
-    }
+    ecs_strbuf_appendstr(&reply->body, "{");
+    ecs_strbuf_list_append(&reply->body, "\"syncs\":");
+    ecs_strbuf_list_push(&reply->body, "[", ",");
 
-    req->pub.method = frag->method;
-    req->pub.path = res + 1;
-    http_decode_url_str(req->pub.path);
+    int32_t i, count = ecs_vec_count(&capture->syncs);
+    ecs_rest_cmd_sync_capture_t *syncs = ecs_vec_first(&capture->syncs);
 
-    if (frag->body_offset) {
-        req->pub.body = &res[frag->body_offset];
-    }
-    int32_t i, count = frag->header_count;
-    for (i = 0; i < count; i ++) {
-        req->pub.headers[i].key = &res[frag->header_offsets[i]];
-        req->pub.headers[i].value = &res[frag->header_value_offsets[i]];
-    }
-    count = frag->param_count;
     for (i = 0; i < count; i ++) {
-        req->pub.params[i].key = &res[frag->param_offsets[i]];
-        req->pub.params[i].value = &res[frag->param_value_offsets[i]];
-        /* Safe, member is only const so that end-user can't change it */
-        http_decode_url_str(ECS_CONST_CAST(char*, req->pub.params[i].value));
+        ecs_rest_cmd_sync_capture_t *sync = &syncs[i];
+        ecs_strbuf_list_appendstr(&reply->body, sync->cmds);
     }
 
-    req->pub.header_count = frag->header_count;
-    req->pub.param_count = frag->param_count;
-    req->res = res;
-    req->req_len = frag->header_offsets[0];
-    if (!req->req_len) {
-        req->req_len = req_len;
-    }
+    ecs_strbuf_list_pop(&reply->body, "]");
+    ecs_strbuf_appendstr(&reply->body, "}");
 
-    return res;
+    return true;
 }
 
 static
-ecs_http_request_entry_t* http_enqueue_request(
-    ecs_http_connection_impl_t *conn,
-    uint64_t conn_id,
-    ecs_http_fragment_t *frag)
+bool flecs_rest_reply(
+    const ecs_http_request_t* req,
+    ecs_http_reply_t *reply,
+    void *ctx)
 {
-    ecs_http_server_t *srv = conn->pub.server;
+    ecs_rest_ctx_t *impl = ctx;
+    ecs_world_t *world = impl->world;
 
-    ecs_os_mutex_lock(srv->lock);
-    bool is_alive = conn->pub.id == conn_id;
+    if (req->path == NULL) {
+        ecs_dbg("rest: bad request (missing path)");
+        flecs_reply_error(reply, "bad request (missing path)");
+        reply->code = 400;
+        return false;
+    }
 
-    if (!is_alive || frag->invalid) { 
-        /* Don't enqueue invalid requests or requests for purged connections */
-        ecs_strbuf_reset(&frag->buf);
-    } else {
-        ecs_http_request_impl_t req;
-        char *res = http_decode_request(&req, frag);
-        if (res) {
-            req.pub.conn = (ecs_http_connection_t*)conn;
+    if (req->method == EcsHttpGet) {
+        /* Entity endpoint */
+        if (!ecs_os_strncmp(req->path, "entity/", 7)) {
+            return flecs_rest_reply_entity(world, req, reply);
 
-            /* Check cache for GET requests */
-            if (frag->method == EcsHttpGet) {
-                ecs_http_request_entry_t *entry = 
-                    http_find_request_entry(srv, res, frag->header_offsets[0]);
-                if (entry) {
-                    /* If an entry is found, don't enqueue a request. Instead
-                     * return the cached response immediately. */
-                    ecs_os_free(res);
-                    return entry;
-                }
-            }
+        /* Query endpoint */
+        } else if (!ecs_os_strcmp(req->path, "query")) {
+            return flecs_rest_reply_query(world, req, reply);
 
-            ecs_http_request_impl_t *req_ptr = flecs_sparse_add_t(
-                &srv->requests, ecs_http_request_impl_t);
-            *req_ptr = req;
-            req_ptr->pub.id = flecs_sparse_last_id(&srv->requests);
-            req_ptr->conn_id = conn->pub.id;
-            ecs_os_linc(&ecs_http_request_received_count);
-        }
-    }
+        /* World endpoint */
+        } else if (!ecs_os_strcmp(req->path, "world")) {
+            return flecs_rest_reply_world(world, req, reply);
 
-    ecs_os_mutex_unlock(srv->lock);
-    return NULL;
-}
+        /* Stats endpoint */
+        } else if (!ecs_os_strncmp(req->path, "stats/", 6)) {
+            return flecs_rest_reply_stats(world, req, reply);
 
-static
-bool http_parse_request(
-    ecs_http_fragment_t *frag,
-    const char* req_frag, 
-    ecs_size_t req_frag_len) 
-{
-    int32_t i;
-    for (i = 0; i < req_frag_len; i++) {
-        char c = req_frag[i];
-        switch (frag->state) {
-        case HttpFragStateBegin:
-            ecs_os_memset_t(frag, 0, ecs_http_fragment_t);
-            frag->state = HttpFragStateMethod;
-            frag->header_buf_ptr = frag->header_buf;
+        /* Tables endpoint */
+        } else if (!ecs_os_strncmp(req->path, "tables", 6)) {
+            return flecs_rest_reply_tables(world, req, reply);
 
-            /* fall through */
-        case HttpFragStateMethod:
-            if (c == ' ') {
-                http_parse_method(frag);
-                ecs_strbuf_reset(&frag->buf);
-                frag->state = HttpFragStatePath;
-                frag->buf.content = NULL;
-            } else {
-                ecs_strbuf_appendch(&frag->buf, c);
-            }
-            break;
-        case HttpFragStatePath:
-            if (c == ' ') {
-                frag->state = HttpFragStateVersion;
-                ecs_strbuf_appendch(&frag->buf, '\0');
-            } else {
-                if (c == '?' || c == '=' || c == '&') {
-                    ecs_strbuf_appendch(&frag->buf, '\0');
-                    int32_t offset = ecs_strbuf_written(&frag->buf);
-                    if (c == '?' || c == '&') {
-                        frag->param_offsets[frag->param_count] = offset;
-                    } else {
-                        frag->param_value_offsets[frag->param_count] = offset;
-                        frag->param_count ++;
-                    }
-                } else {
-                    ecs_strbuf_appendch(&frag->buf, c);
-                }
-            }
-            break;
-        case HttpFragStateVersion:
-            if (c == '\r') {
-                frag->state = HttpFragStateCR;
-            } /* version is not stored */
-            break;
-        case HttpFragStateHeaderStart:
-            if (http_header_writable(frag)) {
-                frag->header_offsets[frag->header_count] = 
-                    ecs_strbuf_written(&frag->buf);
-            }
-            http_header_buf_reset(frag);
-            frag->state = HttpFragStateHeaderName;
+        /* Commands capture endpoint */
+        } else if (!ecs_os_strncmp(req->path, "commands/capture", 16)) {
+            return flecs_rest_reply_commands_capture(world, impl, req, reply);
 
-            /* fall through */
-        case HttpFragStateHeaderName:
-            if (c == ':') {
-                frag->state = HttpFragStateHeaderValueStart;
-                http_header_buf_append(frag, '\0');
-                frag->parse_content_length = !ecs_os_strcmp(
-                    frag->header_buf, "Content-Length");
+        /* Commands request endpoint (request commands from specific frame) */
+        } else if (!ecs_os_strncmp(req->path, "commands/frame/", 15)) {
+            return flecs_rest_reply_commands_request(world, impl, req, reply);
+        }
 
-                if (http_header_writable(frag)) {
-                    ecs_strbuf_appendch(&frag->buf, '\0');
-                    frag->header_value_offsets[frag->header_count] =
-                        ecs_strbuf_written(&frag->buf);
-                }
-            } else if (c == '\r') {
-                frag->state = HttpFragStateCR;
-            } else  {
-                http_header_buf_append(frag, c);
-                if (http_header_writable(frag)) {
-                    ecs_strbuf_appendch(&frag->buf, c);
-                }
-            }
-            break;
-        case HttpFragStateHeaderValueStart:
-            http_header_buf_reset(frag);
-            frag->state = HttpFragStateHeaderValue;
-            if (c == ' ') { /* skip first space */
-                break;
-            }
+    } else if (req->method == EcsHttpPut) {
+        /* Set endpoint */
+        if (!ecs_os_strncmp(req->path, "set/", 4)) {
+            return flecs_rest_set(world, req, reply, &req->path[4]);
+        
+        /* Delete endpoint */
+        } else if (!ecs_os_strncmp(req->path, "delete/", 7)) {
+            return flecs_rest_delete(world, reply, &req->path[7]);
 
-            /* fall through */
-        case HttpFragStateHeaderValue:
-            if (c == '\r') {
-                if (frag->parse_content_length) {
-                    http_header_buf_append(frag, '\0');
-                    int32_t len = atoi(frag->header_buf);
-                    if (len < 0) {
-                        frag->invalid = true;
-                    } else {
-                        frag->content_length = len;
-                    }
-                    frag->parse_content_length = false;
-                }
-                if (http_header_writable(frag)) {
-                    int32_t cur = ecs_strbuf_written(&frag->buf);
-                    if (frag->header_offsets[frag->header_count] < cur &&
-                        frag->header_value_offsets[frag->header_count] < cur)
-                    {
-                        ecs_strbuf_appendch(&frag->buf, '\0');
-                        frag->header_count ++;
-                    }
-                }
-                frag->state = HttpFragStateCR;
-            } else {
-                if (frag->parse_content_length) {
-                    http_header_buf_append(frag, c);
-                }
-                if (http_header_writable(frag)) {
-                    ecs_strbuf_appendch(&frag->buf, c);
-                }
-            }
-            break;
-        case HttpFragStateCR:
-            if (c == '\n') {
-                frag->state = HttpFragStateCRLF;
-            } else {
-                frag->state = HttpFragStateHeaderStart;
-            }
-            break;
-        case HttpFragStateCRLF:
-            if (c == '\r') {
-                frag->state = HttpFragStateCRLFCR;
-            } else {
-                frag->state = HttpFragStateHeaderStart;
-                i--;
-            }
-            break;
-        case HttpFragStateCRLFCR:
-            if (c == '\n') {
-                if (frag->content_length != 0) {
-                    frag->body_offset = ecs_strbuf_written(&frag->buf);
-                    frag->state = HttpFragStateBody;
-                } else {
-                    frag->state = HttpFragStateDone;
-                }
-            } else {
-                frag->state = HttpFragStateHeaderStart;
-            }
-            break;
-        case HttpFragStateBody: {
-                ecs_strbuf_appendch(&frag->buf, c);
-                if ((ecs_strbuf_written(&frag->buf) - frag->body_offset) == 
-                    frag->content_length) 
-                {
-                    frag->state = HttpFragStateDone;
-                }
-            }
-            break;
-        case HttpFragStateDone:
-            break;
+        /* Enable endpoint */
+        } else if (!ecs_os_strncmp(req->path, "enable/", 7)) {
+            return flecs_rest_enable(world, reply, &req->path[7], true);
+
+        /* Disable endpoint */
+        } else if (!ecs_os_strncmp(req->path, "disable/", 8)) {
+            return flecs_rest_enable(world, reply, &req->path[8], false);
+
+        /* Script endpoint */
+        } else if (!ecs_os_strncmp(req->path, "script", 6)) {
+            return flecs_rest_script(world, req, reply);
         }
     }
 
-    if (frag->state == HttpFragStateDone) {
-        return true;
-    } else {
-        return false;
-    }
+    return false;
 }
 
-static
-ecs_http_send_request_t* http_send_queue_post(
-    ecs_http_server_t *srv)
+ecs_http_server_t* ecs_rest_server_init(
+    ecs_world_t *world,
+    const ecs_http_server_desc_t *desc)
 {
-    /* This function should only be called while the server is locked. Before 
-     * the lock is released, the returned element should be populated. */
-    ecs_http_send_queue_t *sq = &srv->send_queue;
-    int32_t next = (sq->head + 1) % ECS_HTTP_SEND_QUEUE_MAX;
-    if (next == sq->tail) {
-        return NULL;
+    ecs_rest_ctx_t *srv_ctx = ecs_os_calloc_t(ecs_rest_ctx_t);
+    ecs_http_server_desc_t private_desc = {0};
+    if (desc) {
+        private_desc = *desc;
     }
+    private_desc.callback = flecs_rest_reply;
+    private_desc.ctx = srv_ctx;
 
-    /* Don't enqueue new requests if server is shutting down */
-    if (!srv->should_run) {
+    ecs_http_server_t *srv = ecs_http_server_init(&private_desc);
+    if (!srv) {
+        ecs_os_free(srv_ctx);
         return NULL;
     }
 
-    /* Return element at end of the queue */
-    ecs_http_send_request_t *result = &sq->requests[sq->head];
-    sq->head = next;
-    return result;
+    srv_ctx->world = world;
+    srv_ctx->srv = srv;
+    srv_ctx->rc = 1;
+    srv_ctx->srv = srv;
+    return srv;
 }
 
-static
-ecs_http_send_request_t* http_send_queue_get(
+void ecs_rest_server_fini(
     ecs_http_server_t *srv)
 {
-    ecs_os_mutex_lock(srv->lock);
-    ecs_http_send_queue_t *sq = &srv->send_queue;
-    if (sq->tail == sq->head) {
-        return NULL;
-    }
-
-    int32_t next = (sq->tail + 1) % ECS_HTTP_SEND_QUEUE_MAX;
-    ecs_http_send_request_t *result = &sq->requests[sq->tail];
-    sq->tail = next;
-    return result;
+    ecs_rest_ctx_t *impl = ecs_http_server_ctx(srv);
+    flecs_rest_server_garbage_collect_all(impl);
+    ecs_os_free(impl);
+    ecs_http_server_fini(srv);
 }
 
 static
-void* http_server_send_queue(void* arg) {
-    ecs_http_server_t *srv = arg;
-    int32_t wait_ms = srv->send_queue.wait_ms;
-
-    /* Run for as long as the server is running or there are messages. When the
-     * server is stopping, no new messages will be enqueued */
-    while (srv->should_run || (srv->send_queue.head != srv->send_queue.tail)) {
-        ecs_http_send_request_t* r = http_send_queue_get(srv);
-        if (!r) {
-            ecs_os_mutex_unlock(srv->lock);
-            /* If the queue is empty, wait so we don't run too fast */
-            if (srv->should_run) {
-                ecs_os_sleep(0, wait_ms * 1000 * 1000);
-            }
-        } else {
-            ecs_http_socket_t sock = r->sock;
-            char *headers = r->headers;
-            int32_t headers_length = r->header_length;
-            char *content = r->content;
-            int32_t content_length = r->content_length;
-            ecs_os_mutex_unlock(srv->lock);
-
-            if (http_socket_is_valid(sock)) {
-                bool error = false;
+void flecs_on_set_rest(ecs_iter_t *it) {
+    EcsRest *rest = it->ptrs[0];
 
-                http_sock_nonblock(sock, false);
-
-                /* Write headers */
-                ecs_size_t written = http_send(sock, headers, headers_length, 0);
-                if (written != headers_length) {
-                    ecs_err("http: failed to write HTTP response headers: %s",
-                        ecs_os_strerror(errno));
-                    ecs_os_linc(&ecs_http_send_error_count);
-                    error = true;
-                } else if (content_length >= 0) {
-                    /* Write content */
-                    written = http_send(sock, content, content_length, 0);
-                    if (written != content_length) {
-                        ecs_err("http: failed to write HTTP response body: %s",
-                            ecs_os_strerror(errno));
-                        ecs_os_linc(&ecs_http_send_error_count);
-                        error = true;
-                    }
-                }
-                if (!error) {
-                    ecs_os_linc(&ecs_http_send_ok_count);
-                }
+    int i;
+    for(i = 0; i < it->count; i ++) {
+        if (!rest[i].port) {
+            rest[i].port = ECS_REST_DEFAULT_PORT;
+        }
 
-                http_close(&sock);
-            } else {
-                ecs_err("http: invalid socket\n");
-            }
+        ecs_http_server_t *srv = ecs_rest_server_init(it->real_world,
+            &(ecs_http_server_desc_t){ 
+                .ipaddr = rest[i].ipaddr, 
+                .port = rest[i].port,
+                .cache_timeout = 0.2
+            });
 
-            ecs_os_free(content);
-            ecs_os_free(headers);
+        if (!srv) {
+            const char *ipaddr = rest[i].ipaddr ? rest[i].ipaddr : "0.0.0.0";
+            ecs_err("failed to create REST server on %s:%u", 
+                ipaddr, rest[i].port);
+            continue;
         }
-    }
-    return NULL;
-}
 
-static
-void http_append_send_headers(
-    ecs_strbuf_t *hdrs,
-    int code, 
-    const char* status, 
-    const char* content_type,  
-    ecs_strbuf_t *extra_headers,
-    ecs_size_t content_len,
-    bool preflight)
-{
-    ecs_strbuf_appendlit(hdrs, "HTTP/1.1 ");
-    ecs_strbuf_appendint(hdrs, code);
-    ecs_strbuf_appendch(hdrs, ' ');
-    ecs_strbuf_appendstr(hdrs, status);
-    ecs_strbuf_appendlit(hdrs, "\r\n");
+        rest[i].impl = ecs_http_server_ctx(srv);
 
-    if (content_type) {
-        ecs_strbuf_appendlit(hdrs, "Content-Type: ");
-        ecs_strbuf_appendstr(hdrs, content_type);
-        ecs_strbuf_appendlit(hdrs, "\r\n");
+        ecs_http_server_start(srv);
     }
+}
 
-    if (content_len >= 0) {
-        ecs_strbuf_appendlit(hdrs, "Content-Length: ");
-        ecs_strbuf_append(hdrs, "%d", content_len);
-        ecs_strbuf_appendlit(hdrs, "\r\n");
-    }
+static
+void DequeueRest(ecs_iter_t *it) {
+    EcsRest *rest = ecs_field(it, EcsRest, 0);
 
-    ecs_strbuf_appendlit(hdrs, "Access-Control-Allow-Origin: *\r\n");
-    if (preflight) {
-        ecs_strbuf_appendlit(hdrs, "Access-Control-Allow-Private-Network: true\r\n");
-        ecs_strbuf_appendlit(hdrs, "Access-Control-Allow-Methods: GET, PUT, OPTIONS\r\n");
-        ecs_strbuf_appendlit(hdrs, "Access-Control-Max-Age: 600\r\n");
+    if (it->delta_system_time > (ecs_ftime_t)1.0) {
+        ecs_warn(
+            "detected large progress interval (%.2fs), REST request may timeout",
+            (double)it->delta_system_time);
     }
 
-    ecs_strbuf_mergebuff(hdrs, extra_headers);
-
-    ecs_strbuf_appendlit(hdrs, "\r\n");
+    int32_t i;
+    for(i = 0; i < it->count; i ++) {
+        ecs_rest_ctx_t *ctx = rest[i].impl;
+        if (ctx) {
+            ecs_http_server_dequeue(ctx->srv, it->delta_time);
+            flecs_rest_server_garbage_collect(it->world, ctx);
+        }
+    } 
 }
 
 static
-void http_send_reply(
-    ecs_http_connection_impl_t* conn, 
-    ecs_http_reply_t* reply,
-    bool preflight) 
-{
-    ecs_strbuf_t hdrs = ECS_STRBUF_INIT;
-    int32_t content_length = reply->body.length;
-    char *content = ecs_strbuf_get(&reply->body);
+void DisableRest(ecs_iter_t *it) {
+    ecs_world_t *world = it->world;
 
-    /* Use asynchronous send queue for outgoing data so send operations won't
-     * hold up main thread */
-    ecs_http_send_request_t *req = NULL;
+    ecs_iter_t rit = ecs_each_id(world, ecs_id(EcsRest));
 
-    if (!preflight) {
-        req = http_send_queue_post(conn->pub.server);
-        if (!req) {
-            reply->code = 503; /* queue full, server is busy */
-            ecs_os_linc(&ecs_http_busy_count);
+    if (it->event == EcsOnAdd) {
+        /* REST module was disabled */
+        while (ecs_each_next(&rit)) {
+            EcsRest *rest = ecs_field(&rit, EcsRest, 0);
+            int i;
+            for (i = 0; i < rit.count; i ++) {
+                ecs_rest_ctx_t *ctx = rest[i].impl;
+                ecs_http_server_stop(ctx->srv);
+            }
         }
-    }
-
-    http_append_send_headers(&hdrs, reply->code, reply->status, 
-        reply->content_type, &reply->headers, content_length, preflight);
-    ecs_size_t headers_length = ecs_strbuf_written(&hdrs);
-    char *headers = ecs_strbuf_get(&hdrs);
-
-    if (!req) {
-        ecs_size_t written = http_send(conn->sock, headers, headers_length, 0);
-        if (written != headers_length) {
-            ecs_err("http: failed to send reply to '%s:%s': %s",
-                conn->pub.host, conn->pub.port, ecs_os_strerror(errno));
-            ecs_os_linc(&ecs_http_send_error_count);
+    } else if (it->event == EcsOnRemove) {
+        /* REST module was enabled */
+        while (ecs_each_next(&rit)) {
+            EcsRest *rest = ecs_field(&rit, EcsRest, 0);
+            int i;
+            for (i = 0; i < rit.count; i ++) {
+                ecs_rest_ctx_t *ctx = rest[i].impl;
+                ecs_http_server_start(ctx->srv);
+            }
         }
-        ecs_os_free(content);
-        ecs_os_free(headers);
-        http_close(&conn->sock);
-        return;
     }
-
-    /* Second, enqueue send request for response body */
-    req->sock = conn->sock;
-    req->headers = headers;
-    req->header_length = headers_length;
-    req->content = content;
-    req->content_length = content_length;
-
-    /* Take ownership of values */
-    reply->body.content = NULL;
-    conn->sock = HTTP_SOCKET_INVALID;
 }
 
-static
-void http_recv_connection(
-    ecs_http_server_t *srv,
-    ecs_http_connection_impl_t *conn, 
-    uint64_t conn_id,
-    ecs_http_socket_t sock)
+void FlecsRestImport(
+    ecs_world_t *world)
 {
-    ecs_size_t bytes_read;
-    char recv_buf[ECS_HTTP_SEND_RECV_BUFFER_SIZE];
-    ecs_http_fragment_t frag = {0};
-    int32_t retries = 0;
+    ECS_MODULE(world, FlecsRest);
 
-    do {
-        if ((bytes_read = http_recv(
-            sock, recv_buf, ECS_SIZEOF(recv_buf), 0)) > 0) 
-        {
-            bool is_alive = conn->pub.id == conn_id;
-            if (!is_alive) {
-                /* Connection has been purged by main thread */
-                goto done;
-            }
+    ECS_IMPORT(world, FlecsPipeline);
+#ifdef FLECS_SCRIPT
+    ECS_IMPORT(world, FlecsScript);
+#endif
+#ifdef FLECS_DOC
+    ECS_IMPORT(world, FlecsDoc);
+    ecs_doc_set_brief(world, ecs_id(FlecsRest), 
+        "Module that implements Flecs REST API");
+#endif
 
-            if (http_parse_request(&frag, recv_buf, bytes_read)) {
-                if (frag.method == EcsHttpOptions) {
-                    ecs_http_reply_t reply;
-                    reply.body = ECS_STRBUF_INIT;
-                    reply.code = 200;
-                    reply.content_type = NULL;
-                    reply.headers = ECS_STRBUF_INIT;
-                    reply.status = "OK";
-                    http_send_reply(conn, &reply, true);
-                    ecs_os_linc(&ecs_http_request_preflight_count);
-                } else {
-                    ecs_http_request_entry_t *entry =
-                        http_enqueue_request(conn, conn_id, &frag);
-                    if (entry) {
-                        ecs_http_reply_t reply;
-                        reply.body = ECS_STRBUF_INIT;
-                        reply.code = entry->code;
-                        reply.content_type = "application/json";
-                        reply.headers = ECS_STRBUF_INIT;
-                        reply.status = "OK";
-                        ecs_strbuf_appendstrn(&reply.body, 
-                            entry->content, entry->content_length);
-                        http_send_reply(conn, &reply, false);
-                        http_connection_free(conn);
+    ecs_set_name_prefix(world, "Ecs");
 
-                        /* Lock was transferred from enqueue_request */
-                        ecs_os_mutex_unlock(srv->lock);
-                    }
-                }
-            } else {
-                ecs_os_linc(&ecs_http_request_invalid_count);
-            }
-        }
+    flecs_bootstrap_component(world, EcsRest);
 
-        ecs_os_sleep(0, 10 * 1000 * 1000);
-    } while ((bytes_read == -1) && (++retries < ECS_HTTP_REQUEST_RECV_RETRY));
+    ecs_set_hooks(world, EcsRest, { 
+        .ctor = flecs_default_ctor,
+        .move = ecs_move(EcsRest),
+        .copy = ecs_copy(EcsRest),
+        .dtor = ecs_dtor(EcsRest),
+        .on_set = flecs_on_set_rest
+    });
 
-    if (retries == ECS_HTTP_REQUEST_RECV_RETRY) {
-        http_close(&sock);
-    }
+    ecs_system(world, {
+        .entity = ecs_entity(world, {.name = "DequeueRest", .add = ecs_ids( ecs_dependson(EcsPostFrame))}),
+        .query.terms = {
+            { .id = ecs_id(EcsRest) },
+        },
+        .callback = DequeueRest,
+        .immediate = true
+    });
 
-done:
-    ecs_strbuf_reset(&frag.buf);
+    ecs_observer(world, {
+        .query = { 
+            .terms = {{ .id = EcsDisabled, .src.id = ecs_id(FlecsRest) }}
+        },
+        .events = {EcsOnAdd, EcsOnRemove},
+        .callback = DisableRest
+    });
+
+    ecs_set_name_prefix(world, "EcsRest");
+    ECS_TAG_DEFINE(world, EcsRestPlecs);
 }
 
-typedef struct {
-    ecs_http_connection_impl_t *conn;
-    uint64_t id;
-} http_conn_res_t;
+#endif
 
-static
-http_conn_res_t http_init_connection(
-    ecs_http_server_t *srv, 
-    ecs_http_socket_t sock_conn,
-    struct sockaddr_storage *remote_addr, 
-    ecs_size_t remote_addr_len) 
-{
-    http_sock_set_timeout(sock_conn, 100);
-    http_sock_keep_alive(sock_conn);
-    http_sock_nonblock(sock_conn, true);
+/**
+ * @file addons/stats.c
+ * @brief Stats addon.
+ */
 
-    /* Create new connection */
-    ecs_os_mutex_lock(srv->lock);
-    ecs_http_connection_impl_t *conn = flecs_sparse_add_t(
-        &srv->connections, ecs_http_connection_impl_t);
-    uint64_t conn_id = conn->pub.id = flecs_sparse_last_id(&srv->connections);
-    conn->pub.server = srv;
-    conn->sock = sock_conn;
-    ecs_os_mutex_unlock(srv->lock);
 
-    char *remote_host = conn->pub.host;
-    char *remote_port = conn->pub.port;
+#ifdef FLECS_SYSTEM
+/**
+ * @file addons/system/system.h
+ * @brief Internal types and functions for system addon.
+ */
 
-    /* Fetch name & port info */
-    if (http_getnameinfo((struct sockaddr*) remote_addr, remote_addr_len,
-        remote_host, ECS_SIZEOF(conn->pub.host),
-        remote_port, ECS_SIZEOF(conn->pub.port),
-            NI_NUMERICHOST | NI_NUMERICSERV))
-    {
-        ecs_os_strcpy(remote_host, "unknown");
-        ecs_os_strcpy(remote_port, "unknown");
-    }
+#ifndef FLECS_SYSTEM_PRIVATE_H
+#define FLECS_SYSTEM_PRIVATE_H
 
-    ecs_dbg_2("http: connection established from '%s:%s' (socket %u)", 
-        remote_host, remote_port, sock_conn);
-    
-    return (http_conn_res_t){ .conn = conn, .id = conn_id };
-}
+#ifdef FLECS_SYSTEM
 
-static
-void http_accept_connections(
-    ecs_http_server_t* srv, 
-    const struct sockaddr* addr, 
-    ecs_size_t addr_len) 
-{
-#ifdef ECS_TARGET_WINDOWS
-    /* If on Windows, test if winsock needs to be initialized */
-    SOCKET testsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    if (INVALID_SOCKET == testsocket && WSANOTINITIALISED == WSAGetLastError()){
-        WSADATA data = { 0 };
-        int result = WSAStartup(MAKEWORD(2, 2), &data);
-        if (result) {
-            ecs_warn("http: WSAStartup failed with GetLastError = %d\n", 
-                GetLastError());
-            return;
-        }
-    } else {
-        http_close(&testsocket);
-    }
-#endif
 
-    /* Resolve name + port (used for logging) */
-    char addr_host[256];
-    char addr_port[20];
+#define ecs_system_t_magic     (0x65637383)
+#define ecs_system_t_tag       EcsSystem
 
-    ecs_http_socket_t sock = HTTP_SOCKET_INVALID;
-    ecs_assert(srv->sock == HTTP_SOCKET_INVALID, ECS_INTERNAL_ERROR, NULL);
+extern ecs_mixins_t ecs_system_t_mixins;
 
-    if (http_getnameinfo(
-        addr, addr_len, addr_host, ECS_SIZEOF(addr_host), addr_port, 
-        ECS_SIZEOF(addr_port), NI_NUMERICHOST | NI_NUMERICSERV))
-    {
-        ecs_os_strcpy(addr_host, "unknown");
-        ecs_os_strcpy(addr_port, "unknown");
-    }
+typedef struct ecs_system_t {
+    ecs_header_t hdr;
 
-    ecs_os_mutex_lock(srv->lock);
-    if (srv->should_run) {
-        ecs_dbg_2("http: initializing connection socket");
+    ecs_run_action_t run;           /* See ecs_system_desc_t */
+    ecs_iter_action_t action;       /* See ecs_system_desc_t */
 
-        sock = socket(addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
-        if (!http_socket_is_valid(sock)) {
-            ecs_err("http: unable to create new connection socket: %s", 
-                ecs_os_strerror(errno));
-            ecs_os_mutex_unlock(srv->lock);
-            goto done;
-        }
+    ecs_query_t *query;             /* System query */
+    ecs_entity_t query_entity;      /* Entity associated with query */
+    ecs_entity_t tick_source;       /* Tick source associated with system */
+    
+    /* Schedule parameters */
+    bool multi_threaded;
+    bool immediate;
 
-        int reuse = 1, result;
-        result = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 
-            (char*)&reuse, ECS_SIZEOF(reuse)); 
-        if (result) {
-            ecs_warn("http: failed to setsockopt: %s", ecs_os_strerror(errno));
-        }
+    ecs_ftime_t time_spent;         /* Time spent on running system */
+    ecs_ftime_t time_passed;        /* Time passed since last invocation */
+    int64_t last_frame;             /* Last frame for which the system was considered */
 
-        if (addr->sa_family == AF_INET6) {
-            int ipv6only = 0;
-            if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, 
-                (char*)&ipv6only, ECS_SIZEOF(ipv6only)))
-            {
-                ecs_warn("http: failed to setsockopt: %s", 
-                    ecs_os_strerror(errno));
-            }
-        }
+    void *ctx;                      /* Userdata for system */
+    void *binding_ctx;              /* Optional language binding context */
 
-        result = http_bind(sock, addr, addr_len);
-        if (result) {
-            ecs_err("http: failed to bind to '%s:%s': %s", 
-                addr_host, addr_port, ecs_os_strerror(errno));
-            ecs_os_mutex_unlock(srv->lock);
-            goto done;
-        }
+    ecs_ctx_free_t ctx_free;
+    ecs_ctx_free_t binding_ctx_free;
 
-        http_sock_set_timeout(sock, 1000);
+    /* Mixins */
+    ecs_world_t *world;
+    ecs_entity_t entity;
+    flecs_poly_dtor_t dtor;      
+} ecs_system_t;
 
-        srv->sock = sock;
+/* Invoked when system becomes active / inactive */
+void ecs_system_activate(
+    ecs_world_t *world,
+    ecs_entity_t system,
+    bool activate,
+    const ecs_system_t *system_data);
 
-        result = listen(srv->sock, SOMAXCONN);
-        if (result) {
-            ecs_warn("http: could not listen for SOMAXCONN (%d) connections: %s", 
-                SOMAXCONN, ecs_os_strerror(errno));
-        }
+/* Internal function to run a system */
+ecs_entity_t flecs_run_intern(
+    ecs_world_t *world,
+    ecs_stage_t *stage,
+    ecs_entity_t system,
+    ecs_system_t *system_data,
+    int32_t stage_current,
+    int32_t stage_count,
+    ecs_ftime_t delta_time,
+    void *param);
 
-        ecs_trace("http: listening for incoming connections on '%s:%s'",
-            addr_host, addr_port);
-    } else {
-        ecs_dbg_2("http: server shut down while initializing");
-    }
-    ecs_os_mutex_unlock(srv->lock);
+#endif
 
-    struct sockaddr_storage remote_addr;
-    ecs_size_t remote_addr_len = 0;
+#endif
 
-    while (srv->should_run) {
-        remote_addr_len = ECS_SIZEOF(remote_addr);
-        ecs_http_socket_t sock_conn = http_accept(srv->sock, (struct sockaddr*) &remote_addr, 
-            &remote_addr_len);
+#endif
 
-        if (!http_socket_is_valid(sock_conn)) {
-            if (srv->should_run) {
-                ecs_dbg("http: connection attempt failed: %s", 
-                    ecs_os_strerror(errno));
-            }
-            continue;
-        }
+#ifdef FLECS_PIPELINE
+/**
+ * @file addons/pipeline/pipeline.h
+ * @brief Internal functions/types for pipeline addon.
+ */
 
-        http_conn_res_t conn = http_init_connection(srv, sock_conn, &remote_addr, remote_addr_len);
-        http_recv_connection(srv, conn.conn, conn.id, sock_conn);
-    }
+#ifndef FLECS_PIPELINE_PRIVATE_H
+#define FLECS_PIPELINE_PRIVATE_H
 
-done:
-    ecs_os_mutex_lock(srv->lock);
-    if (http_socket_is_valid(sock) && errno != EBADF) {
-        http_close(&sock);
-        srv->sock = sock;
-    }
-    ecs_os_mutex_unlock(srv->lock);
 
-    ecs_trace("http: no longer accepting connections on '%s:%s'",
-        addr_host, addr_port);
-}
+/** Instruction data for pipeline.
+ * This type is the element type in the "ops" vector of a pipeline. */
+typedef struct ecs_pipeline_op_t {
+    int32_t offset;             /* Offset in systems vector */
+    int32_t count;              /* Number of systems to run before next op */
+    double time_spent;          /* Time spent merging commands for sync point */
+    int64_t commands_enqueued;  /* Number of commands enqueued for sync point */
+    bool multi_threaded;        /* Whether systems can be ran multi threaded */
+    bool immediate;           /* Whether systems are staged or not */
+} ecs_pipeline_op_t;
 
-static
-void* http_server_thread(void* arg) {
-    ecs_http_server_t *srv = arg;
-    struct sockaddr_in addr;
-    ecs_os_zeromem(&addr);
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(srv->port);
+struct ecs_pipeline_state_t {
+    ecs_query_t *query;         /* Pipeline query */
+    ecs_vec_t ops;              /* Pipeline schedule */
+    ecs_vec_t systems;          /* Vector with system ids */
 
-    if (!srv->ipaddr) {
-        addr.sin_addr.s_addr = htonl(INADDR_ANY);
-    } else {
-        inet_pton(AF_INET, srv->ipaddr, &(addr.sin_addr));
-    }
+    ecs_entity_t last_system;   /* Last system ran by pipeline */
+    ecs_id_record_t *idr_inactive; /* Cached record for quick inactive test */
+    int32_t match_count;        /* Used to track of rebuild is necessary */
+    int32_t rebuild_count;      /* Number of pipeline rebuilds */
+    ecs_iter_t *iters;          /* Iterator for worker(s) */
+    int32_t iter_count;
 
-    http_accept_connections(srv, (struct sockaddr*)&addr, ECS_SIZEOF(addr));
-    return NULL;
-}
+    /* Members for continuing pipeline iteration after pipeline rebuild */
+    ecs_pipeline_op_t *cur_op;  /* Current pipeline op */
+    int32_t cur_i;              /* Index in current result */
+    int32_t ran_since_merge;    /* Index in current op */
+    bool immediate;           /* Is pipeline in readonly mode */
+};
 
-static
-void http_do_request(
-    ecs_http_server_t *srv,
-    ecs_http_reply_t *reply,
-    const ecs_http_request_impl_t *req)
-{
-    ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(srv->callback != NULL, ECS_INVALID_OPERATION, 
-        "missing request handler for server");
+typedef struct EcsPipeline {
+    /* Stable ptr so threads can safely access while entity/components move */
+    ecs_pipeline_state_t *state;
+} EcsPipeline;
 
-    if (srv->callback(ECS_CONST_CAST(ecs_http_request_t*, req), reply, 
-        srv->ctx) == false) 
-    {
-        reply->code = 404;
-        reply->status = "Resource not found";
-        ecs_os_linc(&ecs_http_request_not_handled_count);
-    } else {
-        if (reply->code >= 400) {
-            ecs_os_linc(&ecs_http_request_handled_error_count);
-        } else {
-            ecs_os_linc(&ecs_http_request_handled_ok_count);
-        }
-    }
-error:
-    return;
-}
+////////////////////////////////////////////////////////////////////////////////
+//// Pipeline API
+////////////////////////////////////////////////////////////////////////////////
 
-static
-void http_handle_request(
-    ecs_http_server_t *srv,
-    ecs_http_request_impl_t *req)
-{
-    ecs_http_reply_t reply = ECS_HTTP_REPLY_INIT;
-    ecs_http_connection_impl_t *conn = 
-        (ecs_http_connection_impl_t*)req->pub.conn;
+bool flecs_pipeline_update(
+    ecs_world_t *world,
+    ecs_pipeline_state_t *pq,
+    bool start_of_frame);
 
-    if (req->pub.method != EcsHttpOptions) {
-        if (srv->callback((ecs_http_request_t*)req, &reply, srv->ctx) == false) {
-            reply.code = 404;
-            reply.status = "Resource not found";
-            ecs_os_linc(&ecs_http_request_not_handled_count);
-        } else {
-            if (reply.code >= 400) {
-                ecs_os_linc(&ecs_http_request_handled_error_count);
-            } else {
-                ecs_os_linc(&ecs_http_request_handled_ok_count);
-            }
-        }
+void flecs_run_pipeline(
+    ecs_world_t *world,
+    ecs_pipeline_state_t *pq,
+    ecs_ftime_t delta_time);
 
-        if (req->pub.method == EcsHttpGet) {
-            http_insert_request_entry(srv, req, &reply);
-        }
+int32_t flecs_run_pipeline_ops(
+    ecs_world_t* world,
+    ecs_stage_t* stage,
+    int32_t stage_index,
+    int32_t stage_count,
+    ecs_ftime_t delta_time);
 
-        http_send_reply(conn, &reply, false);
-        ecs_dbg_2("http: reply sent to '%s:%s'", conn->pub.host, conn->pub.port);
-    } else {
-        /* Already taken care of */
-    }
+////////////////////////////////////////////////////////////////////////////////
+//// Worker API
+////////////////////////////////////////////////////////////////////////////////
 
-    http_reply_fini(&reply);
-    http_request_fini(req);
-    http_connection_free(conn);
-}
+void flecs_workers_progress(
+    ecs_world_t *world,
+    ecs_pipeline_state_t *pq,
+    ecs_ftime_t delta_time);
 
-static
-void http_purge_request_cache(
-    ecs_http_server_t *srv,
-    bool fini)
-{
-    ecs_time_t t = {0, 0};
-    double time = ecs_time_measure(&t);
-    ecs_map_iter_t it = ecs_map_iter(&srv->request_cache.impl);
-    while (ecs_map_next(&it)) {
-        ecs_hm_bucket_t *bucket = ecs_map_ptr(&it);
-        int32_t i, count = ecs_vec_count(&bucket->values);
-        ecs_http_request_key_t *keys = ecs_vec_first(&bucket->keys);
-        ecs_http_request_entry_t *entries = ecs_vec_first(&bucket->values);
-        for (i = count - 1; i >= 0; i --) {
-            ecs_http_request_entry_t *entry = &entries[i];
-            if (fini || ((time - entry->time) > srv->cache_purge_timeout)) {
-                ecs_http_request_key_t *key = &keys[i];
-                /* Safe, code owns the value */
-                ecs_os_free(ECS_CONST_CAST(char*, key->array));
-                ecs_os_free(entry->content);
-                flecs_hm_bucket_remove(&srv->request_cache, bucket, 
-                    ecs_map_key(&it), i);
-            }
-        }
-    }
+void flecs_create_worker_threads(
+    ecs_world_t *world);
 
-    if (fini) {
-        flecs_hashmap_fini(&srv->request_cache);
-    }
-}
+void flecs_join_worker_threads(
+    ecs_world_t *world);
 
-static
-int32_t http_dequeue_requests(
-    ecs_http_server_t *srv,
-    double delta_time)
-{
-    ecs_os_mutex_lock(srv->lock);
+void flecs_signal_workers(
+    ecs_world_t *world);
 
-    int32_t i, request_count = flecs_sparse_count(&srv->requests);
-    for (i = request_count - 1; i >= 1; i --) {
-        ecs_http_request_impl_t *req = flecs_sparse_get_dense_t(
-            &srv->requests, ecs_http_request_impl_t, i);
-        http_handle_request(srv, req);
-    }
+void flecs_wait_for_sync(
+    ecs_world_t *world);
 
-    int32_t connections_count = flecs_sparse_count(&srv->connections);
-    for (i = connections_count - 1; i >= 1; i --) {
-        ecs_http_connection_impl_t *conn = flecs_sparse_get_dense_t(
-            &srv->connections, ecs_http_connection_impl_t, i);
+#endif
 
-        conn->dequeue_timeout += delta_time;
-        conn->dequeue_retries ++;
-        
-        if ((conn->dequeue_timeout > 
-            (double)ECS_HTTP_CONNECTION_PURGE_TIMEOUT) &&
-             (conn->dequeue_retries > ECS_HTTP_CONNECTION_PURGE_RETRY_COUNT)) 
-        {
-            ecs_dbg("http: purging connection '%s:%s' (sock = %d)", 
-                conn->pub.host, conn->pub.port, conn->sock);
-            http_connection_free(conn);
-        }
-    }
+#endif
 
-    http_purge_request_cache(srv, false);
-    ecs_os_mutex_unlock(srv->lock);
+#ifdef FLECS_STATS
 
-    return request_count - 1;
-}
+#define ECS_GAUGE_RECORD(m, t, value)\
+    flecs_gauge_record(m, t, (ecs_float_t)(value))
 
-const char* ecs_http_get_header(
-    const ecs_http_request_t* req,
-    const char* name) 
+#define ECS_COUNTER_RECORD(m, t, value)\
+    flecs_counter_record(m, t, (double)(value))
+
+#define ECS_METRIC_FIRST(stats)\
+    ECS_CAST(ecs_metric_t*, ECS_OFFSET(&stats->first_, ECS_SIZEOF(int64_t)))
+
+#define ECS_METRIC_LAST(stats)\
+    ECS_CAST(ecs_metric_t*, ECS_OFFSET(&stats->last_, -ECS_SIZEOF(ecs_metric_t)))
+
+static
+int32_t t_next(
+    int32_t t)
 {
-    for (ecs_size_t i = 0; i < req->header_count; i++) {
-        if (!ecs_os_strcmp(req->headers[i].key, name)) {
-            return req->headers[i].value;
-        }
-    }
-    return NULL;
+    return (t + 1) % ECS_STAT_WINDOW;
 }
 
-const char* ecs_http_get_param(
-    const ecs_http_request_t* req,
-    const char* name) 
+static
+int32_t t_prev(
+    int32_t t)
 {
-    for (ecs_size_t i = 0; i < req->param_count; i++) {
-        if (!ecs_os_strcmp(req->params[i].key, name)) {
-            return req->params[i].value;
-        }
-    }
-    return NULL;
+    return (t - 1 + ECS_STAT_WINDOW) % ECS_STAT_WINDOW;
 }
 
-ecs_http_server_t* ecs_http_server_init(
-    const ecs_http_server_desc_t *desc) 
+static
+void flecs_gauge_record(
+    ecs_metric_t *m,
+    int32_t t,
+    ecs_float_t value)
 {
-    ecs_check(ecs_os_has_threading(), ECS_UNSUPPORTED, 
-        "missing OS API implementation");
-
-    ecs_http_server_t* srv = ecs_os_calloc_t(ecs_http_server_t);
-    srv->lock = ecs_os_mutex_new();
-    srv->sock = HTTP_SOCKET_INVALID;
-
-    srv->should_run = false;
-    srv->initialized = true;
-
-    srv->cache_timeout = desc->cache_timeout;
-    srv->cache_purge_timeout = desc->cache_purge_timeout;
-
-    if (!ECS_EQZERO(srv->cache_timeout) && 
-         ECS_EQZERO(srv->cache_purge_timeout)) 
-    {
-        srv->cache_purge_timeout = srv->cache_timeout * 10;
-    }
+    m->gauge.avg[t] = value;
+    m->gauge.min[t] = value;
+    m->gauge.max[t] = value;
+}
 
-    srv->callback = desc->callback;
-    srv->ctx = desc->ctx;
-    srv->port = desc->port;
-    srv->ipaddr = desc->ipaddr;
-    srv->send_queue.wait_ms = desc->send_queue_wait_ms;
-    if (!srv->send_queue.wait_ms) {
-        srv->send_queue.wait_ms = 1;
+static
+double flecs_counter_record(
+    ecs_metric_t *m,
+    int32_t t,
+    double value)
+{
+    int32_t tp = t_prev(t);
+    double prev = m->counter.value[tp];
+    m->counter.value[t] = value;
+    double gauge_value = value - prev;
+    if (gauge_value < 0) {
+        gauge_value = 0; /* Counters are monotonically increasing */
     }
+    flecs_gauge_record(m, t, (ecs_float_t)gauge_value);
+    return gauge_value;
+}
 
-    flecs_sparse_init_t(&srv->connections, NULL, NULL, ecs_http_connection_impl_t);
-    flecs_sparse_init_t(&srv->requests, NULL, NULL, ecs_http_request_impl_t);
-
-    /* Start at id 1 */
-    flecs_sparse_new_id(&srv->connections);
-    flecs_sparse_new_id(&srv->requests);
-
-    /* Initialize request cache */
-    flecs_hashmap_init(&srv->request_cache, 
-        ecs_http_request_key_t, ecs_http_request_entry_t,
-        http_request_key_hash, http_request_key_compare, NULL);
-
-#ifndef ECS_TARGET_WINDOWS
-    /* Ignore pipe signal. SIGPIPE can occur when a message is sent to a client
-     * but te client already disconnected. */
-    signal(SIGPIPE, SIG_IGN);
-#endif
+static
+void flecs_metric_print(
+    const char *name,
+    ecs_float_t value)
+{
+    ecs_size_t len = ecs_os_strlen(name);
+    ecs_trace("%s: %*s %.2f", name, 32 - len, "", (double)value);
+}
 
-    return srv;
-error:
-    return NULL;
+static
+void flecs_gauge_print(
+    const char *name,
+    int32_t t,
+    const ecs_metric_t *m)
+{
+    flecs_metric_print(name, m->gauge.avg[t]);
 }
 
-void ecs_http_server_fini(
-    ecs_http_server_t* srv) 
+static
+void flecs_counter_print(
+    const char *name,
+    int32_t t,
+    const ecs_metric_t *m)
 {
-    if (srv->should_run) {
-        ecs_http_server_stop(srv);
-    }
-    ecs_os_mutex_free(srv->lock);
-    http_purge_request_cache(srv, true);
-    flecs_sparse_fini(&srv->requests);
-    flecs_sparse_fini(&srv->connections);
-    ecs_os_free(srv);
+    flecs_metric_print(name, m->counter.rate.avg[t]);
 }
 
-int ecs_http_server_start(
-    ecs_http_server_t *srv)
+void ecs_metric_reduce(
+    ecs_metric_t *dst,
+    const ecs_metric_t *src,
+    int32_t t_dst,
+    int32_t t_src)
 {
-    ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(srv->initialized, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!srv->should_run, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!srv->thread, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(dst != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(src != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    srv->should_run = true;
+    bool min_set = false;
+    dst->gauge.avg[t_dst] = 0;
+    dst->gauge.min[t_dst] = 0;
+    dst->gauge.max[t_dst] = 0;
 
-    ecs_dbg("http: starting server thread");
+    ecs_float_t fwindow = (ecs_float_t)ECS_STAT_WINDOW;
 
-    srv->thread = ecs_os_thread_new(http_server_thread, srv);
-    if (!srv->thread) {
-        goto error;
-    }
+    int32_t i;
+    for (i = 0; i < ECS_STAT_WINDOW; i ++) {
+        int32_t t = (t_src + i) % ECS_STAT_WINDOW;
+        dst->gauge.avg[t_dst] += src->gauge.avg[t] / fwindow;
 
-    srv->send_queue.thread = ecs_os_thread_new(http_server_send_queue, srv);
-    if (!srv->send_queue.thread) {
-        goto error;
+        if (!min_set || (src->gauge.min[t] < dst->gauge.min[t_dst])) {
+            dst->gauge.min[t_dst] = src->gauge.min[t];
+            min_set = true;
+        }
+        if ((src->gauge.max[t] > dst->gauge.max[t_dst])) {
+            dst->gauge.max[t_dst] = src->gauge.max[t];
+        }
     }
 
-    return 0;
+    dst->counter.value[t_dst] = src->counter.value[t_src];
+
 error:
-    return -1;
+    return;
 }
 
-void ecs_http_server_stop(
-    ecs_http_server_t* srv) 
+void ecs_metric_reduce_last(
+    ecs_metric_t *m,
+    int32_t prev,
+    int32_t count)
 {
-    ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(srv->initialized, ECS_INVALID_OPERATION, NULL);
-    ecs_check(srv->should_run, ECS_INVALID_PARAMETER, NULL);
-
-    /* Stop server thread */
-    ecs_dbg("http: shutting down server thread");
+    ecs_check(m != NULL, ECS_INVALID_PARAMETER, NULL);
+    int32_t t = t_next(prev);
 
-    ecs_os_mutex_lock(srv->lock);
-    srv->should_run = false;
-    if (http_socket_is_valid(srv->sock)) {
-        http_close(&srv->sock);
+    if (m->gauge.min[t] < m->gauge.min[prev]) {
+        m->gauge.min[prev] = m->gauge.min[t];
     }
-    ecs_os_mutex_unlock(srv->lock);
 
-    ecs_os_thread_join(srv->thread);
-    ecs_os_thread_join(srv->send_queue.thread);
-    ecs_trace("http: server threads shut down");
-
-    /* Cleanup all outstanding requests */
-    int i, count = flecs_sparse_count(&srv->requests);
-    for (i = count - 1; i >= 1; i --) {
-        http_request_fini(flecs_sparse_get_dense_t(
-            &srv->requests, ecs_http_request_impl_t, i));
+    if (m->gauge.max[t] > m->gauge.max[prev]) {
+        m->gauge.max[prev] = m->gauge.max[t];
     }
 
-    /* Close all connections */
-    count = flecs_sparse_count(&srv->connections);
-    for (i = count - 1; i >= 1; i --) {
-        http_connection_free(flecs_sparse_get_dense_t(
-            &srv->connections, ecs_http_connection_impl_t, i));
-    }
+    ecs_float_t fcount = (ecs_float_t)(count + 1);
+    ecs_float_t cur = m->gauge.avg[prev];
+    ecs_float_t next = m->gauge.avg[t];
 
-    ecs_assert(flecs_sparse_count(&srv->connections) == 1, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(flecs_sparse_count(&srv->requests) == 1,
-        ECS_INTERNAL_ERROR, NULL);
+    cur *= ((fcount - 1) / fcount);
+    next *= 1 / fcount;
+
+    m->gauge.avg[prev] = cur + next;
+    m->counter.value[prev] = m->counter.value[t];
 
-    srv->thread = 0;
 error:
     return;
 }
 
-void ecs_http_server_dequeue(
-    ecs_http_server_t* srv,
-    ecs_ftime_t delta_time)
+void ecs_metric_copy(
+    ecs_metric_t *m,
+    int32_t dst,
+    int32_t src)
 {
-    ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(srv->initialized, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(srv->should_run, ECS_INVALID_PARAMETER, NULL);
-    
-    srv->dequeue_timeout += (double)delta_time;
-    srv->stats_timeout += (double)delta_time;
-
-    if ((1000 * srv->dequeue_timeout) > (double)ECS_HTTP_MIN_DEQUEUE_INTERVAL) {
-        srv->dequeue_timeout = 0;
-
-        ecs_time_t t = {0};
-        ecs_time_measure(&t);
-        int32_t request_count = http_dequeue_requests(srv, srv->dequeue_timeout);
-        srv->requests_processed += request_count;
-        srv->requests_processed_total += request_count;
-        double time_spent = ecs_time_measure(&t);
-        srv->request_time += time_spent;
-        srv->request_time_total += time_spent;
-        srv->dequeue_count ++;
-    }
+    ecs_check(m != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(dst != src, ECS_INVALID_PARAMETER, NULL);
 
-    if ((1000 * srv->stats_timeout) > (double)ECS_HTTP_MIN_STATS_INTERVAL) {
-        srv->stats_timeout = 0;
-        ecs_dbg("http: processed %d requests in %.3fs (avg %.3fs / dequeue)",
-            srv->requests_processed, srv->request_time, 
-            (srv->request_time / (double)srv->dequeue_count));
-        srv->requests_processed = 0;
-        srv->request_time = 0;
-        srv->dequeue_count = 0;
-    }
+    m->gauge.avg[dst] = m->gauge.avg[src];
+    m->gauge.min[dst] = m->gauge.min[src];
+    m->gauge.max[dst] = m->gauge.max[src];
+    m->counter.value[dst] = m->counter.value[src];
 
 error:
     return;
 }
 
-int ecs_http_server_http_request(
-    ecs_http_server_t* srv,
-    const char *req,
-    ecs_size_t len,
-    ecs_http_reply_t *reply_out)
+static
+void flecs_stats_reduce(
+    ecs_metric_t *dst_cur,
+    ecs_metric_t *dst_last,
+    ecs_metric_t *src_cur,
+    int32_t t_dst,
+    int32_t t_src)
 {
-    if (!len) {
-        len = ecs_os_strlen(req);
+    for (; dst_cur <= dst_last; dst_cur ++, src_cur ++) {
+        ecs_metric_reduce(dst_cur, src_cur, t_dst, t_src);
     }
+}
 
-    ecs_http_fragment_t frag = {0};
-    if (!http_parse_request(&frag, req, len)) {
-        ecs_strbuf_reset(&frag.buf);
-        reply_out->code = 400;
-        return -1;
-    }
+static
+void flecs_stats_reduce_last(
+    ecs_metric_t *dst_cur,
+    ecs_metric_t *dst_last,
+    ecs_metric_t *src_cur,
+    int32_t t_dst,
+    int32_t t_src,
+    int32_t count)
+{
+    int32_t t_dst_next = t_next(t_dst);
+    for (; dst_cur <= dst_last; dst_cur ++, src_cur ++) {
+        /* Reduce into previous value */
+        ecs_metric_reduce_last(dst_cur, t_dst, count);
 
-    ecs_http_request_impl_t request;
-    char *res = http_decode_request(&request, &frag);
-    if (!res) {
-        reply_out->code = 400;
-        return -1;
+        /* Restore old value */
+        dst_cur->gauge.avg[t_dst_next] = src_cur->gauge.avg[t_src];
+        dst_cur->gauge.min[t_dst_next] = src_cur->gauge.min[t_src];
+        dst_cur->gauge.max[t_dst_next] = src_cur->gauge.max[t_src];
+        dst_cur->counter.value[t_dst_next] = src_cur->counter.value[t_src];
     }
+}
 
-    ecs_http_request_entry_t *entry = 
-        http_find_request_entry(srv, request.res, request.req_len);
-    if (entry) {
-        reply_out->body = ECS_STRBUF_INIT;
-        reply_out->code = entry->code;
-        reply_out->content_type = "application/json";
-        reply_out->headers = ECS_STRBUF_INIT;
-        reply_out->status = "OK";
-        ecs_strbuf_appendstrn(&reply_out->body, 
-            entry->content, entry->content_length);
-    } else {
-        http_do_request(srv, reply_out, &request);
+static
+void flecs_stats_repeat_last(
+    ecs_metric_t *cur,
+    ecs_metric_t *last,
+    int32_t t)
+{
+    int32_t prev = t_prev(t);
+    for (; cur <= last; cur ++) {
+        ecs_metric_copy(cur, t, prev);
+    }
+}
 
-        if (request.pub.method == EcsHttpGet) {
-            http_insert_request_entry(srv, &request, reply_out);
-        }
+static
+void flecs_stats_copy_last(
+    ecs_metric_t *dst_cur,
+    ecs_metric_t *dst_last,
+    ecs_metric_t *src_cur,
+    int32_t t_dst,
+    int32_t t_src)
+{
+    for (; dst_cur <= dst_last; dst_cur ++, src_cur ++) {
+        dst_cur->gauge.avg[t_dst] = src_cur->gauge.avg[t_src];
+        dst_cur->gauge.min[t_dst] = src_cur->gauge.min[t_src];
+        dst_cur->gauge.max[t_dst] = src_cur->gauge.max[t_src];
+        dst_cur->counter.value[t_dst] = src_cur->counter.value[t_src];
     }
+}
 
-    ecs_os_free(res);
+void ecs_world_stats_get(
+    const ecs_world_t *world,
+    ecs_world_stats_t *s)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    http_purge_request_cache(srv, false);
+    world = ecs_get_world(world);
 
-    return (reply_out->code >= 400) ? -1 : 0;
-}
+    int32_t t = s->t = t_next(s->t);
 
-int ecs_http_server_request(
-    ecs_http_server_t* srv,
-    const char *method,
-    const char *req,
-    ecs_http_reply_t *reply_out)
-{
-    const char *http_ver = " HTTP/1.1\r\n\r\n";
-    int32_t method_len = ecs_os_strlen(method);
-    int32_t req_len = ecs_os_strlen(req);
-    int32_t http_ver_len = ecs_os_strlen(http_ver);
+    double delta_frame_count = 
+    ECS_COUNTER_RECORD(&s->frame.frame_count, t, world->info.frame_count_total);
+    ECS_COUNTER_RECORD(&s->frame.merge_count, t, world->info.merge_count_total);
+    ECS_COUNTER_RECORD(&s->frame.rematch_count, t, world->info.rematch_count_total);
+    ECS_COUNTER_RECORD(&s->frame.pipeline_build_count, t, world->info.pipeline_build_count_total);
+    ECS_COUNTER_RECORD(&s->frame.systems_ran, t, world->info.systems_ran_frame);
+    ECS_COUNTER_RECORD(&s->frame.observers_ran, t, world->info.observers_ran_frame);
+    ECS_COUNTER_RECORD(&s->frame.event_emit_count, t, world->event_id);
 
-    int32_t len = method_len + req_len + http_ver_len + 1;
-    if (method_len + req_len + http_ver_len >= 1024) {
-        ecs_err("HTTP request too long");
-        return -1;
+    double delta_world_time = 
+    ECS_COUNTER_RECORD(&s->performance.world_time_raw, t, world->info.world_time_total_raw);
+    ECS_COUNTER_RECORD(&s->performance.world_time, t, world->info.world_time_total);
+    ECS_COUNTER_RECORD(&s->performance.frame_time, t, world->info.frame_time_total);
+    ECS_COUNTER_RECORD(&s->performance.system_time, t, world->info.system_time_total);
+    ECS_COUNTER_RECORD(&s->performance.emit_time, t, world->info.emit_time_total);
+    ECS_COUNTER_RECORD(&s->performance.merge_time, t, world->info.merge_time_total);
+    ECS_COUNTER_RECORD(&s->performance.rematch_time, t, world->info.rematch_time_total);
+    ECS_GAUGE_RECORD(&s->performance.delta_time, t, delta_world_time);
+    if (ECS_NEQZERO(delta_world_time) && ECS_NEQZERO(delta_frame_count)) {
+        ECS_GAUGE_RECORD(&s->performance.fps, t, (double)1 / (delta_world_time / (double)delta_frame_count));
+    } else {
+        ECS_GAUGE_RECORD(&s->performance.fps, t, 0);
     }
 
-    char reqstr[1024];
-    char *ptr = reqstr;
-    ecs_os_memcpy(ptr, method, method_len); ptr += method_len;
-    ptr[0] = ' '; ptr ++;
-    ecs_os_memcpy(ptr, req, req_len); ptr += req_len;
-    ecs_os_memcpy(ptr, http_ver, http_ver_len); ptr += http_ver_len;
-    ptr[0] = '\n';
+    ECS_GAUGE_RECORD(&s->entities.count, t, flecs_entities_count(world));
+    ECS_GAUGE_RECORD(&s->entities.not_alive_count, t, flecs_entities_not_alive_count(world));
 
-    return ecs_http_server_http_request(srv, reqstr, len, reply_out);
-}
+    ECS_GAUGE_RECORD(&s->components.tag_count, t, world->info.tag_id_count);
+    ECS_GAUGE_RECORD(&s->components.component_count, t, world->info.component_id_count);
+    ECS_GAUGE_RECORD(&s->components.pair_count, t, world->info.pair_id_count);
+    ECS_GAUGE_RECORD(&s->components.type_count, t, ecs_sparse_count(&world->type_info));
+    ECS_COUNTER_RECORD(&s->components.create_count, t, world->info.id_create_total);
+    ECS_COUNTER_RECORD(&s->components.delete_count, t, world->info.id_delete_total);
 
-void* ecs_http_server_ctx(
-    ecs_http_server_t* srv)
-{
-    return srv->ctx;
-}
+    ECS_GAUGE_RECORD(&s->queries.query_count, t, ecs_count_id(world, EcsQuery));
+    ECS_GAUGE_RECORD(&s->queries.observer_count, t, ecs_count_id(world, EcsObserver));
+    if (ecs_is_alive(world, EcsSystem)) {
+        ECS_GAUGE_RECORD(&s->queries.system_count, t, ecs_count_id(world, EcsSystem));
+    }
+    ECS_COUNTER_RECORD(&s->tables.create_count, t, world->info.table_create_total);
+    ECS_COUNTER_RECORD(&s->tables.delete_count, t, world->info.table_delete_total);
+    ECS_GAUGE_RECORD(&s->tables.count, t, world->info.table_count);
+    ECS_GAUGE_RECORD(&s->tables.empty_count, t, world->info.empty_table_count);
 
-#endif
+    ECS_COUNTER_RECORD(&s->commands.add_count, t, world->info.cmd.add_count);
+    ECS_COUNTER_RECORD(&s->commands.remove_count, t, world->info.cmd.remove_count);
+    ECS_COUNTER_RECORD(&s->commands.delete_count, t, world->info.cmd.delete_count);
+    ECS_COUNTER_RECORD(&s->commands.clear_count, t, world->info.cmd.clear_count);
+    ECS_COUNTER_RECORD(&s->commands.set_count, t, world->info.cmd.set_count);
+    ECS_COUNTER_RECORD(&s->commands.ensure_count, t, world->info.cmd.ensure_count);
+    ECS_COUNTER_RECORD(&s->commands.modified_count, t, world->info.cmd.modified_count);
+    ECS_COUNTER_RECORD(&s->commands.other_count, t, world->info.cmd.other_count);
+    ECS_COUNTER_RECORD(&s->commands.discard_count, t, world->info.cmd.discard_count);
+    ECS_COUNTER_RECORD(&s->commands.batched_entity_count, t, world->info.cmd.batched_entity_count);
+    ECS_COUNTER_RECORD(&s->commands.batched_count, t, world->info.cmd.batched_command_count);
 
-/**
- * @file addons/journal.c
- * @brief Journal addon.
- */
+    int64_t outstanding_allocs = ecs_os_api_malloc_count + 
+        ecs_os_api_calloc_count - ecs_os_api_free_count;
+    ECS_COUNTER_RECORD(&s->memory.alloc_count, t, ecs_os_api_malloc_count + ecs_os_api_calloc_count);
+    ECS_COUNTER_RECORD(&s->memory.realloc_count, t, ecs_os_api_realloc_count);
+    ECS_COUNTER_RECORD(&s->memory.free_count, t, ecs_os_api_free_count);
+    ECS_GAUGE_RECORD(&s->memory.outstanding_alloc_count, t, outstanding_allocs);
 
+    outstanding_allocs = ecs_block_allocator_alloc_count - ecs_block_allocator_free_count;
+    ECS_COUNTER_RECORD(&s->memory.block_alloc_count, t, ecs_block_allocator_alloc_count);
+    ECS_COUNTER_RECORD(&s->memory.block_free_count, t, ecs_block_allocator_free_count);
+    ECS_GAUGE_RECORD(&s->memory.block_outstanding_alloc_count, t, outstanding_allocs);
 
-#ifdef FLECS_JOURNAL
+    outstanding_allocs = ecs_stack_allocator_alloc_count - ecs_stack_allocator_free_count;
+    ECS_COUNTER_RECORD(&s->memory.stack_alloc_count, t, ecs_stack_allocator_alloc_count);
+    ECS_COUNTER_RECORD(&s->memory.stack_free_count, t, ecs_stack_allocator_free_count);
+    ECS_GAUGE_RECORD(&s->memory.stack_outstanding_alloc_count, t, outstanding_allocs);
 
-static
-char* flecs_journal_entitystr(
-    ecs_world_t *world,
-    ecs_entity_t entity)
-{
-    char *path;
-    const char *_path = ecs_get_symbol(world, entity);
-    if (_path && !strchr(_path, '.')) {
-        path = ecs_asprintf("#[blue]%s", _path);
-    } else {
-        uint32_t gen = entity >> 32;
-        if (gen) {
-            path = ecs_asprintf("#[normal]_%u_%u", (uint32_t)entity, gen);
-        } else {
-            path = ecs_asprintf("#[normal]_%u", (uint32_t)entity);
-        }
-    }
-    return path;
+#ifdef FLECS_HTTP
+    ECS_COUNTER_RECORD(&s->http.request_received_count, t, ecs_http_request_received_count);
+    ECS_COUNTER_RECORD(&s->http.request_invalid_count, t, ecs_http_request_invalid_count);
+    ECS_COUNTER_RECORD(&s->http.request_handled_ok_count, t, ecs_http_request_handled_ok_count);
+    ECS_COUNTER_RECORD(&s->http.request_handled_error_count, t, ecs_http_request_handled_error_count);
+    ECS_COUNTER_RECORD(&s->http.request_not_handled_count, t, ecs_http_request_not_handled_count);
+    ECS_COUNTER_RECORD(&s->http.request_preflight_count, t, ecs_http_request_preflight_count);
+    ECS_COUNTER_RECORD(&s->http.send_ok_count, t, ecs_http_send_ok_count);
+    ECS_COUNTER_RECORD(&s->http.send_error_count, t, ecs_http_send_error_count);
+    ECS_COUNTER_RECORD(&s->http.busy_count, t, ecs_http_busy_count);
+#endif
+
+error:
+    return;
 }
 
-static
-char* flecs_journal_idstr(
-    ecs_world_t *world,
-    ecs_id_t id)
+void ecs_world_stats_reduce(
+    ecs_world_stats_t *dst,
+    const ecs_world_stats_t *src)
 {
-    if (ECS_IS_PAIR(id)) {
-        char *first_path = flecs_journal_entitystr(world, 
-            ecs_pair_first(world, id));
-        char *second_path = flecs_journal_entitystr(world, 
-            ecs_pair_second(world, id));
-        char *result = ecs_asprintf("#[cyan]ecs_pair#[normal](%s, %s)",
-            first_path, second_path);
-        ecs_os_free(first_path);
-        ecs_os_free(second_path);
-        return result;
-    } else if (!(id & ECS_ID_FLAGS_MASK)) {
-        return flecs_journal_entitystr(world, id);
-    } else {
-        return ecs_id_str(world, id);
-    }
+    flecs_stats_reduce(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
+        ECS_METRIC_FIRST(src), (dst->t = t_next(dst->t)), src->t);
 }
 
-static int flecs_journal_sp = 0;
-
-void flecs_journal_begin(
-    ecs_world_t *world,
-    ecs_journal_kind_t kind,
-    ecs_entity_t entity,
-    ecs_type_t *add,
-    ecs_type_t *remove)
+void ecs_world_stats_reduce_last(
+    ecs_world_stats_t *dst,
+    const ecs_world_stats_t *src,
+    int32_t count)
 {
-    flecs_journal_sp ++;
-
-    if (ecs_os_api.log_level_ < FLECS_JOURNAL_LOG_LEVEL) {
-        return;
-    }
-
-    char *path = NULL; 
-    char *var_id = NULL; 
-    if (entity) {
-        if (kind != EcsJournalDeleteWith && kind != EcsJournalRemoveAll) {
-            path = ecs_get_fullpath(world, entity);
-            var_id = flecs_journal_entitystr(world, entity);
-        } else {
-            path = ecs_id_str(world, entity);
-            var_id = flecs_journal_idstr(world, entity);
-        }
-    }
-
-    if (kind == EcsJournalNew) {
-        ecs_print(4, "#[magenta]#ifndef #[normal]_var_%s", var_id);
-        ecs_print(4, "#[magenta]#define #[normal]_var_%s", var_id);
-        ecs_print(4, "#[green]ecs_entity_t %s;", var_id);
-        ecs_print(4, "#[magenta]#endif");
-        ecs_print(4, "%s = #[cyan]ecs_new_id#[reset](world); "
-            "#[grey] // %s = new()", var_id, path);
-    }
-    if (add) {
-        for (int i = 0; i < add->count; i ++) {
-            char *jidstr = flecs_journal_idstr(world, add->array[i]);
-            char *idstr = ecs_id_str(world, add->array[i]);
-            ecs_print(4, "#[cyan]ecs_add_id#[reset](world, %s, %s); "
-                "#[grey] // add(%s, %s)", var_id, jidstr, 
-                    path, idstr);
-            ecs_os_free(idstr);
-            ecs_os_free(jidstr);
-        }
-    }
-    if (remove) {
-        for (int i = 0; i < remove->count; i ++) {
-            char *jidstr = flecs_journal_idstr(world, remove->array[i]);
-            char *idstr = ecs_id_str(world, remove->array[i]);
-            ecs_print(4, "#[cyan]ecs_remove_id#[reset](world, %s, %s); "
-                "#[grey] // remove(%s, %s)", var_id, jidstr, 
-                    path, idstr);
-            ecs_os_free(idstr);
-            ecs_os_free(jidstr);
-        }
-    }
-    if (kind == EcsJournalClear) {
-        ecs_print(4, "#[cyan]ecs_clear#[reset](world, %s); "
-            "#[grey] // clear(%s)", var_id, path);
-    } else if (kind == EcsJournalDelete) {
-        ecs_print(4, "#[cyan]ecs_delete#[reset](world, %s); "
-            "#[grey] // delete(%s)", var_id, path);
-    } else if (kind == EcsJournalDeleteWith) {
-        ecs_print(4, "#[cyan]ecs_delete_with#[reset](world, %s); "
-            "#[grey] // delete_with(%s)", var_id, path);
-    } else if (kind == EcsJournalRemoveAll) {
-        ecs_print(4, "#[cyan]ecs_remove_all#[reset](world, %s); "
-            "#[grey] // remove_all(%s)", var_id, path);
-    } else if (kind == EcsJournalTableEvents) {
-        ecs_print(4, "#[cyan]ecs_run_aperiodic#[reset](world, "
-            "EcsAperiodicEmptyTables);");
-    }
-    ecs_os_free(var_id);
-    ecs_os_free(path);
-    ecs_log_push();
+    flecs_stats_reduce_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
+        ECS_METRIC_FIRST(src), (dst->t = t_prev(dst->t)), src->t, count);
 }
 
-void flecs_journal_end(void) {
-    flecs_journal_sp --;
-    ecs_assert(flecs_journal_sp >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_log_pop();
+void ecs_world_stats_repeat_last(
+    ecs_world_stats_t *stats)
+{
+    flecs_stats_repeat_last(ECS_METRIC_FIRST(stats), ECS_METRIC_LAST(stats),
+        (stats->t = t_next(stats->t)));
 }
 
-#endif
-
-/**
- * @file addons/log.c
- * @brief Log addon.
- */
-
-
-#ifdef FLECS_LOG
-
-#include <ctype.h>
+void ecs_world_stats_copy_last(
+    ecs_world_stats_t *dst,
+    const ecs_world_stats_t *src)
+{
+    flecs_stats_copy_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst),
+        ECS_METRIC_FIRST(src), dst->t, t_next(src->t));
+}
 
-void flecs_colorize_buf(
-    char *msg,
-    bool enable_colors,
-    ecs_strbuf_t *buf)
+void ecs_query_stats_get(
+    const ecs_world_t *world,
+    const ecs_query_t *query,
+    ecs_query_stats_t *s)
 {
-    ecs_assert(msg != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(buf != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
+    (void)world;
 
-    char *ptr, ch, prev = '\0';
-    bool isNum = false;
-    char isStr = '\0';
-    bool isVar = false;
-    bool overrideColor = false;
-    bool autoColor = true;
-    bool dontAppend = false;
+    int32_t t = s->t = t_next(s->t);    
+    ecs_query_count_t counts = ecs_query_count(query);
+    ECS_COUNTER_RECORD(&s->result_count, t, counts.results);
+    ECS_COUNTER_RECORD(&s->matched_table_count, t, counts.tables);
+    ECS_COUNTER_RECORD(&s->matched_empty_table_count, t, counts.empty_tables);
+    ECS_COUNTER_RECORD(&s->matched_entity_count, t, counts.entities);
+    ECS_COUNTER_RECORD(&s->eval_count, t, query->eval_count);
 
-    for (ptr = msg; (ch = *ptr); ptr++) {
-        dontAppend = false;
+error:
+    return;
+}
 
-        if (!overrideColor) {
-            if (isNum && !isdigit(ch) && !isalpha(ch) && (ch != '.') && (ch != '%')) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
-                isNum = false;
-            }
-            if (isStr && (isStr == ch) && prev != '\\') {
-                isStr = '\0';
-            } else if (((ch == '\'') || (ch == '"')) && !isStr &&
-                !isalpha(prev) && (prev != '\\'))
-            {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_CYAN);
-                isStr = ch;
-            }
+void ecs_query_cache_stats_reduce(
+    ecs_query_stats_t *dst,
+    const ecs_query_stats_t *src)
+{
+    flecs_stats_reduce(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
+        ECS_METRIC_FIRST(src), (dst->t = t_next(dst->t)), src->t);
+}
 
-            if ((isdigit(ch) || (ch == '%' && isdigit(prev)) ||
-                (ch == '-' && isdigit(ptr[1]))) && !isNum && !isStr && !isVar &&
-                 !isalpha(prev) && !isdigit(prev) && (prev != '_') &&
-                 (prev != '.'))
-            {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_GREEN);
-                isNum = true;
-            }
+void ecs_query_cache_stats_reduce_last(
+    ecs_query_stats_t *dst,
+    const ecs_query_stats_t *src,
+    int32_t count)
+{
+    flecs_stats_reduce_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
+        ECS_METRIC_FIRST(src), (dst->t = t_prev(dst->t)), src->t, count);
+}
 
-            if (isVar && !isalpha(ch) && !isdigit(ch) && ch != '_') {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
-                isVar = false;
-            }
+void ecs_query_cache_stats_repeat_last(
+    ecs_query_stats_t *stats)
+{
+    flecs_stats_repeat_last(ECS_METRIC_FIRST(stats), ECS_METRIC_LAST(stats),
+        (stats->t = t_next(stats->t)));
+}
 
-            if (!isStr && !isVar && ch == '$' && isalpha(ptr[1])) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_CYAN);
-                isVar = true;
-            }
-        }
+void ecs_query_cache_stats_copy_last(
+    ecs_query_stats_t *dst,
+    const ecs_query_stats_t *src)
+{
+    flecs_stats_copy_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst),
+        ECS_METRIC_FIRST(src), dst->t, t_next(src->t));
+}
 
-        if (!isVar && !isStr && !isNum && ch == '#' && ptr[1] == '[') {
-            bool isColor = true;
-            overrideColor = true;
+#ifdef FLECS_SYSTEM
 
-            /* Custom colors */
-            if (!ecs_os_strncmp(&ptr[2], "]", ecs_os_strlen("]"))) {
-                autoColor = false;
-            } else if (!ecs_os_strncmp(&ptr[2], "green]", ecs_os_strlen("green]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_GREEN);
-            } else if (!ecs_os_strncmp(&ptr[2], "red]", ecs_os_strlen("red]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_RED);
-            } else if (!ecs_os_strncmp(&ptr[2], "blue]", ecs_os_strlen("red]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_BLUE);
-            } else if (!ecs_os_strncmp(&ptr[2], "magenta]", ecs_os_strlen("magenta]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_MAGENTA);
-            } else if (!ecs_os_strncmp(&ptr[2], "cyan]", ecs_os_strlen("cyan]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_CYAN);
-            } else if (!ecs_os_strncmp(&ptr[2], "yellow]", ecs_os_strlen("yellow]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_YELLOW);
-            } else if (!ecs_os_strncmp(&ptr[2], "grey]", ecs_os_strlen("grey]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_GREY);
-            } else if (!ecs_os_strncmp(&ptr[2], "white]", ecs_os_strlen("white]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
-            } else if (!ecs_os_strncmp(&ptr[2], "bold]", ecs_os_strlen("bold]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_BOLD);
-            } else if (!ecs_os_strncmp(&ptr[2], "normal]", ecs_os_strlen("normal]"))) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
-            } else if (!ecs_os_strncmp(&ptr[2], "reset]", ecs_os_strlen("reset]"))) {
-                overrideColor = false;
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
-            } else {
-                isColor = false;
-                overrideColor = false;
-            }
+bool ecs_system_stats_get(
+    const ecs_world_t *world,
+    ecs_entity_t system,
+    ecs_system_stats_t *s)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL);
 
-            if (isColor) {
-                ptr += 2;
-                while ((ch = *ptr) != ']') ptr ++;
-                dontAppend = true;
-            }
-            if (!autoColor) {
-                overrideColor = true;
-            }
-        }
+    world = ecs_get_world(world);
 
-        if (ch == '\n') {
-            if (isNum || isStr || isVar || overrideColor) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
-                overrideColor = false;
-                isNum = false;
-                isStr = false;
-                isVar = false;
-            }
-        }
+    const ecs_system_t *ptr = flecs_poly_get(world, system, ecs_system_t);
+    if (!ptr) {
+        return false;
+    }
 
-        if (!dontAppend) {
-            ecs_strbuf_appendstrn(buf, ptr, 1);
-        }
+    ecs_query_stats_get(world, ptr->query, &s->query);
+    int32_t t = s->query.t;
 
-        if (!overrideColor) {
-            if (((ch == '\'') || (ch == '"')) && !isStr) {
-                if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
-            }
-        }
+    ECS_COUNTER_RECORD(&s->time_spent, t, ptr->time_spent);
 
-        prev = ch;
-    }
+    s->task = !(ptr->query->flags & EcsQueryMatchThis);
 
-    if (isNum || isStr || isVar || overrideColor) {
-        if (enable_colors) ecs_strbuf_appendlit(buf, ECS_NORMAL);
-    }
+    return true;
+error:
+    return false;
 }
 
-void ecs_printv_(
-    int level,
-    const char *file,
-    int32_t line,
-    const char *fmt,
-    va_list args)
+void ecs_system_stats_reduce(
+    ecs_system_stats_t *dst,
+    const ecs_system_stats_t *src)
 {
-    (void)level;
-    (void)line;
-
-    ecs_strbuf_t msg_buf = ECS_STRBUF_INIT;
-
-    /* Apply color. Even if we don't want color, we still need to call the
-     * colorize function to get rid of the color tags (e.g. #[green]) */
-    char *msg_nocolor = ecs_vasprintf(fmt, args);
-    flecs_colorize_buf(msg_nocolor, 
-        ecs_os_api.flags_ & EcsOsApiLogWithColors, &msg_buf);
-    ecs_os_free(msg_nocolor);
-
-    char *msg = ecs_strbuf_get(&msg_buf);
-
-    if (msg) {
-        ecs_os_api.log_(level, file, line, msg);
-        ecs_os_free(msg);
-    } else {
-        ecs_os_api.log_(level, file, line, "");
-    }
+    ecs_query_cache_stats_reduce(&dst->query, &src->query);
+    dst->task = src->task;
+    flecs_stats_reduce(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
+        ECS_METRIC_FIRST(src), dst->query.t, src->query.t);
 }
 
-void ecs_print_(
-    int level,
-    const char *file,
-    int32_t line,
-    const char *fmt,
-    ...)
+void ecs_system_stats_reduce_last(
+    ecs_system_stats_t *dst,
+    const ecs_system_stats_t *src,
+    int32_t count)
 {
-    va_list args;
-    va_start(args, fmt);
-    ecs_printv_(level, file, line, fmt, args);
-    va_end(args);    
+    ecs_query_cache_stats_reduce_last(&dst->query, &src->query, count);
+    dst->task = src->task;
+    flecs_stats_reduce_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
+        ECS_METRIC_FIRST(src), dst->query.t, src->query.t, count);
 }
 
-void ecs_logv_(
-    int level,
-    const char *file,
-    int32_t line,
-    const char *fmt,
-    va_list args)
+void ecs_system_stats_repeat_last(
+    ecs_system_stats_t *stats)
 {
-    if (level > ecs_os_api.log_level_) {
-        return;
-    }
-
-    ecs_printv_(level, file, line, fmt, args);
+    ecs_query_cache_stats_repeat_last(&stats->query);
+    flecs_stats_repeat_last(ECS_METRIC_FIRST(stats), ECS_METRIC_LAST(stats),
+        (stats->query.t));
 }
 
-void ecs_log_(
-    int level,
-    const char *file,
-    int32_t line,
-    const char *fmt,
-    ...)
+void ecs_system_stats_copy_last(
+    ecs_system_stats_t *dst,
+    const ecs_system_stats_t *src)
 {
-    if (level > ecs_os_api.log_level_) {
-        return;
-    }
-
-    va_list args;
-    va_start(args, fmt);
-    ecs_printv_(level, file, line, fmt, args);
-    va_end(args);    
+    ecs_query_cache_stats_copy_last(&dst->query, &src->query);
+    dst->task = src->task;
+    flecs_stats_copy_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst),
+        ECS_METRIC_FIRST(src), dst->query.t, t_next(src->query.t));
 }
 
+#endif
 
-void ecs_log_push_(
-    int32_t level) 
-{
-    if (level <= ecs_os_api.log_level_) {
-        ecs_os_api.log_indent_ ++;
-    }
-}
+#ifdef FLECS_PIPELINE
 
-void ecs_log_pop_(
-    int32_t level)
+bool ecs_pipeline_stats_get(
+    ecs_world_t *stage,
+    ecs_entity_t pipeline,
+    ecs_pipeline_stats_t *s)
 {
-    if (level <= ecs_os_api.log_level_) {
-        ecs_os_api.log_indent_ --;
-        ecs_assert(ecs_os_api.log_indent_ >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(pipeline != 0, ECS_INVALID_PARAMETER, NULL);
+
+    const ecs_world_t *world = ecs_get_world(stage);
+    const EcsPipeline *pqc = ecs_get(world, pipeline, EcsPipeline);
+    if (!pqc) {
+        return false;
     }
-}
+    ecs_pipeline_state_t *pq = pqc->state;
+    ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL);
 
-void ecs_parser_errorv_(
-    const char *name,
-    const char *expr, 
-    int64_t column_arg,
-    const char *fmt,
-    va_list args)
-{
-    if (column_arg > 65536) {
-        /* Limit column size, which prevents the code from throwing up when the
-         * function is called with (expr - ptr), and expr is NULL. */
-        column_arg = 0;
+    int32_t sys_count = 0, active_sys_count = 0;
+
+    /* Count number of active systems */
+    ecs_iter_t it = ecs_query_iter(stage, pq->query);
+    while (ecs_query_next(&it)) {
+        if (flecs_id_record_get_table(pq->idr_inactive, it.table) != NULL) {
+            continue;
+        }
+        active_sys_count += it.count;
     }
-    int32_t column = flecs_itoi32(column_arg);
 
-    if (ecs_os_api.log_level_ >= -2) {
-        ecs_strbuf_t msg_buf = ECS_STRBUF_INIT;
+    /* Count total number of systems in pipeline */
+    it = ecs_query_iter(stage, pq->query);
+    while (ecs_query_next(&it)) {
+        sys_count += it.count;
+    }   
 
-        ecs_strbuf_vappend(&msg_buf, fmt, args);
+    /* Also count synchronization points */
+    ecs_vec_t *ops = &pq->ops;
+    ecs_pipeline_op_t *op = ecs_vec_first_t(ops, ecs_pipeline_op_t);
+    ecs_pipeline_op_t *op_last = ecs_vec_last_t(ops, ecs_pipeline_op_t);
+    int32_t pip_count = active_sys_count + ecs_vec_count(ops);
 
-        if (expr) {
-            ecs_strbuf_appendch(&msg_buf, '\n');
+    if (!sys_count) {
+        return false;
+    }
 
-            /* Find start of line by taking column and looking for the
-             * last occurring newline */
-            if (column != -1) {
-                const char *ptr = &expr[column];
-                while (ptr[0] != '\n' && ptr > expr) {
-                    ptr --;
+    if (ecs_map_is_init(&s->system_stats) && !sys_count) {
+        ecs_map_fini(&s->system_stats);
+    }
+    ecs_map_init_if(&s->system_stats, NULL);
+
+    if (op) {
+        ecs_entity_t *systems = NULL;
+        if (pip_count) {
+            ecs_vec_init_if_t(&s->systems, ecs_entity_t);
+            ecs_vec_set_count_t(NULL, &s->systems, ecs_entity_t, pip_count);
+            systems = ecs_vec_first_t(&s->systems, ecs_entity_t);
+
+            /* Populate systems vector, keep track of sync points */
+            it = ecs_query_iter(stage, pq->query);
+            
+            int32_t i, i_system = 0, ran_since_merge = 0;
+            while (ecs_query_next(&it)) {
+                if (flecs_id_record_get_table(pq->idr_inactive, it.table) != NULL) {
+                    continue;
                 }
 
-                if (ptr == expr) {
-                    /* ptr is already at start of line */
-                } else {
-                    column -= (int32_t)(ptr - expr + 1);
-                    expr = ptr + 1;
+                for (i = 0; i < it.count; i ++) {
+                    systems[i_system ++] = it.entities[i];
+                    ran_since_merge ++;
+                    if (op != op_last && ran_since_merge == op->count) {
+                        ran_since_merge = 0;
+                        op++;
+                        systems[i_system ++] = 0; /* 0 indicates a merge point */
+                    }
                 }
             }
 
-            /* Strip newlines from current statement, if any */            
-            char *newline_ptr = strchr(expr, '\n');
-            if (newline_ptr) {
-                /* Strip newline from expr */
-                ecs_strbuf_appendstrn(&msg_buf, expr, 
-                    (int32_t)(newline_ptr - expr));
-            } else {
-                ecs_strbuf_appendstr(&msg_buf, expr);
-            }
+            systems[i_system ++] = 0; /* Last merge */
+            ecs_assert(pip_count == i_system, ECS_INTERNAL_ERROR, NULL);
+        } else {
+            ecs_vec_fini_t(NULL, &s->systems, ecs_entity_t);
+        }
 
-            ecs_strbuf_appendch(&msg_buf, '\n');
+        /* Get sync point statistics */
+        int32_t i, count = ecs_vec_count(ops);
+        if (count) {
+            ecs_vec_init_if_t(&s->sync_points, ecs_sync_stats_t);
+            ecs_vec_set_min_count_zeromem_t(NULL, &s->sync_points, ecs_sync_stats_t, count);
+            op = ecs_vec_first_t(ops, ecs_pipeline_op_t);
 
-            if (column != -1) {
-                int32_t c;
-                for (c = 0; c < column; c ++) {
-                    ecs_strbuf_appendch(&msg_buf, ' ');
-                }
-                ecs_strbuf_appendch(&msg_buf, '^');
+            for (i = 0; i < count; i ++) {
+                ecs_pipeline_op_t *cur = &op[i];
+                ecs_sync_stats_t *el = ecs_vec_get_t(&s->sync_points, 
+                    ecs_sync_stats_t, i);
+
+                ECS_COUNTER_RECORD(&el->time_spent, s->t, cur->time_spent);
+                ECS_COUNTER_RECORD(&el->commands_enqueued, s->t, 
+                    cur->commands_enqueued);
+
+                el->system_count = cur->count;
+                el->multi_threaded = cur->multi_threaded;
+                el->immediate = cur->immediate;
             }
         }
+    }
 
-        char *msg = ecs_strbuf_get(&msg_buf);
-        ecs_os_err(name, 0, msg);
-        ecs_os_free(msg);
+    /* Separately populate system stats map from build query, which includes
+     * systems that aren't currently active */
+    it = ecs_query_iter(stage, pq->query);
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            ecs_system_stats_t *stats = ecs_map_ensure_alloc_t(&s->system_stats, 
+                ecs_system_stats_t, it.entities[i]);
+            stats->query.t = s->t;
+
+            ecs_system_stats_get(world, it.entities[i], stats);
+        }
     }
+
+    s->t = t_next(s->t);
+
+    return true;
+error:
+    return false;
 }
 
-void ecs_parser_error_(
-    const char *name,
-    const char *expr, 
-    int64_t column,
-    const char *fmt,
-    ...)
+void ecs_pipeline_stats_fini(
+    ecs_pipeline_stats_t *stats)
 {
-    if (ecs_os_api.log_level_  >= -2) {
-        va_list args;
-        va_start(args, fmt);
-        ecs_parser_errorv_(name, expr, column, fmt, args);
-        va_end(args);
+    ecs_map_iter_t it = ecs_map_iter(&stats->system_stats);
+    while (ecs_map_next(&it)) {
+        ecs_system_stats_t *elem = ecs_map_ptr(&it);
+        ecs_os_free(elem);
     }
+    ecs_map_fini(&stats->system_stats);
+    ecs_vec_fini_t(NULL, &stats->systems, ecs_entity_t);
+    ecs_vec_fini_t(NULL, &stats->sync_points, ecs_sync_stats_t);
 }
 
-void ecs_abort_(
-    int32_t err,
-    const char *file,
-    int32_t line,
-    const char *fmt,
-    ...)
+void ecs_pipeline_stats_reduce(
+    ecs_pipeline_stats_t *dst,
+    const ecs_pipeline_stats_t *src)
 {
-    if (fmt) {
-        va_list args;
-        va_start(args, fmt);
-        char *msg = ecs_vasprintf(fmt, args);
-        va_end(args);
-        ecs_fatal_(file, line, "%s (%s)", msg, ecs_strerror(err));
-        ecs_os_free(msg);
-    } else {
-        ecs_fatal_(file, line, "%s", ecs_strerror(err));
+    int32_t system_count = ecs_vec_count(&src->systems);
+    ecs_vec_init_if_t(&dst->systems, ecs_entity_t);
+    ecs_vec_set_count_t(NULL, &dst->systems, ecs_entity_t, system_count);
+    ecs_entity_t *dst_systems = ecs_vec_first_t(&dst->systems, ecs_entity_t);
+    ecs_entity_t *src_systems = ecs_vec_first_t(&src->systems, ecs_entity_t);
+    ecs_os_memcpy_n(dst_systems, src_systems, ecs_entity_t, system_count);
+
+    int32_t i, sync_count = ecs_vec_count(&src->sync_points);
+    ecs_vec_init_if_t(&dst->sync_points, ecs_sync_stats_t);
+    ecs_vec_set_min_count_zeromem_t(NULL, &dst->sync_points, ecs_sync_stats_t, sync_count);
+    ecs_sync_stats_t *dst_syncs = ecs_vec_first_t(&dst->sync_points, ecs_sync_stats_t);
+    ecs_sync_stats_t *src_syncs = ecs_vec_first_t(&src->sync_points, ecs_sync_stats_t);
+    for (i = 0; i < sync_count; i ++) {
+        ecs_sync_stats_t *dst_el = &dst_syncs[i];
+        ecs_sync_stats_t *src_el = &src_syncs[i];
+        flecs_stats_reduce(ECS_METRIC_FIRST(dst_el), ECS_METRIC_LAST(dst_el),
+            ECS_METRIC_FIRST(src_el), dst->t, src->t);
+        dst_el->system_count = src_el->system_count;
+        dst_el->multi_threaded = src_el->multi_threaded;
+        dst_el->immediate = src_el->immediate;
     }
-    ecs_os_api.log_last_error_ = err;
-}
 
-void ecs_assert_log_(
-    int32_t err,
-    const char *cond_str,
-    const char *file,
-    int32_t line,
-    const char *fmt,
-    ...)
-{
-    if (fmt) {
-        va_list args;
-        va_start(args, fmt);
-        char *msg = ecs_vasprintf(fmt, args);
-        va_end(args);
-        ecs_fatal_(file, line, "assert: %s %s (%s)",
-            cond_str, msg, ecs_strerror(err));
-        ecs_os_free(msg);
-    } else {
-        ecs_fatal_(file, line, "assert: %s %s",
-            cond_str, ecs_strerror(err));
+    ecs_map_init_if(&dst->system_stats, NULL);
+    ecs_map_iter_t it = ecs_map_iter(&src->system_stats);
+    
+    while (ecs_map_next(&it)) {
+        ecs_system_stats_t *sys_src = ecs_map_ptr(&it);
+        ecs_system_stats_t *sys_dst = ecs_map_ensure_alloc_t(&dst->system_stats, 
+            ecs_system_stats_t, ecs_map_key(&it));
+        sys_dst->query.t = dst->t;
+        ecs_system_stats_reduce(sys_dst, sys_src);
     }
-    ecs_os_api.log_last_error_ = err;
+    dst->t = t_next(dst->t);
 }
 
-void ecs_deprecated_(
-    const char *file,
-    int32_t line,
-    const char *msg)
+void ecs_pipeline_stats_reduce_last(
+    ecs_pipeline_stats_t *dst,
+    const ecs_pipeline_stats_t *src,
+    int32_t count)
 {
-    ecs_err_(file, line, "%s", msg);
-}
+    int32_t i, sync_count = ecs_vec_count(&src->sync_points);
+    ecs_sync_stats_t *dst_syncs = ecs_vec_first_t(&dst->sync_points, ecs_sync_stats_t);
+    ecs_sync_stats_t *src_syncs = ecs_vec_first_t(&src->sync_points, ecs_sync_stats_t);
 
-bool ecs_should_log(int32_t level) {
-#   if !defined(FLECS_LOG_3)
-    if (level == 3) {
-        return false;
-    }
-#   endif
-#   if !defined(FLECS_LOG_2)
-    if (level == 2) {
-        return false;
-    }
-#   endif
-#   if !defined(FLECS_LOG_1)
-    if (level == 1) {
-        return false;
+    for (i = 0; i < sync_count; i ++) {
+        ecs_sync_stats_t *dst_el = &dst_syncs[i];
+        ecs_sync_stats_t *src_el = &src_syncs[i];
+        flecs_stats_reduce_last(ECS_METRIC_FIRST(dst_el), ECS_METRIC_LAST(dst_el),
+            ECS_METRIC_FIRST(src_el), dst->t, src->t, count);
+        dst_el->system_count = src_el->system_count;
+        dst_el->multi_threaded = src_el->multi_threaded;
+        dst_el->immediate = src_el->immediate;
     }
-#   endif
 
-    return level <= ecs_os_api.log_level_;
+    ecs_map_init_if(&dst->system_stats, NULL);
+    ecs_map_iter_t it = ecs_map_iter(&src->system_stats);
+    while (ecs_map_next(&it)) {
+        ecs_system_stats_t *sys_src = ecs_map_ptr(&it);
+        ecs_system_stats_t *sys_dst = ecs_map_ensure_alloc_t(&dst->system_stats, 
+            ecs_system_stats_t, ecs_map_key(&it));
+        sys_dst->query.t = dst->t;
+        ecs_system_stats_reduce_last(sys_dst, sys_src, count);
+    }
+    dst->t = t_prev(dst->t);
 }
 
-#define ECS_ERR_STR(code) case code: return &(#code[4])
-
-const char* ecs_strerror(
-    int32_t error_code)
+void ecs_pipeline_stats_repeat_last(
+    ecs_pipeline_stats_t *stats)
 {
-    switch (error_code) {
-    ECS_ERR_STR(ECS_INVALID_PARAMETER);
-    ECS_ERR_STR(ECS_NOT_A_COMPONENT);
-    ECS_ERR_STR(ECS_INTERNAL_ERROR);
-    ECS_ERR_STR(ECS_ALREADY_DEFINED);
-    ECS_ERR_STR(ECS_INVALID_COMPONENT_SIZE);
-    ECS_ERR_STR(ECS_INVALID_COMPONENT_ALIGNMENT);
-    ECS_ERR_STR(ECS_NAME_IN_USE);
-    ECS_ERR_STR(ECS_OUT_OF_MEMORY);
-    ECS_ERR_STR(ECS_DOUBLE_FREE);
-    ECS_ERR_STR(ECS_OPERATION_FAILED);
-    ECS_ERR_STR(ECS_INVALID_CONVERSION);
-    ECS_ERR_STR(ECS_MODULE_UNDEFINED);
-    ECS_ERR_STR(ECS_MISSING_SYMBOL);
-    ECS_ERR_STR(ECS_ALREADY_IN_USE);
-    ECS_ERR_STR(ECS_CYCLE_DETECTED);
-    ECS_ERR_STR(ECS_LEAK_DETECTED);
-    ECS_ERR_STR(ECS_COLUMN_INDEX_OUT_OF_RANGE);
-    ECS_ERR_STR(ECS_COLUMN_IS_NOT_SHARED);
-    ECS_ERR_STR(ECS_COLUMN_IS_SHARED);
-    ECS_ERR_STR(ECS_COLUMN_TYPE_MISMATCH);
-    ECS_ERR_STR(ECS_INVALID_WHILE_READONLY);
-    ECS_ERR_STR(ECS_INVALID_FROM_WORKER);
-    ECS_ERR_STR(ECS_OUT_OF_RANGE);
-    ECS_ERR_STR(ECS_MISSING_OS_API);
-    ECS_ERR_STR(ECS_UNSUPPORTED);
-    ECS_ERR_STR(ECS_ACCESS_VIOLATION);
-    ECS_ERR_STR(ECS_COMPONENT_NOT_REGISTERED);
-    ECS_ERR_STR(ECS_INCONSISTENT_COMPONENT_ID);
-    ECS_ERR_STR(ECS_INCONSISTENT_NAME);
-    ECS_ERR_STR(ECS_INCONSISTENT_COMPONENT_ACTION);
-    ECS_ERR_STR(ECS_INVALID_OPERATION);
-    ECS_ERR_STR(ECS_CONSTRAINT_VIOLATED);
-    ECS_ERR_STR(ECS_LOCKED_STORAGE);
-    ECS_ERR_STR(ECS_ID_IN_USE);
+    int32_t i, sync_count = ecs_vec_count(&stats->sync_points);
+    ecs_sync_stats_t *syncs = ecs_vec_first_t(&stats->sync_points, ecs_sync_stats_t);
+
+    for (i = 0; i < sync_count; i ++) {
+        ecs_sync_stats_t *el = &syncs[i];
+        flecs_stats_repeat_last(ECS_METRIC_FIRST(el), ECS_METRIC_LAST(el),
+            (stats->t));
     }
 
-    return "unknown error code";
+    ecs_map_iter_t it = ecs_map_iter(&stats->system_stats);
+    while (ecs_map_next(&it)) {
+        ecs_system_stats_t *sys = ecs_map_ptr(&it);
+        sys->query.t = stats->t;
+        ecs_system_stats_repeat_last(sys);
+    }
+    stats->t = t_next(stats->t);
 }
 
-#else
+void ecs_pipeline_stats_copy_last(
+    ecs_pipeline_stats_t *dst,
+    const ecs_pipeline_stats_t *src)
+{
+    int32_t i, sync_count = ecs_vec_count(&src->sync_points);
+    ecs_vec_init_if_t(&dst->sync_points, ecs_sync_stats_t);
+    ecs_vec_set_min_count_zeromem_t(NULL, &dst->sync_points, ecs_sync_stats_t, sync_count);
+    ecs_sync_stats_t *dst_syncs = ecs_vec_first_t(&dst->sync_points, ecs_sync_stats_t);
+    ecs_sync_stats_t *src_syncs = ecs_vec_first_t(&src->sync_points, ecs_sync_stats_t);
 
-/* Empty bodies for when logging is disabled */
+    for (i = 0; i < sync_count; i ++) {
+        ecs_sync_stats_t *dst_el = &dst_syncs[i];
+        ecs_sync_stats_t *src_el = &src_syncs[i];
+        flecs_stats_copy_last(ECS_METRIC_FIRST(dst_el), ECS_METRIC_LAST(dst_el),
+            ECS_METRIC_FIRST(src_el), dst->t, t_next(src->t));
+        dst_el->system_count = src_el->system_count;
+        dst_el->multi_threaded = src_el->multi_threaded;
+        dst_el->immediate = src_el->immediate;
+    }
 
-void ecs_log_(
-    int32_t level,
-    const char *file,
-    int32_t line,
-    const char *fmt,
-    ...)
-{
-    (void)level;
-    (void)file;
-    (void)line;
-    (void)fmt;
-}
+    ecs_map_init_if(&dst->system_stats, NULL);
 
-void ecs_parser_error_(
-    const char *name,
-    const char *expr, 
-    int64_t column,
-    const char *fmt,
-    ...)
-{
-    (void)name;
-    (void)expr;
-    (void)column;
-    (void)fmt;
+    ecs_map_iter_t it = ecs_map_iter(&src->system_stats);
+    while (ecs_map_next(&it)) {
+        ecs_system_stats_t *sys_src = ecs_map_ptr(&it);
+        ecs_system_stats_t *sys_dst = ecs_map_ensure_alloc_t(&dst->system_stats, 
+            ecs_system_stats_t, ecs_map_key(&it));
+        sys_dst->query.t = dst->t;
+        ecs_system_stats_copy_last(sys_dst, sys_src);
+    }
 }
 
-void ecs_parser_errorv_(
-    const char *name,
-    const char *expr, 
-    int64_t column,
-    const char *fmt,
-    va_list args)
-{
-    (void)name;
-    (void)expr;
-    (void)column;
-    (void)fmt;
-    (void)args;
-}
+#endif
 
-void ecs_abort_(
-    int32_t error_code,
-    const char *file,
-    int32_t line,
-    const char *fmt,
-    ...)
+void ecs_world_stats_log(
+    const ecs_world_t *world,
+    const ecs_world_stats_t *s)
 {
-    (void)error_code;
-    (void)file;
-    (void)line;
-    (void)fmt;
-}
+    int32_t t = s->t;
 
-void ecs_assert_log_(
-    int32_t error_code,
-    const char *condition_str,
-    const char *file,
-    int32_t line,
-    const char *fmt,
-    ...)
-{
-    (void)error_code;
-    (void)condition_str;
-    (void)file;
-    (void)line;
-    (void)fmt;
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    world = ecs_get_world(world);    
+    
+    flecs_counter_print("Frame", t, &s->frame.frame_count);
+    ecs_trace("-------------------------------------");
+    flecs_counter_print("pipeline rebuilds", t, &s->frame.pipeline_build_count);
+    flecs_counter_print("systems ran", t, &s->frame.systems_ran);
+    ecs_trace("");
+    flecs_metric_print("target FPS", (ecs_float_t)world->info.target_fps);
+    flecs_metric_print("time scale", (ecs_float_t)world->info.time_scale);
+    ecs_trace("");
+    flecs_gauge_print("actual FPS", t, &s->performance.fps);
+    flecs_counter_print("frame time", t, &s->performance.frame_time);
+    flecs_counter_print("system time", t, &s->performance.system_time);
+    flecs_counter_print("merge time", t, &s->performance.merge_time);
+    flecs_counter_print("simulation time elapsed", t, &s->performance.world_time);
+    ecs_trace("");
+    flecs_gauge_print("tag id count", t, &s->components.tag_count);
+    flecs_gauge_print("component id count", t, &s->components.component_count);
+    flecs_gauge_print("pair id count", t, &s->components.pair_count);
+    flecs_gauge_print("type count", t, &s->components.type_count);
+    flecs_counter_print("id create count", t, &s->components.create_count);
+    flecs_counter_print("id delete count", t, &s->components.delete_count);
+    ecs_trace("");
+    flecs_gauge_print("alive entity count", t, &s->entities.count);
+    flecs_gauge_print("not alive entity count", t, &s->entities.not_alive_count);
+    ecs_trace("");
+    flecs_gauge_print("query count", t, &s->queries.query_count);
+    flecs_gauge_print("observer count", t, &s->queries.observer_count);
+    flecs_gauge_print("system count", t, &s->queries.system_count);
+    ecs_trace("");
+    flecs_gauge_print("table count", t, &s->tables.count);
+    flecs_gauge_print("empty table count", t, &s->tables.empty_count);
+    flecs_counter_print("table create count", t, &s->tables.create_count);
+    flecs_counter_print("table delete count", t, &s->tables.delete_count);
+    ecs_trace("");
+    flecs_counter_print("add commands", t, &s->commands.add_count);
+    flecs_counter_print("remove commands", t, &s->commands.remove_count);
+    flecs_counter_print("delete commands", t, &s->commands.delete_count);
+    flecs_counter_print("clear commands", t, &s->commands.clear_count);
+    flecs_counter_print("set commands", t, &s->commands.set_count);
+    flecs_counter_print("ensure commands", t, &s->commands.ensure_count);
+    flecs_counter_print("modified commands", t, &s->commands.modified_count);
+    flecs_counter_print("other commands", t, &s->commands.other_count);
+    flecs_counter_print("discarded commands", t, &s->commands.discard_count);
+    flecs_counter_print("batched entities", t, &s->commands.batched_entity_count);
+    flecs_counter_print("batched commands", t, &s->commands.batched_count);
+    ecs_trace("");
+    
+error:
+    return;
 }
 
 #endif
 
-int ecs_log_get_level(void) {
-    return ecs_os_api.log_level_;
-}
+/**
+ * @file addons/timer.c
+ * @brief Timer addon.
+ */
 
-int ecs_log_set_level(
-    int level)
-{
-    int prev = level;
-    ecs_os_api.log_level_ = level;
-    return prev;
-}
 
-bool ecs_log_enable_colors(
-    bool enabled)
-{
-    bool prev = ecs_os_api.flags_ & EcsOsApiLogWithColors;
-    ECS_BIT_COND(ecs_os_api.flags_, EcsOsApiLogWithColors, enabled);
-    return prev;
+#ifdef FLECS_TIMER
+
+static
+void AddTickSource(ecs_iter_t *it) {
+    int32_t i;
+    for (i = 0; i < it->count; i ++) {
+        ecs_set(it->world, it->entities[i], EcsTickSource, {0});
+    }
 }
 
-bool ecs_log_enable_timestamp(
-    bool enabled)
-{
-    bool prev = ecs_os_api.flags_ & EcsOsApiLogWithTimeStamp;
-    ECS_BIT_COND(ecs_os_api.flags_, EcsOsApiLogWithTimeStamp, enabled);
-    return prev;
-}
-
-bool ecs_log_enable_timedelta(
-    bool enabled)
-{
-    bool prev = ecs_os_api.flags_ & EcsOsApiLogWithTimeDelta;
-    ECS_BIT_COND(ecs_os_api.flags_, EcsOsApiLogWithTimeDelta, enabled);
-    return prev;
-}
-
-int ecs_log_last_error(void)
-{
-    int result = ecs_os_api.log_last_error_;
-    ecs_os_api.log_last_error_ = 0;
-    return result;
-}
-
-/**
- * @file addons/meta_c.c
- * @brief C utilities for meta addon.
- */
-
-
-#ifdef FLECS_META_C
-
-#include <ctype.h>
-
-#define ECS_META_IDENTIFIER_LENGTH (256)
-
-#define ecs_meta_error(ctx, ptr, ...)\
-    ecs_parser_error((ctx)->name, (ctx)->desc, ptr - (ctx)->desc, __VA_ARGS__);
+static
+void ProgressTimers(ecs_iter_t *it) {
+    EcsTimer *timer = ecs_field(it, EcsTimer, 0);
+    EcsTickSource *tick_source = ecs_field(it, EcsTickSource, 1);
 
-typedef char ecs_meta_token_t[ECS_META_IDENTIFIER_LENGTH];
+    ecs_assert(timer != NULL, ECS_INTERNAL_ERROR, NULL);
 
-typedef struct meta_parse_ctx_t {
-    const char *name;
-    const char *desc;
-} meta_parse_ctx_t;
+    int i;
+    for (i = 0; i < it->count; i ++) {
+        tick_source[i].tick = false;
 
-typedef struct meta_type_t {
-    ecs_meta_token_t type;
-    ecs_meta_token_t params;
-    bool is_const;
-    bool is_ptr;
-} meta_type_t;
+        if (!timer[i].active) {
+            continue;
+        }
 
-typedef struct meta_member_t {
-    meta_type_t type;
-    ecs_meta_token_t name;
-    int64_t count;
-    bool is_partial;
-} meta_member_t;
+        const ecs_world_info_t *info = ecs_get_world_info(it->world);
+        ecs_ftime_t time_elapsed = timer[i].time + info->delta_time_raw;
+        ecs_ftime_t timeout = timer[i].timeout;
+        
+        if (time_elapsed >= timeout) {
+            ecs_ftime_t t = time_elapsed - timeout;
+            if (t > timeout) {
+                t = 0;
+            }
 
-typedef struct meta_constant_t {
-    ecs_meta_token_t name;
-    int64_t value;
-    bool is_value_set;
-} meta_constant_t;
+            timer[i].time = t; /* Initialize with remainder */
+            tick_source[i].tick = true;
+            tick_source[i].time_elapsed = time_elapsed - timer[i].overshoot;
+            timer[i].overshoot = t;
 
-typedef struct meta_params_t {
-    meta_type_t key_type;
-    meta_type_t type;
-    int64_t count;
-    bool is_key_value;
-    bool is_fixed_size;
-} meta_params_t;
+            if (timer[i].single_shot) {
+                timer[i].active = false;
+            }
+        } else {
+            timer[i].time = time_elapsed;
+        }  
+    }
+}
 
 static
-const char* skip_scope(const char *ptr, meta_parse_ctx_t *ctx) {
-    /* Keep track of which characters were used to open the scope */
-    char stack[256];
-    int32_t sp = 0;
-    char ch;
+void ProgressRateFilters(ecs_iter_t *it) {
+    EcsRateFilter *filter = ecs_field(it, EcsRateFilter, 0);
+    EcsTickSource *tick_dst = ecs_field(it, EcsTickSource, 1);
 
-    while ((ch = *ptr)) {
-        if (ch == '(' || ch == '<') {
-            stack[sp] = ch;
+    int i;
+    for (i = 0; i < it->count; i ++) {
+        ecs_entity_t src = filter[i].src;
+        bool inc = false;
 
-            sp ++;
-            if (sp >= 256) {
-                ecs_meta_error(ctx, ptr, "maximum level of nesting reached");
-                goto error;
-            }            
-        } else if (ch == ')' || ch == '>') {
-            sp --;
-            if ((sp < 0) || (ch == '>' && stack[sp] != '<') || 
-                (ch == ')' && stack[sp] != '(')) 
-            {
-                ecs_meta_error(ctx, ptr, "mismatching %c in identifier", ch);
-                goto error;
+        filter[i].time_elapsed += it->delta_time;
+
+        if (src) {
+            const EcsTickSource *tick_src = ecs_get(
+                it->world, src, EcsTickSource);
+            if (tick_src) {
+                inc = tick_src->tick;
+            } else {
+                inc = true;
             }
+        } else {
+            inc = true;
         }
 
-        ptr ++;
+        if (inc) {
+            filter[i].tick_count ++;
+            bool triggered = !(filter[i].tick_count % filter[i].rate);
+            tick_dst[i].tick = triggered;
+            tick_dst[i].time_elapsed = filter[i].time_elapsed;
 
-        if (!sp) {
-            break;
+            if (triggered) {
+                filter[i].time_elapsed = 0;
+            }            
+        } else {
+            tick_dst[i].tick = false;
         }
     }
-
-    return ptr;
-error:
-    return NULL;
 }
 
 static
-const char* parse_c_digit(
-    const char *ptr,
-    int64_t *value_out)
-{
-    char token[24];
-    ptr = ecs_parse_ws_eol(ptr);
-    ptr = ecs_parse_digit(ptr, token);
-    if (!ptr) {
-        goto error;
-    }
-
-    *value_out = strtol(token, NULL, 0);
+void ProgressTickSource(ecs_iter_t *it) {
+    EcsTickSource *tick_src = ecs_field(it, EcsTickSource, 0);
 
-    return ecs_parse_ws_eol(ptr);
-error:
-    return NULL;
+    /* If tick source has no filters, tick unconditionally */
+    int i;
+    for (i = 0; i < it->count; i ++) {
+        tick_src[i].tick = true;
+        tick_src[i].time_elapsed = it->delta_time;
+    }
 }
 
-static
-const char* parse_c_identifier(
-    const char *ptr, 
-    char *buff,
-    char *params,
-    meta_parse_ctx_t *ctx) 
+ecs_entity_t ecs_set_timeout(
+    ecs_world_t *world,
+    ecs_entity_t timer,
+    ecs_ftime_t timeout)
 {
-    ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(buff != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(ctx != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    char *bptr = buff, ch;
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (params) {
-        params[0] = '\0';
+    if (!timer) {
+        timer = ecs_entity(world, {0});
     }
 
-    /* Ignore whitespaces */
-    ptr = ecs_parse_ws_eol(ptr);
-    ch = *ptr;
+    ecs_set(world, timer, EcsTimer, {
+        .timeout = timeout,
+        .single_shot = true,
+        .active = true
+    });
 
-    if (!isalpha(ch) && (ch != '_')) {
-        ecs_meta_error(ctx, ptr, "invalid identifier (starts with '%c')", ch);
-        goto error;
+    ecs_system_t *system_data = flecs_poly_get(world, timer, ecs_system_t);
+    if (system_data) {
+        system_data->tick_source = timer;
     }
 
-    while ((ch = *ptr) && !isspace(ch) && ch != ';' && ch != ',' && ch != ')' && 
-        ch != '>' && ch != '}' && ch != '*') 
-    {
-        /* Type definitions can contain macros or templates */
-        if (ch == '(' || ch == '<') {
-            if (!params) {
-                ecs_meta_error(ctx, ptr, "unexpected %c", *ptr);
-                goto error;
-            }
-
-            const char *end = skip_scope(ptr, ctx);
-            ecs_os_strncpy(params, ptr, (ecs_size_t)(end - ptr));
-            params[end - ptr] = '\0';
-
-            ptr = end;
-        } else {
-            *bptr = ch;
-            bptr ++;
-            ptr ++;
-        }
-    }
+error:
+    return timer;
+}
 
-    *bptr = '\0';
+ecs_ftime_t ecs_get_timeout(
+    const ecs_world_t *world,
+    ecs_entity_t timer)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(timer != 0, ECS_INVALID_PARAMETER, NULL);
 
-    if (!ch) {
-        ecs_meta_error(ctx, ptr, "unexpected end of token");
-        goto error;
+    const EcsTimer *value = ecs_get(world, timer, EcsTimer);
+    if (value) {
+        return value->timeout;
     }
-
-    return ptr;
 error:
-    return NULL;
+    return 0;
 }
 
-static
-const char * meta_open_scope(
-    const char *ptr,
-    meta_parse_ctx_t *ctx)    
+ecs_entity_t ecs_set_interval(
+    ecs_world_t *world,
+    ecs_entity_t timer,
+    ecs_ftime_t interval)
 {
-    /* Skip initial whitespaces */
-    ptr = ecs_parse_ws_eol(ptr);
-
-    /* Is this the start of the type definition? */
-    if (ctx->desc == ptr) {
-        if (*ptr != '{') {
-            ecs_meta_error(ctx, ptr, "missing '{' in struct definition");
-            goto error; 
-        }
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-        ptr ++;
-        ptr = ecs_parse_ws_eol(ptr);
+    if (!timer) {
+        timer = ecs_new_w(world, EcsTimer);
     }
 
-    /* Is this the end of the type definition? */
-    if (!*ptr) {
-        ecs_meta_error(ctx, ptr, "missing '}' at end of struct definition");
-        goto error;
-    }   
+    EcsTimer *t = ecs_ensure(world, timer, EcsTimer);
+    ecs_check(t != NULL, ECS_INTERNAL_ERROR, NULL);
+    t->timeout = interval;
+    t->active = true;
+    ecs_modified(world, timer, EcsTimer);
 
-    /* Is this the end of the type definition? */
-    if (*ptr == '}') {
-        ptr = ecs_parse_ws_eol(ptr + 1);
-        if (*ptr) {
-            ecs_meta_error(ctx, ptr, 
-                "stray characters after struct definition");
-            goto error;
-        }
-        return NULL;
+    ecs_system_t *system_data = flecs_poly_get(world, timer, ecs_system_t);
+    if (system_data) {
+        system_data->tick_source = timer;
     }
-
-    return ptr;
 error:
-    return NULL;
+    return timer;  
 }
 
-static
-const char* meta_parse_constant(
-    const char *ptr,
-    meta_constant_t *token,
-    meta_parse_ctx_t *ctx)
-{    
-    ptr = meta_open_scope(ptr, ctx);
-    if (!ptr) {
-        return NULL;
-    }
-
-    token->is_value_set = false;
-
-    /* Parse token, constant identifier */
-    ptr = parse_c_identifier(ptr, token->name, NULL, ctx);
-    if (!ptr) {
-        return NULL;
-    }
-
-    ptr = ecs_parse_ws_eol(ptr);
-    if (!ptr) {
-        return NULL;
-    }
+ecs_ftime_t ecs_get_interval(
+    const ecs_world_t *world,
+    ecs_entity_t timer)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    /* Explicit value assignment */
-    if (*ptr == '=') {
-        int64_t value = 0;
-        ptr = parse_c_digit(ptr + 1, &value);
-        token->value = value;
-        token->is_value_set = true;
+    if (!timer) {
+        return 0;
     }
 
-    /* Expect a ',' or '}' */
-    if (*ptr != ',' && *ptr != '}') {
-        ecs_meta_error(ctx, ptr, "missing , after enum constant");
-        goto error;
+    const EcsTimer *value = ecs_get(world, timer, EcsTimer);
+    if (value) {
+        return value->timeout;
     }
+error:
+    return 0;
+}
 
-    if (*ptr == ',') {
-        return ptr + 1;
-    } else {
-        return ptr;
-    }
+void ecs_start_timer(
+    ecs_world_t *world,
+    ecs_entity_t timer)
+{
+    EcsTimer *ptr = ecs_ensure(world, timer, EcsTimer);
+    ecs_check(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ptr->active = true;
+    ptr->time = 0;
 error:
-    return NULL;
+    return;
 }
 
-static
-const char* meta_parse_type(
-    const char *ptr,
-    meta_type_t *token,
-    meta_parse_ctx_t *ctx)
+void ecs_stop_timer(
+    ecs_world_t *world,
+    ecs_entity_t timer)
 {
-    token->is_ptr = false;
-    token->is_const = false;
+    EcsTimer *ptr = ecs_ensure(world, timer, EcsTimer);
+    ecs_check(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ptr->active = false;
+error:
+    return;
+}
 
-    ptr = ecs_parse_ws_eol(ptr);
+void ecs_reset_timer(
+    ecs_world_t *world,
+    ecs_entity_t timer)
+{
+    EcsTimer *ptr = ecs_ensure(world, timer, EcsTimer);
+    ecs_check(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ptr->time = 0;
+error:
+    return;   
+}
 
-    /* Parse token, expect type identifier or ECS_PROPERTY */
-    ptr = parse_c_identifier(ptr, token->type, token->params, ctx);
-    if (!ptr) {
-        goto error;
-    }
+ecs_entity_t ecs_set_rate(
+    ecs_world_t *world,
+    ecs_entity_t filter,
+    int32_t rate,
+    ecs_entity_t source)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (!strcmp(token->type, "ECS_PRIVATE")) {
-        /* Members from this point are not stored in metadata */
-        ptr += ecs_os_strlen(ptr);
-        goto done;
+    if (!filter) {
+        filter = ecs_entity(world, {0});
     }
 
-    /* If token is const, set const flag and continue parsing type */
-    if (!strcmp(token->type, "const")) {
-        token->is_const = true;
-
-        /* Parse type after const */
-        ptr = parse_c_identifier(ptr + 1, token->type, token->params, ctx);
-    }
+    ecs_set(world, filter, EcsRateFilter, {
+        .rate = rate,
+        .src = source
+    });
 
-    /* Check if type is a pointer */
-    ptr = ecs_parse_ws_eol(ptr);
-    if (*ptr == '*') {
-        token->is_ptr = true;
-        ptr ++;
-    }
+    ecs_system_t *system_data = flecs_poly_get(world, filter, ecs_system_t);
+    if (system_data) {
+        system_data->tick_source = filter;
+    }  
 
-done:
-    return ptr;
 error:
-    return NULL;
+    return filter;     
 }
 
-static
-const char* meta_parse_member(
-    const char *ptr,
-    meta_member_t *token,
-    meta_parse_ctx_t *ctx)
+void ecs_set_tick_source(
+    ecs_world_t *world,
+    ecs_entity_t system,
+    ecs_entity_t tick_source)
 {
-    ptr = meta_open_scope(ptr, ctx);
-    if (!ptr) {
-        return NULL;
-    }
-
-    token->count = 1;
-    token->is_partial = false;
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(tick_source != 0, ECS_INVALID_PARAMETER, NULL);
 
-    /* Parse member type */
-    ptr = meta_parse_type(ptr, &token->type, ctx);
-    if (!ptr) {
-        token->is_partial = true;
-        goto error;
-    }
+    ecs_system_t *system_data = flecs_poly_get(world, system, ecs_system_t);
+    ecs_check(system_data != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (!ptr[0]) {
-        return ptr;        
-    }
+    system_data->tick_source = tick_source;
+error:
+    return;
+}
 
-    /* Next token is the identifier */
-    ptr = parse_c_identifier(ptr, token->name, NULL, ctx);
-    if (!ptr) {
-        goto error;
+static
+void RandomizeTimers(ecs_iter_t *it) {
+    EcsTimer *timer = ecs_field(it, EcsTimer, 0);
+    int32_t i;
+    for (i = 0; i < it->count; i ++) {
+        timer[i].time = 
+            ((ecs_ftime_t)rand() / (ecs_ftime_t)RAND_MAX) * timer[i].timeout;
     }
+}
 
-    /* Skip whitespace between member and [ or ; */
-    ptr = ecs_parse_ws_eol(ptr);
+void ecs_randomize_timers(
+    ecs_world_t *world)
+{
+    ecs_observer(world, {
+        .entity = ecs_entity(world, { .name = "flecs.timer.RandomizeTimers" }),
+        .query.terms = {{
+            .id = ecs_id(EcsTimer)
+        }},
+        .events = {EcsOnSet},
+        .yield_existing = true,
+        .callback = RandomizeTimers
+    });
+}
 
-    /* Check if this is an array */
-    char *array_start = strchr(token->name, '[');
-    if (!array_start) {
-        /* If the [ was separated by a space, it will not be parsed as part of
-         * the name */
-        if (*ptr == '[') {
-            /* safe, will not be modified */
-            array_start = ECS_CONST_CAST(char*, ptr);
-        }
-    }
+void FlecsTimerImport(
+    ecs_world_t *world)
+{    
+    ECS_MODULE(world, FlecsTimer);
+    ECS_IMPORT(world, FlecsPipeline);
+#ifdef FLECS_DOC
+    ECS_IMPORT(world, FlecsDoc);
+    ecs_doc_set_brief(world, ecs_id(FlecsTimer), 
+        "Module that implements system timers (used by .interval)");
+#endif
 
-    if (array_start) {
-        /* Check if the [ matches with a ] */
-        char *array_end = strchr(array_start, ']');
-        if (!array_end) {
-            ecs_meta_error(ctx, ptr, "missing ']'");
-            goto error;
+    ecs_set_name_prefix(world, "Ecs");
 
-        } else if (array_end - array_start == 0) {
-            ecs_meta_error(ctx, ptr, "dynamic size arrays are not supported");
-            goto error;
-        }
+    flecs_bootstrap_component(world, EcsTimer);
+    flecs_bootstrap_component(world, EcsRateFilter);
 
-        token->count = atoi(array_start + 1);
+    ecs_set_hooks(world, EcsTimer, {
+        .ctor = flecs_default_ctor
+    });
 
-        if (array_start == ptr) {
-            /* If [ was found after name, continue parsing after ] */
-            ptr = array_end + 1;
-        } else {
-            /* If [ was fonud in name, replace it with 0 terminator */
-            array_start[0] = '\0';
-        }
-    }
+    /* Add EcsTickSource to timers and rate filters */
+    ecs_system(world, {
+        .entity = ecs_entity(world, {.name = "AddTickSource", .add = ecs_ids( ecs_dependson(EcsPreFrame) )}),
+        .query.terms = {
+            { .id = ecs_id(EcsTimer), .oper = EcsOr, .inout = EcsIn },
+            { .id = ecs_id(EcsRateFilter), .oper = EcsAnd, .inout = EcsIn },
+            { .id = ecs_id(EcsTickSource), .oper = EcsNot, .inout = EcsOut}
+        },
+        .callback = AddTickSource
+    });
 
-    /* Expect a ; */
-    if (*ptr != ';') {
-        ecs_meta_error(ctx, ptr, "missing ; after member declaration");
-        goto error;
-    }
+    /* Timer handling */
+    ecs_system(world, {
+        .entity = ecs_entity(world, {.name = "ProgressTimers", .add = ecs_ids( ecs_dependson(EcsPreFrame))}),
+        .query.terms = {
+            { .id = ecs_id(EcsTimer) },
+            { .id = ecs_id(EcsTickSource) }
+        },
+        .callback = ProgressTimers
+    });
 
-    return ptr + 1;
-error:
-    return NULL;
+    /* Rate filter handling */
+    ecs_system(world, {
+        .entity = ecs_entity(world, {.name = "ProgressRateFilters", .add = ecs_ids( ecs_dependson(EcsPreFrame))}),
+        .query.terms = {
+            { .id = ecs_id(EcsRateFilter), .inout = EcsIn },
+            { .id = ecs_id(EcsTickSource), .inout = EcsOut }
+        },
+        .callback = ProgressRateFilters
+    });
+
+    /* TickSource without a timer or rate filter just increases each frame */
+    ecs_system(world, {
+        .entity = ecs_entity(world, { .name = "ProgressTickSource", .add = ecs_ids( ecs_dependson(EcsPreFrame))}),
+        .query.terms = {
+            { .id = ecs_id(EcsTickSource), .inout = EcsOut },
+            { .id = ecs_id(EcsRateFilter), .oper = EcsNot },
+            { .id = ecs_id(EcsTimer), .oper = EcsNot }
+        },
+        .callback = ProgressTickSource
+    });
 }
 
-static
-int meta_parse_desc(
-    const char *ptr,
-    meta_params_t *token,
-    meta_parse_ctx_t *ctx)
-{
-    token->is_key_value = false;
-    token->is_fixed_size = false;
+#endif
 
-    ptr = ecs_parse_ws_eol(ptr);
-    if (*ptr != '(' && *ptr != '<') {
-        ecs_meta_error(ctx, ptr, 
-            "expected '(' at start of collection definition");
-        goto error;
-    }
+/**
+ * @file addons/units.c
+ * @brief Units addon.
+ */
 
-    ptr ++;
 
-    /* Parse type identifier */
-    ptr = meta_parse_type(ptr, &token->type, ctx);
-    if (!ptr) {
-        goto error;
-    }
+#ifdef FLECS_UNITS
 
-    ptr = ecs_parse_ws_eol(ptr);
+void FlecsUnitsImport(
+    ecs_world_t *world)
+{
+    ECS_MODULE(world, FlecsUnits);
 
-    /* If next token is a ',' the first type was a key type */
-    if (*ptr == ',') {
-        ptr = ecs_parse_ws_eol(ptr + 1);
-        
-        if (isdigit(*ptr)) {
-            int64_t value;
-            ptr = parse_c_digit(ptr, &value);
-            if (!ptr) {
-                goto error;
-            }
+#ifdef FLECS_DOC
+    ECS_IMPORT(world, FlecsDoc);
+    ecs_doc_set_brief(world, ecs_id(FlecsUnits), 
+        "Module with (amongst others) SI units for annotating component members");
+#endif
 
-            token->count = value;
-            token->is_fixed_size = true;
-        } else {
-            token->key_type = token->type;
+    ecs_set_name_prefix(world, "Ecs");
 
-            /* Parse element type */
-            ptr = meta_parse_type(ptr, &token->type, ctx);
-            ptr = ecs_parse_ws_eol(ptr);
+    EcsUnitPrefixes = ecs_entity(world, {
+        .name = "prefixes",
+        .add = ecs_ids( EcsModule )
+    });
 
-            token->is_key_value = true;
-        }
-    }
+    /* Initialize unit prefixes */
 
-    if (*ptr != ')' && *ptr != '>') {
-        ecs_meta_error(ctx, ptr, 
-            "expected ')' at end of collection definition");
-        goto error;
-    }
+    ecs_entity_t prev_scope = ecs_set_scope(world, EcsUnitPrefixes);
 
-    return 0;
-error:
-    return -1;
-}
+    EcsYocto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Yocto" }),
+        .symbol = "y",
+        .translation = { .factor = 10, .power = -24 }
+    });
+    EcsZepto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Zepto" }),
+        .symbol = "z",
+        .translation = { .factor = 10, .power = -21 }
+    });
+    EcsAtto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Atto" }),
+        .symbol = "a",
+        .translation = { .factor = 10, .power = -18 }
+    });
+    EcsFemto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Femto" }),
+        .symbol = "a",
+        .translation = { .factor = 10, .power = -15 }
+    });
+    EcsPico = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Pico" }),
+        .symbol = "p",
+        .translation = { .factor = 10, .power = -12 }
+    });
+    EcsNano = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Nano" }),
+        .symbol = "n",
+        .translation = { .factor = 10, .power = -9 }
+    });
+    EcsMicro = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Micro" }),
+        .symbol = "μ",
+        .translation = { .factor = 10, .power = -6 }
+    });
+    EcsMilli = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Milli" }),
+        .symbol = "m",
+        .translation = { .factor = 10, .power = -3 }
+    });
+    EcsCenti = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Centi" }),
+        .symbol = "c",
+        .translation = { .factor = 10, .power = -2 }
+    });
+    EcsDeci = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Deci" }),
+        .symbol = "d",
+        .translation = { .factor = 10, .power = -1 }
+    });
+    EcsDeca = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Deca" }),
+        .symbol = "da",
+        .translation = { .factor = 10, .power = 1 }
+    });
+    EcsHecto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Hecto" }),
+        .symbol = "h",
+        .translation = { .factor = 10, .power = 2 }
+    });
+    EcsKilo = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Kilo" }),
+        .symbol = "k",
+        .translation = { .factor = 10, .power = 3 }
+    });
+    EcsMega = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Mega" }),
+        .symbol = "M",
+        .translation = { .factor = 10, .power = 6 }
+    });
+    EcsGiga = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Giga" }),
+        .symbol = "G",
+        .translation = { .factor = 10, .power = 9 }
+    });
+    EcsTera = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Tera" }),
+        .symbol = "T",
+        .translation = { .factor = 10, .power = 12 }
+    });
+    EcsPeta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Peta" }),
+        .symbol = "P",
+        .translation = { .factor = 10, .power = 15 }
+    });
+    EcsExa = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Exa" }),
+        .symbol = "E",
+        .translation = { .factor = 10, .power = 18 }
+    });
+    EcsZetta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Zetta" }),
+        .symbol = "Z",
+        .translation = { .factor = 10, .power = 21 }
+    });
+    EcsYotta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Yotta" }),
+        .symbol = "Y",
+        .translation = { .factor = 10, .power = 24 }
+    });
 
-static
-ecs_entity_t meta_lookup(
-    ecs_world_t *world,
-    meta_type_t *token,
-    const char *ptr,
-    int64_t count,
-    meta_parse_ctx_t *ctx);
+    EcsKibi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Kibi" }),
+        .symbol = "Ki",
+        .translation = { .factor = 1024, .power = 1 }
+    });
+    EcsMebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Mebi" }),
+        .symbol = "Mi",
+        .translation = { .factor = 1024, .power = 2 }
+    });
+    EcsGibi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Gibi" }),
+        .symbol = "Gi",
+        .translation = { .factor = 1024, .power = 3 }
+    });
+    EcsTebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Tebi" }),
+        .symbol = "Ti",
+        .translation = { .factor = 1024, .power = 4 }
+    });
+    EcsPebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Pebi" }),
+        .symbol = "Pi",
+        .translation = { .factor = 1024, .power = 5 }
+    });
+    EcsExbi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Exbi" }),
+        .symbol = "Ei",
+        .translation = { .factor = 1024, .power = 6 }
+    });
+    EcsZebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Zebi" }),
+        .symbol = "Zi",
+        .translation = { .factor = 1024, .power = 7 }
+    });
+    EcsYobi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
+        .entity = ecs_entity(world, { .name = "Yobi" }),
+        .symbol = "Yi",
+        .translation = { .factor = 1024, .power = 8 }
+    });
 
-static
-ecs_entity_t meta_lookup_array(
-    ecs_world_t *world,
-    ecs_entity_t e,
-    const char *params_decl,
-    meta_parse_ctx_t *ctx)
-{
-    meta_parse_ctx_t param_ctx = {
-        .name = ctx->name,
-        .desc = params_decl
-    };
+    ecs_set_scope(world, prev_scope);
 
-    meta_params_t params;
-    if (meta_parse_desc(params_decl, &params, &param_ctx)) {
-        goto error;
-    }
-    if (!params.is_fixed_size) {
-        ecs_meta_error(ctx, params_decl, "missing size for array");
-        goto error;
-    }
+    /* Duration units */
 
-    if (!params.count) {
-        ecs_meta_error(ctx, params_decl, "invalid array size");
-        goto error;
-    }
+    EcsDuration = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Duration" });
+    prev_scope = ecs_set_scope(world, EcsDuration);
 
-    ecs_entity_t element_type = ecs_lookup_symbol(
-        world, params.type.type, true, true);
-    if (!element_type) {
-        ecs_meta_error(ctx, params_decl, "unknown element type '%s'",
-            params.type.type);
-    }
+        EcsSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
+            .entity = ecs_entity(world, { .name = "Seconds" }),
+            .quantity = EcsDuration,
+            .symbol = "s" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsSeconds,
+            .kind = EcsF32
+        });
+            EcsPicoSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
+                .entity = ecs_entity(world, { .name = "PicoSeconds" }),
+                .quantity = EcsDuration,
+                .base = EcsSeconds,
+                .prefix = EcsPico });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsPicoSeconds,
+                .kind = EcsF32
+            });
 
-    if (!e) {
-        e = ecs_new_id(world);
-    }
 
-    ecs_check(params.count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL);
+            EcsNanoSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
+                .entity = ecs_entity(world, { .name = "NanoSeconds" }),
+                .quantity = EcsDuration,
+                .base = EcsSeconds,
+                .prefix = EcsNano });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsNanoSeconds,
+                .kind = EcsF32
+            });
 
-    return ecs_set(world, e, EcsArray, { element_type, (int32_t)params.count });
-error:
-    return 0;
-}
+            EcsMicroSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
+                .entity = ecs_entity(world, { .name = "MicroSeconds" }),
+                .quantity = EcsDuration,
+                .base = EcsSeconds,
+                .prefix = EcsMicro });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsMicroSeconds,
+                .kind = EcsF32
+            });
 
-static
-ecs_entity_t meta_lookup_vector(
-    ecs_world_t *world,
-    ecs_entity_t e,
-    const char *params_decl,
-    meta_parse_ctx_t *ctx)
-{
-    meta_parse_ctx_t param_ctx = {
-        .name = ctx->name,
-        .desc = params_decl
-    };
+            EcsMilliSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
+                .entity = ecs_entity(world, { .name = "MilliSeconds" }),
+                .quantity = EcsDuration,
+                .base = EcsSeconds,
+                .prefix = EcsMilli });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsMilliSeconds,
+                .kind = EcsF32
+            });
 
-    meta_params_t params;
-    if (meta_parse_desc(params_decl, &params, &param_ctx)) {
-        goto error;
-    }
+        EcsMinutes = ecs_unit_init(world, &(ecs_unit_desc_t){
+            .entity = ecs_entity(world, { .name = "Minutes" }),
+            .quantity = EcsDuration,
+            .base = EcsSeconds,
+            .symbol = "min",
+            .translation = { .factor = 60, .power = 1 } });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsMinutes,
+            .kind = EcsU32
+        });
 
-    if (params.is_key_value) {
-        ecs_meta_error(ctx, params_decl,
-            "unexpected key value parameters for vector");
-        goto error;
-    }
+        EcsHours = ecs_unit_init(world, &(ecs_unit_desc_t){
+            .entity = ecs_entity(world, { .name = "Hours" }),
+            .quantity = EcsDuration,
+            .base = EcsMinutes,
+            .symbol = "h",
+            .translation = { .factor = 60, .power = 1 } });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsHours,
+            .kind = EcsU32
+        });
 
-    ecs_entity_t element_type = meta_lookup(
-        world, &params.type, params_decl, 1, &param_ctx);
+        EcsDays = ecs_unit_init(world, &(ecs_unit_desc_t){
+            .entity = ecs_entity(world, { .name = "Days" }),
+            .quantity = EcsDuration,
+            .base = EcsHours,
+            .symbol = "d",
+            .translation = { .factor = 24, .power = 1 } });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsDays,
+            .kind = EcsU32
+        });
+    ecs_set_scope(world, prev_scope);
 
-    if (!e) {
-        e = ecs_new_id(world);
-    }
+    /* Time units */
 
-    return ecs_set(world, e, EcsVector, { element_type });
-error:
-    return 0;
-}
+    EcsTime = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Time" });
+    prev_scope = ecs_set_scope(world, EcsTime);
 
-static
-ecs_entity_t meta_lookup_bitmask(
-    ecs_world_t *world,
-    ecs_entity_t e,
-    const char *params_decl,
-    meta_parse_ctx_t *ctx)
-{
-    (void)e;
+        EcsDate = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Date" }),
+            .quantity = EcsTime });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsDate,
+            .kind = EcsU32
+        });
+    ecs_set_scope(world, prev_scope);
 
-    meta_parse_ctx_t param_ctx = {
-        .name = ctx->name,
-        .desc = params_decl
-    };
+    /* Mass units */
 
-    meta_params_t params;
-    if (meta_parse_desc(params_decl, &params, &param_ctx)) {
-        goto error;
-    }
+    EcsMass = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Mass" });
+    prev_scope = ecs_set_scope(world, EcsMass);
+        EcsGrams = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Grams" }),
+            .quantity = EcsMass,
+            .symbol = "g" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsGrams,
+            .kind = EcsF32
+        });
+        EcsKiloGrams = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "KiloGrams" }),
+            .quantity = EcsMass,
+            .prefix = EcsKilo,
+            .base = EcsGrams });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsKiloGrams,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-    if (params.is_key_value) {
-        ecs_meta_error(ctx, params_decl,
-            "unexpected key value parameters for bitmask");
-        goto error;
-    }
+    /* Electric current units */
 
-    if (params.is_fixed_size) {
-        ecs_meta_error(ctx, params_decl,
-            "unexpected size for bitmask");
-        goto error;
-    }
+    EcsElectricCurrent = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "ElectricCurrent" });
+    prev_scope = ecs_set_scope(world, EcsElectricCurrent);
+        EcsAmpere = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Ampere" }),
+            .quantity = EcsElectricCurrent,
+            .symbol = "A" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsAmpere,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-    ecs_entity_t bitmask_type = meta_lookup(
-        world, &params.type, params_decl, 1, &param_ctx);
-    ecs_check(bitmask_type != 0, ECS_INVALID_PARAMETER, NULL);
+    /* Amount of substance units */
 
-#ifndef FLECS_NDEBUG
-    /* Make sure this is a bitmask type */
-    const EcsMetaType *type_ptr = ecs_get(world, bitmask_type, EcsMetaType);
-    ecs_check(type_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(type_ptr->kind == EcsBitmaskType, ECS_INVALID_PARAMETER, NULL);
-#endif
+    EcsAmount = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Amount" });
+    prev_scope = ecs_set_scope(world, EcsAmount);
+        EcsMole = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Mole" }),
+            .quantity = EcsAmount,
+            .symbol = "mol" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsMole,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-    return bitmask_type;
-error:
-    return 0;
-}
+    /* Luminous intensity units */
 
-static
-ecs_entity_t meta_lookup(
-    ecs_world_t *world,
-    meta_type_t *token,
-    const char *ptr,
-    int64_t count,
-    meta_parse_ctx_t *ctx)
-{
-    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(token != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(ctx != NULL, ECS_INTERNAL_ERROR, NULL);
+    EcsLuminousIntensity = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "LuminousIntensity" });
+    prev_scope = ecs_set_scope(world, EcsLuminousIntensity);
+        EcsCandela = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Candela" }),
+            .quantity = EcsLuminousIntensity,
+            .symbol = "cd" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsCandela,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-    const char *typename = token->type;
-    ecs_entity_t type = 0;
+    /* Force units */
 
-    /* Parse vector type */
-    if (!token->is_ptr) {
-        if (!ecs_os_strcmp(typename, "ecs_array")) {
-            type = meta_lookup_array(world, 0, token->params, ctx);
-
-        } else if (!ecs_os_strcmp(typename, "ecs_vector") || 
-                !ecs_os_strcmp(typename, "flecs::vector")) 
-        {
-            type = meta_lookup_vector(world, 0, token->params, ctx);
+    EcsForce = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Force" });
+    prev_scope = ecs_set_scope(world, EcsForce);
+        EcsNewton = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Newton" }),
+            .quantity = EcsForce,
+            .symbol = "N" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsNewton,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-        } else if (!ecs_os_strcmp(typename, "flecs::bitmask")) {
-            type = meta_lookup_bitmask(world, 0, token->params, ctx);
+    /* Length units */
 
-        } else if (!ecs_os_strcmp(typename, "flecs::byte")) {
-            type = ecs_id(ecs_byte_t);
+    EcsLength = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Length" });
+    prev_scope = ecs_set_scope(world, EcsLength);
+        EcsMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Meters" }),
+            .quantity = EcsLength,
+            .symbol = "m" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsMeters,
+            .kind = EcsF32
+        });
 
-        } else if (!ecs_os_strcmp(typename, "char")) {
-            type = ecs_id(ecs_char_t);
+            EcsPicoMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "PicoMeters" }),
+                .quantity = EcsLength,
+                .base = EcsMeters,
+                .prefix = EcsPico });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsPicoMeters,
+                .kind = EcsF32
+            });
 
-        } else if (!ecs_os_strcmp(typename, "bool") || 
-                !ecs_os_strcmp(typename, "_Bool")) 
-        {
-            type = ecs_id(ecs_bool_t);
+            EcsNanoMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "NanoMeters" }),
+                .quantity = EcsLength,
+                .base = EcsMeters,
+                .prefix = EcsNano });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsNanoMeters,
+                .kind = EcsF32
+            });
 
-        } else if (!ecs_os_strcmp(typename, "int8_t")) {
-            type = ecs_id(ecs_i8_t);
-        } else if (!ecs_os_strcmp(typename, "int16_t")) {
-            type = ecs_id(ecs_i16_t);
-        } else if (!ecs_os_strcmp(typename, "int32_t")) {
-            type = ecs_id(ecs_i32_t);
-        } else if (!ecs_os_strcmp(typename, "int64_t")) {
-            type = ecs_id(ecs_i64_t);
+            EcsMicroMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "MicroMeters" }),
+                .quantity = EcsLength,
+                .base = EcsMeters,
+                .prefix = EcsMicro });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsMicroMeters,
+                .kind = EcsF32
+            });
 
-        } else if (!ecs_os_strcmp(typename, "uint8_t")) {
-            type = ecs_id(ecs_u8_t);
-        } else if (!ecs_os_strcmp(typename, "uint16_t")) {
-            type = ecs_id(ecs_u16_t);
-        } else if (!ecs_os_strcmp(typename, "uint32_t")) {
-            type = ecs_id(ecs_u32_t);
-        } else if (!ecs_os_strcmp(typename, "uint64_t")) {
-            type = ecs_id(ecs_u64_t);
+            EcsMilliMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "MilliMeters" }),
+                .quantity = EcsLength,
+                .base = EcsMeters,
+                .prefix = EcsMilli });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsMilliMeters,
+                .kind = EcsF32
+            });
 
-        } else if (!ecs_os_strcmp(typename, "float")) {
-            type = ecs_id(ecs_f32_t);
-        } else if (!ecs_os_strcmp(typename, "double")) {
-            type = ecs_id(ecs_f64_t);
+            EcsCentiMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "CentiMeters" }),
+                .quantity = EcsLength,
+                .base = EcsMeters,
+                .prefix = EcsCenti });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsCentiMeters,
+                .kind = EcsF32
+            });
 
-        } else if (!ecs_os_strcmp(typename, "ecs_entity_t")) {
-            type = ecs_id(ecs_entity_t);
+            EcsKiloMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "KiloMeters" }),
+                .quantity = EcsLength,
+                .base = EcsMeters,
+                .prefix = EcsKilo });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsKiloMeters,
+                .kind = EcsF32
+            });
+            
+        EcsMiles = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Miles" }),
+            .quantity = EcsLength,
+            .symbol = "mi"
+        });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsMiles,
+            .kind = EcsF32
+        });
 
-        } else if (!ecs_os_strcmp(typename, "ecs_id_t")) {
-            type = ecs_id(ecs_id_t);
+        EcsPixels = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Pixels" }),
+            .quantity = EcsLength,
+            .symbol = "px"
+        });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsPixels,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-        } else if (!ecs_os_strcmp(typename, "char*")) {
-            type = ecs_id(ecs_string_t);
-        } else {
-            type = ecs_lookup_symbol(world, typename, true, true);
-        }
-    } else {
-        if (!ecs_os_strcmp(typename, "char")) {
-            typename = "flecs.meta.string";
-        } else
-        if (token->is_ptr) {
-            typename = "flecs.meta.uptr";
-        } else
-        if (!ecs_os_strcmp(typename, "char*") || 
-            !ecs_os_strcmp(typename, "flecs::string")) 
-        {
-            typename = "flecs.meta.string";
-        }
+    /* Pressure units */
 
-        type = ecs_lookup_symbol(world, typename, true, true);
-    }
+    EcsPressure = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Pressure" });
+    prev_scope = ecs_set_scope(world, EcsPressure);
+        EcsPascal = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Pascal" }),
+            .quantity = EcsPressure,
+            .symbol = "Pa" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsPascal,
+            .kind = EcsF32
+        });
+        EcsBar = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Bar" }),
+            .quantity = EcsPressure,
+            .symbol = "bar" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsBar,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-    if (count != 1) {
-        ecs_check(count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL);
+    /* Speed units */
 
-        type = ecs_set(world, 0, EcsArray, {type, (int32_t)count});
-    }
+    EcsSpeed = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Speed" });
+    prev_scope = ecs_set_scope(world, EcsSpeed);
+        EcsMetersPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "MetersPerSecond" }),
+            .quantity = EcsSpeed,
+            .base = EcsMeters,
+            .over = EcsSeconds });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsMetersPerSecond,
+            .kind = EcsF32
+        });
+        EcsKiloMetersPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "KiloMetersPerSecond" }),
+            .quantity = EcsSpeed,
+            .base = EcsKiloMeters,
+            .over = EcsSeconds });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsKiloMetersPerSecond,
+            .kind = EcsF32
+        });
+        EcsKiloMetersPerHour = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "KiloMetersPerHour" }),
+            .quantity = EcsSpeed,
+            .base = EcsKiloMeters,
+            .over = EcsHours });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsKiloMetersPerHour,
+            .kind = EcsF32
+        });
+        EcsMilesPerHour = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "MilesPerHour" }),
+            .quantity = EcsSpeed,
+            .base = EcsMiles,
+            .over = EcsHours });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsMilesPerHour,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
+    
+    /* Acceleration */
 
-    if (!type) {
-        ecs_meta_error(ctx, ptr, "unknown type '%s'", typename);
-        goto error;
-    }
+    EcsAcceleration = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+        .entity = ecs_entity(world, { .name = "Acceleration" }),
+        .base = EcsMetersPerSecond,
+        .over = EcsSeconds });
+    ecs_quantity_init(world, &(ecs_entity_desc_t){
+        .id = EcsAcceleration
+    });
+    ecs_primitive_init(world, &(ecs_primitive_desc_t){
+        .entity = EcsAcceleration,
+        .kind = EcsF32
+    });
 
-    return type;
-error:
-    return 0;
-}
+    /* Temperature units */
 
-static
-int meta_parse_struct(
-    ecs_world_t *world,
-    ecs_entity_t t,
-    const char *desc)
-{
-    const char *ptr = desc;
-    const char *name = ecs_get_name(world, t);
+    EcsTemperature = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Temperature" });
+    prev_scope = ecs_set_scope(world, EcsTemperature);
+        EcsKelvin = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Kelvin" }),
+            .quantity = EcsTemperature,
+            .symbol = "K" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsKelvin,
+            .kind = EcsF32
+        });
+        EcsCelsius = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Celsius" }),
+            .quantity = EcsTemperature,
+            .symbol = "°C" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsCelsius,
+            .kind = EcsF32
+        });
+        EcsFahrenheit = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Fahrenheit" }),
+            .quantity = EcsTemperature,
+            .symbol = "F" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsFahrenheit,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-    meta_member_t token;
-    meta_parse_ctx_t ctx = {
-        .name = name,
-        .desc = ptr
-    };
+    /* Data units */
 
-    ecs_entity_t old_scope = ecs_set_scope(world, t);
+    EcsData = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Data" });
+    prev_scope = ecs_set_scope(world, EcsData);
 
-    while ((ptr = meta_parse_member(ptr, &token, &ctx)) && ptr[0]) {
-        ecs_entity_t m = ecs_entity(world, {
-            .name = token.name
+        EcsBits = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Bits" }),
+            .quantity = EcsData,
+            .symbol = "bit" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsBits,
+            .kind = EcsU64
         });
 
-        ecs_entity_t type = meta_lookup(
-            world, &token.type, ptr, 1, &ctx);
-        if (!type) {
-            goto error;
-        }
+            EcsKiloBits = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "KiloBits" }),
+                .quantity = EcsData,
+                .base = EcsBits,
+                .prefix = EcsKilo });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsKiloBits,
+                .kind = EcsU64
+            });
 
-        ecs_set(world, m, EcsMember, {
-            .type = type, 
-            .count = (ecs_size_t)token.count
-        });
-    }
+            EcsMegaBits = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "MegaBits" }),
+                .quantity = EcsData,
+                .base = EcsBits,
+                .prefix = EcsMega });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsMegaBits,
+                .kind = EcsU64
+            });
 
-    ecs_set_scope(world, old_scope);
+            EcsGigaBits = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "GigaBits" }),
+                .quantity = EcsData,
+                .base = EcsBits,
+                .prefix = EcsGiga });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsGigaBits,
+                .kind = EcsU64
+            });
 
-    return 0;
-error:
-    return -1;
-}
+        EcsBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Bytes" }),
+            .quantity = EcsData,
+            .symbol = "B",
+            .base = EcsBits,
+            .translation = { .factor = 8, .power = 1 } });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsBytes,
+            .kind = EcsU64
+        });
 
-static
-int meta_parse_constants(
-    ecs_world_t *world,
-    ecs_entity_t t,
-    const char *desc,
-    bool is_bitmask)
-{
-    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(t != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(desc != NULL, ECS_INTERNAL_ERROR, NULL);
+            EcsKiloBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "KiloBytes" }),
+                .quantity = EcsData,
+                .base = EcsBytes,
+                .prefix = EcsKilo });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsKiloBytes,
+                .kind = EcsU64
+            });
 
-    const char *ptr = desc;
-    const char *name = ecs_get_name(world, t);
-    int32_t name_len = ecs_os_strlen(name);
-    const ecs_world_info_t *info = ecs_get_world_info(world);
-    const char *name_prefix = info->name_prefix;
-    int32_t name_prefix_len = name_prefix ? ecs_os_strlen(name_prefix) : 0;
+            EcsMegaBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "MegaBytes" }),
+                .quantity = EcsData,
+                .base = EcsBytes,
+                .prefix = EcsMega });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsMegaBytes,
+                .kind = EcsU64
+            });
 
-    meta_parse_ctx_t ctx = {
-        .name = name,
-        .desc = ptr
-    };
+            EcsGigaBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "GigaBytes" }),
+                .quantity = EcsData,
+                .base = EcsBytes,
+                .prefix = EcsGiga });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsGigaBytes,
+                .kind = EcsU64
+            });
 
-    meta_constant_t token;
-    int64_t last_value = 0;
+            EcsKibiBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "KibiBytes" }),
+                .quantity = EcsData,
+                .base = EcsBytes,
+                .prefix = EcsKibi });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsKibiBytes,
+                .kind = EcsU64
+            });
 
-    ecs_entity_t old_scope = ecs_set_scope(world, t);
+            EcsMebiBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "MebiBytes" }),
+                .quantity = EcsData,
+                .base = EcsBytes,
+                .prefix = EcsMebi });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsMebiBytes,
+                .kind = EcsU64
+            });
 
-    while ((ptr = meta_parse_constant(ptr, &token, &ctx))) {
-        if (token.is_value_set) {
-            last_value = token.value;
-        } else if (is_bitmask) {
-            ecs_meta_error(&ctx, ptr,
-                "bitmask requires explicit value assignment");
-            goto error;
-        }
+            EcsGibiBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "GibiBytes" }),
+                .quantity = EcsData,
+                .base = EcsBytes,
+                .prefix = EcsGibi });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsGibiBytes,
+                .kind = EcsU64
+            });
 
-        if (name_prefix) {
-            if (!ecs_os_strncmp(token.name, name_prefix, name_prefix_len)) {
-                ecs_os_memmove(token.name, token.name + name_prefix_len, 
-                    ecs_os_strlen(token.name) - name_prefix_len + 1);
-            }
-        }
+    ecs_set_scope(world, prev_scope);
 
-        if (!ecs_os_strncmp(token.name, name, name_len)) {
-            ecs_os_memmove(token.name, token.name + name_len, 
-                ecs_os_strlen(token.name) - name_len + 1);
-        }
+    /* DataRate units */
 
-        ecs_entity_t c = ecs_entity(world, {
-            .name = token.name
-        });
+    EcsDataRate = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "DataRate" });
+    prev_scope = ecs_set_scope(world, EcsDataRate);
 
-        if (!is_bitmask) {
-            ecs_set_pair_object(world, c, EcsConstant, ecs_i32_t, 
-                {(ecs_i32_t)last_value});
-        } else {
-            ecs_set_pair_object(world, c, EcsConstant, ecs_u32_t, 
-                {(ecs_u32_t)last_value});
-        }
+        EcsBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "BitsPerSecond" }),
+            .quantity = EcsDataRate,
+            .base = EcsBits,
+            .over = EcsSeconds });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsBitsPerSecond,
+            .kind = EcsU64
+        });
 
-        last_value ++;
-    }
+            EcsKiloBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "KiloBitsPerSecond" }),
+                .quantity = EcsDataRate,
+                .base = EcsKiloBits,
+                .over = EcsSeconds
+            });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsKiloBitsPerSecond,
+                .kind = EcsU64
+            });
 
-    ecs_set_scope(world, old_scope);
+            EcsMegaBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "MegaBitsPerSecond" }),
+                .quantity = EcsDataRate,
+                .base = EcsMegaBits,
+                .over = EcsSeconds
+            });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsMegaBitsPerSecond,
+                .kind = EcsU64
+            });
 
-    return 0;
-error:
-    return -1;
-}
+            EcsGigaBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "GigaBitsPerSecond" }),
+                .quantity = EcsDataRate,
+                .base = EcsGigaBits,
+                .over = EcsSeconds
+            });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsGigaBitsPerSecond,
+                .kind = EcsU64
+            });
 
-static
-int meta_parse_enum(
-    ecs_world_t *world,
-    ecs_entity_t t,
-    const char *desc)
-{
-    ecs_add(world, t, EcsEnum);
-    return meta_parse_constants(world, t, desc, false);
-}
+        EcsBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "BytesPerSecond" }),
+            .quantity = EcsDataRate,
+            .base = EcsBytes,
+            .over = EcsSeconds });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsBytesPerSecond,
+            .kind = EcsU64
+        });
 
-static
-int meta_parse_bitmask(
-    ecs_world_t *world,
-    ecs_entity_t t,
-    const char *desc)
-{
-    ecs_add(world, t, EcsBitmask);
-    return meta_parse_constants(world, t, desc, true);
-}
+            EcsKiloBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "KiloBytesPerSecond" }),
+                .quantity = EcsDataRate,
+                .base = EcsKiloBytes,
+                .over = EcsSeconds
+            });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsKiloBytesPerSecond,
+                .kind = EcsU64
+            });
 
-int ecs_meta_from_desc(
-    ecs_world_t *world,
-    ecs_entity_t component,
-    ecs_type_kind_t kind,
-    const char *desc)
-{
-    switch(kind) {
-    case EcsStructType:
-        if (meta_parse_struct(world, component, desc)) {
-            goto error;
-        }
-        break;
-    case EcsEnumType:
-        if (meta_parse_enum(world, component, desc)) {
-            goto error;
-        }
-        break;
-    case EcsBitmaskType:
-        if (meta_parse_bitmask(world, component, desc)) {
-            goto error;
-        }
-        break;
-    case EcsPrimitiveType:
-    case EcsArrayType:
-    case EcsVectorType:
-    case EcsOpaqueType:
-        break;
-    default:
-        ecs_throw(ECS_INTERNAL_ERROR, "invalid type kind");
-    }
+            EcsMegaBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "MegaBytesPerSecond" }),
+                .quantity = EcsDataRate,
+                .base = EcsMegaBytes,
+                .over = EcsSeconds
+            });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsMegaBytesPerSecond,
+                .kind = EcsU64
+            });
 
-    return 0;
-error:
-    return -1;
-}
+            EcsGigaBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+                .entity = ecs_entity(world, { .name = "GigaBytesPerSecond" }),
+                .quantity = EcsDataRate,
+                .base = EcsGigaBytes,
+                .over = EcsSeconds
+            });
+            ecs_primitive_init(world, &(ecs_primitive_desc_t){
+                .entity = EcsGigaBytesPerSecond,
+                .kind = EcsU64
+            });
 
-#endif
+        ecs_set_scope(world, prev_scope);
 
-/**
- * @file addons/metrics.c
- * @brief Metrics addon.
- */
+    /* Percentage */
 
+    EcsPercentage = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Percentage" });
+    ecs_unit_init(world, &(ecs_unit_desc_t){ 
+        .entity = EcsPercentage,
+        .symbol = "%"
+    });
+    ecs_primitive_init(world, &(ecs_primitive_desc_t){
+        .entity = EcsPercentage,
+        .kind = EcsF32
+    });
 
-#ifdef FLECS_METRICS
+    /* Angles */
 
-/* Public components */
-ECS_COMPONENT_DECLARE(FlecsMetrics);
-ECS_TAG_DECLARE(EcsMetricInstance);
-ECS_COMPONENT_DECLARE(EcsMetricValue);
-ECS_COMPONENT_DECLARE(EcsMetricSource);
-ECS_TAG_DECLARE(EcsMetric);
-ECS_TAG_DECLARE(EcsCounter);
-ECS_TAG_DECLARE(EcsCounterIncrement);
-ECS_TAG_DECLARE(EcsCounterId);
-ECS_TAG_DECLARE(EcsGauge);
+    EcsAngle = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Angle" });
+    prev_scope = ecs_set_scope(world, EcsAngle);
+        EcsRadians = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Radians" }),
+            .quantity = EcsAngle,
+            .symbol = "rad" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsRadians,
+            .kind = EcsF32
+        });
 
-/* Internal components */
-static ECS_COMPONENT_DECLARE(EcsMetricMember);
-static ECS_COMPONENT_DECLARE(EcsMetricId);
-static ECS_COMPONENT_DECLARE(EcsMetricOneOf);
-static ECS_COMPONENT_DECLARE(EcsMetricCountIds);
-static ECS_COMPONENT_DECLARE(EcsMetricCountTargets);
-static ECS_COMPONENT_DECLARE(EcsMetricMemberInstance);
-static ECS_COMPONENT_DECLARE(EcsMetricIdInstance);
-static ECS_COMPONENT_DECLARE(EcsMetricOneOfInstance);
+        EcsDegrees = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Degrees" }),
+            .quantity = EcsAngle,
+            .symbol = "°" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsDegrees,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-/** Context for metric */
-typedef struct {
-    ecs_entity_t metric;              /**< Metric entity */
-    ecs_entity_t kind;                /**< Metric kind (gauge, counter) */
-} ecs_metric_ctx_t;
+    /* DeciBel */
 
-/** Context for metric that monitors member */
-typedef struct {
-    ecs_metric_ctx_t metric;
-    ecs_primitive_kind_t type_kind;  /**< Primitive type kind of member */
-    uint16_t offset;                 /**< Offset of member in component */
-} ecs_member_metric_ctx_t;
+    EcsBel = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+        .entity = ecs_entity(world, { .name = "Bel" }),
+        .symbol = "B" });
+    ecs_primitive_init(world, &(ecs_primitive_desc_t){
+        .entity = EcsBel,
+        .kind = EcsF32
+    });
+    EcsDeciBel = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+        .entity = ecs_entity(world, { .name = "DeciBel" }),
+        .prefix = EcsDeci,
+        .base = EcsBel });
+    ecs_primitive_init(world, &(ecs_primitive_desc_t){
+        .entity = EcsDeciBel,
+        .kind = EcsF32
+    });
 
-/** Context for metric that monitors whether entity has id */
-typedef struct {
-    ecs_metric_ctx_t metric;
-    ecs_id_record_t *idr;            /**< Id record for monitored component */
-} ecs_id_metric_ctx_t;
+    EcsFrequency = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Frequency" });
+    prev_scope = ecs_set_scope(world, EcsFrequency);
 
-/** Context for metric that monitors whether entity has pair target */
-typedef struct {
-    ecs_metric_ctx_t metric;
-    ecs_id_record_t *idr;            /**< Id record for monitored component */
-    ecs_size_t size;                 /**< Size of metric type */
-    ecs_map_t target_offset;         /**< Pair target to metric type offset */
-} ecs_oneof_metric_ctx_t;
+        EcsHertz = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Hertz" }),
+            .quantity = EcsFrequency,
+            .symbol = "Hz" });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsHertz,
+            .kind = EcsF32
+        });
 
-/** Context for metric that monitors how many entities have a pair target */
-typedef struct {
-    ecs_metric_ctx_t metric;
-    ecs_id_record_t *idr;            /**< Id record for monitored component */
-    ecs_map_t targets;               /**< Map of counters for each target */
-} ecs_count_targets_metric_ctx_t;
+        EcsKiloHertz = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "KiloHertz" }),
+            .prefix = EcsKilo,
+            .base = EcsHertz });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsKiloHertz,
+            .kind = EcsF32
+        });
 
-/** Stores context shared for all instances of member metric */
-typedef struct {
-    ecs_member_metric_ctx_t *ctx;
-} EcsMetricMember;
+        EcsMegaHertz = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "MegaHertz" }),
+            .prefix = EcsMega,
+            .base = EcsHertz });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsMegaHertz,
+            .kind = EcsF32
+        });
 
-/** Stores context shared for all instances of id metric */
-typedef struct {
-    ecs_id_metric_ctx_t *ctx;
-} EcsMetricId;
+        EcsGigaHertz = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "GigaHertz" }),
+            .prefix = EcsGiga,
+            .base = EcsHertz });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsGigaHertz,
+            .kind = EcsF32
+        });
+    ecs_set_scope(world, prev_scope);
 
-/** Stores context shared for all instances of oneof metric */
-typedef struct {
-    ecs_oneof_metric_ctx_t *ctx;
-} EcsMetricOneOf;
+    EcsUri = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
+        .name = "Uri" });
+    prev_scope = ecs_set_scope(world, EcsUri);
 
-/** Stores context shared for all instances of id counter metric */
-typedef struct {
-    ecs_id_t id;
-} EcsMetricCountIds;
+        EcsUriHyperlink = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Hyperlink" }),
+            .quantity = EcsUri });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsUriHyperlink,
+            .kind = EcsString
+        });
 
-/** Stores context shared for all instances of target counter metric */
-typedef struct {
-    ecs_count_targets_metric_ctx_t *ctx;
-} EcsMetricCountTargets;
+        EcsUriImage = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "Image" }),
+            .quantity = EcsUri });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsUriImage,
+            .kind = EcsString
+        });
 
-/** Instance of member metric */
-typedef struct {
-    ecs_ref_t ref;
-    ecs_member_metric_ctx_t *ctx;
-} EcsMetricMemberInstance;
+        EcsUriFile = ecs_unit_init(world, &(ecs_unit_desc_t){ 
+            .entity = ecs_entity(world, { .name = "File" }),
+            .quantity = EcsUri });
+        ecs_primitive_init(world, &(ecs_primitive_desc_t){
+            .entity = EcsUriFile,
+            .kind = EcsString
+        });
+    ecs_set_scope(world, prev_scope);
 
-/** Instance of id metric */
-typedef struct {
-    ecs_record_t *r;
-    ecs_id_metric_ctx_t *ctx;
-} EcsMetricIdInstance;
+    /* Documentation */
+#ifdef FLECS_DOC
+    ECS_IMPORT(world, FlecsDoc);
 
-/** Instance of oneof metric */
-typedef struct {
-    ecs_record_t *r;
-    ecs_oneof_metric_ctx_t *ctx;
-} EcsMetricOneOfInstance;
+    ecs_doc_set_brief(world, EcsDuration, 
+        "Time amount (e.g. \"20 seconds\", \"2 hours\")");
+    ecs_doc_set_brief(world, EcsSeconds, "Time amount in seconds");
+    ecs_doc_set_brief(world, EcsMinutes, "60 seconds");
+    ecs_doc_set_brief(world, EcsHours, "60 minutes");
+    ecs_doc_set_brief(world, EcsDays, "24 hours");
 
-/** Component lifecycle */
+    ecs_doc_set_brief(world, EcsTime,
+        "Time passed since an epoch (e.g. \"5pm\", \"March 3rd 2022\")");
+    ecs_doc_set_brief(world, EcsDate,
+        "Seconds passed since January 1st 1970");
 
-static ECS_DTOR(EcsMetricMember, ptr, {
-    ecs_os_free(ptr->ctx);
-})
+    ecs_doc_set_brief(world, EcsMass, "Units of mass (e.g. \"5 kilograms\")");
 
-static ECS_MOVE(EcsMetricMember, dst, src, {
-    *dst = *src;
-    src->ctx = NULL;
-})
+    ecs_doc_set_brief(world, EcsElectricCurrent,
+        "Units of electrical current (e.g. \"2 ampere\")");
 
-static ECS_DTOR(EcsMetricId, ptr, {
-    ecs_os_free(ptr->ctx);
-})
+    ecs_doc_set_brief(world, EcsAmount,
+        "Units of amount of substance (e.g. \"2 mole\")");
 
-static ECS_MOVE(EcsMetricId, dst, src, {
-    *dst = *src;
-    src->ctx = NULL;
-})
+    ecs_doc_set_brief(world, EcsLuminousIntensity,
+        "Units of luminous intensity (e.g. \"1 candela\")");
 
-static ECS_DTOR(EcsMetricOneOf, ptr, {
-    if (ptr->ctx) {
-        ecs_map_fini(&ptr->ctx->target_offset);
-        ecs_os_free(ptr->ctx);
-    }
-})
+    ecs_doc_set_brief(world, EcsForce, "Units of force (e.g. \"10 newton\")");
 
-static ECS_MOVE(EcsMetricOneOf, dst, src, {
-    *dst = *src;
-    src->ctx = NULL;
-})
+    ecs_doc_set_brief(world, EcsLength,
+        "Units of length (e.g. \"5 meters\", \"20 miles\")");
 
-static ECS_DTOR(EcsMetricCountTargets, ptr, {
-    if (ptr->ctx) {
-        ecs_map_fini(&ptr->ctx->targets);
-        ecs_os_free(ptr->ctx);
-    }
-})
+    ecs_doc_set_brief(world, EcsPressure, 
+        "Units of pressure (e.g. \"1 bar\", \"1000 pascal\")");
 
-static ECS_MOVE(EcsMetricCountTargets, dst, src, {
-    *dst = *src;
-    src->ctx = NULL;
-})
+    ecs_doc_set_brief(world, EcsSpeed,
+        "Units of movement (e.g. \"5 meters/second\")");
 
-/** Observer used for creating new instances of member metric */
-static void flecs_metrics_on_member_metric(ecs_iter_t *it) {
-    ecs_world_t *world = it->world;
-    ecs_member_metric_ctx_t *ctx = it->ctx;
-    ecs_id_t id = ecs_field_id(it, 1);
+    ecs_doc_set_brief(world, EcsAcceleration,
+        "Unit of speed increase (e.g. \"5 meters/second/second\")");
 
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t e = it->entities[i];
-        ecs_entity_t m = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
+    ecs_doc_set_brief(world, EcsTemperature,
+        "Units of temperature (e.g. \"5 degrees Celsius\")");
 
-        EcsMetricMemberInstance *src = ecs_emplace(
-            world, m, EcsMetricMemberInstance);
-        src->ref = ecs_ref_init_id(world, e, id);
-        src->ctx = ctx;
-        ecs_modified(world, m, EcsMetricMemberInstance);
-        ecs_set(world, m, EcsMetricValue, { 0 });
-        ecs_set(world, m, EcsMetricSource, { e });
-        ecs_add(world, m, EcsMetricInstance);
-        ecs_add_pair(world, m, EcsMetric, ctx->metric.kind);
-    }
-}
+    ecs_doc_set_brief(world, EcsData,
+        "Units of information (e.g. \"8 bits\", \"100 megabytes\")");
 
-/** Observer used for creating new instances of id metric */
-static void flecs_metrics_on_id_metric(ecs_iter_t *it) {
-    ecs_world_t *world = it->world;
-    ecs_id_metric_ctx_t *ctx = it->ctx;
+    ecs_doc_set_brief(world, EcsDataRate,
+        "Units of data transmission (e.g. \"100 megabits/second\")");
 
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t e = it->entities[i];
-        ecs_entity_t m = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
+    ecs_doc_set_brief(world, EcsAngle,
+        "Units of rotation (e.g. \"1.2 radians\", \"180 degrees\")");
 
-        EcsMetricIdInstance *src = ecs_emplace(world, m, EcsMetricIdInstance);
-        src->r = ecs_record_find(world, e);
-        src->ctx = ctx;
-        ecs_modified(world, m, EcsMetricIdInstance);
-        ecs_set(world, m, EcsMetricValue, { 0 });
-        ecs_set(world, m, EcsMetricSource, { e });
-        ecs_add(world, m, EcsMetricInstance);
-        ecs_add_pair(world, m, EcsMetric, ctx->metric.kind);
-    }
+    ecs_doc_set_brief(world, EcsFrequency, 
+        "The number of occurrences of a repeating event per unit of time.");
+
+    ecs_doc_set_brief(world, EcsUri, "Universal resource identifier.");
+#endif
 }
 
-/** Observer used for creating new instances of oneof metric */
-static void flecs_metrics_on_oneof_metric(ecs_iter_t *it) {
-    if (it->event == EcsOnRemove) {
-        return;
-    }
+#endif
 
-    ecs_world_t *world = it->world;
-    ecs_oneof_metric_ctx_t *ctx = it->ctx;
+/**
+ * @file datastructures/allocator.c
+ * @brief Allocator for any size.
+ * 
+ * Allocators create a block allocator for each requested size.
+ */
 
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t e = it->entities[i];
-        ecs_entity_t m = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
 
-        EcsMetricOneOfInstance *src = ecs_emplace(world, m, EcsMetricOneOfInstance);
-        src->r = ecs_record_find(world, e);
-        src->ctx = ctx;
-        ecs_modified(world, m, EcsMetricOneOfInstance);
-        ecs_add_pair(world, m, ctx->metric.metric, ecs_id(EcsMetricValue));
-        ecs_set(world, m, EcsMetricSource, { e });
-        ecs_add(world, m, EcsMetricInstance);
-        ecs_add_pair(world, m, EcsMetric, ctx->metric.kind);
-    }
+static
+ecs_size_t flecs_allocator_size(
+    ecs_size_t size)
+{
+    return ECS_ALIGN(size, 16);
 }
 
-/** Set doc name of metric instance to name of source entity */
-#ifdef FLECS_DOC
-static void SetMetricDocName(ecs_iter_t *it) {
-    ecs_world_t *world = it->world;
-    EcsMetricSource *src = ecs_field(it, EcsMetricSource, 1);
+static
+ecs_size_t flecs_allocator_size_hash(
+    ecs_size_t size)
+{
+    return size >> 4;
+}
 
-    int32_t i, count = it->count;
+void flecs_allocator_init(
+    ecs_allocator_t *a)
+{
+    flecs_ballocator_init_n(&a->chunks, ecs_block_allocator_t,
+        FLECS_SPARSE_PAGE_SIZE);
+    flecs_sparse_init_t(&a->sizes, NULL, &a->chunks, ecs_block_allocator_t);
+}
+
+void flecs_allocator_fini(
+    ecs_allocator_t *a)
+{
+    int32_t i = 0, count = flecs_sparse_count(&a->sizes);
     for (i = 0; i < count; i ++) {
-        ecs_entity_t src_e = src[i].entity;
-        const char *name = ecs_get_name(world, src_e);
-        if (name) {
-            ecs_doc_set_name(world, it->entities[i], name);
-        }
+        ecs_block_allocator_t *ba = flecs_sparse_get_dense_t(
+            &a->sizes, ecs_block_allocator_t, i);
+        flecs_ballocator_fini(ba);
     }
+    flecs_sparse_fini(&a->sizes);
+    flecs_ballocator_fini(&a->chunks);
 }
-#endif
 
-/** Delete metric instances for entities that are no longer alive */
-static void ClearMetricInstance(ecs_iter_t *it) {
-    ecs_world_t *world = it->world;
-    EcsMetricSource *src = ecs_field(it, EcsMetricSource, 1);
+ecs_block_allocator_t* flecs_allocator_get(
+    ecs_allocator_t *a, 
+    ecs_size_t size)
+{
+    ecs_assert(size >= 0, ECS_INTERNAL_ERROR, NULL);
+    if (!size) {
+        return NULL;
+    }
 
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t src_e = src[i].entity;
-        if (!ecs_is_alive(world, src_e)) {
-            ecs_delete(world, it->entities[i]);
-        }
+    ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(size <= flecs_allocator_size(size), ECS_INTERNAL_ERROR, NULL);
+    size = flecs_allocator_size(size);
+    ecs_size_t hash = flecs_allocator_size_hash(size);
+    ecs_block_allocator_t *result = flecs_sparse_get_any_t(&a->sizes, 
+        ecs_block_allocator_t, (uint32_t)hash);
+
+    if (!result) {
+        result = flecs_sparse_ensure_fast_t(&a->sizes, 
+            ecs_block_allocator_t, (uint32_t)hash);
+        flecs_ballocator_init(result, size);
     }
-}
 
-/** Update member metric */
-static void UpdateMemberInstance(ecs_iter_t *it, bool counter) {
-    ecs_world_t *world = it->real_world;
-    EcsMetricValue *m = ecs_field(it, EcsMetricValue, 1);
-    EcsMetricMemberInstance *mi = ecs_field(it, EcsMetricMemberInstance, 2);
-    ecs_ftime_t dt = it->delta_time;
+    ecs_assert(result->data_size == size, ECS_INTERNAL_ERROR, NULL);
 
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_member_metric_ctx_t *ctx = mi[i].ctx;
-        ecs_ref_t *ref = &mi[i].ref;
-        if (!ref->entity) {
-            continue;
-        }
+    return result;
+}
 
-        const void *ptr = ecs_ref_get_id(world, ref, ref->id);
-        if (ptr) {
-            ptr = ECS_OFFSET(ptr, ctx->offset);
-            if (!counter) {
-                m[i].value = ecs_meta_ptr_to_float(ctx->type_kind, ptr);
-            } else {
-                m[i].value += 
-                    ecs_meta_ptr_to_float(ctx->type_kind, ptr) * (double)dt;
-            }
-        } else {
-            ecs_delete(it->world, it->entities[i]);
-        }
-    }
-}
-
-static void UpdateGaugeMemberInstance(ecs_iter_t *it) {
-    UpdateMemberInstance(it, false);
+char* flecs_strdup(
+    ecs_allocator_t *a, 
+    const char* str)
+{
+    ecs_size_t len = ecs_os_strlen(str);
+    char *result = flecs_alloc_n(a, char, len + 1);
+    ecs_os_memcpy(result, str, len + 1);
+    return result;
 }
 
-static void UpdateCounterMemberInstance(ecs_iter_t *it) {
-    UpdateMemberInstance(it, false);
+void flecs_strfree(
+    ecs_allocator_t *a, 
+    char* str)
+{
+    ecs_size_t len = ecs_os_strlen(str);
+    flecs_free_n(a, char, len + 1, str);
 }
 
-static void UpdateCounterIncrementMemberInstance(ecs_iter_t *it) {
-    UpdateMemberInstance(it, true);
+void* flecs_dup(
+    ecs_allocator_t *a,
+    ecs_size_t size,
+    const void *src)
+{
+    ecs_block_allocator_t *ba = flecs_allocator_get(a, size);
+    if (ba) {
+        void *dst = flecs_balloc(ba);
+        ecs_os_memcpy(dst, src, size);
+        return dst;
+    } else {
+        return NULL;
+    }
 }
 
-/** Update id metric */
-static void UpdateIdInstance(ecs_iter_t *it, bool counter) {
-    ecs_world_t *world = it->real_world;
-    EcsMetricValue *m = ecs_field(it, EcsMetricValue, 1);
-    EcsMetricIdInstance *mi = ecs_field(it, EcsMetricIdInstance, 2);
-    ecs_ftime_t dt = it->delta_time;
-
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_record_t *r = mi[i].r;
-        if (!r) {
-            continue;
-        }
+/**
+ * @file datastructures/bitset.c
+ * @brief Bitset data structure.
+ * 
+ * Simple bitset implementation. The bitset allows for storage of arbitrary
+ * numbers of bits.
+ */
 
-        ecs_table_t *table = r->table;
-        if (!table) {
-            ecs_delete(it->world, it->entities[i]);
-            continue;
-        }
 
-        ecs_id_metric_ctx_t *ctx = mi[i].ctx;
-        ecs_id_record_t *idr = ctx->idr;
-        if (flecs_search_w_idr(world, table, idr->id, NULL, idr) != -1) {
-            if (!counter) {
-                m[i].value = 1.0;
-            } else {
-                m[i].value += 1.0 * (double)dt;
-            }
-        } else {
-            ecs_delete(it->world, it->entities[i]);
-        }
+static
+void ensure(
+    ecs_bitset_t *bs,
+    ecs_size_t size)
+{
+    if (!bs->size) {
+        int32_t new_size = ((size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t);
+        bs->size = ((size - 1) / 64 + 1) * 64;
+        bs->data = ecs_os_calloc(new_size);
+    } else if (size > bs->size) {
+        int32_t prev_size = ((bs->size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t);
+        bs->size = ((size - 1) / 64 + 1) * 64;
+        int32_t new_size = ((size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t);
+        bs->data = ecs_os_realloc(bs->data, new_size);
+        ecs_os_memset(ECS_OFFSET(bs->data, prev_size), 0, new_size - prev_size);
     }
 }
 
-static void UpdateGaugeIdInstance(ecs_iter_t *it) {
-    UpdateIdInstance(it, false);
-}
-
-static void UpdateCounterIdInstance(ecs_iter_t *it) {
-    UpdateIdInstance(it, true);
+void flecs_bitset_init(
+    ecs_bitset_t* bs)
+{
+    bs->size = 0;
+    bs->count = 0;
+    bs->data = NULL;
 }
 
-/** Update oneof metric */
-static void UpdateOneOfInstance(ecs_iter_t *it, bool counter) {
-    ecs_world_t *world = it->real_world;
-    ecs_table_t *table = it->table;
-    void *m = ecs_table_get_column(table, 
-        ecs_table_type_to_column_index(table, it->columns[0] - 1), it->offset);
-    EcsMetricOneOfInstance *mi = ecs_field(it, EcsMetricOneOfInstance, 2);
-    ecs_ftime_t dt = it->delta_time;
-
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_oneof_metric_ctx_t *ctx = mi[i].ctx;
-        ecs_record_t *r = mi[i].r;
-        if (!r) {
-            continue;
-        }
-
-        ecs_table_t *mtable = r->table;
-
-        double *value = ECS_ELEM(m, ctx->size, i);
-        if (!counter) {
-            ecs_os_memset(value, 0, ctx->size);
-        }
-
-        if (!mtable) {
-            ecs_delete(it->world, it->entities[i]);
-            continue;
-        }
-
-        ecs_id_record_t *idr = ctx->idr;
-        ecs_id_t id;
-        if (flecs_search_w_idr(world, mtable, idr->id, &id, idr) == -1) {
-            ecs_delete(it->world, it->entities[i]);
-            continue;
-        }
-
-        ecs_entity_t tgt = ECS_PAIR_SECOND(id);
-        uint64_t *offset = ecs_map_get(&ctx->target_offset, tgt);
-        if (!offset) {
-            ecs_err("unexpected relationship target for metric");
-            continue;
-        }
-
-        value = ECS_OFFSET(value, *offset);
-
-        if (!counter) {
-            *value = 1.0;
-        } else {
-            *value += 1.0 * (double)dt;
-        }
+void flecs_bitset_ensure(
+    ecs_bitset_t *bs,
+    int32_t count)
+{
+    if (count > bs->count) {
+        bs->count = count;
+        ensure(bs, count);
     }
 }
 
-static void UpdateGaugeOneOfInstance(ecs_iter_t *it) {
-    UpdateOneOfInstance(it, false);
+void flecs_bitset_fini(
+    ecs_bitset_t *bs)
+{
+    ecs_os_free(bs->data);
+    bs->data = NULL;
+    bs->count = 0;
 }
 
-static void UpdateCounterOneOfInstance(ecs_iter_t *it) {
-    UpdateOneOfInstance(it, true);
+void flecs_bitset_addn(
+    ecs_bitset_t *bs,
+    int32_t count)
+{
+    int32_t elem = bs->count += count;
+    ensure(bs, elem);
 }
 
-static void UpdateCountTargets(ecs_iter_t *it) {
-    ecs_world_t *world = it->real_world;
-    EcsMetricCountTargets *m = ecs_field(it, EcsMetricCountTargets, 1);
-
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_count_targets_metric_ctx_t *ctx = m[i].ctx;
-        ecs_id_record_t *cur = ctx->idr;
-        while ((cur = cur->first.next)) {
-            ecs_id_t id = cur->id;
-            ecs_entity_t *mi = ecs_map_ensure(&ctx->targets, id);
-            if (!mi[0]) {
-                mi[0] = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
-                ecs_entity_t tgt = ecs_pair_second(world, cur->id);
-                const char *name = ecs_get_name(world, tgt);
-                if (name) {
-                    ecs_set_name(world, mi[0], name);
-                }
-
-                EcsMetricSource *source = ecs_ensure(
-                    world, mi[0], EcsMetricSource);
-                source->entity = tgt;
-            }
+void flecs_bitset_set(
+    ecs_bitset_t *bs,
+    int32_t elem,
+    bool value)
+{
+    ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL);
+    uint32_t hi = ((uint32_t)elem) >> 6;
+    uint32_t lo = ((uint32_t)elem) & 0x3F;
+    uint64_t v = bs->data[hi];
+    bs->data[hi] = (v & ~((uint64_t)1 << lo)) | ((uint64_t)value << lo);
+error:
+    return;
+}
 
-            EcsMetricValue *value = ecs_ensure(world, mi[0], EcsMetricValue);
-            value->value += (double)ecs_count_id(world, cur->id) * 
-                (double)it->delta_system_time;
-        }
-    }
+bool flecs_bitset_get(
+    const ecs_bitset_t *bs,
+    int32_t elem)
+{
+    ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL);
+    return !!(bs->data[elem >> 6] & ((uint64_t)1 << ((uint64_t)elem & 0x3F)));
+error:
+    return false;
 }
 
-static void UpdateCountIds(ecs_iter_t *it) {
-    ecs_world_t *world = it->real_world;
-    EcsMetricCountIds *m = ecs_field(it, EcsMetricCountIds, 1);
-    EcsMetricValue *v = ecs_field(it, EcsMetricValue, 2);
+int32_t flecs_bitset_count(
+    const ecs_bitset_t *bs)
+{
+    return bs->count;
+}
 
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        v[i].value += (double)ecs_count_id(world, m[i].id) * 
-            (double)it->delta_system_time;
-    }
+void flecs_bitset_remove(
+    ecs_bitset_t *bs,
+    int32_t elem)
+{
+    ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL);
+    int32_t last = bs->count - 1;
+    bool last_value = flecs_bitset_get(bs, last);
+    flecs_bitset_set(bs, elem, last_value);
+    flecs_bitset_set(bs, last, 0);
+    bs->count --;
+error:
+    return;
 }
 
-/** Initialize member metric */
-static
-int flecs_member_metric_init(
-    ecs_world_t *world,
-    ecs_entity_t metric,
-    const ecs_metric_desc_t *desc)
+void flecs_bitset_swap(
+    ecs_bitset_t *bs,
+    int32_t elem_a,
+    int32_t elem_b)
 {
-    ecs_entity_t type = 0, member_type = 0, member = 0, id = 0;
-    uintptr_t offset = 0;
+    ecs_check(elem_a < bs->count, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(elem_b < bs->count, ECS_INVALID_PARAMETER, NULL);
 
-    if (desc->dotmember) {
-        if (!desc->id) {
-            char *metric_name = ecs_get_fullpath(world, metric);
-            ecs_err("missing id for metric '%s' with member '%s",
-                metric_name, desc->dotmember);
-            ecs_os_free(metric_name);
-            goto error;
-        }
+    bool a = flecs_bitset_get(bs, elem_a);
+    bool b = flecs_bitset_get(bs, elem_b);
+    flecs_bitset_set(bs, elem_a, b);
+    flecs_bitset_set(bs, elem_b, a);
+error:
+    return;
+}
 
-        if (desc->member) {
-            char *metric_name = ecs_get_fullpath(world, metric);
-            ecs_err("cannot set both member and dotmember for metric '%s'",
-                metric_name);
-            ecs_os_free(metric_name);
-            goto error;
-        }
+/**
+ * @file datastructures/block_allocator.c
+ * @brief Block allocator.
+ * 
+ * A block allocator is an allocator for a fixed size that allocates blocks of
+ * memory with N elements of the requested size.
+ */
 
-        type = ecs_get_typeid(world, desc->id);
 
-        ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, NULL);
-        if (ecs_meta_push(&cur)) {
-            char *metric_name = ecs_get_fullpath(world, metric);
-            ecs_err("invalid type for metric '%s'", metric_name);
-            ecs_os_free(metric_name);
-            goto error;
-        }
-        if (ecs_meta_dotmember(&cur, desc->dotmember)) {
-            char *metric_name = ecs_get_fullpath(world, metric);
-            ecs_err("invalid dotmember '%s' for metric '%s'",
-                desc->dotmember, metric_name);
-            ecs_os_free(metric_name);
-            goto error;
-        }
+// #ifdef FLECS_SANITIZE
+// #define FLECS_MEMSET_UNINITIALIZED
+// #endif
 
-        id = desc->id;
-        member_type = ecs_meta_get_type(&cur);
-        offset = (uintptr_t)ecs_meta_get_ptr(&cur);
-        member = ecs_meta_get_member_id(&cur);
-    } else {    
-        const EcsMember *m = ecs_get(world, desc->member, EcsMember);
-        if (!m) {
-            char *metric_name = ecs_get_fullpath(world, metric);
-            char *member_name = ecs_get_fullpath(world, desc->member);
-            ecs_err("entity '%s' provided for metric '%s' is not a member",
-                member_name, metric_name);
-            ecs_os_free(member_name);
-            ecs_os_free(metric_name);
-            goto error;
-        }
+int64_t ecs_block_allocator_alloc_count = 0;
+int64_t ecs_block_allocator_free_count = 0;
 
-        type = ecs_get_parent(world, desc->member);
-        if (!type) {
-            char *metric_name = ecs_get_fullpath(world, metric);
-            char *member_name = ecs_get_fullpath(world, desc->member);
-            ecs_err("member '%s' provided for metric '%s' is not part of a type",
-                member_name, metric_name);
-            ecs_os_free(member_name);
-            ecs_os_free(metric_name);
-            goto error;
-        }
-        
-        id = type;
-        if (desc->id) {
-            if (type != ecs_get_typeid(world, desc->id)) {
-                char *metric_name = ecs_get_fullpath(world, metric);
-                char *member_name = ecs_get_fullpath(world, desc->member);
-                char *id_name = ecs_get_fullpath(world, desc->id);
-                ecs_err("member '%s' for metric '%s' is not of type '%s'",
-                    member_name, metric_name, id_name);
-                ecs_os_free(id_name);
-                ecs_os_free(member_name);
-                ecs_os_free(metric_name);
-                goto error;
-            }
-            id = desc->id;
-        }
+#ifndef FLECS_USE_OS_ALLOC
 
-        member = desc->member;
-        member_type = m->type;
-        offset = flecs_ito(uintptr_t, m->offset);
+static
+ecs_block_allocator_chunk_header_t* flecs_balloc_block(
+    ecs_block_allocator_t *allocator)
+{
+    if (!allocator->chunk_size) {
+        return NULL;
     }
 
-    const EcsPrimitive *p = ecs_get(world, member_type, EcsPrimitive);
-    if (!p) {
-        char *metric_name = ecs_get_fullpath(world, metric);
-        char *member_name = ecs_get_fullpath(world, desc->member);
-        ecs_err("member '%s' provided for metric '%s' must have primitive type",
-            member_name, metric_name);
-        ecs_os_free(member_name);
-        ecs_os_free(metric_name);
-        goto error;
-    }
+    ecs_block_allocator_block_t *block = 
+        ecs_os_malloc(ECS_SIZEOF(ecs_block_allocator_block_t) +
+            allocator->block_size);
+    ecs_block_allocator_chunk_header_t *first_chunk = ECS_OFFSET(block, 
+        ECS_SIZEOF(ecs_block_allocator_block_t));
 
-    const EcsMetaType *mt = ecs_get(world, type, EcsMetaType);
-    if (!mt) {
-        char *metric_name = ecs_get_fullpath(world, metric);
-        char *member_name = ecs_get_fullpath(world, desc->member);
-        ecs_err("parent of member '%s' for metric '%s' is not a type",
-            member_name, metric_name);
-        ecs_os_free(member_name);
-        ecs_os_free(metric_name);
-        goto error;
+    block->memory = first_chunk;
+    if (!allocator->block_tail) {
+        ecs_assert(!allocator->block_head, ECS_INTERNAL_ERROR, 0);
+        block->next = NULL;
+        allocator->block_head = block;
+        allocator->block_tail = block;
+    } else {
+        block->next = NULL;
+        allocator->block_tail->next = block;
+        allocator->block_tail = block;
     }
 
-    if (mt->kind != EcsStructType) {
-        char *metric_name = ecs_get_fullpath(world, metric);
-        char *member_name = ecs_get_fullpath(world, desc->member);
-        ecs_err("parent of member '%s' for metric '%s' is not a struct",
-            member_name, metric_name);
-        ecs_os_free(member_name);
-        ecs_os_free(metric_name);
-        goto error;
+    ecs_block_allocator_chunk_header_t *chunk = first_chunk;
+    int32_t i, end;
+    for (i = 0, end = allocator->chunks_per_block - 1; i < end; ++i) {
+        chunk->next = ECS_OFFSET(chunk, allocator->chunk_size);
+        chunk = chunk->next;
     }
 
-    ecs_member_metric_ctx_t *ctx = ecs_os_calloc_t(ecs_member_metric_ctx_t);
-    ctx->metric.metric = metric;
-    ctx->metric.kind = desc->kind;
-    ctx->type_kind = p->kind;
-    ctx->offset = flecs_uto(uint16_t, offset);
+    ecs_os_linc(&ecs_block_allocator_alloc_count);
 
-    ecs_observer(world, {
-        .entity = metric,
-        .events = { EcsOnAdd },
-        .filter.terms[0] = {
-            .id = id,
-            .src.flags = EcsSelf,
-            .inout = EcsInOutNone
-        },
-        .callback = flecs_metrics_on_member_metric,
-        .yield_existing = true,
-        .ctx = ctx
-    });
+    chunk->next = NULL;
+    return first_chunk;
+}
 
-    ecs_set_pair(world, metric, EcsMetricMember, member, { .ctx = ctx });
-    ecs_add_pair(world, metric, EcsMetric, desc->kind);
-    ecs_add_id(world, metric, EcsMetric);
+#endif
 
-    return 0;
-error:
-    return -1;
+void flecs_ballocator_init(
+    ecs_block_allocator_t *ba,
+    ecs_size_t size)
+{
+    ecs_assert(ba != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL);
+    ba->data_size = size;
+#ifdef FLECS_SANITIZE
+    size += ECS_SIZEOF(int64_t);
+#endif
+    ba->chunk_size = ECS_ALIGN(size, 16);
+    ba->chunks_per_block = ECS_MAX(4096 / ba->chunk_size, 1);
+    ba->block_size = ba->chunks_per_block * ba->chunk_size;
+    ba->head = NULL;
+    ba->block_head = NULL;
+    ba->block_tail = NULL;
 }
 
-/** Update id metric */
-static
-int flecs_id_metric_init(
-    ecs_world_t *world,
-    ecs_entity_t metric,
-    const ecs_metric_desc_t *desc)
+ecs_block_allocator_t* flecs_ballocator_new(
+    ecs_size_t size)
 {
-    ecs_id_metric_ctx_t *ctx = ecs_os_calloc_t(ecs_id_metric_ctx_t);
-    ctx->metric.metric = metric;
-    ctx->metric.kind = desc->kind;
-    ctx->idr = flecs_id_record_ensure(world, desc->id);
-    ecs_check(ctx->idr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_block_allocator_t *result = ecs_os_calloc_t(ecs_block_allocator_t);
+    flecs_ballocator_init(result, size);
+    return result;
+}
 
-    ecs_observer(world, {
-        .entity = metric,
-        .events = { EcsOnAdd },
-        .filter.terms[0] = {
-            .id = desc->id,
-            .src.flags = EcsSelf,
-            .inout = EcsInOutNone
-        },
-        .callback = flecs_metrics_on_id_metric,
-        .yield_existing = true,
-        .ctx = ctx
-    });
+void flecs_ballocator_fini(
+    ecs_block_allocator_t *ba)
+{
+    ecs_assert(ba != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_set(world, metric, EcsMetricId, { .ctx = ctx });
-    ecs_add_pair(world, metric, EcsMetric, desc->kind);
-    ecs_add_id(world, metric, EcsMetric);
+#ifdef FLECS_SANITIZE
+    ecs_assert(ba->alloc_count == 0, ECS_LEAK_DETECTED, 
+        "(size = %u)", (uint32_t)ba->data_size);
+#endif
 
-    return 0;
-error:
-    return -1;
+    ecs_block_allocator_block_t *block;
+    for (block = ba->block_head; block;) {
+        ecs_block_allocator_block_t *next = block->next;
+        ecs_os_free(block);
+        ecs_os_linc(&ecs_block_allocator_free_count);
+        block = next;
+    }
+
+    ba->block_head = NULL;
 }
 
-/** Update oneof metric */
-static
-int flecs_oneof_metric_init(
-    ecs_world_t *world,
-    ecs_entity_t metric,
-    ecs_entity_t scope,
-    const ecs_metric_desc_t *desc)
+void flecs_ballocator_free(
+    ecs_block_allocator_t *ba)
 {
-    ecs_oneof_metric_ctx_t *ctx = ecs_os_calloc_t(ecs_oneof_metric_ctx_t);
-    ctx->metric.metric = metric;
-    ctx->metric.kind = desc->kind;
-    ctx->idr = flecs_id_record_ensure(world, desc->id);
-    ecs_check(ctx->idr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_map_init(&ctx->target_offset, NULL);
+    flecs_ballocator_fini(ba);
+    ecs_os_free(ba);
+}
 
-    /* Add member for each child of oneof to metric, so it can be used as metric
-     * instance type that holds values for all targets */
-    ecs_iter_t it = ecs_children(world, scope);
-    uint64_t offset = 0;
-    while (ecs_children_next(&it)) {
-        int32_t i, count = it.count;
-        for (i = 0; i < count; i ++) {
-            ecs_entity_t tgt = it.entities[i];
-            const char *name = ecs_get_name(world, tgt);
-            if (!name) {
-                /* Member must have name */
-                continue;
-            }
-
-            char *to_snake_case = flecs_to_snake_case(name);
-
-            ecs_entity_t mbr = ecs_entity(world, {
-                .name = to_snake_case,
-                .add = { ecs_childof(metric) }
-            });
-
-            ecs_os_free(to_snake_case);
-
-            ecs_set(world, mbr, EcsMember, {
-                .type = ecs_id(ecs_f64_t),
-                .unit = EcsSeconds
-            });
+void* flecs_balloc(
+    ecs_block_allocator_t *ba) 
+{
+    void *result;
+#ifdef FLECS_USE_OS_ALLOC
+    result = ecs_os_malloc(ba->data_size);
+#else
 
-            /* Truncate upper 32 bits of target so we can lookup the offset
-             * with the id we get from the pair */
-            ecs_map_ensure(&ctx->target_offset, (uint32_t)tgt)[0] = offset;
+    if (!ba) return NULL;
 
-            offset += sizeof(double);
-        }
+    if (!ba->head) {
+        ba->head = flecs_balloc_block(ba);
     }
 
-    ctx->size = flecs_uto(ecs_size_t, offset);
+    result = ba->head;
+    ba->head = ba->head->next;
 
-    ecs_observer(world, {
-        .entity = metric,
-        .events = { EcsMonitor },
-        .filter.terms[0] = {
-            .id = desc->id,
-            .src.flags = EcsSelf,
-            .inout = EcsInOutNone
-        },
-        .callback = flecs_metrics_on_oneof_metric,
-        .yield_existing = true,
-        .ctx = ctx
-    });
+#ifdef FLECS_SANITIZE
+    ecs_assert(ba->alloc_count >= 0, ECS_INTERNAL_ERROR, "corrupted allocator");
+    ba->alloc_count ++;
+    *(int64_t*)result = ba->chunk_size;
+    result = ECS_OFFSET(result, ECS_SIZEOF(int64_t));
+#endif
+#endif
 
-    ecs_set(world, metric, EcsMetricOneOf, { .ctx = ctx });
-    ecs_add_pair(world, metric, EcsMetric, desc->kind);
-    ecs_add_id(world, metric, EcsMetric);
+#ifdef FLECS_MEMSET_UNINITIALIZED
+    ecs_os_memset(result, 0xAA, ba->data_size);
+#endif
 
-    return 0;
-error:
-    return -1;
+    return result;
 }
 
-static
-int flecs_count_id_targets_metric_init(
-    ecs_world_t *world,
-    ecs_entity_t metric,
-    const ecs_metric_desc_t *desc)
+void* flecs_bcalloc(
+    ecs_block_allocator_t *ba) 
 {
-    ecs_count_targets_metric_ctx_t *ctx = ecs_os_calloc_t(ecs_count_targets_metric_ctx_t);
-    ctx->metric.metric = metric;
-    ctx->metric.kind = desc->kind;
-    ctx->idr = flecs_id_record_ensure(world, desc->id);
-    ecs_check(ctx->idr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_map_init(&ctx->targets, NULL);
-
-    ecs_set(world, metric, EcsMetricCountTargets, { .ctx = ctx });
-    ecs_add_pair(world, metric, EcsMetric, desc->kind);
-    ecs_add_id(world, metric, EcsMetric); 
-
-    return 0;
-error:
-    return -1;
+#ifdef FLECS_USE_OS_ALLOC
+    return ecs_os_calloc(ba->data_size);
+#else
+    if (!ba) return NULL;
+    void *result = flecs_balloc(ba);
+    ecs_os_memset(result, 0, ba->data_size);
+    return result;
+#endif
 }
 
-static
-int flecs_count_ids_metric_init(
-    ecs_world_t *world,
-    ecs_entity_t metric,
-    const ecs_metric_desc_t *desc)
+void flecs_bfree(
+    ecs_block_allocator_t *ba, 
+    void *memory)
 {
-    ecs_set(world, metric, EcsMetricCountIds, { .id = desc->id });
-    ecs_set(world, metric, EcsMetricValue, { .value = 0 });
-    return 0;
+    flecs_bfree_w_dbg_info(ba, memory, NULL);
 }
 
-ecs_entity_t ecs_metric_init(
-    ecs_world_t *world,
-    const ecs_metric_desc_t *desc)
+FLECS_API
+void flecs_bfree_w_dbg_info(
+    ecs_block_allocator_t *ba, 
+    void *memory,
+    const char *type_name)
 {
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_poly_assert(world, ecs_world_t);
+    (void)type_name;
 
-    ecs_entity_t result = desc->entity;
-    if (!result) {
-        result = ecs_new_id(world);
-    }
+#ifdef FLECS_USE_OS_ALLOC
+    (void)ba;
+    ecs_os_free(memory);
+    return;
+#else
 
-    ecs_entity_t kind = desc->kind;
-    if (!kind) {
-        ecs_err("missing metric kind");
-        goto error;
+    if (!ba) {
+        ecs_assert(memory == NULL, ECS_INTERNAL_ERROR, NULL);
+        return;
     }
-
-    if (kind != EcsGauge && 
-        kind != EcsCounter && 
-        kind != EcsCounterId &&
-        kind != EcsCounterIncrement) 
-    {
-        ecs_err("invalid metric kind %s", ecs_get_fullpath(world, kind));
-        goto error;
+    if (memory == NULL) {
+        return;
     }
 
-    if (kind == EcsCounterIncrement && !desc->member && !desc->dotmember) {
-        ecs_err("CounterIncrement can only be used in combination with member");
-        goto error;
+#ifdef FLECS_SANITIZE
+    memory = ECS_OFFSET(memory, -ECS_SIZEOF(int64_t));
+    if (*(int64_t*)memory != ba->chunk_size) {
+        if (type_name) {
+            ecs_err("chunk %p returned to wrong allocator "
+                "(chunk = %ub, allocator = %ub, type = %s)",
+                    memory, *(int64_t*)memory, ba->chunk_size, type_name);
+        } else {
+            ecs_err("chunk %p returned to wrong allocator "
+                "(chunk = %ub, allocator = %ub)",
+                    memory, *(int64_t*)memory, ba->chunk_size);
+        }
+        ecs_abort(ECS_INTERNAL_ERROR, NULL);
     }
 
-    if (kind == EcsCounterId && (desc->member || desc->dotmember)) {
-        ecs_err("CounterId cannot be used in combination with member");
-        goto error;
-    }
+    ba->alloc_count --;
+#endif
 
-    if (desc->brief) {
-#ifdef FLECS_DOC
-        ecs_doc_set_brief(world, result, desc->brief);
+    ecs_block_allocator_chunk_header_t *chunk = memory;
+    chunk->next = ba->head;
+    ba->head = chunk;
+    ecs_assert(ba->alloc_count >= 0, ECS_INTERNAL_ERROR, "corrupted allocator");
+#endif
+}
+
+void* flecs_brealloc(
+    ecs_block_allocator_t *dst, 
+    ecs_block_allocator_t *src, 
+    void *memory)
+{
+    void *result;
+#ifdef FLECS_USE_OS_ALLOC
+    (void)src;
+    result = ecs_os_realloc(memory, dst->data_size);
 #else
-        ecs_warn("FLECS_DOC is not enabled, ignoring metrics brief");
-#endif        
+    if (dst == src) {
+        return memory;
     }
 
-    if (desc->member || desc->dotmember) {
-        if (flecs_member_metric_init(world, result, desc)) {
-            goto error;
+    result = flecs_balloc(dst);
+    if (result && src) {
+        ecs_size_t size = src->data_size;
+        if (dst->data_size < size) {
+            size = dst->data_size;
         }
-    } else if (desc->id) {
-        if (desc->targets) {
-            if (!ecs_id_is_pair(desc->id)) {
-                ecs_err("cannot specify targets for id that is not a pair");
-                goto error;
-            }
-            if (ECS_PAIR_FIRST(desc->id) == EcsWildcard) {
-                ecs_err("first element of pair cannot be wildcard with "
-                    " targets enabled");
-                goto error;
-            }
-            if (ECS_PAIR_SECOND(desc->id) != EcsWildcard) {
-                ecs_err("second element of pair must be wildcard with "
-                    " targets enabled");
-                goto error;
-            }
+        ecs_os_memcpy(result, memory, size);
+    }
+    flecs_bfree(src, memory);
+#endif
+#ifdef FLECS_MEMSET_UNINITIALIZED
+    if (dst && src && (dst->data_size > src->data_size)) {
+        ecs_os_memset(ECS_OFFSET(result, src->data_size), 0xAA, 
+            dst->data_size - src->data_size);
+    } else if (dst && !src) {
+        ecs_os_memset(result, 0xAA, dst->data_size);
+    }
+#endif
 
-            if (kind == EcsCounterId) {
-                if (flecs_count_id_targets_metric_init(world, result, desc)) {
-                    goto error;
-                }
-            } else {
-                ecs_entity_t first = ecs_pair_first(world, desc->id);
-                ecs_entity_t scope = flecs_get_oneof(world, first);
-                if (!scope) {
-                    ecs_err("first element of pair must have OneOf with "
-                        " targets enabled");
-                    goto error;
-                }
+    return result;
+}
 
-                if (flecs_oneof_metric_init(world, result, scope, desc)) {
-                    goto error;
-                }
-            }
-        } else {
-            if (kind == EcsCounterId) {
-                if (flecs_count_ids_metric_init(world, result, desc)) {
-                    goto error;
-                }
-            } else {
-                if (flecs_id_metric_init(world, result, desc)) {
-                    goto error;
-                }
-            }
-        }
+void* flecs_bdup(
+    ecs_block_allocator_t *ba, 
+    void *memory)
+{
+#ifdef FLECS_USE_OS_ALLOC
+    if (memory && ba->chunk_size) {
+        return ecs_os_memdup(memory, ba->data_size);
     } else {
-        ecs_err("missing source specified for metric");
-        goto error;
+        return NULL;
     }
-
-    return result;
-error:
-    if (result && result != desc->entity) {
-        ecs_delete(world, result);
+#else
+    void *result = flecs_balloc(ba);
+    if (result) {
+        ecs_os_memcpy(result, memory, ba->data_size);
     }
-    return 0;
+    return result;
+#endif
 }
 
-void FlecsMetricsImport(ecs_world_t *world) {
-    ECS_MODULE_DEFINE(world, FlecsMetrics);
-
-    ECS_IMPORT(world, FlecsPipeline);
-    ECS_IMPORT(world, FlecsMeta);
-    ECS_IMPORT(world, FlecsUnits);
-
-    ecs_set_name_prefix(world, "Ecs");
-    ECS_TAG_DEFINE(world, EcsMetric);
-    ecs_entity_t old_scope = ecs_set_scope(world, EcsMetric);
-    ECS_TAG_DEFINE(world, EcsCounter);
-    ECS_TAG_DEFINE(world, EcsCounterIncrement);
-    ECS_TAG_DEFINE(world, EcsCounterId);
-    ECS_TAG_DEFINE(world, EcsGauge);
-    ecs_set_scope(world, old_scope);
+// This is free and unencumbered software released into the public domain under The Unlicense (http://unlicense.org/)
+// main repo: https://github.com/wangyi-fudan/wyhash
+// author: 王一 Wang Yi
+// contributors: Reini Urban, Dietrich Epp, Joshua Haberman, Tommy Ettinger, 
+//               Daniel Lemire, Otmar Ertl, cocowalla, leo-yuriev, 
+//               Diego Barrios Romero, paulie-g, dumblob, Yann Collet, ivte-ms, 
+//               hyb, James Z.M. Gao, easyaspi314 (Devin), TheOneric
 
-    ecs_set_name_prefix(world, "EcsMetric");
-    ECS_TAG_DEFINE(world, EcsMetricInstance);
-    ECS_COMPONENT_DEFINE(world, EcsMetricValue);
-    ECS_COMPONENT_DEFINE(world, EcsMetricSource);
-    ECS_COMPONENT_DEFINE(world, EcsMetricMemberInstance);
-    ECS_COMPONENT_DEFINE(world, EcsMetricIdInstance);
-    ECS_COMPONENT_DEFINE(world, EcsMetricOneOfInstance);
-    ECS_COMPONENT_DEFINE(world, EcsMetricMember);
-    ECS_COMPONENT_DEFINE(world, EcsMetricId);
-    ECS_COMPONENT_DEFINE(world, EcsMetricOneOf);
-    ECS_COMPONENT_DEFINE(world, EcsMetricCountIds);
-    ECS_COMPONENT_DEFINE(world, EcsMetricCountTargets);
+/* quick example:
+   string s="fjsakfdsjkf";
+   uint64_t hash=wyhash(s.c_str(), s.size(), 0, wyp_);
+*/
 
-    ecs_add_id(world, ecs_id(EcsMetricMemberInstance), EcsPrivate);
-    ecs_add_id(world, ecs_id(EcsMetricIdInstance), EcsPrivate);
-    ecs_add_id(world, ecs_id(EcsMetricOneOfInstance), EcsPrivate);
 
-    ecs_struct(world, {
-        .entity = ecs_id(EcsMetricValue),
-        .members = {
-            { .name = "value", .type = ecs_id(ecs_f64_t) }
-        }
-    });
+#ifndef WYHASH_CONDOM
+//protections that produce different results:
+//1: normal valid behavior
+//2: extra protection against entropy loss (probability=2^-63), aka. "blind multiplication"
+#define WYHASH_CONDOM 1
+#endif
 
-    ecs_struct(world, {
-        .entity = ecs_id(EcsMetricSource),
-        .members = {
-            { .name = "entity", .type = ecs_id(ecs_entity_t) }
-        }
-    });
+#ifndef WYHASH_32BIT_MUM
+//0: normal version, slow on 32 bit systems
+//1: faster on 32 bit systems but produces different results, incompatible with wy2u0k function
+#define WYHASH_32BIT_MUM 0  
+#endif
 
-    ecs_set_hooks(world, EcsMetricMember, {
-        .ctor = ecs_default_ctor,
-        .dtor = ecs_dtor(EcsMetricMember),
-        .move = ecs_move(EcsMetricMember)
-    });
+//includes
+#include <stdint.h>
+#include <string.h>
+#if defined(_MSC_VER) && defined(_M_X64)
+  #include <intrin.h>
+  #pragma intrinsic(_umul128)
+#endif
 
-    ecs_set_hooks(world, EcsMetricId, {
-        .ctor = ecs_default_ctor,
-        .dtor = ecs_dtor(EcsMetricId),
-        .move = ecs_move(EcsMetricId)
-    });
+//likely and unlikely macros
+#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
+  #define likely_(x)  __builtin_expect(x,1)
+  #define unlikely_(x)  __builtin_expect(x,0)
+#else
+  #define likely_(x) (x)
+  #define unlikely_(x) (x)
+#endif
 
-    ecs_set_hooks(world, EcsMetricOneOf, {
-        .ctor = ecs_default_ctor,
-        .dtor = ecs_dtor(EcsMetricOneOf),
-        .move = ecs_move(EcsMetricOneOf)
-    });
+//128bit multiply function
+static inline void wymum_(uint64_t *A, uint64_t *B){
+#if(WYHASH_32BIT_MUM)
+  uint64_t hh=(*A>>32)*(*B>>32), hl=(*A>>32)*(uint32_t)*B, lh=(uint32_t)*A*(*B>>32), ll=(uint64_t)(uint32_t)*A*(uint32_t)*B;
+  #if(WYHASH_CONDOM>1)
+  *A^=_wyrot(hl)^hh; *B^=_wyrot(lh)^ll;
+  #else
+  *A=_wyrot(hl)^hh; *B=_wyrot(lh)^ll;
+  #endif
+#elif defined(__SIZEOF_INT128__)
+  __uint128_t r=*A; r*=*B; 
+  #if(WYHASH_CONDOM>1)
+  *A^=(uint64_t)r; *B^=(uint64_t)(r>>64);
+  #else
+  *A=(uint64_t)r; *B=(uint64_t)(r>>64);
+  #endif
+#elif defined(_MSC_VER) && defined(_M_X64)
+  #if(WYHASH_CONDOM>1)
+  uint64_t  a,  b;
+  a=_umul128(*A,*B,&b);
+  *A^=a;  *B^=b;
+  #else
+  *A=_umul128(*A,*B,B);
+  #endif
+#else
+  uint64_t ha=*A>>32, hb=*B>>32, la=(uint32_t)*A, lb=(uint32_t)*B, hi, lo;
+  uint64_t rh=ha*hb, rm0=ha*lb, rm1=hb*la, rl=la*lb, t=rl+(rm0<<32), c=t<rl;
+  lo=t+(rm1<<32); c+=lo<t; hi=rh+(rm0>>32)+(rm1>>32)+c;
+  #if(WYHASH_CONDOM>1)
+  *A^=lo;  *B^=hi;
+  #else
+  *A=lo;  *B=hi;
+  #endif
+#endif
+}
 
-    ecs_set_hooks(world, EcsMetricCountTargets, {
-        .ctor = ecs_default_ctor,
-        .dtor = ecs_dtor(EcsMetricCountTargets),
-        .move = ecs_move(EcsMetricCountTargets)
-    });
+//multiply and xor mix function, aka MUM
+static inline uint64_t wymix_(uint64_t A, uint64_t B){ wymum_(&A,&B); return A^B; }
 
-    ecs_add_id(world, EcsMetric, EcsOneOf);
+//endian macros
+#ifndef WYHASH_LITTLE_ENDIAN
+  #if defined(_WIN32) || defined(__LITTLE_ENDIAN__) || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+    #define WYHASH_LITTLE_ENDIAN 1
+  #elif defined(__BIG_ENDIAN__) || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+    #define WYHASH_LITTLE_ENDIAN 0
+  #else
+    #warning could not determine endianness! Falling back to little endian.
+    #define WYHASH_LITTLE_ENDIAN 1
+  #endif
+#endif
 
-#ifdef FLECS_DOC
-    ECS_OBSERVER(world, SetMetricDocName, EcsOnSet, EcsMetricSource);
+//read functions
+#if (WYHASH_LITTLE_ENDIAN)
+static inline uint64_t wyr8_(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return v;}
+static inline uint64_t wyr4_(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return v;}
+#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
+static inline uint64_t wyr8_(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return __builtin_bswap64(v);}
+static inline uint64_t wyr4_(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return __builtin_bswap32(v);}
+#elif defined(_MSC_VER)
+static inline uint64_t wyr8_(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return _byteswap_uint64(v);}
+static inline uint64_t wyr4_(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return _byteswap_ulong(v);}
+#else
+static inline uint64_t wyr8_(const uint8_t *p) {
+  uint64_t v; memcpy(&v, p, 8);
+  return (((v >> 56) & 0xff)| ((v >> 40) & 0xff00)| ((v >> 24) & 0xff0000)| ((v >>  8) & 0xff000000)| ((v <<  8) & 0xff00000000)| ((v << 24) & 0xff0000000000)| ((v << 40) & 0xff000000000000)| ((v << 56) & 0xff00000000000000));
+}
+static inline uint64_t wyr4_(const uint8_t *p) {
+  uint32_t v; memcpy(&v, p, 4);
+  return (((v >> 24) & 0xff)| ((v >>  8) & 0xff00)| ((v <<  8) & 0xff0000)| ((v << 24) & 0xff000000));
+}
 #endif
+static inline uint64_t wyr3_(const uint8_t *p, size_t k) { return (((uint64_t)p[0])<<16)|(((uint64_t)p[k>>1])<<8)|p[k-1];}
 
-    ECS_SYSTEM(world, ClearMetricInstance, EcsPreStore,
-        [in] Source);
+//wyhash main function
+static inline uint64_t wyhash(const void *key, size_t len, uint64_t seed, const uint64_t *secret){
+  const uint8_t *p=(const uint8_t *)key; seed^=wymix_(seed^secret[0],secret[1]);	uint64_t	a,	b;
+  if(likely_(len<=16)){
+    if(likely_(len>=4)){ a=(wyr4_(p)<<32)|wyr4_(p+((len>>3)<<2)); b=(wyr4_(p+len-4)<<32)|wyr4_(p+len-4-((len>>3)<<2)); }
+    else if(likely_(len>0)){ a=wyr3_(p,len); b=0;}
+    else a=b=0;
+  }
+  else{
+    size_t i=len; 
+    if(unlikely_(i>48)){
+      uint64_t see1=seed, see2=seed;
+      do{
+        seed=wymix_(wyr8_(p)^secret[1],wyr8_(p+8)^seed);
+        see1=wymix_(wyr8_(p+16)^secret[2],wyr8_(p+24)^see1);
+        see2=wymix_(wyr8_(p+32)^secret[3],wyr8_(p+40)^see2);
+        p+=48; i-=48;
+      }while(likely_(i>48));
+      seed^=see1^see2;
+    }
+    while(unlikely_(i>16)){  seed=wymix_(wyr8_(p)^secret[1],wyr8_(p+8)^seed);  i-=16; p+=16;  }
+    a=wyr8_(p+i-16);  b=wyr8_(p+i-8);
+  }
+  a^=secret[1]; b^=seed;  wymum_(&a,&b);
+  return  wymix_(a^secret[0]^len,b^secret[1]);
+}
 
-    ECS_SYSTEM(world, UpdateGaugeMemberInstance, EcsPreStore, 
-        [out]  Value, 
-        [in]   MemberInstance,
-        [none] (Metric, Gauge));
+//the default secret parameters
+static const uint64_t wyp_[4] = {0xa0761d6478bd642full, 0xe7037ed1a0b428dbull, 0x8ebc6af09c88c6e3ull, 0x589965cc75374cc3ull};
 
-    ECS_SYSTEM(world, UpdateCounterMemberInstance, EcsPreStore, 
-        [out]  Value, 
-        [in]   MemberInstance,
-        [none] (Metric, Counter));
+uint64_t flecs_hash(
+    const void *data,
+    ecs_size_t length)
+{
+    return wyhash(data, flecs_ito(size_t, length), 0, wyp_);
+}
 
-    ECS_SYSTEM(world, UpdateCounterIncrementMemberInstance, EcsPreStore, 
-        [out]  Value, 
-        [in]   MemberInstance,
-        [none] (Metric, CounterIncrement));
+/**
+ * @file datastructures/hashmap.c
+ * @brief Hashmap data structure.
+ * 
+ * The hashmap data structure is built on top of the map data structure. Where 
+ * the map data structure can only work with 64bit key values, the hashmap can
+ * hash keys of any size, and handles collisions between hashes.
+ */
 
-    ECS_SYSTEM(world, UpdateGaugeIdInstance, EcsPreStore, 
-        [out]  Value, 
-        [in]   IdInstance,
-        [none] (Metric, Gauge));
 
-    ECS_SYSTEM(world, UpdateCounterIdInstance, EcsPreStore, 
-        [inout] Value, 
-        [in]    IdInstance,
-        [none]  (Metric, Counter));
+static
+int32_t flecs_hashmap_find_key(
+    const ecs_hashmap_t *map,
+    ecs_vec_t *keys,
+    ecs_size_t key_size, 
+    const void *key)
+{
+    int32_t i, count = ecs_vec_count(keys);
+    void *key_array = ecs_vec_first(keys);
+    for (i = 0; i < count; i ++) {
+        void *key_ptr = ECS_OFFSET(key_array, key_size * i);
+        if (map->compare(key_ptr, key) == 0) {
+            return i;
+        }
+    }
+    return -1;
+}
 
-    ECS_SYSTEM(world, UpdateGaugeOneOfInstance, EcsPreStore, 
-        [none] (_, Value), 
-        [in]   OneOfInstance,
-        [none] (Metric, Gauge));
-
-    ECS_SYSTEM(world, UpdateCounterOneOfInstance, EcsPreStore, 
-        [none] (_, Value), 
-        [in]   OneOfInstance,
-        [none] (Metric, Counter));
-
-    ECS_SYSTEM(world, UpdateCountIds, EcsPreStore, 
-        [inout] CountIds, Value);
-
-    ECS_SYSTEM(world, UpdateCountTargets, EcsPreStore, 
-        [inout] CountTargets);
+void flecs_hashmap_init_(
+    ecs_hashmap_t *map,
+    ecs_size_t key_size,
+    ecs_size_t value_size,
+    ecs_hash_value_action_t hash,
+    ecs_compare_action_t compare,
+    ecs_allocator_t *allocator)
+{
+    map->key_size = key_size;
+    map->value_size = value_size;
+    map->hash = hash;
+    map->compare = compare;
+    flecs_ballocator_init_t(&map->bucket_allocator, ecs_hm_bucket_t);
+    ecs_map_init(&map->impl, allocator);
 }
 
-#endif
-
-/**
- * @file addons/module.c
- * @brief Module addon.
- */
-
-
-#ifdef FLECS_MODULE
-
-#include <ctype.h>
-
-char* ecs_module_path_from_c(
-    const char *c_name)
+void flecs_hashmap_fini(
+    ecs_hashmap_t *map)
 {
-    ecs_strbuf_t str = ECS_STRBUF_INIT;
-    const char *ptr;
-    char ch;
-
-    for (ptr = c_name; (ch = *ptr); ptr++) {
-        if (isupper(ch)) {
-            ch = flecs_ito(char, tolower(ch));
-            if (ptr != c_name) {
-                ecs_strbuf_appendstrn(&str, ".", 1);
-            }
-        }
+    ecs_allocator_t *a = map->impl.allocator;
+    ecs_map_iter_t it = ecs_map_iter(&map->impl);
 
-        ecs_strbuf_appendstrn(&str, &ch, 1);
+    while (ecs_map_next(&it)) {
+        ecs_hm_bucket_t *bucket = ecs_map_ptr(&it);
+        ecs_vec_fini(a, &bucket->keys, map->key_size);
+        ecs_vec_fini(a, &bucket->values, map->value_size);
+#ifdef FLECS_SANITIZE        
+        flecs_bfree(&map->bucket_allocator, bucket);
+#endif
     }
 
-    return ecs_strbuf_get(&str);
+    flecs_ballocator_fini(&map->bucket_allocator);
+    ecs_map_fini(&map->impl);
 }
 
-ecs_entity_t ecs_import(
-    ecs_world_t *world,
-    ecs_module_action_t module,
-    const char *module_name)
+void flecs_hashmap_copy(
+    ecs_hashmap_t *dst,
+    const ecs_hashmap_t *src)
 {
-    ecs_check(!(world->flags & EcsWorldReadonly), 
-        ECS_INVALID_WHILE_READONLY, NULL);
-
-    ecs_entity_t old_scope = ecs_set_scope(world, 0);
-    const char *old_name_prefix = world->info.name_prefix;
-
-    char *path = ecs_module_path_from_c(module_name);
-    ecs_entity_t e = ecs_lookup(world, path);
-    ecs_os_free(path);
-    
-    if (!e) {
-        ecs_trace("#[magenta]import#[reset] %s", module_name);
-        ecs_log_push();
-
-        /* Load module */
-        module(world);
+    ecs_assert(dst != src, ECS_INVALID_PARAMETER, NULL);
 
-        /* Lookup module entity (must be registered by module) */
-        e = ecs_lookup(world, module_name);
-        ecs_check(e != 0, ECS_MODULE_UNDEFINED, module_name);
+    flecs_hashmap_init_(dst, src->key_size, src->value_size, src->hash, 
+        src->compare, src->impl.allocator);
+    ecs_map_copy(&dst->impl, &src->impl);
 
-        ecs_log_pop();
+    ecs_allocator_t *a = dst->impl.allocator;
+    ecs_map_iter_t it = ecs_map_iter(&dst->impl);
+    while (ecs_map_next(&it)) {
+        ecs_hm_bucket_t **bucket_ptr = ecs_map_ref(&it, ecs_hm_bucket_t);
+        ecs_hm_bucket_t *src_bucket = bucket_ptr[0];
+        ecs_hm_bucket_t *dst_bucket = flecs_balloc(&dst->bucket_allocator);
+        bucket_ptr[0] = dst_bucket;
+        dst_bucket->keys = ecs_vec_copy(a, &src_bucket->keys, dst->key_size);
+        dst_bucket->values = ecs_vec_copy(a, &src_bucket->values, dst->value_size);
     }
-
-    /* Restore to previous state */
-    ecs_set_scope(world, old_scope);
-    world->info.name_prefix = old_name_prefix;
-
-    return e;
-error:
-    return 0;
-}
-
-ecs_entity_t ecs_import_c(
-    ecs_world_t *world,
-    ecs_module_action_t module,
-    const char *c_name)
-{
-    char *name = ecs_module_path_from_c(c_name);
-    ecs_entity_t e = ecs_import(world, module, name);
-    ecs_os_free(name);
-    return e;
 }
 
-ecs_entity_t ecs_import_from_library(
-    ecs_world_t *world,
-    const char *library_name,
-    const char *module_name)
+void* flecs_hashmap_get_(
+    const ecs_hashmap_t *map,
+    ecs_size_t key_size,
+    const void *key,
+    ecs_size_t value_size)
 {
-    ecs_check(library_name != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    char *import_func = ECS_CONST_CAST(char*, module_name);
-    char *module = ECS_CONST_CAST(char*, module_name);
+    ecs_assert(map->key_size == key_size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(map->value_size == value_size, ECS_INVALID_PARAMETER, NULL);
 
-    if (!ecs_os_has_modules() || !ecs_os_has_dl()) {
-        ecs_err(
-            "library loading not supported, set module_to_dl, dlopen, dlclose "
-            "and dlproc os API callbacks first");
-        return 0;
+    uint64_t hash = map->hash(key);
+    ecs_hm_bucket_t *bucket = ecs_map_get_deref(&map->impl, 
+        ecs_hm_bucket_t, hash);
+    if (!bucket) {
+        return NULL;
     }
 
-    /* If no module name is specified, try default naming convention for loading
-     * the main module from the library */
-    if (!import_func) {
-        import_func = ecs_os_malloc(ecs_os_strlen(library_name) + ECS_SIZEOF("Import"));
-        ecs_assert(import_func != NULL, ECS_OUT_OF_MEMORY, NULL);
-        
-        const char *ptr;
-        char ch, *bptr = import_func;
-        bool capitalize = true;
-        for (ptr = library_name; (ch = *ptr); ptr ++) {
-            if (ch == '.') {
-                capitalize = true;
-            } else {
-                if (capitalize) {
-                    *bptr = flecs_ito(char, toupper(ch));
-                    bptr ++;
-                    capitalize = false;
-                } else {
-                    *bptr = flecs_ito(char, tolower(ch));
-                    bptr ++;
-                }
-            }
-        }
+    int32_t index = flecs_hashmap_find_key(map, &bucket->keys, key_size, key);
+    if (index == -1) {
+        return NULL;
+    }
 
-        *bptr = '\0';
+    return ecs_vec_get(&bucket->values, value_size, index);
+}
 
-        module = ecs_os_strdup(import_func);
-        ecs_assert(module != NULL, ECS_OUT_OF_MEMORY, NULL);
+flecs_hashmap_result_t flecs_hashmap_ensure_(
+    ecs_hashmap_t *map,
+    ecs_size_t key_size,
+    const void *key,
+    ecs_size_t value_size)
+{
+    ecs_assert(map->key_size == key_size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(map->value_size == value_size, ECS_INVALID_PARAMETER, NULL);
 
-        ecs_os_strcat(bptr, "Import");
+    uint64_t hash = map->hash(key);
+    ecs_hm_bucket_t **r = ecs_map_ensure_ref(&map->impl, ecs_hm_bucket_t, hash);
+    ecs_hm_bucket_t *bucket = r[0];
+    if (!bucket) {
+        bucket = r[0] = flecs_bcalloc(&map->bucket_allocator);
     }
 
-    char *library_filename = ecs_os_module_to_dl(library_name);
-    if (!library_filename) {
-        ecs_err("failed to find library file for '%s'", library_name);
-        if (module != module_name) {
-            ecs_os_free(module);
-        }
-        return 0;
+    ecs_allocator_t *a = map->impl.allocator;
+    void *value_ptr, *key_ptr;
+    ecs_vec_t *keys = &bucket->keys;
+    ecs_vec_t *values = &bucket->values;
+    if (!keys->array) {
+        keys = ecs_vec_init(a, &bucket->keys, key_size, 1);
+        values = ecs_vec_init(a, &bucket->values, value_size, 1);
+        key_ptr = ecs_vec_append(a, keys, key_size);        
+        value_ptr = ecs_vec_append(a, values, value_size);
+        ecs_os_memcpy(key_ptr, key, key_size);
+        ecs_os_memset(value_ptr, 0, value_size);
     } else {
-        ecs_trace("found file '%s' for library '%s'", 
-            library_filename, library_name);
+        int32_t index = flecs_hashmap_find_key(map, keys, key_size, key);
+        if (index == -1) {
+            key_ptr = ecs_vec_append(a, keys, key_size);        
+            value_ptr = ecs_vec_append(a, values, value_size);
+            ecs_os_memcpy(key_ptr, key, key_size);
+            ecs_os_memset(value_ptr, 0, value_size);
+        } else {
+            key_ptr = ecs_vec_get(keys, key_size, index);
+            value_ptr = ecs_vec_get(values, value_size, index);
+        }
     }
 
-    ecs_os_dl_t dl = ecs_os_dlopen(library_filename);
-    if (!dl) {
-        ecs_err("failed to load library '%s' ('%s')", 
-            library_name, library_filename);
-        
-        ecs_os_free(library_filename);
+    return (flecs_hashmap_result_t){
+        .key = key_ptr, .value = value_ptr, .hash = hash
+    };
+}
 
-        if (module != module_name) {
-            ecs_os_free(module);
-        }    
+void flecs_hashmap_set_(
+    ecs_hashmap_t *map,
+    ecs_size_t key_size,
+    void *key,
+    ecs_size_t value_size,
+    const void *value)
+{
+    void *value_ptr = flecs_hashmap_ensure_(map, key_size, key, value_size).value;
+    ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_os_memcpy(value_ptr, value, value_size);
+}
 
-        return 0;
-    } else {
-        ecs_trace("library '%s' ('%s') loaded", 
-            library_name, library_filename);
-    }
+ecs_hm_bucket_t* flecs_hashmap_get_bucket(
+    const ecs_hashmap_t *map,
+    uint64_t hash)
+{
+    ecs_assert(map != NULL, ECS_INTERNAL_ERROR, NULL);
+    return ecs_map_get_deref(&map->impl, ecs_hm_bucket_t, hash);
+}
 
-    ecs_module_action_t action = (ecs_module_action_t)
-        ecs_os_dlproc(dl, import_func);
-    if (!action) {
-        ecs_err("failed to load import function %s from library %s",
-            import_func, library_name);
-        ecs_os_free(library_filename);
-        ecs_os_dlclose(dl);            
-        return 0;
-    } else {
-        ecs_trace("found import function '%s' in library '%s' for module '%s'",
-            import_func, library_name, module);
+void flecs_hm_bucket_remove(
+    ecs_hashmap_t *map,
+    ecs_hm_bucket_t *bucket,
+    uint64_t hash,
+    int32_t index)
+{
+    ecs_vec_remove(&bucket->keys, map->key_size, index);
+    ecs_vec_remove(&bucket->values, map->value_size, index);
+
+    if (!ecs_vec_count(&bucket->keys)) {
+        ecs_allocator_t *a = map->impl.allocator;
+        ecs_vec_fini(a, &bucket->keys, map->key_size);
+        ecs_vec_fini(a, &bucket->values, map->value_size);
+        ecs_hm_bucket_t *b = ecs_map_remove_ptr(&map->impl, hash);
+        ecs_assert(bucket == b, ECS_INTERNAL_ERROR, NULL); (void)b;
+        flecs_bfree(&map->bucket_allocator, bucket);
     }
+}
 
-    /* Do not free id, as it will be stored as the component identifier */
-    ecs_entity_t result = ecs_import(world, action, module);
+void flecs_hashmap_remove_w_hash_(
+    ecs_hashmap_t *map,
+    ecs_size_t key_size,
+    const void *key,
+    ecs_size_t value_size,
+    uint64_t hash)
+{
+    ecs_assert(map->key_size == key_size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(map->value_size == value_size, ECS_INVALID_PARAMETER, NULL);
+    (void)value_size;
 
-    if (import_func != module_name) {
-        ecs_os_free(import_func);
+    ecs_hm_bucket_t *bucket = ecs_map_get_deref(&map->impl, 
+        ecs_hm_bucket_t, hash);
+    if (!bucket) {
+        return;
     }
 
-    if (module != module_name) {
-        ecs_os_free(module);
+    int32_t index = flecs_hashmap_find_key(map, &bucket->keys, key_size, key);
+    if (index == -1) {
+        return;
     }
 
-    ecs_os_free(library_filename);
-
-    return result;
-error:
-    return 0;
+    flecs_hm_bucket_remove(map, bucket, hash, index);
 }
 
-ecs_entity_t ecs_module_init(
-    ecs_world_t *world,
-    const char *c_name,
-    const ecs_component_desc_t *desc)
+void flecs_hashmap_remove_(
+    ecs_hashmap_t *map,
+    ecs_size_t key_size,
+    const void *key,
+    ecs_size_t value_size)
 {
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_poly_assert(world, ecs_world_t);
-
-    ecs_entity_t old_scope = ecs_set_scope(world, 0);
+    ecs_assert(map->key_size == key_size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(map->value_size == value_size, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_entity_t e = desc->entity;
-    if (!e) {
-        char *module_path = ecs_module_path_from_c(c_name);
-        e = ecs_new_from_fullpath(world, module_path);
-        ecs_set_symbol(world, e, module_path);
-        ecs_os_free(module_path);
-    } else if (!ecs_exists(world, e)) {
-        char *module_path = ecs_module_path_from_c(c_name);
-        ecs_make_alive(world, e);
-        ecs_add_fullpath(world, e, module_path);
-        ecs_set_symbol(world, e, module_path);
-        ecs_os_free(module_path);
-    }
-    
-    ecs_add_id(world, e, EcsModule);
+    uint64_t hash = map->hash(key);
+    flecs_hashmap_remove_w_hash_(map, key_size, key, value_size, hash);
+}
 
-    ecs_component_desc_t private_desc = *desc;
-    private_desc.entity = e;
+flecs_hashmap_iter_t flecs_hashmap_iter(
+    ecs_hashmap_t *map)
+{
+    return (flecs_hashmap_iter_t){
+        .it = ecs_map_iter(&map->impl)
+    };
+}
 
-    if (desc->type.size) {
-        ecs_entity_t result = ecs_component_init(world, &private_desc);
-        ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(result == e, ECS_INTERNAL_ERROR, NULL);
-        (void)result;
+void* flecs_hashmap_next_(
+    flecs_hashmap_iter_t *it,
+    ecs_size_t key_size,
+    void *key_out,
+    ecs_size_t value_size)
+{
+    int32_t index = ++ it->index;
+    ecs_hm_bucket_t *bucket = it->bucket;
+    while (!bucket || it->index >= ecs_vec_count(&bucket->keys)) {
+        ecs_map_next(&it->it);
+        bucket = it->bucket = ecs_map_ptr(&it->it);
+        if (!bucket) {
+            return NULL;
+        }
+        index = it->index = 0;
     }
 
-    ecs_set_scope(world, old_scope);
-
-    return e;
-error:
-    return 0;
+    if (key_out) {
+        *(void**)key_out = ecs_vec_get(&bucket->keys, key_size, index);
+    }
+    
+    return ecs_vec_get(&bucket->values, value_size, index);
 }
 
-#endif
-
 /**
- * @file addons/monitor.c
- * @brief Monitor addon.
+ * @file datastructures/map.c
+ * @brief Map data structure.
+ * 
+ * Map data structure for 64bit keys and dynamic payload size.
  */
 
 
-#ifdef FLECS_MONITOR
-
-ECS_COMPONENT_DECLARE(FlecsMonitor);
-ECS_COMPONENT_DECLARE(EcsWorldStats);
-ECS_COMPONENT_DECLARE(EcsWorldSummary);
-ECS_COMPONENT_DECLARE(EcsPipelineStats);
+/* The ratio used to determine whether the map should flecs_map_rehash. If
+ * (element_count * ECS_LOAD_FACTOR) > bucket_count, bucket count is increased. */
+#define ECS_LOAD_FACTOR (12)
+#define ECS_BUCKET_END(b, c) ECS_ELEM_T(b, ecs_bucket_t, c)
 
-ecs_entity_t EcsPeriod1s = 0;
-ecs_entity_t EcsPeriod1m = 0;
-ecs_entity_t EcsPeriod1h = 0;
-ecs_entity_t EcsPeriod1d = 0;
-ecs_entity_t EcsPeriod1w = 0;
+static
+uint8_t flecs_log2(uint32_t v) {
+    static const uint8_t log2table[32] = 
+        {0, 9,  1,  10, 13, 21, 2,  29, 11, 14, 16, 18, 22, 25, 3, 30,
+         8, 12, 20, 28, 15, 17, 24, 7,  19, 27, 23, 6,  26, 5,  4, 31};
 
-static int32_t flecs_day_interval_count = 24;
-static int32_t flecs_week_interval_count = 168;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    return log2table[(uint32_t)(v * 0x07C4ACDDU) >> 27];
+}
 
+/* Get bucket count for number of elements */
 static
-ECS_COPY(EcsPipelineStats, dst, src, {
-    (void)dst;
-    (void)src;
-    ecs_abort(ECS_INVALID_OPERATION, "cannot copy pipeline stats component");
-})
+int32_t flecs_map_get_bucket_count(
+    int32_t count)
+{
+    return flecs_next_pow_of_2((int32_t)(count * ECS_LOAD_FACTOR * 0.1));
+}
 
+/* Get bucket shift amount for a given bucket count */
 static
-ECS_MOVE(EcsPipelineStats, dst, src, {
-    ecs_os_memcpy_t(dst, src, EcsPipelineStats);
-    ecs_os_zeromem(src);
-})
+uint8_t flecs_map_get_bucket_shift (
+    int32_t bucket_count)
+{
+    return (uint8_t)(64u - flecs_log2((uint32_t)bucket_count));
+}
 
+/* Get bucket index for provided map key */
 static
-ECS_DTOR(EcsPipelineStats, ptr, {
-    ecs_pipeline_stats_fini(&ptr->stats);
-})
+int32_t flecs_map_get_bucket_index(
+    uint16_t bucket_shift,
+    ecs_map_key_t key) 
+{
+    ecs_assert(bucket_shift != 0, ECS_INTERNAL_ERROR, NULL);
+    return (int32_t)((11400714819323198485ull * key) >> bucket_shift);
+}
 
+/* Get bucket for key */
 static
-void UpdateWorldSummary(ecs_iter_t *it) {
-    EcsWorldSummary *summary = ecs_field(it, EcsWorldSummary, 1);
-
-    const ecs_world_info_t *info = ecs_get_world_info(it->world);
-
-    int32_t i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        summary[i].target_fps = (double)info->target_fps;
-
-        summary[i].frame_time_last = (double)info->frame_time_total - summary[i].frame_time_total;
-        summary[i].system_time_last = (double)info->system_time_total - summary[i].system_time_total;
-        summary[i].merge_time_last = (double)info->merge_time_total - summary[i].merge_time_total;
-
-        summary[i].frame_time_total = (double)info->frame_time_total;
-        summary[i].system_time_total = (double)info->system_time_total;
-        summary[i].merge_time_total = (double)info->merge_time_total;
-
-        summary[i].frame_count ++;
-        summary[i].command_count +=
-            info->cmd.add_count +
-            info->cmd.remove_count +
-            info->cmd.delete_count +
-            info->cmd.clear_count +
-            info->cmd.set_count +
-            info->cmd.ensure_count +
-            info->cmd.modified_count +
-            info->cmd.discard_count +
-            info->cmd.event_count +
-            info->cmd.other_count;
-
-        summary[i].build_info = *ecs_get_build_info();
-    }
+ecs_bucket_t* flecs_map_get_bucket(
+    const ecs_map_t *map,
+    ecs_map_key_t key)
+{
+    ecs_assert(map != NULL, ECS_INVALID_PARAMETER, NULL);
+    int32_t bucket_id = flecs_map_get_bucket_index(map->bucket_shift, key);
+    ecs_assert(bucket_id < map->bucket_count, ECS_INTERNAL_ERROR, NULL);
+    return &map->buckets[bucket_id];
 }
 
+/* Add element to bucket */
 static
-void MonitorStats(ecs_iter_t *it) {
-    ecs_world_t *world = it->real_world;
-
-    EcsStatsHeader *hdr = ecs_field_w_size(it, 0, 1);
-    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 1));
-    void *stats = ECS_OFFSET_T(hdr, EcsStatsHeader);
+ecs_map_val_t* flecs_map_bucket_add(
+    ecs_block_allocator_t *allocator,
+    ecs_bucket_t *bucket,
+    ecs_map_key_t key)
+{
+    ecs_bucket_entry_t *new_entry = flecs_balloc(allocator);
+    new_entry->key = key;
+    new_entry->next = bucket->first;
+    bucket->first = new_entry;
+    return &new_entry->value;
+}
 
-    ecs_ftime_t elapsed = hdr->elapsed;
-    hdr->elapsed += it->delta_time;
-
-    int32_t t_last = (int32_t)(elapsed * 60);
-    int32_t t_next = (int32_t)(hdr->elapsed * 60);
-    int32_t i, dif = t_last - t_next;
-
-    ecs_world_stats_t last_world = {0};
-    ecs_pipeline_stats_t last_pipeline = {0};
-    void *last = NULL;
-
-    if (!dif) {
-        /* Copy last value so we can pass it to reduce_last */
-        if (kind == ecs_id(EcsWorldStats)) {
-            last = &last_world;
-            ecs_world_stats_copy_last(&last_world, stats);
-        } else if (kind == ecs_id(EcsPipelineStats)) {
-            last = &last_pipeline;
-            ecs_pipeline_stats_copy_last(&last_pipeline, stats);
-        }
-    }
-
-    if (kind == ecs_id(EcsWorldStats)) {
-        ecs_world_stats_get(world, stats);
-    } else if (kind == ecs_id(EcsPipelineStats)) {
-        ecs_pipeline_stats_get(world, ecs_get_pipeline(world), stats);
-    }
-
-    if (!dif) {
-        /* Still in same interval, combine with last measurement */
-        hdr->reduce_count ++;
-        if (kind == ecs_id(EcsWorldStats)) {
-            ecs_world_stats_reduce_last(stats, last, hdr->reduce_count);
-        } else if (kind == ecs_id(EcsPipelineStats)) {
-            ecs_pipeline_stats_reduce_last(stats, last, hdr->reduce_count);
-        }
-    } else if (dif > 1) {
-        /* More than 16ms has passed, backfill */
-        for (i = 1; i < dif; i ++) {
-            if (kind == ecs_id(EcsWorldStats)) {
-                ecs_world_stats_repeat_last(stats);
-            } else if (kind == ecs_id(EcsPipelineStats)) {
-                ecs_world_stats_repeat_last(stats);
+/* Remove element from bucket */
+static
+ecs_map_val_t flecs_map_bucket_remove(
+    ecs_map_t *map,
+    ecs_bucket_t *bucket,
+    ecs_map_key_t key)
+{
+    ecs_bucket_entry_t *entry;
+    for (entry = bucket->first; entry; entry = entry->next) {
+        if (entry->key == key) {
+            ecs_map_val_t value = entry->value;
+            ecs_bucket_entry_t **next_holder = &bucket->first;
+            while(*next_holder != entry) {
+                next_holder = &(*next_holder)->next;
             }
+            *next_holder = entry->next;
+            flecs_bfree(map->entry_allocator, entry);
+            map->count --;
+            return value;
         }
-        hdr->reduce_count = 0;
-    }
-
-    if (last && kind == ecs_id(EcsPipelineStats)) {
-        ecs_pipeline_stats_fini(last);
     }
+    
+    return 0;
 }
 
+/* Free contents of bucket */
 static
-void ReduceStats(ecs_iter_t *it) {
-    void *dst = ecs_field_w_size(it, 0, 1);
-    void *src = ecs_field_w_size(it, 0, 2);
-
-    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 1));
-
-    dst = ECS_OFFSET_T(dst, EcsStatsHeader);
-    src = ECS_OFFSET_T(src, EcsStatsHeader);
-
-    if (kind == ecs_id(EcsWorldStats)) {
-        ecs_world_stats_reduce(dst, src);
-    } else if (kind == ecs_id(EcsPipelineStats)) {
-        ecs_pipeline_stats_reduce(dst, src);
+void flecs_map_bucket_clear(
+    ecs_block_allocator_t *allocator,
+    ecs_bucket_t *bucket)
+{
+    ecs_bucket_entry_t *entry = bucket->first;
+    while(entry) {
+        ecs_bucket_entry_t *next = entry->next;
+        flecs_bfree(allocator, entry);
+        entry = next;
     }
 }
 
+/* Get payload pointer for key from bucket */
 static
-void AggregateStats(ecs_iter_t *it) {
-    int32_t interval = *(int32_t*)it->ctx;
-
-    EcsStatsHeader *dst_hdr = ecs_field_w_size(it, 0, 1);
-    EcsStatsHeader *src_hdr = ecs_field_w_size(it, 0, 2);
-
-    void *dst = ECS_OFFSET_T(dst_hdr, EcsStatsHeader);
-    void *src = ECS_OFFSET_T(src_hdr, EcsStatsHeader);
-
-    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 1));
-
-    ecs_world_stats_t last_world = {0};
-    ecs_pipeline_stats_t last_pipeline = {0};
-    void *last = NULL;
-
-    if (dst_hdr->reduce_count != 0) {
-        /* Copy last value so we can pass it to reduce_last */
-        if (kind == ecs_id(EcsWorldStats)) {
-            last_world.t = 0;
-            ecs_world_stats_copy_last(&last_world, dst);
-            last = &last_world;
-        } else if (kind == ecs_id(EcsPipelineStats)) {
-            last_pipeline.t = 0;
-            ecs_pipeline_stats_copy_last(&last_pipeline, dst);
-            last = &last_pipeline;
+ecs_map_val_t* flecs_map_bucket_get(
+    ecs_bucket_t *bucket,
+    ecs_map_key_t key)
+{
+    ecs_bucket_entry_t *entry;
+    for (entry = bucket->first; entry; entry = entry->next) {
+        if (entry->key == key) {
+            return &entry->value;
         }
     }
+    return NULL;
+}
 
-    /* Reduce from minutes to the current day */
-    if (kind == ecs_id(EcsWorldStats)) {
-        ecs_world_stats_reduce(dst, src);
-    } else if (kind == ecs_id(EcsPipelineStats)) {
-        ecs_pipeline_stats_reduce(dst, src);
+/* Grow number of buckets */
+static
+void flecs_map_rehash(
+    ecs_map_t *map,
+    int32_t count)
+{
+    count = flecs_next_pow_of_2(count);
+    if (count < 2) {
+        count = 2;
     }
+    ecs_assert(count > map->bucket_count, ECS_INTERNAL_ERROR, NULL);
+    
+    int32_t old_count = map->bucket_count;
+    ecs_bucket_t *buckets = map->buckets, *b, *end = ECS_BUCKET_END(buckets, old_count);
 
-    if (dst_hdr->reduce_count != 0) {
-        if (kind == ecs_id(EcsWorldStats)) {
-            ecs_world_stats_reduce_last(dst, last, dst_hdr->reduce_count);
-        } else if (kind == ecs_id(EcsPipelineStats)) {
-            ecs_pipeline_stats_reduce_last(dst, last, dst_hdr->reduce_count);
-        }
+    if (map->allocator) {
+        map->buckets = flecs_calloc_n(map->allocator, ecs_bucket_t, count);
+    } else {
+        map->buckets = ecs_os_calloc_n(ecs_bucket_t, count);
     }
+    map->bucket_count = count;
+    map->bucket_shift = flecs_map_get_bucket_shift(count);
 
-    /* A day has 60 24 minute intervals */
-    dst_hdr->reduce_count ++;
-    if (dst_hdr->reduce_count >= interval) {
-        dst_hdr->reduce_count = 0;
+    /* Remap old bucket entries to new buckets */
+    for (b = buckets; b < end; b++) {
+        ecs_bucket_entry_t* entry;
+        for (entry = b->first; entry;) {
+            ecs_bucket_entry_t* next = entry->next;
+            int32_t bucket_index = flecs_map_get_bucket_index(
+                map->bucket_shift, entry->key);
+            ecs_bucket_t *bucket = &map->buckets[bucket_index];
+            entry->next = bucket->first;
+            bucket->first = entry;
+            entry = next;
+        }
     }
 
-    if (last && kind == ecs_id(EcsPipelineStats)) {
-        ecs_pipeline_stats_fini(last);
+    if (map->allocator) {
+        flecs_free_n(map->allocator, ecs_bucket_t, old_count, buckets);
+    } else {
+        ecs_os_free(buckets);
     }
 }
 
-static
-void flecs_stats_monitor_import(
-    ecs_world_t *world,
-    ecs_id_t kind,
-    size_t size)
+void ecs_map_params_init(
+    ecs_map_params_t *params,
+    ecs_allocator_t *allocator)
 {
-    ecs_entity_t prev = ecs_set_scope(world, kind);
-
-    // Called each frame, collects 60 measurements per second
-    ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1s", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
-            .id = ecs_pair(kind, EcsPeriod1s),
-            .src.id = EcsWorld 
-        }},
-        .callback = MonitorStats
-    });
-
-    // Called each second, reduces into 60 measurements per minute
-    ecs_entity_t mw1m = ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1m", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
-            .id = ecs_pair(kind, EcsPeriod1m),
-            .src.id = EcsWorld 
-        }, {
-            .id = ecs_pair(kind, EcsPeriod1s),
-            .src.id = EcsWorld 
-        }},
-        .callback = ReduceStats,
-        .interval = 1.0
-    });
-
-    // Called each minute, reduces into 60 measurements per hour
-    ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1h", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
-            .id = ecs_pair(kind, EcsPeriod1h),
-            .src.id = EcsWorld 
-        }, {
-            .id = ecs_pair(kind, EcsPeriod1m),
-            .src.id = EcsWorld 
-        }},
-        .callback = ReduceStats,
-        .rate = 60,
-        .tick_source = mw1m
-    });
-
-    // Called each minute, reduces into 60 measurements per day
-    ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1d", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
-            .id = ecs_pair(kind, EcsPeriod1d),
-            .src.id = EcsWorld 
-        }, {
-            .id = ecs_pair(kind, EcsPeriod1m),
-            .src.id = EcsWorld 
-        }},
-        .callback = AggregateStats,
-        .rate = 60,
-        .tick_source = mw1m,
-        .ctx = &flecs_day_interval_count
-    });
-
-    // Called each hour, reduces into 60 measurements per week
-    ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1w", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
-            .id = ecs_pair(kind, EcsPeriod1w),
-            .src.id = EcsWorld 
-        }, {
-            .id = ecs_pair(kind, EcsPeriod1h),
-            .src.id = EcsWorld 
-        }},
-        .callback = AggregateStats,
-        .rate = 60,
-        .tick_source = mw1m,
-        .ctx = &flecs_week_interval_count
-    });
-
-    ecs_set_scope(world, prev);
-
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1s), size, NULL);
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1m), size, NULL);
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1h), size, NULL);
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1d), size, NULL);
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1w), size, NULL);
+    params->allocator = allocator;
+    flecs_ballocator_init_t(&params->entry_allocator, ecs_bucket_entry_t);
 }
 
-static
-void flecs_world_monitor_import(
-    ecs_world_t *world)
+void ecs_map_params_fini(
+    ecs_map_params_t *params)
 {
-    ECS_COMPONENT_DEFINE(world, EcsWorldStats);
-
-    flecs_stats_monitor_import(world, ecs_id(EcsWorldStats), 
-        sizeof(EcsWorldStats));
+    flecs_ballocator_fini(&params->entry_allocator);
 }
 
-static
-void flecs_pipeline_monitor_import(
-    ecs_world_t *world)
+void ecs_map_init_w_params(
+    ecs_map_t *result,
+    ecs_map_params_t *params)
 {
-    ECS_COMPONENT_DEFINE(world, EcsPipelineStats);
+    ecs_os_zeromem(result);
 
-    ecs_set_hooks(world, EcsPipelineStats, {
-        .ctor = ecs_default_ctor,
-        .copy = ecs_copy(EcsPipelineStats),
-        .move = ecs_move(EcsPipelineStats),
-        .dtor = ecs_dtor(EcsPipelineStats)
-    });
+    result->allocator = params->allocator;
+
+    if (params->entry_allocator.chunk_size) {
+        result->entry_allocator = &params->entry_allocator;
+        result->shared_allocator = true;
+    } else {
+        result->entry_allocator = flecs_ballocator_new_t(ecs_bucket_entry_t);
+    }
 
-    flecs_stats_monitor_import(world, ecs_id(EcsPipelineStats),
-        sizeof(EcsPipelineStats));
+    flecs_map_rehash(result, 0);
 }
 
-void FlecsMonitorImport(
-    ecs_world_t *world)
+void ecs_map_init_w_params_if(
+    ecs_map_t *result,
+    ecs_map_params_t *params)
 {
-    ECS_MODULE_DEFINE(world, FlecsMonitor);
-    ECS_IMPORT(world, FlecsPipeline);
-    ECS_IMPORT(world, FlecsTimer);
-#ifdef FLECS_META
-    ECS_IMPORT(world, FlecsMeta);
-#endif
-#ifdef FLECS_UNITS
-    ECS_IMPORT(world, FlecsUnits);
-#endif
-#ifdef FLECS_DOC
-    ECS_IMPORT(world, FlecsDoc);
-    ecs_doc_set_brief(world, ecs_id(FlecsMonitor), 
-        "Module that automatically monitors statistics for the world & systems");
-#endif
-
-    ecs_set_name_prefix(world, "Ecs");
-
-    EcsPeriod1s = ecs_new_entity(world, "EcsPeriod1s");
-    EcsPeriod1m = ecs_new_entity(world, "EcsPeriod1m");
-    EcsPeriod1h = ecs_new_entity(world, "EcsPeriod1h");
-    EcsPeriod1d = ecs_new_entity(world, "EcsPeriod1d");
-    EcsPeriod1w = ecs_new_entity(world, "EcsPeriod1w");
-
-    ECS_COMPONENT_DEFINE(world, EcsWorldSummary);
-
-#if defined(FLECS_META) && defined(FLECS_UNITS) 
-    ecs_entity_t build_info = ecs_lookup(world, "flecs.core.build_info_t");
-    ecs_struct(world, {
-        .entity = ecs_id(EcsWorldSummary),
-        .members = {
-            { .name = "target_fps", .type = ecs_id(ecs_f64_t), .unit = EcsHertz },
-            { .name = "frame_time_total", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds },
-            { .name = "system_time_total", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
-            { .name = "merge_time_total", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
-            { .name = "frame_time_last", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
-            { .name = "system_time_last", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
-            { .name = "merge_time_last", .type = ecs_id(ecs_f64_t), .unit = EcsSeconds  },
-            { .name = "frame_count", .type = ecs_id(ecs_u64_t) },
-            { .name = "command_count", .type = ecs_id(ecs_u64_t) },
-            { .name = "build_info", .type = build_info }
-        }
-    });
-#endif
-
-    ecs_system(world, {
-        .entity = ecs_entity(world, { 
-            .name = "UpdateWorldSummary", 
-            .add = {ecs_dependson(EcsPreFrame)} 
-        }),
-        .query.filter.terms[0] = { .id = ecs_id(EcsWorldSummary) },
-        .callback = UpdateWorldSummary
-    });
-
-    ECS_SYSTEM(world, UpdateWorldSummary, EcsPreFrame, WorldSummary);
-    ecs_set(world, EcsWorld, EcsWorldSummary, {0});
-
-    flecs_world_monitor_import(world);
-    flecs_pipeline_monitor_import(world);
-    
-    if (ecs_os_has_time()) {
-        ecs_measure_frame_time(world, true);
-        ecs_measure_system_time(world, true);
+    if (!ecs_map_is_init(result)) {
+        ecs_map_init_w_params(result, params);
     }
 }
 
-#endif
-
-/**
- * @file addons/parser.c
- * @brief Parser addon.
- */
-
-
-#ifdef FLECS_PARSER
-
-#include <ctype.h>
-
-#define TOK_COLON ':'
-#define TOK_AND ','
-#define TOK_OR "||"
-#define TOK_NOT '!'
-#define TOK_OPTIONAL '?'
-#define TOK_BITWISE_OR '|'
-#define TOK_BRACKET_OPEN '['
-#define TOK_BRACKET_CLOSE ']'
-#define TOK_SCOPE_OPEN '{'
-#define TOK_SCOPE_CLOSE '}'
-#define TOK_VARIABLE '$'
-#define TOK_PAREN_OPEN '('
-#define TOK_PAREN_CLOSE ')'
-#define TOK_EQ "=="
-#define TOK_NEQ "!="
-#define TOK_MATCH "~="
-#define TOK_EXPR_STRING '"'
-
-#define TOK_SELF "self"
-#define TOK_UP "up"
-#define TOK_DOWN "down"
-#define TOK_CASCADE "cascade"
-#define TOK_PARENT "parent"
-#define TOK_DESC "desc"
-
-#define TOK_OVERRIDE "OVERRIDE"
-#define TOK_ROLE_AND "AND"
-#define TOK_ROLE_OR "OR"
-#define TOK_ROLE_NOT "NOT"
-#define TOK_ROLE_TOGGLE "TOGGLE"
-
-#define TOK_IN "in"
-#define TOK_OUT "out"
-#define TOK_INOUT "inout"
-#define TOK_INOUT_NONE "none"
-
-static
-const ecs_id_t ECS_OR =                                            (1ull << 59);
-
-static
-const ecs_id_t ECS_NOT =                                           (1ull << 58);
-
-#define ECS_MAX_TOKEN_SIZE (256)
-
-typedef char ecs_token_t[ECS_MAX_TOKEN_SIZE];
-
-const char* ecs_parse_ws_eol(
-    const char *ptr)
+void ecs_map_init(
+    ecs_map_t *result,
+    ecs_allocator_t *allocator)
 {
-    while (isspace(*ptr)) {
-        ptr ++;
-    }
-
-    return ptr;
+    ecs_map_init_w_params(result, &(ecs_map_params_t) {
+        .allocator = allocator
+    });
 }
 
-const char* ecs_parse_ws(
-    const char *ptr)
+void ecs_map_init_if(
+    ecs_map_t *result,
+    ecs_allocator_t *allocator)
 {
-    while ((*ptr != '\n') && isspace(*ptr)) {
-        ptr ++;
-    }
-
-    return ptr;
+    if (!ecs_map_is_init(result)) {
+        ecs_map_init(result, allocator);
+    }   
 }
 
-const char* ecs_parse_digit(
-    const char *ptr,
-    char *token)
+void ecs_map_fini(
+    ecs_map_t *map)
 {
-    char *tptr = token;
-    char ch = ptr[0];
-
-    if (!isdigit(ch) && ch != '-') {
-        ecs_parser_error(NULL, NULL, 0, "invalid start of number '%s'", ptr);
-        return NULL;
+    if (!ecs_map_is_init(map)) {
+        return;
     }
 
-    tptr[0] = ch;
-    tptr ++;
-    ptr ++;
+    bool sanitize = false;
+#ifdef FLECS_SANITIZE
+    sanitize = true;
+#endif
 
-    for (; (ch = *ptr); ptr ++) {
-        if (!isdigit(ch) && (ch != '.') && (ch != 'e')) {
-            break;
+    /* Free buckets in sanitized mode, so we can replace the allocator with
+     * regular malloc/free and use asan/valgrind to find memory errors. */
+    ecs_allocator_t *a = map->allocator;
+    ecs_block_allocator_t *ea = map->entry_allocator;
+    if (map->shared_allocator || sanitize) {
+        ecs_bucket_t *bucket = map->buckets, *end = &bucket[map->bucket_count];
+        while (bucket != end) {
+            flecs_map_bucket_clear(ea, bucket);
+            bucket ++;
         }
+    }
 
-        tptr[0] = ch;
-        tptr ++;
+    if (ea && !map->shared_allocator) {
+        flecs_ballocator_free(ea);
+        map->entry_allocator = NULL;
+    }
+    if (a) {
+        flecs_free_n(a, ecs_bucket_t, map->bucket_count, map->buckets);
+    } else {
+        ecs_os_free(map->buckets);
     }
 
-    tptr[0] = '\0';
-    
-    return ptr;
+    map->bucket_shift = 0;
 }
 
-/* -- Private functions -- */
-
-bool flecs_isident(
-    char ch)
+ecs_map_val_t* ecs_map_get(
+    const ecs_map_t *map,
+    ecs_map_key_t key)
 {
-    return isalpha(ch) || (ch == '_');
+    return flecs_map_bucket_get(flecs_map_get_bucket(map, key), key);
 }
 
-static
-bool flecs_valid_identifier_start_char(
-    char ch)
+void* ecs_map_get_deref_(
+    const ecs_map_t *map,
+    ecs_map_key_t key)
 {
-    if (ch && (flecs_isident(ch) || (ch == '*') ||
-        (ch == '0') || (ch == TOK_VARIABLE) || isdigit(ch))) 
-    {
-        return true;
+    ecs_map_val_t* ptr = flecs_map_bucket_get(
+        flecs_map_get_bucket(map, key), key);
+    if (ptr) {
+        return (void*)(uintptr_t)ptr[0];
     }
-
-    return false;
+    return NULL;
 }
 
-static
-bool flecs_valid_token_start_char(
-    char ch)
+void ecs_map_insert(
+    ecs_map_t *map,
+    ecs_map_key_t key,
+    ecs_map_val_t value)
 {
-    if ((ch == '"') || (ch == '{') || (ch == '}') || (ch == ',') || (ch == '-')
-        || (ch == '[') || (ch == ']') || (ch == '`') || 
-        flecs_valid_identifier_start_char(ch))
-    {
-        return true;
+    ecs_assert(ecs_map_get(map, key) == NULL, ECS_INVALID_PARAMETER, NULL);
+    int32_t map_count = ++map->count;
+    int32_t tgt_bucket_count = flecs_map_get_bucket_count(map_count);
+    int32_t bucket_count = map->bucket_count;
+    if (tgt_bucket_count > bucket_count) {
+        flecs_map_rehash(map, tgt_bucket_count);
     }
 
-    return false;
+    ecs_bucket_t *bucket = flecs_map_get_bucket(map, key);
+    flecs_map_bucket_add(map->entry_allocator, bucket, key)[0] = value;
 }
 
-static
-bool flecs_valid_token_char(
-    char ch)
+void* ecs_map_insert_alloc(
+    ecs_map_t *map,
+    ecs_size_t elem_size,
+    ecs_map_key_t key)
 {
-    if (ch && (flecs_isident(ch) || isdigit(ch) || ch == '.' || ch == '"')) {
-        return true;
-    }
-
-    return false;
+    void *elem = ecs_os_calloc(elem_size);
+    ecs_map_insert_ptr(map, key, (uintptr_t)elem);
+    return elem;
 }
 
-static
-bool flecs_valid_operator_char(
-    char ch)
+ecs_map_val_t* ecs_map_ensure(
+    ecs_map_t *map,
+    ecs_map_key_t key)
 {
-    if (ch == TOK_OPTIONAL || ch == TOK_NOT) {
-        return true;
+    ecs_bucket_t *bucket = flecs_map_get_bucket(map, key);
+    ecs_map_val_t *result = flecs_map_bucket_get(bucket, key);
+    if (result) {
+        return result;
     }
 
-    return false;
+    int32_t map_count = ++map->count;
+    int32_t tgt_bucket_count = flecs_map_get_bucket_count(map_count);
+    int32_t bucket_count = map->bucket_count;
+    if (tgt_bucket_count > bucket_count) {
+        flecs_map_rehash(map, tgt_bucket_count);
+        bucket = flecs_map_get_bucket(map, key);
+    }
+
+    ecs_map_val_t* v = flecs_map_bucket_add(map->entry_allocator, bucket, key);
+    *v = 0;
+    return v;
 }
 
-const char* ecs_parse_token(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token_out,
-    char delim)
+void* ecs_map_ensure_alloc(
+    ecs_map_t *map,
+    ecs_size_t elem_size,
+    ecs_map_key_t key)
 {
-    int64_t column = ptr - expr;
+    ecs_map_val_t *val = ecs_map_ensure(map, key);
+    if (!*val) {
+        void *elem = ecs_os_calloc(elem_size);
+        *val = (ecs_map_val_t)(uintptr_t)elem;
+        return elem;
+    } else {
+        return (void*)(uintptr_t)*val;
+    }
+}
 
-    ptr = ecs_parse_ws(ptr);
-    char *tptr = token_out, ch = ptr[0];
+ecs_map_val_t ecs_map_remove(
+    ecs_map_t *map,
+    ecs_map_key_t key)
+{
+    return flecs_map_bucket_remove(map, flecs_map_get_bucket(map, key), key);
+}
 
-    if (!flecs_valid_token_start_char(ch)) {
-        if (ch == '\0' || ch == '\n') {
-            ecs_parser_error(name, expr, column, 
-                "unexpected end of expression");
-        } else {
-            ecs_parser_error(name, expr, column, 
-                "invalid start of token '%s'", ptr);
-        }
-        return NULL;
+void ecs_map_remove_free(
+    ecs_map_t *map,
+    ecs_map_key_t key)
+{
+    ecs_map_val_t val = ecs_map_remove(map, key);
+    if (val) {
+        ecs_os_free((void*)(uintptr_t)val);
     }
+}
 
-    tptr[0] = ch;
-    tptr ++;
-    ptr ++;
+void ecs_map_clear(
+    ecs_map_t *map)
+{
+    ecs_assert(map != NULL, ECS_INVALID_PARAMETER, NULL);
+    int32_t i, count = map->bucket_count;
+    for (i = 0; i < count; i ++) {
+        flecs_map_bucket_clear(map->entry_allocator, &map->buckets[i]);
+    }
+    if (map->allocator) {
+        flecs_free_n(map->allocator, ecs_bucket_t, count, map->buckets);
+    } else {
+        ecs_os_free(map->buckets);
+    }
+    map->buckets = NULL;
+    map->bucket_count = 0;
+    map->count = 0;
+    flecs_map_rehash(map, 2);
+}
 
-    if (ch == '{' || ch == '}' || ch == '[' || ch == ']' || ch == ',' || ch == '`') {
-        tptr[0] = 0;
-        return ptr;
+ecs_map_iter_t ecs_map_iter(
+    const ecs_map_t *map)
+{
+    if (ecs_map_is_init(map)) {
+        return (ecs_map_iter_t){
+            .map = map,
+            .bucket = NULL,
+            .entry = NULL
+        };
+    } else {
+        return (ecs_map_iter_t){ 0 };
     }
+}
 
-    int tmpl_nesting = 0;
-    bool in_str = ch == '"';
+bool ecs_map_next(
+    ecs_map_iter_t *iter)
+{
+    const ecs_map_t *map = iter->map;
+    ecs_bucket_t *end;
+    if (!map || (iter->bucket == (end = &map->buckets[map->bucket_count]))) {
+        return false;
+    }
 
-    for (; (ch = *ptr); ptr ++) {
-        if (ch == '<') {
-            tmpl_nesting ++;
-        } else if (ch == '>') {
-            if (!tmpl_nesting) {
+    ecs_bucket_entry_t *entry = NULL;
+    if (!iter->bucket) {
+        for (iter->bucket = map->buckets; 
+            iter->bucket != end;
+            ++iter->bucket) 
+        {
+            if (iter->bucket->first) {
+                entry = iter->bucket->first;
                 break;
             }
-            tmpl_nesting --;
-        } else if (ch == '"') {
-            in_str = !in_str;
-        } else if (ch == '\\') {
-            ptr ++;
-            tptr[0] = ptr[0];
-            tptr ++;
-            continue;
-        } else if (!flecs_valid_token_char(ch) && !in_str) {
-            break;
         }
-
-        if (delim && (ch == delim)) {
-            break;
+        if (iter->bucket == end) {
+            return false;
         }
-
-        tptr[0] = ch;
-        tptr ++;
+    } else if ((entry = iter->entry) == NULL) {
+        do {
+            ++iter->bucket;
+            if (iter->bucket == end) {
+                return false;
+            }
+        } while(!iter->bucket->first);
+        entry = iter->bucket->first;
     }
 
-    tptr[0] = '\0';
+    ecs_assert(entry != NULL, ECS_INTERNAL_ERROR, NULL);
+    iter->entry = entry->next;
+    iter->res = &entry->key;
 
-    if (tmpl_nesting != 0) {
-        ecs_parser_error(name, expr, column, 
-            "identifier '%s' has mismatching < > pairs", ptr);
-        return NULL;
+    return true;
+}
+
+void ecs_map_copy(
+    ecs_map_t *dst,
+    const ecs_map_t *src)
+{
+    if (ecs_map_is_init(dst)) {
+        ecs_assert(ecs_map_count(dst) == 0, ECS_INVALID_PARAMETER, NULL);
+        ecs_map_fini(dst);
+    }
+    
+    if (!ecs_map_is_init(src)) {
+        return;
     }
 
-    const char *next_ptr = ecs_parse_ws(ptr);
-    if (next_ptr[0] == ':' && next_ptr != ptr) {
-        /* Whitespace between token and : is significant */
-        ptr = next_ptr - 1;
-    } else {
-        ptr = next_ptr;
+    ecs_map_init(dst, src->allocator);
+
+    ecs_map_iter_t it = ecs_map_iter(src);
+    while (ecs_map_next(&it)) {
+        ecs_map_insert(dst, ecs_map_key(&it), ecs_map_value(&it));
     }
+}
 
-    return ptr;
+/**
+ * @file datastructures/name_index.c
+ * @brief Data structure for resolving 64bit keys by string (name).
+ */
+
+
+static
+uint64_t flecs_name_index_hash(
+    const void *ptr)
+{
+    const ecs_hashed_string_t *str = ptr;
+    ecs_assert(str->hash != 0, ECS_INTERNAL_ERROR, NULL);
+    return str->hash;
 }
 
-const char* ecs_parse_identifier(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token_out)
+static
+int flecs_name_index_compare(
+    const void *ptr1, 
+    const void *ptr2)
 {
-    if (!flecs_valid_identifier_start_char(ptr[0]) && (ptr[0] != '"')) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "expected start of identifier");
-        return NULL;
+    const ecs_hashed_string_t *str1 = ptr1;
+    const ecs_hashed_string_t *str2 = ptr2;
+    ecs_size_t len1 = str1->length;
+    ecs_size_t len2 = str2->length;
+    if (len1 != len2) {
+        return (len1 > len2) - (len1 < len2);
     }
 
-    ptr = ecs_parse_token(name, expr, ptr, token_out, 0);
+    return ecs_os_memcmp(str1->value, str2->value, len1);
+}
 
-    return ptr;
+void flecs_name_index_init(
+    ecs_hashmap_t *hm,
+    ecs_allocator_t *allocator) 
+{
+    flecs_hashmap_init_(hm, 
+        ECS_SIZEOF(ecs_hashed_string_t), ECS_SIZEOF(uint64_t), 
+        flecs_name_index_hash, 
+        flecs_name_index_compare,
+        allocator);
 }
 
-static
-int flecs_parse_identifier(
-    const char *token,
-    ecs_term_id_t *out)
+void flecs_name_index_init_if(
+    ecs_hashmap_t *hm,
+    ecs_allocator_t *allocator) 
 {
-    const char *tptr = token;
-    if (tptr[0] == TOK_VARIABLE && tptr[1]) {
-        out->flags |= EcsIsVariable;
-        tptr ++;
-    }
-    if (tptr[0] == TOK_EXPR_STRING && tptr[1]) {
-        out->flags |= EcsIsName;
-        tptr ++;
-        if (tptr[0] == TOK_NOT) {
-            /* Already parsed */
-            tptr ++;
-        }
+    if (!hm->compare) {
+        flecs_name_index_init(hm, allocator);
     }
+}
 
-    char *name = ecs_os_strdup(tptr);
-    out->name = name;
+bool flecs_name_index_is_init(
+    const ecs_hashmap_t *hm)
+{
+    return hm->compare != NULL;
+}
 
-    ecs_size_t len = ecs_os_strlen(name);
-    if (out->flags & EcsIsName) {
-        if (name[len - 1] != TOK_EXPR_STRING) {
-            ecs_parser_error(NULL, token, 0, "missing '\"' at end of string");
-            return -1;
-        } else {
-            name[len - 1] = '\0';
-        }
+ecs_hashmap_t* flecs_name_index_new(
+    ecs_world_t *world,
+    ecs_allocator_t *allocator) 
+{
+    ecs_hashmap_t *result = flecs_bcalloc(&world->allocators.hashmap);
+    flecs_name_index_init(result, allocator);
+    result->hashmap_allocator = &world->allocators.hashmap;
+    return result;
+}
+
+void flecs_name_index_fini(
+    ecs_hashmap_t *map)
+{
+    flecs_hashmap_fini(map);
+}
+
+void flecs_name_index_free(
+    ecs_hashmap_t *map)
+{
+    if (map) {
+        flecs_name_index_fini(map);
+        flecs_bfree(map->hashmap_allocator, map);
     }
+}
 
-    return 0;
+ecs_hashmap_t* flecs_name_index_copy(
+    ecs_hashmap_t *map)
+{
+    ecs_hashmap_t *result = flecs_bcalloc(map->hashmap_allocator);
+    result->hashmap_allocator = map->hashmap_allocator;
+    flecs_hashmap_copy(result, map);
+    return result;
 }
 
-static
-ecs_entity_t flecs_parse_role(
+ecs_hashed_string_t flecs_get_hashed_string(
     const char *name,
-    const char *sig,
-    int64_t column,
-    const char *token)
-{
-    if (!ecs_os_strcmp(token, TOK_ROLE_AND)) {
-        return ECS_AND;
-    } else if (!ecs_os_strcmp(token, TOK_ROLE_OR)) {
-        return ECS_OR;
-    } else if (!ecs_os_strcmp(token, TOK_ROLE_NOT)) {
-        return ECS_NOT;
-    } else if (!ecs_os_strcmp(token, TOK_OVERRIDE)) {
-        return ECS_OVERRIDE;
-    } else if (!ecs_os_strcmp(token, TOK_ROLE_TOGGLE)) {
-        return ECS_TOGGLE;        
+    ecs_size_t length,
+    uint64_t hash)
+{
+    if (!length) {
+        length = ecs_os_strlen(name);
     } else {
-        ecs_parser_error(name, sig, column, "invalid role '%s'", token);
-        return 0;
+        ecs_assert(length == ecs_os_strlen(name), ECS_INTERNAL_ERROR, NULL);
     }
-}
 
-static
-ecs_oper_kind_t flecs_parse_operator(
-    char ch)
-{
-    if (ch == TOK_OPTIONAL) {
-        return EcsOptional;
-    } else if (ch == TOK_NOT) {
-        return EcsNot;
+    if (!hash) {
+        hash = flecs_hash(name, length);
     } else {
-        ecs_throw(ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(hash == flecs_hash(name, length), ECS_INTERNAL_ERROR, NULL);
     }
-error:
-    return 0;
+
+    return (ecs_hashed_string_t) {
+        .value = ECS_CONST_CAST(char*, name),
+        .length = length,
+        .hash = hash
+    };
 }
 
-static
-const char* flecs_parse_annotation(
+const uint64_t* flecs_name_index_find_ptr(
+    const ecs_hashmap_t *map,
     const char *name,
-    const char *sig,
-    int64_t column,
-    const char *ptr, 
-    ecs_inout_kind_t *inout_kind_out)
+    ecs_size_t length,
+    uint64_t hash)
 {
-    char token[ECS_MAX_TOKEN_SIZE];
-
-    ptr = ecs_parse_identifier(name, sig, ptr, token);
-    if (!ptr) {
+    ecs_hashed_string_t hs = flecs_get_hashed_string(name, length, hash);
+    ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hs.hash);
+    if (!b) {
         return NULL;
     }
 
-    if (!ecs_os_strcmp(token, TOK_IN)) {
-        *inout_kind_out = EcsIn;
-    } else
-    if (!ecs_os_strcmp(token, TOK_OUT)) {
-        *inout_kind_out = EcsOut;
-    } else
-    if (!ecs_os_strcmp(token, TOK_INOUT)) {
-        *inout_kind_out = EcsInOut;
-    } else if (!ecs_os_strcmp(token, TOK_INOUT_NONE)) {
-        *inout_kind_out = EcsInOutNone;
-    }
+    ecs_hashed_string_t *keys = ecs_vec_first(&b->keys);
+    int32_t i, count = ecs_vec_count(&b->keys);
 
-    ptr = ecs_parse_ws(ptr);
+    for (i = 0; i < count; i ++) {
+        ecs_hashed_string_t *key = &keys[i];
+        ecs_assert(key->hash == hs.hash, ECS_INTERNAL_ERROR, NULL);
 
-    if (ptr[0] != TOK_BRACKET_CLOSE) {
-        ecs_parser_error(name, sig, column, "expected ]");
-        return NULL;
+        if (hs.length != key->length) {
+            continue;
+        }
+
+        if (!ecs_os_strcmp(name, key->value)) {
+            uint64_t *e = ecs_vec_get_t(&b->values, uint64_t, i);
+            ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL);
+            return e;
+        }
     }
 
-    return ptr + 1;
+    return NULL;
 }
 
-static
-uint8_t flecs_parse_set_token(
-    const char *token)
+uint64_t flecs_name_index_find(
+    const ecs_hashmap_t *map,
+    const char *name,
+    ecs_size_t length,
+    uint64_t hash)
 {
-    if (!ecs_os_strcmp(token, TOK_SELF)) {
-        return EcsSelf;
-    } else if (!ecs_os_strcmp(token, TOK_UP)) {
-        return EcsUp;
-    } else if (!ecs_os_strcmp(token, TOK_DOWN)) {
-        return EcsDown;
-    } else if (!ecs_os_strcmp(token, TOK_CASCADE)) {
-        return EcsCascade;
-    } else if (!ecs_os_strcmp(token, TOK_DESC)) {
-        return EcsDesc;
-    } else if (!ecs_os_strcmp(token, TOK_PARENT)) {
-        return EcsParent;
-    } else {
-        return 0;
+    const uint64_t *id = flecs_name_index_find_ptr(map, name, length, hash);
+    if (id) {
+        return id[0];
     }
+    return 0;
 }
 
-static
-const char* flecs_parse_term_flags(
-    const ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    int64_t column,
-    const char *ptr,
-    char *token,
-    ecs_term_id_t *id,
-    char tok_end)
+void flecs_name_index_remove(
+    ecs_hashmap_t *map,
+    uint64_t e,
+    uint64_t hash)
 {
-    char token_buf[ECS_MAX_TOKEN_SIZE] = {0};
-    if (!token) {
-        token = token_buf;
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            return NULL;
-        }
+    ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hash);
+    if (!b) {
+        return;
     }
 
-    do {
-        uint8_t tok = flecs_parse_set_token(token);
-        if (!tok) {
-            ecs_parser_error(name, expr, column, 
-                "invalid set token '%s'", token);
-            return NULL;
-        }
-
-        if (id->flags & tok) {
-            ecs_parser_error(name, expr, column, 
-                "duplicate set token '%s'", token);
-            return NULL;            
-        }
-        
-        id->flags |= tok;
-
-        if (ptr[0] == TOK_PAREN_OPEN) {
-            ptr ++;
-
-            /* Relationship (overrides IsA default) */
-            if (!isdigit(ptr[0]) && flecs_valid_token_start_char(ptr[0])) {
-                ptr = ecs_parse_identifier(name, expr, ptr, token);
-                if (!ptr) {
-                    return NULL;
-                }         
-
-                id->trav = ecs_lookup(world, token);
-                if (!id->trav) {
-                    ecs_parser_error(name, expr, column, 
-                        "unresolved identifier '%s'", token);
-                    return NULL;
-                }
-
-                if (ptr[0] == TOK_AND) {
-                    ptr = ecs_parse_ws(ptr + 1);
-                } else if (ptr[0] != TOK_PAREN_CLOSE) {
-                    ecs_parser_error(name, expr, column, 
-                        "expected ',' or ')'");
-                    return NULL;
-                }
-            }
-
-            if (ptr[0] != TOK_PAREN_CLOSE) {
-                ecs_parser_error(name, expr, column, "expected ')', got '%c'",
-                    ptr[0]);
-                return NULL;                
-            } else {
-                ptr = ecs_parse_ws(ptr + 1);
-                if (ptr[0] != tok_end && ptr[0] != TOK_AND && ptr[0] != 0) {
-                    ecs_parser_error(name, expr, column, 
-                        "expected end of set expr");
-                    return NULL;
-                }
-            }
+    uint64_t *ids = ecs_vec_first(&b->values);
+    int32_t i, count = ecs_vec_count(&b->values);
+    for (i = 0; i < count; i ++) {
+        if (ids[i] == e) {
+            flecs_hm_bucket_remove(map, b, hash, i);
+            break;
         }
+    }
+}
 
-        /* Next token in set expression */
-        if (ptr[0] == TOK_BITWISE_OR) {
-            ptr ++;
-            if (flecs_valid_token_start_char(ptr[0])) {
-                ptr = ecs_parse_identifier(name, expr, ptr, token);
-                if (!ptr) {
-                    return NULL;
-                }
-            }
+void flecs_name_index_update_name(
+    ecs_hashmap_t *map,
+    uint64_t e,
+    uint64_t hash,
+    const char *name)
+{
+    ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hash);
+    if (!b) {
+        return;
+    }
 
-        /* End of set expression */
-        } else if (ptr[0] == tok_end || ptr[0] == TOK_AND || !ptr[0]) {
-            break;
+    uint64_t *ids = ecs_vec_first(&b->values);
+    int32_t i, count = ecs_vec_count(&b->values);
+    for (i = 0; i < count; i ++) {
+        if (ids[i] == e) {
+            ecs_hashed_string_t *key = ecs_vec_get_t(
+                &b->keys, ecs_hashed_string_t, i);
+            key->value = ECS_CONST_CAST(char*, name);
+            ecs_assert(ecs_os_strlen(name) == key->length,
+                ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(flecs_hash(name, key->length) == key->hash,
+                ECS_INTERNAL_ERROR, NULL);
+            return;
         }
-    } while (true);
+    }
 
-    return ptr;
+    /* Record must already have been in the index */
+    ecs_abort(ECS_INTERNAL_ERROR, NULL);
 }
 
-static
-const char* flecs_parse_arguments(
-    const ecs_world_t *world,
+void flecs_name_index_ensure(
+    ecs_hashmap_t *map,
+    uint64_t id,
     const char *name,
-    const char *expr,
-    int64_t column,
-    const char *ptr,
-    char *token,
-    ecs_term_t *term,
-    ecs_oper_kind_t *extra_oper,
-    ecs_term_id_t *extra_args)
+    ecs_size_t length,
+    uint64_t hash)
 {
-    (void)column;
-
-    int32_t i, arg = 0;
+    ecs_check(name != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (extra_args) {
-        ecs_os_memset_n(extra_args, 0, ecs_term_id_t, ECS_PARSER_MAX_ARGS);
+    ecs_hashed_string_t key = flecs_get_hashed_string(name, length, hash);
+    
+    uint64_t existing = flecs_name_index_find(
+        map, name, key.length, key.hash);
+    if (existing) {
+        if (existing != id) {
+            ecs_abort(ECS_ALREADY_DEFINED, 
+                "conflicting id registered with name '%s'", name);
+        }
     }
 
-    if (!term) {
-        arg = 2;
-    }
+    flecs_hashmap_result_t hmr = flecs_hashmap_ensure(
+        map, &key, uint64_t);
+    *((uint64_t*)hmr.value) = id;
+error:
+    return;
+}
 
-    do {
-        if (flecs_valid_token_start_char(ptr[0])) {
-            if ((arg == ECS_PARSER_MAX_ARGS) || (!extra_args && arg == 2)) {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "too many arguments in term");
-                goto error;
-            }
+/**
+ * @file datastructures/sparse.c
+ * @brief Sparse set data structure.
+ */
 
-            ptr = ecs_parse_identifier(name, expr, ptr, token);
-            if (!ptr) {
-                goto error;
-            }
 
-            ptr = ecs_parse_ws_eol(ptr);
+/** Compute the page index from an id by stripping the first 12 bits */
+#define PAGE(index) ((int32_t)((uint32_t)index >> FLECS_SPARSE_PAGE_BITS))
 
-            ecs_term_id_t *term_id = NULL;
-            if (arg == 0) {
-                term_id = &term->src;
-            } else if (arg == 1) {
-                term_id = &term->second;
-            } else {
-                term_id = &extra_args[arg - 2];
-            }
+/** This computes the offset of an index inside a page */
+#define OFFSET(index) ((int32_t)index & (FLECS_SPARSE_PAGE_SIZE - 1))
 
-            /* If token is a colon, the token is an identifier followed by a
-             * set expression. */
-            if (ptr[0] == TOK_COLON) {
-                if (flecs_parse_identifier(token, term_id)) {
-                    ecs_parser_error(name, expr, (ptr - expr), 
-                        "invalid identifier '%s'", token);
-                    goto error;
-                }
+/* Utility to get a pointer to the payload */
+#define DATA(array, size, offset) (ECS_OFFSET(array, size * offset))
 
-                ptr = ecs_parse_ws_eol(ptr + 1);
-                ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr,
-                    NULL, term_id, TOK_PAREN_CLOSE);
-                if (!ptr) {
-                    goto error;
-                }
+typedef struct ecs_page_t {
+    int32_t *sparse;            /* Sparse array with indices to dense array */
+    void *data;                 /* Store data in sparse array to reduce  
+                                 * indirection and provide stable pointers. */
+} ecs_page_t;
 
-            /* Check for term flags */
-            } else if (!ecs_os_strcmp(token, TOK_CASCADE) ||
-                !ecs_os_strcmp(token, TOK_DESC) ||
-                !ecs_os_strcmp(token, TOK_SELF) || 
-                !ecs_os_strcmp(token, TOK_UP) || 
-                !ecs_os_strcmp(token, TOK_DOWN) || 
-                !(ecs_os_strcmp(token, TOK_PARENT)))
-            {
-                ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr, 
-                    token, term_id, TOK_PAREN_CLOSE);
-                if (!ptr) {
-                    goto error;
-                }
+static
+ecs_page_t* flecs_sparse_page_new(
+    ecs_sparse_t *sparse,
+    int32_t page_index)
+{
+    ecs_allocator_t *a = sparse->allocator;
+    ecs_block_allocator_t *ca = sparse->page_allocator;
+    int32_t count = ecs_vec_count(&sparse->pages);
+    ecs_page_t *pages;
 
-            /* Regular identifier */
-            } else if (flecs_parse_identifier(token, term_id)) {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "invalid identifier '%s'", token);
-                goto error;
-            }
+    if (count <= page_index) {
+        ecs_vec_set_count_t(a, &sparse->pages, ecs_page_t, page_index + 1);
+        pages = ecs_vec_first_t(&sparse->pages, ecs_page_t);
+        ecs_os_memset_n(&pages[count], 0, ecs_page_t, (1 + page_index - count));
+    } else {
+        pages = ecs_vec_first_t(&sparse->pages, ecs_page_t);
+    }
 
-            if (ptr[0] == TOK_AND) {
-                if (extra_oper && *extra_oper != EcsAnd) {
-                    ecs_parser_error(name, expr, (ptr - expr), 
-                        "cannot mix ',' and '||' in term arguments");
-                    goto error;
-                }
-                ptr = ecs_parse_ws_eol(ptr + 1);
+    ecs_assert(pages != NULL, ECS_INTERNAL_ERROR, NULL);
 
-                if (term) {
-                    term->id_flags = ECS_PAIR;
-                }
+    ecs_page_t *result = &pages[page_index];
+    ecs_assert(result->sparse == NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(result->data == NULL, ECS_INTERNAL_ERROR, NULL);
 
-            } else if (ptr[0] == TOK_PAREN_CLOSE) {
-                ptr = ecs_parse_ws(ptr + 1);
-                break;
+    /* Initialize sparse array with zero's, as zero is used to indicate that the
+     * sparse element has not been paired with a dense element. Use zero
+     * as this means we can take advantage of calloc having a possibly better 
+     * performance than malloc + memset. */
+    result->sparse = ca ? flecs_bcalloc(ca)
+                        : ecs_os_calloc_n(int32_t, FLECS_SPARSE_PAGE_SIZE);
 
-            } else if (extra_oper && ptr[0] == TOK_OR[0] && ptr[1] == TOK_OR[1]){
-                if (arg >= 2 && *extra_oper != EcsOr) {
-                    ecs_parser_error(name, expr, (ptr - expr), 
-                        "cannot mix ',' and '||' in term arguments");
-                    goto error;
-                }
+    /* Initialize the data array with zero's to guarantee that data is 
+     * always initialized. When an entry is removed, data is reset back to
+     * zero. Initialize now, as this can take advantage of calloc. */
+    result->data = a ? flecs_calloc(a, sparse->size * FLECS_SPARSE_PAGE_SIZE)
+                     : ecs_os_calloc(sparse->size * FLECS_SPARSE_PAGE_SIZE);
 
-                *extra_oper = EcsOr;
-                ptr = ecs_parse_ws_eol(ptr + 2);
+    ecs_assert(result->sparse != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(result->data != NULL, ECS_INTERNAL_ERROR, NULL);
 
-                if (term) {
-                    term->id_flags = ECS_PAIR;
-                }
-            } else {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "expected ',' or ')'");
-                goto error;
-            }
-
-        } else {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "expected identifier or set expression");
-            goto error;
-        }
-
-        arg ++;
+    return result;
+}
 
-    } while (true);
+static
+void flecs_sparse_page_free(
+    ecs_sparse_t *sparse,
+    ecs_page_t *page)
+{
+    ecs_allocator_t *a = sparse->allocator;
+    ecs_block_allocator_t *ca = sparse->page_allocator;
 
-    return ptr;
-error:
-    if (term && term->src.name) {
-        ecs_os_free(ECS_CONST_CAST(char*, term->src.name));
-        term->src.name = NULL;
-    }
-    if (term && term->second.name) {
-        ecs_os_free(ECS_CONST_CAST(char*, term->second.name));
-        term->second.name = NULL;
+    if (ca) {
+        flecs_bfree(ca, page->sparse);
+    } else {
+        ecs_os_free(page->sparse);
     }
-    if (extra_args) {
-        for (i = 2; i < arg + 1; i ++) {
-            if (extra_args[i - 2].name) {
-                ecs_os_free(ECS_CONST_CAST(char*, extra_args[i - 2].name));
-                extra_args[i - 2].name = NULL;
-            }
-        }
+    if (a) {
+        flecs_free(a, sparse->size * FLECS_SPARSE_PAGE_SIZE, page->data);
+    } else {
+        ecs_os_free(page->data);
     }
-    return NULL;
 }
 
 static
-void flecs_parser_unexpected_char(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char ch)
+ecs_page_t* flecs_sparse_get_page(
+    const ecs_sparse_t *sparse,
+    int32_t page_index)
 {
-    if (ch && (ch != '\n')) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "unexpected character '%c'", ch);
-    } else {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "unexpected end of term");
+    ecs_assert(page_index >= 0, ECS_INVALID_PARAMETER, NULL);
+    if (page_index >= ecs_vec_count(&sparse->pages)) {
+        return NULL;
     }
+    return ecs_vec_get_t(&sparse->pages, ecs_page_t, page_index);
 }
 
 static
-const char* flecs_parse_term(
-    const ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    ecs_term_t *term_out,
-    ecs_oper_kind_t *extra_oper,
-    ecs_term_id_t *extra_args)
+ecs_page_t* flecs_sparse_get_or_create_page(
+    ecs_sparse_t *sparse,
+    int32_t page_index)
 {
-    const char *ptr = expr;
-    char token[ECS_MAX_TOKEN_SIZE] = {0};
-    ecs_term_t term = { .move = true /* parser never owns resources */ };
+    ecs_page_t *page = flecs_sparse_get_page(sparse, page_index);
+    if (page && page->sparse) {
+        return page;
+    }
 
-    ptr = ecs_parse_ws(ptr);
+    return flecs_sparse_page_new(sparse, page_index);
+}
 
-    /* Inout specifiers always come first */
-    if (ptr[0] == TOK_BRACKET_OPEN) {
-        ptr = flecs_parse_annotation(name, expr, (ptr - expr), ptr + 1, &term.inout);
-        if (!ptr) {
-            goto error;
-        }
-        ptr = ecs_parse_ws_eol(ptr);
-    }
+static
+void flecs_sparse_grow_dense(
+    ecs_sparse_t *sparse)
+{
+    ecs_vec_append_t(sparse->allocator, &sparse->dense, uint64_t);
+}
 
-    if (flecs_valid_operator_char(ptr[0])) {
-        term.oper = flecs_parse_operator(ptr[0]);
-        ptr = ecs_parse_ws(ptr + 1);
-    }
+static
+uint64_t flecs_sparse_strip_generation(
+    uint64_t *index_out)
+{
+    uint64_t index = *index_out;
+    uint64_t gen = index & ECS_GENERATION_MASK;
+    /* Make sure there's no junk in the id */
+    ecs_assert(gen == (index & (0xFFFFFFFFull << 32)),
+        ECS_INVALID_PARAMETER, NULL);
+    *index_out -= gen;
+    return gen;
+}
 
-    /* If next token is the start of an identifier, it could be either a type
-     * role, source or component identifier */
-    if (flecs_valid_identifier_start_char(ptr[0])) {
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            goto error;
-        }
+static
+void flecs_sparse_assign_index(
+    ecs_page_t * page, 
+    uint64_t * dense_array, 
+    uint64_t index, 
+    int32_t dense)
+{
+    /* Initialize sparse-dense pair. This assigns the dense index to the sparse
+     * array, and the sparse index to the dense array .*/
+    page->sparse[OFFSET(index)] = dense;
+    dense_array[dense] = index;
+}
 
-        /* Is token a type role? */
-        if (ptr[0] == TOK_BITWISE_OR && ptr[1] != TOK_BITWISE_OR) {
-            ptr ++;
-            goto flecs_parse_role;
-        }
+static
+uint64_t flecs_sparse_inc_gen(
+    uint64_t index)
+{
+    /* When an index is deleted, its generation is increased so that we can do
+     * liveliness checking while recycling ids */
+    return ECS_GENERATION_INC(index);
+}
 
-        /* Is token a predicate? */
-        if (ptr[0] == TOK_PAREN_OPEN) {
-            goto parse_predicate;    
-        }
+static
+uint64_t flecs_sparse_inc_id(
+    ecs_sparse_t *sparse)
+{
+    /* Generate a new id. The last issued id could be stored in an external
+     * variable, such as is the case with the last issued entity id, which is
+     * stored on the world. */
+    return ++ sparse->max_id;
+}
+
+static
+uint64_t flecs_sparse_get_id(
+    const ecs_sparse_t *sparse)
+{
+    ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL);
+    return sparse->max_id;
+}
 
-        /* Next token must be a predicate */
-        goto parse_predicate;
+static
+void flecs_sparse_set_id(
+    ecs_sparse_t *sparse,
+    uint64_t value)
+{
+    /* Sometimes the max id needs to be assigned directly, which typically 
+     * happens when the API calls get_or_create for an id that hasn't been 
+     * issued before. */
+    sparse->max_id = value;
+}
 
-    /* Pair with implicit subject */
-    } else if (ptr[0] == TOK_PAREN_OPEN) {
-        goto parse_pair;
+/* Pair dense id with new sparse id */
+static
+uint64_t flecs_sparse_create_id(
+    ecs_sparse_t *sparse,
+    int32_t dense)
+{
+    uint64_t index = flecs_sparse_inc_id(sparse);
+    flecs_sparse_grow_dense(sparse);
 
-    /* Open query scope */
-    } else if (ptr[0] == TOK_SCOPE_OPEN) {
-        term.first.id = EcsScopeOpen;
-        term.src.id = 0;
-        term.src.flags = EcsIsEntity;
-        term.inout = EcsInOutNone;
-        goto parse_done;
+    ecs_page_t *page = flecs_sparse_get_or_create_page(sparse, PAGE(index));
+    ecs_assert(page->sparse[OFFSET(index)] == 0, ECS_INTERNAL_ERROR, NULL);
+    
+    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+    flecs_sparse_assign_index(page, dense_array, index, dense);
+    
+    return index;
+}
 
-    /* Close query scope */
-    } else if (ptr[0] == TOK_SCOPE_CLOSE) {
-        term.first.id = EcsScopeClose;
-        term.src.id = 0;
-        term.src.flags = EcsIsEntity;
-        term.inout = EcsInOutNone;
-        ptr = ecs_parse_ws(ptr + 1);
-        goto parse_done;
+/* Create new id */
+static
+uint64_t flecs_sparse_new_index(
+    ecs_sparse_t *sparse)
+{
+    int32_t dense_count = ecs_vec_count(&sparse->dense);
+    int32_t count = sparse->count ++;
 
-    /* Nothing else expected here */
+    ecs_assert(count <= dense_count, ECS_INTERNAL_ERROR, NULL);
+    if (count < dense_count) {
+        /* If there are unused elements in the dense array, return first */
+        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+        return dense_array[count];
     } else {
-        flecs_parser_unexpected_char(name, expr, ptr, ptr[0]);
-        goto error;
+        return flecs_sparse_create_id(sparse, count);
     }
+}
 
-flecs_parse_role:
-    term.id_flags = flecs_parse_role(name, expr, (ptr - expr), token);
-    if (!term.id_flags) {
-        goto error;
+/* Get value from sparse set when it is guaranteed that the value exists. This
+ * function is used when values are obtained using a dense index */
+static
+void* flecs_sparse_get_sparse(
+    const ecs_sparse_t *sparse,
+    int32_t dense,
+    uint64_t index)
+{
+    flecs_sparse_strip_generation(&index);
+    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
+    if (!page || !page->sparse) {
+        return NULL;
     }
 
-    ptr = ecs_parse_ws(ptr);
-
-    /* If next token is the source token, this is an empty source */
-    if (flecs_valid_token_start_char(ptr[0])) {
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            goto error;
-        }
+    int32_t offset = OFFSET(index);
+    ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
+    (void)dense;
 
-        /* If not, it's a predicate */
-        goto parse_predicate;
+    return DATA(page->data, sparse->size, offset);
+}
 
-    } else if (ptr[0] == TOK_PAREN_OPEN) {
-        goto parse_pair;
-    } else {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "expected identifier after role");
-        goto error;
-    }
+/* Swap dense elements. A swap occurs when an element is removed, or when a
+ * removed element is recycled. */
+static
+void flecs_sparse_swap_dense(
+    ecs_sparse_t * sparse,
+    ecs_page_t * page_a,
+    int32_t a,
+    int32_t b)
+{
+    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+    uint64_t index_a = dense_array[a];
+    uint64_t index_b = dense_array[b];
 
-parse_predicate:
-    if (flecs_parse_identifier(token, &term.first)) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "invalid identifier '%s'", token); 
-        goto error;
-    }
+    ecs_page_t *page_b = flecs_sparse_get_or_create_page(sparse, PAGE(index_b));
+    flecs_sparse_assign_index(page_a, dense_array, index_a, b);
+    flecs_sparse_assign_index(page_b, dense_array, index_b, a);
+}
 
-    /* Set expression */
-    if (ptr[0] == TOK_COLON) {
-        ptr = ecs_parse_ws(ptr + 1);
-        ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr, NULL, 
-            &term.first, TOK_COLON);
-        if (!ptr) {
-            goto error;
-        }
+void flecs_sparse_init(
+    ecs_sparse_t *result,
+    struct ecs_allocator_t *allocator,
+    ecs_block_allocator_t *page_allocator,
+    ecs_size_t size)
+{
+    ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL);
+    result->size = size;
+    result->max_id = UINT64_MAX;
+    result->allocator = allocator;
+    result->page_allocator = page_allocator;
 
-        ptr = ecs_parse_ws(ptr);
+    ecs_vec_init_t(allocator, &result->pages, ecs_page_t, 0);
+    ecs_vec_init_t(allocator, &result->dense, uint64_t, 1);
+    result->dense.count = 1;
 
-        if (ptr[0] == TOK_AND || !ptr[0]) {
-            goto parse_done;
-        }
+    /* Consume first value in dense array as 0 is used in the sparse array to
+     * indicate that a sparse element hasn't been paired yet. */
+    ecs_vec_first_t(&result->dense, uint64_t)[0] = 0;
 
-        if (ptr[0] != TOK_COLON) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unexpected token '%c' after predicate set expression", ptr[0]);
-            goto error;
-        }
+    result->count = 1;
+}
 
-        ptr = ecs_parse_ws(ptr + 1);
-    } else if (!ecs_os_strncmp(ptr, TOK_EQ, 2)) {
-        ptr = ecs_parse_ws(ptr + 2);
-        goto parse_eq;
-    } else if (!ecs_os_strncmp(ptr, TOK_NEQ, 2)) {
-        ptr = ecs_parse_ws(ptr + 2);
-        goto parse_neq;
-    } else if (!ecs_os_strncmp(ptr, TOK_MATCH, 2)) {
-        ptr = ecs_parse_ws(ptr + 2);
-        goto parse_match;
-    } else {
-        ptr = ecs_parse_ws(ptr);
-    }
+void flecs_sparse_clear(
+    ecs_sparse_t *sparse)
+{
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (ptr[0] == TOK_PAREN_OPEN) {
-        ptr = ecs_parse_ws_eol(ptr + 1);
-        if (ptr[0] == TOK_PAREN_CLOSE) {
-            term.src.flags = EcsIsEntity;
-            term.src.id = 0;
-            ptr ++;
-            ptr = ecs_parse_ws(ptr);
-        } else {
-            ptr = flecs_parse_arguments(world, name, expr, (ptr - expr), ptr, 
-                token, &term, extra_oper, extra_args);
+    int32_t i, count = ecs_vec_count(&sparse->pages);
+    ecs_page_t *pages = ecs_vec_first_t(&sparse->pages, ecs_page_t);
+    for (i = 0; i < count; i ++) {
+        int32_t *indices = pages[i].sparse;
+        if (indices) {
+            ecs_os_memset_n(indices, 0, int32_t, FLECS_SPARSE_PAGE_SIZE);
         }
-
-        goto parse_done;
     }
 
-    goto parse_done;
+    ecs_vec_set_count_t(sparse->allocator, &sparse->dense, uint64_t, 1);
 
-parse_eq:
-    term.src = term.first;
-    term.first = (ecs_term_id_t){0};
-    term.first.id = EcsPredEq;
-    goto parse_right_operand;
+    sparse->count = 1;
+    sparse->max_id = 0;
+}
 
-parse_neq:
-    term.src = term.first;
-    term.first = (ecs_term_id_t){0};
-    term.first.id = EcsPredEq;
-    if (term.oper != EcsAnd) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "invalid operator combination");
-        goto error;
-    }
-    term.oper = EcsNot;
-    goto parse_right_operand;
+void flecs_sparse_fini(
+    ecs_sparse_t *sparse)
+{
+    ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL);
     
-parse_match:
-    term.src = term.first;
-    term.first = (ecs_term_id_t){0};
-    term.first.id = EcsPredMatch;
-    goto parse_right_operand;
-
-parse_right_operand:
-    if (flecs_valid_token_start_char(ptr[0])) {
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            goto error;
-        }
+    int32_t i, count = ecs_vec_count(&sparse->pages);
+    ecs_page_t *pages = ecs_vec_first_t(&sparse->pages, ecs_page_t);
+    for (i = 0; i < count; i ++) {
+        flecs_sparse_page_free(sparse, &pages[i]);
+    }
 
-        if (term.first.id == EcsPredMatch) {
-            if (token[0] == '"' && token[1] == '!') {
-                term.oper = EcsNot;
-            }
-        }
+    ecs_vec_fini_t(sparse->allocator, &sparse->pages, ecs_page_t);
+    ecs_vec_fini_t(sparse->allocator, &sparse->dense, uint64_t);
+}
 
-        if (flecs_parse_identifier(token, &term.second)) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "invalid identifier '%s'", token); 
-            goto error;
-        }
+uint64_t flecs_sparse_new_id(
+    ecs_sparse_t *sparse)
+{
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    return flecs_sparse_new_index(sparse);
+}
 
-        term.src.flags &= ~EcsTraverseFlags;
-        term.src.flags |= EcsSelf;
-        term.inout = EcsInOutNone;
-    } else {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "expected identifier");
-        goto error;
-    }
-    goto parse_done;
-parse_pair:
-    ptr = ecs_parse_identifier(name, expr, ptr + 1, token);
-    if (!ptr) {
-        goto error;
-    }
+void* flecs_sparse_add(
+    ecs_sparse_t *sparse,
+    ecs_size_t size)
+{
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
+    uint64_t index = flecs_sparse_new_index(sparse);
+    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
+    ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
+    return DATA(page->data, size, OFFSET(index));
+}
 
-    if (ptr[0] == TOK_COLON) {
-        ptr = ecs_parse_ws(ptr + 1);
-        ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr,
-            NULL, &term.first, TOK_PAREN_CLOSE);
-        if (!ptr) {
-            goto error;
-        }
-    }
+uint64_t flecs_sparse_last_id(
+    const ecs_sparse_t *sparse)
+{
+    ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL);
+    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+    return dense_array[sparse->count - 1];
+}
 
-    if (ptr[0] == TOK_AND) {
-        ptr = ecs_parse_ws(ptr + 1);
-        if (ptr[0] == TOK_PAREN_CLOSE) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "expected identifier for second element of pair"); 
-            goto error;
-        }
-        
-        term.src.id = EcsThis;
-        term.src.flags |= EcsIsVariable;
-        goto parse_pair_predicate;
-    } else if (ptr[0] == TOK_PAREN_CLOSE) {
-        term.src.id = EcsThis;
-        term.src.flags |= EcsIsVariable;
-        goto parse_pair_predicate;
-    } else {
-        flecs_parser_unexpected_char(name, expr, ptr, ptr[0]);
-        goto error;
-    }
+void* flecs_sparse_ensure(
+    ecs_sparse_t *sparse,
+    ecs_size_t size,
+    uint64_t index)
+{
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(ecs_vec_count(&sparse->dense) > 0, ECS_INTERNAL_ERROR, NULL);
+    (void)size;
 
-parse_pair_predicate:
-    if (flecs_parse_identifier(token, &term.first)) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "invalid identifier '%s'", token); 
-        goto error;
-    }
+    uint64_t gen = flecs_sparse_strip_generation(&index);
+    ecs_page_t *page = flecs_sparse_get_or_create_page(sparse, PAGE(index));
+    int32_t offset = OFFSET(index);
+    int32_t dense = page->sparse[offset];
 
-    ptr = ecs_parse_ws(ptr);
-    if (flecs_valid_token_start_char(ptr[0])) {
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            goto error;
-        }
+    if (dense) {
+        /* Check if element is alive. If element is not alive, update indices so
+         * that the first unused dense element points to the sparse element. */
+        int32_t count = sparse->count;
+        if (dense >= count) {
+            /* If dense is not alive, swap it with the first unused element. */
+            flecs_sparse_swap_dense(sparse, page, dense, count);
+            dense = count;
 
-        if (ptr[0] == TOK_COLON) {
-            ptr = ecs_parse_ws(ptr + 1);
-            ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr,
-                NULL, &term.second, TOK_PAREN_CLOSE);
-            if (!ptr) {
-                goto error;
-            }
-        }
+            /* First unused element is now last used element */
+            sparse->count ++;
 
-        if (ptr[0] == TOK_PAREN_CLOSE || ptr[0] == TOK_AND || ptr[0] == TOK_OR[0]) {
-            goto parse_pair_object;
+            /* Set dense element to new generation */
+            ecs_vec_first_t(&sparse->dense, uint64_t)[dense] = index | gen;
         } else {
-            flecs_parser_unexpected_char(name, expr, ptr, ptr[0]);
-            goto error;
+            /* Dense is already alive, nothing to be done */
         }
-    } else if (ptr[0] == TOK_PAREN_CLOSE) {
-        /* No object */
-        ptr ++;
-        goto parse_done;
-    } else {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "expected pair object or ')'");
-        goto error;
-    }
-
-parse_pair_object:
-    if (flecs_parse_identifier(token, &term.second)) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "invalid identifier '%s'", token); 
-        goto error;
-    }
 
-    if (term.id_flags == 0) {
-        term.id_flags = ECS_PAIR;
-    }
-
-    if (ptr[0] == TOK_AND) {
-        ptr = ecs_parse_ws(ptr + 1);
-        ptr = flecs_parse_arguments(world, name, expr, (ptr - expr), ptr, token, 
-            NULL, extra_oper, extra_args);
-        if (!ptr) {
-            goto error;
-        }
-    } else if (extra_oper && ptr[0] == TOK_OR[0] && ptr[1] == TOK_OR[1]) {
-        ptr = ecs_parse_ws_eol(ptr + 2);
-        *extra_oper = EcsOr;
-        ptr = flecs_parse_arguments(world, name, expr, (ptr - expr), ptr, token, 
-            NULL, extra_oper, extra_args);
-        if (!ptr) {
-            goto error;
-        }
+        /* Ensure provided generation matches current. Only allow mismatching
+         * generations if the provided generation count is 0. This allows for
+         * using the ensure function in combination with ids that have their
+         * generation stripped. */
+#ifdef FLECS_DEBUG
+        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+        ecs_assert(!gen || dense_array[dense] == (index | gen), ECS_INTERNAL_ERROR, NULL);
+#endif
     } else {
-        ptr ++;
-    }
+        /* Element is not paired yet. Must add a new element to dense array */
+        flecs_sparse_grow_dense(sparse);
 
-    ptr = ecs_parse_ws(ptr);
-    goto parse_done;
+        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);    
+        int32_t dense_count = ecs_vec_count(&sparse->dense) - 1;
+        int32_t count = sparse->count ++;
 
-parse_done:
-    *term_out = term;
-    return ptr;
+        /* If index is larger than max id, update max id */
+        if (index >= flecs_sparse_get_id(sparse)) {
+            flecs_sparse_set_id(sparse, index);
+        }
 
-error:
-    ecs_term_fini(&term);
-    *term_out = (ecs_term_t){0};
-    return NULL;
-}
+        if (count < dense_count) {
+            /* If there are unused elements in the list, move the first unused
+             * element to the end of the list */
+            uint64_t unused = dense_array[count];
+            ecs_page_t *unused_page = flecs_sparse_get_or_create_page(sparse, PAGE(unused));
+            flecs_sparse_assign_index(unused_page, dense_array, unused, dense_count);
+        }
 
-static
-bool flecs_is_valid_end_of_term(
-    const char *ptr)
-{
-    if ((ptr[0] == TOK_AND) ||    /* another term with And operator */
-        (ptr[0] == TOK_OR[0]) ||  /* another term with Or operator */
-        (ptr[0] == '\n') ||       /* newlines are valid */
-        (ptr[0] == '\0') ||       /* end of string */
-        (ptr[0] == '/') ||        /* comment (in plecs) */
-        (ptr[0] == '{') ||        /* scope (in plecs) */
-        (ptr[0] == '}') ||
-        (ptr[0] == '[') ||        /* collection scope (in plecs) */
-        (ptr[0] == ']') ||
-        (ptr[0] == ':') ||        /* inheritance (in plecs) */
-        (ptr[0] == '='))          /* assignment (in plecs) */
-    {
-        return true;
+        flecs_sparse_assign_index(page, dense_array, index, count);
+        dense_array[count] |= gen;
     }
-    return false;
+
+    return DATA(page->data, sparse->size, offset);
 }
 
-char* ecs_parse_term(
-    const ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_term_t *term,
-    ecs_oper_kind_t *extra_oper,
-    ecs_term_id_t *extra_args,
-    bool allow_newline)
+void* flecs_sparse_ensure_fast(
+    ecs_sparse_t *sparse,
+    ecs_size_t size,
+    uint64_t index_long)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    if (extra_oper) {
-        *extra_oper = EcsAnd;
-    }
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(ecs_vec_count(&sparse->dense) > 0, ECS_INTERNAL_ERROR, NULL);
+    (void)size;
 
-    ecs_term_id_t *src = &term->src;
+    uint32_t index = (uint32_t)index_long;
+    ecs_page_t *page = flecs_sparse_get_or_create_page(sparse, PAGE(index));
+    int32_t offset = OFFSET(index);
+    int32_t dense = page->sparse[offset];
+    int32_t count = sparse->count;
 
-    if (ptr != expr) {
-        if (ptr[0]) {
-            if (ptr[0] == ',') {
-                ptr ++;
-            } else if (ptr[0] == '|') {
-                ptr += 2;
-            } else if (ptr[0] == '{') {
-                ptr ++;
-            } else if (ptr[0] == '}') {
-                /* nothing to be done */
-            } else {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "invalid preceding token");
-            }
+    if (!dense) {
+        /* Element is not paired yet. Must add a new element to dense array */
+        sparse->count = count + 1;
+        if (count == ecs_vec_count(&sparse->dense)) {
+            flecs_sparse_grow_dense(sparse);
         }
-    }
-
-    ptr = ecs_parse_ws_eol(ptr);
-    if (!ptr[0]) {
-        *term = (ecs_term_t){0};
-        return ECS_CONST_CAST(char*, ptr);
-    }
-
-    if (ptr == expr && !strcmp(expr, "0")) {
-        return ECS_CONST_CAST(char*, &ptr[1]);
-    }
-
-    /* Parse next element */
-    ptr = flecs_parse_term(world, name, ptr, term, extra_oper, extra_args);
-    if (!ptr) {
-        goto error;
-    }
-
-    /* Check for $() notation */
-    if (term->first.name && !ecs_os_strcmp(term->first.name, "$")) {
-        if (term->src.name) {
-            /* Safe, parser owns name */
-            ecs_os_free(ECS_CONST_CAST(char*, term->first.name));
-            
-            term->first = term->src;
 
-            if (term->second.name) {
-                term->src = term->second;       
-            } else {
-                term->src.id = EcsThis;
-                term->src.name = NULL;
-                term->src.flags |= EcsIsVariable;
-            }
-
-            const char *var_name = strrchr(term->first.name, '.');
-            if (var_name) {
-                var_name ++;
-            } else {
-                var_name = term->first.name;
-            }
-
-            term->second.name = ecs_os_strdup(var_name);
-            term->second.flags |= EcsIsVariable;
-        }
+        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+        flecs_sparse_assign_index(page, dense_array, index, count);
     }
 
-    /* Post-parse consistency checks */
+    return DATA(page->data, sparse->size, offset);
+}
 
-    /* If next token is OR, term is part of an OR expression */
-    if (!ecs_os_strncmp(ptr, TOK_OR, 2)) {
-        /* An OR operator must always follow an AND or another OR */
-        if (term->oper != EcsAnd) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "cannot combine || with other operators");
-            goto error;
-        }
+void flecs_sparse_remove(
+    ecs_sparse_t *sparse,
+    ecs_size_t size,
+    uint64_t index)
+{
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
+    (void)size;
 
-        term->oper = EcsOr;
+    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
+    if (!page || !page->sparse) {
+        return;
     }
 
-    /* Term must either end in end of expression, AND or OR token */
-    if (!flecs_is_valid_end_of_term(ptr)) {
-        if (!flecs_isident(ptr[0]) || ((ptr != expr) && (ptr[-1] != ' '))) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "expected end of expression or next term");
-            goto error;
-        }
-    }
+    uint64_t gen = flecs_sparse_strip_generation(&index);
+    int32_t offset = OFFSET(index);
+    int32_t dense = page->sparse[offset];
 
-    /* If the term just contained a 0, the expression has nothing. Ensure
-     * that after the 0 nothing else follows */
-    if (term->first.name && !ecs_os_strcmp(term->first.name, "0")) {
-        if (ptr[0]) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unexpected term after 0"); 
-            goto error;
+    if (dense) {
+        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+        uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK;
+        if (gen != cur_gen) {
+            /* Generation doesn't match which means that the provided entity is
+             * already not alive. */
+            return;
         }
 
-        if (src->flags != 0) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "invalid combination of 0 with non-default subject");
-            goto error;
+        /* Increase generation */
+        dense_array[dense] = index | flecs_sparse_inc_gen(cur_gen);
+        
+        int32_t count = sparse->count;
+        
+        if (dense == (count - 1)) {
+            /* If dense is the last used element, simply decrease count */
+            sparse->count --;
+        } else if (dense < count) {
+            /* If element is alive, move it to unused elements */
+            flecs_sparse_swap_dense(sparse, page, dense, count - 1);
+            sparse->count --;
+        } else {
+            /* Element is not alive, nothing to be done */
+            return;
         }
 
-        src->flags = EcsIsEntity;
-        src->id = 0;
-        /* Safe, parser owns string */
-        ecs_os_free(ECS_CONST_CAST(char*, term->first.name));
-        term->first.name = NULL;
+        /* Reset memory to zero on remove */
+        void *ptr = DATA(page->data, sparse->size, offset);
+        ecs_os_memset(ptr, 0, size);
+    } else {
+        /* Element is not paired and thus not alive, nothing to be done */
+        return;
     }
+}
 
-    /* Cannot combine EcsIsEntity/0 with operators other than AND */
-    if (term->oper != EcsAnd && ecs_term_match_0(term)) {
-        if (term->first.id != EcsScopeOpen && term->first.id != EcsScopeClose) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "invalid operator for empty source"); 
-            goto error;
-        }
-    }
-
-    /* Automatically assign This if entity is not assigned and the set is
-     * nothing */
-    if (!(src->flags & EcsIsEntity)) {
-        if (!src->name) {
-            if (!src->id) {
-                src->id = EcsThis;
-                src->flags |= EcsIsVariable;
-            }
-        }
-    }
+void* flecs_sparse_get_dense(
+    const ecs_sparse_t *sparse,
+    ecs_size_t size,
+    int32_t dense_index)
+{
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(dense_index < sparse->count, ECS_INVALID_PARAMETER, NULL);
+    (void)size;
 
-    if (src->name && !ecs_os_strcmp(src->name, "0")) {
-        src->id = 0;
-        src->flags = EcsIsEntity;
-    }
+    dense_index ++;
 
-    /* Process role */
-    if (term->id_flags == ECS_AND) {
-        term->oper = EcsAndFrom;
-        term->id_flags = 0;
-    } else if (term->id_flags == ECS_OR) {
-        term->oper = EcsOrFrom;
-        term->id_flags = 0;
-    } else if (term->id_flags == ECS_NOT) {
-        term->oper = EcsNotFrom;
-        term->id_flags = 0;
-    }
+    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+    return flecs_sparse_get_sparse(sparse, dense_index, dense_array[dense_index]);
+}
 
-    if (allow_newline) {
-        ptr = ecs_parse_ws_eol(ptr);
-    } else {
-        ptr = ecs_parse_ws(ptr);
+bool flecs_sparse_is_alive(
+    const ecs_sparse_t *sparse,
+    uint64_t index)
+{
+    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
+    if (!page || !page->sparse) {
+        return false;
     }
 
-    return ECS_CONST_CAST(char*, ptr);
-error:
-    if (term) {
-        ecs_term_fini(term);
+    int32_t offset = OFFSET(index);
+    int32_t dense = page->sparse[offset];
+    if (!dense || (dense >= sparse->count)) {
+        return false;
     }
-    return NULL;
-}
-
-#endif
-
-/**
- * @file addons/plecs.c
- * @brief Plecs addon.
- */
-
-
-#ifdef FLECS_PLECS
-
-ECS_COMPONENT_DECLARE(EcsScript);
-
-#include <ctype.h>
-
-#define TOK_NEWLINE '\n'
-#define TOK_USING "using"
-#define TOK_MODULE "module"
-#define TOK_WITH "with"
-#define TOK_CONST "const"
-#define TOK_PROP "prop"
-#define TOK_ASSEMBLY "assembly"
 
-#define STACK_MAX_SIZE (64)
-
-typedef struct {
-    ecs_value_t value;
-    bool owned;
-} plecs_with_value_t;
-
-typedef struct {
-    const char *name;
-    const char *code;
-
-    ecs_entity_t last_predicate;
-    ecs_entity_t last_subject;
-    ecs_entity_t last_object;
-
-    ecs_id_t last_assign_id;
-    ecs_entity_t assign_to;
-
-    ecs_entity_t scope[STACK_MAX_SIZE];
-    ecs_entity_t default_scope_type[STACK_MAX_SIZE];
-    ecs_entity_t with[STACK_MAX_SIZE];
-    ecs_entity_t using[STACK_MAX_SIZE];
-    int32_t with_frames[STACK_MAX_SIZE];
-    plecs_with_value_t with_value_frames[STACK_MAX_SIZE];
-    int32_t using_frames[STACK_MAX_SIZE];
-    int32_t sp;
-    int32_t with_frame;
-    int32_t using_frame;
-    ecs_entity_t global_with;
-    ecs_entity_t assembly;
-    const char *assembly_start, *assembly_stop;
-
-    char *annot[STACK_MAX_SIZE];
-    int32_t annot_count;
-
-    ecs_vars_t vars;
-    char var_name[256];
-    ecs_entity_t var_type;
-
-    bool with_stmt;
-    bool scope_assign_stmt;
-    bool assign_stmt;
-    bool assembly_stmt;
-    bool assembly_instance;
-    bool isa_stmt;
-    bool decl_stmt;
-    bool decl_type;
-    bool var_stmt;
-    bool var_is_prop;
-    bool is_module;
-
-    int32_t errors;
-} plecs_state_t;
-
-static
-int flecs_plecs_parse(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    ecs_vars_t *vars,
-    ecs_entity_t script,
-    ecs_entity_t instance);
-
-static void flecs_dtor_script(EcsScript *ptr) {
-    ecs_os_free(ptr->script);
-    ecs_vec_fini_t(NULL, &ptr->using_, ecs_entity_t);
+    uint64_t gen = flecs_sparse_strip_generation(&index);
+    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+    uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK;
 
-    int i, count = ptr->prop_defaults.count;
-    ecs_value_t *values = ptr->prop_defaults.array;
-    for (i = 0; i < count; i ++) {
-        ecs_value_free(ptr->world, values[i].type, values[i].ptr);
+    if (cur_gen != gen) {
+        return false;
     }
 
-    ecs_vec_fini_t(NULL, &ptr->prop_defaults, ecs_value_t);
+    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
+    return true;
 }
 
-static
-ECS_MOVE(EcsScript, dst, src, {
-    flecs_dtor_script(dst);
-    dst->using_ = src->using_;
-    dst->prop_defaults = src->prop_defaults;
-    dst->script = src->script;
-    dst->world = src->world;
-    ecs_os_zeromem(&src->using_);
-    ecs_os_zeromem(&src->prop_defaults);
-    src->script = NULL;
-    src->world = NULL;
-})
-
-static
-ECS_DTOR(EcsScript, ptr, {
-    flecs_dtor_script(ptr);
-})
-
-/* Assembly ctor to initialize with default property values */
-static
-void flecs_assembly_ctor(
-    void *ptr,
-    int32_t count,
-    const ecs_type_info_t *ti)
+void* flecs_sparse_try(
+    const ecs_sparse_t *sparse,
+    ecs_size_t size,
+    uint64_t index)
 {
-    ecs_world_t *world = ti->hooks.ctx;
-    ecs_entity_t assembly = ti->component;
-    const EcsStruct *st = ecs_get(world, assembly, EcsStruct);
-
-    if (!st) {
-        ecs_err("assembly '%s' is not a struct, cannot construct", ti->name);
-        return;
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
+    (void)size;
+    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
+    if (!page || !page->sparse) {
+        return NULL;
     }
 
-    const EcsScript *script = ecs_get(world, assembly, EcsScript);
-    if (!script) {
-        ecs_err("assembly '%s' is not a script, cannot construct", ti->name);
-        return;
+    int32_t offset = OFFSET(index);
+    int32_t dense = page->sparse[offset];
+    if (!dense || (dense >= sparse->count)) {
+        return NULL;
     }
 
-    if (st->members.count != script->prop_defaults.count) {
-        ecs_err("number of props (%d) of assembly '%s' does not match members"
-            " (%d), cannot construct", script->prop_defaults.count, 
-                ti->name, st->members.count);
-        return;
+    uint64_t gen = flecs_sparse_strip_generation(&index);
+    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+    uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK;
+    if (cur_gen != gen) {
+        return NULL;
     }
 
-    const ecs_member_t *members = st->members.array;
-    int32_t i, m, member_count = st->members.count;
-    ecs_value_t *values = script->prop_defaults.array;
-    for (m = 0; m < member_count; m ++) {
-        const ecs_member_t *member = &members[m];
-        ecs_value_t *value = &values[m];
-        const ecs_type_info_t *mti = ecs_get_type_info(world, member->type);
-        if (!mti) {
-            ecs_err("failed to get type info for prop '%s' of assembly '%s'",
-                member->name, ti->name);
-            return;
-        }
-
-        for (i = 0; i < count; i ++) {
-            void *el = ECS_ELEM(ptr, ti->size, i);
-            ecs_value_copy_w_type_info(world, mti, 
-                ECS_OFFSET(el, member->offset), value->ptr);
-        }
-    }
+    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
+    return DATA(page->data, sparse->size, offset);
 }
 
-/* Assembly on_set handler to update contents for new property values */
-static
-void flecs_assembly_on_set(
-    ecs_iter_t *it)
+void* flecs_sparse_get(
+    const ecs_sparse_t *sparse,
+    ecs_size_t size,
+    uint64_t index)
 {
-    if (it->table->flags & EcsTableIsPrefab) {
-        /* Don't instantiate assemblies for prefabs */
-        return;
-    }
-
-    ecs_world_t *world = it->world;
-    ecs_entity_t assembly = ecs_field_id(it, 1);
-    const char *name = ecs_get_name(world, assembly);
-    ecs_record_t *r = ecs_record_find(world, assembly);
-
-    const EcsComponent *ct = ecs_record_get(world, r, EcsComponent);
-    ecs_get(world, assembly, EcsComponent);
-    if (!ct) {
-        ecs_err("assembly '%s' is not a component", name);
-        return;
-    }
-
-    const EcsStruct *st = ecs_record_get(world, r, EcsStruct);
-    if (!st) {
-        ecs_err("assembly '%s' is not a struct", name);
-        return;
-    }
-
-    const EcsScript *script = ecs_record_get(world, r, EcsScript);
-    if (!script) {
-        ecs_err("assembly '%s' is missing a script", name);
-        return;
-    }
-
-    void *data = ecs_field_w_size(it, flecs_ito(size_t, ct->size), 1);
-
-    int32_t i, m;
-    for (i = 0; i < it->count; i ++) {
-        /* Create variables to hold assembly properties */
-        ecs_vars_t vars = {0};
-        ecs_vars_init(world, &vars);
-
-        /* Populate properties from assembly members */
-        const ecs_member_t *members = st->members.array;
-        for (m = 0; m < st->members.count; m ++) {
-            const ecs_member_t *member = &members[m];
-
-            ecs_value_t v = {0}; /* Prevent allocating value */
-            ecs_expr_var_t *var = ecs_vars_declare_w_value(
-                &vars, member->name, &v);
-            if (var == NULL) {
-                ecs_err("could not create prop '%s' for assembly '%s'", 
-                    member->name, name);
-                break;
-            }
-
-            /* Assign assembly property from assembly instance */
-            var->value.type = member->type;
-            var->value.ptr = ECS_OFFSET(data, member->offset);
-            var->owned = false;
-        }
-
-        /* Populate $this variable with instance entity */
-        ecs_entity_t instance = it->entities[i];
-        ecs_value_t v = {0};
-        ecs_expr_var_t *var = ecs_vars_declare_w_value(
-            &vars, "this", &v);
-        var->value.type = ecs_id(ecs_entity_t);
-        var->value.ptr = &instance;
-        var->owned = false;
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
+    (void)size;
 
-        /* Update script with new code/properties */
-        ecs_script_update(world, assembly, instance, script->script, &vars);
-        ecs_vars_fini(&vars);
+    ecs_page_t *page = ecs_vec_get_t(&sparse->pages, ecs_page_t, PAGE(index));
+    int32_t offset = OFFSET(index);
+    int32_t dense = page->sparse[offset];
+    ecs_assert(dense != 0, ECS_INTERNAL_ERROR, NULL);
 
-        if (ecs_record_has_id(world, r, EcsFlatten)) {
-            ecs_flatten(it->real_world, ecs_childof(instance), NULL);
-        }
+    uint64_t gen = flecs_sparse_strip_generation(&index);
+    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
+    uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK;
+    (void)cur_gen; (void)gen;
 
-        data = ECS_OFFSET(data, ct->size);
-    }
+    ecs_assert(cur_gen == gen, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(dense < sparse->count, ECS_INTERNAL_ERROR, NULL);
+    return DATA(page->data, sparse->size, offset);
 }
 
-/* Delete contents of assembly instance */
-static
-void flecs_assembly_on_remove(
-    ecs_iter_t *it)
+void* flecs_sparse_get_any(
+    const ecs_sparse_t *sparse,
+    ecs_size_t size,
+    uint64_t index)
 {
-    int32_t i;
-    for (i = 0; i < it->count; i ++) {
-        ecs_entity_t instance = it->entities[i];
-        ecs_script_clear(it->world, 0, instance);
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
+    (void)size;
+    
+    flecs_sparse_strip_generation(&index);
+    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
+    if (!page || !page->sparse) {
+        return NULL;
     }
-}
-
-/* Set default property values on assembly Script component */
-static
-int flecs_assembly_init_defaults(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_entity_t assembly,
-    EcsScript *script,
-    plecs_state_t *state)
-{
-    const EcsStruct *st = ecs_get(world, assembly, EcsStruct);
-    int32_t i, count = st->members.count;
-    const ecs_member_t *members = st->members.array;
-
-    ecs_vec_init_t(NULL, &script->prop_defaults, ecs_value_t, count);
-
-    for (i = 0; i < count; i ++) {
-        const ecs_member_t *member = &members[i];
-        ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, member->name);
-        if (!var) {
-            char *assembly_name = ecs_get_fullpath(world, assembly);
-            ecs_parser_error(name, expr, ptr - expr, 
-                "missing property '%s' for assembly '%s'", 
-                    member->name, assembly_name);
-            ecs_os_free(assembly_name);
-            return -1;
-        }
-
-        if (member->type != var->value.type) {
-            char *assembly_name = ecs_get_fullpath(world, assembly);
-            ecs_parser_error(name, expr, ptr - expr, 
-                "property '%s' for assembly '%s' has mismatching type", 
-                    member->name, assembly_name);
-            ecs_os_free(assembly_name);
-            return -1;
-        }
 
-        ecs_value_t *pv = ecs_vec_append_t(NULL, 
-            &script->prop_defaults, ecs_value_t);
-        pv->type = member->type;
-        pv->ptr = var->value.ptr;
-        var->owned = false; /* Transfer ownership */
+    int32_t offset = OFFSET(index);
+    int32_t dense = page->sparse[offset];
+    bool in_use = dense && (dense < sparse->count);
+    if (!in_use) {
+        return NULL;
     }
 
-    return 0;
+    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
+    return DATA(page->data, sparse->size, offset);
 }
 
-/* Create new assembly */
-static
-int flecs_assembly_create(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_entity_t assembly,
-    char *script_code,
-    plecs_state_t *state)
+int32_t flecs_sparse_count(
+    const ecs_sparse_t *sparse)
 {
-    const EcsStruct *st = ecs_get(world, assembly, EcsStruct);
-    if (!st || !st->members.count) {
-        char *assembly_name = ecs_get_fullpath(world, assembly);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "assembly '%s' has no properties", assembly_name);
-        ecs_os_free(assembly_name);
-        ecs_os_free(script_code);
-        return -1;
-    }
-
-    ecs_add_id(world, assembly, EcsAlwaysOverride);
-
-    EcsScript *script = ecs_ensure(world, assembly, EcsScript);
-    flecs_dtor_script(script);
-    script->world = world;
-    script->script = script_code;
-    ecs_vec_reset_t(NULL, &script->using_, ecs_entity_t);
-
-    ecs_entity_t scope = ecs_get_scope(world);
-    if (scope && (scope = ecs_get_target(world, scope, EcsChildOf, 0))) {
-        ecs_vec_append_t(NULL, &script->using_, ecs_entity_t)[0] = scope;
+    if (!sparse || !sparse->count) {
+        return 0;
     }
 
-    int i, count = state->using_frame;
-    for (i = 0; i < count; i ++) {
-        ecs_vec_append_t(NULL, &script->using_, ecs_entity_t)[0] = 
-            state->using[i];
-    }
+    return sparse->count - 1;
+}
 
-    if (flecs_assembly_init_defaults(
-        world, name, expr, ptr, assembly, script, state)) 
-    {
-        return -1;    
+const uint64_t* flecs_sparse_ids(
+    const ecs_sparse_t *sparse)
+{
+    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    if (sparse->dense.array) {
+        return &(ecs_vec_first_t(&sparse->dense, uint64_t)[1]);
+    } else {
+        return NULL;
     }
+}
 
-    ecs_modified(world, assembly, EcsScript);
+void ecs_sparse_init(
+    ecs_sparse_t *sparse,
+    ecs_size_t elem_size)
+{
+    flecs_sparse_init(sparse, NULL, NULL, elem_size);
+}
 
-    ecs_set_hooks_id(world, assembly, &(ecs_type_hooks_t) {
-        .ctor = flecs_assembly_ctor,
-        .on_set = flecs_assembly_on_set,
-        .on_remove = flecs_assembly_on_remove,
-        .ctx = world
-    });
+void* ecs_sparse_add(
+    ecs_sparse_t *sparse,
+    ecs_size_t elem_size)
+{
+    return flecs_sparse_add(sparse, elem_size);
+}
 
-    return 0;
+uint64_t ecs_sparse_last_id(
+    const ecs_sparse_t *sparse)
+{
+    return flecs_sparse_last_id(sparse);
 }
 
-/* Parser */
+int32_t ecs_sparse_count(
+    const ecs_sparse_t *sparse)
+{
+    return flecs_sparse_count(sparse);
+}
 
-static
-bool plecs_is_newline_comment(
-    const char *ptr)
+void* ecs_sparse_get_dense(
+    const ecs_sparse_t *sparse,
+    ecs_size_t elem_size,
+    int32_t index)
 {
-    if (ptr[0] == '/' && ptr[1] == '/') {
-        return true;
-    }
-    return false;
+    return flecs_sparse_get_dense(sparse, elem_size, index);
 }
 
-static
-const char* plecs_parse_fluff(
-    const char *ptr)
+void* ecs_sparse_get(
+    const ecs_sparse_t *sparse,
+    ecs_size_t elem_size,
+    uint64_t id)
 {
-    do {
-        /* Skip whitespaces before checking for a comment */
-        ptr = ecs_parse_ws(ptr);
+    return flecs_sparse_get(sparse, elem_size, id);
+}
 
-        /* Newline comment, skip until newline character */
-        if (plecs_is_newline_comment(ptr)) {
-            ptr += 2;
+/**
+ * @file datastructures/stack_allocator.c
+ * @brief Stack allocator.
+ * 
+ * The stack allocator enables pushing and popping values to a stack, and has
+ * a lower overhead when compared to block allocators. A stack allocator is a
+ * good fit for small temporary allocations.
+ * 
+ * The stack allocator allocates memory in pages. If the requested size of an
+ * allocation exceeds the page size, a regular allocator is used instead.
+ */
 
-            while (ptr[0] && ptr[0] != TOK_NEWLINE) {
-                ptr ++;
-            }
-        }
 
-        /* If a newline character is found, skip it */
-        if (ptr[0] == TOK_NEWLINE) {
-            ptr ++;
-        }
+#define FLECS_STACK_PAGE_OFFSET ECS_ALIGN(ECS_SIZEOF(ecs_stack_page_t), 16)
 
-    } while (isspace(ptr[0]) || plecs_is_newline_comment(ptr));
+int64_t ecs_stack_allocator_alloc_count = 0;
+int64_t ecs_stack_allocator_free_count = 0;
 
-    return ptr;
+static
+ecs_stack_page_t* flecs_stack_page_new(uint32_t page_id) {
+    ecs_stack_page_t *result = ecs_os_malloc(
+        FLECS_STACK_PAGE_OFFSET + ECS_STACK_PAGE_SIZE);
+    result->data = ECS_OFFSET(result, FLECS_STACK_PAGE_OFFSET);
+    result->next = NULL;
+    result->id = page_id + 1;
+    ecs_os_linc(&ecs_stack_allocator_alloc_count);
+    return result;
 }
 
-static
-ecs_entity_t plecs_lookup(
-    const ecs_world_t *world,
-    const char *path,
-    plecs_state_t *state,
-    ecs_entity_t rel,
-    bool is_subject)
+void* flecs_stack_alloc(
+    ecs_stack_t *stack, 
+    ecs_size_t size,
+    ecs_size_t align)
 {
-    ecs_entity_t e = 0;
+    ecs_assert(size > 0, ECS_INTERNAL_ERROR, NULL);
 
-    if (!is_subject) {
-        ecs_entity_t oneof = 0;
-        if (rel) {
-            if (ecs_has_id(world, rel, EcsOneOf)) {
-                oneof = rel;
-            } else {
-                oneof = ecs_get_target(world, rel, EcsOneOf, 0);
-            }
-            if (oneof) {
-                return ecs_lookup_path_w_sep(
-                    world, oneof, path, NULL, NULL, false);
-            }
+    ecs_stack_page_t *page = stack->tail_page;
+    if (page == &stack->first && !page->data) {
+        page->data = ecs_os_malloc(ECS_STACK_PAGE_SIZE);
+        ecs_os_linc(&ecs_stack_allocator_alloc_count);
+    }
+
+    int16_t sp = flecs_ito(int16_t, ECS_ALIGN(page->sp, align));
+    int16_t next_sp = flecs_ito(int16_t, sp + size);
+    void *result = NULL;
+
+    if (next_sp > ECS_STACK_PAGE_SIZE) {
+        if (size > ECS_STACK_PAGE_SIZE) {
+            result = ecs_os_malloc(size); /* Too large for page */
+            goto done;
         }
-        int using_scope = state->using_frame - 1;
-        for (; using_scope >= 0; using_scope--) {
-            e = ecs_lookup_path_w_sep(
-                world, state->using[using_scope], path, NULL, NULL, false);
-            if (e) {
-                break;
-            }
+
+        if (page->next) {
+            page = page->next;
+        } else {
+            page = page->next = flecs_stack_page_new(page->id);
         }
+        sp = 0;
+        next_sp = flecs_ito(int16_t, size);
+        stack->tail_page = page;
     }
 
-    if (!e) {
-        e = ecs_lookup_path_w_sep(world, 0, path, NULL, NULL, !is_subject);
-    }
+    page->sp = next_sp;
+    result = ECS_OFFSET(page->data, sp);
 
-    return e;
+done:
+#ifdef FLECS_SANITIZE
+    ecs_os_memset(result, 0xAA, size);
+#endif
+    return result;
 }
 
-/* Lookup action used for deserializing entity refs in component values */
-static
-ecs_entity_t plecs_lookup_action(
-    const ecs_world_t *world,
-    const char *path,
-    void *ctx)
+void* flecs_stack_calloc(
+    ecs_stack_t *stack, 
+    ecs_size_t size,
+    ecs_size_t align)
 {
-    return plecs_lookup(world, path, ctx, 0, false);
+    void *ptr = flecs_stack_alloc(stack, size, align);
+    ecs_os_memset(ptr, 0, size);
+    return ptr;
 }
 
-static
-void plecs_apply_with_frame(
-    ecs_world_t *world,
-    plecs_state_t *state,
-    ecs_entity_t e)
+void flecs_stack_free(
+    void *ptr,
+    ecs_size_t size)
 {
-    int32_t i, frame_count = state->with_frames[state->sp];
-    for (i = 0; i < frame_count; i ++) {
-        ecs_id_t id = state->with[i];
-        plecs_with_value_t *v = &state->with_value_frames[i];
-        if (v->value.type) {
-            void *ptr = ecs_ensure_id(world, e, id);
-            ecs_value_copy(world, v->value.type, ptr, v->value.ptr);
-            ecs_modified_id(world, e, id);
-        } else {
-            ecs_add_id(world, e, id);
-        }
+    if (size > ECS_STACK_PAGE_SIZE) {
+        ecs_os_free(ptr);
     }
 }
 
-static
-ecs_entity_t plecs_ensure_entity(
-    ecs_world_t *world,
-    plecs_state_t *state,
-    const char *path,
-    ecs_entity_t rel,
-    bool is_subject)
+ecs_stack_cursor_t* flecs_stack_get_cursor(
+    ecs_stack_t *stack)
 {
-    if (!path) {
-        return 0;
-    }
+    ecs_assert(stack != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_entity_t e = 0;
-    bool is_anonymous = !ecs_os_strcmp(path, "_");
-    bool is_new = false;
-    if (is_anonymous) {
-        path = NULL;
-        e = ecs_new_id(world);
-        is_new = true;
-    }
+    ecs_stack_page_t *page = stack->tail_page;
+    int16_t sp = stack->tail_page->sp;
+    ecs_stack_cursor_t *result = flecs_stack_alloc_t(stack, ecs_stack_cursor_t);
+    result->page = page;
+    result->sp = sp;
+    result->is_free = false;
 
-    if (!e) {
-        e = plecs_lookup(world, path, state, rel, is_subject);
-    }
+#ifdef FLECS_DEBUG
+    ++ stack->cursor_count;
+    result->owner = stack;
+#endif
 
-    if (!e) {
-        is_new = true;
-        if (rel && flecs_get_oneof(world, rel)) {
-            /* If relationship has oneof and entity was not found, don't proceed
-             * with creating an entity as this can cause asserts later on */
-            char *relstr = ecs_get_fullpath(world, rel);
-            ecs_parser_error(state->name, 0, 0, 
-                "invalid identifier '%s' for relationship '%s'", path, relstr);
-            ecs_os_free(relstr);
-            return 0;
-        }
+    result->prev = stack->tail_cursor;
+    stack->tail_cursor = result;
+    return result;
+}
 
-        ecs_entity_t prev_scope = 0;
-        ecs_entity_t prev_with = 0;
-        if (!is_subject) {
-            /* Don't apply scope/with for non-subject entities */
-            prev_scope = ecs_set_scope(world, 0);
-            prev_with = ecs_set_with(world, 0);
-        }
+#define FLECS_STACK_LEAK_MSG \
+    "a stack allocator leak is most likely due to an unterminated " \
+    "iteration: call ecs_iter_fini to fix"
 
-        e = ecs_add_path(world, e, 0, path);
-        ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL);
+void flecs_stack_restore_cursor(
+    ecs_stack_t *stack,
+    ecs_stack_cursor_t *cursor)
+{
+    if (!cursor) {
+        return;
+    }
 
-        if (prev_scope) {
-            ecs_set_scope(world, prev_scope);
-        }
-        if (prev_with) {
-            ecs_set_with(world, prev_with);
-        }
-    } else {
-        /* If entity exists, make sure it gets the right scope and with */
-        if (is_subject) {
-            ecs_entity_t scope = ecs_get_scope(world);
-            if (scope) {
-                ecs_add_pair(world, e, EcsChildOf, scope);
-            }
+    ecs_dbg_assert(stack == cursor->owner, ECS_INVALID_OPERATION, 
+        "attempting to restore a cursor for the wrong stack");
+    ecs_dbg_assert(stack->cursor_count > 0, ECS_DOUBLE_FREE, 
+        "double free detected in stack allocator");
+    ecs_assert(cursor->is_free == false, ECS_DOUBLE_FREE,
+        "double free detected in stack allocator");
 
-            ecs_entity_t with = ecs_get_with(world);
-            if (with) {
-                ecs_add_id(world, e, with);
-            }
-        }
+    cursor->is_free = true;
+
+#ifdef FLECS_DEBUG    
+    -- stack->cursor_count;
+#endif
+
+    /* If cursor is not the last on the stack no memory should be freed */
+    if (cursor != stack->tail_cursor) {
+        return;
     }
 
-    if (is_new) {
-        if (state->assembly && !state->assembly_instance) {
-            ecs_add_id(world, e, EcsPrefab);
+    /* Iterate freed cursors to know how much memory we can free */
+    do {
+        ecs_stack_cursor_t* prev = cursor->prev;
+        if (!prev || !prev->is_free) {
+            break; /* Found active cursor, free up until this point */
         }
+        cursor = prev;
+    } while (cursor);
 
-        if (state->global_with) {
-            ecs_add_id(world, e, state->global_with);
-        }
-    }
+    stack->tail_cursor = cursor->prev;
+    stack->tail_page = cursor->page;
+    stack->tail_page->sp = cursor->sp;
 
-    return e;
+    /* If the cursor count is zero, stack should be empty
+     * if the cursor count is non-zero, stack should not be empty */
+    ecs_dbg_assert((stack->cursor_count == 0) == 
+        (stack->tail_page == &stack->first && stack->tail_page->sp == 0), 
+            ECS_LEAK_DETECTED, FLECS_STACK_LEAK_MSG);
 }
 
-static
-ecs_entity_t plecs_ensure_term_id(
-    ecs_world_t *world,
-    plecs_state_t *state,
-    ecs_term_id_t *term_id,
-    const char *expr,
-    int64_t column,
-    ecs_entity_t pred,
-    bool is_subject)
+void flecs_stack_reset(
+    ecs_stack_t *stack)
 {
-    ecs_entity_t result = 0;
-    const char *name = term_id->name;
-    if (term_id->flags & EcsIsVariable) {
-        if (name != NULL) {
-            ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, name);
-            if (!var) {
-                ecs_parser_error(name, expr, column,
-                    "unresolved variable '%s'", name);
-                return 0;
-            }
-            if (var->value.type != ecs_id(ecs_entity_t)) {
-                ecs_parser_error(name, expr, column,
-                    "variable '%s' is not an entity", name);
-                return 0;
-            }
-            result = *(ecs_entity_t*)var->value.ptr;
-            if (!result) {
-                ecs_parser_error(name, expr, column,
-                    "variable '%s' is not initialized with valid entity", name);
-                return 0;
-            }
-        } else if (term_id->id) {
-            result = term_id->id;
-        } else {
-            ecs_parser_error(name, expr, column, "invalid variable in term");
-            return 0;
-        }
-    } else {
-        result = plecs_ensure_entity(world, state, name, pred, is_subject);
-    }
-    return result;
+    ecs_dbg_assert(stack->cursor_count == 0, ECS_LEAK_DETECTED, 
+        FLECS_STACK_LEAK_MSG);
+    stack->tail_page = &stack->first;
+    stack->first.sp = 0;
+    stack->tail_cursor = NULL;
 }
 
-static
-bool plecs_pred_is_subj(
-    ecs_term_t *term,
-    plecs_state_t *state)
+void flecs_stack_init(
+    ecs_stack_t *stack)
 {
-    if (term->src.name != NULL) {
-        return false;
-    }
-    if (term->second.name != NULL) {
-        return false;
-    }
-    if (ecs_term_match_0(term)) {
-        return false;
-    }
-    if (state->with_stmt) {
-        return false;
-    }
-    if (state->assign_stmt) {
-        return false;
-    }
-    if (state->isa_stmt) {
-        return false;
-    }
-    if (state->decl_type) {
-        return false;
-    }
-
-    return true;
-}
-
-/* Set masks aren't useful in plecs, so translate them back to entity names */
-static
-const char* plecs_set_mask_to_name(
-    ecs_flags32_t flags) 
-{
-    flags &= EcsTraverseFlags;
-    if (flags == EcsSelf) {
-        return "self";
-    } else if (flags == EcsUp) {
-        return "up";
-    } else if (flags == EcsDown) {
-        return "down";
-    } else if (flags == EcsCascade || flags == (EcsUp|EcsCascade)) {
-        return "cascade";
-    } else if (flags == EcsParent) {
-        return "parent";
-    }
-    return NULL;
+    ecs_os_zeromem(stack);
+    stack->tail_page = &stack->first;
+    stack->first.data = NULL;
 }
 
-#ifdef FLECS_DOC
-static
-char* plecs_trim_annot(
-    char *annot)
+void flecs_stack_fini(
+    ecs_stack_t *stack)
 {
-    annot = ECS_CONST_CAST(char*, ecs_parse_ws(annot));
-    int32_t len = ecs_os_strlen(annot) - 1;
-    while (isspace(annot[len]) && (len > 0)) {
-        annot[len] = '\0';
-        len --;
-    }
-    return annot;
-}
-#endif
+    ecs_stack_page_t *next, *cur = &stack->first;
+    ecs_dbg_assert(stack->cursor_count == 0, ECS_LEAK_DETECTED, 
+        FLECS_STACK_LEAK_MSG);
+    ecs_assert(stack->tail_page == &stack->first, ECS_LEAK_DETECTED, 
+        FLECS_STACK_LEAK_MSG);
+    ecs_assert(stack->tail_page->sp == 0, ECS_LEAK_DETECTED, 
+        FLECS_STACK_LEAK_MSG);
 
-static
-void plecs_apply_annotations(
-    ecs_world_t *world,
-    ecs_entity_t subj,
-    plecs_state_t *state)
-{
-    (void)world;
-    (void)subj;
-    (void)state;
-#ifdef FLECS_DOC
-    int32_t i = 0, count = state->annot_count;
-    for (i = 0; i < count; i ++) {
-        char *annot = state->annot[i];
-        if (!ecs_os_strncmp(annot, "@brief ", 7)) {
-            annot = plecs_trim_annot(annot + 7);
-            ecs_doc_set_brief(world, subj, annot);
-        } else if (!ecs_os_strncmp(annot, "@link ", 6)) {
-            annot = plecs_trim_annot(annot + 6);
-            ecs_doc_set_link(world, subj, annot);
-        } else if (!ecs_os_strncmp(annot, "@name ", 6)) {
-            annot = plecs_trim_annot(annot + 6);
-            ecs_doc_set_name(world, subj, annot);
-        } else if (!ecs_os_strncmp(annot, "@color ", 7)) {
-            annot = plecs_trim_annot(annot + 7);
-            ecs_doc_set_color(world, subj, annot);
+    do {
+        next = cur->next;
+        if (cur == &stack->first) {
+            if (cur->data) {
+                ecs_os_linc(&ecs_stack_allocator_free_count);
+            }
+            ecs_os_free(cur->data);
+        } else {
+            ecs_os_linc(&ecs_stack_allocator_free_count);
+            ecs_os_free(cur);
         }
-    }
-#else
-    ecs_warn("cannot apply annotations, doc addon is missing");
-#endif
+    } while ((cur = next));
 }
 
-static
-int plecs_create_term(
-    ecs_world_t *world, 
-    ecs_term_t *term,
-    const char *name,
-    const char *expr,
-    int64_t column,
-    plecs_state_t *state)
-{
-    state->last_subject = 0;
-    state->last_predicate = 0;
-    state->last_object = 0;
-    state->last_assign_id = 0;
-
-    const char *subj_name = term->src.name;
-    if (!subj_name) {
-        subj_name = plecs_set_mask_to_name(term->src.flags);
-    }
-
-    if (!ecs_term_id_is_set(&term->first)) {
-        ecs_parser_error(name, expr, column, "missing term in expression");
-        return -1;
-    }
-
-    if (state->assign_stmt && !ecs_term_match_this(term)) {
-        ecs_parser_error(name, expr, column, 
-            "invalid statement in assign statement");
-        return -1;
-    }
-
-    bool pred_as_subj = plecs_pred_is_subj(term, state);
-    ecs_entity_t subj = 0, obj = 0, pred = plecs_ensure_term_id(
-        world, state, &term->first, expr, column, 0, pred_as_subj);
-    if (!pred) {
-        return -1;
-    }
-
-    subj = plecs_ensure_entity(world, state, subj_name, pred, true);
-
-    if (ecs_term_id_is_set(&term->second)) {
-        obj = plecs_ensure_term_id(world, state, &term->second, expr, column, 
-            pred, !state->assign_stmt && !state->with_stmt);
-        if (!obj) {
-            return -1;
-        }
-    }
-
-    if (state->assign_stmt || state->isa_stmt) {
-        subj = state->assign_to;
-    }
-
-    if (state->isa_stmt && obj) {
-        ecs_parser_error(name, expr, column, 
-            "invalid object in inheritance statement");
-        return -1;
-    }
-
-    if (state->isa_stmt) {
-        pred = ecs_pair(EcsIsA, pred);
-    }
+/**
+ * @file datastructures/strbuf.c
+ * @brief Utility for constructing strings.
+ *
+ * A buffer builds up a list of elements which individually can be up to N bytes
+ * large. While appending, data is added to these elements. More elements are
+ * added on the fly when needed. When an application calls ecs_strbuf_get, all
+ * elements are combined in one string and the element administration is freed.
+ *
+ * This approach prevents reallocs of large blocks of memory, and therefore
+ * copying large blocks of memory when appending to a large buffer. A buffer
+ * preallocates some memory for the element overhead so that for small strings
+ * there is hardly any overhead, while for large strings the overhead is offset
+ * by the reduced time spent on copying memory.
+ * 
+ * The functionality provided by strbuf is similar to std::stringstream.
+ */
 
-    if (subj == EcsVariable) {
-        subj = pred;
-    }
+#include <math.h>
 
-    if (subj) {
-        ecs_id_t id;
-        if (!obj) {
-            id = term->id_flags | pred;
-        } else {
-            id = term->id_flags | ecs_pair(pred, obj);
-            state->last_object = obj;
-        }
-        state->last_assign_id = id;
-        state->last_predicate = pred;
-        state->last_subject = subj;
-        ecs_add_id(world, subj, id);
+/**
+ *  stm32tpl --  STM32 C++ Template Peripheral Library
+ *  Visit https://github.com/antongus/stm32tpl for new versions
+ *
+ *  Copyright (c) 2011-2020 Anton B. Gusev aka AHTOXA
+ */
 
-        pred_as_subj = false;
-    } else {
-        if (!obj) {
-            /* If no subject or object were provided, use predicate as subj 
-             * unless the expression explicitly excluded the subject */
-            if (pred_as_subj) {
-                state->last_subject = pred;
-                subj = pred;
-            } else {
-                state->last_predicate = pred;
-                pred_as_subj = false;
-            }
-        } else {
-            state->last_predicate = pred;
-            state->last_object = obj;
-            pred_as_subj = false;
-        }
-    }
+#define MAX_PRECISION	(10)
+#define EXP_THRESHOLD   (3)
+#define INT64_MAX_F ((double)INT64_MAX)
 
-    /* If this is a with clause (the list of entities between 'with' and scope
-     * open), add subject to the array of with frames */
-    if (state->with_stmt) {
-        ecs_assert(pred != 0, ECS_INTERNAL_ERROR, NULL);
-        ecs_id_t id;
+static const double rounders[MAX_PRECISION + 1] =
+{
+	0.5,				// 0
+	0.05,				// 1
+	0.005,				// 2
+	0.0005,				// 3
+	0.00005,			// 4
+	0.000005,			// 5
+	0.0000005,			// 6
+	0.00000005,			// 7
+	0.000000005,		// 8
+	0.0000000005,		// 9
+	0.00000000005		// 10
+};
 
-        if (obj) {
-            id = ecs_pair(pred, obj);
-        } else {
-            id = pred;
-        }
+static
+char* flecs_strbuf_itoa(
+    char *buf,
+    int64_t v)
+{
+    char *ptr = buf;
+    char * p1;
+	char c;
 
-        state->with[state->with_frame ++] = id;
+	if (!v) {
+		*ptr++ = '0';
     } else {
-        if (subj && !state->scope_assign_stmt) {
-            plecs_apply_with_frame(world, state, subj);
-        }
-    }
-
-    /* If an id was provided by itself, add default scope type to it */
-    ecs_entity_t default_scope_type = state->default_scope_type[state->sp];
-    if (pred_as_subj && default_scope_type) {
-        ecs_add_id(world, subj, default_scope_type);
-    }
-
-    /* If annotations preceded the statement, append */
-    if (!state->decl_type && state->annot_count) {
-        if (!subj) {
-            ecs_parser_error(name, expr, column, 
-                "missing subject for annotations");
-            return -1;
+        if (v < 0) {
+            ptr[0] = '-';
+            ptr ++;
+            v *= -1;
         }
 
-        plecs_apply_annotations(world, subj, state);
-    }
-
-    return 0;
-}
-
-static
-const char* plecs_parse_inherit_stmt(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    if (state->isa_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "cannot nest inheritance");
-        return NULL;
-    }
+		char *p = ptr;
+		while (v) {
+            int64_t vdiv = v / 10;
+            int64_t vmod = v - (vdiv * 10);
+			p[0] = (char)('0' + vmod);
+            p ++;
+			v = vdiv;
+		}
 
-    if (!state->last_subject) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing entity to assign inheritance to");
-        return NULL;
-    }
-    
-    state->isa_stmt = true;
-    state->assign_to = state->last_subject;
+		p1 = p;
 
+		while (p > ptr) {
+			c = *--p;
+			*p = *ptr;
+			*ptr++ = c;
+		}
+		ptr = p1;
+	}
     return ptr;
 }
 
 static
-const char* plecs_parse_assign_var_expr(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state,
-    ecs_expr_var_t *var)
+void flecs_strbuf_ftoa(
+    ecs_strbuf_t *out, 
+    double f, 
+    int precision,
+    char nan_delim)
 {
-    ecs_value_t value = {0};
-
-    if (state->last_assign_id) {
-        value.type = state->last_assign_id;
-        value.ptr = ecs_value_new(world, state->last_assign_id);
-        if (!var && state->assembly_instance) {
-            var = ecs_vars_lookup(&state->vars, state->var_name);
-        }
-    }
+    char buf[64];
+	char * ptr = buf;
+	char c;
+	int64_t intPart;
+    int64_t exp = 0;
 
-    ptr = ecs_parse_expr(world, ptr, &value, 
-        &(ecs_parse_expr_desc_t){
-            .name = name,
-            .expr = expr,
-            .lookup_action = plecs_lookup_action,
-            .lookup_ctx = state,
-            .vars = &state->vars
-        });
-    if (!ptr) {
-        if (state->last_assign_id) {
-            ecs_value_free(world, value.type, value.ptr);
+    if (ecs_os_isnan(f)) {
+        if (nan_delim) {
+            ecs_strbuf_appendch(out, nan_delim);
+            ecs_strbuf_appendlit(out, "NaN");
+            ecs_strbuf_appendch(out, nan_delim);
+            return;
+        } else {
+            ecs_strbuf_appendlit(out, "NaN");
+            return;
         }
-        goto error;
     }
-
-    if (var) {
-        bool ignore = state->var_is_prop && state->assembly_instance;
-        if (!ignore) {
-            if (var->value.ptr) {
-                ecs_value_free(world, var->value.type, var->value.ptr);
-                var->value.ptr = value.ptr;
-                var->value.type = value.type;
-            }
+    if (ecs_os_isinf(f)) {
+        if (nan_delim) {
+            ecs_strbuf_appendch(out, nan_delim);
+            ecs_strbuf_appendlit(out, "Inf");
+            ecs_strbuf_appendch(out, nan_delim);
+            return;
         } else {
-            ecs_value_free(world, value.type, value.ptr);
-        }
-    } else {
-        var = ecs_vars_declare_w_value(
-            &state->vars, state->var_name, &value);
-        if (!var) {
-            goto error;
+            ecs_strbuf_appendlit(out, "Inf");
+            return;
         }
     }
 
-    state->var_is_prop = false;
-    return ptr;
-error:
-    return NULL;
-}
-
-static
-const char* plecs_parse_assign_expr(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state,
-    ecs_expr_var_t *var) 
-{
-    (void)world;
-    
-    if (state->var_stmt) {
-        return plecs_parse_assign_var_expr(world, name, expr, ptr, state, var);
+	if (precision > MAX_PRECISION) {
+		precision = MAX_PRECISION;
     }
 
-    if (!state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr,
-            "unexpected value outside of assignment statement");
-        return NULL;
-    }
+	if (f < 0) {
+		f = -f;
+		*ptr++ = '-';
+	}
 
-    ecs_id_t assign_id = state->last_assign_id;
-    if (!assign_id) {
-        ecs_parser_error(name, expr, ptr - expr,
-            "missing type for assignment statement");
-        return NULL;
-    }
+	if (precision < 0) {
+		if (f < 1.0) precision = 6;
+		else if (f < 10.0) precision = 5;
+		else if (f < 100.0) precision = 4;
+		else if (f < 1000.0) precision = 3;
+		else if (f < 10000.0) precision = 2;
+		else if (f < 100000.0) precision = 1;
+		else precision = 0;
+	}
 
-    ecs_entity_t assign_to = state->assign_to;
-    if (!assign_to) {
-        assign_to = state->last_subject;
+	if (precision) {
+		f += rounders[precision];
     }
 
-    if (!assign_to) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing entity to assign to");
-        return NULL;
+    /* Make sure that number can be represented as 64bit int, increase exp */
+    while (f > INT64_MAX_F) {
+        f /= 1000 * 1000 * 1000;
+        exp += 9;
     }
 
-    ecs_entity_t type = ecs_get_typeid(world, assign_id);
-    if (!type) {
-        char *id_str = ecs_id_str(world, assign_id);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid assignment, '%s' is not a type", id_str);
-        ecs_os_free(id_str);
-        return NULL;
-    }
+	intPart = (int64_t)f;
+	f -= (double)intPart;
 
-    if (assign_to == EcsVariable) {
-        assign_to = type;
-    }
+    ptr = flecs_strbuf_itoa(ptr, intPart);
 
-    void *value_ptr = ecs_ensure_id(world, assign_to, assign_id);
+	if (precision) {
+		*ptr++ = '.';
+		while (precision--) {
+			f *= 10.0;
+			c = (char)f;
+			*ptr++ = (char)('0' + c);
+			f -= c;
+		}
+	}
+	*ptr = 0;
 
-    ptr = ecs_parse_expr(world, ptr, &(ecs_value_t){type, value_ptr}, 
-        &(ecs_parse_expr_desc_t){
-            .name = name,
-            .expr = expr,
-            .lookup_action = plecs_lookup_action,
-            .lookup_ctx = state,
-            .vars = &state->vars
-        });
-    if (!ptr) {
-        return NULL;
+    /* Remove trailing 0s */
+    while ((&ptr[-1] != buf) && (ptr[-1] == '0')) {
+        ptr[-1] = '\0';
+        ptr --;
     }
-
-    ecs_modified_id(world, assign_to, assign_id);
-
-    return ptr;
-}
-
-static
-const char* plecs_parse_assign_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
-{
-    (void)world;
-
-    state->isa_stmt = false;
-
-    /* Component scope (add components to entity) */
-    if (!state->assign_to) {
-        if (!state->last_subject) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "missing entity to assign to");
-            return NULL;
-        }
-        state->assign_to = state->last_subject;
+    if (ptr != buf && ptr[-1] == '.') {
+        ptr[-1] = '\0';
+        ptr --;
     }
 
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid assign statement in assign statement");
-        return NULL;
+    /* If 0s before . exceed threshold, convert to exponent to save space 
+     * without losing precision. */
+    char *cur = ptr;
+    while ((&cur[-1] != buf) && (cur[-1] == '0')) {
+        cur --;
     }
 
-    state->assign_stmt = true;
-    
-    /* Assignment without a preceding component */
-    if (ptr[0] == '{') {
-        ecs_entity_t type = 0;
+    if (exp || ((ptr - cur) > EXP_THRESHOLD)) {
+        cur[0] = '\0';
+        exp += (ptr - cur);
+        ptr = cur;
+    }
 
-        /* If we're in a scope & last_subject is a type, assign to scope */
-        if (ecs_get_scope(world) != 0) {
-            type = ecs_get_typeid(world, state->last_subject);
-            if (type != 0) {
-                type = state->last_subject;
-            }
+    if (exp) {
+        char *p1 = &buf[1];
+        if (nan_delim) {
+            ecs_os_memmove(buf + 1, buf, 1 + (ptr - buf));
+            buf[0] = nan_delim;
+            p1 ++;
         }
 
-        /* If type hasn't been set yet, check if scope has default type */
-        if (!type && !state->scope_assign_stmt) {
-            type = state->default_scope_type[state->sp];
-        }
+        /* Make sure that exp starts after first character */
+        c = p1[0];
 
-        /* If no type has been found still, check if last with id is a type */
-        if (!type && !state->scope_assign_stmt) {
-            int32_t with_frame_count = state->with_frames[state->sp];
-            if (with_frame_count) {
-                type = state->with[with_frame_count - 1];
-            }
+        if (c) {
+            p1[0] = '.';
+            do {
+                char t = (++p1)[0];
+                if (t == '.') {
+                    exp ++;
+                    p1 --;
+                    break;
+                }
+                p1[0] = c;
+                c = t;
+                exp ++;
+            } while (c);
+            ptr = p1 + 1;
+        } else {
+            ptr = p1;
         }
 
-        if (!type) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "missing type for assignment");
-            return NULL;
+        ptr[0] = 'e';
+        ptr = flecs_strbuf_itoa(ptr + 1, exp);
+
+        if (nan_delim) {
+            ptr[0] = nan_delim;
+            ptr ++;
         }
 
-        state->last_assign_id = type;
+        ptr[0] = '\0';
     }
-
-    return ptr;
+    
+    ecs_strbuf_appendstrn(out, buf, (int32_t)(ptr - buf));
 }
 
+/* Add an extra element to the buffer */
 static
-const char* plecs_parse_assign_with_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
+void flecs_strbuf_grow(
+    ecs_strbuf_t *b)
 {
-    int32_t with_frame = state->with_frame - 1;
-    if (with_frame < 0) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing type in with value");
-        return NULL;
-    }
-
-    ecs_id_t id = state->with[with_frame];
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    const ecs_type_info_t *ti = idr ? idr->type_info : NULL;
-    if (!ti) {
-        char *typename = ecs_id_str(world, id);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "id '%s' in with value is not a type", typename);
-        ecs_os_free(typename);
-        return NULL;
-    }
-
-    plecs_with_value_t *v = &state->with_value_frames[with_frame];
-    v->value.type = ti->component;
-    v->value.ptr = ecs_value_new(world, ti->component);
-    v->owned = true;
-    if (!v->value.ptr) {
-        char *typename = ecs_id_str(world, id);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "failed to create value for '%s'", typename);
-        ecs_os_free(typename);
-        return NULL;
-    }
-
-    ptr = ecs_parse_expr(world, ptr, &v->value,
-        &(ecs_parse_expr_desc_t){
-            .name = name,
-            .expr = expr,
-            .lookup_action = plecs_lookup_action,
-            .lookup_ctx = state,
-            .vars = &state->vars
-        });
-    if (!ptr) {
-        return NULL;
+    if (!b->content) {
+        b->content = b->small_string;
+        b->size = ECS_STRBUF_SMALL_STRING_SIZE;
+    } else if (b->content == b->small_string) {
+        b->size *= 2;
+        b->content = ecs_os_malloc_n(char, b->size);
+        ecs_os_memcpy(b->content, b->small_string, b->length);
+    } else {
+        b->size *= 2;
+        if (b->size < 16) b->size = 16;
+        b->content = ecs_os_realloc_n(b->content, char, b->size);
     }
-
-    return ptr;
 }
 
 static
-const char* plecs_parse_assign_with_var(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
+char* flecs_strbuf_ptr(
+    ecs_strbuf_t *b)
 {
-    ecs_assert(ptr[0] == '$', ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(state->with_stmt, ECS_INTERNAL_ERROR, NULL);
-
-    char var_name[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr;
-    ptr = ecs_parse_token(name, expr, ptr + 1, var_name, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "unresolved variable '%s'", var_name);
-        return NULL;
-    }
-
-    ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, var_name);
-    if (!var) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unresolved variable '%s'", var_name);
-        return NULL;
-    }
-
-    int32_t with_frame = state->with_frame;
-    state->with[with_frame] = var->value.type;
-    state->with_value_frames[with_frame].value = var->value;
-    state->with_value_frames[with_frame].owned = false;
-    state->with_frame ++;
-
-    return ptr;
+    ecs_assert(b->content != NULL, ECS_INTERNAL_ERROR, NULL);
+    return &b->content[b->length];
 }
 
+/* Append a format string to a buffer */
 static
-const char* plecs_parse_var_as_component(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
+void flecs_strbuf_vappend(
+    ecs_strbuf_t *b,
+    const char* str,
+    va_list args)
 {
-    ecs_assert(ptr[0] == '$', ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!state->var_stmt, ECS_INTERNAL_ERROR, NULL);
-    char var_name[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr;
-    ptr = ecs_parse_token(name, expr, ptr + 1, var_name, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "unresolved variable '%s'", var_name);
-        return NULL;
-    }
+    va_list arg_cpy;
 
-    ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, var_name);
-    if (!var) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unresolved variable '%s'", var_name);
-        return NULL;
+    if (!str) {
+        return;
     }
 
-    if (!state->assign_to) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing lvalue for variable assignment '%s'", var_name);
-        return NULL;
-    }
+    /* Compute the memory required to add the string to the buffer. If user
+     * provided buffer, use space left in buffer, otherwise use space left in
+     * current element. */
+    int32_t mem_left = b->size - b->length;
+    int32_t mem_required;
 
-    /* Use type of variable as component */
-    ecs_entity_t type = var->value.type;
-    ecs_entity_t assign_to = state->assign_to;
-    if (!assign_to) {
-        assign_to = state->last_subject;
-    }
+    va_copy(arg_cpy, args);
 
-    void *dst = ecs_ensure_id(world, assign_to, type);
-    if (!dst) {
-        char *type_name = ecs_get_fullpath(world, type);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "failed to obtain component for type '%s' of variable '%s'",    
-                type_name, var_name);
-        ecs_os_free(type_name);
-        return NULL;
+    if (b->content) {
+        mem_required = vsnprintf(
+            flecs_strbuf_ptr(b), 
+                flecs_itosize(mem_left), str, args);
+    } else {
+        mem_required = vsnprintf(NULL, 0, str, args);
+        mem_left = 0;
     }
 
-    if (ecs_value_copy(world, type, dst, var->value.ptr)) {
-        char *type_name = ecs_get_fullpath(world, type);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "failed to copy value for variable '%s' of type '%s'",    
-                var_name, type_name);
-        ecs_os_free(type_name);
-        return NULL;
+    ecs_assert(mem_required != -1, ECS_INTERNAL_ERROR, NULL);
+
+    if ((mem_required + 1) >= mem_left) {
+        while ((mem_required + 1) >= mem_left) {
+            flecs_strbuf_grow(b);
+            mem_left = b->size - b->length;
+        }
+        vsnprintf(flecs_strbuf_ptr(b), 
+            flecs_itosize(mem_required + 1), str, arg_cpy);
     }
 
-    ecs_modified_id(world, assign_to, type);
+    b->length += mem_required;
 
-    return ptr;
+    va_end(arg_cpy);
 }
 
 static
-void plecs_push_using(
-    ecs_entity_t scope,
-    plecs_state_t *state)
+void flecs_strbuf_appendstr(
+    ecs_strbuf_t *b,
+    const char* str,
+    int n)
 {
-    for (int i = 0; i < state->using_frame; i ++) {
-        if (state->using[i] == scope) {
-            return;
-        }
+    int32_t mem_left = b->size - b->length;
+    while (n >= mem_left) {
+        flecs_strbuf_grow(b);
+        mem_left = b->size - b->length;
     }
 
-    state->using[state->using_frame ++] = scope;
+    ecs_os_memcpy(flecs_strbuf_ptr(b), str, n);
+    b->length += n;
 }
 
 static
-const char* plecs_parse_using_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
+void flecs_strbuf_appendch(
+    ecs_strbuf_t *b,
+    char ch)
 {
-    if (state->isa_stmt || state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid usage of using keyword");
-        return NULL;
-    }
-
-    char using_path[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr + 1;
-    ptr = ecs_parse_token(name, expr, ptr + 5, using_path, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "expected identifier for using statement");
-        return NULL;
+    if (b->size == b->length) {
+        flecs_strbuf_grow(b);
     }
 
-    ecs_size_t len = ecs_os_strlen(using_path);
-    if (!len) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "missing identifier for using statement");
-        return NULL;
-    }
+    flecs_strbuf_ptr(b)[0] = ch;
+    b->length ++;
+}
 
-    /* Lookahead as * is not matched by parse_token */
-    if (ptr[0] == '*') {
-        using_path[len] = '*';
-        using_path[len + 1] = '\0';
-        len ++;
-        ptr ++;
-    }
+void ecs_strbuf_vappend(
+    ecs_strbuf_t *b,
+    const char* fmt,
+    va_list args)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL);
+    flecs_strbuf_vappend(b, fmt, args);
+}
 
-    ecs_entity_t scope;
-    if (len > 2 && !ecs_os_strcmp(&using_path[len - 2], ".*")) {
-        using_path[len - 2] = '\0';
-        scope = ecs_lookup(world, using_path);
-        if (!scope) {
-            ecs_parser_error(name, expr, ptr - expr,
-                "unresolved identifier '%s' in using statement", using_path);
-            return NULL;
-        }
+void ecs_strbuf_append(
+    ecs_strbuf_t *b,
+    const char* fmt,
+    ...)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL);
 
-        /* Add each child of the scope to using stack */
-        ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ 
-            .id = ecs_childof(scope) });
-        while (ecs_term_next(&it)) {
-            int32_t i, count = it.count;
-            for (i = 0; i < count; i ++) {
-                plecs_push_using(it.entities[i], state);
-            }
-        }
-    } else {
-        scope = plecs_ensure_entity(world, state, using_path, 0, false);
-        if (!scope) {
-            ecs_parser_error(name, expr, ptr - expr,
-                "unresolved identifier '%s' in using statement", using_path);
-            return NULL;
-        }
+    va_list args;
+    va_start(args, fmt);
+    flecs_strbuf_vappend(b, fmt, args);
+    va_end(args);
+}
 
-        plecs_push_using(scope, state);
-    }
+void ecs_strbuf_appendstrn(
+    ecs_strbuf_t *b,
+    const char* str,
+    int32_t len)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL);
+    flecs_strbuf_appendstr(b, str, len);
+}
 
-    state->using_frames[state->sp] = state->using_frame;
-    return ptr;
+void ecs_strbuf_appendch(
+    ecs_strbuf_t *b,
+    char ch)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); 
+    flecs_strbuf_appendch(b, ch);
 }
 
-static
-const char* plecs_parse_module_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
+void ecs_strbuf_appendint(
+    ecs_strbuf_t *b,
+    int64_t v)
 {
-    const char *expr_start = ecs_parse_ws_eol(expr);
-    if (expr_start != ptr) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "module must be first statement of script");
-        return NULL;
-    }
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); 
+    char numbuf[32];
+    char *ptr = flecs_strbuf_itoa(numbuf, v);
+    ecs_strbuf_appendstrn(b, numbuf, flecs_ito(int32_t, ptr - numbuf));
+}
 
-    char module_path[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr + 1;
-    ptr = ecs_parse_token(name, expr, ptr + 6, module_path, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "expected identifier for module statement");
-        return NULL;
-    }
+void ecs_strbuf_appendflt(
+    ecs_strbuf_t *b,
+    double flt,
+    char nan_delim)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); 
+    flecs_strbuf_ftoa(b, flt, 10, nan_delim);
+}
 
-    ecs_component_desc_t desc = {0};
-    desc.entity = ecs_entity(world, { .name = module_path });
-    ecs_entity_t module = ecs_module_init(world, NULL, &desc);
-    if (!module) {
-        return NULL;
+void ecs_strbuf_appendbool(
+    ecs_strbuf_t *buffer,
+    bool v)
+{
+    ecs_assert(buffer != NULL, ECS_INVALID_PARAMETER, NULL); 
+    if (v) {
+        ecs_strbuf_appendlit(buffer, "true");
+    } else {
+        ecs_strbuf_appendlit(buffer, "false");
     }
-
-    state->is_module = true;
-    state->sp ++;
-    state->scope[state->sp] = module;
-    ecs_set_scope(world, module);
-    return ptr;
 }
 
-static
-const char* plecs_parse_with_stmt(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
+void ecs_strbuf_appendstr(
+    ecs_strbuf_t *b,
+    const char* str)
 {
-    if (state->isa_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid with after inheritance");
-        return NULL;
-    }
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL);
+    flecs_strbuf_appendstr(b, str, ecs_os_strlen(str));
+}
 
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid with in assign_stmt");
-        return NULL;
+void ecs_strbuf_mergebuff(
+    ecs_strbuf_t *b,
+    ecs_strbuf_t *src)
+{
+    if (src->content) {
+        ecs_strbuf_appendstr(b, src->content);
     }
-
-    /* Add following expressions to with list */
-    state->with_stmt = true;
-    return ptr + 5;
+    ecs_strbuf_reset(src);
 }
 
-static
-const char* plecs_parse_assembly_stmt(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
+char* ecs_strbuf_get(
+    ecs_strbuf_t *b) 
 {
-    if (state->isa_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid with after inheritance");
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    char *result = b->content;
+    if (!result) {
         return NULL;
     }
 
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid with in assign_stmt");
-        return NULL;
-    }
+    ecs_strbuf_appendch(b, '\0');
+    result = b->content;
 
-    state->assembly_stmt = true;
+    if (result == b->small_string) {
+        result = ecs_os_memdup_n(result, char, b->length + 1);
+    }
 
-    return ptr + 9;
+    b->length = 0;
+    b->content = NULL;
+    b->size = 0;
+    b->list_sp = 0;
+    return result;
 }
 
-static
-const char* plecs_parse_var_type(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state,
-    ecs_entity_t *type_out)
+char* ecs_strbuf_get_small(
+    ecs_strbuf_t *b)
 {
-    char prop_type_name[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr + 1;
-    ptr = ecs_parse_token(name, expr, ptr + 1, prop_type_name, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "expected type for prop declaration");
-        return NULL;
-    }
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    char *result = b->content;
+    result[b->length] = '\0';
+    b->length = 0;
+    b->content = NULL;
+    b->size = 0;
+    return result;
+}
 
-    ecs_entity_t prop_type = plecs_lookup(world, prop_type_name, state, 0, false);
-    if (!prop_type) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unresolved property type '%s'", prop_type_name);
-        return NULL;
+void ecs_strbuf_reset(
+    ecs_strbuf_t *b) 
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    if (b->content && b->content != b->small_string) {
+        ecs_os_free(b->content);
     }
-
-    *type_out = prop_type;
-
-    return ptr;
+    *b = ECS_STRBUF_INIT;
 }
 
-static
-const char* plecs_parse_const_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
+void ecs_strbuf_list_push(
+    ecs_strbuf_t *b,
+    const char *list_open,
+    const char *separator)
 {
-    ptr = ecs_parse_token(name, expr, ptr + 5, state->var_name, 0);
-    if (!ptr) {
-        return NULL;
-    }
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(list_open != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(separator != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(b->list_sp >= 0, ECS_INVALID_OPERATION, 
+        "strbuf list is corrupt");
+    b->list_sp ++;
+    ecs_assert(b->list_sp < ECS_STRBUF_MAX_LIST_DEPTH, 
+        ECS_INVALID_OPERATION, "max depth for strbuf list stack exceeded");
 
-    ptr = ecs_parse_ws(ptr);
+    b->list_stack[b->list_sp].count = 0;
+    b->list_stack[b->list_sp].separator = separator;
 
-    if (ptr[0] == ':') {
-        ptr = plecs_parse_var_type(
-            world, name, expr, ptr, state, &state->last_assign_id);
-        if (!ptr) {
-            return NULL;
+    if (list_open) {
+        char ch = list_open[0];
+        if (ch && !list_open[1]) {
+            ecs_strbuf_appendch(b, ch);
+        } else {
+            ecs_strbuf_appendstr(b, list_open);
         }
-
-        ptr = ecs_parse_ws(ptr);
-    }
-
-    if (ptr[0] != '=') {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "expected '=' after const declaration");
-        return NULL;
     }
-
-    state->var_stmt = true;
-    return ptr + 1;
 }
 
-static
-const char* plecs_parse_prop_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
+void ecs_strbuf_list_pop(
+    ecs_strbuf_t *b,
+    const char *list_close)
 {
-    char prop_name[ECS_MAX_TOKEN_SIZE];
-    ptr = ecs_parse_token(name, expr, ptr + 5, prop_name, 0);
-    if (!ptr) {
-        return NULL;
-    }
-
-    ptr = ecs_parse_ws(ptr);
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(list_close != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(b->list_sp > 0, ECS_INVALID_OPERATION, 
+        "pop called more often than push for strbuf list");
 
-    if (ptr[0] != ':') {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "expected ':' after prop declaration");
-        return NULL;
+    b->list_sp --;
+    
+    if (list_close) {
+        char ch = list_close[0];
+        if (ch && !list_close[1]) {
+            ecs_strbuf_appendch(b, list_close[0]);
+        } else {
+            ecs_strbuf_appendstr(b, list_close);
+        }
     }
+}
 
-    ecs_entity_t prop_type;
-    ptr = plecs_parse_var_type(world, name, expr, ptr, state, &prop_type);
-    if (!ptr) {
-        return NULL;
-    }
+void ecs_strbuf_list_next(
+    ecs_strbuf_t *b)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_entity_t assembly = state->assembly;
-    if (!assembly) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unexpected prop '%s' outside of assembly", prop_name);
-        return NULL;
+    int32_t list_sp = b->list_sp;
+    if (b->list_stack[list_sp].count != 0) {
+        const char *sep = b->list_stack[list_sp].separator;
+        if (sep && !sep[1]) {
+            ecs_strbuf_appendch(b, sep[0]);
+        } else {
+            ecs_strbuf_appendstr(b, sep);
+        }
     }
+    b->list_stack[list_sp].count ++;
+}
 
-    if (!state->assembly_instance) {
-        ecs_entity_t prop_member = ecs_entity(world, {
-            .name = prop_name,
-            .add = { ecs_childof(assembly) }
-        });
+void ecs_strbuf_list_appendch(
+    ecs_strbuf_t *b,
+    char ch)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_strbuf_list_next(b);
+    flecs_strbuf_appendch(b, ch);
+}
 
-        if (!prop_member) {
-            return NULL;
-        }
+void ecs_strbuf_list_append(
+    ecs_strbuf_t *b,
+    const char *fmt,
+    ...)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL);
 
-        ecs_set(world, prop_member, EcsMember, {
-            .type = prop_type
-        });
-    }
+    ecs_strbuf_list_next(b);
 
-    if (ptr[0] != '=') {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "expected '=' after prop type");
-        return NULL;
-    }
+    va_list args;
+    va_start(args, fmt);
+    flecs_strbuf_vappend(b, fmt, args);
+    va_end(args);
+}
 
-    ecs_os_strcpy(state->var_name, prop_name);
-    state->last_assign_id = prop_type;
-    state->var_stmt = true;
-    state->var_is_prop = true;
+void ecs_strbuf_list_appendstr(
+    ecs_strbuf_t *b,
+    const char *str)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    return plecs_parse_fluff(ptr + 1);
+    ecs_strbuf_list_next(b);
+    ecs_strbuf_appendstr(b, str);
 }
 
-static
-const char* plecs_parse_scope_open(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
+void ecs_strbuf_list_appendstrn(
+    ecs_strbuf_t *b,
+    const char *str,
+    int32_t n)
 {
-    state->isa_stmt = false;
-
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid scope in assign_stmt");
-        return NULL;
-    }
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    state->sp ++;
+    ecs_strbuf_list_next(b);
+    ecs_strbuf_appendstrn(b, str, n);
+}
 
-    ecs_entity_t scope = 0;
-    ecs_entity_t default_scope_type = 0;
-    bool assembly_stmt = false;
+int32_t ecs_strbuf_written(
+    const ecs_strbuf_t *b)
+{
+    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    return b->length;
+}
 
-    if (!state->with_stmt) {
-        if (state->last_subject) {
-            scope = state->last_subject;
-            ecs_set_scope(world, state->last_subject);
+/**
+ * @file datastructures/vec.c
+ * @brief Vector with allocator support.
+ */
 
-            /* Check if scope has a default child component */
-            ecs_entity_t def_type_src = ecs_get_target_for_id(world, scope, 
-                0, ecs_pair(EcsDefaultChildComponent, EcsWildcard));
 
-            if (def_type_src) {
-                default_scope_type = ecs_get_target(
-                    world, def_type_src, EcsDefaultChildComponent, 0);
-            }
+ecs_vec_t* ecs_vec_init(
+    ecs_allocator_t *allocator,
+    ecs_vec_t *v,
+    ecs_size_t size,
+    int32_t elem_count)
+{
+    ecs_assert(size != 0, ECS_INVALID_PARAMETER, NULL);
+    v->array = NULL;
+    v->count = 0;
+    if (elem_count) {
+        if (allocator) {
+            v->array = flecs_alloc(allocator, size * elem_count);
         } else {
-            if (state->last_object) {
-                scope = ecs_pair(
-                    state->last_predicate, state->last_object);
-                ecs_set_with(world, scope);
-            } else {
-                if (state->last_predicate) {
-                    scope = ecs_pair(EcsChildOf, state->last_predicate);
-                }
-                ecs_set_scope(world, state->last_predicate);
-            }
-        }
-
-        state->scope[state->sp] = scope;
-        state->default_scope_type[state->sp] = default_scope_type;
-
-        if (state->assembly_stmt) {
-            assembly_stmt = true;
-            if (state->assembly) {
-                ecs_parser_error(name, expr, ptr - expr, 
-                    "invalid nested assembly");
-                return NULL;
-            }
-            state->assembly = scope;
-            state->assembly_stmt = false;
-            state->assembly_start = ptr;
+            v->array = ecs_os_malloc(size * elem_count);
         }
-    } else {
-        state->scope[state->sp] = state->scope[state->sp - 1];
-        state->default_scope_type[state->sp] = 
-            state->default_scope_type[state->sp - 1];
-        state->assign_to = 0;
     }
+    v->size = elem_count;
+#ifdef FLECS_SANITIZE
+    v->elem_size = size;
+#endif
+    return v;
+}
 
-    state->using_frames[state->sp] = state->using_frame;
-    state->with_frames[state->sp] = state->with_frame;
-    state->with_stmt = false;
-
-    ecs_vars_push(&state->vars);
-
-    /* Declare variable to hold assembly instance during instantiation */
-    if (assembly_stmt) {
-        ecs_value_t val = {0};
-        ecs_expr_var_t *var = ecs_vars_declare_w_value(
-            &state->vars, "this", &val);
-        var->value.ptr = ECS_CONST_CAST(void*, &EcsThis); /* Dummy value */
-        var->value.type = ecs_id(ecs_entity_t);
-        var->owned = false;
+void ecs_vec_init_if(
+    ecs_vec_t *vec,
+    ecs_size_t size)
+{
+    ecs_san_assert(!vec->elem_size || vec->elem_size == size, ECS_INVALID_PARAMETER, NULL);
+    (void)vec;
+    (void)size;
+#ifdef FLECS_SANITIZE
+    if (!vec->elem_size) {
+        ecs_assert(vec->count == 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(vec->size == 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(vec->array == NULL, ECS_INTERNAL_ERROR, NULL);
+        vec->elem_size = size;
     }
-
-    return ptr;
+#endif
 }
 
-static
-void plecs_free_with_frame(
-    ecs_world_t *world,
-    plecs_state_t *state)
+void ecs_vec_fini(
+    ecs_allocator_t *allocator,
+    ecs_vec_t *v,
+    ecs_size_t size)
 {
-    int32_t i, prev_with = state->with_frames[state->sp];
-    for (i = prev_with; i < state->with_frame; i ++) {
-        plecs_with_value_t *v = &state->with_value_frames[i];
-        if (!v->owned) {
-            continue;
-        }
-        if (v->value.type) {
-            ecs_value_free(world, v->value.type, v->value.ptr);
-            v->value.type = 0;
-            v->value.ptr = NULL;
-            v->owned = false;
+    if (v->array) {
+        ecs_san_assert(!size || size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+        if (allocator) {
+            flecs_free(allocator, size * v->size, v->array);
+        } else {
+            ecs_os_free(v->array);
         }
+        v->array = NULL;
+        v->count = 0;
+        v->size = 0;
     }
 }
 
-static
-void plecs_free_all_with_frames(
-    ecs_world_t *world,
-    plecs_state_t *state)
+ecs_vec_t* ecs_vec_reset(
+    ecs_allocator_t *allocator,
+    ecs_vec_t *v,
+    ecs_size_t size)
 {
-    int32_t i;
-    for (i = state->sp - 1; i >= 0; i --) {
-        state->sp = i;
-        plecs_free_with_frame(world, state);
-    }    
+    if (!v->size) {
+        ecs_vec_init(allocator, v, size, 0);
+    } else {
+        ecs_san_assert(size == v->elem_size, ECS_INTERNAL_ERROR, NULL);
+        ecs_vec_clear(v);
+    }
+    return v;
 }
 
-static
-const char* plecs_parse_scope_close(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
+void ecs_vec_clear(
+    ecs_vec_t *vec)
 {
-    if (state->isa_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid '}' after inheritance statement");
-        return NULL;
+    vec->count = 0;
+}
+
+ecs_vec_t ecs_vec_copy(
+    ecs_allocator_t *allocator,
+    const ecs_vec_t *v,
+    ecs_size_t size)
+{
+    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    void *array;
+    if (allocator) {
+        array = flecs_dup(allocator, size * v->size, v->array);
+    } else {
+        array = ecs_os_memdup(v->array, size * v->size);
     }
+    return (ecs_vec_t) {
+        .count = v->count,
+        .size = v->size,
+        .array = array
+#ifdef FLECS_SANITIZE
+        , .elem_size = size
+#endif
+    };
+}
 
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unfinished assignment before }");
-        return NULL;
+ecs_vec_t ecs_vec_copy_shrink(
+    ecs_allocator_t *allocator,
+    const ecs_vec_t *v,
+    ecs_size_t size)
+{
+    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    int32_t count = v->count;
+    void *array = NULL;
+    if (count) {
+        if (allocator) {
+            array = flecs_dup(allocator, size * count, v->array);
+        } else {
+            array = ecs_os_memdup(v->array, size * count);
+        }
     }
+    return (ecs_vec_t) {
+        .count = count,
+        .size = count,
+        .array = array
+#ifdef FLECS_SANITIZE
+        , .elem_size = size
+#endif
+    };
+}
 
-    ecs_entity_t cur = state->scope[state->sp], assembly = state->assembly;
-    if (state->sp && (cur == state->scope[state->sp - 1])) {
-        /* Previous scope is also from the assembly, not found the end yet */
-        cur = 0;
-    }
-    if (cur && cur == assembly) {
-        ecs_size_t assembly_len = flecs_ito(ecs_size_t, ptr - state->assembly_start);
-        if (assembly_len) {
-            assembly_len --;
-            char *script = ecs_os_malloc_n(char, assembly_len + 1);
-            ecs_os_memcpy(script, state->assembly_start, assembly_len);
-            script[assembly_len] = '\0';
-            state->assembly = 0;
-            state->assembly_start = NULL;
-            if (flecs_assembly_create(world, name, expr, ptr, assembly, script, state)) {
-                return NULL;
+void ecs_vec_reclaim(
+    ecs_allocator_t *allocator,
+    ecs_vec_t *v,
+    ecs_size_t size)
+{
+    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    int32_t count = v->count;
+    if (count < v->size) {
+        if (count) {
+            if (allocator) {
+                v->array = flecs_realloc(
+                    allocator, size * count, size * v->size, v->array);
+            } else {
+                v->array = ecs_os_realloc(v->array, size * count);
             }
+            v->size = count;
         } else {
-            ecs_parser_error(name, expr, ptr - expr, "empty assembly");
-            return NULL;
+            ecs_vec_fini(allocator, v, size);
         }
     }
+}
 
-    state->scope[state->sp] = 0;
-    state->default_scope_type[state->sp] = 0;
-    state->sp --;
-
-    if (state->sp < 0) {
-        ecs_parser_error(name, expr, ptr - expr, "invalid } without a {");
-        return NULL;
-    }
+void ecs_vec_set_size(
+    ecs_allocator_t *allocator,
+    ecs_vec_t *v,
+    ecs_size_t size,
+    int32_t elem_count)
+{
+    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    if (v->size != elem_count) {
+        if (elem_count < v->count) {
+            elem_count = v->count;
+        }
 
-    ecs_id_t id = state->scope[state->sp];
-    if (!id || ECS_HAS_ID_FLAG(id, PAIR)) {
-        ecs_set_with(world, id);
+        elem_count = flecs_next_pow_of_2(elem_count);
+        if (elem_count < 2) {
+            elem_count = 2;
+        }
+        if (elem_count != v->size) {
+            if (allocator) {
+                v->array = flecs_realloc(
+                    allocator, size * elem_count, size * v->size, v->array);
+            } else {
+                v->array = ecs_os_realloc(v->array, size * elem_count);
+            }
+            v->size = elem_count;
+        }
     }
+}
 
-    if (!id || !ECS_HAS_ID_FLAG(id, PAIR)) {
-        ecs_set_scope(world, id);
+void ecs_vec_set_min_size(
+    struct ecs_allocator_t *allocator,
+    ecs_vec_t *vec,
+    ecs_size_t size,
+    int32_t elem_count)
+{
+    if (elem_count > vec->size) {
+        ecs_vec_set_size(allocator, vec, size, elem_count);
     }
-
-    plecs_free_with_frame(world, state);
-
-    state->with_frame = state->with_frames[state->sp];
-    state->using_frame = state->using_frames[state->sp];
-    state->last_subject = 0;
-    state->assign_stmt = false;
-
-    ecs_vars_pop(&state->vars);
-
-    return plecs_parse_fluff(ptr + 1);
 }
 
-static
-const char *plecs_parse_plecs_term(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
+void ecs_vec_set_min_count(
+    struct ecs_allocator_t *allocator,
+    ecs_vec_t *vec,
+    ecs_size_t size,
+    int32_t elem_count)
 {
-    ecs_term_t term = {0};
-    ecs_entity_t decl_id = 0;
-    if (state->decl_stmt) {
-        decl_id = state->last_predicate;
+    ecs_vec_set_min_size(allocator, vec, size, elem_count);
+    if (vec->count < elem_count) {
+        vec->count = elem_count;
     }
+}
 
-    ptr = ecs_parse_term(world, name, expr, ptr, &term, NULL, NULL, false);
-    if (!ptr) {
-        return NULL;
+void ecs_vec_set_min_count_zeromem(
+    struct ecs_allocator_t *allocator,
+    ecs_vec_t *vec,
+    ecs_size_t size,
+    int32_t elem_count)
+{
+    int32_t count = vec->count;
+    if (count < elem_count) {
+        ecs_vec_set_min_count(allocator, vec, size, elem_count);
+        ecs_os_memset(ECS_ELEM(vec->array, size, count), 0,
+            size * (elem_count - count));
     }
+}
 
-    if (flecs_isident(ptr[0])) {
-        state->decl_type = true;
-    }
+void ecs_vec_set_count(
+    ecs_allocator_t *allocator,
+    ecs_vec_t *v,
+    ecs_size_t size,
+    int32_t elem_count)
+{
+    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    if (v->count != elem_count) {
+        if (v->size < elem_count) {
+            ecs_vec_set_size(allocator, v, size, elem_count);
+        }
 
-    if (!ecs_term_is_initialized(&term)) {
-        ecs_parser_error(name, expr, ptr - expr, "expected identifier");
-        return NULL; /* No term found */
+        v->count = elem_count;
     }
+}
+
+void* ecs_vec_grow(
+    ecs_allocator_t *allocator,
+    ecs_vec_t *v,
+    ecs_size_t size,
+    int32_t elem_count)
+{
+    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(elem_count > 0, ECS_INTERNAL_ERROR, NULL);
+    int32_t count = v->count;
+    ecs_vec_set_count(allocator, v, size, count + elem_count);
+    return ECS_ELEM(v->array, size, count);
+}
 
-    if (plecs_create_term(world, &term, name, expr, (ptr - expr), state)) {
-        ecs_term_fini(&term);
-        return NULL; /* Failed to create term */
+void* ecs_vec_append(
+    ecs_allocator_t *allocator,
+    ecs_vec_t *v,
+    ecs_size_t size)
+{
+    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    int32_t count = v->count;
+    if (v->size == count) {
+        ecs_vec_set_size(allocator, v, size, count + 1);
     }
+    v->count = count + 1;
+    return ECS_ELEM(v->array, size, count);
+}
 
-    if (decl_id && state->last_subject) {
-        ecs_add_id(world, state->last_subject, decl_id);
+void ecs_vec_remove(
+    ecs_vec_t *v,
+    ecs_size_t size,
+    int32_t index)
+{
+    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(index < v->count, ECS_OUT_OF_RANGE, NULL);
+    if (index == --v->count) {
+        return;
     }
 
-    state->decl_type = false;
+    ecs_os_memcpy(
+        ECS_ELEM(v->array, size, index),
+        ECS_ELEM(v->array, size, v->count),
+        size);
+}
 
-    ecs_term_fini(&term);
+void ecs_vec_remove_last(
+    ecs_vec_t *v)
+{
+    v->count --;
+}
 
-    return ptr;
+int32_t ecs_vec_count(
+    const ecs_vec_t *v)
+{
+    return v->count;
 }
 
-static
-const char* plecs_parse_annotation(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
+int32_t ecs_vec_size(
+    const ecs_vec_t *v)
 {
-    do {
-        if(state->annot_count >= STACK_MAX_SIZE) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "max number of annotations reached");
-            return NULL;
-        }
+    return v->size;
+}
 
-        char ch;
-        const char *start = ptr;
-        for (; (ch = *ptr) && ch != '\n'; ptr ++) { }
+void* ecs_vec_get(
+    const ecs_vec_t *v,
+    ecs_size_t size,
+    int32_t index)
+{
+    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(index >= 0, ECS_OUT_OF_RANGE, NULL);
+    ecs_assert(index < v->count, ECS_OUT_OF_RANGE, NULL);
+    return ECS_ELEM(v->array, size, index);
+}
+
+void* ecs_vec_last(
+    const ecs_vec_t *v,
+    ecs_size_t size)
+{
+    ecs_san_assert(!v->elem_size || size == v->elem_size,
+        ECS_INVALID_PARAMETER, NULL);
+    return ECS_ELEM(v->array, size, v->count - 1);
+}
+
+void* ecs_vec_first(
+    const ecs_vec_t *v)
+{
+    return v->array;
+}
 
-        int32_t len = (int32_t)(ptr - start);
-        char *annot = ecs_os_malloc_n(char, len + 1);
-        ecs_os_memcpy_n(annot, start, char, len);
-        annot[len] = '\0';
+ /**
+ * @file addons/rules/api.c
+ * @brief User facing API for rules.
+ */
 
-        state->annot[state->annot_count] = annot;
-        state->annot_count ++;
+#include <ctype.h>
 
-        ptr = plecs_parse_fluff(ptr);
-    } while (ptr[0] == '@');
+ecs_mixins_t ecs_query_t_mixins = {
+    .type_name = "ecs_query_t",
+    .elems = {
+        [EcsMixinWorld] = offsetof(ecs_query_impl_t, pub.world),
+        [EcsMixinEntity] = offsetof(ecs_query_impl_t, pub.entity),
+        [EcsMixinDtor] = offsetof(ecs_query_impl_t, dtor)
+    }
+};
 
-    return ptr;
+int32_t ecs_query_var_count(
+    const ecs_query_t *q)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    return flecs_query_impl(q)->var_pub_count;
 }
 
-static
-void plecs_clear_annotations(
-    plecs_state_t *state)
+int32_t ecs_query_find_var(
+    const ecs_query_t *q,
+    const char *name)
 {
-    int32_t i, count = state->annot_count;
-    for (i = 0; i < count; i ++) {
-        ecs_os_free(state->annot[i]);
+    flecs_poly_assert(q, ecs_query_t);
+
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    ecs_var_id_t var_id = flecs_query_find_var_id(impl, name, EcsVarEntity);
+    if (var_id == EcsVarNone) {
+        if (q->flags & EcsQueryMatchThis) {
+            if (!ecs_os_strcmp(name, EcsThisName)) {
+                var_id = 0;
+            }
+        }
+        if (var_id == EcsVarNone) {
+            return -1;
+        }
     }
-    state->annot_count = 0;
+    return (int32_t)var_id;
 }
 
-static
-const char* plecs_parse_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
+const char* ecs_query_var_name(
+    const ecs_query_t *q,
+    int32_t var_id)
 {
-    state->assign_stmt = false;
-    state->scope_assign_stmt = false;
-    state->isa_stmt = false;
-    state->with_stmt = false;
-    state->decl_stmt = false;
-    state->var_stmt = false;
-    state->last_subject = 0;
-    state->last_predicate = 0;
-    state->last_object = 0;
-    state->assign_to = 0;
-    state->last_assign_id = 0;
+    flecs_poly_assert(q, ecs_query_t);
+
+    if (var_id) {
+        ecs_assert(var_id < flecs_query_impl(q)->var_count, 
+            ECS_INVALID_PARAMETER, NULL);
+        return flecs_query_impl(q)->vars[var_id].name;
+    } else {
+        return EcsThisName;
+    }
+}
 
-    plecs_clear_annotations(state);
+bool ecs_query_var_is_entity(
+    const ecs_query_t *q,
+    int32_t var_id)
+{
+    flecs_poly_assert(q, ecs_query_t);
 
-    ptr = plecs_parse_fluff(ptr);
+    return flecs_query_impl(q)->vars[var_id].kind == EcsVarEntity;
+}
 
-    char ch = ptr[0];
+static
+int flecs_query_set_caching_policy(
+    ecs_query_impl_t *impl,
+    const ecs_query_desc_t *desc)
+{
+    ecs_query_cache_kind_t kind = desc->cache_kind;
 
-    if (!ch) {
-        goto done;
-    } else if (ch == '{') {
-        ptr = plecs_parse_fluff(ptr + 1);
-        goto scope_open;
-    } else if (ch == '}') {
-        goto scope_close;
-    } else if (ch == '-') {
-        ptr = plecs_parse_fluff(ptr + 1);
-        state->assign_to = ecs_get_scope(world);
-        state->scope_assign_stmt = true;
-        goto assign_stmt;
-    } else if (ch == '@') {
-        ptr = plecs_parse_annotation(name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto term_expr;
-    } else if (!ecs_os_strncmp(ptr, TOK_USING " ", 5)) {
-        ptr = plecs_parse_using_stmt(world, name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto done;
-    } else if (!ecs_os_strncmp(ptr, TOK_MODULE " ", 6)) {
-        ptr = plecs_parse_module_stmt(world, name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto done;
-    } else if (!ecs_os_strncmp(ptr, TOK_WITH " ", 5)) {
-        ptr = plecs_parse_with_stmt(name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto term_expr;
-    } else if (!ecs_os_strncmp(ptr, TOK_CONST " ", 6)) {
-        ptr = plecs_parse_const_stmt(world, name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto assign_expr;
-    } else if (!ecs_os_strncmp(ptr, TOK_ASSEMBLY " ", 9)) {
-        ptr = plecs_parse_assembly_stmt(name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto decl_stmt;
-    } else if (!ecs_os_strncmp(ptr, TOK_PROP " ", 5)) {
-        ptr = plecs_parse_prop_stmt(world, name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto assign_expr;
-    } else {
-        goto term_expr;
+    /* If caching policy is default, try to pick a policy that does the right
+     * thing in most cases. */
+    if (kind == EcsQueryCacheDefault) {
+        if (desc->entity || desc->group_by || desc->group_by_callback || 
+            desc->order_by || desc->order_by_callback)
+        {
+            /* If the query is created with an entity handle (typically 
+             * indicating that the query is named or belongs to a system) the
+             * chance is very high that the query will be reused, so enable
+             * caching. 
+             * Additionally, if the query uses features that require a cache
+             * such as group_by/order_by, also enable caching. */
+            kind = EcsQueryCacheAuto;
+        } else {
+            /* Be conservative in other scenario's, as caching adds significant
+             * overhead to the cost of query creation which doesn't offset the
+             * benefit of faster iteration if it's only used once. */
+            kind = EcsQueryCacheNone;
+        }
     }
 
-term_expr:
-    if (!ptr[0]) {
-        goto done;
+    /* Don't cache query, even if it has cacheable terms */
+    if (kind == EcsQueryCacheNone) {
+        impl->pub.cache_kind = EcsQueryCacheNone;
+        if (desc->group_by || desc->order_by) {
+            ecs_err("cannot create uncached query with group_by/order_by");
+            return -1;
+        }
+        return 0;
     }
 
-    if (ptr[0] == '$' && !isspace(ptr[1])) {
-        if (state->with_stmt) {
-            ptr = plecs_parse_assign_with_var(name, expr, ptr, state);
-            if (!ptr) {
-                return NULL;
-            }
-        } else if (!state->var_stmt) {
-            goto assign_var_as_component;
+    /* Entire query must be cached */
+    if (desc->cache_kind == EcsQueryCacheAll) {
+        if (impl->pub.flags & EcsQueryIsCacheable) {
+            impl->pub.cache_kind = EcsQueryCacheAll;
+            return 0;
+        } else {
+            ecs_err("cannot enforce QueryCacheAll, "
+                "query contains uncacheable terms");
+            return -1;
         }
-    } else if (!(ptr = plecs_parse_plecs_term(world, name, ptr, ptr, state))) {
-        goto error;
     }
 
+    /* Only cache terms that are cacheable */
+    if (kind == EcsQueryCacheAuto) {
+        if (impl->pub.flags & EcsQueryIsCacheable) {
+            /* If all terms of the query are cacheable, just set the policy to 
+             * All which simplifies work for the compiler. */
+            impl->pub.cache_kind = EcsQueryCacheAll;
+        } else if (!(impl->pub.flags & EcsQueryHasCacheable)) {
+            /* Same for when the query has no cacheable terms */
+            impl->pub.cache_kind = EcsQueryCacheNone;
+        } else {
+            /* Part of the query is cacheable */
+            impl->pub.cache_kind = EcsQueryCacheAuto;
+        }
+    }
+
+    return 0;
+}
+
+static
+int flecs_query_create_cache(
+    ecs_query_impl_t *impl,
+    ecs_query_desc_t *desc)
+{
+    ecs_query_t *q = &impl->pub;
+    if (flecs_query_set_caching_policy(impl, desc)) {
+        return -1;
+    }
+
+    if ((q->cache_kind != EcsQueryCacheNone) && !q->entity) {
+        /* Cached queries need an entity handle for observer components */
+        q->entity = ecs_new(q->world);
+        desc->entity = q->entity;
+    }
 
-    const char *tptr = ecs_parse_ws(ptr);
-    if (flecs_isident(tptr[0])) {
-        if (state->decl_stmt) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unexpected ' ' in declaration statement");
+    if (q->cache_kind == EcsQueryCacheAll) {
+        /* Create query cache for all terms */
+        if (!flecs_query_cache_init(impl, desc)) {
             goto error;
         }
-        ptr = tptr;
-        goto decl_stmt;
-    }
-
-next_term:
-    ptr = plecs_parse_fluff(ptr);
-
-    if (ptr[0] == ':' && ptr[1] == '-') {
-        ptr = plecs_parse_fluff(ptr + 2);
-        goto assign_stmt;
-    } else if (ptr[0] == ':') {
-        ptr = plecs_parse_fluff(ptr + 1);
-        goto inherit_stmt;
-    } else if (ptr[0] == ',') {
-        ptr = plecs_parse_fluff(ptr + 1);
-        goto term_expr;
-    } else if (ptr[0] == '{' || ptr[0] == '[') {
-        if (state->assign_stmt) {
-            goto assign_expr;
-        } else if (state->with_stmt && !isspace(ptr[-1])) {
-            /* If this is a { in a with statement which directly follows a
-                * non-whitespace character, the with id has a value */
-            ptr = plecs_parse_assign_with_stmt(world, name, expr, ptr, state);
-            if (!ptr) {
+    } else if (q->cache_kind == EcsQueryCacheAuto) {
+        /* Query is partially cached */
+        ecs_query_desc_t cache_desc = *desc;
+        ecs_os_memset_n(&cache_desc.terms, 0, ecs_term_t, FLECS_TERM_COUNT_MAX);
+        cache_desc.expr = NULL;
+
+        /* Maps field indices from cache to query */
+        int8_t field_map[FLECS_TERM_COUNT_MAX];
+
+        int32_t i, count = q->term_count, dst_count = 0, dst_field = 0;
+        ecs_term_t *terms = q->terms;
+        for (i = 0; i < count; i ++) {
+            ecs_term_t *term = &terms[i];
+            if (term->flags_ & EcsTermIsCacheable) {
+                cache_desc.terms[dst_count] = *term;
+                field_map[dst_field] = flecs_ito(int8_t, term->field_index);
+                dst_count ++;
+                if (i) {
+                    dst_field += term->field_index != term[-1].field_index;
+                } else {
+                    dst_field ++;
+                }
+            }
+        }
+
+        if (dst_count) {
+            if (!flecs_query_cache_init(impl, &cache_desc)) {
                 goto error;
             }
 
-            goto next_term;
-        } else {
-            ptr = plecs_parse_fluff(ptr + 1);
-            goto scope_open;
+            impl->field_map = flecs_alloc_n(&impl->pub.stage->allocator,
+                int8_t, FLECS_TERM_COUNT_MAX);
+
+            ecs_os_memcpy_n(impl->field_map, field_map, int8_t, dst_count);
         }
     }
 
-    state->assign_stmt = false;
-    goto done;
-
-decl_stmt:
-    state->decl_stmt = true;
-    goto term_expr;
-
-inherit_stmt:
-    ptr = plecs_parse_inherit_stmt(name, expr, ptr, state);
-    if (!ptr) goto error;
+    return 0;
+error:
+    return -1;
+}
 
-    /* Expect base identifier */
-    goto term_expr;
+static
+void flecs_query_fini(
+    ecs_query_impl_t *impl)
+{
+    ecs_stage_t *stage = impl->pub.stage;
+    ecs_assert(stage != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_allocator_t *a = &stage->allocator;
 
-assign_stmt:
-    ptr = plecs_parse_assign_stmt(world, name, expr, ptr, state);
-    if (!ptr) goto error;
+    if (impl->ctx_free) {
+        impl->ctx_free(impl->pub.ctx);
+    }
 
-    ptr = plecs_parse_fluff(ptr);
+    if (impl->binding_ctx_free) {
+        impl->binding_ctx_free(impl->pub.binding_ctx);
+    }
 
-    /* Assignment without a preceding component */
-    if (ptr[0] == '{' || ptr[0] == '[') {
-        goto assign_expr;
+    if (impl->vars != &impl->vars_cache.var) {
+        flecs_free(a, (ECS_SIZEOF(ecs_query_var_t) + ECS_SIZEOF(char*)) * 
+            impl->var_size, impl->vars);
     }
 
-    /* Expect component identifiers */
-    goto term_expr;
+    flecs_free_n(a, ecs_query_op_t, impl->op_count, impl->ops);
+    flecs_free_n(a, ecs_var_id_t, impl->pub.field_count, impl->src_vars);
+    flecs_free_n(a, int32_t, impl->pub.field_count, impl->monitor);
+    flecs_free_n(a, int8_t, FLECS_TERM_COUNT_MAX, impl->field_map);
+    flecs_name_index_fini(&impl->tvar_index);
+    flecs_name_index_fini(&impl->evar_index);
 
-assign_expr:
-    ptr = plecs_parse_assign_expr(world, name, expr, ptr, state, NULL);
-    if (!ptr) goto error;
+    ecs_query_t *q = &impl->pub;
+    int i, count = q->term_count;
+    for (i = 0; i < count; i ++) {
+        ecs_term_t *term = &q->terms[i];
+        if (!(term->flags_ & EcsTermKeepAlive)) {
+            continue;
+        }
 
-    ptr = plecs_parse_fluff(ptr);
-    if (ptr[0] == ',') {
-        ptr ++;
-        goto term_expr;
-    } else if (ptr[0] == '{') {
-        if (state->var_stmt) {
-            ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, state->var_name);
-            if (var && var->value.type == ecs_id(ecs_entity_t)) {
-                ecs_assert(var->value.ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-                /* The code contained an entity{...} variable assignment, use
-                 * the assigned entity id as type for parsing the expression */
-                state->last_assign_id = *(ecs_entity_t*)var->value.ptr;
-                ptr = plecs_parse_assign_expr(world, name, expr, ptr, state, var);
-                goto done;
+        ecs_id_record_t *idr = flecs_id_record_get(q->world, term->id);
+        if (idr) {
+            if (!(q->world->flags & EcsWorldQuit)) {
+                if (ecs_os_has_threading()) {
+                    int32_t idr_keep_alive = ecs_os_adec(&idr->keep_alive);
+                    ecs_assert(idr_keep_alive >= 0, ECS_INTERNAL_ERROR, NULL);
+                    (void)idr_keep_alive;
+                } else {
+                    idr->keep_alive --;
+                    ecs_assert(idr->keep_alive >= 0, ECS_INTERNAL_ERROR, NULL);
+                }
             }
         }
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "unexpected '{' after assignment");
-        goto error;
     }
 
-    state->assign_stmt = false;
-    state->assign_to = 0;
-    goto done;
-
-assign_var_as_component: {
-    ptr = plecs_parse_var_as_component(world, name, expr, ptr, state);
-    if (!ptr) {
-        goto error;
+    if (impl->tokens) {
+        flecs_free(&q->stage->allocator, impl->tokens_len, impl->tokens);
     }
-    state->assign_stmt = false;
-    state->assign_to = 0;
-    goto done;
-}
-
-scope_open:
-    ptr = plecs_parse_scope_open(world, name, expr, ptr, state);
-    if (!ptr) goto error;
-    goto done;
 
-scope_close:
-    ptr = plecs_parse_scope_close(world, name, expr, ptr, state);
-    if (!ptr) goto error;
-    goto done;
+    if (impl->cache) {
+        flecs_query_cache_fini(impl);
+    }
 
-done:
-    return ptr;
-error:
-    return NULL;
+    flecs_poly_fini(impl, ecs_query_t);
+    flecs_bfree(&stage->allocators.query_impl, impl);
 }
 
 static
-int flecs_plecs_parse(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    ecs_vars_t *vars,
-    ecs_entity_t script,
-    ecs_entity_t instance)
+char* flecs_query_append_token(
+    char *dst,
+    const char *src)
 {
-    const char *ptr = expr;
-    ecs_term_t term = {0};
-    plecs_state_t state = {0};
-
-    if (!expr) {
-        return 0;
-    }
+    int32_t len = ecs_os_strlen(src);
+    ecs_os_memcpy(dst, src, len + 1);
+    return dst + len + 1;
+}
 
-    state.scope[0] = 0;
-    ecs_entity_t prev_scope = ecs_set_scope(world, 0);
-    ecs_entity_t prev_with = ecs_set_with(world, 0);
+static
+void flecs_query_populate_tokens(
+    ecs_query_impl_t *impl)
+{
+    ecs_query_t *q = &impl->pub;
+    int32_t i, term_count = q->term_count;
 
-    if (ECS_IS_PAIR(prev_with) && ECS_PAIR_FIRST(prev_with) == EcsChildOf) {
-        ecs_set_scope(world, ECS_PAIR_SECOND(prev_with));
-        state.scope[0] = ecs_pair_second(world, prev_with);
-    } else {
-        state.global_with = prev_with;
+    char *old_tokens = impl->tokens;
+    int32_t old_tokens_len = impl->tokens_len;
+    impl->tokens = NULL;
+    impl->tokens_len = 0;
+    
+    /* Step 1: determine size of token buffer */
+    int32_t len = 0;
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &q->terms[i];
+        
+        if (term->first.name) {
+            len += ecs_os_strlen(term->first.name) + 1;
+        }
+        if (term->second.name) {
+            len += ecs_os_strlen(term->second.name) + 1;
+        }
+        if (term->src.name) {
+            len += ecs_os_strlen(term->src.name) + 1;
+        }
     }
 
-    ecs_vars_init(world, &state.vars);
-
-    if (script) {
-        const EcsScript *s = ecs_get(world, script, EcsScript);
-        if (!s) {
-            ecs_err("%s: provided script entity is not a script", name);
-            goto error;
-        }
-        if (s && ecs_has(world, script, EcsStruct)) {
-            state.assembly = script;
-            state.assembly_instance = true;
+    /* Step 2: reassign term tokens to buffer */
+    if (len) {
+        impl->tokens = flecs_alloc(&q->stage->allocator, len);
+        impl->tokens_len = flecs_ito(int16_t, len);
+        char *token = impl->tokens, *next;
 
-            if (s->using_.count) {
-                ecs_os_memcpy_n(state.using, s->using_.array, 
-                    ecs_entity_t, s->using_.count);
-                state.using_frame = s->using_.count;
-                state.using_frames[0] = s->using_.count;
+        for (i = 0; i < term_count; i ++) {
+            ecs_term_t *term = &q->terms[i];
+            if (term->first.name) {
+                next = flecs_query_append_token(token, term->first.name);
+                term->first.name = token;
+                token = next;
             }
-
-            if (instance) {
-                ecs_set_scope(world, instance);
+            if (term->second.name) {
+                next = flecs_query_append_token(token, term->second.name);
+                term->second.name = token;
+                token = next;
+            }
+            if (term->src.name) {
+                next = flecs_query_append_token(token, term->src.name);
+                term->src.name = token;
+                token = next;
             }
         }
     }
 
-    if (vars) {
-        state.vars.root.parent = vars->cur;
+    if (old_tokens) {
+        flecs_free(&q->stage->allocator, old_tokens_len, old_tokens);
     }
+}
 
-    do {
-        expr = ptr = plecs_parse_stmt(world, name, expr, ptr, &state);
-        if (!ptr) {
-            goto error;
-        }
+static
+void flecs_query_add_self_ref(
+    ecs_query_t *q)
+{
+    if (q->entity) {
+        int32_t t, term_count = q->term_count;
+        ecs_term_t *terms = q->terms;
 
-        if (!ptr[0]) {
-            break; /* End of expression */
+        for (t = 0; t < term_count; t ++) {
+            ecs_term_t *term = &terms[t];
+            if (ECS_TERM_REF_ID(&term->src) == q->entity) {
+                ecs_add_id(q->world, q->entity, term->id);
+            }
         }
-    } while (true);
+    }
+}
 
-    ecs_set_scope(world, prev_scope);
-    ecs_set_with(world, prev_with);
-    plecs_clear_annotations(&state);
+void ecs_query_fini(
+    ecs_query_t *q)
+{
+    flecs_poly_assert(q, ecs_query_t);
+
+    if (q->entity) {
+        /* If query is associated with entity, use poly dtor path */
+        ecs_delete(q->world, q->entity);
+    } else {
+        flecs_query_fini(flecs_query_impl(q));
+    }
+}
+
+ecs_query_t* ecs_query_init(
+    ecs_world_t *world, 
+    const ecs_query_desc_t *const_desc)
+{
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
+    ecs_query_impl_t *result = flecs_bcalloc(&stage->allocators.query_impl);
+    flecs_poly_init(result, ecs_query_t);
+    
+    ecs_query_desc_t desc = *const_desc;
+    ecs_entity_t entity = const_desc->entity;
 
-    if (state.is_module) {
-        state.sp --;
+    if (entity) {
+        /* Remove existing query if entity has one */
+        ecs_remove_pair(world, entity, ecs_id(EcsPoly), EcsQuery);
     }
 
-    if (state.sp != 0) {
-        ecs_parser_error(name, expr, 0, "missing end of scope");
+    /* Initialize the query */
+    result->pub.entity = entity;
+    result->pub.world = world;
+    result->pub.stage = stage;
+    if (flecs_query_finalize_query(world, &result->pub, &desc)) {
         goto error;
     }
 
-    if (state.assign_stmt) {
-        ecs_parser_error(name, expr, 0, "unfinished assignment");
+    /* If query terms have itself as source, add term ids to self */
+    flecs_query_add_self_ref(&result->pub);
+
+    /* Store remaining string tokens in terms (after entity lookups) in single
+     * token buffer which simplifies memory management & reduces allocations. */
+    flecs_query_populate_tokens(result);
+
+    /* Initialize static context & mixins */
+    result->pub.stage = stage;
+    result->pub.ctx = const_desc->ctx;
+    result->pub.binding_ctx = const_desc->binding_ctx;
+    result->ctx_free = const_desc->ctx_free;
+    result->binding_ctx_free = const_desc->binding_ctx_free;
+    result->dtor = (flecs_poly_dtor_t)flecs_query_fini;
+    result->cache = NULL;
+
+    /* Initialize query cache if necessary */
+    if (flecs_query_create_cache(result, &desc)) {
         goto error;
     }
 
-    if (state.errors) {
+    /* Compile query to operations */
+    if (flecs_query_compile(world, stage, result)) {
         goto error;
     }
 
-    ecs_vars_fini(&state.vars);
+    /* Entity could've been set by finalize query if query is cached */
+    entity = result->pub.entity;
+    if (entity) {
+        EcsPoly *poly = flecs_poly_bind(world, entity, ecs_query_t);
+        poly->poly = result;
+        flecs_poly_modified(world, entity, ecs_query_t);
+    }
 
-    return 0;
+    return &result->pub;
 error:
-    plecs_free_all_with_frames(world, &state);
-    ecs_vars_fini(&state.vars);
-    ecs_set_scope(world, state.scope[0]);
-    ecs_set_with(world, prev_with);
-    ecs_term_fini(&term);
-    return -1;
+    result->pub.entity = 0;
+    ecs_query_fini(&result->pub);
+    return NULL;
 }
 
-int ecs_plecs_from_str(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr)
+bool ecs_query_has(
+    ecs_query_t *q,
+    ecs_entity_t entity,
+    ecs_iter_t *it)
 {
-    return flecs_plecs_parse(world, name, expr, NULL, 0, 0);
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_check(q->flags & EcsQueryMatchThis, ECS_INVALID_PARAMETER, NULL);
+
+    *it = ecs_query_iter(q->world, q);
+    ecs_iter_set_var(it, 0, entity);
+    return ecs_query_next(it);
+error:
+    return false;
 }
 
-int ecs_plecs_from_file(
-    ecs_world_t *world,
-    const char *filename) 
+bool ecs_query_has_table(
+    ecs_query_t *q,
+    ecs_table_t *table,
+    ecs_iter_t *it)
 {
-    char *script = flecs_load_from_file(filename);
-    if (!script) {
-        return -1;
-    }
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_check(q->flags & EcsQueryMatchThis, ECS_INVALID_PARAMETER, NULL);
 
-    int result = ecs_plecs_from_str(world, filename, script);
-    ecs_os_free(script);
-    return result;
+    *it = ecs_query_iter(q->world, q);
+    ecs_iter_set_var_as_table(it, 0, table);
+    return ecs_query_next(it);
+error:
+    return false;
 }
 
-static
-ecs_id_t flecs_script_tag(
-    ecs_entity_t script,
-    ecs_entity_t instance)
+bool ecs_query_has_range(
+    ecs_query_t *q,
+    ecs_table_range_t *range,
+    ecs_iter_t *it)
 {
-    if (!instance) {
-        return ecs_pair_t(EcsScript, script);
-    } else {
-        return ecs_pair(EcsChildOf, instance);
+    flecs_poly_assert(q, ecs_query_t);
+
+    if (q->flags & EcsQueryMatchThis) {
+        if (range->table) {
+            if ((range->offset + range->count) > ecs_table_count(range->table)) {
+                return false;
+            }
+        }
     }
-}
 
-void ecs_script_clear(
-    ecs_world_t *world,
-    ecs_entity_t script,
-    ecs_entity_t instance)
-{
-    ecs_delete_with(world, flecs_script_tag(script, instance));
+    *it = ecs_query_iter(q->world, q);
+    if (q->flags & EcsQueryMatchThis) {
+        ecs_iter_set_var_as_range(it, 0, range);
+    }
+
+    return ecs_query_next(it);
 }
 
-int ecs_script_update(
-    ecs_world_t *world,
-    ecs_entity_t e,
-    ecs_entity_t instance,
-    const char *script,
-    ecs_vars_t *vars)
+ecs_query_count_t ecs_query_count(
+    const ecs_query_t *q)
 {
-    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(script != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_count_t result = {0};
 
-    int result = 0;
-    bool is_defer = ecs_is_deferred(world);
-    ecs_suspend_readonly_state_t srs;
-    ecs_world_t *real_world = NULL;
-    if (is_defer) {
-        ecs_assert(ecs_poly_is(world, ecs_world_t), ECS_INTERNAL_ERROR, NULL);
-        real_world = flecs_suspend_readonly(world, &srs);
-        ecs_assert(real_world != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (!(q->flags & EcsQueryMatchThis)) {
+        return result;
     }
 
-    ecs_script_clear(world, e, instance);
-
-    EcsScript *s = ecs_ensure(world, e, EcsScript);
-    if (!s->script || ecs_os_strcmp(s->script, script)) {
-        s->script = ecs_os_strdup(script);
-        ecs_modified(world, e, EcsScript);
-    }
+    ecs_run_aperiodic(q->world, EcsAperiodicEmptyTables);
 
-    ecs_entity_t prev = ecs_set_with(world, flecs_script_tag(e, instance));
-    if (flecs_plecs_parse(world, ecs_get_name(world, e), script, vars, e, instance)) {
-        ecs_delete_with(world, ecs_pair_t(EcsScript, e));
-        result = -1;
-    }
-    ecs_set_with(world, prev);
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    if (impl->cache && q->flags & EcsQueryIsCacheable) {
+        result.results = flecs_query_cache_table_count(impl->cache);
+        result.entities = flecs_query_cache_entity_count(impl->cache);
+        result.tables = flecs_query_cache_table_count(impl->cache);
+        result.empty_tables = flecs_query_cache_empty_table_count(impl->cache);
+    } else {
+        ecs_iter_t it = flecs_query_iter(q->world, q);
+        it.flags |= EcsIterIsInstanced;
+        it.flags |= EcsIterNoData;
 
-    if (is_defer) {
-        flecs_resume_readonly(real_world, &srs);
+        while (ecs_query_next_instanced(&it)) {
+            result.results ++;
+            result.entities += it.count;
+        }
     }
 
     return result;
 }
 
-ecs_entity_t ecs_script_init(
-    ecs_world_t *world,
-    const ecs_script_desc_t *desc)
+bool ecs_query_is_true(
+    const ecs_query_t *q)
 {
-    const char *script = NULL;
-    ecs_entity_t e = desc->entity;
-    
-    ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_check(desc != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(q, ecs_query_t);
 
-    if (!e) {
-        if (desc->filename) {
-            e = ecs_new_from_path_w_sep(world, 0, desc->filename, "/", NULL);
-        } else {
-            e = ecs_new_id(world);
-        }
-    }
+    ecs_run_aperiodic(q->world, EcsAperiodicEmptyTables);
 
-    script = desc->str;
-    if (!script && desc->filename) {
-        script = flecs_load_from_file(desc->filename);
-        if (!script) {
-            goto error;
-        }
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    if (impl->cache && q->flags & EcsQueryIsCacheable) {
+        return flecs_query_cache_table_count(impl->cache) != 0;
+    } else {
+        ecs_iter_t it = flecs_query_iter(q->world, q);
+        return ecs_iter_is_true(&it);
     }
+}
 
-    if (ecs_script_update(world, e, 0, script, NULL)) {
-        goto error;
-    }
+int32_t ecs_query_match_count(
+    const ecs_query_t *q)
+{
+    flecs_poly_assert(q, ecs_query_t);
 
-    if (script != desc->str) {
-        /* Safe cast, only happens when script is loaded from file */
-        ecs_os_free(ECS_CONST_CAST(char*, script));
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    if (!impl->cache) {
+        return 0;
+    } else {
+        return impl->cache->match_count;
     }
+}
 
-    return e;
-error:
-    if (script != desc->str) {
-        /* Safe cast, only happens when script is loaded from file */
-        ecs_os_free(ECS_CONST_CAST(char*, script));
-    }
-    if (!desc->entity) {
-        ecs_delete(world, e);
-    }
-    return 0;
+/**
+ * @file query/cache.c
+ * @brief Cached query implementation.
+ */
+
+
+int32_t flecs_query_cache_table_count(
+    ecs_query_cache_t *cache)
+{
+    ecs_run_aperiodic(cache->query->world, EcsAperiodicEmptyTables);
+    return cache->cache.tables.count;
 }
 
-void FlecsScriptImport(
-    ecs_world_t *world)
+int32_t flecs_query_cache_empty_table_count(
+    ecs_query_cache_t *cache)
 {
-    ECS_MODULE(world, FlecsScript);
-    ECS_IMPORT(world, FlecsMeta);
-#ifdef FLECS_DOC
-    ECS_IMPORT(world, FlecsDoc);
-    ecs_doc_set_brief(world, ecs_id(FlecsScript), 
-        "Module with components for managing Flecs scripts");
-#endif
+    ecs_run_aperiodic(cache->query->world, EcsAperiodicEmptyTables);
+    return cache->cache.empty_tables.count;
+}
 
-    ecs_set_name_prefix(world, "Ecs");
-    ECS_COMPONENT_DEFINE(world, EcsScript);
+int32_t flecs_query_cache_entity_count(
+    const ecs_query_cache_t *cache)
+{
+    ecs_run_aperiodic(cache->query->world, EcsAperiodicEmptyTables);
+    
+    int32_t result = 0;
+    ecs_table_cache_hdr_t *cur, *last = cache->cache.tables.last;
+    if (!last) {
+        return 0;
+    }
 
-    ecs_set_hooks(world, EcsScript, {
-        .ctor = ecs_default_ctor,
-        .move = ecs_move(EcsScript),
-        .dtor = ecs_dtor(EcsScript)
-    });
+    for (cur = cache->cache.tables.first; cur != NULL; cur = cur->next) {
+        result += ecs_table_count(cur->table);
+    }
 
-    ecs_add_id(world, ecs_id(EcsScript), EcsTag);
-    ecs_add_id(world, ecs_id(EcsScript), EcsPrivate);
+    return result;
+}
 
-    ecs_struct(world, {
-        .entity = ecs_id(EcsScript),
-        .members = {
-            { .name = "using", .type = ecs_vector(world, { 
-                    .entity = ecs_entity(world, { .name = "UsingVector" }),
-                    .type = ecs_id(ecs_entity_t)
-                }),
-                .count = 0
-            },
-            { .name = "script", .type = ecs_id(ecs_string_t), .count = 0 }
-        }
-    });
+static
+uint64_t flecs_query_cache_get_group_id(
+    ecs_query_cache_t *cache,
+    ecs_table_t *table)
+{
+    if (cache->group_by_callback) {
+        return cache->group_by_callback(cache->query->world, table, 
+            cache->group_by, cache->group_by_ctx);
+    } else {
+        return 0;
+    }
 }
 
-#endif
+static
+void flecs_query_cache_compute_group_id(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
+{
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
 
-/**
- * @file addons/rest.c
- * @brief Rest addon.
- */
+    if (cache->group_by_callback) {
+        ecs_table_t *table = match->table;
+        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
 
+        match->group_id = flecs_query_cache_get_group_id(cache, table);
+    } else {
+        match->group_id = 0;
+    }
+}
 
-#ifdef FLECS_REST
+static
+ecs_query_cache_table_list_t* flecs_query_cache_get_group(
+    const ecs_query_cache_t *cache,
+    uint64_t group_id)
+{
+    return ecs_map_get_deref(
+        &cache->groups, ecs_query_cache_table_list_t, group_id);
+}
 
-/* Retain captured commands for one minute at 60 FPS */
-#define FLECS_REST_COMMAND_RETAIN_COUNT (60 * 60)
+static
+ecs_query_cache_table_list_t* flecs_query_cache_ensure_group(
+    ecs_query_cache_t *cache,
+    uint64_t id)
+{
+    ecs_query_cache_table_list_t *group = ecs_map_get_deref(&cache->groups, 
+        ecs_query_cache_table_list_t, id);
 
-static ECS_TAG_DECLARE(EcsRestPlecs);
+    if (!group) {
+        group = ecs_map_insert_alloc_t(&cache->groups, 
+            ecs_query_cache_table_list_t, id);
+        ecs_os_zeromem(group);
+        if (cache->on_group_create) {
+            group->info.ctx = cache->on_group_create(
+                cache->query->world, id, cache->group_by_ctx);
+        }
+    }
 
-typedef struct {
-    ecs_world_t *world;
-    ecs_http_server_t *srv;
-    int32_t rc;
-    ecs_map_t cmd_captures;
-} ecs_rest_ctx_t;
+    return group;
+}
 
-typedef struct {
-    char *cmds;
-    ecs_time_t start_time;
-    ecs_strbuf_t buf;
-} ecs_rest_cmd_sync_capture_t;
+static
+void flecs_query_cache_remove_group(
+    ecs_query_cache_t *cache,
+    uint64_t id)
+{
+    if (cache->on_group_delete) {
+        ecs_query_cache_table_list_t *group = ecs_map_get_deref(&cache->groups, 
+            ecs_query_cache_table_list_t, id);
+        if (group) {
+            cache->on_group_delete(cache->query->world, id, 
+                group->info.ctx, cache->group_by_ctx);
+        }
+    }
 
-typedef struct {
-    ecs_vec_t syncs;
-} ecs_rest_cmd_capture_t;
+    ecs_map_remove_free(&cache->groups, id);
+}
 
-static ECS_COPY(EcsRest, dst, src, {
-    ecs_rest_ctx_t *impl = src->impl;
-    if (impl) {
-        impl->rc ++;
+static
+uint64_t flecs_query_cache_default_group_by(
+    ecs_world_t *world, 
+    ecs_table_t *table, 
+    ecs_id_t id, 
+    void *ctx) 
+{
+    (void)ctx;
+
+    ecs_id_t match;
+    if (ecs_search(world, table, ecs_pair(id, EcsWildcard), &match) != -1) {
+        return ecs_pair_second(world, match);
     }
+    return 0;
+}
 
-    ecs_os_strset(&dst->ipaddr, src->ipaddr);
-    dst->port = src->port;
-    dst->impl = impl;
-})
+/* Find the last node of the group after which this group should be inserted */
+static
+ecs_query_cache_table_match_t* flecs_query_cache_find_group_insertion_node(
+    ecs_query_cache_t *cache,
+    uint64_t group_id)
+{
+    /* Grouping must be enabled */
+    ecs_assert(cache->group_by_callback != NULL, ECS_INTERNAL_ERROR, NULL);
 
-static ECS_MOVE(EcsRest, dst, src, {
-    *dst = *src;
-    src->ipaddr = NULL;
-    src->impl = NULL;
-})
+    ecs_map_iter_t it = ecs_map_iter(&cache->groups);
+    ecs_query_cache_table_list_t *list, *closest_list = NULL;
+    uint64_t id, closest_id = 0;
+    
+    bool desc = false;
 
-static ECS_DTOR(EcsRest, ptr, { 
-    ecs_rest_ctx_t *impl = ptr->impl;
-    if (impl) {
-        impl->rc --;
-        if (!impl->rc) {
-            ecs_rest_server_fini(impl->srv);
-        }
+    if (cache->cascade_by) {
+        desc = (cache->query->terms[
+            cache->cascade_by - 1].src.id & EcsDesc) != 0;
     }
-    ecs_os_free(ptr->ipaddr);
-})
 
-static char *rest_last_err;
-static ecs_os_api_log_t rest_prev_log;
+    /* Find closest smaller group id */
+    while (ecs_map_next(&it)) {
+        id = ecs_map_key(&it);
 
-static 
-void flecs_rest_capture_log(
-    int32_t level, 
-    const char *file, 
-    int32_t line, 
-    const char *msg)
-{
-    (void)file; (void)line;
+        if (!desc) {
+            if (id >= group_id) {
+                continue;
+            }
+        } else {
+            if (id <= group_id) {
+                continue;
+            }
+        }
 
-#ifdef FLECS_DEBUG
-    if (level < 0) {
-        /* Also log to previous log function in debug mode */
-        if (rest_prev_log) {
-            ecs_log_enable_colors(true);
-            rest_prev_log(level, file, line, msg);
-            ecs_log_enable_colors(false);
+        list = ecs_map_ptr(&it);
+        if (!list->last) {
+            ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL);
+            continue;
         }
-    }
-#endif
 
-    if (!rest_last_err && level < 0) {
-        rest_last_err = ecs_os_strdup(msg);
+        bool comp;
+        if (!desc) {
+            comp = ((group_id - id) < (group_id - closest_id));
+        } else {
+            comp = ((group_id - id) > (group_id - closest_id));
+        }
+
+        if (!closest_list || comp) {
+            closest_id = id;
+            closest_list = list;
+        }
     }
-}
 
-static
-char* flecs_rest_get_captured_log(void) {
-    char *result = rest_last_err;
-    rest_last_err = NULL;
-    return result;
+    if (closest_list) {
+        return closest_list->last;
+    } else {
+        return NULL; /* Group should be first in query */
+    }
 }
 
+/* Initialize group with first node */
 static
-void flecs_reply_verror(
-    ecs_http_reply_t *reply,
-    const char *fmt,
-    va_list args)
+void flecs_query_cache_create_group(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
 {
-    ecs_strbuf_appendlit(&reply->body, "{\"error\":\"");
-    ecs_strbuf_vappend(&reply->body, fmt, args);
-    ecs_strbuf_appendlit(&reply->body, "\"}");
-}
+    uint64_t group_id = match->group_id;
 
-static
-void flecs_reply_error(
-    ecs_http_reply_t *reply,
-    const char *fmt,
-    ...)
-{
-    va_list args;
-    va_start(args, fmt);
-    flecs_reply_verror(reply, fmt, args);
-    va_end(args);
-}
+    /* If query has grouping enabled & this is a new/empty group, find
+     * the insertion point for the group */
+    ecs_query_cache_table_match_t *insert_after = 
+        flecs_query_cache_find_group_insertion_node(cache, group_id);
 
-static
-void flecs_rest_bool_param(
-    const ecs_http_request_t *req,
-    const char *name,
-    bool *value_out)
-{
-    const char *value = ecs_http_get_param(req, name);
-    if (value) {
-        if (!ecs_os_strcmp(value, "true")) {
-            value_out[0] = true;
+    if (!insert_after) {
+        /* This group should appear first in the query list */
+        ecs_query_cache_table_match_t *query_first = cache->list.first;
+        if (query_first) {
+            /* If this is not the first match for the query, insert before it */
+            match->next = query_first;
+            query_first->prev = match;
+            cache->list.first = match;
         } else {
-            value_out[0] = false;
+            /* If this is the first match of the query, initialize its list */
+            ecs_assert(cache->list.last == NULL, ECS_INTERNAL_ERROR, NULL);
+            cache->list.first = match;
+            cache->list.last = match;
+        }
+    } else {
+        ecs_assert(cache->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(cache->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        /* This group should appear after another group */
+        ecs_query_cache_table_match_t *insert_before = insert_after->next;
+        match->prev = insert_after;
+        insert_after->next = match;
+        match->next = insert_before;
+        if (insert_before) {
+            insert_before->prev = match;
+        } else {
+            ecs_assert(cache->list.last == insert_after, 
+                ECS_INTERNAL_ERROR, NULL);
+                
+            /* This group should appear last in the query list */
+            cache->list.last = match;
         }
     }
 }
 
+/* Find the list the node should be part of */
 static
-void flecs_rest_int_param(
-    const ecs_http_request_t *req,
-    const char *name,
-    int32_t *value_out)
+ecs_query_cache_table_list_t* flecs_query_cache_get_node_list(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
 {
-    const char *value = ecs_http_get_param(req, name);
-    if (value) {
-        *value_out = atoi(value);
+    if (cache->group_by_callback) {
+        return flecs_query_cache_get_group(cache, match->group_id);
+    } else {
+        return &cache->list;
     }
 }
 
+/* Find or create the list the node should be part of */
 static
-void flecs_rest_string_param(
-    const ecs_http_request_t *req,
-    const char *name,
-    char **value_out)
+ecs_query_cache_table_list_t* flecs_query_cache_ensure_node_list(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
 {
-    const char *value = ecs_http_get_param(req, name);
-    if (value) {
-        *value_out = ECS_CONST_CAST(char*, value);
+    if (cache->group_by_callback) {
+        return flecs_query_cache_ensure_group(cache, match->group_id);
+    } else {
+        return &cache->list;
     }
 }
 
+/* Remove node from list */
 static
-void flecs_rest_parse_json_ser_entity_params(
-    ecs_world_t *world,
-    ecs_entity_to_json_desc_t *desc,
-    const ecs_http_request_t *req)
+void flecs_query_cache_remove_table_node(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
 {
-    flecs_rest_bool_param(req, "path", &desc->serialize_path);
-    flecs_rest_bool_param(req, "label", &desc->serialize_label);
-    flecs_rest_bool_param(req, "brief", &desc->serialize_brief);
-    flecs_rest_bool_param(req, "link", &desc->serialize_link);
-    flecs_rest_bool_param(req, "color", &desc->serialize_color);
-    flecs_rest_bool_param(req, "ids", &desc->serialize_ids);
-    flecs_rest_bool_param(req, "id_labels", &desc->serialize_id_labels);
-    flecs_rest_bool_param(req, "base", &desc->serialize_base);
-    flecs_rest_bool_param(req, "values", &desc->serialize_values);
-    flecs_rest_bool_param(req, "private", &desc->serialize_private);
-    flecs_rest_bool_param(req, "type_info", &desc->serialize_type_info);
-    flecs_rest_bool_param(req, "matches", &desc->serialize_matches);
-    flecs_rest_bool_param(req, "alerts", &desc->serialize_alerts);
+    ecs_query_cache_table_match_t *prev = match->prev;
+    ecs_query_cache_table_match_t *next = match->next;
 
-    char *rel = NULL;
-    flecs_rest_string_param(req, "refs", &rel);
-    if (rel) {
-        desc->serialize_refs = ecs_lookup(world, rel);
+    ecs_assert(prev != match, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(next != match, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!prev || prev != next, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_query_cache_table_list_t *list = 
+        flecs_query_cache_get_node_list(cache, match);
+
+    if (!list || !list->first) {
+        /* If list contains no matches, the match must be empty */
+        ecs_assert(!list || list->last == NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL);
+        return;
     }
-}
 
-static
-void flecs_rest_parse_json_ser_iter_params(
-    ecs_iter_to_json_desc_t *desc,
-    const ecs_http_request_t *req)
-{
-    flecs_rest_bool_param(req, "term_ids", &desc->serialize_term_ids);
-    flecs_rest_bool_param(req, "term_labels", &desc->serialize_term_labels);
-    flecs_rest_bool_param(req, "ids", &desc->serialize_ids);
-    flecs_rest_bool_param(req, "id_labels", &desc->serialize_id_labels);
-    flecs_rest_bool_param(req, "sources", &desc->serialize_sources);
-    flecs_rest_bool_param(req, "variables", &desc->serialize_variables);
-    flecs_rest_bool_param(req, "is_set", &desc->serialize_is_set);
-    flecs_rest_bool_param(req, "values", &desc->serialize_values);
-    flecs_rest_bool_param(req, "private", &desc->serialize_private);
-    flecs_rest_bool_param(req, "entities", &desc->serialize_entities);
-    flecs_rest_bool_param(req, "entity_labels", &desc->serialize_entity_labels);
-    flecs_rest_bool_param(req, "variable_labels", &desc->serialize_variable_labels);
-    flecs_rest_bool_param(req, "variable_ids", &desc->serialize_variable_ids);
-    flecs_rest_bool_param(req, "colors", &desc->serialize_colors);
-    flecs_rest_bool_param(req, "duration", &desc->measure_eval_duration);
-    flecs_rest_bool_param(req, "type_info", &desc->serialize_type_info);
-    flecs_rest_bool_param(req, "field_info", &desc->serialize_field_info);
-    flecs_rest_bool_param(req, "query_info", &desc->serialize_query_info);
-    flecs_rest_bool_param(req, "query_plan", &desc->serialize_query_plan);
-    flecs_rest_bool_param(req, "query_profile", &desc->serialize_query_profile);
-    flecs_rest_bool_param(req, "table", &desc->serialize_table);
-    flecs_rest_bool_param(req, "rows", &desc->serialize_rows);
-    bool results = true;
-    flecs_rest_bool_param(req, "results", &results);
-    desc->dont_serialize_results = !results;
-}
+    ecs_assert(prev != NULL || cache->list.first == match, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(next != NULL || cache->list.last == match, 
+        ECS_INTERNAL_ERROR, NULL);
 
-static
-bool flecs_rest_reply_entity(
-    ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply)
-{
-    char *path = &req->path[7];
-    ecs_dbg_2("rest: request entity '%s'", path);
+    if (prev) {
+        prev->next = next;
+    }
+    if (next) {
+        next->prev = prev;
+    }
 
-    ecs_entity_t e = ecs_lookup_path_w_sep(
-        world, 0, path, "/", NULL, false);
-    if (!e) {
-        ecs_dbg_2("rest: entity '%s' not found", path);
-        flecs_reply_error(reply, "entity '%s' not found", path);
-        reply->code = 404;
-        return true;
+    ecs_assert(list->info.table_count > 0, ECS_INTERNAL_ERROR, NULL);
+    list->info.table_count --;
+
+    if (cache->group_by_callback) {
+        uint64_t group_id = match->group_id;
+
+        /* Make sure query.list is updated if this is the first or last group */
+        if (cache->list.first == match) {
+            ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL);
+            cache->list.first = next;
+            prev = next;
+        }
+        if (cache->list.last == match) {
+            ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL);
+            cache->list.last = prev;
+            next = prev;
+        }
+
+        ecs_assert(cache->list.info.table_count > 0, ECS_INTERNAL_ERROR, NULL);
+        cache->list.info.table_count --;
+        list->info.match_count ++;
+
+        /* Make sure group list only contains nodes that belong to the group */
+        if (prev && prev->group_id != group_id) {
+            /* The previous node belonged to another group */
+            prev = next;
+        }
+        if (next && next->group_id != group_id) {
+            /* The next node belonged to another group */
+            next = prev;
+        }
+
+        /* Do check again, in case both prev & next belonged to another group */
+        if ((!prev && !next) || (prev && prev->group_id != group_id)) {
+            /* There are no more matches left in this group */
+            flecs_query_cache_remove_group(cache, group_id);
+            list = NULL;
+        }
     }
 
-    ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
-    flecs_rest_parse_json_ser_entity_params(world, &desc, req);
-    if (ecs_entity_to_json_buf(world, e, &reply->body, &desc) != 0) {
-        ecs_strbuf_reset(&reply->body);
-        reply->code = 500;
-        reply->status = "Internal server error";
-        return true;
+    if (list) {
+        if (list->first == match) {
+            list->first = next;
+        }
+        if (list->last == match) {
+            list->last = prev;
+        }
     }
-    return true;
+
+    match->prev = NULL;
+    match->next = NULL;
+
+    cache->match_count ++;
 }
 
+/* Add node to list */
 static
-bool flecs_rest_reply_world(
-    ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply)
+void flecs_query_cache_insert_table_node(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
 {
-    (void)req;
-    if (ecs_world_to_json_buf(world, &reply->body, NULL) != 0) {
-        ecs_strbuf_reset(&reply->body);
-        reply->code = 500;
-        reply->status = "Internal server error";
-        return true;
+    /* Node should not be part of an existing list */
+    ecs_assert(match->prev == NULL && match->next == NULL, 
+        ECS_INTERNAL_ERROR, NULL);
+
+    /* If this is the first match, activate system */
+    if (!cache->list.first && cache->entity) {
+        ecs_remove_id(cache->query->world, cache->entity, EcsEmpty);
     }
-    return true;
-}
 
-static
-ecs_entity_t flecs_rest_entity_from_path(
-    ecs_world_t *world,
-    ecs_http_reply_t *reply,
-    const char *path)
-{
-    ecs_entity_t e = ecs_lookup_path_w_sep(
-        world, 0, path, "/", NULL, false);
-    if (!e) {
-        flecs_reply_error(reply, "entity '%s' not found", path);
-        reply->code = 404;
+    flecs_query_cache_compute_group_id(cache, match);
+
+    ecs_query_cache_table_list_t *list = 
+        flecs_query_cache_ensure_node_list(cache, match);
+    if (list->last) {
+        ecs_assert(cache->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(cache->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        ecs_query_cache_table_match_t *last = list->last;
+        ecs_query_cache_table_match_t *last_next = last->next;
+
+        match->prev = last;
+        match->next = last_next;
+        last->next = match;
+
+        if (last_next) {
+            last_next->prev = match;
+        }
+
+        list->last = match;
+
+        if (cache->group_by_callback) {
+            /* Make sure to update query list if this is the last group */
+            if (cache->list.last == last) {
+                cache->list.last = match;
+            }
+        }
+    } else {
+        ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL);
+
+        list->first = match;
+        list->last = match;
+
+        if (cache->group_by_callback) {
+            /* Initialize group with its first node */
+            flecs_query_cache_create_group(cache, match);
+        }
     }
-    return e;
+
+    if (cache->group_by_callback) {
+        list->info.table_count ++;
+        list->info.match_count ++;
+    }
+
+    cache->list.info.table_count ++;
+    cache->match_count ++;
+
+    ecs_assert(match->prev != match, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(match->next != match, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(list->last != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(list->last == match, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cache->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cache->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cache->list.first->prev == NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cache->list.last->next == NULL, ECS_INTERNAL_ERROR, NULL);
 }
 
 static
-bool flecs_rest_set(
+ecs_query_cache_table_match_t* flecs_query_cache_cache_add(
     ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply,
-    const char *path)
+    ecs_query_cache_table_t *elem)
 {
-    ecs_entity_t e;
-    if (!(e = flecs_rest_entity_from_path(world, reply, path))) {
-        return true;
-    }
+    ecs_query_cache_table_match_t *result = 
+        flecs_bcalloc(&world->allocators.query_table_match);
 
-    const char *data = ecs_http_get_param(req, "data");
-    ecs_from_json_desc_t desc = {0};
-    desc.expr = data;
-    desc.name = path;
-    if (ecs_entity_from_json(world, e, data, &desc) == NULL) {
-        flecs_reply_error(reply, "invalid request");
-        reply->code = 400;
-        return true;
+    if (!elem->first) {
+        elem->first = result;
+        elem->last = result;
+    } else {
+        ecs_assert(elem->last != NULL, ECS_INTERNAL_ERROR, NULL);
+        elem->last->next_match = result;
+        elem->last = result;
     }
-    
-    return true;
+
+    return result;
 }
 
+/* The group by function for cascade computes the tree depth for the table type.
+ * This causes tables in the query cache to be ordered by depth, which ensures
+ * breadth-first iteration order. */
 static
-bool flecs_rest_delete(
+uint64_t flecs_query_cache_group_by_cascade(
     ecs_world_t *world,
-    ecs_http_reply_t *reply,
-    const char *path)
+    ecs_table_t *table,
+    ecs_id_t id,
+    void *ctx)
 {
-    ecs_entity_t e;
-    if (!(e = flecs_rest_entity_from_path(world, reply, path))) {
-        return true;
-    }
-
-    ecs_delete(world, e);
-    
-    return true;
+    (void)id;
+    ecs_term_t *term = ctx;
+    ecs_entity_t rel = term->trav;
+    int32_t depth = flecs_relation_depth(world, rel, table);
+    return flecs_ito(uint64_t, depth);
 }
 
 static
-bool flecs_rest_enable(
+void flecs_query_cache_add_ref(
     ecs_world_t *world,
-    ecs_http_reply_t *reply,
-    const char *path,
-    bool enable)
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *qm,
+    ecs_entity_t component,
+    ecs_entity_t entity,
+    ecs_size_t size)
 {
-    ecs_entity_t e;
-    if (!(e = flecs_rest_entity_from_path(world, reply, path))) {
-        return true;
+    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_ref_t *ref = ecs_vec_append_t(&world->allocator, &qm->refs, ecs_ref_t);
+    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
+    
+    if (size) {
+        *ref = ecs_ref_init_id(world, entity, component);
+    } else {
+        *ref = (ecs_ref_t){
+            .entity = entity,
+            .id = 0
+        };
     }
 
-    ecs_enable(world, e, enable);
-    
-    return true;
+    impl->pub.flags |= EcsQueryHasRefs;
 }
 
 static
-bool flecs_rest_script(
-    ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply)
+ecs_query_cache_table_match_t* flecs_query_cache_add_table_match(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_t *qt,
+    ecs_table_t *table)
 {
-    (void)world;
-    (void)req;
-    (void)reply;
-#ifdef FLECS_PLECS
-    const char *data = ecs_http_get_param(req, "data");
-    if (!data) {
-        flecs_reply_error(reply, "missing data parameter");
-        return true;
-    }
-
-    bool prev_color = ecs_log_enable_colors(false);
-    rest_prev_log = ecs_os_api.log_;
-    ecs_os_api.log_ = flecs_rest_capture_log;
+    /* Add match for table. One table can have more than one match, if
+     * the query contains wildcards. */
+    ecs_query_cache_table_match_t *qm = flecs_query_cache_cache_add(
+        cache->query->world, qt);
+    qm->table = table;
 
-    ecs_entity_t script = ecs_script(world, {
-        .entity = ecs_entity(world, { .name = "scripts.main" }),
-        .str = data
-    });
+    qm->columns = flecs_balloc(&cache->allocators.columns);
+    qm->storage_columns = flecs_balloc(&cache->allocators.columns);
+    qm->ids = flecs_balloc(&cache->allocators.ids);
+    qm->sources = flecs_balloc(&cache->allocators.sources);
 
-    if (!script) {
-        char *err = flecs_rest_get_captured_log();
-        char *escaped_err = ecs_astresc('"', err);
-        flecs_reply_error(reply, escaped_err);
-        reply->code = 400; /* bad request */
-        ecs_os_free(escaped_err);
-        ecs_os_free(err);
+    /* Insert match to iteration list if table is not empty */
+    if (!table || ecs_table_count(table) != 0) {
+        flecs_query_cache_insert_table_node(cache, qm);
     }
 
-    ecs_os_api.log_ = rest_prev_log;
-    ecs_log_enable_colors(prev_color);
-
-    return true;
-#else
-    return false;
-#endif
+    return qm;
 }
 
 static
-void flecs_rest_reply_set_captured_log(
-    ecs_http_reply_t *reply)
+void flecs_query_cache_set_table_match(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *qm,
+    ecs_table_t *table,
+    ecs_iter_t *it)
 {
-    char *err = flecs_rest_get_captured_log();
-    if (err) {
-        char *escaped_err = ecs_astresc('"', err);
-        flecs_reply_error(reply, escaped_err);
-        ecs_os_free(escaped_err);
-        ecs_os_free(err);
+    ecs_allocator_t *a = &world->allocator;
+    ecs_query_t *query = cache->query;
+    int32_t i, term_count = query->term_count;
+    int32_t field_count = query->field_count;
+    ecs_term_t *terms = query->terms;
+
+    /* Reset resources in case this is an existing record */
+    ecs_vec_reset_t(a, &qm->refs, ecs_ref_t);
+    ecs_os_memcpy_n(qm->columns, it->columns, int32_t, field_count);
+    ecs_os_memcpy_n(qm->ids, it->ids, ecs_id_t, field_count);
+    ecs_os_memcpy_n(qm->sources, it->sources, ecs_entity_t, field_count);
+    qm->set_fields = it->set_fields;
+    qm->up_fields = it->up_fields;
+
+    if (table) {
+        /* Initialize storage columns for faster access to component storage */
+        for (i = 0; i < field_count; i ++) {
+            int32_t column = it->columns[i];
+            if (!ecs_field_is_set(it, i) || terms[i].inout == EcsInOutNone) {
+                qm->storage_columns[i] = -1;
+                continue;
+            }
+
+            ecs_entity_t src = it->sources[i];
+            if (!src) {
+                qm->storage_columns[i] = ecs_table_type_to_column_index(
+                    table, column);
+            } else {
+                /* Shared field (not from table) */
+                qm->storage_columns[i] = -2;
+            }
+        }
     }
 
-    reply->code = 400;
+    /* Add references for substituted terms */
+    for (i = 0; i < term_count; i ++) {
+        int32_t field = terms[i].field_index;
+        ecs_entity_t src = it->sources[field];
+        ecs_size_t size = 0;
+        if (it->sizes) {
+            size = it->sizes[field];
+        }
+        if (src) {
+            ecs_id_t id = it->ids[field];
+            ecs_assert(ecs_is_valid(world, src), ECS_INTERNAL_ERROR, NULL);
+
+            if (id) {
+                flecs_query_cache_add_ref(
+                    world, impl, qm, id, src, size);
+
+                /* Use column index to bind term and ref */
+                if (qm->set_fields & (1llu << field)) {
+                    qm->columns[field] = ecs_vec_count(&qm->refs) - 1;
+                }
+            }
+        }
+    }
 }
 
 static
-void flecs_rest_iter_to_reply(
+ecs_query_cache_table_t* flecs_query_cache_table_insert(
     ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply,
-    ecs_poly_t *query,
-    ecs_iter_t *it)
+    ecs_query_cache_t *cache,
+    ecs_table_t *table)
 {
-    ecs_iter_to_json_desc_t desc = {0};
-    desc.serialize_entities = true;
-    desc.serialize_variables = true;
-    flecs_rest_parse_json_ser_iter_params(&desc, req);
-    desc.query = query;
+    ecs_query_cache_table_t *qt = flecs_bcalloc(&world->allocators.query_table);
+    if (table) {
+        qt->table_id = table->id;
+    } else {
+        qt->table_id = 0;
+    }
+    ecs_table_cache_insert(&cache->cache, table, &qt->hdr);
+    return qt;
+}
 
-    int32_t offset = 0;
-    int32_t limit = 1000;
+/** Populate query cache with tables */
+static
+void flecs_query_cache_match_tables(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache)
+{
+    ecs_table_t *table = NULL;
+    ecs_query_cache_table_t *qt = NULL;
 
-    flecs_rest_int_param(req, "offset", &offset);
-    flecs_rest_int_param(req, "limit", &limit);
+    ecs_iter_t it = ecs_query_iter(world, cache->query);
+    ECS_BIT_SET(it.flags, EcsIterIsInstanced);
+    ECS_BIT_SET(it.flags, EcsIterNoData);
+    ECS_BIT_SET(it.flags, EcsIterTableOnly);
 
-    if (offset < 0 || limit < 0) {
-        flecs_reply_error(reply, "invalid offset/limit parameter");
-        return;
-    }
+    while (ecs_query_next(&it)) {
+        if ((table != it.table) || (!it.table && !qt)) {
+            /* New table matched, add record to cache */
+            table = it.table;
+            qt = flecs_query_cache_table_insert(world, cache, table);
+        }
 
-    ecs_iter_t pit = ecs_page_iter(it, offset, limit);
-    if (ecs_iter_to_json_buf(world, &pit, &reply->body, &desc)) {
-        flecs_rest_reply_set_captured_log(reply);
+        ecs_query_cache_table_match_t *qm = 
+            flecs_query_cache_add_table_match(cache, qt, table);
+        flecs_query_cache_set_table_match(world, impl, cache, qm, table, &it);
     }
-
-    flecs_rest_int_param(req, "offset", &offset);
 }
 
 static
-bool flecs_rest_reply_existing_query(
+bool flecs_query_cache_match_table(
     ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply,
-    const char *name)
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache,
+    ecs_table_t *table)
 {
-    ecs_entity_t q = ecs_lookup(world, name);
-    if (!q) {
-        flecs_reply_error(reply, "unresolved identifier '%s'", name);
-        reply->code = 404;
-        return true;
+    if (!ecs_map_is_init(&cache->cache.index)) {
+        return false;
     }
 
-    ecs_poly_t *poly = NULL;
-    const EcsPoly *poly_comp = ecs_get_pair(world, q, EcsPoly, EcsQuery);
-    if (!poly_comp) {
-        poly_comp = ecs_get_pair(world, q, EcsPoly, EcsObserver);
-        if (poly_comp) {
-            poly = &((ecs_observer_t*)poly_comp->poly)->filter;
-        } else {
-            flecs_reply_error(reply, 
-                "resolved identifier '%s' is not a query", name);
-            reply->code = 400;
-            return true;
+    ecs_query_cache_table_t *qt = NULL;
+    ecs_query_t *q = cache->query;
+
+    /* Iterate uncached query for table to check if it matches. If this is a
+     * wildcard query, a table can match multiple times. */
+    ecs_iter_t it = flecs_query_iter(world, q);
+    it.flags |= EcsIterIsInstanced;
+    it.flags |= EcsIterNoData;
+    ecs_iter_set_var_as_table(&it, 0, table);
+
+    while (ecs_query_next(&it)) {
+        ecs_assert(it.table == table, ECS_INTERNAL_ERROR, NULL);
+        if (qt == NULL) {
+            table = it.table;
+            qt = flecs_query_cache_table_insert(world, cache, table);
         }
-    } else {
-        poly = poly_comp->poly;
-    }
 
-    if (!poly) {
-        flecs_reply_error(reply, "query '%s' is not initialized", name);
-        reply->code = 400;
-        return true;
+        ecs_query_cache_table_match_t *qm = flecs_query_cache_add_table_match(
+            cache, qt, table);
+        flecs_query_cache_set_table_match(world, impl, cache, qm, table, &it);
     }
 
-    ecs_iter_t it;
-    ecs_iter_poly(world, poly, &it, NULL);
-
-    ecs_dbg_2("rest: request query '%s'", q);
-    bool prev_color = ecs_log_enable_colors(false);
-    rest_prev_log = ecs_os_api.log_;
-    ecs_os_api.log_ = flecs_rest_capture_log;
+    return qt != NULL;
+}
 
-    const char *vars = ecs_http_get_param(req, "vars");
-    if (vars) {
-        if (!ecs_poly_is(poly, ecs_rule_t)) {
-            flecs_reply_error(reply, 
-                "variables are only supported for rule queries");
-            reply->code = 400;
-            return true;
-        }
-        if (ecs_rule_parse_vars(poly, &it, vars) == NULL) {
-            flecs_rest_reply_set_captured_log(reply);
+static
+bool flecs_query_cache_has_refs(
+    ecs_query_cache_t *cache)
+{
+    ecs_term_t *terms = cache->query->terms;
+    int32_t i, count = cache->query->term_count;
+    for (i = 0; i < count; i ++) {
+        if (terms[i].src.id & (EcsUp | EcsIsEntity)) {
             return true;
         }
     }
 
-    flecs_rest_iter_to_reply(world, req, reply, poly, &it);
-
-    ecs_os_api.log_ = rest_prev_log;
-    ecs_log_enable_colors(prev_color);    
-
-    return true;
+    return false;
 }
 
 static
-bool flecs_rest_reply_query(
+void flecs_query_cache_for_each_component_monitor(
     ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply)
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache,
+    void(*callback)(
+        ecs_world_t* world,
+        ecs_id_t id,
+        ecs_query_t *q))
 {
-    const char *q_name = ecs_http_get_param(req, "name");
-    if (q_name) {
-        return flecs_rest_reply_existing_query(world, req, reply, q_name);
+    ecs_query_t *q = &impl->pub;
+    ecs_term_t *terms = cache->query->terms;
+    int32_t i, count = cache->query->term_count;
+
+    for (i = 0; i < count; i++) {
+        ecs_term_t *term = &terms[i];
+        ecs_term_ref_t *src = &term->src;
+
+        if (src->id & EcsUp) {
+            callback(world, ecs_pair(term->trav, EcsWildcard), q);
+            if (term->trav != EcsIsA) {
+                callback(world, ecs_pair(EcsIsA, EcsWildcard), q);
+            }
+            callback(world, term->id, q);
+
+        } else if (src->id & EcsSelf && !ecs_term_match_this(term)) {
+            callback(world, term->id, q);
+        }
     }
+}
 
-    const char *q = ecs_http_get_param(req, "q");
-    if (!q) {
-        ecs_strbuf_appendlit(&reply->body, "Missing parameter 'q'");
-        reply->code = 400; /* bad request */
+static
+bool flecs_query_cache_is_term_ref_supported(
+    ecs_term_ref_t *ref)
+{
+    if (!(ref->id & EcsIsVariable)) {
+        return true;
+    }
+    if (ecs_id_is_wildcard(ref->id)) {
         return true;
     }
+    return false;
+}
 
-    bool try = false;
-    flecs_rest_bool_param(req, "try", &try);
+static
+int flecs_query_cache_process_signature(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache)
+{
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_term_t *terms = cache->query->terms;
+    int32_t i, count = cache->query->term_count;
 
-    ecs_dbg_2("rest: request query '%s'", q);
-    bool prev_color = ecs_log_enable_colors(false);
-    rest_prev_log = ecs_os_api.log_;
-    ecs_os_api.log_ = flecs_rest_capture_log;
+    for (i = 0; i < count; i ++) {
+        ecs_term_t *term = &terms[i];
+        ecs_term_ref_t *first = &term->first;
+        ecs_term_ref_t *src = &term->src;
+        ecs_term_ref_t *second = &term->second;
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
-        .expr = q
-    });
-    if (!r) {
-        flecs_rest_reply_set_captured_log(reply);
-        if (try) {
-            /* If client is trying queries, don't spam console with errors */
-            reply->code = 200;
+        bool is_src_ok = flecs_query_cache_is_term_ref_supported(src);
+        bool is_first_ok = flecs_query_cache_is_term_ref_supported(first);
+        bool is_second_ok = flecs_query_cache_is_term_ref_supported(second);
+
+        (void)first;
+        (void)second;
+        (void)is_src_ok;
+        (void)is_first_ok;
+        (void)is_second_ok;
+
+        /* Queries do not support named variables */
+        ecs_check(is_src_ok || ecs_term_match_this(term),
+            ECS_UNSUPPORTED, NULL);
+        ecs_check(is_first_ok, ECS_UNSUPPORTED, NULL);
+        ecs_check(is_second_ok,  ECS_UNSUPPORTED, NULL);
+        ecs_check(term->inout != EcsInOutFilter, ECS_INVALID_PARAMETER,
+            "invalid usage of InOutFilter for query");
+
+        if (src->id & EcsCascade) {
+            ecs_assert(cache->cascade_by == 0, ECS_INVALID_PARAMETER,
+                "query can only have one cascade term");
+            cache->cascade_by = i + 1;
         }
-    } else {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        flecs_rest_iter_to_reply(world, req, reply, r, &it);
-        ecs_rule_fini(r);
     }
 
-    ecs_os_api.log_ = rest_prev_log;
-    ecs_log_enable_colors(prev_color);
+    impl->pub.flags |= 
+        (ecs_flags32_t)(flecs_query_cache_has_refs(cache) * EcsQueryHasRefs);
 
-    return true;
-}
+    flecs_query_cache_for_each_component_monitor(
+        world, impl, cache, flecs_monitor_register);
 
-#ifdef FLECS_MONITOR
+    return 0;
+error:
+    return -1;
+}
 
+/** When a table becomes empty remove it from the query list, or vice versa. */
 static
-void flecs_rest_array_append_(
-    ecs_strbuf_t *reply,
-    const char *field,
-    int32_t field_len,
-    const ecs_float_t *values,
-    int32_t t)
+void flecs_query_cache_update_table(
+    ecs_query_cache_t *cache,
+    ecs_table_t *table,
+    bool empty)
 {
-    ecs_strbuf_list_appendch(reply, '"');
-    ecs_strbuf_appendstrn(reply, field, field_len);
-    ecs_strbuf_appendlit(reply, "\":");
-    ecs_strbuf_list_push(reply, "[", ",");
+    int32_t prev_count = flecs_query_cache_table_count(cache);
+    ecs_table_cache_set_empty(&cache->cache, table, empty);
+    int32_t cur_count = flecs_query_cache_table_count(cache);
 
-    int32_t i;
-    for (i = t + 1; i <= (t + ECS_STAT_WINDOW); i ++) {
-        int32_t index = i % ECS_STAT_WINDOW;
-        ecs_strbuf_list_next(reply);
-        ecs_strbuf_appendflt(reply, (double)values[index], '"');
+    if (prev_count != cur_count) {
+        ecs_query_cache_table_t *qt = ecs_table_cache_get(&cache->cache, table);
+        ecs_assert(qt != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_query_cache_table_match_t *cur, *next;
+
+        for (cur = qt->first; cur != NULL; cur = next) {
+            next = cur->next_match;
+
+            if (empty) {
+                ecs_assert(ecs_table_count(table) == 0, 
+                    ECS_INTERNAL_ERROR, NULL);
+
+                flecs_query_cache_remove_table_node(cache, cur);
+            } else {
+                ecs_assert(ecs_table_count(table) != 0, 
+                    ECS_INTERNAL_ERROR, NULL);
+
+                flecs_query_cache_insert_table_node(cache, cur);
+            }
+        }
     }
 
-    ecs_strbuf_list_pop(reply, "]");
+    ecs_assert(cur_count || cache->list.first == NULL, 
+        ECS_INTERNAL_ERROR, NULL);
 }
 
-#define flecs_rest_array_append(reply, field, values, t)\
-    flecs_rest_array_append_(reply, field, sizeof(field) - 1, values, t)
-
+/* Remove table */
 static
-void flecs_rest_gauge_append(
-    ecs_strbuf_t *reply,
-    const ecs_metric_t *m,
-    const char *field,
-    int32_t field_len,
-    int32_t t,
-    const char *brief,
-    int32_t brief_len)
+void flecs_query_cache_table_match_free(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_t *elem,
+    ecs_query_cache_table_match_t *first)
 {
-    ecs_strbuf_list_appendch(reply, '"');
-    ecs_strbuf_appendstrn(reply, field, field_len);
-    ecs_strbuf_appendlit(reply, "\":");
-    ecs_strbuf_list_push(reply, "{", ",");
+    ecs_query_cache_table_match_t *cur, *next;
+    ecs_world_t *world = cache->query->world;
 
-    flecs_rest_array_append(reply, "avg", m->gauge.avg, t);
-    flecs_rest_array_append(reply, "min", m->gauge.min, t);
-    flecs_rest_array_append(reply, "max", m->gauge.max, t);
+    for (cur = first; cur != NULL; cur = next) {
+        flecs_bfree(&cache->allocators.columns, cur->columns);
+        flecs_bfree(&cache->allocators.columns, cur->storage_columns);
+        flecs_bfree(&cache->allocators.ids, cur->ids);
+        flecs_bfree(&cache->allocators.sources, cur->sources);
 
-    if (brief) {
-        ecs_strbuf_list_appendlit(reply, "\"brief\":\"");
-        ecs_strbuf_appendstrn(reply, brief, brief_len);
-        ecs_strbuf_appendch(reply, '"');
+        if (cur->monitor) {
+            flecs_bfree(&cache->allocators.monitors, cur->monitor);
+        }
+        if (!elem->hdr.empty) {
+            flecs_query_cache_remove_table_node(cache, cur);
+        }
+        
+        ecs_vec_fini_t(&world->allocator, &cur->refs, ecs_ref_t);
+
+        next = cur->next_match;
+
+        flecs_bfree(&world->allocators.query_table_match, cur);
     }
+}
 
-    ecs_strbuf_list_pop(reply, "}");
+static
+void flecs_query_cache_table_free(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_t *elem)
+{
+    flecs_query_cache_table_match_free(cache, elem, elem->first);
+    flecs_bfree(&cache->query->world->allocators.query_table, elem);
 }
 
 static
-void flecs_rest_counter_append(
-    ecs_strbuf_t *reply,
-    const ecs_metric_t *m,
-    const char *field,
-    int32_t field_len,
-    int32_t t,
-    const char *brief,
-    int32_t brief_len)
+void flecs_query_cache_unmatch_table(
+    ecs_query_cache_t *cache,
+    ecs_table_t *table,
+    ecs_query_cache_table_t *elem)
 {
-    flecs_rest_gauge_append(reply, m, field, field_len, t, brief, brief_len);
+    if (!elem) {
+        elem = ecs_table_cache_get(&cache->cache, table);
+    }
+    if (elem) {
+        ecs_table_cache_remove(&cache->cache, elem->table_id, &elem->hdr);
+        flecs_query_cache_table_free(cache, elem);
+    }
 }
 
-#define ECS_GAUGE_APPEND_T(reply, s, field, t, brief)\
-    flecs_rest_gauge_append(reply, &(s)->field, #field, sizeof(#field) - 1, t, brief, sizeof(brief) - 1)
+/* Rematch system with tables after a change happened to a watched entity */
+static
+void flecs_query_cache_rematch_tables(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl)
+{
+    ecs_iter_t it;
+    ecs_table_t *table = NULL;
+    ecs_query_cache_table_t *qt = NULL;
+    ecs_query_cache_table_match_t *qm = NULL;
+    ecs_query_cache_t *cache = impl->cache;
 
-#define ECS_COUNTER_APPEND_T(reply, s, field, t, brief)\
-    flecs_rest_counter_append(reply, &(s)->field, #field, sizeof(#field) - 1, t, brief, sizeof(brief) - 1)
+    if (cache->monitor_generation == world->monitor_generation) {
+        return;
+    }
 
-#define ECS_GAUGE_APPEND(reply, s, field, brief)\
-    ECS_GAUGE_APPEND_T(reply, s, field, (s)->t, brief)
+    cache->monitor_generation = world->monitor_generation;
 
-#define ECS_COUNTER_APPEND(reply, s, field, brief)\
-    ECS_COUNTER_APPEND_T(reply, s, field, (s)->t, brief)
+    it = ecs_query_iter(world, cache->query);
+    ECS_BIT_SET(it.flags, EcsIterIsInstanced);
+    ECS_BIT_SET(it.flags, EcsIterNoData);
 
-static
-void flecs_world_stats_to_json(
-    ecs_strbuf_t *reply,
-    const EcsWorldStats *monitor_stats)
-{
-    const ecs_world_stats_t *stats = &monitor_stats->stats;
+    world->info.rematch_count_total ++;
+    int32_t rematch_count = ++ cache->rematch_count;
 
-    ecs_strbuf_list_push(reply, "{", ",");
-    ECS_GAUGE_APPEND(reply, stats, entities.count, "Alive entity ids in the world");
-    ECS_GAUGE_APPEND(reply, stats, entities.not_alive_count, "Not alive entity ids in the world");
+    ecs_time_t t = {0};
+    if (world->flags & EcsWorldMeasureFrameTime) {
+        ecs_time_measure(&t);
+    }
 
-    ECS_GAUGE_APPEND(reply, stats, performance.fps, "Frames per second");
-    ECS_COUNTER_APPEND(reply, stats, performance.frame_time, "Time spent in frame");
-    ECS_COUNTER_APPEND(reply, stats, performance.system_time, "Time spent on running systems in frame");
-    ECS_COUNTER_APPEND(reply, stats, performance.emit_time, "Time spent on notifying observers in frame");
-    ECS_COUNTER_APPEND(reply, stats, performance.merge_time, "Time spent on merging commands in frame");
-    ECS_COUNTER_APPEND(reply, stats, performance.rematch_time, "Time spent on revalidating query caches in frame");
+    while (ecs_query_next(&it)) {
+        if ((table != it.table) || (!it.table && !qt)) {
+            if (qm && qm->next_match) {
+                flecs_query_cache_table_match_free(cache, qt, qm->next_match);
+                qm->next_match = NULL;
+            }
 
-    ECS_COUNTER_APPEND(reply, stats, commands.add_count, "Add commands executed");
-    ECS_COUNTER_APPEND(reply, stats, commands.remove_count, "Remove commands executed");
-    ECS_COUNTER_APPEND(reply, stats, commands.delete_count, "Delete commands executed");
-    ECS_COUNTER_APPEND(reply, stats, commands.clear_count, "Clear commands executed");
-    ECS_COUNTER_APPEND(reply, stats, commands.set_count, "Set commands executed");
-    ECS_COUNTER_APPEND(reply, stats, commands.ensure_count, "Get_mut commands executed");
-    ECS_COUNTER_APPEND(reply, stats, commands.modified_count, "Modified commands executed");
-    ECS_COUNTER_APPEND(reply, stats, commands.other_count, "Misc commands executed");
-    ECS_COUNTER_APPEND(reply, stats, commands.discard_count, "Commands for already deleted entities");
-    ECS_COUNTER_APPEND(reply, stats, commands.batched_entity_count, "Entities with batched commands");
-    ECS_COUNTER_APPEND(reply, stats, commands.batched_count, "Number of commands batched");
+            table = it.table;
 
-    ECS_COUNTER_APPEND(reply, stats, frame.merge_count, "Number of merges (sync points)");
-    ECS_COUNTER_APPEND(reply, stats, frame.pipeline_build_count, "Pipeline rebuilds (happen when systems become active/enabled)");
-    ECS_COUNTER_APPEND(reply, stats, frame.systems_ran, "Systems ran in frame");
-    ECS_COUNTER_APPEND(reply, stats, frame.observers_ran, "Number of times an observer was invoked in frame");
-    ECS_COUNTER_APPEND(reply, stats, frame.event_emit_count, "Events emitted in frame");
-    ECS_COUNTER_APPEND(reply, stats, frame.rematch_count, "Number of query cache revalidations");
+            qt = ecs_table_cache_get(&cache->cache, table);
+            if (!qt) {
+                qt = flecs_query_cache_table_insert(world, cache, table);
+            }
 
-    ECS_GAUGE_APPEND(reply, stats, tables.count, "Tables in the world (including empty)");
-    ECS_GAUGE_APPEND(reply, stats, tables.empty_count, "Empty tables in the world");
-    ECS_COUNTER_APPEND(reply, stats, tables.create_count, "Number of new tables created");
-    ECS_COUNTER_APPEND(reply, stats, tables.delete_count, "Number of tables deleted");
+            ecs_assert(qt->hdr.table == table, ECS_INTERNAL_ERROR, NULL);
+            qt->rematch_count = rematch_count;
+            qm = NULL;
+        }
+        if (!qm) {
+            qm = qt->first;
+        } else {
+            qm = qm->next_match;
+        }
+        if (!qm) {
+            qm = flecs_query_cache_add_table_match(cache, qt, table);
+        }
 
-    ECS_GAUGE_APPEND(reply, stats, components.tag_count, "Tag ids in use");
-    ECS_GAUGE_APPEND(reply, stats, components.component_count, "Component ids in use");
-    ECS_GAUGE_APPEND(reply, stats, components.pair_count, "Pair ids in use");
-    ECS_GAUGE_APPEND(reply, stats, components.type_count, "Registered component types");
-    ECS_COUNTER_APPEND(reply, stats, components.create_count, "Number of new component, tag and pair ids created");
-    ECS_COUNTER_APPEND(reply, stats, components.delete_count, "Number of component, pair and tag ids deleted");
+        flecs_query_cache_set_table_match(world, impl, cache, qm, table, &it);
 
-    ECS_GAUGE_APPEND(reply, stats, queries.query_count, "Queries in the world");
-    ECS_GAUGE_APPEND(reply, stats, queries.observer_count, "Observers in the world");
-    ECS_GAUGE_APPEND(reply, stats, queries.system_count, "Systems in the world");
+        if (table && ecs_table_count(table) && cache->group_by_callback) {
+            if (flecs_query_cache_get_group_id(cache, table) != qm->group_id) {
+                /* Update table group */
+                flecs_query_cache_remove_table_node(cache, qm);
+                flecs_query_cache_insert_table_node(cache, qm);
+            }
+        }
+    }
 
-    ECS_COUNTER_APPEND(reply, stats, memory.alloc_count, "Allocations by OS API");
-    ECS_COUNTER_APPEND(reply, stats, memory.realloc_count, "Reallocs by OS API");
-    ECS_COUNTER_APPEND(reply, stats, memory.free_count, "Frees by OS API");
-    ECS_GAUGE_APPEND(reply, stats, memory.outstanding_alloc_count, "Outstanding allocations by OS API");
-    ECS_COUNTER_APPEND(reply, stats, memory.block_alloc_count, "Blocks allocated by block allocators");
-    ECS_COUNTER_APPEND(reply, stats, memory.block_free_count, "Blocks freed by block allocators");
-    ECS_GAUGE_APPEND(reply, stats, memory.block_outstanding_alloc_count, "Outstanding block allocations");
-    ECS_COUNTER_APPEND(reply, stats, memory.stack_alloc_count, "Pages allocated by stack allocators");
-    ECS_COUNTER_APPEND(reply, stats, memory.stack_free_count, "Pages freed by stack allocators");
-    ECS_GAUGE_APPEND(reply, stats, memory.stack_outstanding_alloc_count, "Outstanding page allocations");
+    if (qm && qm->next_match) {
+        flecs_query_cache_table_match_free(cache, qt, qm->next_match);
+        qm->next_match = NULL;
+    }
 
-    ECS_COUNTER_APPEND(reply, stats, http.request_received_count, "Received requests");
-    ECS_COUNTER_APPEND(reply, stats, http.request_invalid_count, "Received invalid requests");
-    ECS_COUNTER_APPEND(reply, stats, http.request_handled_ok_count, "Requests handled successfully");
-    ECS_COUNTER_APPEND(reply, stats, http.request_handled_error_count, "Requests handled with error code");
-    ECS_COUNTER_APPEND(reply, stats, http.request_not_handled_count, "Requests not handled (unknown endpoint)");
-    ECS_COUNTER_APPEND(reply, stats, http.request_preflight_count, "Preflight requests received");
-    ECS_COUNTER_APPEND(reply, stats, http.send_ok_count, "Successful replies");
-    ECS_COUNTER_APPEND(reply, stats, http.send_error_count, "Unsuccessful replies");
-    ECS_COUNTER_APPEND(reply, stats, http.busy_count, "Dropped requests due to full send queue (503)");
+    /* Iterate all tables in cache, remove ones that weren't just matched */
+    ecs_table_cache_iter_t cache_it;
+    if (flecs_table_cache_all_iter(&cache->cache, &cache_it)) {
+        while ((qt = flecs_table_cache_next(&cache_it, ecs_query_cache_table_t))) {
+            if (qt->rematch_count != rematch_count) {
+                flecs_query_cache_unmatch_table(cache, qt->hdr.table, qt);
+            }
+        }
+    }
 
-    ecs_strbuf_list_pop(reply, "}");
+    if (world->flags & EcsWorldMeasureFrameTime) {
+        world->info.rematch_time_total += (ecs_ftime_t)ecs_time_measure(&t);
+    }
 }
 
-static
-void flecs_system_stats_to_json(
+/* -- Private API -- */
+
+void flecs_query_cache_notify(
     ecs_world_t *world,
-    ecs_strbuf_t *reply,
-    ecs_entity_t system,
-    const ecs_system_stats_t *stats)
+    ecs_query_t *q,
+    ecs_query_cache_event_t *event)
 {
-    ecs_strbuf_list_push(reply, "{", ",");
-    ecs_strbuf_list_appendlit(reply, "\"name\":\"");
-    ecs_get_path_w_sep_buf(world, 0, system, ".", NULL, reply);
-    ecs_strbuf_appendch(reply, '"');
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    ecs_query_cache_t *cache = impl->cache;
 
-    if (!stats->task) {
-        ECS_GAUGE_APPEND(reply, &stats->query, matched_table_count, "");
-        ECS_GAUGE_APPEND(reply, &stats->query, matched_entity_count, "");
+    switch(event->kind) {
+    case EcsQueryTableMatch:
+        /* Creation of new table */
+        flecs_query_cache_match_table(world, impl, cache, event->table);
+        break;
+    case EcsQueryTableUnmatch:
+        /* Deletion of table */
+        flecs_query_cache_unmatch_table(cache, event->table, NULL);
+        break;
+    case EcsQueryTableRematch:
+        /* Rematch tables of query */
+        flecs_query_cache_rematch_tables(world, impl);
+        break;
     }
-
-    ECS_COUNTER_APPEND_T(reply, stats, time_spent, stats->query.t, "");
-    ecs_strbuf_list_pop(reply, "}");
 }
 
 static
-void flecs_pipeline_stats_to_json(
+int flecs_query_cache_order_by(
     ecs_world_t *world,
-    ecs_strbuf_t *reply,
-    const EcsPipelineStats *stats)
+    ecs_query_impl_t *impl,
+    ecs_entity_t order_by,
+    ecs_order_by_action_t order_by_callback,
+    ecs_sort_table_action_t action)
 {
-    ecs_strbuf_list_push(reply, "[", ",");
+    ecs_check(impl != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_check(cache != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!ecs_id_is_wildcard(order_by), 
+        ECS_INVALID_PARAMETER, NULL);
 
-    int32_t i, count = ecs_vec_count(&stats->stats.systems), sync_cur = 0;
-    ecs_entity_t *ids = ecs_vec_first_t(&stats->stats.systems, ecs_entity_t);
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t id = ids[i];
-        
-        ecs_strbuf_list_next(reply);
+    /* Find order_by term & make sure it is queried for */
+    const ecs_query_t *query = cache->query;
+    int32_t i, count = query->term_count;
+    int32_t order_by_term = -1;
 
-        if (id) {
-            ecs_system_stats_t *sys_stats = ecs_map_get_deref(
-                &stats->stats.system_stats, ecs_system_stats_t, id);
-            flecs_system_stats_to_json(world, reply, id, sys_stats);
-        } else {
-            /* Sync point */
-            ecs_strbuf_list_push(reply, "{", ",");
-            ecs_sync_stats_t *sync_stats = ecs_vec_get_t(
-                &stats->stats.sync_points, ecs_sync_stats_t, sync_cur);
+    if (order_by) {
+        for (i = 0; i < count; i ++) {
+            const ecs_term_t *term = &query->terms[i];
+            
+            /* Only And terms are supported */
+            if (term->id == order_by && term->oper == EcsAnd) {
+                order_by_term = i;
+                break;
+            }
+        }
 
-            ecs_strbuf_list_appendlit(reply, "\"system_count\":");
-            ecs_strbuf_appendint(reply, sync_stats->system_count);
+        if (order_by_term == -1) {
+            char *id_str = ecs_id_str(world, order_by);
+            ecs_err("order_by component '%s' is not queried for", id_str);
+            ecs_os_free(id_str);
+            goto error;
+        }
+    }
 
-            ecs_strbuf_list_appendlit(reply, "\"multi_threaded\":");
-            ecs_strbuf_appendbool(reply, sync_stats->multi_threaded);
+    cache->order_by = order_by;
+    cache->order_by_callback = order_by_callback;
+    cache->order_by_term = order_by_term;
+    cache->order_by_table_callback = action;
 
-            ecs_strbuf_list_appendlit(reply, "\"no_readonly\":");
-            ecs_strbuf_appendbool(reply, sync_stats->no_readonly);
+    ecs_vec_fini_t(NULL, &cache->table_slices, ecs_query_cache_table_match_t);
+    flecs_query_cache_sort_tables(world, impl);
 
-            ECS_GAUGE_APPEND_T(reply, sync_stats, 
-                time_spent, stats->stats.t, "");
-            ECS_GAUGE_APPEND_T(reply, sync_stats, 
-                commands_enqueued, stats->stats.t, "");
+    if (!cache->table_slices.array) {
+        flecs_query_cache_build_sorted_tables(cache);
+    }
 
-            ecs_strbuf_list_pop(reply, "}");
-            sync_cur ++;
-        }
+    return 0;
+error:
+    return -1;
+}
+
+static
+void flecs_query_cache_group_by(
+    ecs_query_cache_t *cache,
+    ecs_entity_t sort_component,
+    ecs_group_by_action_t group_by)
+{   
+    ecs_check(cache->group_by == 0, ECS_INVALID_OPERATION,
+        "query is already grouped");
+    ecs_check(cache->group_by_callback == 0, ECS_INVALID_OPERATION,
+        "query is already grouped");
+
+    if (!group_by) {
+        /* Builtin function that groups by relationship */
+        group_by = flecs_query_cache_default_group_by;   
     }
 
-    ecs_strbuf_list_pop(reply, "]");
+    cache->group_by = sort_component;
+    cache->group_by_callback = group_by;
+
+    ecs_map_init_w_params(&cache->groups, 
+        &cache->query->world->allocators.query_table_list);
+error:
+    return;
 }
 
 static
-bool flecs_rest_reply_stats(
-    ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply)
+void flecs_query_cache_on_event(
+    ecs_iter_t *it)
 {
-    char *period_str = NULL;
-    flecs_rest_string_param(req, "period", &period_str);
-    char *category = &req->path[6];
+    /* Because this is the observer::run callback, checking if this is event is
+     * already handled is not done for us. */
+    ecs_world_t *world = it->world;
+    ecs_observer_t *o = it->ctx;
+    ecs_observer_impl_t *o_impl = flecs_observer_impl(o);
+    if (o_impl->last_event_id) {
+        if (o_impl->last_event_id[0] == world->event_id) {
+            return;
+        }
+        o_impl->last_event_id[0] = world->event_id;
+    }
 
-    ecs_entity_t period = EcsPeriod1s;
-    if (period_str) {
-        char *period_name = ecs_asprintf("Period%s", period_str);
-        period = ecs_lookup_child(world, ecs_id(FlecsMonitor), period_name);
-        ecs_os_free(period_name);
-        if (!period) {
-            flecs_reply_error(reply, "bad request (invalid period string)");
-            reply->code = 400;
-            return false;
+    ecs_query_impl_t *impl = o->ctx;
+    flecs_poly_assert(impl, ecs_query_t);
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_table_t *table = it->table;
+    ecs_entity_t event = it->event;
+
+    if (event == EcsOnTableCreate) {
+        /* Creation of new table */
+        if (flecs_query_cache_match_table(world, impl, cache, table)) {
+            if (ecs_should_log_3()) {
+                char *table_str = ecs_table_str(world, table);
+                ecs_dbg_3("query cache event: %s for [%s]", 
+                    ecs_get_name(world, event),
+                    table_str);
+                ecs_os_free(table_str);
+            }
         }
+        return;
     }
 
-    if (!ecs_os_strcmp(category, "world")) {
-        const EcsWorldStats *stats = ecs_get_pair(world, EcsWorld, 
-            EcsWorldStats, period);
-        flecs_world_stats_to_json(&reply->body, stats);
-        return true;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    } else if (!ecs_os_strcmp(category, "pipeline")) {
-        const EcsPipelineStats *stats = ecs_get_pair(world, EcsWorld, 
-            EcsPipelineStats, period);
-        flecs_pipeline_stats_to_json(world, &reply->body, stats);
-        return true;
+    /* The observer isn't doing the matching because the query can do it more
+     * efficiently by checking the table with the query cache. */
+    if (ecs_table_cache_get(&cache->cache, table) == NULL) {
+        return;
+    }
 
-    } else {
-        flecs_reply_error(reply, "bad request (unsupported category)");
-        reply->code = 400;
-        return false;
+    if (ecs_should_log_3()) {
+        char *table_str = ecs_table_str(world, table);
+        ecs_dbg_3("query cache event: %s for [%s]", 
+            ecs_get_name(world, event),
+            table_str);
+        ecs_os_free(table_str);
+    }
+
+    if (event == EcsOnTableEmpty) {
+        flecs_query_cache_update_table(cache, table, true);
+    } else
+    if (event == EcsOnTableFill) {
+        flecs_query_cache_update_table(cache, table, false);
+    } else if (event == EcsOnTableDelete) {
+        /* Deletion of table */
+        flecs_query_cache_unmatch_table(cache, table, NULL);
+        return;
     }
 }
-#else
+
 static
-bool flecs_rest_reply_stats(
-    ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply)
+void flecs_query_cache_table_cache_free(
+    ecs_query_cache_t *cache)
 {
-    (void)world;
-    (void)req;
-    (void)reply;
-    return false;
+    ecs_table_cache_iter_t it;
+    ecs_query_cache_table_t *qt;
+
+    if (flecs_table_cache_all_iter(&cache->cache, &it)) {
+        while ((qt = flecs_table_cache_next(&it, ecs_query_cache_table_t))) {
+            flecs_query_cache_table_free(cache, qt);
+        }
+    }
+
+    ecs_table_cache_fini(&cache->cache);
 }
-#endif
 
 static
-void flecs_rest_reply_table_append_type(
-    ecs_world_t *world,
-    ecs_strbuf_t *reply,
-    const ecs_table_t *table)
+void flecs_query_cache_allocators_init(
+    ecs_query_cache_t *cache)
 {
-    ecs_strbuf_list_push(reply, "[", ",");
-    int32_t i, count = table->type.count;
-    ecs_id_t *ids = table->type.array;
-    for (i = 0; i < count; i ++) {
-        ecs_strbuf_list_next(reply);
-        ecs_strbuf_appendch(reply, '"');
-        ecs_id_str_buf(world, ids[i], reply);
-        ecs_strbuf_appendch(reply, '"');
+    int32_t field_count = cache->query->field_count;
+    if (field_count) {
+        flecs_ballocator_init(&cache->allocators.columns, 
+            field_count * ECS_SIZEOF(int32_t));
+        flecs_ballocator_init(&cache->allocators.ids, 
+            field_count * ECS_SIZEOF(ecs_id_t));
+        flecs_ballocator_init(&cache->allocators.sources,
+            field_count * ECS_SIZEOF(ecs_entity_t));
+        flecs_ballocator_init(&cache->allocators.monitors,
+            (1 + field_count) * ECS_SIZEOF(int32_t));
     }
-    ecs_strbuf_list_pop(reply, "]");
 }
 
 static
-void flecs_rest_reply_table_append_memory(
-    ecs_strbuf_t *reply,
-    const ecs_table_t *table)
+void flecs_query_cache_allocators_fini(
+    ecs_query_cache_t *cache)
 {
-    int32_t used = 0, allocated = 0;
+    int32_t field_count = cache->query->field_count;
+    if (field_count) {
+        flecs_ballocator_fini(&cache->allocators.columns);
+        flecs_ballocator_fini(&cache->allocators.ids);
+        flecs_ballocator_fini(&cache->allocators.sources);
+        flecs_ballocator_fini(&cache->allocators.monitors);
+    }
+}
 
-    used += table->data.entities.count * ECS_SIZEOF(ecs_entity_t);
-    allocated += table->data.entities.size * ECS_SIZEOF(ecs_entity_t);
+void flecs_query_cache_fini(
+    ecs_query_impl_t *impl)
+{
+    ecs_world_t *world = impl->pub.world;
+    ecs_stage_t *stage = impl->pub.stage;
+    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    int32_t i, storage_count = table->column_count;
-    ecs_column_t *columns = table->data.columns;
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    for (i = 0; i < storage_count; i ++) {
-        used += columns[i].data.count * columns[i].ti->size;
-        allocated += columns[i].data.size * columns[i].ti->size;
+    if (cache->observer) {
+        flecs_observer_fini(cache->observer);
     }
 
-    ecs_strbuf_list_push(reply, "{", ",");
-    ecs_strbuf_list_append(reply, "\"used\":%d", used);
-    ecs_strbuf_list_append(reply, "\"allocated\":%d", allocated);
-    ecs_strbuf_list_pop(reply, "}");
+    ecs_group_delete_action_t on_delete = cache->on_group_delete;
+    if (on_delete) {
+        ecs_map_iter_t it = ecs_map_iter(&cache->groups);
+        while (ecs_map_next(&it)) {
+            ecs_query_cache_table_list_t *group = ecs_map_ptr(&it);
+            uint64_t group_id = ecs_map_key(&it);
+            on_delete(world, group_id, group->info.ctx, cache->group_by_ctx);
+        }
+        cache->on_group_delete = NULL;
+    }
+
+    if (cache->group_by_ctx_free) {
+        if (cache->group_by_ctx) {
+            cache->group_by_ctx_free(cache->group_by_ctx);
+        }
+    }
+
+    flecs_query_cache_for_each_component_monitor(world, impl, cache,
+        flecs_monitor_unregister);
+    flecs_query_cache_table_cache_free(cache);
+
+    ecs_map_fini(&cache->groups);
+
+    ecs_vec_fini_t(NULL, &cache->table_slices, ecs_query_cache_table_match_t);
+    flecs_query_cache_allocators_fini(cache);
+    ecs_query_fini(cache->query);
+
+    flecs_bfree(&stage->allocators.query_cache, cache);
 }
 
-static
-void flecs_rest_reply_table_append(
-    ecs_world_t *world,
-    ecs_strbuf_t *reply,
-    const ecs_table_t *table)
+/* -- Public API -- */
+
+ecs_query_cache_t* flecs_query_cache_init(
+    ecs_query_impl_t *impl,
+    const ecs_query_desc_t *const_desc)
 {
-    ecs_strbuf_list_next(reply);
-    ecs_strbuf_list_push(reply, "{", ",");
-    ecs_strbuf_list_append(reply, "\"id\":%u", (uint32_t)table->id);
-    ecs_strbuf_list_appendstr(reply, "\"type\":");
-    flecs_rest_reply_table_append_type(world, reply, table);
-    ecs_strbuf_list_append(reply, "\"count\":%d", ecs_table_count(table));
-    ecs_strbuf_list_append(reply, "\"memory\":");
-    flecs_rest_reply_table_append_memory(reply, table);
-    ecs_strbuf_list_pop(reply, "}");
+    ecs_world_t *world = impl->pub.world;
+    ecs_stage_t *stage = impl->pub.stage;
+    ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_check(const_desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(const_desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_query_desc_t was not initialized to zero");
+    ecs_check(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, 
+        "cannot create query during world fini");
+
+    /* Create private version of desc to create the uncached query that will
+     * populate the query cache. */
+    ecs_query_desc_t desc = *const_desc;
+    ecs_entity_t entity = desc.entity;
+    desc.cache_kind = EcsQueryCacheNone; /* Don't create caches recursively */
+    desc.group_by_callback = NULL;
+    desc.group_by = 0;
+    desc.order_by_callback = NULL;
+    desc.order_by = 0;
+    desc.entity = 0;
+    
+    /* Don't pass ctx/binding_ctx to uncached query */
+    desc.ctx = NULL;
+    desc.binding_ctx = NULL;
+    desc.ctx_free = NULL;
+    desc.binding_ctx_free = NULL;
+
+    ecs_query_cache_t *result = flecs_bcalloc(&stage->allocators.query_cache);
+    result->entity = entity;
+    impl->cache = result;
+
+    ecs_observer_desc_t observer_desc = { .query = desc };
+
+    desc.flags |= EcsQueryMatchEmptyTables | EcsQueryTableOnly;
+    ecs_query_t *q = result->query = ecs_query_init(world, &desc);
+    if (!q) {
+        goto error;
+    }
+
+    flecs_query_cache_allocators_init(result);
+
+    if (q->term_count) {
+        observer_desc.run = flecs_query_cache_on_event;
+        observer_desc.ctx = impl;
+        observer_desc.events[0] = EcsOnTableEmpty;
+        observer_desc.events[1] = EcsOnTableFill;
+        observer_desc.events[2] = EcsOnTableCreate;
+        observer_desc.events[3] = EcsOnTableDelete;
+        observer_desc.query.flags |= EcsQueryNoData|EcsQueryIsInstanced;
+
+        /* ecs_query_init could have moved away resources from the terms array
+         * in the descriptor, so use the terms array from the query. */
+        ecs_os_memcpy_n(observer_desc.query.terms, q->terms, 
+            ecs_term_t, FLECS_TERM_COUNT_MAX);
+        observer_desc.query.expr = NULL; /* Already parsed */
+
+        result->observer = flecs_observer_init(world, entity, &observer_desc);
+        if (!result->observer) {
+            goto error;
+        }
+    }
+
+    result->prev_match_count = -1;
+
+    if (ecs_should_log_1()) {
+        char *query_expr = ecs_query_str(result->query);
+        ecs_dbg_1("#[green]query#[normal] [%s] created", 
+            query_expr ? query_expr : "");
+        ecs_os_free(query_expr);
+    }
+
+    ecs_log_push_1();
+
+    if (flecs_query_cache_process_signature(world, impl, result)) {
+        goto error;
+    }
+
+    /* Group before matching so we won't have to move tables around later */
+    int32_t cascade_by = result->cascade_by;
+    if (cascade_by) {
+        flecs_query_cache_group_by(result, result->query->terms[cascade_by - 1].id,
+            flecs_query_cache_group_by_cascade);
+        result->group_by_ctx = &result->query->terms[cascade_by - 1];
+    }
+
+    if (const_desc->group_by_callback || const_desc->group_by) {
+        ecs_check(!result->cascade_by, ECS_INVALID_PARAMETER,
+            "cannot mix cascade and group_by");
+        flecs_query_cache_group_by(result, 
+            const_desc->group_by, const_desc->group_by_callback);
+        result->group_by_ctx = const_desc->group_by_ctx;
+        result->on_group_create = const_desc->on_group_create;
+        result->on_group_delete = const_desc->on_group_delete;
+        result->group_by_ctx_free = const_desc->group_by_ctx_free;
+    }
+
+    /* Ensure that while initially populating the query with tables, they are
+     * in the right empty/non-empty list. This ensures the query won't miss
+     * empty/non-empty events for tables that are currently out of sync, but
+     * change back to being in sync before processing pending events. */
+    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
+    ecs_table_cache_init(world, &result->cache);
+    flecs_query_cache_match_tables(world, impl, result);
+
+    if (const_desc->order_by_callback) {
+        if (flecs_query_cache_order_by(world, impl, 
+            const_desc->order_by, const_desc->order_by_callback,
+            const_desc->order_by_table_callback))
+        {
+            goto error;
+        }
+    }
+
+    if (entity) {
+        if (!flecs_query_cache_table_count(result) && result->query->term_count){
+            ecs_add_id(world, entity, EcsEmpty);
+        }
+    }
+
+    ecs_log_pop_1();
+
+    return result;
+error:
+    return NULL;
 }
 
-static
-bool flecs_rest_reply_tables(
-    ecs_world_t *world,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply)
+ecs_query_cache_table_t* flecs_query_cache_get_table(
+    ecs_query_cache_t *cache,
+    ecs_table_t *table)
 {
-    (void)req;
+    return ecs_table_cache_get(&cache->cache, table);
+}
 
-    ecs_strbuf_list_push(&reply->body, "[", ",");
-    ecs_sparse_t *tables = &world->store.tables;
-    int32_t i, count = flecs_sparse_count(tables);
-    for (i = 0; i < count; i ++) {
-        ecs_table_t *table = flecs_sparse_get_dense_t(tables, ecs_table_t, i);
-        flecs_rest_reply_table_append(world, &reply->body, table);
+void ecs_iter_set_group(
+    ecs_iter_t *it,
+    uint64_t group_id)
+{
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_PARAMETER, NULL);
+
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_impl_t *q = flecs_query_impl(qit->query);
+    ecs_check(q != NULL, ECS_INVALID_PARAMETER, NULL);
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_cache_t *cache = q->cache;
+    ecs_check(cache != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    ecs_query_cache_table_list_t *node = flecs_query_cache_get_group(
+        cache, group_id);
+    if (!node) {
+        qit->node = NULL;
+        qit->last = NULL;
+        return;
     }
-    ecs_strbuf_list_pop(&reply->body, "]");
 
-    return true;
+    ecs_query_cache_table_match_t *first = node->first;
+    if (first) {
+        qit->node = node->first;
+        qit->last = node->last;
+    } else {
+        qit->node = NULL;
+        qit->last = NULL;
+    }
+    
+error:
+    return;
 }
 
-static
-const char* flecs_rest_cmd_kind_to_str(
-    ecs_cmd_kind_t kind)
+const ecs_query_group_info_t* ecs_query_get_group_info(
+    const ecs_query_t *query,
+    uint64_t group_id)
 {
-    switch(kind) {
-    case EcsCmdClone: return "Clone";
-    case EcsCmdBulkNew: return "BulkNew";
-    case EcsCmdAdd: return "Add";
-    case EcsCmdRemove: return "Remove";
-    case EcsCmdSet: return "Set";
-    case EcsCmdEmplace: return "Emplace";
-    case EcsCmdEnsure: return "Ensure";
-    case EcsCmdModified: return "Modified";
-    case EcsCmdModifiedNoHook: return "ModifiedNoHook";
-    case EcsCmdAddModified: return "AddModified";
-    case EcsCmdPath: return "Path";
-    case EcsCmdDelete: return "Delete";
-    case EcsCmdClear: return "Clear";
-    case EcsCmdOnDeleteAction: return "OnDeleteAction";
-    case EcsCmdEnable: return "Enable";
-    case EcsCmdDisable: return "Disable";
-    case EcsCmdEvent: return "Event";
-    case EcsCmdSkip: return "Skip";
-    default: return "Unknown";
+    flecs_poly_assert(query, ecs_query_t);
+    ecs_query_cache_table_list_t *node = flecs_query_cache_get_group(
+        flecs_query_impl(query)->cache, group_id);
+    if (!node) {
+        return NULL;
+    }
+    
+    return &node->info;
+}
+
+void* ecs_query_get_group_ctx(
+    const ecs_query_t *query,
+    uint64_t group_id)
+{
+    flecs_poly_assert(query, ecs_query_t);
+    const ecs_query_group_info_t *info = ecs_query_get_group_info(
+        query, group_id);
+    if (!info) {
+        return NULL;
+    } else {
+        return info->ctx;
     }
 }
 
+
 static
-bool flecs_rest_cmd_has_id(
-    const ecs_cmd_t *cmd)
+ecs_query_cache_table_match_t* flecs_query_next(
+    const ecs_query_run_ctx_t *ctx)
 {
-    switch(cmd->kind) {
-    case EcsCmdClear:
-    case EcsCmdDelete:
-    case EcsCmdClone:
-    case EcsCmdDisable:
-    case EcsCmdPath:
-        return false;
-    case EcsCmdBulkNew:
-    case EcsCmdAdd:
-    case EcsCmdRemove:
-    case EcsCmdSet:
-    case EcsCmdEmplace:
-    case EcsCmdEnsure:
-    case EcsCmdModified:
-    case EcsCmdModifiedNoHook:
-    case EcsCmdAddModified:
-    case EcsCmdOnDeleteAction:
-    case EcsCmdEnable:
-    case EcsCmdEvent:
-    case EcsCmdSkip:
-    default:
-        return true;
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_cache_table_match_t *node = qit->node;
+    ecs_query_cache_table_match_t *prev = qit->prev;
+
+    if (prev != qit->last) {
+        ecs_assert(node != NULL, ECS_INTERNAL_ERROR, NULL);
+        ctx->vars[0].range.table = node->table;
+        it->group_id = node->group_id;
+        it->instance_count = 0;
+        it->references = ecs_vec_first(&node->refs);
+        qit->node = node->next;
+        qit->prev = node;
+        return node;
     }
+
+    return NULL;
 }
 
 static
-void flecs_rest_server_garbage_collect_all(
-    ecs_rest_ctx_t *impl)
+ecs_query_cache_table_match_t* flecs_query_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
 {
-    ecs_map_iter_t it = ecs_map_iter(&impl->cmd_captures);
+    ecs_iter_t *it = ctx->it;
+    if (first) {
+        ecs_var_t *var = &ctx->vars[0];
+        ecs_table_t *table = var->range.table;
+        ecs_assert(table != NULL, ECS_INVALID_OPERATION, 
+            "the variable set on the iterator is missing a table");
 
-    while (ecs_map_next(&it)) {
-        ecs_rest_cmd_capture_t *capture = ecs_map_ptr(&it);
-        int32_t i, count = ecs_vec_count(&capture->syncs);
-        ecs_rest_cmd_sync_capture_t *syncs = ecs_vec_first(&capture->syncs);
-        for (i = 0; i < count; i ++) {
-            ecs_rest_cmd_sync_capture_t *sync = &syncs[i];
-            ecs_os_free(sync->cmds);
+        ecs_query_cache_table_t *qt = flecs_query_cache_get_table(
+            impl->cache, table);
+        if (!qt) {
+            return NULL;
         }
-        ecs_vec_fini_t(NULL, &capture->syncs, ecs_rest_cmd_sync_capture_t);
-        ecs_os_free(capture);
+
+        ecs_query_iter_t *qit = &it->priv_.iter.query;
+        qit->prev = NULL;
+        qit->node = qt->first;
+        qit->last = qt->last;
     }
 
-    ecs_map_fini(&impl->cmd_captures);
+    return flecs_query_next(ctx);
 }
 
 static
-void flecs_rest_server_garbage_collect(
-    ecs_world_t *world,
-    ecs_rest_ctx_t *impl)
+void flecs_query_populate_ptrs(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t offset,
+    ecs_query_cache_table_match_t *node)
 {
-    const ecs_world_info_t *wi = ecs_get_world_info(world);
-    ecs_map_iter_t it = ecs_map_iter(&impl->cmd_captures);
-    ecs_vec_t removed_frames = {0};
-
-    while (ecs_map_next(&it)) {
-        int64_t frame = flecs_uto(int64_t, ecs_map_key(&it));
-        if ((wi->frame_count_total - frame) > FLECS_REST_COMMAND_RETAIN_COUNT) {
-            ecs_rest_cmd_capture_t *capture = ecs_map_ptr(&it);
-            int32_t i, count = ecs_vec_count(&capture->syncs);
-            ecs_rest_cmd_sync_capture_t *syncs = ecs_vec_first(&capture->syncs);
-            for (i = 0; i < count; i ++) {
-                ecs_rest_cmd_sync_capture_t *sync = &syncs[i];
-                ecs_os_free(sync->cmds);
-            }
-            ecs_vec_fini_t(NULL, &capture->syncs, ecs_rest_cmd_sync_capture_t);
-            ecs_os_free(capture);
+    int32_t i, field_count = it->field_count;
+    ecs_data_t *data = &table->data;
+    for (i = 0; i < field_count; i ++) {
+        ECS_TERMSET_CLEAR(it->shared_fields, 1u << i);
 
-            ecs_vec_init_if_t(&removed_frames, int64_t);
-            ecs_vec_append_t(NULL, &removed_frames, int64_t)[0] = frame;
+        int32_t storage_column = node->storage_columns[i];
+        ecs_size_t size = it->sizes[i];
+        if (storage_column < 0 || !size) {
+            /* Tag / no data */
+            it->ptrs[i] = NULL;
+            continue;
         }
+
+        it->ptrs[i] = ecs_vec_get(&data->columns[storage_column].data,
+            it->sizes[i], offset);
     }
+}
 
-    int32_t i, count = ecs_vec_count(&removed_frames);
-    if (count) {
-        int64_t *frames = ecs_vec_first(&removed_frames);
-        if (count) {
-            for (i = 0; i < count; i ++) {
-                ecs_map_remove(&impl->cmd_captures, 
-                    flecs_ito(uint64_t, frames[i]));
-            }
+static
+void flecs_query_populate_ptrs_w_field_map(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t offset,
+    ecs_query_cache_table_match_t *node,
+    int8_t *field_map,
+    int32_t field_count)
+{
+    int32_t i;
+    ecs_data_t *data = &table->data;
+    for (i = 0; i < field_count; i ++) {
+        int32_t storage_column = node->storage_columns[i];
+        int8_t field_index = field_map[i];
+        ecs_size_t size = it->sizes[field_index];
+        if (storage_column < 0 || !size) {
+            /* Tag / no data */
+            it->ptrs[field_index] = NULL;
+            continue;
         }
-        ecs_vec_fini_t(NULL, &removed_frames, int64_t);
+
+        it->ptrs[field_index] = ecs_vec_get(&data->columns[storage_column].data,
+            size, offset);
     }
 }
 
 static
-void flecs_rest_cmd_to_json(
-    ecs_world_t *world,
-    ecs_strbuf_t *buf,
-    ecs_cmd_t *cmd)
+void flecs_query_populate_ptrs_w_shared(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t offset,
+    ecs_query_cache_table_match_t *node,
+    int8_t *field_map,
+    int8_t field_count)
 {
-    ecs_strbuf_list_push(buf, "{", ",");
+    int8_t i;
 
-    ecs_strbuf_list_appendlit(buf, "\"kind\":\"");
-        ecs_strbuf_appendstr(buf, flecs_rest_cmd_kind_to_str(cmd->kind));
-        ecs_strbuf_appendlit(buf, "\"");
+    for (i = 0; i < field_count; i ++) {
+        int32_t column = node->columns[i];
+        int8_t field_index = i;
+        if (field_map) {
+            field_index = field_map[i];
+        }
 
-    if (flecs_rest_cmd_has_id(cmd)) {
-        ecs_strbuf_list_appendlit(buf, "\"id\":\"");
-            char *idstr = ecs_id_str(world, cmd->id);
-            ecs_strbuf_appendstr(buf, idstr);
-            ecs_strbuf_appendlit(buf, "\"");
-            ecs_os_free(idstr);
-    }
+        ecs_size_t size = it->sizes[field_index];
+        if (!ecs_field_is_set(it, i) || !size) {
+            /* Tag / no data */
+            it->ptrs[field_index] = NULL;
+            continue;
+        }
 
-    if (cmd->system) {
-        ecs_strbuf_list_appendlit(buf, "\"system\":\"");
-            char *sysstr = ecs_get_fullpath(world, cmd->system);
-            ecs_strbuf_appendstr(buf, sysstr);
-            ecs_strbuf_appendlit(buf, "\"");
-            ecs_os_free(sysstr); 
+        ecs_entity_t src = it->sources[i];
+        if (src != 0) {
+            ecs_ref_t *ref = &it->references[column];
+            if (ref->id) {
+                it->ptrs[field_index] = (void*)ecs_ref_get_id(
+                    it->real_world, ref, ref->id);
+                ECS_TERMSET_SET(it->shared_fields, 1u << i);
+            } else {
+                it->ptrs[field_index] = NULL;
+            }
+        } else {
+            int32_t storage_column = node->storage_columns[i];
+            if (storage_column < 0) {
+                it->ptrs[field_index] = NULL;
+                continue;
+            }
+            ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+            it->ptrs[field_index] = ecs_vec_get(
+                &table->data.columns[storage_column].data, size, offset);
+            ECS_TERMSET_CLEAR(it->shared_fields, 1u << i);
+        }
     }
+}
 
-    if (cmd->kind == EcsCmdBulkNew) {
-        /* Todo */
-    } else if (cmd->kind == EcsCmdEvent) {
-        /* Todo */
-    } else {
-        if (cmd->entity) {
-            ecs_strbuf_list_appendlit(buf, "\"entity\":\"");
-                char *path = ecs_get_path_w_sep(world, 0, cmd->entity, ".", "");
-                ecs_strbuf_appendstr(buf, path);
-                ecs_strbuf_appendlit(buf, "\"");
-                ecs_os_free(path);
+/* Populate for query that is partially cached.
+ * This requires a mapping from cached fields to query fields. */
+static
+void flecs_query_cache_data_populate(
+    const ecs_query_impl_t *impl,
+    ecs_iter_t *it,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_cache_table_match_t *node)
+{
+    ecs_table_t *table = node->table;
+    ecs_var_t *var = &ctx->vars[0];
+    int32_t count = var->range.count, offset = var->range.offset;
 
-            ecs_strbuf_list_appendlit(buf, "\"is_alive\":\"");
-                if (ecs_is_alive(world, cmd->entity)) {
-                    ecs_strbuf_appendlit(buf, "true");
-                } else {
-                    ecs_strbuf_appendlit(buf, "false");
-                }
-                ecs_strbuf_appendlit(buf, "\"");
+    if (!count) {
+        count = ecs_table_count(table);
+    }
 
-            ecs_strbuf_list_appendlit(buf, "\"next_for_entity\":");
-                ecs_strbuf_appendint(buf, cmd->next_for_entity);
-        }
+    /* If NoData flag is set on iterator, don't populate fields */
+    if (ECS_BIT_IS_SET(it->flags, EcsIterNoData) || !count) {
+        return;
     }
 
-    ecs_strbuf_list_pop(buf, "}");
+    ecs_query_t *cache_query = impl->cache->query;
+    if (!it->references) {
+        flecs_query_populate_ptrs_w_field_map(
+            it, table, offset, node, impl->field_map, cache_query->field_count);
+    } else {
+        flecs_query_populate_ptrs_w_shared(
+            it, table, offset, node, impl->field_map, cache_query->field_count);
+    }
 }
 
+/* Populate for query that is entirely cached.
+ * Cached fields the same as query fields. */
 static
-void flecs_rest_on_commands(
-    const ecs_stage_t *stage,
-    const ecs_vec_t *commands,
-    void *ctx)
+void flecs_query_is_cache_data_populate(
+    ecs_iter_t *it,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_cache_table_match_t *node)
 {
-    ecs_world_t *world = stage->world;
-    ecs_rest_cmd_capture_t *capture = ctx;
-    ecs_assert(capture != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_table_t *table = node->table;
+    ecs_var_t *var = &ctx->vars[0];
+    int32_t count = var->range.count, offset = var->range.offset;
 
-    if (commands) {
-        ecs_vec_init_if_t(&capture->syncs, ecs_rest_cmd_sync_capture_t);
-        ecs_rest_cmd_sync_capture_t *sync = ecs_vec_append_t(
-            NULL, &capture->syncs, ecs_rest_cmd_sync_capture_t);
+    if (!count) {
+        count = ecs_table_count(table);
+    }
 
-        int32_t i, count = ecs_vec_count(commands);
-        ecs_cmd_t *cmds = ecs_vec_first(commands);
-        sync->buf = ECS_STRBUF_INIT;
-        ecs_strbuf_list_push(&sync->buf, "{", ",");
-        ecs_strbuf_list_appendlit(&sync->buf, "\"commands\":");
-            ecs_strbuf_list_push(&sync->buf, "[", ",");
-            for (i = 0; i < count; i ++) {
-                ecs_strbuf_list_next(&sync->buf);
-                flecs_rest_cmd_to_json(world, &sync->buf, &cmds[i]);
-            }
-            ecs_strbuf_list_pop(&sync->buf, "]");
+    /* If NoData flag is set on iterator, don't populate fields */
+    if (ECS_BIT_IS_SET(it->flags, EcsIterNoData) || !count) {
+        return;
+    }
 
-        /* Measure how long it takes to process queue */
-        sync->start_time = (ecs_time_t){0};
-        ecs_time_measure(&sync->start_time);
+    if (!it->references) {
+        flecs_query_populate_ptrs(it, table, offset, node);
     } else {
-        /* Finished processing queue, measure duration */
-        ecs_rest_cmd_sync_capture_t *sync = ecs_vec_last_t(
-            &capture->syncs, ecs_rest_cmd_sync_capture_t);
-        double duration = ecs_time_measure(&sync->start_time);
-
-        ecs_strbuf_list_appendlit(&sync->buf, "\"duration\":");
-        ecs_strbuf_appendflt(&sync->buf, duration, '"');
-        ecs_strbuf_list_pop(&sync->buf, "}");
-
-        sync->cmds = ecs_strbuf_get(&sync->buf);
+        flecs_query_populate_ptrs_w_shared(it, table, offset, node, NULL, 
+            flecs_ito(int8_t, it->field_count));
     }
 }
 
 static
-bool flecs_rest_reply_commands_capture(
-    ecs_world_t *world,
-    ecs_rest_ctx_t *impl,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply)
+void flecs_query_cache_init_mapped_fields(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_cache_table_match_t *node)
 {
-    (void)req;
-    const ecs_world_info_t *wi = ecs_get_world_info(world);
-    ecs_strbuf_appendstr(&reply->body, "{");
-    ecs_strbuf_append(&reply->body, "\"frame\":%u", wi->frame_count_total);
-    ecs_strbuf_appendstr(&reply->body, "}");
-    
-    ecs_map_init_if(&impl->cmd_captures, &world->allocator);
-    ecs_rest_cmd_capture_t *capture = ecs_map_ensure_alloc_t(
-        &impl->cmd_captures, ecs_rest_cmd_capture_t, 
-        flecs_ito(uint64_t, wi->frame_count_total));
+    ecs_iter_t *it = ctx->it;
+    ecs_query_cache_t *cache = impl->cache;
+    int32_t i, field_count = cache->query->field_count;
+    int8_t *field_map = impl->field_map;
 
-    world->on_commands = flecs_rest_on_commands;
-    world->on_commands_ctx = capture;
+    for (i = 0; i < field_count; i ++) {
+        int8_t field_index = field_map[i];
+        it->columns[field_index] = node->columns[i];
+        it->ids[field_index] = node->ids[i];
+        it->sources[field_index] = node->sources[i];
 
-    /* Run garbage collection so that requests don't linger */
-    flecs_rest_server_garbage_collect(world, impl);
+        ecs_termset_t bit = (ecs_termset_t)(1u << i);
+        ecs_termset_t field_bit = (ecs_termset_t)(1u << field_index);
 
-    return true;
+        ECS_TERMSET_COND(it->set_fields, field_bit, node->set_fields & bit);
+        ECS_TERMSET_COND(it->up_fields, field_bit, node->up_fields & bit);
+    }
 }
 
-static
-bool flecs_rest_reply_commands_request(
-    ecs_world_t *world,
-    ecs_rest_ctx_t *impl,
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply)
+/* Iterate cache for query that's partially cached */
+bool flecs_query_cache_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx)
 {
-    (void)world;
-    char *frame_str = &req->path[15];
-    int32_t frame = atoi(frame_str);
-    
-    ecs_map_init_if(&impl->cmd_captures, &world->allocator);
-    const ecs_rest_cmd_capture_t *capture = ecs_map_get_deref(
-        &impl->cmd_captures, ecs_rest_cmd_capture_t, 
-        flecs_ito(uint64_t, frame));
-
-    if (!capture) {
-        ecs_strbuf_appendstr(&reply->body, "{");
-        ecs_strbuf_append(&reply->body, 
-            "\"error\": \"no capture for frame %u\"", frame);
-        ecs_strbuf_appendstr(&reply->body, "}"); 
-        reply->code = 404;
-        return true;
-    }
-
-    ecs_strbuf_appendstr(&reply->body, "{");
-    ecs_strbuf_list_append(&reply->body, "\"syncs\":");
-    ecs_strbuf_list_push(&reply->body, "[", ",");
-
-    int32_t i, count = ecs_vec_count(&capture->syncs);
-    ecs_rest_cmd_sync_capture_t *syncs = ecs_vec_first(&capture->syncs);
-
-    for (i = 0; i < count; i ++) {
-        ecs_rest_cmd_sync_capture_t *sync = &syncs[i];
-        ecs_strbuf_list_appendstr(&reply->body, sync->cmds);
+    ecs_query_cache_table_match_t *node = flecs_query_next(ctx);
+    if (!node) {
+        return false;
     }
 
-    ecs_strbuf_list_pop(&reply->body, "]");
-    ecs_strbuf_appendstr(&reply->body, "}");
+    flecs_query_cache_init_mapped_fields(impl, ctx, node);
 
+    ctx->vars[0].range.count = node->count;
+    ctx->vars[0].range.offset = node->offset;
     return true;
 }
 
-static
-bool flecs_rest_reply(
-    const ecs_http_request_t* req,
-    ecs_http_reply_t *reply,
-    void *ctx)
+/* Iterate cache for query that's entirely cached */
+bool flecs_query_is_cache_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_rest_ctx_t *impl = ctx;
-    ecs_world_t *world = impl->world;
+    (void)impl;
 
-    if (req->path == NULL) {
-        ecs_dbg("rest: bad request (missing path)");
-        flecs_reply_error(reply, "bad request (missing path)");
-        reply->code = 400;
+    ecs_query_cache_table_match_t *node = flecs_query_next(ctx);
+    if (!node) {
         return false;
     }
 
-    if (req->method == EcsHttpGet) {
-        /* Entity endpoint */
-        if (!ecs_os_strncmp(req->path, "entity/", 7)) {
-            return flecs_rest_reply_entity(world, req, reply);
-
-        /* Query endpoint */
-        } else if (!ecs_os_strcmp(req->path, "query")) {
-            return flecs_rest_reply_query(world, req, reply);
-
-        /* World endpoint */
-        } else if (!ecs_os_strcmp(req->path, "world")) {
-            return flecs_rest_reply_world(world, req, reply);
-
-        /* Stats endpoint */
-        } else if (!ecs_os_strncmp(req->path, "stats/", 6)) {
-            return flecs_rest_reply_stats(world, req, reply);
-
-        /* Tables endpoint */
-        } else if (!ecs_os_strncmp(req->path, "tables", 6)) {
-            return flecs_rest_reply_tables(world, req, reply);
-
-        /* Commands capture endpoint */
-        } else if (!ecs_os_strncmp(req->path, "commands/capture", 16)) {
-            return flecs_rest_reply_commands_capture(world, impl, req, reply);
-
-        /* Commands request endpoint (request commands from specific frame) */
-        } else if (!ecs_os_strncmp(req->path, "commands/frame/", 15)) {
-            return flecs_rest_reply_commands_request(world, impl, req, reply);
-        }
-
-    } else if (req->method == EcsHttpPut) {
-        /* Set endpoint */
-        if (!ecs_os_strncmp(req->path, "set/", 4)) {
-            return flecs_rest_set(world, req, reply, &req->path[4]);
-        
-        /* Delete endpoint */
-        } else if (!ecs_os_strncmp(req->path, "delete/", 7)) {
-            return flecs_rest_delete(world, reply, &req->path[7]);
-
-        /* Enable endpoint */
-        } else if (!ecs_os_strncmp(req->path, "enable/", 7)) {
-            return flecs_rest_enable(world, reply, &req->path[7], true);
-
-        /* Disable endpoint */
-        } else if (!ecs_os_strncmp(req->path, "disable/", 8)) {
-            return flecs_rest_enable(world, reply, &req->path[8], false);
+    ecs_iter_t *it = ctx->it;
+    it->columns = node->columns;
+    it->ids = node->ids;
+    it->sources = node->sources;
+    it->set_fields = node->set_fields;
+    it->up_fields = node->up_fields;
+
+    ctx->vars[0].range.count = node->count;
+    ctx->vars[0].range.offset = node->offset;
+    return true;
+}
 
-        /* Script endpoint */
-        } else if (!ecs_os_strncmp(req->path, "script", 6)) {
-            return flecs_rest_script(world, req, reply);
-        }
+/* Iterate cache for query that's partially cached with data */
+bool flecs_query_cache_data_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (!flecs_query_cache_search(impl, ctx)) {
+        return false;
     }
 
-    return false;
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    flecs_query_cache_data_populate(impl, it, ctx, qit->prev);
+    return true;
 }
 
-ecs_http_server_t* ecs_rest_server_init(
-    ecs_world_t *world,
-    const ecs_http_server_desc_t *desc)
+/* Iterate cache for query that's entirely cached with data */
+bool flecs_query_is_cache_data_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_rest_ctx_t *srv_ctx = ecs_os_calloc_t(ecs_rest_ctx_t);
-    ecs_http_server_desc_t private_desc = {0};
-    if (desc) {
-        private_desc = *desc;
-    }
-    private_desc.callback = flecs_rest_reply;
-    private_desc.ctx = srv_ctx;
-
-    ecs_http_server_t *srv = ecs_http_server_init(&private_desc);
-    if (!srv) {
-        ecs_os_free(srv_ctx);
-        return NULL;
+    if (!flecs_query_is_cache_search(impl, ctx)) {
+        return false;
     }
 
-    srv_ctx->world = world;
-    srv_ctx->srv = srv;
-    srv_ctx->rc = 1;
-    srv_ctx->srv = srv;
-    return srv;
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    flecs_query_is_cache_data_populate(it, ctx, qit->prev);
+    return true;
 }
 
-void ecs_rest_server_fini(
-    ecs_http_server_t *srv)
+/* Test if query that is entirely cached matches constrained $this */
+bool flecs_query_cache_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
 {
-    ecs_rest_ctx_t *impl = ecs_http_server_ctx(srv);
-    flecs_rest_server_garbage_collect_all(impl);
-    ecs_os_free(impl);
-    ecs_http_server_fini(srv);
-}
-
-static
-void flecs_on_set_rest(ecs_iter_t *it) {
-    EcsRest *rest = it->ptrs[0];
-
-    int i;
-    for(i = 0; i < it->count; i ++) {
-        if (!rest[i].port) {
-            rest[i].port = ECS_REST_DEFAULT_PORT;
-        }
-
-        ecs_http_server_t *srv = ecs_rest_server_init(it->real_world,
-            &(ecs_http_server_desc_t){ 
-                .ipaddr = rest[i].ipaddr, 
-                .port = rest[i].port,
-                .cache_timeout = 0.2
-            });
-
-        if (!srv) {
-            const char *ipaddr = rest[i].ipaddr ? rest[i].ipaddr : "0.0.0.0";
-            ecs_err("failed to create REST server on %s:%u", 
-                ipaddr, rest[i].port);
-            continue;
-        }
-
-        rest[i].impl = ecs_http_server_ctx(srv);
-
-        ecs_http_server_start(srv);
+    ecs_query_cache_table_match_t *node = flecs_query_test(impl, ctx, first);
+    if (!node) {
+        return false;
     }
-}
 
-static
-void DequeueRest(ecs_iter_t *it) {
-    EcsRest *rest = ecs_field(it, EcsRest, 1);
-
-    if (it->delta_system_time > (ecs_ftime_t)1.0) {
-        ecs_warn(
-            "detected large progress interval (%.2fs), REST request may timeout",
-            (double)it->delta_system_time);
-    }
+    flecs_query_cache_init_mapped_fields(impl, ctx, node);
 
-    int32_t i;
-    for(i = 0; i < it->count; i ++) {
-        ecs_rest_ctx_t *ctx = rest[i].impl;
-        if (ctx) {
-            ecs_http_server_dequeue(ctx->srv, it->delta_time);
-            flecs_rest_server_garbage_collect(it->world, ctx);
-        }
-    } 
+    return true;
 }
 
-static
-void DisableRest(ecs_iter_t *it) {
-    ecs_world_t *world = it->world;
+/* Test if query that is entirely cached matches constrained $this */
+bool flecs_query_is_cache_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
+{
+    ecs_query_cache_table_match_t *node = flecs_query_test(impl, ctx, first);
+    if (!node) {
+        return false;
+    }
 
-    ecs_iter_t rit = ecs_term_iter(world, &(ecs_term_t){
-        .id = ecs_id(EcsRest),
-        .src.flags = EcsSelf
-    });
+    ecs_iter_t *it = ctx->it;
+    it->columns = node->columns;
+    it->ids = node->ids;
+    it->sources = node->sources;
 
-    if (it->event == EcsOnAdd) {
-        /* REST module was disabled */
-        while (ecs_term_next(&rit)) {
-            EcsRest *rest = ecs_field(&rit, EcsRest, 1);
-            int i;
-            for (i = 0; i < rit.count; i ++) {
-                ecs_rest_ctx_t *ctx = rest[i].impl;
-                ecs_http_server_stop(ctx->srv);
-            }
-        }
-    } else if (it->event == EcsOnRemove) {
-        /* REST module was enabled */
-        while (ecs_term_next(&rit)) {
-            EcsRest *rest = ecs_field(&rit, EcsRest, 1);
-            int i;
-            for (i = 0; i < rit.count; i ++) {
-                ecs_rest_ctx_t *ctx = rest[i].impl;
-                ecs_http_server_start(ctx->srv);
-            }
-        }
-    }
+    return true;
 }
 
-void FlecsRestImport(
-    ecs_world_t *world)
+/* Test if query that is partially cached matches constrained $this */
+bool flecs_query_cache_data_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
 {
-    ECS_MODULE(world, FlecsRest);
-
-    ECS_IMPORT(world, FlecsPipeline);
-#ifdef FLECS_PLECS
-    ECS_IMPORT(world, FlecsScript);
-#endif
-#ifdef FLECS_DOC
-    ECS_IMPORT(world, FlecsDoc);
-    ecs_doc_set_brief(world, ecs_id(FlecsRest), 
-        "Module that implements Flecs REST API");
-#endif
-
-    ecs_set_name_prefix(world, "Ecs");
-
-    flecs_bootstrap_component(world, EcsRest);
-
-    ecs_set_hooks(world, EcsRest, { 
-        .ctor = ecs_default_ctor,
-        .move = ecs_move(EcsRest),
-        .copy = ecs_copy(EcsRest),
-        .dtor = ecs_dtor(EcsRest),
-        .on_set = flecs_on_set_rest
-    });
-
-    ECS_SYSTEM(world, DequeueRest, EcsPostFrame, EcsRest);
+    if (!flecs_query_cache_test(impl, ctx, first)) {
+        return false;
+    }
 
-    ecs_system(world, {
-        .entity = ecs_id(DequeueRest),
-        .no_readonly = true
-    });
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    flecs_query_cache_data_populate(impl, it, ctx, qit->prev);
+    return true;
+}
 
-    ecs_observer(world, {
-        .filter = { 
-            .terms = {{ .id = EcsDisabled, .src.id = ecs_id(FlecsRest) }}
-        },
-        .events = {EcsOnAdd, EcsOnRemove},
-        .callback = DisableRest
-    });
+/* Test if query that is entirely cached matches constrained $this with data */
+bool flecs_query_is_cache_data_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
+{
+    if (!flecs_query_is_cache_test(impl, ctx, first)) {
+        return false;
+    }
 
-    ecs_set_name_prefix(world, "EcsRest");
-    ECS_TAG_DEFINE(world, EcsRestPlecs);
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    flecs_query_is_cache_data_populate(it, ctx, qit->prev);
+    return true;
 }
 
-#endif
-
 /**
- * @file addons/snapshot.c
- * @brief Snapshot addon.
+ * @file query/cache_order_by.c
+ * @brief Order by implementation
  */
 
 
-#ifdef FLECS_SNAPSHOT
-
-
-/* World snapshot */
-struct ecs_snapshot_t {
-    ecs_world_t *world;
-    ecs_entity_index_t entity_index;
-    ecs_vec_t tables;
-    uint64_t last_id;
-};
-
-/** Small footprint data structure for storing data associated with a table. */
-typedef struct ecs_table_leaf_t {
-    ecs_table_t *table;
-    ecs_type_t type;
-    ecs_data_t *data;
-} ecs_table_leaf_t;
+ECS_SORT_TABLE_WITH_COMPARE(_, flecs_query_cache_sort_table_generic, order_by, static)
 
 static
-ecs_data_t* flecs_duplicate_data(
+void flecs_query_cache_sort_table(
     ecs_world_t *world,
     ecs_table_t *table,
-    ecs_data_t *main_data)
+    int32_t column_index,
+    ecs_order_by_action_t compare,
+    ecs_sort_table_action_t sort)
 {
-    int32_t count = ecs_table_count(table);
-    if (!count) {
-        return NULL;
+    ecs_data_t *data = &table->data;
+    if (!ecs_vec_count(&data->entities)) {
+        /* Nothing to sort */
+        return;
     }
 
-    ecs_data_t *result = ecs_os_calloc_t(ecs_data_t);
-    int32_t i, column_count = table->column_count;
-    result->columns = flecs_wdup_n(world, ecs_column_t, column_count,
-        main_data->columns);
+    int32_t count = flecs_table_data_count(data);
+    if (count < 2) {
+        return;
+    }
 
-    /* Copy entities */
-    ecs_allocator_t *a = &world->allocator;
-    result->entities = ecs_vec_copy_shrink_t(a, &main_data->entities, ecs_entity_t);
+    ecs_entity_t *entities = ecs_vec_first(&data->entities);
 
-    /* Copy each column */
-    for (i = 0; i < column_count; i ++) {
-        ecs_column_t *column = &result->columns[i];
+    void *ptr = NULL;
+    int32_t size = 0;
+    if (column_index != -1) {
+        ecs_column_t *column = &data->columns[column_index];
         ecs_type_info_t *ti = column->ti;
-        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
-        int32_t size = ti->size;
-        ecs_copy_t copy = ti->hooks.copy_ctor;
-        if (copy) {
-            void *src_ptr = ecs_vec_first(&column->data);
-
-            ecs_vec_t dst;
-            ecs_vec_init(a, &dst, size, count);
-            ecs_vec_set_count(a, &dst, size, count);
-            void *dst_ptr = ecs_vec_first(&dst);
-
-            copy(dst_ptr, src_ptr, count, ti);
-
-            column->data = dst;
-        } else {
-            column->data = ecs_vec_copy_shrink(a, &column->data, size);
-        }
+        size = ti->size;
+        ptr = ecs_vec_first(&column->data);
     }
 
-    return result;
+    if (sort) {
+        sort(world, table, entities, ptr, size, 0, count - 1, compare);
+    } else {
+        flecs_query_cache_sort_table_generic(
+            world, table, entities, ptr, size, 0, count - 1, compare);
+    }
 }
 
+/* Helper struct for building sorted table ranges */
+typedef struct sort_helper_t {
+    ecs_query_cache_table_match_t *match;
+    ecs_entity_t *entities;
+    const void *ptr;
+    int32_t row;
+    int32_t elem_size;
+    int32_t count;
+    bool shared;
+} sort_helper_t;
+
 static
-void snapshot_table(
-    const ecs_world_t *world,
-    ecs_snapshot_t *snapshot,
-    ecs_table_t *table)
+const void* ptr_from_helper(
+    sort_helper_t *helper)
 {
-    if (table->flags & EcsTableHasBuiltins) {
-        return;
+    ecs_assert(helper->row < helper->count, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(helper->elem_size >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(helper->row >= 0, ECS_INTERNAL_ERROR, NULL);
+    if (helper->shared) {
+        return helper->ptr;
+    } else {
+        return ECS_ELEM(helper->ptr, helper->elem_size, helper->row);
     }
-    
-    ecs_table_leaf_t *l = ecs_vec_get_t(
-        &snapshot->tables, ecs_table_leaf_t, (int32_t)table->id);
-    ecs_assert(l != NULL, ECS_INTERNAL_ERROR, NULL);
-    
-    l->table = table;
-    l->type = flecs_type_copy(
-        ECS_CONST_CAST(ecs_world_t*, world), &table->type);
-    l->data = flecs_duplicate_data(
-        ECS_CONST_CAST(ecs_world_t*, world), table, &table->data);
 }
 
 static
-ecs_snapshot_t* snapshot_create(
-    const ecs_world_t *world,
-    const ecs_entity_index_t *entity_index,
-    ecs_iter_t *iter,
-    ecs_iter_next_action_t next)
+ecs_entity_t e_from_helper(
+    sort_helper_t *helper)
 {
-    ecs_snapshot_t *result = ecs_os_calloc_t(ecs_snapshot_t);
-    ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL);
-
-    ecs_run_aperiodic(ECS_CONST_CAST(ecs_world_t*, world), 0);
-
-    result->world = ECS_CONST_CAST(ecs_world_t*, world);
-
-    /* If no iterator is provided, the snapshot will be taken of the entire
-     * world, and we can simply copy the entity index as it will be restored
-     * entirely upon snapshote restore. */
-    if (!iter && entity_index) {
-        flecs_entities_copy(&result->entity_index, entity_index);
-    }
-
-    /* Create vector with as many elements as tables, so we can store the
-     * snapshot tables at their element ids. When restoring a snapshot, the code
-     * will run a diff between the tables in the world and the snapshot, to see
-     * which of the world tables still exist, no longer exist, or need to be
-     * deleted. */
-    uint64_t t, table_count = flecs_sparse_last_id(&world->store.tables) + 1;
-    ecs_vec_init_t(NULL, &result->tables, ecs_table_leaf_t, (int32_t)table_count);
-    ecs_vec_set_count_t(NULL, &result->tables, ecs_table_leaf_t, (int32_t)table_count);
-    ecs_table_leaf_t *arr = ecs_vec_first_t(&result->tables, ecs_table_leaf_t);
-
-    /* Array may have holes, so initialize with 0 */
-    ecs_os_memset_n(arr, 0, ecs_table_leaf_t, table_count);
-
-    /* Iterate tables in iterator */
-    if (iter) {
-        while (next(iter)) {
-            ecs_table_t *table = iter->table;
-            snapshot_table(world, result, table);
-        }
+    if (helper->row < helper->count) {
+        return helper->entities[helper->row];
     } else {
-        for (t = 1; t < table_count; t ++) {
-            ecs_table_t *table = flecs_sparse_get_t(
-                &world->store.tables, ecs_table_t, t);
-            snapshot_table(world, result, table);
-        }
+        return 0;
     }
-
-    return result;
 }
 
-/** Create a snapshot */
-ecs_snapshot_t* ecs_snapshot_take(
-    ecs_world_t *stage)
+static
+void flecs_query_cache_build_sorted_table_range(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_list_t *list)
 {
-    const ecs_world_t *world = ecs_get_world(stage);
-
-    ecs_snapshot_t *result = snapshot_create(
-        world, ecs_eis(world), NULL, NULL);
+    ecs_world_t *world = cache->query->world;
+    ecs_assert(!(world->flags & EcsWorldMultiThreaded), ECS_UNSUPPORTED,
+        "cannot sort query in multithreaded mode");
 
-    result->last_id = flecs_entities_max_id(world);
+    ecs_entity_t id = cache->order_by;
+    ecs_order_by_action_t compare = cache->order_by_callback;
+    int32_t table_count = list->info.table_count;
+    if (!table_count) {
+        return;
+    }
 
-    return result;
-}
+    ecs_vec_init_if_t(&cache->table_slices, ecs_query_cache_table_match_t);
+    int32_t to_sort = 0;
+    int32_t order_by_term = cache->order_by_term;
 
-/** Create a filtered snapshot */
-ecs_snapshot_t* ecs_snapshot_take_w_iter(
-    ecs_iter_t *iter)
-{
-    ecs_world_t *world = iter->world;
-    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    sort_helper_t *helper = flecs_alloc_n(
+        &world->allocator, sort_helper_t, table_count);
+    ecs_query_cache_table_match_t *cur, *end = list->last->next;
+    for (cur = list->first; cur != end; cur = cur->next) {
+        ecs_table_t *table = cur->table;
+        ecs_data_t *data = &table->data;
 
-    ecs_snapshot_t *result = snapshot_create(
-        world, ecs_eis(world), iter, iter ? iter->next : NULL);
+        ecs_assert(ecs_table_count(table) != 0, ECS_INTERNAL_ERROR, NULL);
 
-    result->last_id = flecs_entities_max_id(world);
+        if (id) {
+            const ecs_term_t *term = &cache->query->terms[order_by_term];
+            int32_t field = term->field_index;
+            int32_t column = cur->columns[field];
+            ecs_size_t size = cache->query->sizes[field];
+            ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+            ecs_entity_t src = cur->sources[field];
+            if (src == 0) {
+                column = table->column_map[column];
+                ecs_vec_t *vec = &data->columns[column].data;
+                helper[to_sort].ptr = ecs_vec_first(vec);
+                helper[to_sort].elem_size = size;
+                helper[to_sort].shared = false;
+            } else {
+                ecs_record_t *r = flecs_entities_get(world, src);
+                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
+                ecs_assert(r->table != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    return result;
-}
+                if (term->src.id & EcsUp) {
+                    ecs_entity_t base = 0;
+                    ecs_search_relation(world, r->table, 0, id, 
+                        EcsIsA, term->src.id & EcsTraverseFlags, &base, 0, 0);
+                    if (base && base != src) { /* Component could be inherited */
+                        r = flecs_entities_get(world, base);
+                    }
+                }
 
-/* Restoring an unfiltered snapshot restores the world to the exact state it was
- * when the snapshot was taken. */
-static
-void restore_unfiltered(
-    ecs_world_t *world,
-    ecs_snapshot_t *snapshot)
-{
-    flecs_entity_index_restore(ecs_eis(world), &snapshot->entity_index);
-    flecs_entity_index_fini(&snapshot->entity_index);
-    
-    flecs_entities_max_id(world) = snapshot->last_id;
+                helper[to_sort].ptr = ecs_table_get_id(
+                    world, r->table, id, ECS_RECORD_TO_ROW(r->row));
+                helper[to_sort].elem_size = size;
+                helper[to_sort].shared = true;
+            }
+            ecs_assert(helper[to_sort].ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(helper[to_sort].elem_size != 0, ECS_INTERNAL_ERROR, NULL);
+        } else {
+            helper[to_sort].ptr = NULL;
+            helper[to_sort].elem_size = 0;
+            helper[to_sort].shared = false;
+        }
 
-    ecs_table_leaf_t *leafs = ecs_vec_first_t(&snapshot->tables, ecs_table_leaf_t);
-    int32_t i, count = (int32_t)flecs_sparse_last_id(&world->store.tables);
-    int32_t snapshot_count = ecs_vec_count(&snapshot->tables);
+        helper[to_sort].match = cur;
+        helper[to_sort].entities = ecs_vec_first(&data->entities);
+        helper[to_sort].row = 0;
+        helper[to_sort].count = ecs_table_count(table);
+        to_sort ++;      
+    }
 
-    for (i = 1; i <= count; i ++) {
-        ecs_table_t *world_table = flecs_sparse_get_t(
-            &world->store.tables, ecs_table_t, (uint32_t)i);
+    ecs_assert(to_sort != 0, ECS_INTERNAL_ERROR, NULL);
 
-        if (world_table && (world_table->flags & EcsTableHasBuiltins)) {
-            continue;
-        }
+    bool proceed;
+    do {
+        int32_t j, min = 0;
+        proceed = true;
 
-        ecs_table_leaf_t *snapshot_table = NULL;
-        if (i < snapshot_count) {
-            snapshot_table = &leafs[i];
-            if (!snapshot_table->table) {
-                snapshot_table = NULL;
+        ecs_entity_t e1;
+        while (!(e1 = e_from_helper(&helper[min]))) {
+            min ++;
+            if (min == to_sort) {
+                proceed = false;
+                break;
             }
         }
 
-        /* If the world table no longer exists but the snapshot table does,
-         * reinsert it */
-        if (!world_table && snapshot_table) {
-            ecs_table_t *table = flecs_table_find_or_create(world, 
-                &snapshot_table->type);
-            ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (!proceed) {
+            break;
+        }
 
-            if (snapshot_table->data) {
-                flecs_table_replace_data(world, table, snapshot_table->data);
+        for (j = min + 1; j < to_sort; j++) {
+            ecs_entity_t e2 = e_from_helper(&helper[j]);
+            if (!e2) {
+                continue;
             }
 
-        /* If the world table still exists, replace its data */
-        } else if (world_table && snapshot_table) {
-            ecs_assert(snapshot_table->table == world_table, 
-                ECS_INTERNAL_ERROR, NULL);
+            const void *ptr1 = ptr_from_helper(&helper[min]);
+            const void *ptr2 = ptr_from_helper(&helper[j]);
 
-            if (snapshot_table->data) {
-                flecs_table_replace_data(
-                    world, world_table, snapshot_table->data);
-            } else {
-                flecs_table_clear_data(
-                    world, world_table, &world_table->data);
-                flecs_table_init_data(world, world_table);
+            if (compare(e1, ptr1, e2, ptr2) > 0) {
+                min = j;
+                e1 = e_from_helper(&helper[min]);
             }
-        
-        /* If the snapshot table doesn't exist, this table was created after the
-         * snapshot was taken and needs to be deleted */
-        } else if (world_table && !snapshot_table) {
-            /* Deleting a table invokes OnRemove triggers & updates the entity
-             * index. That is not what we want, since entities may no longer be
-             * valid (if they don't exist in the snapshot) or may have been
-             * restored in a different table. Therefore first clear the data
-             * from the table (which doesn't invoke triggers), and then delete
-             * the table. */
-            flecs_table_clear_data(world, world_table, &world_table->data);
-            flecs_delete_table(world, world_table);
-        
-        /* If there is no world & snapshot table, nothing needs to be done */
-        } else { }
-
-        if (snapshot_table) {
-            ecs_os_free(snapshot_table->data);
-            flecs_type_free(world, &snapshot_table->type);
-        }
-    }
-
-    /* Now that all tables have been restored and world is in a consistent
-     * state, run OnSet systems */
-    int32_t world_count = flecs_sparse_count(&world->store.tables);
-    for (i = 0; i < world_count; i ++) {
-        ecs_table_t *table = flecs_sparse_get_dense_t(
-            &world->store.tables, ecs_table_t, i);
-        if (table->flags & EcsTableHasBuiltins) {
-            continue;
         }
 
-        int32_t tcount = ecs_table_count(table);
-        if (tcount) {
-            int32_t j, storage_count = table->column_count;
-            for (j = 0; j < storage_count; j ++) {
-                ecs_type_t type = {
-                    .array = &table->data.columns[j].id,
-                    .count = 1
-                };
-                flecs_notify_on_set(world, table, 0, tcount, &type, true);
-            }
+        sort_helper_t *cur_helper = &helper[min];
+        if (!cur || cur->columns != cur_helper->match->columns) {
+            cur = ecs_vec_append_t(NULL, &cache->table_slices, 
+                ecs_query_cache_table_match_t);
+            *cur = *(cur_helper->match);
+            cur->offset = cur_helper->row;
+            cur->count = 1;
+        } else {
+            cur->count ++;
         }
-    }
-}
 
-/* Restoring a filtered snapshots only restores the entities in the snapshot
- * to their previous state. */
-static
-void restore_filtered(
-    ecs_world_t *world,
-    ecs_snapshot_t *snapshot)
-{
-    ecs_table_leaf_t *leafs = ecs_vec_first_t(&snapshot->tables, ecs_table_leaf_t);
-    int32_t l = 0, snapshot_count = ecs_vec_count(&snapshot->tables);
+        cur_helper->row ++;
+    } while (proceed);
 
-    for (l = 0; l < snapshot_count; l ++) {
-        ecs_table_leaf_t *snapshot_table = &leafs[l];
-        ecs_table_t *table = snapshot_table->table;
+    /* Iterate through the vector of slices to set the prev/next ptrs. This
+     * can't be done while building the vector, as reallocs may occur */
+    int32_t i, count = ecs_vec_count(&cache->table_slices);    
+    ecs_query_cache_table_match_t *nodes = ecs_vec_first(&cache->table_slices);
+    for (i = 0; i < count; i ++) {
+        nodes[i].prev = &nodes[i - 1];
+        nodes[i].next = &nodes[i + 1];
+    }
 
-        if (!table) {
-            continue;
-        }
+    nodes[0].prev = NULL;
+    nodes[i - 1].next = NULL;
 
-        ecs_data_t *data = snapshot_table->data;
-        if (!data) {
-            flecs_type_free(world, &snapshot_table->type);
-            continue;
-        }
+    flecs_free_n(&world->allocator, sort_helper_t, table_count, helper);
+}
 
-        /* Delete entity from storage first, so that when we restore it to the
-         * current table we can be sure that there won't be any duplicates */
-        int32_t i, entity_count = ecs_vec_count(&data->entities);
-        ecs_entity_t *entities = ecs_vec_first(
-            &snapshot_table->data->entities);
-        for (i = 0; i < entity_count; i ++) {
-            ecs_entity_t e = entities[i];
-            ecs_record_t *r = flecs_entities_try(world, e);
-            if (r && r->table) {
-                flecs_table_delete(world, r->table, 
-                    ECS_RECORD_TO_ROW(r->row), true);
-            } else {
-                /* Make sure that the entity has the same generation count */
-                flecs_entities_make_alive(world, e);
-            }
-        }
+void flecs_query_cache_build_sorted_tables(
+    ecs_query_cache_t *cache)
+{
+    ecs_vec_clear(&cache->table_slices);
 
-        /* Merge data from snapshot table with world table */
-        int32_t old_count = ecs_table_count(snapshot_table->table);
-        int32_t new_count = flecs_table_data_count(snapshot_table->data);
+    if (cache->group_by_callback) {
+        /* Populate sorted node list in grouping order */
+        ecs_query_cache_table_match_t *cur = cache->list.first;
+        if (cur) {
+            do {
+                /* Find list for current group */
+                uint64_t group_id = cur->group_id;
+                ecs_query_cache_table_list_t *list = ecs_map_get_deref(
+                    &cache->groups, ecs_query_cache_table_list_t, group_id);
+                ecs_assert(list != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        flecs_table_merge(world, table, table, &table->data, snapshot_table->data);
+                /* Sort tables in current group */
+                flecs_query_cache_build_sorted_table_range(cache, list);
 
-        /* Run OnSet systems for merged entities */
-        if (new_count) {
-            int32_t j, storage_count = table->column_count;
-            for (j = 0; j < storage_count; j ++) {
-                ecs_type_t type = {
-                    .array = &table->data.columns[j].id,
-                    .count = 1
-                };
-                flecs_notify_on_set(
-                    world, table, old_count, new_count, &type, true);
-            }
+                /* Find next group to sort */
+                cur = list->last->next;
+            } while (cur);
         }
-
-        flecs_wfree_n(world, ecs_column_t, table->column_count,
-            snapshot_table->data->columns);
-        ecs_os_free(snapshot_table->data);
-        flecs_type_free(world, &snapshot_table->type);
+    } else {
+        flecs_query_cache_build_sorted_table_range(cache, &cache->list);
     }
 }
 
-/** Restore a snapshot */
-void ecs_snapshot_restore(
+void flecs_query_cache_sort_tables(
     ecs_world_t *world,
-    ecs_snapshot_t *snapshot)
+    ecs_query_impl_t *impl)
 {
-    ecs_run_aperiodic(world, 0);
-    
-    if (flecs_entity_index_count(&snapshot->entity_index) > 0) {
-        /* Unfiltered snapshots have a copy of the entity index which is
-         * copied back entirely when the snapshot is restored */
-        restore_unfiltered(world, snapshot);
-    } else {
-        restore_filtered(world, snapshot);
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_order_by_action_t compare = cache->order_by_callback;
+    if (!compare) {
+        return;
     }
 
-    ecs_vec_fini_t(NULL, &snapshot->tables, ecs_table_leaf_t);
+    ecs_sort_table_action_t sort = cache->order_by_table_callback;
+    
+    ecs_entity_t order_by = cache->order_by;
+    int32_t order_by_term = cache->order_by_term;
 
-    ecs_os_free(snapshot);
-}
+    /* Iterate over non-empty tables. Don't bother with empty tables as they
+     * have nothing to sort */
 
-ecs_iter_t ecs_snapshot_iter(
-    ecs_snapshot_t *snapshot)
-{
-    ecs_snapshot_iter_t iter = {
-        .tables = snapshot->tables,
-        .index = 0
-    };
+    bool tables_sorted = false;
 
-    return (ecs_iter_t){
-        .world = snapshot->world,
-        .table_count = ecs_vec_count(&snapshot->tables),
-        .priv.iter.snapshot = iter,
-        .next = ecs_snapshot_next
-    };
-}
+    ecs_id_record_t *idr = flecs_id_record_get(world, order_by);
+    ecs_table_cache_iter_t it;
+    ecs_query_cache_table_t *qt;
+    flecs_table_cache_iter(&cache->cache, &it);
 
-bool ecs_snapshot_next(
-    ecs_iter_t *it)
-{
-    ecs_snapshot_iter_t *iter = &it->priv.iter.snapshot;
-    ecs_table_leaf_t *tables = ecs_vec_first_t(&iter->tables, ecs_table_leaf_t);
-    int32_t count = ecs_vec_count(&iter->tables);
-    int32_t i;
+    while ((qt = flecs_table_cache_next(&it, ecs_query_cache_table_t))) {
+        ecs_table_t *table = qt->hdr.table;
+        bool dirty = false;
 
-    for (i = iter->index; i < count; i ++) {
-        ecs_table_t *table = tables[i].table;
-        if (!table) {
-            continue;
+        if (flecs_query_check_table_monitor(impl, qt, 0)) {
+            tables_sorted = true;
+            dirty = true;
         }
 
-        ecs_data_t *data = tables[i].data;
+        int32_t column = -1;
+        if (order_by) {
+            if (flecs_query_check_table_monitor(impl, qt, order_by_term + 1)) {
+                dirty = true;
+            }
 
-        it->table = table;
-        it->count = ecs_table_count(table);
-        if (data) {
-            it->entities = ecs_vec_first(&data->entities);
-        } else {
-            it->entities = NULL;
-        }
-
-        ECS_BIT_SET(it->flags, EcsIterIsValid);
-        iter->index = i + 1;
-        
-        goto yield;
-    }
-
-    ECS_BIT_CLEAR(it->flags, EcsIterIsValid);
-    return false;
-
-yield:
-    ECS_BIT_CLEAR(it->flags, EcsIterIsValid);
-    return true;    
-}
+            if (dirty) {
+                column = -1;
 
-/** Cleanup snapshot */
-void ecs_snapshot_free(
-    ecs_snapshot_t *snapshot)
-{
-    flecs_entity_index_fini(&snapshot->entity_index);
+                const ecs_table_record_t *tr = flecs_id_record_get_table(
+                    idr, table);
+                if (tr) {
+                    column = tr->column;
+                }
 
-    ecs_table_leaf_t *tables = ecs_vec_first_t(&snapshot->tables, ecs_table_leaf_t);
-    int32_t i, count = ecs_vec_count(&snapshot->tables);
-    for (i = 0; i < count; i ++) {
-        ecs_table_leaf_t *snapshot_table = &tables[i];
-        ecs_table_t *table = snapshot_table->table;
-        if (table) {
-            ecs_data_t *data = snapshot_table->data;
-            if (data) {
-                flecs_table_clear_data(snapshot->world, table, data);
-                ecs_os_free(data);
+                if (column == -1) {
+                    /* Component is shared, no sorting is needed */
+                    dirty = false;
+                }
             }
-            flecs_type_free(snapshot->world, &snapshot_table->type);
         }
-    }    
-
-    ecs_vec_fini_t(NULL, &snapshot->tables, ecs_table_leaf_t);
-    ecs_os_free(snapshot);
-}
-
-#endif
-
-/**
- * @file addons/stats.c
- * @brief Stats addon.
- */
-
 
-#ifdef FLECS_SYSTEM
-/**
- * @file addons/system/system.h
- * @brief Internal types and functions for system addon.
- */
+        if (!dirty) {
+            continue;
+        }
 
-#ifndef FLECS_SYSTEM_PRIVATE_H
-#define FLECS_SYSTEM_PRIVATE_H
+        /* Something has changed, sort the table. Prefers using 
+         * flecs_query_cache_sort_table when available */
+        flecs_query_cache_sort_table(world, table, column, compare, sort);
+        tables_sorted = true;
+    }
 
-#ifdef FLECS_SYSTEM
+    if (tables_sorted || cache->match_count != cache->prev_match_count) {
+        flecs_query_cache_build_sorted_tables(cache);
+        cache->match_count ++; /* Increase version if tables changed */
+    }
+}
 
 
-#define ecs_system_t_magic     (0x65637383)
-#define ecs_system_t_tag       EcsSystem
+typedef struct {
+    ecs_table_t *table;
+    int32_t column;
+} flecs_table_column_t;
 
-extern ecs_mixins_t ecs_system_t_mixins;
+static
+void flecs_query_get_column_for_field(
+    const ecs_query_t *q,
+    ecs_query_cache_table_match_t *match,
+    int32_t field,
+    flecs_table_column_t *out)
+{
+    ecs_assert(field >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(field < q->field_count, ECS_INTERNAL_ERROR, NULL);
 
-typedef struct ecs_system_t {
-    ecs_header_t hdr;
+    ecs_entity_t src = match->sources[field];
+    ecs_table_t *table = NULL;
+    int32_t column = -1;
 
-    ecs_run_action_t run;           /* See ecs_system_desc_t */
-    ecs_iter_action_t action;       /* See ecs_system_desc_t */
+    if (!src) {
+        table = match->table;
+        column = match->storage_columns[field];
+        if (column == -2) {
+            /* Shared field */
+            column = -1;
+        }
+    } else {
+        ecs_record_t *r = flecs_entities_get(q->world, src);
+        table = r->table;
 
-    ecs_query_t *query;             /* System query */
-    ecs_entity_t query_entity;      /* Entity associated with query */
-    ecs_entity_t tick_source;       /* Tick source associated with system */
-    
-    /* Schedule parameters */
-    bool multi_threaded;
-    bool no_readonly;
+        int32_t ref_index = match->columns[field];
+        ecs_ref_t *ref = ecs_vec_get_t(&match->refs, ecs_ref_t, ref_index);
+        if (ref->id != 0) {
+            ecs_ref_update(q->world, ref);
+            column = ref->tr->column;
+        }
+    }
 
-    ecs_ftime_t time_spent;         /* Time spent on running system */
-    ecs_ftime_t time_passed;        /* Time passed since last invocation */
-    int64_t last_frame;             /* Last frame for which the system was considered */
+    out->table = table;
+    out->column = column;
+}
 
-    void *ctx;                      /* Userdata for system */
-    void *binding_ctx;              /* Optional language binding context */
+/* Get match monitor. Monitors are used to keep track of whether components 
+ * matched by the query in a table have changed. */
+static
+bool flecs_query_get_match_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match)
+{
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (match->monitor) {
+        return false;
+    }
 
-    ecs_ctx_free_t ctx_free;
-    ecs_ctx_free_t binding_ctx_free;
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    int32_t *monitor = flecs_balloc(&cache->allocators.monitors);
+    monitor[0] = 0;
 
-    /* Mixins */
-    ecs_world_t *world;
-    ecs_entity_t entity;
-    ecs_poly_dtor_t dtor;      
-} ecs_system_t;
+    /* Mark terms that don't need to be monitored. This saves time when reading
+     * and/or updating the monitor. */
+    const ecs_query_t *q = cache->query;
+    int32_t i, field = -1, term_count = q->term_count;
+    flecs_table_column_t tc;
 
-/* Invoked when system becomes active / inactive */
-void ecs_system_activate(
-    ecs_world_t *world,
-    ecs_entity_t system,
-    bool activate,
-    const ecs_system_t *system_data);
+    for (i = 0; i < term_count; i ++) {
+        if (field == q->terms[i].field_index) {
+            if (monitor[field + 1] != -1) {
+                continue;
+            }
+        }
 
-/* Internal function to run a system */
-ecs_entity_t ecs_run_intern(
-    ecs_world_t *world,
-    ecs_stage_t *stage,
-    ecs_entity_t system,
-    ecs_system_t *system_data,
-    int32_t stage_current,
-    int32_t stage_count,
-    ecs_ftime_t delta_time,
-    int32_t offset,
-    int32_t limit,
-    void *param);
+        field = q->terms[i].field_index;
+        monitor[field + 1] = -1;
 
-#endif
+        /* If term isn't read, don't monitor */
+        if (q->terms[i].inout != EcsIn && 
+            q->terms[i].inout != EcsInOut &&
+            q->terms[i].inout != EcsInOutDefault) {
+            continue;
+        }
 
-#endif
+        /* Don't track fields that aren't set */
+        if (!(match->set_fields & (1llu << field))) {
+            continue;
+        }
 
-#endif
+        ecs_assert(match->columns != NULL, ECS_INTERNAL_ERROR, NULL);
+        int32_t column = match->columns[field];
+        ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+        (void)column;
 
-#ifdef FLECS_PIPELINE
-/**
- * @file addons/pipeline/pipeline.h
- * @brief Internal functions/types for pipeline addon.
- */
+        flecs_query_get_column_for_field(q, match, field, &tc);
+        if (tc.column == -1) {
+            continue; /* Don't track terms that aren't stored */
+        }
 
-#ifndef FLECS_PIPELINE_PRIVATE_H
-#define FLECS_PIPELINE_PRIVATE_H
+        monitor[field + 1] = 0;
+    }
 
+    match->monitor = monitor;
 
-/** Instruction data for pipeline.
- * This type is the element type in the "ops" vector of a pipeline. */
-typedef struct ecs_pipeline_op_t {
-    int32_t offset;             /* Offset in systems vector */
-    int32_t count;              /* Number of systems to run before next op */
-    double time_spent;          /* Time spent merging commands for sync point */
-    int64_t commands_enqueued;  /* Number of commands enqueued for sync point */
-    bool multi_threaded;        /* Whether systems can be ran multi threaded */
-    bool no_readonly;           /* Whether systems are staged or not */
-} ecs_pipeline_op_t;
+    impl->pub.flags |= EcsQueryHasMonitor;
 
-struct ecs_pipeline_state_t {
-    ecs_query_t *query;         /* Pipeline query */
-    ecs_vec_t ops;              /* Pipeline schedule */
-    ecs_vec_t systems;          /* Vector with system ids */
+    return true;
+}
 
-    ecs_entity_t last_system;   /* Last system ran by pipeline */
-    ecs_id_record_t *idr_inactive; /* Cached record for quick inactive test */
-    int32_t match_count;        /* Used to track of rebuild is necessary */
-    int32_t rebuild_count;      /* Number of pipeline rebuilds */
-    ecs_iter_t *iters;          /* Iterator for worker(s) */
-    int32_t iter_count;
+/* Get monitor for fixed query terms. Fixed terms are handled separately as they
+ * don't require a query cache, and fixed terms aren't stored in the cache. */
+static
+bool flecs_query_get_fixed_monitor(
+    ecs_query_impl_t *impl,
+    bool check)
+{
+    ecs_query_t *q = &impl->pub;
+    ecs_world_t *world = q->world;
+    ecs_term_t *terms = q->terms;
+    int32_t i, term_count = q->term_count;
 
-    /* Members for continuing pipeline iteration after pipeline rebuild */
-    ecs_pipeline_op_t *cur_op;  /* Current pipeline op */
-    int32_t cur_i;              /* Index in current result */
-    int32_t ran_since_merge;    /* Index in current op */
-    bool no_readonly;           /* Is pipeline in readonly mode */
-};
+    if (!impl->monitor) {
+        impl->monitor = flecs_alloc_n(&impl->pub.stage->allocator, 
+            int32_t, q->field_count);
+        check = false; /* If the monitor is new, initialize it with dirty state */
+    }
 
-typedef struct EcsPipeline {
-    /* Stable ptr so threads can safely access while entity/components move */
-    ecs_pipeline_state_t *state;
-} EcsPipeline;
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
+        int32_t field_index = term->field_index;
 
-////////////////////////////////////////////////////////////////////////////////
-//// Pipeline API
-////////////////////////////////////////////////////////////////////////////////
+        if (!(q->read_fields & (1 << field_index))) {
+            continue; /* If term doesn't read data there's nothing to track */
+        }
 
-bool flecs_pipeline_update(
-    ecs_world_t *world,
-    ecs_pipeline_state_t *pq,
-    bool start_of_frame);
+        if (!(term->src.id & EcsIsEntity)) {
+            continue; /* Not a term with a fixed source */
+        }
 
-void flecs_run_pipeline(
-    ecs_world_t *world,
-    ecs_pipeline_state_t *pq,
-    ecs_ftime_t delta_time);
+        ecs_entity_t src = ECS_TERM_REF_ID(&term->src);
+        ecs_assert(src != 0, ECS_INTERNAL_ERROR, NULL);
 
-int32_t flecs_run_pipeline_ops(
-    ecs_world_t* world,
-    ecs_stage_t* stage,
-    int32_t stage_index,
-    int32_t stage_count,
-    ecs_ftime_t delta_time);
+        ecs_record_t *r = flecs_entities_get(world, src);
+        if (!r || !r->table) {
+            continue; /* Entity is empty, nothing to track */
+        }
 
-////////////////////////////////////////////////////////////////////////////////
-//// Worker API
-////////////////////////////////////////////////////////////////////////////////
+        ecs_id_record_t *idr = flecs_id_record_get(world, term->id);
+        if (!idr) {
+            continue; /* If id doesn't exist, entity can't have it */
+        }
 
-void flecs_workers_progress(
-    ecs_world_t *world,
-    ecs_pipeline_state_t *pq,
-    ecs_ftime_t delta_time);
+        ecs_table_record_t *tr = flecs_id_record_get_table(idr, r->table);
+        if (!tr) {
+            continue; /* Entity doesn't have the component */
+        }
 
-void flecs_create_worker_threads(
-    ecs_world_t *world);
+        /* Copy/check column dirty state from table */
+        int32_t *dirty_state = flecs_table_get_dirty_state(world, r->table);
+        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
 
-void flecs_join_worker_threads(
-    ecs_world_t *world);
+        if (!check) {
+            impl->monitor[field_index] = dirty_state[tr->column + 1];
+        } else {
+            if (impl->monitor[field_index] != dirty_state[tr->column + 1]) {
+                return true;
+            }
+        }
+    }
 
-void flecs_signal_workers(
-    ecs_world_t *world);
+    return !check;
+}
 
-void flecs_wait_for_sync(
-    ecs_world_t *world);
+bool flecs_query_update_fixed_monitor(
+    ecs_query_impl_t *impl)
+{
+    return flecs_query_get_fixed_monitor(impl, false);
+}
 
-#endif
+bool flecs_query_check_fixed_monitor(
+    ecs_query_impl_t *impl)
+{
+    return flecs_query_get_fixed_monitor(impl, true);
+}
 
-#endif
 
-#ifdef FLECS_STATS
+/* Check if single match term has changed */
+static
+bool flecs_query_check_match_monitor_term(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match,
+    int32_t field)
+{
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
 
-#define ECS_GAUGE_RECORD(m, t, value)\
-    flecs_gauge_record(m, t, (ecs_float_t)(value))
+    if (flecs_query_get_match_monitor(impl, match)) {
+        return true;
+    }
 
-#define ECS_COUNTER_RECORD(m, t, value)\
-    flecs_counter_record(m, t, (double)(value))
+    int32_t *monitor = match->monitor;
+    int32_t state = monitor[field];
+    if (state == -1) {
+        return false;
+    }
 
-#define ECS_METRIC_FIRST(stats)\
-    ECS_CAST(ecs_metric_t*, ECS_OFFSET(&stats->first_, ECS_SIZEOF(int64_t)))
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_table_t *table = match->table;
+    if (table) {
+        int32_t *dirty_state = flecs_table_get_dirty_state(
+            cache->query->world, table);
+        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (!field) {
+            return monitor[0] != dirty_state[0];
+        }
+    } else if (!field) {
+        return false;
+    }
 
-#define ECS_METRIC_LAST(stats)\
-    ECS_CAST(ecs_metric_t*, ECS_OFFSET(&stats->last_, -ECS_SIZEOF(ecs_metric_t)))
+    flecs_table_column_t cur;
+    flecs_query_get_column_for_field(
+        &impl->pub, match, field - 1, &cur);
+    ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL);
 
-static
-int32_t t_next(
-    int32_t t)
-{
-    return (t + 1) % ECS_STAT_WINDOW;
+    return monitor[field] != flecs_table_get_dirty_state(
+        cache->query->world, cur.table)[cur.column + 1];
 }
 
 static
-int32_t t_prev(
-    int32_t t)
+bool flecs_query_check_cache_monitor(
+    ecs_query_impl_t *impl)
 {
-    return (t - 1 + ECS_STAT_WINDOW) % ECS_STAT_WINDOW;
-}
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
 
-static
-void flecs_gauge_record(
-    ecs_metric_t *m,
-    int32_t t,
-    ecs_float_t value)
-{
-    m->gauge.avg[t] = value;
-    m->gauge.min[t] = value;
-    m->gauge.max[t] = value;
-}
+    /* If the match count changed, tables got matched/unmatched for the
+     * cache, so return that the query has changed. */
+    if (cache->match_count != cache->prev_match_count) {
+        return true;
+    }
 
-static
-double flecs_counter_record(
-    ecs_metric_t *m,
-    int32_t t,
-    double value)
-{
-    int32_t tp = t_prev(t);
-    double prev = m->counter.value[tp];
-    m->counter.value[t] = value;
-    double gauge_value = value - prev;
-    if (gauge_value < 0) {
-        gauge_value = 0; /* Counters are monotonically increasing */
+    ecs_table_cache_iter_t it;
+    if (flecs_table_cache_iter(&cache->cache, &it)) {
+        ecs_query_cache_table_t *qt;
+        while ((qt = flecs_table_cache_next(&it, ecs_query_cache_table_t))) {
+            if (flecs_query_check_table_monitor(impl, qt, -1)) {
+                return true;
+            }
+        }
     }
-    flecs_gauge_record(m, t, (ecs_float_t)gauge_value);
-    return gauge_value;
-}
 
-static
-void flecs_metric_print(
-    const char *name,
-    ecs_float_t value)
-{
-    ecs_size_t len = ecs_os_strlen(name);
-    ecs_trace("%s: %*s %.2f", name, 32 - len, "", (double)value);
+    return false;
 }
 
 static
-void flecs_gauge_print(
-    const char *name,
-    int32_t t,
-    const ecs_metric_t *m)
+void flecs_query_init_query_monitors(
+    ecs_query_impl_t *impl)
 {
-    flecs_metric_print(name, m->gauge.avg[t]);
+    /* Change monitor for cache */
+    ecs_query_cache_t *cache = impl->cache;
+    if (cache) {
+        ecs_query_cache_table_match_t *cur = cache->list.first;
+
+        /* Ensure each match has a monitor */
+        for (; cur != NULL; cur = cur->next) {
+            ecs_query_cache_table_match_t *match = 
+                (ecs_query_cache_table_match_t*)cur;
+            flecs_query_get_match_monitor(impl, match);
+        }
+    }
 }
 
 static
-void flecs_counter_print(
-    const char *name,
-    int32_t t,
-    const ecs_metric_t *m)
+bool flecs_query_check_match_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match,
+    const ecs_iter_t *it)
 {
-    flecs_metric_print(name, m->counter.rate.avg[t]);
-}
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
 
-void ecs_metric_reduce(
-    ecs_metric_t *dst,
-    const ecs_metric_t *src,
-    int32_t t_dst,
-    int32_t t_src)
-{
-    ecs_check(dst != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(src != NULL, ECS_INVALID_PARAMETER, NULL);
+    if (flecs_query_get_match_monitor(impl, match)) {
+        return true;
+    }
 
-    bool min_set = false;
-    dst->gauge.avg[t_dst] = 0;
-    dst->gauge.min[t_dst] = 0;
-    dst->gauge.max[t_dst] = 0;
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    int32_t *monitor = match->monitor;
+    ecs_table_t *table = match->table;
+    int32_t *dirty_state = NULL;
+    if (table) {
+        dirty_state = flecs_table_get_dirty_state(
+            cache->query->world, table);
+        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (monitor[0] != dirty_state[0]) {
+            return true;
+        }
+    }
 
-    ecs_float_t fwindow = (ecs_float_t)ECS_STAT_WINDOW;
+    bool is_this = false;
+    const ecs_query_t *query = cache->query;
+    ecs_world_t *world = query->world;
+    int32_t i, j, field_count = query->field_count;
+    int32_t *storage_columns = match->storage_columns;
+    ecs_entity_t *sources = match->sources;
+    int32_t *columns = it ? it->columns : match->columns;
+    ecs_flags64_t set_fields = it ? it->set_fields : match->set_fields;
+    
+    ecs_assert(columns != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    int32_t i;
-    for (i = 0; i < ECS_STAT_WINDOW; i ++) {
-        int32_t t = (t_src + i) % ECS_STAT_WINDOW;
-        dst->gauge.avg[t_dst] += src->gauge.avg[t] / fwindow;
+    ecs_vec_t *refs = &match->refs;
+    for (i = 0; i < field_count; i ++) {
+        int32_t mon = monitor[i + 1];
+        if (mon == -1) {
+            continue;
+        }
 
-        if (!min_set || (src->gauge.min[t] < dst->gauge.min[t_dst])) {
-            dst->gauge.min[t_dst] = src->gauge.min[t];
-            min_set = true;
+        if (!(set_fields & (1llu << i))) {
+            continue;
         }
-        if ((src->gauge.max[t] > dst->gauge.max[t_dst])) {
-            dst->gauge.max[t_dst] = src->gauge.max[t];
+
+        int32_t column = storage_columns[i];
+        ecs_entity_t src = sources[i];
+        if (!src) {
+            if (column >= 0) {
+                /* owned component */
+                ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+                if (mon != dirty_state[column + 1]) {
+                    return true;
+                }
+                continue;
+            } else if (column == -1) {
+                continue; /* owned but not a component */
+            }
         }
-    }
 
-    dst->counter.value[t_dst] = src->counter.value[t_src];
+        column = columns[i];
+        ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
 
-error:
-    return;
+        /* Find term index from field index, which differ when using || */
+        int32_t term_index = i;
+        if (query->terms[i].field_index != i) {
+            for (j = i; j < query->term_count; j ++) {
+                if (query->terms[j].field_index == i) {
+                    term_index = j;
+                    break;
+                }
+            }
+        }
+
+        is_this = ecs_term_match_this(&query->terms[term_index]);
+
+        /* Flattened fields are encoded by adding field_count to the column
+         * index of the parent component. */
+        ecs_assert(column <= field_count, ECS_INTERNAL_ERROR, NULL);
+
+        if (is_this) {
+            /* Component reached through traversal from this */
+            int32_t ref_index = column;
+            ecs_ref_t *ref = ecs_vec_get_t(refs, ecs_ref_t, ref_index);
+            if (ref->id != 0) {
+                ecs_ref_update(world, ref);
+                ecs_table_record_t *tr = ref->tr;
+                ecs_table_t *src_table = tr->hdr.table;
+                column = tr->index;
+                column = ecs_table_type_to_column_index(src_table, column);
+                int32_t *src_dirty_state = flecs_table_get_dirty_state(
+                    world, src_table);
+                if (mon != src_dirty_state[column + 1]) {
+                    return true;
+                }
+            }
+        } else {
+            /* Component from static source */
+            ecs_entity_t fixed_src = match->sources[i];
+            ecs_table_t *src_table = ecs_get_table(world, fixed_src);
+            ecs_assert(src_table != NULL, ECS_INTERNAL_ERROR, NULL);
+            column = ecs_table_type_to_column_index(src_table, column);
+            int32_t *src_dirty_state = flecs_table_get_dirty_state(
+                world, src_table);
+            if (mon != src_dirty_state[column + 1]) {
+                return true;
+            }
+        }
+    }
+
+    return false;
 }
 
-void ecs_metric_reduce_last(
-    ecs_metric_t *m,
-    int32_t prev,
-    int32_t count)
+/* Check if any term for matched table has changed */
+bool flecs_query_check_table_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_t *table,
+    int32_t field)
 {
-    ecs_check(m != NULL, ECS_INVALID_PARAMETER, NULL);
-    int32_t t = t_next(prev);
+    ecs_query_cache_table_match_t *cur, *end = table->last->next;
 
-    if (m->gauge.min[t] < m->gauge.min[prev]) {
-        m->gauge.min[prev] = m->gauge.min[t];
+    for (cur = table->first; cur != end; cur = cur->next) {
+        ecs_query_cache_table_match_t *match = 
+            (ecs_query_cache_table_match_t*)cur;
+        if (field == -1) {
+            if (flecs_query_check_match_monitor(impl, match, NULL)) {
+                return true;
+            }
+        } else {
+            if (flecs_query_check_match_monitor_term(impl, match, field)) {
+                return true;
+            } 
+        }
     }
 
-    if (m->gauge.max[t] > m->gauge.max[prev]) {
-        m->gauge.max[prev] = m->gauge.max[t];
+    return false;
+}
+
+void flecs_query_mark_fields_dirty(
+    ecs_query_impl_t *impl,
+    ecs_iter_t *it)
+{
+    ecs_query_t *q = &impl->pub;
+
+    /* Evaluate all writeable non-fixed fields, settable fields */
+    ecs_termset_t write_fields = 
+        (ecs_termset_t)(q->write_fields & ~q->fixed_fields & q->set_fields);
+    if (!write_fields) {
+        return;
     }
 
-    ecs_float_t fcount = (ecs_float_t)(count + 1);
-    ecs_float_t cur = m->gauge.avg[prev];
-    ecs_float_t next = m->gauge.avg[t];
+    ecs_world_t *world = q->world;
+    int32_t i, field_count = q->field_count;
+    for (i = 0; i < field_count; i ++) {
+        if (!(write_fields & (1 << i))) {
+            continue; /* If term doesn't write data there's nothing to track */
+        }
 
-    cur *= ((fcount - 1) / fcount);
-    next *= 1 / fcount;
+        ecs_entity_t src = it->sources[i];
+        ecs_table_t *table;
+        if (!src) {
+            table = it->table;
+        } else {
+            ecs_record_t *r = flecs_entities_get(world, src);
+            if (!r || !(table = r->table)) {
+                continue;
+            }
 
-    m->gauge.avg[prev] = cur + next;
-    m->counter.value[prev] = m->counter.value[t];
+            if (q->shared_readonly_fields & (1 << i)) {
+                /* Shared fields that aren't marked explicitly as out/inout 
+                 * default to readonly */
+                continue;
+            }
+        }
 
-error:
-    return;
+        int32_t type_index = it->columns[i];
+        ecs_assert(type_index >= 0, ECS_INTERNAL_ERROR, NULL);
+        
+        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+        int32_t *dirty_state = table->dirty_state;
+        if (!dirty_state) {
+            continue;
+        }
+
+        int32_t column = table->column_map[type_index];
+        dirty_state[column + 1] ++;
+    }
 }
 
-void ecs_metric_copy(
-    ecs_metric_t *m,
-    int32_t dst,
-    int32_t src)
+void flecs_query_mark_fixed_fields_dirty(
+    ecs_query_impl_t *impl,
+    ecs_iter_t *it)
 {
-    ecs_check(m != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(dst != src, ECS_INVALID_PARAMETER, NULL);
+    /* This function marks fields dirty for terms with fixed sources. */
+    ecs_query_t *q = &impl->pub;
+    ecs_termset_t fixed_write_fields = q->write_fields & q->fixed_fields;
+    if (!fixed_write_fields) {
+        return;
+    }
 
-    m->gauge.avg[dst] = m->gauge.avg[src];
-    m->gauge.min[dst] = m->gauge.min[src];
-    m->gauge.max[dst] = m->gauge.max[src];
-    m->counter.value[dst] = m->counter.value[src];
+    ecs_world_t *world = q->world;
+    int32_t i, field_count = q->field_count;
+    for (i = 0; i < field_count; i ++) {
+        if (!(fixed_write_fields & (1 << i))) {
+            continue; /* If term doesn't write data there's nothing to track */
+        }
 
-error:
-    return;
-}
+        ecs_entity_t src = it->sources[i];
+        ecs_assert(src != 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_record_t *r = flecs_entities_get(world, src);
+        ecs_table_t *table;
+        if (!r || !(table = r->table)) {
+            /* If the field is optional, it's possible that it didn't match */
+            continue;
+        }
 
-static
-void flecs_stats_reduce(
-    ecs_metric_t *dst_cur,
-    ecs_metric_t *dst_last,
-    ecs_metric_t *src_cur,
-    int32_t t_dst,
-    int32_t t_src)
-{
-    for (; dst_cur <= dst_last; dst_cur ++, src_cur ++) {
-        ecs_metric_reduce(dst_cur, src_cur, t_dst, t_src);
+        int32_t *dirty_state = table->dirty_state;
+        if (!dirty_state) {
+            continue;
+        }
+
+        ecs_assert(it->columns[i] >= 0, ECS_INTERNAL_ERROR, NULL);
+        int32_t column = table->column_map[it->columns[i]];
+        dirty_state[column + 1] ++;
     }
 }
 
-static
-void flecs_stats_reduce_last(
-    ecs_metric_t *dst_cur,
-    ecs_metric_t *dst_last,
-    ecs_metric_t *src_cur,
-    int32_t t_dst,
-    int32_t t_src,
-    int32_t count)
+/* Synchronize match monitor with table dirty state */
+void flecs_query_sync_match_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match)
 {
-    int32_t t_dst_next = t_next(t_dst);
-    for (; dst_cur <= dst_last; dst_cur ++, src_cur ++) {
-        /* Reduce into previous value */
-        ecs_metric_reduce_last(dst_cur, t_dst, count);
-
-        /* Restore old value */
-        dst_cur->gauge.avg[t_dst_next] = src_cur->gauge.avg[t_src];
-        dst_cur->gauge.min[t_dst_next] = src_cur->gauge.min[t_src];
-        dst_cur->gauge.max[t_dst_next] = src_cur->gauge.max[t_src];
-        dst_cur->counter.value[t_dst_next] = src_cur->counter.value[t_src];
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (!match->monitor) {
+        if (impl->pub.flags & EcsQueryHasMonitor) {
+            flecs_query_get_match_monitor(impl, match);
+        } else {
+            return;
+        }
     }
-}
 
-static
-void flecs_stats_repeat_last(
-    ecs_metric_t *cur,
-    ecs_metric_t *last,
-    int32_t t)
-{
-    int32_t prev = t_prev(t);
-    for (; cur <= last; cur ++) {
-        ecs_metric_copy(cur, t, prev);
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    int32_t *monitor = match->monitor;
+    ecs_table_t *table = match->table;
+    if (table) {
+        int32_t *dirty_state = flecs_table_get_dirty_state(
+            cache->query->world, table);
+        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+        monitor[0] = dirty_state[0]; /* Did table gain/lose entities */
     }
-}
 
-static
-void flecs_stats_copy_last(
-    ecs_metric_t *dst_cur,
-    ecs_metric_t *dst_last,
-    ecs_metric_t *src_cur,
-    int32_t t_dst,
-    int32_t t_src)
-{
-    for (; dst_cur <= dst_last; dst_cur ++, src_cur ++) {
-        dst_cur->gauge.avg[t_dst] = src_cur->gauge.avg[t_src];
-        dst_cur->gauge.min[t_dst] = src_cur->gauge.min[t_src];
-        dst_cur->gauge.max[t_dst] = src_cur->gauge.max[t_src];
-        dst_cur->counter.value[t_dst] = src_cur->counter.value[t_src];
+    ecs_query_t *q = cache->query;
+    {
+        flecs_table_column_t tc;
+        int32_t t, term_count = q->term_count;
+        for (t = 0; t < term_count; t ++) {
+            int32_t field = q->terms[t].field_index;
+            if (monitor[field + 1] == -1) {
+                continue;
+            }
+
+            flecs_query_get_column_for_field(q, match, field, &tc);
+
+            monitor[field + 1] = flecs_table_get_dirty_state(
+                q->world, tc.table)[tc.column + 1];
+        }
     }
+
+    cache->prev_match_count = cache->match_count;
 }
 
-void ecs_world_stats_get(
-    const ecs_world_t *world,
-    ecs_world_stats_t *s)
+bool ecs_query_changed(
+    ecs_query_t *q)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    world = ecs_get_world(world);
-
-    int32_t t = s->t = t_next(s->t);
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_impl_t *impl = flecs_query_impl(q);
 
-    double delta_frame_count = 
-    ECS_COUNTER_RECORD(&s->frame.frame_count, t, world->info.frame_count_total);
-    ECS_COUNTER_RECORD(&s->frame.merge_count, t, world->info.merge_count_total);
-    ECS_COUNTER_RECORD(&s->frame.rematch_count, t, world->info.rematch_count_total);
-    ECS_COUNTER_RECORD(&s->frame.pipeline_build_count, t, world->info.pipeline_build_count_total);
-    ECS_COUNTER_RECORD(&s->frame.systems_ran, t, world->info.systems_ran_frame);
-    ECS_COUNTER_RECORD(&s->frame.observers_ran, t, world->info.observers_ran_frame);
-    ECS_COUNTER_RECORD(&s->frame.event_emit_count, t, world->event_id);
+    ecs_assert(q->cache_kind != EcsQueryCacheNone, ECS_INVALID_OPERATION, 
+        "change detection is only supported on cached queries");
 
-    double delta_world_time = 
-    ECS_COUNTER_RECORD(&s->performance.world_time_raw, t, world->info.world_time_total_raw);
-    ECS_COUNTER_RECORD(&s->performance.world_time, t, world->info.world_time_total);
-    ECS_COUNTER_RECORD(&s->performance.frame_time, t, world->info.frame_time_total);
-    ECS_COUNTER_RECORD(&s->performance.system_time, t, world->info.system_time_total);
-    ECS_COUNTER_RECORD(&s->performance.emit_time, t, world->info.emit_time_total);
-    ECS_COUNTER_RECORD(&s->performance.merge_time, t, world->info.merge_time_total);
-    ECS_COUNTER_RECORD(&s->performance.rematch_time, t, world->info.rematch_time_total);
-    ECS_GAUGE_RECORD(&s->performance.delta_time, t, delta_world_time);
-    if (ECS_NEQZERO(delta_world_time) && ECS_NEQZERO(delta_frame_count)) {
-        ECS_GAUGE_RECORD(&s->performance.fps, t, (double)1 / (delta_world_time / (double)delta_frame_count));
-    } else {
-        ECS_GAUGE_RECORD(&s->performance.fps, t, 0);
+    /* If query reads terms with fixed sources, check those first as that's 
+     * cheaper than checking entries in the cache. */
+    if (impl->monitor) {
+        if (flecs_query_check_fixed_monitor(impl)) {
+            return true;
+        }
     }
 
-    ECS_GAUGE_RECORD(&s->entities.count, t, flecs_entities_count(world));
-    ECS_GAUGE_RECORD(&s->entities.not_alive_count, t, flecs_entities_not_alive_count(world));
+    /* Check cache for changes. We can't detect changes for terms that are not
+     * cached/cacheable and don't have a fixed source, since that requires 
+     * storing state per result, which doesn't happen for uncached queries. */
+    if (impl->cache) {
+        /* If we're checking the cache, make sure that tables are in the correct
+         * empty/non-empty lists. */
+        flecs_process_pending_tables(q->world);
 
-    ECS_GAUGE_RECORD(&s->components.tag_count, t, world->info.tag_id_count);
-    ECS_GAUGE_RECORD(&s->components.component_count, t, world->info.component_id_count);
-    ECS_GAUGE_RECORD(&s->components.pair_count, t, world->info.pair_id_count);
-    ECS_GAUGE_RECORD(&s->components.type_count, t, ecs_sparse_count(&world->type_info));
-    ECS_COUNTER_RECORD(&s->components.create_count, t, world->info.id_create_total);
-    ECS_COUNTER_RECORD(&s->components.delete_count, t, world->info.id_delete_total);
+        if (!(impl->pub.flags & EcsQueryHasMonitor)) {
+            flecs_query_init_query_monitors(impl);
+        }
 
-    ECS_GAUGE_RECORD(&s->queries.query_count, t, ecs_count_id(world, EcsQuery));
-    ECS_GAUGE_RECORD(&s->queries.observer_count, t, ecs_count_id(world, EcsObserver));
-    if (ecs_is_alive(world, EcsSystem)) {
-        ECS_GAUGE_RECORD(&s->queries.system_count, t, ecs_count_id(world, EcsSystem));
+        /* Check cache entries for changes */
+        return flecs_query_check_cache_monitor(impl);
     }
-    ECS_COUNTER_RECORD(&s->tables.create_count, t, world->info.table_create_total);
-    ECS_COUNTER_RECORD(&s->tables.delete_count, t, world->info.table_delete_total);
-    ECS_GAUGE_RECORD(&s->tables.count, t, world->info.table_count);
-    ECS_GAUGE_RECORD(&s->tables.empty_count, t, world->info.empty_table_count);
-
-    ECS_COUNTER_RECORD(&s->commands.add_count, t, world->info.cmd.add_count);
-    ECS_COUNTER_RECORD(&s->commands.remove_count, t, world->info.cmd.remove_count);
-    ECS_COUNTER_RECORD(&s->commands.delete_count, t, world->info.cmd.delete_count);
-    ECS_COUNTER_RECORD(&s->commands.clear_count, t, world->info.cmd.clear_count);
-    ECS_COUNTER_RECORD(&s->commands.set_count, t, world->info.cmd.set_count);
-    ECS_COUNTER_RECORD(&s->commands.ensure_count, t, world->info.cmd.ensure_count);
-    ECS_COUNTER_RECORD(&s->commands.modified_count, t, world->info.cmd.modified_count);
-    ECS_COUNTER_RECORD(&s->commands.other_count, t, world->info.cmd.other_count);
-    ECS_COUNTER_RECORD(&s->commands.discard_count, t, world->info.cmd.discard_count);
-    ECS_COUNTER_RECORD(&s->commands.batched_entity_count, t, world->info.cmd.batched_entity_count);
-    ECS_COUNTER_RECORD(&s->commands.batched_count, t, world->info.cmd.batched_command_count);
-
-    int64_t outstanding_allocs = ecs_os_api_malloc_count + 
-        ecs_os_api_calloc_count - ecs_os_api_free_count;
-    ECS_COUNTER_RECORD(&s->memory.alloc_count, t, ecs_os_api_malloc_count + ecs_os_api_calloc_count);
-    ECS_COUNTER_RECORD(&s->memory.realloc_count, t, ecs_os_api_realloc_count);
-    ECS_COUNTER_RECORD(&s->memory.free_count, t, ecs_os_api_free_count);
-    ECS_GAUGE_RECORD(&s->memory.outstanding_alloc_count, t, outstanding_allocs);
-
-    outstanding_allocs = ecs_block_allocator_alloc_count - ecs_block_allocator_free_count;
-    ECS_COUNTER_RECORD(&s->memory.block_alloc_count, t, ecs_block_allocator_alloc_count);
-    ECS_COUNTER_RECORD(&s->memory.block_free_count, t, ecs_block_allocator_free_count);
-    ECS_GAUGE_RECORD(&s->memory.block_outstanding_alloc_count, t, outstanding_allocs);
-
-    outstanding_allocs = ecs_stack_allocator_alloc_count - ecs_stack_allocator_free_count;
-    ECS_COUNTER_RECORD(&s->memory.stack_alloc_count, t, ecs_stack_allocator_alloc_count);
-    ECS_COUNTER_RECORD(&s->memory.stack_free_count, t, ecs_stack_allocator_free_count);
-    ECS_GAUGE_RECORD(&s->memory.stack_outstanding_alloc_count, t, outstanding_allocs);
-
-#ifdef FLECS_HTTP
-    ECS_COUNTER_RECORD(&s->http.request_received_count, t, ecs_http_request_received_count);
-    ECS_COUNTER_RECORD(&s->http.request_invalid_count, t, ecs_http_request_invalid_count);
-    ECS_COUNTER_RECORD(&s->http.request_handled_ok_count, t, ecs_http_request_handled_ok_count);
-    ECS_COUNTER_RECORD(&s->http.request_handled_error_count, t, ecs_http_request_handled_error_count);
-    ECS_COUNTER_RECORD(&s->http.request_not_handled_count, t, ecs_http_request_not_handled_count);
-    ECS_COUNTER_RECORD(&s->http.request_preflight_count, t, ecs_http_request_preflight_count);
-    ECS_COUNTER_RECORD(&s->http.send_ok_count, t, ecs_http_send_ok_count);
-    ECS_COUNTER_RECORD(&s->http.send_error_count, t, ecs_http_send_error_count);
-    ECS_COUNTER_RECORD(&s->http.busy_count, t, ecs_http_busy_count);
-#endif
-
-error:
-    return;
-}
-
-void ecs_world_stats_reduce(
-    ecs_world_stats_t *dst,
-    const ecs_world_stats_t *src)
-{
-    flecs_stats_reduce(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
-        ECS_METRIC_FIRST(src), (dst->t = t_next(dst->t)), src->t);
-}
 
-void ecs_world_stats_reduce_last(
-    ecs_world_stats_t *dst,
-    const ecs_world_stats_t *src,
-    int32_t count)
-{
-    flecs_stats_reduce_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
-        ECS_METRIC_FIRST(src), (dst->t = t_prev(dst->t)), src->t, count);
+    return false;
 }
 
-void ecs_world_stats_repeat_last(
-    ecs_world_stats_t *stats)
+bool ecs_iter_changed(
+    ecs_iter_t *it)
 {
-    flecs_stats_repeat_last(ECS_METRIC_FIRST(stats), ECS_METRIC_LAST(stats),
-        (stats->t = t_next(stats->t)));
-}
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_query_next, ECS_UNSUPPORTED, NULL);
+    ecs_check(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
+        ECS_INVALID_PARAMETER, NULL);
 
-void ecs_world_stats_copy_last(
-    ecs_world_stats_t *dst,
-    const ecs_world_stats_t *src)
-{
-    flecs_stats_copy_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst),
-        ECS_METRIC_FIRST(src), dst->t, t_next(src->t));
-}
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_impl_t *impl = flecs_query_impl(qit->query);
+    ecs_query_t *q = &impl->pub;
 
-void ecs_query_stats_get(
-    const ecs_world_t *world,
-    const ecs_query_t *query,
-    ecs_query_stats_t *s)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
-    (void)world;
+    /* First check for changes for terms with fixed sources, if query has any */
+    if (q->read_fields & q->fixed_fields) {
+        /* Detecting changes for uncached terms is costly, so only do it once 
+         * per iteration. */
+        if (!(it->flags & EcsIterFixedInChangeComputed)) {
+            it->flags |= EcsIterFixedInChangeComputed;
+            ECS_BIT_COND(it->flags, EcsIterFixedInChanged, 
+                flecs_query_check_fixed_monitor(impl));
+        }
 
-    int32_t t = s->t = t_next(s->t);
+        if (it->flags & EcsIterFixedInChanged) {
+            return true;
+        }
+    }
 
-    if (query->filter.flags & EcsFilterMatchThis) {
-        ECS_GAUGE_RECORD(&s->matched_entity_count, t, 
-            ecs_query_entity_count(query));
-        ECS_GAUGE_RECORD(&s->matched_table_count, t, 
-            ecs_query_table_count(query));
-        ECS_GAUGE_RECORD(&s->matched_empty_table_count, t, 
-            ecs_query_empty_table_count(query));
-    } else {
-        ECS_GAUGE_RECORD(&s->matched_entity_count, t, 0);
-        ECS_GAUGE_RECORD(&s->matched_table_count, t, 0);
-        ECS_GAUGE_RECORD(&s->matched_empty_table_count, t, 0);
+    /* If query has a cache, check for changes in current matched result */
+    if (impl->cache) {
+        ecs_query_cache_table_match_t *qm = 
+            (ecs_query_cache_table_match_t*)it->priv_.iter.query.prev;
+        ecs_check(qm != NULL, ECS_INVALID_PARAMETER, NULL);
+        return flecs_query_check_match_monitor(impl, qm, it);
     }
-    
-    const ecs_filter_t *f = ecs_query_get_filter(query);
-    ECS_COUNTER_RECORD(&s->eval_count, t, f->eval_count);
 
 error:
-    return;
+    return false;
 }
 
-void ecs_query_stats_reduce(
-    ecs_query_stats_t *dst,
-    const ecs_query_stats_t *src)
+void ecs_iter_skip(
+    ecs_iter_t *it)
 {
-    flecs_stats_reduce(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
-        ECS_METRIC_FIRST(src), (dst->t = t_next(dst->t)), src->t);
-}
+    ecs_assert(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
+        ECS_INVALID_PARAMETER, NULL);
 
-void ecs_query_stats_reduce_last(
-    ecs_query_stats_t *dst,
-    const ecs_query_stats_t *src,
-    int32_t count)
-{
-    flecs_stats_reduce_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
-        ECS_METRIC_FIRST(src), (dst->t = t_prev(dst->t)), src->t, count);
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    if (it->instance_count > it->count) {
+        qit->skip_count ++;
+        if (qit->skip_count == it->instance_count) {
+            /* For non-instanced queries, make sure all entities are skipped */
+            it->flags |= EcsIterSkip;
+        }
+    } else {
+        it->flags |= EcsIterSkip;
+    }
 }
 
-void ecs_query_stats_repeat_last(
-    ecs_query_stats_t *stats)
+/**
+ * @file addons/querys/compile.c
+ * @brief Compile query program from query.
+ */
+
+
+static
+bool flecs_query_var_is_anonymous(
+    const ecs_query_impl_t *query,
+    ecs_var_id_t var_id)
 {
-    flecs_stats_repeat_last(ECS_METRIC_FIRST(stats), ECS_METRIC_LAST(stats),
-        (stats->t = t_next(stats->t)));
+    ecs_query_var_t *var = &query->vars[var_id];
+    return var->anonymous;
 }
 
-void ecs_query_stats_copy_last(
-    ecs_query_stats_t *dst,
-    const ecs_query_stats_t *src)
+ecs_var_id_t flecs_query_add_var(
+    ecs_query_impl_t *query,
+    const char *name,
+    ecs_vec_t *vars,
+    ecs_var_kind_t kind)
 {
-    flecs_stats_copy_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst),
-        ECS_METRIC_FIRST(src), dst->t, t_next(src->t));
-}
+    const char *dot = NULL;
+    if (name) {
+        dot = strchr(name, '.');
+        if (dot) {
+            kind = EcsVarEntity; /* lookup variables are always entities */
+        }
+    }
 
-#ifdef FLECS_SYSTEM
+    ecs_hashmap_t *var_index = NULL;
+    ecs_var_id_t var_id = EcsVarNone;
+    if (name) {
+        if (kind == EcsVarAny) {
+            var_id = flecs_query_find_var_id(query, name, EcsVarEntity);
+            if (var_id != EcsVarNone) {
+                return var_id;
+            }
 
-bool ecs_system_stats_get(
-    const ecs_world_t *world,
-    ecs_entity_t system,
-    ecs_system_stats_t *s)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL);
+            var_id = flecs_query_find_var_id(query, name, EcsVarTable);
+            if (var_id != EcsVarNone) {
+                return var_id;
+            }
 
-    world = ecs_get_world(world);
+            kind = EcsVarTable;
+        } else {
+            var_id = flecs_query_find_var_id(query, name, kind);
+            if (var_id != EcsVarNone) {
+                return var_id;
+            }
+        }
 
-    const ecs_system_t *ptr = ecs_poly_get(world, system, ecs_system_t);
-    if (!ptr) {
-        return false;
+        if (kind == EcsVarTable) {
+            var_index = &query->tvar_index;
+        } else {
+            var_index = &query->evar_index;
+        }
+
+        /* If we're creating an entity var, check if it has a table variant */
+        if (kind == EcsVarEntity && var_id == EcsVarNone) {
+            var_id = flecs_query_find_var_id(query, name, EcsVarTable);
+        }
     }
 
-    ecs_query_stats_get(world, ptr->query, &s->query);
-    int32_t t = s->query.t;
+    ecs_query_var_t *var;
+    ecs_var_id_t result;
+    if (vars) {
+        var = ecs_vec_append_t(NULL, vars, ecs_query_var_t);
+        result = var->id = flecs_itovar(ecs_vec_count(vars));
+    } else {
+        ecs_dbg_assert(query->var_count < query->var_size, 
+            ECS_INTERNAL_ERROR, NULL);
+        var = &query->vars[query->var_count];
+        result = var->id = flecs_itovar(query->var_count);
+        query->var_count ++;
+    }
 
-    ECS_COUNTER_RECORD(&s->time_spent, t, ptr->time_spent);
+    var->kind = flecs_ito(int8_t, kind);
+    var->name = name;
+    var->table_id = var_id;
+    var->base_id = 0;
+    var->lookup = NULL;
+    flecs_set_var_label(var, NULL);
 
-    s->task = !(ptr->query->filter.flags & EcsFilterMatchThis);
+    if (name) {
+        flecs_name_index_init_if(var_index, NULL);
+        flecs_name_index_ensure(var_index, var->id, name, 0, 0);
+        var->anonymous = name[0] == '_';
 
-    return true;
-error:
-    return false;
-}
+        /* Handle variables that require a by-name lookup, e.g. $this.wheel */
+        if (dot != NULL) {
+            ecs_assert(var->table_id == EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+            var->lookup = dot + 1;
+        }
+    }
 
-void ecs_system_stats_reduce(
-    ecs_system_stats_t *dst,
-    const ecs_system_stats_t *src)
-{
-    ecs_query_stats_reduce(&dst->query, &src->query);
-    dst->task = src->task;
-    flecs_stats_reduce(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
-        ECS_METRIC_FIRST(src), dst->query.t, src->query.t);
+    return result;
 }
 
-void ecs_system_stats_reduce_last(
-    ecs_system_stats_t *dst,
-    const ecs_system_stats_t *src,
-    int32_t count)
+static
+ecs_var_id_t flecs_query_add_var_for_term_id(
+    ecs_query_impl_t *query,
+    ecs_term_ref_t *term_id,
+    ecs_vec_t *vars,
+    ecs_var_kind_t kind)
 {
-    ecs_query_stats_reduce_last(&dst->query, &src->query, count);
-    dst->task = src->task;
-    flecs_stats_reduce_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
-        ECS_METRIC_FIRST(src), dst->query.t, src->query.t, count);
-}
+    const char *name = flecs_term_ref_var_name(term_id);
+    if (!name) {
+        return EcsVarNone;
+    }
 
-void ecs_system_stats_repeat_last(
-    ecs_system_stats_t *stats)
-{
-    ecs_query_stats_repeat_last(&stats->query);
-    flecs_stats_repeat_last(ECS_METRIC_FIRST(stats), ECS_METRIC_LAST(stats),
-        (stats->query.t));
+    return flecs_query_add_var(query, name, vars, kind);
 }
 
-void ecs_system_stats_copy_last(
-    ecs_system_stats_t *dst,
-    const ecs_system_stats_t *src)
+/* This function walks over terms to discover which variables are used in the
+ * query. It needs to provide the following functionality:
+ * - create table vars for all variables used as source
+ * - create entity vars for all variables not used as source
+ * - create entity vars for all non-$this vars
+ * - create anonymous vars to store the content of wildcards
+ * - create anonymous vars to store result of lookups (for $var.child_name)
+ * - create anonymous vars for resolving component inheritance
+ * - create array that stores the source variable for each field
+ * - ensure table vars for non-$this variables are anonymous
+ * - ensure variables created inside scopes are anonymous
+ * - place anonymous variables after public variables in vars array
+ */
+static
+int flecs_query_discover_vars(
+    ecs_stage_t *stage,
+    ecs_query_impl_t *query)
 {
-    ecs_query_stats_copy_last(&dst->query, &src->query);
-    dst->task = src->task;
-    flecs_stats_copy_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst),
-        ECS_METRIC_FIRST(src), dst->query.t, t_next(src->query.t));
-}
-
-#endif
-
-#ifdef FLECS_PIPELINE
+    ecs_vec_t *vars = &stage->variables; /* Buffer to reduce allocs */
+    ecs_vec_reset_t(NULL, vars, ecs_query_var_t);
 
-bool ecs_pipeline_stats_get(
-    ecs_world_t *stage,
-    ecs_entity_t pipeline,
-    ecs_pipeline_stats_t *s)
-{
-    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(pipeline != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_term_t *terms = query->pub.terms;
+    int32_t a, i, anonymous_count = 0, count = query->pub.term_count;
+    int32_t anonymous_table_count = 0, scope = 0, scoped_var_index = 0;
+    bool table_this = false, entity_before_table_this = false;
 
-    const ecs_world_t *world = ecs_get_world(stage);
-    const EcsPipeline *pqc = ecs_get(world, pipeline, EcsPipeline);
-    if (!pqc) {
-        return false;
-    }
-    ecs_pipeline_state_t *pq = pqc->state;
-    ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL);
+    /* For This table lookups during discovery. This will be overwritten after
+     * discovery with whether the query actually has a This table variable. */
+    query->has_table_this = true;
 
-    int32_t sys_count = 0, active_sys_count = 0;
+    for (i = 0; i < count; i ++) {
+        ecs_term_t *term = &terms[i];
+        ecs_term_ref_t *first = &term->first;
+        ecs_term_ref_t *second = &term->second;
+        ecs_term_ref_t *src = &term->src;
 
-    /* Count number of active systems */
-    ecs_iter_t it = ecs_query_iter(stage, pq->query);
-    while (ecs_query_next(&it)) {
-        if (flecs_id_record_get_table(pq->idr_inactive, it.table) != NULL) {
+        if (ECS_TERM_REF_ID(first) == EcsScopeOpen) {
+            /* Keep track of which variables are first used in scope, so that we
+             * can mark them as anonymous. Terms inside a scope are collapsed 
+             * into a single result, which means that outside of the scope the
+             * value of those variables is undefined. */
+            if (!scope) {
+                scoped_var_index = ecs_vec_count(vars);
+            }
+            scope ++;
+            continue;
+        } else if (ECS_TERM_REF_ID(first) == EcsScopeClose) {
+            if (!--scope) {
+                /* Any new variables declared after entering a scope should be
+                 * marked as anonymous. */
+                int32_t v;
+                for (v = scoped_var_index; v < ecs_vec_count(vars); v ++) {
+                    ecs_vec_get_t(vars, ecs_query_var_t, v)->anonymous = true;
+                }
+            }
             continue;
         }
-        active_sys_count += it.count;
-    }
-
-    /* Count total number of systems in pipeline */
-    it = ecs_query_iter(stage, pq->query);
-    while (ecs_query_next(&it)) {
-        sys_count += it.count;
-    }   
 
-    /* Also count synchronization points */
-    ecs_vec_t *ops = &pq->ops;
-    ecs_pipeline_op_t *op = ecs_vec_first_t(ops, ecs_pipeline_op_t);
-    ecs_pipeline_op_t *op_last = ecs_vec_last_t(ops, ecs_pipeline_op_t);
-    int32_t pip_count = active_sys_count + ecs_vec_count(ops);
+        ecs_var_id_t first_var_id = flecs_query_add_var_for_term_id(
+            query, first, vars, EcsVarEntity);
+        if (first_var_id == EcsVarNone) {
+            /* If first is not a variable, check if we need to insert anonymous
+             * variable for resolving component inheritance */
+            if (term->flags_ & EcsTermIdInherited) {
+                anonymous_count += 2; /* table & entity variable */
+            }
 
-    if (!sys_count) {
-        return false;
-    }
+            /* If first is a wildcard, insert anonymous variable */
+            if (flecs_term_ref_is_wildcard(first)) {
+                anonymous_count ++;
+            }
+        }
 
-    if (ecs_map_is_init(&s->system_stats) && !sys_count) {
-        ecs_map_fini(&s->system_stats);
-    }
-    ecs_map_init_if(&s->system_stats, NULL);
+        if ((src->id & EcsIsVariable) && (ECS_TERM_REF_ID(src) != EcsThis)) {
+            const char *var_name = flecs_term_ref_var_name(src);
+            if (var_name) {
+                ecs_var_id_t var_id = flecs_query_find_var_id(
+                    query, var_name, EcsVarEntity);
+                if (var_id == EcsVarNone || var_id == first_var_id) {
+                    var_id = flecs_query_add_var(
+                        query, var_name, vars, EcsVarEntity);
+                }
 
-    if (op) {
-        ecs_entity_t *systems = NULL;
-        if (pip_count) {
-            ecs_vec_init_if_t(&s->systems, ecs_entity_t);
-            ecs_vec_set_count_t(NULL, &s->systems, ecs_entity_t, pip_count);
-            systems = ecs_vec_first_t(&s->systems, ecs_entity_t);
+                if (var_id != EcsVarNone) {
+                    /* Mark variable as one for which we need to create a table
+                     * variable. Don't create table variable now, so that we can
+                     * store it in the non-public part of the variable array. */
+                    ecs_query_var_t *var = ecs_vec_get_t(
+                        vars, ecs_query_var_t, (int32_t)var_id - 1);
+                    ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL);
+                    if (!var->lookup) {
+                        var->kind = EcsVarAny;
+                        anonymous_table_count ++;
+                    }
 
-            /* Populate systems vector, keep track of sync points */
-            it = ecs_query_iter(stage, pq->query);
-            
-            int32_t i, i_system = 0, ran_since_merge = 0;
-            while (ecs_query_next(&it)) {
-                if (flecs_id_record_get_table(pq->idr_inactive, it.table) != NULL) {
-                    continue;
-                }
+                    if (!(term->flags_ & EcsTermNoData)) {
+                        /* Can't have an anonymous variable as source of a term
+                         * that returns a component. We need to return each
+                         * instance of the component, whereas anonymous 
+                         * variables are not guaranteed to be resolved to 
+                         * individual entities. */
+                        if (var->anonymous) {
+                            ecs_err(
+                                "can't use anonymous variable '%s' as source of "
+                                "data term", var->name);
+                            goto error;
+                        }
+                    }
 
-                for (i = 0; i < it.count; i ++) {
-                    systems[i_system ++] = it.entities[i];
-                    ran_since_merge ++;
-                    if (op != op_last && ran_since_merge == op->count) {
-                        ran_since_merge = 0;
-                        op++;
-                        systems[i_system ++] = 0; /* 0 indicates a merge point */
+                    /* Track which variable ids are used as field source */
+                    if (!query->src_vars) {
+                        query->src_vars = flecs_calloc_n(&stage->allocator,
+                            ecs_var_id_t, query->pub.field_count);
                     }
+
+                    query->src_vars[term->field_index] = var_id;
                 }
+            } else {
+                if (flecs_term_ref_is_wildcard(src)) {
+                    anonymous_count ++;
+                }
+            }
+        } else if ((src->id & EcsIsVariable) && (ECS_TERM_REF_ID(src) == EcsThis)) {
+            if (flecs_term_is_builtin_pred(term) && term->oper == EcsOr) {
+                flecs_query_add_var(query, EcsThisName, vars, EcsVarEntity);
             }
+        }
 
-            systems[i_system ++] = 0; /* Last merge */
-            ecs_assert(pip_count == i_system, ECS_INTERNAL_ERROR, NULL);
-        } else {
-            ecs_vec_fini_t(NULL, &s->systems, ecs_entity_t);
+        if (flecs_query_add_var_for_term_id(
+            query, second, vars, EcsVarEntity) == EcsVarNone)
+        {
+            /* If second is a wildcard, insert anonymous variable */
+            if (flecs_term_ref_is_wildcard(second)) {
+                anonymous_count ++;
+            }
         }
 
-        /* Get sync point statistics */
-        int32_t i, count = ecs_vec_count(ops);
-        if (count) {
-            ecs_vec_init_if_t(&s->sync_points, ecs_sync_stats_t);
-            ecs_vec_set_min_count_zeromem_t(NULL, &s->sync_points, ecs_sync_stats_t, count);
-            op = ecs_vec_first_t(ops, ecs_pipeline_op_t);
+        if (src->id & EcsIsVariable && second->id & EcsIsVariable) {
+            if (term->flags_ & EcsTermTransitive) {
+                /* Anonymous variable to store temporary id for finding 
+                 * targets for transitive relationship, see compile_term. */
+                anonymous_count ++;
+            }
+        }
 
-            for (i = 0; i < count; i ++) {
-                ecs_pipeline_op_t *cur = &op[i];
-                ecs_sync_stats_t *el = ecs_vec_get_t(&s->sync_points, 
-                    ecs_sync_stats_t, i);
+        /* If member term, make sure source is available as entity */
+        if (term->flags_ & EcsTermIsMember) {
+            flecs_query_add_var_for_term_id(query, src, vars, EcsVarEntity);
+        }
 
-                ECS_COUNTER_RECORD(&el->time_spent, s->t, cur->time_spent);
-                ECS_COUNTER_RECORD(&el->commands_enqueued, s->t, 
-                    cur->commands_enqueued);
+        /* Track if a This entity variable is used before a potential This table 
+         * variable. If this happens, the query has no This table variable */
+        if (ECS_TERM_REF_ID(src) == EcsThis) {
+            table_this = true;
+        }
 
-                el->system_count = cur->count;
-                el->multi_threaded = cur->multi_threaded;
-                el->no_readonly = cur->no_readonly;
+        if (ECS_TERM_REF_ID(first) == EcsThis || ECS_TERM_REF_ID(second) == EcsThis) {
+            if (!table_this) {
+                entity_before_table_this = true;
             }
         }
     }
 
-    /* Separately populate system stats map from build query, which includes
-     * systems that aren't currently active */
-    it = ecs_query_iter(stage, pq->query);
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            ecs_system_stats_t *stats = ecs_map_ensure_alloc_t(&s->system_stats, 
-                ecs_system_stats_t, it.entities[i]);
-            stats->query.t = s->t;
-            ecs_system_stats_get(world, it.entities[i], stats);
+    int32_t var_count = ecs_vec_count(vars);
+    ecs_var_id_t placeholder = EcsVarNone - 1;
+    bool replace_placeholders = false;
+
+    /* Ensure lookup variables have table and/or entity variables */
+    for (i = 0; i < var_count; i ++) {
+        ecs_query_var_t *var = ecs_vec_get_t(vars, ecs_query_var_t, i);
+        if (var->lookup) {
+            char *var_name = ecs_os_strdup(var->name);
+            var_name[var->lookup - var->name - 1] = '\0';
+
+            ecs_var_id_t base_table_id = flecs_query_find_var_id(
+                query, var_name, EcsVarTable);
+            if (base_table_id != EcsVarNone) {
+                var->table_id = base_table_id;
+            } else if (anonymous_table_count) {
+                /* Scan for implicit anonymous table variables that haven't been
+                 * inserted yet (happens after this step). Doing this here vs.
+                 * ensures that anonymous variables are appended at the end of
+                 * the variable array, while also ensuring that variable ids are
+                 * stable (no swapping of table var ids that are in use). */
+                for (a = 0; a < var_count; a ++) {
+                    ecs_query_var_t *avar = ecs_vec_get_t(
+                        vars, ecs_query_var_t, a);
+                    if (avar->kind == EcsVarAny) {
+                        if (!ecs_os_strcmp(avar->name, var_name)) {
+                            base_table_id = (ecs_var_id_t)(a + 1);
+                            break;
+                        }
+                    }
+                }
+                if (base_table_id != EcsVarNone) {
+                    /* Set marker so we can set the new table id afterwards */
+                    var->table_id = placeholder;
+                    replace_placeholders = true;
+                }
+            }
+
+            ecs_var_id_t base_entity_id = flecs_query_find_var_id(
+                query, var_name, EcsVarEntity);
+            if (base_entity_id == EcsVarNone) {
+                /* Get name from table var (must exist). We can't use allocated
+                 * name since variables don't own names. */
+                const char *base_name = NULL;
+                if (base_table_id != EcsVarNone && base_table_id) {
+                    ecs_query_var_t *base_table_var = ecs_vec_get_t(
+                        vars, ecs_query_var_t, (int32_t)base_table_id - 1);
+                    base_name = base_table_var->name;
+                } else {
+                    base_name = EcsThisName;
+                }
+
+                base_entity_id = flecs_query_add_var(
+                    query, base_name, vars, EcsVarEntity);
+                var = ecs_vec_get_t(vars, ecs_query_var_t, i);
+            }
+
+            var->base_id = base_entity_id;
+
+            ecs_os_free(var_name);
         }
     }
+    var_count = ecs_vec_count(vars);
 
-    s->t = t_next(s->t);
+    /* Add non-This table variables */
+    if (anonymous_table_count) {
+        anonymous_table_count = 0;
+        for (i = 0; i < var_count; i ++) {
+            ecs_query_var_t *var = ecs_vec_get_t(vars, ecs_query_var_t, i);
+            if (var->kind == EcsVarAny) {
+                var->kind = EcsVarEntity;
 
-    return true;
-error:
-    return false;
-}
+                ecs_var_id_t var_id = flecs_query_add_var(
+                    query, var->name, vars, EcsVarTable);
+                ecs_vec_get_t(vars, ecs_query_var_t, i)->table_id = var_id;
+                anonymous_table_count ++;
+            }
+        }
 
-void ecs_pipeline_stats_fini(
-    ecs_pipeline_stats_t *stats)
-{
-    ecs_map_iter_t it = ecs_map_iter(&stats->system_stats);
-    while (ecs_map_next(&it)) {
-        ecs_system_stats_t *elem = ecs_map_ptr(&it);
-        ecs_os_free(elem);
+        var_count = ecs_vec_count(vars);
     }
-    ecs_map_fini(&stats->system_stats);
-    ecs_vec_fini_t(NULL, &stats->systems, ecs_entity_t);
-    ecs_vec_fini_t(NULL, &stats->sync_points, ecs_sync_stats_t);
-}
 
-void ecs_pipeline_stats_reduce(
-    ecs_pipeline_stats_t *dst,
-    const ecs_pipeline_stats_t *src)
-{
-    int32_t system_count = ecs_vec_count(&src->systems);
-    ecs_vec_init_if_t(&dst->systems, ecs_entity_t);
-    ecs_vec_set_count_t(NULL, &dst->systems, ecs_entity_t, system_count);
-    ecs_entity_t *dst_systems = ecs_vec_first_t(&dst->systems, ecs_entity_t);
-    ecs_entity_t *src_systems = ecs_vec_first_t(&src->systems, ecs_entity_t);
-    ecs_os_memcpy_n(dst_systems, src_systems, ecs_entity_t, system_count);
+    /* If any forward references to newly added anonymous tables exist, replace
+     * them with the actual table variable ids. */
+    if (replace_placeholders) {
+        for (i = 0; i < var_count; i ++) {
+            ecs_query_var_t *var = ecs_vec_get_t(vars, ecs_query_var_t, i);
+            if (var->table_id == placeholder) {
+                char *var_name = ecs_os_strdup(var->name);
+                var_name[var->lookup - var->name - 1] = '\0';
 
-    int32_t i, sync_count = ecs_vec_count(&src->sync_points);
-    ecs_vec_init_if_t(&dst->sync_points, ecs_sync_stats_t);
-    ecs_vec_set_min_count_zeromem_t(NULL, &dst->sync_points, ecs_sync_stats_t, sync_count);
-    ecs_sync_stats_t *dst_syncs = ecs_vec_first_t(&dst->sync_points, ecs_sync_stats_t);
-    ecs_sync_stats_t *src_syncs = ecs_vec_first_t(&src->sync_points, ecs_sync_stats_t);
-    for (i = 0; i < sync_count; i ++) {
-        ecs_sync_stats_t *dst_el = &dst_syncs[i];
-        ecs_sync_stats_t *src_el = &src_syncs[i];
-        flecs_stats_reduce(ECS_METRIC_FIRST(dst_el), ECS_METRIC_LAST(dst_el),
-            ECS_METRIC_FIRST(src_el), dst->t, src->t);
-        dst_el->system_count = src_el->system_count;
-        dst_el->multi_threaded = src_el->multi_threaded;
-        dst_el->no_readonly = src_el->no_readonly;
-    }
+                var->table_id = flecs_query_find_var_id(
+                    query, var_name, EcsVarTable);
+                ecs_assert(var->table_id != EcsVarNone, 
+                    ECS_INTERNAL_ERROR, NULL);
 
-    ecs_map_init_if(&dst->system_stats, NULL);
-    ecs_map_iter_t it = ecs_map_iter(&src->system_stats);
-    
-    while (ecs_map_next(&it)) {
-        ecs_system_stats_t *sys_src = ecs_map_ptr(&it);
-        ecs_system_stats_t *sys_dst = ecs_map_ensure_alloc_t(&dst->system_stats, 
-            ecs_system_stats_t, ecs_map_key(&it));
-        sys_dst->query.t = dst->t;
-        ecs_system_stats_reduce(sys_dst, sys_src);
+                ecs_os_free(var_name);
+            }
+        }
     }
-    dst->t = t_next(dst->t);
-}
 
-void ecs_pipeline_stats_reduce_last(
-    ecs_pipeline_stats_t *dst,
-    const ecs_pipeline_stats_t *src,
-    int32_t count)
-{
-    int32_t i, sync_count = ecs_vec_count(&src->sync_points);
-    ecs_sync_stats_t *dst_syncs = ecs_vec_first_t(&dst->sync_points, ecs_sync_stats_t);
-    ecs_sync_stats_t *src_syncs = ecs_vec_first_t(&src->sync_points, ecs_sync_stats_t);
+    /* Always include spot for This variable, even if query doesn't use it */
+    var_count ++;
 
-    for (i = 0; i < sync_count; i ++) {
-        ecs_sync_stats_t *dst_el = &dst_syncs[i];
-        ecs_sync_stats_t *src_el = &src_syncs[i];
-        flecs_stats_reduce_last(ECS_METRIC_FIRST(dst_el), ECS_METRIC_LAST(dst_el),
-            ECS_METRIC_FIRST(src_el), dst->t, src->t, count);
-        dst_el->system_count = src_el->system_count;
-        dst_el->multi_threaded = src_el->multi_threaded;
-        dst_el->no_readonly = src_el->no_readonly;
+    ecs_query_var_t *query_vars = &query->vars_cache.var;
+    if ((var_count + anonymous_count) > 1) {
+        query_vars = flecs_alloc(&stage->allocator,
+            (ECS_SIZEOF(ecs_query_var_t) + ECS_SIZEOF(char*)) * 
+                (var_count + anonymous_count));
     }
 
-    ecs_map_init_if(&dst->system_stats, NULL);
-    ecs_map_iter_t it = ecs_map_iter(&src->system_stats);
-    while (ecs_map_next(&it)) {
-        ecs_system_stats_t *sys_src = ecs_map_ptr(&it);
-        ecs_system_stats_t *sys_dst = ecs_map_ensure_alloc_t(&dst->system_stats, 
-            ecs_system_stats_t, ecs_map_key(&it));
-        sys_dst->query.t = dst->t;
-        ecs_system_stats_reduce_last(sys_dst, sys_src, count);
+    query->vars = query_vars;
+    query->var_count = var_count;
+    query->var_pub_count = var_count;
+    query->has_table_this = !entity_before_table_this;
+    query->var_size = var_count + anonymous_count;
+
+    char **var_names = ECS_ELEM(query_vars, ECS_SIZEOF(ecs_query_var_t), 
+        var_count + anonymous_count);
+    query->var_names = (char**)var_names;
+
+    query_vars[0].kind = EcsVarTable;
+    query_vars[0].name = NULL;
+    flecs_set_var_label(&query_vars[0], NULL);
+    query_vars[0].id = 0;
+    query_vars[0].table_id = EcsVarNone;
+    query_vars[0].lookup = NULL;
+    var_names[0] = ECS_CONST_CAST(char*, query_vars[0].name);
+    query_vars ++;
+    var_names ++;
+    var_count --;
+
+    if (var_count) {
+        ecs_query_var_t *user_vars = ecs_vec_first_t(vars, ecs_query_var_t);
+        ecs_os_memcpy_n(query_vars, user_vars, ecs_query_var_t, var_count);
+        for (i = 0; i < var_count; i ++) {
+            var_names[i] = ECS_CONST_CAST(char*, query_vars[i].name);
+        }
     }
-    dst->t = t_prev(dst->t);
-}
 
-void ecs_pipeline_stats_repeat_last(
-    ecs_pipeline_stats_t *stats)
-{
-    int32_t i, sync_count = ecs_vec_count(&stats->sync_points);
-    ecs_sync_stats_t *syncs = ecs_vec_first_t(&stats->sync_points, ecs_sync_stats_t);
+    /* Hide anonymous table variables from application */
+    query->var_pub_count -= anonymous_table_count;
 
-    for (i = 0; i < sync_count; i ++) {
-        ecs_sync_stats_t *el = &syncs[i];
-        flecs_stats_repeat_last(ECS_METRIC_FIRST(el), ECS_METRIC_LAST(el),
-            (stats->t));
+    /* Sanity check to make sure that the public part of the variable array only
+     * contains entity variables. */
+#ifdef FLECS_DEBUG
+    for (i = 1 /* first element = $this */; i < query->var_pub_count; i ++) {
+        ecs_assert(query->vars[i].kind == EcsVarEntity, ECS_INTERNAL_ERROR, NULL);
     }
+#endif
 
-    ecs_map_iter_t it = ecs_map_iter(&stats->system_stats);
-    while (ecs_map_next(&it)) {
-        ecs_system_stats_t *sys = ecs_map_ptr(&it);
-        sys->query.t = stats->t;
-        ecs_system_stats_repeat_last(sys);
+    return 0;
+error:
+    return -1;
+}
+
+static
+bool flecs_query_var_is_unknown(
+    ecs_query_impl_t *query,
+    ecs_var_id_t var_id,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_var_t *vars = query->vars;
+    if (ctx->written & (1ull << var_id)) {
+        return false;
+    } else {
+        ecs_var_id_t table_var = vars[var_id].table_id;
+        if (table_var != EcsVarNone) {
+            return flecs_query_var_is_unknown(query, table_var, ctx);
+        }
     }
-    stats->t = t_next(stats->t);
+    return true;
 }
 
-void ecs_pipeline_stats_copy_last(
-    ecs_pipeline_stats_t *dst,
-    const ecs_pipeline_stats_t *src)
+/* Returns whether term is unkown. A term is unknown when it has variable 
+ * elements (first, second, src) that are all unknown. */
+static
+bool flecs_query_term_is_unknown(
+    ecs_query_impl_t *query, 
+    ecs_term_t *term, 
+    ecs_query_compile_ctx_t *ctx) 
 {
-    int32_t i, sync_count = ecs_vec_count(&src->sync_points);
-    ecs_vec_init_if_t(&dst->sync_points, ecs_sync_stats_t);
-    ecs_vec_set_min_count_zeromem_t(NULL, &dst->sync_points, ecs_sync_stats_t, sync_count);
-    ecs_sync_stats_t *dst_syncs = ecs_vec_first_t(&dst->sync_points, ecs_sync_stats_t);
-    ecs_sync_stats_t *src_syncs = ecs_vec_first_t(&src->sync_points, ecs_sync_stats_t);
+    ecs_query_op_t dummy = {0};
+    flecs_query_compile_term_ref(NULL, query, &dummy, &term->first, 
+        &dummy.first, EcsQueryFirst, EcsVarEntity, ctx, false);
+    flecs_query_compile_term_ref(NULL, query, &dummy, &term->second, 
+        &dummy.second, EcsQuerySecond, EcsVarEntity, ctx, false);
+    flecs_query_compile_term_ref(NULL, query, &dummy, &term->src, 
+        &dummy.src, EcsQuerySrc, EcsVarAny, ctx, false);
 
-    for (i = 0; i < sync_count; i ++) {
-        ecs_sync_stats_t *dst_el = &dst_syncs[i];
-        ecs_sync_stats_t *src_el = &src_syncs[i];
-        flecs_stats_copy_last(ECS_METRIC_FIRST(dst_el), ECS_METRIC_LAST(dst_el),
-            ECS_METRIC_FIRST(src_el), dst->t, t_next(src->t));
-        dst_el->system_count = src_el->system_count;
-        dst_el->multi_threaded = src_el->multi_threaded;
-        dst_el->no_readonly = src_el->no_readonly;
+    bool has_vars = dummy.flags & 
+        ((EcsQueryIsVar << EcsQueryFirst) |
+         (EcsQueryIsVar << EcsQuerySecond) |
+         (EcsQueryIsVar << EcsQuerySrc));
+    if (!has_vars) {
+        /* If term has no variables (typically terms with a static src) there
+         * can't be anything that's unknown. */
+        return false;
     }
 
-    ecs_map_init_if(&dst->system_stats, NULL);
-
-    ecs_map_iter_t it = ecs_map_iter(&src->system_stats);
-    while (ecs_map_next(&it)) {
-        ecs_system_stats_t *sys_src = ecs_map_ptr(&it);
-        ecs_system_stats_t *sys_dst = ecs_map_ensure_alloc_t(&dst->system_stats, 
-            ecs_system_stats_t, ecs_map_key(&it));
-        sys_dst->query.t = dst->t;
-        ecs_system_stats_copy_last(sys_dst, sys_src);
+    if (dummy.flags & (EcsQueryIsVar << EcsQueryFirst)) {
+        if (!flecs_query_var_is_unknown(query, dummy.first.var, ctx)) {
+            return false;
+        }
+    }
+    if (dummy.flags & (EcsQueryIsVar << EcsQuerySecond)) {
+        if (!flecs_query_var_is_unknown(query, dummy.second.var, ctx)) {
+            return false;
+        }
+    }
+    if (dummy.flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        if (!flecs_query_var_is_unknown(query, dummy.src.var, ctx)) {
+            return false;
+        }
     }
-}
 
-#endif
+    return true;
+}
 
-void ecs_world_stats_log(
-    const ecs_world_t *world,
-    const ecs_world_stats_t *s)
+/* Find the next known term from specified offset. This function is used to find
+ * a term that can be evaluated before a term that is unknown. Evaluating known
+ * before unknown terms can significantly decrease the search space. */
+static
+int32_t flecs_query_term_next_known(
+    ecs_query_impl_t *query, 
+    ecs_query_compile_ctx_t *ctx,
+    int32_t offset,
+    ecs_flags64_t compiled) 
 {
-    int32_t t = s->t;
-
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    world = ecs_get_world(world);    
-    
-    flecs_counter_print("Frame", t, &s->frame.frame_count);
-    ecs_trace("-------------------------------------");
-    flecs_counter_print("pipeline rebuilds", t, &s->frame.pipeline_build_count);
-    flecs_counter_print("systems ran", t, &s->frame.systems_ran);
-    ecs_trace("");
-    flecs_metric_print("target FPS", (ecs_float_t)world->info.target_fps);
-    flecs_metric_print("time scale", (ecs_float_t)world->info.time_scale);
-    ecs_trace("");
-    flecs_gauge_print("actual FPS", t, &s->performance.fps);
-    flecs_counter_print("frame time", t, &s->performance.frame_time);
-    flecs_counter_print("system time", t, &s->performance.system_time);
-    flecs_counter_print("merge time", t, &s->performance.merge_time);
-    flecs_counter_print("simulation time elapsed", t, &s->performance.world_time);
-    ecs_trace("");
-    flecs_gauge_print("tag id count", t, &s->components.tag_count);
-    flecs_gauge_print("component id count", t, &s->components.component_count);
-    flecs_gauge_print("pair id count", t, &s->components.pair_count);
-    flecs_gauge_print("type count", t, &s->components.type_count);
-    flecs_counter_print("id create count", t, &s->components.create_count);
-    flecs_counter_print("id delete count", t, &s->components.delete_count);
-    ecs_trace("");
-    flecs_gauge_print("alive entity count", t, &s->entities.count);
-    flecs_gauge_print("not alive entity count", t, &s->entities.not_alive_count);
-    ecs_trace("");
-    flecs_gauge_print("query count", t, &s->queries.query_count);
-    flecs_gauge_print("observer count", t, &s->queries.observer_count);
-    flecs_gauge_print("system count", t, &s->queries.system_count);
-    ecs_trace("");
-    flecs_gauge_print("table count", t, &s->tables.count);
-    flecs_gauge_print("empty table count", t, &s->tables.empty_count);
-    flecs_counter_print("table create count", t, &s->tables.create_count);
-    flecs_counter_print("table delete count", t, &s->tables.delete_count);
-    ecs_trace("");
-    flecs_counter_print("add commands", t, &s->commands.add_count);
-    flecs_counter_print("remove commands", t, &s->commands.remove_count);
-    flecs_counter_print("delete commands", t, &s->commands.delete_count);
-    flecs_counter_print("clear commands", t, &s->commands.clear_count);
-    flecs_counter_print("set commands", t, &s->commands.set_count);
-    flecs_counter_print("ensure commands", t, &s->commands.ensure_count);
-    flecs_counter_print("modified commands", t, &s->commands.modified_count);
-    flecs_counter_print("other commands", t, &s->commands.other_count);
-    flecs_counter_print("discarded commands", t, &s->commands.discard_count);
-    flecs_counter_print("batched entities", t, &s->commands.batched_entity_count);
-    flecs_counter_print("batched commands", t, &s->commands.batched_count);
-    ecs_trace("");
-    
-error:
-    return;
-}
+    ecs_query_t *q = &query->pub;
+    ecs_term_t *terms = q->terms;
+    int32_t i, count = q->term_count;
 
-#endif
+    for (i = offset; i < count; i ++) {
+        ecs_term_t *term = &terms[i];
+        if (compiled & (1ull << i)) {
+            continue;
+        }
 
-/**
- * @file addons/timer.c
- * @brief Timer addon.
- */
+        /* Only evaluate And terms */
+        if (term->oper != EcsAnd || flecs_term_is_or(q, term)){
+            continue;
+        }
 
+        /* Don't reorder terms in scopes */
+        if (term->flags_ & EcsTermIsScope) {
+            continue;
+        }
 
-#ifdef FLECS_TIMER
+        if (flecs_query_term_is_unknown(query, term, ctx)) {
+            continue;
+        }
 
-static
-void AddTickSource(ecs_iter_t *it) {
-    int32_t i;
-    for (i = 0; i < it->count; i ++) {
-        ecs_set(it->world, it->entities[i], EcsTickSource, {0});
+        return i;
     }
+
+    return -1;
 }
 
+/* If the first part of a query contains more than one trivial term, insert a
+ * special instruction which batch-evaluates multiple terms. */
 static
-void ProgressTimers(ecs_iter_t *it) {
-    EcsTimer *timer = ecs_field(it, EcsTimer, 1);
-    EcsTickSource *tick_source = ecs_field(it, EcsTickSource, 2);
+void flecs_query_insert_trivial_search(
+    ecs_query_impl_t *query,
+    ecs_flags64_t *compiled,
+    ecs_flags64_t *populated,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_t *q = &query->pub;
+    ecs_term_t *terms = q->terms;
+    int32_t i, term_count = q->term_count;
+    ecs_flags64_t trivial_set = 0;
 
-    ecs_assert(timer != NULL, ECS_INTERNAL_ERROR, NULL);
+    /* Trivial search always ignores prefabs and disabled entities */
+    if (query->pub.flags & (EcsQueryMatchPrefab|EcsQueryMatchDisabled)) {
+        return;
+    }
 
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        tick_source[i].tick = false;
+    /* Find trivial terms, which can be handled in single instruction */
+    int32_t trivial_wildcard_terms = 0;
+    int32_t trivial_data_terms = 0;
+    int32_t trivial_terms = 0;
+    for (i = 0; i < term_count; i ++) {
+        /* Term is already compiled */
+        if (*compiled & (1ull << i)) {
+            continue;
+        }
 
-        if (!timer[i].active) {
+        ecs_term_t *term = &terms[i];
+        if (!(term->flags_ & EcsTermIsTrivial)) {
             continue;
         }
 
-        const ecs_world_info_t *info = ecs_get_world_info(it->world);
-        ecs_ftime_t time_elapsed = timer[i].time + info->delta_time_raw;
-        ecs_ftime_t timeout = timer[i].timeout;
-        
-        if (time_elapsed >= timeout) {
-            ecs_ftime_t t = time_elapsed - timeout;
-            if (t > timeout) {
-                t = 0;
-            }
+        /* We can only add trivial terms to plan if they no up traversal */
+        if ((term->src.id & EcsTraverseFlags) != EcsSelf) {
+            continue;
+        }
 
-            timer[i].time = t; /* Initialize with remainder */
-            tick_source[i].tick = true;
-            tick_source[i].time_elapsed = time_elapsed - timer[i].overshoot;
-            timer[i].overshoot = t;
+        trivial_set |= (1llu << i);
 
-            if (timer[i].single_shot) {
-                timer[i].active = false;
+        if (ecs_id_is_wildcard(term->id)) {
+            trivial_wildcard_terms ++;
+        }
+
+        if (q->data_fields & (1llu << term->field_index)) {
+            trivial_data_terms ++;
+        }
+
+        trivial_terms ++;
+    }
+
+    if (trivial_terms >= 2) {
+        /* Mark terms as compiled & populated */
+        for (i = 0; i < q->term_count; i ++) {
+            if (trivial_set & (1llu << i)) {
+                *compiled |= (1ull << i);
+                *populated |= (1ull << terms[i].field_index);
             }
+        }
+
+        /* If there's more than 1 trivial term, batch them in trivial search */
+        ecs_query_op_t trivial = {0};
+        if (trivial_wildcard_terms) {
+            trivial.kind = EcsQueryTrivWildcard;
         } else {
-            timer[i].time = time_elapsed;
-        }  
+            if (trivial_data_terms) {
+                trivial.kind = EcsQueryTrivData;
+            }
+            if (!trivial.kind) {
+                trivial.kind = EcsQueryTriv;
+            }
+        }
+
+        /* Store the bitset with trivial terms on the instruction */
+        trivial.src.entity = trivial_set;
+        flecs_query_op_insert(&trivial, ctx);
     }
 }
 
 static
-void ProgressRateFilters(ecs_iter_t *it) {
-    EcsRateFilter *filter = ecs_field(it, EcsRateFilter, 1);
-    EcsTickSource *tick_dst = ecs_field(it, EcsTickSource, 2);
+void flecs_query_insert_cache_search(
+    ecs_query_impl_t *query,
+    ecs_flags64_t *compiled,
+    ecs_flags64_t *populated,
+    ecs_query_compile_ctx_t *ctx)
+{
+    if (!query->cache) {
+        return;
+    }
 
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        ecs_entity_t src = filter[i].src;
-        bool inc = false;
+    ecs_query_t *q = &query->pub;
+    bool populate = true;
 
-        filter[i].time_elapsed += it->delta_time;
+    if (q->cache_kind == EcsQueryCacheAll) {
+        /* If all terms are cacheable, make sure no other terms are compiled */
+        *compiled = 0xFFFFFFFFFFFFFFFF;
+        *populated = 0xFFFFFFFFFFFFFFFF;
+    } else if (q->cache_kind == EcsQueryCacheAuto) {
+        /* The query is partially cacheable */
+        ecs_term_t *terms = q->terms;
+        int32_t i, count = q->term_count;
 
-        if (src) {
-            const EcsTickSource *tick_src = ecs_get(
-                it->world, src, EcsTickSource);
-            if (tick_src) {
-                inc = tick_src->tick;
-            } else {
-                inc = true;
+        for (i = 0; i < count; i ++) {
+            ecs_term_t *term = &terms[i];
+            if (term->flags_ & (EcsTermIsToggle | EcsTermIsMember)) {
+                /* If query returns individual entities, let dedicated populate
+                 * instruction handle populating data fields */
+                populate = false;
+                break;
             }
-        } else {
-            inc = true;
         }
 
-        if (inc) {
-            filter[i].tick_count ++;
-            bool triggered = !(filter[i].tick_count % filter[i].rate);
-            tick_dst[i].tick = triggered;
-            tick_dst[i].time_elapsed = filter[i].time_elapsed;
+        for (i = 0; i < count; i ++) {
+            ecs_term_t *term = &terms[i];
+            int16_t field = term->field_index;
+            if ((*compiled) & (1ull << i)) {
+                continue;
+            }
 
-            if (triggered) {
-                filter[i].time_elapsed = 0;
-            }            
+            if (!(term->flags_ & EcsTermIsCacheable)) {
+                continue;
+            }
+
+            *compiled |= (1ull << i);
+
+            if (populate) {
+                *populated |= (1ull << field);
+            }
+        }
+    }
+
+    /* Insert the operation for cache traversal */
+    ecs_query_op_t op = {0};
+    if (!populate || (q->flags & EcsQueryNoData)) {
+        if (q->flags & EcsQueryIsCacheable) {
+            op.kind = EcsQueryIsCache;
         } else {
-            tick_dst[i].tick = false;
+            op.kind = EcsQueryCache;
+        }
+    } else {
+        if (q->flags & EcsQueryIsCacheable) {
+            op.kind = EcsQueryIsCacheData;
+        } else {
+            op.kind = EcsQueryCacheData;
         }
     }
+
+    flecs_query_write(0, &op.written);
+    flecs_query_write_ctx(0, ctx, false);
+    flecs_query_op_insert(&op, ctx);
 }
 
 static
-void ProgressTickSource(ecs_iter_t *it) {
-    EcsTickSource *tick_src = ecs_field(it, EcsTickSource, 1);
+bool flecs_term_ref_match_multiple(
+    ecs_term_ref_t *ref)
+{
+    return (ref->id & EcsIsVariable) && (ECS_TERM_REF_ID(ref) != EcsAny);
+}
 
-    /* If tick source has no filters, tick unconditionally */
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        tick_src[i].tick = true;
-        tick_src[i].time_elapsed = it->delta_time;
-    }
+static
+bool flecs_term_match_multiple(
+    ecs_term_t *term)
+{
+    return flecs_term_ref_match_multiple(&term->first) ||
+        flecs_term_ref_match_multiple(&term->second);
 }
 
-ecs_entity_t ecs_set_timeout(
-    ecs_world_t *world,
-    ecs_entity_t timer,
-    ecs_ftime_t timeout)
+/* Insert instruction to populate data fields. */
+void flecs_query_insert_populate(
+    ecs_query_impl_t *query,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_flags64_t populated)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_query_t *q = &query->pub;
+    int32_t i, term_count = q->term_count;
 
-    timer = ecs_set(world, timer, EcsTimer, {
-        .timeout = timeout,
-        .single_shot = true,
-        .active = true
-    });
+    if (populated && !(q->flags & EcsQueryNoData)) {
+        int32_t populate_count = 0;
+        int32_t self_count = 0;
 
-    ecs_system_t *system_data = ecs_poly_get(world, timer, ecs_system_t);
-    if (system_data) {
-        system_data->tick_source = timer;
-    }
+        /* Figure out which populate instruction to use */
+        for (i = 0; i < term_count; i ++) {
+            ecs_term_t *term = &q->terms[i];
+            int16_t field = term->field_index;
 
-error:
-    return timer;
-}
+            if (!(populated & (1ull << field))) {
+                /* Only check fields that need to be populated */
+                continue;
+            }
 
-ecs_ftime_t ecs_get_timeout(
-    const ecs_world_t *world,
-    ecs_entity_t timer)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(timer != 0, ECS_INVALID_PARAMETER, NULL);
+            populate_count ++;
 
-    const EcsTimer *value = ecs_get(world, timer, EcsTimer);
-    if (value) {
-        return value->timeout;
+            /* Callee is asking us to populate a term without data */
+            if (ecs_term_match_this(term) && !(term->src.id & EcsUp)) {
+                self_count ++;
+            }
+        }
+
+        ecs_assert(populate_count != 0, ECS_INTERNAL_ERROR, NULL);
+
+        ecs_query_op_kind_t kind = EcsQueryPopulate;
+        if (populate_count == self_count) {
+            kind = EcsQueryPopulateSelf;
+        }
+
+        ecs_query_op_t op = {0};
+        op.kind = flecs_ito(uint8_t, kind);
+        op.src.entity = populated; /* Abuse for bitset w/fields to populate */
+        flecs_query_op_insert(&op, ctx);
     }
-error:
-    return 0;
 }
 
-ecs_entity_t ecs_set_interval(
-    ecs_world_t *world,
-    ecs_entity_t timer,
-    ecs_ftime_t interval)
+static
+int flecs_query_insert_toggle(
+    ecs_query_impl_t *impl,
+    ecs_query_compile_ctx_t *ctx)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_query_t *q = &impl->pub;
+    int32_t i, j, term_count = q->term_count;
+    ecs_term_t *terms = q->terms;
+    ecs_flags64_t fields_done = 0;
 
-    if (!timer) {
-        timer = ecs_new(world, EcsTimer);
-    }
+    for (i = 0; i < term_count; i ++) {
+        if (fields_done & (1llu << i)) {
+            continue;
+        }
 
-    EcsTimer *t = ecs_ensure(world, timer, EcsTimer);
-    ecs_check(t != NULL, ECS_INVALID_PARAMETER, NULL);
-    t->timeout = interval;
-    t->active = true;
-    ecs_modified(world, timer, EcsTimer);
+        ecs_term_t *term = &terms[i];
+        if (term->flags_ & EcsTermIsToggle) {
+            ecs_query_op_t cur = {0};
+            flecs_query_compile_term_ref(NULL, impl, &cur, &term->src, 
+                &cur.src, EcsQuerySrc, EcsVarAny, ctx, false);
 
-    ecs_system_t *system_data = ecs_poly_get(world, timer, ecs_system_t);
-    if (system_data) {
-        system_data->tick_source = timer;
-    }
-error:
-    return timer;  
-}
+            ecs_flags64_t and_toggles = 0;
+            ecs_flags64_t not_toggles = 0;
+            ecs_flags64_t optional_toggles = 0;
 
-ecs_ftime_t ecs_get_interval(
-    const ecs_world_t *world,
-    ecs_entity_t timer)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+            for (j = i; j < term_count; j ++) {
+                if (fields_done & (1llu << j)) {
+                    continue;
+                }
 
-    if (!timer) {
-        return 0;
-    }
+                /* Also includes term[i], so flags get set correctly */
+                term = &terms[j];
 
-    const EcsTimer *value = ecs_get(world, timer, EcsTimer);
-    if (value) {
-        return value->timeout;
+                /* If term is not for the same src, skip */
+                ecs_query_op_t next = {0};
+                flecs_query_compile_term_ref(NULL, impl, &next, &term->src,
+                    &next.src, EcsQuerySrc, EcsVarAny, ctx, false);
+                if (next.src.entity != cur.src.entity || 
+                    next.flags != cur.flags) 
+                {
+                    continue;
+                }
+
+                /* Source matches, set flag */
+                if (term->oper == EcsNot) {
+                    not_toggles |= (1llu << j);
+                } else if (term->oper == EcsOptional) {
+                    optional_toggles |= (1llu << j);
+                } else {
+                    and_toggles |= (1llu << j);
+                }
+
+                fields_done |= (1llu << j);
+            }
+
+            if (and_toggles || not_toggles) {
+                ecs_query_op_t op = {0};
+                op.kind = EcsQueryToggle;
+                op.src = cur.src;
+                op.flags = cur.flags;
+
+                if (op.flags & (EcsQueryIsVar << EcsQuerySrc)) {
+                    flecs_query_write(op.src.var, &op.written);
+                }
+
+                /* Encode fields:
+                 * - first.entity is the fields that match enabled bits
+                 * - second.entity is the fields that match disabled bits
+                 */
+                op.first.entity = and_toggles;
+                op.second.entity = not_toggles;
+                flecs_query_op_insert(&op, ctx);
+            }
+
+            /* Insert separate instructions for optional terms. To make sure
+             * entities are returned in batches where fields are never partially 
+             * set or unset, the result must be split up into batches that have 
+             * the exact same toggle masks. Instead of complicating the toggle 
+             * instruction with code to scan for blocks that have the same bits 
+             * set, separate instructions let the query engine backtrack to get 
+             * the right results. */
+            if (optional_toggles) {
+                for (j = i; j < term_count; j ++) {
+                    uint64_t field_bit = 1ull << j;
+                    if (!(optional_toggles & field_bit)) {
+                        continue;
+                    }
+
+                    ecs_query_op_t op = {0};
+                    op.kind = EcsQueryToggleOption;
+                    op.src = cur.src;
+                    op.first.entity = field_bit;
+                    op.flags = cur.flags;
+                    flecs_query_op_insert(&op, ctx);
+                }
+            }
+        }
     }
-error:
+
     return 0;
 }
 
-void ecs_start_timer(
+static
+int flecs_query_insert_fixed_src_terms(
     ecs_world_t *world,
-    ecs_entity_t timer)
+    ecs_query_impl_t *impl,
+    ecs_flags64_t *compiled,
+    ecs_flags64_t *populated_out,
+    ecs_query_compile_ctx_t *ctx)
 {
-    EcsTimer *ptr = ecs_ensure(world, timer, EcsTimer);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ptr->active = true;
-    ptr->time = 0;
-error:
-    return;
-}
+    ecs_query_t *q = &impl->pub;
+    int32_t i, term_count = q->term_count;
+    ecs_term_t *terms = q->terms;
+    ecs_flags64_t populated = 0;
 
-void ecs_stop_timer(
-    ecs_world_t *world,
-    ecs_entity_t timer)
-{
-    EcsTimer *ptr = ecs_ensure(world, timer, EcsTimer);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ptr->active = false;
-error:
-    return;
-}
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
 
-void ecs_reset_timer(
-    ecs_world_t *world,
-    ecs_entity_t timer)
-{
-    EcsTimer *ptr = ecs_ensure(world, timer, EcsTimer);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ptr->time = 0;
-error:
-    return;   
-}
+        if (term->oper ==  EcsNot) {
+            /* If term has not operator and variables for first/second, we can't
+             * put the term first as this could prevent us from getting back
+             * valid results. For example:
+             *   !$var(e), Tag($var)
+             * 
+             * Here, the first term would evaluate to false (and cause the 
+             * entire query not to match) if 'e' has any components.
+             * 
+             * However, when reordering we get results:
+             *   Tag($var), !$var(e)
+             * 
+             * Now the query returns all entities with Tag, that 'e' does not
+             * have as component. For this reason, queries should never use
+             * unwritten variables in not terms- and we should also not reorder
+             * terms in a way that results in doing this. */
+            if (flecs_term_match_multiple(term)) {
+                continue;
+            }
+        }
 
-ecs_entity_t ecs_set_rate(
-    ecs_world_t *world,
-    ecs_entity_t filter,
-    int32_t rate,
-    ecs_entity_t source)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+        /* Don't reorder terms in scopes */
+        if (term->flags_ & EcsTermIsScope) {
+            continue;
+        }
 
-    filter = ecs_set(world, filter, EcsRateFilter, {
-        .rate = rate,
-        .src = source
-    });
+        if (term->src.id & EcsIsEntity && ECS_TERM_REF_ID(&term->src)) {
+            if (flecs_query_compile_term(world, impl, term, populated_out, ctx)) {
+                return -1;
+            }
 
-    ecs_system_t *system_data = ecs_poly_get(world, filter, ecs_system_t);
-    if (system_data) {
-        system_data->tick_source = filter;
-    }  
+            *compiled |= (1llu << i);
 
-error:
-    return filter;     
+            /* If this is a data field, track it. This will let us insert an
+             * instruction specifically for populating data fields of terms with
+             * fixed source (see below). */
+            if (q->data_fields & (1llu << term->field_index)) {
+                populated |= (1llu << term->field_index);
+            }
+        }
+    }
+
+    if (populated) {
+        /* If data fields with a fixed source were evaluated, insert a populate
+         * instruction that just populates those fields. The advantage of doing
+         * this before the rest of the query is evaluated, is that we only 
+         * populate data for static fields once vs. for each returned result of
+         * the query, which would be wasteful since this data doesn't change. */
+        flecs_query_insert_populate(impl, ctx, populated);
+    }
+
+    *populated_out |= populated;
+
+    return 0;
 }
 
-void ecs_set_tick_source(
+int flecs_query_compile(
     ecs_world_t *world,
-    ecs_entity_t system,
-    ecs_entity_t tick_source)
+    ecs_stage_t *stage,
+    ecs_query_impl_t *query)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(tick_source != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_query_t *q = &query->pub;
+    ecs_term_t *terms = q->terms;
+    ecs_query_compile_ctx_t ctx = {0};
+    ecs_vec_reset_t(NULL, &stage->operations, ecs_query_op_t);
+    ctx.ops = &stage->operations;
+    ctx.cur = ctx.ctrlflow;
+    ctx.cur->lbl_begin = -1;
+    ctx.cur->lbl_begin = -1;
+    ecs_vec_clear(ctx.ops);
 
-    ecs_system_t *system_data = ecs_poly_get(world, system, ecs_system_t);
-    ecs_check(system_data != NULL, ECS_INVALID_PARAMETER, NULL);
+    /* Find all variables defined in query */
+    if (flecs_query_discover_vars(stage, query)) {
+        return -1;
+    }
 
-    system_data->tick_source = tick_source;
-error:
-    return;
-}
+    /* If query contains fixed source terms, insert operation to set sources */
+    int32_t i, term_count = q->term_count;
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
+        if (term->src.id & EcsIsEntity) {
+            ecs_query_op_t set_fixed = {0};
+            set_fixed.kind = EcsQuerySetFixed;
+            flecs_query_op_insert(&set_fixed, &ctx);
+            break;
+        }
+    }
 
-static
-void RandomizeTimers(ecs_iter_t *it) {
-    EcsTimer *timer = ecs_field(it, EcsTimer, 1);
-    int32_t i;
-    for (i = 0; i < it->count; i ++) {
-        timer[i].time = 
-            ((ecs_ftime_t)rand() / (ecs_ftime_t)RAND_MAX) * timer[i].timeout;
+    /* If the query contains terms with fixed ids (no wildcards, variables), 
+     * insert instruction that initializes ecs_iter_t::ids. This allows for the
+     * insertion of simpler instructions later on. 
+     * If the query is entirely cacheable, ids are populated by the cache. */
+    if (q->cache_kind != EcsQueryCacheAll) {
+        for (i = 0; i < term_count; i ++) {
+            ecs_term_t *term = &terms[i];
+            if (flecs_term_is_fixed_id(q, term) || 
+                (term->src.id & EcsIsEntity && 
+                    !(term->src.id & ~EcsTermRefFlags))) 
+            {
+                ecs_query_op_t set_ids = {0};
+                set_ids.kind = EcsQuerySetIds;
+                flecs_query_op_insert(&set_ids, &ctx);
+                break;
+            }
+        }
     }
-}
 
-void ecs_randomize_timers(
-    ecs_world_t *world)
-{
-    ecs_observer(world, {
-        .entity = ecs_entity(world, { .name = "flecs.timer.RandomizeTimers" }),
-        .filter.terms = {{
-            .id = ecs_id(EcsTimer)
-        }},
-        .events = {EcsOnSet},
-        .yield_existing = true,
-        .callback = RandomizeTimers
-    });
-}
+    ecs_flags64_t compiled = 0;
+    ecs_flags64_t populated = 0;
 
-void FlecsTimerImport(
-    ecs_world_t *world)
-{    
-    ECS_MODULE(world, FlecsTimer);
-    ECS_IMPORT(world, FlecsPipeline);
-#ifdef FLECS_DOC
-    ECS_IMPORT(world, FlecsDoc);
-    ecs_doc_set_brief(world, ecs_id(FlecsTimer), 
-        "Module that implements system timers (used by .interval)");
-#endif
+    /* Always evaluate terms with fixed source before other terms */
+    flecs_query_insert_fixed_src_terms(
+        world, query, &compiled, &populated, &ctx);
 
-    ecs_set_name_prefix(world, "Ecs");
+    /* Compile cacheable terms */
+    flecs_query_insert_cache_search(
+        query, &compiled, &populated, &ctx);
 
-    flecs_bootstrap_component(world, EcsTimer);
-    flecs_bootstrap_component(world, EcsRateFilter);
+    /* Insert trivial term search if query allows for it */
+    flecs_query_insert_trivial_search(
+        query, &compiled, &populated, &ctx);
 
-    ecs_set_hooks(world, EcsTimer, {
-        .ctor = ecs_default_ctor
-    });
+    /* Compile remaining query terms to instructions */
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
+        int32_t compile = i;
 
-    /* Add EcsTickSource to timers and rate filters */
-    ecs_system(world, {
-        .entity = ecs_entity(world, {.name = "AddTickSource", .add = { ecs_dependson(EcsPreFrame) }}),
-        .query.filter.terms = {
-            { .id = ecs_id(EcsTimer), .oper = EcsOr, .inout = EcsIn },
-            { .id = ecs_id(EcsRateFilter), .oper = EcsAnd, .inout = EcsIn },
-            { .id = ecs_id(EcsTickSource), .oper = EcsNot, .inout = EcsOut}
-        },
-        .callback = AddTickSource
-    });
+        if (compiled & (1ull << i)) {
+            continue; /* Already compiled */
+        }
 
-    /* Timer handling */
-    ecs_system(world, {
-        .entity = ecs_entity(world, {.name = "ProgressTimers", .add = { ecs_dependson(EcsPreFrame)}}),
-        .query.filter.terms = {
-            { .id = ecs_id(EcsTimer) },
-            { .id = ecs_id(EcsTickSource) }
-        },
-        .callback = ProgressTimers
-    });
+        bool can_reorder = true;
+        if (term->oper != EcsAnd || flecs_term_is_or(q, term)){
+            can_reorder = false;
+        }
 
-    /* Rate filter handling */
-    ecs_system(world, {
-        .entity = ecs_entity(world, {.name = "ProgressRateFilters", .add = { ecs_dependson(EcsPreFrame)}}),
-        .query.filter.terms = {
-            { .id = ecs_id(EcsRateFilter), .inout = EcsIn },
-            { .id = ecs_id(EcsTickSource), .inout = EcsOut }
-        },
-        .callback = ProgressRateFilters
-    });
+        /* If variables have been written, but this term has no known variables,
+         * first try to resolve terms that have known variables. This can 
+         * significantly reduce the search space. 
+         * Only perform this optimization after at least one variable has been
+         * written to, as all terms are unknown otherwise. */
+        if (can_reorder && ctx.written && 
+            flecs_query_term_is_unknown(query, term, &ctx)) 
+        {
+            int32_t term_index = flecs_query_term_next_known(
+                query, &ctx, i + 1, compiled);
+            if (term_index != -1) {
+                term = &q->terms[term_index];
+                compile = term_index;
+                i --; /* Repeat current term */
+            }
+        }
 
-    /* TickSource without a timer or rate filter just increases each frame */
-    ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "ProgressTickSource", .add = { ecs_dependson(EcsPreFrame)}}),
-        .query.filter.terms = {
-            { .id = ecs_id(EcsTickSource), .inout = EcsOut },
-            { .id = ecs_id(EcsRateFilter), .oper = EcsNot },
-            { .id = ecs_id(EcsTimer), .oper = EcsNot }
-        },
-        .callback = ProgressTickSource
-    });
-}
+        if (flecs_query_compile_term(world, query, term, &populated, &ctx)) {
+            return -1;
+        }
 
-#endif
+        compiled |= (1ull << compile);
+    }
 
-/**
- * @file addons/units.c
- * @brief Units addon.
- */
+    ecs_var_id_t this_id = flecs_query_find_var_id(query, "this", EcsVarEntity);
 
+    /* If This variable has been written as entity, insert an operation to 
+     * assign it to it.entities for consistency. */
+    if (this_id != EcsVarNone && (ctx.written & (1ull << this_id))) {
+        ecs_query_op_t set_this = {0};
+        set_this.kind = EcsQuerySetThis;
+        set_this.flags |= (EcsQueryIsVar << EcsQueryFirst);
+        set_this.first.var = this_id;
+        flecs_query_op_insert(&set_this, &ctx);
+    }
 
-#ifdef FLECS_UNITS
+    /* Make sure non-This variables are written as entities */
+    if (query->vars) {
+        for (i = 0; i < query->var_count; i ++) {
+            ecs_query_var_t *var = &query->vars[i];
+            if (var->id && var->kind == EcsVarTable && var->name) {
+                ecs_var_id_t var_id = flecs_query_find_var_id(query, var->name,
+                    EcsVarEntity);
+                if (!flecs_query_is_written(var_id, ctx.written)) {
+                    /* Skip anonymous variables */
+                    if (!flecs_query_var_is_anonymous(query, var_id)) {
+                        flecs_query_insert_each(var->id, var_id, &ctx, false);
+                    }
+                }
+            }
+        }
+    }
 
-void FlecsUnitsImport(
-    ecs_world_t *world)
-{
-    ECS_MODULE(world, FlecsUnits);
+    /* If query contains non-This variables as term source, build lookup array */
+    if (query->src_vars) {
+        ecs_assert(query->vars != NULL, ECS_INTERNAL_ERROR, NULL);
+        bool only_anonymous = true;
 
-#ifdef FLECS_DOC
-    ECS_IMPORT(world, FlecsDoc);
-    ecs_doc_set_brief(world, ecs_id(FlecsUnits), 
-        "Module with (amongst others) SI units for annotating component members");
-#endif
+        for (i = 0; i < q->field_count; i ++) {
+            ecs_var_id_t var_id = query->src_vars[i];
+            if (!var_id) {
+                continue;
+            }
 
-    ecs_set_name_prefix(world, "Ecs");
+            if (!flecs_query_var_is_anonymous(query, var_id)) {
+                only_anonymous = false;
+                break;
+            } else {
+                /* Don't fetch component data for anonymous variables. Because
+                 * not all metadata (such as it.sources) is initialized for
+                 * anonymous variables, and because they may only be available
+                 * as table variables (each is not guaranteed to be inserted for
+                 * anonymous variables) the iterator may not have sufficient
+                 * information to resolve component data. */
+                for (int32_t t = 0; t < q->term_count; t ++) {
+                    ecs_term_t *term = &q->terms[t];
+                    if (term->field_index == i) {
+                        term->inout = EcsInOutNone;
+                    }
+                }
+            }
+        }
 
-    EcsUnitPrefixes = ecs_entity(world, {
-        .name = "prefixes",
-        .add = { EcsModule }
-    });
+        /* Don't insert setvar instruction if all vars are anonymous */
+        if (!only_anonymous) {
+            ecs_query_op_t set_vars = {0};
+            set_vars.kind = EcsQuerySetVars;
+            flecs_query_op_insert(&set_vars, &ctx);
+        }
 
-    /* Initialize unit prefixes */
+        for (i = 0; i < q->field_count; i ++) {
+            ecs_var_id_t var_id = query->src_vars[i];
+            if (!var_id) {
+                continue;
+            }
 
-    ecs_entity_t prev_scope = ecs_set_scope(world, EcsUnitPrefixes);
+            if (query->vars[var_id].kind == EcsVarTable) {
+                var_id = flecs_query_find_var_id(query, query->vars[var_id].name,
+                    EcsVarEntity);
 
-    EcsYocto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Yocto" }),
-        .symbol = "y",
-        .translation = { .factor = 10, .power = -24 }
-    });
-    EcsZepto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Zepto" }),
-        .symbol = "z",
-        .translation = { .factor = 10, .power = -21 }
-    });
-    EcsAtto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Atto" }),
-        .symbol = "a",
-        .translation = { .factor = 10, .power = -18 }
-    });
-    EcsFemto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Femto" }),
-        .symbol = "a",
-        .translation = { .factor = 10, .power = -15 }
-    });
-    EcsPico = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Pico" }),
-        .symbol = "p",
-        .translation = { .factor = 10, .power = -12 }
-    });
-    EcsNano = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Nano" }),
-        .symbol = "n",
-        .translation = { .factor = 10, .power = -9 }
-    });
-    EcsMicro = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Micro" }),
-        .symbol = "μ",
-        .translation = { .factor = 10, .power = -6 }
-    });
-    EcsMilli = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Milli" }),
-        .symbol = "m",
-        .translation = { .factor = 10, .power = -3 }
-    });
-    EcsCenti = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Centi" }),
-        .symbol = "c",
-        .translation = { .factor = 10, .power = -2 }
-    });
-    EcsDeci = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Deci" }),
-        .symbol = "d",
-        .translation = { .factor = 10, .power = -1 }
-    });
-    EcsDeca = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Deca" }),
-        .symbol = "da",
-        .translation = { .factor = 10, .power = 1 }
-    });
-    EcsHecto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Hecto" }),
-        .symbol = "h",
-        .translation = { .factor = 10, .power = 2 }
-    });
-    EcsKilo = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Kilo" }),
-        .symbol = "k",
-        .translation = { .factor = 10, .power = 3 }
-    });
-    EcsMega = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Mega" }),
-        .symbol = "M",
-        .translation = { .factor = 10, .power = 6 }
-    });
-    EcsGiga = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Giga" }),
-        .symbol = "G",
-        .translation = { .factor = 10, .power = 9 }
-    });
-    EcsTera = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Tera" }),
-        .symbol = "T",
-        .translation = { .factor = 10, .power = 12 }
-    });
-    EcsPeta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Peta" }),
-        .symbol = "P",
-        .translation = { .factor = 10, .power = 15 }
-    });
-    EcsExa = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Exa" }),
-        .symbol = "E",
-        .translation = { .factor = 10, .power = 18 }
-    });
-    EcsZetta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Zetta" }),
-        .symbol = "Z",
-        .translation = { .factor = 10, .power = 21 }
-    });
-    EcsYotta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Yotta" }),
-        .symbol = "Y",
-        .translation = { .factor = 10, .power = 24 }
-    });
+                /* Variables used as source that aren't This must be entities */
+                ecs_assert(var_id != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+            }
 
-    EcsKibi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Kibi" }),
-        .symbol = "Ki",
-        .translation = { .factor = 1024, .power = 1 }
-    });
-    EcsMebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Mebi" }),
-        .symbol = "Mi",
-        .translation = { .factor = 1024, .power = 2 }
-    });
-    EcsGibi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Gibi" }),
-        .symbol = "Gi",
-        .translation = { .factor = 1024, .power = 3 }
-    });
-    EcsTebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Tebi" }),
-        .symbol = "Ti",
-        .translation = { .factor = 1024, .power = 4 }
-    });
-    EcsPebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Pebi" }),
-        .symbol = "Pi",
-        .translation = { .factor = 1024, .power = 5 }
-    });
-    EcsExbi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Exbi" }),
-        .symbol = "Ei",
-        .translation = { .factor = 1024, .power = 6 }
-    });
-    EcsZebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Zebi" }),
-        .symbol = "Zi",
-        .translation = { .factor = 1024, .power = 7 }
-    });
-    EcsYobi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t){
-        .entity = ecs_entity(world, { .name = "Yobi" }),
-        .symbol = "Yi",
-        .translation = { .factor = 1024, .power = 8 }
-    });
+            query->src_vars[i] = var_id;
+        }
+    }
 
-    ecs_set_scope(world, prev_scope);
+    ecs_assert((term_count - ctx.skipped) >= 0, ECS_INTERNAL_ERROR, NULL);
 
-    /* Duration units */
+    /* If query is empty, insert Nothing instruction */
+    if (!(term_count - ctx.skipped)) {
+        ecs_vec_clear(ctx.ops);
+        ecs_query_op_t nothing = {0};
+        nothing.kind = EcsQueryNothing;
+        flecs_query_op_insert(&nothing, &ctx);
+    } else {
+        /* If query contains terms for toggleable components, insert toggle */
+        if (!(q->flags & EcsQueryTableOnly)) {
+            flecs_query_insert_toggle(query, &ctx);
+        }
 
-    EcsDuration = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Duration" });
-    prev_scope = ecs_set_scope(world, EcsDuration);
+        /* Insert instruction to populate remaining data fields */
+        ecs_flags64_t remaining = q->data_fields & ~populated;
+        flecs_query_insert_populate(query, &ctx, remaining);
 
-        EcsSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
-            .entity = ecs_entity(world, { .name = "Seconds" }),
-            .quantity = EcsDuration,
-            .symbol = "s" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsSeconds,
-            .kind = EcsF32
-        });
-            EcsPicoSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
-                .entity = ecs_entity(world, { .name = "PicoSeconds" }),
-                .quantity = EcsDuration,
-                .base = EcsSeconds,
-                .prefix = EcsPico });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsPicoSeconds,
-                .kind = EcsF32
-            });
+        /* Insert yield. If program reaches this operation, a result was found */
+        ecs_query_op_t yield = {0};
+        yield.kind = EcsQueryYield;
+        flecs_query_op_insert(&yield, &ctx);
+    }
 
+    int32_t op_count = ecs_vec_count(ctx.ops);
+    if (op_count) {
+        query->op_count = op_count;
+        query->ops = flecs_alloc_n(&stage->allocator, ecs_query_op_t, op_count);
+        ecs_query_op_t *query_ops = ecs_vec_first_t(ctx.ops, ecs_query_op_t);
+        ecs_os_memcpy_n(query->ops, query_ops, ecs_query_op_t, op_count);
+    }
 
-            EcsNanoSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
-                .entity = ecs_entity(world, { .name = "NanoSeconds" }),
-                .quantity = EcsDuration,
-                .base = EcsSeconds,
-                .prefix = EcsNano });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsNanoSeconds,
-                .kind = EcsF32
-            });
+    return 0;
+}
 
-            EcsMicroSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
-                .entity = ecs_entity(world, { .name = "MicroSeconds" }),
-                .quantity = EcsDuration,
-                .base = EcsSeconds,
-                .prefix = EcsMicro });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsMicroSeconds,
-                .kind = EcsF32
-            });
+/**
+ * @file addons/querys/compiler_term.c
+ * @brief Compile query term.
+ */
 
-            EcsMilliSeconds = ecs_unit_init(world, &(ecs_unit_desc_t){
-                .entity = ecs_entity(world, { .name = "MilliSeconds" }),
-                .quantity = EcsDuration,
-                .base = EcsSeconds,
-                .prefix = EcsMilli });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsMilliSeconds,
-                .kind = EcsF32
-            });
 
-        EcsMinutes = ecs_unit_init(world, &(ecs_unit_desc_t){
-            .entity = ecs_entity(world, { .name = "Minutes" }),
-            .quantity = EcsDuration,
-            .base = EcsSeconds,
-            .symbol = "min",
-            .translation = { .factor = 60, .power = 1 } });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsMinutes,
-            .kind = EcsU32
-        });
+#define FlecsRuleOrMarker ((int16_t)-2) /* Marks instruction in OR chain */
 
-        EcsHours = ecs_unit_init(world, &(ecs_unit_desc_t){
-            .entity = ecs_entity(world, { .name = "Hours" }),
-            .quantity = EcsDuration,
-            .base = EcsMinutes,
-            .symbol = "h",
-            .translation = { .factor = 60, .power = 1 } });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsHours,
-            .kind = EcsU32
-        });
+ecs_var_id_t flecs_query_find_var_id(
+    const ecs_query_impl_t *query,
+    const char *name,
+    ecs_var_kind_t kind)
+{
+    ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        EcsDays = ecs_unit_init(world, &(ecs_unit_desc_t){
-            .entity = ecs_entity(world, { .name = "Days" }),
-            .quantity = EcsDuration,
-            .base = EcsHours,
-            .symbol = "d",
-            .translation = { .factor = 24, .power = 1 } });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsDays,
-            .kind = EcsU32
-        });
-    ecs_set_scope(world, prev_scope);
+    if (kind == EcsVarTable) {
+        if (!ecs_os_strcmp(name, EcsThisName)) {
+            if (query->has_table_this) {
+                return 0;
+            } else {
+                return EcsVarNone;
+            }
+        }
 
-    /* Time units */
+        if (!flecs_name_index_is_init(&query->tvar_index)) {
+            return EcsVarNone;
+        }
 
-    EcsTime = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Time" });
-    prev_scope = ecs_set_scope(world, EcsTime);
+        uint64_t index = flecs_name_index_find(
+            &query->tvar_index, name, 0, 0);
+        if (index == 0) {
+            return EcsVarNone;
+        }
+        return flecs_utovar(index);
+    }
 
-        EcsDate = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Date" }),
-            .quantity = EcsTime });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsDate,
-            .kind = EcsU32
-        });
-    ecs_set_scope(world, prev_scope);
+    if (kind == EcsVarEntity) {
+        if (!flecs_name_index_is_init(&query->evar_index)) {
+            return EcsVarNone;
+        }
 
-    /* Mass units */
+        uint64_t index = flecs_name_index_find(
+            &query->evar_index, name, 0, 0);
+        if (index == 0) {
+            return EcsVarNone;
+        }
+        return flecs_utovar(index);
+    }
 
-    EcsMass = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Mass" });
-    prev_scope = ecs_set_scope(world, EcsMass);
-        EcsGrams = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Grams" }),
-            .quantity = EcsMass,
-            .symbol = "g" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsGrams,
-            .kind = EcsF32
-        });
-        EcsKiloGrams = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "KiloGrams" }),
-            .quantity = EcsMass,
-            .prefix = EcsKilo,
-            .base = EcsGrams });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsKiloGrams,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+    ecs_assert(kind == EcsVarAny, ECS_INTERNAL_ERROR, NULL);
 
-    /* Electric current units */
+    /* If searching for any kind of variable, start with most specific */
+    ecs_var_id_t index = flecs_query_find_var_id(query, name, EcsVarEntity);
+    if (index != EcsVarNone) {
+        return index;
+    }
 
-    EcsElectricCurrent = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "ElectricCurrent" });
-    prev_scope = ecs_set_scope(world, EcsElectricCurrent);
-        EcsAmpere = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Ampere" }),
-            .quantity = EcsElectricCurrent,
-            .symbol = "A" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsAmpere,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+    return flecs_query_find_var_id(query, name, EcsVarTable);
+}
 
-    /* Amount of substance units */
+static
+ecs_var_id_t flecs_query_most_specific_var(
+    ecs_query_impl_t *query,
+    const char *name,
+    ecs_var_kind_t kind,
+    ecs_query_compile_ctx_t *ctx)
+{
+    if (kind == EcsVarTable || kind == EcsVarEntity) {
+        return flecs_query_find_var_id(query, name, kind);
+    }
 
-    EcsAmount = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Amount" });
-    prev_scope = ecs_set_scope(world, EcsAmount);
-        EcsMole = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Mole" }),
-            .quantity = EcsAmount,
-            .symbol = "mol" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsMole,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+    ecs_var_id_t evar = flecs_query_find_var_id(query, name, EcsVarEntity);
+    if ((evar != EcsVarNone) && flecs_query_is_written(evar, ctx->written)) {
+        /* If entity variable is available and written to, it contains the most
+         * specific result and should be used. */
+        return evar;
+    }
 
-    /* Luminous intensity units */
+    ecs_var_id_t tvar = flecs_query_find_var_id(query, name, EcsVarTable);
+    if ((tvar != EcsVarNone) && !flecs_query_is_written(tvar, ctx->written)) {
+        /* If variable of any kind is requested and variable hasn't been written
+         * yet, write to table variable */
+        return tvar;
+    }
 
-    EcsLuminousIntensity = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "LuminousIntensity" });
-    prev_scope = ecs_set_scope(world, EcsLuminousIntensity);
-        EcsCandela = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Candela" }),
-            .quantity = EcsLuminousIntensity,
-            .symbol = "cd" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsCandela,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+    /* If table var is written, and entity var doesn't exist or is not written,
+     * return table var */
+    if (tvar != EcsVarNone) {
+        return tvar;
+    } else {
+        return evar;
+    }
+}
 
-    /* Force units */
+ecs_query_lbl_t flecs_query_op_insert(
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t *elem = ecs_vec_append_t(NULL, ctx->ops, ecs_query_op_t);
+    int32_t count = ecs_vec_count(ctx->ops);
+    *elem = *op;
+    if (count > 1) {
+        if (ctx->cur->lbl_begin == -1) {
+            /* Variables written by previous instruction can't be written by
+             * this instruction, except when this is part of an OR chain. */
+            elem->written &= ~elem[-1].written;
+        }
+    }
 
-    EcsForce = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Force" });
-    prev_scope = ecs_set_scope(world, EcsForce);
-        EcsNewton = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Newton" }),
-            .quantity = EcsForce,
-            .symbol = "N" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsNewton,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+    elem->next = flecs_itolbl(count);
+    elem->prev = flecs_itolbl(count - 2);
+    return flecs_itolbl(count - 1);
+}
 
-    /* Length units */
+ecs_query_op_t* flecs_query_begin_block(
+    ecs_query_op_kind_t kind,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t op = {0};
+    op.kind = flecs_ito(uint8_t, kind);
+    ctx->cur->lbl_begin = flecs_query_op_insert(&op, ctx);
+    return ecs_vec_get_t(ctx->ops, ecs_query_op_t, ctx->cur->lbl_begin);
+}
 
-    EcsLength = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Length" });
-    prev_scope = ecs_set_scope(world, EcsLength);
-        EcsMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Meters" }),
-            .quantity = EcsLength,
-            .symbol = "m" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsMeters,
-            .kind = EcsF32
-        });
+void flecs_query_end_block(
+    ecs_query_compile_ctx_t *ctx,
+    bool reset)
+{
+    ecs_query_op_t new_op = {0};
+    new_op.kind = EcsQueryEnd;
+    ecs_query_lbl_t end = flecs_query_op_insert(&new_op, ctx);
+    
+    ecs_query_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_query_op_t);
+    ops[ctx->cur->lbl_begin].next = end;
 
-            EcsPicoMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "PicoMeters" }),
-                .quantity = EcsLength,
-                .base = EcsMeters,
-                .prefix = EcsPico });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsPicoMeters,
-                .kind = EcsF32
-            });
+    ecs_query_op_t *end_op = &ops[end];
+    if (reset && ctx->cur->lbl_query != -1) {
+        ecs_query_op_t *query_op = &ops[ctx->cur->lbl_query];
+        end_op->prev = ctx->cur->lbl_begin;
+        end_op->src = query_op->src;
+        end_op->first = query_op->first;
+        end_op->second = query_op->second;
+        end_op->flags = query_op->flags;
+        end_op->field_index = query_op->field_index;
+    } else {
+        end_op->prev = ctx->cur->lbl_begin;
+        end_op->field_index = -1;
+    }
 
-            EcsNanoMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "NanoMeters" }),
-                .quantity = EcsLength,
-                .base = EcsMeters,
-                .prefix = EcsNano });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsNanoMeters,
-                .kind = EcsF32
-            });
+    ctx->cur->lbl_begin = -1;
+}
 
-            EcsMicroMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "MicroMeters" }),
-                .quantity = EcsLength,
-                .base = EcsMeters,
-                .prefix = EcsMicro });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsMicroMeters,
-                .kind = EcsF32
-            });
+static
+void flecs_query_begin_block_cond_eval(
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_write_flags_t cond_write_state)
+{
+    ecs_var_id_t first_var = EcsVarNone, second_var = EcsVarNone, src_var = EcsVarNone;
+    ecs_write_flags_t cond_mask = 0;
 
-            EcsMilliMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "MilliMeters" }),
-                .quantity = EcsLength,
-                .base = EcsMeters,
-                .prefix = EcsMilli });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsMilliMeters,
-                .kind = EcsF32
-            });
+    if (flecs_query_ref_flags(op->flags, EcsQueryFirst) == EcsQueryIsVar) {
+        first_var = op->first.var;
+        ecs_assert(first_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        cond_mask |= (1ull << first_var);
+    }
+    if (flecs_query_ref_flags(op->flags, EcsQuerySecond) == EcsQueryIsVar) {
+        second_var = op->second.var;
+        ecs_assert(second_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        cond_mask |= (1ull << second_var);
+    }
+    if (flecs_query_ref_flags(op->flags, EcsQuerySrc) == EcsQueryIsVar) {
+        src_var = op->src.var;
+        ecs_assert(src_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        cond_mask |= (1ull << src_var);
+    }
 
-            EcsCentiMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "CentiMeters" }),
-                .quantity = EcsLength,
-                .base = EcsMeters,
-                .prefix = EcsCenti });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsCentiMeters,
-                .kind = EcsF32
-            });
+    /* Variables set in an OR chain are marked as conditional writes. However, 
+     * writes from previous terms in the current OR chain shouldn't be treated
+     * as variables that are conditionally set, so instead use the write mask 
+     * from before the chain started. */
+    if (ctx->ctrlflow->in_or) {
+        cond_write_state = ctx->ctrlflow->cond_written_or;
+    }
 
-            EcsKiloMeters = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "KiloMeters" }),
-                .quantity = EcsLength,
-                .base = EcsMeters,
-                .prefix = EcsKilo });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsKiloMeters,
-                .kind = EcsF32
-            });
-            
-        EcsMiles = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Miles" }),
-            .quantity = EcsLength,
-            .symbol = "mi"
-        });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsMiles,
-            .kind = EcsF32
-        });
+    /* If this term uses conditionally set variables, insert instruction that
+     * jumps over the term if the variables weren't set yet. */
+    if (cond_mask & cond_write_state) {
+        ctx->cur->lbl_cond_eval = flecs_itolbl(ecs_vec_count(ctx->ops));
 
-        EcsPixels = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Pixels" }),
-            .quantity = EcsLength,
-            .symbol = "px"
-        });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsPixels,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+        ecs_query_op_t jmp_op = {0};
+        jmp_op.kind = EcsQueryIfVar;
 
-    /* Pressure units */
+        if ((first_var != EcsVarNone) && cond_write_state & (1ull << first_var)) {
+            jmp_op.flags |= (EcsQueryIsVar << EcsQueryFirst);
+            jmp_op.first.var = first_var;
+        }
+        if ((second_var != EcsVarNone) && cond_write_state & (1ull << second_var)) {
+            jmp_op.flags |= (EcsQueryIsVar << EcsQuerySecond);
+            jmp_op.second.var = second_var;
+        }
+        if ((src_var != EcsVarNone) && cond_write_state & (1ull << src_var)) {
+            jmp_op.flags |= (EcsQueryIsVar << EcsQuerySrc);
+            jmp_op.src.var = src_var;
+        }
 
-    EcsPressure = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Pressure" });
-    prev_scope = ecs_set_scope(world, EcsPressure);
-        EcsPascal = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Pascal" }),
-            .quantity = EcsPressure,
-            .symbol = "Pa" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsPascal,
-            .kind = EcsF32
-        });
-        EcsBar = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Bar" }),
-            .quantity = EcsPressure,
-            .symbol = "bar" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsBar,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+        flecs_query_op_insert(&jmp_op, ctx);
+    } else {
+        ctx->cur->lbl_cond_eval = -1;
+    }
+}
 
-    /* Speed units */
+static
+void flecs_query_end_block_cond_eval(
+    ecs_query_compile_ctx_t *ctx)
+{
+    if (ctx->cur->lbl_cond_eval == -1) {
+        return;
+    }
 
-    EcsSpeed = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Speed" });
-    prev_scope = ecs_set_scope(world, EcsSpeed);
-        EcsMetersPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "MetersPerSecond" }),
-            .quantity = EcsSpeed,
-            .base = EcsMeters,
-            .over = EcsSeconds });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsMetersPerSecond,
-            .kind = EcsF32
-        });
-        EcsKiloMetersPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "KiloMetersPerSecond" }),
-            .quantity = EcsSpeed,
-            .base = EcsKiloMeters,
-            .over = EcsSeconds });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsKiloMetersPerSecond,
-            .kind = EcsF32
-        });
-        EcsKiloMetersPerHour = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "KiloMetersPerHour" }),
-            .quantity = EcsSpeed,
-            .base = EcsKiloMeters,
-            .over = EcsHours });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsKiloMetersPerHour,
-            .kind = EcsF32
-        });
-        EcsMilesPerHour = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "MilesPerHour" }),
-            .quantity = EcsSpeed,
-            .base = EcsMiles,
-            .over = EcsHours });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsMilesPerHour,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
-    
-    /* Acceleration */
+    ecs_assert(ctx->cur->lbl_query >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_query_op_t end_op = {0};
+    end_op.kind = EcsQueryEnd;
+    ecs_query_lbl_t end = flecs_query_op_insert(&end_op, ctx);
 
-    EcsAcceleration = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-        .entity = ecs_entity(world, { .name = "Acceleration" }),
-        .base = EcsMetersPerSecond,
-        .over = EcsSeconds });
-    ecs_quantity_init(world, &(ecs_entity_desc_t){
-        .id = EcsAcceleration
-    });
-    ecs_primitive_init(world, &(ecs_primitive_desc_t){
-        .entity = EcsAcceleration,
-        .kind = EcsF32
-    });
+    ecs_query_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_query_op_t);
+    ops[ctx->cur->lbl_cond_eval].next = end;
 
-    /* Temperature units */
+    ecs_query_op_t *end_op_ptr = &ops[end];
+    ecs_query_op_t *query_op = &ops[ctx->cur->lbl_query];
+    end_op_ptr->prev = ctx->cur->lbl_cond_eval;
+    end_op_ptr->src = query_op->src;
+    end_op_ptr->first = query_op->first;
+    end_op_ptr->second = query_op->second;
+    end_op_ptr->flags = query_op->flags;
+    end_op_ptr->field_index = query_op->field_index;
+}
 
-    EcsTemperature = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Temperature" });
-    prev_scope = ecs_set_scope(world, EcsTemperature);
-        EcsKelvin = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Kelvin" }),
-            .quantity = EcsTemperature,
-            .symbol = "K" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsKelvin,
-            .kind = EcsF32
-        });
-        EcsCelsius = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Celsius" }),
-            .quantity = EcsTemperature,
-            .symbol = "°C" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsCelsius,
-            .kind = EcsF32
-        });
-        EcsFahrenheit = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Fahrenheit" }),
-            .quantity = EcsTemperature,
-            .symbol = "F" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsFahrenheit,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+static
+void flecs_query_begin_block_or(
+    ecs_query_op_t *op,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t *or_op = flecs_query_begin_block(EcsQueryNot, ctx);
+    or_op->kind = EcsQueryOr;
 
-    /* Data units */
+    /* Set the source of the evaluate terms as source of the Or instruction. 
+     * This lets the engine determine whether the variable has already been
+     * written. When the source is not yet written, an OR operation needs to
+     * take the union of all the terms in the OR chain. When the variable is
+     * known, it will return after the first matching term.
+     * 
+     * In case a term in the OR expression is an equality predicate which 
+     * compares the left hand side with a variable, the variable acts as an 
+     * alias, so we can always assume that it's written. */
+    bool add_src = true;
+    if (ECS_TERM_REF_ID(&term->first) == EcsPredEq && term->second.id & EcsIsVariable) {
+        if (!(flecs_query_is_written(op->src.var, ctx->written))) {
+            add_src = false;
+        }
+    }
 
-    EcsData = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Data" });
-    prev_scope = ecs_set_scope(world, EcsData);
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        if (add_src) {
+            or_op->flags = (EcsQueryIsVar << EcsQuerySrc);
+            or_op->src = op->src;
+            ctx->cur->src_or = op->src;
+        }
 
-        EcsBits = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Bits" }),
-            .quantity = EcsData,
-            .symbol = "bit" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsBits,
-            .kind = EcsU64
-        });
+        ctx->cur->src_written_or = flecs_query_is_written(
+            op->src.var, ctx->written);
+    }
+}
 
-            EcsKiloBits = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "KiloBits" }),
-                .quantity = EcsData,
-                .base = EcsBits,
-                .prefix = EcsKilo });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsKiloBits,
-                .kind = EcsU64
-            });
+static
+void flecs_query_end_block_or(
+    ecs_query_impl_t *impl,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t op = {0};
+    op.kind = EcsQueryEnd;
+    ecs_query_lbl_t end = flecs_query_op_insert(&op, ctx);
 
-            EcsMegaBits = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "MegaBits" }),
-                .quantity = EcsData,
-                .base = EcsBits,
-                .prefix = EcsMega });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsMegaBits,
-                .kind = EcsU64
-            });
+    ecs_query_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_query_op_t);
+    int32_t i, prev_or = ctx->cur->lbl_begin + 1;
+    for (i = ctx->cur->lbl_begin + 1; i < end; i ++) {
+        if (ops[i].next == FlecsRuleOrMarker) {
+            if (i == (end - 1)) {
+                ops[prev_or].prev = ctx->cur->lbl_begin;
+            } else {
+                ops[prev_or].prev = flecs_itolbl(i + 1);
+            }
 
-            EcsGigaBits = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "GigaBits" }),
-                .quantity = EcsData,
-                .base = EcsBits,
-                .prefix = EcsGiga });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsGigaBits,
-                .kind = EcsU64
-            });
+            ops[i].next = flecs_itolbl(end);
 
-        EcsBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Bytes" }),
-            .quantity = EcsData,
-            .symbol = "B",
-            .base = EcsBits,
-            .translation = { .factor = 8, .power = 1 } });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsBytes,
-            .kind = EcsU64
-        });
+            prev_or = i + 1;
+        }
+    }
 
-            EcsKiloBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "KiloBytes" }),
-                .quantity = EcsData,
-                .base = EcsBytes,
-                .prefix = EcsKilo });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsKiloBytes,
-                .kind = EcsU64
-            });
+    ecs_query_op_t *first = &ops[ctx->cur->lbl_begin];
+    bool src_is_var = first->flags & (EcsQueryIsVar << EcsQuerySrc);
+    first->next = flecs_itolbl(end);
+    ops[end].prev = ctx->cur->lbl_begin;
+    ops[end - 1].prev = ctx->cur->lbl_begin;
 
-            EcsMegaBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "MegaBytes" }),
-                .quantity = EcsData,
-                .base = EcsBytes,
-                .prefix = EcsMega });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsMegaBytes,
-                .kind = EcsU64
-            });
+    ctx->ctrlflow->in_or = false;
+    ctx->cur->lbl_begin = -1;
+    if (src_is_var) {
+        ecs_var_id_t src_var = first->src.var;
+        ctx->written |= (1llu << src_var);
 
-            EcsGigaBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "GigaBytes" }),
-                .quantity = EcsData,
-                .base = EcsBytes,
-                .prefix = EcsGiga });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsGigaBytes,
-                .kind = EcsU64
-            });
+        /* If src is a table variable, it is possible that this was resolved to
+         * an entity variable in all of the OR terms. If this is the case, mark
+         * entity variable as written as well. */
+        ecs_query_var_t *var = &impl->vars[src_var];
+        if (var->kind == EcsVarTable) {
+            const char *name = var->name;
+            if (!name) {
+                name = "this";
+            }
 
-            EcsKibiBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "KibiBytes" }),
-                .quantity = EcsData,
-                .base = EcsBytes,
-                .prefix = EcsKibi });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsKibiBytes,
-                .kind = EcsU64
-            });
+            ecs_var_id_t evar = flecs_query_find_var_id(
+                impl, name, EcsVarEntity);
+            if (evar != EcsVarNone && (ctx->cond_written & (1llu << evar))) {
+                ctx->written |= (1llu << evar);
+                ctx->cond_written &= ~(1llu << evar);
+            }
+        }
+    }
+    ctx->written |= ctx->cond_written;
 
-            EcsMebiBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "MebiBytes" }),
-                .quantity = EcsData,
-                .base = EcsBytes,
-                .prefix = EcsMebi });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsMebiBytes,
-                .kind = EcsU64
-            });
+    /* Scan which variables were conditionally written in the OR chain and 
+     * reset instructions after the OR chain. If a variable is set in part one
+     * of a chain but not part two, there would be nothing writing to the
+     * variable in part two, leaving it to the previous value. To address this
+     * a reset is inserted that resets the variable value on redo. */
+    for (i = 1; i < (8 * ECS_SIZEOF(ecs_write_flags_t)); i ++) {
+        ecs_write_flags_t prev = 1 & (ctx->ctrlflow->cond_written_or >> i);
+        ecs_write_flags_t cur = 1 & (ctx->cond_written >> i);
 
-            EcsGibiBytes = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "GibiBytes" }),
-                .quantity = EcsData,
-                .base = EcsBytes,
-                .prefix = EcsGibi });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsGibiBytes,
-                .kind = EcsU64
-            });
+        /* Skip variable if it's the source for the OR chain */
+        if (src_is_var && (i == first->src.var)) {
+            continue;
+        }
 
-    ecs_set_scope(world, prev_scope);
+        if (!prev && cur) {
+            ecs_query_op_t reset_op = {0};
+            reset_op.kind = EcsQueryReset;
+            reset_op.flags |= (EcsQueryIsVar << EcsQuerySrc);
+            reset_op.src.var = flecs_itovar(i);
+            flecs_query_op_insert(&reset_op, ctx);
+        }
+    }
+}
 
-    /* DataRate units */
+void flecs_query_insert_each(
+    ecs_var_id_t tvar,
+    ecs_var_id_t evar,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
+{
+    ecs_query_op_t each = {0};
+    each.kind = EcsQueryEach;
+    each.src.var = evar;
+    each.first.var = tvar;
+    each.flags = (EcsQueryIsVar << EcsQuerySrc) | 
+                 (EcsQueryIsVar << EcsQueryFirst);
+    flecs_query_write_ctx(evar, ctx, cond_write);
+    flecs_query_write(evar, &each.written);
+    flecs_query_op_insert(&each, ctx);
+}
 
-    EcsDataRate = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "DataRate" });
-    prev_scope = ecs_set_scope(world, EcsDataRate);
+static
+void flecs_query_insert_lookup(
+    ecs_var_id_t base_var,
+    ecs_var_id_t evar,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
+{
+    ecs_query_op_t lookup = {0};
+    lookup.kind = EcsQueryLookup;
+    lookup.src.var = evar;
+    lookup.first.var = base_var;
+    lookup.flags = (EcsQueryIsVar << EcsQuerySrc) | 
+                 (EcsQueryIsVar << EcsQueryFirst);
+    flecs_query_write_ctx(evar, ctx, cond_write);
+    flecs_query_write(evar, &lookup.written);
+    flecs_query_op_insert(&lookup, ctx);
+}
 
-        EcsBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "BitsPerSecond" }),
-            .quantity = EcsDataRate,
-            .base = EcsBits,
-            .over = EcsSeconds });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsBitsPerSecond,
-            .kind = EcsU64
-        });
+static
+void flecs_query_insert_unconstrained_transitive(
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
+{
+    /* Create anonymous variable to store the target ids. This will return the
+     * list of targets without constraining the variable of the term, which
+     * needs to stay variable to find all transitive relationships for a src. */
+    ecs_var_id_t tgt = flecs_query_add_var(query, NULL, NULL, EcsVarEntity);
+    flecs_set_var_label(&query->vars[tgt], query->vars[op->second.var].name);
 
-            EcsKiloBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "KiloBitsPerSecond" }),
-                .quantity = EcsDataRate,
-                .base = EcsKiloBits,
-                .over = EcsSeconds
-            });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsKiloBitsPerSecond,
-                .kind = EcsU64
-            });
+    /* First, find ids to start traversal from. This fixes op.second. */
+    ecs_query_op_t find_ids = {0};
+    find_ids.kind = EcsQueryIdsRight;
+    find_ids.field_index = -1;
+    find_ids.first = op->first;
+    find_ids.second = op->second;
+    find_ids.flags = op->flags;
+    find_ids.flags &= (ecs_flags8_t)~((EcsQueryIsVar|EcsQueryIsEntity) << EcsQuerySrc);
+    find_ids.second.var = tgt;
+    flecs_query_write_ctx(tgt, ctx, cond_write);
+    flecs_query_write(tgt, &find_ids.written);
+    flecs_query_op_insert(&find_ids, ctx);
 
-            EcsMegaBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "MegaBitsPerSecond" }),
-                .quantity = EcsDataRate,
-                .base = EcsMegaBits,
-                .over = EcsSeconds
-            });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsMegaBitsPerSecond,
-                .kind = EcsU64
-            });
+    /* Next, iterate all tables for the ids. This fixes op.src */
+    ecs_query_op_t and_op = {0};
+    and_op.kind = EcsQueryAnd;
+    and_op.field_index = op->field_index;
+    and_op.first = op->first;
+    and_op.second = op->second;
+    and_op.src = op->src;
+    and_op.flags = op->flags | EcsQueryIsSelf;
+    and_op.second.var = tgt;
+    flecs_query_write_ctx(and_op.src.var, ctx, cond_write);
+    flecs_query_write(and_op.src.var, &and_op.written);
+    flecs_query_op_insert(&and_op, ctx);
+}
 
-            EcsGigaBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "GigaBitsPerSecond" }),
-                .quantity = EcsDataRate,
-                .base = EcsGigaBits,
-                .over = EcsSeconds
-            });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsGigaBitsPerSecond,
-                .kind = EcsU64
-            });
+static
+void flecs_query_insert_inheritance(
+    ecs_query_impl_t *query,
+    ecs_term_t *term,
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
+{
+    /* Anonymous variable to store the resolved component ids */
+    ecs_var_id_t tvar = flecs_query_add_var(query, NULL, NULL, EcsVarTable);
+    ecs_var_id_t evar = flecs_query_add_var(query, NULL, NULL, EcsVarEntity);
 
-        EcsBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "BytesPerSecond" }),
-            .quantity = EcsDataRate,
-            .base = EcsBytes,
-            .over = EcsSeconds });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsBytesPerSecond,
-            .kind = EcsU64
-        });
+    flecs_set_var_label(&query->vars[tvar], ecs_get_name(query->pub.world, 
+        ECS_TERM_REF_ID(&term->first)));
+    flecs_set_var_label(&query->vars[evar], ecs_get_name(query->pub.world, 
+        ECS_TERM_REF_ID(&term->first)));
 
-            EcsKiloBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "KiloBytesPerSecond" }),
-                .quantity = EcsDataRate,
-                .base = EcsKiloBytes,
-                .over = EcsSeconds
-            });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsKiloBytesPerSecond,
-                .kind = EcsU64
-            });
+    ecs_query_op_t trav_op = {0};
+    trav_op.kind = EcsQueryTrav;
+    trav_op.field_index = -1;
+    trav_op.first.entity = EcsIsA;
+    trav_op.second.entity = ECS_TERM_REF_ID(&term->first);
+    trav_op.src.var = tvar;
+    trav_op.flags = EcsQueryIsSelf;
+    trav_op.flags |= (EcsQueryIsEntity << EcsQueryFirst);
+    trav_op.flags |= (EcsQueryIsEntity << EcsQuerySecond);
+    trav_op.flags |= (EcsQueryIsVar << EcsQuerySrc);
+    trav_op.written |= (1ull << tvar);
+    if (term->first.id & EcsSelf) {
+        trav_op.match_flags |= EcsTermReflexive;
+    }
+    flecs_query_op_insert(&trav_op, ctx);
+    flecs_query_insert_each(tvar, evar, ctx, cond_write);
 
-            EcsMegaBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "MegaBytesPerSecond" }),
-                .quantity = EcsDataRate,
-                .base = EcsMegaBytes,
-                .over = EcsSeconds
-            });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsMegaBytesPerSecond,
-                .kind = EcsU64
-            });
+    ecs_query_ref_t r = { .var = evar };
+    op->first = r;
+    op->flags &= (ecs_flags8_t)~(EcsQueryIsEntity << EcsQueryFirst);
+    op->flags |= (EcsQueryIsVar << EcsQueryFirst);
+}
 
-            EcsGigaBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-                .entity = ecs_entity(world, { .name = "GigaBytesPerSecond" }),
-                .quantity = EcsDataRate,
-                .base = EcsGigaBytes,
-                .over = EcsSeconds
-            });
-            ecs_primitive_init(world, &(ecs_primitive_desc_t){
-                .entity = EcsGigaBytesPerSecond,
-                .kind = EcsU64
-            });
+void flecs_query_compile_term_ref(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_term_ref_t *term_ref,
+    ecs_query_ref_t *ref,
+    ecs_flags8_t ref_kind,
+    ecs_var_kind_t kind,
+    ecs_query_compile_ctx_t *ctx,
+    bool create_wildcard_vars)
+{
+    (void)world;
 
-        ecs_set_scope(world, prev_scope);
+    if (!ecs_term_ref_is_set(term_ref)) {
+        return;
+    }
 
-    /* Percentage */
+    if (term_ref->id & EcsIsVariable) {
+        op->flags |= (ecs_flags8_t)(EcsQueryIsVar << ref_kind);
+        const char *name = flecs_term_ref_var_name(term_ref);
+        if (name) {
+            ref->var = flecs_query_most_specific_var(query, name, kind, ctx);
+            ecs_assert(ref->var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        } else if (create_wildcard_vars) {
+            bool is_wildcard = flecs_term_ref_is_wildcard(term_ref);
+            if (is_wildcard && (kind == EcsVarAny)) {
+                ref->var = flecs_query_add_var(query, NULL, NULL, EcsVarTable);
+            } else {
+                ref->var = flecs_query_add_var(query, NULL, NULL, EcsVarEntity);
+            }
+            if (is_wildcard) {
+                flecs_set_var_label(&query->vars[ref->var], 
+                    ecs_get_name(world, ECS_TERM_REF_ID(term_ref)));
+            }
+            ecs_assert(ref->var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        }
+    }
 
-    EcsPercentage = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Percentage" });
-    ecs_unit_init(world, &(ecs_unit_desc_t){ 
-        .entity = EcsPercentage,
-        .symbol = "%"
-    });
-    ecs_primitive_init(world, &(ecs_primitive_desc_t){
-        .entity = EcsPercentage,
-        .kind = EcsF32
-    });
+    if (term_ref->id & EcsIsEntity) {
+        op->flags |= (ecs_flags8_t)(EcsQueryIsEntity << ref_kind);
+        ref->entity = ECS_TERM_REF_ID(term_ref);
+    }
+}
 
-    /* Angles */
+static
+int flecs_query_compile_ensure_vars(
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write,
+    bool *written_out)
+{
+    ecs_flags16_t flags = flecs_query_ref_flags(op->flags, ref_kind);
+    bool written = false;
+
+    if (flags & EcsQueryIsVar) {
+        ecs_var_id_t var_id = ref->var;
+        ecs_query_var_t *var = &query->vars[var_id];
+
+        if (var->kind == EcsVarEntity && 
+            !flecs_query_is_written(var_id, ctx->written)) 
+        {
+            /* If entity variable is not yet written but a table variant exists
+             * that has been written, insert each operation to translate from
+             * entity variable to table */
+            ecs_var_id_t tvar = var->table_id;
+            if ((tvar != EcsVarNone) && 
+                flecs_query_is_written(tvar, ctx->written)) 
+            {
+                if (var->lookup) {
+                    if (!flecs_query_is_written(tvar, ctx->written)) {
+                        ecs_err("dependent variable of '$%s' is not written", 
+                            var->name);
+                        return -1;
+                    }
+
+                    if (!flecs_query_is_written(var->base_id, ctx->written)) {
+                        flecs_query_insert_each(
+                            tvar, var->base_id, ctx, cond_write);
+                    }
+                } else {
+                    flecs_query_insert_each(tvar, var_id, ctx, cond_write);
+                }
+
+                /* Variable was written, just not as entity */
+                written = true;
+            } else if (var->lookup) {
+                if (!flecs_query_is_written(var->base_id, ctx->written)) {
+                    ecs_err("dependent variable of '$%s' is not written", 
+                        var->name);
+                    return -1;
+                }
+            }
+        }
+
+        written |= flecs_query_is_written(var_id, ctx->written);
+    } else {
+        /* If it's not a variable, it's always written */
+        written = true;
+    }
+
+    if (written_out) {
+        *written_out = written;
+    }
+
+    return 0;
+}
+
+static
+bool flecs_query_compile_lookup(
+    ecs_query_impl_t *query,
+    ecs_var_id_t var_id,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write) 
+{
+    ecs_query_var_t *var = &query->vars[var_id];
+    if (var->lookup) {
+        flecs_query_insert_lookup(var->base_id, var_id, ctx, cond_write);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+static
+void flecs_query_insert_contains(
+    ecs_query_impl_t *query,
+    ecs_var_id_t src_var,
+    ecs_var_id_t other_var,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t contains = {0};
+    if ((src_var != other_var) && (src_var == query->vars[other_var].table_id)) {
+        contains.kind = EcsQueryContain;
+        contains.src.var = src_var;
+        contains.first.var = other_var;
+        contains.flags |= (EcsQueryIsVar << EcsQuerySrc) | 
+                          (EcsQueryIsVar << EcsQueryFirst);
+        flecs_query_op_insert(&contains, ctx);
+    }
+}
+
+static
+void flecs_query_insert_pair_eq(
+    int32_t field_index,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t contains = {0};
+    contains.kind = EcsQueryPairEq;
+    contains.field_index = flecs_ito(int8_t, field_index);
+    flecs_query_op_insert(&contains, ctx);
+}
+
+static
+int flecs_query_compile_builtin_pred(
+    ecs_query_t *q,
+    ecs_term_t *term,
+    ecs_query_op_t *op,
+    ecs_write_flags_t write_state)
+{
+    ecs_entity_t id = ECS_TERM_REF_ID(&term->first);
+
+    ecs_query_op_kind_t eq[] = {EcsQueryPredEq, EcsQueryPredNeq};
+    ecs_query_op_kind_t eq_name[] = {EcsQueryPredEqName, EcsQueryPredNeqName};
+    ecs_query_op_kind_t eq_match[] = {EcsQueryPredEqMatch, EcsQueryPredNeqMatch};
+    
+    ecs_flags16_t flags_src = flecs_query_ref_flags(op->flags, EcsQuerySrc);
+    ecs_flags16_t flags_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+
+    if (id == EcsPredEq) {
+        if (term->second.id & EcsIsName) {
+            op->kind = flecs_ito(uint8_t, eq_name[term->oper == EcsNot]);
+        } else {
+            op->kind = flecs_ito(uint8_t, eq[term->oper == EcsNot]);
+        }
+    } else if (id == EcsPredMatch) {
+        op->kind = flecs_ito(uint8_t, eq_match[term->oper == EcsNot]);
+    }
+
+    if (flags_2nd & EcsQueryIsVar) {
+        if (!(write_state & (1ull << op->second.var))) {
+            ecs_err("uninitialized variable '%s' on right-hand side of "
+                "equality operator", ecs_query_var_name(q, op->second.var));
+            return -1;
+        }
+    }
+
+    ecs_assert(flags_src & EcsQueryIsVar, ECS_INTERNAL_ERROR, NULL);
+    (void)flags_src;
+
+    if (!(write_state & (1ull << op->src.var))) {
+        /* If this is an == operator with a right-hand side that resolves to a
+         * single entity, the left-hand side is allowed to be undefined, as the
+         * instruction will be evaluated as an assignment. */
+        if (op->kind != EcsQueryPredEq && op->kind != EcsQueryPredEqName) {
+            ecs_err("uninitialized variable '%s' on left-hand side of "
+                "equality operator", ecs_query_var_name(q, op->src.var));
+            return -1;
+        }
+    }
+
+    return 0;
+}
 
-    EcsAngle = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Angle" });
-    prev_scope = ecs_set_scope(world, EcsAngle);
-        EcsRadians = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Radians" }),
-            .quantity = EcsAngle,
-            .symbol = "rad" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsRadians,
-            .kind = EcsF32
-        });
+static
+int flecs_query_ensure_scope_var(
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_var_id_t var = ref->var;
 
-        EcsDegrees = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Degrees" }),
-            .quantity = EcsAngle,
-            .symbol = "°" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsDegrees,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+    if (query->vars[var].kind == EcsVarEntity && 
+        !flecs_query_is_written(var, ctx->written)) 
+    {
+        ecs_var_id_t table_var = query->vars[var].table_id;
+        if (table_var != EcsVarNone && 
+            flecs_query_is_written(table_var, ctx->written)) 
+        {
+            if (flecs_query_compile_ensure_vars(
+                query, op, ref, ref_kind, ctx, false, NULL))
+            {
+                goto error;
+            }
+        }
+    }
 
-    /* DeciBel */
+    return 0;
+error:
+    return -1;
+}
 
-    EcsBel = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-        .entity = ecs_entity(world, { .name = "Bel" }),
-        .symbol = "B" });
-    ecs_primitive_init(world, &(ecs_primitive_desc_t){
-        .entity = EcsBel,
-        .kind = EcsF32
-    });
-    EcsDeciBel = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-        .entity = ecs_entity(world, { .name = "DeciBel" }),
-        .prefix = EcsDeci,
-        .base = EcsBel });
-    ecs_primitive_init(world, &(ecs_primitive_desc_t){
-        .entity = EcsDeciBel,
-        .kind = EcsF32
-    });
+static
+int flecs_query_ensure_scope_vars(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_term_t *term)
+{
+    /* If the scope uses variables as entity that have only been written as
+     * table, resolve them as entities before entering the scope. */
+    ecs_term_t *cur = term;
+    while(ECS_TERM_REF_ID(&cur->first) != EcsScopeClose) {
+        /* Dummy operation to obtain variable information for term */
+        ecs_query_op_t op = {0};
+        flecs_query_compile_term_ref(world, query, &op, &cur->first, 
+            &op.first, EcsQueryFirst, EcsVarEntity, ctx, false);
+        flecs_query_compile_term_ref(world, query, &op, &cur->second, 
+            &op.second, EcsQuerySecond, EcsVarEntity, ctx, false);
+
+        if (op.flags & (EcsQueryIsVar << EcsQueryFirst)) {
+            if (flecs_query_ensure_scope_var(
+                query, &op, &op.first, EcsQueryFirst, ctx))
+            {
+                goto error;
+            }
+        }
+        if (op.flags & (EcsQueryIsVar << EcsQuerySecond)) {
+            if (flecs_query_ensure_scope_var(
+                query, &op, &op.second, EcsQuerySecond, ctx))
+            {
+                goto error;
+            }
+        }
 
-    EcsFrequency = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Frequency" });
-    prev_scope = ecs_set_scope(world, EcsFrequency);
+        cur ++;
+    }
 
-        EcsHertz = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Hertz" }),
-            .quantity = EcsFrequency,
-            .symbol = "Hz" });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsHertz,
-            .kind = EcsF32
-        });
+    return 0;
+error:
+    return -1;
+}
 
-        EcsKiloHertz = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "KiloHertz" }),
-            .prefix = EcsKilo,
-            .base = EcsHertz });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsKiloHertz,
-            .kind = EcsF32
-        });
+static
+void flecs_query_compile_push(
+    ecs_query_compile_ctx_t *ctx)
+{
+    ctx->cur = &ctx->ctrlflow[++ ctx->scope];
+    ctx->cur->lbl_begin = -1;
+    ctx->cur->lbl_begin = -1;
+}
 
-        EcsMegaHertz = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "MegaHertz" }),
-            .prefix = EcsMega,
-            .base = EcsHertz });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsMegaHertz,
-            .kind = EcsF32
-        });
+static
+void flecs_query_compile_pop(
+    ecs_query_compile_ctx_t *ctx)
+{
+    ctx->cur = &ctx->ctrlflow[-- ctx->scope];
+}
 
-        EcsGigaHertz = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "GigaHertz" }),
-            .prefix = EcsGiga,
-            .base = EcsHertz });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsGigaHertz,
-            .kind = EcsF32
-        });
-    ecs_set_scope(world, prev_scope);
+static
+int flecs_query_compile_0_src(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx)
+{
+    /* If the term has a 0 source, check if it's a scope open/close */
+    if (ECS_TERM_REF_ID(&term->first) == EcsScopeOpen) {
+        if (flecs_query_ensure_scope_vars(world, impl, ctx, term)) {
+            goto error;
+        }
+        if (term->oper == EcsNot) {
+            ctx->scope_is_not |= (ecs_flags32_t)(1ull << ctx->scope);
+            flecs_query_begin_block(EcsQueryNot, ctx);
+        } else {
+            ctx->scope_is_not &= (ecs_flags32_t)~(1ull << ctx->scope);
+        }
+        flecs_query_compile_push(ctx);
+    } else if (ECS_TERM_REF_ID(&term->first) == EcsScopeClose) {
+        flecs_query_compile_pop(ctx);
+        if (ctx->scope_is_not & (ecs_flags32_t)(1ull << (ctx->scope))) {
+            flecs_query_end_block(ctx, false);
+        }
+    } else {
+        /* Noop */
+    }
 
-    EcsUri = ecs_quantity_init(world, &(ecs_entity_desc_t){ 
-        .name = "Uri" });
-    prev_scope = ecs_set_scope(world, EcsUri);
+    return 0;
+error:
+    return -1;
+}
 
-        EcsUriHyperlink = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Hyperlink" }),
-            .quantity = EcsUri });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsUriHyperlink,
-            .kind = EcsString
-        });
+static
+bool flecs_query_select_all(
+    ecs_term_t *term,
+    ecs_query_op_t *op,
+    ecs_var_id_t src_var,
+    ecs_query_compile_ctx_t *ctx)
+{
+    bool builtin_pred = flecs_term_is_builtin_pred(term);
+    bool pred_match = builtin_pred && ECS_TERM_REF_ID(&term->first) == EcsPredMatch;
 
-        EcsUriImage = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "Image" }),
-            .quantity = EcsUri });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsUriImage,
-            .kind = EcsString
-        });
+    if (term->oper == EcsNot || term->oper == EcsOptional || 
+        term->oper == EcsNotFrom || pred_match) 
+    {
+        ecs_query_op_t match_any = {0};
+        match_any.kind = EcsAnd;
+        match_any.flags = EcsQueryIsSelf | (EcsQueryIsEntity << EcsQueryFirst);
+        match_any.flags |= (EcsQueryIsVar << EcsQuerySrc);
+        match_any.src = op->src;
+        match_any.field_index = -1;
+        if (!pred_match) {
+            match_any.first.entity = EcsAny;
+        } else {
+            /* If matching by name, instead of finding all tables, just find
+             * the ones with a name. */
+            match_any.first.entity = ecs_id(EcsIdentifier);
+            match_any.second.entity = EcsName;
+            match_any.flags |= (EcsQueryIsEntity << EcsQuerySecond);
+        }
+        match_any.written = (1ull << src_var);
+        flecs_query_op_insert(&match_any, ctx);
+        flecs_query_write_ctx(op->src.var, ctx, false);
 
-        EcsUriFile = ecs_unit_init(world, &(ecs_unit_desc_t){ 
-            .entity = ecs_entity(world, { .name = "File" }),
-            .quantity = EcsUri });
-        ecs_primitive_init(world, &(ecs_primitive_desc_t){
-            .entity = EcsUriFile,
-            .kind = EcsString
-        });
-    ecs_set_scope(world, prev_scope);
+        /* Update write administration */
+        return true;
+    }
+    return false;
+}
 
-    /* Documentation */
-#ifdef FLECS_DOC
-    ECS_IMPORT(world, FlecsDoc);
+#ifdef FLECS_META
+static
+int flecs_query_compile_begin_member_term(
+    ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_entity_t first_id)
+{
+    ecs_assert(first_id != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(first_id & EcsIsEntity, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_doc_set_brief(world, EcsDuration, 
-        "Time amount (e.g. \"20 seconds\", \"2 hours\")");
-    ecs_doc_set_brief(world, EcsSeconds, "Time amount in seconds");
-    ecs_doc_set_brief(world, EcsMinutes, "60 seconds");
-    ecs_doc_set_brief(world, EcsHours, "60 minutes");
-    ecs_doc_set_brief(world, EcsDays, "24 hours");
+    first_id = ECS_TERM_REF_ID(&term->first);
 
-    ecs_doc_set_brief(world, EcsTime,
-        "Time passed since an epoch (e.g. \"5pm\", \"March 3rd 2022\")");
-    ecs_doc_set_brief(world, EcsDate,
-        "Seconds passed since January 1st 1970");
+    /* First compile as if it's a regular term, to match the component */
+    term->flags_ &= (ecs_termset_t)~EcsTermIsMember;
 
-    ecs_doc_set_brief(world, EcsMass, "Units of mass (e.g. \"5 kilograms\")");
+    /* Replace term id with member parent (the component) */
+    ecs_entity_t component = ecs_get_parent(world, first_id);
+    if (!component) {
+        ecs_err("member without parent in query");
+        return -1;
+    }
 
-    ecs_doc_set_brief(world, EcsElectricCurrent,
-        "Units of electrical current (e.g. \"2 ampere\")");
+    if (!ecs_has(world, component, EcsComponent)) {
+        ecs_err("parent of member is not a component");
+        return -1;
+    }
 
-    ecs_doc_set_brief(world, EcsAmount,
-        "Units of amount of substance (e.g. \"2 mole\")");
+    bool second_wildcard = ECS_TERM_REF_ID(&term->second) == EcsWildcard &&
+        (term->second.id & EcsIsVariable) && !term->second.name;
 
-    ecs_doc_set_brief(world, EcsLuminousIntensity,
-        "Units of luminous intensity (e.g. \"1 candela\")");
+    term->first.id = component | ECS_TERM_REF_FLAGS(&term->first);
+    term->second.id = 0;
+    term->id = component;
 
-    ecs_doc_set_brief(world, EcsForce, "Units of force (e.g. \"10 newton\")");
+    ctx->oper = (ecs_oper_kind_t)term->oper;
+    if (term->oper == EcsNot && !second_wildcard) {
+        /* When matching a member term with not operator, we need to cover both
+         * the case where an entity doesn't have the component, and where it 
+         * does have the component, but doesn't match the member. */
+        term->oper = EcsOptional;
+    }
 
-    ecs_doc_set_brief(world, EcsLength,
-        "Units of length (e.g. \"5 meters\", \"20 miles\")");
+    return 0;
+}
 
-    ecs_doc_set_brief(world, EcsPressure, 
-        "Units of pressure (e.g. \"1 bar\", \"1000 pascal\")");
+static
+int flecs_query_compile_end_member_term(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_op_t *op,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_id_t term_id,
+    ecs_entity_t first_id,
+    ecs_entity_t second_id,
+    bool cond_write)
+{
+    ecs_entity_t component = ECS_TERM_REF_ID(&term->first);
+    const EcsComponent *comp = ecs_get(world, component, EcsComponent);
+    ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_doc_set_brief(world, EcsSpeed,
-        "Units of movement (e.g. \"5 meters/second\")");
+    /* Restore term values */
+    term->id = term_id;
+    term->first.id = first_id;
+    term->second.id = second_id;
+    term->flags_ |= EcsTermIsMember;
+    term->oper = flecs_ito(int16_t, ctx->oper);
+
+    first_id = ECS_TERM_REF_ID(&term->first);
+    const EcsMember *member = ecs_get(world, first_id, EcsMember);
+    ecs_assert(member != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_query_var_t *var = &impl->vars[op->src.var];
+    const char *var_name = flecs_term_ref_var_name(&term->src);
+    ecs_var_id_t evar = flecs_query_find_var_id(
+        impl, var_name, EcsVarEntity);
+    bool second_wildcard = ECS_TERM_REF_ID(&term->second) == EcsWildcard &&
+        (term->second.id & EcsIsVariable) && !term->second.name;
+
+    if (term->oper == EcsOptional) {
+        second_wildcard = true;
+    }
+
+    ecs_query_op_t mbr_op = *op;
+    mbr_op.kind = EcsQueryMemberEq;
+    mbr_op.first.entity = /* Encode type size and member offset */
+        flecs_ito(uint32_t, member->offset) | 
+        (flecs_ito(uint64_t, comp->size) << 32);
+
+    /* If this is a term with a Not operator, conditionally evaluate member on
+     * whether term was set by previous operation (see begin_member_term). */
+    if (ctx->oper == EcsNot || ctx->oper == EcsOptional) {
+        if (second_wildcard && ctx->oper == EcsNot) {
+            /* A !(T.value, *) term doesn't need special operations */
+            return 0;
+        }
 
-    ecs_doc_set_brief(world, EcsAcceleration,
-        "Unit of speed increase (e.g. \"5 meters/second/second\")");
+        /* Resolve to entity variable before entering if block, so that we 
+         * don't have different branches of the query working with different
+         * versions of the same variable. */
+        if (var->kind == EcsVarTable) {
+            flecs_query_insert_each(op->src.var, evar, ctx, cond_write);
+            var = &impl->vars[evar];
+        }
 
-    ecs_doc_set_brief(world, EcsTemperature,
-        "Units of temperature (e.g. \"5 degrees Celsius\")");
+        ecs_query_op_t *if_op = flecs_query_begin_block(EcsQueryIfSet, ctx);
+        if_op->other = term->field_index;
 
-    ecs_doc_set_brief(world, EcsData,
-        "Units of information (e.g. \"8 bits\", \"100 megabytes\")");
+        if (ctx->oper == EcsNot) {
+            mbr_op.kind = EcsQueryMemberNeq;
+        }
+    }
 
-    ecs_doc_set_brief(world, EcsDataRate,
-        "Units of data transmission (e.g. \"100 megabits/second\")");
+    if (var->kind == EcsVarTable) {
+        /* If MemberEq is called on table variable, store it on .other member.
+         * This causes MemberEq to do double duty as 'each' instruction,
+         * which is faster than having to go back & forth between instructions
+         * while finding matching values. */
+        mbr_op.other = flecs_itolbl(op->src.var + 1);
 
-    ecs_doc_set_brief(world, EcsAngle,
-        "Units of rotation (e.g. \"1.2 radians\", \"180 degrees\")");
+        /* Mark entity variable as written */
+        flecs_query_write_ctx(evar, ctx, cond_write);
+        flecs_query_write(evar, &mbr_op.written);
+    }
 
-    ecs_doc_set_brief(world, EcsFrequency, 
-        "The number of occurrences of a repeating event per unit of time.");
+    flecs_query_compile_term_ref(world, impl, &mbr_op, &term->src, 
+        &mbr_op.src, EcsQuerySrc, EcsVarEntity, ctx, true);
 
-    ecs_doc_set_brief(world, EcsUri, "Universal resource identifier.");
-#endif
-}
+    if (second_wildcard) {
+        mbr_op.flags |= (EcsQueryIsEntity << EcsQuerySecond);
+        mbr_op.second.entity = EcsWildcard;
+    } else {
+        flecs_query_compile_term_ref(world, impl, &mbr_op, &term->second, 
+            &mbr_op.second, EcsQuerySecond, EcsVarEntity, ctx, true);
+        
+        if (term->second.id & EcsIsVariable) {
+            if (flecs_query_compile_ensure_vars(impl, &mbr_op, &mbr_op.second, 
+                EcsQuerySecond, ctx, cond_write, NULL)) 
+            {
+                goto error;
+            }
 
-#endif
+            flecs_query_write_ctx(mbr_op.second.var, ctx, cond_write);
+            flecs_query_write(mbr_op.second.var, &mbr_op.written);
+        }
+    }
 
-/**
- * @file datastructures/allocator.c
- * @brief Allocator for any size.
- * 
- * Allocators create a block allocator for each requested size.
- */
+    flecs_query_op_insert(&mbr_op, ctx);
 
+    if (ctx->oper == EcsNot || ctx->oper == EcsOptional) {
+        flecs_query_end_block(ctx, false);
+    }
 
+    return 0;
+error:
+    return -1;
+}
+#else
 static
-ecs_size_t flecs_allocator_size(
-    ecs_size_t size)
+int flecs_query_compile_begin_member_term(
+    ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_entity_t first_id)
 {
-    return ECS_ALIGN(size, 16);
+    (void)world; (void)term; (void)ctx; (void)first_id;
+    return 0;
 }
 
 static
-ecs_size_t flecs_allocator_size_hash(
-    ecs_size_t size)
+int flecs_query_compile_end_member_term(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_op_t *op,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_id_t term_id,
+    ecs_entity_t first_id,
+    ecs_entity_t second_id,
+    bool cond_write)
 {
-    return size >> 4;
+    (void)world; (void)impl; (void)op; (void)term; (void)ctx; (void)term_id;
+    (void)first_id; (void)second_id; (void)cond_write;
+    return 0;
 }
+#endif
 
-void flecs_allocator_init(
-    ecs_allocator_t *a)
+static
+void flecs_query_mark_last_or_op(
+    ecs_query_compile_ctx_t *ctx)
 {
-    flecs_ballocator_init_n(&a->chunks, ecs_block_allocator_t,
-        FLECS_SPARSE_PAGE_SIZE);
-    flecs_sparse_init_t(&a->sizes, NULL, &a->chunks, ecs_block_allocator_t);
+    ecs_query_op_t *op_ptr = ecs_vec_last_t(ctx->ops, ecs_query_op_t);
+    op_ptr->next = FlecsRuleOrMarker;
 }
 
-void flecs_allocator_fini(
-    ecs_allocator_t *a)
+static
+void flecs_query_set_op_kind(
+    ecs_query_t *q,
+    ecs_query_op_t *op,
+    ecs_term_t *term,
+    bool src_is_var,
+    bool member_term)
 {
-    int32_t i = 0, count = flecs_sparse_count(&a->sizes);
-    for (i = 0; i < count; i ++) {
-        ecs_block_allocator_t *ba = flecs_sparse_get_dense_t(
-            &a->sizes, ecs_block_allocator_t, i);
-        flecs_ballocator_fini(ba);
+    /* Default instruction for And operators. If the source is fixed (like for
+     * singletons or terms with an entity source), use With, which like And but
+     * just matches against a source (vs. finding a source). */
+    op->kind = src_is_var ? EcsQueryAnd : EcsQueryWith;
+
+    /* Handle *From operators */
+    if (term->oper == EcsAndFrom) {
+        op->kind = EcsQueryAndFrom;
+    } else if (term->oper == EcsOrFrom) {
+        op->kind = EcsQueryOrFrom;
+    } else if (term->oper == EcsNotFrom) {
+        op->kind = EcsQueryNotFrom;
+
+    /* If query is transitive, use Trav(ersal) instruction */
+    } else if (term->flags_ & EcsTermTransitive) {
+        ecs_assert(ecs_term_ref_is_set(&term->second), ECS_INTERNAL_ERROR, NULL);
+        op->kind = EcsQueryTrav;
+    } else {
+        /* Ignore cascade flag */
+        ecs_entity_t trav_flags = EcsTraverseFlags & ~(EcsCascade|EcsDesc);
+        if (term->flags_ & (EcsTermMatchAny|EcsTermMatchAnySrc)) {
+            op->kind = EcsQueryAndAny;
+        } else if ((term->src.id & trav_flags) == EcsUp) {
+            op->kind = EcsQueryUp;
+        } else if ((term->src.id & trav_flags) == (EcsSelf|EcsUp)) {
+            op->kind = EcsQuerySelfUp;
+        }
+    }
+
+    /* If term has fixed id, insert simpler instruction that skips dealing with
+     * wildcard terms and variables */
+    if (flecs_term_is_fixed_id(q, term) && !member_term) {
+        if (op->kind == EcsQueryAnd) {
+            op->kind = EcsQueryAndId;
+        } else if (op->kind == EcsQuerySelfUp) {
+            op->kind = EcsQuerySelfUpId;
+        } else if (op->kind == EcsQueryUp) {
+            op->kind = EcsQueryUpId;
+        }
     }
-    flecs_sparse_fini(&a->sizes);
-    flecs_ballocator_fini(&a->chunks);
 }
 
-ecs_block_allocator_t* flecs_allocator_get(
-    ecs_allocator_t *a, 
-    ecs_size_t size)
+int flecs_query_compile_term(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_term_t *term,
+    ecs_flags64_t *populated,
+    ecs_query_compile_ctx_t *ctx)
 {
-    ecs_assert(size >= 0, ECS_INTERNAL_ERROR, NULL);
-    if (!size) {
-        return NULL;
+    ecs_id_t term_id = term->id;
+    ecs_entity_t first_id = term->first.id;
+    ecs_entity_t second_id = term->second.id;
+    bool toggle_term = (term->flags_ & EcsTermIsToggle) != 0;
+    bool member_term = (term->flags_ & EcsTermIsMember) != 0;
+    if (member_term) {
+        (*populated) |= (1llu << term->field_index);
+        flecs_query_compile_begin_member_term(world, term, ctx, first_id);
+    }
+
+    ecs_query_t *q = &query->pub;
+    bool first_term = term == q->terms;
+    bool first_is_var = term->first.id & EcsIsVariable;
+    bool second_is_var = term->second.id & EcsIsVariable;
+    bool src_is_var = term->src.id & EcsIsVariable;
+    bool src_is_wildcard = src_is_var && 
+        (ECS_TERM_REF_ID(&term->src) == EcsWildcard ||
+            ECS_TERM_REF_ID(&term->src) == EcsAny);
+    bool src_is_lookup = false;
+    bool builtin_pred = flecs_term_is_builtin_pred(term);
+    bool is_not = (term->oper == EcsNot) && !builtin_pred;
+    bool is_optional = (term->oper == EcsOptional);
+    bool is_or = flecs_term_is_or(q, term);
+    bool first_or = false, last_or = false;
+    bool cond_write = term->oper == EcsOptional || is_or;
+    ecs_query_op_t op = {0};
+
+    if (is_or) {
+        first_or = first_term || (term[-1].oper != EcsOr);
+        last_or = term->oper != EcsOr;
     }
 
-    ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(size <= flecs_allocator_size(size), ECS_INTERNAL_ERROR, NULL);
-    size = flecs_allocator_size(size);
-    ecs_size_t hash = flecs_allocator_size_hash(size);
-    ecs_block_allocator_t *result = flecs_sparse_get_any_t(&a->sizes, 
-        ecs_block_allocator_t, (uint32_t)hash);
+    if (term->oper == EcsAndFrom || term->oper == EcsOrFrom || 
+        term->oper == EcsNotFrom) 
+    {
+        const ecs_type_t *type = ecs_get_type(world, term->id);
+        if (!type) {
+            /* Empty type for id in *From operation is a noop */
+            ctx->skipped ++;
+            return 0;
+        }
 
-    if (!result) {
-        result = flecs_sparse_ensure_fast_t(&a->sizes, 
-            ecs_block_allocator_t, (uint32_t)hash);
-        flecs_ballocator_init(result, size);
+        int32_t i, count = type->count;
+        ecs_id_t *ti_ids = type->array;
+
+        for (i = 0; i < count; i ++) {
+            ecs_id_t ti_id = ti_ids[i];
+            ecs_id_record_t *idr = flecs_id_record_get(world, ti_id);
+            if (!(idr->flags & EcsIdDontInherit)) {
+                break;
+            }
+        }
+
+        if (i == count) {
+            /* Type did not contain any ids to perform operation on */
+            ctx->skipped ++;
+            return 0;
+        }
     }
 
-    ecs_assert(result->data_size == size, ECS_INTERNAL_ERROR, NULL);
+    /* !_ (don't match anything) terms always return nothing. */
+    if (is_not && term->id == EcsAny) {
+        op.kind = EcsQueryNothing;
+        flecs_query_op_insert(&op, ctx);
+        return 0;
+    }
 
-    return result;
-}
+    if (first_or) {
+        ctx->ctrlflow->cond_written_or = ctx->cond_written;
+        ctx->ctrlflow->in_or = true;
+    } else if (is_or) {
+        ctx->written = ctx->ctrlflow->written_or;
+    }
 
-char* flecs_strdup(
-    ecs_allocator_t *a, 
-    const char* str)
-{
-    ecs_size_t len = ecs_os_strlen(str);
-    char *result = flecs_alloc_n(a, char, len + 1);
-    ecs_os_memcpy(result, str, len + 1);
-    return result;
-}
+    if (!ECS_TERM_REF_ID(&term->src) && term->src.id & EcsIsEntity) {
+        if (flecs_query_compile_0_src(world, query, term, ctx)) {
+            goto error;
+        }
+        return 0;
+    }
 
-void flecs_strfree(
-    ecs_allocator_t *a, 
-    char* str)
-{
-    ecs_size_t len = ecs_os_strlen(str);
-    flecs_free_n(a, char, len + 1, str);
-}
+    if (builtin_pred) {
+        ecs_entity_t id_noflags = ECS_TERM_REF_ID(&term->second);
+        if (id_noflags == EcsWildcard || id_noflags == EcsAny) {
+            /* Noop */
+            return 0;
+        }
+    }
 
-void* flecs_dup(
-    ecs_allocator_t *a,
-    ecs_size_t size,
-    const void *src)
-{
-    ecs_block_allocator_t *ba = flecs_allocator_get(a, size);
-    if (ba) {
-        void *dst = flecs_balloc(ba);
-        ecs_os_memcpy(dst, src, size);
-        return dst;
-    } else {
-        return NULL;
+    op.field_index = flecs_ito(int8_t, term->field_index);
+    op.term_index = flecs_ito(int8_t, term - q->terms);
+
+    flecs_query_set_op_kind(q, &op, term, src_is_var, member_term);
+
+    /* Save write state at start of term so we can use it to reliably track
+     * variables got written by this term. */
+    ecs_write_flags_t cond_write_state = ctx->cond_written;
+
+    /* Resolve variables and entities for operation arguments */
+    flecs_query_compile_term_ref(world, query, &op, &term->first, 
+        &op.first, EcsQueryFirst, EcsVarEntity, ctx, true);
+    flecs_query_compile_term_ref(world, query, &op, &term->second, 
+        &op.second, EcsQuerySecond, EcsVarEntity, ctx, true);
+    flecs_query_compile_term_ref(world, query, &op, &term->src, 
+        &op.src, EcsQuerySrc, EcsVarAny, ctx, true);
+
+    bool src_written = true;
+    if (src_is_var) {
+        src_is_lookup = query->vars[op.src.var].lookup != NULL;
+        src_written = flecs_query_is_written(op.src.var, ctx->written);
     }
-}
 
-/**
- * @file datastructures/bitset.c
- * @brief Bitset data structure.
- * 
- * Simple bitset implementation. The bitset allows for storage of arbitrary
- * numbers of bits.
- */
+    /* Insert each instructions for table -> entity variable if needed */
+    bool first_written, second_written;
+    if (flecs_query_compile_ensure_vars(
+        query, &op, &op.first, EcsQueryFirst, ctx, cond_write, &first_written)) 
+    {
+        goto error;    
+    }
 
+    if (flecs_query_compile_ensure_vars(
+        query, &op, &op.second, EcsQuerySecond, ctx, cond_write, &second_written))
+    {
+        goto error;
+    }
 
-static
-void ensure(
-    ecs_bitset_t *bs,
-    ecs_size_t size)
-{
-    if (!bs->size) {
-        int32_t new_size = ((size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t);
-        bs->size = ((size - 1) / 64 + 1) * 64;
-        bs->data = ecs_os_calloc(new_size);
-    } else if (size > bs->size) {
-        int32_t prev_size = ((bs->size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t);
-        bs->size = ((size - 1) / 64 + 1) * 64;
-        int32_t new_size = ((size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t);
-        bs->data = ecs_os_realloc(bs->data, new_size);
-        ecs_os_memset(ECS_OFFSET(bs->data, prev_size), 0, new_size - prev_size);
+    /* Store write state of variables for first OR term in chain which will get
+     * restored for the other terms in the chain, so that all OR terms make the
+     * same assumptions about which variables were already written. */
+    if (first_or) {
+        ctx->ctrlflow->written_or = ctx->written;
+    }
+
+    /* If an optional or not term is inserted for a source that's not been 
+     * written to yet, insert instruction that selects all entities so we have
+     * something to match the optional/not against. */
+    if (src_is_var && !src_written && !src_is_wildcard && !src_is_lookup) {
+        src_written = flecs_query_select_all(term, &op, op.src.var, ctx);
+    }
+
+    /* A bit of special logic for OR expressions and equality predicates. If the
+     * left-hand of an equality operator is a table, and there are multiple
+     * operators in an Or expression, the Or chain should match all entities in
+     * the table that match the right hand sides of the operator expressions. 
+     * For this to work, the src variable needs to be resolved as entity, as an
+     * Or chain would otherwise only yield the first match from a table. */
+    if (src_is_var && src_written && (builtin_pred || member_term) && term->oper == EcsOr) {
+        if (query->vars[op.src.var].kind == EcsVarTable) {
+            flecs_query_compile_term_ref(world, query, &op, &term->src, 
+                    &op.src, EcsQuerySrc, EcsVarEntity, ctx, true);
+            ctx->ctrlflow->written_or |= (1llu << op.src.var);
+        }
+    }
+
+    if (flecs_query_compile_ensure_vars(
+        query, &op, &op.src, EcsQuerySrc, ctx, cond_write, NULL)) 
+    {
+        goto error;
+    }
+
+    /* If source is Any (_) and first and/or second are unconstrained, insert an
+     * ids instruction instead of an And */
+    if (term->flags_ & EcsTermMatchAnySrc) {
+        op.kind = EcsQueryIds;
+        /* Use up-to-date written values after potentially inserting each */
+        if (!first_written || !second_written) {
+            if (!first_written) {
+                /* If first is unknown, traverse left: <- (*, t) */
+                if (ECS_TERM_REF_ID(&term->first) != EcsAny) {
+                    op.kind = EcsQueryIdsLeft;
+                }
+            } else {
+                /* If second is wildcard, traverse right: (r, *) -> */
+                if (ECS_TERM_REF_ID(&term->second) != EcsAny) {
+                    op.kind = EcsQueryIdsRight;
+                }
+            }
+            op.src.entity = 0;
+            src_is_var = false;
+            op.flags &= (ecs_flags8_t)~(EcsQueryIsVar << EcsQuerySrc); /* ids has no src */
+            op.flags &= (ecs_flags8_t)~(EcsQueryIsEntity << EcsQuerySrc);
+        }
+
+    /* If source variable is not written and we're querying just for Any, insert
+     * a dedicated instruction that uses the Any record in the id index. Any 
+     * queries that are evaluated against written sources can use Wildcard 
+     * records, which is what the AndAny instruction does. */
+    } else if (!src_written && term->id == EcsAny && op.kind == EcsQueryAndAny) {
+        /* Lookup variables ($var.child_name) are always written */
+        if (!src_is_lookup) {
+            op.kind = EcsQuerySelectAny; /* Uses Any (_) id record */
+        }
+    }
+
+    /* If this is a transitive term and both the target and source are unknown,
+     * find the targets for the relationship first. This clusters together 
+     * tables for the same target, which allows for more efficient usage of the
+     * traversal caches. */
+    if (term->flags_ & EcsTermTransitive && src_is_var && second_is_var) {
+        if (!src_written && !second_written) {
+            flecs_query_insert_unconstrained_transitive(
+                query, &op, ctx, cond_write);
+        }
+    }
+
+    /* Check if this term has variables that have been conditionally written,
+     * like variables written by an optional term. */
+    if (ctx->cond_written) {
+        if (!is_or || first_or) {
+            flecs_query_begin_block_cond_eval(&op, ctx, cond_write_state);
+        }
+    }
+
+    /* If term can toggle and is Not, change operator to Optional as we
+     * have to match entities that have the component but disabled. */
+    if (toggle_term && is_not) {
+        is_not = false;
+        is_optional = true;
+    }
+
+    /* Handle Not, Optional, Or operators */
+    if (is_not) {
+        flecs_query_begin_block(EcsQueryNot, ctx);
+    } else if (is_optional) {
+        flecs_query_begin_block(EcsQueryOptional, ctx);
+    } else if (first_or) {
+        flecs_query_begin_block_or(&op, term, ctx);
+    }
+
+    /* If term has component inheritance enabled, insert instruction to walk
+     * down the relationship tree of the id. */
+    if (term->flags_ & EcsTermIdInherited) {
+        flecs_query_insert_inheritance(query, term, &op, ctx, cond_write);
+    }
+
+    op.match_flags = term->flags_;
+
+    ecs_write_flags_t write_state = ctx->written;
+    if (first_is_var) {
+        op.flags &= (ecs_flags8_t)~(EcsQueryIsEntity << EcsQueryFirst);
+        op.flags |= (EcsQueryIsVar << EcsQueryFirst);
+    }
+
+    if (term->src.id & EcsSelf) {
+        op.flags |= EcsQueryIsSelf;
+    }
+
+    /* Insert instructions for lookup variables */
+    if (first_is_var) {
+        if (flecs_query_compile_lookup(query, op.first.var, ctx, cond_write)) {
+            write_state |= (1ull << op.first.var); // lookups are resolved inline
+        }
+    }
+    if (src_is_var) {
+        if (flecs_query_compile_lookup(query, op.src.var, ctx, cond_write)) {
+            write_state |= (1ull << op.src.var); // lookups are resolved inline
+        }
+    }
+    if (second_is_var) {
+        if (flecs_query_compile_lookup(query, op.second.var, ctx, cond_write)) {
+            write_state |= (1ull << op.second.var); // lookups are resolved inline
+        }
+    }
+
+    if (builtin_pred) {
+        if (flecs_query_compile_builtin_pred(q, term, &op, write_state)) {
+            goto error;
+        }
     }
-}
 
-void flecs_bitset_init(
-    ecs_bitset_t* bs)
-{
-    bs->size = 0;
-    bs->count = 0;
-    bs->data = NULL;
-}
+    /* If we're writing the $this variable, filter out disabled/prefab entities
+     * unless the query explicitly matches them.
+     * This could've been done with regular With instructions, but since 
+     * filtering out disabled/prefab entities is the default and this check is
+     * cheap to perform on table flags, it's worth special casing. */
+    if (!src_written && op.src.var == 0) {
+        ecs_flags32_t query_flags = q->flags;
+        if (!(query_flags & EcsQueryMatchDisabled) || 
+            !(query_flags & EcsQueryMatchPrefab)) 
+        {
+            ecs_flags32_t table_flags = EcsTableNotQueryable;
+            if (!(query_flags & EcsQueryMatchDisabled)) {
+                table_flags |= EcsTableIsDisabled;
+            }
+            if (!(query_flags & EcsQueryMatchPrefab)) {
+                table_flags |= EcsTableIsPrefab;
+            }
 
-void flecs_bitset_ensure(
-    ecs_bitset_t *bs,
-    int32_t count)
-{
-    if (count > bs->count) {
-        bs->count = count;
-        ensure(bs, count);
+            op.other = flecs_itolbl(table_flags);
+        }
     }
-}
 
-void flecs_bitset_fini(
-    ecs_bitset_t *bs)
-{
-    ecs_os_free(bs->data);
-    bs->data = NULL;
-    bs->count = 0;
-}
+    /* After evaluating a term, a used variable is always written */
+    if (src_is_var) {
+        flecs_query_write(op.src.var, &op.written);
+        flecs_query_write_ctx(op.src.var, ctx, cond_write);
+    }
+    if (first_is_var) {
+        flecs_query_write(op.first.var, &op.written);
+        flecs_query_write_ctx(op.first.var, ctx, cond_write);
+    }
+    if (second_is_var) {
+        flecs_query_write(op.second.var, &op.written);
+        flecs_query_write_ctx(op.second.var, ctx, cond_write);
+    }
+    
+    flecs_query_op_insert(&op, ctx);
 
-void flecs_bitset_addn(
-    ecs_bitset_t *bs,
-    int32_t count)
-{
-    int32_t elem = bs->count += count;
-    ensure(bs, elem);
-}
+    ctx->cur->lbl_query = flecs_itolbl(ecs_vec_count(ctx->ops) - 1);
+    if (is_or && !member_term) {
+        flecs_query_mark_last_or_op(ctx);
+    }
 
-void flecs_bitset_set(
-    ecs_bitset_t *bs,
-    int32_t elem,
-    bool value)
-{
-    ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL);
-    uint32_t hi = ((uint32_t)elem) >> 6;
-    uint32_t lo = ((uint32_t)elem) & 0x3F;
-    uint64_t v = bs->data[hi];
-    bs->data[hi] = (v & ~((uint64_t)1 << lo)) | ((uint64_t)value << lo);
-error:
-    return;
-}
+    /* Handle self-references between src and first/second variables */
+    if (src_is_var) {
+        if (first_is_var) {
+            flecs_query_insert_contains(query, op.src.var, op.first.var, ctx);
+        }
+        if (second_is_var && op.first.var != op.second.var) {
+            flecs_query_insert_contains(query, op.src.var, op.second.var, ctx);
+        }
+    }
 
-bool flecs_bitset_get(
-    const ecs_bitset_t *bs,
-    int32_t elem)
-{
-    ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL);
-    return !!(bs->data[elem >> 6] & ((uint64_t)1 << ((uint64_t)elem & 0x3F)));
-error:
-    return false;
-}
+    /* Handle self references between first and second variables */
+    if (!ecs_id_is_wildcard(first_id)) {
+        if (first_is_var && !first_written && (op.first.var == op.second.var)) {
+            flecs_query_insert_pair_eq(term->field_index, ctx);
+        }
+    }
 
-int32_t flecs_bitset_count(
-    const ecs_bitset_t *bs)
-{
-    return bs->count;
-}
+    /* Handle closing of Not, Optional and Or operators */
+    if (is_not) {
+        flecs_query_end_block(ctx, true);
+    } else if (is_optional) {
+        flecs_query_end_block(ctx, true);
+    }
 
-void flecs_bitset_remove(
-    ecs_bitset_t *bs,
-    int32_t elem)
-{
-    ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL);
-    int32_t last = bs->count - 1;
-    bool last_value = flecs_bitset_get(bs, last);
-    flecs_bitset_set(bs, elem, last_value);
-    flecs_bitset_set(bs, last, 0);
-    bs->count --;
-error:
-    return;
-}
+    /* Now that the term is resolved, evaluate member of component */
+    if (member_term) {
+        flecs_query_compile_end_member_term(world, query, &op, term, ctx, 
+            term_id, first_id, second_id, cond_write);
+        if (is_or) {
+            flecs_query_mark_last_or_op(ctx);
+        }
+    }
 
-void flecs_bitset_swap(
-    ecs_bitset_t *bs,
-    int32_t elem_a,
-    int32_t elem_b)
-{
-    ecs_check(elem_a < bs->count, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(elem_b < bs->count, ECS_INVALID_PARAMETER, NULL);
+    if (last_or) {
+        flecs_query_end_block_or(query, ctx);
+    }
 
-    bool a = flecs_bitset_get(bs, elem_a);
-    bool b = flecs_bitset_get(bs, elem_b);
-    flecs_bitset_set(bs, elem_a, b);
-    flecs_bitset_set(bs, elem_b, a);
+    /* Handle closing of conditional evaluation */
+    if (ctx->cur->lbl_cond_eval && (first_is_var || second_is_var || src_is_var)) {
+        if (!is_or || last_or) {
+            flecs_query_end_block_cond_eval(ctx);
+        }
+    }
+
+    /* Ensure that term id is set after evaluating Not */
+    if (term->flags_ & EcsTermIdInherited) {
+        if (is_not) {
+            ecs_query_op_t set_id = {0};
+            set_id.kind = EcsQuerySetId;
+            set_id.first.entity = term->id;
+            set_id.flags = (EcsQueryIsEntity << EcsQueryFirst);
+            set_id.field_index = flecs_ito(int8_t, term->field_index);
+            flecs_query_op_insert(&set_id, ctx);
+        }
+    }
+
+    return 0;
 error:
-    return;
+    return -1;
 }
 
 /**
- * @file datastructures/block_allocator.c
- * @brief Block allocator.
- * 
- * A block allocator is an allocator for a fixed size that allocates blocks of
- * memory with N elements of the requested size.
+ * @file addons/querys/engine.c
+ * @brief Query engine implementation.
  */
 
 
-// #ifdef FLECS_SANITIZE
-// #define FLECS_MEMSET_UNINITIALIZED
-// #endif
+// #define FLECS_QUERY_TRACE
 
-int64_t ecs_block_allocator_alloc_count = 0;
-int64_t ecs_block_allocator_free_count = 0;
+#ifdef FLECS_QUERY_TRACE
+static int flecs_query_trace_indent = 0;
+#endif
 
-#ifndef FLECS_USE_OS_ALLOC
+static
+bool flecs_query_dispatch(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx);
 
 static
-ecs_block_allocator_chunk_header_t* flecs_balloc_block(
-    ecs_block_allocator_t *allocator)
-{
-    if (!allocator->chunk_size) {
-        return NULL;
-    }
+bool flecs_query_run_until(
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    const ecs_query_op_t *ops,
+    ecs_query_lbl_t first,
+    ecs_query_lbl_t cur,
+    int32_t last);
 
-    ecs_block_allocator_block_t *block = 
-        ecs_os_malloc(ECS_SIZEOF(ecs_block_allocator_block_t) +
-            allocator->block_size);
-    ecs_block_allocator_chunk_header_t *first_chunk = ECS_OFFSET(block, 
-        ECS_SIZEOF(ecs_block_allocator_block_t));
+static
+void flecs_query_populate_field(
+    ecs_iter_t *it,
+    ecs_table_range_t *range,
+    int8_t field_index,
+    ecs_query_run_ctx_t *ctx);
 
-    block->memory = first_chunk;
-    if (!allocator->block_tail) {
-        ecs_assert(!allocator->block_head, ECS_INTERNAL_ERROR, 0);
-        block->next = NULL;
-        allocator->block_head = block;
-        allocator->block_tail = block;
-    } else {
-        block->next = NULL;
-        allocator->block_tail->next = block;
-        allocator->block_tail = block;
-    }
+static
+void flecs_query_populate_field_from_range(
+    ecs_iter_t *it,
+    ecs_table_range_t *range,
+    int8_t field_index,
+    int32_t index);
 
-    ecs_block_allocator_chunk_header_t *chunk = first_chunk;
-    int32_t i, end;
-    for (i = 0, end = allocator->chunks_per_block - 1; i < end; ++i) {
-        chunk->next = ECS_OFFSET(chunk, allocator->chunk_size);
-        chunk = chunk->next;
+static
+void flecs_query_set_iter_this(
+    ecs_iter_t *it,
+    const ecs_query_run_ctx_t *ctx)
+{
+    const ecs_table_range_t *range = &ctx->vars[0].range;
+    ecs_table_t *table = range->table;
+    int32_t count = range->count;
+    if (table) {
+        if (!count) {
+            count = ecs_table_count(table);
+        }
+        it->table = table;
+        it->offset = range->offset;
+        it->count = count;
+        it->entities = ECS_ELEM_T(
+            table->data.entities.array, ecs_entity_t, it->offset);
+    } else if (count == 1) {
+        it->count = 1;
+        it->entities = &ctx->vars[0].entity;
     }
-
-    ecs_os_linc(&ecs_block_allocator_alloc_count);
-
-    chunk->next = NULL;
-    return first_chunk;
 }
 
-#endif
-
-void flecs_ballocator_init(
-    ecs_block_allocator_t *ba,
-    ecs_size_t size)
+static
+ecs_query_op_ctx_t* flecs_op_ctx_(
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(ba != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL);
-    ba->data_size = size;
-#ifdef FLECS_SANITIZE
-    size += ECS_SIZEOF(int64_t);
-#endif
-    ba->chunk_size = ECS_ALIGN(size, 16);
-    ba->chunks_per_block = ECS_MAX(4096 / ba->chunk_size, 1);
-    ba->block_size = ba->chunks_per_block * ba->chunk_size;
-    ba->head = NULL;
-    ba->block_head = NULL;
-    ba->block_tail = NULL;
+    return &ctx->op_ctx[ctx->op_index];
 }
 
-ecs_block_allocator_t* flecs_ballocator_new(
-    ecs_size_t size)
-{
-    ecs_block_allocator_t *result = ecs_os_calloc_t(ecs_block_allocator_t);
-    flecs_ballocator_init(result, size);
-    return result;
-}
+#define flecs_op_ctx(ctx, op_kind) (&flecs_op_ctx_(ctx)->is.op_kind)
 
-void flecs_ballocator_fini(
-    ecs_block_allocator_t *ba)
+static
+void flecs_reset_source_set_flag(
+    ecs_iter_t *it,
+    int32_t field_index)
 {
-    ecs_assert(ba != NULL, ECS_INTERNAL_ERROR, NULL);
-
-#ifdef FLECS_SANITIZE
-    ecs_assert(ba->alloc_count == 0, ECS_LEAK_DETECTED, 
-        "(size = %u)", (uint32_t)ba->data_size);
-#endif
-
-    ecs_block_allocator_block_t *block;
-    for (block = ba->block_head; block;) {
-        ecs_block_allocator_block_t *next = block->next;
-        ecs_os_free(block);
-        ecs_os_linc(&ecs_block_allocator_free_count);
-        block = next;
-    }
-    ba->block_head = NULL;
+    ecs_assert(field_index != -1, ECS_INTERNAL_ERROR, NULL);
+    ECS_TERMSET_CLEAR(it->up_fields, 1u << field_index);
 }
 
-void flecs_ballocator_free(
-    ecs_block_allocator_t *ba)
+static
+void flecs_set_source_set_flag(
+    ecs_iter_t *it,
+    int32_t field_index)
 {
-    flecs_ballocator_fini(ba);
-    ecs_os_free(ba);
+    ecs_assert(field_index != -1, ECS_INTERNAL_ERROR, NULL);
+    ECS_TERMSET_SET(it->up_fields, 1u << field_index);
 }
 
-void* flecs_balloc(
-    ecs_block_allocator_t *ba) 
+static
+ecs_table_range_t flecs_range_from_entity(
+    ecs_entity_t e,
+    const ecs_query_run_ctx_t *ctx)
 {
-    void *result;
-#ifdef FLECS_USE_OS_ALLOC
-    result = ecs_os_malloc(ba->data_size);
-#else
-
-    if (!ba) return NULL;
-
-    if (!ba->head) {
-        ba->head = flecs_balloc_block(ba);
+    ecs_record_t *r = flecs_entities_get(ctx->world, e);
+    if (!r) {
+        return (ecs_table_range_t){ 0 };
     }
-
-    result = ba->head;
-    ba->head = ba->head->next;
-
-#ifdef FLECS_SANITIZE
-    ecs_assert(ba->alloc_count >= 0, ECS_INTERNAL_ERROR, "corrupted allocator");
-    ba->alloc_count ++;
-    *(int64_t*)result = ba->chunk_size;
-    result = ECS_OFFSET(result, ECS_SIZEOF(int64_t));
-#endif
-#endif
-
-#ifdef FLECS_MEMSET_UNINITIALIZED
-    ecs_os_memset(result, 0xAA, ba->data_size);
-#endif
-
-    return result;
-}
-
-void* flecs_bcalloc(
-    ecs_block_allocator_t *ba) 
-{
-#ifdef FLECS_USE_OS_ALLOC
-    return ecs_os_calloc(ba->data_size);
-#else
-    if (!ba) return NULL;
-    void *result = flecs_balloc(ba);
-    ecs_os_memset(result, 0, ba->data_size);
-    return result;
-#endif
+    return (ecs_table_range_t){
+        .table = r->table,
+        .offset = ECS_RECORD_TO_ROW(r->row),
+        .count = 1
+    };
 }
 
-void flecs_bfree(
-    ecs_block_allocator_t *ba, 
-    void *memory) 
+static
+ecs_table_range_t flecs_query_var_get_range(
+    int32_t var_id,
+    const ecs_query_run_ctx_t *ctx)
 {
-#ifdef FLECS_USE_OS_ALLOC
-    (void)ba;
-    ecs_os_free(memory);
-    return;
-#else
-
-    if (!ba) {
-        ecs_assert(memory == NULL, ECS_INTERNAL_ERROR, NULL);
-        return;
-    }
-    if (memory == NULL) {
-        return;
+    ecs_assert(var_id < ctx->query->var_count, ECS_INTERNAL_ERROR, NULL);
+    ecs_var_t *var = &ctx->vars[var_id];
+    ecs_table_t *table = var->range.table;
+    if (table) {
+        return var->range;
     }
 
-#ifdef FLECS_SANITIZE
-    memory = ECS_OFFSET(memory, -ECS_SIZEOF(int64_t));
-    if (*(int64_t*)memory != ba->chunk_size) {
-        ecs_err("chunk %p returned to wrong allocator "
-            "(chunk = %ub, allocator = %ub)",
-                memory, *(int64_t*)memory, ba->chunk_size);
-        ecs_abort(ECS_INTERNAL_ERROR, NULL);
+    ecs_entity_t entity = var->entity;
+    if (entity && entity != EcsWildcard) {
+        var->range = flecs_range_from_entity(entity, ctx);
+        return var->range;
     }
 
-    ba->alloc_count --;
-#endif
-
-    ecs_block_allocator_chunk_header_t *chunk = memory;
-    chunk->next = ba->head;
-    ba->head = chunk;
-    ecs_assert(ba->alloc_count >= 0, ECS_INTERNAL_ERROR, "corrupted allocator");
-#endif
+    return (ecs_table_range_t){ 0 };
 }
 
-void* flecs_brealloc(
-    ecs_block_allocator_t *dst, 
-    ecs_block_allocator_t *src, 
-    void *memory)
+static
+ecs_table_t* flecs_query_var_get_table(
+    int32_t var_id,
+    const ecs_query_run_ctx_t *ctx)
 {
-    void *result;
-#ifdef FLECS_USE_OS_ALLOC
-    (void)src;
-    result = ecs_os_realloc(memory, dst->data_size);
-#else
-    if (dst == src) {
-        return memory;
+    ecs_var_t *var = &ctx->vars[var_id];
+    ecs_table_t *table = var->range.table;
+    if (table) {
+        return table;
     }
 
-    result = flecs_balloc(dst);
-    if (result && src) {
-        ecs_size_t size = src->data_size;
-        if (dst->data_size < size) {
-            size = dst->data_size;
-        }
-        ecs_os_memcpy(result, memory, size);
-    }
-    flecs_bfree(src, memory);
-#endif
-#ifdef FLECS_MEMSET_UNINITIALIZED
-    if (dst && src && (dst->data_size > src->data_size)) {
-        ecs_os_memset(ECS_OFFSET(result, src->data_size), 0xAA, 
-            dst->data_size - src->data_size);
-    } else if (dst && !src) {
-        ecs_os_memset(result, 0xAA, dst->data_size);
+    ecs_entity_t entity = var->entity;
+    if (entity && entity != EcsWildcard) {
+        var->range = flecs_range_from_entity(entity, ctx);
+        return var->range.table;
     }
-#endif
 
-    return result;
+    return NULL;
 }
 
-void* flecs_bdup(
-    ecs_block_allocator_t *ba, 
-    void *memory)
+static
+ecs_table_t* flecs_query_get_table(
+    const ecs_query_op_t *op,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind,
+    const ecs_query_run_ctx_t *ctx)
 {
-#ifdef FLECS_USE_OS_ALLOC
-    if (memory && ba->chunk_size) {
-        return ecs_os_memdup(memory, ba->data_size);
+    ecs_flags16_t flags = flecs_query_ref_flags(op->flags, ref_kind);
+    if (flags & EcsQueryIsEntity) {
+        return ecs_get_table(ctx->world, ref->entity);
     } else {
-        return NULL;
-    }
-#else
-    void *result = flecs_balloc(ba);
-    if (result) {
-        ecs_os_memcpy(result, memory, ba->data_size);
+        return flecs_query_var_get_table(ref->var, ctx);
     }
-    return result;
-#endif
 }
 
-// This is free and unencumbered software released into the public domain under The Unlicense (http://unlicense.org/)
-// main repo: https://github.com/wangyi-fudan/wyhash
-// author: 王一 Wang Yi
-// contributors: Reini Urban, Dietrich Epp, Joshua Haberman, Tommy Ettinger, 
-//               Daniel Lemire, Otmar Ertl, cocowalla, leo-yuriev, 
-//               Diego Barrios Romero, paulie-g, dumblob, Yann Collet, ivte-ms, 
-//               hyb, James Z.M. Gao, easyaspi314 (Devin), TheOneric
-
-/* quick example:
-   string s="fjsakfdsjkf";
-   uint64_t hash=wyhash(s.c_str(), s.size(), 0, wyp_);
-*/
-
-
-#ifndef WYHASH_CONDOM
-//protections that produce different results:
-//1: normal valid behavior
-//2: extra protection against entropy loss (probability=2^-63), aka. "blind multiplication"
-#define WYHASH_CONDOM 1
-#endif
+static
+ecs_table_range_t flecs_query_get_range(
+    const ecs_query_op_t *op,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t flags = flecs_query_ref_flags(op->flags, ref_kind);
+    if (flags & EcsQueryIsEntity) {
+        ecs_assert(!(flags & EcsQueryIsVar), ECS_INTERNAL_ERROR, NULL);
+        return flecs_range_from_entity(ref->entity, ctx);
+    } else {
+        ecs_var_t *var = &ctx->vars[ref->var];
+        if (var->range.table) {
+            return ctx->vars[ref->var].range;
+        } else if (var->entity) {
+            return flecs_range_from_entity(var->entity, ctx);
+        }
+    }
+    return (ecs_table_range_t){0};
+}
 
-#ifndef WYHASH_32BIT_MUM
-//0: normal version, slow on 32 bit systems
-//1: faster on 32 bit systems but produces different results, incompatible with wy2u0k function
-#define WYHASH_32BIT_MUM 0  
-#endif
+static
+ecs_entity_t flecs_query_var_get_entity(
+    ecs_var_id_t var_id,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_assert(var_id < (ecs_var_id_t)ctx->query->var_count, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_var_t *var = &ctx->vars[var_id];
+    ecs_entity_t entity = var->entity;
+    if (entity) {
+        return entity;
+    }
 
-//includes
-#include <stdint.h>
-#include <string.h>
-#if defined(_MSC_VER) && defined(_M_X64)
-  #include <intrin.h>
-  #pragma intrinsic(_umul128)
-#endif
+    ecs_assert(var->range.count == 1, ECS_INTERNAL_ERROR, NULL);
+    ecs_table_t *table = var->range.table;
+    ecs_entity_t *entities = table->data.entities.array;
+    var->entity = entities[var->range.offset];
+    return var->entity;
+}
 
-//likely and unlikely macros
-#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
-  #define likely_(x)  __builtin_expect(x,1)
-  #define unlikely_(x)  __builtin_expect(x,0)
-#else
-  #define likely_(x) (x)
-  #define unlikely_(x) (x)
-#endif
+static
+void flecs_query_var_reset(
+    ecs_var_id_t var_id,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ctx->vars[var_id].entity = EcsWildcard;
+    ctx->vars[var_id].range.table = NULL;
+}
 
-//128bit multiply function
-static inline void wymum_(uint64_t *A, uint64_t *B){
-#if(WYHASH_32BIT_MUM)
-  uint64_t hh=(*A>>32)*(*B>>32), hl=(*A>>32)*(uint32_t)*B, lh=(uint32_t)*A*(*B>>32), ll=(uint64_t)(uint32_t)*A*(uint32_t)*B;
-  #if(WYHASH_CONDOM>1)
-  *A^=_wyrot(hl)^hh; *B^=_wyrot(lh)^ll;
-  #else
-  *A=_wyrot(hl)^hh; *B=_wyrot(lh)^ll;
-  #endif
-#elif defined(__SIZEOF_INT128__)
-  __uint128_t r=*A; r*=*B; 
-  #if(WYHASH_CONDOM>1)
-  *A^=(uint64_t)r; *B^=(uint64_t)(r>>64);
-  #else
-  *A=(uint64_t)r; *B=(uint64_t)(r>>64);
-  #endif
-#elif defined(_MSC_VER) && defined(_M_X64)
-  #if(WYHASH_CONDOM>1)
-  uint64_t  a,  b;
-  a=_umul128(*A,*B,&b);
-  *A^=a;  *B^=b;
-  #else
-  *A=_umul128(*A,*B,B);
-  #endif
-#else
-  uint64_t ha=*A>>32, hb=*B>>32, la=(uint32_t)*A, lb=(uint32_t)*B, hi, lo;
-  uint64_t rh=ha*hb, rm0=ha*lb, rm1=hb*la, rl=la*lb, t=rl+(rm0<<32), c=t<rl;
-  lo=t+(rm1<<32); c+=lo<t; hi=rh+(rm0>>32)+(rm1>>32)+c;
-  #if(WYHASH_CONDOM>1)
-  *A^=lo;  *B^=hi;
-  #else
-  *A=lo;  *B=hi;
-  #endif
-#endif
+static
+void flecs_query_var_set_range(
+    const ecs_query_op_t *op,
+    ecs_var_id_t var_id,
+    ecs_table_t *table,
+    int32_t offset,
+    int32_t count,
+    const ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    ecs_assert(ctx->query_vars[var_id].kind == EcsVarTable, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(flecs_query_is_written(var_id, op->written), 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_var_t *var = &ctx->vars[var_id];
+    var->entity = 0;
+    var->range = (ecs_table_range_t){ 
+        .table = table,
+        .offset = offset,
+        .count = count
+    };
 }
 
-//multiply and xor mix function, aka MUM
-static inline uint64_t wymix_(uint64_t A, uint64_t B){ wymum_(&A,&B); return A^B; }
-
-//endian macros
-#ifndef WYHASH_LITTLE_ENDIAN
-  #if defined(_WIN32) || defined(__LITTLE_ENDIAN__) || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-    #define WYHASH_LITTLE_ENDIAN 1
-  #elif defined(__BIG_ENDIAN__) || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-    #define WYHASH_LITTLE_ENDIAN 0
-  #else
-    #warning could not determine endianness! Falling back to little endian.
-    #define WYHASH_LITTLE_ENDIAN 1
-  #endif
-#endif
+static
+void flecs_query_var_narrow_range(
+    ecs_var_id_t var_id,
+    ecs_table_t *table,
+    int32_t offset,
+    int32_t count,
+    const ecs_query_run_ctx_t *ctx)
+{    
+    ecs_var_t *var = &ctx->vars[var_id];
+    
+    var->entity = 0;
+    var->range = (ecs_table_range_t){ 
+        .table = table,
+        .offset = offset,
+        .count = count
+    };
 
-//read functions
-#if (WYHASH_LITTLE_ENDIAN)
-static inline uint64_t wyr8_(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return v;}
-static inline uint64_t wyr4_(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return v;}
-#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
-static inline uint64_t wyr8_(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return __builtin_bswap64(v);}
-static inline uint64_t wyr4_(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return __builtin_bswap32(v);}
-#elif defined(_MSC_VER)
-static inline uint64_t wyr8_(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return _byteswap_uint64(v);}
-static inline uint64_t wyr4_(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return _byteswap_ulong(v);}
-#else
-static inline uint64_t wyr8_(const uint8_t *p) {
-  uint64_t v; memcpy(&v, p, 8);
-  return (((v >> 56) & 0xff)| ((v >> 40) & 0xff00)| ((v >> 24) & 0xff0000)| ((v >>  8) & 0xff000000)| ((v <<  8) & 0xff00000000)| ((v << 24) & 0xff0000000000)| ((v << 40) & 0xff000000000000)| ((v << 56) & 0xff00000000000000));
+    if (ctx->query_vars[var_id].kind != EcsVarTable) {    
+        ecs_assert(count == 1, ECS_INTERNAL_ERROR, NULL);
+        var->entity = flecs_table_entities_array(table)[offset];
+    }
 }
-static inline uint64_t wyr4_(const uint8_t *p) {
-  uint32_t v; memcpy(&v, p, 4);
-  return (((v >> 24) & 0xff)| ((v >>  8) & 0xff00)| ((v <<  8) & 0xff0000)| ((v << 24) & 0xff000000));
+
+static
+void flecs_query_var_set_entity(
+    const ecs_query_op_t *op,
+    ecs_var_id_t var_id,
+    ecs_entity_t entity,
+    const ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    ecs_assert(var_id < (ecs_var_id_t)ctx->query->var_count, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(flecs_query_is_written(var_id, op->written), 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_var_t *var = &ctx->vars[var_id];
+    var->range.table = NULL;
+    var->entity = entity;
 }
-#endif
-static inline uint64_t wyr3_(const uint8_t *p, size_t k) { return (((uint64_t)p[0])<<16)|(((uint64_t)p[k>>1])<<8)|p[k-1];}
 
-//wyhash main function
-static inline uint64_t wyhash(const void *key, size_t len, uint64_t seed, const uint64_t *secret){
-  const uint8_t *p=(const uint8_t *)key; seed^=wymix_(seed^secret[0],secret[1]);	uint64_t	a,	b;
-  if(likely_(len<=16)){
-    if(likely_(len>=4)){ a=(wyr4_(p)<<32)|wyr4_(p+((len>>3)<<2)); b=(wyr4_(p+len-4)<<32)|wyr4_(p+len-4-((len>>3)<<2)); }
-    else if(likely_(len>0)){ a=wyr3_(p,len); b=0;}
-    else a=b=0;
-  }
-  else{
-    size_t i=len; 
-    if(unlikely_(i>48)){
-      uint64_t see1=seed, see2=seed;
-      do{
-        seed=wymix_(wyr8_(p)^secret[1],wyr8_(p+8)^seed);
-        see1=wymix_(wyr8_(p+16)^secret[2],wyr8_(p+24)^see1);
-        see2=wymix_(wyr8_(p+32)^secret[3],wyr8_(p+40)^see2);
-        p+=48; i-=48;
-      }while(likely_(i>48));
-      seed^=see1^see2;
+static
+void flecs_query_set_vars(
+    const ecs_query_op_t *op,
+    ecs_id_t id,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t flags_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t flags_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+
+    if (flags_1st & EcsQueryIsVar) {
+        ecs_var_id_t var = op->first.var;
+        if (op->written & (1ull << var)) {
+            if (ECS_IS_PAIR(id)) {
+                flecs_query_var_set_entity(
+                    op, var, ecs_get_alive(ctx->world, ECS_PAIR_FIRST(id)), ctx);
+            } else {
+                flecs_query_var_set_entity(op, var, id, ctx);
+            }
+        }
+    }
+
+    if (flags_2nd & EcsQueryIsVar) {
+        ecs_var_id_t var = op->second.var;
+        if (op->written & (1ull << var)) {
+            flecs_query_var_set_entity(
+                op, var, ecs_get_alive(ctx->world, ECS_PAIR_SECOND(id)), ctx);
+        }
     }
-    while(unlikely_(i>16)){  seed=wymix_(wyr8_(p)^secret[1],wyr8_(p+8)^seed);  i-=16; p+=16;  }
-    a=wyr8_(p+i-16);  b=wyr8_(p+i-8);
-  }
-  a^=secret[1]; b^=seed;  wymum_(&a,&b);
-  return  wymix_(a^secret[0]^len,b^secret[1]);
 }
 
-//the default secret parameters
-static const uint64_t wyp_[4] = {0xa0761d6478bd642full, 0xe7037ed1a0b428dbull, 0x8ebc6af09c88c6e3ull, 0x589965cc75374cc3ull};
+static
+ecs_table_range_t flecs_get_ref_range(
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t flag,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (flag & EcsQueryIsEntity) {
+        return flecs_range_from_entity(ref->entity, ctx);
+    } else if (flag & EcsQueryIsVar) {
+        return flecs_query_var_get_range(ref->var, ctx);
+    }
+    return (ecs_table_range_t){0};
+}
 
-uint64_t flecs_hash(
-    const void *data,
-    ecs_size_t length)
+static
+ecs_entity_t flecs_get_ref_entity(
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t flag,
+    const ecs_query_run_ctx_t *ctx)
 {
-    return wyhash(data, flecs_ito(size_t, length), 0, wyp_);
+    if (flag & EcsQueryIsEntity) {
+        return ref->entity;
+    } else if (flag & EcsQueryIsVar) {
+        return flecs_query_var_get_entity(ref->var, ctx);
+    }
+    return 0;
 }
 
-/**
- * @file datastructures/hashmap.c
- * @brief Hashmap data structure.
- * 
- * The hashmap data structure is built on top of the map data structure. Where 
- * the map data structure can only work with 64bit key values, the hashmap can
- * hash keys of any size, and handles collisions between hashes.
- */
+static
+ecs_id_t flecs_query_op_get_id_w_written(
+    const ecs_query_op_t *op,
+    uint64_t written,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t flags_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t flags_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+    ecs_entity_t first = 0, second = 0;
+
+    if (flags_1st) {
+        if (flecs_ref_is_written(op, &op->first, EcsQueryFirst, written)) {
+            first = flecs_get_ref_entity(&op->first, flags_1st, ctx);
+        } else if (flags_1st & EcsQueryIsVar) {
+            first = EcsWildcard;
+        }
+    }
+    if (flags_2nd) {
+        if (flecs_ref_is_written(op, &op->second, EcsQuerySecond, written)) {
+            second = flecs_get_ref_entity(&op->second, flags_2nd, ctx);
+        } else if (flags_2nd & EcsQueryIsVar) {
+            second = EcsWildcard;
+        }
+    }
+
+    if (flags_2nd & (EcsQueryIsVar | EcsQueryIsEntity)) {
+        return ecs_pair(first, second);
+    } else {
+        return flecs_entities_get_alive(ctx->world, first);
+    }
+}
 
+static
+ecs_id_t flecs_query_op_get_id(
+    const ecs_query_op_t *op,
+    const ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index];
+    return flecs_query_op_get_id_w_written(op, written, ctx);
+}
 
 static
-int32_t flecs_hashmap_find_key(
-    const ecs_hashmap_t *map,
-    ecs_vec_t *keys,
-    ecs_size_t key_size, 
-    const void *key)
+int16_t flecs_query_next_column(
+    ecs_table_t *table,
+    ecs_id_t id,
+    int32_t column)
 {
-    int32_t i, count = ecs_vec_count(keys);
-    void *key_array = ecs_vec_first(keys);
-    for (i = 0; i < count; i ++) {
-        void *key_ptr = ECS_OFFSET(key_array, key_size * i);
-        if (map->compare(key_ptr, key) == 0) {
-            return i;
-        }
+    if (!ECS_IS_PAIR(id) || (ECS_PAIR_FIRST(id) != EcsWildcard)) {
+        column = column + 1;
+    } else {
+        ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+        column = ecs_search_offset(NULL, table, column + 1, id, NULL);
+        ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL);
     }
-    return -1;
+    return flecs_ito(int16_t, column);
 }
 
-void flecs_hashmap_init_(
-    ecs_hashmap_t *map,
-    ecs_size_t key_size,
-    ecs_size_t value_size,
-    ecs_hash_value_action_t hash,
-    ecs_compare_action_t compare,
-    ecs_allocator_t *allocator)
+static
+void flecs_query_it_set_column(
+    ecs_iter_t *it,
+    int32_t field_index,
+    int32_t column)
 {
-    map->key_size = key_size;
-    map->value_size = value_size;
-    map->hash = hash;
-    map->compare = compare;
-    flecs_ballocator_init_t(&map->bucket_allocator, ecs_hm_bucket_t);
-    ecs_map_init(&map->impl, allocator);
+    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(field_index >= 0, ECS_INTERNAL_ERROR, NULL);
+    it->columns[field_index] = column;
 }
 
-void flecs_hashmap_fini(
-    ecs_hashmap_t *map)
+static
+ecs_id_t flecs_query_it_set_id(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t field_index,
+    int32_t column)
 {
-    ecs_allocator_t *a = map->impl.allocator;
-    ecs_map_iter_t it = ecs_map_iter(&map->impl);
+    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(field_index >= 0, ECS_INTERNAL_ERROR, NULL);
+    return it->ids[field_index] = table->type.array[column];
+}
 
-    while (ecs_map_next(&it)) {
-        ecs_hm_bucket_t *bucket = ecs_map_ptr(&it);
-        ecs_vec_fini(a, &bucket->keys, map->key_size);
-        ecs_vec_fini(a, &bucket->values, map->value_size);
-#ifdef FLECS_SANITIZE        
-        flecs_bfree(&map->bucket_allocator, bucket);
-#endif
+static
+void flecs_query_set_match(
+    const ecs_query_op_t *op,
+    ecs_table_t *table,
+    int32_t column,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+    int32_t field_index = op->field_index;
+    if (field_index == -1) {
+        return;
     }
 
-    flecs_ballocator_fini(&map->bucket_allocator);
-    ecs_map_fini(&map->impl);
+    ecs_iter_t *it = ctx->it;
+    flecs_query_it_set_column(it, field_index, column);
+    ecs_id_t matched = flecs_query_it_set_id(it, table, field_index, column);
+    flecs_query_set_vars(op, matched, ctx);
 }
 
-void flecs_hashmap_copy(
-    ecs_hashmap_t *dst,
-    const ecs_hashmap_t *src)
+static
+void flecs_query_set_trav_match(
+    const ecs_query_op_t *op,
+    int32_t column,
+    ecs_entity_t trav,
+    ecs_entity_t second,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(dst != src, ECS_INVALID_PARAMETER, NULL);
-
-    flecs_hashmap_init_(dst, src->key_size, src->value_size, src->hash, 
-        src->compare, src->impl.allocator);
-    ecs_map_copy(&dst->impl, &src->impl);
+    int32_t field_index = op->field_index;
+    if (field_index == -1) {
+        return;
+    }
 
-    ecs_allocator_t *a = dst->impl.allocator;
-    ecs_map_iter_t it = ecs_map_iter(&dst->impl);
-    while (ecs_map_next(&it)) {
-        ecs_hm_bucket_t **bucket_ptr = ecs_map_ref(&it, ecs_hm_bucket_t);
-        ecs_hm_bucket_t *src_bucket = bucket_ptr[0];
-        ecs_hm_bucket_t *dst_bucket = flecs_balloc(&dst->bucket_allocator);
-        bucket_ptr[0] = dst_bucket;
-        dst_bucket->keys = ecs_vec_copy(a, &src_bucket->keys, dst->key_size);
-        dst_bucket->values = ecs_vec_copy(a, &src_bucket->values, dst->value_size);
+    ecs_iter_t *it = ctx->it;
+    ecs_id_t matched = ecs_pair(trav, second);
+    it->ids[op->field_index] = matched;
+    if (column != -1) {
+        flecs_query_it_set_column(it, op->field_index, column);
     }
+    flecs_query_set_vars(op, matched, ctx);
 }
 
-void* flecs_hashmap_get_(
-    const ecs_hashmap_t *map,
-    ecs_size_t key_size,
-    const void *key,
-    ecs_size_t value_size)
+static
+bool flecs_query_table_filter(
+    ecs_table_t *table,
+    ecs_query_lbl_t other,
+    ecs_flags32_t filter_mask)
 {
-    ecs_assert(map->key_size == key_size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(map->value_size == value_size, ECS_INVALID_PARAMETER, NULL);
+    uint32_t filter = flecs_ito(uint32_t, other);
+    return (table->flags & filter_mask & filter) != 0;
+}
 
-    uint64_t hash = map->hash(key);
-    ecs_hm_bucket_t *bucket = ecs_map_get_deref(&map->impl, 
-        ecs_hm_bucket_t, hash);
-    if (!bucket) {
-        return NULL;
+static
+bool flecs_query_select_w_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_id_t id,
+    ecs_flags32_t filter_mask)
+{
+    ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+    ecs_id_record_t *idr = op_ctx->idr;
+    ecs_table_record_t *tr;
+    ecs_table_t *table;
+
+    if (!redo) {
+        if (!idr || idr->id != id) {
+            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
+            if (!idr) {
+                return false;
+            }
+        }
+
+        if (ctx->query->pub.flags & EcsQueryMatchEmptyTables) {
+            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
+        } else {
+            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
+        }
     }
 
-    int32_t index = flecs_hashmap_find_key(map, &bucket->keys, key_size, key);
-    if (index == -1) {
-        return NULL;
+repeat:
+    if (!redo || !op_ctx->remaining) {
+        tr = flecs_table_cache_next(&op_ctx->it, ecs_table_record_t);
+        if (!tr) {
+            return false;
+        }
+
+        op_ctx->column = flecs_ito(int16_t, tr->index);
+        op_ctx->remaining = flecs_ito(int16_t, tr->count - 1);
+        table = tr->hdr.table;
+        flecs_query_var_set_range(op, op->src.var, table, 0, 0, ctx);
+    } else {
+        tr = (ecs_table_record_t*)op_ctx->it.cur;
+        ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
+        table = tr->hdr.table;
+        op_ctx->column = flecs_query_next_column(table, idr->id, op_ctx->column);
+        op_ctx->remaining --;
     }
 
-    return ecs_vec_get(&bucket->values, value_size, index);
+    if (flecs_query_table_filter(table, op->other, filter_mask)) {
+        goto repeat;
+    }
+
+    flecs_query_set_match(op, table, op_ctx->column, ctx);
+    return true;
 }
 
-flecs_hashmap_result_t flecs_hashmap_ensure_(
-    ecs_hashmap_t *map,
-    ecs_size_t key_size,
-    const void *key,
-    ecs_size_t value_size)
+static
+bool flecs_query_select(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(map->key_size == key_size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(map->value_size == value_size, ECS_INVALID_PARAMETER, NULL);
+    ecs_id_t id = 0;
+    if (!redo) {
+        id = flecs_query_op_get_id(op, ctx);
+    }
+    return flecs_query_select_w_id(op, redo, ctx, id, 
+        (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled));
+}
 
-    uint64_t hash = map->hash(key);
-    ecs_hm_bucket_t **r = ecs_map_ensure_ref(&map->impl, ecs_hm_bucket_t, hash);
-    ecs_hm_bucket_t *bucket = r[0];
-    if (!bucket) {
-        bucket = r[0] = flecs_bcalloc(&map->bucket_allocator);
+static
+bool flecs_query_with(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+    ecs_id_record_t *idr = op_ctx->idr;
+    const ecs_table_record_t *tr;
+
+    ecs_table_t *table = flecs_query_get_table(op, &op->src, EcsQuerySrc, ctx);
+    if (!table) {
+        return false;
     }
 
-    ecs_allocator_t *a = map->impl.allocator;
-    void *value_ptr, *key_ptr;
-    ecs_vec_t *keys = &bucket->keys;
-    ecs_vec_t *values = &bucket->values;
-    if (!keys->array) {
-        keys = ecs_vec_init(a, &bucket->keys, key_size, 1);
-        values = ecs_vec_init(a, &bucket->values, value_size, 1);
-        key_ptr = ecs_vec_append(a, keys, key_size);        
-        value_ptr = ecs_vec_append(a, values, value_size);
-        ecs_os_memcpy(key_ptr, key, key_size);
-        ecs_os_memset(value_ptr, 0, value_size);
+    if (!redo) {
+        ecs_id_t id = flecs_query_op_get_id(op, ctx);
+        if (!idr || idr->id != id) {
+            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
+            if (!idr) {
+                return false;
+            }
+        }
+
+        tr = flecs_id_record_get_table(idr, table);
+        if (!tr) {
+            return false;
+        }
+
+        op_ctx->column = flecs_ito(int16_t, tr->index);
+        op_ctx->remaining = flecs_ito(int16_t, tr->count);
     } else {
-        int32_t index = flecs_hashmap_find_key(map, keys, key_size, key);
-        if (index == -1) {
-            key_ptr = ecs_vec_append(a, keys, key_size);        
-            value_ptr = ecs_vec_append(a, values, value_size);
-            ecs_os_memcpy(key_ptr, key, key_size);
-            ecs_os_memset(value_ptr, 0, value_size);
-        } else {
-            key_ptr = ecs_vec_get(keys, key_size, index);
-            value_ptr = ecs_vec_get(values, value_size, index);
+        if (--op_ctx->remaining <= 0) {
+            return false;
         }
+
+        op_ctx->column = flecs_query_next_column(table, idr->id, op_ctx->column);
+        ecs_assert(op_ctx->column != -1, ECS_INTERNAL_ERROR, NULL);
     }
 
-    return (flecs_hashmap_result_t){
-        .key = key_ptr, .value = value_ptr, .hash = hash
-    };
+    flecs_query_set_match(op, table, op_ctx->column, ctx);
+    return true;
 }
 
-void flecs_hashmap_set_(
-    ecs_hashmap_t *map,
-    ecs_size_t key_size,
-    void *key,
-    ecs_size_t value_size,
-    const void *value)
+static
+bool flecs_query_and(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    void *value_ptr = flecs_hashmap_ensure_(map, key_size, key, value_size).value;
-    ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_os_memcpy(value_ptr, value, value_size);
+    uint64_t written = ctx->written[ctx->op_index];
+    if (written & (1ull << op->src.var)) {
+        return flecs_query_with(op, redo, ctx);
+    } else {
+        return flecs_query_select(op, redo, ctx);
+    }
 }
 
-ecs_hm_bucket_t* flecs_hashmap_get_bucket(
-    const ecs_hashmap_t *map,
-    uint64_t hash)
+static
+bool flecs_query_select_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_flags32_t table_filter)
 {
-    ecs_assert(map != NULL, ECS_INTERNAL_ERROR, NULL);
-    return ecs_map_get_deref(&map->impl, ecs_hm_bucket_t, hash);
-}
+    ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+    ecs_iter_t *it = ctx->it;
+    int8_t field = op->field_index;
+    ecs_assert(field != -1, ECS_INTERNAL_ERROR, NULL);
 
-void flecs_hm_bucket_remove(
-    ecs_hashmap_t *map,
-    ecs_hm_bucket_t *bucket,
-    uint64_t hash,
-    int32_t index)
-{
-    ecs_vec_remove(&bucket->keys, map->key_size, index);
-    ecs_vec_remove(&bucket->values, map->value_size, index);
+    if (!redo) {
+        ecs_id_t id = it->ids[field];
+        ecs_id_record_t *idr = op_ctx->idr;
+        if (!idr || idr->id != id) {
+            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
+            if (!idr) {
+                return false;
+            }
+        }
 
-    if (!ecs_vec_count(&bucket->keys)) {
-        ecs_allocator_t *a = map->impl.allocator;
-        ecs_vec_fini(a, &bucket->keys, map->key_size);
-        ecs_vec_fini(a, &bucket->values, map->value_size);
-        ecs_hm_bucket_t *b = ecs_map_remove_ptr(&map->impl, hash);
-        ecs_assert(bucket == b, ECS_INTERNAL_ERROR, NULL); (void)b;
-        flecs_bfree(&map->bucket_allocator, bucket);
+        if (ctx->query->pub.flags & EcsQueryMatchEmptyTables) {
+            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
+        } else {
+            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
+        }
+    }
+
+repeat: {}
+    const ecs_table_record_t *tr = flecs_table_cache_next(
+        &op_ctx->it, ecs_table_record_t);
+    if (!tr) {
+        return false;
+    }
+
+    ecs_table_t *table = tr->hdr.table;
+    if (flecs_query_table_filter(table, op->other, table_filter)) {
+        goto repeat;
     }
+
+    flecs_query_var_set_range(op, op->src.var, table, 0, 0, ctx);
+    flecs_query_it_set_column(it, field, tr->index);
+    return true;
 }
 
-void flecs_hashmap_remove_w_hash_(
-    ecs_hashmap_t *map,
-    ecs_size_t key_size,
-    const void *key,
-    ecs_size_t value_size,
-    uint64_t hash)
+static
+bool flecs_query_with_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(map->key_size == key_size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(map->value_size == value_size, ECS_INVALID_PARAMETER, NULL);
-    (void)value_size;
+    if (redo) {
+        return false;
+    }
 
-    ecs_hm_bucket_t *bucket = ecs_map_get_deref(&map->impl, 
-        ecs_hm_bucket_t, hash);
-    if (!bucket) {
-        return;
+    ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+    ecs_iter_t *it = ctx->it;
+    int8_t field = op->field_index;
+    ecs_assert(field != -1, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_table_t *table = flecs_query_get_table(op, &op->src, EcsQuerySrc, ctx);
+    if (!table) {
+        return false;
     }
 
-    int32_t index = flecs_hashmap_find_key(map, &bucket->keys, key_size, key);
-    if (index == -1) {
-        return;
+    ecs_id_t id = it->ids[field];
+    ecs_id_record_t *idr = op_ctx->idr;
+    if (!idr || idr->id != id) {
+        idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
+        if (!idr) {
+            return false;
+        }
+    }
+
+    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+    if (!tr) {
+        return false;
     }
 
-    flecs_hm_bucket_remove(map, bucket, hash, index);
+    flecs_query_it_set_column(it, field, tr->index);
+    return true;
 }
 
-void flecs_hashmap_remove_(
-    ecs_hashmap_t *map,
-    ecs_size_t key_size,
-    const void *key,
-    ecs_size_t value_size)
+static
+bool flecs_query_and_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(map->key_size == key_size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(map->value_size == value_size, ECS_INVALID_PARAMETER, NULL);
-
-    uint64_t hash = map->hash(key);
-    flecs_hashmap_remove_w_hash_(map, key_size, key, value_size, hash);
+    uint64_t written = ctx->written[ctx->op_index];
+    if (written & (1ull << op->src.var)) {
+        return flecs_query_with_id(op, redo, ctx);
+    } else {
+        return flecs_query_select_id(op, redo, ctx, 
+            (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled));
+    }
 }
 
-flecs_hashmap_iter_t flecs_hashmap_iter(
-    ecs_hashmap_t *map)
+static
+bool flecs_query_up_select(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    bool self,
+    bool id_only)
 {
-    return (flecs_hashmap_iter_t){
-        .it = ecs_map_iter(&map->impl)
-    };
-}
+    ecs_query_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
+    ecs_world_t *world = ctx->world;
+    ecs_iter_t *it = ctx->it;
+    bool redo_select = redo;
+    const ecs_query_t *q = &ctx->query->pub;
 
-void* flecs_hashmap_next_(
-    flecs_hashmap_iter_t *it,
-    ecs_size_t key_size,
-    void *key_out,
-    ecs_size_t value_size)
-{
-    int32_t index = ++ it->index;
-    ecs_hm_bucket_t *bucket = it->bucket;
-    while (!bucket || it->index >= ecs_vec_count(&bucket->keys)) {
-        ecs_map_next(&it->it);
-        bucket = it->bucket = ecs_map_ptr(&it->it);
-        if (!bucket) {
-            return NULL;
+    /* Early out if traversal relationship doesn't exist */
+    op_ctx->trav = q->terms[op->term_index].trav;
+    if (!op_ctx->idr_trav) {
+        op_ctx->idr_trav = flecs_id_record_get(ctx->world, 
+            ecs_pair(op_ctx->trav, EcsWildcard));
+    }
+    if (!op_ctx->idr_trav || !flecs_table_cache_count(&op_ctx->idr_trav->cache)){
+        if (!self) {
+            return false;
+        } else if (id_only) {
+            return flecs_query_select_id(op, redo, ctx,
+                (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled));
+        } else {
+            return flecs_query_select(op, redo, ctx);
         }
-        index = it->index = 0;
     }
 
-    if (key_out) {
-        *(void**)key_out = ecs_vec_get(&bucket->keys, key_size, index);
+    if (!redo) {
+        op_ctx->with = flecs_query_op_get_id(op, ctx);
+        op_ctx->idr_with = flecs_id_record_get(ctx->world, op_ctx->with);
+        if (!op_ctx->idr_with) {
+            return false;
+        }
+
+        op_ctx->down = NULL;
+        op_ctx->cache_elem = 0;
     }
-    
-    return ecs_vec_get(&bucket->values, value_size, index);
-}
 
-/**
- * @file datastructures/map.c
- * @brief Map data structure.
- * 
- * Map data structure for 64bit keys and dynamic payload size.
- */
+    ecs_trav_down_t *down = op_ctx->down;
 
+    do {
+        while (!down) {
+            ecs_table_t *table = op_ctx->table;
+            if (!table) {
+                ecs_table_range_t range;
+                it->sources[op->field_index] = 0;
+                do {
+                    bool result;
+                    if (id_only) {
+                        result = flecs_query_select_id(op, redo_select, ctx, 0);
+                    } else {
+                        result = flecs_query_select_w_id(op, redo_select, ctx, 
+                            op_ctx->with, 0);
+                    }
+                    if (!result) {
+                        return false;
+                    }
 
-/* The ratio used to determine whether the map should flecs_map_rehash. If
- * (element_count * ECS_LOAD_FACTOR) > bucket_count, bucket count is increased. */
-#define ECS_LOAD_FACTOR (12)
-#define ECS_BUCKET_END(b, c) ECS_ELEM_T(b, ecs_bucket_t, c)
+                    redo_select = true;
 
-static
-uint8_t flecs_log2(uint32_t v) {
-    static const uint8_t log2table[32] = 
-        {0, 9,  1,  10, 13, 21, 2,  29, 11, 14, 16, 18, 22, 25, 3, 30,
-         8, 12, 20, 28, 15, 17, 24, 7,  19, 27, 23, 6,  26, 5,  4, 31};
+                    range = flecs_query_get_range(
+                        op, &op->src, EcsQuerySrc, ctx);
+                    ecs_assert(range.table != NULL, ECS_INTERNAL_ERROR, NULL);
+                } while (!self && range.table->_->traversable_count == 0);
 
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    return log2table[(uint32_t)(v * 0x07C4ACDDU) >> 27];
-}
+                if (!range.count) {
+                    range.count = ecs_table_count(range.table);
+                }
 
-/* Get bucket count for number of elements */
-static
-int32_t flecs_map_get_bucket_count(
-    int32_t count)
-{
-    return flecs_next_pow_of_2((int32_t)(count * ECS_LOAD_FACTOR * 0.1));
-}
+                table = op_ctx->table = range.table;
+                op_ctx->row = range.offset;
+                op_ctx->end = range.offset + range.count;
+                op_ctx->matched = it->ids[op->field_index];
 
-/* Get bucket shift amount for a given bucket count */
-static
-uint8_t flecs_map_get_bucket_shift (
-    int32_t bucket_count)
-{
-    return (uint8_t)(64u - flecs_log2((uint32_t)bucket_count));
-}
+                if (self) {
+                    if (!flecs_query_table_filter(table, op->other, 
+                        (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)))
+                    {
+                        flecs_reset_source_set_flag(it, op->field_index);
+                        op_ctx->row --;
+                        return true;
+                    }
+                }
 
-/* Get bucket index for provided map key */
-static
-int32_t flecs_map_get_bucket_index(
-    uint16_t bucket_shift,
-    ecs_map_key_t key) 
-{
-    ecs_assert(bucket_shift != 0, ECS_INTERNAL_ERROR, NULL);
-    return (int32_t)((11400714819323198485ull * key) >> bucket_shift);
-}
+                redo_select = true;
+            } else {
+                op_ctx->row ++;
+            }
 
-/* Get bucket for key */
-static
-ecs_bucket_t* flecs_map_get_bucket(
-    const ecs_map_t *map,
-    ecs_map_key_t key)
-{
-    ecs_assert(map != NULL, ECS_INVALID_PARAMETER, NULL);
-    int32_t bucket_id = flecs_map_get_bucket_index(map->bucket_shift, key);
-    ecs_assert(bucket_id < map->bucket_count, ECS_INTERNAL_ERROR, NULL);
-    return &map->buckets[bucket_id];
-}
+            if (table->_->traversable_count == 0) {
+                op_ctx->table = NULL;
+                continue;
+            } else {
+                int32_t row;
+                ecs_entity_t entity = 0;
+                ecs_entity_t *entities = flecs_table_entities_array(table);
 
-/* Add element to bucket */
-static
-ecs_map_val_t* flecs_map_bucket_add(
-    ecs_block_allocator_t *allocator,
-    ecs_bucket_t *bucket,
-    ecs_map_key_t key)
-{
-    ecs_bucket_entry_t *new_entry = flecs_balloc(allocator);
-    new_entry->key = key;
-    new_entry->next = bucket->first;
-    bucket->first = new_entry;
-    return &new_entry->value;
-}
+                for (row = op_ctx->row; row < op_ctx->end; row ++) {
+                    entity = entities[row];
+                    ecs_record_t *record = flecs_entities_get(world, entity);
+                    if (record->row & EcsEntityIsTraversable) {
+                        it->sources[op->field_index] = entity;
+                        break;
+                    }
+                }
 
-/* Remove element from bucket */
-static
-ecs_map_val_t flecs_map_bucket_remove(
-    ecs_map_t *map,
-    ecs_bucket_t *bucket,
-    ecs_map_key_t key)
-{
-    ecs_bucket_entry_t *entry;
-    for (entry = bucket->first; entry; entry = entry->next) {
-        if (entry->key == key) {
-            ecs_map_val_t value = entry->value;
-            ecs_bucket_entry_t **next_holder = &bucket->first;
-            while(*next_holder != entry) {
-                next_holder = &(*next_holder)->next;
+                if (row == op_ctx->end) {
+                    op_ctx->table = NULL;
+                    continue;
+                }
+
+                bool match_empty = (q->flags & EcsQueryMatchEmptyTables) != 0;
+                down = op_ctx->down = flecs_query_get_down_cache(ctx, &op_ctx->cache, 
+                    op_ctx->trav, entity, op_ctx->idr_with, self, match_empty);
+                op_ctx->cache_elem = -1;
             }
-            *next_holder = entry->next;
-            flecs_bfree(map->entry_allocator, entry);
-            map->count --;
-            return value;
         }
-    }
-    
-    return 0;
+
+next_elem:
+        if ((++ op_ctx->cache_elem) >= ecs_vec_count(&down->elems)) {
+            down = NULL;
+            continue;
+        }
+
+        ecs_trav_down_elem_t *elem = ecs_vec_get_t(
+            &down->elems, ecs_trav_down_elem_t, op_ctx->cache_elem);
+
+        flecs_query_var_set_range(op, op->src.var, elem->table, 0, 0, ctx);
+        flecs_query_set_vars(op, op_ctx->matched, ctx);
+
+        if (flecs_query_table_filter(elem->table, op->other, 
+            (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)))
+        {
+            goto next_elem;
+        }
+
+        break;
+    } while (true);
+
+    flecs_set_source_set_flag(it, op->field_index);
+
+    return true;
 }
 
-/* Free contents of bucket */
 static
-void flecs_map_bucket_clear(
-    ecs_block_allocator_t *allocator,
-    ecs_bucket_t *bucket)
+bool flecs_query_up_with(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_bucket_entry_t *entry = bucket->first;
-    while(entry) {
-        ecs_bucket_entry_t *next = entry->next;
-        flecs_bfree(allocator, entry);
-        entry = next;
+    const ecs_query_t *q = &ctx->query->pub;
+    ecs_query_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
+    ecs_iter_t *it = ctx->it;
+
+    /* Early out if traversal relationship doesn't exist */
+    op_ctx->trav = q->terms[op->term_index].trav;
+    if (!op_ctx->idr_trav) {
+        op_ctx->idr_trav = flecs_id_record_get(ctx->world, 
+            ecs_pair(op_ctx->trav, EcsWildcard));
+    }
+    if (!op_ctx->idr_trav || !flecs_table_cache_all_count(&op_ctx->idr_trav->cache)){
+        return false;
     }
-}
 
-/* Get payload pointer for key from bucket */
-static
-ecs_map_val_t* flecs_map_bucket_get(
-    ecs_bucket_t *bucket,
-    ecs_map_key_t key)
-{
-    ecs_bucket_entry_t *entry;
-    for (entry = bucket->first; entry; entry = entry->next) {
-        if (entry->key == key) {
-            return &entry->value;
+    if (!redo) {
+        op_ctx->trav = q->terms[op->term_index].trav;
+        op_ctx->with = flecs_query_op_get_id(op, ctx);
+        op_ctx->idr_with = flecs_id_record_get(ctx->world, op_ctx->with);
+
+        if (!op_ctx->idr_with) {
+            return false;
         }
+
+        ecs_table_range_t range = flecs_query_get_range(
+            op, &op->src, EcsQuerySrc, ctx);
+        if (!range.table) {
+            return false;
+        }
+
+        ecs_trav_up_t *up = flecs_query_get_up_cache(ctx, &op_ctx->cache, 
+            range.table, op_ctx->with, op_ctx->trav, op_ctx->idr_with,
+            op_ctx->idr_trav);
+
+        if (!up) {
+            return false;
+        }
+
+        it->sources[op->field_index] = flecs_entities_get_alive(
+            ctx->world, up->src);
+        it->columns[op->field_index] = up->column;
+        it->ids[op->field_index] = up->id;
+        flecs_query_set_vars(op, up->id, ctx);
+        flecs_set_source_set_flag(it, op->field_index);
+        return true;
+    } else {
+        return false;
     }
-    return NULL;
 }
 
-/* Grow number of buckets */
 static
-void flecs_map_rehash(
-    ecs_map_t *map,
-    int32_t count)
+bool flecs_query_self_up_with(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    bool id_only)
 {
-    count = flecs_next_pow_of_2(count);
-    if (count < 2) {
-        count = 2;
-    }
-    ecs_assert(count > map->bucket_count, ECS_INTERNAL_ERROR, NULL);
-    
-    int32_t old_count = map->bucket_count;
-    ecs_bucket_t *buckets = map->buckets, *b, *end = ECS_BUCKET_END(buckets, old_count);
+    if (!redo) {
+        bool result;
+        if (id_only) {
+            result = flecs_query_with_id(op, redo, ctx);
+        } else {
+            result = flecs_query_with(op, redo, ctx);
+        }
 
-    if (map->allocator) {
-        map->buckets = flecs_calloc_n(map->allocator, ecs_bucket_t, count);
-    } else {
-        map->buckets = ecs_os_calloc_n(ecs_bucket_t, count);
-    }
-    map->bucket_count = count;
-    map->bucket_shift = flecs_map_get_bucket_shift(count);
+        flecs_reset_source_set_flag(ctx->it, op->field_index);
 
-    /* Remap old bucket entries to new buckets */
-    for (b = buckets; b < end; b++) {
-        ecs_bucket_entry_t* entry;
-        for (entry = b->first; entry;) {
-            ecs_bucket_entry_t* next = entry->next;
-            int32_t bucket_index = flecs_map_get_bucket_index(
-                map->bucket_shift, entry->key);
-            ecs_bucket_t *bucket = &map->buckets[bucket_index];
-            entry->next = bucket->first;
-            bucket->first = entry;
-            entry = next;
+        if (result) {
+            ecs_query_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
+            op_ctx->trav = 0;
+            if (flecs_query_ref_flags(op->flags, EcsQuerySrc) & EcsQueryIsVar) {
+                ecs_iter_t *it = ctx->it;
+                it->sources[op->field_index] = 0;
+            }
+            return true;
         }
-    }
 
-    if (map->allocator) {
-        flecs_free_n(map->allocator, ecs_bucket_t, old_count, buckets);
+        return flecs_query_up_with(op, redo, ctx);
     } else {
-        ecs_os_free(buckets);
+        ecs_query_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
+        if (op_ctx->trav == 0) {
+            return flecs_query_with(op, redo, ctx);
+        }
     }
-}
 
-void ecs_map_params_init(
-    ecs_map_params_t *params,
-    ecs_allocator_t *allocator)
-{
-    params->allocator = allocator;
-    flecs_ballocator_init_t(&params->entry_allocator, ecs_bucket_entry_t);
+    return false;
 }
 
-void ecs_map_params_fini(
-    ecs_map_params_t *params)
+static
+bool flecs_query_up(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    flecs_ballocator_fini(&params->entry_allocator);
+    uint64_t written = ctx->written[ctx->op_index];
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        return flecs_query_up_with(op, redo, ctx);
+    } else {
+        return flecs_query_up_select(op, redo, ctx, false, false);
+    }
 }
 
-void ecs_map_init_w_params(
-    ecs_map_t *result,
-    ecs_map_params_t *params)
+static
+bool flecs_query_self_up(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_os_zeromem(result);
-
-    result->allocator = params->allocator;
-
-    if (params->entry_allocator.chunk_size) {
-        result->entry_allocator = &params->entry_allocator;
-        result->shared_allocator = true;
+    uint64_t written = ctx->written[ctx->op_index];
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        return flecs_query_self_up_with(op, redo, ctx, false);
     } else {
-        result->entry_allocator = flecs_ballocator_new_t(ecs_bucket_entry_t);
+        return flecs_query_up_select(op, redo, ctx, true, false);
     }
-
-    flecs_map_rehash(result, 0);
 }
 
-void ecs_map_init_w_params_if(
-    ecs_map_t *result,
-    ecs_map_params_t *params)
+static
+bool flecs_query_up_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    if (!ecs_map_is_init(result)) {
-        ecs_map_init_w_params(result, params);
+    uint64_t written = ctx->written[ctx->op_index];
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        return flecs_query_up_with(op, redo, ctx);
+    } else {
+        return flecs_query_up_select(op, redo, ctx, false, true);
     }
 }
 
-void ecs_map_init(
-    ecs_map_t *result,
-    ecs_allocator_t *allocator)
+static
+bool flecs_query_self_up_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_map_init_w_params(result, &(ecs_map_params_t) {
-        .allocator = allocator
-    });
+    uint64_t written = ctx->written[ctx->op_index];
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        return flecs_query_self_up_with(op, redo, ctx, true);
+    } else {
+        return flecs_query_up_select(op, redo, ctx, true, true);
+    }
 }
 
-void ecs_map_init_if(
-    ecs_map_t *result,
-    ecs_allocator_t *allocator)
+static
+bool flecs_query_select_any(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    if (!ecs_map_is_init(result)) {
-        ecs_map_init(result, allocator);
-    }   
+    return flecs_query_select_w_id(op, redo, ctx, EcsAny, 
+        (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled));
 }
 
-void ecs_map_fini(
-    ecs_map_t *map)
+static
+bool flecs_query_and_any(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    if (!ecs_map_is_init(map)) {
-        return;
-    }
-
-    bool sanitize = false;
-#ifdef FLECS_SANITIZE
-    sanitize = true;
-#endif
-
-    /* Free buckets in sanitized mode, so we can replace the allocator with
-     * regular malloc/free and use asan/valgrind to find memory errors. */
-    ecs_allocator_t *a = map->allocator;
-    ecs_block_allocator_t *ea = map->entry_allocator;
-    if (map->shared_allocator || sanitize) {
-        ecs_bucket_t *bucket = map->buckets, *end = &bucket[map->bucket_count];
-        while (bucket != end) {
-            flecs_map_bucket_clear(ea, bucket);
-            bucket ++;
+    ecs_flags16_t match_flags = op->match_flags;
+    if (redo) {
+        if (match_flags & EcsTermMatchAnySrc) {
+            return false;
         }
     }
 
-    if (ea && !map->shared_allocator) {
-        flecs_ballocator_free(ea);
-        map->entry_allocator = NULL;
-    }
-    if (a) {
-        flecs_free_n(a, ecs_bucket_t, map->bucket_count, map->buckets);
+    uint64_t written = ctx->written[ctx->op_index];
+    int32_t remaining = 1;
+    bool result;
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        result = flecs_query_with(op, redo, ctx);
     } else {
-        ecs_os_free(map->buckets);
+        result = flecs_query_select(op, redo, ctx);
+        remaining = 0;
     }
 
-    map->bucket_shift = 0;
-}
-
-ecs_map_val_t* ecs_map_get(
-    const ecs_map_t *map,
-    ecs_map_key_t key)
-{
-    return flecs_map_bucket_get(flecs_map_get_bucket(map, key), key);
-}
-
-void* ecs_map_get_deref_(
-    const ecs_map_t *map,
-    ecs_map_key_t key)
-{
-    ecs_map_val_t* ptr = flecs_map_bucket_get(
-        flecs_map_get_bucket(map, key), key);
-    if (ptr) {
-        return (void*)(uintptr_t)ptr[0];
+    if (!redo) {
+        ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+        if (match_flags & EcsTermMatchAny && op_ctx->remaining) {
+            op_ctx->remaining = flecs_ito(int16_t, remaining);
+        }
     }
-    return NULL;
-}
 
-void ecs_map_insert(
-    ecs_map_t *map,
-    ecs_map_key_t key,
-    ecs_map_val_t value)
-{
-    ecs_assert(ecs_map_get(map, key) == NULL, ECS_INVALID_PARAMETER, NULL);
-    int32_t map_count = ++map->count;
-    int32_t tgt_bucket_count = flecs_map_get_bucket_count(map_count);
-    int32_t bucket_count = map->bucket_count;
-    if (tgt_bucket_count > bucket_count) {
-        flecs_map_rehash(map, tgt_bucket_count);
+    int32_t field = op->field_index;
+    if (field != -1) {
+        ctx->it->ids[field] = flecs_query_op_get_id(op, ctx);
     }
 
-    ecs_bucket_t *bucket = flecs_map_get_bucket(map, key);
-    flecs_map_bucket_add(map->entry_allocator, bucket, key)[0] = value;
+    return result;
 }
 
-void* ecs_map_insert_alloc(
-    ecs_map_t *map,
-    ecs_size_t elem_size,
-    ecs_map_key_t key)
+static
+bool flecs_query_triv(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    void *elem = ecs_os_calloc(elem_size);
-    ecs_map_insert_ptr(map, key, (uintptr_t)elem);
-    return elem;
+    ecs_query_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
+    ecs_flags64_t termset = op->src.entity;
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        flecs_query_set_iter_this(ctx->it, ctx);
+        return flecs_query_trivial_test(
+            ctx->query, ctx, !redo, termset);
+    } else {
+        return flecs_query_trivial_search_nodata(
+            ctx->query, ctx, op_ctx, !redo, termset);
+    }
 }
 
-ecs_map_val_t* ecs_map_ensure(
-    ecs_map_t *map,
-    ecs_map_key_t key)
+static
+bool flecs_query_triv_data(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_bucket_t *bucket = flecs_map_get_bucket(map, key);
-    ecs_map_val_t *result = flecs_map_bucket_get(bucket, key);
-    if (result) {
-        return result;
-    }
-
-    int32_t map_count = ++map->count;
-    int32_t tgt_bucket_count = flecs_map_get_bucket_count(map_count);
-    int32_t bucket_count = map->bucket_count;
-    if (tgt_bucket_count > bucket_count) {
-        flecs_map_rehash(map, tgt_bucket_count);
-        bucket = flecs_map_get_bucket(map, key);
+    ecs_query_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
+    ecs_flags64_t termset = op->src.entity;
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        flecs_query_set_iter_this(ctx->it, ctx);
+        return flecs_query_trivial_test(
+            ctx->query, ctx, !redo, termset);
+    } else {
+        return flecs_query_trivial_search(
+            ctx->query, ctx, op_ctx, !redo, termset);
     }
-
-    ecs_map_val_t* v = flecs_map_bucket_add(map->entry_allocator, bucket, key);
-    *v = 0;
-    return v;
 }
 
-void* ecs_map_ensure_alloc(
-    ecs_map_t *map,
-    ecs_size_t elem_size,
-    ecs_map_key_t key)
+static
+bool flecs_query_triv_wildcard(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_map_val_t *val = ecs_map_ensure(map, key);
-    if (!*val) {
-        void *elem = ecs_os_calloc(elem_size);
-        *val = (ecs_map_val_t)(uintptr_t)elem;
-        return elem;
+    ecs_query_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
+    ecs_flags64_t termset = op->src.entity;
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        flecs_query_set_iter_this(ctx->it, ctx);
+        return flecs_query_trivial_test_w_wildcards(
+            ctx->query, ctx, !redo, termset);
     } else {
-        return (void*)(uintptr_t)*val;
+        return flecs_query_trivial_search_w_wildcards(
+            ctx->query, ctx, op_ctx, !redo, termset);
     }
 }
 
-ecs_map_val_t ecs_map_remove(
-    ecs_map_t *map,
-    ecs_map_key_t key)
+static
+bool flecs_query_cache(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    return flecs_map_bucket_remove(map, flecs_map_get_bucket(map, key), key);
+    (void)op;
+    (void)redo;
+
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        return flecs_query_cache_test(ctx->query, ctx, !redo);
+    } else {
+        return flecs_query_cache_search(ctx->query, ctx);
+    }
 }
 
-void ecs_map_remove_free(
-    ecs_map_t *map,
-    ecs_map_key_t key)
+static
+bool flecs_query_cache_data(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_map_val_t val = ecs_map_remove(map, key);
-    if (val) {
-        ecs_os_free((void*)(uintptr_t)val);
+    (void)op;
+    (void)redo;
+
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        return flecs_query_cache_data_test(ctx->query, ctx, !redo);
+    } else {
+        return flecs_query_cache_data_search(ctx->query, ctx);
     }
 }
 
-void ecs_map_clear(
-    ecs_map_t *map)
+static
+bool flecs_query_is_cache(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(map != NULL, ECS_INVALID_PARAMETER, NULL);
-    int32_t i, count = map->bucket_count;
-    for (i = 0; i < count; i ++) {
-        flecs_map_bucket_clear(map->entry_allocator, &map->buckets[i]);
-    }
-    if (map->allocator) {
-        flecs_free_n(map->allocator, ecs_bucket_t, count, map->buckets);
+    (void)op;
+
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        return flecs_query_is_cache_test(ctx->query, ctx, !redo);
     } else {
-        ecs_os_free(map->buckets);
+        return flecs_query_is_cache_search(ctx->query, ctx);
     }
-    map->buckets = NULL;
-    map->bucket_count = 0;
-    map->count = 0;
-    flecs_map_rehash(map, 2);
 }
 
-ecs_map_iter_t ecs_map_iter(
-    const ecs_map_t *map)
+static
+bool flecs_query_is_cache_data(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    if (ecs_map_is_init(map)) {
-        return (ecs_map_iter_t){
-            .map = map,
-            .bucket = NULL,
-            .entry = NULL
-        };
+    (void)op;
+
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        return flecs_query_is_cache_data_test(ctx->query, ctx, !redo);
     } else {
-        return (ecs_map_iter_t){ 0 };
+        return flecs_query_is_cache_data_search(ctx->query, ctx);
     }
 }
 
-bool ecs_map_next(
-    ecs_map_iter_t *iter)
+static
+bool flecs_query_trav_fixed_src_reflexive(
+    const ecs_query_op_t *op,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_table_range_t *range,
+    ecs_entity_t trav,
+    ecs_entity_t second)
 {
-    const ecs_map_t *map = iter->map;
-    ecs_bucket_t *end;
-    if (!map || (iter->bucket == (end = &map->buckets[map->bucket_count]))) {
+    ecs_table_t *table = range->table;
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_entity_t *entities = table->data.entities.array;
+    int32_t count = range->count;
+    if (!count) {
+        count = ecs_table_count(table);
+    }
+
+    int32_t i = range->offset, end = i + count;
+    for (; i < end; i ++) {
+        if (entities[i] == second) {
+            /* Even though table doesn't have the specific relationship 
+             * pair, the relationship is reflexive and the target entity
+             * is stored in the table. */
+            break;
+        }
+    }
+    if (i == end) {
+        /* Table didn't contain target entity */
         return false;
     }
+    if (count > 1) {
+        /* If the range contains more than one entity, set the range to
+         * return only the entity matched by the reflexive property. */
+        ecs_assert(flecs_query_ref_flags(op->flags, EcsQuerySrc) & EcsQueryIsVar, 
+            ECS_INTERNAL_ERROR, NULL);
+        ecs_var_t *var = &ctx->vars[op->src.var];
+        ecs_table_range_t *var_range = &var->range;
+        var_range->offset = i;
+        var_range->count = 1;
+        var->entity = entities[i];
+    }
 
-    ecs_bucket_entry_t *entry = NULL;
-    if (!iter->bucket) {
-        for (iter->bucket = map->buckets; 
-            iter->bucket != end;
-            ++iter->bucket) 
+    flecs_query_set_trav_match(op, -1, trav, second, ctx);
+    return true;
+}
+
+static
+bool flecs_query_trav_unknown_src_reflexive(
+    const ecs_query_op_t *op,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_entity_t trav,
+    ecs_entity_t second)
+{
+    ecs_assert(flecs_query_ref_flags(op->flags, EcsQuerySrc) & EcsQueryIsVar,
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_var_id_t src_var = op->src.var;
+    flecs_query_var_set_entity(op, src_var, second, ctx);
+    flecs_query_var_get_table(src_var, ctx);
+
+    ecs_table_t *table = ctx->vars[src_var].range.table;
+    if (table) {
+        if (flecs_query_table_filter(table, op->other, 
+            (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)))
         {
-            if (iter->bucket->first) {
-                entry = iter->bucket->first;
-                break;
-            }
-        }
-        if (iter->bucket == end) {
             return false;
         }
-    } else if ((entry = iter->entry) == NULL) {
-        do {
-            ++iter->bucket;
-            if (iter->bucket == end) {
-                return false;
-            }
-        } while(!iter->bucket->first);
-        entry = iter->bucket->first;
     }
 
-    ecs_assert(entry != NULL, ECS_INTERNAL_ERROR, NULL);
-    iter->entry = entry->next;
-    iter->res = &entry->key;
-
+    flecs_query_set_trav_match(op, -1, trav, second, ctx);
     return true;
 }
 
-void ecs_map_copy(
-    ecs_map_t *dst,
-    const ecs_map_t *src)
+static
+bool flecs_query_trav_fixed_src_up_fixed_second(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    if (ecs_map_is_init(dst)) {
-        ecs_assert(ecs_map_count(dst) == 0, ECS_INVALID_PARAMETER, NULL);
-        ecs_map_fini(dst);
-    }
-    
-    if (!ecs_map_is_init(src)) {
-        return;
+    if (redo) {
+        return false; /* If everything's fixed, can only have a single result */
     }
 
-    ecs_map_init(dst, src->allocator);
+    ecs_flags16_t f_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t f_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+    ecs_flags16_t f_src = flecs_query_ref_flags(op->flags, EcsQuerySrc);
+    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
+    ecs_entity_t second = flecs_get_ref_entity(&op->second, f_2nd, ctx);
+    ecs_table_range_t range = flecs_get_ref_range(&op->src, f_src, ctx);
+    ecs_table_t *table = range.table;
 
-    ecs_map_iter_t it = ecs_map_iter(src);
-    while (ecs_map_next(&it)) {
-        ecs_map_insert(dst, ecs_map_key(&it), ecs_map_value(&it));
+    /* Check if table has transitive relationship by traversing upwards */
+    int32_t column = ecs_search_relation(ctx->world, table, 0, 
+        ecs_pair(trav, second), trav, EcsSelf|EcsUp, NULL, NULL, NULL);
+    if (column == -1) {
+        if (op->match_flags & EcsTermReflexive) {
+            return flecs_query_trav_fixed_src_reflexive(op, ctx,
+                &range, trav, second);
+        } else {
+            return false;
+        }
     }
-}
-
-/**
- * @file datastructures/name_index.c
- * @brief Data structure for resolving 64bit keys by string (name).
- */
 
+    flecs_query_set_trav_match(op, column, trav, second, ctx);
+    return true;
+}
 
 static
-uint64_t flecs_name_index_hash(
-    const void *ptr)
+bool flecs_query_trav_unknown_src_up_fixed_second(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    const ecs_hashed_string_t *str = ptr;
-    ecs_assert(str->hash != 0, ECS_INTERNAL_ERROR, NULL);
-    return str->hash;
+    ecs_flags16_t f_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t f_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
+    ecs_entity_t second = flecs_get_ref_entity(&op->second, f_2nd, ctx);
+    ecs_query_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
+
+    if (!redo) {
+        ecs_record_t *r_second = flecs_entities_get(ctx->world, second);
+        bool traversable = r_second && r_second->row & EcsEntityIsTraversable;
+        bool reflexive = op->match_flags & EcsTermReflexive;
+        if (!traversable && !reflexive) {
+            trav_ctx->cache.id = 0;
+
+            /* If there's no record for the entity, it can't have a subtree so
+             * forward operation to a regular select. */
+            return flecs_query_select(op, redo, ctx);
+        }
+
+        /* Entity is traversable, which means it could have a subtree */
+        flecs_query_get_trav_down_cache(ctx, &trav_ctx->cache, trav, second);
+        trav_ctx->index = 0;
+
+        if (op->match_flags & EcsTermReflexive) {
+            trav_ctx->index = -1;
+            if(flecs_query_trav_unknown_src_reflexive(
+                op, ctx, trav, second))
+            {
+                /* It's possible that we couldn't return the entity required for
+                 * reflexive matching, like when it's a prefab or disabled. */
+                return true;
+            }
+        }
+    } else {
+        if (!trav_ctx->cache.id) {
+            /* No traversal cache, which means this is a regular select */
+            return flecs_query_select(op, redo, ctx);
+        }
+    }
+
+    if (trav_ctx->index == -1) {
+        redo = false; /* First result after handling reflexive relationship */
+        trav_ctx->index = 0;
+    }
+
+    /* Forward to select */
+    int32_t count = ecs_vec_count(&trav_ctx->cache.entities);
+    ecs_trav_elem_t *elems = ecs_vec_first(&trav_ctx->cache.entities);
+    for (; trav_ctx->index < count; trav_ctx->index ++) {
+        ecs_trav_elem_t *el = &elems[trav_ctx->index];
+        trav_ctx->and.idr = el->idr; /* prevents lookup by select */
+        if (flecs_query_select_w_id(op, redo, ctx, ecs_pair(trav, el->entity),
+            (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled))) 
+        {
+            return true;
+        }
+        
+        redo = false;
+    }
+
+    return false;
 }
 
 static
-int flecs_name_index_compare(
-    const void *ptr1, 
-    const void *ptr2)
+bool flecs_query_trav_yield_reflexive_src(
+    const ecs_query_op_t *op,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_table_range_t *range,
+    ecs_entity_t trav)
 {
-    const ecs_hashed_string_t *str1 = ptr1;
-    const ecs_hashed_string_t *str2 = ptr2;
-    ecs_size_t len1 = str1->length;
-    ecs_size_t len2 = str2->length;
-    if (len1 != len2) {
-        return (len1 > len2) - (len1 < len2);
+    ecs_var_t *vars = ctx->vars;
+    ecs_query_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
+    int32_t offset = trav_ctx->offset, count = trav_ctx->count;
+    bool src_is_var = op->flags & (EcsQueryIsVar << EcsQuerySrc);
+
+    if (trav_ctx->index >= (offset + count)) {
+        /* Restore previous offset, count */
+        if (src_is_var) {
+            ecs_var_id_t src_var = op->src.var;
+            vars[src_var].range.offset = offset;
+            vars[src_var].range.count = count;
+            vars[src_var].entity = 0;
+        }
+        return false;
     }
 
-    return ecs_os_memcmp(str1->value, str2->value, len1);
-}
+    ecs_entity_t entity = ecs_vec_get_t(
+        &range->table->data.entities, ecs_entity_t, trav_ctx->index)[0];
+    flecs_query_set_trav_match(op, -1, trav, entity, ctx);
 
-void flecs_name_index_init(
-    ecs_hashmap_t *hm,
-    ecs_allocator_t *allocator) 
-{
-    flecs_hashmap_init_(hm, 
-        ECS_SIZEOF(ecs_hashed_string_t), ECS_SIZEOF(uint64_t), 
-        flecs_name_index_hash, 
-        flecs_name_index_compare,
-        allocator);
+    /* Hijack existing variable to return one result at a time */
+    if (src_is_var) {
+        ecs_var_id_t src_var = op->src.var;
+        ecs_table_t *table = vars[src_var].range.table;
+        ecs_assert(!table || table == ecs_get_table(ctx->world, entity),
+            ECS_INTERNAL_ERROR, NULL);
+        (void)table;
+        vars[src_var].entity = entity;
+        vars[src_var].range = flecs_range_from_entity(entity, ctx);
+    }
+
+    return true;
 }
 
-void flecs_name_index_init_if(
-    ecs_hashmap_t *hm,
-    ecs_allocator_t *allocator) 
+static
+bool flecs_query_trav_fixed_src_up_unknown_second(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    if (!hm->compare) {
-        flecs_name_index_init(hm, allocator);
+    ecs_flags16_t f_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t f_src = flecs_query_ref_flags(op->flags, EcsQuerySrc);
+    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
+    ecs_table_range_t range = flecs_get_ref_range(&op->src, f_src, ctx);
+    ecs_table_t *table = range.table;
+    ecs_query_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
+
+    if (!redo) {
+        flecs_query_get_trav_up_cache(ctx, &trav_ctx->cache, trav, table);
+        trav_ctx->index = 0;
+        if (op->match_flags & EcsTermReflexive) {
+            trav_ctx->yield_reflexive = true;
+            trav_ctx->index = range.offset;
+            trav_ctx->offset = range.offset;
+            trav_ctx->count = range.count ? range.count : ecs_table_count(table);
+        }
+    } else {
+        trav_ctx->index ++;
     }
-}
 
-bool flecs_name_index_is_init(
-    const ecs_hashmap_t *hm)
-{
-    return hm->compare != NULL;
-}
+    if (trav_ctx->yield_reflexive) {
+        if (flecs_query_trav_yield_reflexive_src(op, ctx, &range, trav)) {
+            return true;
+        }
+        trav_ctx->yield_reflexive = false;
+        trav_ctx->index = 0;
+    }
 
-ecs_hashmap_t* flecs_name_index_new(
-    ecs_world_t *world,
-    ecs_allocator_t *allocator) 
-{
-    ecs_hashmap_t *result = flecs_bcalloc(&world->allocators.hashmap);
-    flecs_name_index_init(result, allocator);
-    result->hashmap_allocator = &world->allocators.hashmap;
-    return result;
-}
+    if (trav_ctx->index >= ecs_vec_count(&trav_ctx->cache.entities)) {
+        return false;
+    }
 
-void flecs_name_index_fini(
-    ecs_hashmap_t *map)
-{
-    flecs_hashmap_fini(map);
+    ecs_trav_elem_t *el = ecs_vec_get_t(
+        &trav_ctx->cache.entities, ecs_trav_elem_t, trav_ctx->index);
+    flecs_query_set_trav_match(op, el->column, trav, el->entity, ctx);
+    return true;
 }
 
-void flecs_name_index_free(
-    ecs_hashmap_t *map)
+static
+bool flecs_query_trav(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    if (map) {
-        flecs_name_index_fini(map);
-        flecs_bfree(map->hashmap_allocator, map);
+    uint64_t written = ctx->written[ctx->op_index];
+
+    if (!flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        if (!flecs_ref_is_written(op, &op->second, EcsQuerySecond, written)) {
+            /* This can't happen, src or second should have been resolved */
+            ecs_abort(ECS_INTERNAL_ERROR, 
+                "invalid instruction sequence: unconstrained traversal");
+        } else {
+            return flecs_query_trav_unknown_src_up_fixed_second(op, redo, ctx);
+        }
+    } else {
+        if (!flecs_ref_is_written(op, &op->second, EcsQuerySecond, written)) {
+            return flecs_query_trav_fixed_src_up_unknown_second(op, redo, ctx);
+        } else {
+            return flecs_query_trav_fixed_src_up_fixed_second(op, redo, ctx);
+        }
     }
 }
 
-ecs_hashmap_t* flecs_name_index_copy(
-    ecs_hashmap_t *map)
+static
+int32_t flecs_query_next_inheritable_id(
+    ecs_world_t *world,
+    ecs_type_t *type,
+    int32_t index)
 {
-    ecs_hashmap_t *result = flecs_bcalloc(map->hashmap_allocator);
-    result->hashmap_allocator = map->hashmap_allocator;
-    flecs_hashmap_copy(result, map);
-    return result;
+    int32_t i;
+    for (i = index; i < type->count; i ++) {
+        ecs_id_record_t *idr = flecs_id_record_get(world, type->array[i]);
+        if (!(idr->flags & EcsIdDontInherit)) {
+            return i;
+        }
+    }
+    return -1;
 }
 
-ecs_hashed_string_t flecs_get_hashed_string(
-    const char *name,
-    ecs_size_t length,
-    uint64_t hash)
+static
+bool flecs_query_x_from(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_oper_kind_t oper)
 {
-    if (!length) {
-        length = ecs_os_strlen(name);
-    } else {
-        ecs_assert(length == ecs_os_strlen(name), ECS_INTERNAL_ERROR, NULL);
-    }
+    ecs_query_xfrom_ctx_t *op_ctx = flecs_op_ctx(ctx, xfrom);
+    ecs_world_t *world = ctx->world;
+    ecs_type_t *type;
+    int32_t i;
 
-    if (!hash) {
-        hash = flecs_hash(name, length);
+    if (!redo) {
+        /* Find entity that acts as the template from which we match the ids */
+        ecs_id_t id = flecs_query_op_get_id(op, ctx);
+        ecs_assert(ecs_is_alive(world, id), ECS_INTERNAL_ERROR, NULL);
+        ecs_record_t *r = flecs_entities_get(world, id);
+        ecs_table_t *table;
+        if (!r || !(table = r->table)) {
+            /* Nothing to match */
+            return false;
+        }
+
+        /* Find first id to test against. Skip ids with DontInherit flag. */
+        type = op_ctx->type = &table->type;
+        op_ctx->first_id_index = flecs_query_next_inheritable_id(
+            world, type, 0);
+        op_ctx->cur_id_index = op_ctx->first_id_index;
+
+        if (op_ctx->cur_id_index == -1) {
+            return false; /* No ids to filter on */
+        }
     } else {
-        ecs_assert(hash == flecs_hash(name, length), ECS_INTERNAL_ERROR, NULL);
+        type = op_ctx->type;
     }
 
-    return (ecs_hashed_string_t) {
-        .value = ECS_CONST_CAST(char*, name),
-        .length = length,
-        .hash = hash
-    };
-}
+    ecs_id_t *ids = type->array;
 
-const uint64_t* flecs_name_index_find_ptr(
-    const ecs_hashmap_t *map,
-    const char *name,
-    ecs_size_t length,
-    uint64_t hash)
-{
-    ecs_hashed_string_t hs = flecs_get_hashed_string(name, length, hash);
-    ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hs.hash);
-    if (!b) {
-        return NULL;
+    /* Check if source is variable, and if it's already written */
+    bool src_written = true;
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        uint64_t written = ctx->written[ctx->op_index];
+        src_written = written & (1ull << op->src.var);
     }
 
-    ecs_hashed_string_t *keys = ecs_vec_first(&b->keys);
-    int32_t i, count = ecs_vec_count(&b->keys);
+    do {
+        int32_t id_index = op_ctx->cur_id_index;
 
-    for (i = 0; i < count; i ++) {
-        ecs_hashed_string_t *key = &keys[i];
-        ecs_assert(key->hash == hs.hash, ECS_INTERNAL_ERROR, NULL);
+        /* If source is not yet written, find tables with first id */
+        if (!src_written) {
+            ecs_entity_t first_id = ids[id_index];
 
-        if (hs.length != key->length) {
+            if (!flecs_query_select_w_id(op, redo, ctx, 
+                first_id, (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)))
+            {
+                if (oper == EcsOrFrom) {
+                    id_index = flecs_query_next_inheritable_id(
+                        world, type, id_index + 1);
+                    if (id_index != -1) {
+                        op_ctx->cur_id_index = id_index;
+                        redo = false;
+                        continue;
+                    }
+                }
+
+                return false;
+            }
+
+            id_index ++; /* First id got matched */
+        } else if (redo && src_written) {
+            return false;
+        }
+
+        ecs_table_t *src_table = flecs_query_get_table(
+            op, &op->src, EcsQuerySrc, ctx);
+        if (!src_table) {
             continue;
         }
+        
+        redo = true;
+
+        if (!src_written && oper == EcsOrFrom) {
+            /* Eliminate duplicate matches from tables that have multiple 
+             * components from the type list */
+            if (op_ctx->cur_id_index != op_ctx->first_id_index) {
+                for (i = op_ctx->first_id_index; i < op_ctx->cur_id_index; i ++) {
+                    ecs_id_record_t *idr = flecs_id_record_get(world, ids[i]);
+                    if (!idr) {
+                        continue;
+                    }
 
-        if (!ecs_os_strcmp(name, key->value)) {
-            uint64_t *e = ecs_vec_get_t(&b->values, uint64_t, i);
-            ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL);
-            return e;
+                    if (idr->flags & EcsIdDontInherit) {
+                        continue;
+                    }
+                    
+                    if (flecs_id_record_get_table(idr, src_table) != NULL) {
+                        /* Already matched */
+                        break;
+                    }
+                }
+                if (i != op_ctx->cur_id_index) {
+                    continue;
+                }
+            }
+            return true;
         }
-    }
 
-    return NULL;
+        if (oper == EcsAndFrom || oper == EcsNotFrom || src_written) {
+            for (i = id_index; i < type->count; i ++) {
+                ecs_id_record_t *idr = flecs_id_record_get(world, ids[i]);
+                if (!idr) {
+                    if (oper == EcsAndFrom) {
+                        return false;
+                    } else {
+                        continue;
+                    }
+                }
+
+                if (idr->flags & EcsIdDontInherit) {
+                    continue;
+                }
+
+                if (flecs_id_record_get_table(idr, src_table) == NULL) {
+                    if (oper == EcsAndFrom) {
+                        break; /* Must have all ids */
+                    }
+                } else {
+                    if (oper == EcsNotFrom) {
+                        break; /* Must have none of the ids */
+                    } else if (oper == EcsOrFrom) {
+                        return true; /* Single match is enough */
+                    }
+                }
+            }
+
+            if (i == type->count) {
+                if (oper == EcsAndFrom || oper == EcsNotFrom) {
+                    break; /* All ids matched */
+                }
+            }
+        }
+    } while (true);
+
+    return true;
 }
 
-uint64_t flecs_name_index_find(
-    const ecs_hashmap_t *map,
-    const char *name,
-    ecs_size_t length,
-    uint64_t hash)
+static
+bool flecs_query_and_from(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    const uint64_t *id = flecs_name_index_find_ptr(map, name, length, hash);
-    if (id) {
-        return id[0];
-    }
-    return 0;
+    return flecs_query_x_from(op, redo, ctx, EcsAndFrom);
 }
 
-void flecs_name_index_remove(
-    ecs_hashmap_t *map,
-    uint64_t e,
-    uint64_t hash)
+static
+bool flecs_query_not_from(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hash);
-    if (!b) {
-        return;
-    }
+    return flecs_query_x_from(op, redo, ctx, EcsNotFrom);
+}
 
-    uint64_t *ids = ecs_vec_first(&b->values);
-    int32_t i, count = ecs_vec_count(&b->values);
-    for (i = 0; i < count; i ++) {
-        if (ids[i] == e) {
-            flecs_hm_bucket_remove(map, b, hash, i);
-            break;
-        }
-    }
+static
+bool flecs_query_or_from(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_x_from(op, redo, ctx, EcsOrFrom);
 }
 
-void flecs_name_index_update_name(
-    ecs_hashmap_t *map,
-    uint64_t e,
-    uint64_t hash,
-    const char *name)
+static
+bool flecs_query_ids(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hash);
-    if (!b) {
-        return;
+    if (redo) {
+        return false;
     }
 
-    uint64_t *ids = ecs_vec_first(&b->values);
-    int32_t i, count = ecs_vec_count(&b->values);
-    for (i = 0; i < count; i ++) {
-        if (ids[i] == e) {
-            ecs_hashed_string_t *key = ecs_vec_get_t(
-                &b->keys, ecs_hashed_string_t, i);
-            key->value = ECS_CONST_CAST(char*, name);
-            ecs_assert(ecs_os_strlen(name) == key->length,
-                ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(flecs_hash(name, key->length) == key->hash,
-                ECS_INTERNAL_ERROR, NULL);
-            return;
+    ecs_id_record_t *cur;
+    ecs_id_t id = flecs_query_op_get_id(op, ctx);
+
+    {
+        cur = flecs_id_record_get(ctx->world, id);
+        if (!cur || !cur->cache.tables.count) {
+            return false;
         }
     }
 
-    /* Record must already have been in the index */
-    ecs_abort(ECS_INTERNAL_ERROR, NULL);
+    flecs_query_set_vars(op, cur->id, ctx);
+
+    if (op->field_index != -1) {
+        ecs_iter_t *it = ctx->it;
+        it->ids[op->field_index] = id;
+        it->sources[op->field_index] = EcsWildcard;
+        it->columns[op->field_index] = -1; /* Mark field as set */
+    }
+
+    return true;
 }
 
-void flecs_name_index_ensure(
-    ecs_hashmap_t *map,
-    uint64_t id,
-    const char *name,
-    ecs_size_t length,
-    uint64_t hash)
+static
+bool flecs_query_idsright(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_check(name != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_query_ids_ctx_t *op_ctx = flecs_op_ctx(ctx, ids);
+    ecs_id_record_t *cur;
 
-    ecs_hashed_string_t key = flecs_get_hashed_string(name, length, hash);
-    
-    uint64_t existing = flecs_name_index_find(
-        map, name, key.length, key.hash);
-    if (existing) {
-        if (existing != id) {
-            ecs_abort(ECS_ALREADY_DEFINED, 
-                "conflicting id registered with name '%s'", name);
+    if (!redo) {
+        ecs_id_t id = flecs_query_op_get_id(op, ctx);
+        if (!ecs_id_is_wildcard(id)) {
+            /* If id is not a wildcard, we can directly return it. This can 
+             * happen if a variable was constrained by an iterator. */
+            op_ctx->cur = NULL;
+            flecs_query_set_vars(op, id, ctx);
+            return true;
         }
-    }
-
-    flecs_hashmap_result_t hmr = flecs_hashmap_ensure(
-        map, &key, uint64_t);
-    *((uint64_t*)hmr.value) = id;
-error:
-    return;
-}
 
-/**
- * @file datastructures/sparse.c
- * @brief Sparse set data structure.
- */
+        cur = op_ctx->cur = flecs_id_record_get(ctx->world, id);
+        if (!cur) {
+            return false;
+        }
+    } else {
+        if (!op_ctx->cur) {
+            return false;
+        }
+    }
 
+    do {
+        cur = op_ctx->cur = op_ctx->cur->first.next;
+    } while (cur && !cur->cache.tables.count); /* Skip empty ids */
 
-/** Compute the page index from an id by stripping the first 12 bits */
-#define PAGE(index) ((int32_t)((uint32_t)index >> FLECS_SPARSE_PAGE_BITS))
+    if (!cur) {
+        return false;
+    }
 
-/** This computes the offset of an index inside a page */
-#define OFFSET(index) ((int32_t)index & (FLECS_SPARSE_PAGE_SIZE - 1))
+    flecs_query_set_vars(op, cur->id, ctx);
 
-/* Utility to get a pointer to the payload */
-#define DATA(array, size, offset) (ECS_OFFSET(array, size * offset))
+    if (op->field_index != -1) {
+        ecs_iter_t *it = ctx->it;
+        ecs_id_t id = flecs_query_op_get_id_w_written(op, op->written, ctx);
+        it->ids[op->field_index] = id;
+        it->sources[op->field_index] = EcsWildcard;
+        ECS_TERMSET_SET(it->set_fields, 1u << op->field_index);
+    }
 
-typedef struct ecs_page_t {
-    int32_t *sparse;            /* Sparse array with indices to dense array */
-    void *data;                 /* Store data in sparse array to reduce  
-                                 * indirection and provide stable pointers. */
-} ecs_page_t;
+    return true;
+}
 
 static
-ecs_page_t* flecs_sparse_page_new(
-    ecs_sparse_t *sparse,
-    int32_t page_index)
+bool flecs_query_idsleft(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_allocator_t *a = sparse->allocator;
-    ecs_block_allocator_t *ca = sparse->page_allocator;
-    int32_t count = ecs_vec_count(&sparse->pages);
-    ecs_page_t *pages;
+    ecs_query_ids_ctx_t *op_ctx = flecs_op_ctx(ctx, ids);
+    ecs_id_record_t *cur;
 
-    if (count <= page_index) {
-        ecs_vec_set_count_t(a, &sparse->pages, ecs_page_t, page_index + 1);
-        pages = ecs_vec_first_t(&sparse->pages, ecs_page_t);
-        ecs_os_memset_n(&pages[count], 0, ecs_page_t, (1 + page_index - count));
+    if (!redo) {
+        ecs_id_t id = flecs_query_op_get_id(op, ctx);
+        if (!ecs_id_is_wildcard(id)) {
+            /* If id is not a wildcard, we can directly return it. This can 
+             * happen if a variable was constrained by an iterator. */
+            op_ctx->cur = NULL;
+            flecs_query_set_vars(op, id, ctx);
+            return true;
+        }
+
+        cur = op_ctx->cur = flecs_id_record_get(ctx->world, id);
+        if (!cur) {
+            return false;
+        }
     } else {
-        pages = ecs_vec_first_t(&sparse->pages, ecs_page_t);
+        if (!op_ctx->cur) {
+            return false;
+        }
     }
 
-    ecs_assert(pages != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_page_t *result = &pages[page_index];
-    ecs_assert(result->sparse == NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(result->data == NULL, ECS_INTERNAL_ERROR, NULL);
+    do {
+        cur = op_ctx->cur = op_ctx->cur->second.next;
+    } while (cur && !cur->cache.tables.count); /* Skip empty ids */ 
 
-    /* Initialize sparse array with zero's, as zero is used to indicate that the
-     * sparse element has not been paired with a dense element. Use zero
-     * as this means we can take advantage of calloc having a possibly better 
-     * performance than malloc + memset. */
-    result->sparse = ca ? flecs_bcalloc(ca)
-                        : ecs_os_calloc_n(int32_t, FLECS_SPARSE_PAGE_SIZE);
+    if (!cur) {
+        return false;
+    }
 
-    /* Initialize the data array with zero's to guarantee that data is 
-     * always initialized. When an entry is removed, data is reset back to
-     * zero. Initialize now, as this can take advantage of calloc. */
-    result->data = a ? flecs_calloc(a, sparse->size * FLECS_SPARSE_PAGE_SIZE)
-                     : ecs_os_calloc(sparse->size * FLECS_SPARSE_PAGE_SIZE);
+    flecs_query_set_vars(op, cur->id, ctx);
 
-    ecs_assert(result->sparse != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(result->data != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (op->field_index != -1) {
+        ecs_iter_t *it = ctx->it;
+        ecs_id_t id = flecs_query_op_get_id_w_written(op, op->written, ctx);
+        it->ids[op->field_index] = id;
+        it->sources[op->field_index] = EcsWildcard;
+        ECS_TERMSET_SET(it->set_fields, 1u << op->field_index);
+    }
 
-    return result;
+    return true;
 }
 
 static
-void flecs_sparse_page_free(
-    ecs_sparse_t *sparse,
-    ecs_page_t *page)
+bool flecs_query_each(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_allocator_t *a = sparse->allocator;
-    ecs_block_allocator_t *ca = sparse->page_allocator;
+    ecs_query_each_ctx_t *op_ctx = flecs_op_ctx(ctx, each);
+    int32_t row;
 
-    if (ca) {
-        flecs_bfree(ca, page->sparse);
-    } else {
-        ecs_os_free(page->sparse);
+    ecs_table_range_t range = flecs_query_var_get_range(op->first.var, ctx);
+    ecs_table_t *table = range.table;
+    if (!table) {
+        return false;
     }
-    if (a) {
-        flecs_free(a, sparse->size * FLECS_SPARSE_PAGE_SIZE, page->data);
+
+    if (!redo) {
+        row = op_ctx->row = range.offset;
     } else {
-        ecs_os_free(page->data);
+        int32_t end = range.count;
+        if (end) {
+            end += range.offset;
+        } else {
+            end = table->data.entities.count;
+        }
+        row = ++ op_ctx->row;
+        if (op_ctx->row >= end) {
+            return false;
+        }
     }
+
+    ecs_assert(row < ecs_table_count(table), ECS_INTERNAL_ERROR, NULL);
+    ecs_entity_t *entities = table->data.entities.array;
+    flecs_query_var_set_entity(op, op->src.var, entities[row], ctx);
+
+    return true;
 }
 
 static
-ecs_page_t* flecs_sparse_get_page(
-    const ecs_sparse_t *sparse,
-    int32_t page_index)
+bool flecs_query_store(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(page_index >= 0, ECS_INVALID_PARAMETER, NULL);
-    if (page_index >= ecs_vec_count(&sparse->pages)) {
-        return NULL;
+    if (!redo) {
+        flecs_query_var_set_entity(op, op->src.var, op->first.entity, ctx);
+        return true;
+    } else {
+        return false;
     }
-    return ecs_vec_get_t(&sparse->pages, ecs_page_t, page_index);
 }
 
 static
-ecs_page_t* flecs_sparse_get_or_create_page(
-    ecs_sparse_t *sparse,
-    int32_t page_index)
+bool flecs_query_reset(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
 {
-    ecs_page_t *page = flecs_sparse_get_page(sparse, page_index);
-    if (page && page->sparse) {
-        return page;
+    if (!redo) {
+        return true;
+    } else {
+        flecs_query_var_reset(op->src.var, ctx);
+        return false;
     }
-
-    return flecs_sparse_page_new(sparse, page_index);
 }
 
 static
-void flecs_sparse_grow_dense(
-    ecs_sparse_t *sparse)
+const char* flecs_query_name_arg(
+    const ecs_query_op_t *op,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_vec_append_t(sparse->allocator, &sparse->dense, uint64_t);
+    int8_t term_index = op->term_index;
+    const ecs_term_t *term = &ctx->query->pub.terms[term_index];
+    return term->second.name;
 }
 
 static
-uint64_t flecs_sparse_strip_generation(
-    uint64_t *index_out)
+bool flecs_query_compare_range(
+    const ecs_table_range_t *l,
+    const ecs_table_range_t *r)
 {
-    uint64_t index = *index_out;
-    uint64_t gen = index & ECS_GENERATION_MASK;
-    /* Make sure there's no junk in the id */
-    ecs_assert(gen == (index & (0xFFFFFFFFull << 32)),
-        ECS_INVALID_PARAMETER, NULL);
-    *index_out -= gen;
-    return gen;
-}
+    if (l->table != r->table) {
+        return false;
+    }
 
-static
-void flecs_sparse_assign_index(
-    ecs_page_t * page, 
-    uint64_t * dense_array, 
-    uint64_t index, 
-    int32_t dense)
-{
-    /* Initialize sparse-dense pair. This assigns the dense index to the sparse
-     * array, and the sparse index to the dense array .*/
-    page->sparse[OFFSET(index)] = dense;
-    dense_array[dense] = index;
-}
+    if (l->count) {
+        int32_t l_end = l->offset + l->count;
+        int32_t r_end = r->offset + r->count;
+        if (r->offset < l->offset) {
+            return false;
+        }
+        if (r_end > l_end) {
+            return false;
+        }
+    } else {
+        /* Entire table is matched */
+    }
 
-static
-uint64_t flecs_sparse_inc_gen(
-    uint64_t index)
-{
-    /* When an index is deleted, its generation is increased so that we can do
-     * liveliness checking while recycling ids */
-    return ECS_GENERATION_INC(index);
+    return true;
 }
 
 static
-uint64_t flecs_sparse_inc_id(
-    ecs_sparse_t *sparse)
+bool flecs_query_pred_eq_w_range(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    ecs_table_range_t r)
 {
-    /* Generate a new id. The last issued id could be stored in an external
-     * variable, such as is the case with the last issued entity id, which is
-     * stored on the world. */
-    return ++ sparse->max_id;
-}
+    if (redo) {
+        return false;
+    }
 
-static
-uint64_t flecs_sparse_get_id(
-    const ecs_sparse_t *sparse)
-{
-    ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL);
-    return sparse->max_id;
-}
+    uint64_t written = ctx->written[ctx->op_index];
+    ecs_var_id_t src_var = op->src.var;
+    if (!(written & (1ull << src_var))) {
+        /* left = unknown, right = known. Assign right-hand value to left */
+        ecs_var_id_t l = src_var;
+        ctx->vars[l].range = r;
+        if (r.count == 1) {
+            ctx->vars[l].entity = ecs_vec_get_t(&r.table->data.entities, 
+                ecs_entity_t, r.offset)[0];
+        }
+        return true;
+    } else {
+        ecs_table_range_t l = flecs_query_get_range(
+            op, &op->src, EcsQuerySrc, ctx);
 
-static
-void flecs_sparse_set_id(
-    ecs_sparse_t *sparse,
-    uint64_t value)
-{
-    /* Sometimes the max id needs to be assigned directly, which typically 
-     * happens when the API calls get_or_create for an id that hasn't been 
-     * issued before. */
-    sparse->max_id = value;
+        if (!flecs_query_compare_range(&l, &r)) {
+            return false;
+        }
+
+        ctx->vars[src_var].range.offset = r.offset;
+        ctx->vars[src_var].range.count = r.count;
+        return true;
+    }
 }
 
-/* Pair dense id with new sparse id */
 static
-uint64_t flecs_sparse_create_id(
-    ecs_sparse_t *sparse,
-    int32_t dense)
+bool flecs_query_pred_eq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    uint64_t index = flecs_sparse_inc_id(sparse);
-    flecs_sparse_grow_dense(sparse);
+    uint64_t written = ctx->written[ctx->op_index]; (void)written;
+    ecs_assert(flecs_ref_is_written(op, &op->second, EcsQuerySecond, written),
+        ECS_INTERNAL_ERROR, 
+            "invalid instruction sequence: uninitialized eq operand");
 
-    ecs_page_t *page = flecs_sparse_get_or_create_page(sparse, PAGE(index));
-    ecs_assert(page->sparse[OFFSET(index)] == 0, ECS_INTERNAL_ERROR, NULL);
-    
-    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-    flecs_sparse_assign_index(page, dense_array, index, dense);
-    
-    return index;
+    ecs_table_range_t r = flecs_query_get_range(
+        op, &op->second, EcsQuerySecond, ctx);
+    return flecs_query_pred_eq_w_range(op, redo, ctx, r);
 }
 
-/* Create new id */
 static
-uint64_t flecs_sparse_new_index(
-    ecs_sparse_t *sparse)
+bool flecs_query_pred_eq_name(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    int32_t dense_count = ecs_vec_count(&sparse->dense);
-    int32_t count = sparse->count ++;
-
-    ecs_assert(count <= dense_count, ECS_INTERNAL_ERROR, NULL);
-    if (count < dense_count) {
-        /* If there are unused elements in the dense array, return first */
-        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-        return dense_array[count];
-    } else {
-        return flecs_sparse_create_id(sparse, count);
+    const char *name = flecs_query_name_arg(op, ctx);
+    ecs_entity_t e = ecs_lookup(ctx->world, name);
+    if (!e) {
+        /* Entity doesn't exist */
+        return false;
     }
+
+    ecs_table_range_t r = flecs_range_from_entity(e, ctx);
+    return flecs_query_pred_eq_w_range(op, redo, ctx, r);
 }
 
-/* Get value from sparse set when it is guaranteed that the value exists. This
- * function is used when values are obtained using a dense index */
 static
-void* flecs_sparse_get_sparse(
-    const ecs_sparse_t *sparse,
-    int32_t dense,
-    uint64_t index)
+bool flecs_query_pred_neq_w_range(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    ecs_table_range_t r)
 {
-    flecs_sparse_strip_generation(&index);
-    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
-    if (!page || !page->sparse) {
-        return NULL;
+    ecs_query_eq_ctx_t *op_ctx = flecs_op_ctx(ctx, eq);
+    ecs_var_id_t src_var = op->src.var;
+    ecs_table_range_t l = flecs_query_get_range(
+        op, &op->src, EcsQuerySrc, ctx);
+
+    /* If tables don't match, neq always returns once */
+    if (l.table != r.table) {
+        return true && !redo;
     }
 
-    int32_t offset = OFFSET(index);
-    ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
-    (void)dense;
+    int32_t l_offset;
+    int32_t l_count;
+    if (!redo) {
+        /* Make sure we're working with the correct table count */
+        if (!l.count && l.table) {
+            l.count = ecs_table_count(l.table);
+        }
 
-    return DATA(page->data, sparse->size, offset);
-}
+        l_offset = l.offset;
+        l_count = l.count;
 
-/* Swap dense elements. A swap occurs when an element is removed, or when a
- * removed element is recycled. */
-static
-void flecs_sparse_swap_dense(
-    ecs_sparse_t * sparse,
-    ecs_page_t * page_a,
-    int32_t a,
-    int32_t b)
-{
-    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-    uint64_t index_a = dense_array[a];
-    uint64_t index_b = dense_array[b];
+        /* Cache old value */
+        op_ctx->range = l;
+    } else {
+        l_offset = op_ctx->range.offset;
+        l_count = op_ctx->range.count;
+    }
 
-    ecs_page_t *page_b = flecs_sparse_get_or_create_page(sparse, PAGE(index_b));
-    flecs_sparse_assign_index(page_a, dense_array, index_a, b);
-    flecs_sparse_assign_index(page_b, dense_array, index_b, a);
-}
+    /* If the table matches, a Neq returns twice: once for the slice before the
+     * excluded slice, once for the slice after the excluded slice. If the right
+     * hand range starts & overlaps with the left hand range, there is only
+     * one slice. */
+    ecs_var_t *var = &ctx->vars[src_var];
+    if (!redo && r.offset > l_offset) {
+        int32_t end = r.offset;
+        if (end > l_count) {
+            end = l_count;
+        }
 
-void flecs_sparse_init(
-    ecs_sparse_t *result,
-    struct ecs_allocator_t *allocator,
-    ecs_block_allocator_t *page_allocator,
-    ecs_size_t size)
-{
-    ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL);
-    result->size = size;
-    result->max_id = UINT64_MAX;
-    result->allocator = allocator;
-    result->page_allocator = page_allocator;
+        /* Return first slice */
+        var->range.table = l.table;
+        var->range.offset = l_offset;
+        var->range.count = end - l_offset;
+        op_ctx->redo = false;
+        return true;
+    } else if (!op_ctx->redo) {
+        int32_t l_end = op_ctx->range.offset + l_count;
+        int32_t r_end = r.offset + r.count;
 
-    ecs_vec_init_t(allocator, &result->pages, ecs_page_t, 0);
-    ecs_vec_init_t(allocator, &result->dense, uint64_t, 1);
-    result->dense.count = 1;
+        if (l_end <= r_end) {
+            /* If end of existing range falls inside the excluded range, there's
+             * nothing more to return */
+            var->range = l;
+            return false;
+        }
 
-    /* Consume first value in dense array as 0 is used in the sparse array to
-     * indicate that a sparse element hasn't been paired yet. */
-    ecs_vec_first_t(&result->dense, uint64_t)[0] = 0;
+        /* Return second slice */
+        var->range.table = l.table;
+        var->range.offset = r_end;
+        var->range.count = l_end - r_end;
 
-    result->count = 1;
+        /* Flag so we know we're done the next redo */
+        op_ctx->redo = true;
+        return true;
+    } else {
+        /* Restore previous value */
+        var->range = l;
+        return false;
+    }
 }
 
-void flecs_sparse_clear(
-    ecs_sparse_t *sparse)
+static
+bool flecs_query_pred_match(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    bool is_neq)
 {
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_query_eq_ctx_t *op_ctx = flecs_op_ctx(ctx, eq);
+    uint64_t written = ctx->written[ctx->op_index];
+    ecs_assert(flecs_ref_is_written(op, &op->src, EcsQuerySrc, written),
+        ECS_INTERNAL_ERROR, 
+            "invalid instruction sequence: uninitialized match operand");
+    (void)written;
 
-    int32_t i, count = ecs_vec_count(&sparse->pages);
-    ecs_page_t *pages = ecs_vec_first_t(&sparse->pages, ecs_page_t);
-    for (i = 0; i < count; i ++) {
-        int32_t *indices = pages[i].sparse;
-        if (indices) {
-            ecs_os_memset_n(indices, 0, int32_t, FLECS_SPARSE_PAGE_SIZE);
+    ecs_var_id_t src_var = op->src.var;
+    const char *match = flecs_query_name_arg(op, ctx);
+    ecs_table_range_t l;
+    if (!redo) {
+        l = flecs_query_get_range(op, &op->src, EcsQuerySrc, ctx);
+        if (!l.table) {
+            return false;
+        }
+
+        if (!l.count) {
+            l.count = ecs_table_count(l.table);
+        }
+
+        op_ctx->range = l;
+        op_ctx->index = l.offset;
+        op_ctx->name_col = flecs_ito(int16_t,   
+            ecs_table_get_type_index(ctx->world, l.table, 
+                ecs_pair(ecs_id(EcsIdentifier), EcsName)));
+        if (op_ctx->name_col == -1) {
+            return is_neq;
+        }
+        op_ctx->name_col = flecs_ito(int16_t, 
+            l.table->column_map[op_ctx->name_col]);
+        ecs_assert(op_ctx->name_col != -1, ECS_INTERNAL_ERROR, NULL);
+    } else {
+        if (op_ctx->name_col == -1) {
+            /* Table has no name */
+            return false;
         }
+
+        l = op_ctx->range;
     }
 
-    ecs_vec_set_count_t(sparse->allocator, &sparse->dense, uint64_t, 1);
+    const EcsIdentifier *names = l.table->data.columns[op_ctx->name_col].data.array;
+    int32_t count = l.offset + l.count, offset = -1;
+    for (; op_ctx->index < count; op_ctx->index ++) {
+        const char *name = names[op_ctx->index].value;
+        bool result = strstr(name, match);
+        if (is_neq) {
+            result = !result;
+        }
 
-    sparse->count = 1;
-    sparse->max_id = 0;
-}
+        if (!result) {
+            if (offset != -1) {
+                break;
+            }
+        } else {
+            if (offset == -1) {
+                offset = op_ctx->index;
+            }
+        }
+    }
 
-void flecs_sparse_fini(
-    ecs_sparse_t *sparse)
-{
-    ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL);
-    
-    int32_t i, count = ecs_vec_count(&sparse->pages);
-    ecs_page_t *pages = ecs_vec_first_t(&sparse->pages, ecs_page_t);
-    for (i = 0; i < count; i ++) {
-        flecs_sparse_page_free(sparse, &pages[i]);
+    if (offset == -1) {
+        ctx->vars[src_var].range = op_ctx->range;
+        return false;
     }
 
-    ecs_vec_fini_t(sparse->allocator, &sparse->pages, ecs_page_t);
-    ecs_vec_fini_t(sparse->allocator, &sparse->dense, uint64_t);
+    ctx->vars[src_var].range.offset = offset;
+    ctx->vars[src_var].range.count = (op_ctx->index - offset);
+    return true;
 }
 
-uint64_t flecs_sparse_new_id(
-    ecs_sparse_t *sparse)
+static
+bool flecs_query_pred_eq_match(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    return flecs_sparse_new_index(sparse);
+    return flecs_query_pred_match(op, redo, ctx, false);
 }
 
-void* flecs_sparse_add(
-    ecs_sparse_t *sparse,
-    ecs_size_t size)
+static
+bool flecs_query_pred_neq_match(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
-    uint64_t index = flecs_sparse_new_index(sparse);
-    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
-    ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
-    return DATA(page->data, size, OFFSET(index));
+    return flecs_query_pred_match(op, redo, ctx, true);
 }
 
-uint64_t flecs_sparse_last_id(
-    const ecs_sparse_t *sparse)
+static
+bool flecs_query_member_cmp(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    bool neq)
 {
-    ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL);
-    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-    return dense_array[sparse->count - 1];
-}
+    ecs_table_range_t range;
+    if (op->other) {
+        ecs_var_id_t table_var = flecs_itovar(op->other - 1);
+        range = flecs_query_var_get_range(table_var, ctx);
+    } else {
+        range = flecs_query_get_range(op, &op->src, EcsQuerySrc, ctx);
+    }
 
-void* flecs_sparse_ensure(
-    ecs_sparse_t *sparse,
-    ecs_size_t size,
-    uint64_t index)
-{
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(ecs_vec_count(&sparse->dense) > 0, ECS_INTERNAL_ERROR, NULL);
-    (void)size;
+    ecs_table_t *table = range.table;
+    if (!table) {
+        return false;
+    }
 
-    uint64_t gen = flecs_sparse_strip_generation(&index);
-    ecs_page_t *page = flecs_sparse_get_or_create_page(sparse, PAGE(index));
-    int32_t offset = OFFSET(index);
-    int32_t dense = page->sparse[offset];
+    ecs_query_membereq_ctx_t *op_ctx = flecs_op_ctx(ctx, membereq);
+    ecs_iter_t *it = ctx->it;
+    int8_t field_index = op->field_index;
 
-    if (dense) {
-        /* Check if element is alive. If element is not alive, update indices so
-         * that the first unused dense element points to the sparse element. */
-        int32_t count = sparse->count;
-        if (dense >= count) {
-            /* If dense is not alive, swap it with the first unused element. */
-            flecs_sparse_swap_dense(sparse, page, dense, count);
-            dense = count;
+    if (!range.count) {
+        range.count = ecs_table_count(range.table); 
+    }
 
-            /* First unused element is now last used element */
-            sparse->count ++;
-        } else {
-            /* Dense is already alive, nothing to be done */
-        }
+    int32_t row, end = range.count;
+    if (end) {
+        end += range.offset;
+    } else {
+        end = ecs_table_count(range.table);
+    }
 
-        /* Ensure provided generation matches current. Only allow mismatching
-         * generations if the provided generation count is 0. This allows for
-         * using the ensure function in combination with ids that have their
-         * generation stripped. */
-#ifdef FLECS_DEBUG
-        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-        ecs_assert(!gen || dense_array[dense] == (index | gen), ECS_INTERNAL_ERROR, NULL);
-#endif
+    void *data;
+    if (!redo) {
+        row = op_ctx->each.row = range.offset;
+
+        /* Get data ptr starting from offset 0 so we can use row to index */
+        range.offset = 0;
+
+        /* Populate data field so we have the array we can compare the member
+         * value against. */
+        void *old_data = it->ptrs[field_index];
+        flecs_query_populate_field_from_range(
+            it, &range, field_index, it->columns[field_index]);
+        data = op_ctx->data = it->ptrs[field_index];
+
+        /* Ensure we only write ptrs when we match data */
+        it->ptrs[field_index] = old_data;
+
+        /* Member fields are of type ecs_entity_t */
+        #ifdef FLECS_META
+        it->ids[field_index] = ecs_id(ecs_entity_t);
+        #else
+        it->ids[field_index] = 0;
+        #endif
     } else {
-        /* Element is not paired yet. Must add a new element to dense array */
-        flecs_sparse_grow_dense(sparse);
+        row = ++ op_ctx->each.row;
+        if (op_ctx->each.row >= end) {
+            return false;
+        }
 
-        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);    
-        int32_t dense_count = ecs_vec_count(&sparse->dense) - 1;
-        int32_t count = sparse->count ++;
+        data = op_ctx->data;
+    }
 
-        /* If index is larger than max id, update max id */
-        if (index >= flecs_sparse_get_id(sparse)) {
-            flecs_sparse_set_id(sparse, index);
-        }
+    int32_t offset = (int32_t)op->first.entity;
+    int32_t size = (int32_t)(op->first.entity >> 32);
+    ecs_entity_t *entities = table->data.entities.array;
+    ecs_entity_t e = 0;
+    ecs_entity_t *val;
 
-        if (count < dense_count) {
-            /* If there are unused elements in the list, move the first unused
-             * element to the end of the list */
-            uint64_t unused = dense_array[count];
-            ecs_page_t *unused_page = flecs_sparse_get_or_create_page(sparse, PAGE(unused));
-            flecs_sparse_assign_index(unused_page, dense_array, unused, dense_count);
-        }
+    ecs_assert(row < ecs_table_count(table), ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); /* Must be written */
+    ecs_assert(entities != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        flecs_sparse_assign_index(page, dense_array, index, count);
-        dense_array[count] |= gen;
+    bool second_written = true;
+    if (op->flags & (EcsQueryIsVar << EcsQuerySecond)) {
+        uint64_t written = ctx->written[ctx->op_index];
+        second_written = written & (1ull << op->second.var);
     }
 
-    return DATA(page->data, sparse->size, offset);
-}
+    if (second_written) {
+        ecs_flags16_t second_flags = flecs_query_ref_flags(
+            op->flags, EcsQuerySecond);
+        ecs_entity_t second = flecs_get_ref_entity(
+            &op->second, second_flags, ctx);
 
-void* flecs_sparse_ensure_fast(
-    ecs_sparse_t *sparse,
-    ecs_size_t size,
-    uint64_t index_long)
-{
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(ecs_vec_count(&sparse->dense) > 0, ECS_INTERNAL_ERROR, NULL);
-    (void)size;
+        do {
+            e = entities[row];
 
-    uint32_t index = (uint32_t)index_long;
-    ecs_page_t *page = flecs_sparse_get_or_create_page(sparse, PAGE(index));
-    int32_t offset = OFFSET(index);
-    int32_t dense = page->sparse[offset];
-    int32_t count = sparse->count;
+            val = ECS_OFFSET(ECS_ELEM(data, size, row), offset);
+            if (val[0] == second || second == EcsWildcard) {
+                if (!neq) {
+                    goto match;
+                }
+            } else {
+                if (neq) {
+                    goto match;
+                }
+            }
 
-    if (!dense) {
-        /* Element is not paired yet. Must add a new element to dense array */
-        sparse->count = count + 1;
-        if (count == ecs_vec_count(&sparse->dense)) {
-            flecs_sparse_grow_dense(sparse);
-        }
+            row ++;
+        } while (row < end);
 
-        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-        flecs_sparse_assign_index(page, dense_array, index, count);
+        return false;
+    } else {
+        e = entities[row];
+        val = ECS_OFFSET(ECS_ELEM(data, size, row), offset);
+        flecs_query_var_set_entity(op, op->second.var, val[0], ctx);
     }
 
-    return DATA(page->data, sparse->size, offset);
+match:
+    if (op->other) {
+        ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL);
+        flecs_query_var_set_entity(op, op->src.var, e, ctx);
+    }
+
+    it->ptrs[field_index] = val;
+    op_ctx->each.row = row;
+
+    return true;
 }
 
-void flecs_sparse_remove(
-    ecs_sparse_t *sparse,
-    ecs_size_t size,
-    uint64_t index)
+static
+bool flecs_query_member_eq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
-    (void)size;
+    return flecs_query_member_cmp(op, redo, ctx, false);
+}
 
-    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
-    if (!page || !page->sparse) {
-        return;
-    }
+static
+bool flecs_query_member_neq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_member_cmp(op, redo, ctx, true);
+}
 
-    uint64_t gen = flecs_sparse_strip_generation(&index);
-    int32_t offset = OFFSET(index);
-    int32_t dense = page->sparse[offset];
+typedef struct {
+    ecs_flags64_t mask;
+    bool has_bitset;
+} flecs_query_row_mask_t;
 
-    if (dense) {
-        uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-        uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK;
-        if (gen != cur_gen) {
-            /* Generation doesn't match which means that the provided entity is
-             * already not alive. */
-            return;
+static
+flecs_query_row_mask_t flecs_query_get_row_mask(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t block_index,
+    ecs_flags64_t and_fields,
+    ecs_flags64_t not_fields,
+    ecs_query_toggle_ctx_t *op_ctx)
+{
+    ecs_flags64_t mask = UINT64_MAX;
+    int32_t i, field_count = it->field_count;
+    ecs_flags64_t fields = and_fields | not_fields;
+    bool has_bitset = false;
+
+    for (i = 0; i < field_count; i ++) {
+        uint64_t field_bit = 1llu << i;
+        if (!(fields & field_bit)) {
+            continue;
         }
 
-        /* Increase generation */
-        dense_array[dense] = index | flecs_sparse_inc_gen(cur_gen);
-        
-        int32_t count = sparse->count;
-        
-        if (dense == (count - 1)) {
-            /* If dense is the last used element, simply decrease count */
-            sparse->count --;
-        } else if (dense < count) {
-            /* If element is alive, move it to unused elements */
-            flecs_sparse_swap_dense(sparse, page, dense, count - 1);
-            sparse->count --;
+        if (not_fields & field_bit) {
+            it->set_fields &= (ecs_termset_t)~field_bit;
+        } else if (and_fields & field_bit) {
+            ecs_assert(it->set_fields & field_bit, ECS_INTERNAL_ERROR, NULL);
         } else {
-            /* Element is not alive, nothing to be done */
-            return;
+            ecs_abort(ECS_INTERNAL_ERROR, NULL);
         }
 
-        /* Reset memory to zero on remove */
-        void *ptr = DATA(page->data, sparse->size, offset);
-        ecs_os_memset(ptr, 0, size);
-    } else {
-        /* Element is not paired and thus not alive, nothing to be done */
-        return;
+        ecs_id_t id = it->ids[i];
+        ecs_bitset_t *bs = flecs_table_get_toggle(table, id);
+        if (!bs) {
+            if (not_fields & field_bit) {
+                if (op_ctx->prev_set_fields & field_bit) {
+                    has_bitset = false;
+                    break;
+                }
+            }
+            continue;
+        }
+
+        ecs_assert((64 * block_index) < bs->size, ECS_INTERNAL_ERROR, NULL);
+        ecs_flags64_t block = bs->data[block_index];
+
+        if (not_fields & field_bit) {
+            block = ~block;
+        }
+        mask &= block;
+        has_bitset = true;
     }
+
+    return (flecs_query_row_mask_t){ mask, has_bitset };
 }
 
-void* flecs_sparse_get_dense(
-    const ecs_sparse_t *sparse,
-    ecs_size_t size,
-    int32_t dense_index)
+static
+bool flecs_query_toggle_for_up(
+    ecs_iter_t *it,
+    ecs_flags64_t and_fields,
+    ecs_flags64_t not_fields)
 {
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(dense_index < sparse->count, ECS_INVALID_PARAMETER, NULL);
-    (void)size;
+    int32_t i, field_count = it->field_count;
+    ecs_flags64_t fields = (and_fields | not_fields) & it->up_fields;
 
-    dense_index ++;
+    for (i = 0; i < field_count; i ++) {
+        uint64_t field_bit = 1llu << i;
+        if (!(fields & field_bit)) {
+            continue;
+        }
 
-    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-    return flecs_sparse_get_sparse(sparse, dense_index, dense_array[dense_index]);
+        bool match = false;
+        if ((it->set_fields & field_bit)) {
+            ecs_entity_t src = it->sources[i];
+            ecs_assert(src != 0, ECS_INTERNAL_ERROR, NULL);
+            match = ecs_is_enabled_id(it->world, src, it->ids[i]);
+        }
+
+        if (field_bit & not_fields) {
+            match = !match;
+        }
+
+        if (!match) {
+            return false;
+        }
+    }
+
+    return true;
 }
 
-bool flecs_sparse_is_alive(
-    const ecs_sparse_t *sparse,
-    uint64_t index)
+static
+bool flecs_query_toggle_cmp(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    ecs_flags64_t and_fields,
+    ecs_flags64_t not_fields)
 {
-    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
-    if (!page || !page->sparse) {
-        return false;
-    }
+    ecs_iter_t *it = ctx->it;
+    ecs_query_toggle_ctx_t *op_ctx = flecs_op_ctx(ctx, toggle);
+    ecs_table_range_t range = flecs_query_get_range(
+        op, &op->src, EcsQuerySrc, ctx);
+    ecs_table_t *table = range.table;
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    int32_t offset = OFFSET(index);
-    int32_t dense = page->sparse[offset];
-    if (!dense || (dense >= sparse->count)) {
+    if ((and_fields & op_ctx->prev_set_fields) != and_fields) {
+        /* If not all fields matching and toggles are set, table can't match */
         return false;
     }
 
-    uint64_t gen = flecs_sparse_strip_generation(&index);
-    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-    uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK;
+    ecs_flags32_t up_fields = it->up_fields;
+    if (!redo) {
+        if (up_fields & (and_fields|not_fields)) {
+            /* If there are toggle fields that were matched with query 
+             * traversal, evaluate those separately. */
+            if (!flecs_query_toggle_for_up(it, and_fields, not_fields)) {
+                return false;
+            }
 
-    if (cur_gen != gen) {
-        return false;
+            it->set_fields &= (ecs_termset_t)~(not_fields & up_fields);
+        }
     }
 
-    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
-    return true;
-}
+    /* Shared fields are evaluated, can be ignored from now on */
+    // and_fields &= ~up_fields;
+    not_fields &= ~up_fields;
 
-void* flecs_sparse_try(
-    const ecs_sparse_t *sparse,
-    ecs_size_t size,
-    uint64_t index)
-{
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
-    (void)size;
-    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
-    if (!page || !page->sparse) {
-        return NULL;
+    if (!(table->flags & EcsTableHasToggle)) {
+        if (not_fields) {
+            /* If any of the toggle fields with a not operator are for fields
+             * that are set, without a bitset those fields can't match. */
+            return false;
+        } else {
+            /* If table doesn't have toggles but query matched toggleable 
+             * components, all entities match. */
+            if (!redo) {            
+                return true;
+            } else {
+                return false;
+            }
+        }
     }
 
-    int32_t offset = OFFSET(index);
-    int32_t dense = page->sparse[offset];
-    if (!dense || (dense >= sparse->count)) {
-        return NULL;
+    if (table && !range.count) {
+        range.count = ecs_table_count(table);
+        if (!range.count) {
+            return false;
+        }
     }
 
-    uint64_t gen = flecs_sparse_strip_generation(&index);
-    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-    uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK;
-    if (cur_gen != gen) {
-        return NULL;
+    int32_t i, j;
+    int32_t first, last, block_index, cur;
+    uint64_t block = 0;
+    if (!redo) {
+        op_ctx->range = range;
+        cur = op_ctx->cur = range.offset;
+        block_index = op_ctx->block_index = -1;
+        first = range.offset;
+        last = range.offset + range.count;
+    } else {
+        if (!op_ctx->has_bitset) {
+            goto done;
+        }
+
+        last = op_ctx->range.offset + op_ctx->range.count;
+        cur = op_ctx->cur;
+        ecs_assert(cur <= last, ECS_INTERNAL_ERROR, NULL);
+        if (cur == last) {
+            goto done;
+        }
+
+        first = cur;
+        block_index = op_ctx->block_index;
+        block = op_ctx->block;
     }
 
-    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
-    return DATA(page->data, sparse->size, offset);
-}
+    /* If end of last iteration is start of new block, compute new block */    
+    int32_t new_block_index = cur / 64, row = first;
+    if (new_block_index != block_index) {
+compute_block:
+        block_index = op_ctx->block_index = new_block_index;
 
-void* flecs_sparse_get(
-    const ecs_sparse_t *sparse,
-    ecs_size_t size,
-    uint64_t index)
-{
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
-    (void)size;
+        flecs_query_row_mask_t row_mask = flecs_query_get_row_mask(
+            it, table, block_index, and_fields, not_fields, op_ctx);
 
-    ecs_page_t *page = ecs_vec_get_t(&sparse->pages, ecs_page_t, PAGE(index));
-    int32_t offset = OFFSET(index);
-    int32_t dense = page->sparse[offset];
-    ecs_assert(dense != 0, ECS_INTERNAL_ERROR, NULL);
+        /* If table doesn't have bitset columns, all columns match */
+        if (!(op_ctx->has_bitset = row_mask.has_bitset)) {
+            if (!not_fields) {
+                return true;
+            } else {
+                goto done;
+            }
+        }
 
-    uint64_t gen = flecs_sparse_strip_generation(&index);
-    uint64_t *dense_array = ecs_vec_first_t(&sparse->dense, uint64_t);
-    uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK;
-    (void)cur_gen; (void)gen;
+        /* No enabled bits */
+        block = row_mask.mask;
+        if (!block) {
+next_block:
+            new_block_index ++;
+            cur = new_block_index * 64;
+            if (cur >= last) {
+                /* No more rows */
+                goto done;
+            }
 
-    ecs_assert(cur_gen == gen, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(dense < sparse->count, ECS_INTERNAL_ERROR, NULL);
-    return DATA(page->data, sparse->size, offset);
-}
+            op_ctx->cur = cur;
+            goto compute_block;
+        }
 
-void* flecs_sparse_get_any(
-    const ecs_sparse_t *sparse,
-    ecs_size_t size,
-    uint64_t index)
-{
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL);
-    (void)size;
-    
-    flecs_sparse_strip_generation(&index);
-    ecs_page_t *page = flecs_sparse_get_page(sparse, PAGE(index));
-    if (!page || !page->sparse) {
-        return NULL;
+        op_ctx->block = block;
     }
 
-    int32_t offset = OFFSET(index);
-    int32_t dense = page->sparse[offset];
-    bool in_use = dense && (dense < sparse->count);
-    if (!in_use) {
-        return NULL;
-    }
+    /* Find first enabled bit (TODO: use faster bitmagic) */
+    int32_t first_bit = cur - (block_index * 64);
+    int32_t last_bit = ECS_MIN(64, last - (block_index * 64));
+    ecs_assert(first_bit >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(first_bit < 64, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(last_bit >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(last_bit <= 64, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(last_bit >= first_bit, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_assert(dense == page->sparse[offset], ECS_INTERNAL_ERROR, NULL);
-    return DATA(page->data, sparse->size, offset);
-}
+    for (i = first_bit; i < last_bit; i ++) {
+        uint64_t bit = (1ull << i);
+        bool cond = 0 != (block & bit);
+        if (cond) {
+            /* Find last enabled bit */
+            for (j = i; j < last_bit; j ++) {
+                bit = (1ull << j);
+                cond = !(block & bit);
+                if (cond) {
+                    break;
+                }
+            }
 
-int32_t flecs_sparse_count(
-    const ecs_sparse_t *sparse)
-{
-    if (!sparse || !sparse->count) {
-        return 0;
+            row = i + (block_index * 64);
+            cur = j + (block_index * 64);
+            break;
+        }
     }
 
-    return sparse->count - 1;
-}
-
-const uint64_t* flecs_sparse_ids(
-    const ecs_sparse_t *sparse)
-{
-    ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL);
-    if (sparse->dense.array) {
-        return &(ecs_vec_first_t(&sparse->dense, uint64_t)[1]);
-    } else {
-        return NULL;
+    if (i == last_bit) {
+        goto next_block;
     }
-}
 
-void ecs_sparse_init(
-    ecs_sparse_t *sparse,
-    ecs_size_t elem_size)
-{
-    flecs_sparse_init(sparse, NULL, NULL, elem_size);
-}
+    ecs_assert(row >= first, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cur <= last, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cur >= first, ECS_INTERNAL_ERROR, NULL);
 
-void* ecs_sparse_add(
-    ecs_sparse_t *sparse,
-    ecs_size_t elem_size)
-{
-    return flecs_sparse_add(sparse, elem_size);
-}
+    if (!(cur - row)) {
+        goto done;
+    }
 
-uint64_t ecs_sparse_last_id(
-    const ecs_sparse_t *sparse)
-{
-    return flecs_sparse_last_id(sparse);
-}
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        flecs_query_var_narrow_range(op->src.var, table, row, cur - row, ctx);
+    }
+    op_ctx->cur = cur;
 
-int32_t ecs_sparse_count(
-    const ecs_sparse_t *sparse)
-{
-    return flecs_sparse_count(sparse);
-}
+    return true;
 
-void* ecs_sparse_get_dense(
-    const ecs_sparse_t *sparse,
-    ecs_size_t elem_size,
-    int32_t index)
-{
-    return flecs_sparse_get_dense(sparse, elem_size, index);
-}
+done:
+    /* Restore range & set fields */
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        flecs_query_var_narrow_range(op->src.var, 
+            table, op_ctx->range.offset, op_ctx->range.count, ctx);
+    }
 
-void* ecs_sparse_get(
-    const ecs_sparse_t *sparse,
-    ecs_size_t elem_size,
-    uint64_t id)
-{
-    return flecs_sparse_get(sparse, elem_size, id);
+    it->set_fields = op_ctx->prev_set_fields;
+    return false;
 }
 
-/**
- * @file datastructures/stack_allocator.c
- * @brief Stack allocator.
- * 
- * The stack allocator enables pushing and popping values to a stack, and has
- * a lower overhead when compared to block allocators. A stack allocator is a
- * good fit for small temporary allocations.
- * 
- * The stack allocator allocates memory in pages. If the requested size of an
- * allocation exceeds the page size, a regular allocator is used instead.
- */
-
-
-#define FLECS_STACK_PAGE_OFFSET ECS_ALIGN(ECS_SIZEOF(ecs_stack_page_t), 16)
+static
+bool flecs_query_toggle(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    ecs_iter_t *it = ctx->it;
+    ecs_query_toggle_ctx_t *op_ctx = flecs_op_ctx(ctx, toggle);
+    if (!redo) {
+        op_ctx->prev_set_fields = it->set_fields;
+    }
 
-int64_t ecs_stack_allocator_alloc_count = 0;
-int64_t ecs_stack_allocator_free_count = 0;
+    ecs_flags64_t and_fields = op->first.entity;
+    ecs_flags64_t not_fields = op->second.entity & op_ctx->prev_set_fields;
 
-static
-ecs_stack_page_t* flecs_stack_page_new(uint32_t page_id) {
-    ecs_stack_page_t *result = ecs_os_malloc(
-        FLECS_STACK_PAGE_OFFSET + ECS_STACK_PAGE_SIZE);
-    result->data = ECS_OFFSET(result, FLECS_STACK_PAGE_OFFSET);
-    result->next = NULL;
-    result->id = page_id + 1;
-    ecs_os_linc(&ecs_stack_allocator_alloc_count);
-    return result;
+    return flecs_query_toggle_cmp(
+        op, redo, ctx, and_fields, not_fields);
 }
 
-void* flecs_stack_alloc(
-    ecs_stack_t *stack, 
-    ecs_size_t size,
-    ecs_size_t align)
+static
+bool flecs_query_toggle_option(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_stack_page_t *page = stack->tail_page;
-    if (page == &stack->first && !page->data) {
-        page->data = ecs_os_malloc(ECS_STACK_PAGE_SIZE);
-        ecs_os_linc(&ecs_stack_allocator_alloc_count);
+    ecs_iter_t *it = ctx->it;
+    ecs_query_toggle_ctx_t *op_ctx = flecs_op_ctx(ctx, toggle);
+    if (!redo) {
+        op_ctx->prev_set_fields = it->set_fields;
+        op_ctx->optional_not = false;
+        op_ctx->has_bitset = false;
     }
 
-    int16_t sp = flecs_ito(int16_t, ECS_ALIGN(page->sp, align));
-    int16_t next_sp = flecs_ito(int16_t, sp + size);
-    void *result = NULL;
-
-    if (next_sp > ECS_STACK_PAGE_SIZE) {
-        if (size > ECS_STACK_PAGE_SIZE) {
-            result = ecs_os_malloc(size); /* Too large for page */
-            goto done;
-        }
-
-        if (page->next) {
-            page = page->next;
-        } else {
-            page = page->next = flecs_stack_page_new(page->id);
-        }
-        sp = 0;
-        next_sp = flecs_ito(int16_t, size);
-        stack->tail_page = page;
+repeat: {}
+    ecs_flags64_t and_fields = 0, not_fields = 0;
+    if (op_ctx->optional_not) {
+        not_fields = op->first.entity & op_ctx->prev_set_fields;
+    } else {
+        and_fields = op->first.entity;
     }
 
-    page->sp = next_sp;
-    result = ECS_OFFSET(page->data, sp);
+    bool result = flecs_query_toggle_cmp(
+        op, redo, ctx, and_fields, not_fields);
+    if (!result) {
+        if (!op_ctx->optional_not) {
+            /* Run the not-branch of optional fields */
+            op_ctx->optional_not = true;
+            it->set_fields = op_ctx->prev_set_fields;
+            redo = false;
+            goto repeat;
+        }
+    }
 
-done:
-#ifdef FLECS_SANITIZE
-    ecs_os_memset(result, 0xAA, size);
-#endif
     return result;
 }
 
-void* flecs_stack_calloc(
-    ecs_stack_t *stack, 
-    ecs_size_t size,
-    ecs_size_t align)
+static
+bool flecs_query_pred_neq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    void *ptr = flecs_stack_alloc(stack, size, align);
-    ecs_os_memset(ptr, 0, size);
-    return ptr;
+    uint64_t written = ctx->written[ctx->op_index]; (void)written;
+    ecs_assert(flecs_ref_is_written(op, &op->second, EcsQuerySecond, written),
+        ECS_INTERNAL_ERROR, 
+            "invalid instruction sequence: uninitialized neq operand");
+
+    ecs_table_range_t r = flecs_query_get_range(
+        op, &op->second, EcsQuerySecond, ctx);
+    return flecs_query_pred_neq_w_range(op, redo, ctx, r);
 }
 
-void flecs_stack_free(
-    void *ptr,
-    ecs_size_t size)
+static
+bool flecs_query_pred_neq_name(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    if (size > ECS_STACK_PAGE_SIZE) {
-        ecs_os_free(ptr);
+    const char *name = flecs_query_name_arg(op, ctx);
+    ecs_entity_t e = ecs_lookup(ctx->world, name);
+    if (!e) {
+        /* Entity doesn't exist */
+        return true && !redo;
     }
+
+    ecs_table_range_t r = flecs_range_from_entity(e, ctx);
+    return flecs_query_pred_neq_w_range(op, redo, ctx, r);
 }
 
-ecs_stack_cursor_t* flecs_stack_get_cursor(
-    ecs_stack_t *stack)
+static
+bool flecs_query_lookup(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_stack_page_t *page = stack->tail_page;
-    int16_t sp = stack->tail_page->sp;
-    ecs_stack_cursor_t *result = flecs_stack_alloc_t(stack, ecs_stack_cursor_t);
-    result->page = page;
-    result->sp = sp;
-    result->is_free = false;
-
-#ifdef FLECS_DEBUG
-    ++ stack->cursor_count;
-    result->owner = stack;
-#endif
+    if (redo) {
+        return false;
+    }
 
-    result->prev = stack->tail_cursor;
-    stack->tail_cursor = result;
-    return result;
-}
+    const ecs_query_impl_t *query = ctx->query;
+    ecs_entity_t first = flecs_query_var_get_entity(op->first.var, ctx);
+    ecs_query_var_t *var = &query->vars[op->src.var];
 
-void flecs_stack_restore_cursor(
-    ecs_stack_t *stack,
-    ecs_stack_cursor_t *cursor)
-{
-    if (!cursor) {
-        return;
+    ecs_entity_t result = ecs_lookup_path_w_sep(ctx->world, first, var->lookup,
+        NULL, NULL, false);
+    if (!result) {
+        flecs_query_var_set_entity(op, op->src.var, EcsWildcard, ctx);
+        return false;
     }
 
-    ecs_dbg_assert(stack == cursor->owner, ECS_INVALID_OPERATION, NULL);
-    ecs_dbg_assert(stack->cursor_count > 0, ECS_DOUBLE_FREE, NULL);
-    ecs_assert(cursor->is_free == false, ECS_DOUBLE_FREE, NULL);
+    flecs_query_var_set_entity(op, op->src.var, result, ctx);
 
-    cursor->is_free = true;
+    return true;
+}
 
-#ifdef FLECS_DEBUG    
-    -- stack->cursor_count;
-#endif
+static
+bool flecs_query_setvars(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
 
-    /* If cursor is not the last on the stack no memory should be freed */
-    if (cursor != stack->tail_cursor) {
-        return;
+    const ecs_query_impl_t *query = ctx->query;
+    const ecs_query_t *q = &query->pub;
+    ecs_var_id_t *src_vars = query->src_vars;
+    ecs_iter_t *it = ctx->it;
+
+    if (redo) {
+        return false;
     }
 
-    /* Iterate freed cursors to know how much memory we can free */
-    do {
-        ecs_stack_cursor_t* prev = cursor->prev;
-        if (!prev || !prev->is_free) {
-            break; /* Found active cursor, free up until this point */
+    int32_t i;
+    ecs_flags32_t up_fields = it->up_fields;
+    for (i = 0; i < q->field_count; i ++) {
+        ecs_var_id_t var_id = src_vars[i];
+        if (!var_id) {
+            continue;
         }
-        cursor = prev;
-    } while (cursor);
 
-    stack->tail_cursor = cursor->prev;
-    stack->tail_page = cursor->page;
-    stack->tail_page->sp = cursor->sp;
+        if (up_fields & (1u << i)) {
+            continue;
+        }
 
-    /* If the cursor count is zero, stack should be empty
-     * if the cursor count is non-zero, stack should not be empty */
-    ecs_dbg_assert((stack->cursor_count == 0) == 
-        (stack->tail_page == &stack->first && stack->tail_page->sp == 0), 
-            ECS_LEAK_DETECTED, NULL);
-}
+        it->sources[i] = flecs_query_var_get_entity(var_id, ctx);
+    }
 
-void flecs_stack_reset(
-    ecs_stack_t *stack)
-{
-    ecs_dbg_assert(stack->cursor_count == 0, ECS_LEAK_DETECTED, NULL);
-    stack->tail_page = &stack->first;
-    stack->first.sp = 0;
-    stack->tail_cursor = NULL;
+    return true;
 }
 
-void flecs_stack_init(
-    ecs_stack_t *stack)
+static
+bool flecs_query_setthis(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_os_zeromem(stack);
-    stack->tail_page = &stack->first;
-    stack->first.data = NULL;
+    ecs_query_setthis_ctx_t *op_ctx = flecs_op_ctx(ctx, setthis);
+    ecs_var_t *vars = ctx->vars;
+    ecs_var_t *this_var = &vars[op->first.var];
+
+    if (!redo) {
+        /* Save values so we can restore them later */
+        op_ctx->range = vars[0].range;
+
+        /* Constrain This table variable to a single entity from the table */
+        vars[0].range = flecs_range_from_entity(this_var->entity, ctx);
+        vars[0].entity = this_var->entity;
+        return true;
+    } else {
+        /* Restore previous values, so that instructions that are operating on
+         * the table variable use all the entities in the table. */
+        vars[0].range = op_ctx->range;
+        vars[0].entity = 0;
+        return false;
+    }
 }
 
-void flecs_stack_fini(
-    ecs_stack_t *stack)
+static
+bool flecs_query_setfixed(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_stack_page_t *next, *cur = &stack->first;
-    ecs_dbg_assert(stack->cursor_count == 0, ECS_LEAK_DETECTED, NULL);
-    ecs_assert(stack->tail_page == &stack->first, ECS_LEAK_DETECTED, NULL);
-    ecs_assert(stack->tail_page->sp == 0, ECS_LEAK_DETECTED, NULL);
+    (void)op;
+    const ecs_query_impl_t *query = ctx->query;
+    const ecs_query_t *q = &query->pub;
+    ecs_iter_t *it = ctx->it;
 
-    do {
-        next = cur->next;
-        if (cur == &stack->first) {
-            if (cur->data) {
-                ecs_os_linc(&ecs_stack_allocator_free_count);
-            }
-            ecs_os_free(cur->data);
-        } else {
-            ecs_os_linc(&ecs_stack_allocator_free_count);
-            ecs_os_free(cur);
+    if (redo) {
+        return false;
+    }
+
+    int32_t i;
+    for (i = 0; i < q->term_count; i ++) {
+        const ecs_term_t *term = &q->terms[i];
+        const ecs_term_ref_t *src = &term->src;
+        if (src->id & EcsIsEntity) {
+            it->sources[term->field_index] = ECS_TERM_REF_ID(src);
         }
-    } while ((cur = next));
+    }
+
+    return true;
 }
 
-/**
- * @file datastructures/strbuf.c
- * @brief Utility for constructing strings.
- *
- * A buffer builds up a list of elements which individually can be up to N bytes
- * large. While appending, data is added to these elements. More elements are
- * added on the fly when needed. When an application calls ecs_strbuf_get, all
- * elements are combined in one string and the element administration is freed.
- *
- * This approach prevents reallocs of large blocks of memory, and therefore
- * copying large blocks of memory when appending to a large buffer. A buffer
- * preallocates some memory for the element overhead so that for small strings
- * there is hardly any overhead, while for large strings the overhead is offset
- * by the reduced time spent on copying memory.
- * 
- * The functionality provided by strbuf is similar to std::stringstream.
- */
+static
+bool flecs_query_setids(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    const ecs_query_impl_t *query = ctx->query;
+    const ecs_query_t *q = &query->pub;
+    ecs_iter_t *it = ctx->it;
 
-#include <math.h>
+    if (redo) {
+        return false;
+    }
 
-/**
- *  stm32tpl --  STM32 C++ Template Peripheral Library
- *  Visit https://github.com/antongus/stm32tpl for new versions
- *
- *  Copyright (c) 2011-2020 Anton B. Gusev aka AHTOXA
- */
+    int32_t i;
+    for (i = 0; i < q->term_count; i ++) {
+        const ecs_term_t *term = &q->terms[i];
+        it->ids[term->field_index] = term->id;
+    }
 
-#define MAX_PRECISION	(10)
-#define EXP_THRESHOLD   (3)
-#define INT64_MAX_F ((double)INT64_MAX)
+    return true;
+}
 
-static const double rounders[MAX_PRECISION + 1] =
+static
+bool flecs_query_setid(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-	0.5,				// 0
-	0.05,				// 1
-	0.005,				// 2
-	0.0005,				// 3
-	0.00005,			// 4
-	0.000005,			// 5
-	0.0000005,			// 6
-	0.00000005,			// 7
-	0.000000005,		// 8
-	0.0000000005,		// 9
-	0.00000000005		// 10
-};
+    if (redo) {
+        return false;
+    }
+
+    ecs_assert(op->field_index != -1, ECS_INTERNAL_ERROR, NULL);
+    ctx->it->ids[op->field_index] = op->first.entity;
+    return true;
+}
 
+/* Check if entity is stored in table */
 static
-char* flecs_strbuf_itoa(
-    char *buf,
-    int64_t v)
+bool flecs_query_contain(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    char *ptr = buf;
-    char * p1;
-	char c;
-
-	if (!v) {
-		*ptr++ = '0';
-    } else {
-        if (v < 0) {
-            ptr[0] = '-';
-            ptr ++;
-            v *= -1;
-        }
+    if (redo) {
+        return false;
+    }
 
-		char *p = ptr;
-		while (v) {
-            int64_t vdiv = v / 10;
-            int64_t vmod = v - (vdiv * 10);
-			p[0] = (char)('0' + vmod);
-            p ++;
-			v = vdiv;
-		}
+    ecs_var_id_t src_id = op->src.var;
+    ecs_var_id_t first_id = op->first.var;
 
-		p1 = p;
+    ecs_table_t *table = flecs_query_var_get_table(src_id, ctx);
 
-		while (p > ptr) {
-			c = *--p;
-			*p = *ptr;
-			*ptr++ = c;
-		}
-		ptr = p1;
-	}
-    return ptr;
+    ecs_entity_t e = flecs_query_var_get_entity(first_id, ctx);
+    return table == ecs_get_table(ctx->world, e);
 }
 
+/* Check if first and second id of pair from last operation are the same */
 static
-void flecs_strbuf_ftoa(
-    ecs_strbuf_t *out, 
-    double f, 
-    int precision,
-    char nan_delim)
+bool flecs_query_pair_eq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    char buf[64];
-	char * ptr = buf;
-	char c;
-	int64_t intPart;
-    int64_t exp = 0;
-
-    if (ecs_os_isnan(f)) {
-        if (nan_delim) {
-            ecs_strbuf_appendch(out, nan_delim);
-            ecs_strbuf_appendlit(out, "NaN");
-            ecs_strbuf_appendch(out, nan_delim);
-            return;
-        } else {
-            ecs_strbuf_appendlit(out, "NaN");
-            return;
-        }
-    }
-    if (ecs_os_isinf(f)) {
-        if (nan_delim) {
-            ecs_strbuf_appendch(out, nan_delim);
-            ecs_strbuf_appendlit(out, "Inf");
-            ecs_strbuf_appendch(out, nan_delim);
-            return;
-        } else {
-            ecs_strbuf_appendlit(out, "Inf");
-            return;
-        }
-    }
-
-	if (precision > MAX_PRECISION) {
-		precision = MAX_PRECISION;
+    if (redo) {
+        return false;
     }
 
-	if (f < 0) {
-		f = -f;
-		*ptr++ = '-';
-	}
+    ecs_iter_t *it = ctx->it;
+    ecs_id_t id = it->ids[op->field_index];
+    return ECS_PAIR_FIRST(id) == ECS_PAIR_SECOND(id);
+}
 
-	if (precision < 0) {
-		if (f < 1.0) precision = 6;
-		else if (f < 10.0) precision = 5;
-		else if (f < 100.0) precision = 4;
-		else if (f < 1000.0) precision = 3;
-		else if (f < 10000.0) precision = 2;
-		else if (f < 100000.0) precision = 1;
-		else precision = 0;
-	}
+static
+void flecs_query_reset_after_block(
+    const ecs_query_op_t *start_op,
+    ecs_query_run_ctx_t *ctx,
+    ecs_query_ctrl_ctx_t *op_ctx,
+    bool result)
+{
+    ecs_query_lbl_t op_index = start_op->next;
+    const ecs_query_op_t *op = &ctx->qit->ops[op_index];
 
-	if (precision) {
-		f += rounders[precision];
+    int32_t field = op->field_index;
+    if (field == -1) {
+        goto done;
     }
 
-    /* Make sure that number can be represented as 64bit int, increase exp */
-    while (f > INT64_MAX_F) {
-        f /= 1000 * 1000 * 1000;
-        exp += 9;
+    /* Set/unset field */
+    ecs_iter_t *it = ctx->it;
+    if (result) {
+        ECS_TERMSET_SET(it->set_fields, 1u << field);
+        return;
     }
 
-	intPart = (int64_t)f;
-	f -= (double)intPart;
-
-    ptr = flecs_strbuf_itoa(ptr, intPart);
+    /* Reset state after a field was not matched */
+    ctx->written[op_index] = ctx->written[ctx->op_index];
+    ctx->op_index = op_index;
+    ECS_TERMSET_CLEAR(it->set_fields, 1u << field);
 
-	if (precision) {
-		*ptr++ = '.';
-		while (precision--) {
-			f *= 10.0;
-			c = (char)f;
-			*ptr++ = (char)('0' + c);
-			f -= c;
-		}
-	}
-	*ptr = 0;
+    /* Ignore variables written by Not operation */
+    uint64_t *written = ctx->written;
+    uint64_t written_cur = written[op->prev + 1];
+    ecs_flags16_t flags_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t flags_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
 
-    /* Remove trailing 0s */
-    while ((&ptr[-1] != buf) && (ptr[-1] == '0')) {
-        ptr[-1] = '\0';
-        ptr --;
-    }
-    if (ptr != buf && ptr[-1] == '.') {
-        ptr[-1] = '\0';
-        ptr --;
+    /* Overwrite id with cleared out variables */
+    ecs_id_t id = flecs_query_op_get_id(op, ctx);
+    if (id) {
+        it->ids[field] = id;
     }
 
-    /* If 0s before . exceed threshold, convert to exponent to save space 
-     * without losing precision. */
-    char *cur = ptr;
-    while ((&cur[-1] != buf) && (cur[-1] == '0')) {
-        cur --;
+    /* Reset variables */
+    if (flags_1st & EcsQueryIsVar) {
+        if (!flecs_ref_is_written(op, &op->first, EcsQueryFirst, written_cur)){
+            flecs_query_var_reset(op->first.var, ctx);
+        }
+    }
+    if (flags_2nd & EcsQueryIsVar) {
+        if (!flecs_ref_is_written(op, &op->second, EcsQuerySecond, written_cur)){
+            flecs_query_var_reset(op->second.var, ctx);
+        }
     }
 
-    if (exp || ((ptr - cur) > EXP_THRESHOLD)) {
-        cur[0] = '\0';
-        exp += (ptr - cur);
-        ptr = cur;
+    /* If term has entity src, set it because no other instruction might */
+    if (op->flags & (EcsQueryIsEntity << EcsQuerySrc)) {
+        it->sources[field] = op->src.entity;
     }
 
-    if (exp) {
-        char *p1 = &buf[1];
-        if (nan_delim) {
-            ecs_os_memmove(buf + 1, buf, 1 + (ptr - buf));
-            buf[0] = nan_delim;
-            p1 ++;
-        }
+done:
+    op_ctx->op_index = op_index;
+}
 
-        /* Make sure that exp starts after first character */
-        c = p1[0];
+static
+bool flecs_query_run_block(
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    ecs_query_ctrl_ctx_t *op_ctx)
+{
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
 
-        if (c) {
-            p1[0] = '.';
-            do {
-                char t = (++p1)[0];
-                if (t == '.') {
-                    exp ++;
-                    p1 --;
-                    break;
-                }
-                p1[0] = c;
-                c = t;
-                exp ++;
-            } while (c);
-            ptr = p1 + 1;
-        } else {
-            ptr = p1;
-        }
+    if (!redo) {
+        op_ctx->op_index = flecs_itolbl(ctx->op_index + 1);
+    } else if (ctx->qit->ops[op_ctx->op_index].kind == EcsQueryEnd) {
+        return false;
+    }
 
-        ptr[0] = 'e';
-        ptr = flecs_strbuf_itoa(ptr + 1, exp);
+    ctx->written[ctx->op_index + 1] = ctx->written[ctx->op_index];
 
-        if (nan_delim) {
-            ptr[0] = nan_delim;
-            ptr ++;
-        }
+    const ecs_query_op_t *op = &ctx->qit->ops[ctx->op_index];
+    bool result = flecs_query_run_until(
+        redo, ctx, qit->ops, ctx->op_index, op_ctx->op_index, op->next);
 
-        ptr[0] = '\0';
-    }
-    
-    ecs_strbuf_appendstrn(out, buf, (int32_t)(ptr - buf));
+    op_ctx->op_index = flecs_itolbl(ctx->op_index - 1);
+    return result;
 }
 
-/* Add an extra element to the buffer */
 static
-void flecs_strbuf_grow(
-    ecs_strbuf_t *b)
+ecs_query_lbl_t flecs_query_last_op_for_or_cond(
+    const ecs_query_op_t *ops,
+    ecs_query_lbl_t cur,
+    ecs_query_lbl_t last)
 {
-    if (!b->content) {
-        b->content = b->small_string;
-        b->size = ECS_STRBUF_SMALL_STRING_SIZE;
-    } else if (b->content == b->small_string) {
-        b->size *= 2;
-        b->content = ecs_os_malloc_n(char, b->size);
-        ecs_os_memcpy(b->content, b->small_string, b->length);
-    } else {
-        b->size *= 2;
-        if (b->size < 16) b->size = 16;
-        b->content = ecs_os_realloc_n(b->content, char, b->size);
-    }
+    const ecs_query_op_t *cur_op, *last_op = &ops[last];
+
+    do {
+        cur_op = &ops[cur];
+        cur ++;
+    } while (cur_op->next != last && cur_op != last_op);
+
+    return cur;
 }
 
 static
-char* flecs_strbuf_ptr(
-    ecs_strbuf_t *b)
-{
-    ecs_assert(b->content != NULL, ECS_INTERNAL_ERROR, NULL);
-    return &b->content[b->length];
+bool flecs_query_run_until_for_select_or(
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    const ecs_query_op_t *ops,
+    ecs_query_lbl_t first,
+    ecs_query_lbl_t cur,
+    int32_t last)
+{
+    ecs_query_lbl_t last_for_cur = flecs_query_last_op_for_or_cond(
+        ops, cur, flecs_itolbl(last));
+    if (redo) {
+        /* If redoing, start from the last instruction of the last executed 
+         * sequence */
+        cur = flecs_itolbl(last_for_cur - 1);
+    }
+
+    flecs_query_run_until(redo, ctx, ops, first, cur, last_for_cur);
+#ifdef FLECS_QUERY_TRACE
+    printf("%*s%s (or)\n", (flecs_query_trace_indent + 1)*2, "",
+        ctx->op_index == last ? "true" : "false");
+#endif
+    return ctx->op_index == last;
 }
 
-/* Append a format string to a buffer */
 static
-void flecs_strbuf_vappend(
-    ecs_strbuf_t *b,
-    const char* str,
-    va_list args)
+bool flecs_query_select_or(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    va_list arg_cpy;
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
 
-    if (!str) {
-        return;
+    ecs_query_lbl_t first = flecs_itolbl(ctx->op_index + 1);
+    if (!redo) {
+        op_ctx->op_index = first;
     }
 
-    /* Compute the memory required to add the string to the buffer. If user
-     * provided buffer, use space left in buffer, otherwise use space left in
-     * current element. */
-    int32_t mem_left = b->size - b->length;
-    int32_t mem_required;
+    const ecs_query_op_t *ops = qit->ops;
+    const ecs_query_op_t *first_op = &ops[first - 1];
+    ecs_query_lbl_t last = first_op->next;
+    const ecs_query_op_t *last_op = &ops[last];
+    const ecs_query_op_t *cur_op = &ops[op_ctx->op_index];
+    bool result = false;
 
-    va_copy(arg_cpy, args);
+    do {
+        ecs_query_lbl_t cur = op_ctx->op_index;
+        ctx->op_index = cur;
+        ctx->written[cur] = op->written;
 
-    if (b->content) {
-        mem_required = vsnprintf(
-            flecs_strbuf_ptr(b), 
-                flecs_itosize(mem_left), str, args);
-    } else {
-        mem_required = vsnprintf(NULL, 0, str, args);
-        mem_left = 0;
-    }
+        result = flecs_query_run_until_for_select_or(
+            redo, ctx, ops, flecs_itolbl(first - 1), cur, last);
+
+        if (result) {
+            if (first == cur) {
+                break;
+            }
+
+            /* If a previous operation in the OR chain returned a result for the
+             * same matched source, skip it so we don't yield for each matching
+             * element in the chain. */
+
+            /* Copy written status so that the variables we just wrote will show
+             * up as written for the test. This ensures that the instructions
+             * match against the result we already found, vs. starting a new
+             * search (the difference between select & with). */
+            ecs_query_lbl_t prev = first;
+            bool dup_found = false;
+
+            /* While terms of an OR chain always operate on the same source, it
+             * is possible that a table variable is resolved to an entity 
+             * variable. When checking for duplicates, copy the entity variable
+             * to the table, to ensure we're only testing the found entity. */
+            const ecs_query_op_t *prev_op = &ops[cur - 1];
+            ecs_var_t old_table_var;
+            ecs_os_memset_t(&old_table_var, 0, ecs_var_t);
+            bool restore_table_var = false;
+            
+            if (prev_op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+                if (first_op->src.var != prev_op->src.var) {
+                    restore_table_var = true;
+                    old_table_var = ctx->vars[first_op->src.var];
+                    ctx->vars[first_op->src.var] = 
+                        ctx->vars[prev_op->src.var];
+                }
+            }
+
+            do {
+                ctx->written[prev] = ctx->written[last];
+
+                flecs_query_run_until(false, ctx, ops, flecs_itolbl(first - 1), 
+                    prev, cur);
+
+                if (ctx->op_index == last) {
+                    /* Duplicate match was found, find next result */
+                    redo = true;
+                    dup_found = true;
+                    break;
+                }
+
+                break;
+            } while (true);
 
-    ecs_assert(mem_required != -1, ECS_INTERNAL_ERROR, NULL);
+            /* Restore table variable to full range for next result */
+            if (restore_table_var) {
+                ctx->vars[first_op->src.var] = old_table_var;
+            }
 
-    if ((mem_required + 1) >= mem_left) {
-        while ((mem_required + 1) >= mem_left) {
-            flecs_strbuf_grow(b);
-            mem_left = b->size - b->length;
+            if (dup_found) {
+                continue;
+            }
+
+            break;
         }
-        vsnprintf(flecs_strbuf_ptr(b), 
-            flecs_itosize(mem_required + 1), str, arg_cpy);
-    }
 
-    b->length += mem_required;
+        /* No result was found, go to next operation in chain */
+        op_ctx->op_index = flecs_query_last_op_for_or_cond(
+            ops, op_ctx->op_index, last);
+        cur_op = &qit->ops[op_ctx->op_index];
 
-    va_end(arg_cpy);
+        redo = false;
+    } while (cur_op != last_op);
+
+    return result;
 }
 
 static
-void flecs_strbuf_appendstr(
-    ecs_strbuf_t *b,
-    const char* str,
-    int n)
+bool flecs_query_with_or(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    int32_t mem_left = b->size - b->length;
-    while (n >= mem_left) {
-        flecs_strbuf_grow(b);
-        mem_left = b->size - b->length;
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+
+    bool result = flecs_query_run_block(redo, ctx, op_ctx);
+    if (result) {
+        /* If a match was found, no need to keep searching for this source */
+        op_ctx->op_index = op->next;
     }
 
-    ecs_os_memcpy(flecs_strbuf_ptr(b), str, n);
-    b->length += n;
+    return result;
 }
 
 static
-void flecs_strbuf_appendch(
-    ecs_strbuf_t *b,
-    char ch)
+bool flecs_query_or(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    if (b->size == b->length) {
-        flecs_strbuf_grow(b);
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        uint64_t written = ctx->written[ctx->op_index];
+        if (!(written & (1ull << op->src.var))) {
+            return flecs_query_select_or(op, redo, ctx);
+        }
     }
 
-    flecs_strbuf_ptr(b)[0] = ch;
-    b->length ++;
+    return flecs_query_with_or(op, redo, ctx);
 }
 
-void ecs_strbuf_vappend(
-    ecs_strbuf_t *b,
-    const char* fmt,
-    va_list args)
+static
+bool flecs_query_run_block_w_reset(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL);
-    flecs_strbuf_vappend(b, fmt, args);
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+
+    bool result = flecs_query_run_block(redo, ctx, op_ctx);
+    flecs_query_reset_after_block(op, ctx, op_ctx, result);
+    return result;
 }
 
-void ecs_strbuf_append(
-    ecs_strbuf_t *b,
-    const char* fmt,
-    ...)
+static
+bool flecs_query_not(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL);
+    if (redo) {
+        return false;
+    }
 
-    va_list args;
-    va_start(args, fmt);
-    flecs_strbuf_vappend(b, fmt, args);
-    va_end(args);
+    return !flecs_query_run_block_w_reset(op, redo, ctx);
 }
 
-void ecs_strbuf_appendstrn(
-    ecs_strbuf_t *b,
-    const char* str,
-    int32_t len)
-{
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL);
-    flecs_strbuf_appendstr(b, str, len);
+static
+bool flecs_query_optional(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{   
+    bool result = flecs_query_run_block_w_reset(op, redo, ctx);
+    if (!redo) {
+        return true; /* Return at least once */
+    } else {
+        return result;
+    }
 }
 
-void ecs_strbuf_appendch(
-    ecs_strbuf_t *b,
-    char ch)
+static
+bool flecs_query_eval_if(
+    const ecs_query_op_t *op,
+    ecs_query_run_ctx_t *ctx,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); 
-    flecs_strbuf_appendch(b, ch);
+    bool result = true;
+    if (flecs_query_ref_flags(op->flags, ref_kind) == EcsQueryIsVar) {
+        result = ctx->vars[ref->var].entity != EcsWildcard;
+        ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+        flecs_query_reset_after_block(op, ctx, op_ctx, result);
+        return result;
+    }
+    return true;
 }
 
-void ecs_strbuf_appendint(
-    ecs_strbuf_t *b,
-    int64_t v)
+static
+bool flecs_query_if_var(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); 
-    char numbuf[32];
-    char *ptr = flecs_strbuf_itoa(numbuf, v);
-    ecs_strbuf_appendstrn(b, numbuf, flecs_ito(int32_t, ptr - numbuf));
-}
+    if (!redo) {
+        if (!flecs_query_eval_if(op, ctx, &op->src, EcsQuerySrc) ||
+            !flecs_query_eval_if(op, ctx, &op->first, EcsQueryFirst) ||
+            !flecs_query_eval_if(op, ctx, &op->second, EcsQuerySecond))
+        {
+            return true;
+        }
+    }
 
-void ecs_strbuf_appendflt(
-    ecs_strbuf_t *b,
-    double flt,
-    char nan_delim)
-{
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); 
-    flecs_strbuf_ftoa(b, flt, 10, nan_delim);
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+    return flecs_query_run_block(redo, ctx, op_ctx);
 }
 
-void ecs_strbuf_appendbool(
-    ecs_strbuf_t *buffer,
-    bool v)
+static
+bool flecs_query_if_set(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(buffer != NULL, ECS_INVALID_PARAMETER, NULL); 
-    if (v) {
-        ecs_strbuf_appendlit(buffer, "true");
-    } else {
-        ecs_strbuf_appendlit(buffer, "false");
+    ecs_iter_t *it = ctx->it;
+    uint8_t field_index = flecs_ito(uint8_t, op->other);
+
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+    if (!redo) {
+        op_ctx->is_set = ecs_field_is_set(it, field_index);
+    }
+
+    if (!op_ctx->is_set) {
+        return !redo;
     }
+
+    return flecs_query_run_block(redo, ctx, op_ctx);
 }
 
-void ecs_strbuf_appendstr(
-    ecs_strbuf_t *b,
-    const char* str)
+static
+bool flecs_query_end(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL);
-    flecs_strbuf_appendstr(b, str, ecs_os_strlen(str));
+    (void)op; (void)ctx;
+    return !redo;
 }
 
-void ecs_strbuf_mergebuff(
-    ecs_strbuf_t *b,
-    ecs_strbuf_t *src)
+static
+void flecs_query_populate_field_from_range(
+    ecs_iter_t *it,
+    ecs_table_range_t *range,
+    int8_t field_index,
+    int32_t index)
 {
-    if (src->content) {
-        ecs_strbuf_appendstr(b, src->content);
+    ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(range->table != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (range->count && range->table->column_map) {
+        int32_t column = range->table->column_map[index];
+        if (column != -1) {
+            it->ptrs[field_index] = ECS_ELEM(
+                range->table->data.columns[column].data.array,
+                it->sizes[field_index],
+                range->offset);
+        }
     }
-    ecs_strbuf_reset(src);
 }
 
-char* ecs_strbuf_get(
-    ecs_strbuf_t *b) 
+static
+void flecs_query_populate_field(
+    ecs_iter_t *it,
+    ecs_table_range_t *range,
+    int8_t field_index,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    char *result = b->content;
-    if (!result) {
-        return NULL;
-    }
+    int32_t index = it->columns[field_index];
+    ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(ecs_field_is_set(it, field_index), ECS_INTERNAL_ERROR, NULL);
 
-    ecs_strbuf_appendch(b, '\0');
-    result = b->content;
+    ecs_entity_t src = it->sources[field_index];
+    if (!src) {
+        flecs_query_populate_field_from_range(it, range, field_index, index);
+        ECS_TERMSET_CLEAR(it->shared_fields, 1u << field_index);
+    } else {
+        ecs_record_t *r = flecs_entities_get(ctx->world, src);
+        ecs_table_t *src_table = r->table;
+        if (src_table->column_map) {
+            int32_t column = src_table->column_map[index];
+            if (column != -1) {
+                it->ptrs[field_index] = ecs_vec_get(
+                    &src_table->data.columns[column].data,
+                    it->sizes[field_index],
+                    ECS_RECORD_TO_ROW(r->row));
 
-    if (result == b->small_string) {
-        result = ecs_os_memdup_n(result, char, b->length + 1);
+                ECS_TERMSET_SET(it->shared_fields, 1u << field_index);
+            }
+        }
     }
+}
 
-    b->length = 0;
-    b->content = NULL;
-    b->size = 0;
-    b->list_sp = 0;
-    return result;
+static
+bool flecs_query_populate(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    if (!redo) {
+        ecs_iter_t *it = ctx->it;
+        if (it->flags & EcsIterNoData) {
+            return true;
+        }
+
+        const ecs_query_impl_t *query = ctx->query;
+        const ecs_query_t *q = &query->pub;
+        int8_t i, field_count = q->field_count;
+        ecs_flags64_t data_fields = op->src.entity; /* Bitset with fields to set */
+        ecs_table_range_t *range = &ctx->vars[0].range;
+        ecs_table_t *table = range->table;
+        if (table && !range->count) {
+            range->count = ecs_table_count(table);
+        }
+
+        /* Only populate fields that are set */
+        data_fields &= it->set_fields;
+        for (i = 0; i < field_count; i ++) {
+            if (!(data_fields & (1llu << i))) {
+                continue;
+            }
+
+            flecs_query_populate_field(it, range, i, ctx);
+        }
+
+        return true;
+    } else {
+        return false;
+    }
 }
 
-char* ecs_strbuf_get_small(
-    ecs_strbuf_t *b)
+static
+bool flecs_query_populate_self(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    char *result = b->content;
-    result[b->length] = '\0';
-    b->length = 0;
-    b->content = NULL;
-    b->size = 0;
-    return result;
+    (void)op;
+    if (!redo) {
+        const ecs_query_impl_t *query = ctx->query;
+        const ecs_query_t *q = &query->pub;
+        int32_t i, field_count = q->field_count;
+        ecs_flags64_t data_fields = op->src.entity; /* Bitset with fields to set */
+        ecs_iter_t *it = ctx->it;
+
+        ecs_table_range_t *range = &ctx->vars[0].range;
+        ecs_table_t *table = range->table;
+        if (!table->column_map) {
+            return true;
+        }
+
+        if (!ecs_table_count(table)) {
+            return true;
+        }
+
+        /* Only populate fields that can be set */
+        data_fields &= it->set_fields;
+        for (i = 0; i < field_count; i ++) {
+            if (!(data_fields & (1llu << i))) {
+                continue;
+            }
+
+            int32_t index = it->columns[i];
+            ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
+
+            int32_t column = table->column_map[index];
+            if (column != -1) {
+                it->ptrs[i] = ECS_ELEM(
+                    table->data.columns[column].data.array,
+                    it->sizes[i],
+                    range->offset);
+            }
+        }
+
+        return true;
+    } else {
+        return false;
+    }
 }
 
-void ecs_strbuf_reset(
-    ecs_strbuf_t *b) 
+static
+bool flecs_query_dispatch(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    if (b->content && b->content != b->small_string) {
-        ecs_os_free(b->content);
+    switch(op->kind) {
+    case EcsQueryAnd: return flecs_query_and(op, redo, ctx);
+    case EcsQueryAndId: return flecs_query_and_id(op, redo, ctx);
+    case EcsQueryAndAny: return flecs_query_and_any(op, redo, ctx);
+    case EcsQueryTriv: return flecs_query_triv(op, redo, ctx);
+    case EcsQueryTrivData: return flecs_query_triv_data(op, redo, ctx);
+    case EcsQueryTrivWildcard: return flecs_query_triv_wildcard(op, redo, ctx);
+    case EcsQueryCache: return flecs_query_cache(op, redo, ctx);
+    case EcsQueryIsCache: return flecs_query_is_cache(op, redo, ctx);
+    case EcsQueryCacheData: return flecs_query_cache_data(op, redo, ctx);
+    case EcsQueryIsCacheData: return flecs_query_is_cache_data(op, redo, ctx);
+    case EcsQuerySelectAny: return flecs_query_select_any(op, redo, ctx);
+    case EcsQueryUp: return flecs_query_up(op, redo, ctx);
+    case EcsQueryUpId: return flecs_query_up_id(op, redo, ctx);
+    case EcsQuerySelfUp: return flecs_query_self_up(op, redo, ctx);
+    case EcsQuerySelfUpId: return flecs_query_self_up_id(op, redo, ctx);
+    case EcsQueryWith: return flecs_query_with(op, redo, ctx);
+    case EcsQueryTrav: return flecs_query_trav(op, redo, ctx);
+    case EcsQueryAndFrom: return flecs_query_and_from(op, redo, ctx);
+    case EcsQueryNotFrom: return flecs_query_not_from(op, redo, ctx);
+    case EcsQueryOrFrom: return flecs_query_or_from(op, redo, ctx);
+    case EcsQueryIds: return flecs_query_ids(op, redo, ctx);
+    case EcsQueryIdsRight: return flecs_query_idsright(op, redo, ctx);
+    case EcsQueryIdsLeft: return flecs_query_idsleft(op, redo, ctx);
+    case EcsQueryEach: return flecs_query_each(op, redo, ctx);
+    case EcsQueryStore: return flecs_query_store(op, redo, ctx);
+    case EcsQueryReset: return flecs_query_reset(op, redo, ctx);
+    case EcsQueryOr: return flecs_query_or(op, redo, ctx);
+    case EcsQueryOptional: return flecs_query_optional(op, redo, ctx);
+    case EcsQueryIfVar: return flecs_query_if_var(op, redo, ctx);
+    case EcsQueryIfSet: return flecs_query_if_set(op, redo, ctx);
+    case EcsQueryEnd: return flecs_query_end(op, redo, ctx);
+    case EcsQueryNot: return flecs_query_not(op, redo, ctx);
+    case EcsQueryPredEq: return flecs_query_pred_eq(op, redo, ctx);
+    case EcsQueryPredNeq: return flecs_query_pred_neq(op, redo, ctx);
+    case EcsQueryPredEqName: return flecs_query_pred_eq_name(op, redo, ctx);
+    case EcsQueryPredNeqName: return flecs_query_pred_neq_name(op, redo, ctx);
+    case EcsQueryPredEqMatch: return flecs_query_pred_eq_match(op, redo, ctx);
+    case EcsQueryPredNeqMatch: return flecs_query_pred_neq_match(op, redo, ctx);
+    case EcsQueryMemberEq: return flecs_query_member_eq(op, redo, ctx);
+    case EcsQueryMemberNeq: return flecs_query_member_neq(op, redo, ctx);
+    case EcsQueryToggle: return flecs_query_toggle(op, redo, ctx);
+    case EcsQueryToggleOption: return flecs_query_toggle_option(op, redo, ctx);
+    case EcsQueryLookup: return flecs_query_lookup(op, redo, ctx);
+    case EcsQuerySetVars: return flecs_query_setvars(op, redo, ctx);
+    case EcsQuerySetThis: return flecs_query_setthis(op, redo, ctx);
+    case EcsQuerySetFixed: return flecs_query_setfixed(op, redo, ctx);
+    case EcsQuerySetIds: return flecs_query_setids(op, redo, ctx);
+    case EcsQuerySetId: return flecs_query_setid(op, redo, ctx);
+    case EcsQueryContain: return flecs_query_contain(op, redo, ctx);
+    case EcsQueryPairEq: return flecs_query_pair_eq(op, redo, ctx);
+    case EcsQueryPopulate: return flecs_query_populate(op, redo, ctx);
+    case EcsQueryPopulateSelf: return flecs_query_populate_self(op, redo, ctx);
+    case EcsQueryYield: return false;
+    case EcsQueryNothing: return false;
     }
-    *b = ECS_STRBUF_INIT;
+    return false;
 }
 
-void ecs_strbuf_list_push(
-    ecs_strbuf_t *b,
-    const char *list_open,
-    const char *separator)
+static
+bool flecs_query_run_until(
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    const ecs_query_op_t *ops,
+    ecs_query_lbl_t first,
+    ecs_query_lbl_t cur,
+    int32_t last)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(list_open != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(separator != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(b->list_sp >= 0, ECS_INVALID_OPERATION, NULL);
-    b->list_sp ++;
-    ecs_assert(b->list_sp < ECS_STRBUF_MAX_LIST_DEPTH, 
-        ECS_INVALID_OPERATION, NULL);
+    ecs_assert(first >= -1, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cur >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cur > first, ECS_INTERNAL_ERROR, NULL);
 
-    b->list_stack[b->list_sp].count = 0;
-    b->list_stack[b->list_sp].separator = separator;
+    ctx->op_index = cur;
+    const ecs_query_op_t *op = &ops[ctx->op_index];
+    const ecs_query_op_t *last_op = &ops[last];
+    ecs_assert(last > first, ECS_INTERNAL_ERROR, NULL);
 
-    if (list_open) {
-        char ch = list_open[0];
-        if (ch && !list_open[1]) {
-            ecs_strbuf_appendch(b, ch);
-        } else {
-            ecs_strbuf_appendstr(b, list_open);
+#ifdef FLECS_QUERY_TRACE
+    printf("%*sblock:\n", flecs_query_trace_indent*2, "");
+    flecs_query_trace_indent ++;
+#endif
+
+    do {
+        #ifdef FLECS_DEBUG
+        ctx->qit->profile[ctx->op_index].count[redo] ++;
+        #endif
+
+#ifdef FLECS_QUERY_TRACE
+        printf("%*s%d: %s\n", flecs_query_trace_indent*2, "", 
+            ctx->op_index, flecs_query_op_str(op->kind));
+#endif
+
+        bool result = flecs_query_dispatch(op, redo, ctx);
+        cur = (&op->prev)[result];
+        redo = cur < ctx->op_index;
+
+        if (!redo) {
+            ctx->written[cur] |= ctx->written[ctx->op_index] | op->written;
         }
-    }
+
+        ctx->op_index = cur;
+        op = &ops[ctx->op_index];
+
+        if (cur <= first) {
+#ifdef FLECS_QUERY_TRACE
+            printf("%*sfalse\n", flecs_query_trace_indent*2, "");
+            flecs_query_trace_indent --;
+#endif
+            return false;
+        }
+    } while (op < last_op);
+    
+#ifdef FLECS_QUERY_TRACE
+        printf("%*strue\n", flecs_query_trace_indent*2, "");
+        flecs_query_trace_indent --;
+#endif
+
+    return true;
 }
 
-void ecs_strbuf_list_pop(
-    ecs_strbuf_t *b,
-    const char *list_close)
+static
+void flecs_query_iter_init(
+    ecs_query_run_ctx_t *ctx)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(list_close != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(b->list_sp > 0, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(ctx->written != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_iter_t *it = ctx->it;
 
-    b->list_sp --;
-    
-    if (list_close) {
-        char ch = list_close[0];
-        if (ch && !list_close[1]) {
-            ecs_strbuf_appendch(b, list_close[0]);
-        } else {
-            ecs_strbuf_appendstr(b, list_close);
+    const ecs_query_impl_t *query = ctx->query;
+    const ecs_query_t *q = &query->pub;
+    ecs_flags64_t it_written = it->constrained_vars;
+    ctx->written[0] = it_written;
+    if (it_written && ctx->query->src_vars) {
+        /* If variables were constrained, check if there are any table
+         * variables that have a constrained entity variable. */
+        ecs_var_t *vars = ctx->vars;
+        int32_t i, count = q->field_count;
+        for (i = 0; i < count; i ++) {
+            ecs_var_id_t var_id = query->src_vars[i];
+            ecs_query_var_t *var = &query->vars[var_id];
+
+            if (!(it_written & (1ull << var_id)) || 
+                (var->kind == EcsVarTable) || (var->table_id == EcsVarNone)) 
+            {
+                continue;
+            }
+
+            /* Initialize table variable with constrained entity variable */
+            ecs_var_t *tvar = &vars[var->table_id];
+            tvar->range = flecs_range_from_entity(vars[var_id].entity, ctx);
+            ctx->written[0] |= (1ull << var->table_id); /* Mark as written */
+        }
+    }
+
+    ecs_flags32_t flags = q->flags;
+    ecs_query_cache_t *cache = query->cache;
+    if (flags & EcsQueryIsTrivial && !cache) {
+        if ((flags & EcsQueryMatchOnlySelf) || 
+            !flecs_table_cache_all_count(&ctx->world->idr_isa_wildcard->cache)) 
+        {
+            if (it_written) {
+                flecs_query_set_iter_this(it, ctx);
+
+                if (flags & EcsQueryMatchWildcards) {
+                    it->flags |= EcsIterTrivialTestWildcard;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                } else {
+                    it->flags |= EcsIterTrivialTest;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                }
+            } else {
+                if (flags & EcsQueryMatchWildcards) {
+                    it->flags |= EcsIterTrivialSearchWildcard;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                } else if (flags & EcsQueryNoData) {
+                    it->flags |= EcsIterTrivialSearchNoData;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                } else {
+                    it->flags |= EcsIterTrivialSearch;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                }
+            }
         }
     }
+
+    if (cache) {
+        cache->prev_match_count = cache->match_count;
+    }
+
+    flecs_iter_validate(it);
 }
 
-void ecs_strbuf_list_next(
-    ecs_strbuf_t *b)
+bool ecs_query_next_instanced(
+    ecs_iter_t *it)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
 
-    int32_t list_sp = b->list_sp;
-    if (b->list_stack[list_sp].count != 0) {
-        const char *sep = b->list_stack[list_sp].separator;
-        if (sep && !sep[1]) {
-            ecs_strbuf_appendch(b, sep[0]);
-        } else {
-            ecs_strbuf_appendstr(b, sep);
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_impl_t *impl = ECS_CONST_CAST(ecs_query_impl_t*, qit->query);
+    ecs_query_run_ctx_t ctx;
+    ctx.world = it->real_world;
+    ctx.query = impl;
+    ctx.it = it;
+    ctx.vars = qit->vars;
+    ctx.query_vars = qit->query_vars;
+    ctx.written = qit->written;
+    ctx.op_ctx = qit->op_ctx;
+    ctx.qit = qit;
+    const ecs_query_op_t *ops = qit->ops;
+
+    bool redo = true;
+    if (!(it->flags & EcsIterIsValid)) {
+        ecs_assert(impl != NULL, ECS_INVALID_PARAMETER, NULL);
+        flecs_query_iter_init(&ctx);
+        redo = false;
+    } else {
+        it->frame_offset += it->count;
+
+        if (!(it->flags & EcsIterSkip)) {
+            flecs_query_mark_fields_dirty(impl, it);
+            if (qit->prev) {
+                if (ctx.query->pub.flags & EcsQueryHasMonitor) {
+                    flecs_query_sync_match_monitor(impl, qit->prev);
+                }
+            }
         }
+
+        it->flags &= ~EcsIterSkip;
     }
-    b->list_stack[list_sp].count ++;
+
+    /* Specialized iterator modes for trivial queries */
+    if (it->flags & EcsIterTrivialSearch) {
+        ecs_query_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_search(ctx.query, &ctx, op_ctx, !redo, mask)) {
+            goto done;
+        }
+        it->table = ctx.vars[0].range.table;
+        it->count = ecs_table_count(it->table);
+        it->entities = flecs_table_entities_array(it->table);
+        return true;
+    } else if (it->flags & EcsIterTrivialSearchNoData) {
+        ecs_query_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_search_nodata(ctx.query, &ctx, op_ctx, !redo, mask)) {
+            goto done;
+        }
+        it->table = ctx.vars[0].range.table;
+        it->count = ecs_table_count(it->table);
+        it->entities = flecs_table_entities_array(it->table);
+        return true;
+    } else if (it->flags & EcsIterTrivialSearchWildcard) {
+        ecs_query_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_search_w_wildcards(ctx.query, &ctx, op_ctx, !redo, mask)) {
+            goto done;
+        }
+        it->table = ctx.vars[0].range.table;
+        it->count = ecs_table_count(it->table);
+        it->entities = flecs_table_entities_array(it->table);
+        return true;
+    } else if (it->flags & EcsIterTrivialTest) {
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_test(ctx.query, &ctx, !redo, mask)) {
+            goto done;
+        }
+        return true;
+    } else if (it->flags & EcsIterTrivialTestWildcard) {
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_test_w_wildcards(ctx.query, &ctx, !redo, mask)) {
+            goto done;
+        }
+        return true;
+    }
+
+    /* Default iterator mode */
+    if (flecs_query_run_until(redo, &ctx, ops, -1, qit->op, impl->op_count - 1)) {
+        ecs_assert(ops[ctx.op_index].kind == EcsQueryYield, 
+            ECS_INTERNAL_ERROR, NULL);
+        flecs_query_set_iter_this(it, &ctx);
+        ecs_assert(it->count >= 0, ECS_INTERNAL_ERROR, NULL);
+        qit->op = flecs_itolbl(ctx.op_index - 1);
+        return true;
+    }
+
+done:
+    flecs_query_mark_fixed_fields_dirty(impl, it);
+    if (ctx.query->monitor) {
+        flecs_query_update_fixed_monitor(
+            ECS_CONST_CAST(ecs_query_impl_t*, ctx.query));
+    }
+
+    ecs_iter_fini(it);
+    return false;
 }
 
-void ecs_strbuf_list_appendch(
-    ecs_strbuf_t *b,
-    char ch)
+bool ecs_query_next(
+    ecs_iter_t *it)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_strbuf_list_next(b);
-    flecs_strbuf_appendch(b, ch);
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+
+    if (flecs_iter_next_row(it)) {
+        return true;
+    }
+
+    return flecs_iter_next_instanced(it, ecs_query_next_instanced(it));
+error:
+    return false;
 }
 
-void ecs_strbuf_list_append(
-    ecs_strbuf_t *b,
-    const char *fmt,
-    ...)
+static
+void flecs_query_iter_fini_ctx(
+    ecs_iter_t *it,
+    ecs_query_iter_t *qit)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_strbuf_list_next(b);
+    const ecs_query_impl_t *query = flecs_query_impl(qit->query);
+    int32_t i, count = query->op_count;
+    ecs_query_op_t *ops = query->ops;
+    ecs_query_op_ctx_t *ctx = qit->op_ctx;
+    ecs_allocator_t *a = flecs_query_get_allocator(it);
 
-    va_list args;
-    va_start(args, fmt);
-    flecs_strbuf_vappend(b, fmt, args);
-    va_end(args);
+    for (i = 0; i < count; i ++) {
+        ecs_query_op_t *op = &ops[i];
+        switch(op->kind) {
+        case EcsQueryTrav:
+            flecs_query_trav_cache_fini(a, &ctx[i].is.trav.cache);
+            break;
+        case EcsQueryUp:
+        case EcsQuerySelfUp:
+        case EcsQueryUpId:
+        case EcsQuerySelfUpId: {
+            ecs_trav_up_cache_t *cache = &ctx[i].is.up.cache;
+            if (cache->dir == EcsTravDown) {
+                flecs_query_down_cache_fini(a, cache);
+            } else {
+                flecs_query_up_cache_fini(cache);
+            }
+            break;
+        }
+        default:
+            break;
+        }
+    }
 }
 
-void ecs_strbuf_list_appendstr(
-    ecs_strbuf_t *b,
-    const char *str)
+static
+void flecs_query_iter_fini(
+    ecs_iter_t *it)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_assert(qit->query != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(qit->query, ecs_query_t);
+    int32_t op_count = flecs_query_impl(qit->query)->op_count;
+    int32_t var_count = flecs_query_impl(qit->query)->var_count;
 
-    ecs_strbuf_list_next(b);
-    ecs_strbuf_appendstr(b, str);
+#ifdef FLECS_DEBUG
+    if (it->flags & EcsIterProfile) {
+        char *str = ecs_query_str_w_profile(qit->query, it);
+        printf("%s\n", str);
+        ecs_os_free(str);
+    }
+
+    flecs_iter_free_n(qit->profile, ecs_query_op_profile_t, op_count);
+#endif
+
+    flecs_query_iter_fini_ctx(it, qit);
+    flecs_iter_free_n(qit->vars, ecs_var_t, var_count);
+    flecs_iter_free_n(qit->written, ecs_write_flags_t, op_count);
+    flecs_iter_free_n(qit->op_ctx, ecs_query_op_ctx_t, op_count);
+    qit->vars = NULL;
+    qit->written = NULL;
+    qit->op_ctx = NULL;
+    qit->query = NULL;
 }
 
-void ecs_strbuf_list_appendstrn(
-    ecs_strbuf_t *b,
-    const char *str,
-    int32_t n)
+ecs_iter_t flecs_query_iter(
+    const ecs_world_t *world,
+    const ecs_query_t *q)
 {
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_iter_t it = {0};
+    ecs_query_iter_t *qit = &it.priv_.iter.query;
+    ecs_check(q != NULL, ECS_INVALID_PARAMETER, NULL);
+    
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+
+    int32_t i, var_count = impl->var_count, op_count = impl->op_count;
+    it.world = ECS_CONST_CAST(ecs_world_t*, world);
+    it.real_world = q->world;
+    it.query = q;
+    it.system = q->entity;
+    it.next = ecs_query_next;
+    it.fini = flecs_query_iter_fini;
+    it.field_count = q->field_count;
+    it.sizes = q->sizes;
+    it.set_fields = q->set_fields;
+    it.up_fields = 0;
+    flecs_query_apply_iter_flags(&it, q);
 
-    ecs_strbuf_list_next(b);
-    ecs_strbuf_appendstrn(b, str, n);
-}
+    flecs_iter_init(world, &it, 
+        flecs_iter_cache_ids |
+        flecs_iter_cache_columns |
+        flecs_iter_cache_sources |
+        flecs_iter_cache_ptrs);
 
-int32_t ecs_strbuf_written(
-    const ecs_strbuf_t *b)
-{
-    ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
-    return b->length;
-}
+    qit->query = q;
+    qit->query_vars = impl->vars;
+    qit->ops = impl->ops;
 
-/**
- * @file datastructures/switch_list.c
- * @brief Interleaved linked list for storing mutually exclusive values.
- * 
- * Data structure that stores N interleaved linked lists in an array.
- * This allows for efficient storage of elements with mutually exclusive values.
- * Each linked list has a header element which points to the index in the array
- * that stores the first node of the list. Each list node points to the next
- * array element.
- *
- * The data structure allows for efficient storage and retrieval for values with
- * mutually exclusive values, such as enumeration values. The linked list allows
- * an application to obtain all elements for a given (enumeration) value without
- * having to search.
- *
- * While the list accepts 64 bit values, it only uses the lower 32bits of the
- * value for selecting the correct linked list.
- * 
- * The switch list is used to store union relationships.
- */
+    ecs_query_cache_t *cache = impl->cache;
+    if (cache) {
+        qit->node = cache->list.first;
+        qit->last = cache->list.last;
 
+        if (cache->order_by_callback && cache->list.info.table_count) {
+            flecs_query_cache_sort_tables(it.real_world, impl);
+            qit->node = ecs_vec_first(&cache->table_slices);
+            qit->last = ecs_vec_last_t(
+                &cache->table_slices, ecs_query_cache_table_match_t);
+        }
+    }
 
-#ifdef FLECS_SANITIZE
-static 
-void flecs_switch_verify_nodes(
-    ecs_switch_header_t *hdr,
-    ecs_switch_node_t *nodes)
-{
-    if (!hdr) {
-        return;
+    if (var_count) {
+        qit->vars = flecs_iter_calloc_n(&it, ecs_var_t, var_count);
     }
 
-    int32_t prev = -1, elem = hdr->element, count = 0;
-    while (elem != -1) {
-        ecs_assert(prev == nodes[elem].prev, ECS_INTERNAL_ERROR, NULL);
-        prev = elem;
-        elem = nodes[elem].next;
-        count ++;
+    if (op_count) {
+        qit->written = flecs_iter_calloc_n(&it, ecs_write_flags_t, op_count);
+        qit->op_ctx = flecs_iter_calloc_n(&it, ecs_query_op_ctx_t, op_count);
     }
 
-    ecs_assert(count == hdr->count, ECS_INTERNAL_ERROR, NULL);
-}
-#else
-#define flecs_switch_verify_nodes(hdr, nodes)
+#ifdef FLECS_DEBUG
+    qit->profile = flecs_iter_calloc_n(&it, ecs_query_op_profile_t, op_count);
 #endif
 
-static
-ecs_switch_header_t* flecs_switch_get_header(
-    const ecs_switch_t *sw,
-    uint64_t value)
-{
-    if (value == 0) {
-        return NULL;
+    for (i = 1; i < var_count; i ++) {
+        qit->vars[i].entity = EcsWildcard;
     }
-    return (ecs_switch_header_t*)ecs_map_get(&sw->hdrs, value);
+
+    it.variables = qit->vars;
+    it.variable_count = impl->var_pub_count;
+    it.variable_names = impl->var_names;
+
+error:
+    return it;
 }
 
-static
-ecs_switch_header_t *flecs_switch_ensure_header(
-    ecs_switch_t *sw,
-    uint64_t value)
+ecs_iter_t ecs_query_iter(
+    const ecs_world_t *world,
+    const ecs_query_t *q)
 {
-    ecs_switch_header_t *node = flecs_switch_get_header(sw, value);
-    if (!node && (value != 0)) {
-        node = (ecs_switch_header_t*)ecs_map_ensure(&sw->hdrs, value);
-        node->count = 0;
-        node->element = -1;
+    ecs_run_aperiodic(q->world, EcsAperiodicEmptyTables);
+
+    /* Ok, only for stats */
+    ECS_CONST_CAST(ecs_query_t*, q)->eval_count ++;
+
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    ecs_query_cache_t *cache = impl->cache;
+    if (cache) {
+        /* If monitors changed, do query rematching */
+        ecs_flags32_t flags = q->flags;
+        if (!(world->flags & EcsWorldReadonly) && flags & EcsQueryHasRefs) {
+            flecs_eval_component_monitors(q->world);
+        }
     }
 
-    return node;
+    return flecs_query_iter(world, q);
 }
 
+/**
+ * @file addons/rules/trav_cache.c
+ * @brief Cache that stores the result of graph traversal.
+ */
+
+
 static
-void flecs_switch_remove_node(
-    ecs_switch_header_t *hdr,
-    ecs_switch_node_t *nodes,
-    ecs_switch_node_t *node,
-    int32_t element)
+void flecs_query_build_down_cache(
+    ecs_world_t *world,
+    ecs_allocator_t *a,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_entity_t entity)
 {
-    ecs_assert(&nodes[element] == node, ECS_INTERNAL_ERROR, NULL);
-
-    /* Update previous node/header */
-    if (hdr->element == element) {
-        ecs_assert(node->prev == -1, ECS_INVALID_PARAMETER, NULL);
-        /* If this is the first node, update the header */
-        hdr->element = node->next;
-    } else {
-        /* If this is not the first node, update the previous node to the 
-         * removed node's next ptr */
-        ecs_assert(node->prev != -1, ECS_INVALID_PARAMETER, NULL);
-        ecs_switch_node_t *prev_node = &nodes[node->prev];
-        prev_node->next = node->next;
+    ecs_id_record_t *idr = flecs_id_record_get(world, ecs_pair(trav, entity));
+    if (!idr) {
+        return;
     }
 
-    /* Update next node */
-    int32_t next = node->next;
-    if (next != -1) {
-        ecs_assert(next >= 0, ECS_INVALID_PARAMETER, NULL);
-        /* If this is not the last node, update the next node to point to the
-         * removed node's prev ptr */
-        ecs_switch_node_t *next_node = &nodes[next];
-        next_node->prev = node->prev;
-    }
+    ecs_trav_elem_t *elem = ecs_vec_append_t(a, &cache->entities, 
+        ecs_trav_elem_t);
+    elem->entity = entity;
+    elem->idr = idr;
+
+    ecs_table_cache_iter_t it;
+    if (flecs_table_cache_iter(&idr->cache, &it)) {
+        ecs_table_record_t *tr; 
+        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+            ecs_assert(tr->count == 1, ECS_INTERNAL_ERROR, NULL);
+            ecs_table_t *table = tr->hdr.table;
+            if (!table->_->traversable_count) {
+                continue;
+            }
 
-    /* Decrease count of current header */
-    hdr->count --;
-    ecs_assert(hdr->count >= 0, ECS_INTERNAL_ERROR, NULL);
+            int32_t i, count = ecs_table_count(table);
+            ecs_entity_t *entities = table->data.entities.array;
+            for (i = 0; i < count; i ++) {
+                ecs_record_t *r = flecs_entities_get(world, entities[i]);
+                if (r->row & EcsEntityIsTraversable) {
+                    flecs_query_build_down_cache(
+                        world, a, ctx, cache, trav, entities[i]);
+                }
+            }
+        }
+    }
 }
 
-void flecs_switch_init(
-    ecs_switch_t *sw,
-    ecs_allocator_t *allocator,
-    int32_t elements)
+static
+void flecs_query_build_up_cache(
+    ecs_world_t *world,
+    ecs_allocator_t *a,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_table_t *table,
+    const ecs_table_record_t *tr,
+    int32_t root_column)
 {
-    ecs_map_init(&sw->hdrs, allocator);
-    ecs_vec_init_t(allocator, &sw->nodes, ecs_switch_node_t, elements);
-    ecs_vec_init_t(allocator, &sw->values, uint64_t, elements);
+    ecs_id_t *ids = table->type.array;
+    int32_t i = tr->index, end = i + tr->count;
+    bool is_root = root_column == -1;
 
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
-    uint64_t *values = ecs_vec_first(&sw->values);
+    for (; i < end; i ++) {
+        ecs_entity_t second = ecs_pair_second(world, ids[i]);
+        if (is_root) {
+            root_column = i;
+        }
 
-    int i;
-    for (i = 0; i < elements; i ++) {
-        nodes[i].prev = -1;
-        nodes[i].next = -1;
-        values[i] = 0;
+        ecs_trav_elem_t *el = ecs_vec_append_t(a, &cache->entities, 
+            ecs_trav_elem_t);
+        el->entity = second;
+        el->column = root_column;
+        el->idr = NULL;
+
+        ecs_record_t *r = flecs_entities_get_any(world, second);
+        if (r->table) {
+            ecs_table_record_t *r_tr = flecs_id_record_get_table(
+                cache->idr, r->table);
+            if (!r_tr) {
+                return;
+            }
+            flecs_query_build_up_cache(world, a, ctx, cache, trav, r->table, 
+                r_tr, root_column);
+        }
     }
 }
 
-void flecs_switch_clear(
-    ecs_switch_t *sw)
+void flecs_query_trav_cache_fini(
+    ecs_allocator_t *a,
+    ecs_trav_cache_t *cache)
 {
-    ecs_map_clear(&sw->hdrs);
-    ecs_vec_fini_t(sw->hdrs.allocator, &sw->nodes, ecs_switch_node_t);
-    ecs_vec_fini_t(sw->hdrs.allocator, &sw->values, uint64_t);
+    ecs_vec_fini_t(a, &cache->entities, ecs_trav_elem_t);
 }
 
-void flecs_switch_fini(
-    ecs_switch_t *sw)
+void flecs_query_get_trav_down_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_entity_t entity)
 {
-    ecs_map_fini(&sw->hdrs);
-    ecs_vec_fini_t(sw->hdrs.allocator, &sw->nodes, ecs_switch_node_t);
-    ecs_vec_fini_t(sw->hdrs.allocator, &sw->values, uint64_t);
+    if (cache->id != ecs_pair(trav, entity) || cache->up) {
+        ecs_world_t *world = ctx->it->real_world;
+        ecs_allocator_t *a = flecs_query_get_allocator(ctx->it);
+        ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
+        flecs_query_build_down_cache(world, a, ctx, cache, trav, entity);
+        cache->id = ecs_pair(trav, entity);
+        cache->up = false;
+    }
 }
 
-void flecs_switch_add(
-    ecs_switch_t *sw)
+void flecs_query_get_trav_up_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_table_t *table)
 {
-    ecs_switch_node_t *node = ecs_vec_append_t(sw->hdrs.allocator, 
-        &sw->nodes, ecs_switch_node_t);
-    uint64_t *value = ecs_vec_append_t(sw->hdrs.allocator, 
-        &sw->values, uint64_t);
-    node->prev = -1;
-    node->next = -1;
-    *value = 0;
-}
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_world_t *world = ctx->it->real_world;
+    ecs_allocator_t *a = flecs_query_get_allocator(ctx->it);
 
-void flecs_switch_set_count(
-    ecs_switch_t *sw,
-    int32_t count)
-{
-    int32_t old_count = ecs_vec_count(&sw->nodes);
-    if (old_count == count) {
-        return;
+    ecs_id_record_t *idr = cache->idr;
+    if (!idr || idr->id != ecs_pair(trav, EcsWildcard)) {
+        idr = cache->idr = flecs_id_record_get(world, 
+            ecs_pair(trav, EcsWildcard));
+        if (!idr) {
+            ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
+            return;
+        }
     }
 
-    ecs_vec_set_count_t(sw->hdrs.allocator, &sw->nodes, ecs_switch_node_t, count);
-    ecs_vec_set_count_t(sw->hdrs.allocator, &sw->values, uint64_t, count);
+    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+    if (!tr) {
+        ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
+        return;
+    }
 
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
-    uint64_t *values = ecs_vec_first(&sw->values);
+    ecs_id_t id = table->type.array[tr->index];
 
-    int32_t i;
-    for (i = old_count; i < count; i ++) {
-        ecs_switch_node_t *node = &nodes[i];
-        node->prev = -1;
-        node->next = -1;
-        values[i] = 0;
+    if (cache->id != id || !cache->up) {
+        ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
+        flecs_query_build_up_cache(world, a, ctx, cache, trav, table, tr, -1);
+        cache->id = id;
+        cache->up = true;
     }
 }
 
-int32_t flecs_switch_count(
-    ecs_switch_t *sw)
-{
-    ecs_assert(ecs_vec_count(&sw->values) == ecs_vec_count(&sw->nodes),
-        ECS_INTERNAL_ERROR, NULL);
-    return ecs_vec_count(&sw->values);
-}
 
-void flecs_switch_ensure(
-    ecs_switch_t *sw,
-    int32_t count)
+static
+void flecs_trav_entity_down_isa(
+    ecs_world_t *world,
+    ecs_allocator_t *a,
+    ecs_trav_up_cache_t *cache,
+    ecs_trav_down_t *dst,
+    ecs_entity_t trav,
+    ecs_entity_t entity,
+    ecs_id_record_t *idr_with,
+    bool self,
+    bool empty);
+
+static
+ecs_trav_down_t* flecs_trav_entity_down(
+    ecs_world_t *world,
+    ecs_allocator_t *a,
+    ecs_trav_up_cache_t *cache,
+    ecs_trav_down_t *dst,
+    ecs_entity_t trav,
+    ecs_entity_t entity,
+    ecs_id_record_t *idr_trav,
+    ecs_id_record_t *idr_with,
+    bool self,
+    bool empty);
+
+static
+ecs_trav_down_t* flecs_trav_down_ensure(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_up_cache_t *cache,
+    ecs_entity_t entity)
 {
-    int32_t old_count = ecs_vec_count(&sw->nodes);
-    if (old_count >= count) {
-        return;
+    ecs_trav_down_t **trav = ecs_map_ensure_ref(
+        &cache->src, ecs_trav_down_t, entity);
+    if (!trav[0]) {
+        trav[0] = flecs_iter_calloc_t(ctx->it, ecs_trav_down_t);
+        ecs_vec_init_t(NULL, &trav[0]->elems, ecs_trav_down_elem_t, 0);
     }
 
-    flecs_switch_set_count(sw, count);
+    return trav[0];
 }
 
-void flecs_switch_addn(
-    ecs_switch_t *sw,
-    int32_t count)
+static
+ecs_trav_down_t* flecs_trav_table_down(
+    ecs_world_t *world,
+    ecs_allocator_t *a,
+    ecs_trav_up_cache_t *cache,
+    ecs_trav_down_t *dst,
+    ecs_entity_t trav,
+    const ecs_table_t *table,
+    ecs_id_record_t *idr_with,
+    bool self,
+    bool empty)
 {
-    int32_t old_count = ecs_vec_count(&sw->nodes);
-    flecs_switch_set_count(sw, old_count + count);
-}
+    ecs_assert(table->id != 0, ECS_INTERNAL_ERROR, NULL);
 
-void flecs_switch_set(
-    ecs_switch_t *sw,
-    int32_t element,
-    uint64_t value)
-{
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->nodes), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->values), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element >= 0, ECS_INVALID_PARAMETER, NULL);
+    if (!table->_->traversable_count) {
+        return dst;
+    }
 
-    uint64_t *values = ecs_vec_first(&sw->values);
-    uint64_t cur_value = values[element];
+    ecs_assert(idr_with != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    /* If the node is already assigned to the value, nothing to be done */
-    if (cur_value == value) {
-        return;
-    }
+    ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
+    int32_t i, count = ecs_table_count(table);
+    for (i = 0; i < count; i ++) {
+        ecs_entity_t entity = entities[i];
+        ecs_record_t *record = flecs_entities_get(world, entity);
+        if (!record) {
+            continue;
+        }
 
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
-    ecs_switch_node_t *node = &nodes[element];
+        uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
+        if (flags & EcsEntityIsTraversable) {
+            ecs_id_record_t *idr_trav = flecs_id_record_get(world, 
+                ecs_pair(trav, entity));
+            if (!idr_trav) {
+                continue;
+            }
 
-    ecs_switch_header_t *dst_hdr = flecs_switch_ensure_header(sw, value);
-    ecs_switch_header_t *cur_hdr = flecs_switch_get_header(sw, cur_value);
+            flecs_trav_entity_down(world, a, cache, dst, 
+                trav, entity, idr_trav, idr_with, self, empty);
+        }
+    }
 
-    flecs_switch_verify_nodes(cur_hdr, nodes);
-    flecs_switch_verify_nodes(dst_hdr, nodes);
+    return dst;
+}
 
-    /* If value is not 0, and dst_hdr is NULL, then this is not a valid value
-     * for this switch */
-    ecs_assert(dst_hdr != NULL || !value, ECS_INVALID_PARAMETER, NULL);
+static
+void flecs_trav_entity_down_isa(
+    ecs_world_t *world,
+    ecs_allocator_t *a,
+    ecs_trav_up_cache_t *cache,
+    ecs_trav_down_t *dst,
+    ecs_entity_t trav,
+    ecs_entity_t entity,
+    ecs_id_record_t *idr_with,
+    bool self,
+    bool empty)
+{
+    if (trav == EcsIsA || !world->idr_isa_wildcard) {
+        return;
+    }
 
-    if (cur_hdr) {
-        flecs_switch_remove_node(cur_hdr, nodes, node, element);
+    ecs_id_record_t *idr_isa = flecs_id_record_get(
+        world, ecs_pair(EcsIsA, entity));
+    if (!idr_isa) {
+        return;
     }
 
-    /* Now update the node itself by adding it as the first node of dst */
-    node->prev = -1;
-    values[element] = value;
+    ecs_table_cache_iter_t it;
+    if (flecs_table_cache_iter(&idr_isa->cache, &it)) {
+        ecs_table_record_t *tr;
+        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+            ecs_table_t *table = tr->hdr.table;
+            if (!table->_->traversable_count) {
+                continue;
+            }
 
-    if (dst_hdr) {
-        node->next = dst_hdr->element;
+            ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
+            int32_t i, count = ecs_table_count(table);
+            for (i = 0; i < count; i ++) {
+                ecs_entity_t e = entities[i];
+                ecs_record_t *record = flecs_entities_get(world, e);
+                if (!record) {
+                    continue;
+                }
 
-        /* Also update the dst header */
-        int32_t first = dst_hdr->element;
-        if (first != -1) {
-            ecs_assert(first >= 0, ECS_INTERNAL_ERROR, NULL);
-            ecs_switch_node_t *first_node = &nodes[first];
-            first_node->prev = element;
+                uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
+                if (flags & EcsEntityIsTraversable) {
+                    ecs_id_record_t *idr_trav = flecs_id_record_get(world, 
+                        ecs_pair(trav, e));
+                    flecs_trav_entity_down(world, a, cache, dst, trav, e,
+                        idr_trav, idr_with, self, empty);
+                }
+            }
         }
-
-        dst_hdr->element = element;
-        dst_hdr->count ++;        
     }
 }
 
-void flecs_switch_remove(
-    ecs_switch_t *sw,
-    int32_t elem)
+static
+ecs_trav_down_t* flecs_trav_entity_down(
+    ecs_world_t *world,
+    ecs_allocator_t *a,
+    ecs_trav_up_cache_t *cache,
+    ecs_trav_down_t *dst,
+    ecs_entity_t trav,
+    ecs_entity_t entity,
+    ecs_id_record_t *idr_trav,
+    ecs_id_record_t *idr_with,
+    bool self,
+    bool empty)
 {
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(elem < ecs_vec_count(&sw->nodes), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(elem >= 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(dst != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(idr_with != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    uint64_t *values = ecs_vec_first(&sw->values);
-    uint64_t value = values[elem];
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
-    ecs_switch_node_t *node = &nodes[elem];
+    flecs_trav_entity_down_isa(
+        world, a, cache, dst, trav, entity, idr_with, self, empty);
 
-    /* If node is currently assigned to a case, remove it from the list */
-    if (value != 0) {
-        ecs_switch_header_t *hdr = flecs_switch_get_header(sw, value);
-        ecs_assert(hdr != NULL, ECS_INTERNAL_ERROR, NULL);
+    int32_t first = ecs_vec_count(&dst->elems);
 
-        flecs_switch_verify_nodes(hdr, nodes);
-        flecs_switch_remove_node(hdr, nodes, node, elem);
+    ecs_table_cache_iter_t it;
+    bool result;
+    if (empty) {
+        result = flecs_table_cache_all_iter(&idr_trav->cache, &it);
+    } else {
+        result = flecs_table_cache_iter(&idr_trav->cache, &it);
     }
+    if (result) {
+        ecs_table_record_t *tr; 
+        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+            ecs_assert(tr->count == 1, ECS_INTERNAL_ERROR, NULL);
+            ecs_table_t *table = tr->hdr.table;
+            bool leaf = false;
 
-    int32_t last_elem = ecs_vec_count(&sw->nodes) - 1;
-    if (last_elem != elem) {
-        ecs_switch_node_t *last = ecs_vec_last_t(&sw->nodes, ecs_switch_node_t);
-        int32_t next = last->next, prev = last->prev;
-        if (next != -1) {
-            ecs_switch_node_t *n = &nodes[next];
-            n->prev = elem;
-        }
+            if (flecs_id_record_get_table(idr_with, table) != NULL) {
+                if (self) {
+                    continue;
+                }
+                leaf = true;
+            }
 
-        if (prev != -1) {
-            ecs_switch_node_t *n = &nodes[prev];
-            n->next = elem;
-        } else {
-            ecs_switch_header_t *hdr = flecs_switch_get_header(sw, values[last_elem]);
-            if (hdr && hdr->element != -1) {
-                ecs_assert(hdr->element == last_elem, 
-                    ECS_INTERNAL_ERROR, NULL);
-                hdr->element = elem;
+            /* If record is not the first instance of (trav, *), don't add it
+             * to the cache. */
+            int32_t index = tr->index;
+            if (index) {
+                ecs_id_t id = table->type.array[index - 1];
+                if (ECS_IS_PAIR(id) && ECS_PAIR_FIRST(id) == trav) {
+                    int32_t col = ecs_search_relation(world, table, 0, 
+                        idr_with->id, trav, EcsUp, NULL, NULL, &tr);
+                    ecs_assert(col >= 0, ECS_INTERNAL_ERROR, NULL);
+
+                    if (col != index) {
+                        /* First relationship through which the id is 
+                         * reachable is not the current one, so skip. */
+                        continue;
+                    }
+                }
             }
+
+            ecs_trav_down_elem_t *elem = ecs_vec_append_t(
+                a, &dst->elems, ecs_trav_down_elem_t);
+            elem->table = table;
+            elem->leaf = leaf;
+        }
+    }
+
+    /* Breadth first walk */
+    int32_t t, last = ecs_vec_count(&dst->elems);
+    for (t = first; t < last; t ++) {
+        ecs_trav_down_elem_t *elem = ecs_vec_get_t(
+            &dst->elems, ecs_trav_down_elem_t, t);
+        if (!elem->leaf) {
+            flecs_trav_table_down(world, a, cache, dst, trav,
+                elem->table, idr_with, self, empty);
         }
     }
 
-    /* Remove element from arrays */
-    ecs_vec_remove_t(&sw->nodes, ecs_switch_node_t, elem);
-    ecs_vec_remove_t(&sw->values, uint64_t, elem);
+    return dst;
 }
 
-uint64_t flecs_switch_get(
-    const ecs_switch_t *sw,
-    int32_t element)
+ecs_trav_down_t* flecs_query_get_down_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_up_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_entity_t e,
+    ecs_id_record_t *idr_with,
+    bool self,
+    bool empty)
 {
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->nodes), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->values), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element >= 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_world_t *world = ctx->it->real_world;
+    ecs_assert(cache->dir != EcsTravUp, ECS_INTERNAL_ERROR, NULL);
+    cache->dir = EcsTravDown;
+
+    ecs_allocator_t *a = flecs_query_get_allocator(ctx->it);
+    ecs_map_init_if(&cache->src, a);
+
+    ecs_trav_down_t *result = flecs_trav_down_ensure(ctx, cache, e);
+    if (result->ready) {
+        return result;
+    }
 
-    uint64_t *values = ecs_vec_first(&sw->values);
-    return values[element];
+    ecs_id_record_t *idr_trav = flecs_id_record_get(world, ecs_pair(trav, e));
+    if (!idr_trav) {
+        if (trav != EcsIsA) {
+            flecs_trav_entity_down_isa(
+                world, a, cache, result, trav, e, idr_with, self, empty);
+        }
+        result->ready = true;
+        return result;
+    }
+
+    ecs_vec_init_t(a, &result->elems, ecs_trav_down_elem_t, 0);
+    flecs_trav_entity_down(
+        world, a, cache, result, trav, e, idr_trav, idr_with, self, empty);
+    result->ready = true;
+
+    return result;
 }
 
-ecs_vec_t* flecs_switch_values(
-    const ecs_switch_t *sw)
+void flecs_query_down_cache_fini(
+    ecs_allocator_t *a,
+    ecs_trav_up_cache_t *cache)
 {
-    return ECS_CONST_CAST(ecs_vec_t*, &sw->values);
+    ecs_map_iter_t it = ecs_map_iter(&cache->src);
+    while (ecs_map_next(&it)) {
+        ecs_trav_down_t *t = ecs_map_ptr(&it);
+        ecs_vec_fini_t(a, &t->elems, ecs_trav_down_elem_t);
+    }
+    ecs_map_fini(&cache->src);
 }
 
-int32_t flecs_switch_case_count(
-    const ecs_switch_t *sw,
-    uint64_t value)
+
+static
+ecs_trav_up_t* flecs_trav_up_ensure(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_up_cache_t *cache,
+    uint64_t table_id)
 {
-    ecs_switch_header_t *hdr = flecs_switch_get_header(sw, value);
-    if (!hdr) {
-        return 0;
+    ecs_trav_up_t **trav = ecs_map_ensure_ref(
+        &cache->src, ecs_trav_up_t, table_id);
+    if (!trav[0]) {
+        trav[0] = flecs_iter_calloc_t(ctx->it, ecs_trav_up_t);
     }
 
-    return hdr->count;
+    return trav[0];
 }
 
-void flecs_switch_swap(
-    ecs_switch_t *sw,
-    int32_t elem_1,
-    int32_t elem_2)
-{
-    uint64_t v1 = flecs_switch_get(sw, elem_1);
-    uint64_t v2 = flecs_switch_get(sw, elem_2);
+static
+int32_t flecs_trav_type_search(
+    ecs_trav_up_t *up,
+    const ecs_table_t *table,
+    ecs_id_record_t *idr_with,
+    ecs_type_t *type)
+{    
+    ecs_table_record_t *tr = ecs_table_cache_get(&idr_with->cache, table);
+    if (tr) {
+        up->id = type->array[tr->index];
+        return up->column = tr->index;
+    }
 
-    flecs_switch_set(sw, elem_2, v1);
-    flecs_switch_set(sw, elem_1, v2);
+    return -1;
 }
 
-int32_t flecs_switch_first(
-    const ecs_switch_t *sw,
-    uint64_t value)
+static
+int32_t flecs_trav_type_offset_search(
+    ecs_trav_up_t *up,
+    int32_t offset,
+    ecs_id_t with,
+    ecs_type_t *type)
 {
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    
-    ecs_switch_header_t *hdr = flecs_switch_get_header(sw, value);
-    if (!hdr) {
-        return -1;
+    ecs_assert(offset > 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(with != 0, ECS_INVALID_PARAMETER, NULL);
+
+    while (offset < type->count) {
+        ecs_id_t type_id = type->array[offset ++];
+        if (ecs_id_match(type_id, with)) {
+            up->id = type_id;
+            return up->column = offset - 1;
+        }
     }
 
-    return hdr->element;
+    return -1;
 }
 
-int32_t flecs_switch_next(
-    const ecs_switch_t *sw,
-    int32_t element)
+static
+ecs_trav_up_t* flecs_trav_table_up(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_allocator_t *a,
+    ecs_trav_up_cache_t *cache,
+    const ecs_world_t *world,
+    ecs_entity_t src,
+    ecs_id_t with,
+    ecs_id_t rel,
+    ecs_id_record_t *idr_with,
+    ecs_id_record_t *idr_trav)
 {
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->nodes), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element >= 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_trav_up_t *up = flecs_trav_up_ensure(ctx, cache, src);
+    if (up->ready) {
+        return up;
+    }
 
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
+    ecs_record_t *src_record = flecs_entities_get_any(world, src);
+    ecs_table_t *table = src_record->table;
+    if (!table) {
+        goto not_found;
+    }
 
-    return nodes[element].next;
-}
+    ecs_type_t type = table->type;
+    if (flecs_trav_type_search(up, table, idr_with, &type) >= 0) {
+        up->src = src;
+        goto found;
+    }
 
-/**
- * @file datastructures/vec.c
- * @brief Vector with allocator support.
- */
+    ecs_flags32_t flags = table->flags;
+    if ((flags & EcsTableHasPairs) && rel) {
+        bool is_a = idr_trav == world->idr_isa_wildcard;
+        if (is_a) {
+            if (!(flags & EcsTableHasIsA)) {
+                goto not_found;
+            }
+
+            if (!flecs_type_can_inherit_id(world, table, idr_with, with)) {
+                goto not_found;
+            }
+        }
+
+        ecs_trav_up_t up_pair = {0};
+        int32_t r_column = flecs_trav_type_search(
+                &up_pair, table, idr_trav, &type);
+
+        while (r_column != -1) {
+            ecs_entity_t tgt = ECS_PAIR_SECOND(up_pair.id);
+            ecs_assert(tgt != 0, ECS_INTERNAL_ERROR, NULL);
+
+            ecs_trav_up_t *up_parent = flecs_trav_table_up(ctx, a, cache,
+                world, tgt, with, rel, idr_with, idr_trav);
+            if (up_parent->column != -1) {
+                up->src = up_parent->src;
+                up->column = up_parent->column;
+                up->id = up_parent->id;
+                goto found;
+            }
+
+            r_column = flecs_trav_type_offset_search(
+                &up_pair, r_column + 1, rel, &type);
+        }
 
+        if (!is_a) {
+            idr_trav = world->idr_isa_wildcard;
+            r_column = flecs_trav_type_search(
+                    &up_pair, table, idr_trav, &type);
+
+            while (r_column != -1) {
+                ecs_entity_t tgt = ECS_PAIR_SECOND(up_pair.id);
+                ecs_assert(tgt != 0, ECS_INTERNAL_ERROR, NULL);
+
+                ecs_trav_up_t *up_parent = flecs_trav_table_up(ctx, a, cache,
+                    world, tgt, with, rel, idr_with, idr_trav);
+                if (up_parent->column != -1) {
+                    up->src = up_parent->src;
+                    up->column = up_parent->column;
+                    up->id = up_parent->id;
+                    goto found;
+                }
 
-ecs_vec_t* ecs_vec_init(
-    ecs_allocator_t *allocator,
-    ecs_vec_t *v,
-    ecs_size_t size,
-    int32_t elem_count)
-{
-    ecs_assert(size != 0, ECS_INVALID_PARAMETER, NULL);
-    v->array = NULL;
-    v->count = 0;
-    if (elem_count) {
-        if (allocator) {
-            v->array = flecs_alloc(allocator, size * elem_count);
-        } else {
-            v->array = ecs_os_malloc(size * elem_count);
+                r_column = flecs_trav_type_offset_search(
+                    &up_pair, r_column + 1, rel, &type);
+            }
         }
     }
-    v->size = elem_count;
-#ifdef FLECS_SANITIZE
-    v->elem_size = size;
-#endif
-    return v;
+
+not_found:
+    up->column = -1;
+found:
+    up->ready = true;
+    return up;
 }
 
-void ecs_vec_init_if(
-    ecs_vec_t *vec,
-    ecs_size_t size)
+ecs_trav_up_t* flecs_query_get_up_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_up_cache_t *cache,
+    ecs_table_t *table,
+    ecs_id_t with,
+    ecs_entity_t trav,
+    ecs_id_record_t *idr_with,
+    ecs_id_record_t *idr_trav)
 {
-    ecs_san_assert(!vec->elem_size || vec->elem_size == size, ECS_INVALID_PARAMETER, NULL);
-    (void)vec;
-    (void)size;
-#ifdef FLECS_SANITIZE
-    if (!vec->elem_size) {
-        ecs_assert(vec->count == 0, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(vec->size == 0, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(vec->array == NULL, ECS_INTERNAL_ERROR, NULL);
-        vec->elem_size = size;
+    if (cache->with && cache->with != with) {
+        flecs_query_up_cache_fini(cache);
     }
-#endif
-}
 
-void ecs_vec_fini(
-    ecs_allocator_t *allocator,
-    ecs_vec_t *v,
-    ecs_size_t size)
-{
-    if (v->array) {
-        ecs_san_assert(!size || size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-        if (allocator) {
-            flecs_free(allocator, size * v->size, v->array);
-        } else {
-            ecs_os_free(v->array);
-        }
-        v->array = NULL;
-        v->count = 0;
-        v->size = 0;
+    ecs_world_t *world = ctx->it->real_world;
+    ecs_allocator_t *a = flecs_query_get_allocator(ctx->it);
+    ecs_map_init_if(&cache->src, a);
+
+    ecs_assert(cache->dir != EcsTravDown, ECS_INTERNAL_ERROR, NULL);
+    cache->dir = EcsTravUp;
+    cache->with = with;
+
+    ecs_assert(idr_with != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(idr_trav != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_table_record_t *tr = ecs_table_cache_get(&idr_trav->cache, table);
+    if (!tr) {
+        return NULL; /* Table doesn't have the relationship */
     }
-}
 
-ecs_vec_t* ecs_vec_reset(
-    ecs_allocator_t *allocator,
-    ecs_vec_t *v,
-    ecs_size_t size)
-{
-    if (!v->size) {
-        ecs_vec_init(allocator, v, size, 0);
-    } else {
-        ecs_san_assert(size == v->elem_size, ECS_INTERNAL_ERROR, NULL);
-        ecs_vec_clear(v);
+    int32_t i = tr->index, end = i + tr->count;
+    for (; i < end; i ++) {
+        ecs_id_t id = table->type.array[i];
+        ecs_entity_t tgt = ECS_PAIR_SECOND(id);
+        ecs_trav_up_t *result = flecs_trav_table_up(ctx, a, cache, world, tgt,
+            with, ecs_pair(trav, EcsWildcard), idr_with, idr_trav);
+        ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (result->src != 0) {
+            return result;
+        }
     }
-    return v;
-}
 
-void ecs_vec_clear(
-    ecs_vec_t *vec)
-{
-    vec->count = 0;
+    return NULL;
 }
 
-ecs_vec_t ecs_vec_copy(
-    ecs_allocator_t *allocator,
-    const ecs_vec_t *v,
-    ecs_size_t size)
+void flecs_query_up_cache_fini(
+    ecs_trav_up_cache_t *cache)
 {
-    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-    void *array;
-    if (allocator) {
-        array = flecs_dup(allocator, size * v->size, v->array);
-    } else {
-        array = ecs_os_memdup(v->array, size * v->size);
-    }
-    return (ecs_vec_t) {
-        .count = v->count,
-        .size = v->size,
-        .array = array
-#ifdef FLECS_SANITIZE
-        , .elem_size = size
-#endif
-    };
+    ecs_map_fini(&cache->src);
 }
 
-ecs_vec_t ecs_vec_copy_shrink(
-    ecs_allocator_t *allocator,
-    const ecs_vec_t *v,
-    ecs_size_t size)
-{
-    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-    int32_t count = v->count;
-    void *array = NULL;
-    if (count) {
-        if (allocator) {
-            array = flecs_dup(allocator, size * count, v->array);
-        } else {
-            array = ecs_os_memdup(v->array, size * count);
-        }
-    }
-    return (ecs_vec_t) {
-        .count = count,
-        .size = count,
-        .array = array
-#ifdef FLECS_SANITIZE
-        , .elem_size = size
-#endif
-    };
-}
+/**
+ * @file addons/querys/engine.c
+ * @brief Iterator for trivial queries.
+ */
 
-void ecs_vec_reclaim(
-    ecs_allocator_t *allocator,
-    ecs_vec_t *v,
-    ecs_size_t size)
+
+static
+bool flecs_query_trivial_search_init(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    const ecs_query_t *query,
+    bool first,
+    ecs_flags64_t term_set)
 {
-    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-    int32_t count = v->count;
-    if (count < v->size) {
-        if (count) {
-            if (allocator) {
-                v->array = flecs_realloc(
-                    allocator, size * count, size * v->size, v->array);
-            } else {
-                v->array = ecs_os_realloc(v->array, size * count);
+    if (first) {
+        /* Find first trivial term*/
+        int32_t t;
+        for (t = 0; t < query->term_count; t ++) {
+            if (term_set & (1llu << t)) {
+                break;
             }
-            v->size = count;
-        } else {
-            ecs_vec_fini(allocator, v, size);
         }
-    }
-}
 
-void ecs_vec_set_size(
-    ecs_allocator_t *allocator,
-    ecs_vec_t *v,
-    ecs_size_t size,
-    int32_t elem_count)
-{
-    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-    if (v->size != elem_count) {
-        if (elem_count < v->count) {
-            elem_count = v->count;
+        ecs_assert(t != query->term_count, ECS_INTERNAL_ERROR, NULL);
+
+        const ecs_term_t *term = &query->terms[t];
+        ecs_id_record_t *idr = flecs_id_record_get(ctx->world, term->id);
+        if (!idr) {
+            return false;
         }
 
-        elem_count = flecs_next_pow_of_2(elem_count);
-        if (elem_count < 2) {
-            elem_count = 2;
+        if (query->flags & EcsQueryMatchEmptyTables) {
+            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)){
+                return false;
+            }
+        } else {
+            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
         }
-        if (elem_count != v->size) {
-            if (allocator) {
-                v->array = flecs_realloc(
-                    allocator, size * elem_count, size * v->size, v->array);
-            } else {
-                v->array = ecs_os_realloc(v->array, size * elem_count);
+
+        /* Find next term to evaluate once */
+        for (; t < query->term_count; t ++) {
+            if (term_set & (1llu << t)) {
+                break;
             }
-            v->size = elem_count;
         }
-    }
-}
 
-void ecs_vec_set_min_size(
-    struct ecs_allocator_t *allocator,
-    ecs_vec_t *vec,
-    ecs_size_t size,
-    int32_t elem_count)
-{
-    if (elem_count > vec->size) {
-        ecs_vec_set_size(allocator, vec, size, elem_count);
+        op_ctx->first_to_eval = t;
     }
-}
 
-void ecs_vec_set_min_count(
-    struct ecs_allocator_t *allocator,
-    ecs_vec_t *vec,
-    ecs_size_t size,
-    int32_t elem_count)
-{
-    ecs_vec_set_min_size(allocator, vec, size, elem_count);
-    if (vec->count < elem_count) {
-        vec->count = elem_count;
-    }
+    return true;
 }
 
-void ecs_vec_set_min_count_zeromem(
-    struct ecs_allocator_t *allocator,
-    ecs_vec_t *vec,
-    ecs_size_t size,
-    int32_t elem_count)
+bool flecs_query_trivial_search(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t term_set)
 {
-    int32_t count = vec->count;
-    if (count < elem_count) {
-        ecs_vec_set_min_count(allocator, vec, size, elem_count);
-        ecs_os_memset(ECS_ELEM(vec->array, size, count), 0,
-            size * (elem_count - count));
+    const ecs_query_t *q = &query->pub;
+    const ecs_term_t *terms = q->terms;
+    ecs_iter_t *it = ctx->it;
+    int32_t t, term_count = query->pub.term_count;
+
+    if (!flecs_query_trivial_search_init(ctx, op_ctx, q, first, term_set)) {
+        return false;
     }
-}
 
-void ecs_vec_set_count(
-    ecs_allocator_t *allocator,
-    ecs_vec_t *v,
-    ecs_size_t size,
-    int32_t elem_count)
-{
-    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-    if (v->count != elem_count) {
-        if (v->size < elem_count) {
-            ecs_vec_set_size(allocator, v, size, elem_count);
+    do {
+        const ecs_table_record_t *tr = flecs_table_cache_next(
+            &op_ctx->it, ecs_table_record_t);
+        if (!tr) {
+            return false;
         }
 
-        v->count = elem_count;
-    }
-}
+        ecs_table_t *table = tr->hdr.table;
+        if (table->flags & (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)) {
+            continue;
+        }
 
-void* ecs_vec_grow(
-    ecs_allocator_t *allocator,
-    ecs_vec_t *v,
-    ecs_size_t size,
-    int32_t elem_count)
-{
-    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(elem_count > 0, ECS_INTERNAL_ERROR, NULL);
-    int32_t count = v->count;
-    ecs_vec_set_count(allocator, v, size, count + elem_count);
-    return ECS_ELEM(v->array, size, count);
-}
+        for (t = op_ctx->first_to_eval; t < term_count; t ++) {
+            if (!(term_set & (1llu << t))) {
+                continue;
+            }
 
-void* ecs_vec_append(
-    ecs_allocator_t *allocator,
-    ecs_vec_t *v,
-    ecs_size_t size)
-{
-    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-    int32_t count = v->count;
-    if (v->size == count) {
-        ecs_vec_set_size(allocator, v, size, count + 1);
-    }
-    v->count = count + 1;
-    return ECS_ELEM(v->array, size, count);
-}
+            const ecs_term_t *term = &terms[t];
+            ecs_id_record_t *idr = flecs_id_record_get(ctx->world, term->id);
+            if (!idr) {
+                return false;
+            }
 
-void ecs_vec_remove(
-    ecs_vec_t *v,
-    ecs_size_t size,
-    int32_t index)
-{
-    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index < v->count, ECS_OUT_OF_RANGE, NULL);
-    if (index == --v->count) {
-        return;
-    }
+            const ecs_table_record_t *tr_with = flecs_id_record_get_table(
+                idr, table);
+            if (!tr_with) {
+                break;
+            }
 
-    ecs_os_memcpy(
-        ECS_ELEM(v->array, size, index),
-        ECS_ELEM(v->array, size, v->count),
-        size);
-}
+            it->columns[t] = tr_with->index;
+            if (tr_with->column != -1) {
+                it->ptrs[t] = ecs_vec_first(
+                    &table->data.columns[tr_with->column].data);
+            }
+        }
 
-void ecs_vec_remove_last(
-    ecs_vec_t *v)
-{
-    v->count --;
-}
+        if (t == term_count) {
+            ctx->vars[0].range.table = table;
+            ctx->vars[0].range.count = 0;
+            ctx->vars[0].range.offset = 0;
+            it->columns[0] = tr->index;
+            if (tr->column != -1) {
+                it->ptrs[0] = ecs_vec_first(
+                    &table->data.columns[tr->column].data);
+            }
+            break;
+        }
+    } while (true);
 
-int32_t ecs_vec_count(
-    const ecs_vec_t *v)
-{
-    return v->count;
+    return true;
 }
 
-int32_t ecs_vec_size(
-    const ecs_vec_t *v)
+bool flecs_query_trivial_search_w_wildcards(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t term_set)
 {
-    return v->size;
-}
+    bool result = flecs_query_trivial_search(
+        query, ctx, op_ctx, first, term_set);
+    if (result) {
+        ecs_iter_t *it = ctx->it;
+        ecs_table_t *table = ctx->vars[0].range.table;
+        int32_t t, term_count = query->pub.term_count;
+        for (t = 0; t < term_count; t ++) {
+            if (term_set & (1llu << t)) {
+                int32_t column = it->columns[t];
+                ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+                it->ids[t] = table->type.array[column];
+            }
+        }
+    }
 
-void* ecs_vec_get(
-    const ecs_vec_t *v,
-    ecs_size_t size,
-    int32_t index)
-{
-    ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index < v->count, ECS_OUT_OF_RANGE, NULL);
-    return ECS_ELEM(v->array, size, index);
+    return result;
 }
 
-void* ecs_vec_last(
-    const ecs_vec_t *v,
-    ecs_size_t size)
+bool flecs_query_trivial_search_nodata(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t term_set)
 {
-    ecs_san_assert(!v->elem_size || size == v->elem_size,
-        ECS_INVALID_PARAMETER, NULL);
-    return ECS_ELEM(v->array, size, v->count - 1);
-}
+    const ecs_query_t *q = &query->pub;
+    const ecs_term_t *terms = q->terms;
+    ecs_iter_t *it = ctx->it;
+    int32_t t, term_count = query->pub.term_count;
 
-void* ecs_vec_first(
-    const ecs_vec_t *v)
-{
-    return v->array;
-}
+    if (!flecs_query_trivial_search_init(ctx, op_ctx, q, first, term_set)) {
+        return false;
+    }
+
+    do {
+        const ecs_table_record_t *tr = flecs_table_cache_next(
+            &op_ctx->it, ecs_table_record_t);
+        if (!tr) {
+            return false;
+        }
 
+        ecs_table_t *table = tr->hdr.table;
+        if (table->flags & (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)) {
+            continue;
+        }
 
-static
-ecs_entity_index_page_t* flecs_entity_index_ensure_page(
-    ecs_entity_index_t *index,
-    uint32_t id)
-{
-    int32_t page_index = (int32_t)(id >> FLECS_ENTITY_PAGE_BITS);
-    if (page_index >= ecs_vec_count(&index->pages)) {
-        ecs_vec_set_min_count_zeromem_t(index->allocator, &index->pages, 
-            ecs_entity_index_page_t*, page_index + 1);
-    }
+        for (t = op_ctx->first_to_eval; t < term_count; t ++) {
+            if (!(term_set & (1llu << t))) {
+                continue;
+            }
 
-    ecs_entity_index_page_t **page_ptr = ecs_vec_get_t(&index->pages, 
-        ecs_entity_index_page_t*, page_index);
-    ecs_entity_index_page_t *page = *page_ptr;
-    if (!page) {
-        page = *page_ptr = flecs_bcalloc(&index->page_allocator);
-        ecs_assert(page != NULL, ECS_OUT_OF_MEMORY, NULL);
-    }
+            const ecs_term_t *term = &terms[t];
+            ecs_id_record_t *idr = flecs_id_record_get(ctx->world, term->id);
+            if (!idr) {
+                break;
+            }
 
-    return page;
-}
+            const ecs_table_record_t *tr_with = flecs_id_record_get_table(
+                idr, table);
+            if (!tr_with) {
+                break;
+            }
 
-void flecs_entity_index_init(
-    ecs_allocator_t *allocator,
-    ecs_entity_index_t *index)
-{
-    index->allocator = allocator;
-    index->alive_count = 1;
-    ecs_vec_init_t(allocator, &index->dense, uint64_t, 1);
-    ecs_vec_set_count_t(allocator, &index->dense, uint64_t, 1);
-    ecs_vec_init_t(allocator, &index->pages, ecs_entity_index_page_t*, 0);
-    flecs_ballocator_init(&index->page_allocator, 
-        ECS_SIZEOF(ecs_entity_index_page_t));
-}
+            it->columns[t] = tr_with->index;
+        }
 
-void flecs_entity_index_fini(
-    ecs_entity_index_t *index)
-{
-    ecs_vec_fini_t(index->allocator, &index->dense, uint64_t);
-#if defined(FLECS_SANITIZE) || defined(FLECS_USE_OS_ALLOC)
-    int32_t i, count = ecs_vec_count(&index->pages);
-    ecs_entity_index_page_t **pages = ecs_vec_first(&index->pages);
-    for (i = 0; i < count; i ++) {
-        flecs_bfree(&index->page_allocator, pages[i]);
-    }
-#endif
-    ecs_vec_fini_t(index->allocator, &index->pages, ecs_entity_index_page_t*);
-    flecs_ballocator_fini(&index->page_allocator);
-}
+        if (t == term_count) {
+            ctx->vars[0].range.table = table;
+            ctx->vars[0].range.count = 0;
+            ctx->vars[0].range.offset = 0;
+            it->columns[0] = tr->index;
+            break;
+        }
+    } while (true);
 
-ecs_record_t* flecs_entity_index_get_any(
-    const ecs_entity_index_t *index,
-    uint64_t entity)
-{
-    uint32_t id = (uint32_t)entity;
-    int32_t page_index = (int32_t)(id >> FLECS_ENTITY_PAGE_BITS);
-    ecs_entity_index_page_t *page = ecs_vec_get_t(&index->pages, 
-        ecs_entity_index_page_t*, page_index)[0];
-    ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
-    ecs_assert(r->dense != 0, ECS_INVALID_PARAMETER, NULL);
-    return r;
+    return true;
 }
 
-ecs_record_t* flecs_entity_index_get(
-    const ecs_entity_index_t *index,
-    uint64_t entity)
+bool flecs_query_trivial_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first,
+    ecs_flags64_t term_set)
 {
-    ecs_record_t *r = flecs_entity_index_get_any(index, entity);
-    ecs_assert(r->dense < index->alive_count, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(ecs_vec_get_t(&index->dense, uint64_t, r->dense)[0] == entity, 
-        ECS_INVALID_PARAMETER, NULL);
-    return r;
-}
+    if (first) {
+        const ecs_query_t *q = &impl->pub;
+        const ecs_term_t *terms = q->terms;
+        ecs_iter_t *it = ctx->it;
+        int32_t t, term_count = impl->pub.term_count;
 
-ecs_record_t* flecs_entity_index_try_get_any(
-    const ecs_entity_index_t *index,
-    uint64_t entity)
-{
-    uint32_t id = (uint32_t)entity;
-    int32_t page_index = (int32_t)(id >> FLECS_ENTITY_PAGE_BITS);
-    if (page_index >= ecs_vec_count(&index->pages)) {
-        return NULL;
-    }
+        ecs_table_t *table = it->table;
+        ecs_assert(table != NULL, ECS_INVALID_OPERATION,
+            "the variable set on the iterator is missing a table");
 
-    ecs_entity_index_page_t *page = ecs_vec_get_t(&index->pages, 
-        ecs_entity_index_page_t*, page_index)[0];
-    if (!page) {
-        return NULL;
-    }
+        for (t = 0; t < term_count; t ++) {
+            if (!(term_set & (1llu << t))) {
+                continue;
+            }
 
-    ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
-    if (!r->dense) {
-        return NULL;
-    }
+            const ecs_term_t *term = &terms[t];
+            ecs_id_record_t *idr = flecs_id_record_get(q->world, term->id);
+            if (!idr) {
+                return false;
+            }
 
-    return r;
-}
+            const ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+            if (!tr) {
+                return false;
+            }
 
-ecs_record_t* flecs_entity_index_try_get(
-    const ecs_entity_index_t *index,
-    uint64_t entity)
-{
-    ecs_record_t *r = flecs_entity_index_try_get_any(index, entity);
-    if (r) {
-        if (r->dense >= index->alive_count) {
-            return NULL;
+            it->columns[t] = tr->index;
+            if (it->count && tr->column != -1) {
+                it->ptrs[t] = ecs_vec_get(
+                    &table->data.columns[tr->column].data,
+                    it->sizes[t],
+                    it->offset);
+            }
         }
-        if (ecs_vec_get_t(&index->dense, uint64_t, r->dense)[0] != entity) {
-            return NULL;
+
+        it->entities = flecs_table_entities_array(table);
+        if (it->entities) {
+            it->entities = &it->entities[it->offset];
         }
+
+        return true;
+    } else {
+        return false;
     }
-    return r;
 }
 
-ecs_record_t* flecs_entity_index_ensure(
-    ecs_entity_index_t *index,
-    uint64_t entity)
+bool flecs_query_trivial_test_w_wildcards(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    bool first,
+    ecs_flags64_t term_set)
 {
-    uint32_t id = (uint32_t)entity;
-    ecs_entity_index_page_t *page = flecs_entity_index_ensure_page(index, id);
-    ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
-
-    int32_t dense = r->dense;
-    if (dense) {
-        /* Entity is already alive, nothing to be done */
-        if (dense < index->alive_count) {
-            ecs_assert(
-                ecs_vec_get_t(&index->dense, uint64_t, dense)[0] == entity, 
-                ECS_INTERNAL_ERROR, NULL);
-            return r;
+    int32_t t, term_count = query->pub.term_count;
+    bool result = flecs_query_trivial_test(
+        query, ctx, first, term_set);
+    if (result) {
+        ecs_iter_t *it = ctx->it;
+        ecs_table_t *table = ctx->vars[0].range.table;
+        for (t = 0; t < term_count; t ++) {
+            if (term_set & (1llu << t)) {
+                int32_t column = it->columns[t];
+                ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+                it->ids[t] = table->type.array[column];
+            }
         }
-    } else {
-        /* Entity doesn't have a dense index yet */
-        ecs_vec_append_t(index->allocator, &index->dense, uint64_t)[0] = entity;
-        r->dense = dense = ecs_vec_count(&index->dense) - 1;
-        index->max_id = id > index->max_id ? id : index->max_id;
     }
 
-    ecs_assert(dense != 0, ECS_INTERNAL_ERROR, NULL);
-
-    /* Entity is not alive, swap with first not alive element */
-    uint64_t *ids = ecs_vec_first(&index->dense);
-    uint64_t e_swap = ids[index->alive_count];
-    ecs_record_t *r_swap = flecs_entity_index_get_any(index, e_swap);
-    ecs_assert(r_swap->dense == index->alive_count, 
-        ECS_INTERNAL_ERROR, NULL);
+    return result;
+}
 
-    r_swap->dense = dense;
-    r->dense = index->alive_count;
-    ids[dense] = e_swap;
-    ids[index->alive_count ++] = entity;
+ /**
+ * @file query/util.c
+ * @brief Query utilities.
+ */
 
-    ecs_assert(flecs_entity_index_is_alive(index, entity), 
-        ECS_INTERNAL_ERROR, NULL);
 
-    return r;
+ecs_query_lbl_t flecs_itolbl(int64_t val) {
+    return flecs_ito(int16_t, val);
 }
 
-void flecs_entity_index_remove(
-    ecs_entity_index_t *index,
-    uint64_t entity)
-{
-    ecs_record_t *r = flecs_entity_index_try_get(index, entity);
-    if (!r) {
-        /* Entity is not alive or doesn't exist, nothing to be done */
-        return;
-    }
-
-    int32_t dense = r->dense;
-    int32_t i_swap = -- index->alive_count;
-    uint64_t *e_swap_ptr = ecs_vec_get_t(&index->dense, uint64_t, i_swap);
-    uint64_t e_swap = e_swap_ptr[0];
-    ecs_record_t *r_swap = flecs_entity_index_get_any(index, e_swap);
-    ecs_assert(r_swap->dense == i_swap, ECS_INTERNAL_ERROR, NULL);
-
-    r_swap->dense = dense;
-    r->table = NULL;
-    r->idr = NULL;
-    r->row = 0;
-    r->dense = i_swap;
-    ecs_vec_get_t(&index->dense, uint64_t, dense)[0] = e_swap;
-    e_swap_ptr[0] = ECS_GENERATION_INC(entity);
-    ecs_assert(!flecs_entity_index_is_alive(index, entity), 
-        ECS_INTERNAL_ERROR, NULL);
+ecs_var_id_t flecs_itovar(int64_t val) {
+    return flecs_ito(uint8_t, val);
 }
 
-void flecs_entity_index_make_alive(
-    ecs_entity_index_t *index,
-    uint64_t entity)
-{
-    ecs_record_t *r = flecs_entity_index_try_get_any(index, entity);
-    if (r) {
-        ecs_vec_get_t(&index->dense, uint64_t, r->dense)[0] = entity;
-    }
+ecs_var_id_t flecs_utovar(uint64_t val) {
+    return flecs_uto(uint8_t, val);
 }
 
-uint64_t flecs_entity_index_get_alive(
-    const ecs_entity_index_t *index,
-    uint64_t entity)
+bool flecs_term_is_builtin_pred(
+    ecs_term_t *term)
 {
-    ecs_record_t *r = flecs_entity_index_try_get_any(index, entity);
-    if (r) {
-        return ecs_vec_get_t(&index->dense, uint64_t, r->dense)[0];
-    } else {
-        return 0;
+    if (term->first.id & EcsIsEntity) {
+        ecs_entity_t id = ECS_TERM_REF_ID(&term->first);
+        if (id == EcsPredEq || id == EcsPredMatch || id == EcsPredLookup) {
+            return true;
+        }
     }
+    return false;
 }
 
-bool flecs_entity_index_is_alive(
-    const ecs_entity_index_t *index,
-    uint64_t entity)
+const char* flecs_term_ref_var_name(
+    ecs_term_ref_t *ref)
 {
-    return flecs_entity_index_try_get(index, entity) != NULL;
-}
+    if (!(ref->id & EcsIsVariable)) {
+        return NULL;
+    }
 
-bool flecs_entity_index_is_valid(
-    const ecs_entity_index_t *index,
-    uint64_t entity)
-{
-    uint32_t id = (uint32_t)entity;    
-    ecs_record_t *r = flecs_entity_index_try_get_any(index, id);
-    if (!r || !r->dense) {
-        /* Doesn't exist yet, so is valid */
-        return true;
+    if (ECS_TERM_REF_ID(ref) == EcsThis) {
+        return EcsThisName;
     }
 
-    /* If the id exists, it must be alive */
-    return r->dense < index->alive_count;
+    return ref->name;
 }
 
-bool flecs_entity_index_exists(
-    const ecs_entity_index_t *index,
-    uint64_t entity)
+bool flecs_term_ref_is_wildcard(
+    ecs_term_ref_t *ref)
 {
-    return flecs_entity_index_try_get_any(index, entity) != NULL;
+    if ((ref->id & EcsIsVariable) && 
+        ((ECS_TERM_REF_ID(ref) == EcsWildcard) || (ECS_TERM_REF_ID(ref) == EcsAny))) 
+    {
+        return true;
+    }
+    return false;
 }
 
-uint64_t flecs_entity_index_new_id(
-    ecs_entity_index_t *index)
+bool flecs_term_is_fixed_id(
+    ecs_query_t *q,
+    ecs_term_t *term)
 {
-    if (index->alive_count != ecs_vec_count(&index->dense)) {
-        /* Recycle id */
-        return ecs_vec_get_t(&index->dense, uint64_t, index->alive_count ++)[0];
+    /* Transitive/inherited terms have variable ids */
+    if (term->flags_ & (EcsTermTransitive|EcsTermIdInherited)) {
+        return false;
     }
 
-    /* Create new id */
-    uint32_t id = (uint32_t)++ index->max_id;
-    ecs_vec_append_t(index->allocator, &index->dense, uint64_t)[0] = id;
-
-    ecs_entity_index_page_t *page = flecs_entity_index_ensure_page(index, id);
-    ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
-    r->dense = index->alive_count ++;
-    ecs_assert(index->alive_count == ecs_vec_count(&index->dense), 
-        ECS_INTERNAL_ERROR, NULL);
-
-    return id;
-}
+    /* Or terms can match different ids */
+    if (term->oper == EcsOr) {
+        return false;
+    }
+    if ((term != q->terms) && term[-1].oper == EcsOr) {
+        return false;
+    }
 
-uint64_t* flecs_entity_index_new_ids(
-    ecs_entity_index_t *index,
-    int32_t count)
-{
-    int32_t alive_count = index->alive_count;
-    int32_t new_count = alive_count + count;
-    int32_t dense_count = ecs_vec_count(&index->dense);
+    /* Wildcards can assume different ids */
+    if (ecs_id_is_wildcard(term->id)) {
+        return false;
+    }
 
-    if (new_count < dense_count) {
-        /* Recycle ids */
-        index->alive_count = new_count;
-        return ecs_vec_get_t(&index->dense, uint64_t, alive_count);
+    /* Any terms can have fixed ids, but they require special handling */
+    if (term->flags_ & (EcsTermMatchAny|EcsTermMatchAnySrc)) {
+        return false;
     }
 
-    /* Allocate new ids */
-    ecs_vec_set_count_t(index->allocator, &index->dense, uint64_t, new_count);
-    int32_t i, to_add = new_count - dense_count;
-    for (i = 0; i < to_add; i ++) {
-        uint32_t id = (uint32_t)++ index->max_id;
-        int32_t dense = dense_count + i;
-        ecs_vec_get_t(&index->dense, uint64_t, dense)[0] = id;
-        ecs_entity_index_page_t *page = flecs_entity_index_ensure_page(index, id);
-        ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
-        r->dense = dense;
+    /* First terms that are Not or Optional require special handling */
+    if (term->oper == EcsNot || term->oper == EcsOptional) {
+        if (term == q->terms) {
+            return false;
+        }
     }
 
-    index->alive_count = new_count;
-    return ecs_vec_get_t(&index->dense, uint64_t, alive_count);
+    return true;
 }
 
-void flecs_entity_index_set_size(
-    ecs_entity_index_t *index,
-    int32_t size)
+bool flecs_term_is_or(
+    const ecs_query_t *q,
+    const ecs_term_t *term)
 {
-    ecs_vec_set_size_t(index->allocator, &index->dense, uint64_t, size);
+    bool first_term = term == q->terms;
+    return (term->oper == EcsOr) || (!first_term && term[-1].oper == EcsOr);
 }
 
-int32_t flecs_entity_index_count(
-    const ecs_entity_index_t *index)
+ecs_flags16_t flecs_query_ref_flags(
+    ecs_flags16_t flags,
+    ecs_flags16_t kind)
 {
-    return index->alive_count - 1;
+    return (flags >> kind) & (EcsQueryIsVar | EcsQueryIsEntity);
 }
 
-int32_t flecs_entity_index_size(
-    const ecs_entity_index_t *index)
+bool flecs_query_is_written(
+    ecs_var_id_t var_id,
+    uint64_t written)
 {
-    return ecs_vec_count(&index->dense) - 1;
+    if (var_id == EcsVarNone) {
+        return true;
+    }
+
+    ecs_assert(var_id < EcsQueryMaxVarCount, ECS_INTERNAL_ERROR, NULL);
+    return (written & (1ull << var_id)) != 0;
 }
 
-int32_t flecs_entity_index_not_alive_count(
-    const ecs_entity_index_t *index)
+void flecs_query_write(
+    ecs_var_id_t var_id,
+    uint64_t *written)
 {
-    return ecs_vec_count(&index->dense) - index->alive_count;
+    ecs_assert(var_id < EcsQueryMaxVarCount, ECS_INTERNAL_ERROR, NULL);
+    *written |= (1ull << var_id);
 }
 
-void flecs_entity_index_clear(
-    ecs_entity_index_t *index)
+void flecs_query_write_ctx(
+    ecs_var_id_t var_id,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
 {
-    int32_t i, count = ecs_vec_count(&index->pages);
-    ecs_entity_index_page_t **pages = ecs_vec_first_t(&index->pages, 
-        ecs_entity_index_page_t*);
-    for (i = 0; i < count; i ++) {
-        ecs_entity_index_page_t *page = pages[i];
-        if (page) {
-            ecs_os_zeromem(page);
+    bool is_written = flecs_query_is_written(var_id, ctx->written);
+    flecs_query_write(var_id, &ctx->written);
+    if (!is_written) {
+        if (cond_write) {
+            flecs_query_write(var_id, &ctx->cond_written);
         }
     }
-
-    ecs_vec_set_count_t(index->allocator, &index->dense, uint64_t, 1);
-
-    index->alive_count = 1;
-    index->max_id = 0;
 }
 
-const uint64_t* flecs_entity_index_ids(
-    const ecs_entity_index_t *index)
+bool flecs_ref_is_written(
+    const ecs_query_op_t *op,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t kind,
+    uint64_t written)
 {
-    return ecs_vec_get_t(&index->dense, uint64_t, 1);
+    ecs_flags16_t flags = flecs_query_ref_flags(op->flags, kind);
+    if (flags & EcsQueryIsEntity) {
+        ecs_assert(!(flags & EcsQueryIsVar), ECS_INTERNAL_ERROR, NULL);
+        if (ref->entity) {
+            return true;
+        }
+    } else if (flags & EcsQueryIsVar) {
+        return flecs_query_is_written(ref->var, written);
+    }
+    return false;
 }
 
-static
-void flecs_entity_index_copy_intern(
-    ecs_entity_index_t * dst,
-    const ecs_entity_index_t * src)
+ecs_allocator_t* flecs_query_get_allocator(
+    const ecs_iter_t *it)
 {
-    flecs_entity_index_set_size(dst, flecs_entity_index_size(src));
-    const uint64_t *ids = flecs_entity_index_ids(src);
-    
-    int32_t i, count = src->alive_count;
-    for (i = 0; i < count - 1; i ++) {
-        uint64_t id = ids[i];
-        ecs_record_t *src_ptr = flecs_entity_index_get(src, id);
-        ecs_record_t *dst_ptr = flecs_entity_index_ensure(dst, id);
-        flecs_entity_index_make_alive(dst, id);
-        ecs_os_memcpy_t(dst_ptr, src_ptr, ecs_record_t);
+    ecs_world_t *world = it->world;
+    if (flecs_poly_is(world, ecs_world_t)) {
+        return &world->allocator;
+    } else {
+        ecs_assert(flecs_poly_is(world, ecs_stage_t), ECS_INTERNAL_ERROR, NULL);
+        return &((ecs_stage_t*)world)->allocator;
     }
-
-    dst->max_id = src->max_id;
-
-    ecs_assert(src->alive_count == dst->alive_count, ECS_INTERNAL_ERROR, NULL);
 }
 
-void flecs_entity_index_copy(
-    ecs_entity_index_t *dst,
-    const ecs_entity_index_t *src)
+const char* flecs_query_op_str(
+    uint16_t kind)
 {
-    if (!src) {
-        return;
+    switch(kind) {
+    case EcsQueryAnd:           return "and       ";
+    case EcsQueryAndId:         return "andid     ";
+    case EcsQueryAndAny:        return "andany    ";
+    case EcsQueryTriv:          return "triv      ";
+    case EcsQueryTrivData:      return "trivpop   ";
+    case EcsQueryTrivWildcard:  return "trivwc    ";
+    case EcsQueryCache:         return "cache     ";
+    case EcsQueryCacheData:     return "cachepop  ";
+    case EcsQueryIsCache:       return "xcache    ";
+    case EcsQueryIsCacheData:   return "xcachepop ";
+    case EcsQuerySelectAny:     return "any       ";
+    case EcsQueryUp:            return "up        ";
+    case EcsQueryUpId:          return "upid      ";
+    case EcsQuerySelfUp:        return "selfup    ";
+    case EcsQuerySelfUpId:      return "selfupid  ";
+    case EcsQueryWith:          return "with      ";
+    case EcsQueryTrav:          return "trav      ";
+    case EcsQueryAndFrom:       return "andfrom   ";
+    case EcsQueryOrFrom:        return "orfrom    ";
+    case EcsQueryNotFrom:       return "notfrom   ";
+    case EcsQueryIds:           return "ids       ";
+    case EcsQueryIdsRight:      return "idsr      ";
+    case EcsQueryIdsLeft:       return "idsl      ";
+    case EcsQueryEach:          return "each      ";
+    case EcsQueryStore:         return "store     ";
+    case EcsQueryReset:         return "reset     ";
+    case EcsQueryOr:            return "or        ";
+    case EcsQueryOptional:      return "option    ";
+    case EcsQueryIfVar:         return "ifvar     ";
+    case EcsQueryIfSet:         return "ifset     ";
+    case EcsQueryEnd:           return "end       ";
+    case EcsQueryNot:           return "not       ";
+    case EcsQueryPredEq:        return "eq        ";
+    case EcsQueryPredNeq:       return "neq       ";
+    case EcsQueryPredEqName:    return "eq_nm     ";
+    case EcsQueryPredNeqName:   return "neq_nm    ";
+    case EcsQueryPredEqMatch:   return "eq_m      ";
+    case EcsQueryPredNeqMatch:  return "neq_m     ";
+    case EcsQueryMemberEq:      return "membereq  ";
+    case EcsQueryMemberNeq:     return "memberneq ";
+    case EcsQueryToggle:        return "toggle    ";
+    case EcsQueryToggleOption:  return "togglopt  ";
+    case EcsQueryLookup:        return "lookup    ";
+    case EcsQuerySetVars:       return "setvars   ";
+    case EcsQuerySetThis:       return "setthis   ";
+    case EcsQuerySetFixed:      return "setfix    ";
+    case EcsQuerySetIds:        return "setids    ";
+    case EcsQuerySetId:         return "setid     ";
+    case EcsQueryContain:       return "contain   ";
+    case EcsQueryPairEq:        return "pair_eq   ";
+    case EcsQueryPopulate:      return "pop       ";
+    case EcsQueryPopulateSelf:  return "popself   ";
+    case EcsQueryYield:         return "yield     ";
+    case EcsQueryNothing:       return "nothing   ";
+    default:                   return "!invalid  ";
+    }
+}
+
+static
+int32_t flecs_query_op_ref_str(
+    const ecs_query_impl_t *query,
+    ecs_query_ref_t *ref,
+    ecs_flags16_t flags,
+    ecs_strbuf_t *buf)
+{
+    int32_t color_chars = 0;
+    if (flags & EcsQueryIsVar) {
+        ecs_assert(ref->var < query->var_count, ECS_INTERNAL_ERROR, NULL);
+        ecs_query_var_t *var = &query->vars[ref->var];
+        ecs_strbuf_appendlit(buf, "#[green]$#[reset]");
+        if (var->kind == EcsVarTable) {
+            ecs_strbuf_appendch(buf, '[');
+        }
+        ecs_strbuf_appendlit(buf, "#[green]");
+        if (var->name) {
+            ecs_strbuf_appendstr(buf, var->name);
+        } else {
+            if (var->id) {
+#ifdef FLECS_DEBUG
+                if (var->label) {
+                    ecs_strbuf_appendstr(buf, var->label);
+                    ecs_strbuf_appendch(buf, '\'');
+                }
+#endif
+                ecs_strbuf_append(buf, "%d", var->id);
+            } else {
+                ecs_strbuf_appendlit(buf, "this");
+            }
+        }
+        ecs_strbuf_appendlit(buf, "#[reset]");
+        if (var->kind == EcsVarTable) {
+            ecs_strbuf_appendch(buf, ']');
+        }
+        color_chars = ecs_os_strlen("#[green]#[reset]#[green]#[reset]");
+    } else if (flags & EcsQueryIsEntity) {
+        char *path = ecs_get_fullpath(query->pub.world, ref->entity);
+        ecs_strbuf_appendlit(buf, "#[blue]");
+        ecs_strbuf_appendstr(buf, path);
+        ecs_strbuf_appendlit(buf, "#[reset]");
+        ecs_os_free(path);
+        color_chars = ecs_os_strlen("#[blue]#[reset]");
     }
-
-    flecs_entity_index_init(src->allocator, dst);
-    flecs_entity_index_copy_intern(dst, src);
+    return color_chars;
 }
 
-void flecs_entity_index_restore(
-    ecs_entity_index_t *dst,
-    const ecs_entity_index_t *src)
+static
+void flecs_query_str_append_bitset(
+    ecs_strbuf_t *buf,
+    ecs_flags64_t bitset)
 {
-    if (!src) {
-        return;
+    ecs_strbuf_list_push(buf, "{", ",");
+    int8_t b;
+    for (b = 0; b < 64; b ++) {
+        if (bitset & (1llu << b)) {
+            ecs_strbuf_list_append(buf, "%d", b);
+        }
     }
-
-    flecs_entity_index_clear(dst);
-    flecs_entity_index_copy_intern(dst, src);
+    ecs_strbuf_list_pop(buf, "}");
 }
 
-/**
- * @file id_index.c
- * @brief Index for looking up tables by (component) id.
- * 
- * An id record stores the administration for an in use (component) id, that is
- * an id that has been used in tables.
- * 
- * An id record contains a table cache, which stores the list of tables that
- * have the id. Each entry in the cache (a table record) stores the first 
- * occurrence of the id in the table and the number of occurrences of the id in
- * the table (in the case of wildcard ids).
- * 
- * Id records are used in lots of scenarios, like uncached queries, or for 
- * getting a component array/component for an entity.
- */
+char* ecs_query_str_w_profile(
+    const ecs_query_t *q,
+    const ecs_iter_t *it)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_impl_t *impl = flecs_query_impl(q);
 
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    ecs_query_op_t *ops = impl->ops;
+    int32_t i, count = impl->op_count, indent = 0;
+    for (i = 0; i < count; i ++) {
+        ecs_query_op_t *op = &ops[i];
+        ecs_flags16_t flags = op->flags;
+        ecs_flags16_t src_flags = flecs_query_ref_flags(flags, EcsQuerySrc);
+        ecs_flags16_t first_flags = flecs_query_ref_flags(flags, EcsQueryFirst);
+        ecs_flags16_t second_flags = flecs_query_ref_flags(flags, EcsQuerySecond);
 
-static
-ecs_id_record_elem_t* flecs_id_record_elem(
-    ecs_id_record_t *head,
-    ecs_id_record_elem_t *list,
-    ecs_id_record_t *idr)
-{
-    return ECS_OFFSET(idr, (uintptr_t)list - (uintptr_t)head);
-}
+        if (it) {
+#ifdef FLECS_DEBUG
+            const ecs_query_iter_t *rit = &it->priv_.iter.query;
+            ecs_strbuf_append(&buf, 
+                "#[green]%4d -> #[red]%4d <- #[grey]  |   ",
+                rit->profile[i].count[0],
+                rit->profile[i].count[1]);
+#endif
+        }
 
-static
-void flecs_id_record_elem_insert(
-    ecs_id_record_t *head,
-    ecs_id_record_t *idr,
-    ecs_id_record_elem_t *elem)
-{
-    ecs_id_record_elem_t *head_elem = flecs_id_record_elem(idr, elem, head);
-    ecs_id_record_t *cur = head_elem->next;
-    elem->next = cur;
-    elem->prev = head;
-    if (cur) {
-        ecs_id_record_elem_t *cur_elem = flecs_id_record_elem(idr, elem, cur);
-        cur_elem->prev = idr;
-    }
-    head_elem->next = idr;
-}
+        ecs_strbuf_append(&buf, 
+            "#[normal]%2d. [#[grey]%2d#[reset], #[green]%2d#[reset]]  ", 
+                i, op->prev, op->next);
+        int32_t hidden_chars, start = ecs_strbuf_written(&buf);
+        if (op->kind == EcsQueryEnd) {
+            indent --;
+        }
 
-static
-void flecs_id_record_elem_remove(
-    ecs_id_record_t *idr,
-    ecs_id_record_elem_t *elem)
-{
-    ecs_id_record_t *prev = elem->prev;
-    ecs_id_record_t *next = elem->next;
-    ecs_assert(prev != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_strbuf_append(&buf, "%*s", indent, "");
+        ecs_strbuf_appendstr(&buf, flecs_query_op_str(op->kind));
+        ecs_strbuf_appendstr(&buf, " ");
 
-    ecs_id_record_elem_t *prev_elem = flecs_id_record_elem(idr, elem, prev);
-    prev_elem->next = next;
-    if (next) {
-        ecs_id_record_elem_t *next_elem = flecs_id_record_elem(idr, elem, next);
-        next_elem->prev = prev;
-    }
-}
+        int32_t written = ecs_strbuf_written(&buf);
+        for (int32_t j = 0; j < (12 - (written - start)); j ++) {
+            ecs_strbuf_appendch(&buf, ' ');
+        }
+    
+        hidden_chars = flecs_query_op_ref_str(impl, &op->src, src_flags, &buf);
 
-static
-void flecs_insert_id_elem(
-    ecs_world_t *world,
-    ecs_id_record_t *idr,
-    ecs_id_t wildcard,
-    ecs_id_record_t *widr)
-{
-    ecs_assert(ecs_id_is_wildcard(wildcard), ECS_INTERNAL_ERROR, NULL);
-    if (!widr) {
-        widr = flecs_id_record_ensure(world, wildcard);
-    }
-    ecs_assert(widr != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (op->kind == EcsQueryNot || 
+            op->kind == EcsQueryOr || 
+            op->kind == EcsQueryOptional || 
+            op->kind == EcsQueryIfVar ||
+            op->kind == EcsQueryIfSet) 
+        {
+            indent ++;
+        }
 
-    if (ECS_PAIR_SECOND(wildcard) == EcsWildcard) {
-        ecs_assert(ECS_PAIR_FIRST(wildcard) != EcsWildcard, 
-            ECS_INTERNAL_ERROR, NULL);
-        flecs_id_record_elem_insert(widr, idr, &idr->first);
-    } else {
-        ecs_assert(ECS_PAIR_FIRST(wildcard) == EcsWildcard, 
-            ECS_INTERNAL_ERROR, NULL);
-        flecs_id_record_elem_insert(widr, idr, &idr->second);
+        if (op->kind == EcsQueryPopulate || 
+            op->kind == EcsQueryPopulateSelf ||
+            op->kind == EcsQueryTriv ||
+            op->kind == EcsQueryTrivData ||
+            op->kind == EcsQueryTrivWildcard)
+        {
+            flecs_query_str_append_bitset(&buf, op->src.entity);
+        }
 
-        if (idr->flags & EcsIdTraversable) {
-            flecs_id_record_elem_insert(widr, idr, &idr->trav);
+        if (op->kind == EcsQueryIfSet) {
+            ecs_strbuf_append(&buf, "[%d]\n", op->other);
+            continue;
         }
-    }
-}
 
-static
-void flecs_remove_id_elem(
-    ecs_id_record_t *idr,
-    ecs_id_t wildcard)
-{
-    ecs_assert(ecs_id_is_wildcard(wildcard), ECS_INTERNAL_ERROR, NULL);
+        bool is_toggle = op->kind == EcsQueryToggle || 
+            op->kind == EcsQueryToggleOption;
 
-    if (ECS_PAIR_SECOND(wildcard) == EcsWildcard) {
-        ecs_assert(ECS_PAIR_FIRST(wildcard) != EcsWildcard, 
-            ECS_INTERNAL_ERROR, NULL);
-        flecs_id_record_elem_remove(idr, &idr->first);
-    } else {
-        ecs_assert(ECS_PAIR_FIRST(wildcard) == EcsWildcard, 
-            ECS_INTERNAL_ERROR, NULL);
-        flecs_id_record_elem_remove(idr, &idr->second);
+        if (!first_flags && !second_flags && !is_toggle) {
+            ecs_strbuf_appendstr(&buf, "\n");
+            continue;
+        }
 
-        if (idr->flags & EcsIdTraversable) {
-            flecs_id_record_elem_remove(idr, &idr->trav);
+        written = ecs_strbuf_written(&buf) - hidden_chars;
+        for (int32_t j = 0; j < (30 - (written - start)); j ++) {
+            ecs_strbuf_appendch(&buf, ' ');
+        }
+
+        if (is_toggle) {
+            if (op->first.entity) {
+                flecs_query_str_append_bitset(&buf, op->first.entity);
+            }
+            if (op->second.entity) {
+                if (op->first.entity) {
+                    ecs_strbuf_appendlit(&buf, ", !");
+                }
+                flecs_query_str_append_bitset(&buf, op->second.entity);
+            }
+            ecs_strbuf_appendstr(&buf, "\n");
+            continue;
+        }
+
+        ecs_strbuf_appendstr(&buf, "(");
+        if (op->kind == EcsQueryMemberEq || op->kind == EcsQueryMemberNeq) {
+            uint32_t offset = (uint32_t)op->first.entity;
+            uint32_t size = (uint32_t)(op->first.entity >> 32);
+            ecs_strbuf_append(&buf, "#[yellow]elem#[reset]([%d], 0x%x, 0x%x)", 
+                op->field_index, size, offset);
+        } else {
+            flecs_query_op_ref_str(impl, &op->first, first_flags, &buf);
+        }
+
+        if (second_flags) {
+            ecs_strbuf_appendstr(&buf, ", ");
+            flecs_query_op_ref_str(impl, &op->second, second_flags, &buf);
+        } else {
+            switch (op->kind) {
+            case EcsQueryPredEqName:
+            case EcsQueryPredNeqName:
+            case EcsQueryPredEqMatch:
+            case EcsQueryPredNeqMatch: {
+                int8_t term_index = op->term_index;
+                ecs_strbuf_appendstr(&buf, ", #[yellow]\"");
+                ecs_strbuf_appendstr(&buf, q->terms[term_index].second.name);
+                ecs_strbuf_appendstr(&buf, "\"#[reset]");
+                break;
+            }
+            case EcsQueryLookup: {
+                ecs_var_id_t src_id = op->src.var;
+                ecs_strbuf_appendstr(&buf, ", #[yellow]\"");
+                ecs_strbuf_appendstr(&buf, impl->vars[src_id].lookup);
+                ecs_strbuf_appendstr(&buf, "\"#[reset]");
+                break;
+            }
+            default:
+                break;
+            }
         }
+
+        ecs_strbuf_appendch(&buf, ')');
+
+        ecs_strbuf_appendch(&buf, '\n');
     }
+
+#ifdef FLECS_LOG    
+    char *str = ecs_strbuf_get(&buf);
+    flecs_colorize_buf(str, ecs_os_api.flags_ & EcsOsApiLogWithColors, &buf);
+    ecs_os_free(str);
+#endif
+    return ecs_strbuf_get(&buf);
 }
 
-static
-ecs_id_t flecs_id_record_hash(
-    ecs_id_t id)
+char* ecs_query_plan(
+    const ecs_query_t *q)
 {
-    id = ecs_strip_generation(id);
-    if (ECS_IS_PAIR(id)) {
-        ecs_entity_t r = ECS_PAIR_FIRST(id);
-        ecs_entity_t o = ECS_PAIR_SECOND(id);
-        if (r == EcsAny) {
-            r = EcsWildcard;
-        }
-        if (o == EcsAny) {
-            o = EcsWildcard;
-        }
-        id = ecs_pair(r, o);
-    }
-    return id;
+    return ecs_query_str_w_profile(q, NULL);
 }
 
 static
-ecs_id_record_t* flecs_id_record_new(
-    ecs_world_t *world,
-    ecs_id_t id)
+void flecs_query_str_add_id(
+    const ecs_world_t *world,
+    ecs_strbuf_t *buf,
+    const ecs_term_t *term,
+    const ecs_term_ref_t *ref,
+    bool is_src,
+    ecs_flags64_t default_traverse_flags)
 {
-    ecs_id_record_t *idr, *idr_t = NULL;
-    ecs_id_t hash = flecs_id_record_hash(id);
-    if (hash >= FLECS_HI_ID_RECORD_ID) {
-        idr = flecs_bcalloc(&world->allocators.id_record);
-        ecs_map_insert_ptr(&world->id_index_hi, hash, idr);
-    } else {
-        idr = &world->id_index_lo[hash];
-        ecs_os_zeromem(idr);
+    bool is_added = false;
+    ecs_entity_t ref_id = ECS_TERM_REF_ID(ref);
+    if (!is_src || ref_id != EcsThis) {
+        if (ref->id & EcsIsVariable && !ecs_id_is_wildcard(ref_id)){
+            ecs_strbuf_appendlit(buf, "$");
+        }
+        if (ref_id) {
+            char *path = ecs_get_fullpath(world, ref_id);
+            ecs_strbuf_appendstr(buf, path);
+            ecs_os_free(path);
+        } else if (ref->name) {
+            ecs_strbuf_appendstr(buf, ref->name);
+        } else {
+            ecs_strbuf_appendlit(buf, "0");
+        }
+        is_added = true;
     }
 
-    ecs_table_cache_init(world, &idr->cache);
+    ecs_flags64_t flags = ECS_TERM_REF_FLAGS(ref);
+    if (!(flags & EcsTraverseFlags)) {
+        /* If flags haven't been set yet, initialize with defaults. This can
+         * happen if an error is thrown while the term is being finalized */
+        flags |= default_traverse_flags;
+    }
 
-    idr->id = id;
-    idr->refcount = 1;
-    idr->reachable.current = -1;
+    if ((flags & EcsTraverseFlags) != default_traverse_flags) {
+        if (is_added) {
+            ecs_strbuf_list_push(buf, ":", "|");
+        } else {
+            ecs_strbuf_list_push(buf, "", "|");
+        }
+        if (is_src) {
+            if (flags & EcsSelf) {
+                ecs_strbuf_list_appendstr(buf, "self");
+            }
 
-    bool is_wildcard = ecs_id_is_wildcard(id);
-    bool is_pair = ECS_IS_PAIR(id);
+            if (flags & EcsCascade) {
+                ecs_strbuf_list_appendstr(buf, "cascade");
+            } else if (flags & EcsUp) {
+                ecs_strbuf_list_appendstr(buf, "up");
+            }
 
-    ecs_entity_t rel = 0, tgt = 0, role = id & ECS_ID_FLAGS_MASK;
-    if (is_pair) {
-        // rel = ecs_pair_first(world, id);
-        rel = ECS_PAIR_FIRST(id);
-        rel = flecs_entities_get_alive(world, rel);
-        ecs_assert(rel != 0, ECS_INTERNAL_ERROR, NULL);
+            if (flags & EcsDesc) {
+                ecs_strbuf_list_appendstr(buf, "desc");
+            }
 
-        /* Relationship object can be 0, as tables without a ChildOf 
-         * relationship are added to the (ChildOf, 0) id record */
-        tgt = ECS_PAIR_SECOND(id);
+            if (term->trav && (term->trav != EcsIsA)) {
+                ecs_strbuf_list_push(buf, "(", "");
 
-#ifdef FLECS_DEBUG
-        /* Check constraints */
-        if (tgt) {
-            tgt = flecs_entities_get_alive(world, tgt);
-            ecs_assert(tgt != 0, ECS_INTERNAL_ERROR, NULL);
+                char *rel_path = ecs_get_fullpath(world, term->trav);
+                ecs_strbuf_appendstr(buf, rel_path);
+                ecs_os_free(rel_path);
 
-            /* Can't use relationship as target */
-            if (ecs_has_id(world, tgt, EcsRelationship)) {
-                if (!ecs_id_is_wildcard(rel) && 
-                    !ecs_has_id(world, rel, EcsTrait)) 
-                {
-                    char *idstr = ecs_id_str(world, id);
-                    char *tgtstr = ecs_id_str(world, tgt);
-                    ecs_err("constraint violated: relationship '%s' cannot be used"
-                        " as target in pair '%s'", tgtstr, idstr);
-                    ecs_os_free(tgtstr);
-                    ecs_os_free(idstr);
-                    #ifndef FLECS_SOFT_ASSERT
-                    ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
-                    #endif
-                }
+                ecs_strbuf_list_pop(buf, ")");
             }
         }
 
-        if (ecs_has_id(world, rel, EcsTarget)) {
-            char *idstr = ecs_id_str(world, id);
-            char *relstr = ecs_id_str(world, rel);
-            ecs_err("constraint violated: "
-                "%s: target '%s' cannot be used as relationship",
-                    idstr, relstr);
-            ecs_os_free(relstr);
-            ecs_os_free(idstr);
-            #ifndef FLECS_SOFT_ASSERT
-            ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
-            #endif
+        ecs_strbuf_list_pop(buf, "");
+    }
+}
+
+static
+void flecs_term_str_w_strbuf(
+    const ecs_world_t *world,
+    const ecs_term_t *term,
+    ecs_strbuf_t *buf,
+    int32_t t)
+{
+    const ecs_term_ref_t *src = &term->src;
+    const ecs_term_ref_t *first = &term->first;
+    const ecs_term_ref_t *second = &term->second;
+
+    ecs_entity_t src_id = ECS_TERM_REF_ID(src);
+    ecs_entity_t first_id = ECS_TERM_REF_ID(first);
+
+    uint64_t def_src_mask = EcsSelf|EcsUp;
+    uint64_t def_first_mask = EcsSelf;
+    uint64_t def_second_mask = EcsSelf;
+
+    bool src_set = !ecs_term_match_0(term);
+    bool first_set = ecs_term_ref_is_set(first);
+    bool second_set = ecs_term_ref_is_set(second);
+
+    if (first_id == EcsScopeOpen) {
+        ecs_strbuf_appendlit(buf, "{");
+        return;
+    } else if (first_id == EcsScopeClose) {
+        ecs_strbuf_appendlit(buf, "}");
+        return;
+    }
+
+    if (((ECS_TERM_REF_ID(&term->first) == EcsPredEq) || 
+         (ECS_TERM_REF_ID(&term->first) == EcsPredMatch)) && 
+        (term->first.id & EcsIsEntity)) 
+    {
+        ecs_strbuf_appendlit(buf, "$");
+        if (ECS_TERM_REF_ID(&term->src) == EcsThis && 
+           (term->src.id & EcsIsVariable))
+        {
+            ecs_strbuf_appendlit(buf, "this");
+        } else if (term->src.id & EcsIsVariable) {
+            ecs_strbuf_appendstr(buf, term->src.name);
+        } else {
+            /* Shouldn't happen */
         }
 
-        if (tgt && !ecs_id_is_wildcard(tgt)) {
-            /* Check if target of relationship satisfies OneOf property */
-            ecs_entity_t oneof = flecs_get_oneof(world, rel);
-            if (oneof) {
-                if (!ecs_has_pair(world, tgt, EcsChildOf, oneof)) {
-                    char *idstr = ecs_id_str(world, id);
-                    char *tgtstr = ecs_get_fullpath(world, tgt);
-                    char *oneofstr = ecs_get_fullpath(world, oneof);
-                    ecs_err("OneOf constraint violated: "
-                        "%s: '%s' is not a child of '%s'",
-                        idstr, tgtstr, oneofstr);
-                    ecs_os_free(oneofstr);
-                    ecs_os_free(tgtstr);
-                    ecs_os_free(idstr);
-                    #ifndef FLECS_SOFT_ASSERT
-                    ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
-                    #endif
-                }
+        if (ECS_TERM_REF_ID(&term->first) == EcsPredEq) {
+            if (term->oper == EcsNot) {
+                ecs_strbuf_appendlit(buf, " != ");
+            } else {
+                ecs_strbuf_appendlit(buf, " == ");
             }
+        } else if (ECS_TERM_REF_ID(&term->first) == EcsPredMatch) {
+            ecs_strbuf_appendlit(buf, " ~= ");
+        }
 
-            /* Check if we're not trying to inherit from a final target */
-            if (rel == EcsIsA) {
-                if (ecs_has_id(world, tgt, EcsFinal)) {
-                    char *idstr = ecs_id_str(world, id);
-                    char *tgtstr = ecs_get_fullpath(world, tgt);
-                    ecs_err("Final constraint violated: "
-                            "%s: cannot inherit from final entity '%s'",
-                        idstr, tgtstr);
-                    ecs_os_free(tgtstr);
-                    ecs_os_free(idstr);
-                    #ifndef FLECS_SOFT_ASSERT
-                    ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
-                    #endif
+        if (term->second.id & EcsIsEntity) {
+            if (term->second.id != 0) {
+                ecs_get_path_w_sep_buf(
+                    world, 0, ECS_TERM_REF_ID(&term->second), ".", NULL, buf);
+            }
+        } else {
+            if (term->second.id & EcsIsVariable) {
+                ecs_strbuf_appendlit(buf, "$");
+                if (term->second.name) {
+                    ecs_strbuf_appendstr(buf, term->second.name);
+                } else if (ECS_TERM_REF_ID(&term->second) == EcsThis) {
+                    ecs_strbuf_appendlit(buf, "this");
+                }
+            } else if (term->second.id & EcsIsName) {
+                ecs_strbuf_appendlit(buf, "\"");
+                if ((ECS_TERM_REF_ID(&term->first) == EcsPredMatch) && 
+                    (term->oper == EcsNot)) 
+                {
+                    ecs_strbuf_appendlit(buf, "!");
                 }
+                ecs_strbuf_appendstr(buf, term->second.name);
+                ecs_strbuf_appendlit(buf, "\"");
             }
         }
-#endif
 
-        if (!is_wildcard && (rel != EcsFlag)) {
-            /* Inherit flags from (relationship, *) record */
-            ecs_id_record_t *idr_r = flecs_id_record_ensure(
-                world, ecs_pair(rel, EcsWildcard));
-            idr->parent = idr_r;
-            idr->flags = idr_r->flags;
+        return;
+    }
 
-            /* If pair is not a wildcard, append it to wildcard lists. These 
-             * allow for quickly enumerating all relationships for an object, 
-             * or all objects for a relationship. */
-            flecs_insert_id_elem(world, idr, ecs_pair(rel, EcsWildcard), idr_r);
+    if (!t || !(term[-1].oper == EcsOr)) {
+        if (term->inout == EcsIn) {
+            ecs_strbuf_appendlit(buf, "[in] ");
+        } else if (term->inout == EcsInOut) {
+            ecs_strbuf_appendlit(buf, "[inout] ");
+        } else if (term->inout == EcsOut) {
+            ecs_strbuf_appendlit(buf, "[out] ");
+        } else if (term->inout == EcsInOutNone && term->oper != EcsNot) {
+            ecs_strbuf_appendlit(buf, "[none] ");
+        }
+    }
 
-            idr_t = flecs_id_record_ensure(world, ecs_pair(EcsWildcard, tgt));
-            flecs_insert_id_elem(world, idr, ecs_pair(EcsWildcard, tgt), idr_t);
+    if (term->first.id & EcsIsEntity && first_id) {
+        if (ecs_has_id(world, first_id, EcsDontInherit)) {
+            def_src_mask = EcsSelf;
+        }
+    }
+
+    if (term->oper == EcsNot) {
+        ecs_strbuf_appendlit(buf, "!");
+    } else if (term->oper == EcsOptional) {
+        ecs_strbuf_appendlit(buf, "?");
+    }
 
-            if (rel == EcsUnion) {
-                idr->flags |= EcsIdUnion;
+    if (!src_set) {
+        flecs_query_str_add_id(world, buf, term, &term->first, false, 
+            def_first_mask);
+        if (!second_set) {
+            ecs_strbuf_appendlit(buf, "()");
+        } else {
+            ecs_strbuf_appendlit(buf, "(0,");
+            flecs_query_str_add_id(world, buf, term, &term->second, false, 
+                def_second_mask);
+            ecs_strbuf_appendlit(buf, ")");
+        }
+    } else if (ecs_term_match_this(term) && 
+        (src->id & EcsTraverseFlags) == def_src_mask)
+    {
+        if (first_set) {
+            if (second_set) {
+                ecs_strbuf_appendlit(buf, "(");
+            }
+            flecs_query_str_add_id(world, buf, term, &term->first, false, 
+                def_first_mask);
+            if (second_set) {
+                ecs_strbuf_appendlit(buf, ",");
+                flecs_query_str_add_id(
+                    world, buf, term, &term->second, false, def_second_mask);
+                ecs_strbuf_appendlit(buf, ")");
             }
+        } else if (term->id) {
+            char *str = ecs_id_str(world, term->id);
+            ecs_strbuf_appendstr(buf, str);
+            ecs_os_free(str);
         }
     } else {
-        rel = id & ECS_COMPONENT_MASK;
-        ecs_assert(rel != 0, ECS_INTERNAL_ERROR, NULL);
-
-        /* Can't use relationship outside of a pair */
-#ifdef FLECS_DEBUG
-        rel = flecs_entities_get_alive(world, rel);
-        if (ecs_has_id(world, rel, EcsRelationship) ||
-            ecs_has_id(world, rel, EcsTarget)) 
-        {
-            char *idstr = ecs_id_str(world, id);
-            char *relstr = ecs_id_str(world, rel);
-            ecs_err("constraint violated: "
-                "%s: relationship '%s' cannot be used as component",
-                    idstr, relstr);
-            ecs_os_free(relstr);
-            ecs_os_free(idstr);
-            #ifndef FLECS_SOFT_ASSERT
-            ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
-            #endif
+        ecs_id_t flags = term->id & ECS_ID_FLAGS_MASK;
+        if (flags && !ECS_HAS_ID_FLAG(flags, PAIR)) {
+            ecs_strbuf_appendstr(buf, ecs_id_flag_str(flags));
+            ecs_strbuf_appendch(buf, '|');
         }
 
-        if (ecs_has_id(world, rel, EcsTarget)) {
-            char *idstr = ecs_id_str(world, id);
-            char *relstr = ecs_id_str(world, rel);
-            ecs_err("constraint violated: "
-                "%s: target '%s' cannot be used as component",
-                    idstr, relstr);
-            ecs_os_free(relstr);
-            ecs_os_free(idstr);
-            #ifndef FLECS_SOFT_ASSERT
-            ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
-            #endif
+        flecs_query_str_add_id(world, buf, term, &term->first, false, 
+            def_first_mask);
+        ecs_strbuf_appendlit(buf, "(");
+        if (term->src.id & EcsIsEntity && src_id == first_id) {
+            ecs_strbuf_appendlit(buf, "$");
+        } else {
+            flecs_query_str_add_id(world, buf, term, &term->src, true, 
+                def_src_mask);
         }
-#endif
-    }
-
-    /* Initialize type info if id is not a tag */
-    if (!is_wildcard && (!role || is_pair)) {
-        if (!(idr->flags & EcsIdTag)) {
-            const ecs_type_info_t *ti = flecs_type_info_get(world, rel);
-            if (!ti && tgt) {
-                ti = flecs_type_info_get(world, tgt);
-            }
-            idr->type_info = ti;
+        if (second_set) {
+            ecs_strbuf_appendlit(buf, ",");
+            flecs_query_str_add_id(world, buf, term, &term->second, false, 
+                def_second_mask);
         }
+        ecs_strbuf_appendlit(buf, ")");
     }
+}
 
-    /* Mark entities that are used as component/pair ids. When a tracked
-     * entity is deleted, cleanup policies are applied so that the store
-     * won't contain any tables with deleted ids. */
+char* ecs_term_str(
+    const ecs_world_t *world,
+    const ecs_term_t *term)
+{
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    flecs_term_str_w_strbuf(world, term, &buf, 0);
+    return ecs_strbuf_get(&buf);
+}
 
-    /* Flag for OnDelete policies */
-    flecs_add_flag(world, rel, EcsEntityIsId);
-    if (tgt) {
-        /* Flag for OnDeleteTarget policies */
-        ecs_record_t *tgt_r = flecs_entities_get_any(world, tgt);
-        ecs_assert(tgt_r != NULL, ECS_INTERNAL_ERROR, NULL);
-        flecs_record_add_flag(tgt_r, EcsEntityIsTarget);
-        if (idr->flags & EcsIdTraversable) {
-            /* Flag used to determine if object should be traversed when
-             * propagating events or with super/subset queries */
-            flecs_record_add_flag(tgt_r, EcsEntityIsTraversable);
+char* flecs_query_str(
+    const ecs_world_t *world,
+    const ecs_query_t *query,
+    const ecs_query_validator_ctx_t *ctx,
+    int32_t *term_start_out)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
 
-            /* Add reference to (*, tgt) id record to entity record */
-            tgt_r->idr = idr_t;
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    const ecs_term_t *terms = query->terms;
+    int32_t i, count = query->term_count;
+
+    for (i = 0; i < count; i ++) {
+        const ecs_term_t *term = &terms[i];
+
+        if (term_start_out && ctx) {
+            if (ctx->term_index == i) {
+                term_start_out[0] = ecs_strbuf_written(&buf);
+                if (i) {
+                    term_start_out[0] += 2; /* whitespace  + , */
+                }
+            }
         }
-    }
 
-    ecs_observable_t *o = &world->observable;
-    idr->flags |= flecs_observers_exist(o, id, EcsOnAdd) * EcsIdHasOnAdd;
-    idr->flags |= flecs_observers_exist(o, id, EcsOnRemove) * EcsIdHasOnRemove;
-    idr->flags |= flecs_observers_exist(o, id, EcsOnSet) * EcsIdHasOnSet;
-    idr->flags |= flecs_observers_exist(o, id, EcsUnSet) * EcsIdHasUnSet;
-    idr->flags |= flecs_observers_exist(o, id, EcsOnTableFill) * EcsIdHasOnTableFill;
-    idr->flags |= flecs_observers_exist(o, id, EcsOnTableEmpty) * EcsIdHasOnTableEmpty;
-    idr->flags |= flecs_observers_exist(o, id, EcsOnTableCreate) * EcsIdHasOnTableCreate;
-    idr->flags |= flecs_observers_exist(o, id, EcsOnTableDelete) * EcsIdHasOnTableDelete;
+        flecs_term_str_w_strbuf(world, term, &buf, i);
 
-    if (ecs_should_log_1()) {
-        char *id_str = ecs_id_str(world, id);
-        ecs_dbg_1("#[green]id#[normal] %s #[green]created", id_str);
-        ecs_os_free(id_str);
+        if (i != (count - 1)) {
+            if (term->oper == EcsOr) {
+                ecs_strbuf_appendlit(&buf, " || ");
+            } else {
+                if (ECS_TERM_REF_ID(&term->first) != EcsScopeOpen) {
+                    if (ECS_TERM_REF_ID(&term[1].first) != EcsScopeClose) {
+                        ecs_strbuf_appendlit(&buf, ", ");
+                    }
+                }
+            }
+        }
     }
 
-    /* Update counters */
-    world->info.id_create_total ++;
-    world->info.component_id_count += idr->type_info != NULL;
-    world->info.tag_id_count += idr->type_info == NULL;
-    world->info.pair_id_count += is_pair;
-
-    return idr;
+    return ecs_strbuf_get(&buf);
+error:
+    return NULL;
 }
 
-static
-void flecs_id_record_assert_empty(
-    ecs_id_record_t *idr)
+char* ecs_query_str(
+    const ecs_query_t *q)
 {
-    (void)idr;
-    ecs_assert(flecs_table_cache_count(&idr->cache) == 0, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(flecs_table_cache_empty_count(&idr->cache) == 0, 
-        ECS_INTERNAL_ERROR, NULL);
+    return flecs_query_str(q->world, q, NULL, NULL);
 }
 
-static
-void flecs_id_record_free(
-    ecs_world_t *world,
-    ecs_id_record_t *idr)
+int32_t flecs_query_pivot_term(
+    const ecs_world_t *world,
+    const ecs_query_t *query)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_id_t id = idr->id;
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    flecs_id_record_assert_empty(idr);
+    const ecs_term_t *terms = query->terms;
+    int32_t i, term_count = query->term_count;
+    int32_t pivot_term = -1, min_count = -1, self_pivot_term = -1;
 
-    /* Id is still in use by a filter, query, rule or observer */
-    ecs_assert((world->flags & EcsWorldQuit) || (idr->keep_alive == 0), 
-        ECS_ID_IN_USE, "cannot delete id that is queried for");
+    for (i = 0; i < term_count; i ++) {
+        const ecs_term_t *term = &terms[i];
+        ecs_id_t id = term->id;
 
-    if (ECS_IS_PAIR(id)) {
-        ecs_entity_t rel = ECS_PAIR_FIRST(id);
-        ecs_entity_t tgt = ECS_PAIR_SECOND(id);
-        if (!ecs_id_is_wildcard(id)) {
-            if (ECS_PAIR_FIRST(id) != EcsFlag) {
-                /* If id is not a wildcard, remove it from the wildcard lists */
-                flecs_remove_id_elem(idr, ecs_pair(rel, EcsWildcard));
-                flecs_remove_id_elem(idr, ecs_pair(EcsWildcard, tgt));
-            }
-        } else {
-            ecs_log_push_2();
+        if ((term->oper != EcsAnd) || (i && (term[-1].oper == EcsOr))) {
+            continue;
+        }
 
-            /* If id is a wildcard, it means that all id records that match the
-             * wildcard are also empty, so release them */
-            if (ECS_PAIR_FIRST(id) == EcsWildcard) {
-                /* Iterate (*, Target) list */
-                ecs_id_record_t *cur, *next = idr->second.next;
-                while ((cur = next)) {
-                    flecs_id_record_assert_empty(cur);
-                    next = cur->second.next;
-                    flecs_id_record_release(world, cur);
-                }
-            } else {
-                /* Iterate (Relationship, *) list */
-                ecs_assert(ECS_PAIR_SECOND(id) == EcsWildcard, 
-                    ECS_INTERNAL_ERROR, NULL);
-                ecs_id_record_t *cur, *next = idr->first.next;
-                while ((cur = next)) {
-                    flecs_id_record_assert_empty(cur);
-                    next = cur->first.next;
-                    flecs_id_record_release(world, cur);
-                }
-            }
+        if (!ecs_term_match_this(term)) {
+            continue;
+        }
 
-            ecs_log_pop_2();
+        ecs_id_record_t *idr = flecs_id_record_get(world, id);
+        if (!idr) {
+            /* If one of the terms does not match with any data, iterator 
+             * should not return anything */
+            return -2; /* -2 indicates query doesn't match anything */
+        }
+
+        int32_t table_count = flecs_table_cache_count(&idr->cache);
+        if (min_count == -1 || table_count < min_count) {
+            min_count = table_count;
+            pivot_term = i;
+            if ((term->src.id & EcsTraverseFlags) == EcsSelf) {
+                self_pivot_term = i;
+            }
         }
     }
 
-    /* Update counters */
-    world->info.id_delete_total ++;
-    world->info.pair_id_count -= ECS_IS_PAIR(id);
-    world->info.component_id_count -= idr->type_info != NULL;
-    world->info.tag_id_count -= idr->type_info == NULL;
+    if (self_pivot_term != -1) {
+        pivot_term = self_pivot_term;
+    }
 
-    /* Unregister the id record from the world & free resources */
-    ecs_table_cache_fini(&idr->cache);
-    flecs_name_index_free(idr->name_index);
-    ecs_vec_fini_t(&world->allocator, &idr->reachable.ids, ecs_reachable_elem_t);
+    return pivot_term;
+error:
+    return -2;
+}
 
-    ecs_id_t hash = flecs_id_record_hash(id);
-    if (hash >= FLECS_HI_ID_RECORD_ID) {
-        ecs_map_remove(&world->id_index_hi, hash);
-        flecs_bfree(&world->allocators.id_record, idr);
+void flecs_query_apply_iter_flags(
+    ecs_iter_t *it,
+    const ecs_query_t *query)
+{
+    ECS_BIT_COND(it->flags, EcsIterIsInstanced, 
+        ECS_BIT_IS_SET(query->flags, EcsQueryIsInstanced));
+    ECS_BIT_COND(it->flags, EcsIterNoData,
+        ECS_BIT_IS_SET(query->flags, EcsQueryNoData));
+    ECS_BIT_COND(it->flags, EcsIterHasCondSet, 
+        ECS_BIT_IS_SET(query->flags, EcsQueryHasCondSet));
+}
+
+/**
+ * @file validator.c
+ * @brief Validate and finalize queries.
+ */
+
+#include <ctype.h>
+
+#ifdef FLECS_SCRIPT
+#endif
+
+static
+void flecs_query_validator_error(
+    const ecs_query_validator_ctx_t *ctx,
+    const char *fmt,
+    ...)
+{
+    va_list args;
+    va_start(args, fmt);
+
+    int32_t term_start = 0;
+
+    char *expr = NULL;
+    if (ctx->query) {
+        expr = flecs_query_str(ctx->world, ctx->query, ctx, &term_start);
     } else {
-        idr->id = 0; /* Tombstone */
+        expr = ecs_term_str(ctx->world, ctx->term);
     }
-
-    if (ecs_should_log_1()) {
-        char *id_str = ecs_id_str(world, id);
-        ecs_dbg_1("#[green]id#[normal] %s #[red]deleted", id_str);
-        ecs_os_free(id_str);
+    const char *name = NULL;
+    if (ctx->query && ctx->query->entity) {
+        name = ecs_get_name(ctx->query->world, ctx->query->entity);
     }
+    ecs_parser_errorv(name, expr, term_start, fmt, args);
+    ecs_os_free(expr);
+
+    va_end(args);
 }
 
-ecs_id_record_t* flecs_id_record_ensure(
-    ecs_world_t *world,
-    ecs_id_t id)
+static
+int flecs_term_ref_finalize_flags(
+    ecs_term_ref_t *ref,
+    ecs_query_validator_ctx_t *ctx)
 {
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        idr = flecs_id_record_new(world, id);
+    if ((ref->id & EcsIsEntity) && (ref->id & EcsIsVariable)) {
+        flecs_query_validator_error(ctx, "cannot set both IsEntity and IsVariable");
+        return -1;
+    }
+
+    if (ref->name && ref->name[0] == '$') {
+        if (!ref->name[1]) {
+            if (ref->id & ~EcsTermRefFlags) {
+                flecs_query_validator_error(ctx, 
+                    "conflicting values for .name and .id");
+                return -1;
+            }
+
+            ref->id |= EcsVariable;
+        } else {
+            ref->name = &ref->name[1];
+        }
+
+        ref->id |= EcsIsVariable;
+    } 
+
+    if (!(ref->id & (EcsIsEntity|EcsIsVariable|EcsIsName))) {
+        if (ECS_TERM_REF_ID(ref) || ref->name) {
+            if (ECS_TERM_REF_ID(ref) == EcsThis || 
+                ECS_TERM_REF_ID(ref) == EcsWildcard || 
+                ECS_TERM_REF_ID(ref) == EcsAny || 
+                ECS_TERM_REF_ID(ref) == EcsVariable) 
+            {
+                /* Builtin variable ids default to variable */
+                ref->id |= EcsIsVariable;
+            } else {
+                ref->id |= EcsIsEntity;
+            }
+        }
     }
-    return idr;
+
+    return 0;
 }
 
-ecs_id_record_t* flecs_id_record_get(
+static
+int flecs_term_ref_lookup(
     const ecs_world_t *world,
-    ecs_id_t id)
+    ecs_entity_t scope,
+    ecs_term_ref_t *ref,
+    ecs_query_validator_ctx_t *ctx)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    if (id == ecs_pair(EcsIsA, EcsWildcard)) {
-        return world->idr_isa_wildcard;
-    } else if (id == ecs_pair(EcsChildOf, EcsWildcard)) {
-        return world->idr_childof_wildcard;
-    } else if (id == ecs_pair_t(EcsIdentifier, EcsName)) {
-        return world->idr_identifier_name;
+    const char *name = ref->name;
+    if (!name) {
+        return 0;
     }
 
-    ecs_id_t hash = flecs_id_record_hash(id);
-    ecs_id_record_t *idr = NULL;
-    if (hash >= FLECS_HI_ID_RECORD_ID) {
-        idr = ecs_map_get_deref(&world->id_index_hi, ecs_id_record_t, hash);
-    } else {
-        idr = &world->id_index_lo[hash];
-        if (!idr->id) {
-            idr = NULL;
+    if (ref->id & EcsIsVariable) {
+        if (!ecs_os_strcmp(name, "this")) {
+            ref->id = EcsThis | ECS_TERM_REF_FLAGS(ref);
+            ref->name = NULL;
+            return 0;
         }
+        return 0;
+    } else if (ref->id & EcsIsName) {
+        if (ref->name == NULL) {
+            flecs_query_validator_error(ctx, "IsName flag specified without name");
+            return -1;
+        }
+        return 0;
     }
 
-    return idr;
-}
+    ecs_assert(ref->id & EcsIsEntity, ECS_INTERNAL_ERROR, NULL);
 
-ecs_id_record_t* flecs_query_id_record_get(
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        ecs_entity_t first = ECS_PAIR_FIRST(id);
-        if (ECS_IS_PAIR(id) && (first != EcsWildcard)) {
-            idr = flecs_id_record_get(world, ecs_pair(EcsUnion, first));
+    if (flecs_identifier_is_0(name)) {
+        if (ECS_TERM_REF_ID(ref)) {
+            flecs_query_validator_error(
+                ctx, "name '0' does not match entity id");
+            return -1;
         }
-        return idr;
-    }
-    if (ECS_IS_PAIR(id) && 
-        ECS_PAIR_SECOND(id) == EcsWildcard && 
-        (idr->flags & EcsIdUnion)) 
-    {
-        idr = flecs_id_record_get(world, 
-            ecs_pair(EcsUnion, ECS_PAIR_FIRST(id)));
+        ref->name = NULL;
+        return 0;
     }
 
-    return idr;
-}
+    ecs_entity_t e = 0;
+    if (scope) {
+        e = ecs_lookup_child(world, scope, name);
+    }
 
-void flecs_id_record_claim(
-    ecs_world_t *world,
-    ecs_id_record_t *idr)
-{
-    (void)world;
-    idr->refcount ++;
-}
+    if (!e) {
+        e = ecs_lookup(world, name);
+    }
 
-int32_t flecs_id_record_release(
-    ecs_world_t *world,
-    ecs_id_record_t *idr)
-{
-    int32_t rc = -- idr->refcount;
-    ecs_assert(rc >= 0, ECS_INTERNAL_ERROR, NULL);
+    if (!e) {
+        if (ctx->query && (ctx->query->flags & EcsQueryAllowUnresolvedByName)) {
+            ref->id |= EcsIsName;
+            ref->id &= ~EcsIsEntity;
+            return 0;
+        } else {
+            flecs_query_validator_error(ctx, "unresolved identifier '%s'", name);
+            return -1;
+        }
+    }
 
-    if (!rc) {
-        flecs_id_record_free(world, idr);
+    ecs_entity_t ref_id = ECS_TERM_REF_ID(ref);
+    if (ref_id && ref_id != e) {
+        char *e_str = ecs_get_fullpath(world, ref_id);
+        flecs_query_validator_error(ctx, "name '%s' does not match term.id '%s'", 
+            name, e_str);
+        ecs_os_free(e_str);
+        return -1;
     }
 
-    return rc;
-}
+    ref->id = e | ECS_TERM_REF_FLAGS(ref);
+    ref_id = ECS_TERM_REF_ID(ref);
 
-void flecs_id_record_release_tables(
-    ecs_world_t *world,
-    ecs_id_record_t *idr)
-{
-    /* Cache should not contain tables that aren't empty */
-    ecs_assert(flecs_table_cache_count(&idr->cache) == 0, 
-        ECS_INTERNAL_ERROR, NULL);
+    if (!ecs_os_strcmp(name, "*") || !ecs_os_strcmp(name, "_") || 
+        !ecs_os_strcmp(name, "$")) 
+    {
+        ref->id &= ~EcsIsEntity;
+        ref->id |= EcsIsVariable;
+    }
 
-    ecs_table_cache_iter_t it;
-    if (flecs_table_cache_empty_iter(&idr->cache, &it)) {
-        ecs_table_record_t *tr;
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            /* Release current table */
-            flecs_table_free(world, tr->hdr.table);
+    /* Check if looked up id is alive (relevant for numerical ids) */
+    if (!(ref->id & EcsIsName) && ref_id) {
+        if (!ecs_is_alive(world, ref_id)) {
+            flecs_query_validator_error(ctx, "identifier '%s' is not alive", ref->name);
+            return -1;
         }
+
+        ref->name = NULL;
+        return 0;
     }
+
+    return 0;
 }
 
-bool flecs_id_record_set_type_info(
-    ecs_world_t *world,
-    ecs_id_record_t *idr,
-    const ecs_type_info_t *ti)
+static
+int flecs_term_refs_finalize(
+    const ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
 {
-    bool is_wildcard = ecs_id_is_wildcard(idr->id);
-    if (!is_wildcard) {
-        if (ti) {
-            if (!idr->type_info) {
-                world->info.tag_id_count --;
-                world->info.component_id_count ++;
-            }
-        } else {
-            if (idr->type_info) {
-                world->info.tag_id_count ++;
-                world->info.component_id_count --;
-            }
+    ecs_term_ref_t *src = &term->src;
+    ecs_term_ref_t *first = &term->first;
+    ecs_term_ref_t *second = &term->second;
+
+    if ((term->src.id & EcsCascade) && !(term->src.id & EcsUp)) {
+        /* If cascade is specified without up/down, add up */
+        term->src.id |= EcsUp;
+    }
+
+    if (!(src->id & EcsTraverseFlags)) {
+        /* When no traversal flags are specified, the default traversal 
+         * relationship is IsA so inherited components are matched by default */
+        src->id |= EcsSelf | EcsUp;
+        if (!term->trav) {
+            term->trav = EcsIsA;
         }
+    } else if ((src->id & EcsUp) && !term->trav) {
+        /* When traversal flags are specified but no traversal relationship,
+         * default to ChildOf, which is the most common kind of traversal. */
+        term->trav = EcsChildOf;
     }
 
-    bool changed = idr->type_info != ti;
-    idr->type_info = ti;
+    /* Include subsets for component by default, to support inheritance */
+    if (!(first->id & EcsTraverseFlags)) {
+        first->id |= EcsSelf;
+    }
 
-    return changed;
-}
+    /* Traverse Self by default for pair target */
+    if (!(second->id & EcsTraverseFlags)) {
+        if (ECS_TERM_REF_ID(second) || second->name || (second->id & EcsIsEntity)) {
+            second->id |= EcsSelf;
+        }
+    }
 
-ecs_hashmap_t* flecs_id_record_name_index_ensure(
-    ecs_world_t *world,
-    ecs_id_record_t *idr)
-{
-    ecs_hashmap_t *map = idr->name_index;
-    if (!map) {
-        map = idr->name_index = flecs_name_index_new(world, &world->allocator);
+    /* Source defaults to This */
+    if (!ECS_TERM_REF_ID(src) && (src->name == NULL) && !(src->id & EcsIsEntity)) {
+        src->id = EcsThis | ECS_TERM_REF_FLAGS(src);
+        src->id |= EcsIsVariable;
     }
 
-    return map;
-}
+    /* Initialize term identifier flags */
+    if (flecs_term_ref_finalize_flags(src, ctx)) {
+        return -1;
+    }
 
-ecs_hashmap_t* flecs_id_name_index_ensure(
-    ecs_world_t *world,
-    ecs_id_t id)
-{
-    ecs_poly_assert(world, ecs_world_t);
+    if (flecs_term_ref_finalize_flags(first, ctx)) {
+        return -1;
+    }
 
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (flecs_term_ref_finalize_flags(second, ctx)) {
+        return -1;
+    }
 
-    return flecs_id_record_name_index_ensure(world, idr);
-}
+    /* Lookup term identifiers by name */
+    if (flecs_term_ref_lookup(world, 0, src, ctx)) {
+        return -1;
+    }
+    if (flecs_term_ref_lookup(world, 0, first, ctx)) {
+        return -1;
+    }
 
-ecs_hashmap_t* flecs_id_name_index_get(
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    ecs_poly_assert(world, ecs_world_t);
+    ecs_entity_t first_id = 0;
+    ecs_entity_t oneof = 0;
+    if (first->id & EcsIsEntity) {
+        first_id = ECS_TERM_REF_ID(first);
 
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return NULL;
+        if (!first_id) {
+            flecs_query_validator_error(ctx, "invalid \"0\" for first.name");
+            return -1;
+        }
+
+        /* If first element of pair has OneOf property, lookup second element of
+         * pair in the value of the OneOf property */
+        oneof = flecs_get_oneof(world, first_id);
     }
 
-    return idr->name_index;
-}
+    if (flecs_term_ref_lookup(world, oneof, &term->second, ctx)) {
+        return -1;
+    }
 
-ecs_table_record_t* flecs_table_record_get(
-    const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_id_t id)
-{
-    ecs_poly_assert(world, ecs_world_t);
+    /* If source is 0, reset traversal flags */
+    if (ECS_TERM_REF_ID(src) == 0 && src->id & EcsIsEntity) {
+        src->id &= ~EcsTraverseFlags;
+        term->trav = 0;
+    }
 
-    ecs_id_record_t* idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return NULL;
+    /* If source is wildcard, term won't return any data */
+    if ((src->id & EcsIsVariable) && ecs_id_is_wildcard(ECS_TERM_REF_ID(src))) {
+        term->inout = EcsInOutNone;
     }
 
-    return (ecs_table_record_t*)ecs_table_cache_get(&idr->cache, table);
+    return 0;
 }
 
-ecs_table_record_t* flecs_id_record_get_table(
-    const ecs_id_record_t *idr,
-    const ecs_table_t *table)
+static
+ecs_entity_t flecs_term_ref_get_entity(
+    const ecs_term_ref_t *ref)
 {
-    ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-    return (ecs_table_record_t*)ecs_table_cache_get(&idr->cache, table);
+    if (ref->id & EcsIsEntity) {
+        return ECS_TERM_REF_ID(ref); /* Id is known */
+    } else if (ref->id & EcsIsVariable) {
+        /* Return wildcard for variables, as they aren't known yet */
+        if (ECS_TERM_REF_ID(ref) != EcsAny) {
+            /* Any variable should not use wildcard, as this would return all
+             * ids matching a wildcard, whereas Any returns the first match */
+            return EcsWildcard;
+        } else {
+            return EcsAny;
+        }
+    } else {
+        return 0; /* Term id is uninitialized */
+    }
 }
 
-void flecs_init_id_records(
-    ecs_world_t *world)
+static
+int flecs_term_populate_id(
+    ecs_term_t *term)
 {
-    /* Cache often used id records on world */
-    world->idr_wildcard = flecs_id_record_ensure(world, EcsWildcard);
-    world->idr_wildcard_wildcard = flecs_id_record_ensure(world, 
-        ecs_pair(EcsWildcard, EcsWildcard));
-    world->idr_any = flecs_id_record_ensure(world, EcsAny);
-    world->idr_isa_wildcard = flecs_id_record_ensure(world, 
-        ecs_pair(EcsIsA, EcsWildcard));
-}
+    ecs_entity_t first = flecs_term_ref_get_entity(&term->first);
+    ecs_entity_t second = flecs_term_ref_get_entity(&term->second);
+    ecs_id_t flags = term->id & ECS_ID_FLAGS_MASK;
 
-void flecs_fini_id_records(
-    ecs_world_t *world)
-{
-    /* Loop & delete first element until there are no elements left. Id records
-     * can recursively delete each other, this ensures we always have a
-     * valid iterator. */
-    while (ecs_map_count(&world->id_index_hi) > 0) {
-        ecs_map_iter_t it = ecs_map_iter(&world->id_index_hi);
-        ecs_map_next(&it);
-        flecs_id_record_release(world, ecs_map_ptr(&it));
+    if (first & ECS_ID_FLAGS_MASK) {
+        return -1;
+    }
+    if (second & ECS_ID_FLAGS_MASK) {
+        return -1;
     }
 
-    int32_t i;
-    for (i = 0; i < FLECS_HI_ID_RECORD_ID; i ++) {
-        ecs_id_record_t *idr = &world->id_index_lo[i];
-        if (idr->id) {
-            flecs_id_record_release(world, idr);
-        }
+    if ((second || (term->second.id & EcsIsEntity))) {
+        flags |= ECS_PAIR;
     }
 
-    ecs_assert(ecs_map_count(&world->id_index_hi) == 0, 
-        ECS_INTERNAL_ERROR, NULL);
+    if (!second && !ECS_HAS_ID_FLAG(flags, PAIR)) {
+        term->id = first | flags;
+    } else {
+        term->id = ecs_pair(first, second) | flags;
+    }
 
-    ecs_map_fini(&world->id_index_hi);
-    ecs_os_free(world->id_index_lo);
+    return 0;
 }
 
-/**
- * @file table.c
- * @brief Table storage implementation.
- * 
- * Tables are the data structure that store the component data. Tables have
- * columns for each component in the table, and rows for each entity stored in
- * the table. Once created, the component list for a table doesn't change, but
- * entities can move from one table to another.
- * 
- * Each table has a type, which is a vector with the (component) ids in the 
- * table. The vector is sorted by id, which ensures that there can be only one
- * table for each unique combination of components.
- * 
- * Not all ids in a table have to be components. Tags are ids that have no
- * data type associated with them, and as a result don't need to be explicitly
- * stored beyond an element in the table type. To save space and speed up table
- * creation, each table has a reference to a "storage table", which is a table
- * that only includes component ids (so excluding tags).
- * 
- * Note that the actual data is not stored on the storage table. The storage 
- * table is only used for sharing administration. A column_map member maps
- * between column indices of the table and its storage table. Tables are 
- * refcounted, which ensures that storage tables won't be deleted if other
- * tables have references to it.
- */
-
-
-/* Table sanity check to detect storage issues. Only enabled in SANITIZE mode as
- * this can severely slow down many ECS operations. */
-#ifdef FLECS_SANITIZE
 static
-void flecs_table_check_sanity(ecs_table_t *table) {
-    int32_t size = ecs_vec_size(&table->data.entities);
-    int32_t count = ecs_vec_count(&table->data.entities);
-
-    int32_t i;
-    int32_t sw_offset = table->_ ? table->_->sw_offset : 0;
-    int32_t sw_count = table->_ ? table->_->sw_count : 0;
-    int32_t bs_offset = table->_ ? table->_->bs_offset : 0;
-    int32_t bs_count = table->_ ? table->_->bs_count : 0;
-    int32_t type_count = table->type.count;
-    ecs_id_t *ids = table->type.array;
-
-    ecs_assert((sw_count + sw_offset) <= type_count, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert((bs_count + bs_offset) <= type_count, ECS_INTERNAL_ERROR, NULL);
-
-    if (table->column_count) {
-        int32_t column_count = table->column_count;
-        ecs_assert(type_count >= column_count, ECS_INTERNAL_ERROR, NULL);
-
-        int32_t *column_map = table->column_map;
-        ecs_assert(column_map != NULL, ECS_INTERNAL_ERROR, NULL);
+int flecs_term_populate_from_id(
+    const ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
+{
+    ecs_entity_t first = 0;
+    ecs_entity_t second = 0;
 
-        ecs_assert(table->data.columns != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (ECS_HAS_ID_FLAG(term->id, PAIR)) {
+        first = ECS_PAIR_FIRST(term->id);
+        second = ECS_PAIR_SECOND(term->id);
 
-        for (i = 0; i < column_count; i ++) {
-            ecs_vec_t *column = &table->data.columns[i].data;
-            ecs_assert(size == column->size, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(count == column->count, ECS_INTERNAL_ERROR, NULL);
-            int32_t column_map_id = column_map[i + type_count];
-            ecs_assert(column_map_id >= 0, ECS_INTERNAL_ERROR, NULL);
+        if (!first) {
+            flecs_query_validator_error(ctx, "missing first element in term.id");
+            return -1;
+        }
+        if (!second) {
+            if (first != EcsChildOf) {
+                flecs_query_validator_error(ctx, "missing second element in term.id");
+                return -1;
+            } else {
+                /* (ChildOf, 0) is allowed so query can be used to efficiently
+                 * query for root entities */
+            }
         }
     } else {
-        ecs_assert(table->column_map == NULL, ECS_INTERNAL_ERROR, NULL);
+        first = term->id & ECS_COMPONENT_MASK;
+        if (!first) {
+            flecs_query_validator_error(ctx, "missing first element in term.id");
+            return -1;
+        }
     }
 
-    if (sw_count) {
-        ecs_assert(table->_->sw_columns != NULL, 
-            ECS_INTERNAL_ERROR, NULL);
-        for (i = 0; i < sw_count; i ++) {
-            ecs_switch_t *sw = &table->_->sw_columns[i];
-            ecs_assert(ecs_vec_count(&sw->values) == count, 
-                ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(ECS_PAIR_FIRST(ids[i + sw_offset]) == EcsUnion,
-                ECS_INTERNAL_ERROR, NULL);
+    ecs_entity_t term_first = flecs_term_ref_get_entity(&term->first);
+    if (term_first) {
+        if ((uint32_t)term_first != (uint32_t)first) {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.first");
+            return -1;
+        }
+    } else {
+        ecs_entity_t first_id = ecs_get_alive(world, first);
+        if (!first_id) {
+            term->first.id = first | ECS_TERM_REF_FLAGS(&term->first);
+        } else {
+            term->first.id = first_id | ECS_TERM_REF_FLAGS(&term->first);
         }
     }
 
-    if (bs_count) {
-        ecs_assert(table->_->bs_columns != NULL, 
-            ECS_INTERNAL_ERROR, NULL);
-        for (i = 0; i < bs_count; i ++) {
-            ecs_bitset_t *bs = &table->_->bs_columns[i];
-            ecs_assert(flecs_bitset_count(bs) == count,
-                ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(ECS_HAS_ID_FLAG(ids[i + bs_offset], TOGGLE),
-                ECS_INTERNAL_ERROR, NULL);
+    ecs_entity_t term_second = flecs_term_ref_get_entity(&term->second);
+    if (term_second) {
+        if ((uint32_t)term_second != second) {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.second");
+            return -1;
+        }
+    } else if (second) {
+        ecs_entity_t second_id = ecs_get_alive(world, second);
+        if (!second_id) {
+            term->second.id = second | ECS_TERM_REF_FLAGS(&term->second);
+        } else {
+            term->second.id = second_id | ECS_TERM_REF_FLAGS(&term->second);
         }
     }
 
-    ecs_assert((table->_->traversable_count == 0) || 
-        (table->flags & EcsTableHasTraversable), ECS_INTERNAL_ERROR, NULL);
+    return 0;
 }
-#else
-#define flecs_table_check_sanity(table)
-#endif
 
-/* Set flags for type hooks so table operations can quickly check whether a
- * fast or complex operation that invokes hooks is required. */
 static
-ecs_flags32_t flecs_type_info_flags(
-    const ecs_type_info_t *ti) 
+int flecs_term_verify_eq_pred(
+    const ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
 {
-    ecs_flags32_t flags = 0;
+    const ecs_term_ref_t *second = &term->second;
+    const ecs_term_ref_t *src = &term->src;
+    ecs_entity_t first_id = ECS_TERM_REF_ID(&term->first);
+    ecs_entity_t second_id = ECS_TERM_REF_ID(&term->second);
+    ecs_entity_t src_id = ECS_TERM_REF_ID(&term->src);
 
-    if (ti->hooks.ctor) {
-        flags |= EcsTableHasCtors;
+    if (term->oper != EcsAnd && term->oper != EcsNot && term->oper != EcsOr) {
+        flecs_query_validator_error(ctx, "invalid operator combination");
+        goto error;
     }
-    if (ti->hooks.on_add) {
-        flags |= EcsTableHasCtors;
+
+    if ((src->id & EcsIsName) && (second->id & EcsIsName)) {
+        flecs_query_validator_error(ctx, "both sides of operator cannot be a name");
+        goto error;
     }
-    if (ti->hooks.dtor) {
-        flags |= EcsTableHasDtors;
+
+    if ((src->id & EcsIsEntity) && (second->id & EcsIsEntity)) {
+        flecs_query_validator_error(ctx, "both sides of operator cannot be an entity");
+        goto error;
     }
-    if (ti->hooks.on_remove) {
-        flags |= EcsTableHasDtors;
+
+    if (!(src->id & EcsIsVariable)) {
+        flecs_query_validator_error(ctx, "left-hand of operator must be a variable");
+        goto error;
     }
-    if (ti->hooks.copy) {
-        flags |= EcsTableHasCopy;
+
+    if (first_id == EcsPredMatch && !(second->id & EcsIsName)) {
+        flecs_query_validator_error(ctx, "right-hand of match operator must be a string");
+        goto error;
     }
-    if (ti->hooks.move) {
-        flags |= EcsTableHasMove;
-    }  
 
-    return flags;  
+    if ((src->id & EcsIsVariable) && (second->id & EcsIsVariable)) {
+        if (src_id && src_id == second_id) {
+            flecs_query_validator_error(ctx, "both sides of operator are equal");
+            goto error;
+        }
+        if (src->name && second->name && !ecs_os_strcmp(src->name, second->name)) {
+            flecs_query_validator_error(ctx, "both sides of operator are equal");
+            goto error;
+        }
+    }
+
+    return 0;
+error:
+    return -1;
 }
 
 static
-void flecs_table_init_columns(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    int32_t column_count)
+int flecs_term_verify(
+    const ecs_world_t *world,
+    const ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
 {
-    if (!column_count) {
-        return;
+    const ecs_term_ref_t *first = &term->first;
+    const ecs_term_ref_t *second = &term->second;
+    const ecs_term_ref_t *src = &term->src;
+    ecs_entity_t first_id = 0, second_id = 0;
+    ecs_id_t flags = term->id & ECS_ID_FLAGS_MASK;
+    ecs_id_t id = term->id;
+
+    if ((src->id & EcsIsName) && (second->id & EcsIsName)) {
+        flecs_query_validator_error(ctx, "mismatch between term.id_flags & term.id");
+        return -1;
     }
 
-    int32_t i, cur = 0, ids_count = table->type.count;
-    ecs_column_t *columns = flecs_wcalloc_n(world, ecs_column_t, column_count);
-    table->data.columns = columns;
+    ecs_entity_t src_id = ECS_TERM_REF_ID(src);
+    if (first->id & EcsIsEntity) {
+        first_id = ECS_TERM_REF_ID(first);
+    }
 
-    ecs_id_t *ids = table->type.array;
-    ecs_table_record_t *records = table->_->records;
-    int32_t *t2s = table->column_map;
-    int32_t *s2t = &table->column_map[ids_count];
+    if (second->id & EcsIsEntity) {
+        second_id = ECS_TERM_REF_ID(second);
+    }
 
-    for (i = 0; i < ids_count; i ++) {
-        ecs_table_record_t *tr = &records[i];
-        ecs_id_record_t *idr = (ecs_id_record_t*)tr->hdr.cache;
-        const ecs_type_info_t *ti = idr->type_info;
-        if (!ti) {
-            t2s[i] = -1;
-            continue;
+    if (first_id == EcsPredEq || first_id == EcsPredMatch || first_id == EcsPredLookup) {
+        return flecs_term_verify_eq_pred(term, ctx);
+    }
+
+    if (ecs_term_ref_is_set(second) && !ECS_HAS_ID_FLAG(flags, PAIR)) {
+        flecs_query_validator_error(ctx, "expected PAIR flag for term with pair");
+        return -1;
+    } else if (!ecs_term_ref_is_set(second) && ECS_HAS_ID_FLAG(flags, PAIR)) {
+        if (first_id != EcsChildOf) {
+            flecs_query_validator_error(ctx, "unexpected PAIR flag for term without pair");
+            return -1;
+        } else {
+            /* Exception is made for ChildOf so we can use (ChildOf, 0) to match
+             * all entities in the root */
         }
+    }
 
-        t2s[i] = cur;
-        s2t[cur] = i;
-        tr->column = flecs_ito(int16_t, cur);
+    if (!ecs_term_ref_is_set(src)) {
+        flecs_query_validator_error(ctx, "term.src is not initialized");
+        return -1;
+    }
 
-        columns[cur].ti = ECS_CONST_CAST(ecs_type_info_t*, ti);
-        columns[cur].id = ids[i];
-        columns[cur].size = ti->size;
+    if (!ecs_term_ref_is_set(first)) {
+        flecs_query_validator_error(ctx, "term.first is not initialized");
+        return -1;
+    }
 
-        if (ECS_IS_PAIR(ids[i])) {
-            ecs_table_record_t *wc_tr = flecs_id_record_get_table(
-                idr->parent, table);
-            if (wc_tr->index == tr->index) {
-                wc_tr->column = tr->column;
-            }
+    if (ECS_HAS_ID_FLAG(flags, PAIR)) {
+        if (!ECS_PAIR_FIRST(id)) {
+            flecs_query_validator_error(ctx, "invalid 0 for first element in pair id");
+            return -1;
+        }
+        if ((ECS_PAIR_FIRST(id) != EcsChildOf) && !ECS_PAIR_SECOND(id)) {
+            flecs_query_validator_error(ctx, "invalid 0 for second element in pair id");
+            return -1;
         }
 
-#ifdef FLECS_DEBUG
-        ecs_vec_init(NULL, &columns[cur].data, ti->size, 0);
-#endif
+        if ((first->id & EcsIsEntity) && 
+            (ecs_entity_t_lo(first_id) != ECS_PAIR_FIRST(id))) 
+        {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.first");
+            return -1;
+        }
+        if ((first->id & EcsIsVariable) && 
+            !ecs_id_is_wildcard(ECS_PAIR_FIRST(id)))
+        {
+            char *id_str = ecs_id_str(world, id);
+            flecs_query_validator_error(ctx, 
+                "expected wildcard for variable term.first (got %s)", id_str);
+            ecs_os_free(id_str);
+            return -1;
+        }
 
-        table->flags |= flecs_type_info_flags(ti);
-        cur ++;
+        if ((second->id & EcsIsEntity) && 
+            (ecs_entity_t_lo(second_id) != ECS_PAIR_SECOND(id))) 
+        {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.second");
+            return -1;
+        }
+        if ((second->id & EcsIsVariable) && 
+            !ecs_id_is_wildcard(ECS_PAIR_SECOND(id))) 
+        {
+            char *id_str = ecs_id_str(world, id);
+            flecs_query_validator_error(ctx, 
+                "expected wildcard for variable term.second (got %s)", id_str);
+            ecs_os_free(id_str);
+            return -1;
+        }
+    } else {
+        ecs_entity_t component = id & ECS_COMPONENT_MASK;
+        if (!component) {
+            flecs_query_validator_error(ctx, "missing component id");
+            return -1;
+        }
+        if ((first->id & EcsIsEntity) && 
+            (ecs_entity_t_lo(first_id) != ecs_entity_t_lo(component))) 
+        {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.first");
+            return -1;
+        }
+        if ((first->id & EcsIsVariable) && !ecs_id_is_wildcard(component)) {
+            char *id_str = ecs_id_str(world, id);
+            flecs_query_validator_error(ctx, 
+                "expected wildcard for variable term.first (got %s)", id_str);
+            ecs_os_free(id_str);
+            return -1;
+        }
     }
-}
-
-/* Initialize table storage */
-void flecs_table_init_data(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    ecs_data_t *storage = &table->data;
-    ecs_vec_init_t(NULL, &storage->entities, ecs_entity_t, 0);
 
-    flecs_table_init_columns(world, table, table->column_count);
+    if (first_id) {
+        if (ecs_term_ref_is_set(second)) {
+            ecs_flags64_t mask = EcsIsEntity | EcsIsVariable;
+            if ((src->id & mask) == (second->id & mask)) {
+                bool is_same = false;
+                if (src->id & EcsIsEntity) {
+                    is_same = src_id == second_id;
+                } else if (src->name && second->name) {
+                    is_same = !ecs_os_strcmp(src->name, second->name);
+                }
 
-    ecs_table__t *meta = table->_;
-    int32_t i, sw_count = meta->sw_count;
-    int32_t bs_count = meta->bs_count;
+                if (is_same && ecs_has_id(world, first_id, EcsAcyclic)
+                    && !(term->flags_ & EcsTermReflexive)) 
+                {
+                    char *pred_str = ecs_get_fullpath(world, term->first.id);
+                    flecs_query_validator_error(ctx, "term with acyclic relationship"
+                        " '%s' cannot have same subject and object",
+                            pred_str);
+                    ecs_os_free(pred_str);
+                    return -1;
+                }
+            }
+        }
 
-    if (sw_count) {
-        meta->sw_columns = flecs_wcalloc_n(world, ecs_switch_t, sw_count);
-        for (i = 0; i < sw_count; i ++) {
-            flecs_switch_init(&meta->sw_columns[i], 
-                &world->allocator, 0);
+        if (second_id && !ecs_id_is_wildcard(second_id)) {
+            ecs_entity_t oneof = flecs_get_oneof(world, first_id);
+            if (oneof) {
+                if (!ecs_has_pair(world, second_id, EcsChildOf, oneof)) {
+                    char *second_str = ecs_get_fullpath(world, second_id);
+                    char *oneof_str = ecs_get_fullpath(world, oneof);
+                    char *id_str = ecs_id_str(world, term->id);
+                    flecs_query_validator_error(ctx, 
+                        "invalid target '%s' for %s: must be child of '%s'",
+                            second_str, id_str, oneof_str);
+                    ecs_os_free(second_str);
+                    ecs_os_free(oneof_str);
+                    ecs_os_free(id_str);
+                    return -1;
+                }
+            }
         }
     }
 
-    if (bs_count) {
-        meta->bs_columns = flecs_wcalloc_n(world, ecs_bitset_t, bs_count);
-        for (i = 0; i < bs_count; i ++) {
-            flecs_bitset_init(&meta->bs_columns[i]);
+    if (term->trav) {
+        if (!ecs_has_id(world, term->trav, EcsTraversable)) {
+            char *r_str = ecs_get_fullpath(world, term->trav);
+            flecs_query_validator_error(ctx, 
+                "cannot traverse non-traversable relationship '%s'", r_str);
+            ecs_os_free(r_str);
+            return -1;
         }
     }
+
+    return 0;
 }
 
-/* Initialize table flags. Table flags are used in lots of scenarios to quickly
- * check the features of a table without having to inspect the table type. Table
- * flags are typically used to early-out of potentially expensive operations. */
 static
-void flecs_table_init_flags(
-    ecs_world_t *world,
-    ecs_table_t *table)
+int flecs_term_finalize(
+    const ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
 {
-    ecs_id_t *ids = table->type.array;
-    int32_t count = table->type.count;
-
-    int32_t i;
-    for (i = 0; i < count; i ++) {
-        ecs_id_t id = ids[i];
-
-        if (id <= EcsLastInternalComponentId) {
-            table->flags |= EcsTableHasBuiltins;
-        }
-
-        if (id == EcsModule) {
-            table->flags |= EcsTableHasBuiltins;
-            table->flags |= EcsTableHasModule;
-        } else if (id == EcsPrefab) {
-            table->flags |= EcsTableIsPrefab;
-        } else if (id == EcsDisabled) {
-            table->flags |= EcsTableIsDisabled;
-        } else {
-            if (ECS_IS_PAIR(id)) {
-                ecs_entity_t r = ECS_PAIR_FIRST(id);
+    ctx->term = term;
 
-                table->flags |= EcsTableHasPairs;
+    ecs_term_ref_t *src = &term->src;
+    ecs_term_ref_t *first = &term->first;
+    ecs_term_ref_t *second = &term->second;
+    ecs_flags64_t src_flags = ECS_TERM_REF_FLAGS(src);
+    ecs_flags64_t first_flags = ECS_TERM_REF_FLAGS(first);
+    ecs_flags64_t second_flags = ECS_TERM_REF_FLAGS(second);
 
-                if (r == EcsIsA) {
-                    table->flags |= EcsTableHasIsA;
-                } else if (r == EcsChildOf) {
-                    table->flags |= EcsTableHasChildOf;
-                    ecs_entity_t obj = ecs_pair_second(world, id);
-                    ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL);
+    if (first->name && (first->id & ~EcsTermRefFlags)) {
+        flecs_query_validator_error(ctx, 
+            "first.name and first.id have competing values");
+        return -1;
+    }
+    if (src->name && (src->id & ~EcsTermRefFlags)) {
+        flecs_query_validator_error(ctx, 
+            "src.name and src.id have competing values");
+        return -1;
+    }
+    if (second->name && (second->id & ~EcsTermRefFlags)) {
+        flecs_query_validator_error(ctx, 
+            "second.name and second.id have competing values");
+        return -1;
+    }
 
-                    if (obj == EcsFlecs || obj == EcsFlecsCore || 
-                        ecs_has_id(world, obj, EcsModule)) 
-                    {
-                        /* If table contains entities that are inside one of the 
-                         * builtin modules, it contains builtin entities */
-                        table->flags |= EcsTableHasBuiltins;
-                        table->flags |= EcsTableHasModule;
-                    }
-                } else if (id == ecs_pair_t(EcsIdentifier, EcsName)) {
-                    table->flags |= EcsTableHasName;
-                } else if (r == EcsUnion) {
-                    ecs_table__t *meta = table->_;
-                    table->flags |= EcsTableHasUnion;
 
-                    if (!meta->sw_count) {
-                        meta->sw_offset = flecs_ito(int16_t, i);
-                    }
-                    meta->sw_count ++;
-                } else if (r == ecs_id(EcsFlattenTarget)) {
-                    ecs_table__t *meta = table->_;
-                    table->flags |= EcsTableHasTarget;
-                    meta->ft_offset = flecs_ito(int16_t, i);
-                } else if (r == ecs_id(EcsPoly)) {
-                    table->flags |= EcsTableHasBuiltins;
-                }
-            } else {
-                if (ECS_HAS_ID_FLAG(id, TOGGLE)) {
-                    ecs_table__t *meta = table->_;
-                    table->flags |= EcsTableHasToggle;
+    if (term->id & ~ECS_ID_FLAGS_MASK) {
+        if (flecs_term_populate_from_id(world, term, ctx)) {
+            return -1;
+        }
+    }
 
-                    if (!meta->bs_count) {
-                        meta->bs_offset = flecs_ito(int16_t, i);
-                    }
-                    meta->bs_count ++;
-                }
-                if (ECS_HAS_ID_FLAG(id, OVERRIDE)) {
-                    table->flags |= EcsTableHasOverrides;
-                }
-            }
-        } 
+    if (flecs_term_refs_finalize(world, term, ctx)) {
+        return -1;
     }
-}
 
-/* Utility function that appends an element to the table record array */
-static
-void flecs_table_append_to_records(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_vec_t *records,
-    ecs_id_t id,
-    int32_t column)
-{
-    /* To avoid a quadratic search, use the O(1) lookup that the index
-     * already provides. */
-    ecs_id_record_t *idr = flecs_id_record_ensure(world, id);
-    ecs_table_record_t *tr = (ecs_table_record_t*)flecs_id_record_get_table(
-            idr, table);
-    if (!tr) {
-        tr = ecs_vec_append_t(&world->allocator, records, ecs_table_record_t);
-        tr->index = flecs_ito(int16_t, column);
-        tr->count = 1;
+    ecs_entity_t first_id = ECS_TERM_REF_ID(first);
+    ecs_entity_t second_id = ECS_TERM_REF_ID(second);
+    ecs_entity_t src_id = ECS_TERM_REF_ID(src);
 
-        ecs_table_cache_insert(&idr->cache, table, &tr->hdr);
-    } else {
-        tr->count ++;
+    if ((first->id & EcsIsVariable) && (first_id == EcsAny)) {
+        term->flags_ |= EcsTermMatchAny;
     }
 
-    ecs_assert(tr->hdr.cache != NULL, ECS_INTERNAL_ERROR, NULL);
-}
+    if ((second->id & EcsIsVariable) && (second_id == EcsAny)) {
+        term->flags_ |= EcsTermMatchAny;
+    }
 
-/* Main table initialization function */
-void flecs_table_init(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_table_t *from)
-{
-    /* Make sure table->flags is initialized */
-    flecs_table_init_flags(world, table);
+    if ((src->id & EcsIsVariable) && (src_id == EcsAny)) {
+        term->flags_ |= EcsTermMatchAnySrc;
+    }
 
-    /* The following code walks the table type to discover which id records the
-     * table needs to register table records with. 
-     *
-     * In addition to registering itself with id records for each id in the
-     * table type, a table also registers itself with wildcard id records. For
-     * example, if a table contains (Eats, Apples), it will register itself with
-     * wildcard id records (Eats, *),  (*, Apples) and (*, *). This makes it
-     * easier for wildcard queries to find the relevant tables. */
+    ecs_flags64_t ent_var_mask = EcsIsEntity | EcsIsVariable;
 
-    int32_t dst_i = 0, dst_count = table->type.count;
-    int32_t src_i = 0, src_count = 0;
-    ecs_id_t *dst_ids = table->type.array;
-    ecs_id_t *src_ids = NULL;
-    ecs_table_record_t *tr = NULL, *src_tr = NULL;
-    if (from) {
-        src_count = from->type.count;
-        src_ids = from->type.array;
-        src_tr = from->_->records;
+    /* If EcsVariable is used by itself, assign to predicate (singleton) */
+    if ((ECS_TERM_REF_ID(src) == EcsVariable) && (src->id & EcsIsVariable)) {
+        src->id = first->id | ECS_TERM_REF_FLAGS(src);
+        src->id &= ~ent_var_mask;
+        src->id |= first->id & ent_var_mask;
+        src->name = first->name;
     }
 
-    /* We don't know in advance how large the records array will be, so use
-     * cached vector. This eliminates unnecessary allocations, and/or expensive
-     * iterations to determine how many records we need. */
-    ecs_allocator_t *a = &world->allocator;
-    ecs_vec_t *records = &world->store.records;
-    ecs_vec_reset_t(a, records, ecs_table_record_t);
-    ecs_id_record_t *idr, *childof_idr = NULL;
-
-    int32_t last_id = -1; /* Track last regular (non-pair) id */
-    int32_t first_pair = -1; /* Track the first pair in the table */
-    int32_t first_role = -1; /* Track first id with role */
+    if ((ECS_TERM_REF_ID(second) == EcsVariable) && (second->id & EcsIsVariable)) {
+        second->id = first->id | ECS_TERM_REF_FLAGS(second);
+        second->id &= ~ent_var_mask;
+        second->id |= first->id & ent_var_mask;
+        second->name = first->name;
+    }
 
-    /* Scan to find boundaries of regular ids, pairs and roles */
-    for (dst_i = 0; dst_i < dst_count; dst_i ++) {
-        ecs_id_t dst_id = dst_ids[dst_i];
-        if (first_pair == -1 && ECS_IS_PAIR(dst_id)) {
-            first_pair = dst_i;
-        }
-        if ((dst_id & ECS_COMPONENT_MASK) == dst_id) {
-            last_id = dst_i;
-        } else if (first_role == -1 && !ECS_IS_PAIR(dst_id)) {
-            first_role = dst_i;
+    if (!(term->id & ~ECS_ID_FLAGS_MASK)) {
+        if (flecs_term_populate_id(term)) {
+            return -1;
         }
     }
 
-    /* The easy part: initialize a record for every id in the type */
-    for (dst_i = 0; (dst_i < dst_count) && (src_i < src_count); ) {
-        ecs_id_t dst_id = dst_ids[dst_i];
-        ecs_id_t src_id = src_ids[src_i];
-
-        idr = NULL;
-
-        if (dst_id == src_id) {
-            ecs_assert(src_tr != NULL, ECS_INTERNAL_ERROR, NULL);
-            idr = (ecs_id_record_t*)src_tr[src_i].hdr.cache;
-        } else if (dst_id < src_id) {
-            idr = flecs_id_record_ensure(world, dst_id);
-        }
-        if (idr) {
-            tr = ecs_vec_append_t(a, records, ecs_table_record_t);
-            tr->hdr.cache = (ecs_table_cache_t*)idr;
-            tr->index = flecs_ito(int16_t, dst_i);
-            tr->count = 1;
+    /* If term queries for !(ChildOf, _), translate it to the builtin 
+     * (ChildOf, 0) index which is a cheaper way to find root entities */
+    if (term->oper == EcsNot && term->id == ecs_pair(EcsChildOf, EcsAny)) {
+        /* Only if the source is not EcsAny */
+        if (!(ECS_TERM_REF_ID(&term->src) == EcsAny && (term->src.id & EcsIsVariable))) {
+            term->oper = EcsAnd;
+            term->id = ecs_pair(EcsChildOf, 0);
+            second->id = 0;
+            second->id |= EcsSelf|EcsIsEntity;
         }
-
-        dst_i += dst_id <= src_id;
-        src_i += dst_id >= src_id;
     }
 
-    /* Add remaining ids that the "from" table didn't have */
-    for (; (dst_i < dst_count); dst_i ++) {
-        ecs_id_t dst_id = dst_ids[dst_i];
-        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
-        idr = flecs_id_record_ensure(world, dst_id);
-        tr->hdr.cache = (ecs_table_cache_t*)idr;
-        ecs_assert(tr->hdr.cache != NULL, ECS_INTERNAL_ERROR, NULL);
-        tr->index = flecs_ito(int16_t, dst_i);
-        tr->count = 1;
+    ecs_entity_t first_entity = 0;
+    if ((first->id & EcsIsEntity)) {
+        first_entity = first_id;
     }
 
-    /* We're going to insert records from the vector into the index that
-     * will get patched up later. To ensure the record pointers don't get
-     * invalidated we need to grow the vector so that it won't realloc as
-     * we're adding the next set of records */
-    if (first_role != -1 || first_pair != -1) {
-        int32_t start = first_role;
-        if (first_pair != -1 && (start != -1 || first_pair < start)) {
-            start = first_pair;
-        }
-
-        /* Total number of records can never be higher than
-         * - number of regular (non-pair) ids +
-         * - three records for pairs: (R,T), (R,*), (*,T)
-         * - one wildcard (*), one any (_) and one pair wildcard (*,*) record
-         * - one record for (ChildOf, 0)
-         */
-        int32_t flag_id_count = dst_count - start;
-        int32_t record_count = start + 3 * flag_id_count + 3 + 1;
-        ecs_vec_set_min_size_t(a, records, ecs_table_record_t, record_count);
-    }
+    ecs_id_record_t *idr = flecs_id_record_get(world, term->id);
+    ecs_flags32_t id_flags = idr ? idr->flags : 0;
 
-    /* Add records for ids with roles (used by cleanup logic) */
-    if (first_role != -1) {
-        for (dst_i = first_role; dst_i < dst_count; dst_i ++) {
-            ecs_id_t id = dst_ids[dst_i];
-            if (!ECS_IS_PAIR(id)) {
-                ecs_entity_t first = 0;
-                ecs_entity_t second = 0;
-                if (ECS_HAS_ID_FLAG(id, PAIR)) {
-                    first = ECS_PAIR_FIRST(id);
-                    second = ECS_PAIR_SECOND(id);
-                } else {
-                    first = id & ECS_COMPONENT_MASK;
-                }
-                if (first) {
-                    flecs_table_append_to_records(world, table, records, 
-                        ecs_pair(EcsFlag, first), dst_i);
-                }
-                if (second) {
-                    flecs_table_append_to_records(world, table, records, 
-                        ecs_pair(EcsFlag, second), dst_i);
-                }
+    if (first_entity) {
+        /* Only enable inheritance for ids which are inherited from at the time
+         * of query creation. To force component inheritance to be evaluated,
+         * an application can explicitly set traversal flags. */
+        if (flecs_id_record_get(world, ecs_pair(EcsIsA, first->id))) {
+            if (!((first_flags & EcsTraverseFlags) == EcsSelf)) {
+                term->flags_ |= EcsTermIdInherited;
             }
         }
-    }
 
-    int32_t last_pair = -1;
-    bool has_childof = table->flags & EcsTableHasChildOf;
-    if (first_pair != -1) {
-        /* Add a (Relationship, *) record for each relationship. */
-        ecs_entity_t r = 0;
-        for (dst_i = first_pair; dst_i < dst_count; dst_i ++) {
-            ecs_id_t dst_id = dst_ids[dst_i];
-            if (!ECS_IS_PAIR(dst_id)) {
-                break; /* no more pairs */
+        /* Don't traverse ids that cannot be inherited */
+        if ((id_flags & EcsIdDontInherit) && (term->trav == EcsIsA)) {
+            if (src_flags & EcsUp) {
+                flecs_query_validator_error(ctx, 
+                    "traversing not allowed for id that can't be inherited");
+                return -1;
             }
-            if (r != ECS_PAIR_FIRST(dst_id)) { /* New relationship, new record */
-                tr = ecs_vec_get_t(records, ecs_table_record_t, dst_i);
+            src->id &= ~EcsUp;
+            term->trav = 0;
+        }
 
-                ecs_id_record_t *p_idr = (ecs_id_record_t*)tr->hdr.cache;
-                r = ECS_PAIR_FIRST(dst_id);
-                if (r == EcsChildOf) {
-                    childof_idr = p_idr;
+        /* If component id is final, don't attempt component inheritance */
+        ecs_record_t *first_record = flecs_entities_get(world, first_entity);
+        ecs_table_t *first_table = first_record ? first_record->table : NULL;
+        if (first_table) {
+            /* Add traversal flags for transitive relationships */
+            if (ecs_term_ref_is_set(second) && !((second_flags & EcsTraverseFlags) == EcsSelf)) {
+                if (!((src->id & EcsIsVariable) && (src_id == EcsAny))) {
+                    if (!((second->id & EcsIsVariable) && (second_id == EcsAny))) {
+                        if (ecs_table_has_id(world, first_table, EcsTransitive)) {
+                            term->flags_ |= EcsTermTransitive;
+                        }
+                    }
                 }
-
-                idr = p_idr->parent; /* (R, *) */
-                ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-
-                tr = ecs_vec_append_t(a, records, ecs_table_record_t);
-                tr->hdr.cache = (ecs_table_cache_t*)idr;
-                tr->index = flecs_ito(int16_t, dst_i);
-                tr->count = 0;
             }
 
-            ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-            tr->count ++;
+            if (ecs_table_has_id(world, first_table, EcsReflexive)) {
+                term->flags_ |= EcsTermReflexive;
+            }
         }
 
-        last_pair = dst_i;
-
-        /* Add a (*, Target) record for each relationship target. Type
-         * ids are sorted relationship-first, so we can't simply do a single linear 
-         * scan to find all occurrences for a target. */
-        for (dst_i = first_pair; dst_i < last_pair; dst_i ++) {
-            ecs_id_t dst_id = dst_ids[dst_i];
-            ecs_id_t tgt_id = ecs_pair(EcsWildcard, ECS_PAIR_SECOND(dst_id));
+        /* Check if term has toggleable component */
+        if (id_flags & EcsIdCanToggle) {
+            term->flags_ |= EcsTermIsToggle;
+        }
 
-            flecs_table_append_to_records(
-                world, table, records, tgt_id, dst_i);
+        /* Check if this is a member query */
+#ifdef FLECS_META
+        if (ecs_id(EcsMember) != 0) {
+            if (first_entity) {
+                if (ecs_has(world, first_entity, EcsMember)) {
+                    term->flags_ |= EcsTermIsMember;
+                }
+            }
         }
+#endif
     }
 
-    /* Lastly, add records for all-wildcard ids */
-    if (last_id >= 0) {
-        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
-        tr->hdr.cache = (ecs_table_cache_t*)world->idr_wildcard;
-        tr->index = 0;
-        tr->count = flecs_ito(int16_t, last_id + 1);
-    }
-    if (last_pair - first_pair) {
-        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
-        tr->hdr.cache = (ecs_table_cache_t*)world->idr_wildcard_wildcard;
-        tr->index = flecs_ito(int16_t, first_pair);
-        tr->count = flecs_ito(int16_t, last_pair - first_pair);
-    }
-    if (dst_count) {
-        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
-        tr->hdr.cache = (ecs_table_cache_t*)world->idr_any;
-        tr->index = 0;
-        tr->count = 1;
-    }
-    if (dst_count && !has_childof) {
-        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
-        childof_idr = world->idr_childof_0;
-        tr->hdr.cache = (ecs_table_cache_t*)childof_idr;
-        tr->index = 0;
-        tr->count = 1;
+    if (ECS_TERM_REF_ID(first) == EcsVariable) {
+        flecs_query_validator_error(ctx, "invalid $ for term.first");
+        return -1;
     }
 
-    /* Now that all records have been added, copy them to array */
-    int32_t i, dst_record_count = ecs_vec_count(records);
-    ecs_table_record_t *dst_tr = flecs_wdup_n(world, ecs_table_record_t, 
-        dst_record_count, ecs_vec_first_t(records, ecs_table_record_t));
-    table->_->record_count = flecs_ito(int16_t, dst_record_count);
-    table->_->records = dst_tr;
-    int32_t column_count = 0;
-
-    /* Register & patch up records */
-    for (i = 0; i < dst_record_count; i ++) {
-        tr = &dst_tr[i];
-        idr = (ecs_id_record_t*)dst_tr[i].hdr.cache;
-        ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        if (ecs_table_cache_get(&idr->cache, table)) {
-            /* If this is a target wildcard record it has already been 
-             * registered, but the record is now at a different location in
-             * memory. Patch up the linked list with the new address */
-            ecs_table_cache_replace(&idr->cache, table, &tr->hdr);
-        } else {
-            /* Other records are not registered yet */
-            ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_table_cache_insert(&idr->cache, table, &tr->hdr);
+    if (term->oper == EcsAndFrom || term->oper == EcsOrFrom || term->oper == EcsNotFrom) {
+        if (term->inout != EcsInOutDefault && term->inout != EcsInOutNone) {
+            flecs_query_validator_error(ctx, 
+                "invalid inout value for AndFrom/OrFrom/NotFrom term");
+            return -1;
         }
+    }
 
-        /* Claim id record so it stays alive as long as the table exists */
-        flecs_id_record_claim(world, idr);
-
-        /* Initialize event flags */
-        table->flags |= idr->flags & EcsIdEventMask;
+    /* Is term trivial/cacheable */
+    bool cacheable_term = true;
+    bool trivial_term = true;
+    if (term->oper != EcsAnd) {
+        trivial_term = false;
+    }
 
-        /* Initialize column index (will be overwritten by init_columns) */
-        tr->column = -1;
+    if (ecs_id_is_wildcard(term->id)) {
+        if (!(id_flags & EcsIdExclusive)) {
+            trivial_term = false;
+        }
 
-        if (idr->flags & EcsIdAlwaysOverride) {
-            table->flags |= EcsTableHasOverrides;
+        if (first->id & EcsIsVariable) {
+            if (!ecs_id_is_wildcard(first_id) || first_id == EcsAny) {
+                trivial_term = false;
+                cacheable_term = false;
+            }
         }
 
-        if ((i < table->type.count) && (idr->type_info != NULL)) {
-            column_count ++;
+        if (second->id & EcsIsVariable) {
+            if (!ecs_id_is_wildcard(second_id) || second_id == EcsAny) {
+                trivial_term = false;
+                cacheable_term = false;
+            }
         }
     }
 
-    if (column_count) {
-        table->column_map = flecs_walloc_n(world, int32_t, 
-            dst_count + column_count);
+    if (!ecs_term_match_this(term)) {
+        trivial_term = false;
     }
-    table->column_count = flecs_ito(int16_t, column_count);
-    flecs_table_init_data(world, table);
-
-    if (table->flags & EcsTableHasName) {
-        ecs_assert(childof_idr != NULL, ECS_INTERNAL_ERROR, NULL);
-        table->_->name_index = 
-            flecs_id_record_name_index_ensure(world, childof_idr);
-        ecs_assert(table->_->name_index != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (term->flags_ & EcsTermTransitive) {
+        trivial_term = false;
+        cacheable_term = false;
     }
-
-    if (table->flags & EcsTableHasOnTableCreate) {
-        flecs_emit(world, world, &(ecs_event_desc_t) {
-            .ids = &table->type,
-            .event = EcsOnTableCreate,
-            .table = table,
-            .flags = EcsEventTableOnly,
-            .observable = world
-        });
+    if (term->flags_ & EcsTermIdInherited) {
+        trivial_term = false;
+        cacheable_term = false;
     }
-}
+    if (term->flags_ & EcsTermIsScope) {
+        cacheable_term = false;
+    }
+    if (term->trav && term->trav != EcsIsA) {
+        trivial_term = false;
+    }
+    if (!(src->id & EcsSelf)) {
+        trivial_term = false;
+    }
+    if (((ECS_TERM_REF_ID(&term->first) == EcsPredEq) || 
+         (ECS_TERM_REF_ID(&term->first) == EcsPredMatch) || 
+         (ECS_TERM_REF_ID(&term->first) == EcsPredLookup)) && 
+        (term->first.id & EcsIsEntity)) 
+    {
+        trivial_term = false;
+        cacheable_term = false;
+    }
+    if (ECS_TERM_REF_ID(src) != EcsThis) {
+        cacheable_term = false;
+    }
+    if (term->id == ecs_childof(0)) {
+        cacheable_term = false;
+    }
+    if (term->flags_ & EcsTermIsMember) {
+        trivial_term = false;
+        cacheable_term = false;
 
-/* Unregister table from id records */
-static
-void flecs_table_records_unregister(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    uint64_t table_id = table->id;
-    int32_t i, count = table->_->record_count;
-    for (i = 0; i < count; i ++) {
-        ecs_table_record_t *tr = &table->_->records[i];
-        ecs_table_cache_t *cache = tr->hdr.cache;
-        ecs_id_t id = ((ecs_id_record_t*)cache)->id;
+    }
+    if (term->flags_ & EcsTermIsToggle) {
+        trivial_term = false;
+    }
 
-        ecs_assert(tr->hdr.cache == cache, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(tr->hdr.table == table, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(flecs_id_record_get(world, id) == (ecs_id_record_t*)cache,
-            ECS_INTERNAL_ERROR, NULL);
-        (void)id;
+    ECS_BIT_COND16(term->flags_, EcsTermIsTrivial, trivial_term);
+    ECS_BIT_COND16(term->flags_, EcsTermIsCacheable, cacheable_term);
 
-        ecs_table_cache_remove(cache, table_id, &tr->hdr);
-        flecs_id_record_release(world, (ecs_id_record_t*)cache);
+    if (flecs_term_verify(world, term, ctx)) {
+        return -1;
     }
 
-    flecs_wfree_n(world, ecs_table_record_t, count, table->_->records);
+    return 0;
 }
 
-/* Keep track for what kind of builtin events observers are registered that can
- * potentially match the table. This allows code to early out of calling the
- * emit function that notifies observers. */
-static
-void flecs_table_add_trigger_flags(
-    ecs_world_t *world, 
-    ecs_table_t *table, 
-    ecs_entity_t event) 
+bool flecs_identifier_is_0(
+    const char *id)
 {
-    (void)world;
-
-    if (event == EcsOnAdd) {
-        table->flags |= EcsTableHasOnAdd;
-    } else if (event == EcsOnRemove) {
-        table->flags |= EcsTableHasOnRemove;
-    } else if (event == EcsOnSet) {
-        table->flags |= EcsTableHasOnSet;
-    } else if (event == EcsUnSet) {
-        table->flags |= EcsTableHasUnSet;
-    } else if (event == EcsOnTableFill) {
-        table->flags |= EcsTableHasOnTableFill;
-    } else if (event == EcsOnTableEmpty) {
-        table->flags |= EcsTableHasOnTableEmpty;
-    }
+    return id[0] == '0' && !id[1];
 }
 
-/* Invoke OnRemove observers for all entities in table. Useful during table 
- * deletion or when clearing entities from a table. */
-static
-void flecs_table_notify_on_remove(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data)
+bool ecs_term_ref_is_set(
+    const ecs_term_ref_t *ref)
 {
-    int32_t count = data->entities.count;
-    if (count) {
-        flecs_notify_on_remove(world, table, NULL, 0, count, &table->type);
-    }
+    return ECS_TERM_REF_ID(ref) != 0 || ref->name != NULL || ref->id & EcsIsEntity;
 }
 
-/* Invoke type hook for entities in table */
-static
-void flecs_table_invoke_hook(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_iter_action_t callback,
-    ecs_entity_t event,
-    ecs_column_t *column,
-    ecs_entity_t *entities,
-    int32_t row,
-    int32_t count)
+bool ecs_term_is_initialized(
+    const ecs_term_t *term)
+{
+    return term->id != 0 || ecs_term_ref_is_set(&term->first);
+}
+
+bool ecs_term_match_this(
+    const ecs_term_t *term)
 {
-    void *ptr = ecs_vec_get(&column->data, column->size, row);
-    flecs_invoke_hook(world, table, count, row, entities, ptr, column->id, 
-        column->ti, event, callback);
+    return (term->src.id & EcsIsVariable) && 
+        (ECS_TERM_REF_ID(&term->src) == EcsThis);
 }
 
-/* Construct components */
-static
-void flecs_table_invoke_ctor(
-    ecs_column_t *column,
-    int32_t row,
-    int32_t count)
+bool ecs_term_match_0(
+    const ecs_term_t *term)
 {
-    ecs_type_info_t *ti = column->ti;
-    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_xtor_t ctor = ti->hooks.ctor;
-    if (ctor) {
-        void *ptr = ecs_vec_get(&column->data, column->size, row);
-        ctor(ptr, count, ti);
-    }
+    return (!ECS_TERM_REF_ID(&term->src) && (term->src.id & EcsIsEntity));
 }
 
-/* Destruct components */
-static
-void flecs_table_invoke_dtor(
-    ecs_column_t *column,
-    int32_t row,
-    int32_t count)
+int ecs_term_finalize(
+    const ecs_world_t *world,
+    ecs_term_t *term)
 {
-    ecs_type_info_t *ti = column->ti;
-    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_xtor_t dtor = ti->hooks.dtor;
-    if (dtor) {
-        void *ptr = ecs_vec_get(&column->data, column->size, row);
-        dtor(ptr, count, ti);
-    }
+    ecs_query_validator_ctx_t ctx = {0};
+    ctx.world = world;
+    ctx.term = term;
+    return flecs_term_finalize(world, term, &ctx);
 }
 
-/* Run hooks that get invoked when component is added to entity */
 static
-void flecs_table_invoke_add_hooks(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_column_t *column,
-    ecs_entity_t *entities,
-    int32_t row,
-    int32_t count,
-    bool construct)
+ecs_term_t* flecs_query_or_other_type(
+    ecs_query_t *q,
+    int32_t t)
 {
-    ecs_type_info_t *ti = column->ti;
-    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    if (construct) {
-        flecs_table_invoke_ctor(column, row, count);
+    ecs_term_t *term = &q->terms[t];
+    ecs_term_t *first = NULL;
+    while (t--) {
+        if (q->terms[t].oper != EcsOr) {
+            break;
+        }
+        first = &q->terms[t];
     }
 
-    ecs_iter_action_t on_add = ti->hooks.on_add;
-    if (on_add) {
-        flecs_table_invoke_hook(world, table, on_add, EcsOnAdd, column,
-            entities, row, count);
+    if (first) {
+        ecs_world_t *world = q->world;
+        const ecs_type_info_t *first_type = ecs_get_type_info(world, first->id);
+        const ecs_type_info_t *term_type = ecs_get_type_info(world, term->id);
+        if (first_type == term_type) {
+            return NULL;
+        }
+        return first;
+    } else {
+        return NULL;
     }
 }
 
-/* Run hooks that get invoked when component is removed from entity */
 static
-void flecs_table_invoke_remove_hooks(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_column_t *column,
-    ecs_entity_t *entities,
-    int32_t row,
-    int32_t count,
-    bool dtor)
+void flecs_normalize_term_name(
+    ecs_term_ref_t *ref) 
 {
-    ecs_type_info_t *ti = column->ti;
-    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (ref->name && ref->name[0] == '$' && ref->name[1]) {
+        ecs_assert(ref->id & EcsIsVariable, ECS_INTERNAL_ERROR, NULL);
+        const char *old = ref->name;
+        ref->name = &old[1];
 
-    ecs_iter_action_t on_remove = ti->hooks.on_remove;
-    if (on_remove) {
-        flecs_table_invoke_hook(world, table, on_remove, EcsOnRemove, column,
-            entities, row, count);
-    }
-    
-    if (dtor) {
-        flecs_table_invoke_dtor(column, row, count);
+        if (!ecs_os_strcmp(ref->name, "this")) {
+            ref->name = NULL;
+            ref->id |= EcsThis;
+        }
     }
 }
 
-/* Destruct all components and/or delete all entities in table in range */
 static
-void flecs_table_dtor_all(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data,
-    int32_t row,
-    int32_t count,
-    bool update_entity_index,
-    bool is_delete)
+int flecs_query_finalize_terms(
+    const ecs_world_t *world,
+    ecs_query_t *q)
 {
-    /* Can't delete and not update the entity index */
-    ecs_assert(!is_delete || update_entity_index, ECS_INTERNAL_ERROR, NULL);
-
-    int32_t ids_count = table->column_count;
-    ecs_entity_t *entities = data->entities.array;
-    int32_t i, c, end = row + count;
+    int32_t i, term_count = q->term_count, field_count = 0;
+    ecs_term_t *terms = q->terms;
+    int32_t nodata_terms = 0, scope_nesting = 0, cacheable_terms = 0;
+    bool cond_set = false;
 
-    if (is_delete && table->_->traversable_count) {
-        /* If table contains monitored entities with traversable relationships,
-         * make sure to invalidate observer cache */
-        flecs_emit_propagate_invalidate(world, table, row, count);
-    }
+    ecs_query_validator_ctx_t ctx = {0};
+    ctx.world = world;
+    ctx.query = q;
 
-    /* If table has components with destructors, iterate component columns */
-    if (table->flags & EcsTableHasDtors) {
-        /* Throw up a lock just to be sure */
-        table->_->lock = true;
+    q->flags |= EcsQueryMatchOnlyThis;
 
-        /* Run on_remove callbacks first before destructing components */
-        for (c = 0; c < ids_count; c++) {
-            ecs_column_t *column = &data->columns[c];
-            ecs_iter_action_t on_remove = column->ti->hooks.on_remove;
-            if (on_remove) {
-                flecs_table_invoke_hook(world, table, on_remove, EcsOnRemove, 
-                    column, &entities[row], row, count);
-            }
+    bool cacheable = true;
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
+        bool prev_is_or = i && term[-1].oper == EcsOr;
+        bool nodata_term = false;
+        ctx.term_index = i;
+        if (flecs_term_finalize(world, term, &ctx)) {
+            return -1;
         }
 
-        /* Destruct components */
-        for (c = 0; c < ids_count; c++) {
-            flecs_table_invoke_dtor(&data->columns[c], row, count);
+        if (scope_nesting) {
+            /* Terms inside a scope are not cacheable */
+            ECS_BIT_CLEAR16(term->flags_, EcsTermIsCacheable);
         }
 
-        /* Iterate entities first, then components. This ensures that only one
-         * entity is invalidated at a time, which ensures that destructors can
-         * safely access other entities. */
-        for (i = row; i < end; i ++) {
-            /* Update entity index after invoking destructors so that entity can
-             * be safely used in destructor callbacks. */
-            if (update_entity_index) {
-                ecs_entity_t e = entities[i];
-                ecs_assert(!e || ecs_is_valid(world, e), 
-                    ECS_INTERNAL_ERROR, NULL);
-
-                if (is_delete) {
-                    flecs_entities_remove(world, e);
-                    ecs_assert(ecs_is_valid(world, e) == false, 
-                        ECS_INTERNAL_ERROR, NULL);
+        /* If one of the terms in an OR chain isn't cacheable, none are */
+        if (term->flags_ & EcsTermIsCacheable) {
+            /* Current term is marked as cacheable. Check if it is part of an OR
+             * chain, and if so, the previous term was also cacheable. */
+            if (prev_is_or) {
+                if (term[-1].flags_ & EcsTermIsCacheable) {
+                    cacheable_terms ++;
                 } else {
-                    // If this is not a delete, clear the entity index record
-                    ecs_record_t *record = flecs_entities_get(world, e);
-                    record->table = NULL;
-                    record->row = 0;
+                    ECS_BIT_CLEAR16(term->flags_, EcsTermIsCacheable);
                 }
             } else {
-                /* This should only happen in rare cases, such as when the data
-                 * cleaned up is not part of the world (like with snapshots) */
+                cacheable_terms ++;
             }
-        }
 
-        table->_->lock = false;
+            /* Toggle terms may be cacheable for fetching the initial component, 
+             * but require an additional toggle instruction for evaluation. */
+            if (term->flags_ & EcsTermIsToggle) {
+                cacheable = false;
+            }
+        } else if (prev_is_or) {
+            /* Current term is not cacheable. If it is part of an OR chain, mark
+             * previous terms in the chain as also not cacheable. */
+            int32_t j;
+            for (j = i - 1; j >= 0; j --) {
+                if (terms[j].oper != EcsOr) {
+                    break;
+                }
+                if (terms[j].flags_ & EcsTermIsCacheable) {
+                    cacheable_terms --;
+                    ECS_BIT_CLEAR16(terms[j].flags_, EcsTermIsCacheable);
+                }
+            }
+        }
 
-    /* If table does not have destructors, just update entity index */
-    } else if (update_entity_index) {
-        if (is_delete) {
-            for (i = row; i < end; i ++) {
-                ecs_entity_t e = entities[i];
-                ecs_assert(!e || ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL);
-                flecs_entities_remove(world, e);
-                ecs_assert(!ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL);
-            } 
-        } else {
-            for (i = row; i < end; i ++) {
-                ecs_entity_t e = entities[i];
-                ecs_assert(!e || ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL);
-                ecs_record_t *record = flecs_entities_get(world, e);
-                record->table = NULL;
-                record->row = record->row & ECS_ROW_FLAGS_MASK;
-                (void)e;
+        if (prev_is_or) {
+            if (ECS_TERM_REF_ID(&term[-1].src) != ECS_TERM_REF_ID(&term->src)) {
+                flecs_query_validator_error(&ctx, "mismatching src.id for OR terms");
+                return -1;
             }
-        }      
-    }
-}
+            if (term->oper != EcsOr && term->oper != EcsAnd) {
+                flecs_query_validator_error(&ctx, 
+                    "term after OR operator must use AND operator");
+                return -1;
+            }
+        } else {
+            field_count ++;
+        }
 
-/* Cleanup table storage */
-static
-void flecs_table_fini_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data,
-    bool do_on_remove,
-    bool update_entity_index,
-    bool is_delete,
-    bool deactivate)
-{
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
+        term->field_index = flecs_ito(int16_t, field_count - 1);
 
-    if (!data) {
-        return;
-    }
+        if (ecs_id_is_wildcard(term->id)) {
+            q->flags |= EcsQueryMatchWildcards;
+        }
 
-    if (do_on_remove) {
-        flecs_table_notify_on_remove(world, table, data);        
-    }
+        if (ecs_term_match_this(term)) {
+            ECS_BIT_SET(q->flags, EcsQueryMatchThis);
+        } else {
+            ECS_BIT_CLEAR(q->flags, EcsQueryMatchOnlyThis);
+        }
 
-    int32_t count = flecs_table_data_count(data);
-    if (count) {
-        flecs_table_dtor_all(world, table, data, 0, count, 
-            update_entity_index, is_delete);
-    }
+        if (ECS_TERM_REF_ID(term) == EcsPrefab) {
+            ECS_BIT_SET(q->flags, EcsQueryMatchPrefab);
+        }
+        if (ECS_TERM_REF_ID(term) == EcsDisabled && (term->src.id & EcsSelf)) {
+            ECS_BIT_SET(q->flags, EcsQueryMatchDisabled);
+        }
 
-    ecs_column_t *columns = data->columns;
-    if (columns) {
-        int32_t c, column_count = table->column_count;
-        for (c = 0; c < column_count; c ++) {
-            /* Sanity check */
-            ecs_assert(columns[c].data.count == data->entities.count,
-                ECS_INTERNAL_ERROR, NULL);
-            ecs_vec_fini(&world->allocator,
-                &columns[c].data, columns[c].size);
+        if (ECS_BIT_IS_SET(q->flags, EcsQueryNoData)) {
+            term->inout = EcsInOutNone;
+        }
+        
+        if (term->oper == EcsNot && term->inout == EcsInOutDefault) {
+            term->inout = EcsInOutNone;
         }
-        flecs_wfree_n(world, ecs_column_t, column_count, columns);
-        data->columns = NULL;
-    }
 
-    ecs_table__t *meta = table->_;
-    ecs_switch_t *sw_columns = meta->sw_columns;
-    if (sw_columns) {
-        int32_t c, column_count = meta->sw_count;
-        for (c = 0; c < column_count; c ++) {
-            flecs_switch_fini(&sw_columns[c]);
+        if ((term->id == EcsWildcard) || (term->id == 
+            ecs_pair(EcsWildcard, EcsWildcard))) 
+        {
+            /* If term type is unknown beforehand, default the inout type to
+             * none. This prevents accidentally requesting lots of components,
+             * which can put stress on serializer code. */
+            if (term->inout == EcsInOutDefault) {
+                term->inout = EcsInOutNone;
+            }
         }
-        flecs_wfree_n(world, ecs_switch_t, column_count, sw_columns);
-        meta->sw_columns = NULL;
-    }
 
-    ecs_bitset_t *bs_columns = meta->bs_columns;
-    if (bs_columns) {
-        int32_t c, column_count = meta->bs_count;
-        for (c = 0; c < column_count; c ++) {
-            flecs_bitset_fini(&bs_columns[c]);
+        if (term->inout == EcsInOutNone) {
+            nodata_term = true;
+        } else if (!ecs_get_type_info(world, term->id)) {
+            nodata_term = true;
+        } else {
+            if (ecs_id_is_tag(world, term->id)) {
+                nodata_term = true;
+            } else if ((ECS_PAIR_SECOND(term->id) == EcsWildcard) ||
+                       (ECS_PAIR_SECOND(term->id) == EcsAny)) 
+            {
+                /* If the second element of a pair is a wildcard and the first
+                 * element is not a type, we can't know in advance what the
+                 * type of the term is, so it can't provide data. */
+                if (!ecs_get_type_info(world, ecs_pair_first(world, term->id))) {
+                    nodata_term = true;
+                }
+            }
         }
-        flecs_wfree_n(world, ecs_bitset_t, column_count, bs_columns);
-        meta->bs_columns = NULL;
-    }
 
-    ecs_vec_fini_t(&world->allocator, &data->entities, ecs_entity_t);
+        if (term->inout != EcsIn && term->inout != EcsInOutNone) {
+            /* Non-this terms default to EcsIn */
+            if (ecs_term_match_this(term) || term->inout != EcsInOutDefault) {
+                q->flags |= EcsQueryHasOutTerms;
+            }
 
-    if (deactivate && count) {
-        flecs_table_set_empty(world, table);
-    }
+            bool match_non_this = !ecs_term_match_this(term) || 
+                (term->src.id & EcsUp);
+            if (match_non_this && term->inout != EcsInOutDefault) {
+                q->flags |= EcsQueryHasNonThisOutTerms;
+            }
+        }
 
-    table->_->traversable_count = 0;
-    table->flags &= ~EcsTableHasTraversable;
-}
+        if (!nodata_term) {
+            /* If terms in an OR chain do not all return the same type, the 
+             * field will not provide any data */
+            if (term->oper == EcsOr || (i && term[-1].oper == EcsOr)) {
+                ecs_term_t *first = flecs_query_or_other_type(q, i);
+                if (first) {
+                    if (first == &term[-1]) {
+                        if (!(term[-1].flags_ & EcsTermNoData)) {
+                            nodata_terms ++;
+                        }
+                    }
+                    nodata_term = true;
+                }
+                q->data_fields &= (ecs_termset_t)~(1llu << term->field_index);
+            }
+        }
 
-ecs_vec_t* flecs_table_entities(
-    ecs_table_t *table)
-{
-    return &table->data.entities;
-}
+        if (term->flags_ & EcsTermIsMember) {
+            nodata_term = false;
+        }
 
-ecs_entity_t* flecs_table_entities_array(
-    ecs_table_t *table)
-{
-    return ecs_vec_first(flecs_table_entities(table));
-}
+        if (nodata_term) {
+            nodata_terms ++;
+            term->flags_ |= EcsTermNoData;
+        } else if (term->oper != EcsNot) {
+            ECS_TERMSET_SET(q->data_fields, 1u << term->field_index);
 
-/* Cleanup, no OnRemove, don't update entity index, don't deactivate table */
-void flecs_table_clear_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data)
-{
-    flecs_table_fini_data(world, table, data, false, false, false, false);
-}
+            if (term->inout != EcsIn) {
+                ECS_TERMSET_SET(q->write_fields, 1u << term->field_index);
+            }
+            if (term->inout != EcsOut) {
+                ECS_TERMSET_SET(q->read_fields, 1u << term->field_index);
+            }
+            if (term->inout == EcsInOutDefault) {
+                ECS_TERMSET_SET(q->shared_readonly_fields, 
+                    1u << term->field_index);
+            }
+        }
 
-/* Cleanup, no OnRemove, clear entity index, deactivate table */
-void flecs_table_clear_entities_silent(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    flecs_table_fini_data(world, table, &table->data, false, true, false, true);
-}
+        if (ECS_TERM_REF_ID(&term->src) && (term->src.id & EcsIsEntity)) {
+            ECS_TERMSET_SET(q->fixed_fields, 1u << term->field_index);
+        }
 
-/* Cleanup, run OnRemove, clear entity index, deactivate table */
-void flecs_table_clear_entities(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    flecs_table_fini_data(world, table, &table->data, true, true, false, true);
-}
+        ecs_id_record_t *idr = flecs_id_record_get(world, term->id);
+        if (idr) {
+            if (ecs_os_has_threading()) {
+                ecs_os_ainc(&idr->keep_alive);
+            } else {
+                idr->keep_alive ++;
+            }
+            term->flags_ |= EcsTermKeepAlive;
+        }
 
-/* Cleanup, run OnRemove, delete from entity index, deactivate table */
-void flecs_table_delete_entities(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    flecs_table_fini_data(world, table, &table->data, true, true, true, true);
-}
+        if (term->oper == EcsOptional || term->oper == EcsNot) {
+            cond_set = true;
+        }
 
-/* Unset all components in table. This function is called before a table is 
- * deleted, and invokes all UnSet handlers, if any */
-void flecs_table_remove_actions(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    (void)world;
-    flecs_table_notify_on_remove(world, table, &table->data);
-}
+        ecs_entity_t first_id = ECS_TERM_REF_ID(&term->first);
+        if (first_id == EcsPredEq || first_id == EcsPredMatch ||
+            first_id == EcsPredLookup)
+        {
+            q->flags |= EcsQueryHasPred;
+            term->src.id = (term->src.id & ~EcsTraverseFlags) | EcsSelf;
+            term->inout = EcsInOutNone;
+        } else {
+            if (!ecs_term_match_0(term) && term->oper != EcsNot && 
+                term->oper != EcsNotFrom) 
+            {
+                ECS_TERMSET_SET(q->set_fields, 1u << term->field_index);
+            }
+        }
 
-/* Free table resources. */
-void flecs_table_free(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    bool is_root = table == &world->store.root;
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(is_root || table->id != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(is_root || flecs_sparse_is_alive(&world->store.tables, table->id),
-        ECS_INTERNAL_ERROR, NULL);
-    (void)world;
+        if (first_id == EcsScopeOpen) {
+            q->flags |= EcsQueryHasScopes;
+            scope_nesting ++;
+        }
 
-    if (!is_root && !(world->flags & EcsWorldQuit)) {
-        if (table->flags & EcsTableHasOnTableDelete) {
-            flecs_emit(world, world, &(ecs_event_desc_t) {
-                .ids = &table->type,
-                .event = EcsOnTableDelete,
-                .table = table,
-                .flags = EcsEventTableOnly,
-                .observable = world
-            });
+        if (scope_nesting) {
+            term->flags_ |= EcsTermIsScope;
         }
-    }
 
-    if (ecs_should_log_2()) {
-        char *expr = ecs_type_str(world, &table->type);
-        ecs_dbg_2(
-            "#[green]table#[normal] [%s] #[red]deleted#[reset] with id %d", 
-            expr, table->id);
-        ecs_os_free(expr);
-        ecs_log_push_2();
-    }
+        if (first_id == EcsScopeClose) {
+            if (i && ECS_TERM_REF_ID(&terms[i - 1].first) == EcsScopeOpen) {
+                flecs_query_validator_error(&ctx, "invalid empty scope");
+                return -1;
+            }
 
-    world->info.empty_table_count -= (ecs_table_count(table) == 0);
+            q->flags |= EcsQueryHasScopes;
+            scope_nesting --;
+        }
 
-    /* Cleanup data, no OnRemove, delete from entity index, don't deactivate */
-    flecs_table_fini_data(world, table, &table->data, false, true, true, false);
-    flecs_table_clear_edges(world, table);
+        if (scope_nesting < 0) {
+            flecs_query_validator_error(&ctx, "'}' without matching '{'");
+        }
+    }
 
-    if (!is_root) {
-        ecs_type_t ids = {
-            .array = table->type.array,
-            .count = table->type.count
-        };
+    if (scope_nesting != 0) {
+        flecs_query_validator_error(&ctx, "missing '}'");
+        return -1;
+    }
 
-        flecs_hashmap_remove_w_hash(
-            &world->store.table_map, &ids, ecs_table_t*, table->_->hash);
+    if (term_count && (terms[term_count - 1].oper == EcsOr)) {
+        flecs_query_validator_error(&ctx, 
+            "last term of query can't have OR operator");
+        return -1;
     }
 
-    flecs_wfree_n(world, int32_t, table->column_count + 1, table->dirty_state);
-    flecs_wfree_n(world, int32_t, table->column_count + table->type.count, 
-        table->column_map);
-    flecs_table_records_unregister(world, table);
+    q->field_count = flecs_ito(int8_t, field_count);
 
-    /* Update counters */
-    world->info.table_count --;
-    world->info.table_delete_total ++;
+    if (field_count) {
+        for (i = 0; i < term_count; i ++) {
+            ecs_term_t *term = &terms[i];
+            int32_t field = term->field_index;
+            q->ids[field] = term->id;
 
-    flecs_free_t(&world->allocator, ecs_table__t, table->_);
+            if (term->oper == EcsOr || (i && (term[-1].oper == EcsOr))) {
+                if (flecs_query_or_other_type(q, i)) {
+                    q->sizes[field] = 0;
+                    q->ids[field] = 0;
+                    continue;
+                }
+            }
 
-    if (!(world->flags & EcsWorldFini)) {
-        ecs_assert(!is_root, ECS_INTERNAL_ERROR, NULL);
-        flecs_table_free_type(world, table);
-        flecs_sparse_remove_t(&world->store.tables, ecs_table_t, table->id);
+            ecs_id_record_t *idr = flecs_id_record_get(world, term->id);
+            if (idr) {
+                if (!ECS_IS_PAIR(idr->id) || ECS_PAIR_FIRST(idr->id) != EcsWildcard) {
+                    if (idr->type_info) {
+                        q->sizes[field] = idr->type_info->size;
+                        q->ids[field] = idr->id;
+                    }
+                }
+            } else {
+                const ecs_type_info_t *ti = ecs_get_type_info(
+                    world, term->id);
+                if (ti) {
+                    q->sizes[field] = ti->size;
+                    q->ids[field] = term->id;
+                }
+            }
+
+            if (term->flags_ & EcsTermIsMember) {
+                q->sizes[field] = ECS_SIZEOF(ecs_entity_t);
+#ifdef FLECS_META
+                q->ids[field] = ecs_id(ecs_entity_t);
+#endif
+            }
+        }
     }
 
-    ecs_log_pop_2();
-}
+    ecs_assert(nodata_terms <= term_count, ECS_INTERNAL_ERROR, NULL);
+    if (nodata_terms == term_count) {
+        ECS_BIT_SET(q->flags, EcsQueryNoData);
+    }
 
-/* Free table type. Do this separately from freeing the table as types can be
- * in use by application destructors. */
-void flecs_table_free_type(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    flecs_wfree_n(world, ecs_id_t, table->type.count, table->type.array);
-}
+    ECS_BIT_COND(q->flags, EcsQueryHasCondSet, cond_set);
 
-/* Reset a table to its initial state. */
-void flecs_table_reset(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    flecs_table_clear_edges(world, table);
-}
+    /* Check if this is a trivial query */
+    if ((q->flags & EcsQueryMatchOnlyThis)) {
+        if (!(q->flags & 
+            (EcsQueryHasPred|EcsQueryMatchDisabled|EcsQueryMatchPrefab))) 
+        {
+            ECS_BIT_SET(q->flags, EcsQueryMatchOnlySelf);
 
-/* Keep track of number of traversable entities in table. A traversable entity
- * is an entity used as target in a pair with a traversable relationship. The
- * traversable count and flag are used by code to early out of mechanisms like
- * event propagation and recursive cleanup. */
-void flecs_table_traversable_add(
-    ecs_table_t *table,
-    int32_t value)
-{
-    int32_t result = table->_->traversable_count += value;
-    ecs_assert(result >= 0, ECS_INTERNAL_ERROR, NULL);
-    if (result == 0) {
-        table->flags &= ~EcsTableHasTraversable;
-    } else if (result == value) {
-        table->flags |= EcsTableHasTraversable;
-    }
-}
+            for (i = 0; i < term_count; i ++) {
+                ecs_term_t *term = &terms[i];
+                ecs_term_ref_t *src = &term->src;
 
-/* Mark table column dirty. This usually happens as the result of a set 
- * operation, or iteration of a query with [out] fields. */
-static
-void flecs_table_mark_table_dirty(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    int32_t index)
-{
-    (void)world;
-    if (table->dirty_state) {
-        table->dirty_state[index] ++;
-    }
-}
+                if (src->id & EcsUp) {
+                    ECS_BIT_CLEAR(q->flags, EcsQueryMatchOnlySelf);
+                }
 
-/* Mark table component dirty */
-void flecs_table_mark_dirty(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_entity_t component)
-{
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+                if (!(term->flags_ & EcsTermIsTrivial)) {
+                    break;
+                }
 
-    if (table->dirty_state) {
-        ecs_id_record_t *idr = flecs_id_record_get(world, component);
-        if (!idr) {
-            return;
-        }
+                if (!(q->flags & EcsQueryNoData)) {
+                    if (term->inout == EcsInOutNone) {
+                        break;
+                    }
+                }
+            }
 
-        const ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-        if (!tr || tr->column == -1) {
-            return;
+            if (term_count && (i == term_count)) {
+                ECS_BIT_SET(q->flags, EcsQueryIsTrivial);
+            }
         }
+    }
 
-        table->dirty_state[tr->column + 1] ++;
+    /* Set cacheable flags */
+    if (!(q->flags & EcsQueryMatchEmptyTables)) {
+        ECS_BIT_COND(q->flags, EcsQueryHasCacheable, 
+            cacheable_terms != 0);
+        ECS_BIT_COND(q->flags, EcsQueryIsCacheable, 
+            cacheable && (cacheable_terms == term_count));
     }
-}
 
-/* Get (or create) dirty state of table. Used by queries for change tracking */
-int32_t* flecs_table_get_dirty_state(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    if (!table->dirty_state) {
-        int32_t column_count = table->column_count;
-        table->dirty_state = flecs_alloc_n(&world->allocator,
-             int32_t, column_count + 1);
-        ecs_assert(table->dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
-        for (int i = 0; i < column_count + 1; i ++) {
-            table->dirty_state[i] = 1;
-        }
+    for (i = 0; i < q->term_count; i ++) {
+        ecs_term_t *term = &q->terms[i];
+        /* Post process term names in case they were used to create variables */
+        flecs_normalize_term_name(&term->first);
+        flecs_normalize_term_name(&term->second);
+        flecs_normalize_term_name(&term->src);
     }
-    return table->dirty_state;
+
+    return 0;
 }
 
-/* Table move logic for switch (union relationship) column */
 static
-void flecs_table_move_switch_columns(
-    ecs_table_t *dst_table, 
-    int32_t dst_index,
-    ecs_table_t *src_table, 
-    int32_t src_index,
-    int32_t count,
-    bool clear)
+int flecs_query_query_populate_terms(
+    ecs_world_t *world,
+    ecs_stage_t *stage,
+    ecs_query_t *q,
+    const ecs_query_desc_t *desc)
 {
-    ecs_table__t *dst_meta = dst_table->_;
-    ecs_table__t *src_meta = src_table->_;
-    if (!dst_meta && !src_meta) {
-        return;
+    /* Count number of initialized terms in desc->terms */
+    int32_t i, term_count = 0;
+    for (i = 0; i < FLECS_TERM_COUNT_MAX; i ++) {
+        if (!ecs_term_is_initialized(&desc->terms[i])) {
+            break;
+        }
+        term_count ++;
     }
 
-    int32_t i_old = 0, src_column_count = src_meta ? src_meta->sw_count : 0;
-    int32_t i_new = 0, dst_column_count = dst_meta ? dst_meta->sw_count : 0;
-    if (!src_column_count && !dst_column_count) {
-        return;
+    /* Copy terms from array to query */
+    if (term_count) {
+        ecs_os_memcpy_n(&q->terms, desc->terms, ecs_term_t, term_count);
     }
 
-    ecs_switch_t *src_columns = src_meta ? src_meta->sw_columns : NULL;
-    ecs_switch_t *dst_columns = dst_meta ? dst_meta->sw_columns : NULL;
-
-    ecs_type_t dst_type = dst_table->type;
-    ecs_type_t src_type = src_table->type;
+    /* Parse query expression if set */
+    const char *expr = desc->expr;
+    if (expr && expr[0]) {
+    #ifdef FLECS_SCRIPT
+        ecs_script_t script = {
+            .world = world,
+            .name = desc->entity ? ecs_get_name(world, desc->entity) : NULL,
+            .code = expr
+        };
 
-    int32_t offset_new = dst_meta ? dst_meta->sw_offset : 0;
-    int32_t offset_old = src_meta ? src_meta->sw_offset : 0;
+        /* Allocate buffer that's large enough to tokenize the query string */
+        script.token_buffer_size = ecs_os_strlen(expr) * 2 + 1;
+        script.token_buffer = flecs_alloc(
+            &stage->allocator, script.token_buffer_size);
 
-    ecs_id_t *dst_ids = dst_type.array;
-    ecs_id_t *src_ids = src_type.array;
+        if (flecs_terms_parse(&script, &q->terms[term_count], 
+            &term_count))
+        {
+            flecs_free(&stage->allocator, 
+                script.token_buffer_size, script.token_buffer);
+            goto error;
+        }
 
-    for (; (i_new < dst_column_count) && (i_old < src_column_count);) {
-        ecs_entity_t dst_id = dst_ids[i_new + offset_new];
-        ecs_entity_t src_id = src_ids[i_old + offset_old];
+        /* Store on query object so we can free later */
+        flecs_query_impl(q)->tokens = script.token_buffer;
+        flecs_query_impl(q)->tokens_len = 
+            flecs_ito(int16_t, script.token_buffer_size);
+    #else
+        (void)world;
+        (void)stage;
+        ecs_err("cannot parse query expression: script addon required");
+        goto error;
+    #endif
+    }
 
-        if (dst_id == src_id) {
-            ecs_switch_t *src_switch = &src_columns[i_old];
-            ecs_switch_t *dst_switch = &dst_columns[i_new];
+    q->term_count = flecs_ito(int8_t, term_count);
 
-            flecs_switch_ensure(dst_switch, dst_index + count);
+    return 0;
+error:  
+    return -1;
+}
 
-            int i;
-            for (i = 0; i < count; i ++) {
-                uint64_t value = flecs_switch_get(src_switch, src_index + i);
-                flecs_switch_set(dst_switch, dst_index + i, value);
-            }
+int flecs_query_finalize_query(
+    ecs_world_t *world,
+    ecs_query_t *q,
+    const ecs_query_desc_t *desc)    
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_query_desc_t was not initialized to zero");
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
 
-            if (clear) {
-                ecs_assert(count == flecs_switch_count(src_switch), 
-                    ECS_INTERNAL_ERROR, NULL);
-                flecs_switch_clear(src_switch);
-            }
-        } else if (dst_id > src_id) {
-            ecs_switch_t *src_switch = &src_columns[i_old];
-            flecs_switch_clear(src_switch);
-        }
+    q->flags |= desc->flags;
 
-        i_new += dst_id <= src_id;
-        i_old += dst_id >= src_id;
+    /* Populate term array from desc terms & DSL expression */
+    if (flecs_query_query_populate_terms(world, stage, q, desc)) {
+        goto error;
     }
 
-    /* Clear remaining columns */
-    if (clear) {
-        for (; (i_old < src_column_count); i_old ++) {
-            ecs_switch_t *src_switch = &src_columns[i_old];
-            ecs_assert(count == flecs_switch_count(src_switch), 
-                ECS_INTERNAL_ERROR, NULL);
-            flecs_switch_clear(src_switch);
-        }
+    /* Ensure all fields are consistent and properly filled out */
+    if (flecs_query_finalize_terms(world, q)) {
+        goto error;
     }
+
+    return 0;
+error:
+    return -1;
 }
 
-/* Table move logic for bitset (toggle component) column */
+
 static
-void flecs_table_move_bitset_columns(
-    ecs_table_t *dst_table, 
-    int32_t dst_index,
-    ecs_table_t *src_table, 
-    int32_t src_index,
-    int32_t count,
-    bool clear)
+ecs_entity_index_page_t* flecs_entity_index_ensure_page(
+    ecs_entity_index_t *index,
+    uint32_t id)
 {
-    ecs_table__t *dst_meta = dst_table->_;
-    ecs_table__t *src_meta = src_table->_;
-    if (!dst_meta && !src_meta) {
-        return;
+    int32_t page_index = (int32_t)(id >> FLECS_ENTITY_PAGE_BITS);
+    if (page_index >= ecs_vec_count(&index->pages)) {
+        ecs_vec_set_min_count_zeromem_t(index->allocator, &index->pages, 
+            ecs_entity_index_page_t*, page_index + 1);
     }
 
-    int32_t i_old = 0, src_column_count = src_meta ? src_meta->bs_count : 0;
-    int32_t i_new = 0, dst_column_count = dst_meta ? dst_meta->bs_count : 0;
-
-    if (!src_column_count && !dst_column_count) {
-        return;
+    ecs_entity_index_page_t **page_ptr = ecs_vec_get_t(&index->pages, 
+        ecs_entity_index_page_t*, page_index);
+    ecs_entity_index_page_t *page = *page_ptr;
+    if (!page) {
+        page = *page_ptr = flecs_bcalloc(&index->page_allocator);
+        ecs_assert(page != NULL, ECS_OUT_OF_MEMORY, NULL);
     }
 
-    ecs_bitset_t *src_columns = src_meta ? src_meta->bs_columns : NULL;
-    ecs_bitset_t *dst_columns = dst_meta ? dst_meta->bs_columns : NULL;
+    return page;
+}
 
-    ecs_type_t dst_type = dst_table->type;
-    ecs_type_t src_type = src_table->type;
+void flecs_entity_index_init(
+    ecs_allocator_t *allocator,
+    ecs_entity_index_t *index)
+{
+    index->allocator = allocator;
+    index->alive_count = 1;
+    ecs_vec_init_t(allocator, &index->dense, uint64_t, 1);
+    ecs_vec_set_count_t(allocator, &index->dense, uint64_t, 1);
+    ecs_vec_init_t(allocator, &index->pages, ecs_entity_index_page_t*, 0);
+    flecs_ballocator_init(&index->page_allocator, 
+        ECS_SIZEOF(ecs_entity_index_page_t));
+}
 
-    int32_t offset_new = dst_meta ? dst_meta->bs_offset : 0;
-    int32_t offset_old = src_meta ? src_meta->bs_offset : 0;
+void flecs_entity_index_fini(
+    ecs_entity_index_t *index)
+{
+    ecs_vec_fini_t(index->allocator, &index->dense, uint64_t);
+#if defined(FLECS_SANITIZE) || defined(FLECS_USE_OS_ALLOC)
+    int32_t i, count = ecs_vec_count(&index->pages);
+    ecs_entity_index_page_t **pages = ecs_vec_first(&index->pages);
+    for (i = 0; i < count; i ++) {
+        flecs_bfree(&index->page_allocator, pages[i]);
+    }
+#endif
+    ecs_vec_fini_t(index->allocator, &index->pages, ecs_entity_index_page_t*);
+    flecs_ballocator_fini(&index->page_allocator);
+}
 
-    ecs_id_t *dst_ids = dst_type.array;
-    ecs_id_t *src_ids = src_type.array;
+ecs_record_t* flecs_entity_index_get_any(
+    const ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    uint32_t id = (uint32_t)entity;
+    int32_t page_index = (int32_t)(id >> FLECS_ENTITY_PAGE_BITS);
+    ecs_entity_index_page_t *page = ecs_vec_get_t(&index->pages, 
+        ecs_entity_index_page_t*, page_index)[0];
+    ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
+    ecs_assert(r->dense != 0, ECS_INVALID_PARAMETER, 
+        "entity %u does not exist", (uint32_t)entity);
+    return r;
+}
 
-    for (; (i_new < dst_column_count) && (i_old < src_column_count);) {
-        ecs_id_t dst_id = dst_ids[i_new + offset_new];
-        ecs_id_t src_id = src_ids[i_old + offset_old];
+ecs_record_t* flecs_entity_index_get(
+    const ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    ecs_record_t *r = flecs_entity_index_get_any(index, entity);
+    ecs_assert(r->dense < index->alive_count, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(ecs_vec_get_t(&index->dense, uint64_t, r->dense)[0] == entity, 
+        ECS_INVALID_PARAMETER, "mismatching liveliness generation for entity");
+    return r;
+}
 
-        if (dst_id == src_id) {
-            ecs_bitset_t *src_bs = &src_columns[i_old];
-            ecs_bitset_t *dst_bs = &dst_columns[i_new];
+ecs_record_t* flecs_entity_index_try_get_any(
+    const ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    uint32_t id = (uint32_t)entity;
+    int32_t page_index = (int32_t)(id >> FLECS_ENTITY_PAGE_BITS);
+    if (page_index >= ecs_vec_count(&index->pages)) {
+        return NULL;
+    }
 
-            flecs_bitset_ensure(dst_bs, dst_index + count);
+    ecs_entity_index_page_t *page = ecs_vec_get_t(&index->pages, 
+        ecs_entity_index_page_t*, page_index)[0];
+    if (!page) {
+        return NULL;
+    }
 
-            int i;
-            for (i = 0; i < count; i ++) {
-                uint64_t value = flecs_bitset_get(src_bs, src_index + i);
-                flecs_bitset_set(dst_bs, dst_index + i, value);
-            }
+    ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
+    if (!r->dense) {
+        return NULL;
+    }
 
-            if (clear) {
-                ecs_assert(count == flecs_bitset_count(src_bs), 
-                    ECS_INTERNAL_ERROR, NULL);
-                flecs_bitset_fini(src_bs);
-            }
-        } else if (dst_id > src_id) {
-            ecs_bitset_t *src_bs = &src_columns[i_old];
-            flecs_bitset_fini(src_bs);
-        }
+    return r;
+}
 
-        i_new += dst_id <= src_id;
-        i_old += dst_id >= src_id;
+ecs_record_t* flecs_entity_index_try_get(
+    const ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    ecs_record_t *r = flecs_entity_index_try_get_any(index, entity);
+    if (r) {
+        if (r->dense >= index->alive_count) {
+            return NULL;
+        }
+        if (ecs_vec_get_t(&index->dense, uint64_t, r->dense)[0] != entity) {
+            return NULL;
+        }
     }
+    return r;
+}
 
-    /* Clear remaining columns */
-    if (clear) {
-        for (; (i_old < src_column_count); i_old ++) {
-            ecs_bitset_t *src_bs = &src_columns[i_old];
-            ecs_assert(count == flecs_bitset_count(src_bs), 
+ecs_record_t* flecs_entity_index_ensure(
+    ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    uint32_t id = (uint32_t)entity;
+    ecs_entity_index_page_t *page = flecs_entity_index_ensure_page(index, id);
+    ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
+
+    int32_t dense = r->dense;
+    if (dense) {
+        /* Entity is already alive, nothing to be done */
+        if (dense < index->alive_count) {
+            ecs_assert(
+                ecs_vec_get_t(&index->dense, uint64_t, dense)[0] == entity, 
                 ECS_INTERNAL_ERROR, NULL);
-            flecs_bitset_fini(src_bs);
+            return r;
         }
+    } else {
+        /* Entity doesn't have a dense index yet */
+        ecs_vec_append_t(index->allocator, &index->dense, uint64_t)[0] = entity;
+        r->dense = dense = ecs_vec_count(&index->dense) - 1;
+        index->max_id = id > index->max_id ? id : index->max_id;
     }
-}
 
-/* Grow table column. When a column needs to be reallocated this function takes
- * care of correctly invoking ctor/move/dtor hooks. */
-static
-void flecs_table_grow_column(
-    ecs_world_t *world,
-    ecs_column_t *column,
-    int32_t to_add,
-    int32_t dst_size,
-    bool construct)
-{
-    ecs_assert(column != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(dense != 0, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_type_info_t *ti = column->ti;
-    int32_t size = column->size;
-    int32_t count = column->data.count;
-    int32_t src_size = column->data.size;
-    int32_t dst_count = count + to_add;
-    bool can_realloc = dst_size != src_size;
-    void *result = NULL;
+    /* Entity is not alive, swap with first not alive element */
+    uint64_t *ids = ecs_vec_first(&index->dense);
+    uint64_t e_swap = ids[index->alive_count];
+    ecs_record_t *r_swap = flecs_entity_index_get_any(index, e_swap);
+    ecs_assert(r_swap->dense == index->alive_count, 
+        ECS_INTERNAL_ERROR, NULL);
 
-    ecs_assert(dst_size >= dst_count, ECS_INTERNAL_ERROR, NULL);
+    r_swap->dense = dense;
+    r->dense = index->alive_count;
+    ids[dense] = e_swap;
+    ids[index->alive_count ++] = entity;
 
-    /* If the array could possibly realloc and the component has a move action 
-     * defined, move old elements manually */
-    ecs_move_t move_ctor;
-    if (count && can_realloc && (move_ctor = ti->hooks.ctor_move_dtor)) {
-        ecs_xtor_t ctor = ti->hooks.ctor;
-        ecs_assert(ctor != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(move_ctor != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(flecs_entity_index_is_alive(index, entity), 
+        ECS_INTERNAL_ERROR, NULL);
 
-        /* Create  vector */
-        ecs_vec_t dst;
-        ecs_vec_init(&world->allocator, &dst, size, dst_size);
-        dst.count = dst_count;
+    return r;
+}
 
-        void *src_buffer = column->data.array;
-        void *dst_buffer = dst.array;
+void flecs_entity_index_remove(
+    ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    ecs_record_t *r = flecs_entity_index_try_get(index, entity);
+    if (!r) {
+        /* Entity is not alive or doesn't exist, nothing to be done */
+        return;
+    }
 
-        /* Move (and construct) existing elements to new vector */
-        move_ctor(dst_buffer, src_buffer, count, ti);
+    int32_t dense = r->dense;
+    int32_t i_swap = -- index->alive_count;
+    uint64_t *e_swap_ptr = ecs_vec_get_t(&index->dense, uint64_t, i_swap);
+    uint64_t e_swap = e_swap_ptr[0];
+    ecs_record_t *r_swap = flecs_entity_index_get_any(index, e_swap);
+    ecs_assert(r_swap->dense == i_swap, ECS_INTERNAL_ERROR, NULL);
 
-        if (construct) {
-            /* Construct new element(s) */
-            result = ECS_ELEM(dst_buffer, size, count);
-            ctor(result, to_add, ti);
-        }
+    r_swap->dense = dense;
+    r->table = NULL;
+    r->idr = NULL;
+    r->row = 0;
+    r->dense = i_swap;
+    ecs_vec_get_t(&index->dense, uint64_t, dense)[0] = e_swap;
+    e_swap_ptr[0] = ECS_GENERATION_INC(entity);
+    ecs_assert(!flecs_entity_index_is_alive(index, entity), 
+        ECS_INTERNAL_ERROR, NULL);
+}
 
-        /* Free old vector */
-        ecs_vec_fini(&world->allocator, &column->data, size);
+void flecs_entity_index_make_alive(
+    ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    ecs_record_t *r = flecs_entity_index_try_get_any(index, entity);
+    if (r) {
+        ecs_vec_get_t(&index->dense, uint64_t, r->dense)[0] = entity;
+    }
+}
 
-        column->data = dst;
+uint64_t flecs_entity_index_get_alive(
+    const ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    ecs_record_t *r = flecs_entity_index_try_get_any(index, entity);
+    if (r) {
+        return ecs_vec_get_t(&index->dense, uint64_t, r->dense)[0];
     } else {
-        /* If array won't realloc or has no move, simply add new elements */
-        if (can_realloc) {
-            ecs_vec_set_size(&world->allocator, &column->data, size, dst_size);
-        }
+        return 0;
+    }
+}
 
-        result = ecs_vec_grow(&world->allocator, &column->data, size, to_add);
+bool flecs_entity_index_is_alive(
+    const ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    return flecs_entity_index_try_get(index, entity) != NULL;
+}
 
-        ecs_xtor_t ctor;
-        if (construct && (ctor = ti->hooks.ctor)) {
-            /* If new elements need to be constructed and component has a
-             * constructor, construct */
-            ctor(result, to_add, ti);
-        }
+bool flecs_entity_index_is_valid(
+    const ecs_entity_index_t *index,
+    uint64_t entity)
+{
+    uint32_t id = (uint32_t)entity;    
+    ecs_record_t *r = flecs_entity_index_try_get_any(index, id);
+    if (!r || !r->dense) {
+        /* Doesn't exist yet, so is valid */
+        return true;
     }
 
-    ecs_assert(column->data.size == dst_size, ECS_INTERNAL_ERROR, NULL);
+    /* If the id exists, it must be alive */
+    return r->dense < index->alive_count;
 }
 
-/* Grow all data structures in a table */
-static
-int32_t flecs_table_grow_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data,
-    int32_t to_add,
-    int32_t size,
-    const ecs_entity_t *ids)
+bool flecs_entity_index_exists(
+    const ecs_entity_index_t *index,
+    uint64_t entity)
 {
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    int32_t cur_count = flecs_table_data_count(data);
-    int32_t column_count = table->column_count;
+    return flecs_entity_index_try_get_any(index, entity) != NULL;
+}
 
-    /* Add entity to column with entity ids */
-    ecs_vec_set_size_t(&world->allocator, &data->entities, ecs_entity_t, size);
-    ecs_entity_t *e = ecs_vec_last_t(&data->entities, ecs_entity_t) + 1;
-    data->entities.count += to_add;
-    if (data->entities.size > size) {
-        size = data->entities.size;
+uint64_t flecs_entity_index_new_id(
+    ecs_entity_index_t *index)
+{
+    if (index->alive_count != ecs_vec_count(&index->dense)) {
+        /* Recycle id */
+        return ecs_vec_get_t(&index->dense, uint64_t, index->alive_count ++)[0];
     }
 
-    /* Initialize entity ids and record ptrs */
-    int32_t i;
-    if (ids) {
-        ecs_os_memcpy_n(e, ids, ecs_entity_t, to_add);
-    } else {
-        ecs_os_memset(e, 0, ECS_SIZEOF(ecs_entity_t) * to_add);
-    }
+    /* Create new id */
+    uint32_t id = (uint32_t)++ index->max_id;
+    ecs_vec_append_t(index->allocator, &index->dense, uint64_t)[0] = id;
 
-    /* Add elements to each column array */
-    ecs_column_t *columns = data->columns;
-    for (i = 0; i < column_count; i ++) {
-        flecs_table_grow_column(world, &columns[i], to_add, size, true);
-        ecs_assert(columns[i].data.size == size, ECS_INTERNAL_ERROR, NULL);
-        flecs_table_invoke_add_hooks(world, table, &columns[i], e, 
-            cur_count, to_add, false);
-    }
+    ecs_entity_index_page_t *page = flecs_entity_index_ensure_page(index, id);
+    ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
+    r->dense = index->alive_count ++;
+    ecs_assert(index->alive_count == ecs_vec_count(&index->dense), 
+        ECS_INTERNAL_ERROR, NULL);
 
-    ecs_table__t *meta = table->_;
-    int32_t sw_count = meta->sw_count;
-    int32_t bs_count = meta->bs_count;
-    ecs_switch_t *sw_columns = meta->sw_columns;
-    ecs_bitset_t *bs_columns = meta->bs_columns; 
+    return id;
+}
 
-    /* Add elements to each switch column */
-    for (i = 0; i < sw_count; i ++) {
-        ecs_switch_t *sw = &sw_columns[i];
-        flecs_switch_addn(sw, to_add);
+uint64_t* flecs_entity_index_new_ids(
+    ecs_entity_index_t *index,
+    int32_t count)
+{
+    int32_t alive_count = index->alive_count;
+    int32_t new_count = alive_count + count;
+    int32_t dense_count = ecs_vec_count(&index->dense);
+
+    if (new_count < dense_count) {
+        /* Recycle ids */
+        index->alive_count = new_count;
+        return ecs_vec_get_t(&index->dense, uint64_t, alive_count);
     }
 
-    /* Add elements to each bitset column */
-    for (i = 0; i < bs_count; i ++) {
-        ecs_bitset_t *bs = &bs_columns[i];
-        flecs_bitset_addn(bs, to_add);
+    /* Allocate new ids */
+    ecs_vec_set_count_t(index->allocator, &index->dense, uint64_t, new_count);
+    int32_t i, to_add = new_count - dense_count;
+    for (i = 0; i < to_add; i ++) {
+        uint32_t id = (uint32_t)++ index->max_id;
+        int32_t dense = dense_count + i;
+        ecs_vec_get_t(&index->dense, uint64_t, dense)[0] = id;
+        ecs_entity_index_page_t *page = flecs_entity_index_ensure_page(index, id);
+        ecs_assert(page != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
+        r->dense = dense;
     }
 
-    /* If the table is monitored indicate that there has been a change */
-    flecs_table_mark_table_dirty(world, table, 0);
+    index->alive_count = new_count;
+    return ecs_vec_get_t(&index->dense, uint64_t, alive_count);
+}
 
-    if (!(world->flags & EcsWorldReadonly) && !cur_count) {
-        flecs_table_set_empty(world, table);
+void flecs_entity_index_set_size(
+    ecs_entity_index_t *index,
+    int32_t size)
+{
+    ecs_vec_set_size_t(index->allocator, &index->dense, uint64_t, size);
+}
+
+int32_t flecs_entity_index_count(
+    const ecs_entity_index_t *index)
+{
+    return index->alive_count - 1;
+}
+
+int32_t flecs_entity_index_size(
+    const ecs_entity_index_t *index)
+{
+    return ecs_vec_count(&index->dense) - 1;
+}
+
+int32_t flecs_entity_index_not_alive_count(
+    const ecs_entity_index_t *index)
+{
+    return ecs_vec_count(&index->dense) - index->alive_count;
+}
+
+void flecs_entity_index_clear(
+    ecs_entity_index_t *index)
+{
+    int32_t i, count = ecs_vec_count(&index->pages);
+    ecs_entity_index_page_t **pages = ecs_vec_first_t(&index->pages, 
+        ecs_entity_index_page_t*);
+    for (i = 0; i < count; i ++) {
+        ecs_entity_index_page_t *page = pages[i];
+        if (page) {
+            ecs_os_zeromem(page);
+        }
     }
 
-    /* Return index of first added entity */
-    return cur_count;
+    ecs_vec_set_count_t(index->allocator, &index->dense, uint64_t, 1);
+
+    index->alive_count = 1;
+    index->max_id = 0;
+}
+
+const uint64_t* flecs_entity_index_ids(
+    const ecs_entity_index_t *index)
+{
+    return ecs_vec_get_t(&index->dense, uint64_t, 1);
 }
 
-/* Append operation for tables that don't have any complex logic */
 static
-void flecs_table_fast_append(
-    ecs_world_t *world,
-    ecs_column_t *columns,
-    int32_t count)
+void flecs_entity_index_copy_intern(
+    ecs_entity_index_t * dst,
+    const ecs_entity_index_t * src)
 {
-    /* Add elements to each column array */
-    int32_t i;
-    for (i = 0; i < count; i ++) {
-        ecs_column_t *column = &columns[i];
-        ecs_vec_append(&world->allocator, &column->data, column->size);
+    flecs_entity_index_set_size(dst, flecs_entity_index_size(src));
+    const uint64_t *ids = flecs_entity_index_ids(src);
+    
+    int32_t i, count = src->alive_count;
+    for (i = 0; i < count - 1; i ++) {
+        uint64_t id = ids[i];
+        ecs_record_t *src_ptr = flecs_entity_index_get(src, id);
+        ecs_record_t *dst_ptr = flecs_entity_index_ensure(dst, id);
+        flecs_entity_index_make_alive(dst, id);
+        ecs_os_memcpy_t(dst_ptr, src_ptr, ecs_record_t);
     }
-}
 
-/* Append entity to table */
-int32_t flecs_table_append(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_entity_t entity,
-    bool construct,
-    bool on_add)
-{
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(!(table->flags & EcsTableHasTarget), 
-        ECS_INVALID_OPERATION, NULL);
+    dst->max_id = src->max_id;
 
-    flecs_table_check_sanity(table);
+    ecs_assert(src->alive_count == dst->alive_count, ECS_INTERNAL_ERROR, NULL);
+}
 
-    /* Get count & size before growing entities array. This tells us whether the
-     * arrays will realloc */
-    ecs_data_t *data = &table->data;
-    int32_t count = data->entities.count;
-    int32_t column_count = table->column_count;
-    ecs_column_t *columns = table->data.columns;
+void flecs_entity_index_copy(
+    ecs_entity_index_t *dst,
+    const ecs_entity_index_t *src)
+{
+    if (!src) {
+        return;
+    }
 
-    /* Grow buffer with entity ids, set new element to new entity */
-    ecs_entity_t *e = ecs_vec_append_t(&world->allocator, 
-        &data->entities, ecs_entity_t);
-    ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL);
-    *e = entity;
- 
-    /* If the table is monitored indicate that there has been a change */
-    flecs_table_mark_table_dirty(world, table, 0);
-    ecs_assert(count >= 0, ECS_INTERNAL_ERROR, NULL);
+    flecs_entity_index_init(src->allocator, dst);
+    flecs_entity_index_copy_intern(dst, src);
+}
 
-    /* Fast path: no switch columns, no lifecycle actions */
-    if (!(table->flags & EcsTableIsComplex)) {
-        flecs_table_fast_append(world, columns, column_count);
-        if (!count) {
-            flecs_table_set_empty(world, table); /* See below */
-        }
-        return count;
+void flecs_entity_index_restore(
+    ecs_entity_index_t *dst,
+    const ecs_entity_index_t *src)
+{
+    if (!src) {
+        return;
     }
 
-    ecs_entity_t *entities = data->entities.array;
+    flecs_entity_index_clear(dst);
+    flecs_entity_index_copy_intern(dst, src);
+}
 
-    /* Reobtain size to ensure that the columns have the same size as the 
-     * entities and record vectors. This keeps reasoning about when allocations
-     * occur easier. */
-    int32_t size = data->entities.size;
+/**
+ * @file id_index.c
+ * @brief Index for looking up tables by (component) id.
+ * 
+ * An id record stores the administration for an in use (component) id, that is
+ * an id that has been used in tables.
+ * 
+ * An id record contains a table cache, which stores the list of tables that
+ * have the id. Each entry in the cache (a table record) stores the first 
+ * occurrence of the id in the table and the number of occurrences of the id in
+ * the table (in the case of wildcard ids).
+ * 
+ * Id records are used in lots of scenarios, like uncached queries, or for 
+ * getting a component array/component for an entity.
+ */
 
-    /* Grow component arrays with 1 element */
-    int32_t i;
-    for (i = 0; i < column_count; i ++) {
-        ecs_column_t *column = &columns[i];
-        flecs_table_grow_column(world, column, 1, size, construct);
 
-        ecs_iter_action_t on_add_hook;
-        if (on_add && (on_add_hook = column->ti->hooks.on_add)) {
-            flecs_table_invoke_hook(world, table, on_add_hook, EcsOnAdd, column,
-                &entities[count], count, 1);
-        }
+static
+ecs_id_record_elem_t* flecs_id_record_elem(
+    ecs_id_record_t *head,
+    ecs_id_record_elem_t *list,
+    ecs_id_record_t *idr)
+{
+    return ECS_OFFSET(idr, (uintptr_t)list - (uintptr_t)head);
+}
 
-        ecs_assert(columns[i].data.size == 
-            data->entities.size, ECS_INTERNAL_ERROR, NULL); 
-        ecs_assert(columns[i].data.count == 
-            data->entities.count, ECS_INTERNAL_ERROR, NULL);
+static
+void flecs_id_record_elem_insert(
+    ecs_id_record_t *head,
+    ecs_id_record_t *idr,
+    ecs_id_record_elem_t *elem)
+{
+    ecs_id_record_elem_t *head_elem = flecs_id_record_elem(idr, elem, head);
+    ecs_id_record_t *cur = head_elem->next;
+    elem->next = cur;
+    elem->prev = head;
+    if (cur) {
+        ecs_id_record_elem_t *cur_elem = flecs_id_record_elem(idr, elem, cur);
+        cur_elem->prev = idr;
     }
+    head_elem->next = idr;
+}
 
-    ecs_table__t *meta = table->_;
-    int32_t sw_count = meta->sw_count;
-    int32_t bs_count = meta->bs_count;
-    ecs_switch_t *sw_columns = meta->sw_columns;
-    ecs_bitset_t *bs_columns = meta->bs_columns;
-
-    /* Add element to each switch column */
-    for (i = 0; i < sw_count; i ++) {
-        ecs_assert(sw_columns != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_switch_t *sw = &sw_columns[i];
-        flecs_switch_add(sw);
-    }
+static
+void flecs_id_record_elem_remove(
+    ecs_id_record_t *idr,
+    ecs_id_record_elem_t *elem)
+{
+    ecs_id_record_t *prev = elem->prev;
+    ecs_id_record_t *next = elem->next;
+    ecs_assert(prev != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    /* Add element to each bitset column */
-    for (i = 0; i < bs_count; i ++) {
-        ecs_assert(bs_columns != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_bitset_t *bs = &bs_columns[i];
-        flecs_bitset_addn(bs, 1);
+    ecs_id_record_elem_t *prev_elem = flecs_id_record_elem(idr, elem, prev);
+    prev_elem->next = next;
+    if (next) {
+        ecs_id_record_elem_t *next_elem = flecs_id_record_elem(idr, elem, next);
+        next_elem->prev = prev;
     }
+}
 
-    /* If this is the first entity in this table, signal queries so that the
-     * table moves from an inactive table to an active table. */
-    if (!count) {
-        flecs_table_set_empty(world, table);
+static
+void flecs_insert_id_elem(
+    ecs_world_t *world,
+    ecs_id_record_t *idr,
+    ecs_id_t wildcard,
+    ecs_id_record_t *widr)
+{
+    ecs_assert(ecs_id_is_wildcard(wildcard), ECS_INTERNAL_ERROR, NULL);
+    if (!widr) {
+        widr = flecs_id_record_ensure(world, wildcard);
     }
+    ecs_assert(widr != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    flecs_table_check_sanity(table);
+    if (ECS_PAIR_SECOND(wildcard) == EcsWildcard) {
+        ecs_assert(ECS_PAIR_FIRST(wildcard) != EcsWildcard, 
+            ECS_INTERNAL_ERROR, NULL);
+        flecs_id_record_elem_insert(widr, idr, &idr->first);
+    } else {
+        ecs_assert(ECS_PAIR_FIRST(wildcard) == EcsWildcard, 
+            ECS_INTERNAL_ERROR, NULL);
+        flecs_id_record_elem_insert(widr, idr, &idr->second);
 
-    return count;
+        if (idr->flags & EcsIdTraversable) {
+            flecs_id_record_elem_insert(widr, idr, &idr->trav);
+        }
+    }
 }
 
-/* Delete last operation for tables that don't have any complex logic */
 static
-void flecs_table_fast_delete_last(
-    ecs_column_t *columns,
-    int32_t column_count) 
+void flecs_remove_id_elem(
+    ecs_id_record_t *idr,
+    ecs_id_t wildcard)
 {
-    int i;
-    for (i = 0; i < column_count; i ++) {
-        ecs_vec_remove_last(&columns[i].data);
+    ecs_assert(ecs_id_is_wildcard(wildcard), ECS_INTERNAL_ERROR, NULL);
+
+    if (ECS_PAIR_SECOND(wildcard) == EcsWildcard) {
+        ecs_assert(ECS_PAIR_FIRST(wildcard) != EcsWildcard, 
+            ECS_INTERNAL_ERROR, NULL);
+        flecs_id_record_elem_remove(idr, &idr->first);
+    } else {
+        ecs_assert(ECS_PAIR_FIRST(wildcard) == EcsWildcard, 
+            ECS_INTERNAL_ERROR, NULL);
+        flecs_id_record_elem_remove(idr, &idr->second);
+
+        if (idr->flags & EcsIdTraversable) {
+            flecs_id_record_elem_remove(idr, &idr->trav);
+        }
     }
 }
 
-/* Delete operation for tables that don't have any complex logic */
 static
-void flecs_table_fast_delete(
-    ecs_column_t *columns,
-    int32_t column_count,
-    int32_t index) 
+ecs_id_t flecs_id_record_hash(
+    ecs_id_t id)
 {
-    int i;
-    for (i = 0; i < column_count; i ++) {
-        ecs_column_t *column = &columns[i];
-        ecs_vec_remove(&column->data, column->size, index);
+    id = ecs_strip_generation(id);
+    if (ECS_IS_PAIR(id)) {
+        ecs_entity_t r = ECS_PAIR_FIRST(id);
+        ecs_entity_t o = ECS_PAIR_SECOND(id);
+        if (r == EcsAny) {
+            r = EcsWildcard;
+        }
+        if (o == EcsAny) {
+            o = EcsWildcard;
+        }
+        id = ecs_pair(r, o);
     }
+    return id;
 }
 
-/* Delete entity from table */
-void flecs_table_delete(
+static
+ecs_id_record_t* flecs_id_record_new(
     ecs_world_t *world,
-    ecs_table_t *table,
-    int32_t index,
-    bool destruct)
+    ecs_id_t id)
 {
-    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(!(table->flags & EcsTableHasTarget), 
-        ECS_INVALID_OPERATION, NULL);
-
-    flecs_table_check_sanity(table);
+    ecs_id_record_t *idr, *idr_t = NULL;
+    ecs_id_t hash = flecs_id_record_hash(id);
+    if (hash >= FLECS_HI_ID_RECORD_ID) {
+        idr = flecs_bcalloc(&world->allocators.id_record);
+        ecs_map_insert_ptr(&world->id_index_hi, hash, idr);
+    } else {
+        idr = &world->id_index_lo[hash];
+        ecs_os_zeromem(idr);
+    }
 
-    ecs_data_t *data = &table->data;
-    int32_t count = data->entities.count;
+    ecs_table_cache_init(world, &idr->cache);
 
-    ecs_assert(count > 0, ECS_INTERNAL_ERROR, NULL);
-    count --;
-    ecs_assert(index <= count, ECS_INTERNAL_ERROR, NULL);
+    idr->id = id;
+    idr->refcount = 1;
+    idr->reachable.current = -1;
 
-    /* Move last entity id to index */
-    ecs_entity_t *entities = data->entities.array;
-    ecs_entity_t entity_to_move = entities[count];
-    ecs_entity_t entity_to_delete = entities[index];
-    entities[index] = entity_to_move;
-    ecs_vec_remove_last(&data->entities);
+    bool is_wildcard = ecs_id_is_wildcard(id);
+    bool is_pair = ECS_IS_PAIR(id);
 
-    /* Update record of moved entity in entity index */
-    if (index != count) {
-        ecs_record_t *record_to_move = flecs_entities_get(world, entity_to_move);
-        if (record_to_move) {
-            uint32_t row_flags = record_to_move->row & ECS_ROW_FLAGS_MASK;
-            record_to_move->row = ECS_ROW_TO_RECORD(index, row_flags);
-            ecs_assert(record_to_move->table != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(record_to_move->table == table, ECS_INTERNAL_ERROR, NULL);
-        }
-    }     
+    ecs_entity_t rel = 0, tgt = 0, role = id & ECS_ID_FLAGS_MASK;
+    if (is_pair) {
+        // rel = ecs_pair_first(world, id);
+        rel = ECS_PAIR_FIRST(id);
+        rel = flecs_entities_get_alive(world, rel);
+        ecs_assert(rel != 0, ECS_INTERNAL_ERROR, NULL);
 
-    /* If the table is monitored indicate that there has been a change */
-    flecs_table_mark_table_dirty(world, table, 0);    
+        /* Relationship object can be 0, as tables without a ChildOf 
+         * relationship are added to the (ChildOf, 0) id record */
+        tgt = ECS_PAIR_SECOND(id);
 
-    /* If table is empty, deactivate it */
-    if (!count) {
-        flecs_table_set_empty(world, table);
-    }
+#ifdef FLECS_DEBUG
+        /* Check constraints */
+        if (tgt) {
+            tgt = flecs_entities_get_alive(world, tgt);
+            ecs_assert(tgt != 0, ECS_INTERNAL_ERROR, NULL);
 
-    /* Destruct component data */
-    ecs_column_t *columns = data->columns;
-    int32_t column_count = table->column_count;
-    int32_t i;
+            /* Can't use relationship as target */
+            if (ecs_has_id(world, tgt, EcsRelationship)) {
+                if (!ecs_id_is_wildcard(rel) && 
+                    !ecs_has_id(world, rel, EcsTrait)) 
+                {
+                    char *idstr = ecs_id_str(world, id);
+                    char *tgtstr = ecs_id_str(world, tgt);
+                    ecs_err("constraint violated: relationship '%s' cannot be used"
+                        " as target in pair '%s'", tgtstr, idstr);
+                    ecs_os_free(tgtstr);
+                    ecs_os_free(idstr);
+                    #ifndef FLECS_SOFT_ASSERT
+                    ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
+                    #endif
+                }
+            }
+        }
 
-    /* If this is a table without lifecycle callbacks or special columns, take
-     * fast path that just remove an element from the array(s) */
-    if (!(table->flags & EcsTableIsComplex)) {
-        if (index == count) {
-            flecs_table_fast_delete_last(columns, column_count);
-        } else {
-            flecs_table_fast_delete(columns, column_count, index);
+        if (ecs_has_id(world, rel, EcsTarget)) {
+            char *idstr = ecs_id_str(world, id);
+            char *relstr = ecs_id_str(world, rel);
+            ecs_err("constraint violated: "
+                "%s: target '%s' cannot be used as relationship",
+                    idstr, relstr);
+            ecs_os_free(relstr);
+            ecs_os_free(idstr);
+            #ifndef FLECS_SOFT_ASSERT
+            ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
+            #endif
         }
 
-        flecs_table_check_sanity(table);
-        return;
-    }
+        if (tgt && !ecs_id_is_wildcard(tgt)) {
+            /* Check if target of relationship satisfies OneOf property */
+            ecs_entity_t oneof = flecs_get_oneof(world, rel);
+            if (oneof) {
+                if (!ecs_has_pair(world, tgt, EcsChildOf, oneof)) {
+                    char *idstr = ecs_id_str(world, id);
+                    char *tgtstr = ecs_get_fullpath(world, tgt);
+                    char *oneofstr = ecs_get_fullpath(world, oneof);
+                    ecs_err("OneOf constraint violated: "
+                        "%s: '%s' is not a child of '%s'",
+                        idstr, tgtstr, oneofstr);
+                    ecs_os_free(oneofstr);
+                    ecs_os_free(tgtstr);
+                    ecs_os_free(idstr);
+                    #ifndef FLECS_SOFT_ASSERT
+                    ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
+                    #endif
+                }
+            }
 
-    /* Last element, destruct & remove */
-    if (index == count) {
-        /* If table has component destructors, invoke */
-        if (destruct && (table->flags & EcsTableHasDtors)) {            
-            for (i = 0; i < column_count; i ++) {
-                flecs_table_invoke_remove_hooks(world, table, &columns[i], 
-                    &entity_to_delete, index, 1, true);
+            /* Check if we're not trying to inherit from a final target */
+            if (rel == EcsIsA) {
+                if (ecs_has_id(world, tgt, EcsFinal)) {
+                    char *idstr = ecs_id_str(world, id);
+                    char *tgtstr = ecs_get_fullpath(world, tgt);
+                    ecs_err("Final constraint violated: "
+                            "%s: cannot inherit from final entity '%s'",
+                        idstr, tgtstr);
+                    ecs_os_free(tgtstr);
+                    ecs_os_free(idstr);
+                    #ifndef FLECS_SOFT_ASSERT
+                    ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
+                    #endif
+                }
             }
         }
+#endif
 
-        flecs_table_fast_delete_last(columns, column_count);
+        if (!is_wildcard && (rel != EcsFlag)) {
+            /* Inherit flags from (relationship, *) record */
+            ecs_id_record_t *idr_r = flecs_id_record_ensure(
+                world, ecs_pair(rel, EcsWildcard));
+            idr->parent = idr_r;
+            idr->flags = idr_r->flags;
 
-    /* Not last element, move last element to deleted element & destruct */
-    } else {
-        /* If table has component destructors, invoke */
-        if ((table->flags & (EcsTableHasDtors | EcsTableHasMove))) {
-            for (i = 0; i < column_count; i ++) {
-                ecs_column_t *column = &columns[i];
-                ecs_type_info_t *ti = column->ti;
-                ecs_size_t size = column->size;
-                void *dst = ecs_vec_get(&column->data, size, index);
-                void *src = ecs_vec_last(&column->data, size);
+            /* If pair is not a wildcard, append it to wildcard lists. These 
+             * allow for quickly enumerating all relationships for an object, 
+             * or all objects for a relationship. */
+            flecs_insert_id_elem(world, idr, ecs_pair(rel, EcsWildcard), idr_r);
 
-                ecs_iter_action_t on_remove = ti->hooks.on_remove;
-                if (destruct && on_remove) {
-                    flecs_table_invoke_hook(world, table, on_remove, EcsOnRemove,
-                        column, &entity_to_delete, index, 1);
-                }
+            idr_t = flecs_id_record_ensure(world, ecs_pair(EcsWildcard, tgt));
+            flecs_insert_id_elem(world, idr, ecs_pair(EcsWildcard, tgt), idr_t);
+        }
+    } else {
+        rel = id & ECS_COMPONENT_MASK;
+        ecs_assert(rel != 0, ECS_INTERNAL_ERROR, NULL);
 
-                ecs_move_t move_dtor = ti->hooks.move_dtor;
-                
-                // If neither move nor move_ctor are set, this indicates that non-destructive move 
-                // semantics are not supported for this type. In such cases, we set the move_dtor
-                // as ctor_move_dtor, which indicates a destructive move operation. 
-                // This adjustment ensures compatibility with different language bindings.
-                if (!ti->hooks.move_ctor && ti->hooks.ctor_move_dtor) {
-                  move_dtor = ti->hooks.ctor_move_dtor;
-                }
+        /* Can't use relationship outside of a pair */
+#ifdef FLECS_DEBUG
+        rel = flecs_entities_get_alive(world, rel);
+        if (ecs_has_id(world, rel, EcsRelationship) ||
+            ecs_has_id(world, rel, EcsTarget)) 
+        {
+            char *idstr = ecs_id_str(world, id);
+            char *relstr = ecs_id_str(world, rel);
+            ecs_err("constraint violated: "
+                "%s: relationship '%s' cannot be used as component",
+                    idstr, relstr);
+            ecs_os_free(relstr);
+            ecs_os_free(idstr);
+            #ifndef FLECS_SOFT_ASSERT
+            ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
+            #endif
+        }
 
-                if (move_dtor) {
-                    move_dtor(dst, src, 1, ti);
-                } else {
-                    ecs_os_memcpy(dst, src, size);
-                }
+        if (ecs_has_id(world, rel, EcsTarget)) {
+            char *idstr = ecs_id_str(world, id);
+            char *relstr = ecs_id_str(world, rel);
+            ecs_err("constraint violated: "
+                "%s: target '%s' cannot be used as component",
+                    idstr, relstr);
+            ecs_os_free(relstr);
+            ecs_os_free(idstr);
+            #ifndef FLECS_SOFT_ASSERT
+            ecs_abort(ECS_CONSTRAINT_VIOLATED, NULL);
+            #endif
+        }
+#endif
+    }
 
-                ecs_vec_remove_last(&column->data);
+    /* Initialize type info if id is not a tag */
+    if (!is_wildcard && (!role || is_pair)) {
+        if (!(idr->flags & EcsIdTag)) {
+            const ecs_type_info_t *ti = flecs_type_info_get(world, rel);
+            if (!ti && tgt) {
+                ti = flecs_type_info_get(world, tgt);
             }
-        } else {
-            flecs_table_fast_delete(columns, column_count, index);
+            idr->type_info = ti;
+        }
+    }
+
+    /* Mark entities that are used as component/pair ids. When a tracked
+     * entity is deleted, cleanup policies are applied so that the store
+     * won't contain any tables with deleted ids. */
+
+    /* Flag for OnDelete policies */
+    flecs_add_flag(world, rel, EcsEntityIsId);
+    if (tgt) {
+        /* Flag for OnDeleteTarget policies */
+        ecs_record_t *tgt_r = flecs_entities_get_any(world, tgt);
+        ecs_assert(tgt_r != NULL, ECS_INTERNAL_ERROR, NULL);
+        flecs_record_add_flag(tgt_r, EcsEntityIsTarget);
+        if (idr->flags & EcsIdTraversable) {
+            /* Flag used to determine if object should be traversed when
+             * propagating events or with super/subset queries */
+            flecs_record_add_flag(tgt_r, EcsEntityIsTraversable);
+
+            /* Add reference to (*, tgt) id record to entity record */
+            tgt_r->idr = idr_t;
         }
     }
 
-    /* Remove elements from switch columns */
-    ecs_table__t *meta = table->_;
-    ecs_switch_t *sw_columns = meta->sw_columns;
-    int32_t sw_count = meta->sw_count;
-    for (i = 0; i < sw_count; i ++) {
-        flecs_switch_remove(&sw_columns[i], index);
-    }
+    ecs_observable_t *o = &world->observable;
+    idr->flags |= flecs_observers_exist(o, id, EcsOnAdd) * EcsIdHasOnAdd;
+    idr->flags |= flecs_observers_exist(o, id, EcsOnRemove) * EcsIdHasOnRemove;
+    idr->flags |= flecs_observers_exist(o, id, EcsOnSet) * EcsIdHasOnSet;
+    idr->flags |= flecs_observers_exist(o, id, EcsUnSet) * EcsIdHasUnSet;
+    idr->flags |= flecs_observers_exist(o, id, EcsOnTableFill) * EcsIdHasOnTableFill;
+    idr->flags |= flecs_observers_exist(o, id, EcsOnTableEmpty) * EcsIdHasOnTableEmpty;
+    idr->flags |= flecs_observers_exist(o, id, EcsOnTableCreate) * EcsIdHasOnTableCreate;
+    idr->flags |= flecs_observers_exist(o, id, EcsOnTableDelete) * EcsIdHasOnTableDelete;
+
+    if (ecs_should_log_1()) {
+        char *id_str = ecs_id_str(world, id);
+        ecs_dbg_1("#[green]id#[normal] %s #[green]created", id_str);
+        ecs_os_free(id_str);
+    }
+
+    /* Update counters */
+    world->info.id_create_total ++;
+    world->info.component_id_count += idr->type_info != NULL;
+    world->info.tag_id_count += idr->type_info == NULL;
+    world->info.pair_id_count += is_pair;
 
-    /* Remove elements from bitset columns */
-    ecs_bitset_t *bs_columns = meta->bs_columns;
-    int32_t bs_count = meta->bs_count;
-    for (i = 0; i < bs_count; i ++) {
-        flecs_bitset_remove(&bs_columns[i], index);
-    }
+    return idr;
+}
 
-    flecs_table_check_sanity(table);
+static
+void flecs_id_record_assert_empty(
+    ecs_id_record_t *idr)
+{
+    (void)idr;
+    ecs_assert(flecs_table_cache_count(&idr->cache) == 0, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(flecs_table_cache_empty_count(&idr->cache) == 0, 
+        ECS_INTERNAL_ERROR, NULL);
 }
 
-/* Move operation for tables that don't have any complex logic */
 static
-void flecs_table_fast_move(
-    ecs_table_t *dst_table,
-    int32_t dst_index,
-    ecs_table_t *src_table,
-    int32_t src_index)
+void flecs_id_record_free(
+    ecs_world_t *world,
+    ecs_id_record_t *idr)
 {
-    int32_t i_new = 0, dst_column_count = dst_table->column_count;
-    int32_t i_old = 0, src_column_count = src_table->column_count;
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_id_t id = idr->id;
 
-    ecs_column_t *src_columns = src_table->data.columns;
-    ecs_column_t *dst_columns = dst_table->data.columns;
+    flecs_id_record_assert_empty(idr);
 
-    for (; (i_new < dst_column_count) && (i_old < src_column_count);) {
-        ecs_column_t *dst_column = &dst_columns[i_new];
-        ecs_column_t *src_column = &src_columns[i_old];
-        ecs_id_t dst_id = dst_column->id;
-        ecs_id_t src_id = src_column->id;
+    /* Id is still in use by a query */
+    ecs_assert((world->flags & EcsWorldQuit) || (idr->keep_alive == 0), 
+        ECS_ID_IN_USE, "cannot delete id that is queried for");
 
-        if (dst_id == src_id) {
-            int32_t size = dst_column->size;
-            void *dst = ecs_vec_get(&dst_column->data, size, dst_index);
-            void *src = ecs_vec_get(&src_column->data, size, src_index);
-            ecs_os_memcpy(dst, src, size);
+    if (ECS_IS_PAIR(id)) {
+        ecs_entity_t rel = ECS_PAIR_FIRST(id);
+        ecs_entity_t tgt = ECS_PAIR_SECOND(id);
+        if (!ecs_id_is_wildcard(id)) {
+            if (ECS_PAIR_FIRST(id) != EcsFlag) {
+                /* If id is not a wildcard, remove it from the wildcard lists */
+                flecs_remove_id_elem(idr, ecs_pair(rel, EcsWildcard));
+                flecs_remove_id_elem(idr, ecs_pair(EcsWildcard, tgt));
+            }
+        } else {
+            ecs_log_push_2();
+
+            /* If id is a wildcard, it means that all id records that match the
+             * wildcard are also empty, so release them */
+            if (ECS_PAIR_FIRST(id) == EcsWildcard) {
+                /* Iterate (*, Target) list */
+                ecs_id_record_t *cur, *next = idr->second.next;
+                while ((cur = next)) {
+                    flecs_id_record_assert_empty(cur);
+                    next = cur->second.next;
+                    flecs_id_record_release(world, cur);
+                }
+            } else {
+                /* Iterate (Relationship, *) list */
+                ecs_assert(ECS_PAIR_SECOND(id) == EcsWildcard, 
+                    ECS_INTERNAL_ERROR, NULL);
+                ecs_id_record_t *cur, *next = idr->first.next;
+                while ((cur = next)) {
+                    flecs_id_record_assert_empty(cur);
+                    next = cur->first.next;
+                    flecs_id_record_release(world, cur);
+                }
+            }
+
+            ecs_log_pop_2();
         }
+    }
 
-        i_new += dst_id <= src_id;
-        i_old += dst_id >= src_id;
+    /* Update counters */
+    world->info.id_delete_total ++;
+    world->info.pair_id_count -= ECS_IS_PAIR(id);
+    world->info.component_id_count -= idr->type_info != NULL;
+    world->info.tag_id_count -= idr->type_info == NULL;
+
+    /* Unregister the id record from the world & free resources */
+    ecs_table_cache_fini(&idr->cache);
+    flecs_name_index_free(idr->name_index);
+    ecs_vec_fini_t(&world->allocator, &idr->reachable.ids, ecs_reachable_elem_t);
+
+    ecs_id_t hash = flecs_id_record_hash(id);
+    if (hash >= FLECS_HI_ID_RECORD_ID) {
+        ecs_map_remove(&world->id_index_hi, hash);
+        flecs_bfree(&world->allocators.id_record, idr);
+    } else {
+        idr->id = 0; /* Tombstone */
+    }
+
+    if (ecs_should_log_1()) {
+        char *id_str = ecs_id_str(world, id);
+        ecs_dbg_1("#[green]id#[normal] %s #[red]deleted", id_str);
+        ecs_os_free(id_str);
     }
 }
 
-/* Move entity from src to dst table */
-void flecs_table_move(
+ecs_id_record_t* flecs_id_record_ensure(
     ecs_world_t *world,
-    ecs_entity_t dst_entity,
-    ecs_entity_t src_entity,
-    ecs_table_t *dst_table,
-    int32_t dst_index,
-    ecs_table_t *src_table,
-    int32_t src_index,
-    bool construct)
+    ecs_id_t id)
 {
-    ecs_assert(dst_table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(src_table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!dst_table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(!src_table->_->lock, ECS_LOCKED_STORAGE, NULL);
-
-    ecs_assert(src_index >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(dst_index >= 0, ECS_INTERNAL_ERROR, NULL);
-
-    flecs_table_check_sanity(dst_table);
-    flecs_table_check_sanity(src_table);
-
-    if (!((dst_table->flags | src_table->flags) & EcsTableIsComplex)) {
-        flecs_table_fast_move(dst_table, dst_index, src_table, src_index);
-        flecs_table_check_sanity(dst_table);
-        flecs_table_check_sanity(src_table);
-        return;
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        idr = flecs_id_record_new(world, id);
     }
+    return idr;
+}
 
-    flecs_table_move_switch_columns(dst_table, dst_index, src_table, src_index, 1, false);
-    flecs_table_move_bitset_columns(dst_table, dst_index, src_table, src_index, 1, false);
+ecs_id_record_t* flecs_id_record_get(
+    const ecs_world_t *world,
+    ecs_id_t id)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    if (id == ecs_pair(EcsIsA, EcsWildcard)) {
+        return world->idr_isa_wildcard;
+    } else if (id == ecs_pair(EcsChildOf, EcsWildcard)) {
+        return world->idr_childof_wildcard;
+    } else if (id == ecs_pair_t(EcsIdentifier, EcsName)) {
+        return world->idr_identifier_name;
+    }
 
-    /* If the source and destination entities are the same, move component 
-     * between tables. If the entities are not the same (like when cloning) use
-     * a copy. */
-    bool same_entity = dst_entity == src_entity;
+    ecs_id_t hash = flecs_id_record_hash(id);
+    ecs_id_record_t *idr = NULL;
+    if (hash >= FLECS_HI_ID_RECORD_ID) {
+        idr = ecs_map_get_deref(&world->id_index_hi, ecs_id_record_t, hash);
+    } else {
+        idr = &world->id_index_lo[hash];
+        if (!idr->id) {
+            idr = NULL;
+        }
+    }
 
-    /* Call move_dtor for moved away from storage only if the entity is at the
-     * last index in the source table. If it isn't the last entity, the last 
-     * entity in the table will be moved to the src storage, which will take
-     * care of cleaning up resources. */
-    bool use_move_dtor = ecs_table_count(src_table) == (src_index + 1);
+    return idr;
+}
 
-    int32_t i_new = 0, dst_column_count = dst_table->column_count;
-    int32_t i_old = 0, src_column_count = src_table->column_count;
+void flecs_id_record_claim(
+    ecs_world_t *world,
+    ecs_id_record_t *idr)
+{
+    (void)world;
+    idr->refcount ++;
+}
 
-    ecs_column_t *src_columns = src_table->data.columns;
-    ecs_column_t *dst_columns = dst_table->data.columns;
+int32_t flecs_id_record_release(
+    ecs_world_t *world,
+    ecs_id_record_t *idr)
+{
+    int32_t rc = -- idr->refcount;
+    ecs_assert(rc >= 0, ECS_INTERNAL_ERROR, NULL);
 
-    for (; (i_new < dst_column_count) && (i_old < src_column_count); ) {
-        ecs_column_t *dst_column = &dst_columns[i_new];
-        ecs_column_t *src_column = &src_columns[i_old];
-        ecs_id_t dst_id = dst_column->id;
-        ecs_id_t src_id = src_column->id;
+    if (!rc) {
+        flecs_id_record_free(world, idr);
+    }
 
-        if (dst_id == src_id) {
-            int32_t size = dst_column->size;
+    return rc;
+}
 
-            ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL);
-            void *dst = ecs_vec_get(&dst_column->data, size, dst_index);
-            void *src = ecs_vec_get(&src_column->data, size, src_index);
-            ecs_type_info_t *ti = dst_column->ti;
+void flecs_id_record_release_tables(
+    ecs_world_t *world,
+    ecs_id_record_t *idr)
+{
+    /* Cache should not contain tables that aren't empty */
+    ecs_assert(flecs_table_cache_count(&idr->cache) == 0, 
+        ECS_INTERNAL_ERROR, NULL);
 
-            if (same_entity) {
-                ecs_move_t move = ti->hooks.move_ctor;
-                if (use_move_dtor || !move) {
-                    /* Also use move_dtor if component doesn't have a move_ctor
-                     * registered, to ensure that the dtor gets called to 
-                     * cleanup resources. */
-                    move = ti->hooks.ctor_move_dtor;
-                }
+    ecs_table_cache_iter_t it;
+    if (flecs_table_cache_empty_iter(&idr->cache, &it)) {
+        ecs_table_record_t *tr;
+        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+            /* Release current table */
+            flecs_table_fini(world, tr->hdr.table);
+        }
+    }
+}
 
-                if (move) {
-                    move(dst, src, 1, ti);
-                } else {
-                    ecs_os_memcpy(dst, src, size);
-                }
-            } else {
-                ecs_copy_t copy = ti->hooks.copy_ctor;
-                if (copy) {
-                    copy(dst, src, 1, ti);
-                } else {
-                    ecs_os_memcpy(dst, src, size);
-                }
+bool flecs_id_record_set_type_info(
+    ecs_world_t *world,
+    ecs_id_record_t *idr,
+    const ecs_type_info_t *ti)
+{
+    bool is_wildcard = ecs_id_is_wildcard(idr->id);
+    if (!is_wildcard) {
+        if (ti) {
+            if (!idr->type_info) {
+                world->info.tag_id_count --;
+                world->info.component_id_count ++;
             }
         } else {
-            if (dst_id < src_id) {
-                flecs_table_invoke_add_hooks(world, dst_table,
-                    dst_column, &dst_entity, dst_index, 1, construct);
-            } else {
-                flecs_table_invoke_remove_hooks(world, src_table,
-                    src_column, &src_entity, src_index, 1, use_move_dtor);
+            if (idr->type_info) {
+                world->info.tag_id_count ++;
+                world->info.component_id_count --;
             }
         }
-
-        i_new += dst_id <= src_id;
-        i_old += dst_id >= src_id;
     }
 
-    for (; (i_new < dst_column_count); i_new ++) {
-        flecs_table_invoke_add_hooks(world, dst_table, &dst_columns[i_new], 
-            &dst_entity, dst_index, 1, construct);
-    }
+    bool changed = idr->type_info != ti;
+    idr->type_info = ti;
 
-    for (; (i_old < src_column_count); i_old ++) {
-        flecs_table_invoke_remove_hooks(world, src_table, &src_columns[i_old], 
-            &src_entity, src_index, 1, use_move_dtor);
+    return changed;
+}
+
+ecs_hashmap_t* flecs_id_record_name_index_ensure(
+    ecs_world_t *world,
+    ecs_id_record_t *idr)
+{
+    ecs_hashmap_t *map = idr->name_index;
+    if (!map) {
+        map = idr->name_index = flecs_name_index_new(world, &world->allocator);
     }
 
-    flecs_table_check_sanity(dst_table);
-    flecs_table_check_sanity(src_table);
+    return map;
 }
 
-/* Append n entities to table */
-int32_t flecs_table_appendn(
+ecs_hashmap_t* flecs_id_name_index_ensure(
     ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data,
-    int32_t to_add,
-    const ecs_entity_t *ids)
+    ecs_id_t id)
 {
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    flecs_poly_assert(world, ecs_world_t);
 
-    flecs_table_check_sanity(table);
-    int32_t cur_count = flecs_table_data_count(data);
-    int32_t result = flecs_table_grow_data(
-        world, table, data, to_add, cur_count + to_add, ids);
-    flecs_table_check_sanity(table);
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    return result;
+    return flecs_id_record_name_index_ensure(world, idr);
 }
 
-/* Set allocated table size */
-void flecs_table_set_size(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data,
-    int32_t size)
+ecs_hashmap_t* flecs_id_name_index_get(
+    const ecs_world_t *world,
+    ecs_id_t id)
 {
-    ecs_assert(table != NULL, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    flecs_poly_assert(world, ecs_world_t);
 
-    flecs_table_check_sanity(table);
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return NULL;
+    }
 
-    int32_t cur_count = flecs_table_data_count(data);
+    return idr->name_index;
+}
 
-    if (cur_count < size) {
-        flecs_table_grow_data(world, table, data, 0, size, NULL);
-        flecs_table_check_sanity(table);
+ecs_table_record_t* flecs_table_record_get(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    ecs_id_t id)
+{
+    flecs_poly_assert(world, ecs_world_t);
+
+    ecs_id_record_t* idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return NULL;
     }
+
+    return (ecs_table_record_t*)ecs_table_cache_get(&idr->cache, table);
 }
 
-/* Shrink table storage to fit number of entities */
-bool flecs_table_shrink(
-    ecs_world_t *world,
-    ecs_table_t *table)
+ecs_table_record_t* flecs_id_record_get_table(
+    const ecs_id_record_t *idr,
+    const ecs_table_t *table)
 {
-    ecs_assert(table != NULL, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    (void)world;
+    ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+    return (ecs_table_record_t*)ecs_table_cache_get(&idr->cache, table);
+}
 
-    flecs_table_check_sanity(table);
+void flecs_init_id_records(
+    ecs_world_t *world)
+{
+    /* Cache often used id records on world */
+    world->idr_wildcard = flecs_id_record_ensure(world, EcsWildcard);
+    world->idr_wildcard_wildcard = flecs_id_record_ensure(world, 
+        ecs_pair(EcsWildcard, EcsWildcard));
+    world->idr_any = flecs_id_record_ensure(world, EcsAny);
+    world->idr_isa_wildcard = flecs_id_record_ensure(world, 
+        ecs_pair(EcsIsA, EcsWildcard));
+}
 
-    ecs_data_t *data = &table->data;
-    bool has_payload = data->entities.array != NULL;
-    ecs_vec_reclaim_t(&world->allocator, &data->entities, ecs_entity_t);
+void flecs_fini_id_records(
+    ecs_world_t *world)
+{
+    /* Loop & delete first element until there are no elements left. Id records
+     * can recursively delete each other, this ensures we always have a
+     * valid iterator. */
+    while (ecs_map_count(&world->id_index_hi) > 0) {
+        ecs_map_iter_t it = ecs_map_iter(&world->id_index_hi);
+        ecs_map_next(&it);
+        flecs_id_record_release(world, ecs_map_ptr(&it));
+    }
 
-    int32_t i, count = table->column_count;
-    for (i = 0; i < count; i ++) {
-        ecs_column_t *column = &data->columns[i];
-        ecs_vec_reclaim(&world->allocator, &column->data, column->size);
+    int32_t i;
+    for (i = 0; i < FLECS_HI_ID_RECORD_ID; i ++) {
+        ecs_id_record_t *idr = &world->id_index_lo[i];
+        if (idr->id) {
+            flecs_id_record_release(world, idr);
+        }
     }
 
-    return has_payload;
-}
+    ecs_assert(ecs_map_count(&world->id_index_hi) == 0, 
+        ECS_INTERNAL_ERROR, NULL);
 
-/* Return number of entities in table */
-int32_t flecs_table_data_count(
-    const ecs_data_t *data)
-{
-    return data ? data->entities.count : 0;
+    ecs_map_fini(&world->id_index_hi);
+    ecs_os_free(world->id_index_lo);
 }
 
-/* Swap operation for switch (union relationship) columns */
+/**
+ * @file table.c
+ * @brief Table storage implementation.
+ * 
+ * Tables are the data structure that store the component data. Tables have
+ * columns for each component in the table, and rows for each entity stored in
+ * the table. Once created, the component list for a table doesn't change, but
+ * entities can move from one table to another.
+ * 
+ * Each table has a type, which is a vector with the (component) ids in the 
+ * table. The vector is sorted by id, which ensures that there can be only one
+ * table for each unique combination of components.
+ * 
+ * Not all ids in a table have to be components. Tags are ids that have no
+ * data type associated with them, and as a result don't need to be explicitly
+ * stored beyond an element in the table type. To save space and speed up table
+ * creation, each table has a reference to a "storage table", which is a table
+ * that only includes component ids (so excluding tags).
+ * 
+ * Note that the actual data is not stored on the storage table. The storage 
+ * table is only used for sharing administration. A column_map member maps
+ * between column indices of the table and its storage table. Tables are 
+ * refcounted, which ensures that storage tables won't be deleted if other
+ * tables have references to it.
+ */
+
+
+/* Table sanity check to detect storage issues. Only enabled in SANITIZE mode as
+ * this can severely slow down many ECS operations. */
+#ifdef FLECS_SANITIZE
 static
-void flecs_table_swap_switch_columns(
-    ecs_table_t *table,
-    int32_t row_1,
-    int32_t row_2)
-{
-    int32_t i = 0, column_count = table->_->sw_count;
-    if (!column_count) {
-        return;
-    }
+void flecs_table_check_sanity(ecs_table_t *table) {
+    int32_t size = ecs_vec_size(&table->data.entities);
+    int32_t count = ecs_vec_count(&table->data.entities);
+
+    int32_t i;
+    int32_t bs_offset = table->_ ? table->_->bs_offset : 0;
+    int32_t bs_count = table->_ ? table->_->bs_count : 0;
+    int32_t type_count = table->type.count;
+    ecs_id_t *ids = table->type.array;
 
-    ecs_switch_t *columns = table->_->sw_columns;
+    ecs_assert((bs_count + bs_offset) <= type_count, ECS_INTERNAL_ERROR, NULL);
 
-    for (i = 0; i < column_count; i ++) {
-        ecs_switch_t *sw = &columns[i];
-        flecs_switch_swap(sw, row_1, row_2);
+    if (table->column_count) {
+        int32_t column_count = table->column_count;
+        ecs_assert(type_count >= column_count, ECS_INTERNAL_ERROR, NULL);
+
+        int32_t *column_map = table->column_map;
+        ecs_assert(column_map != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        ecs_assert(table->data.columns != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        for (i = 0; i < column_count; i ++) {
+            ecs_vec_t *column = &table->data.columns[i].data;
+            ecs_assert(size == column->size, ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(count == column->count, ECS_INTERNAL_ERROR, NULL);
+            int32_t column_map_id = column_map[i + type_count];
+            ecs_assert(column_map_id >= 0, ECS_INTERNAL_ERROR, NULL);
+        }
+    } else {
+        ecs_assert(table->column_map == NULL, ECS_INTERNAL_ERROR, NULL);
+    }
+
+    if (bs_count) {
+        ecs_assert(table->_->bs_columns != NULL, 
+            ECS_INTERNAL_ERROR, NULL);
+        for (i = 0; i < bs_count; i ++) {
+            ecs_bitset_t *bs = &table->_->bs_columns[i];
+            ecs_assert(flecs_bitset_count(bs) == count,
+                ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(ECS_HAS_ID_FLAG(ids[i + bs_offset], TOGGLE),
+                ECS_INTERNAL_ERROR, NULL);
+        }
     }
+
+    ecs_assert((table->_->traversable_count == 0) || 
+        (table->flags & EcsTableHasTraversable), ECS_INTERNAL_ERROR, NULL);
 }
+#else
+#define flecs_table_check_sanity(table)
+#endif
 
-/* Swap operation for bitset (toggle component) columns */
+/* Set flags for type hooks so table operations can quickly check whether a
+ * fast or complex operation that invokes hooks is required. */
 static
-void flecs_table_swap_bitset_columns(
-    ecs_table_t *table,
-    int32_t row_1,
-    int32_t row_2)
+ecs_flags32_t flecs_type_info_flags(
+    const ecs_type_info_t *ti) 
 {
-    int32_t i = 0, column_count = table->_->bs_count;
-    if (!column_count) {
-        return;
+    ecs_flags32_t flags = 0;
+
+    if (ti->hooks.ctor) {
+        flags |= EcsTableHasCtors;
+    }
+    if (ti->hooks.on_add) {
+        flags |= EcsTableHasCtors;
+    }
+    if (ti->hooks.dtor) {
+        flags |= EcsTableHasDtors;
+    }
+    if (ti->hooks.on_remove) {
+        flags |= EcsTableHasDtors;
     }
-
-    ecs_bitset_t *columns = table->_->bs_columns;
-
-    for (i = 0; i < column_count; i ++) {
-        ecs_bitset_t *bs = &columns[i];
-        flecs_bitset_swap(bs, row_1, row_2);
+    if (ti->hooks.copy) {
+        flags |= EcsTableHasCopy;
     }
+    if (ti->hooks.move) {
+        flags |= EcsTableHasMove;
+    }  
+
+    return flags;  
 }
 
-/* Swap two rows in a table. Used for table sorting. */
-void flecs_table_swap(
+static
+void flecs_table_init_columns(
     ecs_world_t *world,
     ecs_table_t *table,
-    int32_t row_1,
-    int32_t row_2)
-{    
-    (void)world;
-
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(row_1 >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(row_2 >= 0, ECS_INTERNAL_ERROR, NULL);
-
-    flecs_table_check_sanity(table);
-    
-    if (row_1 == row_2) {
+    int32_t column_count)
+{
+    if (!column_count) {
         return;
     }
 
-    /* If the table is monitored indicate that there has been a change */
-    flecs_table_mark_table_dirty(world, table, 0);    
-
-    ecs_entity_t *entities = table->data.entities.array;
-    ecs_entity_t e1 = entities[row_1];
-    ecs_entity_t e2 = entities[row_2];
+    int32_t i, cur = 0, ids_count = table->type.count;
+    ecs_column_t *columns = flecs_wcalloc_n(world, ecs_column_t, column_count);
+    table->data.columns = columns;
 
-    ecs_record_t *record_ptr_1 = flecs_entities_get(world, e1);
-    ecs_record_t *record_ptr_2 = flecs_entities_get(world, e2);
+    ecs_id_t *ids = table->type.array;
+    ecs_table_record_t *records = table->_->records;
+    int32_t *t2s = table->column_map;
+    int32_t *s2t = &table->column_map[ids_count];
 
-    ecs_assert(record_ptr_1 != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(record_ptr_2 != NULL, ECS_INTERNAL_ERROR, NULL);
+    for (i = 0; i < ids_count; i ++) {
+        ecs_table_record_t *tr = &records[i];
+        ecs_id_record_t *idr = (ecs_id_record_t*)tr->hdr.cache;
+        const ecs_type_info_t *ti = idr->type_info;
+        if (!ti) {
+            t2s[i] = -1;
+            continue;
+        }
 
-    /* Keep track of whether entity is watched */
-    uint32_t flags_1 = ECS_RECORD_TO_ROW_FLAGS(record_ptr_1->row);
-    uint32_t flags_2 = ECS_RECORD_TO_ROW_FLAGS(record_ptr_2->row);
+        t2s[i] = cur;
+        s2t[cur] = i;
+        tr->column = flecs_ito(int16_t, cur);
 
-    /* Swap entities & records */
-    entities[row_1] = e2;
-    entities[row_2] = e1;
-    record_ptr_1->row = ECS_ROW_TO_RECORD(row_2, flags_1);
-    record_ptr_2->row = ECS_ROW_TO_RECORD(row_1, flags_2);
+        columns[cur].ti = ECS_CONST_CAST(ecs_type_info_t*, ti);
+        columns[cur].id = ids[i];
+        columns[cur].size = ti->size;
 
-    flecs_table_swap_switch_columns(table, row_1, row_2);
-    flecs_table_swap_bitset_columns(table, row_1, row_2);
+        if (ECS_IS_PAIR(ids[i])) {
+            ecs_table_record_t *wc_tr = flecs_id_record_get_table(
+                idr->parent, table);
+            if (wc_tr->index == tr->index) {
+                wc_tr->column = tr->column;
+            }
+        }
 
-    ecs_column_t *columns = table->data.columns;
-    if (!columns) {
-        flecs_table_check_sanity(table);
-        return;
-    }
+#ifdef FLECS_DEBUG
+        ecs_vec_init(NULL, &columns[cur].data, ti->size, 0);
+#endif
 
-    /* Find the maximum size of column elements
-     * and allocate a temporary buffer for swapping */
-    int32_t i, temp_buffer_size = ECS_SIZEOF(uint64_t), column_count = table->column_count;
-    for (i = 0; i < column_count; i++) {
-        temp_buffer_size = ECS_MAX(temp_buffer_size, columns[i].size);
+        table->flags |= flecs_type_info_flags(ti);
+        cur ++;
     }
+}
 
-    void* tmp = ecs_os_alloca(temp_buffer_size);
+/* Initialize table storage */
+void flecs_table_init_data(
+    ecs_world_t *world,
+    ecs_table_t *table)
+{
+    ecs_data_t *storage = &table->data;
+    ecs_vec_init_t(NULL, &storage->entities, ecs_entity_t, 0);
 
-    /* Swap columns */
-    for (i = 0; i < column_count; i ++) {
-        int32_t size = columns[i].size;
-        ecs_column_t *column = &columns[i];
-        void *ptr = column->data.array;
-        const ecs_type_info_t *ti = column->ti;
-        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_table_init_columns(world, table, table->column_count);
 
-        void *el_1 = ECS_ELEM(ptr, size, row_1);
-        void *el_2 = ECS_ELEM(ptr, size, row_2);
+    ecs_table__t *meta = table->_;
+    int32_t i, bs_count = meta->bs_count;
 
-        ecs_move_t move = ti->hooks.move;
-        if (!move) {
-            ecs_os_memcpy(tmp, el_1, size);
-            ecs_os_memcpy(el_1, el_2, size);
-            ecs_os_memcpy(el_2, tmp, size);
-        } else {
-            ecs_move_t move_ctor = ti->hooks.move_ctor;
-            ecs_move_t move_dtor = ti->hooks.move_dtor;
-            ecs_assert(move_ctor != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(move_dtor != NULL, ECS_INTERNAL_ERROR, NULL);
-            move_ctor(tmp, el_1, 1, ti);
-            move(el_1, el_2, 1, ti);
-            move_dtor(el_2, tmp, 1, ti);
+    if (bs_count) {
+        meta->bs_columns = flecs_wcalloc_n(world, ecs_bitset_t, bs_count);
+        for (i = 0; i < bs_count; i ++) {
+            flecs_bitset_init(&meta->bs_columns[i]);
         }
     }
-
-    flecs_table_check_sanity(table);
 }
 
+/* Initialize table flags. Table flags are used in lots of scenarios to quickly
+ * check the features of a table without having to inspect the table type. Table
+ * flags are typically used to early-out of potentially expensive operations. */
 static
-void flecs_table_merge_vec(
+void flecs_table_init_flags(
     ecs_world_t *world,
-    ecs_vec_t *dst,
-    ecs_vec_t *src,
-    int32_t size,
-    int32_t elem_size)
+    ecs_table_t *table)
 {
-    int32_t dst_count = dst->count;
+    ecs_id_t *ids = table->type.array;
+    int32_t count = table->type.count;
 
-    if (!dst_count) {
-        ecs_vec_fini(&world->allocator, dst, size);
-        *dst = *src;
-        src->array = NULL;
-        src->count = 0;
-        src->size = 0;
-    } else {
-        int32_t src_count = src->count;
+    int32_t i;
+    for (i = 0; i < count; i ++) {
+        ecs_id_t id = ids[i];
 
-        if (elem_size) {
-            ecs_vec_set_size(&world->allocator, 
-                dst, size, elem_size);
+        if (id <= EcsLastInternalComponentId) {
+            table->flags |= EcsTableHasBuiltins;
         }
-        ecs_vec_set_count(&world->allocator, 
-            dst, size, dst_count + src_count);
 
-        void *dst_ptr = ECS_ELEM(dst->array, size, dst_count);
-        void *src_ptr = src->array;
-        ecs_os_memcpy(dst_ptr, src_ptr, size * src_count);
+        if (id == EcsModule) {
+            table->flags |= EcsTableHasBuiltins;
+            table->flags |= EcsTableHasModule;
+        } else if (id == EcsPrefab) {
+            table->flags |= EcsTableIsPrefab;
+        } else if (id == EcsDisabled) {
+            table->flags |= EcsTableIsDisabled;
+        } else if (id == EcsNotQueryable) {
+            table->flags |= EcsTableNotQueryable;
+        } else {
+            if (ECS_IS_PAIR(id)) {
+                ecs_entity_t r = ECS_PAIR_FIRST(id);
 
-        ecs_vec_fini(&world->allocator, src, size);
+                table->flags |= EcsTableHasPairs;
+
+                if (r == EcsIsA) {
+                    table->flags |= EcsTableHasIsA;
+                } else if (r == EcsChildOf) {
+                    table->flags |= EcsTableHasChildOf;
+                    ecs_entity_t obj = ecs_pair_second(world, id);
+                    ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL);
+
+                    if (obj == EcsFlecs || obj == EcsFlecsCore || 
+                        ecs_has_id(world, obj, EcsModule)) 
+                    {
+                        /* If table contains entities that are inside one of the 
+                         * builtin modules, it contains builtin entities */
+                        table->flags |= EcsTableHasBuiltins;
+                        table->flags |= EcsTableHasModule;
+                    }
+                } else if (id == ecs_pair_t(EcsIdentifier, EcsName)) {
+                    table->flags |= EcsTableHasName;
+                } else if (r == ecs_id(EcsPoly)) {
+                    table->flags |= EcsTableHasBuiltins;
+                }
+            } else {
+                if (ECS_HAS_ID_FLAG(id, TOGGLE)) {
+                    ecs_table__t *meta = table->_;
+                    table->flags |= EcsTableHasToggle;
+
+                    if (!meta->bs_count) {
+                        meta->bs_offset = flecs_ito(int16_t, i);
+                    }
+                    meta->bs_count ++;
+                }
+                if (ECS_HAS_ID_FLAG(id, OVERRIDE)) {
+                    table->flags |= EcsTableHasOverrides;
+                }
+            }
+        } 
     }
 }
 
-/* Merge data from one table column into other table column */
+/* Utility function that appends an element to the table record array */
 static
-void flecs_table_merge_column(
+void flecs_table_append_to_records(
     ecs_world_t *world,
-    ecs_column_t *dst,
-    ecs_column_t *src,
-    int32_t column_size)
+    ecs_table_t *table,
+    ecs_vec_t *records,
+    ecs_id_t id,
+    int32_t column)
 {
-    ecs_size_t size = dst->size;
-    int32_t dst_count = dst->data.count;
-
-    if (!dst_count) {
-        ecs_vec_fini(&world->allocator, &dst->data, size);
-        *dst = *src;
-        src->data.array = NULL;
-        src->data.count = 0;
-        src->data.size = 0;
+    /* To avoid a quadratic search, use the O(1) lookup that the index
+     * already provides. */
+    ecs_id_record_t *idr = flecs_id_record_ensure(world, id);
+    ecs_table_record_t *tr = (ecs_table_record_t*)flecs_id_record_get_table(
+            idr, table);
+    if (!tr) {
+        tr = ecs_vec_append_t(&world->allocator, records, ecs_table_record_t);
+        tr->index = flecs_ito(int16_t, column);
+        tr->count = 1;
 
-    /* If the new table is not empty, copy the contents from the
-     * src into the dst. */
+        ecs_table_cache_insert(&idr->cache, table, &tr->hdr);
     } else {
-        int32_t src_count = src->data.count;
-
-        flecs_table_grow_column(world, dst, src_count, column_size, false);
-        void *dst_ptr = ECS_ELEM(dst->data.array, size, dst_count);
-        void *src_ptr = src->data.array;
+        tr->count ++;
+    }
 
-        /* Move values into column */
-        ecs_type_info_t *ti = dst->ti;
-        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_move_t move = ti->hooks.ctor_move_dtor;
-        if (move) {
-            move(dst_ptr, src_ptr, src_count, ti);
-        } else {
-            ecs_os_memcpy(dst_ptr, src_ptr, size * src_count);
-        }
+    ecs_assert(tr->hdr.cache != NULL, ECS_INTERNAL_ERROR, NULL);
+}
 
-        ecs_vec_fini(&world->allocator, &src->data, size);
-    }
+void flecs_table_emit(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_entity_t event)
+{
+    flecs_emit(world, world, &(ecs_event_desc_t) {
+        .ids = &table->type,
+        .event = event,
+        .table = table,
+        .flags = EcsEventTableOnly,
+        .observable = world
+    });
 }
 
-/* Merge storage of two tables. */
-static
-void flecs_table_merge_data(
+/* Main table initialization function */
+void flecs_table_init(
     ecs_world_t *world,
-    ecs_table_t *dst_table,
-    ecs_table_t *src_table,
-    int32_t src_count,
-    int32_t dst_count,
-    ecs_data_t *src_data,
-    ecs_data_t *dst_data)
+    ecs_table_t *table,
+    ecs_table_t *from)
 {
-    int32_t i_new = 0, dst_column_count = dst_table->column_count;
-    int32_t i_old = 0, src_column_count = src_table->column_count;
-    ecs_column_t *src_columns = src_data->columns;
-    ecs_column_t *dst_columns = dst_data->columns;
+    /* Make sure table->flags is initialized */
+    flecs_table_init_flags(world, table);
 
-    ecs_assert(!dst_column_count || dst_columns, ECS_INTERNAL_ERROR, NULL);
+    /* The following code walks the table type to discover which id records the
+     * table needs to register table records with. 
+     *
+     * In addition to registering itself with id records for each id in the
+     * table type, a table also registers itself with wildcard id records. For
+     * example, if a table contains (Eats, Apples), it will register itself with
+     * wildcard id records (Eats, *),  (*, Apples) and (*, *). This makes it
+     * easier for wildcard queries to find the relevant tables. */
 
-    if (!src_count) {
-        return;
+    int32_t dst_i = 0, dst_count = table->type.count;
+    int32_t src_i = 0, src_count = 0;
+    ecs_id_t *dst_ids = table->type.array;
+    ecs_id_t *src_ids = NULL;
+    ecs_table_record_t *tr = NULL, *src_tr = NULL;
+    if (from) {
+        src_count = from->type.count;
+        src_ids = from->type.array;
+        src_tr = from->_->records;
     }
 
-    /* Merge entities */
-    flecs_table_merge_vec(world, &dst_data->entities, &src_data->entities, 
-        ECS_SIZEOF(ecs_entity_t), 0);
-    ecs_assert(dst_data->entities.count == src_count + dst_count, 
-        ECS_INTERNAL_ERROR, NULL);
-    int32_t column_size = dst_data->entities.size;
+    /* We don't know in advance how large the records array will be, so use
+     * cached vector. This eliminates unnecessary allocations, and/or expensive
+     * iterations to determine how many records we need. */
     ecs_allocator_t *a = &world->allocator;
+    ecs_vec_t *records = &world->store.records;
+    ecs_vec_reset_t(a, records, ecs_table_record_t);
+    ecs_id_record_t *idr, *childof_idr = NULL;
+
+    int32_t last_id = -1; /* Track last regular (non-pair) id */
+    int32_t first_pair = -1; /* Track the first pair in the table */
+    int32_t first_role = -1; /* Track first id with role */
+
+    /* Scan to find boundaries of regular ids, pairs and roles */
+    for (dst_i = 0; dst_i < dst_count; dst_i ++) {
+        ecs_id_t dst_id = dst_ids[dst_i];
+        if (first_pair == -1 && ECS_IS_PAIR(dst_id)) {
+            first_pair = dst_i;
+        }
+        if ((dst_id & ECS_COMPONENT_MASK) == dst_id) {
+            last_id = dst_i;
+        } else if (first_role == -1 && !ECS_IS_PAIR(dst_id)) {
+            first_role = dst_i;
+        }
+    }
+
+    /* The easy part: initialize a record for every id in the type */
+    for (dst_i = 0; (dst_i < dst_count) && (src_i < src_count); ) {
+        ecs_id_t dst_id = dst_ids[dst_i];
+        ecs_id_t src_id = src_ids[src_i];
+
+        idr = NULL;
 
-    for (; (i_new < dst_column_count) && (i_old < src_column_count); ) {
-        ecs_column_t *dst_column = &dst_columns[i_new];
-        ecs_column_t *src_column = &src_columns[i_old];
-        ecs_id_t dst_id = dst_column->id;
-        ecs_id_t src_id = src_column->id;
-    
         if (dst_id == src_id) {
-            flecs_table_merge_column(world, dst_column, src_column, column_size);
-            flecs_table_mark_table_dirty(world, dst_table, i_new + 1);
-            i_new ++;
-            i_old ++;
+            ecs_assert(src_tr != NULL, ECS_INTERNAL_ERROR, NULL);
+            idr = (ecs_id_record_t*)src_tr[src_i].hdr.cache;
         } else if (dst_id < src_id) {
-            /* New column, make sure vector is large enough. */
-            ecs_size_t size = dst_column->size;
-            ecs_vec_set_size(a, &dst_column->data, size, column_size);
-            ecs_vec_set_count(a, &dst_column->data, size, src_count + dst_count);
-            flecs_table_invoke_ctor(dst_column, dst_count, src_count);
-            i_new ++;
-        } else if (dst_id > src_id) {
-            /* Old column does not occur in new table, destruct */
-            flecs_table_invoke_dtor(src_column, 0, src_count);
-            ecs_vec_fini(a, &src_column->data, src_column->size);
-            i_old ++;
+            idr = flecs_id_record_ensure(world, dst_id);
+        }
+        if (idr) {
+            tr = ecs_vec_append_t(a, records, ecs_table_record_t);
+            tr->hdr.cache = (ecs_table_cache_t*)idr;
+            tr->index = flecs_ito(int16_t, dst_i);
+            tr->count = 1;
         }
+
+        dst_i += dst_id <= src_id;
+        src_i += dst_id >= src_id;
     }
 
-    flecs_table_move_switch_columns(dst_table, dst_count, src_table, 0, src_count, true);
-    flecs_table_move_bitset_columns(dst_table, dst_count, src_table, 0, src_count, true);
+    /* Add remaining ids that the "from" table didn't have */
+    for (; (dst_i < dst_count); dst_i ++) {
+        ecs_id_t dst_id = dst_ids[dst_i];
+        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
+        idr = flecs_id_record_ensure(world, dst_id);
+        tr->hdr.cache = (ecs_table_cache_t*)idr;
+        ecs_assert(tr->hdr.cache != NULL, ECS_INTERNAL_ERROR, NULL);
+        tr->index = flecs_ito(int16_t, dst_i);
+        tr->count = 1;
+    }
 
-    /* Initialize remaining columns */
-    for (; i_new < dst_column_count; i_new ++) {
-        ecs_column_t *column = &dst_columns[i_new];
-        int32_t size = column->size;
-        ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL);
-        ecs_vec_set_size(a, &column->data, size, column_size);
-        ecs_vec_set_count(a, &column->data, size, src_count + dst_count);
-        flecs_table_invoke_ctor(column, dst_count, src_count);
+    /* We're going to insert records from the vector into the index that
+     * will get patched up later. To ensure the record pointers don't get
+     * invalidated we need to grow the vector so that it won't realloc as
+     * we're adding the next set of records */
+    if (first_role != -1 || first_pair != -1) {
+        int32_t start = first_role;
+        if (first_pair != -1 && (start != -1 || first_pair < start)) {
+            start = first_pair;
+        }
+
+        /* Total number of records can never be higher than
+         * - number of regular (non-pair) ids +
+         * - three records for pairs: (R,T), (R,*), (*,T)
+         * - one wildcard (*), one any (_) and one pair wildcard (*,*) record
+         * - one record for (ChildOf, 0)
+         */
+        int32_t flag_id_count = dst_count - start;
+        int32_t record_count = start + 3 * flag_id_count + 3 + 1;
+        ecs_vec_set_min_size_t(a, records, ecs_table_record_t, record_count);
     }
 
-    /* Destruct remaining columns */
-    for (; i_old < src_column_count; i_old ++) {
-        ecs_column_t *column = &src_columns[i_old];
-        flecs_table_invoke_dtor(column, 0, src_count);
-        ecs_vec_fini(a, &column->data, column->size);
-    }    
+    /* Add records for ids with roles (used by cleanup logic) */
+    if (first_role != -1) {
+        for (dst_i = first_role; dst_i < dst_count; dst_i ++) {
+            ecs_id_t id = dst_ids[dst_i];
+            if (!ECS_IS_PAIR(id)) {
+                ecs_entity_t first = 0;
+                ecs_entity_t second = 0;
+                if (ECS_HAS_ID_FLAG(id, PAIR)) {
+                    first = ECS_PAIR_FIRST(id);
+                    second = ECS_PAIR_SECOND(id);
+                } else {
+                    first = id & ECS_COMPONENT_MASK;
+                }
+                if (first) {
+                    flecs_table_append_to_records(world, table, records, 
+                        ecs_pair(EcsFlag, first), dst_i);
+                }
+                if (second) {
+                    flecs_table_append_to_records(world, table, records, 
+                        ecs_pair(EcsFlag, second), dst_i);
+                }
+            }
+        }
+    }
 
-    /* Mark entity column as dirty */
-    flecs_table_mark_table_dirty(world, dst_table, 0); 
-}
+    int32_t last_pair = -1;
+    bool has_childof = table->flags & EcsTableHasChildOf;
+    if (first_pair != -1) {
+        /* Add a (Relationship, *) record for each relationship. */
+        ecs_entity_t r = 0;
+        for (dst_i = first_pair; dst_i < dst_count; dst_i ++) {
+            ecs_id_t dst_id = dst_ids[dst_i];
+            if (!ECS_IS_PAIR(dst_id)) {
+                break; /* no more pairs */
+            }
+            if (r != ECS_PAIR_FIRST(dst_id)) { /* New relationship, new record */
+                tr = ecs_vec_get_t(records, ecs_table_record_t, dst_i);
 
-/* Merge source table into destination table. This typically happens as result
- * of a bulk operation, like when a component is removed from all entities in 
- * the source table (like for the Remove OnDelete policy). */
-void flecs_table_merge(
-    ecs_world_t *world,
-    ecs_table_t *dst_table,
-    ecs_table_t *src_table,
-    ecs_data_t *dst_data,
-    ecs_data_t *src_data)
-{
-    ecs_assert(src_table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!src_table->_->lock, ECS_LOCKED_STORAGE, NULL);
+                ecs_id_record_t *p_idr = (ecs_id_record_t*)tr->hdr.cache;
+                r = ECS_PAIR_FIRST(dst_id);
+                if (r == EcsChildOf) {
+                    childof_idr = p_idr;
+                }
 
-    flecs_table_check_sanity(src_table);
-    flecs_table_check_sanity(dst_table);
-    
-    bool move_data = false;
-    
-    /* If there is nothing to merge to, just clear the old table */
-    if (!dst_table) {
-        flecs_table_clear_data(world, src_table, src_data);
-        flecs_table_check_sanity(src_table);
-        return;
-    } else {
-        ecs_assert(!dst_table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    }
+                idr = p_idr->parent; /* (R, *) */
+                ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    /* If there is no data to merge, drop out */
-    if (!src_data) {
-        return;
-    }
+                tr = ecs_vec_append_t(a, records, ecs_table_record_t);
+                tr->hdr.cache = (ecs_table_cache_t*)idr;
+                tr->index = flecs_ito(int16_t, dst_i);
+                tr->count = 0;
+            }
+
+            ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
+            tr->count ++;
+        }
+
+        last_pair = dst_i;
+
+        /* Add a (*, Target) record for each relationship target. Type
+         * ids are sorted relationship-first, so we can't simply do a single linear 
+         * scan to find all occurrences for a target. */
+        for (dst_i = first_pair; dst_i < last_pair; dst_i ++) {
+            ecs_id_t dst_id = dst_ids[dst_i];
+            ecs_id_t tgt_id = ecs_pair(EcsWildcard, ECS_PAIR_SECOND(dst_id));
 
-    if (!dst_data) {
-        dst_data = &dst_table->data;
-        if (dst_table == src_table) {
-            move_data = true;
+            flecs_table_append_to_records(
+                world, table, records, tgt_id, dst_i);
         }
     }
 
-    ecs_entity_t *src_entities = src_data->entities.array;
-    int32_t src_count = src_data->entities.count;
-    int32_t dst_count = dst_data->entities.count;
-
-    /* First, update entity index so old entities point to new type */
-    int32_t i;
-    for(i = 0; i < src_count; i ++) {
-        ecs_record_t *record = flecs_entities_ensure(world, src_entities[i]);
-        uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
-        record->row = ECS_ROW_TO_RECORD(dst_count + i, flags);
-        record->table = dst_table;
+    /* Lastly, add records for all-wildcard ids */
+    if (last_id >= 0) {
+        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
+        tr->hdr.cache = (ecs_table_cache_t*)world->idr_wildcard;
+        tr->index = 0;
+        tr->count = flecs_ito(int16_t, last_id + 1);
     }
-
-    /* Merge table columns */
-    if (move_data) {
-        *dst_data = *src_data;
-    } else {
-        flecs_table_merge_data(world, dst_table, src_table, src_count, dst_count, 
-            src_data, dst_data);
+    if (last_pair - first_pair) {
+        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
+        tr->hdr.cache = (ecs_table_cache_t*)world->idr_wildcard_wildcard;
+        tr->index = flecs_ito(int16_t, first_pair);
+        tr->count = flecs_ito(int16_t, last_pair - first_pair);
     }
-
-    if (src_count) {
-        if (!dst_count) {
-            flecs_table_set_empty(world, dst_table);
-        }
-        flecs_table_set_empty(world, src_table);
-
-        flecs_table_traversable_add(dst_table, src_table->_->traversable_count);
-        flecs_table_traversable_add(src_table, -src_table->_->traversable_count);
-        ecs_assert(src_table->_->traversable_count == 0, ECS_INTERNAL_ERROR, NULL);
+    if (dst_count) {
+        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
+        tr->hdr.cache = (ecs_table_cache_t*)world->idr_any;
+        tr->index = 0;
+        tr->count = 1;
     }
-
-    flecs_table_check_sanity(src_table);
-    flecs_table_check_sanity(dst_table);
-}
-
-/* Replace data with other data. Used by snapshots to restore previous state. */
-void flecs_table_replace_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data)
-{
-    int32_t prev_count = 0;
-    ecs_data_t *table_data = &table->data;
-    ecs_assert(!data || data != table_data, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-
-    flecs_table_check_sanity(table);
-
-    prev_count = table_data->entities.count;
-    flecs_table_notify_on_remove(world, table, table_data);
-    flecs_table_clear_data(world, table, table_data);
-
-    if (data) {
-        table->data = *data;
-    } else {
-        flecs_table_init_data(world, table);
+    if (dst_count && !has_childof) {
+        tr = ecs_vec_append_t(a, records, ecs_table_record_t);
+        childof_idr = world->idr_childof_0;
+        tr->hdr.cache = (ecs_table_cache_t*)childof_idr;
+        tr->index = 0;
+        tr->count = 1;
     }
 
-    int32_t count = ecs_table_count(table);
+    /* Now that all records have been added, copy them to array */
+    int32_t i, dst_record_count = ecs_vec_count(records);
+    ecs_table_record_t *dst_tr = flecs_wdup_n(world, ecs_table_record_t, 
+        dst_record_count, ecs_vec_first_t(records, ecs_table_record_t));
+    table->_->record_count = flecs_ito(int16_t, dst_record_count);
+    table->_->records = dst_tr;
+    int32_t column_count = 0;
 
-    if (!prev_count && count) {
-        flecs_table_set_empty(world, table);
-    } else if (prev_count && !count) {
-        flecs_table_set_empty(world, table);
-    }
+    /* Register & patch up records */
+    for (i = 0; i < dst_record_count; i ++) {
+        tr = &dst_tr[i];
+        idr = (ecs_id_record_t*)dst_tr[i].hdr.cache;
+        ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    flecs_table_check_sanity(table);
-}
+        if (ecs_table_cache_get(&idr->cache, table)) {
+            /* If this is a target wildcard record it has already been 
+             * registered, but the record is now at a different location in
+             * memory. Patch up the linked list with the new address */
+            ecs_table_cache_replace(&idr->cache, table, &tr->hdr);
+        } else {
+            /* Other records are not registered yet */
+            ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_table_cache_insert(&idr->cache, table, &tr->hdr);
+        }
 
-/* Internal mechanism for propagating information to tables */
-void flecs_table_notify(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_table_event_t *event)
-{
-    if (world->flags & EcsWorldFini) {
-        return;
-    }
+        /* Claim id record so it stays alive as long as the table exists */
+        flecs_id_record_claim(world, idr);
 
-    switch(event->kind) {
-    case EcsTableTriggersForId:
-        flecs_table_add_trigger_flags(world, table, event->event);
-        break;
-    case EcsTableNoTriggersForId:
-        break;
-    }
-}
+        /* Initialize event flags */
+        table->flags |= idr->flags & EcsIdEventMask;
 
-/* -- Public API -- */
+        /* Initialize column index (will be overwritten by init_columns) */
+        tr->column = -1;
 
-void ecs_table_lock(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    if (table) {
-        if (ecs_poly_is(world, ecs_world_t) && !(world->flags & EcsWorldReadonly)) {
-            table->_->lock ++;
+        if (idr->flags & EcsIdAlwaysOverride) {
+            table->flags |= EcsTableHasOverrides;
         }
-    }
-}
 
-void ecs_table_unlock(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    if (table) {
-        if (ecs_poly_is(world, ecs_world_t) && !(world->flags & EcsWorldReadonly)) {
-            table->_->lock --;
-            ecs_assert(table->_->lock >= 0, ECS_INVALID_OPERATION, NULL);
+        if ((i < table->type.count) && (idr->type_info != NULL)) {
+            column_count ++;
         }
     }
-}
 
-const ecs_type_t* ecs_table_get_type(
-    const ecs_table_t *table)
-{
-    if (table) {
-        return &table->type;
-    } else {
-        return NULL;
+    if (column_count) {
+        table->column_map = flecs_walloc_n(world, int32_t, 
+            dst_count + column_count);
     }
-}
-
-int32_t ecs_table_get_type_index(
-    const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_id_t id)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
+    table->column_count = flecs_ito(int16_t, column_count);
+    flecs_table_init_data(world, table);
 
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return -1;
+    if (table->flags & EcsTableHasName) {
+        ecs_assert(childof_idr != NULL, ECS_INTERNAL_ERROR, NULL);
+        table->_->name_index = 
+            flecs_id_record_name_index_ensure(world, childof_idr);
+        ecs_assert(table->_->name_index != NULL, ECS_INTERNAL_ERROR, NULL);
     }
 
-    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-    if (!tr) {
-        return -1;
+    if (table->flags & EcsTableHasOnTableCreate) {
+        flecs_table_emit(world, table, EcsOnTableCreate);
     }
-
-    return tr->index;
-error:
-    return -1;
 }
 
-int32_t ecs_table_get_column_index(
-    const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_id_t id)
+/* Unregister table from id records */
+static
+void flecs_table_records_unregister(
+    ecs_world_t *world,
+    ecs_table_t *table)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
-
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return -1;
-    }
-
-    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-    if (!tr) {
-        return -1;
-    }
-
-    return tr->column;
-error:
-    return -1;
-}
+    uint64_t table_id = table->id;
+    int32_t i, count = table->_->record_count;
+    for (i = 0; i < count; i ++) {
+        ecs_table_record_t *tr = &table->_->records[i];
+        ecs_table_cache_t *cache = tr->hdr.cache;
+        ecs_id_t id = ((ecs_id_record_t*)cache)->id;
 
-int32_t ecs_table_column_count(
-    const ecs_table_t *table)
-{
-    return table->column_count;
-}
+        ecs_assert(tr->hdr.cache == cache, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(tr->hdr.table == table, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(flecs_id_record_get(world, id) == (ecs_id_record_t*)cache,
+            ECS_INTERNAL_ERROR, NULL);
+        (void)id;
 
-int32_t ecs_table_type_to_column_index(
-    const ecs_table_t *table,
-    int32_t index)
-{
-    ecs_assert(index >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(index < table->type.count, ECS_INVALID_PARAMETER, NULL);
-    int32_t *column_map = table->column_map;
-    if (column_map) {
-        return column_map[index];
+        ecs_table_cache_remove(cache, table_id, &tr->hdr);
+        flecs_id_record_release(world, (ecs_id_record_t*)cache);
     }
-error:
-    return -1;
-}
 
-int32_t ecs_table_column_to_type_index(
-    const ecs_table_t *table,
-    int32_t index)
-{
-    ecs_check(index < table->column_count, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(table->column_map != NULL, ECS_INVALID_PARAMETER, NULL);
-    int32_t offset = table->type.count;
-    return table->column_map[offset + index];
-error:
-    return -1;
+    flecs_wfree_n(world, ecs_table_record_t, count, table->_->records);
 }
 
-void* ecs_table_get_column(
-    const ecs_table_t *table,
-    int32_t index,
-    int32_t offset)
+/* Keep track for what kind of builtin events observers are registered that can
+ * potentially match the table. This allows code to early out of calling the
+ * emit function that notifies observers. */
+static
+void flecs_table_add_trigger_flags(
+    ecs_world_t *world, 
+    ecs_table_t *table, 
+    ecs_entity_t event) 
 {
-    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(index < table->column_count, ECS_INVALID_PARAMETER, NULL);
+    (void)world;
 
-    ecs_column_t *column = &table->data.columns[index];
-    void *result = column->data.array;
-    if (offset) {
-        result = ECS_ELEM(result, column->size, offset);
+    if (event == EcsOnAdd) {
+        table->flags |= EcsTableHasOnAdd;
+    } else if (event == EcsOnRemove) {
+        table->flags |= EcsTableHasOnRemove;
+    } else if (event == EcsOnSet) {
+        table->flags |= EcsTableHasOnSet;
+    } else if (event == EcsUnSet) {
+        table->flags |= EcsTableHasUnSet;
+    } else if (event == EcsOnTableFill) {
+        table->flags |= EcsTableHasOnTableFill;
+    } else if (event == EcsOnTableEmpty) {
+        table->flags |= EcsTableHasOnTableEmpty;
     }
-
-    return result;
-error:
-    return NULL;
 }
 
-void* ecs_table_get_id(
-    const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_id_t id,
-    int32_t offset)
+/* Invoke OnRemove observers for all entities in table. Useful during table 
+ * deletion or when clearing entities from a table. */
+static
+void flecs_table_notify_on_remove(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_data_t *data)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
-
-    world = ecs_get_world(world);
-
-    int32_t index = ecs_table_get_column_index(world, table, id);
-    if (index == -1) {
-        return NULL;
+    int32_t count = data->entities.count;
+    if (count) {
+        flecs_notify_on_remove(world, table, NULL, 0, count, &table->type);
     }
-
-    return ecs_table_get_column(table, index, offset);
-error:
-    return NULL;
 }
 
-size_t ecs_table_get_column_size(
-    const ecs_table_t *table,
-    int32_t column)
+/* Invoke type hook for entities in table */
+static
+void flecs_table_invoke_hook(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_iter_action_t callback,
+    ecs_entity_t event,
+    ecs_column_t *column,
+    ecs_entity_t *entities,
+    int32_t row,
+    int32_t count)
 {
-    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(column < table->column_count, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(table->column_map != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    return flecs_ito(size_t, table->data.columns[column].size);
-error:
-    return 0;
+    void *ptr = ecs_vec_get(&column->data, column->size, row);
+    flecs_invoke_hook(world, table, count, row, entities, ptr, column->id, 
+        column->ti, event, callback);
 }
 
-int32_t ecs_table_count(
-    const ecs_table_t *table)
+/* Construct components */
+static
+void flecs_table_invoke_ctor(
+    ecs_column_t *column,
+    int32_t row,
+    int32_t count)
 {
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    return flecs_table_data_count(&table->data);
+    ecs_type_info_t *ti = column->ti;
+    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_xtor_t ctor = ti->hooks.ctor;
+    if (ctor) {
+        void *ptr = ecs_vec_get(&column->data, column->size, row);
+        ctor(ptr, count, ti);
+    }
 }
 
-bool ecs_table_has_id(
-    const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_id_t id)
+/* Destruct components */
+static
+void flecs_table_invoke_dtor(
+    ecs_column_t *column,
+    int32_t row,
+    int32_t count)
 {
-    return ecs_table_get_type_index(world, table, id) != -1;
+    ecs_type_info_t *ti = column->ti;
+    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_xtor_t dtor = ti->hooks.dtor;
+    if (dtor) {
+        void *ptr = ecs_vec_get(&column->data, column->size, row);
+        dtor(ptr, count, ti);
+    }
 }
 
-int32_t ecs_table_get_depth(
-    const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_entity_t rel)
+/* Run hooks that get invoked when component is added to entity */
+static
+void flecs_table_invoke_add_hooks(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_column_t *column,
+    ecs_entity_t *entities,
+    int32_t row,
+    int32_t count,
+    bool construct)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_id_is_valid(world, rel), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_has_id(world, rel, EcsAcyclic), ECS_INVALID_PARAMETER, NULL);
+    ecs_type_info_t *ti = column->ti;
+    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    world = ecs_get_world(world);
+    if (construct) {
+        flecs_table_invoke_ctor(column, row, count);
+    }
 
-    return flecs_relation_depth(world, rel, table);
-error:
-    return -1;
+    ecs_iter_action_t on_add = ti->hooks.on_add;
+    if (on_add) {
+        flecs_table_invoke_hook(world, table, on_add, EcsOnAdd, column,
+            entities, row, count);
+    }
 }
 
-bool ecs_table_has_flags(
+/* Run hooks that get invoked when component is removed from entity */
+static
+void flecs_table_invoke_remove_hooks(
+    ecs_world_t *world,
     ecs_table_t *table,
-    ecs_flags32_t flags)
+    ecs_column_t *column,
+    ecs_entity_t *entities,
+    int32_t row,
+    int32_t count,
+    bool dtor)
 {
-    return (table->flags & flags) == flags;
-}
+    ecs_type_info_t *ti = column->ti;
+    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
 
-int32_t flecs_table_column_to_union_index(
-    const ecs_table_t *table,
-    int32_t column)
-{
-    int32_t sw_count = table->_->sw_count;
-    if (sw_count) {
-        int32_t sw_offset = table->_->sw_offset;
-        if (column >= sw_offset && column < (sw_offset + sw_count)){
-            return column - sw_offset;
-        }
+    ecs_iter_action_t on_remove = ti->hooks.on_remove;
+    if (on_remove) {
+        flecs_table_invoke_hook(world, table, on_remove, EcsOnRemove, column,
+            entities, row, count);
+    }
+    
+    if (dtor) {
+        flecs_table_invoke_dtor(column, row, count);
     }
-    return -1;
 }
 
-void ecs_table_swap_rows(
-    ecs_world_t* world,
-    ecs_table_t* table,
-    int32_t row_1,
-    int32_t row_2)
+/* Destruct all components and/or delete all entities in table in range */
+static
+void flecs_table_dtor_all(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_data_t *data,
+    int32_t row,
+    int32_t count,
+    bool is_delete)
 {
-    flecs_table_swap(world, table, row_1, row_2);
-}
+    int32_t ids_count = table->column_count;
+    ecs_entity_t *entities = data->entities.array;
+    int32_t i, c, end = row + count;
 
-int32_t flecs_table_observed_count(
-    const ecs_table_t *table)
-{
-    return table->_->traversable_count;
-}
+    if (is_delete && table->_->traversable_count) {
+        /* If table contains monitored entities with traversable relationships,
+         * make sure to invalidate observer cache */
+        flecs_emit_propagate_invalidate(world, table, row, count);
+    }
 
-void* ecs_record_get_column(
-    const ecs_record_t *r,
-    int32_t index,
-    size_t c_size)
-{
-    (void)c_size;
-    ecs_table_t *table = r->table;
+    /* If table has components with destructors, iterate component columns */
+    if (table->flags & EcsTableHasDtors) {
+        /* Throw up a lock just to be sure */
+        table->_->lock = true;
 
-    ecs_check(index < table->column_count, ECS_INVALID_PARAMETER, NULL);
-    ecs_column_t *column = &table->data.columns[index];
-    ecs_size_t size = column->size;
+        /* Run on_remove callbacks first before destructing components */
+        for (c = 0; c < ids_count; c++) {
+            ecs_column_t *column = &data->columns[c];
+            ecs_iter_action_t on_remove = column->ti->hooks.on_remove;
+            if (on_remove) {
+                flecs_table_invoke_hook(world, table, on_remove, EcsOnRemove, 
+                    column, &entities[row], row, count);
+            }
+        }
 
-    ecs_check(!flecs_utosize(c_size) || flecs_utosize(c_size) == size, 
-        ECS_INVALID_PARAMETER, NULL);
+        /* Destruct components */
+        for (c = 0; c < ids_count; c++) {
+            flecs_table_invoke_dtor(&data->columns[c], row, count);
+        }
 
-    return ecs_vec_get(&column->data, size, ECS_RECORD_TO_ROW(r->row));
-error:
-    return NULL;
-}
+        /* Iterate entities first, then components. This ensures that only one
+         * entity is invalidated at a time, which ensures that destructors can
+         * safely access other entities. */
+        for (i = row; i < end; i ++) {
+            /* Update entity index after invoking destructors so that entity can
+             * be safely used in destructor callbacks. */
+            ecs_entity_t e = entities[i];
+            ecs_assert(!e || ecs_is_valid(world, e), 
+                ECS_INTERNAL_ERROR, NULL);
 
-ecs_record_t* ecs_record_find(
-    const ecs_world_t *world,
-    ecs_entity_t entity)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
+            if (is_delete) {
+                flecs_entities_remove(world, e);
+                ecs_assert(ecs_is_valid(world, e) == false, 
+                    ECS_INTERNAL_ERROR, NULL);
+            } else {
+                // If this is not a delete, clear the entity index record
+                ecs_record_t *record = flecs_entities_get(world, e);
+                record->table = NULL;
+                record->row = 0;
+            }
+        }
 
-    world = ecs_get_world(world);
+        table->_->lock = false;
 
-    ecs_record_t *r = flecs_entities_get(world, entity);
-    if (r) {
-        return r;
+    /* If table does not have destructors, just update entity index */
+    } else {
+        if (is_delete) {
+            for (i = row; i < end; i ++) {
+                ecs_entity_t e = entities[i];
+                ecs_assert(!e || ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL);
+                flecs_entities_remove(world, e);
+                ecs_assert(!ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL);
+            } 
+        } else {
+            for (i = row; i < end; i ++) {
+                ecs_entity_t e = entities[i];
+                ecs_assert(!e || ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL);
+                ecs_record_t *record = flecs_entities_get(world, e);
+                record->table = NULL;
+                record->row = record->row & ECS_ROW_FLAGS_MASK;
+                (void)e;
+            }
+        }      
     }
-error:
-    return NULL;
 }
 
-/**
- * @file table_cache.c
- * @brief Data structure for fast table iteration/lookups.
- * 
- * A table cache is a data structure that provides constant time operations for
- * insertion and removal of tables, and to testing whether a table is registered
- * with the cache. A table cache also provides functions to iterate the tables
- * in a cache.
- * 
- * The world stores a table cache per (component) id inside the id record 
- * administration. Cached queries store a table cache with matched tables.
- * 
- * A table cache has separate lists for non-empty tables and empty tables. This
- * improves performance as applications don't waste time iterating empty tables.
- */
-
-
+/* Cleanup table storage */
 static
-void flecs_table_cache_list_remove(
-    ecs_table_cache_t *cache,
-    ecs_table_cache_hdr_t *elem)
+void flecs_table_fini_data(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_data_t *data,
+    bool do_on_remove,
+    bool is_delete,
+    bool deactivate)
 {
-    ecs_table_cache_hdr_t *next = elem->next;
-    ecs_table_cache_hdr_t *prev = elem->prev;
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
 
-    if (next) {
-        next->prev = prev;
+    if (!data) {
+        return;
     }
-    if (prev) {
-        prev->next = next;
+
+    if (do_on_remove) {
+        flecs_table_notify_on_remove(world, table, data);        
     }
 
-    cache->empty_tables.count -= !!elem->empty;
-    cache->tables.count -= !elem->empty;
+    int32_t count = flecs_table_data_count(data);
+    if (count) {
+        flecs_table_dtor_all(world, table, data, 0, count, is_delete);
+    }
 
-    if (cache->empty_tables.first == elem) {
-        cache->empty_tables.first = next;
-    } else if (cache->tables.first == elem) {
-        cache->tables.first = next;
+    ecs_column_t *columns = data->columns;
+    if (columns) {
+        int32_t c, column_count = table->column_count;
+        for (c = 0; c < column_count; c ++) {
+            /* Sanity check */
+            ecs_assert(columns[c].data.count == data->entities.count,
+                ECS_INTERNAL_ERROR, NULL);
+            ecs_vec_fini(&world->allocator,
+                &columns[c].data, columns[c].size);
+        }
+        flecs_wfree_n(world, ecs_column_t, column_count, columns);
+        data->columns = NULL;
     }
-    if (cache->empty_tables.last == elem) {
-        cache->empty_tables.last = prev;
+
+    ecs_table__t *meta = table->_;
+    ecs_bitset_t *bs_columns = meta->bs_columns;
+    if (bs_columns) {
+        int32_t c, column_count = meta->bs_count;
+        for (c = 0; c < column_count; c ++) {
+            flecs_bitset_fini(&bs_columns[c]);
+        }
+        flecs_wfree_n(world, ecs_bitset_t, column_count, bs_columns);
+        meta->bs_columns = NULL;
     }
-    if (cache->tables.last == elem) {
-        cache->tables.last = prev;
+
+    ecs_vec_fini_t(&world->allocator, &data->entities, ecs_entity_t);
+
+    if (deactivate && count) {
+        flecs_table_set_empty(world, table);
     }
+
+    table->_->traversable_count = 0;
+    table->flags &= ~EcsTableHasTraversable;
 }
 
-static
-void flecs_table_cache_list_insert(
-    ecs_table_cache_t *cache,
-    ecs_table_cache_hdr_t *elem)
+ecs_vec_t* flecs_table_entities(
+    ecs_table_t *table)
 {
-    ecs_table_cache_hdr_t *last;
-    if (elem->empty) {
-        last = cache->empty_tables.last;
-        cache->empty_tables.last = elem;
-        if ((++ cache->empty_tables.count) == 1) {
-            cache->empty_tables.first = elem;
-        }
-    } else {
-        last = cache->tables.last;
-        cache->tables.last = elem;
-        if ((++ cache->tables.count) == 1) {
-            cache->tables.first = elem;
-        }
-    }
+    return &table->data.entities;
+}
 
-    elem->next = NULL;
-    elem->prev = last;
+ecs_entity_t* flecs_table_entities_array(
+    ecs_table_t *table)
+{
+    return ecs_vec_first(flecs_table_entities(table));
+}
 
-    if (last) {
-        last->next = elem;
-    }
+/* Cleanup, no OnRemove, clear entity index, deactivate table */
+void flecs_table_clear_entities_silent(
+    ecs_world_t *world,
+    ecs_table_t *table)
+{
+    flecs_table_fini_data(world, table, &table->data, false, false, true);
 }
 
-void ecs_table_cache_init(
+/* Cleanup, run OnRemove, clear entity index, deactivate table */
+void flecs_table_clear_entities(
     ecs_world_t *world,
-    ecs_table_cache_t *cache)
+    ecs_table_t *table)
 {
-    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_map_init_w_params(&cache->index, &world->allocators.ptr);
+    flecs_table_fini_data(world, table, &table->data, true, false, true);
 }
 
-void ecs_table_cache_fini(
-    ecs_table_cache_t *cache)
+/* Cleanup, run OnRemove, delete from entity index, deactivate table */
+void flecs_table_delete_entities(
+    ecs_world_t *world,
+    ecs_table_t *table)
 {
-    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_map_fini(&cache->index);
+    flecs_table_fini_data(world, table, &table->data, true, true, true);
 }
 
-bool ecs_table_cache_is_empty(
-    const ecs_table_cache_t *cache)
+/* Unset all components in table. This function is called before a table is 
+ * deleted, and invokes all UnSet handlers, if any */
+void flecs_table_remove_actions(
+    ecs_world_t *world,
+    ecs_table_t *table)
 {
-    return ecs_map_count(&cache->index) == 0;
+    (void)world;
+    flecs_table_notify_on_remove(world, table, &table->data);
 }
 
-void ecs_table_cache_insert(
-    ecs_table_cache_t *cache,
-    const ecs_table_t *table,
-    ecs_table_cache_hdr_t *result)
+/* Free table resources. */
+void flecs_table_fini(
+    ecs_world_t *world,
+    ecs_table_t *table)
 {
-    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(ecs_table_cache_get(cache, table) == NULL,
+    bool is_root = table == &world->store.root;
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    ecs_assert(is_root || table->id != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(is_root || flecs_sparse_is_alive(&world->store.tables, table->id),
         ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL);
+    (void)world;
 
-    bool empty;
-    if (!table) {
-        empty = false;
-    } else {
-        empty = ecs_table_count(table) == 0;
+    if (!is_root && !(world->flags & EcsWorldQuit)) {
+        if (table->flags & EcsTableHasOnTableDelete) {
+            flecs_table_emit(world, table, EcsOnTableDelete);
+        }
     }
 
-    result->cache = cache;
-    result->table = ECS_CONST_CAST(ecs_table_t*, table);
-    result->empty = empty;
-
-    flecs_table_cache_list_insert(cache, result);
-
-    if (table) {
-        ecs_map_insert_ptr(&cache->index, table->id, result);
+    if (ecs_should_log_2()) {
+        char *expr = ecs_type_str(world, &table->type);
+        ecs_dbg_2(
+            "#[green]table#[normal] [%s] #[red]deleted#[reset] with id %d", 
+            expr, table->id);
+        ecs_os_free(expr);
+        ecs_log_push_2();
     }
 
-    ecs_assert(empty || cache->tables.first != NULL, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!empty || cache->empty_tables.first != NULL, 
-        ECS_INTERNAL_ERROR, NULL);
-}
+    world->info.empty_table_count -= (ecs_table_count(table) == 0);
 
-void ecs_table_cache_replace(
-    ecs_table_cache_t *cache,
-    const ecs_table_t *table,
-    ecs_table_cache_hdr_t *elem)
-{
-    ecs_table_cache_hdr_t **r = ecs_map_get_ref(
-        &cache->index, ecs_table_cache_hdr_t, table->id);
-    ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
+    /* Cleanup data, no OnRemove, delete from entity index, don't deactivate */
+    flecs_table_fini_data(world, table, &table->data, false, true, false);
+    flecs_table_clear_edges(world, table);
 
-    ecs_table_cache_hdr_t *old = *r;
-    ecs_assert(old != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (!is_root) {
+        ecs_type_t ids = {
+            .array = table->type.array,
+            .count = table->type.count
+        };
 
-    ecs_table_cache_hdr_t *prev = old->prev, *next = old->next;
-    if (prev) {
-        ecs_assert(prev->next == old, ECS_INTERNAL_ERROR, NULL);
-        prev->next = elem;
-    }
-    if (next) {
-        ecs_assert(next->prev == old, ECS_INTERNAL_ERROR, NULL);
-        next->prev = elem;
+        flecs_hashmap_remove_w_hash(
+            &world->store.table_map, &ids, ecs_table_t*, table->_->hash);
     }
 
-    if (cache->empty_tables.first == old) {
-        cache->empty_tables.first = elem;
-    }
-    if (cache->empty_tables.last == old) {
-        cache->empty_tables.last = elem;
-    }
-    if (cache->tables.first == old) {
-        cache->tables.first = elem;
-    }
-    if (cache->tables.last == old) {
-        cache->tables.last = elem;
+    flecs_wfree_n(world, int32_t, table->column_count + 1, table->dirty_state);
+    flecs_wfree_n(world, int32_t, table->column_count + table->type.count, 
+        table->column_map);
+    flecs_table_records_unregister(world, table);
+
+    /* Update counters */
+    world->info.table_count --;
+    world->info.table_delete_total ++;
+
+    flecs_free_t(&world->allocator, ecs_table__t, table->_);
+
+    if (!(world->flags & EcsWorldFini)) {
+        ecs_assert(!is_root, ECS_INTERNAL_ERROR, NULL);
+        flecs_table_free_type(world, table);
+        flecs_sparse_remove_t(&world->store.tables, ecs_table_t, table->id);
     }
 
-    *r = elem;
-    elem->prev = prev;
-    elem->next = next;
+    ecs_log_pop_2();
 }
 
-void* ecs_table_cache_get(
-    const ecs_table_cache_t *cache,
-    const ecs_table_t *table)
+/* Free table type. Do this separately from freeing the table as types can be
+ * in use by application destructors. */
+void flecs_table_free_type(
+    ecs_world_t *world,
+    ecs_table_t *table)
 {
-    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
-    if (table) {
-        if (ecs_map_is_init(&cache->index)) {
-            return ecs_map_get_deref(&cache->index, void**, table->id);
-        }
-        return NULL;
-    } else {
-        ecs_table_cache_hdr_t *elem = cache->tables.first;
-        ecs_assert(!elem || elem->table == NULL, ECS_INTERNAL_ERROR, NULL);
-        return elem;
-    }
+    flecs_wfree_n(world, ecs_id_t, table->type.count, table->type.array);
 }
 
-void* ecs_table_cache_remove(
-    ecs_table_cache_t *cache,
-    uint64_t table_id,
-    ecs_table_cache_hdr_t *elem)
+/* Reset a table to its initial state. */
+void flecs_table_reset(
+    ecs_world_t *world,
+    ecs_table_t *table)
 {
-    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(table_id != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_assert(elem->cache == cache, ECS_INTERNAL_ERROR, NULL);
-
-    flecs_table_cache_list_remove(cache, elem);
-    ecs_map_remove(&cache->index, table_id);
-
-    return elem;
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    flecs_table_clear_edges(world, table);
 }
 
-bool ecs_table_cache_set_empty(
-    ecs_table_cache_t *cache,
-    const ecs_table_t *table,
-    bool empty)
+/* Keep track of number of traversable entities in table. A traversable entity
+ * is an entity used as target in a pair with a traversable relationship. The
+ * traversable count and flag are used by code to early out of mechanisms like
+ * event propagation and recursive cleanup. */
+void flecs_table_traversable_add(
+    ecs_table_t *table,
+    int32_t value)
 {
-    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_table_cache_hdr_t *elem = ecs_map_get_deref(&cache->index, 
-        ecs_table_cache_hdr_t, table->id);
-    if (!elem) {
-        return false;
-    }
-
-    if (elem->empty == empty) {
-        return false;
+    int32_t result = table->_->traversable_count += value;
+    ecs_assert(result >= 0, ECS_INTERNAL_ERROR, NULL);
+    if (result == 0) {
+        table->flags &= ~EcsTableHasTraversable;
+    } else if (result == value) {
+        table->flags |= EcsTableHasTraversable;
     }
-
-    flecs_table_cache_list_remove(cache, elem);
-    elem->empty = empty;
-    flecs_table_cache_list_insert(cache, elem);
-
-    return true;
 }
 
-bool flecs_table_cache_iter(
-    ecs_table_cache_t *cache,
-    ecs_table_cache_iter_t *out)
+/* Mark table column dirty. This usually happens as the result of a set 
+ * operation, or iteration of a query with [out] fields. */
+static
+void flecs_table_mark_table_dirty(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    int32_t index)
 {
-    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL);
-    out->next = cache->tables.first;
-    out->next_list = NULL;
-    out->cur = NULL;
-    return out->next != NULL;
+    (void)world;
+    if (table->dirty_state) {
+        table->dirty_state[index] ++;
+    }
 }
 
-bool flecs_table_cache_empty_iter(
-    ecs_table_cache_t *cache,
-    ecs_table_cache_iter_t *out)
+/* Mark table component dirty */
+void flecs_table_mark_dirty(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_entity_t component)
 {
-    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL);
-    out->next = cache->empty_tables.first;
-    out->next_list = NULL;
-    out->cur = NULL;
-    return out->next != NULL;
-}
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
 
-bool flecs_table_cache_all_iter(
-    ecs_table_cache_t *cache,
-    ecs_table_cache_iter_t *out)
-{
-    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL);
-    out->next = cache->empty_tables.first;
-    out->next_list = cache->tables.first;
-    out->cur = NULL;
-    return out->next != NULL || out->next_list != NULL;
+    if (table->dirty_state) {
+        ecs_id_record_t *idr = flecs_id_record_get(world, component);
+        if (!idr) {
+            return;
+        }
+
+        const ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+        if (!tr || tr->column == -1) {
+            return;
+        }
+
+        table->dirty_state[tr->column + 1] ++;
+    }
 }
 
-ecs_table_cache_hdr_t* flecs_table_cache_next_(
-    ecs_table_cache_iter_t *it)
+/* Get (or create) dirty state of table. Used by queries for change tracking */
+int32_t* flecs_table_get_dirty_state(
+    ecs_world_t *world,
+    ecs_table_t *table)
 {
-    ecs_table_cache_hdr_t *next = it->next;
-    if (!next) {
-        next = it->next_list;
-        it->next_list = NULL;
-        if (!next) {
-            return NULL;
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (!table->dirty_state) {
+        int32_t column_count = table->column_count;
+        table->dirty_state = flecs_alloc_n(&world->allocator,
+             int32_t, column_count + 1);
+        ecs_assert(table->dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+        for (int i = 0; i < column_count + 1; i ++) {
+            table->dirty_state[i] = 1;
         }
     }
-
-    it->cur = next;
-    it->next = next->next;
-    return next;
+    return table->dirty_state;
 }
 
-/**
- * @file table_graph.c
- * @brief Data structure to speed up table transitions.
- * 
- * The table graph is used to speed up finding tables in add/remove operations.
- * For example, if component C is added to an entity in table [A, B], the entity
- * must be moved to table [A, B, C]. The graph speeds this process up with an
- * edge for component C that connects [A, B] to [A, B, C].
- */
+/* Table move logic for bitset (toggle component) column */
+static
+void flecs_table_move_bitset_columns(
+    ecs_table_t *dst_table, 
+    int32_t dst_index,
+    ecs_table_t *src_table, 
+    int32_t src_index,
+    int32_t count,
+    bool clear)
+{
+    ecs_table__t *dst_meta = dst_table->_;
+    ecs_table__t *src_meta = src_table->_;
+    if (!dst_meta && !src_meta) {
+        return;
+    }
 
+    int32_t i_old = 0, src_column_count = src_meta ? src_meta->bs_count : 0;
+    int32_t i_new = 0, dst_column_count = dst_meta ? dst_meta->bs_count : 0;
 
-/* Id sequence (type) utilities */
+    if (!src_column_count && !dst_column_count) {
+        return;
+    }
 
-static
-uint64_t flecs_type_hash(const void *ptr) {
-    const ecs_type_t *type = ptr;
-    ecs_id_t *ids = type->array;
-    int32_t count = type->count;
-    return flecs_hash(ids, count * ECS_SIZEOF(ecs_id_t));
-}
+    ecs_bitset_t *src_columns = src_meta ? src_meta->bs_columns : NULL;
+    ecs_bitset_t *dst_columns = dst_meta ? dst_meta->bs_columns : NULL;
 
-static
-int flecs_type_compare(const void *ptr_1, const void *ptr_2) {
-    const ecs_type_t *type_1 = ptr_1;
-    const ecs_type_t *type_2 = ptr_2;
+    ecs_type_t dst_type = dst_table->type;
+    ecs_type_t src_type = src_table->type;
 
-    int32_t count_1 = type_1->count;
-    int32_t count_2 = type_2->count;
+    int32_t offset_new = dst_meta ? dst_meta->bs_offset : 0;
+    int32_t offset_old = src_meta ? src_meta->bs_offset : 0;
 
-    if (count_1 != count_2) {
-        return (count_1 > count_2) - (count_1 < count_2);
-    }
+    ecs_id_t *dst_ids = dst_type.array;
+    ecs_id_t *src_ids = src_type.array;
 
-    const ecs_id_t *ids_1 = type_1->array;
-    const ecs_id_t *ids_2 = type_2->array;
-    int result = 0;
-    
-    int32_t i;
-    for (i = 0; !result && (i < count_1); i ++) {
-        ecs_id_t id_1 = ids_1[i];
-        ecs_id_t id_2 = ids_2[i];
-        result = (id_1 > id_2) - (id_1 < id_2);
-    }
+    for (; (i_new < dst_column_count) && (i_old < src_column_count);) {
+        ecs_id_t dst_id = dst_ids[i_new + offset_new];
+        ecs_id_t src_id = src_ids[i_old + offset_old];
 
-    return result;
-}
+        if (dst_id == src_id) {
+            ecs_bitset_t *src_bs = &src_columns[i_old];
+            ecs_bitset_t *dst_bs = &dst_columns[i_new];
 
-void flecs_table_hashmap_init(
-    ecs_world_t *world, 
-    ecs_hashmap_t *hm) 
-{
-    flecs_hashmap_init(hm, ecs_type_t, ecs_table_t*, 
-        flecs_type_hash, flecs_type_compare, &world->allocator);
-}
+            flecs_bitset_ensure(dst_bs, dst_index + count);
 
-/* Find location where to insert id into type */
-static
-int flecs_type_find_insert(
-    const ecs_type_t *type,
-    int32_t offset,
-    ecs_id_t to_add)
-{
-    ecs_id_t *array = type->array;
-    int32_t i, count = type->count;
+            int i;
+            for (i = 0; i < count; i ++) {
+                uint64_t value = flecs_bitset_get(src_bs, src_index + i);
+                flecs_bitset_set(dst_bs, dst_index + i, value);
+            }
 
-    for (i = offset; i < count; i ++) {
-        ecs_id_t id = array[i];
-        if (id == to_add) {
-            return -1;
+            if (clear) {
+                ecs_assert(count == flecs_bitset_count(src_bs), 
+                    ECS_INTERNAL_ERROR, NULL);
+                flecs_bitset_fini(src_bs);
+            }
+        } else if (dst_id > src_id) {
+            ecs_bitset_t *src_bs = &src_columns[i_old];
+            flecs_bitset_fini(src_bs);
         }
-        if (id > to_add) {
-            return i;
+
+        i_new += dst_id <= src_id;
+        i_old += dst_id >= src_id;
+    }
+
+    /* Clear remaining columns */
+    if (clear) {
+        for (; (i_old < src_column_count); i_old ++) {
+            ecs_bitset_t *src_bs = &src_columns[i_old];
+            ecs_assert(count == flecs_bitset_count(src_bs), 
+                ECS_INTERNAL_ERROR, NULL);
+            flecs_bitset_fini(src_bs);
         }
     }
-    return i;
 }
 
-/* Find location of id in type */
+/* Grow table column. When a column needs to be reallocated this function takes
+ * care of correctly invoking ctor/move/dtor hooks. */
 static
-int flecs_type_find(
-    const ecs_type_t *type,
-    ecs_id_t id)
+void flecs_table_grow_column(
+    ecs_world_t *world,
+    ecs_column_t *column,
+    int32_t to_add,
+    int32_t dst_size,
+    bool construct)
 {
-    ecs_id_t *array = type->array;
-    int32_t i, count = type->count;
+    ecs_assert(column != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    for (i = 0; i < count; i ++) {
-        ecs_id_t cur = array[i];
-        if (ecs_id_match(cur, id)) {
-            return i;
-        }
-        if (cur > id) {
-            return -1;
+    ecs_type_info_t *ti = column->ti;
+    int32_t size = column->size;
+    int32_t count = column->data.count;
+    int32_t src_size = column->data.size;
+    int32_t dst_count = count + to_add;
+    bool can_realloc = dst_size != src_size;
+    void *result = NULL;
+
+    ecs_assert(dst_size >= dst_count, ECS_INTERNAL_ERROR, NULL);
+
+    /* If the array could possibly realloc and the component has a move action 
+     * defined, move old elements manually */
+    ecs_move_t move_ctor;
+    if (count && can_realloc && (move_ctor = ti->hooks.ctor_move_dtor)) {
+        ecs_xtor_t ctor = ti->hooks.ctor;
+        ecs_assert(ctor != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(move_ctor != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        /* Create  vector */
+        ecs_vec_t dst;
+        ecs_vec_init(&world->allocator, &dst, size, dst_size);
+        dst.count = dst_count;
+
+        void *src_buffer = column->data.array;
+        void *dst_buffer = dst.array;
+
+        /* Move (and construct) existing elements to new vector */
+        move_ctor(dst_buffer, src_buffer, count, ti);
+
+        if (construct) {
+            /* Construct new element(s) */
+            result = ECS_ELEM(dst_buffer, size, count);
+            ctor(result, to_add, ti);
         }
-    }
 
-    return -1;
-}
+        /* Free old vector */
+        ecs_vec_fini(&world->allocator, &column->data, size);
 
-/* Count number of matching ids */
-static
-int flecs_type_count_matches(
-    const ecs_type_t *type,
-    ecs_id_t wildcard,
-    int32_t offset)
-{
-    ecs_id_t *array = type->array;
-    int32_t i = offset, count = type->count;
+        column->data = dst;
+    } else {
+        /* If array won't realloc or has no move, simply add new elements */
+        if (can_realloc) {
+            ecs_vec_set_size(&world->allocator, &column->data, size, dst_size);
+        }
 
-    for (; i < count; i ++) {
-        ecs_id_t cur = array[i];
-        if (!ecs_id_match(cur, wildcard)) {
-            break;
+        result = ecs_vec_grow(&world->allocator, &column->data, size, to_add);
+
+        ecs_xtor_t ctor;
+        if (construct && (ctor = ti->hooks.ctor)) {
+            /* If new elements need to be constructed and component has a
+             * constructor, construct */
+            ctor(result, to_add, ti);
         }
     }
 
-    return i - offset;
+    ecs_assert(column->data.size == dst_size, ECS_INTERNAL_ERROR, NULL);
 }
 
-/* Create type from source type with id */
+/* Grow all data structures in a table */
 static
-int flecs_type_new_with(
+int32_t flecs_table_grow_data(
     ecs_world_t *world,
-    ecs_type_t *dst,
-    const ecs_type_t *src,
-    ecs_id_t with)
+    ecs_table_t *table,
+    ecs_data_t *data,
+    int32_t to_add,
+    int32_t size,
+    const ecs_entity_t *ids)
 {
-    ecs_id_t *src_array = src->array;
-    int32_t at = flecs_type_find_insert(src, 0, with);
-    if (at == -1) {
-        return -1;
-    }
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    int32_t dst_count = src->count + 1;
-    ecs_id_t *dst_array = flecs_walloc_n(world, ecs_id_t, dst_count);
-    dst->count = dst_count;
-    dst->array = dst_array;
+    int32_t cur_count = flecs_table_data_count(data);
+    int32_t column_count = table->column_count;
 
-    if (at) {
-        ecs_os_memcpy_n(dst_array, src_array, ecs_id_t, at);
+    /* Add entity to column with entity ids */
+    ecs_vec_set_size_t(&world->allocator, &data->entities, ecs_entity_t, size);
+    ecs_entity_t *e = ecs_vec_last_t(&data->entities, ecs_entity_t) + 1;
+    data->entities.count += to_add;
+    if (data->entities.size > size) {
+        size = data->entities.size;
     }
 
-    int32_t remain = src->count - at;
-    if (remain) {
-        ecs_os_memcpy_n(&dst_array[at + 1], &src_array[at], ecs_id_t, remain);
+    /* Initialize entity ids and record ptrs */
+    int32_t i;
+    if (ids) {
+        ecs_os_memcpy_n(e, ids, ecs_entity_t, to_add);
+    } else {
+        ecs_os_memset(e, 0, ECS_SIZEOF(ecs_entity_t) * to_add);
     }
 
-    dst_array[at] = with;
+    /* Add elements to each column array */
+    ecs_column_t *columns = data->columns;
+    for (i = 0; i < column_count; i ++) {
+        flecs_table_grow_column(world, &columns[i], to_add, size, true);
+        ecs_assert(columns[i].data.size == size, ECS_INTERNAL_ERROR, NULL);
+        flecs_table_invoke_add_hooks(world, table, &columns[i], e, 
+            cur_count, to_add, false);
+    }
 
-    return 0;
-}
+    ecs_table__t *meta = table->_;
+    int32_t bs_count = meta->bs_count;
+    ecs_bitset_t *bs_columns = meta->bs_columns; 
 
-/* Create type from source type without ids matching wildcard */
-static
-int flecs_type_new_filtered(
-    ecs_world_t *world,
-    ecs_type_t *dst,
-    const ecs_type_t *src,
-    ecs_id_t wildcard,
-    int32_t at)
-{
-    *dst = flecs_type_copy(world, src);
-    ecs_id_t *dst_array = dst->array;
-    ecs_id_t *src_array = src->array;
-    if (at) {
-        ecs_assert(dst_array != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_os_memcpy_n(dst_array, src_array, ecs_id_t, at);
+    /* Add elements to each bitset column */
+    for (i = 0; i < bs_count; i ++) {
+        ecs_bitset_t *bs = &bs_columns[i];
+        flecs_bitset_addn(bs, to_add);
     }
 
-    int32_t i = at + 1, w = at, count = src->count;
-    for (; i < count; i ++) {
-        ecs_id_t id = src_array[i];
-        if (!ecs_id_match(id, wildcard)) {
-            dst_array[w] = id;
-            w ++;
-        }
-    }
+    /* If the table is monitored indicate that there has been a change */
+    flecs_table_mark_table_dirty(world, table, 0);
 
-    dst->count = w;
-    if (w != count) {
-        dst->array = flecs_wrealloc_n(world, ecs_id_t, w, count, dst->array);
+    if (!(world->flags & EcsWorldReadonly) && !cur_count) {
+        flecs_table_set_empty(world, table);
     }
 
-    return 0;
+    /* Return index of first added entity */
+    return cur_count;
 }
 
-/* Create type from source type without id */
+/* Append operation for tables that don't have any complex logic */
 static
-int flecs_type_new_without(
+void flecs_table_fast_append(
     ecs_world_t *world,
-    ecs_type_t *dst,
-    const ecs_type_t *src,
-    ecs_id_t without)
+    ecs_column_t *columns,
+    int32_t count)
 {
-    ecs_id_t *src_array = src->array;
-    int32_t count = 1, at = flecs_type_find(src, without);
-    if (at == -1) {
-        return -1;
+    /* Add elements to each column array */
+    int32_t i;
+    for (i = 0; i < count; i ++) {
+        ecs_column_t *column = &columns[i];
+        ecs_vec_append(&world->allocator, &column->data, column->size);
     }
+}
 
-    int32_t src_count = src->count;
-    if (src_count == 1) {
-        dst->array = NULL;
-        dst->count = 0;
-        return 0;
-    }
+/* Append entity to table */
+int32_t flecs_table_append(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_entity_t entity,
+    bool construct,
+    bool on_add)
+{
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
 
-    if (ecs_id_is_wildcard(without)) {
-        if (ECS_IS_PAIR(without)) {
-            ecs_entity_t r = ECS_PAIR_FIRST(without);
-            ecs_entity_t o = ECS_PAIR_SECOND(without);
-            if (r == EcsWildcard && o != EcsWildcard) {
-                return flecs_type_new_filtered(world, dst, src, without, at);
-            }
-        }
-        count += flecs_type_count_matches(src, without, at + 1);
-    }
+    flecs_table_check_sanity(table);
 
-    int32_t dst_count = src_count - count;
-    dst->count = dst_count;
-    if (!dst_count) {
-        dst->array = NULL;
-        return 0;
-    }
+    /* Get count & size before growing entities array. This tells us whether the
+     * arrays will realloc */
+    ecs_data_t *data = &table->data;
+    int32_t count = data->entities.count;
+    int32_t column_count = table->column_count;
+    ecs_column_t *columns = table->data.columns;
 
-    ecs_id_t *dst_array = flecs_walloc_n(world, ecs_id_t, dst_count);
-    dst->array = dst_array;
+    /* Grow buffer with entity ids, set new element to new entity */
+    ecs_entity_t *e = ecs_vec_append_t(&world->allocator, 
+        &data->entities, ecs_entity_t);
+    ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL);
+    *e = entity;
+ 
+    /* If the table is monitored indicate that there has been a change */
+    flecs_table_mark_table_dirty(world, table, 0);
+    ecs_assert(count >= 0, ECS_INTERNAL_ERROR, NULL);
 
-    if (at) {
-        ecs_os_memcpy_n(dst_array, src_array, ecs_id_t, at);
+    /* Fast path: no switch columns, no lifecycle actions */
+    if (!(table->flags & EcsTableIsComplex)) {
+        flecs_table_fast_append(world, columns, column_count);
+        if (!count) {
+            flecs_table_set_empty(world, table); /* See below */
+        }
+        return count;
     }
 
-    int32_t remain = dst_count - at;
-    if (remain) {
-        ecs_os_memcpy_n(
-            &dst_array[at], &src_array[at + count], ecs_id_t, remain);
-    }
+    ecs_entity_t *entities = data->entities.array;
 
-    return 0;
-}
+    /* Reobtain size to ensure that the columns have the same size as the 
+     * entities and record vectors. This keeps reasoning about when allocations
+     * occur easier. */
+    int32_t size = data->entities.size;
 
-/* Copy type */
-ecs_type_t flecs_type_copy(
-    ecs_world_t *world,
-    const ecs_type_t *src)
-{
-    int32_t src_count = src->count;
-    if (!src_count) {
-        return (ecs_type_t){ 0 };
-    }
+    /* Grow component arrays with 1 element */
+    int32_t i;
+    for (i = 0; i < column_count; i ++) {
+        ecs_column_t *column = &columns[i];
+        flecs_table_grow_column(world, column, 1, size, construct);
 
-    ecs_id_t *ids = flecs_walloc_n(world, ecs_id_t, src_count);
-    ecs_os_memcpy_n(ids, src->array, ecs_id_t, src_count);
-    return (ecs_type_t) {
-        .array = ids,
-        .count = src_count
-    };
-}
+        ecs_iter_action_t on_add_hook;
+        if (on_add && (on_add_hook = column->ti->hooks.on_add)) {
+            flecs_table_invoke_hook(world, table, on_add_hook, EcsOnAdd, column,
+                &entities[count], count, 1);
+        }
 
-/* Free type */
-void flecs_type_free(
-    ecs_world_t *world,
-    ecs_type_t *type)
-{
-    int32_t count = type->count;
-    if (count) {
-        flecs_wfree_n(world, ecs_id_t, type->count, type->array);
+        ecs_assert(columns[i].data.size == 
+            data->entities.size, ECS_INTERNAL_ERROR, NULL); 
+        ecs_assert(columns[i].data.count == 
+            data->entities.count, ECS_INTERNAL_ERROR, NULL);
     }
-}
 
-/* Add to type */
-static
-void flecs_type_add(
-    ecs_world_t *world,
-    ecs_type_t *type,
-    ecs_id_t add)
-{
-    ecs_type_t new_type;
-    int res = flecs_type_new_with(world, &new_type, type, add);
-    if (res != -1) {
-        flecs_type_free(world, type);
-        type->array = new_type.array;
-        type->count = new_type.count;
+    ecs_table__t *meta = table->_;
+    int32_t bs_count = meta->bs_count;
+    ecs_bitset_t *bs_columns = meta->bs_columns;
+
+    /* Add element to each bitset column */
+    for (i = 0; i < bs_count; i ++) {
+        ecs_assert(bs_columns != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_bitset_t *bs = &bs_columns[i];
+        flecs_bitset_addn(bs, 1);
     }
-}
 
-/* Graph edge utilities */
+    /* If this is the first entity in this table, signal queries so that the
+     * table moves from an inactive table to an active table. */
+    if (!count) {
+        flecs_table_set_empty(world, table);
+    }
 
-void flecs_table_diff_builder_init(
-    ecs_world_t *world,
-    ecs_table_diff_builder_t *builder)
-{
-    ecs_allocator_t *a = &world->allocator;
-    ecs_vec_init_t(a, &builder->added, ecs_id_t, 256);
-    ecs_vec_init_t(a, &builder->removed, ecs_id_t, 256);
-}
+    flecs_table_check_sanity(table);
 
-void flecs_table_diff_builder_fini(
-    ecs_world_t *world,
-    ecs_table_diff_builder_t *builder)
-{
-    ecs_allocator_t *a = &world->allocator;
-    ecs_vec_fini_t(a, &builder->added, ecs_id_t);
-    ecs_vec_fini_t(a, &builder->removed, ecs_id_t);
+    return count;
 }
 
-void flecs_table_diff_builder_clear(
-    ecs_table_diff_builder_t *builder)
+/* Delete last operation for tables that don't have any complex logic */
+static
+void flecs_table_fast_delete_last(
+    ecs_column_t *columns,
+    int32_t column_count) 
 {
-    ecs_vec_clear(&builder->added);
-    ecs_vec_clear(&builder->removed);
+    int i;
+    for (i = 0; i < column_count; i ++) {
+        ecs_vec_remove_last(&columns[i].data);
+    }
 }
 
+/* Delete operation for tables that don't have any complex logic */
 static
-void flecs_table_diff_build_type(
-    ecs_world_t *world,
-    ecs_vec_t *vec,
-    ecs_type_t *type,
-    int32_t offset)
+void flecs_table_fast_delete(
+    ecs_column_t *columns,
+    int32_t column_count,
+    int32_t index) 
 {
-    int32_t count = vec->count - offset;
-    ecs_assert(count >= 0, ECS_INTERNAL_ERROR, NULL);
-    if (count) {
-        type->array = flecs_wdup_n(world, ecs_id_t, count, 
-            ECS_ELEM_T(vec->array, ecs_id_t, offset));
-        type->count = count;
-        ecs_vec_set_count_t(&world->allocator, vec, ecs_id_t, offset);
+    int i;
+    for (i = 0; i < column_count; i ++) {
+        ecs_column_t *column = &columns[i];
+        ecs_vec_remove(&column->data, column->size, index);
     }
 }
 
-void flecs_table_diff_build(
+/* Delete entity from table */
+void flecs_table_delete(
     ecs_world_t *world,
-    ecs_table_diff_builder_t *builder,
-    ecs_table_diff_t *diff,
-    int32_t added_offset,
-    int32_t removed_offset)
+    ecs_table_t *table,
+    int32_t index,
+    bool destruct)
 {
-    flecs_table_diff_build_type(world, &builder->added, &diff->added, 
-        added_offset);
-    flecs_table_diff_build_type(world, &builder->removed, &diff->removed, 
-        removed_offset);
-}
+    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
 
-void flecs_table_diff_build_noalloc(
-    ecs_table_diff_builder_t *builder,
-    ecs_table_diff_t *diff)
-{
-    diff->added = (ecs_type_t){
-        .array = builder->added.array, .count = builder->added.count };
-    diff->removed = (ecs_type_t){
-        .array = builder->removed.array, .count = builder->removed.count };
-}
+    flecs_table_check_sanity(table);
 
-static
-void flecs_table_diff_build_add_type_to_vec(
-    ecs_world_t *world,
-    ecs_vec_t *vec,
-    ecs_type_t *add)
-{
-    if (!add || !add->count) {
-        return;
-    }
+    ecs_data_t *data = &table->data;
+    int32_t count = data->entities.count;
 
-    int32_t offset = vec->count;
-    ecs_vec_grow_t(&world->allocator, vec, ecs_id_t, add->count);
-    ecs_os_memcpy_n(ecs_vec_get_t(vec, ecs_id_t, offset),
-        add->array, ecs_id_t, add->count);
-}
+    ecs_assert(count > 0, ECS_INTERNAL_ERROR, NULL);
+    count --;
+    ecs_assert(index <= count, ECS_INTERNAL_ERROR, NULL);
 
-void flecs_table_diff_build_append_table(
-    ecs_world_t *world,
-    ecs_table_diff_builder_t *dst,
-    ecs_table_diff_t *src)
-{
-    flecs_table_diff_build_add_type_to_vec(world, &dst->added, &src->added);
-    flecs_table_diff_build_add_type_to_vec(world, &dst->removed, &src->removed);
-}
+    /* Move last entity id to index */
+    ecs_entity_t *entities = data->entities.array;
+    ecs_entity_t entity_to_move = entities[count];
+    ecs_entity_t entity_to_delete = entities[index];
+    entities[index] = entity_to_move;
+    ecs_vec_remove_last(&data->entities);
 
-static
-void flecs_table_diff_free(
-    ecs_world_t *world,
-    ecs_table_diff_t *diff) 
-{
-    flecs_wfree_n(world, ecs_id_t, diff->added.count, diff->added.array);
-    flecs_wfree_n(world, ecs_id_t, diff->removed.count, diff->removed.array);
-    flecs_bfree(&world->allocators.table_diff, diff);
-}
+    /* Update record of moved entity in entity index */
+    if (index != count) {
+        ecs_record_t *record_to_move = flecs_entities_get(world, entity_to_move);
+        if (record_to_move) {
+            uint32_t row_flags = record_to_move->row & ECS_ROW_FLAGS_MASK;
+            record_to_move->row = ECS_ROW_TO_RECORD(index, row_flags);
+            ecs_assert(record_to_move->table != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(record_to_move->table == table, ECS_INTERNAL_ERROR, NULL);
+        }
+    }     
 
-static
-ecs_graph_edge_t* flecs_table_ensure_hi_edge(
-    ecs_world_t *world,
-    ecs_graph_edges_t *edges,
-    ecs_id_t id)
-{
-    if (!edges->hi) {
-        edges->hi = flecs_alloc_t(&world->allocator, ecs_map_t);
-        ecs_map_init_w_params(edges->hi, &world->allocators.ptr);
+    /* If the table is monitored indicate that there has been a change */
+    flecs_table_mark_table_dirty(world, table, 0);    
+
+    /* If table is empty, deactivate it */
+    if (!count) {
+        flecs_table_set_empty(world, table);
     }
 
-    ecs_graph_edge_t **r = ecs_map_ensure_ref(edges->hi, ecs_graph_edge_t, id);
-    ecs_graph_edge_t *edge = r[0];
-    if (edge) {
-        return edge;
+    /* Destruct component data */
+    ecs_column_t *columns = data->columns;
+    int32_t column_count = table->column_count;
+    int32_t i;
+
+    /* If this is a table without lifecycle callbacks or special columns, take
+     * fast path that just remove an element from the array(s) */
+    if (!(table->flags & EcsTableIsComplex)) {
+        if (index == count) {
+            flecs_table_fast_delete_last(columns, column_count);
+        } else {
+            flecs_table_fast_delete(columns, column_count, index);
+        }
+
+        flecs_table_check_sanity(table);
+        return;
     }
 
-    if (id < FLECS_HI_COMPONENT_ID) {
-        edge = &edges->lo[id];
+    /* Last element, destruct & remove */
+    if (index == count) {
+        /* If table has component destructors, invoke */
+        if (destruct && (table->flags & EcsTableHasDtors)) {            
+            for (i = 0; i < column_count; i ++) {
+                flecs_table_invoke_remove_hooks(world, table, &columns[i], 
+                    &entity_to_delete, index, 1, true);
+            }
+        }
+
+        flecs_table_fast_delete_last(columns, column_count);
+
+    /* Not last element, move last element to deleted element & destruct */
     } else {
-        edge = flecs_bcalloc(&world->allocators.graph_edge);
-    }
+        /* If table has component destructors, invoke */
+        if ((table->flags & (EcsTableHasDtors | EcsTableHasMove))) {
+            for (i = 0; i < column_count; i ++) {
+                ecs_column_t *column = &columns[i];
+                ecs_type_info_t *ti = column->ti;
+                ecs_size_t size = column->size;
+                void *dst = ecs_vec_get(&column->data, size, index);
+                void *src = ecs_vec_last(&column->data, size);
 
-    r[0] = edge;
-    return edge;
-}
+                ecs_iter_action_t on_remove = ti->hooks.on_remove;
+                if (destruct && on_remove) {
+                    flecs_table_invoke_hook(world, table, on_remove, EcsOnRemove,
+                        column, &entity_to_delete, index, 1);
+                }
 
-static
-ecs_graph_edge_t* flecs_table_ensure_edge(
-    ecs_world_t *world,
-    ecs_graph_edges_t *edges,
-    ecs_id_t id)
-{
-    ecs_graph_edge_t *edge;
-    
-    if (id < FLECS_HI_COMPONENT_ID) {
-        if (!edges->lo) {
-            edges->lo = flecs_bcalloc(&world->allocators.graph_edge_lo);
+                ecs_move_t move_dtor = ti->hooks.move_dtor;
+                
+                // If neither move nor move_ctor are set, this indicates that non-destructive move 
+                // semantics are not supported for this type. In such cases, we set the move_dtor
+                // as ctor_move_dtor, which indicates a destructive move operation. 
+                // This adjustment ensures compatibility with different language bindings.
+                if (!ti->hooks.move_ctor && ti->hooks.ctor_move_dtor) {
+                  move_dtor = ti->hooks.ctor_move_dtor;
+                }
+
+                if (move_dtor) {
+                    move_dtor(dst, src, 1, ti);
+                } else {
+                    ecs_os_memcpy(dst, src, size);
+                }
+
+                ecs_vec_remove_last(&column->data);
+            }
+        } else {
+            flecs_table_fast_delete(columns, column_count, index);
         }
-        edge = &edges->lo[id];
-    } else {
-        edge = flecs_table_ensure_hi_edge(world, edges, id);
     }
 
-    return edge;
+    /* Remove elements from bitset columns */
+    ecs_table__t *meta = table->_;
+    ecs_bitset_t *bs_columns = meta->bs_columns;
+    int32_t bs_count = meta->bs_count;
+    for (i = 0; i < bs_count; i ++) {
+        flecs_bitset_remove(&bs_columns[i], index);
+    }
+
+    flecs_table_check_sanity(table);
 }
 
+/* Move operation for tables that don't have any complex logic */
 static
-void flecs_table_disconnect_edge(
-    ecs_world_t *world,
-    ecs_id_t id,
-    ecs_graph_edge_t *edge)
+void flecs_table_fast_move(
+    ecs_table_t *dst_table,
+    int32_t dst_index,
+    ecs_table_t *src_table,
+    int32_t src_index)
 {
-    ecs_assert(edge != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(edge->id == id, ECS_INTERNAL_ERROR, NULL);
-    (void)id;
+    int32_t i_new = 0, dst_column_count = dst_table->column_count;
+    int32_t i_old = 0, src_column_count = src_table->column_count;
 
-    /* Remove backref from destination table */
-    ecs_graph_edge_hdr_t *next = edge->hdr.next;
-    ecs_graph_edge_hdr_t *prev = edge->hdr.prev;
+    ecs_column_t *src_columns = src_table->data.columns;
+    ecs_column_t *dst_columns = dst_table->data.columns;
 
-    if (next) {
-        next->prev = prev;
-    }
-    if (prev) {
-        prev->next = next;
-    }
+    for (; (i_new < dst_column_count) && (i_old < src_column_count);) {
+        ecs_column_t *dst_column = &dst_columns[i_new];
+        ecs_column_t *src_column = &src_columns[i_old];
+        ecs_id_t dst_id = dst_column->id;
+        ecs_id_t src_id = src_column->id;
 
-    /* Remove data associated with edge */
-    ecs_table_diff_t *diff = edge->diff;
-    if (diff) {
-        flecs_table_diff_free(world, diff);
-    }
+        if (dst_id == src_id) {
+            int32_t size = dst_column->size;
+            void *dst = ecs_vec_get(&dst_column->data, size, dst_index);
+            void *src = ecs_vec_get(&src_column->data, size, src_index);
+            ecs_os_memcpy(dst, src, size);
+        }
 
-    /* If edge id is low, clear it from fast lookup array */
-    if (id < FLECS_HI_COMPONENT_ID) {
-        ecs_os_memset_t(edge, 0, ecs_graph_edge_t);
-    } else {
-        flecs_bfree(&world->allocators.graph_edge, edge);
+        i_new += dst_id <= src_id;
+        i_old += dst_id >= src_id;
     }
 }
 
-static
-void flecs_table_remove_edge(
+/* Move entity from src to dst table */
+void flecs_table_move(
     ecs_world_t *world,
-    ecs_graph_edges_t *edges,
-    ecs_id_t id,
-    ecs_graph_edge_t *edge)
-{
-    ecs_assert(edges != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(edges->hi != NULL, ECS_INTERNAL_ERROR, NULL);
-    flecs_table_disconnect_edge(world, id, edge);
-    ecs_map_remove(edges->hi, id);
-}
-
-static
-void flecs_table_init_edges(
-    ecs_graph_edges_t *edges)
+    ecs_entity_t dst_entity,
+    ecs_entity_t src_entity,
+    ecs_table_t *dst_table,
+    int32_t dst_index,
+    ecs_table_t *src_table,
+    int32_t src_index,
+    bool construct)
 {
-    edges->lo = NULL;
-    edges->hi = NULL;
-}
+    ecs_assert(dst_table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(src_table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!dst_table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    ecs_assert(!src_table->_->lock, ECS_LOCKED_STORAGE, NULL);
 
-static
-void flecs_table_init_node(
-    ecs_graph_node_t *node)
-{
-    flecs_table_init_edges(&node->add);
-    flecs_table_init_edges(&node->remove);
-}
+    ecs_assert(src_index >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(dst_index >= 0, ECS_INTERNAL_ERROR, NULL);
 
-bool flecs_table_records_update_empty(
-    ecs_table_t *table)
-{
-    bool result = false;
-    bool is_empty = ecs_table_count(table) == 0;
+    flecs_table_check_sanity(dst_table);
+    flecs_table_check_sanity(src_table);
 
-    int32_t i, count = table->_->record_count;
-    for (i = 0; i < count; i ++) {
-        ecs_table_record_t *tr = &table->_->records[i];
-        ecs_table_cache_t *cache = tr->hdr.cache;
-        result |= ecs_table_cache_set_empty(cache, table, is_empty);
+    if (!((dst_table->flags | src_table->flags) & EcsTableIsComplex)) {
+        flecs_table_fast_move(dst_table, dst_index, src_table, src_index);
+        flecs_table_check_sanity(dst_table);
+        flecs_table_check_sanity(src_table);
+        return;
     }
 
-    return result;
-}
+    flecs_table_move_bitset_columns(dst_table, dst_index, src_table, src_index, 1, false);
 
-static
-void flecs_init_table(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_table_t *prev)
-{
-    table->flags = 0;
-    table->dirty_state = NULL;
-    table->_->lock = 0;
-    table->_->generation = 0;
+    /* If the source and destination entities are the same, move component 
+     * between tables. If the entities are not the same (like when cloning) use
+     * a copy. */
+    bool same_entity = dst_entity == src_entity;
 
-    flecs_table_init_node(&table->node);
+    /* Call move_dtor for moved away from storage only if the entity is at the
+     * last index in the source table. If it isn't the last entity, the last 
+     * entity in the table will be moved to the src storage, which will take
+     * care of cleaning up resources. */
+    bool use_move_dtor = ecs_table_count(src_table) == (src_index + 1);
 
-    flecs_table_init(world, table, prev);
-}
+    int32_t i_new = 0, dst_column_count = dst_table->column_count;
+    int32_t i_old = 0, src_column_count = src_table->column_count;
 
-static
-ecs_table_t *flecs_create_table(
-    ecs_world_t *world,
-    ecs_type_t *type,
-    flecs_hashmap_result_t table_elem,
-    ecs_table_t *prev)
-{
-    ecs_table_t *result = flecs_sparse_add_t(&world->store.tables, ecs_table_t);
-    ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL);
-    result->_ = flecs_calloc_t(&world->allocator, ecs_table__t);
-    ecs_assert(result->_ != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_column_t *src_columns = src_table->data.columns;
+    ecs_column_t *dst_columns = dst_table->data.columns;
 
-#ifdef FLECS_SANITIZE
-    int32_t i, j, count = type->count;
-    for (i = 0; i < count - 1; i ++) {
-        if (type->array[i] >= type->array[i + 1]) {
-            for (j = 0; j < count; j ++) {
-                char *str = ecs_id_str(world, type->array[j]);
-                if (i == j) {
-                    ecs_err(" > %d: %s", j, str);
+    for (; (i_new < dst_column_count) && (i_old < src_column_count); ) {
+        ecs_column_t *dst_column = &dst_columns[i_new];
+        ecs_column_t *src_column = &src_columns[i_old];
+        ecs_id_t dst_id = dst_column->id;
+        ecs_id_t src_id = src_column->id;
+
+        if (dst_id == src_id) {
+            int32_t size = dst_column->size;
+
+            ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL);
+            void *dst = ecs_vec_get(&dst_column->data, size, dst_index);
+            void *src = ecs_vec_get(&src_column->data, size, src_index);
+            ecs_type_info_t *ti = dst_column->ti;
+
+            if (same_entity) {
+                ecs_move_t move = ti->hooks.move_ctor;
+                if (use_move_dtor || !move) {
+                    /* Also use move_dtor if component doesn't have a move_ctor
+                     * registered, to ensure that the dtor gets called to 
+                     * cleanup resources. */
+                    move = ti->hooks.ctor_move_dtor;
+                }
+
+                if (move) {
+                    move(dst, src, 1, ti);
                 } else {
-                    ecs_err("   %d: %s", j, str);
+                    ecs_os_memcpy(dst, src, size);
+                }
+            } else {
+                ecs_copy_t copy = ti->hooks.copy_ctor;
+                if (copy) {
+                    copy(dst, src, 1, ti);
+                } else {
+                    ecs_os_memcpy(dst, src, size);
                 }
-                ecs_os_free(str);
             }
-            ecs_abort(ECS_CONSTRAINT_VIOLATED, "table type is not ordered");
+        } else {
+            if (dst_id < src_id) {
+                flecs_table_invoke_add_hooks(world, dst_table,
+                    dst_column, &dst_entity, dst_index, 1, construct);
+            } else {
+                flecs_table_invoke_remove_hooks(world, src_table,
+                    src_column, &src_entity, src_index, 1, use_move_dtor);
+            }
         }
-    }
-#endif
-
-    result->id = flecs_sparse_last_id(&world->store.tables);
-    result->type = *type;
 
-    if (ecs_should_log_2()) {
-        char *expr = ecs_type_str(world, &result->type);
-        ecs_dbg_2(
-            "#[green]table#[normal] [%s] #[green]created#[reset] with id %d", 
-            expr, result->id);
-        ecs_os_free(expr);
+        i_new += dst_id <= src_id;
+        i_old += dst_id >= src_id;
     }
 
-    ecs_log_push_2();
-
-    /* Store table in table hashmap */
-    *(ecs_table_t**)table_elem.value = result;
+    for (; (i_new < dst_column_count); i_new ++) {
+        flecs_table_invoke_add_hooks(world, dst_table, &dst_columns[i_new], 
+            &dst_entity, dst_index, 1, construct);
+    }
 
-    /* Set keyvalue to one that has the same lifecycle as the table */
-    *(ecs_type_t*)table_elem.key = result->type;
-    result->_->hash = table_elem.hash;
+    for (; (i_old < src_column_count); i_old ++) {
+        flecs_table_invoke_remove_hooks(world, src_table, &src_columns[i_old], 
+            &src_entity, src_index, 1, use_move_dtor);
+    }
 
-    flecs_init_table(world, result, prev);
+    flecs_table_check_sanity(dst_table);
+    flecs_table_check_sanity(src_table);
+}
 
-    /* Update counters */
-    world->info.table_count ++;
-    world->info.empty_table_count ++;
-    world->info.table_create_total ++;
+/* Append n entities to table */
+int32_t flecs_table_appendn(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_data_t *data,
+    int32_t to_add,
+    const ecs_entity_t *ids)
+{
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
 
-    ecs_log_pop_2();
+    flecs_table_check_sanity(table);
+    int32_t cur_count = flecs_table_data_count(data);
+    int32_t result = flecs_table_grow_data(
+        world, table, data, to_add, cur_count + to_add, ids);
+    flecs_table_check_sanity(table);
 
     return result;
 }
 
-static
-ecs_table_t* flecs_table_ensure(
+/* Set allocated table size */
+void flecs_table_set_size(
     ecs_world_t *world,
-    ecs_type_t *type,
-    bool own_type,
-    ecs_table_t *prev)
-{    
-    ecs_poly_assert(world, ecs_world_t);   
+    ecs_table_t *table,
+    ecs_data_t *data,
+    int32_t size)
+{
+    ecs_assert(table != NULL, ECS_LOCKED_STORAGE, NULL);
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
 
-    int32_t id_count = type->count;
-    if (!id_count) {
-        return &world->store.root;
-    }
+    flecs_table_check_sanity(table);
 
-    ecs_table_t *table;
-    flecs_hashmap_result_t elem = flecs_hashmap_ensure(
-        &world->store.table_map, type, ecs_table_t*);
-    if ((table = *(ecs_table_t**)elem.value)) {
-        if (own_type) {
-            flecs_type_free(world, type);
-        }
-        return table;
+    int32_t cur_count = flecs_table_data_count(data);
+
+    if (cur_count < size) {
+        flecs_table_grow_data(world, table, data, 0, size, NULL);
+        flecs_table_check_sanity(table);
     }
+}
 
-    /* If we get here, table needs to be created which is only allowed when the
-     * application is not currently in progress */
-    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INTERNAL_ERROR, NULL);
+/* Shrink table storage to fit number of entities */
+bool flecs_table_shrink(
+    ecs_world_t *world,
+    ecs_table_t *table)
+{
+    ecs_assert(table != NULL, ECS_LOCKED_STORAGE, NULL);
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    (void)world;
 
-    /* If we get here, the table has not been found, so create it. */
-    if (own_type) {
-        return flecs_create_table(world, type, elem, prev);
+    flecs_table_check_sanity(table);
+
+    ecs_data_t *data = &table->data;
+    bool has_payload = data->entities.array != NULL;
+    ecs_vec_reclaim_t(&world->allocator, &data->entities, ecs_entity_t);
+
+    int32_t i, count = table->column_count;
+    for (i = 0; i < count; i ++) {
+        ecs_column_t *column = &data->columns[i];
+        ecs_vec_reclaim(&world->allocator, &column->data, column->size);
     }
 
-    ecs_type_t copy = flecs_type_copy(world, type);
-    return flecs_create_table(world, &copy, elem, prev);
+    return has_payload;
 }
 
-static
-void flecs_diff_insert_added(
-    ecs_world_t *world,
-    ecs_table_diff_builder_t *diff,
-    ecs_id_t id)
+/* Return number of entities in table */
+int32_t flecs_table_data_count(
+    const ecs_data_t *data)
 {
-    ecs_vec_append_t(&world->allocator, &diff->added, ecs_id_t)[0] = id;
+    return data ? data->entities.count : 0;
 }
 
+/* Swap operation for bitset (toggle component) columns */
 static
-void flecs_diff_insert_removed(
-    ecs_world_t *world,
-    ecs_table_diff_builder_t *diff,
-    ecs_id_t id)
+void flecs_table_swap_bitset_columns(
+    ecs_table_t *table,
+    int32_t row_1,
+    int32_t row_2)
 {
-    ecs_allocator_t *a = &world->allocator;
-    ecs_vec_append_t(a, &diff->removed, ecs_id_t)[0] = id;
+    int32_t i = 0, column_count = table->_->bs_count;
+    if (!column_count) {
+        return;
+    }
+
+    ecs_bitset_t *columns = table->_->bs_columns;
+
+    for (i = 0; i < column_count; i ++) {
+        ecs_bitset_t *bs = &columns[i];
+        flecs_bitset_swap(bs, row_1, row_2);
+    }
 }
 
-static
-void flecs_compute_table_diff(
+/* Swap two rows in a table. Used for table sorting. */
+void flecs_table_swap(
     ecs_world_t *world,
-    ecs_table_t *node,
-    ecs_table_t *next,
-    ecs_graph_edge_t *edge,
-    ecs_id_t id)
-{
-    if (ECS_IS_PAIR(id)) {
-        ecs_id_record_t *idr = flecs_id_record_get(world, ecs_pair(
-            ECS_PAIR_FIRST(id), EcsWildcard));
-        if (idr->flags & EcsIdUnion) {
-            if (node != next) {
-                id = ecs_pair(EcsUnion, ECS_PAIR_FIRST(id));
-            } else {
-                ecs_table_diff_t *diff = flecs_bcalloc(
-                    &world->allocators.table_diff);
-                diff->added.count = 1;
-                diff->added.array = flecs_wdup_n(world, ecs_id_t, 1, &id);
-                edge->diff = diff;
-                return;
-            }
-        }
-    }
+    ecs_table_t *table,
+    int32_t row_1,
+    int32_t row_2)
+{    
+    (void)world;
 
-    ecs_type_t node_type = node->type;
-    ecs_type_t next_type = next->type;
+    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    ecs_assert(row_1 >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(row_2 >= 0, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_id_t *ids_node = node_type.array;
-    ecs_id_t *ids_next = next_type.array;
-    int32_t i_node = 0, node_count = node_type.count;
-    int32_t i_next = 0, next_count = next_type.count;
-    int32_t added_count = 0;
-    int32_t removed_count = 0;
-    bool trivial_edge = !ECS_HAS_RELATION(id, EcsIsA);
+    flecs_table_check_sanity(table);
+    
+    if (row_1 == row_2) {
+        return;
+    }
 
-    /* First do a scan to see how big the diff is, so we don't have to realloc
-     * or alloc more memory than required. */
-    for (; i_node < node_count && i_next < next_count; ) {
-        ecs_id_t id_node = ids_node[i_node];
-        ecs_id_t id_next = ids_next[i_next];
+    /* If the table is monitored indicate that there has been a change */
+    flecs_table_mark_table_dirty(world, table, 0);    
 
-        bool added = id_next < id_node;
-        bool removed = id_node < id_next;
+    ecs_entity_t *entities = table->data.entities.array;
+    ecs_entity_t e1 = entities[row_1];
+    ecs_entity_t e2 = entities[row_2];
 
-        trivial_edge &= !added || id_next == id;
-        trivial_edge &= !removed || id_node == id;
+    ecs_record_t *record_ptr_1 = flecs_entities_get(world, e1);
+    ecs_record_t *record_ptr_2 = flecs_entities_get(world, e2);
 
-        added_count += added;
-        removed_count += removed;
+    ecs_assert(record_ptr_1 != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(record_ptr_2 != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        i_node += id_node <= id_next;
-        i_next += id_next <= id_node;
-    }
+    /* Keep track of whether entity is watched */
+    uint32_t flags_1 = ECS_RECORD_TO_ROW_FLAGS(record_ptr_1->row);
+    uint32_t flags_2 = ECS_RECORD_TO_ROW_FLAGS(record_ptr_2->row);
 
-    added_count += next_count - i_next;
-    removed_count += node_count - i_node;
+    /* Swap entities & records */
+    entities[row_1] = e2;
+    entities[row_2] = e1;
+    record_ptr_1->row = ECS_ROW_TO_RECORD(row_2, flags_1);
+    record_ptr_2->row = ECS_ROW_TO_RECORD(row_1, flags_2);
 
-    trivial_edge &= (added_count + removed_count) <= 1 && 
-        !ecs_id_is_wildcard(id);
+    flecs_table_swap_bitset_columns(table, row_1, row_2);
 
-    if (trivial_edge) {
-        /* If edge is trivial there's no need to create a diff element for it */
+    ecs_column_t *columns = table->data.columns;
+    if (!columns) {
+        flecs_table_check_sanity(table);
         return;
     }
 
-    ecs_table_diff_builder_t *builder = &world->allocators.diff_builder;
-    int32_t added_offset = builder->added.count;
-    int32_t removed_offset = builder->removed.count;
+    /* Find the maximum size of column elements
+     * and allocate a temporary buffer for swapping */
+    int32_t i, temp_buffer_size = ECS_SIZEOF(uint64_t), column_count = table->column_count;
+    for (i = 0; i < column_count; i++) {
+        temp_buffer_size = ECS_MAX(temp_buffer_size, columns[i].size);
+    }
 
-    for (i_node = 0, i_next = 0; i_node < node_count && i_next < next_count; ) {
-        ecs_id_t id_node = ids_node[i_node];
-        ecs_id_t id_next = ids_next[i_next];
+    void* tmp = ecs_os_alloca(temp_buffer_size);
 
-        if (id_next < id_node) {
-            flecs_diff_insert_added(world, builder, id_next);
-        } else if (id_node < id_next) {
-            flecs_diff_insert_removed(world, builder, id_node);
-        }
+    /* Swap columns */
+    for (i = 0; i < column_count; i ++) {
+        int32_t size = columns[i].size;
+        ecs_column_t *column = &columns[i];
+        void *ptr = column->data.array;
+        const ecs_type_info_t *ti = column->ti;
+        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        i_node += id_node <= id_next;
-        i_next += id_next <= id_node;
-    }
+        void *el_1 = ECS_ELEM(ptr, size, row_1);
+        void *el_2 = ECS_ELEM(ptr, size, row_2);
 
-    for (; i_next < next_count; i_next ++) {
-        flecs_diff_insert_added(world, builder, ids_next[i_next]);
-    }
-    for (; i_node < node_count; i_node ++) {
-        flecs_diff_insert_removed(world, builder, ids_node[i_node]);
+        ecs_move_t move = ti->hooks.move;
+        if (!move) {
+            ecs_os_memcpy(tmp, el_1, size);
+            ecs_os_memcpy(el_1, el_2, size);
+            ecs_os_memcpy(el_2, tmp, size);
+        } else {
+            ecs_move_t move_ctor = ti->hooks.move_ctor;
+            ecs_move_t move_dtor = ti->hooks.move_dtor;
+            ecs_assert(move_ctor != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(move_dtor != NULL, ECS_INTERNAL_ERROR, NULL);
+            move_ctor(tmp, el_1, 1, ti);
+            move(el_1, el_2, 1, ti);
+            move_dtor(el_2, tmp, 1, ti);
+        }
     }
 
-    ecs_table_diff_t *diff = flecs_bcalloc(&world->allocators.table_diff);
-    edge->diff = diff;
-    flecs_table_diff_build(world, builder, diff, added_offset, removed_offset);
-
-    ecs_assert(diff->added.count == added_count, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(diff->removed.count == removed_count, ECS_INTERNAL_ERROR, NULL);
+    flecs_table_check_sanity(table);
 }
 
 static
-void flecs_add_overrides_for_base(
+void flecs_table_merge_vec(
     ecs_world_t *world,
-    ecs_type_t *dst_type,
-    ecs_id_t pair)
+    ecs_vec_t *dst,
+    ecs_vec_t *src,
+    int32_t size,
+    int32_t elem_size)
 {
-    ecs_entity_t base = ecs_pair_second(world, pair);
-    ecs_assert(base != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_table_t *base_table = ecs_get_table(world, base);
-    if (!base_table) {
-        return;
-    }
+    int32_t dst_count = dst->count;
 
-    ecs_id_t *ids = base_table->type.array;
+    if (!dst_count) {
+        ecs_vec_fini(&world->allocator, dst, size);
+        *dst = *src;
+        src->array = NULL;
+        src->count = 0;
+        src->size = 0;
+    } else {
+        int32_t src_count = src->count;
 
-    ecs_flags32_t flags = base_table->flags;
-    if (flags & EcsTableHasOverrides) {
-        int32_t i, count = base_table->type.count;
-        for (i = 0; i < count; i ++) {
-            ecs_id_t id = ids[i];
-            ecs_id_t to_add = 0;
-            if (ECS_HAS_ID_FLAG(id, OVERRIDE)) {
-                to_add = id & ~ECS_OVERRIDE;
-            } else {
-                ecs_table_record_t *tr = &base_table->_->records[i];
-                ecs_id_record_t *idr = (ecs_id_record_t*)tr->hdr.cache;
-                if (idr->flags & EcsIdAlwaysOverride) {
-                    to_add = id;
-                }
-            }
-            if (to_add) {
-                ecs_id_t wc = ecs_pair(ECS_PAIR_FIRST(to_add), EcsWildcard);
-                bool exclusive = false;
-                if (ECS_IS_PAIR(to_add)) {
-                    ecs_id_record_t *idr = flecs_id_record_get(world, wc);
-                    if (idr) {
-                        exclusive = (idr->flags & EcsIdExclusive) != 0;
-                    }
-                }
-                if (!exclusive) {
-                    flecs_type_add(world, dst_type, to_add);
-                } else {
-                    int32_t column = flecs_type_find(dst_type, wc);
-                    if (column == -1) {
-                        flecs_type_add(world, dst_type, to_add);
-                    } else {
-                        dst_type->array[column] = to_add;
-                    }
-                }
-            }
+        if (elem_size) {
+            ecs_vec_set_size(&world->allocator, 
+                dst, size, elem_size);
         }
-    }
+        ecs_vec_set_count(&world->allocator, 
+            dst, size, dst_count + src_count);
 
-    if (flags & EcsTableHasIsA) {
-        ecs_table_record_t *tr = flecs_id_record_get_table(
-            world->idr_isa_wildcard, base_table);
-        ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-        int32_t i = tr->index, end = i + tr->count;
-        for (; i != end; i ++) {
-            flecs_add_overrides_for_base(world, dst_type, ids[i]);
-        }
+        void *dst_ptr = ECS_ELEM(dst->array, size, dst_count);
+        void *src_ptr = src->array;
+        ecs_os_memcpy(dst_ptr, src_ptr, size * src_count);
+
+        ecs_vec_fini(&world->allocator, src, size);
     }
 }
 
+/* Merge data from one table column into other table column */
 static
-void flecs_add_with_property(
+void flecs_table_merge_column(
     ecs_world_t *world,
-    ecs_id_record_t *idr_with_wildcard,
-    ecs_type_t *dst_type,
-    ecs_entity_t r,
-    ecs_entity_t o)
+    ecs_column_t *dst,
+    ecs_column_t *src,
+    int32_t column_size)
 {
-    r = ecs_get_alive(world, r);
+    ecs_size_t size = dst->size;
+    int32_t dst_count = dst->data.count;
 
-    /* Check if component/relationship has With pairs, which contain ids
-     * that need to be added to the table. */
-    ecs_table_t *table = ecs_get_table(world, r);
-    if (!table) {
-        return;
-    }
-    
-    ecs_table_record_t *tr = flecs_id_record_get_table(
-        idr_with_wildcard, table);
-    if (tr) {
-        int32_t i = tr->index, end = i + tr->count;
-        ecs_id_t *ids = table->type.array;
+    if (!dst_count) {
+        ecs_vec_fini(&world->allocator, &dst->data, size);
+        *dst = *src;
+        src->data.array = NULL;
+        src->data.count = 0;
+        src->data.size = 0;
 
-        for (; i < end; i ++) {
-            ecs_id_t id = ids[i];
-            ecs_assert(ECS_PAIR_FIRST(id) == EcsWith, ECS_INTERNAL_ERROR, NULL);
-            ecs_id_t ra = ECS_PAIR_SECOND(id);
-            ecs_id_t a = ra;
-            if (o) {
-                a = ecs_pair(ra, o);
-            }
+    /* If the new table is not empty, copy the contents from the
+     * src into the dst. */
+    } else {
+        int32_t src_count = src->data.count;
 
-            flecs_type_add(world, dst_type, a);
-            flecs_add_with_property(world, idr_with_wildcard, dst_type, ra, o);
+        flecs_table_grow_column(world, dst, src_count, column_size, false);
+        void *dst_ptr = ECS_ELEM(dst->data.array, size, dst_count);
+        void *src_ptr = src->data.array;
+
+        /* Move values into column */
+        ecs_type_info_t *ti = dst->ti;
+        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_move_t move = ti->hooks.ctor_move_dtor;
+        if (move) {
+            move(dst_ptr, src_ptr, src_count, ti);
+        } else {
+            ecs_os_memcpy(dst_ptr, src_ptr, size * src_count);
         }
-    }
 
+        ecs_vec_fini(&world->allocator, &src->data, size);
+    }
 }
 
+/* Merge storage of two tables. */
 static
-ecs_table_t* flecs_find_table_with(
+void flecs_table_merge_data(
     ecs_world_t *world,
-    ecs_table_t *node,
-    ecs_id_t with)
-{    
-    ecs_make_alive_id(world, with);
-
-    ecs_id_record_t *idr = NULL;
-    ecs_entity_t r = 0, o = 0;
+    ecs_table_t *dst_table,
+    ecs_table_t *src_table,
+    int32_t src_count,
+    int32_t dst_count,
+    ecs_data_t *src_data,
+    ecs_data_t *dst_data)
+{
+    int32_t i_new = 0, dst_column_count = dst_table->column_count;
+    int32_t i_old = 0, src_column_count = src_table->column_count;
+    ecs_column_t *src_columns = src_data->columns;
+    ecs_column_t *dst_columns = dst_data->columns;
 
-    if (ECS_IS_PAIR(with)) {
-        r = ECS_PAIR_FIRST(with);
-        o = ECS_PAIR_SECOND(with);
-        idr = flecs_id_record_ensure(world, ecs_pair(r, EcsWildcard));
-        if (idr->flags & EcsIdUnion) {
-            ecs_type_t dst_type;
-            ecs_id_t union_id = ecs_pair(EcsUnion, r);
-            int res = flecs_type_new_with(
-                world, &dst_type, &node->type, union_id);
-            if (res == -1) {
-                return node;
-            }
+    ecs_assert(!dst_column_count || dst_columns, ECS_INTERNAL_ERROR, NULL);
 
-            return flecs_table_ensure(world, &dst_type, true, node);
-        } else if (idr->flags & EcsIdExclusive) {
-            /* Relationship is exclusive, check if table already has it */
-            ecs_table_record_t *tr = flecs_id_record_get_table(idr, node);
-            if (tr) {
-                /* Table already has an instance of the relationship, create
-                 * a new id sequence with the existing id replaced */
-                ecs_type_t dst_type = flecs_type_copy(world, &node->type);
-                ecs_assert(dst_type.array != NULL, ECS_INTERNAL_ERROR, NULL);
-                dst_type.array[tr->index] = with;
-                return flecs_table_ensure(world, &dst_type, true, node);
-            }
-        }
-    } else {
-        idr = flecs_id_record_ensure(world, with);
-        r = with;
+    if (!src_count) {
+        return;
     }
 
-    /* Create sequence with new id */
-    ecs_type_t dst_type;
-    int res = flecs_type_new_with(world, &dst_type, &node->type, with);
-    if (res == -1) {
-        return node; /* Current table already has id */
-    }
+    /* Merge entities */
+    flecs_table_merge_vec(world, &dst_data->entities, &src_data->entities, 
+        ECS_SIZEOF(ecs_entity_t), 0);
+    ecs_assert(dst_data->entities.count == src_count + dst_count, 
+        ECS_INTERNAL_ERROR, NULL);
+    int32_t column_size = dst_data->entities.size;
+    ecs_allocator_t *a = &world->allocator;
 
-    if (r == EcsIsA) {
-        /* If adding a prefab, check if prefab has overrides */
-        flecs_add_overrides_for_base(world, &dst_type, with);
-    } else if (r == EcsChildOf) {
-        o = ecs_get_alive(world, o);
-        if (ecs_has_id(world, o, EcsPrefab)) {
-            flecs_type_add(world, &dst_type, EcsPrefab);
+    for (; (i_new < dst_column_count) && (i_old < src_column_count); ) {
+        ecs_column_t *dst_column = &dst_columns[i_new];
+        ecs_column_t *src_column = &src_columns[i_old];
+        ecs_id_t dst_id = dst_column->id;
+        ecs_id_t src_id = src_column->id;
+    
+        if (dst_id == src_id) {
+            flecs_table_merge_column(world, dst_column, src_column, column_size);
+            flecs_table_mark_table_dirty(world, dst_table, i_new + 1);
+            i_new ++;
+            i_old ++;
+        } else if (dst_id < src_id) {
+            /* New column, make sure vector is large enough. */
+            ecs_size_t size = dst_column->size;
+            ecs_vec_set_size(a, &dst_column->data, size, column_size);
+            ecs_vec_set_count(a, &dst_column->data, size, src_count + dst_count);
+            flecs_table_invoke_ctor(dst_column, dst_count, src_count);
+            i_new ++;
+        } else if (dst_id > src_id) {
+            /* Old column does not occur in new table, destruct */
+            flecs_table_invoke_dtor(src_column, 0, src_count);
+            ecs_vec_fini(a, &src_column->data, src_column->size);
+            i_old ++;
         }
     }
 
-    if (idr->flags & EcsIdWith) {
-        ecs_id_record_t *idr_with_wildcard = flecs_id_record_get(world,
-            ecs_pair(EcsWith, EcsWildcard));
-        /* If id has With property, add targets to type */
-        flecs_add_with_property(world, idr_with_wildcard, &dst_type, r, o);
+    flecs_table_move_bitset_columns(dst_table, dst_count, src_table, 0, src_count, true);
+
+    /* Initialize remaining columns */
+    for (; i_new < dst_column_count; i_new ++) {
+        ecs_column_t *column = &dst_columns[i_new];
+        int32_t size = column->size;
+        ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_vec_set_size(a, &column->data, size, column_size);
+        ecs_vec_set_count(a, &column->data, size, src_count + dst_count);
+        flecs_table_invoke_ctor(column, dst_count, src_count);
     }
 
-    return flecs_table_ensure(world, &dst_type, true, node);
+    /* Destruct remaining columns */
+    for (; i_old < src_column_count; i_old ++) {
+        ecs_column_t *column = &src_columns[i_old];
+        flecs_table_invoke_dtor(column, 0, src_count);
+        ecs_vec_fini(a, &column->data, column->size);
+    }    
+
+    /* Mark entity column as dirty */
+    flecs_table_mark_table_dirty(world, dst_table, 0); 
 }
 
-static
-ecs_table_t* flecs_find_table_without(
+/* Merge source table into destination table. This typically happens as result
+ * of a bulk operation, like when a component is removed from all entities in 
+ * the source table (like for the Remove OnDelete policy). */
+void flecs_table_merge(
     ecs_world_t *world,
-    ecs_table_t *node,
-    ecs_id_t without)
+    ecs_table_t *dst_table,
+    ecs_table_t *src_table)
 {
-    if (ECS_IS_PAIR(without)) {
-        ecs_entity_t r = 0;
-        ecs_id_record_t *idr = NULL;
-        r = ECS_PAIR_FIRST(without);
-        idr = flecs_id_record_get(world, ecs_pair(r, EcsWildcard));
-        if (idr && idr->flags & EcsIdUnion) {
-            without = ecs_pair(EcsUnion, r);
-        }
-    }
-
-    /* Create sequence with new id */
-    ecs_type_t dst_type;
-    int res = flecs_type_new_without(world, &dst_type, &node->type, without);
-    if (res == -1) {
-        return node; /* Current table does not have id */
-    }
+    ecs_assert(src_table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(dst_table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!src_table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    ecs_assert(!dst_table->_->lock, ECS_LOCKED_STORAGE, NULL);
 
-    return flecs_table_ensure(world, &dst_type, true, node);
-}
+    flecs_table_check_sanity(src_table);
+    flecs_table_check_sanity(dst_table);
 
-static
-void flecs_table_init_edge(
-    ecs_table_t *table,
-    ecs_graph_edge_t *edge,
-    ecs_id_t id,
-    ecs_table_t *to)
-{
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(edge != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(edge->id == 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(edge->hdr.next == NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(edge->hdr.prev == NULL, ECS_INTERNAL_ERROR, NULL);
-    
-    edge->from = table;
-    edge->to = to;
-    edge->id = id;
-}
+    ecs_data_t *dst_data = &dst_table->data;
+    ecs_data_t *src_data = &src_table->data;
 
-static
-void flecs_init_edge_for_add(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_graph_edge_t *edge,
-    ecs_id_t id,
-    ecs_table_t *to)
-{
-    flecs_table_init_edge(table, edge, id, to);
+    ecs_entity_t *src_entities = src_data->entities.array;
+    int32_t src_count = src_data->entities.count;
+    int32_t dst_count = dst_data->entities.count;
 
-    flecs_table_ensure_hi_edge(world, &table->node.add, id);
+    /* First, update entity index so old entities point to new type */
+    int32_t i;
+    for(i = 0; i < src_count; i ++) {
+        ecs_record_t *record = flecs_entities_ensure(world, src_entities[i]);
+        uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
+        record->row = ECS_ROW_TO_RECORD(dst_count + i, flags);
+        record->table = dst_table;
+    }
 
-    if (table != to || table->flags & EcsTableHasUnion) {
-        /* Add edges are appended to refs.next */
-        ecs_graph_edge_hdr_t *to_refs = &to->node.refs;
-        ecs_graph_edge_hdr_t *next = to_refs->next;
-        
-        to_refs->next = &edge->hdr;
-        edge->hdr.prev = to_refs;
+    /* Merge table columns */
+    flecs_table_merge_data(world, dst_table, src_table, src_count, dst_count, 
+        src_data, dst_data);
 
-        edge->hdr.next = next;
-        if (next) {
-            next->prev = &edge->hdr;
+    if (src_count) {
+        if (!dst_count) {
+            flecs_table_set_empty(world, dst_table);
         }
+        flecs_table_set_empty(world, src_table);
 
-        flecs_compute_table_diff(world, table, to, edge, id);
+        flecs_table_traversable_add(dst_table, src_table->_->traversable_count);
+        flecs_table_traversable_add(src_table, -src_table->_->traversable_count);
+        ecs_assert(src_table->_->traversable_count == 0, ECS_INTERNAL_ERROR, NULL);
     }
+
+    flecs_table_check_sanity(src_table);
+    flecs_table_check_sanity(dst_table);
 }
 
-static
-void flecs_init_edge_for_remove(
+/* Internal mechanism for propagating information to tables */
+void flecs_table_notify(
     ecs_world_t *world,
     ecs_table_t *table,
-    ecs_graph_edge_t *edge,
-    ecs_id_t id,
-    ecs_table_t *to)
+    ecs_table_event_t *event)
 {
-    flecs_table_init_edge(table, edge, id, to);
-
-    flecs_table_ensure_hi_edge(world, &table->node.remove, id);
+    if (world->flags & EcsWorldFini) {
+        return;
+    }
 
-    if (table != to) {
-        /* Remove edges are appended to refs.prev */
-        ecs_graph_edge_hdr_t *to_refs = &to->node.refs;
-        ecs_graph_edge_hdr_t *prev = to_refs->prev;
+    switch(event->kind) {
+    case EcsTableTriggersForId:
+        flecs_table_add_trigger_flags(world, table, event->event);
+        break;
+    case EcsTableNoTriggersForId:
+        break;
+    }
+}
 
-        to_refs->prev = &edge->hdr;
-        edge->hdr.next = to_refs;
+int32_t flecs_table_get_toggle_column(
+    ecs_table_t *table,
+    ecs_id_t id)
+{
+    ecs_id_t *ids = table->type.array;
+    int32_t i = table->_->bs_offset, end = i + table->_->bs_count;
 
-        edge->hdr.prev = prev;
-        if (prev) {
-            prev->next = &edge->hdr;
+    for (; i < end; i ++) {
+        if (ids[i] == (ECS_TOGGLE | id)) {
+            return i;
         }
-
-        flecs_compute_table_diff(world, table, to, edge, id);
     }
+
+    return -1;
 }
 
-static
-ecs_table_t* flecs_create_edge_for_remove(
-    ecs_world_t *world,
-    ecs_table_t *node,
-    ecs_graph_edge_t *edge,
+ecs_bitset_t* flecs_table_get_toggle(
+    ecs_table_t *table,
     ecs_id_t id)
 {
-    ecs_table_t *to = flecs_find_table_without(world, node, id);
-    flecs_init_edge_for_remove(world, node, edge, id, to);
-    return to;   
+    int32_t toggle_column = flecs_table_get_toggle_column(table, id);
+    if (toggle_column == -1) {
+        return NULL;
+    }
+
+    toggle_column -= table->_->bs_offset;
+    ecs_assert(toggle_column >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(toggle_column < table->_->bs_count, ECS_INTERNAL_ERROR, NULL);
+    return &table->_->bs_columns[toggle_column];
 }
 
-static
-ecs_table_t* flecs_create_edge_for_add(
+/* -- Public API -- */
+
+void ecs_table_lock(
     ecs_world_t *world,
-    ecs_table_t *node,
-    ecs_graph_edge_t *edge,
-    ecs_id_t id)
+    ecs_table_t *table)
 {
-    ecs_table_t *to = flecs_find_table_with(world, node, id);
-    flecs_init_edge_for_add(world, node, edge, id, to);
-    return to;
+    if (table) {
+        if (flecs_poly_is(world, ecs_world_t) && !(world->flags & EcsWorldReadonly)) {
+            table->_->lock ++;
+        }
+    }
 }
 
-ecs_table_t* flecs_table_traverse_remove(
+void ecs_table_unlock(
     ecs_world_t *world,
-    ecs_table_t *node,
-    ecs_id_t *id_ptr,
-    ecs_table_diff_t *diff)
+    ecs_table_t *table)
 {
-    ecs_poly_assert(world, ecs_world_t);
-
-    node = node ? node : &world->store.root;
-
-    /* Removing 0 from an entity is not valid */
-    ecs_check(id_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(id_ptr[0] != 0, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_id_t id = id_ptr[0];
-    ecs_graph_edge_t *edge = flecs_table_ensure_edge(world, &node->node.remove, id);
-    ecs_table_t *to = edge->to;
+    if (table) {
+        if (flecs_poly_is(world, ecs_world_t) && !(world->flags & EcsWorldReadonly)) {
+            table->_->lock --;
+            ecs_assert(table->_->lock >= 0, ECS_INVALID_OPERATION, 
+                "table_unlock called more often than table_lock");
+        }
+    }
+}
 
-    if (!to) {
-        to = flecs_create_edge_for_remove(world, node, edge, id);
-        ecs_assert(to != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(edge->to != NULL, ECS_INTERNAL_ERROR, NULL);
+const ecs_type_t* ecs_table_get_type(
+    const ecs_table_t *table)
+{
+    if (table) {
+        return &table->type;
+    } else {
+        return NULL;
     }
+}
 
-    if (node != to) {
-        if (edge->diff) {
-            *diff = *edge->diff;
-        } else {
-            diff->added.count = 0;
-            diff->removed.array = id_ptr;
-            diff->removed.count = 1;
-        }
+int32_t ecs_table_get_type_index(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    ecs_id_t id)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
+
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return -1;
     }
 
-    return to;
+    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+    if (!tr) {
+        return -1;
+    }
+
+    return tr->index;
 error:
-    return NULL;
+    return -1;
 }
 
-ecs_table_t* flecs_table_traverse_add(
-    ecs_world_t *world,
-    ecs_table_t *node,
-    ecs_id_t *id_ptr,
-    ecs_table_diff_t *diff)
+int32_t ecs_table_get_column_index(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    ecs_id_t id)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(diff != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    node = node ? node : &world->store.root;
-
-    /* Adding 0 to an entity is not valid */
-    ecs_check(id_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(id_ptr[0] != 0, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_id_t id = id_ptr[0];
-    ecs_graph_edge_t *edge = flecs_table_ensure_edge(world, &node->node.add, id);
-    ecs_table_t *to = edge->to;
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
 
-    if (!to) {
-        to = flecs_create_edge_for_add(world, node, edge, id);
-        ecs_assert(to != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(edge->to != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return -1;
     }
 
-    if (node != to || edge->diff) {
-        if (edge->diff) {
-            *diff = *edge->diff;
-        } else {
-            diff->added.array = id_ptr;
-            diff->added.count = 1;
-            diff->removed.count = 0;
-        }
+    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+    if (!tr) {
+        return -1;
     }
 
-    return to;
+    return tr->column;
 error:
-    return NULL;
+    return -1;
 }
 
-ecs_table_t* flecs_table_find_or_create(
-    ecs_world_t *world,
-    ecs_type_t *type)
+int32_t ecs_table_column_count(
+    const ecs_table_t *table)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    return flecs_table_ensure(world, type, false, NULL);
+    return table->column_count;
 }
 
-void flecs_init_root_table(
-    ecs_world_t *world)
+int32_t ecs_table_type_to_column_index(
+    const ecs_table_t *table,
+    int32_t index)
 {
-    ecs_poly_assert(world, ecs_world_t);
-
-    world->store.root.type = (ecs_type_t){0};
-    world->store.root._ = flecs_calloc_t(&world->allocator, ecs_table__t);
-    flecs_init_table(world, &world->store.root, NULL);
+    ecs_assert(index >= 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(index < table->type.count, ECS_INVALID_PARAMETER, NULL);
+    int32_t *column_map = table->column_map;
+    if (column_map) {
+        return column_map[index];
+    }
+error:
+    return -1;
+}
 
-    /* Ensure table indices start at 1, as 0 is reserved for the root */
-    uint64_t new_id = flecs_sparse_new_id(&world->store.tables);
-    ecs_assert(new_id == 0, ECS_INTERNAL_ERROR, NULL);
-    (void)new_id;
+int32_t ecs_table_column_to_type_index(
+    const ecs_table_t *table,
+    int32_t index)
+{
+    ecs_check(index < table->column_count, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(table->column_map != NULL, ECS_INVALID_PARAMETER, NULL);
+    int32_t offset = table->type.count;
+    return table->column_map[offset + index];
+error:
+    return -1;
 }
 
-void flecs_table_clear_edges(
-    ecs_world_t *world,
-    ecs_table_t *table)
+void* ecs_table_get_column(
+    const ecs_table_t *table,
+    int32_t index,
+    int32_t offset)
 {
-    (void)world;
-    ecs_poly_assert(world, ecs_world_t);
+    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(index < table->column_count, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_log_push_1();
+    ecs_column_t *column = &table->data.columns[index];
+    void *result = column->data.array;
+    if (offset) {
+        result = ECS_ELEM(result, column->size, offset);
+    }
 
-    ecs_map_iter_t it;
-    ecs_graph_node_t *table_node = &table->node;
-    ecs_graph_edges_t *node_add = &table_node->add;
-    ecs_graph_edges_t *node_remove = &table_node->remove;
-    ecs_map_t *add_hi = node_add->hi;
-    ecs_map_t *remove_hi = node_remove->hi;
-    ecs_graph_edge_hdr_t *node_refs = &table_node->refs;
+    return result;
+error:
+    return NULL;
+}
 
-    /* Cleanup outgoing edges */
-    it = ecs_map_iter(add_hi);
-    while (ecs_map_next(&it)) {
-        flecs_table_disconnect_edge(world, ecs_map_key(&it), ecs_map_ptr(&it));
-    }
+void* ecs_table_get_id(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    ecs_id_t id,
+    int32_t offset)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
 
-    it = ecs_map_iter(remove_hi);
-    while (ecs_map_next(&it)) {
-        flecs_table_disconnect_edge(world, ecs_map_key(&it), ecs_map_ptr(&it));
-    }
+    world = ecs_get_world(world);
 
-    /* Cleanup incoming add edges */
-    ecs_graph_edge_hdr_t *next, *cur = node_refs->next;
-    if (cur) {
-        do {
-            ecs_graph_edge_t *edge = (ecs_graph_edge_t*)cur;
-            ecs_assert(edge->to == table, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(edge->from != NULL, ECS_INTERNAL_ERROR, NULL);
-            next = cur->next;
-            flecs_table_remove_edge(world, &edge->from->node.add, edge->id, edge);
-        } while ((cur = next));
+    int32_t index = ecs_table_get_column_index(world, table, id);
+    if (index == -1) {
+        return NULL;
     }
 
-    /* Cleanup incoming remove edges */
-    cur = node_refs->prev;
-    if (cur) {
-        do {
-            ecs_graph_edge_t *edge = (ecs_graph_edge_t*)cur;
-            ecs_assert(edge->to == table, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(edge->from != NULL, ECS_INTERNAL_ERROR, NULL);
-            next = cur->prev;
-            flecs_table_remove_edge(world, &edge->from->node.remove, edge->id, edge);
-        } while ((cur = next));
-    }
+    return ecs_table_get_column(table, index, offset);
+error:
+    return NULL;
+}
 
-    if (node_add->lo) {
-        flecs_bfree(&world->allocators.graph_edge_lo, node_add->lo);
-    }
-    if (node_remove->lo) {
-        flecs_bfree(&world->allocators.graph_edge_lo, node_remove->lo);
-    }
+size_t ecs_table_get_column_size(
+    const ecs_table_t *table,
+    int32_t column)
+{
+    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(column < table->column_count, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(table->column_map != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_map_fini(add_hi);
-    ecs_map_fini(remove_hi);
-    flecs_free_t(&world->allocator, ecs_map_t, add_hi);
-    flecs_free_t(&world->allocator, ecs_map_t, remove_hi);
-    table_node->add.lo = NULL;
-    table_node->remove.lo = NULL;
-    table_node->add.hi = NULL;
-    table_node->remove.hi = NULL;
+    return flecs_ito(size_t, table->data.columns[column].size);
+error:
+    return 0;
+}
 
-    ecs_log_pop_1();
+int32_t ecs_table_count(
+    const ecs_table_t *table)
+{
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    return flecs_table_data_count(&table->data);
 }
 
-/* Public convenience functions for traversing table graph */
-ecs_table_t* ecs_table_add_id(
-    ecs_world_t *world,
-    ecs_table_t *table,
+bool ecs_table_has_id(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
     ecs_id_t id)
 {
-    ecs_table_diff_t diff;
-    return flecs_table_traverse_add(world, table, &id, &diff);
+    return ecs_table_get_type_index(world, table, id) != -1;
 }
 
-ecs_table_t* ecs_table_remove_id(
-    ecs_world_t *world,
+int32_t ecs_table_get_depth(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    ecs_entity_t rel)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_id_is_valid(world, rel), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_has_id(world, rel, EcsAcyclic), ECS_INVALID_PARAMETER,
+        "cannot safely determine depth for relationship that is not acyclic "
+            "(add Acyclic property to relationship)");
+
+    world = ecs_get_world(world);
+
+    return flecs_relation_depth(world, rel, table);
+error:
+    return -1;
+}
+
+bool ecs_table_has_flags(
     ecs_table_t *table,
-    ecs_id_t id)
+    ecs_flags32_t flags)
 {
-    ecs_table_diff_t diff;
-    return flecs_table_traverse_remove(world, table, &id, &diff);
+    return (table->flags & flags) == flags;
 }
 
-ecs_table_t* ecs_table_find(
-    ecs_world_t *world,
-    const ecs_id_t *ids,
-    int32_t id_count)
+void ecs_table_swap_rows(
+    ecs_world_t* world,
+    ecs_table_t* table,
+    int32_t row_1,
+    int32_t row_2)
 {
-    ecs_type_t type = {
-        .array = ECS_CONST_CAST(ecs_id_t*, ids),
-        .count = id_count
-    };
-    return flecs_table_ensure(world, &type, false, NULL);
+    flecs_table_swap(world, table, row_1, row_2);
 }
 
-/**
- * @file expr/deserialize.c
- * @brief Deserialize flecs string format into (component) values.
- */
+int32_t flecs_table_observed_count(
+    const ecs_table_t *table)
+{
+    return table->_->traversable_count;
+}
 
-#include <ctype.h>
+void* ecs_record_get_column(
+    const ecs_record_t *r,
+    int32_t index,
+    size_t c_size)
+{
+    (void)c_size;
+    ecs_table_t *table = r->table;
 
-#ifdef FLECS_EXPR
+    ecs_check(index < table->column_count, ECS_INVALID_PARAMETER, NULL);
+    ecs_column_t *column = &table->data.columns[index];
+    ecs_size_t size = column->size;
 
-/* String deserializer for values & simple expressions */
+    ecs_check(!flecs_utosize(c_size) || flecs_utosize(c_size) == size, 
+        ECS_INVALID_PARAMETER, NULL);
 
-/* Order in enumeration is important, as it is used for precedence */
-typedef enum ecs_expr_oper_t {
-    EcsExprOperUnknown,
-    EcsLeftParen,
-    EcsCondAnd,
-    EcsCondOr,
-    EcsCondEq,
-    EcsCondNeq,
-    EcsCondGt,
-    EcsCondGtEq,
-    EcsCondLt,
-    EcsCondLtEq,
-    EcsShiftLeft,
-    EcsShiftRight,
-    EcsAdd,
-    EcsSub,
-    EcsMul,
-    EcsDiv,
-    EcsMin
-} ecs_expr_oper_t;
+    return ecs_vec_get(&column->data, size, ECS_RECORD_TO_ROW(r->row));
+error:
+    return NULL;
+}
 
-/* Used to track temporary values */
-#define EXPR_MAX_STACK_SIZE (256)
+ecs_record_t* ecs_record_find(
+    const ecs_world_t *world,
+    ecs_entity_t entity)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
 
-typedef struct ecs_expr_value_t {
-    const ecs_type_info_t *ti;
-    void *ptr;
-} ecs_expr_value_t;
+    world = ecs_get_world(world);
 
-typedef struct ecs_value_stack_t {
-    ecs_expr_value_t values[EXPR_MAX_STACK_SIZE];
-    ecs_stack_cursor_t *cursor;
-    ecs_stack_t *stack;
-    ecs_stage_t *stage;
-    int32_t count;
-} ecs_value_stack_t;
+    ecs_record_t *r = flecs_entities_get(world, entity);
+    if (r) {
+        return r;
+    }
+error:
+    return NULL;
+}
+
+/**
+ * @file table_cache.c
+ * @brief Data structure for fast table iteration/lookups.
+ * 
+ * A table cache is a data structure that provides constant time operations for
+ * insertion and removal of tables, and to testing whether a table is registered
+ * with the cache. A table cache also provides functions to iterate the tables
+ * in a cache.
+ * 
+ * The world stores a table cache per (component) id inside the id record 
+ * administration. Cached queries store a table cache with matched tables.
+ * 
+ * A table cache has separate lists for non-empty tables and empty tables. This
+ * improves performance as applications don't waste time iterating empty tables.
+ */
 
-static
-const char* flecs_parse_expr(
-    ecs_world_t *world,
-    ecs_value_stack_t *stack,
-    const char *ptr,
-    ecs_value_t *value,
-    ecs_expr_oper_t op,
-    const ecs_parse_expr_desc_t *desc);
 
 static
-void* flecs_expr_value_new(
-    ecs_value_stack_t *stack,
-    ecs_entity_t type)
+void flecs_table_cache_list_remove(
+    ecs_table_cache_t *cache,
+    ecs_table_cache_hdr_t *elem)
 {
-    ecs_stage_t *stage = stack->stage;
-    ecs_world_t *world = stage->world;
-    ecs_id_record_t *idr = flecs_id_record_get(world, type);
-    if (!idr) {
-        return NULL;
-    }
+    ecs_table_cache_hdr_t *next = elem->next;
+    ecs_table_cache_hdr_t *prev = elem->prev;
 
-    const ecs_type_info_t *ti = idr->type_info;
-    if (!ti) {
-        return NULL;
+    if (next) {
+        next->prev = prev;
+    }
+    if (prev) {
+        prev->next = next;
     }
 
-    ecs_assert(ti->size != 0, ECS_INTERNAL_ERROR, NULL);
-    void *result = flecs_stack_alloc(stack->stack, ti->size, ti->alignment);
-    if (ti->hooks.ctor) {
-        ti->hooks.ctor(result, 1, ti);
-    } else {
-        ecs_os_memset(result, 0, ti->size);
+    cache->empty_tables.count -= !!elem->empty;
+    cache->tables.count -= !elem->empty;
+
+    if (cache->empty_tables.first == elem) {
+        cache->empty_tables.first = next;
+    } else if (cache->tables.first == elem) {
+        cache->tables.first = next;
     }
-    if (ti->hooks.dtor) {
-        /* Track values that have destructors */
-        stack->values[stack->count].ti = ti;
-        stack->values[stack->count].ptr = result;
-        stack->count ++;
+    if (cache->empty_tables.last == elem) {
+        cache->empty_tables.last = prev;
+    }
+    if (cache->tables.last == elem) {
+        cache->tables.last = prev;
     }
-
-    return result;
 }
 
 static
-const char* flecs_str_to_expr_oper(
-    const char *str,
-    ecs_expr_oper_t *op)
+void flecs_table_cache_list_insert(
+    ecs_table_cache_t *cache,
+    ecs_table_cache_hdr_t *elem)
 {
-    if (!ecs_os_strncmp(str, "+", 1)) {
-        *op = EcsAdd;
-        return str + 1;
-    } else if (!ecs_os_strncmp(str, "-", 1)) {
-        *op = EcsSub;
-        return str + 1;
-    } else if (!ecs_os_strncmp(str, "*", 1)) {
-        *op = EcsMul;
-        return str + 1;
-    } else if (!ecs_os_strncmp(str, "/", 1)) {
-        *op = EcsDiv;
-        return str + 1;
-    } else if (!ecs_os_strncmp(str, "&&", 2)) {
-        *op = EcsCondAnd;
-        return str + 2;
-    } else if (!ecs_os_strncmp(str, "||", 2)) {
-        *op = EcsCondOr;
-        return str + 2;
-    } else if (!ecs_os_strncmp(str, "==", 2)) {
-        *op = EcsCondEq;
-        return str + 2;
-    } else if (!ecs_os_strncmp(str, "!=", 2)) {
-        *op = EcsCondNeq;
-        return str + 2;
-    } else if (!ecs_os_strncmp(str, ">=", 2)) {
-        *op = EcsCondGtEq;
-        return str + 2;
-    } else if (!ecs_os_strncmp(str, "<=", 2)) {
-        *op = EcsCondLtEq;
-        return str + 2;
-    } else if (!ecs_os_strncmp(str, ">>", 2)) {
-        *op = EcsShiftRight;
-        return str + 2;
-    } else if (!ecs_os_strncmp(str, "<<", 2)) {
-        *op = EcsShiftLeft;
-        return str + 2;
-    } else if (!ecs_os_strncmp(str, ">", 1)) {
-        *op = EcsCondGt;
-        return str + 1;
-    } else if (!ecs_os_strncmp(str, "<", 1)) {
-        *op = EcsCondLt;
-        return str + 1;
+    ecs_table_cache_hdr_t *last;
+    if (elem->empty) {
+        last = cache->empty_tables.last;
+        cache->empty_tables.last = elem;
+        if ((++ cache->empty_tables.count) == 1) {
+            cache->empty_tables.first = elem;
+        }
+    } else {
+        last = cache->tables.last;
+        cache->tables.last = elem;
+        if ((++ cache->tables.count) == 1) {
+            cache->tables.first = elem;
+        }
     }
 
-    *op = EcsExprOperUnknown;
-    return NULL;
+    elem->next = NULL;
+    elem->prev = last;
+
+    if (last) {
+        last->next = elem;
+    }
 }
 
-const char *ecs_parse_expr_token(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token)
+void ecs_table_cache_init(
+    ecs_world_t *world,
+    ecs_table_cache_t *cache)
 {
-    char *token_ptr = token;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_map_init_w_params(&cache->index, &world->allocators.ptr);
+}
 
-    if (ptr[0] == '/') {
-        char ch;
-        if (ptr[1] == '/') {
-            // Single line comment
-            for (ptr = &ptr[2]; (ch = ptr[0]) && (ch != '\n'); ptr ++) {}
-            token[0] = 0;
-            return ecs_parse_ws_eol(ptr);
-        } else if (ptr[1] == '*') {
-            // Multi line comment
-            for (ptr = &ptr[2]; (ch = ptr[0]); ptr ++) {
-                if (ch == '*' && ptr[1] == '/') {
-                    token[0] = 0;
-                    return ecs_parse_ws_eol(ptr + 2);
-                }
-            }
+void ecs_table_cache_fini(
+    ecs_table_cache_t *cache)
+{
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_map_fini(&cache->index);
+}
 
-            ecs_parser_error(name, expr, ptr - expr, 
-                "missing */ for multiline comment");
-            return NULL;
-        }
+bool ecs_table_cache_is_empty(
+    const ecs_table_cache_t *cache)
+{
+    return ecs_map_count(&cache->index) == 0;
+}
+
+void ecs_table_cache_insert(
+    ecs_table_cache_t *cache,
+    const ecs_table_t *table,
+    ecs_table_cache_hdr_t *result)
+{
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(ecs_table_cache_get(cache, table) == NULL,
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    bool empty;
+    if (!table) {
+        empty = false;
+    } else {
+        empty = ecs_table_count(table) == 0;
     }
 
-    ecs_expr_oper_t op;
-    if (ptr[0] == '(') {
-        token[0] = '(';
-        token[1] = 0;
-        return ptr + 1;
-    } else if (ptr[0] != '-') {
-        const char *tptr = flecs_str_to_expr_oper(ptr, &op);
-        if (tptr) {
-            ecs_os_strncpy(token, ptr, tptr - ptr);
-            return tptr;
-        }
-    }
+    result->cache = cache;
+    result->table = ECS_CONST_CAST(ecs_table_t*, table);
+    result->empty = empty;
 
-    while ((ptr = ecs_parse_token(name, expr, ptr, token_ptr, 0))) {
-        if (ptr[0] == '|' && ptr[1] != '|') {
-            token_ptr = &token_ptr[ecs_os_strlen(token_ptr)];
-            token_ptr[0] = '|';
-            token_ptr[1] = '\0';
-            token_ptr ++;
-            ptr ++;
-        } else {
-            break;
-        }
+    flecs_table_cache_list_insert(cache, result);
+
+    if (table) {
+        ecs_map_insert_ptr(&cache->index, table->id, result);
     }
 
-    return ptr;
+    ecs_assert(empty || cache->tables.first != NULL, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!empty || cache->empty_tables.first != NULL, 
+        ECS_INTERNAL_ERROR, NULL);
 }
 
-static
-const char* flecs_parse_multiline_string(
-    ecs_meta_cursor_t *cur,
-    const char *name,
-    const char *expr,
-    const char *ptr)
+void ecs_table_cache_replace(
+    ecs_table_cache_t *cache,
+    const ecs_table_t *table,
+    ecs_table_cache_hdr_t *elem)
 {
-    /* Multiline string */
-    ecs_strbuf_t str = ECS_STRBUF_INIT;
-    char ch;
-    while ((ch = ptr[0]) && (ch != '`')) {
-        if (ch == '\\' && ptr[1] == '`') {
-            ch = '`';
-            ptr ++;
-        }
-        ecs_strbuf_appendch(&str, ch);
-        ptr ++;
+    ecs_table_cache_hdr_t **r = ecs_map_get_ref(
+        &cache->index, ecs_table_cache_hdr_t, table->id);
+    ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_table_cache_hdr_t *old = *r;
+    ecs_assert(old != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_table_cache_hdr_t *prev = old->prev, *next = old->next;
+    if (prev) {
+        ecs_assert(prev->next == old, ECS_INTERNAL_ERROR, NULL);
+        prev->next = elem;
     }
-    
-    if (ch != '`') {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing '`' to close multiline string");
-        goto error;
+    if (next) {
+        ecs_assert(next->prev == old, ECS_INTERNAL_ERROR, NULL);
+        next->prev = elem;
     }
-    char *strval = ecs_strbuf_get(&str);
-    if (ecs_meta_set_string(cur, strval) != 0) {
-        goto error;
+
+    if (cache->empty_tables.first == old) {
+        cache->empty_tables.first = elem;
+    }
+    if (cache->empty_tables.last == old) {
+        cache->empty_tables.last = elem;
+    }
+    if (cache->tables.first == old) {
+        cache->tables.first = elem;
+    }
+    if (cache->tables.last == old) {
+        cache->tables.last = elem;
     }
-    ecs_os_free(strval);
 
-    return ptr + 1;
-error:
-    return NULL;
+    *r = elem;
+    elem->prev = prev;
+    elem->next = next;
 }
 
-static
-bool flecs_parse_is_float(
-    const char *ptr)
+void* ecs_table_cache_get(
+    const ecs_table_cache_t *cache,
+    const ecs_table_t *table)
 {
-    ecs_assert(isdigit(ptr[0]), ECS_INTERNAL_ERROR, NULL);
-    char ch;
-    while ((ch = (++ptr)[0])) {
-        if (ch == '.' || ch == 'e') {
-            return true;
-        }
-        if (!isdigit(ch)) {
-            return false;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (table) {
+        if (ecs_map_is_init(&cache->index)) {
+            return ecs_map_get_deref(&cache->index, void**, table->id);
         }
+        return NULL;
+    } else {
+        ecs_table_cache_hdr_t *elem = cache->tables.first;
+        ecs_assert(!elem || elem->table == NULL, ECS_INTERNAL_ERROR, NULL);
+        return elem;
     }
-    return false;
 }
 
-/* Attempt to resolve variable dotexpression to value (foo.bar) */
-static
-ecs_value_t flecs_dotresolve_var(
-    ecs_world_t *world,
-    ecs_vars_t *vars,
-    char *token)
+void* ecs_table_cache_remove(
+    ecs_table_cache_t *cache,
+    uint64_t table_id,
+    ecs_table_cache_hdr_t *elem)
 {
-    char *dot = strchr(token, '.');
-    if (!dot) {
-        return (ecs_value_t){ .type = ecs_id(ecs_entity_t) };
-    }
-
-    dot[0] = '\0';
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(table_id != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    const ecs_expr_var_t *var = ecs_vars_lookup(vars, token);
-    if (!var) {
-        return (ecs_value_t){0};
-    }
+    ecs_assert(elem->cache == cache, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_meta_cursor_t cur = ecs_meta_cursor(
-        world, var->value.type, var->value.ptr);
-    ecs_meta_push(&cur);
-    if (ecs_meta_dotmember(&cur, dot + 1) != 0) {
-        return (ecs_value_t){0};
-    }
+    flecs_table_cache_list_remove(cache, elem);
+    ecs_map_remove(&cache->index, table_id);
 
-    return (ecs_value_t){ 
-        .ptr = ecs_meta_get_ptr(&cur),
-        .type = ecs_meta_get_type(&cur)
-    };
+    return elem;
 }
 
-static
-int flecs_meta_call(
-    ecs_world_t *world,
-    ecs_value_stack_t *stack,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_meta_cursor_t *cur, 
-    const char *function) 
+bool ecs_table_cache_set_empty(
+    ecs_table_cache_t *cache,
+    const ecs_table_t *table,
+    bool empty)
 {
-    ecs_entity_t type = ecs_meta_get_type(cur);
-    void *value_ptr = ecs_meta_get_ptr(cur);
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    if (!ecs_os_strcmp(function, "parent")) {
-        if (type != ecs_id(ecs_entity_t)) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "parent() can only be called on entity");
-            return -1;
-        }
+    ecs_table_cache_hdr_t *elem = ecs_map_get_deref(&cache->index, 
+        ecs_table_cache_hdr_t, table->id);
+    if (!elem) {
+        return false;
+    }
 
-        *(ecs_entity_t*)value_ptr = ecs_get_parent(
-            world, *(ecs_entity_t*)value_ptr);
-    } else if (!ecs_os_strcmp(function, "name")) {
-        if (type != ecs_id(ecs_entity_t)) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "name() can only be called on entity");
-            return -1;
-        }
+    if (elem->empty == empty) {
+        return false;
+    }
 
-        char **result = flecs_expr_value_new(stack, ecs_id(ecs_string_t));
-        *result = ecs_os_strdup(ecs_get_name(world, *(ecs_entity_t*)value_ptr));
-        *cur = ecs_meta_cursor(world, ecs_id(ecs_string_t), result);
-    } else if (!ecs_os_strcmp(function, "doc_name")) {
-#ifdef FLECS_DOC
-        if (type != ecs_id(ecs_entity_t)) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "name() can only be called on entity");
-            return -1;
-        }
+    flecs_table_cache_list_remove(cache, elem);
+    elem->empty = empty;
+    flecs_table_cache_list_insert(cache, elem);
 
-        char **result = flecs_expr_value_new(stack, ecs_id(ecs_string_t));
-        *result = ecs_os_strdup(ecs_doc_get_name(world, *(ecs_entity_t*)value_ptr));
-        *cur = ecs_meta_cursor(world, ecs_id(ecs_string_t), result);
-#else
-        ecs_parser_error(name, expr, ptr - expr, 
-            "doc_name() is not available without FLECS_DOC addon");
-        return -1;
-#endif
-    } else {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unknown function '%s'", function);
-        return -1;
-    }
+    return true;
+}
 
-    return 0;
+bool flecs_table_cache_iter(
+    ecs_table_cache_t *cache,
+    ecs_table_cache_iter_t *out)
+{
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL);
+    out->next = cache->tables.first;
+    out->next_list = NULL;
+    out->cur = NULL;
+    return out->next != NULL;
 }
 
-/* Determine the type of an expression from the first character(s). This allows
- * us to initialize a storage for a type if none was provided. */
-static
-ecs_entity_t flecs_parse_discover_type(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_entity_t input_type,
-    const ecs_parse_expr_desc_t *desc)
+bool flecs_table_cache_empty_iter(
+    ecs_table_cache_t *cache,
+    ecs_table_cache_iter_t *out)
 {
-    /* String literal */
-    if (ptr[0] == '"' || ptr[0] == '`') {
-        if (input_type == ecs_id(ecs_char_t)) {
-            return input_type;
-        }
-        return ecs_id(ecs_string_t);
-    }
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL);
+    out->next = cache->empty_tables.first;
+    out->next_list = NULL;
+    out->cur = NULL;
+    return out->next != NULL;
+}
 
-    /* Negative number literal */
-    if (ptr[0] == '-') {
-        if (!isdigit(ptr[1])) {
-            ecs_parser_error(name, expr, ptr - expr, "invalid literal");
-            return 0;
-        }
-        if (flecs_parse_is_float(ptr + 1)) {
-            return ecs_id(ecs_f64_t);
-        } else {
-            return ecs_id(ecs_i64_t);
-        }
-    }
+bool flecs_table_cache_all_iter(
+    ecs_table_cache_t *cache,
+    ecs_table_cache_iter_t *out)
+{
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL);
+    out->next = cache->empty_tables.first;
+    out->next_list = cache->tables.first;
+    out->cur = NULL;
+    return out->next != NULL || out->next_list != NULL;
+}
 
-    /* Positive number literal */
-    if (isdigit(ptr[0])) {
-        if (flecs_parse_is_float(ptr)) {
-            return ecs_id(ecs_f64_t);
-        } else {
-            return ecs_id(ecs_u64_t);
+ecs_table_cache_hdr_t* flecs_table_cache_next_(
+    ecs_table_cache_iter_t *it)
+{
+    ecs_table_cache_hdr_t *next = it->next;
+    if (!next) {
+        next = it->next_list;
+        it->next_list = NULL;
+        if (!next) {
+            return NULL;
         }
     }
 
-    /* Variable */
-    if (ptr[0] == '$') {
-        if (!desc || !desc->vars) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "unresolved variable (no variable scope)");
-            return 0;
-        }
-        char token[ECS_MAX_TOKEN_SIZE];
-        if (ecs_parse_expr_token(name, expr, &ptr[1], token) == NULL) {
-            return 0;
-        }
+    it->cur = next;
+    it->next = next->next;
+    return next;
+}
 
-        const ecs_expr_var_t *var = ecs_vars_lookup(desc->vars, token);
-        if (!var) {
-            ecs_size_t len = ecs_os_strlen(token);
-            if (ptr[len + 1] == '(') {
-                while ((len > 0) && (token[len] != '.')) {
-                    len --;
-                }
-                if (token[len] == '.') {
-                    token[len] = '\0';
-                }
-            }
+/**
+ * @file table_graph.c
+ * @brief Data structure to speed up table transitions.
+ * 
+ * The table graph is used to speed up finding tables in add/remove operations.
+ * For example, if component C is added to an entity in table [A, B], the entity
+ * must be moved to table [A, B, C]. The graph speeds this process up with an
+ * edge for component C that connects [A, B] to [A, B, C].
+ */
 
-            ecs_value_t v = flecs_dotresolve_var(world, desc->vars, token);
-            if (v.type) {
-                return v.type;
-            }
 
-            ecs_parser_error(name, expr, ptr - expr, 
-                "unresolved variable '%s'", token);
-            return 0;
-        }
-        return var->value.type;
-    }
+/* Id sequence (type) utilities */
 
-    /* Boolean */
-    if (ptr[0] == 't' && !ecs_os_strncmp(ptr, "true", 4)) {
-        if (!isalpha(ptr[4]) && ptr[4] != '_') {
-            return ecs_id(ecs_bool_t);
-        }
-    }
-    if (ptr[0] == 'f' && !ecs_os_strncmp(ptr, "false", 5)) {
-        if (!isalpha(ptr[5]) && ptr[5] != '_') {
-            return ecs_id(ecs_bool_t);
-        }
-    }
+static
+uint64_t flecs_type_hash(const void *ptr) {
+    const ecs_type_t *type = ptr;
+    ecs_id_t *ids = type->array;
+    int32_t count = type->count;
+    return flecs_hash(ids, count * ECS_SIZEOF(ecs_id_t));
+}
 
-    /* Entity identifier */
-    if (isalpha(ptr[0])) {
-        if (!input_type) { /* Identifier could also be enum/bitmask constant */
-            return ecs_id(ecs_entity_t);
-        }
-    }
+static
+int flecs_type_compare(const void *ptr_1, const void *ptr_2) {
+    const ecs_type_t *type_1 = ptr_1;
+    const ecs_type_t *type_2 = ptr_2;
 
-    /* If no default type was provided we can't automatically deduce the type of
-     * composite/collection expressions. */
-    if (!input_type) {
-        if (ptr[0] == '{') {
-            ecs_parser_error(name, expr, ptr - expr,
-                "unknown type for composite literal");
-            return 0;
-        }
+    int32_t count_1 = type_1->count;
+    int32_t count_2 = type_2->count;
 
-        if (ptr[0] == '[') {
-            ecs_parser_error(name, expr, ptr - expr,
-                "unknown type for collection literal");
-            return 0;
-        }
+    if (count_1 != count_2) {
+        return (count_1 > count_2) - (count_1 < count_2);
+    }
 
-        ecs_parser_error(name, expr, ptr - expr, "invalid expression");
+    const ecs_id_t *ids_1 = type_1->array;
+    const ecs_id_t *ids_2 = type_2->array;
+    int result = 0;
+    
+    int32_t i;
+    for (i = 0; !result && (i < count_1); i ++) {
+        ecs_id_t id_1 = ids_1[i];
+        ecs_id_t id_2 = ids_2[i];
+        result = (id_1 > id_2) - (id_1 < id_2);
     }
 
-    return input_type;
+    return result;
 }
 
-/* Normalize types to their largest representation.
- * Rather than taking the original type of a value, use the largest 
- * representation of the type so we don't have to worry about overflowing the
- * original type in the operation. */
-static
-ecs_entity_t flecs_largest_type(
-    const EcsPrimitive *type)
+void flecs_table_hashmap_init(
+    ecs_world_t *world, 
+    ecs_hashmap_t *hm) 
 {
-    switch(type->kind) {
-    case EcsBool:   return ecs_id(ecs_bool_t);
-    case EcsChar:   return ecs_id(ecs_char_t);
-    case EcsByte:   return ecs_id(ecs_u8_t);
-    case EcsU8:     return ecs_id(ecs_u64_t);
-    case EcsU16:    return ecs_id(ecs_u64_t);
-    case EcsU32:    return ecs_id(ecs_u64_t);
-    case EcsU64:    return ecs_id(ecs_u64_t);
-    case EcsI8:     return ecs_id(ecs_i64_t);
-    case EcsI16:    return ecs_id(ecs_i64_t);
-    case EcsI32:    return ecs_id(ecs_i64_t);
-    case EcsI64:    return ecs_id(ecs_i64_t);
-    case EcsF32:    return ecs_id(ecs_f64_t);
-    case EcsF64:    return ecs_id(ecs_f64_t);
-    case EcsUPtr:   return ecs_id(ecs_u64_t);
-    case EcsIPtr:   return ecs_id(ecs_i64_t);
-    case EcsString: return ecs_id(ecs_string_t);
-    case EcsEntity: return ecs_id(ecs_entity_t);
-    case EcsId:     return ecs_id(ecs_id_t);
-    default: ecs_throw(ECS_INTERNAL_ERROR, NULL);
-    }
-error:
-    return 0;
+    flecs_hashmap_init(hm, ecs_type_t, ecs_table_t*, 
+        flecs_type_hash, flecs_type_compare, &world->allocator);
 }
 
-/** Test if a normalized type can promote to another type in an expression */
+/* Find location where to insert id into type */
 static
-bool flecs_is_type_number(
-    ecs_entity_t type)
+int flecs_type_find_insert(
+    const ecs_type_t *type,
+    int32_t offset,
+    ecs_id_t to_add)
 {
-    if      (type == ecs_id(ecs_bool_t)) return false;
-    else if (type == ecs_id(ecs_char_t)) return false;
-    else if (type == ecs_id(ecs_u8_t)) return false;
-    else if (type == ecs_id(ecs_u64_t)) return true;
-    else if (type == ecs_id(ecs_i64_t)) return true;
-    else if (type == ecs_id(ecs_f64_t)) return true;
-    else if (type == ecs_id(ecs_string_t)) return false;
-    else if (type == ecs_id(ecs_entity_t)) return false;
-    else return false;
-}
+    ecs_id_t *array = type->array;
+    int32_t i, count = type->count;
 
-static
-bool flecs_oper_valid_for_type(
-    ecs_entity_t type,
-    ecs_expr_oper_t op)
-{
-    switch(op) {
-    case EcsAdd:
-    case EcsSub:
-    case EcsMul:
-    case EcsDiv:
-        return flecs_is_type_number(type);
-    case EcsCondEq:
-    case EcsCondNeq:
-    case EcsCondAnd:
-    case EcsCondOr:
-    case EcsCondGt:
-    case EcsCondGtEq:
-    case EcsCondLt:
-    case EcsCondLtEq:
-        return flecs_is_type_number(type) ||
-            (type == ecs_id(ecs_bool_t)) ||
-            (type == ecs_id(ecs_char_t)) ||
-            (type == ecs_id(ecs_entity_t));
-    case EcsShiftLeft:
-    case EcsShiftRight:
-        return (type == ecs_id(ecs_u64_t));
-    case EcsExprOperUnknown:
-    case EcsLeftParen:
-    case EcsMin:
-        return false;
-    default: 
-        ecs_abort(ECS_INTERNAL_ERROR, NULL);
+    for (i = offset; i < count; i ++) {
+        ecs_id_t id = array[i];
+        if (id == to_add) {
+            return -1;
+        }
+        if (id > to_add) {
+            return i;
+        }
     }
+    return i;
 }
 
-/** Promote type to most expressive (f64 > i64 > u64) */
+/* Find location of id in type */
 static
-ecs_entity_t flecs_promote_type(
-    ecs_entity_t type,
-    ecs_entity_t promote_to)
-{
-    if (type == ecs_id(ecs_u64_t)) {
-        return promote_to;
-    }
-    if (promote_to == ecs_id(ecs_u64_t)) {
-        return type;
-    }
-    if (type == ecs_id(ecs_f64_t)) {
-        return type;
-    }
-    if (promote_to == ecs_id(ecs_f64_t)) {
-        return promote_to;
+int flecs_type_find(
+    const ecs_type_t *type,
+    ecs_id_t id)
+{
+    ecs_id_t *array = type->array;
+    int32_t i, count = type->count;
+
+    for (i = 0; i < count; i ++) {
+        ecs_id_t cur = array[i];
+        if (ecs_id_match(cur, id)) {
+            return i;
+        }
+        if (cur > id) {
+            return -1;
+        }
     }
-    return ecs_id(ecs_i64_t);
+
+    return -1;
 }
 
+/* Count number of matching ids */
 static
-int flecs_oper_precedence(
-    ecs_expr_oper_t left,
-    ecs_expr_oper_t right)
+int flecs_type_count_matches(
+    const ecs_type_t *type,
+    ecs_id_t wildcard,
+    int32_t offset)
 {
-    return (left > right) - (left < right);
+    ecs_id_t *array = type->array;
+    int32_t i = offset, count = type->count;
+
+    for (; i < count; i ++) {
+        ecs_id_t cur = array[i];
+        if (!ecs_id_match(cur, wildcard)) {
+            break;
+        }
+    }
+
+    return i - offset;
 }
 
+/* Create type from source type with id */
 static
-void flecs_value_cast(
+int flecs_type_new_with(
     ecs_world_t *world,
-    ecs_value_stack_t *stack,
-    ecs_value_t *value,
-    ecs_entity_t type)
+    ecs_type_t *dst,
+    const ecs_type_t *src,
+    ecs_id_t with)
 {
-    if (value->type == type) {
-        return;
+    ecs_id_t *src_array = src->array;
+    int32_t at = flecs_type_find_insert(src, 0, with);
+    if (at == -1) {
+        return -1;
     }
 
-    ecs_value_t result;
-    result.type = type;
-    result.ptr = flecs_expr_value_new(stack, type);
+    int32_t dst_count = src->count + 1;
+    ecs_id_t *dst_array = flecs_walloc_n(world, ecs_id_t, dst_count);
+    dst->count = dst_count;
+    dst->array = dst_array;
 
-    if (value->ptr) {
-        ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, result.ptr);
-        ecs_meta_set_value(&cur, value);
+    if (at) {
+        ecs_os_memcpy_n(dst_array, src_array, ecs_id_t, at);
     }
 
-    *value = result;
+    int32_t remain = src->count - at;
+    if (remain) {
+        ecs_os_memcpy_n(&dst_array[at + 1], &src_array[at], ecs_id_t, remain);
+    }
+
+    dst_array[at] = with;
+
+    return 0;
 }
 
+/* Create type from source type without ids matching wildcard */
 static
-bool flecs_expr_op_is_equality(
-    ecs_expr_oper_t op)
+int flecs_type_new_filtered(
+    ecs_world_t *world,
+    ecs_type_t *dst,
+    const ecs_type_t *src,
+    ecs_id_t wildcard,
+    int32_t at)
 {
-    switch(op) {
-    case EcsCondEq:
-    case EcsCondNeq:
-    case EcsCondGt:
-    case EcsCondGtEq:
-    case EcsCondLt:
-    case EcsCondLtEq:
-        return true;
-    case EcsCondAnd:
-    case EcsCondOr:
-    case EcsShiftLeft:
-    case EcsShiftRight:
-    case EcsAdd:
-    case EcsSub:
-    case EcsMul:
-    case EcsDiv:
-    case EcsExprOperUnknown:
-    case EcsLeftParen:
-    case EcsMin:
-        return false;
-    default:
-        ecs_throw(ECS_INTERNAL_ERROR, "invalid operator");
+    *dst = flecs_type_copy(world, src);
+    ecs_id_t *dst_array = dst->array;
+    ecs_id_t *src_array = src->array;
+    if (at) {
+        ecs_assert(dst_array != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_os_memcpy_n(dst_array, src_array, ecs_id_t, at);
     }
-error:
-    return false;
+
+    int32_t i = at + 1, w = at, count = src->count;
+    for (; i < count; i ++) {
+        ecs_id_t id = src_array[i];
+        if (!ecs_id_match(id, wildcard)) {
+            dst_array[w] = id;
+            w ++;
+        }
+    }
+
+    dst->count = w;
+    if (w != count) {
+        dst->array = flecs_wrealloc_n(world, ecs_id_t, w, count, dst->array);
+    }
+
+    return 0;
 }
 
+/* Create type from source type without id */
 static
-ecs_entity_t flecs_binary_expr_type(
+int flecs_type_new_without(
     ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_value_t *lvalue,
-    ecs_value_t *rvalue,
-    ecs_expr_oper_t op,
-    ecs_entity_t *operand_type_out)
+    ecs_type_t *dst,
+    const ecs_type_t *src,
+    ecs_id_t without)
 {
-    ecs_entity_t result_type = 0, operand_type = 0;
-
-    switch(op) {
-    case EcsDiv: 
-        /* Result type of a division is always a float */
-        *operand_type_out = ecs_id(ecs_f64_t);
-        return ecs_id(ecs_f64_t);
-    case EcsCondAnd:
-    case EcsCondOr:
-        /* Result type of a condition operator is always a bool */
-        *operand_type_out = ecs_id(ecs_bool_t);
-        return ecs_id(ecs_bool_t);
-    case EcsCondEq:
-    case EcsCondNeq:
-    case EcsCondGt:
-    case EcsCondGtEq:
-    case EcsCondLt:
-    case EcsCondLtEq:
-        /* Result type of equality operator is always bool, but operand types
-         * should not be casted to bool */
-        result_type = ecs_id(ecs_bool_t);
-        break;
-    case EcsShiftLeft:
-    case EcsShiftRight:
-    case EcsAdd:
-    case EcsSub:
-    case EcsMul:
-    case EcsExprOperUnknown:
-    case EcsLeftParen:
-    case EcsMin:
-        break;
-    default:
-        ecs_throw(ECS_INTERNAL_ERROR, "invalid operator");
+    ecs_id_t *src_array = src->array;
+    int32_t count = 1, at = flecs_type_find(src, without);
+    if (at == -1) {
+        return -1;
     }
 
-    /* Result type for arithmetic operators is determined by operands */
-    const EcsPrimitive *ltype_ptr = ecs_get(world, lvalue->type, EcsPrimitive);
-    const EcsPrimitive *rtype_ptr = ecs_get(world, rvalue->type, EcsPrimitive);
-    if (!ltype_ptr || !rtype_ptr) {
-        char *lname = ecs_get_fullpath(world, lvalue->type);
-        char *rname = ecs_get_fullpath(world, rvalue->type);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid non-primitive type in binary expression (%s, %s)",
-                lname, rname);
-        ecs_os_free(lname);
-        ecs_os_free(rname);
+    int32_t src_count = src->count;
+    if (src_count == 1) {
+        dst->array = NULL;
+        dst->count = 0;
         return 0;
     }
 
-    ecs_entity_t ltype = flecs_largest_type(ltype_ptr);
-    ecs_entity_t rtype = flecs_largest_type(rtype_ptr);
-    if (ltype == rtype) {
-        operand_type = ltype;
-        goto done;
-    }
-
-    if (flecs_expr_op_is_equality(op)) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "mismatching types in equality expression");
-        return 0;
+    if (ecs_id_is_wildcard(without)) {
+        if (ECS_IS_PAIR(without)) {
+            ecs_entity_t r = ECS_PAIR_FIRST(without);
+            ecs_entity_t o = ECS_PAIR_SECOND(without);
+            if (r == EcsWildcard && o != EcsWildcard) {
+                return flecs_type_new_filtered(world, dst, src, without, at);
+            }
+        }
+        count += flecs_type_count_matches(src, without, at + 1);
     }
 
-    if (!flecs_is_type_number(ltype) || !flecs_is_type_number(rtype)) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "incompatible types in binary expression");
+    int32_t dst_count = src_count - count;
+    dst->count = dst_count;
+    if (!dst_count) {
+        dst->array = NULL;
         return 0;
     }
 
-    operand_type = flecs_promote_type(ltype, rtype);
+    ecs_id_t *dst_array = flecs_walloc_n(world, ecs_id_t, dst_count);
+    dst->array = dst_array;
 
-done:
-    if (op == EcsSub && operand_type == ecs_id(ecs_u64_t)) {
-        /* Result of subtracting two unsigned ints can be negative */
-        operand_type = ecs_id(ecs_i64_t);
+    if (at) {
+        ecs_os_memcpy_n(dst_array, src_array, ecs_id_t, at);
     }
 
-    if (!result_type) {
-        result_type = operand_type;
+    int32_t remain = dst_count - at;
+    if (remain) {
+        ecs_os_memcpy_n(
+            &dst_array[at], &src_array[at + count], ecs_id_t, remain);
     }
 
-    *operand_type_out = operand_type;
-    return result_type;
-error:
     return 0;
 }
 
-/* Macro's to let the compiler do the operations & conversion work for us */
-
-#define ECS_VALUE_GET(value, T) (*(T*)value->ptr)
+/* Copy type */
+ecs_type_t flecs_type_copy(
+    ecs_world_t *world,
+    const ecs_type_t *src)
+{
+    int32_t src_count = src->count;
+    if (!src_count) {
+        return (ecs_type_t){ 0 };
+    }
 
-#define ECS_BINARY_OP_T(left, right, result, op, R, T)\
-    ECS_VALUE_GET(result, R) = ECS_VALUE_GET(left, T) op ECS_VALUE_GET(right, T)
+    ecs_id_t *ids = flecs_walloc_n(world, ecs_id_t, src_count);
+    ecs_os_memcpy_n(ids, src->array, ecs_id_t, src_count);
+    return (ecs_type_t) {
+        .array = ids,
+        .count = src_count
+    };
+}
 
-#define ECS_BINARY_OP(left, right, result, op)\
-    if (left->type == ecs_id(ecs_u64_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_u64_t, ecs_u64_t);\
-    } else if (left->type == ecs_id(ecs_i64_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_i64_t, ecs_i64_t);\
-    } else if (left->type == ecs_id(ecs_f64_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_f64_t, ecs_f64_t);\
-    } else {\
-        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
+/* Free type */
+void flecs_type_free(
+    ecs_world_t *world,
+    ecs_type_t *type)
+{
+    int32_t count = type->count;
+    if (count) {
+        flecs_wfree_n(world, ecs_id_t, type->count, type->array);
     }
+}
 
-#define ECS_BINARY_COND_EQ_OP(left, right, result, op)\
-    if (left->type == ecs_id(ecs_u64_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_u64_t);\
-    } else if (left->type == ecs_id(ecs_i64_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_i64_t);\
-    } else if (left->type == ecs_id(ecs_f64_t)) { \
-        ecs_parser_error(name, expr, ptr - expr, "unsupported operator for floating point");\
-        return -1;\
-    } else if (left->type == ecs_id(ecs_u8_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_u8_t);\
-    } else if (left->type == ecs_id(ecs_char_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_char_t);\
-    } else if (left->type == ecs_id(ecs_bool_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_bool_t);\
-    } else {\
-        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
+/* Add to type */
+static
+void flecs_type_add(
+    ecs_world_t *world,
+    ecs_type_t *type,
+    ecs_id_t add)
+{
+    ecs_type_t new_type;
+    int res = flecs_type_new_with(world, &new_type, type, add);
+    if (res != -1) {
+        flecs_type_free(world, type);
+        type->array = new_type.array;
+        type->count = new_type.count;
     }
+}
 
-#define ECS_BINARY_COND_OP(left, right, result, op)\
-    if (left->type == ecs_id(ecs_u64_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_u64_t);\
-    } else if (left->type == ecs_id(ecs_i64_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_i64_t);\
-    } else if (left->type == ecs_id(ecs_f64_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_f64_t);\
-    } else if (left->type == ecs_id(ecs_u8_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_u8_t);\
-    } else if (left->type == ecs_id(ecs_char_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_char_t);\
-    } else if (left->type == ecs_id(ecs_bool_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_bool_t);\
-    } else {\
-        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
-    }
+/* Graph edge utilities */
 
-#define ECS_BINARY_BOOL_OP(left, right, result, op)\
-    if (left->type == ecs_id(ecs_bool_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_bool_t);\
-    } else {\
-        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
-    }
+void flecs_table_diff_builder_init(
+    ecs_world_t *world,
+    ecs_table_diff_builder_t *builder)
+{
+    ecs_allocator_t *a = &world->allocator;
+    ecs_vec_init_t(a, &builder->added, ecs_id_t, 256);
+    ecs_vec_init_t(a, &builder->removed, ecs_id_t, 256);
+}
 
-#define ECS_BINARY_UINT_OP(left, right, result, op)\
-    if (left->type == ecs_id(ecs_u64_t)) { \
-        ECS_BINARY_OP_T(left, right, result, op, ecs_u64_t, ecs_u64_t);\
-    } else {\
-        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
-    }
+void flecs_table_diff_builder_fini(
+    ecs_world_t *world,
+    ecs_table_diff_builder_t *builder)
+{
+    ecs_allocator_t *a = &world->allocator;
+    ecs_vec_fini_t(a, &builder->added, ecs_id_t);
+    ecs_vec_fini_t(a, &builder->removed, ecs_id_t);
+}
+
+void flecs_table_diff_builder_clear(
+    ecs_table_diff_builder_t *builder)
+{
+    ecs_vec_clear(&builder->added);
+    ecs_vec_clear(&builder->removed);
+}
 
 static
-int flecs_binary_expr_do(
+void flecs_table_diff_build_type(
     ecs_world_t *world,
-    ecs_value_stack_t *stack,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_value_t *lvalue,
-    ecs_value_t *rvalue,
-    ecs_value_t *result,
-    ecs_expr_oper_t op)
+    ecs_vec_t *vec,
+    ecs_type_t *type,
+    int32_t offset)
 {
-    /* Find expression type */
-    ecs_entity_t operand_type, type = flecs_binary_expr_type(
-        world, name, expr, ptr, lvalue, rvalue, op, &operand_type);
-    if (!type) {
-        goto error;
+    int32_t count = vec->count - offset;
+    ecs_assert(count >= 0, ECS_INTERNAL_ERROR, NULL);
+    if (count) {
+        type->array = flecs_wdup_n(world, ecs_id_t, count, 
+            ECS_ELEM_T(vec->array, ecs_id_t, offset));
+        type->count = count;
+        ecs_vec_set_count_t(&world->allocator, vec, ecs_id_t, offset);
     }
+}
 
-    if (!flecs_oper_valid_for_type(type, op)) {
-        ecs_parser_error(name, expr, ptr - expr, "invalid operator for type");
-        goto error;
+void flecs_table_diff_build(
+    ecs_world_t *world,
+    ecs_table_diff_builder_t *builder,
+    ecs_table_diff_t *diff,
+    int32_t added_offset,
+    int32_t removed_offset)
+{
+    flecs_table_diff_build_type(world, &builder->added, &diff->added, 
+        added_offset);
+    flecs_table_diff_build_type(world, &builder->removed, &diff->removed, 
+        removed_offset);
+}
+
+void flecs_table_diff_build_noalloc(
+    ecs_table_diff_builder_t *builder,
+    ecs_table_diff_t *diff)
+{
+    diff->added = (ecs_type_t){
+        .array = builder->added.array, .count = builder->added.count };
+    diff->removed = (ecs_type_t){
+        .array = builder->removed.array, .count = builder->removed.count };
+}
+
+static
+void flecs_table_diff_build_add_type_to_vec(
+    ecs_world_t *world,
+    ecs_vec_t *vec,
+    ecs_type_t *add)
+{
+    if (!add || !add->count) {
+        return;
     }
 
-    flecs_value_cast(world, stack, lvalue, operand_type);
-    flecs_value_cast(world, stack, rvalue, operand_type);
+    int32_t offset = vec->count;
+    ecs_vec_grow_t(&world->allocator, vec, ecs_id_t, add->count);
+    ecs_os_memcpy_n(ecs_vec_get_t(vec, ecs_id_t, offset),
+        add->array, ecs_id_t, add->count);
+}
 
-    ecs_value_t *storage = result;
-    ecs_value_t tmp_storage = {0};
-    if (result->type != type) {
-        storage = &tmp_storage;
-        storage->type = type;
-        storage->ptr = flecs_expr_value_new(stack, type);
+void flecs_table_diff_build_append_table(
+    ecs_world_t *world,
+    ecs_table_diff_builder_t *dst,
+    ecs_table_diff_t *src)
+{
+    flecs_table_diff_build_add_type_to_vec(world, &dst->added, &src->added);
+    flecs_table_diff_build_add_type_to_vec(world, &dst->removed, &src->removed);
+}
+
+static
+void flecs_table_diff_free(
+    ecs_world_t *world,
+    ecs_table_diff_t *diff) 
+{
+    flecs_wfree_n(world, ecs_id_t, diff->added.count, diff->added.array);
+    flecs_wfree_n(world, ecs_id_t, diff->removed.count, diff->removed.array);
+    flecs_bfree(&world->allocators.table_diff, diff);
+}
+
+static
+ecs_graph_edge_t* flecs_table_ensure_hi_edge(
+    ecs_world_t *world,
+    ecs_graph_edges_t *edges,
+    ecs_id_t id)
+{
+    if (!edges->hi) {
+        edges->hi = flecs_alloc_t(&world->allocator, ecs_map_t);
+        ecs_map_init_w_params(edges->hi, &world->allocators.ptr);
     }
 
-    switch(op) {
-    case EcsAdd:
-        ECS_BINARY_OP(lvalue, rvalue, storage, +);
-        break;
-    case EcsSub:
-        ECS_BINARY_OP(lvalue, rvalue, storage, -);
-        break;
-    case EcsMul:
-        ECS_BINARY_OP(lvalue, rvalue, storage, *);
-        break;
-    case EcsDiv:
-        ECS_BINARY_OP(lvalue, rvalue, storage, /);
-        break;
-    case EcsCondEq:
-        ECS_BINARY_COND_EQ_OP(lvalue, rvalue, storage, ==);
-        break;
-    case EcsCondNeq:
-        ECS_BINARY_COND_EQ_OP(lvalue, rvalue, storage, !=);
-        break;
-    case EcsCondGt:
-        ECS_BINARY_COND_OP(lvalue, rvalue, storage, >);
-        break;
-    case EcsCondGtEq:
-        ECS_BINARY_COND_OP(lvalue, rvalue, storage, >=);
-        break;
-    case EcsCondLt:
-        ECS_BINARY_COND_OP(lvalue, rvalue, storage, <);
-        break;
-    case EcsCondLtEq:
-        ECS_BINARY_COND_OP(lvalue, rvalue, storage, <=);
-        break;
-    case EcsCondAnd:
-        ECS_BINARY_BOOL_OP(lvalue, rvalue, storage, &&);
-        break;
-    case EcsCondOr:
-        ECS_BINARY_BOOL_OP(lvalue, rvalue, storage, ||);
-        break;
-    case EcsShiftLeft:
-        ECS_BINARY_UINT_OP(lvalue, rvalue, storage, <<);
-        break;
-    case EcsShiftRight:
-        ECS_BINARY_UINT_OP(lvalue, rvalue, storage, >>);
-        break;
-    case EcsExprOperUnknown:
-    case EcsLeftParen:
-    case EcsMin:
-        ecs_parser_error(name, expr, ptr - expr, "unsupported operator");
-        goto error;
-    default:
-        ecs_throw(ECS_INTERNAL_ERROR, NULL);
+    ecs_graph_edge_t **r = ecs_map_ensure_ref(edges->hi, ecs_graph_edge_t, id);
+    ecs_graph_edge_t *edge = r[0];
+    if (edge) {
+        return edge;
     }
 
-    if (storage->ptr != result->ptr) {
-        if (!result->ptr) {
-            *result = *storage;
-        } else {
-            ecs_meta_cursor_t cur = ecs_meta_cursor(world, 
-                result->type, result->ptr);
-            ecs_meta_set_value(&cur, storage);
-        }
+    if (id < FLECS_HI_COMPONENT_ID) {
+        edge = &edges->lo[id];
+    } else {
+        edge = flecs_bcalloc(&world->allocators.graph_edge);
     }
 
-    return 0;
-error:
-    return -1;
+    r[0] = edge;
+    return edge;
 }
 
 static
-const char* flecs_binary_expr_parse(
+ecs_graph_edge_t* flecs_table_ensure_edge(
     ecs_world_t *world,
-    ecs_value_stack_t *stack,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_value_t *lvalue,
-    ecs_value_t *result,
-    ecs_expr_oper_t left_op,
-    const ecs_parse_expr_desc_t *desc)
+    ecs_graph_edges_t *edges,
+    ecs_id_t id)
 {
-    ecs_entity_t result_type = result->type;
-    do {
-        ecs_expr_oper_t op;
-        ptr = flecs_str_to_expr_oper(ptr, &op);
-        if (!ptr) {
-            ecs_parser_error(name, expr, ptr - expr, "invalid operator");
-            return NULL;
+    ecs_graph_edge_t *edge;
+    
+    if (id < FLECS_HI_COMPONENT_ID) {
+        if (!edges->lo) {
+            edges->lo = flecs_bcalloc(&world->allocators.graph_edge_lo);
         }
+        edge = &edges->lo[id];
+    } else {
+        edge = flecs_table_ensure_hi_edge(world, edges, id);
+    }
 
-        ptr = ecs_parse_ws_eol(ptr);
-
-        ecs_value_t rvalue = {0};
-        const char *rptr = flecs_parse_expr(world, stack, ptr, &rvalue, op, desc);
-        if (!rptr) {
-            return NULL;
-        }
+    return edge;
+}
 
-        if (flecs_binary_expr_do(world, stack, name, expr, ptr, 
-            lvalue, &rvalue, result, op)) 
-        {
-            return NULL;
-        }
+static
+void flecs_table_disconnect_edge(
+    ecs_world_t *world,
+    ecs_id_t id,
+    ecs_graph_edge_t *edge)
+{
+    ecs_assert(edge != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(edge->id == id, ECS_INTERNAL_ERROR, NULL);
+    (void)id;
 
-        ptr = rptr;
+    /* Remove backref from destination table */
+    ecs_graph_edge_hdr_t *next = edge->hdr.next;
+    ecs_graph_edge_hdr_t *prev = edge->hdr.prev;
 
-        ecs_expr_oper_t right_op;
-        flecs_str_to_expr_oper(rptr, &right_op);
-        if (right_op > left_op) {
-            if (result_type) {
-                /* If result was initialized, preserve its value */
-                lvalue->type = result->type;
-                lvalue->ptr = flecs_expr_value_new(stack, lvalue->type);
-                ecs_value_copy(world, lvalue->type, lvalue->ptr, result->ptr);
-                continue;
-            } else {
-                /* Otherwise move result to lvalue */
-                *lvalue = *result;
-                ecs_os_zeromem(result);
-                continue;
-            }
-        }
+    if (next) {
+        next->prev = prev;
+    }
+    if (prev) {
+        prev->next = next;
+    }
 
-        break;
-    } while (true);
+    /* Remove data associated with edge */
+    ecs_table_diff_t *diff = edge->diff;
+    if (diff) {
+        flecs_table_diff_free(world, diff);
+    }
 
-    return ptr;
+    /* If edge id is low, clear it from fast lookup array */
+    if (id < FLECS_HI_COMPONENT_ID) {
+        ecs_os_memset_t(edge, 0, ecs_graph_edge_t);
+    } else {
+        flecs_bfree(&world->allocators.graph_edge, edge);
+    }
 }
 
 static
-const char* flecs_funccall_parse(
+void flecs_table_remove_edge(
     ecs_world_t *world,
-    ecs_value_stack_t *stack,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token,
-    ecs_meta_cursor_t *cur,
-    ecs_value_t *value,
-    bool isvar,
-    const ecs_parse_expr_desc_t *desc)
+    ecs_graph_edges_t *edges,
+    ecs_id_t id,
+    ecs_graph_edge_t *edge)
 {
-    char *sep = strrchr(token, '.');
-    if (!sep) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing object for function call '%s'", token);
-        return NULL;
+    ecs_assert(edges != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(edges->hi != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_table_disconnect_edge(world, id, edge);
+    ecs_map_remove(edges->hi, id);
+}
+
+static
+void flecs_table_init_edges(
+    ecs_graph_edges_t *edges)
+{
+    edges->lo = NULL;
+    edges->hi = NULL;
+}
+
+static
+void flecs_table_init_node(
+    ecs_graph_node_t *node)
+{
+    flecs_table_init_edges(&node->add);
+    flecs_table_init_edges(&node->remove);
+}
+
+bool flecs_table_records_update_empty(
+    ecs_table_t *table)
+{
+    bool result = false;
+    bool is_empty = ecs_table_count(table) == 0;
+
+    int32_t i, count = table->_->record_count;
+    for (i = 0; i < count; i ++) {
+        ecs_table_record_t *tr = &table->_->records[i];
+        ecs_table_cache_t *cache = tr->hdr.cache;
+        result |= ecs_table_cache_set_empty(cache, table, is_empty);
     }
 
-    sep[0] = '\0';
-    const char *function = sep + 1;
+    return result;
+}
 
-    if (!isvar) {
-        if (ecs_meta_set_string(cur, token) != 0) {
-            goto error;
+static
+void flecs_init_table(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_table_t *prev)
+{
+    table->flags = 0;
+    table->dirty_state = NULL;
+    table->_->lock = 0;
+    table->_->generation = 0;
+
+    flecs_table_init_node(&table->node);
+
+    flecs_table_init(world, table, prev);
+}
+
+static
+ecs_table_t *flecs_table_new(
+    ecs_world_t *world,
+    ecs_type_t *type,
+    flecs_hashmap_result_t table_elem,
+    ecs_table_t *prev)
+{
+    ecs_table_t *result = flecs_sparse_add_t(&world->store.tables, ecs_table_t);
+    ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL);
+    result->_ = flecs_calloc_t(&world->allocator, ecs_table__t);
+    ecs_assert(result->_ != NULL, ECS_INTERNAL_ERROR, NULL);
+
+#ifdef FLECS_SANITIZE
+    int32_t i, j, count = type->count;
+    for (i = 0; i < count - 1; i ++) {
+        if (type->array[i] >= type->array[i + 1]) {
+            for (j = 0; j < count; j ++) {
+                char *str = ecs_id_str(world, type->array[j]);
+                if (i == j) {
+                    ecs_err(" > %d: %s", j, str);
+                } else {
+                    ecs_err("   %d: %s", j, str);
+                }
+                ecs_os_free(str);
+            }
+            ecs_abort(ECS_CONSTRAINT_VIOLATED, "table type is not ordered");
         }
-    } else {
-        const ecs_expr_var_t *var = ecs_vars_lookup(desc->vars, token);
-        ecs_meta_set_value(cur, &var->value);
     }
+#endif
 
-    do {
-        if (!function[0]) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "missing function name for function call '%s'", token);
-            return NULL;
-        }
+    result->id = flecs_sparse_last_id(&world->store.tables);
+    result->type = *type;
 
-        if (flecs_meta_call(world, stack, name, expr, ptr, cur, 
-            function) != 0) 
-        {
-            goto error;
-        }
+    if (ecs_should_log_2()) {
+        char *expr = ecs_type_str(world, &result->type);
+        ecs_dbg_2(
+            "#[green]table#[normal] [%s] #[green]created#[reset] with id %d", 
+            expr, result->id);
+        ecs_os_free(expr);
+    }
 
-        ecs_entity_t type = ecs_meta_get_type(cur);
-        value->ptr = ecs_meta_get_ptr(cur);
-        value->type = type;
+    ecs_log_push_2();
 
-        ptr += 2;
-        if (ptr[0] != '.') {
-            break;
-        }
+    /* Store table in table hashmap */
+    *(ecs_table_t**)table_elem.value = result;
 
-        ptr ++;
-        char *paren = strchr(ptr, '(');
-        if (!paren) {
-            break;
-        }
+    /* Set keyvalue to one that has the same lifecycle as the table */
+    *(ecs_type_t*)table_elem.key = result->type;
+    result->_->hash = table_elem.hash;
 
-        ecs_size_t len = flecs_ito(int32_t, paren - ptr);
-        if (len >= ECS_MAX_TOKEN_SIZE) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "token exceeds maximum token size");
-            goto error;
-        }
+    flecs_init_table(world, result, prev);
 
-        ecs_os_strncpy(token, ptr, len);
-        token[len] = '\0';
-        function = token;
+    /* Update counters */
+    world->info.table_count ++;
+    world->info.empty_table_count ++;
+    world->info.table_create_total ++;
 
-        ptr = paren;
-    } while (true);
+    ecs_log_pop_2();
 
-    return ptr;
-error:
-    return NULL;
+    return result;
 }
 
 static
-const char* flecs_parse_expr(
+ecs_table_t* flecs_table_ensure(
     ecs_world_t *world,
-    ecs_value_stack_t *stack,
-    const char *ptr,
-    ecs_value_t *value,
-    ecs_expr_oper_t left_op,
-    const ecs_parse_expr_desc_t *desc)
-{
-    ecs_assert(value != NULL, ECS_INTERNAL_ERROR, NULL);
-    char token[ECS_MAX_TOKEN_SIZE];
-    int depth = 0;
-    ecs_value_t result = {0};
-    ecs_meta_cursor_t cur = {0};
-    const char *name = desc ? desc->name : NULL;
-    const char *expr = desc ? desc->expr : NULL;
-    token[0] = '\0';
-    expr = expr ? expr : ptr;
-
-    ptr = ecs_parse_ws_eol(ptr);
+    ecs_type_t *type,
+    bool own_type,
+    ecs_table_t *prev)
+{    
+    flecs_poly_assert(world, ecs_world_t);   
 
-    /* Check for postfix operators */
-    ecs_expr_oper_t unary_op = EcsExprOperUnknown;
-    if (ptr[0] == '-' && !isdigit(ptr[1])) {
-        unary_op = EcsMin;
-        ptr = ecs_parse_ws_eol(ptr + 1);
+    int32_t id_count = type->count;
+    if (!id_count) {
+        return &world->store.root;
     }
 
-    /* Initialize storage and cursor. If expression starts with a '(' storage
-     * will be initialized by a nested expression */
-    if (ptr[0] != '(') {
-        ecs_entity_t type = flecs_parse_discover_type(
-            world, name, expr, ptr, value->type, desc);
-        if (!type) {
-            return NULL;
-        }
-
-        result.type = type;
-        if (type != value->type) {
-            result.ptr = flecs_expr_value_new(stack, type);
-        } else {
-            result.ptr = value->ptr;
+    ecs_table_t *table;
+    flecs_hashmap_result_t elem = flecs_hashmap_ensure(
+        &world->store.table_map, type, ecs_table_t*);
+    if ((table = *(ecs_table_t**)elem.value)) {
+        if (own_type) {
+            flecs_type_free(world, type);
         }
+        return table;
+    }
 
-        cur = ecs_meta_cursor(world, result.type, result.ptr);
-        if (!cur.valid) {
-            return NULL;
-        }
+    /* If we get here, table needs to be created which is only allowed when the
+     * application is not currently in progress */
+    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INTERNAL_ERROR, NULL);
 
-        cur.lookup_action = desc ? desc->lookup_action : NULL;
-        cur.lookup_ctx = desc ? desc->lookup_ctx : NULL;
+    /* If we get here, the table has not been found, so create it. */
+    if (own_type) {
+        return flecs_table_new(world, type, elem, prev);
     }
 
-    /* Loop that parses all values in a value scope */
-    while ((ptr = ecs_parse_expr_token(name, expr, ptr, token))) {
-        /* Used to track of the result of the parsed token can be used as the
-         * lvalue for a binary expression */
-        bool is_lvalue = false;
-        bool newline = false;
-
-        if (!token[0]) {
-            /* Comment */
-            continue;
-        }
+    ecs_type_t copy = flecs_type_copy(world, type);
+    return flecs_table_new(world, &copy, elem, prev);
+}
 
-        if (!ecs_os_strcmp(token, "(")) {
-            ecs_value_t temp_result, *out;
-            if (!depth) {
-                out = &result;
-            } else {
-                temp_result.type = ecs_meta_get_type(&cur);
-                temp_result.ptr = ecs_meta_get_ptr(&cur);
-                out = &temp_result;
-            }
+static
+void flecs_diff_insert_added(
+    ecs_world_t *world,
+    ecs_table_diff_builder_t *diff,
+    ecs_id_t id)
+{
+    ecs_vec_append_t(&world->allocator, &diff->added, ecs_id_t)[0] = id;
+}
 
-            /* Parenthesis, parse nested expression */
-            ptr = flecs_parse_expr(world, stack, ptr, out, EcsLeftParen, desc);
-            if (ptr[0] != ')') {
-                ecs_parser_error(name, expr, ptr - expr, 
-                    "missing closing parenthesis");
-                return NULL;
-            }
-            ptr = ecs_parse_ws(ptr + 1);
-            is_lvalue = true;
+static
+void flecs_diff_insert_removed(
+    ecs_world_t *world,
+    ecs_table_diff_builder_t *diff,
+    ecs_id_t id)
+{
+    ecs_allocator_t *a = &world->allocator;
+    ecs_vec_append_t(a, &diff->removed, ecs_id_t)[0] = id;
+}
 
-        } else if (!ecs_os_strcmp(token, "{")) {
-            /* Parse nested value scope */
-            ecs_entity_t scope_type = ecs_meta_get_type(&cur);
+static
+void flecs_compute_table_diff(
+    ecs_world_t *world,
+    ecs_table_t *node,
+    ecs_table_t *next,
+    ecs_graph_edge_t *edge,
+    ecs_id_t id)
+{
+    ecs_type_t node_type = node->type;
+    ecs_type_t next_type = next->type;
 
-            depth ++; /* Keep track of depth so we know when parsing is done */
-            if (ecs_meta_push(&cur) != 0) {
-                goto error;
-            }
+    ecs_id_t *ids_node = node_type.array;
+    ecs_id_t *ids_next = next_type.array;
+    int32_t i_node = 0, node_count = node_type.count;
+    int32_t i_next = 0, next_count = next_type.count;
+    int32_t added_count = 0;
+    int32_t removed_count = 0;
+    bool trivial_edge = !ECS_HAS_RELATION(id, EcsIsA);
 
-            if (ecs_meta_is_collection(&cur)) {
-                char *path = ecs_get_fullpath(world, scope_type);
-                ecs_parser_error(name, expr, ptr - expr, 
-                    "expected '[' for collection type '%s'", path);
-                ecs_os_free(path);
-                return NULL;
-            }
-        }
+    /* First do a scan to see how big the diff is, so we don't have to realloc
+     * or alloc more memory than required. */
+    for (; i_node < node_count && i_next < next_count; ) {
+        ecs_id_t id_node = ids_node[i_node];
+        ecs_id_t id_next = ids_next[i_next];
 
-        else if (!ecs_os_strcmp(token, "}")) {
-            depth --;
+        bool added = id_next < id_node;
+        bool removed = id_node < id_next;
 
-            if (ecs_meta_is_collection(&cur)) {
-                ecs_parser_error(name, expr, ptr - expr, "expected ']'");
-                return NULL;
-            }
+        trivial_edge &= !added || id_next == id;
+        trivial_edge &= !removed || id_node == id;
 
-            if (ecs_meta_pop(&cur) != 0) {
-                goto error;
-            }
-        }
+        added_count += added;
+        removed_count += removed;
 
-        else if (!ecs_os_strcmp(token, "[")) {
-            /* Open collection value scope */
-            depth ++;
-            if (ecs_meta_push(&cur) != 0) {
-                goto error;
-            }
+        i_node += id_node <= id_next;
+        i_next += id_next <= id_node;
+    }
 
-            if (!ecs_meta_is_collection(&cur)) {
-                ecs_parser_error(name, expr, ptr - expr, "unexpected '['");
-                return NULL;
-            }
-        }
+    added_count += next_count - i_next;
+    removed_count += node_count - i_node;
 
-        else if (!ecs_os_strcmp(token, "]")) {
-            depth --;
+    trivial_edge &= (added_count + removed_count) <= 1 && 
+        !ecs_id_is_wildcard(id);
 
-            if (!ecs_meta_is_collection(&cur)) {
-                ecs_parser_error(name, expr, ptr - expr, "expected '}'");
-                return NULL;
-            }
+    if (trivial_edge) {
+        /* If edge is trivial there's no need to create a diff element for it */
+        return;
+    }
 
-            if (ecs_meta_pop(&cur) != 0) {
-                goto error;
-            }
-        }
+    ecs_table_diff_builder_t *builder = &world->allocators.diff_builder;
+    int32_t added_offset = builder->added.count;
+    int32_t removed_offset = builder->removed.count;
 
-        else if (!ecs_os_strcmp(token, "-")) {
-            if (unary_op != EcsExprOperUnknown) {
-                ecs_parser_error(name, expr, ptr - expr, 
-                    "unexpected unary operator");
-                return NULL;
-            }
-            unary_op = EcsMin;
-        }
+    for (i_node = 0, i_next = 0; i_node < node_count && i_next < next_count; ) {
+        ecs_id_t id_node = ids_node[i_node];
+        ecs_id_t id_next = ids_next[i_next];
 
-        else if (!ecs_os_strcmp(token, ",")) {
-            /* Move to next field */
-            if (ecs_meta_next(&cur) != 0) {
-                goto error;
-            }
+        if (id_next < id_node) {
+            flecs_diff_insert_added(world, builder, id_next);
+        } else if (id_node < id_next) {
+            flecs_diff_insert_removed(world, builder, id_node);
         }
 
-        else if (!ecs_os_strcmp(token, "null")) {
-            if (ecs_meta_set_null(&cur) != 0) {
-                goto error;
-            }
-
-            is_lvalue = true;
-        }
+        i_node += id_node <= id_next;
+        i_next += id_next <= id_node;
+    }
 
-        else if (token[0] == '\"') {
-            /* Regular string */
-            if (ecs_meta_set_string_literal(&cur, token) != 0) {
-                goto error;
-            }
+    for (; i_next < next_count; i_next ++) {
+        flecs_diff_insert_added(world, builder, ids_next[i_next]);
+    }
+    for (; i_node < node_count; i_node ++) {
+        flecs_diff_insert_removed(world, builder, ids_node[i_node]);
+    }
 
-            is_lvalue = true;
-        }
+    ecs_table_diff_t *diff = flecs_bcalloc(&world->allocators.table_diff);
+    edge->diff = diff;
+    flecs_table_diff_build(world, builder, diff, added_offset, removed_offset);
 
-        else if (!ecs_os_strcmp(token, "`")) {
-            /* Multiline string */
-            if (!(ptr = flecs_parse_multiline_string(&cur, name, expr, ptr))) {
-                goto error;
-            }
+    ecs_assert(diff->added.count == added_count, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(diff->removed.count == removed_count, ECS_INTERNAL_ERROR, NULL);
+}
 
-            is_lvalue = true;
+static
+void flecs_add_overrides_for_base(
+    ecs_world_t *world,
+    ecs_type_t *dst_type,
+    ecs_id_t pair)
+{
+    ecs_entity_t base = ecs_pair_second(world, pair);
+    ecs_assert(base != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_table_t *base_table = ecs_get_table(world, base);
+    if (!base_table) {
+        return;
+    }
 
-        } else if (token[0] == '$') {
-            /* Variable */
-            if (!desc || !desc->vars) {
-                ecs_parser_error(name, expr, ptr - expr, 
-                    "unresolved variable '%s' (no variable scope)", token);
-                return NULL;
-            }
+    ecs_id_t *ids = base_table->type.array;
 
-            if (!token[1]) {
-                /* Empty name means default to assigned member */
-                const char *member = ecs_meta_get_member(&cur);
-                if (!member) {
-                    ecs_parser_error(name, expr, ptr - expr, 
-                        "invalid default variable outside member assignment");
-                    return NULL;
+    ecs_flags32_t flags = base_table->flags;
+    if (flags & EcsTableHasOverrides) {
+        int32_t i, count = base_table->type.count;
+        for (i = 0; i < count; i ++) {
+            ecs_id_t id = ids[i];
+            ecs_id_t to_add = 0;
+            if (ECS_HAS_ID_FLAG(id, OVERRIDE)) {
+                to_add = id & ~ECS_OVERRIDE;
+            } else {
+                ecs_table_record_t *tr = &base_table->_->records[i];
+                ecs_id_record_t *idr = (ecs_id_record_t*)tr->hdr.cache;
+                if (idr->flags & EcsIdAlwaysOverride) {
+                    to_add = id;
                 }
-                ecs_os_strcpy(&token[1], member);
             }
-
-            const ecs_expr_var_t *var = ecs_vars_lookup(desc->vars, &token[1]);
-            if (!var) {
-                if (ptr[0] == '(') {
-                    /* Function */
-                    ptr = flecs_funccall_parse(world, stack, name, expr, ptr, 
-                        &token[1], &cur, &result, true, desc);
-                    if (!ptr) {
-                        goto error;
+            if (to_add) {
+                ecs_id_t wc = ecs_pair(ECS_PAIR_FIRST(to_add), EcsWildcard);
+                bool exclusive = false;
+                if (ECS_IS_PAIR(to_add)) {
+                    ecs_id_record_t *idr = flecs_id_record_get(world, wc);
+                    if (idr) {
+                        exclusive = (idr->flags & EcsIdExclusive) != 0;
                     }
+                }
+                if (!exclusive) {
+                    flecs_type_add(world, dst_type, to_add);
                 } else {
-                    ecs_value_t v = flecs_dotresolve_var(world, desc->vars, &token[1]);
-                    if (!v.ptr) {
-                        ecs_parser_error(name, expr, ptr - expr, 
-                            "unresolved variable '%s'", token);
-                        return NULL;
+                    int32_t column = flecs_type_find(dst_type, wc);
+                    if (column == -1) {
+                        flecs_type_add(world, dst_type, to_add);
                     } else {
-                        ecs_meta_set_value(&cur, &v);
+                        dst_type->array[column] = to_add;
                     }
                 }
-            } else {
-                ecs_meta_set_value(&cur, &var->value);
             }
-            is_lvalue = true;
+        }
+    }
 
-        } else {
-            const char *tptr = ecs_parse_ws(ptr);
-            for (; ptr != tptr; ptr ++) {
-                if (ptr[0] == '\n') {
-                    newline = true;
-                }
-            }
+    if (flags & EcsTableHasIsA) {
+        ecs_table_record_t *tr = flecs_id_record_get_table(
+            world->idr_isa_wildcard, base_table);
+        ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
+        int32_t i = tr->index, end = i + tr->count;
+        for (; i != end; i ++) {
+            flecs_add_overrides_for_base(world, dst_type, ids[i]);
+        }
+    }
+}
 
-            if (ptr[0] == ':') {
-                /* Member assignment */
-                ptr ++;
-                if (ecs_meta_dotmember(&cur, token) != 0) {
-                    goto error;
-                }
-            } else if (ptr[0] == '(') {
-                /* Function */
-                ptr = flecs_funccall_parse(world, stack, name, expr, ptr, 
-                    token, &cur, &result, false, desc);
-                if (!ptr) {
-                    goto error;
-                }
-            } else {
-                if (ecs_meta_set_string(&cur, token) != 0) {
-                    goto error;
-                }
+static
+void flecs_add_with_property(
+    ecs_world_t *world,
+    ecs_id_record_t *idr_with_wildcard,
+    ecs_type_t *dst_type,
+    ecs_entity_t r,
+    ecs_entity_t o)
+{
+    r = ecs_get_alive(world, r);
+
+    /* Check if component/relationship has With pairs, which contain ids
+     * that need to be added to the table. */
+    ecs_table_t *table = ecs_get_table(world, r);
+    if (!table) {
+        return;
+    }
+    
+    ecs_table_record_t *tr = flecs_id_record_get_table(
+        idr_with_wildcard, table);
+    if (tr) {
+        int32_t i = tr->index, end = i + tr->count;
+        ecs_id_t *ids = table->type.array;
+
+        for (; i < end; i ++) {
+            ecs_id_t id = ids[i];
+            ecs_assert(ECS_PAIR_FIRST(id) == EcsWith, ECS_INTERNAL_ERROR, NULL);
+            ecs_id_t ra = ECS_PAIR_SECOND(id);
+            ecs_id_t a = ra;
+            if (o) {
+                a = ecs_pair(ra, o);
             }
 
-            is_lvalue = true;
+            flecs_type_add(world, dst_type, a);
+            flecs_add_with_property(world, idr_with_wildcard, dst_type, ra, o);
         }
+    }
 
-        /* If lvalue was parsed, apply operators. Expressions cannot start
-         * directly after a newline character. */
-        if (is_lvalue && !newline) {
-            if (unary_op != EcsExprOperUnknown) {
-                if (unary_op == EcsMin) {
-                    int64_t v = -1;
-                    ecs_value_t lvalue = {.type = ecs_id(ecs_i64_t), .ptr = &v};
-                    ecs_value_t *out, rvalue, temp_out = {0};
-
-                    if (!depth) {
-                        rvalue = result;
-                        ecs_os_zeromem(&result);
-                        out = &result;
-                    } else {
-                        ecs_entity_t cur_type = ecs_meta_get_type(&cur);
-                        void *cur_ptr = ecs_meta_get_ptr(&cur);
-                        rvalue.type = cur_type;
-                        rvalue.ptr = cur_ptr;
-                        temp_out.type = cur_type;
-                        temp_out.ptr = cur_ptr;
-                        out = &temp_out;
-                    }
+}
 
-                    flecs_binary_expr_do(world, stack, name, expr, ptr, &lvalue,
-                        &rvalue, out, EcsMul);
-                }
-                unary_op = 0;
-            }
+static
+ecs_table_t* flecs_find_table_with(
+    ecs_world_t *world,
+    ecs_table_t *node,
+    ecs_id_t with)
+{    
+    ecs_make_alive_id(world, with);
 
-            ecs_expr_oper_t right_op;
-            flecs_str_to_expr_oper(ptr, &right_op);
-            if (right_op) {
-                /* This is a binary expression, test precedence to determine if
-                 * it should be evaluated here */
-                if (flecs_oper_precedence(left_op, right_op) < 0) {
-                    ecs_value_t lvalue;
-                    ecs_value_t *op_result = &result;
-                    ecs_value_t temp_storage;
-                    if (!depth) {
-                        /* Root level value, move result to lvalue storage */
-                        lvalue = result;
-                        ecs_os_zeromem(&result);
-                    } else {
-                        /* Not a root level value. Move the parsed lvalue to a
-                         * temporary storage, and initialize the result value
-                         * for the binary operation with the current cursor */
-                        ecs_entity_t cur_type = ecs_meta_get_type(&cur);
-                        void *cur_ptr = ecs_meta_get_ptr(&cur);
-                        lvalue.type = cur_type;
-                        lvalue.ptr = flecs_expr_value_new(stack, cur_type);
-                        ecs_value_copy(world, cur_type, lvalue.ptr, cur_ptr);
-                        temp_storage.type = cur_type;
-                        temp_storage.ptr = cur_ptr;
-                        op_result = &temp_storage;
-                    }
+    ecs_id_record_t *idr = NULL;
+    ecs_entity_t r = 0, o = 0;
 
-                    /* Do the binary expression */
-                    ptr = flecs_binary_expr_parse(world, stack, name, expr, ptr, 
-                        &lvalue, op_result, left_op, desc);
-                    if (!ptr) {
-                        return NULL;
-                    }
-                }
+    if (ECS_IS_PAIR(with)) {
+        r = ECS_PAIR_FIRST(with);
+        o = ECS_PAIR_SECOND(with);
+        idr = flecs_id_record_ensure(world, ecs_pair(r, EcsWildcard));
+        if (idr->flags & EcsIdExclusive) {
+            /* Relationship is exclusive, check if table already has it */
+            ecs_table_record_t *tr = flecs_id_record_get_table(idr, node);
+            if (tr) {
+                /* Table already has an instance of the relationship, create
+                 * a new id sequence with the existing id replaced */
+                ecs_type_t dst_type = flecs_type_copy(world, &node->type);
+                ecs_assert(dst_type.array != NULL, ECS_INTERNAL_ERROR, NULL);
+                dst_type.array[tr->index] = with;
+                return flecs_table_ensure(world, &dst_type, true, node);
             }
         }
+    } else {
+        idr = flecs_id_record_ensure(world, with);
+        r = with;
+    }
 
-        if (!depth) {
-            /* Reached the end of the root scope */
-            break;
-        }
+    /* Create sequence with new id */
+    ecs_type_t dst_type;
+    int res = flecs_type_new_with(world, &dst_type, &node->type, with);
+    if (res == -1) {
+        return node; /* Current table already has id */
+    }
 
-        ptr = ecs_parse_ws_eol(ptr);
+    if (r == EcsIsA) {
+        /* If adding a prefab, check if prefab has overrides */
+        flecs_add_overrides_for_base(world, &dst_type, with);
+    } else if (r == EcsChildOf) {
+        o = ecs_get_alive(world, o);
+        if (ecs_has_id(world, o, EcsPrefab)) {
+            flecs_type_add(world, &dst_type, EcsPrefab);
+        }
     }
 
-    if (!value->ptr) {
-        value->type = result.type;
-        value->ptr = flecs_expr_value_new(stack, result.type);
+    if (idr->flags & EcsIdWith) {
+        ecs_id_record_t *idr_with_wildcard = flecs_id_record_get(world,
+            ecs_pair(EcsWith, EcsWildcard));
+        /* If id has With property, add targets to type */
+        flecs_add_with_property(world, idr_with_wildcard, &dst_type, r, o);
     }
 
-    if (value->ptr != result.ptr) {
-        cur = ecs_meta_cursor(world, value->type, value->ptr);
-        ecs_meta_set_value(&cur, &result);
+    return flecs_table_ensure(world, &dst_type, true, node);
+}
+
+static
+ecs_table_t* flecs_find_table_without(
+    ecs_world_t *world,
+    ecs_table_t *node,
+    ecs_id_t without)
+{
+    /* Create sequence with new id */
+    ecs_type_t dst_type;
+    int res = flecs_type_new_without(world, &dst_type, &node->type, without);
+    if (res == -1) {
+        return node; /* Current table does not have id */
     }
 
-    ecs_assert(value->type != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(value->ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+    return flecs_table_ensure(world, &dst_type, true, node);
+}
 
-    return ptr;
-error:
-    return NULL;
+static
+void flecs_table_init_edge(
+    ecs_table_t *table,
+    ecs_graph_edge_t *edge,
+    ecs_id_t id,
+    ecs_table_t *to)
+{
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(edge != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(edge->id == 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(edge->hdr.next == NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(edge->hdr.prev == NULL, ECS_INTERNAL_ERROR, NULL);
+    
+    edge->from = table;
+    edge->to = to;
+    edge->id = id;
 }
 
-const char* ecs_parse_expr(
+static
+void flecs_init_edge_for_add(
     ecs_world_t *world,
-    const char *ptr,
-    ecs_value_t *value,
-    const ecs_parse_expr_desc_t *desc)
+    ecs_table_t *table,
+    ecs_graph_edge_t *edge,
+    ecs_id_t id,
+    ecs_table_t *to)
 {
-    /* Prepare storage for temporary values */
-    ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_value_stack_t stack;
-    stack.count = 0;
-    stack.stage = stage;
-    stack.stack = &stage->allocators.deser_stack;
-    stack.cursor = flecs_stack_get_cursor(stack.stack);
+    flecs_table_init_edge(table, edge, id, to);
 
-    /* Parse expression */
-    bool storage_provided = value->ptr != NULL;
-    ptr = flecs_parse_expr(world, &stack, ptr, value, EcsExprOperUnknown, desc);
+    flecs_table_ensure_hi_edge(world, &table->node.add, id);
 
-    /* If no result value was provided, allocate one as we can't return a 
-     * pointer to a temporary storage */
-    if (!storage_provided && value->ptr) {
-        ecs_assert(value->type != 0, ECS_INTERNAL_ERROR, NULL);
-        void *temp_storage = value->ptr;
-        value->ptr = ecs_value_new(world, value->type);
-        ecs_value_move_ctor(world, value->type, value->ptr, temp_storage);
-    }
-    
-    /* Cleanup temporary values */
-    int i;
-    for (i = 0; i < stack.count; i ++) {
-        const ecs_type_info_t *ti = stack.values[i].ti;
-        ecs_assert(ti->hooks.dtor != NULL, ECS_INTERNAL_ERROR, NULL);
-        ti->hooks.dtor(stack.values[i].ptr, 1, ti);
-    }
-    flecs_stack_restore_cursor(stack.stack, stack.cursor);
+    if (table != to) {
+        /* Add edges are appended to refs.next */
+        ecs_graph_edge_hdr_t *to_refs = &to->node.refs;
+        ecs_graph_edge_hdr_t *next = to_refs->next;
+        
+        to_refs->next = &edge->hdr;
+        edge->hdr.prev = to_refs;
 
-    return ptr;
+        edge->hdr.next = next;
+        if (next) {
+            next->prev = &edge->hdr;
+        }
+
+        flecs_compute_table_diff(world, table, to, edge, id);
+    }
 }
 
-#endif
+static
+void flecs_init_edge_for_remove(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_graph_edge_t *edge,
+    ecs_id_t id,
+    ecs_table_t *to)
+{
+    flecs_table_init_edge(table, edge, id, to);
 
-/**
- * @file expr/serialize.c
- * @brief Serialize (component) values to flecs string format.
- */
+    flecs_table_ensure_hi_edge(world, &table->node.remove, id);
 
+    if (table != to) {
+        /* Remove edges are appended to refs.prev */
+        ecs_graph_edge_hdr_t *to_refs = &to->node.refs;
+        ecs_graph_edge_hdr_t *prev = to_refs->prev;
 
-#ifdef FLECS_EXPR
+        to_refs->prev = &edge->hdr;
+        edge->hdr.next = to_refs;
 
-static
-int flecs_expr_ser_type(
-    const ecs_world_t *world,
-    const ecs_vec_t *ser, 
-    const void *base, 
-    ecs_strbuf_t *str,
-    bool is_expr);
+        edge->hdr.prev = prev;
+        if (prev) {
+            prev->next = &edge->hdr;
+        }
 
-static
-int flecs_expr_ser_type_ops(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *ops,
-    int32_t op_count,
-    const void *base, 
-    ecs_strbuf_t *str,
-    int32_t in_array,
-    bool is_expr);
+        flecs_compute_table_diff(world, table, to, edge, id);
+    }
+}
 
 static
-int flecs_expr_ser_type_op(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *base,
-    ecs_strbuf_t *str,
-    bool is_expr);
+ecs_table_t* flecs_create_edge_for_remove(
+    ecs_world_t *world,
+    ecs_table_t *node,
+    ecs_graph_edge_t *edge,
+    ecs_id_t id)
+{
+    ecs_table_t *to = flecs_find_table_without(world, node, id);
+    flecs_init_edge_for_remove(world, node, edge, id, to);
+    return to;   
+}
 
 static
-ecs_primitive_kind_t flecs_expr_op_to_primitive_kind(ecs_meta_type_op_kind_t kind) {
-    return kind - EcsOpPrimitive;
+ecs_table_t* flecs_create_edge_for_add(
+    ecs_world_t *world,
+    ecs_table_t *node,
+    ecs_graph_edge_t *edge,
+    ecs_id_t id)
+{
+    ecs_table_t *to = flecs_find_table_with(world, node, id);
+    flecs_init_edge_for_add(world, node, edge, id, to);
+    return to;
 }
 
-/* Serialize a primitive value */
-static
-int flecs_expr_ser_primitive(
-    const ecs_world_t *world,
-    ecs_primitive_kind_t kind,
-    const void *base, 
-    ecs_strbuf_t *str,
-    bool is_expr) 
+ecs_table_t* flecs_table_traverse_remove(
+    ecs_world_t *world,
+    ecs_table_t *node,
+    ecs_id_t *id_ptr,
+    ecs_table_diff_t *diff)
 {
-    switch(kind) {
-    case EcsBool:
-        if (*(const bool*)base) {
-            ecs_strbuf_appendlit(str, "true");
-        } else {
-            ecs_strbuf_appendlit(str, "false");
-        }
-        break;
-    case EcsChar: {
-        char chbuf[3];
-        char ch = *(const char*)base;
-        if (ch) {
-            ecs_chresc(chbuf, *(const char*)base, '"');
-            if (is_expr) ecs_strbuf_appendch(str, '"');
-            ecs_strbuf_appendstr(str, chbuf);
-            if (is_expr) ecs_strbuf_appendch(str, '"');
-        } else {
-            ecs_strbuf_appendch(str, '0');
-        }
-        break;
-    }
-    case EcsByte:
-        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint8_t*)base));
-        break;
-    case EcsU8:
-        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint8_t*)base));
-        break;
-    case EcsU16:
-        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint16_t*)base));
-        break;
-    case EcsU32:
-        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint32_t*)base));
-        break;
-    case EcsU64:
-        ecs_strbuf_append(str, "%llu", *(const uint64_t*)base);
-        break;
-    case EcsI8:
-        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int8_t*)base));
-        break;
-    case EcsI16:
-        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int16_t*)base));
-        break;
-    case EcsI32:
-        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int32_t*)base));
-        break;
-    case EcsI64:
-        ecs_strbuf_appendint(str, *(const int64_t*)base);
-        break;
-    case EcsF32:
-        ecs_strbuf_appendflt(str, (double)*(const float*)base, 0);
-        break;
-    case EcsF64:
-        ecs_strbuf_appendflt(str, *(const double*)base, 0);
-        break;
-    case EcsIPtr:
-        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const intptr_t*)base));
-        break;
-    case EcsUPtr:
-        ecs_strbuf_append(str, "%u", *(const uintptr_t*)base);
-        break;
-    case EcsString: {
-        const char *value = *ECS_CONST_CAST(const char**, base);
-        if (value) {
-            if (!is_expr) {
-                ecs_strbuf_appendstr(str, value);
-            } else {
-                ecs_size_t length = ecs_stresc(NULL, 0, '"', value);
-                if (length == ecs_os_strlen(value)) {
-                    ecs_strbuf_appendch(str, '"');
-                    ecs_strbuf_appendstrn(str, value, length);
-                    ecs_strbuf_appendch(str, '"');
-                } else {
-                    char *out = ecs_os_malloc(length + 3);
-                    ecs_stresc(out + 1, length, '"', value);
-                    out[0] = '"';
-                    out[length + 1] = '"';
-                    out[length + 2] = '\0';
-                    ecs_strbuf_appendstr(str, out);
-                    ecs_os_free(out);
-                }
-            }
-        } else {
-            ecs_strbuf_appendlit(str, "null");
-        }
-        break;
+    flecs_poly_assert(world, ecs_world_t);
+
+    node = node ? node : &world->store.root;
+
+    /* Removing 0 from an entity is not valid */
+    ecs_check(id_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(id_ptr[0] != 0, ECS_INVALID_PARAMETER, NULL);
+
+    ecs_id_t id = id_ptr[0];
+    ecs_graph_edge_t *edge = flecs_table_ensure_edge(world, &node->node.remove, id);
+    ecs_table_t *to = edge->to;
+
+    if (!to) {
+        to = flecs_create_edge_for_remove(world, node, edge, id);
+        ecs_assert(to != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(edge->to != NULL, ECS_INTERNAL_ERROR, NULL);
     }
-    case EcsEntity: {
-        ecs_entity_t e = *(const ecs_entity_t*)base;
-        if (!e) {
-            ecs_strbuf_appendch(str, '0');
+
+    if (node != to) {
+        if (edge->diff) {
+            *diff = *edge->diff;
         } else {
-            ecs_get_path_w_sep_buf(world, 0, e, ".", NULL, str);
+            diff->added.count = 0;
+            diff->removed.array = id_ptr;
+            diff->removed.count = 1;
         }
-        break;
     }
-    case EcsId: {
-        ecs_id_t id = *(const ecs_id_t*)base;
-        if (!id) {
-            ecs_strbuf_appendch(str, '0');
+
+    return to;
+error:
+    return NULL;
+}
+
+ecs_table_t* flecs_table_traverse_add(
+    ecs_world_t *world,
+    ecs_table_t *node,
+    ecs_id_t *id_ptr,
+    ecs_table_diff_t *diff)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(diff != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    node = node ? node : &world->store.root;
+
+    /* Adding 0 to an entity is not valid */
+    ecs_check(id_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(id_ptr[0] != 0, ECS_INVALID_PARAMETER, NULL);
+
+    ecs_id_t id = id_ptr[0];
+    ecs_graph_edge_t *edge = flecs_table_ensure_edge(world, &node->node.add, id);
+    ecs_table_t *to = edge->to;
+
+    if (!to) {
+        to = flecs_create_edge_for_add(world, node, edge, id);
+        ecs_assert(to != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(edge->to != NULL, ECS_INTERNAL_ERROR, NULL);
+    }
+
+    if (node != to || edge->diff) {
+        if (edge->diff) {
+            *diff = *edge->diff;
         } else {
-            ecs_id_str_buf(world, id, str);
+            diff->added.array = id_ptr;
+            diff->added.count = 1;
+            diff->removed.count = 0;
         }
-        break;
-    }
-    default:
-        ecs_err("invalid primitive kind");
-        return -1;
     }
 
-    return 0;
+    return to;
+error:
+    return NULL;
 }
 
-/* Serialize enumeration */
-static
-int flecs_expr_ser_enum(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *base, 
-    ecs_strbuf_t *str) 
+ecs_table_t* flecs_table_find_or_create(
+    ecs_world_t *world,
+    ecs_type_t *type)
 {
-    const EcsEnum *enum_type = ecs_get(world, op->type, EcsEnum);
-    ecs_check(enum_type != NULL, ECS_INVALID_PARAMETER, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    return flecs_table_ensure(world, type, false, NULL);
+}
 
-    int32_t val = *(const int32_t*)base;
-    
-    /* Enumeration constants are stored in a map that is keyed on the
-     * enumeration value. */
-    ecs_enum_constant_t *c = ecs_map_get_deref(&enum_type->constants, 
-        ecs_enum_constant_t, (ecs_map_key_t)val);
-    if (!c) {
-        char *path = ecs_get_fullpath(world, op->type);
-        ecs_err("value %d is not valid for enum type '%s'", val, path);
-        ecs_os_free(path);
-        goto error;
-    }
+void flecs_init_root_table(
+    ecs_world_t *world)
+{
+    flecs_poly_assert(world, ecs_world_t);
 
-    ecs_strbuf_appendstr(str, ecs_get_name(world, c->constant));
+    world->store.root.type = (ecs_type_t){0};
+    world->store.root._ = flecs_calloc_t(&world->allocator, ecs_table__t);
+    flecs_init_table(world, &world->store.root, NULL);
 
-    return 0;
-error:
-    return -1;
+    /* Ensure table indices start at 1, as 0 is reserved for the root */
+    uint64_t new_id = flecs_sparse_new_id(&world->store.tables);
+    ecs_assert(new_id == 0, ECS_INTERNAL_ERROR, NULL);
+    (void)new_id;
 }
 
-/* Serialize bitmask */
-static
-int flecs_expr_ser_bitmask(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *ptr, 
-    ecs_strbuf_t *str) 
+void flecs_table_clear_edges(
+    ecs_world_t *world,
+    ecs_table_t *table)
 {
-    const EcsBitmask *bitmask_type = ecs_get(world, op->type, EcsBitmask);
-    ecs_check(bitmask_type != NULL, ECS_INVALID_PARAMETER, NULL);
-    uint32_t value = *(const uint32_t*)ptr;
+    (void)world;
+    flecs_poly_assert(world, ecs_world_t);
 
-    ecs_strbuf_list_push(str, "", "|");
+    ecs_log_push_1();
 
-    /* Multiple flags can be set at a given time. Iterate through all the flags
-     * and append the ones that are set. */
-    ecs_map_iter_t it = ecs_map_iter(&bitmask_type->constants);
-    int count = 0;
+    ecs_map_iter_t it;
+    ecs_graph_node_t *table_node = &table->node;
+    ecs_graph_edges_t *node_add = &table_node->add;
+    ecs_graph_edges_t *node_remove = &table_node->remove;
+    ecs_map_t *add_hi = node_add->hi;
+    ecs_map_t *remove_hi = node_remove->hi;
+    ecs_graph_edge_hdr_t *node_refs = &table_node->refs;
+
+    /* Cleanup outgoing edges */
+    it = ecs_map_iter(add_hi);
     while (ecs_map_next(&it)) {
-        ecs_bitmask_constant_t *c = ecs_map_ptr(&it);
-        ecs_map_key_t key = ecs_map_key(&it);
-        if ((value & key) == key) {
-            ecs_strbuf_list_appendstr(str, ecs_get_name(world, c->constant));
-            count ++;
-            value -= (uint32_t)key;
-        }
+        flecs_table_disconnect_edge(world, ecs_map_key(&it), ecs_map_ptr(&it));
     }
 
-    if (value != 0) {
-        /* All bits must have been matched by a constant */
-        char *path = ecs_get_fullpath(world, op->type);
-        ecs_err(
-            "value for bitmask %s contains bits (%u) that cannot be mapped to constant", 
-            path, value);
-        ecs_os_free(path);
-        goto error;
+    it = ecs_map_iter(remove_hi);
+    while (ecs_map_next(&it)) {
+        flecs_table_disconnect_edge(world, ecs_map_key(&it), ecs_map_ptr(&it));
     }
 
-    if (!count) {
-        ecs_strbuf_list_appendstr(str, "0");
+    /* Cleanup incoming add edges */
+    ecs_graph_edge_hdr_t *next, *cur = node_refs->next;
+    if (cur) {
+        do {
+            ecs_graph_edge_t *edge = (ecs_graph_edge_t*)cur;
+            ecs_assert(edge->to == table, ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(edge->from != NULL, ECS_INTERNAL_ERROR, NULL);
+            next = cur->next;
+            flecs_table_remove_edge(world, &edge->from->node.add, edge->id, edge);
+        } while ((cur = next));
     }
 
-    ecs_strbuf_list_pop(str, "");
+    /* Cleanup incoming remove edges */
+    cur = node_refs->prev;
+    if (cur) {
+        do {
+            ecs_graph_edge_t *edge = (ecs_graph_edge_t*)cur;
+            ecs_assert(edge->to == table, ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(edge->from != NULL, ECS_INTERNAL_ERROR, NULL);
+            next = cur->prev;
+            flecs_table_remove_edge(world, &edge->from->node.remove, edge->id, edge);
+        } while ((cur = next));
+    }
 
-    return 0;
-error:
-    return -1;
+    if (node_add->lo) {
+        flecs_bfree(&world->allocators.graph_edge_lo, node_add->lo);
+    }
+    if (node_remove->lo) {
+        flecs_bfree(&world->allocators.graph_edge_lo, node_remove->lo);
+    }
+
+    ecs_map_fini(add_hi);
+    ecs_map_fini(remove_hi);
+    flecs_free_t(&world->allocator, ecs_map_t, add_hi);
+    flecs_free_t(&world->allocator, ecs_map_t, remove_hi);
+    table_node->add.lo = NULL;
+    table_node->remove.lo = NULL;
+    table_node->add.hi = NULL;
+    table_node->remove.hi = NULL;
+
+    ecs_log_pop_1();
 }
 
-/* Serialize elements of a contiguous array */
-static
-int expr_ser_elements(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *ops, 
-    int32_t op_count,
-    const void *base, 
-    int32_t elem_count, 
-    int32_t elem_size,
-    ecs_strbuf_t *str,
-    bool is_array)
+/* Public convenience functions for traversing table graph */
+ecs_table_t* ecs_table_add_id(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_id_t id)
 {
-    ecs_strbuf_list_push(str, "[", ", ");
+    ecs_table_diff_t diff;
+    return flecs_table_traverse_add(world, table, &id, &diff);
+}
 
-    const void *ptr = base;
+ecs_table_t* ecs_table_remove_id(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_id_t id)
+{
+    ecs_table_diff_t diff;
+    return flecs_table_traverse_remove(world, table, &id, &diff);
+}
 
-    int i;
-    for (i = 0; i < elem_count; i ++) {
-        ecs_strbuf_list_next(str);
-        if (flecs_expr_ser_type_ops(
-            world, ops, op_count, ptr, str, is_array, true)) 
-        {
-            return -1;
-        }
-        ptr = ECS_OFFSET(ptr, elem_size);
-    }
+ecs_table_t* ecs_table_find(
+    ecs_world_t *world,
+    const ecs_id_t *ids,
+    int32_t id_count)
+{
+    ecs_type_t type = {
+        .array = ECS_CONST_CAST(ecs_id_t*, ids),
+        .count = id_count
+    };
+    return flecs_table_ensure(world, &type, false, NULL);
+}
 
-    ecs_strbuf_list_pop(str, "]");
+/**
+ * @file json/deserialize.c
+ * @brief Deserialize JSON strings into (component) values.
+ */
 
-    return 0;
-}
+/**
+ * @file json/json.h
+ * @brief Internal functions for JSON addon.
+ */
 
-static
-int expr_ser_type_elements(
-    const ecs_world_t *world,
-    ecs_entity_t type, 
-    const void *base, 
-    int32_t elem_count, 
-    ecs_strbuf_t *str,
-    bool is_array)
-{
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
-    ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL);
+#ifndef FLECS_JSON_PRIVATE_H
+#define FLECS_JSON_PRIVATE_H
 
-    const EcsComponent *comp = ecs_get(world, type, EcsComponent);
-    ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_meta_type_op_t *ops = ecs_vec_first_t(&ser->ops, ecs_meta_type_op_t);
-    int32_t op_count = ecs_vec_count(&ser->ops);
-    return expr_ser_elements(
-        world, ops, op_count, base, elem_count, comp->size, str, is_array);
-}
+#ifdef FLECS_JSON
 
-/* Serialize array */
-static
-int expr_ser_array(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *ptr, 
-    ecs_strbuf_t *str) 
-{
-    const EcsArray *a = ecs_get(world, op->type, EcsArray);
-    ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL);
+/* Deserialize from JSON */
+typedef enum ecs_json_token_t {
+    JsonObjectOpen,
+    JsonObjectClose,
+    JsonArrayOpen,
+    JsonArrayClose,
+    JsonColon,
+    JsonComma,
+    JsonNumber,
+    JsonString,
+    JsonBoolean,
+    JsonTrue,
+    JsonFalse,
+    JsonNull,
+    JsonLargeInt,
+    JsonLargeString,
+    JsonInvalid
+} ecs_json_token_t;
 
-    return expr_ser_type_elements(
-        world, a->type, ptr, a->count, str, true);
-}
+typedef struct ecs_json_value_ser_ctx_t {
+    ecs_entity_t type;
+    const EcsTypeSerializer *ser;
+    char *id_label;
+    bool initialized;
+} ecs_json_value_ser_ctx_t;
 
-/* Serialize vector */
-static
-int expr_ser_vector(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *base, 
-    ecs_strbuf_t *str) 
-{
-    const ecs_vec_t *value = base;
-    const EcsVector *v = ecs_get(world, op->type, EcsVector);
-    ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL);
+/* Cached data for serializer */
+typedef struct ecs_json_ser_ctx_t {
+    ecs_id_record_t *idr_doc_name;
+    ecs_id_record_t *idr_doc_color;
+    ecs_json_value_ser_ctx_t value_ctx[64];
+} ecs_json_ser_ctx_t;
 
-    int32_t count = ecs_vec_count(value);
-    void *array = ecs_vec_first(value);
+const char* flecs_json_parse(
+    const char *json,
+    ecs_json_token_t *token_kind,
+    char *token);
 
-    /* Serialize contiguous buffer of vector */
-    return expr_ser_type_elements(world, v->type, array, count, str, false);
-}
+const char* flecs_json_parse_large_string(
+    const char *json,
+    ecs_strbuf_t *buf);
 
-/* Forward serialization to the different type kinds */
-static
-int flecs_expr_ser_type_op(
+const char* flecs_json_expect(
+    const char *json,
+    ecs_json_token_t token_kind,
+    char *token,
+    const ecs_from_json_desc_t *desc);
+
+const char* flecs_json_expect_string(
+    const char *json,
+    char *token,
+    char **out,
+    const ecs_from_json_desc_t *desc);
+
+const char* flecs_json_expect_member(
+    const char *json,
+    char *token,
+    const ecs_from_json_desc_t *desc);
+
+const char* flecs_json_expect_member_name(
+    const char *json,
+    char *token,
+    const char *member_name,
+    const ecs_from_json_desc_t *desc);
+
+const char* flecs_json_skip_object(
+    const char *json,
+    char *token,
+    const ecs_from_json_desc_t *desc);
+
+const char* flecs_json_skip_array(
+    const char *json,
+    char *token,
+    const ecs_from_json_desc_t *desc);
+
+/* Serialize to JSON */
+void flecs_json_next(
+    ecs_strbuf_t *buf);
+
+void flecs_json_number(
+    ecs_strbuf_t *buf,
+    double value);
+
+void flecs_json_u32(
+    ecs_strbuf_t *buf,
+    uint32_t value);
+
+void flecs_json_true(
+    ecs_strbuf_t *buf);
+
+void flecs_json_false(
+    ecs_strbuf_t *buf);
+
+void flecs_json_bool(
+    ecs_strbuf_t *buf,
+    bool value);
+
+void flecs_json_array_push(
+    ecs_strbuf_t *buf);
+
+void flecs_json_array_pop(
+    ecs_strbuf_t *buf);
+
+void flecs_json_object_push(
+    ecs_strbuf_t *buf);
+
+void flecs_json_object_pop(
+    ecs_strbuf_t *buf);
+
+void flecs_json_string(
+    ecs_strbuf_t *buf,
+    const char *value);
+
+void flecs_json_string_escape(
+    ecs_strbuf_t *buf,
+    const char *value);
+
+void flecs_json_member(
+    ecs_strbuf_t *buf,
+    const char *name);
+
+void flecs_json_membern(
+    ecs_strbuf_t *buf,
+    const char *name,
+    int32_t name_len);
+
+#define flecs_json_memberl(buf, name)\
+    flecs_json_membern(buf, name, sizeof(name) - 1)
+
+void flecs_json_path(
+    ecs_strbuf_t *buf,
     const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *ptr,
-    ecs_strbuf_t *str,
-    bool is_expr)
-{
-    switch(op->kind) {
-    case EcsOpPush:
-    case EcsOpPop:
-        /* Should not be parsed as single op */
-        ecs_throw(ECS_INVALID_PARAMETER, NULL);
-        break;
-    case EcsOpEnum:
-        if (flecs_expr_ser_enum(world, op, ECS_OFFSET(ptr, op->offset), str)) {
-            goto error;
-        }
-        break;
-    case EcsOpBitmask:
-        if (flecs_expr_ser_bitmask(world, op, ECS_OFFSET(ptr, op->offset), str)) {
-            goto error;
-        }
-        break;
-    case EcsOpArray:
-        if (expr_ser_array(world, op, ECS_OFFSET(ptr, op->offset), str)) {
-            goto error;
-        }
-        break;
-    case EcsOpVector:
-        if (expr_ser_vector(world, op, ECS_OFFSET(ptr, op->offset), str)) {
-            goto error;
-        }
-        break;
-    case EcsOpScope:
-    case EcsOpPrimitive:
-    case EcsOpBool:
-    case EcsOpChar:
-    case EcsOpByte:
-    case EcsOpU8:
-    case EcsOpU16:
-    case EcsOpU32:
-    case EcsOpU64:
-    case EcsOpI8:
-    case EcsOpI16:
-    case EcsOpI32:
-    case EcsOpI64:
-    case EcsOpF32:
-    case EcsOpF64:
-    case EcsOpUPtr:
-    case EcsOpIPtr:
-    case EcsOpEntity:
-    case EcsOpId:
-    case EcsOpString:
-    case EcsOpOpaque:
-        if (flecs_expr_ser_primitive(world, flecs_expr_op_to_primitive_kind(op->kind), 
-            ECS_OFFSET(ptr, op->offset), str, is_expr))
-        {
-            /* Unknown operation */
-            ecs_err("unknown serializer operation kind (%d)", op->kind);
-            goto error;
-        }
-        break;
-    default:
-        ecs_throw(ECS_INVALID_PARAMETER, "invalid operation");
-    }
+    ecs_entity_t e);
 
-    return 0;
-error:
-    return -1;
-}
+void flecs_json_label(
+    ecs_strbuf_t *buf,
+    const ecs_world_t *world,
+    ecs_entity_t e);
 
-/* Iterate over a slice of the type ops array */
-static
-int flecs_expr_ser_type_ops(
+void flecs_json_color(
+    ecs_strbuf_t *buf,
     const ecs_world_t *world,
-    ecs_meta_type_op_t *ops,
-    int32_t op_count,
-    const void *base,
-    ecs_strbuf_t *str,
-    int32_t in_array,
-    bool is_expr) 
-{
-    for (int i = 0; i < op_count; i ++) {
-        ecs_meta_type_op_t *op = &ops[i];
+    ecs_entity_t e);
 
-        if (in_array <= 0) {
-            if (op->name) {
-                ecs_strbuf_list_next(str);
-                ecs_strbuf_append(str, "%s: ", op->name);
-            }
+void flecs_json_id(
+    ecs_strbuf_t *buf,
+    const ecs_world_t *world,
+    ecs_id_t id);
 
-            int32_t elem_count = op->count;
-            if (elem_count > 1) {
-                /* Serialize inline array */
-                if (expr_ser_elements(world, op, op->op_count, base,
-                    elem_count, op->size, str, true))
-                {
-                    return -1;
-                }
+void flecs_json_id_member(
+    ecs_strbuf_t *buf,
+    const ecs_world_t *world,
+    ecs_id_t id);
 
-                i += op->op_count - 1;
-                continue;
-            }
-        }
+ecs_primitive_kind_t flecs_json_op_to_primitive_kind(
+    ecs_meta_type_op_kind_t kind);
 
-        switch(op->kind) {
-        case EcsOpPush:
-            ecs_strbuf_list_push(str, "{", ", ");
-            in_array --;
-            break;
-        case EcsOpPop:
-            ecs_strbuf_list_pop(str, "}");
-            in_array ++;
-            break;
-        case EcsOpArray:
-        case EcsOpVector:
-        case EcsOpEnum:
-        case EcsOpBitmask:
-        case EcsOpScope:
-        case EcsOpPrimitive:
-        case EcsOpBool:
-        case EcsOpChar:
-        case EcsOpByte:
-        case EcsOpU8:
-        case EcsOpU16:
-        case EcsOpU32:
-        case EcsOpU64:
-        case EcsOpI8:
-        case EcsOpI16:
-        case EcsOpI32:
-        case EcsOpI64:
-        case EcsOpF32:
-        case EcsOpF64:
-        case EcsOpUPtr:
-        case EcsOpIPtr:
-        case EcsOpEntity:
-        case EcsOpId:
-        case EcsOpString:
-        case EcsOpOpaque:
-            if (flecs_expr_ser_type_op(world, op, base, str, is_expr)) {
-                goto error;
-            }
-            break;
-        default:
-            ecs_throw(ECS_INVALID_PARAMETER, "invalid operation");
-        }
-    }
+bool flecs_json_serialize_get_field_ctx(
+    const ecs_world_t *world,
+    const ecs_iter_t *it,
+    int32_t f,
+    ecs_json_ser_ctx_t *ser_ctx);
 
-    return 0;
-error:
-    return -1;
-}
+int flecs_json_serialize_iter_result_rows(
+    const ecs_world_t *world,
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf,
+    const ecs_iter_to_json_desc_t *desc,
+    ecs_json_ser_ctx_t *ser_ctx);
 
-/* Iterate over the type ops of a type */
-static
-int flecs_expr_ser_type(
+bool flecs_json_serialize_iter_result_is_set(
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf);
+
+bool flecs_json_skip_variable(
+    const char *name);
+
+void flecs_json_serialize_field(
     const ecs_world_t *world,
-    const ecs_vec_t *v_ops,
-    const void *base, 
-    ecs_strbuf_t *str,
-    bool is_expr) 
-{
-    ecs_meta_type_op_t *ops = ecs_vec_first_t(v_ops, ecs_meta_type_op_t);
-    int32_t count = ecs_vec_count(v_ops);
-    return flecs_expr_ser_type_ops(world, ops, count, base, str, 0, is_expr);
-}
+    const ecs_iter_t *it,
+    const ecs_query_t *q,
+    int field,
+    ecs_strbuf_t *buf,
+    ecs_json_ser_ctx_t *ctx);
 
-int ecs_ptr_to_expr_buf(
+void flecs_json_serialize_query(
     const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *ptr,
-    ecs_strbuf_t *buf_out)
-{
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
-    if (ser == NULL) {
-        char *path = ecs_get_fullpath(world, type);
-        ecs_err("cannot serialize value for type '%s'", path);
-        ecs_os_free(path);
-        goto error;
-    }
+    const ecs_query_t *q,
+    ecs_strbuf_t *buf);
 
-    if (flecs_expr_ser_type(world, &ser->ops, ptr, buf_out, true)) {
-        goto error;
-    }
+int flecs_json_ser_type(
+    const ecs_world_t *world,
+    const ecs_vec_t *ser,
+    const void *base,
+    ecs_strbuf_t *str);
 
-    return 0;
-error:
-    return -1;
-}
+#endif
 
-char* ecs_ptr_to_expr(
-    const ecs_world_t *world, 
-    ecs_entity_t type, 
-    const void* ptr)
-{
-    ecs_strbuf_t str = ECS_STRBUF_INIT;
+#endif /* FLECS_JSON_PRIVATE_H */
 
-    if (ecs_ptr_to_expr_buf(world, type, ptr, &str) != 0) {
-        ecs_strbuf_reset(&str);
-        return NULL;
-    }
+#include <ctype.h>
 
-    return ecs_strbuf_get(&str);
+#ifdef FLECS_JSON
+
+typedef struct {
+    ecs_allocator_t *a;
+    ecs_vec_t records;
+    ecs_vec_t result_ids;
+    ecs_vec_t columns_set;
+    ecs_map_t anonymous_ids;
+    ecs_map_t missing_reflection;
+} ecs_from_json_ctx_t;
+
+static
+void flecs_from_json_ctx_init(
+    ecs_allocator_t *a,
+    ecs_from_json_ctx_t *ctx)
+{
+    ctx->a = a;
+    ecs_vec_init_t(a, &ctx->records, ecs_record_t*, 0);
+    ecs_vec_init_t(a, &ctx->result_ids, ecs_id_t, 0);
+    ecs_vec_init_t(a, &ctx->columns_set, ecs_id_t, 0);
+    ecs_map_init(&ctx->anonymous_ids, a);
+    ecs_map_init(&ctx->missing_reflection, a);
 }
 
-int ecs_ptr_to_str_buf(
+static
+void flecs_from_json_ctx_fini(
+    ecs_from_json_ctx_t *ctx)
+{
+    ecs_vec_fini_t(ctx->a, &ctx->records, ecs_record_t*);
+    ecs_vec_fini_t(ctx->a, &ctx->result_ids, ecs_record_t*);
+    ecs_vec_fini_t(ctx->a, &ctx->columns_set, ecs_id_t);
+    ecs_map_fini(&ctx->anonymous_ids);
+    ecs_map_fini(&ctx->missing_reflection);
+}
+
+static
+const char* flecs_json_parse_path(
     const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *ptr,
-    ecs_strbuf_t *buf_out)
+    const char *json,
+    char *token,
+    ecs_entity_t *out,
+    const ecs_from_json_desc_t *desc)
 {
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
-    if (ser == NULL) {
-        char *path = ecs_get_fullpath(world, type);
-        ecs_err("cannot serialize value for type '%s'", path);
-        ecs_os_free(path);
+    char *path = NULL;
+    json = flecs_json_expect_string(json, token, &path, desc);
+    if (!json) {
         goto error;
     }
 
-    if (flecs_expr_ser_type(world, &ser->ops, ptr, buf_out, false)) {
+    ecs_entity_t result = ecs_lookup(world, path);
+    if (!result) {
+        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+            "unresolved identifier '%s'", path);
         goto error;
     }
 
-    return 0;
-error:
-    return -1;
-}
+    *out = result;
 
-char* ecs_ptr_to_str(
-    const ecs_world_t *world, 
-    ecs_entity_t type, 
-    const void* ptr)
-{
-    ecs_strbuf_t str = ECS_STRBUF_INIT;
+    if (path != token) {
+        ecs_os_free(path);
+    }
 
-    if (ecs_ptr_to_str_buf(world, type, ptr, &str) != 0) {
-        ecs_strbuf_reset(&str);
-        return NULL;
+    return json;
+error:
+    if (path != token) {
+        ecs_os_free(path);
     }
 
-    return ecs_strbuf_get(&str);
+    return NULL;
 }
 
-int ecs_primitive_to_expr_buf(
+const char* ecs_ptr_from_json(
     const ecs_world_t *world,
-    ecs_primitive_kind_t kind,
-    const void *base, 
-    ecs_strbuf_t *str)
+    ecs_entity_t type,
+    void *ptr,
+    const char *json,
+    const ecs_from_json_desc_t *desc)
 {
-    return flecs_expr_ser_primitive(world, kind, base, str, true);
-}
-
-#endif
+    ecs_json_token_t token_kind = 0;
+    char token_buffer[ECS_MAX_TOKEN_SIZE], t_lah[ECS_MAX_TOKEN_SIZE];
+    char *token = token_buffer;
+    int depth = 0;
 
-/**
- * @file expr/utils.c
- * @brief String parsing utilities.
- */
+    const char *name = NULL;
+    const char *expr = NULL;
 
+    ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, ptr);
+    if (cur.valid == false) {
+        return NULL;
+    }
 
-#ifdef FLECS_EXPR
+    if (desc) {
+        name = desc->name;
+        expr = desc->expr;
+        cur.lookup_action = desc->lookup_action;
+        cur.lookup_ctx = desc->lookup_ctx;
+    }
 
-#include <ctype.h>
+    while ((json = flecs_json_parse(json, &token_kind, token))) {
+        if (token_kind == JsonLargeString) {
+            ecs_strbuf_t large_token = ECS_STRBUF_INIT;
+            json = flecs_json_parse_large_string(json, &large_token);
+            if (!json) {
+                break;
+            }
 
-char* ecs_chresc(
-    char *out, 
-    char in, 
-    char delimiter) 
-{
-    char *bptr = out;
-    switch(in) {
-    case '\a':
-        *bptr++ = '\\';
-        *bptr = 'a';
-        break;
-    case '\b':
-        *bptr++ = '\\';
-        *bptr = 'b';
-        break;
-    case '\f':
-        *bptr++ = '\\';
-        *bptr = 'f';
-        break;
-    case '\n':
-        *bptr++ = '\\';
-        *bptr = 'n';
-        break;
-    case '\r':
-        *bptr++ = '\\';
-        *bptr = 'r';
-        break;
-    case '\t':
-        *bptr++ = '\\';
-        *bptr = 't';
-        break;
-    case '\v':
-        *bptr++ = '\\';
-        *bptr = 'v';
-        break;
-    case '\\':
-        *bptr++ = '\\';
-        *bptr = '\\';
-        break;
-    case '\033':
-        *bptr = '['; /* Used for terminal colors */
-        break;
-    default:
-        if (in == delimiter) {
-            *bptr++ = '\\';
-            *bptr = delimiter;
-        } else {
-            *bptr = in;
+            token = ecs_strbuf_get(&large_token);
+            token_kind = JsonString;
         }
-        break;
-    }
-
-    *(++bptr) = '\0';
 
-    return bptr;
-}
+        if (token_kind == JsonObjectOpen) {
+            depth ++;
+            if (ecs_meta_push(&cur) != 0) {
+                goto error;
+            }
 
-const char* ecs_chrparse(
-    const char *in, 
-    char *out) 
-{
-    const char *result = in + 1;
-    char ch;
+            if (ecs_meta_is_collection(&cur)) {
+                ecs_parser_error(name, expr, json - expr, "expected '['");
+                return NULL;
+            }
+        } else if (token_kind == JsonObjectClose) {
+            depth --;
 
-    if (in[0] == '\\') {
-        result ++;
+            if (ecs_meta_is_collection(&cur)) {
+                ecs_parser_error(name, expr, json - expr, "expected ']'");
+                return NULL;
+            }
 
-        switch(in[1]) {
-        case 'a':
-            ch = '\a';
-            break;
-        case 'b':
-            ch = '\b';
-            break;
-        case 'f':
-            ch = '\f';
-            break;
-        case 'n':
-            ch = '\n';
-            break;
-        case 'r':
-            ch = '\r';
-            break;
-        case 't':
-            ch = '\t';
-            break;
-        case 'v':
-            ch = '\v';
-            break;
-        case '\\':
-            ch = '\\';
-            break;
-        case '"':
-            ch = '"';
-            break;
-        case '0':
-            ch = '\0';
-            break;
-        case ' ':
-            ch = ' ';
-            break;
-        case '$':
-            ch = '$';
-            break;
-        default:
-            goto error;
-        }
-    } else {
-        ch = in[0];
-    }
+            if (ecs_meta_pop(&cur) != 0) {
+                goto error;
+            }
+        } else if (token_kind == JsonArrayOpen) {
+            depth ++;
+            if (ecs_meta_push(&cur) != 0) {
+                goto error;
+            }
 
-    if (out) {
-        *out = ch;
-    }
+            if (!ecs_meta_is_collection(&cur)) {
+                ecs_parser_error(name, expr, json - expr, "expected '{'");
+                return NULL;
+            }
+        } else if (token_kind == JsonArrayClose) {
+            depth --;
 
-    return result;
-error:
-    return NULL;
-}
+            if (!ecs_meta_is_collection(&cur)) {
+                ecs_parser_error(name, expr, json - expr, "expected '}'");
+                return NULL;
+            }
 
-ecs_size_t ecs_stresc(
-    char *out, 
-    ecs_size_t n, 
-    char delimiter, 
-    const char *in) 
-{
-    const char *ptr = in;
-    char ch, *bptr = out, buff[3];
-    ecs_size_t written = 0;
-    while ((ch = *ptr++)) {
-        if ((written += (ecs_size_t)(ecs_chresc(
-            buff, ch, delimiter) - buff)) <= n) 
-        {
-            /* If size != 0, an out buffer must be provided. */
-            ecs_check(out != NULL, ECS_INVALID_PARAMETER, NULL);
-            *bptr++ = buff[0];
-            if ((ch = buff[1])) {
-                *bptr = ch;
-                bptr++;
+            if (ecs_meta_pop(&cur) != 0) {
+                goto error;
+            }
+        } else if (token_kind == JsonComma) {
+            if (ecs_meta_next(&cur) != 0) {
+                goto error;
+            }
+        } else if (token_kind == JsonNull) {
+            if (ecs_meta_set_null(&cur) != 0) {
+                goto error;
+            }
+        } else if (token_kind == JsonString) {
+            const char *lah = flecs_json_parse(
+                json, &token_kind, t_lah);
+            if (token_kind == JsonColon) {
+                /* Member assignment */
+                json = lah;
+                if (ecs_meta_dotmember(&cur, token) != 0) {
+                    goto error;
+                }
+            } else {
+                if (ecs_meta_set_string(&cur, token) != 0) {
+                    goto error;
+                }
+            }
+        } else if (token_kind == JsonNumber) {
+            double number = atof(token);
+            if (ecs_meta_set_float(&cur, number) != 0) {
+                goto error;
+            }
+        } else if (token_kind == JsonLargeInt) {
+            int64_t number = flecs_ito(int64_t, atoll(token));
+            if (ecs_meta_set_int(&cur, number) != 0) {
+                goto error;
+            }
+        } else if (token_kind == JsonNull) {
+            if (ecs_meta_set_null(&cur) != 0) {
+                goto error;
+            }
+        } else if (token_kind == JsonTrue) {
+            if (ecs_meta_set_bool(&cur, true) != 0) {
+                goto error;
+            }
+        } else if (token_kind == JsonFalse) {
+            if (ecs_meta_set_bool(&cur, false) != 0) {
+                goto error;
             }
+        } else {
+            goto error;
         }
-    }
 
-    if (bptr) {
-        while (written < n) {
-            *bptr = '\0';
-            bptr++;
-            written++;
+        if (token != token_buffer) {
+            ecs_os_free(token);
+            token = token_buffer;
+        }
+
+        if (!depth) {
+            break;
         }
     }
-    return written;
+
+    return json;
 error:
-    return 0;
+    return NULL;
 }
 
-char* ecs_astresc(
-    char delimiter, 
-    const char *in)
+const char* ecs_entity_from_json(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    const char *json,
+    const ecs_from_json_desc_t *desc_param)
 {
-    if (!in) {
+    ecs_json_token_t token_kind = 0;
+    char token[ECS_MAX_TOKEN_SIZE];
+
+    ecs_from_json_desc_t desc = {0};
+
+    const char *name = NULL, *expr = json, *ids = NULL, *values = NULL, *lah;
+    if (desc_param) {
+        desc = *desc_param;
+    }
+
+    json = flecs_json_expect(json, JsonObjectOpen, token, &desc);
+    if (!json) {
+        goto error;
+    }
+
+    lah = flecs_json_parse(json, &token_kind, token);
+    if (!lah) {
+        goto error;
+    }
+
+    if (token_kind == JsonObjectClose) {
+        return lah;
+    }
+
+    json = flecs_json_expect_member(json, token, &desc);
+    if (!json) {
         return NULL;
     }
 
-    ecs_size_t len = ecs_stresc(NULL, 0, delimiter, in);
-    char *out = ecs_os_malloc_n(char, len + 1);
-    ecs_stresc(out, len, delimiter, in);
-    out[len] = '\0';
-    return out;
-}
+    if (!ecs_os_strcmp(token, "path")) {
+        char *path = NULL;
+        json = flecs_json_expect_string(json, token, &path, &desc);
+        if (!json) {
+            goto error;
+        }
 
-static
-const char* flecs_parse_var_name(
-    const char *ptr,
-    char *token_out)
-{
-    char ch, *bptr = token_out;
+        ecs_add_fullpath(world, e, path);
 
-    while ((ch = *ptr)) {
-        if (bptr - token_out > ECS_MAX_TOKEN_SIZE) {
+        if (path != token) {
+            ecs_os_free(path);
+        }
+
+        json = flecs_json_parse(json, &token_kind, token);
+        if (!json) {
             goto error;
         }
 
-        if (isalpha(ch) || isdigit(ch) || ch == '_') {
-            *bptr = ch;
-            bptr ++;
-            ptr ++;
-        } else {
-            break;
+        if (token_kind == JsonObjectClose) {
+            return json;
+        } else if (token_kind != JsonComma) {
+            ecs_parser_error(name, expr, json - expr, "unexpected character");
+            goto error;
         }
-    }
 
-    if (bptr == token_out) {
+        json = flecs_json_expect_member_name(json, token, "ids", &desc);
+        if (!json) {
+            goto error;
+        }
+    } else if (ecs_os_strcmp(token, "ids")) {
+        ecs_parser_error(name, expr, json - expr, "expected member 'ids'");
         goto error;
     }
 
-    *bptr = '\0';
+    json = flecs_json_expect(json, JsonArrayOpen, token, &desc);
+    if (!json) {
+        goto error;
+    }
 
-    return ptr;
-error:
-    return NULL;
-}
+    ids = json;
 
-static
-const char* flecs_parse_interpolated_str(
-    const char *ptr,
-    char *token_out)
-{
-    char ch, *bptr = token_out;
+    json = flecs_json_skip_array(json, token, &desc);
+    if (!json) {
+        return NULL;
+    }
 
-    while ((ch = *ptr)) {
-        if (bptr - token_out > ECS_MAX_TOKEN_SIZE) {
+    json = flecs_json_parse(json, &token_kind, token);
+    if (token_kind != JsonObjectClose) {
+        if (token_kind != JsonComma) {
+            ecs_parser_error(name, expr, json - expr, "expected ','");
             goto error;
         }
 
-        if (ch == '\\') {
-            if (ptr[1] == '}') {
-                *bptr = '}';
-                bptr ++;
-                ptr += 2;
-                continue;
-            }
+        json = flecs_json_expect_member_name(json, token, "values", &desc);
+        if (!json) {
+            goto error;
         }
 
-        if (ch != '}') {
-            *bptr = ch;
-            bptr ++;
-            ptr ++;
-        } else {
-            ptr ++;
-            break;
+        json = flecs_json_expect(json, JsonArrayOpen, token, &desc);
+        if (!json) {
+            goto error;
         }
-    }
 
-    if (bptr == token_out) {
-        goto error;
+        values = json;
     }
 
-    *bptr = '\0';
-
-    return ptr;
-error:
-    return NULL;
-}
+    do {
+        ecs_entity_t first = 0, second = 0, type_id = 0;
+        ecs_id_t id;
 
-char* ecs_interpolate_string(
-    ecs_world_t *world,
-    const char *str,
-    const ecs_vars_t *vars)
-{
-    char token[ECS_MAX_TOKEN_SIZE];
-    ecs_strbuf_t result = ECS_STRBUF_INIT;
-    const char *ptr;
-    char ch;
+        ids = flecs_json_parse(ids, &token_kind, token);
+        if (!ids) {
+            goto error;
+        }
 
-    for(ptr = str; (ch = *ptr); ptr++) {
-        if (ch == '\\') {
-            ptr ++;
-            if (ptr[0] == '$') {
-                ecs_strbuf_appendch(&result, '$');
-                continue;
-            }
-            if (ptr[0] == '\\') {
-                ecs_strbuf_appendch(&result, '\\');
-                continue;
-            }
-            if (ptr[0] == '{') {
-                ecs_strbuf_appendch(&result, '{');
-                continue;
-            }
-            if (ptr[0] == '}') {
-                ecs_strbuf_appendch(&result, '}');
-                continue;
+        if (token_kind == JsonArrayClose) {
+            if (values) {
+                if (values[0] != ']') {
+                    ecs_parser_error(name, expr, values - expr, "expected ']'");
+                    goto error;
+                }
+                json = flecs_parse_ws_eol(values + 1);
+            } else {
+                json = ids;
             }
-            ptr --;
-        }
 
-        if (ch == '$') {
-            ptr = flecs_parse_var_name(ptr + 1, token);
-            if (!ptr) {
-                ecs_parser_error(NULL, str, ptr - str, 
-                    "invalid variable name '%s'", ptr);
+            break;
+        } else if (token_kind == JsonArrayOpen) {
+            ids = flecs_json_parse_path(world, ids, token, &first, &desc);
+            if (!ids) {
                 goto error;
             }
 
-            ecs_expr_var_t *var = ecs_vars_lookup(vars, token);
-            if (!var) {
-                ecs_parser_error(NULL, str, ptr - str, 
-                    "unresolved variable '%s'", token);
+            ids = flecs_json_parse(ids, &token_kind, token);
+            if (!ids) {
                 goto error;
             }
 
-            if (ecs_ptr_to_str_buf(
-                world, var->value.type, var->value.ptr, &result)) 
-            {
+            if (token_kind == JsonComma) {
+                /* Id is a pair*/
+                ids = flecs_json_parse_path(world, ids, token, &second, &desc);
+                if (!ids) {
+                    goto error;
+                }
+
+                ids = flecs_json_expect(ids, JsonArrayClose, token, &desc);
+                if (!ids) {
+                    goto error;
+                }
+            } else if (token_kind != JsonArrayClose) {
+                ecs_parser_error(name, expr, ids - expr, "expected ',' or ']'");
                 goto error;
             }
 
-            ptr --;
-        } else if (ch == '{') {
-            ptr = flecs_parse_interpolated_str(ptr + 1, token);
-            if (!ptr) {
-                ecs_parser_error(NULL, str, ptr - str, 
-                    "invalid interpolated expression");
+            lah = flecs_json_parse(ids, &token_kind, token);
+            if (!lah) {
                 goto error;
             }
 
-            ecs_parse_expr_desc_t expr_desc = { 
-                .vars = ECS_CONST_CAST(ecs_vars_t*, vars) 
-            };
-            ecs_value_t expr_result = {0};
-            if (!ecs_parse_expr(world, token, &expr_result, &expr_desc)) {
+            if (token_kind == JsonComma) {
+                ids = lah;
+            } else if (token_kind != JsonArrayClose) {
+                ecs_parser_error(name, expr, lah - expr, "expected ',' or ']'");
                 goto error;
             }
+        } else {
+            ecs_parser_error(name, expr, lah - expr, "expected '[' or ']'");
+            goto error;
+        }
 
-            if (ecs_ptr_to_str_buf(
-                world, expr_result.type, expr_result.ptr, &result)) 
-            {
+        if (second) {
+            id = ecs_pair(first, second);
+            type_id = ecs_get_typeid(world, id);
+            if (!type_id) {
+                ecs_parser_error(name, expr, ids - expr, "id is not a type");
                 goto error;
             }
-
-            ecs_value_free(world, expr_result.type, expr_result.ptr);
-
-            ptr --;
         } else {
-            ecs_strbuf_appendch(&result, ch);
+            id = first;
+            type_id = first;
         }
-    }
-
-    return ecs_strbuf_get(&result);
-error:
-    return NULL;
-}
-
-void ecs_iter_to_vars(
-    const ecs_iter_t *it,
-    ecs_vars_t *vars,
-    int offset)
-{
-    ecs_check(vars != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!offset || offset < it->count, ECS_INVALID_PARAMETER, NULL);
 
-    /* Set variable for $this */
-    if (it->count) {
-        ecs_expr_var_t *var = ecs_vars_lookup(vars, "this");
-        if (!var) {
-            ecs_value_t v = { 
-                .ptr = &it->entities[offset], 
-                .type = ecs_id(ecs_entity_t) 
-            };
-            var = ecs_vars_declare_w_value(vars, "this", &v);
-            var->owned = false;
-        } else {
-            var->value.ptr = &it->entities[offset];
+        /* Get mutable pointer */
+        void *comp_ptr = ecs_ensure_id(world, e, id);
+        if (!comp_ptr) {
+            char *idstr = ecs_id_str(world, id);
+            ecs_parser_error(name, expr, json - expr, 
+                "id '%s' is not a valid component", idstr);
+            ecs_os_free(idstr);
+            goto error;
         }
-    }
 
-    /* Set variables for fields */
-    {
-        int32_t i, field_count = it->field_count;
-        for (i = 0; i < field_count; i ++) {
-            ecs_size_t size = it->sizes[i];
-            if (!size) {
-                continue;
-            }
+        if (values) {
+            ecs_from_json_desc_t parse_desc = {
+                .name = name,
+                .expr = expr,
+            };
 
-            void *ptr = it->ptrs[i];
-            if (!ptr) {
-                continue;
+            values = ecs_ptr_from_json(
+                world, type_id, comp_ptr, values, &parse_desc);
+            if (!values) {
+                goto error;
             }
 
-            ptr = ECS_OFFSET(ptr, offset * size);
-
-            char name[16];
-            ecs_os_sprintf(name, "%d", i + 1);
-            ecs_expr_var_t *var = ecs_vars_lookup(vars, name);
-            if (!var) {
-                ecs_value_t v = { .ptr = ptr, .type = it->ids[i] };
-                var = ecs_vars_declare_w_value(vars, name, &v);
-                var->owned = false;
-            } else {
-                ecs_check(var->value.type == it->ids[i], 
-                    ECS_INVALID_PARAMETER, NULL);
-                var->value.ptr = ptr;
+            lah = flecs_json_parse(values, &token_kind, token);
+            if (!lah) {
+                goto error;
             }
-        }
-    }
 
-    /* Set variables for query variables */
-    {
-        int32_t i, var_count = it->variable_count;
-        for (i = 1 /* skip this variable */ ; i < var_count; i ++) {
-            ecs_entity_t *e_ptr = NULL;
-            ecs_var_t *query_var = &it->variables[i];
-            if (query_var->entity) {
-                e_ptr = &query_var->entity;
+            if (token_kind == JsonComma) {
+                values = lah;
+            } else if (token_kind != JsonArrayClose) {
+                ecs_parser_error(name, expr, json - expr, 
+                    "expected ',' or ']'");
+                goto error;
             } else {
-                ecs_table_range_t *range = &query_var->range;
-                if (range->count == 1) {
-                    ecs_entity_t *entities = range->table->data.entities.array;
-                    e_ptr = &entities[range->offset];
-                }
-            }
-            if (!e_ptr) {
-                continue;
+                values = flecs_parse_ws_eol(values);
             }
 
-            ecs_expr_var_t *var = ecs_vars_lookup(vars, it->variable_names[i]);
-            if (!var) {
-                ecs_value_t v = { .ptr = e_ptr, .type = ecs_id(ecs_entity_t) };
-                var = ecs_vars_declare_w_value(vars, it->variable_names[i], &v);
-                var->owned = false;
-            } else {
-                ecs_check(var->value.type == ecs_id(ecs_entity_t), 
-                    ECS_INVALID_PARAMETER, NULL);
-                var->value.ptr = e_ptr;
-            }
+            ecs_modified_id(world, e, id);
         }
-    }
+    } while(ids[0]);
 
+    return flecs_json_expect(json, JsonObjectClose, token, &desc);
 error:
-    return;
-}
-
-#endif
-
-/**
- * @file expr/vars.c
- * @brief Utilities for variable substitution in flecs string expressions.
- */
-
-
-#ifdef FLECS_EXPR
-
-static
-void flecs_expr_var_scope_init(
-    ecs_world_t *world,
-    ecs_expr_var_scope_t *scope,
-    ecs_expr_var_scope_t *parent)
-{
-    flecs_name_index_init(&scope->var_index, &world->allocator);
-    ecs_vec_init_t(&world->allocator, &scope->vars, ecs_expr_var_t, 0);
-    scope->parent = parent;
+    return NULL;
 }
 
 static
-void flecs_expr_var_scope_fini(
+ecs_entity_t flecs_json_new_id(
     ecs_world_t *world,
-    ecs_expr_var_scope_t *scope)
+    ecs_entity_t ser_id)
 {
-    ecs_vec_t *vars = &scope->vars;
-    int32_t i, count = vars->count;
-    for (i = 0; i < count; i++) {
-        ecs_expr_var_t *var = ecs_vec_get_t(vars, ecs_expr_var_t, i);
-        if (var->owned) {
-            ecs_value_free(world, var->value.type, var->value.ptr);
-        }
-        flecs_strfree(&world->allocator, var->name);
+    /* Try to honor low id requirements */
+    if (ser_id < FLECS_HI_COMPONENT_ID) {
+        return ecs_new_low_id(world);
+    } else {
+        return ecs_new(world);
     }
-
-    ecs_vec_fini_t(&world->allocator, &scope->vars, ecs_expr_var_t);
-    flecs_name_index_fini(&scope->var_index);
 }
 
-void ecs_vars_init(
+static
+ecs_entity_t flecs_json_lookup(
     ecs_world_t *world,
-    ecs_vars_t *vars)
-{
-    flecs_expr_var_scope_init(world, &vars->root, NULL);
-    vars->world = world;
-    vars->cur = &vars->root;
-}
-
-void ecs_vars_fini(
-    ecs_vars_t *vars)
-{
-    ecs_expr_var_scope_t *cur = vars->cur, *next;
-    do {
-        next = cur->parent;
-        flecs_expr_var_scope_fini(vars->world, cur);
-        if (cur != &vars->root) {
-            flecs_free_t(&vars->world->allocator, ecs_expr_var_scope_t, cur);
-        } else {
-            break;
-        }
-    } while ((cur = next));
-}
-
-void ecs_vars_push(
-    ecs_vars_t *vars)
-{
-    ecs_expr_var_scope_t *scope = flecs_calloc_t(&vars->world->allocator, 
-        ecs_expr_var_scope_t);
-    flecs_expr_var_scope_init(vars->world, scope, vars->cur);
-    vars->cur = scope;
-}
-
-int ecs_vars_pop(
-    ecs_vars_t *vars)
-{
-    ecs_expr_var_scope_t *scope = vars->cur;
-    ecs_check(scope != &vars->root, ECS_INVALID_OPERATION, NULL);
-    vars->cur = scope->parent;
-    flecs_expr_var_scope_fini(vars->world, scope);
-    flecs_free_t(&vars->world->allocator, ecs_expr_var_scope_t, scope);
-    return 0;
-error:
-    return 1;
-}
-
-ecs_expr_var_t* ecs_vars_declare(
-    ecs_vars_t *vars,
+    ecs_entity_t parent,
     const char *name,
-    ecs_entity_t type)
+    const ecs_from_json_desc_t *desc)
 {
-    ecs_assert(vars != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(name != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(type != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_expr_var_scope_t *scope = vars->cur;
-    ecs_hashmap_t *var_index = &scope->var_index;
-
-    if (flecs_name_index_find(var_index, name, 0, 0) != 0) {
-        ecs_err("variable %s redeclared", name);
-        goto error;
+    ecs_entity_t scope = 0;
+    if (parent) {
+        scope = ecs_set_scope(world, parent);
     }
-
-    ecs_expr_var_t *var = ecs_vec_append_t(&vars->world->allocator, 
-        &scope->vars, ecs_expr_var_t);
-    
-    var->value.ptr = ecs_value_new(vars->world, type);
-    if (!var->value.ptr) {
-        goto error;
+    ecs_entity_t result = desc->lookup_action(world, name, desc->lookup_ctx);
+    if (parent) {
+        ecs_set_scope(world, scope);
     }
-    var->value.type = type;
-    var->name = flecs_strdup(&vars->world->allocator, name);
-    var->owned = true;
-
-    flecs_name_index_ensure(var_index, 
-        flecs_ito(uint64_t, ecs_vec_count(&scope->vars)), var->name, 0, 0);
-    return var;
-error:
-    return NULL;
+    return result;
 }
 
-ecs_expr_var_t* ecs_vars_declare_w_value(
-    ecs_vars_t *vars,
-    const char *name,
-    ecs_value_t *value)
+static
+void flecs_json_mark_reserved(
+    ecs_map_t *anonymous_ids,
+    ecs_entity_t e)
 {
-    ecs_assert(vars != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(name != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(value != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_expr_var_scope_t *scope = vars->cur;
-    ecs_hashmap_t *var_index = &scope->var_index;
-
-    if (flecs_name_index_find(var_index, name, 0, 0) != 0) {
-        ecs_err("variable %s redeclared", name);
-        ecs_value_free(vars->world, value->type, value->ptr);
-        goto error;
-    }
-
-    ecs_expr_var_t *var = ecs_vec_append_t(&vars->world->allocator, 
-        &scope->vars, ecs_expr_var_t);
-    var->value = *value;
-    var->name = flecs_strdup(&vars->world->allocator, name);
-    var->owned = true;
-    value->ptr = NULL; /* Take ownership, prevent double free */
-
-    flecs_name_index_ensure(var_index, 
-        flecs_ito(uint64_t, ecs_vec_count(&scope->vars)), var->name, 0, 0);
-    return var;
-error:
-    return NULL;
+    ecs_entity_t *reserved = ecs_map_ensure(anonymous_ids, e);
+    ecs_assert(reserved[0] == 0, ECS_INTERNAL_ERROR, NULL);
+    reserved[0] = 0;
 }
 
 static
-ecs_expr_var_t* flecs_vars_scope_lookup(
-    ecs_expr_var_scope_t *scope,
+bool flecs_json_name_is_anonymous(
     const char *name)
 {
-    uint64_t var_id = flecs_name_index_find(&scope->var_index, name, 0, 0);
-    if (var_id == 0) {
-        if (scope->parent) {
-            return flecs_vars_scope_lookup(scope->parent, name);
+    ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (isdigit(name[0])) {
+        const char *ptr;
+        for (ptr = name + 1; *ptr; ptr ++) {
+            if (!isdigit(*ptr)) {
+                break;
+            }
         }
-        return NULL;
-    }
-
-    return ecs_vec_get_t(&scope->vars, ecs_expr_var_t, 
-        flecs_uto(int32_t, var_id - 1));
-}
-
-ecs_expr_var_t* ecs_vars_lookup(
-    const ecs_vars_t *vars,
-    const char *name)
-{
-    return flecs_vars_scope_lookup(vars->cur, name);
-}
-
-#endif
-
-/**
- * @file json/deserialize.c
- * @brief Deserialize JSON strings into (component) values.
- */
-
-/**
- * @file json/json.h
- * @brief Internal functions for JSON addon.
- */
-
-#ifndef FLECS_JSON_PRIVATE_H
-#define FLECS_JSON_PRIVATE_H
-
-
-#ifdef FLECS_JSON
-
-/* Deserialize from JSON */
-typedef enum ecs_json_token_t {
-    JsonObjectOpen,
-    JsonObjectClose,
-    JsonArrayOpen,
-    JsonArrayClose,
-    JsonColon,
-    JsonComma,
-    JsonNumber,
-    JsonString,
-    JsonBoolean,
-    JsonTrue,
-    JsonFalse,
-    JsonNull,
-    JsonLargeInt,
-    JsonLargeString,
-    JsonInvalid
-} ecs_json_token_t;
-
-typedef struct ecs_json_value_ser_ctx_t {
-    ecs_entity_t type;
-    const EcsMetaTypeSerialized *ser;
-    char *id_label;
-    bool initialized;
-} ecs_json_value_ser_ctx_t;
-
-/* Cached data for serializer */
-typedef struct ecs_json_ser_ctx_t {
-    ecs_id_record_t *idr_doc_name;
-    ecs_id_record_t *idr_doc_color;
-    ecs_json_value_ser_ctx_t value_ctx[64];
-} ecs_json_ser_ctx_t;
-
-const char* flecs_json_parse(
-    const char *json,
-    ecs_json_token_t *token_kind,
-    char *token);
-
-const char* flecs_json_parse_large_string(
-    const char *json,
-    ecs_strbuf_t *buf);
-
-const char* flecs_json_expect(
-    const char *json,
-    ecs_json_token_t token_kind,
-    char *token,
-    const ecs_from_json_desc_t *desc);
-
-const char* flecs_json_expect_string(
-    const char *json,
-    char *token,
-    char **out,
-    const ecs_from_json_desc_t *desc);
-
-const char* flecs_json_expect_member(
-    const char *json,
-    char *token,
-    const ecs_from_json_desc_t *desc);
-
-const char* flecs_json_expect_member_name(
-    const char *json,
-    char *token,
-    const char *member_name,
-    const ecs_from_json_desc_t *desc);
+        if (!(*ptr)) {
+            return true;
+        }
+    }
+    return false;
+}
 
-const char* flecs_json_skip_object(
-    const char *json,
-    char *token,
-    const ecs_from_json_desc_t *desc);
+static
+ecs_entity_t flecs_json_ensure_entity(
+    ecs_world_t *world,
+    const char *name,
+    ecs_map_t *anonymous_ids)
+{
+    ecs_entity_t e = 0;
 
-const char* flecs_json_skip_array(
-    const char *json,
-    char *token,
-    const ecs_from_json_desc_t *desc);
+    if (flecs_json_name_is_anonymous(name)) {
+        /* Anonymous entity, find or create mapping to new id */
+        ecs_entity_t ser_id = flecs_ito(ecs_entity_t, atoll(name));
+        ecs_entity_t *deser_id = ecs_map_get(anonymous_ids, ser_id);
+        if (deser_id) {
+            if (!deser_id[0]) {
+                /* Id is already issued by deserializer, create new id */
+                deser_id[0] = flecs_json_new_id(world, ser_id);
 
-/* Serialize to JSON */
-void flecs_json_next(
-    ecs_strbuf_t *buf);
+                /* Mark new id as reserved */
+                flecs_json_mark_reserved(anonymous_ids, deser_id[0]);
+            } else {
+                /* Id mapping exists */
+            }
+        } else {
+            /* Id has not yet been issued by deserializer, which means it's safe
+             * to use. This allows the deserializer to bind to existing 
+             * anonymous ids, as they will never be reissued. */
+            deser_id = ecs_map_ensure(anonymous_ids, ser_id);
+            if (!ecs_exists(world, ser_id) || 
+               (ecs_is_alive(world, ser_id) && !ecs_get_name(world, ser_id))) 
+            {
+                /* Only use existing id if it's alive or doesn't exist yet. The 
+                 * id could have been recycled for another entity 
+                 * Also don't use existing id if the existing entity is not
+                 * anonymous. */
+                deser_id[0] = ser_id;
+                ecs_make_alive(world, ser_id);
+            } else {
+                /* If id exists and is not alive, create a new id */
+                deser_id[0] = flecs_json_new_id(world, ser_id);
 
-void flecs_json_number(
-    ecs_strbuf_t *buf,
-    double value);
+                /* Mark new id as reserved */
+                flecs_json_mark_reserved(anonymous_ids, deser_id[0]);
+            }
+        }
 
-void flecs_json_u32(
-    ecs_strbuf_t *buf,
-    uint32_t value);
+        e = deser_id[0];
+    } else {
+        e = ecs_lookup_path_w_sep(world, 0, name, ".", NULL, false);
+        if (!e) {
+            e = ecs_entity(world, { .name = name });
+            flecs_json_mark_reserved(anonymous_ids, e);
+        }
+    }
 
-void flecs_json_true(
-    ecs_strbuf_t *buf);
+    return e;
+}
 
-void flecs_json_false(
-    ecs_strbuf_t *buf);
+static
+ecs_table_t* flecs_json_parse_table(
+    ecs_world_t *world,
+    const char *json,
+    char *token,
+    ecs_from_json_ctx_t *ctx,
+    const ecs_from_json_desc_t *desc)
+{
+    ecs_json_token_t token_kind = 0;
 
-void flecs_json_bool(
-    ecs_strbuf_t *buf,
-    bool value);
+    ecs_vec_clear(&ctx->result_ids);
 
-void flecs_json_array_push(
-    ecs_strbuf_t *buf);
+    do {
+        ecs_id_t id = 0;
+        json = flecs_json_expect(json, JsonArrayOpen, token, desc);
+        if (!json) {
+            goto error;
+        }
 
-void flecs_json_array_pop(
-    ecs_strbuf_t *buf);
+        char *first_name = NULL;
+        json = flecs_json_expect_string(json, token, &first_name, desc);
+        if (!json) {
+            goto error;
+        }
 
-void flecs_json_object_push(
-    ecs_strbuf_t *buf);
+        ecs_entity_t first = flecs_json_lookup(world, 0, first_name, desc);
+        if (first_name != token) {
+            ecs_os_free(first_name);
+        }
 
-void flecs_json_object_pop(
-    ecs_strbuf_t *buf);
+        if (!first) {
+            goto error;
+        }
 
-void flecs_json_string(
-    ecs_strbuf_t *buf,
-    const char *value);
+        json = flecs_json_parse(json, &token_kind, token);
+        if (token_kind == JsonComma) {
+            char *second_name = NULL;
+            json = flecs_json_expect_string(json, token, &second_name, desc);
+            if (!json) {
+                goto error;
+            }
 
-void flecs_json_string_escape(
-    ecs_strbuf_t *buf,
-    const char *value);
+            ecs_entity_t second = flecs_json_lookup(world, 0, second_name, desc);
+            if (second_name != token) {
+                ecs_os_free(second_name);
+            }
 
-void flecs_json_member(
-    ecs_strbuf_t *buf,
-    const char *name);
+            if (!second) {
+                goto error;
+            }
 
-void flecs_json_membern(
-    ecs_strbuf_t *buf,
-    const char *name,
-    int32_t name_len);
+            id = ecs_pair(first, second);
 
-#define flecs_json_memberl(buf, name)\
-    flecs_json_membern(buf, name, sizeof(name) - 1)
+            json = flecs_json_expect(json, JsonArrayClose, token, desc);
+            if (!json) {
+                goto error;
+            }
+        } else if (token_kind == JsonArrayClose) {
+            id = first;
+        } else {
+            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+                "expected ',' or ']");
+            goto error;
+        }
 
-void flecs_json_path(
-    ecs_strbuf_t *buf,
-    const ecs_world_t *world,
-    ecs_entity_t e);
+        ecs_vec_append_t(ctx->a, &ctx->result_ids, ecs_id_t)[0] = id;
 
-void flecs_json_label(
-    ecs_strbuf_t *buf,
-    const ecs_world_t *world,
-    ecs_entity_t e);
+        const char *lah = flecs_json_parse(json, &token_kind, token);
+        if (token_kind == JsonComma) {
+            json = lah;
+        } else if (token_kind == JsonArrayClose) {
+            break;
+        } else {
+            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+                "expected ',' or ']'");
+            goto error;
+        }
+    } while (json[0]);
 
-void flecs_json_color(
-    ecs_strbuf_t *buf,
-    const ecs_world_t *world,
-    ecs_entity_t e);
+    /* Make a copy of the ids array because we need the original order for 
+     * deserializing the component values, and the sorted order for finding or
+     * creating the table. */
+    ecs_vec_t id_copy = ecs_vec_copy_t(ctx->a, &ctx->result_ids, ecs_id_t);
+    ecs_type_t type = { 
+        .array = ecs_vec_first(&id_copy),
+        .count = ecs_vec_count(&id_copy)
+    };
 
-void flecs_json_id(
-    ecs_strbuf_t *buf,
-    const ecs_world_t *world,
-    ecs_id_t id);
+    qsort(type.array, flecs_itosize(type.count), sizeof(ecs_id_t), 
+        flecs_id_qsort_cmp);
 
-void flecs_json_id_member(
-    ecs_strbuf_t *buf,
-    const ecs_world_t *world,
-    ecs_id_t id);
+    ecs_table_t *table = flecs_table_find_or_create(world, &type);
+    if (!table) {
+        goto error;
+    }
 
-ecs_primitive_kind_t flecs_json_op_to_primitive_kind(
-    ecs_meta_type_op_kind_t kind);
+    ecs_vec_fini_t(ctx->a, &id_copy, ecs_id_t);
 
-bool flecs_json_serialize_get_field_ctx(
-    const ecs_world_t *world,
-    const ecs_iter_t *it,
-    int32_t f,
-    ecs_json_ser_ctx_t *ser_ctx);
+    return table;
+error:
+    return NULL;
+}
 
-int flecs_json_serialize_iter_result_rows(
-    const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc,
-    ecs_json_ser_ctx_t *ser_ctx);
+static
+void flecs_json_zeromem_table(
+    ecs_table_t *table)
+{
+    int32_t count = ecs_vec_count(&table->data.entities);
+    int32_t i, column_count = table->column_count;
+    for (i = 0; i < column_count; i ++) {
+        ecs_column_t *column = &table->data.columns[i];
+        ecs_type_info_t *ti = column->ti;
+        if (!ti->hooks.ctor) {
+            void *ptr = ecs_vec_first(&column->data);
+            ecs_os_memset(ptr, 0, ti->size * count);
+        }
+    }
+}
 
-bool flecs_json_serialize_iter_result_is_set(
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf);
+static
+int flecs_json_parse_entities(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_entity_t parent,
+    const char *json,
+    char *token,
+    ecs_from_json_ctx_t *ctx,
+    const ecs_from_json_desc_t *desc)
+{
+    char name_token[ECS_MAX_TOKEN_SIZE];
+    ecs_json_token_t token_kind = 0;
+    ecs_vec_clear(&ctx->records);
 
-bool flecs_json_skip_variable(
-    const char *name);
+    do {
+        char *name = NULL;
+        json = flecs_json_parse(json, &token_kind, name_token);
+        if (!json) {
+            goto error;
+        }
 
-void flecs_json_serialize_field(
-    const ecs_world_t *world,
-    const ecs_iter_t *it,
-    const ecs_filter_t *q,
-    int field,
-    ecs_strbuf_t *buf,
-    ecs_json_ser_ctx_t *ctx);
+        if (token_kind == JsonLargeString) {
+            ecs_strbuf_t large_token = ECS_STRBUF_INIT;
+            json = flecs_json_parse_large_string(json, &large_token);
+            if (!json) {
+                break;
+            }
 
-void flecs_json_serialize_query(
-    const ecs_world_t *world,
-    const ecs_filter_t *q,
-    ecs_strbuf_t *buf);
+            name = ecs_strbuf_get(&large_token);
+            token_kind = JsonString;
+        } else {
+            name = name_token;
+        }
 
-int flecs_json_ser_type(
-    const ecs_world_t *world,
-    const ecs_vec_t *ser,
-    const void *base,
-    ecs_strbuf_t *str);
+        if ((token_kind != JsonNumber) && (token_kind != JsonString)) {
+            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+                "expected number or string");
+            goto error;
+        }
 
-#endif
+        ecs_entity_t e = flecs_json_lookup(world, parent, name, desc);
+        ecs_record_t *r = flecs_entities_try(world, e);
+        ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
 
-#endif /* FLECS_JSON_PRIVATE_H */
+        if (r->table != table) {
+            bool cleared = false;
+            if (r->table) {
+                ecs_commit(world, e, r, r->table, NULL, &r->table->type);
+                cleared = true;
+            }
 
-#include <ctype.h>
+            ecs_commit(world, e, r, table, &table->type, NULL);
+            if (cleared) {
+                char *entity_name = strrchr(name, '.');
+                if (entity_name) {
+                    entity_name ++;
+                } else {
+                    entity_name = name;
+                }
+                if (!flecs_json_name_is_anonymous(entity_name)) {
+                    ecs_set_name(world, e, entity_name);
+                }
+            }
+        }
 
-#ifdef FLECS_JSON
+        if (name != name_token) {
+            ecs_os_free(name);
+        }
 
-typedef struct {
-    ecs_allocator_t *a;
-    ecs_vec_t records;
-    ecs_vec_t result_ids;
-    ecs_vec_t columns_set;
-    ecs_map_t anonymous_ids;
-    ecs_map_t missing_reflection;
-} ecs_from_json_ctx_t;
+        if (table != r->table) {
+            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+                "invalid entity identifier");
+            goto error;
+        } else {
+            ecs_assert(table == r->table, ECS_INTERNAL_ERROR, NULL);
+            ecs_record_t** elem = ecs_vec_append_t(
+                ctx->a, &ctx->records, ecs_record_t*);
+            *elem = r;
+        }
 
-static
-void flecs_from_json_ctx_init(
-    ecs_allocator_t *a,
-    ecs_from_json_ctx_t *ctx)
-{
-    ctx->a = a;
-    ecs_vec_init_t(a, &ctx->records, ecs_record_t*, 0);
-    ecs_vec_init_t(a, &ctx->result_ids, ecs_id_t, 0);
-    ecs_vec_init_t(a, &ctx->columns_set, ecs_id_t, 0);
-    ecs_map_init(&ctx->anonymous_ids, a);
-    ecs_map_init(&ctx->missing_reflection, a);
-}
+        json = flecs_json_parse(json, &token_kind, token);
+        if (token_kind == JsonArrayClose) {
+            break;
+        } else if (token_kind != JsonComma) {
+            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+                "expected ',' or ']'");
+            goto error;
+        }
+    } while(json[0]);
 
-static
-void flecs_from_json_ctx_fini(
-    ecs_from_json_ctx_t *ctx)
-{
-    ecs_vec_fini_t(ctx->a, &ctx->records, ecs_record_t*);
-    ecs_vec_fini_t(ctx->a, &ctx->result_ids, ecs_record_t*);
-    ecs_vec_fini_t(ctx->a, &ctx->columns_set, ecs_id_t);
-    ecs_map_fini(&ctx->anonymous_ids);
-    ecs_map_fini(&ctx->missing_reflection);
+    return 0;
+error:
+    return -1;
 }
 
 static
-const char* flecs_json_parse_path(
-    const ecs_world_t *world,
+const char* flecs_json_missing_reflection(
+    ecs_world_t *world,
+    ecs_id_t id,
     const char *json,
     char *token,
-    ecs_entity_t *out,
+    ecs_from_json_ctx_t *ctx,
     const ecs_from_json_desc_t *desc)
 {
-    char *path = NULL;
-    json = flecs_json_expect_string(json, token, &path, desc);
-    if (!json) {
-        goto error;
-    }
-
-    ecs_entity_t result = ecs_lookup(world, path);
-    if (!result) {
-        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-            "unresolved identifier '%s'", path);
-        goto error;
+    if (!desc->strict && ecs_map_get(&ctx->missing_reflection, id)) {
+        json = flecs_json_skip_array(json, token, desc);
+        goto done;
     }
 
-    *out = result;
+    /* Don't spam log when multiple values of a type can't be deserialized */
+    ecs_map_ensure(&ctx->missing_reflection, id);
 
-    if (path != token) {
-        ecs_os_free(path);
-    }
+    char *id_str = ecs_id_str(world, id);
+    ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+        "missing reflection for '%s'", id_str);
+    ecs_os_free(id_str);
 
-    return json;
-error:
-    if (path != token) {
-        ecs_os_free(path);
+done:
+    if (desc->strict) {
+        return NULL;
+    } else {
+        return flecs_json_skip_array(json, token, desc);
     }
-
-    return NULL;
 }
 
-const char* ecs_ptr_from_json(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    void *ptr,
+static
+const char* flecs_json_parse_column(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_id_t id,
     const char *json,
+    char *token,
+    ecs_from_json_ctx_t *ctx,
     const ecs_from_json_desc_t *desc)
 {
-    ecs_json_token_t token_kind = 0;
-    char token_buffer[ECS_MAX_TOKEN_SIZE], t_lah[ECS_MAX_TOKEN_SIZE];
-    char *token = token_buffer;
-    int depth = 0;
+    /* If deserializing id caused trouble before, don't bother trying again */
+    if (!desc->strict && ecs_map_get(&ctx->missing_reflection, id)) {
+        return flecs_json_skip_array(json, token, desc);
+    }
 
-    const char *name = NULL;
-    const char *expr = NULL;
+    ecs_table_record_t *tr = flecs_table_record_get(world, table, id);
+    /* Table was created with this id, it should exist */
+    ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, ptr);
-    if (cur.valid == false) {
-        return NULL;
+    /* If id is not a component, reflection data is missing */
+    int32_t column_index = tr->column;
+    if (column_index == -1) {
+        return flecs_json_missing_reflection(world, id, json, token, ctx, desc);
     }
 
-    if (desc) {
-        name = desc->name;
-        expr = desc->expr;
-        cur.lookup_action = desc->lookup_action;
-        cur.lookup_ctx = desc->lookup_ctx;
-    }
+    ecs_json_token_t token_kind = 0;
+    ecs_column_t *column = &table->data.columns[column_index];
+    ecs_type_info_t *ti = column->ti;
+    ecs_size_t size = ti->size;
+    ecs_entity_t type = ti->component;
 
-    while ((json = flecs_json_parse(json, &token_kind, token))) {
-        if (token_kind == JsonLargeString) {
-            ecs_strbuf_t large_token = ECS_STRBUF_INIT;
-            json = flecs_json_parse_large_string(json, &large_token);
-            if (!json) {
+    ecs_record_t **record_array = ecs_vec_first_t(&ctx->records, ecs_record_t*);
+    int32_t entity = 0;
+    bool values_set = false;
+    const char *values_start = json;
+
+    do {
+        ecs_record_t *r = record_array[entity];
+        int32_t row = ECS_RECORD_TO_ROW(r->row);
+
+        void *ptr = ecs_vec_get(&column->data, size, row);
+        ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        json = ecs_ptr_from_json(world, type, ptr, json, desc);
+        if (!json) {
+            if (desc->strict) {
                 break;
+            } else {
+                return flecs_json_missing_reflection(
+                    world, id, values_start, token, ctx, desc);
             }
+        } else {
+            values_set = true;
+        }
 
-            token = ecs_strbuf_get(&large_token);
-            token_kind = JsonString;
+        json = flecs_json_parse(json, &token_kind, token);
+        if (token_kind == JsonArrayClose) {
+            break;
+        } else if (token_kind != JsonComma) {
+            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+                "expected ',' or ']'");
         }
 
-        if (token_kind == JsonObjectOpen) {
-            depth ++;
-            if (ecs_meta_push(&cur) != 0) {
-                goto error;
-            }
+        entity ++;
+    } while (json[0]);
 
-            if (ecs_meta_is_collection(&cur)) {
-                ecs_parser_error(name, expr, json - expr, "expected '['");
-                return NULL;
-            }
-        } else if (token_kind == JsonObjectClose) {
-            depth --;
+    if (values_set) {
+        ecs_id_t *id_set = ecs_vec_append_t(
+            ctx->a, &ctx->columns_set, ecs_id_t);
+        *id_set = id;
+    }
 
-            if (ecs_meta_is_collection(&cur)) {
-                ecs_parser_error(name, expr, json - expr, "expected ']'");
-                return NULL;
-            }
+    return json;
+}
+
+static
+const char* flecs_json_parse_values(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    const char *json,
+    char *token,
+    ecs_from_json_ctx_t *ctx,
+    const ecs_from_json_desc_t *desc)
+{
+    ecs_json_token_t token_kind = 0;
+    int32_t value = 0;
 
-            if (ecs_meta_pop(&cur) != 0) {
-                goto error;
-            }
-        } else if (token_kind == JsonArrayOpen) {
-            depth ++;
-            if (ecs_meta_push(&cur) != 0) {
-                goto error;
-            }
+    ecs_vec_clear(&ctx->columns_set);
 
-            if (!ecs_meta_is_collection(&cur)) {
-                ecs_parser_error(name, expr, json - expr, "expected '{'");
-                return NULL;
-            }
-        } else if (token_kind == JsonArrayClose) {
-            depth --;
+    do {
+        if (value >= table->type.count) {
+            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+                "more elements in values array than expected for table");
+            goto error;
+        }
 
-            if (!ecs_meta_is_collection(&cur)) {
-                ecs_parser_error(name, expr, json - expr, "expected '}'");
-                return NULL;
-            }
+        json = flecs_json_parse(json, &token_kind, token);
+        if (!json) {
+            goto error;
+        }
 
-            if (ecs_meta_pop(&cur) != 0) {
-                goto error;
-            }
-        } else if (token_kind == JsonComma) {
-            if (ecs_meta_next(&cur) != 0) {
-                goto error;
-            }
-        } else if (token_kind == JsonNull) {
-            if (ecs_meta_set_null(&cur) != 0) {
+        if (token_kind == JsonArrayClose) {
+            break;
+        } else if (token_kind == JsonArrayOpen) {
+            ecs_id_t *idptr = ecs_vec_get_t(&ctx->result_ids, ecs_id_t, value);
+            ecs_assert(idptr != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_id_t id = idptr[0];
+            
+            json = flecs_json_parse_column(world, table, id,
+                json, token, ctx, desc);
+            if (!json) {
                 goto error;
             }
-        } else if (token_kind == JsonString) {
-            const char *lah = flecs_json_parse(
-                json, &token_kind, t_lah);
-            if (token_kind == JsonColon) {
-                /* Member assignment */
-                json = lah;
-                if (ecs_meta_dotmember(&cur, token) != 0) {
-                    goto error;
-                }
-            } else {
-                if (ecs_meta_set_string(&cur, token) != 0) {
-                    goto error;
-                }
-            }
         } else if (token_kind == JsonNumber) {
-            double number = atof(token);
-            if (ecs_meta_set_float(&cur, number) != 0) {
-                goto error;
-            }
-        } else if (token_kind == JsonLargeInt) {
-            int64_t number = flecs_ito(int64_t, atoll(token));
-            if (ecs_meta_set_int(&cur, number) != 0) {
-                goto error;
-            }
-        } else if (token_kind == JsonNull) {
-            if (ecs_meta_set_null(&cur) != 0) {
-                goto error;
-            }
-        } else if (token_kind == JsonTrue) {
-            if (ecs_meta_set_bool(&cur, true) != 0) {
-                goto error;
-            }
-        } else if (token_kind == JsonFalse) {
-            if (ecs_meta_set_bool(&cur, false) != 0) {
+            if (!ecs_os_strcmp(token, "0")) {
+                /* no data */
+            } else {
+                ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+                    "unexpected number");
                 goto error;
             }
-        } else {
-            goto error;
         }
 
-        if (token != token_buffer) {
-            ecs_os_free(token);
-            token = token_buffer;
+        json = flecs_json_parse(json, &token_kind, token);
+        if (token_kind == JsonArrayClose) {
+            break;
+        } else if (token_kind != JsonComma) {
+            ecs_parser_error(desc->name, desc->expr, json - desc->expr,
+                    "expected ',' or ']'");
+            goto error;
         }
 
-        if (!depth) {
-            break;
+        value ++;
+    } while (json[0]);
+
+    /* Send OnSet notifications */
+    ecs_defer_begin(world);
+    ecs_type_t type = { 
+        .array = ctx->columns_set.array, 
+        .count = ctx->columns_set.count };
+
+    int32_t table_count = ecs_table_count(table);
+    int32_t i, record_count = ecs_vec_count(&ctx->records);
+
+    /* If the entire table was inserted, send bulk notification */
+    if (table_count == ecs_vec_count(&ctx->records)) {
+        flecs_notify_on_set(
+            world, table, 0, ecs_table_count(table), &type, true);
+    } else {
+        ecs_record_t **rvec = ecs_vec_first_t(&ctx->records, ecs_record_t*);
+        for (i = 0; i < record_count; i ++) {
+            ecs_record_t *r = rvec[i];
+            int32_t row = ECS_RECORD_TO_ROW(r->row);
+            flecs_notify_on_set(world, table, row, 1, &type, true);
         }
     }
 
+    ecs_defer_end(world);
+
     return json;
 error:
     return NULL;
 }
 
-const char* ecs_entity_from_json(
+static
+const char* flecs_json_parse_result(
     ecs_world_t *world,
-    ecs_entity_t e,
     const char *json,
-    const ecs_from_json_desc_t *desc_param)
+    char *token,
+    ecs_from_json_ctx_t *ctx,
+    const ecs_from_json_desc_t *desc)
 {
     ecs_json_token_t token_kind = 0;
-    char token[ECS_MAX_TOKEN_SIZE];
+    const char *ids = NULL, *values = NULL, *entities = NULL;
 
-    ecs_from_json_desc_t desc = {0};
+    json = flecs_json_expect(json, JsonObjectOpen, token, desc);
+    if (!json) {
+        goto error;
+    }
 
-    const char *name = NULL, *expr = json, *ids = NULL, *values = NULL, *lah;
-    if (desc_param) {
-        desc = *desc_param;
+    json = flecs_json_expect_member_name(json, token, "ids", desc);
+    if (!json) {
+        goto error;
     }
 
-    json = flecs_json_expect(json, JsonObjectOpen, token, &desc);
+    json = flecs_json_expect(json, JsonArrayOpen, token, desc);
     if (!json) {
         goto error;
     }
 
-    lah = flecs_json_parse(json, &token_kind, token);
-    if (!lah) {
+    ids = json; /* store start of ids array */
+
+    json = flecs_json_skip_array(json, token, desc);
+    if (!json) {
         goto error;
     }
 
-    if (token_kind == JsonObjectClose) {
-        return lah;
+    json = flecs_json_expect(json, JsonComma, token, desc);
+    if (!json) {
+        goto error;
     }
 
-    json = flecs_json_expect_member(json, token, &desc);
+    json = flecs_json_expect_member(json, token, desc);
     if (!json) {
-        return NULL;
+        goto error;
     }
 
-    if (!ecs_os_strcmp(token, "path")) {
-        char *path = NULL;
-        json = flecs_json_expect_string(json, token, &path, &desc);
+    ecs_entity_t parent = 0;
+    if (!ecs_os_strcmp(token, "parent")) {
+        char *parent_name = NULL;
+        json = flecs_json_expect_string(json, token, &parent_name, desc);
         if (!json) {
             goto error;
         }
 
-        ecs_add_fullpath(world, e, path);
-
-        if (path != token) {
-            ecs_os_free(path);
+        parent = flecs_json_lookup(world, 0, parent_name, desc);
+        if (parent_name != token) {
+            ecs_os_free(parent_name);
         }
 
-        json = flecs_json_parse(json, &token_kind, token);
+        json = flecs_json_expect(json, JsonComma, token, desc);
         if (!json) {
             goto error;
         }
 
-        if (token_kind == JsonObjectClose) {
-            return json;
-        } else if (token_kind != JsonComma) {
-            ecs_parser_error(name, expr, json - expr, "unexpected character");
-            goto error;
-        }
-
-        json = flecs_json_expect_member_name(json, token, "ids", &desc);
+        json = flecs_json_expect_member(json, token, desc);
         if (!json) {
             goto error;
         }
-    } else if (ecs_os_strcmp(token, "ids")) {
-        ecs_parser_error(name, expr, json - expr, "expected member 'ids'");
+    }
+
+    if (ecs_os_strcmp(token, "entities")) {
+        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+            "expected 'entities'");
         goto error;
     }
 
-    json = flecs_json_expect(json, JsonArrayOpen, token, &desc);
+    json = flecs_json_expect(json, JsonArrayOpen, token, desc);
     if (!json) {
         goto error;
     }
 
-    ids = json;
+    entities = json; /* store start of entity id array */
 
-    json = flecs_json_skip_array(json, token, &desc);
+    json = flecs_json_skip_array(json, token, desc);
     if (!json) {
-        return NULL;
+        goto error;
     }
 
     json = flecs_json_parse(json, &token_kind, token);
-    if (token_kind != JsonObjectClose) {
-        if (token_kind != JsonComma) {
-            ecs_parser_error(name, expr, json - expr, "expected ','");
-            goto error;
-        }
-
-        json = flecs_json_expect_member_name(json, token, "values", &desc);
+    if (token_kind == JsonComma) {
+        json = flecs_json_expect_member_name(json, token, "values", desc);
         if (!json) {
             goto error;
         }
 
-        json = flecs_json_expect(json, JsonArrayOpen, token, &desc);
+        json = flecs_json_expect(json, JsonArrayOpen, token, desc);
         if (!json) {
             goto error;
         }
 
-        values = json;
+        values = json; /* store start of entities array */
+    } else if (token_kind != JsonObjectClose) {
+        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+            "expected ',' or '}'");
+        goto error;
     }
 
-    do {
-        ecs_entity_t first = 0, second = 0, type_id = 0;
-        ecs_id_t id;
-
-        ids = flecs_json_parse(ids, &token_kind, token);
-        if (!ids) {
-            goto error;
-        }
-
-        if (token_kind == JsonArrayClose) {
-            if (values) {
-                if (values[0] != ']') {
-                    ecs_parser_error(name, expr, values - expr, "expected ']'");
-                    goto error;
-                }
-                json = ecs_parse_ws_eol(values + 1);
-            } else {
-                json = ids;
-            }
-
-            break;
-        } else if (token_kind == JsonArrayOpen) {
-            ids = flecs_json_parse_path(world, ids, token, &first, &desc);
-            if (!ids) {
-                goto error;
-            }
-
-            ids = flecs_json_parse(ids, &token_kind, token);
-            if (!ids) {
-                goto error;
-            }
-
-            if (token_kind == JsonComma) {
-                /* Id is a pair*/
-                ids = flecs_json_parse_path(world, ids, token, &second, &desc);
-                if (!ids) {
-                    goto error;
-                }
-
-                ids = flecs_json_expect(ids, JsonArrayClose, token, &desc);
-                if (!ids) {
-                    goto error;
-                }
-            } else if (token_kind != JsonArrayClose) {
-                ecs_parser_error(name, expr, ids - expr, "expected ',' or ']'");
-                goto error;
-            }
-
-            lah = flecs_json_parse(ids, &token_kind, token);
-            if (!lah) {
-                goto error;
-            }
+    /* Find table from ids */
+    ecs_table_t *table = flecs_json_parse_table(world, ids, token, ctx, desc);
+    if (!table) {
+        goto error;
+    }
 
-            if (token_kind == JsonComma) {
-                ids = lah;
-            } else if (token_kind != JsonArrayClose) {
-                ecs_parser_error(name, expr, lah - expr, "expected ',' or ']'");
-                goto error;
-            }
-        } else {
-            ecs_parser_error(name, expr, lah - expr, "expected '[' or ']'");
-            goto error;
-        }
+    /* Add entities to table */
+    if (flecs_json_parse_entities(world, table, parent,
+        entities, token, ctx, desc)) 
+    {
+        goto error;
+    }
 
-        if (second) {
-            id = ecs_pair(first, second);
-            type_id = ecs_get_typeid(world, id);
-            if (!type_id) {
-                ecs_parser_error(name, expr, ids - expr, "id is not a type");
-                goto error;
-            }
-        } else {
-            id = first;
-            type_id = first;
-        }
+    /* If not parsing in strict mode, initialize component arrays to 0. This
+     * ensures that even if components can't be deserialized (because of 
+     * incomplete reflection data) component values aren't left uninitialized */
+    if (!desc->strict) {
+        flecs_json_zeromem_table(table);
+    }
 
-        /* Get mutable pointer */
-        void *comp_ptr = ecs_ensure_id(world, e, id);
-        if (!comp_ptr) {
-            char *idstr = ecs_id_str(world, id);
-            ecs_parser_error(name, expr, json - expr, 
-                "id '%s' is not a valid component", idstr);
-            ecs_os_free(idstr);
+    /* Parse values */
+    if (values) {
+        json = flecs_json_parse_values(world, table, values, token, ctx, desc);
+        if (!json) {
             goto error;
         }
 
-        if (values) {
-            ecs_from_json_desc_t parse_desc = {
-                .name = name,
-                .expr = expr,
-            };
-
-            values = ecs_ptr_from_json(
-                world, type_id, comp_ptr, values, &parse_desc);
-            if (!values) {
+        json = flecs_json_parse(json, &token_kind, token);
+        if (token_kind == JsonComma) {
+            json = flecs_json_expect_member_name(json, token, "alerts", desc);
+            if (!json) {
                 goto error;
             }
 
-            lah = flecs_json_parse(values, &token_kind, token);
-            if (!lah) {
+            json = flecs_json_expect(json, JsonBoolean, token, desc);
+            if (!json) {
                 goto error;
             }
 
-            if (token_kind == JsonComma) {
-                values = lah;
-            } else if (token_kind != JsonArrayClose) {
-                ecs_parser_error(name, expr, json - expr, 
-                    "expected ',' or ']'");
+            json = flecs_json_expect(json, JsonObjectClose, token, desc);
+            if (!json) {
                 goto error;
-            } else {
-                values = ecs_parse_ws_eol(values);
             }
-
-            ecs_modified_id(world, e, id);
+        } else if (token_kind != JsonObjectClose) {
+            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+                "expected '}'");
+            goto error;
         }
-    } while(ids[0]);
+    }
 
-    return flecs_json_expect(json, JsonObjectClose, token, &desc);
+    return json;
 error:
     return NULL;
 }
 
-static
-ecs_entity_t flecs_json_new_id(
+const char* ecs_world_from_json(
     ecs_world_t *world,
-    ecs_entity_t ser_id)
+    const char *json,
+    const ecs_from_json_desc_t *desc_arg)
 {
-    /* Try to honor low id requirements */
-    if (ser_id < FLECS_HI_COMPONENT_ID) {
-        return ecs_new_low_id(world);
-    } else {
-        return ecs_new_id(world);
-    }
-}
+    ecs_json_token_t token_kind;
+    char token[ECS_MAX_TOKEN_SIZE];
 
-static
-ecs_entity_t flecs_json_lookup(
-    ecs_world_t *world,
-    ecs_entity_t parent,
-    const char *name,
-    const ecs_from_json_desc_t *desc)
-{
-    ecs_entity_t scope = 0;
-    if (parent) {
-        scope = ecs_set_scope(world, parent);
-    }
-    ecs_entity_t result = desc->lookup_action(world, name, desc->lookup_ctx);
-    if (parent) {
-        ecs_set_scope(world, scope);
+    ecs_from_json_desc_t desc = {0};
+    ecs_allocator_t *a = &world->allocator;
+    ecs_from_json_ctx_t ctx;
+    flecs_from_json_ctx_init(a, &ctx);
+
+    const char *name = NULL, *expr = json, *lah;
+    if (desc_arg) {
+        desc = *desc_arg;
     }
-    return result;
-}
 
-static
-void flecs_json_mark_reserved(
-    ecs_map_t *anonymous_ids,
-    ecs_entity_t e)
-{
-    ecs_entity_t *reserved = ecs_map_ensure(anonymous_ids, e);
-    ecs_assert(reserved[0] == 0, ECS_INTERNAL_ERROR, NULL);
-    reserved[0] = 0;
-}
+    if (!desc.lookup_action) {
+        desc.lookup_action = (ecs_entity_t(*)(
+            const ecs_world_t*, const char*, void*))flecs_json_ensure_entity;
+        desc.lookup_ctx = &ctx.anonymous_ids;
+    }
 
-static
-bool flecs_json_name_is_anonymous(
-    const char *name)
-{
-    ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL);
-    if (isdigit(name[0])) {
-        const char *ptr;
-        for (ptr = name + 1; *ptr; ptr ++) {
-            if (!isdigit(*ptr)) {
-                break;
-            }
-        }
-        if (!(*ptr)) {
-            return true;
-        }
+    json = flecs_json_expect(json, JsonObjectOpen, token, &desc);
+    if (!json) {
+        goto error;
     }
-    return false;
-}
 
-static
-ecs_entity_t flecs_json_ensure_entity(
-    ecs_world_t *world,
-    const char *name,
-    ecs_map_t *anonymous_ids)
-{
-    ecs_entity_t e = 0;
+    json = flecs_json_expect_member_name(json, token, "results", &desc);
+    if (!json) {
+        goto error;
+    }
 
-    if (flecs_json_name_is_anonymous(name)) {
-        /* Anonymous entity, find or create mapping to new id */
-        ecs_entity_t ser_id = flecs_ito(ecs_entity_t, atoll(name));
-        ecs_entity_t *deser_id = ecs_map_get(anonymous_ids, ser_id);
-        if (deser_id) {
-            if (!deser_id[0]) {
-                /* Id is already issued by deserializer, create new id */
-                deser_id[0] = flecs_json_new_id(world, ser_id);
+    json = flecs_json_expect(json, JsonArrayOpen, token, &desc);
+    if (!json) {
+        goto error;
+    }
 
-                /* Mark new id as reserved */
-                flecs_json_mark_reserved(anonymous_ids, deser_id[0]);
-            } else {
-                /* Id mapping exists */
-            }
-        } else {
-            /* Id has not yet been issued by deserializer, which means it's safe
-             * to use. This allows the deserializer to bind to existing 
-             * anonymous ids, as they will never be reissued. */
-            deser_id = ecs_map_ensure(anonymous_ids, ser_id);
-            if (!ecs_exists(world, ser_id) || 
-               (ecs_is_alive(world, ser_id) && !ecs_get_name(world, ser_id))) 
-            {
-                /* Only use existing id if it's alive or doesn't exist yet. The 
-                 * id could have been recycled for another entity 
-                 * Also don't use existing id if the existing entity is not
-                 * anonymous. */
-                deser_id[0] = ser_id;
-                ecs_make_alive(world, ser_id);
-            } else {
-                /* If id exists and is not alive, create a new id */
-                deser_id[0] = flecs_json_new_id(world, ser_id);
+    lah = flecs_json_parse(json, &token_kind, token);
+    if (token_kind == JsonArrayClose) {
+        json = lah;
+        goto end;
+    }
 
-                /* Mark new id as reserved */
-                flecs_json_mark_reserved(anonymous_ids, deser_id[0]);
-            }
+    do {
+        json = flecs_json_parse_result(world, json, token, &ctx, &desc);
+        if (!json) {
+            goto error;
         }
 
-        e = deser_id[0];
-    } else {
-        e = ecs_lookup_path_w_sep(world, 0, name, ".", NULL, false);
-        if (!e) {
-            e = ecs_entity(world, { .name = name });
-            flecs_json_mark_reserved(anonymous_ids, e);
+        json = flecs_json_parse(json, &token_kind, token);
+        if (token_kind == JsonArrayClose) {
+            break;
+        } else if (token_kind != JsonComma) {
+            ecs_parser_error(name, expr, json - expr,
+                    "expected ',' or ']'");
+            goto error;
         }
+    } while(json && json[0]);
+
+end:
+    flecs_from_json_ctx_fini(&ctx);
+
+    json = flecs_json_expect(json, JsonObjectClose, token, &desc);
+    if (!json) {
+        goto error;
     }
 
-    return e;
+    return json;
+error:
+    flecs_from_json_ctx_fini(&ctx);
+    return NULL;
 }
 
-static
-ecs_table_t* flecs_json_parse_table(
+const char* ecs_world_from_json_file(
     ecs_world_t *world,
-    const char *json,
-    char *token,
-    ecs_from_json_ctx_t *ctx,
+    const char *filename,
     const ecs_from_json_desc_t *desc)
 {
-    ecs_json_token_t token_kind = 0;
+    char *json = flecs_load_from_file(filename);
+    if (!json) {
+        ecs_err("file not found: %s", filename);
+        return NULL;
+    }
 
-    ecs_vec_clear(&ctx->result_ids);
+    const char *result = ecs_world_from_json(world, json, desc);
+    ecs_os_free(json);
+    return result;
+}
 
-    do {
-        ecs_id_t id = 0;
-        json = flecs_json_expect(json, JsonArrayOpen, token, desc);
-        if (!json) {
-            goto error;
-        }
+#endif
 
-        char *first_name = NULL;
-        json = flecs_json_expect_string(json, token, &first_name, desc);
-        if (!json) {
-            goto error;
-        }
+/**
+ * @file json/json.c
+ * @brief JSON serializer utilities.
+ */
 
-        ecs_entity_t first = flecs_json_lookup(world, 0, first_name, desc);
-        if (first_name != token) {
-            ecs_os_free(first_name);
-        }
+#include <ctype.h>
 
-        if (!first) {
-            goto error;
-        }
+#ifdef FLECS_JSON
 
-        json = flecs_json_parse(json, &token_kind, token);
-        if (token_kind == JsonComma) {
-            char *second_name = NULL;
-            json = flecs_json_expect_string(json, token, &second_name, desc);
-            if (!json) {
-                goto error;
-            }
+static
+const char* flecs_json_token_str(
+    ecs_json_token_t token_kind)
+{
+    switch(token_kind) {
+    case JsonObjectOpen: return "{";
+    case JsonObjectClose: return "}";
+    case JsonArrayOpen: return "[";
+    case JsonArrayClose: return "]";
+    case JsonColon: return ":";
+    case JsonComma: return ",";
+    case JsonNumber: return "number";
+    case JsonLargeInt: return "large integer";
+    case JsonLargeString:
+    case JsonString: return "string";
+    case JsonBoolean: return "bool";
+    case JsonTrue: return "true";
+    case JsonFalse: return "false";
+    case JsonNull: return "null";
+    case JsonInvalid: return "invalid";
+    default:
+        ecs_throw(ECS_INTERNAL_ERROR, NULL);
+    }
+error:
+    return "<<invalid token kind>>";
+}
 
-            ecs_entity_t second = flecs_json_lookup(world, 0, second_name, desc);
-            if (second_name != token) {
-                ecs_os_free(second_name);
-            }
+const char* flecs_json_parse(
+    const char *json,
+    ecs_json_token_t *token_kind,
+    char *token)
+{
+    ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
+    json = flecs_parse_ws_eol(json);
 
-            if (!second) {
-                goto error;
-            }
+    char ch = json[0];
 
-            id = ecs_pair(first, second);
+    if (ch == '{') {
+        token_kind[0] = JsonObjectOpen;
+        return json + 1;
+    } else if (ch == '}') {
+        token_kind[0] = JsonObjectClose;
+        return json + 1;
+    } else if (ch == '[') {
+        token_kind[0] = JsonArrayOpen;
+        return json + 1;
+    } else if (ch == ']') {
+        token_kind[0] = JsonArrayClose;
+        return json + 1;
+    } else if (ch == ':') {
+        token_kind[0] = JsonColon;
+        return json + 1;
+    } else if (ch == ',') {
+        token_kind[0] = JsonComma;
+        return json + 1;
+    } else if (ch == '"') {
+        const char *start = json;
+        char *token_ptr = token;
+        json ++;
+        for (; (ch = json[0]); ) {
+            if (token_ptr - token >= ECS_MAX_TOKEN_SIZE) {
+                /* Token doesn't fit in buffer, signal to app to try again with
+                 * dynamic buffer. */
+                token_kind[0] = JsonLargeString;
+                return start;
+            }
 
-            json = flecs_json_expect(json, JsonArrayClose, token, desc);
-            if (!json) {
-                goto error;
+            if (ch == '"') {
+                json ++;
+                token_ptr[0] = '\0';
+                break;
             }
-        } else if (token_kind == JsonArrayClose) {
-            id = first;
-        } else {
-            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "expected ',' or ']");
-            goto error;
-        }
 
-        ecs_vec_append_t(ctx->a, &ctx->result_ids, ecs_id_t)[0] = id;
+            json = flecs_chrparse(json, token_ptr ++);
+        }
 
-        const char *lah = flecs_json_parse(json, &token_kind, token);
-        if (token_kind == JsonComma) {
-            json = lah;
-        } else if (token_kind == JsonArrayClose) {
-            break;
+        if (!ch) {
+            token_kind[0] = JsonInvalid;
+            return NULL;
         } else {
-            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "expected ',' or ']'");
-            goto error;
+            token_kind[0] = JsonString;
+            return json;
+        }
+    } else if (isdigit(ch) || (ch == '-')) {
+        token_kind[0] = JsonNumber;
+        const char *result = flecs_parse_digit(json, token);
+        
+        /* Cheap initial check if parsed token could represent large int */
+        if (result - json > 15) {
+            /* Less cheap secondary check to see if number is integer */
+            if (!strchr(token, '.')) {
+                token_kind[0] = JsonLargeInt;
+            }
         }
-    } while (json[0]);
 
-    /* Make a copy of the ids array because we need the original order for 
-     * deserializing the component values, and the sorted order for finding or
-     * creating the table. */
-    ecs_vec_t id_copy = ecs_vec_copy_t(ctx->a, &ctx->result_ids, ecs_id_t);
-    ecs_type_t type = { 
-        .array = ecs_vec_first(&id_copy),
-        .count = ecs_vec_count(&id_copy)
-    };
+        return result;
+    } else if (isalpha(ch)) {
+        if (!ecs_os_strncmp(json, "null", 4)) {
+            token_kind[0] = JsonNull;
+            json += 4;
+        } else
+        if (!ecs_os_strncmp(json, "true", 4)) {
+            token_kind[0] = JsonTrue;
+            json += 4;
+        } else
+        if (!ecs_os_strncmp(json, "false", 5)) {
+            token_kind[0] = JsonFalse;
+            json += 5;
+        }
 
-    qsort(type.array, flecs_itosize(type.count), sizeof(ecs_id_t), 
-        flecs_id_qsort_cmp);
+        if (isalpha(json[0]) || isdigit(json[0])) {
+            token_kind[0] = JsonInvalid;
+            return NULL;
+        }
 
-    ecs_table_t *table = flecs_table_find_or_create(world, &type);
-    if (!table) {
-        goto error;
+        return json;
+    } else {
+        token_kind[0] = JsonInvalid;
+        return NULL;
     }
-
-    ecs_vec_fini_t(ctx->a, &id_copy, ecs_id_t);
-
-    return table;
-error:
-    return NULL;
 }
 
-static
-void flecs_json_zeromem_table(
-    ecs_table_t *table)
+const char* flecs_json_parse_large_string(
+    const char *json,
+    ecs_strbuf_t *buf)
 {
-    int32_t count = ecs_vec_count(&table->data.entities);
-    int32_t i, column_count = table->column_count;
-    for (i = 0; i < column_count; i ++) {
-        ecs_column_t *column = &table->data.columns[i];
-        ecs_type_info_t *ti = column->ti;
-        if (!ti->hooks.ctor) {
-            void *ptr = ecs_vec_first(&column->data);
-            ecs_os_memset(ptr, 0, ti->size * count);
+    if (json[0] != '"') {
+        return NULL; /* can only parse strings */
+    }
+
+    char ch, ch_out;
+    json ++;
+    for (; (ch = json[0]); ) {
+        if (ch == '"') {
+            json ++;
+            break;
         }
+
+        json = flecs_chrparse(json, &ch_out);
+        ecs_strbuf_appendch(buf, ch_out);
+    }
+
+    if (!ch) {
+        return NULL;
+    } else {
+        return json;
     }
 }
 
-static
-int flecs_json_parse_entities(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_entity_t parent,
+const char* flecs_json_expect(
     const char *json,
+    ecs_json_token_t token_kind,
     char *token,
-    ecs_from_json_ctx_t *ctx,
     const ecs_from_json_desc_t *desc)
 {
-    char name_token[ECS_MAX_TOKEN_SIZE];
-    ecs_json_token_t token_kind = 0;
-    ecs_vec_clear(&ctx->records);
-
-    do {
-        char *name = NULL;
-        json = flecs_json_parse(json, &token_kind, name_token);
-        if (!json) {
-            goto error;
-        }
+    /* Strings must be handled by flecs_json_expect_string for LargeString */
+    ecs_assert(token_kind != JsonString, ECS_INTERNAL_ERROR, NULL);
 
-        if (token_kind == JsonLargeString) {
-            ecs_strbuf_t large_token = ECS_STRBUF_INIT;
-            json = flecs_json_parse_large_string(json, &large_token);
-            if (!json) {
-                break;
-            }
+    ecs_json_token_t kind = 0;
+    json = flecs_json_parse(json, &kind, token);
 
-            name = ecs_strbuf_get(&large_token);
-            token_kind = JsonString;
+    if (kind == JsonInvalid) {
+        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+            "invalid json");
+        return NULL;
+    } else if (kind != token_kind) {
+        if (token_kind == JsonBoolean && 
+            (kind == JsonTrue || kind == JsonFalse)) 
+        {
+            /* ok */
         } else {
-            name = name_token;
-        }
-
-        if ((token_kind != JsonNumber) && (token_kind != JsonString)) {
             ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "expected number or string");
-            goto error;
+                "expected %s, got %s",
+                flecs_json_token_str(token_kind), flecs_json_token_str(kind));
+            return NULL;
         }
+    }
 
-        ecs_entity_t e = flecs_json_lookup(world, parent, name, desc);
-        ecs_record_t *r = flecs_entities_try(world, e);
-        ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        if (r->table != table) {
-            bool cleared = false;
-            if (r->table) {
-                ecs_commit(world, e, r, r->table, NULL, &r->table->type);
-                cleared = true;
-            }
+    return json;
+}
 
-            ecs_commit(world, e, r, table, &table->type, NULL);
-            if (cleared) {
-                char *entity_name = strrchr(name, '.');
-                if (entity_name) {
-                    entity_name ++;
-                } else {
-                    entity_name = name;
-                }
-                if (!flecs_json_name_is_anonymous(entity_name)) {
-                    ecs_set_name(world, e, entity_name);
-                }
-            }
-        }
+const char* flecs_json_expect_string(
+    const char *json,
+    char *token,
+    char **out,
+    const ecs_from_json_desc_t *desc)
+{
+    ecs_json_token_t token_kind = 0;
+    json = flecs_json_parse(json, &token_kind, token);
+    if (token_kind == JsonInvalid) {
+        ecs_parser_error(
+            desc->name, desc->expr, json - desc->expr, "invalid json");
+        return NULL;
+    } else if (token_kind != JsonString && token_kind != JsonLargeString) {
+        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+            "expected string");
+        return NULL;
+    }
 
-        if (name != name_token) {
-            ecs_os_free(name);
+    if (token_kind == JsonLargeString) {
+        ecs_strbuf_t large_token = ECS_STRBUF_INIT;
+        json = flecs_json_parse_large_string(json, &large_token);
+        if (!json) {
+            return NULL;
         }
 
-        if (table != r->table) {
-            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "invalid entity identifier");
-            goto error;
+        if (out) {
+            *out = ecs_strbuf_get(&large_token);
         } else {
-            ecs_assert(table == r->table, ECS_INTERNAL_ERROR, NULL);
-            ecs_record_t** elem = ecs_vec_append_t(
-                ctx->a, &ctx->records, ecs_record_t*);
-            *elem = r;
-        }
-
-        json = flecs_json_parse(json, &token_kind, token);
-        if (token_kind == JsonArrayClose) {
-            break;
-        } else if (token_kind != JsonComma) {
-            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "expected ',' or ']'");
-            goto error;
+            ecs_strbuf_reset(&large_token);
         }
-    } while(json[0]);
+    } else if (out) {
+        *out = token;
+    }
 
-    return 0;
-error:
-    return -1;
+    return json;
 }
 
-static
-const char* flecs_json_missing_reflection(
-    ecs_world_t *world,
-    ecs_id_t id,
+const char* flecs_json_expect_member(
     const char *json,
     char *token,
-    ecs_from_json_ctx_t *ctx,
     const ecs_from_json_desc_t *desc)
 {
-    if (!desc->strict && ecs_map_get(&ctx->missing_reflection, id)) {
-        json = flecs_json_skip_array(json, token, desc);
-        goto done;
+    char *out = NULL;
+    json = flecs_json_expect_string(json, token, &out, desc);
+    if (!json) {
+        return NULL;
     }
 
-    /* Don't spam log when multiple values of a type can't be deserialized */
-    ecs_map_ensure(&ctx->missing_reflection, id);
-
-    char *id_str = ecs_id_str(world, id);
-    ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-        "missing reflection for '%s'", id_str);
-    ecs_os_free(id_str);
+    if (out != token) {
+        ecs_os_free(out);
+    }
 
-done:
-    if (desc->strict) {
+    json = flecs_json_expect(json, JsonColon, token, desc);
+    if (!json) {
         return NULL;
-    } else {
-        return flecs_json_skip_array(json, token, desc);
     }
+    return json;
 }
 
-static
-const char* flecs_json_parse_column(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_id_t id,
+const char* flecs_json_expect_member_name(
     const char *json,
     char *token,
-    ecs_from_json_ctx_t *ctx,
+    const char *member_name,
     const ecs_from_json_desc_t *desc)
 {
-    /* If deserializing id caused trouble before, don't bother trying again */
-    if (!desc->strict && ecs_map_get(&ctx->missing_reflection, id)) {
-        return flecs_json_skip_array(json, token, desc);
+    json = flecs_json_expect_member(json, token, desc);
+    if (!json) {
+        return NULL;
     }
-
-    ecs_table_record_t *tr = flecs_table_record_get(world, table, id);
-    /* Table was created with this id, it should exist */
-    ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    /* If id is not a component, reflection data is missing */
-    int32_t column_index = tr->column;
-    if (column_index == -1) {
-        return flecs_json_missing_reflection(world, id, json, token, ctx, desc);
+    if (ecs_os_strcmp(token, member_name)) {
+        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+            "expected member '%s'", member_name);
+        return NULL;
     }
+    return json;
+}
 
-    ecs_json_token_t token_kind = 0;
-    ecs_column_t *column = &table->data.columns[column_index];
-    ecs_type_info_t *ti = column->ti;
-    ecs_size_t size = ti->size;
-    ecs_entity_t type = ti->component;
+static
+const char* flecs_json_skip_string(
+    const char *json)
+{
+    if (json[0] != '"') {
+        return NULL; /* can only skip strings */
+    }
 
-    ecs_record_t **record_array = ecs_vec_first_t(&ctx->records, ecs_record_t*);
-    int32_t entity = 0;
-    bool values_set = false;
-    const char *values_start = json;
+    char ch, ch_out;
+    json ++;
+    for (; (ch = json[0]); ) {
+        if (ch == '"') {
+            json ++;
+            break;
+        }
 
-    do {
-        ecs_record_t *r = record_array[entity];
-        int32_t row = ECS_RECORD_TO_ROW(r->row);
+        json = flecs_chrparse(json, &ch_out);
+    }
 
-        void *ptr = ecs_vec_get(&column->data, size, row);
-        ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (!ch) {
+        return NULL;
+    } else {
+        return json;
+    }
+}
 
-        json = ecs_ptr_from_json(world, type, ptr, json, desc);
-        if (!json) {
-            if (desc->strict) {
-                break;
-            } else {
-                return flecs_json_missing_reflection(
-                    world, id, values_start, token, ctx, desc);
-            }
-        } else {
-            values_set = true;
-        }
+const char* flecs_json_skip_object(
+    const char *json,
+    char *token,
+    const ecs_from_json_desc_t *desc)
+{
+    ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_json_token_t token_kind = 0;
 
-        json = flecs_json_parse(json, &token_kind, token);
-        if (token_kind == JsonArrayClose) {
-            break;
-        } else if (token_kind != JsonComma) {
+    while ((json = flecs_json_parse(json, &token_kind, token))) {
+        if (token_kind == JsonObjectOpen) {
+            json = flecs_json_skip_object(json, token, desc);
+        } else if (token_kind == JsonArrayOpen) {
+            json = flecs_json_skip_array(json, token, desc);
+        } else if (token_kind == JsonLargeString) {
+            json = flecs_json_skip_string(json);
+        } else if (token_kind == JsonObjectClose) {
+            return json;
+        } else if (token_kind == JsonArrayClose) {
             ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "expected ',' or ']'");
+                "expected }, got ]");
+            return NULL;
         }
 
-        entity ++;
-    } while (json[0]);
-
-    if (values_set) {
-        ecs_id_t *id_set = ecs_vec_append_t(
-            ctx->a, &ctx->columns_set, ecs_id_t);
-        *id_set = id;
+        ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
     }
 
-    return json;
+    ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
+        "expected }, got end of string");
+    return NULL;
 }
 
-static
-const char* flecs_json_parse_values(
-    ecs_world_t *world,
-    ecs_table_t *table,
+const char* flecs_json_skip_array(
     const char *json,
     char *token,
-    ecs_from_json_ctx_t *ctx,
     const ecs_from_json_desc_t *desc)
 {
+    ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_json_token_t token_kind = 0;
-    int32_t value = 0;
-
-    ecs_vec_clear(&ctx->columns_set);
 
-    do {
-        if (value >= table->type.count) {
+    while ((json = flecs_json_parse(json, &token_kind, token))) {
+        if (token_kind == JsonObjectOpen) {
+            json = flecs_json_skip_object(json, token, desc);
+        } else if (token_kind == JsonArrayOpen) {
+            json = flecs_json_skip_array(json, token, desc);
+        } else if (token_kind == JsonLargeString) {
+            json = flecs_json_skip_string(json);
+        } else if (token_kind == JsonObjectClose) {
             ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "more elements in values array than expected for table");
-            goto error;
+                "expected ]");
+            return NULL;
+        } else if (token_kind == JsonArrayClose) {
+            return json;
         }
 
-        json = flecs_json_parse(json, &token_kind, token);
-        if (!json) {
-            goto error;
-        }
+        ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
+    }
 
-        if (token_kind == JsonArrayClose) {
-            break;
-        } else if (token_kind == JsonArrayOpen) {
-            ecs_id_t *idptr = ecs_vec_get_t(&ctx->result_ids, ecs_id_t, value);
-            ecs_assert(idptr != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_id_t id = idptr[0];
-            
-            json = flecs_json_parse_column(world, table, id,
-                json, token, ctx, desc);
-            if (!json) {
-                goto error;
-            }
-        } else if (token_kind == JsonNumber) {
-            if (!ecs_os_strcmp(token, "0")) {
-                /* no data */
-            } else {
-                ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                    "unexpected number");
-                goto error;
-            }
-        }
+    ecs_parser_error(desc->name, desc->expr, json - desc->expr, "expected ]");
+    return NULL;
+}
 
-        json = flecs_json_parse(json, &token_kind, token);
-        if (token_kind == JsonArrayClose) {
-            break;
-        } else if (token_kind != JsonComma) {
-            ecs_parser_error(desc->name, desc->expr, json - desc->expr,
-                    "expected ',' or ']'");
-            goto error;
-        }
+void flecs_json_next(
+    ecs_strbuf_t *buf)
+{
+    ecs_strbuf_list_next(buf);
+}
 
-        value ++;
-    } while (json[0]);
+void flecs_json_number(
+    ecs_strbuf_t *buf,
+    double value)
+{
+    ecs_strbuf_appendflt(buf, value, '"');
+}
 
-    /* Send OnSet notifications */
-    ecs_defer_begin(world);
-    ecs_type_t type = { 
-        .array = ctx->columns_set.array, 
-        .count = ctx->columns_set.count };
+void flecs_json_u32(
+    ecs_strbuf_t *buf,
+    uint32_t value)
+{
+    ecs_strbuf_appendint(buf, flecs_uto(int64_t, value));
+}
 
-    int32_t table_count = ecs_table_count(table);
-    int32_t i, record_count = ecs_vec_count(&ctx->records);
+void flecs_json_true(
+    ecs_strbuf_t *buf)
+{
+    ecs_strbuf_appendlit(buf, "true");
+}
 
-    /* If the entire table was inserted, send bulk notification */
-    if (table_count == ecs_vec_count(&ctx->records)) {
-        flecs_notify_on_set(
-            world, table, 0, ecs_table_count(table), &type, true);
+void flecs_json_false(
+    ecs_strbuf_t *buf)
+{
+    ecs_strbuf_appendlit(buf, "false");
+}
+
+void flecs_json_bool(
+    ecs_strbuf_t *buf,
+    bool value)
+{
+    if (value) {
+        flecs_json_true(buf);
     } else {
-        ecs_record_t **rvec = ecs_vec_first_t(&ctx->records, ecs_record_t*);
-        for (i = 0; i < record_count; i ++) {
-            ecs_record_t *r = rvec[i];
-            int32_t row = ECS_RECORD_TO_ROW(r->row);
-            flecs_notify_on_set(world, table, row, 1, &type, true);
-        }
+        flecs_json_false(buf);
     }
+}
 
-    ecs_defer_end(world);
+void flecs_json_array_push(
+    ecs_strbuf_t *buf)
+{
+    ecs_strbuf_list_push(buf, "[", ", ");
+}
 
-    return json;
-error:
-    return NULL;
+void flecs_json_array_pop(
+    ecs_strbuf_t *buf)
+{
+    ecs_strbuf_list_pop(buf, "]");
 }
 
-static
-const char* flecs_json_parse_result(
-    ecs_world_t *world,
-    const char *json,
-    char *token,
-    ecs_from_json_ctx_t *ctx,
-    const ecs_from_json_desc_t *desc)
+void flecs_json_object_push(
+    ecs_strbuf_t *buf)
 {
-    ecs_json_token_t token_kind = 0;
-    const char *ids = NULL, *values = NULL, *entities = NULL;
+    ecs_strbuf_list_push(buf, "{", ", ");
+}
 
-    json = flecs_json_expect(json, JsonObjectOpen, token, desc);
-    if (!json) {
-        goto error;
+void flecs_json_object_pop(
+    ecs_strbuf_t *buf)
+{
+    ecs_strbuf_list_pop(buf, "}");
+}
+
+void flecs_json_string(
+    ecs_strbuf_t *buf,
+    const char *value)
+{
+    ecs_strbuf_appendch(buf, '"');
+    ecs_strbuf_appendstr(buf, value);
+    ecs_strbuf_appendch(buf, '"');
+}
+
+void flecs_json_string_escape(
+    ecs_strbuf_t *buf,
+    const char *value)
+{
+    ecs_size_t length = flecs_stresc(NULL, 0, '"', value);
+    if (length == ecs_os_strlen(value)) {
+        ecs_strbuf_appendch(buf, '"');
+        ecs_strbuf_appendstrn(buf, value, length);
+        ecs_strbuf_appendch(buf, '"');
+    } else {
+        char *out = ecs_os_malloc(length + 3);
+        flecs_stresc(out + 1, length, '"', value);
+        out[0] = '"';
+        out[length + 1] = '"';
+        out[length + 2] = '\0';
+        ecs_strbuf_appendstr(buf, out);
+        ecs_os_free(out);
     }
+}
 
-    json = flecs_json_expect_member_name(json, token, "ids", desc);
-    if (!json) {
-        goto error;
+void flecs_json_member(
+    ecs_strbuf_t *buf,
+    const char *name)
+{
+    flecs_json_membern(buf, name, ecs_os_strlen(name));
+}
+
+void flecs_json_membern(
+    ecs_strbuf_t *buf,
+    const char *name,
+    int32_t name_len)
+{
+    ecs_strbuf_list_appendch(buf, '"');
+    ecs_strbuf_appendstrn(buf, name, name_len);
+    ecs_strbuf_appendlit(buf, "\":");
+}
+
+void flecs_json_path(
+    ecs_strbuf_t *buf,
+    const ecs_world_t *world,
+    ecs_entity_t e)
+{
+    ecs_strbuf_appendch(buf, '"');
+    ecs_get_path_w_sep_buf(world, 0, e, ".", "", buf);
+    ecs_strbuf_appendch(buf, '"');
+}
+
+static
+const char* flecs_json_entity_label(
+    const ecs_world_t *world,
+    ecs_entity_t e)
+{
+    const char *lbl = NULL;
+    if (!e) {
+        return "0";
     }
+#ifdef FLECS_DOC
+    lbl = ecs_doc_get_name(world, e);
+#else
+    lbl = ecs_get_name(world, e);
+#endif
+    return lbl;
+}
 
-    json = flecs_json_expect(json, JsonArrayOpen, token, desc);
-    if (!json) {
-        goto error;
+void flecs_json_label(
+    ecs_strbuf_t *buf,
+    const ecs_world_t *world,
+    ecs_entity_t e)
+{
+    const char *lbl = flecs_json_entity_label(world, e);
+    if (lbl) {
+        flecs_json_string_escape(buf, lbl);
+    } else {
+        ecs_strbuf_appendch(buf, '0');
     }
+}
 
-    ids = json; /* store start of ids array */
+void flecs_json_color(
+    ecs_strbuf_t *buf,
+    const ecs_world_t *world,
+    ecs_entity_t e)
+{
+    (void)world;
+    (void)e;
 
-    json = flecs_json_skip_array(json, token, desc);
-    if (!json) {
-        goto error;
-    }
+    const char *color = NULL;
+#ifdef FLECS_DOC
+    color = ecs_doc_get_color(world, e);
+#endif
 
-    json = flecs_json_expect(json, JsonComma, token, desc);
-    if (!json) {
-        goto error;
+    if (color) {
+        ecs_strbuf_appendch(buf, '"');
+        ecs_strbuf_appendstr(buf, color);
+        ecs_strbuf_appendch(buf, '"');
+    } else {
+        ecs_strbuf_appendch(buf, '0');
     }
+}
 
-    json = flecs_json_expect_member(json, token, desc);
-    if (!json) {
-        goto error;
+void flecs_json_id(
+    ecs_strbuf_t *buf,
+    const ecs_world_t *world,
+    ecs_id_t id)
+{
+    ecs_strbuf_appendch(buf, '[');
+
+    if (ECS_IS_PAIR(id)) {
+        ecs_entity_t first = ecs_pair_first(world, id);
+        ecs_entity_t second = ecs_pair_second(world, id);
+        ecs_strbuf_appendch(buf, '"');
+        ecs_get_path_w_sep_buf(world, 0, first, ".", "", buf);
+        ecs_strbuf_appendch(buf, '"');
+        ecs_strbuf_appendch(buf, ',');
+        ecs_strbuf_appendch(buf, '"');
+        ecs_get_path_w_sep_buf(world, 0, second, ".", "", buf);
+        ecs_strbuf_appendch(buf, '"');
+    } else {
+        ecs_strbuf_appendch(buf, '"');
+        ecs_get_path_w_sep_buf(world, 0, id & ECS_COMPONENT_MASK, ".", "", buf);
+        ecs_strbuf_appendch(buf, '"');
     }
 
-    ecs_entity_t parent = 0;
-    if (!ecs_os_strcmp(token, "parent")) {
-        char *parent_name = NULL;
-        json = flecs_json_expect_string(json, token, &parent_name, desc);
-        if (!json) {
-            goto error;
-        }
+    ecs_strbuf_appendch(buf, ']');
+}
 
-        parent = flecs_json_lookup(world, 0, parent_name, desc);
-        if (parent_name != token) {
-            ecs_os_free(parent_name);
+void flecs_json_id_member(
+    ecs_strbuf_t *buf,
+    const ecs_world_t *world,
+    ecs_id_t id)
+{
+    if (ECS_IS_PAIR(id)) {
+        ecs_strbuf_appendch(buf, '(');
+        ecs_entity_t first = ecs_pair_first(world, id);
+        ecs_entity_t second = ecs_pair_second(world, id);
+        {
+            const char *lbl = flecs_json_entity_label(world, first);
+            if (lbl) {
+                ecs_strbuf_appendstr(buf, lbl);
+            }
         }
-
-        json = flecs_json_expect(json, JsonComma, token, desc);
-        if (!json) {
-            goto error;
+        ecs_strbuf_appendch(buf, ',');
+        {
+            const char *lbl = flecs_json_entity_label(world, second);
+            if (lbl) {
+                ecs_strbuf_appendstr(buf, lbl);
+            }
         }
-
-        json = flecs_json_expect_member(json, token, desc);
-        if (!json) {
-            goto error;
+        ecs_strbuf_appendch(buf, ')');
+    } else {
+        const char *lbl = flecs_json_entity_label(world, id & ECS_COMPONENT_MASK);
+        if (lbl) {
+            ecs_strbuf_appendstr(buf, lbl);
         }
     }
+}
 
-    if (ecs_os_strcmp(token, "entities")) {
-        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-            "expected 'entities'");
-        goto error;
-    }
+ecs_primitive_kind_t flecs_json_op_to_primitive_kind(
+    ecs_meta_type_op_kind_t kind) 
+{
+    return kind - EcsOpPrimitive;
+}
 
-    json = flecs_json_expect(json, JsonArrayOpen, token, desc);
-    if (!json) {
-        goto error;
-    }
+#endif
 
-    entities = json; /* store start of entity id array */
+/**
+ * @file json/serialize.c
+ * @brief Serialize (component) values to JSON strings.
+ */
 
-    json = flecs_json_skip_array(json, token, desc);
-    if (!json) {
-        goto error;
-    }
+/**
+ * @file meta/meta.h
+ * @brief Private functions for meta addon.
+ */
 
-    json = flecs_json_parse(json, &token_kind, token);
-    if (token_kind == JsonComma) {
-        json = flecs_json_expect_member_name(json, token, "values", desc);
-        if (!json) {
-            goto error;
-        }
+#ifndef FLECS_META_PRIVATE_H
+#define FLECS_META_PRIVATE_H
 
-        json = flecs_json_expect(json, JsonArrayOpen, token, desc);
-        if (!json) {
-            goto error;
-        }
 
-        values = json; /* store start of entities array */
-    } else if (token_kind != JsonObjectClose) {
-        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-            "expected ',' or '}'");
-        goto error;
-    }
+#ifdef FLECS_META
 
-    /* Find table from ids */
-    ecs_table_t *table = flecs_json_parse_table(world, ids, token, ctx, desc);
-    if (!table) {
-        goto error;
-    }
+void ecs_meta_type_serialized_init(
+    ecs_iter_t *it);
 
-    /* Add entities to table */
-    if (flecs_json_parse_entities(world, table, parent,
-        entities, token, ctx, desc)) 
-    {
-        goto error;
-    }
+void ecs_meta_dtor_serialized(
+    EcsTypeSerializer *ptr);
 
-    /* If not parsing in strict mode, initialize component arrays to 0. This
-     * ensures that even if components can't be deserialized (because of 
-     * incomplete reflection data) component values aren't left uninitialized */
-    if (!desc->strict) {
-        flecs_json_zeromem_table(table);
-    }
+ecs_meta_type_op_kind_t flecs_meta_primitive_to_op_kind(
+    ecs_primitive_kind_t kind);
 
-    /* Parse values */
-    if (values) {
-        json = flecs_json_parse_values(world, table, values, token, ctx, desc);
-        if (!json) {
-            goto error;
-        }
+bool flecs_unit_validate(
+    ecs_world_t *world,
+    ecs_entity_t t,
+    EcsUnit *data);
 
-        json = flecs_json_parse(json, &token_kind, token);
-        if (token_kind == JsonComma) {
-            json = flecs_json_expect_member_name(json, token, "alerts", desc);
-            if (!json) {
-                goto error;
-            }
+void flecs_meta_import_definitions(
+    ecs_world_t *world);
 
-            json = flecs_json_expect(json, JsonBoolean, token, desc);
-            if (!json) {
-                goto error;
-            }
+int flecs_expr_ser_primitive(
+    const ecs_world_t *world,
+    ecs_primitive_kind_t kind,
+    const void *base, 
+    ecs_strbuf_t *str,
+    bool is_expr);
 
-            json = flecs_json_expect(json, JsonObjectClose, token, desc);
-            if (!json) {
-                goto error;
-            }
-        } else if (token_kind != JsonObjectClose) {
-            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "expected '}'");
-            goto error;
-        }
-    }
+#endif
 
-    return json;
-error:
-    return NULL;
-}
+#endif
 
-const char* ecs_world_from_json(
-    ecs_world_t *world,
-    const char *json,
-    const ecs_from_json_desc_t *desc_arg)
-{
-    ecs_json_token_t token_kind;
-    char token[ECS_MAX_TOKEN_SIZE];
 
-    ecs_from_json_desc_t desc = {0};
-    ecs_allocator_t *a = &world->allocator;
-    ecs_from_json_ctx_t ctx;
-    flecs_from_json_ctx_init(a, &ctx);
+#ifdef FLECS_JSON
 
-    const char *name = NULL, *expr = json, *lah;
-    if (desc_arg) {
-        desc = *desc_arg;
-    }
+static
+int flecs_json_ser_type_ops(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *ops,
+    int32_t op_count,
+    const void *base, 
+    ecs_strbuf_t *str,
+    int32_t in_array);
 
-    if (!desc.lookup_action) {
-        desc.lookup_action = (ecs_entity_t(*)(
-            const ecs_world_t*, const char*, void*))flecs_json_ensure_entity;
-        desc.lookup_ctx = &ctx.anonymous_ids;
-    }
+static
+int flecs_json_ser_type_op(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *base,
+    ecs_strbuf_t *str);
 
-    json = flecs_json_expect(json, JsonObjectOpen, token, &desc);
-    if (!json) {
-        goto error;
-    }
+/* Serialize enumeration */
+static
+int json_ser_enum(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *base, 
+    ecs_strbuf_t *str) 
+{
+    const EcsEnum *enum_type = ecs_get(world, op->type, EcsEnum);
+    ecs_check(enum_type != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    json = flecs_json_expect_member_name(json, token, "results", &desc);
-    if (!json) {
+    int32_t value = *(const int32_t*)base;
+    
+    /* Enumeration constants are stored in a map that is keyed on the
+     * enumeration value. */
+    ecs_enum_constant_t *constant = ecs_map_get_deref(&enum_type->constants,
+        ecs_enum_constant_t, (ecs_map_key_t)value);
+    if (!constant) {
+        /* If the value is not found, it is not a valid enumeration constant */
+        char *name = ecs_get_fullpath(world, op->type);
+        ecs_err("enumeration value '%d' of type '%s' is not a valid constant", 
+            value, name);
+        ecs_os_free(name);
         goto error;
     }
 
-    json = flecs_json_expect(json, JsonArrayOpen, token, &desc);
-    if (!json) {
-        goto error;
-    }
+    ecs_strbuf_appendch(str, '"');
+    ecs_strbuf_appendstr(str, ecs_get_name(world, constant->constant));
+    ecs_strbuf_appendch(str, '"');
+
+    return 0;
+error:
+    return -1;
+}
+
+/* Serialize bitmask */
+static
+int json_ser_bitmask(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *ptr, 
+    ecs_strbuf_t *str) 
+{
+    const EcsBitmask *bitmask_type = ecs_get(world, op->type, EcsBitmask);
+    ecs_check(bitmask_type != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    lah = flecs_json_parse(json, &token_kind, token);
-    if (token_kind == JsonArrayClose) {
-        json = lah;
-        goto end;
+    uint32_t value = *(const uint32_t*)ptr;
+    if (!value) {
+        ecs_strbuf_appendch(str, '0');
+        return 0;
     }
 
-    do {
-        json = flecs_json_parse_result(world, json, token, &ctx, &desc);
-        if (!json) {
-            goto error;
-        }
+    ecs_strbuf_list_push(str, "\"", "|");
 
-        json = flecs_json_parse(json, &token_kind, token);
-        if (token_kind == JsonArrayClose) {
-            break;
-        } else if (token_kind != JsonComma) {
-            ecs_parser_error(name, expr, json - expr,
-                    "expected ',' or ']'");
-            goto error;
+    /* Multiple flags can be set at a given time. Iterate through all the flags
+     * and append the ones that are set. */
+    ecs_map_iter_t it = ecs_map_iter(&bitmask_type->constants);
+    while (ecs_map_next(&it)) {
+        ecs_bitmask_constant_t *constant = ecs_map_ptr(&it);
+        ecs_map_key_t key = ecs_map_key(&it);
+        if ((value & key) == key) {
+            ecs_strbuf_list_appendstr(str, 
+                ecs_get_name(world, constant->constant));
+            value -= (uint32_t)key;
         }
-    } while(json && json[0]);
-
-end:
-    flecs_from_json_ctx_fini(&ctx);
+    }
 
-    json = flecs_json_expect(json, JsonObjectClose, token, &desc);
-    if (!json) {
+    if (value != 0) {
+        /* All bits must have been matched by a constant */
+        char *name = ecs_get_fullpath(world, op->type);
+        ecs_err("bitmask value '%u' of type '%s' contains invalid/unknown bits", 
+            value, name);
+        ecs_os_free(name);
         goto error;
     }
 
-    return json;
+    ecs_strbuf_list_pop(str, "\"");
+
+    return 0;
 error:
-    flecs_from_json_ctx_fini(&ctx);
-    return NULL;
+    return -1;
 }
 
-const char* ecs_world_from_json_file(
-    ecs_world_t *world,
-    const char *filename,
-    const ecs_from_json_desc_t *desc)
+/* Serialize elements of a contiguous array */
+static
+int json_ser_elements(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *ops, 
+    int32_t op_count,
+    const void *base, 
+    int32_t elem_count, 
+    int32_t elem_size,
+    ecs_strbuf_t *str,
+    bool is_array)
 {
-    char *json = flecs_load_from_file(filename);
-    if (!json) {
-        ecs_err("file not found: %s", filename);
-        return NULL;
+    flecs_json_array_push(str);
+
+    const void *ptr = base;
+
+    int i;
+    for (i = 0; i < elem_count; i ++) {
+        ecs_strbuf_list_next(str);
+        if (flecs_json_ser_type_ops(world, ops, op_count, ptr, str, is_array)) {
+            return -1;
+        }
+        ptr = ECS_OFFSET(ptr, elem_size);
     }
 
-    const char *result = ecs_world_from_json(world, json, desc);
-    ecs_os_free(json);
-    return result;
+    flecs_json_array_pop(str);
+
+    return 0;
 }
 
-#endif
+static
+int flecs_json_ser_type_elements(
+    const ecs_world_t *world,
+    ecs_entity_t type, 
+    const void *base, 
+    int32_t elem_count, 
+    ecs_strbuf_t *str,
+    bool is_array)
+{
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
+    ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL);
 
-/**
- * @file json/json.c
- * @brief JSON serializer utilities.
- */
+    const EcsComponent *comp = ecs_get(world, type, EcsComponent);
+    ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL);
 
-#include <ctype.h>
+    ecs_meta_type_op_t *ops = ecs_vec_first_t(&ser->ops, ecs_meta_type_op_t);
+    int32_t op_count = ecs_vec_count(&ser->ops);
 
-#ifdef FLECS_JSON
+    return json_ser_elements(
+        world, ops, op_count, base, elem_count, comp->size, str, is_array);
+}
 
+/* Serialize array */
 static
-const char* flecs_json_token_str(
-    ecs_json_token_t token_kind)
+int json_ser_array(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *ptr, 
+    ecs_strbuf_t *str) 
 {
-    switch(token_kind) {
-    case JsonObjectOpen: return "{";
-    case JsonObjectClose: return "}";
-    case JsonArrayOpen: return "[";
-    case JsonArrayClose: return "]";
-    case JsonColon: return ":";
-    case JsonComma: return ",";
-    case JsonNumber: return "number";
-    case JsonLargeInt: return "large integer";
-    case JsonLargeString:
-    case JsonString: return "string";
-    case JsonBoolean: return "bool";
-    case JsonTrue: return "true";
-    case JsonFalse: return "false";
-    case JsonNull: return "null";
-    case JsonInvalid: return "invalid";
-    default:
-        ecs_throw(ECS_INTERNAL_ERROR, NULL);
-    }
-error:
-    return "<<invalid token kind>>";
+    const EcsArray *a = ecs_get(world, op->type, EcsArray);
+    ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    return flecs_json_ser_type_elements(
+        world, a->type, ptr, a->count, str, true);
 }
 
-const char* flecs_json_parse(
-    const char *json,
-    ecs_json_token_t *token_kind,
-    char *token)
+/* Serialize vector */
+static
+int json_ser_vector(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *base, 
+    ecs_strbuf_t *str) 
 {
-    ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
-    json = ecs_parse_ws_eol(json);
-
-    char ch = json[0];
-
-    if (ch == '{') {
-        token_kind[0] = JsonObjectOpen;
-        return json + 1;
-    } else if (ch == '}') {
-        token_kind[0] = JsonObjectClose;
-        return json + 1;
-    } else if (ch == '[') {
-        token_kind[0] = JsonArrayOpen;
-        return json + 1;
-    } else if (ch == ']') {
-        token_kind[0] = JsonArrayClose;
-        return json + 1;
-    } else if (ch == ':') {
-        token_kind[0] = JsonColon;
-        return json + 1;
-    } else if (ch == ',') {
-        token_kind[0] = JsonComma;
-        return json + 1;
-    } else if (ch == '"') {
-        const char *start = json;
-        char *token_ptr = token;
-        json ++;
-        for (; (ch = json[0]); ) {
-            if (token_ptr - token >= ECS_MAX_TOKEN_SIZE) {
-                /* Token doesn't fit in buffer, signal to app to try again with
-                 * dynamic buffer. */
-                token_kind[0] = JsonLargeString;
-                return start;
-            }
-
-            if (ch == '"') {
-                json ++;
-                token_ptr[0] = '\0';
-                break;
-            }
-
-            json = ecs_chrparse(json, token_ptr ++);
-        }
+    const ecs_vec_t *value = base;
+    const EcsVector *v = ecs_get(world, op->type, EcsVector);
+    ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        if (!ch) {
-            token_kind[0] = JsonInvalid;
-            return NULL;
-        } else {
-            token_kind[0] = JsonString;
-            return json;
-        }
-    } else if (isdigit(ch) || (ch == '-')) {
-        token_kind[0] = JsonNumber;
-        const char *result = ecs_parse_digit(json, token);
-        
-        /* Cheap initial check if parsed token could represent large int */
-        if (result - json > 15) {
-            /* Less cheap secondary check to see if number is integer */
-            if (!strchr(token, '.')) {
-                token_kind[0] = JsonLargeInt;
-            }
-        }
+    int32_t count = ecs_vec_count(value);
+    void *array = ecs_vec_first(value);
 
-        return result;
-    } else if (isalpha(ch)) {
-        if (!ecs_os_strncmp(json, "null", 4)) {
-            token_kind[0] = JsonNull;
-            json += 4;
-        } else
-        if (!ecs_os_strncmp(json, "true", 4)) {
-            token_kind[0] = JsonTrue;
-            json += 4;
-        } else
-        if (!ecs_os_strncmp(json, "false", 5)) {
-            token_kind[0] = JsonFalse;
-            json += 5;
-        }
+    /* Serialize contiguous buffer of vector */
+    return flecs_json_ser_type_elements(world, v->type, array, count, str, false);
+}
 
-        if (isalpha(json[0]) || isdigit(json[0])) {
-            token_kind[0] = JsonInvalid;
-            return NULL;
-        }
+typedef struct json_serializer_ctx_t {
+    ecs_strbuf_t *str;
+    bool is_collection;
+    bool is_struct;
+} json_serializer_ctx_t;
 
-        return json;
-    } else {
-        token_kind[0] = JsonInvalid;
-        return NULL;
+static
+int json_ser_custom_value(
+    const ecs_serializer_t *ser,
+    ecs_entity_t type,
+    const void *value)
+{
+    json_serializer_ctx_t *json_ser = ser->ctx;
+    if (json_ser->is_collection) {
+        ecs_strbuf_list_next(json_ser->str);
     }
+    return ecs_ptr_to_json_buf(ser->world, type, value, json_ser->str);
 }
 
-const char* flecs_json_parse_large_string(
-    const char *json,
-    ecs_strbuf_t *buf)
+static
+int json_ser_custom_member(
+    const ecs_serializer_t *ser,
+    const char *name)
 {
-    if (json[0] != '"') {
-        return NULL; /* can only parse strings */
-    }
-
-    char ch, ch_out;
-    json ++;
-    for (; (ch = json[0]); ) {
-        if (ch == '"') {
-            json ++;
-            break;
-        }
-
-        json = ecs_chrparse(json, &ch_out);
-        ecs_strbuf_appendch(buf, ch_out);
-    }
-
-    if (!ch) {
-        return NULL;
-    } else {
-        return json;
+    json_serializer_ctx_t *json_ser = ser->ctx;
+    if (!json_ser->is_struct) {
+        ecs_err("serializer::member can only be called for structs");
+        return -1;
     }
+    flecs_json_member(json_ser->str, name);
+    return 0;
 }
 
-const char* flecs_json_expect(
-    const char *json,
-    ecs_json_token_t token_kind,
-    char *token,
-    const ecs_from_json_desc_t *desc)
+static
+int json_ser_custom_type(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *base, 
+    ecs_strbuf_t *str)
 {
-    /* Strings must be handled by flecs_json_expect_string for LargeString */
-    ecs_assert(token_kind != JsonString, ECS_INTERNAL_ERROR, NULL);
+    const EcsOpaque *ct = ecs_get(world, op->type, EcsOpaque);
+    ecs_assert(ct != NULL, ECS_INVALID_OPERATION, 
+        "entity %s in opaque type serializer instruction is not an opaque type",
+            ecs_get_name(world, op->type));
+    ecs_assert(ct->as_type != 0, ECS_INVALID_OPERATION, 
+        "opaque type %s has not populated as_type field",
+            ecs_get_name(world, op->type));
+    ecs_assert(ct->serialize != NULL, ECS_INVALID_OPERATION,
+        "opaque type %s does not have serialize interface", 
+            ecs_get_name(world, op->type));
+
+    const EcsType *pt = ecs_get(world, ct->as_type, EcsType);
+    ecs_assert(pt != NULL, ECS_INVALID_OPERATION, 
+        "opaque type %s is missing flecs.meta.Type component",
+            ecs_get_name(world, op->type));
 
-    ecs_json_token_t kind = 0;
-    json = flecs_json_parse(json, &kind, token);
+    ecs_type_kind_t kind = pt->kind;
+    bool is_collection = false;
+    bool is_struct = false;
 
-    if (kind == JsonInvalid) {
-        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-            "invalid json");
-        return NULL;
-    } else if (kind != token_kind) {
-        if (token_kind == JsonBoolean && 
-            (kind == JsonTrue || kind == JsonFalse)) 
-        {
-            /* ok */
-        } else {
-            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "expected %s, got %s",
-                flecs_json_token_str(token_kind), flecs_json_token_str(kind));
-            return NULL;
-        }
+    if (kind == EcsStructType) {
+        flecs_json_object_push(str);
+        is_struct = true;
+    } else if (kind == EcsArrayType || kind == EcsVectorType) {
+        flecs_json_array_push(str);
+        is_collection = true;
     }
 
-    return json;
-}
+    json_serializer_ctx_t json_ser = {
+        .str = str,
+        .is_struct = is_struct,
+        .is_collection = is_collection
+    };
 
-const char* flecs_json_expect_string(
-    const char *json,
-    char *token,
-    char **out,
-    const ecs_from_json_desc_t *desc)
-{
-    ecs_json_token_t token_kind = 0;
-    json = flecs_json_parse(json, &token_kind, token);
-    if (token_kind == JsonInvalid) {
-        ecs_parser_error(
-            desc->name, desc->expr, json - desc->expr, "invalid json");
-        return NULL;
-    } else if (token_kind != JsonString && token_kind != JsonLargeString) {
-        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-            "expected string");
-        return NULL;
-    }
+    ecs_serializer_t ser = {
+        .world = world,
+        .value = json_ser_custom_value,
+        .member = json_ser_custom_member,
+        .ctx = &json_ser
+    };
 
-    if (token_kind == JsonLargeString) {
-        ecs_strbuf_t large_token = ECS_STRBUF_INIT;
-        json = flecs_json_parse_large_string(json, &large_token);
-        if (!json) {
-            return NULL;
-        }
+    if (ct->serialize(&ser, base)) {
+        return -1;
+    }
 
-        if (out) {
-            *out = ecs_strbuf_get(&large_token);
-        } else {
-            ecs_strbuf_reset(&large_token);
-        }
-    } else if (out) {
-        *out = token;
+    if (kind == EcsStructType) {
+        flecs_json_object_pop(str);
+    } else if (kind == EcsArrayType || kind == EcsVectorType) {
+        flecs_json_array_pop(str);
     }
 
-    return json;
+    return 0;
 }
 
-const char* flecs_json_expect_member(
-    const char *json,
-    char *token,
-    const ecs_from_json_desc_t *desc)
+/* Forward serialization to the different type kinds */
+static
+int flecs_json_ser_type_op(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *ptr,
+    ecs_strbuf_t *str) 
 {
-    char *out = NULL;
-    json = flecs_json_expect_string(json, token, &out, desc);
-    if (!json) {
-        return NULL;
-    }
-
-    if (out != token) {
-        ecs_os_free(out);
+    void *vptr = ECS_OFFSET(ptr, op->offset);
+    bool large_int = false;
+    if (op->kind == EcsOpI64) {
+        if (*(int64_t*)vptr >= 2147483648) {
+            large_int = true;
+        }
+    } else if (op->kind == EcsOpU64) {
+        if (*(uint64_t*)vptr >= 2147483648) {
+            large_int = true;
+        }
     }
 
-    json = flecs_json_expect(json, JsonColon, token, desc);
-    if (!json) {
-        return NULL;
+    if (large_int) {
+        ecs_strbuf_appendch(str, '"');
     }
-    return json;
-}
 
-const char* flecs_json_expect_member_name(
-    const char *json,
-    char *token,
-    const char *member_name,
-    const ecs_from_json_desc_t *desc)
-{
-    json = flecs_json_expect_member(json, token, desc);
-    if (!json) {
-        return NULL;
-    }
-    if (ecs_os_strcmp(token, member_name)) {
-        ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-            "expected member '%s'", member_name);
-        return NULL;
+    switch(op->kind) {
+    case EcsOpPush:
+    case EcsOpPop:
+        /* Should not be parsed as single op */
+        ecs_throw(ECS_INVALID_PARAMETER, NULL);
+        break;
+    case EcsOpF32:
+        ecs_strbuf_appendflt(str, 
+            (ecs_f64_t)*(const ecs_f32_t*)vptr, '"');
+        break;
+    case EcsOpF64:
+        ecs_strbuf_appendflt(str, 
+            *(ecs_f64_t*)vptr, '"');
+        break;
+    case EcsOpEnum:
+        if (json_ser_enum(world, op, vptr, str)) {
+            goto error;
+        }
+        break;
+    case EcsOpBitmask:
+        if (json_ser_bitmask(world, op, vptr, str)) {
+            goto error;
+        }
+        break;
+    case EcsOpArray:
+        if (json_ser_array(world, op, vptr, str)) {
+            goto error;
+        }
+        break;
+    case EcsOpVector:
+        if (json_ser_vector(world, op, vptr, str)) {
+            goto error;
+        }
+        break;
+    case EcsOpOpaque:
+        if (json_ser_custom_type(world, op, vptr, str)) {
+            goto error;
+        }
+        break;
+    case EcsOpEntity: {
+        ecs_entity_t e = *(const ecs_entity_t*)vptr;
+        if (!e) {
+            ecs_strbuf_appendch(str, '0');
+        } else {
+            flecs_json_path(str, world, e);
+        }
+        break;
     }
-    return json;
-}
-
-static
-const char* flecs_json_skip_string(
-    const char *json)
-{
-    if (json[0] != '"') {
-        return NULL; /* can only skip strings */
+    case EcsOpId: {
+        ecs_id_t id = *(const ecs_id_t*)vptr;
+        if (!id) {
+            ecs_strbuf_appendch(str, '0');
+        } else {
+            flecs_json_id(str, world, id);
+        }
+        break;
     }
 
-    char ch, ch_out;
-    json ++;
-    for (; (ch = json[0]); ) {
-        if (ch == '"') {
-            json ++;
-            break;
+    case EcsOpU64:
+    case EcsOpI64:
+    case EcsOpBool:
+    case EcsOpChar:
+    case EcsOpByte:
+    case EcsOpU8:
+    case EcsOpU16:
+    case EcsOpU32:
+    case EcsOpI8:
+    case EcsOpI16:
+    case EcsOpI32:
+    case EcsOpUPtr:
+    case EcsOpIPtr:
+    case EcsOpString:
+        if (flecs_expr_ser_primitive(world, 
+            flecs_json_op_to_primitive_kind(op->kind), 
+            ECS_OFFSET(ptr, op->offset), str, true)) 
+        {
+            ecs_throw(ECS_INTERNAL_ERROR, NULL);
         }
+        break;
 
-        json = ecs_chrparse(json, &ch_out);
+    case EcsOpPrimitive:
+    case EcsOpScope:
+    default:
+        ecs_throw(ECS_INTERNAL_ERROR, NULL);
     }
 
-    if (!ch) {
-        return NULL;
-    } else {
-        return json;
+    if (large_int) {
+        ecs_strbuf_appendch(str, '"');
     }
+
+    return 0;
+error:
+    return -1;
 }
 
-const char* flecs_json_skip_object(
-    const char *json,
-    char *token,
-    const ecs_from_json_desc_t *desc)
+/* Iterate over a slice of the type ops array */
+static
+int flecs_json_ser_type_ops(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *ops,
+    int32_t op_count,
+    const void *base,
+    ecs_strbuf_t *str,
+    int32_t in_array)
 {
-    ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_json_token_t token_kind = 0;
-
-    while ((json = flecs_json_parse(json, &token_kind, token))) {
-        if (token_kind == JsonObjectOpen) {
-            json = flecs_json_skip_object(json, token, desc);
-        } else if (token_kind == JsonArrayOpen) {
-            json = flecs_json_skip_array(json, token, desc);
-        } else if (token_kind == JsonLargeString) {
-            json = flecs_json_skip_string(json);
-        } else if (token_kind == JsonObjectClose) {
-            return json;
-        } else if (token_kind == JsonArrayClose) {
-            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "expected }, got ]");
-            return NULL;
-        }
-
-        ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
-    }
+    for (int i = 0; i < op_count; i ++) {
+        ecs_meta_type_op_t *op = &ops[i];
 
-    ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-        "expected }, got end of string");
-    return NULL;
-}
+        if (in_array <= 0) {
+            if (op->name) {
+                flecs_json_member(str, op->name);
+            }
 
-const char* flecs_json_skip_array(
-    const char *json,
-    char *token,
-    const ecs_from_json_desc_t *desc)
-{
-    ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_json_token_t token_kind = 0;
+            int32_t elem_count = op->count;
+            if (elem_count > 1) {
+                /* Serialize inline array */
+                if (json_ser_elements(world, op, op->op_count, base,
+                    elem_count, op->size, str, true))
+                {
+                    return -1;
+                }
 
-    while ((json = flecs_json_parse(json, &token_kind, token))) {
-        if (token_kind == JsonObjectOpen) {
-            json = flecs_json_skip_object(json, token, desc);
-        } else if (token_kind == JsonArrayOpen) {
-            json = flecs_json_skip_array(json, token, desc);
-        } else if (token_kind == JsonLargeString) {
-            json = flecs_json_skip_string(json);
-        } else if (token_kind == JsonObjectClose) {
-            ecs_parser_error(desc->name, desc->expr, json - desc->expr, 
-                "expected ]");
-            return NULL;
-        } else if (token_kind == JsonArrayClose) {
-            return json;
+                i += op->op_count - 1;
+                continue;
+            }
+        }
+        
+        switch(op->kind) {
+        case EcsOpPush:
+            flecs_json_object_push(str);
+            in_array --;
+            break;
+        case EcsOpPop:
+            flecs_json_object_pop(str);
+            in_array ++;
+            break;
+        case EcsOpArray:
+        case EcsOpVector:
+        case EcsOpScope:
+        case EcsOpEnum:
+        case EcsOpBitmask:
+        case EcsOpPrimitive:
+        case EcsOpBool:
+        case EcsOpChar:
+        case EcsOpByte:
+        case EcsOpU8:
+        case EcsOpU16:
+        case EcsOpU32:
+        case EcsOpU64:
+        case EcsOpI8:
+        case EcsOpI16:
+        case EcsOpI32:
+        case EcsOpI64:
+        case EcsOpF32:
+        case EcsOpF64:
+        case EcsOpUPtr:
+        case EcsOpIPtr:
+        case EcsOpEntity:
+        case EcsOpId:
+        case EcsOpString:
+        case EcsOpOpaque:
+            if (flecs_json_ser_type_op(world, op, base, str)) {
+                goto error;
+            }
+            break;
+        default:
+            ecs_throw(ECS_INTERNAL_ERROR, NULL);
         }
-
-        ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
     }
 
-    ecs_parser_error(desc->name, desc->expr, json - desc->expr, "expected ]");
-    return NULL;
+    return 0;
+error:
+    return -1;
 }
 
-void flecs_json_next(
-    ecs_strbuf_t *buf)
+/* Iterate over the type ops of a type */
+int flecs_json_ser_type(
+    const ecs_world_t *world,
+    const ecs_vec_t *v_ops,
+    const void *base, 
+    ecs_strbuf_t *str) 
 {
-    ecs_strbuf_list_next(buf);
+    ecs_meta_type_op_t *ops = ecs_vec_first_t(v_ops, ecs_meta_type_op_t);
+    int32_t count = ecs_vec_count(v_ops);
+    return flecs_json_ser_type_ops(world, ops, count, base, str, 0);
 }
 
-void flecs_json_number(
+static
+int array_to_json_buf_w_type_data(
+    const ecs_world_t *world,
+    const void *ptr,
+    int32_t count,
     ecs_strbuf_t *buf,
-    double value)
+    const EcsComponent *comp,
+    const EcsTypeSerializer *ser)
 {
-    ecs_strbuf_appendflt(buf, value, '"');
-}
+    if (count) {
+        ecs_size_t size = comp->size;
 
-void flecs_json_u32(
-    ecs_strbuf_t *buf,
-    uint32_t value)
-{
-    ecs_strbuf_appendint(buf, flecs_uto(int64_t, value));
-}
+        flecs_json_array_push(buf);
 
-void flecs_json_true(
-    ecs_strbuf_t *buf)
-{
-    ecs_strbuf_appendlit(buf, "true");
-}
+        do {
+            ecs_strbuf_list_next(buf);
+            if (flecs_json_ser_type(world, &ser->ops, ptr, buf)) {
+                return -1;
+            }
 
-void flecs_json_false(
-    ecs_strbuf_t *buf)
-{
-    ecs_strbuf_appendlit(buf, "false");
-}
+            ptr = ECS_OFFSET(ptr, size);
+        } while (-- count);
 
-void flecs_json_bool(
-    ecs_strbuf_t *buf,
-    bool value)
-{
-    if (value) {
-        flecs_json_true(buf);
+        flecs_json_array_pop(buf);
     } else {
-        flecs_json_false(buf);
+        if (flecs_json_ser_type(world, &ser->ops, ptr, buf)) {
+            return -1;
+        }
     }
-}
-
-void flecs_json_array_push(
-    ecs_strbuf_t *buf)
-{
-    ecs_strbuf_list_push(buf, "[", ", ");
-}
-
-void flecs_json_array_pop(
-    ecs_strbuf_t *buf)
-{
-    ecs_strbuf_list_pop(buf, "]");
-}
 
-void flecs_json_object_push(
-    ecs_strbuf_t *buf)
-{
-    ecs_strbuf_list_push(buf, "{", ", ");
+    return 0;
 }
 
-void flecs_json_object_pop(
+int ecs_array_to_json_buf(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *ptr,
+    int32_t count,
     ecs_strbuf_t *buf)
 {
-    ecs_strbuf_list_pop(buf, "}");
-}
-
-void flecs_json_string(
-    ecs_strbuf_t *buf,
-    const char *value)
-{
-    ecs_strbuf_appendch(buf, '"');
-    ecs_strbuf_appendstr(buf, value);
-    ecs_strbuf_appendch(buf, '"');
-}
-
-void flecs_json_string_escape(
-    ecs_strbuf_t *buf,
-    const char *value)
-{
-    ecs_size_t length = ecs_stresc(NULL, 0, '"', value);
-    if (length == ecs_os_strlen(value)) {
-        ecs_strbuf_appendch(buf, '"');
-        ecs_strbuf_appendstrn(buf, value, length);
-        ecs_strbuf_appendch(buf, '"');
-    } else {
-        char *out = ecs_os_malloc(length + 3);
-        ecs_stresc(out + 1, length, '"', value);
-        out[0] = '"';
-        out[length + 1] = '"';
-        out[length + 2] = '\0';
-        ecs_strbuf_appendstr(buf, out);
-        ecs_os_free(out);
+    const EcsComponent *comp = ecs_get(world, type, EcsComponent);
+    if (!comp) {
+        char *path = ecs_get_fullpath(world, type);
+        ecs_err("cannot serialize to JSON, '%s' is not a component", path);
+        ecs_os_free(path);
+        return -1;
     }
-}
 
-void flecs_json_member(
-    ecs_strbuf_t *buf,
-    const char *name)
-{
-    flecs_json_membern(buf, name, ecs_os_strlen(name));
-}
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
+    if (!ser) {
+        char *path = ecs_get_fullpath(world, type);
+        ecs_err("cannot serialize to JSON, '%s' has no reflection data", path);
+        ecs_os_free(path);
+        return -1;
+    }
 
-void flecs_json_membern(
-    ecs_strbuf_t *buf,
-    const char *name,
-    int32_t name_len)
-{
-    ecs_strbuf_list_appendch(buf, '"');
-    ecs_strbuf_appendstrn(buf, name, name_len);
-    ecs_strbuf_appendlit(buf, "\":");
+    return array_to_json_buf_w_type_data(world, ptr, count, buf, comp, ser);
 }
 
-void flecs_json_path(
-    ecs_strbuf_t *buf,
-    const ecs_world_t *world,
-    ecs_entity_t e)
+char* ecs_array_to_json(
+    const ecs_world_t *world, 
+    ecs_entity_t type, 
+    const void* ptr,
+    int32_t count)
 {
-    ecs_strbuf_appendch(buf, '"');
-    ecs_get_path_w_sep_buf(world, 0, e, ".", "", buf);
-    ecs_strbuf_appendch(buf, '"');
-}
+    ecs_strbuf_t str = ECS_STRBUF_INIT;
 
-static
-const char* flecs_json_entity_label(
-    const ecs_world_t *world,
-    ecs_entity_t e)
-{
-    const char *lbl = NULL;
-    if (!e) {
-        return "0";
+    if (ecs_array_to_json_buf(world, type, ptr, count, &str) != 0) {
+        ecs_strbuf_reset(&str);
+        return NULL;
     }
-#ifdef FLECS_DOC
-    lbl = ecs_doc_get_name(world, e);
-#else
-    lbl = ecs_get_name(world, e);
-#endif
-    return lbl;
+
+    return ecs_strbuf_get(&str);
 }
 
-void flecs_json_label(
-    ecs_strbuf_t *buf,
+int ecs_ptr_to_json_buf(
     const ecs_world_t *world,
-    ecs_entity_t e)
+    ecs_entity_t type,
+    const void *ptr,
+    ecs_strbuf_t *buf)
 {
-    const char *lbl = flecs_json_entity_label(world, e);
-    if (lbl) {
-        flecs_json_string_escape(buf, lbl);
-    } else {
-        ecs_strbuf_appendch(buf, '0');
-    }
+    return ecs_array_to_json_buf(world, type, ptr, 0, buf);
 }
 
-void flecs_json_color(
-    ecs_strbuf_t *buf,
-    const ecs_world_t *world,
-    ecs_entity_t e)
+char* ecs_ptr_to_json(
+    const ecs_world_t *world, 
+    ecs_entity_t type, 
+    const void* ptr)
 {
-    (void)world;
-    (void)e;
-
-    const char *color = NULL;
-#ifdef FLECS_DOC
-    color = ecs_doc_get_color(world, e);
-#endif
-
-    if (color) {
-        ecs_strbuf_appendch(buf, '"');
-        ecs_strbuf_appendstr(buf, color);
-        ecs_strbuf_appendch(buf, '"');
-    } else {
-        ecs_strbuf_appendch(buf, '0');
-    }
+    return ecs_array_to_json(world, type, ptr, 0);
 }
 
-void flecs_json_id(
-    ecs_strbuf_t *buf,
+static
+bool flecs_json_skip_id(
     const ecs_world_t *world,
-    ecs_id_t id)
+    ecs_id_t id,
+    const ecs_entity_to_json_desc_t *desc,
+    ecs_entity_t ent,
+    ecs_entity_t inst,
+    ecs_entity_t *pred_out,
+    ecs_entity_t *obj_out,
+    ecs_entity_t *role_out,
+    bool *hidden_out)
 {
-    ecs_strbuf_appendch(buf, '[');
+    bool is_base = ent != inst;
+    ecs_entity_t pred = 0, obj = 0, role = 0;
+    bool hidden = false;
 
-    if (ECS_IS_PAIR(id)) {
-        ecs_entity_t first = ecs_pair_first(world, id);
-        ecs_entity_t second = ecs_pair_second(world, id);
-        ecs_strbuf_appendch(buf, '"');
-        ecs_get_path_w_sep_buf(world, 0, first, ".", "", buf);
-        ecs_strbuf_appendch(buf, '"');
-        ecs_strbuf_appendch(buf, ',');
-        ecs_strbuf_appendch(buf, '"');
-        ecs_get_path_w_sep_buf(world, 0, second, ".", "", buf);
-        ecs_strbuf_appendch(buf, '"');
+    if (ECS_HAS_ID_FLAG(id, PAIR)) {
+        pred = ecs_pair_first(world, id);
+        obj = ecs_pair_second(world, id);
     } else {
-        ecs_strbuf_appendch(buf, '"');
-        ecs_get_path_w_sep_buf(world, 0, id & ECS_COMPONENT_MASK, ".", "", buf);
-        ecs_strbuf_appendch(buf, '"');
+        pred = id & ECS_COMPONENT_MASK;
+        if (id & ECS_ID_FLAGS_MASK) {
+            role = id & ECS_ID_FLAGS_MASK;
+        }
     }
 
-    ecs_strbuf_appendch(buf, ']');
-}
-
-void flecs_json_id_member(
-    ecs_strbuf_t *buf,
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    if (ECS_IS_PAIR(id)) {
-        ecs_strbuf_appendch(buf, '(');
-        ecs_entity_t first = ecs_pair_first(world, id);
-        ecs_entity_t second = ecs_pair_second(world, id);
-        {
-            const char *lbl = flecs_json_entity_label(world, first);
-            if (lbl) {
-                ecs_strbuf_appendstr(buf, lbl);
-            }
+    if (is_base) {
+        if (ecs_has_id(world, pred, EcsDontInherit)) {
+            return true;
         }
-        ecs_strbuf_appendch(buf, ',');
-        {
-            const char *lbl = flecs_json_entity_label(world, second);
-            if (lbl) {
-                ecs_strbuf_appendstr(buf, lbl);
-            }
+    }
+    if (!desc || !desc->serialize_private) {
+        if (ecs_has_id(world, pred, EcsPrivate)) {
+            return true;
         }
-        ecs_strbuf_appendch(buf, ')');
-    } else {
-        const char *lbl = flecs_json_entity_label(world, id & ECS_COMPONENT_MASK);
-        if (lbl) {
-            ecs_strbuf_appendstr(buf, lbl);
+    }
+    if (is_base) {
+        if (ecs_get_target_for_id(world, inst, EcsIsA, id) != ent) {
+            hidden = true;
         }
     }
-}
-
-ecs_primitive_kind_t flecs_json_op_to_primitive_kind(
-    ecs_meta_type_op_kind_t kind) 
-{
-    return kind - EcsOpPrimitive;
-}
-
-#endif
-
-/**
- * @file json/serialize.c
- * @brief Serialize (component) values to JSON strings.
- */
-
-
-#ifdef FLECS_JSON
-
-static
-int flecs_json_ser_type_ops(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *ops,
-    int32_t op_count,
-    const void *base, 
-    ecs_strbuf_t *str,
-    int32_t in_array);
-
-static
-int flecs_json_ser_type_op(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *base,
-    ecs_strbuf_t *str);
-
-/* Serialize enumeration */
-static
-int json_ser_enum(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *base, 
-    ecs_strbuf_t *str) 
-{
-    const EcsEnum *enum_type = ecs_get(world, op->type, EcsEnum);
-    ecs_check(enum_type != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    int32_t value = *(const int32_t*)base;
-    
-    /* Enumeration constants are stored in a map that is keyed on the
-     * enumeration value. */
-    ecs_enum_constant_t *constant = ecs_map_get_deref(&enum_type->constants,
-        ecs_enum_constant_t, (ecs_map_key_t)value);
-    if (!constant) {
-        /* If the value is not found, it is not a valid enumeration constant */
-        char *name = ecs_get_fullpath(world, op->type);
-        ecs_err("enumeration value '%d' of type '%s' is not a valid constant", 
-            value, name);
-        ecs_os_free(name);
-        goto error;
+    if (hidden && (!desc || !desc->serialize_hidden)) {
+        return true;
     }
 
-    ecs_strbuf_appendch(str, '"');
-    ecs_strbuf_appendstr(str, ecs_get_name(world, constant->constant));
-    ecs_strbuf_appendch(str, '"');
+    *pred_out = pred;
+    *obj_out = obj;
+    *role_out = role;
+    if (hidden_out) *hidden_out = hidden;
 
-    return 0;
-error:
-    return -1;
+    return false;
 }
 
-/* Serialize bitmask */
 static
-int json_ser_bitmask(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *ptr, 
-    ecs_strbuf_t *str) 
+int flecs_json_append_type_labels(
+    const ecs_world_t *world, 
+    ecs_strbuf_t *buf,
+    const ecs_id_t *ids,
+    int32_t count,
+    ecs_entity_t ent, 
+    ecs_entity_t inst,
+    const ecs_entity_to_json_desc_t *desc) 
 {
-    const EcsBitmask *bitmask_type = ecs_get(world, op->type, EcsBitmask);
-    ecs_check(bitmask_type != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    uint32_t value = *(const uint32_t*)ptr;
-    if (!value) {
-        ecs_strbuf_appendch(str, '0');
+    (void)world; (void)buf; (void)ids; (void)count; (void)ent; (void)inst; 
+    (void)desc;
+    
+#ifdef FLECS_DOC
+    if (!desc || !desc->serialize_id_labels) {
         return 0;
     }
 
-    ecs_strbuf_list_push(str, "\"", "|");
+    flecs_json_memberl(buf, "id_labels");
+    flecs_json_array_push(buf);
 
-    /* Multiple flags can be set at a given time. Iterate through all the flags
-     * and append the ones that are set. */
-    ecs_map_iter_t it = ecs_map_iter(&bitmask_type->constants);
-    while (ecs_map_next(&it)) {
-        ecs_bitmask_constant_t *constant = ecs_map_ptr(&it);
-        ecs_map_key_t key = ecs_map_key(&it);
-        if ((value & key) == key) {
-            ecs_strbuf_list_appendstr(str, 
-                ecs_get_name(world, constant->constant));
-            value -= (uint32_t)key;
+    int32_t i;
+    for (i = 0; i < count; i ++) {
+        ecs_entity_t pred = 0, obj = 0, role = 0;
+        if (flecs_json_skip_id(world, ids[i], desc, ent, inst, &pred, &obj, &role, 0)) {
+            continue;
         }
-    }
 
-    if (value != 0) {
-        /* All bits must have been matched by a constant */
-        char *name = ecs_get_fullpath(world, op->type);
-        ecs_err("bitmask value '%u' of type '%s' contains invalid/unknown bits", 
-            value, name);
-        ecs_os_free(name);
-        goto error;
-    }
+        if (desc && desc->serialize_id_labels) {
+            flecs_json_next(buf);
 
-    ecs_strbuf_list_pop(str, "\"");
+            flecs_json_array_push(buf);
+            flecs_json_next(buf);
+            flecs_json_label(buf, world, pred);
+            if (obj) {
+                flecs_json_next(buf);
+                flecs_json_label(buf, world, obj);
+            }
+
+            flecs_json_array_pop(buf);
+        }
+    }
 
+    flecs_json_array_pop(buf);
+#endif
     return 0;
-error:
-    return -1;
 }
 
-/* Serialize elements of a contiguous array */
 static
-int json_ser_elements(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *ops, 
-    int32_t op_count,
-    const void *base, 
-    int32_t elem_count, 
-    int32_t elem_size,
-    ecs_strbuf_t *str,
-    bool is_array)
+int flecs_json_append_type_values(
+    const ecs_world_t *world, 
+    ecs_strbuf_t *buf, 
+    const ecs_id_t *ids,
+    int32_t count,
+    ecs_entity_t ent, 
+    ecs_entity_t inst,
+    const ecs_entity_to_json_desc_t *desc) 
 {
-    flecs_json_array_push(str);
+    if (!desc || !desc->serialize_values) {
+        return 0;
+    }
 
-    const void *ptr = base;
+    flecs_json_memberl(buf, "values");
+    flecs_json_array_push(buf);
 
-    int i;
-    for (i = 0; i < elem_count; i ++) {
-        ecs_strbuf_list_next(str);
-        if (flecs_json_ser_type_ops(world, ops, op_count, ptr, str, is_array)) {
-            return -1;
+    int32_t i;
+    for (i = 0; i < count; i ++) {
+        bool hidden;
+        ecs_entity_t pred = 0, obj = 0, role = 0;
+        ecs_id_t id = ids[i];
+        if (flecs_json_skip_id(world, id, desc, ent, inst, &pred, &obj, &role, 
+            &hidden)) 
+        {
+            continue;
         }
-        ptr = ECS_OFFSET(ptr, elem_size);
-    }
 
-    flecs_json_array_pop(str);
+        if (!hidden) {
+            bool serialized = false;
+            ecs_entity_t typeid = ecs_get_typeid(world, id);
+            if (typeid) {
+                const EcsTypeSerializer *ser = ecs_get(
+                    world, typeid, EcsTypeSerializer);
+                if (ser) {
+                    const void *ptr = ecs_get_id(world, ent, id);
+                    ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+
+                    flecs_json_next(buf);
+                    if (flecs_json_ser_type(world, &ser->ops, ptr, buf) != 0) {
+                        /* Entity contains invalid value */
+                        return -1;
+                    }
+                    serialized = true;
+                }
+            }
+            if (!serialized) {
+                flecs_json_next(buf);
+                flecs_json_number(buf, 0);
+            }
+        } else {
+            if (!desc || desc->serialize_hidden) {
+                flecs_json_next(buf);
+                flecs_json_number(buf, 0);
+            }
+        }
+    }
 
+    flecs_json_array_pop(buf);
+    
     return 0;
 }
 
 static
-int flecs_json_ser_type_elements(
-    const ecs_world_t *world,
-    ecs_entity_t type, 
-    const void *base, 
-    int32_t elem_count, 
-    ecs_strbuf_t *str,
-    bool is_array)
+int flecs_json_append_type_info(
+    const ecs_world_t *world, 
+    ecs_strbuf_t *buf, 
+    const ecs_id_t *ids,
+    int32_t count,
+    ecs_entity_t ent, 
+    ecs_entity_t inst,
+    const ecs_entity_to_json_desc_t *desc) 
 {
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
-    ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    const EcsComponent *comp = ecs_get(world, type, EcsComponent);
-    ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (!desc || !desc->serialize_type_info) {
+        return 0;
+    }
 
-    ecs_meta_type_op_t *ops = ecs_vec_first_t(&ser->ops, ecs_meta_type_op_t);
-    int32_t op_count = ecs_vec_count(&ser->ops);
+    flecs_json_memberl(buf, "type_info");
+    flecs_json_array_push(buf);
 
-    return json_ser_elements(
-        world, ops, op_count, base, elem_count, comp->size, str, is_array);
-}
+    int32_t i;
+    for (i = 0; i < count; i ++) {
+        bool hidden;
+        ecs_entity_t pred = 0, obj = 0, role = 0;
+        ecs_id_t id = ids[i];
+        if (flecs_json_skip_id(world, id, desc, ent, inst, &pred, &obj, &role, 
+            &hidden)) 
+        {
+            continue;
+        }
 
-/* Serialize array */
-static
-int json_ser_array(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *ptr, 
-    ecs_strbuf_t *str) 
-{
-    const EcsArray *a = ecs_get(world, op->type, EcsArray);
-    ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (!hidden) {
+            ecs_entity_t typeid = ecs_get_typeid(world, id);
+            if (typeid) {
+                flecs_json_next(buf);
+                if (ecs_type_info_to_json_buf(world, typeid, buf) != 0) {
+                    return -1;
+                }
+            } else {
+                flecs_json_next(buf);
+                flecs_json_number(buf, 0);
+            }
+        } else {
+            if (!desc || desc->serialize_hidden) {
+                flecs_json_next(buf);
+                flecs_json_number(buf, 0);
+            }
+        }
+    }
 
-    return flecs_json_ser_type_elements(
-        world, a->type, ptr, a->count, str, true);
+    flecs_json_array_pop(buf);
+    
+    return 0;
 }
 
-/* Serialize vector */
 static
-int json_ser_vector(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *base, 
-    ecs_strbuf_t *str) 
+int flecs_json_append_type_hidden(
+    const ecs_world_t *world, 
+    ecs_strbuf_t *buf, 
+    const ecs_id_t *ids,
+    int32_t count,
+    ecs_entity_t ent, 
+    ecs_entity_t inst,
+    const ecs_entity_to_json_desc_t *desc) 
 {
-    const ecs_vec_t *value = base;
-    const EcsVector *v = ecs_get(world, op->type, EcsVector);
-    ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (!desc || !desc->serialize_hidden) {
+        return 0;
+    }
 
-    int32_t count = ecs_vec_count(value);
-    void *array = ecs_vec_first(value);
+    if (ent == inst) {
+        return 0; /* if this is not a base, components are never hidden */
+    }
 
-    /* Serialize contiguous buffer of vector */
-    return flecs_json_ser_type_elements(world, v->type, array, count, str, false);
-}
+    flecs_json_memberl(buf, "hidden");
+    flecs_json_array_push(buf);
 
-typedef struct json_serializer_ctx_t {
-    ecs_strbuf_t *str;
-    bool is_collection;
-    bool is_struct;
-} json_serializer_ctx_t;
+    int32_t i;
+    for (i = 0; i < count; i ++) {
+        bool hidden;
+        ecs_entity_t pred = 0, obj = 0, role = 0;
+        ecs_id_t id = ids[i];
+        if (flecs_json_skip_id(world, id, desc, ent, inst, &pred, &obj, &role, 
+            &hidden)) 
+        {
+            continue;
+        }
 
-static
-int json_ser_custom_value(
-    const ecs_serializer_t *ser,
-    ecs_entity_t type,
-    const void *value)
-{
-    json_serializer_ctx_t *json_ser = ser->ctx;
-    if (json_ser->is_collection) {
-        ecs_strbuf_list_next(json_ser->str);
+        flecs_json_next(buf);
+        flecs_json_bool(buf, hidden);
     }
-    return ecs_ptr_to_json_buf(ser->world, type, value, json_ser->str);
-}
 
-static
-int json_ser_custom_member(
-    const ecs_serializer_t *ser,
-    const char *name)
-{
-    json_serializer_ctx_t *json_ser = ser->ctx;
-    if (!json_ser->is_struct) {
-        ecs_err("serializer::member can only be called for structs");
-        return -1;
-    }
-    flecs_json_member(json_ser->str, name);
+    flecs_json_array_pop(buf);
+    
     return 0;
 }
 
 static
-int json_ser_custom_type(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *base, 
-    ecs_strbuf_t *str)
+int flecs_json_append_type(
+    const ecs_world_t *world, 
+    ecs_strbuf_t *buf, 
+    ecs_entity_t ent, 
+    ecs_entity_t inst,
+    const ecs_entity_to_json_desc_t *desc) 
 {
-    const EcsOpaque *ct = ecs_get(world, op->type, EcsOpaque);
-    ecs_assert(ct != NULL, ECS_INVALID_OPERATION, NULL);
-    ecs_assert(ct->as_type != 0, ECS_INVALID_OPERATION, NULL);
-    ecs_assert(ct->serialize != NULL, ECS_INVALID_OPERATION, 
-        ecs_get_name(world, op->type));
+    const ecs_id_t *ids = NULL;
+    int32_t i, count = 0;
 
-    const EcsMetaType *pt = ecs_get(world, ct->as_type, EcsMetaType);
-    ecs_assert(pt != NULL, ECS_INVALID_OPERATION, NULL);
+    const ecs_type_t *type = ecs_get_type(world, ent);
+    if (type) {
+        ids = type->array;
+        count = type->count;
+    }
 
-    ecs_type_kind_t kind = pt->kind;
-    bool is_collection = false;
-    bool is_struct = false;
+    if (!desc || desc->serialize_ids) {
+        flecs_json_memberl(buf, "ids");
+        flecs_json_array_push(buf);
 
-    if (kind == EcsStructType) {
-        flecs_json_object_push(str);
-        is_struct = true;
-    } else if (kind == EcsArrayType || kind == EcsVectorType) {
-        flecs_json_array_push(str);
-        is_collection = true;
-    }
+        for (i = 0; i < count; i ++) {
+            ecs_entity_t pred = 0, obj = 0, role = 0;
+            if (flecs_json_skip_id(world, ids[i], desc, ent, inst, &pred, &obj, &role, 0)) {
+                continue;
+            }
 
-    json_serializer_ctx_t json_ser = {
-        .str = str,
-        .is_struct = is_struct,
-        .is_collection = is_collection
-    };
+            flecs_json_next(buf);
+            flecs_json_array_push(buf);
+            flecs_json_next(buf);
+            flecs_json_path(buf, world, pred);
+            if (obj || role) {
+                flecs_json_next(buf);
+                if (obj) {
+                    flecs_json_path(buf, world, obj);
+                } else {
+                    flecs_json_number(buf, 0);
+                }
+                if (role) {
+                    flecs_json_next(buf);
+                    flecs_json_string(buf, ecs_id_flag_str(role));
+                }
+            }
+            flecs_json_array_pop(buf);
+        }
+        flecs_json_array_pop(buf);
+    }
 
-    ecs_serializer_t ser = {
-        .world = world,
-        .value = json_ser_custom_value,
-        .member = json_ser_custom_member,
-        .ctx = &json_ser
-    };
+    if (flecs_json_append_type_labels(world, buf, ids, count, ent, inst, desc)) {
+        return -1;
+    }
+    
+    if (flecs_json_append_type_values(world, buf, ids, count, ent, inst, desc)) {
+        return -1;
+    }
 
-    if (ct->serialize(&ser, base)) {
+    if (flecs_json_append_type_info(world, buf, ids, count, ent, inst, desc)) {
         return -1;
     }
 
-    if (kind == EcsStructType) {
-        flecs_json_object_pop(str);
-    } else if (kind == EcsArrayType || kind == EcsVectorType) {
-        flecs_json_array_pop(str);
+    if (flecs_json_append_type_hidden(world, buf, ids, count, ent, inst, desc)) {
+        return -1;
     }
 
     return 0;
 }
 
-/* Forward serialization to the different type kinds */
 static
-int flecs_json_ser_type_op(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    const void *ptr,
-    ecs_strbuf_t *str) 
+int flecs_json_append_base(
+    const ecs_world_t *world, 
+    ecs_strbuf_t *buf, 
+    ecs_entity_t ent, 
+    ecs_entity_t inst,
+    const ecs_entity_to_json_desc_t *desc) 
 {
-    void *vptr = ECS_OFFSET(ptr, op->offset);
-    bool large_int = false;
-    if (op->kind == EcsOpI64) {
-        if (*(int64_t*)vptr >= 2147483648) {
-            large_int = true;
-        }
-    } else if (op->kind == EcsOpU64) {
-        if (*(uint64_t*)vptr >= 2147483648) {
-            large_int = true;
-        }
-    }
-
-    if (large_int) {
-        ecs_strbuf_appendch(str, '"');
+    const ecs_type_t *type = ecs_get_type(world, ent);
+    ecs_id_t *ids = NULL;
+    int32_t i, count = 0;
+    if (type) {
+        ids = type->array;
+        count = type->count;
     }
 
-    switch(op->kind) {
-    case EcsOpPush:
-    case EcsOpPop:
-        /* Should not be parsed as single op */
-        ecs_throw(ECS_INVALID_PARAMETER, NULL);
-        break;
-    case EcsOpF32:
-        ecs_strbuf_appendflt(str, 
-            (ecs_f64_t)*(const ecs_f32_t*)vptr, '"');
-        break;
-    case EcsOpF64:
-        ecs_strbuf_appendflt(str, 
-            *(ecs_f64_t*)vptr, '"');
-        break;
-    case EcsOpEnum:
-        if (json_ser_enum(world, op, vptr, str)) {
-            goto error;
-        }
-        break;
-    case EcsOpBitmask:
-        if (json_ser_bitmask(world, op, vptr, str)) {
-            goto error;
-        }
-        break;
-    case EcsOpArray:
-        if (json_ser_array(world, op, vptr, str)) {
-            goto error;
-        }
-        break;
-    case EcsOpVector:
-        if (json_ser_vector(world, op, vptr, str)) {
-            goto error;
-        }
-        break;
-    case EcsOpOpaque:
-        if (json_ser_custom_type(world, op, vptr, str)) {
-            goto error;
-        }
-        break;
-    case EcsOpEntity: {
-        ecs_entity_t e = *(const ecs_entity_t*)vptr;
-        if (!e) {
-            ecs_strbuf_appendch(str, '0');
-        } else {
-            flecs_json_path(str, world, e);
+    for (i = 0; i < count; i ++) {
+        ecs_id_t id = ids[i];
+        if (ECS_HAS_RELATION(id, EcsIsA)) {
+            if (flecs_json_append_base(world, buf, ecs_pair_second(world, id), inst, desc)) 
+            {
+                return -1;
+            }
         }
-        break;
     }
-    case EcsOpId: {
-        ecs_id_t id = *(const ecs_id_t*)vptr;
-        if (!id) {
-            ecs_strbuf_appendch(str, '0');
-        } else {
-            flecs_json_id(str, world, id);
-        }
-        break;
+
+    ecs_strbuf_list_next(buf);
+    flecs_json_object_push(buf);
+    flecs_json_memberl(buf, "path");
+    flecs_json_path(buf, world, ent);
+
+    if (flecs_json_append_type(world, buf, ent, inst, desc)) {
+        return -1;
     }
 
-    case EcsOpU64:
-    case EcsOpI64:
-    case EcsOpBool:
-    case EcsOpChar:
-    case EcsOpByte:
-    case EcsOpU8:
-    case EcsOpU16:
-    case EcsOpU32:
-    case EcsOpI8:
-    case EcsOpI16:
-    case EcsOpI32:
-    case EcsOpUPtr:
-    case EcsOpIPtr:
-    case EcsOpString:
-        if (ecs_primitive_to_expr_buf(world, 
-            flecs_json_op_to_primitive_kind(op->kind), 
-            ECS_OFFSET(ptr, op->offset), str)) 
-        {
-            ecs_throw(ECS_INTERNAL_ERROR, NULL);
-        }
-        break;
+    flecs_json_object_pop(buf);
+
+    return 0;
+}
+
+#ifdef FLECS_ALERTS
+static
+int flecs_json_serialize_entity_alerts(
+    const ecs_world_t *world,
+    ecs_strbuf_t *buf,
+    ecs_entity_t entity,
+    const EcsAlertsActive *alerts,
+    bool self)
+{
+    ecs_assert(alerts != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_map_iter_t it = ecs_map_iter(&alerts->alerts);
+    while (ecs_map_next(&it)) {
+        flecs_json_next(buf);
+        flecs_json_object_push(buf);
+        ecs_entity_t ai = ecs_map_value(&it);
+        char *alert_name = ecs_get_fullpath(world, ai);
+        flecs_json_memberl(buf, "alert");
+        flecs_json_string(buf, alert_name);
+        ecs_os_free(alert_name);
 
-    case EcsOpPrimitive:
-    case EcsOpScope:
-    default:
-        ecs_throw(ECS_INTERNAL_ERROR, NULL);
-    }
+        ecs_entity_t severity_id = ecs_get_target(
+            world, ai, ecs_id(EcsAlert), 0);
+        const char *severity = ecs_get_name(world, severity_id);
 
-    if (large_int) {
-        ecs_strbuf_appendch(str, '"');
+        const EcsAlertInstance *alert = ecs_get(
+            world, ai, EcsAlertInstance);
+        if (alert) {
+            if (alert->message) {
+                flecs_json_memberl(buf, "message");
+                flecs_json_string(buf, alert->message);
+            }
+            flecs_json_memberl(buf, "severity");
+            flecs_json_string(buf, severity);
+            
+            if (!self) {
+                char *path = ecs_get_fullpath(world, entity);
+                flecs_json_memberl(buf, "path");
+                flecs_json_string(buf, path);
+                ecs_os_free(path);
+            }
+        }
+        flecs_json_object_pop(buf);
     }
 
     return 0;
-error:
-    return -1;
 }
 
-/* Iterate over a slice of the type ops array */
 static
-int flecs_json_ser_type_ops(
+int flecs_json_serialize_children_alerts(
     const ecs_world_t *world,
-    ecs_meta_type_op_t *ops,
-    int32_t op_count,
-    const void *base,
-    ecs_strbuf_t *str,
-    int32_t in_array)
+    ecs_strbuf_t *buf,
+    ecs_entity_t entity)
 {
-    for (int i = 0; i < op_count; i ++) {
-        ecs_meta_type_op_t *op = &ops[i];
+    ecs_query_t *q = ecs_query(ECS_CONST_CAST(ecs_world_t*, world), {
+        .terms = {{ .id = ecs_pair(EcsChildOf, entity) }}
+    });
 
-        if (in_array <= 0) {
-            if (op->name) {
-                flecs_json_member(str, op->name);
-            }
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        EcsAlertsActive *alerts = ecs_table_get_id(
+            world, it.table, ecs_id(EcsAlertsActive), it.offset);
 
-            int32_t elem_count = op->count;
-            if (elem_count > 1) {
-                /* Serialize inline array */
-                if (json_ser_elements(world, op, op->op_count, base,
-                    elem_count, op->size, str, true))
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            ecs_entity_t child = it.entities[i];
+            if (alerts) {
+                if (flecs_json_serialize_entity_alerts(
+                    world, buf, child, &alerts[i], false))
                 {
-                    return -1;
+                    goto error;
                 }
-
-                i += op->op_count - 1;
-                continue;
             }
-        }
-        
-        switch(op->kind) {
-        case EcsOpPush:
-            flecs_json_object_push(str);
-            in_array --;
-            break;
-        case EcsOpPop:
-            flecs_json_object_pop(str);
-            in_array ++;
-            break;
-        case EcsOpArray:
-        case EcsOpVector:
-        case EcsOpScope:
-        case EcsOpEnum:
-        case EcsOpBitmask:
-        case EcsOpPrimitive:
-        case EcsOpBool:
-        case EcsOpChar:
-        case EcsOpByte:
-        case EcsOpU8:
-        case EcsOpU16:
-        case EcsOpU32:
-        case EcsOpU64:
-        case EcsOpI8:
-        case EcsOpI16:
-        case EcsOpI32:
-        case EcsOpI64:
-        case EcsOpF32:
-        case EcsOpF64:
-        case EcsOpUPtr:
-        case EcsOpIPtr:
-        case EcsOpEntity:
-        case EcsOpId:
-        case EcsOpString:
-        case EcsOpOpaque:
-            if (flecs_json_ser_type_op(world, op, base, str)) {
-                goto error;
+
+            ecs_record_t *r = flecs_entities_get(world, it.entities[i]);
+            if (r->row & EcsEntityIsTraversable) {
+                if (flecs_json_serialize_children_alerts(
+                    world, buf, child))
+                {
+                    goto error;
+                }
             }
-            break;
-        default:
-            ecs_throw(ECS_INTERNAL_ERROR, NULL);
         }
     }
 
+    ecs_query_fini(q);
+
     return 0;
 error:
     return -1;
 }
+#endif
 
-/* Iterate over the type ops of a type */
-int flecs_json_ser_type(
+static
+int flecs_json_serialize_alerts(
     const ecs_world_t *world,
-    const ecs_vec_t *v_ops,
-    const void *base, 
-    ecs_strbuf_t *str) 
+    ecs_strbuf_t *buf,
+    ecs_entity_t entity)
 {
-    ecs_meta_type_op_t *ops = ecs_vec_first_t(v_ops, ecs_meta_type_op_t);
-    int32_t count = ecs_vec_count(v_ops);
-    return flecs_json_ser_type_ops(world, ops, count, base, str, 0);
+    (void)world;
+    (void)buf;
+    (void)entity;
+
+#ifdef FLECS_ALERTS
+    if (!ecs_id(EcsAlertsActive)) {
+        return 0; /* Alert module not imported */
+    }
+
+    flecs_json_memberl(buf, "alerts");
+    flecs_json_array_push(buf);
+    const EcsAlertsActive *alerts = ecs_get(world, entity, EcsAlertsActive);
+    if (alerts) {
+        flecs_json_serialize_entity_alerts(world, buf, entity, alerts, true);
+    }
+    flecs_json_serialize_children_alerts(world, buf, entity);
+    flecs_json_array_pop(buf);
+#endif
+    return 0;
 }
 
 static
-int array_to_json_buf_w_type_data(
+int flecs_json_serialize_refs_idr(
     const ecs_world_t *world,
-    const void *ptr,
-    int32_t count,
     ecs_strbuf_t *buf,
-    const EcsComponent *comp,
-    const EcsMetaTypeSerialized *ser)
+    ecs_id_record_t *idr)
 {
-    if (count) {
-        ecs_size_t size = comp->size;
+    char *id_str = ecs_id_str(world, ecs_pair_first(world, idr->id));
 
-        flecs_json_array_push(buf);
+    flecs_json_member(buf, id_str);
+    ecs_os_free(id_str);
 
-        do {
-            ecs_strbuf_list_next(buf);
-            if (flecs_json_ser_type(world, &ser->ops, ptr, buf)) {
-                return -1;
+    flecs_json_array_push(buf);
+
+    ecs_table_cache_iter_t it;
+    if (idr && flecs_table_cache_all_iter((ecs_table_cache_t*)idr, &it)) {
+        const ecs_table_record_t *tr;
+        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+            ecs_table_t *table = tr->hdr.table;
+            int32_t i, count = ecs_table_count(table);
+            ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
+            for (i = 0; i < count; i ++) {
+                ecs_entity_t e = entities[i];
+                flecs_json_next(buf);
+                flecs_json_path(buf, world, e);
             }
+        }
+    }
 
-            ptr = ECS_OFFSET(ptr, size);
-        } while (-- count);
+    flecs_json_array_pop(buf);
 
-        flecs_json_array_pop(buf);
-    } else {
-        if (flecs_json_ser_type(world, &ser->ops, ptr, buf)) {
-            return -1;
+    return 0;
+}
+
+static
+int flecs_json_serialize_refs(
+    const ecs_world_t *world,
+    ecs_strbuf_t *buf,
+    ecs_entity_t entity,
+    ecs_entity_t relationship)
+{
+    ecs_id_record_t *idr = flecs_id_record_get(world, 
+        ecs_pair(relationship, entity));
+
+    if (idr) {
+        if (relationship == EcsWildcard) {
+            ecs_id_record_t *cur = idr;
+            while ((cur = cur->second.next)) {
+                flecs_json_serialize_refs_idr(world, buf, cur);
+            }
+        } else {
+            flecs_json_serialize_refs_idr(world, buf, idr);
         }
     }
+    
+    return 0;
+}
+
+static
+int flecs_json_serialize_matches(
+    const ecs_world_t *world,
+    ecs_strbuf_t *buf,
+    ecs_entity_t entity)
+{
+    ecs_id_record_t *idr = flecs_id_record_get(world, 
+        ecs_pair_t(EcsPoly, EcsQuery));
+
+    if (idr) {
+        ecs_table_cache_iter_t it;
+        if (idr && flecs_table_cache_iter((ecs_table_cache_t*)idr, &it)) {
+            const ecs_table_record_t *tr;
+            while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
+                ecs_table_t *table = tr->hdr.table;
+                EcsPoly *queries = ecs_table_get_column(table, tr->column, 0);
+
+                int32_t i, count = ecs_table_count(table);
+                ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
+                for (i = 0; i < count; i ++) {
+                    flecs_poly_t *q = queries[i].poly;
+                    if (!q) {
+                        continue;
+                    }
 
+                    ecs_iter_t qit = ecs_query_iter(world, q);
+                    if (!qit.variables) {
+                        ecs_iter_fini(&qit);
+                        continue;
+                    }
+                    ecs_iter_set_var(&qit, 0, entity);
+                    if (ecs_iter_is_true(&qit)) {
+                        flecs_json_next(buf);
+                        flecs_json_path(buf, world, entities[i]);
+                    }
+                }
+            }
+        }
+    }
+    
     return 0;
 }
 
-int ecs_array_to_json_buf(
+int ecs_entity_to_json_buf(
     const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *ptr,
-    int32_t count,
-    ecs_strbuf_t *buf)
+    ecs_entity_t entity,
+    ecs_strbuf_t *buf,
+    const ecs_entity_to_json_desc_t *desc)
 {
-    const EcsComponent *comp = ecs_get(world, type, EcsComponent);
-    if (!comp) {
-        char *path = ecs_get_fullpath(world, type);
-        ecs_err("cannot serialize to JSON, '%s' is not a component", path);
-        ecs_os_free(path);
+    if (!entity || !ecs_is_valid(world, entity)) {
         return -1;
     }
 
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
-    if (!ser) {
-        char *path = ecs_get_fullpath(world, type);
-        ecs_err("cannot serialize to JSON, '%s' has no reflection data", path);
-        ecs_os_free(path);
-        return -1;
+    flecs_json_object_push(buf);
+
+    if (!desc || desc->serialize_path) {
+        flecs_json_memberl(buf, "path");
+        flecs_json_path(buf, world, entity);
     }
 
-    return array_to_json_buf_w_type_data(world, ptr, count, buf, comp, ser);
+#ifdef FLECS_DOC
+    if (desc && desc->serialize_label) {
+        flecs_json_memberl(buf, "label");
+        const char *doc_name = ecs_doc_get_name(world, entity);
+        if (doc_name) {
+            flecs_json_string_escape(buf, doc_name);
+        } else {
+            char num_buf[20];
+            ecs_os_sprintf(num_buf, "%u", (uint32_t)entity);
+            flecs_json_string(buf, num_buf);
+        }
+    }
+
+    if (desc && desc->serialize_brief) {
+        const char *doc_brief = ecs_doc_get_brief(world, entity);
+        if (doc_brief) {
+            flecs_json_memberl(buf, "brief");
+            flecs_json_string_escape(buf, doc_brief);
+        }
+    }
+
+    if (desc && desc->serialize_link) {
+        const char *doc_link = ecs_doc_get_link(world, entity);
+        if (doc_link) {
+            flecs_json_memberl(buf, "link");
+            flecs_json_string_escape(buf, doc_link);
+        }
+    }
+
+    if (desc && desc->serialize_color) {
+        const char *doc_color = ecs_doc_get_color(world, entity);
+        if (doc_color) {
+            flecs_json_memberl(buf, "color");
+            flecs_json_string_escape(buf, doc_color);
+        }
+    }
+#endif
+
+    const ecs_type_t *type = ecs_get_type(world, entity);
+    ecs_id_t *ids = NULL;
+    int32_t i, count = 0;
+    if (type) {
+        ids = type->array;
+        count = type->count;
+    }
+
+    if (!desc || desc->serialize_base) {
+        if (ecs_has_pair(world, entity, EcsIsA, EcsWildcard)) {
+            flecs_json_memberl(buf, "is_a");
+            flecs_json_array_push(buf);
+
+            for (i = 0; i < count; i ++) {
+                ecs_id_t id = ids[i];
+                if (ECS_HAS_RELATION(id, EcsIsA)) {
+                    if (flecs_json_append_base(
+                        world, buf, ecs_pair_second(world, id), entity, desc)) 
+                    {
+                        return -1;
+                    }
+                }
+            }
+
+            flecs_json_array_pop(buf);
+        }
+    }
+
+    if (flecs_json_append_type(world, buf, entity, entity, desc)) {
+        goto error;
+    }
+
+    if (desc && desc->serialize_alerts) {
+        if (flecs_json_serialize_alerts(world, buf, entity)) {
+            goto error;
+        }
+    }
+
+    if (desc && desc->serialize_refs) {
+        flecs_json_memberl(buf, "refs");
+        flecs_json_object_push(buf);
+        if (flecs_json_serialize_refs(world, buf, entity, desc->serialize_refs)) {
+            goto error;
+        }
+        flecs_json_object_pop(buf);
+    }
+
+    if (desc && desc->serialize_matches) {
+        flecs_json_memberl(buf, "matches");
+        flecs_json_array_push(buf);
+        if (flecs_json_serialize_matches(world, buf, entity)) {
+            goto error;
+        }
+        flecs_json_array_pop(buf);
+    }
+
+    flecs_json_object_pop(buf);
+
+    return 0;
+error:
+    return -1;
 }
 
-char* ecs_array_to_json(
-    const ecs_world_t *world, 
-    ecs_entity_t type, 
-    const void* ptr,
-    int32_t count)
+char* ecs_entity_to_json(
+    const ecs_world_t *world,
+    ecs_entity_t entity,
+    const ecs_entity_to_json_desc_t *desc)
 {
-    ecs_strbuf_t str = ECS_STRBUF_INIT;
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
 
-    if (ecs_array_to_json_buf(world, type, ptr, count, &str) != 0) {
-        ecs_strbuf_reset(&str);
+    if (ecs_entity_to_json_buf(world, entity, &buf, desc) != 0) {
+        ecs_strbuf_reset(&buf);
         return NULL;
     }
 
-    return ecs_strbuf_get(&str);
+    return ecs_strbuf_get(&buf);
 }
 
-int ecs_ptr_to_json_buf(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *ptr,
-    ecs_strbuf_t *buf)
+bool flecs_json_skip_variable(
+    const char *name)
 {
-    return ecs_array_to_json_buf(world, type, ptr, 0, buf);
+    if (!name || name[0] == '_' || !ecs_os_strcmp(name, "this")) {
+        return true;
+    } else {
+        return false;
+    }
 }
 
-char* ecs_ptr_to_json(
-    const ecs_world_t *world, 
-    ecs_entity_t type, 
-    const void* ptr)
+static
+void flecs_json_serialize_id(
+    const ecs_world_t *world,
+    ecs_id_t id,
+    ecs_strbuf_t *buf) 
 {
-    return ecs_array_to_json(world, type, ptr, 0);
+    flecs_json_id(buf, world, id);
 }
 
 static
-bool flecs_json_skip_id(
+void flecs_json_serialize_id_label(
     const ecs_world_t *world,
     ecs_id_t id,
-    const ecs_entity_to_json_desc_t *desc,
-    ecs_entity_t ent,
-    ecs_entity_t inst,
-    ecs_entity_t *pred_out,
-    ecs_entity_t *obj_out,
-    ecs_entity_t *role_out,
-    bool *hidden_out)
+    ecs_strbuf_t *buf) 
 {
-    bool is_base = ent != inst;
-    ecs_entity_t pred = 0, obj = 0, role = 0;
-    bool hidden = false;
-
-    if (ECS_HAS_ID_FLAG(id, PAIR)) {
+    ecs_entity_t pred = id, obj = 0;
+    if (ECS_IS_PAIR(id)) {
         pred = ecs_pair_first(world, id);
         obj = ecs_pair_second(world, id);
-    } else {
-        pred = id & ECS_COMPONENT_MASK;
-        if (id & ECS_ID_FLAGS_MASK) {
-            role = id & ECS_ID_FLAGS_MASK;
-        }
     }
 
-    if (is_base) {
-        if (ecs_has_id(world, pred, EcsDontInherit)) {
-            return true;
-        }
-    }
-    if (!desc || !desc->serialize_private) {
-        if (ecs_has_id(world, pred, EcsPrivate)) {
-            return true;
-        }
-    }
-    if (is_base) {
-        if (ecs_get_target_for_id(world, inst, EcsIsA, id) != ent) {
-            hidden = true;
-        }
-    }
-    if (hidden && (!desc || !desc->serialize_hidden)) {
-        return true;
+    flecs_json_array_push(buf);
+    flecs_json_next(buf);
+    flecs_json_label(buf, world, pred);
+    if (obj) {
+        flecs_json_next(buf);
+        flecs_json_label(buf, world, obj);
     }
-
-    *pred_out = pred;
-    *obj_out = obj;
-    *role_out = role;
-    if (hidden_out) *hidden_out = hidden;
-
-    return false;
+    flecs_json_array_pop(buf);
 }
 
 static
-int flecs_json_append_type_labels(
-    const ecs_world_t *world, 
-    ecs_strbuf_t *buf,
-    const ecs_id_t *ids,
-    int32_t count,
-    ecs_entity_t ent, 
-    ecs_entity_t inst,
-    const ecs_entity_to_json_desc_t *desc) 
+void flecs_json_serialize_iter_ids(
+    const ecs_world_t *world,
+    const ecs_iter_t *it, 
+    ecs_strbuf_t *buf) 
 {
-    (void)world; (void)buf; (void)ids; (void)count; (void)ent; (void)inst; 
-    (void)desc;
-    
-#ifdef FLECS_DOC
-    if (!desc || !desc->serialize_id_labels) {
-        return 0;
+    int32_t field_count = it->field_count;
+    if (!field_count) {
+        return;
     }
 
-    flecs_json_memberl(buf, "id_labels");
-    flecs_json_array_push(buf);
-
-    int32_t i;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t pred = 0, obj = 0, role = 0;
-        if (flecs_json_skip_id(world, ids[i], desc, ent, inst, &pred, &obj, &role, 0)) {
-            continue;
-        }
-
-        if (obj && (pred == EcsUnion)) {
-            pred = obj;
-            obj = ecs_get_target(world, ent, pred, 0);
-            if (!ecs_is_alive(world, obj)) {
-                /* Union relationships aren't automatically cleaned up, so they
-                 * can contain invalid entity ids. Don't serialize value until
-                 * relationship is valid again. */
-                continue;
-            }
-        }
-
-        if (desc && desc->serialize_id_labels) {
-            flecs_json_next(buf);
-
-            flecs_json_array_push(buf);
-            flecs_json_next(buf);
-            flecs_json_label(buf, world, pred);
-            if (obj) {
-                flecs_json_next(buf);
-                flecs_json_label(buf, world, obj);
-            }
+    flecs_json_memberl(buf, "ids");
+    flecs_json_array_push(buf);
 
-            flecs_json_array_pop(buf);
-        }
+    for (int i = 0; i < field_count; i ++) {
+        flecs_json_next(buf);
+        flecs_json_serialize_id(world, it->query->terms[i].id, buf);
     }
 
     flecs_json_array_pop(buf);
-#endif
-    return 0;
 }
 
 static
-int flecs_json_append_type_values(
-    const ecs_world_t *world, 
-    ecs_strbuf_t *buf, 
-    const ecs_id_t *ids,
-    int32_t count,
-    ecs_entity_t ent, 
-    ecs_entity_t inst,
-    const ecs_entity_to_json_desc_t *desc) 
+void flecs_json_serialize_iter_id_labels(
+    const ecs_world_t *world,
+    const ecs_iter_t *it, 
+    ecs_strbuf_t *buf) 
 {
-    if (!desc || !desc->serialize_values) {
-        return 0;
+    int32_t field_count = it->field_count;
+    if (!field_count) {
+        return;
     }
 
-    flecs_json_memberl(buf, "values");
+    flecs_json_memberl(buf, "id_labels");
     flecs_json_array_push(buf);
 
-    int32_t i;
-    for (i = 0; i < count; i ++) {
-        bool hidden;
-        ecs_entity_t pred = 0, obj = 0, role = 0;
-        ecs_id_t id = ids[i];
-        if (flecs_json_skip_id(world, id, desc, ent, inst, &pred, &obj, &role, 
-            &hidden)) 
-        {
-            continue;
-        }
-
-        if (!hidden) {
-            bool serialized = false;
-            ecs_entity_t typeid = ecs_get_typeid(world, id);
-            if (typeid) {
-                const EcsMetaTypeSerialized *ser = ecs_get(
-                    world, typeid, EcsMetaTypeSerialized);
-                if (ser) {
-                    const void *ptr = ecs_get_id(world, ent, id);
-                    ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-
-                    flecs_json_next(buf);
-                    if (flecs_json_ser_type(world, &ser->ops, ptr, buf) != 0) {
-                        /* Entity contains invalid value */
-                        return -1;
-                    }
-                    serialized = true;
-                }
-            }
-            if (!serialized) {
-                flecs_json_next(buf);
-                flecs_json_number(buf, 0);
-            }
-        } else {
-            if (!desc || desc->serialize_hidden) {
-                flecs_json_next(buf);
-                flecs_json_number(buf, 0);
-            }
-        }
+    for (int i = 0; i < field_count; i ++) {
+        flecs_json_next(buf);
+        flecs_json_serialize_id_label(world, it->query->terms[i].id, buf);
     }
 
     flecs_json_array_pop(buf);
-    
-    return 0;
 }
 
 static
-int flecs_json_append_type_info(
-    const ecs_world_t *world, 
-    ecs_strbuf_t *buf, 
-    const ecs_id_t *ids,
-    int32_t count,
-    ecs_entity_t ent, 
-    ecs_entity_t inst,
-    const ecs_entity_to_json_desc_t *desc) 
+void flecs_json_serialize_id_str(
+    const ecs_world_t *world,
+    ecs_id_t id,
+    ecs_strbuf_t *buf)
 {
-    if (!desc || !desc->serialize_type_info) {
-        return 0;
+    ecs_strbuf_appendch(buf, '"');
+    if (ECS_IS_PAIR(id)) {
+        ecs_entity_t first = ecs_pair_first(world, id);
+        ecs_entity_t second = ecs_pair_first(world, id);
+        ecs_strbuf_appendch(buf, '(');
+        ecs_get_path_w_sep_buf(world, 0, first, ".", "", buf);
+        ecs_strbuf_appendch(buf, ',');
+        ecs_get_path_w_sep_buf(world, 0, second, ".", "", buf);
+        ecs_strbuf_appendch(buf, ')');
+    } else {
+        ecs_get_path_w_sep_buf(
+            world, 0, id & ECS_COMPONENT_MASK, ".", "", buf);
+    }
+    ecs_strbuf_appendch(buf, '"');
+}
+
+static
+void flecs_json_serialize_type_info(
+    const ecs_world_t *world,
+    const ecs_iter_t *it, 
+    ecs_strbuf_t *buf) 
+{
+    int32_t field_count = it->field_count;
+    if (!field_count) {
+        return;
+    }
+
+    if (it->flags & EcsIterNoData) {
+        return;
     }
 
     flecs_json_memberl(buf, "type_info");
-    flecs_json_array_push(buf);
+    flecs_json_object_push(buf);
 
-    int32_t i;
-    for (i = 0; i < count; i ++) {
-        bool hidden;
-        ecs_entity_t pred = 0, obj = 0, role = 0;
-        ecs_id_t id = ids[i];
-        if (flecs_json_skip_id(world, id, desc, ent, inst, &pred, &obj, &role, 
-            &hidden)) 
-        {
-            continue;
+    for (int i = 0; i < field_count; i ++) {
+        flecs_json_next(buf);
+        ecs_entity_t typeid = 0;
+        if (it->query->terms[i].inout != EcsInOutNone) {
+            typeid = ecs_get_typeid(world, it->query->terms[i].id);
         }
-
-        if (!hidden) {
-            ecs_entity_t typeid = ecs_get_typeid(world, id);
-            if (typeid) {
-                flecs_json_next(buf);
-                if (ecs_type_info_to_json_buf(world, typeid, buf) != 0) {
-                    return -1;
-                }
-            } else {
-                flecs_json_next(buf);
-                flecs_json_number(buf, 0);
-            }
+        if (typeid) {
+            flecs_json_serialize_id_str(world, typeid, buf);
+            ecs_strbuf_appendch(buf, ':');
+            ecs_type_info_to_json_buf(world, typeid, buf);
         } else {
-            if (!desc || desc->serialize_hidden) {
-                flecs_json_next(buf);
-                flecs_json_number(buf, 0);
-            }
+            flecs_json_serialize_id_str(world, it->query->terms[i].id, buf);
+            ecs_strbuf_appendlit(buf, ":0");
         }
     }
 
-    flecs_json_array_pop(buf);
-    
-    return 0;
+    flecs_json_object_pop(buf);
 }
 
 static
-int flecs_json_append_type_hidden(
-    const ecs_world_t *world, 
-    ecs_strbuf_t *buf, 
-    const ecs_id_t *ids,
-    int32_t count,
-    ecs_entity_t ent, 
-    ecs_entity_t inst,
-    const ecs_entity_to_json_desc_t *desc) 
+void flecs_json_serialize_field_info(
+    const ecs_world_t *world,
+    const ecs_iter_t *it, 
+    ecs_strbuf_t *buf,
+    ecs_json_ser_ctx_t *ctx)
 {
-    if (!desc || !desc->serialize_hidden) {
-        return 0;
+    int32_t field_count = it->field_count;
+    if (!field_count || !it->query) {
+        return;
     }
 
-    if (ent == inst) {
-        return 0; /* if this is not a base, components are never hidden */
-    }
+    const ecs_query_t *q = it->query;
 
-    flecs_json_memberl(buf, "hidden");
+    flecs_json_memberl(buf, "field_info");
     flecs_json_array_push(buf);
 
-    int32_t i;
-    for (i = 0; i < count; i ++) {
-        bool hidden;
-        ecs_entity_t pred = 0, obj = 0, role = 0;
-        ecs_id_t id = ids[i];
-        if (flecs_json_skip_id(world, id, desc, ent, inst, &pred, &obj, &role, 
-            &hidden)) 
-        {
-            continue;
-        }
-
+    int f;
+    for (f = 0; f < field_count; f ++) {
         flecs_json_next(buf);
-        flecs_json_bool(buf, hidden);
+        flecs_json_serialize_field(world, it, q, f, buf, ctx);
     }
 
     flecs_json_array_pop(buf);
-    
-    return 0;
 }
 
 static
-int flecs_json_append_type(
-    const ecs_world_t *world, 
-    ecs_strbuf_t *buf, 
-    ecs_entity_t ent, 
-    ecs_entity_t inst,
-    const ecs_entity_to_json_desc_t *desc) 
+void flecs_json_serialize_query_info(
+    const ecs_world_t *world,
+    const ecs_iter_t *it, 
+    ecs_strbuf_t *buf)
 {
-    const ecs_id_t *ids = NULL;
-    int32_t i, count = 0;
-
-    const ecs_type_t *type = ecs_get_type(world, ent);
-    if (type) {
-        ids = type->array;
-        count = type->count;
+    if (!it->query) {
+        return;
     }
 
-    if (!desc || desc->serialize_ids) {
-        flecs_json_memberl(buf, "ids");
-        flecs_json_array_push(buf);
-
-        for (i = 0; i < count; i ++) {
-            ecs_entity_t pred = 0, obj = 0, role = 0;
-            if (flecs_json_skip_id(world, ids[i], desc, ent, inst, &pred, &obj, &role, 0)) {
-                continue;
-            }
-
-            if (obj && (pred == EcsUnion)) {
-                pred = obj;
-                obj = ecs_get_target(world, ent, pred, 0);
-                if (!ecs_is_alive(world, obj)) {
-                    /* Union relationships aren't automatically cleaned up, so they
-                    * can contain invalid entity ids. Don't serialize value until
-                    * relationship is valid again. */
-                    continue;
-                }
-            }
+    const ecs_query_t *q = it->query;
+    flecs_json_memberl(buf, "query_info");
+    flecs_json_serialize_query(world, q, buf);
+}
 
-            flecs_json_next(buf);
-            flecs_json_array_push(buf);
-            flecs_json_next(buf);
-            flecs_json_path(buf, world, pred);
-            if (obj || role) {
-                flecs_json_next(buf);
-                if (obj) {
-                    flecs_json_path(buf, world, obj);
-                } else {
-                    flecs_json_number(buf, 0);
-                }
-                if (role) {
-                    flecs_json_next(buf);
-                    flecs_json_string(buf, ecs_id_flag_str(role));
-                }
-            }
-            flecs_json_array_pop(buf);
-        }
-        flecs_json_array_pop(buf);
-    }
+static
+void flecs_json_serialize_query_plan(
+    const ecs_world_t *world,
+    ecs_strbuf_t *buf,
+    const ecs_iter_to_json_desc_t *desc)
+{
+    (void)world;
+    (void)buf;
+    (void)desc;
 
-    if (flecs_json_append_type_labels(world, buf, ids, count, ent, inst, desc)) {
-        return -1;
-    }
-    
-    if (flecs_json_append_type_values(world, buf, ids, count, ent, inst, desc)) {
-        return -1;
+    if (!desc->query) {
+        return;
     }
 
-    if (flecs_json_append_type_info(world, buf, ids, count, ent, inst, desc)) {
-        return -1;
-    }
+    const ecs_query_t *q = desc->query;
+    flecs_poly_assert(q, ecs_query_t);
 
-    if (flecs_json_append_type_hidden(world, buf, ids, count, ent, inst, desc)) {
-        return -1;
-    }
+    flecs_json_memberl(buf, "query_plan");
 
-    return 0;
+    bool prev_color = ecs_log_enable_colors(true);
+    char *plan = ecs_query_plan(q);
+    flecs_json_string_escape(buf, plan);
+    ecs_os_free(plan);
+    ecs_log_enable_colors(prev_color);
 }
 
 static
-int flecs_json_append_base(
-    const ecs_world_t *world, 
-    ecs_strbuf_t *buf, 
-    ecs_entity_t ent, 
-    ecs_entity_t inst,
-    const ecs_entity_to_json_desc_t *desc) 
+void flecs_json_serialize_query_profile(
+    const ecs_world_t *world,
+    ecs_strbuf_t *buf,
+    const ecs_iter_t *it,
+    const ecs_iter_to_json_desc_t *desc)
 {
-    const ecs_type_t *type = ecs_get_type(world, ent);
-    ecs_id_t *ids = NULL;
-    int32_t i, count = 0;
-    if (type) {
-        ids = type->array;
-        count = type->count;
+    if (!desc->query) {
+        return;
     }
+    
+    ecs_time_t t = {0};
+    int32_t result_count = 0, entity_count = 0, i, sample_count = 100;
+    ecs_size_t component_bytes = 0, shared_component_bytes = 0;
+    double eval_time = 0, eval_min = 0, eval_max = 0;
+    ecs_time_measure(&t);
 
-    for (i = 0; i < count; i ++) {
-        ecs_id_t id = ids[i];
-        if (ECS_HAS_RELATION(id, EcsIsA)) {
-            if (flecs_json_append_base(world, buf, ecs_pair_second(world, id), inst, desc)) 
-            {
-                return -1;
+    for (i = 0; i < sample_count; i ++) {
+        result_count = 0; 
+        entity_count = 0;
+        component_bytes = 0;
+        shared_component_bytes = 0;
+
+        ecs_iter_t qit = ecs_query_iter(world, desc->query);
+        qit.flags |= EcsIterIsInstanced;
+    
+        while (ecs_iter_next(&qit)) {
+            result_count ++;
+            entity_count += qit.count;
+
+            int32_t f, field_count = qit.field_count;
+            for (f = 0; f < field_count; f ++) {
+                size_t size = ecs_field_size(&qit, f);
+                if (ecs_field_is_set(&qit, f) && size) {
+                    if (ecs_field_is_self(&qit, f)) {
+                        component_bytes += 
+                            flecs_uto(ecs_size_t, size) * qit.count;
+                    } else {
+                        shared_component_bytes += flecs_uto(ecs_size_t, size);
+                    }
+                }
             }
         }
+
+        double time_measure = ecs_time_measure(&t);
+        if (!i) {
+            eval_min = time_measure;
+        } else if (time_measure < eval_min) {
+            eval_min = time_measure;
+        }
+
+        if (time_measure > eval_max) {
+            eval_max = time_measure;
+        }
+
+        eval_time += time_measure;
+
+        /* Don't profile for too long */
+        if (eval_time > 0.001) {
+            i ++;
+            break;
+        }
     }
 
-    ecs_strbuf_list_next(buf);
-    flecs_json_object_push(buf);
-    flecs_json_memberl(buf, "path");
-    flecs_json_path(buf, world, ent);
+    eval_time /= i;
 
-    if (flecs_json_append_type(world, buf, ent, inst, desc)) {
-        return -1;
+    flecs_json_memberl(buf, "query_profile");
+    flecs_json_object_push(buf);
+    if (it->query) {
+        /* Correct for profiler */
+        ECS_CONST_CAST(ecs_query_t*, it->query)->eval_count -= i;
+        flecs_json_memberl(buf, "eval_count");
+        flecs_json_number(buf, it->query->eval_count);
     }
+    flecs_json_memberl(buf, "result_count");
+    flecs_json_number(buf, result_count);
+    flecs_json_memberl(buf, "entity_count");
+    flecs_json_number(buf, entity_count);
+
+    flecs_json_memberl(buf, "eval_time_avg_us");
+    flecs_json_number(buf, eval_time * 1000.0 * 1000.0);
+    flecs_json_memberl(buf, "eval_time_min_us");
+    flecs_json_number(buf, eval_min * 1000.0 * 1000.0);
+    flecs_json_memberl(buf, "eval_time_max_us");
+    flecs_json_number(buf, eval_max * 1000.0 * 1000.0);
+
+    flecs_json_memberl(buf, "component_bytes");
+    flecs_json_number(buf, component_bytes);
+    flecs_json_memberl(buf, "shared_component_bytes");
+    flecs_json_number(buf, shared_component_bytes);
 
     flecs_json_object_pop(buf);
+}
 
-    return 0;
+static
+void flecs_json_serialize_iter_variables(ecs_iter_t *it, ecs_strbuf_t *buf) {
+    char **variable_names = it->variable_names;
+    int32_t var_count = it->variable_count;
+    int32_t actual_count = 0;
+
+    for (int i = 1; i < var_count; i ++) {
+        const char *var_name = variable_names[i];
+        if (flecs_json_skip_variable(var_name)) continue;
+
+        if (!actual_count) {
+            flecs_json_memberl(buf, "vars");
+            flecs_json_array_push(buf);
+            actual_count ++;
+        }
+
+        ecs_strbuf_list_next(buf);
+        flecs_json_string(buf, var_name);
+    }
+
+    if (actual_count) {
+        flecs_json_array_pop(buf);
+    }
 }
 
-#ifdef FLECS_ALERTS
 static
-int flecs_json_serialize_entity_alerts(
+void flecs_json_serialize_iter_result_ids(
     const ecs_world_t *world,
-    ecs_strbuf_t *buf,
-    ecs_entity_t entity,
-    const EcsAlertsActive *alerts,
-    bool self)
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf)
 {
-    ecs_assert(alerts != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_json_memberl(buf, "ids");
+    flecs_json_array_push(buf);
 
-    ecs_map_iter_t it = ecs_map_iter(&alerts->alerts);
-    while (ecs_map_next(&it)) {
+    for (int i = 0; i < it->field_count; i ++) {
         flecs_json_next(buf);
-        flecs_json_object_push(buf);
-        ecs_entity_t ai = ecs_map_value(&it);
-        char *alert_name = ecs_get_fullpath(world, ai);
-        flecs_json_memberl(buf, "alert");
-        flecs_json_string(buf, alert_name);
-        ecs_os_free(alert_name);
+        flecs_json_serialize_id(world, ecs_field_id(it, i), buf);
+    }
 
-        ecs_entity_t severity_id = ecs_get_target(
-            world, ai, ecs_id(EcsAlert), 0);
-        const char *severity = ecs_get_name(world, severity_id);
+    flecs_json_array_pop(buf);
+}
 
-        const EcsAlertInstance *alert = ecs_get(
-            world, ai, EcsAlertInstance);
-        if (alert) {
-            if (alert->message) {
-                flecs_json_memberl(buf, "message");
-                flecs_json_string(buf, alert->message);
-            }
-            flecs_json_memberl(buf, "severity");
-            flecs_json_string(buf, severity);
-            
-            if (!self) {
-                char *path = ecs_get_fullpath(world, entity);
-                flecs_json_memberl(buf, "path");
-                flecs_json_string(buf, path);
-                ecs_os_free(path);
-            }
-        }
-        flecs_json_object_pop(buf);
+static
+void flecs_json_serialize_iter_result_id_labels(
+    const ecs_world_t *world,
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf)
+{
+    flecs_json_memberl(buf, "id_labels");
+    flecs_json_array_push(buf);
+
+    for (int i = 0; i < it->field_count; i ++) {
+        flecs_json_next(buf);
+        flecs_json_serialize_id_label(world, ecs_field_id(it, i), buf);
     }
 
-    return 0;
+    flecs_json_array_pop(buf);
 }
 
 static
-int flecs_json_serialize_children_alerts(
+void flecs_json_serialize_iter_result_table_type(
     const ecs_world_t *world,
+    const ecs_iter_t *it,
     ecs_strbuf_t *buf,
-    ecs_entity_t entity)
+    const ecs_iter_to_json_desc_t *desc)
 {
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter(ECS_CONST_CAST(ecs_world_t*, world), {
-        .storage = &f,
-        .terms = {{ .id = ecs_pair(EcsChildOf, entity) }}
-    });
+    if (!it->table) {
+        return;
+    }
 
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    while (ecs_filter_next(&it)) {
-        EcsAlertsActive *alerts = ecs_table_get_id(
-            world, it.table, ecs_id(EcsAlertsActive), it.offset);
+    if (desc->serialize_ids) {
+        flecs_json_memberl(buf, "ids");
+        flecs_json_array_push(buf);
 
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            ecs_entity_t child = it.entities[i];
-            if (alerts) {
-                if (flecs_json_serialize_entity_alerts(
-                    world, buf, child, &alerts[i], false))
-                {
-                    goto error;
+        ecs_type_t *type = &it->table->type;
+        for (int i = 0; i < type->count; i ++) {
+            ecs_id_t id = type->array[i];
+            if (!desc->serialize_private) {
+                ecs_entity_t e = id;
+                if (ECS_IS_PAIR(id)) {
+                    e = ecs_pair_first(world, id);
+                }
+                if (ecs_owns_id(world, e, EcsPrivate)) {
+                    continue;
                 }
             }
+            flecs_json_next(buf);
+            flecs_json_serialize_id(world, id, buf);
+        }
 
-            ecs_record_t *r = flecs_entities_get(world, it.entities[i]);
-            if (r->row & EcsEntityIsTraversable) {
-                if (flecs_json_serialize_children_alerts(
-                    world, buf, child))
-                {
-                    goto error;
+        flecs_json_array_pop(buf);
+    }
+    if (desc->serialize_id_labels) {
+        flecs_json_memberl(buf, "id_labels");
+        flecs_json_array_push(buf);
+
+        ecs_type_t *type = &it->table->type;
+        for (int i = 0; i < type->count; i ++) {
+            ecs_id_t id = type->array[i];
+            if (!desc->serialize_private) {
+                ecs_entity_t e = id;
+                if (ECS_IS_PAIR(id)) {
+                    e = ecs_pair_first(world, id);
+                }
+                if (ecs_owns_id(world, e, EcsPrivate)) {
+                    continue;
                 }
             }
+            flecs_json_next(buf);
+            flecs_json_serialize_id_label(world, id, buf);
         }
-    }
-
-    ecs_filter_fini(&f);
 
-    return 0;
-error:
-    return -1;
+        flecs_json_array_pop(buf);
+    }
 }
-#endif
 
 static
-int flecs_json_serialize_alerts(
+void flecs_json_serialize_iter_result_sources(
     const ecs_world_t *world,
-    ecs_strbuf_t *buf,
-    ecs_entity_t entity)
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf)
 {
-    (void)world;
-    (void)buf;
-    (void)entity;
+    flecs_json_memberl(buf, "sources");
+    flecs_json_array_push(buf);
 
-#ifdef FLECS_ALERTS
-    if (!ecs_id(EcsAlertsActive)) {
-        return 0; /* Alert module not imported */
+    for (int i = 0; i < it->field_count; i ++) {
+        flecs_json_next(buf);
+        ecs_entity_t subj = it->sources[i];
+        if (subj) {            
+            flecs_json_path(buf, world, subj);
+        } else {
+            ecs_strbuf_appendch(buf, '0');
+        }
     }
 
-    flecs_json_memberl(buf, "alerts");
-    flecs_json_array_push(buf);
-    const EcsAlertsActive *alerts = ecs_get(world, entity, EcsAlertsActive);
-    if (alerts) {
-        flecs_json_serialize_entity_alerts(world, buf, entity, alerts, true);
-    }
-    flecs_json_serialize_children_alerts(world, buf, entity);
     flecs_json_array_pop(buf);
-#endif
-    return 0;
 }
 
-static
-int flecs_json_serialize_refs_idr(
-    const ecs_world_t *world,
-    ecs_strbuf_t *buf,
-    ecs_id_record_t *idr)
+bool flecs_json_serialize_iter_result_is_set(
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf)
 {
-    char *id_str = ecs_id_str(world, ecs_pair_first(world, idr->id));
-
-    flecs_json_member(buf, id_str);
-    ecs_os_free(id_str);
+    if (!(it->flags & EcsIterHasCondSet)) {
+        return false;
+    }
 
+    flecs_json_memberl(buf, "is_set");
     flecs_json_array_push(buf);
 
-    ecs_table_cache_iter_t it;
-    if (idr && flecs_table_cache_all_iter((ecs_table_cache_t*)idr, &it)) {
-        const ecs_table_record_t *tr;
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            ecs_table_t *table = tr->hdr.table;
-            int32_t i, count = ecs_table_count(table);
-            ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
-            for (i = 0; i < count; i ++) {
-                ecs_entity_t e = entities[i];
-                flecs_json_next(buf);
-                flecs_json_path(buf, world, e);
-            }
+    for (int i = 0; i < it->field_count; i ++) {
+        ecs_strbuf_list_next(buf);
+        if (ecs_field_is_set(it, i)) {
+            flecs_json_true(buf);
+        } else {
+            flecs_json_false(buf);
         }
     }
 
     flecs_json_array_pop(buf);
 
-    return 0;
+    return true;
 }
 
 static
-int flecs_json_serialize_refs(
+void flecs_json_serialize_iter_result_variables(
     const ecs_world_t *world,
-    ecs_strbuf_t *buf,
-    ecs_entity_t entity,
-    ecs_entity_t relationship)
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf) 
 {
-    ecs_id_record_t *idr = flecs_id_record_get(world, 
-        ecs_pair(relationship, entity));
+    char **variable_names = it->variable_names;
+    ecs_var_t *variables = it->variables;
+    int32_t var_count = it->variable_count;
+    int32_t actual_count = 0;
 
-    if (idr) {
-        if (relationship == EcsWildcard) {
-            ecs_id_record_t *cur = idr;
-            while ((cur = cur->second.next)) {
-                flecs_json_serialize_refs_idr(world, buf, cur);
-            }
-        } else {
-            flecs_json_serialize_refs_idr(world, buf, idr);
+    for (int i = 1; i < var_count; i ++) {
+        const char *var_name = variable_names[i];
+        if (flecs_json_skip_variable(var_name)) continue;
+
+        if (!actual_count) {
+            flecs_json_memberl(buf, "vars");
+            flecs_json_array_push(buf);
+            actual_count ++;
         }
+
+        ecs_strbuf_list_next(buf);
+        flecs_json_path(buf, world, variables[i].entity);
+    }
+
+    if (actual_count) {
+        flecs_json_array_pop(buf);
     }
-    
-    return 0;
 }
 
 static
-int flecs_json_serialize_matches(
+void flecs_json_serialize_iter_result_variable_labels(
     const ecs_world_t *world,
-    ecs_strbuf_t *buf,
-    ecs_entity_t entity)
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf) 
 {
-    ecs_id_record_t *idr = flecs_id_record_get(world, 
-        ecs_pair_t(EcsPoly, EcsQuery));
-
-    if (idr) {
-        ecs_table_cache_iter_t it;
-        if (idr && flecs_table_cache_iter((ecs_table_cache_t*)idr, &it)) {
-            const ecs_table_record_t *tr;
-            while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-                ecs_table_t *table = tr->hdr.table;
-                EcsPoly *queries = ecs_table_get_column(table, tr->column, 0);
+    char **variable_names = it->variable_names;
+    ecs_var_t *variables = it->variables;
+    int32_t var_count = it->variable_count;
+    int32_t actual_count = 0;
 
-                int32_t i, count = ecs_table_count(table);
-                ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
-                for (i = 0; i < count; i ++) {
-                    ecs_poly_t *q = queries[i].poly;
-                    if (!q) {
-                        continue;
-                    }
+    for (int i = 1; i < var_count; i ++) {
+        const char *var_name = variable_names[i];
+        if (flecs_json_skip_variable(var_name)) continue;
 
-                    ecs_iter_t qit;
-                    ecs_iter_poly(world, q, &qit, NULL);
-                    if (!qit.variables) {
-                        ecs_iter_fini(&qit);
-                        continue;
-                    }
-                    ecs_iter_set_var(&qit, 0, entity);
-                    if (ecs_iter_is_true(&qit)) {
-                        flecs_json_next(buf);
-                        flecs_json_path(buf, world, entities[i]);
-                    }
-                }
-            }
+        if (!actual_count) {
+            flecs_json_memberl(buf, "var_labels");
+            flecs_json_array_push(buf);
+            actual_count ++;
         }
+
+        ecs_strbuf_list_next(buf);
+        flecs_json_label(buf, world, variables[i].entity);
     }
-    
-    return 0;
-}
 
-int ecs_entity_to_json_buf(
-    const ecs_world_t *world,
-    ecs_entity_t entity,
-    ecs_strbuf_t *buf,
-    const ecs_entity_to_json_desc_t *desc)
-{
-    if (!entity || !ecs_is_valid(world, entity)) {
-        return -1;
+    if (actual_count) {
+        flecs_json_array_pop(buf);
     }
+}
 
-    flecs_json_object_push(buf);
+static
+void flecs_json_serialize_iter_result_variable_ids(
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf) 
+{
+    char **variable_names = it->variable_names;
+    ecs_var_t *variables = it->variables;
+    int32_t var_count = it->variable_count;
+    int32_t actual_count = 0;
 
-    if (!desc || desc->serialize_path) {
-        flecs_json_memberl(buf, "path");
-        flecs_json_path(buf, world, entity);
-    }
+    for (int i = 1; i < var_count; i ++) {
+        const char *var_name = variable_names[i];
+        if (flecs_json_skip_variable(var_name)) continue;
 
-#ifdef FLECS_DOC
-    if (desc && desc->serialize_label) {
-        flecs_json_memberl(buf, "label");
-        const char *doc_name = ecs_doc_get_name(world, entity);
-        if (doc_name) {
-            flecs_json_string_escape(buf, doc_name);
-        } else {
-            char num_buf[20];
-            ecs_os_sprintf(num_buf, "%u", (uint32_t)entity);
-            flecs_json_string(buf, num_buf);
+        if (!actual_count) {
+            flecs_json_memberl(buf, "var_ids");
+            flecs_json_array_push(buf);
+            actual_count ++;
         }
+
+        ecs_strbuf_list_next(buf);
+        flecs_json_u32(buf, (uint32_t)variables[i].entity);
     }
 
-    if (desc && desc->serialize_brief) {
-        const char *doc_brief = ecs_doc_get_brief(world, entity);
-        if (doc_brief) {
-            flecs_json_memberl(buf, "brief");
-            flecs_json_string_escape(buf, doc_brief);
-        }
+    if (actual_count) {
+        flecs_json_array_pop(buf);
     }
+}
 
-    if (desc && desc->serialize_link) {
-        const char *doc_link = ecs_doc_get_link(world, entity);
-        if (doc_link) {
-            flecs_json_memberl(buf, "link");
-            flecs_json_string_escape(buf, doc_link);
-        }
+static
+bool flecs_json_serialize_iter_result_entity_names(
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf) 
+{
+    ecs_assert(it->count != 0, ECS_INTERNAL_ERROR, NULL);
+
+    EcsIdentifier *names = ecs_table_get_id(it->world, it->table, 
+        ecs_pair(ecs_id(EcsIdentifier), EcsName), it->offset);
+    if (!names) {
+        return false;
     }
 
-    if (desc && desc->serialize_color) {
-        const char *doc_color = ecs_doc_get_color(world, entity);
-        if (doc_color) {
-            flecs_json_memberl(buf, "color");
-            flecs_json_string_escape(buf, doc_color);
-        }
+    int i;
+    for (i = 0; i < it->count; i ++) {
+        flecs_json_next(buf);
+        flecs_json_string(buf, names[i].value);
     }
-#endif
 
-    const ecs_type_t *type = ecs_get_type(world, entity);
-    ecs_id_t *ids = NULL;
-    int32_t i, count = 0;
-    if (type) {
-        ids = type->array;
-        count = type->count;
+    return true;
+}
+
+static
+void flecs_json_serialize_iter_result_entity_ids(
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf) 
+{
+    if (!it->count) {
+        return;
     }
 
-    if (!desc || desc->serialize_base) {
-        if (ecs_has_pair(world, entity, EcsIsA, EcsWildcard)) {
-            flecs_json_memberl(buf, "is_a");
-            flecs_json_array_push(buf);
+    flecs_json_memberl(buf, "entity_ids");
+    flecs_json_array_push(buf);
 
-            for (i = 0; i < count; i ++) {
-                ecs_id_t id = ids[i];
-                if (ECS_HAS_RELATION(id, EcsIsA)) {
-                    if (flecs_json_append_base(
-                        world, buf, ecs_pair_second(world, id), entity, desc)) 
-                    {
-                        return -1;
-                    }
-                }
-            }
+    ecs_entity_t *entities = it->entities;
 
-            flecs_json_array_pop(buf);
-        }
+    int i, count = it->count;
+    for (i = 0; i < count; i ++) {
+        flecs_json_next(buf);
+        flecs_json_u32(buf, (uint32_t)entities[i]);
     }
 
-    if (flecs_json_append_type(world, buf, entity, entity, desc)) {
-        goto error;
+    flecs_json_array_pop(buf);
+}
+
+static
+void flecs_json_serialize_iter_result_parent(
+    const ecs_world_t *world,
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf) 
+{
+    ecs_table_t *table = it->table;
+    if (!(table->flags & EcsTableHasChildOf)) {
+        return;
     }
 
-    if (desc && desc->serialize_alerts) {
-        if (flecs_json_serialize_alerts(world, buf, entity)) {
-            goto error;
-        }
+    ecs_table_record_t *tr = flecs_id_record_get_table(
+        world->idr_childof_wildcard, it->table);
+    if (tr == NULL) {
+        return;
     }
 
-    if (desc && desc->serialize_refs) {
-        flecs_json_memberl(buf, "refs");
-        flecs_json_object_push(buf);
-        if (flecs_json_serialize_refs(world, buf, entity, desc->serialize_refs)) {
-            goto error;
-        }
-        flecs_json_object_pop(buf);
+    ecs_id_t id = table->type.array[tr->index];
+    ecs_entity_t parent = ecs_pair_second(world, id);
+    char *path = ecs_get_path_w_sep(world, 0, parent, ".", "");
+    flecs_json_memberl(buf, "parent");
+    flecs_json_string(buf, path);
+    ecs_os_free(path);
+}
+
+static
+void flecs_json_serialize_iter_result_entities(
+    const ecs_world_t *world,
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf) 
+{
+    if (!it->count) {
+        return;
     }
 
-    if (desc && desc->serialize_matches) {
-        flecs_json_memberl(buf, "matches");
-        flecs_json_array_push(buf);
-        if (flecs_json_serialize_matches(world, buf, entity)) {
-            goto error;
+    flecs_json_serialize_iter_result_parent(world, it, buf);
+
+    flecs_json_memberl(buf, "entities");
+    flecs_json_array_push(buf);
+
+    if (!flecs_json_serialize_iter_result_entity_names(it, buf)) {
+        ecs_entity_t *entities = it->entities;
+
+        int i, count = it->count;
+        for (i = 0; i < count; i ++) {
+            flecs_json_next(buf);
+            flecs_json_u32(buf, (uint32_t)entities[i]);
         }
-        flecs_json_array_pop(buf);
     }
 
-    flecs_json_object_pop(buf);
-
-    return 0;
-error:
-    return -1;
+    flecs_json_array_pop(buf);
 }
 
-char* ecs_entity_to_json(
-    const ecs_world_t *world,
-    ecs_entity_t entity,
-    const ecs_entity_to_json_desc_t *desc)
+static
+void flecs_json_serialize_iter_result_entity_labels(
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf,
+    const ecs_json_ser_ctx_t *ser_ctx)
 {
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    (void)buf;
+    (void)ser_ctx;
+    if (!it->count) {
+        return;
+    }
 
-    if (ecs_entity_to_json_buf(world, entity, &buf, desc) != 0) {
-        ecs_strbuf_reset(&buf);
-        return NULL;
+    if (!ser_ctx->idr_doc_name) {
+        return;
     }
 
-    return ecs_strbuf_get(&buf);
-}
+#ifdef FLECS_DOC
+    ecs_table_t *table = it->table;
+    ecs_table_record_t *tr = flecs_id_record_get_table(
+        ser_ctx->idr_doc_name, table);
+    if (tr == NULL) {
+        return;
+    }
 
-bool flecs_json_skip_variable(
-    const char *name)
-{
-    if (!name || name[0] == '_' || !ecs_os_strcmp(name, "this")) {
-        return true;
-    } else {
-        return false;
+    EcsDocDescription *labels = ecs_table_get_column(
+        table, tr->column, it->offset);
+    ecs_assert(labels != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    flecs_json_memberl(buf, "entity_labels");
+    flecs_json_array_push(buf);
+
+    int i;
+    for (i = 0; i < it->count; i ++) {
+        flecs_json_next(buf);
+        flecs_json_string_escape(buf, labels[i].value);
     }
-}
 
-static
-void flecs_json_serialize_id(
-    const ecs_world_t *world,
-    ecs_id_t id,
-    ecs_strbuf_t *buf) 
-{
-    flecs_json_id(buf, world, id);
+    flecs_json_array_pop(buf);
+#endif
 }
 
 static
-void flecs_json_serialize_id_label(
-    const ecs_world_t *world,
-    ecs_id_t id,
-    ecs_strbuf_t *buf) 
+void flecs_json_serialize_iter_result_colors(
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf,
+    const ecs_json_ser_ctx_t *ser_ctx) 
 {
-    ecs_entity_t pred = id, obj = 0;
-    if (ECS_IS_PAIR(id)) {
-        pred = ecs_pair_first(world, id);
-        obj = ecs_pair_second(world, id);
+    (void)buf;
+    (void)ser_ctx;
+
+    if (!it->count) {
+        return;
     }
 
+#ifdef FLECS_DOC
+    if (!ser_ctx->idr_doc_color) {
+        return;
+    }
+
+    ecs_table_record_t *tr = flecs_id_record_get_table(
+        ser_ctx->idr_doc_color, it->table);
+    if (tr == NULL) {
+        return;
+    }
+
+    EcsDocDescription *colors = ecs_table_get_column(
+        it->table, tr->column, it->offset);
+    ecs_assert(colors != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    flecs_json_memberl(buf, "colors");
     flecs_json_array_push(buf);
-    flecs_json_next(buf);
-    flecs_json_label(buf, world, pred);
-    if (obj) {
+
+    int i;
+    for (i = 0; i < it->count; i ++) {
         flecs_json_next(buf);
-        flecs_json_label(buf, world, obj);
+        flecs_json_string(buf, colors[i].value);
     }
+
     flecs_json_array_pop(buf);
+#endif
 }
 
 static
-void flecs_json_serialize_iter_ids(
+int flecs_json_serialize_iter_result_values(
     const ecs_world_t *world,
-    const ecs_iter_t *it, 
+    const ecs_iter_t *it,
     ecs_strbuf_t *buf) 
 {
-    int32_t field_count = it->field_count;
-    if (!field_count) {
-        return;
+    if (!it->ptrs || (it->flags & EcsIterNoData)) {
+        return 0;
     }
 
-    flecs_json_memberl(buf, "ids");
-    flecs_json_array_push(buf);
+    flecs_json_memberl(buf, "values");
+    flecs_json_array_push(buf);
+
+    int32_t i, term_count = it->field_count;
+    for (i = 0; i < term_count; i ++) {
+        ecs_strbuf_list_next(buf);
+
+        const void *ptr = NULL;
+        if (it->ptrs) {
+            ptr = it->ptrs[i];
+        }
+
+        if (!ptr) {
+            /* No data in column. Append 0 if this is not an optional term */
+            if (ecs_field_is_set(it, i)) {
+                ecs_strbuf_appendch(buf, '0');
+                continue;
+            }
+        }
+
+        if (ecs_field_is_writeonly(it, i)) {
+            ecs_strbuf_appendch(buf, '0');
+            continue;
+        }
+
+        /* Get component id (can be different in case of pairs) */
+        ecs_entity_t type = ecs_get_typeid(world, it->ids[i]);
+        if (!type) {
+            /* Odd, we have a ptr but no Component? Not the place of the
+             * serializer to complain about that. */
+            ecs_strbuf_appendch(buf, '0');
+            continue;
+        }
+
+        const EcsComponent *comp = ecs_get(world, type, EcsComponent);
+        if (!comp) {
+            /* Also odd, typeid but not a component? */
+            ecs_strbuf_appendch(buf, '0');
+            continue;
+        }
+
+        const EcsTypeSerializer *ser = ecs_get(
+            world, type, EcsTypeSerializer);
+        if (!ser) {
+            /* Not odd, component just has no reflection data */
+            ecs_strbuf_appendch(buf, '0');
+            continue;
+        }
+
+        /* If term is not set, append empty array. This indicates that the term
+         * could have had data but doesn't */
+        if (!ecs_field_is_set(it, i)) {
+            flecs_json_array_push(buf);
+            flecs_json_array_pop(buf);
+            continue;
+        }
 
-    for (int i = 0; i < field_count; i ++) {
-        flecs_json_next(buf);
-        flecs_json_serialize_id(world, it->terms[i].id, buf);
+        if (ecs_field_is_self(it, i)) {
+            int32_t count = it->count;
+            if (array_to_json_buf_w_type_data(world, ptr, count, buf, comp, ser)) {
+                return -1;
+            }
+        } else {
+            if (array_to_json_buf_w_type_data(world, ptr, 0, buf, comp, ser)) {
+                return -1;
+            }
+        }
     }
 
     flecs_json_array_pop(buf);
+
+    return 0;
 }
 
 static
-void flecs_json_serialize_iter_id_labels(
+int flecs_json_serialize_iter_result_columns(
     const ecs_world_t *world,
-    const ecs_iter_t *it, 
-    ecs_strbuf_t *buf) 
+    const ecs_iter_t *it,
+    ecs_strbuf_t *buf,
+    const ecs_iter_to_json_desc_t *desc)
 {
-    int32_t field_count = it->field_count;
-    if (!field_count) {
-        return;
+    ecs_table_t *table = it->table;
+    if (!table || !table->column_count) {
+        return 0;
     }
 
-    flecs_json_memberl(buf, "id_labels");
+    flecs_json_memberl(buf, "values");
     flecs_json_array_push(buf);
 
-    for (int i = 0; i < field_count; i ++) {
-        flecs_json_next(buf);
-        flecs_json_serialize_id_label(world, it->terms[i].id, buf);
-    }
+    ecs_type_t *type = &table->type;
+    int32_t *column_map = table->column_map;
+    ecs_assert(column_map != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    flecs_json_array_pop(buf);
-}
+    for (int i = 0; i < type->count; i ++) {
+        int32_t storage_column = -1;
+        if (column_map) {
+            storage_column = column_map[i];
+        }
 
-static
-void flecs_json_serialize_id_str(
-    const ecs_world_t *world,
-    ecs_id_t id,
-    ecs_strbuf_t *buf)
-{
-    ecs_strbuf_appendch(buf, '"');
-    if (ECS_IS_PAIR(id)) {
-        ecs_entity_t first = ecs_pair_first(world, id);
-        ecs_entity_t second = ecs_pair_first(world, id);
-        ecs_strbuf_appendch(buf, '(');
-        ecs_get_path_w_sep_buf(world, 0, first, ".", "", buf);
-        ecs_strbuf_appendch(buf, ',');
-        ecs_get_path_w_sep_buf(world, 0, second, ".", "", buf);
-        ecs_strbuf_appendch(buf, ')');
-    } else {
-        ecs_get_path_w_sep_buf(
-            world, 0, id & ECS_COMPONENT_MASK, ".", "", buf);
-    }
-    ecs_strbuf_appendch(buf, '"');
-}
+        if (!desc->serialize_private) {
+            ecs_id_t id = type->array[i];
+            ecs_entity_t e = id;
+            if (ECS_IS_PAIR(id)) {
+                e = ecs_pair_first(world, id);
+            }
+            if (ecs_owns_id(world, e, EcsPrivate)) {
+                continue;
+            }
+        }
 
-static
-void flecs_json_serialize_type_info(
-    const ecs_world_t *world,
-    const ecs_iter_t *it, 
-    ecs_strbuf_t *buf) 
-{
-    int32_t field_count = it->field_count;
-    if (!field_count) {
-        return;
-    }
+        ecs_strbuf_list_next(buf);
 
-    if (it->flags & EcsIterNoData) {
-        return;
-    }
+        if (storage_column == -1) {
+            ecs_strbuf_appendch(buf, '0');
+            continue;
+        }
 
-    flecs_json_memberl(buf, "type_info");
-    flecs_json_object_push(buf);
+        ecs_entity_t typeid = table->data.columns[storage_column].ti->component;
+        if (!typeid) {
+            ecs_strbuf_appendch(buf, '0');
+            continue;
+        }
 
-    for (int i = 0; i < field_count; i ++) {
-        flecs_json_next(buf);
-        ecs_entity_t typeid = 0;
-        if (it->terms[i].inout != EcsInOutNone) {
-            typeid = ecs_get_typeid(world, it->terms[i].id);
+        const EcsComponent *comp = ecs_get(world, typeid, EcsComponent);
+        if (!comp) {
+            ecs_strbuf_appendch(buf, '0');
+            continue;
         }
-        if (typeid) {
-            flecs_json_serialize_id_str(world, typeid, buf);
-            ecs_strbuf_appendch(buf, ':');
-            ecs_type_info_to_json_buf(world, typeid, buf);
-        } else {
-            flecs_json_serialize_id_str(world, it->terms[i].id, buf);
-            ecs_strbuf_appendlit(buf, ":0");
+
+        const EcsTypeSerializer *ser = ecs_get(
+            world, typeid, EcsTypeSerializer);
+        if (!ser) {
+            ecs_strbuf_appendch(buf, '0');
+            continue;
+        }
+
+        void *ptr = ecs_vec_first(&table->data.columns[storage_column].data);
+        if (array_to_json_buf_w_type_data(world, ptr, it->count, buf, comp, ser)) {
+            return -1;
         }
     }
 
-    flecs_json_object_pop(buf);
+    flecs_json_array_pop(buf);
+
+    return 0;
 }
 
 static
-void flecs_json_serialize_field_info(
-    const ecs_world_t *world,
+int flecs_json_serialize_iter_result(
+    const ecs_world_t *world, 
     const ecs_iter_t *it, 
     ecs_strbuf_t *buf,
-    ecs_json_ser_ctx_t *ctx)
-{
-    int32_t field_count = it->field_count;
-    if (!field_count || !it->query) {
-        return;
-    }
+    const ecs_iter_to_json_desc_t *desc,
+    ecs_json_ser_ctx_t *ser_ctx) 
+{    
+    if (desc && desc->serialize_rows) {
+        if (flecs_json_serialize_iter_result_rows(world, it, buf, desc, ser_ctx)) {
+            return -1;
+        }
+    } else {
+        flecs_json_next(buf);
+        flecs_json_object_push(buf);
 
-    const ecs_filter_t *q = it->query;
+        /* Each result can be matched with different component ids. Add them to
+        * the result so clients know with which component an entity was matched */
+        if (desc && desc->serialize_table) {
+            flecs_json_serialize_iter_result_table_type(world, it, buf, desc);
+        } else {
+            if (!desc || desc->serialize_ids) {
+                flecs_json_serialize_iter_result_ids(world, it, buf);
+            }
+            if (desc && desc->serialize_id_labels) {
+                flecs_json_serialize_iter_result_id_labels(world, it, buf);
+            }
+        }
 
-    flecs_json_memberl(buf, "field_info");
-    flecs_json_array_push(buf);
+        /* Include information on which entity the term is matched with */
+        if (!desc || (desc->serialize_sources && !desc->serialize_table)) {
+            flecs_json_serialize_iter_result_sources(world, it, buf);
+        }
 
-    int f;
-    for (f = 0; f < field_count; f ++) {
-        flecs_json_next(buf);
-        flecs_json_serialize_field(world, it, q, f, buf, ctx);
-    }
+        /* Write variable values for current result */
+        if (!desc || desc->serialize_variables) {
+            flecs_json_serialize_iter_result_variables(world, it, buf);
+        }
 
-    flecs_json_array_pop(buf);
-}
+        /* Write labels for variables */
+        if (desc && desc->serialize_variable_labels) {
+            flecs_json_serialize_iter_result_variable_labels(world, it, buf);
+        }
 
-static
-void flecs_json_serialize_query_info(
-    const ecs_world_t *world,
-    const ecs_iter_t *it, 
-    ecs_strbuf_t *buf)
-{
-    if (!it->query) {
-        return;
-    }
+        /* Write ids for variables */
+        if (desc && desc->serialize_variable_ids) {
+            flecs_json_serialize_iter_result_variable_ids(it, buf);
+        }
 
-    const ecs_filter_t *q = it->query;
-    flecs_json_memberl(buf, "query_info");
-    flecs_json_serialize_query(world, q, buf);
-}
+        /* Include information on which terms are set, to support optional terms */
+        if (!desc || (desc->serialize_is_set && !desc->serialize_table)) {
+            flecs_json_serialize_iter_result_is_set(it, buf);
+        }
 
-static
-void flecs_json_serialize_query_plan(
-    const ecs_world_t *world,
-    ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc)
-{
-    (void)world;
-    (void)buf;
-    (void)desc;
+        /* Write entity ids for current result (for queries with This terms) */
+        if (!desc || desc->serialize_entities) {
+            flecs_json_serialize_iter_result_entities(world, it, buf);
+        }
 
-#ifdef FLECS_RULES
-    if (!desc->query) {
-        return;
-    }
+        /* Write ids for entities */
+        if (desc && desc->serialize_entity_ids) {
+            flecs_json_serialize_iter_result_entity_ids(it, buf);
+        }
 
-    if (!ecs_poly_is(desc->query, ecs_rule_t)) {
-        return;
-    }
+        /* Write labels for entities */
+        if (desc && desc->serialize_entity_labels) {
+            flecs_json_serialize_iter_result_entity_labels(it, buf, ser_ctx);
+        }
 
-    const ecs_rule_t *q = desc->query;
-    ecs_poly_assert(q, ecs_rule_t);
+        /* Write colors for entities */
+        if (desc && desc->serialize_colors) {
+            flecs_json_serialize_iter_result_colors(it, buf, ser_ctx);
+        }
 
-    flecs_json_memberl(buf, "query_plan");
+        /* Serialize component values */
+        if (desc && desc->serialize_table) {
+            if (flecs_json_serialize_iter_result_columns(world, it, buf, desc)) {
+                return -1;
+            }
+        } else {
+            if (!desc || desc->serialize_values) {
+                if (flecs_json_serialize_iter_result_values(world, it, buf)) {
+                    return -1;
+                }
+            }
+        }
 
-    bool prev_color = ecs_log_enable_colors(true);
-    char *plan = ecs_rule_str(q);
-    flecs_json_string_escape(buf, plan);
-    ecs_os_free(plan);
-    ecs_log_enable_colors(prev_color);
+        /* Add "alerts": true member if table has entities with active alerts */
+#ifdef FLECS_ALERTS
+        if (it->table && (ecs_id(EcsAlertsActive) != 0)) {
+            /* Only add field if alerts addon is imported */
+            if (ecs_table_has_id(world, it->table, ecs_id(EcsAlertsActive))) {
+                flecs_json_memberl(buf, "alerts");
+                flecs_json_true(buf);
+            }
+        }
 #endif
+
+        flecs_json_object_pop(buf);
+    }
+
+    return 0;
 }
 
-static
-void flecs_json_serialize_query_profile(
-    const ecs_world_t *world,
+int ecs_iter_to_json_buf(
+    ecs_iter_t *it,
     ecs_strbuf_t *buf,
-    const ecs_iter_t *it,
     const ecs_iter_to_json_desc_t *desc)
 {
-    if (!desc->query) {
-        return;
+    ecs_world_t *world = it->real_world;
+    ecs_time_t duration = {0};
+    if (desc && desc->measure_eval_duration) {
+        ecs_time_measure(&duration);
     }
-    
-    ecs_time_t t = {0};
-    int32_t result_count = 0, entity_count = 0, i, sample_count = 100;
-    ecs_size_t component_bytes = 0, shared_component_bytes = 0;
-    double eval_time = 0, eval_min = 0, eval_max = 0;
-    ecs_time_measure(&t);
 
-    for (i = 0; i < sample_count; i ++) {
-        result_count = 0; 
-        entity_count = 0;
-        component_bytes = 0;
-        shared_component_bytes = 0;
+    /* Cache id record for flecs.doc ids */
+    ecs_json_ser_ctx_t ser_ctx;
+    ecs_os_zeromem(&ser_ctx);
+#ifdef FLECS_DOC
+    ser_ctx.idr_doc_name = flecs_id_record_get(world, 
+        ecs_pair_t(EcsDocDescription, EcsName));
+    ser_ctx.idr_doc_color = flecs_id_record_get(world, 
+        ecs_pair_t(EcsDocDescription, EcsDocColor));
+#endif
 
-        ecs_iter_t pit;
-        ecs_iter_poly(world, desc->query, &pit, NULL);
-        pit.flags |= EcsIterIsInstanced;
-    
-        while (ecs_iter_next(&pit)) {
-            result_count ++;
-            entity_count += pit.count;
+    flecs_json_object_push(buf);
 
-            int32_t f, field_count = pit.field_count;
-            for (f = 0; f < field_count; f ++) {
-                size_t size = ecs_field_size(&pit, f + 1);
-                if (ecs_field_is_set(&pit, f + 1) && size) {
-                    if (ecs_field_is_self(&pit, f + 1)) {
-                        component_bytes += 
-                            flecs_uto(ecs_size_t, size) * pit.count;
-                    } else {
-                        shared_component_bytes += flecs_uto(ecs_size_t, size);
-                    }
-                }
-            }
+    /* Serialize component ids of the terms (usually provided by query) */
+    if (!desc || !desc->serialize_rows) {
+        if (!desc || desc->serialize_term_ids) {
+            flecs_json_serialize_iter_ids(world, it, buf);
         }
 
-        double time_measure = ecs_time_measure(&t);
-        if (!i) {
-            eval_min = time_measure;
-        } else if (time_measure < eval_min) {
-            eval_min = time_measure;
+        if (desc && desc->serialize_term_labels) {
+            flecs_json_serialize_iter_id_labels(world, it, buf);
         }
 
-        if (time_measure > eval_max) {
-            eval_max = time_measure;
-        }
+        /* Serialize variable names, if iterator has any */
+        flecs_json_serialize_iter_variables(it, buf);
+    }
 
-        eval_time += time_measure;
+    /* Serialize type info if enabled */
+    if (desc && desc->serialize_type_info) {
+        flecs_json_serialize_type_info(world, it, buf);
+    }
 
-        /* Don't profile for too long */
-        if (eval_time > 0.001) {
-            i ++;
-            break;
-        }
+    /* Serialize field info if enabled */
+    if (desc && desc->serialize_field_info) {
+        flecs_json_serialize_field_info(world, it, buf, &ser_ctx);
     }
 
-    eval_time /= i;
+    /* Serialize query info if enabled */
+    if (desc && desc->serialize_query_info) {
+        flecs_json_serialize_query_info(world, it, buf);
+    }
 
-    flecs_json_memberl(buf, "query_profile");
-    flecs_json_object_push(buf);
-    if (it->query) {
-        /* Correct for profiler */
-        ECS_CONST_CAST(ecs_filter_t*, it->query)->eval_count -= i;
-        flecs_json_memberl(buf, "eval_count");
-        flecs_json_number(buf, it->query->eval_count);
+    /* Serialize query plan if enabled */
+    if (desc && desc->serialize_query_plan) {
+        flecs_json_serialize_query_plan(world, buf, desc);
     }
-    flecs_json_memberl(buf, "result_count");
-    flecs_json_number(buf, result_count);
-    flecs_json_memberl(buf, "entity_count");
-    flecs_json_number(buf, entity_count);
 
-    flecs_json_memberl(buf, "eval_time_avg_us");
-    flecs_json_number(buf, eval_time * 1000.0 * 1000.0);
-    flecs_json_memberl(buf, "eval_time_min_us");
-    flecs_json_number(buf, eval_min * 1000.0 * 1000.0);
-    flecs_json_memberl(buf, "eval_time_max_us");
-    flecs_json_number(buf, eval_max * 1000.0 * 1000.0);
+    /* Profile query */
+    if (desc && desc->serialize_query_profile) {
+        flecs_json_serialize_query_profile(world, buf, it, desc);
+    }
 
-    flecs_json_memberl(buf, "component_bytes");
-    flecs_json_number(buf, component_bytes);
-    flecs_json_memberl(buf, "shared_component_bytes");
-    flecs_json_number(buf, shared_component_bytes);
+    /* Serialize results */
+    if (!desc || !desc->dont_serialize_results) {
+        flecs_json_memberl(buf, "results");
+        flecs_json_array_push(buf);
 
-    flecs_json_object_pop(buf);
-}
+        /* Use instancing for improved performance */
+        ECS_BIT_SET(it->flags, EcsIterIsInstanced);
 
-static
-void flecs_json_serialize_iter_variables(ecs_iter_t *it, ecs_strbuf_t *buf) {
-    char **variable_names = it->variable_names;
-    int32_t var_count = it->variable_count;
-    int32_t actual_count = 0;
+        /* If serializing entire table, don't bother letting the iterator populate
+        * data fields as we'll be iterating all columns. */
+        if (desc && desc->serialize_table) {
+            ECS_BIT_SET(it->flags, EcsIterNoData);
+        }
 
-    for (int i = 1; i < var_count; i ++) {
-        const char *var_name = variable_names[i];
-        if (flecs_json_skip_variable(var_name)) continue;
+        ecs_iter_next_action_t next = it->next;
+        while (next(it)) {
+            if (flecs_json_serialize_iter_result(world, it, buf, desc, &ser_ctx)) {
+                ecs_strbuf_reset(buf);
+                ecs_iter_fini(it);
+                return -1;
+            }
+        }
 
-        if (!actual_count) {
-            flecs_json_memberl(buf, "vars");
-            flecs_json_array_push(buf);
-            actual_count ++;
+        flecs_json_array_pop(buf);
+    } else {
+        ecs_iter_fini(it);
+    }
+
+    int32_t f, field_count = it->field_count;
+    if (desc && (desc->serialize_rows || desc->serialize_values)) {
+        for (f = 0; f < field_count; f ++) {
+            ecs_os_free(ser_ctx.value_ctx[f].id_label);
         }
+    }
 
-        ecs_strbuf_list_next(buf);
-        flecs_json_string(buf, var_name);
+    if (desc && desc->measure_eval_duration) {
+        double dt = ecs_time_measure(&duration);
+        flecs_json_memberl(buf, "eval_duration");
+        flecs_json_number(buf, dt);
     }
 
-    if (actual_count) {
-        flecs_json_array_pop(buf);
+    flecs_json_object_pop(buf);
+
+    return 0;
+}
+
+char* ecs_iter_to_json(
+    ecs_iter_t *it,
+    const ecs_iter_to_json_desc_t *desc)
+{
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+
+    if (ecs_iter_to_json_buf(it, &buf, desc)) {
+        ecs_strbuf_reset(&buf);
+        return NULL;
     }
+
+    return ecs_strbuf_get(&buf);
 }
 
-static
-void flecs_json_serialize_iter_result_ids(
-    const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf)
+int ecs_world_to_json_buf(
+    ecs_world_t *world,
+    ecs_strbuf_t *buf_out,
+    const ecs_world_to_json_desc_t *desc)
 {
-    flecs_json_memberl(buf, "ids");
-    flecs_json_array_push(buf);
+    ecs_query_desc_t query_desc = {0};
 
-    for (int i = 0; i < it->field_count; i ++) {
-        flecs_json_next(buf);
-        flecs_json_serialize_id(world, ecs_field_id(it, i + 1), buf);
+    if (desc && desc->serialize_builtin && desc->serialize_modules) {
+        query_desc.terms[0].id = EcsAny;
+    } else {
+        bool serialize_builtin = desc && desc->serialize_builtin;
+        bool serialize_modules = desc && desc->serialize_modules;
+        int32_t term_id = 0;
+
+        if (!serialize_builtin) {
+            query_desc.terms[term_id].id = ecs_pair(EcsChildOf, EcsFlecs);
+            query_desc.terms[term_id].oper = EcsNot;
+            query_desc.terms[term_id].src.id = EcsSelf | EcsUp;
+            term_id ++;
+        }
+        if (!serialize_modules) {
+            query_desc.terms[term_id].id = EcsModule;
+            query_desc.terms[term_id].oper = EcsNot;
+            query_desc.terms[term_id].src.id = EcsSelf | EcsUp;
+        }
     }
 
-    flecs_json_array_pop(buf);
+    query_desc.flags = EcsQueryMatchDisabled|EcsQueryMatchPrefab;
+
+    ecs_query_t *q = ecs_query_init(world, &query_desc);
+    if (!q) {
+        return -1;
+    }
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_to_json_desc_t json_desc = { 
+        .serialize_table = true,
+        .serialize_ids = true,
+        .serialize_entities = true,
+        .serialize_private = true
+    };
+
+    int ret = ecs_iter_to_json_buf(&it, buf_out, &json_desc);
+    ecs_query_fini(q);
+    return ret;
 }
 
-static
-void flecs_json_serialize_iter_result_id_labels(
-    const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf)
+char* ecs_world_to_json(
+    ecs_world_t *world,
+    const ecs_world_to_json_desc_t *desc)
 {
-    flecs_json_memberl(buf, "id_labels");
-    flecs_json_array_push(buf);
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
 
-    for (int i = 0; i < it->field_count; i ++) {
-        flecs_json_next(buf);
-        flecs_json_serialize_id_label(world, ecs_field_id(it, i + 1), buf);
+    if (ecs_world_to_json_buf(world, &buf, desc)) {
+        ecs_strbuf_reset(&buf);
+        return NULL;
     }
 
-    flecs_json_array_pop(buf);
+    return ecs_strbuf_get(&buf);
 }
 
-static
-void flecs_json_serialize_iter_result_table_type(
+#endif
+
+/**
+ * @file json/serialize_type_info.c
+ * @brief Serialize type (reflection) information to JSON.
+ */
+
+
+#ifdef FLECS_JSON
+
+void flecs_json_serialize_field(
     const ecs_world_t *world,
     const ecs_iter_t *it,
+    const ecs_query_t *q,
+    int field,
     ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc)
+    ecs_json_ser_ctx_t *ctx)
 {
-    if (!it->table) {
-        return;
-    }
+    flecs_json_object_push(buf);
+    flecs_json_memberl(buf, "id");
 
-    if (desc->serialize_ids) {
-        flecs_json_memberl(buf, "ids");
-        flecs_json_array_push(buf);
+    flecs_json_serialize_get_field_ctx(world, it, field, ctx);
+    ecs_json_value_ser_ctx_t *value_ctx = &ctx->value_ctx[field];
 
-        ecs_type_t *type = &it->table->type;
-        for (int i = 0; i < type->count; i ++) {
-            ecs_id_t id = type->array[i];
-            if (!desc->serialize_private) {
-                ecs_entity_t e = id;
-                if (ECS_IS_PAIR(id)) {
-                    e = ecs_pair_first(world, id);
-                }
-                if (ecs_owns_id(world, e, EcsPrivate)) {
-                    continue;
-                }
+    if (value_ctx->id_label) {
+        flecs_json_string(buf, value_ctx->id_label);
+
+        const ecs_term_t *term = &q->terms[0];
+        int t;
+        for (t = 0; t < q->term_count; t ++) {
+            if (q->terms[t].field_index == field) {
+                term = &q->terms[t];
+                break;
             }
-            flecs_json_next(buf);
-            flecs_json_serialize_id(world, id, buf);
         }
 
-        flecs_json_array_pop(buf);
-    }
-    if (desc->serialize_id_labels) {
-        flecs_json_memberl(buf, "id_labels");
-        flecs_json_array_push(buf);
+        if (term->oper != EcsNot) {
+            if (term->oper == EcsOptional) {
+                flecs_json_memberl(buf, "optional");
+                flecs_json_bool(buf, true);
+            }
 
-        ecs_type_t *type = &it->table->type;
-        for (int i = 0; i < type->count; i ++) {
-            ecs_id_t id = type->array[i];
-            if (!desc->serialize_private) {
-                ecs_entity_t e = id;
-                if (ECS_IS_PAIR(id)) {
-                    e = ecs_pair_first(world, id);
-                }
-                if (ecs_owns_id(world, e, EcsPrivate)) {
-                    continue;
+            if (ECS_IS_PAIR(term->id)) {
+                if ((term->first.id & EcsIsEntity) && ECS_TERM_REF_ID(&term->first)) {
+                    if (ecs_has_id(world, ECS_TERM_REF_ID(&term->first), EcsExclusive)) {
+                        flecs_json_memberl(buf, "exclusive");
+                        flecs_json_bool(buf, true);
+                    }
                 }
             }
-            flecs_json_next(buf);
-            flecs_json_serialize_id_label(world, id, buf);
-        }
 
-        flecs_json_array_pop(buf);
-    }
-}
+            if (value_ctx->type) {
+                flecs_json_memberl(buf, "type");
+                flecs_json_label(buf, world, value_ctx->type);
 
-static
-void flecs_json_serialize_iter_result_sources(
-    const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf)
-{
-    flecs_json_memberl(buf, "sources");
-    flecs_json_array_push(buf);
+                const char *symbol = ecs_get_symbol(world, value_ctx->type);
+                if (symbol) {
+                    flecs_json_memberl(buf, "symbol");
+                    flecs_json_string(buf, symbol);
+                }
+            }
 
-    for (int i = 0; i < it->field_count; i ++) {
-        flecs_json_next(buf);
-        ecs_entity_t subj = it->sources[i];
-        if (subj) {            
-            flecs_json_path(buf, world, subj);
+            if (value_ctx->ser) {
+                flecs_json_memberl(buf, "schema");
+                ecs_type_info_to_json_buf(world, value_ctx->type, buf);
+            }
         } else {
-            ecs_strbuf_appendch(buf, '0');
+            flecs_json_memberl(buf, "not");
+            flecs_json_bool(buf, true);
         }
+    } else {
+        ecs_strbuf_appendlit(buf, "0");
     }
 
-    flecs_json_array_pop(buf);
+    flecs_json_object_pop(buf);
 }
 
-bool flecs_json_serialize_iter_result_is_set(
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf)
-{
-    if (!(it->flags & EcsIterHasCondSet)) {
-        return false;
-    }
-
-    flecs_json_memberl(buf, "is_set");
-    flecs_json_array_push(buf);
+#endif
 
-    for (int i = 0; i < it->field_count; i ++) {
-        ecs_strbuf_list_next(buf);
-        if (ecs_field_is_set(it, i + 1)) {
-            flecs_json_true(buf);
-        } else {
-            flecs_json_false(buf);
-        }
-    }
+/**
+ * @file json/serialize_iter_rows.c
+ * @brief Serialize (component) values to JSON strings.
+ */
 
-    flecs_json_array_pop(buf);
 
-    return true;
-}
+#ifdef FLECS_JSON
 
 static
-void flecs_json_serialize_iter_result_variables(
+bool flecs_json_serialize_row_tags(
     const ecs_world_t *world,
     const ecs_iter_t *it,
-    ecs_strbuf_t *buf) 
+    ecs_strbuf_t *buf)  
 {
-    char **variable_names = it->variable_names;
-    ecs_var_t *variables = it->variables;
-    int32_t var_count = it->variable_count;
-    int32_t actual_count = 0;
+    int32_t f, field_count = it->field_count;
+    ecs_id_t *ids = it->ids;
+    void **ptrs = it->ptrs;
+    
+    int32_t tag_count = 0;
+    for (f = 0; f < field_count; f ++) {
+        if (!ecs_field_is_set(it, f)) {
+            continue;
+        }
 
-    for (int i = 1; i < var_count; i ++) {
-        const char *var_name = variable_names[i];
-        if (flecs_json_skip_variable(var_name)) continue;
+        ecs_id_t id = ids[f];
+        if (ECS_IS_PAIR(id)) {
+            continue;
+        }
 
-        if (!actual_count) {
-            flecs_json_memberl(buf, "vars");
+        if (ptrs[f]) {
+            continue; /* Ignore components */
+        }
+
+        if (!tag_count) {
+            flecs_json_memberl(buf, "tags");
             flecs_json_array_push(buf);
-            actual_count ++;
         }
 
-        ecs_strbuf_list_next(buf);
-        flecs_json_path(buf, world, variables[i].entity);
+        flecs_json_next(buf);
+        flecs_json_label(buf, world, id);
+
+        tag_count ++;
     }
 
-    if (actual_count) {
+    if (tag_count) {
         flecs_json_array_pop(buf);
     }
+
+    return tag_count != 0;
 }
 
 static
-void flecs_json_serialize_iter_result_variable_labels(
+bool flecs_json_serialize_row_pairs(
     const ecs_world_t *world,
     const ecs_iter_t *it,
-    ecs_strbuf_t *buf) 
+    ecs_strbuf_t *buf)  
 {
-    char **variable_names = it->variable_names;
-    ecs_var_t *variables = it->variables;
-    int32_t var_count = it->variable_count;
-    int32_t actual_count = 0;
+    int32_t f, field_count = it->field_count;
+    ecs_id_t *ids = it->ids;
+    
+    int32_t pair_count = 0;
+    for (f = 0; f < field_count; f ++) {
+        if (!ecs_field_is_set(it, f)) {
+            continue;
+        }
 
-    for (int i = 1; i < var_count; i ++) {
-        const char *var_name = variable_names[i];
-        if (flecs_json_skip_variable(var_name)) continue;
+        ecs_id_t id = ids[f];
+        if (!ECS_IS_PAIR(id)) {
+            continue;
+        }
 
-        if (!actual_count) {
-            flecs_json_memberl(buf, "var_labels");
-            flecs_json_array_push(buf);
-            actual_count ++;
+        if (!pair_count) {
+            flecs_json_memberl(buf, "pairs");
+            flecs_json_object_push(buf);
         }
 
-        ecs_strbuf_list_next(buf);
-        flecs_json_label(buf, world, variables[i].entity);
+        flecs_json_next(buf);
+        ecs_entity_t first = ecs_pair_first(world, id);
+        ecs_entity_t second = ecs_pair_second(world, id);
+
+        flecs_json_label(buf, world, first);
+        ecs_strbuf_appendlit(buf, ":");
+        flecs_json_label(buf, world, second);
+
+        pair_count ++;
     }
 
-    if (actual_count) {
-        flecs_json_array_pop(buf);
+    if (pair_count) {
+        flecs_json_object_pop(buf);
     }
+
+    return pair_count != 0;
 }
 
 static
-void flecs_json_serialize_iter_result_variable_ids(
+bool flecs_json_serialize_row_vars(
+    const ecs_world_t *world,
     const ecs_iter_t *it,
-    ecs_strbuf_t *buf) 
+    ecs_strbuf_t *buf)
 {
     char **variable_names = it->variable_names;
-    ecs_var_t *variables = it->variables;
     int32_t var_count = it->variable_count;
     int32_t actual_count = 0;
 
@@ -54441,645 +54146,707 @@ void flecs_json_serialize_iter_result_variable_ids(
         const char *var_name = variable_names[i];
         if (flecs_json_skip_variable(var_name)) continue;
 
+        ecs_entity_t var = it->variables[i].entity;
+        if (!var) {
+            /* Can't happen, but not the place of the serializer to complain */
+            continue;
+        }
+
         if (!actual_count) {
-            flecs_json_memberl(buf, "var_ids");
-            flecs_json_array_push(buf);
+            flecs_json_memberl(buf, "vars");
+            flecs_json_object_push(buf);
             actual_count ++;
         }
 
-        ecs_strbuf_list_next(buf);
-        flecs_json_u32(buf, (uint32_t)variables[i].entity);
+        flecs_json_member(buf, var_name);
+        flecs_json_label(buf, world, var);
     }
 
     if (actual_count) {
-        flecs_json_array_pop(buf);
+        flecs_json_object_pop(buf);
     }
+
+    return actual_count != 0;
 }
 
 static
-bool flecs_json_serialize_iter_result_entity_names(
+bool flecs_json_serialize_tags_pairs_vars(
+    const ecs_world_t *world,
     const ecs_iter_t *it,
-    ecs_strbuf_t *buf) 
+    ecs_strbuf_t *buf)
 {
-    ecs_assert(it->count != 0, ECS_INTERNAL_ERROR, NULL);
-
-    EcsIdentifier *names = ecs_table_get_id(it->world, it->table, 
-        ecs_pair(ecs_id(EcsIdentifier), EcsName), it->offset);
-    if (!names) {
-        return false;
-    }
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        flecs_json_next(buf);
-        flecs_json_string(buf, names[i].value);
+    bool result = false;
+    ecs_strbuf_list_push(buf, "", ",");
+    result |= flecs_json_serialize_row_tags(world, it, buf);
+    result |= flecs_json_serialize_row_pairs(world, it, buf);
+    result |= flecs_json_serialize_row_vars(world, it, buf);
+    result |= flecs_json_serialize_iter_result_is_set(it, buf);
+    ecs_strbuf_list_pop(buf, "");
+    if (!result) {
+        ecs_strbuf_reset(buf);
     }
-
-    return true;
+    return result;
 }
 
 static
-void flecs_json_serialize_iter_result_entity_ids(
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf) 
+bool flecs_json_serialize_table_row_tags(
+    const ecs_world_t *world,
+    const ecs_table_t *table,
+    ecs_strbuf_t *buf,
+    const ecs_iter_to_json_desc_t *desc)
 {
-    if (!it->count) {
-        return;
-    }
+    int32_t f, type_count = table->type.count;
+    ecs_id_t *ids = table->type.array;
+    int32_t *column_map = table->column_map;
+    
+    int32_t tag_count = 0;
+    for (f = 0; f < type_count; f ++) {
+        ecs_id_t id = ids[f];
+        if (ECS_IS_PAIR(id)) {
+            continue;
+        }
 
-    flecs_json_memberl(buf, "entity_ids");
-    flecs_json_array_push(buf);
+        if (column_map[f] != -1) {
+            continue; /* Ignore components */
+        }
 
-    ecs_entity_t *entities = it->entities;
+        if (!desc || !desc->serialize_private) {
+            if (ecs_has_id(world, id & ECS_COMPONENT_MASK, EcsPrivate)) {
+                continue;
+            }
+        }
 
-    int i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        flecs_json_next(buf);
-        flecs_json_u32(buf, (uint32_t)entities[i]);
-    }
+        if (!tag_count) {
+            flecs_json_memberl(buf, "tags");
+            flecs_json_array_push(buf);
+        }
 
-    flecs_json_array_pop(buf);
-}
+        flecs_json_next(buf);
+        flecs_json_label(buf, world, id);
 
-static
-void flecs_json_serialize_iter_result_parent(
-    const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf) 
-{
-    ecs_table_t *table = it->table;
-    if (!(table->flags & EcsTableHasChildOf)) {
-        return;
+        tag_count ++;
     }
 
-    ecs_table_record_t *tr = flecs_id_record_get_table(
-        world->idr_childof_wildcard, it->table);
-    if (tr == NULL) {
-        return;
+    if (tag_count) {
+        flecs_json_array_pop(buf);
     }
 
-    ecs_id_t id = table->type.array[tr->index];
-    ecs_entity_t parent = ecs_pair_second(world, id);
-    char *path = ecs_get_path_w_sep(world, 0, parent, ".", "");
-    flecs_json_memberl(buf, "parent");
-    flecs_json_string(buf, path);
-    ecs_os_free(path);
+    return tag_count != 0;
 }
 
 static
-void flecs_json_serialize_iter_result_entities(
+bool flecs_json_serialize_table_row_pairs(
     const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf) 
+    const ecs_table_t *table,
+    ecs_strbuf_t *buf,
+    const ecs_iter_to_json_desc_t *desc)
 {
-    if (!it->count) {
-        return;
-    }
+    int32_t f, type_count = table->type.count;
+    ecs_id_t *ids = table->type.array;
+    
+    int32_t pair_count = 0;
+    bool same_first = false;
 
-    flecs_json_serialize_iter_result_parent(world, it, buf);
+    for (f = 0; f < type_count; f ++) {
+        ecs_id_t id = ids[f];
+        if (!ECS_IS_PAIR(id)) {
+            continue;
+        }
 
-    flecs_json_memberl(buf, "entities");
-    flecs_json_array_push(buf);
+        ecs_entity_t first = flecs_entities_get_alive(
+            world, ECS_PAIR_FIRST(id));
+        if (!desc || !desc->serialize_private) {
+            if (ecs_has_id(world, first, EcsPrivate)) {
+                continue;
+            }
+        }
 
-    if (!flecs_json_serialize_iter_result_entity_names(it, buf)) {
-        ecs_entity_t *entities = it->entities;
+        if (!pair_count) {
+            flecs_json_memberl(buf, "pairs");
+            flecs_json_object_push(buf);            
+        }
 
-        int i, count = it->count;
-        for (i = 0; i < count; i ++) {
-            flecs_json_next(buf);
-            flecs_json_u32(buf, (uint32_t)entities[i]);
+        ecs_entity_t second = flecs_entities_get_alive(
+            world, ECS_PAIR_SECOND(id));
+
+        bool is_last = f == (type_count - 1);
+        bool is_same = !is_last && 
+            (ECS_PAIR_FIRST(ids[f + 1]) == ECS_PAIR_FIRST(id));
+
+        if (same_first && f && ECS_PAIR_FIRST(ids[f - 1]) != ECS_PAIR_FIRST(id)) {
+            /* New pair has different first elem, so close array */
+            flecs_json_array_pop(buf);
+            same_first = false;
         }
-    }
 
-    flecs_json_array_pop(buf);
-}
+        if (!same_first) {
+            /* Only append pair label if we're not appending to array */
+            flecs_json_next(buf);
+            flecs_json_label(buf, world, first);
+            ecs_strbuf_appendlit(buf, ":");
 
-static
-void flecs_json_serialize_iter_result_entity_labels(
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf,
-    const ecs_json_ser_ctx_t *ser_ctx)
-{
-    (void)buf;
-    (void)ser_ctx;
-    if (!it->count) {
-        return;
-    }
+            /* Open array scope if this is a pair with multiple targets */
+            if (is_same) {
+                flecs_json_array_push(buf);
+                same_first = true;
+            }
+        } 
+        if (same_first) {
+            flecs_json_next(buf);
+        }
 
-    if (!ser_ctx->idr_doc_name) {
-        return;
-    }
+        flecs_json_label(buf, world, second);
 
-#ifdef FLECS_DOC
-    ecs_table_t *table = it->table;
-    ecs_table_record_t *tr = flecs_id_record_get_table(
-        ser_ctx->idr_doc_name, table);
-    if (tr == NULL) {
-        return;
+        pair_count ++;
     }
 
-    EcsDocDescription *labels = ecs_table_get_column(
-        table, tr->column, it->offset);
-    ecs_assert(labels != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    flecs_json_memberl(buf, "entity_labels");
-    flecs_json_array_push(buf);
+    if (same_first) {
+        flecs_json_array_pop(buf);
+    }
 
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        flecs_json_next(buf);
-        flecs_json_string_escape(buf, labels[i].value);
+    if (pair_count) {
+        flecs_json_object_pop(buf);
     }
 
-    flecs_json_array_pop(buf);
-#endif
+    return pair_count != 0;
 }
 
 static
-void flecs_json_serialize_iter_result_colors(
-    const ecs_iter_t *it,
+bool flecs_json_serialize_table_tags_pairs_vars(
+    const ecs_world_t *world,
+    ecs_table_t *table,
     ecs_strbuf_t *buf,
-    const ecs_json_ser_ctx_t *ser_ctx) 
+    const ecs_iter_to_json_desc_t *desc)
 {
-    (void)buf;
-    (void)ser_ctx;
-
-    if (!it->count) {
-        return;
+    bool result = false;
+    ecs_strbuf_list_push(buf, "", ",");
+    result |= flecs_json_serialize_table_row_tags(world, table, buf, desc);
+    result |= flecs_json_serialize_table_row_pairs(world, table, buf, desc);
+    ecs_strbuf_list_pop(buf, "");
+    if (!result) {
+        ecs_strbuf_reset(buf);
     }
+    return result;
+}
 
-#ifdef FLECS_DOC
-    if (!ser_ctx->idr_doc_color) {
-        return;
+static
+bool flecs_json_serialize_get_value_ctx(
+    const ecs_world_t *world,
+    ecs_id_t id,
+    ecs_json_value_ser_ctx_t *ctx)
+{
+    if (!id) {
+        return false;
     }
+    if (!ctx->initialized) {
+        ctx->initialized = true;
 
-    ecs_table_record_t *tr = flecs_id_record_get_table(
-        ser_ctx->idr_doc_color, it->table);
-    if (tr == NULL) {
-        return;
-    }
+        ecs_strbuf_t idlbl = ECS_STRBUF_INIT;
+        flecs_json_id_member(&idlbl, world, id);
+        ctx->id_label = ecs_strbuf_get(&idlbl);
 
-    EcsDocDescription *colors = ecs_table_get_column(
-        it->table, tr->column, it->offset);
-    ecs_assert(colors != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_entity_t type = ecs_get_typeid(world, id);
+        if (!type) {
+            return false;
+        }
 
-    flecs_json_memberl(buf, "colors");
-    flecs_json_array_push(buf);
+        ctx->type = type;
+        ctx->ser = ecs_get(world, type, EcsTypeSerializer);
+        if (!ctx->ser) {
+            return false;
+        }
 
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        flecs_json_next(buf);
-        flecs_json_string(buf, colors[i].value);
+        return true;
+    } else {
+        return ctx->ser != NULL;
     }
+}
 
-    flecs_json_array_pop(buf);
-#endif
+bool flecs_json_serialize_get_field_ctx(
+    const ecs_world_t *world,
+    const ecs_iter_t *it,
+    int32_t f,
+    ecs_json_ser_ctx_t *ser_ctx)
+{
+    ecs_json_value_ser_ctx_t *value_ctx = &ser_ctx->value_ctx[f];
+    if (it->query) {
+        return flecs_json_serialize_get_value_ctx(
+            world, it->query->ids[f], value_ctx);
+    } else if (it->ids[f]) {
+        return flecs_json_serialize_get_value_ctx(world, it->ids[f], value_ctx);
+    } else {
+        return false;
+    }
 }
 
 static
-int flecs_json_serialize_iter_result_values(
+int flecs_json_serialize_row_components(
     const ecs_world_t *world,
     const ecs_iter_t *it,
-    ecs_strbuf_t *buf) 
+    ecs_strbuf_t *buf,
+    ecs_json_ser_ctx_t *ser_ctx,
+    int32_t row)
 {
-    if (!it->ptrs || (it->flags & EcsIterNoData)) {
+    void **ptrs = it->ptrs;
+    if (!ptrs) {
         return 0;
     }
 
-    flecs_json_memberl(buf, "values");
-    flecs_json_array_push(buf);
-
-    int32_t i, term_count = it->field_count;
-    for (i = 0; i < term_count; i ++) {
-        ecs_strbuf_list_next(buf);
-
-        const void *ptr = NULL;
-        if (it->ptrs) {
-            ptr = it->ptrs[i];
+    int32_t f, field_count = it->field_count, component_count = 0;
+    for (f = 0; f < field_count; f ++) {
+        if (!ecs_field_is_set(it, f)) {
+            continue;
         }
 
+        void *ptr = ptrs[f];
         if (!ptr) {
-            /* No data in column. Append 0 if this is not an optional term */
-            if (ecs_field_is_set(it, i + 1)) {
-                ecs_strbuf_appendch(buf, '0');
-                continue;
-            }
-        }
-
-        if (ecs_field_is_writeonly(it, i + 1)) {
-            ecs_strbuf_appendch(buf, '0');
             continue;
         }
 
-        /* Get component id (can be different in case of pairs) */
-        ecs_entity_t type = ecs_get_typeid(world, it->ids[i]);
-        if (!type) {
-            /* Odd, we have a ptr but no Component? Not the place of the
-             * serializer to complain about that. */
-            ecs_strbuf_appendch(buf, '0');
-            continue;
+        if (ecs_field_is_self(it, f)) {
+            ptr = ECS_ELEM(ptr, it->sizes[f], row);
         }
 
-        const EcsComponent *comp = ecs_get(world, type, EcsComponent);
-        if (!comp) {
-            /* Also odd, typeid but not a component? */
-            ecs_strbuf_appendch(buf, '0');
+        ecs_json_value_ser_ctx_t *value_ctx = &ser_ctx->value_ctx[f];
+        if (!flecs_json_serialize_get_value_ctx(world, it->ids[f], value_ctx)) {
             continue;
         }
 
-        const EcsMetaTypeSerialized *ser = ecs_get(
-            world, type, EcsMetaTypeSerialized);
-        if (!ser) {
-            /* Not odd, component just has no reflection data */
-            ecs_strbuf_appendch(buf, '0');
-            continue;
+        if (!component_count) {
+            flecs_json_memberl(buf, "components");
+            flecs_json_object_push(buf);
         }
 
-        /* If term is not set, append empty array. This indicates that the term
-         * could have had data but doesn't */
-        if (!ecs_field_is_set(it, i + 1)) {
-            flecs_json_array_push(buf);
-            flecs_json_array_pop(buf);
-            continue;
+        flecs_json_member(buf, value_ctx->id_label);
+        if (flecs_json_ser_type(world, &value_ctx->ser->ops, ptr, buf) != 0) {
+            return -1;
         }
 
-        if (ecs_field_is_self(it, i + 1)) {
-            int32_t count = it->count;
-            if (array_to_json_buf_w_type_data(world, ptr, count, buf, comp, ser)) {
-                return -1;
-            }
-        } else {
-            if (array_to_json_buf_w_type_data(world, ptr, 0, buf, comp, ser)) {
-                return -1;
-            }
-        }
+        component_count ++;
     }
 
-    flecs_json_array_pop(buf);
+    if (component_count) {
+        flecs_json_object_pop(buf);
+    }
 
     return 0;
 }
 
 static
-int flecs_json_serialize_iter_result_columns(
+int flecs_json_serialize_row_table_components(
     const ecs_world_t *world,
-    const ecs_iter_t *it,
+    ecs_table_t *table,
     ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc)
+    ecs_json_value_ser_ctx_t *values_ctx,
+    int32_t row,
+    int32_t column_count)
 {
-    ecs_table_t *table = it->table;
-    if (!table || !table->column_count) {
-        return 0;
-    }
-
-    flecs_json_memberl(buf, "values");
-    flecs_json_array_push(buf);
-
-    ecs_type_t *type = &table->type;
-    int32_t *column_map = table->column_map;
-    ecs_assert(column_map != NULL, ECS_INTERNAL_ERROR, NULL);
+    int32_t f, component_count = 0;
+    for (f = 0; f < column_count; f ++) {
+        ecs_column_t *column = &table->data.columns[f];
+        ecs_json_value_ser_ctx_t *value_ctx = &values_ctx[f];
+        if (!flecs_json_serialize_get_value_ctx(world, column->id, value_ctx)) {
+            continue;
+        }
 
-    for (int i = 0; i < type->count; i ++) {
-        int32_t storage_column = -1;
-        if (column_map) {
-            storage_column = column_map[i];
+        if (!component_count) {
+            flecs_json_memberl(buf, "components");
+            flecs_json_object_push(buf);
         }
 
-        if (!desc->serialize_private) {
-            ecs_id_t id = type->array[i];
-            ecs_entity_t e = id;
-            if (ECS_IS_PAIR(id)) {
-                e = ecs_pair_first(world, id);
-            }
-            if (ecs_owns_id(world, e, EcsPrivate)) {
-                continue;
-            }
+        void *ptr = ecs_vec_get(&column->data, column->size, row);
+        ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(value_ctx->id_label != NULL, ECS_INTERNAL_ERROR, NULL);
+        flecs_json_member(buf, value_ctx->id_label);
+        if (flecs_json_ser_type(world, &value_ctx->ser->ops, ptr, buf) != 0) {
+            return -1;
         }
 
-        ecs_strbuf_list_next(buf);
+        component_count ++;
+    }
 
-        if (storage_column == -1) {
-            ecs_strbuf_appendch(buf, '0');
-            continue;
-        }
+    if (component_count) {
+        flecs_json_object_pop(buf);
+    }
 
-        ecs_entity_t typeid = table->data.columns[storage_column].ti->component;
-        if (!typeid) {
-            ecs_strbuf_appendch(buf, '0');
-            continue;
-        }
+    return 0;
+}
 
-        const EcsComponent *comp = ecs_get(world, typeid, EcsComponent);
-        if (!comp) {
-            ecs_strbuf_appendch(buf, '0');
-            continue;
+static
+void flecs_json_serialize_iter_this_row(
+    const ecs_iter_t *it,
+    const char *parent_path,
+    const EcsIdentifier *names,
+    int32_t row,
+    ecs_strbuf_t *buf)
+{
+    if (parent_path) {
+        flecs_json_memberl(buf, "parent");
+        flecs_json_string(buf, parent_path);
+    }
+
+    flecs_json_memberl(buf, "name");
+    if (names) {
+        flecs_json_string(buf, names[row].value);
+    } else {
+        ecs_strbuf_appendlit(buf, "\"");
+        ecs_strbuf_appendint(buf, flecs_uto(int64_t, 
+            (uint32_t)it->entities[row]));
+        ecs_strbuf_appendlit(buf, "\"");
+    }
+}
+
+static
+int flecs_json_serialize_iter_result_query_rows(
+    const ecs_world_t *world, 
+    const ecs_iter_t *it, 
+    ecs_strbuf_t *buf,
+    ecs_json_ser_ctx_t *ser_ctx,
+    int32_t count,
+    bool has_this,
+    const char *parent_path,
+    const EcsIdentifier *names)
+{
+    /* Serialize tags, pairs, vars once, since they're the same for each row */
+    ecs_strbuf_t tags_pairs_vars_buf = ECS_STRBUF_INIT;
+    int32_t tags_pairs_vars_len = 0;
+    char *tags_pairs_vars = NULL;
+    if (flecs_json_serialize_tags_pairs_vars(world, it, &tags_pairs_vars_buf)) {
+        tags_pairs_vars_len = ecs_strbuf_written(&tags_pairs_vars_buf);
+        tags_pairs_vars = ecs_strbuf_get(&tags_pairs_vars_buf);
+    }
+
+    int32_t i;
+    for (i = 0; i < count; i ++) {
+        flecs_json_next(buf);
+        flecs_json_object_push(buf);
+
+        if (has_this) {
+            flecs_json_serialize_iter_this_row(
+                it, parent_path, names, i, buf);
         }
 
-        const EcsMetaTypeSerialized *ser = ecs_get(
-            world, typeid, EcsMetaTypeSerialized);
-        if (!ser) {
-            ecs_strbuf_appendch(buf, '0');
-            continue;
+        if (tags_pairs_vars) {
+            ecs_strbuf_list_appendstrn(buf, 
+                tags_pairs_vars, tags_pairs_vars_len);
         }
 
-        void *ptr = ecs_vec_first(&table->data.columns[storage_column].data);
-        if (array_to_json_buf_w_type_data(world, ptr, it->count, buf, comp, ser)) {
+        if (flecs_json_serialize_row_components(world, it, buf, ser_ctx, i)) {
             return -1;
         }
+
+        flecs_json_object_pop(buf);
     }
 
-    flecs_json_array_pop(buf);
+    ecs_os_free(tags_pairs_vars);
 
     return 0;
 }
 
 static
-int flecs_json_serialize_iter_result(
+int flecs_json_serialize_iter_result_table_rows(
     const ecs_world_t *world, 
     const ecs_iter_t *it, 
     ecs_strbuf_t *buf,
     const ecs_iter_to_json_desc_t *desc,
-    ecs_json_ser_ctx_t *ser_ctx) 
-{    
-    if (desc && desc->serialize_rows) {
-        if (flecs_json_serialize_iter_result_rows(world, it, buf, desc, ser_ctx)) {
-            return -1;
-        }
-    } else {
+    int32_t count,
+    bool has_this,
+    const char *parent_path,
+    const EcsIdentifier *names)
+{
+    ecs_table_t *table = it->table;
+    if (!table || !count) {
+        return 0;
+    }
+
+    /* Serialize tags, pairs, vars once, since they're the same for each row */
+    ecs_strbuf_t tags_pairs_vars_buf = ECS_STRBUF_INIT;
+    int32_t tags_pairs_vars_len = 0;
+    char *tags_pairs_vars = NULL;
+    if (flecs_json_serialize_table_tags_pairs_vars(
+        world, table, &tags_pairs_vars_buf, desc)) 
+    {
+        tags_pairs_vars_len = ecs_strbuf_written(&tags_pairs_vars_buf);
+        tags_pairs_vars = ecs_strbuf_get(&tags_pairs_vars_buf);
+    }
+
+    /* If one entity has more than 256 components (oof), bad luck */
+    ecs_json_value_ser_ctx_t values_ctx[256] = {{0}};
+    int32_t column_count = table->column_count;
+    if (column_count > 256) {
+        column_count = 256;
+    }
+
+    int32_t i, end = it->offset + count;
+    int result = 0;
+    for (i = it->offset; i < end; i ++) {
         flecs_json_next(buf);
         flecs_json_object_push(buf);
 
-        /* Each result can be matched with different component ids. Add them to
-        * the result so clients know with which component an entity was matched */
-        if (desc && desc->serialize_table) {
-            flecs_json_serialize_iter_result_table_type(world, it, buf, desc);
-        } else {
-            if (!desc || desc->serialize_ids) {
-                flecs_json_serialize_iter_result_ids(world, it, buf);
-            }
-            if (desc && desc->serialize_id_labels) {
-                flecs_json_serialize_iter_result_id_labels(world, it, buf);
+        if (has_this) {
+            const EcsIdentifier *name_ptr = NULL;
+            if (names) {
+                /* Correct for offset applied by iterator */
+                name_ptr = &names[-it->offset];
             }
+            flecs_json_serialize_iter_this_row(
+                it, parent_path, name_ptr, i, buf);
         }
 
-        /* Include information on which entity the term is matched with */
-        if (!desc || (desc->serialize_sources && !desc->serialize_table)) {
-            flecs_json_serialize_iter_result_sources(world, it, buf);
-        }
-
-        /* Write variable values for current result */
-        if (!desc || desc->serialize_variables) {
-            flecs_json_serialize_iter_result_variables(world, it, buf);
-        }
-
-        /* Write labels for variables */
-        if (desc && desc->serialize_variable_labels) {
-            flecs_json_serialize_iter_result_variable_labels(world, it, buf);
+        if (tags_pairs_vars) {
+            ecs_strbuf_list_appendstrn(buf, 
+                tags_pairs_vars, tags_pairs_vars_len);
         }
 
-        /* Write ids for variables */
-        if (desc && desc->serialize_variable_ids) {
-            flecs_json_serialize_iter_result_variable_ids(it, buf);
+        if (flecs_json_serialize_row_table_components(
+            world, table, buf, values_ctx, i, column_count)) 
+        {
+            result = -1;
+            break;
         }
 
-        /* Include information on which terms are set, to support optional terms */
-        if (!desc || (desc->serialize_is_set && !desc->serialize_table)) {
-            flecs_json_serialize_iter_result_is_set(it, buf);
-        }
+        flecs_json_object_pop(buf);
+    }
 
-        /* Write entity ids for current result (for queries with This terms) */
-        if (!desc || desc->serialize_entities) {
-            flecs_json_serialize_iter_result_entities(world, it, buf);
-        }
+    for (i = 0; i < column_count; i ++) {
+        ecs_os_free(values_ctx[i].id_label);
+    }
 
-        /* Write ids for entities */
-        if (desc && desc->serialize_entity_ids) {
-            flecs_json_serialize_iter_result_entity_ids(it, buf);
-        }
+    ecs_os_free(tags_pairs_vars);
 
-        /* Write labels for entities */
-        if (desc && desc->serialize_entity_labels) {
-            flecs_json_serialize_iter_result_entity_labels(it, buf, ser_ctx);
-        }
+    return result;
+}
 
-        /* Write colors for entities */
-        if (desc && desc->serialize_colors) {
-            flecs_json_serialize_iter_result_colors(it, buf, ser_ctx);
-        }
+int flecs_json_serialize_iter_result_rows(
+    const ecs_world_t *world, 
+    const ecs_iter_t *it, 
+    ecs_strbuf_t *buf,
+    const ecs_iter_to_json_desc_t *desc,
+    ecs_json_ser_ctx_t *ser_ctx)
+{
+    char *parent_path = NULL;
+    EcsIdentifier *names = NULL;
 
-        /* Serialize component values */
-        if (desc && desc->serialize_table) {
-            if (flecs_json_serialize_iter_result_columns(world, it, buf, desc)) {
-                return -1;
-            }
-        } else {
-            if (!desc || desc->serialize_values) {
-                if (flecs_json_serialize_iter_result_values(world, it, buf)) {
-                    return -1;
-                }
+    int32_t count = it->count;
+    bool has_this = true;
+    if (!count) {
+        count = 1; /* Query without this variable */
+        has_this = false;
+    } else {
+        ecs_table_t *table = it->table;
+        if (table) {
+            /* Get path to parent once for entire table */
+            if (table->flags & EcsTableHasChildOf) {
+                const ecs_table_record_t *tr = flecs_table_record_get(
+                    world, table, ecs_pair(EcsChildOf, EcsWildcard));
+                ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
+                ecs_entity_t parent = ecs_pair_second(
+                    world, table->type.array[tr->index]);
+                parent_path = ecs_get_path_w_sep(world, 0, parent, ".", "");
             }
-        }
 
-        /* Add "alerts": true member if table has entities with active alerts */
-#ifdef FLECS_ALERTS
-        if (it->table && (ecs_id(EcsAlertsActive) != 0)) {
-            /* Only add field if alerts addon is imported */
-            if (ecs_table_has_id(world, it->table, ecs_id(EcsAlertsActive))) {
-                flecs_json_memberl(buf, "alerts");
-                flecs_json_true(buf);
+            /* Fetch name column once vs. calling ecs_get_name for each row */
+            if (table->flags & EcsTableHasName) {
+                names = ecs_table_get_id(it->world, it->table, 
+                    ecs_pair(ecs_id(EcsIdentifier), EcsName), it->offset);
             }
+        } else {
+            /* Very rare case, but could happen if someone's using an iterator
+             * to return empty entities. */
         }
-#endif
+    }
 
-        flecs_json_object_pop(buf);
+    if (!desc->serialize_table) {
+        flecs_json_serialize_iter_result_query_rows(
+            world, it, buf, ser_ctx, count, has_this, parent_path, names);
+    } else {
+        flecs_json_serialize_iter_result_table_rows(
+            world, it, buf, desc, count, has_this, parent_path, names);
     }
 
+    ecs_os_free(parent_path);
+
     return 0;
 }
 
-int ecs_iter_to_json_buf(
-    const ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc)
-{
-    ecs_time_t duration = {0};
-    if (desc && desc->measure_eval_duration) {
-        ecs_time_measure(&duration);
-    }
-
-    /* Cache id record for flecs.doc ids */
-    ecs_json_ser_ctx_t ser_ctx;
-    ecs_os_zeromem(&ser_ctx);
-#ifdef FLECS_DOC
-    ser_ctx.idr_doc_name = flecs_id_record_get(world, 
-        ecs_pair_t(EcsDocDescription, EcsName));
-    ser_ctx.idr_doc_color = flecs_id_record_get(world, 
-        ecs_pair_t(EcsDocDescription, EcsDocColor));
 #endif
 
-    flecs_json_object_push(buf);
-
-    /* Serialize component ids of the terms (usually provided by query) */
-    if (!desc || !desc->serialize_rows) {
-        if (!desc || desc->serialize_term_ids) {
-            flecs_json_serialize_iter_ids(world, it, buf);
-        }
-
-        if (desc && desc->serialize_term_labels) {
-            flecs_json_serialize_iter_id_labels(world, it, buf);
-        }
-
-        /* Serialize variable names, if iterator has any */
-        flecs_json_serialize_iter_variables(it, buf);
-    }
-
-    /* Serialize type info if enabled */
-    if (desc && desc->serialize_type_info) {
-        flecs_json_serialize_type_info(world, it, buf);
-    }
+/**
+ * @file json/serialize_query_info.c
+ * @brief Serialize (component) values to JSON strings.
+ */
 
-    /* Serialize field info if enabled */
-    if (desc && desc->serialize_field_info) {
-        flecs_json_serialize_field_info(world, it, buf, &ser_ctx);
-    }
 
-    /* Serialize query info if enabled */
-    if (desc && desc->serialize_query_info) {
-        flecs_json_serialize_query_info(world, it, buf);
-    }
+#ifdef FLECS_JSON
 
-    /* Serialize query plan if enabled */
-    if (desc && desc->serialize_query_plan) {
-        flecs_json_serialize_query_plan(world, buf, desc);
+static
+const char* flecs_json_inout_str(
+    int16_t kind)
+{
+    switch(kind) {
+    case EcsIn: return "in";
+    case EcsOut: return "out";
+    case EcsInOut: return "inout";
+    case EcsInOutNone: return "none";
+    case EcsInOutFilter: return "filter";
+    case EcsInOutDefault: return "default";
+    default: return "unknown";
     }
+}
 
-    /* Profile query */
-    if (desc && desc->serialize_query_profile) {
-        flecs_json_serialize_query_profile(world, buf, it, desc);
+static
+const char* flecs_json_oper_str(
+    int16_t kind)
+{
+    switch(kind) {
+    case EcsAnd: return "and";
+    case EcsNot: return "not";
+    case EcsOr: return "or";
+    case EcsOptional: return "optional";
+    case EcsAndFrom: return "andfrom";
+    case EcsNotFrom: return "notfrom";
+    case EcsOrFrom: return "orfrom";
+    default: return "unknown";
     }
+}
 
-    /* Serialize results */
-    if (!desc || !desc->dont_serialize_results) {
-        flecs_json_memberl(buf, "results");
-        flecs_json_array_push(buf);
-
-        /* Use instancing for improved performance */
-        ECS_BIT_SET(it->flags, EcsIterIsInstanced);
+static
+void flecs_json_serialize_term_entity(
+    const ecs_world_t *world,
+    ecs_entity_t e,
+    ecs_strbuf_t *buf)
+{
+    flecs_json_memberl(buf, "entity");
+    flecs_json_path(buf, world, e);
 
-        /* If serializing entire table, don't bother letting the iterator populate
-        * data fields as we'll be iterating all columns. */
-        if (desc && desc->serialize_table) {
-            ECS_BIT_SET(it->flags, EcsIterNoData);
+    if (e) {
+        const char *symbol = ecs_get_symbol(world, e);
+        if (symbol) {
+            flecs_json_memberl(buf, "symbol");
+            flecs_json_string(buf, symbol);
         }
 
-        ecs_iter_next_action_t next = it->next;
-        while (next(it)) {
-            if (flecs_json_serialize_iter_result(world, it, buf, desc, &ser_ctx)) {
-                ecs_strbuf_reset(buf);
-                ecs_iter_fini(it);
-                return -1;
-            }
+        if (ecs_has(world, e, EcsComponent)) {
+            flecs_json_memberl(buf, "type");
+            flecs_json_true(buf);
         }
-
-        flecs_json_array_pop(buf);
-    } else {
-        ecs_iter_fini(it);
     }
+}
 
-    int32_t f, field_count = it->field_count;
-    if (desc && (desc->serialize_rows || desc->serialize_values)) {
-        for (f = 0; f < field_count; f ++) {
-            ecs_os_free(ser_ctx.value_ctx[f].id_label);
+static
+void flecs_json_serialize_term_ref(
+    const ecs_world_t *world,
+    const ecs_term_ref_t *ref,
+    ecs_strbuf_t *buf)
+{
+    flecs_json_object_push(buf);
+    if (ref->id & EcsIsEntity) {
+        flecs_json_serialize_term_entity(world, ECS_TERM_REF_ID(ref), buf);
+    } else if (ref->id & EcsIsVariable) {
+        flecs_json_memberl(buf, "var");
+        if (ref->name) {
+            flecs_json_string(buf, ref->name);
+        } else if (ref->id) {
+            if (ECS_TERM_REF_ID(ref) == EcsThis) {
+                flecs_json_string(buf, "this");
+            } else {
+                flecs_json_path(buf, world, ECS_TERM_REF_ID(ref));
+            }
         }
+    } else if (ref->id & EcsIsName) {
+        flecs_json_memberl(buf, "name");
+        flecs_json_string(buf, ref->name);
     }
-
-    if (desc && desc->measure_eval_duration) {
-        double dt = ecs_time_measure(&duration);
-        flecs_json_memberl(buf, "eval_duration");
-        flecs_json_number(buf, dt);
-    }
-
     flecs_json_object_pop(buf);
-
-    return 0;
 }
 
-char* ecs_iter_to_json(
+static
+void flecs_json_serialize_term_trav(
     const ecs_world_t *world,
-    ecs_iter_t *it,
-    const ecs_iter_to_json_desc_t *desc)
+    const ecs_term_t *term,
+    ecs_strbuf_t *buf)
 {
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
-
-    if (ecs_iter_to_json_buf(world, it, &buf, desc)) {
-        ecs_strbuf_reset(&buf);
-        return NULL;
+    if (term->trav) {
+        flecs_json_memberl(buf, "trav");
+        flecs_json_object_push(buf);
+        flecs_json_serialize_term_entity(world, term->trav, buf);
+        flecs_json_object_pop(buf);
     }
 
-    return ecs_strbuf_get(&buf);
+    flecs_json_memberl(buf, "flags");
+    flecs_json_array_push(buf);
+    if (term->src.id & EcsSelf) {
+        flecs_json_next(buf);
+        flecs_json_string(buf, "self");
+    }
+    if (term->src.id & EcsCascade) {
+        flecs_json_next(buf);
+        flecs_json_string(buf, "cascade");
+    } else
+    if (term->src.id & EcsUp) {
+        flecs_json_next(buf);
+        flecs_json_string(buf, "up");
+    }
+    flecs_json_array_pop(buf);
 }
 
-int ecs_world_to_json_buf(
-    ecs_world_t *world,
-    ecs_strbuf_t *buf_out,
-    const ecs_world_to_json_desc_t *desc)
+static
+void flecs_json_serialize_term(
+    const ecs_world_t *world,
+    const ecs_query_t *q,
+    int t,
+    ecs_strbuf_t *buf)
 {
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_desc_t filter_desc = {0};
-    filter_desc.storage = &f;
+    const ecs_term_t *term = &q->terms[t];
 
-    if (desc && desc->serialize_builtin && desc->serialize_modules) {
-        filter_desc.terms[0].id = EcsAny;
-    } else {
-        bool serialize_builtin = desc && desc->serialize_builtin;
-        bool serialize_modules = desc && desc->serialize_modules;
-        int32_t term_id = 0;
+    flecs_json_object_push(buf);
+    flecs_json_memberl(buf, "inout");
+    flecs_json_string(buf, flecs_json_inout_str(term->inout));
 
-        if (!serialize_builtin) {
-            filter_desc.terms[term_id].id = ecs_pair(EcsChildOf, EcsFlecs);
-            filter_desc.terms[term_id].oper = EcsNot;
-            filter_desc.terms[term_id].src.flags = EcsSelf | EcsParent;
-            term_id ++;
-        }
-        if (!serialize_modules) {
-            filter_desc.terms[term_id].id = EcsModule;
-            filter_desc.terms[term_id].oper = EcsNot;
-            filter_desc.terms[term_id].src.flags = EcsSelf | EcsParent;
+    flecs_json_memberl(buf, "has_data");
+    flecs_json_bool(buf, 0 == (term->flags_ & EcsTermNoData));
+
+    if (term->first.id & EcsIsEntity && term->first.id) {
+        if (ecs_has_id(world, ECS_TERM_REF_ID(&term->first), EcsDontInherit)) {
+            flecs_json_memberl(buf, "dont_inherit");
+            flecs_json_true(buf);
         }
     }
 
-    filter_desc.flags = EcsFilterMatchDisabled|EcsFilterMatchPrefab;
+    flecs_json_memberl(buf, "oper");
+    flecs_json_string(buf, flecs_json_oper_str(term->oper));
 
-    if (ecs_filter_init(world, &filter_desc) == NULL) {
-        return -1;
+    flecs_json_memberl(buf, "src");
+    flecs_json_serialize_term_ref(world, &term->src, buf);
+
+    flecs_json_memberl(buf, "first");
+    flecs_json_serialize_term_ref(world, &term->first, buf);
+    
+    if (ECS_TERM_REF_ID(&term->second) || term->second.name || term->second.id & EcsIsEntity) {
+        flecs_json_memberl(buf, "second");
+        flecs_json_serialize_term_ref(world, &term->second, buf);
     }
 
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_to_json_desc_t json_desc = { 
-        .serialize_table = true,
-        .serialize_ids = true,
-        .serialize_entities = true,
-        .serialize_private = true
-    };
+    flecs_json_serialize_term_trav(world, term, buf);
 
-    int ret = ecs_iter_to_json_buf(world, &it, buf_out, &json_desc);
-    ecs_filter_fini(&f);
-    return ret;
+    flecs_json_object_pop(buf);
 }
 
-char* ecs_world_to_json(
-    ecs_world_t *world,
-    const ecs_world_to_json_desc_t *desc)
+void flecs_json_serialize_query(
+    const ecs_world_t *world,
+    const ecs_query_t *q,
+    ecs_strbuf_t *buf)
 {
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
-
-    if (ecs_world_to_json_buf(world, &buf, desc)) {
-        ecs_strbuf_reset(&buf);
-        return NULL;
+    flecs_json_object_push(buf);
+    flecs_json_memberl(buf, "terms");
+    flecs_json_array_push(buf);
+    int t;
+    for (t = 0; t < q->term_count; t ++) {
+        flecs_json_next(buf);
+        flecs_json_serialize_term(world, q, t, buf);
     }
-
-    return ecs_strbuf_get(&buf);
+    flecs_json_array_pop(buf);
+    flecs_json_object_pop(buf);
 }
 
 #endif
@@ -55092,1824 +54859,1874 @@ char* ecs_world_to_json(
 
 #ifdef FLECS_JSON
 
-void flecs_json_serialize_field(
+static
+int json_typeinfo_ser_type(
     const ecs_world_t *world,
-    const ecs_iter_t *it,
-    const ecs_filter_t *q,
-    int field,
-    ecs_strbuf_t *buf,
-    ecs_json_ser_ctx_t *ctx)
-{
-    flecs_json_object_push(buf);
-    flecs_json_memberl(buf, "id");
-
-    flecs_json_serialize_get_field_ctx(world, it, field, ctx);
-    ecs_json_value_ser_ctx_t *value_ctx = &ctx->value_ctx[field];
-
-    if (value_ctx->id_label) {
-        flecs_json_string(buf, value_ctx->id_label);
-
-        const ecs_term_t *term = &q->terms[0];
-        int t;
-        for (t = 0; t < q->term_count; t ++) {
-            if (q->terms[t].field_index == field) {
-                term = &q->terms[t];
-                break;
-            }
-        }
-
-        if (term->oper != EcsNot) {
-            if (term->oper == EcsOptional) {
-                flecs_json_memberl(buf, "optional");
-                flecs_json_bool(buf, true);
-            }
-
-            if (ECS_IS_PAIR(term->id)) {
-                if (term->first.flags & EcsIsEntity && term->first.id) {
-                    if (ecs_has_id(world, term->first.id, EcsExclusive)) {
-                        flecs_json_memberl(buf, "exclusive");
-                        flecs_json_bool(buf, true);
-                    }
-                }
-            }
-
-            if (value_ctx->type) {
-                flecs_json_memberl(buf, "type");
-                flecs_json_label(buf, world, value_ctx->type);
-
-                const char *symbol = ecs_get_symbol(world, value_ctx->type);
-                if (symbol) {
-                    flecs_json_memberl(buf, "symbol");
-                    flecs_json_string(buf, symbol);
-                }
-            }
+    ecs_entity_t type,
+    ecs_strbuf_t *buf);
 
-            if (value_ctx->ser) {
-                flecs_json_memberl(buf, "schema");
-                ecs_type_info_to_json_buf(world, value_ctx->type, buf);
-            }
-        } else {
-            flecs_json_memberl(buf, "not");
-            flecs_json_bool(buf, true);
-        }
-    } else {
-        ecs_strbuf_appendlit(buf, "0");
+static
+int json_typeinfo_ser_primitive(
+    ecs_primitive_kind_t kind,
+    ecs_strbuf_t *str) 
+{
+    switch(kind) {
+    case EcsBool:
+        flecs_json_string(str, "bool");
+        break;
+    case EcsChar:
+    case EcsString:
+        flecs_json_string(str, "text");
+        break;
+    case EcsByte:
+        flecs_json_string(str, "byte");
+        break;
+    case EcsU8:
+    case EcsU16:
+    case EcsU32:
+    case EcsU64:
+    case EcsI8:
+    case EcsI16:
+    case EcsI32:
+    case EcsI64:
+    case EcsIPtr:
+    case EcsUPtr:
+        flecs_json_string(str, "int");
+        break;
+    case EcsF32:
+    case EcsF64:
+        flecs_json_string(str, "float");
+        break;
+    case EcsEntity:
+        flecs_json_string(str, "entity");
+        break;
+    case EcsId:
+        flecs_json_string(str, "id");
+        break;
+    default:
+        return -1;
     }
 
-    flecs_json_object_pop(buf);
+    return 0;
 }
 
-#endif
-
-/**
- * @file json/serialize_iter_rows.c
- * @brief Serialize (component) values to JSON strings.
- */
-
-
-#ifdef FLECS_JSON
-
 static
-bool flecs_json_serialize_row_tags(
+void json_typeinfo_ser_constants(
     const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf)  
+    ecs_entity_t type,
+    ecs_strbuf_t *str)
 {
-    int32_t f, field_count = it->field_count;
-    ecs_id_t *ids = it->ids;
-    void **ptrs = it->ptrs;
-    
-    int32_t tag_count = 0;
-    for (f = 0; f < field_count; f ++) {
-        if (!ecs_field_is_set(it, f + 1)) {
-            continue;
-        }
-
-        ecs_id_t id = ids[f];
-        if (ECS_IS_PAIR(id)) {
-            continue;
-        }
-
-        if (ptrs[f]) {
-            continue; /* Ignore components */
+    ecs_iter_t it = ecs_each_id(world, ecs_pair(EcsChildOf, type));
+    while (ecs_each_next(&it)) {
+        int32_t i, count = it.count;
+        for (i = 0; i < count; i ++) {
+            flecs_json_next(str);
+            flecs_json_string(str, ecs_get_name(world, it.entities[i]));
         }
+    }
+}
 
-        if (!tag_count) {
-            flecs_json_memberl(buf, "tags");
-            flecs_json_array_push(buf);
-        }
+static
+void json_typeinfo_ser_enum(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    ecs_strbuf_t *str)
+{
+    ecs_strbuf_list_appendstr(str, "\"enum\"");
+    json_typeinfo_ser_constants(world, type, str);
+}
 
-        flecs_json_next(buf);
-        flecs_json_label(buf, world, id);
+static
+void json_typeinfo_ser_bitmask(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    ecs_strbuf_t *str)
+{
+    ecs_strbuf_list_appendstr(str, "\"bitmask\"");
+    json_typeinfo_ser_constants(world, type, str);
+}
 
-        tag_count ++;
-    }
+static
+int json_typeinfo_ser_array(
+    const ecs_world_t *world,
+    ecs_entity_t elem_type,
+    int32_t count,
+    ecs_strbuf_t *str)
+{
+    ecs_strbuf_list_appendstr(str, "\"array\"");
 
-    if (tag_count) {
-        flecs_json_array_pop(buf);
+    flecs_json_next(str);
+    if (json_typeinfo_ser_type(world, elem_type, str)) {
+        goto error;
     }
 
-    return tag_count != 0;
+    ecs_strbuf_list_append(str, "%u", count);
+    return 0;
+error:
+    return -1;
 }
 
 static
-bool flecs_json_serialize_row_pairs(
+int json_typeinfo_ser_array_type(
     const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf)  
+    ecs_entity_t type,
+    ecs_strbuf_t *str)
 {
-    int32_t f, field_count = it->field_count;
-    ecs_id_t *ids = it->ids;
-    
-    int32_t pair_count = 0;
-    for (f = 0; f < field_count; f ++) {
-        if (!ecs_field_is_set(it, f + 1)) {
-            continue;
-        }
-
-        ecs_id_t id = ids[f];
-        if (!ECS_IS_PAIR(id)) {
-            continue;
-        }
-
-        if (!pair_count) {
-            flecs_json_memberl(buf, "pairs");
-            flecs_json_object_push(buf);
-        }
+    const EcsArray *arr = ecs_get(world, type, EcsArray);
+    ecs_assert(arr != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (json_typeinfo_ser_array(world, arr->type, arr->count, str)) {
+        goto error;
+    }
 
-        flecs_json_next(buf);
-        ecs_entity_t first = ecs_pair_first(world, id);
-        ecs_entity_t second = ecs_pair_second(world, id);
+    return 0;
+error:
+    return -1;
+}
 
-        flecs_json_label(buf, world, first);
-        ecs_strbuf_appendlit(buf, ":");
-        flecs_json_label(buf, world, second);
+static
+int json_typeinfo_ser_vector(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    ecs_strbuf_t *str)
+{
+    const EcsVector *arr = ecs_get(world, type, EcsVector);
+    ecs_assert(arr != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        pair_count ++;
-    }
+    ecs_strbuf_list_appendstr(str, "\"vector\"");
 
-    if (pair_count) {
-        flecs_json_object_pop(buf);
+    flecs_json_next(str);
+    if (json_typeinfo_ser_type(world, arr->type, str)) {
+        goto error;
     }
 
-    return pair_count != 0;
+    return 0;
+error:
+    return -1;
 }
 
+/* Serialize unit information */
 static
-bool flecs_json_serialize_row_vars(
+int json_typeinfo_ser_unit(
     const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf)
+    ecs_strbuf_t *str,
+    ecs_entity_t unit) 
 {
-    char **variable_names = it->variable_names;
-    int32_t var_count = it->variable_count;
-    int32_t actual_count = 0;
-
-    for (int i = 1; i < var_count; i ++) {
-        const char *var_name = variable_names[i];
-        if (flecs_json_skip_variable(var_name)) continue;
+    flecs_json_memberl(str, "unit");
+    flecs_json_path(str, world, unit);
 
-        ecs_entity_t var = it->variables[i].entity;
-        if (!var) {
-            /* Can't happen, but not the place of the serializer to complain */
-            continue;
+    const EcsUnit *uptr = ecs_get(world, unit, EcsUnit);
+    if (uptr) {
+        if (uptr->symbol) {
+            flecs_json_memberl(str, "symbol");
+            flecs_json_string(str, uptr->symbol);
         }
-
-        if (!actual_count) {
-            flecs_json_memberl(buf, "vars");
-            flecs_json_object_push(buf);
-            actual_count ++;
+        ecs_entity_t quantity = ecs_get_target(world, unit, EcsQuantity, 0);
+        if (quantity) {
+            flecs_json_memberl(str, "quantity");
+            flecs_json_path(str, world, quantity);
         }
-
-        flecs_json_member(buf, var_name);
-        flecs_json_label(buf, world, var);
-    }
-
-    if (actual_count) {
-        flecs_json_object_pop(buf);
     }
 
-    return actual_count != 0;
+    return 0;
 }
 
 static
-bool flecs_json_serialize_tags_pairs_vars(
-    const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf)
+void json_typeinfo_ser_range(
+    ecs_strbuf_t *str,
+    const char *kind,
+    ecs_member_value_range_t *range)
 {
-    bool result = false;
-    ecs_strbuf_list_push(buf, "", ",");
-    result |= flecs_json_serialize_row_tags(world, it, buf);
-    result |= flecs_json_serialize_row_pairs(world, it, buf);
-    result |= flecs_json_serialize_row_vars(world, it, buf);
-    result |= flecs_json_serialize_iter_result_is_set(it, buf);
-    ecs_strbuf_list_pop(buf, "");
-    if (!result) {
-        ecs_strbuf_reset(buf);
-    }
-    return result;
+    flecs_json_member(str, kind);
+    flecs_json_array_push(str);
+    flecs_json_next(str);
+    flecs_json_number(str, range->min);
+    flecs_json_next(str);
+    flecs_json_number(str, range->max);
+    flecs_json_array_pop(str);
 }
 
+/* Forward serialization to the different type kinds */
 static
-bool flecs_json_serialize_table_row_tags(
+int json_typeinfo_ser_type_op(
     const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc)
+    ecs_meta_type_op_t *op, 
+    ecs_strbuf_t *str,
+    const EcsStruct *st) 
 {
-    int32_t f, type_count = table->type.count;
-    ecs_id_t *ids = table->type.array;
-    int32_t *column_map = table->column_map;
-    
-    int32_t tag_count = 0;
-    for (f = 0; f < type_count; f ++) {
-        ecs_id_t id = ids[f];
-        if (ECS_IS_PAIR(id)) {
-            continue;
-        }
+    if (op->kind == EcsOpOpaque) {
+        const EcsOpaque *ct = ecs_get(world, op->type, 
+            EcsOpaque);
+        ecs_assert(ct != NULL, ECS_INTERNAL_ERROR, NULL);
+        return json_typeinfo_ser_type(world, ct->as_type, str);
+    }
 
-        if (column_map[f] != -1) {
-            continue; /* Ignore components */
+    flecs_json_array_push(str);
+
+    switch(op->kind) {
+    case EcsOpPush:
+    case EcsOpPop:
+        /* Should not be parsed as single op */
+        ecs_throw(ECS_INVALID_PARAMETER, 
+            "unexpected push/pop serializer instruction");
+        break;
+    case EcsOpEnum:
+        json_typeinfo_ser_enum(world, op->type, str);
+        break;
+    case EcsOpBitmask:
+        json_typeinfo_ser_bitmask(world, op->type, str);
+        break;
+    case EcsOpArray:
+        json_typeinfo_ser_array_type(world, op->type, str);
+        break;
+    case EcsOpVector:
+        json_typeinfo_ser_vector(world, op->type, str);
+        break;
+    case EcsOpOpaque:
+        /* Can't happen, already handled above */
+        ecs_throw(ECS_INTERNAL_ERROR, NULL);
+        break;
+    case EcsOpBool:
+    case EcsOpChar:
+    case EcsOpByte:
+    case EcsOpU8:
+    case EcsOpU16:
+    case EcsOpU32:
+    case EcsOpU64:
+    case EcsOpI8:
+    case EcsOpI16:
+    case EcsOpI32:
+    case EcsOpI64:
+    case EcsOpF32:
+    case EcsOpF64:
+    case EcsOpUPtr:
+    case EcsOpIPtr:
+    case EcsOpEntity:
+    case EcsOpId:
+    case EcsOpString:
+        if (json_typeinfo_ser_primitive( 
+            flecs_json_op_to_primitive_kind(op->kind), str))
+        {
+            ecs_throw(ECS_INTERNAL_ERROR, NULL);
         }
+        break;
+    case EcsOpScope:
+    case EcsOpPrimitive:
+    default:
+        ecs_throw(ECS_INTERNAL_ERROR, NULL);
+    }
+
+    if (st) {
+        ecs_member_t *m = ecs_vec_get_t(
+            &st->members, ecs_member_t, op->member_index);
+        ecs_assert(m != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        bool value_range = ECS_NEQ(m->range.min, m->range.max);
+        bool error_range = ECS_NEQ(m->error_range.min, m->error_range.max);
+        bool warning_range = ECS_NEQ(m->warning_range.min, m->warning_range.max);
+
+        ecs_entity_t unit = m->unit;
+        if (unit || error_range || warning_range || value_range) {
+            flecs_json_next(str);
+            flecs_json_next(str);
+            flecs_json_object_push(str);
 
-        if (!desc || !desc->serialize_private) {
-            if (ecs_has_id(world, id & ECS_COMPONENT_MASK, EcsPrivate)) {
-                continue;
+            if (unit) {
+                json_typeinfo_ser_unit(world, str, unit);
+            }
+            if (value_range) {
+                json_typeinfo_ser_range(str, "range", &m->range);
+            }
+            if (error_range) {
+                json_typeinfo_ser_range(str, "error_range", &m->error_range);
+            }
+            if (warning_range) {
+                json_typeinfo_ser_range(str, "warning_range", &m->warning_range);
             }
-        }
 
-        if (!tag_count) {
-            flecs_json_memberl(buf, "tags");
-            flecs_json_array_push(buf);
+            flecs_json_object_pop(str);
         }
-
-        flecs_json_next(buf);
-        flecs_json_label(buf, world, id);
-
-        tag_count ++;
     }
 
-    if (tag_count) {
-        flecs_json_array_pop(buf);
-    }
+    flecs_json_array_pop(str);
 
-    return tag_count != 0;
+    return 0;
+error:
+    return -1;
 }
 
+/* Iterate over a slice of the type ops array */
 static
-bool flecs_json_serialize_table_row_pairs(
+int json_typeinfo_ser_type_ops(
     const ecs_world_t *world,
-    const ecs_table_t *table,
-    ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc)
+    ecs_meta_type_op_t *ops,
+    int32_t op_count,
+    ecs_strbuf_t *str,
+    const EcsStruct *st) 
 {
-    int32_t f, type_count = table->type.count;
-    ecs_id_t *ids = table->type.array;
-    
-    int32_t pair_count = 0;
-    bool same_first = false;
+    const EcsStruct *stack[64] = {st};
+    int32_t sp = 1;
 
-    for (f = 0; f < type_count; f ++) {
-        ecs_id_t id = ids[f];
-        if (!ECS_IS_PAIR(id)) {
-            continue;
-        }
+    for (int i = 0; i < op_count; i ++) {
+        ecs_meta_type_op_t *op = &ops[i];
 
-        ecs_entity_t first = flecs_entities_get_alive(
-            world, ECS_PAIR_FIRST(id));
-        if (!desc || !desc->serialize_private) {
-            if (ecs_has_id(world, first, EcsPrivate)) {
-                continue;
+        if (op != ops) {
+            if (op->name) {
+                flecs_json_member(str, op->name);
             }
         }
 
-        if (!pair_count) {
-            flecs_json_memberl(buf, "pairs");
-            flecs_json_object_push(buf);            
-        }
-
-        ecs_entity_t second = flecs_entities_get_alive(
-            world, ECS_PAIR_SECOND(id));
-
-        bool is_last = f == (type_count - 1);
-        bool is_same = !is_last && 
-            (ECS_PAIR_FIRST(ids[f + 1]) == ECS_PAIR_FIRST(id));
-
-        if (same_first && f && ECS_PAIR_FIRST(ids[f - 1]) != ECS_PAIR_FIRST(id)) {
-            /* New pair has different first elem, so close array */
-            flecs_json_array_pop(buf);
-            same_first = false;
+        int32_t elem_count = op->count;
+        if (elem_count > 1) {
+            flecs_json_array_push(str);
+            json_typeinfo_ser_array(world, op->type, op->count, str);
+            flecs_json_array_pop(str);
+            i += op->op_count - 1;
+            continue;
         }
 
-        if (!same_first) {
-            /* Only append pair label if we're not appending to array */
-            flecs_json_next(buf);
-            flecs_json_label(buf, world, first);
-            ecs_strbuf_appendlit(buf, ":");
-
-            /* Open array scope if this is a pair with multiple targets */
-            if (is_same) {
-                flecs_json_array_push(buf);
-                same_first = true;
+        switch(op->kind) {
+        case EcsOpPush:
+            flecs_json_object_push(str);
+            ecs_assert(sp < 63, ECS_INVALID_OPERATION, "type nesting too deep");
+            stack[sp ++] = ecs_get(world, op->type, EcsStruct);
+            break;
+        case EcsOpPop:
+            flecs_json_object_pop(str);
+            sp --;
+            break;
+        case EcsOpArray:
+        case EcsOpVector:
+        case EcsOpEnum:
+        case EcsOpBitmask:
+        case EcsOpBool:
+        case EcsOpChar:
+        case EcsOpByte:
+        case EcsOpU8:
+        case EcsOpU16:
+        case EcsOpU32:
+        case EcsOpU64:
+        case EcsOpI8:
+        case EcsOpI16:
+        case EcsOpI32:
+        case EcsOpI64:
+        case EcsOpF32:
+        case EcsOpF64:
+        case EcsOpUPtr:
+        case EcsOpIPtr:
+        case EcsOpEntity:
+        case EcsOpId:
+        case EcsOpString:
+        case EcsOpOpaque:
+            if (json_typeinfo_ser_type_op(world, op, str, stack[sp - 1])) {
+                goto error;
             }
-        } 
-        if (same_first) {
-            flecs_json_next(buf);
+            break;
+        case EcsOpPrimitive:
+        case EcsOpScope:
+        default:
+            ecs_throw(ECS_INTERNAL_ERROR, NULL);
         }
-
-        flecs_json_label(buf, world, second);
-
-        pair_count ++;
-    }
-
-    if (same_first) {
-        flecs_json_array_pop(buf);
-    }
-
-    if (pair_count) {
-        flecs_json_object_pop(buf);
     }
 
-    return pair_count != 0;
+    return 0;
+error:
+    return -1;
 }
 
 static
-bool flecs_json_serialize_table_tags_pairs_vars(
+int json_typeinfo_ser_type(
     const ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc)
+    ecs_entity_t type,
+    ecs_strbuf_t *buf)
 {
-    bool result = false;
-    ecs_strbuf_list_push(buf, "", ",");
-    result |= flecs_json_serialize_table_row_tags(world, table, buf, desc);
-    result |= flecs_json_serialize_table_row_pairs(world, table, buf, desc);
-    ecs_strbuf_list_pop(buf, "");
-    if (!result) {
-        ecs_strbuf_reset(buf);
+    const EcsComponent *comp = ecs_get(world, type, EcsComponent);
+    if (!comp) {
+        ecs_strbuf_appendch(buf, '0');
+        return 0;
     }
-    return result;
-}
 
-static
-bool flecs_json_serialize_get_value_ctx(
-    const ecs_world_t *world,
-    ecs_id_t id,
-    ecs_json_value_ser_ctx_t *ctx)
-{
-    if (!id) {
-        return false;
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
+    if (!ser) {
+        ecs_strbuf_appendch(buf, '0');
+        return 0;
     }
-    if (!ctx->initialized) {
-        ctx->initialized = true;
 
-        ecs_strbuf_t idlbl = ECS_STRBUF_INIT;
-        flecs_json_id_member(&idlbl, world, id);
-        ctx->id_label = ecs_strbuf_get(&idlbl);
-
-        ecs_entity_t type = ecs_get_typeid(world, id);
-        if (!type) {
-            return false;
-        }
-
-        ctx->type = type;
-        ctx->ser = ecs_get(world, type, EcsMetaTypeSerialized);
-        if (!ctx->ser) {
-            return false;
-        }
+    const EcsStruct *st = ecs_get(world, type, EcsStruct);
+    ecs_meta_type_op_t *ops = ecs_vec_first_t(&ser->ops, ecs_meta_type_op_t);
+    int32_t count = ecs_vec_count(&ser->ops);
 
-        return true;
-    } else {
-        return ctx->ser != NULL;
-    }
+    return json_typeinfo_ser_type_ops(world, ops, count, buf, st);
 }
 
-bool flecs_json_serialize_get_field_ctx(
+int ecs_type_info_to_json_buf(
     const ecs_world_t *world,
-    const ecs_iter_t *it,
-    int32_t f,
-    ecs_json_ser_ctx_t *ser_ctx)
+    ecs_entity_t type,
+    ecs_strbuf_t *buf)
 {
-    ecs_json_value_ser_ctx_t *value_ctx = &ser_ctx->value_ctx[f];
-    if (it->query) {
-        return flecs_json_serialize_get_value_ctx(
-            world, it->query->ids[f], value_ctx);
-    } else if (it->ids[f]) {
-        return flecs_json_serialize_get_value_ctx(world, it->ids[f], value_ctx);
-    } else {
-        return false;
-    }
+    return json_typeinfo_ser_type(world, type, buf);
 }
 
-static
-int flecs_json_serialize_row_components(
+char* ecs_type_info_to_json(
     const ecs_world_t *world,
-    const ecs_iter_t *it,
-    ecs_strbuf_t *buf,
-    ecs_json_ser_ctx_t *ser_ctx,
-    int32_t row)
+    ecs_entity_t type)
 {
-    void **ptrs = it->ptrs;
-    if (!ptrs) {
-        return 0;
-    }
+    ecs_strbuf_t str = ECS_STRBUF_INIT;
 
-    int32_t f, field_count = it->field_count, component_count = 0;
-    for (f = 0; f < field_count; f ++) {
-        if (!ecs_field_is_set(it, f + 1)) {
-            continue;
-        }
+    if (ecs_type_info_to_json_buf(world, type, &str) != 0) {
+        ecs_strbuf_reset(&str);
+        return NULL;
+    }
 
-        void *ptr = ptrs[f];
-        if (!ptr) {
-            continue;
-        }
+    return ecs_strbuf_get(&str);
+}
 
-        if (ecs_field_is_self(it, f + 1)) {
-            ptr = ECS_ELEM(ptr, it->sizes[f], row);
-        }
+#endif
 
-        ecs_json_value_ser_ctx_t *value_ctx = &ser_ctx->value_ctx[f];
-        if (!flecs_json_serialize_get_value_ctx(world, it->ids[f], value_ctx)) {
-            continue;
-        }
+/**
+ * @file meta/api.c
+ * @brief API for creating entities with reflection data.
+ */
 
-        if (!component_count) {
-            flecs_json_memberl(buf, "components");
-            flecs_json_object_push(buf);
-        }
 
-        flecs_json_member(buf, value_ctx->id_label);
-        if (flecs_json_ser_type(world, &value_ctx->ser->ops, ptr, buf) != 0) {
-            return -1;
-        }
+#ifdef FLECS_META
 
-        component_count ++;
+static
+bool flecs_type_is_number(
+    ecs_world_t *world,
+    ecs_entity_t type)
+{
+    const EcsPrimitive *p = ecs_get(world, type, EcsPrimitive);
+    if (!p) {
+        return false;
     }
 
-    if (component_count) {
-        flecs_json_object_pop(buf);
-    }
+    switch(p->kind) {
+    case EcsChar:
+    case EcsU8:
+    case EcsU16:
+    case EcsU32:
+    case EcsU64:
+    case EcsI8:
+    case EcsI16:
+    case EcsI32:
+    case EcsI64:
+    case EcsF32:
+    case EcsF64:
+        return true;
 
-    return 0;
+    case EcsBool:
+    case EcsByte:
+    case EcsUPtr:
+    case EcsIPtr:
+    case EcsString:
+    case EcsEntity:
+    case EcsId:
+        return false;
+    default:
+        ecs_abort(ECS_INVALID_PARAMETER, NULL);
+    }
 }
 
-static
-int flecs_json_serialize_row_table_components(
+/* Serialize a primitive value */
+int flecs_expr_ser_primitive(
     const ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_strbuf_t *buf,
-    ecs_json_value_ser_ctx_t *values_ctx,
-    int32_t row,
-    int32_t column_count)
+    ecs_primitive_kind_t kind,
+    const void *base, 
+    ecs_strbuf_t *str,
+    bool is_expr) 
 {
-    int32_t f, component_count = 0;
-    for (f = 0; f < column_count; f ++) {
-        ecs_column_t *column = &table->data.columns[f];
-        ecs_json_value_ser_ctx_t *value_ctx = &values_ctx[f];
-        if (!flecs_json_serialize_get_value_ctx(world, column->id, value_ctx)) {
-            continue;
-        }
-
-        if (!component_count) {
-            flecs_json_memberl(buf, "components");
-            flecs_json_object_push(buf);
+    switch(kind) {
+    case EcsBool:
+        if (*(const bool*)base) {
+            ecs_strbuf_appendlit(str, "true");
+        } else {
+            ecs_strbuf_appendlit(str, "false");
         }
-
-        void *ptr = ecs_vec_get(&column->data, column->size, row);
-        ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(value_ctx->id_label != NULL, ECS_INTERNAL_ERROR, NULL);
-        flecs_json_member(buf, value_ctx->id_label);
-        if (flecs_json_ser_type(world, &value_ctx->ser->ops, ptr, buf) != 0) {
-            return -1;
+        break;
+    case EcsChar: {
+        char chbuf[3];
+        char ch = *(const char*)base;
+        if (ch) {
+            flecs_chresc(chbuf, *(const char*)base, '"');
+            if (is_expr) ecs_strbuf_appendch(str, '"');
+            ecs_strbuf_appendstr(str, chbuf);
+            if (is_expr) ecs_strbuf_appendch(str, '"');
+        } else {
+            ecs_strbuf_appendch(str, '0');
         }
-
-        component_count ++;
+        break;
     }
-
-    if (component_count) {
-        flecs_json_object_pop(buf);
+    case EcsByte:
+        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint8_t*)base));
+        break;
+    case EcsU8:
+        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint8_t*)base));
+        break;
+    case EcsU16:
+        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint16_t*)base));
+        break;
+    case EcsU32:
+        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint32_t*)base));
+        break;
+    case EcsU64:
+        ecs_strbuf_append(str, "%llu", *(const uint64_t*)base);
+        break;
+    case EcsI8:
+        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int8_t*)base));
+        break;
+    case EcsI16:
+        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int16_t*)base));
+        break;
+    case EcsI32:
+        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int32_t*)base));
+        break;
+    case EcsI64:
+        ecs_strbuf_appendint(str, *(const int64_t*)base);
+        break;
+    case EcsF32:
+        ecs_strbuf_appendflt(str, (double)*(const float*)base, 0);
+        break;
+    case EcsF64:
+        ecs_strbuf_appendflt(str, *(const double*)base, 0);
+        break;
+    case EcsIPtr:
+        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const intptr_t*)base));
+        break;
+    case EcsUPtr:
+        ecs_strbuf_append(str, "%u", *(const uintptr_t*)base);
+        break;
+    case EcsString: {
+        const char *value = *ECS_CONST_CAST(const char**, base);
+        if (value) {
+            if (!is_expr) {
+                ecs_strbuf_appendstr(str, value);
+            } else {
+                ecs_size_t length = flecs_stresc(NULL, 0, '"', value);
+                if (length == ecs_os_strlen(value)) {
+                    ecs_strbuf_appendch(str, '"');
+                    ecs_strbuf_appendstrn(str, value, length);
+                    ecs_strbuf_appendch(str, '"');
+                } else {
+                    char *out = ecs_os_malloc(length + 3);
+                    flecs_stresc(out + 1, length, '"', value);
+                    out[0] = '"';
+                    out[length + 1] = '"';
+                    out[length + 2] = '\0';
+                    ecs_strbuf_appendstr(str, out);
+                    ecs_os_free(out);
+                }
+            }
+        } else {
+            ecs_strbuf_appendlit(str, "null");
+        }
+        break;
     }
-
-    return 0;
-}
-
-static
-void flecs_json_serialize_iter_this_row(
-    const ecs_iter_t *it,
-    const char *parent_path,
-    const EcsIdentifier *names,
-    int32_t row,
-    ecs_strbuf_t *buf)
-{
-    if (parent_path) {
-        flecs_json_memberl(buf, "parent");
-        flecs_json_string(buf, parent_path);
+    case EcsEntity: {
+        ecs_entity_t e = *(const ecs_entity_t*)base;
+        if (!e) {
+            ecs_strbuf_appendch(str, '0');
+        } else {
+            ecs_get_path_w_sep_buf(world, 0, e, ".", NULL, str);
+        }
+        break;
     }
-
-    flecs_json_memberl(buf, "name");
-    if (names) {
-        flecs_json_string(buf, names[row].value);
-    } else {
-        ecs_strbuf_appendlit(buf, "\"");
-        ecs_strbuf_appendint(buf, flecs_uto(int64_t, 
-            (uint32_t)it->entities[row]));
-        ecs_strbuf_appendlit(buf, "\"");
+    case EcsId: {
+        ecs_id_t id = *(const ecs_id_t*)base;
+        if (!id) {
+            ecs_strbuf_appendch(str, '0');
+        } else {
+            ecs_id_str_buf(world, id, str);
+        }
+        break;
     }
-}
-
-static
-int flecs_json_serialize_iter_result_query_rows(
-    const ecs_world_t *world, 
-    const ecs_iter_t *it, 
-    ecs_strbuf_t *buf,
-    ecs_json_ser_ctx_t *ser_ctx,
-    int32_t count,
-    bool has_this,
-    const char *parent_path,
-    const EcsIdentifier *names)
-{
-    /* Serialize tags, pairs, vars once, since they're the same for each row */
-    ecs_strbuf_t tags_pairs_vars_buf = ECS_STRBUF_INIT;
-    int32_t tags_pairs_vars_len = 0;
-    char *tags_pairs_vars = NULL;
-    if (flecs_json_serialize_tags_pairs_vars(world, it, &tags_pairs_vars_buf)) {
-        tags_pairs_vars_len = ecs_strbuf_written(&tags_pairs_vars_buf);
-        tags_pairs_vars = ecs_strbuf_get(&tags_pairs_vars_buf);
+    default:
+        ecs_err("invalid primitive kind");
+        return -1;
     }
 
-    int32_t i;
-    for (i = 0; i < count; i ++) {
-        flecs_json_next(buf);
-        flecs_json_object_push(buf);
-
-        if (has_this) {
-            flecs_json_serialize_iter_this_row(
-                it, parent_path, names, i, buf);
-        }
-
-        if (tags_pairs_vars) {
-            ecs_strbuf_list_appendstrn(buf, 
-                tags_pairs_vars, tags_pairs_vars_len);
-        }
-
-        if (flecs_json_serialize_row_components(world, it, buf, ser_ctx, i)) {
-            return -1;
-        }
+    return 0;
+}
 
-        flecs_json_object_pop(buf);
+ecs_entity_t ecs_primitive_init(
+    ecs_world_t *world,
+    const ecs_primitive_desc_t *desc)
+{
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
+
+    ecs_entity_t t = desc->entity;
+    if (!t) {
+        t = ecs_new_low_id(world);
     }
 
-    ecs_os_free(tags_pairs_vars);
+    ecs_set(world, t, EcsPrimitive, { desc->kind });
 
-    return 0;
+    flecs_resume_readonly(world, &rs);
+    return t;
 }
 
-static
-int flecs_json_serialize_iter_result_table_rows(
-    const ecs_world_t *world, 
-    const ecs_iter_t *it, 
-    ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc,
-    int32_t count,
-    bool has_this,
-    const char *parent_path,
-    const EcsIdentifier *names)
+ecs_entity_t ecs_enum_init(
+    ecs_world_t *world,
+    const ecs_enum_desc_t *desc)
 {
-    ecs_table_t *table = it->table;
-    if (!table || !count) {
-        return 0;
-    }
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
 
-    /* Serialize tags, pairs, vars once, since they're the same for each row */
-    ecs_strbuf_t tags_pairs_vars_buf = ECS_STRBUF_INIT;
-    int32_t tags_pairs_vars_len = 0;
-    char *tags_pairs_vars = NULL;
-    if (flecs_json_serialize_table_tags_pairs_vars(
-        world, table, &tags_pairs_vars_buf, desc)) 
-    {
-        tags_pairs_vars_len = ecs_strbuf_written(&tags_pairs_vars_buf);
-        tags_pairs_vars = ecs_strbuf_get(&tags_pairs_vars_buf);
+    ecs_entity_t t = desc->entity;
+    if (!t) {
+        t = ecs_new_low_id(world);
     }
 
-    /* If one entity has more than 256 components (oof), bad luck */
-    ecs_json_value_ser_ctx_t values_ctx[256] = {{0}};
-    int32_t column_count = table->column_count;
-    if (column_count > 256) {
-        column_count = 256;
-    }
+    ecs_add(world, t, EcsEnum);
 
-    int32_t i, end = it->offset + count;
-    int result = 0;
-    for (i = it->offset; i < end; i ++) {
-        flecs_json_next(buf);
-        flecs_json_object_push(buf);
+    ecs_entity_t old_scope = ecs_set_scope(world, t);
 
-        if (has_this) {
-            const EcsIdentifier *name_ptr = NULL;
-            if (names) {
-                /* Correct for offset applied by iterator */
-                name_ptr = &names[-it->offset];
-            }
-            flecs_json_serialize_iter_this_row(
-                it, parent_path, name_ptr, i, buf);
+    int i;
+    for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) {
+        const ecs_enum_constant_t *m_desc = &desc->constants[i];
+        if (!m_desc->name) {
+            break;
         }
 
-        if (tags_pairs_vars) {
-            ecs_strbuf_list_appendstrn(buf, 
-                tags_pairs_vars, tags_pairs_vars_len);
-        }
+        ecs_entity_t c = ecs_entity(world, {
+            .name = m_desc->name
+        });
 
-        if (flecs_json_serialize_row_table_components(
-            world, table, buf, values_ctx, i, column_count)) 
-        {
-            result = -1;
-            break;
+        if (!m_desc->value) {
+            ecs_add_id(world, c, EcsConstant);
+        } else {
+            ecs_set_pair_second(world, c, EcsConstant, ecs_i32_t, 
+                {m_desc->value});
         }
-
-        flecs_json_object_pop(buf);
     }
 
-    for (i = 0; i < column_count; i ++) {
-        ecs_os_free(values_ctx[i].id_label);
-    }
+    ecs_set_scope(world, old_scope);
+    flecs_resume_readonly(world, &rs);
 
-    ecs_os_free(tags_pairs_vars);
+    if (i == 0) {
+        ecs_err("enum '%s' has no constants", ecs_get_name(world, t));
+        ecs_delete(world, t);
+        return 0;
+    }
 
-    return result;
+    return t;
 }
 
-int flecs_json_serialize_iter_result_rows(
-    const ecs_world_t *world, 
-    const ecs_iter_t *it, 
-    ecs_strbuf_t *buf,
-    const ecs_iter_to_json_desc_t *desc,
-    ecs_json_ser_ctx_t *ser_ctx)
+ecs_entity_t ecs_bitmask_init(
+    ecs_world_t *world,
+    const ecs_bitmask_desc_t *desc)
 {
-    char *parent_path = NULL;
-    EcsIdentifier *names = NULL;
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
 
-    int32_t count = it->count;
-    bool has_this = true;
-    if (!count) {
-        count = 1; /* Query without this variable */
-        has_this = false;
-    } else {
-        ecs_table_t *table = it->table;
-        if (table) {
-            /* Get path to parent once for entire table */
-            if (table->flags & EcsTableHasChildOf) {
-                const ecs_table_record_t *tr = flecs_table_record_get(
-                    world, table, ecs_pair(EcsChildOf, EcsWildcard));
-                ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-                ecs_entity_t parent = ecs_pair_second(
-                    world, table->type.array[tr->index]);
-                parent_path = ecs_get_path_w_sep(world, 0, parent, ".", "");
-            }
+    ecs_entity_t t = desc->entity;
+    if (!t) {
+        t = ecs_new_low_id(world);
+    }
 
-            /* Fetch name column once vs. calling ecs_get_name for each row */
-            if (table->flags & EcsTableHasName) {
-                names = ecs_table_get_id(it->world, it->table, 
-                    ecs_pair(ecs_id(EcsIdentifier), EcsName), it->offset);
-            }
+    ecs_add(world, t, EcsBitmask);
+
+    ecs_entity_t old_scope = ecs_set_scope(world, t);
+
+    int i;
+    for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) {
+        const ecs_bitmask_constant_t *m_desc = &desc->constants[i];
+        if (!m_desc->name) {
+            break;
+        }
+
+        ecs_entity_t c = ecs_entity(world, {
+            .name = m_desc->name
+        });
+
+        if (!m_desc->value) {
+            ecs_add_id(world, c, EcsConstant);
         } else {
-            /* Very rare case, but could happen if someone's using an iterator
-             * to return empty entities. */
+            ecs_set_pair_second(world, c, EcsConstant, ecs_u32_t, 
+                {m_desc->value});
         }
     }
 
-    if (!desc->serialize_table) {
-        flecs_json_serialize_iter_result_query_rows(
-            world, it, buf, ser_ctx, count, has_this, parent_path, names);
-    } else {
-        flecs_json_serialize_iter_result_table_rows(
-            world, it, buf, desc, count, has_this, parent_path, names);
-    }
+    ecs_set_scope(world, old_scope);
+    flecs_resume_readonly(world, &rs);
 
-    ecs_os_free(parent_path);
+    if (i == 0) {
+        ecs_err("bitmask '%s' has no constants", ecs_get_name(world, t));
+        ecs_delete(world, t);
+        return 0;
+    }
 
-    return 0;
+    return t;
 }
 
-#endif
+ecs_entity_t ecs_array_init(
+    ecs_world_t *world,
+    const ecs_array_desc_t *desc)
+{
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
 
-/**
- * @file json/serialize_query_info.c
- * @brief Serialize (component) values to JSON strings.
- */
+    ecs_entity_t t = desc->entity;
+    if (!t) {
+        t = ecs_new_low_id(world);
+    }
 
+    ecs_set(world, t, EcsArray, {
+        .type = desc->type,
+        .count = desc->count
+    });
 
-#ifdef FLECS_JSON
+    flecs_resume_readonly(world, &rs);
 
-static
-const char* flecs_json_inout_str(
-    ecs_inout_kind_t kind)
-{
-    switch(kind) {
-    case EcsIn: return "in";
-    case EcsOut: return "out";
-    case EcsInOut: return "inout";
-    case EcsInOutNone: return "none";
-    case EcsInOutDefault: return "default";
-    default: return "unknown";
-    }
+    return t;
 }
 
-static
-const char* flecs_json_oper_str(
-    ecs_oper_kind_t kind)
+ecs_entity_t ecs_vector_init(
+    ecs_world_t *world,
+    const ecs_vector_desc_t *desc)
 {
-    switch(kind) {
-    case EcsAnd: return "and";
-    case EcsNot: return "not";
-    case EcsOr: return "or";
-    case EcsOptional: return "optional";
-    case EcsAndFrom: return "andfrom";
-    case EcsNotFrom: return "notfrom";
-    case EcsOrFrom: return "orfrom";
-    default: return "unknown";
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
+
+    ecs_entity_t t = desc->entity;
+    if (!t) {
+        t = ecs_new_low_id(world);
     }
-}
 
-static
-void flecs_json_serialize_term_entity(
-    const ecs_world_t *world,
-    ecs_entity_t e,
-    ecs_strbuf_t *buf)
-{
-    flecs_json_memberl(buf, "entity");
-    flecs_json_path(buf, world, e);
+    ecs_set(world, t, EcsVector, {
+        .type = desc->type
+    });
 
-    if (e) {
-        const char *symbol = ecs_get_symbol(world, e);
-        if (symbol) {
-            flecs_json_memberl(buf, "symbol");
-            flecs_json_string(buf, symbol);
-        }
+    flecs_resume_readonly(world, &rs);
 
-        if (ecs_has(world, e, EcsComponent)) {
-            flecs_json_memberl(buf, "type");
-            flecs_json_true(buf);
-        }
-    }
+    return t;
 }
 
 static
-void flecs_json_serialize_term_ref(
-    const ecs_world_t *world,
-    const ecs_term_id_t *ref,
-    ecs_strbuf_t *buf)
+bool flecs_member_range_overlaps(
+    const ecs_member_value_range_t *range,
+    const ecs_member_value_range_t *with)
 {
-    flecs_json_object_push(buf);
-    if (ref->flags & EcsIsEntity) {
-        flecs_json_serialize_term_entity(world, ref->id, buf);
-    } else if (ref->flags & EcsIsVariable) {
-        flecs_json_memberl(buf, "var");
-        if (ref->name) {
-            flecs_json_string(buf, ref->name);
-        } else if (ref->id) {
-            if (ref->id == EcsThis) {
-                flecs_json_string(buf, "this");
-            } else {
-                flecs_json_path(buf, world, ref->id);
-            }
-        }
-    } else if (ref->flags & EcsIsName) {
-        flecs_json_memberl(buf, "name");
-        flecs_json_string(buf, ref->name);
+    if (ECS_EQ(with->min, with->max)) {
+        return false;
     }
-    flecs_json_object_pop(buf);
-}
 
-static
-void flecs_json_serialize_term_trav(
-    const ecs_world_t *world,
-    const ecs_term_t *term,
-    ecs_strbuf_t *buf)
-{
-    if (term->src.trav) {
-        flecs_json_memberl(buf, "trav");
-        flecs_json_object_push(buf);
-        flecs_json_serialize_term_entity(world, term->src.trav, buf);
-        flecs_json_object_pop(buf);
+    if (ECS_EQ(range->min, range->max)) {
+        return false;
     }
 
-    flecs_json_memberl(buf, "flags");
-    flecs_json_array_push(buf);
-    if (term->src.flags & EcsSelf) {
-        flecs_json_next(buf);
-        flecs_json_string(buf, "self");
-    }
-    if (term->src.flags & EcsCascade) {
-        flecs_json_next(buf);
-        flecs_json_string(buf, "cascade");
-    } else
-    if (term->src.flags & EcsUp) {
-        flecs_json_next(buf);
-        flecs_json_string(buf, "up");
+    if (range->min < with->min || 
+        range->max > with->max) 
+    {
+        return true;
     }
-    flecs_json_array_pop(buf);
+
+    return false;
 }
 
-static
-void flecs_json_serialize_term(
-    const ecs_world_t *world,
-    const ecs_filter_t *q,
-    int t,
-    ecs_strbuf_t *buf)
+ecs_entity_t ecs_struct_init(
+    ecs_world_t *world,
+    const ecs_struct_desc_t *desc)
 {
-    ecs_term_t *term = &q->terms[t];
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
 
-    flecs_json_object_push(buf);
-    flecs_json_memberl(buf, "inout");
-    flecs_json_string(buf, flecs_json_inout_str(term->inout));
+    ecs_entity_t t = desc->entity;
+    if (!t) {
+        t = ecs_new_low_id(world);
+    }
 
-    flecs_json_memberl(buf, "has_data");
-    flecs_json_bool(buf, 0 == (term->flags & EcsTermNoData));
+    ecs_entity_t old_scope = ecs_set_scope(world, t);
 
-    if (term->first.flags & EcsIsEntity && term->first.id) {
-        if (ecs_has_id(world, term->first.id, EcsDontInherit)) {
-            flecs_json_memberl(buf, "dont_inherit");
-            flecs_json_true(buf);
+    int i;
+    for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) {
+        const ecs_member_t *m_desc = &desc->members[i];
+        if (!m_desc->type) {
+            break;
         }
-    }
-
-    flecs_json_memberl(buf, "oper");
-    flecs_json_string(buf, flecs_json_oper_str(term->oper));
 
-    flecs_json_memberl(buf, "src");
-    flecs_json_serialize_term_ref(world, &term->src, buf);
+        if (!m_desc->name) {
+            ecs_err("member %d of struct '%s' does not have a name", i, 
+                ecs_get_name(world, t));
+            goto error;
+        }
 
-    flecs_json_memberl(buf, "first");
-    flecs_json_serialize_term_ref(world, &term->first, buf);
-    
-    if (term->second.id || term->second.name || term->second.flags & EcsIsEntity) {
-        flecs_json_memberl(buf, "second");
-        flecs_json_serialize_term_ref(world, &term->second, buf);
-    }
+        ecs_entity_t m = ecs_entity(world, {
+            .name = m_desc->name
+        });
 
-    flecs_json_serialize_term_trav(world, term, buf);
+        ecs_set(world, m, EcsMember, {
+            .type = m_desc->type, 
+            .count = m_desc->count,
+            .offset = m_desc->offset,
+            .unit = m_desc->unit
+        });
 
-    flecs_json_object_pop(buf);
-}
+        EcsMemberRanges *ranges = NULL;
+        const ecs_member_value_range_t *range = &m_desc->range;
+        const ecs_member_value_range_t *error = &m_desc->error_range;
+        const ecs_member_value_range_t *warning = &m_desc->warning_range;
+        if (ECS_NEQ(range->min, range->max)) {
+            ranges = ecs_ensure(world, m, EcsMemberRanges);
+            if (range->min > range->max) {
+                char *member_name = ecs_get_fullpath(world, m);
+                ecs_err("member '%s' has an invalid value range [%f..%f]",
+                    member_name, range->min, range->max);
+                ecs_os_free(member_name);
+                goto error;
+            }
+            ranges->value.min = range->min;
+            ranges->value.max = range->max;
+        }
+        if (ECS_NEQ(error->min, error->max)) {
+            if (error->min > error->max) {
+                char *member_name = ecs_get_fullpath(world, m);
+                ecs_err("member '%s' has an invalid error range [%f..%f]",
+                    member_name, error->min, error->max);
+                ecs_os_free(member_name);
+                goto error;
+            }
+            if (flecs_member_range_overlaps(error, range)) {
+                char *member_name = ecs_get_fullpath(world, m);
+                ecs_err("error range of member '%s' overlaps with value range",
+                    member_name);
+                ecs_os_free(member_name);
+                goto error;
+            }
+            if (!ranges) {
+                ranges = ecs_ensure(world, m, EcsMemberRanges);
+            }
+            ranges->error.min = error->min;
+            ranges->error.max = error->max;
+        }
 
-void flecs_json_serialize_query(
-    const ecs_world_t *world,
-    const ecs_filter_t *q,
-    ecs_strbuf_t *buf)
-{
-    flecs_json_object_push(buf);
-    flecs_json_memberl(buf, "terms");
-    flecs_json_array_push(buf);
-    int t;
-    for (t = 0; t < q->term_count; t ++) {
-        flecs_json_next(buf);
-        flecs_json_serialize_term(world, q, t, buf);
-    }
-    flecs_json_array_pop(buf);
-    flecs_json_object_pop(buf);
-}
+        if (ECS_NEQ(warning->min, warning->max)) {
+            if (warning->min > warning->max) {
+                char *member_name = ecs_get_fullpath(world, m);
+                ecs_err("member '%s' has an invalid warning range [%f..%f]",
+                    member_name, warning->min, warning->max);
+                ecs_os_free(member_name);
+                goto error;
+            }
+            if (flecs_member_range_overlaps(warning, range)) {
+                char *member_name = ecs_get_fullpath(world, m);
+                ecs_err("warning range of member '%s' overlaps with value "
+                    "range", member_name);
+                ecs_os_free(member_name);
+                goto error;
+            }
+            if (flecs_member_range_overlaps(warning, error)) {
+                char *member_name = ecs_get_fullpath(world, m);
+                ecs_err("warning range of member '%s' overlaps with error "
+                    "range", member_name);
+                ecs_os_free(member_name);
+                goto error;
+            }
 
-#endif
+            if (!ranges) {
+                ranges = ecs_ensure(world, m, EcsMemberRanges);
+            }
+            ranges->warning.min = warning->min;
+            ranges->warning.max = warning->max;
+        }
 
-/**
- * @file json/serialize_type_info.c
- * @brief Serialize type (reflection) information to JSON.
- */
+        if (ranges && !flecs_type_is_number(world, m_desc->type)) {
+            char *member_name = ecs_get_fullpath(world, m);
+            ecs_err("member '%s' has an value/error/warning range, but is not a "
+                    "number", member_name);
+            ecs_os_free(member_name);
+            goto error;
+        }
 
+        if (ranges) {
+            ecs_modified(world, m, EcsMemberRanges);
+        }
+    }
 
-#ifdef FLECS_JSON
+    ecs_set_scope(world, old_scope);
+    flecs_resume_readonly(world, &rs);
 
-static
-int json_typeinfo_ser_type(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    ecs_strbuf_t *buf);
+    if (i == 0) {
+        ecs_err("struct '%s' has no members", ecs_get_name(world, t));
+        goto error;
+    }
 
-static
-int json_typeinfo_ser_primitive(
-    ecs_primitive_kind_t kind,
-    ecs_strbuf_t *str) 
-{
-    switch(kind) {
-    case EcsBool:
-        flecs_json_string(str, "bool");
-        break;
-    case EcsChar:
-    case EcsString:
-        flecs_json_string(str, "text");
-        break;
-    case EcsByte:
-        flecs_json_string(str, "byte");
-        break;
-    case EcsU8:
-    case EcsU16:
-    case EcsU32:
-    case EcsU64:
-    case EcsI8:
-    case EcsI16:
-    case EcsI32:
-    case EcsI64:
-    case EcsIPtr:
-    case EcsUPtr:
-        flecs_json_string(str, "int");
-        break;
-    case EcsF32:
-    case EcsF64:
-        flecs_json_string(str, "float");
-        break;
-    case EcsEntity:
-        flecs_json_string(str, "entity");
-        break;
-    case EcsId:
-        flecs_json_string(str, "id");
-        break;
-    default:
-        return -1;
+    if (!ecs_has(world, t, EcsStruct)) {
+        goto error;
     }
 
+    return t;
+error:
+    flecs_resume_readonly(world, &rs);
+    if (t) {
+        ecs_delete(world, t);
+    }
     return 0;
 }
 
-static
-void json_typeinfo_ser_constants(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    ecs_strbuf_t *str)
+ecs_entity_t ecs_opaque_init(
+    ecs_world_t *world,
+    const ecs_opaque_desc_t *desc)
 {
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t) {
-        .id = ecs_pair(EcsChildOf, type)
-    });
+    ecs_assert(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(desc->type.as_type != 0, ECS_INVALID_PARAMETER, NULL);
 
-    while (ecs_term_next(&it)) {
-        int32_t i, count = it.count;
-        for (i = 0; i < count; i ++) {
-            flecs_json_next(str);
-            flecs_json_string(str, ecs_get_name(world, it.entities[i]));
-        }
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
+
+    ecs_entity_t t = desc->entity;
+    if (!t) {
+        t = ecs_new_low_id(world);
     }
-}
 
-static
-void json_typeinfo_ser_enum(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    ecs_strbuf_t *str)
-{
-    ecs_strbuf_list_appendstr(str, "\"enum\"");
-    json_typeinfo_ser_constants(world, type, str);
-}
+    ecs_set_ptr(world, t, EcsOpaque, &desc->type);
 
-static
-void json_typeinfo_ser_bitmask(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    ecs_strbuf_t *str)
-{
-    ecs_strbuf_list_appendstr(str, "\"bitmask\"");
-    json_typeinfo_ser_constants(world, type, str);
+    flecs_resume_readonly(world, &rs);
+
+    return t;
 }
 
-static
-int json_typeinfo_ser_array(
-    const ecs_world_t *world,
-    ecs_entity_t elem_type,
-    int32_t count,
-    ecs_strbuf_t *str)
+ecs_entity_t ecs_unit_init(
+    ecs_world_t *world,
+    const ecs_unit_desc_t *desc)
 {
-    ecs_strbuf_list_appendstr(str, "\"array\"");
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
 
-    flecs_json_next(str);
-    if (json_typeinfo_ser_type(world, elem_type, str)) {
-        goto error;
+    ecs_entity_t t = desc->entity;
+    if (!t) {
+        t = ecs_new_low_id(world);
     }
 
-    ecs_strbuf_list_append(str, "%u", count);
-    return 0;
-error:
-    return -1;
-}
+    ecs_entity_t quantity = desc->quantity;
+    if (quantity) {
+        if (!ecs_has_id(world, quantity, EcsQuantity)) {
+            ecs_err("entity '%s' for unit '%s' is not a quantity",
+                ecs_get_name(world, quantity), ecs_get_name(world, t));
+            goto error;
+        }
 
-static
-int json_typeinfo_ser_array_type(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    ecs_strbuf_t *str)
-{
-    const EcsArray *arr = ecs_get(world, type, EcsArray);
-    ecs_assert(arr != NULL, ECS_INTERNAL_ERROR, NULL);
-    if (json_typeinfo_ser_array(world, arr->type, arr->count, str)) {
+        ecs_add_pair(world, t, EcsQuantity, desc->quantity);
+    } else {
+        ecs_remove_pair(world, t, EcsQuantity, EcsWildcard);
+    }
+
+    EcsUnit *value = ecs_ensure(world, t, EcsUnit);
+    value->base = desc->base;
+    value->over = desc->over;
+    value->translation = desc->translation;
+    value->prefix = desc->prefix;
+    ecs_os_strset(&value->symbol, desc->symbol);
+
+    if (!flecs_unit_validate(world, t, value)) {
         goto error;
     }
 
-    return 0;
+    ecs_modified(world, t, EcsUnit);
+
+    flecs_resume_readonly(world, &rs);
+    return t;
 error:
-    return -1;
+    if (t) {
+        ecs_delete(world, t);
+    }
+    flecs_resume_readonly(world, &rs);
+    return 0;
 }
 
-static
-int json_typeinfo_ser_vector(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    ecs_strbuf_t *str)
+ecs_entity_t ecs_unit_prefix_init(
+    ecs_world_t *world,
+    const ecs_unit_prefix_desc_t *desc)
 {
-    const EcsVector *arr = ecs_get(world, type, EcsVector);
-    ecs_assert(arr != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_strbuf_list_appendstr(str, "\"vector\"");
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
 
-    flecs_json_next(str);
-    if (json_typeinfo_ser_type(world, arr->type, str)) {
-        goto error;
+    ecs_entity_t t = desc->entity;
+    if (!t) {
+        t = ecs_new_low_id(world);
     }
 
-    return 0;
-error:
-    return -1;
+    ecs_set(world, t, EcsUnitPrefix, {
+        .symbol = ECS_CONST_CAST(char*, desc->symbol),
+        .translation = desc->translation
+    });
+
+    flecs_resume_readonly(world, &rs);
+
+    return t;
 }
 
-/* Serialize unit information */
-static
-int json_typeinfo_ser_unit(
-    const ecs_world_t *world,
-    ecs_strbuf_t *str,
-    ecs_entity_t unit) 
+ecs_entity_t ecs_quantity_init(
+    ecs_world_t *world,
+    const ecs_entity_desc_t *desc)
 {
-    flecs_json_memberl(str, "unit");
-    flecs_json_path(str, world, unit);
+    ecs_suspend_readonly_state_t rs;
+    world = flecs_suspend_readonly(world, &rs);
 
-    const EcsUnit *uptr = ecs_get(world, unit, EcsUnit);
-    if (uptr) {
-        if (uptr->symbol) {
-            flecs_json_memberl(str, "symbol");
-            flecs_json_string(str, uptr->symbol);
-        }
-        ecs_entity_t quantity = ecs_get_target(world, unit, EcsQuantity, 0);
-        if (quantity) {
-            flecs_json_memberl(str, "quantity");
-            flecs_json_path(str, world, quantity);
-        }
+    ecs_entity_t t = ecs_entity_init(world, desc);
+    if (!t) {
+        return 0;
     }
 
-    return 0;
-}
+    ecs_add_id(world, t, EcsQuantity);
 
-static
-void json_typeinfo_ser_range(
-    ecs_strbuf_t *str,
-    const char *kind,
-    ecs_member_value_range_t *range)
-{
-    flecs_json_member(str, kind);
-    flecs_json_array_push(str);
-    flecs_json_next(str);
-    flecs_json_number(str, range->min);
-    flecs_json_next(str);
-    flecs_json_number(str, range->max);
-    flecs_json_array_pop(str);
+    flecs_resume_readonly(world, &rs);
+
+    return t;
 }
 
-/* Forward serialization to the different type kinds */
-static
-int json_typeinfo_ser_type_op(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *op, 
-    ecs_strbuf_t *str,
-    const EcsStruct *st) 
-{
-    if (op->kind == EcsOpOpaque) {
-        const EcsOpaque *ct = ecs_get(world, op->type, 
-            EcsOpaque);
-        ecs_assert(ct != NULL, ECS_INTERNAL_ERROR, NULL);
-        return json_typeinfo_ser_type(world, ct->as_type, str);
-    }
+#endif
 
-    flecs_json_array_push(str);
+/**
+ * @file addons/meta_c.c
+ * @brief C utilities for meta addon.
+ */
 
-    switch(op->kind) {
-    case EcsOpPush:
-    case EcsOpPop:
-        /* Should not be parsed as single op */
-        ecs_throw(ECS_INVALID_PARAMETER, NULL);
-        break;
-    case EcsOpEnum:
-        json_typeinfo_ser_enum(world, op->type, str);
-        break;
-    case EcsOpBitmask:
-        json_typeinfo_ser_bitmask(world, op->type, str);
-        break;
-    case EcsOpArray:
-        json_typeinfo_ser_array_type(world, op->type, str);
-        break;
-    case EcsOpVector:
-        json_typeinfo_ser_vector(world, op->type, str);
-        break;
-    case EcsOpOpaque:
-        /* Can't happen, already handled above */
-        ecs_throw(ECS_INTERNAL_ERROR, NULL);
-        break;
-    case EcsOpBool:
-    case EcsOpChar:
-    case EcsOpByte:
-    case EcsOpU8:
-    case EcsOpU16:
-    case EcsOpU32:
-    case EcsOpU64:
-    case EcsOpI8:
-    case EcsOpI16:
-    case EcsOpI32:
-    case EcsOpI64:
-    case EcsOpF32:
-    case EcsOpF64:
-    case EcsOpUPtr:
-    case EcsOpIPtr:
-    case EcsOpEntity:
-    case EcsOpId:
-    case EcsOpString:
-        if (json_typeinfo_ser_primitive( 
-            flecs_json_op_to_primitive_kind(op->kind), str))
-        {
-            ecs_throw(ECS_INTERNAL_ERROR, NULL);
-        }
-        break;
-    case EcsOpScope:
-    case EcsOpPrimitive:
-    default:
-        ecs_throw(ECS_INTERNAL_ERROR, NULL);
-    }
 
-    if (st) {
-        ecs_member_t *m = ecs_vec_get_t(
-            &st->members, ecs_member_t, op->member_index);
-        ecs_assert(m != NULL, ECS_INTERNAL_ERROR, NULL);
+#ifdef FLECS_META
 
-        bool value_range = ECS_NEQ(m->range.min, m->range.max);
-        bool error_range = ECS_NEQ(m->error_range.min, m->error_range.max);
-        bool warning_range = ECS_NEQ(m->warning_range.min, m->warning_range.max);
+#include <ctype.h>
 
-        ecs_entity_t unit = m->unit;
-        if (unit || error_range || warning_range || value_range) {
-            flecs_json_next(str);
-            flecs_json_next(str);
-            flecs_json_object_push(str);
+#define ECS_META_IDENTIFIER_LENGTH (256)
 
-            if (unit) {
-                json_typeinfo_ser_unit(world, str, unit);
-            }
-            if (value_range) {
-                json_typeinfo_ser_range(str, "range", &m->range);
-            }
-            if (error_range) {
-                json_typeinfo_ser_range(str, "error_range", &m->error_range);
-            }
-            if (warning_range) {
-                json_typeinfo_ser_range(str, "warning_range", &m->warning_range);
+#define ecs_meta_error(ctx, ptr, ...)\
+    ecs_parser_error((ctx)->name, (ctx)->desc, ptr - (ctx)->desc, __VA_ARGS__);
+
+typedef char ecs_meta_token_t[ECS_META_IDENTIFIER_LENGTH];
+
+typedef struct meta_parse_ctx_t {
+    const char *name;
+    const char *desc;
+} meta_parse_ctx_t;
+
+typedef struct meta_type_t {
+    ecs_meta_token_t type;
+    ecs_meta_token_t params;
+    bool is_const;
+    bool is_ptr;
+} meta_type_t;
+
+typedef struct meta_member_t {
+    meta_type_t type;
+    ecs_meta_token_t name;
+    int64_t count;
+    bool is_partial;
+} meta_member_t;
+
+typedef struct meta_constant_t {
+    ecs_meta_token_t name;
+    int64_t value;
+    bool is_value_set;
+} meta_constant_t;
+
+typedef struct meta_params_t {
+    meta_type_t key_type;
+    meta_type_t type;
+    int64_t count;
+    bool is_key_value;
+    bool is_fixed_size;
+} meta_params_t;
+
+static
+const char* skip_scope(const char *ptr, meta_parse_ctx_t *ctx) {
+    /* Keep track of which characters were used to open the scope */
+    char stack[256];
+    int32_t sp = 0;
+    char ch;
+
+    while ((ch = *ptr)) {
+        if (ch == '(' || ch == '<') {
+            stack[sp] = ch;
+
+            sp ++;
+            if (sp >= 256) {
+                ecs_meta_error(ctx, ptr, "maximum level of nesting reached");
+                goto error;
+            }            
+        } else if (ch == ')' || ch == '>') {
+            sp --;
+            if ((sp < 0) || (ch == '>' && stack[sp] != '<') || 
+                (ch == ')' && stack[sp] != '(')) 
+            {
+                ecs_meta_error(ctx, ptr, "mismatching %c in identifier", ch);
+                goto error;
             }
+        }
 
-            flecs_json_object_pop(str);
+        ptr ++;
+
+        if (!sp) {
+            break;
         }
     }
 
-    flecs_json_array_pop(str);
+    return ptr;
+error:
+    return NULL;
+}
 
-    return 0;
+static
+const char* parse_c_digit(
+    const char *ptr,
+    int64_t *value_out)
+{
+    char token[24];
+    ptr = flecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_digit(ptr, token);
+    if (!ptr) {
+        goto error;
+    }
+
+    *value_out = strtol(token, NULL, 0);
+
+    return flecs_parse_ws_eol(ptr);
 error:
-    return -1;
+    return NULL;
 }
 
-/* Iterate over a slice of the type ops array */
 static
-int json_typeinfo_ser_type_ops(
-    const ecs_world_t *world,
-    ecs_meta_type_op_t *ops,
-    int32_t op_count,
-    ecs_strbuf_t *str,
-    const EcsStruct *st) 
+const char* parse_c_identifier(
+    const char *ptr, 
+    char *buff,
+    char *params,
+    meta_parse_ctx_t *ctx) 
 {
-    const EcsStruct *stack[64] = {st};
-    int32_t sp = 1;
+    ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(buff != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(ctx != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    for (int i = 0; i < op_count; i ++) {
-        ecs_meta_type_op_t *op = &ops[i];
+    char *bptr = buff, ch;
 
-        if (op != ops) {
-            if (op->name) {
-                flecs_json_member(str, op->name);
-            }
-        }
+    if (params) {
+        params[0] = '\0';
+    }
 
-        int32_t elem_count = op->count;
-        if (elem_count > 1) {
-            flecs_json_array_push(str);
-            json_typeinfo_ser_array(world, op->type, op->count, str);
-            flecs_json_array_pop(str);
-            i += op->op_count - 1;
-            continue;
-        }
+    /* Ignore whitespaces */
+    ptr = flecs_parse_ws_eol(ptr);
+    ch = *ptr;
 
-        switch(op->kind) {
-        case EcsOpPush:
-            flecs_json_object_push(str);
-            ecs_assert(sp < 63, ECS_INVALID_OPERATION, "type nesting too deep");
-            stack[sp ++] = ecs_get(world, op->type, EcsStruct);
-            break;
-        case EcsOpPop:
-            flecs_json_object_pop(str);
-            sp --;
-            break;
-        case EcsOpArray:
-        case EcsOpVector:
-        case EcsOpEnum:
-        case EcsOpBitmask:
-        case EcsOpBool:
-        case EcsOpChar:
-        case EcsOpByte:
-        case EcsOpU8:
-        case EcsOpU16:
-        case EcsOpU32:
-        case EcsOpU64:
-        case EcsOpI8:
-        case EcsOpI16:
-        case EcsOpI32:
-        case EcsOpI64:
-        case EcsOpF32:
-        case EcsOpF64:
-        case EcsOpUPtr:
-        case EcsOpIPtr:
-        case EcsOpEntity:
-        case EcsOpId:
-        case EcsOpString:
-        case EcsOpOpaque:
-            if (json_typeinfo_ser_type_op(world, op, str, stack[sp - 1])) {
+    if (!isalpha(ch) && (ch != '_')) {
+        ecs_meta_error(ctx, ptr, "invalid identifier (starts with '%c')", ch);
+        goto error;
+    }
+
+    while ((ch = *ptr) && !isspace(ch) && ch != ';' && ch != ',' && ch != ')' && 
+        ch != '>' && ch != '}' && ch != '*') 
+    {
+        /* Type definitions can contain macros or templates */
+        if (ch == '(' || ch == '<') {
+            if (!params) {
+                ecs_meta_error(ctx, ptr, "unexpected %c", *ptr);
                 goto error;
             }
-            break;
-        case EcsOpPrimitive:
-        case EcsOpScope:
-        default:
-            ecs_throw(ECS_INTERNAL_ERROR, NULL);
+
+            const char *end = skip_scope(ptr, ctx);
+            ecs_os_strncpy(params, ptr, (ecs_size_t)(end - ptr));
+            params[end - ptr] = '\0';
+
+            ptr = end;
+        } else {
+            *bptr = ch;
+            bptr ++;
+            ptr ++;
         }
     }
 
-    return 0;
+    *bptr = '\0';
+
+    if (!ch) {
+        ecs_meta_error(ctx, ptr, "unexpected end of token");
+        goto error;
+    }
+
+    return ptr;
 error:
-    return -1;
+    return NULL;
 }
 
 static
-int json_typeinfo_ser_type(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    ecs_strbuf_t *buf)
+const char * meta_open_scope(
+    const char *ptr,
+    meta_parse_ctx_t *ctx)    
 {
-    const EcsComponent *comp = ecs_get(world, type, EcsComponent);
-    if (!comp) {
-        ecs_strbuf_appendch(buf, '0');
-        return 0;
+    /* Skip initial whitespaces */
+    ptr = flecs_parse_ws_eol(ptr);
+
+    /* Is this the start of the type definition? */
+    if (ctx->desc == ptr) {
+        if (*ptr != '{') {
+            ecs_meta_error(ctx, ptr, "missing '{' in struct definition");
+            goto error; 
+        }
+
+        ptr ++;
+        ptr = flecs_parse_ws_eol(ptr);
     }
 
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
-    if (!ser) {
-        ecs_strbuf_appendch(buf, '0');
-        return 0;
+    /* Is this the end of the type definition? */
+    if (!*ptr) {
+        ecs_meta_error(ctx, ptr, "missing '}' at end of struct definition");
+        goto error;
+    }   
+
+    /* Is this the end of the type definition? */
+    if (*ptr == '}') {
+        ptr = flecs_parse_ws_eol(ptr + 1);
+        if (*ptr) {
+            ecs_meta_error(ctx, ptr, 
+                "stray characters after struct definition");
+            goto error;
+        }
+        return NULL;
     }
 
-    const EcsStruct *st = ecs_get(world, type, EcsStruct);
-    ecs_meta_type_op_t *ops = ecs_vec_first_t(&ser->ops, ecs_meta_type_op_t);
-    int32_t count = ecs_vec_count(&ser->ops);
-
-    return json_typeinfo_ser_type_ops(world, ops, count, buf, st);
+    return ptr;
+error:
+    return NULL;
 }
 
-int ecs_type_info_to_json_buf(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    ecs_strbuf_t *buf)
-{
-    return json_typeinfo_ser_type(world, type, buf);
-}
+static
+const char* meta_parse_constant(
+    const char *ptr,
+    meta_constant_t *token,
+    meta_parse_ctx_t *ctx)
+{    
+    ptr = meta_open_scope(ptr, ctx);
+    if (!ptr) {
+        return NULL;
+    }
 
-char* ecs_type_info_to_json(
-    const ecs_world_t *world,
-    ecs_entity_t type)
-{
-    ecs_strbuf_t str = ECS_STRBUF_INIT;
+    token->is_value_set = false;
 
-    if (ecs_type_info_to_json_buf(world, type, &str) != 0) {
-        ecs_strbuf_reset(&str);
+    /* Parse token, constant identifier */
+    ptr = parse_c_identifier(ptr, token->name, NULL, ctx);
+    if (!ptr) {
         return NULL;
     }
 
-    return ecs_strbuf_get(&str);
-}
+    ptr = flecs_parse_ws_eol(ptr);
+    if (!ptr) {
+        return NULL;
+    }
 
-#endif
+    /* Explicit value assignment */
+    if (*ptr == '=') {
+        int64_t value = 0;
+        ptr = parse_c_digit(ptr + 1, &value);
+        token->value = value;
+        token->is_value_set = true;
+    }
 
-/**
- * @file meta/api.c
- * @brief API for creating entities with reflection data.
- */
+    /* Expect a ',' or '}' */
+    if (*ptr != ',' && *ptr != '}') {
+        ecs_meta_error(ctx, ptr, "missing , after enum constant");
+        goto error;
+    }
 
-/**
- * @file meta/meta.h
- * @brief Private functions for meta addon.
- */
+    if (*ptr == ',') {
+        return ptr + 1;
+    } else {
+        return ptr;
+    }
+error:
+    return NULL;
+}
 
-#ifndef FLECS_META_PRIVATE_H
-#define FLECS_META_PRIVATE_H
+static
+const char* meta_parse_type(
+    const char *ptr,
+    meta_type_t *token,
+    meta_parse_ctx_t *ctx)
+{
+    token->is_ptr = false;
+    token->is_const = false;
 
+    ptr = flecs_parse_ws_eol(ptr);
 
-#ifdef FLECS_META
+    /* Parse token, expect type identifier or ECS_PROPERTY */
+    ptr = parse_c_identifier(ptr, token->type, token->params, ctx);
+    if (!ptr) {
+        goto error;
+    }
 
-void ecs_meta_type_serialized_init(
-    ecs_iter_t *it);
+    if (!strcmp(token->type, "ECS_PRIVATE")) {
+        /* Members from this point are not stored in metadata */
+        ptr += ecs_os_strlen(ptr);
+        goto done;
+    }
 
-void ecs_meta_dtor_serialized(
-    EcsMetaTypeSerialized *ptr);
+    /* If token is const, set const flag and continue parsing type */
+    if (!strcmp(token->type, "const")) {
+        token->is_const = true;
 
-ecs_meta_type_op_kind_t flecs_meta_primitive_to_op_kind(
-    ecs_primitive_kind_t kind);
+        /* Parse type after const */
+        ptr = parse_c_identifier(ptr + 1, token->type, token->params, ctx);
+    }
 
-bool flecs_unit_validate(
-    ecs_world_t *world,
-    ecs_entity_t t,
-    EcsUnit *data);
+    /* Check if type is a pointer */
+    ptr = flecs_parse_ws_eol(ptr);
+    if (*ptr == '*') {
+        token->is_ptr = true;
+        ptr ++;
+    }
 
-void flecs_meta_import_definitions(
-    ecs_world_t *world);
+done:
+    return ptr;
+error:
+    return NULL;
+}
 
-#endif
+static
+const char* meta_parse_member(
+    const char *ptr,
+    meta_member_t *token,
+    meta_parse_ctx_t *ctx)
+{
+    ptr = meta_open_scope(ptr, ctx);
+    if (!ptr) {
+        return NULL;
+    }
 
-#endif
+    token->count = 1;
+    token->is_partial = false;
 
+    /* Parse member type */
+    ptr = meta_parse_type(ptr, &token->type, ctx);
+    if (!ptr) {
+        token->is_partial = true;
+        goto error;
+    }
 
-#ifdef FLECS_META
+    if (!ptr[0]) {
+        return ptr;        
+    }
 
-static
-bool flecs_type_is_number(
-    ecs_world_t *world,
-    ecs_entity_t type)
-{
-    const EcsPrimitive *p = ecs_get(world, type, EcsPrimitive);
-    if (!p) {
-        return false;
+    /* Next token is the identifier */
+    ptr = parse_c_identifier(ptr, token->name, NULL, ctx);
+    if (!ptr) {
+        goto error;
     }
 
-    switch(p->kind) {
-    case EcsChar:
-    case EcsU8:
-    case EcsU16:
-    case EcsU32:
-    case EcsU64:
-    case EcsI8:
-    case EcsI16:
-    case EcsI32:
-    case EcsI64:
-    case EcsF32:
-    case EcsF64:
-        return true;
+    /* Skip whitespace between member and [ or ; */
+    ptr = flecs_parse_ws_eol(ptr);
 
-    case EcsBool:
-    case EcsByte:
-    case EcsUPtr:
-    case EcsIPtr:
-    case EcsString:
-    case EcsEntity:
-    case EcsId:
-        return false;
-    default:
-        ecs_abort(ECS_INVALID_PARAMETER, NULL);
+    /* Check if this is an array */
+    char *array_start = strchr(token->name, '[');
+    if (!array_start) {
+        /* If the [ was separated by a space, it will not be parsed as part of
+         * the name */
+        if (*ptr == '[') {
+            /* safe, will not be modified */
+            array_start = ECS_CONST_CAST(char*, ptr);
+        }
     }
-}
 
-ecs_entity_t ecs_primitive_init(
-    ecs_world_t *world,
-    const ecs_primitive_desc_t *desc)
-{
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
+    if (array_start) {
+        /* Check if the [ matches with a ] */
+        char *array_end = strchr(array_start, ']');
+        if (!array_end) {
+            ecs_meta_error(ctx, ptr, "missing ']'");
+            goto error;
 
-    ecs_entity_t t = desc->entity;
-    if (!t) {
-        t = ecs_new_low_id(world);
+        } else if (array_end - array_start == 0) {
+            ecs_meta_error(ctx, ptr, "dynamic size arrays are not supported");
+            goto error;
+        }
+
+        token->count = atoi(array_start + 1);
+
+        if (array_start == ptr) {
+            /* If [ was found after name, continue parsing after ] */
+            ptr = array_end + 1;
+        } else {
+            /* If [ was fonud in name, replace it with 0 terminator */
+            array_start[0] = '\0';
+        }
     }
 
-    ecs_set(world, t, EcsPrimitive, { desc->kind });
+    /* Expect a ; */
+    if (*ptr != ';') {
+        ecs_meta_error(ctx, ptr, "missing ; after member declaration");
+        goto error;
+    }
 
-    flecs_resume_readonly(world, &rs);
-    return t;
+    return ptr + 1;
+error:
+    return NULL;
 }
 
-ecs_entity_t ecs_enum_init(
-    ecs_world_t *world,
-    const ecs_enum_desc_t *desc)
+static
+int meta_parse_desc(
+    const char *ptr,
+    meta_params_t *token,
+    meta_parse_ctx_t *ctx)
 {
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
+    token->is_key_value = false;
+    token->is_fixed_size = false;
 
-    ecs_entity_t t = desc->entity;
-    if (!t) {
-        t = ecs_new_low_id(world);
+    ptr = flecs_parse_ws_eol(ptr);
+    if (*ptr != '(' && *ptr != '<') {
+        ecs_meta_error(ctx, ptr, 
+            "expected '(' at start of collection definition");
+        goto error;
     }
 
-    ecs_add(world, t, EcsEnum);
+    ptr ++;
 
-    ecs_entity_t old_scope = ecs_set_scope(world, t);
+    /* Parse type identifier */
+    ptr = meta_parse_type(ptr, &token->type, ctx);
+    if (!ptr) {
+        goto error;
+    }
 
-    int i;
-    for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) {
-        const ecs_enum_constant_t *m_desc = &desc->constants[i];
-        if (!m_desc->name) {
-            break;
-        }
+    ptr = flecs_parse_ws_eol(ptr);
 
-        ecs_entity_t c = ecs_entity(world, {
-            .name = m_desc->name
-        });
+    /* If next token is a ',' the first type was a key type */
+    if (*ptr == ',') {
+        ptr = flecs_parse_ws_eol(ptr + 1);
+        
+        if (isdigit(*ptr)) {
+            int64_t value;
+            ptr = parse_c_digit(ptr, &value);
+            if (!ptr) {
+                goto error;
+            }
 
-        if (!m_desc->value) {
-            ecs_add_id(world, c, EcsConstant);
+            token->count = value;
+            token->is_fixed_size = true;
         } else {
-            ecs_set_pair_object(world, c, EcsConstant, ecs_i32_t, 
-                {m_desc->value});
+            token->key_type = token->type;
+
+            /* Parse element type */
+            ptr = meta_parse_type(ptr, &token->type, ctx);
+            ptr = flecs_parse_ws_eol(ptr);
+
+            token->is_key_value = true;
         }
     }
 
-    ecs_set_scope(world, old_scope);
-    flecs_resume_readonly(world, &rs);
-
-    if (i == 0) {
-        ecs_err("enum '%s' has no constants", ecs_get_name(world, t));
-        ecs_delete(world, t);
-        return 0;
+    if (*ptr != ')' && *ptr != '>') {
+        ecs_meta_error(ctx, ptr, 
+            "expected ')' at end of collection definition");
+        goto error;
     }
 
-    return t;
+    return 0;
+error:
+    return -1;
 }
 
-ecs_entity_t ecs_bitmask_init(
+static
+ecs_entity_t meta_lookup(
     ecs_world_t *world,
-    const ecs_bitmask_desc_t *desc)
+    meta_type_t *token,
+    const char *ptr,
+    int64_t count,
+    meta_parse_ctx_t *ctx);
+
+static
+ecs_entity_t meta_lookup_array(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    const char *params_decl,
+    meta_parse_ctx_t *ctx)
 {
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
+    meta_parse_ctx_t param_ctx = {
+        .name = ctx->name,
+        .desc = params_decl
+    };
 
-    ecs_entity_t t = desc->entity;
-    if (!t) {
-        t = ecs_new_low_id(world);
+    meta_params_t params;
+    if (meta_parse_desc(params_decl, &params, &param_ctx)) {
+        goto error;
+    }
+    if (!params.is_fixed_size) {
+        ecs_meta_error(ctx, params_decl, "missing size for array");
+        goto error;
     }
 
-    ecs_add(world, t, EcsBitmask);
+    if (!params.count) {
+        ecs_meta_error(ctx, params_decl, "invalid array size");
+        goto error;
+    }
 
-    ecs_entity_t old_scope = ecs_set_scope(world, t);
+    ecs_entity_t element_type = ecs_lookup_symbol(
+        world, params.type.type, true, true);
+    if (!element_type) {
+        ecs_meta_error(ctx, params_decl, "unknown element type '%s'",
+            params.type.type);
+    }
 
-    int i;
-    for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) {
-        const ecs_bitmask_constant_t *m_desc = &desc->constants[i];
-        if (!m_desc->name) {
-            break;
-        }
+    if (!e) {
+        e = ecs_new(world);
+    }
 
-        ecs_entity_t c = ecs_entity(world, {
-            .name = m_desc->name
-        });
+    ecs_check(params.count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL);
 
-        if (!m_desc->value) {
-            ecs_add_id(world, c, EcsConstant);
-        } else {
-            ecs_set_pair_object(world, c, EcsConstant, ecs_u32_t, 
-                {m_desc->value});
-        }
+    ecs_set(world, e, EcsArray, { element_type, (int32_t)params.count });
+
+    return e;
+error:
+    return 0;
+}
+
+static
+ecs_entity_t meta_lookup_vector(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    const char *params_decl,
+    meta_parse_ctx_t *ctx)
+{
+    meta_parse_ctx_t param_ctx = {
+        .name = ctx->name,
+        .desc = params_decl
+    };
+
+    meta_params_t params;
+    if (meta_parse_desc(params_decl, &params, &param_ctx)) {
+        goto error;
     }
 
-    ecs_set_scope(world, old_scope);
-    flecs_resume_readonly(world, &rs);
+    if (params.is_key_value) {
+        ecs_meta_error(ctx, params_decl,
+            "unexpected key value parameters for vector");
+        goto error;
+    }
 
-    if (i == 0) {
-        ecs_err("bitmask '%s' has no constants", ecs_get_name(world, t));
-        ecs_delete(world, t);
-        return 0;
+    ecs_entity_t element_type = meta_lookup(
+        world, &params.type, params_decl, 1, &param_ctx);
+
+    if (!e) {
+        e = ecs_new(world);
     }
 
-    return t;
+    ecs_set(world, e, EcsVector, { element_type });
+
+    return e;
+error:
+    return 0;
 }
 
-ecs_entity_t ecs_array_init(
+static
+ecs_entity_t meta_lookup_bitmask(
     ecs_world_t *world,
-    const ecs_array_desc_t *desc)
+    ecs_entity_t e,
+    const char *params_decl,
+    meta_parse_ctx_t *ctx)
 {
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
+    (void)e;
 
-    ecs_entity_t t = desc->entity;
-    if (!t) {
-        t = ecs_new_low_id(world);
+    meta_parse_ctx_t param_ctx = {
+        .name = ctx->name,
+        .desc = params_decl
+    };
+
+    meta_params_t params;
+    if (meta_parse_desc(params_decl, &params, &param_ctx)) {
+        goto error;
     }
 
-    ecs_set(world, t, EcsArray, {
-        .type = desc->type,
-        .count = desc->count
-    });
+    if (params.is_key_value) {
+        ecs_meta_error(ctx, params_decl,
+            "unexpected key value parameters for bitmask");
+        goto error;
+    }
 
-    flecs_resume_readonly(world, &rs);
+    if (params.is_fixed_size) {
+        ecs_meta_error(ctx, params_decl,
+            "unexpected size for bitmask");
+        goto error;
+    }
 
-    return t;
+    ecs_entity_t bitmask_type = meta_lookup(
+        world, &params.type, params_decl, 1, &param_ctx);
+    ecs_check(bitmask_type != 0, ECS_INVALID_PARAMETER, NULL);
+
+#ifndef FLECS_NDEBUG
+    /* Make sure this is a bitmask type */
+    const EcsType *type_ptr = ecs_get(world, bitmask_type, EcsType);
+    ecs_check(type_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(type_ptr->kind == EcsBitmaskType, ECS_INVALID_PARAMETER, NULL);
+#endif
+
+    return bitmask_type;
+error:
+    return 0;
 }
 
-ecs_entity_t ecs_vector_init(
+static
+ecs_entity_t meta_lookup(
     ecs_world_t *world,
-    const ecs_vector_desc_t *desc)
+    meta_type_t *token,
+    const char *ptr,
+    int64_t count,
+    meta_parse_ctx_t *ctx)
 {
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
+    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(token != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(ctx != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    const char *typename = token->type;
+    ecs_entity_t type = 0;
+
+    /* Parse vector type */
+    if (!token->is_ptr) {
+        if (!ecs_os_strcmp(typename, "ecs_array")) {
+            type = meta_lookup_array(world, 0, token->params, ctx);
+
+        } else if (!ecs_os_strcmp(typename, "ecs_vector") || 
+                !ecs_os_strcmp(typename, "flecs::vector")) 
+        {
+            type = meta_lookup_vector(world, 0, token->params, ctx);
+
+        } else if (!ecs_os_strcmp(typename, "flecs::bitmask")) {
+            type = meta_lookup_bitmask(world, 0, token->params, ctx);
+
+        } else if (!ecs_os_strcmp(typename, "flecs::byte")) {
+            type = ecs_id(ecs_byte_t);
+
+        } else if (!ecs_os_strcmp(typename, "char")) {
+            type = ecs_id(ecs_char_t);
+
+        } else if (!ecs_os_strcmp(typename, "bool") || 
+                !ecs_os_strcmp(typename, "_Bool")) 
+        {
+            type = ecs_id(ecs_bool_t);
+
+        } else if (!ecs_os_strcmp(typename, "int8_t")) {
+            type = ecs_id(ecs_i8_t);
+        } else if (!ecs_os_strcmp(typename, "int16_t")) {
+            type = ecs_id(ecs_i16_t);
+        } else if (!ecs_os_strcmp(typename, "int32_t")) {
+            type = ecs_id(ecs_i32_t);
+        } else if (!ecs_os_strcmp(typename, "int64_t")) {
+            type = ecs_id(ecs_i64_t);
+
+        } else if (!ecs_os_strcmp(typename, "uint8_t")) {
+            type = ecs_id(ecs_u8_t);
+        } else if (!ecs_os_strcmp(typename, "uint16_t")) {
+            type = ecs_id(ecs_u16_t);
+        } else if (!ecs_os_strcmp(typename, "uint32_t")) {
+            type = ecs_id(ecs_u32_t);
+        } else if (!ecs_os_strcmp(typename, "uint64_t")) {
+            type = ecs_id(ecs_u64_t);
 
-    ecs_entity_t t = desc->entity;
-    if (!t) {
-        t = ecs_new_low_id(world);
-    }
+        } else if (!ecs_os_strcmp(typename, "float")) {
+            type = ecs_id(ecs_f32_t);
+        } else if (!ecs_os_strcmp(typename, "double")) {
+            type = ecs_id(ecs_f64_t);
 
-    ecs_set(world, t, EcsVector, {
-        .type = desc->type
-    });
+        } else if (!ecs_os_strcmp(typename, "ecs_entity_t")) {
+            type = ecs_id(ecs_entity_t);
 
-    flecs_resume_readonly(world, &rs);
+        } else if (!ecs_os_strcmp(typename, "ecs_id_t")) {
+            type = ecs_id(ecs_id_t);
 
-    return t;
-}
+        } else if (!ecs_os_strcmp(typename, "char*")) {
+            type = ecs_id(ecs_string_t);
+        } else {
+            type = ecs_lookup_symbol(world, typename, true, true);
+        }
+    } else {
+        if (!ecs_os_strcmp(typename, "char")) {
+            typename = "flecs.meta.string";
+        } else
+        if (token->is_ptr) {
+            typename = "flecs.meta.uptr";
+        } else
+        if (!ecs_os_strcmp(typename, "char*") || 
+            !ecs_os_strcmp(typename, "flecs::string")) 
+        {
+            typename = "flecs.meta.string";
+        }
 
-static
-bool flecs_member_range_overlaps(
-    const ecs_member_value_range_t *range,
-    const ecs_member_value_range_t *with)
-{
-    if (ECS_EQ(with->min, with->max)) {
-        return false;
+        type = ecs_lookup_symbol(world, typename, true, true);
     }
 
-    if (ECS_EQ(range->min, range->max)) {
-        return false;
+    if (count != 1) {
+        ecs_check(count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL);
+
+        type = ecs_insert(world, ecs_value(EcsArray, {type, (int32_t)count}));
     }
 
-    if (range->min < with->min || 
-        range->max > with->max) 
-    {
-        return true;
+    if (!type) {
+        ecs_meta_error(ctx, ptr, "unknown type '%s'", typename);
+        goto error;
     }
 
-    return false;
+    return type;
+error:
+    return 0;
 }
 
-ecs_entity_t ecs_struct_init(
+static
+int meta_parse_struct(
     ecs_world_t *world,
-    const ecs_struct_desc_t *desc)
+    ecs_entity_t t,
+    const char *desc)
 {
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
+    const char *ptr = desc;
+    const char *name = ecs_get_name(world, t);
 
-    ecs_entity_t t = desc->entity;
-    if (!t) {
-        t = ecs_new_low_id(world);
-    }
+    meta_member_t token;
+    meta_parse_ctx_t ctx = {
+        .name = name,
+        .desc = ptr
+    };
 
     ecs_entity_t old_scope = ecs_set_scope(world, t);
 
-    int i;
-    for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) {
-        const ecs_member_t *m_desc = &desc->members[i];
-        if (!m_desc->type) {
-            break;
-        }
-
-        if (!m_desc->name) {
-            ecs_err("member %d of struct '%s' does not have a name", i, 
-                ecs_get_name(world, t));
-            goto error;
-        }
-
+    while ((ptr = meta_parse_member(ptr, &token, &ctx)) && ptr[0]) {
         ecs_entity_t m = ecs_entity(world, {
-            .name = m_desc->name
-        });
-
-        ecs_set(world, m, EcsMember, {
-            .type = m_desc->type, 
-            .count = m_desc->count,
-            .offset = m_desc->offset,
-            .unit = m_desc->unit
+            .name = token.name
         });
 
-        EcsMemberRanges *ranges = NULL;
-        const ecs_member_value_range_t *range = &m_desc->range;
-        const ecs_member_value_range_t *error = &m_desc->error_range;
-        const ecs_member_value_range_t *warning = &m_desc->warning_range;
-        if (ECS_NEQ(range->min, range->max)) {
-            ranges = ecs_ensure(world, m, EcsMemberRanges);
-            if (range->min > range->max) {
-                char *member_name = ecs_get_fullpath(world, m);
-                ecs_err("member '%s' has an invalid value range [%f..%f]",
-                    member_name, range->min, range->max);
-                ecs_os_free(member_name);
-                goto error;
-            }
-            ranges->value.min = range->min;
-            ranges->value.max = range->max;
-        }
-        if (ECS_NEQ(error->min, error->max)) {
-            if (error->min > error->max) {
-                char *member_name = ecs_get_fullpath(world, m);
-                ecs_err("member '%s' has an invalid error range [%f..%f]",
-                    member_name, error->min, error->max);
-                ecs_os_free(member_name);
-                goto error;
-            }
-            if (flecs_member_range_overlaps(error, range)) {
-                char *member_name = ecs_get_fullpath(world, m);
-                ecs_err("error range of member '%s' overlaps with value range",
-                    member_name);
-                ecs_os_free(member_name);
-                goto error;
-            }
-            if (!ranges) {
-                ranges = ecs_ensure(world, m, EcsMemberRanges);
-            }
-            ranges->error.min = error->min;
-            ranges->error.max = error->max;
-        }
-
-        if (ECS_NEQ(warning->min, warning->max)) {
-            if (warning->min > warning->max) {
-                char *member_name = ecs_get_fullpath(world, m);
-                ecs_err("member '%s' has an invalid warning range [%f..%f]",
-                    member_name, warning->min, warning->max);
-                ecs_os_free(member_name);
-                goto error;
-            }
-            if (flecs_member_range_overlaps(warning, range)) {
-                char *member_name = ecs_get_fullpath(world, m);
-                ecs_err("warning range of member '%s' overlaps with value "
-                    "range", member_name);
-                ecs_os_free(member_name);
-                goto error;
-            }
-            if (flecs_member_range_overlaps(warning, error)) {
-                char *member_name = ecs_get_fullpath(world, m);
-                ecs_err("warning range of member '%s' overlaps with error "
-                    "range", member_name);
-                ecs_os_free(member_name);
-                goto error;
-            }
-
-            if (!ranges) {
-                ranges = ecs_ensure(world, m, EcsMemberRanges);
-            }
-            ranges->warning.min = warning->min;
-            ranges->warning.max = warning->max;
-        }
-
-        if (ranges && !flecs_type_is_number(world, m_desc->type)) {
-            char *member_name = ecs_get_fullpath(world, m);
-            ecs_err("member '%s' has an value/error/warning range, but is not a "
-                    "number", member_name);
-            ecs_os_free(member_name);
+        ecs_entity_t type = meta_lookup(
+            world, &token.type, ptr, 1, &ctx);
+        if (!type) {
             goto error;
         }
 
-        if (ranges) {
-            ecs_modified(world, m, EcsMemberRanges);
-        }
+        ecs_set(world, m, EcsMember, {
+            .type = type, 
+            .count = (ecs_size_t)token.count
+        });
     }
 
     ecs_set_scope(world, old_scope);
-    flecs_resume_readonly(world, &rs);
-
-    if (i == 0) {
-        ecs_err("struct '%s' has no members", ecs_get_name(world, t));
-        goto error;
-    }
-
-    if (!ecs_has(world, t, EcsStruct)) {
-        goto error;
-    }
 
-    return t;
-error:
-    flecs_resume_readonly(world, &rs);
-    if (t) {
-        ecs_delete(world, t);
-    }
     return 0;
+error:
+    return -1;
 }
 
-ecs_entity_t ecs_opaque_init(
+static
+int meta_parse_constants(
     ecs_world_t *world,
-    const ecs_opaque_desc_t *desc)
+    ecs_entity_t t,
+    const char *desc,
+    bool is_bitmask)
 {
-    ecs_assert(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(desc->type.as_type != 0, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
+    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(t != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(desc != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_entity_t t = desc->entity;
-    if (!t) {
-        t = ecs_new_low_id(world);
-    }
+    const char *ptr = desc;
+    const char *name = ecs_get_name(world, t);
+    int32_t name_len = ecs_os_strlen(name);
+    const ecs_world_info_t *info = ecs_get_world_info(world);
+    const char *name_prefix = info->name_prefix;
+    int32_t name_prefix_len = name_prefix ? ecs_os_strlen(name_prefix) : 0;
 
-    ecs_set_ptr(world, t, EcsOpaque, &desc->type);
+    meta_parse_ctx_t ctx = {
+        .name = name,
+        .desc = ptr
+    };
 
-    flecs_resume_readonly(world, &rs);
+    meta_constant_t token;
+    int64_t last_value = 0;
 
-    return t;
-}
+    ecs_entity_t old_scope = ecs_set_scope(world, t);
 
-ecs_entity_t ecs_unit_init(
-    ecs_world_t *world,
-    const ecs_unit_desc_t *desc)
-{
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
+    while ((ptr = meta_parse_constant(ptr, &token, &ctx))) {
+        if (token.is_value_set) {
+            last_value = token.value;
+        } else if (is_bitmask) {
+            ecs_meta_error(&ctx, ptr,
+                "bitmask requires explicit value assignment");
+            goto error;
+        }
 
-    ecs_entity_t t = desc->entity;
-    if (!t) {
-        t = ecs_new_low_id(world);
-    }
+        if (name_prefix) {
+            if (!ecs_os_strncmp(token.name, name_prefix, name_prefix_len)) {
+                ecs_os_memmove(token.name, token.name + name_prefix_len, 
+                    ecs_os_strlen(token.name) - name_prefix_len + 1);
+            }
+        }
 
-    ecs_entity_t quantity = desc->quantity;
-    if (quantity) {
-        if (!ecs_has_id(world, quantity, EcsQuantity)) {
-            ecs_err("entity '%s' for unit '%s' is not a quantity",
-                ecs_get_name(world, quantity), ecs_get_name(world, t));
-            goto error;
+        if (!ecs_os_strncmp(token.name, name, name_len)) {
+            ecs_os_memmove(token.name, token.name + name_len, 
+                ecs_os_strlen(token.name) - name_len + 1);
         }
 
-        ecs_add_pair(world, t, EcsQuantity, desc->quantity);
-    } else {
-        ecs_remove_pair(world, t, EcsQuantity, EcsWildcard);
-    }
+        ecs_entity_t c = ecs_entity(world, {
+            .name = token.name
+        });
 
-    EcsUnit *value = ecs_ensure(world, t, EcsUnit);
-    value->base = desc->base;
-    value->over = desc->over;
-    value->translation = desc->translation;
-    value->prefix = desc->prefix;
-    ecs_os_strset(&value->symbol, desc->symbol);
+        if (!is_bitmask) {
+            ecs_set_pair_second(world, c, EcsConstant, ecs_i32_t, 
+                {(ecs_i32_t)last_value});
+        } else {
+            ecs_set_pair_second(world, c, EcsConstant, ecs_u32_t, 
+                {(ecs_u32_t)last_value});
+        }
 
-    if (!flecs_unit_validate(world, t, value)) {
-        goto error;
+        last_value ++;
     }
 
-    ecs_modified(world, t, EcsUnit);
+    ecs_set_scope(world, old_scope);
 
-    flecs_resume_readonly(world, &rs);
-    return t;
-error:
-    if (t) {
-        ecs_delete(world, t);
-    }
-    flecs_resume_readonly(world, &rs);
     return 0;
+error:
+    return -1;
 }
 
-ecs_entity_t ecs_unit_prefix_init(
+static
+int meta_parse_enum(
     ecs_world_t *world,
-    const ecs_unit_prefix_desc_t *desc)
+    ecs_entity_t t,
+    const char *desc)
 {
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
-
-    ecs_entity_t t = desc->entity;
-    if (!t) {
-        t = ecs_new_low_id(world);
-    }
-
-    ecs_set(world, t, EcsUnitPrefix, {
-        .symbol = ECS_CONST_CAST(char*, desc->symbol),
-        .translation = desc->translation
-    });
-
-    flecs_resume_readonly(world, &rs);
-
-    return t;
+    ecs_add(world, t, EcsEnum);
+    return meta_parse_constants(world, t, desc, false);
 }
 
-ecs_entity_t ecs_quantity_init(
+static
+int meta_parse_bitmask(
     ecs_world_t *world,
-    const ecs_entity_desc_t *desc)
+    ecs_entity_t t,
+    const char *desc)
 {
-    ecs_suspend_readonly_state_t rs;
-    world = flecs_suspend_readonly(world, &rs);
+    ecs_add(world, t, EcsBitmask);
+    return meta_parse_constants(world, t, desc, true);
+}
 
-    ecs_entity_t t = ecs_entity_init(world, desc);
-    if (!t) {
-        return 0;
+int ecs_meta_from_desc(
+    ecs_world_t *world,
+    ecs_entity_t component,
+    ecs_type_kind_t kind,
+    const char *desc)
+{
+    switch(kind) {
+    case EcsStructType:
+        if (meta_parse_struct(world, component, desc)) {
+            goto error;
+        }
+        break;
+    case EcsEnumType:
+        if (meta_parse_enum(world, component, desc)) {
+            goto error;
+        }
+        break;
+    case EcsBitmaskType:
+        if (meta_parse_bitmask(world, component, desc)) {
+            goto error;
+        }
+        break;
+    case EcsPrimitiveType:
+    case EcsArrayType:
+    case EcsVectorType:
+    case EcsOpaqueType:
+        break;
+    default:
+        ecs_throw(ECS_INTERNAL_ERROR, "invalid type kind");
     }
 
-    ecs_add_id(world, t, EcsQuantity);
-
-    flecs_resume_readonly(world, &rs);
-
-    return t;
+    return 0;
+error:
+    return -1;
 }
 
 #endif
@@ -56922,7 +56739,7 @@ ecs_entity_t ecs_quantity_init(
 #include <ctype.h>
 
 #ifdef FLECS_META
-#ifdef FLECS_PARSER
+#ifdef FLECS_SCRIPT
 #endif
 
 static
@@ -56993,7 +56810,8 @@ static
 ecs_meta_type_op_t* flecs_meta_cursor_get_op(
     ecs_meta_scope_t *scope)
 {
-    ecs_assert(scope->ops != NULL, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(scope->ops != NULL, ECS_INVALID_OPERATION, 
+        "type serializer is missing instructions");
     return &scope->ops[scope->op_cur];
 }
 
@@ -57089,8 +56907,8 @@ int flecs_meta_cursor_push_type(
     ecs_entity_t type,
     void *ptr)
 {
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
     if (ser == NULL) {
         char *str = ecs_id_str(world, type);
         ecs_err("cannot open scope for '%s' (missing reflection data)", str);
@@ -57232,11 +57050,33 @@ int ecs_meta_member(
     return 0;
 }
 
+static
+const char* flecs_meta_parse_member(
+    const char *start,
+    char *token_out)
+{
+    const char *ptr;
+    char ch;
+    for (ptr = start; (ch = *ptr); ptr ++) {
+        if (ch == '.') {
+            break;
+        }
+    }
+
+    int32_t len = flecs_ito(int32_t, ptr - start);
+    ecs_os_memcpy(token_out, start, len);
+    token_out[len] = '\0';
+    if (ch == '.') {
+        ptr ++;
+    }
+
+    return ptr;
+}
+
 int ecs_meta_dotmember(
     ecs_meta_cursor_t *cursor,
     const char *name)
 {
-#ifdef FLECS_PARSER
     ecs_meta_scope_t *cur_scope = flecs_meta_cursor_get_scope(cursor);
     flecs_meta_cursor_restore_scope(cursor, cur_scope);
 
@@ -57245,13 +57085,7 @@ int ecs_meta_dotmember(
 
     char token[ECS_MAX_TOKEN_SIZE];
     const char *ptr = name;
-    while ((ptr = ecs_parse_token(NULL, NULL, ptr, token, '.'))) {
-        if (ptr[0] != '.' && ptr[0]) {
-            ecs_parser_error(NULL, name, ptr - name, 
-                "expected '.' or end of string");
-            goto error;
-        }
-
+    while ((ptr = flecs_meta_parse_member(ptr, token))) {
         if (dotcount) {
             ecs_meta_push(cursor);
         }
@@ -57264,8 +57098,6 @@ int ecs_meta_dotmember(
             break;   
         }
 
-        ptr ++; /* Skip . */
-
         dotcount ++;
     }
 
@@ -57277,12 +57109,6 @@ int ecs_meta_dotmember(
     return 0;
 error:
     return -1;
-#else
-    (void)cursor;
-    (void)name;
-    ecs_err("the FLECS_PARSER addon is required for ecs_meta_dotmember");
-    return -1;
-#endif
 }
 
 int ecs_meta_push(
@@ -57398,7 +57224,7 @@ int ecs_meta_push(
     case EcsOpOpaque: {
         const EcsOpaque *type_ptr = ecs_get(world, op->type, EcsOpaque);
         ecs_entity_t as_type = type_ptr->as_type;
-        const EcsMetaType *mtype_ptr = ecs_get(world, as_type, EcsMetaType);
+        const EcsType *mtype_ptr = ecs_get(world, as_type, EcsType);
 
         /* Check what kind of type the opaque type represents */
         switch(mtype_ptr->kind) {
@@ -57545,8 +57371,8 @@ int ecs_meta_pop(
         } else if (op->kind == EcsOpOpaque) {
             const EcsOpaque *opaque = scope->opaque;
             if (scope->is_collection) {
-                const EcsMetaType *mtype = ecs_get(cursor->world, 
-                    opaque->as_type, EcsMetaType);
+                const EcsType *mtype = ecs_get(cursor->world, 
+                    opaque->as_type, EcsType);
                 ecs_assert(mtype != NULL, ECS_INTERNAL_ERROR, NULL);
 
                 /* When popping a opaque collection type, call resize to make 
@@ -57831,7 +57657,9 @@ int ecs_meta_set_char(
     cases_T_signed(ptr, value, ecs_meta_bounds_signed);
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_char) { /* preferred operation */
             opaque->assign_char(ptr, value);
             break;
@@ -57888,7 +57716,9 @@ int ecs_meta_set_int(
     cases_T_float(ptr, value);
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_int) { /* preferred operation */
             opaque->assign_int(ptr, value);
             break;
@@ -57939,7 +57769,9 @@ int ecs_meta_set_uint(
     cases_T_float(ptr, value);
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_uint) { /* preferred operation */
             opaque->assign_uint(ptr, value);
             break;
@@ -57995,7 +57827,9 @@ int ecs_meta_set_float(
     cases_T_float(ptr, value);
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_float) { /* preferred operation */
             opaque->assign_float(ptr, value);
             break;
@@ -58040,7 +57874,7 @@ int ecs_meta_set_value(
     ecs_check(value != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_entity_t type = value->type;
     ecs_check(type != 0, ECS_INVALID_PARAMETER, NULL);
-    const EcsMetaType *mt = ecs_get(cursor->world, type, EcsMetaType);
+    const EcsType *mt = ecs_get(cursor->world, type, EcsType);
     if (!mt) {
         ecs_err("type of value does not have reflection data");
         return -1;
@@ -58114,7 +57948,7 @@ int flecs_meta_add_bitmask_constant(
         return -1;
     }
 
-    const ecs_u32_t *v = ecs_get_pair_object(
+    const ecs_u32_t *v = ecs_get_pair_second(
         cursor->world, c, EcsConstant, ecs_u32_t);
     if (v == NULL) {
         char *path = ecs_get_fullpath(cursor->world, op->type);
@@ -58181,6 +58015,13 @@ int flecs_meta_cursor_lookup(
     return 0;
 }
 
+static
+bool flecs_meta_valid_digit(
+    const char *str)
+{
+    return str[0] == '-' || isdigit(str[0]);
+}
+
 int ecs_meta_set_string(
     ecs_meta_cursor_t *cursor,
     const char *value)
@@ -58189,6 +58030,41 @@ int ecs_meta_set_string(
     ecs_meta_type_op_t *op = flecs_meta_cursor_get_op(scope);
     void *ptr = flecs_meta_cursor_get_ptr(cursor->world, scope);
 
+    switch(op->kind) {
+    case EcsOpI8:
+    case EcsOpU8:
+    case EcsOpByte:
+    case EcsOpI16:
+    case EcsOpU16:
+    case EcsOpI32:
+    case EcsOpU32:
+    case EcsOpI64:
+    case EcsOpU64:
+    case EcsOpIPtr:
+    case EcsOpUPtr:
+    case EcsOpF32:
+    case EcsOpF64:
+        if (!flecs_meta_valid_digit(value)) {
+            ecs_err("expected number, got '%s'", value);
+            goto error;
+        }
+    case EcsOpEnum:
+    case EcsOpBitmask:
+    case EcsOpArray:
+    case EcsOpVector:
+    case EcsOpOpaque:
+    case EcsOpPush:
+    case EcsOpPop:
+    case EcsOpPrimitive:
+    case EcsOpBool:
+    case EcsOpChar:
+    case EcsOpString:
+    case EcsOpEntity:
+    case EcsOpId:
+    case EcsOpScope:
+        break;
+    }
+
     switch(op->kind) {
     case EcsOpBool:
         if (!ecs_os_strcmp(value, "true")) {
@@ -58253,7 +58129,7 @@ int ecs_meta_set_string(
             goto error;
         }
 
-        const ecs_i32_t *v = ecs_get_pair_object(
+        const ecs_i32_t *v = ecs_get_pair_second(
             cursor->world, c, EcsConstant, ecs_i32_t);
         if (v == NULL) {
             char *path = ecs_get_fullpath(cursor->world, op->type);
@@ -58279,25 +58155,16 @@ int ecs_meta_set_string(
         break;
     }
     case EcsOpId: {
+    #ifdef FLECS_SCRIPT
         ecs_id_t id = 0;
-#ifdef FLECS_PARSER
-        ecs_term_t term = {0};
-        if (ecs_parse_term(
-            cursor->world, NULL, value, value, &term, NULL, NULL, false)) 
-        {
-            if (ecs_term_finalize(cursor->world, &term)) {
-                ecs_term_fini(&term);
-                goto error;
-            }
-            id = term.id;
-            ecs_term_fini(&term);
-        } else {
-            ecs_term_fini(&term);
+        if (flecs_id_parse(cursor->world, NULL, value, &id) == NULL) {
             goto error;
         }
-#endif
-        set_T(ecs_id_t, ptr, id);
 
+        set_T(ecs_id_t, ptr, id);
+    #else
+        ecs_err("cannot parse component expression: script addon required");
+    #endif
         break;
     }
     case EcsOpPop:
@@ -58305,7 +58172,9 @@ int ecs_meta_set_string(
         goto error;
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_string) { /* preferred */
             opaque->assign_string(ptr, value);
             break;
@@ -59001,8 +58870,18 @@ void flecs_meta_import_core_definitions(
         }
     });
 
+    ecs_struct(world, {
+        .entity = ecs_id(EcsDefaultChildComponent),
+        .members = {
+            { .name = "component", .type = ecs_id(ecs_entity_t) }
+        }
+    });
+
     ecs_entity_t string_vec = ecs_vector(world, {
-        .entity = ecs_entity(world, { .name = "flecs.core.string_vec_t "}),
+        .entity = ecs_entity(world, { 
+            .name = "flecs.core.string_vec_t",
+            .root_sep = ""
+        }),
         .type = ecs_id(ecs_string_t)
     });
 
@@ -59075,7 +58954,7 @@ void flecs_meta_import_meta_definitions(
     });
 
     ecs_struct_init(world, &(ecs_struct_desc_t){
-        .entity = ecs_id(EcsMetaType),
+        .entity = ecs_id(EcsType),
         .members = {
             { .name = "kind", .type = type_kind }
         }
@@ -59193,8 +59072,8 @@ void flecs_meta_import_meta_definitions(
     ecs_entity_t meta = ecs_lookup(world, "flecs.meta");
     ecs_doc_set_brief(world, meta, "Flecs module with reflection components");
 
-    ecs_doc_set_brief(world, ecs_id(EcsMetaType), "Component added to types");
-    ecs_doc_set_brief(world, ecs_id(EcsMetaTypeSerialized), "Component that stores reflection data in an optimized format");
+    ecs_doc_set_brief(world, ecs_id(EcsType), "Component added to types");
+    ecs_doc_set_brief(world, ecs_id(EcsTypeSerializer), "Component that stores reflection data in an optimized format");
     ecs_doc_set_brief(world, ecs_id(EcsPrimitive), "Component added to primitive types");
     ecs_doc_set_brief(world, ecs_id(EcsEnum), "Component added to enumeration types");
     ecs_doc_set_brief(world, ecs_id(EcsBitmask), "Component added to bitmask types");
@@ -59260,10 +59139,10 @@ static ECS_DTOR(ecs_string_t, ptr, {
 })
 
 
-/* EcsMetaTypeSerialized lifecycle */
+/* EcsTypeSerializer lifecycle */
 
 void ecs_meta_dtor_serialized(
-    EcsMetaTypeSerialized *ptr) 
+    EcsTypeSerializer *ptr) 
 {
     int32_t i, count = ecs_vec_count(&ptr->ops);
     ecs_meta_type_op_t *ops = ecs_vec_first(&ptr->ops);
@@ -59278,7 +59157,7 @@ void ecs_meta_dtor_serialized(
     ecs_vec_fini_t(NULL, &ptr->ops, ecs_meta_type_op_t);
 }
 
-static ECS_COPY(EcsMetaTypeSerialized, dst, src, {
+static ECS_COPY(EcsTypeSerializer, dst, src, {
     ecs_meta_dtor_serialized(dst);
 
     dst->ops = ecs_vec_copy_t(NULL, &src->ops, ecs_meta_type_op_t);
@@ -59294,13 +59173,13 @@ static ECS_COPY(EcsMetaTypeSerialized, dst, src, {
     }
 })
 
-static ECS_MOVE(EcsMetaTypeSerialized, dst, src, {
+static ECS_MOVE(EcsTypeSerializer, dst, src, {
     ecs_meta_dtor_serialized(dst);
     dst->ops = src->ops;
     src->ops = (ecs_vec_t){0};
 })
 
-static ECS_DTOR(EcsMetaTypeSerialized, ptr, { 
+static ECS_DTOR(EcsTypeSerializer, ptr, { 
     ecs_meta_dtor_serialized(ptr);
 })
 
@@ -59491,7 +59370,7 @@ int flecs_init_type(
     ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(type != 0, ECS_INTERNAL_ERROR, NULL);
 
-    EcsMetaType *meta_type = ecs_ensure(world, type, EcsMetaType);
+    EcsType *meta_type = ecs_ensure(world, type, EcsType);
     if (meta_type->kind == 0) {
         meta_type->existing = ecs_has(world, type, EcsComponent);
 
@@ -59499,7 +59378,7 @@ int flecs_init_type(
          * serializers on uninitialized values. */
         ecs_type_info_t *ti = flecs_type_info_ensure(world, type);
         if (!ti->hooks.ctor) {
-            ti->hooks.ctor = ecs_default_ctor;
+            ti->hooks.ctor = flecs_default_ctor;
         }
     } else {
         if (meta_type->kind != kind) {
@@ -59540,7 +59419,7 @@ int flecs_init_type(
     }
 
     meta_type->kind = kind;
-    ecs_modified(world, type, EcsMetaType);
+    ecs_modified(world, type, EcsType);
 
     return 0;
 }
@@ -59778,7 +59657,7 @@ int flecs_add_member_to_struct(
 
     ecs_modified(world, type, EcsStruct);
 
-    /* Do this last as it triggers the update of EcsMetaTypeSerialized */
+    /* Do this last as it triggers the update of EcsTypeSerializer */
     if (flecs_init_type(world, type, EcsStructType, size, alignment)) {
         return -1;
     }
@@ -59827,7 +59706,7 @@ int flecs_add_constant_to_enum(
             return -1;
         }
 
-        const int32_t *value_ptr = ecs_get_pair_object(
+        const int32_t *value_ptr = ecs_get_pair_second(
             world, e, EcsConstant, ecs_i32_t);
         ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL);
         value = *value_ptr;
@@ -59860,7 +59739,7 @@ int flecs_add_constant_to_enum(
     c->value = value;
     c->constant = e;
 
-    ecs_i32_t *cptr = ecs_ensure_pair_object(
+    ecs_i32_t *cptr = ecs_ensure_pair_second(
         world, e, EcsConstant, ecs_i32_t);
     ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL);
     cptr[0] = value;
@@ -59900,7 +59779,7 @@ int flecs_add_constant_to_bitmask(
             return -1;
         }
 
-        const uint32_t *value_ptr = ecs_get_pair_object(
+        const uint32_t *value_ptr = ecs_get_pair_second(
             world, e, EcsConstant, ecs_u32_t);
         ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL);
         value = *value_ptr;
@@ -59929,7 +59808,7 @@ int flecs_add_constant_to_bitmask(
     c->value = value;
     c->constant = e;
 
-    ecs_u32_t *cptr = ecs_ensure_pair_object(
+    ecs_u32_t *cptr = ecs_ensure_pair_second(
         world, e, EcsConstant, ecs_u32_t);
     ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL);
     cptr[0] = value;
@@ -59943,7 +59822,7 @@ int flecs_add_constant_to_bitmask(
 static
 void flecs_set_primitive(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsPrimitive *type = ecs_field(it, EcsPrimitive, 1);
+    EcsPrimitive *type = ecs_field(it, EcsPrimitive, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -60010,7 +59889,7 @@ void flecs_set_primitive(ecs_iter_t *it) {
 static
 void flecs_set_member(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsMember *member = ecs_field(it, EcsMember, 1);
+    EcsMember *member = ecs_field(it, EcsMember, 0);
     EcsMemberRanges *ranges = ecs_table_get_id(world, it->table, 
         ecs_id(EcsMemberRanges), it->offset);
 
@@ -60031,7 +59910,7 @@ void flecs_set_member(ecs_iter_t *it) {
 static
 void flecs_set_member_ranges(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsMemberRanges *ranges = ecs_field(it, EcsMemberRanges, 1);
+    EcsMemberRanges *ranges = ecs_field(it, EcsMemberRanges, 0);
     EcsMember *member = ecs_table_get_id(world, it->table, 
         ecs_id(EcsMember), it->offset);
     if (!member) {
@@ -60066,7 +59945,7 @@ void flecs_add_enum(ecs_iter_t *it) {
 
         ecs_add_id(world, e, EcsExclusive);
         ecs_add_id(world, e, EcsOneOf);
-        ecs_add_id(world, e, EcsTag);
+        ecs_add_id(world, e, EcsPairIsTag);
     }
 }
 
@@ -60108,7 +59987,7 @@ void flecs_add_constant(ecs_iter_t *it) {
 static
 void flecs_set_array(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsArray *array = ecs_field(it, EcsArray, 1);
+    EcsArray *array = ecs_field(it, EcsArray, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -60138,7 +60017,7 @@ void flecs_set_array(ecs_iter_t *it) {
 static
 void flecs_set_vector(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsVector *array = ecs_field(it, EcsVector, 1);
+    EcsVector *array = ecs_field(it, EcsVector, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -60159,7 +60038,7 @@ void flecs_set_vector(ecs_iter_t *it) {
 static
 void flecs_set_custom_type(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsOpaque *serialize = ecs_field(it, EcsOpaque, 1);
+    EcsOpaque *serialize = ecs_field(it, EcsOpaque, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -60308,7 +60187,7 @@ bool flecs_unit_validate(
 
 static
 void flecs_set_unit(ecs_iter_t *it) {
-    EcsUnit *u = ecs_field(it, EcsUnit, 1);
+    EcsUnit *u = ecs_field(it, EcsUnit, 0);
 
     ecs_world_t *world = it->world;
 
@@ -60340,7 +60219,7 @@ void flecs_unit_quantity_monitor(ecs_iter_t *it) {
 static
 void ecs_meta_type_init_default_ctor(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsMetaType *type = ecs_field(it, EcsMetaType, 1);
+    EcsType *type = ecs_field(it, EcsType, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -60354,7 +60233,7 @@ void ecs_meta_type_init_default_ctor(ecs_iter_t *it) {
             if (!ti || !ti->hooks.ctor) {
                 ecs_set_hooks_id(world, e, 
                     &(ecs_type_hooks_t){ 
-                        .ctor = ecs_default_ctor
+                        .ctor = flecs_default_ctor
                     });
             }
         }
@@ -60379,71 +60258,164 @@ void FlecsMetaImport(
 
     ecs_set_name_prefix(world, "Ecs");
 
-    flecs_bootstrap_component(world, EcsMetaType);
-    flecs_bootstrap_component(world, EcsMetaTypeSerialized);
-    flecs_bootstrap_component(world, EcsPrimitive);
-    flecs_bootstrap_component(world, EcsEnum);
-    flecs_bootstrap_component(world, EcsBitmask);
-    flecs_bootstrap_component(world, EcsMember);
-    flecs_bootstrap_component(world, EcsMemberRanges);
-    flecs_bootstrap_component(world, EcsStruct);
-    flecs_bootstrap_component(world, EcsArray);
-    flecs_bootstrap_component(world, EcsVector);
-    flecs_bootstrap_component(world, EcsOpaque);
-    flecs_bootstrap_component(world, EcsUnit);
-    flecs_bootstrap_component(world, EcsUnitPrefix);
-
-    flecs_bootstrap_tag(world, EcsConstant);
-    flecs_bootstrap_tag(world, EcsQuantity);
-
-    ecs_set_hooks(world, EcsMetaType, { .ctor = ecs_default_ctor });
-
-    ecs_set_hooks(world, EcsMetaTypeSerialized, { 
-        .ctor = ecs_default_ctor,
-        .move = ecs_move(EcsMetaTypeSerialized),
-        .copy = ecs_copy(EcsMetaTypeSerialized),
-        .dtor = ecs_dtor(EcsMetaTypeSerialized)
+    flecs_bootstrap_component(world, EcsTypeSerializer);
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsType),
+            .name = "type", .symbol = "EcsType"
+        }),
+        .type.size = sizeof(EcsType),
+        .type.alignment = ECS_ALIGNOF(EcsType)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsPrimitive),
+            .name = "primitive", .symbol = "EcsPrimitive"
+        }),
+        .type.size = sizeof(EcsPrimitive),
+        .type.alignment = ECS_ALIGNOF(EcsPrimitive)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = EcsConstant,
+            .name = "constant", .symbol = "EcsConstant"
+        })
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsEnum),
+            .name = "enum", .symbol = "EcsEnum"
+        }),
+        .type.size = sizeof(EcsEnum),
+        .type.alignment = ECS_ALIGNOF(EcsEnum)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsBitmask),
+            .name = "bitmask", .symbol = "EcsBitmask"
+        }),
+        .type.size = sizeof(EcsBitmask),
+        .type.alignment = ECS_ALIGNOF(EcsBitmask)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsMember),
+            .name = "member", .symbol = "EcsMember"
+        }),
+        .type.size = sizeof(EcsMember),
+        .type.alignment = ECS_ALIGNOF(EcsMember)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsMemberRanges),
+            .name = "member_ranges", .symbol = "EcsMemberRanges"
+        }),
+        .type.size = sizeof(EcsMemberRanges),
+        .type.alignment = ECS_ALIGNOF(EcsMemberRanges)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsStruct),
+            .name = "struct", .symbol = "EcsStruct"
+        }),
+        .type.size = sizeof(EcsStruct),
+        .type.alignment = ECS_ALIGNOF(EcsStruct)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsArray),
+            .name = "array", .symbol = "EcsArray"
+        }),
+        .type.size = sizeof(EcsArray),
+        .type.alignment = ECS_ALIGNOF(EcsArray)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsVector),
+            .name = "vector", .symbol = "EcsVector"
+        }),
+        .type.size = sizeof(EcsVector),
+        .type.alignment = ECS_ALIGNOF(EcsVector)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsOpaque),
+            .name = "opaque", .symbol = "EcsOpaque"
+        }),
+        .type.size = sizeof(EcsOpaque),
+        .type.alignment = ECS_ALIGNOF(EcsOpaque)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsUnit),
+            .name = "unit", .symbol = "EcsUnit"
+        }),
+        .type.size = sizeof(EcsUnit),
+        .type.alignment = ECS_ALIGNOF(EcsUnit)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsUnitPrefix),
+            .name = "unit_prefix", .symbol = "EcsUnitPrefix"
+        }),
+        .type.size = sizeof(EcsUnitPrefix),
+        .type.alignment = ECS_ALIGNOF(EcsUnitPrefix)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = EcsQuantity,
+            .name = "quantity", .symbol = "EcsQuantity"
+        })
+    });
+
+    ecs_set_hooks(world, EcsType, { .ctor = flecs_default_ctor });
+
+    ecs_set_hooks(world, EcsTypeSerializer, { 
+        .ctor = flecs_default_ctor,
+        .move = ecs_move(EcsTypeSerializer),
+        .copy = ecs_copy(EcsTypeSerializer),
+        .dtor = ecs_dtor(EcsTypeSerializer)
     });
 
     ecs_set_hooks(world, EcsStruct, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsStruct),
         .copy = ecs_copy(EcsStruct),
         .dtor = ecs_dtor(EcsStruct)
     });
 
     ecs_set_hooks(world, EcsMember, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .on_set = flecs_member_on_set
     });
 
     ecs_set_hooks(world, EcsMemberRanges, { 
-        .ctor = ecs_default_ctor
+        .ctor = flecs_default_ctor
     });
 
     ecs_set_hooks(world, EcsEnum, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsEnum),
         .copy = ecs_copy(EcsEnum),
         .dtor = ecs_dtor(EcsEnum)
     });
 
     ecs_set_hooks(world, EcsBitmask, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsBitmask),
         .copy = ecs_copy(EcsBitmask),
         .dtor = ecs_dtor(EcsBitmask)
     });
 
     ecs_set_hooks(world, EcsUnit, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsUnit),
         .copy = ecs_copy(EcsUnit),
         .dtor = ecs_dtor(EcsUnit)
     });
 
     ecs_set_hooks(world, EcsUnitPrefix, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsUnitPrefix),
         .copy = ecs_copy(EcsUnitPrefix),
         .dtor = ecs_dtor(EcsUnitPrefix)
@@ -60453,85 +60425,85 @@ void FlecsMetaImport(
     ecs_entity_t old_scope = ecs_set_scope( /* Keep meta scope clean */
         world, EcsFlecsInternals);
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsPrimitive), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsPrimitive), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_primitive
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsMember), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsMember), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_member
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsMemberRanges), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsMemberRanges), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_member_ranges
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsEnum), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsEnum), .src.id = EcsSelf },
         .events = {EcsOnAdd},
         .callback = flecs_add_enum
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsBitmask), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsBitmask), .src.id = EcsSelf },
         .events = {EcsOnAdd},
         .callback = flecs_add_bitmask
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = EcsConstant, .src.flags = EcsSelf },
+        .query.terms[0] = { .id = EcsConstant, .src.id = EcsSelf },
         .events = {EcsOnAdd},
         .callback = flecs_add_constant
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_pair(EcsConstant, EcsWildcard), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_pair(EcsConstant, EcsWildcard), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_add_constant
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsArray), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsArray), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_array
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsVector), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsVector), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_vector
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsOpaque), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsOpaque), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_custom_type
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsUnit), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsUnit), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_unit
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsMetaType), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsType), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = ecs_meta_type_serialized_init
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsMetaType), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsType), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = ecs_meta_type_init_default_ctor
     });
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(EcsUnit) },
             { .id = EcsQuantity }
         },
@@ -60572,28 +60544,21 @@ void FlecsMetaImport(
     #undef ECS_PRIMITIVE
 
     ecs_set_hooks(world, ecs_string_t, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .copy = ecs_copy(ecs_string_t),
         .move = ecs_move(ecs_string_t),
         .dtor = ecs_dtor(ecs_string_t)
     });
 
     /* Set default child components */
-    ecs_add_pair(world, ecs_id(EcsStruct), 
-        EcsDefaultChildComponent, ecs_id(EcsMember));
-
-    ecs_add_pair(world, ecs_id(EcsMember), 
-        EcsDefaultChildComponent, ecs_id(EcsMember));
-
-    ecs_add_pair(world, ecs_id(EcsEnum), 
-        EcsDefaultChildComponent, EcsConstant);
-
-    ecs_add_pair(world, ecs_id(EcsBitmask), 
-        EcsDefaultChildComponent, EcsConstant);
+    ecs_set(world, ecs_id(EcsStruct),  EcsDefaultChildComponent, {ecs_id(EcsMember)});
+    ecs_set(world, ecs_id(EcsMember),  EcsDefaultChildComponent, {ecs_id(EcsMember)});
+    ecs_set(world, ecs_id(EcsEnum),    EcsDefaultChildComponent, {EcsConstant});
+    ecs_set(world, ecs_id(EcsBitmask), EcsDefaultChildComponent, {EcsConstant});
 
     /* Relationship properties */
     ecs_add_id(world, EcsQuantity, EcsExclusive);
-    ecs_add_id(world, EcsQuantity, EcsTag);
+    ecs_add_id(world, EcsQuantity, EcsPairIsTag);
 
     /* Import reflection definitions for builtin types */
     flecs_meta_import_definitions(world);
@@ -60833,10 +60798,10 @@ int flecs_meta_serialize_type(
     ecs_size_t offset,
     ecs_vec_t *ops)
 {
-    const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType);
+    const EcsType *ptr = ecs_get(world, type, EcsType);
     if (!ptr) {
         char *path = ecs_get_fullpath(world, type);
-        ecs_err("missing EcsMetaType for type %s'", path);
+        ecs_err("missing EcsType for type %s'", path);
         ecs_os_free(path);
         return -1;
     }
@@ -60860,10 +60825,10 @@ int flecs_meta_serialize_component(
     ecs_entity_t type,
     ecs_vec_t *ops)
 {
-    const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType);
+    const EcsType *ptr = ecs_get(world, type, EcsType);
     if (!ptr) {
         char *path = ecs_get_fullpath(world, type);
-        ecs_err("missing EcsMetaType for type %s'", path);
+        ecs_err("missing EcsType for type %s'", path);
         ecs_os_free(path);
         return -1;
     }
@@ -60887,8 +60852,8 @@ void ecs_meta_type_serialized_init(
         ecs_vec_init_t(NULL, &ops, ecs_meta_type_op_t, 0);
         flecs_meta_serialize_component(world, e, &ops);
 
-        EcsMetaTypeSerialized *ptr = ecs_ensure(
-            world, e, EcsMetaTypeSerialized);
+        EcsTypeSerializer *ptr = ecs_ensure(
+            world, e, EcsTypeSerializer);
         if (ptr->ops.array) {
             ecs_meta_dtor_serialized(ptr);
         }
@@ -61545,7 +61510,7 @@ static void flecs_pipeline_free(
     ecs_pipeline_state_t *p) 
 {
     if (p) {
-        ecs_world_t *world = p->query->filter.world;
+        ecs_world_t *world = p->query->world;
         ecs_allocator_t *a = &world->allocator;
         ecs_vec_fini_t(a, &p->ops, ecs_pipeline_op_t);
         ecs_vec_fini_t(a, &p->systems, ecs_entity_t);
@@ -61662,17 +61627,17 @@ bool flecs_pipeline_check_term(
 {
     (void)world;
 
-    ecs_term_id_t *src = &term->src;
-    if (src->flags & EcsInOutNone) {
+    ecs_term_ref_t *src = &term->src;
+    if (term->inout == EcsInOutNone || term->inout == EcsInOutFilter) {
         return false;
     }
 
     ecs_id_t id = term->id;
-    ecs_oper_kind_t oper = term->oper;
-    ecs_inout_kind_t inout = term->inout;
+    int16_t oper = term->oper;
+    int16_t inout = term->inout;
     bool from_any = ecs_term_match_0(term);
     bool from_this = ecs_term_match_this(term);
-    bool is_shared = !from_any && (!from_this || !(src->flags & EcsSelf));
+    bool is_shared = !from_any && (!from_this || !(src->id & EcsSelf));
 
     ecs_write_kind_t ws = flecs_pipeline_get_write_state(write_state, id);
 
@@ -61715,6 +61680,7 @@ bool flecs_pipeline_check_term(
             break;
         case EcsInOutDefault:
         case EcsInOutNone:
+        case EcsInOutFilter:
         case EcsIn:
             break;
         }
@@ -61730,6 +61696,7 @@ bool flecs_pipeline_check_term(
             /* fall through */
         case EcsInOutDefault:
         case EcsInOutNone:
+        case EcsInOutFilter:
         case EcsOut:
             break;
         }
@@ -61741,13 +61708,13 @@ bool flecs_pipeline_check_term(
 static
 bool flecs_pipeline_check_terms(
     ecs_world_t *world,
-    ecs_filter_t *filter,
+    ecs_query_t *query,
     bool is_active,
     ecs_write_state_t *ws)
 {
     bool needs_merge = false;
-    ecs_term_t *terms = filter->terms;
-    int32_t t, term_count = filter->term_count;
+    ecs_term_t *terms = query->terms;
+    int32_t t, term_count = query->term_count;
 
     /* Check This terms first. This way if a term indicating writing to a stage
      * was added before the term, it won't cause merging. */
@@ -61774,7 +61741,7 @@ EcsPoly* flecs_pipeline_term_system(
     ecs_iter_t *it)
 {
     int32_t index = ecs_table_get_column_index(
-        it->real_world, it->table, ecs_poly_id(EcsSystem));
+        it->real_world, it->table, flecs_poly_id(EcsSystem));
     ecs_assert(index != -1, ECS_INTERNAL_ERROR, NULL);
     EcsPoly *poly = ecs_table_get_column(it->table, index, it->offset);
     ecs_assert(poly != NULL, ECS_INTERNAL_ERROR, NULL);
@@ -61788,7 +61755,8 @@ bool flecs_pipeline_build(
 {
     ecs_iter_t it = ecs_query_iter(world, pq->query);
 
-    if (pq->match_count == pq->query->match_count) {
+    int32_t new_match_count = ecs_query_match_count(pq->query);
+    if (pq->match_count == new_match_count) {
         /* No need to rebuild the pipeline */
         ecs_iter_fini(&it);
         return false;
@@ -61807,7 +61775,7 @@ bool flecs_pipeline_build(
     ecs_vec_reset_t(a, &pq->systems, ecs_entity_t);
 
     bool multi_threaded = false;
-    bool no_readonly = false;
+    bool immediate = false;
     bool first = true;
 
     /* Iterate systems in pipeline, add ops for running / merging */
@@ -61818,18 +61786,18 @@ bool flecs_pipeline_build(
 
         int32_t i;
         for (i = 0; i < it.count; i ++) {
-            ecs_poly_assert(poly[i].poly, ecs_system_t);
+            flecs_poly_assert(poly[i].poly, ecs_system_t);
             ecs_system_t *sys = (ecs_system_t*)poly[i].poly;
             ecs_query_t *q = sys->query;
 
             bool needs_merge = false;
             needs_merge = flecs_pipeline_check_terms(
-                world, &q->filter, is_active, &ws);
+                world, q, is_active, &ws);
 
             if (is_active) {
                 if (first) {
                     multi_threaded = sys->multi_threaded;
-                    no_readonly = sys->no_readonly;
+                    immediate = sys->immediate;
                     first = false;
                 }
 
@@ -61837,13 +61805,13 @@ bool flecs_pipeline_build(
                     needs_merge = true;
                     multi_threaded = sys->multi_threaded;
                 }
-                if (sys->no_readonly != no_readonly) {
+                if (sys->immediate != immediate) {
                     needs_merge = true;
-                    no_readonly = sys->no_readonly;
+                    immediate = sys->immediate;
                 }
             }
 
-            if (no_readonly) {
+            if (immediate) {
                 needs_merge = true;
             }
 
@@ -61866,7 +61834,7 @@ bool flecs_pipeline_build(
                 needs_merge = false;
                 if (is_active) {
                     needs_merge = flecs_pipeline_check_terms(
-                        world, &q->filter, true, &ws);
+                        world, q, true, &ws);
                 }
 
                 /* The component states were just reset, so if we conclude that
@@ -61879,7 +61847,7 @@ bool flecs_pipeline_build(
                 op->offset = ecs_vec_count(&pq->systems);
                 op->count = 0;
                 op->multi_threaded = false;
-                op->no_readonly = false;
+                op->immediate = false;
                 op->time_spent = 0;
                 op->commands_enqueued = 0;
             }
@@ -61891,7 +61859,7 @@ bool flecs_pipeline_build(
                     it.entities[i];
                 if (!op->count) {
                     op->multi_threaded = multi_threaded;
-                    op->no_readonly = no_readonly;
+                    op->immediate = immediate;
                 }
                 op->count ++;
             }
@@ -61916,7 +61884,7 @@ bool flecs_pipeline_build(
         ecs_log_push_1();
 
         ecs_dbg("#[green]schedule#[reset]: threading: %d, staging: %d:", 
-            op->multi_threaded, !op->no_readonly);
+            op->multi_threaded, !op->immediate);
         ecs_log_push_1();
 
         int32_t i, count = ecs_vec_count(&pq->systems);
@@ -61925,7 +61893,7 @@ bool flecs_pipeline_build(
         for (i = 0; i < count; i ++) {
             ecs_entity_t system = systems[i];
             const EcsPoly *poly = ecs_get_pair(world, system, EcsPoly, EcsSystem);
-            ecs_poly_assert(poly->poly, ecs_system_t);
+            flecs_poly_assert(poly->poly, ecs_system_t);
             ecs_system_t *sys = (ecs_system_t*)poly->poly;
 
 #ifdef FLECS_LOG_1
@@ -61960,7 +61928,7 @@ bool flecs_pipeline_build(
                         "#[green]schedule#[reset]: "
                         "threading: %d, staging: %d:",
                         op[op_index].multi_threaded, 
-                        !op[op_index].no_readonly);
+                        !op[op_index].immediate);
                 }
                 ecs_log_push_1();
             }
@@ -61980,7 +61948,7 @@ bool flecs_pipeline_build(
         ecs_log_pop_1();
     }
 
-    pq->match_count = pq->query->match_count;
+    pq->match_count = new_match_count;
 
     ecs_assert(pq->cur_op <= ecs_vec_last_t(&pq->ops, ecs_pipeline_op_t),
         ECS_INTERNAL_ERROR, NULL);
@@ -62010,8 +61978,9 @@ bool flecs_pipeline_update(
     ecs_pipeline_state_t *pq,
     bool start_of_frame)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, 
+        "cannot update pipeline while world is in readonly mode");
 
     /* If any entity mutations happened that could have affected query matching
      * notify appropriate queries so caches are up to date. This includes the
@@ -62084,7 +62053,7 @@ int32_t flecs_run_pipeline_ops(
     for (; i < count; i++) {
         ecs_entity_t system = systems[i];
         const EcsPoly* poly = ecs_get_pair(world, system, EcsPoly, EcsSystem);
-        ecs_poly_assert(poly->poly, ecs_system_t);
+        flecs_poly_assert(poly->poly, ecs_system_t);
         ecs_system_t* sys = (ecs_system_t*)poly->poly;
 
         /* Keep track of the last frame for which the system has ran, so we
@@ -62093,14 +62062,14 @@ int32_t flecs_run_pipeline_ops(
         sys->last_frame = world->info.frame_count_total + 1;
 
         ecs_stage_t* s = NULL;
-        if (!op->no_readonly) {
-            /* If system is no_readonly it operates on the actual world, not
+        if (!op->immediate) {
+            /* If system is immediate it operates on the actual world, not
              * the stage. Only pass stage to system if it's readonly. */
             s = stage;
         }
 
-        ecs_run_intern(world, s, system, sys, stage_index,
-            stage_count, delta_time, 0, 0, NULL);
+        flecs_run_intern(world, s, system, sys, stage_index,
+            stage_count, delta_time, NULL);
 
         world->info.systems_ran_frame++;
         ran_since_merge++;
@@ -62119,17 +62088,18 @@ void flecs_run_pipeline(
     ecs_pipeline_state_t *pq,
     ecs_ftime_t delta_time)
 {
-    ecs_assert(world != NULL, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(pq->query != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_poly_assert(world, ecs_stage_t);
+    flecs_poly_assert(world, ecs_stage_t);
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);  
-    int32_t stage_index = ecs_get_stage_id(stage->thread_ctx);
+    int32_t stage_index = ecs_stage_get_id(stage->thread_ctx);
     int32_t stage_count = ecs_get_stage_count(world);
     bool multi_threaded = world->worker_cond != 0;
 
-    ecs_assert(!stage_index, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(!stage_index, ECS_INVALID_OPERATION, 
+        "cannot run pipeline on stage");
 
     // Update the pipeline the workers will execute
     world->pq = pq;
@@ -62145,12 +62115,12 @@ void flecs_run_pipeline(
             continue;
         }
 
-        bool no_readonly = pq->cur_op->no_readonly;
+        bool immediate = pq->cur_op->immediate;
         bool op_multi_threaded = multi_threaded && pq->cur_op->multi_threaded;
 
-        pq->no_readonly = no_readonly;
+        pq->immediate = immediate;
 
-        if (!no_readonly) {
+        if (!immediate) {
             ecs_readonly_begin(world, multi_threaded);
         }
 
@@ -62179,7 +62149,7 @@ void flecs_run_pipeline(
             flecs_wait_for_sync(world);
         }
 
-        if (!no_readonly) {
+        if (!immediate) {
             ecs_time_t mt = { 0 };
             if (measure_time) {
                 ecs_time_measure(&mt);
@@ -62187,7 +62157,7 @@ void flecs_run_pipeline(
 
             int32_t si;
             for (si = 0; si < stage_count; si ++) {
-                ecs_stage_t *s = &world->stages[si];
+                ecs_stage_t *s = world->stages[si];
                 pq->cur_op->commands_enqueued += ecs_vec_count(&s->cmd->queue);
             }
 
@@ -62228,14 +62198,14 @@ void flecs_run_startup_systems(
     ecs_log_push_2();
     ecs_entity_t start_pip = ecs_pipeline_init(world, &(ecs_pipeline_desc_t){
         .query = {
-            .filter.terms = {
+            .terms = {
                 { .id = EcsSystem },
-                { .id = EcsPhase, .src.flags = EcsCascade, .src.trav = EcsDependsOn },
-                { .id = ecs_dependson(EcsOnStart), .src.trav = EcsDependsOn },
-                { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsDependsOn, .oper = EcsNot },
-                { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsChildOf, .oper = EcsNot }
+                { .id = EcsPhase, .src.id = EcsCascade, .trav = EcsDependsOn },
+                { .id = ecs_dependson(EcsOnStart), .trav = EcsDependsOn },
+                { .id = EcsDisabled, .src.id = EcsUp, .trav = EcsDependsOn, .oper = EcsNot },
+                { .id = EcsDisabled, .src.id = EcsUp, .trav = EcsChildOf, .oper = EcsNot }
             },
-            .order_by = flecs_entity_compare
+            .order_by_callback = flecs_entity_compare
         }
     });
     ecs_log_pop_2();
@@ -62245,7 +62215,8 @@ void flecs_run_startup_systems(
     ecs_log_push_2();
     ecs_assert(start_pip != 0, ECS_INTERNAL_ERROR, NULL);
     const EcsPipeline *p = ecs_get(world, start_pip, EcsPipeline);
-    ecs_check(p != NULL, ECS_INVALID_OPERATION, NULL);
+    ecs_check(p != NULL, ECS_INVALID_OPERATION, 
+        "pipeline entity is missing flecs.pipeline.Pipeline component");
     flecs_workers_progress(world, p->state, 0);
     ecs_log_pop_2();
 
@@ -62280,7 +62251,8 @@ bool ecs_progress(
     ecs_dbg_3("#[bold]progress#[reset](dt = %.2f)", (double)delta_time);
     ecs_log_push_3();
     const EcsPipeline *p = ecs_get(world, world->pipeline, EcsPipeline);
-    ecs_check(p != NULL, ECS_INVALID_OPERATION, NULL);
+    ecs_check(p != NULL, ECS_INVALID_OPERATION,
+        "pipeline entity is missing flecs.pipeline.Pipeline component");
     flecs_workers_progress(world, p->state, delta_time);
     ecs_log_pop_3();
 
@@ -62314,7 +62286,7 @@ void ecs_set_pipeline(
     ecs_world_t *world,
     ecs_entity_t pipeline)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check( ecs_get(world, pipeline, EcsPipeline) != NULL, 
         ECS_INVALID_PARAMETER, "not a pipeline");
 
@@ -62337,19 +62309,19 @@ ecs_entity_t ecs_pipeline_init(
     ecs_world_t *world,
     const ecs_pipeline_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
 
     ecs_entity_t result = desc->entity;
     if (!result) {
-        result = ecs_new(world, 0);
+        result = ecs_new(world);
     }
 
     ecs_query_desc_t qd = desc->query;
-    if (!qd.order_by) {
-        qd.order_by = flecs_entity_compare;
+    if (!qd.order_by_callback) {
+        qd.order_by_callback = flecs_entity_compare;
     }
-    qd.filter.entity = result;
+    qd.entity = result;
 
     ecs_query_t *query = ecs_query_init(world, &qd);
     if (!query) {
@@ -62357,9 +62329,9 @@ ecs_entity_t ecs_pipeline_init(
         return 0;
     }
 
-    ecs_check(query->filter.terms != NULL, ECS_INVALID_PARAMETER, 
+    ecs_check(query->terms != NULL, ECS_INVALID_PARAMETER, 
         "pipeline query cannot be empty");
-    ecs_check(query->filter.terms[0].id == EcsSystem,
+    ecs_check(query->terms[0].id == EcsSystem,
         ECS_INVALID_PARAMETER, "pipeline must start with System term");
 
     ecs_pipeline_state_t *pq = ecs_os_calloc_t(ecs_pipeline_state_t);
@@ -62422,17 +62394,17 @@ void FlecsPipelineImport(
      * relationships. This ensures that, for example, EcsOnUpdate doesn't have a
      * direct DependsOn relationship on EcsPreUpdate, which ensures that when
      * the EcsPreUpdate phase is disabled, EcsOnUpdate still runs. */
-    ecs_entity_t phase_0 = ecs_new(world, 0);
-    ecs_entity_t phase_1 = ecs_new_w_pair(world, EcsDependsOn, phase_0);
-    ecs_entity_t phase_2 = ecs_new_w_pair(world, EcsDependsOn, phase_1);
-    ecs_entity_t phase_3 = ecs_new_w_pair(world, EcsDependsOn, phase_2);
-    ecs_entity_t phase_4 = ecs_new_w_pair(world, EcsDependsOn, phase_3);
-    ecs_entity_t phase_5 = ecs_new_w_pair(world, EcsDependsOn, phase_4);
-    ecs_entity_t phase_6 = ecs_new_w_pair(world, EcsDependsOn, phase_5);
-    ecs_entity_t phase_7 = ecs_new_w_pair(world, EcsDependsOn, phase_6);
-    ecs_entity_t phase_8 = ecs_new_w_pair(world, EcsDependsOn, phase_7);
-
-    flecs_bootstrap_phase(world, EcsOnStart,   0);
+    ecs_entity_t phase_0 = ecs_entity(world, {0});
+    ecs_entity_t phase_1 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_0)) });
+    ecs_entity_t phase_2 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_1)) });
+    ecs_entity_t phase_3 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_2)) });
+    ecs_entity_t phase_4 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_3)) });
+    ecs_entity_t phase_5 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_4)) });
+    ecs_entity_t phase_6 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_5)) });
+    ecs_entity_t phase_7 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_6)) });
+    ecs_entity_t phase_8 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_7)) });
+
+    flecs_bootstrap_phase(world, EcsOnStart,    0);
     flecs_bootstrap_phase(world, EcsPreFrame,   0);
     flecs_bootstrap_phase(world, EcsOnLoad,     phase_0);
     flecs_bootstrap_phase(world, EcsPostLoad,   phase_1);
@@ -62445,7 +62417,7 @@ void FlecsPipelineImport(
     flecs_bootstrap_phase(world, EcsPostFrame,  phase_8);
 
     ecs_set_hooks(world, EcsPipeline, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(EcsPipeline),
         .move = ecs_move(EcsPipeline)
     });
@@ -62453,14 +62425,14 @@ void FlecsPipelineImport(
     world->pipeline = ecs_pipeline(world, {
         .entity = ecs_entity(world, { .name = "BuiltinPipeline" }),
         .query = {
-            .filter.terms = {
+            .terms = {
                 { .id = EcsSystem },
-                { .id = EcsPhase, .src.flags = EcsCascade, .src.trav = EcsDependsOn },
-                { .id = ecs_dependson(EcsOnStart), .src.trav = EcsDependsOn, .oper = EcsNot },
-                { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsDependsOn, .oper = EcsNot },
-                { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsChildOf, .oper = EcsNot }
+                { .id = EcsPhase, .src.id = EcsCascade, .trav = EcsDependsOn },
+                { .id = ecs_dependson(EcsOnStart), .trav = EcsDependsOn, .oper = EcsNot },
+                { .id = EcsDisabled, .src.id = EcsUp, .trav = EcsDependsOn, .oper = EcsNot },
+                { .id = EcsDisabled, .src.id = EcsUp, .trav = EcsChildOf, .oper = EcsNot }
             },
-            .order_by = flecs_entity_compare
+            .order_by_callback = flecs_entity_compare
         }
     });
 
@@ -62506,8 +62478,8 @@ void* flecs_worker(void *arg) {
     ecs_stage_t *stage = arg;
     ecs_world_t *world = stage->world;
 
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_assert(stage, ecs_stage_t);
+    flecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(stage, ecs_stage_t);
 
     ecs_dbg_2("worker %d: start", stage->id);
 
@@ -62549,13 +62521,13 @@ void* flecs_worker(void *arg) {
 void flecs_create_worker_threads(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     int32_t stages = ecs_get_stage_count(world);
 
     for (int32_t i = 1; i < stages; i ++) {
         ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i);
         ecs_assert(stage != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_poly_assert(stage, ecs_stage_t);
+        flecs_poly_assert(stage, ecs_stage_t);
 
         ecs_assert(stage->thread == 0, ECS_INTERNAL_ERROR, NULL);
         if (ecs_using_task_threads(world)) {
@@ -62566,7 +62538,8 @@ void flecs_create_worker_threads(
             /* workers are using long-running os threads */
             stage->thread = ecs_os_thread_new(flecs_worker, stage);
         }
-        ecs_assert(stage->thread != 0, ECS_OPERATION_FAILED, NULL);
+        ecs_assert(stage->thread != 0, ECS_OPERATION_FAILED,
+            "failed to create thread");
     }
 }
 
@@ -62589,7 +62562,7 @@ static
 void flecs_wait_for_workers(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     int32_t stage_count = ecs_get_stage_count(world);
     if (stage_count <= 1) {
@@ -62650,15 +62623,14 @@ void flecs_signal_workers(
 void flecs_join_worker_threads(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     bool threads_active = false;
 
     /* Test if threads are created. Cannot use workers_running, since this is
      * a potential race if threads haven't spun up yet. */
-    ecs_stage_t *stages = world->stages;
     int i, count = world->stage_count;
     for (i = 1; i < count; i ++) {
-        ecs_stage_t *stage = &stages[i];
+        ecs_stage_t *stage = world->stages[i];
         if (stage->thread) {
             threads_active = true;
             break;
@@ -62679,12 +62651,13 @@ void flecs_join_worker_threads(
 
     /* Join all threads with main */
     for (i = 1; i < count; i ++) {
+        ecs_stage_t *stage = world->stages[i];
         if (ecs_using_task_threads(world)) {
-            ecs_os_task_join(stages[i].thread);
+            ecs_os_task_join(stage->thread);
         } else {
-            ecs_os_thread_join(stages[i].thread);
+            ecs_os_thread_join(stage->thread);
         }
-        stages[i].thread = 0;
+        stage->thread = 0;
     }
 
     world->flags &= ~EcsWorldQuitWorkers;
@@ -62697,8 +62670,9 @@ void flecs_workers_progress(
     ecs_pipeline_state_t *pq,
     ecs_ftime_t delta_time)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(!ecs_is_deferred(world), ECS_INVALID_OPERATION, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(!ecs_is_deferred(world), ECS_INVALID_OPERATION, 
+        "cannot call progress while world is deferred");
 
     /* Make sure workers are running and ready */
     flecs_wait_for_workers(world);
@@ -62777,6731 +62751,7458 @@ bool ecs_using_task_threads(
 
 #endif
 
- /**
- * @file addons/rules/api.c
- * @brief User facing API for rules.
+/**
+ * @file addons/script/assembly.c
+ * @brief Script assembly implementation.
  */
 
- /**
- * @file addons/rules/rules.h
- * @brief Internal types and functions for rules addon.
- */
 
-#ifndef FLECS_RULES_PRIVATE_H
-#define FLECS_RULES_PRIVATE_H
+#ifdef FLECS_SCRIPT
 
+/* Assembly ctor to initialize with default property values */
+static
+void flecs_script_assembly_ctor(
+    void *ptr,
+    int32_t count,
+    const ecs_type_info_t *ti)
+{
+    ecs_world_t *world = ti->hooks.ctx;
+    ecs_entity_t assembly_entity = ti->component;
+    
+    const EcsStruct *st = ecs_get(world, assembly_entity, EcsStruct);
+    if (!st) {
+        ecs_os_memset(ptr, 0, count * ti->size);
+        return;
+    }
 
-#ifdef FLECS_RULES
+    const EcsScript *script = ecs_get(world, assembly_entity, EcsScript);
+    if (!script) {
+        ecs_err("assembly '%s' is not a script, cannot construct", ti->name);
+        return;
+    }
 
-typedef uint8_t ecs_var_id_t;
-typedef int16_t ecs_rule_lbl_t;
-typedef ecs_flags64_t ecs_write_flags_t;
+    ecs_script_assembly_t *assembly = script->assembly;
+    ecs_assert(assembly != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (st->members.count != assembly->prop_defaults.count) {
+        ecs_err("number of props (%d) of assembly '%s' does not match members"
+            " (%d), cannot construct", assembly->prop_defaults.count, 
+                ti->name, st->members.count);
+        return;
+    }
 
-#define EcsRuleMaxVarCount      (64)
-#define EcsVarNone              ((ecs_var_id_t)-1)
-#define EcsThisName             "this"
+    const ecs_member_t *members = st->members.array;
+    int32_t i, m, member_count = st->members.count;
+    ecs_script_var_t *values = assembly->prop_defaults.array;
+    for (m = 0; m < member_count; m ++) {
+        const ecs_member_t *member = &members[m];
+        ecs_script_var_t *value = &values[m];
+        const ecs_type_info_t *mti = value->type_info;
+        ecs_assert(mti != NULL, ECS_INTERNAL_ERROR, NULL);
 
-/* -- Variable types -- */
-typedef enum {
-    EcsVarEntity,          /* Variable that stores an entity id */
-    EcsVarTable,           /* Variable that stores a table */
-    EcsVarAny              /* Used when requesting either entity or table var */
-} ecs_var_kind_t;
+        for (i = 0; i < count; i ++) {
+            void *el = ECS_ELEM(ptr, ti->size, i);
+            ecs_value_copy_w_type_info(world, mti, 
+                ECS_OFFSET(el, member->offset), value->value.ptr);
+        }
+    }
+}
+
+/* Assembly on_set handler to update contents for new property values */
+static
+void flecs_script_assembly_on_set(
+    ecs_iter_t *it)
+{
+    if (it->table->flags & EcsTableIsPrefab) {
+        /* Don't instantiate assemblies for prefabs */
+        return;
+    }
+
+    ecs_world_t *world = it->world;
+    ecs_entity_t assembly_entity = ecs_field_id(it, 0);
+    ecs_record_t *r = ecs_record_find(world, assembly_entity);
+    if (!r) {
+        ecs_err("assembly entity is empty (should never happen)");
+        return;
+    }
+
+    const EcsScript *script = ecs_record_get(world, r, EcsScript);
+    if (!script) {
+        ecs_err("assembly is missing script component");
+        return;
+    }
+
+    ecs_script_assembly_t *assembly = script->assembly;
+    ecs_assert(assembly != NULL, ECS_INTERNAL_ERROR, NULL);
+    const ecs_type_info_t *ti = assembly->type_info;
+    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+    const EcsStruct *st = ecs_record_get(world, r, EcsStruct);
+
+    void *data = ecs_field_w_size(it, flecs_ito(size_t, ti->size), 0);
+
+    ecs_script_eval_visitor_t v;
+    flecs_script_eval_visit_init(script->script, &v);
+    ecs_vec_t prev_using = v.using;
+    v.using = assembly->using_;
+
+    ecs_script_scope_t *scope = assembly->node->scope;
+
+    /* Dummy entity node for instance */
+    ecs_script_entity_t instance_node = {
+        .node = {
+            .kind = EcsAstEntity,
+            .pos = assembly->node->node.pos
+        },
+        .scope = scope
+    };
+
+    v.entity = &instance_node;
+
+    int32_t i, m;
+    for (i = 0; i < it->count; i ++) {
+        v.parent = it->entities[i];
+        instance_node.eval = it->entities[i];
+
+        /* Create variables to hold assembly properties */
+        ecs_script_vars_t *vars = flecs_script_vars_push(
+            NULL, &v.stack, v.allocator);
+
+        /* Populate properties from assembly members */
+        if (st) {
+            const ecs_member_t *members = st->members.array;
+            for (m = 0; m < st->members.count; m ++) {
+                const ecs_member_t *member = &members[m];
+
+                /* Assign assembly property from assembly instance */
+                ecs_script_var_t *var = ecs_script_vars_declare(vars, member->name);
+                var->value.type = member->type;
+                var->value.ptr = ECS_OFFSET(data, member->offset);
+            }
+        }
+
+        /* Populate $this variable with instance entity */
+        ecs_entity_t instance = it->entities[i];
+        ecs_script_var_t *var = ecs_script_vars_declare(vars, "this");
+        var->value.type = ecs_id(ecs_entity_t);
+        var->value.ptr = &instance;
+
+        bool is_defer = ecs_is_deferred(world);
+        ecs_suspend_readonly_state_t srs;
+        ecs_world_t *real_world = NULL;
+        if (is_defer) {
+            ecs_assert(flecs_poly_is(world, ecs_world_t), ECS_INTERNAL_ERROR, NULL);
+            real_world = flecs_suspend_readonly(world, &srs);
+            ecs_assert(real_world != NULL, ECS_INTERNAL_ERROR, NULL);
+        }
+
+        ecs_script_clear(world, assembly_entity, instance);
+
+        /* Run assembly code */
+        v.vars = vars;
+        ecs_script_visit_scope(&v, scope);
+
+        if (is_defer) {
+            flecs_resume_readonly(real_world, &srs);
+        }
+
+        /* Pop variable scope */
+        ecs_script_vars_pop(vars);
+
+        data = ECS_OFFSET(data, ti->size);
+    }
+
+    v.using = prev_using;
+    flecs_script_eval_visit_fini(&v);
+}
+
+static
+int flecs_script_eval_prop(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_var_node_t *node)
+{
+    ecs_script_assembly_t *assembly = v->assembly;
+    ecs_script_var_t *var = ecs_script_vars_declare(v->vars, node->name);
+    if (!var) {
+        flecs_script_eval_error(v, node, 
+            "variable '%s' redeclared", node->name);
+        return -1;
+    }
+
+    if (node->type) {
+        ecs_entity_t type = flecs_script_find_entity(v, 0, node->type);
+        if (!type) {
+            flecs_script_eval_error(v, node,
+                "unresolved type '%s' for const variable '%s'", 
+                    node->type, node->name);
+            return -1;
+        }
+
+        const ecs_type_info_t *ti = flecs_script_get_type_info(v, node, type);
+        if (!ti) {
+            return -1;
+        }
+
+        var->value.type = type;
+        var->value.ptr = flecs_stack_alloc(&v->stack, ti->size, ti->alignment);
+        var->type_info = ti;
+
+        if (flecs_script_eval_expr(v, node->expr, &var->value)) {
+            return -1;
+        }
+
+        ecs_script_var_t *value = ecs_vec_append_t(&v->base.script->allocator, 
+            &assembly->prop_defaults, ecs_script_var_t);
+        value->value.ptr = flecs_calloc(&v->base.script->allocator, ti->size);
+        value->value.type = type;
+        value->type_info = ti;
+        ecs_value_copy_w_type_info(
+            v->world, ti, value->value.ptr, var->value.ptr);
+
+        ecs_entity_t mbr = ecs_entity(v->world, {
+            .name = node->name,
+            .parent = assembly->entity
+        });
+
+        ecs_set(v->world, mbr, EcsMember, { .type = var->value.type });
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_assembly_eval(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node)
+{
+    switch(node->kind) {
+    case EcsAstProp:
+        return flecs_script_eval_prop(v, (ecs_script_var_node_t*)node);
+    case EcsAstScope:
+    case EcsAstTag:
+    case EcsAstComponent:
+    case EcsAstVarComponent:
+    case EcsAstDefaultComponent:
+    case EcsAstWithVar:
+    case EcsAstWithTag:
+    case EcsAstWithComponent:
+    case EcsAstWith:
+    case EcsAstUsing:
+    case EcsAstModule:
+    case EcsAstAnnotation:
+    case EcsAstAssembly:
+    case EcsAstConst:
+    case EcsAstEntity:
+    case EcsAstPairScope:
+    case EcsAstIf:
+        break;
+    }
+
+    return flecs_script_eval_node(v, node);
+}
+
+static
+int flecs_script_assembly_preprocess(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_assembly_t *assembly)
+{
+    v->assembly = assembly;
+    v->base.visit = (ecs_visit_action_t)flecs_script_assembly_eval;
+    v->vars = flecs_script_vars_push(v->vars, &v->stack, v->allocator);
+    int result = ecs_script_visit_scope(v, assembly->node->scope);
+    v->vars = ecs_script_vars_pop(v->vars);
+    v->assembly = NULL;
+    return result;
+}
+
+static
+int flecs_script_assembly_hoist_using(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_assembly_t *assembly)
+{
+    if (v->module) {
+        ecs_vec_append_t(
+            v->allocator, &assembly->using_, ecs_entity_t)[0] = v->module;
+    }
+
+    int i, count = ecs_vec_count(&v->using);
+    for (i = 0; i < count; i ++) {
+        ecs_vec_append_t(v->allocator, &assembly->using_, ecs_entity_t)[0] = 
+            ecs_vec_get_t(&v->using, ecs_entity_t, i)[0];
+    }
+
+    return 0;
+}
+
+ecs_script_assembly_t* flecs_script_assembly_init(
+    ecs_script_t *script)
+{
+    ecs_allocator_t *a = &script->allocator;
+    ecs_script_assembly_t *result = flecs_alloc_t(a, ecs_script_assembly_t);
+    ecs_vec_init_t(NULL, &result->prop_defaults, ecs_script_var_t, 0);
+    ecs_vec_init_t(NULL, &result->using_, ecs_entity_t, 0);
+    return result;
+}
+
+void flecs_script_assembly_fini(
+    ecs_script_t *script,
+    ecs_script_assembly_t *assembly)
+{
+    ecs_assert(script != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_allocator_t *a = &script->allocator;
+
+    int32_t i, count = ecs_vec_count(&assembly->prop_defaults);
+    ecs_script_var_t *values = ecs_vec_first(&assembly->prop_defaults);
+    for (i = 0; i < count; i ++) {
+        ecs_script_var_t *value = &values[i];
+        const ecs_type_info_t *ti = value->type_info;
+        if (ti->hooks.dtor) {
+            ti->hooks.dtor(value->value.ptr, 1, ti);
+        }
+        flecs_free(a, ti->size, value->value.ptr);
+    }
+
+    ecs_vec_fini_t(a, &assembly->prop_defaults, ecs_script_var_t);
+    ecs_vec_fini_t(a, &assembly->using_, ecs_entity_t);
+    flecs_free_t(a, ecs_script_assembly_t, assembly);
+}
+
+/* Create new assembly */
+int flecs_script_eval_assembly(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_assembly_node_t *node)
+{
+    ecs_entity_t assembly_entity = flecs_script_create_entity(v, node->name);
+    if (!assembly_entity) {
+        return -1;
+    }
+
+    ecs_script_assembly_t *assembly = flecs_script_assembly_init(v->base.script);
+    assembly->entity = assembly_entity;
+    assembly->node = node;
+
+    if (flecs_script_assembly_preprocess(v, assembly)) {
+        goto error;
+    }
+
+    if (flecs_script_assembly_hoist_using(v, assembly)) {
+        goto error;
+    }
+
+    /* If assembly has no props, give assembly dummy size so we can register
+     * hooks for it. */
+    if (!ecs_has(v->world, assembly_entity, EcsComponent)) {
+        ecs_set(v->world, assembly_entity, EcsComponent, {1, 1});
+    }
+
+    assembly->type_info = ecs_get_type_info(v->world, assembly_entity);
+
+    ecs_add_id(v->world, assembly_entity, EcsAlwaysOverride);
+
+    EcsScript *script = ecs_ensure(v->world, assembly_entity, EcsScript);
+    if (script->script) {
+        if (script->assembly) {
+            flecs_script_assembly_fini(script->script, script->assembly);
+        }
+        ecs_script_free(script->script);
+    }
+
+    script->script = v->base.script;
+    script->assembly = assembly;
+    ecs_modified(v->world, assembly_entity, EcsScript);
+
+    ecs_set_hooks_id(v->world, assembly_entity, &(ecs_type_hooks_t) {
+        .ctor = flecs_script_assembly_ctor,
+        .on_set = flecs_script_assembly_on_set,
+        .ctx = v->world
+    });
+
+    /* Keep script alive for as long as assembly is alive */
+    v->base.script->refcount ++;
+
+    return 0;
+error:
+    flecs_script_assembly_fini(v->base.script, assembly);
+    return -1;
+}
 
-typedef struct ecs_rule_var_t {
-    int8_t kind;           /* variable kind (EcsVarEntity or EcsVarTable) */
-    bool anonymous;        /* variable is anonymous */
-    ecs_var_id_t id;       /* variable id */
-    ecs_var_id_t table_id; /* id to table variable, if any */
-    ecs_var_id_t base_id;  /* id to base entity variable, for lookups */
-    const char *name;      /* variable name */
-    const char *lookup;    /* Lookup string for variable */
-#ifdef FLECS_DEBUG
-    const char *label;     /* for debugging */
 #endif
-} ecs_rule_var_t;
 
-/* -- Instruction kinds -- */
-typedef enum {
-    EcsRuleAnd,            /* And operator: find or match id against variable source */
-    EcsRuleAndId,          /* And operator for fixed id (no wildcards/variables) */
-    EcsRuleAndAny,         /* And operator with support for matching Any src/id */
-    EcsRuleTriv,           /* Trivial search */
-    EcsRuleTrivData,       /* Trivial search with setting data fields */
-    EcsRuleTrivWildcard,   /* Trivial search with (exclusive) wildcard ids */
-    EcsRuleSelectAny,      /* Dedicated instruction for _ queries where the src is unknown */
-    EcsRuleUp,             /* Up traversal */
-    EcsRuleUpId,           /* Up traversal for fixed id (like AndId) */
-    EcsRuleSelfUp,         /* Self|up traversal */
-    EcsRuleSelfUpId,       /* Self|up traversal for fixed id (like AndId) */
-    EcsRuleWith,           /* Match id against fixed or variable source */
-    EcsRuleTrav,           /* Support for transitive/reflexive queries */
-    EcsRuleIds,            /* Test for existence of ids matching wildcard */
-    EcsRuleIdsRight,       /* Find ids in use that match (R, *) wildcard */
-    EcsRuleIdsLeft,        /* Find ids in use that match (*, T) wildcard */
-    EcsRuleEach,           /* Iterate entities in table, populate entity variable */
-    EcsRuleStore,          /* Store table or entity in variable */
-    EcsRuleReset,          /* Reset value of variable to wildcard (*) */
-    EcsRuleOr,             /* Or operator */
-    EcsRuleOptional,       /* Optional operator */
-    EcsRuleIf,             /* Conditional execution */
-    EcsRuleNot,            /* Sets iterator state after term was not matched */
-    EcsRuleEnd,            /* End of control flow block */
-    EcsRulePredEq,         /* Test if variable is equal to, or assign to if not set */
-    EcsRulePredNeq,        /* Test if variable is not equal to */
-    EcsRulePredEqName,     /* Same as EcsRulePredEq but with matching by name */
-    EcsRulePredNeqName,    /* Same as EcsRulePredNeq but with matching by name */
-    EcsRulePredEqMatch,    /* Same as EcsRulePredEq but with fuzzy matching by name */
-    EcsRulePredNeqMatch,   /* Same as EcsRulePredNeq but with fuzzy matching by name */
-    EcsRuleLookup,         /* Lookup relative to variable */
-    EcsRuleSetVars,        /* Populate it.sources from variables */
-    EcsRuleSetThis,        /* Populate This entity variable */
-    EcsRuleSetFixed,       /* Set fixed source entity ids */
-    EcsRuleSetIds,         /* Set fixed (component) ids */
-    EcsRuleSetId,          /* Set id if not set */
-    EcsRuleContain,        /* Test if table contains entity */
-    EcsRulePairEq,         /* Test if both elements of pair are the same */
-    EcsRulePopulate,       /* Populate any data fields */
-    EcsRulePopulateSelf,   /* Populate only self (owned) data fields */
-    EcsRuleYield,          /* Yield result back to application */
-    EcsRuleNothing         /* Must be last */
-} ecs_rule_op_kind_t;
-
-/* Op flags to indicate if ecs_rule_ref_t is entity or variable */
-#define EcsRuleIsEntity  (1 << 0)
-#define EcsRuleIsVar     (1 << 1)
-#define EcsRuleIsSelf    (1 << 6)
-
-/* Op flags used to shift EcsRuleIsEntity and EcsRuleIsVar */
-#define EcsRuleSrc     0
-#define EcsRuleFirst   2
-#define EcsRuleSecond  4
+/**
+ * @file addons/script/ast.c
+ * @brief Script AST implementation.
+ */
 
-/* References to variable or entity */
-typedef union {
-    ecs_var_id_t var;
-    ecs_entity_t entity;
-} ecs_rule_ref_t;
 
-/* Query instruction */
-typedef struct ecs_rule_op_t {
-    uint8_t kind;              /* Instruction kind */
-    ecs_flags8_t flags;        /* Flags storing whether 1st/2nd are variables */
-    int8_t field_index;        /* Query field corresponding with operation */
-    int8_t term_index;         /* Query term corresponding with operation */
-    ecs_rule_lbl_t prev;       /* Backtracking label (no data) */
-    ecs_rule_lbl_t next;       /* Forwarding label. Must come after prev */
-    ecs_rule_lbl_t other;      /* Misc register used for control flow */
-    ecs_flags16_t match_flags; /* Flags that modify matching behavior */
-    ecs_rule_ref_t src;
-    ecs_rule_ref_t first;
-    ecs_rule_ref_t second;
-    ecs_flags64_t written;     /* Bitset with variables written by op */
-} ecs_rule_op_t;
+#ifdef FLECS_SCRIPT
 
- /* And context */
-typedef struct {
-    ecs_id_record_t *idr;
-    ecs_table_cache_iter_t it;
-    int16_t column;
-    int16_t remaining;
-} ecs_rule_and_ctx_t;
+#define flecs_ast_strdup(parser, str)\
+    (str ? flecs_strdup(&parser->script->allocator, str) : NULL)
+#define flecs_ast_new(parser, T, kind)\
+    (T*)flecs_ast_new_(parser, ECS_SIZEOF(T), kind)
+#define flecs_ast_vec(parser, vec, T) \
+    ecs_vec_init_t(&parser->script->allocator, &vec, T*, 0)
+#define flecs_ast_append(parser, vec, T, node) \
+    ecs_vec_append_t(&parser->script->allocator, &vec, T*)[0] = node
 
-/* Down traversal cache (for resolving up queries w/unknown source) */
-typedef struct {
-    ecs_table_t *table;
-    bool leaf; /* Table owns and inherits id (for Up queries without Self) */
-} ecs_trav_down_elem_t;
+static
+void* flecs_ast_new_(
+    ecs_script_parser_t *parser,
+    ecs_size_t size, 
+    ecs_script_node_kind_t kind)
+{
+    ecs_assert(parser->script != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_allocator_t *a = &parser->script->allocator;
+    ecs_script_node_t *result = flecs_calloc(a, size);
+    result->kind = kind;
+    result->pos = parser->pos;
+    return result;
+}
 
-typedef struct {
-    ecs_vec_t elems;      /* vector<ecs_trav_down_elem_t> */
-    bool ready;
-} ecs_trav_down_t;
+ecs_script_scope_t* flecs_script_scope_new(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *result = flecs_ast_new(
+        parser, ecs_script_scope_t, EcsAstScope);
+    flecs_ast_vec(parser, result->stmts, ecs_script_node_t);
+    return result;
+}
 
-typedef struct {
-    ecs_entity_t src;
-    ecs_id_t id;
-    int32_t column;
-    bool ready;
-} ecs_trav_up_t;
+bool flecs_scope_is_empty(
+    ecs_script_scope_t *scope)
+{
+    return ecs_vec_count(&scope->stmts) == 0;
+}
 
-typedef struct {
-    ecs_map_t src;        /* map<entity, trav_down_t> or map<table_id, trav_up_t> */
-    ecs_id_t with;
-    ecs_flags32_t dir;
-} ecs_trav_up_cache_t;
+ecs_script_scope_t* flecs_script_insert_scope(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_script_scope_t *result = flecs_script_scope_new(parser);
+    flecs_ast_append(parser, scope->stmts, ecs_script_scope_t, result);
+    return result;
+}
 
-/* And up context */
-typedef struct {
-    ecs_rule_and_ctx_t and;
-    ecs_table_t *table;
-    int32_t row;
-    int32_t end;
-    ecs_entity_t trav;
-    ecs_id_t with;
-    ecs_id_t matched;
-    ecs_id_record_t *idr_with;
-    ecs_id_record_t *idr_trav;
-    ecs_trav_down_t *down;
-    int32_t cache_elem;
-    ecs_trav_up_cache_t cache;
-} ecs_rule_up_ctx_t;
+ecs_script_entity_t* flecs_script_insert_entity(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
-/* Cache for storing results of upward/downward "all" traversal. This type of
- * traversal iterates and caches the entire tree. */
-typedef struct {
-    ecs_entity_t entity;
-    ecs_id_record_t *idr;
-    int32_t column;
-} ecs_trav_elem_t;
+    ecs_script_entity_t *result = flecs_ast_new(
+        parser, ecs_script_entity_t, EcsAstEntity);
 
-typedef struct {
-    ecs_id_t id;
-    ecs_id_record_t *idr;
-    ecs_vec_t entities;
-    bool up;
-} ecs_trav_cache_t;
+    if (name && !ecs_os_strcmp(name, "_")) {
+        name = NULL;
+    }
 
-/* Trav context */
-typedef struct {
-    ecs_rule_and_ctx_t and;
-    int32_t index;
-    int32_t offset;
-    int32_t count;
-    ecs_trav_cache_t cache;
-    bool yield_reflexive;
-} ecs_rule_trav_ctx_t;
+    result->name = name;
 
- /* Eq context */
-typedef struct {
-    ecs_table_range_t range;
-    int32_t index;
-    int16_t name_col;
-    bool redo;
-} ecs_rule_eq_ctx_t;
+    ecs_script_scope_t *entity_scope = flecs_script_scope_new(parser);
+    ecs_assert(entity_scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    result->scope = entity_scope;
 
- /* Each context */
-typedef struct {
-    int32_t row;
-} ecs_rule_each_ctx_t;
+    flecs_ast_append(parser, scope->stmts, ecs_script_entity_t, result);
+    return result;
+}
 
- /* Setthis context */
-typedef struct {
-    ecs_table_range_t range;
-} ecs_rule_setthis_ctx_t;
+static
+void flecs_script_set_id(
+    ecs_script_id_t *id,
+    const char *first,
+    const char *second)
+{
+    ecs_assert(first != NULL, ECS_INTERNAL_ERROR, NULL);
+    id->first = first;
+    id->second = second;
+}
 
-/* Ids context */
-typedef struct {
-    ecs_id_record_t *cur;
-} ecs_rule_ids_ctx_t;
+ecs_script_pair_scope_t* flecs_script_insert_pair_scope(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_script_pair_scope_t *result = flecs_ast_new(
+        parser, ecs_script_pair_scope_t, EcsAstPairScope);
+    flecs_script_set_id(&result->id, first, second);
+    result->scope = flecs_script_scope_new(parser);
 
-/* Control flow context */
-typedef struct {
-    ecs_rule_lbl_t op_index;
-    ecs_id_t field_id;
-} ecs_rule_ctrl_ctx_t;
+    flecs_ast_append(parser, scope->stmts, ecs_script_pair_scope_t, result);
+    return result;
+}
 
-/* Trivial context */
-typedef struct {
-    ecs_table_cache_iter_t it;
-    const ecs_table_record_t *tr;
-} ecs_rule_trivial_ctx_t;
+ecs_script_tag_t* flecs_script_insert_pair_tag(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
-typedef struct ecs_rule_op_ctx_t {
-    union {
-        ecs_rule_and_ctx_t and;
-        ecs_rule_up_ctx_t up;
-        ecs_rule_trav_ctx_t trav;
-        ecs_rule_ids_ctx_t ids;
-        ecs_rule_eq_ctx_t eq;
-        ecs_rule_each_ctx_t each;
-        ecs_rule_setthis_ctx_t setthis;
-        ecs_rule_ctrl_ctx_t ctrl;
-        ecs_rule_trivial_ctx_t trivial;
-    } is;
-} ecs_rule_op_ctx_t;
+    ecs_script_tag_t *result = flecs_ast_new(
+        parser, ecs_script_tag_t, EcsAstTag);
+    flecs_script_set_id(&result->id, first, second);
 
-typedef struct {
-    /* Labels used for control flow */
-    ecs_rule_lbl_t lbl_query; /* Used to find the op that does the actual searching */
-    ecs_rule_lbl_t lbl_begin;
-    ecs_rule_lbl_t lbl_cond_eval;
-    ecs_write_flags_t cond_written_or; /* Cond written flags at start of or chain */
-    bool in_or; /* Whether we're in an or chain */
-} ecs_rule_compile_ctrlflow_t;
+    flecs_ast_append(parser, scope->stmts, ecs_script_tag_t, result);
 
-/* Rule compiler state */
-typedef struct {
-    ecs_vec_t *ops;
-    ecs_write_flags_t written; /* Bitmask to check which variables have been written */
-    ecs_write_flags_t cond_written; /* Track conditional writes (optional operators) */
+    return result;
+}
 
-    /* Maintain control flow per scope */
-    ecs_rule_compile_ctrlflow_t ctrlflow[FLECS_QUERY_SCOPE_NESTING_MAX];
-    ecs_rule_compile_ctrlflow_t *cur; /* Current scope */
+ecs_script_tag_t* flecs_script_insert_tag(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    return flecs_script_insert_pair_tag(parser, name, NULL);
+}
 
-    int32_t scope; /* Nesting level of query scopes */
-    ecs_flags32_t scope_is_not; /* Whether scope is prefixed with not */
-} ecs_rule_compile_ctx_t;
+ecs_script_component_t* flecs_script_insert_pair_component(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
-/* Rule run state */
-typedef struct {
-    uint64_t *written;            /* Bitset to check which variables have been written */
-    ecs_rule_lbl_t op_index;      /* Currently evaluated operation */
-    ecs_var_t *vars;              /* Variable storage */
-    ecs_iter_t *it;               /* Iterator */
-    ecs_rule_op_ctx_t *op_ctx;    /* Operation context (stack) */
-    ecs_world_t *world;           /* Reference to world */
-    const ecs_rule_t *rule;       /* Reference to rule */
-    const ecs_rule_var_t *rule_vars; /* Reference to rule variable array */
-    ecs_flags32_t *source_set;    /* Whether ecs_iter_t::sources is written by instruction */
-    ecs_rule_iter_t *rit;
-} ecs_rule_run_ctx_t;
+    ecs_script_component_t *result = flecs_ast_new(
+            parser, ecs_script_component_t, EcsAstComponent);
+    flecs_script_set_id(&result->id, first, second);
 
-typedef struct {
-    ecs_rule_var_t var;
-    const char *name;
-} ecs_rule_var_cache_t;
+    flecs_ast_append(parser, scope->stmts, ecs_script_component_t, result);
 
-struct ecs_rule_t {
-    ecs_header_t hdr;             /* Poly header */
-    ecs_filter_t filter;          /* Filter */
+    return result;
+}
 
-    /* Variables */
-    ecs_rule_var_t *vars;         /* Variables */
-    int32_t var_count;            /* Number of variables */
-    int32_t var_pub_count;        /* Number of public variables */
-    bool has_table_this;          /* Does rule have [$this] */
-    ecs_hashmap_t tvar_index;     /* Name index for table variables */
-    ecs_hashmap_t evar_index;     /* Name index for entity variables */
-    ecs_rule_var_cache_t vars_cache; /* For trivial rules with only This variables */
-    char **var_names;             /* Array with variable names for iterator */
+ecs_script_component_t* flecs_script_insert_component(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    return flecs_script_insert_pair_component(parser, name, NULL);
+}
+
+ecs_script_default_component_t* flecs_script_insert_default_component(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_default_component_t *result = flecs_ast_new(
+            parser, ecs_script_default_component_t, EcsAstDefaultComponent);
+
+    flecs_ast_append(parser, scope->stmts, 
+        ecs_script_default_component_t, result);
+
+    return result;
+}
+
+ecs_script_var_component_t* flecs_script_insert_var_component(
+    ecs_script_parser_t *parser,
+    const char *var_name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(var_name != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_var_component_t *result = flecs_ast_new(
+            parser, ecs_script_var_component_t, EcsAstVarComponent);
+    result->name = var_name;
+
+    flecs_ast_append(parser, scope->stmts, 
+        ecs_script_var_component_t, result);
+    return result;
+}
 
-    ecs_var_id_t *src_vars;       /* Array with ids to source variables for fields */
-    ecs_rule_op_t *ops;           /* Operations */
-    int32_t op_count;             /* Number of operations */
+ecs_script_with_t* flecs_script_insert_with(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    /* Mixins */
-    ecs_iterable_t iterable;
-    ecs_poly_dtor_t dtor;
+    ecs_script_with_t *result = flecs_ast_new(
+        parser, ecs_script_with_t, EcsAstWith);
 
-#ifdef FLECS_DEBUG
-    int32_t var_size;             /* Used for out of bounds check during compilation */
-#endif
-};
+    result->expressions = flecs_script_scope_new(parser);
+    result->scope = flecs_script_scope_new(parser);
 
-/* Convert integer to label */
-ecs_rule_lbl_t flecs_itolbl(
-    int64_t val);
+    flecs_ast_append(parser, scope->stmts, ecs_script_with_t, result);
+    return result;
+}
 
-/* Get ref flags (IsEntity) or IsVar) for ref (Src, First, Second) */
-ecs_flags16_t flecs_rule_ref_flags(
-    ecs_flags16_t flags,
-    ecs_flags16_t kind);
+ecs_script_using_t* flecs_script_insert_using(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
-/* Check if variable is written */
-bool flecs_rule_is_written(
-    ecs_var_id_t var_id,
-    uint64_t written);
+    ecs_script_using_t *result = flecs_ast_new(
+        parser, ecs_script_using_t, EcsAstUsing);
 
-/* Check if ref is written (calls flecs_rule_is_written)*/
-bool flecs_ref_is_written(
-    const ecs_rule_op_t *op,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t kind,
-    uint64_t written);
+    result->name = name;
 
-/* Compile filter to list of operations */
-int flecs_rule_compile(
-    ecs_world_t *world,
-    ecs_stage_t *stage,
-    ecs_rule_t *rule);
+    flecs_ast_append(parser, scope->stmts, ecs_script_using_t, result);
+    return result;
+}
 
-/* Get allocator from iterator */
-ecs_allocator_t* flecs_rule_get_allocator(
-    const ecs_iter_t *it);
+ecs_script_module_t* flecs_script_insert_module(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
+    ecs_script_module_t *result = flecs_ast_new(
+        parser, ecs_script_module_t, EcsAstModule);
 
-/* Traversal cache for transitive queries. Finds all reachable entities by
- * following a relationship */
+    result->name = name;
 
-/* Find all entities when traversing downwards */
-void flecs_rule_get_trav_down_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_entity_t entity);
+    flecs_ast_append(parser, scope->stmts, ecs_script_module_t, result);
+    return result;
+}
 
-/* Find all entities when traversing upwards */
-void flecs_rule_get_trav_up_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_table_t *table);
+ecs_script_annot_t* flecs_script_insert_annot(
+    ecs_script_parser_t *parser,
+    const char *name,
+    const char *expr)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
-/* Free traversal cache */
-void flecs_rule_trav_cache_fini(
-    ecs_allocator_t *a,
-    ecs_trav_cache_t *cache);
+    ecs_script_annot_t *result = flecs_ast_new(
+        parser, ecs_script_annot_t, EcsAstAnnotation);
 
-/* Traversal caches for up traversal. Enables searching upwards until an entity
- * with the queried for id has been found. */
+    result->name = name;
+    result->expr = expr;
 
-/* Traverse downwards from starting entity to find all tables for which the
- * specified entity is the source of the queried for id ('with'). */
-ecs_trav_down_t* flecs_rule_get_down_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_up_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_entity_t entity,
-    ecs_id_record_t *idr_with,
-    bool self);
+    flecs_ast_append(parser, scope->stmts, ecs_script_annot_t, result);
+    return result;
+}
 
-/* Free down traversal cache */
-void flecs_rule_down_cache_fini(
-    ecs_allocator_t *a,
-    ecs_trav_up_cache_t *cache);
+ecs_script_assembly_node_t* flecs_script_insert_assembly(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
-ecs_trav_up_t* flecs_rule_get_up_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_up_cache_t *cache,
-    ecs_table_t *table,
-    ecs_id_t with,
-    ecs_entity_t trav,
-    ecs_id_record_t *idr_with,
-    ecs_id_record_t *idr_trav);
+    ecs_script_assembly_node_t *result = flecs_ast_new(
+        parser, ecs_script_assembly_node_t, EcsAstAssembly);
+    result->name = name;
+    result->scope = flecs_script_scope_new(parser);
 
-/* Free up traversal cache */
-void flecs_rule_up_cache_fini(
-    ecs_trav_up_cache_t *cache);
+    flecs_ast_append(parser, scope->stmts, ecs_script_assembly_node_t, result);
+    return result;
+}
 
-/* Convert instruction kind to string */
-const char* flecs_rule_op_str(
-    uint16_t kind);
+ecs_script_var_node_t* flecs_script_insert_var(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
-/* Iterator for trivial queries. */
-bool flecs_rule_trivial_search(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t until);
+    ecs_script_var_node_t *result = flecs_ast_new(
+        parser, ecs_script_var_node_t, EcsAstConst);
+    result->name = name;
 
-/* Iterator for trivial queries. */
-bool flecs_rule_trivial_search_nodata(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t until);
+    flecs_ast_append(parser, scope->stmts, ecs_script_var_node_t, result);
+    return result;
+}
 
-/* Iterator for trivial queries with wildcard matching. */
-bool flecs_rule_trivial_search_w_wildcards(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t until);
+ecs_script_if_t* flecs_script_insert_if(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
 
-/* Trivial test for constrained $this. */
-bool flecs_rule_trivial_test(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    bool first,
-    int32_t term_count);
+    ecs_script_if_t *result = flecs_ast_new(
+        parser, ecs_script_if_t, EcsAstIf);
+    result->if_true = flecs_script_scope_new(parser);
+    result->if_false = flecs_script_scope_new(parser);
 
-/* Trivial test for constrained $this with wildcard matching. */
-bool flecs_rule_trivial_test_w_wildcards(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    bool first,
-    int32_t term_count);
+    flecs_ast_append(parser, scope->stmts, ecs_script_if_t, result);
+    return result;
+}
 
 #endif
 
-#endif /* FLECS_RULES_PRIVATE_H */
+/**
+ * @file addons/script/expr.c
+ * @brief Evaluate script expressions.
+ */
+
 
+#ifdef FLECS_SCRIPT
 #include <ctype.h>
 
-#ifdef FLECS_RULES
+/* String deserializer for script expressions */
 
-static ecs_mixins_t ecs_rule_t_mixins = {
-    .type_name = "ecs_rule_t",
-    .elems = {
-        [EcsMixinWorld] = offsetof(ecs_rule_t, filter.world),
-        [EcsMixinEntity] = offsetof(ecs_rule_t, filter.entity),
-        [EcsMixinIterable] = offsetof(ecs_rule_t, iterable),
-        [EcsMixinDtor] = offsetof(ecs_rule_t, dtor)
-    }
-};
+/* Order in enumeration is important, as it is used for precedence */
+typedef enum ecs_expr_oper_t {
+    EcsExprOperUnknown,
+    EcsLeftParen,
+    EcsCondAnd,
+    EcsCondOr,
+    EcsCondEq,
+    EcsCondNeq,
+    EcsCondGt,
+    EcsCondGtEq,
+    EcsCondLt,
+    EcsCondLtEq,
+    EcsShiftLeft,
+    EcsShiftRight,
+    EcsAdd,
+    EcsSub,
+    EcsMul,
+    EcsDiv,
+    EcsMin
+} ecs_expr_oper_t;
 
-const char* flecs_rule_op_str(
-    uint16_t kind)
-{
-    switch(kind) {
-    case EcsRuleAnd:           return "and     ";
-    case EcsRuleAndId:         return "andid   ";
-    case EcsRuleAndAny:        return "andany  ";
-    case EcsRuleTriv:          return "triv    ";
-    case EcsRuleTrivData:      return "trivpop ";
-    case EcsRuleTrivWildcard:  return "trivwc  ";
-    case EcsRuleSelectAny:     return "any     ";
-    case EcsRuleUp:            return "up      ";
-    case EcsRuleUpId:          return "upid    ";
-    case EcsRuleSelfUp:        return "selfup  ";
-    case EcsRuleSelfUpId:      return "selfupid";
-    case EcsRuleWith:          return "with    ";
-    case EcsRuleTrav:          return "trav    ";
-    case EcsRuleIds:           return "ids     ";
-    case EcsRuleIdsRight:      return "idsr    ";
-    case EcsRuleIdsLeft:       return "idsl    ";
-    case EcsRuleEach:          return "each    ";
-    case EcsRuleStore:         return "store   ";
-    case EcsRuleReset:         return "reset   ";
-    case EcsRuleOr:            return "or      ";
-    case EcsRuleOptional:      return "option  ";
-    case EcsRuleIf:            return "if      ";
-    case EcsRuleEnd:           return "end     ";
-    case EcsRuleNot:           return "not     ";
-    case EcsRulePredEq:        return "eq      ";
-    case EcsRulePredNeq:       return "neq     ";
-    case EcsRulePredEqName:    return "eq_nm   ";
-    case EcsRulePredNeqName:   return "neq_nm  ";
-    case EcsRulePredEqMatch:   return "eq_m    ";
-    case EcsRulePredNeqMatch:  return "neq_m   ";
-    case EcsRuleLookup:        return "lookup  ";
-    case EcsRuleSetVars:       return "setvars ";
-    case EcsRuleSetThis:       return "setthis ";
-    case EcsRuleSetFixed:      return "setfix  ";
-    case EcsRuleSetIds:        return "setids  ";
-    case EcsRuleSetId:         return "setid   ";
-    case EcsRuleContain:       return "contain ";
-    case EcsRulePairEq:        return "pair_eq ";
-    case EcsRulePopulate:      return "pop     ";
-    case EcsRulePopulateSelf:  return "popself ";
-    case EcsRuleYield:         return "yield   ";
-    case EcsRuleNothing:       return "nothing ";
-    default:                   return "!invalid";
-    }
-}
-
-/* Implementation for iterable mixin */
-static
-void flecs_rule_iter_mixin_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter)
-{
-    ecs_poly_assert(poly, ecs_rule_t);
+/* Used to track temporary values */
+#define FLECS_EXPR_MAX_STACK_SIZE (256)
 
-    if (filter) {
-        iter[1] = ecs_rule_iter(world, ECS_CONST_CAST(ecs_rule_t*, poly));
-        iter[0] = ecs_term_chain_iter(&iter[1], filter);
-    } else {
-        iter[0] = ecs_rule_iter(world, ECS_CONST_CAST(ecs_rule_t*, poly));
-    }
-}
+typedef struct ecs_expr_value_t {
+    const ecs_type_info_t *ti;
+    void *ptr;
+} ecs_expr_value_t;
+
+typedef struct ecs_value_stack_t {
+    ecs_expr_value_t values[FLECS_EXPR_MAX_STACK_SIZE];
+    ecs_stack_cursor_t *cursor;
+    ecs_stack_t *stack;
+    ecs_stage_t *stage;
+    int32_t count;
+} ecs_value_stack_t;
 
 static
-void flecs_rule_fini(
-    ecs_rule_t *rule)
-{
-    if (rule->vars != &rule->vars_cache.var) {
-        ecs_os_free(rule->vars);
-    }
+const char* flecs_script_expr_run(
+    ecs_world_t *world,
+    ecs_value_stack_t *stack,
+    const char *ptr,
+    ecs_value_t *value,
+    ecs_expr_oper_t op,
+    const ecs_script_expr_run_desc_t *desc);
 
-    ecs_os_free(rule->ops);
-    ecs_os_free(rule->src_vars);
-    flecs_name_index_fini(&rule->tvar_index);
-    flecs_name_index_fini(&rule->evar_index);
-    ecs_filter_fini(&rule->filter);
+#define TOK_VARIABLE '$'
 
-    ecs_poly_free(rule, ecs_rule_t);
-}
+/* -- Private functions -- */
 
-void ecs_rule_fini(
-    ecs_rule_t *rule)
+static
+bool flecs_isident(
+    char ch)
 {
-    if (rule->filter.entity) {
-        /* If filter is associated with entity, use poly dtor path */
-        ecs_delete(rule->filter.world, rule->filter.entity);
-    } else {
-        flecs_rule_fini(rule);
-    }
+    return isalpha(ch) || (ch == '_');
 }
 
-ecs_rule_t* ecs_rule_init(
-    ecs_world_t *world, 
-    const ecs_filter_desc_t *const_desc)
+static
+bool flecs_valid_identifier_start_char(
+    char ch)
 {
-    ecs_rule_t *result = ecs_poly_new(ecs_rule_t);
-    ecs_stage_t *stage = flecs_stage_from_world(&world);
-
-    /* Initialize the query */
-    ecs_filter_desc_t desc = *const_desc;
-    desc.storage = &result->filter; /* Use storage of rule */
-    result->filter = ECS_FILTER_INIT;
-    if (ecs_filter_init(world, &desc) == NULL) {
-        goto error;
+    if (ch && (flecs_isident(ch) || (ch == '*') ||
+        (ch == '0') || (ch == TOK_VARIABLE) || isdigit(ch))) 
+    {
+        return true;
     }
 
-    result->iterable.init = flecs_rule_iter_mixin_init;
+    return false;
+}
 
-    /* Compile filter to operations */
-    if (flecs_rule_compile(world, stage, result)) {
-        goto error;
+static
+bool flecs_valid_token_start_char(
+    char ch)
+{
+    if ((ch == '"') || (ch == '{') || (ch == '}') || (ch == ',') || (ch == '-')
+        || (ch == '[') || (ch == ']') || (ch == '`') || 
+        flecs_valid_identifier_start_char(ch))
+    {
+        return true;
     }
 
-    ecs_entity_t entity = const_desc->entity;
-    result->dtor = (ecs_poly_dtor_t)flecs_rule_fini;
+    return false;
+}
 
-    if (entity) {
-        EcsPoly *poly = ecs_poly_bind(world, entity, ecs_rule_t);
-        poly->poly = result;
-        ecs_poly_modified(world, entity, ecs_rule_t);
+static
+bool flecs_valid_token_char(
+    char ch)
+{
+    if (ch && (flecs_isident(ch) || isdigit(ch) || ch == '.' || ch == '"')) {
+        return true;
     }
 
-    return result;
-error:
-    ecs_rule_fini(result);
-    return NULL;
+    return false;
 }
 
 static
-int32_t flecs_rule_op_ref_str(
-    const ecs_rule_t *rule,
-    ecs_rule_ref_t *ref,
-    ecs_flags16_t flags,
-    ecs_strbuf_t *buf)
+const char* flecs_parse_ws(
+    const char *ptr)
 {
-    int32_t color_chars = 0;
-    if (flags & EcsRuleIsVar) {
-        ecs_assert(ref->var < rule->var_count, ECS_INTERNAL_ERROR, NULL);
-        ecs_rule_var_t *var = &rule->vars[ref->var];
-        ecs_strbuf_appendlit(buf, "#[green]$#[reset]");
-        if (var->kind == EcsVarTable) {
-            ecs_strbuf_appendch(buf, '[');
-        }
-        ecs_strbuf_appendlit(buf, "#[green]");
-        if (var->name) {
-            ecs_strbuf_appendstr(buf, var->name);
-        } else {
-            if (var->id) {
-#ifdef FLECS_DEBUG
-                if (var->label) {
-                    ecs_strbuf_appendstr(buf, var->label);
-                    ecs_strbuf_appendch(buf, '\'');
-                }
-#endif
-                ecs_strbuf_append(buf, "%d", var->id);
-            } else {
-                ecs_strbuf_appendlit(buf, "this");
-            }
-        }
-        ecs_strbuf_appendlit(buf, "#[reset]");
-        if (var->kind == EcsVarTable) {
-            ecs_strbuf_appendch(buf, ']');
-        }
-        color_chars = ecs_os_strlen("#[green]#[reset]#[green]#[reset]");
-    } else if (flags & EcsRuleIsEntity) {
-        char *path = ecs_get_fullpath(rule->filter.world, ref->entity);
-        ecs_strbuf_appendlit(buf, "#[blue]");
-        ecs_strbuf_appendstr(buf, path);
-        ecs_strbuf_appendlit(buf, "#[reset]");
-        ecs_os_free(path);
-        color_chars = ecs_os_strlen("#[blue]#[reset]");
+    while ((*ptr != '\n') && isspace(*ptr)) {
+        ptr ++;
     }
-    return color_chars;
+
+    return ptr;
 }
 
-char* ecs_rule_str_w_profile(
-    const ecs_rule_t *rule,
-    const ecs_iter_t *it)
+static
+const char* flecs_parse_expr_token(
+    const char *name,
+    const char *expr,
+    const char *ptr,
+    char *token_out,
+    char delim)
 {
-    ecs_poly_assert(rule, ecs_rule_t);
-
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
-    ecs_rule_op_t *ops = rule->ops;
-    int32_t i, count = rule->op_count, indent = 0;
-
-    for (i = 0; i < count; i ++) {
-        ecs_rule_op_t *op = &ops[i];
-        ecs_flags16_t flags = op->flags;
-        ecs_flags16_t src_flags = flecs_rule_ref_flags(flags, EcsRuleSrc);
-        ecs_flags16_t first_flags = flecs_rule_ref_flags(flags, EcsRuleFirst);
-        ecs_flags16_t second_flags = flecs_rule_ref_flags(flags, EcsRuleSecond);
+    int64_t column = ptr - expr;
 
-        if (it) {
-#ifdef FLECS_DEBUG
-            const ecs_rule_iter_t *rit = &it->priv.iter.rule;
-            ecs_strbuf_append(&buf, 
-                "#[green]%4d -> #[red]%4d <- #[grey]  |   ",
-                rit->profile[i].count[0],
-                rit->profile[i].count[1]);
-#endif
-        }
+    ptr = flecs_parse_ws(ptr);
+    char *tptr = token_out, ch = ptr[0];
 
-        ecs_strbuf_append(&buf, 
-            "#[normal]%2d. [#[grey]%2d#[reset], #[green]%2d#[reset]]  ", 
-                i, op->prev, op->next);
-        int32_t hidden_chars, start = ecs_strbuf_written(&buf);
-        if (op->kind == EcsRuleEnd) {
-            indent --;
+    if (!flecs_valid_token_start_char(ch)) {
+        if (ch == '\0' || ch == '\n') {
+            ecs_parser_error(name, expr, column, 
+                "unexpected end of expression");
+        } else {
+            ecs_parser_error(name, expr, column, 
+                "invalid start of token '%s'", ptr);
         }
+        return NULL;
+    }
 
-        ecs_strbuf_append(&buf, "%*s", indent, "");
-        ecs_strbuf_appendstr(&buf, flecs_rule_op_str(op->kind));
-        ecs_strbuf_appendstr(&buf, " ");
+    tptr[0] = ch;
+    tptr ++;
+    ptr ++;
 
-        int32_t written = ecs_strbuf_written(&buf);
-        for (int32_t j = 0; j < (12 - (written - start)); j ++) {
-            ecs_strbuf_appendch(&buf, ' ');
-        }
-    
-        hidden_chars = flecs_rule_op_ref_str(rule, &op->src, src_flags, &buf);
+    if (ch == '{' || ch == '}' || ch == '[' || ch == ']' || ch == ',' || ch == '`') {
+        tptr[0] = 0;
+        return ptr;
+    }
 
-        if (op->kind == EcsRuleNot || 
-            op->kind == EcsRuleOr || 
-            op->kind == EcsRuleOptional || 
-            op->kind == EcsRuleIf) 
-        {
-            indent ++;
-        }
+    int tmpl_nesting = 0;
+    bool in_str = ch == '"';
 
-        if (!first_flags && !second_flags) {
-            ecs_strbuf_appendstr(&buf, "\n");
+    for (; (ch = *ptr); ptr ++) {
+        if (ch == '<') {
+            tmpl_nesting ++;
+        } else if (ch == '>') {
+            if (!tmpl_nesting) {
+                break;
+            }
+            tmpl_nesting --;
+        } else if (ch == '"') {
+            in_str = !in_str;
+        } else if (ch == '\\') {
+            ptr ++;
+            tptr[0] = ptr[0];
+            tptr ++;
             continue;
+        } else if (!flecs_valid_token_char(ch) && !in_str) {
+            break;
         }
 
-        written = ecs_strbuf_written(&buf) - hidden_chars;
-        for (int32_t j = 0; j < (30 - (written - start)); j ++) {
-            ecs_strbuf_appendch(&buf, ' ');
-        }
-
-        if (!first_flags && !second_flags) {
-            ecs_strbuf_appendstr(&buf, "\n");
-            continue;
+        if (delim && (ch == delim)) {
+            break;
         }
 
-        ecs_strbuf_appendstr(&buf, "(");
-        flecs_rule_op_ref_str(rule, &op->first, first_flags, &buf);
-
-        if (second_flags) {
-            ecs_strbuf_appendstr(&buf, ", ");
-            flecs_rule_op_ref_str(rule, &op->second, second_flags, &buf);
-        } else {
-            switch (op->kind) {
-            case EcsRulePredEqName:
-            case EcsRulePredNeqName:
-            case EcsRulePredEqMatch:
-            case EcsRulePredNeqMatch: {
-                int8_t term_index = op->term_index;
-                ecs_strbuf_appendstr(&buf, ", #[yellow]\"");
-                ecs_strbuf_appendstr(&buf, rule->filter.terms[term_index].second.name);
-                ecs_strbuf_appendstr(&buf, "\"#[reset]");
-                break;
-            }
-            case EcsRuleLookup: {
-                ecs_var_id_t src_id = op->src.var;
-                ecs_strbuf_appendstr(&buf, ", #[yellow]\"");
-                ecs_strbuf_appendstr(&buf, rule->vars[src_id].lookup);
-                ecs_strbuf_appendstr(&buf, "\"#[reset]");
-                break;
-            }
-            default:
-                break;
-            }
-        }
+        tptr[0] = ch;
+        tptr ++;
+    }
 
-        ecs_strbuf_appendch(&buf, ')');
+    tptr[0] = '\0';
 
-        ecs_strbuf_appendch(&buf, '\n');
+    if (tmpl_nesting != 0) {
+        ecs_parser_error(name, expr, column, 
+            "identifier '%s' has mismatching < > pairs", ptr);
+        return NULL;
     }
 
-#ifdef FLECS_LOG    
-    char *str = ecs_strbuf_get(&buf);
-    flecs_colorize_buf(str, ecs_os_api.flags_ & EcsOsApiLogWithColors, &buf);
-    ecs_os_free(str);
-#endif
-    return ecs_strbuf_get(&buf);
-}
-
-char* ecs_rule_str(
-    const ecs_rule_t *rule)
-{
-    return ecs_rule_str_w_profile(rule, NULL);
-}
+    const char *next_ptr = flecs_parse_ws(ptr);
+    if (next_ptr[0] == ':' && next_ptr != ptr) {
+        /* Whitespace between token and : is significant */
+        ptr = next_ptr - 1;
+    } else {
+        ptr = next_ptr;
+    }
 
-const ecs_filter_t* ecs_rule_get_filter(
-    const ecs_rule_t *rule)
-{
-    return &rule->filter;
+    return ptr;
 }
 
-const char* ecs_rule_parse_vars(
-    ecs_rule_t *rule,
-    ecs_iter_t *it,
-    const char *expr)
+static
+void* flecs_expr_value_new(
+    ecs_value_stack_t *stack,
+    ecs_entity_t type)
 {
-    ecs_poly_assert(rule, ecs_rule_t);
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(expr != NULL, ECS_INVALID_PARAMETER, NULL)
-    char token[ECS_MAX_TOKEN_SIZE];
-    const char *ptr = expr;
-    bool paren = false;
+    ecs_stage_t *stage = stack->stage;
+    ecs_world_t *world = stage->world;
+    ecs_id_record_t *idr = flecs_id_record_get(world, type);
+    if (!idr) {
+        return NULL;
+    }
 
-    const char *name = NULL;
-    if (rule->filter.entity) {
-        name = ecs_get_name(rule->filter.world, rule->filter.entity);
+    const ecs_type_info_t *ti = idr->type_info;
+    if (!ti) {
+        return NULL;
     }
 
-    ptr = ecs_parse_ws_eol(ptr);
-    if (!ptr[0]) {
-        return ptr;
+    ecs_assert(ti->size != 0, ECS_INTERNAL_ERROR, NULL);
+    void *result = flecs_stack_alloc(stack->stack, ti->size, ti->alignment);
+    if (ti->hooks.ctor) {
+        ti->hooks.ctor(result, 1, ti);
+    } else {
+        ecs_os_memset(result, 0, ti->size);
+    }
+    if (ti->hooks.dtor) {
+        /* Track values that have destructors */
+        stack->values[stack->count].ti = ti;
+        stack->values[stack->count].ptr = result;
+        stack->count ++;
     }
 
-    if (ptr[0] == '(') {
-        paren = true;
-        ptr = ecs_parse_ws_eol(ptr + 1);
-        if (ptr[0] == ')') {
-            return ptr + 1;
-        }
+    return result;
+}
+
+static
+const char* flecs_str_to_expr_oper(
+    const char *str,
+    ecs_expr_oper_t *op)
+{
+    if (!ecs_os_strncmp(str, "+", 1)) {
+        *op = EcsAdd;
+        return str + 1;
+    } else if (!ecs_os_strncmp(str, "-", 1)) {
+        *op = EcsSub;
+        return str + 1;
+    } else if (!ecs_os_strncmp(str, "*", 1)) {
+        *op = EcsMul;
+        return str + 1;
+    } else if (!ecs_os_strncmp(str, "/", 1)) {
+        *op = EcsDiv;
+        return str + 1;
+    } else if (!ecs_os_strncmp(str, "&&", 2)) {
+        *op = EcsCondAnd;
+        return str + 2;
+    } else if (!ecs_os_strncmp(str, "||", 2)) {
+        *op = EcsCondOr;
+        return str + 2;
+    } else if (!ecs_os_strncmp(str, "==", 2)) {
+        *op = EcsCondEq;
+        return str + 2;
+    } else if (!ecs_os_strncmp(str, "!=", 2)) {
+        *op = EcsCondNeq;
+        return str + 2;
+    } else if (!ecs_os_strncmp(str, ">=", 2)) {
+        *op = EcsCondGtEq;
+        return str + 2;
+    } else if (!ecs_os_strncmp(str, "<=", 2)) {
+        *op = EcsCondLtEq;
+        return str + 2;
+    } else if (!ecs_os_strncmp(str, ">>", 2)) {
+        *op = EcsShiftRight;
+        return str + 2;
+    } else if (!ecs_os_strncmp(str, "<<", 2)) {
+        *op = EcsShiftLeft;
+        return str + 2;
+    } else if (!ecs_os_strncmp(str, ">", 1)) {
+        *op = EcsCondGt;
+        return str + 1;
+    } else if (!ecs_os_strncmp(str, "<", 1)) {
+        *op = EcsCondLt;
+        return str + 1;
     }
 
-    do {
-        ptr = ecs_parse_ws_eol(ptr);
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            return NULL;
-        }
+    *op = EcsExprOperUnknown;
+    return NULL;
+}
 
-        int var = ecs_rule_find_var(rule, token);
-        if (var == -1) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unknown variable '%s'", token);
-            return NULL;
-        }
+static
+const char *flecs_script_expr_parse_token(
+    const char *name,
+    const char *expr,
+    const char *ptr,
+    char *token)
+{
+    char *token_ptr = token;
 
-        ptr = ecs_parse_ws_eol(ptr);
-        if (ptr[0] != ':') {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "missing ':'");
-            return NULL;
-        }
+    if (ptr[0] == '/') {
+        char ch;
+        if (ptr[1] == '/') {
+            // Single line comment
+            for (ptr = &ptr[2]; (ch = ptr[0]) && (ch != '\n'); ptr ++) {}
+            token[0] = 0;
+            return flecs_parse_ws_eol(ptr);
+        } else if (ptr[1] == '*') {
+            // Multi line comment
+            for (ptr = &ptr[2]; (ch = ptr[0]); ptr ++) {
+                if (ch == '*' && ptr[1] == '/') {
+                    token[0] = 0;
+                    return flecs_parse_ws_eol(ptr + 2);
+                }
+            }
 
-        ptr = ecs_parse_ws_eol(ptr + 1);
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
+            ecs_parser_error(name, expr, ptr - expr, 
+                "missing */ for multiline comment");
             return NULL;
         }
+    }
 
-        ecs_entity_t val = ecs_lookup(rule->filter.world, token);
-        if (!val) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unresolved entity '%s'", token);
-            return NULL;
+    ecs_expr_oper_t op;
+    if (ptr[0] == '(') {
+        token[0] = '(';
+        token[1] = 0;
+        return ptr + 1;
+    } else if (ptr[0] != '-') {
+        const char *tptr = flecs_str_to_expr_oper(ptr, &op);
+        if (tptr) {
+            ecs_os_strncpy(token, ptr, tptr - ptr);
+            return tptr;
         }
+    }
 
-        ecs_iter_set_var(it, var, val);
-
-        ptr = ecs_parse_ws_eol(ptr);
-        if (ptr[0] == ')') {
-            if (!paren) {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "unexpected closing parenthesis");
-                return NULL;
-            }
-
-            ptr ++;
-            break;
-        } else if (ptr[0] == ',') {
-            ptr ++;
-        } else if (!ptr[0]) {
-            if (paren) {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "missing closing parenthesis");
-                return NULL;
-            }
-            break;
+    while ((ptr = flecs_parse_expr_token(name, expr, ptr, token_ptr, 0))) {
+        if (ptr[0] == '|' && ptr[1] != '|') {
+            token_ptr = &token_ptr[ecs_os_strlen(token_ptr)];
+            token_ptr[0] = '|';
+            token_ptr[1] = '\0';
+            token_ptr ++;
+            ptr ++;
         } else {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "expected , or end of string");
-            return NULL;
+            break;
         }
-    } while (true);
+    }
 
     return ptr;
-error:
-    return NULL;
-}
-
-#endif
-
-/**
- * @file addons/rules/compile.c
- * @brief Compile rule program from filter.
- */
-
-
-#ifdef FLECS_RULES
-
-#define FlecsRuleOrMarker ((int16_t)-2) /* Marks instruction in OR chain */
-
-ecs_rule_lbl_t flecs_itolbl(int64_t val) {
-    return flecs_ito(int16_t, val);
 }
 
 static
-ecs_var_id_t flecs_itovar(int64_t val) {
-    return flecs_ito(uint8_t, val);
-}
+const char* flecs_parse_multiline_string(
+    ecs_meta_cursor_t *cur,
+    const char *name,
+    const char *expr,
+    const char *ptr)
+{
+    /* Multiline string */
+    ecs_strbuf_t str = ECS_STRBUF_INIT;
+    char ch;
+    while ((ch = ptr[0]) && (ch != '`')) {
+        if (ch == '\\' && ptr[1] == '`') {
+            ch = '`';
+            ptr ++;
+        }
+        ecs_strbuf_appendch(&str, ch);
+        ptr ++;
+    }
+    
+    if (ch != '`') {
+        ecs_parser_error(name, expr, ptr - expr, 
+            "missing '`' to close multiline string");
+        goto error;
+    }
+    char *strval = ecs_strbuf_get(&str);
+    if (ecs_meta_set_string(cur, strval) != 0) {
+        goto error;
+    }
+    ecs_os_free(strval);
 
-static
-ecs_var_id_t flecs_utovar(uint64_t val) {
-    return flecs_uto(uint8_t, val);
+    return ptr + 1;
+error:
+    return NULL;
 }
 
-#ifdef FLECS_DEBUG
-#define flecs_set_var_label(var, lbl) (var)->label = lbl
-#else
-#define flecs_set_var_label(var, lbl)
-#endif
-
 static
-bool flecs_rule_is_builtin_pred(
-    ecs_term_t *term)
+bool flecs_parse_is_float(
+    const char *ptr)
 {
-    if (term->first.flags & EcsIsEntity) {
-        ecs_entity_t id = term->first.id;
-        if (id == EcsPredEq || id == EcsPredMatch || id == EcsPredLookup) {
+    ecs_assert(isdigit(ptr[0]), ECS_INTERNAL_ERROR, NULL);
+    char ch;
+    while ((ch = (++ptr)[0])) {
+        if (ch == '.' || ch == 'e') {
             return true;
         }
+        if (!isdigit(ch)) {
+            return false;
+        }
     }
     return false;
 }
 
-bool flecs_rule_is_written(
-    ecs_var_id_t var_id,
-    uint64_t written)
+/* Attempt to resolve variable dotexpression to value (foo.bar) */
+static
+ecs_value_t flecs_dotresolve_var(
+    ecs_world_t *world,
+    ecs_script_vars_t *vars,
+    char *token)
 {
-    if (var_id == EcsVarNone) {
-        return true;
+    char *dot = strchr(token, '.');
+    if (!dot) {
+        return (ecs_value_t){ .type = ecs_id(ecs_entity_t) };
     }
 
-    ecs_assert(var_id < EcsRuleMaxVarCount, ECS_INTERNAL_ERROR, NULL);
-    return (written & (1ull << var_id)) != 0;
-}
+    dot[0] = '\0';
 
-static
-void flecs_rule_write(
-    ecs_var_id_t var_id,
-    uint64_t *written)
-{
-    ecs_assert(var_id < EcsRuleMaxVarCount, ECS_INTERNAL_ERROR, NULL);
-    *written |= (1ull << var_id);
+    const ecs_script_var_t *var = ecs_script_vars_lookup(vars, token);
+    if (!var) {
+        return (ecs_value_t){0};
+    }
+
+    ecs_meta_cursor_t cur = ecs_meta_cursor(
+        world, var->value.type, var->value.ptr);
+    ecs_meta_push(&cur);
+    if (ecs_meta_dotmember(&cur, dot + 1) != 0) {
+        return (ecs_value_t){0};
+    }
+
+    return (ecs_value_t){ 
+        .ptr = ecs_meta_get_ptr(&cur),
+        .type = ecs_meta_get_type(&cur)
+    };
 }
 
 static
-void flecs_rule_write_ctx(
-    ecs_var_id_t var_id,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
+int flecs_meta_call(
+    ecs_world_t *world,
+    ecs_value_stack_t *stack,
+    const char *name,
+    const char *expr,
+    const char *ptr,
+    ecs_meta_cursor_t *cur, 
+    const char *function) 
 {
-    bool is_written = flecs_rule_is_written(var_id, ctx->written);
-    flecs_rule_write(var_id, &ctx->written);
-    if (!is_written) {
-        if (cond_write) {
-            flecs_rule_write(var_id, &ctx->cond_written);
+    ecs_entity_t type = ecs_meta_get_type(cur);
+    void *value_ptr = ecs_meta_get_ptr(cur);
+
+    if (!ecs_os_strcmp(function, "parent")) {
+        if (type != ecs_id(ecs_entity_t)) {
+            ecs_parser_error(name, expr, ptr - expr, 
+                "parent() can only be called on entity");
+            return -1;
         }
-    }
-}
 
-ecs_flags16_t flecs_rule_ref_flags(
-    ecs_flags16_t flags,
-    ecs_flags16_t kind)
-{
-    return (flags >> kind) & (EcsRuleIsVar | EcsRuleIsEntity);
-}
+        *(ecs_entity_t*)value_ptr = ecs_get_parent(
+            world, *(ecs_entity_t*)value_ptr);
+    } else if (!ecs_os_strcmp(function, "name")) {
+        if (type != ecs_id(ecs_entity_t)) {
+            ecs_parser_error(name, expr, ptr - expr, 
+                "name() can only be called on entity");
+            return -1;
+        }
 
-bool flecs_ref_is_written(
-    const ecs_rule_op_t *op,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t kind,
-    uint64_t written)
-{
-    ecs_flags16_t flags = flecs_rule_ref_flags(op->flags, kind);
-    if (flags & EcsRuleIsEntity) {
-        ecs_assert(!(flags & EcsRuleIsVar), ECS_INTERNAL_ERROR, NULL);
-        if (ref->entity) {
-            return true;
+        char **result = flecs_expr_value_new(stack, ecs_id(ecs_string_t));
+        *result = ecs_os_strdup(ecs_get_name(world, *(ecs_entity_t*)value_ptr));
+        *cur = ecs_meta_cursor(world, ecs_id(ecs_string_t), result);
+    } else if (!ecs_os_strcmp(function, "doc_name")) {
+#ifdef FLECS_DOC
+        if (type != ecs_id(ecs_entity_t)) {
+            ecs_parser_error(name, expr, ptr - expr, 
+                "name() can only be called on entity");
+            return -1;
         }
-    } else if (flags & EcsRuleIsVar) {
-        return flecs_rule_is_written(ref->var, written);
+
+        char **result = flecs_expr_value_new(stack, ecs_id(ecs_string_t));
+        *result = ecs_os_strdup(ecs_doc_get_name(world, *(ecs_entity_t*)value_ptr));
+        *cur = ecs_meta_cursor(world, ecs_id(ecs_string_t), result);
+#else
+        ecs_parser_error(name, expr, ptr - expr, 
+            "doc_name() is not available without FLECS_DOC addon");
+        return -1;
+#endif
+    } else {
+        ecs_parser_error(name, expr, ptr - expr, 
+            "unknown function '%s'", function);
+        return -1;
     }
-    return false;
-}
 
-static
-bool flecs_rule_var_is_anonymous(
-    const ecs_rule_t *rule,
-    ecs_var_id_t var_id)
-{
-    ecs_rule_var_t *var = &rule->vars[var_id];
-    return var->anonymous;
+    return 0;
 }
 
+/* Determine the type of an expression from the first character(s). This allows
+ * us to initialize a storage for a type if none was provided. */
 static
-ecs_var_id_t flecs_rule_find_var_id(
-    const ecs_rule_t *rule,
+ecs_entity_t flecs_parse_discover_type(
+    ecs_world_t *world,
     const char *name,
-    ecs_var_kind_t kind)
+    const char *expr,
+    const char *ptr,
+    ecs_entity_t input_type,
+    const ecs_script_expr_run_desc_t *desc)
 {
-    ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL);
+    /* String literal */
+    if (ptr[0] == '"' || ptr[0] == '`') {
+        if (input_type == ecs_id(ecs_char_t)) {
+            return input_type;
+        }
+        return ecs_id(ecs_string_t);
+    }
 
-    /* Backwards compatibility */
-    if (!ecs_os_strcmp(name, "This")) {
-        name = "this";
+    /* Negative number literal */
+    if (ptr[0] == '-') {
+        if (!isdigit(ptr[1])) {
+            ecs_parser_error(name, expr, ptr - expr, "invalid literal");
+            return 0;
+        }
+        if (flecs_parse_is_float(ptr + 1)) {
+            return ecs_id(ecs_f64_t);
+        } else {
+            return ecs_id(ecs_i64_t);
+        }
     }
 
-    if (kind == EcsVarTable) {
-        if (!ecs_os_strcmp(name, EcsThisName)) {
-            if (rule->has_table_this) {
-                return 0;
-            } else {
-                return EcsVarNone;
-            }
+    /* Positive number literal */
+    if (isdigit(ptr[0])) {
+        if (flecs_parse_is_float(ptr)) {
+            return ecs_id(ecs_f64_t);
+        } else {
+            return ecs_id(ecs_u64_t);
         }
+    }
 
-        if (!flecs_name_index_is_init(&rule->tvar_index)) {
-            return EcsVarNone;
+    /* Variable */
+    if (ptr[0] == '$') {
+        if (!desc || !desc->vars) {
+            ecs_parser_error(name, expr, ptr - expr, 
+                "unresolved variable (no variable scope)");
+            return 0;
+        }
+        char token[ECS_MAX_TOKEN_SIZE];
+        if (flecs_script_expr_parse_token(name, expr, &ptr[1], token) == NULL) {
+            return 0;
         }
 
-        uint64_t index = flecs_name_index_find(
-            &rule->tvar_index, name, 0, 0);
-        if (index == 0) {
-            return EcsVarNone;
+        const ecs_script_var_t *var = ecs_script_vars_lookup(desc->vars, token);
+        if (!var) {
+            ecs_size_t len = ecs_os_strlen(token);
+            if (ptr[len + 1] == '(') {
+                while ((len > 0) && (token[len] != '.')) {
+                    len --;
+                }
+                if (token[len] == '.') {
+                    token[len] = '\0';
+                }
+            }
+
+            ecs_value_t v = flecs_dotresolve_var(world, desc->vars, token);
+            if (v.type) {
+                return v.type;
+            }
+
+            ecs_parser_error(name, expr, ptr - expr, 
+                "unresolved variable '%s'", token);
+            return 0;
         }
-        return flecs_utovar(index);
+        return var->value.type;
     }
 
-    if (kind == EcsVarEntity) {
-        if (!flecs_name_index_is_init(&rule->evar_index)) {
-            return EcsVarNone;
+    /* Boolean */
+    if (ptr[0] == 't' && !ecs_os_strncmp(ptr, "true", 4)) {
+        if (!isalpha(ptr[4]) && ptr[4] != '_') {
+            return ecs_id(ecs_bool_t);
+        }
+    }
+    if (ptr[0] == 'f' && !ecs_os_strncmp(ptr, "false", 5)) {
+        if (!isalpha(ptr[5]) && ptr[5] != '_') {
+            return ecs_id(ecs_bool_t);
         }
+    }
 
-        uint64_t index = flecs_name_index_find(
-            &rule->evar_index, name, 0, 0);
-        if (index == 0) {
-            return EcsVarNone;
+    /* Entity identifier */
+    if (isalpha(ptr[0])) {
+        if (!input_type) { /* Identifier could also be enum/bitmask constant */
+            return ecs_id(ecs_entity_t);
         }
-        return flecs_utovar(index);
     }
 
-    ecs_assert(kind == EcsVarAny, ECS_INTERNAL_ERROR, NULL);
+    /* If no default type was provided we can't automatically deduce the type of
+     * composite/collection expressions. */
+    if (!input_type) {
+        if (ptr[0] == '{') {
+            ecs_parser_error(name, expr, ptr - expr,
+                "unknown type for composite literal");
+            return 0;
+        }
 
-    /* If searching for any kind of variable, start with most specific */
-    ecs_var_id_t index = flecs_rule_find_var_id(rule, name, EcsVarEntity);
-    if (index != EcsVarNone) {
-        return index;
-    }
+        if (ptr[0] == '[') {
+            ecs_parser_error(name, expr, ptr - expr,
+                "unknown type for collection literal");
+            return 0;
+        }
 
-    return flecs_rule_find_var_id(rule, name, EcsVarTable);
-}
+        ecs_parser_error(name, expr, ptr - expr, "invalid expression");
+    }
 
-int32_t ecs_rule_var_count(
-    const ecs_rule_t *rule)
-{
-    return rule->var_pub_count;
+    return input_type;
 }
 
-int32_t ecs_rule_find_var(
-    const ecs_rule_t *rule,
-    const char *name)
+/* Normalize types to their largest representation.
+ * Rather than taking the original type of a value, use the largest 
+ * representation of the type so we don't have to worry about overflowing the
+ * original type in the operation. */
+static
+ecs_entity_t flecs_largest_type(
+    const EcsPrimitive *type)
 {
-    ecs_var_id_t var_id = flecs_rule_find_var_id(rule, name, EcsVarEntity);
-    if (var_id == EcsVarNone) {
-        if (rule->filter.flags & EcsFilterMatchThis) {
-            if (!ecs_os_strcmp(name, "This")) {
-                name = "this";
-            }
-            if (!ecs_os_strcmp(name, EcsThisName)) {
-                var_id = 0;
-            }
-        }
-        if (var_id == EcsVarNone) {
-            return -1;
-        }
+    switch(type->kind) {
+    case EcsBool:   return ecs_id(ecs_bool_t);
+    case EcsChar:   return ecs_id(ecs_char_t);
+    case EcsByte:   return ecs_id(ecs_u8_t);
+    case EcsU8:     return ecs_id(ecs_u64_t);
+    case EcsU16:    return ecs_id(ecs_u64_t);
+    case EcsU32:    return ecs_id(ecs_u64_t);
+    case EcsU64:    return ecs_id(ecs_u64_t);
+    case EcsI8:     return ecs_id(ecs_i64_t);
+    case EcsI16:    return ecs_id(ecs_i64_t);
+    case EcsI32:    return ecs_id(ecs_i64_t);
+    case EcsI64:    return ecs_id(ecs_i64_t);
+    case EcsF32:    return ecs_id(ecs_f64_t);
+    case EcsF64:    return ecs_id(ecs_f64_t);
+    case EcsUPtr:   return ecs_id(ecs_u64_t);
+    case EcsIPtr:   return ecs_id(ecs_i64_t);
+    case EcsString: return ecs_id(ecs_string_t);
+    case EcsEntity: return ecs_id(ecs_entity_t);
+    case EcsId:     return ecs_id(ecs_id_t);
+    default: ecs_throw(ECS_INTERNAL_ERROR, NULL);
     }
-    return (int32_t)var_id;
+error:
+    return 0;
 }
 
-const char* ecs_rule_var_name(
-    const ecs_rule_t *rule,
-    int32_t var_id)
+/** Test if a normalized type can promote to another type in an expression */
+static
+bool flecs_is_type_number(
+    ecs_entity_t type)
 {
-    if (var_id) {
-        return rule->vars[var_id].name;
-    } else {
-        return EcsThisName;
-    }
+    if      (type == ecs_id(ecs_bool_t)) return false;
+    else if (type == ecs_id(ecs_char_t)) return false;
+    else if (type == ecs_id(ecs_u8_t)) return false;
+    else if (type == ecs_id(ecs_u64_t)) return true;
+    else if (type == ecs_id(ecs_i64_t)) return true;
+    else if (type == ecs_id(ecs_f64_t)) return true;
+    else if (type == ecs_id(ecs_string_t)) return false;
+    else if (type == ecs_id(ecs_entity_t)) return false;
+    else return false;
 }
 
-bool ecs_rule_var_is_entity(
-    const ecs_rule_t *rule,
-    int32_t var_id)
+static
+bool flecs_oper_valid_for_type(
+    ecs_entity_t type,
+    ecs_expr_oper_t op)
 {
-    return rule->vars[var_id].kind == EcsVarEntity;
+    switch(op) {
+    case EcsAdd:
+    case EcsSub:
+    case EcsMul:
+    case EcsDiv:
+        return flecs_is_type_number(type);
+    case EcsCondEq:
+    case EcsCondNeq:
+    case EcsCondAnd:
+    case EcsCondOr:
+    case EcsCondGt:
+    case EcsCondGtEq:
+    case EcsCondLt:
+    case EcsCondLtEq:
+        return flecs_is_type_number(type) ||
+            (type == ecs_id(ecs_bool_t)) ||
+            (type == ecs_id(ecs_char_t)) ||
+            (type == ecs_id(ecs_entity_t));
+    case EcsShiftLeft:
+    case EcsShiftRight:
+        return (type == ecs_id(ecs_u64_t));
+    case EcsExprOperUnknown:
+    case EcsLeftParen:
+    case EcsMin:
+        return false;
+    default: 
+        ecs_abort(ECS_INTERNAL_ERROR, NULL);
+    }
 }
 
+/** Promote type to most expressive (f64 > i64 > u64) */
 static
-const char* flecs_term_id_var_name(
-    ecs_term_id_t *term_id)
+ecs_entity_t flecs_promote_type(
+    ecs_entity_t type,
+    ecs_entity_t promote_to)
 {
-    if (!(term_id->flags & EcsIsVariable)) {
-        return NULL;
+    if (type == ecs_id(ecs_u64_t)) {
+        return promote_to;
     }
-
-    if (term_id->id == EcsThis) {
-        return EcsThisName;
+    if (promote_to == ecs_id(ecs_u64_t)) {
+        return type;
     }
-
-    return term_id->name;
+    if (type == ecs_id(ecs_f64_t)) {
+        return type;
+    }
+    if (promote_to == ecs_id(ecs_f64_t)) {
+        return promote_to;
+    }
+    return ecs_id(ecs_i64_t);
 }
 
 static
-bool flecs_term_id_is_wildcard(
-    ecs_term_id_t *term_id)
+int flecs_oper_precedence(
+    ecs_expr_oper_t left,
+    ecs_expr_oper_t right)
 {
-    if ((term_id->flags & EcsIsVariable) && 
-        ((term_id->id == EcsWildcard) || (term_id->id == EcsAny))) 
-    {
-        return true;
-    }
-    return false;
+    return (left > right) - (left < right);
 }
 
 static
-ecs_var_id_t flecs_rule_add_var(
-    ecs_rule_t *rule,
-    const char *name,
-    ecs_vec_t *vars,
-    ecs_var_kind_t kind)
+void flecs_value_cast(
+    ecs_world_t *world,
+    ecs_value_stack_t *stack,
+    ecs_value_t *value,
+    ecs_entity_t type)
 {
-    const char *dot = NULL;
-    if (name) {
-        dot = strchr(name, '.');
-        if (dot) {
-            kind = EcsVarEntity; /* lookup variables are always entities */
-        }
-    }
-
-    ecs_hashmap_t *var_index = NULL;
-    ecs_var_id_t var_id = EcsVarNone;
-    if (name) {
-        if (kind == EcsVarAny) {
-            var_id = flecs_rule_find_var_id(rule, name, EcsVarEntity);
-            if (var_id != EcsVarNone) {
-                return var_id;
-            }
-
-            var_id = flecs_rule_find_var_id(rule, name, EcsVarTable);
-            if (var_id != EcsVarNone) {
-                return var_id;
-            }
-
-            kind = EcsVarTable;
-        } else {
-            var_id = flecs_rule_find_var_id(rule, name, kind);
-            if (var_id != EcsVarNone) {
-                return var_id;
-            }
-        }
-
-        if (kind == EcsVarTable) {
-            var_index = &rule->tvar_index;
-        } else {
-            var_index = &rule->evar_index;
-        }
-
-        /* If we're creating an entity var, check if it has a table variant */
-        if (kind == EcsVarEntity && var_id == EcsVarNone) {
-            var_id = flecs_rule_find_var_id(rule, name, EcsVarTable);
-        }
-    }
-
-    ecs_rule_var_t *var;
-    ecs_var_id_t result;
-    if (vars) {
-        var = ecs_vec_append_t(NULL, vars, ecs_rule_var_t);
-        result = var->id = flecs_itovar(ecs_vec_count(vars));
-    } else {
-        ecs_dbg_assert(rule->var_count < rule->var_size, 
-            ECS_INTERNAL_ERROR, NULL);
-        var = &rule->vars[rule->var_count];
-        result = var->id = flecs_itovar(rule->var_count);
-        rule->var_count ++;
+    if (value->type == type) {
+        return;
     }
 
-    var->kind = flecs_ito(int8_t, kind);
-    var->name = name;
-    var->table_id = var_id;
-    var->base_id = 0;
-    var->lookup = NULL;
-    flecs_set_var_label(var, NULL);
-
-    if (name) {
-        flecs_name_index_init_if(var_index, NULL);
-        flecs_name_index_ensure(var_index, var->id, name, 0, 0);
-        var->anonymous = name[0] == '_';
+    ecs_value_t result;
+    result.type = type;
+    result.ptr = flecs_expr_value_new(stack, type);
 
-        /* Handle variables that require a by-name lookup, e.g. $this.wheel */
-        if (dot != NULL) {
-            ecs_assert(var->table_id == EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-            var->lookup = dot + 1;
-        }
+    if (value->ptr) {
+        ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, result.ptr);
+        ecs_meta_set_value(&cur, value);
     }
 
-    return result;
+    *value = result;
 }
 
 static
-ecs_var_id_t flecs_rule_add_var_for_term_id(
-    ecs_rule_t *rule,
-    ecs_term_id_t *term_id,
-    ecs_vec_t *vars,
-    ecs_var_kind_t kind)
+bool flecs_expr_op_is_equality(
+    ecs_expr_oper_t op)
 {
-    const char *name = flecs_term_id_var_name(term_id);
-    if (!name) {
-        return EcsVarNone;
+    switch(op) {
+    case EcsCondEq:
+    case EcsCondNeq:
+    case EcsCondGt:
+    case EcsCondGtEq:
+    case EcsCondLt:
+    case EcsCondLtEq:
+        return true;
+    case EcsCondAnd:
+    case EcsCondOr:
+    case EcsShiftLeft:
+    case EcsShiftRight:
+    case EcsAdd:
+    case EcsSub:
+    case EcsMul:
+    case EcsDiv:
+    case EcsExprOperUnknown:
+    case EcsLeftParen:
+    case EcsMin:
+        return false;
+    default:
+        ecs_throw(ECS_INTERNAL_ERROR, "invalid operator");
     }
-
-    return flecs_rule_add_var(rule, name, vars, kind);
+error:
+    return false;
 }
 
-/* This function walks over terms to discover which variables are used in the
- * query. It needs to provide the following functionality:
- * - create table vars for all variables used as source
- * - create entity vars for all variables not used as source
- * - create entity vars for all non-$this vars
- * - create anonymous vars to store the content of wildcards
- * - create anonymous vars to store result of lookups (for $var.child_name)
- * - create anonymous vars for resolving component inheritance
- * - create array that stores the source variable for each field
- * - ensure table vars for non-$this variables are anonymous
- * - ensure variables created inside scopes are anonymous
- * - place anonymous variables after public variables in vars array
- */
 static
-int flecs_rule_discover_vars(
-    ecs_stage_t *stage,
-    ecs_rule_t *rule)
+ecs_entity_t flecs_binary_expr_type(
+    ecs_world_t *world,
+    const char *name,
+    const char *expr,
+    const char *ptr,
+    ecs_value_t *lvalue,
+    ecs_value_t *rvalue,
+    ecs_expr_oper_t op,
+    ecs_entity_t *operand_type_out)
 {
-    ecs_vec_t *vars = &stage->variables; /* Buffer to reduce allocs */
-    ecs_vec_reset_t(NULL, vars, ecs_rule_var_t);
+    ecs_entity_t result_type = 0, operand_type = 0;
 
-    ecs_term_t *terms = rule->filter.terms;
-    int32_t a, i, anonymous_count = 0, count = rule->filter.term_count;
-    int32_t anonymous_table_count = 0, scope = 0, scoped_var_index = 0;
-    bool table_this = false, entity_before_table_this = false;
+    switch(op) {
+    case EcsDiv: 
+        /* Result type of a division is always a float */
+        *operand_type_out = ecs_id(ecs_f64_t);
+        return ecs_id(ecs_f64_t);
+    case EcsCondAnd:
+    case EcsCondOr:
+        /* Result type of a condition operator is always a bool */
+        *operand_type_out = ecs_id(ecs_bool_t);
+        return ecs_id(ecs_bool_t);
+    case EcsCondEq:
+    case EcsCondNeq:
+    case EcsCondGt:
+    case EcsCondGtEq:
+    case EcsCondLt:
+    case EcsCondLtEq:
+        /* Result type of equality operator is always bool, but operand types
+         * should not be casted to bool */
+        result_type = ecs_id(ecs_bool_t);
+        break;
+    case EcsShiftLeft:
+    case EcsShiftRight:
+    case EcsAdd:
+    case EcsSub:
+    case EcsMul:
+    case EcsExprOperUnknown:
+    case EcsLeftParen:
+    case EcsMin:
+        break;
+    default:
+        ecs_throw(ECS_INTERNAL_ERROR, "invalid operator");
+    }
 
-    /* For This table lookups during discovery. This will be overwritten after
-     * discovery with whether the rule actually has a This table variable. */
-    rule->has_table_this = true;
+    /* Result type for arithmetic operators is determined by operands */
+    const EcsPrimitive *ltype_ptr = ecs_get(world, lvalue->type, EcsPrimitive);
+    const EcsPrimitive *rtype_ptr = ecs_get(world, rvalue->type, EcsPrimitive);
+    if (!ltype_ptr || !rtype_ptr) {
+        char *lname = ecs_get_fullpath(world, lvalue->type);
+        char *rname = ecs_get_fullpath(world, rvalue->type);
+        ecs_parser_error(name, expr, ptr - expr, 
+            "invalid non-primitive type in binary expression (%s, %s)",
+                lname, rname);
+        ecs_os_free(lname);
+        ecs_os_free(rname);
+        return 0;
+    }
 
-    for (i = 0; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-        ecs_term_id_t *first = &term->first;
-        ecs_term_id_t *second = &term->second;
-        ecs_term_id_t *src = &term->src;
+    ecs_entity_t ltype = flecs_largest_type(ltype_ptr);
+    ecs_entity_t rtype = flecs_largest_type(rtype_ptr);
+    if (ltype == rtype) {
+        operand_type = ltype;
+        goto done;
+    }
 
-        if (first->id == EcsScopeOpen) {
-            /* Keep track of which variables are first used in scope, so that we
-             * can mark them as anonymous. Terms inside a scope are collapsed 
-             * into a single result, which means that outside of the scope the
-             * value of those variables is undefined. */
-            if (!scope) {
-                scoped_var_index = ecs_vec_count(vars);
-            }
-            scope ++;
-            continue;
-        } else if (first->id == EcsScopeClose) {
-            if (!--scope) {
-                /* Any new variables declared after entering a scope should be
-                 * marked as anonymous. */
-                int32_t v;
-                for (v = scoped_var_index; v < ecs_vec_count(vars); v ++) {
-                    ecs_vec_get_t(vars, ecs_rule_var_t, v)->anonymous = true;
-                }
-            }
-            continue;
-        }
+    if (flecs_expr_op_is_equality(op)) {
+        ecs_parser_error(name, expr, ptr - expr, 
+            "mismatching types in equality expression");
+        return 0;
+    }
 
-        ecs_var_id_t first_var_id = flecs_rule_add_var_for_term_id(
-            rule, first, vars, EcsVarEntity);
-        if (first_var_id == EcsVarNone) {
-            /* If first is not a variable, check if we need to insert anonymous
-             * variable for resolving component inheritance */
-            if (term->flags & EcsTermIdInherited) {
-                anonymous_count += 2; /* table & entity variable */
-            }
+    if (!flecs_is_type_number(ltype) || !flecs_is_type_number(rtype)) {
+        ecs_parser_error(name, expr, ptr - expr, 
+            "incompatible types in binary expression");
+        return 0;
+    }
 
-            /* If first is a wildcard, insert anonymous variable */
-            if (flecs_term_id_is_wildcard(first)) {
-                anonymous_count ++;
-            }
-        }
+    operand_type = flecs_promote_type(ltype, rtype);
 
-        if ((src->flags & EcsIsVariable) && (src->id != EcsThis)) {
-            const char *var_name = flecs_term_id_var_name(src);
-            if (var_name) {
-                ecs_var_id_t var_id = flecs_rule_find_var_id(
-                    rule, var_name, EcsVarEntity);
-                if (var_id == EcsVarNone || var_id == first_var_id) {
-                    var_id = flecs_rule_add_var(
-                        rule, var_name, vars, EcsVarEntity);
-                }
+done:
+    if (op == EcsSub && operand_type == ecs_id(ecs_u64_t)) {
+        /* Result of subtracting two unsigned ints can be negative */
+        operand_type = ecs_id(ecs_i64_t);
+    }
 
-                if (var_id != EcsVarNone) {
-                    /* Mark variable as one for which we need to create a table
-                     * variable. Don't create table variable now, so that we can
-                     * store it in the non-public part of the variable array. */
-                    ecs_rule_var_t *var = ecs_vec_get_t(
-                        vars, ecs_rule_var_t, (int32_t)var_id - 1);
-                    ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL);
-                    if (!var->lookup) {
-                        var->kind = EcsVarAny;
-                        anonymous_table_count ++;
-                    }
+    if (!result_type) {
+        result_type = operand_type;
+    }
 
-                    if (!(term->flags & EcsTermNoData)) {
-                        /* Can't have an anonymous variable as source of a term
-                         * that returns a component. We need to return each
-                         * instance of the component, whereas anonymous 
-                         * variables are not guaranteed to be resolved to 
-                         * individual entities. */
-                        if (var->anonymous) {
-                            ecs_err(
-                                "can't use anonymous variable '%s' as source of "
-                                "data term", var->name);
-                            goto error;
-                        }
-                    }
+    *operand_type_out = operand_type;
+    return result_type;
+error:
+    return 0;
+}
 
-                    /* Track which variable ids are used as field source */
-                    if (!rule->src_vars) {
-                        rule->src_vars = ecs_os_calloc_n(ecs_var_id_t,
-                            rule->filter.field_count);
-                    }
+/* Macro's to let the compiler do the operations & conversion work for us */
 
-                    rule->src_vars[term->field_index] = var_id;
-                }
-            } else {
-                if (flecs_term_id_is_wildcard(src)) {
-                    anonymous_count ++;
-                }
-            }
-        } else if ((src->flags & EcsIsVariable) && (src->id == EcsThis)) {
-            if (flecs_rule_is_builtin_pred(term) && term->oper == EcsOr) {
-                flecs_rule_add_var(rule, EcsThisName, vars, EcsVarEntity);
-            }
-        }
+#define ECS_VALUE_GET(value, T) (*(T*)value->ptr)
 
-        if (flecs_rule_add_var_for_term_id(
-            rule, second, vars, EcsVarEntity) == EcsVarNone)
-        {
-            /* If second is a wildcard, insert anonymous variable */
-            if (flecs_term_id_is_wildcard(second)) {
-                anonymous_count ++;
-            }
-        }
+#define ECS_BINARY_OP_T(left, right, result, op, R, T)\
+    ECS_VALUE_GET(result, R) = ECS_VALUE_GET(left, T) op ECS_VALUE_GET(right, T)
 
-        if (src->flags & EcsIsVariable && second->flags & EcsIsVariable) {
-            if (term->flags & EcsTermTransitive) {
-                /* Anonymous variable to store temporary id for finding 
-                 * targets for transitive relationship, see compile_term. */
-                anonymous_count ++;
-            }
-        }
+#define ECS_BINARY_OP(left, right, result, op)\
+    if (left->type == ecs_id(ecs_u64_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_u64_t, ecs_u64_t);\
+    } else if (left->type == ecs_id(ecs_i64_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_i64_t, ecs_i64_t);\
+    } else if (left->type == ecs_id(ecs_f64_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_f64_t, ecs_f64_t);\
+    } else {\
+        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
+    }
 
-        /* Track if a This entity variable is used before a potential This table 
-         * variable. If this happens, the rule has no This table variable */
-        if (src->id == EcsThis) {
-            table_this = true;
-        }
-        if (first->id == EcsThis || second->id == EcsThis) {
-            if (!table_this) {
-                entity_before_table_this = true;
-            }
-        }
+#define ECS_BINARY_COND_EQ_OP(left, right, result, op)\
+    if (left->type == ecs_id(ecs_u64_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_u64_t);\
+    } else if (left->type == ecs_id(ecs_i64_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_i64_t);\
+    } else if (left->type == ecs_id(ecs_f64_t)) { \
+        ecs_parser_error(name, expr, ptr - expr, "unsupported operator for floating point");\
+        return -1;\
+    } else if (left->type == ecs_id(ecs_u8_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_u8_t);\
+    } else if (left->type == ecs_id(ecs_char_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_char_t);\
+    } else if (left->type == ecs_id(ecs_bool_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_bool_t);\
+    } else {\
+        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
     }
 
-    int32_t var_count = ecs_vec_count(vars);
-    ecs_var_id_t placeholder = EcsVarNone - 1;
-    bool replace_placeholders = false;
+#define ECS_BINARY_COND_OP(left, right, result, op)\
+    if (left->type == ecs_id(ecs_u64_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_u64_t);\
+    } else if (left->type == ecs_id(ecs_i64_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_i64_t);\
+    } else if (left->type == ecs_id(ecs_f64_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_f64_t);\
+    } else if (left->type == ecs_id(ecs_u8_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_u8_t);\
+    } else if (left->type == ecs_id(ecs_char_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_char_t);\
+    } else if (left->type == ecs_id(ecs_bool_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_bool_t);\
+    } else {\
+        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
+    }
 
-    /* Ensure lookup variables have table and/or entity variables */
-    for (i = 0; i < var_count; i ++) {
-        ecs_rule_var_t *var = ecs_vec_get_t(vars, ecs_rule_var_t, i);
-        if (var->lookup) {
-            char *var_name = ecs_os_strdup(var->name);
-            var_name[var->lookup - var->name - 1] = '\0';
+#define ECS_BINARY_BOOL_OP(left, right, result, op)\
+    if (left->type == ecs_id(ecs_bool_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_bool_t, ecs_bool_t);\
+    } else {\
+        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
+    }
 
-            ecs_var_id_t base_table_id = flecs_rule_find_var_id(
-                rule, var_name, EcsVarTable);
-            if (base_table_id != EcsVarNone) {
-                var->table_id = base_table_id;
-            } else if (anonymous_table_count) {
-                /* Scan for implicit anonymous table variables that haven't been
-                 * inserted yet (happens after this step). Doing this here vs.
-                 * ensures that anonymous variables are appended at the end of
-                 * the variable array, while also ensuring that variable ids are
-                 * stable (no swapping of table var ids that are in use). */
-                for (a = 0; a < var_count; a ++) {
-                    ecs_rule_var_t *avar = ecs_vec_get_t(
-                        vars, ecs_rule_var_t, a);
-                    if (avar->kind == EcsVarAny) {
-                        if (!ecs_os_strcmp(avar->name, var_name)) {
-                            base_table_id = (ecs_var_id_t)(a + 1);
-                            break;
-                        }
-                    }
-                }
-                if (base_table_id != EcsVarNone) {
-                    /* Set marker so we can set the new table id afterwards */
-                    var->table_id = placeholder;
-                    replace_placeholders = true;
-                }
-            }
+#define ECS_BINARY_UINT_OP(left, right, result, op)\
+    if (left->type == ecs_id(ecs_u64_t)) { \
+        ECS_BINARY_OP_T(left, right, result, op, ecs_u64_t, ecs_u64_t);\
+    } else {\
+        ecs_abort(ECS_INTERNAL_ERROR, "unexpected type in binary expression");\
+    }
 
-            ecs_var_id_t base_entity_id = flecs_rule_find_var_id(
-                rule, var_name, EcsVarEntity);
-            if (base_entity_id == EcsVarNone) {
-                /* Get name from table var (must exist). We can't use allocated
-                 * name since variables don't own names. */
-                const char *base_name = NULL;
-                if (base_table_id != EcsVarNone && base_table_id) {
-                    ecs_rule_var_t *base_table_var = ecs_vec_get_t(
-                        vars, ecs_rule_var_t, (int32_t)base_table_id - 1);
-                    base_name = base_table_var->name;
-                } else {
-                    base_name = EcsThisName;
-                }
+static
+int flecs_binary_expr_do(
+    ecs_world_t *world,
+    ecs_value_stack_t *stack,
+    const char *name,
+    const char *expr,
+    const char *ptr,
+    ecs_value_t *lvalue,
+    ecs_value_t *rvalue,
+    ecs_value_t *result,
+    ecs_expr_oper_t op)
+{
+    /* Find expression type */
+    ecs_entity_t operand_type, type = flecs_binary_expr_type(
+        world, name, expr, ptr, lvalue, rvalue, op, &operand_type);
+    if (!type) {
+        goto error;
+    }
 
-                base_entity_id = flecs_rule_add_var(
-                    rule, base_name, vars, EcsVarEntity);
-                var = ecs_vec_get_t(vars, ecs_rule_var_t, i);
-            }
+    if (!flecs_oper_valid_for_type(type, op)) {
+        ecs_parser_error(name, expr, ptr - expr, "invalid operator for type");
+        goto error;
+    }
 
-            var->base_id = base_entity_id;
+    flecs_value_cast(world, stack, lvalue, operand_type);
+    flecs_value_cast(world, stack, rvalue, operand_type);
 
-            ecs_os_free(var_name);
-        }
+    ecs_value_t *storage = result;
+    ecs_value_t tmp_storage = {0};
+    if (result->type != type) {
+        storage = &tmp_storage;
+        storage->type = type;
+        storage->ptr = flecs_expr_value_new(stack, type);
     }
-    var_count = ecs_vec_count(vars);
 
-    /* Add non-This table variables */
-    if (anonymous_table_count) {
-        anonymous_table_count = 0;
-        for (i = 0; i < var_count; i ++) {
-            ecs_rule_var_t *var = ecs_vec_get_t(vars, ecs_rule_var_t, i);
-            if (var->kind == EcsVarAny) {
-                var->kind = EcsVarEntity;
+    switch(op) {
+    case EcsAdd:
+        ECS_BINARY_OP(lvalue, rvalue, storage, +);
+        break;
+    case EcsSub:
+        ECS_BINARY_OP(lvalue, rvalue, storage, -);
+        break;
+    case EcsMul:
+        ECS_BINARY_OP(lvalue, rvalue, storage, *);
+        break;
+    case EcsDiv:
+        ECS_BINARY_OP(lvalue, rvalue, storage, /);
+        break;
+    case EcsCondEq:
+        ECS_BINARY_COND_EQ_OP(lvalue, rvalue, storage, ==);
+        break;
+    case EcsCondNeq:
+        ECS_BINARY_COND_EQ_OP(lvalue, rvalue, storage, !=);
+        break;
+    case EcsCondGt:
+        ECS_BINARY_COND_OP(lvalue, rvalue, storage, >);
+        break;
+    case EcsCondGtEq:
+        ECS_BINARY_COND_OP(lvalue, rvalue, storage, >=);
+        break;
+    case EcsCondLt:
+        ECS_BINARY_COND_OP(lvalue, rvalue, storage, <);
+        break;
+    case EcsCondLtEq:
+        ECS_BINARY_COND_OP(lvalue, rvalue, storage, <=);
+        break;
+    case EcsCondAnd:
+        ECS_BINARY_BOOL_OP(lvalue, rvalue, storage, &&);
+        break;
+    case EcsCondOr:
+        ECS_BINARY_BOOL_OP(lvalue, rvalue, storage, ||);
+        break;
+    case EcsShiftLeft:
+        ECS_BINARY_UINT_OP(lvalue, rvalue, storage, <<);
+        break;
+    case EcsShiftRight:
+        ECS_BINARY_UINT_OP(lvalue, rvalue, storage, >>);
+        break;
+    case EcsExprOperUnknown:
+    case EcsLeftParen:
+    case EcsMin:
+        ecs_parser_error(name, expr, ptr - expr, "unsupported operator");
+        goto error;
+    default:
+        ecs_throw(ECS_INTERNAL_ERROR, NULL);
+    }
 
-                ecs_var_id_t var_id = flecs_rule_add_var(
-                    rule, var->name, vars, EcsVarTable);
-                ecs_vec_get_t(vars, ecs_rule_var_t, i)->table_id = var_id;
-                anonymous_table_count ++;
-            }
+    if (storage->ptr != result->ptr) {
+        if (!result->ptr) {
+            *result = *storage;
+        } else {
+            ecs_meta_cursor_t cur = ecs_meta_cursor(world, 
+                result->type, result->ptr);
+            ecs_meta_set_value(&cur, storage);
         }
-
-        var_count = ecs_vec_count(vars);
     }
 
-    /* If any forward references to newly added anonymous tables exist, replace
-     * them with the actual table variable ids. */
-    if (replace_placeholders) {
-        for (i = 0; i < var_count; i ++) {
-            ecs_rule_var_t *var = ecs_vec_get_t(vars, ecs_rule_var_t, i);
-            if (var->table_id == placeholder) {
-                char *var_name = ecs_os_strdup(var->name);
-                var_name[var->lookup - var->name - 1] = '\0';
-
-                var->table_id = flecs_rule_find_var_id(
-                    rule, var_name, EcsVarTable);
-                ecs_assert(var->table_id != EcsVarNone, 
-                    ECS_INTERNAL_ERROR, NULL);
+    return 0;
+error:
+    return -1;
+}
 
-                ecs_os_free(var_name);
-            }
+static
+const char* flecs_binary_expr_parse(
+    ecs_world_t *world,
+    ecs_value_stack_t *stack,
+    const char *name,
+    const char *expr,
+    const char *ptr,
+    ecs_value_t *lvalue,
+    ecs_value_t *result,
+    ecs_expr_oper_t left_op,
+    const ecs_script_expr_run_desc_t *desc)
+{
+    ecs_entity_t result_type = result->type;
+    do {
+        ecs_expr_oper_t op;
+        ptr = flecs_str_to_expr_oper(ptr, &op);
+        if (!ptr) {
+            ecs_parser_error(name, expr, ptr - expr, "invalid operator");
+            return NULL;
         }
-    }
-
-    /* Always include spot for This variable, even if rule doesn't use it */
-    var_count ++;
 
-    ecs_rule_var_t *rule_vars = &rule->vars_cache.var;
-    if ((var_count + anonymous_count) > 1) {
-        rule_vars = ecs_os_malloc(
-            (ECS_SIZEOF(ecs_rule_var_t) + ECS_SIZEOF(char*)) * 
-                (var_count + anonymous_count));
-    }
+        ptr = flecs_parse_ws_eol(ptr);
 
-    rule->vars = rule_vars;
-    rule->var_count = var_count;
-    rule->var_pub_count = var_count;
-    rule->has_table_this = !entity_before_table_this;
+        ecs_value_t rvalue = {0};
+        const char *rptr = flecs_script_expr_run(world, stack, ptr, &rvalue, op, desc);
+        if (!rptr) {
+            return NULL;
+        }
 
-#ifdef FLECS_DEBUG
-    rule->var_size = var_count + anonymous_count;
-#endif
+        if (flecs_binary_expr_do(world, stack, name, expr, ptr, 
+            lvalue, &rvalue, result, op)) 
+        {
+            return NULL;
+        }
 
-    char **var_names = ECS_ELEM(rule_vars, ECS_SIZEOF(ecs_rule_var_t), 
-        var_count + anonymous_count);
-    rule->var_names = (char**)var_names;
-
-    rule_vars[0].kind = EcsVarTable;
-    rule_vars[0].name = NULL;
-    flecs_set_var_label(&rule_vars[0], NULL);
-    rule_vars[0].id = 0;
-    rule_vars[0].table_id = EcsVarNone;
-    rule_vars[0].lookup = NULL;
-    var_names[0] = ECS_CONST_CAST(char*, rule_vars[0].name);
-    rule_vars ++;
-    var_names ++;
-    var_count --;
+        ptr = rptr;
 
-    if (var_count) {
-        ecs_rule_var_t *user_vars = ecs_vec_first_t(vars, ecs_rule_var_t);
-        ecs_os_memcpy_n(rule_vars, user_vars, ecs_rule_var_t, var_count);
-        for (i = 0; i < var_count; i ++) {
-            var_names[i] = ECS_CONST_CAST(char*, rule_vars[i].name);
+        ecs_expr_oper_t right_op;
+        flecs_str_to_expr_oper(rptr, &right_op);
+        if (right_op > left_op) {
+            if (result_type) {
+                /* If result was initialized, preserve its value */
+                lvalue->type = result->type;
+                lvalue->ptr = flecs_expr_value_new(stack, lvalue->type);
+                ecs_value_copy(world, lvalue->type, lvalue->ptr, result->ptr);
+                continue;
+            } else {
+                /* Otherwise move result to lvalue */
+                *lvalue = *result;
+                ecs_os_zeromem(result);
+                continue;
+            }
         }
-    }
 
-    /* Hide anonymous table variables from application */
-    rule->var_pub_count -= anonymous_table_count;
-
-    /* Sanity check to make sure that the public part of the variable array only
-     * contains entity variables. */
-#ifdef FLECS_DEBUG
-    for (i = 1 /* first element = $this */; i < rule->var_pub_count; i ++) {
-        ecs_assert(rule->vars[i].kind == EcsVarEntity, ECS_INTERNAL_ERROR, NULL);
-    }
-#endif
+        break;
+    } while (true);
 
-    return 0;
-error:
-    return -1;
+    return ptr;
 }
 
 static
-ecs_var_id_t flecs_rule_most_specific_var(
-    ecs_rule_t *rule,
+const char* flecs_funccall_parse(
+    ecs_world_t *world,
+    ecs_value_stack_t *stack,
     const char *name,
-    ecs_var_kind_t kind,
-    ecs_rule_compile_ctx_t *ctx)
+    const char *expr,
+    const char *ptr,
+    char *token,
+    ecs_meta_cursor_t *cur,
+    ecs_value_t *value,
+    bool isvar,
+    const ecs_script_expr_run_desc_t *desc)
 {
-    if (kind == EcsVarTable || kind == EcsVarEntity) {
-        return flecs_rule_find_var_id(rule, name, kind);
-    }
-
-    ecs_var_id_t evar = flecs_rule_find_var_id(rule, name, EcsVarEntity);
-    if ((evar != EcsVarNone) && flecs_rule_is_written(evar, ctx->written)) {
-        /* If entity variable is available and written to, it contains the most
-         * specific result and should be used. */
-        return evar;
+    char *sep = strrchr(token, '.');
+    if (!sep) {
+        ecs_parser_error(name, expr, ptr - expr, 
+            "missing object for function call '%s'", token);
+        return NULL;
     }
 
-    ecs_var_id_t tvar = flecs_rule_find_var_id(rule, name, EcsVarTable);
-    if ((tvar != EcsVarNone) && !flecs_rule_is_written(tvar, ctx->written)) {
-        /* If variable of any kind is requested and variable hasn't been written
-         * yet, write to table variable */
-        return tvar;
-    }
+    sep[0] = '\0';
+    const char *function = sep + 1;
 
-    /* If table var is written, and entity var doesn't exist or is not written,
-     * return table var */
-    if (tvar != EcsVarNone) {
-        return tvar;
+    if (!isvar) {
+        if (ecs_meta_set_string(cur, token) != 0) {
+            goto error;
+        }
     } else {
-        return evar;
+        const ecs_script_var_t *var = ecs_script_vars_lookup(desc->vars, token);
+        ecs_meta_set_value(cur, &var->value);
     }
-}
 
-static
-ecs_rule_lbl_t flecs_rule_op_insert(
-    ecs_rule_op_t *op,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t *elem = ecs_vec_append_t(NULL, ctx->ops, ecs_rule_op_t);
-    int32_t count = ecs_vec_count(ctx->ops);
-    *elem = *op;
-    if (count > 1) {
-        if (ctx->cur->lbl_begin == -1) {
-            /* Variables written by previous instruction can't be written by
-             * this instruction, except when this is a union. */
-            elem->written &= ~elem[-1].written;
+    do {
+        if (!function[0]) {
+            ecs_parser_error(name, expr, ptr - expr, 
+                "missing function name for function call '%s'", token);
+            return NULL;
         }
-    }
 
-    elem->next = flecs_itolbl(count);
-    elem->prev = flecs_itolbl(count - 2);
-    return flecs_itolbl(count - 1);
-}
+        if (flecs_meta_call(world, stack, name, expr, ptr, cur, 
+            function) != 0) 
+        {
+            goto error;
+        }
 
-static
-ecs_rule_op_t* flecs_rule_begin_block(
-    ecs_rule_op_kind_t kind,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t op = {0};
-    op.kind = flecs_ito(uint8_t, kind);
-    ctx->cur->lbl_begin = flecs_rule_op_insert(&op, ctx);
-    return ecs_vec_get_t(ctx->ops, ecs_rule_op_t, ctx->cur->lbl_begin);
-}
+        ecs_entity_t type = ecs_meta_get_type(cur);
+        value->ptr = ecs_meta_get_ptr(cur);
+        value->type = type;
 
-static
-void flecs_rule_end_block(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t new_op = {0};
-    new_op.kind = EcsRuleEnd;
-    ecs_rule_lbl_t end = flecs_rule_op_insert(&new_op, ctx);
-    
-    ecs_rule_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_rule_op_t);
-    ops[ctx->cur->lbl_begin].next = end;
+        ptr += 2;
+        if (ptr[0] != '.') {
+            break;
+        }
 
-    ecs_rule_op_t *end_op = &ops[end];
-    if (ctx->cur->lbl_query != -1) {
-        ecs_rule_op_t *query_op = &ops[ctx->cur->lbl_query];
-        end_op->prev = ctx->cur->lbl_begin;
-        end_op->src = query_op->src;
-        end_op->first = query_op->first;
-        end_op->second = query_op->second;
-        end_op->flags = query_op->flags;
-        end_op->field_index = query_op->field_index;
-    } else {
-        end_op->prev = ctx->cur->lbl_begin;
-        end_op->field_index = -1;
-    }
+        ptr ++;
+        char *paren = strchr(ptr, '(');
+        if (!paren) {
+            break;
+        }
 
-    ctx->cur->lbl_begin = -1;
+        ecs_size_t len = flecs_ito(int32_t, paren - ptr);
+        if (len >= ECS_MAX_TOKEN_SIZE) {
+            ecs_parser_error(name, expr, ptr - expr, 
+                "token exceeds maximum token size");
+            goto error;
+        }
+
+        ecs_os_strncpy(token, ptr, len);
+        token[len] = '\0';
+        function = token;
+
+        ptr = paren;
+    } while (true);
+
+    return ptr;
+error:
+    return NULL;
 }
 
 static
-void flecs_rule_begin_block_cond_eval(
-    ecs_rule_op_t *op,
-    ecs_rule_compile_ctx_t *ctx,
-    ecs_write_flags_t cond_write_state)
+const char* flecs_script_expr_run(
+    ecs_world_t *world,
+    ecs_value_stack_t *stack,
+    const char *ptr,
+    ecs_value_t *value,
+    ecs_expr_oper_t left_op,
+    const ecs_script_expr_run_desc_t *desc)
 {
-    ecs_var_id_t first_var = EcsVarNone, second_var = EcsVarNone, src_var = EcsVarNone;
-    ecs_write_flags_t cond_mask = 0;
+    ecs_assert(value != NULL, ECS_INTERNAL_ERROR, NULL);
+    char token[ECS_MAX_TOKEN_SIZE];
+    int depth = 0;
+    ecs_value_t result = {0};
+    ecs_meta_cursor_t cur = {0};
+    const char *name = desc ? desc->name : NULL;
+    const char *expr = desc ? desc->expr : NULL;
+    token[0] = '\0';
+    expr = expr ? expr : ptr;
 
-    if (flecs_rule_ref_flags(op->flags, EcsRuleFirst) == EcsRuleIsVar) {
-        first_var = op->first.var;
-        ecs_assert(first_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-        cond_mask |= (1ull << first_var);
-    }
-    if (flecs_rule_ref_flags(op->flags, EcsRuleSecond) == EcsRuleIsVar) {
-        second_var = op->second.var;
-        ecs_assert(second_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-        cond_mask |= (1ull << second_var);
-    }
-    if (flecs_rule_ref_flags(op->flags, EcsRuleSrc) == EcsRuleIsVar) {
-        src_var = op->src.var;
-        ecs_assert(src_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-        cond_mask |= (1ull << src_var);
-    }
+    ptr = flecs_parse_ws_eol(ptr);
 
-    /* Variables set in an OR chain are marked as conditional writes. However, 
-     * writes from previous terms in the current OR chain shouldn't be treated
-     * as variables that are conditionally set, so instead use the write mask 
-     * from before the chain started. */
-    if (ctx->ctrlflow->in_or) {
-        cond_write_state = ctx->ctrlflow->cond_written_or;
+    /* Check for postfix operators */
+    ecs_expr_oper_t unary_op = EcsExprOperUnknown;
+    if (ptr[0] == '-' && !isdigit(ptr[1])) {
+        unary_op = EcsMin;
+        ptr = flecs_parse_ws_eol(ptr + 1);
     }
 
-    /* If this term uses conditionally set variables, insert instruction that
-     * jumps over the term if the variables weren't set yet. */
-    if (cond_mask & cond_write_state) {
-        ctx->cur->lbl_cond_eval = flecs_itolbl(ecs_vec_count(ctx->ops));
-
-        ecs_rule_op_t jmp_op = {0};
-        jmp_op.kind = EcsRuleIf;
-
-        if ((first_var != EcsVarNone) && cond_write_state & (1ull << first_var)) {
-            jmp_op.flags |= (EcsRuleIsVar << EcsRuleFirst);
-            jmp_op.first.var = first_var;
+    /* Initialize storage and cursor. If expression starts with a '(' storage
+     * will be initialized by a nested expression */
+    if (ptr[0] != '(') {
+        ecs_entity_t type = flecs_parse_discover_type(
+            world, name, expr, ptr, value->type, desc);
+        if (!type) {
+            return NULL;
         }
-        if ((second_var != EcsVarNone) && cond_write_state & (1ull << second_var)) {
-            jmp_op.flags |= (EcsRuleIsVar << EcsRuleSecond);
-            jmp_op.second.var = second_var;
+
+        result.type = type;
+        if (type != value->type) {
+            result.ptr = flecs_expr_value_new(stack, type);
+        } else {
+            result.ptr = value->ptr;
         }
-        if ((src_var != EcsVarNone) && cond_write_state & (1ull << src_var)) {
-            jmp_op.flags |= (EcsRuleIsVar << EcsRuleSrc);
-            jmp_op.src.var = src_var;
+
+        cur = ecs_meta_cursor(world, result.type, result.ptr);
+        if (!cur.valid) {
+            return NULL;
         }
 
-        flecs_rule_op_insert(&jmp_op, ctx);
-    } else {
-        ctx->cur->lbl_cond_eval = -1;
+        cur.lookup_action = desc ? desc->lookup_action : NULL;
+        cur.lookup_ctx = desc ? desc->lookup_ctx : NULL;
     }
-}
 
-static
-void flecs_rule_end_block_cond_eval(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    if (ctx->cur->lbl_cond_eval == -1) {
-        return;
-    }
+    /* Loop that parses all values in a value scope */
+    while ((ptr = flecs_script_expr_parse_token(name, expr, ptr, token))) {
+        /* Used to track of the result of the parsed token can be used as the
+         * lvalue for a binary expression */
+        bool is_lvalue = false;
+        bool newline = false;
 
-    ecs_assert(ctx->cur->lbl_query >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_rule_op_t end_op = {0};
-    end_op.kind = EcsRuleEnd;
-    ecs_rule_lbl_t end = flecs_rule_op_insert(&end_op, ctx);
+        if (!token[0]) {
+            /* Comment */
+            continue;
+        }
 
-    ecs_rule_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_rule_op_t);
-    ops[ctx->cur->lbl_cond_eval].next = end;
+        if (!ecs_os_strcmp(token, "(")) {
+            ecs_value_t temp_result, *out;
+            if (!depth) {
+                out = &result;
+            } else {
+                temp_result.type = ecs_meta_get_type(&cur);
+                temp_result.ptr = ecs_meta_get_ptr(&cur);
+                out = &temp_result;
+            }
 
-    ecs_rule_op_t *end_op_ptr = &ops[end];
-    ecs_rule_op_t *query_op = &ops[ctx->cur->lbl_query];
-    end_op_ptr->prev = ctx->cur->lbl_cond_eval;
-    end_op_ptr->src = query_op->src;
-    end_op_ptr->first = query_op->first;
-    end_op_ptr->second = query_op->second;
-    end_op_ptr->flags = query_op->flags;
-    end_op_ptr->field_index = query_op->field_index;
-}
+            /* Parenthesis, parse nested expression */
+            ptr = flecs_script_expr_run(world, stack, ptr, out, EcsLeftParen, desc);
+            if (ptr[0] != ')') {
+                ecs_parser_error(name, expr, ptr - expr, 
+                    "missing closing parenthesis");
+                return NULL;
+            }
+            ptr = flecs_parse_ws(ptr + 1);
+            is_lvalue = true;
 
-static
-void flecs_rule_begin_block_or(
-    ecs_rule_op_t *op,
-    ecs_term_t *term,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t *or_op = flecs_rule_begin_block(EcsRuleNot, ctx);
-    or_op->kind = EcsRuleOr;
+        } else if (!ecs_os_strcmp(token, "{")) {
+            /* Parse nested value scope */
+            ecs_entity_t scope_type = ecs_meta_get_type(&cur);
 
-    /* Set the source of the evaluate terms as source of the Or instruction. 
-     * This lets the engine determine whether the variable has already been
-     * written. When the source is not yet written, an OR operation needs to
-     * take the union of all the terms in the OR chain. When the variable is
-     * known, it will return after the first matching term.
-     * 
-     * In case a term in the OR expression is an equality predicate which 
-     * compares the left hand side with a variable, the variable acts as an 
-     * alias, so we can always assume that it's written. */
-    bool add_src = true;
-    if (term->first.id == EcsPredEq && term->second.flags & EcsIsVariable) {
-        if (!(flecs_rule_is_written(op->src.var, ctx->written))) {
-            add_src = false;
+            depth ++; /* Keep track of depth so we know when parsing is done */
+            if (ecs_meta_push(&cur) != 0) {
+                goto error;
+            }
+
+            if (ecs_meta_is_collection(&cur)) {
+                char *path = ecs_get_fullpath(world, scope_type);
+                ecs_parser_error(name, expr, ptr - expr, 
+                    "expected '[' for collection type '%s'", path);
+                ecs_os_free(path);
+                return NULL;
+            }
         }
-    }
 
-    if (add_src) {
-        if (op->flags & (EcsRuleIsVar << EcsRuleSrc)) {
-            or_op->flags = (EcsRuleIsVar << EcsRuleSrc);
-            or_op->src = op->src;
+        else if (!ecs_os_strcmp(token, "}")) {
+            depth --;
+
+            if (ecs_meta_is_collection(&cur)) {
+                ecs_parser_error(name, expr, ptr - expr, "expected ']'");
+                return NULL;
+            }
+
+            if (ecs_meta_pop(&cur) != 0) {
+                goto error;
+            }
         }
-    }
-}
 
-static
-void flecs_rule_end_block_or(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t op = {0};
-    op.kind = EcsRuleEnd;
-    ecs_rule_lbl_t end = flecs_rule_op_insert(&op, ctx);
-    
-    ecs_rule_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_rule_op_t);
-    int32_t i, j, prev_or = -2;
-    for (i = ctx->cur->lbl_begin + 1; i < end; i ++) {
-        if (ops[i].next == FlecsRuleOrMarker) {
-            if (prev_or != -2) {
-                ops[prev_or].prev = flecs_itolbl(i);
+        else if (!ecs_os_strcmp(token, "[")) {
+            /* Open collection value scope */
+            depth ++;
+            if (ecs_meta_push(&cur) != 0) {
+                goto error;
             }
-            ops[i].next = flecs_itolbl(end);
-            prev_or = i;
-        } else {
-            /* Combine operation with next OR marker. This supports OR chains 
-             * with terms that require multiple operations to test. */
-            for (j = i + 1; j < end; j ++) {
-                if (ops[j].next == FlecsRuleOrMarker) {
-                    if (j == (end - 1)) {
-                        ops[i].prev = ctx->cur->lbl_begin;
-                    } else {
-                        ops[i].prev = flecs_itolbl(j + 1);
-                    }
-                    break;
-                }
+
+            if (!ecs_meta_is_collection(&cur)) {
+                ecs_parser_error(name, expr, ptr - expr, "unexpected '['");
+                return NULL;
             }
         }
-    }
 
-    ops[ctx->cur->lbl_begin].next = flecs_itolbl(end);
-    ops[end].prev = ctx->cur->lbl_begin;
-    ops[end - 1].prev = ctx->cur->lbl_begin;
+        else if (!ecs_os_strcmp(token, "]")) {
+            depth --;
 
-    /* Scan which variables were conditionally written in the OR chain and 
-     * reset instructions after the OR chain. If a variable is set in part one
-     * of a chain but not part two, there would be nothing writing to the
-     * variable in part two, leaving it to the previous value. To address this
-     * a reset is inserted that resets the variable value on redo. */
-    for (i = 1; i < (8 * ECS_SIZEOF(ecs_write_flags_t)); i ++) {
-        ecs_write_flags_t prev = 1 & (ctx->ctrlflow->cond_written_or >> i);
-        ecs_write_flags_t cur = 1 & (ctx->cond_written >> i);
+            if (!ecs_meta_is_collection(&cur)) {
+                ecs_parser_error(name, expr, ptr - expr, "expected '}'");
+                return NULL;
+            }
 
-        if (!prev && cur) {
-            ecs_rule_op_t reset_op = {0};
-            reset_op.kind = EcsRuleReset;
-            reset_op.flags |= (EcsRuleIsVar << EcsRuleSrc);
-            reset_op.src.var = flecs_itovar(i);
-            flecs_rule_op_insert(&reset_op, ctx);
+            if (ecs_meta_pop(&cur) != 0) {
+                goto error;
+            }
         }
-    }
-
-    ctx->ctrlflow->in_or = false;
-    ctx->cur->lbl_begin = -1;
-}
 
-static
-void flecs_rule_insert_each(
-    ecs_var_id_t tvar,
-    ecs_var_id_t evar,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
-{
-    ecs_rule_op_t each = {0};
-    each.kind = EcsRuleEach;
-    each.src.var = evar;
-    each.first.var = tvar;
-    each.flags = (EcsRuleIsVar << EcsRuleSrc) | 
-                 (EcsRuleIsVar << EcsRuleFirst);
-    flecs_rule_write_ctx(evar, ctx, cond_write);
-    flecs_rule_write(evar, &each.written);
-    flecs_rule_op_insert(&each, ctx);
-}
+        else if (!ecs_os_strcmp(token, "-")) {
+            if (unary_op != EcsExprOperUnknown) {
+                ecs_parser_error(name, expr, ptr - expr, 
+                    "unexpected unary operator");
+                return NULL;
+            }
+            unary_op = EcsMin;
+        }
 
-static
-void flecs_rule_insert_lookup(
-    ecs_var_id_t base_var,
-    ecs_var_id_t evar,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
-{
-    ecs_rule_op_t lookup = {0};
-    lookup.kind = EcsRuleLookup;
-    lookup.src.var = evar;
-    lookup.first.var = base_var;
-    lookup.flags = (EcsRuleIsVar << EcsRuleSrc) | 
-                 (EcsRuleIsVar << EcsRuleFirst);
-    flecs_rule_write_ctx(evar, ctx, cond_write);
-    flecs_rule_write(evar, &lookup.written);
-    flecs_rule_op_insert(&lookup, ctx);
-}
+        else if (!ecs_os_strcmp(token, ",")) {
+            /* Move to next field */
+            if (ecs_meta_next(&cur) != 0) {
+                goto error;
+            }
+        }
 
-static
-void flecs_rule_insert_unconstrained_transitive(
-    ecs_rule_t *rule,
-    ecs_rule_op_t *op,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
-{
-    /* Create anonymous variable to store the target ids. This will return the
-     * list of targets without constraining the variable of the term, which
-     * needs to stay variable to find all transitive relationships for a src. */
-    ecs_var_id_t tgt = flecs_rule_add_var(rule, NULL, NULL, EcsVarEntity);
-    flecs_set_var_label(&rule->vars[tgt], rule->vars[op->second.var].name);
+        else if (!ecs_os_strcmp(token, "null")) {
+            if (ecs_meta_set_null(&cur) != 0) {
+                goto error;
+            }
 
-    /* First, find ids to start traversal from. This fixes op.second. */
-    ecs_rule_op_t find_ids = {0};
-    find_ids.kind = EcsRuleIdsRight;
-    find_ids.field_index = -1;
-    find_ids.first = op->first;
-    find_ids.second = op->second;
-    find_ids.flags = op->flags;
-    find_ids.flags &= (ecs_flags8_t)~((EcsRuleIsVar|EcsRuleIsEntity) << EcsRuleSrc);
-    find_ids.second.var = tgt;
-    flecs_rule_write_ctx(tgt, ctx, cond_write);
-    flecs_rule_write(tgt, &find_ids.written);
-    flecs_rule_op_insert(&find_ids, ctx);
+            is_lvalue = true;
+        }
 
-    /* Next, iterate all tables for the ids. This fixes op.src */
-    ecs_rule_op_t and_op = {0};
-    and_op.kind = EcsRuleAnd;
-    and_op.field_index = op->field_index;
-    and_op.first = op->first;
-    and_op.second = op->second;
-    and_op.src = op->src;
-    and_op.flags = op->flags | EcsRuleIsSelf;
-    and_op.second.var = tgt;
-    flecs_rule_write_ctx(and_op.src.var, ctx, cond_write);
-    flecs_rule_write(and_op.src.var, &and_op.written);
-    flecs_rule_op_insert(&and_op, ctx);
-}
+        else if (token[0] == '\"') {
+            /* Regular string */
+            if (ecs_meta_set_string_literal(&cur, token) != 0) {
+                goto error;
+            }
 
-static
-void flecs_rule_insert_inheritance(
-    ecs_rule_t *rule,
-    ecs_term_t *term,
-    ecs_rule_op_t *op,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
-{
-    /* Anonymous variable to store the resolved component ids */
-    ecs_var_id_t tvar = flecs_rule_add_var(rule, NULL, NULL, EcsVarTable);
-    ecs_var_id_t evar = flecs_rule_add_var(rule, NULL, NULL, EcsVarEntity);
-    flecs_set_var_label(&rule->vars[tvar], ecs_get_name(rule->filter.world, term->first.id));
-    flecs_set_var_label(&rule->vars[evar], ecs_get_name(rule->filter.world, term->first.id));
+            is_lvalue = true;
+        }
 
-    ecs_rule_op_t trav_op = {0};
-    trav_op.kind = EcsRuleTrav;
-    trav_op.field_index = -1;
-    trav_op.first.entity = term->first.trav;
-    trav_op.second.entity = term->first.id;
-    trav_op.src.var = tvar;
-    trav_op.flags = EcsRuleIsSelf;
-    trav_op.flags |= (EcsRuleIsEntity << EcsRuleFirst);
-    trav_op.flags |= (EcsRuleIsEntity << EcsRuleSecond);
-    trav_op.flags |= (EcsRuleIsVar << EcsRuleSrc);
-    trav_op.written |= (1ull << tvar);
-    if (term->first.flags & EcsSelf) {
-        trav_op.match_flags |= EcsTermReflexive;
-    }
-    flecs_rule_op_insert(&trav_op, ctx);
-    flecs_rule_insert_each(tvar, evar, ctx, cond_write);
+        else if (!ecs_os_strcmp(token, "`")) {
+            /* Multiline string */
+            if (!(ptr = flecs_parse_multiline_string(&cur, name, expr, ptr))) {
+                goto error;
+            }
 
-    ecs_rule_ref_t r = { .var = evar };
-    op->first = r;
-    op->flags &= (ecs_flags8_t)~(EcsRuleIsEntity << EcsRuleFirst);
-    op->flags |= (EcsRuleIsVar << EcsRuleFirst);
-}
+            is_lvalue = true;
 
-static
-void flecs_rule_compile_term_id(
-    ecs_world_t *world,
-    ecs_rule_t *rule,
-    ecs_rule_op_t *op,
-    ecs_term_id_t *term_id,
-    ecs_rule_ref_t *ref,
-    ecs_flags8_t ref_kind,
-    ecs_var_kind_t kind,
-    ecs_rule_compile_ctx_t *ctx,
-    bool create_wildcard_vars)
-{
-    (void)world;
+        } else if (token[0] == '$') {
+            /* Variable */
+            if (!desc || !desc->vars) {
+                ecs_parser_error(name, expr, ptr - expr, 
+                    "unresolved variable '%s' (no variable scope)", token);
+                return NULL;
+            }
 
-    if (!ecs_term_id_is_set(term_id)) {
-        return;
-    }
+            if (!token[1]) {
+                /* Empty name means default to assigned member */
+                const char *member = ecs_meta_get_member(&cur);
+                if (!member) {
+                    ecs_parser_error(name, expr, ptr - expr, 
+                        "invalid default variable outside member assignment");
+                    return NULL;
+                }
+                ecs_os_strcpy(&token[1], member);
+            }
 
-    if (term_id->flags & EcsIsVariable) {
-        op->flags |= (ecs_flags8_t)(EcsRuleIsVar << ref_kind);
-        const char *name = flecs_term_id_var_name(term_id);
-        if (name) {
-            ref->var = flecs_rule_most_specific_var(rule, name, kind, ctx);
-            ecs_assert(ref->var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-        } else if (create_wildcard_vars) {
-            bool is_wildcard = flecs_term_id_is_wildcard(term_id);
-            if (is_wildcard && (kind == EcsVarAny)) {
-                ref->var = flecs_rule_add_var(rule, NULL, NULL, EcsVarTable);
+            const ecs_script_var_t *var = ecs_script_vars_lookup(desc->vars, &token[1]);
+            if (!var) {
+                if (ptr[0] == '(') {
+                    /* Function */
+                    ptr = flecs_funccall_parse(world, stack, name, expr, ptr, 
+                        &token[1], &cur, &result, true, desc);
+                    if (!ptr) {
+                        goto error;
+                    }
+                } else {
+                    ecs_value_t v = flecs_dotresolve_var(world, desc->vars, &token[1]);
+                    if (!v.ptr) {
+                        ecs_parser_error(name, expr, ptr - expr, 
+                            "unresolved variable '%s'", token);
+                        return NULL;
+                    } else {
+                        ecs_meta_set_value(&cur, &v);
+                    }
+                }
             } else {
-                ref->var = flecs_rule_add_var(rule, NULL, NULL, EcsVarEntity);
+                ecs_meta_set_value(&cur, &var->value);
             }
-            if (is_wildcard) {
-                flecs_set_var_label(&rule->vars[ref->var], 
-                    ecs_get_name(world, term_id->id));
+            is_lvalue = true;
+        } else {
+            const char *tptr = flecs_parse_ws(ptr);
+            for (; ptr != tptr; ptr ++) {
+                if (ptr[0] == '\n') {
+                    newline = true;
+                }
             }
-            ecs_assert(ref->var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+
+            if (ptr[0] == ':') {
+                /* Member assignment */
+                ptr ++;
+                if (ecs_meta_dotmember(&cur, token) != 0) {
+                    goto error;
+                }
+            } else if (ptr[0] == '(') {
+                /* Function */
+                ptr = flecs_funccall_parse(world, stack, name, expr, ptr, 
+                    token, &cur, &result, false, desc);
+                if (!ptr) {
+                    goto error;
+                }
+            } else {
+                if (ecs_meta_set_string(&cur, token) != 0) {
+                    goto error;
+                }
+            }
+
+            is_lvalue = true;
         }
-    }
 
-    if (term_id->flags & EcsIsEntity) {
-        op->flags |= (ecs_flags8_t)(EcsRuleIsEntity << ref_kind);
-        ref->entity = term_id->id;
-    }
-}
+        /* If lvalue was parsed, apply operators. Expressions cannot start
+         * directly after a newline character. */
+        if (is_lvalue && !newline) {
+            if (unary_op != EcsExprOperUnknown) {
+                if (unary_op == EcsMin) {
+                    int64_t v = -1;
+                    ecs_value_t lvalue = {.type = ecs_id(ecs_i64_t), .ptr = &v};
+                    ecs_value_t *out, rvalue, temp_out = {0};
 
-static
-int flecs_rule_compile_ensure_vars(
-    ecs_rule_t *rule,
-    ecs_rule_op_t *op,
-    ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write,
-    bool *written_out)
-{
-    ecs_flags16_t flags = flecs_rule_ref_flags(op->flags, ref_kind);
-    bool written = false;
+                    if (!depth) {
+                        rvalue = result;
+                        ecs_os_zeromem(&result);
+                        out = &result;
+                    } else {
+                        ecs_entity_t cur_type = ecs_meta_get_type(&cur);
+                        void *cur_ptr = ecs_meta_get_ptr(&cur);
+                        rvalue.type = cur_type;
+                        rvalue.ptr = cur_ptr;
+                        temp_out.type = cur_type;
+                        temp_out.ptr = cur_ptr;
+                        out = &temp_out;
+                    }
 
-    if (flags & EcsRuleIsVar) {
-        ecs_var_id_t var_id = ref->var;
-        ecs_rule_var_t *var = &rule->vars[var_id];
+                    flecs_binary_expr_do(world, stack, name, expr, ptr, &lvalue,
+                        &rvalue, out, EcsMul);
+                }
+                unary_op = 0;
+            }
 
-        if (var->kind == EcsVarEntity && 
-            !flecs_rule_is_written(var_id, ctx->written)) 
-        {
-            /* If entity variable is not yet written but a table variant exists
-             * that has been written, insert each operation to translate from
-             * entity variable to table */
-            ecs_var_id_t tvar = var->table_id;
-            if ((tvar != EcsVarNone) && 
-                flecs_rule_is_written(tvar, ctx->written)) 
-            {
-                if (var->lookup) {
-                    if (!flecs_rule_is_written(tvar, ctx->written)) {
-                        ecs_err("dependent variable of '$%s' is not written", 
-                            var->name);
-                        return -1;
+            ecs_expr_oper_t right_op;
+            flecs_str_to_expr_oper(ptr, &right_op);
+            if (right_op) {
+                /* This is a binary expression, test precedence to determine if
+                 * it should be evaluated here */
+                if (flecs_oper_precedence(left_op, right_op) < 0) {
+                    ecs_value_t lvalue;
+                    ecs_value_t *op_result = &result;
+                    ecs_value_t temp_storage;
+                    if (!depth) {
+                        /* Root level value, move result to lvalue storage */
+                        lvalue = result;
+                        ecs_os_zeromem(&result);
+                    } else {
+                        /* Not a root level value. Move the parsed lvalue to a
+                         * temporary storage, and initialize the result value
+                         * for the binary operation with the current cursor */
+                        ecs_entity_t cur_type = ecs_meta_get_type(&cur);
+                        void *cur_ptr = ecs_meta_get_ptr(&cur);
+                        lvalue.type = cur_type;
+                        lvalue.ptr = flecs_expr_value_new(stack, cur_type);
+                        ecs_value_copy(world, cur_type, lvalue.ptr, cur_ptr);
+                        temp_storage.type = cur_type;
+                        temp_storage.ptr = cur_ptr;
+                        op_result = &temp_storage;
                     }
 
-                    if (!flecs_rule_is_written(var->base_id, ctx->written)) {
-                        flecs_rule_insert_each(
-                            tvar, var->base_id, ctx, cond_write);
+                    /* Do the binary expression */
+                    ptr = flecs_binary_expr_parse(world, stack, name, expr, ptr, 
+                        &lvalue, op_result, left_op, desc);
+                    if (!ptr) {
+                        return NULL;
                     }
-                } else {
-                    flecs_rule_insert_each(tvar, var_id, ctx, cond_write);
-                }
-
-                /* Variable was written, just not as entity */
-                written = true;
-            } else if (var->lookup) {
-                if (!flecs_rule_is_written(var->base_id, ctx->written)) {
-                    ecs_err("dependent variable of '$%s' is not written", 
-                        var->name);
-                    return -1;
                 }
             }
         }
 
-        written |= flecs_rule_is_written(var_id, ctx->written);
-    } else {
-        /* If it's not a variable, it's always written */
-        written = true;
-    }
+        if (!depth) {
+            /* Reached the end of the root scope */
+            break;
+        }
 
-    if (written_out) {
-        *written_out = written;
+        ptr = flecs_parse_ws_eol(ptr);
     }
 
-    return 0;
-}
-
-static
-bool flecs_rule_compile_lookup(
-    ecs_rule_t *rule,
-    ecs_var_id_t var_id,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write) 
-{
-    ecs_rule_var_t *var = &rule->vars[var_id];
-    if (var->lookup) {
-        flecs_rule_insert_lookup(var->base_id, var_id, ctx, cond_write);
-        return true;
-    } else {
-        return false;
+    if (!value->ptr) {
+        value->type = result.type;
+        value->ptr = flecs_expr_value_new(stack, result.type);
     }
-}
 
-static
-void flecs_rule_insert_contains(
-    ecs_rule_t *rule,
-    ecs_var_id_t src_var,
-    ecs_var_id_t other_var,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t contains = {0};
-    if ((src_var != other_var) && (src_var == rule->vars[other_var].table_id)) {
-        contains.kind = EcsRuleContain;
-        contains.src.var = src_var;
-        contains.first.var = other_var;
-        contains.flags |= (EcsRuleIsVar << EcsRuleSrc) | 
-                          (EcsRuleIsVar << EcsRuleFirst);
-        flecs_rule_op_insert(&contains, ctx);
+    if (value->ptr != result.ptr) {
+        cur = ecs_meta_cursor(world, value->type, value->ptr);
+        ecs_meta_set_value(&cur, &result);
     }
-}
 
-static
-void flecs_rule_insert_pair_eq(
-    int32_t field_index,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t contains = {0};
-    contains.kind = EcsRulePairEq;
-    contains.field_index = flecs_ito(int8_t, field_index);
-    flecs_rule_op_insert(&contains, ctx);
+    ecs_assert(value->type != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(value->ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    return ptr;
+error:
+    return NULL;
 }
 
-static
-bool flecs_rule_term_fixed_id(
-    ecs_filter_t *filter,
-    ecs_term_t *term)
+const char* ecs_script_expr_run(
+    ecs_world_t *world,
+    const char *ptr,
+    ecs_value_t *value,
+    const ecs_script_expr_run_desc_t *desc)
 {
-    /* Transitive/inherited terms have variable ids */
-    if (term->flags & (EcsTermTransitive|EcsTermIdInherited)) {
-        return false;
-    }
+    /* Prepare storage for temporary values */
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
+    ecs_value_stack_t stack;
+    stack.count = 0;
+    stack.stage = stage;
+    stack.stack = &stage->allocators.deser_stack;
+    stack.cursor = flecs_stack_get_cursor(stack.stack);
 
-    /* Or terms can match different ids */
-    if (term->oper == EcsOr) {
-        return false;
+    /* Parse expression */
+    bool storage_provided = value->ptr != NULL;
+    ptr = flecs_script_expr_run(world, &stack, ptr, value, EcsExprOperUnknown, desc);
+
+    /* If no result value was provided, allocate one as we can't return a 
+     * pointer to a temporary storage */
+    if (!storage_provided && value->ptr) {
+        ecs_assert(value->type != 0, ECS_INTERNAL_ERROR, NULL);
+        void *temp_storage = value->ptr;
+        value->ptr = ecs_value_new(world, value->type);
+        ecs_value_move_ctor(world, value->type, value->ptr, temp_storage);
     }
-    if ((term != filter->terms) && term[-1].oper == EcsOr) {
-        return false;
+    
+    /* Cleanup temporary values */
+    int i;
+    for (i = 0; i < stack.count; i ++) {
+        const ecs_type_info_t *ti = stack.values[i].ti;
+        ecs_assert(ti->hooks.dtor != NULL, ECS_INTERNAL_ERROR, NULL);
+        ti->hooks.dtor(stack.values[i].ptr, 1, ti);
     }
+    flecs_stack_restore_cursor(stack.stack, stack.cursor);
 
-    /* Wildcards can assume different ids */
-    if (ecs_id_is_wildcard(term->id)) {
-        return false;
-    }
+    return ptr;
+}
 
-    /* Any terms can have fixed ids, but they require special handling */
-    if (term->flags & (EcsTermMatchAny|EcsTermMatchAnySrc)) {
-        return false;
-    }
+#endif
 
-    /* First terms that are Not or Optional require special handling */
-    if (term->oper == EcsNot || term->oper == EcsOptional) {
-        if (term == filter->terms) {
-            return false;
-        }
-    }
+/**
+ * @file addons/script/interpolate.c
+ * @brief String interpolation.
+ */
 
-    return true;
-}
+
+#ifdef FLECS_SCRIPT
+#include <ctype.h>
 
 static
-int flecs_rule_compile_builtin_pred(
-    ecs_rule_t *rule,
-    ecs_term_t *term,
-    ecs_rule_op_t *op,
-    ecs_write_flags_t write_state)
+const char* flecs_parse_var_name(
+    const char *ptr,
+    char *token_out)
 {
-    ecs_entity_t id = term->first.id;
+    char ch, *bptr = token_out;
 
-    ecs_rule_op_kind_t eq[] = {EcsRulePredEq, EcsRulePredNeq};
-    ecs_rule_op_kind_t eq_name[] = {EcsRulePredEqName, EcsRulePredNeqName};
-    ecs_rule_op_kind_t eq_match[] = {EcsRulePredEqMatch, EcsRulePredNeqMatch};
-    
-    ecs_flags16_t flags_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
+    while ((ch = *ptr)) {
+        if (bptr - token_out > ECS_MAX_TOKEN_SIZE) {
+            goto error;
+        }
 
-    if (id == EcsPredEq) {
-        if (term->second.flags & EcsIsName) {
-            op->kind = flecs_ito(uint8_t, eq_name[term->oper == EcsNot]);
+        if (isalpha(ch) || isdigit(ch) || ch == '_') {
+            *bptr = ch;
+            bptr ++;
+            ptr ++;
         } else {
-            op->kind = flecs_ito(uint8_t, eq[term->oper == EcsNot]);
+            break;
         }
-    } else if (id == EcsPredMatch) {
-        op->kind = flecs_ito(uint8_t, eq_match[term->oper == EcsNot]);
     }
 
-    op->first = op->src;
-    op->src = (ecs_rule_ref_t){0};
-    op->flags &= (ecs_flags8_t)~((EcsRuleIsEntity|EcsRuleIsVar) << EcsRuleSrc);
-    op->flags &= (ecs_flags8_t)~((EcsRuleIsEntity|EcsRuleIsVar) << EcsRuleFirst);
-    op->flags |= EcsRuleIsVar << EcsRuleFirst;
-
-    if (flags_2nd & EcsRuleIsVar) {
-        if (!(write_state & (1ull << op->second.var))) {
-            ecs_err("uninitialized variable '%s' on right-hand side of "
-                "equality operator", 
-                    ecs_rule_var_name(rule, op->second.var));
-            return -1;
-        }
+    if (bptr == token_out) {
+        goto error;
     }
 
-    if (!(write_state & (1ull << op->first.var))) {
-        /* If this is an == operator with a right-hand side that resolves to a
-         * single entity, the left-hand side is allowed to be undefined, as the
-         * instruction will be evaluated as an assignment. */
-        if (op->kind != EcsRulePredEq && op->kind != EcsRulePredEqName) {
-            ecs_err("uninitialized variable '%s' on left-hand side of "
-                "equality operator", 
-                    ecs_rule_var_name(rule, op->first.var));
-            return -1;
-        }
-    }
+    *bptr = '\0';
 
-    return 0;
+    return ptr;
+error:
+    return NULL;
 }
 
 static
-int flecs_rule_ensure_scope_var(
-    ecs_rule_t *rule,
-    ecs_rule_op_t *op,
-    ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind,
-    ecs_rule_compile_ctx_t *ctx)
+const char* flecs_parse_interpolated_str(
+    const char *ptr,
+    char *token_out)
 {
-    ecs_var_id_t var = ref->var;
-
-    if (rule->vars[var].kind == EcsVarEntity && 
-        !flecs_rule_is_written(var, ctx->written)) 
-    {
-        ecs_var_id_t table_var = rule->vars[var].table_id;
-        if (table_var != EcsVarNone && 
-            flecs_rule_is_written(table_var, ctx->written)) 
-        {
-            if (flecs_rule_compile_ensure_vars(
-                rule, op, ref, ref_kind, ctx, false, NULL))
-            {
-                goto error;
-            }
+    char ch, *bptr = token_out;
 
+    while ((ch = *ptr)) {
+        if (bptr - token_out > ECS_MAX_TOKEN_SIZE) {
+            goto error;
         }
-    }
-
-    return 0;
-error:
-    return -1;
-}
 
-static
-int flecs_rule_ensure_scope_vars(
-    ecs_world_t *world,
-    ecs_rule_t *rule,
-    ecs_rule_compile_ctx_t *ctx,
-    ecs_term_t *term)
-{
-    /* If the scope uses variables as entity that have only been written as
-     * table, resolve them as entities before entering the scope. */
-    ecs_term_t *cur = term;
-    while(cur->first.id != EcsScopeClose) {
-        /* Dummy operation to obtain variable information for term */
-        ecs_rule_op_t op = {0};
-        flecs_rule_compile_term_id(world, rule, &op, &cur->first, 
-            &op.first, EcsRuleFirst, EcsVarEntity, ctx, false);
-        flecs_rule_compile_term_id(world, rule, &op, &cur->second, 
-            &op.second, EcsRuleSecond, EcsVarEntity, ctx, false);
-
-        if (op.flags & (EcsRuleIsVar << EcsRuleFirst)) {
-            if (flecs_rule_ensure_scope_var(
-                rule, &op, &op.first, EcsRuleFirst, ctx))
-            {
-                goto error;
-            }
-        }
-        if (op.flags & (EcsRuleIsVar << EcsRuleSecond)) {
-            if (flecs_rule_ensure_scope_var(
-                rule, &op, &op.second, EcsRuleSecond, ctx))
-            {
-                goto error;
+        if (ch == '\\') {
+            if (ptr[1] == '}') {
+                *bptr = '}';
+                bptr ++;
+                ptr += 2;
+                continue;
             }
         }
 
-        cur ++;
+        if (ch != '}') {
+            *bptr = ch;
+            bptr ++;
+            ptr ++;
+        } else {
+            ptr ++;
+            break;
+        }
     }
 
-    return 0;
-error:
-    return -1;
-}
-
-static
-void flecs_rule_compile_push(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ctx->cur = &ctx->ctrlflow[++ ctx->scope];
-    ctx->cur->lbl_begin = -1;
-    ctx->cur->lbl_begin = -1;
-}
+    if (bptr == token_out) {
+        goto error;
+    }
 
-static
-void flecs_rule_compile_pop(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ctx->cur = &ctx->ctrlflow[-- ctx->scope];
-}
+    *bptr = '\0';
 
-static
-bool flecs_rule_term_is_or(
-    const ecs_filter_t *filter,
-    const ecs_term_t *term)
-{
-    bool first_term = term == filter->terms;
-    return (term->oper == EcsOr) || (!first_term && term[-1].oper == EcsOr);
+    return ptr;
+error:
+    return NULL;
 }
 
-static
-int flecs_rule_compile_term(
+char* ecs_script_string_interpolate(
     ecs_world_t *world,
-    ecs_rule_t *rule,
-    ecs_term_t *term,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_filter_t *filter = &rule->filter;
-    bool first_term = term == filter->terms;
-    bool first_is_var = term->first.flags & EcsIsVariable;
-    bool second_is_var = term->second.flags & EcsIsVariable;
-    bool src_is_var = term->src.flags & EcsIsVariable;
-    bool builtin_pred = flecs_rule_is_builtin_pred(term);
-    bool is_not = (term->oper == EcsNot) && !builtin_pred;
-    bool is_or = flecs_rule_term_is_or(filter, term);
-    bool first_or = false, last_or = false;
-    bool cond_write = term->oper == EcsOptional || is_or;
-    ecs_rule_op_t op = {0};
-
-    if (is_or) {
-        first_or = first_term || (term[-1].oper != EcsOr);
-        last_or = term->oper != EcsOr;
-    }
-
-    /* !_ (don't match anything) terms always return nothing. */
-    if (is_not && term->id == EcsAny) {
-        op.kind = EcsRuleNothing;
-        flecs_rule_op_insert(&op, ctx);
-        return 0;
-    }
-
-    if (is_or && (first_term || term[-1].oper != EcsOr)) {
-        ctx->ctrlflow->cond_written_or = ctx->cond_written;
-        ctx->ctrlflow->in_or = true;
-    }
+    const char *str,
+    const ecs_script_vars_t *vars)
+{
+    char token[ECS_MAX_TOKEN_SIZE];
+    ecs_strbuf_t result = ECS_STRBUF_INIT;
+    const char *ptr;
+    char ch;
 
-    if (!term->src.id && term->src.flags & EcsIsEntity) {
-        /* If the term has a 0 source, check if it's a scope open/close */
-        if (term->first.id == EcsScopeOpen) {
-            if (flecs_rule_ensure_scope_vars(world, rule, ctx, term)) {
-                goto error;
+    for(ptr = str; (ch = *ptr); ptr++) {
+        if (ch == '\\') {
+            ptr ++;
+            if (ptr[0] == '$') {
+                ecs_strbuf_appendch(&result, '$');
+                continue;
             }
-            if (term->oper == EcsNot) {
-                ctx->scope_is_not |= (ecs_flags32_t)(1ull << ctx->scope);
-                flecs_rule_begin_block(EcsRuleNot, ctx);
-            } else {
-                ctx->scope_is_not &= (ecs_flags32_t)~(1ull << ctx->scope);
+            if (ptr[0] == '\\') {
+                ecs_strbuf_appendch(&result, '\\');
+                continue;
             }
-            flecs_rule_compile_push(ctx);
-        } else if (term->first.id == EcsScopeClose) {
-            flecs_rule_compile_pop(ctx);
-            if (ctx->scope_is_not & (ecs_flags32_t)(1ull << (ctx->scope))) {
-                ctx->cur->lbl_query = -1;
-                flecs_rule_end_block(ctx);
+            if (ptr[0] == '{') {
+                ecs_strbuf_appendch(&result, '{');
+                continue;
             }
-        } else {
-            /* Noop */
-        }
-        return 0;
-    }
-
-    if (builtin_pred) {
-        if (term->second.id == EcsWildcard || term->second.id == EcsAny) {
-            /* Noop */
-            return 0;
-        }
-    }
-
-    /* Default instruction for And operators. If the source is fixed (like for
-     * singletons or terms with an entity source), use With, which like And but
-     * just matches against a source (vs. finding a source). */
-    op.kind = src_is_var ? EcsRuleAnd : EcsRuleWith;
-    op.field_index = flecs_ito(int8_t, term->field_index);
-    op.term_index = flecs_ito(int8_t, term - filter->terms);
-
-    /* If rule is transitive, use Trav(ersal) instruction */
-    if (term->flags & EcsTermTransitive) {
-        ecs_assert(ecs_term_id_is_set(&term->second), ECS_INTERNAL_ERROR, NULL);
-        op.kind = EcsRuleTrav;
-    } else {
-        /* Ignore cascade & parent flags */
-        ecs_flags32_t trav_flags = EcsTraverseFlags & ~(EcsCascade|EcsParent);
-        if (term->flags & (EcsTermMatchAny|EcsTermMatchAnySrc)) {
-            op.kind = EcsRuleAndAny;
-        } else if ((term->src.flags & trav_flags) == EcsUp) {
-            op.kind = EcsRuleUp;
-        } else if ((term->src.flags & trav_flags) == (EcsSelf|EcsUp)) {
-            op.kind = EcsRuleSelfUp;
-        }
-    }
-
-    /* If term has fixed id, insert simpler instruction that skips dealing with
-     * wildcard terms and variables */
-    if (flecs_rule_term_fixed_id(filter, term)) {
-        if (op.kind == EcsRuleAnd) {
-            op.kind = EcsRuleAndId;
-        } else if (op.kind == EcsRuleSelfUp) {
-            op.kind = EcsRuleSelfUpId;
-        } else if (op.kind == EcsRuleUp) {
-            op.kind = EcsRuleUpId;
-        }
-    }
-
-    /* Save write state at start of term so we can use it to reliably track
-     * variables got written by this term. */
-    ecs_write_flags_t cond_write_state = ctx->cond_written;
-
-    /* Resolve component inheritance if necessary */
-    ecs_var_id_t first_var = EcsVarNone, second_var = EcsVarNone, src_var = EcsVarNone;
-
-    /* Resolve variables and entities for operation arguments */
-    flecs_rule_compile_term_id(world, rule, &op, &term->first, 
-        &op.first, EcsRuleFirst, EcsVarEntity, ctx, true);
-    flecs_rule_compile_term_id(world, rule, &op, &term->second, 
-        &op.second, EcsRuleSecond, EcsVarEntity, ctx, true);
-
-    if (first_is_var) first_var = op.first.var;
-    if (second_is_var) second_var = op.second.var;
-
-    flecs_rule_compile_term_id(world, rule, &op, &term->src, 
-        &op.src, EcsRuleSrc, EcsVarAny, ctx, true);
-    if (src_is_var) src_var = op.src.var;
-    bool src_written = flecs_rule_is_written(src_var, ctx->written);
-
-    /* Insert each instructions for table -> entity variable if needed */
-    bool first_written, second_written;
-    if (flecs_rule_compile_ensure_vars(
-        rule, &op, &op.first, EcsRuleFirst, ctx, cond_write, &first_written)) 
-    {
-        goto error;    
-    }
-    if (flecs_rule_compile_ensure_vars(
-        rule, &op, &op.second, EcsRuleSecond, ctx, cond_write, &second_written))
-    {
-        goto error;
-    }
-
-    /* If the query starts with a Not or Optional term, insert an operation that
-     * matches all entities. */
-    if (first_term && src_is_var && !src_written && term->src.id != EcsAny) {
-        bool pred_match = builtin_pred && term->first.id == EcsPredMatch;
-        if (term->oper == EcsNot || term->oper == EcsOptional || pred_match) {
-            ecs_rule_op_t match_any = {0};
-            match_any.kind = EcsAnd;
-            match_any.flags = EcsRuleIsSelf | (EcsRuleIsEntity << EcsRuleFirst);
-            match_any.flags |= (EcsRuleIsVar << EcsRuleSrc);
-            match_any.src = op.src;
-            match_any.field_index = -1;
-            if (!pred_match) {
-                match_any.first.entity = EcsAny;
-            } else {
-                /* If matching by name, instead of finding all tables, just find
-                 * the ones with a name. */
-                match_any.first.entity = ecs_id(EcsIdentifier);
-                match_any.second.entity = EcsName;
-                match_any.flags |= (EcsRuleIsEntity << EcsRuleSecond);
+            if (ptr[0] == '}') {
+                ecs_strbuf_appendch(&result, '}');
+                continue;
             }
-            match_any.written = (1ull << src_var);
-            flecs_rule_op_insert(&match_any, ctx);
-            flecs_rule_write_ctx(op.src.var, ctx, false);
-
-            /* Update write administration */
-            src_written = true;
-        }
-    }
-
-    /* A bit of special logic for OR expressions and equality predicates. If the
-     * left-hand of an equality operator is a table, and there are multiple
-     * operators in an Or expression, the Or chain should match all entities in
-     * the table that match the right hand sides of the operator expressions. 
-     * For this to work, the src variable needs to be resolved as entity, as an
-     * Or chain would otherwise only yield the first match from a table. */
-    if (src_is_var && src_written && builtin_pred && term->oper == EcsOr) {
-        /* Or terms are required to have the same source, so we don't have to
-         * worry about the last term in the chain. */
-        if (rule->vars[src_var].kind == EcsVarTable) {
-            flecs_rule_compile_term_id(world, rule, &op, &term->src, 
-                    &op.src, EcsRuleSrc, EcsVarEntity, ctx, true);
-            src_var = op.src.var;
+            ptr --;
         }
-    }
-
-    if (flecs_rule_compile_ensure_vars(
-        rule, &op, &op.src, EcsRuleSrc, ctx, cond_write, NULL)) 
-    {
-        goto error;
-    }
 
-    /* If source is Any (_) and first and/or second are unconstrained, insert an
-     * ids instruction instead of an And */
-    if (term->flags & EcsTermMatchAnySrc) {
-        op.kind = EcsRuleIds;
-        /* Use up-to-date written values after potentially inserting each */
-        if (!first_written || !second_written) {
-            if (!first_written) {
-                /* If first is unknown, traverse left: <- (*, t) */
-                if (term->first.id != EcsAny) {
-                    op.kind = EcsRuleIdsLeft;
-                }
-            } else {
-                /* If second is wildcard, traverse right: (r, *) -> */
-                if (term->second.id != EcsAny) {
-                    op.kind = EcsRuleIdsRight;
-                }
+        if (ch == '$') {
+            ptr = flecs_parse_var_name(ptr + 1, token);
+            if (!ptr) {
+                ecs_parser_error(NULL, str, ptr - str, 
+                    "invalid variable name '%s'", ptr);
+                goto error;
             }
-            op.src.entity = 0;
-            op.flags &= (ecs_flags8_t)~(EcsRuleIsVar << EcsRuleSrc); /* ids has no src */
-            op.flags &= (ecs_flags8_t)~(EcsRuleIsEntity << EcsRuleSrc);
-        }
-
-    /* If source variable is not written and we're querying just for Any, insert
-     * a dedicated instruction that uses the Any record in the id index. Any 
-     * queries that are evaluated against written sources can use Wildcard 
-     * records, which is what the AndAny instruction does. */
-    } else if (!src_written && term->id == EcsAny && op.kind == EcsRuleAndAny) {
-        /* Lookup variables ($var.child_name) are always written */
-        if (!rule->vars[src_var].lookup) {
-            op.kind = EcsRuleSelectAny; /* Uses Any (_) id record */
-        }
-    }
-
-    /* If this is a transitive term and both the target and source are unknown,
-     * find the targets for the relationship first. This clusters together 
-     * tables for the same target, which allows for more efficient usage of the
-     * traversal caches. */
-    if (term->flags & EcsTermTransitive && src_is_var && second_is_var) {
-        if (!src_written && !second_written) {
-            flecs_rule_insert_unconstrained_transitive(
-                rule, &op, ctx, cond_write);
-        }
-    }
 
-    /* Check if this term has variables that have been conditionally written,
-     * like variables written by an optional term. */
-    if (ctx->cond_written) {
-        if (!is_or || first_or) {
-            flecs_rule_begin_block_cond_eval(&op, ctx, cond_write_state);
-        }
-    }
+            ecs_script_var_t *var = ecs_script_vars_lookup(vars, token);
+            if (!var) {
+                ecs_parser_error(NULL, str, ptr - str, 
+                    "unresolved variable '%s'", token);
+                goto error;
+            }
 
-    /* Handle Not, Optional, Or operators */
-    if (is_not) {
-        flecs_rule_begin_block(EcsRuleNot, ctx);
-    } else if (term->oper == EcsOptional) {
-        flecs_rule_begin_block(EcsRuleOptional, ctx);
-    } else if (first_or) {
-        flecs_rule_begin_block_or(&op, term, ctx);
-    }
+            if (ecs_ptr_to_str_buf(
+                world, var->value.type, var->value.ptr, &result)) 
+            {
+                goto error;
+            }
 
-    /* If term has component inheritance enabled, insert instruction to walk
-     * down the relationship tree of the id. */
-    if (term->flags & EcsTermIdInherited) {
-        flecs_rule_insert_inheritance(rule, term, &op, ctx, cond_write);
-    }
+            ptr --;
+        } else if (ch == '{') {
+            ptr = flecs_parse_interpolated_str(ptr + 1, token);
+            if (!ptr) {
+                ecs_parser_error(NULL, str, ptr - str, 
+                    "invalid interpolated expression");
+                goto error;
+            }
 
-    op.match_flags = term->flags;
+            ecs_script_expr_run_desc_t expr_desc = { 
+                .vars = ECS_CONST_CAST(ecs_script_vars_t*, vars) 
+            };
 
-    if (first_is_var) {
-        op.first.var = first_var;
-        op.flags &= (ecs_flags8_t)~(EcsRuleIsEntity << EcsRuleFirst);
-        op.flags |= (EcsRuleIsVar << EcsRuleFirst);
-    }
+            ecs_value_t expr_result = {0};
+            if (!ecs_script_expr_run(world, token, &expr_result, &expr_desc)) {
+                goto error;
+            }
 
-    if (term->src.flags & EcsSelf) {
-        op.flags |= EcsRuleIsSelf;
-    }
+            if (ecs_ptr_to_str_buf(
+                world, expr_result.type, expr_result.ptr, &result)) 
+            {
+                goto error;
+            }
 
-    /* Insert instructions for lookup variables */
-    ecs_write_flags_t write_state = ctx->written;
-    if (first_is_var) {
-        if (flecs_rule_compile_lookup(rule, first_var, ctx, cond_write)) {
-            write_state |= (1ull << first_var); // lookups are resolved inline
-        }
-    }
-    if (src_is_var) {
-        if (flecs_rule_compile_lookup(rule, src_var, ctx, cond_write)) {
-            write_state |= (1ull << src_var); // lookups are resolved inline
-        }
-    }
-    if (second_is_var) {
-        if (flecs_rule_compile_lookup(rule, second_var, ctx, cond_write)) {
-            write_state |= (1ull << second_var); // lookups are resolved inline
-        }
-    }
+            ecs_value_free(world, expr_result.type, expr_result.ptr);
 
-    if (builtin_pred) {
-        if (flecs_rule_compile_builtin_pred(rule, term, &op, write_state)) {
-            goto error;
+            ptr --;
+        } else {
+            ecs_strbuf_appendch(&result, ch);
         }
     }
 
-    /* If we're writing the $this variable, filter out disabled/prefab entities
-     * unless the filter explicitly matches them.
-     * This could've been done with regular With instructions, but since 
-     * filtering out disabled/prefab entities is the default and this check is
-     * cheap to perform on table flags, it's worth special casing. */
-    if (!src_written && src_var == 0) {
-        ecs_flags32_t filter_flags = filter->flags;
-        if (!(filter_flags & EcsFilterMatchDisabled) || 
-            !(filter_flags & EcsFilterMatchPrefab)) 
-        {
-            ecs_flags32_t table_flags = 0;
-            if (!(filter_flags & EcsFilterMatchDisabled)) {
-                table_flags |= EcsTableIsDisabled;
-            }
-            if (!(filter_flags & EcsFilterMatchPrefab)) {
-                table_flags |= EcsTableIsPrefab;
-            }
-
-            op.other = flecs_itolbl(table_flags);
-        }
-    }
+    return ecs_strbuf_get(&result);
+error:
+    return NULL;
+}
 
-    /* After evaluating a term, a used variable is always written */
-    if (src_is_var) {
-        flecs_rule_write(src_var, &op.written);
-        flecs_rule_write_ctx(op.src.var, ctx, cond_write);
-    }
-    if (first_is_var) {
-        flecs_rule_write(first_var, &op.written);
-        flecs_rule_write_ctx(first_var, ctx, cond_write);
-    }
-    if (second_is_var) {
-        flecs_rule_write(second_var, &op.written);
-        flecs_rule_write_ctx(second_var, ctx, cond_write);
-    }
-    flecs_rule_op_insert(&op, ctx);
+#endif
 
-    ctx->cur->lbl_query = flecs_itolbl(ecs_vec_count(ctx->ops) - 1);
-    if (is_or) {
-        ecs_rule_op_t *op_ptr = ecs_vec_get_t(ctx->ops, ecs_rule_op_t, 
-            ctx->cur->lbl_query);
-        op_ptr->next = FlecsRuleOrMarker;
-    }
+/**
+ * @file addons/script/parser.c
+ * @brief Script grammar parser.
+ */
 
-    /* Handle self-references between src and first/second variables */
-    if (src_is_var) {
-        if (first_is_var) {
-            flecs_rule_insert_contains(rule, src_var, first_var, ctx);
-        }
-        if (second_is_var && first_var != second_var) {
-            flecs_rule_insert_contains(rule, src_var, second_var, ctx);
-        }
-    }
 
-    /* Handle self references between first and second variables */
-    if (first_is_var && !first_written && (first_var == second_var)) {
-        flecs_rule_insert_pair_eq(term->field_index, ctx);
-    }
+#ifdef FLECS_SCRIPT
+/**
+ * @file addons/script/parser.h
+ * @brief Script grammar parser.
+ * 
+ * Macro utilities that facilitate a simple recursive descent parser.
+ */
 
-    /* Handle closing of Not, Optional and Or operators */
-    if (is_not) {
-        flecs_rule_end_block(ctx);
-    } else if (term->oper == EcsOptional) {
-        flecs_rule_end_block(ctx);
-    } else if (last_or) {
-        flecs_rule_end_block_or(ctx);
-    }
+#ifndef FLECS_SCRIPT_PARSER_H
+#define FLECS_SCRIPT_PARSER_H
 
-    /* Handle closing of conditional evaluation */
-    if (ctx->cur->lbl_cond_eval && (first_is_var || second_is_var || src_is_var)) {
-        if (!is_or || last_or) {
-            flecs_rule_end_block_cond_eval(ctx);
-        }
-    }
+#if defined(ECS_TARGET_CLANG)
+/* Ignore unused enum constants in switch as it would blow up the parser code */
+#pragma clang diagnostic ignored "-Wswitch-enum"
+/* To allow for nested Parse statements */
+#pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
 
-    /* Ensure that term id is set after evaluating Not */
-    if (term->flags & EcsTermIdInherited) {
-        if (is_not) {
-            ecs_rule_op_t set_id = {0};
-            set_id.kind = EcsRuleSetId;
-            set_id.first.entity = term->id;
-            set_id.flags = (EcsRuleIsEntity << EcsRuleFirst);
-            set_id.field_index = flecs_ito(int8_t, term->field_index);
-            flecs_rule_op_insert(&set_id, ctx);
-        }
-    }
+/* Create script & parser structs with static token buffer */
+#define EcsParserFixedBuffer(w, script_name, expr, tokens, tokens_len)\
+    ecs_script_t script = {\
+        .world = ECS_CONST_CAST(ecs_world_t*, w),\
+        .name = script_name,\
+        .code = expr\
+    };\
+    ecs_script_parser_t parser = {\
+        .script = &script,\
+        .pos = expr,\
+        .token_cur = tokens\
+    }
+
+/* Definitions for parser functions */
+#define ParserBegin\
+    ecs_script_tokens_t token_stack = {0};\
+    ecs_script_token_t *tokens = token_stack.tokens;\
+    (void)tokens
+
+#define ParserEnd\
+        Error("unexpected end of rule (parser error)");\
+    error:\
+        return NULL
+
+/* Get token */
+#define Token(n) (tokens[n].value)
+
+/* Error */
+#define Error(...)\
+    ecs_parser_error(parser->script->name, parser->script->code,\
+        (pos - parser->script->code) - 1, __VA_ARGS__);\
+    goto error
+
+/* Parse expression */
+#define Expr(until, ...)\
+    {\
+        ecs_assert(token_stack.count < 256, ECS_INTERNAL_ERROR, NULL);\
+        ecs_script_token_t *t = &token_stack.tokens[token_stack.count ++];\
+        if (!(pos = flecs_script_expr(parser, pos, t, until))) {\
+            goto error;\
+        }\
+        if (!t->value[0] && (until == '\n' || until == '{')) {\
+            pos ++;\
+            Error("empty expression");\
+        }\
+    }\
+    Parse_1(until, __VA_ARGS__)
+
+/* Parse token until character */
+#define Until(until, ...)\
+    {\
+        ecs_assert(token_stack.count < 256, ECS_INTERNAL_ERROR, NULL);\
+        ecs_script_token_t *t = &token_stack.tokens[token_stack.count ++];\
+        if (!(pos = flecs_script_until(parser, pos, t, until))) {\
+            goto error;\
+        }\
+    }\
+    Parse_1(until, __VA_ARGS__)
+
+/* Parse next token */
+#define Parse(...)\
+    {\
+        ecs_assert(token_stack.count < 256, ECS_INTERNAL_ERROR, NULL);\
+        ecs_script_token_t *t = &token_stack.tokens[token_stack.count ++];\
+        if (!(pos = flecs_script_token(parser, pos, t, false))) {\
+            goto error;\
+        }\
+        switch(t->kind) {\
+            __VA_ARGS__\
+        default:\
+            if (t->value) {\
+                Error("unexpected %s'%s'", \
+                    flecs_script_token_kind_str(t->kind), t->value);\
+            } else {\
+                Error("unexpected %s", \
+                    flecs_script_token_kind_str(t->kind));\
+            }\
+        }\
+    }
+
+/* Parse N consecutive tokens */
+#define Parse_1(tok, ...)\
+    Parse(\
+        case tok: {\
+            __VA_ARGS__\
+        }\
+    )
+
+#define Parse_2(tok1, tok2, ...)\
+    Parse_1(tok1, \
+        Parse(\
+            case tok2: {\
+                __VA_ARGS__\
+            }\
+        )\
+    )
+
+#define Parse_3(tok1, tok2, tok3, ...)\
+    Parse_2(tok1, tok2, \
+        Parse(\
+            case tok3: {\
+                __VA_ARGS__\
+            }\
+        )\
+    )
+
+#define Parse_4(tok1, tok2, tok3, tok4, ...)\
+    Parse_3(tok1, tok2, tok3, \
+        Parse(\
+            case tok4: {\
+                __VA_ARGS__\
+            }\
+        )\
+    )
+
+#define Parse_5(tok1, tok2, tok3, tok4, tok5, ...)\
+    Parse_4(tok1, tok2, tok3, tok4, \
+        Parse(\
+            case tok5: {\
+                __VA_ARGS__\
+            }\
+        )\
+    )
+
+/* Same as Parse, but doesn't error out if token is not in handled cases */
+#define LookAhead(...)\
+    const char *lookahead;\
+    ecs_script_token_t lookahead_token;\
+    if ((lookahead = flecs_script_token(parser, pos, &lookahead_token, true))) {\
+        token_stack.tokens[token_stack.count ++] = lookahead_token;\
+        switch(lookahead_token.kind) {\
+            __VA_ARGS__\
+        default:\
+            token_stack.count --;\
+            break;\
+        }\
+    }
+
+/* Lookahead N consecutive tokens */
+#define LookAhead_1(tok, ...)\
+    LookAhead(\
+        case tok: {\
+            __VA_ARGS__\
+        }\
+    )
+
+#define LookAhead_2(tok1, tok2, ...)\
+    LookAhead_1(tok1, \
+        const char *old_ptr = pos;\
+        pos = lookahead;\
+        LookAhead(\
+            case tok2: {\
+                __VA_ARGS__\
+            }\
+        )\
+        pos = old_ptr;\
+    )
+
+#define LookAhead_3(tok1, tok2, tok3, ...)\
+    LookAhead_2(tok1, tok2, \
+        const char *old_ptr = pos;\
+        pos = lookahead;\
+        LookAhead(\
+            case tok3: {\
+                __VA_ARGS__\
+            }\
+        )\
+        pos = old_ptr;\
+    )
+
+/* Open scope */
+#define Scope(s, ...) {\
+        ecs_script_scope_t *old_scope = parser->scope;\
+        parser->scope = s;\
+        __VA_ARGS__\
+        parser->scope = old_scope;\
+    }
+
+/* Parser loop */
+#define Loop(...)\
+    int32_t token_stack_count = token_stack.count;\
+    do {\
+        token_stack.count = token_stack_count;\
+        __VA_ARGS__\
+    } while (true);
 
-    return 0;
-error:
-    return -1;
-}
+#define EndOfRule return pos
 
-static
-bool flecs_rule_var_is_unknown(
-    ecs_rule_t *rule,
-    ecs_var_id_t var_id,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_var_t *vars = rule->vars;
-    if (ctx->written & (1ull << var_id)) {
-        return false;
-    } else {
-        ecs_var_id_t table_var = vars[var_id].table_id;
-        if (table_var != EcsVarNone) {
-            return flecs_rule_var_is_unknown(rule, table_var, ctx);
-        }
-    }
-    return true;
-}
+#endif
+
+
+#define EcsTokEndOfStatement\
+    case ';':\
+    case '\n':\
+    case '\0'
 
-/* Returns whether term is unkown. A term is unknown when it has variable 
- * elements (first, second, src) that are all unknown. */
 static
-bool flecs_rule_term_is_unknown(
-    ecs_rule_t *rule, 
-    ecs_term_t *term, 
-    ecs_rule_compile_ctx_t *ctx) 
+const char* flecs_script_stmt(
+    ecs_script_parser_t *parser,
+    const char *pos);
+
+/* Parse scope (statements inside {}) */
+static
+const char* flecs_script_scope(
+    ecs_script_parser_t *parser,
+    ecs_script_scope_t *scope,
+    const char *pos)
 {
-    ecs_rule_op_t dummy = {0};
-    flecs_rule_compile_term_id(NULL, rule, &dummy, &term->first, 
-        &dummy.first, EcsRuleFirst, EcsVarEntity, ctx, false);
-    flecs_rule_compile_term_id(NULL, rule, &dummy, &term->second, 
-        &dummy.second, EcsRuleSecond, EcsVarEntity, ctx, false);
-    flecs_rule_compile_term_id(NULL, rule, &dummy, &term->src, 
-        &dummy.src, EcsRuleSrc, EcsVarAny, ctx, false);
+    ParserBegin;
 
-    bool has_vars = dummy.flags & 
-        ((EcsRuleIsVar << EcsRuleFirst) |
-         (EcsRuleIsVar << EcsRuleSecond) |
-         (EcsRuleIsVar << EcsRuleSrc));
-    if (!has_vars) {
-        /* If term has no variables (typically terms with a static src) there
-         * can't be anything that's unknown. */
-        return false;
-    }
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(pos[-1] == '{', ECS_INTERNAL_ERROR, NULL);
 
-    if (dummy.flags & (EcsRuleIsVar << EcsRuleFirst)) {
-        if (!flecs_rule_var_is_unknown(rule, dummy.first.var, ctx)) {
-            return false;
-        }
-    }
-    if (dummy.flags & (EcsRuleIsVar << EcsRuleSecond)) {
-        if (!flecs_rule_var_is_unknown(rule, dummy.second.var, ctx)) {
-            return false;
-        }
-    }
-    if (dummy.flags & (EcsRuleIsVar << EcsRuleSrc)) {
-        if (!flecs_rule_var_is_unknown(rule, dummy.src.var, ctx)) {
-            return false;
+    ecs_script_scope_t *prev = parser->scope;
+    parser->scope = scope;
+
+    Loop(
+        LookAhead(
+            case EcsTokScopeClose:
+                pos = lookahead;
+                goto scope_close;
+            case EcsTokEnd:
+                Error("unexpected end of script");
+                goto error;
+        )
+
+        pos = flecs_script_stmt(parser, pos);
+        if (!pos) {
+            goto error;
         }
-    }
+    )
 
-    return true;
+scope_close:
+    parser->scope = prev;
+
+    ecs_assert(pos[-1] == '}', ECS_INTERNAL_ERROR, NULL);
+    return pos;
+
+    ParserEnd;
 }
 
-/* Find the next known term from specified offset. This function is used to find
- * a term that can be evaluated before a term that is unknown. Evaluating known
- * before unknown terms can significantly decrease the search space. */
+/* Parse comma expression (expressions separated by ',') */
 static
-int32_t flecs_rule_term_next_known(
-    ecs_rule_t *rule, 
-    ecs_rule_compile_ctx_t *ctx,
-    int32_t offset,
-    ecs_flags64_t compiled) 
+const char* flecs_script_comma_expr(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    bool is_base_list)
 {
-    ecs_filter_t *filter = &rule->filter;
-    ecs_term_t *terms = filter->terms;
-    int32_t i, count = filter->term_count;
+    ParserBegin;
 
-    for (i = offset; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (compiled & (1ull << i)) {
-            continue;
-        }
+    Loop(
+        LookAhead(
+            case '\n':
+                pos = lookahead;
+                continue;
 
-        /* Only evaluate And terms */
-        if (term->oper != EcsAnd || flecs_rule_term_is_or(&rule->filter, term)){
-            continue;
-        }
+            case EcsTokIdentifier:
+                pos = lookahead;
 
-        /* Don't reorder terms before/after scopes */
-        if (term->first.id == EcsScopeOpen || term->first.id == EcsScopeClose) {
-            return -1;
-        }
+                if (is_base_list) {
+                    flecs_script_insert_pair_tag(parser, "IsA", Token(0));
+                } else {
+                    flecs_script_insert_entity(parser, Token(0));
+                }
 
-        if (flecs_rule_term_is_unknown(rule, term, ctx)) {
-            continue;
-        }
+                LookAhead_1(',',
+                    pos = lookahead;
+                    continue;
+                )
+        )
 
-        return i;
-    }
+        break;
+    )
 
-    return -1;
+    return pos;
 }
 
-/* If the first part of a query contains more than one trivial term, insert a
- * special instruction which batch-evaluates multiple terms. */
+/* Parse with expression (expression after 'with' keyword) */
 static
-int32_t flecs_rule_insert_trivial_search(
-    ecs_rule_t *rule,
-    ecs_rule_compile_ctx_t *ctx)
+const char* flecs_script_with_expr(
+    ecs_script_parser_t *parser,
+    const char *pos)
 {
-    ecs_filter_t *filter = &rule->filter;
-    ecs_term_t *terms = filter->terms;
-    int32_t i, term_count = filter->term_count;
+    ParserBegin;
 
-    /* Find trivial terms, which can be handled in single instruction */
-    int32_t trivial_wildcard_terms = 0;
-    int32_t trivial_data_terms = 0;
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (!(term->flags & EcsTermIsTrivial)) {
-            break;
-        }
+    Parse(
+        // Position
+        case EcsTokIdentifier: {
+            // Position (
+            LookAhead_1('(',
+                pos = lookahead;
 
-        /* We can only add trivial terms to plan if they no up traversal */
-        if ((term->src.flags & EcsTraverseFlags) != EcsSelf) {
-            break;
-        }
+                // Position ( expr )
+                Expr(')',
+                    ecs_script_component_t *component =
+                        flecs_script_insert_component(parser, Token(0));
+                    component->node.kind = EcsAstWithComponent;
+                    component->expr = Token(2);
+                    EndOfRule;
+                )
+            )
 
-        if (ecs_id_is_wildcard(term->id)) {
-            trivial_wildcard_terms ++;
-        }
+            if (Token(0)[0] == '$') {
+                ecs_script_var_component_t *var = 
+                    flecs_script_insert_var_component(parser, &Token(0)[1]);
+                var->node.kind = EcsAstWithVar;
+            } else {
+                ecs_script_tag_t *tag =
+                    flecs_script_insert_tag(parser, Token(0));
+                tag->node.kind = EcsAstWithTag;
+            }
 
-        if (!(term->flags & EcsTermNoData)) {
-            trivial_data_terms ++;
+            EndOfRule;
         }
-    }
 
-    int32_t trivial_terms = i;
-    if (trivial_terms >= 2) {
-        /* If there's more than 1 trivial term, batch them in trivial search */
-        ecs_rule_op_t trivial = {0};
-        if (trivial_wildcard_terms) {
-            trivial.kind = EcsRuleTrivWildcard;
-        } else {
-            if (trivial_data_terms) {
-                /* Check to see if there are remaining data terms. If there are,
-                 * we'll have to insert an instruction later that populates all
-                 * fields, so don't do double work here. */
-                for (i = trivial_terms; i < term_count; i ++) {
-                    ecs_term_t *term = &terms[i];
-                    if (!(term->flags & EcsTermIsTrivial)) {
-                        break;
-                    }
-                }
-                if (trivial_terms == term_count || i != term_count) {
-                    /* Nobody else is going to set the data fields, so we should
-                     * do it here. */
-                    trivial.kind = EcsRuleTrivData;
-                }
-            }
-            if (!trivial.kind) {
-                trivial.kind = EcsRuleTriv;
-            }
-        }
+        // (
+        case '(':
+            // (Eats, Apples)
+            Parse_4(EcsTokIdentifier, ',', EcsTokIdentifier, ')',
+                // (Eats, Apples) ( expr
+                LookAhead_1('(',
+                    pos = lookahead;
 
-        /* Store on the operation how many trivial terms should be evaluated */
-        trivial.other = (ecs_rule_lbl_t)trivial_terms;
-        flecs_rule_op_insert(&trivial, ctx);
-    } else {
-        /* If fewer than 1 trivial term, there's no point in batching them */
-        trivial_terms = 0;
-    }
+                    // (Eats, Apples) ( expr )
+                    Expr(')',
+                        ecs_script_component_t *component =
+                            flecs_script_insert_pair_component(parser, 
+                                Token(1), Token(3));
+                        component->node.kind = EcsAstWithComponent;
+                        component->expr = Token(6);
+                        EndOfRule;
+                    )
+                )
 
-    return trivial_terms;
+                ecs_script_tag_t *tag = 
+                    flecs_script_insert_pair_tag(parser, Token(1), Token(3));
+                tag->node.kind = EcsAstWithTag;
+                EndOfRule;
+            )
+    )
+
+    ParserEnd;
 }
 
-/* Insert instruction to populate data fields. */
+/* Parse with expression list (expression list after 'with' keyword) */
 static
-void flecs_rule_insert_populate(
-    ecs_rule_t *rule,
-    ecs_rule_compile_ctx_t *ctx,
-    int32_t trivial_terms)
-{
-    ecs_filter_t *filter = &rule->filter;
-    int32_t i, term_count = filter->term_count;
-
-    /* Insert instruction that populates data. This instruction does not
-     * have to be inserted if the filter provides no data, or if all terms
-     * of the filter are trivial, in which case the trivial search operation
-     * also sets the data. */
-    if (!(filter->flags & EcsFilterNoData) && (trivial_terms != term_count)) {
-        int32_t data_fields = 0;
-        bool only_self = true;
-
-        /* There are two instructions for setting data fields, a fast one 
-         * that only supports owned fields, and one that supports any kind
-         * of field. Loop through (remaining) terms to check which one we
-         * need to use. */
-        for (i = trivial_terms; i < term_count; i ++) {
-            ecs_term_t *term = &filter->terms[i];
-            if (term->flags & EcsTermNoData) {
-                /* Don't care about terms that have no data */
-                continue;
-            }
+const char* flecs_script_with(
+    ecs_script_parser_t *parser,
+    ecs_script_with_t *with,
+    const char *pos)
+{
+    ParserBegin;
 
-            data_fields ++;
+    bool has_next;
+    do {
+        Scope(with->expressions, 
+            pos = flecs_script_with_expr(parser, pos);
+        )
 
-            if (!ecs_term_match_this(term)) {
-                break;
-            }
+        if (!pos) {
+            goto error;
+        }
 
-            if (term->src.flags & EcsUp) {
+        Parse(
+            case ',': {
+                has_next = true;
                 break;
             }
-        }
-
-        if (i != filter->term_count) {
-            only_self = false; /* Needs the more complex operation */
-        }
-
-        if (data_fields) {
-            if (only_self) {
-                ecs_rule_op_t nothing = {0};
-                nothing.kind = EcsRulePopulateSelf;
-                flecs_rule_op_insert(&nothing, ctx);
-            } else {
-                ecs_rule_op_t nothing = {0};
-                nothing.kind = EcsRulePopulate;
-                flecs_rule_op_insert(&nothing, ctx);
+            case '{': {
+                return flecs_script_scope(parser, with->scope, pos);
             }
-        }
-    }
+        )
+    } while (has_next);
+
+    ParserEnd;
 }
 
-int flecs_rule_compile(
-    ecs_world_t *world,
-    ecs_stage_t *stage,
-    ecs_rule_t *rule)
+/* Parse a single statement */
+static
+const char* flecs_script_stmt(
+    ecs_script_parser_t *parser,
+    const char *pos) 
 {
-    ecs_filter_t *filter = &rule->filter;
-    ecs_term_t *terms = filter->terms;
-    ecs_rule_compile_ctx_t ctx = {0};
-    ecs_vec_reset_t(NULL, &stage->operations, ecs_rule_op_t);
-    ctx.ops = &stage->operations;
-    ctx.cur = ctx.ctrlflow;
-    ctx.cur->lbl_begin = -1;
-    ctx.cur->lbl_begin = -1;
-    ecs_vec_clear(ctx.ops);
+    ParserBegin;
 
-    /* Find all variables defined in query */
-    if (flecs_rule_discover_vars(stage, rule)) {
-        return -1;
-    }
+    Parse(
+        case EcsTokIdentifier:        goto identifier;
+        case '{':                     return flecs_script_scope(parser, 
+                                        flecs_script_insert_scope(parser), pos);
+        case '(':                     goto paren;
+        case '@':                     goto annotation;
+        case EcsTokKeywordWith:       goto with_stmt;
+        case EcsTokKeywordModule:     goto module_stmt;
+        case EcsTokKeywordUsing:      goto using_stmt;
+        case EcsTokKeywordAssembly:   goto assembly_stmt;
+        case EcsTokKeywordProp:       goto prop_var;
+        case EcsTokKeywordConst:      goto const_var;
+        case EcsTokKeywordIf:         goto if_stmt;
+        EcsTokEndOfStatement:         EndOfRule;
+    );
 
-    /* If rule contains fixed source terms, insert operation to set sources */
-    int32_t i, term_count = filter->term_count;
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (term->src.flags & EcsIsEntity) {
-            ecs_rule_op_t set_fixed = {0};
-            set_fixed.kind = EcsRuleSetFixed;
-            flecs_rule_op_insert(&set_fixed, &ctx);
-            break;
+identifier: {
+    // enterprise } (end of scope)
+    LookAhead_1('}',
+        goto insert_tag;
+    )
+
+    Parse(
+        // enterprise {
+        case '{': {
+            return flecs_script_scope(parser, 
+                flecs_script_insert_entity(
+                    parser, Token(0))->scope, pos);
         }
-    }
 
-    /* If the rule contains terms with fixed ids (no wildcards, variables), 
-     * insert instruction that initializes ecs_iter_t::ids. This allows for the
-     * insertion of simpler instructions later on. */
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (flecs_rule_term_fixed_id(filter, term) || 
-           (term->src.flags & EcsIsEntity && !term->src.id)) 
-        {
-            ecs_rule_op_t set_ids = {0};
-            set_ids.kind = EcsRuleSetIds;
-            flecs_rule_op_insert(&set_ids, &ctx);
-            break;
+        // Red,
+        case ',': {
+            flecs_script_insert_entity(parser, Token(0));
+            pos = flecs_script_comma_expr(parser, pos, false);
+            EndOfRule;
         }
-    }
 
-    /* Insert trivial term search if query allows for it */
-    int32_t trivial_terms = flecs_rule_insert_trivial_search(rule, &ctx);
+        // Npc\n
+        EcsTokEndOfStatement: {
+            // Npc\n{
+            LookAhead_1('{',
+                pos = lookahead;
+                return flecs_script_scope(parser, 
+                    flecs_script_insert_entity(
+                        parser, Token(0))->scope, pos);
+            )
 
-    /* Compile remaining query terms to instructions */
-    ecs_flags64_t compiled = 0;
-    for (i = trivial_terms; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        int32_t compile = i;
+            goto insert_tag;
+        }
 
-        if (compiled & (1ull << i)) {
-            continue; /* Already compiled */
+        // Position:
+        case ':': {
+            goto identifier_colon;
         }
 
-        bool can_reorder = true;
-        if (term->oper != EcsAnd || flecs_rule_term_is_or(&rule->filter, term)){
-            can_reorder = false;
+        // x =
+        case '=': {
+            goto identifier_assign;
         }
 
-        /* If variables have been written, but this term has no known variables,
-         * first try to resolve terms that have known variables. This can 
-         * significantly reduce the search space. 
-         * Only perform this optimization after at least one variable has been
-         * written to, as all terms are unknown otherwise. */
-        if (can_reorder && ctx.written && 
-            flecs_rule_term_is_unknown(rule, term, &ctx)) 
-        {
-            int32_t term_index = flecs_rule_term_next_known(
-                rule, &ctx, i + 1, compiled);
-            if (term_index != -1) {
-                term = &rule->filter.terms[term_index];
-                compile = term_index;
-                i --; /* Repeat current term */
-            }
+        // SpaceShip(
+        case '(': {
+            goto identifier_paren;
         }
 
-        if (flecs_rule_compile_term(world, rule, term, &ctx)) {
-            return -1;
+        // Spaceship enterprise
+        case EcsTokIdentifier: {
+            goto identifier_identifier;
         }
+    )
+}
 
-        compiled |= (1ull << compile);
-    }
+insert_tag: {
+    if (Token(0)[0] == '$') {
+        if (!flecs_script_insert_var_component(parser, &Token(0)[1])) {
+            Error(
+                "invalid context for variable component '%s': must be "
+                    "part of entity", tokens[0].value);
+        }
+    } else {
+        if (!flecs_script_insert_tag(parser, Token(0))) {
+            Error(
+                "invalid context for tag '%s': must be part of entity", 
+                tokens[0].value);
+        }
+    }
+
+    EndOfRule;
+}
+
+// @
+annotation: {
+    // @brief
+    Parse_1(EcsTokIdentifier,
+        // $brief expr
+        Until('\n', 
+            flecs_script_insert_annot(parser, Token(1), Token(2));
+            EndOfRule;
+        )
+    )
+}
+
+// with
+with_stmt: {
+    ecs_script_with_t *with = flecs_script_insert_with(parser);
+    pos = flecs_script_with(parser, with, pos);
+    EndOfRule;
+}
+
+// using
+using_stmt: {
+    // using flecs.meta\n
+    Parse_2(EcsTokIdentifier, '\n',
+        flecs_script_insert_using(parser, Token(1));
+        EndOfRule;
+    )
+}
+
+// module
+module_stmt: {
+    // using flecs.meta\n
+    Parse_2(EcsTokIdentifier, '\n',
+        flecs_script_insert_module(parser, Token(1));
+        EndOfRule;
+    )
+}
+
+// assembly
+assembly_stmt: {
+    // assembly SpaceShip
+    Parse_1(EcsTokIdentifier, 
+        ecs_script_assembly_node_t *assembly = flecs_script_insert_assembly(
+            parser, Token(1));
+
+        Parse(
+            // assembly SpaceShip {
+            case '{':
+                return flecs_script_scope(parser, assembly->scope, pos);
+
+            // assembly SpaceShip\n
+            EcsTokEndOfStatement:
+                EndOfRule;
+        )
+    )
+}
+
+// prop
+prop_var: {
+    // prop color = Color:
+    Parse_4(EcsTokIdentifier, '=', EcsTokIdentifier, ':',
+        ecs_script_var_node_t *var = flecs_script_insert_var(
+            parser, Token(1));
+        var->node.kind = EcsAstProp;
+        var->type = Token(3);
+
+        // prop color = Color : {
+        LookAhead_1('{',
+            // prop color = Color: {expr}
+            pos = lookahead;
+            Expr('}',
+                var->expr = Token(6);
+                EndOfRule;
+            )
+        )
+
+        // prop color = Color : expr\n
+        Expr('\n',
+            var->expr = Token(5);
+            EndOfRule;
+        )
+    )
+}
+
+// const
+const_var: {
+    // const color
+    Parse_1(EcsTokIdentifier,
+        ecs_script_var_node_t *var = flecs_script_insert_var(
+            parser, Token(1));
+        var->node.kind = EcsAstConst;
+
+        Parse(
+            // const color =
+            case '=': {
+                // const color = Color :
+                LookAhead_2(EcsTokIdentifier, ':',
+                    pos = lookahead;
+
+                    var->type = Token(3);
+
+                    // const color = Color: {
+                    LookAhead_1('{',
+                        // const color = Color: {expr}
+                        pos = lookahead;
+                        Expr('}',
+                            var->expr = Token(6);
+                            EndOfRule;
+                        )
+                    )
+
+                    // const color = Color: expr\n
+                    Expr('\n',
+                        var->expr = Token(5);
+                        EndOfRule;
+                    )
+                )
+
+                // const PI = expr\n
+                Expr('\n',
+                    var->expr = Token(3);
+                    EndOfRule;
+                )
+            }
+        )
+    )
+}
+
+// if
+if_stmt: {
+    // if expr {
+    Expr('{',
+        ecs_script_if_t *stmt = flecs_script_insert_if(parser);
+        stmt->expr = Token(1);
+        pos = flecs_script_scope(parser, stmt->if_true, pos);
+        if (!pos) {
+            goto error;
+        }
 
-    ecs_var_id_t this_id = flecs_rule_find_var_id(rule, "This", EcsVarEntity);
+        // if expr { } else
+        LookAhead_1(EcsTokKeywordElse, 
+            pos = lookahead;
 
-    /* If This variable has been written as entity, insert an operation to 
-     * assign it to it.entities for consistency. */
-    if (this_id != EcsVarNone && (ctx.written & (1ull << this_id))) {
-        ecs_rule_op_t set_this = {0};
-        set_this.kind = EcsRuleSetThis;
-        set_this.flags |= (EcsRuleIsVar << EcsRuleFirst);
-        set_this.first.var = this_id;
-        flecs_rule_op_insert(&set_this, &ctx);
-    }
+            // if expr { } else {
+            Parse_1('{',
+                return flecs_script_scope(parser, stmt->if_false, pos);
+            )
+        )
 
-    /* Make sure non-This variables are written as entities */
-    if (rule->vars) {
-        for (i = 0; i < rule->var_count; i ++) {
-            ecs_rule_var_t *var = &rule->vars[i];
-            if (var->id && var->kind == EcsVarTable && var->name) {
-                ecs_var_id_t var_id = flecs_rule_find_var_id(rule, var->name,
-                    EcsVarEntity);
-                if (!flecs_rule_is_written(var_id, ctx.written)) {
-                    /* Skip anonymous variables */
-                    if (!flecs_rule_var_is_anonymous(rule, var_id)) {
-                        flecs_rule_insert_each(var->id, var_id, &ctx, false);
-                    }
-                }
-            }
+        EndOfRule;
+    )
+}
+
+// (
+paren: {
+    // (Likes, Apples)
+    Parse_4(EcsTokIdentifier, ',', EcsTokIdentifier, ')',
+        goto pair;
+    )
+}
+
+// (Likes, Apples)
+pair: {
+    // (Likes, Apples) } (end of scope)
+    LookAhead_1('}',
+        flecs_script_insert_pair_tag(parser, Token(1), Token(3));
+        EndOfRule;
+    )
+
+    Parse(
+        // (Likes, Apples)\n
+        EcsTokEndOfStatement: {
+            flecs_script_insert_pair_tag(parser, Token(1), Token(3));
+            EndOfRule;
         }
-    }
 
-    /* If rule contains non-This variables as term source, build lookup array */
-    if (rule->src_vars) {
-        ecs_assert(rule->vars != NULL, ECS_INTERNAL_ERROR, NULL);
-        bool only_anonymous = true;
+        // (Eats, Apples):
+        case ':': {
+            // (Eats, Apples): {
+            Parse_1('{',
+                // (Eats, Apples): { expr }
+                Expr('}',
+                    ecs_script_component_t *comp = 
+                        flecs_script_insert_pair_component(
+                            parser, Token(1), Token(3));
+                    comp->expr = Token(7);
+                    EndOfRule;
+                )
+            )
+        }
 
-        for (i = 0; i < filter->field_count; i ++) {
-            ecs_var_id_t var_id = rule->src_vars[i];
-            if (!var_id) {
-                continue;
-            }
+        // (IsA, Machine) {
+        case '{': {
+            ecs_script_pair_scope_t *ps = flecs_script_insert_pair_scope(
+                parser, Token(1), Token(3));
+            return flecs_script_scope(parser, ps->scope, pos);
+        }
+    )
+}
 
-            if (!flecs_rule_var_is_anonymous(rule, var_id)) {
-                only_anonymous = false;
-                break;
-            } else {
-                /* Don't fetch component data for anonymous variables. Because
-                 * not all metadata (such as it.sources) is initialized for
-                 * anonymous variables, and because they may only be available
-                 * as table variables (each is not guaranteed to be inserted for
-                 * anonymous variables) the iterator may not have sufficient
-                 * information to resolve component data. */
-                for (int32_t t = 0; t < filter->term_count; t ++) {
-                    ecs_term_t *term = &filter->terms[t];
-                    if (term->field_index == i) {
-                        term->inout = EcsInOutNone;
+// Position:
+identifier_colon: {
+    {
+        // Position: {
+        LookAhead_1('{',
+            pos = lookahead;
+            goto component_expr_scope;
+        )
+    }
+
+    {
+        // Position: {
+        LookAhead_1('[',
+            pos = lookahead;
+            goto component_expr_collection;
+        )
+    }
+
+    // enterprise : SpaceShip
+    Parse_1(EcsTokIdentifier, {
+        ecs_script_entity_t *entity = flecs_script_insert_entity(
+            parser, Token(0));
+
+        Scope(entity->scope, 
+            flecs_script_insert_pair_tag(parser, "IsA", Token(2));
+
+            LookAhead_1(',', {
+                pos = lookahead;
+                pos = flecs_script_comma_expr(parser, pos, true);
+            })
+        )
+
+        Parse(
+            // enterprise : SpaceShip\n
+            EcsTokEndOfStatement:
+                EndOfRule;
+
+            // enterprise : SpaceShip {
+            case '{':
+                return flecs_script_scope(parser, entity->scope, pos);
+        )
+    })
+}
+
+// x =
+identifier_assign: {
+    ecs_script_entity_t *entity = flecs_script_insert_entity(
+        parser, Token(0));
+
+    // x = Position: {
+    LookAhead_2(EcsTokIdentifier, ':',
+        pos = lookahead;
+
+        Parse_1('{', {
+            // x = Position: {expr}
+            Expr('}', 
+                Scope(entity->scope, 
+                    ecs_script_component_t *comp = 
+                        flecs_script_insert_component(parser, Token(2));
+                    comp->expr = Token(5);
+                )
+
+                // x = Position: {expr}\n
+                Parse(
+                    EcsTokEndOfStatement:
+                        EndOfRule;
+                )
+            )
+        })
+    )
+
+    // x = f32\n
+    Expr('\n',
+        Scope(entity->scope, 
+            ecs_script_default_component_t *comp = 
+                flecs_script_insert_default_component(parser);
+            comp->expr = Token(2);
+        )
+        
+        EndOfRule;
+    )
+}
+
+// Spaceship enterprise
+identifier_identifier: {
+    Parse(
+        // Spaceship enterprise\n
+        EcsTokEndOfStatement: {
+            ecs_script_entity_t *entity = flecs_script_insert_entity(
+                parser, Token(1));
+            entity->kind = Token(0);
+            EndOfRule;
+        }
+
+        // Spaceship enterprise {
+        case '{': {
+            ecs_script_entity_t *entity = flecs_script_insert_entity(
+                parser, Token(1));
+            entity->kind = Token(0);
+            return flecs_script_scope(parser, entity->scope, pos);
+        }
+
+        // Spaceship enterprise(
+        case '(': {
+            goto component_expr_paren;
+        }
+    )
+}
+
+// SpaceShip(
+identifier_paren: {
+    // SpaceShip()
+    Expr(')', 
+        Parse(
+            // SpaceShip(expr)\n
+            EcsTokEndOfStatement: {
+                ecs_script_entity_t *entity = flecs_script_insert_entity(
+                    parser, NULL);
+
+                Scope(entity->scope, 
+                    ecs_script_component_t *comp = 
+                        flecs_script_insert_component(parser, Token(0)); 
+                    comp->expr = Token(2);
+                    if (!ecs_os_strcmp(comp->expr, "{}")) {
+                        comp->expr = NULL;
                     }
-                }
+                )
+
+                EndOfRule;
             }
-        }
 
-        /* Don't insert setvar instruction if all vars are anonymous */
-        if (!only_anonymous) {
-            ecs_rule_op_t set_vars = {0};
-            set_vars.kind = EcsRuleSetVars;
-            flecs_rule_op_insert(&set_vars, &ctx);
-        }
+            // SpaceShip(expr) {
+            case '{': {
+                ecs_script_entity_t *entity = flecs_script_insert_entity(
+                    parser, NULL);
 
-        for (i = 0; i < filter->field_count; i ++) {
-            ecs_var_id_t var_id = rule->src_vars[i];
-            if (!var_id) {
-                continue;
+                Scope(entity->scope, 
+                    ecs_script_component_t *comp = 
+                        flecs_script_insert_component(parser, Token(0)); 
+                    comp->expr = Token(2);
+                )
+
+                return flecs_script_scope(parser, entity->scope, pos);
             }
+        )
+    )
+}
 
-            if (rule->vars[var_id].kind == EcsVarTable) {
-                var_id = flecs_rule_find_var_id(rule, rule->vars[var_id].name,
-                    EcsVarEntity);
+// Position: {
+component_expr_scope: {
 
-                /* Variables used as source that aren't This must be entities */
-                ecs_assert(var_id != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+    // Position: {expr}
+    Expr('}', {
+        ecs_script_component_t *comp = flecs_script_insert_component(
+            parser, Token(0));
+        comp->expr = Token(3);
+        EndOfRule; 
+    })
+}
+
+// Points: [
+component_expr_collection: {
+    // Position: [expr]
+    Expr(']', {
+        ecs_script_component_t *comp = flecs_script_insert_component(
+            parser, Token(0));
+        comp->expr = Token(3);
+        comp->is_collection = true;
+        EndOfRule; 
+    })
+}
+
+// Position spaceship (
+component_expr_paren: {
+    // Position spaceship (expr)
+    Expr(')',
+        ecs_script_entity_t *entity = flecs_script_insert_entity(
+            parser, Token(1));
+        entity->kind = Token(0);
+        entity->kind_w_expr = true;
+
+        Scope(entity->scope, 
+            ecs_script_component_t *component = 
+                flecs_script_insert_component(parser, Token(0));
+            component->expr = Token(3);
+        )
+
+        Parse(
+            // Position spaceship (expr)\n
+            EcsTokEndOfStatement: {
+                EndOfRule;
             }
 
-            rule->src_vars[i] = var_id;
-        }
-    }
+            // Position spaceship (expr) {
+            case '{': {
+                return flecs_script_scope(parser, entity->scope, pos);
+            }
+        )
+    )
 
-    /* If filter is empty, insert Nothing instruction */
-    if (!term_count) {
-        ecs_rule_op_t nothing = {0};
-        nothing.kind = EcsRuleNothing;
-        flecs_rule_op_insert(&nothing, &ctx);
-    } else {
-        /* Insert instruction to populate data fields */
-        flecs_rule_insert_populate(rule, &ctx, trivial_terms);
+    ParserEnd;
+}
 
-        /* Insert yield. If program reaches this operation, a result was found */
-        ecs_rule_op_t yield = {0};
-        yield.kind = EcsRuleYield;
-        flecs_rule_op_insert(&yield, &ctx);
-    }
+}
 
-    int32_t op_count = ecs_vec_count(ctx.ops);
-    if (op_count) {
-        rule->op_count = op_count;
-        rule->ops = ecs_os_malloc_n(ecs_rule_op_t, op_count);
-        ecs_rule_op_t *rule_ops = ecs_vec_first_t(ctx.ops, ecs_rule_op_t);
-        ecs_os_memcpy_n(rule->ops, rule_ops, ecs_rule_op_t, op_count);
+/* Parse script */
+ecs_script_t* ecs_script_parse(
+    ecs_world_t *world,
+    const char *name,
+    const char *code) 
+{
+    if (!code) {
+        code = "";
     }
 
-    return 0;
+    ecs_script_t *script = flecs_script_new(world);
+    script->name = name;
+    script->code = code;
+
+    ecs_script_parser_t parser = {
+        .script = script,
+        .scope = script->root,
+        .significant_newline = true
+    };
+
+    /* Allocate a buffer that is able to store all parsed tokens. Multiply the
+     * size of the script by two so that there is enough space to add \0
+     * terminators and expression deliminators ('""') 
+     * The token buffer will exist for as long as the script object exists, and
+     * ensures that AST nodes don't need to do separate allocations for the data
+     * they contain. */
+    script->token_buffer_size = ecs_os_strlen(code) * 2 + 1;
+    script->token_buffer = flecs_alloc(
+        &script->allocator, script->token_buffer_size);
+    parser.token_cur = script->token_buffer;
+
+    /* Start parsing code */
+    const char *pos = code;
+
+    do {
+        pos = flecs_script_stmt(&parser, pos);
+        if (!pos) {
+            /* NULL means error */
+            goto error;
+        }
+
+        if (!pos[0]) {
+            /* \0 means end of input */
+            break;
+        }
+    } while (true);
+
+    return script;
+error:
+    ecs_script_free(script);
+    return NULL;
 }
 
 #endif
 
 /**
- * @file addons/rules/engine.c
- * @brief Rules engine implementation.
+ * @file addons/script/query_parser.c
+ * @brief Script grammar parser.
  */
 
 
-#ifdef FLECS_RULES
+#ifdef FLECS_SCRIPT
 
-static
-bool flecs_rule_dispatch(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx);
+#define EcsTokTermIdentifier\
+    EcsTokIdentifier:\
+    case EcsTokNumber:\
+    case EcsTokMul
+
+#define EcsTokEndOfTerm\
+    '}':\
+        pos --; /* Give token back to parser */\
+    case EcsTokOr:\
+        if (t->kind == EcsTokOr) {\
+            if (parser->term->oper != EcsAnd) {\
+                Error("cannot mix operators in || expression");\
+            }\
+            parser->term->oper = EcsOr;\
+        }\
+    case ',':\
+    case '\n':\
+    case '\0'
+
+// $this ==
+static
+const char* flecs_query_parse_term_equality_pred(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_entity_t pred) 
+{
+    ParserBegin;
+
+    if (parser->term->oper != EcsAnd) {
+        Error("cannot mix operator with equality expression");
+    }
+
+    parser->term->src = parser->term->first;
+    parser->term->first = (ecs_term_ref_t){0};
+    parser->term->first.id = pred;
+
+    Parse(
+        // $this == foo
+        //          ^
+        case EcsTokTermIdentifier: {
+            parser->term->second.name = Token(0);
+            Parse( case EcsTokEndOfTerm: EndOfRule; )
+        }
+
+        // $this == "foo"
+        //          ^
+        case EcsTokString: {
+            parser->term->second.name = Token(0);
+            parser->term->second.id = EcsIsName;
+
+            if (pred == EcsPredMatch) {
+                if (Token(0)[0] == '!') {
+                    /* If match expression starts with !, set Not operator. The
+                     * reason the ! is embedded in the expression is because 
+                     * there is only a single match (~=) operator. */
+                    parser->term->second.name ++;
+                    parser->term->oper = EcsNot;
+                }
+            }
 
-static
-bool flecs_rule_run_until(
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    const ecs_rule_op_t *ops,
-    ecs_rule_lbl_t first,
-    ecs_rule_lbl_t cur,
-    ecs_rule_op_kind_t until);
+            Parse( 
+                case EcsTokEndOfTerm:
+                    EndOfRule; 
+            )
+        }
+    )
 
-ecs_allocator_t* flecs_rule_get_allocator(
-    const ecs_iter_t *it)
-{
-    ecs_world_t *world = it->world;
-    if (ecs_poly_is(world, ecs_world_t)) {
-        return &world->allocator;
-    } else {
-        ecs_assert(ecs_poly_is(world, ecs_stage_t), ECS_INTERNAL_ERROR, NULL);
-        return &((ecs_stage_t*)world)->allocator;
-    }
+    ParserEnd;
 }
 
 static
-ecs_rule_op_ctx_t* flecs_op_ctx_(
-    const ecs_rule_run_ctx_t *ctx)
+ecs_entity_t flecs_query_parse_trav_flags(
+    const char *tok)
 {
-    return &ctx->op_ctx[ctx->op_index];
+         if (!ecs_os_strcmp(tok, "self"))    return EcsSelf;
+    else if (!ecs_os_strcmp(tok, "up"))      return EcsUp;
+    else if (!ecs_os_strcmp(tok, "cascade")) return EcsCascade;
+    else if (!ecs_os_strcmp(tok, "desc"))    return EcsDesc;
+    else return 0;
 }
 
-#define flecs_op_ctx(ctx, op_kind) (&flecs_op_ctx_(ctx)->is.op_kind)
-
 static
-void flecs_reset_source_set_flag(
-    const ecs_rule_run_ctx_t *ctx,
-    int32_t field_index)
+const char* flecs_query_parse_term_trav(
+    ecs_script_parser_t *parser,
+    ecs_term_ref_t *ref,
+    const char *pos) 
 {
-    ecs_assert(field_index != -1, ECS_INTERNAL_ERROR, NULL);
-    (*ctx->source_set) &= ~(1u << field_index);
-}
+    ParserBegin;
 
-static
-void flecs_set_source_set_flag(
-    const ecs_rule_run_ctx_t *ctx,
-    int32_t field_index)
-{
-    ecs_assert(field_index != -1, ECS_INTERNAL_ERROR, NULL);
-    (*ctx->source_set) |= (1u << field_index);
-}
+    Loop(
+        // self
+        Parse_1(EcsTokIdentifier,
+            ref->id |= flecs_query_parse_trav_flags(Token(0));
 
-static
-ecs_table_range_t flecs_range_from_entity(
-    ecs_entity_t e,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_record_t *r = flecs_entities_get(ctx->world, e);
-    if (!r) {
-        return (ecs_table_range_t){ 0 };
-    }
-    return (ecs_table_range_t){
-        .table = r->table,
-        .offset = ECS_RECORD_TO_ROW(r->row),
-        .count = 1
-    };
-}
+            LookAhead(
+                // self|
+                case '|':
+                    pos = lookahead;
+                    continue;
 
-static
-ecs_table_range_t flecs_rule_var_get_range(
-    int32_t var_id,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_assert(var_id < ctx->rule->var_count, ECS_INTERNAL_ERROR, NULL);
-    ecs_var_t *var = &ctx->vars[var_id];
-    ecs_table_t *table = var->range.table;
-    if (table) {
-        return var->range;
-    }
+                // self IsA
+                case EcsTokIdentifier:
+                    pos = lookahead;
+                    parser->term->trav = ecs_lookup(
+                        parser->script->world, Token(1));
+                    if (!parser->term->trav) {
+                        Error(
+                            "unresolved traversal relationship '%s'", Token(1));
+                        goto error;
+                    }
 
-    ecs_entity_t entity = var->entity;
-    if (entity && entity != EcsWildcard) {
-        var->range = flecs_range_from_entity(entity, ctx);
-        return var->range;
-    }
+                    EndOfRule;
+            )
 
-    return (ecs_table_range_t){ 0 };
+            EndOfRule;
+        )
+    )
+
+    ParserEnd;
 }
 
+// Position(
 static
-ecs_table_t* flecs_rule_var_get_table(
-    int32_t var_id,
-    const ecs_rule_run_ctx_t *ctx)
+const char* flecs_query_parse_term_arg(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    int32_t arg)
 {
-    ecs_var_t *var = &ctx->vars[var_id];
-    ecs_table_t *table = var->range.table;
-    if (table) {
-        return table;
-    }
+    ParserBegin;
 
-    ecs_entity_t entity = var->entity;
-    if (entity && entity != EcsWildcard) {
-        var->range = flecs_range_from_entity(entity, ctx);
-        return var->range.table;
-    }
+    ecs_term_ref_t *ref = NULL;
 
-    return NULL;
-}
+    // Position(src
+    if (arg == 0) {
+        ref = &parser->term->src;
 
-static
-ecs_table_t* flecs_rule_get_table(
-    const ecs_rule_op_t *op,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t flags = flecs_rule_ref_flags(op->flags, ref_kind);
-    if (flags & EcsRuleIsEntity) {
-        return ecs_get_table(ctx->world, ref->entity);
+    // Position(src, tgt
+    } else if (arg == 1) {
+        ref = &parser->term->second;
     } else {
-        return flecs_rule_var_get_table(ref->var, ctx);
+        if (arg > FLECS_TERM_ARG_COUNT_MAX) {
+            Error("too many arguments in term");
+        }
+        ref = &parser->extra_args[arg - 2];
     }
-}
 
-static
-ecs_table_range_t flecs_rule_get_range(
-    const ecs_rule_op_t *op,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t flags = flecs_rule_ref_flags(op->flags, ref_kind);
-    if (flags & EcsRuleIsEntity) {
-        ecs_assert(!(flags & EcsRuleIsVar), ECS_INTERNAL_ERROR, NULL);
-        return flecs_range_from_entity(ref->entity, ctx);
-    } else {
-        ecs_var_t *var = &ctx->vars[ref->var];
-        if (var->range.table) {
-            return ctx->vars[ref->var].range;
-        } else if (var->entity) {
-            return flecs_range_from_entity(var->entity, ctx);
+    bool is_trav_flag = false;
+    LookAhead_1(EcsTokIdentifier, 
+        is_trav_flag = flecs_query_parse_trav_flags(Token(0)) != 0;
+    )
+
+    if (is_trav_flag) {
+        // Position(self|up
+        //          ^
+        pos = flecs_query_parse_term_trav(parser, ref, pos);
+        if (!pos) {
+            goto error;
         }
-    }
-    return (ecs_table_range_t){0};
-}
+    } else {
+        // Position(src
+        //          ^
+        Parse(
+            case EcsTokTermIdentifier: {
+                ref->name = Token(0);
+
+                // Position(src|
+                //          ^
+                LookAhead_1('|',
+                    pos = lookahead;
+                    pos = flecs_query_parse_term_trav(parser, ref, pos);
+                    if (!pos) {
+                        goto error;
+                    }
 
-static
-ecs_entity_t flecs_rule_var_get_entity(
-    ecs_var_id_t var_id,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_assert(var_id < (ecs_var_id_t)ctx->rule->var_count, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_var_t *var = &ctx->vars[var_id];
-    ecs_entity_t entity = var->entity;
-    if (entity) {
-        return entity;
+                    // Position(src|up IsA
+                    //          ^
+                    LookAhead_1(EcsTokIdentifier,
+                        pos = lookahead;
+                        parser->term->trav = ecs_lookup(
+                            parser->script->world, Token(1));
+                        if (!parser->term->trav) {
+                            Error(
+                                "unresolved trav identifier '%s'", Token(1));
+                        }
+                    )
+                )
+
+                break;
+            }
+        )
     }
 
-    ecs_assert(var->range.count == 1, ECS_INTERNAL_ERROR, NULL);
-    ecs_table_t *table = var->range.table;
-    ecs_entity_t *entities = table->data.entities.array;
-    var->entity = entities[var->range.offset];
-    return var->entity;
-}
+    Parse(
+        // Position(src,
+        //          ^
+        case ',':
+            if ((arg > 1) && parser->extra_oper != EcsAnd) {
+                Error("cannot mix operators in extra term arguments");
+            }
+            parser->extra_oper = EcsAnd;
+            return flecs_query_parse_term_arg(parser, pos, arg + 1);
 
-static
-void flecs_rule_var_reset(
-    ecs_var_id_t var_id,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ctx->vars[var_id].entity = EcsWildcard;
-    ctx->vars[var_id].range.table = NULL;
-}
+        // Position(src, second ||
+        //          ^
+        case EcsTokOr:
+            if ((arg > 1) && parser->extra_oper != EcsOr) {
+                Error("cannot mix operators in extra term arguments");
+            }
+            parser->extra_oper = EcsOr;
+            return flecs_query_parse_term_arg(parser, pos, arg + 1);
 
-static
-void flecs_rule_var_set_table(
-    const ecs_rule_op_t *op,
-    ecs_var_id_t var_id,
-    ecs_table_t *table,
-    int32_t offset,
-    int32_t count,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    ecs_assert(ctx->rule_vars[var_id].kind == EcsVarTable, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(flecs_rule_is_written(var_id, op->written), 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_var_t *var = &ctx->vars[var_id];
-    var->entity = 0;
-    var->range = (ecs_table_range_t){ 
-        .table = table,
-        .offset = offset,
-        .count = count
-    };
-}
+        // Position(src)
+        //          ^
+        case ')':
+            Parse(
+                case EcsTokEndOfTerm:
+                    EndOfRule;
+            )
+    )
 
-static
-void flecs_rule_var_set_entity(
-    const ecs_rule_op_t *op,
-    ecs_var_id_t var_id,
-    ecs_entity_t entity,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    ecs_assert(var_id < (ecs_var_id_t)ctx->rule->var_count, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(flecs_rule_is_written(var_id, op->written), 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_var_t *var = &ctx->vars[var_id];
-    var->range.table = NULL;
-    var->entity = entity;
+    ParserEnd;
 }
 
+// Position
 static
-void flecs_rule_set_vars(
-    const ecs_rule_op_t *op,
-    ecs_id_t id,
-    const ecs_rule_run_ctx_t *ctx)
+const char* flecs_query_parse_term_id(
+    ecs_script_parser_t *parser,
+    const char *pos) 
 {
-    ecs_flags16_t flags_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t flags_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
+    ParserBegin;
 
-    if (flags_1st & EcsRuleIsVar) {
-        ecs_var_id_t var = op->first.var;
-        if (op->written & (1ull << var)) {
-            if (ECS_IS_PAIR(id)) {
-                flecs_rule_var_set_entity(
-                    op, var, ecs_get_alive(ctx->world, ECS_PAIR_FIRST(id)), ctx);
-            } else {
-                flecs_rule_var_set_entity(op, var, id, ctx);
+    Parse(
+        case EcsTokEq:
+            return flecs_query_parse_term_equality_pred(
+                parser, pos, EcsPredEq);
+        case EcsTokNeq: {
+            const char *ret = flecs_query_parse_term_equality_pred(
+                parser, pos, EcsPredEq);
+            if (ret) {
+                parser->term->oper = EcsNot;
             }
+            return ret;
         }
-    }
-    if (flags_2nd & EcsRuleIsVar) {
-        ecs_var_id_t var = op->second.var;
-        if (op->written & (1ull << var)) {
-            flecs_rule_var_set_entity(
-                op, var, ecs_get_alive(ctx->world, ECS_PAIR_SECOND(id)), ctx);
-        }
-    }
-}
+        case EcsTokMatch:
+            return flecs_query_parse_term_equality_pred(
+                parser, pos, EcsPredMatch);
 
-static
-ecs_table_range_t flecs_get_ref_range(
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t flag,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (flag & EcsRuleIsEntity) {
-        return flecs_range_from_entity(ref->entity, ctx);
-    } else if (flag & EcsRuleIsVar) {
-        return flecs_rule_var_get_range(ref->var, ctx);
-    }
-    return (ecs_table_range_t){0};
-}
+        // Position|
+        case '|': {
+            pos = flecs_query_parse_term_trav(parser, &parser->term->first, pos);
+            if (!pos) {
+                goto error;
+            }
 
-static
-ecs_entity_t flecs_get_ref_entity(
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t flag,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (flag & EcsRuleIsEntity) {
-        return ref->entity;
-    } else if (flag & EcsRuleIsVar) {
-        return flecs_rule_var_get_entity(ref->var, ctx);
-    }
-    return 0;
-}
+            // Position|self(
+            Parse(
+                case '(':
+                    return flecs_query_parse_term_arg(parser, pos, 0);
+                case EcsTokEndOfTerm:
+                    EndOfRule;
+            )
+        }
 
-static
-ecs_id_t flecs_rule_op_get_id_w_written(
-    const ecs_rule_op_t *op,
-    uint64_t written,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t flags_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t flags_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
-    ecs_entity_t first = 0, second = 0;
+        // Position(
+        case '(': {
+            // Position()
+            LookAhead_1(')',
+                pos = lookahead;
+                parser->term->src.id = EcsIsEntity;
 
-    if (flags_1st) {
-        if (flecs_ref_is_written(op, &op->first, EcsRuleFirst, written)) {
-            first = flecs_get_ref_entity(&op->first, flags_1st, ctx);
-        } else if (flags_1st & EcsRuleIsVar) {
-            first = EcsWildcard;
-        }
-    }
-    if (flags_2nd) {
-        if (flecs_ref_is_written(op, &op->second, EcsRuleSecond, written)) {
-            second = flecs_get_ref_entity(&op->second, flags_2nd, ctx);
-        } else if (flags_2nd & EcsRuleIsVar) {
-            second = EcsWildcard;
+                Parse(
+                    case EcsTokEndOfTerm:
+                        EndOfRule;
+                )
+            )
+
+            return flecs_query_parse_term_arg(parser, pos, 0);
         }
-    }
 
-    if (flags_2nd & (EcsRuleIsVar | EcsRuleIsEntity)) {
-        return ecs_pair(first, second);
-    } else {
-        return flecs_entities_get_alive(ctx->world, first);
-    }
-}
+        case EcsTokEndOfTerm: 
+            EndOfRule;
+    )
 
-static
-ecs_id_t flecs_rule_op_get_id(
-    const ecs_rule_op_t *op,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    return flecs_rule_op_get_id_w_written(op, written, ctx);
+    ParserEnd;
 }
 
-static
-int16_t flecs_rule_next_column(
-    ecs_table_t *table,
-    ecs_id_t id,
-    int32_t column)
+// (
+static const char* flecs_query_parse_term_pair(
+    ecs_script_parser_t *parser,
+    const char *pos)
 {
-    if (!ECS_IS_PAIR(id) || (ECS_PAIR_FIRST(id) != EcsWildcard)) {
-        column = column + 1;
-    } else {
-        ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
-        column = ecs_search_offset(NULL, table, column + 1, id, NULL);
-        ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL);
-    }
-    return flecs_ito(int16_t, column);
-}
+    ParserBegin;
 
-static
-void flecs_rule_it_set_column(
-    ecs_iter_t *it,
-    int32_t field_index,
-    int32_t column)
-{
-    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(field_index >= 0, ECS_INTERNAL_ERROR, NULL);
-    it->columns[field_index] = column + 1;
-}
+    // (Position
+    //  ^
+    Parse(
+        case EcsTokTermIdentifier: {
+            parser->term->first.name = Token(0);
 
-static
-ecs_id_t flecs_rule_it_set_id(
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    int32_t field_index,
-    int32_t column)
-{
-    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(field_index >= 0, ECS_INTERNAL_ERROR, NULL);
-    return it->ids[field_index] = table->type.array[column];
-}
+            LookAhead_1('|',
+                // (Position|self
+                pos = lookahead;
+                pos = flecs_query_parse_term_trav(
+                    parser, &parser->term->first, pos);
+                if (!pos) {
+                    goto error;
+                }
+            )
 
-static
-void flecs_rule_set_match(
-    const ecs_rule_op_t *op,
-    ecs_table_t *table,
-    int32_t column,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
-    int32_t field_index = op->field_index;
-    if (field_index == -1) {
-        return;
-    }
+            // (Position,
+            Parse_1(',',
+                return flecs_query_parse_term_arg(parser, pos, 1);
+            )
+        }
+    )
 
-    ecs_iter_t *it = ctx->it;
-    flecs_rule_it_set_column(it, field_index, column);
-    ecs_id_t matched = flecs_rule_it_set_id(it, table, field_index, column);
-    flecs_rule_set_vars(op, matched, ctx);
+    ParserEnd;
 }
 
+// AND
 static
-void flecs_rule_set_trav_match(
-    const ecs_rule_op_t *op,
-    int32_t column,
-    ecs_entity_t trav,
-    ecs_entity_t second,
-    const ecs_rule_run_ctx_t *ctx)
+const char* flecs_query_parse_term_flags(
+    ecs_script_parser_t *parser,
+    const char *token_0,
+    const char *pos) 
 {
-    int32_t field_index = op->field_index;
-    if (field_index == -1) {
-        return;
-    }
+    ecs_assert(token_0 != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_iter_t *it = ctx->it;
-    ecs_id_t matched = ecs_pair(trav, second);
-    it->ids[op->field_index] = matched;
-    if (column != -1) {
-        flecs_rule_it_set_column(it, op->field_index, column);
+    ParserBegin;
+
+    ecs_id_t flag = 0;
+    int16_t oper = 0;
+    ecs_term_t *term = parser->term;
+
+    // AND
+    if      (!ecs_os_strcmp(token_0, "AND"))      oper = EcsAndFrom;
+    else if (!ecs_os_strcmp(token_0, "OR"))       oper = EcsOrFrom;
+    else if (!ecs_os_strcmp(token_0, "NOT"))      oper = EcsNotFrom;
+    else if (!ecs_os_strcmp(token_0, "OVERRIDE")) flag = ECS_OVERRIDE;
+    else if (!ecs_os_strcmp(token_0, "TOGGLE"))   flag = ECS_TOGGLE;
+    else {
+        // Position
+        term->first.name = token_0;
+        return flecs_query_parse_term_id(parser, pos);
+    }
+
+    if (oper || flag) {
+        // AND |
+        //     ^
+        Parse_1('|', 
+            Parse(
+                // AND | Position
+                //     ^
+                case EcsTokTermIdentifier: { 
+                    if (oper) {
+                        term->oper = oper;
+                    } else if (flag) {
+                        term->id = flag;
+                    }
+
+                    term->first.name = Token(1);
+
+                    return flecs_query_parse_term_id(parser, pos);
+                }
+
+                // AND | (
+                //     ^
+                case '(': {
+                    return flecs_query_parse_term_pair(parser, pos);
+                }
+            )
+        )
     }
-    flecs_rule_set_vars(op, matched, ctx);
-}
 
-static
-bool flecs_rule_table_filter(
-    ecs_table_t *table,
-    ecs_rule_lbl_t other,
-    ecs_flags32_t filter_mask)
-{
-    uint32_t filter = flecs_ito(uint32_t, other);
-    return (table->flags & filter_mask & filter) != 0;
+    ParserEnd;
 }
 
+// !
 static
-bool flecs_rule_select_w_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_id_t id,
-    ecs_flags32_t filter_mask)
+const char* flecs_query_parse_term_unary(
+    ecs_script_parser_t *parser,
+    const char *pos)
 {
-    ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-    ecs_id_record_t *idr = op_ctx->idr;
-    ecs_table_record_t *tr;
-    ecs_table_t *table;
+    ParserBegin;
 
-    if (!redo) {
-        if (!idr || idr->id != id) {
-            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
-            if (!idr) {
-                return false;
-            }
+    Parse(
+        // !(
+        case '(': {
+            return flecs_query_parse_term_pair(parser, pos);
         }
 
-        if (ctx->rule->filter.flags & EcsFilterMatchEmptyTables) {
-            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)) {
-                return false;
-            }
-        } else {
-            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
-                return false;
-            }
+        // !{
+        case '{': {
+            parser->term->first.id = EcsScopeOpen;
+            parser->term->src.id = EcsIsEntity;
+            parser->term->inout = EcsInOutNone;
+            EndOfRule;
         }
-    }
 
-repeat:
-    if (!redo || !op_ctx->remaining) {
-        tr = flecs_table_cache_next(&op_ctx->it, ecs_table_record_t);
-        if (!tr) {
-            return false;
+        // !Position
+        //  ^
+        case EcsTokTermIdentifier: {
+            parser->term->first.name = Token(0);
+            return flecs_query_parse_term_id(parser, pos);
         }
+    )
 
-        op_ctx->column = flecs_ito(int16_t, tr->index);
-        op_ctx->remaining = flecs_ito(int16_t, tr->count - 1);
-        table = tr->hdr.table;
-        flecs_rule_var_set_table(op, op->src.var, table, 0, 0, ctx);
-    } else {
-        tr = (ecs_table_record_t*)op_ctx->it.cur;
-        ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-        table = tr->hdr.table;
-        op_ctx->column = flecs_rule_next_column(table, idr->id, op_ctx->column);
-        op_ctx->remaining --;
-    }
-
-    if (flecs_rule_table_filter(table, op->other, filter_mask)) {
-        goto repeat;
-    }
-
-    flecs_rule_set_match(op, table, op_ctx->column, ctx);
-    return true;
+    ParserEnd;
 }
 
+// [
 static
-bool flecs_rule_select(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+const char* flecs_query_parse_term_inout(
+    ecs_script_parser_t *parser,
+    const char *pos)
 {
-    ecs_id_t id = 0;
-    if (!redo) {
-        id = flecs_rule_op_get_id(op, ctx);
-    }
-    return flecs_rule_select_w_id(op, redo, ctx, id, 
-        (EcsTableIsPrefab|EcsTableIsDisabled));
+    ParserBegin;
+
+    ecs_term_t *term = parser->term;
+
+    // [inout]
+    //  ^
+    Parse_2(EcsTokIdentifier, ']',
+        if      (!ecs_os_strcmp(Token(0), "default")) term->inout = EcsInOutDefault;
+        else if (!ecs_os_strcmp(Token(0), "none"))    term->inout = EcsInOutNone;
+        else if (!ecs_os_strcmp(Token(0), "filter"))  term->inout = EcsInOutFilter;
+        else if (!ecs_os_strcmp(Token(0), "inout"))   term->inout = EcsInOut;
+        else if (!ecs_os_strcmp(Token(0), "in"))      term->inout = EcsIn;
+        else if (!ecs_os_strcmp(Token(0), "out"))     term->inout = EcsOut;
+
+        Parse(
+            // [inout] Position
+            //  ^
+            case EcsTokTermIdentifier: { 
+                return flecs_query_parse_term_flags(parser, Token(2), pos);
+            }
+
+            // [inout] !Position
+            //  ^
+            case '!':
+                term->oper = EcsNot;
+                return flecs_query_parse_term_unary(parser, pos);
+            case '?':
+                term->oper = EcsOptional;
+                return flecs_query_parse_term_unary(parser, pos);
+
+            // [inout] (
+            //  ^
+            case '(': {
+                return flecs_query_parse_term_pair(parser, pos);
+            }
+        )
+    )
+
+    ParserEnd;
 }
 
 static
-bool flecs_rule_with(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+const char* flecs_query_parse_term(
+    ecs_script_parser_t *parser,
+    const char *pos) 
 {
-    ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-    ecs_id_record_t *idr = op_ctx->idr;
-    const ecs_table_record_t *tr;
+    ParserBegin;
 
-    ecs_table_t *table = flecs_rule_get_table(op, &op->src, EcsRuleSrc, ctx);
-    if (!table) {
-        return false;
+    Parse(
+        case '[':
+            return flecs_query_parse_term_inout(parser, pos);
+        case EcsTokTermIdentifier:   
+            return flecs_query_parse_term_flags(parser, Token(0), pos);
+        case '(':
+            return flecs_query_parse_term_pair(parser, pos);
+        case '!':
+            parser->term->oper = EcsNot;
+            return flecs_query_parse_term_unary(parser, pos);
+        case '?':
+            parser->term->oper = EcsOptional;
+            return flecs_query_parse_term_unary(parser, pos);
+        case '{':
+            parser->term->first.id = EcsScopeOpen;
+            parser->term->src.id = EcsIsEntity;
+            parser->term->inout = EcsInOutNone;
+            EndOfRule;
+        case '}':
+            parser->term->first.id = EcsScopeClose;
+            parser->term->src.id = EcsIsEntity;
+            parser->term->inout = EcsInOutNone;
+            LookAhead_1(',',
+                pos = lookahead;
+            )
+            EndOfRule;
+        case '\n':\
+        case '\0':
+            EndOfRule;
+    );
+
+    ParserEnd;
+}
+
+int flecs_terms_parse(
+    ecs_script_t *script,
+    ecs_term_t *terms,
+    int32_t *term_count_out)
+{
+    if (!ecs_os_strcmp(script->code, "0")) {
+        *term_count_out = 0;
+        return 0;
     }
 
-    if (!redo) {
-        ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-        if (!idr || idr->id != id) {
-            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
-            if (!idr) {
-                return false;
-            }
+    ecs_script_parser_t parser = {
+        .script = script,
+        .pos = script->code
+    };
+
+    parser.token_cur = script->token_buffer;
+
+    int32_t term_count = 0;
+    const char *ptr = script->code;
+    ecs_term_ref_t extra_args[FLECS_TERM_ARG_COUNT_MAX];
+    ecs_os_memset_n(extra_args, 0, ecs_term_ref_t, 
+        FLECS_TERM_ARG_COUNT_MAX);
+
+    parser.extra_args = extra_args;
+    parser.extra_oper = 0;
+
+    do {
+        if (term_count == FLECS_TERM_COUNT_MAX) {
+            ecs_err("max number of terms (%d) reached, increase "
+                "FLECS_TERM_COUNT_MAX to support more",
+                FLECS_TERM_COUNT_MAX);
+            goto error;
         }
 
-        tr = flecs_id_record_get_table(idr, table);
-        if (!tr) {
-            return false;
+        /* Parse next term */
+        ecs_term_t *term = &terms[term_count];
+        parser.term = term;
+        ecs_os_memset_t(term, 0, ecs_term_t);
+        ecs_os_memset_n(extra_args, 0, ecs_term_ref_t, FLECS_TERM_ARG_COUNT_MAX);
+        parser.extra_oper = 0;
+
+        ptr = flecs_query_parse_term(&parser, ptr);
+        if (!ptr) {
+            /* Parser error */
+            goto error;
         }
 
-        op_ctx->column = flecs_ito(int16_t, tr->index);
-        op_ctx->remaining = flecs_ito(int16_t, tr->count);
-    } else {
-        if (--op_ctx->remaining <= 0) {
-            return false;
+        if (!ecs_term_is_initialized(term)) {
+            /* Last term parsed */
+            break;
         }
 
-        op_ctx->column = flecs_rule_next_column(table, idr->id, op_ctx->column);
-        ecs_assert(op_ctx->column != -1, ECS_INTERNAL_ERROR, NULL);
-    }
+        term_count ++;
 
-    flecs_rule_set_match(op, table, op_ctx->column, ctx);
-    return true;
-}
+        /* Unpack terms with more than two args into multiple terms so that:
+         *   Rel(X, Y, Z)
+         *  becomes:
+         *   Rel(X, Y), Rel(Y, Z) */
+        int32_t arg = 0;
+        while (ecs_term_ref_is_set(&extra_args[arg ++])) {
+            ecs_assert(arg <= FLECS_TERM_ARG_COUNT_MAX, 
+                ECS_INTERNAL_ERROR, NULL);
 
-static
-bool flecs_rule_and(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (written & (1ull << op->src.var)) {
-        return flecs_rule_with(op, redo, ctx);
-    } else {
-        return flecs_rule_select(op, redo, ctx);
-    }
-}
+            if (term_count == FLECS_TERM_COUNT_MAX) {
+                ecs_err("max number of terms (%d) reached, increase "
+                    "FLECS_TERM_COUNT_MAX to support more",
+                    FLECS_TERM_COUNT_MAX);
+                goto error;
+            }
 
-static
-bool flecs_rule_select_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_flags32_t table_filter)
-{
-    ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-    ecs_iter_t *it = ctx->it;
-    int8_t field = op->field_index;
-    ecs_assert(field != -1, ECS_INTERNAL_ERROR, NULL);
+            term = &terms[term_count ++];
+            *term = term[-1];
 
-    if (!redo) {
-        ecs_id_t id = it->ids[field];
-        ecs_id_record_t *idr = op_ctx->idr;
-        if (!idr || idr->id != id) {
-            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
-            if (!idr) {
-                return false;
+            if (parser.extra_oper == EcsAnd) {
+                term->src = term[-1].second;
+                term->second = extra_args[arg - 1];
+            } else if (parser.extra_oper == EcsOr) {
+                term->src = term[-1].src;
+                term->second = extra_args[arg - 1];
+                term[-1].oper = EcsOr;
             }
-        }
 
-        if (ctx->rule->filter.flags & EcsFilterMatchEmptyTables) {
-            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)) {
-                return false;
+            if (term->first.name != NULL) {
+                term->first.name = term->first.name;
             }
-        } else {
-            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
-                return false;
+    
+            if (term->src.name != NULL) {
+                term->src.name = term->src.name;
             }
         }
-    }
 
-repeat: {}
-    const ecs_table_record_t *tr = flecs_table_cache_next(
-        &op_ctx->it, ecs_table_record_t);
-    if (!tr) {
-        return false;
-    }
+        if (arg) {
+            ecs_os_memset_n(extra_args, 0, ecs_term_ref_t, 
+                FLECS_TERM_ARG_COUNT_MAX);
+        }
+    } while (ptr[0]);
 
-    ecs_table_t *table = tr->hdr.table;
-    if (flecs_rule_table_filter(table, op->other, table_filter)) {
-        goto repeat;
-    }
+    (*term_count_out) += term_count;
 
-    flecs_rule_var_set_table(op, op->src.var, table, 0, 0, ctx);
-    flecs_rule_it_set_column(it, field, tr->index);
-    return true;
+    return 0;
+error:
+    return -1;
 }
 
-static
-bool flecs_rule_with_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+const char* flecs_id_parse(
+    const ecs_world_t *world,
+    const char *name,
+    const char *expr,
+    ecs_id_t *id)
 {
-    if (redo) {
-        return false;
-    }
+    char token_buffer[256];
+    ecs_term_t term = {0};
+    EcsParserFixedBuffer(world, name, expr, token_buffer, 256);
+    parser.term = &term;
 
-    ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-    ecs_iter_t *it = ctx->it;
-    int8_t field = op->field_index;
-    ecs_assert(field != -1, ECS_INTERNAL_ERROR, NULL);
+    expr = flecs_scan_whitespace(&parser, expr);
+    if (!ecs_os_strcmp(expr, "0")) {
+        *id = 0;
+        return &expr[1];
+    }
 
-    ecs_table_t *table = flecs_rule_get_table(op, &op->src, EcsRuleSrc, ctx);
-    if (!table) {
-        return false;
+    const char *result = flecs_query_parse_term(&parser, expr);
+    if (!result) {
+        return NULL;
     }
 
-    ecs_id_t id = it->ids[field];
-    ecs_id_record_t *idr = op_ctx->idr;
-    if (!idr || idr->id != id) {
-        idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
-        if (!idr) {
-            return false;
-        }
+    if (ecs_term_finalize(world, &term)) {
+        return NULL;
     }
 
-    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-    if (!tr) {
-        return false;
+    if (!ecs_id_is_valid(world, term.id)) {
+        ecs_parser_error(name, expr, (result - expr), 
+            "invalid term for add expression");
+        return NULL;
     }
 
-    flecs_rule_it_set_column(it, field, tr->index);
-    return true;
-}
+    if (term.oper != EcsAnd) {
+        ecs_parser_error(name, expr, (result - expr), 
+            "invalid operator for add expression");
+        return NULL;
+    }
 
-static
-bool flecs_rule_and_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (written & (1ull << op->src.var)) {
-        return flecs_rule_with_id(op, redo, ctx);
-    } else {
-        return flecs_rule_select_id(op, redo, ctx, 
-            (EcsTableIsPrefab|EcsTableIsDisabled));
+    if ((term.src.id & ~EcsTraverseFlags) != (EcsThis|EcsIsVariable)) {
+        ecs_parser_error(name, expr, (result - expr), 
+            "invalid source for add expression (must be $this)");
+        return NULL;
     }
+
+    *id = term.id;
+    
+    return result;
 }
 
 static
-bool flecs_rule_up_select(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx,
-    bool self,
-    bool id_only)
+const char* flecs_query_arg_parse(
+    ecs_script_parser_t *parser,
+    ecs_query_t *q,
+    ecs_iter_t *it,
+    const char *pos)
 {
-    ecs_rule_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
-    ecs_world_t *world = ctx->world;
-    ecs_iter_t *it = ctx->it;
-    bool redo_select = redo;
-    const ecs_filter_t *filter = &ctx->rule->filter;
+    ParserBegin;
 
-    /* Early out if traversal relationship doesn't exist */
-    op_ctx->trav = filter->terms[op->term_index].src.trav;
-    if (!op_ctx->idr_trav) {
-        op_ctx->idr_trav = flecs_id_record_get(ctx->world, 
-            ecs_pair(op_ctx->trav, EcsWildcard));
-    }
-    if (!op_ctx->idr_trav || !flecs_table_cache_count(&op_ctx->idr_trav->cache)){
-        if (!self) {
-            return false;
-        } else if (id_only) {
-            return flecs_rule_select_id(op, redo, ctx,
-                (EcsTableIsPrefab|EcsTableIsDisabled));
-        } else {
-            return flecs_rule_select(op, redo, ctx);
+    Parse_3(EcsTokIdentifier, ':', EcsTokIdentifier, {
+        int var = ecs_query_find_var(q, Token(0));
+        if (var == -1) {
+            Error("unknown variable '%s'", Token(0));
         }
-    }
 
-    if (!redo) {
-        op_ctx->with = flecs_rule_op_get_id(op, ctx);
-        op_ctx->idr_with = flecs_id_record_get(ctx->world, op_ctx->with);
-        if (!op_ctx->idr_with) {
-            return false;
+        ecs_entity_t val = ecs_lookup(q->world, Token(2));
+        if (!val) {
+            Error("unresolved entity '%s'", Token(2));
         }
 
-        op_ctx->down = NULL;
-        op_ctx->cache_elem = 0;
-    }
-
-    ecs_trav_down_t *down = op_ctx->down;
+        ecs_iter_set_var(it, var, val);
 
-    do {
-        while (!down) {
-            ecs_table_t *table = op_ctx->table;
-            if (!table) {
-                ecs_table_range_t range;
-                it->sources[op->field_index] = 0;
-                do {
-                    bool result;
-                    if (id_only) {
-                        result = flecs_rule_select_id(op, redo_select, ctx, 0);
-                    } else {
-                        result = flecs_rule_select_w_id(op, redo_select, ctx, 
-                            op_ctx->with, 0);
-                    }
-                    if (!result) {
-                        return false;
-                    }
+        EndOfRule;
+    })
 
-                    redo_select = true;
+    ParserEnd;
+}
 
-                    range = flecs_rule_get_range(
-                        op, &op->src, EcsRuleSrc, ctx);
-                    ecs_assert(range.table != NULL, ECS_INTERNAL_ERROR, NULL);
-                } while (!self && range.table->_->traversable_count == 0);
+static
+const char* flecs_query_args_parse(
+    ecs_script_parser_t *parser,
+    ecs_query_t *q,
+    ecs_iter_t *it,
+    const char *pos)
+{
+    ParserBegin;
+
+    bool has_paren = false;
+    LookAhead(
+        case '\0':
+            pos = lookahead;
+            EndOfRule;
+        case '(': {
+            pos = lookahead;
+            has_paren = true;
+            LookAhead_1(')',
+                pos = lookahead;
+                EndOfRule;
+            )
+        }
+    )
+
+    Loop(
+        pos = flecs_query_arg_parse(parser, q, it, pos);
+        if (!pos) {
+            goto error;
+        }
 
-                if (!range.count) {
-                    range.count = ecs_table_count(range.table);
+        Parse(
+            case ',':
+                continue;
+            case '\0':
+                EndOfRule;
+            case ')':
+                if (!has_paren) {
+                    Error("unexpected ')' without opening '(')");
                 }
+                EndOfRule;
+        )
+    )
 
-                table = op_ctx->table = range.table;
-                op_ctx->row = range.offset;
-                op_ctx->end = range.offset + range.count;
-                op_ctx->matched = it->ids[op->field_index];
+    ParserEnd;
+}
 
-                if (self) {
-                    if (!flecs_rule_table_filter(table, op->other, 
-                        (EcsTableIsPrefab|EcsTableIsDisabled)))
-                    {
-                        flecs_reset_source_set_flag(ctx, op->field_index);
-                        op_ctx->row --;
-                        return true;
-                    }
-                }
+const char* ecs_query_args_parse(
+    ecs_query_t *q,
+    ecs_iter_t *it,
+    const char *expr)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(expr != NULL, ECS_INVALID_PARAMETER, NULL);
 
-                redo_select = true;
-            } else {
-                op_ctx->row ++;
-            }
+    const char *q_name = q->entity ? ecs_get_name(q->world, q->entity) : NULL;
+    if (ecs_os_strlen(expr) > 512) {
+        ecs_parser_error(q_name, expr, 0, "query argument expression too long");
+        return NULL;
+    }
 
-            if (table->_->traversable_count == 0) {
-                op_ctx->table = NULL;
-                continue;
-            } else {
-                int32_t row;
-                ecs_entity_t entity = 0;
-                ecs_entity_t *entities = flecs_table_entities_array(table);
+    char token_buffer[1024];
+    EcsParserFixedBuffer(q->world, q_name, expr, token_buffer, 256);
+    return flecs_query_args_parse(&parser, q, it, expr);
+error:
+    return NULL;
+}
 
-                for (row = op_ctx->row; row < op_ctx->end; row ++) {
-                    entity = entities[row];
-                    ecs_record_t *record = flecs_entities_get(world, entity);
-                    if (record->row & EcsEntityIsTraversable) {
-                        it->sources[op->field_index] = entity;
-                        break;
-                    }
-                }
+#endif
 
-                if (row == op_ctx->end) {
-                    op_ctx->table = NULL;
-                    continue;
-                }
+/**
+ * @file addons/script/script.c
+ * @brief Script API.
+ */
 
-                down = op_ctx->down = flecs_rule_get_down_cache(ctx, &op_ctx->cache, 
-                    op_ctx->trav, entity, op_ctx->idr_with, self);
-                op_ctx->cache_elem = -1;
-            }
-        }
 
-next_elem:
-        if ((++ op_ctx->cache_elem) >= ecs_vec_count(&down->elems)) {
-            down = NULL;
-            continue;
+#ifdef FLECS_SCRIPT
+
+ECS_COMPONENT_DECLARE(EcsScript);
+
+static
+ECS_MOVE(EcsScript, dst, src, {
+    if (dst->script && (dst->script != src->script)) {
+        if (dst->assembly && (dst->assembly != src->assembly)) {
+            flecs_script_assembly_fini(dst->script, dst->assembly);
         }
+        ecs_script_free(dst->script);
+    }
+    dst->script = src->script;
+    dst->assembly = src->assembly;
+    src->script = NULL;
+    src->assembly = NULL;
+})
 
-        ecs_trav_down_elem_t *elem = ecs_vec_get_t(
-            &down->elems, ecs_trav_down_elem_t, op_ctx->cache_elem);
+static
+ECS_DTOR(EcsScript, ptr, {
+    if (ptr->assembly) {
+        flecs_script_assembly_fini(ptr->script, ptr->assembly);
+    }
+    if (ptr->script) {
+        ecs_script_free(ptr->script);
+    }
+})
+
+static
+ecs_id_t flecs_script_tag(
+    ecs_entity_t script,
+    ecs_entity_t instance)
+{
+    if (!instance) {
+        return ecs_pair_t(EcsScript, script);
+    } else {
+        return ecs_pair(EcsChildOf, instance);
+    }
+}
 
-        flecs_rule_var_set_table(op, op->src.var, elem->table, 0, 0, ctx);
-        flecs_rule_set_vars(op, op_ctx->matched, ctx);
+ecs_script_t* flecs_script_new(
+    ecs_world_t *world) 
+{
+    ecs_script_t *result = ecs_os_calloc_t(ecs_script_t);
+    flecs_allocator_init(&result->allocator);
+    ecs_script_parser_t parser = { .script = result };
+    result->root = flecs_script_scope_new(&parser);
+    result->world = world;
+    result->refcount = 1;
+    return result;
+}
 
-        if (flecs_rule_table_filter(elem->table, op->other, 
-            (EcsTableIsPrefab|EcsTableIsDisabled)))
-        {
-            goto next_elem;
-        }
+void ecs_script_clear(
+    ecs_world_t *world,
+    ecs_entity_t script,
+    ecs_entity_t instance)
+{
+    ecs_delete_with(world, flecs_script_tag(script, instance));
+}
 
-        break;
-    } while (true);
+int ecs_script_run(
+    ecs_world_t *world,
+    const char *name,
+    const char *code)
+{
+    ecs_script_t *script = ecs_script_parse(world, name, code);
+    if (!script) {
+        goto error;
+    }
 
-    flecs_set_source_set_flag(ctx, op->field_index);
+    ecs_entity_t prev_scope = ecs_set_scope(world, 0);
 
-    return true;
+    if (ecs_script_eval(script)) {
+        goto error_free;
+    }
+
+    ecs_set_scope(world, prev_scope);
+
+    ecs_script_free(script);
+    return 0;
+error_free:
+    ecs_script_free(script);
+error:
+    return -1;
 }
 
-static
-bool flecs_rule_up_with(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+int ecs_script_run_file(
+    ecs_world_t *world,
+    const char *filename) 
 {
-    const ecs_filter_t *filter = &ctx->rule->filter;
-    ecs_rule_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
-    ecs_iter_t *it = ctx->it;
+    char *script = flecs_load_from_file(filename);
+    if (!script) {
+        return -1;
+    }
 
-    /* Early out if traversal relationship doesn't exist */
-    op_ctx->trav = filter->terms[op->term_index].src.trav;
-    if (!op_ctx->idr_trav) {
-        op_ctx->idr_trav = flecs_id_record_get(ctx->world, 
-            ecs_pair(op_ctx->trav, EcsWildcard));
+    int result = ecs_script_run(world, filename, script);
+    ecs_os_free(script);
+    return result;
+}
+
+void ecs_script_free(
+    ecs_script_t *script)
+{
+    ecs_check(script->refcount > 0, ECS_INVALID_OPERATION, NULL);
+    if (!--script->refcount) {
+        flecs_script_visit_free(script);
+        flecs_free(&script->allocator, 
+            script->token_buffer_size, script->token_buffer);
+        flecs_allocator_fini(&script->allocator);
+        ecs_os_free(script);
     }
-    if (!op_ctx->idr_trav || !flecs_table_cache_count(&op_ctx->idr_trav->cache)){
-        return false;
+error:
+    return;
+}
+
+int ecs_script_update(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    ecs_entity_t instance,
+    const char *code)
+{
+    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(code != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    const char *name = ecs_get_name(world, e);
+    EcsScript *s = ecs_ensure(world, e, EcsScript);
+    if (s->assembly) {
+        char *assembly_name = ecs_get_fullpath(world, s->assembly->entity);
+        ecs_err("cannot update scripts for individual assemblies, "
+            "update parent script instead (tried to update '%s')",
+                assembly_name);
+        ecs_os_free(assembly_name);
+        return -1;
     }
 
-    if (!redo) {
-        op_ctx->trav = filter->terms[op->term_index].src.trav;
-        op_ctx->with = flecs_rule_op_get_id(op, ctx);
-        op_ctx->idr_with = flecs_id_record_get(ctx->world, op_ctx->with);
+    if (s->script) {
+        ecs_script_free(s->script);
+    }
 
-        if (!op_ctx->idr_with) {
-            return false;
-        }
+    s->script = ecs_script_parse(world, name, code);
+    if (!s->script) {
+        return -1;
+    }
 
-        ecs_table_range_t range = flecs_rule_get_range(
-            op, &op->src, EcsRuleSrc, ctx);
-        if (!range.table) {
-            return false;
-        }
+    int result = 0;
+    bool is_defer = ecs_is_deferred(world);
+    ecs_suspend_readonly_state_t srs;
+    ecs_world_t *real_world = NULL;
+    if (is_defer) {
+        ecs_assert(flecs_poly_is(world, ecs_world_t), ECS_INTERNAL_ERROR, NULL);
+        real_world = flecs_suspend_readonly(world, &srs);
+        ecs_assert(real_world != NULL, ECS_INTERNAL_ERROR, NULL);
+    }
 
-        ecs_trav_up_t *up = flecs_rule_get_up_cache(ctx, &op_ctx->cache, 
-            range.table, op_ctx->with, op_ctx->trav, op_ctx->idr_with,
-            op_ctx->idr_trav);
+    ecs_script_clear(world, e, instance);
 
-        if (!up) {
-            return false;
-        }
+    ecs_entity_t prev = ecs_set_with(world, flecs_script_tag(e, instance));
 
-        it->sources[op->field_index] = flecs_entities_get_alive(
-            ctx->world, up->src);
-        it->columns[op->field_index] = up->column + 1;
-        it->ids[op->field_index] = up->id;
-        flecs_rule_set_vars(op, up->id, ctx);
-        flecs_set_source_set_flag(ctx, op->field_index);
-        return true;
-    } else {
-        return false;
+    if (ecs_script_eval(s->script)) {
+        ecs_delete_with(world, ecs_pair_t(EcsScript, e));
+        result = -1;
+    }
+
+    ecs_set_with(world, prev);
+
+    if (is_defer) {
+        flecs_resume_readonly(real_world, &srs);
     }
+
+    return result;
 }
 
-static
-bool flecs_rule_self_up_with(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx,
-    bool id_only)
+ecs_entity_t ecs_script_init(
+    ecs_world_t *world,
+    const ecs_script_desc_t *desc)
 {
-    if (!redo) {
-        bool result;
-        if (id_only) {
-            result = flecs_rule_with_id(op, redo, ctx);
+    const char *script = NULL;
+    ecs_entity_t e = desc->entity;
+    
+    ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_check(desc != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    if (!e) {
+        if (desc->filename) {
+            e = ecs_new_from_path_w_sep(world, 0, desc->filename, "/", NULL);
         } else {
-            result = flecs_rule_with(op, redo, ctx);
+            e = ecs_new(world);
         }
-        if (result) {
-            ecs_rule_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
-            op_ctx->trav = 0;
-            if (flecs_rule_ref_flags(op->flags, EcsRuleSrc) & EcsRuleIsVar) {
-                ecs_iter_t *it = ctx->it;
-                it->sources[op->field_index] = 0;
-            }
-            return true;
+    }
+
+    script = desc->code;
+    if (!script && desc->filename) {
+        script = flecs_load_from_file(desc->filename);
+        if (!script) {
+            goto error;
         }
+    }
 
-        flecs_reset_source_set_flag(ctx, op->field_index);
+    if (ecs_script_update(world, e, 0, script)) {
+        goto error;
+    }
 
-        return flecs_rule_up_with(op, redo, ctx);
-    } else {
-        ecs_rule_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
-        if (op_ctx->trav == 0) {
-            return flecs_rule_with(op, redo, ctx);
-        }
+    if (script != desc->code) {
+        /* Safe cast, only happens when script is loaded from file */
+        ecs_os_free(ECS_CONST_CAST(char*, script));
     }
 
-    return false;
+    return e;
+error:
+    if (script != desc->code) {
+        /* Safe cast, only happens when script is loaded from file */
+        ecs_os_free(ECS_CONST_CAST(char*, script));
+    }
+    if (!desc->entity) {
+        ecs_delete(world, e);
+    }
+    return 0;
+}
+
+void FlecsScriptImport(
+    ecs_world_t *world)
+{
+    ECS_MODULE(world, FlecsScript);
+    ECS_IMPORT(world, FlecsMeta);
+#ifdef FLECS_DOC
+    ECS_IMPORT(world, FlecsDoc);
+    ecs_doc_set_brief(world, ecs_id(FlecsScript), 
+        "Module with components for managing Flecs scripts");
+#endif
+
+    ecs_set_name_prefix(world, "Ecs");
+    ECS_COMPONENT_DEFINE(world, EcsScript);
+
+    ecs_set_hooks(world, EcsScript, {
+        .ctor = flecs_default_ctor,
+        .move = ecs_move(EcsScript),
+        .dtor = ecs_dtor(EcsScript)
+    });
+
+    ecs_add_id(world, ecs_id(EcsScript), EcsPairIsTag);
+    ecs_add_id(world, ecs_id(EcsScript), EcsPrivate);
 }
 
+#endif
+
+/**
+ * @file addons/script/serialize.c
+ * @brief Serialize values to string.
+ */
+
+
+#ifdef FLECS_SCRIPT
+
+static
+int flecs_expr_ser_type(
+    const ecs_world_t *world,
+    const ecs_vec_t *ser, 
+    const void *base, 
+    ecs_strbuf_t *str,
+    bool is_expr);
+
 static
-bool flecs_rule_up(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        return flecs_rule_up_with(op, redo, ctx);
-    } else {
-        return flecs_rule_up_select(op, redo, ctx, false, false);
-    }
-}
+int flecs_expr_ser_type_ops(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *ops,
+    int32_t op_count,
+    const void *base, 
+    ecs_strbuf_t *str,
+    int32_t in_array,
+    bool is_expr);
 
 static
-bool flecs_rule_self_up(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        return flecs_rule_self_up_with(op, redo, ctx, false);
-    } else {
-        return flecs_rule_up_select(op, redo, ctx, true, false);
-    }
-}
+int flecs_expr_ser_type_op(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *base,
+    ecs_strbuf_t *str,
+    bool is_expr);
 
 static
-bool flecs_rule_up_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        return flecs_rule_up_with(op, redo, ctx);
-    } else {
-        return flecs_rule_up_select(op, redo, ctx, false, true);
-    }
+ecs_primitive_kind_t flecs_expr_op_to_primitive_kind(ecs_meta_type_op_kind_t kind) {
+    return kind - EcsOpPrimitive;
 }
 
+/* Serialize enumeration */
 static
-bool flecs_rule_self_up_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+int flecs_expr_ser_enum(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *base, 
+    ecs_strbuf_t *str) 
 {
-    uint64_t written = ctx->written[ctx->op_index];
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        return flecs_rule_self_up_with(op, redo, ctx, true);
-    } else {
-        return flecs_rule_up_select(op, redo, ctx, true, true);
+    const EcsEnum *enum_type = ecs_get(world, op->type, EcsEnum);
+    ecs_check(enum_type != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    int32_t val = *(const int32_t*)base;
+    
+    /* Enumeration constants are stored in a map that is keyed on the
+     * enumeration value. */
+    ecs_enum_constant_t *c = ecs_map_get_deref(&enum_type->constants, 
+        ecs_enum_constant_t, (ecs_map_key_t)val);
+    if (!c) {
+        char *path = ecs_get_fullpath(world, op->type);
+        ecs_err("value %d is not valid for enum type '%s'", val, path);
+        ecs_os_free(path);
+        goto error;
     }
-}
 
-static
-bool flecs_rule_select_any(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    return flecs_rule_select_w_id(op, redo, ctx, EcsAny, 
-        (EcsTableIsPrefab|EcsTableIsDisabled));
+    ecs_strbuf_appendstr(str, ecs_get_name(world, c->constant));
+
+    return 0;
+error:
+    return -1;
 }
 
+/* Serialize bitmask */
 static
-bool flecs_rule_and_any(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+int flecs_expr_ser_bitmask(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *ptr, 
+    ecs_strbuf_t *str) 
 {
-    ecs_flags16_t match_flags = op->match_flags;
-    if (redo) {
-        if (match_flags & EcsTermMatchAnySrc) {
-            return false;
+    const EcsBitmask *bitmask_type = ecs_get(world, op->type, EcsBitmask);
+    ecs_check(bitmask_type != NULL, ECS_INVALID_PARAMETER, NULL);
+    uint32_t value = *(const uint32_t*)ptr;
+
+    ecs_strbuf_list_push(str, "", "|");
+
+    /* Multiple flags can be set at a given time. Iterate through all the flags
+     * and append the ones that are set. */
+    ecs_map_iter_t it = ecs_map_iter(&bitmask_type->constants);
+    int count = 0;
+    while (ecs_map_next(&it)) {
+        ecs_bitmask_constant_t *c = ecs_map_ptr(&it);
+        ecs_map_key_t key = ecs_map_key(&it);
+        if ((value & key) == key) {
+            ecs_strbuf_list_appendstr(str, ecs_get_name(world, c->constant));
+            count ++;
+            value -= (uint32_t)key;
         }
     }
 
-    uint64_t written = ctx->written[ctx->op_index];
-    int32_t remaining = 1;
-    bool result;
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        result = flecs_rule_with(op, redo, ctx);
-    } else {
-        result = flecs_rule_select(op, redo, ctx);
-        remaining = 0;
+    if (value != 0) {
+        /* All bits must have been matched by a constant */
+        char *path = ecs_get_fullpath(world, op->type);
+        ecs_err(
+            "value for bitmask %s contains bits (%u) that cannot be mapped to constant", 
+            path, value);
+        ecs_os_free(path);
+        goto error;
     }
 
-    if (!redo) {
-        ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-        if (match_flags & EcsTermMatchAny && op_ctx->remaining) {
-            op_ctx->remaining = flecs_ito(int16_t, remaining);
-        }
+    if (!count) {
+        ecs_strbuf_list_appendstr(str, "0");
     }
 
-    int32_t field = op->field_index;
-    if (field != -1) {
-        ctx->it->ids[field] = flecs_rule_op_get_id(op, ctx);
-    }
+    ecs_strbuf_list_pop(str, "");
 
-    return result;
+    return 0;
+error:
+    return -1;
 }
 
+/* Serialize elements of a contiguous array */
 static
-bool flecs_rule_triv(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+int expr_ser_elements(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *ops, 
+    int32_t op_count,
+    const void *base, 
+    int32_t elem_count, 
+    int32_t elem_size,
+    ecs_strbuf_t *str,
+    bool is_array)
 {
-    ecs_rule_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
-    int32_t until = flecs_ito(int32_t, op->other);
-    uint64_t written = ctx->written[ctx->op_index];
-    ctx->written[ctx->op_index + 1] |= 1ull;
-    if (written & 1ull) {
-        return flecs_rule_trivial_test(ctx->rule, ctx, !redo, until);
-    } else {
-        return flecs_rule_trivial_search_nodata(ctx->rule, ctx, op_ctx, !redo, until);
-    }
-}
+    ecs_strbuf_list_push(str, "[", ", ");
 
-static
-bool flecs_rule_triv_data(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
-    int32_t until = flecs_ito(int32_t, op->other);
-    uint64_t written = ctx->written[ctx->op_index];
-    ctx->written[ctx->op_index + 1] |= 1ull;
-    if (written & 1ull) {
-        return flecs_rule_trivial_test(ctx->rule, ctx, !redo, until);
-    } else {
-        return flecs_rule_trivial_search(ctx->rule, ctx, op_ctx, !redo, until);
-    }
-}
+    const void *ptr = base;
 
-static
-bool flecs_rule_triv_wildcard(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
-    int32_t until = flecs_ito(int32_t, op->other);
-    uint64_t written = ctx->written[ctx->op_index];
-    ctx->written[ctx->op_index + 1] |= 1ull;
-    if (written & 1ull) {
-        return flecs_rule_trivial_test_w_wildcards(ctx->rule, ctx, !redo, until);
-    } else {
-        return flecs_rule_trivial_search_w_wildcards(ctx->rule, ctx, op_ctx, !redo, until);
+    int i;
+    for (i = 0; i < elem_count; i ++) {
+        ecs_strbuf_list_next(str);
+        if (flecs_expr_ser_type_ops(
+            world, ops, op_count, ptr, str, is_array, true)) 
+        {
+            return -1;
+        }
+        ptr = ECS_OFFSET(ptr, elem_size);
     }
+
+    ecs_strbuf_list_pop(str, "]");
+
+    return 0;
 }
 
 static
-bool flecs_rule_trav_fixed_src_reflexive(
-    const ecs_rule_op_t *op,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_table_range_t *range,
-    ecs_entity_t trav,
-    ecs_entity_t second)
+int expr_ser_type_elements(
+    const ecs_world_t *world,
+    ecs_entity_t type, 
+    const void *base, 
+    int32_t elem_count, 
+    ecs_strbuf_t *str,
+    bool is_array)
 {
-    ecs_table_t *table = range->table;
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_entity_t *entities = table->data.entities.array;
-    int32_t count = range->count;
-    if (!count) {
-        count = ecs_table_count(table);
-    }
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
+    ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    int32_t i = range->offset, end = i + count;
-    for (; i < end; i ++) {
-        if (entities[i] == second) {
-            /* Even though table doesn't have the specific relationship 
-             * pair, the relationship is reflexive and the target entity
-             * is stored in the table. */
-            break;
-        }
-    }
-    if (i == end) {
-        /* Table didn't contain target entity */
-        return false;
-    }
-    if (count > 1) {
-        /* If the range contains more than one entity, set the range to
-         * return only the entity matched by the reflexive property. */
-        ecs_assert(flecs_rule_ref_flags(op->flags, EcsRuleSrc) & EcsRuleIsVar, 
-            ECS_INTERNAL_ERROR, NULL);
-        ecs_var_t *var = &ctx->vars[op->src.var];
-        ecs_table_range_t *var_range = &var->range;
-        var_range->offset = i;
-        var_range->count = 1;
-        var->entity = entities[i];
-    }
+    const EcsComponent *comp = ecs_get(world, type, EcsComponent);
+    ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    flecs_rule_set_trav_match(op, -1, trav, second, ctx);
-    return true;
+    ecs_meta_type_op_t *ops = ecs_vec_first_t(&ser->ops, ecs_meta_type_op_t);
+    int32_t op_count = ecs_vec_count(&ser->ops);
+    return expr_ser_elements(
+        world, ops, op_count, base, elem_count, comp->size, str, is_array);
 }
 
+/* Serialize array */
 static
-bool flecs_rule_trav_unknown_src_reflexive(
-    const ecs_rule_op_t *op,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_entity_t trav,
-    ecs_entity_t second)
+int expr_ser_array(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *ptr, 
+    ecs_strbuf_t *str) 
 {
-    ecs_assert(flecs_rule_ref_flags(op->flags, EcsRuleSrc) & EcsRuleIsVar,
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_var_id_t src_var = op->src.var;
-    flecs_rule_var_set_entity(op, src_var, second, ctx);
-    flecs_rule_var_get_table(src_var, ctx);
-    flecs_rule_set_trav_match(op, -1, trav, second, ctx);
-    return true;
+    const EcsArray *a = ecs_get(world, op->type, EcsArray);
+    ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    return expr_ser_type_elements(
+        world, a->type, ptr, a->count, str, true);
 }
 
+/* Serialize vector */
 static
-bool flecs_rule_trav_fixed_src_up_fixed_second(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+int expr_ser_vector(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *base, 
+    ecs_strbuf_t *str) 
 {
-    if (redo) {
-        return false; /* If everything's fixed, can only have a single result */
-    }
-
-    ecs_flags16_t f_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t f_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
-    ecs_flags16_t f_src = flecs_rule_ref_flags(op->flags, EcsRuleSrc);
-    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
-    ecs_entity_t second = flecs_get_ref_entity(&op->second, f_2nd, ctx);
-    ecs_table_range_t range = flecs_get_ref_range(&op->src, f_src, ctx);
-    ecs_table_t *table = range.table;
+    const ecs_vec_t *value = base;
+    const EcsVector *v = ecs_get(world, op->type, EcsVector);
+    ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    /* Check if table has transitive relationship by traversing upwards */
-    int32_t column = ecs_search_relation(ctx->world, table, 0, 
-        ecs_pair(trav, second), trav, EcsSelf|EcsUp, NULL, NULL, NULL);
-    if (column == -1) {
-        if (op->match_flags & EcsTermReflexive) {
-            return flecs_rule_trav_fixed_src_reflexive(op, ctx,
-                &range, trav, second);
-        } else {
-            return false;
-        }
-    }
+    int32_t count = ecs_vec_count(value);
+    void *array = ecs_vec_first(value);
 
-    flecs_rule_set_trav_match(op, column, trav, second, ctx);
-    return true;
+    /* Serialize contiguous buffer of vector */
+    return expr_ser_type_elements(world, v->type, array, count, str, false);
 }
 
+/* Forward serialization to the different type kinds */
 static
-bool flecs_rule_trav_unknown_src_up_fixed_second(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+int flecs_expr_ser_type_op(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *op, 
+    const void *ptr,
+    ecs_strbuf_t *str,
+    bool is_expr)
 {
-    ecs_flags16_t f_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t f_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
-    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
-    ecs_entity_t second = flecs_get_ref_entity(&op->second, f_2nd, ctx);
-    ecs_rule_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
-
-    if (!redo) {
-        ecs_record_t *r_second = flecs_entities_get(ctx->world, second);
-        bool traversable = r_second && r_second->row & EcsEntityIsTraversable;
-        bool reflexive = op->match_flags & EcsTermReflexive;
-        if (!traversable && !reflexive) {
-            trav_ctx->cache.id = 0;
-
-            /* If there's no record for the entity, it can't have a subtree so
-             * forward operation to a regular select. */
-            return flecs_rule_select(op, redo, ctx);
+    switch(op->kind) {
+    case EcsOpPush:
+    case EcsOpPop:
+        /* Should not be parsed as single op */
+        ecs_throw(ECS_INVALID_PARAMETER, NULL);
+        break;
+    case EcsOpEnum:
+        if (flecs_expr_ser_enum(world, op, ECS_OFFSET(ptr, op->offset), str)) {
+            goto error;
         }
-
-        /* Entity is traversable, which means it could have a subtree */
-        flecs_rule_get_trav_down_cache(ctx, &trav_ctx->cache, trav, second);
-        trav_ctx->index = 0;
-
-        if (op->match_flags & EcsTermReflexive) {
-            trav_ctx->index = -1;
-            return flecs_rule_trav_unknown_src_reflexive(
-                op, ctx, trav, second);
+        break;
+    case EcsOpBitmask:
+        if (flecs_expr_ser_bitmask(world, op, ECS_OFFSET(ptr, op->offset), str)) {
+            goto error;
         }
-    } else {
-        if (!trav_ctx->cache.id) {
-            /* No traversal cache, which means this is a regular select */
-            return flecs_rule_select(op, redo, ctx);
+        break;
+    case EcsOpArray:
+        if (expr_ser_array(world, op, ECS_OFFSET(ptr, op->offset), str)) {
+            goto error;
         }
-    }
-
-    if (trav_ctx->index == -1) {
-        redo = false; /* First result after handling reflexive relationship */
-        trav_ctx->index = 0;
-    }
-
-    /* Forward to select */
-    int32_t count = ecs_vec_count(&trav_ctx->cache.entities);
-    ecs_trav_elem_t *elems = ecs_vec_first(&trav_ctx->cache.entities);
-    for (; trav_ctx->index < count; trav_ctx->index ++) {
-        ecs_trav_elem_t *el = &elems[trav_ctx->index];
-        trav_ctx->and.idr = el->idr; /* prevents lookup by select */
-        if (flecs_rule_select_w_id(op, redo, ctx, ecs_pair(trav, el->entity),
-            (EcsTableIsPrefab|EcsTableIsDisabled))) 
+        break;
+    case EcsOpVector:
+        if (expr_ser_vector(world, op, ECS_OFFSET(ptr, op->offset), str)) {
+            goto error;
+        }
+        break;
+    case EcsOpScope:
+    case EcsOpPrimitive:
+    case EcsOpBool:
+    case EcsOpChar:
+    case EcsOpByte:
+    case EcsOpU8:
+    case EcsOpU16:
+    case EcsOpU32:
+    case EcsOpU64:
+    case EcsOpI8:
+    case EcsOpI16:
+    case EcsOpI32:
+    case EcsOpI64:
+    case EcsOpF32:
+    case EcsOpF64:
+    case EcsOpUPtr:
+    case EcsOpIPtr:
+    case EcsOpEntity:
+    case EcsOpId:
+    case EcsOpString:
+    case EcsOpOpaque:
+        if (flecs_expr_ser_primitive(world, flecs_expr_op_to_primitive_kind(op->kind), 
+            ECS_OFFSET(ptr, op->offset), str, is_expr))
         {
-            return true;
+            /* Unknown operation */
+            ecs_err("unknown serializer operation kind (%d)", op->kind);
+            goto error;
         }
-        
-        redo = false;
+        break;
+    default:
+        ecs_throw(ECS_INVALID_PARAMETER, "invalid operation");
     }
 
-    return false;
+    return 0;
+error:
+    return -1;
 }
 
+/* Iterate over a slice of the type ops array */
 static
-bool flecs_rule_trav_yield_reflexive_src(
-    const ecs_rule_op_t *op,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_table_range_t *range,
-    ecs_entity_t trav)
+int flecs_expr_ser_type_ops(
+    const ecs_world_t *world,
+    ecs_meta_type_op_t *ops,
+    int32_t op_count,
+    const void *base,
+    ecs_strbuf_t *str,
+    int32_t in_array,
+    bool is_expr) 
 {
-    ecs_var_t *vars = ctx->vars;
-    ecs_rule_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
-    int32_t offset = trav_ctx->offset, count = trav_ctx->count;
-    bool src_is_var = op->flags & (EcsRuleIsVar << EcsRuleSrc);
+    for (int i = 0; i < op_count; i ++) {
+        ecs_meta_type_op_t *op = &ops[i];
 
-    if (trav_ctx->index >= (offset + count)) {
-        /* Restore previous offset, count */
-        if (src_is_var) {
-            ecs_var_id_t src_var = op->src.var;
-            vars[src_var].range.offset = offset;
-            vars[src_var].range.count = count;
-            vars[src_var].entity = 0;
-        }
-        return false;
-    }
+        if (in_array <= 0) {
+            if (op->name) {
+                ecs_strbuf_list_next(str);
+                ecs_strbuf_append(str, "%s: ", op->name);
+            }
 
-    ecs_entity_t entity = ecs_vec_get_t(
-        &range->table->data.entities, ecs_entity_t, trav_ctx->index)[0];
-    flecs_rule_set_trav_match(op, -1, trav, entity, ctx);
+            int32_t elem_count = op->count;
+            if (elem_count > 1) {
+                /* Serialize inline array */
+                if (expr_ser_elements(world, op, op->op_count, base,
+                    elem_count, op->size, str, true))
+                {
+                    return -1;
+                }
 
-    /* Hijack existing variable to return one result at a time */
-    if (src_is_var) {
-        ecs_var_id_t src_var = op->src.var;
-        ecs_table_t *table = vars[src_var].range.table;
-        ecs_assert(!table || table == ecs_get_table(ctx->world, entity),
-            ECS_INTERNAL_ERROR, NULL);
-        (void)table;
-        vars[src_var].entity = entity;
-        vars[src_var].range = flecs_range_from_entity(entity, ctx);
+                i += op->op_count - 1;
+                continue;
+            }
+        }
+
+        switch(op->kind) {
+        case EcsOpPush:
+            ecs_strbuf_list_push(str, "{", ", ");
+            in_array --;
+            break;
+        case EcsOpPop:
+            ecs_strbuf_list_pop(str, "}");
+            in_array ++;
+            break;
+        case EcsOpArray:
+        case EcsOpVector:
+        case EcsOpEnum:
+        case EcsOpBitmask:
+        case EcsOpScope:
+        case EcsOpPrimitive:
+        case EcsOpBool:
+        case EcsOpChar:
+        case EcsOpByte:
+        case EcsOpU8:
+        case EcsOpU16:
+        case EcsOpU32:
+        case EcsOpU64:
+        case EcsOpI8:
+        case EcsOpI16:
+        case EcsOpI32:
+        case EcsOpI64:
+        case EcsOpF32:
+        case EcsOpF64:
+        case EcsOpUPtr:
+        case EcsOpIPtr:
+        case EcsOpEntity:
+        case EcsOpId:
+        case EcsOpString:
+        case EcsOpOpaque:
+            if (flecs_expr_ser_type_op(world, op, base, str, is_expr)) {
+                goto error;
+            }
+            break;
+        default:
+            ecs_throw(ECS_INVALID_PARAMETER, "invalid operation");
+        }
     }
 
-    return true;
+    return 0;
+error:
+    return -1;
 }
 
+/* Iterate over the type ops of a type */
 static
-bool flecs_rule_trav_fixed_src_up_unknown_second(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+int flecs_expr_ser_type(
+    const ecs_world_t *world,
+    const ecs_vec_t *v_ops,
+    const void *base, 
+    ecs_strbuf_t *str,
+    bool is_expr) 
 {
-    ecs_flags16_t f_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t f_src = flecs_rule_ref_flags(op->flags, EcsRuleSrc);
-    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
-    ecs_table_range_t range = flecs_get_ref_range(&op->src, f_src, ctx);
-    ecs_table_t *table = range.table;
-    ecs_rule_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
-
-    if (!redo) {
-        flecs_rule_get_trav_up_cache(ctx, &trav_ctx->cache, trav, table);
-        trav_ctx->index = 0;
-        if (op->match_flags & EcsTermReflexive) {
-            trav_ctx->yield_reflexive = true;
-            trav_ctx->index = range.offset;
-            trav_ctx->offset = range.offset;
-            trav_ctx->count = range.count ? range.count : ecs_table_count(table);
-        }
-    } else {
-        trav_ctx->index ++;
-    }
+    ecs_meta_type_op_t *ops = ecs_vec_first_t(v_ops, ecs_meta_type_op_t);
+    int32_t count = ecs_vec_count(v_ops);
+    return flecs_expr_ser_type_ops(world, ops, count, base, str, 0, is_expr);
+}
 
-    if (trav_ctx->yield_reflexive) {
-        if (flecs_rule_trav_yield_reflexive_src(op, ctx, &range, trav)) {
-            return true;
-        }
-        trav_ctx->yield_reflexive = false;
-        trav_ctx->index = 0;
+int ecs_ptr_to_expr_buf(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *ptr,
+    ecs_strbuf_t *buf_out)
+{
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
+    if (ser == NULL) {
+        char *path = ecs_get_fullpath(world, type);
+        ecs_err("cannot serialize value for type '%s'", path);
+        ecs_os_free(path);
+        goto error;
     }
 
-    if (trav_ctx->index >= ecs_vec_count(&trav_ctx->cache.entities)) {
-        return false;
+    if (flecs_expr_ser_type(world, &ser->ops, ptr, buf_out, true)) {
+        goto error;
     }
 
-    ecs_trav_elem_t *el = ecs_vec_get_t(
-        &trav_ctx->cache.entities, ecs_trav_elem_t, trav_ctx->index);
-    flecs_rule_set_trav_match(op, el->column, trav, el->entity, ctx);
-    return true;
+    return 0;
+error:
+    return -1;
 }
 
-static
-bool flecs_rule_trav(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+char* ecs_ptr_to_expr(
+    const ecs_world_t *world, 
+    ecs_entity_t type, 
+    const void* ptr)
 {
-    uint64_t written = ctx->written[ctx->op_index];
+    ecs_strbuf_t str = ECS_STRBUF_INIT;
 
-    if (!flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        if (!flecs_ref_is_written(op, &op->second, EcsRuleSecond, written)) {
-            /* This can't happen, src or second should have been resolved */
-            ecs_abort(ECS_INTERNAL_ERROR, 
-                "invalid instruction sequence: unconstrained traversal");
-        } else {
-            return flecs_rule_trav_unknown_src_up_fixed_second(op, redo, ctx);
-        }
-    } else {
-        if (!flecs_ref_is_written(op, &op->second, EcsRuleSecond, written)) {
-            return flecs_rule_trav_fixed_src_up_unknown_second(op, redo, ctx);
-        } else {
-            return flecs_rule_trav_fixed_src_up_fixed_second(op, redo, ctx);
-        }
+    if (ecs_ptr_to_expr_buf(world, type, ptr, &str) != 0) {
+        ecs_strbuf_reset(&str);
+        return NULL;
     }
+
+    return ecs_strbuf_get(&str);
 }
 
-static
-bool flecs_rule_ids(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+int ecs_ptr_to_str_buf(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *ptr,
+    ecs_strbuf_t *buf_out)
 {
-    if (redo) {
-        return false;
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
+    if (ser == NULL) {
+        char *path = ecs_get_fullpath(world, type);
+        ecs_err("cannot serialize value for type '%s'", path);
+        ecs_os_free(path);
+        goto error;
     }
 
-    ecs_id_record_t *cur;
-    ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-
-    {
-        cur = flecs_id_record_get(ctx->world, id);
-        if (!cur || !cur->cache.tables.count) {
-            return false;
-        }
+    if (flecs_expr_ser_type(world, &ser->ops, ptr, buf_out, false)) {
+        goto error;
     }
 
-    flecs_rule_set_vars(op, cur->id, ctx);
+    return 0;
+error:
+    return -1;
+}
 
-    if (op->field_index != -1) {
-        ecs_iter_t *it = ctx->it;
-        it->ids[op->field_index] = id;
-        it->sources[op->field_index] = EcsWildcard;
-        it->columns[op->field_index] = -1; /* Mark field as set */
+char* ecs_ptr_to_str(
+    const ecs_world_t *world, 
+    ecs_entity_t type, 
+    const void* ptr)
+{
+    ecs_strbuf_t str = ECS_STRBUF_INIT;
+
+    if (ecs_ptr_to_str_buf(world, type, ptr, &str) != 0) {
+        ecs_strbuf_reset(&str);
+        return NULL;
     }
 
-    return true;
+    return ecs_strbuf_get(&str);
 }
 
-static
-bool flecs_rule_idsright(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_ids_ctx_t *op_ctx = flecs_op_ctx(ctx, ids);
-    ecs_id_record_t *cur;
+#endif
 
-    if (!redo) {
-        ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-        if (!ecs_id_is_wildcard(id)) {
-            /* If id is not a wildcard, we can directly return it. This can 
-             * happen if a variable was constrained by an iterator. */
-            op_ctx->cur = NULL;
-            flecs_rule_set_vars(op, id, ctx);
-            return true;
-        }
+/**
+ * @file addons/script/tokenizer.c
+ * @brief Script tokenizer.
+ */
 
-        cur = op_ctx->cur = flecs_id_record_get(ctx->world, id);
-        if (!cur) {
-            return false;
-        }
-    } else {
-        if (!op_ctx->cur) {
-            return false;
-        }
-    }
 
-    do {
-        cur = op_ctx->cur = op_ctx->cur->first.next;
-    } while (cur && !cur->cache.tables.count); /* Skip empty ids */
+#ifdef FLECS_SCRIPT
 
-    if (!cur) {
-        return false;
-    }
+#define Keyword(keyword, _kind)\
+    } else if (!ecs_os_strncmp(pos, keyword " ", ecs_os_strlen(keyword) + 1)) {\
+        out->value = keyword;\
+        out->kind = _kind;\
+        return pos + ecs_os_strlen(keyword);
 
-    flecs_rule_set_vars(op, cur->id, ctx);
+#define OperatorMultiChar(oper, _kind)\
+    } else if (!ecs_os_strncmp(pos, oper, ecs_os_strlen(oper))) {\
+        out->value = oper;\
+        out->kind = _kind;\
+        return pos + ecs_os_strlen(oper);
 
-    if (op->field_index != -1) {
-        ecs_iter_t *it = ctx->it;
-        ecs_id_t id = flecs_rule_op_get_id_w_written(op, op->written, ctx);
-        it->ids[op->field_index] = id;
-        it->sources[op->field_index] = EcsWildcard;
-        it->columns[op->field_index] = -1; /* Mark field as set */
-    }
+#define Operator(oper, _kind)\
+    } else if (pos[0] == oper[0]) {\
+        out->value = oper;\
+        out->kind = _kind;\
+        return pos + 1;
 
-    return true;
+const char* flecs_script_token_kind_str(
+    ecs_script_token_kind_t kind)
+{
+    switch(kind) {
+    case EcsTokUnknown:
+        return "unknown token ";
+    case EcsTokColon:
+    case EcsTokScopeOpen:
+    case EcsTokScopeClose:
+    case EcsTokParenOpen:
+    case EcsTokParenClose:
+    case EcsTokBracketOpen:
+    case EcsTokBracketClose:
+    case EcsTokAnnotation:
+    case EcsTokComma:
+    case EcsTokSemiColon:
+    case EcsTokMul:
+    case EcsTokAssign:
+    case EcsTokBitwiseOr:
+    case EcsTokNot:
+    case EcsTokOptional:
+    case EcsTokEq:
+    case EcsTokNeq:
+    case EcsTokMatch:
+    case EcsTokOr:
+        return "";
+    case EcsTokKeywordWith:
+    case EcsTokKeywordUsing:
+    case EcsTokKeywordAssembly:
+    case EcsTokKeywordProp:
+    case EcsTokKeywordConst:
+    case EcsTokKeywordIf:
+    case EcsTokKeywordElse:
+    case EcsTokKeywordModule:
+        return "keyword ";
+    case EcsTokIdentifier:
+        return "identifier ";
+    case EcsTokString:
+        return "string ";
+    case EcsTokNumber:
+        return "number ";
+    case EcsTokNewline:
+        return "newline";
+    case EcsTokEnd:
+        return "end of script";
+    default:
+        return "<corrupt>";
+    }
 }
 
-static
-bool flecs_rule_idsleft(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+const char* flecs_scan_whitespace(
+    ecs_script_parser_t *parser,
+    const char *pos) 
 {
-    ecs_rule_ids_ctx_t *op_ctx = flecs_op_ctx(ctx, ids);
-    ecs_id_record_t *cur;
-
-    if (!redo) {
-        ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-        if (!ecs_id_is_wildcard(id)) {
-            /* If id is not a wildcard, we can directly return it. This can 
-             * happen if a variable was constrained by an iterator. */
-            op_ctx->cur = NULL;
-            flecs_rule_set_vars(op, id, ctx);
-            return true;
-        }
+    (void)parser;
 
-        cur = op_ctx->cur = flecs_id_record_get(ctx->world, id);
-        if (!cur) {
-            return false;
+    if (parser->significant_newline) {
+        while (pos[0] && isspace(pos[0]) && pos[0] != '\n') {
+            pos ++;
         }
     } else {
-        if (!op_ctx->cur) {
-            return false;
+        while (pos[0] && isspace(pos[0])) {
+            pos ++;
         }
     }
 
-    do {
-        cur = op_ctx->cur = op_ctx->cur->second.next;
-    } while (cur && !cur->cache.tables.count); /* Skip empty ids */
-
-    if (!cur) {
-        return false;
-    }
-
-    flecs_rule_set_vars(op, cur->id, ctx);
-
-    if (op->field_index != -1) {
-        ecs_iter_t *it = ctx->it;
-        ecs_id_t id = flecs_rule_op_get_id_w_written(op, op->written, ctx);
-        it->ids[op->field_index] = id;
-        it->sources[op->field_index] = EcsWildcard;
-        it->columns[op->field_index] = -1; /* Mark field as set */
-    }
-
-    return true;
+    return pos;
 }
 
 static
-bool flecs_rule_each(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+const char* flecs_scan_whitespace_and_comment(
+    ecs_script_parser_t *parser,
+    const char *pos) 
 {
-    ecs_rule_each_ctx_t *op_ctx = flecs_op_ctx(ctx, each);
-    int32_t row;
-
-    ecs_table_range_t range = flecs_rule_var_get_range(op->first.var, ctx);
-    ecs_table_t *table = range.table;
-    if (!table) {
-        return false;
-    }
+repeat_skip_whitespace_comment:
+    pos = flecs_scan_whitespace(parser, pos);
+    if (pos[0] == '/') {
+        if (pos[1] == '/') {
+            for (pos = pos + 2; pos[0] && pos[0] != '\n'; pos ++) { }
+            if (pos[0] == '\n') {
+                pos ++;
+                goto repeat_skip_whitespace_comment;
+            }
+        } else if (pos[1] == '*') {
+            for (pos = &pos[2]; pos[0] != 0; pos ++) {
+                if (pos[0] == '*' && pos[1] == '/') {
+                    pos += 2;
+                    goto repeat_skip_whitespace_comment;
+                }
+            }
 
-    if (!redo) {
-        row = op_ctx->row = range.offset;
-    } else {
-        int32_t end = range.count;
-        if (end) {
-            end += range.offset;
-        } else {
-            end = table->data.entities.count;
-        }
-        row = ++ op_ctx->row;
-        if (op_ctx->row >= end) {
-            return false;
+            ecs_parser_error(parser->script->name, parser->script->code, 
+                pos - parser->script->code, "missing */ for multiline comment");
         }
     }
 
-    ecs_assert(row < ecs_table_count(table), ECS_INTERNAL_ERROR, NULL);
-
-    ecs_entity_t *entities = table->data.entities.array;
-    ecs_entity_t e;
-    do {
-        if (row == ecs_table_count(table)) {
-            return false;
-        }
-        e = entities[row ++];
-        ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL);
-    
-        /* Exclude entities that are used as markers by rule engine */
-    } while ((e == EcsWildcard) || (e == EcsAny) || 
-        (e == EcsThis) || (e == EcsVariable));
-
-    flecs_rule_var_set_entity(op, op->src.var, e, ctx);
-
-    return true;
-}
-
-static
-bool flecs_rule_store(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (!redo) {
-        flecs_rule_var_set_entity(op, op->src.var, op->first.entity, ctx);
-        return true;
-    } else {
-        return false;
-    }
+    return pos;
 }
 
+// Identifier token
 static
-bool flecs_rule_reset(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
+bool flecs_script_is_identifier(
+    char c)
 {
-    if (!redo) {
-        return true;
-    } else {
-        flecs_rule_var_reset(op->src.var, ctx);
-        return false;
-    }
+    return isalpha(c) || (c == '_') || (c == '$');
 }
 
 static
-void flecs_rule_reset_after_block(
-    const ecs_rule_op_t *start_op,
-    ecs_rule_run_ctx_t *ctx,
-    ecs_rule_ctrl_ctx_t *op_ctx)
+const char* flecs_script_identifier(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out) 
 {
-    ecs_rule_lbl_t op_index = start_op->next;
-    const ecs_rule_op_t *op = &ctx->rit->ops[op_index];
-    ctx->written[op_index] = ctx->written[ctx->op_index];
-    ctx->op_index = op_index;
-
-    int32_t field = op->field_index;
-    if (field == -1) {
-        goto done;
-    }
-
-    ecs_iter_t *it = ctx->it;
+    out->kind = EcsTokIdentifier;
+    out->value = parser->token_cur;
 
-    /* Not terms return no data */
-    it->columns[field] = 0;
+    ecs_assert(flecs_script_is_identifier(pos[0]), ECS_INTERNAL_ERROR, NULL);
+    char *outpos = parser->token_cur;
+    do {
+        char c = pos[0];
+        bool is_ident = flecs_script_is_identifier(c) || 
+            isdigit(c) || (c == '.') || (c == '*');
+
+        if (!is_ident) {
+            if (c == '\\') {
+                pos ++;
+            } else if (c == '<') {
+                int32_t indent = 0;
+                do {
+                    c = *pos;
+
+                    if (c == '<') {
+                        indent ++;
+                    } else if (c == '>') {
+                        indent --;
+                    } else if (!c) {
+                        ecs_parser_error(parser->script->name, 
+                            parser->script->code, pos - parser->script->code, 
+                                "< without > in identifier");
+                        return NULL;
+                    }
 
-    /* Ignore variables written by Not operation */
-    uint64_t *written = ctx->written;
-    uint64_t written_cur = written[op->prev + 1];
-    ecs_flags16_t flags_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t flags_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
+                    *outpos = c;
+                    outpos ++;
+                    pos ++;
 
-    /* Overwrite id with cleared out variables */
-    ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-    if (id) {
-        it->ids[field] = id;
-    }
+                    if (!indent) {
+                        break;
+                    }
+                } while (true);
 
-    /* Reset variables */
-    if (flags_1st & EcsRuleIsVar) {
-        if (!flecs_ref_is_written(op, &op->first, EcsRuleFirst, written_cur)){
-            flecs_rule_var_reset(op->first.var, ctx);
-        }
-    }
-    if (flags_2nd & EcsRuleIsVar) {
-        if (!flecs_ref_is_written(op, &op->second, EcsRuleSecond, written_cur)){
-            flecs_rule_var_reset(op->second.var, ctx);
+                *outpos = '\0';
+                parser->token_cur = outpos + 1;
+                return pos;
+            } else if (c == '>') {
+                ecs_parser_error(parser->script->name, parser->script->code,
+                    pos - parser->script->code, "> without < in identifier");
+                return NULL;
+            } else {
+                *outpos = '\0';
+                parser->token_cur = outpos + 1;
+                return pos;
+            }
         }
-    }
-
-    /* If term has entity src, set it because no other instruction might */
-    if (op->flags & (EcsRuleIsEntity << EcsRuleSrc)) {
-        it->sources[field] = op->src.entity;
-    }
 
-done:
-    op_ctx->op_index = op_index;
+        *outpos = *pos;
+        outpos ++;
+        pos ++;
+    } while (true);
 }
 
+// Number token
 static
-const char* flecs_rule_name_arg(
-    const ecs_rule_op_t *op,
-    ecs_rule_run_ctx_t *ctx)
+bool flecs_script_is_number(
+    char c)
 {
-    int8_t term_index = op->term_index;
-    ecs_term_t *term = &ctx->rule->filter.terms[term_index];
-    return term->second.name;
+    return isdigit(c) || (c == '-');
 }
 
 static
-bool flecs_rule_compare_range(
-    const ecs_table_range_t *l,
-    const ecs_table_range_t *r)
+const char* flecs_script_number(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out) 
 {
-    if (l->table != r->table) {
-        return false;
-    }
+    out->kind = EcsTokNumber;
+    out->value = parser->token_cur;
 
-    if (l->count) {
-        int32_t l_end = l->offset + l->count;
-        int32_t r_end = r->offset + r->count;
-        if (r->offset < l->offset) {
-            return false;
-        }
-        if (r_end > l_end) {
-            return false;
+    ecs_assert(flecs_script_is_number(pos[0]), ECS_INTERNAL_ERROR, NULL);
+    char *outpos = parser->token_cur;
+    do {
+        char c = pos[0];
+        if (!isdigit(c)) {
+            *outpos = '\0';
+            parser->token_cur = outpos + 1;
+            break;
         }
-    } else {
-        /* Entire table is matched */
-    }
 
-    return true;
+        outpos[0] = pos[0];
+        outpos ++;
+        pos ++;
+    } while (true);
+
+    return pos;
 }
 
 static
-bool flecs_rule_pred_eq_w_range(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    ecs_table_range_t r)
+const char* flecs_script_skip_string(
+    ecs_script_parser_t *parser,
+    const char *pos, 
+    char delim)
 {
-    if (redo) {
-        return false;
-    }
-
-    uint64_t written = ctx->written[ctx->op_index];
-    ecs_var_id_t first_var = op->first.var;
-    if (!(written & (1ull << first_var))) {
-        /* left = unknown, right = known. Assign right-hand value to left */
-        ecs_var_id_t l = first_var;
-        ctx->vars[l].range = r;
-        if (r.count == 1) {
-            ctx->vars[l].entity = ecs_vec_get_t(&r.table->data.entities, 
-                ecs_entity_t, r.offset)[0];
-        }
-        return true;
-    } else {
-        ecs_table_range_t l = flecs_rule_get_range(
-            op, &op->first, EcsRuleFirst, ctx);
-
-        if (!flecs_rule_compare_range(&l, &r)) {
-            return false;
+    char ch;
+    for (; (ch = pos[0]) && pos[0] != delim; pos ++) {
+        if (ch == '\\') {
+            pos ++;
         }
-
-        ctx->vars[first_var].range.offset = r.offset;
-        ctx->vars[first_var].range.count = r.count;
-        return true;
     }
-}
 
-static
-bool flecs_rule_pred_eq(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index]; (void)written;
-    ecs_assert(flecs_ref_is_written(op, &op->second, EcsRuleSecond, written),
-        ECS_INTERNAL_ERROR, 
-            "invalid instruction sequence: uninitialized eq operand");
+    if (!pos[0]) {
+        ecs_parser_error(parser->script->name, parser->script->code,
+            pos - parser->script->code, "unterminated string");
+        return NULL;
+    }
 
-    ecs_table_range_t r = flecs_rule_get_range(
-        op, &op->second, EcsRuleSecond, ctx);
-    return flecs_rule_pred_eq_w_range(op, redo, ctx, r);
+    return pos;
 }
 
 static
-bool flecs_rule_pred_eq_name(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+const char* flecs_script_string(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out) 
 {
-    const char *name = flecs_rule_name_arg(op, ctx);
-    ecs_entity_t e = ecs_lookup(ctx->world, name);
-    if (!e) {
-        /* Entity doesn't exist */
-        return false;
+    const char *end = flecs_script_skip_string(parser, pos + 1, '"');
+    if (!end) {
+        return NULL;
     }
 
-    ecs_table_range_t r = flecs_range_from_entity(e, ctx);
-    return flecs_rule_pred_eq_w_range(op, redo, ctx, r);
+    ecs_assert(end[0] == '"', ECS_INTERNAL_ERROR, NULL);
+    end --;
+
+    int32_t len = flecs_ito(int32_t, end - pos);
+    ecs_os_memcpy(parser->token_cur, pos + 1, len);
+    parser->token_cur[len] = '\0';
+
+    out->kind = EcsTokString;
+    out->value = parser->token_cur;
+    parser->token_cur += len + 1;
+    return end + 2;
 }
 
-static
-bool flecs_rule_pred_neq_w_range(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    ecs_table_range_t r)
+const char* flecs_script_expr(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out,
+    char until)
 {
-    ecs_rule_eq_ctx_t *op_ctx = flecs_op_ctx(ctx, eq);
-    ecs_var_id_t first_var = op->first.var;
-    ecs_table_range_t l = flecs_rule_get_range(
-        op, &op->first, EcsRuleFirst, ctx);
+    parser->pos = pos;
 
-    /* If tables don't match, neq always returns once */
-    if (l.table != r.table) {
-        return true && !redo;
+    int32_t scope_depth = until == '}' ? 1 : 0;
+    int32_t paren_depth = until == ')' ? 1 : 0;
+    
+    const char *start = pos = flecs_scan_whitespace(parser, pos);
+    char ch;
+
+    for (; (ch = pos[0]); pos ++) {
+        if (ch == '{') {
+            if (ch == until) {
+                break;
+            }
+            scope_depth ++;
+        } else 
+        if (ch == '}') {
+            scope_depth --;
+            if (!scope_depth && until == '}') {
+                break;
+            }
+            if (scope_depth < 0) {
+                ecs_parser_error(parser->script->name, parser->script->code,
+                    pos - parser->script->code, "mismatching { }");
+                return NULL;
+            }
+        } else
+        if (ch == '(') {
+            paren_depth ++;
+        } else
+        if (ch == ')') {
+            paren_depth --;
+            if (!paren_depth && until == ')') {
+                break;
+            }
+            if (paren_depth < 0) {
+                ecs_parser_error(parser->script->name, parser->script->code,
+                    pos - parser->script->code, "mismatching ( )");
+                return NULL;
+            }
+        } else
+        if (ch == '"') {
+            pos = flecs_script_skip_string(parser, pos + 1, '"');
+            if (!pos) {
+                return NULL;
+            }
+        } else
+        if (ch == '`') {
+            pos = flecs_script_skip_string(parser, pos + 1, '`');
+            if (!pos) {
+                return NULL;
+            }
+        } else
+        if (ch == until) {
+            break;
+        }
     }
 
-    int32_t l_offset;
-    int32_t l_count;
-    if (!redo) {
-        /* Make sure we're working with the correct table count */
-        if (!l.count && l.table) {
-            l.count = ecs_table_count(l.table);
+    if (!pos[0]) {
+        if (until == '\0') {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected end of script");
+            return NULL;
+        } else
+        if (until == '\n') {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected newline");
+            return NULL;
+        } else {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected '%c'", until);
+            return NULL;
         }
+    }
 
-        l_offset = l.offset;
-        l_count = l.count;
+    if (scope_depth) {
+        ecs_parser_error(parser->script->name, parser->script->code,
+            pos - parser->script->code, "mismatching { }");
+        return NULL;
+    }
+    if (paren_depth) {
+        ecs_parser_error(parser->script->name, parser->script->code,
+            pos - parser->script->code, "mismatching ( )");
+        return NULL;
+    }
 
-        /* Cache old value */
-        op_ctx->range = l;
+    if (until != ']') {
+        parser->token_cur[0] = '{';
     } else {
-        l_offset = op_ctx->range.offset;
-        l_count = op_ctx->range.count;
+        parser->token_cur[0] = '[';
     }
+    
+    int32_t len = flecs_ito(int32_t, pos - start);
+    ecs_os_memcpy(parser->token_cur + 1, start, len);
+    out->value = parser->token_cur;
+    parser->token_cur += len + 1;
 
-    /* If the table matches, a Neq returns twice: once for the slice before the
-     * excluded slice, once for the slice after the excluded slice. If the right
-     * hand range starts & overlaps with the left hand range, there is only
-     * one slice. */
-    ecs_var_t *var = &ctx->vars[first_var];
-    if (!redo && r.offset > l_offset) {
-        int32_t end = r.offset;
-        if (end > l_count) {
-            end = l_count;
-        }
+    while (isspace(parser->token_cur[-1])) {
+        parser->token_cur --;
+    }
 
-        /* Return first slice */
-        var->range.table = l.table;
-        var->range.offset = l_offset;
-        var->range.count = end - l_offset;
-        op_ctx->redo = false;
-        return true;
-    } else if (!op_ctx->redo) {
-        int32_t l_end = op_ctx->range.offset + l_count;
-        int32_t r_end = r.offset + r.count;
+    if (until != ']') {
+        parser->token_cur[0] = '}';
+    } else {
+        parser->token_cur[0] = ']';
+    }
 
-        if (l_end <= r_end) {
-            /* If end of existing range falls inside the excluded range, there's
-             * nothing more to return */
-            var->range = l;
-            return false;
-        }
+    parser->token_cur ++;
 
-        /* Return second slice */
-        var->range.table = l.table;
-        var->range.offset = r_end;
-        var->range.count = l_end - r_end;
+    parser->token_cur[0] = '\0';
+    parser->token_cur ++;
 
-        /* Flag so we know we're done the next redo */
-        op_ctx->redo = true;
-        return true;
-    } else {
-        /* Restore previous value */
-        var->range = l;
-        return false;
-    }
+    return pos;
 }
 
-static
-bool flecs_rule_pred_match(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    bool is_neq)
+const char* flecs_script_until(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out,
+    char until)
 {
-    ecs_rule_eq_ctx_t *op_ctx = flecs_op_ctx(ctx, eq);
-    uint64_t written = ctx->written[ctx->op_index];
-    ecs_assert(flecs_ref_is_written(op, &op->first, EcsRuleFirst, written),
-        ECS_INTERNAL_ERROR, 
-            "invalid instruction sequence: uninitialized match operand");
-    (void)written;
+    parser->pos = pos;
+    
+    const char *start = pos = flecs_scan_whitespace(parser, pos);
+    char ch;
 
-    ecs_var_id_t first_var = op->first.var;
-    const char *match = flecs_rule_name_arg(op, ctx);
-    ecs_table_range_t l;
-    if (!redo) {
-        l = flecs_rule_get_range(op, &op->first, EcsRuleFirst, ctx);
-        if (!l.table) {
-            return false;
+    for (; (ch = pos[0]); pos ++) {
+        if (ch == until) {
+            break;
         }
+    }
 
-        if (!l.count) {
-            l.count = ecs_table_count(l.table);
+    if (!pos[0]) {
+        if (until == '\0') {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected end of script");
+            return NULL;
+        } else
+        if (until == '\n') {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected newline");
+            return NULL;
+        } else {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected '%c'", until);
+            return NULL;
         }
+    }
 
-        op_ctx->range = l;
-        op_ctx->index = l.offset;
-        op_ctx->name_col = flecs_ito(int16_t,   
-            ecs_table_get_type_index(ctx->world, l.table, 
-                ecs_pair(ecs_id(EcsIdentifier), EcsName)));
-        if (op_ctx->name_col == -1) {
-            return is_neq;
-        }
-        op_ctx->name_col = flecs_ito(int16_t, 
-            l.table->column_map[op_ctx->name_col]);
-        ecs_assert(op_ctx->name_col != -1, ECS_INTERNAL_ERROR, NULL);
-    } else {
-        if (op_ctx->name_col == -1) {
-            /* Table has no name */
-            return false;
-        }
+    int32_t len = flecs_ito(int32_t, pos - start);
+    ecs_os_memcpy(parser->token_cur, start, len);
+    out->value = parser->token_cur;
+    parser->token_cur += len;
 
-        l = op_ctx->range;
+    while (isspace(parser->token_cur[-1])) {
+        parser->token_cur --;
     }
 
-    const EcsIdentifier *names = l.table->data.columns[op_ctx->name_col].data.array;
-    int32_t count = l.offset + l.count, offset = -1;
-    for (; op_ctx->index < count; op_ctx->index ++) {
-        const char *name = names[op_ctx->index].value;
-        bool result = strstr(name, match);
-        if (is_neq) {
-            result = !result;
-        }
+    parser->token_cur[0] = '\0';
+    parser->token_cur ++;
 
-        if (!result) {
-            if (offset != -1) {
-                break;
-            }
-        } else {
-            if (offset == -1) {
-                offset = op_ctx->index;
-            }
-        }
-    }
+    return pos;
+}
 
-    if (offset == -1) {
-        ctx->vars[first_var].range = op_ctx->range;
-        return false;
+const char* flecs_script_token(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out,
+    bool is_lookahead)
+{
+    parser->pos = pos;
+
+    // Skip whitespace and comments
+    pos = flecs_scan_whitespace_and_comment(parser, pos);
+
+    out->kind = EcsTokUnknown;
+    out->value = NULL;
+
+    if (pos[0] == '\0') {
+        out->kind = EcsTokEnd;
+        return pos;
+    } else if (pos[0] == '\n') {
+        out->kind = EcsTokNewline;
+        
+        // Parse multiple newlines/whitespaces as a single token
+        pos = flecs_scan_whitespace_and_comment(parser, pos + 1);
+        if (pos[0] == '\n') {
+            pos ++;
+        }
+        return pos;
+
+    Operator          (":",        EcsTokColon)
+    Operator          ("{",        EcsTokScopeOpen)
+    Operator          ("}",        EcsTokScopeClose)
+    Operator          ("(",        EcsTokParenOpen)
+    Operator          (")",        EcsTokParenClose)
+    Operator          ("[",        EcsTokBracketOpen)
+    Operator          ("]",        EcsTokBracketClose)
+    Operator          ("@",        EcsTokAnnotation)
+    Operator          (",",        EcsTokComma)
+    Operator          (";",        EcsTokSemiColon)
+    Operator          ("*",        EcsTokMul)
+    Operator          ("?",        EcsTokOptional)
+
+    OperatorMultiChar ("==",       EcsTokEq)
+    OperatorMultiChar ("!=",       EcsTokNeq)
+    OperatorMultiChar ("~=",       EcsTokMatch)
+    OperatorMultiChar ("||",       EcsTokOr)
+
+    OperatorMultiChar ("!",        EcsTokNot)
+    OperatorMultiChar ("=",        EcsTokAssign)
+    OperatorMultiChar ("|",        EcsTokBitwiseOr)
+
+    Keyword           ("with",     EcsTokKeywordWith)
+    Keyword           ("using",    EcsTokKeywordUsing)
+    Keyword           ("assembly", EcsTokKeywordAssembly)
+    Keyword           ("prop",     EcsTokKeywordProp)
+    Keyword           ("const",    EcsTokKeywordConst)
+    Keyword           ("if",       EcsTokKeywordIf)
+    Keyword           ("else",     EcsTokKeywordElse)
+    Keyword           ("module",   EcsTokKeywordModule)
+
+    } else if (pos[0] == '"') {
+        return flecs_script_string(parser, pos, out);
+
+    } else if (flecs_script_is_number(pos[0])) {
+        return flecs_script_number(parser, pos, out);
+
+    } else if (flecs_script_is_identifier(pos[0])) {
+        return flecs_script_identifier(parser, pos, out);
+    }
+
+    if (!is_lookahead) {
+        ecs_parser_error(parser->script->name, parser->script->code,
+            pos - parser->script->code, "unknown token '%c'", pos[0]);
     }
 
-    ctx->vars[first_var].range.offset = offset;
-    ctx->vars[first_var].range.count = (op_ctx->index - offset);
-    return true;
+    return NULL;
 }
 
-static
-bool flecs_rule_pred_eq_match(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+#endif
+
+/**
+ * @file addons/script/vars.c
+ * @brief Script variables.
+ */
+
+
+#ifdef FLECS_SCRIPT
+
+ecs_script_vars_t* flecs_script_vars_push(
+    ecs_script_vars_t *parent,
+    ecs_stack_t *stack,
+    ecs_allocator_t *allocator)
 {
-    return flecs_rule_pred_match(op, redo, ctx, false);
+    ecs_check(stack || parent, ECS_INVALID_PARAMETER, 
+        "must provide either parent scope or stack allocator");
+    ecs_check(allocator || parent, ECS_INVALID_PARAMETER, 
+        "must provide either parent scope or allocator");
+
+    if (!stack) {
+        stack = parent->stack;
+    } else if (parent) {
+        ecs_check(stack == parent->stack, ECS_INVALID_PARAMETER, 
+            "provided stack allocator is different from parent scope");
+    }
+    if (!allocator) {
+        allocator = parent->allocator;
+    } else if (parent) {
+        ecs_check(allocator == parent->allocator, ECS_INVALID_PARAMETER, 
+            "provided allocator is different from parent scope");        
+    }
+
+    ecs_stack_cursor_t *cursor = flecs_stack_get_cursor(stack);
+    ecs_script_vars_t *result = flecs_stack_calloc_t(stack, ecs_script_vars_t);
+    ecs_vec_init_t(allocator, &result->vars, ecs_script_var_t, 0);
+    result->parent = parent;
+    if (parent) {
+        result->world = parent->world;
+    }
+    result->stack = stack;
+    result->allocator = allocator;
+    result->cursor = cursor;
+    return result;
+error:
+    return NULL;
 }
 
-static
-bool flecs_rule_pred_neq_match(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+ecs_script_vars_t* ecs_script_vars_init(
+    ecs_world_t *world)
 {
-    return flecs_rule_pred_match(op, redo, ctx, true);
+    ecs_script_vars_t *result = flecs_script_vars_push(NULL, 
+        flecs_stage_get_stack_allocator(world),
+        flecs_stage_get_allocator(world));
+    result->world = ecs_get_world(world); /* Provided world can be stage */
+    return result;
 }
 
-static
-bool flecs_rule_pred_neq(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+void ecs_script_vars_fini(
+    ecs_script_vars_t *vars)
 {
-    uint64_t written = ctx->written[ctx->op_index]; (void)written;
-    ecs_assert(flecs_ref_is_written(op, &op->second, EcsRuleSecond, written),
-        ECS_INTERNAL_ERROR, 
-            "invalid instruction sequence: uninitialized neq operand");
+    ecs_check(vars->parent == NULL, ECS_INVALID_PARAMETER,
+        "ecs_script_vars_fini can only be called on the roots cope");
+    ecs_script_vars_pop(vars);
+error:
+    return;
+}
 
-    ecs_table_range_t r = flecs_rule_get_range(
-        op, &op->second, EcsRuleSecond, ctx);
-    return flecs_rule_pred_neq_w_range(op, redo, ctx, r);
+ecs_script_vars_t* ecs_script_vars_push(
+    ecs_script_vars_t *parent)
+{
+    ecs_check(parent != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_stack_t *stack = parent->stack;
+    ecs_allocator_t *allocator = parent->allocator;
+    ecs_check(stack != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(allocator != NULL, ECS_INVALID_PARAMETER, NULL);
+    return flecs_script_vars_push(parent, stack, allocator);
+error:
+    return NULL;
 }
 
-static
-bool flecs_rule_pred_neq_name(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+ecs_script_vars_t* ecs_script_vars_pop(
+    ecs_script_vars_t *vars)
 {
-    const char *name = flecs_rule_name_arg(op, ctx);
-    ecs_entity_t e = ecs_lookup(ctx->world, name);
-    if (!e) {
-        /* Entity doesn't exist */
-        return true && !redo;
+    ecs_script_vars_t *parent = vars->parent;
+    ecs_stack_cursor_t *cursor = vars->cursor;
+    int32_t i, count = ecs_vec_count(&vars->vars);
+    if (count) {
+        ecs_script_var_t *var_array = ecs_vec_first(&vars->vars);
+        for (i = 0; i < count; i ++) {
+            ecs_script_var_t *var = &var_array[i];
+            if (!var->value.ptr) {
+                continue;
+            }
+
+            if (!var->type_info || !var->type_info->hooks.dtor) {
+                continue;
+            }
+
+            var->type_info->hooks.dtor(var->value.ptr, 1, var->type_info);
+        }
+
+        flecs_name_index_fini(&vars->var_index);
     }
 
-    ecs_table_range_t r = flecs_range_from_entity(e, ctx);
-    return flecs_rule_pred_neq_w_range(op, redo, ctx, r);
+    ecs_vec_fini_t(vars->allocator, &vars->vars, ecs_script_var_t);
+    flecs_stack_restore_cursor(vars->stack, cursor);
+    return parent;
 }
 
-static
-bool flecs_rule_lookup(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+ecs_script_var_t* ecs_script_vars_declare(
+    ecs_script_vars_t *vars,
+    const char *name)
 {
-    if (redo) {
-        return false;
+    if (!ecs_vec_count(&vars->vars)) {
+        flecs_name_index_init(&vars->var_index, vars->allocator);
+    } else {
+        if (flecs_name_index_find(&vars->var_index, name, 0, 0) != 0) {
+            goto error;
+        }
     }
 
-    const ecs_rule_t *rule = ctx->rule;
-    ecs_entity_t first = flecs_rule_var_get_entity(op->first.var, ctx);
-    ecs_rule_var_t *var = &rule->vars[op->src.var];
-
-    ecs_entity_t result = ecs_lookup_path_w_sep(ctx->world, first, var->lookup,
-        NULL, NULL, false);
-    if (!result) {
-        flecs_rule_var_set_entity(op, op->src.var, EcsWildcard, ctx);
-        return false;
-    }
+    ecs_script_var_t *var = ecs_vec_append_t(
+        vars->allocator, &vars->vars, ecs_script_var_t);
+    var->name = name;
+    var->value.ptr = NULL;
+    var->value.type = 0;
+    var->type_info = NULL;
 
-    flecs_rule_var_set_entity(op, op->src.var, result, ctx);
+    flecs_name_index_ensure(&vars->var_index,
+        flecs_ito(uint64_t, ecs_vec_count(&vars->vars)), name, 0, 0);
 
-    return true;
+    return var;
+error:
+    return NULL;
 }
 
-static
-bool flecs_rule_setvars(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+ecs_script_var_t* ecs_script_vars_define_id(
+    ecs_script_vars_t *vars,
+    const char *name,
+    ecs_entity_t type)
 {
-    (void)op;
+    ecs_check(vars->world != NULL, ECS_INVALID_OPERATION, "variable scope is "
+        "not associated with world, create scope with ecs_script_vars_init");
 
-    const ecs_rule_t *rule = ctx->rule;
-    const ecs_filter_t *filter = &rule->filter;
-    ecs_var_id_t *src_vars = rule->src_vars;
-    ecs_iter_t *it = ctx->it;
+    const ecs_type_info_t *ti = ecs_get_type_info(vars->world, type);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, 
+        "the entity provided for the type parameter is not a type");
 
-    if (redo) {
-        return false;
+    ecs_script_var_t *result = ecs_script_vars_declare(vars, name);
+    if (!result) {
+        return NULL;
     }
 
-    int32_t i;
-    ecs_flags32_t source_set = *ctx->source_set;
-    for (i = 0; i < filter->field_count; i ++) {
-        ecs_var_id_t var_id = src_vars[i];
-        if (!var_id) {
-            continue;
-        }
-
-        if (source_set & (1u << i)) {
-            continue;
-        }
+    result->value.type = type;
+    result->value.ptr = flecs_stack_alloc(vars->stack, ti->size, ti->alignment);
+    result->type_info = ti;
 
-        it->sources[i] = flecs_rule_var_get_entity(var_id, ctx);
+    if (ti->hooks.ctor) {
+        ti->hooks.ctor(result->value.ptr, 1, ti);
     }
 
-    return true;
+    return result;
+error:
+    return NULL;
 }
 
-static
-bool flecs_rule_setthis(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+ecs_script_var_t* ecs_script_vars_lookup(
+    const ecs_script_vars_t *vars,
+    const char *name)
 {
-    ecs_rule_setthis_ctx_t *op_ctx = flecs_op_ctx(ctx, setthis);
-    ecs_var_t *vars = ctx->vars;
-    ecs_var_t *this_var = &vars[op->first.var];
-
-    if (!redo) {
-        /* Save values so we can restore them later */
-        op_ctx->range = vars[0].range;
+    uint64_t var_id = 0;
+    if (ecs_vec_count(&vars->vars)) {
+        var_id = flecs_name_index_find(&vars->var_index, name, 0, 0);
+    }
 
-        /* Constrain This table variable to a single entity from the table */
-        vars[0].range = flecs_range_from_entity(this_var->entity, ctx);
-        vars[0].entity = this_var->entity;
-        return true;
-    } else {
-        /* Restore previous values, so that instructions that are operating on
-         * the table variable use all the entities in the table. */
-        vars[0].range = op_ctx->range;
-        vars[0].entity = 0;
-        return false;
+    if (!var_id) {
+        if (vars->parent) {
+            return ecs_script_vars_lookup(vars->parent, name);
+        }
+        return NULL;
     }
+
+    return ecs_vec_get_t(&vars->vars, ecs_script_var_t, 
+        flecs_uto(int32_t, var_id - 1));
 }
 
-static
-bool flecs_rule_setfixed(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    const ecs_rule_t *rule = ctx->rule;
-    const ecs_filter_t *filter = &rule->filter;
-    ecs_iter_t *it = ctx->it;
+/* Static names for iterator fields */
+static const char* flecs_script_iter_field_names[] = {
+    "0", "1",  "2",  "3",  "4",  "5",  "6",  "7",
+    "8", "9", "10", "11", "12", "13", "14", "15"
+};
 
-    if (redo) {
-        return false;
-    }
+void ecs_script_vars_from_iter(
+    const ecs_iter_t *it,
+    ecs_script_vars_t *vars,
+    int offset)
+{
+    ecs_check(vars != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!offset || offset < it->count, ECS_INVALID_PARAMETER, NULL);
 
-    int32_t i;
-    for (i = 0; i < filter->term_count; i ++) {
-        ecs_term_t *term = &filter->terms[i];
-        ecs_term_id_t *src = &term->src;
-        if (src->flags & EcsIsEntity) {
-            it->sources[term->field_index] = src->id;
+    /* Set variable for $this */
+    if (it->count) {
+        ecs_script_var_t *var = ecs_script_vars_lookup(vars, "this");
+        if (!var) {
+            var = ecs_script_vars_declare(vars, "this");
+            var->value.type = ecs_id(ecs_entity_t);
         }
+        var->value.ptr = &it->entities[offset];
     }
 
-    return true;
-}
+    /* Set variables for fields */
+    {
+        int32_t i, field_count = it->field_count;
+        for (i = 0; i < field_count; i ++) {
+            ecs_size_t size = it->sizes[i];
+            if (!size) {
+                continue;
+            }
 
-static
-bool flecs_rule_setids(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    const ecs_rule_t *rule = ctx->rule;
-    const ecs_filter_t *filter = &rule->filter;
-    ecs_iter_t *it = ctx->it;
+            void *ptr = it->ptrs[i];
+            if (!ptr) {
+                continue;
+            }
 
-    if (redo) {
-        return false;
+            ptr = ECS_OFFSET(ptr, offset * size);
+
+            const char *name = flecs_script_iter_field_names[i];
+            ecs_script_var_t *var = ecs_script_vars_lookup(vars, name);
+            if (!var) {
+                var = ecs_script_vars_declare(vars, name);
+                ecs_assert(ecs_script_vars_lookup(vars, name) != NULL,  
+                    ECS_INTERNAL_ERROR, NULL);
+                var->value.type = it->ids[i];
+            } else {
+                ecs_check(var->value.type == it->ids[i], 
+                    ECS_INVALID_PARAMETER, NULL);
+            }
+            var->value.ptr = ptr;
+        }
     }
 
-    int32_t i;
-    for (i = 0; i < filter->term_count; i ++) {
-        ecs_term_t *term = &filter->terms[i];
-        it->ids[term->field_index] = term->id;
+    /* Set variables for query variables */
+    {
+        int32_t i, var_count = it->variable_count;
+        for (i = 1 /* skip this variable */ ; i < var_count; i ++) {
+            ecs_entity_t *e_ptr = NULL;
+            ecs_var_t *query_var = &it->variables[i];
+            if (query_var->entity) {
+                e_ptr = &query_var->entity;
+            } else {
+                ecs_table_range_t *range = &query_var->range;
+                if (range->count == 1) {
+                    ecs_entity_t *entities = range->table->data.entities.array;
+                    e_ptr = &entities[range->offset];
+                }
+            }
+            if (!e_ptr) {
+                continue;
+            }
+
+            ecs_script_var_t *var = ecs_script_vars_lookup(
+                vars, it->variable_names[i]);
+            if (!var) {
+                var = ecs_script_vars_declare(vars, it->variable_names[i]);
+                var->value.type = ecs_id(ecs_entity_t);
+            } else {
+                ecs_check(var->value.type == ecs_id(ecs_entity_t), 
+                    ECS_INVALID_PARAMETER, NULL);
+            }
+            var->value.ptr = e_ptr;
+        }
     }
 
-    return true;
+error:
+    return;
 }
 
-static
-bool flecs_rule_setid(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+#endif
+
+/**
+ * @file addons/script/visit.c
+ * @brief Script AST visitor utilities.
+ */
+
+
+#ifdef FLECS_SCRIPT
+
+ecs_script_node_t* ecs_script_parent_node_(
+    ecs_script_visit_t *v)
 {
-    if (redo) {
-        return false;
+    if (v->depth > 1) {
+        return v->nodes[v->depth - 2]; /* Last node is current node */
+    } else {
+        return NULL;
     }
-
-    ecs_assert(op->field_index != -1, ECS_INTERNAL_ERROR, NULL);
-    ctx->it->ids[op->field_index] = op->first.entity;
-    return true;
 }
 
-/* Check if entity is stored in table */
-static
-bool flecs_rule_contain(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+ecs_script_scope_t* ecs_script_current_scope_(
+    ecs_script_visit_t *v)
 {
-    if (redo) {
-        return false;
+    int32_t depth;
+    for(depth = v->depth - 1; depth >= 0; depth --) {
+        ecs_script_node_t *node = v->nodes[depth];
+        if (node->kind == EcsAstScope) {
+            return (ecs_script_scope_t*)node;
+        }
     }
 
-    ecs_var_id_t src_id = op->src.var;
-    ecs_var_id_t first_id = op->first.var;
+    return NULL;
+}
 
-    ecs_table_t *table = flecs_rule_var_get_table(src_id, ctx);
+ecs_script_node_t* ecs_script_parent_(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *child)
+{
+    int32_t depth;
+    for(depth = v->depth - 1; depth >= 0; depth --) {
+        ecs_script_node_t *node = v->nodes[depth];
+        if (node == child && depth) {
+            return v->nodes[depth - 1];
+        }
+    }
 
-    ecs_entity_t e = flecs_rule_var_get_entity(first_id, ctx);
-    return table == ecs_get_table(ctx->world, e);
+    return NULL;
 }
 
-/* Check if first and second id of pair from last operation are the same */
-static
-bool flecs_rule_pair_eq(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+int32_t ecs_script_node_line_number_(
+    ecs_script_t *script,
+    ecs_script_node_t *node)
 {
-    if (redo) {
-        return false;
+    const char *ptr;
+    int32_t line_count = 1;
+    for (ptr = script->code; ptr < node->pos; ptr ++) {
+        ecs_assert(ptr[0] != 0, ECS_INTERNAL_ERROR, NULL);
+        if (ptr[0] == '\n') {
+            line_count ++;
+        }
     }
 
-    ecs_iter_t *it = ctx->it;
-    ecs_id_t id = it->ids[op->field_index];
-    return ECS_PAIR_FIRST(id) == ECS_PAIR_SECOND(id);
+    return line_count;
 }
 
-static
-bool flecs_rule_select_or(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+int ecs_script_visit_scope_(
+    ecs_script_visit_t *v,
+    ecs_script_scope_t *scope)
 {
-    ecs_iter_t *it = ctx->it;
-    ecs_rule_iter_t *rit = &it->priv.iter.rule;
-    ecs_rule_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
-
-    ecs_rule_lbl_t first = flecs_itolbl(ctx->op_index + 1);
-    if (!redo) {
-        op_ctx->op_index = first;
-    }
+    ecs_script_node_t **nodes = ecs_vec_first_t(
+        &scope->stmts, ecs_script_node_t*);
 
-    const ecs_rule_op_t *cur = &rit->ops[op_ctx->op_index];
-    bool result = false;
-    
-    /* Evaluate operations in OR chain one by one. */
+    v->nodes[v->depth ++] = (ecs_script_node_t*)scope;
 
-    do {
-        ctx->op_index = op_ctx->op_index;
-        ctx->written[op_ctx->op_index] = op->written;
+    int32_t i, count = ecs_vec_count(&scope->stmts);
+    for (i = 0; i < count; i ++) {
+        if (!i) {
+            v->prev = NULL;
+        } else {
+            v->prev = nodes[i - 1];
+        }
 
-        result = flecs_rule_dispatch(cur, redo, ctx);
-        if (result) {
-            ctx->written[op_ctx->op_index] |= cur->written;
+        if (i != (count - 1)) {
+            v->next = nodes[i + 1];
+        } else {
+            v->next = NULL;
+        }
 
-            /* If a previous operation in the OR chain returned a result for the
-             * same matched source, skip it so we don't yield for each matching
-             * element in the chain. */
-            ecs_rule_lbl_t prev_index;
-            for (prev_index = first; prev_index < op_ctx->op_index; 
-                prev_index ++) 
-            {
-                const ecs_rule_op_t *prev = &rit->ops[prev_index];
-                ctx->op_index = prev_index;
-                ctx->written[prev_index] = ctx->written[op_ctx->op_index];
-                if (flecs_rule_dispatch(prev, false, ctx)) {
-                    break;
-                }
-            }
+        v->nodes[v->depth ++] = nodes[i];
 
-            if (prev_index != op_ctx->op_index) {
-                /* Duplicate match was found, redo search */
-                redo = true;
-                continue;
-            }
-            break;
+        if (v->visit(v, nodes[i])) {
+            return -1;
         }
 
-        /* No result was found, go to next operation in chain */
-        op_ctx->op_index ++;
-        cur = &rit->ops[op_ctx->op_index];
-        redo = false;
-    } while (cur->kind != EcsRuleEnd);
+        v->depth --;
+    }
 
-    return result;
+    v->depth --;
+
+    return 0;
 }
 
-static
-bool flecs_rule_run_block(
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    ecs_rule_ctrl_ctx_t *op_ctx)
+int ecs_script_visit_node_(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *node)
 {
-    ecs_iter_t *it = ctx->it;
-    ecs_rule_iter_t *rit = &it->priv.iter.rule;
+    v->nodes[v->depth ++] = node;
 
-    if (!redo) {
-        op_ctx->op_index = flecs_itolbl(ctx->op_index + 1);
-    } else if (ctx->rit->ops[op_ctx->op_index].kind == EcsRuleEnd) {
-        return false;
+    if (v->visit(v, node)) {
+        return -1;
     }
 
-    ctx->written[ctx->op_index + 1] = ctx->written[ctx->op_index];
+    v->depth --;
 
-    return flecs_rule_run_until(
-        redo, ctx, rit->ops, ctx->op_index, op_ctx->op_index, EcsRuleEnd);
+    return 0;
 }
 
-static
-bool flecs_rule_with_or(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+int ecs_script_visit_(
+    ecs_script_visit_t *visitor,
+    ecs_visit_action_t visit,
+    ecs_script_t *script)
 {
-    ecs_rule_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
-
-    bool result = flecs_rule_run_block(redo, ctx, op_ctx);
+    visitor->script = script;
+    visitor->visit = visit;
+    visitor->depth = 0;
+    int result = ecs_script_visit_node(visitor, script->root);
     if (result) {
-        /* If a match was found, no need to keep searching for this source */
-        op_ctx->op_index = op->next;
+        return -1;
     }
 
-    return result;
-}
-
-static
-bool flecs_rule_or(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    if (op->flags & (EcsRuleIsVar << EcsRuleSrc)) {
-        uint64_t written = ctx->written[ctx->op_index];
-        if (!(written & (1ull << op->src.var))) {
-            return flecs_rule_select_or(op, redo, ctx);
-        }
+    if (visitor->depth) {
+        ecs_parser_error(script->name, NULL, 0, "unexpected end of script");
+        return -1;
     }
 
-    return flecs_rule_with_or(op, redo, ctx);
+    return 0;
 }
 
-static
-bool flecs_rule_run_block_w_reset(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+#endif
+
+/**
+ * @file addons/script/visit_eval.c
+ * @brief Script evaluation visitor.
+ */
+
+
+#ifdef FLECS_SCRIPT
+
+void flecs_script_eval_error_(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node,
+    const char *fmt,
+    ...)
 {
-    ecs_rule_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
-    bool result = flecs_rule_run_block(redo, ctx, op_ctx);
-    if (!result) {
-        flecs_rule_reset_after_block(op, ctx, op_ctx);
+    va_list args;
+    va_start(args, fmt);
+    char *msg = flecs_vasprintf(fmt, args);
+    va_end(args);
+
+    if (node) {
+        int32_t line = ecs_script_node_line_number(v->base.script, node);
+        ecs_parser_error(v->base.script->name, NULL, 0, "%d: %s", line, msg);
+    } else {
+        ecs_parser_error(v->base.script->name, NULL, 0, "%s", msg);
     }
-    return result;
+
+    ecs_os_free(msg);
 }
 
 static
-bool flecs_rule_not(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+ecs_value_t* flecs_script_with_append(
+    ecs_allocator_t *a,
+    ecs_script_eval_visitor_t *v)
 {
-    if (redo) {
-        return false;
+    if (ecs_vec_count(&v->with)) {
+        ecs_assert(ecs_vec_last_t(&v->with, ecs_value_t)->type == 0, 
+            ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(ecs_vec_last_t(&v->with, ecs_value_t)->ptr == NULL, 
+            ECS_INTERNAL_ERROR, NULL);
+        ecs_vec_remove_last(&v->with);
     }
 
-    return !flecs_rule_run_block_w_reset(op, redo, ctx);
+    ecs_vec_append_t(a, &v->with, ecs_value_t);
+    ecs_value_t *last = ecs_vec_append_t(a, &v->with, ecs_value_t);
+    ecs_os_memset_t(last, 0, ecs_value_t);
+    return ecs_vec_get_t(&v->with, ecs_value_t, ecs_vec_count(&v->with) - 2);
 }
 
 static
-bool flecs_rule_optional(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{   
-    bool result = flecs_rule_run_block_w_reset(op, redo, ctx);
-    if (!redo) {
-        return true; /* Return at least once */
+void flecs_script_with_set_count(
+    ecs_allocator_t *a,
+    ecs_script_eval_visitor_t *v,
+    int32_t count)
+{
+    if (count) {
+        ecs_value_t *last = ecs_vec_get_t(&v->with, ecs_value_t, count);
+        ecs_os_memset_t(last, 0, ecs_value_t);
+        ecs_vec_set_count_t(a, &v->with, ecs_value_t, count + 1);
     } else {
-        return result;
+        ecs_vec_set_count_t(a, &v->with, ecs_value_t, 0);
     }
 }
 
 static
-bool flecs_rule_eval_if(
-    const ecs_rule_op_t *op,
-    ecs_rule_run_ctx_t *ctx,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind)
+ecs_value_t* flecs_script_with_last(
+    ecs_script_eval_visitor_t *v)
 {
-    if (flecs_rule_ref_flags(op->flags, ref_kind) == EcsRuleIsVar) {
-        if (ctx->vars[ref->var].entity == EcsWildcard) {
-            ecs_rule_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
-            flecs_rule_reset_after_block(op, ctx, op_ctx);
-            return false;
-        }
+    int32_t count = ecs_vec_count(&v->with);
+    if (count) {
+        return ecs_vec_get_t(&v->with, ecs_value_t, count - 2);
     }
-    return true;
+    return NULL;
 }
 
 static
-bool flecs_rule_if(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+int32_t flecs_script_with_count(
+    ecs_script_eval_visitor_t *v)
 {
-    if (!redo) {
-        if (!flecs_rule_eval_if(op, ctx, &op->src, EcsRuleSrc) ||
-            !flecs_rule_eval_if(op, ctx, &op->first, EcsRuleFirst) ||
-            !flecs_rule_eval_if(op, ctx, &op->second, EcsRuleSecond))
-        {
-            return true;
-        }
+    if (ecs_vec_count(&v->with)) {
+        ecs_assert(ecs_vec_last_t(&v->with, ecs_value_t)->type == 0, 
+            ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(ecs_vec_last_t(&v->with, ecs_value_t)->ptr == NULL, 
+            ECS_INTERNAL_ERROR, NULL);
+        return ecs_vec_count(&v->with) - 1;
     }
-
-    return flecs_rule_run_block_w_reset(op, redo, ctx);
-}
-
-static
-bool flecs_rule_end(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    (void)op; (void)ctx;
-    return !redo;
+    return 0;
 }
 
-static
-bool flecs_rule_populate(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+const ecs_type_info_t* flecs_script_get_type_info(
+    ecs_script_eval_visitor_t *v,
+    void *node,
+    ecs_id_t id)
 {
-    (void)op;
-    if (!redo) {
-        ecs_iter_t *it = ctx->it;
-        if (it->flags & EcsIterNoData) {
-            return true;
-        }
-
-        ECS_BIT_CLEAR(it->flags, EcsIterHasShared);
-
-        const ecs_rule_t *rule = ctx->rule;
-        const ecs_filter_t *filter = &rule->filter;
-        int32_t i, field_count = filter->field_count;
-        ecs_flags64_t data_fields = filter->data_fields;
-        ecs_table_range_t *range = &ctx->vars[0].range;
-        ecs_table_t *table = range->table;
-        if (table && !range->count) {
-            range->count = ecs_table_count(table);
-        }
-
-        for (i = 0; i < field_count; i ++) {
-            if (!(data_fields & (1llu << i))) {
-                continue;
-            }
+    ecs_id_record_t *idr = flecs_id_record_ensure(v->world, id);
+    if (!idr) {
+        goto error;
+    }
 
-            int32_t index = it->columns[i];
-            ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
-            if (!index) {
-                continue;
-            }
-    
-            ecs_entity_t src = it->sources[i];
-            if (!src) {
-                ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-                if (range->count && table->column_map) {
-                    int32_t column = table->column_map[index - 1];
-                    if (column != -1) {
-                        it->ptrs[i] = ECS_ELEM(
-                            table->data.columns[column].data.array,
-                            it->sizes[i],
-                            range->offset);
-                        continue;
-                    }
-                }
-            } else {
-                ecs_record_t *r = flecs_entities_get(ctx->world, src);
-                ecs_table_t *src_table = r->table;
-                if (src_table->column_map) {
-                    int32_t column = src_table->column_map[index - 1];
-                    if (column != -1) {
-                        it->ptrs[i] = ecs_vec_get(
-                            &src_table->data.columns[column].data,
-                            it->sizes[i],
-                            ECS_RECORD_TO_ROW(r->row));
-                        ECS_BIT_SET(it->flags, EcsIterHasShared);
-                        continue;
-                    }
-                }
-            }
-        }
+    if (!idr->type_info) {
+        goto error;
+    }
 
-        return true;
-    } else {
-        return false;
+    return idr->type_info;
+error:
+    {
+        char *idstr = ecs_id_str(v->world, id);
+        flecs_script_eval_error(v, node, 
+            "cannot set value of '%s': not a component", idstr);
+        ecs_os_free(idstr);
     }
+    return NULL;
 }
 
-static
-bool flecs_rule_populate_self(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+ecs_entity_t flecs_script_find_entity(
+    ecs_script_eval_visitor_t *v,
+    ecs_entity_t from,
+    const char *path)
 {
-    (void)op;
-    if (!redo) {
-        const ecs_rule_t *rule = ctx->rule;
-        const ecs_filter_t *filter = &rule->filter;
-        int32_t i, field_count = filter->field_count;
-        ecs_flags64_t data_fields = filter->data_fields;
-        ecs_iter_t *it = ctx->it;
+    if (!path) {
+        return 0;
+    }
 
-        ecs_table_range_t *range = &ctx->vars[0].range;
-        ecs_table_t *table = range->table;
-        if (!table->column_map) {
-            return true;
+    if (path[0] == '$') {
+        const ecs_script_var_t *var = ecs_script_vars_lookup(v->vars, &path[1]);
+        if (!var) {
+            return 0;
         }
 
-        if (!ecs_table_count(table)) {
-            return true;
+        if (var->value.type != ecs_id(ecs_entity_t)) {
+            char *type_str = ecs_id_str(v->world, var->value.type);
+            flecs_script_eval_error(v, NULL, 
+                "variable '%s' must be of type entity, got '%s'", 
+                    path, type_str);
+            ecs_os_free(type_str);
+            return 0;
         }
 
-        for (i = 0; i < field_count; i ++) {
-            if (!(data_fields & (1llu << i))) {
-                continue;
-            }
+        if (var->value.ptr == NULL) {
+            flecs_script_eval_error(v, NULL, 
+                "variable '%s' is not initialized", path);
+            return 0;
+        }
 
-            int32_t index = it->columns[i];
-            ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL); /* Only owned */
-            if (!index) {
-                continue;
-            }
+        ecs_entity_t result = *(ecs_entity_t*)var->value.ptr;
+        if (!result) {
+            flecs_script_eval_error(v, NULL, 
+                "variable '%s' contains invalid entity id (0)", path);
+            return 0;
+        }
 
-            int32_t column = table->column_map[index - 1];
-            if (column != -1) {
-                it->ptrs[i] = ECS_ELEM(
-                    table->data.columns[column].data.array,
-                    it->sizes[i],
-                    range->offset);
+        return result;
+    }
+
+    if (from) {
+        return ecs_lookup_path_w_sep(v->world, from, path, NULL, NULL, false);
+    } else {
+        int32_t i, using_count = ecs_vec_count(&v->using);
+        if (using_count) {
+            ecs_entity_t *using = ecs_vec_first(&v->using);
+            for (i = using_count - 1; i >= 0; i --) {
+                ecs_entity_t e = ecs_lookup_path_w_sep(
+                    v->world, using[i], path, NULL, NULL, false);
+                if (e) {
+                    return e;
+                }
             }
         }
 
-        return true;
-    } else {
-        return false;
+        return ecs_lookup_path_w_sep(
+            v->world, v->parent, path, NULL, NULL, true);
     }
 }
 
-static
-bool flecs_rule_dispatch(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
+ecs_entity_t flecs_script_create_entity(
+    ecs_script_eval_visitor_t *v,
+    const char *name)
 {
-    switch(op->kind) {
-    case EcsRuleAnd: return flecs_rule_and(op, redo, ctx);
-    case EcsRuleAndId: return flecs_rule_and_id(op, redo, ctx);
-    case EcsRuleAndAny: return flecs_rule_and_any(op, redo, ctx);
-    case EcsRuleTriv: return flecs_rule_triv(op, redo, ctx);
-    case EcsRuleTrivData: return flecs_rule_triv_data(op, redo, ctx);
-    case EcsRuleTrivWildcard: return flecs_rule_triv_wildcard(op, redo, ctx);
-    case EcsRuleSelectAny: return flecs_rule_select_any(op, redo, ctx);
-    case EcsRuleUp: return flecs_rule_up(op, redo, ctx);
-    case EcsRuleUpId: return flecs_rule_up_id(op, redo, ctx);
-    case EcsRuleSelfUp: return flecs_rule_self_up(op, redo, ctx);
-    case EcsRuleSelfUpId: return flecs_rule_self_up_id(op, redo, ctx);
-    case EcsRuleWith: return flecs_rule_with(op, redo, ctx);
-    case EcsRuleTrav: return flecs_rule_trav(op, redo, ctx);
-    case EcsRuleIds: return flecs_rule_ids(op, redo, ctx);
-    case EcsRuleIdsRight: return flecs_rule_idsright(op, redo, ctx);
-    case EcsRuleIdsLeft: return flecs_rule_idsleft(op, redo, ctx);
-    case EcsRuleEach: return flecs_rule_each(op, redo, ctx);
-    case EcsRuleStore: return flecs_rule_store(op, redo, ctx);
-    case EcsRuleReset: return flecs_rule_reset(op, redo, ctx);
-    case EcsRuleOr: return flecs_rule_or(op, redo, ctx);
-    case EcsRuleOptional: return flecs_rule_optional(op, redo, ctx);
-    case EcsRuleIf: return flecs_rule_if(op, redo, ctx);
-    case EcsRuleEnd: return flecs_rule_end(op, redo, ctx);
-    case EcsRuleNot: return flecs_rule_not(op, redo, ctx);
-    case EcsRulePredEq: return flecs_rule_pred_eq(op, redo, ctx);
-    case EcsRulePredNeq: return flecs_rule_pred_neq(op, redo, ctx);
-    case EcsRulePredEqName: return flecs_rule_pred_eq_name(op, redo, ctx);
-    case EcsRulePredNeqName: return flecs_rule_pred_neq_name(op, redo, ctx);
-    case EcsRulePredEqMatch: return flecs_rule_pred_eq_match(op, redo, ctx);
-    case EcsRulePredNeqMatch: return flecs_rule_pred_neq_match(op, redo, ctx);
-    case EcsRuleLookup: return flecs_rule_lookup(op, redo, ctx);
-    case EcsRuleSetVars: return flecs_rule_setvars(op, redo, ctx);
-    case EcsRuleSetThis: return flecs_rule_setthis(op, redo, ctx);
-    case EcsRuleSetFixed: return flecs_rule_setfixed(op, redo, ctx);
-    case EcsRuleSetIds: return flecs_rule_setids(op, redo, ctx);
-    case EcsRuleSetId: return flecs_rule_setid(op, redo, ctx);
-    case EcsRuleContain: return flecs_rule_contain(op, redo, ctx);
-    case EcsRulePairEq: return flecs_rule_pair_eq(op, redo, ctx);
-    case EcsRulePopulate: return flecs_rule_populate(op, redo, ctx);
-    case EcsRulePopulateSelf: return flecs_rule_populate_self(op, redo, ctx);
-    case EcsRuleYield: return false;
-    case EcsRuleNothing: return false;
+    ecs_value_t *with = NULL;
+    if (flecs_script_with_count(v)) {
+        with = ecs_vec_first_t(&v->with, ecs_value_t);
     }
-    return false;
-}
-
-static
-bool flecs_rule_run_until(
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    const ecs_rule_op_t *ops,
-    ecs_rule_lbl_t first,
-    ecs_rule_lbl_t cur,
-    ecs_rule_op_kind_t until)
-{
-    ecs_assert(first >= -1, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(cur >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(cur > first, ECS_INTERNAL_ERROR, NULL);
-
-    ctx->op_index = cur;
-    const ecs_rule_op_t *op = &ops[ctx->op_index];
-    ecs_assert(op->kind != until, ECS_INTERNAL_ERROR, NULL);
-
-    do {
-        #ifdef FLECS_DEBUG
-        ctx->rit->profile[ctx->op_index].count[redo] ++;
-        #endif
-
-        bool result = flecs_rule_dispatch(op, redo, ctx);
-        cur = (&op->prev)[result];
-        redo = cur < ctx->op_index;
-
-        if (!redo) {
-            ctx->written[cur] |= ctx->written[ctx->op_index] | op->written;
-        }
-
-        ctx->op_index = cur;
-        op = &ops[ctx->op_index];
 
-        if (cur <= first) {
-            return false;
-        }
-        if (op->kind == until) {
-            return true;
-        }
-    } while (true);
+    if (name || with) {
+        ecs_entity_desc_t desc = {0};
+        desc.name = name;
+        desc.parent = v->parent;
+        desc.set = with;
+        return ecs_entity_init(v->world, &desc);
+    } else if (v->parent) {
+        return ecs_new_w_pair(v->world, EcsChildOf, v->parent);
+    } else {
+        return ecs_new(v->world);
+    }
 }
 
 static
-void flecs_rule_iter_init(
-    ecs_rule_run_ctx_t *ctx)
+ecs_entity_t flecs_script_find_entity_action(
+    const ecs_world_t *world,
+    const char *path,
+    void *ctx)
 {
-    ecs_assert(ctx->written != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_iter_t *it = ctx->it;
-
-    const ecs_rule_t *rule = ctx->rule;
-    ecs_flags64_t it_written = it->constrained_vars;
-    ctx->written[0] = it_written;
-    if (it_written && ctx->rule->src_vars) {
-        /* If variables were constrained, check if there are any table
-         * variables that have a constrained entity variable. */
-        ecs_var_t *vars = ctx->vars;
-        int32_t i, count = rule->filter.field_count;
-        for (i = 0; i < count; i ++) {
-            ecs_var_id_t var_id = rule->src_vars[i];
-            ecs_rule_var_t *var = &rule->vars[var_id];
-
-            if (!(it_written & (1ull << var_id)) || 
-                (var->kind == EcsVarTable) || (var->table_id == EcsVarNone)) 
-            {
-                continue;
-            }
-
-            /* Initialize table variable with constrained entity variable */
-            ecs_var_t *tvar = &vars[var->table_id];
-            tvar->range = flecs_range_from_entity(vars[var_id].entity, ctx);
-            ctx->written[0] |= (1ull << var->table_id); /* Mark as written */
-        }
-    }
-
-    ecs_flags32_t flags = rule->filter.flags;
-    if (flags & EcsFilterIsTrivial) {
-        if ((flags & EcsFilterMatchOnlySelf) || 
-            !flecs_table_cache_count(&ctx->world->idr_isa_wildcard->cache)) 
-        {
-            if (it_written) {
-                it->offset = ctx->vars[0].range.offset;
-                it->count = ctx->vars[0].range.count;
-                if (!it->count) {
-                    ecs_assert(!it->offset, ECS_INVALID_PARAMETER, NULL);
-                    it->count = ecs_table_count(ctx->vars[0].range.table);
-                }
-
-                it->flags |= EcsIterTrivialTest;
-                flecs_rule_setids(&rule->ops[0], false, ctx);
-            } else {
-                if (flags & EcsFilterHasWildcards) {
-                    it->flags |= EcsIterTrivialSearchWildcard;
-                    flecs_rule_setids(&rule->ops[0], false, ctx);
-                } else if (flags & EcsFilterNoData) {
-                    it->flags |= EcsIterTrivialSearchNoData;
-                    flecs_rule_setids(&rule->ops[0], false, ctx);
-                } else {
-                    it->flags |= EcsIterTrivialSearch;
-                    flecs_rule_setids(&rule->ops[0], false, ctx);
-                }
-            }
-        }
-    }
-
-    flecs_iter_validate(it);
+    (void)world;
+    ecs_script_eval_visitor_t *v = ctx;
+    return flecs_script_find_entity(v, 0, path);
 }
 
-bool ecs_rule_next_instanced(
-    ecs_iter_t *it)
+static
+int flecs_script_eval_id(
+    ecs_script_eval_visitor_t *v,
+    void *node,
+    ecs_script_id_t *id)
 {
-    ecs_assert(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(it->next == ecs_rule_next, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_rule_iter_t *rit = &it->priv.iter.rule;
-    ecs_rule_run_ctx_t ctx;
-    ctx.world = it->real_world;
-    ctx.rule = rit->rule;
-    ctx.it = it;
-    ctx.vars = rit->vars;
-    ctx.rule_vars = rit->rule_vars;
-    ctx.written = rit->written;
-    ctx.op_ctx = rit->op_ctx;
-    ctx.source_set = &rit->source_set;
-    ctx.rit = rit;
-    const ecs_rule_op_t *ops = rit->ops;
+    ecs_entity_t second_from = 0;
 
-    bool redo = true;
-    if (!(it->flags & EcsIterIsValid)) {
-        ecs_assert(ctx.rule != NULL, ECS_INVALID_PARAMETER, NULL);
-        flecs_rule_iter_init(&ctx);
-        redo = false;
-    } else {
-        it->frame_offset += it->count;
+    if (!id->first) {
+        flecs_script_eval_error(v, node, 
+            "invalid component/tag identifier");
+        return -1;
     }
 
-    /* Specialized iterator modes for trivial queries */
-    if (it->flags & EcsIterTrivialSearch) {
-        ecs_rule_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
-        int32_t fields = ctx.rule->filter.term_count;
-        if (!flecs_rule_trivial_search(ctx.rule, &ctx, op_ctx, !redo, fields)) {
-            goto done;
+    if (v->assembly) {
+        /* Can't resolve variables while preprocessing assembly scope */
+        if (id->first[0] == '$') {
+            return 0;
         }
-        it->table = ctx.vars[0].range.table;
-        it->count = ecs_table_count(it->table);
-        it->entities = flecs_table_entities_array(it->table);
-        return true;
-    } else if (it->flags & EcsIterTrivialSearchNoData) {
-        ecs_rule_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
-        int32_t fields = ctx.rule->filter.term_count;
-        if (!flecs_rule_trivial_search_nodata(ctx.rule, &ctx, op_ctx, !redo, fields)) {
-            goto done;
+        if (id->second && id->second[0] == '$') {
+            return 0;
         }
-        it->table = ctx.vars[0].range.table;
-        it->count = ecs_table_count(it->table);
-        it->entities = flecs_table_entities_array(it->table);
-        return true;
-    } else if (it->flags & EcsIterTrivialTest) {
-        int32_t fields = ctx.rule->filter.term_count;
-        if (!flecs_rule_trivial_test(ctx.rule, &ctx, !redo, fields)) {
-            goto done;
+    }
+
+    ecs_entity_t first = flecs_script_find_entity(v, 0, id->first);
+    if (!first) {
+        if (id->first[0] == '$') {
+            flecs_script_eval_error(v, node, 
+                "unresolved variable '%s'", id->first);
+            return -1;
         }
-        return true;
-    } else if (it->flags & EcsIterTrivialSearchWildcard) {
-        ecs_rule_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
-        int32_t fields = ctx.rule->filter.term_count;
-        if (!flecs_rule_trivial_search_w_wildcards(ctx.rule, &ctx, op_ctx, !redo, fields)) {
-            goto done;
+
+        /* Tags/components must be created in advance for assemblies */
+        if (v->assembly) {
+            flecs_script_eval_error(v, node, 
+                "'%s' must be defined outside of assembly scope", id->first);
+            return -1;
         }
-        it->table = ctx.vars[0].range.table;
-        it->count = ecs_table_count(it->table);
-        it->entities = flecs_table_entities_array(it->table);
-        return true;
+
+        first = ecs_entity(v->world, {
+            .name = id->first,
+            .parent = v->module,
+        });
+        
+        if (!first) {
+            return -1;
+        }
+    } else if (id->second) {
+        second_from = flecs_get_oneof(v->world, first);
     }
 
-    /* Default iterator mode */
-    if (flecs_rule_run_until(redo, &ctx, ops, -1, rit->op, EcsRuleYield)) {
-        ecs_assert(ops[ctx.op_index].kind == EcsRuleYield, 
-            ECS_INTERNAL_ERROR, NULL);
-        ecs_table_range_t *range = &ctx.vars[0].range;
-        ecs_table_t *table = range->table;
-        int32_t count = range->count;
-        if (table) {
-            if (!count) {
-                count = ecs_table_count(table);
+    if (id->second) {
+        ecs_entity_t second = flecs_script_find_entity(
+            v, second_from, id->second);
+        if (!second) {
+            if (id->second[0] == '$') {
+                flecs_script_eval_error(v, node, 
+                    "unresolved variable '%s'", id->second);
+                return -1;
+            }
+
+            /* Tags/components must be created in advance for assemblies */
+            if (v->assembly) {
+                flecs_script_eval_error(v, node, 
+                    "'%s' must be defined outside of assembly scope", 
+                        id->second);
+                return -1;
+            }
+
+            if (second_from) {
+                char *parent_str = ecs_id_str(v->world, second_from);
+                flecs_script_eval_error(v, node, "target '%s' not found in "
+                    "parent '%s'", id->second, parent_str);
+                ecs_os_free(parent_str);
+                return -1;
+            }
+
+            second = ecs_entity(v->world, {
+                .name = id->second,
+                .parent = v->module,
+            });
+
+            if (!second) {
+                return -1;
             }
-            it->table = table;
-            it->offset = range->offset;
-            it->count = count;
-            it->entities = ECS_ELEM_T(
-                table->data.entities.array, ecs_entity_t, it->offset);
-        } else if (count == 1) {
-            it->count = 1;
-            it->entities = &ctx.vars[0].entity;
         }
 
-        rit->op = flecs_itolbl(ctx.op_index - 1);
-        return true;
+        id->eval = ecs_pair(first, second);
+    } else {
+        id->eval = first;
     }
 
-done:
-    ecs_iter_fini(it);
-    return false;
+    return 0;
 }
 
-bool ecs_rule_next(
-    ecs_iter_t *it)
+int flecs_script_eval_expr(
+    ecs_script_eval_visitor_t *v,
+    const char *expr,
+    ecs_value_t *value)
 {
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_rule_next, ECS_INVALID_PARAMETER, NULL);
+    if (!value->type && expr[0] == '{') {
+        expr ++;
+    }
 
-    if (flecs_iter_next_row(it)) {
-        return true;
+    ecs_script_expr_run_desc_t desc = {
+        .name = v->base.script->name,
+        .expr = expr,
+        .lookup_action = flecs_script_find_entity_action,
+        .lookup_ctx = v,
+        .vars = v->vars
+    };
+
+    if (!ecs_script_expr_run(v->world, expr, value, &desc)) {
+        return -1;
     }
 
-    return flecs_iter_next_instanced(it, ecs_rule_next_instanced(it));
-error:
-    return false;
+    return 0;
 }
 
 static
-void flecs_rule_iter_fini_ctx(
-    ecs_iter_t *it,
-    ecs_rule_iter_t *rit)
+int flecs_script_eval_scope(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_scope_t *node)
 {
-    const ecs_rule_t *rule = rit->rule;
-    int32_t i, count = rule->op_count;
-    ecs_rule_op_t *ops = rule->ops;
-    ecs_rule_op_ctx_t *ctx = rit->op_ctx;
-    ecs_allocator_t *a = flecs_rule_get_allocator(it);
+    ecs_script_node_t *scope_parent = ecs_script_parent_node(v);
+    ecs_entity_t prev_eval_parent = v->parent;
+    int32_t prev_using_count = ecs_vec_count(&v->using);
 
-    for (i = 0; i < count; i ++) {
-        ecs_rule_op_t *op = &ops[i];
-        switch(op->kind) {
-        case EcsRuleTrav:
-            flecs_rule_trav_cache_fini(a, &ctx[i].is.trav.cache);
-            break;
-        case EcsRuleUp:
-        case EcsRuleSelfUp:
-        case EcsRuleUpId:
-        case EcsRuleSelfUpId: {
-            ecs_trav_up_cache_t *cache = &ctx[i].is.up.cache;
-            if (cache->dir == EcsDown) {
-                flecs_rule_down_cache_fini(a, cache);
-            } else {
-                flecs_rule_up_cache_fini(cache);
-            }
-            break;
-        }
-        default:
+    for (int i = v->base.depth - 2; i >= 0; i --) {
+        if (v->base.nodes[i]->kind == EcsAstScope) {
+            node->parent = (ecs_script_scope_t*)v->base.nodes[i];
             break;
         }
     }
-}
 
-static
-void flecs_rule_iter_fini(
-    ecs_iter_t *it)
-{
-    ecs_rule_iter_t *rit = &it->priv.iter.rule;
-    ecs_assert(rit->rule != NULL, ECS_INVALID_OPERATION, NULL);
-    ecs_poly_assert(rit->rule, ecs_rule_t);
-    int32_t op_count = rit->rule->op_count;
-    int32_t var_count = rit->rule->var_count;
+    ecs_allocator_t *a = v->allocator;
+    v->vars = flecs_script_vars_push(v->vars, &v->stack, a);
 
-#ifdef FLECS_DEBUG
-    if (it->flags & EcsIterProfile) {
-        char *str = ecs_rule_str_w_profile(rit->rule, it);
-        printf("%s\n", str);
-        ecs_os_free(str);
+    if (scope_parent && (scope_parent->kind == EcsAstEntity)) {
+        v->parent = ecs_script_node(entity, scope_parent)->eval;
     }
 
-    flecs_iter_free_n(rit->profile, ecs_rule_op_profile_t, op_count);
-#endif
+    int result = ecs_script_visit_scope(v, node);
 
-    flecs_rule_iter_fini_ctx(it, rit);
-    flecs_iter_free_n(rit->vars, ecs_var_t, var_count);
-    flecs_iter_free_n(rit->written, ecs_write_flags_t, op_count);
-    flecs_iter_free_n(rit->op_ctx, ecs_rule_op_ctx_t, op_count);
-    rit->vars = NULL;
-    rit->written = NULL;
-    rit->op_ctx = NULL;
-    rit->rule = NULL;
+    ecs_vec_set_count_t(a, &v->using, ecs_entity_t, prev_using_count);
+    v->vars = ecs_script_vars_pop(v->vars);
+    v->parent = prev_eval_parent;
+
+    return result;
 }
 
-ecs_iter_t ecs_rule_iter(
-    const ecs_world_t *world,
-    const ecs_rule_t *rule)
+static
+int flecs_script_apply_annot(
+    ecs_script_eval_visitor_t *v,
+    ecs_entity_t entity,
+    ecs_script_annot_t *node)
 {
-    ecs_iter_t it = {0};
-    ecs_rule_iter_t *rit = &it.priv.iter.rule;
-    ecs_check(rule != NULL, ECS_INVALID_PARAMETER, NULL);
+    if (!ecs_os_strcmp(node->name, "name")) {
+        ecs_doc_set_name(v->world, entity, node->expr);
+    } else
+    if (!ecs_os_strcmp(node->name, "brief")) {
+        ecs_doc_set_brief(v->world, entity, node->expr);
+    } else 
+    if (!ecs_os_strcmp(node->name, "detail")) {
+        ecs_doc_set_detail(v->world, entity, node->expr);
+    } else
+    if (!ecs_os_strcmp(node->name, "link")) {
+        ecs_doc_set_link(v->world, entity, node->expr);
+    } else
+    if (!ecs_os_strcmp(node->name, "color")) {
+        ecs_doc_set_color(v->world, entity, node->expr);
+    } else {
+        flecs_script_eval_error(v, node, "unknown annotation '%s'",
+            node->name);
+        return -1;
+    }
+    
+    return 0;
+}
 
-    // Ok, only for stats
-    ECS_CONST_CAST(ecs_rule_t*, rule)->filter.eval_count ++;
+static
+int flecs_script_eval_entity(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_entity_t *node)
+{
+    /* Inherit kind from parent kind's DefaultChildComponent, if it existst */
+    if (node->kind) {
+        ecs_script_id_t id = {
+            .first = node->kind
+        };
 
-    ecs_run_aperiodic(rule->filter.world, EcsAperiodicEmptyTables);
+        if (flecs_script_eval_id(v, node, &id)) {
+            return -1;
+        }
 
-    int32_t i, var_count = rule->var_count, op_count = rule->op_count;
-    it.world = ECS_CONST_CAST(ecs_world_t*, world);
-    it.real_world = rule->filter.world;
-    it.query = &rule->filter;
-    it.terms = rule->filter.terms;
-    it.next = ecs_rule_next;
-    it.fini = flecs_rule_iter_fini;
-    it.field_count = rule->filter.field_count;
-    it.sizes = rule->filter.sizes;
-    it.system = rule->filter.entity;
-    flecs_filter_apply_iter_flags(&it, &rule->filter);
+        node->eval_kind = id.eval;
+    } else {
+        ecs_script_scope_t *scope = ecs_script_current_scope(v);
+        if (scope && scope->default_component_eval) {
+            node->eval_kind = scope->default_component_eval;
+        }
+    }
 
-    flecs_iter_init(world, &it, 
-        flecs_iter_cache_ids |
-        flecs_iter_cache_columns |
-        flecs_iter_cache_sources |
-        flecs_iter_cache_ptrs);
+    if (v->assembly) {
+        return 0;
+    }
 
-    rit->rule = rule;
-    rit->rule_vars = rule->vars;
-    rit->ops = rule->ops;
-    rit->source_set = 0;
-    if (var_count) {
-        rit->vars = flecs_iter_calloc_n(&it, ecs_var_t, var_count);
+    node->eval = flecs_script_create_entity(v, node->name);
+    node->parent = v->entity;
+
+    const EcsDefaultChildComponent *default_comp = NULL;
+    ecs_script_entity_t *old_entity = v->entity;
+    v->entity = node;
+
+    if (node->eval_kind) {
+        ecs_add_id(v->world, node->eval, node->eval_kind);
+
+        default_comp = 
+            ecs_get(v->world, node->eval_kind, EcsDefaultChildComponent);
+        if (default_comp) {
+            if (!default_comp->component) {
+                flecs_script_eval_error(v, node, "entity '%s' has kind '%s' "
+                    "with uninitialized DefaultChildComponent",
+                        node->name, node->kind);
+                return -1;
+            }
+
+            node->scope->default_component_eval = default_comp->component;
+        }
     }
-    if (op_count) {
-        rit->written = flecs_iter_calloc_n(&it, ecs_write_flags_t, op_count);
-        rit->op_ctx = flecs_iter_calloc_n(&it, ecs_rule_op_ctx_t, op_count);
+
+    int32_t i, count = ecs_vec_count(&v->annot);
+    if (count) {
+        ecs_script_annot_t **annots = ecs_vec_first(&v->annot);
+        for (i = 0; i < count ; i ++) {
+            flecs_script_apply_annot(v, node->eval, annots[i]);
+        }
+        ecs_vec_clear(&v->annot);
     }
 
-#ifdef FLECS_DEBUG
-    rit->profile = flecs_iter_calloc_n(&it, ecs_rule_op_profile_t, op_count);
-#endif
+    if (ecs_script_visit_node(v, node->scope)) {
+        return -1;
+    }
 
-    for (i = 1; i < var_count; i ++) {
-        rit->vars[i].entity = EcsWildcard;
+    if (node->eval_kind) {
+        if (!node->kind_w_expr) {
+            if (ecs_get_type_info(v->world, node->eval_kind) != NULL) {
+                ecs_modified_id(v->world, node->eval, node->eval_kind);
+            }
+        }
     }
 
-    it.variables = rit->vars;
-    it.variable_count = rule->var_pub_count;
-    it.variable_names = rule->var_names;
+    v->entity = old_entity;
 
-error:
-    return it;
+    return 0;
 }
 
-#endif
+static
+ecs_entity_t flecs_script_get_src(
+    ecs_script_eval_visitor_t *v,
+    ecs_entity_t entity,
+    ecs_id_t id)
+{
+    if (entity == EcsVariable) { // Singleton ($)
+        if (ECS_IS_PAIR(id)) {
+            return ecs_pair_first(v->world, id);
+        } else {
+            return id & ECS_COMPONENT_MASK;
+        }
+    }
+    return entity;
+}
 
-/**
- * @file addons/rules/trav_cache.c
- * @brief Cache that stores the result of graph traversal.
- */
+static
+int flecs_script_eval_tag(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_tag_t *node)
+{
+    if (flecs_script_eval_id(v, node, &node->id)) {
+        return -1;
+    }
 
+    if (v->assembly) {
+        return 0;
+    }
 
-#ifdef FLECS_RULES
+    if (!v->entity) {
+        if (node->id.second) {
+            flecs_script_eval_error(
+                v, node, "missing entity for pair (%s, %s)",
+                node->id.first, node->id.second);
+        } else {
+            flecs_script_eval_error(v, node, "missing entity for tag %s", 
+                node->id.first);
+        }
+        return -1;
+    }
+
+    ecs_entity_t src = flecs_script_get_src(
+        v, v->entity->eval, node->id.eval);
+    ecs_add_id(v->world, src, node->id.eval);
+
+    return 0;
+}
 
 static
-void flecs_rule_build_down_cache(
-    ecs_world_t *world,
-    ecs_allocator_t *a,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_entity_t entity)
+int flecs_script_eval_component(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_component_t *node)
 {
-    ecs_id_record_t *idr = flecs_id_record_get(world, ecs_pair(trav, entity));
-    if (!idr) {
-        return;
+    if (flecs_script_eval_id(v, node, &node->id)) {
+        return -1;
     }
 
-    ecs_trav_elem_t *elem = ecs_vec_append_t(a, &cache->entities, 
-        ecs_trav_elem_t);
-    elem->entity = entity;
-    elem->idr = idr;
+    if (v->assembly) {
+        return 0;
+    }
 
-    ecs_table_cache_iter_t it;
-    if (flecs_table_cache_iter(&idr->cache, &it)) {
-        ecs_table_record_t *tr; 
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            ecs_assert(tr->count == 1, ECS_INTERNAL_ERROR, NULL);
-            ecs_table_t *table = tr->hdr.table;
-            if (!table->_->traversable_count) {
-                continue;
+    if (!v->entity) {
+        if (node->id.second) {
+            flecs_script_eval_error(v, node, "missing entity for pair (%s, %s)",
+                node->id.first, node->id.second);
+        } else {
+            flecs_script_eval_error(v, node, "missing entity for component %s", 
+                node->id.first);
+        }
+        return -1;
+    }
+
+    ecs_entity_t src = flecs_script_get_src(v, v->entity->eval, node->id.eval);
+
+    if (node->expr && node->expr[0]) {
+        const ecs_type_info_t *ti = flecs_script_get_type_info(
+            v, node, node->id.eval);
+        if (!ti) {
+            return -1;
+        }
+
+        const EcsType *type = ecs_get(v->world, ti->component, EcsType);
+        if (type) {
+            bool is_collection = false;
+
+            switch(type->kind) {
+            case EcsPrimitiveType:
+            case EcsBitmaskType:
+            case EcsEnumType:
+            case EcsStructType:
+            case EcsOpaqueType:
+                break;
+            case EcsArrayType:
+            case EcsVectorType:
+                is_collection = true;
+                break;
             }
 
-            int32_t i, count = ecs_table_count(table);
-            ecs_entity_t *entities = table->data.entities.array;
-            for (i = 0; i < count; i ++) {
-                ecs_record_t *r = flecs_entities_get(world, entities[i]);
-                if (r->row & EcsEntityIsTraversable) {
-                    flecs_rule_build_down_cache(
-                        world, a, ctx, cache, trav, entities[i]);
+            if (node->is_collection != is_collection) {
+                char *id_str = ecs_id_str(v->world, ti->component);
+                if (node->is_collection && !is_collection) {
+                    flecs_script_eval_error(v, node, 
+                        "type %s is not a collection (use '%s: {...}')", 
+                            id_str, id_str);
+                } else {
+                    flecs_script_eval_error(v, node, 
+                        "type %s is a collection (use '%s: [...]')", 
+                            id_str, id_str);
                 }
+                ecs_os_free(id_str);
+                return -1;
+            }
+        }
+ 
+        ecs_value_t value = {
+            .ptr = ecs_ensure_id(v->world, src, node->id.eval),
+            .type = ti->component
+        };
+
+        if (ecs_os_strcmp(node->expr, "{}")) {
+            if (flecs_script_eval_expr(v, node->expr, &value)) {
+                return -1;
             }
         }
+
+        ecs_modified_id(v->world, src, node->id.eval);
+    } else {
+        ecs_add_id(v->world, src, node->id.eval);
     }
+
+    return 0;
 }
 
 static
-void flecs_rule_build_up_cache(
-    ecs_world_t *world,
-    ecs_allocator_t *a,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_table_t *table,
-    const ecs_table_record_t *tr,
-    int32_t root_column)
+int flecs_script_eval_var_component(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_var_component_t *node)
 {
-    ecs_id_t *ids = table->type.array;
-    int32_t i = tr->index, end = i + tr->count;
-    bool is_root = root_column == -1;
+    ecs_script_var_t *var = ecs_script_vars_lookup(v->vars, node->name);
+    if (!var) {
+        flecs_script_eval_error(v, node, 
+            "unresolved variable '%s'", node->name);
+        return -1;
+    }
 
-    for (; i < end; i ++) {
-        ecs_entity_t second = ecs_pair_second(world, ids[i]);
-        if (is_root) {
-            root_column = i;
+    ecs_id_t var_id = var->value.type;
+
+    if (var->value.ptr) {
+        const ecs_type_info_t *ti = flecs_script_get_type_info(
+            v, node, var_id);
+        if (!ti) {
+            return -1;
         }
 
-        ecs_trav_elem_t *el = ecs_vec_append_t(a, &cache->entities, 
-            ecs_trav_elem_t);
-        el->entity = second;
-        el->column = root_column;
-        el->idr = NULL;
+        ecs_value_t value = {
+            .ptr = ecs_ensure_id(v->world, v->entity->eval, var_id),
+            .type = var_id
+        };
 
-        ecs_record_t *r = flecs_entities_get_any(world, second);
-        if (r->table) {
-            ecs_table_record_t *r_tr = flecs_id_record_get_table(
-                cache->idr, r->table);
-            if (!r_tr) {
-                return;
-            }
-            flecs_rule_build_up_cache(world, a, ctx, cache, trav, r->table, 
-                r_tr, root_column);
-        }
+        ecs_value_copy_w_type_info(v->world, ti, value.ptr, var->value.ptr);
+
+        ecs_modified_id(v->world, v->entity->eval, var_id);
+    } else {
+        ecs_add_id(v->world, v->entity->eval, var_id);
     }
-}
 
-void flecs_rule_trav_cache_fini(
-    ecs_allocator_t *a,
-    ecs_trav_cache_t *cache)
-{
-    ecs_vec_fini_t(a, &cache->entities, ecs_trav_elem_t);
+    return 0;
 }
 
-void flecs_rule_get_trav_down_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_entity_t entity)
+static
+int flecs_script_eval_default_component(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_default_component_t *node)
 {
-    if (cache->id != ecs_pair(trav, entity) || cache->up) {
-        ecs_world_t *world = ctx->it->real_world;
-        ecs_allocator_t *a = flecs_rule_get_allocator(ctx->it);
-        ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
-        flecs_rule_build_down_cache(world, a, ctx, cache, trav, entity);
-        cache->id = ecs_pair(trav, entity);
-        cache->up = false;
+    if (!v->entity) {
+        flecs_script_eval_error(v, node, 
+            "missing entity for default component");
+        return -1;
     }
-}
 
-void flecs_rule_get_trav_up_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_table_t *table)
-{
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_world_t *world = ctx->it->real_world;
-    ecs_allocator_t *a = flecs_rule_get_allocator(ctx->it);
+    ecs_script_scope_t *scope = ecs_script_current_scope(v);
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(scope->node.kind == EcsAstScope, ECS_INTERNAL_ERROR, NULL);
+    scope = scope->parent;
 
-    ecs_id_record_t *idr = cache->idr;
-    if (!idr || idr->id != ecs_pair(trav, EcsWildcard)) {
-        idr = cache->idr = flecs_id_record_get(world, 
-            ecs_pair(trav, EcsWildcard));
-        if (!idr) {
-            ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
-            return;
-        }
+    if (!scope) {
+        flecs_script_eval_error(v, node,
+            "entity '%s' is in root scope which cannot have a default type",
+                v->entity->name); 
+        return -1;
     }
 
-    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-    if (!tr) {
-        ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
-        return;
+    ecs_id_t default_type = scope->default_component_eval;
+    if (!default_type) {
+        flecs_script_eval_error(v, node,
+            "scope for entity '%s' does not have a default type",
+                v->entity->name);
+        return -1;
     }
 
-    ecs_id_t id = table->type.array[tr->index];
-
-    if (cache->id != id || !cache->up) {
-        ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
-        flecs_rule_build_up_cache(world, a, ctx, cache, trav, table, tr, -1);
-        cache->id = id;
-        cache->up = true;
+    if (ecs_get_type_info(v->world, default_type) == NULL) {
+        char *id_str = ecs_id_str(v->world, default_type);
+        flecs_script_eval_error(v, node,
+            "cannot use tag '%s' as default type in assignment",
+                id_str);
+        ecs_os_free(id_str);
+        return -1;
     }
-}
 
-#endif
+    ecs_value_t value = {
+        .ptr = ecs_ensure_id(v->world, v->entity->eval, default_type),
+        .type = default_type
+    };
 
+    if (flecs_script_eval_expr(v, node->expr, &value)) {
+        return -1;
+    }
 
-#ifdef FLECS_RULES
+    ecs_modified_id(v->world, v->entity->eval, default_type);
 
-static
-void flecs_trav_entity_down_isa(
-    ecs_world_t *world,
-    ecs_allocator_t *a,
-    ecs_trav_up_cache_t *cache,
-    ecs_trav_down_t *dst,
-    ecs_entity_t trav,
-    ecs_entity_t entity,
-    ecs_id_record_t *idr_with,
-    bool self);
+    return 0;
+}
 
 static
-ecs_trav_down_t* flecs_trav_entity_down(
-    ecs_world_t *world,
-    ecs_allocator_t *a,
-    ecs_trav_up_cache_t *cache,
-    ecs_trav_down_t *dst,
-    ecs_entity_t trav,
-    ecs_entity_t entity,
-    ecs_id_record_t *idr_trav,
-    ecs_id_record_t *idr_with,
-    bool self);
+int flecs_script_eval_with_var(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_var_node_t *node)
+{
+    ecs_script_var_t *var = ecs_script_vars_lookup(v->vars, node->name);
+    if (!var) {
+        flecs_script_eval_error(v, node, 
+            "unresolved variable '%s'", node->name);
+        return -1;
+    }
+
+    ecs_allocator_t *a = v->allocator;
+    ecs_value_t *value = flecs_script_with_append(a, v);
+    *value = var->value;
+
+    return 0;
+}
 
 static
-ecs_trav_down_t* flecs_trav_down_ensure(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_up_cache_t *cache,
-    ecs_entity_t entity)
+int flecs_script_eval_with_tag(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_tag_t *node)
 {
-    ecs_trav_down_t **trav = ecs_map_ensure_ref(
-        &cache->src, ecs_trav_down_t, entity);
-    if (!trav[0]) {
-        trav[0] = flecs_iter_calloc_t(ctx->it, ecs_trav_down_t);
-        ecs_vec_init_t(NULL, &trav[0]->elems, ecs_trav_down_elem_t, 0);
+    if (flecs_script_eval_id(v, node, &node->id)) {
+        return -1;
     }
 
-    return trav[0];
+    ecs_allocator_t *a = v->allocator;
+    ecs_value_t *value = flecs_script_with_append(a, v);
+    value->type = node->id.eval;
+    value->ptr = NULL;
+
+    return 0;
 }
 
 static
-ecs_trav_down_t* flecs_trav_table_down(
-    ecs_world_t *world,
-    ecs_allocator_t *a,
-    ecs_trav_up_cache_t *cache,
-    ecs_trav_down_t *dst,
-    ecs_entity_t trav,
-    const ecs_table_t *table,
-    ecs_id_record_t *idr_with,
-    bool self)
+int flecs_script_eval_with_component(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_component_t *node)
 {
-    ecs_assert(table->id != 0, ECS_INTERNAL_ERROR, NULL);
-
-    if (!table->_->traversable_count) {
-        return dst;
+    if (flecs_script_eval_id(v, node, &node->id)) {
+        return -1;
     }
 
-    ecs_assert(idr_with != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_allocator_t *a = v->allocator;
+    ecs_value_t *value = flecs_script_with_append(a, v);
+    value->type = node->id.eval;
+    value->ptr = NULL;
 
-    ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
-    int32_t i, count = ecs_table_count(table);
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t entity = entities[i];
-        ecs_record_t *record = flecs_entities_get(world, entity);
-        if (!record) {
-            continue;
+    if (node->expr && node->expr[0]) {
+        const ecs_type_info_t *ti = flecs_script_get_type_info(
+            v, node, node->id.eval);
+        if (!ti) {
+            return -1;
         }
 
-        uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
-        if (flags & EcsEntityIsTraversable) {
-            ecs_id_record_t *idr_trav = flecs_id_record_get(world, 
-                ecs_pair(trav, entity));
-            if (!idr_trav) {
-                continue;
-            }
+        value->ptr = flecs_stack_alloc(&v->stack, ti->size, ti->alignment);
+        value->type = ti->component; // Expression parser needs actual type
 
-            flecs_trav_entity_down(world, a, cache, dst, 
-                trav, entity, idr_trav, idr_with, self);
+        if (flecs_script_eval_expr(v, node->expr, value)) {
+            return -1;
         }
+
+        value->type = node->id.eval; // Restore so we're adding actual id
     }
 
-    return dst;
+    return 0;
 }
 
 static
-void flecs_trav_entity_down_isa(
-    ecs_world_t *world,
-    ecs_allocator_t *a,
-    ecs_trav_up_cache_t *cache,
-    ecs_trav_down_t *dst,
-    ecs_entity_t trav,
-    ecs_entity_t entity,
-    ecs_id_record_t *idr_with,
-    bool self)
+int flecs_script_eval_with(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_with_t *node)
 {
-    if (trav == EcsIsA || !world->idr_isa_wildcard) {
-        return;
+    ecs_allocator_t *a = v->allocator;
+    int32_t prev_with_count = flecs_script_with_count(v);
+    ecs_stack_cursor_t *prev_stack_cursor = flecs_stack_get_cursor(&v->stack);
+    int result = 0;
+
+    if (ecs_script_visit_scope(v, node->expressions)) {
+        result = -1;
+        goto error;
     }
 
-    ecs_id_record_t *idr_isa = flecs_id_record_get(
-        world, ecs_pair(EcsIsA, entity));
-    if (!idr_isa) {
-        return;
+    ecs_value_t *value = flecs_script_with_last(v);
+    if (!value->ptr) {
+        if (ecs_is_valid(v->world, value->type)) {
+            node->scope->default_component_eval = value->type;
+        }
     }
 
-    ecs_table_cache_iter_t it;
-    if (flecs_table_cache_all_iter(&idr_isa->cache, &it)) {
-        ecs_table_record_t *tr;
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            ecs_table_t *table = tr->hdr.table;
-            if (!table->_->traversable_count) {
-                continue;
-            }
+    if (ecs_script_visit_scope(v, node->scope)) {
+        result = -1;
+        goto error;
+    }
 
-            ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
-            int32_t i, count = ecs_table_count(table);
+error:
+    flecs_script_with_set_count(a, v, prev_with_count);
+    flecs_stack_restore_cursor(&v->stack, prev_stack_cursor);
+    return result;
+}
+
+static
+int flecs_script_eval_using(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_using_t *node)
+{
+    ecs_allocator_t *a = v->allocator;
+    int32_t len = ecs_os_strlen(node->name);
+
+    if (len > 2 && !ecs_os_strcmp(&node->name[len - 2], ".*")) {
+        char *path = flecs_strdup(a, node->name);
+        path[len - 2] = '\0';
+
+        ecs_entity_t from = ecs_lookup(v->world, path);
+        if (!from) {
+            flecs_script_eval_error(v, node, 
+                "unresolved path '%s' in using statement", path);
+            flecs_strfree(a, path);
+            return -1;
+        }
+
+        /* Add each child of the scope to using stack */
+        ecs_iter_t it = ecs_children(v->world, from);
+        while (ecs_children_next(&it)) {
+            int32_t i, count = it.count;
             for (i = 0; i < count; i ++) {
-                ecs_entity_t e = entities[i];
-                ecs_record_t *record = flecs_entities_get(world, e);
-                if (!record) {
-                    continue;
-                }
+                ecs_vec_append_t(
+                    a, &v->using, ecs_entity_t)[0] = it.entities[i];
+            }
+        }
 
-                uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
-                if (flags & EcsEntityIsTraversable) {
-                    ecs_id_record_t *idr_trav = flecs_id_record_get(world, 
-                        ecs_pair(trav, e));
-                    flecs_trav_entity_down(world, a, cache, dst, trav, e,
-                        idr_trav, idr_with, self);
-                }
+        flecs_strfree(a, path);
+    } else {
+        ecs_entity_t from = ecs_lookup_path_w_sep(
+            v->world, 0, node->name, NULL, NULL, false);
+        if (!from) {
+            from = ecs_entity(v->world, {
+                .name = node->name,
+                .root_sep = ""
+            });
+
+            if (!from) {
+                return -1;
             }
         }
+
+        ecs_vec_append_t(a, &v->using, ecs_entity_t)[0] = from;
     }
+
+    return 0;
 }
 
 static
-ecs_trav_down_t* flecs_trav_entity_down(
-    ecs_world_t *world,
-    ecs_allocator_t *a,
-    ecs_trav_up_cache_t *cache,
-    ecs_trav_down_t *dst,
-    ecs_entity_t trav,
-    ecs_entity_t entity,
-    ecs_id_record_t *idr_trav,
-    ecs_id_record_t *idr_with,
-    bool self)
+int flecs_script_eval_module(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_module_t *node)
 {
-    ecs_assert(dst != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(idr_with != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_entity_t m = flecs_script_create_entity(v, node->name);
+    if (!m) {
+        return -1;
+    }
 
-    flecs_trav_entity_down_isa(
-        world, a, cache, dst, trav, entity, idr_with, self);
+    ecs_add_id(v->world, m, EcsModule);
 
-    int32_t first = ecs_vec_count(&dst->elems);
+    v->module = m;
+    v->parent = m;
 
-    ecs_table_cache_iter_t it;
-    if (flecs_table_cache_iter(&idr_trav->cache, &it)) {
-        ecs_table_record_t *tr; 
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            ecs_assert(tr->count == 1, ECS_INTERNAL_ERROR, NULL);
-            ecs_table_t *table = tr->hdr.table;
-            bool leaf = false;
+    return 0;
+}
 
-            if (flecs_id_record_get_table(idr_with, table) != NULL) {
-                if (self) {
-                    continue;
-                }
-                leaf = true;
-            }
+static
+int flecs_script_eval_const(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_var_node_t *node)
+{
+    ecs_script_var_t *var = ecs_script_vars_declare(v->vars, node->name);
+    if (!var) {
+        flecs_script_eval_error(v, node, 
+            "variable '%s' redeclared", node->name);
+        return -1;
+    }
 
-            /* If record is not the first instance of (trav, *), don't add it
-             * to the cache. */
-            int32_t index = tr->index;
-            if (index) {
-                ecs_id_t id = table->type.array[index - 1];
-                if (ECS_IS_PAIR(id) && ECS_PAIR_FIRST(id) == trav) {
-                    int32_t col = ecs_search_relation(world, table, 0, 
-                        idr_with->id, trav, EcsUp, NULL, NULL, &tr);
-                    ecs_assert(col >= 0, ECS_INTERNAL_ERROR, NULL);
+    if (node->type) {
+        ecs_entity_t type = flecs_script_find_entity(v, 0, node->type);
+        if (!type) {
+            flecs_script_eval_error(v, node,
+                "unresolved type '%s' for const variable '%s'", 
+                    node->type, node->name);
+            return -1;
+        }
+
+        const ecs_type_info_t *ti = flecs_script_get_type_info(v, node, type);
+        if (!ti) {
+            return -1;
+        }
+
+        var->value.ptr = flecs_stack_calloc(&v->stack, ti->size, ti->alignment);
+        var->value.type = type;
+        var->type_info = ti;
+
+        if (flecs_script_eval_expr(v, node->expr, &var->value)) {
+            return -1;
+        }
+    } else {
+        /* We don't know the type yet, so we can't create a storage for it yet.
+         * Run the expression first to deduce the type. */
+        ecs_value_t value = {0};
+        if (flecs_script_eval_expr(v, node->expr, &value)) {
+            return -1;
+        }
+
+        ecs_assert(value.type != 0, ECS_INTERNAL_ERROR, NULL);
+        const ecs_type_info_t *ti = ecs_get_type_info(v->world, value.type);
+        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        var->value.ptr = flecs_stack_calloc(&v->stack, ti->size, ti->alignment);
+        var->value.type = value.type;
+        var->type_info = ti;
+
+        ecs_value_copy_w_type_info(v->world, ti, var->value.ptr, value.ptr);
+        ecs_value_fini_w_type_info(v->world, ti, value.ptr);
+        flecs_free(&v->world->allocator, ti->size, value.ptr);
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_eval_pair_scope(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_pair_scope_t *node)
+{
+    ecs_entity_t first = flecs_script_create_entity(v, node->id.first);
+    if (!first) {
+        return -1;
+    }
 
-                    if (col != index) {
-                        /* First relationship through which the id is 
-                         * reachable is not the current one, so skip. */
-                        continue;
-                    }
-                }
-            }
+    ecs_entity_t second = flecs_script_create_entity(v, node->id.second);
+    if (!second) {
+        return -1;
+    }
 
-            ecs_trav_down_elem_t *elem = ecs_vec_append_t(
-                a, &dst->elems, ecs_trav_down_elem_t);
-            elem->table = table;
-            elem->leaf = leaf;
-        }
+    ecs_allocator_t *a = v->allocator;
+    ecs_entity_t prev_first = v->with_relationship;
+    ecs_entity_t prev_second = 0;
+    int32_t prev_with_relationship_sp = v->with_relationship_sp;
+
+    v->with_relationship = first;
+
+    if (prev_first != first) {
+        /* Append new element to with stack */
+        ecs_value_t *value = flecs_script_with_append(a, v);
+        value->type = ecs_pair(first, second);
+        value->ptr = NULL;
+        v->with_relationship_sp = flecs_script_with_count(v) - 1;
+    } else {
+        /* Get existing with element for current relationhip stack */
+        ecs_value_t *value = ecs_vec_get_t(
+            &v->with, ecs_value_t, v->with_relationship_sp);
+        ecs_assert(ECS_PAIR_FIRST(value->type) == (uint32_t)first, 
+            ECS_INTERNAL_ERROR, NULL);
+        prev_second = ECS_PAIR_SECOND(value->type);
+        value->type = ecs_pair(first, second);
+        value->ptr = NULL;
     }
 
-    /* Breadth first walk */
-    int32_t t, last = ecs_vec_count(&dst->elems);
-    for (t = first; t < last; t ++) {
-        ecs_trav_down_elem_t *elem = ecs_vec_get_t(
-            &dst->elems, ecs_trav_down_elem_t, t);
-        if (!elem->leaf) {
-            flecs_trav_table_down(world, a, cache, dst, trav,
-                elem->table, idr_with, self);
-        }
+    if (ecs_script_visit_scope(v, node->scope)) {
+        return -1;
     }
 
-    return dst;
+    if (prev_second) {
+        ecs_value_t *value = ecs_vec_get_t(
+            &v->with, ecs_value_t, v->with_relationship_sp);
+        value->type = ecs_pair(first, prev_second);
+    } else {
+        flecs_script_with_set_count(a, v, v->with_relationship_sp);
+    }
+
+    v->with_relationship = prev_first;
+    v->with_relationship_sp = prev_with_relationship_sp;
+
+    return 0;
 }
 
-ecs_trav_down_t* flecs_rule_get_down_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_up_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_entity_t e,
-    ecs_id_record_t *idr_with,
-    bool self)
+static
+int flecs_script_eval_if(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_if_t *node)
 {
-    ecs_world_t *world = ctx->it->real_world;
-    ecs_assert(!(cache->dir & EcsUp), ECS_INTERNAL_ERROR, NULL);
-    cache->dir = EcsDown;
+    bool cond = false;
+    ecs_value_t condval = { .type = ecs_id(ecs_bool_t), .ptr = &cond };
 
-    ecs_allocator_t *a = flecs_rule_get_allocator(ctx->it);
-    ecs_map_init_if(&cache->src, a);
+    if (flecs_script_eval_expr(v, node->expr, &condval)) {
+        return -1;
+    }
 
-    ecs_trav_down_t *result = flecs_trav_down_ensure(ctx, cache, e);
-    if (result->ready) {
-        return result;
+    if (flecs_script_eval_scope(v, cond ? node->if_true : node->if_false)) {
+        return -1;
     }
 
-    ecs_id_record_t *idr_trav = flecs_id_record_get(world, ecs_pair(trav, e));
-    if (!idr_trav) {
-        if (trav != EcsIsA) {
-            flecs_trav_entity_down_isa(
-                world, a, cache, result, trav, e, idr_with, self);
-        }
-        result->ready = true;
-        return result;
+    return 0;
+}
+
+static
+int flecs_script_eval_annot(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_annot_t *node)
+{
+    if (!v->base.next) {
+        flecs_script_eval_error(v, node,
+            "annotation '%s' is not applied to anything", node->name);
+        return -1;
     }
 
-    ecs_vec_init_t(a, &result->elems, ecs_trav_down_elem_t, 0);
-    flecs_trav_entity_down(
-        world, a, cache, result, trav, e, idr_trav, idr_with, self);
-    result->ready = true;
+    ecs_script_node_kind_t kind = v->base.next->kind;
+    if (kind != EcsAstEntity && kind != EcsAstAnnotation) {
+        flecs_script_eval_error(v, node,
+            "annotation must be applied to an entity");
+        return -1;
+    }
 
-    return result;
+    ecs_allocator_t *a = v->allocator;
+    ecs_vec_append_t(a, &v->annot, ecs_script_annot_t*)[0] = node;
+
+    return 0;
 }
 
-void flecs_rule_down_cache_fini(
-    ecs_allocator_t *a,
-    ecs_trav_up_cache_t *cache)
+int flecs_script_eval_node(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node)
+{
+    switch(node->kind) {
+    case EcsAstScope:
+        return flecs_script_eval_scope(
+            v, (ecs_script_scope_t*)node);
+    case EcsAstTag:
+        return flecs_script_eval_tag(
+            v, (ecs_script_tag_t*)node);
+    case EcsAstComponent:
+        return flecs_script_eval_component(
+            v, (ecs_script_component_t*)node);
+    case EcsAstVarComponent:
+        return flecs_script_eval_var_component(
+            v, (ecs_script_var_component_t*)node);
+    case EcsAstDefaultComponent:
+        return flecs_script_eval_default_component(
+            v, (ecs_script_default_component_t*)node);
+    case EcsAstWithVar:
+        return flecs_script_eval_with_var(
+            v, (ecs_script_var_node_t*)node);
+    case EcsAstWithTag:
+        return flecs_script_eval_with_tag(
+            v, (ecs_script_tag_t*)node);
+    case EcsAstWithComponent:
+        return flecs_script_eval_with_component(
+            v, (ecs_script_component_t*)node);
+    case EcsAstWith:
+        return flecs_script_eval_with(
+            v, (ecs_script_with_t*)node);
+    case EcsAstUsing:
+        return flecs_script_eval_using(
+            v, (ecs_script_using_t*)node);
+    case EcsAstModule:
+        return flecs_script_eval_module(
+            v, (ecs_script_module_t*)node);
+    case EcsAstAnnotation:
+        return flecs_script_eval_annot(
+            v, (ecs_script_annot_t*)node);
+    case EcsAstAssembly:
+        return flecs_script_eval_assembly(
+            v, (ecs_script_assembly_node_t*)node);
+    case EcsAstProp:
+        return 0;
+    case EcsAstConst:
+        return flecs_script_eval_const(
+            v, (ecs_script_var_node_t*)node);
+    case EcsAstEntity:
+        return flecs_script_eval_entity(
+            v, (ecs_script_entity_t*)node);
+    case EcsAstPairScope:
+        return flecs_script_eval_pair_scope(
+            v, (ecs_script_pair_scope_t*)node);
+    case EcsAstIf:
+        return flecs_script_eval_if(
+            v, (ecs_script_if_t*)node);
+    }
+
+    ecs_abort(ECS_INTERNAL_ERROR, "corrupt AST node kind");
+}
+
+void flecs_script_eval_visit_init(
+    ecs_script_t *script,
+    ecs_script_eval_visitor_t *v)
+{
+    *v = (ecs_script_eval_visitor_t){
+        .base = {
+            .script = script,
+            .visit = (ecs_visit_action_t)flecs_script_eval_node
+        },  
+        .world = script->world,
+        .allocator = &script->allocator
+    };
+
+    flecs_stack_init(&v->stack);
+    ecs_vec_init_t(v->allocator, &v->using, ecs_entity_t, 0);
+    ecs_vec_init_t(v->allocator, &v->with, ecs_value_t, 0);
+    ecs_vec_init_t(v->allocator, &v->annot, ecs_script_annot_t*, 0);
+}
+
+void flecs_script_eval_visit_fini(
+    ecs_script_eval_visitor_t *v)
 {
-    ecs_map_iter_t it = ecs_map_iter(&cache->src);
-    while (ecs_map_next(&it)) {
-        ecs_trav_down_t *t = ecs_map_ptr(&it);
-        ecs_vec_fini_t(a, &t->elems, ecs_trav_down_elem_t);
-    }
-    ecs_map_fini(&cache->src);
+    ecs_vec_fini_t(v->allocator, &v->annot, ecs_script_annot_t*);
+    ecs_vec_fini_t(v->allocator, &v->with, ecs_value_t);
+    ecs_vec_fini_t(v->allocator, &v->using, ecs_entity_t);
+    flecs_stack_fini(&v->stack);
+}
+
+int ecs_script_eval(
+    ecs_script_t *script)
+{
+    ecs_script_eval_visitor_t v;
+    flecs_script_eval_visit_init(script, &v);
+    int result = ecs_script_visit(script, &v, flecs_script_eval_node);
+    flecs_script_eval_visit_fini(&v);
+    return result;
 }
 
 #endif
 
+/**
+ * @file addons/script/visit_free.c
+ * @brief Script free visitor (frees AST resources).
+ */
+
 
-#ifdef FLECS_RULES
+#ifdef FLECS_SCRIPT
 
 static
-ecs_trav_up_t* flecs_trav_up_ensure(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_up_cache_t *cache,
-    uint64_t table_id)
+void flecs_script_scope_free(
+    ecs_script_visit_t *v,
+    ecs_script_scope_t *node)
 {
-    ecs_trav_up_t **trav = ecs_map_ensure_ref(
-        &cache->src, ecs_trav_up_t, table_id);
-    if (!trav[0]) {
-        trav[0] = flecs_iter_calloc_t(ctx->it, ecs_trav_up_t);
-    }
-
-    return trav[0];
+    ecs_script_visit_scope(v, node);
+    ecs_vec_fini_t(&v->script->allocator, &node->stmts, ecs_script_node_t*);
+    flecs_free_t(&v->script->allocator, ecs_script_scope_t, node);
 }
 
 static
-int32_t flecs_trav_type_search(
-    ecs_trav_up_t *up,
-    const ecs_table_t *table,
-    ecs_id_record_t *idr_with,
-    ecs_type_t *type)
-{    
-    ecs_table_record_t *tr = ecs_table_cache_get(&idr_with->cache, table);
-    if (tr) {
-        up->id = type->array[tr->index];
-        return up->column = tr->index;
-    }
+void flecs_script_with_free(
+    ecs_script_visit_t *v,
+    ecs_script_with_t *node)
+{
+    flecs_script_scope_free(v, node->expressions);
+    flecs_script_scope_free(v, node->scope);
+}
 
-    return -1;
+static
+void flecs_script_assembly_free(
+    ecs_script_visit_t *v,
+    ecs_script_assembly_node_t *node)
+{
+    flecs_script_scope_free(v, node->scope);
 }
 
 static
-int32_t flecs_trav_type_offset_search(
-    ecs_trav_up_t *up,
-    int32_t offset,
-    ecs_id_t with,
-    ecs_type_t *type)
+void flecs_script_entity_free(
+    ecs_script_visit_t *v,
+    ecs_script_entity_t *node)
 {
-    ecs_assert(offset > 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(with != 0, ECS_INVALID_PARAMETER, NULL);
+    flecs_script_scope_free(v, node->scope);
+}
 
-    while (offset < type->count) {
-        ecs_id_t type_id = type->array[offset ++];
-        if (ecs_id_match(type_id, with)) {
-            up->id = flecs_to_public_id(type_id);
-            return up->column = offset - 1;
-        }
-    }
+static
+void flecs_script_pair_scope_free(
+    ecs_script_visit_t *v,
+    ecs_script_pair_scope_t *node)
+{
+    flecs_script_scope_free(v, node->scope);
+}
 
-    return -1;
+static
+void flecs_script_if_free(
+    ecs_script_visit_t *v,
+    ecs_script_if_t *node)
+{
+    flecs_script_scope_free(v, node->if_true);
+    flecs_script_scope_free(v, node->if_false);
 }
 
 static
-ecs_trav_up_t* flecs_trav_table_up(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_allocator_t *a,
-    ecs_trav_up_cache_t *cache,
-    const ecs_world_t *world,
-    ecs_entity_t src,
-    ecs_id_t with,
-    ecs_id_t rel,
-    ecs_id_record_t *idr_with,
-    ecs_id_record_t *idr_trav)
+int flecs_script_stmt_free(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *node)
 {
-    ecs_trav_up_t *up = flecs_trav_up_ensure(ctx, cache, src);
-    if (up->ready) {
-        return up;
+    ecs_allocator_t *a = &v->script->allocator;
+    switch(node->kind) {
+    case EcsAstScope:
+        flecs_script_scope_free(v, (ecs_script_scope_t*)node);
+        break;
+    case EcsAstWith:
+        flecs_script_with_free(v, (ecs_script_with_t*)node);
+        flecs_free_t(a, ecs_script_with_t, node);
+        break;
+    case EcsAstAssembly:
+        flecs_script_assembly_free(v, (ecs_script_assembly_node_t*)node);
+        flecs_free_t(a, ecs_script_assembly_node_t, node);
+        break;
+    case EcsAstEntity:
+        flecs_script_entity_free(v, (ecs_script_entity_t*)node);
+        flecs_free_t(a, ecs_script_entity_t, node);
+        break;
+    case EcsAstPairScope:
+        flecs_script_pair_scope_free(v, (ecs_script_pair_scope_t*)node);
+        flecs_free_t(a, ecs_script_pair_scope_t, node);
+        break;
+    case EcsAstIf:
+        flecs_script_if_free(v, (ecs_script_if_t*)node);
+        flecs_free_t(a, ecs_script_if_t, node);
+        break;
+    case EcsAstTag:
+        flecs_free_t(a, ecs_script_tag_t, node);
+        break;
+    case EcsAstComponent:
+        flecs_free_t(a, ecs_script_component_t, node);
+        break;
+    case EcsAstDefaultComponent:
+        flecs_free_t(a, ecs_script_default_component_t, node);
+        break;
+    case EcsAstVarComponent:
+        flecs_free_t(a, ecs_script_var_component_t, node);
+        break;
+    case EcsAstWithVar:
+        flecs_free_t(a, ecs_script_var_component_t, node);
+        break;
+    case EcsAstWithTag:
+        flecs_free_t(a, ecs_script_tag_t, node);
+        break;
+    case EcsAstWithComponent:
+        flecs_free_t(a, ecs_script_component_t, node);
+        break;
+    case EcsAstUsing:
+        flecs_free_t(a, ecs_script_using_t, node);
+        break;
+    case EcsAstModule:
+        flecs_free_t(a, ecs_script_module_t, node);
+        break;
+    case EcsAstAnnotation:
+        flecs_free_t(a, ecs_script_annot_t, node);
+        break;
+    case EcsAstProp:
+    case EcsAstConst:
+        flecs_free_t(a, ecs_script_var_node_t, node);
+        break;
     }
 
-    ecs_record_t *src_record = flecs_entities_get_any(world, src);
-    ecs_table_t *table = src_record->table;
-    if (!table) {
-        goto not_found;
-    }
+    return 0;
+}
 
-    ecs_type_t type = table->type;
-    if (flecs_trav_type_search(up, table, idr_with, &type) >= 0) {
-        up->src = src;
-        goto found;
+int flecs_script_visit_free(
+    ecs_script_t *script)
+{
+    ecs_check(script != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_script_visit_t v = {
+        .script = script
+    };
+
+    if (ecs_script_visit(script, &v, flecs_script_stmt_free)) {
+        goto error;
     }
 
-    ecs_flags32_t flags = table->flags;
-    if ((flags & EcsTableHasPairs) && rel) {
-        bool is_a = idr_trav == world->idr_isa_wildcard;
-        if (is_a) {
-            if (!(flags & EcsTableHasIsA)) {
-                goto not_found;
-            }
+    return 0;
+error:
+    return - 1;
+}
 
-            if (!flecs_type_can_inherit_id(world, table, idr_with, with)) {
-                goto not_found;
-            }
-        }
+#endif
 
-        ecs_trav_up_t up_pair = {0};
-        int32_t r_column = flecs_trav_type_search(
-                &up_pair, table, idr_trav, &type);
+/**
+ * @file addons/script/visit_to_str.c
+ * @brief Script AST to string visitor.
+ */
 
-        while (r_column != -1) {
-            ecs_entity_t tgt = ECS_PAIR_SECOND(up_pair.id);
-            ecs_assert(tgt != 0, ECS_INTERNAL_ERROR, NULL);
 
-            ecs_trav_up_t *up_parent = flecs_trav_table_up(ctx, a, cache,
-                world, tgt, with, rel, idr_with, idr_trav);
-            if (up_parent->column != -1) {
-                up->src = up_parent->src;
-                up->column = up_parent->column;
-                up->id = up_parent->id;
-                goto found;
-            }
+#ifdef FLECS_SCRIPT
 
-            r_column = flecs_trav_type_offset_search(
-                &up_pair, r_column + 1, rel, &type);
-        }
+typedef struct ecs_script_str_visitor_t {
+    ecs_script_visit_t base;
+    ecs_strbuf_t *buf;
+    int32_t depth;
+    bool newline;
+} ecs_script_str_visitor_t;
 
-        if (!is_a) {
-            idr_trav = world->idr_isa_wildcard;
-            r_column = flecs_trav_type_search(
-                    &up_pair, table, idr_trav, &type);
+static
+int flecs_script_scope_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_scope_t *scope);
 
-            while (r_column != -1) {
-                ecs_entity_t tgt = ECS_PAIR_SECOND(up_pair.id);
-                ecs_assert(tgt != 0, ECS_INTERNAL_ERROR, NULL);
+static
+void flecs_scriptbuf_append(
+    ecs_script_str_visitor_t *v,
+    const char *fmt,
+    ...)
+{
+    if (v->newline) {
+        ecs_strbuf_append(v->buf, "%*s", v->depth * 2, "");
+        v->newline = false;
+    }
 
-                ecs_trav_up_t *up_parent = flecs_trav_table_up(ctx, a, cache,
-                    world, tgt, with, rel, idr_with, idr_trav);
-                if (up_parent->column != -1) {
-                    up->src = up_parent->src;
-                    up->column = up_parent->column;
-                    up->id = up_parent->id;
-                    goto found;
-                }
+    va_list args;
+    va_start(args, fmt);
+    ecs_strbuf_vappend(v->buf, fmt, args);
+    va_end(args);
 
-                r_column = flecs_trav_type_offset_search(
-                    &up_pair, r_column + 1, rel, &type);
-            }
-        }
+    if (fmt[strlen(fmt) - 1] == '\n') {
+        v->newline = true;
     }
-
-not_found:
-    up->column = -1;
-found:
-    up->ready = true;
-    return up;
 }
 
-ecs_trav_up_t* flecs_rule_get_up_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_up_cache_t *cache,
-    ecs_table_t *table,
-    ecs_id_t with,
-    ecs_entity_t trav,
-    ecs_id_record_t *idr_with,
-    ecs_id_record_t *idr_trav)
+static
+void flecs_scriptbuf_appendstr(
+    ecs_script_str_visitor_t *v,
+    const char *str)
 {
-    if (cache->with && cache->with != with) {
-        flecs_rule_up_cache_fini(cache);
+    if (v->newline) {
+        ecs_strbuf_append(v->buf, "%*s", v->depth * 2, "");
+        v->newline = false;
     }
 
-    ecs_world_t *world = ctx->it->real_world;
-    ecs_allocator_t *a = flecs_rule_get_allocator(ctx->it);
-    ecs_map_init_if(&cache->src, a);
-
-    ecs_assert(!(cache->dir & EcsDown), ECS_INTERNAL_ERROR, NULL);
-    cache->dir = EcsUp;
-    cache->with = with;
+    ecs_strbuf_appendstr(v->buf, str);
 
-    ecs_assert(idr_with != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(idr_trav != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_table_record_t *tr = ecs_table_cache_get(&idr_trav->cache, table);
-    if (!tr) {
-        return NULL; /* Table doesn't have the relationship */
+    if (str[strlen(str) - 1] == '\n') {
+        v->newline = true;
     }
+}
 
-    int32_t i = tr->index, end = i + tr->count;
-    for (; i < end; i ++) {
-        ecs_id_t id = table->type.array[i];
-        ecs_entity_t tgt = ECS_PAIR_SECOND(id);
-        ecs_trav_up_t *result = flecs_trav_table_up(ctx, a, cache, world, tgt,
-            with, ecs_pair(trav, EcsWildcard), idr_with, idr_trav);
-        ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL);
-        if (result->src != 0) {
-            return result;
-        }
+static
+void flecs_script_id_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_id_t *id)
+{
+    if (id->second) {
+        flecs_scriptbuf_append(v, "(%s, %s)", 
+            id->first, id->second);
+    } else {
+        flecs_scriptbuf_appendstr(v, id->first);
     }
-
-    return NULL;
 }
 
-void flecs_rule_up_cache_fini(
-    ecs_trav_up_cache_t *cache)
+static
+void flecs_script_expr_to_str(
+    ecs_script_str_visitor_t *v,
+    const char *expr)
 {
-    ecs_map_fini(&cache->src);
+    if (expr) {
+        flecs_scriptbuf_append(v, "%s%s%s", ECS_GREEN, expr, ECS_NORMAL);
+    } else {
+        flecs_scriptbuf_appendstr(v, "{}");
+    }
 }
 
-#endif
-
-/**
- * @file addons/rules/engine.c
- * @brief Iterator for trivial queries.
- */
+static
+const char* flecs_script_node_to_str(
+    ecs_script_node_t *node)
+{
+    switch(node->kind) {
+    case EcsAstScope:              return "scope";
+    case EcsAstWithTag:
+    case EcsAstTag:                return "tag";
+    case EcsAstWithComponent:
+    case EcsAstComponent:          return "component";
+    case EcsAstWithVar:
+    case EcsAstVarComponent:       return "var";
+    case EcsAstDefaultComponent:   return "default_component";
+    case EcsAstWith:               return "with";
+    case EcsAstUsing:              return "using";
+    case EcsAstModule:             return "module";
+    case EcsAstAnnotation:         return "annot";
+    case EcsAstAssembly:           return "assembly";
+    case EcsAstProp:               return "prop";
+    case EcsAstConst:              return "const";
+    case EcsAstEntity:             return "entity";
+    case EcsAstPairScope:          return "pair_scope";
+    case EcsAstIf:                 return "if";
+    }
+    return "???";
+}
 
+static
+void flecs_scriptbuf_node(
+    ecs_script_str_visitor_t *v,
+    ecs_script_node_t *node)
+{
+    flecs_scriptbuf_append(v, "%s%s%s: ", 
+        ECS_BLUE, flecs_script_node_to_str(node), ECS_NORMAL);
+}
 
-#ifdef FLECS_RULES
+static
+void flecs_script_tag_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_tag_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_script_id_to_str(v, &node->id);
+    flecs_scriptbuf_appendstr(v, "\n");
+}
 
 static
-bool flecs_rule_trivial_init(
-    ecs_world_t *world,
-    const ecs_filter_t *filter)
+void flecs_script_component_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_component_t *node)
 {
-    int32_t t, count = filter->term_count;
-    ecs_term_t *terms = filter->terms;
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_script_id_to_str(v, &node->id);
+    if (node->expr) {
+        flecs_scriptbuf_appendstr(v, ": ");
+        flecs_script_expr_to_str(v, node->expr);
+    }
+    flecs_scriptbuf_appendstr(v, "\n");
+}
 
-    for (t = 0; t < count; t ++) {
-        ecs_term_t *term = &terms[t];
-        if (!term->idr) {
-            term->idr = flecs_id_record_get(world, term->id);
-            if (!term->idr) {
-                /* Id doesn't exist, so query can't match */
-                return false;
-            }
-        }
+static
+void flecs_script_default_component_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_default_component_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    if (node->expr) {
+        flecs_script_expr_to_str(v, node->expr);
     }
+    flecs_scriptbuf_appendstr(v, "\n");
+}
 
-    return true;
+static
+void flecs_script_with_var_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_var_component_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s ", node->name);
+    flecs_scriptbuf_appendstr(v, "\n");
 }
 
-bool flecs_rule_trivial_test(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    bool first,
-    int32_t term_count)
+static
+void flecs_script_with_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_with_t *node)
 {
-    if (first) {
-        const ecs_filter_t *filter = &rule->filter;
-        int32_t t;
-        ecs_term_t *terms = filter->terms;
-        ecs_iter_t *it = ctx->it;
+    flecs_scriptbuf_node(v, &node->node);
+    
+    flecs_scriptbuf_appendstr(v, "{\n");
+    v->depth ++;
+    flecs_scriptbuf_append(v, "%sexpressions%s: ", ECS_CYAN, ECS_NORMAL);
+    flecs_script_scope_to_str(v, node->expressions);
+    flecs_scriptbuf_append(v, "%sscope%s: ", ECS_CYAN, ECS_NORMAL);
+    flecs_script_scope_to_str(v, node->scope);
+    v->depth --;
+    flecs_scriptbuf_appendstr(v, "}\n");
+}
 
-        if (!flecs_rule_trivial_init(ctx->world, filter)) {
-            return false;
-        }
+static
+void flecs_script_using_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_using_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s\n", node->name);
+}
 
-        ecs_table_t *table = ctx->vars[0].range.table;
-        ecs_assert(table != NULL, ECS_INVALID_OPERATION, NULL);
+static
+void flecs_script_module_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_module_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s\n", node->name);
+}
 
-        for (t = 0; t < term_count; t ++) {
-            ecs_term_t *term = &terms[t];
-            const ecs_table_record_t *tr = flecs_id_record_get_table(
-                term->idr, table);
-            if (!tr) {
-                return false;
-            }
+static
+void flecs_script_annot_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_annot_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s = %s\"%s\"%s", node->name, 
+        ECS_GREEN, node->expr, ECS_NORMAL);
+    flecs_scriptbuf_appendstr(v, "\n");
+}
 
-            it->columns[t] = tr->index + 1;
-            if (it->count && tr->column != -1) {
-                it->ptrs[t] = ecs_vec_get(
-                    &table->data.columns[tr->column].data,
-                    it->sizes[t],
-                    it->offset);
-            }
-        }
+static
+void flecs_script_assembly_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_assembly_node_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s ", node->name);
+    flecs_script_scope_to_str(v, node->scope);
+}
 
-        it->table = table;
-        it->entities = &flecs_table_entities_array(table)[it->offset];
-        return true;
+static
+void flecs_script_var_node_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_var_node_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    if (node->type) {
+        flecs_scriptbuf_append(v, "%s : %s = ", 
+            node->name,
+            node->type);
     } else {
-        return false;
+        flecs_scriptbuf_append(v, "%s = ", 
+            node->name);
     }
+    flecs_script_expr_to_str(v, node->expr);
+    flecs_scriptbuf_appendstr(v, "\n");
 }
 
 static
-bool flecs_rule_trivial_search_init(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    const ecs_filter_t *filter,
-    bool first)
+void flecs_script_entity_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_entity_t *node)
 {
-    if (first) {
-        ecs_term_t *terms = filter->terms;
-        if (!flecs_rule_trivial_init(ctx->world, filter)) {
-            return false;
-        }
+    flecs_scriptbuf_node(v, &node->node);
+    if (node->kind) {
+        flecs_scriptbuf_append(v, "%s ", node->kind);
+    }
+    if (node->name) {
+        flecs_scriptbuf_append(v, "%s ", node->name);
+    } else {
+        flecs_scriptbuf_appendstr(v, "<anon> ");
+    }
 
-        if (filter->flags & EcsFilterMatchEmptyTables) {
-            if (!flecs_table_cache_all_iter(&terms[0].idr->cache, &op_ctx->it)){
-                return false;
-            }
-        } else {
-            if (!flecs_table_cache_iter(&terms[0].idr->cache, &op_ctx->it)) {
-                return false;
-            }
-        }
+    if (!flecs_scope_is_empty(node->scope)) {
+        flecs_script_scope_to_str(v, node->scope);
+    } else {
+        flecs_scriptbuf_appendstr(v, "\n");
     }
+}
 
-    return true;
+static
+void flecs_script_pair_scope_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_pair_scope_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_script_id_to_str(v, &node->id);
+    flecs_scriptbuf_appendstr(v, " ");
+    flecs_script_scope_to_str(v, node->scope);
 }
 
-bool flecs_rule_trivial_search(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t term_count)
+static
+void flecs_script_if_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_if_t *node)
 {
-    const ecs_filter_t *filter = &rule->filter;
-    int32_t t;
-    ecs_term_t *terms = filter->terms;
-    ecs_iter_t *it = ctx->it;
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_script_expr_to_str(v, node->expr);
 
-    if (!flecs_rule_trivial_search_init(ctx, op_ctx, filter, first)) {
-        return false;
+    flecs_scriptbuf_appendstr(v, " {\n");
+    v->depth ++;
+    flecs_scriptbuf_append(v, "%strue%s: ", ECS_CYAN, ECS_NORMAL);
+    flecs_script_scope_to_str(v, node->if_true);
+    flecs_scriptbuf_append(v, "%sfalse%s: ", ECS_CYAN, ECS_NORMAL);
+    flecs_script_scope_to_str(v, node->if_false);
+    v->depth --;
+    flecs_scriptbuf_appendstr(v, "}\n");
+}
+
+static
+int flecs_script_scope_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_scope_t *scope)
+{
+    if (!ecs_vec_count(&scope->stmts)) {
+        flecs_scriptbuf_appendstr(v, "{}\n");
+        return 0;
     }
 
-    do {
-        const ecs_table_record_t *tr = flecs_table_cache_next(
-            &op_ctx->it, ecs_table_record_t);
-        if (!tr) {
-            return false;
-        }
+    flecs_scriptbuf_appendstr(v, "{\n");
 
-        ecs_table_t *table = tr->hdr.table;
-        if (table->flags & (EcsTableIsPrefab|EcsTableIsDisabled)) {
-            continue;
-        }
+    v->depth ++;
 
-        for (t = 1; t < term_count; t ++) {
-            ecs_term_t *term = &terms[t];
-            const ecs_table_record_t *tr_with = flecs_id_record_get_table(
-                term->idr, table);
-            if (!tr_with) {
-                break;
-            }
+    if (ecs_script_visit_scope(v, scope)) {
+        return -1;
+    }
 
-            it->columns[t] = tr_with->index + 1;
-            if (tr_with->column != -1) {
-                it->ptrs[t] = ecs_vec_first(
-                    &table->data.columns[tr_with->column].data);
-            }
-        }
+    v->depth --;
 
-        if (t == term_count) {
-            ctx->vars[0].range.table = table;
-            ctx->vars[0].range.count = 0;
-            ctx->vars[0].range.offset = 0;
-            it->columns[0] = tr->index + 1;
-            if (tr->column != -1) {
-                it->ptrs[0] = ecs_vec_first(
-                    &table->data.columns[tr->column].data);
-            }
-            break;
-        }
-    } while (true);
+    flecs_scriptbuf_appendstr(v, "}\n");
 
-    return true;
+    return 0;
 }
 
-bool flecs_rule_trivial_search_w_wildcards(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t term_count)
+static
+int flecs_script_stmt_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_node_t *node)
 {
-    bool result = flecs_rule_trivial_search(
-        rule, ctx, op_ctx, first, term_count);
-    if (result) {
-        ecs_iter_t *it = ctx->it;
-        ecs_table_t *table = ctx->vars[0].range.table;
-        int32_t t;
-        for (t = 0; t < term_count; t ++) {
-            it->ids[t] = table->type.array[it->columns[t] - 1];
+    switch(node->kind) {
+    case EcsAstScope:
+        if (flecs_script_scope_to_str(v, (ecs_script_scope_t*)node)) {
+            return -1;
         }
+        break;
+    case EcsAstTag:
+    case EcsAstWithTag:
+        flecs_script_tag_to_str(v, (ecs_script_tag_t*)node);
+        break;
+    case EcsAstComponent:
+    case EcsAstWithComponent:
+        flecs_script_component_to_str(v, (ecs_script_component_t*)node);
+        break;
+    case EcsAstVarComponent:
+    case EcsAstWithVar:
+        flecs_script_with_var_to_str(v, 
+            (ecs_script_var_component_t*)node);
+        break;
+    case EcsAstDefaultComponent:
+        flecs_script_default_component_to_str(v, 
+            (ecs_script_default_component_t*)node);
+        break;
+    case EcsAstWith:
+        flecs_script_with_to_str(v, (ecs_script_with_t*)node);
+        break;
+    case EcsAstUsing:
+        flecs_script_using_to_str(v, (ecs_script_using_t*)node);
+        break;
+    case EcsAstModule:
+        flecs_script_module_to_str(v, (ecs_script_module_t*)node);
+        break;
+    case EcsAstAnnotation:
+        flecs_script_annot_to_str(v, (ecs_script_annot_t*)node);
+        break;
+    case EcsAstAssembly:
+        flecs_script_assembly_to_str(v, (ecs_script_assembly_node_t*)node);
+        break;
+    case EcsAstConst:
+    case EcsAstProp:
+        flecs_script_var_node_to_str(v, (ecs_script_var_node_t*)node);
+        break;
+    case EcsAstEntity:
+        flecs_script_entity_to_str(v, (ecs_script_entity_t*)node);
+        break;
+    case EcsAstPairScope:
+        flecs_script_pair_scope_to_str(v, (ecs_script_pair_scope_t*)node);
+        break;
+    case EcsAstIf:
+        flecs_script_if_to_str(v, (ecs_script_if_t*)node);
+        break;
     }
 
-    return result;
+    return 0;
 }
 
-bool flecs_rule_trivial_test_w_wildcards(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    bool first,
-    int32_t term_count)
+int ecs_script_ast_to_buf(
+    ecs_script_t *script,
+    ecs_strbuf_t *buf)
 {
-    bool result = flecs_rule_trivial_test(
-        rule, ctx, first, term_count);
-    if (result) {
-        ecs_iter_t *it = ctx->it;
-        ecs_table_t *table = ctx->vars[0].range.table;
-        int32_t t;
-        for (t = 0; t < term_count; t ++) {
-            it->ids[t] = table->type.array[it->columns[t] - 1];
-        }
+    ecs_check(script != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(buf != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_script_str_visitor_t v = { .buf = buf };
+    if (ecs_script_visit(script, &v, flecs_script_stmt_to_str)) {
+        goto error;
     }
 
-    return result;
+    return 0;
+error:
+    ecs_strbuf_reset(buf);
+    return - 1;
 }
 
-bool flecs_rule_trivial_search_nodata(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t term_count)
+char* ecs_script_ast_to_str(
+    ecs_script_t *script)
 {
-    const ecs_filter_t *filter = &rule->filter;
-    int32_t t;
-    ecs_term_t *terms = filter->terms;
-    ecs_iter_t *it = ctx->it;
-
-    if (!flecs_rule_trivial_search_init(ctx, op_ctx, filter, first)) {
-        return false;
+    ecs_check(script != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    if (ecs_script_ast_to_buf(script, &buf)) {
+        goto error;
     }
 
-    do {
-        const ecs_table_record_t *tr = flecs_table_cache_next(
-            &op_ctx->it, ecs_table_record_t);
-        if (!tr) {
-            return false;
-        }
-
-        ecs_table_t *table = tr->hdr.table;
-        if (table->flags & (EcsTableIsPrefab|EcsTableIsDisabled)) {
-            continue;
-        }
-
-        for (t = 1; t < term_count; t ++) {
-            ecs_term_t *term = &terms[t];
-            const ecs_table_record_t *tr_with = flecs_id_record_get_table(
-                term->idr, table);
-            if (!tr_with) {
-                break;
-            }
-
-            it->columns[t] = tr_with->index + 1;
-        }
-
-        if (t == term_count) {
-            ctx->vars[0].range.table = table;
-            ctx->vars[0].range.count = 0;
-            ctx->vars[0].range.offset = 0;
-            it->columns[0] = tr->index + 1;
-            break;
-        }
-    } while (true);
-
-    return true;
+    return ecs_strbuf_get(&buf);
+error:
+    return NULL;
 }
 
 #endif
@@ -69526,7 +70227,7 @@ ecs_mixins_t ecs_system_t_mixins = {
 
 /* -- Public API -- */
 
-ecs_entity_t ecs_run_intern(
+ecs_entity_t flecs_run_intern(
     ecs_world_t *world,
     ecs_stage_t *stage,
     ecs_entity_t system,
@@ -69534,8 +70235,6 @@ ecs_entity_t ecs_run_intern(
     int32_t stage_index,
     int32_t stage_count,    
     ecs_ftime_t delta_time,
-    int32_t offset,
-    int32_t limit,
     void *param) 
 {
     ecs_ftime_t time_elapsed = delta_time;
@@ -69582,28 +70281,22 @@ ecs_entity_t ecs_run_intern(
     if (stage) {
         thread_ctx = stage->thread_ctx;
     } else {
-        stage = &world->stages[0];
+        stage = world->stages[0];
     }
 
     /* Prepare the query iterator */
-    ecs_iter_t pit, wit, qit = ecs_query_iter(thread_ctx, system_data->query);
+    ecs_iter_t wit, qit = ecs_query_iter(thread_ctx, system_data->query);
     ecs_iter_t *it = &qit;
 
     qit.system = system;
     qit.delta_time = delta_time;
     qit.delta_system_time = time_elapsed;
-    qit.frame_offset = offset;
     qit.param = param;
     qit.ctx = system_data->ctx;
     qit.binding_ctx = system_data->binding_ctx;
 
     flecs_defer_begin(world, stage);
 
-    if (offset || limit) {
-        pit = ecs_page_iter(it, offset, limit);
-        it = &pit;
-    }
-
     if (stage_count > 1 && system_data->multi_threaded) {
         wit = ecs_worker_iter(it, stage_index, stage_count);
         it = &wit;
@@ -69616,7 +70309,7 @@ ecs_entity_t ecs_run_intern(
     ecs_run_action_t run = system_data->run;
     if (run) {
         run(it);
-    } else if (system_data->query->filter.term_count) {
+    } else if (system_data->query->term_count) {
         if (it == &qit) {
             while (ecs_query_next(&qit)) {
                 action(&qit);
@@ -69644,21 +70337,6 @@ ecs_entity_t ecs_run_intern(
 
 /* -- Public API -- */
 
-ecs_entity_t ecs_run_w_filter(
-    ecs_world_t *world,
-    ecs_entity_t system,
-    ecs_ftime_t delta_time,
-    int32_t offset,
-    int32_t limit,
-    void *param)
-{
-    ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_system_t *system_data = ecs_poly_get(world, system, ecs_system_t);
-    ecs_assert(system_data != NULL, ECS_INVALID_PARAMETER, NULL);
-    return ecs_run_intern(world, stage, system, system_data, 0, 0, delta_time, 
-        offset, limit, param);
-}
-
 ecs_entity_t ecs_run_worker(
     ecs_world_t *world,
     ecs_entity_t system,
@@ -69668,12 +70346,12 @@ ecs_entity_t ecs_run_worker(
     void *param)
 {
     ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_system_t *system_data = ecs_poly_get(world, system, ecs_system_t);
+    ecs_system_t *system_data = flecs_poly_get(world, system, ecs_system_t);
     ecs_assert(system_data != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    return ecs_run_intern(
+    return flecs_run_intern(
         world, stage, system, system_data, stage_index, stage_count, 
-        delta_time, 0, 0, param);
+        delta_time, param);
 }
 
 ecs_entity_t ecs_run(
@@ -69682,14 +70360,18 @@ ecs_entity_t ecs_run(
     ecs_ftime_t delta_time,
     void *param)
 {
-    return ecs_run_w_filter(world, system, delta_time, 0, 0, param);
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
+    ecs_system_t *system_data = flecs_poly_get(world, system, ecs_system_t);
+    ecs_assert(system_data != NULL, ECS_INVALID_PARAMETER, NULL);
+    return flecs_run_intern(
+        world, stage, system, system_data, 0, 0, delta_time, param);
 }
 
 ecs_query_t* ecs_system_get_query(
     const ecs_world_t *world,
     ecs_entity_t system)
 {
-    const ecs_system_t *s = ecs_poly_get(world, system, ecs_system_t);
+    const ecs_system_t *s = flecs_poly_get(world, system, ecs_system_t);
     if (s) {
         return s->query;
     } else {
@@ -69701,7 +70383,7 @@ void* ecs_system_get_ctx(
     const ecs_world_t *world,
     ecs_entity_t system)
 {
-    const ecs_system_t *s = ecs_poly_get(world, system, ecs_system_t);
+    const ecs_system_t *s = flecs_poly_get(world, system, ecs_system_t);
     if (s) {
         return s->ctx;
     } else {
@@ -69713,7 +70395,7 @@ void* ecs_system_get_binding_ctx(
     const ecs_world_t *world,
     ecs_entity_t system)
 {
-    const ecs_system_t *s = ecs_poly_get(world, system, ecs_system_t);
+    const ecs_system_t *s = flecs_poly_get(world, system, ecs_system_t);
     if (s) {
         return s->binding_ctx;
     } else {
@@ -69732,7 +70414,7 @@ void flecs_system_fini(ecs_system_t *sys) {
         sys->binding_ctx_free(sys->binding_ctx);
     }
 
-    ecs_poly_free(sys, ecs_system_t);
+    flecs_poly_free(sys, ecs_system_t);
 }
 
 static
@@ -69770,28 +70452,30 @@ ecs_entity_t ecs_system_init(
     ecs_world_t *world,
     const ecs_system_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_system_desc_t was not initialized to zero");
     ecs_assert(!(world->flags & EcsWorldReadonly), 
         ECS_INVALID_WHILE_READONLY, NULL);
 
     ecs_entity_t entity = desc->entity;
     if (!entity) {
-        entity = ecs_new(world, 0);
+        entity = ecs_entity(world, {0});
     }
-    EcsPoly *poly = ecs_poly_bind(world, entity, ecs_system_t);
+
+    EcsPoly *poly = flecs_poly_bind(world, entity, ecs_system_t);
     if (!poly->poly) {
-        ecs_system_t *system = ecs_poly_new(ecs_system_t);
+        ecs_system_t *system = flecs_poly_new(ecs_system_t);
         ecs_assert(system != NULL, ECS_INTERNAL_ERROR, NULL);
         
         poly->poly = system;
         system->world = world;
-        system->dtor = (ecs_poly_dtor_t)flecs_system_fini;
+        system->dtor = (flecs_poly_dtor_t)flecs_system_fini;
         system->entity = entity;
 
         ecs_query_desc_t query_desc = desc->query;
-        query_desc.filter.entity = entity;
+        query_desc.entity = entity;
 
         ecs_query_t *query = ecs_query_init(world, &query_desc);
         if (!query) {
@@ -69800,10 +70484,10 @@ ecs_entity_t ecs_system_init(
         }
 
         /* Prevent the system from moving while we're initializing */
-        flecs_defer_begin(world, &world->stages[0]);
+        flecs_defer_begin(world, world->stages[0]);
 
         system->query = query;
-        system->query_entity = query->filter.entity;
+        system->query_entity = query->entity;
 
         system->run = desc->run;
         system->action = desc->callback;
@@ -69817,7 +70501,7 @@ ecs_entity_t ecs_system_init(
         system->tick_source = desc->tick_source;
 
         system->multi_threaded = desc->multi_threaded;
-        system->no_readonly = desc->no_readonly;
+        system->immediate = desc->immediate;
 
         flecs_system_init_timer(world, entity, desc);
 
@@ -69828,7 +70512,7 @@ ecs_entity_t ecs_system_init(
 
         ecs_defer_end(world);            
     } else {
-        ecs_poly_assert(poly->poly, ecs_system_t);
+        flecs_poly_assert(poly->poly, ecs_system_t);
         ecs_system_t *system = (ecs_system_t*)poly->poly;
 
         if (desc->run) {
@@ -69861,20 +70545,20 @@ ecs_entity_t ecs_system_init(
         if (desc->binding_ctx_free) {
             system->binding_ctx_free = desc->binding_ctx_free;
         }
-        if (desc->query.filter.instanced) {
-            ECS_BIT_SET(system->query->filter.flags, EcsFilterIsInstanced);
+        if (desc->query.flags & EcsQueryIsInstanced) {
+            ECS_BIT_SET(system->query->flags, EcsQueryIsInstanced);
         }
         if (desc->multi_threaded) {
             system->multi_threaded = desc->multi_threaded;
         }
-        if (desc->no_readonly) {
-            system->no_readonly = desc->no_readonly;
+        if (desc->immediate) {
+            system->immediate = desc->immediate;
         }
 
         flecs_system_init_timer(world, entity, desc);
     }
 
-    ecs_poly_modified(world, entity, ecs_system_t);
+    flecs_poly_modified(world, entity, ecs_system_t);
 
     return entity;
 error:
diff --git a/flecs.h b/flecs.h
index fb52e3b64..90673d470 100644
--- a/flecs.h
+++ b/flecs.h
@@ -33,9 +33,9 @@
  */
 
 /* Flecs version macro */
-#define FLECS_VERSION_MAJOR 3
-#define FLECS_VERSION_MINOR 2
-#define FLECS_VERSION_PATCH 12
+#define FLECS_VERSION_MAJOR 4
+#define FLECS_VERSION_MINOR 0
+#define FLECS_VERSION_PATCH 0
 #define FLECS_VERSION FLECS_VERSION_IMPL(\
     FLECS_VERSION_MAJOR, FLECS_VERSION_MINOR, FLECS_VERSION_PATCH)
 
@@ -64,11 +64,6 @@
  */
 // #define FLECS_LEGACY
 
-/** @def FLECS_NO_DEPRECATED_WARNINGS
- * disables deprecated warnings
- */
-#define FLECS_NO_DEPRECATED_WARNINGS
-
 /** @def FLECS_ACCURATE_COUNTERS
  * Define to ensure that global counters used for statistics (such as the
  * allocation counters in the OS API) are accurate in multithreaded
@@ -132,7 +127,17 @@
  */
 // #define FLECS_KEEP_ASSERT
 
-/** @def FLECS_CUSTOM_BUILD
+/** \def FLECS_CPP_NO_AUTO_REGISTRATION
+ * When set, the C++ API will require that components are registered before they
+ * are used. This is useful in multithreaded applications, where components need
+ * to be registered beforehand, and to catch issues in projects where component 
+ * registration is mandatory. Disabling automatic component registration also
+ * slightly improves performance.
+ * The C API is not affected by this feature.
+ */
+// #define FLECS_CPP_NO_AUTO_REGISTRATION
+
+/** \def FLECS_CUSTOM_BUILD
  * This macro lets you customize which addons to build flecs with.
  * Without any addons Flecs is just a minimal ECS storage, but addons add
  * features such as systems, scheduling and reflection. If an addon is disabled,
@@ -175,10 +180,7 @@
 // #define FLECS_C          /**< C API convenience macros, always enabled */
 #define FLECS_CPP           /**< C++ API */
 #define FLECS_MODULE        /**< Module support */
-#define FLECS_PARSER        /**< String parser for queries */
-#define FLECS_PLECS         /**< ECS data definition format */
-#define FLECS_RULES         /**< Constraint solver for advanced queries */
-#define FLECS_SNAPSHOT      /**< Snapshot & restore ECS data */
+#define FLECS_SCRIPT         /**< ECS data definition format */
 #define FLECS_STATS         /**< Access runtime statistics */
 #define FLECS_MONITOR       /**< Track runtime statistics periodically */
 #define FLECS_METRICS       /**< Expose component data as statistics */
@@ -187,9 +189,7 @@
 #define FLECS_PIPELINE      /**< Pipeline support */
 #define FLECS_TIMER         /**< Timer support */
 #define FLECS_META          /**< Reflection support */
-#define FLECS_META_C        /**< Utilities for populating reflection data */
 #define FLECS_UNITS         /**< Builtin standard units */
-#define FLECS_EXPR          /**< Parsing strings to/from component values */
 #define FLECS_JSON          /**< Parsing JSON to/from component values */
 #define FLECS_DOC           /**< Document entities & components */
 #define FLECS_LOG           /**< When enabled ECS provides more detailed logs */
@@ -263,21 +263,39 @@
 #define FLECS_ID_DESC_MAX (32)
 #endif
 
-/** @def FLECS_TERM_DESC_MAX
- * Maximum number of terms in ecs_filter_desc_t */
-#define FLECS_TERM_DESC_MAX (16)
-
-/** @def FLECS_EVENT_DESC_MAX
+/** \def FLECS_EVENT_DESC_MAX
  * Maximum number of events in ecs_observer_desc_t */
+#ifndef FLECS_EVENT_DESC_MAX
 #define FLECS_EVENT_DESC_MAX (8)
+#endif
 
 /** @def FLECS_VARIABLE_COUNT_MAX
  * Maximum number of query variables per query */
 #define FLECS_VARIABLE_COUNT_MAX (64)
 
+/** \def FLECS_TERM_COUNT_MAX 
+ * Maximum number of terms in queries. Should not be set higher than 64. */
+#ifndef FLECS_TERM_COUNT_MAX
+#define FLECS_TERM_COUNT_MAX 16
+#endif
+
+/** \def FLECS_TERM_ARG_COUNT_MAX 
+ * Maximum number of arguments for a term. */
+#ifndef FLECS_TERM_ARG_COUNT_MAX
+#define FLECS_TERM_ARG_COUNT_MAX (16)
+#endif
+
+/** \def FLECS_QUERY_VARIABLE_COUNT_MAX
+ * Maximum number of query variables per query */
+#ifndef FLECS_QUERY_VARIABLE_COUNT_MAX
+#define FLECS_QUERY_VARIABLE_COUNT_MAX (64)
+#endif
+
 /** @def FLECS_QUERY_SCOPE_NESTING_MAX
  * Maximum nesting depth of query scopes */
+#ifndef FLECS_QUERY_SCOPE_NESTING_MAX
 #define FLECS_QUERY_SCOPE_NESTING_MAX (8)
+#endif
 
 /** @} */
 
@@ -361,8 +379,8 @@ extern "C" {
 #define EcsIdTraversable               (1u << 8)
 #define EcsIdTag                       (1u << 9)
 #define EcsIdWith                      (1u << 10)
-#define EcsIdUnion                     (1u << 11)
 #define EcsIdAlwaysOverride            (1u << 12)
+#define EcsIdCanToggle                 (1u << 13)
 
 #define EcsIdHasOnAdd                  (1u << 16) /* Same values as table flags */
 #define EcsIdHasOnRemove               (1u << 17) 
@@ -395,49 +413,53 @@ extern "C" {
 #define EcsIterIsValid                 (1u << 0u)  /* Does iterator contain valid result */
 #define EcsIterNoData                  (1u << 1u)  /* Does iterator provide (component) data */
 #define EcsIterIsInstanced             (1u << 2u)  /* Is iterator instanced */
-#define EcsIterHasShared               (1u << 3u)  /* Does result have shared terms */
-#define EcsIterTableOnly               (1u << 4u)  /* Result only populates table */
-#define EcsIterEntityOptional          (1u << 5u)  /* Treat terms with entity subject as optional */
-#define EcsIterNoResults               (1u << 6u)  /* Iterator has no results */
-#define EcsIterIgnoreThis              (1u << 7u)  /* Only evaluate non-this terms */
-#define EcsIterMatchVar                (1u << 8u)  
-#define EcsIterHasCondSet              (1u << 10u) /* Does iterator have conditionally set fields */
-#define EcsIterProfile                 (1u << 11u) /* Profile iterator performance */
-#define EcsIterTrivialSearch           (1u << 12u) /* Trivial iterator mode */
-#define EcsIterTrivialSearchNoData     (1u << 13u) /* Trivial iterator w/no data */
-#define EcsIterTrivialTest             (1u << 14u) /* Trivial test mode (constrained $this) */
-#define EcsIterTrivialSearchWildcard   (1u << 15u) /* Trivial search with wildcard ids */
-#define EcsIterCppEach                 (1u << 16u) /* Uses C++ 'each' iterator */
+#define EcsIterNoResults               (1u << 3u)  /* Iterator has no results */
+#define EcsIterIgnoreThis              (1u << 4u)  /* Only evaluate non-this terms */
+#define EcsIterHasCondSet              (1u << 6u)  /* Does iterator have conditionally set fields */
+#define EcsIterProfile                 (1u << 7u)  /* Profile iterator performance */
+#define EcsIterTrivialSearch           (1u << 8u)  /* Trivial iterator mode */
+#define EcsIterTrivialSearchNoData     (1u << 9u)  /* Trivial iterator w/no data */
+#define EcsIterTrivialTest             (1u << 10u) /* Trivial test mode (constrained $this) */
+#define EcsIterTrivialTestWildcard     (1u << 11u) /* Trivial test w/wildcards */
+#define EcsIterTrivialSearchWildcard   (1u << 12u) /* Trivial search with wildcard ids */
+#define EcsIterCacheSearch             (1u << 13u) /* Cache search */
+#define EcsIterFixedInChangeComputed   (1u << 14u) /* Change detection for fixed in terms is done */
+#define EcsIterFixedInChanged          (1u << 15u) /* Fixed in terms changed */
+#define EcsIterSkip                    (1u << 16u) /* Result was skipped for change detection */
+#define EcsIterCppEach                 (1u << 17u) /* Uses C++ 'each' iterator */
+
+/* Same as event flags */
+#define EcsIterTableOnly               (1u << 18u)  /* Result only populates table */
+
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Event flags (used by ecs_event_decs_t::flags)
 ////////////////////////////////////////////////////////////////////////////////
 
-#define EcsEventTableOnly              (1u << 4u)   /* Table event (no data, same as iter flags) */
-#define EcsEventNoOnSet                (1u << 16u)  /* Don't emit OnSet/UnSet for inherited ids */
+#define EcsEventTableOnly              (1u << 18u) /* Table event (no data, same as iter flags) */
+#define EcsEventNoOnSet                (1u << 16u) /* Don't emit OnSet/UnSet for inherited ids */
+
 
 ////////////////////////////////////////////////////////////////////////////////
-//// Filter flags (used by ecs_filter_t::flags)
+//// Query flags (used by ecs_query_t::flags)
 ////////////////////////////////////////////////////////////////////////////////
 
-#define EcsFilterMatchThis             (1u << 1u)  /* Has terms that match This */
-#define EcsFilterMatchOnlyThis         (1u << 2u)  /* Has only terms that match This */
-#define EcsFilterMatchPrefab           (1u << 3u)  /* Does filter match prefabs */
-#define EcsFilterMatchDisabled         (1u << 4u)  /* Does filter match disabled entities */
-#define EcsFilterMatchEmptyTables      (1u << 5u)  /* Does filter return empty tables */
-#define EcsFilterMatchAnything         (1u << 6u)  /* False if filter has no/only Not terms */
-#define EcsFilterNoData                (1u << 7u)  /* When true, data fields won't be populated */
-#define EcsFilterIsInstanced           (1u << 8u)  /* Is filter instanced (see ecs_filter_desc_t) */
-#define EcsFilterPopulate              (1u << 9u)  /* Populate data, ignore non-matching fields */
-#define EcsFilterHasCondSet            (1u << 10u) /* Does filter have conditionally set fields */
-#define EcsFilterUnresolvedByName      (1u << 11u) /* Use by-name matching for unresolved entity identifiers */
-#define EcsFilterHasPred               (1u << 12u) /* Filter has equality predicates */
-#define EcsFilterHasScopes             (1u << 13u) /* Filter has query scopes */
-#define EcsFilterIsTrivial             (1u << 14u) /* Trivial filter */
-#define EcsFilterMatchOnlySelf         (1u << 15u) /* Filter has no up traversal */
-#define EcsFilterHasWildcards          (1u << 16u) /* Filter has no up traversal */
-#define EcsFilterOwnsStorage           (1u << 17u) /* Is ecs_filter_t object owned by filter */
-#define EcsFilterOwnsTermsStorage      (1u << 18u) /* Is terms array owned by filter */
+/* Flags that can only be set by the query implementation */
+#define EcsQueryMatchThis             (1u << 11u) /* Query has terms with $this source */
+#define EcsQueryMatchOnlyThis         (1u << 12u) /* Query only has terms with $this source */
+#define EcsQueryMatchOnlySelf         (1u << 13u) /* Query has no terms with up traversal */
+#define EcsQueryMatchWildcards        (1u << 14u) /* Query matches wildcards */
+#define EcsQueryHasCondSet            (1u << 15u) /* Query has conditionally set fields */
+#define EcsQueryHasPred               (1u << 16u) /* Query has equality predicates */
+#define EcsQueryHasScopes             (1u << 17u) /* Query has query scopes */
+#define EcsQueryHasRefs               (1u << 18u) /* Query has terms with static source */
+#define EcsQueryHasOutTerms           (1u << 19u) /* Query has [out] terms */
+#define EcsQueryHasNonThisOutTerms    (1u << 20u) /* Query has [out] terms with no $this source */
+#define EcsQueryHasMonitor            (1u << 21u) /* Query has monitor for change detection */
+#define EcsQueryIsTrivial             (1u << 22u) /* Query can use trivial evaluation function */
+#define EcsQueryHasCacheable          (1u << 23u) /* Query has cacheable terms */
+#define EcsQueryIsCacheable           (1u << 24u) /* All terms of query are cacheable */
+
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Observer flags (used by ecs_observer_t::flags)
@@ -460,11 +482,11 @@ extern "C" {
 #define EcsTableHasPairs               (1u << 6u)  /* Does the table type have pairs */
 #define EcsTableHasModule              (1u << 7u)  /* Does the table have module data */
 #define EcsTableIsDisabled             (1u << 8u)  /* Does the table type has EcsDisabled */
-#define EcsTableHasCtors               (1u << 9u)
-#define EcsTableHasDtors               (1u << 10u)
-#define EcsTableHasCopy                (1u << 11u)
-#define EcsTableHasMove                (1u << 12u)
-#define EcsTableHasUnion               (1u << 13u)
+#define EcsTableNotQueryable           (1u << 9u)  /* Table should never be returned by queries */
+#define EcsTableHasCtors               (1u << 10u)
+#define EcsTableHasDtors               (1u << 11u)
+#define EcsTableHasCopy                (1u << 12u)
+#define EcsTableHasMove                (1u << 13u)
 #define EcsTableHasToggle              (1u << 14u)
 #define EcsTableHasOverrides           (1u << 15u)
 
@@ -478,30 +500,15 @@ extern "C" {
 #define EcsTableHasOnTableDelete       (1u << 23u)
 
 #define EcsTableHasTraversable         (1u << 25u)
-#define EcsTableHasTarget              (1u << 26u)
-
 #define EcsTableMarkedForDelete        (1u << 30u)
 
 /* Composite table flags */
 #define EcsTableHasLifecycle        (EcsTableHasCtors | EcsTableHasDtors)
-#define EcsTableIsComplex           (EcsTableHasLifecycle | EcsTableHasUnion | EcsTableHasToggle)
-#define EcsTableHasAddActions       (EcsTableHasIsA | EcsTableHasUnion | EcsTableHasCtors | EcsTableHasOnAdd | EcsTableHasOnSet)
+#define EcsTableIsComplex           (EcsTableHasLifecycle | EcsTableHasToggle)
+#define EcsTableHasAddActions       (EcsTableHasIsA | EcsTableHasCtors | EcsTableHasOnAdd | EcsTableHasOnSet)
 #define EcsTableHasRemoveActions    (EcsTableHasIsA | EcsTableHasDtors | EcsTableHasOnRemove | EcsTableHasUnSet)
 
 
-////////////////////////////////////////////////////////////////////////////////
-//// Query flags (used by ecs_query_t::flags)
-////////////////////////////////////////////////////////////////////////////////
-
-#define EcsQueryHasRefs                (1u << 1u)  /* Does query have references */
-#define EcsQueryIsSubquery             (1u << 2u)  /* Is query a subquery */
-#define EcsQueryIsOrphaned             (1u << 3u)  /* Is subquery orphaned */
-#define EcsQueryHasOutTerms            (1u << 4u)  /* Does query have out terms */
-#define EcsQueryHasNonThisOutTerms     (1u << 5u)  /* Does query have non-this out terms */
-#define EcsQueryHasMonitor             (1u << 6u)  /* Does query track changes */
-#define EcsQueryTrivialIter            (1u << 7u)  /* Does the query require special features to iterate */
-
-
 ////////////////////////////////////////////////////////////////////////////////
 //// Aperiodic action flags (used by ecs_run_aperiodic)
 ////////////////////////////////////////////////////////////////////////////////
@@ -736,6 +743,20 @@ typedef uint16_t ecs_flags16_t;
 typedef uint32_t ecs_flags32_t;
 typedef uint64_t ecs_flags64_t;
 
+/* Bitmask type with compile-time defined size */
+#define ecs_flagsn_t_(bits) ecs_flags##bits##_t
+#define ecs_flagsn_t(bits) ecs_flagsn_t_(bits)
+
+/* Bitset type that can store exactly as many bits as there are terms */
+#define ecs_termset_t ecs_flagsn_t(FLECS_TERM_COUNT_MAX)
+
+/* Utility macro's for setting/clearing termset bits */
+#define ECS_TERMSET_SET(set, flag) ((set) |= (ecs_termset_t)(flag))
+#define ECS_TERMSET_CLEAR(set, flag) ((set) &= (ecs_termset_t)~(flag))
+#define ECS_TERMSET_COND(set, flag, cond) ((cond) \
+    ? (ECS_TERMSET_SET(set, flag)) \
+    : (ECS_TERMSET_CLEAR(set, flag)))
+
 /* Keep unsigned integers out of the codebase as they do more harm than good */
 typedef int32_t ecs_size_t;
 
@@ -815,11 +836,7 @@ typedef struct ecs_allocator_t ecs_allocator_t;
 /* Magic number to identify the type of the object */
 #define ecs_world_t_magic     (0x65637377)
 #define ecs_stage_t_magic     (0x65637373)
-#define ecs_query_t_magic     (0x65637371)
-#define ecs_rule_t_magic      (0x65637375)
-#define ecs_table_t_magic     (0x65637374)
-#define ecs_filter_t_magic    (0x65637366)
-#define ecs_trigger_t_magic   (0x65637372)
+#define ecs_query_t_magic     (0x65637375)
 #define ecs_observer_t_magic  (0x65637362)
 
 
@@ -845,6 +862,8 @@ typedef struct ecs_allocator_t ecs_allocator_t;
 #define ECS_PAIR_SECOND(e)            (ecs_entity_t_lo(e))
 #define ECS_HAS_RELATION(e, rel)      (ECS_HAS_ID_FLAG(e, PAIR) && (ECS_PAIR_FIRST(e) == rel))
 
+#define ECS_TERM_REF_FLAGS(ref)       ((ref)->id & EcsTermRefFlags)
+#define ECS_TERM_REF_ID(ref)          ((ref)->id & ~EcsTermRefFlags)
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Convert between C typenames and variables
@@ -867,9 +886,9 @@ typedef struct ecs_allocator_t ecs_allocator_t;
 #define ecs_pair_first(world, pair) ecs_get_alive(world, ECS_PAIR_FIRST(pair))
 #define ecs_pair_second(world, pair) ecs_get_alive(world, ECS_PAIR_SECOND(pair))
 #define ecs_pair_relation ecs_pair_first
-#define ecs_pair_object ecs_pair_second
+#define ecs_pair_target ecs_pair_second
 
-#define ecs_poly_id(tag) ecs_pair(ecs_id(EcsPoly), tag)
+#define flecs_poly_id(tag) ecs_pair(ecs_id(EcsPoly), tag)
 
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1466,6 +1485,12 @@ void flecs_bfree(
     ecs_block_allocator_t *allocator, 
     void *memory);
 
+FLECS_API
+void flecs_bfree_w_dbg_info(
+    ecs_block_allocator_t *allocator, 
+    void *memory,
+    const char *type_name);
+
 FLECS_API
 void* flecs_brealloc(
     ecs_block_allocator_t *dst, 
@@ -1479,6 +1504,100 @@ void* flecs_bdup(
 
 #endif
 
+/**
+ * @file datastructures/stack_allocator.h
+ * @brief Stack allocator.
+ */
+
+#ifndef FLECS_STACK_ALLOCATOR_H
+#define FLECS_STACK_ALLOCATOR_H
+
+/** Stack allocator for quick allocation of small temporary values */
+#define ECS_STACK_PAGE_SIZE (4096)
+
+typedef struct ecs_stack_page_t {
+    void *data;
+    struct ecs_stack_page_t *next;
+    int16_t sp;
+    uint32_t id;
+} ecs_stack_page_t;
+
+typedef struct ecs_stack_cursor_t {
+    struct ecs_stack_cursor_t *prev;
+    struct ecs_stack_page_t *page;
+    int16_t sp;
+    bool is_free;
+#ifdef FLECS_DEBUG
+    struct ecs_stack_t *owner;
+#endif
+} ecs_stack_cursor_t;
+
+typedef struct ecs_stack_t {
+    ecs_stack_page_t first;
+    ecs_stack_page_t *tail_page;
+    ecs_stack_cursor_t *tail_cursor;
+#ifdef FLECS_DEBUG
+    int32_t cursor_count;
+#endif
+} ecs_stack_t;
+
+FLECS_DBG_API
+void flecs_stack_init(
+    ecs_stack_t *stack);
+
+FLECS_DBG_API
+void flecs_stack_fini(
+    ecs_stack_t *stack);
+
+FLECS_DBG_API
+void* flecs_stack_alloc(
+    ecs_stack_t *stack, 
+    ecs_size_t size,
+    ecs_size_t align);
+
+#define flecs_stack_alloc_t(stack, T)\
+    flecs_stack_alloc(stack, ECS_SIZEOF(T), ECS_ALIGNOF(T))
+
+#define flecs_stack_alloc_n(stack, T, count)\
+    flecs_stack_alloc(stack, ECS_SIZEOF(T) * count, ECS_ALIGNOF(T))
+
+FLECS_DBG_API
+void* flecs_stack_calloc(
+    ecs_stack_t *stack, 
+    ecs_size_t size,
+    ecs_size_t align);
+
+#define flecs_stack_calloc_t(stack, T)\
+    flecs_stack_calloc(stack, ECS_SIZEOF(T), ECS_ALIGNOF(T))
+
+#define flecs_stack_calloc_n(stack, T, count)\
+    flecs_stack_calloc(stack, ECS_SIZEOF(T) * count, ECS_ALIGNOF(T))
+
+FLECS_DBG_API
+void flecs_stack_free(
+    void *ptr,
+    ecs_size_t size);
+
+#define flecs_stack_free_t(ptr, T)\
+    flecs_stack_free(ptr, ECS_SIZEOF(T))
+
+#define flecs_stack_free_n(ptr, T, count)\
+    flecs_stack_free(ptr, ECS_SIZEOF(T) * count)
+
+void flecs_stack_reset(
+    ecs_stack_t *stack);
+
+FLECS_DBG_API
+ecs_stack_cursor_t* flecs_stack_get_cursor(
+    ecs_stack_t *stack);
+
+FLECS_DBG_API
+void flecs_stack_restore_cursor(
+    ecs_stack_t *stack,
+    ecs_stack_cursor_t *cursor);
+
+#endif
+
 /**
  * @file map.h
  * @brief Map data structure.
@@ -1730,9 +1849,13 @@ void* flecs_dup(
 #define flecs_calloc_t(a, T) flecs_calloc(a, ECS_SIZEOF(T))
 #define flecs_calloc_n(a, T, count) flecs_calloc(a, ECS_SIZEOF(T) * (count))
 
-#define flecs_free(a, size, ptr) flecs_bfree(flecs_allocator_get(a, size), ptr)
-#define flecs_free_t(a, T, ptr) flecs_free(a, ECS_SIZEOF(T), ptr)
-#define flecs_free_n(a, T, count, ptr) flecs_free(a, ECS_SIZEOF(T) * (count), ptr)
+#define flecs_free(a, size, ptr)\
+    flecs_bfree(flecs_allocator_get(a, size), ptr)
+#define flecs_free_t(a, T, ptr)\
+    flecs_bfree_w_dbg_info(flecs_allocator_get(a, ECS_SIZEOF(T)), ptr, #T)
+#define flecs_free_n(a, T, count, ptr)\
+    flecs_bfree_w_dbg_info(flecs_allocator_get(a, ECS_SIZEOF(T) * (count))\
+        , ptr, #T)
 
 #define flecs_realloc(a, size_dst, size_src, ptr)\
     flecs_brealloc(flecs_allocator_get(a, size_dst),\
@@ -2304,16 +2427,16 @@ void ecs_os_set_api_defaults(void);
 #endif
 
 #define ecs_os_memcpy_t(ptr1, ptr2, T) ecs_os_memcpy(ptr1, ptr2, ECS_SIZEOF(T))
-#define ecs_os_memcpy_n(ptr1, ptr2, T, count) ecs_os_memcpy(ptr1, ptr2, ECS_SIZEOF(T) * count)
+#define ecs_os_memcpy_n(ptr1, ptr2, T, count) ecs_os_memcpy(ptr1, ptr2, ECS_SIZEOF(T) * (size_t)count)
 #define ecs_os_memcmp_t(ptr1, ptr2, T) ecs_os_memcmp(ptr1, ptr2, ECS_SIZEOF(T))
 
 #define ecs_os_memmove_t(ptr1, ptr2, T) ecs_os_memmove(ptr1, ptr2, ECS_SIZEOF(T))
-#define ecs_os_memmove_n(ptr1, ptr2, T, count) ecs_os_memmove(ptr1, ptr2, ECS_SIZEOF(T) * count)
+#define ecs_os_memmove_n(ptr1, ptr2, T, count) ecs_os_memmove(ptr1, ptr2, ECS_SIZEOF(T) * (size_t)count)
 #define ecs_os_memmove_t(ptr1, ptr2, T) ecs_os_memmove(ptr1, ptr2, ECS_SIZEOF(T))
 
 #define ecs_os_strcmp(str1, str2) strcmp(str1, str2)
 #define ecs_os_memset_t(ptr, value, T) ecs_os_memset(ptr, value, ECS_SIZEOF(T))
-#define ecs_os_memset_n(ptr, value, T, count) ecs_os_memset(ptr, value, ECS_SIZEOF(T) * count)
+#define ecs_os_memset_n(ptr, value, T, count) ecs_os_memset(ptr, value, ECS_SIZEOF(T) * (size_t)count)
 #define ecs_os_zeromem(ptr) ecs_os_memset(ptr, 0, ECS_SIZEOF(*ptr))
 
 #define ecs_os_memdup_t(ptr, T) ecs_os_memdup(ptr, ECS_SIZEOF(T))
@@ -2578,60 +2701,18 @@ typedef struct {
  * that forces the API to ignore the old component ids. */
 typedef struct ecs_world_t ecs_world_t;
 
+/** A stage enables modification while iterating and from multiple threads */
+typedef struct ecs_stage_t ecs_stage_t;
+
 /** A table stores entities and components for a specific type. */
 typedef struct ecs_table_t ecs_table_t;
 
 /** A term is a single element in a query. */
 typedef struct ecs_term_t ecs_term_t;
 
-/** A filter is an iterable data structure that describes a query.
- * Filters are used by the various query implementations in Flecs, like queries,
- * observers and rules, to describe a query. Filters themselves can also be
- * iterated. */
-typedef struct ecs_filter_t ecs_filter_t;
-
-/** A query that caches its results.
- * Queries are the fastest mechanism for finding and iterating over entities.
- * Queries cache results as a list of matching tables (vs. individual entities).
- *
- * This has several advantages:
- * - Matching is only performed when new tables are created, which is infrequent
- * - Iterating a query just walks over the cache, no actual searching is needed
- * - Iteration is table-based, which allows for direct iteration of underlying
- *   component arrays, providing good cache locality.
- *
- * While queries are the fastest mechanism to iterate entities, they are slower
- * to create than other mechanisms, as a result of having to build the cache
- * first. For this reason queries are best suited for use cases where a single
- * query can be reused many times (like is the case for systems).
- *
- * For ad-hoc queries it is recommended to use filters or rules instead, which
- * are slower to iterate, but much faster to create. Applications should at all
- * times avoid frequent creation/deletion of queries. */
+/** A query returns entities matching a list of constraints. */
 typedef struct ecs_query_t ecs_query_t;
 
-/** A rule is a query with advanced graph traversal features.
- * Rules are fast uncached queries with support for advanced graph features such
- * as the usage of query variables. A simple example of a rule that matches all
- * spaceship entities docked to a planet:
- *
- *     SpaceShip, (DockedTo, $planet), Planet($planet)
- *
- * Here, the rule traverses the DockedTo relationship, and matches Planet on the
- * target of this relationship. Through the usage of variables rules can match
- * arbitrary patterns against entity graphs. Other features supported
- * exclusively by rules are:
- * - Component inheritance
- * - Transitivity
- *
- * Rules have similar iteration performance to filters, but are slower than
- * queries. Rules and filters will eventually be merged into a single query
- * implementation. Features still lacking for rules are:
- * - Up traversal
- * - AndFrom, OrFrom, NotFrom operators
- */
-typedef struct ecs_rule_t ecs_rule_t;
-
 /** An observer is a system that is invoked when an event matches its query.
  * Observers allow applications to respond to specific events, such as adding or
  * removing a component. Observers are created by both specifying a query and
@@ -2646,10 +2727,9 @@ typedef struct ecs_rule_t ecs_rule_t;
  *   });
  * @endcode
  *
- * Observer queries can be as complex as filters. Observers only trigger when
- * the source of the event matches the full observer query. For example, an
- * OnAdd observer for Position, Velocity will only trigger after both components
- * have been added to the entity. */
+ * Observers only trigger when the source of the event matches the full observer 
+ * query. For example, an OnAdd observer for Position, Velocity will only 
+ * trigger after both components have been added to the entity. */
 typedef struct ecs_observer_t ecs_observer_t;
 
 /** An observable produces events that can be listened for by an observer.
@@ -2657,10 +2737,9 @@ typedef struct ecs_observer_t ecs_observer_t;
  * observable objects as well. */
 typedef struct ecs_observable_t ecs_observable_t;
 
-/* Type used for iterating iterable objects.
- * Iterators are a common interface across iterable objects (world, filters,
- * rules, queries, systems, observers) to provide applications with information
- * about the currently iterated result, and to store any state required for the
+/** Type used for iterating iterable objects.
+ * Iterators are objects that provide applications with information
+ * about the currently iterated result, and store any state required for the
  * iteration. */
 typedef struct ecs_iter_t ecs_iter_t;
 
@@ -2696,16 +2775,13 @@ typedef struct ecs_table_record_t ecs_table_record_t;
 /** A poly object.
  * A poly (short for polymorph) object is an object that has a variable list of
  * capabilities, determined by a mixin table. This is the current list of types
- * in the flecs API that can be used as an ecs_poly_t:
+ * in the flecs API that can be used as an flecs_poly_t:
  *
  * - ecs_world_t
  * - ecs_stage_t
  * - ecs_query_t
- * - ecs_filter_t
- * - ecs_rule_t
- * - (more to come)
  *
- * Functions that accept an ecs_poly_t argument can accept objects of these
+ * Functions that accept an flecs_poly_t argument can accept objects of these
  * types. If the object does not have the requested mixin the API will throw an
  * assert.
  *
@@ -2715,15 +2791,16 @@ typedef struct ecs_table_record_t ecs_table_record_t;
  * (in some ways it's like a mini-ECS). Additionally, each poly object has a
  * header that enables the API to do sanity checking on the input arguments.
  */
-typedef void ecs_poly_t;
+typedef void flecs_poly_t;
 
 /** Type that stores poly mixins */
 typedef struct ecs_mixins_t ecs_mixins_t;
 
-/** Header for ecs_poly_t objects. */
+/** Header for flecs_poly_t objects. */
 typedef struct ecs_header_t {
-    int32_t magic; /* Magic number verifying it's a flecs object */
-    int32_t type;  /* Magic number indicating which type of flecs object */
+    int32_t magic;    /* Magic number verifying it's a flecs object */
+    int32_t type;     /* Magic number indicating which type of flecs object */
+    int32_t refcount; /* Refcount, to enable RAII handles */
     ecs_mixins_t *mixins; /* Table with offsets to (optional) mixins */
 } ecs_header_t;
 
@@ -2757,23 +2834,6 @@ typedef void (*ecs_run_action_t)(
 typedef void (*ecs_iter_action_t)(
     ecs_iter_t *it);
 
-/** Function prototype for creating an iterator from a poly.
- * Used to create iterators from poly objects with the iterable mixin. When a
- * filter is provided, an array of two iterators must be passed to the function.
- * This allows the mixin implementation to create a chained iterator when
- * necessary, which requires two iterator objects.
- *
- * @param world The world or stage for which to create the iterator.
- * @param iterable An iterable poly object.
- * @param it The iterator to create (out parameter)
- * @param filter Optional term to filter results.
- */
-typedef void (*ecs_iter_init_action_t)(
-    const ecs_world_t *world,
-    const ecs_poly_t *iterable,
-    ecs_iter_t *it,
-    ecs_term_t *filter);
-
 /** Function prototype for iterating an iterator.
  * Stored inside initialized iterators. This allows an application to iterate
  * an iterator without needing to know what created it.
@@ -2873,23 +2933,8 @@ typedef void (*ecs_move_t)(
     const ecs_type_info_t *type_info);
 
 /* Destructor function for poly objects */
-typedef void (*ecs_poly_dtor_t)(
-    ecs_poly_t *poly);
-
-/** @} */
-
-/**
- * @defgroup mixins Poly mixin types.
- * Mixin types for poly mechanism.
- *
- * @{
- */
-
-/** Iterable mixin.
- * Allows its container to be iterated. */
-typedef struct ecs_iterable_t {
-    ecs_iter_init_action_t init; /**< Callback that creates iterator. */
-} ecs_iterable_t;
+typedef void (*flecs_poly_dtor_t)(
+    flecs_poly_t *poly);
 
 /** @} */
 
@@ -2904,6 +2949,7 @@ typedef struct ecs_iterable_t {
 typedef enum ecs_inout_kind_t {
     EcsInOutDefault,  /**< InOut for regular terms, In for shared terms */
     EcsInOutNone,     /**< Term is neither read nor written */
+    EcsInOutFilter,   /**< Same as InOutNOne + prevents term from triggering observers */
     EcsInOut,         /**< Term is both read and written */
     EcsIn,            /**< Term is only read */
     EcsOut,           /**< Term is only written */
@@ -2920,39 +2966,94 @@ typedef enum ecs_oper_kind_t {
     EcsNotFrom,       /**< Term must match none of the components from term id */
 } ecs_oper_kind_t;
 
+/** Specify cache policy for query */
+typedef enum ecs_query_cache_kind_t {
+    EcsQueryCacheDefault,   /**< Behavior determined by query creation context */
+    EcsQueryCacheAuto,      /**< Cache query terms that are cacheable */
+    EcsQueryCacheAll,       /**< Require that all query terms can be cached */
+    EcsQueryCacheNone,      /**< No caching */
+} ecs_query_cache_kind_t;
+
 /* Term id flags  */
-#define EcsSelf                       (1u << 1)  /**< Match on self */
-#define EcsUp                         (1u << 2)  /**< Match by traversing upwards */
-#define EcsDown                       (1u << 3)  /**< Match by traversing downwards (derived, cannot be set) */
-#define EcsTraverseAll                (1u << 4)  /**< Match all entities encountered through traversal */
-#define EcsCascade                    (1u << 5)  /**< Sort results breadth first */
-#define EcsDesc                       (1u << 6)  /**< Iterate groups in descending order  */
-#define EcsParent                     (1u << 7)  /**< Short for up(ChildOf) */
-#define EcsIsVariable                 (1u << 8)  /**< Term id is a variable */
-#define EcsIsEntity                   (1u << 9)  /**< Term id is an entity */
-#define EcsIsName                     (1u << 10) /**< Term id is a name (don't attempt to lookup as entity) */
-#define EcsFilter                     (1u << 11) /**< Prevent observer from triggering on term */
-#define EcsTraverseFlags              (EcsUp|EcsDown|EcsTraverseAll|EcsSelf|EcsCascade|EcsDesc|EcsParent)
-
-/* Term flags discovered & set during filter creation. Mostly used internally to
+
+/** Match on self.
+ * Can be combined with other term flags on the ecs_term_t::flags field.
+ * \ingroup queries
+ */
+#define EcsSelf                       (1llu << 63)
+
+/** Match by traversing upwards.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsUp                         (1llu << 62)
+
+/** Traverse relationship transitively.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsTrav                       (1llu << 61)
+
+/** Sort results breadth first.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsCascade                    (1llu << 60)
+
+/** Iterate groups in descending order.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsDesc                       (1llu << 59)
+
+/** Term id is a variable.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsIsVariable                 (1llu << 58)
+
+/** Term id is an entity.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsIsEntity                   (1llu << 57)
+
+/** Term id is a name (don't attempt to lookup as entity).
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsIsName                     (1llu << 56)
+
+/** All term traversal flags.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsTraverseFlags              (EcsSelf|EcsUp|EcsTrav|EcsCascade|EcsDesc)
+
+/** All term reference kind flags.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsTermRefFlags               (EcsTraverseFlags|EcsIsVariable|EcsIsEntity|EcsIsName)
+
+/* Term flags discovered & set during query creation. Mostly used internally to
  * store information relevant to queries. */
 #define EcsTermMatchAny               (1u << 0)
 #define EcsTermMatchAnySrc            (1u << 1)
-#define EcsTermSrcFirstEq             (1u << 2)
-#define EcsTermSrcSecondEq            (1u << 3)
-#define EcsTermTransitive             (1u << 4)
-#define EcsTermReflexive              (1u << 5)
-#define EcsTermIdInherited            (1u << 6)
-#define EcsTermIsTrivial              (1u << 7)
-#define EcsTermNoData                 (1u << 8)
-
-/* Term flags used for term iteration */
-#define EcsTermMatchDisabled          (1u << 7)
-#define EcsTermMatchPrefab            (1u << 8)
-
-/** Type that describes a single identifier in a term */
-typedef struct ecs_term_id_t {
-    ecs_entity_t id;            /**< Entity id. If left to 0 and flags does not
+#define EcsTermTransitive             (1u << 2)
+#define EcsTermReflexive              (1u << 3)
+#define EcsTermIdInherited            (1u << 4)
+#define EcsTermIsTrivial              (1u << 5)
+#define EcsTermNoData                 (1u << 6)
+#define EcsTermIsCacheable            (1u << 7)
+#define EcsTermIsScope                (1u << 8)
+#define EcsTermIsMember               (1u << 9)
+#define EcsTermIsToggle               (1u << 10)
+#define EcsTermKeepAlive              (1u << 11)
+
+/** Type that describes a reference to an entity or variable in a term. */
+typedef struct ecs_term_ref_t {
+    ecs_entity_t id;            /**< Entity id. If left to 0 and flags does not 
                                  * specify whether id is an entity or a variable
                                  * the id will be initialized to EcsThis.
                                  * To explicitly set the id to 0, leave the id
@@ -2963,13 +3064,7 @@ typedef struct ecs_term_id_t {
                                  * entity name. When ecs_term_t::move is true,
                                  * the API assumes ownership over the string and
                                  * will free it when the term is destroyed. */
-
-    ecs_entity_t trav;          /**< Relationship to traverse when looking for the
-                                 * component. The relationship must have
-                                 * the Traversable property. Default is IsA. */
-
-    ecs_flags32_t flags;        /**< Term flags */
-} ecs_term_id_t;
+} ecs_term_ref_t;
 
 /** Type that describes a term (single element in a query) */
 struct ecs_term_t {
@@ -2978,59 +3073,62 @@ struct ecs_term_t {
                                  * first/second members, which provide more
                                  * flexibility. */
 
-    ecs_term_id_t src;          /**< Source of term */
-    ecs_term_id_t first;        /**< Component or first element of pair */
-    ecs_term_id_t second;       /**< Second element of pair */
+    ecs_term_ref_t src;          /**< Source of term */
+    ecs_term_ref_t first;        /**< Component or first element of pair */
+    ecs_term_ref_t second;       /**< Second element of pair */
 
-    ecs_inout_kind_t inout;     /**< Access to contents matched by term */
-    ecs_oper_kind_t oper;       /**< Operator of term */
+    ecs_entity_t trav;          /**< Relationship to traverse when looking for the
+                                 * component. The relationship must have
+                                 * the Traversable property. Default is IsA. */
 
-    ecs_id_t id_flags;          /**< Id flags of term id */
-    char *name;                 /**< Name of term */
+    int16_t inout;              /**< Access to contents matched by term */
+    int16_t oper;               /**< Operator of term */
 
-    int32_t field_index;        /**< Index of field for term in iterator */
-    ecs_id_record_t *idr;       /**< Cached pointer to internal index */
+    int16_t field_index;        /**< Index of field for term in iterator */
+    ecs_flags16_t flags_;       /**< Flags that help eval, set by ecs_query_init */
+};
 
-    ecs_flags16_t flags;        /**< Flags that help eval, set by ecs_filter_init */
+/** Queries are lists of constraints (terms) that match entities. */
+struct ecs_query_t {
+    ecs_header_t hdr;
 
-    bool move;                  /**< Used by internals */
-};
+    ecs_term_t terms[FLECS_TERM_COUNT_MAX]; /**< Query terms */
+    int32_t sizes[FLECS_TERM_COUNT_MAX]; /**< Component sizes. Indexed by field */
+    ecs_id_t ids[FLECS_TERM_COUNT_MAX]; /**< Component ids. Indexed by field */
 
-/** Use $this variable to initialize user-allocated filter object */
-FLECS_API extern ecs_filter_t ECS_FILTER_INIT;
+    ecs_flags32_t flags;        /**< Query flags */
+    int8_t term_count;          /**< Number of query terms */
+    int8_t field_count;         /**< Number of fields returned by query */
 
-/** Filters allow for ad-hoc quick filtering of entity tables. */
-struct ecs_filter_t {
-    ecs_header_t hdr;
+    /* Bitmasks for quick field information lookups */
+    ecs_termset_t fixed_fields; /**< Fields with a fixed source */
+    ecs_termset_t data_fields;  /**< Fields that have data */
+    ecs_termset_t write_fields; /**< Fields that write data */
+    ecs_termset_t read_fields;  /**< Fields that read data */
+    ecs_termset_t shared_readonly_fields; /**< Fields that don't write shared data */
+    ecs_termset_t set_fields;   /**< Fields that will be set */
 
-    int8_t term_count;        /**< Number of elements in terms array */
-    int8_t field_count;       /**< Number of fields in iterator for filter */
-    ecs_flags32_t flags;      /**< Filter flags */
-    ecs_flags64_t data_fields; /**< Bitset with fields that have data */
+    ecs_query_cache_kind_t cache_kind;  /**< Caching policy of query */
 
-    ecs_term_t *terms;         /**< Array containing terms for filter */
-    char *variable_names[1];   /**< Placeholder variable names array */
-    int32_t *sizes;            /**< Field size (same for each result) */
-    ecs_id_t *ids;             /**< Array with field ids */
+    void *ctx;                  /**< User context to pass to callback */
+    void *binding_ctx;          /**< Context to be used for language bindings */
 
-    int32_t eval_count;        /**< Number of times query is evaluated */
+    ecs_entity_t entity;        /**< Entity associated with query (optional) */
+    ecs_world_t *world;         /**< World mixin */
+    ecs_stage_t *stage;         /**< Stage the query was created with */
 
-    /* Mixins */
-    ecs_entity_t entity;       /**< Entity associated with filter (optional) */
-    ecs_iterable_t iterable;   /**< Iterable mixin */
-    ecs_poly_dtor_t dtor;      /**< Dtor mixin */
-    ecs_world_t *world;        /**< World mixin */
+    int32_t eval_count;         /**< Number of times query is evaluated */
 };
 
-/* An observer reacts to events matching a filter */
+/* An observer reacts to events matching a query */
 struct ecs_observer_t {
     ecs_header_t hdr;
+    
+    ecs_query_t *query;        /**< Observer query */
 
-    ecs_filter_t filter;        /**< Query for observer */
-
-    /* Observer events */
+    /** Observer events */
     ecs_entity_t events[FLECS_EVENT_DESC_MAX];
-    int32_t event_count;
+    int32_t event_count;        /**< Number of events */
 
     ecs_iter_action_t callback; /**< See ecs_observer_desc_t::callback */
     ecs_run_action_t run;       /**< See ecs_observer_desc_t::run */
@@ -3043,16 +3141,8 @@ struct ecs_observer_t {
 
     ecs_observable_t *observable; /**< Observable for observer */
 
-    int32_t *last_event_id;     /**< Last handled event id */
-    int32_t last_event_id_storage;
-
-    ecs_id_t register_id;       /**< Id observer is registered with (single term observers only) */
-    int32_t term_index;         /**< Index of the term in parent observer (single term observers only) */
-
-    ecs_flags32_t flags;        /**< Observer flags */
-
-    /* Mixins */
-    ecs_poly_dtor_t dtor;
+    ecs_world_t *world;         /**< The world */
+    ecs_entity_t entity;        /**< Entity associated with observer */
 };
 
 /** @} */
@@ -3139,23 +3229,16 @@ extern "C" {
 //// Opaque types
 ////////////////////////////////////////////////////////////////////////////////
 
-/** A stage enables modification while iterating and from multiple threads */
-typedef struct ecs_stage_t ecs_stage_t;
-
 /** Table data */
 typedef struct ecs_data_t ecs_data_t;
 
-/* Switch list */
-typedef struct ecs_switch_t ecs_switch_t;
-
 /* Cached query table data */
-typedef struct ecs_query_table_match_t ecs_query_table_match_t;
+typedef struct ecs_query_cache_table_match_t ecs_query_cache_table_match_t;
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Non-opaque types
 ////////////////////////////////////////////////////////////////////////////////
 
-/** Mixin for emitting events to triggers/observers */
 /** All observers for a specific event */
 typedef struct ecs_event_record_t {
     struct ecs_event_id_record_t *any;
@@ -3179,7 +3262,7 @@ struct ecs_record_t {
     ecs_id_record_t *idr; /* Id record to (*, entity) for target entities */
     ecs_table_t *table;   /* Identifies a type (and table) in world */
     uint32_t row;         /* Table row of the entity */
-    int32_t dense;        /* Index in dense array */    
+    int32_t dense;        /* Index in dense array of entity index */    
 };
 
 /** Range in table */
@@ -3209,18 +3292,6 @@ struct ecs_ref_t {
     ecs_record_t *record;   /* Entity index record */
 };
 
-/* Cursor to stack allocator. Type is public to allow for white box testing. */
-struct ecs_stack_page_t;
-
-typedef struct ecs_stack_cursor_t {
-    struct ecs_stack_cursor_t *prev;
-    struct ecs_stack_page_t *page;
-    int16_t sp;
-    bool is_free;
-#ifdef FLECS_DEBUG
-    struct ecs_stack_t *owner;
-#endif
-} ecs_stack_cursor_t;
 
 /* Page-iterator specific data */
 typedef struct ecs_page_iter_t {
@@ -3241,86 +3312,40 @@ typedef struct ecs_table_cache_iter_t {
     struct ecs_table_cache_hdr_t *next_list;
 } ecs_table_cache_iter_t;
 
-/** Term-iterator specific data */
-typedef struct ecs_term_iter_t {
-    ecs_term_t term;
-    ecs_id_record_t *self_index;
-    ecs_id_record_t *set_index;
-
-    ecs_id_record_t *cur;
+/** Each iterator */
+typedef struct ecs_each_iter_t {
     ecs_table_cache_iter_t it;
-    int32_t index;
-    int32_t observed_table_count;
-    
-    ecs_table_t *table;
-    int32_t cur_match;
-    int32_t match_count;
-    int32_t last_column;
-
-    bool empty_tables;
-
-    /* Storage */
-    ecs_id_t id;
-    int32_t column;
-    ecs_entity_t subject;
-    ecs_size_t size;
-    void *ptr;
-} ecs_term_iter_t;
-
-typedef enum ecs_iter_kind_t {
-    EcsIterEvalCondition,
-    EcsIterEvalTables,
-    EcsIterEvalChain,
-    EcsIterEvalNone
-} ecs_iter_kind_t;
-
-/** Filter-iterator specific data */
-typedef struct ecs_filter_iter_t {
-    const ecs_filter_t *filter;
-    ecs_iter_kind_t kind; 
-    ecs_term_iter_t term_iter;
-    int32_t matches_left;
-    int32_t pivot_term;
-} ecs_filter_iter_t;
-
-/** Query-iterator specific data */
-typedef struct ecs_query_iter_t {
-    ecs_query_t *query;
-    ecs_query_table_match_t *node, *prev, *last;
-    int32_t sparse_smallest;
-    int32_t sparse_first;
-    int32_t bitset_first;
-    int32_t skip_count;
-} ecs_query_iter_t;
 
-/** Snapshot-iterator specific data */
-typedef struct ecs_snapshot_iter_t {
-    ecs_filter_t filter;
-    ecs_vec_t tables; /* ecs_table_leaf_t */
-    int32_t index;
-} ecs_snapshot_iter_t;
+    /* Storage for iterator fields */
+    ecs_id_t ids;
+    ecs_entity_t sources;
+    ecs_size_t sizes;
+    int32_t columns;
+    void *ptrs;
+} ecs_each_iter_t;
 
-typedef struct ecs_rule_op_profile_t {
+typedef struct ecs_query_op_profile_t {
     int32_t count[2]; /* 0 = enter, 1 = redo */
-} ecs_rule_op_profile_t;
-
-/** Rule-iterator specific data */
-typedef struct ecs_rule_iter_t {
-    const ecs_rule_t *rule;
-    struct ecs_var_t *vars;              /* Variable storage */
-    const struct ecs_rule_var_t *rule_vars;
-    const struct ecs_rule_op_t *ops;
-    struct ecs_rule_op_ctx_t *op_ctx;    /* Operation-specific state */
+} ecs_query_op_profile_t;
+
+/** Query iterator */
+typedef struct ecs_query_iter_t {
+    const ecs_query_t *query;
+    struct ecs_var_t *vars;               /* Variable storage */
+    const struct ecs_query_var_t *query_vars;
+    const struct ecs_query_op_t *ops;
+    struct ecs_query_op_ctx_t *op_ctx;    /* Operation-specific state */
+    ecs_query_cache_table_match_t *node, *prev, *last; /* For cached iteration */
     uint64_t *written;
-    ecs_flags32_t source_set;
+    int32_t skip_count;
 
 #ifdef FLECS_DEBUG
-    ecs_rule_op_profile_t *profile;
+    ecs_query_op_profile_t *profile;
 #endif
 
     int16_t op;
     int16_t sp;
-} ecs_rule_iter_t;
+} ecs_query_iter_t;
 
 /* Bits for tracking whether a cache was used/whether the array was allocated.
  * Used by flecs_iter_init, flecs_iter_validate and ecs_iter_fini. 
@@ -3329,8 +3354,7 @@ typedef struct ecs_rule_iter_t {
 #define flecs_iter_cache_columns       (1u << 1u)
 #define flecs_iter_cache_sources       (1u << 2u)
 #define flecs_iter_cache_ptrs          (1u << 3u)
-#define flecs_iter_cache_match_indices (1u << 4u)
-#define flecs_iter_cache_variables     (1u << 5u)
+#define flecs_iter_cache_variables     (1u << 4u)
 #define flecs_iter_cache_all           (255)
 
 /* Inline iterator arrays to prevent allocations for small array sizes */
@@ -3344,88 +3368,16 @@ typedef struct ecs_iter_cache_t {
  * progress & to provide builtin storage. */
 typedef struct ecs_iter_private_t {
     union {
-        ecs_term_iter_t term;
-        ecs_filter_iter_t filter;
         ecs_query_iter_t query;
-        ecs_rule_iter_t rule;
-        ecs_snapshot_iter_t snapshot;
         ecs_page_iter_t page;
         ecs_worker_iter_t worker;
+        ecs_each_iter_t each;
     } iter;                       /* Iterator specific data */
 
-    void *entity_iter;            /* Filter applied after matching a table */
+    void *entity_iter;            /* Query applied after matching a table */
     ecs_iter_cache_t cache;       /* Inline arrays to reduce allocations */
 } ecs_iter_private_t;
 
-/** Iterator */
-struct ecs_iter_t {
-    /* World */
-    ecs_world_t *world;           /* The world */
-    ecs_world_t *real_world;      /* Actual world. This differs from world when in readonly mode */
-
-    /* Matched data */
-    ecs_entity_t *entities;       /* Entity identifiers */
-    void **ptrs;                  /* Pointers to components. Array if from this, pointer if not. */
-    ecs_size_t *sizes;            /* Component sizes */
-    ecs_table_t *table;           /* Current table */
-    ecs_table_t *other_table;     /* Prev or next table when adding/removing */
-    ecs_id_t *ids;                /* (Component) ids */
-    ecs_var_t *variables;         /* Values of variables (if any) */
-    int32_t *columns;             /* Query term to table column mapping */
-    ecs_entity_t *sources;        /* Entity on which the id was matched (0 if same as entities) */
-    int32_t *match_indices;       /* Indices of current match for term. Allows an iterator to iterate
-                                   * all permutations of wildcards in query. */
-    ecs_ref_t *references;        /* Cached refs to components (if iterating a cache) */
-    ecs_flags64_t constrained_vars; /* Bitset that marks constrained variables */
-    uint64_t group_id;            /* Group id for table, if group_by is used */
-    int32_t field_count;          /* Number of fields in iterator */
-
-    /* Input information */
-    ecs_entity_t system;          /* The system (if applicable) */
-    ecs_entity_t event;           /* The event (if applicable) */
-    ecs_id_t event_id;            /* The (component) id for the event */
-    int32_t event_cur;            /* Unique event id. Used to dedup observer calls */
-
-    /* Query information */
-    const ecs_filter_t *query;    /* Query being evaluated */
-    ecs_term_t *terms;            /* Term array of query being evaluated */
-    int32_t table_count;          /* Active table count for query */
-    int32_t term_index;           /* Index of term that emitted an event.
-                                   * This field will be set to the 'index' field
-                                   * of an observer term. */
-    int32_t variable_count;       /* Number of variables for query */
-    char **variable_names;        /* Names of variables (if any) */
-
-    /* Context */
-    void *param;                  /* Param passed to ecs_run */
-    void *ctx;                    /* System context */
-    void *binding_ctx;            /* Binding context */
-
-    /* Time */
-    ecs_ftime_t delta_time;       /* Time elapsed since last frame */
-    ecs_ftime_t delta_system_time;/* Time elapsed since last system invocation */
-
-    /* Iterator counters */
-    int32_t frame_offset;         /* Offset relative to start of iteration */
-    int32_t offset;               /* Offset relative to current table */
-    int32_t count;                /* Number of entities to iterate */
-    int32_t instance_count;       /* Number of entities to iterate before next table */
-
-    /* Iterator flags */
-    ecs_flags32_t flags;
-
-    ecs_entity_t interrupted_by;  /* When set, system execution is interrupted */
-
-    ecs_iter_private_t priv;      /* Private data */
-
-    /* Chained iterators */
-    ecs_iter_next_action_t next;  /* Function to progress iterator */
-    ecs_iter_action_t callback;   /* Callback of system or observer */
-    ecs_iter_action_t set_var;    /* Invoked after setting variable (optionally set) */
-    ecs_iter_fini_action_t fini;  /* Function to cleanup iterator resources */
-    ecs_iter_t *chain_it;         /* Optional, allows for creating iterator chains */
-};
-
 #ifdef __cplusplus
 }
 #endif
@@ -3466,61 +3418,182 @@ extern "C" {
 //// Global type handles
 ////////////////////////////////////////////////////////////////////////////////
 
-/** This allows passing 0 as type to functions that accept ids */
-#define FLECS_ID0ID_ 0
-
 FLECS_API
-char* ecs_module_path_from_c(
+char* flecs_module_path_from_c(
     const char *c_name);
 
-bool ecs_identifier_is_0(
+bool flecs_identifier_is_0(
     const char *id);
 
 /* Constructor that zeromem's a component value */
 FLECS_API
-void ecs_default_ctor(
+void flecs_default_ctor(
     void *ptr, 
     int32_t count, 
     const ecs_type_info_t *ctx);
 
 /* Create allocated string from format */
 FLECS_DBG_API
-char* ecs_vasprintf(
+char* flecs_vasprintf(
     const char *fmt,
     va_list args);
 
 /* Create allocated string from format */
 FLECS_API
-char* ecs_asprintf(
+char* flecs_asprintf(
     const char *fmt,
     ...);
 
-/* Convert identifier to snake case */
+/** Write an escaped character.
+ * Write a character to an output string, insert escape character if necessary.
+ *
+ * @param out The string to write the character to.
+ * @param in The input character.
+ * @param delimiter The delimiter used (for example '"')
+ * @return Pointer to the character after the last one written.
+ */
 FLECS_API
-char* flecs_to_snake_case(
-    const char *str);
-
-FLECS_DBG_API
-int32_t flecs_table_observed_count(
-    const ecs_table_t *table);
+char* flecs_chresc(
+    char *out,
+    char in,
+    char delimiter);
 
-FLECS_DBG_API
-void flecs_dump_backtrace(
-    void *stream);
+/** Parse an escaped character.
+ * Parse a character with a potential escape sequence.
+ *
+ * @param in Pointer to character in input string.
+ * @param out Output string.
+ * @return Pointer to the character after the last one read.
+ */
+const char* flecs_chrparse(
+    const char *in,
+    char *out);
 
+/** Write an escaped string.
+ * Write an input string to an output string, escape characters where necessary.
+ * To determine the size of the output string, call the operation with a NULL
+ * argument for 'out', and use the returned size to allocate a string that is
+ * large enough.
+ *
+ * @param out Pointer to output string (must be).
+ * @param size Maximum number of characters written to output.
+ * @param delimiter The delimiter used (for example '"').
+ * @param in The input string.
+ * @return The number of characters that (would) have been written.
+ */
 FLECS_API
-ecs_iter_t flecs_children(
-    const ecs_world_t *stage,
-    ecs_entity_t rel,
-    ecs_entity_t parent);
+ecs_size_t flecs_stresc(
+    char *out,
+    ecs_size_t size,
+    char delimiter,
+    const char *in);
 
-/** Calculate offset from address */
-#ifdef __cplusplus
-#define ECS_OFFSET(o, offset) reinterpret_cast<void*>((reinterpret_cast<uintptr_t>(o)) + (static_cast<uintptr_t>(offset)))
-#else
-#define ECS_OFFSET(o, offset) (void*)(((uintptr_t)(o)) + ((uintptr_t)(offset)))
-#endif
-#define ECS_OFFSET_T(o, T) ECS_OFFSET(o, ECS_SIZEOF(T))
+/** Return escaped string.
+ * Return escaped version of input string. Same as flecs_stresc(), but returns an
+ * allocated string of the right size.
+ *
+ * @param delimiter The delimiter used (for example '"').
+ * @param in The input string.
+ * @return Escaped string.
+ */
+FLECS_API
+char* flecs_astresc(
+    char delimiter,
+    const char *in);
+
+/** Skip whitespace and newline characters.
+ * This function skips whitespace characters.
+ *
+ * @param ptr Pointer to (potential) whitespaces to skip.
+ * @return Pointer to the next non-whitespace character.
+ */
+FLECS_API
+const char* flecs_parse_ws_eol(
+    const char *ptr);
+
+/** Parse digit.
+ * This function will parse until the first non-digit character is found. The
+ * provided expression must contain at least one digit character.
+ *
+ * @param ptr The expression to parse.
+ * @param token The output buffer.
+ * @return Pointer to the first non-digit character.
+ */
+FLECS_API
+const char* flecs_parse_digit(
+    const char *ptr,
+    char *token);
+
+/* Convert identifier to snake case */
+FLECS_API
+char* flecs_to_snake_case(
+    const char *str);
+
+FLECS_DBG_API
+int32_t flecs_table_observed_count(
+    const ecs_table_t *table);
+
+FLECS_DBG_API
+void flecs_dump_backtrace(
+    void *stream);
+
+/* Suspend/resume readonly state. To fully support implicit registration of
+ * components, it should be possible to register components while the world is
+ * in readonly mode. It is not uncommon that a component is used first from
+ * within a system, which are often ran while in readonly mode.
+ * 
+ * Suspending readonly mode is only allowed when the world is not multithreaded.
+ * When a world is multithreaded, it is not safe to (even temporarily) leave
+ * readonly mode, so a multithreaded application should always explicitly
+ * register components in advance. 
+ * 
+ * These operations also suspend deferred mode.
+ */
+typedef struct ecs_suspend_readonly_state_t {
+    bool is_readonly;
+    bool is_deferred;
+    int32_t defer_count;
+    ecs_entity_t scope;
+    ecs_entity_t with;
+    ecs_vec_t commands;
+    ecs_stack_t defer_stack;
+    ecs_stage_t *stage;
+} ecs_suspend_readonly_state_t;
+
+FLECS_API
+ecs_world_t* flecs_suspend_readonly(
+    const ecs_world_t *world,
+    ecs_suspend_readonly_state_t *state);
+
+FLECS_API
+void flecs_resume_readonly(
+    ecs_world_t *world,
+    ecs_suspend_readonly_state_t *state);
+
+FLECS_API
+int32_t flecs_poly_claim_(
+    flecs_poly_t *poly);
+
+FLECS_API
+int32_t flecs_poly_release_(
+    flecs_poly_t *poly);
+
+FLECS_API
+int32_t flecs_poly_refcount(
+    flecs_poly_t *poly);
+
+#define flecs_poly_claim(poly) \
+    flecs_poly_claim_(ECS_CONST_CAST(void*, reinterpret_cast<const void*>(poly)))
+#define flecs_poly_release(poly) \
+    flecs_poly_release_(ECS_CONST_CAST(void*, reinterpret_cast<const void*>(poly)))
+
+/** Calculate offset from address */
+#ifdef __cplusplus
+#define ECS_OFFSET(o, offset) reinterpret_cast<void*>((reinterpret_cast<uintptr_t>(o)) + (static_cast<uintptr_t>(offset)))
+#else
+#define ECS_OFFSET(o, offset) (void*)(((uintptr_t)(o)) + ((uintptr_t)(offset)))
+#endif
+#define ECS_OFFSET_T(o, T) ECS_OFFSET(o, ECS_SIZEOF(T))
 
 #define ECS_ELEM(ptr, size, index) ECS_OFFSET(ptr, (size) * (index))
 #define ECS_ELEM_T(o, T, index) ECS_ELEM(o, ECS_SIZEOF(T), index)
@@ -3531,8 +3604,18 @@ ecs_iter_t flecs_children(
 #define ECS_BIT_COND(flags, bit, cond) ((cond) \
     ? (ECS_BIT_SET(flags, bit)) \
     : (ECS_BIT_CLEAR(flags, bit)))
+
+#define ECS_BIT_CLEAR16(flags, bit) (flags) &= (ecs_flags16_t)~(bit)   
+#define ECS_BIT_COND16(flags, bit, cond) ((cond) \
+    ? (ECS_BIT_SET(flags, bit)) \
+    : (ECS_BIT_CLEAR16(flags, bit)))
+
 #define ECS_BIT_IS_SET(flags, bit) ((flags) & (bit))
 
+#define ECS_BIT_SETN(flags, n) ECS_BIT_SET(flags, 1llu << n)
+#define ECS_BIT_CLEARN(flags, n) ECS_BIT_CLEAR(flags, 1llu << n)
+#define ECS_BIT_CONDN(flags, n, cond) ECS_BIT_COND(flags, 1llu << n, cond)
+
 #ifdef __cplusplus
 }
 #endif
@@ -3688,6 +3771,12 @@ void* flecs_hashmap_next_(
 #endif
 
 
+/* Utility to hold a value of a dynamic type */
+typedef struct ecs_value_t {
+    ecs_entity_t type;
+    void *ptr;
+} ecs_value_t;
+
 /** Used with ecs_entity_init().
  *
  * @ingroup entities
@@ -3697,6 +3786,8 @@ typedef struct ecs_entity_desc_t {
 
     ecs_entity_t id;      /**< Set to modify existing entity (optional) */
 
+    ecs_entity_t parent;  /**< Parent entity. */
+
     const char *name;     /**< Name of the entity. If no entity is provided, an
                            * entity with this name will be looked up first. When
                            * an entity is provided, the name will be verified
@@ -3722,8 +3813,11 @@ typedef struct ecs_entity_desc_t {
                            * components) will be used to create the entity, if
                            * no id is specified. */
 
-    /** Array of ids to add to the new or existing entity. */
-    ecs_id_t add[FLECS_ID_DESC_MAX];
+    /** 0-terminated array of ids to add to the entity. */
+    const ecs_id_t *add;
+
+    /** 0-terminated array of values to set on the entity. */
+    const ecs_value_t *set;
 
     /** String expression with components to add */
     const char *add_expr;
@@ -3773,76 +3867,182 @@ typedef struct ecs_component_desc_t {
     ecs_type_info_t type;
 } ecs_component_desc_t;
 
-/** Used with ecs_filter_init().
+/** Iterator.
+ * Used for iterating queries. The ecs_iter_t type contains all the information
+ * that is provided by a query, and contains all the state required for the
+ * iterator code.
+ * 
+ * Functions that create iterators accept as first argument the world, and as
+ * second argument the object they iterate. For example:
+ * 
+ * @code
+ * ecs_iter_t it = ecs_query_iter(world, q);
+ * @endcode
+ * 
+ * When this code is called from a system, it is important to use the world
+ * provided by its iterator object. For example:
+ * 
+ * @code
+ * void Collide(ecs_iter_t *it) {
+ *   ecs_iter_t qit = ecs_query_iter(it->world, Colliders);
+ * }
+ * @endcode
+ * 
+ * This ensures thread safe allocation and cleanup of any resources required by 
+ * the iterator.
  *
- * @ingroup filters
+ * @ingroup queries
  */
-typedef struct ecs_filter_desc_t {
-    int32_t _canary;
+struct ecs_iter_t {
+    /* World */
+    ecs_world_t *world;           /**< The world */
+    ecs_world_t *real_world;      /**< Actual world. This differs from world when in readonly mode */
+
+    /* Matched data */
+    ecs_entity_t *entities;       /**< Entity identifiers */
+    void **ptrs;                  /**< Pointers to components. Array if from this, pointer if not. */
+    const ecs_size_t *sizes;      /**< Component sizes */
+    ecs_table_t *table;           /**< Current table */
+    ecs_table_t *other_table;     /**< Prev or next table when adding/removing */
+    ecs_id_t *ids;                /**< (Component) ids */
+    ecs_var_t *variables;         /**< Values of variables (if any) */
+    int32_t *columns;             /**< Query term to table column mapping */
+    ecs_entity_t *sources;        /**< Entity on which the id was matched (0 if same as entities) */
+    ecs_ref_t *references;        /**< Cached refs to components (if iterating a cache) */
+    ecs_flags64_t constrained_vars; /**< Bitset that marks constrained variables */
+    uint64_t group_id;            /**< Group id for table, if group_by is used */
+    int32_t field_count;          /**< Number of fields in iterator */
+    ecs_termset_t set_fields;     /**< Fields that are set */
+    ecs_termset_t shared_fields;  /**< Bitset with shared fields */
+    ecs_termset_t up_fields;      /**< Bitset with fields matched through up traversal */
 
-    /** Terms of the filter. If a filter has more terms than
-     * FLECS_TERM_DESC_MAX use terms_buffer */
-    ecs_term_t terms[FLECS_TERM_DESC_MAX];
+    /* Input information */
+    ecs_entity_t system;          /**< The system (if applicable) */
+    ecs_entity_t event;           /**< The event (if applicable) */
+    ecs_id_t event_id;            /**< The (component) id for the event */
+    int32_t event_cur;            /**< Unique event id. Used to dedup observer calls */
 
-    /** For filters with lots of terms an outside array can be provided. */
-    ecs_term_t *terms_buffer;
+    /* Query information */
+    const ecs_query_t *query;     /**< Query being evaluated */
+    int32_t term_index;           /**< Index of term that emitted an event.
+                                   * This field will be set to the 'index' field
+                                   * of an observer term. */
+    int32_t variable_count;       /**< Number of variables for query */
+    char **variable_names;        /**< Names of variables (if any) */
 
-    /** Number of terms in array provided in terms_buffer. */
-    int32_t terms_buffer_count;
+    /* Context */
+    void *param;                  /**< Param passed to ecs_run */
+    void *ctx;                    /**< System context */
+    void *binding_ctx;            /**< Binding context */
 
-    /** External storage to prevent allocation of the filter object */
-    ecs_filter_t *storage;
+    /* Time */
+    ecs_ftime_t delta_time;       /**< Time elapsed since last frame */
+    ecs_ftime_t delta_system_time;/**< Time elapsed since last system invocation */
 
-    /** When true, terms returned by an iterator may either contain 1 or N
-     * elements, where terms with N elements are owned, and terms with 1 element
-     * are shared, for example from a parent or base entity. When false, the
-     * iterator will at most return 1 element when the result contains both
-     * owned and shared terms. */
-    bool instanced;
+    /* Iterator counters */
+    int32_t frame_offset;         /**< Offset relative to start of iteration */
+    int32_t offset;               /**< Offset relative to current table */
+    int32_t count;                /**< Number of entities to iterate */
+    int32_t instance_count;       /**< Number of entities to iterate before next table */
 
-    /** Flags for advanced usage */
-    ecs_flags32_t flags;
+    /* Misc */
+    ecs_flags32_t flags;          /**< Iterator flags */
+    ecs_entity_t interrupted_by;  /**< When set, system execution is interrupted */
+    ecs_iter_private_t priv_;     /**< Private data */
 
-    /** Filter expression. Should not be set at the same time as terms array */
-    const char *expr;
+    /* Chained iterators */
+    ecs_iter_next_action_t next;  /**< Function to progress iterator */
+    ecs_iter_action_t callback;   /**< Callback of system or observer */
+    ecs_iter_fini_action_t fini;  /**< Function to cleanup iterator resources */
+    ecs_iter_t *chain_it;         /**< Optional, allows for creating iterator chains */
+};
 
-    /** Entity associated with query (optional) */
-    ecs_entity_t entity;
-} ecs_filter_desc_t;
 
-/** Used with ecs_query_init().
- *
- * @ingroup queries
+/** Query must match prefabs.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryMatchPrefab           (1u << 1u)
+
+/** Query must match disabled entities.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryMatchDisabled         (1u << 2u)
+
+/** Query must match empty tables.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryMatchEmptyTables      (1u << 3u)
+
+/** Query won't provide component data.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryNoData                (1u << 4u)
+
+/** Query iteration is always instanced.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryIsInstanced           (1u << 5u)
+
+/** Query may have unresolved entity identifiers.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryAllowUnresolvedByName (1u << 6u)
+
+/** Query only returns whole tables (ignores toggle/member fields).
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryTableOnly             (1u << 7u)
+
+
+/** Used with ecs_query_init. 
+ * 
+ * \ingroup queries
  */
 typedef struct ecs_query_desc_t {
     int32_t _canary;
 
-    /** Filter for the query */
-    ecs_filter_desc_t filter;
+    /** Query terms */
+    ecs_term_t terms[FLECS_TERM_COUNT_MAX];
 
-    /** Component to be used by order_by */
-    ecs_entity_t order_by_component;
+    /** Query DSL expression (optional) */
+    const char *expr;
+
+    /** Caching policy of query */
+    ecs_query_cache_kind_t cache_kind;
+
+    /** Flags for enabling query features */
+    ecs_flags32_t flags;
 
     /** Callback used for ordering query results. If order_by_id is 0, the
      * pointer provided to the callback will be NULL. If the callback is not
      * set, results will not be ordered. */
-    ecs_order_by_action_t order_by;
+    ecs_order_by_action_t order_by_callback;
 
-    /** Callback used for ordering query results. Same as order_by,
+    /** Callback used for ordering query results. Same as order_by_callback,
      * but more efficient. */
-    ecs_sort_table_action_t sort_table;
+    ecs_sort_table_action_t order_by_table_callback;
 
-    /** Id to be used by group_by. This id is passed to the group_by function and
-     * can be used identify the part of an entity type that should be used for
-     * grouping. */
-    ecs_id_t group_by_id;
+    /** Component to sort on, used together with order_by_callback or
+     * order_by_table_callback. */
+    ecs_entity_t order_by;
+
+    /** Component id to be used for grouping. Used together with the
+     * group_by_callback. */
+    ecs_id_t group_by;
 
     /** Callback used for grouping results. If the callback is not set, results
      * will not be grouped. When set, this callback will be used to calculate a
      * "rank" for each entity (table) based on its components. This rank is then
      * used to sort entities (tables), so that entities (tables) of the same
      * rank are "grouped" together when iterated. */
-    ecs_group_by_action_t group_by;
+    ecs_group_by_action_t group_by_callback;
 
     /** Callback that is invoked when a new group is created. The return value of
      * the callback is stored as context for a group. */
@@ -3858,14 +4058,6 @@ typedef struct ecs_query_desc_t {
     /** Function to free group_by_ctx */
     ecs_ctx_free_t group_by_ctx_free;
 
-    /** If set, the query will be created as a subquery. A subquery matches at
-     * most a subset of its parent query. Subqueries do not directly receive
-     * (table) notifications from the world. Instead parent queries forward
-     * results to subqueries. This can improve matching performance, as fewer
-     * queries need to be matched with new tables.
-     * Subqueries can be nested. */
-    ecs_query_t *parent;
-
     /** User context to pass to callback */
     void *ctx;
 
@@ -3877,6 +4069,9 @@ typedef struct ecs_query_desc_t {
 
     /** Callback to free binding_ctx */
     ecs_ctx_free_t binding_ctx_free;
+
+    /** Entity associated with query (optional) */
+    ecs_entity_t entity;
 } ecs_query_desc_t;
 
 /** Used with ecs_observer_init().
@@ -3889,22 +4084,21 @@ typedef struct ecs_observer_desc_t {
     /** Existing entity to associate with observer (optional) */
     ecs_entity_t entity;
 
-    /** Filter for observer */
-    ecs_filter_desc_t filter;
+    /** Query for observer */
+    ecs_query_desc_t query;
 
     /** Events to observe (OnAdd, OnRemove, OnSet, UnSet) */
     ecs_entity_t events[FLECS_EVENT_DESC_MAX];
 
     /** When observer is created, generate events from existing data. For example,
-     * EcsOnAdd Position would match all existing instances of Position.
-     * This is only supported for events that are iterable (see EcsIterable) */
+     * EcsOnAdd Position would match all existing instances of Position. */
     bool yield_existing;
 
     /** Callback to invoke on an event, invoked when the observer matches. */
     ecs_iter_action_t callback;
 
     /** Callback invoked on an event. When left to NULL the default runner
-     * is used which matches the event with the observer's filter, and calls
+     * is used which matches the event with the observer's query, and calls
      * 'callback' when it matches.
      * A reason to override the run function is to improve performance, if there
      * are more efficient way to test whether an event matches the observer than
@@ -3924,7 +4118,7 @@ typedef struct ecs_observer_desc_t {
     ecs_ctx_free_t binding_ctx_free;
 
     /** Observable with which to register the observer */
-    ecs_poly_t *observable;
+    flecs_poly_t *observable;
 
     /** Optional shared last event id for multiple observers. Ensures only one
      * of the observers with the shared id gets triggered for an event */
@@ -3977,7 +4171,7 @@ typedef struct ecs_event_desc_t {
     const void *const_param;
 
     /** Observable (usually the world) */
-    ecs_poly_t *observable;
+    flecs_poly_t *observable;
 
     /** Event flags */
     ecs_flags32_t flags;
@@ -3991,12 +4185,6 @@ typedef struct ecs_event_desc_t {
  * @{
  */
 
-/* Utility to hold a value of a dynamic type */
-typedef struct ecs_value_t {
-    ecs_entity_t type;
-    void *ptr;
-} ecs_value_t;
-
 /** Type with information about the current Flecs build */
 typedef struct ecs_build_info_t {
     const char *compiler;           /**< Compiler used to compile flecs */
@@ -4102,17 +4290,17 @@ typedef struct EcsComponent {
 
 /** Component for storing a poly object */
 typedef struct EcsPoly {
-    ecs_poly_t *poly;          /**< Pointer to poly object */
+    flecs_poly_t *poly;          /**< Pointer to poly object */
 } EcsPoly;
 
-/** Target data for flattened relationships. */
-typedef struct EcsFlattenTarget {
-    int32_t count;
-    ecs_record_t *target;
-} EcsFlattenTarget;
-
-/** Component for iterable entities */
-typedef ecs_iterable_t EcsIterable;
+/** When added to an entity this informs serialization formats which component 
+ * to use when a value is assigned to an entity without specifying the 
+ * component. This is intended as a hint, serialization formats are not required 
+ * to use it. Adding this component does not change the behavior of core ECS 
+ * operations. */
+typedef struct EcsDefaultChildComponent {
+    ecs_id_t component;
+} EcsDefaultChildComponent;
 
 /** @} */
 /** @} */
@@ -4166,9 +4354,6 @@ FLECS_API extern const ecs_id_t ECS_OVERRIDE;
 /** Adds bitset to storage which allows component to be enabled/disabled */
 FLECS_API extern const ecs_id_t ECS_TOGGLE;
 
-/** Include all components from entity to which AND is applied */
-FLECS_API extern const ecs_id_t ECS_AND;
-
 /** @} */
 
 /**
@@ -4179,8 +4364,8 @@ FLECS_API extern const ecs_id_t ECS_AND;
 /* Builtin component ids */
 FLECS_API extern const ecs_entity_t ecs_id(EcsComponent);
 FLECS_API extern const ecs_entity_t ecs_id(EcsIdentifier);
-FLECS_API extern const ecs_entity_t ecs_id(EcsIterable);
 FLECS_API extern const ecs_entity_t ecs_id(EcsPoly);
+FLECS_API extern const ecs_entity_t ecs_id(EcsDefaultChildComponent);
 
 FLECS_API extern const ecs_entity_t EcsQuery;
 FLECS_API extern const ecs_entity_t EcsObserver;
@@ -4230,8 +4415,8 @@ FLECS_API extern const ecs_entity_t EcsTransitive;
 FLECS_API extern const ecs_entity_t EcsReflexive;
 
 /** Ensures that entity/component cannot be used as target in IsA relationship.
- * Final can improve the performance of rule-based queries, as they will not
- * attempt to substitute a final component with its subsets.
+ * Final can improve the performance of queries as they will not attempt to 
+ * substitute a final component with its subsets.
  *
  * Behavior:
  *   if IsA(X, Y) and Final(Y) throw error
@@ -4289,9 +4474,8 @@ FLECS_API extern const ecs_entity_t EcsWith;
  */
 FLECS_API extern const ecs_entity_t EcsOneOf;
 
-/** Can be added to relationship to indicate that it should never hold data,
- * even when it or the relationship target is a component. */
-FLECS_API extern const ecs_entity_t EcsTag;
+/** Mark a component as toggleable with enable_id/disable_id. */
+FLECS_API extern const ecs_entity_t EcsCanToggle;
 
 /** Can be added to components to indicate it is a trait. Traits are components
  * and/or tags that are added to other components to modify their behavior.
@@ -4314,10 +4498,9 @@ FLECS_API extern const ecs_entity_t EcsRelationship;
  */
 FLECS_API extern const ecs_entity_t EcsTarget;
 
-/** Tag to indicate that relationship is stored as union. Union relationships
- * enable changing the target of a union without switching tables. Union
- * relationships are also marked as exclusive. */
-FLECS_API extern const ecs_entity_t EcsUnion;
+/** Can be added to relationship to indicate that it should never hold data, 
+ * even when it or the relationship target is a component. */
+FLECS_API extern const ecs_entity_t EcsPairIsTag;
 
 /** Tag to indicate name identifier */
 FLECS_API extern const ecs_entity_t EcsName;
@@ -4354,6 +4537,11 @@ FLECS_API extern const ecs_entity_t EcsPrefab;
  * EcsDisabled is explicitly queried for. */
 FLECS_API extern const ecs_entity_t EcsDisabled;
 
+/** Trait added to entities that should never be returned by queries. Reserved
+ * for internal entities that have special meaning to the query engine, such as
+ * EcsThis, EcsWildcard, EcsAny. */
+FLECS_API extern const ecs_entity_t EcsNotQueryable;
+
 /** Event that triggers when an id is added to an entity */
 FLECS_API extern const ecs_entity_t EcsOnAdd;
 
@@ -4400,21 +4588,7 @@ FLECS_API extern const ecs_entity_t EcsDelete;
  * EcsOnDeleteTarget. */
 FLECS_API extern const ecs_entity_t EcsPanic;
 
-/** Component that stores data for flattened relationships */
-FLECS_API extern const ecs_entity_t ecs_id(EcsFlattenTarget);
-
-/** Tag added to root entity to indicate its subtree should be flattened. Used
- * together with assemblies. */
-FLECS_API extern const ecs_entity_t EcsFlatten;
-
-/** Used like (EcsDefaultChildComponent, Component). When added to an entity,
- * this informs serialization formats which component to use when a value is
- * assigned to an entity without specifying the component. This is intended as
- * a hint, serialization formats are not required to use it. Adding this
- * component does not change the behavior of core ECS operations. */
-FLECS_API extern const ecs_entity_t EcsDefaultChildComponent;
-
-/* Builtin predicates for comparing entity ids in queries. Only supported by rules */
+/* Builtin predicates for comparing entity ids in queries. Only supported by queries */
 FLECS_API extern const ecs_entity_t EcsPredEq;
 FLECS_API extern const ecs_entity_t EcsPredMatch;
 FLECS_API extern const ecs_entity_t EcsPredLookup;
@@ -4690,7 +4864,7 @@ void ecs_set_target_fps(
  * multithreaded applications the world needs to be entirely immutable. For this
  * purpose multi threaded readonly mode exists, which disallows all mutations on
  * the world. This means that in multi threaded applications, entity liveliness
- * operations, implicit component registration, and on-the-fly filter creation
+ * operations, implicit component registration, and on-the-fly query creation
  * are not guaranteed to work.
  * 
  * While in readonly mode, applications can still enqueue ECS operations on a
@@ -4821,27 +4995,6 @@ FLECS_API
 void ecs_defer_resume(
     ecs_world_t *world);
 
-/** Enable/disable auto-merging for world or stage.
- * When auto-merging is enabled, staged data will automatically be merged with
- * the world when staging ends. This happens at the end of ecs_progress(), at a
- * sync point or when ecs_readonly_end() is called.
- *
- * Applications can exercise more control over when data from a stage is merged
- * by disabling auto-merging. This requires an application to explicitly call
- * ecs_merge() on the stage.
- *
- * When this function is invoked on the world, it sets all current stages to
- * the provided value and sets the default for new stages. When this function is
- * invoked on a stage, auto-merging is only set for that specific stage.
- *
- * @param world The world.
- * @param automerge Whether to enable or disable auto-merging.
- */
-FLECS_API
-void ecs_set_automerge(
-    ecs_world_t *world,
-    bool automerge);
-
 /** Configure world to have N stages.
  * This initializes N stages, which allows applications to defer operations to
  * multiple isolated defer queues. This is typically used for applications with
@@ -4870,17 +5023,6 @@ FLECS_API
 int32_t ecs_get_stage_count(
     const ecs_world_t *world);
 
-/** Get current stage id.
- * The stage id can be used by an application to learn about which stage it is
- * using, which typically corresponds with the worker thread id.
- *
- * @param world The world.
- * @return The stage id.
- */
-FLECS_API
-int32_t ecs_get_stage_id(
-    const ecs_world_t *world);
-
 /** Get stage-specific world pointer.
  * Flecs threads can safely invoke the API as long as they have a private
  * context to write to, also referred to as the stage. This function returns a
@@ -4912,47 +5054,35 @@ FLECS_API
 bool ecs_stage_is_readonly(
     const ecs_world_t *world);
 
-/** Create asynchronous stage.
- * An asynchronous stage can be used to asynchronously queue operations for
- * later merging with the world. An asynchronous stage is similar to a regular
- * stage, except that it does not allow reading from the world.
- *
- * Asynchronous stages are never merged automatically, and must therefore be
- * manually merged with the ecs_merge() function. It is not necessary to call
- * ecs_defer_begin() or ecs_defer_end() before and after enqueuing commands, as an
- * asynchronous stage unconditionally defers operations.
- *
- * The application must ensure that no commands are added to the stage while the
- * stage is being merged.
- *
- * An asynchronous stage must be cleaned up by ecs_async_stage_free().
+/** Create unmanaged stage.
+ * Create a stage who's lifecycle is not managed by the world. Must be freed
+ * with ecs_stage_free.
  *
  * @param world The world.
  * @return The stage.
  */
 FLECS_API
-ecs_world_t* ecs_async_stage_new(
+ecs_world_t* ecs_stage_new(
     ecs_world_t *world);
 
-/** Free asynchronous stage.
- * The provided stage must be an asynchronous stage. If a non-asynchronous stage
- * is provided, the operation will fail.
+/** Free unmanaged stage.
  *
  * @param stage The stage to free.
  */
 FLECS_API
-void ecs_async_stage_free(
+void ecs_stage_free(
     ecs_world_t *stage);
 
-/** Test whether provided stage is asynchronous.
+/** Get stage id.
+ * The stage id can be used by an application to learn about which stage it is
+ * using, which typically corresponds with the worker thread id.
  *
- * @param stage The stage.
- * @return True when the stage is asynchronous, false for a regular stage or
- *         world.
+ * @param world The world.
+ * @return The stage id.
  */
 FLECS_API
-bool ecs_stage_is_async(
-    ecs_world_t *stage);
+int32_t ecs_stage_get_id(
+    const ecs_world_t *world);
 
 /** @} */
 
@@ -5039,7 +5169,7 @@ void ecs_dim(
     int32_t entity_count);
 
 /** Set a range for issuing new entity ids.
- * This function constrains the entity identifiers returned by ecs_new() to the
+ * This function constrains the entity identifiers returned by ecs_new_w() to the
  * specified range. This operation can be used to ensure that multiple processes
  * can run in the same simulation without requiring a central service that
  * coordinates issuing identifiers.
@@ -5149,7 +5279,7 @@ int32_t ecs_delete_empty_tables(
  */
 FLECS_API
 const ecs_world_t* ecs_get_world(
-    const ecs_poly_t *poly);
+    const flecs_poly_t *poly);
 
 /** Get entity from poly.
  *
@@ -5158,13 +5288,13 @@ const ecs_world_t* ecs_get_world(
  */
 FLECS_API
 ecs_entity_t ecs_get_entity(
-    const ecs_poly_t *poly);
+    const flecs_poly_t *poly);
 
 /** Test if pointer is of specified type.
  * Usage:
  *
  * @code
- * ecs_poly_is(ptr, ecs_world_t)
+ * flecs_poly_is(ptr, ecs_world_t)
  * @endcode
  *
  * This operation only works for poly types.
@@ -5174,12 +5304,12 @@ ecs_entity_t ecs_get_entity(
  * @return True if the pointer is of the specified type.
  */
 FLECS_API
-bool ecs_poly_is_(
-    const ecs_poly_t *object,
+bool flecs_poly_is_(
+    const flecs_poly_t *object,
     int32_t type);
 
-#define ecs_poly_is(object, type)\
-    ecs_poly_is_(object, type##_magic)
+#define flecs_poly_is(object, type)\
+    flecs_poly_is_(object, type##_magic)
 
 /** Make a pair id.
  * This function is equivalent to using the ecs_pair() macro, and is added for
@@ -5220,7 +5350,7 @@ ecs_id_t ecs_make_pair(
  * @return The new entity id.
  */
 FLECS_API
-ecs_entity_t ecs_new_id(
+ecs_entity_t ecs_new(
     ecs_world_t *world);
 
 /** Create new low id.
@@ -5802,23 +5932,30 @@ bool ecs_record_has_id(
     ecs_id_t id);
 
 /** Emplace a component.
- * Emplace is similar to ecs_ensure_id() except that the component constructor is not
- * invoked for the returned pointer, allowing the component to be "constructed"
- * directly in the storage.
- *
- * Emplace can only be used if the entity does not yet have the component. If
- * the entity has the component, the operation will fail.
+ * Emplace is similar to ecs_ensure_id() except that the component constructor
+ * is not invoked for the returned pointer, allowing the component to be 
+ * constructed directly in the storage.
+ * 
+ * When the is_new parameter is not provided, the operation will assert when the
+ * component already exists. When the is_new parameter is provided, it will
+ * indicate whether the returned storage has been constructed.
+ * 
+ * When is_new indicates that the storage has not yet been constructed, it must
+ * be constructed by the code invoking this operation. Not constructing the
+ * component will result in undefined behavior.
  *
  * @param world The world.
  * @param entity The entity.
  * @param id The component to obtain.
+ * @param is_new Whether this is an existing or new component.
  * @return The (uninitialized) component pointer.
  */
 FLECS_API
 void* ecs_emplace_id(
     ecs_world_t *world,
     ecs_entity_t entity,
-    ecs_id_t id);
+    ecs_id_t id,
+    bool *is_new);
 
 /** Signal that a component has been modified.
  * This operation is usually used after modifying a component value obtained by
@@ -5849,10 +5986,9 @@ void ecs_modified_id(
  * @param id The id of the component to set.
  * @param size The size of the pointed-to value.
  * @param ptr The pointer to the value.
- * @return The entity. A new entity if no entity was provided.
  */
 FLECS_API
-ecs_entity_t ecs_set_id(
+void ecs_set_id(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_id_t id,
@@ -5875,7 +6011,7 @@ ecs_entity_t ecs_set_id(
  * An entity is valid if it is not 0 and if it is alive.
  *
  * ecs_is_valid() will return true for ids that don't exist (alive or not alive). This
- * allows for using ids that have never been created by ecs_new() or similar. In
+ * allows for using ids that have never been created by ecs_new_w() or similar. In
  * this the function differs from ecs_is_alive(), which will return false for
  * entities that do not yet exist.
  *
@@ -5893,7 +6029,7 @@ bool ecs_is_valid(
 
 /** Test whether an entity is alive.
  * Entities are alive after they are created, and become not alive when they are
- * deleted. Operations that return alive ids are (amongst others) ecs_new_id(),
+ * deleted. Operations that return alive ids are (amongst others) ecs_new(),
  * ecs_new_low_id() and ecs_entity_init(). Ids can be made alive with the ecs_make_alive()
  * function.
  *
@@ -5902,12 +6038,12 @@ bool ecs_is_valid(
  * possible for the API to distinguish between the two. An example:
  *
  * @code
- * ecs_entity_t e1 = ecs_new_id(world);
+ * ecs_entity_t e1 = ecs_new(world);
  * ecs_is_alive(world, e1);             // true
  * ecs_delete(world, e1);
  * ecs_is_alive(world, e1);             // false
  *
- * ecs_entity_t e2 = ecs_new_id(world); // recycles e1
+ * ecs_entity_t e2 = ecs_new(world); // recycles e1
  * ecs_is_alive(world, e2);             // true
  * ecs_is_alive(world, e1);             // false
  * @endcode
@@ -5930,22 +6066,6 @@ FLECS_API
 ecs_id_t ecs_strip_generation(
     ecs_entity_t e);
 
-/** Override the generation of an entity.
- * The generation count of an entity is increased each time an entity is deleted
- * and is used to test whether an entity id is alive.
- *
- * This operation overrides the current generation of an entity with the
- * specified generation, which can be useful if an entity is externally managed,
- * like for external pools, savefiles or netcode.
- *
- * @param world The world.
- * @param entity Entity for which to set the generation with the new generation.
- */
-FLECS_API
-void ecs_set_entity_generation(
-    ecs_world_t *world,
-    ecs_entity_t entity);
-
 /** Get alive identifier.
  * In some cases an application may need to work with identifiers from which
  * the generation has been stripped. A typical scenario in which this happens is
@@ -5970,7 +6090,7 @@ ecs_entity_t ecs_get_alive(
 /** Ensure id is alive.
  * This operation ensures that the provided id is alive. This is useful in
  * scenarios where an application has an existing id that has not been created
- * with ecs_new() (such as a global constant or an id from a remote application).
+ * with ecs_new_w() (such as a global constant or an id from a remote application).
  *
  * When this operation is successful it guarantees that the provided id exists,
  * is valid and is alive.
@@ -6027,6 +6147,25 @@ bool ecs_exists(
     const ecs_world_t *world,
     ecs_entity_t entity);
 
+/** Override the generation of an entity.
+ * The generation count of an entity is increased each time an entity is deleted
+ * and is used to test whether an entity id is alive.
+ *
+ * This operation overrides the current generation of an entity with the
+ * specified generation, which can be useful if an entity is externally managed,
+ * like for external pools, savefiles or netcode.
+ * 
+ * This operation is similar to ecs_make_alive, except that it will also
+ * override the generation of an alive entity.
+ *
+ * @param world The world.
+ * @param entity Entity for which to set the generation with the new generation.
+ */
+FLECS_API
+void ecs_set_generation(
+    ecs_world_t *world,
+    ecs_entity_t entity);
+
 /** @} */
 
 /**
@@ -6209,48 +6348,6 @@ int32_t ecs_get_depth(
     ecs_entity_t entity,
     ecs_entity_t rel);
 
-typedef struct ecs_flatten_desc_t {
-    /* When true, the flatten operation will not remove names from entities in
-     * the flattened tree. This may fail if entities from different subtrees
-     * have the same name. */
-    bool keep_names;
-
-    /* When true, the flattened tree won't contain information about the
-     * original depth of the entities. This can reduce fragmentation, but may
-     * cause existing code, such as cascade queries, to no longer work. */
-    bool lose_depth;
-} ecs_flatten_desc_t;
-
-/** Recursively flatten relationship for target entity (experimental).
- * This operation combines entities in the subtree of the specified pair from
- * different parents in the same table. This can reduce memory fragmentation
- * and reduces the number of tables in the storage, which improves RAM
- * utilization and various other operations, such as entity cleanup.
- *
- * The lifecycle of entities in a fixed subtree are bound to the specified
- * parent. Entities in a fixed subtree cannot be deleted individually. Entities
- * can also not change the target of the fixed relationship, which includes
- * removing the relationship.
- *
- * Entities in a fixed subtree are still fragmented on subtree depth. This
- * ensures that entities can still be iterated in breadth-first order with the
- * cascade query modifier.
- *
- * The current implementation is limited to exclusive acyclic relationships, and
- * does not allow for adding/removing to entities in flattened tables. An entity
- * may only be flattened for a single relationship. Future iterations of the
- * feature may remove these limitations.
- *
- * @param world The world.
- * @param pair The relationship pair from which to start flattening.
- * @param desc Options for flattening the tree.
- */
-FLECS_API
-void ecs_flatten(
-    ecs_world_t *world,
-    ecs_id_t pair,
-    const ecs_flatten_desc_t *desc);
-
 /** Count entities that have the specified id.
  * Returns the number of entities that have the specified id.
  *
@@ -6685,7 +6782,7 @@ const ecs_type_hooks_t* ecs_get_hooks_id(
  * - it is an entity without the EcsComponent component
  * - it has an EcsComponent with size member set to 0
  * - it is a pair where both elements are a tag
- * - it is a pair where the first element has the EcsTag tag
+ * - it is a pair where the first element has the EcsPairIsTag tag
  *
  * @param world The world.
  * @param id The id.
@@ -6696,23 +6793,6 @@ bool ecs_id_is_tag(
     const ecs_world_t *world,
     ecs_id_t id);
 
-/** Return whether represents a union.
- * This operation returns whether the specified type represents a union. Only
- * pair ids can be unions.
- *
- * An id represents a union when:
- * - The first element of the pair is EcsUnion/flecs::Union
- * - The first element of the pair has EcsUnion/flecs::Union
- *
- * @param world The world.
- * @param id The id.
- * @return Whether the provided id represents a union.
- */
-FLECS_API
-bool ecs_id_is_union(
-    const ecs_world_t *world,
-    ecs_id_t id);
-
 /** Returns whether specified id is in use.
  * This operation returns whether an id is in use in the world. An id is in use
  * if it has been added to one or more tables.
@@ -6735,7 +6815,7 @@ bool ecs_id_in_use(
  * EcsComponent value with size 0, the operation will return 0.
  *
  * For a pair id the operation will return the type associated with the pair, by
- * applying the following rules in order:
+ * applying the following querys in order:
  * - The first pair element is returned if it is a component
  * - 0 is returned if the relationship entity has the Tag property
  * - The second pair element is returned if it is a component
@@ -6849,102 +6929,38 @@ void ecs_id_str_buf(
 /** @} */
 
 /**
- * @defgroup filters Filters
- * Functions for working with `ecs_term_t` and `ecs_filter_t`.
- *
+ * @defgroup queries Queries
+ * @brief Functions for working with `ecs_term_t` and `ecs_query_t`.
  * @{
  */
 
-/** Iterator for a single (component) id.
- * A term iterator returns all entities (tables) that match a single (component)
- * id. The search for the matching set of entities (tables) is performed in
- * constant time.
+/** Test whether term id is set.
  *
- * @param world The world.
- * @param term The term.
- * @return The iterator.
+ * @param id The term id.
+ * @return True when set, false when not set.
  */
-FLECS_API
-ecs_iter_t ecs_term_iter(
-    const ecs_world_t *world,
-    ecs_term_t *term);
+FLECS_API 
+bool ecs_term_ref_is_set(
+    const ecs_term_ref_t *id);
 
-/** Return a chained term iterator.
- * A chained iterator applies a filter to the results of the input iterator. The
- * resulting iterator must be iterated with ecs_term_next().
+/** Test whether a term is set.
+ * This operation can be used to test whether a term has been initialized with
+ * values or whether it is empty.
+ *
+ * An application generally does not need to invoke this operation. It is useful
+ * when initializing a 0-initialized array of terms (like in ecs_term_desc_t) as
+ * this operation can be used to find the last initialized element.
  *
- * @param it The input iterator
- * @param term The term filter to apply to the iterator.
- * @return The chained iterator.
+ * @param term The term.
+ * @return True when set, false when not set.
  */
 FLECS_API
-ecs_iter_t ecs_term_chain_iter(
-    const ecs_iter_t *it,
-    ecs_term_t *term);
+bool ecs_term_is_initialized(
+    const ecs_term_t *term);
 
-/** Progress a term iterator.
- * This operation progresses the term iterator to the next table. The
- * iterator must have been initialized with ecs_term_iter(). This operation
- * must be invoked at least once before interpreting the contents of the
- * iterator.
- *
- * @param it The iterator.
- * @returns True if more data is available, false if not.
- */
-FLECS_API
-bool ecs_term_next(
-    ecs_iter_t *it);
-
-/** Iterator for a parent's children.
- * This operation is equivalent to a term iterator for (ChildOf, parent).
- * Iterate the result with ecs_children_next().
- *
- * @param world The world.
- * @param parent The parent for which to iterate the children.
- * @return The iterator.
- */
-FLECS_API
-ecs_iter_t ecs_children(
-    const ecs_world_t *world,
-    ecs_entity_t parent);
-
-/** Progress a children iterator.
- * Equivalent to ecs_term_next().
- *
- * @param it The iterator.
- * @returns True if more data is available, false if not.
- */
-FLECS_API
-bool ecs_children_next(
-    ecs_iter_t *it);
-
-/** Test whether term id is set.
- *
- * @param id The term id.
- * @return True when set, false when not set.
- */
-FLECS_API
-bool ecs_term_id_is_set(
-    const ecs_term_id_t *id);
-
-/** Test whether a term is set.
- * This operation can be used to test whether a term has been initialized with
- * values or whether it is empty.
- *
- * An application generally does not need to invoke this operation. It is useful
- * when initializing a 0-initialized array of terms (like in ecs_term_desc_t) as
- * this operation can be used to find the last initialized element.
- *
- * @param term The term.
- * @return True when set, false when not set.
- */
-FLECS_API
-bool ecs_term_is_initialized(
-    const ecs_term_t *term);
-
-/** Is term matched on $this variable.
- * This operation checks whether a term is matched on the $this variable, which
- * is the default source for queries.
+/** Is term matched on $this variable.
+ * This operation checks whether a term is matched on the $this variable, which
+ * is the default source for queries.
  *
  * A term has a $this source when:
  * - ecs_term_t::src::id is EcsThis
@@ -6976,139 +6992,6 @@ FLECS_API
 bool ecs_term_match_0(
     const ecs_term_t *term);
 
-/** Finalize term.
- * Ensure that all fields of a term are consistent and filled out. This
- * operation should be invoked before using and after assigning members to, or
- * parsing a term. When a term contains unresolved identifiers, this operation
- * will resolve and assign the identifiers. If the term contains any identifiers
- * that cannot be resolved, the operation will fail.
- *
- * An application generally does not need to invoke this operation as the APIs
- * that use terms (such as filters, queries and triggers) will finalize terms
- * when they are created.
- *
- * The name and expr parameters are optional, and only used for giving more
- * descriptive error messages.
- *
- * @param world The world.
- * @param term The term to finalize.
- * @return Zero if success, nonzero if an error occurred.
- */
-FLECS_API
-int ecs_term_finalize(
-    const ecs_world_t *world,
-    ecs_term_t *term);
-
-/** Copy resources of a term to another term.
- * This operation copies one term to another term. If the source term contains
- * allocated resources (such as identifiers), they will be duplicated so that
- * no memory is shared between the terms.
- *
- * @param src The term to copy from.
- * @return The destination term.
- */
-FLECS_API
-ecs_term_t ecs_term_copy(
-    const ecs_term_t *src);
-
-/** Move resources of a term to another term.
- * Same as copy, but moves resources from src, if src->move is set to true. If
- * src->move is not set to true, this operation will do a copy.
- *
- * The conditional move reduces redundant allocations in scenarios where a list
- * of terms is partially created with allocated resources.
- *
- * @param src The term to move from.
- * @return The destination term.
- */
-FLECS_API
-ecs_term_t ecs_term_move(
-    ecs_term_t *src);
-
-/** Free resources of term.
- * This operation frees all resources (such as identifiers) of a term. The term
- * itself is not freed.
- *
- * @param term The term to free.
- */
-FLECS_API
-void ecs_term_fini(
-    ecs_term_t *term);
-
-/** Initialize filter
- * A filter is a lightweight object that can be used to query for entities in
- * a world. Filters, as opposed to queries, do not cache results. They are
- * therefore slower to iterate, but are faster to create.
- *
- * When a filter is copied by value, make sure to use ecs_filter_move() to
- * ensure that the terms pointer still points to the inline array:
- *
- * @code
- * ecs_filter_move(&dst_filter, &src_filter)
- * @endcode
- *
- * Alternatively, the ecs_filter_move() function can be called with both arguments
- * set to the same filter, to ensure the pointer is valid:
- *
- * @code
- * ecs_filter_move(&f, &f)
- * @endcode
- *
- * It is possible to create a filter without allocating any memory, by setting
- * the .storage member in ecs_filter_desc_t. See the documentation for the
- * member for more details.
- *
- * @param world The world.
- * @param desc Properties for the filter to create.
- * @return The filter if successful, NULL if not successful.
- */
-FLECS_API
-ecs_filter_t * ecs_filter_init(
-    ecs_world_t *world,
-    const ecs_filter_desc_t *desc);
-
-/** Deinitialize filter.
- * Free resources associated with filter.
- *
- * @param filter The filter to deinitialize.
- */
-FLECS_API
-void ecs_filter_fini(
-    ecs_filter_t *filter);
-
-/** Finalize filter.
- * When manually assigning an array of terms to the filter struct (so not when
- * using ecs_filter_init()), this operation should be used to ensure that all
- * terms are assigned properly and all (derived) fields have been set.
- *
- * When ecs_filter_init() is used to create the filter, this function should not
- * be called. The purpose of this operation is to support creation of filters
- * without allocating memory.
- *
- * @param filter The filter to finalize.
- * @return Zero if filter is valid, non-zero if it contains errors.
- * @
- */
-FLECS_API
-int ecs_filter_finalize(
-    const ecs_world_t *world,
-    ecs_filter_t *filter);
-
-/** Find index for $this variable.
- * This operation looks up the index of the $this variable. This index can
- * be used in operations like ecs_iter_set_var() and ecs_iter_get_var().
- *
- * The operation will return -1 if the variable was not found. This happens when
- * a filter only has terms that are not matched on the $this variable, like a
- * filter that exclusively matches singleton components.
- *
- * @param filter The rule.
- * @return The index of the $this variable.
- */
-FLECS_API
-int32_t ecs_filter_find_this_var(
-    const ecs_filter_t *filter);
-
 /** Convert term to string expression.
  * Convert term to a string expression. The resulting expression is equivalent
  * to the same term, with the exception of And & Or operators.
@@ -7122,111 +7005,42 @@ char* ecs_term_str(
     const ecs_world_t *world,
     const ecs_term_t *term);
 
-/** Convert filter to string expression.
- * Convert filter terms to a string expression. The resulting expression can be
- * parsed to create the same filter.
- *
- * @param world The world.
- * @param filter The filter.
- * @return The filter converted to a string.
+/** Convert query to string expression.
+ * Convert query to a string expression. The resulting expression can be
+ * parsed to create the same query.
+ * 
+ * @param query The query.
+ * @return The query converted to a string.
  */
-FLECS_API
-char* ecs_filter_str(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter);
+FLECS_API 
+char* ecs_query_str(
+    const ecs_query_t *query); 
 
-/** Return a filter iterator.
- * A filter iterator lets an application iterate over entities that match the
- * specified filter.
- *
- * @param world The world.
- * @param filter The filter.
- * @return An iterator that can be used with ecs_filter_next().
- */
-FLECS_API
-ecs_iter_t ecs_filter_iter(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter);
+/** @} */
 
-/** Return a chained filter iterator.
- * A chained iterator applies a filter to the results of the input iterator. The
- * resulting iterator must be iterated with ecs_filter_next().
- *
- * @param it The input iterator
- * @param filter The filter to apply to the iterator.
- * @return The chained iterator.
+/**
+ * @defgroup each_iter Each iterator
+ * @brief Find all entities that have a single (component) id.
+ * @{
  */
-FLECS_API
-ecs_iter_t ecs_filter_chain_iter(
-    const ecs_iter_t *it,
-    const ecs_filter_t *filter);
 
-/** Get pivot term for filter.
- * The pivot term is the term that matches the smallest set of tables, and is
- * a good default starting point for a search.
- *
- * The following conditions must be met for a term to be considered as pivot:
- * - It must have a This subject
- * - It must have the And operator
- *
- * When a filter does not have any terms that match those conditions, it will
- * return -1.
- *
- * If one or more terms in the filter have no matching tables the filter won't
- * yield any results. In this case the operation will return -2 which gives a
- * search function the option to early out.
- *
- * @param world The world.
- * @param filter The filter.
- * @return Index of the pivot term (use with filter->terms)
- */
 FLECS_API
-int32_t ecs_filter_pivot_term(
+ecs_iter_t ecs_each_id(
     const ecs_world_t *world,
-    const ecs_filter_t *filter);
-
-/** Iterate tables matched by filter.
- * This operation progresses the filter iterator to the next table. The
- * iterator must have been initialized with ecs_filter_iter(). This operation
- * must be invoked at least once before interpreting the contents of the
- * iterator.
- *
- * @param it The iterator
- * @return True if more data is available, false if not.
- */
-FLECS_API
-bool ecs_filter_next(
-    ecs_iter_t *it);
+    ecs_id_t id);
 
-/** Same as ecs_filter_next, but always instanced.
- * See instanced property of ecs_filter_desc_t.
- *
- * @param it The iterator
- * @return True if more data is available, false if not.
- */
 FLECS_API
-bool ecs_filter_next_instanced(
+bool ecs_each_next(
     ecs_iter_t *it);
 
-/** Move resources of one filter to another.
- *
- * @param dst The destination filter.
- * @param src The source filter.
- */
 FLECS_API
-void ecs_filter_move(
-    ecs_filter_t *dst,
-    ecs_filter_t *src);
+ecs_iter_t ecs_children(
+    const ecs_world_t *world,
+    ecs_entity_t parent);
 
-/** Copy resources of one filter to another.
- *
- * @param dst The destination filter.
- * @param src The source filter.
- */
 FLECS_API
-void ecs_filter_copy(
-    ecs_filter_t *dst,
-    const ecs_filter_t *src);
+bool ecs_children_next(
+    ecs_iter_t *it);
 
 /** @} */
 
@@ -7238,48 +7052,17 @@ void ecs_filter_copy(
  */
 
 /** Create a query.
- * This operation creates a query. Queries are used to iterate over entities
- * that match a filter and are the fastest way to find and iterate over entities
- * and their components.
- *
- * Queries should be created once, and reused multiple times. While iterating a
- * query is a cheap operation, creating and deleting a query is expensive. The
- * reason for this is that queries are "pre-matched", which means that a query
- * stores state about which entities (or rather, tables) match with the query.
- * Building up this state happens during query creation.
- *
- * Once a query is created, matching only happens when new tables are created.
- * In most applications this is an infrequent process, since it only occurs when
- * a new combination of components is introduced. While matching is expensive,
- * it is important to note that matching does not happen on a per-entity basis,
- * but on a per-table basis. This means that the average time spent on matching
- * per frame should rapidly approach zero over the lifetime of an application.
- *
- * A query provides direct access to the component arrays. When an application
- * creates/deletes entities or adds/removes components, these arrays can shift
- * component values around, or may grow in size. This can cause unexpected or
- * undefined behavior to occur if these operations are performed while
- * iterating. To prevent this from happening an application should either not
- * perform these operations while iterating, or use deferred operations (see
- * ecs_defer_begin() and ecs_defer_end()).
- *
- * Queries can be created and deleted dynamically. If a query was not deleted
- * (using ecs_query_fini()) before the world is deleted, it will be deleted
- * automatically.
- *
+ * 
  * @param world The world.
- * @param desc A structure describing the query properties.
- * @return The new query.
+ * @param desc The descriptor (see ecs_query_desc_t)
+ * @return The query.
  */
 FLECS_API
 ecs_query_t* ecs_query_init(
     ecs_world_t *world,
     const ecs_query_desc_t *desc);
 
-/** Destroy a query.
- * This operation destroys a query and its resources. If the query is used as
- * the parent of subqueries, those subqueries will be orphaned and must be
- * deinitialized as well.
+/** Delete a query.
  *
  * @param query The query.
  */
@@ -7287,111 +7070,158 @@ FLECS_API
 void ecs_query_fini(
     ecs_query_t *query);
 
-/** Get filter from a query.
- * This operation obtains a pointer to the internally constructed filter
- * of the query and can be used to introspect the query terms.
+/** Return number of variables in query.
  *
  * @param query The query.
- * @return The filter.
+ * @return The number of variables/
  */
 FLECS_API
-const ecs_filter_t* ecs_query_get_filter(
+int32_t ecs_query_var_count(
     const ecs_query_t *query);
 
-/** Return a query iterator.
- * A query iterator lets an application iterate over entities that match the
- * specified query. If a sorting function is specified, the query will check
- * whether a resort is required upon creating the iterator.
- *
- * Creating a query iterator is a cheap operation that does not allocate any
- * resources. An application does not need to deinitialize or free a query
- * iterator before it goes out of scope.
+/** Find variable index.
+ * This operation looks up the index of a variable in the query. This index can
+ * be used in operations like ecs_iter_set_var() and ecs_iter_get_var().
  *
- * To iterate the iterator, an application should use ecs_query_next() to progress
- * the iterator and test if it has data.
+ * @param query The query.
+ * @param name The variable name.
+ * @return The variable index.
+ */
+FLECS_API
+int32_t ecs_query_find_var(
+    const ecs_query_t *query,
+    const char *name);    
+
+/** Get variable name.
+ * This operation returns the variable name for an index.
  *
- * Query iteration requires an outer and an inner loop. The outer loop uses
- * ecs_query_next() to test if new tables are available. The inner loop iterates
- * the entities in the table, and is usually a for loop that uses iter.count to
- * loop through the entities and component arrays.
+ * @param query The query.
+ * @param var_id The variable index.
+ */
+FLECS_API
+const char* ecs_query_var_name(
+    const ecs_query_t *query,
+    int32_t var_id);
+
+/** Test if variable is an entity.
+ * Internally the query engine has entity variables and table variables. When
+ * iterating through query variables (by using ecs_query_variable_count) only
+ * the values for entity variables are accessible. This operation enables an
+ * application to check if a variable is an entity variable.
  *
- * The two loops are necessary because of how data is stored internally.
- * Entities are grouped by the components they have, in tables. A single query
- * can (and often does) match with multiple tables. Because each table has its
- * own set of arrays, an application has to reobtain pointers to those arrays
- * for each matching table.
+ * @param query The query.
+ * @param var_id The variable id.
+ */
+FLECS_API
+bool ecs_query_var_is_entity(
+    const ecs_query_t *query,
+    int32_t var_id);  
+
+/** Iterate a query.
+ * Note that query iterators may allocate memory, and that unless the iterator
+ * is iterated until completion, it may still hold resources. When stopping
+ * iteration before ecs_query_next has returned false, use ecs_iter_fini to
+ * cleanup any remaining resources.
  *
- * @param world The world or stage, when iterating in readonly mode.
- * @param query The query to iterate.
- * @return The query iterator.
+ * @param world The world.
+ * @param query The query.
+ * @return An iterator.
  */
 FLECS_API
 ecs_iter_t ecs_query_iter(
     const ecs_world_t *world,
-    ecs_query_t *query);
+    const ecs_query_t *query);
 
-/** Progress the query iterator.
- * This operation progresses the query iterator to the next table. The
- * iterator must have been initialized with ecs_query_iter(). This operation
- * must be invoked at least once before interpreting the contents of the
- * iterator.
+/** Progress query iterator.
  *
- * @param iter The iterator.
- * @returns True if more data is available, false if not.
+ * @param it The iterator.
  */
 FLECS_API
 bool ecs_query_next(
-    ecs_iter_t *iter);
+    ecs_iter_t *it);
 
-/** Same as ecs_query_next, but always instanced.
- * See "instanced" property of ecs_filter_desc_t.
+/** Progress instanced iterator.
+ * Should not be called unless you know what you're doing :-)
  *
- * @param iter The iterator.
- * @returns True if more data is available, false if not.
+ * @param it The iterator.
  */
 FLECS_API
 bool ecs_query_next_instanced(
-    ecs_iter_t *iter);
+    ecs_iter_t *it);
 
-/** Fast alternative to ecs_query_next() that only returns matched tables.
- * This operation only populates the ecs_iter_t::table field. To access the
- * matched components, call ecs_query_populate().
- *
- * If this operation is used with a query that has inout/out terms, those terms
- * will not be marked dirty unless ecs_query_populate() is called.
- *
- * @param iter The iterator.
- * @returns True if more data is available, false if not.
+/** Returns true if query matches with entity. */
+FLECS_API
+bool ecs_query_has(
+    ecs_query_t *query,
+    ecs_entity_t entity,
+    ecs_iter_t *it);
+
+/** Returns true if query matches with table. */
+FLECS_API
+bool ecs_query_has_table(
+    ecs_query_t *query,
+    ecs_table_t *table,
+    ecs_iter_t *it);
+
+/** Returns true if query matches with table. */
+FLECS_API
+bool ecs_query_has_range(
+    ecs_query_t *query,
+    ecs_table_range_t *range,
+    ecs_iter_t *it);
+
+/** Returns how often a match event happened for a cached query. 
+ * This operation can be used to determine whether the query cache has been 
+ * updated with new tables.
  */
 FLECS_API
-bool ecs_query_next_table(
-    ecs_iter_t *iter);
+int32_t ecs_query_match_count(
+    const ecs_query_t *query);
 
-/** Populate iterator fields.
- * This operation can be combined with ecs_query_next_table() to populate the
- * iterator fields for the current table.
+/** Convert query to a string.
+ * This will convert the query program to a string which can aid in debugging
+ * the behavior of a query.
  *
- * Populating fields conditionally can save time when a query uses change
- * detection, and only needs iterator data when the table has changed. When this
- * operation is called, inout/out terms will be marked dirty.
+ * The returned string must be freed with ecs_os_free().
  *
- * In cases where inout/out terms are conditionally written and no changes
- * were made after calling ecs_query_populate(), the ecs_query_skip() function can
- * be called to prevent the matched table components from being marked dirty.
+ * @param query The query.
+ * @return The string
+ */
+FLECS_API
+char* ecs_query_plan(
+    const ecs_query_t *query);
+
+/** Convert query to string with profile.
+ * To use this you must set the EcsIterProfile flag on an iterator before
+ * starting iteration:
+ *   it.flags |= EcsIterProfile
  *
- * This operation does should not be used with queries that match disabled
- * components, union relationships, or with queries that use order_by.
+ * @param query The query.
+ * @return The string
+ */
+FLECS_API
+char* ecs_query_str_w_profile(
+    const ecs_query_t *query,
+    const ecs_iter_t *it);
+
+/** Populate variables from key-value string.
+ * Convenience function to set query variables from a key-value string separated
+ * by comma's. The string must have the following format:
+ *   var_a: value, var_b: value
  *
- * When the when_changed argument is set to true, the iterator data will only
- * populate when the data has changed, using query change detection.
+ * The key-value list may optionally be enclosed in parenthesis.
+ * 
+ * This function uses the script addon.
  *
- * @param iter The iterator.
- * @param when_changed Only populate data when result has changed.
+ * @param query The query.
+ * @param it The iterator for which to set the variables.
+ * @param expr The key-value expression.
  */
 FLECS_API
-int ecs_query_populate(
-    ecs_iter_t *iter,
-    bool when_changed);
+const char* ecs_query_args_parse(
+    ecs_query_t *query,
+    ecs_iter_t *it,
+    const char *expr);
 
 /** Returns whether the query data changed since the last iteration.
  * The operation will return true after:
@@ -7419,13 +7249,11 @@ int ecs_query_populate(
  * - The iterator must be instanced
  *
  * @param query The query (optional if 'it' is provided).
- * @param it The iterator result to test (optional if 'query' is provided).
  * @return true if entities changed, otherwise false.
  */
 FLECS_API
 bool ecs_query_changed(
-    ecs_query_t *query,
-    const ecs_iter_t *it);
+    ecs_query_t *query);
 
 /** Skip a table while iterating.
  * This operation lets the query iterator know that a table was skipped while
@@ -7438,7 +7266,7 @@ bool ecs_query_changed(
  * @param it The iterator result to skip.
  */
 FLECS_API
-void ecs_query_skip(
+void ecs_iter_skip(
     ecs_iter_t *it);
 
 /** Set group to iterate for query iterator.
@@ -7458,13 +7286,13 @@ void ecs_query_skip(
  *
  * The group to iterate must be set before the first call to ecs_query_next(). No
  * operations that can add/remove components should be invoked between calling
- * ecs_query_set_group() and ecs_query_next().
+ * ecs_iter_set_group() and ecs_query_next().
  *
  * @param it The query iterator.
  * @param group_id The group to iterate.
  */
 FLECS_API
-void ecs_query_set_group(
+void ecs_iter_set_group(
     ecs_iter_t *it,
     uint64_t group_id);
 
@@ -7494,88 +7322,45 @@ const ecs_query_group_info_t* ecs_query_get_group_info(
     const ecs_query_t *query,
     uint64_t group_id);
 
-/** Returns whether query is orphaned.
- * When the parent query of a subquery is deleted, it is left in an orphaned
- * state. The only valid operation on an orphaned query is deleting it. Only
- * subqueries can be orphaned.
- *
- * @param query The query.
- * @return true if query is orphaned, otherwise false.
- */
-FLECS_API
-bool ecs_query_orphaned(
-    const ecs_query_t *query);
+/** Struct returned by ecs_query_count. */
+typedef struct ecs_query_count_t {
+    int32_t results;
+    int32_t entities;
+    int32_t tables;
+    int32_t empty_tables;
+} ecs_query_count_t;
 
-/** Convert query to string.
+/** Returns number of entities and results the query matches with.
+ * Only entities matching the $this variable as source are counted.
  *
  * @param query The query.
- * @return The query string.
+ * @return The number of matched entities.
  */
 FLECS_API
-char* ecs_query_str(
+ecs_query_count_t ecs_query_count(
     const ecs_query_t *query);
 
-/** Returns number of tables query matched with.
- *
+/** Does query return one or more results. 
+ * 
  * @param query The query.
- * @return The number of matched tables.
+ * @return True if query matches anything, false if not.
  */
 FLECS_API
-int32_t ecs_query_table_count(
+bool ecs_query_is_true(
     const ecs_query_t *query);
 
-/** Returns number of empty tables query matched with.
+/** @} */
+
+/**
+ * @defgroup observers Observers
+ * Functions for working with events and observers.
  *
- * @param query The query.
- * @return The number of matched empty tables.
+ * @{
  */
-FLECS_API
-int32_t ecs_query_empty_table_count(
-    const ecs_query_t *query);
 
-/** Returns number of entities query matched with.
- * This operation iterates all non-empty tables in the query cache to find the
- * total number of entities.
- *
- * @param query The query.
- * @return The number of matched entities.
- */
-FLECS_API
-int32_t ecs_query_entity_count(
-    const ecs_query_t *query);
-
-/** Get query ctx.
- * Return the value set in ecs_query_desc_t::ctx.
- *
- * @param query The query.
- * @return The context.
- */
-FLECS_API
-void* ecs_query_get_ctx(
-    const ecs_query_t *query);
-
-/** Get query binding ctx.
- * Return the value set in ecs_query_desc_t::binding_ctx.
- *
- * @param query The query.
- * @return The context.
- */
-FLECS_API
-void* ecs_query_get_binding_ctx(
-    const ecs_query_t *query);
-
-/** @} */
-
-/**
- * @defgroup observers Observers
- * Functions for working with events and observers.
- *
- * @{
- */
-
-/** Send event.
- * This sends an event to matching triggers & is the mechanism used by flecs
- * itself to send OnAdd, OnRemove, etc events.
+/** Send event.
+ * This sends an event to matching triggers & is the mechanism used by flecs
+ * itself to send OnAdd, OnRemove, etc events.
  *
  * Applications can use this function to send custom events, where a custom
  * event can be any regular entity.
@@ -7617,7 +7402,7 @@ ecs_entity_t ecs_observer_init(
 /** Default run action for observer.
  * This function can be called from a custom observer run action (see
  * ecs_observer_desc_t::run for more details). This function ensures that the
- * observer's filter is applied to the iterator's table, filters out duplicate
+ * observer's query is applied to the iterator's table, filters out duplicate
  * events and implements EcsMonitor logic.
  *
  * @param it The iterator.
@@ -7659,7 +7444,7 @@ void* ecs_observer_get_binding_ctx(
  * @return The observer query.
  */
 FLECS_API
-const ecs_filter_t* ecs_observer_get_filter(
+const ecs_query_t* ecs_observer_get_query(
     const ecs_world_t *world,
     ecs_entity_t observer);
 
@@ -7672,34 +7457,6 @@ const ecs_filter_t* ecs_observer_get_filter(
  * @{
  */
 
-/** Create iterator from poly object.
- * The provided poly object must have the iterable mixin. If an object is
- * provided that does not have the mixin, the function will assert.
- *
- * When a filter is provided, an array of two iterators must be passed to the
- * function. This allows the mixin implementation to create a chained iterator
- * when necessary, which requires two iterator objects.
- *
- * If a filter is provided, the first element in the array of two iterators is
- * the one that should be iterated. The mixin implementation may or may not set
- * the second element, depending on whether an iterator chain is required.
- *
- * Additionally, when a filter is provided the returned iterator will be for a
- * single term with the provided filter id. If the iterator is chained, the
- * previous iterator in the chain can be accessed through it->chain_it.
- *
- * @param world The world or stage for which to create the iterator.
- * @param poly The poly object from which to create the iterator.
- * @param iter The iterator (out, ecs_iter_t[2] when filter is set).
- * @param filter Optional term used for filtering the results.
- */
-FLECS_API
-void ecs_iter_poly(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter);
-
 /** Progress any iterator.
  * This operation is useful in combination with iterators for which it is not
  * known what created them. Example use cases are functions that should accept
@@ -7707,7 +7464,7 @@ void ecs_iter_poly(
  * objects.
  *
  * This operation is slightly slower than using a type-specific iterator (e.g.
- * ecs_filter_next(), ecs_query_next()) as it has to call a function pointer which
+ * ecs_query_next, ecs_query_next) as it has to call a function pointer which
  * introduces a level of indirection.
  *
  * @param it The iterator.
@@ -7747,8 +7504,8 @@ int32_t ecs_iter_count(
 
 /** Test if iterator is true.
  * This operation will return true if the iterator returns at least one result.
- * This is especially useful in combination with fact-checking rules (see the
- * rules addon).
+ * This is especially useful in combination with fact-checking querys (see the
+ * querys addon).
  *
  * The operation requires a valid iterator. After the operation is invoked, the
  * application should no longer invoke next on the iterator and should treat it
@@ -7780,20 +7537,20 @@ ecs_entity_t ecs_iter_first(
  * Example:
  *
  * @code
- * // Rule that matches (Eats, *)
- * ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+ * // Query that matches (Eats, *)
+ * ecs_query_t *q = ecs_query(world, {
  *   .terms = {
  *     { .first.id = Eats, .second.name = "$food" }
  *   }
  * });
- *
- * int food_var = ecs_rule_find_var(r, "food");
- *
+ * 
+ * int food_var = ecs_query_find_var(r, "food");
+ * 
  * // Set Food to Apples, so we're only matching (Eats, Apples)
- * ecs_iter_t it = ecs_rule_iter(world, r);
+ * ecs_iter_t it = ecs_query_iter(world, q);
  * ecs_iter_set_var(&it, food_var, Apples);
- *
- * while (ecs_rule_next(&it)) {
+ * 
+ * while (ecs_query_next(&it)) {
  *   for (int i = 0; i < it.count; i ++) {
  *     // iterate as usual
  *   }
@@ -7908,6 +7665,10 @@ bool ecs_iter_var_is_constrained(
     ecs_iter_t *it,
     int32_t var_id);
 
+FLECS_API
+bool ecs_iter_changed(
+    ecs_iter_t *it);
+
 /** Convert iterator to string.
  * Prints the contents of an iterator to a string. Useful for debugging and/or
  * testing the output of an iterator.
@@ -8078,7 +7839,7 @@ ecs_id_t ecs_field_id(
  * @return The index of the matched column, -1 if not matched.
  */
 FLECS_API
-int32_t ecs_field_column_index(
+int32_t ecs_field_column(
     const ecs_iter_t *it,
     int32_t index);
 
@@ -8551,7 +8312,7 @@ int32_t ecs_search_relation(
     int32_t offset,
     ecs_id_t id,
     ecs_entity_t rel,
-    ecs_flags32_t flags, /* EcsSelf and/or EcsUp */
+    ecs_flags64_t flags, /* EcsSelf and/or EcsUp */
     ecs_entity_t *subject_out,
     ecs_id_t *id_out,
     struct ecs_table_record_t **tr_out);
@@ -8794,7 +8555,7 @@ int ecs_value_move_ctor(
         desc.add_expr = #__VA_ARGS__; \
         id_ = ecs_entity_init(world, &desc); \
         ecs_id(id_) = id_; \
-        ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, NULL); \
+        ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, "failed to create entity %s", #id_); \
     } \
     (void)id_; \
     (void)ecs_id(id_)
@@ -8882,7 +8643,7 @@ int ecs_value_move_ctor(
         desc.type.alignment = ECS_ALIGNOF(id_); \
         ecs_id(id_) = ecs_component_init(world, &desc);\
     }\
-    ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, NULL)
+    ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, "failed to create component %s", #id_)
 
 /** Declare & define a component.
  *
@@ -8916,10 +8677,10 @@ int ecs_value_move_ctor(
         edesc.name = #id_; \
         desc.entity = ecs_entity_init(world, &edesc); \
         desc.callback = id_;\
-        desc.filter.expr = #__VA_ARGS__;\
+        desc.query.expr = #__VA_ARGS__;\
         desc.events[0] = kind;\
         ecs_id(id_) = ecs_observer_init(world, &desc);\
-        ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, NULL);\
+        ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, "failed to create observer %s", #id_);\
     }
 
 /** Declare & define an observer.
@@ -8937,6 +8698,41 @@ int ecs_value_move_ctor(
     (void)ecs_id(id);\
     (void)id
 
+/* Forward declare a query. */
+#define ECS_QUERY_DECLARE(name)         ecs_query_t* name
+
+/** Define a forward declared observer.
+ *
+ * Example:
+ *
+ * @code
+ * ECS_QUERY_DEFINE(world, AddPosition, Position);
+ * @endcode
+ */
+#define ECS_QUERY_DEFINE(world, name_, ...)\
+    {\
+        ecs_query_desc_t desc = {0};\
+        ecs_entity_desc_t edesc = {0}; \
+        edesc.name = #name_; \
+        desc.entity = ecs_entity_init(world, &edesc); \
+        desc.expr = #__VA_ARGS__;\
+        name_ = ecs_query_init(world, &desc);\
+        ecs_assert(name_ != NULL, ECS_INVALID_PARAMETER, "failed to create query %s", #name_);\
+    }
+
+/** Declare & define an observer.
+ *
+ * Example:
+ *
+ * @code
+ * ECS_OBSERVER(world, AddPosition, EcsOnAdd, Position);
+ * @endcode
+ */
+#define ECS_QUERY(world, name, ...)\
+    ecs_query_t* name = NULL; \
+    ECS_QUERY_DEFINE(world, name, __VA_ARGS__);\
+    (void)name
+
 /** Shorthand for creating an entity with ecs_entity_init().
  *
  * Example:
@@ -8983,28 +8779,12 @@ int ecs_value_move_ctor(
         .type.alignment = ECS_ALIGNOF(T) \
     })
 
-/** Shorthand for creating a filter with ecs_filter_init().
- *
- * Example:
- *
- * @code
- * ecs_filter(world, {
- *   .terms = {{ ecs_id(Position) }}
- * });
- * @endcode
- */
-#define ecs_filter(world, ...)\
-    ecs_filter_init(world, &(ecs_filter_desc_t) __VA_ARGS__ )
-
-/** Shorthand for creating a query with ecs_query_init().
+/** Shorthand for creating a query with ecs_query_cache_init.
  *
  * Example:
- *
- * @code
- * ecs_query(world, {
- *   .filter.terms = {{ ecs_id(Position) }}
- * });
- * @endcode
+ *   ecs_query(world, {
+ *     .terms = {{ ecs_id(Position) }}
+ *   });
  */
 #define ecs_query(world, ...)\
     ecs_query_init(world, &(ecs_query_desc_t) __VA_ARGS__ )
@@ -9015,7 +8795,7 @@ int ecs_value_move_ctor(
  *
  * @code
  * ecs_observer(world, {
- *   .filter.terms = {{ ecs_id(Position) }},
+ *   .terms = {{ ecs_id(Position) }},
  *   .events = { EcsOnAdd },
  *   .callback = AddPosition
  * });
@@ -9043,7 +8823,7 @@ int ecs_value_move_ctor(
  * @{
  */
 
-#define ecs_new(world, T) ecs_new_w_id(world, ecs_id(T))
+#define ecs_new_w(world, T) ecs_new_w_id(world, ecs_id(T))
 
 #define ecs_new_w_pair(world, first, second)\
     ecs_new_w_id(world, ecs_pair(first, second))
@@ -9051,20 +8831,6 @@ int ecs_value_move_ctor(
 #define ecs_bulk_new(world, component, count)\
     ecs_bulk_new_w_id(world, ecs_id(component), count)
 
-#define ecs_new_entity(world, n)\
-    ecs_entity_init(world, &(ecs_entity_desc_t){\
-        .name = n,\
-    })
-
-#define ecs_new_prefab(world, n)\
-    ecs_entity_init(world, &(ecs_entity_desc_t){\
-        .name = n,\
-        .add = {EcsPrefab}\
-    })
-
-#define ecs_delete_children(world, parent)\
-    ecs_delete_with(world, ecs_pair(EcsChildOf, parent))
-
 /** @} */
 
 /**
@@ -9099,6 +8865,10 @@ int ecs_value_move_ctor(
  * @{
  */
 
+/* insert */
+#define ecs_insert(world, ...)\
+    ecs_entity(world, { .set = ecs_values(__VA_ARGS__)})
+
 /* set */
 
 #define ecs_set_ptr(world, entity, component, ptr)\
@@ -9117,19 +8887,17 @@ int ecs_value_move_ctor(
         ecs_pair(first, ecs_id(Second)),\
         sizeof(Second), &(Second)__VA_ARGS__)
 
-#define ecs_set_pair_object ecs_set_pair_second
-
 #define ecs_set_override(world, entity, T, ...)\
     ecs_add_id(world, entity, ECS_OVERRIDE | ecs_id(T));\
     ecs_set(world, entity, T, __VA_ARGS__)
 
 /* emplace */
 
-#define ecs_emplace(world, entity, T)\
-    (ECS_CAST(T*, ecs_emplace_id(world, entity, ecs_id(T))))
+#define ecs_emplace(world, entity, T, is_new)\
+    (ECS_CAST(T*, ecs_emplace_id(world, entity, ecs_id(T), is_new)))
 
-#define ecs_emplace_pair(world, entity, First, second)\
-    (ECS_CAST(First*, ecs_emplace_id(world, entity, ecs_pair_t(First, second))))
+#define ecs_emplace_pair(world, entity, First, second, is_new)\
+    (ECS_CAST(First*, ecs_emplace_id(world, entity, ecs_pair_t(First, second), is_new)))
 
 /* get */
 
@@ -9144,8 +8912,6 @@ int ecs_value_move_ctor(
     (ECS_CAST(const Second*, ecs_get_id(world, subject,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_get_pair_object ecs_get_pair_second
-
 /* get_mut */
 
 #define ecs_get_mut(world, entity, T)\
@@ -9159,8 +8925,6 @@ int ecs_value_move_ctor(
     (ECS_CAST(Second*, ecs_get_mut_id(world, subject,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_get_mut_pair_object ecs_get_mut_pair_second
-
 #define ecs_get_mut(world, entity, T)\
     (ECS_CAST(T*, ecs_get_mut_id(world, entity, ecs_id(T))))
 
@@ -9177,8 +8941,6 @@ int ecs_value_move_ctor(
     (ECS_CAST(Second*, ecs_ensure_id(world, subject,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_ensure_pair_object ecs_ensure_pair_second
-
 #define ecs_ensure(world, entity, T)\
     (ECS_CAST(T*, ecs_ensure_id(world, entity, ecs_id(T))))
 
@@ -9190,8 +8952,6 @@ int ecs_value_move_ctor(
     (ECS_CAST(Second*, ecs_ensure_id(world, subject,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_ensure_pair_object ecs_ensure_pair_second
-
 /* modified */
 
 #define ecs_modified(world, entity, component)\
@@ -9227,8 +8987,6 @@ int ecs_value_move_ctor(
     (ECS_CAST(Second*, ecs_record_ensure_id(world, record,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_record_ensure_pair_object ecs_record_ensure_pair_second
-
 #define ecs_ref_init(world, entity, T)\
     ecs_ref_init_id(world, entity, ecs_id(T))
 
@@ -9302,7 +9060,7 @@ int ecs_value_move_ctor(
 #define ecs_enable_component(world, entity, T, enable)\
     ecs_enable_id(world, entity, ecs_id(T), enable)
 
-#define ecs_is_enabled_component(world, entity, T)\
+#define ecs_is_enabled(world, entity, T)\
     ecs_is_enabled_id(world, entity, ecs_id(T))
 
 #define ecs_enable_pair(world, entity, First, second, enable)\
@@ -9321,10 +9079,6 @@ int ecs_value_move_ctor(
 #define ecs_lookup_path(world, parent, path)\
     ecs_lookup_path_w_sep(world, parent, path, ".", NULL, true)
 
-/* Deprecated: use ecs_lookup instead */
-#define ecs_lookup_fullpath(world, path)\
-    ecs_lookup(world, path)
-
 #define ecs_get_path(world, parent, child)\
     ecs_get_path_w_sep(world, parent, child, ".", NULL)
 
@@ -9337,9 +9091,6 @@ int ecs_value_move_ctor(
 #define ecs_new_from_path(world, parent, path)\
     ecs_new_from_path_w_sep(world, parent, path, ".", NULL)
 
-#define ecs_new_from_fullpath(world, path)\
-    ecs_new_from_path_w_sep(world, 0, path, ".", NULL)
-
 #define ecs_add_path(world, entity, parent, path)\
     ecs_add_path_w_sep(world, entity, parent, path, ".", NULL)
 
@@ -9467,9 +9218,27 @@ int ecs_value_move_ctor(
  * @{
  */
 
-#define ecs_value(T, ptr) ((ecs_value_t){ecs_id(T), ptr})
+/** Convenience macro for creating compound literal id array */
+#define ecs_ids(...) (ecs_id_t[]){ __VA_ARGS__, 0 }
+
+/** Convenience macro for creating compound literal values array */
+#define ecs_values(...) (ecs_value_t[]){ __VA_ARGS__, {0, 0}}
+
+/** Convenience macro for creating compound literal value */
+#define ecs_value_ptr(T, ptr) ((ecs_value_t){ecs_id(T), ptr})
+
+/** Convenience macro for creating compound literal pair value */
+#define ecs_value_pair(R, t, ...) ((ecs_value_t){ecs_pair_t(R, t), &(R)__VA_ARGS__})
+
+/** Convenience macro for creating compound literal pair value */
+#define ecs_value_pair_2nd(r, T, ...) ((ecs_value_t){ecs_pair(r, ecs_id(T)), &(T)__VA_ARGS__})
+
+/** Convenience macro for creating heap allocated value */
 #define ecs_value_new_t(world, T) ecs_value_new(world, ecs_id(T))
 
+/** Convenience macro for creating compound literal value literal */
+#define ecs_value(T, ...) ((ecs_value_t){ecs_id(T), &(T)__VA_ARGS__})
+
 /** @} */
 
 /** @} */
@@ -9607,16 +9376,11 @@ int ecs_value_move_ctor(
 #define ecs_isa(e)       ecs_pair(EcsIsA, e)
 #define ecs_childof(e)   ecs_pair(EcsChildOf, e)
 #define ecs_dependson(e) ecs_pair(EcsDependsOn, e)
+#define ecs_with(e)      ecs_pair(EcsWith, e)
 
-#define ecs_query_new(world, q_expr)\
-    ecs_query_init(world, &(ecs_query_desc_t){\
-        .filter.expr = q_expr\
-    })
-
-#define ecs_rule_new(world, q_expr)\
-    ecs_rule_init(world, &(ecs_filter_desc_t){\
-        .expr = q_expr\
-    })
+#define ecs_each(world, id) ecs_each_id(world, ecs_id(id))
+#define ecs_each_pair(world, r, t) ecs_each_id(world, ecs_pair(r, t))
+#define ecs_each_pair_t(world, R, t) ecs_each_id(world, ecs_pair(ecs_id(R), t))
 
 /** @} */
 
@@ -9646,17 +9410,8 @@ int ecs_value_move_ctor(
 #ifdef FLECS_NO_MODULE
 #undef FLECS_MODULE
 #endif
-#ifdef FLECS_NO_PARSER
-#undef FLECS_PARSER
-#endif
-#ifdef FLECS_NO_PLECS
-#undef FLECS_PLECS
-#endif
-#ifdef FLECS_NO_RULES
-#undef FLECS_RULES
-#endif
-#ifdef FLECS_NO_SNAPSHOT
-#undef FLECS_SNAPSHOT
+#ifdef FLECS_NO_SCRIPT
+#undef FLECS_SCRIPT
 #endif
 #ifdef FLECS_NO_MONITOR
 #undef FLECS_MONITOR
@@ -9676,15 +9431,9 @@ int ecs_value_move_ctor(
 #ifdef FLECS_NO_META
 #undef FLECS_META
 #endif
-#ifdef FLECS_NO_META_C
-#undef FLECS_META_C
-#endif
 #ifdef FLECS_NO_UNITS
 #undef FLECS_UNITS
 #endif
-#ifdef FLECS_NO_EXPR
-#undef FLECS_EXPR
-#endif
 #ifdef FLECS_NO_JSON
 #undef FLECS_JSON
 #endif
@@ -10383,12 +10132,6 @@ int ecs_log_last_error(void);
 #endif
 #endif
 
-#ifdef FLECS_PLECS
-#ifndef FLECS_EXPR
-#define FLECS_EXPR
-#endif
-#endif
-
 #ifdef FLECS_APP
 #ifdef FLECS_NO_APP
 #error "FLECS_NO_APP failed: APP is required by other addons"
@@ -11187,11 +10930,11 @@ extern "C" {
         edesc.id = id_;\
         edesc.name = #id_;\
         desc.entity = ecs_entity_init(world, &edesc);\
-        desc.query.filter.expr = #__VA_ARGS__; \
+        desc.query.expr = #__VA_ARGS__; \
         id_ = ecs_pipeline_init(world, &desc); \
         ecs_id(id_) = id_;\
     } \
-    ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, "failed to create pipeline");
 
 #define ECS_PIPELINE(world, id, ...) \
     ecs_entity_t id = 0, ecs_id(id) = 0; ECS_PIPELINE_DEFINE(world, id, __VA_ARGS__);\
@@ -11421,9 +11164,8 @@ typedef struct ecs_system_desc_t {
      *
      * It should not be assumed that the input iterator can always be iterated
      * with ecs_query_next(). When a system is multithreaded and/or paged, the
-     * iterator can be either a worker or paged iterator. Future use cases may
-     * introduce additional inputs for a system, such as rules and filters. The
-     * correct function to use for iteration is ecs_iter_next().
+     * iterator can be either a worker or paged iterator. The correct function 
+     * to use for iteration is ecs_iter_next().
      *
      * An implementation can test whether the iterator is a query iterator by
      * testing whether the it->next value is equal to ecs_query_next(). */
@@ -11460,7 +11202,7 @@ typedef struct ecs_system_desc_t {
 
     /** If true, system will have access to the actual world. Cannot be true at the
      * same time as multi_threaded. */
-    bool no_readonly;
+    bool immediate;
 } ecs_system_desc_t;
 
 /** Create a system */
@@ -11486,16 +11228,20 @@ ecs_entity_t ecs_system_init(
     { \
         ecs_system_desc_t desc = {0}; \
         ecs_entity_desc_t edesc = {0}; \
+        ecs_id_t add_ids[3] = {\
+            ((phase) ? ecs_pair(EcsDependsOn, (phase)) : 0), \
+            (phase), \
+            0 \
+        };\
         edesc.id = ecs_id(id_);\
         edesc.name = #id_;\
-        edesc.add[0] = ((phase) ? ecs_pair(EcsDependsOn, (phase)) : 0); \
-        edesc.add[1] = (phase); \
+        edesc.add = add_ids;\
         desc.entity = ecs_entity_init(world, &edesc);\
-        desc.query.filter.expr = #__VA_ARGS__; \
+        desc.query.expr = #__VA_ARGS__; \
         desc.callback = id_; \
         ecs_id(id_) = ecs_system_init(world, &desc); \
     } \
-    ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, NULL)
+    ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, "failed to create system %s", #id_)
 
 /** Declare & define a system.
  *
@@ -11519,9 +11265,9 @@ ecs_entity_t ecs_system_init(
  * ecs_system(world, {
  *   .entity = ecs_entity(world, {
  *     .name = "MyEntity",
- *     .add = { ecs_dependson(EcsOnUpdate) }
+ *     .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
  *   }),
- *   .query.filter.terms = {
+ *   .query.terms = {
  *     { ecs_id(Position) },
  *     { ecs_id(Velocity) }
  *   },
@@ -11587,35 +11333,6 @@ ecs_entity_t ecs_run_worker(
     ecs_ftime_t delta_time,
     void *param);
 
-/** Run system with offset/limit and type filter.
- * This operation is the same as ecs_run(), but filters the entities that will be
- * iterated by the system.
- *
- * Entities can be filtered in two ways. Offset and limit control the range of
- * entities that is iterated over. The range is applied to all entities matched
- * with the system, thus may cover multiple archetypes.
- *
- * The type filter controls which entity types the system will evaluate. Only
- * types that contain all components in the type filter will be iterated over. A
- * type filter is only evaluated once per table, which makes filtering cheap if
- * the number of entities is large and the number of tables is small, but not as
- * cheap as filtering in the system signature.
- *
- * @param world The world.
- * @param system The system to invoke.
- * @param delta_time The time passed since the last system invocation.
- * @param param A user-defined parameter to pass to the system.
- * @return handle to last evaluated entity if system was interrupted.
- */
-FLECS_API
-ecs_entity_t ecs_run_w_filter(
-    ecs_world_t *world,
-    ecs_entity_t system,
-    ecs_ftime_t delta_time,
-    int32_t offset,
-    int32_t limit,
-    void *param);
-
 /** Get the query object for a system.
  * Systems use queries under the hood. This enables an application to get access
  * to the underlying query object of a system. This can be useful when, for
@@ -11831,17 +11548,18 @@ typedef struct ecs_world_stats_t {
     int32_t t;
 } ecs_world_stats_t;
 
-/** Statistics for a single query (use ecs_query_stats_get()) */
+/** Statistics for a single query (use ecs_query_cache_stats_get) */
 typedef struct ecs_query_stats_t {
     int64_t first_;
-    ecs_metric_t matched_table_count;       /**< Matched non-empty tables */
-    ecs_metric_t matched_empty_table_count; /**< Matched empty tables */
+    ecs_metric_t result_count;              /**< Number of query results */
+    ecs_metric_t matched_table_count;       /**< Number of matched tables */
+    ecs_metric_t matched_empty_table_count; /**< Number of matched empty tables */
     ecs_metric_t matched_entity_count;      /**< Number of matched entities */
     ecs_metric_t eval_count;                /**< Number of times query is evaluated */
     int64_t last_;
 
-    /** Current position in ring buffer */
-    int32_t t;
+    /** Current position in ringbuffer */
+    int32_t t; 
 } ecs_query_stats_t;
 
 /** Statistics for a single system (use ecs_system_stats_get()) */
@@ -11864,7 +11582,7 @@ typedef struct ecs_sync_stats_t {
 
     int32_t system_count;
     bool multi_threaded;
-    bool no_readonly;
+    bool immediate;
 } ecs_sync_stats_t;
 
 /** Statistics for all systems in a pipeline. */
@@ -11944,26 +11662,26 @@ void ecs_query_stats_get(
     ecs_query_stats_t *stats);
 
 /** Reduce source measurement window into single destination measurement. */
-FLECS_API
-void ecs_query_stats_reduce(
+FLECS_API 
+void ecs_query_cache_stats_reduce(
     ecs_query_stats_t *dst,
     const ecs_query_stats_t *src);
 
 /** Reduce last measurement into previous measurement, restore old value. */
 FLECS_API
-void ecs_query_stats_reduce_last(
+void ecs_query_cache_stats_reduce_last(
     ecs_query_stats_t *stats,
     const ecs_query_stats_t *old,
     int32_t count);
 
 /** Repeat last measurement. */
 FLECS_API
-void ecs_query_stats_repeat_last(
+void ecs_query_cache_stats_repeat_last(
     ecs_query_stats_t *stats);
 
 /** Copy last measurement from source to destination. */
 FLECS_API
-void ecs_query_stats_copy_last(
+void ecs_query_cache_stats_copy_last(
     ecs_query_stats_t *dst,
     const ecs_query_stats_t *src);
 
@@ -12365,11 +12083,11 @@ typedef struct ecs_alert_desc_t {
     /** Alert query. An alert will be created for each entity that matches the
      * specified query. The query must have at least one term that uses the
      * $this variable (default). */
-    ecs_filter_desc_t filter;
+    ecs_query_desc_t query;
 
     /** Template for alert message. This string is used to generate the alert
      * message and may refer to variables in the query result. The format for
-     * the template expressions is as specified by ecs_interpolate_string().
+     * the template expressions is as specified by ecs_script_string_interpolate().
      *
      * Examples:
      *
@@ -12597,331 +12315,97 @@ void FlecsMonitorImport(
 
 #endif
 
-#ifdef FLECS_DOC
-#ifdef FLECS_NO_DOC
-#error "FLECS_NO_DOC failed: DOC is required by other addons"
+#ifdef FLECS_JSON
+#ifdef FLECS_NO_JSON
+#error "FLECS_NO_JSON failed: JSON is required by other addons"
 #endif
 /**
- * @file addons/doc.h
- * @brief Doc module.
+ * @file addons/json.h
+ * @brief JSON parser addon.
  *
- * The doc module allows for documenting entities (and thus components, systems)
- * by adding brief and/or detailed descriptions as components. Documentation
- * added with the doc module can be retrieved at runtime, and can be used by
- * tooling such as UIs or documentation frameworks.
+ * Parse expression strings into component values. Entity identifiers,
+ * enumerations and bitmasks are encoded as strings.
+ *
+ * See docs/JsonFormat.md for a description of the JSON format.
  */
 
-#ifdef FLECS_DOC
-
-#ifndef FLECS_DOC_H
-#define FLECS_DOC_H
+#ifdef FLECS_JSON
 
-#ifndef FLECS_MODULE
-#define FLECS_MODULE
+#ifndef FLECS_META
+#define FLECS_META
 #endif
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#ifndef FLECS_JSON_H
+#define FLECS_JSON_H
 
 /**
- * @defgroup c_addons_doc Doc
+ * @defgroup c_addons_json Json
  * @ingroup c_addons
- * Utilities for documenting entities, components and systems.
+ * Functions for serializing to/from JSON.
  *
  * @{
  */
 
-FLECS_API extern const ecs_entity_t ecs_id(EcsDocDescription);
-FLECS_API extern const ecs_entity_t EcsDocBrief;
-FLECS_API extern const ecs_entity_t EcsDocDetail;
-FLECS_API extern const ecs_entity_t EcsDocLink;
-FLECS_API extern const ecs_entity_t EcsDocColor;
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-typedef struct EcsDocDescription {
-    char *value;
-} EcsDocDescription;
+/** Used with ecs_ptr_from_json(), ecs_entity_from_json(). */
+typedef struct ecs_from_json_desc_t {
+    const char *name; /**< Name of expression (used for logging) */
+    const char *expr; /**< Full expression (used for logging) */
 
-/** Add human-readable name to entity.
- * Contrary to entity names, human readable names do not have to be unique and
- * can contain special characters used in the query language like '*'.
+    /** Callback that allows for specifying a custom lookup function. The
+     * default behavior uses ecs_lookup() */
+    ecs_entity_t (*lookup_action)(
+        const ecs_world_t*,
+        const char *value,
+        void *ctx);
+    void *lookup_ctx;
+
+    /** Require components to be registered with reflection data. When not
+     * in strict mode, values for components without reflection are ignored. */
+    bool strict;
+} ecs_from_json_desc_t;
+
+/** Parse JSON string into value.
+ * This operation parses a JSON expression into the provided pointer. The
+ * memory pointed to must be large enough to contain a value of the used type.
  *
  * @param world The world.
- * @param entity The entity to which to add the name.
- * @param name The name to add.
- *
- * @see ecs_doc_get_name()
- * @see flecs::doc::set_name()
- * @see flecs::entity_builder::set_doc_name()
+ * @param type The type of the expression to parse.
+ * @param ptr Pointer to the memory to write to.
+ * @param json The JSON expression to parse.
+ * @param desc Configuration parameters for deserializer.
+ * @return Pointer to the character after the last one read, or NULL if failed.
  */
 FLECS_API
-void ecs_doc_set_name(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *name);
+const char* ecs_ptr_from_json(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    void *ptr,
+    const char *json,
+    const ecs_from_json_desc_t *desc);
 
-/** Add brief description to entity.
+/** Parse JSON object with multiple component values into entity. The format
+ * is the same as the one outputted by ecs_entity_to_json(), but at the moment
+ * only supports the "ids" and "values" member.
  *
  * @param world The world.
- * @param entity The entity to which to add the description.
- * @param description The description to add.
- *
- * @see ecs_doc_get_brief()
- * @see flecs::doc::set_brief()
- * @see flecs::entity_builder::set_doc_brief()
+ * @param entity The entity to serialize to.
+ * @param json The JSON expression to parse (see entity in JSON format manual).
+ * @param desc Configuration parameters for deserializer.
+ * @return Pointer to the character after the last one read, or NULL if failed.
  */
 FLECS_API
-void ecs_doc_set_brief(
+const char* ecs_entity_from_json(
     ecs_world_t *world,
     ecs_entity_t entity,
-    const char *description);
+    const char *json,
+    const ecs_from_json_desc_t *desc);
 
-/** Add detailed description to entity.
- *
- * @param world The world.
- * @param entity The entity to which to add the description.
- * @param description The description to add.
- *
- * @see ecs_doc_get_detail()
- * @see flecs::doc::set_detail()
- * @see flecs::entity_builder::set_doc_detail()
- */
-FLECS_API
-void ecs_doc_set_detail(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *description);
-
-/** Add link to external documentation to entity.
- *
- * @param world The world.
- * @param entity The entity to which to add the link.
- * @param link The link to add.
- *
- * @see ecs_doc_get_link()
- * @see flecs::doc::set_link()
- * @see flecs::entity_builder::set_doc_link()
- */
-FLECS_API
-void ecs_doc_set_link(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *link);
-
-/** Add color to entity.
- * UIs can use color as hint to improve visualizing entities.
- *
- * @param world The world.
- * @param entity The entity to which to add the link.
- * @param color The color to add.
- *
- * @see ecs_doc_get_color()
- * @see flecs::doc::set_color()
- * @see flecs::entity_builder::set_doc_color()
- */
-FLECS_API
-void ecs_doc_set_color(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *color);
-
-/** Get human readable name from entity.
- * If entity does not have an explicit human readable name, this operation will
- * return the entity name.
- *
- * To test if an entity has a human readable name, use:
- *
- * @code
- * ecs_has_pair(world, e, ecs_id(EcsDocDescription), EcsName);
- * @endcode
- *
- * Or in C++:
- *
- * @code
- * e.has<flecs::doc::Description>(flecs::Name);
- * @endcode
- *
- * @param world The world.
- * @param entity The entity from which to get the name.
- * @return The name.
- *
- * @see ecs_doc_set_name()
- * @see flecs::doc::get_name()
- * @see flecs::entity_view::get_doc_name()
- */
-FLECS_API
-const char* ecs_doc_get_name(
-    const ecs_world_t *world,
-    ecs_entity_t entity);
-
-/** Get brief description from entity.
- *
- * @param world The world.
- * @param entity The entity from which to get the description.
- * @return The description.
- *
- * @see ecs_doc_set_brief()
- * @see flecs::doc::get_brief()
- * @see flecs::entity_view::get_doc_brief()
- */
-FLECS_API
-const char* ecs_doc_get_brief(
-    const ecs_world_t *world,
-    ecs_entity_t entity);
-
-/** Get detailed description from entity.
- *
- * @param world The world.
- * @param entity The entity from which to get the description.
- * @return The description.
- *
- * @see ecs_doc_set_detail()
- * @see flecs::doc::get_detail()
- * @see flecs::entity_view::get_doc_detail()
- */
-FLECS_API
-const char* ecs_doc_get_detail(
-    const ecs_world_t *world,
-    ecs_entity_t entity);
-
-/** Get link to external documentation from entity.
- *
- * @param world The world.
- * @param entity The entity from which to get the link.
- * @return The link.
- *
- * @see ecs_doc_set_link()
- * @see flecs::doc::get_link()
- * @see flecs::entity_view::get_doc_link()
- */
-FLECS_API
-const char* ecs_doc_get_link(
-    const ecs_world_t *world,
-    ecs_entity_t entity);
-
-/** Get color from entity.
- *
- * @param world The world.
- * @param entity The entity from which to get the color.
- * @return The color.
- *
- * @see ecs_doc_set_color()
- * @see flecs::doc::get_color()
- * @see flecs::entity_view::get_doc_color()
- */
-FLECS_API
-const char* ecs_doc_get_color(
-    const ecs_world_t *world,
-    ecs_entity_t entity);
-
-/* Module import */
-FLECS_API
-void FlecsDocImport(
-    ecs_world_t *world);
-
-/** @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-#endif
-
-#endif
-
-#ifdef FLECS_JSON
-#ifdef FLECS_NO_JSON
-#error "FLECS_NO_JSON failed: JSON is required by other addons"
-#endif
-/**
- * @file addons/json.h
- * @brief JSON parser addon.
- *
- * Parse expression strings into component values. Entity identifiers,
- * enumerations and bitmasks are encoded as strings.
- *
- * See docs/JsonFormat.md for a description of the JSON format.
- */
-
-#ifdef FLECS_JSON
-
-#ifndef FLECS_EXPR
-#define FLECS_EXPR
-#endif
-
-#ifndef FLECS_JSON_H
-#define FLECS_JSON_H
-
-/**
- * @defgroup c_addons_json Json
- * @ingroup c_addons
- * Functions for serializing to/from JSON.
- *
- * @{
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Used with ecs_ptr_from_json(), ecs_entity_from_json(). */
-typedef struct ecs_from_json_desc_t {
-    const char *name; /**< Name of expression (used for logging) */
-    const char *expr; /**< Full expression (used for logging) */
-
-    /** Callback that allows for specifying a custom lookup function. The
-     * default behavior uses ecs_lookup() */
-    ecs_entity_t (*lookup_action)(
-        const ecs_world_t*,
-        const char *value,
-        void *ctx);
-    void *lookup_ctx;
-
-    /** Require components to be registered with reflection data. When not
-     * in strict mode, values for components without reflection are ignored. */
-    bool strict;
-} ecs_from_json_desc_t;
-
-/** Parse JSON string into value.
- * This operation parses a JSON expression into the provided pointer. The
- * memory pointed to must be large enough to contain a value of the used type.
- *
- * @param world The world.
- * @param type The type of the expression to parse.
- * @param ptr Pointer to the memory to write to.
- * @param json The JSON expression to parse.
- * @param desc Configuration parameters for deserializer.
- * @return Pointer to the character after the last one read, or NULL if failed.
- */
-FLECS_API
-const char* ecs_ptr_from_json(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    void *ptr,
-    const char *json,
-    const ecs_from_json_desc_t *desc);
-
-/** Parse JSON object with multiple component values into entity. The format
- * is the same as the one outputted by ecs_entity_to_json(), but at the moment
- * only supports the "ids" and "values" member.
- *
- * @param world The world.
- * @param entity The entity to serialize to.
- * @param json The JSON expression to parse (see entity in JSON format manual).
- * @param desc Configuration parameters for deserializer.
- * @return Pointer to the character after the last one read, or NULL if failed.
- */
-FLECS_API
-const char* ecs_entity_from_json(
-    ecs_world_t *world,
-    ecs_entity_t entity,
-    const char *json,
-    const ecs_from_json_desc_t *desc);
-
-/** Parse JSON object with multiple entities into the world. The format is the
- * same as the one outputted by ecs_world_to_json().
+/** Parse JSON object with multiple entities into the world. The format is the
+ * same as the one outputted by ecs_world_to_json().
  *
  * @param world The world.
  * @param json The JSON expression to parse (see iterator in JSON format manual).
@@ -13126,7 +12610,7 @@ typedef struct ecs_iter_to_json_desc_t {
     bool serialize_query_plan;      /**< Serialize query plan */
     bool serialize_query_profile;   /**< Profile query performance */
     bool dont_serialize_results;    /**< If true, query won't be evaluated */
-    ecs_poly_t *query;              /**< Query object (required for serialize_query_[plan|profile]). */
+    flecs_poly_t *query;              /**< Query object (required for serialize_query_[plan|profile]). */
 } ecs_iter_to_json_desc_t;
 
 #define ECS_ITER_TO_JSON_INIT (ecs_iter_to_json_desc_t){\
@@ -13160,27 +12644,23 @@ typedef struct ecs_iter_to_json_desc_t {
  * This operation will iterate the contents of the iterator and serialize them
  * to JSON. The function accepts iterators from any source.
  *
- * @param world The world.
  * @param iter The iterator to serialize to JSON.
  * @return A JSON string with the serialized iterator data, or NULL if failed.
  */
 FLECS_API
 char* ecs_iter_to_json(
-    const ecs_world_t *world,
     ecs_iter_t *iter,
     const ecs_iter_to_json_desc_t *desc);
 
 /** Serialize iterator into JSON string buffer.
  * Same as ecs_iter_to_json(), but serializes to an ecs_strbuf_t instance.
  *
- * @param world The world.
  * @param iter The iterator to serialize.
  * @param buf_out The strbuf to append the string to.
  * @return Zero if success, non-zero if failed.
  */
 FLECS_API
 int ecs_iter_to_json_buf(
-    const ecs_world_t *world,
     ecs_iter_t *iter,
     ecs_strbuf_t *buf_out,
     const ecs_iter_to_json_desc_t *desc);
@@ -13194,15 +12674,15 @@ typedef struct ecs_world_to_json_desc_t {
 /** Serialize world into JSON string.
  * This operation iterates the contents of the world to JSON. The operation is
  * equivalent to the following code:
- *
+ * 
  * @code
- * ecs_filter_t *f = ecs_filter(world, {
+ * ecs_query_t *f = ecs_query(world, {
  *   .terms = {{ .id = EcsAny }}
  * });
- *
- * ecs_iter_t it = ecs_filter_init(world, &f);
+ * 
+ * ecs_iter_t it = ecs_query_init(world, &f);
  * ecs_iter_to_json_desc_t desc = { .serialize_table = true };
- * ecs_iter_to_json(world, iter, &desc);
+ * ecs_iter_to_json(iter, &desc);
  * @endcode
  *
  * @param world The world to serialize.
@@ -13238,11 +12718,6 @@ int ecs_world_to_json_buf(
 
 #endif
 
-#if defined(FLECS_EXPR) || defined(FLECS_META_C)
-#ifndef FLECS_META
-#define FLECS_META
-#endif
-#endif
 #ifdef FLECS_UNITS
 #ifdef FLECS_NO_UNITS
 #error "FLECS_NO_UNITS failed: UNITS is required by other addons"
@@ -13584,2165 +13059,1871 @@ void FlecsUnitsImport(
 
 #endif
 
-#ifdef FLECS_META
-#ifdef FLECS_NO_META
-#error "FLECS_NO_META failed: META is required by other addons"
+#ifdef FLECS_SCRIPT
+#ifdef FLECS_NO_SCRIPT
+#error "FLECS_NO_SCRIPT failed: SCRIPT is required by other addons"
 #endif
 /**
- * @file addons/meta.h
- * @brief Meta addon.
+ * @file addons/script.h
+ * @brief Flecs script module.
  *
- * The meta addon enables reflecting on component data. Types are stored as
- * entities, with components that store the reflection data. A type has at least
- * two components:
- *
- * - EcsComponent: core component, contains size & alignment
- * - EcsMetaType:  component that indicates what kind of type the entity is
- *
- * Additionally the type may have an additional component that contains the
- * reflection data for the type. For example, structs have these components:
- *
- * - EcsComponent
- * - EcsMetaType
- * - EcsStruct
- *
- * Structs can be populated by adding child entities with the EcsMember
- * component. Adding a child with a Member component to an entity will
- * automatically add the EcsStruct component to the parent.
- *
- * Enums/bitmasks can be populated by adding child entities with the Constant
- * tag. By default constants are automatically assigned values when they are
- * added to the enum/bitmask. The parent entity must have the EcsEnum or
- * EcsBitmask component before adding the constants.
- *
- * To create enum constants with a manual value, set (Constant, i32) to the
- * desired value. To create bitmask constants with a manual value, set
- * (Constant, u32) to the desired value. Constants with manual values should not
- * conflict with other constants.
- *
- * The _init APIs are convenience wrappers around creating the entities and
- * components for the types.
- *
- * When a type is created it automatically receives the EcsComponent and
- * EcsMetaType components. The former means that the resulting type can be
- * used as a regular component:
- *
- * @code
- * // Create Position type
- * ecs_entity_t pos = ecs_struct_init(world, &(ecs_struct_desc_t){
- *  .entity.name = "Position",
- *  .members = {
- *       {"x", ecs_id(ecs_f32_t)},
- *       {"y", ecs_id(ecs_f32_t)}
- *   }
- * });
- *
- * // Create entity with Position component
- * ecs_entity_t e = ecs_new_w_id(world, pos);
- * @endcode
- *
- * Type entities do not have to be named.
+ * For script, see examples/script.
  */
 
-#ifdef FLECS_META
+#ifdef FLECS_SCRIPT
 
 /**
- * @defgroup c_addons_meta Meta
+ * @defgroup c_addons_script Flecs script
  * @ingroup c_addons
- * Flecs reflection framework.
+ * DSL for loading scenes, assets and configuration.
  *
  * @{
  */
 
-#include <stddef.h>
+#ifndef FLECS_META
+#define FLECS_META
+#endif
 
-#ifndef FLECS_MODULE
-#define FLECS_MODULE
+#ifndef FLECS_DOC
+#define FLECS_DOC
 #endif
 
-#ifndef FLECS_META_H
-#define FLECS_META_H
+
+#ifndef FLECS_SCRIPT_H
+#define FLECS_SCRIPT_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define ECS_MEMBER_DESC_CACHE_SIZE (32)
-
-/** Primitive type definitions.
- * These typedefs allow the builtin primitives to be used as regular components:
- *
- * @code
- * ecs_set(world, e, ecs_i32_t, {10});
- * @endcode
- *
- * Or a more useful example (create an enum constant with a manual value):
- *
- * @code
- * ecs_set_pair_object(world, e, EcsConstant, ecs_i32_t, {10});
- * @endcode
- */
-typedef bool ecs_bool_t;
-typedef char ecs_char_t;
-typedef unsigned char ecs_byte_t;
-typedef uint8_t ecs_u8_t;
-typedef uint16_t ecs_u16_t;
-typedef uint32_t ecs_u32_t;
-typedef uint64_t ecs_u64_t;
-typedef uintptr_t ecs_uptr_t;
-typedef int8_t ecs_i8_t;
-typedef int16_t ecs_i16_t;
-typedef int32_t ecs_i32_t;
-typedef int64_t ecs_i64_t;
-typedef intptr_t ecs_iptr_t;
-typedef float ecs_f32_t;
-typedef double ecs_f64_t;
-typedef char* ecs_string_t;
+FLECS_API
+extern ECS_COMPONENT_DECLARE(EcsScript);
 
-/* Meta module component ids */
-FLECS_API extern const ecs_entity_t ecs_id(EcsMetaType);
-FLECS_API extern const ecs_entity_t ecs_id(EcsMetaTypeSerialized);
-FLECS_API extern const ecs_entity_t ecs_id(EcsPrimitive);
-FLECS_API extern const ecs_entity_t ecs_id(EcsEnum);
-FLECS_API extern const ecs_entity_t ecs_id(EcsBitmask);
-FLECS_API extern const ecs_entity_t ecs_id(EcsMember);
-FLECS_API extern const ecs_entity_t ecs_id(EcsMemberRanges);
-FLECS_API extern const ecs_entity_t ecs_id(EcsStruct);
-FLECS_API extern const ecs_entity_t ecs_id(EcsArray);
-FLECS_API extern const ecs_entity_t ecs_id(EcsVector);
-FLECS_API extern const ecs_entity_t ecs_id(EcsOpaque);
-FLECS_API extern const ecs_entity_t ecs_id(EcsUnit);
-FLECS_API extern const ecs_entity_t ecs_id(EcsUnitPrefix);
-FLECS_API extern const ecs_entity_t EcsConstant;
-FLECS_API extern const ecs_entity_t EcsQuantity;
+typedef struct ecs_script_t ecs_script_t;
+typedef struct ecs_script_assembly_t ecs_script_assembly_t;
 
-/* Primitive type component ids */
-FLECS_API extern const ecs_entity_t ecs_id(ecs_bool_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_char_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_byte_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_u8_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_u16_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_u32_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_u64_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_uptr_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_i8_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_i16_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_i32_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_i64_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_iptr_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_f32_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_f64_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_string_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_entity_t);
-FLECS_API extern const ecs_entity_t ecs_id(ecs_id_t);
+/** Script variable. */
+typedef struct ecs_script_var_t {
+    const char *name;
+    ecs_value_t value;
+    const ecs_type_info_t *type_info;
+} ecs_script_var_t;
 
-/** Type kinds supported by meta addon */
-typedef enum ecs_type_kind_t {
-    EcsPrimitiveType,
-    EcsBitmaskType,
-    EcsEnumType,
-    EcsStructType,
-    EcsArrayType,
-    EcsVectorType,
-    EcsOpaqueType,
-    EcsTypeKindLast = EcsOpaqueType
-} ecs_type_kind_t;
+/** Script variable scope. */
+typedef struct ecs_script_vars_t {
+    struct ecs_script_vars_t *parent;
+    ecs_hashmap_t var_index;
+    ecs_vec_t vars;
 
-/** Component that is automatically added to every type with the right kind. */
-typedef struct EcsMetaType {
-    ecs_type_kind_t kind;
-    bool existing;         /**< Did the type exist or is it populated from reflection */
-    bool partial;          /**< Is the reflection data a partial type description */
-} EcsMetaType;
+    const ecs_world_t *world;
+    struct ecs_stack_t *stack;
+    ecs_stack_cursor_t *cursor;
+    ecs_allocator_t *allocator;
+} ecs_script_vars_t;
 
-/** Primitive type kinds supported by meta addon */
-typedef enum ecs_primitive_kind_t {
-    EcsBool = 1,
-    EcsChar,
-    EcsByte,
-    EcsU8,
-    EcsU16,
-    EcsU32,
-    EcsU64,
-    EcsI8,
-    EcsI16,
-    EcsI32,
-    EcsI64,
-    EcsF32,
-    EcsF64,
-    EcsUPtr,
-    EcsIPtr,
-    EcsString,
-    EcsEntity,
-    EcsId,
-    EcsPrimitiveKindLast = EcsId
-} ecs_primitive_kind_t;
+/** Script component. 
+ * This component is added to the entities of managed scripts and assemblies.
+ */
+typedef struct EcsScript {
+    ecs_script_t *script;
+    ecs_script_assembly_t *assembly; /* Only set for assembly scripts */
+} EcsScript;
 
-/** Component added to primitive types */
-typedef struct EcsPrimitive {
-    ecs_primitive_kind_t kind;
-} EcsPrimitive;
 
-/** Component added to member entities */
-typedef struct EcsMember {
-    ecs_entity_t type;
-    int32_t count;
-    ecs_entity_t unit;
-    int32_t offset;
-} EcsMember;
+/* Parsing & running scripts */
 
-/** Type expressing a range for a member value */
-typedef struct ecs_member_value_range_t {
-    double min;
-    double max;
-} ecs_member_value_range_t;
+/** Parse script.
+ * This operation parses a script and returns a script object upon success. To
+ * run the script, call ecs_script_eval().
+ * 
+ * @param world The world.
+ * @param name Name of the script (typically a file/module name).
+ * @param code The script code.
+ * @return Script object if success, NULL if failed.
+*/
+FLECS_API
+ecs_script_t* ecs_script_parse(
+    ecs_world_t *world,
+    const char *name,
+    const char *code);
 
-/** Component added to member entities to express valid value ranges */
-typedef struct EcsMemberRanges {
-    ecs_member_value_range_t value;
-    ecs_member_value_range_t warning;
-    ecs_member_value_range_t error;
-} EcsMemberRanges;
+/** Evaluate script.
+ * This operation evaluates (runs) a parsed script.
+ * 
+ * @param script The script.
+ * @return Zero if success, non-zero if failed.
+*/
+FLECS_API
+int ecs_script_eval(
+    ecs_script_t *script);
 
-/** Element type of members vector in EcsStruct */
-typedef struct ecs_member_t {
-    /** Must be set when used with ecs_struct_desc_t */
-    const char *name;
-    ecs_entity_t type;
+/** Free script.
+ * This operation frees a script object.
+ * 
+ * Assemblies created by the script rely upon resources in the script object,
+ * and for that reason keep the script alive until all assemblies created by the
+ * script are deleted.
+ *
+ * @param script The script.
+ */
+FLECS_API
+void ecs_script_free(
+    ecs_script_t *script);
 
-    /** May be set when used with ecs_struct_desc_t */
-    int32_t count;
-    int32_t offset;
+/** Parse script.
+ * This parses a script and instantiates the entities in the world.
+ * This operation is the equivalent to doing:
+ * 
+ * @code
+ * ecs_script_t *script = ecs_script_parse(world, name, code);
+ * ecs_script_eval(script);
+ * ecs_script_free(script);
+ * @endcode
+ * 
+ * @param world The world.
+ * @param name The script name (typically the file).
+ * @param code The script.
+ * @return Zero if success, non-zero otherwise.
+ */
+FLECS_API
+int ecs_script_run(
+    ecs_world_t *world,
+    const char *name,
+    const char *code);
 
-    /** May be set when used with ecs_struct_desc_t, will be auto-populated if
-     * type entity is also a unit */
-    ecs_entity_t unit;
+/** Parse script file.
+ * This parses a script file and instantiates the entities in the world. This
+ * operation is equivalent to loading the file contents and passing it to
+ * ecs_script_run().
+ *
+ * @param world The world.
+ * @param filename The script file name.
+ * @return Zero if success, non-zero if failed.
+ */
+FLECS_API
+int ecs_script_run_file(
+    ecs_world_t *world,
+    const char *filename);
 
-    /** Numerical range that specifies which values member can assume. This
-     * range may be used by UI elements such as a progress bar or slider. The
-     * value of a member should not exceed this range. */
-    ecs_member_value_range_t range;
+/** Convert script AST to string.
+ * This operation converts the script abstract syntax tree to a string, which
+ * can be used to debug a script.
+ * 
+ * @param script The script.
+ * @param buf The buffer to write to.
+ * @return Zero if success, non-zero if failed.
+ */
+FLECS_API
+int ecs_script_ast_to_buf(
+    ecs_script_t *script,
+    ecs_strbuf_t *buf);
 
-    /** Numerical range outside of which the value represents an error. This
-     * range may be used by UI elements to style a value. */
-    ecs_member_value_range_t error_range;
+/** Convert script AST to string.
+ * This operation converts the script abstract syntax tree to a string, which
+ * can be used to debug a script.
+ * 
+ * @param script The script.
+ * @return The string if success, NULL if failed.
+ */
+FLECS_API
+char* ecs_script_ast_to_str(
+    ecs_script_t *script);
 
-    /** Numerical range outside of which the value represents an warning. This
-     * range may be used by UI elements to style a value. */
-    ecs_member_value_range_t warning_range;
 
-    /** Should not be set by ecs_struct_desc_t */
-    ecs_size_t size;
-    ecs_entity_t member;
-} ecs_member_t;
+/* Managed scripts (script associated with entity that outlives the function) */
 
-/** Component added to struct type entities */
-typedef struct EcsStruct {
-    /** Populated from child entities with Member component */
-    ecs_vec_t members; /* vector<ecs_member_t> */
-} EcsStruct;
-
-typedef struct ecs_enum_constant_t {
-    /** Must be set when used with ecs_enum_desc_t */
-    const char *name;
-
-    /** May be set when used with ecs_enum_desc_t */
-    int32_t value;
-
-    /** Should not be set by ecs_enum_desc_t */
-    ecs_entity_t constant;
-} ecs_enum_constant_t;
+/** Used with ecs_script_init() */
+typedef struct ecs_script_desc_t {
+    ecs_entity_t entity;   /* Set to customize entity handle associated with script */
+    const char *filename;  /* Set to load script from file */
+    const char *code;      /* Set to parse script from string */
+} ecs_script_desc_t;
 
-/** Component added to enum type entities */
-typedef struct EcsEnum {
-    /** Populated from child entities with Constant component */
-    ecs_map_t constants; /* map<i32_t, ecs_enum_constant_t> */
-} EcsEnum;
+/** Load managed script.
+ * A managed script tracks which entities it creates, and keeps those entities
+ * synchronized when the contents of the script are updated. When the script is
+ * updated, entities that are no longer in the new version will be deleted.
+ *
+ * This feature is experimental.
+ *
+ * @param world The world.
+ * @param desc Script descriptor.
+ */
+FLECS_API
+ecs_entity_t ecs_script_init(
+    ecs_world_t *world,
+    const ecs_script_desc_t *desc);
 
-typedef struct ecs_bitmask_constant_t {
-    /** Must be set when used with ecs_bitmask_desc_t */
-    const char *name;
+#define ecs_script(world, ...)\
+    ecs_script_init(world, &(ecs_script_desc_t) __VA_ARGS__)
 
-    /** May be set when used with ecs_bitmask_desc_t */
-    ecs_flags32_t value;
+/** Update script with new code.
+ *
+ * @param world The world.
+ * @param script The script entity.
+ * @param instance An assembly instance (optional).
+ * @param code The script code.
+ */
+FLECS_API
+int ecs_script_update(
+    ecs_world_t *world,
+    ecs_entity_t script,
+    ecs_entity_t instance,
+    const char *code);
 
-    /** Should not be set by ecs_bitmask_desc_t */
-    ecs_entity_t constant;
-} ecs_bitmask_constant_t;
+/** Clear all entities associated with script.
+ *
+ * @param world The world.
+ * @param script The script entity.
+ * @param instance The script instance.
+ */
+FLECS_API
+void ecs_script_clear(
+    ecs_world_t *world,
+    ecs_entity_t script,
+    ecs_entity_t instance);
 
-/** Component added to bitmask type entities */
-typedef struct EcsBitmask {
-    /* Populated from child entities with Constant component */
-    ecs_map_t constants; /* map<u32_t, ecs_bitmask_constant_t> */
-} EcsBitmask;
 
-/** Component added to array type entities */
-typedef struct EcsArray {
-    ecs_entity_t type; /**< Element type */
-    int32_t count;     /**< Number of elements */
-} EcsArray;
+/* Script variables */
 
-/** Component added to vector type entities */
-typedef struct EcsVector {
-    ecs_entity_t type; /**< Element type */
-} EcsVector;
+/** Create new variable scope.
+ * Create root variable scope. A variable scope contains one or more variables. 
+ * Scopes can be nested, which allows variables in different scopes to have the 
+ * same name. Variables from parent scopes will be shadowed by variables in 
+ * child scopes with the same name.
+ * 
+ * Use the `ecs_script_vars_push()` and `ecs_script_vars_pop()` functions to
+ * push and pop variable scopes.
+ * 
+ * When a variable contains allocated resources (e.g. a string), its resources
+ * will be freed when `ecs_script_vars_pop()` is called on the scope, the
+ * ecs_script_vars_t::type_info field is initialized for the variable, and 
+ * `ecs_type_info_t::hooks::dtor` is set.
+ * 
+ * @param world The world.
+ */
+FLECS_API
+ecs_script_vars_t* ecs_script_vars_init(
+    ecs_world_t *world);
 
+/** Free variable scope.
+ * Free root variable scope. The provided scope should not have a parent. This
+ * operation calls `ecs_script_vars_pop()` on the scope.
+ *
+ * @param vars The variable scope.
+ */
+FLECS_API
+void ecs_script_vars_fini(
+    ecs_script_vars_t *vars);
 
-/* Opaque type support */
+/** Push new variable scope.
+ * 
+ * Scopes created with ecs_script_vars_push() must be cleaned up with
+ * ecs_script_vars_pop().
+ * 
+ * If the stack and allocator arguments are left to NULL, their values will be
+ * copied from the parent.
+ *
+ * @param parent The parent scope (provide NULL for root scope).
+ * @return The new variable scope.
+ */
+FLECS_API
+ecs_script_vars_t* ecs_script_vars_push(
+    ecs_script_vars_t *parent);
 
-#if !defined(__cplusplus) || !defined(FLECS_CPP)
+/** Pop variable scope.
+ * This frees up the resources for a variable scope. The scope must be at the
+ * top of a vars stack. Calling ecs_script_vars_pop() on a scope that is not the
+ * last scope causes undefined behavior.
+ *
+ * @param vars The scope to free.
+ * @return The parent scope.
+ */
+FLECS_API
+ecs_script_vars_t* ecs_script_vars_pop(
+    ecs_script_vars_t *vars);
 
-/** Serializer interface */
-typedef struct ecs_serializer_t {
-    /* Serialize value */
-    int (*value)(
-        const struct ecs_serializer_t *ser, /**< Serializer */
-        ecs_entity_t type,                  /**< Type of the value to serialize */
-        const void *value);                 /**< Pointer to the value to serialize */
+/** Declare a variable.
+ * This operation declares a new variable in the current scope. If a variable
+ * with the specified name already exists, the operation will fail.
+ * 
+ * This operation does not allocate storage for the variable. This is done to
+ * allow for variables that point to existing storage, which prevents having
+ * to copy existing values to a variable scope.
+ * 
+ * @param vars The variable scope.
+ * @param name The variable name.
+ * @return The new variable, or NULL if the operation failed.
+ */
+FLECS_API
+ecs_script_var_t* ecs_script_vars_declare(
+    ecs_script_vars_t *vars,
+    const char *name);
 
-    /* Serialize member */
-    int (*member)(
-        const struct ecs_serializer_t *ser, /**< Serializer */
-        const char *member);                /**< Member name */
+/** Define a variable.
+ * This operation calls `ecs_script_vars_declare()` and allocates storage for
+ * the variable. If the type has a ctor, it will be called on the new storage.
+ * 
+ * The scope's stack allocator will be used to allocate the storage. After 
+ * `ecs_script_vars_pop()` is called on the scope, the variable storage will no
+ * longer be valid.
+ * 
+ * The operation will fail if the type argument is not a type.
+ * 
+ * @param vars The variable scope.
+ * @param name The variable name.
+ * @param type The variable type.
+ * @return The new variable, or NULL if the operation failed.
+ */
+FLECS_API
+ecs_script_var_t* ecs_script_vars_define_id(
+    ecs_script_vars_t *vars,
+    const char *name,
+    ecs_entity_t type);
 
-    const ecs_world_t *world;
-    void *ctx;
-} ecs_serializer_t;
+#define ecs_script_vars_define(vars, name, type)\
+    ecs_script_vars_define_id(vars, name, ecs_id(type))
 
-#elif defined(__cplusplus)
+/** Lookup a variable.
+ * This operation looks up a variable in the current scope. If the variable 
+ * can't be found in the current scope, the operation will recursively search
+ * the parent scopes.
+ * 
+ * @param vars The variable scope.
+ * @param name The variable name.
+ * @return The variable, or NULL if a one with the provided name does not exist.
+ */
+FLECS_API
+ecs_script_var_t* ecs_script_vars_lookup(
+    const ecs_script_vars_t *vars,
+    const char *name);
 
-} /* extern "C" { */
+/** Convert iterator to vars
+ * This operation converts an iterator to a variable array. This allows for
+ * using iterator results in expressions. The operation only converts a
+ * single result at a time, and does not progress the iterator.
+ *
+ * Iterator fields with data will be made available as variables with as name
+ * the field index (e.g. "$1"). The operation does not check if reflection data
+ * is registered for a field type. If no reflection data is registered for the
+ * type, using the field variable in expressions will fail.
+ *
+ * Field variables will only contain single elements, even if the iterator
+ * returns component arrays. The offset parameter can be used to specify which
+ * element in the component arrays to return. The offset parameter must be
+ * smaller than it->count.
+ *
+ * The operation will create a variable for query variables that contain a
+ * single entity.
+ *
+ * The operation will attempt to use existing variables. If a variable does not
+ * yet exist, the operation will create it. If an existing variable exists with
+ * a mismatching type, the operation will fail.
+ *
+ * Accessing variables after progressing the iterator or after the iterator is
+ * destroyed will result in undefined behavior.
+ *
+ * If vars contains a variable that is not present in the iterator, the variable
+ * will not be modified.
+ *
+ * @param it The iterator to convert to variables.
+ * @param vars The variables to write to.
+ * @param offset The offset to the current element.
+ */
+FLECS_API
+void ecs_script_vars_from_iter(
+    const ecs_iter_t *it,
+    ecs_script_vars_t *vars,
+    int offset);
 
-/** Serializer interface (same layout as C, but with convenience methods) */
-typedef struct ecs_serializer_t {
-    /* Serialize value */
-    int (*value_)(
-        const struct ecs_serializer_t *ser,
-        ecs_entity_t type,
-        const void *value);
 
-    /* Serialize member */
-    int (*member_)(
-        const struct ecs_serializer_t *ser,
-        const char *name);
+/* Standalone expression evaluation */
 
-    /* Serialize value */
-    int value(ecs_entity_t type, const void *value) const;
+/** Used with ecs_script_expr_run(). */
+typedef struct ecs_script_expr_run_desc_t {
+    const char *name;
+    const char *expr;
+    ecs_entity_t (*lookup_action)(
+        const ecs_world_t*,
+        const char *value,
+        void *ctx);
+    void *lookup_ctx;
+    ecs_script_vars_t *vars;
+} ecs_script_expr_run_desc_t;
 
-    /* Serialize value */
-    template <typename T>
-    int value(const T& value) const;
+/** Parse standalone expression into value.
+ * This operation parses a flecs expression into the provided pointer. The
+ * memory pointed to must be large enough to contain a value of the used type.
+ *
+ * If no type and pointer are provided for the value argument, the operation
+ * will discover the type from the expression and allocate storage for the
+ * value. The allocated value must be freed with ecs_value_free().
+ *
+ * @param world The world.
+ * @param ptr The pointer to the expression to parse.
+ * @param value The value containing type & pointer to write to.
+ * @param desc Configuration parameters for deserializer.
+ * @return Pointer to the character after the last one read, or NULL if failed.
+ */
+FLECS_API
+const char* ecs_script_expr_run(
+    ecs_world_t *world,
+    const char *ptr,
+    ecs_value_t *value,
+    const ecs_script_expr_run_desc_t *desc);
 
-    /* Serialize member */
-    int member(const char *name) const;
+/** Evaluate interpolated expressions in string.
+ * This operation evaluates expressions in a string, and replaces them with
+ * their evaluated result. Supported expression formats are:
+ *  - $variable_name
+ *  - {expression}
+ *
+ * The $, { and } characters can be escaped with a backslash (\).
+ *
+ * @param world The world.
+ * @param str The string to evaluate.
+ * @param vars The variables to use for evaluation.
+ */
+FLECS_API
+char* ecs_script_string_interpolate(
+    ecs_world_t *world,
+    const char *str,
+    const ecs_script_vars_t *vars);
 
-    const ecs_world_t *world;
-    void *ctx;
-} ecs_serializer_t;
 
-extern "C" {
-#endif
+/* Value serialization */
 
-/** Callback invoked serializing an opaque type. */
-typedef int (*ecs_meta_serialize_t)(
-    const ecs_serializer_t *ser,
-    const void *src);                  /**< Pointer to value to serialize */
+/** Serialize value into expression string.
+ * This operation serializes a value of the provided type to a string. The
+ * memory pointed to must be large enough to contain a value of the used type.
+ *
+ * @param world The world.
+ * @param type The type of the value to serialize.
+ * @param data The value to serialize.
+ * @return String with expression, or NULL if failed.
+ */
+FLECS_API
+char* ecs_ptr_to_expr(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *data);
 
-typedef struct EcsOpaque {
-    ecs_entity_t as_type;              /**< Type that describes the serialized output */
-    ecs_meta_serialize_t serialize;    /**< Serialize action */
+/** Serialize value into expression buffer.
+ * Same as ecs_ptr_to_expr(), but serializes to an ecs_strbuf_t instance.
+ *
+ * @param world The world.
+ * @param type The type of the value to serialize.
+ * @param data The value to serialize.
+ * @param buf The strbuf to append the string to.
+ * @return Zero if success, non-zero if failed.
+ */
+FLECS_API
+int ecs_ptr_to_expr_buf(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *data,
+    ecs_strbuf_t *buf);
 
-    /* Deserializer interface
-     * Only override the callbacks that are valid for the opaque type. If a
-     * deserializer attempts to assign a value type that is not supported by the
-     * interface, a conversion error is thrown.
-     */
+/** Similar as ecs_ptr_to_expr(), but serializes values to string.
+ * Whereas the output of ecs_ptr_to_expr() is a valid expression, the output of
+ * ecs_ptr_to_str() is a string representation of the value. In most cases the
+ * output of the two operations is the same, but there are some differences:
+ * - Strings are not quoted
+ *
+ * @param world The world.
+ * @param type The type of the value to serialize.
+ * @param data The value to serialize.
+ * @return String with result, or NULL if failed.
+ */
+FLECS_API
+char* ecs_ptr_to_str(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *data);
 
-    /** Assign bool value */
-    void (*assign_bool)(
-        void *dst,
-        bool value);
+/** Serialize value into string buffer.
+ * Same as ecs_ptr_to_str(), but serializes to an ecs_strbuf_t instance.
+ *
+ * @param world The world.
+ * @param type The type of the value to serialize.
+ * @param data The value to serialize.
+ * @param buf The strbuf to append the string to.
+ * @return Zero if success, non-zero if failed.
+ */
+FLECS_API
+int ecs_ptr_to_str_buf(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *data,
+    ecs_strbuf_t *buf);
 
-    /** Assign char value */
-    void (*assign_char)(
-        void *dst,
-        char value);
+/* Module import */
+FLECS_API
+void FlecsScriptImport(
+    ecs_world_t *world);
 
-    /** Assign int value */
-    void (*assign_int)(
-        void *dst,
-        int64_t value);
+#ifdef __cplusplus
+}
+#endif
 
-    /** Assign unsigned int value */
-    void (*assign_uint)(
-        void *dst,
-        uint64_t value);
+#endif
 
-    /** Assign float value */
-    void (*assign_float)(
-        void *dst,
-        double value);
+/** @} */
 
-    /** Assign string value */
-    void (*assign_string)(
-        void *dst,
-        const char *value);
+#endif
 
-    /** Assign entity value */
-    void (*assign_entity)(
-        void *dst,
-        ecs_world_t *world,
-        ecs_entity_t entity);
+#endif
 
-    /** Assign (component) id value */
-    void (*assign_id)(
-        void *dst,
-        ecs_world_t *world,
-        ecs_id_t id);
+#ifdef FLECS_DOC
+#ifdef FLECS_NO_DOC
+#error "FLECS_NO_DOC failed: DOC is required by other addons"
+#endif
+/**
+ * @file addons/doc.h
+ * @brief Doc module.
+ *
+ * The doc module allows for documenting entities (and thus components, systems)
+ * by adding brief and/or detailed descriptions as components. Documentation
+ * added with the doc module can be retrieved at runtime, and can be used by
+ * tooling such as UIs or documentation frameworks.
+ */
 
-    /** Assign null value */
-    void (*assign_null)(
-        void *dst);
+#ifdef FLECS_DOC
 
-    /** Clear collection elements */
-    void (*clear)(
-        void *dst);
+#ifndef FLECS_DOC_H
+#define FLECS_DOC_H
 
-    /** Ensure & get collection element */
-    void* (*ensure_element)(
-        void *dst,
-        size_t elem);
+#ifndef FLECS_MODULE
+#define FLECS_MODULE
+#endif
 
-    /** Ensure & get element */
-    void* (*ensure_member)(
-        void *dst,
-        const char *member);
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-    /** Return number of elements */
-    size_t (*count)(
-        const void *dst);
+/**
+ * @defgroup c_addons_doc Doc
+ * @ingroup c_addons
+ * Utilities for documenting entities, components and systems.
+ *
+ * @{
+ */
 
-    /** Resize to number of elements */
-    void (*resize)(
-        void *dst,
-        size_t count);
-} EcsOpaque;
+FLECS_API extern const ecs_entity_t ecs_id(EcsDocDescription);
+FLECS_API extern const ecs_entity_t EcsDocBrief;
+FLECS_API extern const ecs_entity_t EcsDocDetail;
+FLECS_API extern const ecs_entity_t EcsDocLink;
+FLECS_API extern const ecs_entity_t EcsDocColor;
 
+typedef struct EcsDocDescription {
+    char *value;
+} EcsDocDescription;
 
-/* Units */
+/** Add human-readable name to entity.
+ * Contrary to entity names, human readable names do not have to be unique and
+ * can contain special characters used in the query language like '*'.
+ *
+ * @param world The world.
+ * @param entity The entity to which to add the name.
+ * @param name The name to add.
+ *
+ * @see ecs_doc_get_name()
+ * @see flecs::doc::set_name()
+ * @see flecs::entity_builder::set_doc_name()
+ */
+FLECS_API
+void ecs_doc_set_name(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *name);
 
-/* Helper type to describe translation between two units. Note that this
- * is not intended as a generic approach to unit conversions (e.g. from celsius
- * to fahrenheit) but to translate between units that derive from the same base
- * (e.g. meters to kilometers).
+/** Add brief description to entity.
  *
- * Note that power is applied to the factor. When describing a translation of
- * 1000, either use {factor = 1000, power = 1} or {factor = 1, power = 3}. */
-typedef struct ecs_unit_translation_t {
-    int32_t factor; /**< Factor to apply (e.g. "1000", "1000000", "1024") */
-    int32_t power;  /**< Power to apply to factor (e.g. "1", "3", "-9") */
-} ecs_unit_translation_t;
+ * @param world The world.
+ * @param entity The entity to which to add the description.
+ * @param description The description to add.
+ *
+ * @see ecs_doc_get_brief()
+ * @see flecs::doc::set_brief()
+ * @see flecs::entity_builder::set_doc_brief()
+ */
+FLECS_API
+void ecs_doc_set_brief(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *description);
 
-typedef struct EcsUnit {
-    char *symbol;
-    ecs_entity_t prefix; /**< Order of magnitude prefix relative to derived */
-    ecs_entity_t base;   /**< Base unit (e.g. "meters") */
-    ecs_entity_t over;   /**< Over unit (e.g. "per second") */
-    ecs_unit_translation_t translation; /**< Translation for derived unit */
-} EcsUnit;
+/** Add detailed description to entity.
+ *
+ * @param world The world.
+ * @param entity The entity to which to add the description.
+ * @param description The description to add.
+ *
+ * @see ecs_doc_get_detail()
+ * @see flecs::doc::set_detail()
+ * @see flecs::entity_builder::set_doc_detail()
+ */
+FLECS_API
+void ecs_doc_set_detail(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *description);
 
-typedef struct EcsUnitPrefix {
-    char *symbol;        /**< Symbol of prefix (e.g. "K", "M", "Ki") */
-    ecs_unit_translation_t translation; /**< Translation of prefix */
-} EcsUnitPrefix;
+/** Add link to external documentation to entity.
+ *
+ * @param world The world.
+ * @param entity The entity to which to add the link.
+ * @param link The link to add.
+ *
+ * @see ecs_doc_get_link()
+ * @see flecs::doc::set_link()
+ * @see flecs::entity_builder::set_doc_link()
+ */
+FLECS_API
+void ecs_doc_set_link(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *link);
 
+/** Add color to entity.
+ * UIs can use color as hint to improve visualizing entities.
+ *
+ * @param world The world.
+ * @param entity The entity to which to add the link.
+ * @param color The color to add.
+ *
+ * @see ecs_doc_get_color()
+ * @see flecs::doc::set_color()
+ * @see flecs::entity_builder::set_doc_color()
+ */
+FLECS_API
+void ecs_doc_set_color(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const char *color);
 
-/* Serializer utilities */
-
-typedef enum ecs_meta_type_op_kind_t {
-    EcsOpArray,
-    EcsOpVector,
-    EcsOpOpaque,
-    EcsOpPush,
-    EcsOpPop,
-
-    EcsOpScope, /**< Marks last constant that can open/close a scope */
-
-    EcsOpEnum,
-    EcsOpBitmask,
-
-    EcsOpPrimitive, /**< Marks first constant that's a primitive */
-
-    EcsOpBool,
-    EcsOpChar,
-    EcsOpByte,
-    EcsOpU8,
-    EcsOpU16,
-    EcsOpU32,
-    EcsOpU64,
-    EcsOpI8,
-    EcsOpI16,
-    EcsOpI32,
-    EcsOpI64,
-    EcsOpF32,
-    EcsOpF64,
-    EcsOpUPtr,
-    EcsOpIPtr,
-    EcsOpString,
-    EcsOpEntity,
-    EcsOpId,
-    EcsMetaTypeOpKindLast = EcsOpId
-} ecs_meta_type_op_kind_t;
-
-typedef struct ecs_meta_type_op_t {
-    ecs_meta_type_op_kind_t kind;
-    ecs_size_t offset;      /**< Offset of current field */
-    int32_t count;
-    const char *name;       /**< Name of value (only used for struct members) */
-    int32_t op_count;       /**< Number of operations until next field or end */
-    ecs_size_t size;        /**< Size of type of operation */
-    ecs_entity_t type;      /**< Type entity */
-    int32_t member_index;   /**< Index of member in struct */
-    ecs_hashmap_t *members; /**< string -> member index (structs only) */
-} ecs_meta_type_op_t;
-
-typedef struct EcsMetaTypeSerialized {
-    ecs_vec_t ops;      /**< vector<ecs_meta_type_op_t> */
-} EcsMetaTypeSerialized;
-
-
-/* Deserializer utilities */
-
-#define ECS_META_MAX_SCOPE_DEPTH (32) /* >32 levels of nesting is not sane */
-
-typedef struct ecs_meta_scope_t {
-    ecs_entity_t type;        /**< The type being iterated */
-    ecs_meta_type_op_t *ops;  /**< The type operations (see ecs_meta_type_op_t) */
-    int32_t op_count;         /**< Number of operations in ops array to process */
-    int32_t op_cur;           /**< Current operation */
-    int32_t elem_cur;         /**< Current element (for collections) */
-    int32_t prev_depth;       /**< Depth to restore, in case dotmember was used */
-    void *ptr;                /**< Pointer to the value being iterated */
-
-    const EcsComponent *comp; /**< Pointer to component, in case size/alignment is needed */
-    const EcsOpaque *opaque;  /**< Opaque type interface */
-    ecs_vec_t *vector;        /**< Current vector, in case a vector is iterated */
-    ecs_hashmap_t *members;   /**< string -> member index */
-    bool is_collection;       /**< Is the scope iterating elements? */
-    bool is_inline_array;     /**< Is the scope iterating an inline array? */
-    bool is_empty_scope;      /**< Was scope populated (for collections) */
-} ecs_meta_scope_t;
-
-/** Type that enables iterating/populating a value using reflection data */
-typedef struct ecs_meta_cursor_t {
-    const ecs_world_t *world;
-    ecs_meta_scope_t scope[ECS_META_MAX_SCOPE_DEPTH];
-    int32_t depth;
-    bool valid;
-    bool is_primitive_scope;  /**< If in root scope, this allows for a push for primitive types */
-
-    /* Custom entity lookup action for overriding default ecs_lookup */
-    ecs_entity_t (*lookup_action)(const ecs_world_t*, const char*, void*);
-    void *lookup_ctx;
-} ecs_meta_cursor_t;
-
+/** Get human readable name from entity.
+ * If entity does not have an explicit human readable name, this operation will
+ * return the entity name.
+ *
+ * To test if an entity has a human readable name, use:
+ *
+ * @code
+ * ecs_has_pair(world, e, ecs_id(EcsDocDescription), EcsName);
+ * @endcode
+ *
+ * Or in C++:
+ *
+ * @code
+ * e.has<flecs::doc::Description>(flecs::Name);
+ * @endcode
+ *
+ * @param world The world.
+ * @param entity The entity from which to get the name.
+ * @return The name.
+ *
+ * @see ecs_doc_set_name()
+ * @see flecs::doc::get_name()
+ * @see flecs::entity_view::get_doc_name()
+ */
 FLECS_API
-ecs_meta_cursor_t ecs_meta_cursor(
+const char* ecs_doc_get_name(
     const ecs_world_t *world,
-    ecs_entity_t type,
-    void *ptr);
-
-/** Get pointer to current field */
-FLECS_API
-void* ecs_meta_get_ptr(
-    ecs_meta_cursor_t *cursor);
-
-/** Move cursor to next field */
-FLECS_API
-int ecs_meta_next(
-    ecs_meta_cursor_t *cursor);
-
-/** Move cursor to a element */
-FLECS_API
-int ecs_meta_elem(
-    ecs_meta_cursor_t *cursor,
-    int32_t elem);
-
-/** Move cursor to member */
-FLECS_API
-int ecs_meta_member(
-    ecs_meta_cursor_t *cursor,
-    const char *name);
-
-/** Move cursor to member, supports dot-separated nested members */
-FLECS_API
-int ecs_meta_dotmember(
-    ecs_meta_cursor_t *cursor,
-    const char *name);
-
-/** Push a scope (required/only valid for structs & collections) */
-FLECS_API
-int ecs_meta_push(
-    ecs_meta_cursor_t *cursor);
-
-/** Pop a struct or collection scope (must follow a push) */
-FLECS_API
-int ecs_meta_pop(
-    ecs_meta_cursor_t *cursor);
-
-/** Is the current scope a collection? */
-FLECS_API
-bool ecs_meta_is_collection(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get type of current element. */
-FLECS_API
-ecs_entity_t ecs_meta_get_type(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get unit of current element. */
-FLECS_API
-ecs_entity_t ecs_meta_get_unit(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get member name of current member */
-FLECS_API
-const char* ecs_meta_get_member(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get member entity of current member */
-FLECS_API
-ecs_entity_t ecs_meta_get_member_id(
-    const ecs_meta_cursor_t *cursor);
-
-/* The set functions assign the field with the specified value. If the value
- * does not have the same type as the field, it will be cased to the field type.
- * If no valid conversion is available, the operation will fail. */
-
-/** Set field with boolean value */
-FLECS_API
-int ecs_meta_set_bool(
-    ecs_meta_cursor_t *cursor,
-    bool value);
-
-/** Set field with char value */
-FLECS_API
-int ecs_meta_set_char(
-    ecs_meta_cursor_t *cursor,
-    char value);
-
-/** Set field with int value */
-FLECS_API
-int ecs_meta_set_int(
-    ecs_meta_cursor_t *cursor,
-    int64_t value);
-
-/** Set field with uint value */
-FLECS_API
-int ecs_meta_set_uint(
-    ecs_meta_cursor_t *cursor,
-    uint64_t value);
-
-/** Set field with float value */
-FLECS_API
-int ecs_meta_set_float(
-    ecs_meta_cursor_t *cursor,
-    double value);
-
-/** Set field with string value */
-FLECS_API
-int ecs_meta_set_string(
-    ecs_meta_cursor_t *cursor,
-    const char *value);
-
-/** Set field with string literal value (has enclosing "") */
-FLECS_API
-int ecs_meta_set_string_literal(
-    ecs_meta_cursor_t *cursor,
-    const char *value);
-
-/** Set field with entity value */
-FLECS_API
-int ecs_meta_set_entity(
-    ecs_meta_cursor_t *cursor,
-    ecs_entity_t value);
-
-/** Set field with (component) id value */
-FLECS_API
-int ecs_meta_set_id(
-    ecs_meta_cursor_t *cursor,
-    ecs_id_t value);
-
-/** Set field with null value */
-FLECS_API
-int ecs_meta_set_null(
-    ecs_meta_cursor_t *cursor);
-
-/** Set field with dynamic value */
-FLECS_API
-int ecs_meta_set_value(
-    ecs_meta_cursor_t *cursor,
-    const ecs_value_t *value);
-
-/* Functions for getting members. */
-
-/** Get field value as boolean. */
-FLECS_API
-bool ecs_meta_get_bool(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get field value as char. */
-FLECS_API
-char ecs_meta_get_char(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get field value as signed integer. */
-FLECS_API
-int64_t ecs_meta_get_int(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get field value as unsigned integer. */
-FLECS_API
-uint64_t ecs_meta_get_uint(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get field value as float. */
-FLECS_API
-double ecs_meta_get_float(
-    const ecs_meta_cursor_t *cursor);
+    ecs_entity_t entity);
 
-/** Get field value as string.
- * This operation does not perform conversions. If the field is not a string,
- * this operation will fail.
+/** Get brief description from entity.
+ *
+ * @param world The world.
+ * @param entity The entity from which to get the description.
+ * @return The description.
+ *
+ * @see ecs_doc_set_brief()
+ * @see flecs::doc::get_brief()
+ * @see flecs::entity_view::get_doc_brief()
  */
 FLECS_API
-const char* ecs_meta_get_string(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get field value as entity.
- * This operation does not perform conversions. */
-FLECS_API
-ecs_entity_t ecs_meta_get_entity(
-    const ecs_meta_cursor_t *cursor);
-
-/** Get field value as (component) id.
- * This operation can convert from an entity. */
-ecs_id_t ecs_meta_get_id(
-    const ecs_meta_cursor_t *cursor);
-
-/** Convert pointer of primitive kind to float. */
-FLECS_API
-double ecs_meta_ptr_to_float(
-    ecs_primitive_kind_t type_kind,
-    const void *ptr);
-
-/* API functions for creating meta types */
-
-/** Used with ecs_primitive_init(). */
-typedef struct ecs_primitive_desc_t {
-    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
-    ecs_primitive_kind_t kind;
-} ecs_primitive_desc_t;
+const char* ecs_doc_get_brief(
+    const ecs_world_t *world,
+    ecs_entity_t entity);
 
-/** Create a new primitive type */
+/** Get detailed description from entity.
+ *
+ * @param world The world.
+ * @param entity The entity from which to get the description.
+ * @return The description.
+ *
+ * @see ecs_doc_set_detail()
+ * @see flecs::doc::get_detail()
+ * @see flecs::entity_view::get_doc_detail()
+ */
 FLECS_API
-ecs_entity_t ecs_primitive_init(
-    ecs_world_t *world,
-    const ecs_primitive_desc_t *desc);
-
-/** Used with ecs_enum_init(). */
-typedef struct ecs_enum_desc_t {
-    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
-    ecs_enum_constant_t constants[ECS_MEMBER_DESC_CACHE_SIZE];
-} ecs_enum_desc_t;
+const char* ecs_doc_get_detail(
+    const ecs_world_t *world,
+    ecs_entity_t entity);
 
-/** Create a new enum type */
+/** Get link to external documentation from entity.
+ *
+ * @param world The world.
+ * @param entity The entity from which to get the link.
+ * @return The link.
+ *
+ * @see ecs_doc_set_link()
+ * @see flecs::doc::get_link()
+ * @see flecs::entity_view::get_doc_link()
+ */
 FLECS_API
-ecs_entity_t ecs_enum_init(
-    ecs_world_t *world,
-    const ecs_enum_desc_t *desc);
-
-
-/** Used with ecs_bitmask_init(). */
-typedef struct ecs_bitmask_desc_t {
-    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
-    ecs_bitmask_constant_t constants[ECS_MEMBER_DESC_CACHE_SIZE];
-} ecs_bitmask_desc_t;
+const char* ecs_doc_get_link(
+    const ecs_world_t *world,
+    ecs_entity_t entity);
 
-/** Create a new bitmask type */
+/** Get color from entity.
+ *
+ * @param world The world.
+ * @param entity The entity from which to get the color.
+ * @return The color.
+ *
+ * @see ecs_doc_set_color()
+ * @see flecs::doc::get_color()
+ * @see flecs::entity_view::get_doc_color()
+ */
 FLECS_API
-ecs_entity_t ecs_bitmask_init(
-    ecs_world_t *world,
-    const ecs_bitmask_desc_t *desc);
-
-
-/** Used with ecs_array_init(). */
-typedef struct ecs_array_desc_t {
-    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
-    ecs_entity_t type;
-    int32_t count;
-} ecs_array_desc_t;
+const char* ecs_doc_get_color(
+    const ecs_world_t *world,
+    ecs_entity_t entity);
 
-/** Create a new array type */
+/* Module import */
 FLECS_API
-ecs_entity_t ecs_array_init(
-    ecs_world_t *world,
-    const ecs_array_desc_t *desc);
-
-
-/** Used with ecs_vector_init(). */
-typedef struct ecs_vector_desc_t {
-    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
-    ecs_entity_t type;
-} ecs_vector_desc_t;
+void FlecsDocImport(
+    ecs_world_t *world);
 
-/** Create a new vector type */
-FLECS_API
-ecs_entity_t ecs_vector_init(
-    ecs_world_t *world,
-    const ecs_vector_desc_t *desc);
+/** @} */
 
+#ifdef __cplusplus
+}
+#endif
 
-/** Used with ecs_struct_init(). */
-typedef struct ecs_struct_desc_t {
-    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
-    ecs_member_t members[ECS_MEMBER_DESC_CACHE_SIZE];
-} ecs_struct_desc_t;
+#endif
 
-/** Create a new struct type */
-FLECS_API
-ecs_entity_t ecs_struct_init(
-    ecs_world_t *world,
-    const ecs_struct_desc_t *desc);
+#endif
 
-/** Used with ecs_opaque_init(). */
-typedef struct ecs_opaque_desc_t {
-    ecs_entity_t entity;
-    EcsOpaque type;
-} ecs_opaque_desc_t;
+#endif
 
-/** Create a new opaque type.
- * Opaque types are types of which the layout doesn't match what can be modelled
- * with the primitives of the meta framework, but which have a structure
- * that can be described with meta primitives. Typical examples are STL types
- * such as std::string or std::vector, types with a nontrivial layout, and types
- * that only expose getter/setter methods.
+#ifdef FLECS_META
+#ifdef FLECS_NO_META
+#error "FLECS_NO_META failed: META is required by other addons"
+#endif
+/**
+ * @file addons/meta.h
+ * @brief Meta addon.
  *
- * An opaque type is a combination of a serialization function, and a handle to
- * a meta type which describes the structure of the serialized output. For
- * example, an opaque type for std::string would have a serializer function that
- * accesses .c_str(), and with type ecs_string_t.
+ * The meta addon enables reflecting on component data. Types are stored as
+ * entities, with components that store the reflection data. A type has at least
+ * two components:
  *
- * The serializer callback accepts a serializer object and a pointer to the
- * value of the opaque type to be serialized. The serializer has two methods:
+ * - EcsComponent: core component, contains size & alignment
+ * - EcsType:  component that indicates what kind of type the entity is
  *
- * - value, which serializes a value (such as .c_str())
- * - member, which specifies a member to be serialized (in the case of a struct)
+ * Additionally the type may have an additional component that contains the
+ * reflection data for the type. For example, structs have these components:
+ *
+ * - EcsComponent
+ * - EcsType
+ * - EcsStruct
+ *
+ * Structs can be populated by adding child entities with the EcsMember
+ * component. Adding a child with a Member component to an entity will
+ * automatically add the EcsStruct component to the parent.
+ *
+ * Enums/bitmasks can be populated by adding child entities with the Constant
+ * tag. By default constants are automatically assigned values when they are
+ * added to the enum/bitmask. The parent entity must have the EcsEnum or
+ * EcsBitmask component before adding the constants.
+ *
+ * To create enum constants with a manual value, set (Constant, i32) to the
+ * desired value. To create bitmask constants with a manual value, set
+ * (Constant, u32) to the desired value. Constants with manual values should not
+ * conflict with other constants.
+ *
+ * The _init APIs are convenience wrappers around creating the entities and
+ * components for the types.
+ *
+ * When a type is created it automatically receives the EcsComponent and
+ * EcsType components. The former means that the resulting type can be
+ * used as a regular component:
+ *
+ * @code
+ * // Create Position type
+ * ecs_entity_t pos = ecs_struct_init(world, &(ecs_struct_desc_t){
+ *  .entity.name = "Position",
+ *  .members = {
+ *       {"x", ecs_id(ecs_f32_t)},
+ *       {"y", ecs_id(ecs_f32_t)}
+ *   }
+ * });
+ *
+ * // Create entity with Position component
+ * ecs_entity_t e = ecs_new_w_id(world, pos);
+ * @endcode
+ *
+ * Type entities do not have to be named.
  */
-FLECS_API
-ecs_entity_t ecs_opaque_init(
-    ecs_world_t *world,
-    const ecs_opaque_desc_t *desc);
 
-/** Used with ecs_unit_init(). */
-typedef struct ecs_unit_desc_t {
-    /** Existing entity to associate with unit (optional) */
-    ecs_entity_t entity;
+#ifdef FLECS_META
+
+/**
+ * @defgroup c_addons_meta Meta
+ * @ingroup c_addons
+ * Flecs reflection framework.
+ *
+ * @{
+ */
 
-    /** Unit symbol, e.g. "m", "%", "g". (optional) */
-    const char *symbol;
+#include <stddef.h>
 
-    /** Unit quantity, e.g. distance, percentage, weight. (optional) */
-    ecs_entity_t quantity;
+#ifndef FLECS_MODULE
+#define FLECS_MODULE
+#endif
 
-    /** Base unit, e.g. "meters" (optional) */
-    ecs_entity_t base;
+#ifndef FLECS_META_H
+#define FLECS_META_H
 
-    /** Over unit, e.g. "per second" (optional) */
-    ecs_entity_t over;
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-    /** Translation to apply to derived unit (optional) */
-    ecs_unit_translation_t translation;
+#define ECS_MEMBER_DESC_CACHE_SIZE (32)
 
-    /** Prefix indicating order of magnitude relative to the derived unit. If set
-     * together with "translation", the values must match. If translation is not
-     * set, setting prefix will auto-populate it.
-     * Additionally, setting the prefix will enforce that the symbol (if set)
-     * is consistent with the prefix symbol + symbol of the derived unit. If the
-     * symbol is not set, it will be auto populated. */
-    ecs_entity_t prefix;
-} ecs_unit_desc_t;
+/** Primitive type definitions.
+ * These typedefs allow the builtin primitives to be used as regular components:
+ *
+ * @code
+ * ecs_set(world, e, ecs_i32_t, {10});
+ * @endcode
+ *
+ * Or a more useful example (create an enum constant with a manual value):
+ *
+ * @code
+ * ecs_set_pair_second(world, e, EcsConstant, ecs_i32_t, {10});
+ * @endcode
+ */
+typedef bool ecs_bool_t;
+typedef char ecs_char_t;
+typedef unsigned char ecs_byte_t;
+typedef uint8_t ecs_u8_t;
+typedef uint16_t ecs_u16_t;
+typedef uint32_t ecs_u32_t;
+typedef uint64_t ecs_u64_t;
+typedef uintptr_t ecs_uptr_t;
+typedef int8_t ecs_i8_t;
+typedef int16_t ecs_i16_t;
+typedef int32_t ecs_i32_t;
+typedef int64_t ecs_i64_t;
+typedef intptr_t ecs_iptr_t;
+typedef float ecs_f32_t;
+typedef double ecs_f64_t;
+typedef char* ecs_string_t;
 
-/** Create a new unit */
-FLECS_API
-ecs_entity_t ecs_unit_init(
-    ecs_world_t *world,
-    const ecs_unit_desc_t *desc);
+/* Meta module component ids */
+FLECS_API extern const ecs_entity_t ecs_id(EcsType);
+FLECS_API extern const ecs_entity_t ecs_id(EcsTypeSerializer);
+FLECS_API extern const ecs_entity_t ecs_id(EcsPrimitive);
+FLECS_API extern const ecs_entity_t ecs_id(EcsEnum);
+FLECS_API extern const ecs_entity_t ecs_id(EcsBitmask);
+FLECS_API extern const ecs_entity_t ecs_id(EcsMember);
+FLECS_API extern const ecs_entity_t ecs_id(EcsMemberRanges);
+FLECS_API extern const ecs_entity_t ecs_id(EcsStruct);
+FLECS_API extern const ecs_entity_t ecs_id(EcsArray);
+FLECS_API extern const ecs_entity_t ecs_id(EcsVector);
+FLECS_API extern const ecs_entity_t ecs_id(EcsOpaque);
+FLECS_API extern const ecs_entity_t ecs_id(EcsUnit);
+FLECS_API extern const ecs_entity_t ecs_id(EcsUnitPrefix);
+FLECS_API extern const ecs_entity_t EcsConstant;
+FLECS_API extern const ecs_entity_t EcsQuantity;
 
-/** Used with ecs_unit_prefix_init(). */
-typedef struct ecs_unit_prefix_desc_t {
-    /** Existing entity to associate with unit prefix (optional) */
-    ecs_entity_t entity;
+/* Primitive type component ids */
+FLECS_API extern const ecs_entity_t ecs_id(ecs_bool_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_char_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_byte_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_u8_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_u16_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_u32_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_u64_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_uptr_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_i8_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_i16_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_i32_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_i64_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_iptr_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_f32_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_f64_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_string_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_entity_t);
+FLECS_API extern const ecs_entity_t ecs_id(ecs_id_t);
 
-    /** Unit symbol, e.g. "m", "%", "g". (optional) */
-    const char *symbol;
+/** Type kinds supported by meta addon */
+typedef enum ecs_type_kind_t {
+    EcsPrimitiveType,
+    EcsBitmaskType,
+    EcsEnumType,
+    EcsStructType,
+    EcsArrayType,
+    EcsVectorType,
+    EcsOpaqueType,
+    EcsTypeKindLast = EcsOpaqueType
+} ecs_type_kind_t;
 
-    /** Translation to apply to derived unit (optional) */
-    ecs_unit_translation_t translation;
-} ecs_unit_prefix_desc_t;
+/** Component that is automatically added to every type with the right kind. */
+typedef struct EcsType {
+    ecs_type_kind_t kind;
+    bool existing;         /**< Did the type exist or is it populated from reflection */
+    bool partial;          /**< Is the reflection data a partial type description */
+} EcsType;
 
-/** Create a new unit prefix */
-FLECS_API
-ecs_entity_t ecs_unit_prefix_init(
-    ecs_world_t *world,
-    const ecs_unit_prefix_desc_t *desc);
+/** Primitive type kinds supported by meta addon */
+typedef enum ecs_primitive_kind_t {
+    EcsBool = 1,
+    EcsChar,
+    EcsByte,
+    EcsU8,
+    EcsU16,
+    EcsU32,
+    EcsU64,
+    EcsI8,
+    EcsI16,
+    EcsI32,
+    EcsI64,
+    EcsF32,
+    EcsF64,
+    EcsUPtr,
+    EcsIPtr,
+    EcsString,
+    EcsEntity,
+    EcsId,
+    EcsPrimitiveKindLast = EcsId
+} ecs_primitive_kind_t;
 
-/** Create a new quantity */
-FLECS_API
-ecs_entity_t ecs_quantity_init(
-    ecs_world_t *world,
-    const ecs_entity_desc_t *desc);
+/** Component added to primitive types */
+typedef struct EcsPrimitive {
+    ecs_primitive_kind_t kind;
+} EcsPrimitive;
 
-/* Convenience macros */
+/** Component added to member entities */
+typedef struct EcsMember {
+    ecs_entity_t type;
+    int32_t count;
+    ecs_entity_t unit;
+    int32_t offset;
+} EcsMember;
 
-#define ecs_primitive(world, ...)\
-    ecs_primitive_init(world, &(ecs_primitive_desc_t) __VA_ARGS__ )
+/** Type expressing a range for a member value */
+typedef struct ecs_member_value_range_t {
+    double min;
+    double max;
+} ecs_member_value_range_t;
 
-#define ecs_enum(world, ...)\
-    ecs_enum_init(world, &(ecs_enum_desc_t) __VA_ARGS__ )
+/** Component added to member entities to express valid value ranges */
+typedef struct EcsMemberRanges {
+    ecs_member_value_range_t value;
+    ecs_member_value_range_t warning;
+    ecs_member_value_range_t error;
+} EcsMemberRanges;
 
-#define ecs_bitmask(world, ...)\
-    ecs_bitmask_init(world, &(ecs_bitmask_desc_t) __VA_ARGS__ )
+/** Element type of members vector in EcsStruct */
+typedef struct ecs_member_t {
+    /** Must be set when used with ecs_struct_desc_t */
+    const char *name;
+    ecs_entity_t type;
 
-#define ecs_array(world, ...)\
-    ecs_array_init(world, &(ecs_array_desc_t) __VA_ARGS__ )
+    /** May be set when used with ecs_struct_desc_t */
+    int32_t count;
+    int32_t offset;
 
-#define ecs_vector(world, ...)\
-    ecs_vector_init(world, &(ecs_vector_desc_t) __VA_ARGS__ )
+    /** May be set when used with ecs_struct_desc_t, will be auto-populated if
+     * type entity is also a unit */
+    ecs_entity_t unit;
 
-#define ecs_opaque(world, ...)\
-    ecs_opaque_init(world, &(ecs_opaque_desc_t) __VA_ARGS__ )
+    /** Numerical range that specifies which values member can assume. This
+     * range may be used by UI elements such as a progress bar or slider. The
+     * value of a member should not exceed this range. */
+    ecs_member_value_range_t range;
 
-#define ecs_struct(world, ...)\
-    ecs_struct_init(world, &(ecs_struct_desc_t) __VA_ARGS__ )
+    /** Numerical range outside of which the value represents an error. This
+     * range may be used by UI elements to style a value. */
+    ecs_member_value_range_t error_range;
 
-#define ecs_unit(world, ...)\
-    ecs_unit_init(world, &(ecs_unit_desc_t) __VA_ARGS__ )
+    /** Numerical range outside of which the value represents an warning. This
+     * range may be used by UI elements to style a value. */
+    ecs_member_value_range_t warning_range;
 
-#define ecs_unit_prefix(world, ...)\
-    ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) __VA_ARGS__ )
+    /** Should not be set by ecs_struct_desc_t */
+    ecs_size_t size;
+    ecs_entity_t member;
+} ecs_member_t;
 
-#define ecs_quantity(world, ...)\
-    ecs_quantity_init(world, &(ecs_entity_desc_t) __VA_ARGS__ )
+/** Component added to struct type entities */
+typedef struct EcsStruct {
+    /** Populated from child entities with Member component */
+    ecs_vec_t members; /* vector<ecs_member_t> */
+} EcsStruct;
 
-/* Module import */
-FLECS_API
-void FlecsMetaImport(
-    ecs_world_t *world);
+typedef struct ecs_enum_constant_t {
+    /** Must be set when used with ecs_enum_desc_t */
+    const char *name;
 
-#ifdef __cplusplus
-}
-#endif
+    /** May be set when used with ecs_enum_desc_t */
+    int32_t value;
 
-#endif
+    /** Should not be set by ecs_enum_desc_t */
+    ecs_entity_t constant;
+} ecs_enum_constant_t;
 
-/** @} */
+/** Component added to enum type entities */
+typedef struct EcsEnum {
+    /** Populated from child entities with Constant component */
+    ecs_map_t constants; /* map<i32_t, ecs_enum_constant_t> */
+} EcsEnum;
 
-#endif
+typedef struct ecs_bitmask_constant_t {
+    /** Must be set when used with ecs_bitmask_desc_t */
+    const char *name;
 
-#endif
+    /** May be set when used with ecs_bitmask_desc_t */
+    ecs_flags32_t value;
 
-#ifdef FLECS_EXPR
-#ifdef FLECS_NO_EXPR
-#error "FLECS_NO_EXPR failed: EXPR is required by other addons"
-#endif
-/**
- * @file addons/expr.h
- * @brief Flecs expression parser addon.
- *
- * Parse expression strings into component values. The notation is similar to
- * JSON but with a smaller footprint, native support for (large) integer types,
- * character types, enumerations, bitmasks and entity identifiers.
- *
- * Examples:
- *
- * Member names:
- *
- *     {x: 10, y: 20}
- *
- * No member names (uses member ordering):
- *
- *     {10, 20}
- *
- * Enum values:
- *
- *     {color: Red}
- *
- * Bitmask values:
- *
- *     {toppings: Lettuce|Tomato}
- *
- * Collections:
- *
- *     {points: [10, 20, 30]}
- *
- * Nested objects:
- *
- *     {start: {x: 10, y: 20}, stop: {x: 30, y: 40}}
- *
- */
+    /** Should not be set by ecs_bitmask_desc_t */
+    ecs_entity_t constant;
+} ecs_bitmask_constant_t;
 
-#ifdef FLECS_EXPR
+/** Component added to bitmask type entities */
+typedef struct EcsBitmask {
+    /* Populated from child entities with Constant component */
+    ecs_map_t constants; /* map<u32_t, ecs_bitmask_constant_t> */
+} EcsBitmask;
 
-#ifndef FLECS_META
-#define FLECS_META
-#endif
+/** Component added to array type entities */
+typedef struct EcsArray {
+    ecs_entity_t type; /**< Element type */
+    int32_t count;     /**< Number of elements */
+} EcsArray;
 
-#ifndef FLECS_PARSER
-#define FLECS_PARSER
-#endif
+/** Component added to vector type entities */
+typedef struct EcsVector {
+    ecs_entity_t type; /**< Element type */
+} EcsVector;
 
-#ifndef FLECS_EXPR_H
-#define FLECS_EXPR_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+/* Opaque type support */
 
-/**
- * @defgroup c_addons_expr Expr
- * @ingroup c_addons
- * Serialize/deserialize values to string.
- *
- * @{
- */
+#if !defined(__cplusplus) || !defined(FLECS_CPP)
 
-/** Write an escaped character.
- * Write a character to an output string, insert escape character if necessary.
- *
- * @param out The string to write the character to.
- * @param in The input character.
- * @param delimiter The delimiter used (for example '"')
- * @return Pointer to the character after the last one written.
- */
-FLECS_API
-char* ecs_chresc(
-    char *out,
-    char in,
-    char delimiter);
+/** Serializer interface */
+typedef struct ecs_serializer_t {
+    /* Serialize value */
+    int (*value)(
+        const struct ecs_serializer_t *ser, /**< Serializer */
+        ecs_entity_t type,                  /**< Type of the value to serialize */
+        const void *value);                 /**< Pointer to the value to serialize */
 
-/** Parse an escaped character.
- * Parse a character with a potential escape sequence.
- *
- * @param in Pointer to character in input string.
- * @param out Output string.
- * @return Pointer to the character after the last one read.
- */
-const char* ecs_chrparse(
-    const char *in,
-    char *out);
+    /* Serialize member */
+    int (*member)(
+        const struct ecs_serializer_t *ser, /**< Serializer */
+        const char *member);                /**< Member name */
 
-/** Write an escaped string.
- * Write an input string to an output string, escape characters where necessary.
- * To determine the size of the output string, call the operation with a NULL
- * argument for 'out', and use the returned size to allocate a string that is
- * large enough.
- *
- * @param out Pointer to output string (must be).
- * @param size Maximum number of characters written to output.
- * @param delimiter The delimiter used (for example '"').
- * @param in The input string.
- * @return The number of characters that (would) have been written.
- */
-FLECS_API
-ecs_size_t ecs_stresc(
-    char *out,
-    ecs_size_t size,
-    char delimiter,
-    const char *in);
+    const ecs_world_t *world;
+    void *ctx;
+} ecs_serializer_t;
 
-/** Return escaped string.
- * Return escaped version of input string. Same as ecs_stresc(), but returns an
- * allocated string of the right size.
- *
- * @param delimiter The delimiter used (for example '"').
- * @param in The input string.
- * @return Escaped string.
- */
-FLECS_API
-char* ecs_astresc(
-    char delimiter,
-    const char *in);
+#elif defined(__cplusplus)
 
-/** Storage for parser variables. Variables make it possible to parameterize
- * expression strings, and are referenced with the $ operator (e.g. $var). */
-typedef struct ecs_expr_var_t {
-    char *name;
-    ecs_value_t value;
-    bool owned; /* Set to false if ecs_vars_t should not take ownership of var */
-} ecs_expr_var_t;
+} /* extern "C" { */
 
-typedef struct ecs_expr_var_scope_t {
-    ecs_hashmap_t var_index;
-    ecs_vec_t vars;
-    struct ecs_expr_var_scope_t *parent;
-} ecs_expr_var_scope_t;
+/** Serializer interface (same layout as C, but with convenience methods) */
+typedef struct ecs_serializer_t {
+    /* Serialize value */
+    int (*value_)(
+        const struct ecs_serializer_t *ser,
+        ecs_entity_t type,
+        const void *value);
 
-typedef struct ecs_vars_t {
-    ecs_world_t *world;
-    ecs_expr_var_scope_t root;
-    ecs_expr_var_scope_t *cur;
-} ecs_vars_t;
+    /* Serialize member */
+    int (*member_)(
+        const struct ecs_serializer_t *ser,
+        const char *name);
 
-/** Init variable storage */
-FLECS_API
-void ecs_vars_init(
-    ecs_world_t *world,
-    ecs_vars_t *vars);
+    /* Serialize value */
+    int value(ecs_entity_t type, const void *value) const;
 
-/** Cleanup variable storage */
-FLECS_API
-void ecs_vars_fini(
-    ecs_vars_t *vars);
+    /* Serialize value */
+    template <typename T>
+    int value(const T& value) const;
 
-/** Push variable scope */
-FLECS_API
-void ecs_vars_push(
-    ecs_vars_t *vars);
+    /* Serialize member */
+    int member(const char *name) const;
 
-/** Pop variable scope */
-FLECS_API
-int ecs_vars_pop(
-    ecs_vars_t *vars);
+    const ecs_world_t *world;
+    void *ctx;
+} ecs_serializer_t;
 
-/** Declare variable in current scope */
-FLECS_API
-ecs_expr_var_t* ecs_vars_declare(
-    ecs_vars_t *vars,
-    const char *name,
-    ecs_entity_t type);
+extern "C" {
+#endif
 
-/** Declare variable in current scope from value.
- * This operation takes ownership of the value. The value pointer must be
- * allocated with ecs_value_new().
- */
-FLECS_API
-ecs_expr_var_t* ecs_vars_declare_w_value(
-    ecs_vars_t *vars,
-    const char *name,
-    ecs_value_t *value);
+/** Callback invoked serializing an opaque type. */
+typedef int (*ecs_meta_serialize_t)(
+    const ecs_serializer_t *ser,
+    const void *src);                  /**< Pointer to value to serialize */
 
-/** Lookup variable in scope and parent scopes */
-FLECS_API
-ecs_expr_var_t* ecs_vars_lookup(
-    const ecs_vars_t *vars,
-    const char *name);
+typedef struct EcsOpaque {
+    ecs_entity_t as_type;              /**< Type that describes the serialized output */
+    ecs_meta_serialize_t serialize;    /**< Serialize action */
 
-/** Used with ecs_parse_expr(). */
-typedef struct ecs_parse_expr_desc_t {
-    const char *name;
-    const char *expr;
-    ecs_entity_t (*lookup_action)(
-        const ecs_world_t*,
-        const char *value,
-        void *ctx);
-    void *lookup_ctx;
-    ecs_vars_t *vars;
-} ecs_parse_expr_desc_t;
+    /* Deserializer interface
+     * Only override the callbacks that are valid for the opaque type. If a
+     * deserializer attempts to assign a value type that is not supported by the
+     * interface, a conversion error is thrown.
+     */
 
-/** Parse expression into value.
- * This operation parses a flecs expression into the provided pointer. The
- * memory pointed to must be large enough to contain a value of the used type.
- *
- * If no type and pointer are provided for the value argument, the operation
- * will discover the type from the expression and allocate storage for the
- * value. The allocated value must be freed with ecs_value_free().
- *
- * @param world The world.
- * @param ptr The pointer to the expression to parse.
- * @param value The value containing type & pointer to write to.
- * @param desc Configuration parameters for deserializer.
- * @return Pointer to the character after the last one read, or NULL if failed.
- */
-FLECS_API
-const char* ecs_parse_expr(
-    ecs_world_t *world,
-    const char *ptr,
-    ecs_value_t *value,
-    const ecs_parse_expr_desc_t *desc);
+    /** Assign bool value */
+    void (*assign_bool)(
+        void *dst,
+        bool value);
 
-/** Serialize value into expression string.
- * This operation serializes a value of the provided type to a string. The
- * memory pointed to must be large enough to contain a value of the used type.
- *
- * @param world The world.
- * @param type The type of the value to serialize.
- * @param data The value to serialize.
- * @return String with expression, or NULL if failed.
- */
-FLECS_API
-char* ecs_ptr_to_expr(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *data);
+    /** Assign char value */
+    void (*assign_char)(
+        void *dst,
+        char value);
 
-/** Serialize value into expression buffer.
- * Same as ecs_ptr_to_expr(), but serializes to an ecs_strbuf_t instance.
- *
- * @param world The world.
- * @param type The type of the value to serialize.
- * @param data The value to serialize.
- * @param buf The strbuf to append the string to.
- * @return Zero if success, non-zero if failed.
- */
-FLECS_API
-int ecs_ptr_to_expr_buf(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *data,
-    ecs_strbuf_t *buf);
+    /** Assign int value */
+    void (*assign_int)(
+        void *dst,
+        int64_t value);
 
-/** Similar as ecs_ptr_to_expr(), but serializes values to string.
- * Whereas the output of ecs_ptr_to_expr() is a valid expression, the output of
- * ecs_ptr_to_str() is a string representation of the value. In most cases the
- * output of the two operations is the same, but there are some differences:
- * - Strings are not quoted
- *
- * @param world The world.
- * @param type The type of the value to serialize.
- * @param data The value to serialize.
- * @return String with result, or NULL if failed.
- */
-FLECS_API
-char* ecs_ptr_to_str(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *data);
+    /** Assign unsigned int value */
+    void (*assign_uint)(
+        void *dst,
+        uint64_t value);
 
-/** Serialize value into string buffer.
- * Same as ecs_ptr_to_str(), but serializes to an ecs_strbuf_t instance.
- *
- * @param world The world.
- * @param type The type of the value to serialize.
- * @param data The value to serialize.
- * @param buf The strbuf to append the string to.
- * @return Zero if success, non-zero if failed.
- */
-FLECS_API
-int ecs_ptr_to_str_buf(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *data,
-    ecs_strbuf_t *buf);
+    /** Assign float value */
+    void (*assign_float)(
+        void *dst,
+        double value);
 
-/** Serialize primitive value into string buffer.
- * Serializes a primitive value to an ecs_strbuf_t instance. This operation can
- * be reused by other serializers to avoid having to write boilerplate code that
- * serializes primitive values to a string.
- *
- * @param world The world.
- * @param kind The kind of primitive value.
- * @param data The value to serialize
- * @param buf The strbuf to append the string to.
- * @return Zero if success, non-zero if failed.
- */
-FLECS_API
-int ecs_primitive_to_expr_buf(
-    const ecs_world_t *world,
-    ecs_primitive_kind_t kind,
-    const void *data,
-    ecs_strbuf_t *buf);
+    /** Assign string value */
+    void (*assign_string)(
+        void *dst,
+        const char *value);
 
-/** Parse expression token.
- * Expression tokens can contain more characters (such as '|') than tokens
- * parsed by the query (term) parser.
- *
- * @param name The name of the expression (used for debug logs).
- * @param expr The full expression (used for debug logs).
- * @param ptr The pointer to the expression to parse.
- * @param token The buffer to write to (must have size ECS_MAX_TOKEN_SIZE)
- * @return Pointer to the character after the last one read, or NULL if failed.
- */
-FLECS_API
-const char *ecs_parse_expr_token(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token);
+    /** Assign entity value */
+    void (*assign_entity)(
+        void *dst,
+        ecs_world_t *world,
+        ecs_entity_t entity);
 
-/** Evaluate interpolated expressions in string.
- * This operation evaluates expressions in a string, and replaces them with
- * their evaluated result. Supported expression formats are:
- *  - $variable_name
- *  - {expression}
- *
- * The $, { and } characters can be escaped with a backslash (\).
- *
- * @param world The world.
- * @param str The string to evaluate.
- * @param vars The variables to use for evaluation.
- */
-FLECS_API
-char* ecs_interpolate_string(
-    ecs_world_t *world,
-    const char *str,
-    const ecs_vars_t *vars);
+    /** Assign (component) id value */
+    void (*assign_id)(
+        void *dst,
+        ecs_world_t *world,
+        ecs_id_t id);
 
-/** Convert iterator to vars
- * This operation converts an iterator to a variable array. This allows for
- * using iterator results in expressions. The operation only converts a
- * single result at a time, and does not progress the iterator.
- *
- * Iterator fields with data will be made available as variables with as name
- * the field index (e.g. "$1"). The operation does not check if reflection data
- * is registered for a field type. If no reflection data is registered for the
- * type, using the field variable in expressions will fail.
- *
- * Field variables will only contain single elements, even if the iterator
- * returns component arrays. The offset parameter can be used to specify which
- * element in the component arrays to return. The offset parameter must be
- * smaller than it->count.
- *
- * The operation will create a variable for query variables that contain a
- * single entity.
- *
- * The operation will attempt to use existing variables. If a variable does not
- * yet exist, the operation will create it. If an existing variable exists with
- * a mismatching type, the operation will fail.
- *
- * Accessing variables after progressing the iterator or after the iterator is
- * destroyed will result in undefined behavior.
- *
- * If vars contains a variable that is not present in the iterator, the variable
- * will not be modified.
- *
- * @param it The iterator to convert to variables.
- * @param vars The variables to write to.
- * @param offset The offset to the current element.
- */
-FLECS_API
-void ecs_iter_to_vars(
-    const ecs_iter_t *it,
-    ecs_vars_t *vars,
-    int offset);
+    /** Assign null value */
+    void (*assign_null)(
+        void *dst);
 
-/** @} */
+    /** Clear collection elements */
+    void (*clear)(
+        void *dst);
 
-#ifdef __cplusplus
-}
-#endif
+    /** Ensure & get collection element */
+    void* (*ensure_element)(
+        void *dst,
+        size_t elem);
 
-#endif
+    /** Ensure & get element */
+    void* (*ensure_member)(
+        void *dst,
+        const char *member);
 
-#endif
+    /** Return number of elements */
+    size_t (*count)(
+        const void *dst);
 
-#endif
+    /** Resize to number of elements */
+    void (*resize)(
+        void *dst,
+        size_t count);
+} EcsOpaque;
 
-#ifdef FLECS_META_C
-#ifdef FLECS_NO_META_C
-#error "FLECS_NO_META_C failed: META_C is required by other addons"
-#endif
-/**
- * @file addons/meta_c.h
- * @brief Utility macros for populating reflection data in C.
- */
 
-#ifdef FLECS_META_C
+/* Units */
 
-/**
- * @defgroup c_addons_meta_c Meta Utilities
- * @ingroup c_addons
- * Macro utilities to automatically insert reflection data.
+/* Helper type to describe translation between two units. Note that this
+ * is not intended as a generic approach to unit conversions (e.g. from celsius
+ * to fahrenheit) but to translate between units that derive from the same base
+ * (e.g. meters to kilometers).
  *
- * @{
- */
+ * Note that power is applied to the factor. When describing a translation of
+ * 1000, either use {factor = 1000, power = 1} or {factor = 1, power = 3}. */
+typedef struct ecs_unit_translation_t {
+    int32_t factor; /**< Factor to apply (e.g. "1000", "1000000", "1024") */
+    int32_t power;  /**< Power to apply to factor (e.g. "1", "3", "-9") */
+} ecs_unit_translation_t;
 
-#ifndef FLECS_META
-#define FLECS_META
-#endif
+typedef struct EcsUnit {
+    char *symbol;
+    ecs_entity_t prefix; /**< Order of magnitude prefix relative to derived */
+    ecs_entity_t base;   /**< Base unit (e.g. "meters") */
+    ecs_entity_t over;   /**< Over unit (e.g. "per second") */
+    ecs_unit_translation_t translation; /**< Translation for derived unit */
+} EcsUnit;
 
-#ifndef FLECS_PARSER
-#define FLECS_PARSER
-#endif
+typedef struct EcsUnitPrefix {
+    char *symbol;        /**< Symbol of prefix (e.g. "K", "M", "Ki") */
+    ecs_unit_translation_t translation; /**< Translation of prefix */
+} EcsUnitPrefix;
 
-#ifndef FLECS_META_C_H
-#define FLECS_META_C_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+/* Serializer utilities */
 
-/* Macro that controls behavior of API. Usually set in module header. When the
- * macro is not defined, it defaults to IMPL. */
+typedef enum ecs_meta_type_op_kind_t {
+    EcsOpArray,
+    EcsOpVector,
+    EcsOpOpaque,
+    EcsOpPush,
+    EcsOpPop,
 
-/* Define variables used by reflection utilities. This should only be defined
- * by the module itself, not by the code importing the module */
-/* #define ECS_META_IMPL IMPL */
+    EcsOpScope, /**< Marks last constant that can open/close a scope */
 
-/* Don't define variables used by reflection utilities but still declare the
- * variable for the component id. This enables the reflection utilities to be
- * used for global component variables, even if no reflection is used. */
-/* #define ECS_META_IMPL DECLARE */
+    EcsOpEnum,
+    EcsOpBitmask,
 
-/* Don't define variables used by reflection utilities. This generates an extern
- * variable for the component identifier. */
-/* #define ECS_META_IMPL EXTERN */
+    EcsOpPrimitive, /**< Marks first constant that's a primitive */
 
-/** Declare component with descriptor */
-#define ECS_META_COMPONENT(world, name)\
-    ECS_COMPONENT_DEFINE(world, name);\
-    ecs_meta_from_desc(world, ecs_id(name),\
-        FLECS__##name##_kind, FLECS__##name##_desc)
+    EcsOpBool,
+    EcsOpChar,
+    EcsOpByte,
+    EcsOpU8,
+    EcsOpU16,
+    EcsOpU32,
+    EcsOpU64,
+    EcsOpI8,
+    EcsOpI16,
+    EcsOpI32,
+    EcsOpI64,
+    EcsOpF32,
+    EcsOpF64,
+    EcsOpUPtr,
+    EcsOpIPtr,
+    EcsOpString,
+    EcsOpEntity,
+    EcsOpId,
+    EcsMetaTypeOpKindLast = EcsOpId
+} ecs_meta_type_op_kind_t;
+
+typedef struct ecs_meta_type_op_t {
+    ecs_meta_type_op_kind_t kind;
+    ecs_size_t offset;      /**< Offset of current field */
+    int32_t count;
+    const char *name;       /**< Name of value (only used for struct members) */
+    int32_t op_count;       /**< Number of operations until next field or end */
+    ecs_size_t size;        /**< Size of type of operation */
+    ecs_entity_t type;      /**< Type entity */
+    int32_t member_index;   /**< Index of member in struct */
+    ecs_hashmap_t *members; /**< string -> member index (structs only) */
+} ecs_meta_type_op_t;
+
+typedef struct EcsTypeSerializer {
+    ecs_vec_t ops;      /**< vector<ecs_meta_type_op_t> */
+} EcsTypeSerializer;
+
+
+/* Deserializer utilities */
+
+#define ECS_META_MAX_SCOPE_DEPTH (32) /* >32 levels of nesting is not sane */
+
+typedef struct ecs_meta_scope_t {
+    ecs_entity_t type;        /**< The type being iterated */
+    ecs_meta_type_op_t *ops;  /**< The type operations (see ecs_meta_type_op_t) */
+    int32_t op_count;         /**< Number of operations in ops array to process */
+    int32_t op_cur;           /**< Current operation */
+    int32_t elem_cur;         /**< Current element (for collections) */
+    int32_t prev_depth;       /**< Depth to restore, in case dotmember was used */
+    void *ptr;                /**< Pointer to the value being iterated */
+
+    const EcsComponent *comp; /**< Pointer to component, in case size/alignment is needed */
+    const EcsOpaque *opaque;  /**< Opaque type interface */
+    ecs_vec_t *vector;        /**< Current vector, in case a vector is iterated */
+    ecs_hashmap_t *members;   /**< string -> member index */
+    bool is_collection;       /**< Is the scope iterating elements? */
+    bool is_inline_array;     /**< Is the scope iterating an inline array? */
+    bool is_empty_scope;      /**< Was scope populated (for collections) */
+} ecs_meta_scope_t;
 
-/** ECS_STRUCT(name, body) */
-#define ECS_STRUCT(name, ...)\
-    ECS_META_IMPL_CALL(ECS_STRUCT_, ECS_META_IMPL, name, #__VA_ARGS__);\
-    ECS_STRUCT_TYPE(name, __VA_ARGS__)
+/** Type that enables iterating/populating a value using reflection data */
+typedef struct ecs_meta_cursor_t {
+    const ecs_world_t *world;
+    ecs_meta_scope_t scope[ECS_META_MAX_SCOPE_DEPTH];
+    int32_t depth;
+    bool valid;
+    bool is_primitive_scope;  /**< If in root scope, this allows for a push for primitive types */
 
-/** ECS_ENUM(name, body) */
-#define ECS_ENUM(name, ...)\
-    ECS_META_IMPL_CALL(ECS_ENUM_, ECS_META_IMPL, name, #__VA_ARGS__);\
-    ECS_ENUM_TYPE(name, __VA_ARGS__)
+    /* Custom entity lookup action for overriding default ecs_lookup */
+    ecs_entity_t (*lookup_action)(const ecs_world_t*, const char*, void*);
+    void *lookup_ctx;
+} ecs_meta_cursor_t;
 
-/** ECS_BITMASK(name, body) */
-#define ECS_BITMASK(name, ...)\
-    ECS_META_IMPL_CALL(ECS_BITMASK_, ECS_META_IMPL, name, #__VA_ARGS__);\
-    ECS_ENUM_TYPE(name, __VA_ARGS__)
+FLECS_API
+ecs_meta_cursor_t ecs_meta_cursor(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    void *ptr);
 
-/** Macro used to mark part of type for which no reflection data is created */
-#define ECS_PRIVATE
+/** Get pointer to current field */
+FLECS_API
+void* ecs_meta_get_ptr(
+    ecs_meta_cursor_t *cursor);
 
-/** Populate meta information from type descriptor. */
+/** Move cursor to next field */
 FLECS_API
-int ecs_meta_from_desc(
-    ecs_world_t *world,
-    ecs_entity_t component,
-    ecs_type_kind_t kind,
-    const char *desc);
+int ecs_meta_next(
+    ecs_meta_cursor_t *cursor);
 
+/** Move cursor to a element */
+FLECS_API
+int ecs_meta_elem(
+    ecs_meta_cursor_t *cursor,
+    int32_t elem);
 
-/* Private API */
+/** Move cursor to member */
+FLECS_API
+int ecs_meta_member(
+    ecs_meta_cursor_t *cursor,
+    const char *name);
 
-/* Utilities to switch between IMPL, DECLARE and EXTERN variants */
-#define ECS_META_IMPL_CALL_INNER(base, impl, name, type_desc)\
-    base ## impl(name, type_desc)
+/** Move cursor to member, supports dot-separated nested members */
+FLECS_API
+int ecs_meta_dotmember(
+    ecs_meta_cursor_t *cursor,
+    const char *name);
 
-#define ECS_META_IMPL_CALL(base, impl, name, type_desc)\
-    ECS_META_IMPL_CALL_INNER(base, impl, name, type_desc)
+/** Push a scope (required/only valid for structs & collections) */
+FLECS_API
+int ecs_meta_push(
+    ecs_meta_cursor_t *cursor);
 
-/* ECS_STRUCT implementation */
-#define ECS_STRUCT_TYPE(name, ...)\
-    typedef struct __VA_ARGS__ name
+/** Pop a struct or collection scope (must follow a push) */
+FLECS_API
+int ecs_meta_pop(
+    ecs_meta_cursor_t *cursor);
 
-#define ECS_STRUCT_ECS_META_IMPL ECS_STRUCT_IMPL
+/** Is the current scope a collection? */
+FLECS_API
+bool ecs_meta_is_collection(
+    const ecs_meta_cursor_t *cursor);
 
-#define ECS_STRUCT_IMPL(name, type_desc)\
-    extern ECS_COMPONENT_DECLARE(name);\
-    static const char *FLECS__##name##_desc = type_desc;\
-    static ecs_type_kind_t FLECS__##name##_kind = EcsStructType;\
-    ECS_COMPONENT_DECLARE(name) = 0
+/** Get type of current element. */
+FLECS_API
+ecs_entity_t ecs_meta_get_type(
+    const ecs_meta_cursor_t *cursor);
 
-#define ECS_STRUCT_DECLARE(name, type_desc)\
-    extern ECS_COMPONENT_DECLARE(name);\
-    ECS_COMPONENT_DECLARE(name) = 0
+/** Get unit of current element. */
+FLECS_API
+ecs_entity_t ecs_meta_get_unit(
+    const ecs_meta_cursor_t *cursor);
 
-#define ECS_STRUCT_EXTERN(name, type_desc)\
-    extern ECS_COMPONENT_DECLARE(name)
+/** Get member name of current member */
+FLECS_API
+const char* ecs_meta_get_member(
+    const ecs_meta_cursor_t *cursor);
 
+/** Get member entity of current member */
+FLECS_API
+ecs_entity_t ecs_meta_get_member_id(
+    const ecs_meta_cursor_t *cursor);
 
-/* ECS_ENUM implementation */
-#define ECS_ENUM_TYPE(name, ...)\
-    typedef enum __VA_ARGS__ name
+/* The set functions assign the field with the specified value. If the value
+ * does not have the same type as the field, it will be cased to the field type.
+ * If no valid conversion is available, the operation will fail. */
 
-#define ECS_ENUM_ECS_META_IMPL ECS_ENUM_IMPL
+/** Set field with boolean value */
+FLECS_API
+int ecs_meta_set_bool(
+    ecs_meta_cursor_t *cursor,
+    bool value);
 
-#define ECS_ENUM_IMPL(name, type_desc)\
-    extern ECS_COMPONENT_DECLARE(name);\
-    static const char *FLECS__##name##_desc = type_desc;\
-    static ecs_type_kind_t FLECS__##name##_kind = EcsEnumType;\
-    ECS_COMPONENT_DECLARE(name) = 0
+/** Set field with char value */
+FLECS_API
+int ecs_meta_set_char(
+    ecs_meta_cursor_t *cursor,
+    char value);
 
-#define ECS_ENUM_DECLARE(name, type_desc)\
-    extern ECS_COMPONENT_DECLARE(name);\
-    ECS_COMPONENT_DECLARE(name) = 0
+/** Set field with int value */
+FLECS_API
+int ecs_meta_set_int(
+    ecs_meta_cursor_t *cursor,
+    int64_t value);
 
-#define ECS_ENUM_EXTERN(name, type_desc)\
-    extern ECS_COMPONENT_DECLARE(name)
+/** Set field with uint value */
+FLECS_API
+int ecs_meta_set_uint(
+    ecs_meta_cursor_t *cursor,
+    uint64_t value);
 
+/** Set field with float value */
+FLECS_API
+int ecs_meta_set_float(
+    ecs_meta_cursor_t *cursor,
+    double value);
 
-/* ECS_BITMASK implementation */
-#define ECS_BITMASK_TYPE(name, ...)\
-    typedef enum __VA_ARGS__ name
+/** Set field with string value */
+FLECS_API
+int ecs_meta_set_string(
+    ecs_meta_cursor_t *cursor,
+    const char *value);
 
-#define ECS_BITMASK_ECS_META_IMPL ECS_BITMASK_IMPL
+/** Set field with string literal value (has enclosing "") */
+FLECS_API
+int ecs_meta_set_string_literal(
+    ecs_meta_cursor_t *cursor,
+    const char *value);
 
-#define ECS_BITMASK_IMPL(name, type_desc)\
-    extern ECS_COMPONENT_DECLARE(name);\
-    static const char *FLECS__##name##_desc = type_desc;\
-    static ecs_type_kind_t FLECS__##name##_kind = EcsBitmaskType;\
-    ECS_COMPONENT_DECLARE(name) = 0
+/** Set field with entity value */
+FLECS_API
+int ecs_meta_set_entity(
+    ecs_meta_cursor_t *cursor,
+    ecs_entity_t value);
 
-#define ECS_BITMASK_DECLARE(name, type_desc)\
-    extern ECS_COMPONENT_DECLARE(name);\
-    ECS_COMPONENT_DECLARE(name) = 0
+/** Set field with (component) id value */
+FLECS_API
+int ecs_meta_set_id(
+    ecs_meta_cursor_t *cursor,
+    ecs_id_t value);
 
-#define ECS_BITMASK_EXTERN(name, type_desc)\
-    extern ECS_COMPONENT_DECLARE(name)
+/** Set field with null value */
+FLECS_API
+int ecs_meta_set_null(
+    ecs_meta_cursor_t *cursor);
 
-#ifdef __cplusplus
-}
-#endif
+/** Set field with dynamic value */
+FLECS_API
+int ecs_meta_set_value(
+    ecs_meta_cursor_t *cursor,
+    const ecs_value_t *value);
 
-#endif // FLECS_META_C_H
+/* Functions for getting members. */
 
-/** @} */
+/** Get field value as boolean. */
+FLECS_API
+bool ecs_meta_get_bool(
+    const ecs_meta_cursor_t *cursor);
 
-#endif // FLECS_META_C
+/** Get field value as char. */
+FLECS_API
+char ecs_meta_get_char(
+    const ecs_meta_cursor_t *cursor);
 
-#endif
+/** Get field value as signed integer. */
+FLECS_API
+int64_t ecs_meta_get_int(
+    const ecs_meta_cursor_t *cursor);
 
-#ifdef FLECS_PLECS
-#ifdef FLECS_NO_PLECS
-#error "FLECS_NO_PLECS failed: PLECS is required by other addons"
-#endif
-/**
- * @file addons/plecs.h
- * @brief Flecs script module.
- *
- * For script, see examples/plecs.
- */
+/** Get field value as unsigned integer. */
+FLECS_API
+uint64_t ecs_meta_get_uint(
+    const ecs_meta_cursor_t *cursor);
 
-#ifdef FLECS_PLECS
+/** Get field value as float. */
+FLECS_API
+double ecs_meta_get_float(
+    const ecs_meta_cursor_t *cursor);
 
-/**
- * @defgroup c_addons_plecs Flecs script
- * @ingroup c_addons
- * Data definition format for loading entity data.
- *
- * @{
+/** Get field value as string.
+ * This operation does not perform conversions. If the field is not a string,
+ * this operation will fail.
  */
+FLECS_API
+const char* ecs_meta_get_string(
+    const ecs_meta_cursor_t *cursor);
 
-#ifndef FLECS_MODULE
-#define FLECS_MODULE
-#endif
-
-#ifndef FLECS_PARSER
-#define FLECS_PARSER
-#endif
-
-#ifndef FLECS_EXPR
-#define FLECS_EXPR
-#endif
+/** Get field value as entity.
+ * This operation does not perform conversions. */
+FLECS_API
+ecs_entity_t ecs_meta_get_entity(
+    const ecs_meta_cursor_t *cursor);
 
-#ifndef FLECS_PLECS_H
-#define FLECS_PLECS_H
+/** Get field value as (component) id.
+ * This operation can convert from an entity. */
+ecs_id_t ecs_meta_get_id(
+    const ecs_meta_cursor_t *cursor);
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+/** Convert pointer of primitive kind to float. */
+FLECS_API
+double ecs_meta_ptr_to_float(
+    ecs_primitive_kind_t type_kind,
+    const void *ptr);
 
-FLECS_API
-extern ECS_COMPONENT_DECLARE(EcsScript);
+/* API functions for creating meta types */
 
-/* Script component */
-typedef struct EcsScript {
-    ecs_vec_t using_;
-    char *script;
-    ecs_vec_t prop_defaults;
-    ecs_world_t *world;
-} EcsScript;
+/** Used with ecs_primitive_init(). */
+typedef struct ecs_primitive_desc_t {
+    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
+    ecs_primitive_kind_t kind;
+} ecs_primitive_desc_t;
 
-/** Parse plecs string.
- * This parses a plecs string and instantiates the entities in the world.
- *
- * @param world The world.
- * @param name The script name (typically the file).
- * @param str The plecs string.
- * @return Zero if success, non-zero otherwise.
- */
+/** Create a new primitive type */
 FLECS_API
-int ecs_plecs_from_str(
+ecs_entity_t ecs_primitive_init(
     ecs_world_t *world,
-    const char *name,
-    const char *str);
+    const ecs_primitive_desc_t *desc);
 
-/** Parse plecs file.
- * This parses a plecs file and instantiates the entities in the world. This
- * operation is equivalent to loading the file contents and passing it to
- * ecs_plecs_from_str().
- *
- * @param world The world.
- * @param filename The plecs file name.
- * @return Zero if success, non-zero otherwise.
- */
+/** Used with ecs_enum_init(). */
+typedef struct ecs_enum_desc_t {
+    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
+    ecs_enum_constant_t constants[ECS_MEMBER_DESC_CACHE_SIZE];
+} ecs_enum_desc_t;
+
+/** Create a new enum type */
 FLECS_API
-int ecs_plecs_from_file(
+ecs_entity_t ecs_enum_init(
     ecs_world_t *world,
-    const char *filename);
+    const ecs_enum_desc_t *desc);
 
-/** Used with ecs_script_init() */
-typedef struct ecs_script_desc_t {
-    ecs_entity_t entity;      /* Set to customize entity handle associated with script */
-    const char *filename;     /* Set to load script from file */
-    const char *str;          /* Set to parse script from string */
-} ecs_script_desc_t;
 
-/** Load managed script.
- * A managed script tracks which entities it creates, and keeps those entities
- * synchronized when the contents of the script are updated. When the script is
- * updated, entities that are no longer in the new version will be deleted.
- *
- * This feature is experimental.
- *
- * @param world The world.
- * @param desc Script descriptor.
- */
+/** Used with ecs_bitmask_init(). */
+typedef struct ecs_bitmask_desc_t {
+    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
+    ecs_bitmask_constant_t constants[ECS_MEMBER_DESC_CACHE_SIZE];
+} ecs_bitmask_desc_t;
+
+/** Create a new bitmask type */
 FLECS_API
-ecs_entity_t ecs_script_init(
+ecs_entity_t ecs_bitmask_init(
     ecs_world_t *world,
-    const ecs_script_desc_t *desc);
+    const ecs_bitmask_desc_t *desc);
 
-#define ecs_script(world, ...)\
-    ecs_script_init(world, &(ecs_script_desc_t) __VA_ARGS__)
 
-/** Update script with new code.
- *
- * @param world The world.
- * @param script The script entity.
- * @param instance An assembly instance (optional).
- * @param str The script code.
- * @param vars Optional preset variables for script parameterization.
- */
-FLECS_API
-int ecs_script_update(
-    ecs_world_t *world,
-    ecs_entity_t script,
-    ecs_entity_t instance,
-    const char *str,
-    ecs_vars_t *vars);
+/** Used with ecs_array_init(). */
+typedef struct ecs_array_desc_t {
+    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
+    ecs_entity_t type;
+    int32_t count;
+} ecs_array_desc_t;
 
-/** Clear all entities associated with script.
- *
- * @param world The world.
- * @param script The script entity.
- * @param instance The script instance.
- */
+/** Create a new array type */
 FLECS_API
-void ecs_script_clear(
+ecs_entity_t ecs_array_init(
     ecs_world_t *world,
-    ecs_entity_t script,
-    ecs_entity_t instance);
+    const ecs_array_desc_t *desc);
 
-/* Module import */
-FLECS_API
-void FlecsScriptImport(
-    ecs_world_t *world);
 
-#ifdef __cplusplus
-}
-#endif
+/** Used with ecs_vector_init(). */
+typedef struct ecs_vector_desc_t {
+    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
+    ecs_entity_t type;
+} ecs_vector_desc_t;
 
-#endif
+/** Create a new vector type */
+FLECS_API
+ecs_entity_t ecs_vector_init(
+    ecs_world_t *world,
+    const ecs_vector_desc_t *desc);
 
-/** @} */
 
-#endif
+/** Used with ecs_struct_init(). */
+typedef struct ecs_struct_desc_t {
+    ecs_entity_t entity; /**< Existing entity to use for type (optional) */
+    ecs_member_t members[ECS_MEMBER_DESC_CACHE_SIZE];
+} ecs_struct_desc_t;
 
-#endif
+/** Create a new struct type */
+FLECS_API
+ecs_entity_t ecs_struct_init(
+    ecs_world_t *world,
+    const ecs_struct_desc_t *desc);
 
-#ifdef FLECS_RULES
-#ifdef FLECS_NO_RULES
-#error "FLECS_NO_RULES failed: RULES is required by other addons"
-#endif
-/**
- * @file addons/rules.h
- * @brief Rule query engine addon.
+/** Used with ecs_opaque_init(). */
+typedef struct ecs_opaque_desc_t {
+    ecs_entity_t entity;
+    EcsOpaque type;
+} ecs_opaque_desc_t;
+
+/** Create a new opaque type.
+ * Opaque types are types of which the layout doesn't match what can be modelled
+ * with the primitives of the meta framework, but which have a structure
+ * that can be described with meta primitives. Typical examples are STL types
+ * such as std::string or std::vector, types with a nontrivial layout, and types
+ * that only expose getter/setter methods.
+ *
+ * An opaque type is a combination of a serialization function, and a handle to
+ * a meta type which describes the structure of the serialized output. For
+ * example, an opaque type for std::string would have a serializer function that
+ * accesses .c_str(), and with type ecs_string_t.
  *
- * Rules are advanced queries that in addition to the capabilities of regular
- * queries and filters have the following features:
+ * The serializer callback accepts a serializer object and a pointer to the
+ * value of the opaque type to be serialized. The serializer has two methods:
  *
- * - query for all components of an entity (vs. all entities for a component)
- * - query for all relationship pairs of an entity
- * - support for query variables that are resolved at evaluation time
- * - automatic traversal of transitive relationships
+ * - value, which serializes a value (such as .c_str())
+ * - member, which specifies a member to be serialized (in the case of a struct)
  */
+FLECS_API
+ecs_entity_t ecs_opaque_init(
+    ecs_world_t *world,
+    const ecs_opaque_desc_t *desc);
 
-#ifdef FLECS_RULES
+/** Used with ecs_unit_init(). */
+typedef struct ecs_unit_desc_t {
+    /** Existing entity to associate with unit (optional) */
+    ecs_entity_t entity;
 
-/**
- * @defgroup c_addons_rules Rules
- * @ingroup c_addons
- * Rules are an advanced query engine for matching against entity graphs.
- *
- * @{
- */
+    /** Unit symbol, e.g. "m", "%", "g". (optional) */
+    const char *symbol;
 
-#ifndef FLECS_RULES_H
-#define FLECS_RULES_H
+    /** Unit quantity, e.g. distance, percentage, weight. (optional) */
+    ecs_entity_t quantity;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+    /** Base unit, e.g. "meters" (optional) */
+    ecs_entity_t base;
 
-/** Convenience macro for rule creation */
-#define ecs_rule(world, ...)\
-    ecs_rule_init(world, &(ecs_filter_desc_t) __VA_ARGS__ )
+    /** Over unit, e.g. "per second" (optional) */
+    ecs_entity_t over;
 
-/** Create a rule.
- * A rule accepts the same descriptor as a filter, but has the additional
- * ability to use query variables.
- *
- * Query variables can be used to constrain wildcards across multiple terms to
- * the same entity. Regular ECS queries do this in a limited form, as querying
- * for Position, Velocity only returns entities that have both components.
- *
- * Query variables expand this to constrain entities that are resolved while the
- * query is being matched. Consider a query for all entities and the mission
- * they are on:
- *   (Mission, *)
- *
- * If an entity is on multiple missions, the wildcard will match it multiple
- * times. Now say we want to only list combat missions. Naively we could try:
- *   (Mission, *), CombatMission(*)
- *
- * But this doesn't work, as term 1 returns entities with missions, and term 2
- * returns all combat missions for all entities. Query variables make it
- * possible to apply CombatMission to the found mission:
- *   (Mission, $M), CombatMission($M)
- *
- * By using the same variable ('M') we ensure that CombatMission is applied to
- * the mission found in the current result.
- *
- * Variables can be used in each part of the term (predicate, subject, object).
- * This is a valid query:
- *   Likes($X, $Y), Likes($Y, $X)
- *
- * This is also a valid query:
- *   _Component, Serializable(_Component)
- *
- * In the query expression syntax, variables are prefixed with a $. When using
- * the descriptor, specify the variable kind:
- *   desc.terms[0].second = { .name = "X", .var = EcsVarIsVariable }
- *
- * Different terms with the same variable name are automatically correlated by
- * the query engine.
- *
- * A rule needs to be explicitly deleted with ecs_rule_fini().
- *
- * @param world The world.
- * @param desc The descriptor (see ecs_filter_desc_t)
- * @return The rule.
- */
+    /** Translation to apply to derived unit (optional) */
+    ecs_unit_translation_t translation;
+
+    /** Prefix indicating order of magnitude relative to the derived unit. If set
+     * together with "translation", the values must match. If translation is not
+     * set, setting prefix will auto-populate it.
+     * Additionally, setting the prefix will enforce that the symbol (if set)
+     * is consistent with the prefix symbol + symbol of the derived unit. If the
+     * symbol is not set, it will be auto populated. */
+    ecs_entity_t prefix;
+} ecs_unit_desc_t;
+
+/** Create a new unit */
 FLECS_API
-ecs_rule_t* ecs_rule_init(
+ecs_entity_t ecs_unit_init(
     ecs_world_t *world,
-    const ecs_filter_desc_t *desc);
+    const ecs_unit_desc_t *desc);
 
-/** Delete a rule.
- *
- * @param rule The rule.
- */
-FLECS_API
-void ecs_rule_fini(
-    ecs_rule_t *rule);
+/** Used with ecs_unit_prefix_init(). */
+typedef struct ecs_unit_prefix_desc_t {
+    /** Existing entity to associate with unit prefix (optional) */
+    ecs_entity_t entity;
 
-/** Obtain filter from rule.
- * This operation returns the filter with which the rule was created.
- *
- * @param rule The rule.
- * @return The filter.
- */
-FLECS_API
-const ecs_filter_t* ecs_rule_get_filter(
-    const ecs_rule_t *rule);
+    /** Unit symbol, e.g. "m", "%", "g". (optional) */
+    const char *symbol;
 
-/** Return number of variables in rule.
- *
- * @param rule The rule.
- * @return The number of variables/
- */
-FLECS_API
-int32_t ecs_rule_var_count(
-    const ecs_rule_t *rule);
+    /** Translation to apply to derived unit (optional) */
+    ecs_unit_translation_t translation;
+} ecs_unit_prefix_desc_t;
 
-/** Find variable index.
- * This operation looks up the index of a variable in the rule. This index can
- * be used in operations like ecs_iter_set_var() and ecs_iter_get_var().
- *
- * @param rule The rule.
- * @param name The variable name.
- * @return The variable index.
- */
+/** Create a new unit prefix */
 FLECS_API
-int32_t ecs_rule_find_var(
-    const ecs_rule_t *rule,
-    const char *name);
+ecs_entity_t ecs_unit_prefix_init(
+    ecs_world_t *world,
+    const ecs_unit_prefix_desc_t *desc);
 
-/** Get variable name.
- * This operation returns the variable name for an index.
- *
- * @param rule The rule.
- * @param var_id The variable index.
- */
+/** Create a new quantity */
 FLECS_API
-const char* ecs_rule_var_name(
-    const ecs_rule_t *rule,
-    int32_t var_id);
+ecs_entity_t ecs_quantity_init(
+    ecs_world_t *world,
+    const ecs_entity_desc_t *desc);
 
-/** Test if variable is an entity.
- * Internally the rule engine has entity variables and table variables. When
- * iterating through rule variables (by using ecs_rule_variable_count()) only
- * the values for entity variables are accessible. This operation enables an
- * application to check if a variable is an entity variable.
- *
- * @param rule The rule.
- * @param var_id The variable id.
- */
-FLECS_API
-bool ecs_rule_var_is_entity(
-    const ecs_rule_t *rule,
-    int32_t var_id);
+/* Convenience macros */
+
+#define ecs_primitive(world, ...)\
+    ecs_primitive_init(world, &(ecs_primitive_desc_t) __VA_ARGS__ )
+
+#define ecs_enum(world, ...)\
+    ecs_enum_init(world, &(ecs_enum_desc_t) __VA_ARGS__ )
 
-/** Iterate a rule.
- * Note that rule iterators may allocate memory, and that unless the iterator
- * is iterated until completion, it may still hold resources. When stopping
- * iteration before ecs_rule_next() has returned false, use ecs_iter_fini() to
- * cleanup any remaining resources.
- *
- * @param world The world.
- * @param rule The rule.
- * @return An iterator.
- */
-FLECS_API
-ecs_iter_t ecs_rule_iter(
-    const ecs_world_t *world,
-    const ecs_rule_t *rule);
+#define ecs_bitmask(world, ...)\
+    ecs_bitmask_init(world, &(ecs_bitmask_desc_t) __VA_ARGS__ )
 
-/** Progress rule iterator.
- *
- * @param it The iterator.
- */
-FLECS_API
-bool ecs_rule_next(
-    ecs_iter_t *it);
+#define ecs_array(world, ...)\
+    ecs_array_init(world, &(ecs_array_desc_t) __VA_ARGS__ )
 
-/** Progress instanced iterator.
- * Should not be called unless you know what you're doing :-)
- *
- * @param it The iterator.
- */
-FLECS_API
-bool ecs_rule_next_instanced(
-    ecs_iter_t *it);
+#define ecs_vector(world, ...)\
+    ecs_vector_init(world, &(ecs_vector_desc_t) __VA_ARGS__ )
 
-/** Convert rule to a string.
- * This will convert the rule program to a string which can aid in debugging
- * the behavior of a rule.
- *
- * The returned string must be freed with ecs_os_free().
- *
- * @param rule The rule.
- * @return The string
- */
-FLECS_API
-char* ecs_rule_str(
-    const ecs_rule_t *rule);
+#define ecs_opaque(world, ...)\
+    ecs_opaque_init(world, &(ecs_opaque_desc_t) __VA_ARGS__ )
 
-/** Convert rule to string with profile.
- * To use this you must set the EcsIterProfile flag on an iterator before
- * starting iteration:
- *   it.flags |= EcsIterProfile
- *
- * @param rule The rule.
- * @return The string
- */
-FLECS_API
-char* ecs_rule_str_w_profile(
-    const ecs_rule_t *rule,
-    const ecs_iter_t *it);
+#define ecs_struct(world, ...)\
+    ecs_struct_init(world, &(ecs_struct_desc_t) __VA_ARGS__ )
 
-/** Populate variables from key-value string.
- * Convenience function to set rule variables from a key-value string separated
- * by comma's. The string must have the following format:
- *   var_a: value, var_b: value
- *
- * The key-value list may optionally be enclosed in parenthesis.
- *
- * @param rule The rule.
- * @param it The iterator for which to set the variables.
- * @param expr The key-value expression.
- */
-FLECS_API
-const char* ecs_rule_parse_vars(
-    ecs_rule_t *rule,
-    ecs_iter_t *it,
-    const char *expr);
+#define ecs_unit(world, ...)\
+    ecs_unit_init(world, &(ecs_unit_desc_t) __VA_ARGS__ )
 
-#ifdef __cplusplus
-}
-#endif
+#define ecs_unit_prefix(world, ...)\
+    ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) __VA_ARGS__ )
 
-#endif // FLECS_RULES_H
+#define ecs_quantity(world, ...)\
+    ecs_quantity_init(world, &(ecs_entity_desc_t) __VA_ARGS__ )
 
-/** @} */
 
-#endif // FLECS_RULES
+/* Module import */
+FLECS_API
+void FlecsMetaImport(
+    ecs_world_t *world);
 
+#ifdef __cplusplus
+}
 #endif
 
-#ifdef FLECS_SNAPSHOT
-#ifdef FLECS_NO_SNAPSHOT
-#error "FLECS_NO_SNAPSHOT failed: SNAPSHOT is required by other addons"
-#endif
 /**
- * @file addons/snapshot.h
- * @brief Snapshot addon.
- *
- * A snapshot records the state of a world in a way so that it can be restored
- * later. Snapshots work with POD components and non-POD components, provided
- * that the appropriate lifecycle actions are registered for non-POD components.
- *
- * A snapshot is tightly coupled to a world. It is not possible to restore a
- * snapshot from world A into world B.
+ * @file addons/meta_c.h
+ * @brief Utility macros for populating reflection data in C.
  */
 
-#ifdef FLECS_SNAPSHOT
+#ifdef FLECS_META
 
 /**
- * @defgroup c_addons_snapshot Snapshot
+ * @defgroup c_addons_meta_c Meta Utilities
  * @ingroup c_addons
- * @brief Save & restore world.
+ * Macro utilities to automatically insert reflection data.
  *
  * @{
  */
 
-#ifndef FLECS_SNAPSHOT_H
-#define FLECS_SNAPSHOT_H
+#ifndef FLECS_META_C_H
+#define FLECS_META_C_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/** A snapshot stores the state of a world in a particular point in time. */
-typedef struct ecs_snapshot_t ecs_snapshot_t;
+/* Macro that controls behavior of API. Usually set in module header. When the
+ * macro is not defined, it defaults to IMPL. */
 
-/** Create a snapshot.
- * This operation makes a copy of the current state of the world.
- *
- * @param world The world to snapshot.
- * @return The snapshot.
- */
-FLECS_API
-ecs_snapshot_t* ecs_snapshot_take(
-    ecs_world_t *world);
+/* Define variables used by reflection utilities. This should only be defined
+ * by the module itself, not by the code importing the module */
+/* #define ECS_META_IMPL IMPL */
 
-/** Create a filtered snapshot.
- * This operation is the same as ecs_snapshot_take(), but accepts an iterator so
- * an application can control what is stored by the snapshot.
- *
- * @param iter An iterator to the data to be stored by the snapshot.
- * @return The snapshot.
- */
-FLECS_API
-ecs_snapshot_t* ecs_snapshot_take_w_iter(
-    ecs_iter_t *iter);
+/* Don't define variables used by reflection utilities but still declare the
+ * variable for the component id. This enables the reflection utilities to be
+ * used for global component variables, even if no reflection is used. */
+/* #define ECS_META_IMPL DECLARE */
 
-/** Restore a snapshot.
- * This operation restores the world to the state it was in when the specified
- * snapshot was taken. A snapshot can only be used once for restoring, as its
- * data replaces the data that is currently in the world.
- * This operation also resets the last issued entity handle, so any calls to
- * ecs_new() may return entity ids that have been issued before restoring the
- * snapshot.
- *
- * The world in which the snapshot is restored must be the same as the world in
- * which the snapshot is taken.
- *
- * @param world The world to restore the snapshot to.
- * @param snapshot The snapshot to restore.
- */
+/* Don't define variables used by reflection utilities. This generates an extern
+ * variable for the component identifier. */
+/* #define ECS_META_IMPL EXTERN */
+
+/** Declare component with descriptor */
+#define ECS_META_COMPONENT(world, name)\
+    ECS_COMPONENT_DEFINE(world, name);\
+    ecs_meta_from_desc(world, ecs_id(name),\
+        FLECS__##name##_kind, FLECS__##name##_desc)
+
+/** ECS_STRUCT(name, body) */
+#define ECS_STRUCT(name, ...)\
+    ECS_META_IMPL_CALL(ECS_STRUCT_, ECS_META_IMPL, name, #__VA_ARGS__);\
+    ECS_STRUCT_TYPE(name, __VA_ARGS__)
+
+/** ECS_ENUM(name, body) */
+#define ECS_ENUM(name, ...)\
+    ECS_META_IMPL_CALL(ECS_ENUM_, ECS_META_IMPL, name, #__VA_ARGS__);\
+    ECS_ENUM_TYPE(name, __VA_ARGS__)
+
+/** ECS_BITMASK(name, body) */
+#define ECS_BITMASK(name, ...)\
+    ECS_META_IMPL_CALL(ECS_BITMASK_, ECS_META_IMPL, name, #__VA_ARGS__);\
+    ECS_ENUM_TYPE(name, __VA_ARGS__)
+
+/** Macro used to mark part of type for which no reflection data is created */
+#define ECS_PRIVATE
+
+/** Populate meta information from type descriptor. */
 FLECS_API
-void ecs_snapshot_restore(
+int ecs_meta_from_desc(
     ecs_world_t *world,
-    ecs_snapshot_t *snapshot);
+    ecs_entity_t component,
+    ecs_type_kind_t kind,
+    const char *desc);
 
-/** Obtain iterator to snapshot data.
- *
- * @param snapshot The snapshot to iterate over.
- * @return Iterator to snapshot data. */
-FLECS_API
-ecs_iter_t ecs_snapshot_iter(
-    ecs_snapshot_t *snapshot);
 
-/** Progress snapshot iterator.
- *
- * @param iter The snapshot iterator.
- * @return True if more data is available, otherwise false.
- */
-FLECS_API
-bool ecs_snapshot_next(
-    ecs_iter_t *iter);
+/* Private API */
 
-/** Free snapshot resources.
- * This frees resources associated with a snapshot without restoring it.
- *
- * @param snapshot The snapshot to free.
- */
-FLECS_API
-void ecs_snapshot_free(
-    ecs_snapshot_t *snapshot);
+/* Utilities to switch between IMPL, DECLARE and EXTERN variants */
+#define ECS_META_IMPL_CALL_INNER(base, impl, name, type_desc)\
+    base ## impl(name, type_desc)
 
-#ifdef __cplusplus
-}
-#endif
+#define ECS_META_IMPL_CALL(base, impl, name, type_desc)\
+    ECS_META_IMPL_CALL_INNER(base, impl, name, type_desc)
 
-#endif
+/* ECS_STRUCT implementation */
+#define ECS_STRUCT_TYPE(name, ...)\
+    typedef struct __VA_ARGS__ name
 
-/** @} */
+#define ECS_STRUCT_ECS_META_IMPL ECS_STRUCT_IMPL
 
-#endif
+#define ECS_STRUCT_IMPL(name, type_desc)\
+    extern ECS_COMPONENT_DECLARE(name);\
+    static const char *FLECS__##name##_desc = type_desc;\
+    static ecs_type_kind_t FLECS__##name##_kind = EcsStructType;\
+    ECS_COMPONENT_DECLARE(name) = 0
 
-#endif
+#define ECS_STRUCT_DECLARE(name, type_desc)\
+    extern ECS_COMPONENT_DECLARE(name);\
+    ECS_COMPONENT_DECLARE(name) = 0
 
-#ifdef FLECS_PARSER
-#ifdef FLECS_NO_PARSER
-#error "FLECS_NO_PARSER failed: PARSER is required by other addons"
-#endif
-/**
- * @file addons/parser.h
- * @brief Parser addon.
- *
- * The parser addon parses string expressions into lists of terms, and can be
- * used to construct filters, queries and types.
- */
+#define ECS_STRUCT_EXTERN(name, type_desc)\
+    extern ECS_COMPONENT_DECLARE(name)
 
-#ifdef FLECS_PARSER
 
-/**
- * @defgroup c_addons_parser Parser
- * @ingroup c_addons
- * Query DSL parser and parsing utilities.
- *
- * @{
- */
+/* ECS_ENUM implementation */
+#define ECS_ENUM_TYPE(name, ...)\
+    typedef enum __VA_ARGS__ name
 
-#ifndef FLECS_PARSER_H
-#define FLECS_PARSER_H
+#define ECS_ENUM_ECS_META_IMPL ECS_ENUM_IMPL
 
-/** Maximum number of extra arguments in term expression */
-#define ECS_PARSER_MAX_ARGS (16)
+#define ECS_ENUM_IMPL(name, type_desc)\
+    extern ECS_COMPONENT_DECLARE(name);\
+    static const char *FLECS__##name##_desc = type_desc;\
+    static ecs_type_kind_t FLECS__##name##_kind = EcsEnumType;\
+    ECS_COMPONENT_DECLARE(name) = 0
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#define ECS_ENUM_DECLARE(name, type_desc)\
+    extern ECS_COMPONENT_DECLARE(name);\
+    ECS_COMPONENT_DECLARE(name) = 0
 
-/** Skip whitespace characters.
- * This function skips whitespace characters. Does not skip newlines.
- *
- * @param ptr Pointer to (potential) whitespaces to skip.
- * @return Pointer to the next non-whitespace character.
- */
-FLECS_API
-const char* ecs_parse_ws(
-    const char *ptr);
+#define ECS_ENUM_EXTERN(name, type_desc)\
+    extern ECS_COMPONENT_DECLARE(name)
 
-/** Skip whitespace and newline characters.
- * This function skips whitespace characters.
- *
- * @param ptr Pointer to (potential) whitespaces to skip.
- * @return Pointer to the next non-whitespace character.
- */
-FLECS_API
-const char* ecs_parse_ws_eol(
-    const char *ptr);
 
-/** Utility function to parse an identifier */
-const char* ecs_parse_identifier(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token_out);
+/* ECS_BITMASK implementation */
+#define ECS_BITMASK_TYPE(name, ...)\
+    typedef enum __VA_ARGS__ name
 
-/** Parse digit.
- * This function will parse until the first non-digit character is found. The
- * provided expression must contain at least one digit character.
- *
- * @param ptr The expression to parse.
- * @param token The output buffer.
- * @return Pointer to the first non-digit character.
- */
-FLECS_API
-const char* ecs_parse_digit(
-    const char *ptr,
-    char *token);
+#define ECS_BITMASK_ECS_META_IMPL ECS_BITMASK_IMPL
 
-/** Parse a single token.
- * This function can be used as simple tokenizer by other parsers.
- *
- * @param name of program (used for logging).
- * @param expr pointer to token to parse.
- * @param ptr pointer to first character to parse.
- * @param token_out Parsed token (buffer should be ECS_MAX_TOKEN_SIZE large)
- * @return Pointer to the next token, or NULL if error occurred.
- */
-FLECS_API
-const char* ecs_parse_token(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token_out,
-    char delim);
+#define ECS_BITMASK_IMPL(name, type_desc)\
+    extern ECS_COMPONENT_DECLARE(name);\
+    static const char *FLECS__##name##_desc = type_desc;\
+    static ecs_type_kind_t FLECS__##name##_kind = EcsBitmaskType;\
+    ECS_COMPONENT_DECLARE(name) = 0
 
-/** Parse term in expression.
- * This operation parses a single term in an expression and returns a pointer
- * to the next term expression.
- *
- * If the returned pointer points to the 0-terminator, the expression is fully
- * parsed. The function would typically be called in a while loop:
- *
- * @code
- * const char *ptr = expr;
- * while (ptr[0] && (ptr = ecs_parse_term(world, name, expr, ptr, &term))) { }
- * @endcode
- *
- * The operation does not attempt to find entity ids from the names in the
- * expression. Use the ecs_term_resolve_ids() function to resolve the identifiers
- * in the parsed term.
- *
- * The returned term will in most cases contain allocated resources, which
- * should freed (or used) by the application. To free the resources for a term,
- * use the ecs_term_free() function.
- *
- * The parser accepts expressions in the legacy string format.
- *
- * @param world The world.
- * @param name The name of the expression (optional, improves error logs)
- * @param expr The expression to parse (optional, improves error logs)
- * @param ptr The pointer to the current term (must be in expr).
- * @param term_out Out parameter for the term.
- * @param extra_args Out array for extra args, must be of size ECS_PARSER_MAX_ARGS.
- * @return pointer to next term if successful, NULL if failed.
- */
-FLECS_API
-char* ecs_parse_term(
-    const ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_term_t *term_out,
-    ecs_oper_kind_t *extra_oper,
-    ecs_term_id_t *extra_args,
-    bool allow_newline);
+#define ECS_BITMASK_DECLARE(name, type_desc)\
+    extern ECS_COMPONENT_DECLARE(name);\
+    ECS_COMPONENT_DECLARE(name) = 0
+
+#define ECS_BITMASK_EXTERN(name, type_desc)\
+    extern ECS_COMPONENT_DECLARE(name)
 
 #ifdef __cplusplus
 }
-#endif // __cplusplus
+#endif
+
+#endif // FLECS_META_H
+
+/** @} */
 
-#endif // FLECS_PARSER_H
+#endif // FLECS_META
+
+
+#endif
 
 /** @} */
 
-#endif // FLECS_PARSER
+#endif
 
 #endif
 
@@ -16097,7 +15278,7 @@ struct component;
 namespace _
 {
 template <typename T, typename U = int>
-struct cpp_type;
+struct type;
 
 template <typename Func, typename ... Components>
 struct each_delegate;
@@ -16125,17 +15306,16 @@ namespace flecs {
 
 using world_t = ecs_world_t;
 using world_info_t = ecs_world_info_t;
-using query_group_info_t = ecs_query_group_info_t;
 using id_t = ecs_id_t;
 using entity_t = ecs_entity_t;
 using type_t = ecs_type_t;
 using table_t = ecs_table_t;
-using filter_t = ecs_filter_t;
-using observer_t = ecs_observer_t;
+using term_t = ecs_term_t;
 using query_t = ecs_query_t;
-using rule_t = ecs_rule_t;
-using ref_t = ecs_ref_t;
+using query_group_info_t = ecs_query_group_info_t;
+using observer_t = ecs_observer_t;
 using iter_t = ecs_iter_t;
+using ref_t = ecs_ref_t;
 using type_info_t = ecs_type_info_t;
 using type_hooks_t = ecs_type_hooks_t;
 using flags32_t = ecs_flags32_t;
@@ -16143,6 +15323,7 @@ using flags32_t = ecs_flags32_t;
 enum inout_kind_t {
     InOutDefault = EcsInOutDefault,
     InOutNone = EcsInOutNone,
+    InOutFilter = EcsInOutFilter,
     InOut = EcsInOut,
     In = EcsIn,
     Out = EcsOut
@@ -16158,6 +15339,13 @@ enum oper_kind_t {
     NotFrom = EcsNotFrom
 };
 
+enum query_cache_kind_t {
+    QueryCacheDefault = EcsQueryCacheDefault,
+    QueryCacheAuto = EcsQueryCacheAuto,
+    QueryCacheAll = EcsQueryCacheAll,
+    QueryCacheNone = EcsQueryCacheNone
+};
+
 /** Id flags */
 static const flecs::entity_t Pair = ECS_PAIR;
 static const flecs::entity_t Override = ECS_OVERRIDE;
@@ -16170,9 +15358,8 @@ static const flecs::entity_t Toggle = ECS_TOGGLE;
 /* Builtin components */
 using Component = EcsComponent;
 using Identifier = EcsIdentifier;
-using Iterable = EcsIterable;
 using Poly = EcsPoly;
-using FlattenTarget = EcsFlattenTarget;
+using DefaultChildComponent = EcsDefaultChildComponent;
 
 /* Builtin tags */
 static const flecs::entity_t Query = EcsQuery;
@@ -16196,16 +15383,16 @@ static const flecs::entity_t OnTableCreate = EcsOnTableCreate;
 static const flecs::entity_t OnTableDelete = EcsOnTableDelete;
 
 /* Builtin term flags */
-static const uint32_t Self = EcsSelf;
-static const uint32_t Up = EcsUp;
-static const uint32_t Down = EcsDown;
-static const uint32_t Cascade = EcsCascade;
-static const uint32_t Desc = EcsDesc;
-static const uint32_t Parent = EcsParent;
-static const uint32_t IsVariable = EcsIsVariable;
-static const uint32_t IsEntity = EcsIsEntity;
-static const uint32_t Filter = EcsFilter;
-static const uint32_t TraverseFlags = EcsTraverseFlags;
+static const uint64_t Self = EcsSelf;
+static const uint64_t Up = EcsUp;
+static const uint64_t Trav = EcsTrav;
+static const uint64_t Cascade = EcsCascade;
+static const uint64_t Desc = EcsDesc;
+static const uint64_t IsVariable = EcsIsVariable;
+static const uint64_t IsEntity = EcsIsEntity;
+static const uint64_t IsName = EcsIsName;
+static const uint64_t TraverseFlags = EcsTraverseFlags;
+static const uint64_t TermRefFlags = EcsTermRefFlags;
 
 /* Builtin entity ids */
 static const flecs::entity_t Flecs = EcsFlecs;
@@ -16221,8 +15408,7 @@ static const flecs::entity_t Reflexive = EcsReflexive;
 static const flecs::entity_t Final = EcsFinal;
 static const flecs::entity_t DontInherit = EcsDontInherit;
 static const flecs::entity_t AlwaysOverride = EcsAlwaysOverride;
-static const flecs::entity_t Tag = EcsTag;
-static const flecs::entity_t Union = EcsUnion;
+static const flecs::entity_t PairIsTag = EcsPairIsTag;
 static const flecs::entity_t Exclusive = EcsExclusive;
 static const flecs::entity_t Acyclic = EcsAcyclic;
 static const flecs::entity_t Traversable = EcsTraversable;
@@ -16232,6 +15418,7 @@ static const flecs::entity_t OneOf = EcsOneOf;
 static const flecs::entity_t Trait = EcsTrait;
 static const flecs::entity_t Relationship = EcsRelationship;
 static const flecs::entity_t Target = EcsTarget;
+static const flecs::entity_t CanToggle = EcsCanToggle;
 
 /* Builtin relationships */
 static const flecs::entity_t IsA = EcsIsA;
@@ -16250,10 +15437,6 @@ static const flecs::entity_t Remove = EcsRemove;
 static const flecs::entity_t Delete = EcsDelete;
 static const flecs::entity_t Panic = EcsPanic;
 
-/* Misc */
-static const flecs::entity_t Flatten = EcsFlatten;
-static const flecs::entity_t DefaultChildComponent = EcsDefaultChildComponent;
-
 /* Builtin predicates for comparing entity ids in queries. Only supported by rules */
 static const flecs::entity_t PredEq = EcsPredEq;
 static const flecs::entity_t PredMatch = EcsPredMatch;
@@ -16432,29 +15615,29 @@ template <typename T>
 struct array_iterator
 {
     explicit array_iterator(T* value, int index) {
-        m_value = value;
-        m_index = index;
+        value_ = value;
+        index_ = index;
     }
 
     bool operator!=(array_iterator const& other) const
     {
-        return m_index != other.m_index;
+        return index_ != other.index_;
     }
 
     T & operator*() const
     {
-        return m_value[m_index];
+        return value_[index_];
     }
 
     array_iterator& operator++()
     {
-        ++m_index;
+        ++index_;
         return *this;
     }
 
 private:
-    T* m_value;
-    int m_index;
+    T* value_;
+    int index_;
 };
 
 template <typename T, size_t Size, class Enable = void> 
@@ -16472,19 +15655,19 @@ struct array<T, Size, enable_if_t<Size != 0> > final {
     }
 
     T& operator[](int index) {
-        return m_array[index];
+        return array_[index];
     }
 
     T& operator[](size_t index) {
-        return m_array[index];
+        return array_[index];
     }
 
     array_iterator<T> begin() {
-        return array_iterator<T>(m_array, 0);
+        return array_iterator<T>(array_, 0);
     }
 
     array_iterator<T> end() {
-        return array_iterator<T>(m_array, Size);
+        return array_iterator<T>(array_, Size);
     }
 
     size_t size() {
@@ -16492,7 +15675,7 @@ struct array<T, Size, enable_if_t<Size != 0> > final {
     }
 
     T* ptr() {
-        return m_array;
+        return array_;
     }
 
     template <typename Func>
@@ -16503,7 +15686,7 @@ struct array<T, Size, enable_if_t<Size != 0> > final {
     }
 
 private:
-    T m_array[Size];
+    T array_[Size];
 };
 
 template<typename T, size_t Size>
@@ -16545,43 +15728,43 @@ struct string_view;
 // wrapping in an std::string.
 struct string {
     explicit string() 
-        : m_str(nullptr)
-        , m_const_str("")
-        , m_length(0) { }
+        : str_(nullptr)
+        , const_str_("")
+        , length_(0) { }
 
     explicit string(char *str) 
-        : m_str(str)
-        , m_const_str(str ? str : "")
-        , m_length(str ? ecs_os_strlen(str) : 0) { }
+        : str_(str)
+        , const_str_(str ? str : "")
+        , length_(str ? ecs_os_strlen(str) : 0) { }
 
     ~string() {
         // If flecs is included in a binary but is not used, it is possible that
         // the OS API is not initialized. Calling ecs_os_free in that case could
         // crash the application during exit. However, if a string has been set
         // flecs has been used, and OS API should have been initialized.
-        if (m_str) {
-            ecs_os_free(m_str);
+        if (str_) {
+            ecs_os_free(str_);
         }
     }
 
     string(string&& str) noexcept {
-        ecs_os_free(m_str);
-        m_str = str.m_str;
-        m_const_str = str.m_const_str;
-        m_length = str.m_length;
-        str.m_str = nullptr;
+        ecs_os_free(str_);
+        str_ = str.str_;
+        const_str_ = str.const_str_;
+        length_ = str.length_;
+        str.str_ = nullptr;
     }
 
     operator const char*() const {
-        return m_const_str;
+        return const_str_;
     }
 
     string& operator=(string&& str) noexcept {
-        ecs_os_free(m_str);
-        m_str = str.m_str;
-        m_const_str = str.m_const_str;
-        m_length = str.m_length;
-        str.m_str = nullptr;
+        ecs_os_free(str_);
+        str_ = str.str_;
+        const_str_ = str.const_str_;
+        length_ = str.length_;
+        str.str_ = nullptr;
         return *this;
     }
 
@@ -16590,19 +15773,19 @@ struct string {
     string(const string& str) = delete;
 
     bool operator==(const flecs::string& str) const {
-        if (str.m_const_str == m_const_str) {
+        if (str.const_str_ == const_str_) {
             return true;
         }
 
-        if (!m_const_str || !str.m_const_str) {
+        if (!const_str_ || !str.const_str_) {
             return false;
         }
 
-        if (str.m_length != m_length) {
+        if (str.length_ != length_) {
             return false;
         }
 
-        return ecs_os_strcmp(str, m_const_str) == 0;
+        return ecs_os_strcmp(str, const_str_) == 0;
     }
 
     bool operator!=(const flecs::string& str) const {
@@ -16610,15 +15793,15 @@ struct string {
     }    
 
     bool operator==(const char *str) const {
-        if (m_const_str == str) {
+        if (const_str_ == str) {
             return true;
         }
 
-        if (!m_const_str || !str) {
+        if (!const_str_ || !str) {
             return false;
         }
 
-        return ecs_os_strcmp(str, m_const_str) == 0;
+        return ecs_os_strcmp(str, const_str_) == 0;
     }
 
     bool operator!=(const char *str) const {
@@ -16626,11 +15809,11 @@ struct string {
     }    
 
     const char* c_str() const {
-        return m_const_str;
+        return const_str_;
     }
 
     std::size_t length() const {
-        return static_cast<std::size_t>(m_length);
+        return static_cast<std::size_t>(length_);
     }
 
     template <size_t N>
@@ -16643,14 +15826,14 @@ struct string {
     }
 
     void clear() {
-        ecs_os_free(m_str);
-        m_str = nullptr;
-        m_const_str = nullptr;
+        ecs_os_free(str_);
+        str_ = nullptr;
+        const_str_ = nullptr;
     }
 
     bool contains(const char *substr) {
-        if (m_const_str) {
-            return strstr(m_const_str, substr) != nullptr;
+        if (const_str_) {
+            return strstr(const_str_, substr) != nullptr;
         } else {
             return false;
         }
@@ -16663,13 +15846,13 @@ struct string {
     // Making this constructor private forces the code to explicitly create a
     // string_view which emphasizes that the string won't be freed by the class.
     string(const char *str)
-        : m_str(nullptr)
-        , m_const_str(str ? str : "")
-        , m_length(str ? ecs_os_strlen(str) : 0) { }
+        : str_(nullptr)
+        , const_str_(str ? str : "")
+        , length_(str ? ecs_os_strlen(str) : 0) { }
 
-    char *m_str = nullptr;
-    const char *m_const_str;
-    ecs_size_t m_length;
+    char *str_ = nullptr;
+    const char *const_str_;
+    ecs_size_t length_;
 };
 
 // For consistency, the API returns a string_view where it could have returned
@@ -17169,7 +16352,7 @@ struct enum_data {
 /** Convenience function for getting enum reflection data */
 template <typename E>
 enum_data<E> enum_type(flecs::world_t *world) {
-    _::cpp_type<E>::id(world); // Ensure enum is registered
+    _::type<E>::id(world); // Ensure enum is registered
     auto& ref = _::enum_type<E>::get();
     return enum_data<E>(world, ref.data);
 }
@@ -17185,22 +16368,22 @@ namespace flecs {
 
 struct stringstream {
     explicit stringstream() 
-        : m_buf({}) { }
+        : buf_({}) { }
 
     ~stringstream() {
-        ecs_strbuf_reset(&m_buf);
+        ecs_strbuf_reset(&buf_);
     }
 
     stringstream(stringstream&& str) noexcept {
-        ecs_strbuf_reset(&m_buf);
-        m_buf = str.m_buf;
-        str.m_buf = {};
+        ecs_strbuf_reset(&buf_);
+        buf_ = str.buf_;
+        str.buf_ = {};
     }
 
     stringstream& operator=(stringstream&& str) noexcept {
-        ecs_strbuf_reset(&m_buf);
-        m_buf = str.m_buf;
-        str.m_buf = {};
+        ecs_strbuf_reset(&buf_);
+        buf_ = str.buf_;
+        str.buf_ = {};
         return *this;
     }
 
@@ -17209,16 +16392,16 @@ struct stringstream {
     stringstream(const stringstream& str) = delete;    
 
     stringstream& operator<<(const char* str) {
-        ecs_strbuf_appendstr(&m_buf, str);
+        ecs_strbuf_appendstr(&buf_, str);
         return *this;
     }
 
     flecs::string str() {
-        return flecs::string(ecs_strbuf_get(&m_buf));
+        return flecs::string(ecs_strbuf_get(&buf_));
     }
 
 private:
-    ecs_strbuf_t m_buf;
+    ecs_strbuf_t buf_;
 };
 
 }
@@ -17404,42 +16587,42 @@ struct entity;
  */
 struct id {
     id()
-        : m_world(nullptr)
-        , m_id(0) { }
+        : world_(nullptr)
+        , id_(0) { }
 
     explicit id(flecs::id_t value)
-        : m_world(nullptr)
-        , m_id(value) { }
+        : world_(nullptr)
+        , id_(value) { }
 
     explicit id(flecs::world_t *world, flecs::id_t value = 0)
-        : m_world(world)
-        , m_id(value) { }
+        : world_(world)
+        , id_(value) { }
 
     explicit id(flecs::world_t *world, flecs::id_t first, flecs::id_t second)
-        : m_world(world)
-        , m_id(ecs_pair(first, second)) { }
+        : world_(world)
+        , id_(ecs_pair(first, second)) { }
 
     explicit id(flecs::id_t first, flecs::id_t second)
-        : m_world(nullptr)
-        , m_id(ecs_pair(first, second)) { }
+        : world_(nullptr)
+        , id_(ecs_pair(first, second)) { }
 
     explicit id(const flecs::id& first, const flecs::id& second)
-        : m_world(first.m_world)
-        , m_id(ecs_pair(first.m_id, second.m_id)) { }
+        : world_(first.world_)
+        , id_(ecs_pair(first.id_, second.id_)) { }
 
     /** Test if id is pair (has first, second) */
     bool is_pair() const {
-        return (m_id & ECS_ID_FLAGS_MASK) == flecs::Pair;
+        return (id_ & ECS_ID_FLAGS_MASK) == flecs::Pair;
     }
 
     /** Test if id is a wildcard */
     bool is_wildcard() const {
-        return ecs_id_is_wildcard(m_id);
+        return ecs_id_is_wildcard(id_);
     }
 
     /** Test if id is entity */
     bool is_entity() const {
-        return !(m_id & ECS_ID_FLAGS_MASK);
+        return !(id_ & ECS_ID_FLAGS_MASK);
     }
 
     /** Return id as entity (only allowed when id is valid entity) */
@@ -17462,12 +16645,12 @@ struct id {
 
     /** Test if id has specified role */
     bool has_flags(flecs::id_t flags) const {
-        return ((m_id & flags) == flags);
+        return ((id_ & flags) == flags);
     }
 
     /** Test if id has any role */
     bool has_flags() const {
-        return (m_id & ECS_ID_FLAGS_MASK) != 0;
+        return (id_ & ECS_ID_FLAGS_MASK) != 0;
     }
 
     /** Return id flags set on id */
@@ -17478,7 +16661,7 @@ struct id {
         if (!is_pair()) {
             return false;
         }
-        return ECS_PAIR_FIRST(m_id) == first;
+        return ECS_PAIR_FIRST(id_) == first;
     }
 
     /** Get first element from a pair.
@@ -17495,21 +16678,21 @@ struct id {
 
     /* Convert id to string */
     flecs::string str() const {
-        return flecs::string(ecs_id_str(m_world, m_id));
+        return flecs::string(ecs_id_str(world_, id_));
     }
 
     /** Convert role of id to string. */
     flecs::string flags_str() const {
-        return flecs::string_view( ecs_id_flag_str(m_id & ECS_ID_FLAGS_MASK));
+        return flecs::string_view( ecs_id_flag_str(id_ & ECS_ID_FLAGS_MASK));
     }
 
     /** Return flecs::id_t value */
     flecs::id_t raw_id() const {
-        return m_id;
+        return id_;
     }
 
     operator flecs::id_t() const {
-        return m_id;
+        return id_;
     }
 
     flecs::world world() const;
@@ -17517,8 +16700,8 @@ struct id {
 protected:
     /* World is optional, but guarantees that entity identifiers extracted from
      * the id are valid */
-    flecs::world_t *m_world;
-    flecs::id_t m_id;
+    flecs::world_t *world_;
+    flecs::id_t id_;
 };
 
 /** @} */
@@ -17535,7 +16718,7 @@ struct id {
 namespace flecs {
 
 /**
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  *
  * @{
  */
@@ -17548,8 +16731,8 @@ struct term_builder;
 }
 
 /**
- * @file addons/cpp/mixins/filter/decl.hpp
- * @brief Filter declarations.
+ * @file addons/cpp/mixins/query/decl.hpp
+ * @brief Query declarations.
  */
 
 #pragma once
@@ -17557,20 +16740,19 @@ struct term_builder;
 namespace flecs {
 
 /**
- * @defgroup cpp_core_filters Filters
+ * @defgroup cpp_core_queries Queries
  * @ingroup cpp_core
- * Filters are cheaper to create, but slower to iterate than flecs::query.
  *
  * @{
  */
 
-struct filter_base;
+struct query_base;
 
 template<typename ... Components>
-struct filter;
+struct query;
 
 template<typename ... Components>
-struct filter_builder;
+struct query_builder;
 
 /** @} */
 
@@ -17603,20 +16785,20 @@ namespace flecs {
 template <typename Base, typename E>
 struct event_builder_base {
     event_builder_base(flecs::world_t *world, flecs::entity_t event)
-        : m_world(world)
-        , m_desc{}
-        , m_ids{}
-        , m_ids_array{}
+        : world_(world)
+        , desc_{}
+        , ids_{}
+        , ids_array_{}
     {
-        m_desc.event = event;
+        desc_.event = event;
     }
 
     /** Add component to emit for */
     template <typename T>
     Base& id() {
-        m_ids.array = m_ids_array;
-        m_ids.array[m_ids.count] = _::cpp_type<T>().id(m_world);
-        m_ids.count ++;
+        ids_.array = ids_array_;
+        ids_.array[ids_.count] = _::type<T>().id(world_);
+        ids_.count ++;
         return *this;
     }
     
@@ -17628,8 +16810,8 @@ struct event_builder_base {
     template <typename First, typename Second>
     Base& id() {
         return id(
-            ecs_pair(_::cpp_type<First>::id(this->m_world), 
-                _::cpp_type<Second>::id(this->m_world)));
+            ecs_pair(_::type<First>::id(this->world_), 
+                _::type<Second>::id(this->world_)));
     }
 
     /** 
@@ -17639,7 +16821,7 @@ struct event_builder_base {
      */
     template <typename First>
     Base& id(entity_t second) {
-        return id(ecs_pair(_::cpp_type<First>::id(this->m_world), second));
+        return id(ecs_pair(_::type<First>::id(this->world_), second));
     }
 
     /** 
@@ -17653,57 +16835,57 @@ struct event_builder_base {
 
     /** Add (component) id to emit for */
     Base& id(flecs::id_t id) {
-        m_ids.array = m_ids_array;
-        m_ids.array[m_ids.count] = id;
-        m_ids.count ++;
+        ids_.array = ids_array_;
+        ids_.array[ids_.count] = id;
+        ids_.count ++;
         return *this;
     }
 
     /** Set entity for which to emit event */
     Base& entity(flecs::entity_t e) {
-        m_desc.entity = e;
+        desc_.entity = e;
         return *this;
     }
 
     /* Set table for which to emit event */
     Base& table(flecs::table_t *t, int32_t offset = 0, int32_t count = 0) {
-        m_desc.table = t;
-        m_desc.offset = offset;
-        m_desc.count = count;
+        desc_.table = t;
+        desc_.offset = offset;
+        desc_.count = count;
         return *this;
     }
 
     /* Set event data */
     Base& ctx(const E* ptr) {
-        m_desc.const_param = ptr;
+        desc_.const_param = ptr;
         return *this;
     }
 
     /* Set event data */
     Base& ctx(E* ptr) {
-        m_desc.param = ptr;
+        desc_.param = ptr;
         return *this;
     }
 
     void emit() {
-        m_ids.array = m_ids_array;
-        m_desc.ids = &m_ids;
-        m_desc.observable = const_cast<flecs::world_t*>(ecs_get_world(m_world));
-        ecs_emit(m_world, &m_desc);
+        ids_.array = ids_array_;
+        desc_.ids = &ids_;
+        desc_.observable = const_cast<flecs::world_t*>(ecs_get_world(world_));
+        ecs_emit(world_, &desc_);
     }
 
     void enqueue() {
-        m_ids.array = m_ids_array;
-        m_desc.ids = &m_ids;
-        m_desc.observable = const_cast<flecs::world_t*>(ecs_get_world(m_world));
-        ecs_enqueue(m_world, &m_desc);
+        ids_.array = ids_array_;
+        desc_.ids = &ids_;
+        desc_.observable = const_cast<flecs::world_t*>(ecs_get_world(world_));
+        ecs_enqueue(world_, &desc_);
     }
 
 protected:
-    flecs::world_t *m_world;
-    ecs_event_desc_t m_desc;
-    flecs::type_t m_ids;
-    flecs::id_t m_ids_array[ECS_EVENT_DESC_ID_COUNT_MAX];
+    flecs::world_t *world_;
+    ecs_event_desc_t desc_;
+    flecs::type_t ids_;
+    flecs::id_t ids_array_[ECS_EVENT_DESC_ID_COUNT_MAX];
 
 private:
     operator Base&() {
@@ -17725,13 +16907,13 @@ struct event_builder_typed : event_builder_base<event_builder_typed<E>, E> {
 
     /* Set event data */
     Class& ctx(const E& ptr) {
-        this->m_desc.const_param = &ptr;
+        this->desc_.const_param = &ptr;
         return *this;
     }
 
     /* Set event data */
     Class& ctx(E&& ptr) {
-        this->m_desc.param = &ptr;
+        this->desc_.param = &ptr;
         return *this;
     }
 };
@@ -17766,35 +16948,6 @@ using event_from_func_t = typename event_from_func<Func>::type;
 }
 }
 
-/**
- * @file addons/cpp/mixins/query/decl.hpp
- * @brief Query declarations.
- */
-
-#pragma once
-
-namespace flecs {
-
-/**
- * @defgroup cpp_core_queries Queries
- * @ingroup cpp_core
- * Cached query implementation. Fast to iterate, but slower to create than flecs::filter.
- *
- * @{
- */
-
-struct query_base;
-
-template<typename ... Components>
-struct query;
-
-template<typename ... Components>
-struct query_builder;
-
-/** @} */
-
-}
-
 /**
  * @file addons/cpp/mixins/observer/decl.hpp
  * @brief Observer declarations.
@@ -17930,33 +17083,6 @@ void timer_init(flecs::world& world);
 } // namespace _
 } // namespace flecs
 
-#endif
-#ifdef FLECS_SNAPSHOT
-/**
- * @file addons/cpp/mixins/snapshot/decl.hpp
- * @brief Snapshot module declarations.
- */
-
-#pragma once
-
-namespace flecs {
-
-/**
- * @defgroup cpp_addons_snapshots Snapshots
- * @ingroup cpp_addons
- * Save & restore world.
- *
- * @{
- */
-
-using snapshot_t = ecs_snapshot_t;
-
-struct snapshot;
-
-/** @} */
-
-}
-
 #endif
 #ifdef FLECS_DOC
 /**
@@ -18037,37 +17163,6 @@ void init(flecs::world& world);
 
 }
 
-#endif
-#ifdef FLECS_RULES
-/**
- * @file addons/cpp/mixins/rule/decl.hpp
- * @brief Rule declarations.
- */
-
-#pragma once
-
-namespace flecs {
-
-/**
- * @defgroup cpp_addons_rules Rules
- * @ingroup cpp_addons
- * Rules are an advanced query engine for matching against entity graphs.
- *
- * @{
- */
-
-struct rule_base;
-
-template<typename ... Components>
-struct rule;
-
-template<typename ... Components>
-struct rule_builder;
-
-/** @} */
-
-}
-
 #endif
 #ifdef FLECS_META
 /**
@@ -18109,8 +17204,8 @@ using enum_constant_t = ecs_enum_constant_t;
 using bitmask_constant_t = ecs_bitmask_constant_t;
 
 /* Components */
-using MetaType = EcsMetaType;
-using MetaTypeSerialized = EcsMetaTypeSerialized;
+using Type = EcsType;
+using TypeSerializer = EcsTypeSerializer;
 using Primitive = EcsPrimitive;
 using Enum = EcsEnum;
 using Bitmask = EcsBitmask;
@@ -18214,42 +17309,42 @@ namespace flecs {
  */
 struct cursor {
     cursor(flecs::world_t *world, flecs::entity_t type_id, void *ptr) {
-        m_cursor = ecs_meta_cursor(world, type_id, ptr);
+        cursor_ = ecs_meta_cursor(world, type_id, ptr);
     }
 
     /** Push value scope (such as a nested struct) */
     int push() {
-        return ecs_meta_push(&m_cursor);
+        return ecs_meta_push(&cursor_);
     }
 
     /** Pop value scope */
     int pop() {
-        return ecs_meta_pop(&m_cursor);
+        return ecs_meta_pop(&cursor_);
     }
 
     /** Move to next member/element */
     int next() {
-        return ecs_meta_next(&m_cursor);
+        return ecs_meta_next(&cursor_);
     }
 
     /** Move to member by name */
     int member(const char *name) {
-        return ecs_meta_member(&m_cursor, name);
+        return ecs_meta_member(&cursor_, name);
     }
 
     /** Move to element by index */
     int elem(int32_t elem) {
-        return ecs_meta_elem(&m_cursor, elem);
+        return ecs_meta_elem(&cursor_, elem);
     }
 
     /** Test if current scope is a collection type */
     bool is_collection() {
-        return ecs_meta_is_collection(&m_cursor);
+        return ecs_meta_is_collection(&cursor_);
     }
 
     /** Get member name */
     flecs::string_view get_member() const {
-        return flecs::string_view(ecs_meta_get_member(&m_cursor));
+        return flecs::string_view(ecs_meta_get_member(&cursor_));
     }
 
     /** Get type of value */
@@ -18260,94 +17355,94 @@ struct cursor {
 
     /** Get untyped pointer to value */
     void* get_ptr() {
-        return ecs_meta_get_ptr(&m_cursor);
+        return ecs_meta_get_ptr(&cursor_);
     }
 
     /** Set boolean value */
     int set_bool(bool value) {
-        return ecs_meta_set_bool(&m_cursor, value);
+        return ecs_meta_set_bool(&cursor_, value);
     }
 
     /** Set char value */
     int set_char(char value) {
-        return ecs_meta_set_char(&m_cursor, value);
+        return ecs_meta_set_char(&cursor_, value);
     }
 
     /** Set signed int value */
     int set_int(int64_t value) {
-        return ecs_meta_set_int(&m_cursor, value);
+        return ecs_meta_set_int(&cursor_, value);
     }
 
     /** Set unsigned int value */
     int set_uint(uint64_t value) {
-        return ecs_meta_set_uint(&m_cursor, value);
+        return ecs_meta_set_uint(&cursor_, value);
     }
 
     /** Set float value */
     int set_float(double value) {
-        return ecs_meta_set_float(&m_cursor, value);
+        return ecs_meta_set_float(&cursor_, value);
     }
 
     /** Set string value */
     int set_string(const char *value) {
-        return ecs_meta_set_string(&m_cursor, value);
+        return ecs_meta_set_string(&cursor_, value);
     }
 
     /** Set string literal value */
     int set_string_literal(const char *value) {
-        return ecs_meta_set_string_literal(&m_cursor, value);
+        return ecs_meta_set_string_literal(&cursor_, value);
     }
 
     /** Set entity value */
     int set_entity(flecs::entity_t value) {
-        return ecs_meta_set_entity(&m_cursor, value);
+        return ecs_meta_set_entity(&cursor_, value);
     }
 
     /** Set (component) id value */
     int set_id(flecs::id_t value) {
-        return ecs_meta_set_id(&m_cursor, value);
+        return ecs_meta_set_id(&cursor_, value);
     }
 
     /** Set null value */
     int set_null() {
-        return ecs_meta_set_null(&m_cursor);
+        return ecs_meta_set_null(&cursor_);
     }
 
     /** Get boolean value */
     bool get_bool() const {
-        return ecs_meta_get_bool(&m_cursor);
+        return ecs_meta_get_bool(&cursor_);
     }
 
     /** Get char value */
     char get_char() const {
-        return ecs_meta_get_char(&m_cursor);
+        return ecs_meta_get_char(&cursor_);
     }
 
     /** Get signed int value */
     int64_t get_int() const {
-        return ecs_meta_get_int(&m_cursor);
+        return ecs_meta_get_int(&cursor_);
     }
 
     /** Get unsigned int value */
     uint64_t get_uint() const {
-        return ecs_meta_get_uint(&m_cursor);
+        return ecs_meta_get_uint(&cursor_);
     }
 
     /** Get float value */
     double get_float() const {
-        return ecs_meta_get_float(&m_cursor);
+        return ecs_meta_get_float(&cursor_);
     }
 
     /** Get string value */
     const char *get_string() const {
-        return ecs_meta_get_string(&m_cursor);
+        return ecs_meta_get_string(&cursor_);
     }
 
     /** Get entity value */
     flecs::entity get_entity() const;
 
     /** Cursor object */
-    ecs_meta_cursor_t m_cursor;
+    ecs_meta_cursor_t cursor_;
 };
 
 /** @} */
@@ -18388,7 +17483,7 @@ template <typename T, typename ElemType = void>
 struct opaque {
     opaque(flecs::world_t *w = nullptr) : world(w) {
         if (world) {
-            desc.entity = _::cpp_type<T>::id(world);
+            desc.entity = _::type<T>::id(world);
         }
     }
 
@@ -18952,15 +18047,15 @@ namespace flecs {
 /** Event builder interface */
 struct metric_builder {
     metric_builder(flecs::world_t *world, flecs::entity_t entity) 
-        : m_world(world) 
+        : world_(world) 
     {
-        m_desc.entity = entity;
+        desc_.entity = entity;
     }
 
     ~metric_builder();
 
     metric_builder& member(flecs::entity_t e) {
-        m_desc.member = e;
+        desc_.member = e;
         return *this;
     }
 
@@ -18975,61 +18070,61 @@ struct metric_builder {
     metric_builder& dotmember(const char *name);
 
     metric_builder& id(flecs::id_t the_id) {
-        m_desc.id = the_id;
+        desc_.id = the_id;
         return *this;
     }
 
     metric_builder& id(flecs::entity_t first, flecs::entity_t second) {
-        m_desc.id = ecs_pair(first, second);
+        desc_.id = ecs_pair(first, second);
         return *this;
     }
 
     template <typename T>
     metric_builder& id() {
-        return id(_::cpp_type<T>::id(m_world));
+        return id(_::type<T>::id(world_));
     }
 
     template <typename First>
     metric_builder& id(flecs::entity_t second) {
-        return id(_::cpp_type<First>::id(m_world), second);
+        return id(_::type<First>::id(world_), second);
     }
 
     template <typename Second>
     metric_builder& id_second(flecs::entity_t first) {
-        return id(first, _::cpp_type<Second>::id(m_world));
+        return id(first, _::type<Second>::id(world_));
     }
 
     template <typename First, typename Second>
     metric_builder& id() {
-        return id<First>(_::cpp_type<Second>::id(m_world));
+        return id<First>(_::type<Second>::id(world_));
     }
 
     metric_builder& targets(bool value = true) {
-        m_desc.targets = value;
+        desc_.targets = value;
         return *this;
     }
 
     metric_builder& kind(flecs::entity_t the_kind) {
-        m_desc.kind = the_kind;
+        desc_.kind = the_kind;
         return *this;
     }
 
     template <typename Kind>
     metric_builder& kind() {
-        return kind(_::cpp_type<Kind>::id(m_world));
+        return kind(_::type<Kind>::id(world_));
     }
 
     metric_builder& brief(const char *b) {
-        m_desc.brief = b;
+        desc_.brief = b;
         return *this;
     }
 
     operator flecs::entity();
 
 protected:
-    flecs::world_t *m_world;
-    ecs_metric_desc_t m_desc = {};
-    bool m_created = false;
+    flecs::world_t *world_;
+    ecs_metric_desc_t desc_ = {};
+    bool created_ = false;
 };
 
 /**
@@ -19166,72 +18261,74 @@ namespace flecs {
 /** App builder interface */
 struct app_builder {
     app_builder(flecs::world_t *world)
-        : m_world(world)
-        , m_desc{}
+        : world_(world)
+        , desc_{}
     {
         const ecs_world_info_t *stats = ecs_get_world_info(world);
-        m_desc.target_fps = stats->target_fps;
+        desc_.target_fps = stats->target_fps;
         ecs_ftime_t t_zero = 0.0;
-        if (ECS_EQ(m_desc.target_fps, t_zero)) {
-            m_desc.target_fps = 60;
+        if (ECS_EQ(desc_.target_fps, t_zero)) {
+            desc_.target_fps = 60;
         }
     }
 
     app_builder& target_fps(ecs_ftime_t value) {
-        m_desc.target_fps = value;
+        desc_.target_fps = value;
         return *this;
     }
 
     app_builder& delta_time(ecs_ftime_t value) {
-        m_desc.delta_time = value;
+        desc_.delta_time = value;
         return *this;
     }
 
     app_builder& threads(int32_t value) {
-        m_desc.threads = value;
+        desc_.threads = value;
         return *this;
     }
 
     app_builder& frames(int32_t value) {
-        m_desc.frames = value;
+        desc_.frames = value;
         return *this;
     }
 
     app_builder& enable_rest(uint16_t port = 0) {
-        m_desc.enable_rest = true;
-        m_desc.port = port;
+        desc_.enable_rest = true;
+        desc_.port = port;
         return *this;
     }
 
     app_builder& enable_monitor(bool value = true) {
-        m_desc.enable_monitor = value;
+        desc_.enable_monitor = value;
         return *this;
     }
 
     app_builder& init(ecs_app_init_action_t value) {
-        m_desc.init = value;
+        desc_.init = value;
         return *this;
     }
 
     app_builder& ctx(void *value) {
-        m_desc.ctx = value;
+        desc_.ctx = value;
         return *this;
     }
 
     int run() {
-        int result = ecs_app_run(m_world, &m_desc);
-        if (ecs_should_quit(m_world)) {
+        int result = ecs_app_run(world_, &desc_);
+        if (ecs_should_quit(world_)) {
             // Only free world if quit flag is set. This ensures that we won't
             // try to cleanup the world if the app is used in an environment
             // that takes over the main loop, like with emscripten.
-            ecs_fini(m_world);
+            if (!flecs_poly_release(world_)) {
+                ecs_fini(world_);
+            }
         }
         return result;
     }
 
 private:
-    flecs::world_t *m_world;
-    ecs_app_desc_t m_desc;
+    flecs::world_t *world_;
+    ecs_app_desc_t desc_;
 };
 
 /** @} */
@@ -19889,40 +18986,42 @@ namespace flecs
  */
 template <typename T>
 struct ref {
-    ref() : m_world(nullptr), m_ref{} { }
+    ref() : world_(nullptr), ref_{} { }
 
     ref(world_t *world, entity_t entity, flecs::id_t id = 0)
-        : m_ref()
+        : ref_()
     {
         // the world we were called with may be a stage; convert it to a world
         // here if that is the case
-        m_world = world ? const_cast<flecs::world_t *>(ecs_get_world(world))
+        world_ = world ? const_cast<flecs::world_t *>(ecs_get_world(world))
             : nullptr;
         if (!id) {
-            id = _::cpp_type<T>::id(world);
+            id = _::type<T>::id(world);
         }
 
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
-        m_ref = ecs_ref_init_id(m_world, entity, id);
+        ref_ = ecs_ref_init_id(world_, entity, id);
     }
 
     T* operator->() {
         T* result = static_cast<T*>(ecs_ref_get_id(
-            m_world, &m_ref, this->m_ref.id));
+            world_, &ref_, this->ref_.id));
 
-        ecs_assert(result != NULL, ECS_INVALID_PARAMETER, NULL);
+        ecs_assert(result != NULL, ECS_INVALID_PARAMETER,
+            "nullptr dereference by flecs::ref");
 
         return result;
     }
 
     T* get() {
         return static_cast<T*>(ecs_ref_get_id(
-            m_world, &m_ref, this->m_ref.id));
+            world_, &ref_, this->ref_.id));
     }
 
     T* try_get() {
-        if (!m_world || !m_ref.entity) {
+        if (!world_ || !ref_.entity) {
             return nullptr;
         }
 
@@ -19932,8 +19031,8 @@ struct ref {
     flecs::entity entity() const;
 
 private:
-    world_t *m_world;
-    flecs::ref_t m_ref;
+    world_t *world_;
+    flecs::ref_t ref_;
 };
 
 /** @} */
@@ -19955,7 +19054,8 @@ namespace flecs
 // set(T&&), T = constructible
 template <typename T, if_t< is_flecs_constructible<T>::value > = 0>
 inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t id) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
     if (!ecs_is_deferred(world)) {
         T& dst = *static_cast<T*>(ecs_ensure_id(world, entity, id));
@@ -19971,7 +19071,8 @@ inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t i
 // set(const T&), T = constructible
 template <typename T, if_t< is_flecs_constructible<T>::value > = 0>
 inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::id_t id) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
     if (!ecs_is_deferred(world)) {
         T& dst = *static_cast<T*>(ecs_ensure_id(world, entity, id));
@@ -19987,7 +19088,8 @@ inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::i
 // set(T&&), T = not constructible
 template <typename T, if_not_t< is_flecs_constructible<T>::value > = 0>
 inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t id) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
     if (!ecs_is_deferred(world)) {
         T& dst = *static_cast<remove_reference_t<T>*>(ecs_ensure_id(world, entity, id));
@@ -20003,7 +19105,8 @@ inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t i
 // set(const T&), T = not constructible
 template <typename T, if_not_t< is_flecs_constructible<T>::value > = 0>
 inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::id_t id) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
     if (!ecs_is_deferred(world)) {
         T& dst = *static_cast<remove_reference_t<T>*>(ecs_ensure_id(world, entity, id));
@@ -20021,8 +19124,9 @@ template <typename T, typename ... Args, if_t<
     std::is_constructible<actual_type_t<T>, Args...>::value ||
     std::is_default_constructible<actual_type_t<T>>::value > = 0>
 inline void emplace(world_t *world, flecs::entity_t entity, flecs::id_t id, Args&&... args) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-    T& dst = *static_cast<T*>(ecs_emplace_id(world, entity, id));
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+    T& dst = *static_cast<T*>(ecs_emplace_id(world, entity, id, nullptr));
 
     FLECS_PLACEMENT_NEW(&dst, T{FLECS_FWD(args)...});
 
@@ -20032,14 +19136,14 @@ inline void emplace(world_t *world, flecs::entity_t entity, flecs::id_t id, Args
 // set(T&&)
 template <typename T, typename A>
 inline void set(world_t *world, entity_t entity, A&& value) {
-    id_t id = _::cpp_type<T>::id(world);
+    id_t id = _::type<T>::id(world);
     flecs::set(world, entity, FLECS_FWD(value), id);
 }
 
 // set(const T&)
 template <typename T, typename A>
 inline void set(world_t *world, entity_t entity, const A& value) {
-    id_t id = _::cpp_type<T>::id(world);
+    id_t id = _::type<T>::id(world);
     flecs::set(world, entity, value, id);
 }
 
@@ -20075,91 +19179,99 @@ struct world {
     /** Create world.
      */
     explicit world()
-        : m_world( ecs_init() )
-        , m_owned( true ) { init_builtin_components(); }
+        : world_( ecs_init() ) { 
+            init_builtin_components(); 
+        }
 
     /** Create world with command line arguments.
      * Currently command line arguments are not interpreted, but they may be
      * used in the future to configure Flecs parameters.
      */
     explicit world(int argc, char *argv[])
-        : m_world( ecs_init_w_args(argc, argv) )
-        , m_owned( true ) { init_builtin_components(); }
+        : world_( ecs_init_w_args(argc, argv) ) { 
+            init_builtin_components(); 
+        }
 
     /** Create world from C world.
      */
     explicit world(world_t *w)
-        : m_world( w )
-        , m_owned( false ) { }
+        : world_( w ) { 
+            if (w) {
+                flecs_poly_claim(w);
+            }
+        }
 
     /** Not allowed to copy a world. May only take a reference.
      */
-    world(const world& obj) = delete;
-
-    world(world&& obj) noexcept {
-        m_world = obj.m_world;
-        m_owned = obj.m_owned;
-        obj.m_world = nullptr;
-        obj.m_owned = false;
+    world(const world& obj) {
+        this->world_ = obj.world_;
+        flecs_poly_claim(this->world_);
     }
 
-    /* Implicit conversion to world_t* */
-    operator world_t*() const { return m_world; }
+    world& operator=(const world& obj) noexcept {
+        this->world_ = obj.world_;
+        flecs_poly_claim(this->world_);
+        return *this;
+    }
 
-    /** Not allowed to copy a world. May only take a reference.
-     */
-    world& operator=(const world& obj) = delete;
+    world(world&& obj) noexcept {
+        world_ = obj.world_;
+        obj.world_ = nullptr;
+    }
 
     world& operator=(world&& obj) noexcept {
-        this->~world();
-
-        m_world = obj.m_world;
-        m_owned = obj.m_owned;
-        obj.m_world = nullptr;
-        obj.m_owned = false;
+        world_ = obj.world_;
+        obj.world_ = nullptr;
         return *this;
     }
 
     ~world() {
-        if (m_owned && ecs_stage_is_async(m_world)) {
-            ecs_async_stage_free(m_world);
-        } else
-        if (m_owned && m_world) {
-            ecs_fini(m_world);
+        if (world_) {
+            if (!flecs_poly_release(world_)) {
+                if (ecs_stage_get_id(world_) == -1) {
+                    ecs_stage_free(world_);
+                } else {
+                    ecs_fini(world_);
+                }
+            }
         }
     }
 
+    /* Implicit conversion to world_t* */
+    operator world_t*() const { return world_; }
+
     /** Deletes and recreates the world. */
     void reset() {
-        // Can only reset the world if we own the world object.
-        ecs_assert(this->m_owned, ECS_INVALID_OPERATION, NULL);
-        ecs_fini(m_world);
-        m_world = ecs_init();
+        /* Make sure there's only one reference to the world */
+        ecs_assert(flecs_poly_refcount(world_) == 1, ECS_INVALID_OPERATION,
+            "reset would invalidate other handles");
+        ecs_fini(world_);
+        world_ = ecs_init();
     }
 
     /** Obtain pointer to C world object.
      */
     world_t* c_ptr() const {
-        return m_world;
+        return world_;
     }
 
     /** Signal application should quit.
      * After calling this operation, the next call to progress() returns false.
      */
     void quit() const {
-        ecs_quit(m_world);
+        ecs_quit(world_);
     }
 
     /** Register action to be executed when world is destroyed.
      */
     void atfini(ecs_fini_action_t action, void *ctx = nullptr) const {
-        ecs_atfini(m_world, action, ctx);
+        ecs_atfini(world_, action, ctx);
     }
 
     /** Test if quit() has been called.
      */
     bool should_quit() const {
-        return ecs_should_quit(m_world);
+        return ecs_should_quit(world_);
     }
 
     /** Begin frame.
@@ -20181,7 +19293,7 @@ struct world {
      * @return The provided delta_time, or measured time if 0 was provided.
      */
     ecs_ftime_t frame_begin(float delta_time = 0) const {
-        return ecs_frame_begin(m_world, delta_time);
+        return ecs_frame_begin(world_, delta_time);
     }
 
     /** End frame.
@@ -20191,7 +19303,7 @@ struct world {
      * This function should only be ran from the main thread.
      */
     void frame_end() const {
-        ecs_frame_end(m_world);
+        ecs_frame_end(world_);
     }
 
     /** Begin readonly mode.
@@ -20201,7 +19313,7 @@ struct world {
      * @return Whether world is currently staged.
      */
     bool readonly_begin(bool multi_threaded = false) const {
-        return ecs_readonly_begin(m_world, multi_threaded);
+        return ecs_readonly_begin(world_, multi_threaded);
     }
 
     /** End readonly mode.
@@ -20209,7 +19321,7 @@ struct world {
      * @see ecs_readonly_end
      */
     void readonly_end() const {
-        ecs_readonly_end(m_world);
+        ecs_readonly_end(world_);
     }
 
     /** Defer operations until end of frame.
@@ -20219,7 +19331,7 @@ struct world {
      * This operation is thread safe.
      */
     bool defer_begin() const {
-        return ecs_defer_begin(m_world);
+        return ecs_defer_begin(world_);
     }
 
     /** End block of operations to defer.
@@ -20228,13 +19340,13 @@ struct world {
      * This operation is thread safe.
      */
     bool defer_end() const {
-        return ecs_defer_end(m_world);
+        return ecs_defer_end(world_);
     }
 
     /** Test whether deferring is enabled.
      */
     bool is_deferred() const {
-        return ecs_is_deferred(m_world);
+        return ecs_is_deferred(world_);
     }
 
     /** Configure world to have N stages.
@@ -20250,7 +19362,7 @@ struct world {
      * @param stages The number of stages.
      */
     void set_stage_count(int32_t stages) const {
-        ecs_set_stage_count(m_world, stages);
+        ecs_set_stage_count(world_, stages);
     }
 
     /** Get number of configured stages.
@@ -20259,7 +19371,7 @@ struct world {
      * @return The number of stages used for threading.
      */
     int32_t get_stage_count() const {
-        return ecs_get_stage_count(m_world);
+        return ecs_get_stage_count(world_);
     }
 
     /** Get current stage id.
@@ -20269,7 +19381,7 @@ struct world {
      * @return The stage id.
      */
     int32_t get_stage_id() const {
-        return ecs_get_stage_id(m_world);
+        return ecs_stage_get_id(world_);
     }
 
     /** Test if is a stage.
@@ -20280,30 +19392,11 @@ struct world {
      */
     bool is_stage() const {
         ecs_assert(
-            ecs_poly_is(m_world, ecs_world_t) ||
-            ecs_poly_is(m_world, ecs_stage_t),
-                ECS_INVALID_PARAMETER, NULL);
-        return ecs_poly_is(m_world, ecs_stage_t);
-    }
-
-    /** Enable/disable auto-merging for world or stage.
-     * When auto-merging is enabled, staged data will automatically be merged
-     * with the world when staging ends. This happens at the end of progress(),
-     * at a sync point or when readonly_end() is called.
-     *
-     * Applications can exercise more control over when data from a stage is
-     * merged by disabling auto-merging. This requires an application to
-     * explicitly call merge() on the stage.
-     *
-     * When this function is invoked on the world, it sets all current stages to
-     * the provided value and sets the default for new stages. When this
-     * function is invoked on a stage, auto-merging is only set for that specific
-     * stage.
-     *
-     * @param automerge Whether to enable or disable auto-merging.
-     */
-    void set_automerge(bool automerge) const {
-        ecs_set_automerge(m_world, automerge);
+            flecs_poly_is(world_, ecs_world_t) ||
+            flecs_poly_is(world_, ecs_stage_t), 
+                ECS_INVALID_PARAMETER, 
+                "flecs::world instance contains invalid reference to world or stage");
+        return flecs_poly_is(world_, ecs_stage_t);
     }
 
     /** Merge world or stage.
@@ -20315,7 +19408,7 @@ struct world {
      * This operation may be called on an already merged stage or world.
      */
     void merge() const {
-        ecs_merge(m_world);
+        ecs_merge(world_);
     }
 
     /** Get stage-specific world pointer.
@@ -20333,7 +19426,7 @@ struct world {
      * @return A thread-specific pointer to the world.
      */
     flecs::world get_stage(int32_t stage_id) const {
-        return flecs::world(ecs_get_stage(m_world, stage_id));
+        return flecs::world(ecs_get_stage(world_, stage_id));
     }
 
     /** Create asynchronous stage.
@@ -20349,14 +19442,12 @@ struct world {
      * The application must ensure that no commands are added to the stage while the
      * stage is being merged.
      *
-     * An asynchronous stage must be cleaned up by ecs_async_stage_free.
-     *
      * @return The stage.
      */
     flecs::world async_stage() const {
-        auto result = flecs::world(ecs_async_stage_new(m_world));
-        result.m_owned = true;
-        return result;
+        ecs_world_t *as = ecs_stage_new(world_);
+        flecs_poly_release(as); // world object will claim
+        return flecs::world(as);
     }
 
     /** Get actual world.
@@ -20368,7 +19459,7 @@ struct world {
     flecs::world get_world() const {
         /* Safe cast, mutability is checked */
         return flecs::world(
-            m_world ? const_cast<flecs::world_t*>(ecs_get_world(m_world)) : nullptr);
+            world_ ? const_cast<flecs::world_t*>(ecs_get_world(world_)) : nullptr);
     }
 
     /** Test whether the current world object is readonly.
@@ -20378,7 +19469,7 @@ struct world {
      * @return True if the world or stage is readonly.
      */
     bool is_readonly() const {
-        return ecs_stage_is_readonly(m_world);
+        return ecs_stage_is_readonly(world_);
     }
 
     /** Set world context.
@@ -20388,7 +19479,7 @@ struct world {
      * @param ctx The world context.
      */
     void set_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
-        ecs_set_ctx(m_world, ctx, ctx_free);
+        ecs_set_ctx(world_, ctx, ctx_free);
     }
 
     /** Get world context.
@@ -20396,7 +19487,7 @@ struct world {
      * @return The configured world context.
      */
     void* get_ctx() const {
-        return ecs_get_ctx(m_world);
+        return ecs_get_ctx(world_);
     }
 
     /** Set world binding context.
@@ -20406,7 +19497,7 @@ struct world {
      * @param ctx The world context.
      */
     void set_binding_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
-        ecs_set_binding_ctx(m_world, ctx, ctx_free);
+        ecs_set_binding_ctx(world_, ctx, ctx_free);
     }
 
     /** Get world binding context.
@@ -20414,7 +19505,7 @@ struct world {
      * @return The configured world context.
      */
     void* get_binding_ctx() const {
-        return ecs_get_binding_ctx(m_world);
+        return ecs_get_binding_ctx(world_);
     }
 
     /** Preallocate memory for number of entities.
@@ -20423,7 +19514,7 @@ struct world {
      * @param entity_count Number of entities to preallocate memory for.
      */
     void dim(int32_t entity_count) const {
-        ecs_dim(m_world, entity_count);
+        ecs_dim(world_, entity_count);
     }
 
     /** Set entity range.
@@ -20433,7 +19524,7 @@ struct world {
      * @param max Maximum entity id issued.
      */
     void set_entity_range(entity_t min, entity_t max) const {
-        ecs_set_entity_range(m_world, min, max);
+        ecs_set_entity_range(world_, min, max);
     }
 
     /** Enforce that operations cannot modify entities outside of range.
@@ -20445,7 +19536,7 @@ struct world {
      * @param enabled True if range check should be enabled, false if not.
      */
     void enable_range_check(bool enabled) const {
-        ecs_enable_range_check(m_world, enabled);
+        ecs_enable_range_check(world_, enabled);
     }
 
     /** Set current scope.
@@ -20473,29 +19564,29 @@ struct world {
      *  @see ecs_set_lookup_path
      */
     flecs::entity_t* set_lookup_path(const flecs::entity_t *search_path) const {
-        return ecs_set_lookup_path(m_world, search_path);
+        return ecs_set_lookup_path(world_, search_path);
     }
 
     /** Lookup entity by name.
      *
      * @param name Entity name.
-     * @param search_path When false, only the current scope is searched.
+     * @param recursive When false, only the current scope is searched.
      * @result The entity if found, or 0 if not found.
      */
-    flecs::entity lookup(const char *name, bool search_path = true) const;
+    flecs::entity lookup(const char *name, const char *sep = "::", const char *root_sep = "::", bool recursive = true) const;
 
     /** Set singleton component.
      */
     template <typename T, if_t< !is_callable<T>::value > = 0>
     void set(const T& value) const {
-        flecs::set<T>(m_world, _::cpp_type<T>::id(m_world), value);
+        flecs::set<T>(world_, _::type<T>::id(world_), value);
     }
 
     /** Set singleton component.
      */
     template <typename T, if_t< !is_callable<T>::value > = 0>
     void set(T&& value) const {
-        flecs::set<T>(m_world, _::cpp_type<T>::id(m_world),
+        flecs::set<T>(world_, _::type<T>::id(world_),
             FLECS_FWD(value));
     }
 
@@ -20504,7 +19595,7 @@ struct world {
     template <typename First, typename Second, typename P = flecs::pair<First, Second>,
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     void set(const A& value) const {
-        flecs::set<P>(m_world, _::cpp_type<First>::id(m_world), value);
+        flecs::set<P>(world_, _::type<First>::id(world_), value);
     }
 
     /** Set singleton pair.
@@ -20512,7 +19603,7 @@ struct world {
     template <typename First, typename Second, typename P = flecs::pair<First, Second>,
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     void set(A&& value) const {
-        flecs::set<P>(m_world, _::cpp_type<First>::id(m_world), FLECS_FWD(value));
+        flecs::set<P>(world_, _::type<First>::id(world_), FLECS_FWD(value));
     }
 
     /** Set singleton pair.
@@ -20532,9 +19623,8 @@ struct world {
 
     template <typename T, typename ... Args>
     void emplace(Args&&... args) const {
-        flecs::id_t component_id = _::cpp_type<T>::id(m_world);
-        flecs::emplace<T>(m_world, component_id, component_id,
-            FLECS_FWD(args)...);
+        flecs::id_t component_id = _::type<T>::id(world_);
+        flecs::emplace<T>(world_, component_id, component_id, FLECS_FWD(args)...);
     }
 
     /** Ensure singleton component.
@@ -20750,7 +19840,7 @@ struct world {
      * @param component_id The component id.
      */
     int count(flecs::id_t component_id) const {
-        return ecs_count_id(m_world, component_id);
+        return ecs_count_id(world_, component_id);
     }
 
     /** Count entities matching a pair.
@@ -20759,7 +19849,7 @@ struct world {
      * @param second The second element of the pair.
      */
     int count(flecs::entity_t first, flecs::entity_t second) const {
-        return ecs_count_id(m_world, ecs_pair(first, second));
+        return ecs_count_id(world_, ecs_pair(first, second));
     }
 
     /** Count entities matching a component.
@@ -20768,7 +19858,7 @@ struct world {
      */
     template <typename T>
     int count() const {
-        return count(_::cpp_type<T>::id(m_world));
+        return count(_::type<T>::id(world_));
     }
 
     /** Count entities matching a pair.
@@ -20778,7 +19868,7 @@ struct world {
      */
     template <typename First>
     int count(flecs::entity_t second) const {
-        return count(_::cpp_type<First>::id(m_world), second);
+        return count(_::type<First>::id(world_), second);
     }
 
     /** Count entities matching a pair.
@@ -20789,17 +19879,17 @@ struct world {
     template <typename First, typename Second>
     int count() const {
         return count(
-            _::cpp_type<First>::id(m_world),
-            _::cpp_type<Second>::id(m_world));
+            _::type<First>::id(world_),
+            _::type<Second>::id(world_));
     }
 
     /** All entities created in function are created with id.
      */
     template <typename Func>
     void with(id_t with_id, const Func& func) const {
-        ecs_id_t prev = ecs_set_with(m_world, with_id);
+        ecs_id_t prev = ecs_set_with(world_, with_id);
         func();
-        ecs_set_with(m_world, prev);
+        ecs_set_with(world_, prev);
     }
 
     /** All entities created in function are created with type.
@@ -20835,16 +19925,16 @@ struct world {
      */
     template <typename Func>
     void scope(id_t parent, const Func& func) const {
-        ecs_entity_t prev = ecs_set_scope(m_world, parent);
+        ecs_entity_t prev = ecs_set_scope(world_, parent);
         func();
-        ecs_set_scope(m_world, prev);
+        ecs_set_scope(world_, prev);
     }
 
     /** Same as scope(parent, func), but with T as parent.
      */
     template <typename T, typename Func>
     void scope(const Func& func) const {
-        flecs::id_t parent = _::cpp_type<T>::id(m_world);
+        flecs::id_t parent = _::type<T>::id(world_);
         scope(parent, func);
     }
 
@@ -20860,7 +19950,7 @@ struct world {
 
     /** Delete all entities with specified id. */
     void delete_with(id_t the_id) const {
-        ecs_delete_with(m_world, the_id);
+        ecs_delete_with(world_, the_id);
     }
 
     /** Delete all entities with specified pair. */
@@ -20871,24 +19961,24 @@ struct world {
     /** Delete all entities with specified component. */
     template <typename T>
     void delete_with() const {
-        delete_with(_::cpp_type<T>::id(m_world));
+        delete_with(_::type<T>::id(world_));
     }
 
     /** Delete all entities with specified pair. */
     template <typename First, typename Second>
     void delete_with() const {
-        delete_with(_::cpp_type<First>::id(m_world), _::cpp_type<Second>::id(m_world));
+        delete_with(_::type<First>::id(world_), _::type<Second>::id(world_));
     }
 
     /** Delete all entities with specified pair. */
     template <typename First>
     void delete_with(entity_t second) const {
-        delete_with(_::cpp_type<First>::id(m_world), second);
+        delete_with(_::type<First>::id(world_), second);
     }
 
     /** Remove all instances of specified id. */
     void remove_all(id_t the_id) const {
-        ecs_remove_all(m_world, the_id);
+        ecs_remove_all(world_, the_id);
     }
 
     /** Remove all instances of specified pair. */
@@ -20899,19 +19989,19 @@ struct world {
     /** Remove all instances of specified component. */
     template <typename T>
     void remove_all() const {
-        remove_all(_::cpp_type<T>::id(m_world));
+        remove_all(_::type<T>::id(world_));
     }
 
     /** Remove all instances of specified pair. */
     template <typename First, typename Second>
     void remove_all() const {
-        remove_all(_::cpp_type<First>::id(m_world), _::cpp_type<Second>::id(m_world));
+        remove_all(_::type<First>::id(world_), _::type<Second>::id(world_));
     }
 
     /** Remove all instances of specified pair. */
     template <typename First>
     void remove_all(entity_t second) const {
-        remove_all(_::cpp_type<First>::id(m_world), second);
+        remove_all(_::type<First>::id(world_), second);
     }
 
     /** Defer all operations called in function. If the world is already in
@@ -20919,9 +20009,9 @@ struct world {
      */
     template <typename Func>
     void defer(const Func& func) const {
-        ecs_defer_begin(m_world);
+        ecs_defer_begin(world_);
         func();
-        ecs_defer_end(m_world);
+        ecs_defer_end(world_);
     }
 
     /** Suspend deferring operations.
@@ -20929,7 +20019,7 @@ struct world {
      * @see ecs_defer_suspend
      */
     void defer_suspend() const {
-        ecs_defer_suspend(m_world);
+        ecs_defer_suspend(world_);
     }
 
     /** Resume deferring operations.
@@ -20937,7 +20027,7 @@ struct world {
      * @see ecs_defer_suspend
      */
     void defer_resume() const {
-        ecs_defer_resume(m_world);
+        ecs_defer_resume(world_);
     }
 
     /** Check if entity id exists in the world.
@@ -20945,7 +20035,7 @@ struct world {
      * @see ecs_exists
      */
     bool exists(flecs::entity_t e) const {
-        return ecs_exists(m_world, e);
+        return ecs_exists(world_, e);
     }
 
     /** Check if entity id exists in the world.
@@ -20953,7 +20043,7 @@ struct world {
      * @see ecs_is_alive
      */
     bool is_alive(flecs::entity_t e) const {
-        return ecs_is_alive(m_world, e);
+        return ecs_is_alive(world_, e);
     }
 
     /** Check if entity id is valid.
@@ -20962,7 +20052,7 @@ struct world {
      * @see ecs_is_valid
      */
     bool is_valid(flecs::entity_t e) const {
-        return ecs_is_valid(m_world, e);
+        return ecs_is_valid(world_, e);
     }
 
     /** Get alive entity for id.
@@ -20976,14 +20066,14 @@ struct world {
 
     /* Run callback after completing frame */
     void run_post_frame(ecs_fini_action_t action, void *ctx) const {
-        ecs_run_post_frame(m_world, action, ctx);
+        ecs_run_post_frame(world_, action, ctx);
     }
 
     /** Get the world info.
      * @see ecs_get_world_info
      */
     const flecs::world_info_t* get_info() const{
-        return ecs_get_world_info(m_world);
+        return ecs_get_world_info(world_);
     }
 
     /** Get delta_time */
@@ -21146,7 +20236,7 @@ flecs::event_builder_typed<E> event() const;
 
 /**
  * @memberof flecs::world
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  *
  * @{
  */
@@ -21169,72 +20259,6 @@ flecs::term term() const;
 
 /** @} */
 
-/**
- * @file addons/cpp/mixins/filter/mixin.inl
- * @brief Filter world mixin.
- */
-
-/**
- * @memberof flecs::world
- * @ingroup cpp_core_filters
- *
- * @{
- */
-
-/** Create a filter.
- * 
- * @see ecs_filter_init
- */
-template <typename... Comps, typename... Args>
-flecs::filter<Comps...> filter(Args &&... args) const;
-
-/** Create a filter builder.
- * 
- * @see ecs_filter_init
- */
-template <typename... Comps, typename... Args>
-flecs::filter_builder<Comps...> filter_builder(Args &&... args) const;
-
-/** Iterate over all entities with components in argument list of function.
- * The function parameter must match the following signature:
- *
- * @code
- * void(*)(T&, U&, ...)
- * @endcode
- *
- * or:
- *
- * @code
- * void(*)(flecs::entity, T&, U&, ...)
- * @endcode
- * 
- */
-template <typename Func>
-void each(Func&& func) const;
-
-/** Iterate over all entities with provided component.
- * The function parameter must match the following signature:
- *
- * @code
- * void(*)(T&)
- * @endcode
- *
- * or:
- *
- * @code
- * void(*)(flecs::entity, T&)
- * @endcode
- * 
- */
-template <typename T, typename Func>
-void each(Func&& func) const;
-
-/** Iterate over all entities with provided (component) id. */
-template <typename Func>
-void each(flecs::id_t term_id, Func&& func) const;
-
-/** @} */
-
 /**
  * @file addons/cpp/mixins/observer/mixin.inl
  * @brief Observer world mixin.
@@ -21280,23 +20304,63 @@ flecs::observer_builder<Components...> observer(Args &&... args) const;
  */
 
 /** Create a query.
+ * 
  * @see ecs_query_init
  */
 template <typename... Comps, typename... Args>
 flecs::query<Comps...> query(Args &&... args) const;
 
-/** Create a subquery.
+/** Create a query from entity.
+ * 
  * @see ecs_query_init
  */
-template <typename... Comps, typename... Args>
-flecs::query<Comps...> query(flecs::query_base& parent, Args &&... args) const;
+flecs::query<> query(flecs::entity query_entity) const;
 
 /** Create a query builder.
+ * 
  * @see ecs_query_init
  */
 template <typename... Comps, typename... Args>
 flecs::query_builder<Comps...> query_builder(Args &&... args) const;
 
+/** Iterate over all entities with components in argument list of function.
+ * The function parameter must match the following signature:
+ *
+ * @code
+ * void(*)(T&, U&, ...)
+ * @endcode
+ *
+ * or:
+ *
+ * @code
+ * void(*)(flecs::entity, T&, U&, ...)
+ * @endcode
+ * 
+ */
+template <typename Func>
+void each(Func&& func) const;
+
+/** Iterate over all entities with provided component.
+ * The function parameter must match the following signature:
+ *
+ * @code
+ * void(*)(T&)
+ * @endcode
+ *
+ * or:
+ *
+ * @code
+ * void(*)(flecs::entity, T&)
+ * @endcode
+ * 
+ */
+template <typename T, typename Func>
+void each(Func&& func) const;
+
+/** Iterate over all entities with provided (component) id. */
+template <typename Func>
+void each(flecs::id_t term_id, Func&& func) const;
+
 /** @} */
 
 /**
@@ -21427,41 +20491,20 @@ void reset_clock() const;
  */
 void set_threads(int32_t threads) const;
 
-/** Set number of threads.
- * @see ecs_get_stage_count
- */
-int32_t get_threads() const;
-
-/** Set number of task threads.
- * @see ecs_set_task_threads
- */
-void set_task_threads(int32_t task_threads) const;
-
-/** Returns true if task thread use has been requested.
- * @see ecs_using_task_threads
- */
-bool using_task_threads() const;
-
-/** @} */
-
-#   endif
-#   ifdef FLECS_SNAPSHOT
-/**
- * @file addons/cpp/mixins/snapshot/mixin.inl
- * @brief Snapshot world mixin.
+/** Set number of threads.
+ * @see ecs_get_stage_count
  */
+int32_t get_threads() const;
 
-/**
- * @memberof flecs::world
- * @ingroup cpp_addons_snapshots
- *
- * @{
+/** Set number of task threads.
+ * @see ecs_set_task_threads
  */
+void set_task_threads(int32_t task_threads) const;
 
-/** Create a snapshot.
+/** Returns true if task thread use has been requested.
+ * @see ecs_using_task_threads
  */
-template <typename... Args>
-flecs::snapshot snapshot(Args &&... args) const;
+bool using_task_threads() const;
 
 /** @} */
 
@@ -21524,68 +20567,48 @@ flecs::timer timer(Args &&... args) const;
 void randomize_timers() const;
 
 #   endif
-#   ifdef FLECS_RULES
-/**
- * @file addons/cpp/mixins/rule/mixin.inl
- * @brief Rule world mixin.
- */
-
-/**
- * @memberof flecs::world
- * @ingroup cpp_addons_rules
- *
- * @{
- */
-
-/** Create a rule.
- * @see ecs_rule_init
- */
-template <typename... Comps, typename... Args>
-flecs::rule<Comps...> rule(Args &&... args) const;
-
-/** Create a subrule.
- * @see ecs_rule_init
- */
-template <typename... Comps, typename... Args>
-flecs::rule<Comps...> rule(flecs::rule_base& parent, Args &&... args) const;
-
-/** Create a rule builder.
- * @see ecs_rule_init
- */
-template <typename... Comps, typename... Args>
-flecs::rule_builder<Comps...> rule_builder(Args &&... args) const;
-
-/** @} */
-
-#   endif
-#   ifdef FLECS_PLECS
+#   ifdef FLECS_SCRIPT
 /**
- * @file addons/cpp/mixins/plecs/mixin.inl
- * @brief Plecs world mixin.
+ * @file addons/cpp/mixins/script/mixin.inl
+ * @brief Script world mixin.
  */
 
 /**
- * @defgroup cpp_addons_plecs Plecs
+ * @defgroup cpp_addons_script Script
  * @ingroup cpp_addons
  * Data definition format for loading entity data.
  *
  * @{
  */
 
-/** Load plecs string.
- * @see ecs_plecs_from_str
+/** Run script.
+ * @see ecs_script_run
  */
-int plecs_from_str(const char *name, const char *str) const {
-    return ecs_plecs_from_str(m_world, name, str);
+int script_run(const char *name, const char *str) const {
+    return ecs_script_run(world_, name, str);
 }
 
-/** Load plecs from file.
- * @see ecs_plecs_from_file
+/** Run script from file.
+ * @see ecs_script_run_file
  */
-int plecs_from_file(const char *filename) const {
-    return ecs_plecs_from_file(m_world, filename);
+int script_run_file(const char *filename) const {
+    return ecs_script_run_file(world_, filename);
+}
+
+/** Convert value to string */
+flecs::string to_expr(flecs::entity_t tid, const void* value) {
+    char *expr = ecs_ptr_to_expr(world_, tid, value);
+    return flecs::string(expr);
 }
 
+/** Convert value to string */
+template <typename T>
+flecs::string to_expr(const T* value) {
+    flecs::entity_t tid = _::type<T>::id(world_);
+    return to_expr(tid, value);
+}
+
+
 /** @} */
 
 #   endif
@@ -21602,28 +20625,15 @@ int plecs_from_file(const char *filename) const {
  * @{
  */
 
-/** Convert value to string */
-flecs::string to_expr(flecs::entity_t tid, const void* value) {
-    char *expr = ecs_ptr_to_expr(m_world, tid, value);
-    return flecs::string(expr);
-}
-
-/** Convert value to string */
-template <typename T>
-flecs::string to_expr(const T* value) {
-    flecs::entity_t tid = _::cpp_type<T>::id(m_world);
-    return to_expr(tid, value);
-}
-
 /** Return meta cursor to value */
 flecs::cursor cursor(flecs::entity_t tid, void *ptr) {
-    return flecs::cursor(m_world, tid, ptr);
+    return flecs::cursor(world_, tid, ptr);
 }
 
 /** Return meta cursor to value */
 template <typename T>
 flecs::cursor cursor(void *ptr) {
-    flecs::entity_t tid = _::cpp_type<T>::id(m_world);
+    flecs::entity_t tid = _::type<T>::id(world_);
     return cursor(tid, ptr);
 }
 
@@ -21659,7 +20669,7 @@ flecs::entity vector();
  * @ingroup cpp_addons_json
  */
 flecs::string to_json(flecs::entity_t tid, const void* value) {
-    char *json = ecs_ptr_to_json(m_world, tid, value);
+    char *json = ecs_ptr_to_json(world_, tid, value);
     return flecs::string(json);
 }
 
@@ -21670,7 +20680,7 @@ flecs::string to_json(flecs::entity_t tid, const void* value) {
  */
 template <typename T>
 flecs::string to_json(const T* value) {
-    flecs::entity_t tid = _::cpp_type<T>::id(m_world);
+    flecs::entity_t tid = _::type<T>::id(world_);
     return to_json(tid, value);
 }
 
@@ -21680,7 +20690,7 @@ flecs::string to_json(const T* value) {
  * @ingroup cpp_addons_json
  */
 flecs::string to_json() {
-    return flecs::string( ecs_world_to_json(m_world, nullptr) );
+    return flecs::string( ecs_world_to_json(world_, nullptr) );
 }
 
 /** Deserialize value from JSON.
@@ -21689,7 +20699,7 @@ flecs::string to_json() {
  * @ingroup cpp_addons_json
  */
 const char* from_json(flecs::entity_t tid, void* value, const char *json, flecs::from_json_desc_t *desc = nullptr) {
-    return ecs_ptr_from_json(m_world, tid, value, json, desc);
+    return ecs_ptr_from_json(world_, tid, value, json, desc);
 }
 
 /** Deserialize value from JSON.
@@ -21699,7 +20709,7 @@ const char* from_json(flecs::entity_t tid, void* value, const char *json, flecs:
  */
 template <typename T>
 const char* from_json(T* value, const char *json, flecs::from_json_desc_t *desc = nullptr) {
-    return ecs_ptr_from_json(m_world, _::cpp_type<T>::id(m_world),
+    return ecs_ptr_from_json(world_, _::type<T>::id(world_),
         value, json, desc);
 }
 
@@ -21709,7 +20719,7 @@ const char* from_json(T* value, const char *json, flecs::from_json_desc_t *desc
  * @ingroup cpp_addons_json
  */
 const char* from_json(const char *json, flecs::from_json_desc_t *desc = nullptr) {
-    return ecs_world_from_json(m_world, json, desc);
+    return ecs_world_from_json(world_, json, desc);
 }
 
 /** Deserialize JSON file into world.
@@ -21718,7 +20728,7 @@ const char* from_json(const char *json, flecs::from_json_desc_t *desc = nullptr)
  * @ingroup cpp_addons_json
  */
 const char* from_json_file(const char *json, flecs::from_json_desc_t *desc = nullptr) {
-    return ecs_world_from_json_file(m_world, json, desc);
+    return ecs_world_from_json_file(world_, json, desc);
 }
 
 #   endif
@@ -21742,8 +20752,9 @@ const char* from_json_file(const char *json, flecs::from_json_desc_t *desc = nul
  * required for frameworks like emscripten.
  */
 flecs::app_builder app() {
-    m_owned = false; // App takes ownership of world
-    return flecs::app_builder(m_world);
+    flecs::world_t *w = world_;
+    world_ = nullptr; // Take ownership
+    return flecs::app_builder(w);
 }
 
 /** @} */
@@ -21775,8 +20786,7 @@ flecs::alert_builder<Comps...> alert(Args &&... args) const;
 public:
     void init_builtin_components();
 
-    world_t *m_world;
-    bool m_owned;
+    world_t *world_;
 };
 
 /** Scoped world.
@@ -21785,24 +20795,22 @@ flecs::alert_builder<Comps...> alert(Args &&... args) const;
 struct scoped_world : world {
     scoped_world(
         flecs::world_t *w,
-        flecs::entity_t s) : world(nullptr)
+        flecs::entity_t s) : world(w)
     {
-        m_prev_scope = ecs_set_scope(w, s);
-        m_world = w;
-        m_owned = false;
+        prev_scope_ = ecs_set_scope(w, s);
     }
 
     ~scoped_world() {
-        ecs_set_scope(m_world, m_prev_scope);
+        ecs_set_scope(world_, prev_scope_);
     }
 
     scoped_world(const scoped_world& obj) : world(nullptr) {
-        m_prev_scope = obj.m_prev_scope;
-        m_world = obj.m_world;
-        m_owned = obj.m_owned;
+        prev_scope_ = obj.prev_scope_;
+        world_ = obj.world_;
+        flecs_poly_claim(world_);
     }
 
-    flecs::entity_t m_prev_scope;
+    flecs::entity_t prev_scope_;
 };
 
 /** @} */
@@ -21836,10 +20844,10 @@ namespace flecs
  */
 struct untyped_field {
     untyped_field(void* array, size_t size, size_t count, bool is_shared = false)
-        : m_data(array)
-        , m_size(size)
-        , m_count(count)
-        , m_is_shared(is_shared) {}
+        : data_(array)
+        , size_(size)
+        , count_(count)
+        , is_shared_(is_shared) {}
 
     /** Return element in component array.
      * This operator may only be used if the field is not shared.
@@ -21848,18 +20856,18 @@ struct untyped_field {
      * @return Reference to element.
      */
     void* operator[](size_t index) const {
-        ecs_assert(!m_is_shared, ECS_INVALID_PARAMETER,
+        ecs_assert(!is_shared_, ECS_INVALID_PARAMETER,
             "invalid usage of [] operator for shared component field");
-        ecs_assert(index < m_count, ECS_COLUMN_INDEX_OUT_OF_RANGE,
+        ecs_assert(index < count_, ECS_COLUMN_INDEX_OUT_OF_RANGE,
             "index %d out of range for field", index);
-        return ECS_OFFSET(m_data, m_size * index);
+        return ECS_OFFSET(data_, size_ * index);
     }
 
 protected:
-    void* m_data;
-    size_t m_size;
-    size_t m_count;
-    bool m_is_shared;
+    void* data_;
+    size_t size_;
+    size_t count_;
+    bool is_shared_;
 };
 
 /** Wrapper class around a field.
@@ -21880,9 +20888,9 @@ struct field {
      * @param is_shared Is the component shared or not.
      */
     field(T* array, size_t count, bool is_shared = false)
-        : m_data(array)
-        , m_count(count)
-        , m_is_shared(is_shared) {}
+        : data_(array)
+        , count_(count)
+        , is_shared_(is_shared) {}
 
     /** Create field from iterator.
      *
@@ -21914,9 +20922,9 @@ struct field {
     T* operator->() const;
 
 protected:
-    T* m_data;
-    size_t m_count;
-    bool m_is_shared;
+    T* data_;
+    size_t count_;
+    bool is_shared_;
 };
 
 }
@@ -21953,26 +20961,26 @@ template <typename T>
 struct range_iterator
 {
     explicit range_iterator(T value)
-        : m_value(value){}
+        : value_(value){}
 
     bool operator!=(range_iterator const& other) const
     {
-        return m_value != other.m_value;
+        return value_ != other.value_;
     }
 
     T const& operator*() const
     {
-        return m_value;
+        return value_;
     }
 
     range_iterator& operator++()
     {
-        ++m_value;
+        ++value_;
         return *this;
     }
 
 private:
-    T m_value;
+    T value_;
 };
 
 } // namespace _
@@ -21998,17 +21006,17 @@ struct iter {
      *
      * @param it Pointer to C iterator.
      */
-    iter(ecs_iter_t *it) : m_iter(it) {
-        m_begin = 0;
-        m_end = static_cast<std::size_t>(it->count);
+    iter(ecs_iter_t *it) : iter_(it) {
+        begin_ = 0;
+        end_ = static_cast<std::size_t>(it->count);
     }
 
     row_iterator begin() const {
-        return row_iterator(m_begin);
+        return row_iterator(begin_);
     }
 
     row_iterator end() const {
-        return row_iterator(m_end);
+        return row_iterator(end_);
     }
 
     flecs::entity system() const;
@@ -22020,19 +21028,19 @@ struct iter {
     flecs::world world() const;
 
     const flecs::iter_t* c_ptr() const {
-        return m_iter;
+        return iter_;
     }
 
     size_t count() const {
-        return static_cast<size_t>(m_iter->count);
+        return static_cast<size_t>(iter_->count);
     }
 
     ecs_ftime_t delta_time() const {
-        return m_iter->delta_time;
+        return iter_->delta_time;
     }
 
     ecs_ftime_t delta_system_time() const {
-        return m_iter->delta_system_time;
+        return iter_->delta_system_time;
     }
 
     flecs::type type() const;
@@ -22045,7 +21053,7 @@ struct iter {
      * ctx contains the context pointer assigned to a system.
      */
     void* ctx() {
-        return m_iter->ctx;
+        return iter_->ctx;
     }
 
     /** Access ctx.
@@ -22053,14 +21061,14 @@ struct iter {
      */
     template <typename T>
     T* ctx() {
-        return static_cast<T*>(m_iter->ctx);
+        return static_cast<T*>(iter_->ctx);
     }
 
     /** Access param.
      * param contains the pointer passed to the param argument of system::run
      */
     void* param() {
-        return m_iter->param;
+        return iter_->param;
     }
 
     /** Access param.
@@ -22069,7 +21077,7 @@ struct iter {
     template <typename T>
     T* param() {
         /* TODO: type check */
-        return static_cast<T*>(m_iter->param);
+        return static_cast<T*>(iter_->param);
     }
 
     /** Obtain mutable handle to entity being iterated over.
@@ -22083,7 +21091,7 @@ struct iter {
      * @param index The field index.
      */
     bool is_self(int32_t index) const {
-        return ecs_field_is_self(m_iter, index);
+        return ecs_field_is_self(iter_, index);
     }
 
     /** Returns whether field is set.
@@ -22091,7 +21099,7 @@ struct iter {
      * @param index The field index.
      */
     bool is_set(int32_t index) const {
-        return ecs_field_is_set(m_iter, index);
+        return ecs_field_is_set(iter_, index);
     }
 
     /** Returns whether field is readonly.
@@ -22099,13 +21107,13 @@ struct iter {
      * @param index The field index.
      */
     bool is_readonly(int32_t index) const {
-        return ecs_field_is_readonly(m_iter, index);
+        return ecs_field_is_readonly(iter_, index);
     }
 
     /** Number of fields in iterator.
      */
     int32_t field_count() const {
-        return m_iter->field_count;
+        return iter_->field_count;
     }
 
     /** Size of field data type.
@@ -22113,7 +21121,7 @@ struct iter {
      * @param index The field id.
      */
     size_t size(int32_t index) const {
-        return ecs_field_size(m_iter, index);
+        return ecs_field_size(iter_, index);
     }
 
     /** Obtain field source (0 if This).
@@ -22140,13 +21148,13 @@ struct iter {
      * @param index The field index.
      */
     int32_t column_index(int32_t index) const {
-        return ecs_field_column_index(m_iter, index);
+        return ecs_field_column(iter_, index);
     }
 
     /** Convert current iterator result to string.
      */
     flecs::string str() const {
-        char *s = ecs_iter_str(m_iter);
+        char *s = ecs_iter_str(iter_);
         return flecs::string(s);
     }
 
@@ -22182,7 +21190,7 @@ struct iter {
      * @param index The field index.
      */
     flecs::untyped_field field(int32_t index) const {
-        ecs_assert(!(m_iter->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
+        ecs_assert(!(iter_->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
             "cannot .field from .each, use .field_at(%d, row) instead", index);
         return get_unchecked_field(index);
     }
@@ -22204,7 +21212,7 @@ struct iter {
         typename std::enable_if<
             std::is_const<T>::value == false, void>::type* = nullptr>
     A& field_at(int32_t index, size_t row) const {
-        ecs_assert(!ecs_field_is_readonly(m_iter, index),
+        ecs_assert(!ecs_field_is_readonly(iter_, index),
             ECS_ACCESS_VIOLATION, NULL);
         return get_field<A>(index)[row];
     }
@@ -22214,18 +21222,13 @@ struct iter {
      * @return The entity ids.
      */
     flecs::field<const flecs::entity_t> entities() const {
-        return flecs::field<const flecs::entity_t>(m_iter->entities, static_cast<size_t>(m_iter->count), false);
-    }
-
-    /** Obtain the total number of tables the iterator will iterate over. */
-    int32_t table_count() const {
-        return m_iter->table_count;
+        return flecs::field<const flecs::entity_t>(iter_->entities, static_cast<size_t>(iter_->count), false);
     }
 
     /** Check if the current table has changed since the last iteration.
      * Can only be used when iterating queries and/or systems. */
     bool changed() {
-        return ecs_query_changed(nullptr, m_iter);
+        return ecs_iter_changed(iter_);
     }
 
     /** Skip current table.
@@ -22236,12 +21239,12 @@ struct iter {
      * When this operation is invoked, the components of the current table will
      * not be marked dirty. */
     void skip() {
-        ecs_query_skip(m_iter);
+        ecs_iter_skip(iter_);
     }
 
     /* Return group id for current table (grouped queries only) */
     uint64_t group_id() const {
-        return m_iter->group_id;
+        return iter_->group_id;
     }
 
 #ifdef FLECS_RULES
@@ -22262,14 +21265,14 @@ struct iter {
     flecs::field<T> get_field(int32_t index) const {
 
 #ifndef FLECS_NDEBUG
-        ecs_entity_t term_id = ecs_field_id(m_iter, index);
+        ecs_entity_t term_id = ecs_field_id(iter_, index);
         ecs_assert(ECS_HAS_ID_FLAG(term_id, PAIR) ||
-            term_id == _::cpp_type<T>::id(m_iter->world),
+            term_id == _::type<T>::id(iter_->world),
             ECS_COLUMN_TYPE_MISMATCH, NULL);
 #endif
 
         size_t count;
-        bool is_shared = !ecs_field_is_self(m_iter, index);
+        bool is_shared = !ecs_field_is_self(iter_, index);
 
         /* If a shared column is retrieved with 'column', there will only be a
          * single value. Ensure that the application does not accidentally read
@@ -22279,18 +21282,18 @@ struct iter {
         } else {
             /* If column is owned, there will be as many values as there are
              * entities. */
-            count = static_cast<size_t>(m_iter->count);
+            count = static_cast<size_t>(iter_->count);
         }
 
         return flecs::field<A>(
-            static_cast<T*>(ecs_field_w_size(m_iter, sizeof(A), index)),
+            static_cast<T*>(ecs_field_w_size(iter_, sizeof(A), index)),
             count, is_shared);
     }
 
     flecs::untyped_field get_unchecked_field(int32_t index) const {
         size_t count;
-        size_t size = ecs_field_size(m_iter, index);
-        bool is_shared = !ecs_field_is_self(m_iter, index);
+        size_t size = ecs_field_size(iter_, index);
+        bool is_shared = !ecs_field_is_self(iter_, index);
 
         /* If a shared column is retrieved with 'column', there will only be a
          * single value. Ensure that the application does not accidentally read
@@ -22300,16 +21303,16 @@ struct iter {
         } else {
             /* If column is owned, there will be as many values as there are
              * entities. */
-            count = static_cast<size_t>(m_iter->count);
+            count = static_cast<size_t>(iter_->count);
         }
 
         return flecs::untyped_field(
-            ecs_field_w_size(m_iter, 0, index), size, count, is_shared);
+            ecs_field_w_size(iter_, 0, index), size, count, is_shared);
     }
 
-    flecs::iter_t *m_iter;
-    std::size_t m_begin;
-    std::size_t m_end;
+    flecs::iter_t *iter_;
+    std::size_t begin_;
+    std::size_t end_;
 };
 
 } // namespace flecs
@@ -22375,7 +21378,7 @@ struct entity_view : public id {
      * @return The integer entity id.
      */
     entity_t id() const {
-        return m_id;
+        return id_;
     }
 
     /** Check if entity is valid.
@@ -22383,7 +21386,7 @@ struct entity_view : public id {
      * @return True if the entity is alive, false otherwise.
      */
     bool is_valid() const {
-        return m_world && ecs_is_valid(m_world, m_id);
+        return world_ && ecs_is_valid(world_, id_);
     }
   
     explicit operator bool() const {
@@ -22395,7 +21398,7 @@ struct entity_view : public id {
      * @return True if the entity is alive, false otherwise.
      */
     bool is_alive() const {
-        return m_world && ecs_is_alive(m_world, m_id);
+        return world_ && ecs_is_alive(world_, id_);
     }
 
     /** Return the entity name.
@@ -22403,7 +21406,7 @@ struct entity_view : public id {
      * @return The entity name.
      */
     flecs::string_view name() const {
-        return flecs::string_view(ecs_get_name(m_world, m_id));
+        return flecs::string_view(ecs_get_name(world_, id_));
     }
 
     /** Return the entity symbol.
@@ -22411,7 +21414,7 @@ struct entity_view : public id {
      * @return The entity symbol.
      */
     flecs::string_view symbol() const {
-        return flecs::string_view(ecs_get_symbol(m_world, m_id));
+        return flecs::string_view(ecs_get_symbol(world_, id_));
     }
 
     /** Return the entity path.
@@ -22427,7 +21430,7 @@ struct entity_view : public id {
      * @return The relative hierarchical entity path.
      */
     flecs::string path_from(flecs::entity_t parent, const char *sep = "::", const char *init_sep = "::") const {
-        char *path = ecs_get_path_w_sep(m_world, parent, m_id, sep, init_sep);
+        char *path = ecs_get_path_w_sep(world_, parent, id_, sep, init_sep);
         return flecs::string(path);
     }
 
@@ -22437,11 +21440,11 @@ struct entity_view : public id {
      */
     template <typename Parent>
     flecs::string path_from(const char *sep = "::", const char *init_sep = "::") const {
-        return path_from(_::cpp_type<Parent>::id(m_world), sep, init_sep);
+        return path_from(_::type<Parent>::id(world_), sep, init_sep);
     }
 
     bool enabled() const {
-        return !ecs_has_id(m_world, m_id, flecs::Disabled);
+        return !ecs_has_id(world_, id_, flecs::Disabled);
     }
 
     /** Get the entity's type.
@@ -22514,7 +21517,7 @@ struct entity_view : public id {
      */
     template <typename First, typename Func>
     void each(const Func& func) const { 
-        return each(_::cpp_type<First>::id(m_world), func);
+        return each(_::type<First>::id(world_), func);
     }
 
     /** Iterate children for entity.
@@ -22532,13 +21535,15 @@ struct entity_view : public id {
         /* When the entity is a wildcard, this would attempt to query for all
          * entities with (ChildOf, *) or (ChildOf, _) instead of querying for
          * the children of the wildcard entity. */
-        if (m_id == flecs::Wildcard || m_id == flecs::Any) {
+        if (id_ == flecs::Wildcard || id_ == flecs::Any) {
             /* This is correct, wildcard entities don't have children */
             return;
         }
 
-        ecs_iter_t it = flecs_children(m_world, rel, m_id);
-        while (ecs_children_next(&it)) {
+        flecs::world world(world_);
+
+        ecs_iter_t it = ecs_each_id(world_, ecs_pair(rel, id_));
+        while (ecs_each_next(&it)) {
             _::each_delegate<Func>(FLECS_MOV(func)).invoke(&it);
         }
     }
@@ -22555,7 +21560,7 @@ struct entity_view : public id {
      */
     template <typename Rel, typename Func>
     void children(Func&& func) const {
-        children(_::cpp_type<Rel>::id(m_world), FLECS_MOV(func));
+        children(_::type<Rel>::id(world_), FLECS_MOV(func));
     }
 
     /** Iterate children for entity.
@@ -22582,9 +21587,10 @@ struct entity_view : public id {
      */
     template <typename T, if_t< is_actual<T>::value > = 0>
     const T* get() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return static_cast<const T*>(ecs_get_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return static_cast<const T*>(ecs_get_id(world_, id_, comp_id));
     }
 
     /** Get component value.
@@ -22598,9 +21604,10 @@ struct entity_view : public id {
     template <typename T, typename A = actual_type_t<T>, 
         if_t< flecs::is_pair<T>::value > = 0>
     const A* get() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<A>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return static_cast<const A*>(ecs_get_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<A>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return static_cast<const A*>(ecs_get_id(world_, id_, comp_id));
     }
 
     /** Get a pair.
@@ -22623,10 +21630,11 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_not_t< is_enum<Second>::value> = 0>
     const First* get(Second second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
-        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto comp_id = _::type<First>::id(world_);
+        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         return static_cast<const First*>(
-            ecs_get_id(m_world, m_id, ecs_pair(comp_id, second)));
+            ecs_get_id(world_, id_, ecs_pair(comp_id, second)));
     }
 
     /** Get a pair.
@@ -22637,7 +21645,7 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_t<is_enum<Second>::value> = 0>
     const First* get(Second constant) const {
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         flecs::entity_t target = et.entity(constant);
         return get<First>(target);
     }
@@ -22649,7 +21657,7 @@ struct entity_view : public id {
      *         have the component.
      */
     const void* get(flecs::id_t comp) const {
-        return ecs_get_id(m_world, m_id, comp);
+        return ecs_get_id(world_, id_, comp);
     }
 
     /** Get a pair (untyped).
@@ -22661,7 +21669,7 @@ struct entity_view : public id {
      * @param second The second element of the pair.
      */
     const void* get(flecs::entity_t first, flecs::entity_t second) const {
-        return ecs_get_id(m_world, m_id, ecs_pair(first, second));
+        return ecs_get_id(world_, id_, ecs_pair(first, second));
     }
 
     /** Get 1..N components.
@@ -22718,10 +21726,11 @@ struct entity_view : public id {
      */
     template<typename Second>
     const Second* get_second(flecs::entity_t first) const {
-        auto second = _::cpp_type<Second>::id(m_world);
-        ecs_assert(_::cpp_type<Second>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto second = _::type<Second>::id(world_);
+        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         return static_cast<const Second*>(
-            ecs_get_id(m_world, m_id, ecs_pair(first, second)));
+            ecs_get_id(world_, id_, ecs_pair(first, second)));
     }
 
     /** Get the second part for a pair.
@@ -22744,9 +21753,10 @@ struct entity_view : public id {
      */
     template <typename T, if_t< is_actual<T>::value > = 0>
     T* get_mut() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return static_cast<T*>(ecs_get_mut_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return static_cast<T*>(ecs_get_mut_id(world_, id_, comp_id));
     }
 
     /** Get mutable component value.
@@ -22760,9 +21770,10 @@ struct entity_view : public id {
     template <typename T, typename A = actual_type_t<T>, 
         if_t< flecs::is_pair<T>::value > = 0>
     A* get_mut() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<A>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return static_cast<A*>(ecs_get_mut_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<A>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return static_cast<A*>(ecs_get_mut_id(world_, id_, comp_id));
     }
 
     /** Get a mutable pair.
@@ -22785,10 +21796,11 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_not_t< is_enum<Second>::value> = 0>
     First* get_mut(Second second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
-        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto comp_id = _::type<First>::id(world_);
+        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER, 
+            "operation invalid for empty type");
         return static_cast<First*>(
-            ecs_get_mut_id(m_world, m_id, ecs_pair(comp_id, second)));
+            ecs_get_mut_id(world_, id_, ecs_pair(comp_id, second)));
     }
 
     /** Get a mutable pair.
@@ -22799,7 +21811,7 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_t<is_enum<Second>::value> = 0>
     First* get_mut(Second constant) const {
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         flecs::entity_t target = et.entity(constant);
         return get_mut<First>(target);
     }
@@ -22811,7 +21823,7 @@ struct entity_view : public id {
      *         have the component.
      */
     void* get_mut(flecs::id_t comp) const {
-        return ecs_get_mut_id(m_world, m_id, comp);
+        return ecs_get_mut_id(world_, id_, comp);
     }
 
     /** Get a mutable pair (untyped).
@@ -22823,7 +21835,7 @@ struct entity_view : public id {
      * @param second The second element of the pair.
      */
     void* get_mut(flecs::entity_t first, flecs::entity_t second) const {
-        return ecs_get_mut_id(m_world, m_id, ecs_pair(first, second));
+        return ecs_get_mut_id(world_, id_, ecs_pair(first, second));
     }
 
     /** Get the second part for a pair.
@@ -22835,10 +21847,11 @@ struct entity_view : public id {
      */
     template<typename Second>
     Second* get_mut_second(flecs::entity_t first) const {
-        auto second = _::cpp_type<Second>::id(m_world);
-        ecs_assert(_::cpp_type<Second>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto second = _::type<Second>::id(world_);
+        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER, 
+            "operation invalid for empty type");
         return static_cast<Second*>(
-            ecs_get_mut_id(m_world, m_id, ecs_pair(first, second)));
+            ecs_get_mut_id(world_, id_, ecs_pair(first, second)));
     }
 
     /** Get the second part for a pair.
@@ -22906,7 +21919,7 @@ struct entity_view : public id {
      * @return The depth.
      */
     int32_t depth(flecs::entity_t rel) const {
-        return ecs_get_depth(m_world, m_id, rel);
+        return ecs_get_depth(world_, id_, rel);
     }
 
     /** Get depth for given relationship.
@@ -22916,7 +21929,7 @@ struct entity_view : public id {
      */
     template<typename Rel>
     int32_t depth() const {
-        return this->depth(_::cpp_type<Rel>::id(m_world));
+        return this->depth(_::type<Rel>::id(world_));
     }
 
     /** Get parent of entity.
@@ -22942,7 +21955,7 @@ struct entity_view : public id {
      * @return True if the entity has the provided entity, false otherwise.
      */
     bool has(flecs::id_t e) const {
-        return ecs_has_id(m_world, m_id, e);
+        return ecs_has_id(world_, id_, e);
     }     
 
     /** Check if entity has the provided component.
@@ -22952,14 +21965,14 @@ struct entity_view : public id {
      */
     template <typename T>
     bool has() const {
-        flecs::id_t cid = _::cpp_type<T>::id(m_world);
-        bool result = ecs_has_id(m_world, m_id, cid);
+        flecs::id_t cid = _::type<T>::id(world_);
+        bool result = ecs_has_id(world_, id_, cid);
         if (result) {
             return result;
         }
 
         if (is_enum<T>::value) {
-            return ecs_has_pair(m_world, m_id, cid, flecs::Wildcard);
+            return ecs_has_pair(world_, id_, cid, flecs::Wildcard);
         }
 
         return false;
@@ -22973,12 +21986,12 @@ struct entity_view : public id {
      */
     template <typename E, if_t< is_enum<E>::value > = 0>
     bool has(E value) const {
-        auto r = _::cpp_type<E>::id(m_world);
-        auto o = enum_type<E>(m_world).entity(value);
+        auto r = _::type<E>::id(world_);
+        auto o = enum_type<E>(world_).entity(value);
         ecs_assert(o, ECS_INVALID_PARAMETER,
             "Constant was not found in Enum reflection data."
             " Did you mean to use has<E>() instead of has(E)?");
-        return ecs_has_pair(m_world, m_id, r, o);
+        return ecs_has_pair(world_, id_, r, o);
     }
 
     /** Check if entity has the provided pair.
@@ -22989,7 +22002,7 @@ struct entity_view : public id {
      */
     template <typename First, typename Second>
     bool has() const {
-        return this->has<First>(_::cpp_type<Second>::id(m_world));
+        return this->has<First>(_::type<Second>::id(world_));
     }
 
     /** Check if entity has the provided pair.
@@ -23000,8 +22013,8 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
     bool has(Second second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
-        return ecs_has_id(m_world, m_id, ecs_pair(comp_id, second));
+        auto comp_id = _::type<First>::id(world_);
+        return ecs_has_id(world_, id_, ecs_pair(comp_id, second));
     }
 
     /** Check if entity has the provided pair.
@@ -23012,7 +22025,7 @@ struct entity_view : public id {
      */
     template <typename Second>
     bool has_second(flecs::entity_t first) const {
-        return this->has(first, _::cpp_type<Second>::id(m_world));
+        return this->has(first, _::type<Second>::id(world_));
     }
 
     /** Check if entity has the provided pair.
@@ -23023,7 +22036,7 @@ struct entity_view : public id {
      */
     template<typename First, typename E, if_t< is_enum<E>::value > = 0>
     bool has(E value) const {
-        const auto& et = enum_type<E>(this->m_world);
+        const auto& et = enum_type<E>(this->world_);
         flecs::entity_t second = et.entity(value);
         return has<First>(second);
     }
@@ -23035,7 +22048,7 @@ struct entity_view : public id {
      * @return True if the entity has the provided component, false otherwise.
      */
     bool has(flecs::id_t first, flecs::id_t second) const {
-        return ecs_has_id(m_world, m_id, ecs_pair(first, second));
+        return ecs_has_id(world_, id_, ecs_pair(first, second));
     }
 
     /** Check if entity owns the provided entity.
@@ -23045,7 +22058,7 @@ struct entity_view : public id {
      * @return True if the entity owns the provided entity, false otherwise.
      */
     bool owns(flecs::id_t e) const {
-        return ecs_owns_id(m_world, m_id, e);
+        return ecs_owns_id(world_, id_, e);
     }
 
     /** Check if entity owns the provided pair.
@@ -23056,7 +22069,7 @@ struct entity_view : public id {
      */
     template <typename First>
     bool owns(flecs::id_t second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
+        auto comp_id = _::type<First>::id(world_);
         return owns(ecs_pair(comp_id, second));
     }
 
@@ -23078,7 +22091,7 @@ struct entity_view : public id {
      */
     template <typename T>
     bool owns() const {
-        return owns(_::cpp_type<T>::id(m_world));
+        return owns(_::type<T>::id(world_));
     }
 
     /** Check if entity owns the provided pair.
@@ -23091,8 +22104,8 @@ struct entity_view : public id {
     template <typename First, typename Second>
     bool owns() const {
         return owns(
-            _::cpp_type<First>::id(m_world),
-            _::cpp_type<Second>::id(m_world));
+            _::type<First>::id(world_),
+            _::type<Second>::id(world_));
     }
 
     /** Test if id is enabled.
@@ -23101,7 +22114,7 @@ struct entity_view : public id {
      * @return True if enabled, false if not.
      */
     bool enabled(flecs::id_t id) const {
-        return ecs_is_enabled_id(m_world, m_id, id);
+        return ecs_is_enabled_id(world_, id_, id);
     }
 
     /** Test if component is enabled.
@@ -23111,7 +22124,7 @@ struct entity_view : public id {
      */
     template<typename T>
     bool enabled() const {
-        return this->enabled(_::cpp_type<T>::id(m_world));
+        return this->enabled(_::type<T>::id(world_));
     }
 
     /** Test if pair is enabled.
@@ -23132,7 +22145,7 @@ struct entity_view : public id {
      */
     template <typename First>
     bool enabled(flecs::id_t second) const {
-        return this->enabled(_::cpp_type<First>::id(m_world), second);
+        return this->enabled(_::type<First>::id(world_), second);
     }
 
     /** Test if pair is enabled.
@@ -23143,7 +22156,7 @@ struct entity_view : public id {
      */
     template <typename First, typename Second>
     bool enabled() const {
-        return this->enabled<First>(_::cpp_type<Second>::id(m_world));
+        return this->enabled<First>(_::type<Second>::id(world_));
     }
 
     flecs::entity clone(bool clone_value = true, flecs::entity_t dst_id = 0) const;
@@ -23200,7 +22213,7 @@ struct entity_view : public id {
  * @ingroup cpp_addons_json
  */
 flecs::string to_json(const flecs::entity_to_json_desc_t *desc = nullptr) const {
-    char *json = ecs_entity_to_json(m_world, m_id, desc);
+    char *json = ecs_entity_to_json(world_, id_, desc);
     return flecs::string(json);
 }
 
@@ -23221,7 +22234,7 @@ flecs::string to_json(const flecs::entity_to_json_desc_t *desc = nullptr) const
  * @ingroup cpp_addons_doc
  */
 const char* doc_name() const {
-    return ecs_doc_get_name(m_world, m_id);
+    return ecs_doc_get_name(world_, id_);
 }
 
 /** Get brief description.
@@ -23234,7 +22247,7 @@ const char* doc_name() const {
  * @ingroup cpp_addons_doc
  */
 const char* doc_brief() const {
-    return ecs_doc_get_brief(m_world, m_id);
+    return ecs_doc_get_brief(world_, id_);
 }
 
 /** Get detailed description.
@@ -23247,7 +22260,7 @@ const char* doc_brief() const {
  * @ingroup cpp_addons_doc
  */
 const char* doc_detail() const {
-    return ecs_doc_get_detail(m_world, m_id);
+    return ecs_doc_get_detail(world_, id_);
 }
 
 /** Get link to external documentation.
@@ -23260,7 +22273,7 @@ const char* doc_detail() const {
  * @ingroup cpp_addons_doc
  */
 const char* doc_link() const {
-    return ecs_doc_get_link(m_world, m_id);
+    return ecs_doc_get_link(world_, id_);
 }
 
 /** Get color.
@@ -23273,7 +22286,7 @@ const char* doc_link() const {
  * @ingroup cpp_addons_doc
  */
 const char* doc_color() const {
-    return ecs_doc_get_color(m_world, m_id);
+    return ecs_doc_get_color(world_, id_);
 }
 
 #   endif
@@ -23289,7 +22302,7 @@ const char* doc_color() const {
  * @ingroup cpp_addons_alerts
  */
 int32_t alert_count(flecs::entity_t alert = 0) const {
-    return ecs_get_alert_count(m_world, m_id, alert);
+    return ecs_get_alert_count(world_, id_, alert);
 }
 
 #   endif
@@ -23320,9 +22333,9 @@ E to_constant() const;
  * @param evt The event to emit.
  */
 void emit(flecs::entity_t evt) {
-    flecs::world(m_world)
+    flecs::world(world_)
         .event(evt)
-        .entity(m_id)
+        .entity(id_)
         .emit();
 }
 
@@ -23342,7 +22355,7 @@ void emit(flecs::entity evt);
  */
 template <typename Evt, if_t<is_empty<Evt>::value> = 0>
 void emit() {
-    this->emit(_::cpp_type<Evt>::id(m_world));
+    this->emit(_::type<Evt>::id(world_));
 }
 
 /** Emit event with payload for entity.
@@ -23353,9 +22366,9 @@ void emit() {
  */
 template <typename Evt, if_not_t<is_empty<Evt>::value> = 0>
 void emit(const Evt& payload) {
-    flecs::world(m_world)
-        .event(_::cpp_type<Evt>::id(m_world))
-        .entity(m_id)
+    flecs::world(world_)
+        .event(_::type<Evt>::id(world_))
+        .entity(id_)
         .ctx(&payload)
         .emit();
 }
@@ -23368,9 +22381,9 @@ void emit(const Evt& payload) {
  * @param evt The event to enqueue.
  */
 void enqueue(flecs::entity_t evt) {
-    flecs::world(m_world)
+    flecs::world(world_)
         .event(evt)
-        .entity(m_id)
+        .entity(id_)
         .enqueue();
 }
 
@@ -23390,7 +22403,7 @@ void enqueue(flecs::entity evt);
  */
 template <typename Evt, if_t<is_empty<Evt>::value> = 0>
 void enqueue() {
-    this->enqueue(_::cpp_type<Evt>::id(m_world));
+    this->enqueue(_::type<Evt>::id(world_));
 }
 
 /** Enqueue event with payload for entity.
@@ -23401,9 +22414,9 @@ void enqueue() {
  */
 template <typename Evt, if_not_t<is_empty<Evt>::value> = 0>
 void enqueue(const Evt& payload) {
-    flecs::world(m_world)
-        .event(_::cpp_type<Evt>::id(m_world))
-        .entity(m_id)
+    flecs::world(world_)
+        .event(_::type<Evt>::id(world_))
+        .entity(id_)
         .ctx(&payload)
         .enqueue();
 }
@@ -23444,7 +22457,7 @@ struct entity_builder : entity_view {
     Self& add() {
         flecs_static_assert(is_flecs_constructible<T>::value,
             "cannot default construct type: add T::T() or use emplace<T>()");
-        ecs_add_id(this->m_world, this->m_id, _::cpp_type<T>::id(this->m_world));
+        ecs_add_id(this->world_, this->id_, _::type<T>::id(this->world_));
         return to_base();
     }
 
@@ -23459,8 +22472,8 @@ struct entity_builder : entity_view {
      */
     template <typename E, if_t< is_enum<E>::value > = 0>
     Self& add(E value) {
-        flecs::entity_t first = _::cpp_type<E>::id(this->m_world);
-        const auto& et = enum_type<E>(this->m_world);
+        flecs::entity_t first = _::type<E>::id(this->world_);
+        const auto& et = enum_type<E>(this->world_);
         flecs::entity_t second = et.entity(value);
 
         ecs_assert(second, ECS_INVALID_PARAMETER, "Component was not found in reflection data.");
@@ -23473,7 +22486,7 @@ struct entity_builder : entity_view {
      * @param component The component to add.
      */
     Self& add(id_t component) {
-        ecs_add_id(this->m_world, this->m_id, component);
+        ecs_add_id(this->world_, this->id_, component);
         return to_base();
     }
 
@@ -23484,7 +22497,7 @@ struct entity_builder : entity_view {
      * @param second The second element of the pair.
      */
     Self& add(entity_t first, entity_t second) {
-        ecs_add_pair(this->m_world, this->m_id, first, second);
+        ecs_add_pair(this->world_, this->id_, first, second);
         return to_base();
     }
 
@@ -23496,7 +22509,7 @@ struct entity_builder : entity_view {
      */
     template<typename First, typename Second>
     Self& add() {
-        return this->add<First>(_::cpp_type<Second>::id(this->m_world));
+        return this->add<First>(_::type<Second>::id(this->world_));
     }
 
     /** Add a pair.
@@ -23509,7 +22522,7 @@ struct entity_builder : entity_view {
     Self& add(Second second) {
         flecs_static_assert(is_flecs_constructible<First>::value,
             "cannot default construct type: add T::T() or use emplace<T>()");
-        return this->add(_::cpp_type<First>::id(this->m_world), second);
+        return this->add(_::type<First>::id(this->world_), second);
     }
 
     /** Add a pair.
@@ -23523,7 +22536,7 @@ struct entity_builder : entity_view {
     Self& add(Second constant) {
         flecs_static_assert(is_flecs_constructible<First>::value,
             "cannot default construct type: add T::T() or use emplace<T>()");
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         return this->add<First>(et.entity(constant));
     }
 
@@ -23535,7 +22548,7 @@ struct entity_builder : entity_view {
      */
     template<typename Second>
     Self& add_second(flecs::entity_t first) {
-        return this->add(first, _::cpp_type<Second>::id(this->m_world));
+        return this->add(first, _::type<Second>::id(this->world_));
     }
 
     /** Conditional add.
@@ -23582,7 +22595,7 @@ struct entity_builder : entity_view {
              * second which will remove all instances of the relationship.
              * Replacing 0 with Wildcard will make it possible to use the second
              * as the condition. */
-            if (!second || ecs_has_id(this->m_world, first, flecs::Exclusive)) {
+            if (!second || ecs_has_id(this->world_, first, flecs::Exclusive)) {
                 second = flecs::Wildcard;
             }
             return this->remove(first, second);
@@ -23598,7 +22611,7 @@ struct entity_builder : entity_view {
      */
     template <typename First>
     Self& add_if(bool cond, flecs::entity_t second) {
-        return this->add_if(cond, _::cpp_type<First>::id(this->m_world), second);
+        return this->add_if(cond, _::type<First>::id(this->world_), second);
     }
 
     /** Conditional add.
@@ -23610,7 +22623,7 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Second>
     Self& add_if(bool cond) {
-        return this->add_if<First>(cond, _::cpp_type<Second>::id(this->m_world));
+        return this->add_if<First>(cond, _::type<Second>::id(this->world_));
     }
 
     /** Conditional add.
@@ -23621,7 +22634,7 @@ struct entity_builder : entity_view {
      */
     template <typename E, if_t< is_enum<E>::value > = 0>
     Self& add_if(bool cond, E constant) {
-        const auto& et = enum_type<E>(this->m_world);
+        const auto& et = enum_type<E>(this->world_);
         return this->add_if<E>(cond, et.entity(constant));
     }
 
@@ -23639,7 +22652,7 @@ struct entity_builder : entity_view {
      */
     template <typename T>
     Self& is_a() {
-        return this->add(flecs::IsA, _::cpp_type<T>::id(this->m_world));
+        return this->add(flecs::IsA, _::type<T>::id(this->world_));
     }
 
     /** Shortcut for add(ChildOf, entity).
@@ -23665,7 +22678,7 @@ struct entity_builder : entity_view {
     template <typename E, if_t<is_enum<E>::value> = 0>
     Self& depends_on(E second)
     {
-        const auto& et = enum_type<E>(this->m_world);
+        const auto& et = enum_type<E>(this->world_);
         flecs::entity_t target = et.entity(second);
         return depends_on(target);
     }
@@ -23681,7 +22694,7 @@ struct entity_builder : entity_view {
     /** Shortcut for add(SlotOf, target(ChildOf)).
      */
     Self& slot() {
-        ecs_check(ecs_get_target(m_world, m_id, flecs::ChildOf, 0), 
+        ecs_check(ecs_get_target(world_, id_, flecs::ChildOf, 0), 
             ECS_INVALID_PARAMETER, "add ChildOf pair before using slot()");
         return this->slot_of(this->target(flecs::ChildOf));
     error:
@@ -23694,7 +22707,7 @@ struct entity_builder : entity_view {
      */
     template <typename T>
     Self& child_of() {
-        return this->child_of(_::cpp_type<T>::id(this->m_world));
+        return this->child_of(_::type<T>::id(this->world_));
     }
  
     /** Shortcut for add(DependsOn, entity).
@@ -23703,7 +22716,7 @@ struct entity_builder : entity_view {
      */
     template <typename T>
     Self& depends_on() {
-        return this->depends_on(_::cpp_type<T>::id(this->m_world));
+        return this->depends_on(_::type<T>::id(this->world_));
     }
 
     /** Shortcut for add(SlotOf, entity).
@@ -23712,7 +22725,7 @@ struct entity_builder : entity_view {
      */
     template <typename T>
     Self& slot_of() {
-        return this->slot_of(_::cpp_type<T>::id(this->m_world));
+        return this->slot_of(_::type<T>::id(this->world_));
     }
 
     /** Remove a component from an entity.
@@ -23721,7 +22734,7 @@ struct entity_builder : entity_view {
      */
     template <typename T, if_not_t< is_enum<T>::value > = 0>
     Self& remove() {
-        ecs_remove_id(this->m_world, this->m_id, _::cpp_type<T>::id(this->m_world));
+        ecs_remove_id(this->world_, this->id_, _::type<T>::id(this->world_));
         return to_base();
     }
 
@@ -23732,7 +22745,7 @@ struct entity_builder : entity_view {
      */
     template <typename E, if_t< is_enum<E>::value > = 0>
     Self& remove() {
-        flecs::entity_t first = _::cpp_type<E>::id(this->m_world);
+        flecs::entity_t first = _::type<E>::id(this->world_);
         return this->remove(first, flecs::Wildcard);
     }
 
@@ -23741,7 +22754,7 @@ struct entity_builder : entity_view {
      * @param entity The entity to remove.
      */
     Self& remove(entity_t entity) {
-        ecs_remove_id(this->m_world, this->m_id, entity);
+        ecs_remove_id(this->world_, this->id_, entity);
         return to_base();
     }
 
@@ -23752,7 +22765,7 @@ struct entity_builder : entity_view {
      * @param second The second element of the pair.
      */
     Self& remove(entity_t first, entity_t second) {
-        ecs_remove_pair(this->m_world, this->m_id, first, second);
+        ecs_remove_pair(this->world_, this->id_, first, second);
         return to_base();
     }
 
@@ -23764,7 +22777,7 @@ struct entity_builder : entity_view {
      */
     template<typename First, typename Second>
     Self& remove() {
-        return this->remove<First>(_::cpp_type<Second>::id(this->m_world));
+        return this->remove<First>(_::type<Second>::id(this->world_));
     }
 
     /** Remove a pair.
@@ -23775,7 +22788,7 @@ struct entity_builder : entity_view {
      */
     template<typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
     Self& remove(Second second) {
-        return this->remove(_::cpp_type<First>::id(this->m_world), second);
+        return this->remove(_::type<First>::id(this->world_), second);
     }
 
     /** Removes a pair.
@@ -23786,7 +22799,7 @@ struct entity_builder : entity_view {
      */
     template<typename Second>
     Self& remove_second(flecs::entity_t first) {
-        return this->remove(first, _::cpp_type<Second>::id(this->m_world));
+        return this->remove(first, _::type<Second>::id(this->world_));
     }
 
     /** Remove a pair.
@@ -23797,7 +22810,7 @@ struct entity_builder : entity_view {
      */
     template<typename First, typename Second, if_t< is_enum<Second>::value > = 0>
     Self& remove(Second constant) {
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         flecs::entity_t second = et.entity(constant);
         return this->remove<First>(second);
     }  
@@ -23830,7 +22843,7 @@ struct entity_builder : entity_view {
      */     
     template <typename T>
     Self& override() {
-        return this->override(_::cpp_type<T>::id(this->m_world));
+        return this->override(_::type<T>::id(this->world_));
     }
 
     /** Mark pair for auto-overriding.
@@ -23841,7 +22854,7 @@ struct entity_builder : entity_view {
      */     
     template <typename First>
     Self& override(flecs::entity_t second) {
-        return this->override(_::cpp_type<First>::id(this->m_world), second);
+        return this->override(_::type<First>::id(this->world_), second);
     }
 
     /** Mark pair for auto-overriding.
@@ -23852,7 +22865,7 @@ struct entity_builder : entity_view {
      */     
     template <typename First, typename Second>
     Self& override() {
-        return this->override<First>(_::cpp_type<Second>::id(this->m_world));
+        return this->override<First>(_::type<Second>::id(this->world_));
     }
 
     /** Set component, mark component for auto-overriding.
@@ -23936,8 +22949,8 @@ struct entity_builder : entity_view {
     Self& emplace_override(Args&&... args) {
         this->override<T>();
 
-        flecs::emplace<T>(this->m_world, this->m_id, 
-            _::cpp_type<T>::id(this->m_world), FLECS_FWD(args)...);
+        flecs::emplace<T>(this->world_, this->id_, 
+            _::type<T>::id(this->world_), FLECS_FWD(args)...);
 
         return to_base();  
     }
@@ -23954,9 +22967,9 @@ struct entity_builder : entity_view {
     Self& emplace_override(Args&&... args) {
         this->override<First, Second>();
 
-        flecs::emplace<A>(this->m_world, this->m_id, 
-            ecs_pair(_::cpp_type<First>::id(this->m_world),
-                _::cpp_type<Second>::id(this->m_world)),
+        flecs::emplace<A>(this->world_, this->id_, 
+            ecs_pair(_::type<First>::id(this->world_),
+                _::type<Second>::id(this->world_)),
                     FLECS_FWD(args)...);
 
         return to_base();  
@@ -23967,7 +22980,7 @@ struct entity_builder : entity_view {
      * queries.
      */
     Self& enable() {
-        ecs_enable(this->m_world, this->m_id, true);
+        ecs_enable(this->world_, this->id_, true);
         return to_base();
     }
 
@@ -23976,7 +22989,7 @@ struct entity_builder : entity_view {
      * with queries, unless explicitly specified in the query expression.
      */
     Self& disable() {
-        ecs_enable(this->m_world, this->m_id, false);
+        ecs_enable(this->world_, this->id_, false);
         return to_base();
     }
 
@@ -23988,7 +23001,7 @@ struct entity_builder : entity_view {
      * @param toggle True to enable, false to disable (default = true).
      */   
     Self& enable(flecs::id_t id, bool toggle = true) {
-        ecs_enable_id(this->m_world, this->m_id, id, toggle);
+        ecs_enable_id(this->world_, this->id_, id, toggle);
         return to_base();       
     }
 
@@ -23999,7 +23012,7 @@ struct entity_builder : entity_view {
      */   
     template<typename T>
     Self& enable() {
-        return this->enable(_::cpp_type<T>::id(this->m_world));
+        return this->enable(_::type<T>::id(this->world_));
     }
 
     /** Enable a pair.
@@ -24020,7 +23033,7 @@ struct entity_builder : entity_view {
      */   
     template<typename First>
     Self& enable(flecs::id_t second) {
-        return this->enable(_::cpp_type<First>::id(), second);
+        return this->enable(_::type<First>::id(), second);
     }
 
     /** Enable a pair.
@@ -24031,7 +23044,7 @@ struct entity_builder : entity_view {
      */   
     template<typename First, typename Second>
     Self& enable() {
-        return this->enable<First>(_::cpp_type<Second>::id());
+        return this->enable<First>(_::type<Second>::id());
     }
 
     /** Disable an id.
@@ -24051,7 +23064,7 @@ struct entity_builder : entity_view {
      */   
     template<typename T>
     Self& disable() {
-        return this->disable(_::cpp_type<T>::id());
+        return this->disable(_::type<T>::id());
     }
 
     /** Disable a pair.
@@ -24072,7 +23085,7 @@ struct entity_builder : entity_view {
      */   
     template<typename First>
     Self& disable(flecs::id_t second) {
-        return this->disable(_::cpp_type<First>::id(), second);
+        return this->disable(_::type<First>::id(), second);
     }
 
     /** Disable a pair.
@@ -24083,17 +23096,17 @@ struct entity_builder : entity_view {
      */   
     template<typename First, typename Second>
     Self& disable() {
-        return this->disable<First>(_::cpp_type<Second>::id());
+        return this->disable<First>(_::type<Second>::id());
     }
 
     Self& set_ptr(entity_t comp, size_t size, const void *ptr) {
-        ecs_set_id(this->m_world, this->m_id, comp, size, ptr);
+        ecs_set_id(this->world_, this->id_, comp, size, ptr);
         return to_base();
     }
 
     Self& set_ptr(entity_t comp, const void *ptr) {
         const flecs::Component *cptr = ecs_get(
-            this->m_world, comp, EcsComponent);
+            this->world_, comp, EcsComponent);
 
         /* Can't set if it's not a component */
         ecs_assert(cptr != NULL, ECS_INVALID_PARAMETER, NULL);
@@ -24101,31 +23114,29 @@ struct entity_builder : entity_view {
         return set_ptr(comp, cptr->size, ptr);
     }
 
-    template<typename T, if_t< 
-        !is_callable<T>::value && is_actual<T>::value> = 0 >
+    template<typename T, if_t<is_actual<T>::value> = 0 >
     Self& set(T&& value) {
-        flecs::set<T>(this->m_world, this->m_id, FLECS_FWD(value));
+        flecs::set<T>(this->world_, this->id_, FLECS_FWD(value));
         return to_base();
     }
 
-    template<typename T, if_t< 
-        !is_callable<T>::value && is_actual<T>::value > = 0>
+    template<typename T, if_t<is_actual<T>::value > = 0>
     Self& set(const T& value) {
-        flecs::set<T>(this->m_world, this->m_id, value);
+        flecs::set<T>(this->world_, this->id_, value);
         return to_base();
     }
 
     template<typename T, typename A = actual_type_t<T>, if_not_t< 
-        is_callable<T>::value || is_actual<T>::value > = 0>
+        is_actual<T>::value > = 0>
     Self& set(A&& value) {
-        flecs::set<T>(this->m_world, this->m_id, FLECS_FWD(value));
+        flecs::set<T>(this->world_, this->id_, FLECS_FWD(value));
         return to_base();
     }
 
     template<typename T, typename A = actual_type_t<T>, if_not_t<
-        is_callable<T>::value || is_actual<T>::value > = 0>
+        is_actual<T>::value > = 0>
     Self& set(const A& value) {
-        flecs::set<T>(this->m_world, this->m_id, value);
+        flecs::set<T>(this->world_, this->id_, value);
         return to_base();
     }
 
@@ -24140,7 +23151,7 @@ struct entity_builder : entity_view {
     template <typename First, typename Second, typename P = pair<First, Second>, 
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     Self& set(A&& value) {
-        flecs::set<P>(this->m_world, this->m_id, FLECS_FWD(value));
+        flecs::set<P>(this->world_, this->id_, FLECS_FWD(value));
         return to_base();
     }
 
@@ -24155,7 +23166,7 @@ struct entity_builder : entity_view {
     template <typename First, typename Second, typename P = pair<First, Second>, 
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     Self& set(const A& value) {
-        flecs::set<P>(this->m_world, this->m_id, value);
+        flecs::set<P>(this->world_, this->id_, value);
         return to_base();
     }
 
@@ -24169,8 +23180,8 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
     Self& set(Second second, const First& value) {
-        auto first = _::cpp_type<First>::id(this->m_world);
-        flecs::set(this->m_world, this->m_id, value, 
+        auto first = _::type<First>::id(this->world_);
+        flecs::set(this->world_, this->id_, value, 
             ecs_pair(first, second));
         return to_base();
     }
@@ -24185,8 +23196,8 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
     Self& set(Second second, First&& value) {
-        auto first = _::cpp_type<First>::id(this->m_world);
-        flecs::set(this->m_world, this->m_id, FLECS_FWD(value), 
+        auto first = _::type<First>::id(this->world_);
+        flecs::set(this->world_, this->id_, FLECS_FWD(value), 
             ecs_pair(first, second));
         return to_base();
     }
@@ -24201,7 +23212,7 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Second, if_t< is_enum<Second>::value > = 0>
     Self& set(Second constant, const First& value) {
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         flecs::entity_t second = et.entity(constant);
         return set<First>(second, value);
     }
@@ -24216,8 +23227,8 @@ struct entity_builder : entity_view {
      */
     template <typename Second>
     Self& set_second(entity_t first, const Second& value) {
-        auto second = _::cpp_type<Second>::id(this->m_world);
-        flecs::set(this->m_world, this->m_id, value, 
+        auto second = _::type<Second>::id(this->world_);
+        flecs::set(this->world_, this->id_, value, 
             ecs_pair(first, second));
         return to_base();
     }
@@ -24232,15 +23243,15 @@ struct entity_builder : entity_view {
      */
     template <typename Second>
     Self& set_second(entity_t first, Second&& value) {
-        auto second = _::cpp_type<Second>::id(this->m_world);
-        flecs::set(this->m_world, this->m_id, FLECS_FWD(value), 
+        auto second = _::type<Second>::id(this->world_);
+        flecs::set(this->world_, this->id_, FLECS_FWD(value), 
             ecs_pair(first, second));
         return to_base();
     }
 
     template <typename First, typename Second>
     Self& set_second(const Second& value) {
-        flecs::set<pair_object<First, Second>>(this->m_world, this->m_id, value);
+        flecs::set<pair_object<First, Second>>(this->world_, this->id_, value);
         return to_base();
     }    
 
@@ -24259,8 +23270,8 @@ struct entity_builder : entity_view {
      *
      * @param func The callback to invoke.
      */
-    template <typename Func, if_t< is_callable<Func>::value > = 0>
-    Self& set(const Func& func);
+    template <typename Func>
+    Self& insert(const Func& func);
 
     /** Emplace component.
      * Emplace constructs a component in the storage, which prevents calling the
@@ -24285,33 +23296,33 @@ struct entity_builder : entity_view {
      */
     template<typename T, typename ... Args, typename A = actual_type_t<T>>
     Self& emplace(Args&&... args) {
-        flecs::emplace<A>(this->m_world, this->m_id, 
-            _::cpp_type<T>::id(this->m_world), FLECS_FWD(args)...);
+        flecs::emplace<A>(this->world_, this->id_, 
+            _::type<T>::id(this->world_), FLECS_FWD(args)...);
         return to_base();
     }
 
     template <typename First, typename Second, typename ... Args, typename P = pair<First, Second>, 
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     Self& emplace(Args&&... args) {
-        flecs::emplace<A>(this->m_world, this->m_id, 
-            ecs_pair(_::cpp_type<First>::id(this->m_world),
-                _::cpp_type<Second>::id(this->m_world)),
+        flecs::emplace<A>(this->world_, this->id_, 
+            ecs_pair(_::type<First>::id(this->world_),
+                _::type<Second>::id(this->world_)),
             FLECS_FWD(args)...);
         return to_base();
     }
 
     template <typename First, typename ... Args>
     Self& emplace_first(flecs::entity_t second, Args&&... args) {
-        flecs::emplace<First>(this->m_world, this->m_id, 
-            ecs_pair(_::cpp_type<First>::id(this->m_world), second),
+        flecs::emplace<First>(this->world_, this->id_, 
+            ecs_pair(_::type<First>::id(this->world_), second),
             FLECS_FWD(args)...);
         return to_base();
     }
 
     template <typename Second, typename ... Args>
     Self& emplace_second(flecs::entity_t first, Args&&... args) {
-        flecs::emplace<Second>(this->m_world, this->m_id, 
-            ecs_pair(first, _::cpp_type<Second>::id(this->m_world)),
+        flecs::emplace<Second>(this->world_, this->id_, 
+            ecs_pair(first, _::type<Second>::id(this->world_)),
             FLECS_FWD(args)...);
         return to_base();
     }
@@ -24323,9 +23334,9 @@ struct entity_builder : entity_view {
      */
     template <typename Func>
     Self& with(const Func& func) {
-        ecs_id_t prev = ecs_set_with(this->m_world, this->m_id);
+        ecs_id_t prev = ecs_set_with(this->world_, this->id_);
         func();
-        ecs_set_with(this->m_world, prev);
+        ecs_set_with(this->world_, prev);
         return to_base();
     }
 
@@ -24337,7 +23348,7 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Func>
     Self& with(const Func& func) {
-        with(_::cpp_type<First>::id(this->m_world), func);
+        with(_::type<First>::id(this->world_), func);
         return to_base();
     }
 
@@ -24349,38 +23360,38 @@ struct entity_builder : entity_view {
      */
     template <typename Func>
     Self& with(entity_t first, const Func& func) {
-        ecs_id_t prev = ecs_set_with(this->m_world, 
-            ecs_pair(first, this->m_id));
+        ecs_id_t prev = ecs_set_with(this->world_, 
+            ecs_pair(first, this->id_));
         func();
-        ecs_set_with(this->m_world, prev);
+        ecs_set_with(this->world_, prev);
         return to_base();
     }
 
     /** The function will be ran with the scope set to the current entity. */
     template <typename Func>
     Self& scope(const Func& func) {
-        ecs_entity_t prev = ecs_set_scope(this->m_world, this->m_id);
+        ecs_entity_t prev = ecs_set_scope(this->world_, this->id_);
         func();
-        ecs_set_scope(this->m_world, prev);
+        ecs_set_scope(this->world_, prev);
         return to_base();
     }
 
     /** Return world scoped to entity */
     scoped_world scope() const {
-        return scoped_world(m_world, m_id);
+        return scoped_world(world_, id_);
     }
 
     /* Set the entity name.
      */
     Self& set_name(const char *name) {
-        ecs_set_name(this->m_world, this->m_id, name);
+        ecs_set_name(this->world_, this->id_, name);
         return to_base();
     }
 
     /* Set entity alias.
      */
     Self& set_alias(const char *name) {
-        ecs_set_alias(this->m_world, this->m_id, name);
+        ecs_set_alias(this->world_, this->id_, name);
         return to_base();
     }
 
@@ -24401,7 +23412,7 @@ struct entity_builder : entity_view {
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_name(const char *name) {
-    ecs_doc_set_name(m_world, m_id, name);
+    ecs_doc_set_name(world_, id_, name);
     return to_base();
 }
 
@@ -24416,7 +23427,7 @@ Self& set_doc_name(const char *name) {
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_brief(const char *brief) {
-    ecs_doc_set_brief(m_world, m_id, brief);
+    ecs_doc_set_brief(world_, id_, brief);
     return to_base();
 }
 
@@ -24431,7 +23442,7 @@ Self& set_doc_brief(const char *brief) {
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_detail(const char *detail) {
-    ecs_doc_set_detail(m_world, m_id, detail);
+    ecs_doc_set_detail(world_, id_, detail);
     return to_base();
 }
 
@@ -24446,7 +23457,7 @@ Self& set_doc_detail(const char *detail) {
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_link(const char *link) {
-    ecs_doc_set_link(m_world, m_id, link);
+    ecs_doc_set_link(world_, id_, link);
     return to_base();
 }
 
@@ -24461,7 +23472,7 @@ Self& set_doc_link(const char *link) {
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_color(const char *link) {
-    ecs_doc_set_color(m_world, m_id, link);
+    ecs_doc_set_color(world_, id_, link);
     return to_base();
 }
 
@@ -24490,7 +23501,7 @@ Self& unit(
     int32_t power = 0) 
 {
     ecs_unit_desc_t desc = {};
-    desc.entity = this->m_id;
+    desc.entity = this->id_;
     desc.symbol = const_cast<char*>(symbol); /* safe, will be copied in */
     desc.base = base;
     desc.over = over;
@@ -24511,7 +23522,7 @@ Self& unit(
     int32_t power = 0) 
 {
     ecs_unit_desc_t desc = {};
-    desc.entity = this->m_id;
+    desc.entity = this->id_;
     desc.base = base;
     desc.over = over;
     desc.prefix = prefix;
@@ -24529,7 +23540,7 @@ Self& unit_prefix(
     int32_t power = 0) 
 {
     ecs_unit_prefix_desc_t desc = {};
-    desc.entity = this->m_id;
+    desc.entity = this->id_;
     desc.symbol = const_cast<char*>(symbol); /* safe, will be copied in */
     desc.translation.factor = factor;
     desc.translation.power = power;
@@ -24547,7 +23558,7 @@ Self& quantity(flecs::entity_t quantity) {
 /** Make entity a unity prefix */
 template <typename Quantity>
 Self& quantity() {
-    return this->quantity(_::cpp_type<Quantity>::id(this->world()));
+    return this->quantity(_::type<Quantity>::id(this->world()));
 }
 
 /** Make entity a quantity */
@@ -24576,16 +23587,16 @@ Self& set_json(
     const char *json, 
     flecs::from_json_desc_t *desc = nullptr) 
 {
-    flecs::entity_t type = ecs_get_typeid(m_world, e);
+    flecs::entity_t type = ecs_get_typeid(world_, e);
     if (!type) {
         ecs_err("id is not a type");
         return to_base();
     }
 
-    void *ptr = ecs_ensure_id(m_world, m_id, e);
+    void *ptr = ecs_ensure_id(world_, id_, e);
     ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_ptr_from_json(m_world, type, ptr, json, desc);
-    ecs_modified_id(m_world, m_id, e);
+    ecs_ptr_from_json(world_, type, ptr, json, desc);
+    ecs_modified_id(world_, id_, e);
 
     return to_base();
 }
@@ -24614,7 +23625,7 @@ Self& set_json(
     const char *json, 
     flecs::from_json_desc_t *desc = nullptr) 
 {
-    return set_json(_::cpp_type<T>::id(m_world), json, desc);
+    return set_json(_::type<T>::id(world_), json, desc);
 }
 
 /** Set pair from JSON.
@@ -24628,8 +23639,8 @@ Self& set_json(
     flecs::from_json_desc_t *desc = nullptr) 
 {
     return set_json(
-        _::cpp_type<R>::id(m_world), 
-        _::cpp_type<T>::id(m_world),
+        _::type<R>::id(world_), 
+        _::type<T>::id(world_),
         json, desc);
 }
 
@@ -24645,7 +23656,7 @@ Self& set_json(
     flecs::from_json_desc_t *desc = nullptr) 
 {
     return set_json(
-        _::cpp_type<R>::id(m_world), t,
+        _::type<R>::id(world_), t,
         json, desc);
 }
 
@@ -24661,7 +23672,7 @@ Self& set_json_second(
     flecs::from_json_desc_t *desc = nullptr) 
 {
     return set_json(
-        r, _::cpp_type<T>::id(m_world),
+        r, _::type<T>::id(world_),
         json, desc);
 }
 
@@ -24743,8 +23754,13 @@ struct entity : entity_builder<entity>
     explicit entity(world_t *world)
         : entity_builder()
     {
-        m_world = world;
-        m_id = ecs_new(world, 0);
+        world_ = world;
+        if (!ecs_get_scope(world_) && !ecs_get_with(world_)) {
+            id_ = ecs_new(world);
+        } else {
+            ecs_entity_desc_t desc = {};
+            id_ = ecs_entity_init(world_, &desc);
+        }
     }
 
     /** Wrap an existing entity id.
@@ -24753,8 +23769,8 @@ struct entity : entity_builder<entity>
      * @param id The entity id.
      */
     explicit entity(const flecs::world_t *world, flecs::entity_t id) {
-        m_world = const_cast<flecs::world_t*>(world);
-        m_id = id;
+        world_ = const_cast<flecs::world_t*>(world);
+        id_ = id;
     }
 
     /** Create a named entity.
@@ -24769,13 +23785,13 @@ struct entity : entity_builder<entity>
     explicit entity(world_t *world, const char *name)
         : entity_builder()
     {
-        m_world = world;
+        world_ = world;
 
         ecs_entity_desc_t desc = {};
         desc.name = name;
         desc.sep = "::";
         desc.root_sep = "::";
-        m_id = ecs_entity_init(world, &desc);
+        id_ = ecs_entity_init(world, &desc);
     }
 
     /** Conversion from flecs::entity_t to flecs::entity.
@@ -24798,9 +23814,10 @@ struct entity : entity_builder<entity>
      */
     template <typename T>
     T& ensure() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return *static_cast<T*>(ecs_ensure_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return *static_cast<T*>(ecs_ensure_id(world_, id_, comp_id));
     }
 
     /** Get mutable component value (untyped).
@@ -24813,7 +23830,7 @@ struct entity : entity_builder<entity>
      * @return Pointer to the component value.
      */
     void* ensure(entity_t comp) const {
-        return ecs_ensure_id(m_world, m_id, comp);
+        return ecs_ensure_id(world_, id_, comp);
     }
 
     /** Get mutable pointer for a pair.
@@ -24825,9 +23842,9 @@ struct entity : entity_builder<entity>
     template <typename First, typename Second, typename P = pair<First, Second>,
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     A& ensure() const {
-        return *static_cast<A*>(ecs_ensure_id(m_world, m_id, ecs_pair(
-            _::cpp_type<First>::id(m_world),
-            _::cpp_type<Second>::id(m_world))));
+        return *static_cast<A*>(ecs_ensure_id(world_, id_, ecs_pair(
+            _::type<First>::id(world_),
+            _::type<Second>::id(world_))));
     }
 
     /** Get mutable pointer for the first element of a pair.
@@ -24838,10 +23855,11 @@ struct entity : entity_builder<entity>
      */
     template <typename First>
     First& ensure(entity_t second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
-        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto comp_id = _::type<First>::id(world_);
+        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         return *static_cast<First*>(
-            ecs_ensure_id(m_world, m_id, ecs_pair(comp_id, second)));
+            ecs_ensure_id(world_, id_, ecs_pair(comp_id, second)));
     }
 
     /** Get mutable pointer for a pair (untyped).
@@ -24853,11 +23871,9 @@ struct entity : entity_builder<entity>
      * @param second The second element of the pair.
      */
     void* ensure(entity_t first, entity_t second) const {
-        return ecs_ensure_id(m_world, m_id, ecs_pair(first, second));
+        return ecs_ensure_id(world_, id_, ecs_pair(first, second));
     }
 
-    #endif
-
     /** Get mutable pointer for the second element of a pair.
      * This operation gets the value for a pair from the entity.
      *
@@ -24866,20 +23882,24 @@ struct entity : entity_builder<entity>
      */
     template <typename Second>
     Second& ensure_second(entity_t first) const {
-        auto second = _::cpp_type<Second>::id(m_world);
-        ecs_assert(_::cpp_type<Second>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto second = _::type<Second>::id(world_);
+        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         return *static_cast<Second*>(
-            ecs_ensure_id(m_world, m_id, ecs_pair(first, second)));
+            ecs_ensure_id(world_, id_, ecs_pair(first, second)));
     }
 
+    #endif
+
     /** Signal that component was modified.
      *
      * @tparam T component that was modified.
      */
     template <typename T>
     void modified() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         this->modified(comp_id);
     }
 
@@ -24890,7 +23910,7 @@ struct entity : entity_builder<entity>
      */
     template <typename First, typename Second>
     void modified() const {
-        this->modified<First>(_::cpp_type<Second>::id(m_world));
+        this->modified<First>(_::type<Second>::id(world_));
     }
 
     /** Signal that the first part of a pair was modified.
@@ -24900,8 +23920,9 @@ struct entity : entity_builder<entity>
      */
     template <typename First>
     void modified(entity_t second) const {
-        auto first = _::cpp_type<First>::id(m_world);
-        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto first = _::type<First>::id(world_);
+        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         this->modified(first, second);
     }
 
@@ -24921,7 +23942,7 @@ struct entity : entity_builder<entity>
      * @param comp component that was modified.
      */
     void modified(entity_t comp) const {
-        ecs_modified_id(m_world, m_id, comp);
+        ecs_modified_id(world_, id_, comp);
     }
 
     /** Get reference to component.
@@ -24933,7 +23954,7 @@ struct entity : entity_builder<entity>
      */
     template <typename T, if_t< is_actual<T>::value > = 0>
     ref<T> get_ref() const {
-        return ref<T>(m_world, m_id, _::cpp_type<T>::id(m_world));
+        return ref<T>(world_, id_, _::type<T>::id(world_));
     }
 
     /** Get reference to component.
@@ -24947,37 +23968,30 @@ struct entity : entity_builder<entity>
      */
     template <typename T, typename A = actual_type_t<T>, if_t< flecs::is_pair<T>::value > = 0>
     ref<A> get_ref() const {
-        return ref<A>(m_world, m_id,
-                      ecs_pair(_::cpp_type<typename T::first>::id(m_world),
-                               _::cpp_type<typename T::second>::id(m_world)));
+        return ref<A>(world_, id_,
+                      ecs_pair(_::type<typename T::first>::id(world_),
+                               _::type<typename T::second>::id(world_)));
     }
 
 
     template <typename First, typename Second, typename P = flecs::pair<First, Second>,
         typename A = actual_type_t<P>>
     ref<A> get_ref() const {
-        return ref<A>(m_world, m_id,
-            ecs_pair(_::cpp_type<First>::id(m_world),
-                _::cpp_type<Second>::id(m_world)));
+        return ref<A>(world_, id_,
+            ecs_pair(_::type<First>::id(world_),
+                _::type<Second>::id(world_)));
     }
 
     template <typename First>
     ref<First> get_ref(flecs::entity_t second) const {
-        return ref<First>(m_world, m_id,
-            ecs_pair(_::cpp_type<First>::id(m_world), second));
+        return ref<First>(world_, id_,
+            ecs_pair(_::type<First>::id(world_), second));
     }
 
     template <typename Second>
     ref<Second> get_ref_second(flecs::entity_t first) const {
-        return ref<Second>(m_world, m_id,
-            ecs_pair(first, _::cpp_type<Second>::id(m_world)));
-    }
-
-    /** Recursively flatten relationship.
-     * @see ecs_flatten
-     */
-    void flatten(flecs::entity_t r, const ecs_flatten_desc_t *desc = nullptr) {
-        ecs_flatten(m_world, ecs_pair(r, m_id), desc);
+        return ref<Second>(world_, id_,
+            ecs_pair(first, _::type<Second>::id(world_)));
     }
 
     /** Clear an entity.
@@ -24985,7 +23999,7 @@ struct entity : entity_builder<entity>
      * the entity id.
      */
     void clear() const {
-        ecs_clear(m_world, m_id);
+        ecs_clear(world_, id_);
     }
 
     /** Delete an entity.
@@ -24993,7 +24007,7 @@ struct entity : entity_builder<entity>
      * entity object goes out of scope.
      */
     void destruct() const {
-        ecs_delete(m_world, m_id);
+        ecs_delete(world_, id_);
     }
 
     /** Return entity as entity_view.
@@ -25006,7 +24020,7 @@ struct entity : entity_builder<entity>
      */
     flecs::entity_view view() const {
         return flecs::entity_view(
-            const_cast<flecs::world_t*>(ecs_get_world(m_world)), m_id);
+            const_cast<flecs::world_t*>(ecs_get_world(world_)), id_);
     }
 
     /** Entity id 0.
@@ -25018,7 +24032,7 @@ struct entity : entity_builder<entity>
     static
     flecs::entity null(const flecs::world_t *world) {
         flecs::entity result;
-        result.m_world = const_cast<flecs::world_t*>(world);
+        result.world_ = const_cast<flecs::world_t*>(world);
         return result;
     }
 
@@ -25035,7 +24049,7 @@ struct entity : entity_builder<entity>
  * @ingroup cpp_addons_json
  */
 const char* from_json(const char *json) {
-    return ecs_entity_from_json(m_world, m_id, json, nullptr);
+    return ecs_entity_from_json(world_, id_, json, nullptr);
 }
 
 #   endif
@@ -25097,7 +24111,7 @@ struct term_ptrs {
                     *>(nullptr)...);
     }
 
-    array m_terms;
+    array terms_;
 
 private:
     /* Populate terms array without checking for references */
@@ -25105,9 +24119,9 @@ struct term_ptrs {
 
     template <typename T, typename... Targs>
     bool populate(const ecs_iter_t *iter, size_t index, T, Targs... comps) {
-        m_terms[index].ptr = iter->ptrs[index];
+        terms_[index].ptr = iter->ptrs[index];
         bool is_ref = iter->sources && iter->sources[index] != 0;
-        m_terms[index].is_ref = is_ref;
+        terms_[index].is_ref = is_ref;
         is_ref |= populate(iter, index + 1, comps ...);
         return is_ref;
     }  
@@ -25123,11 +24137,11 @@ struct each_column { };
 // Base class
 struct each_column_base {
     each_column_base(const _::term_ptr& term, size_t row) 
-        : m_term(term), m_row(row) { }
+        : term_(term), row_(row) { }
 
 protected:
-    const _::term_ptr& m_term;
-    size_t m_row;    
+    const _::term_ptr& term_;
+    size_t row_;    
 };
 
 // If type is not a pointer, return a reference to the type (default case)
@@ -25140,7 +24154,7 @@ struct each_column<T, if_t< !is_pointer<T>::value &&
         : each_column_base(term, row) { }
 
     T& get_row() {
-        return static_cast<T*>(this->m_term.ptr)[this->m_row];
+        return static_cast<T*>(this->term_.ptr)[this->row_];
     }  
 };
 
@@ -25156,7 +24170,7 @@ struct each_column<T, if_t< !is_pointer<T>::value &&
         : each_column_base(term, row) { }
 
     T get_row() {
-        return static_cast<actual_type_t<T>*>(this->m_term.ptr)[this->m_row];
+        return static_cast<actual_type_t<T>*>(this->term_.ptr)[this->row_];
     }  
 };
 
@@ -25187,8 +24201,8 @@ struct each_column<T, if_t< is_pointer<T>::value &&
         : each_column_base(term, row) { }
 
     actual_type_t<T> get_row() {
-        if (this->m_term.ptr) {
-            return &static_cast<actual_type_t<T>>(this->m_term.ptr)[this->m_row];
+        if (this->term_.ptr) {
+            return &static_cast<actual_type_t<T>>(this->term_.ptr)[this->row_];
         } else {
             // optional argument doesn't have a value
             return nullptr;
@@ -25211,7 +24225,7 @@ struct each_ref_column : public each_column<T> {
             // This check only happens when the current table being iterated
             // over caused the query to match a reference. The check is
             // performed once per iterated table.
-            this->m_row = 0;
+            this->row_ = 0;
         }
     }
 };
@@ -25235,10 +24249,10 @@ struct each_delegate : public delegate {
 
     template < if_not_t< is_same< decay_t<Func>, decay_t<Func>& >::value > = 0>
     explicit each_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     explicit each_delegate(const Func& func) noexcept 
-        : m_func(func) { }
+        : func_(func) { }
 
     // Invoke object directly. This operation is useful when the calling
     // function has just constructed the delegate, such as what happens when
@@ -25249,10 +24263,10 @@ struct each_delegate : public delegate {
         iter->flags |= EcsIterCppEach;
 
         if (terms.populate(iter)) {
-            invoke_callback< each_ref_column >(iter, m_func, 0, terms.m_terms);
+            invoke_callback< each_ref_column >(iter, func_, 0, terms.terms_);
         } else {
-            invoke_callback< each_column >(iter, m_func, 0, terms.m_terms);
-        }   
+            invoke_callback< each_column >(iter, func_, 0, terms.terms_);
+        }
     }
 
     // Static function that can be used as callback for systems/triggers
@@ -25389,7 +24403,7 @@ struct each_delegate : public delegate {
             iter, func, index + 1, columns, comps..., columns[index]);
     }    
 
-    Func m_func;
+    Func func_;
 };
 
 template <typename Func, typename ... Components>
@@ -25411,10 +24425,10 @@ struct find_delegate : public delegate {
 
     template < if_not_t< is_same< decay_t<Func>, decay_t<Func>& >::value > = 0>
     explicit find_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     explicit find_delegate(const Func& func) noexcept 
-        : m_func(func) { }
+        : func_(func) { }
 
     // Invoke object directly. This operation is useful when the calling
     // function has just constructed the delegate, such as what happens when
@@ -25423,9 +24437,9 @@ struct find_delegate : public delegate {
         term_ptrs<Components...> terms;
 
         if (terms.populate(iter)) {
-            return invoke_callback< each_ref_column >(iter, m_func, 0, terms.m_terms);
+            return invoke_callback< each_ref_column >(iter, func_, 0, terms.terms_);
         } else {
-            return invoke_callback< each_column >(iter, m_func, 0, terms.m_terms);
+            return invoke_callback< each_column >(iter, func_, 0, terms.terms_);
         }   
     }
 
@@ -25543,7 +24557,7 @@ struct find_delegate : public delegate {
             iter, func, index + 1, columns, comps..., columns[index]);
     }
 
-    Func m_func;
+    Func func_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -25560,10 +24574,10 @@ struct iter_delegate : delegate {
 public:
     template < if_not_t< is_same< decay_t<Func>, decay_t<Func>& >::value > = 0>
     explicit iter_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     explicit iter_delegate(const Func& func) noexcept 
-        : m_func(func) { }
+        : func_(func) { }
 
     // Invoke object directly. This operation is useful when the calling
     // function has just constructed the delegate, such as what happens when
@@ -25571,7 +24585,7 @@ struct iter_delegate : delegate {
     void invoke(ecs_iter_t *iter) const {
         term_ptrs<Components...> terms;
         terms.populate(iter);
-        invoke_callback(iter, m_func, 0, terms.m_terms);
+        invoke_callback(iter, func_, 0, terms.terms_);
     }
 
     // Static function that can be used as callback for systems/triggers
@@ -25627,7 +24641,7 @@ struct iter_delegate : delegate {
             columns[index]);
     }
 
-    Func m_func;
+    Func func_;
 };
 
 
@@ -25638,7 +24652,7 @@ struct iter_delegate : delegate {
 template <typename Func>
 struct entity_observer_delegate : delegate {
     explicit entity_observer_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     // Static function that can be used as callback for systems/triggers
     static void run(ecs_iter_t *iter) {
@@ -25649,23 +24663,23 @@ struct entity_observer_delegate : delegate {
     static void invoke(ecs_iter_t *iter) {
         auto self = static_cast<const entity_observer_delegate*>(iter->binding_ctx);
         ecs_assert(self != nullptr, ECS_INTERNAL_ERROR, NULL);
-        self->m_func(flecs::entity(iter->world, ecs_field_src(iter, 1)));
+        self->func_(flecs::entity(iter->world, ecs_field_src(iter, 0)));
     }
 
     template <typename F, if_t<arity<F>::value == 0> = 0>
     static void invoke(ecs_iter_t *iter) {
         auto self = static_cast<const entity_observer_delegate*>(iter->binding_ctx);
         ecs_assert(self != nullptr, ECS_INTERNAL_ERROR, NULL);
-        self->m_func();
+        self->func_();
     }
 
-    Func m_func;
+    Func func_;
 };
 
 template <typename Func, typename Event>
 struct entity_payload_observer_delegate : delegate {
     explicit entity_payload_observer_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     // Static function that can be used as callback for systems/triggers
     static void run(ecs_iter_t *iter) {
@@ -25682,7 +24696,7 @@ struct entity_payload_observer_delegate : delegate {
             "entity observer invoked without payload");
 
         Event *data = static_cast<Event*>(iter->param);
-        self->m_func(*data);
+        self->func_(*data);
     }
 
     template <typename F, if_t<arity<F>::value == 2> = 0>
@@ -25694,10 +24708,10 @@ struct entity_payload_observer_delegate : delegate {
             "entity observer invoked without payload");
 
         Event *data = static_cast<Event*>(iter->param);
-        self->m_func(flecs::entity(iter->world, ecs_field_src(iter, 1)), *data);
+        self->func_(flecs::entity(iter->world, ecs_field_src(iter, 0)), *data);
     }
 
-    Func m_func;
+    Func func_;
 };
 
 
@@ -25743,7 +24757,7 @@ struct entity_with_delegate_impl<arg_list<Args ...>> {
         /* Get column indices for components */
         ColumnArray columns ({
             ecs_table_get_column_index(real_world, table, 
-                _::cpp_type<Args>().id(world))...
+                _::type<Args>().id(world))...
         });
 
         /* Get pointers for columns for entity */
@@ -25764,7 +24778,7 @@ struct entity_with_delegate_impl<arg_list<Args ...>> {
         size_t i = 0;
         DummyArray dummy ({
             (ptrs[i ++] = ecs_ensure_id(world, e, 
-                _::cpp_type<Args>().id(world)), 0)...
+                _::type<Args>().id(world)), 0)...
         });
 
         return true;
@@ -25913,1649 +24927,1700 @@ struct entity_with_delegate_impl<arg_list<Args ...>> {
     template <typename Func, typename ... TArgs, 
         if_t<sizeof...(TArgs) == sizeof...(Args)> = 0>
     static void invoke_callback(
-        const Func& f, size_t, ArrayType&, TArgs&& ... comps) 
-    {
-        f(*static_cast<typename base_arg_type<Args>::type*>(comps)...);
-    }
-
-    template <typename Func, typename ... TArgs, 
-        if_t<sizeof...(TArgs) != sizeof...(Args)> = 0>
-    static void invoke_callback(const Func& f, size_t arg, ArrayType& ptrs, 
-        TArgs&& ... comps) 
-    {
-        invoke_callback(f, arg + 1, ptrs, comps..., ptrs[arg]);
-    }
-};
-
-template <typename Func, typename U = int>
-struct entity_with_delegate {
-    static_assert(function_traits<Func>::value, "type is not callable");
-};
-
-template <typename Func>
-struct entity_with_delegate<Func, if_t< is_callable<Func>::value > >
-    : entity_with_delegate_impl< arg_list_t<Func> >
-{
-    static_assert(function_traits<Func>::arity > 0,
-        "function must have at least one argument");
-};
-
-} // namespace _
-
-// Experimental: allows using the each delegate for use cases outside of flecs
-template <typename Func, typename ... Args>
-using delegate = _::each_delegate<typename std::decay<Func>::type, Args...>;
-
-} // namespace flecs
-
-/**
- * @file addons/cpp/utils/iterable.hpp
- * @brief Base class for iterable objects, like queries.
- */
-
-namespace flecs {
-
-template <typename ... Components>
-struct iter_iterable;
-
-template <typename ... Components>
-struct page_iterable;
-
-template <typename ... Components>
-struct worker_iterable; 
-
-template <typename ... Components>
-struct iterable {
-
-    /** Each iterator.
-     * The "each" iterator accepts a function that is invoked for each matching
-     * entity. The following function signatures are valid:
-     *  - func(flecs::entity e, Components& ...)
-     *  - func(flecs::iter& it, size_t index, Components& ....)
-     *  - func(Components& ...)
-     * 
-     * Each iterators are automatically instanced.
-     */
-    template <typename Func>
-    void each(Func&& func) const {
-        each(nullptr, FLECS_FWD(func));
-    }
-
-    template <typename Func>
-    void each(flecs::world_t *world, Func&& func) const {
-        iterate<_::each_delegate>(world, FLECS_FWD(func), 
-            this->next_each_action());
-    }
-
-    template <typename Func>
-    void each(flecs::iter& it, Func&& func) const {
-        iterate<_::each_delegate>(it.world(), FLECS_FWD(func),
-            this->next_each_action());
-    }
-
-    template <typename Func>
-    void each(flecs::entity e, Func&& func) const {
-        iterate<_::each_delegate>(e.world(), FLECS_FWD(func), 
-            this->next_each_action());
-    }
-
-    template <typename Func>
-    flecs::entity find(Func&& func) const {
-        return iterate_find<_::find_delegate>(nullptr, FLECS_FWD(func), 
-            this->next_each_action());
-    }
-
-    /** Iter iterator.
-     * The "iter" iterator accepts a function that is invoked for each matching
-     * table. The following function signatures are valid:
-     *  - func(flecs::iter& it, Components* ...)
-     *  - func(Components& ...)
-     * 
-     * Iter iterators are not automatically instanced. When a result contains
-     * shared components, entities of the result will be iterated one by one.
-     * This ensures that applications can't accidentally read out of bounds by
-     * accessing a shared component as an array.
-     */
-    template <typename Func>
-    void iter(Func&& func) const { 
-        iterate<_::iter_delegate>(nullptr, FLECS_FWD(func), 
-            this->next_action());
-    }
-
-    template <typename Func>
-    void iter(flecs::world_t *world, Func&& func) const {
-        iterate<_::iter_delegate>(world, FLECS_FWD(func), 
-            this->next_action());
-    }
-
-    template <typename Func>
-    void iter(flecs::iter& it, Func&& func) const {
-        iterate<_::iter_delegate>(it.world(), FLECS_FWD(func),
-            this->next_action());
-    }
-
-    template <typename Func>
-    void iter(flecs::entity e, Func&& func) const {
-        iterate<_::iter_delegate>(e.world(), FLECS_FWD(func), 
-            this->next_action());
-    }
-
-    /** Create iterator.
-     * Create an iterator object that can be modified before iterating.
-     */
-    iter_iterable<Components...> iter(flecs::world_t *world = nullptr) const;
-
-    /** Page iterator.
-     * Create an iterator that limits the returned entities with offset/limit.
-     * 
-     * @param offset How many entities to skip.
-     * @param limit The maximum number of entities to return.
-     * @return Iterable that can be iterated with each/iter.
-     */
-    page_iterable<Components...> page(int32_t offset, int32_t limit);
-
-    /** Worker iterator.
-     * Create an iterator that divides the number of matched entities across
-     * a number of resources.
-     * 
-     * @param index The index of the current resource.
-     * @param count The total number of resources to divide entities between.
-     * @return Iterable that can be iterated with each/iter.
-     */
-    worker_iterable<Components...> worker(int32_t index, int32_t count);
-
-    /** Return number of entities matched by iterable. */
-    int32_t count() const {
-        return this->iter().count();
-    }
-
-    /** Return whether iterable has any matches. */
-    bool is_true() const {
-        return this->iter().is_true();
-    }
-
-    /** Return first entity matched by iterable. */
-    flecs::entity first() const {
-        return this->iter().first();
-    }
-
-    virtual ~iterable() { }
-protected:
-    friend iter_iterable<Components...>;
-    friend page_iterable<Components...>;
-    friend worker_iterable<Components...>;
-
-    virtual ecs_iter_t get_iter(flecs::world_t *stage) const = 0;
-    virtual ecs_iter_next_action_t next_action() const = 0;
-    virtual ecs_iter_next_action_t next_each_action() const = 0;
-
-    template < template<typename Func, typename ... Comps> class Delegate, typename Func, typename NextFunc, typename ... Args>
-    void iterate(flecs::world_t *stage, Func&& func, NextFunc next, Args &&... args) const {
-        ecs_iter_t it = this->get_iter(stage);
-        if (Delegate<Func, Components...>::instanced()) {
-            ECS_BIT_SET(it.flags, EcsIterIsInstanced);
-        }
+        const Func& f, size_t, ArrayType&, TArgs&& ... comps) 
+    {
+        f(*static_cast<typename base_arg_type<Args>::type*>(comps)...);
+    }
 
-        while (next(&it, FLECS_FWD(args)...)) {
-            Delegate<Func, Components...>(func).invoke(&it);
-        }
+    template <typename Func, typename ... TArgs, 
+        if_t<sizeof...(TArgs) != sizeof...(Args)> = 0>
+    static void invoke_callback(const Func& f, size_t arg, ArrayType& ptrs, 
+        TArgs&& ... comps) 
+    {
+        invoke_callback(f, arg + 1, ptrs, comps..., ptrs[arg]);
     }
+};
 
-    template < template<typename Func, typename ... Comps> class Delegate, typename Func, typename NextFunc, typename ... Args>
-    flecs::entity iterate_find(flecs::world_t *stage, Func&& func, NextFunc next, Args &&... args) const {
-        ecs_iter_t it = this->get_iter(stage);
-        if (Delegate<Func, Components...>::instanced()) {
-            ECS_BIT_SET(it.flags, EcsIterIsInstanced);
-        }
+template <typename Func, typename U = int>
+struct entity_with_delegate {
+    static_assert(function_traits<Func>::value, "type is not callable");
+};
 
-        flecs::entity result;
-        while (!result && next(&it, FLECS_FWD(args)...)) {
-            result = Delegate<Func, Components...>(func).invoke(&it);
-        }
-        if (result) {
-            ecs_iter_fini(&it);
-        }
-        return result;
-    }
+template <typename Func>
+struct entity_with_delegate<Func, if_t< is_callable<Func>::value > >
+    : entity_with_delegate_impl< arg_list_t<Func> >
+{
+    static_assert(function_traits<Func>::arity > 0,
+        "function must have at least one argument");
 };
 
-template <typename ... Components>
-struct iter_iterable final : iterable<Components...> {
-    template <typename Iterable>
-    iter_iterable(Iterable *it, flecs::world_t *world) 
-    {
-        m_it = it->get_iter(world);
-        m_next = it->next_action();
-        m_next_each = it->next_action();
-    }
+} // namespace _
 
-    iter_iterable<Components...>& set_var(int var_id, flecs::entity_t value) {
-        ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, 0);
-        ecs_iter_set_var(&m_it, var_id, value);
-        return *this;
-    }
+// Experimental: allows using the each delegate for use cases outside of flecs
+template <typename Func, typename ... Args>
+using delegate = _::each_delegate<typename std::decay<Func>::type, Args...>;
+
+} // namespace flecs
 
-#   ifdef FLECS_RULES
 /**
- * @file addons/cpp/mixins/rule/iterable.inl
- * @brief Rule iterable mixin.
+ * @file addons/cpp/component.hpp
+ * @brief Registering/obtaining info from components.
  */
 
+#pragma once
+
+#include <ctype.h>
+#include <stdio.h>
+
 /**
- * @memberof flecs::iter
- * @ingroup cpp_addons_rules
+ * @defgroup cpp_components Components
+ * @ingroup cpp_core
+ * Registering and working with components.
  *
  * @{
  */
 
-iter_iterable<Components...>& set_var(const char *name, flecs::entity_t value) {
-    ecs_rule_iter_t *rit = &m_it.priv.iter.rule;
-    int var_id = ecs_rule_find_var(rit->rule, name);
-    ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
-    ecs_iter_set_var(&m_it, var_id, value);
-    return *this;
+namespace flecs {
+
+namespace _ {
+
+// Trick to obtain typename from type, as described here
+// https://blog.molecular-matters.com/2015/12/11/getting-the-type-of-a-template-argument-as-string-without-rtti/
+//
+// The code from the link has been modified to work with more types, and across
+// multiple compilers. The resulting string should be the same on all platforms
+// for all compilers.
+//
+
+#if defined(__GNUC__) || defined(_WIN32)
+template <typename T>
+inline static const char* type_name() {
+    static const size_t len = ECS_FUNC_TYPE_LEN(const char*, type_name, ECS_FUNC_NAME);
+    static char result[len + 1] = {};
+    static const size_t front_len = ECS_FUNC_NAME_FRONT(const char*, type_name);
+    return ecs_cpp_get_type_name(result, ECS_FUNC_NAME, len, front_len);
 }
+#else
+#error "implicit component registration not supported"
+#endif
 
-/** @} */
+// Translate a typename into a language-agnostic identifier. This allows for
+// registration of components/modules across language boundaries.
+template <typename T>
+inline static const char* symbol_name() {
+    static const size_t len = ECS_FUNC_TYPE_LEN(const char*, symbol_name, ECS_FUNC_NAME);
+    static char result[len + 1] = {};
+    return ecs_cpp_get_symbol_name(result, type_name<T>(), len);
+}
 
-#   endif
-#   ifdef FLECS_JSON
-/**
- * @file addons/cpp/mixins/json/iterable.inl
- * @brief JSON iterable mixin.
- */
+template <> inline const char* symbol_name<uint8_t>() {
+    return "u8";
+}
+template <> inline const char* symbol_name<uint16_t>() {
+    return "u16";
+}
+template <> inline const char* symbol_name<uint32_t>() {
+    return "u32";
+}
+template <> inline const char* symbol_name<uint64_t>() {
+    return "u64";
+}
+template <> inline const char* symbol_name<int8_t>() {
+    return "i8";
+}
+template <> inline const char* symbol_name<int16_t>() {
+    return "i16";
+}
+template <> inline const char* symbol_name<int32_t>() {
+    return "i32";
+}
+template <> inline const char* symbol_name<int64_t>() {
+    return "i64";
+}
+template <> inline const char* symbol_name<float>() {
+    return "f32";
+}
+template <> inline const char* symbol_name<double>() {
+    return "f64";
+}
 
-/** Serialize iterator result to JSON.
- * 
- * @memberof flecs::iter
- * @ingroup cpp_addons_json
- */
-flecs::string to_json(flecs::iter_to_json_desc_t *desc = nullptr) {
-    char *json = ecs_iter_to_json(m_it.real_world, &m_it, desc);
-    return flecs::string(json);
+// If type is trivial, don't register lifecycle actions. While the functions
+// that obtain the lifecycle callback do detect whether the callback is required
+// adding a special case for trivial types eases the burden a bit on the
+// compiler as it reduces the number of templates to evaluate.
+template<typename T, enable_if_t<
+    std::is_trivial<T>::value == true
+        >* = nullptr>
+void register_lifecycle_actions(ecs_world_t*, ecs_entity_t) { }
+
+// If the component is non-trivial, register component lifecycle actions.
+// Depending on the type not all callbacks may be available.
+template<typename T, enable_if_t<
+    std::is_trivial<T>::value == false
+        >* = nullptr>
+void register_lifecycle_actions(
+    ecs_world_t *world,
+    ecs_entity_t component)
+{
+    ecs_type_hooks_t cl{};
+    cl.ctor = ctor<T>();
+    cl.dtor = dtor<T>();
+
+    cl.copy = copy<T>();
+    cl.copy_ctor = copy_ctor<T>();
+    cl.move = move<T>();
+    cl.move_ctor = move_ctor<T>();
+
+    cl.ctor_move_dtor = ctor_move_dtor<T>();
+    cl.move_dtor = move_dtor<T>();
+
+    ecs_set_hooks_id( world, component, &cl);
 }
 
-#   endif
+// Class that manages component ids across worlds & binaries.
+// The type class stores the component id for a C++ type in a static global
+// variable that is shared between worlds. Whenever a component is used this
+// class will check if it already has been registered (has the global id been
+// set), and if not, register the component with the world.
+//
+// If the id has been set, the class will ensure it is known by the world. If it
+// is not known the component has been registered by another world and will be
+// registered with the world using the same id. If the id does exist, the class
+// will register it as a component, and verify whether the input is consistent.
+template <typename T>
+struct cpp_type_impl {
+    static_assert(is_pointer<T>::value == false,
+        "pointer types are not allowed for components");
 
-    // Return total number of entities in result.
-    int32_t count() {
-        int32_t result = 0;
-        while (m_next_each(&m_it)) {
-            result += m_it.count;
+    // Initialize component identifier
+    static void init(
+        entity_t entity,
+        bool allow_tag = true)
+    {
+        if (s_reset_count != ecs_cpp_reset_count_get()) {
+            reset();
         }
-        return result;
-    }
 
-    // Returns true if iterator yields at least once result.
-    bool is_true() {
-        bool result = m_next_each(&m_it);
-        if (result) {
-            ecs_iter_fini(&m_it);
+        // If an identifier was already set, check for consistency
+        if (s_id) {
+            ecs_assert(s_id == entity, ECS_INCONSISTENT_COMPONENT_ID,
+                type_name<T>());
+            ecs_assert(allow_tag == s_allow_tag, ECS_INVALID_PARAMETER, NULL);
+
+            // Component was already registered and data is consistent with new
+            // identifier, so nothing else to be done.
+            return;
         }
-        return result;
-    }
 
-    // Return first matching entity.
-    flecs::entity first() {
-        flecs::entity result;
-        if (m_next_each(&m_it) && m_it.count) {
-            result = flecs::entity(m_it.world, m_it.entities[0]);
-            ecs_iter_fini(&m_it);
+        // Component wasn't registered yet, set the values. Register component
+        // name as the fully qualified flecs path.
+        s_id = entity;
+        s_allow_tag = allow_tag;
+        s_size = sizeof(T);
+        s_alignment = alignof(T);
+        if (is_empty<T>::value && allow_tag) {
+            s_size = 0;
+            s_alignment = 0;
         }
-        return result;
+
+        s_reset_count = ecs_cpp_reset_count_get();
     }
 
-    // Limit results to tables with specified group id (grouped queries only)
-    iter_iterable<Components...>& set_group(uint64_t group_id) {
-        ecs_query_set_group(&m_it, group_id);
-        return *this;
-    }
+    // Obtain a component identifier for explicit component registration.
+    static entity_t id_explicit(world_t *world = nullptr,
+        const char *name = nullptr, bool allow_tag = true, flecs::id_t id = 0,
+        bool is_component = true, bool *existing = nullptr)
+    {
+        if (!s_id) {
+            // If no world was provided the component cannot be registered
+            ecs_assert(world != nullptr, ECS_COMPONENT_NOT_REGISTERED, name);
+        } else {
+            ecs_assert(!id || s_id == id, ECS_INCONSISTENT_COMPONENT_ID, NULL);
+        }
+
+        // If no id has been registered yet for the component (indicating the
+        // component has not yet been registered, or the component is used
+        // across more than one binary), or if the id does not exists in the
+        // world (indicating a multi-world application), register it.
+        if (!s_id || (world && !ecs_exists(world, s_id))) {
+            init(s_id ? s_id : id, allow_tag);
+
+            ecs_assert(!id || s_id == id, ECS_INTERNAL_ERROR, NULL);
+
+            const char *symbol = nullptr;
+            if (id) {
+                symbol = ecs_get_symbol(world, id);
+            }
+            if (!symbol) {
+                symbol = symbol_name<T>();
+            }
+
+            entity_t entity = ecs_cpp_component_register_explicit(
+                    world, s_id, id, name, type_name<T>(), symbol,
+                        s_size, s_alignment, is_component, existing);
 
-    // Limit results to tables with specified group id (grouped queries only)
-    template <typename Group>
-    iter_iterable<Components...>& set_group() {
-        ecs_query_set_group(&m_it, _::cpp_type<Group>().id(m_it.real_world));
-        return *this;
-    }
+            s_id = entity;
 
-protected:
-    ecs_iter_t get_iter(flecs::world_t *world) const {
-        if (world) {
-            ecs_iter_t result = m_it;
-            result.world = world;
-            return result;
+            // If component is enum type, register constants
+            #if FLECS_CPP_ENUM_REFLECTION_SUPPORT
+            _::init_enum<T>(world, entity);
+            #endif
         }
-        return m_it;
-    }
 
-    ecs_iter_next_action_t next_action() const {
-        return m_next;
-    }
+        // By now the identifier must be valid and known with the world.
+        ecs_assert(s_id != 0 && ecs_exists(world, s_id),
+            ECS_INTERNAL_ERROR, NULL);
 
-    ecs_iter_next_action_t next_each_action() const {
-        return m_next_each;
+        return s_id;
     }
 
-private:
-    ecs_iter_t m_it;
-    ecs_iter_next_action_t m_next;
-    ecs_iter_next_action_t m_next_each;
-};
+    // Obtain a component identifier for implicit component registration. This
+    // is almost the same as id_explicit, except that this operation
+    // automatically registers lifecycle callbacks.
+    // Additionally, implicit registration temporarily resets the scope & with
+    // state of the world, so that the component is not implicitly created with
+    // the scope/with of the code it happens to be first used by.
+    static id_t id(world_t *world = nullptr, const char *name = nullptr,
+        bool allow_tag = true)
+    {
+        // If no id has been registered yet, do it now.
+#ifndef FLECS_CPP_NO_AUTO_REGISTRATION
+        if (!registered(world)) {
+            ecs_entity_t prev_scope = 0;
+            ecs_id_t prev_with = 0;
 
-template <typename ... Components>
-iter_iterable<Components...> iterable<Components...>::iter(flecs::world_t *world) const
-{
-    return iter_iterable<Components...>(this, world);
-}
+            if (world) {
+                prev_scope = ecs_set_scope(world, 0);
+                prev_with = ecs_set_with(world, 0);
+            }
 
-template <typename ... Components>
-struct page_iterable final : iterable<Components...> {
-    template <typename Iterable>
-    page_iterable(int32_t offset, int32_t limit, Iterable *it) 
-        : m_offset(offset)
-        , m_limit(limit)
-    {
-        m_chain_it = it->get_iter(nullptr);
-    }
+            // This will register a component id, but will not register
+            // lifecycle callbacks.
+            bool existing;
+            id_explicit(world, name, allow_tag, 0, true, &existing);
 
-protected:
-    ecs_iter_t get_iter(flecs::world_t*) const {
-        return ecs_page_iter(&m_chain_it, m_offset, m_limit);
-    }
+            // Register lifecycle callbacks, but only if the component has a
+            // size. Components that don't have a size are tags, and tags don't
+            // require construction/destruction/copy/move's.
+            if (size() && !existing) {
+                register_lifecycle_actions<T>(world, s_id);
+            }
 
-    ecs_iter_next_action_t next_action() const {
-        return ecs_page_next;
-    }
+            if (prev_with) {
+                ecs_set_with(world, prev_with);
+            }
+            if (prev_scope) {
+                ecs_set_scope(world, prev_scope);
+            }
+        }
+#else
+        (void)world;
+        (void)name;
+        (void)allow_tag;
 
-    ecs_iter_next_action_t next_each_action() const {
-        return ecs_page_next;
-    }
+        ecs_assert(registered(world), ECS_INVALID_OPERATION, 
+            "component '%s' was not registered before use",
+            type_name<T>());
+#endif
 
-private:
-    ecs_iter_t m_chain_it;
-    int32_t m_offset;
-    int32_t m_limit;
-};
+        // By now we should have a valid identifier
+        ecs_assert(s_id != 0, ECS_INTERNAL_ERROR, NULL);
 
-template <typename ... Components>
-page_iterable<Components...> iterable<Components...>::page(
-    int32_t offset, 
-    int32_t limit) 
-{
-    return page_iterable<Components...>(offset, limit, this);
-}
+        return s_id;
+    }
 
-template <typename ... Components>
-struct worker_iterable final : iterable<Components...> {
-    worker_iterable(int32_t offset, int32_t limit, iterable<Components...> *it) 
-        : m_offset(offset)
-        , m_limit(limit)
-    {
-        m_chain_it = it->get_iter(nullptr);
+    // Return the size of a component.
+    static size_t size() {
+        ecs_assert(s_id != 0, ECS_INTERNAL_ERROR, NULL);
+        return s_size;
     }
 
-protected:
-    ecs_iter_t get_iter(flecs::world_t*) const {
-        return ecs_worker_iter(&m_chain_it, m_offset, m_limit);
+    // Return the alignment of a component.
+    static size_t alignment() {
+        ecs_assert(s_id != 0, ECS_INTERNAL_ERROR, NULL);
+        return s_alignment;
     }
 
-    ecs_iter_next_action_t next_action() const {
-        return ecs_worker_next;
+    // Was the component already registered.
+    static bool registered(flecs::world_t *world) {
+        if (s_reset_count != ecs_cpp_reset_count_get()) {
+            reset();
+        }
+        if (s_id == 0) {
+            return false;
+        }
+        if (world && !ecs_exists(world, s_id)) {
+            return false;
+        }
+        return true;
     }
 
-    ecs_iter_next_action_t next_each_action() const {
-        return ecs_worker_next;
+    // This function is only used to test cross-translation unit features. No
+    // code other than test cases should invoke this function.
+    static void reset() {
+        s_id = 0;
+        s_size = 0;
+        s_alignment = 0;
+        s_allow_tag = true;
     }
 
-private:
-    ecs_iter_t m_chain_it;
-    int32_t m_offset;
-    int32_t m_limit;
+    static entity_t s_id;
+    static size_t s_size;
+    static size_t s_alignment;
+    static bool s_allow_tag;
+    static int32_t s_reset_count;
 };
 
-template <typename ... Components>
-worker_iterable<Components...> iterable<Components...>::worker(
-    int32_t index, 
-    int32_t count) 
+// Global templated variables that hold component identifier and other info
+template <typename T> entity_t      cpp_type_impl<T>::s_id;
+template <typename T> size_t        cpp_type_impl<T>::s_size;
+template <typename T> size_t        cpp_type_impl<T>::s_alignment;
+template <typename T> bool          cpp_type_impl<T>::s_allow_tag( true );
+template <typename T> int32_t       cpp_type_impl<T>::s_reset_count;
+
+// Front facing class for implicitly registering a component & obtaining
+// static component data
+
+// Regular type
+template <typename T>
+struct type<T, if_not_t< is_pair<T>::value >>
+    : cpp_type_impl<base_type_t<T>> { };
+
+// Pair type
+template <typename T>
+struct type<T, if_t< is_pair<T>::value >>
 {
-    return worker_iterable<Components...>(index, count, this);
-}
+    // Override id method to return id of pair
+    static id_t id(world_t *world = nullptr) {
+        return ecs_pair(
+            type< pair_first_t<T> >::id(world),
+            type< pair_second_t<T> >::id(world));
+    }
+};
 
-}
+} // namespace _
 
-/**
- * @file addons/cpp/component.hpp
- * @brief Registering/obtaining info from components.
+/** Untyped component class.
+ * Generic base class for flecs::component.
+ *
+ * @ingroup cpp_components
  */
+struct untyped_component : entity {
+    using entity::entity;
 
-#pragma once
-
-#include <ctype.h>
-#include <stdio.h>
+#   ifdef FLECS_META
+/**
+ * @file addons/cpp/mixins/meta/untyped_component.inl
+ * @brief Meta component mixin.
+ */
 
 /**
- * @defgroup cpp_components Components
- * @ingroup cpp_core
- * Registering and working with components.
- *
+ * @memberof flecs::component
+ * @ingroup cpp_addons_meta
+ * 
  * @{
  */
 
-namespace flecs {
+/** Add member with unit. */
+untyped_component& member(flecs::entity_t type_id, flecs::entity_t unit, const char *name, int32_t count = 0, size_t offset = 0) {
+    ecs_entity_desc_t desc = {};
+    desc.name = name;
+    desc.parent = id_;
+    ecs_entity_t eid = ecs_entity_init(world_, &desc);
+    ecs_assert(eid != 0, ECS_INTERNAL_ERROR, NULL);
 
-namespace _ {
+    flecs::entity e(world_, eid);
 
-// Trick to obtain typename from type, as described here
-// https://blog.molecular-matters.com/2015/12/11/getting-the-type-of-a-template-argument-as-string-without-rtti/
-//
-// The code from the link has been modified to work with more types, and across
-// multiple compilers. The resulting string should be the same on all platforms
-// for all compilers.
-//
+    Member m = {};
+    m.type = type_id;
+    m.unit = unit;
+    m.count = count;
+    m.offset = static_cast<int32_t>(offset);
+    e.set<Member>(m);
 
-#if defined(__GNUC__) || defined(_WIN32)
-template <typename T>
-inline static const char* type_name() {
-    static const size_t len = ECS_FUNC_TYPE_LEN(const char*, type_name, ECS_FUNC_NAME);
-    static char result[len + 1] = {};
-    static const size_t front_len = ECS_FUNC_NAME_FRONT(const char*, type_name);
-    return ecs_cpp_get_type_name(result, ECS_FUNC_NAME, len, front_len);
+    return *this;
 }
-#else
-#error "implicit component registration not supported"
-#endif
 
-// Translate a typename into a language-agnostic identifier. This allows for
-// registration of components/modules across language boundaries.
-template <typename T>
-inline static const char* symbol_name() {
-    static const size_t len = ECS_FUNC_TYPE_LEN(const char*, symbol_name, ECS_FUNC_NAME);
-    static char result[len + 1] = {};
-    return ecs_cpp_get_symbol_name(result, type_name<T>(), len);
+/** Add member. */
+untyped_component& member(flecs::entity_t type_id, const char* name, int32_t count = 0, size_t offset = 0) {
+    return member(type_id, 0, name, count, offset);
 }
 
-template <> inline const char* symbol_name<uint8_t>() {
-    return "u8";
+/** Add member. */
+template <typename MemberType>
+untyped_component& member(const char *name, int32_t count = 0, size_t offset = 0) {
+    flecs::entity_t type_id = _::type<MemberType>::id(world_);
+    return member(type_id, name, count, offset);
 }
-template <> inline const char* symbol_name<uint16_t>() {
-    return "u16";
+
+/** Add member with unit. */
+template <typename MemberType>
+untyped_component& member(flecs::entity_t unit, const char *name, int32_t count = 0, size_t offset = 0) {
+    flecs::entity_t type_id = _::type<MemberType>::id(world_);
+    return member(type_id, unit, name, count, offset);
 }
-template <> inline const char* symbol_name<uint32_t>() {
-    return "u32";
+
+/** Add member with unit. */
+template <typename MemberType, typename UnitType>
+untyped_component& member(const char *name, int32_t count = 0, size_t offset = 0) {
+    flecs::entity_t type_id = _::type<MemberType>::id(world_);
+    flecs::entity_t unit_id = _::type<UnitType>::id(world_);
+    return member(type_id, unit_id, name, count, offset);
 }
-template <> inline const char* symbol_name<uint64_t>() {
-    return "u64";
+
+/** Add member using pointer-to-member. */
+template <typename MemberType, typename ComponentType, typename RealType = typename std::remove_extent<MemberType>::type>
+untyped_component& member(const char* name, const MemberType ComponentType::* ptr) {
+    flecs::entity_t type_id = _::type<RealType>::id(world_);
+    size_t offset = reinterpret_cast<size_t>(&(static_cast<ComponentType*>(nullptr)->*ptr));
+    return member(type_id, name, std::extent<MemberType>::value, offset);
 }
-template <> inline const char* symbol_name<int8_t>() {
-    return "i8";
+
+/** Add member with unit using pointer-to-member. */
+template <typename MemberType, typename ComponentType, typename RealType = typename std::remove_extent<MemberType>::type>
+untyped_component& member(flecs::entity_t unit, const char* name, const MemberType ComponentType::* ptr) {
+    flecs::entity_t type_id = _::type<RealType>::id(world_);
+    size_t offset = reinterpret_cast<size_t>(&(static_cast<ComponentType*>(nullptr)->*ptr));
+    return member(type_id, unit, name, std::extent<MemberType>::value, offset);
 }
-template <> inline const char* symbol_name<int16_t>() {
-    return "i16";
+
+/** Add member with unit using pointer-to-member. */
+template <typename UnitType, typename MemberType, typename ComponentType, typename RealType = typename std::remove_extent<MemberType>::type>
+untyped_component& member(const char* name, const MemberType ComponentType::* ptr) {
+    flecs::entity_t type_id = _::type<RealType>::id(world_);
+    flecs::entity_t unit_id = _::type<UnitType>::id(world_);
+    size_t offset = reinterpret_cast<size_t>(&(static_cast<ComponentType*>(nullptr)->*ptr));
+    return member(type_id, unit_id, name, std::extent<MemberType>::value, offset);
 }
-template <> inline const char* symbol_name<int32_t>() {
-    return "i32";
+
+/** Add constant. */
+untyped_component& constant(const char *name, int32_t value) {
+    ecs_add_id(world_, id_, _::type<flecs::Enum>::id(world_));
+
+    ecs_entity_desc_t desc = {};
+    desc.name = name;
+    desc.parent = id_;
+    ecs_entity_t eid = ecs_entity_init(world_, &desc);
+    ecs_assert(eid != 0, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_set_id(world_, eid, 
+        ecs_pair(flecs::Constant, flecs::I32), sizeof(int32_t),
+        &value);
+
+    return *this;
 }
-template <> inline const char* symbol_name<int64_t>() {
-    return "i64";
+
+/** Add bitmask constant. */
+untyped_component& bit(const char *name, uint32_t value) {
+    ecs_add_id(world_, id_, _::type<flecs::Bitmask>::id(world_));
+
+    ecs_entity_desc_t desc = {};
+    desc.name = name;
+    desc.parent = id_;
+    ecs_entity_t eid = ecs_entity_init(world_, &desc);
+    ecs_assert(eid != 0, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_set_id(world_, eid, 
+        ecs_pair(flecs::Constant, flecs::U32), sizeof(uint32_t),
+        &value);
+
+    return *this;
 }
-template <> inline const char* symbol_name<float>() {
-    return "f32";
+
+/** Register array metadata for component */
+template <typename Elem>
+untyped_component& array(int32_t elem_count) {
+    ecs_array_desc_t desc = {};
+    desc.entity = id_;
+    desc.type = _::type<Elem>::id(world_);
+    desc.count = elem_count;
+    ecs_array_init(world_, &desc);
+    return *this;
 }
-template <> inline const char* symbol_name<double>() {
-    return "f64";
+
+/** Add member value range */
+untyped_component& range(double min, double max) {
+    const flecs::member_t *m = ecs_cpp_last_member(world_, id_);
+    if (!m) {
+        return *this;
+    }
+
+    flecs::world w(world_);
+    flecs::entity me = w.entity(m->member);
+
+    // Don't use C++ ensure because Unreal defines a macro called ensure
+    flecs::MemberRanges *mr = static_cast<flecs::MemberRanges*>(
+        ecs_ensure_id(w, me, w.id<flecs::MemberRanges>()));
+    mr->value.min = min;
+    mr->value.max = max;
+    me.modified<flecs::MemberRanges>();
+    return *this;
 }
 
-// If type is trivial, don't register lifecycle actions. While the functions
-// that obtain the lifecycle callback do detect whether the callback is required
-// adding a special case for trivial types eases the burden a bit on the
-// compiler as it reduces the number of templates to evaluate.
-template<typename T, enable_if_t<
-    std::is_trivial<T>::value == true
-        >* = nullptr>
-void register_lifecycle_actions(ecs_world_t*, ecs_entity_t) { }
+/** Add member warning range */
+untyped_component& warning_range(double min, double max) {
+    const flecs::member_t *m = ecs_cpp_last_member(world_, id_);
+    if (!m) {
+        return *this;
+    }
 
-// If the component is non-trivial, register component lifecycle actions.
-// Depending on the type not all callbacks may be available.
-template<typename T, enable_if_t<
-    std::is_trivial<T>::value == false
-        >* = nullptr>
-void register_lifecycle_actions(
-    ecs_world_t *world,
-    ecs_entity_t component)
-{
-    ecs_type_hooks_t cl{};
-    cl.ctor = ctor<T>();
-    cl.dtor = dtor<T>();
+    flecs::world w(world_);
+    flecs::entity me = w.entity(m->member);
 
-    cl.copy = copy<T>();
-    cl.copy_ctor = copy_ctor<T>();
-    cl.move = move<T>();
-    cl.move_ctor = move_ctor<T>();
+    // Don't use C++ ensure because Unreal defines a macro called ensure
+    flecs::MemberRanges *mr = static_cast<flecs::MemberRanges*>(
+        ecs_ensure_id(w, me, w.id<flecs::MemberRanges>()));
+    mr->warning.min = min;
+    mr->warning.max = max;
+    me.modified<flecs::MemberRanges>();
+    return *this;
+}
 
-    cl.ctor_move_dtor = ctor_move_dtor<T>();
-    cl.move_dtor = move_dtor<T>();
+/** Add member error range */
+untyped_component& error_range(double min, double max) {
+    const flecs::member_t *m = ecs_cpp_last_member(world_, id_);
+    if (!m) {
+        return *this;
+    }
 
-    ecs_set_hooks_id( world, component, &cl);
+    flecs::world w(world_);
+    flecs::entity me = w.entity(m->member);
+
+    // Don't use C++ ensure because Unreal defines a macro called ensure
+    flecs::MemberRanges *mr = static_cast<flecs::MemberRanges*>(ecs_ensure_id(
+        w, me, w.id<flecs::MemberRanges>()));
+    mr->error.min = min;
+    mr->error.max = max;
+    me.modified<flecs::MemberRanges>();
+    return *this;
 }
 
-// Class that manages component ids across worlds & binaries.
-// The cpp_type class stores the component id for a C++ type in a static global
-// variable that is shared between worlds. Whenever a component is used this
-// class will check if it already has been registered (has the global id been
-// set), and if not, register the component with the world.
-//
-// If the id has been set, the class will ensure it is known by the world. If it
-// is not known the component has been registered by another world and will be
-// registered with the world using the same id. If the id does exist, the class
-// will register it as a component, and verify whether the input is consistent.
-template <typename T>
-struct cpp_type_impl {
-    static_assert(is_pointer<T>::value == false,
-        "pointer types are not allowed for components");
-    // Initialize component identifier
-    static void init(
-        entity_t entity,
-        bool allow_tag = true)
-    {
-        if (s_reset_count != ecs_cpp_reset_count_get()) {
-            reset();
-        }
 
-        // If an identifier was already set, check for consistency
-        if (s_id) {
-            ecs_assert(s_id == entity, ECS_INCONSISTENT_COMPONENT_ID,
-                type_name<T>());
-            ecs_assert(allow_tag == s_allow_tag, ECS_INVALID_PARAMETER, NULL);
+/** @} */
 
-            // Component was already registered and data is consistent with new
-            // identifier, so nothing else to be done.
-            return;
-        }
+#   endif
+#   ifdef FLECS_METRICS
+/**
+ * @file addons/cpp/mixins/meta/untyped_component.inl
+ * @brief Metrics component mixin.
+ */
 
-        // Component wasn't registered yet, set the values. Register component
-        // name as the fully qualified flecs path.
-        s_id = entity;
-        s_allow_tag = allow_tag;
-        s_size = sizeof(T);
-        s_alignment = alignof(T);
-        if (is_empty<T>::value && allow_tag) {
-            s_size = 0;
-            s_alignment = 0;
-        }
+/**
+ * @memberof flecs::component
+ * @ingroup cpp_addons_metrics
+ * 
+ * @{
+ */
 
-        s_reset_count = ecs_cpp_reset_count_get();
-    }
+/** Register member as metric.
+ * When no explicit name is provided, this operation will derive the metric name
+ * from the member name. When the member name is "value", the operation will use
+ * the name of the component.
+ * 
+ * When the brief parameter is provided, it is set on the metric as if 
+ * set_doc_brief is used. The brief description can be obtained with 
+ * get_doc_brief.
+ * 
+ * @tparam Kind Metric kind (Counter, CounterIncrement or Gauge).
+ * @param parent Parent entity of the metric (optional).
+ * @param brief Description for metric (optional).
+ * @param name Name of metric (optional).
+ */
+template <typename Kind>
+untyped_component& metric(
+    flecs::entity_t parent = 0, 
+    const char *brief = nullptr, 
+    const char *name = nullptr);
 
-    // Obtain a component identifier for explicit component registration.
-    static entity_t id_explicit(world_t *world = nullptr,
-        const char *name = nullptr, bool allow_tag = true, flecs::id_t id = 0,
-        bool is_component = true, bool *existing = nullptr)
+/** @} */
+
+#   endif
+};
+
+/** Component class.
+ * Class used to register components and component metadata.
+ *
+ * @ingroup cpp_components
+ */
+template <typename T>
+struct component : untyped_component {
+    /** Register a component.
+     * If the component was already registered, this operation will return a handle
+     * to the existing component.
+     *
+     * @param world The world for which to register the component.
+     * @param name Optional name (overrides typename).
+     * @param allow_tag If true, empty types will be registered with size 0.
+     * @param id Optional id to register component with.
+     */
+    component(
+        flecs::world_t *world,
+        const char *name = nullptr,
+        bool allow_tag = true,
+        flecs::id_t id = 0)
     {
-        if (!s_id) {
-            // If no world was provided the component cannot be registered
-            ecs_assert(world != nullptr, ECS_COMPONENT_NOT_REGISTERED, name);
-        } else {
-            ecs_assert(!id || s_id == id, ECS_INCONSISTENT_COMPONENT_ID, NULL);
+        const char *n = name;
+        bool implicit_name = false;
+        if (!n) {
+            n = _::type_name<T>();
+
+            /* Keep track of whether name was explicitly set. If not, and the
+            * component was already registered, just use the registered name.
+            *
+            * The registered name may differ from the typename as the registered
+            * name includes the flecs scope. This can in theory be different from
+            * the C++ namespace though it is good practice to keep them the same */
+            implicit_name = true;
         }
 
-        // If no id has been registered yet for the component (indicating the
-        // component has not yet been registered, or the component is used
-        // across more than one binary), or if the id does not exists in the
-        // world (indicating a multi-world application), register it.
-        if (!s_id || (world && !ecs_exists(world, s_id))) {
-            init(s_id ? s_id : id, allow_tag);
+        if (_::type<T>::registered(world)) {
+            /* Obtain component id. Because the component is already registered,
+             * this operation does nothing besides returning the existing id */
+            id = _::type<T>::id_explicit(world, name, allow_tag, id);
 
-            ecs_assert(!id || s_id == id, ECS_INTERNAL_ERROR, NULL);
+            ecs_cpp_component_validate(world, id, n, _::symbol_name<T>(),
+                _::type<T>::size(),
+                _::type<T>::alignment(),
+                implicit_name);
+        } else {
+            /* If component is registered from an existing scope, ignore the
+             * namespace in the name of the component. */
+            if (implicit_name && (ecs_get_scope(world) != 0)) {
+                /* If the type is a template type, make sure to ignore ':'
+                 * inside the template parameter list. */
+                const char *start = strchr(n, '<'), *last_elem = NULL;
+                if (start) {
+                    const char *ptr = start;
+                    while (ptr[0] && (ptr[0] != ':') && (ptr > n)) {
+                        ptr --;
+                    }
+                    if (ptr[0] == ':') {
+                        last_elem = ptr;
+                    }
+                }
 
-            const char *symbol = nullptr;
-            if (id) {
-                symbol = ecs_get_symbol(world, id);
-            }
-            if (!symbol) {
-                symbol = symbol_name<T>();
+                if (last_elem) {
+                    name = last_elem + 1;
+                }
             }
 
-            entity_t entity = ecs_cpp_component_register_explicit(
-                    world, s_id, id, name, type_name<T>(), symbol,
-                        s_size, s_alignment, is_component, existing);
+            /* Find or register component */
+            bool existing;
+            id = ecs_cpp_component_register(world, id, n, _::symbol_name<T>(),
+                ECS_SIZEOF(T), ECS_ALIGNOF(T), implicit_name, &existing);
 
-            s_id = entity;
+            /* Initialize static component data */
+            id = _::type<T>::id_explicit(world, name, allow_tag, id);
 
-            // If component is enum type, register constants
-            #if FLECS_CPP_ENUM_REFLECTION_SUPPORT
-            _::init_enum<T>(world, entity);
-            #endif
+            /* Initialize lifecycle actions (ctor, dtor, copy, move) */
+            if (_::type<T>::size() && !existing) {
+                _::register_lifecycle_actions<T>(world, id);
+            }
         }
 
-        // By now the identifier must be valid and known with the world.
-        ecs_assert(s_id != 0 && ecs_exists(world, s_id),
-            ECS_INTERNAL_ERROR, NULL);
+        world_ = world;
+        id_ = id;
+    }
 
-        return s_id;
+    /** Register on_add hook. */
+    template <typename Func>
+    component<T>& on_add(Func&& func) {
+        using Delegate = typename _::each_delegate<typename std::decay<Func>::type, T>;
+        flecs::type_hooks_t h = get_hooks();
+        ecs_assert(h.on_add == nullptr, ECS_INVALID_OPERATION,
+            "on_add hook is already set");
+        BindingCtx *ctx = get_binding_ctx(h);
+        h.on_add = Delegate::run_add;
+        ctx->on_add = FLECS_NEW(Delegate)(FLECS_FWD(func));
+        ctx->free_on_add = reinterpret_cast<ecs_ctx_free_t>(
+            _::free_obj<Delegate>);
+        ecs_set_hooks_id(world_, id_, &h);
+        return *this;
     }
 
-    // Obtain a component identifier for implicit component registration. This
-    // is almost the same as id_explicit, except that this operation
-    // automatically registers lifecycle callbacks.
-    // Additionally, implicit registration temporarily resets the scope & with
-    // state of the world, so that the component is not implicitly created with
-    // the scope/with of the code it happens to be first used by.
-    static id_t id(world_t *world = nullptr, const char *name = nullptr,
-        bool allow_tag = true)
-    {
-        // If no id has been registered yet, do it now.
-#ifndef FLECS_CPP_NO_AUTO_REGISTRATION
-        if (!registered(world)) {
-            ecs_entity_t prev_scope = 0;
-            ecs_id_t prev_with = 0;
+    /** Register on_remove hook. */
+    template <typename Func>
+    component<T>& on_remove(Func&& func) {
+        using Delegate = typename _::each_delegate<
+            typename std::decay<Func>::type, T>;
+        flecs::type_hooks_t h = get_hooks();
+        ecs_assert(h.on_remove == nullptr, ECS_INVALID_OPERATION,
+            "on_remove hook is already set");
+        BindingCtx *ctx = get_binding_ctx(h);
+        h.on_remove = Delegate::run_remove;
+        ctx->on_remove = FLECS_NEW(Delegate)(FLECS_FWD(func));
+        ctx->free_on_remove = reinterpret_cast<ecs_ctx_free_t>(
+            _::free_obj<Delegate>);
+        ecs_set_hooks_id(world_, id_, &h);
+        return *this;
+    }
 
-            if (world) {
-                prev_scope = ecs_set_scope(world, 0);
-                prev_with = ecs_set_with(world, 0);
-            }
+    /** Register on_set hook. */
+    template <typename Func>
+    component<T>& on_set(Func&& func) {
+        using Delegate = typename _::each_delegate<
+            typename std::decay<Func>::type, T>;
+        flecs::type_hooks_t h = get_hooks();
+        ecs_assert(h.on_set == nullptr, ECS_INVALID_OPERATION,
+            "on_set hook is already set");
+        BindingCtx *ctx = get_binding_ctx(h);
+        h.on_set = Delegate::run_set;
+        ctx->on_set = FLECS_NEW(Delegate)(FLECS_FWD(func));
+        ctx->free_on_set = reinterpret_cast<ecs_ctx_free_t>(
+            _::free_obj<Delegate>);
+        ecs_set_hooks_id(world_, id_, &h);
+        return *this;
+    }
 
-            // This will register a component id, but will not register
-            // lifecycle callbacks.
-            bool existing;
-            id_explicit(world, name, allow_tag, 0, true, &existing);
+#   ifdef FLECS_META
 
-            // Register lifecycle callbacks, but only if the component has a
-            // size. Components that don't have a size are tags, and tags don't
-            // require construction/destruction/copy/move's.
-            if (size() && !existing) {
-                register_lifecycle_actions<T>(world, s_id);
-            }
+/** Register opaque type interface */
+template <typename Func>
+component& opaque(const Func& type_support) {
+    flecs::world world(world_);
+    auto ts = type_support(world);
+    ts.desc.entity = _::type<T>::id(world_);
+    ecs_opaque_init(world_, &ts.desc);
+    return *this;
+}
 
-            if (prev_with) {
-                ecs_set_with(world, prev_with);
-            }
-            if (prev_scope) {
-                ecs_set_scope(world, prev_scope);
-            }
-        }
-#else
-        (void)world;
-        (void)name;
-        (void)allow_tag;
+flecs::opaque<T> opaque(flecs::entity_t as_type) {
+    return flecs::opaque<T>(world_).as_type(as_type);
+}
 
-        ecs_assert(registered(world), ECS_INVALID_OPERATION,
-            "component '%s' was not registered before use",
-            type_name<T>());
-#endif
+flecs::opaque<T> opaque(flecs::entity as_type) {
+    return this->opaque(as_type.id());
+}
 
-        // By now we should have a valid identifier
-        ecs_assert(s_id != 0, ECS_INTERNAL_ERROR, NULL);
+flecs::opaque<T> opaque(flecs::untyped_component as_type) {
+    return this->opaque(as_type.id());
+}
 
-        return s_id;
-    }
+/** Return opaque type builder for collection type */
+template <typename ElemType>
+flecs::opaque<T, ElemType> opaque(flecs::id_t as_type) {
+    return flecs::opaque<T, ElemType>(world_).as_type(as_type);
+}
 
-    // Return the size of a component.
-    static size_t size() {
-        ecs_assert(s_id != 0, ECS_INTERNAL_ERROR, NULL);
-        return s_size;
-    }
+/** Add constant. */
+component<T>& constant(const char *name, T value) {
+    int32_t v = static_cast<int32_t>(value);
+    untyped_component::constant(name, v);
+    return *this;
+}
 
-    // Return the alignment of a component.
-    static size_t alignment() {
-        ecs_assert(s_id != 0, ECS_INTERNAL_ERROR, NULL);
-        return s_alignment;
-    }
+#   endif
 
-    // Was the component already registered.
-    static bool registered(flecs::world_t *world) {
-        if (s_reset_count != ecs_cpp_reset_count_get()) {
-            reset();
-        }
-        if (s_id == 0) {
-            return false;
-        }
-        if (world && !ecs_exists(world, s_id)) {
-            return false;
+private:
+    using BindingCtx = _::component_binding_ctx;
+
+    BindingCtx* get_binding_ctx(flecs::type_hooks_t& h){
+        BindingCtx *result = static_cast<BindingCtx*>(h.binding_ctx);
+        if (!result) {
+            result = FLECS_NEW(BindingCtx);
+            h.binding_ctx = result;
+            h.binding_ctx_free = reinterpret_cast<ecs_ctx_free_t>(
+                _::free_obj<BindingCtx>);
         }
-        return true;
+        return result;
     }
 
-    // This function is only used to test cross-translation unit features. No
-    // code other than test cases should invoke this function.
-    static void reset() {
-        s_id = 0;
-        s_size = 0;
-        s_alignment = 0;
-        s_allow_tag = true;
+    flecs::type_hooks_t get_hooks() {
+        const flecs::type_hooks_t* h = ecs_get_hooks_id(world_, id_);
+        if (h) {
+            return *h;
+        } else {
+            return {};
+        }
     }
-
-    static entity_t s_id;
-    static size_t s_size;
-    static size_t s_alignment;
-    static bool s_allow_tag;
-    static int32_t s_reset_count;
 };
 
-// Global templated variables that hold component identifier and other info
-template <typename T> entity_t      cpp_type_impl<T>::s_id;
-template <typename T> size_t        cpp_type_impl<T>::s_size;
-template <typename T> size_t        cpp_type_impl<T>::s_alignment;
-template <typename T> bool          cpp_type_impl<T>::s_allow_tag( true );
-template <typename T> int32_t       cpp_type_impl<T>::s_reset_count;
-
-// Front facing class for implicitly registering a component & obtaining
-// static component data
-
-// Regular type
-template <typename T>
-struct cpp_type<T, if_not_t< is_pair<T>::value >>
-    : cpp_type_impl<base_type_t<T>> { };
-
-// Pair type
+/** Get id currently assigned to component. If no world has registered the
+ * component yet, this operation will return 0. */
 template <typename T>
-struct cpp_type<T, if_t< is_pair<T>::value >>
-{
-    // Override id method to return id of pair
-    static id_t id(world_t *world = nullptr) {
-        return ecs_pair(
-            cpp_type< pair_first_t<T> >::id(world),
-            cpp_type< pair_second_t<T> >::id(world));
+flecs::entity_t type_id() {
+    if (_::type<T>::s_reset_count == ecs_cpp_reset_count_get()) {
+        return _::type<T>::s_id;
+    } else {
+        return 0;
     }
-};
-
-} // namespace _
+}
 
-/** Untyped component class.
- * Generic base class for flecs::component.
+/** Reset static component ids.
+ * When components are registered their component ids are stored in a static
+ * type specific variable. This stored id is passed into component registration
+ * functions to ensure consistent ids across worlds.
+ *
+ * In some cases this can be undesirable, like when a process repeatedly creates
+ * worlds with different components. A typical example where this can happen is
+ * when running multiple tests in a single process, where each test registers
+ * its own set of components.
+ *
+ * This operation can be used to prevent reusing of component ids and force
+ * generating a new ids upon registration.
+ *
+ * Note that this operation should *never* be called while there are still
+ * alive worlds in a process. Doing so results in undefined behavior.
+ *
+ * Also note that this operation does not actually change the static component
+ * variables. It only ensures that the next time a component id is requested, a
+ * new id will be generated.
  *
  * @ingroup cpp_components
  */
-struct untyped_component : entity {
-    using entity::entity;
+inline void reset() {
+    ecs_cpp_reset_count_inc();
+}
+
+}
+
+/** @} */
 
-#   ifdef FLECS_META
 /**
- * @file addons/cpp/mixins/meta/untyped_component.inl
- * @brief Meta component mixin.
+ * @file addons/cpp/type.hpp
+ * @brief Utility functions for id vector.
  */
 
+#pragma once
+
+namespace flecs {
+
 /**
- * @memberof flecs::component
- * @ingroup cpp_addons_meta
- * 
+ * @defgroup cpp_types Types
+ * @ingroup cpp_core
+ * @brief Type operations.
+ *
  * @{
  */
 
-/** Add member with unit. */
-untyped_component& member(flecs::entity_t type_id, flecs::entity_t unit, const char *name, int32_t count = 0, size_t offset = 0) {
-    ecs_entity_desc_t desc = {};
-    desc.name = name;
-    desc.add[0] = ecs_pair(flecs::ChildOf, m_id);
-    ecs_entity_t eid = ecs_entity_init(m_world, &desc);
-    ecs_assert(eid != 0, ECS_INTERNAL_ERROR, NULL);
+/** Type class.
+ * A type is a vector of component ids which can be requested from entities or tables.
+ */
+struct type {
+    type() : world_(nullptr), type_(nullptr) { }
 
-    flecs::entity e(m_world, eid);
+    type(world_t *world, const type_t *t)
+        : world_(world)
+        , type_(t) { }
 
-    Member m = {};
-    m.type = type_id;
-    m.unit = unit;
-    m.count = count;
-    m.offset = static_cast<int32_t>(offset);
-    e.set<Member>(m);
+    /** Convert type to comma-separated string */
+    flecs::string str() const {
+        return flecs::string(ecs_type_str(world_, type_));
+    }
 
-    return *this;
-}
+    /** Return number of ids in type */
+    int32_t count() const {
+        if (!type_) {
+            return 0;
+        }
+        return type_->count;
+    }
 
-/** Add member. */
-untyped_component& member(flecs::entity_t type_id, const char* name, int32_t count = 0, size_t offset = 0) {
-    return member(type_id, 0, name, count, offset);
-}
+    /** Return pointer to array. */
+    flecs::id_t* array() const {
+        if (!type_) {
+            return nullptr;
+        }
+        return type_->array;
+    }
 
-/** Add member. */
-template <typename MemberType>
-untyped_component& member(const char *name, int32_t count = 0, size_t offset = 0) {
-    flecs::entity_t type_id = _::cpp_type<MemberType>::id(m_world);
-    return member(type_id, name, count, offset);
-}
+    /** Get id at specified index in type */
+    flecs::id get(int32_t index) const {
+        ecs_assert(type_ != NULL, ECS_INVALID_PARAMETER, NULL);
+        ecs_assert(type_->count > index, ECS_OUT_OF_RANGE, NULL);
+        if (!type_) {
+            return flecs::id();
+        }
+        return flecs::id(world_, type_->array[index]);
+    }
 
-/** Add member with unit. */
-template <typename MemberType>
-untyped_component& member(flecs::entity_t unit, const char *name, int32_t count = 0, size_t offset = 0) {
-    flecs::entity_t type_id = _::cpp_type<MemberType>::id(m_world);
-    return member(type_id, unit, name, count, offset);
-}
+    flecs::id_t* begin() const {
+        return type_->array;
+    }
 
-/** Add member with unit. */
-template <typename MemberType, typename UnitType>
-untyped_component& member(const char *name, int32_t count = 0, size_t offset = 0) {
-    flecs::entity_t type_id = _::cpp_type<MemberType>::id(m_world);
-    flecs::entity_t unit_id = _::cpp_type<UnitType>::id(m_world);
-    return member(type_id, unit_id, name, count, offset);
-}
+    flecs::id_t* end() const {
+        return &type_->array[type_->count];
+    }
 
-/** Add member using pointer-to-member. */
-template <typename MemberType, typename ComponentType, typename RealType = typename std::remove_extent<MemberType>::type>
-untyped_component& member(const char* name, const MemberType ComponentType::* ptr) {
-    flecs::entity_t type_id = _::cpp_type<RealType>::id(m_world);
-    size_t offset = reinterpret_cast<size_t>(&(static_cast<ComponentType*>(nullptr)->*ptr));
-    return member(type_id, name, std::extent<MemberType>::value, offset);
-}
+    /** Implicit conversion to type_t */
+    operator const type_t*() const {
+        return type_;
+    }
+private:
+    world_t *world_;
+    const type_t *type_;
+};
 
-/** Add member with unit using pointer-to-member. */
-template <typename MemberType, typename ComponentType, typename RealType = typename std::remove_extent<MemberType>::type>
-untyped_component& member(flecs::entity_t unit, const char* name, const MemberType ComponentType::* ptr) {
-    flecs::entity_t type_id = _::cpp_type<RealType>::id(m_world);
-    size_t offset = reinterpret_cast<size_t>(&(static_cast<ComponentType*>(nullptr)->*ptr));
-    return member(type_id, unit, name, std::extent<MemberType>::value, offset);
-}
+/** #} */
 
-/** Add member with unit using pointer-to-member. */
-template <typename UnitType, typename MemberType, typename ComponentType, typename RealType = typename std::remove_extent<MemberType>::type>
-untyped_component& member(const char* name, const MemberType ComponentType::* ptr) {
-    flecs::entity_t type_id = _::cpp_type<RealType>::id(m_world);
-    flecs::entity_t unit_id = _::cpp_type<UnitType>::id(m_world);
-    size_t offset = reinterpret_cast<size_t>(&(static_cast<ComponentType*>(nullptr)->*ptr));
-    return member(type_id, unit_id, name, std::extent<MemberType>::value, offset);
 }
 
-/** Add constant. */
-untyped_component& constant(const char *name, int32_t value) {
-    ecs_add_id(m_world, m_id, _::cpp_type<flecs::Enum>::id(m_world));
-
-    ecs_entity_desc_t desc = {};
-    desc.name = name;
-    desc.add[0] = ecs_pair(flecs::ChildOf, m_id);
-    ecs_entity_t eid = ecs_entity_init(m_world, &desc);
-    ecs_assert(eid != 0, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_set_id(m_world, eid, 
-        ecs_pair(flecs::Constant, flecs::I32), sizeof(int32_t),
-        &value);
+/**
+ * @file addons/cpp/table.hpp
+ * @brief Direct access to table data.
+ */
 
-    return *this;
-}
+#pragma once
 
-/** Add bitmask constant. */
-untyped_component& bit(const char *name, uint32_t value) {
-    ecs_add_id(m_world, m_id, _::cpp_type<flecs::Bitmask>::id(m_world));
+namespace flecs {
 
-    ecs_entity_desc_t desc = {};
-    desc.name = name;
-    desc.add[0] = ecs_pair(flecs::ChildOf, m_id);
-    ecs_entity_t eid = ecs_entity_init(m_world, &desc);
-    ecs_assert(eid != 0, ECS_INTERNAL_ERROR, NULL);
+/**
+ * @defgroup cpp_tables Tables
+ * @ingroup cpp_core
+ * Table operations.
+ *
+ * @{
+ */
 
-    ecs_set_id(m_world, eid, 
-        ecs_pair(flecs::Constant, flecs::U32), sizeof(uint32_t),
-        &value);
+struct table {
+    table() : world_(nullptr), table_(nullptr) { }
 
-    return *this;
-}
+    table(world_t *world, table_t *t)
+        : world_(world)
+        , table_(t) { }
 
-/** Register array metadata for component */
-template <typename Elem>
-untyped_component& array(int32_t elem_count) {
-    ecs_array_desc_t desc = {};
-    desc.entity = m_id;
-    desc.type = _::cpp_type<Elem>::id(m_world);
-    desc.count = elem_count;
-    ecs_array_init(m_world, &desc);
-    return *this;
-}
+    virtual ~table() { }
 
-/** Add member value range */
-untyped_component& range(double min, double max) {
-    const flecs::member_t *m = ecs_cpp_last_member(m_world, m_id);
-    if (!m) {
-        return *this;
+    /** Convert table type to string. */
+    flecs::string str() const {
+        return flecs::string(ecs_table_str(world_, table_));
     }
 
-    flecs::world w(m_world);
-    flecs::entity me = w.entity(m->member);
-
-    // Don't use C++ ensure because Unreal defines a macro called ensure
-    flecs::MemberRanges *mr = static_cast<flecs::MemberRanges*>(
-        ecs_ensure_id(w, me, w.id<flecs::MemberRanges>()));
-    mr->value.min = min;
-    mr->value.max = max;
-    me.modified<flecs::MemberRanges>();
-    return *this;
-}
-
-/** Add member warning range */
-untyped_component& warning_range(double min, double max) {
-    const flecs::member_t *m = ecs_cpp_last_member(m_world, m_id);
-    if (!m) {
-        return *this;
+    /** Get table type. */
+    flecs::type type() const {
+        return flecs::type(world_, ecs_table_get_type(table_));
     }
 
-    flecs::world w(m_world);
-    flecs::entity me = w.entity(m->member);
-
-    // Don't use C++ ensure because Unreal defines a macro called ensure
-    flecs::MemberRanges *mr = static_cast<flecs::MemberRanges*>(
-        ecs_ensure_id(w, me, w.id<flecs::MemberRanges>()));
-    mr->warning.min = min;
-    mr->warning.max = max;
-    me.modified<flecs::MemberRanges>();
-    return *this;
-}
+    /** Get table count. */
+    int32_t count() const {
+        return ecs_table_count(table_);
+    }
 
-/** Add member error range */
-untyped_component& error_range(double min, double max) {
-    const flecs::member_t *m = ecs_cpp_last_member(m_world, m_id);
-    if (!m) {
-        return *this;
+    /** Find type index for (component) id.
+     *
+     * @param id The (component) id.
+     * @return The index of the id in the table type, -1 if not found/
+     */
+    int32_t type_index(flecs::id_t id) const {
+        return ecs_table_get_type_index(world_, table_, id);
     }
 
-    flecs::world w(m_world);
-    flecs::entity me = w.entity(m->member);
+    /** Find type index for type.
+     *
+     * @tparam T The type.
+     * @return True if the table has the type, false if not.
+     */
+    template <typename T>
+    int32_t type_index() const {
+        return type_index(_::type<T>::id(world_));
+    }
 
-    // Don't use C++ ensure because Unreal defines a macro called ensure
-    flecs::MemberRanges *mr = static_cast<flecs::MemberRanges*>(ecs_ensure_id(
-        w, me, w.id<flecs::MemberRanges>()));
-    mr->error.min = min;
-    mr->error.max = max;
-    me.modified<flecs::MemberRanges>();
-    return *this;
-}
+    /** Find type index for pair.
+     * @param first First element of pair.
+     * @param second Second element of pair.
+     * @return True if the table has the pair, false if not.
+     */
+    int32_t type_index(flecs::entity_t first, flecs::entity_t second) const {
+        return type_index(ecs_pair(first, second));
+    }
 
+    /** Find type index for pair.
+     * @tparam First First element of pair.
+     * @param second Second element of pair.
+     * @return True if the table has the pair, false if not.
+     */
+    template <typename First>
+    int32_t type_index(flecs::entity_t second) const {
+        return type_index(_::type<First>::id(world_), second);
+    }
 
-/** @} */
+    /** Find type index for pair.
+     * @tparam First First element of pair.
+     * @tparam Second Second element of pair.
+     * @return True if the table has the pair, false if not.
+     */
+    template <typename First, typename Second>
+    int32_t type_index() const {
+        return type_index<First>(_::type<Second>::id(world_));
+    }
 
-#   endif
-#   ifdef FLECS_METRICS
-/**
- * @file addons/cpp/mixins/meta/untyped_component.inl
- * @brief Metrics component mixin.
- */
+    /** Find column index for (component) id.
+     *
+     * @param id The (component) id.
+     * @return The index of the id in the table type, -1 if not found/
+     */
+    int32_t column_index(flecs::id_t id) const {
+        return ecs_table_get_column_index(world_, table_, id);
+    }
 
-/**
- * @memberof flecs::component
- * @ingroup cpp_addons_metrics
- * 
- * @{
- */
+    /** Find column index for type.
+     *
+     * @tparam T The type.
+     * @return True if the table has the type, false if not.
+     */
+    template <typename T>
+    int32_t column_index() const {
+        return column_index(_::type<T>::id(world_));
+    }
 
-/** Register member as metric.
- * When no explicit name is provided, this operation will derive the metric name
- * from the member name. When the member name is "value", the operation will use
- * the name of the component.
- * 
- * When the brief parameter is provided, it is set on the metric as if 
- * set_doc_brief is used. The brief description can be obtained with 
- * get_doc_brief.
- * 
- * @tparam Kind Metric kind (Counter, CounterIncrement or Gauge).
- * @param parent Parent entity of the metric (optional).
- * @param brief Description for metric (optional).
- * @param name Name of metric (optional).
- */
-template <typename Kind>
-untyped_component& metric(
-    flecs::entity_t parent = 0, 
-    const char *brief = nullptr, 
-    const char *name = nullptr);
+    /** Find column index for pair.
+     * @param first First element of pair.
+     * @param second Second element of pair.
+     * @return True if the table has the pair, false if not.
+     */
+    int32_t column_index(flecs::entity_t first, flecs::entity_t second) const {
+        return column_index(ecs_pair(first, second));
+    }
 
-/** @} */
+    /** Find column index for pair.
+     * @tparam First First element of pair.
+     * @param second Second element of pair.
+     * @return True if the table has the pair, false if not.
+     */
+    template <typename First>
+    int32_t column_index(flecs::entity_t second) const {
+        return column_index(_::type<First>::id(world_), second);
+    }
 
-#   endif
-};
+    /** Find column index for pair.
+     * @tparam First First element of pair.
+     * @tparam Second Second element of pair.
+     * @return True if the table has the pair, false if not.
+     */
+    template <typename First, typename Second>
+    int32_t column_index() const {
+        return column_index<First>(_::type<Second>::id(world_));
+    }
 
-/** Component class.
- * Class used to register components and component metadata.
- *
- * @ingroup cpp_components
- */
-template <typename T>
-struct component : untyped_component {
-    /** Register a component.
-     * If the component was already registered, this operation will return a handle
-     * to the existing component.
+    /** Test if table has (component) id.
      *
-     * @param world The world for which to register the component.
-     * @param name Optional name (overrides typename).
-     * @param allow_tag If true, empty types will be registered with size 0.
-     * @param id Optional id to register component with.
+     * @param id The (component) id.
+     * @return True if the table has the id, false if not.
      */
-    component(
-        flecs::world_t *world,
-        const char *name = nullptr,
-        bool allow_tag = true,
-        flecs::id_t id = 0)
-    {
-        const char *n = name;
-        bool implicit_name = false;
-        if (!n) {
-            n = _::type_name<T>();
+    bool has(flecs::id_t id) const {
+        return type_index(id) != -1;
+    }
 
-            /* Keep track of whether name was explicitly set. If not, and the
-            * component was already registered, just use the registered name.
-            *
-            * The registered name may differ from the typename as the registered
-            * name includes the flecs scope. This can in theory be different from
-            * the C++ namespace though it is good practice to keep them the same */
-            implicit_name = true;
-        }
+    /** Test if table has the type.
+     *
+     * @tparam T The type.
+     * @return True if the table has the type, false if not.
+     */
+    template <typename T>
+    bool has() const {
+        return type_index<T>() != -1;
+    }
 
-        if (_::cpp_type<T>::registered(world)) {
-            /* Obtain component id. Because the component is already registered,
-             * this operation does nothing besides returning the existing id */
-            id = _::cpp_type<T>::id_explicit(world, name, allow_tag, id);
+    /** Test if table has the pair.
+     *
+     * @param first First element of pair.
+     * @param second Second element of pair.
+     * @return True if the table has the pair, false if not.
+     */
+    bool has(flecs::entity_t first, flecs::entity_t second) const {
+        return type_index(first, second) != -1;
+    }
 
-            ecs_cpp_component_validate(world, id, n, _::symbol_name<T>(),
-                _::cpp_type<T>::size(),
-                _::cpp_type<T>::alignment(),
-                implicit_name);
-        } else {
-            /* If component is registered from an existing scope, ignore the
-             * namespace in the name of the component. */
-            if (implicit_name && (ecs_get_scope(world) != 0)) {
-                /* If the type is a template type, make sure to ignore ':'
-                 * inside the template parameter list. */
-                const char *start = strchr(n, '<'), *last_elem = NULL;
-                if (start) {
-                    const char *ptr = start;
-                    while (ptr[0] && (ptr[0] != ':') && (ptr > n)) {
-                        ptr --;
-                    }
-                    if (ptr[0] == ':') {
-                        last_elem = ptr;
-                    }
-                }
-                if (last_elem) {
-                    name = last_elem + 1;
-                }
-            }
+    /** Test if table has the pair.
+     *
+     * @tparam First First element of pair.
+     * @param second Second element of pair.
+     * @return True if the table has the pair, false if not.
+     */
+    template <typename First>
+    bool has(flecs::entity_t second) const {
+        return type_index<First>(second) != -1;
+    }
 
-            /* Find or register component */
-            bool existing;
-            id = ecs_cpp_component_register(world, id, n, _::symbol_name<T>(),
-                ECS_SIZEOF(T), ECS_ALIGNOF(T), implicit_name, &existing);
+    /** Test if table has the pair.
+     *
+     * @tparam First First element of pair.
+     * @tparam Second Second element of pair.
+     * @return True if the table has the pair, false if not.
+     */
+    template <typename First, typename Second>
+    bool has() const {
+        return type_index<First, Second>() != -1;
+    }
 
-            /* Initialize static component data */
-            id = _::cpp_type<T>::id_explicit(world, name, allow_tag, id);
+    /** Get pointer to component array by column index.
+     *
+     * @param index The column index.
+     * @return Pointer to the column, NULL if not a component.
+     */
+    virtual void* get_column(int32_t index) const {
+        return ecs_table_get_column(table_, index, 0);
+    }
 
-            /* Initialize lifecycle actions (ctor, dtor, copy, move) */
-            if (_::cpp_type<T>::size() && !existing) {
-                _::register_lifecycle_actions<T>(world, id);
-            }
+    /** Get pointer to component array by component.
+     *
+     * @param id The component id.
+     * @return Pointer to the column, NULL if not found.
+     */
+    void* get(flecs::id_t id) const {
+        int32_t index = column_index(id);
+        if (index == -1) {
+            return NULL;
         }
+        return get_column(index);
+    }
 
-        m_world = world;
-        m_id = id;
+    /** Get pointer to component array by pair.
+     *
+     * @param first The first element of the pair.
+     * @param second The second element of the pair.
+     * @return Pointer to the column, NULL if not found.
+     */
+    void* get(flecs::entity_t first, flecs::entity_t second) const {
+        return get(ecs_pair(first, second));
     }
 
-    /** Register on_add hook. */
-    template <typename Func>
-    component<T>& on_add(Func&& func) {
-        using Delegate = typename _::each_delegate<typename std::decay<Func>::type, T>;
-        flecs::type_hooks_t h = get_hooks();
-        ecs_assert(h.on_add == nullptr, ECS_INVALID_OPERATION,
-            "on_add hook is already set");
-        BindingCtx *ctx = get_binding_ctx(h);
-        h.on_add = Delegate::run_add;
-        ctx->on_add = FLECS_NEW(Delegate)(FLECS_FWD(func));
-        ctx->free_on_add = reinterpret_cast<ecs_ctx_free_t>(
-            _::free_obj<Delegate>);
-        ecs_set_hooks_id(m_world, m_id, &h);
-        return *this;
+    /** Get pointer to component array by component.
+     *
+     * @tparam T The component.
+     * @return Pointer to the column, NULL if not found.
+     */
+    template <typename T, if_t< is_actual<T>::value > = 0>
+    T* get() const {
+        return static_cast<T*>(get(_::type<T>::id(world_)));
     }
 
-    /** Register on_remove hook. */
-    template <typename Func>
-    component<T>& on_remove(Func&& func) {
-        using Delegate = typename _::each_delegate<
-            typename std::decay<Func>::type, T>;
-        flecs::type_hooks_t h = get_hooks();
-        ecs_assert(h.on_remove == nullptr, ECS_INVALID_OPERATION,
-            "on_remove hook is already set");
-        BindingCtx *ctx = get_binding_ctx(h);
-        h.on_remove = Delegate::run_remove;
-        ctx->on_remove = FLECS_NEW(Delegate)(FLECS_FWD(func));
-        ctx->free_on_remove = reinterpret_cast<ecs_ctx_free_t>(
-            _::free_obj<Delegate>);
-        ecs_set_hooks_id(m_world, m_id, &h);
-        return *this;
+    /** Get pointer to component array by (enum) component.
+     *
+     * @tparam T The (enum) component.
+     * @return Pointer to the column, NULL if not found.
+     */
+    template <typename T, if_t< is_enum<T>::value > = 0>
+    T* get() const {
+        return static_cast<T*>(get(_::type<T>::id(world_)));
     }
 
-    /** Register on_set hook. */
-    template <typename Func>
-    component<T>& on_set(Func&& func) {
-        using Delegate = typename _::each_delegate<
-            typename std::decay<Func>::type, T>;
-        flecs::type_hooks_t h = get_hooks();
-        ecs_assert(h.on_set == nullptr, ECS_INVALID_OPERATION,
-            "on_set hook is already set");
-        BindingCtx *ctx = get_binding_ctx(h);
-        h.on_set = Delegate::run_set;
-        ctx->on_set = FLECS_NEW(Delegate)(FLECS_FWD(func));
-        ctx->free_on_set = reinterpret_cast<ecs_ctx_free_t>(
-            _::free_obj<Delegate>);
-        ecs_set_hooks_id(m_world, m_id, &h);
-        return *this;
+    /** Get pointer to component array by component.
+     *
+     * @tparam T The component.
+     * @return Pointer to the column, NULL if not found.
+     */
+    template <typename T, typename A = actual_type_t<T>,
+        if_t< flecs::is_pair<T>::value > = 0>
+    A* get() const {
+        return static_cast<A*>(get(_::type<T>::id(world_)));
     }
 
-#   ifdef FLECS_META
+    /** Get pointer to component array by pair.
+     *
+     * @tparam First The first element of the pair.
+     * @param second The second element of the pair.
+     * @return Pointer to the column, NULL if not found.
+     */
+    template <typename First>
+    First* get(flecs::entity_t second) const {
+        return static_cast<First*>(get(_::type<First>::id(world_), second));
+    }
 
-/** Register opaque type interface */
-template <typename Func>
-component& opaque(const Func& type_support) {
-    flecs::world world(m_world);
-    auto ts = type_support(world);
-    ts.desc.entity = _::cpp_type<T>::id(m_world);
-    ecs_opaque_init(m_world, &ts.desc);
-    return *this;
-}
+    /** Get pointer to component array by pair.
+     *
+     * @tparam First The first element of the pair.
+     * @tparam Second The second element of the pair.
+     * @return Pointer to the column, NULL if not found.
+     */
+    template <typename First, typename Second, typename P = flecs::pair<First, Second>,
+        typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
+    A* get() const {
+        return static_cast<A*>(get<First>(_::type<Second>::id(world_)));
+    }
 
-flecs::opaque<T> opaque(flecs::entity_t as_type) {
-    return flecs::opaque<T>(m_world).as_type(as_type);
-}
+    /** Get column size */
+    size_t column_size(int32_t index) {
+        return ecs_table_get_column_size(table_, index);
+    }
 
-flecs::opaque<T> opaque(flecs::entity as_type) {
-    return this->opaque(as_type.id());
-}
+    /** Get depth for given relationship.
+     *
+     * @param rel The relationship.
+     * @return The depth.
+     */
+    int32_t depth(flecs::entity_t rel) {
+        return ecs_table_get_depth(world_, table_, rel);
+    }
 
-flecs::opaque<T> opaque(flecs::untyped_component as_type) {
-    return this->opaque(as_type.id());
-}
+    /** Get depth for given relationship.
+     *
+     * @tparam Rel The relationship.
+     * @return The depth.
+     */
+    template <typename Rel>
+    int32_t depth() {
+        return depth(_::type<Rel>::id(world_));
+    }
 
-/** Return opaque type builder for collection type */
-template <typename ElemType>
-flecs::opaque<T, ElemType> opaque(flecs::id_t as_type) {
-    return flecs::opaque<T, ElemType>(m_world).as_type(as_type);
-}
+    /** Get table.
+     *
+     * @return The table.
+     */
+    table_t* get_table() const {
+        return table_;
+    }
 
-/** Add constant. */
-component<T>& constant(const char *name, T value) {
-    int32_t v = static_cast<int32_t>(value);
-    untyped_component::constant(name, v);
-    return *this;
-}
+    /* Implicit conversion to table_t */
+    operator table_t*() const {
+        return table_;
+    }
 
-#   endif
+protected:
+    world_t *world_;
+    table_t *table_;
+};
 
-private:
-    using BindingCtx = _::component_binding_ctx;
+struct table_range : table {
+    table_range()
+        : table()
+        , offset_(0)
+        , count_(0) { }
 
-    BindingCtx* get_binding_ctx(flecs::type_hooks_t& h){
-        BindingCtx *result = static_cast<BindingCtx*>(h.binding_ctx);
-        if (!result) {
-            result = FLECS_NEW(BindingCtx);
-            h.binding_ctx = result;
-            h.binding_ctx_free = reinterpret_cast<ecs_ctx_free_t>(
-                _::free_obj<BindingCtx>);
-        }
-        return result;
-    }
+    table_range(world_t *world, table_t *t, int32_t offset, int32_t count)
+        : table(world, t)
+        , offset_(offset)
+        , count_(count) { }
 
-    flecs::type_hooks_t get_hooks() {
-        const flecs::type_hooks_t* h = ecs_get_hooks_id(m_world, m_id);
-        if (h) {
-            return *h;
-        } else {
-            return {};
-        }
+    int32_t offset() const {
+        return offset_;
     }
-};
 
-/** Get id currently assigned to component. If no world has registered the
- * component yet, this operation will return 0. */
-template <typename T>
-flecs::entity_t type_id() {
-    if (_::cpp_type<T>::s_reset_count == ecs_cpp_reset_count_get()) {
-        return _::cpp_type<T>::s_id;
-    } else {
-        return 0;
+    int32_t count() const {
+        return count_;
     }
-}
 
-/** Reset static component ids.
- * When components are registered their component ids are stored in a static
- * type specific variable. This stored id is passed into component registration
- * functions to ensure consistent ids across worlds.
- *
- * In some cases this can be undesirable, like when a process repeatedly creates
- * worlds with different components. A typical example where this can happen is
- * when running multiple tests in a single process, where each test registers
- * its own set of components.
- *
- * This operation can be used to prevent reusing of component ids and force
- * generating a new ids upon registration.
- *
- * Note that this operation should *never* be called while there are still
- * alive worlds in a process. Doing so results in undefined behavior.
- *
- * Also note that this operation does not actually change the static component
- * variables. It only ensures that the next time a component id is requested, a
- * new id will be generated.
- *
- * @ingroup cpp_components
- */
-inline void reset() {
-    ecs_cpp_reset_count_inc();
-}
+    /** Get pointer to component array by column index.
+     *
+     * @param index The column index.
+     * @return Pointer to the column, NULL if not a component.
+     */
+    void* get_column(int32_t index) const override {
+        return ecs_table_get_column(table_, index, offset_);
+    }
 
-}
+private:
+    int32_t offset_ = 0;
+    int32_t count_ = 0;
+};
 
 /** @} */
 
+}
+
 /**
- * @file addons/cpp/type.hpp
- * @brief Utility functions for id vector.
+ * @file addons/cpp/utils/iterable.hpp
+ * @brief Base class for iterable objects, like queries.
  */
 
-#pragma once
-
 namespace flecs {
 
-/**
- * @defgroup cpp_types Types
- * @ingroup cpp_core
- * @brief Type operations.
- *
- * @{
- */
+template <typename ... Components>
+struct iter_iterable;
 
-/** Type class.
- * A type is a vector of component ids which can be requested from entities or tables.
- */
-struct type {
-    type() : m_world(nullptr), m_type(nullptr) { }
+template <typename ... Components>
+struct page_iterable;
 
-    type(world_t *world, const type_t *t)
-        : m_world(world)
-        , m_type(t) { }
+template <typename ... Components>
+struct worker_iterable; 
 
-    /** Convert type to comma-separated string */
-    flecs::string str() const {
-        return flecs::string(ecs_type_str(m_world, m_type));
+template <typename ... Components>
+struct iterable {
+
+    /** Each iterator.
+     * The "each" iterator accepts a function that is invoked for each matching
+     * entity. The following function signatures are valid:
+     *  - func(flecs::entity e, Components& ...)
+     *  - func(flecs::iter& it, size_t index, Components& ....)
+     *  - func(Components& ...)
+     * 
+     * Each iterators are automatically instanced.
+     */
+    template <typename Func>
+    void each(Func&& func) const {
+        each(nullptr, FLECS_FWD(func));
     }
 
-    /** Return number of ids in type */
-    int32_t count() const {
-        if (!m_type) {
-            return 0;
-        }
-        return m_type->count;
+    template <typename Func>
+    void each(flecs::world_t *world, Func&& func) const {
+        iterate<_::each_delegate>(world, FLECS_FWD(func), 
+            this->next_each_action());
     }
 
-    /** Return pointer to array. */
-    flecs::id_t* array() const {
-        if (!m_type) {
-            return nullptr;
-        }
-        return m_type->array;
+    template <typename Func>
+    void each(flecs::iter& it, Func&& func) const {
+        iterate<_::each_delegate>(it.world(), FLECS_FWD(func),
+            this->next_each_action());
     }
 
-    /** Get id at specified index in type */
-    flecs::id get(int32_t index) const {
-        ecs_assert(m_type != NULL, ECS_INVALID_PARAMETER, NULL);
-        ecs_assert(m_type->count > index, ECS_OUT_OF_RANGE, NULL);
-        if (!m_type) {
-            return flecs::id();
-        }
-        return flecs::id(m_world, m_type->array[index]);
+    template <typename Func>
+    void each(flecs::entity e, Func&& func) const {
+        iterate<_::each_delegate>(e.world(), FLECS_FWD(func), 
+            this->next_each_action());
     }
 
-    flecs::id_t* begin() const {
-        return m_type->array;
+    template <typename Func>
+    flecs::entity find(Func&& func) const {
+        return iterate_find<_::find_delegate>(nullptr, FLECS_FWD(func), 
+            this->next_each_action());
+    }
+
+    /** Iter iterator.
+     * The "iter" iterator accepts a function that is invoked for each matching
+     * table. The following function signatures are valid:
+     *  - func(flecs::iter& it, Components* ...)
+     *  - func(Components& ...)
+     * 
+     * Iter iterators are not automatically instanced. When a result contains
+     * shared components, entities of the result will be iterated one by one.
+     * This ensures that applications can't accidentally read out of bounds by
+     * accessing a shared component as an array.
+     */
+    template <typename Func>
+    void iter(Func&& func) const { 
+        iterate<_::iter_delegate>(nullptr, FLECS_FWD(func), 
+            this->next_action());
+    }
+
+    template <typename Func>
+    void iter(flecs::world_t *world, Func&& func) const {
+        iterate<_::iter_delegate>(world, FLECS_FWD(func), 
+            this->next_action());
     }
 
-    flecs::id_t* end() const {
-        return &m_type->array[m_type->count];
+    template <typename Func>
+    void iter(flecs::iter& it, Func&& func) const {
+        iterate<_::iter_delegate>(it.world(), FLECS_FWD(func),
+            this->next_action());
     }
 
-    /** Implicit conversion to type_t */
-    operator const type_t*() const {
-        return m_type;
+    template <typename Func>
+    void iter(flecs::entity e, Func&& func) const {
+        iterate<_::iter_delegate>(e.world(), FLECS_FWD(func), 
+            this->next_action());
     }
-private:
-    world_t *m_world;
-    const type_t *m_type;
-};
-
-/** #} */
-
-}
-
-/**
- * @file addons/cpp/table.hpp
- * @brief Direct access to table data.
- */
-
-#pragma once
-
-namespace flecs {
-
-/**
- * @defgroup cpp_tables Tables
- * @ingroup cpp_core
- * Table operations.
- *
- * @{
- */
 
-struct table {
-    table() : m_world(nullptr), m_table(nullptr) { }
+    /** Create iterator.
+     * Create an iterator object that can be modified before iterating.
+     */
+    iter_iterable<Components...> iter(flecs::world_t *world = nullptr) const;
 
-    table(world_t *world, table_t *t)
-        : m_world(world)
-        , m_table(t) { }
+    /** Page iterator.
+     * Create an iterator that limits the returned entities with offset/limit.
+     * 
+     * @param offset How many entities to skip.
+     * @param limit The maximum number of entities to return.
+     * @return Iterable that can be iterated with each/iter.
+     */
+    page_iterable<Components...> page(int32_t offset, int32_t limit);
 
-    virtual ~table() { }
+    /** Worker iterator.
+     * Create an iterator that divides the number of matched entities across
+     * a number of resources.
+     * 
+     * @param index The index of the current resource.
+     * @param count The total number of resources to divide entities between.
+     * @return Iterable that can be iterated with each/iter.
+     */
+    worker_iterable<Components...> worker(int32_t index, int32_t count);
 
-    /** Convert table type to string. */
-    flecs::string str() const {
-        return flecs::string(ecs_table_str(m_world, m_table));
+    /** Return number of entities matched by iterable. */
+    int32_t count() const {
+        return this->iter().count();
     }
 
-    /** Get table type. */
-    flecs::type type() const {
-        return flecs::type(m_world, ecs_table_get_type(m_table));
+    /** Return whether iterable has any matches. */
+    bool is_true() const {
+        return this->iter().is_true();
     }
 
-    /** Get table count. */
-    int32_t count() const {
-        return ecs_table_count(m_table);
+    /** Return first entity matched by iterable. */
+    flecs::entity first() const {
+        return this->iter().first();
     }
 
-    /** Find type index for (component) id.
-     *
-     * @param id The (component) id.
-     * @return The index of the id in the table type, -1 if not found/
-     */
-    int32_t type_index(flecs::id_t id) const {
-        return ecs_table_get_type_index(m_world, m_table, id);
+    iter_iterable<Components...> set_var(int var_id, flecs::entity_t value) {
+        return this->iter().set_var(var_id, value);
     }
 
-    /** Find type index for type.
-     *
-     * @tparam T The type.
-     * @return True if the table has the type, false if not.
-     */
-    template <typename T>
-    int32_t type_index() const {
-        return type_index(_::cpp_type<T>::id(m_world));
+    iter_iterable<Components...> set_var(const char *name, flecs::entity_t value) {
+        return this->iter().set_var(name, value);
     }
 
-    /** Find type index for pair.
-     * @param first First element of pair.
-     * @param second Second element of pair.
-     * @return True if the table has the pair, false if not.
-     */
-    int32_t type_index(flecs::entity_t first, flecs::entity_t second) const {
-        return type_index(ecs_pair(first, second));
+    iter_iterable<Components...> set_var(const char *name, flecs::table_t *value) {
+        return this->iter().set_var(name, value);
     }
 
-    /** Find type index for pair.
-     * @tparam First First element of pair.
-     * @param second Second element of pair.
-     * @return True if the table has the pair, false if not.
-     */
-    template <typename First>
-    int32_t type_index(flecs::entity_t second) const {
-        return type_index(_::cpp_type<First>::id(m_world), second);
+    iter_iterable<Components...> set_var(const char *name, ecs_table_range_t value) {
+        return this->iter().set_var(name, value);
     }
 
-    /** Find type index for pair.
-     * @tparam First First element of pair.
-     * @tparam Second Second element of pair.
-     * @return True if the table has the pair, false if not.
-     */
-    template <typename First, typename Second>
-    int32_t type_index() const {
-        return type_index<First>(_::cpp_type<Second>::id(m_world));
+    iter_iterable<Components...> set_var(const char *name, flecs::table_range value) {
+        return this->iter().set_var(name, value);
     }
 
-    /** Find column index for (component) id.
-     *
-     * @param id The (component) id.
-     * @return The index of the id in the table type, -1 if not found/
-     */
-    int32_t column_index(flecs::id_t id) const {
-        return ecs_table_get_column_index(m_world, m_table, id);
+    // Limit results to tables with specified group id (grouped queries only)
+    iter_iterable<Components...> set_group(uint64_t group_id) {
+        return this->iter().set_group(group_id);
     }
 
-    /** Find column index for type.
-     *
-     * @tparam T The type.
-     * @return True if the table has the type, false if not.
-     */
-    template <typename T>
-    int32_t column_index() const {
-        return column_index(_::cpp_type<T>::id(m_world));
+    // Limit results to tables with specified group id (grouped queries only)
+    template <typename Group>
+    iter_iterable<Components...> set_group() {
+        return this->iter().template set_group<Group>();
     }
 
-    /** Find column index for pair.
-     * @param first First element of pair.
-     * @param second Second element of pair.
-     * @return True if the table has the pair, false if not.
-     */
-    int32_t column_index(flecs::entity_t first, flecs::entity_t second) const {
-        return column_index(ecs_pair(first, second));
+    virtual ~iterable() { }
+protected:
+    friend iter_iterable<Components...>;
+    friend page_iterable<Components...>;
+    friend worker_iterable<Components...>;
+
+    virtual ecs_iter_t get_iter(flecs::world_t *stage) const = 0;
+    virtual ecs_iter_next_action_t next_action() const = 0;
+    virtual ecs_iter_next_action_t next_each_action() const = 0;
+
+    template < template<typename Func, typename ... Comps> class Delegate, typename Func, typename NextFunc, typename ... Args>
+    void iterate(flecs::world_t *stage, Func&& func, NextFunc next, Args &&... args) const {
+        ecs_iter_t it = this->get_iter(stage);
+        if (Delegate<Func, Components...>::instanced()) {
+            ECS_BIT_SET(it.flags, EcsIterIsInstanced);
+        }
+
+        while (next(&it, FLECS_FWD(args)...)) {
+            Delegate<Func, Components...>(func).invoke(&it);
+        }
     }
 
-    /** Find column index for pair.
-     * @tparam First First element of pair.
-     * @param second Second element of pair.
-     * @return True if the table has the pair, false if not.
-     */
-    template <typename First>
-    int32_t column_index(flecs::entity_t second) const {
-        return column_index(_::cpp_type<First>::id(m_world), second);
+    template < template<typename Func, typename ... Comps> class Delegate, typename Func, typename NextFunc, typename ... Args>
+    flecs::entity iterate_find(flecs::world_t *stage, Func&& func, NextFunc next, Args &&... args) const {
+        ecs_iter_t it = this->get_iter(stage);
+        if (Delegate<Func, Components...>::instanced()) {
+            ECS_BIT_SET(it.flags, EcsIterIsInstanced);
+        }
+
+        flecs::entity result;
+        while (!result && next(&it, FLECS_FWD(args)...)) {
+            result = Delegate<Func, Components...>(func).invoke(&it);
+        }
+        if (result) {
+            ecs_iter_fini(&it);
+        }
+        return result;
     }
+};
 
-    /** Find column index for pair.
-     * @tparam First First element of pair.
-     * @tparam Second Second element of pair.
-     * @return True if the table has the pair, false if not.
-     */
-    template <typename First, typename Second>
-    int32_t column_index() const {
-        return column_index<First>(_::cpp_type<Second>::id(m_world));
+template <typename ... Components>
+struct iter_iterable final : iterable<Components...> {
+    template <typename Iterable>
+    iter_iterable(Iterable *it, flecs::world_t *world) 
+    {
+        it_ = it->get_iter(world);
+        next_ = it->next_action();
+        next_each_ = it->next_action();
+        ecs_assert(next_ != nullptr, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(next_each_ != nullptr, ECS_INTERNAL_ERROR, NULL);
     }
 
-    /** Test if table has (component) id.
-     *
-     * @param id The (component) id.
-     * @return True if the table has the id, false if not.
-     */
-    bool has(flecs::id_t id) const {
-        return type_index(id) != -1;
+    iter_iterable<Components...>& set_var(int var_id, flecs::entity_t value) {
+        ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, 0);
+        ecs_iter_set_var(&it_, var_id, value);
+        return *this;
     }
 
-    /** Test if table has the type.
-     *
-     * @tparam T The type.
-     * @return True if the table has the type, false if not.
-     */
-    template <typename T>
-    bool has() const {
-        return type_index<T>() != -1;
+    iter_iterable<Components...>& set_var(const char *name, flecs::entity_t value) {
+        ecs_query_iter_t *qit = &it_.priv_.iter.query;
+        int var_id = ecs_query_find_var(qit->query, name);
+        ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
+        ecs_iter_set_var(&it_, var_id, value);
+        return *this;
     }
 
-    /** Test if table has the pair.
-     *
-     * @param first First element of pair.
-     * @param second Second element of pair.
-     * @return True if the table has the pair, false if not.
-     */
-    bool has(flecs::entity_t first, flecs::entity_t second) const {
-        return type_index(first, second) != -1;
+    iter_iterable<Components...>& set_var(const char *name, flecs::table_t *value) {
+        ecs_query_iter_t *qit = &it_.priv_.iter.query;
+        int var_id = ecs_query_find_var(qit->query, name);
+        ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
+        ecs_iter_set_var_as_table(&it_, var_id, value);
+        return *this;
     }
 
-    /** Test if table has the pair.
-     *
-     * @tparam First First element of pair.
-     * @param second Second element of pair.
-     * @return True if the table has the pair, false if not.
-     */
-    template <typename First>
-    bool has(flecs::entity_t second) const {
-        return type_index<First>(second) != -1;
+    iter_iterable<Components...>& set_var(const char *name, ecs_table_range_t value) {
+        ecs_query_iter_t *qit = &it_.priv_.iter.query;
+        int var_id = ecs_query_find_var(qit->query, name);
+        ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
+        ecs_iter_set_var_as_range(&it_, var_id, &value);
+        return *this;
     }
 
-    /** Test if table has the pair.
-     *
-     * @tparam First First element of pair.
-     * @tparam Second Second element of pair.
-     * @return True if the table has the pair, false if not.
-     */
-    template <typename First, typename Second>
-    bool has() const {
-        return type_index<First, Second>() != -1;
+    iter_iterable<Components...>& set_var(const char *name, flecs::table_range value) {
+        ecs_table_range_t range;
+        range.table = value.get_table();
+        range.offset = value.offset();
+        range.count = value.count();
+        return set_var(name, range);
     }
 
-    /** Get pointer to component array by column index.
-     *
-     * @param index The column index.
-     * @return Pointer to the column, NULL if not a component.
-     */
-    virtual void* get_column(int32_t index) const {
-        return ecs_table_get_column(m_table, index, 0);
+#   ifdef FLECS_JSON
+/**
+ * @file addons/cpp/mixins/json/iterable.inl
+ * @brief JSON iterable mixin.
+ */
+
+/** Serialize iterator result to JSON.
+ * 
+ * @memberof flecs::iter
+ * @ingroup cpp_addons_json
+ */
+flecs::string to_json(flecs::iter_to_json_desc_t *desc = nullptr) {
+    char *json = ecs_iter_to_json(&it_, desc);
+    return flecs::string(json);
+}
+
+#   endif
+
+    // Return total number of entities in result.
+    int32_t count() {
+        int32_t result = 0;
+        while (next_each_(&it_)) {
+            result += it_.count;
+        }
+        return result;
     }
 
-    /** Get pointer to component array by component.
-     *
-     * @param id The component id.
-     * @return Pointer to the column, NULL if not found.
-     */
-    void* get(flecs::id_t id) const {
-        int32_t index = column_index(id);
-        if (index == -1) {
-            return NULL;
+    // Returns true if iterator yields at least once result.
+    bool is_true() {
+        bool result = next_each_(&it_);
+        if (result) {
+            ecs_iter_fini(&it_);
         }
-        return get_column(index);
+        return result;
     }
 
-    /** Get pointer to component array by pair.
-     *
-     * @param first The first element of the pair.
-     * @param second The second element of the pair.
-     * @return Pointer to the column, NULL if not found.
-     */
-    void* get(flecs::entity_t first, flecs::entity_t second) const {
-        return get(ecs_pair(first, second));
+    // Return first matching entity.
+    flecs::entity first() {
+        flecs::entity result;
+        if (next_each_(&it_) && it_.count) {
+            result = flecs::entity(it_.world, it_.entities[0]);
+            ecs_iter_fini(&it_);
+        }
+        return result;
     }
 
-    /** Get pointer to component array by component.
-     *
-     * @tparam T The component.
-     * @return Pointer to the column, NULL if not found.
-     */
-    template <typename T, if_t< is_actual<T>::value > = 0>
-    T* get() const {
-        return static_cast<T*>(get(_::cpp_type<T>::id(m_world)));
+    // Limit results to tables with specified group id (grouped queries only)
+    iter_iterable<Components...>& set_group(uint64_t group_id) {
+        ecs_iter_set_group(&it_, group_id);
+        return *this;
     }
 
-    /** Get pointer to component array by (enum) component.
-     *
-     * @tparam T The (enum) component.
-     * @return Pointer to the column, NULL if not found.
-     */
-    template <typename T, if_t< is_enum<T>::value > = 0>
-    T* get() const {
-        return static_cast<T*>(get(_::cpp_type<T>::id(m_world)));
+    // Limit results to tables with specified group id (grouped queries only)
+    template <typename Group>
+    iter_iterable<Components...>& set_group() {
+        ecs_iter_set_group(&it_, _::type<Group>().id(it_.real_world));
+        return *this;
     }
 
-    /** Get pointer to component array by component.
-     *
-     * @tparam T The component.
-     * @return Pointer to the column, NULL if not found.
-     */
-    template <typename T, typename A = actual_type_t<T>,
-        if_t< flecs::is_pair<T>::value > = 0>
-    A* get() const {
-        return static_cast<A*>(get(_::cpp_type<T>::id(m_world)));
+protected:
+    ecs_iter_t get_iter(flecs::world_t *world) const {
+        if (world) {
+            ecs_iter_t result = it_;
+            result.world = world;
+            return result;
+        }
+        return it_;
     }
 
-    /** Get pointer to component array by pair.
-     *
-     * @tparam First The first element of the pair.
-     * @param second The second element of the pair.
-     * @return Pointer to the column, NULL if not found.
-     */
-    template <typename First>
-    First* get(flecs::entity_t second) const {
-        return static_cast<First*>(get(_::cpp_type<First>::id(m_world), second));
+    ecs_iter_next_action_t next_action() const {
+        return next_;
     }
 
-    /** Get pointer to component array by pair.
-     *
-     * @tparam First The first element of the pair.
-     * @tparam Second The second element of the pair.
-     * @return Pointer to the column, NULL if not found.
-     */
-    template <typename First, typename Second, typename P = flecs::pair<First, Second>,
-        typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
-    A* get() const {
-        return static_cast<A*>(get<First>(_::cpp_type<Second>::id(m_world)));
+    ecs_iter_next_action_t next_each_action() const {
+        return next_each_;
     }
 
-    /** Get column size */
-    size_t column_size(int32_t index) {
-        return ecs_table_get_column_size(m_table, index);
+private:
+    ecs_iter_t it_;
+    ecs_iter_next_action_t next_;
+    ecs_iter_next_action_t next_each_;
+};
+
+template <typename ... Components>
+iter_iterable<Components...> iterable<Components...>::iter(flecs::world_t *world) const
+{
+    return iter_iterable<Components...>(this, world);
+}
+
+template <typename ... Components>
+struct page_iterable final : iterable<Components...> {
+    template <typename Iterable>
+    page_iterable(int32_t offset, int32_t limit, Iterable *it) 
+        : offset_(offset)
+        , limit_(limit)
+    {
+        chain_it_ = it->get_iter(nullptr);
     }
 
-    /** Get depth for given relationship.
-     *
-     * @param rel The relationship.
-     * @return The depth.
-     */
-    int32_t depth(flecs::entity_t rel) {
-        return ecs_table_get_depth(m_world, m_table, rel);
+protected:
+    ecs_iter_t get_iter(flecs::world_t*) const {
+        return ecs_page_iter(&chain_it_, offset_, limit_);
     }
 
-    /** Get depth for given relationship.
-     *
-     * @tparam Rel The relationship.
-     * @return The depth.
-     */
-    template <typename Rel>
-    int32_t depth() {
-        return depth(_::cpp_type<Rel>::id(m_world));
+    ecs_iter_next_action_t next_action() const {
+        return ecs_page_next;
     }
 
-    /* Implicit conversion to table_t */
-    operator table_t*() const {
-        return m_table;
+    ecs_iter_next_action_t next_each_action() const {
+        return ecs_page_next;
     }
 
-protected:
-    world_t *m_world;
-    table_t *m_table;
+private:
+    ecs_iter_t chain_it_;
+    int32_t offset_;
+    int32_t limit_;
 };
 
-struct table_range : table {
-    table_range()
-        : table()
-        , m_offset(0)
-        , m_count(0) { }
+template <typename ... Components>
+page_iterable<Components...> iterable<Components...>::page(
+    int32_t offset, 
+    int32_t limit) 
+{
+    return page_iterable<Components...>(offset, limit, this);
+}
 
-    table_range(world_t *world, table_t *t, int32_t offset, int32_t count)
-        : table(world, t)
-        , m_offset(offset)
-        , m_count(count) { }
+template <typename ... Components>
+struct worker_iterable final : iterable<Components...> {
+    worker_iterable(int32_t offset, int32_t limit, iterable<Components...> *it) 
+        : offset_(offset)
+        , limit_(limit)
+    {
+        chain_it_ = it->get_iter(nullptr);
+    }
 
-    int32_t offset() const {
-        return m_offset;
+protected:
+    ecs_iter_t get_iter(flecs::world_t*) const {
+        return ecs_worker_iter(&chain_it_, offset_, limit_);
     }
 
-    int32_t count() const {
-        return m_count;
+    ecs_iter_next_action_t next_action() const {
+        return ecs_worker_next;
     }
 
-    /** Get pointer to component array by column index.
-     *
-     * @param index The column index.
-     * @return Pointer to the column, NULL if not a component.
-     */
-    void* get_column(int32_t index) const override {
-        return ecs_table_get_column(m_table, index, m_offset);
+    ecs_iter_next_action_t next_each_action() const {
+        return ecs_worker_next;
     }
 
 private:
-    int32_t m_offset = 0;
-    int32_t m_count = 0;
+    ecs_iter_t chain_it_;
+    int32_t offset_;
+    int32_t limit_;
 };
 
-/** @} */
+template <typename ... Components>
+worker_iterable<Components...> iterable<Components...>::worker(
+    int32_t index, 
+    int32_t count) 
+{
+    return worker_iterable<Components...>(index, count, this);
+}
 
 }
 
@@ -27573,57 +26638,57 @@ namespace flecs {
 inline flecs::entity id::entity() const {
     ecs_assert(!is_pair(), ECS_INVALID_OPERATION, NULL);
     ecs_assert(!flags(), ECS_INVALID_OPERATION, NULL);
-    return flecs::entity(m_world, m_id);
+    return flecs::entity(world_, id_);
 }
 
 inline flecs::entity id::flags() const {
-    return flecs::entity(m_world, m_id & ECS_ID_FLAGS_MASK);
+    return flecs::entity(world_, id_ & ECS_ID_FLAGS_MASK);
 }
 
 inline flecs::entity id::first() const {
     ecs_assert(is_pair(), ECS_INVALID_OPERATION, NULL);
 
-    flecs::entity_t e = ECS_PAIR_FIRST(m_id);
-    if (m_world) {
-        return flecs::entity(m_world, ecs_get_alive(m_world, e));
+    flecs::entity_t e = ECS_PAIR_FIRST(id_);
+    if (world_) {
+        return flecs::entity(world_, ecs_get_alive(world_, e));
     } else {
         return flecs::entity(e);
     }
 }
 
 inline flecs::entity id::second() const {
-    flecs::entity_t e = ECS_PAIR_SECOND(m_id);
-    if (m_world) {
-        return flecs::entity(m_world, ecs_get_alive(m_world, e));
+    flecs::entity_t e = ECS_PAIR_SECOND(id_);
+    if (world_) {
+        return flecs::entity(world_, ecs_get_alive(world_, e));
     } else {
         return flecs::entity(e);
     }
 }
 
 inline flecs::entity id::add_flags(flecs::id_t flags) const {
-    return flecs::entity(m_world, m_id | flags);
+    return flecs::entity(world_, id_ | flags);
 }
 
 inline flecs::entity id::remove_flags(flecs::id_t flags) const {
     (void)flags;
-    ecs_assert((m_id & ECS_ID_FLAGS_MASK) == flags, ECS_INVALID_PARAMETER, NULL);
-    return flecs::entity(m_world, m_id & ECS_COMPONENT_MASK);
+    ecs_assert((id_ & ECS_ID_FLAGS_MASK) == flags, ECS_INVALID_PARAMETER, NULL);
+    return flecs::entity(world_, id_ & ECS_COMPONENT_MASK);
 }
 
 inline flecs::entity id::remove_flags() const {
-    return flecs::entity(m_world, m_id & ECS_COMPONENT_MASK);
+    return flecs::entity(world_, id_ & ECS_COMPONENT_MASK);
 }
 
 inline flecs::entity id::remove_generation() const {
-    return flecs::entity(m_world, static_cast<uint32_t>(m_id));
+    return flecs::entity(world_, static_cast<uint32_t>(id_));
 }
 
 inline flecs::world id::world() const {
-    return flecs::world(m_world);
+    return flecs::world(world_);
 }
 
 inline flecs::entity id::type_id() const {
-    return flecs::entity(m_world, ecs_get_typeid(m_world, m_id));
+    return flecs::entity(world_, ecs_get_typeid(world_, id_));
 }
 
 
@@ -27631,21 +26696,21 @@ inline flecs::entity id::type_id() const {
 
 template <typename T>
 inline flecs::id world::id() const {
-    return flecs::id(m_world, _::cpp_type<T>::id(m_world));
+    return flecs::id(world_, _::type<T>::id(world_));
 }
 
 template <typename ... Args>
 inline flecs::id world::id(Args&&... args) const {
-    return flecs::id(m_world, FLECS_FWD(args)...);
+    return flecs::id(world_, FLECS_FWD(args)...);
 }
 
 template <typename First, typename Second>
 inline flecs::id world::pair() const {
     return flecs::id(
-        m_world, 
+        world_, 
         ecs_pair(
-            _::cpp_type<First>::id(m_world), 
-            _::cpp_type<Second>::id(m_world)));
+            _::type<First>::id(world_), 
+            _::type<Second>::id(world_)));
 }
 
 template <typename First>
@@ -27654,9 +26719,9 @@ inline flecs::id world::pair(entity_t o) const {
         "cannot create nested pairs");
 
     return flecs::id(
-        m_world,
+        world_,
         ecs_pair(
-            _::cpp_type<First>::id(m_world), 
+            _::type<First>::id(world_), 
             o));
 }
 
@@ -27665,7 +26730,7 @@ inline flecs::id world::pair(entity_t r, entity_t o) const {
         "cannot create nested pairs");
 
     return flecs::id(
-        m_world,
+        world_,
         ecs_pair(r, o));
 }
 
@@ -27682,65 +26747,65 @@ namespace flecs {
 
 template <typename T>
 flecs::entity ref<T>::entity() const {
-    return flecs::entity(m_world, m_ref.entity);
+    return flecs::entity(world_, ref_.entity);
 }
 
 template <typename Self>
-template <typename Func, if_t< is_callable<Func>::value > >
-inline Self& entity_builder<Self>::set(const Func& func) {
+template <typename Func>
+inline Self& entity_builder<Self>::insert(const Func& func) {
     _::entity_with_delegate<Func>::invoke_ensure(
-        this->m_world, this->m_id, func);
+        this->world_, this->id_, func);
     return to_base();
 }
 
 template <typename T, if_t< is_enum<T>::value > >
 const T* entity_view::get() const {
-    entity_t r = _::cpp_type<T>::id(m_world);
-    entity_t c = ecs_get_target(m_world, m_id, r, 0);
+    entity_t r = _::type<T>::id(world_);
+    entity_t c = ecs_get_target(world_, id_, r, 0);
 
     if (c) {
         // Get constant value from constant entity
-        const T* v = static_cast<const T*>(ecs_get_id(m_world, c, r));
+        const T* v = static_cast<const T*>(ecs_get_id(world_, c, r));
         ecs_assert(v != NULL, ECS_INTERNAL_ERROR, 
             "missing enum constant value");
         return v;
     } else {
         // If there is no matching pair for (r, *), try just r
-        return static_cast<const T*>(ecs_get_id(m_world, m_id, r));
+        return static_cast<const T*>(ecs_get_id(world_, id_, r));
     }
 }
 
 template<typename First>
 inline flecs::entity entity_view::target(int32_t index) const 
 {
-    return flecs::entity(m_world, 
-        ecs_get_target(m_world, m_id, _::cpp_type<First>::id(m_world), index));
+    return flecs::entity(world_, 
+        ecs_get_target(world_, id_, _::type<First>::id(world_), index));
 }
 
 inline flecs::entity entity_view::target(
     flecs::entity_t relationship, 
     int32_t index) const 
 {
-    return flecs::entity(m_world, 
-        ecs_get_target(m_world, m_id, relationship, index));
+    return flecs::entity(world_, 
+        ecs_get_target(world_, id_, relationship, index));
 }
 
 inline flecs::entity entity_view::target_for(
     flecs::entity_t relationship, 
     flecs::id_t id) const 
 {
-    return flecs::entity(m_world, 
-        ecs_get_target_for_id(m_world, m_id, relationship, id));
+    return flecs::entity(world_, 
+        ecs_get_target_for_id(world_, id_, relationship, id));
 }
 
 template <typename T>
 inline flecs::entity entity_view::target_for(flecs::entity_t relationship) const {
-    return target_for(relationship, _::cpp_type<T>::id(m_world));
+    return target_for(relationship, _::type<T>::id(world_));
 }
 
 template <typename First, typename Second>
 inline flecs::entity entity_view::target_for(flecs::entity_t relationship) const {
-    return target_for(relationship, _::cpp_type<First, Second>::id(m_world));
+    return target_for(relationship, _::type<First, Second>::id(world_));
 }
 
 inline flecs::entity entity_view::parent() const {
@@ -27750,37 +26815,37 @@ inline flecs::entity entity_view::parent() const {
 inline flecs::entity entity_view::mut(const flecs::world& stage) const {
     ecs_assert(!stage.is_readonly(), ECS_INVALID_PARAMETER, 
         "cannot use readonly world/stage to create mutable handle");
-    return flecs::entity(m_id).set_stage(stage.c_ptr());
+    return flecs::entity(id_).set_stage(stage.c_ptr());
 }
 
 inline flecs::entity entity_view::mut(const flecs::iter& it) const {
     ecs_assert(!it.world().is_readonly(), ECS_INVALID_PARAMETER, 
         "cannot use iterator created for readonly world/stage to create mutable handle");
-    return flecs::entity(m_id).set_stage(it.world().c_ptr());
+    return flecs::entity(id_).set_stage(it.world().c_ptr());
 }
 
 inline flecs::entity entity_view::mut(const flecs::entity_view& e) const {
     ecs_assert(!e.world().is_readonly(), ECS_INVALID_PARAMETER, 
         "cannot use entity created for readonly world/stage to create mutable handle");
-    return flecs::entity(m_id).set_stage(e.m_world);
+    return flecs::entity(id_).set_stage(e.world_);
 }
 
 inline flecs::entity entity_view::set_stage(world_t *stage) {
-    return flecs::entity(stage, m_id);
+    return flecs::entity(stage, id_);
 }   
 
 inline flecs::type entity_view::type() const {
-    return flecs::type(m_world, ecs_get_type(m_world, m_id));
+    return flecs::type(world_, ecs_get_type(world_, id_));
 }
 
 inline flecs::table entity_view::table() const {
-    return flecs::table(m_world, ecs_get_table(m_world, m_id));
+    return flecs::table(world_, ecs_get_table(world_, id_));
 }
 
 inline flecs::table_range entity_view::range() const {
-    ecs_record_t *r = ecs_record_find(m_world, m_id);
+    ecs_record_t *r = ecs_record_find(world_, id_);
     if (r) {
-        return flecs::table_range(m_world, r->table, 
+        return flecs::table_range(world_, r->table, 
             ECS_RECORD_TO_ROW(r->row), 1);
     }
     return flecs::table_range();
@@ -27788,7 +26853,7 @@ inline flecs::table_range entity_view::range() const {
 
 template <typename Func>
 inline void entity_view::each(const Func& func) const {
-    const ecs_type_t *type = ecs_get_type(m_world, m_id);
+    const ecs_type_t *type = ecs_get_type(world_, id_);
     if (!type) {
         return;
     }
@@ -27798,24 +26863,17 @@ inline void entity_view::each(const Func& func) const {
 
     for (int i = 0; i < count; i ++) {
         ecs_id_t id = ids[i];
-        flecs::id ent(m_world, id);
+        flecs::id ent(world_, id);
         func(ent); 
-
-        // Union object is not stored in type, so handle separately
-        if (ECS_PAIR_FIRST(id) == EcsUnion) {
-            ent = flecs::id(m_world, ECS_PAIR_SECOND(id),
-                ecs_get_target(m_world, m_id, ECS_PAIR_SECOND(id), 0));
-            func(ent);
-        }
     }
 }
 
 template <typename Func>
 inline void entity_view::each(flecs::id_t pred, flecs::id_t obj, const Func& func) const {
     flecs::world_t *real_world = const_cast<flecs::world_t*>(
-        ecs_get_world(m_world));
+        ecs_get_world(world_));
 
-    const ecs_table_t *table = ecs_get_table(m_world, m_id);
+    const ecs_table_t *table = ecs_get_table(world_, id_);
     if (!table) {
         return;
     }
@@ -27835,7 +26893,7 @@ inline void entity_view::each(flecs::id_t pred, flecs::id_t obj, const Func& fun
     
     while (-1 != (cur = ecs_search_offset(real_world, table, cur, pattern, 0)))
     {
-        flecs::id ent(m_world, ids[cur]);
+        flecs::id ent(world_, ids[cur]);
         func(ent);
         cur ++;
     }
@@ -27851,59 +26909,59 @@ inline void entity_view::each(const flecs::entity_view& rel, const Func& func) c
 
 template <typename Func, if_t< is_callable<Func>::value > >
 inline bool entity_view::get(const Func& func) const {
-    return _::entity_with_delegate<Func>::invoke_get(m_world, m_id, func);
+    return _::entity_with_delegate<Func>::invoke_get(world_, id_, func);
 } 
 
 inline flecs::entity entity_view::lookup(const char *path, bool search_path) const {
-    ecs_assert(m_id != 0, ECS_INVALID_PARAMETER, "invalid lookup from null handle");
-    auto id = ecs_lookup_path_w_sep(m_world, m_id, path, "::", "::", search_path);
-    return flecs::entity(m_world, id);
+    ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, "invalid lookup from null handle");
+    auto id = ecs_lookup_path_w_sep(world_, id_, path, "::", "::", search_path);
+    return flecs::entity(world_, id);
 }
 
 inline flecs::entity entity_view::clone(bool copy_value, flecs::entity_t dst_id) const {
     if (!dst_id) {
-        dst_id = ecs_new_id(m_world);
+        dst_id = ecs_new(world_);
     }
 
-    flecs::entity dst = flecs::entity(m_world, dst_id);
-    ecs_clone(m_world, dst_id, m_id, copy_value);
+    flecs::entity dst = flecs::entity(world_, dst_id);
+    ecs_clone(world_, dst_id, id_, copy_value);
     return dst;
 }
 
 // Entity mixin implementation
 template <typename... Args>
 inline flecs::entity world::entity(Args &&... args) const {
-    return flecs::entity(m_world, FLECS_FWD(args)...);
+    return flecs::entity(world_, FLECS_FWD(args)...);
 }
 
 template <typename E, if_t< is_enum<E>::value >>
 inline flecs::id world::id(E value) const {
-    flecs::entity_t constant = enum_type<E>(m_world).entity(value);
-    return flecs::id(m_world, constant);
+    flecs::entity_t constant = enum_type<E>(world_).entity(value);
+    return flecs::id(world_, constant);
 }
 
 template <typename E, if_t< is_enum<E>::value >>
 inline flecs::entity world::entity(E value) const {
-    flecs::entity_t constant = enum_type<E>(m_world).entity(value);
-    return flecs::entity(m_world, constant);
+    flecs::entity_t constant = enum_type<E>(world_).entity(value);
+    return flecs::entity(world_, constant);
 }
 
 template <typename T>
 inline flecs::entity world::entity(const char *name) const {
-    return flecs::entity(m_world, 
-        _::cpp_type<T>::id_explicit(m_world, name, true, 0, false) );
+    return flecs::entity(world_, 
+        _::type<T>::id_explicit(world_, name, true, 0, false) );
 }
 
 template <typename... Args>
 inline flecs::entity world::prefab(Args &&... args) const {
-    flecs::entity result = flecs::entity(m_world, FLECS_FWD(args)...);
+    flecs::entity result = flecs::entity(world_, FLECS_FWD(args)...);
     result.add(flecs::Prefab);
     return result;
 }
 
 template <typename T>
 inline flecs::entity world::prefab(const char *name) const {
-    flecs::entity result = flecs::component<T>(m_world, name, true);
+    flecs::entity result = flecs::component<T>(world_, name, true);
     result.add(flecs::Prefab);
     return result;
 }
@@ -27921,12 +26979,12 @@ namespace flecs {
 
 template <typename T, typename... Args>
 inline flecs::component<T> world::component(Args &&... args) const {
-    return flecs::component<T>(m_world, FLECS_FWD(args)...);
+    return flecs::component<T>(world_, FLECS_FWD(args)...);
 }
 
 template <typename... Args>
 inline flecs::untyped_component world::component(Args &&... args) const {
-    return flecs::untyped_component(m_world, FLECS_FWD(args)...);
+    return flecs::untyped_component(world_, FLECS_FWD(args)...);
 }
 
 } // namespace flecs
@@ -27964,7 +27022,7 @@ namespace _ {
 
     template <typename T, if_t< is_reference<T>::value > = 0>
     static constexpr flecs::inout_kind_t type_to_inout() {
-        return flecs::Out;
+        return flecs::InOut;
     }
 
     template <typename T, if_not_t< 
@@ -27986,13 +27044,13 @@ namespace _ {
     template <typename ... Components>
     struct sig {
         sig(flecs::world_t *world) 
-            : m_world(world)
-            , ids({ (_::cpp_type<remove_pointer_t<Components>>::id(world))... })
+            : world_(world)
+            , ids({ (_::type<remove_pointer_t<Components>>::id(world))... })
             , inout ({ (type_to_inout<Components>())... })
             , oper ({ (type_to_oper<Components>())... }) 
         { }
 
-        flecs::world_t *m_world;
+        flecs::world_t *world_;
         flecs::array<flecs::id_t, sizeof...(Components)> ids;
         flecs::array<flecs::inout_kind_t, sizeof...(Components)> inout;
         flecs::array<flecs::oper_kind_t, sizeof...(Components)> oper;
@@ -28001,23 +27059,7 @@ namespace _ {
         void populate(const Builder& b) {
             size_t i = 0;
             for (auto id : ids) {
-                if (!(id & ECS_ID_FLAGS_MASK)) {
-                    const flecs::type_info_t *ti = ecs_get_type_info(m_world, id);
-                    if (ti) {
-                        // Union relationships always return a value of type
-                        // flecs::entity_t which holds the target id of the 
-                        // union relationship.
-                        // If a union component with a non-zero size (like an 
-                        // enum) is added to the query signature, the each/iter
-                        // functions would accept a parameter of the component
-                        // type instead of flecs::entity_t, which would cause
-                        // an assert.
-                        ecs_assert(!ti->size || !ecs_has_id(m_world, id, flecs::Union),
-                            ECS_INVALID_PARAMETER,
-                            "use term() method to add union relationship");
-                    }
-                }
-                b->term(id).inout(inout[i]).oper(oper[i]);
+                b->with(id).inout(inout[i]).oper(oper[i]);
                 i ++;
             }
         }
@@ -28035,80 +27077,25 @@ namespace flecs
  * descriptions can reference entities by id, name or by variable, which means
  * the entity will be resolved when the term is evaluated.
  * 
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  */
 template<typename Base>
 struct term_id_builder_i {
-    term_id_builder_i() : m_term_id(nullptr) { }
+    term_id_builder_i() : term_id_(nullptr) { }
 
     virtual ~term_id_builder_i() { }
 
     /* The self flag indicates the term identifier itself is used */
     Base& self() {
         this->assert_term_id();
-        m_term_id->flags |= flecs::Self;
-        return *this;
-    }
-
-    /* The up flag indicates that the term identifier may be substituted by
-     * traversing a relationship upwards. For example: substitute the identifier
-     * with its parent by traversing the ChildOf relationship. */
-    Base& up(flecs::entity_t trav = 0) {
-        this->assert_term_id();
-        m_term_id->flags |= flecs::Up;
-        if (trav) {
-            m_term_id->trav = trav;
-        }
-        return *this;
-    }
-
-    template <typename Trav>
-    Base& up() {
-        return this->up(_::cpp_type<Trav>::id(this->world_v()));
-    }
-
-    /* The cascade flag is like up, but returns results in breadth-first order.
-     * Only supported for flecs::query */
-    Base& cascade(flecs::entity_t trav = 0) {
-        this->assert_term_id();
-        m_term_id->flags |= flecs::Cascade;
-        if (trav) {
-            m_term_id->trav = trav;
-        }
-        return *this;
-    }
-
-    template <typename Trav>
-    Base& cascade() {
-        return this->cascade(_::cpp_type<Trav>::id(this->world_v()));
-    }
-
-    /* Use with cascade to iterate results in descending (bottom -> top) order */
-    Base& desc() {
-        this->assert_term_id();
-        m_term_id->flags |= flecs::Desc;
-        return *this;
-    }
-
-    /* The parent flag is short for up(flecs::ChildOf) */
-    Base& parent() {
-        this->assert_term_id();
-        m_term_id->flags |= flecs::Parent;
-        return *this;
-    }
-
-    /* Specify relationship to traverse, and flags to indicate direction */
-    Base& trav(flecs::entity_t trav, flecs::flags32_t flags = 0) {
-        this->assert_term_id();
-        m_term_id->trav = trav;
-        m_term_id->flags |= flags;
+        term_id_->id |= flecs::Self;
         return *this;
     }
 
     /* Specify value of identifier by id */
     Base& id(flecs::entity_t id) {
         this->assert_term_id();
-        m_term_id->id = id;
+        term_id_->id = id;
         return *this;
     }
 
@@ -28122,45 +27109,44 @@ struct term_id_builder_i {
      */
     Base& entity(flecs::entity_t entity) {
         this->assert_term_id();
-        m_term_id->flags = flecs::IsEntity;
-        m_term_id->id = entity;
+        term_id_->id = entity | flecs::IsEntity;
         return *this;
     }
 
     /* Specify value of identifier by name */
     Base& name(const char *name) {
         this->assert_term_id();
-        m_term_id->flags |= flecs::IsEntity;
-        m_term_id->name = const_cast<char*>(name);
+        term_id_->id |= flecs::IsEntity;
+        term_id_->name = const_cast<char*>(name);
         return *this;
     }
 
     /* Specify identifier is a variable (resolved at query evaluation time) */
     Base& var(const char *var_name) {
         this->assert_term_id();
-        m_term_id->flags |= flecs::IsVariable;
-        m_term_id->name = const_cast<char*>(var_name);
+        term_id_->id |= flecs::IsVariable;
+        term_id_->name = const_cast<char*>(var_name);
         return *this;
     }
 
     /* Override term id flags */
     Base& flags(flecs::flags32_t flags) {
         this->assert_term_id();
-        m_term_id->flags = flags;
+        term_id_->id = flags;
         return *this;
     }
 
-    ecs_term_id_t *m_term_id;
-    
+    ecs_term_ref_t *term_id_;
+
 protected:
     virtual flecs::world_t* world_v() = 0;
 
-private:
     void assert_term_id() {
-        ecs_assert(m_term_id != NULL, ECS_INVALID_PARAMETER, 
+        ecs_assert(term_id_ != NULL, ECS_INVALID_PARAMETER, 
             "no active term (call .term() first)");
     }
 
+private:
     operator Base&() {
         return *static_cast<Base*>(this);
     }
@@ -28169,11 +27155,11 @@ struct term_id_builder_i {
 /** Term builder interface. 
  * A term is a single element of a query expression. 
  * 
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  */
 template<typename Base>
 struct term_builder_i : term_id_builder_i<Base> {
-    term_builder_i() : m_term(nullptr) { }
+    term_builder_i() : term_(nullptr) { }
 
     term_builder_i(ecs_term_t *term_ptr) { 
         set_term(term_ptr);
@@ -28186,7 +27172,7 @@ struct term_builder_i : term_id_builder_i<Base> {
     /* Call prior to setting values for src identifier */
     Base& src() {
         this->assert_term();
-        this->m_term_id = &m_term->src;
+        this->term_id_ = &term_->src;
         return *this;
     }
 
@@ -28195,7 +27181,7 @@ struct term_builder_i : term_id_builder_i<Base> {
      * populated as well). */
     Base& first() {
         this->assert_term();
-        this->m_term_id = &m_term->first;
+        this->term_id_ = &term_->first;
         return *this;
     }
 
@@ -28203,7 +27189,7 @@ struct term_builder_i : term_id_builder_i<Base> {
      * element of a pair. Requires that first() is populated as well. */
     Base& second() {
         this->assert_term();
-        this->m_term_id = &m_term->second;
+        this->term_id_ = &term_->second;
         return *this;
     }
 
@@ -28217,7 +27203,7 @@ struct term_builder_i : term_id_builder_i<Base> {
     /* Select src identifier, initialize it with id associated with type */
     template<typename T>
     Base& src() {
-        this->src(_::cpp_type<T>::id(this->world_v()));
+        this->src(_::type<T>::id(this->world_v()));
         return *this;
     }
 
@@ -28244,7 +27230,7 @@ struct term_builder_i : term_id_builder_i<Base> {
     /* Select first identifier, initialize it with id associated with type */
     template<typename T>
     Base& first() {
-        this->first(_::cpp_type<T>::id(this->world_v()));
+        this->first(_::type<T>::id(this->world_v()));
         return *this;
     }
 
@@ -28261,44 +27247,97 @@ struct term_builder_i : term_id_builder_i<Base> {
         return *this;
     }
 
-    /* Select second identifier, initialize it with entity id */
-    Base& second(flecs::entity_t id) {
-        this->second();
-        this->id(id);
+    /* Select second identifier, initialize it with entity id */
+    Base& second(flecs::entity_t id) {
+        this->second();
+        this->id(id);
+        return *this;
+    }
+
+    /* Select second identifier, initialize it with id associated with type */
+    template<typename T>
+    Base& second() {
+        this->second(_::type<T>::id(this->world_v()));
+        return *this;
+    }
+
+    /* Select second identifier, initialize it with name. If name starts with a $
+     * the name is interpreted as a variable. */
+    Base& second(const char *name) {
+        ecs_assert(name != NULL, ECS_INVALID_PARAMETER, NULL);
+        this->second();
+        if (name[0] == '$') {
+            this->var(&name[1]);
+        } else {
+            this->name(name);
+        }
+        return *this;
+    }
+
+    /* The up flag indicates that the term identifier may be substituted by
+     * traversing a relationship upwards. For example: substitute the identifier
+     * with its parent by traversing the ChildOf relationship. */
+    Base& up(flecs::entity_t trav = 0) {
+        this->assert_term_id();
+        this->term_id_->id |= flecs::Up;
+        if (trav) {
+            term_->trav = trav;
+        }
+        return *this;
+    }
+
+    template <typename Trav>
+    Base& up() {
+        return this->up(_::type<Trav>::id(this->world_v()));
+    }
+
+    /* The cascade flag is like up, but returns results in breadth-first order.
+     * Only supported for flecs::query */
+    Base& cascade(flecs::entity_t trav = 0) {
+        this->assert_term_id();
+        this->term_id_->id |= flecs::Cascade;
+        if (trav) {
+            term_->trav = trav;
+        }
         return *this;
     }
 
-    /* Select second identifier, initialize it with id associated with type */
-    template<typename T>
-    Base& second() {
-        this->second(_::cpp_type<T>::id(this->world_v()));
+    template <typename Trav>
+    Base& cascade() {
+        return this->cascade(_::type<Trav>::id(this->world_v()));
+    }
+
+    /* Use with cascade to iterate results in descending (bottom -> top) order */
+    Base& desc() {
+        this->assert_term_id();
+        this->term_id_->id |= flecs::Desc;
         return *this;
     }
 
-    /* Select second identifier, initialize it with name. If name starts with a $
-     * the name is interpreted as a variable. */
-    Base& second(const char *name) {
-        ecs_assert(name != NULL, ECS_INVALID_PARAMETER, NULL);
-        this->second();
-        if (name[0] == '$') {
-            this->var(&name[1]);
-        } else {
-            this->name(name);
-        }
+    /* Same as up(), exists for backwards compatibility */
+    Base& parent() {
+        return this->up();
+    }
+
+    /* Specify relationship to traverse, and flags to indicate direction */
+    Base& trav(flecs::entity_t trav, flecs::flags32_t flags = 0) {
+        this->assert_term_id();
+        term_->trav = trav;
+        this->term_id_->id |= flags;
         return *this;
     }
 
-    /** Set role of term. */
-    Base& role(id_t role) {
+    /** Set id flags for term. */
+    Base& id_flags(id_t flags) {
         this->assert_term();
-        m_term->id_flags = role;
+        term_->id |= flags;
         return *this;
     }
 
     /** Set read/write access of term. */
     Base& inout(flecs::inout_kind_t inout) {
         this->assert_term();
-        m_term->inout = static_cast<ecs_inout_kind_t>(inout);
+        term_->inout = static_cast<ecs_inout_kind_t>(inout);
         return *this;
     }
 
@@ -28312,8 +27351,8 @@ struct term_builder_i : term_id_builder_i<Base> {
      */
     Base& inout_stage(flecs::inout_kind_t inout) {
         this->assert_term();
-        m_term->inout = static_cast<ecs_inout_kind_t>(inout);
-        if (m_term->oper != EcsNot) {
+        term_->inout = static_cast<ecs_inout_kind_t>(inout);
+        if (term_->oper != EcsNot) {
             this->src().entity(0);
         }
         return *this;
@@ -28363,7 +27402,7 @@ struct term_builder_i : term_id_builder_i<Base> {
     /** Set operator of term. */
     Base& oper(flecs::oper_kind_t oper) {
         this->assert_term();
-        m_term->oper = static_cast<ecs_oper_kind_t>(oper);
+        term_->oper = static_cast<ecs_oper_kind_t>(oper);
         return *this;
     }
 
@@ -28405,47 +27444,47 @@ struct term_builder_i : term_id_builder_i<Base> {
     /** Match singleton. */
     Base& singleton() {
         this->assert_term();
-        ecs_assert(m_term->id || m_term->first.id, ECS_INVALID_PARAMETER, 
+        ecs_assert(term_->id || term_->first.id, ECS_INVALID_PARAMETER, 
                 "no component specified for singleton");
         
-        flecs::id_t sid = m_term->id;
+        flecs::id_t sid = term_->id;
         if (!sid) {
-            sid = m_term->first.id;
+            sid = term_->first.id;
         }
 
         ecs_assert(sid != 0, ECS_INVALID_PARAMETER, NULL);
 
         if (!ECS_IS_PAIR(sid)) {
-            m_term->src.id = sid;
+            term_->src.id = sid;
         } else {
-            m_term->src.id = ecs_pair_first(world(), sid);
+            term_->src.id = ecs_pair_first(world(), sid);
         }
         return *this;
     }
 
-    /* Filter terms are not triggered on by observers */
+    /* Query terms are not triggered on by observers */
     Base& filter() {
-        m_term->src.flags |= flecs::Filter;
+        term_->inout = EcsInOutFilter;
         return *this;
     }
 
-    ecs_term_t *m_term;
+    ecs_term_t *term_;
 
 protected:
     virtual flecs::world_t* world_v() = 0;
 
     void set_term(ecs_term_t *term) {
-        m_term = term;
+        term_ = term;
         if (term) {
-            this->m_term_id = &m_term->src; // default to subject
+            this->term_id_ = &term_->src; // default to subject
         } else {
-            this->m_term_id = nullptr;
+            this->term_id_ = nullptr;
         }
     }
 
 private:
     void assert_term() {
-        ecs_assert(m_term != NULL, ECS_INVALID_PARAMETER, 
+        ecs_assert(term_ != NULL, ECS_INVALID_PARAMETER, 
             "no active term (call .term() first)");
     }
 
@@ -28461,119 +27500,76 @@ namespace flecs {
 
 /** Class that describes a term.
  * 
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  */
 struct term final : term_builder_i<term> {
     term()
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(nullptr) { value.move = true; }
+        , world_(nullptr) { }
 
     term(flecs::world_t *world_ptr) 
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(world_ptr) { value.move = true; }
+        , world_(world_ptr) { }
 
     term(flecs::world_t *world_ptr, ecs_term_t t)
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(world_ptr) {
+        , world_(world_ptr) {
             value = t;
-            value.move = false;
             this->set_term(&value);
         }
 
     term(flecs::world_t *world_ptr, id_t id)
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(world_ptr) {
+        , world_(world_ptr) {
             if (id & ECS_ID_FLAGS_MASK) {
                 value.id = id;
             } else {
                 value.first.id = id;
             }
-            value.move = false;
             this->set_term(&value);
         }
 
     term(flecs::world_t *world_ptr, entity_t r, entity_t o)
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(world_ptr) {
+        , world_(world_ptr) {
             value.id = ecs_pair(r, o);
-            value.move = false;
             this->set_term(&value);
         }
 
     term(id_t id) 
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(nullptr) { 
+        , world_(nullptr) { 
             if (id & ECS_ID_FLAGS_MASK) {
                 value.id = id;
             } else {
                 value.first.id = id;
             }
-            value.move = true; 
         }
 
     term(id_t r, id_t o) 
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(nullptr) { 
+        , world_(nullptr) { 
             value.id = ecs_pair(r, o);
-            value.move = true; 
         }
 
-    term(const term& t) : term_builder_i<term>(&value) {
-        m_world = t.m_world;
-        value = ecs_term_copy(&t.value);
-        this->set_term(&value);
-    }
-
-    term(term&& t) noexcept : term_builder_i<term>(&value) {
-        m_world = t.m_world;
-        value = ecs_term_move(&t.value);
-        t.reset();
-        this->set_term(&value);
-    }
-
-    term& operator=(const term& t) {
-        ecs_assert(m_world == t.m_world, ECS_INVALID_PARAMETER, NULL);
-        ecs_term_fini(&value);
-        value = ecs_term_copy(&t.value);
-        this->set_term(&value);
-        return *this;
-    }
-
-    term& operator=(term&& t) noexcept {
-        ecs_assert(m_world == t.m_world, ECS_INVALID_PARAMETER, NULL);
-        ecs_term_fini(&value);
-        value = t.value;
-        this->set_term(&value);
-        t.reset();
-        return *this;
-    }   
-
-    ~term() {
-        ecs_term_fini(&value);
-    }
-
     void reset() {
         value = {};
         this->set_term(nullptr);
     }
 
-    int finalize() {
-        return ecs_term_finalize(m_world, &value);
-    }
-
     bool is_set() {
         return ecs_term_is_initialized(&value);
     }
 
     flecs::id id() {
-        return flecs::id(m_world, value.id);
+        return flecs::id(world_, value.id);
     }
 
     flecs::inout_kind_t inout() {
@@ -28585,60 +27581,60 @@ struct term final : term_builder_i<term> {
     }
 
     flecs::entity get_src() {
-        return flecs::entity(m_world, value.src.id);
+        return flecs::entity(world_, ECS_TERM_REF_ID(&value.src));
     }
 
     flecs::entity get_first() {
-        return flecs::entity(m_world, value.first.id);
+        return flecs::entity(world_, ECS_TERM_REF_ID(&value.first));
     }
 
     flecs::entity get_second() {
-        return flecs::entity(m_world, value.second.id);
+        return flecs::entity(world_, ECS_TERM_REF_ID(&value.second));
     }
 
-    ecs_term_t move() { /* explicit move to ecs_term_t */
-        return ecs_term_move(&value);
+    operator flecs::term_t() const {
+        return value;
     }
 
-    ecs_term_t value;
+    flecs::term_t value;
 
 protected:
-    flecs::world_t* world_v() override { return m_world; }
+    flecs::world_t* world_v() override { return world_; }
 
 private:
-    flecs::world_t *m_world;
+    flecs::world_t *world_;
 };
 
 // Term mixin implementation
 template <typename... Args>
 inline flecs::term world::term(Args &&... args) const {
-    return flecs::term(m_world, FLECS_FWD(args)...);
+    return flecs::term(world_, FLECS_FWD(args)...);
 }
 
 template <typename T>
 inline flecs::term world::term() const {
-    return flecs::term(m_world, _::cpp_type<T>::id(m_world));
+    return flecs::term(world_, _::type<T>::id(world_));
 }
 
 template <typename First, typename Second>
 inline flecs::term world::term() const {
-    return flecs::term(m_world, ecs_pair(
-        _::cpp_type<First>::id(m_world),
-        _::cpp_type<Second>::id(m_world)));
+    return flecs::term(world_, ecs_pair(
+        _::type<First>::id(world_),
+        _::type<Second>::id(world_)));
 }
 
 }
 
 /**
- * @file addons/cpp/mixins/filter/impl.hpp
- * @brief Filter implementation.
+ * @file addons/cpp/mixins/query/impl.hpp
+ * @brief Query implementation.
  */
 
 #pragma once
 
 /**
- * @file addons/cpp/mixins/filter/builder.hpp
- * @brief Filter builder.
+ * @file addons/cpp/mixins/query/builder.hpp
+ * @brief Query builder.
  */
 
 #pragma once
@@ -28666,32 +27662,32 @@ struct builder : IBuilder<Base, Components ...>
 
 public:
     builder(flecs::world_t *world)
-        : IBase(&m_desc)
-        , m_desc{}
-        , m_world(world) { }
+        : IBase(&desc_)
+        , desc_{}
+        , world_(world) { }
 
     builder(const builder& f) 
-        : IBase(&m_desc, f.m_term_index)
+        : IBase(&desc_, f.term_index_)
     {
-        m_world = f.m_world;
-        m_desc = f.m_desc;
+        world_ = f.world_;
+        desc_ = f.desc_;
     }
 
     builder(builder&& f)  noexcept
         : builder<T, TDesc, Base, IBuilder, Components...>(f) { }
 
     operator TDesc*() {
-        return &m_desc;
+        return &desc_;
     }
 
     T<Components ...> build() {
-        return T<Components...>(m_world, *static_cast<Base*>(this));
+        return T<Components...>(world_, *static_cast<Base*>(this));
     }
 
 protected:
-    flecs::world_t* world_v() override { return m_world; }
-    TDesc m_desc;
-    flecs::world_t *m_world;
+    flecs::world_t* world_v() override { return world_; }
+    TDesc desc_;
+    flecs::world_t *world_;
 };
 
 #undef FLECS_TBUILDER
@@ -28701,8 +27697,8 @@ struct builder : IBuilder<Base, Components ...>
 } // namespace flecs
 
 /**
- * @file addons/cpp/mixins/filter/builder_i.hpp
- * @brief Filter builder interface.
+ * @file addons/cpp/mixins/query/builder_i.hpp
+ * @brief Query builder interface.
  */
 
 #pragma once
@@ -28711,600 +27707,237 @@ struct builder : IBuilder<Base, Components ...>
 namespace flecs 
 {
 
-/** Filter builder interface.
+/** Query builder interface.
  * 
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  */
 template<typename Base, typename ... Components>
-struct filter_builder_i : term_builder_i<Base> {
-    filter_builder_i(ecs_filter_desc_t *desc, int32_t term_index = 0) 
-        : m_term_index(term_index)
-        , m_expr_count(0)
-        , m_desc(desc) { }
+struct query_builder_i : term_builder_i<Base> {
+    query_builder_i(ecs_query_desc_t *desc, int32_t term_index = 0) 
+        : term_index_(term_index)
+        , expr_count_(0)
+        , desc_(desc) { }
 
     Base& instanced() {
-        m_desc->instanced = true;
-        return *this;
-    }
-
-    Base& filter_flags(ecs_flags32_t flags) {
-        m_desc->flags |= flags;
-        return *this;
-    }
-
-    Base& expr(const char *expr) {
-        ecs_check(m_expr_count == 0, ECS_INVALID_OPERATION,
-            "filter_builder::expr() called more than once");
-        m_desc->expr = expr;
-        m_expr_count ++;
-
-    error:
-        return *this;
-    }
-
-    /* With/without shorthand notation. */
-
-    template <typename ... Args>
-    Base& with(Args&&... args) {
-        return this->term(FLECS_FWD(args)...).inout_none();
-    }
-
-    template <typename T, typename ... Args>
-    Base& with(Args&&... args) {
-        return this->term<T>(FLECS_FWD(args)...).inout_none();
-    }
-
-    template <typename First, typename Second>
-    Base& with() {
-        return this->term<First, Second>().inout_none();
-    }
-
-    template <typename ... Args>
-    Base& without(Args&&... args) {
-        return this->term(FLECS_FWD(args)...).not_();
-    }
-
-    template <typename T, typename ... Args>
-    Base& without(Args&&... args) {
-        return this->term<T>(FLECS_FWD(args)...).not_();
-    }
-
-    template <typename First, typename Second>
-    Base& without() {
-        return this->term<First, Second>().not_();
-    }
-
-    /* Write/read shorthand notation */
-
-    Base& write() {
-        term_builder_i<Base>::write();
-        return *this;
-    }
-
-    template <typename ... Args>
-    Base& write(Args&&... args) {
-        return this->term(FLECS_FWD(args)...).write();
-    }
-
-    template <typename T, typename ... Args>
-    Base& write(Args&&... args) {
-        return this->term<T>(FLECS_FWD(args)...).write();
-    }
-
-    template <typename First, typename Second>
-    Base& write() {
-        return this->term<First, Second>().write();
-    }
-
-    Base& read() {
-        term_builder_i<Base>::read();
-        return *this;
-    }
-
-    template <typename ... Args>
-    Base& read(Args&&... args) {
-        return this->term(FLECS_FWD(args)...).read();
-    }
-
-    template <typename T, typename ... Args>
-    Base& read(Args&&... args) {
-        return this->term<T>(FLECS_FWD(args)...).read();
-    }
-
-    template <typename First, typename Second>
-    Base& read() {
-        return this->term<First, Second>().read();
-    }
-
-    /* Scope_open/scope_close shorthand notation. */
-    Base& scope_open() {
-        return this->with(flecs::ScopeOpen).entity(0);
-    }
-
-    Base& scope_close() {
-        return this->with(flecs::ScopeClose).entity(0);
-    }
-
-    /* Term notation for more complex query features */
-
-    Base& term() {
-        if (this->m_term) {
-            ecs_check(ecs_term_is_initialized(this->m_term), 
-                ECS_INVALID_OPERATION, 
-                    "filter_builder::term() called without initializing term");
-        }
-
-        if (m_term_index >= FLECS_TERM_DESC_MAX) {
-            if (m_term_index == FLECS_TERM_DESC_MAX) {
-                m_desc->terms_buffer = ecs_os_calloc_n(
-                    ecs_term_t, m_term_index + 1);
-                ecs_os_memcpy_n(m_desc->terms_buffer, m_desc->terms, 
-                    ecs_term_t, m_term_index);
-                ecs_os_memset_n(m_desc->terms, 0, 
-                    ecs_term_t, FLECS_TERM_DESC_MAX);
-            } else {
-                m_desc->terms_buffer = ecs_os_realloc_n(m_desc->terms_buffer, 
-                    ecs_term_t, m_term_index + 1);
-            }
-
-            m_desc->terms_buffer_count = m_term_index + 1;
-
-            this->set_term(&m_desc->terms_buffer[m_term_index]);
-        } else {
-            this->set_term(&m_desc->terms[m_term_index]);
-        }
-
-        m_term_index ++;
-    
-    error:
-        return *this;
-    }
-
-    Base& term_at(int32_t term_index) {
-        ecs_assert(term_index > 0, ECS_INVALID_PARAMETER, NULL);
-        int32_t prev_index = m_term_index;
-        m_term_index = term_index - 1;
-        this->term();
-        m_term_index = prev_index;
-        ecs_assert(ecs_term_is_initialized(this->m_term), 
-            ECS_INVALID_PARAMETER, NULL);
-        return *this;
-    }
-
-    Base& arg(int32_t term_index) {
-        return this->term_at(term_index);
-    }
-
-    template<typename T>
-    Base& term() {
-        this->term();
-        *this->m_term = flecs::term(_::cpp_type<T>::id(this->world_v())).move();
-        this->m_term->inout = static_cast<ecs_inout_kind_t>(
-            _::type_to_inout<T>());
-        return *this;
-    }
-
-    Base& term(id_t id) {
-        this->term();
-        *this->m_term = flecs::term(id).move();
-        return *this;
-    }
-
-    Base& term(const char *name) {
-        this->term();
-        *this->m_term = flecs::term().first(name).move();
-        return *this;
-    }
-
-    Base& term(const char *first, const char *second) {
-        this->term();
-        *this->m_term = flecs::term().first(first).second(second).move();
-        return *this;
-    }
-
-    Base& term(entity_t r, entity_t o) {
-        this->term();
-        *this->m_term = flecs::term(r, o).move();
+        desc_->flags |= EcsQueryIsInstanced;
         return *this;
     }
 
-    Base& term(entity_t r, const char *o) {
-        this->term();
-        *this->m_term = flecs::term(r).second(o).move();
-        return *this;
-    }
-
-    template<typename First>
-    Base& term(id_t o) {
-        return this->term(_::cpp_type<First>::id(this->world_v()), o);
-    }
-
-    template<typename First>
-    Base& term(const char *second) {
-        return this->term(_::cpp_type<First>::id(this->world_v())).second(second);
-    }
-
-    template<typename First, typename Second>
-    Base& term() {
-        return this->term<First>(_::cpp_type<Second>::id(this->world_v()));
-    }
-
-    template <typename E, if_t< is_enum<E>::value > = 0>
-    Base& term(E value) {
-        flecs::entity_t r = _::cpp_type<E>::id(this->world_v());
-        auto o = enum_type<E>(this->world_v()).entity(value);
-        return this->term(r, o);
-    }
-
-    Base& term(flecs::term& term) {
-        this->term();
-        *this->m_term = term.move();
-        return *this;
-    }
-
-    Base& term(flecs::term&& term) {
-        this->term();
-        *this->m_term = term.move();
-        return *this;
-    }
-
-protected:
-    virtual flecs::world_t* world_v() = 0;
-    int32_t m_term_index;
-    int32_t m_expr_count;
-
-private:
-    operator Base&() {
-        return *static_cast<Base*>(this);
-    }
-
-    ecs_filter_desc_t *m_desc;
-};
-
-}
-
-
-namespace flecs {
-namespace _ {
-    template <typename ... Components>
-    using filter_builder_base = builder<
-        filter, ecs_filter_desc_t, filter_builder<Components...>, 
-        filter_builder_i, Components ...>;
-}
-
-/** Filter builder.
- * 
- * @ingroup cpp_core_filters
- */
-template <typename ... Components>
-struct filter_builder final : _::filter_builder_base<Components...> {
-    filter_builder(flecs::world_t* world, const char *name = nullptr)
-        : _::filter_builder_base<Components...>(world)
-    {
-        _::sig<Components...>(world).populate(this);
-        if (name != nullptr) {
-            ecs_entity_desc_t entity_desc = {};
-            entity_desc.name = name;
-            entity_desc.sep = "::";
-            entity_desc.root_sep = "::";
-            this->m_desc.entity = ecs_entity_init(world, &entity_desc);
-        }
-    }
-
-    template <typename Func>
-    void each(Func&& func) {
-        this->build().each(FLECS_FWD(func));
-    }
-};
-
-}
+    Base& flags(ecs_flags32_t flags) {
+        desc_->flags |= flags;
+        return *this;
+    }
 
+    Base& cache_kind(query_cache_kind_t kind) {
+        desc_->cache_kind = static_cast<ecs_query_cache_kind_t>(kind);
+        return *this;
+    }
 
-namespace flecs 
-{
+    Base& cached() {
+        return cache_kind(flecs::QueryCacheAuto);
+    }
 
-struct filter_base {
-    filter_base()
-        : m_world(nullptr)
-        , m_filter({})
-        , m_filter_ptr(nullptr) { }
-
-    filter_base(world_t *world, const ecs_filter_t *filter)
-        : m_world(world)
-        , m_filter({})
-        , m_filter_ptr(filter) { }
-
-    filter_base(world_t *world, ecs_filter_t *filter)
-        : m_world(world)
-        , m_filter_ptr(&m_filter) {
-            ecs_filter_move(&m_filter, filter);
-        }
+    Base& expr(const char *expr) {
+        ecs_check(expr_count_ == 0, ECS_INVALID_OPERATION,
+            "query_builder::expr() called more than once");
+        desc_->expr = expr;
+        expr_count_ ++;
 
-    filter_base(world_t *world, ecs_filter_desc_t *desc) 
-        : m_world(world)
-    {
-        desc->storage = &m_filter;
+    error:
+        return *this;
+    }
 
-        if (ecs_filter_init(world, desc) == NULL) {
-            ecs_abort(ECS_INVALID_PARAMETER, NULL);
-        }
+    /* With methods */
 
-        if (desc->terms_buffer) {
-            ecs_os_free(desc->terms_buffer);
+    template<typename T>
+    Base& with() {
+        this->term();
+        *this->term_ = flecs::term(_::type<T>::id(this->world_v()));
+        this->term_->inout = static_cast<ecs_inout_kind_t>(
+            _::type_to_inout<T>());
+            if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
         }
-
-        m_filter_ptr = &m_filter;
+        return *this;
     }
 
-    filter_base(const filter_base& obj) {
-        this->m_world = obj.m_world;
-        if (obj.m_filter_ptr) {
-            this->m_filter_ptr = &this->m_filter;
-        } else {
-            this->m_filter_ptr = nullptr;
+    Base& with(id_t id) {
+        this->term();
+        *this->term_ = flecs::term(id);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
         }
-        ecs_filter_copy(&m_filter, &obj.m_filter);
+        return *this;
     }
 
-    filter_base& operator=(const filter_base& obj) {
-        this->m_world = obj.m_world;
-        if (obj.m_filter_ptr) {
-            this->m_filter_ptr = &this->m_filter;
-        } else {
-            this->m_filter_ptr = nullptr;
+    Base& with(const char *name) {
+        this->term();
+        *this->term_ = flecs::term().first(name);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
         }
-        ecs_filter_copy(&m_filter, &obj.m_filter);
-        return *this; 
+        return *this;
     }
 
-    filter_base(filter_base&& obj) noexcept {
-        this->m_world = obj.m_world;
-        if (obj.m_filter_ptr) {
-            this->m_filter_ptr = &this->m_filter;
-        } else {
-            this->m_filter_ptr = nullptr;
+    Base& with(const char *first, const char *second) {
+        this->term();
+        *this->term_ = flecs::term().first(first).second(second);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
         }
-        ecs_filter_move(&m_filter, &obj.m_filter);
+        return *this;
     }
 
-    filter_base& operator=(filter_base&& obj) noexcept {
-        this->m_world = obj.m_world;
-        if (obj.m_filter_ptr) {
-            this->m_filter_ptr = &this->m_filter;
-        } else {
-            this->m_filter_ptr = nullptr;
+    Base& with(entity_t r, entity_t o) {
+        this->term();
+        *this->term_ = flecs::term(r, o);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
         }
-        ecs_filter_move(&m_filter, &obj.m_filter);
-        return *this; 
+        return *this;
     }
 
-    flecs::entity entity() {
-        return flecs::entity(m_world, ecs_get_entity(m_filter_ptr));
+    Base& with(entity_t r, const char *o) {
+        this->term();
+        *this->term_ = flecs::term(r).second(o);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
+        }
+        return *this;
     }
 
-    operator const flecs::filter_t*() const {
-        return m_filter_ptr;
+    template<typename First>
+    Base& with(id_t o) {
+        return this->with(_::type<First>::id(this->world_v()), o);
     }
 
-    /** Free the filter.
-     */
-    ~filter_base() {
-        if ((&m_filter == m_filter_ptr) && m_filter_ptr) {
-            ecs_filter_fini(&m_filter);
-        }
+    template<typename First>
+    Base& with(const char *second) {
+        return this->with(_::type<First>::id(this->world_v())).second(second);
     }
 
-    template <typename Func>
-    void each_term(const Func& func) {
-        for (int i = 0; i < m_filter_ptr->term_count; i ++) {
-            flecs::term t(m_world, m_filter_ptr->terms[i]);
-            func(t);
-            t.reset(); // prevent freeing resources
-        }
+    template<typename First, typename Second>
+    Base& with() {
+        return this->with<First>(_::type<Second>::id(this->world_v()));
     }
 
-    flecs::term term(int32_t index) {
-        return flecs::term(m_world, m_filter_ptr->terms[index]);
+    template <typename E, if_t< is_enum<E>::value > = 0>
+    Base& with(E value) {
+        flecs::entity_t r = _::type<E>::id(this->world_v());
+        auto o = enum_type<E>(this->world_v()).entity(value);
+        return this->with(r, o);
     }
 
-    int32_t field_count() {
-        return m_filter_ptr->term_count;
+    Base& with(flecs::term& term) {
+        this->term();
+        *this->term_ = term;
+        return *this;
     }
 
-    flecs::string str() {
-        char *result = ecs_filter_str(m_world, m_filter_ptr);
-        return flecs::string(result);
+    Base& with(flecs::term&& term) {
+        this->term();
+        *this->term_ = term;
+        return *this;
     }
 
-    operator filter<>() const;
-
-protected:
-    world_t *m_world = nullptr;
-    filter_t m_filter = ECS_FILTER_INIT;
-    const filter_t *m_filter_ptr;
-};
-
-template<typename ... Components>
-struct filter : filter_base, iterable<Components...> {
-private:
-    using Terms = typename _::term_ptrs<Components...>::array;
-
-public:
-    using filter_base::filter_base;
+    /* Without methods, shorthand for .with(...).not_(). */
 
-    filter() : filter_base() { } // necessary not to confuse msvc
+    template <typename ... Args>
+    Base& without(Args&&... args) {
+        return this->with(FLECS_FWD(args)...).not_();
+    }
 
-    filter(const filter& obj) : filter_base(obj) { }
+    template <typename T, typename ... Args>
+    Base& without(Args&&... args) {
+        return this->with<T>(FLECS_FWD(args)...).not_();
+    }
 
-    filter& operator=(const filter& obj) {
-        filter_base::operator=(obj);
-        return *this;
+    template <typename First, typename Second>
+    Base& without() {
+        return this->with<First, Second>().not_();
     }
 
-    filter(filter&& obj) noexcept : filter_base(FLECS_MOV(obj)) { }
+    /* Write/read methods */
 
-    filter& operator=(filter&& obj) noexcept {
-        filter_base::operator=(FLECS_FWD(obj));
+    Base& write() {
+        term_builder_i<Base>::write();
         return *this;
     }
 
-private:
-    ecs_iter_t get_iter(flecs::world_t *world) const override {
-        if (!world) {
-            world = m_world;
-        }
-        return ecs_filter_iter(world, m_filter_ptr);
+    template <typename ... Args>
+    Base& write(Args&&... args) {
+        return this->with(FLECS_FWD(args)...).write();
     }
 
-    ecs_iter_next_action_t next_action() const override {
-        return ecs_filter_next;
+    template <typename T, typename ... Args>
+    Base& write(Args&&... args) {
+        return this->with<T>(FLECS_FWD(args)...).write();
     }
 
-    ecs_iter_next_action_t next_each_action() const override {
-        return ecs_filter_next_instanced;
+    template <typename First, typename Second>
+    Base& write() {
+        return this->with<First, Second>().write();
     }
-};
-
-// World mixin implementation
-template <typename... Comps, typename... Args>
-inline flecs::filter<Comps...> world::filter(Args &&... args) const {
-    return flecs::filter_builder<Comps...>(m_world, FLECS_FWD(args)...)
-        .build();
-}
-
-template <typename... Comps, typename... Args>
-inline flecs::filter_builder<Comps...> world::filter_builder(Args &&... args) const {
-    return flecs::filter_builder<Comps...>(m_world, FLECS_FWD(args)...);
-}
-
-// world::each
-namespace _ {
 
-// Each with entity parameter
-template<typename Func, typename ... Args>
-struct filter_delegate_w_ent;
-
-template<typename Func, typename E, typename ... Args>
-struct filter_delegate_w_ent<Func, arg_list<E, Args ...> >
-{
-    filter_delegate_w_ent(const flecs::world& world, Func&& func) {
-        auto f = world.filter<Args ...>();
-        f.each(FLECS_MOV(func));
+    Base& read() {
+        term_builder_i<Base>::read();
+        return *this;
     }
-};
-
-// Each without entity parameter
-template<typename Func, typename ... Args>
-struct filter_delegate_no_ent;
 
-template<typename Func, typename ... Args>
-struct filter_delegate_no_ent<Func, arg_list<Args ...> >
-{
-    filter_delegate_no_ent(const flecs::world& world, Func&& func) {
-        auto f = world.filter<Args ...>();
-        f.each(FLECS_MOV(func));
+    template <typename ... Args>
+    Base& read(Args&&... args) {
+        return this->with(FLECS_FWD(args)...).read();
     }
-};
-
-// Switch between function with & without entity parameter
-template<typename Func, typename T = int>
-struct filter_delegate;
 
-template <typename Func>
-struct filter_delegate<Func, if_t<is_same<first_arg_t<Func>, flecs::entity>::value> > {
-    filter_delegate(const flecs::world& world, Func&& func) {
-        filter_delegate_w_ent<Func, arg_list_t<Func>>(world, FLECS_MOV(func));
+    template <typename T, typename ... Args>
+    Base& read(Args&&... args) {
+        return this->with<T>(FLECS_FWD(args)...).read();
     }
-};
 
-template <typename Func>
-struct filter_delegate<Func, if_not_t<is_same<first_arg_t<Func>, flecs::entity>::value> > {
-    filter_delegate(const flecs::world& world, Func&& func) {
-        filter_delegate_no_ent<Func, arg_list_t<Func>>(world, FLECS_MOV(func));
+    template <typename First, typename Second>
+    Base& read() {
+        return this->with<First, Second>().read();
     }
-};
-
-}
 
-template <typename Func>
-inline void world::each(Func&& func) const {
-    _::filter_delegate<Func> f_delegate(*this, FLECS_MOV(func));
-}
-
-template <typename T, typename Func>
-inline void world::each(Func&& func) const {
-    ecs_term_t t = {};
-    t.id = _::cpp_type<T>::id();
-    ecs_iter_t it = ecs_term_iter(m_world, &t);
-
-    while (ecs_term_next(&it)) {
-        _::each_delegate<Func, T>(func).invoke(&it);
+    /* Scope_open/scope_close shorthand notation. */
+    Base& scope_open() {
+        return this->with(flecs::ScopeOpen).entity(0);
     }
-}
 
-template <typename Func>
-inline void world::each(flecs::id_t term_id, Func&& func) const {
-    ecs_term_t t = {};
-    t.id = term_id;
-    ecs_iter_t it = ecs_term_iter(m_world, &t);
-
-    while (ecs_term_next(&it)) {
-        _::each_delegate<Func>(func).invoke(&it);
+    Base& scope_close() {
+        return this->with(flecs::ScopeClose).entity(0);
     }
-}
-
-// filter_base implementation
-inline filter_base::operator flecs::filter<> () const {
-    flecs::filter<> f;
-    ecs_filter_copy(&f.m_filter, &this->m_filter);
-    f.m_filter_ptr = &f.m_filter;
-    f.m_world = this->m_world;
-    return f;
-}
-
-}
-
-/**
- * @file addons/cpp/mixins/query/impl.hpp
- * @brief Query implementation.
- */
-
-#pragma once
-
-/**
- * @file addons/cpp/mixins/query/builder.hpp
- * @brief Query builder.
- */
-
-#pragma once
 
-/**
- * @file addons/cpp/mixins/query/builder_i.hpp
- * @brief Query builder interface.
- */
+    /* Term notation for more complex query features */
 
-#pragma once
+    Base& term() {
+        if (this->term_) {
+            ecs_check(ecs_term_is_initialized(this->term_), 
+                ECS_INVALID_OPERATION, 
+                    "query_builder::term() called without initializing term");
+        }
 
+        ecs_check(term_index_ < FLECS_TERM_COUNT_MAX, 
+            ECS_INVALID_PARAMETER, "maximum number of terms exceeded");
 
-namespace flecs {
+        this->set_term(&desc_->terms[term_index_]);
 
-/** Query builder interface.
- * 
- * @ingroup cpp_core_queries
- */
-template<typename Base, typename ... Components>
-struct query_builder_i : filter_builder_i<Base, Components ...> {
-private:
-    using BaseClass = filter_builder_i<Base, Components ...>;
+        term_index_ ++;
     
-public:
-    query_builder_i()
-        : BaseClass(nullptr)
-        , m_desc(nullptr) { }
+    error:
+        return *this;
+    }
 
-    query_builder_i(ecs_query_desc_t *desc, int32_t term_index = 0) 
-        : BaseClass(&desc->filter, term_index)
-        , m_desc(desc) { }
+    Base& term_at(int32_t term_index) {
+        ecs_assert(term_index >= 0, ECS_INVALID_PARAMETER, NULL);
+        int32_t prev_index = term_index_;
+        term_index_ = term_index;
+        this->term();
+        term_index_ = prev_index;
+        ecs_assert(ecs_term_is_initialized(this->term_), 
+            ECS_INVALID_PARAMETER, NULL);
+        return *this;
+    }
 
     /** Sort the output of a query.
      * This enables sorting of entities across matched tables. As a result of this
@@ -29327,7 +27960,7 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
     template <typename T>
     Base& order_by(int(*compare)(flecs::entity_t, const T*, flecs::entity_t, const T*)) {
         ecs_order_by_action_t cmp = reinterpret_cast<ecs_order_by_action_t>(compare);
-        return this->order_by(_::cpp_type<T>::id(this->world_v()), cmp);
+        return this->order_by(_::type<T>::id(this->world_v()), cmp);
     }
 
     /** Sort the output of a query.
@@ -29337,8 +27970,8 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
      * @param compare The compare function used to sort the components.
      */    
     Base& order_by(flecs::entity_t component, int(*compare)(flecs::entity_t, const void*, flecs::entity_t, const void*)) {
-        m_desc->order_by = reinterpret_cast<ecs_order_by_action_t>(compare);
-        m_desc->order_by_component = component;
+        desc_->order_by_callback = reinterpret_cast<ecs_order_by_action_t>(compare);
+        desc_->order_by = component;
         return *this;
     }
 
@@ -29362,7 +27995,7 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
     template <typename T>
     Base& group_by(uint64_t(*group_by_action)(flecs::world_t*, flecs::table_t *table, flecs::id_t id, void* ctx)) {
         ecs_group_by_action_t action = reinterpret_cast<ecs_group_by_action_t>(group_by_action);
-        return this->group_by(_::cpp_type<T>::id(this->world_v()), action);
+        return this->group_by(_::type<T>::id(this->world_v()), action);
     }
 
     /** Group and sort matched tables.
@@ -29372,8 +28005,8 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
      * @param group_by_action Callback that determines group id for table.
      */
     Base& group_by(flecs::entity_t component, uint64_t(*group_by_action)(flecs::world_t*, flecs::table_t *table, flecs::id_t id, void* ctx)) {
-        m_desc->group_by = reinterpret_cast<ecs_group_by_action_t>(group_by_action);
-        m_desc->group_by_id = component;
+        desc_->group_by_callback = reinterpret_cast<ecs_group_by_action_t>(group_by_action);
+        desc_->group_by = component;
         return *this;
     }
 
@@ -29384,7 +28017,7 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
      */
     template <typename T>
     Base& group_by() {
-        return this->group_by(_::cpp_type<T>::id(this->world_v()), nullptr);
+        return this->group_by(_::type<T>::id(this->world_v()), nullptr);
     }
 
     /** Group and sort matched tables.
@@ -29402,37 +28035,36 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
      * @param ctx_free Function to cleanup context (called when query is deleted).
      */
     Base& group_by_ctx(void *ctx, ecs_ctx_free_t ctx_free = nullptr) {
-        m_desc->group_by_ctx = ctx;
-        m_desc->group_by_ctx_free = ctx_free;
+        desc_->group_by_ctx = ctx;
+        desc_->group_by_ctx_free = ctx_free;
         return *this;
     }
 
     /** Specify on_group_create action.
      */
     Base& on_group_create(ecs_group_create_action_t action) {
-        m_desc->on_group_create = action;
+        desc_->on_group_create = action;
         return *this;
     }
 
     /** Specify on_group_delete action.
      */
     Base& on_group_delete(ecs_group_delete_action_t action) {
-        m_desc->on_group_delete = action;
+        desc_->on_group_delete = action;
         return *this;
     }
 
-    /** Specify parent query (creates subquery) */
-    Base& observable(const query_base& parent);
-    
 protected:
     virtual flecs::world_t* world_v() = 0;
+    int32_t term_index_;
+    int32_t expr_count_;
 
 private:
     operator Base&() {
         return *static_cast<Base*>(this);
     }
 
-    ecs_query_desc_t *m_desc;
+    ecs_query_desc_t *desc_;
 };
 
 }
@@ -29452,6 +28084,13 @@ namespace _ {
  */
 template <typename ... Components>
 struct query_builder final : _::query_builder_base<Components...> {
+    query_builder(flecs::world_t* world, flecs::entity query_entity)
+        : _::query_builder_base<Components...>(world)
+    {
+        _::sig<Components...>(world).populate(this);
+        this->desc_.entity = query_entity.id();
+    }
+
     query_builder(flecs::world_t* world, const char *name = nullptr)
         : _::query_builder_base<Components...>(world)
     {
@@ -29461,45 +28100,106 @@ struct query_builder final : _::query_builder_base<Components...> {
             entity_desc.name = name;
             entity_desc.sep = "::";
             entity_desc.root_sep = "::";
-            this->m_desc.filter.entity = ecs_entity_init(world, &entity_desc);
+            this->desc_.entity = ecs_entity_init(world, &entity_desc);
         }
     }
+
+    template <typename Func>
+    void each(Func&& func) {
+        this->build().each(FLECS_FWD(func));
+    }
 };
 
 }
 
 
-namespace flecs {
-
-////////////////////////////////////////////////////////////////////////////////
-//// Persistent queries
-////////////////////////////////////////////////////////////////////////////////
+namespace flecs 
+{
 
 struct query_base {
-    query_base()
-        : m_world(nullptr)
-        , m_query(nullptr) { }    
-    
-    query_base(world_t *world, query_t *query = nullptr)
-        : m_world(world)
-        , m_query(query) { }
+    query_base() { }
 
-    query_base(world_t *world, ecs_query_desc_t *desc) 
-        : m_world(world)
-    {
-        m_query = ecs_query_init(world, desc);
+    query_base(query_t *q)
+        : query_(q) { 
+            flecs_poly_claim(q);
+        }
 
-        if (!m_query) {
-            ecs_abort(ECS_INVALID_PARAMETER, NULL);
+    query_base(const query_t *q)
+        : query_(ECS_CONST_CAST(query_t*, q)) { 
+            flecs_poly_claim(q);
         }
 
-        if (desc->filter.terms_buffer) {
-            ecs_os_free(desc->filter.terms_buffer);
+    query_base(world_t *world, ecs_query_desc_t *desc) {
+        if (desc->entity && desc->terms[0].id == 0) {
+            const flecs::Poly *query_poly = ecs_get_pair(
+                world, desc->entity, EcsPoly, EcsQuery);
+            if (query_poly) {
+                query_ = static_cast<flecs::query_t*>(query_poly->poly);
+                flecs_poly_claim(query_);
+                return;
+            }
         }
+
+        query_ = ecs_query_init(world, desc);
+    }
+
+    query_base(const query_base& obj) {
+        this->query_ = obj.query_;
+        flecs_poly_claim(this->query_);
     }
 
-    operator query_t*() const {
-        return m_query;
+    query_base& operator=(const query_base& obj) {
+        this->query_ = obj.query_;
+        flecs_poly_claim(this->query_);
+        return *this; 
+    }
+
+    query_base(query_base&& obj) noexcept {
+        this->query_ = obj.query_;
+        obj.query_ = nullptr;
+    }
+
+    query_base& operator=(query_base&& obj) noexcept {
+        this->query_ = obj.query_;
+        obj.query_ = nullptr;
+        return *this; 
+    }
+
+    flecs::entity entity() {
+        return flecs::entity(query_->world, query_->entity);
+    }
+
+    operator const flecs::query_t*() const {
+        return query_;
+    }
+
+    operator bool() const {
+        return query_ != nullptr;
+    }
+
+    /** Free persistent query.
+     * A persistent query is a query that is associated with an entity, such as
+     * system queries and named queries. Persistent queries must be deleted with
+     * destruct(), or will be deleted automatically at world cleanup. 
+     */
+    void destruct() {
+        ecs_assert(query_->entity != 0, ECS_INVALID_OPERATION, "destruct() "
+            "should only be called on queries associated with entities");
+        ecs_query_fini(query_);
+        query_ = nullptr;
+    }
+
+    ~query_base() {
+        /* Only free if query is not associated with entity, such as system
+         * queries and named queries. Named queries have to be either explicitly
+         * deleted with the .destruct() method, or will be deleted when the
+         * world is deleted. */
+        if (query_ && !query_->entity) {
+            if (!flecs_poly_release(query_)) {
+                ecs_query_fini(query_);
+                query_ = nullptr;
+            }
+        }
     }
 
     /** Returns whether the query data changed since the last iteration.
@@ -29512,18 +28212,7 @@ struct query_base {
      * @return true if entities changed, otherwise false.
      */
     bool changed() const {
-        return ecs_query_changed(m_query, 0);
-    }
-
-    /** Returns whether query is orphaned.
-     * When the parent query of a subquery is deleted, it is left in an orphaned
-     * state. The only valid operation on an orphaned query is deleting it. Only
-     * subqueries can be orphaned.
-     *
-     * @return true if query is orphaned, otherwise false.
-     */
-    bool orphaned() const {
-        return ecs_query_orphaned(m_query);
+        return ecs_query_changed(query_);
     }
 
     /** Get info for group. 
@@ -29532,7 +28221,7 @@ struct query_base {
      * @return The group info.
      */
     const flecs::query_group_info_t* group_info(uint64_t group_id) const {
-        return ecs_query_get_group_info(m_query, group_id);
+        return ecs_query_get_group_info(query_, group_id);
     }
 
     /** Get context for group. 
@@ -29549,66 +28238,81 @@ struct query_base {
         }
     }
 
-    /** Free the query.
-     */
-    void destruct() {
-        ecs_query_fini(m_query);
-        m_world = nullptr;
-        m_query = nullptr;
+    template <typename Func>
+    void each_term(const Func& func) {
+        for (int i = 0; i < query_->term_count; i ++) {
+            flecs::term t(query_->world, query_->terms[i]);
+            func(t);
+            t.reset(); // prevent freeing resources
+        }
     }
 
-    template <typename Func>
-    void each_term(const Func& func) const {
-        this->filter().each_term(func);
+    flecs::term term(int32_t index) {
+        return flecs::term(query_->world, query_->terms[index]);
     }
 
-    filter_base filter() const {
-        return filter_base(m_world, ecs_query_get_filter(m_query));
+    int32_t term_count() {
+        return query_->term_count;
     }
 
-    flecs::term term(int32_t index) const {
-        const ecs_filter_t *f = ecs_query_get_filter(m_query);
-        ecs_assert(f != NULL, ECS_INVALID_PARAMETER, NULL);
-        return flecs::term(m_world, f->terms[index]);
+    int32_t field_count() {
+        return query_->field_count;
     }
 
-    int32_t field_count() const {
-        const ecs_filter_t *f = ecs_query_get_filter(m_query);
-        return f->term_count;   
+    int32_t find_var(const char *name) {
+        return ecs_query_find_var(query_, name);
     }
 
-    flecs::string str() const {
-        const ecs_filter_t *f = ecs_query_get_filter(m_query);
-        char *result = ecs_filter_str(m_world, f);
+    flecs::string str() {
+        char *result = ecs_query_str(query_);
         return flecs::string(result);
     }
 
-    flecs::entity entity() const {
-        return flecs::entity(m_world, ecs_get_entity(m_query));
+    /** Returns a string representing the query plan.
+     * This can be used to analyze the behavior & performance of the query.
+     * @see ecs_query_plan
+     */
+    flecs::string plan() const {
+        char *result = ecs_query_plan(query_);
+        return flecs::string(result);
     }
-    
+
     operator query<>() const;
 
 protected:
-    world_t *m_world;
-    query_t *m_query;
+    query_t *query_ = nullptr;
 };
 
 template<typename ... Components>
-struct query final : query_base, iterable<Components...> {
-public:
-    flecs::world world() const {
-        return flecs::world(m_world);
-    }
-    
+struct query : query_base, iterable<Components...> {
 private:
     using Terms = typename _::term_ptrs<Components...>::array;
 
+public:
+    using query_base::query_base;
+
+    query() : query_base() { } // necessary not to confuse msvc
+
+    query(const query& obj) : query_base(obj) { }
+
+    query& operator=(const query& obj) {
+        query_base::operator=(obj);
+        return *this;
+    }
+
+    query(query&& obj) noexcept : query_base(FLECS_MOV(obj)) { }
+
+    query& operator=(query&& obj) noexcept {
+        query_base::operator=(FLECS_FWD(obj));
+        return *this;
+    }
+
+private:
     ecs_iter_t get_iter(flecs::world_t *world) const override {
         if (!world) {
-            world = m_world;
+            world = query_->world;
         }
-        return ecs_query_iter(world, m_query);
+        return ecs_query_iter(world, query_);
     }
 
     ecs_iter_next_action_t next_action() const override {
@@ -29618,36 +28322,104 @@ struct query final : query_base, iterable<Components...> {
     ecs_iter_next_action_t next_each_action() const override {
         return ecs_query_next_instanced;
     }
-
-public:
-    using query_base::query_base;
 };
 
-// Mixin implementation
+// World mixin implementation
 template <typename... Comps, typename... Args>
 inline flecs::query<Comps...> world::query(Args &&... args) const {
-    return flecs::query_builder<Comps...>(m_world, FLECS_FWD(args)...)
+    return flecs::query_builder<Comps...>(world_, FLECS_FWD(args)...)
         .build();
 }
 
+inline flecs::query<> world::query(flecs::entity query_entity) const {
+    ecs_query_desc_t desc = {};
+    desc.entity = query_entity;
+    return flecs::query<>(world_, &desc);
+}
+
 template <typename... Comps, typename... Args>
 inline flecs::query_builder<Comps...> world::query_builder(Args &&... args) const {
-    return flecs::query_builder<Comps...>(m_world, FLECS_FWD(args)...);
+    return flecs::query_builder<Comps...>(world_, FLECS_FWD(args)...);
+}
+
+// world::each
+namespace _ {
+
+// Each with entity parameter
+template<typename Func, typename ... Args>
+struct query_delegate_w_ent;
+
+template<typename Func, typename E, typename ... Args>
+struct query_delegate_w_ent<Func, arg_list<E, Args ...> >
+{
+    query_delegate_w_ent(const flecs::world& world, Func&& func) {
+        auto f = world.query<Args ...>();
+        f.each(FLECS_MOV(func));
+    }
+};
+
+// Each without entity parameter
+template<typename Func, typename ... Args>
+struct query_delegate_no_ent;
+
+template<typename Func, typename ... Args>
+struct query_delegate_no_ent<Func, arg_list<Args ...> >
+{
+    query_delegate_no_ent(const flecs::world& world, Func&& func) {
+        auto f = world.query<Args ...>();
+        f.each(FLECS_MOV(func));
+    }
+};
+
+// Switch between function with & without entity parameter
+template<typename Func, typename T = int>
+struct query_delegate;
+
+template <typename Func>
+struct query_delegate<Func, if_t<is_same<first_arg_t<Func>, flecs::entity>::value> > {
+    query_delegate(const flecs::world& world, Func&& func) {
+        query_delegate_w_ent<Func, arg_list_t<Func>>(world, FLECS_MOV(func));
+    }
+};
+
+template <typename Func>
+struct query_delegate<Func, if_not_t<is_same<first_arg_t<Func>, flecs::entity>::value> > {
+    query_delegate(const flecs::world& world, Func&& func) {
+        query_delegate_no_ent<Func, arg_list_t<Func>>(world, FLECS_MOV(func));
+    }
+};
+
+}
+
+template <typename Func>
+inline void world::each(Func&& func) const {
+    _::query_delegate<Func> f_delegate(*this, FLECS_MOV(func));
+}
+
+template <typename T, typename Func>
+inline void world::each(Func&& func) const {
+    ecs_iter_t it = ecs_each_id(world_, _::type<T>::id());
+
+    while (ecs_each_next(&it)) {
+        _::each_delegate<Func, T>(func).invoke(&it);
+    }
 }
 
-// Builder implementation
-template <typename Base, typename ... Components>
-inline Base& query_builder_i<Base, Components ...>::observable(const query_base& parent) {
-    m_desc->parent = parent;
-    return *static_cast<Base*>(this);
+template <typename Func>
+inline void world::each(flecs::id_t each_id, Func&& func) const {
+    ecs_iter_t it = ecs_each_id(world_, each_id);
+
+    while (ecs_each_next(&it)) {
+        _::each_delegate<Func>(func).invoke(&it);
+    }
 }
 
 // query_base implementation
-inline query_base::operator query<>() const {
-    return flecs::query<>(m_world, m_query);
+inline query_base::operator flecs::query<> () const {
+    return flecs::query<>(query_);
 }
 
-} // namespace flecs
+}
 
 /**
  * @file addons/cpp/mixins/observer/impl.hpp
@@ -29683,16 +28455,16 @@ struct node_builder : IBuilder<Base, Components ...>
 
 public:
     explicit node_builder(flecs::world_t* world, const char *name = nullptr)
-        : IBase(&m_desc)
-        , m_desc{}
-        , m_world(world)
-        , m_instanced(false)
+        : IBase(&desc_)
+        , desc_{}
+        , world_(world)
+        , instanced_(false)
     {
         ecs_entity_desc_t entity_desc = {};
         entity_desc.name = name;
         entity_desc.sep = "::";
         entity_desc.root_sep = "::";
-        m_desc.entity = ecs_entity_init(m_world, &entity_desc);
+        desc_.entity = ecs_entity_init(world_, &entity_desc);
     }
 
     /* Iter (or each) is mandatory and always the last thing that 
@@ -29711,26 +28483,26 @@ struct node_builder : IBuilder<Base, Components ...>
     T each(Func&& func) {
         using Delegate = typename _::each_delegate<
             typename std::decay<Func>::type, Components...>;
-        m_instanced = true;
+        instanced_ = true;
         return build<Delegate>(FLECS_FWD(func));
     }
 
 protected:
-    flecs::world_t* world_v() override { return m_world; }
-    TDesc m_desc;
-    flecs::world_t *m_world;
-    bool m_instanced;
+    flecs::world_t* world_v() override { return world_; }
+    TDesc desc_;
+    flecs::world_t *world_;
+    bool instanced_;
 
 private:
     template <typename Delegate, typename Func>
     T build(Func&& func) {
         auto ctx = FLECS_NEW(Delegate)(FLECS_FWD(func));
-        m_desc.callback = Delegate::run;
-        m_desc.binding_ctx = ctx;
-        m_desc.binding_ctx_free = reinterpret_cast<
+        desc_.callback = Delegate::run;
+        desc_.binding_ctx = ctx;
+        desc_.binding_ctx_free = reinterpret_cast<
             ecs_ctx_free_t>(_::free_obj<Delegate>);
         
-        return T(m_world, &m_desc, m_instanced);
+        return T(world_, &desc_, instanced_);
     }
 };
 
@@ -29754,23 +28526,23 @@ namespace flecs {
  * @ingroup cpp_observers
  */
 template<typename Base, typename ... Components>
-struct observer_builder_i : filter_builder_i<Base, Components ...> {
-    using BaseClass = filter_builder_i<Base, Components ...>;
+struct observer_builder_i : query_builder_i<Base, Components ...> {
+    using BaseClass = query_builder_i<Base, Components ...>;
     observer_builder_i()
         : BaseClass(nullptr)
-        , m_desc(nullptr)
-        , m_event_count(0) { }
+        , desc_(nullptr)
+        , event_count_(0) { }
 
     observer_builder_i(ecs_observer_desc_t *desc) 
-        : BaseClass(&desc->filter)
-        , m_desc(desc)
-        , m_event_count(0) { }
+        : BaseClass(&desc->query)
+        , desc_(desc)
+        , event_count_(0) { }
 
     /** Specify the event(s) for when the observer should run.
      * @param evt The event.
      */
     Base& event(entity_t evt) {
-        m_desc->events[m_event_count ++] = evt;
+        desc_->events[event_count_ ++] = evt;
         return *this;
     }
 
@@ -29779,25 +28551,25 @@ struct observer_builder_i : filter_builder_i<Base, Components ...> {
      */
     template <typename E>
     Base& event() {
-        m_desc->events[m_event_count ++] = _::cpp_type<E>().id(world_v());
+        desc_->events[event_count_ ++] = _::type<E>().id(world_v());
         return *this;
     }
 
-    /** Invoke observer for anything that matches its filter on creation */
+    /** Invoke observer for anything that matches its query on creation */
     Base& yield_existing(bool value = true) {
-        m_desc->yield_existing = value;
+        desc_->yield_existing = value;
         return *this;
     }
 
     /** Set observer context */
     Base& ctx(void *ptr) {
-        m_desc->ctx = ptr;
+        desc_->ctx = ptr;
         return *this;
     }
 
     /** Set observer run callback */
     Base& run(ecs_iter_action_t action) {
-        m_desc->run = action;
+        desc_->run = action;
         return *this;
     }
 
@@ -29809,8 +28581,8 @@ struct observer_builder_i : filter_builder_i<Base, Components ...> {
         return *static_cast<Base*>(this);
     }
 
-    ecs_observer_desc_t *m_desc;
-    int32_t m_event_count;
+    ecs_observer_desc_t *desc_;
+    int32_t event_count_;
 };
 
 }
@@ -29851,44 +28623,38 @@ struct observer final : entity
 
     observer(flecs::world_t *world, ecs_observer_desc_t *desc, bool instanced) 
     {
-        if (!desc->filter.instanced) {
-            desc->filter.instanced = instanced;
+        if (!(desc->query.flags & EcsQueryIsInstanced)) {
+            ECS_BIT_COND(desc->query.flags, EcsQueryIsInstanced, instanced);
         }
 
-        m_world = world;
-        m_id = ecs_observer_init(world, desc);
-
-        if (desc->filter.terms_buffer) {
-            ecs_os_free(desc->filter.terms_buffer);
-        }
+        world_ = world;
+        id_ = ecs_observer_init(world, desc);
     }
 
     void ctx(void *ctx) {
         ecs_observer_desc_t desc = {};
-        desc.entity = m_id;
+        desc.entity = id_;
         desc.ctx = ctx;
-        ecs_observer_init(m_world, &desc);
+        ecs_observer_init(world_, &desc);
     }
 
     void* ctx() const {
-        return ecs_observer_get_ctx(m_world, m_id);
+        return ecs_observer_get_ctx(world_, id_);
     }
 
-    flecs::filter<> query() const {
-        const flecs::Poly *poly = this->get<flecs::Poly>(flecs::Observer);
-        const ecs_observer_t *ob = static_cast<const flecs::observer_t*>(poly->poly);
-        return flecs::filter<>(m_world, &ob->filter);
+    flecs::query<> query() const {
+        return flecs::query<>(ecs_observer_get_query(world_, id_));
     }
 };
 
 // Mixin implementation
 inline observer world::observer(flecs::entity e) const {
-    return flecs::observer(m_world, e);
+    return flecs::observer(world_, e);
 }
 
 template <typename... Comps, typename... Args>
 inline observer_builder<Comps...> world::observer(Args &&... args) const {
-    return flecs::observer_builder<Comps...>(m_world, FLECS_FWD(args)...);
+    return flecs::observer_builder<Comps...>(world_, FLECS_FWD(args)...);
 }
 
 } // namespace flecs
@@ -29907,12 +28673,12 @@ namespace flecs
 // Mixin implementation
 
 inline flecs::event_builder world::event(flecs::entity_t evt) const {
-    return flecs::event_builder(m_world, evt);
+    return flecs::event_builder(world_, evt);
 }
 
 template <typename E>
 inline flecs::event_builder_typed<E> world::event() const {
-    return flecs::event_builder_typed<E>(m_world, _::cpp_type<E>().id(m_world));
+    return flecs::event_builder_typed<E>(world_, _::type<E>().id(world_));
 }
 
 namespace _ {
@@ -29926,8 +28692,8 @@ namespace _ {
     {
         ecs_observer_desc_t desc = {};
         desc.events[0] = event;
-        desc.filter.terms[0].id = EcsAny;
-        desc.filter.terms[0].src.id = entity;
+        desc.query.terms[0].id = EcsAny;
+        desc.query.terms[0].src.id = entity;
         desc.callback = callback;
         desc.binding_ctx = binding_ctx;
         desc.binding_ctx_free = binding_ctx_free;
@@ -29946,7 +28712,7 @@ namespace _ {
         {
             using Delegate = _::entity_observer_delegate<Func>;
             auto ctx = FLECS_NEW(Delegate)(FLECS_FWD(f));
-            entity_observer_create(world, _::cpp_type<Evt>::id(world), entity, Delegate::run, ctx, 
+            entity_observer_create(world, _::type<Evt>::id(world), entity, Delegate::run, ctx, 
                 reinterpret_cast<ecs_ctx_free_t>(_::free_obj<Delegate>));
         }
 
@@ -29958,7 +28724,7 @@ namespace _ {
         {
             using Delegate = _::entity_payload_observer_delegate<Func, Evt>;
             auto ctx = FLECS_NEW(Delegate)(FLECS_FWD(f));
-            entity_observer_create(world, _::cpp_type<Evt>::id(world), entity, Delegate::run, ctx, 
+            entity_observer_create(world, _::type<Evt>::id(world), entity, Delegate::run, ctx, 
                 reinterpret_cast<ecs_ctx_free_t>(_::free_obj<Delegate>));
         }
     };
@@ -29970,7 +28736,7 @@ inline Self& entity_builder<Self>::observe(flecs::entity_t evt, Func&& f) {
     using Delegate = _::entity_observer_delegate<Func>;
     auto ctx = FLECS_NEW(Delegate)(FLECS_FWD(f));
 
-    _::entity_observer_create(m_world, evt, m_id, Delegate::run, ctx,
+    _::entity_observer_create(world_, evt, id_, Delegate::run, ctx,
         reinterpret_cast<ecs_ctx_free_t>(_::free_obj<Delegate>));
 
     return to_base();
@@ -29980,7 +28746,7 @@ template <typename Self>
 template <typename Evt, typename Func>
 inline Self& entity_builder<Self>::observe(Func&& f) {
     _::entity_observer_factory<Func>::template create<Evt>(
-        m_world, m_id, FLECS_FWD(f));
+        world_, id_, FLECS_FWD(f));
     return to_base();
 }
 
@@ -30018,8 +28784,8 @@ inline E entity_view::to_constant() const {
 
 template <typename E, if_t< is_enum<E>::value >>
 inline flecs::entity world::to_entity(E constant) const {
-    const auto& et = enum_type<E>(m_world);
-    return flecs::entity(m_world, et.entity(constant));
+    const auto& et = enum_type<E>(world_);
+    return flecs::entity(world_, et.entity(constant));
 }
 
 }
@@ -30044,17 +28810,17 @@ ecs_entity_t do_import(world& world, const char *symbol) {
 
     // Initialize module component type & don't allow it to be registered as a
     // tag, as this would prevent calling emplace()
-    auto m_c = component<T>(world, nullptr, false);
-    ecs_add_id(world, m_c, EcsModule);
+    auto c_ = component<T>(world, nullptr, false);
+    ecs_add_id(world, c_, EcsModule);
 
-    ecs_set_scope(world, m_c);
+    ecs_set_scope(world, c_);
     world.emplace<T>(world);
     ecs_set_scope(world, scope);
 
     // It should now be possible to lookup the module
     ecs_entity_t m = ecs_lookup_symbol(world, symbol, false, false);
     ecs_assert(m != 0, ECS_MODULE_UNDEFINED, symbol);
-    ecs_assert(m == m_c, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(m == c_, ECS_INTERNAL_ERROR, NULL);
 
     ecs_log_pop();
 
@@ -30067,11 +28833,11 @@ flecs::entity import(world& world) {
 
     ecs_entity_t m = ecs_lookup_symbol(world, symbol, true, false);
 
-    if (!_::cpp_type<T>::registered(world)) {
+    if (!_::type<T>::registered(world)) {
 
         /* Module is registered with world, initialize static data */
         if (m) {
-            _::cpp_type<T>::init(m, false);
+            _::type<T>::init(m, false);
 
         /* Module is not yet registered, register it now */
         } else {
@@ -30099,12 +28865,12 @@ flecs::entity import(world& world) {
 
 template <typename Module>
 inline flecs::entity world::module(const char *name) const {
-    flecs::id_t result = _::cpp_type<Module>::id(m_world, nullptr, false);
+    flecs::id_t result = _::type<Module>::id(world_, nullptr, false);
     if (name) {
-        ecs_add_path_w_sep(m_world, result, 0, name, "::", "::");
+        ecs_add_path_w_sep(world_, result, 0, name, "::", "::");
     }
-    ecs_set_scope(m_world, result);
-    return flecs::entity(m_world, result);
+    ecs_set_scope(world_, result);
+    return flecs::entity(world_, result);
 }
 
 template <typename Module>
@@ -30155,7 +28921,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
 public:
     system_builder_i(ecs_system_desc_t *desc) 
         : BaseClass(&desc->query)
-        , m_desc(desc) { }
+        , desc_(desc) { }
 
     /** Specify in which phase the system should run.
      *
@@ -30163,14 +28929,14 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      */
     Base& kind(entity_t phase) {
         flecs::entity_t cur_phase = ecs_get_target(
-            world_v(), m_desc->entity, EcsDependsOn, 0);
+            world_v(), desc_->entity, EcsDependsOn, 0);
         if (cur_phase) {
-            ecs_remove_id(world_v(), m_desc->entity, ecs_dependson(cur_phase));
-            ecs_remove_id(world_v(), m_desc->entity, cur_phase);
+            ecs_remove_id(world_v(), desc_->entity, ecs_dependson(cur_phase));
+            ecs_remove_id(world_v(), desc_->entity, cur_phase);
         }
         if (phase) {
-            ecs_add_id(world_v(), m_desc->entity, ecs_dependson(phase));
-            ecs_add_id(world_v(), m_desc->entity, phase);
+            ecs_add_id(world_v(), desc_->entity, ecs_dependson(phase));
+            ecs_add_id(world_v(), desc_->entity, phase);
         }
         return *this;
     }
@@ -30189,7 +28955,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      */
     template <typename Phase>
     Base& kind() {
-        return this->kind(_::cpp_type<Phase>::id(world_v()));
+        return this->kind(_::type<Phase>::id(world_v()));
     }
 
     /** Specify whether system can run on multiple threads.
@@ -30197,7 +28963,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param value If false system will always run on a single thread.
      */
     Base& multi_threaded(bool value = true) {
-        m_desc->multi_threaded = value;
+        desc_->multi_threaded = value;
         return *this;
     }
 
@@ -30205,8 +28971,8 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      *
      * @param value If false system will always run staged.
      */
-    Base& no_readonly(bool value = true) {
-        m_desc->no_readonly = value;
+    Base& immediate(bool value = true) {
+        desc_->immediate = value;
         return *this;
     }
 
@@ -30218,7 +28984,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param interval The interval value.
      */
     Base& interval(ecs_ftime_t interval) {
-        m_desc->interval = interval;
+        desc_->interval = interval;
         return *this;
     }
 
@@ -30231,8 +28997,8 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param rate The multiple at which to run the system.
      */
     Base& rate(const entity_t tick_source, int32_t rate) {
-        m_desc->rate = rate;
-        m_desc->tick_source = tick_source;
+        desc_->rate = rate;
+        desc_->tick_source = tick_source;
         return *this;
     }
 
@@ -30244,7 +29010,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param rate The multiple at which to run the system.
      */
     Base& rate(int32_t rate) {
-        m_desc->rate = rate;
+        desc_->rate = rate;
         return *this;
     }
 
@@ -30255,7 +29021,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      */
     template<typename T>
     Base& tick_source() {
-        m_desc->tick_source = _::cpp_type<T>::id(world_v());
+        desc_->tick_source = _::type<T>::id(world_v());
         return *this;
     }
 
@@ -30265,19 +29031,19 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param tick_source The tick source to use for the system.
      */
     Base& tick_source(flecs::entity_t tick_source) {
-        m_desc->tick_source = tick_source;
+        desc_->tick_source = tick_source;
         return *this;
     }
 
     /** Set system context */
     Base& ctx(void *ptr) {
-        m_desc->ctx = ptr;
+        desc_->ctx = ptr;
         return *this;
     }
 
     /** Set system run callback */
     Base& run(ecs_iter_action_t action) {
-        m_desc->run = action;
+        desc_->run = action;
         return *this;
     }
 
@@ -30289,7 +29055,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
         return *static_cast<Base*>(this);
     }
 
-    ecs_system_desc_t *m_desc;
+    ecs_system_desc_t *desc_;
 };
 
 }
@@ -30315,8 +29081,8 @@ struct system_builder final : _::system_builder_base<Components...> {
         _::sig<Components...>(world).populate(this);
 
 #ifdef FLECS_PIPELINE
-        ecs_add_id(world, this->m_desc.entity, ecs_dependson(flecs::OnUpdate));
-        ecs_add_id(world, this->m_desc.entity, flecs::OnUpdate);
+        ecs_add_id(world, this->desc_.entity, ecs_dependson(flecs::OnUpdate));
+        ecs_add_id(world, this->desc_.entity, flecs::OnUpdate);
 #endif
     }
 };
@@ -30335,50 +29101,47 @@ struct system_runner_fluent {
         int32_t stage_count, 
         ecs_ftime_t delta_time, 
         void *param)
-        : m_stage(world)
-        , m_id(id)
-        , m_delta_time(delta_time)
-        , m_param(param)
-        , m_offset(0)
-        , m_limit(0)
-        , m_stage_current(stage_current)
-        , m_stage_count(stage_count) { }
+        : stage_(world)
+        , id_(id)
+        , delta_time_(delta_time)
+        , param_(param)
+        , stage_current_(stage_current)
+        , stage_count_(stage_count) { }
 
     system_runner_fluent& offset(int32_t offset) {
-        m_offset = offset;
+        offset_ = offset;
         return *this;
     }
 
     system_runner_fluent& limit(int32_t limit) {
-        m_limit = limit;
+        limit_ = limit;
         return *this;
     }
 
     system_runner_fluent& stage(flecs::world& stage) {
-        m_stage = stage.c_ptr();
+        stage_ = stage.c_ptr();
         return *this;
     }
 
     ~system_runner_fluent() {
-        if (m_stage_count) {
+        if (stage_count_) {
             ecs_run_worker(
-                m_stage, m_id, m_stage_current, m_stage_count, m_delta_time,
-                m_param);            
+                stage_, id_, stage_current_, stage_count_, delta_time_,
+                param_);            
         } else {
-            ecs_run_w_filter(
-                m_stage, m_id, m_delta_time, m_offset, m_limit, m_param);
+            ecs_run(stage_, id_, delta_time_, param_);
         }
     }
 
 private:
-    world_t *m_stage;
-    entity_t m_id;
-    ecs_ftime_t m_delta_time;
-    void *m_param;
-    int32_t m_offset;
-    int32_t m_limit;
-    int32_t m_stage_current;
-    int32_t m_stage_count;
+    world_t *stage_;
+    entity_t id_;
+    ecs_ftime_t delta_time_;
+    void *param_;
+    int32_t offset_;
+    int32_t limit_;
+    int32_t stage_current_;
+    int32_t stage_count_;
 };
 
 struct system final : entity
@@ -30386,41 +29149,37 @@ struct system final : entity
     using entity::entity;
 
     explicit system() {
-        m_id = 0;
-        m_world = nullptr;
+        id_ = 0;
+        world_ = nullptr;
     }
 
     explicit system(flecs::world_t *world, ecs_system_desc_t *desc, bool instanced) 
     {
-        if (!desc->query.filter.instanced) {
-            desc->query.filter.instanced = instanced;
+        if (!(desc->query.flags & EcsQueryIsInstanced)) {
+            ECS_BIT_COND(desc->query.flags, EcsQueryIsInstanced, instanced);
         }
 
-        m_world = world;
-        m_id = ecs_system_init(world, desc);
-
-        if (desc->query.filter.terms_buffer) {
-            ecs_os_free(desc->query.filter.terms_buffer);
-        }
+        world_ = world;
+        id_ = ecs_system_init(world, desc);
     }
 
     void ctx(void *ctx) {
         ecs_system_desc_t desc = {};
-        desc.entity = m_id;
+        desc.entity = id_;
         desc.ctx = ctx;
-        ecs_system_init(m_world, &desc);
+        ecs_system_init(world_, &desc);
     }
 
     void* ctx() const {
-        return ecs_system_get_ctx(m_world, m_id);
+        return ecs_system_get_ctx(world_, id_);
     }
 
     flecs::query<> query() const {
-        return flecs::query<>(m_world, ecs_system_get_query(m_world, m_id));
+        return flecs::query<>(ecs_system_get_query(world_, id_));
     }
 
     system_runner_fluent run(ecs_ftime_t delta_time = 0.0f, void *param = nullptr) const {
-        return system_runner_fluent(m_world, m_id, 0, 0, delta_time, param);
+        return system_runner_fluent(world_, id_, 0, 0, delta_time, param);
     }
 
     system_runner_fluent run_worker(
@@ -30430,7 +29189,7 @@ struct system final : entity
         void *param = nullptr) const 
     {
         return system_runner_fluent(
-            m_world, m_id, stage_current, stage_count, delta_time, param);
+            world_, id_, stage_current, stage_count, delta_time, param);
     }
 
 #   ifdef FLECS_TIMER
@@ -30500,12 +29259,12 @@ void set_tick_source(flecs::entity e);
 
 // Mixin implementation
 inline system world::system(flecs::entity e) const {
-    return flecs::system(m_world, e);
+    return flecs::system(world_, e);
 }
 
 template <typename... Comps, typename... Args>
 inline system_builder<Comps...> world::system(Args &&... args) const {
-    return flecs::system_builder<Comps...>(m_world, FLECS_FWD(args)...);
+    return flecs::system_builder<Comps...>(world_, FLECS_FWD(args)...);
 }
 
 namespace _ {
@@ -30551,10 +29310,10 @@ template<typename Base>
 struct pipeline_builder_i : query_builder_i<Base> {
     pipeline_builder_i(ecs_pipeline_desc_t *desc, int32_t term_index = 0) 
         : query_builder_i<Base>(&desc->query, term_index)
-        , m_desc(desc) { }
+        , desc_(desc) { }
 
 private:
-    ecs_pipeline_desc_t *m_desc;
+    ecs_pipeline_desc_t *desc_;
 };
 
 }
@@ -30578,7 +29337,7 @@ struct pipeline_builder final : _::pipeline_builder_base<Components...> {
         : _::pipeline_builder_base<Components...>(world)
     {
         _::sig<Components...>(world).populate(this);
-        this->m_desc.entity = id;
+        this->desc_.entity = id;
     }
 };
 
@@ -30592,79 +29351,75 @@ struct pipeline : entity {
     pipeline(world_t *world, ecs_pipeline_desc_t *desc) 
         : entity(world)
     {
-        m_id = ecs_pipeline_init(world, desc);
+        id_ = ecs_pipeline_init(world, desc);
 
-        if (!m_id) {
+        if (!id_) {
             ecs_abort(ECS_INVALID_PARAMETER, NULL);
         }
-
-        if (desc->query.filter.terms_buffer) {
-            ecs_os_free(desc->query.filter.terms_buffer);
-        }
     }
 };
 
 inline flecs::pipeline_builder<> world::pipeline() const {
-    return flecs::pipeline_builder<>(m_world);
+    return flecs::pipeline_builder<>(world_);
 }
 
 template <typename Pipeline, if_not_t< is_enum<Pipeline>::value >>
 inline flecs::pipeline_builder<> world::pipeline() const {
-    return flecs::pipeline_builder<>(m_world, _::cpp_type<Pipeline>::id(m_world));
+    return flecs::pipeline_builder<>(world_, _::type<Pipeline>::id(world_));
 }
 
 inline void world::set_pipeline(const flecs::entity pip) const {
-    return ecs_set_pipeline(m_world, pip);
+    return ecs_set_pipeline(world_, pip);
 }
 
 template <typename Pipeline>
 inline void world::set_pipeline() const {
-    return ecs_set_pipeline(m_world, _::cpp_type<Pipeline>::id(m_world));
+    return ecs_set_pipeline(world_, _::type<Pipeline>::id(world_));
 }
 
 inline flecs::entity world::get_pipeline() const {
-    return flecs::entity(m_world, ecs_get_pipeline(m_world));
+    return flecs::entity(world_, ecs_get_pipeline(world_));
 }
 
 inline bool world::progress(ecs_ftime_t delta_time) const {
-    return ecs_progress(m_world, delta_time);
+    return ecs_progress(world_, delta_time);
 }
 
 inline void world::run_pipeline(const flecs::entity_t pip, ecs_ftime_t delta_time) const {
-    return ecs_run_pipeline(m_world, pip, delta_time);
+    return ecs_run_pipeline(world_, pip, delta_time);
 }
 
 template <typename Pipeline, if_not_t< is_enum<Pipeline>::value >>
 inline void world::run_pipeline(ecs_ftime_t delta_time) const {
-    return ecs_run_pipeline(m_world, _::cpp_type<Pipeline>::id(m_world), delta_time);
+    return ecs_run_pipeline(world_, _::type<Pipeline>::id(world_), delta_time);
 }
 
 inline void world::set_time_scale(ecs_ftime_t mul) const {
-    ecs_set_time_scale(m_world, mul);
+    ecs_set_time_scale(world_, mul);
 }
 
 inline void world::set_target_fps(ecs_ftime_t target_fps) const {
-    ecs_set_target_fps(m_world, target_fps);
+    ecs_set_target_fps(world_, target_fps);
 }
 
 inline void world::reset_clock() const {
-    ecs_reset_clock(m_world);
+    ecs_reset_clock(world_);
 }
 
 inline void world::set_threads(int32_t threads) const {
-    ecs_set_threads(m_world, threads);
+    ecs_set_threads(world_, threads);
 }
 
 inline int32_t world::get_threads() const {
-    return ecs_get_stage_count(m_world);
+    return ecs_get_stage_count(world_);
 }
 
 inline void world::set_task_threads(int32_t task_threads) const {
-    ecs_set_task_threads(m_world, task_threads);
+    ecs_set_task_threads(world_, task_threads);
 }
 
 inline bool world::using_task_threads() const {
-    return ecs_using_task_threads(m_world);
+    return ecs_using_task_threads(world_);
 }
 
 }
@@ -30685,86 +29440,86 @@ struct timer final : entity {
     using entity::entity;
 
     timer& interval(ecs_ftime_t interval) {
-        ecs_set_interval(m_world, m_id, interval);
+        ecs_set_interval(world_, id_, interval);
         return *this;
     }
 
     ecs_ftime_t interval() {
-        return ecs_get_interval(m_world, m_id);
+        return ecs_get_interval(world_, id_);
     }
 
     timer& timeout(ecs_ftime_t timeout) {
-        ecs_set_timeout(m_world, m_id, timeout);
+        ecs_set_timeout(world_, id_, timeout);
         return *this;
     }
 
     ecs_ftime_t timeout() {
-        return ecs_get_timeout(m_world, m_id);
+        return ecs_get_timeout(world_, id_);
     }
 
     timer& rate(int32_t rate, flecs::entity_t tick_source = 0) {
-        ecs_set_rate(m_world, m_id, rate, tick_source);
+        ecs_set_rate(world_, id_, rate, tick_source);
         return *this;
     }
 
     void start() {
-        ecs_start_timer(m_world, m_id);
+        ecs_start_timer(world_, id_);
     }
 
     void stop() {
-        ecs_stop_timer(m_world, m_id);
+        ecs_stop_timer(world_, id_);
     }
 };
 
 template <typename T>
 inline flecs::timer world::timer() const {
-    return flecs::timer(m_world, _::cpp_type<T>::id(m_world));
+    return flecs::timer(world_, _::type<T>::id(world_));
 }
 
 template <typename... Args>
 inline flecs::timer world::timer(Args &&... args) const {
-    return flecs::timer(m_world, FLECS_FWD(args)...);
+    return flecs::timer(world_, FLECS_FWD(args)...);
 }
 
 inline void world::randomize_timers() const {
-    ecs_randomize_timers(m_world);
+    ecs_randomize_timers(world_);
 }
 
 inline void system::interval(ecs_ftime_t interval) {
-    ecs_set_interval(m_world, m_id, interval);
+    ecs_set_interval(world_, id_, interval);
 }
 
 inline ecs_ftime_t system::interval() {
-    return ecs_get_interval(m_world, m_id);
+    return ecs_get_interval(world_, id_);
 }
 
 inline void system::timeout(ecs_ftime_t timeout) {
-    ecs_set_timeout(m_world, m_id, timeout);
+    ecs_set_timeout(world_, id_, timeout);
 }
 
 inline ecs_ftime_t system::timeout() {
-    return ecs_get_timeout(m_world, m_id);
+    return ecs_get_timeout(world_, id_);
 }
 
 inline void system::rate(int32_t rate) {
-    ecs_set_rate(m_world, m_id, rate, 0);
+    ecs_set_rate(world_, id_, rate, 0);
 }
 
 inline void system::start() {
-    ecs_start_timer(m_world, m_id);
+    ecs_start_timer(world_, id_);
 }
 
 inline void system::stop() {
-    ecs_stop_timer(m_world, m_id);
+    ecs_stop_timer(world_, id_);
 }
 
 template<typename T>
 inline void system::set_tick_source() {
-    ecs_set_tick_source(m_world, m_id, _::cpp_type<T>::id(m_world));
+    ecs_set_tick_source(world_, id_, _::type<T>::id(world_));
 }
 
 inline void system::set_tick_source(flecs::entity e) {
-    ecs_set_tick_source(m_world, m_id, e);
+    ecs_set_tick_source(world_, id_, e);
 }
 
 namespace _ {
@@ -30777,99 +29532,6 @@ inline void timer_init(flecs::world& world) {
 }
 }
 
-#endif
-#ifdef FLECS_SNAPSHOT
-/**
- * @file addons/cpp/mixins/snapshot/impl.hpp
- * @brief Snapshot module implementation.
- */
-
-#pragma once
-
-namespace flecs {
-
-struct snapshot final {
-    explicit snapshot(const world& world)
-        : m_world( world )
-        , m_snapshot( nullptr ) { }
-
-    snapshot(const snapshot& obj) 
-        : m_world( obj.m_world )
-    { 
-        ecs_iter_t it = ecs_snapshot_iter(obj.m_snapshot);
-        m_snapshot = ecs_snapshot_take_w_iter(&it);
-    }
-
-    snapshot(snapshot&& obj) noexcept
-        : m_world(obj.m_world)
-        , m_snapshot(obj.m_snapshot)
-    {
-        obj.m_snapshot = nullptr;
-    }
-
-    snapshot& operator=(const snapshot& obj) {
-        ecs_assert(m_world.c_ptr() == obj.m_world.c_ptr(), ECS_INVALID_PARAMETER, NULL);
-        ecs_iter_t it = ecs_snapshot_iter(obj.m_snapshot);
-        m_snapshot = ecs_snapshot_take_w_iter(&it);        
-        return *this;
-    }
-
-    snapshot& operator=(snapshot&& obj) noexcept {
-        ecs_assert(m_world.c_ptr() == obj.m_world.c_ptr(), ECS_INVALID_PARAMETER, NULL);
-        m_snapshot = obj.m_snapshot;
-        obj.m_snapshot = nullptr;
-        return *this;
-    }
-
-    void take() {
-        if (m_snapshot) {
-            ecs_snapshot_free(m_snapshot);
-        }
-
-        m_snapshot = ecs_snapshot_take(m_world.c_ptr());
-    }
-
-    template <typename F>
-    void take(const F& f) {
-        if (m_snapshot) {
-            ecs_snapshot_free(m_snapshot);
-        }
-
-        ecs_iter_t it = ecs_filter_iter(m_world, f.c_ptr());
-
-        m_snapshot = ecs_snapshot_take_w_iter(&it);
-    }    
-
-    void restore() {
-        if (m_snapshot) {
-            ecs_snapshot_restore(m_world.c_ptr(), m_snapshot);
-            m_snapshot = nullptr;
-        }
-    }
-
-    ~snapshot() {
-        if (m_snapshot) {
-            ecs_snapshot_free(m_snapshot);
-        }
-    }
-
-    snapshot_t* c_ptr() const {
-        return m_snapshot;
-    }
-
-private:
-    const world& m_world;
-    snapshot_t *m_snapshot;
-};
-
-// Snapshot mixin implementation
-template <typename... Args>
-inline flecs::snapshot world::snapshot(Args &&... args) const {
-    return flecs::snapshot(*this, FLECS_FWD(args)...);
-}
-
-}
-
 #endif
 #ifdef FLECS_DOC
 /**
@@ -31037,190 +29699,6 @@ inline void init(flecs::world& world) {
 } // namespace rest
 } // namespace flecs
 
-#endif
-#ifdef FLECS_RULES
-/**
- * @file addons/cpp/mixins/rule/impl.hpp
- * @brief Rule implementation.
- */
-
-#pragma once
-
-/**
- * @file addons/cpp/mixins/rule/builder.hpp
- * @brief Rule builder.
- */
-
-#pragma once
-
-
-namespace flecs {
-namespace _ {
-    template <typename ... Components>
-    using rule_builder_base = builder<
-        rule, ecs_filter_desc_t, rule_builder<Components...>, 
-        filter_builder_i, Components ...>;
-}
-
-/** Rule builder.
- * 
- * @ingroup cpp_addons_rules
- */
-template <typename ... Components>
-struct rule_builder final : _::rule_builder_base<Components...> {
-    rule_builder(flecs::world_t* world, const char *name = nullptr)
-        : _::rule_builder_base<Components...>(world)
-    {
-        _::sig<Components...>(world).populate(this);
-        if (name != nullptr) {
-            ecs_entity_desc_t entity_desc = {};
-            entity_desc.name = name;
-            entity_desc.sep = "::";
-            entity_desc.root_sep = "::";
-            this->m_desc.entity = ecs_entity_init(world, &entity_desc);
-        }
-    }
-};
-
-}
-
-
-namespace flecs {
-
-////////////////////////////////////////////////////////////////////////////////
-//// Persistent queries
-////////////////////////////////////////////////////////////////////////////////
-
-struct rule_base {
-    rule_base()
-        : m_world(nullptr)
-        , m_rule(nullptr) { }    
-    
-    rule_base(world_t *world, rule_t *rule = nullptr)
-        : m_world(world)
-        , m_rule(rule) { }
-
-    rule_base(world_t *world, ecs_filter_desc_t *desc) 
-        : m_world(world)
-    {
-        m_rule = ecs_rule_init(world, desc);
-        if (desc->terms_buffer) {
-            ecs_os_free(desc->terms_buffer);
-        }
-    }
-
-    bool is_valid() const {
-        return m_rule != nullptr;
-    }
-
-    operator rule_t*() const {
-        return m_rule;
-    }
-
-    flecs::entity entity() {
-        return flecs::entity(m_world, ecs_get_entity(m_rule));
-    }
-
-    /** Free the rule. */
-    void destruct() {
-        if (m_rule) {
-            ecs_rule_fini(m_rule);
-            m_world = nullptr;
-            m_rule = nullptr;
-        }
-    }
-
-    template <typename Func>
-    void each_term(const Func& func) const {
-        this->filter().each_term(func);
-    }
-
-    /** Move the rule. */
-    void move(flecs::rule_base&& obj) {
-        this->destruct();
-        this->m_world = obj.m_world;
-        this->m_rule = obj.m_rule;
-        obj.m_world = nullptr;
-        obj.m_rule = nullptr;
-    }
-
-    flecs::filter_base filter() const {
-        return filter_base(m_world, ecs_rule_get_filter(m_rule));
-    }
-
-    /** Converts this rule to a string expression
-     * @see ecs_filter_str
-     */
-    flecs::string str() const {
-        const ecs_filter_t *f = ecs_rule_get_filter(m_rule);
-        char *result = ecs_filter_str(m_world, f);
-        return flecs::string(result);
-    }
-
-
-    /** Converts this rule to a string that can be used to aid debugging
-     * the behavior of the rule.
-     * @see ecs_rule_str
-     */
-    flecs::string rule_str() const {
-        char *result = ecs_rule_str(m_rule);
-        return flecs::string(result);
-    }
-
-    operator rule<>() const;
-
-protected:
-    world_t *m_world;
-    rule_t *m_rule;
-};
-
-template<typename ... Components>
-struct rule final : rule_base, iterable<Components...> {
-private:
-    using Terms = typename _::term_ptrs<Components...>::array;
-
-    ecs_iter_t get_iter(flecs::world_t *world) const override {
-        if (!world) {
-            world = m_world;
-        }
-        return ecs_rule_iter(world, m_rule);
-    }
-
-    ecs_iter_next_action_t next_action() const override {
-        return ecs_rule_next;
-    }
-
-    ecs_iter_next_action_t next_each_action() const override {
-        return ecs_rule_next_instanced;
-    }
-
-public:
-    using rule_base::rule_base;
-
-    int32_t find_var(const char *name) {
-        return ecs_rule_find_var(m_rule, name);
-    }
-};
-
-// Mixin implementation
-template <typename... Comps, typename... Args>
-inline flecs::rule<Comps...> world::rule(Args &&... args) const {
-    return flecs::rule_builder<Comps...>(m_world, FLECS_FWD(args)...)
-        .build();
-}
-
-template <typename... Comps, typename... Args>
-inline flecs::rule_builder<Comps...> world::rule_builder(Args &&... args) const {
-    return flecs::rule_builder<Comps...>(m_world, FLECS_FWD(args)...);
-}
-
-// rule_base implementation
-inline rule_base::operator rule<>() const {
-    return flecs::rule<>(m_world, m_rule);
-}
-
-} // namespace flecs
-
 #endif
 #ifdef FLECS_META
 /**
@@ -31268,29 +29746,29 @@ inline void init(flecs::world& world) {
 
     world.component<type_kind_t>("flecs::meta::type_kind");
     world.component<primitive_kind_t>("flecs::meta::primitive_kind");
-    world.component<member_t>("flecs::meta::member");
+    world.component<member_t>("flecs::meta::member_t");
     world.component<enum_constant_t>("flecs::meta::enum_constant");
     world.component<bitmask_constant_t>("flecs::meta::bitmask_constant");
 
-    world.component<MetaType>("flecs::meta::MetaType");
-    world.component<MetaTypeSerialized>("flecs::meta::MetaTypeSerialized");
-    world.component<Primitive>("flecs::meta::Primitive");
-    world.component<Enum>("flecs::meta::Enum");
-    world.component<Bitmask>("flecs::meta::Bitmask");
-    world.component<Member>("flecs::meta::Member");
-    world.component<MemberRanges>("flecs::meta::MemberRanges");
-    world.component<Struct>("flecs::meta::Struct");
-    world.component<Array>("flecs::meta::Array");
-    world.component<Vector>("flecs::meta::Vector");
+    world.component<Type>("flecs::meta::type");
+    world.component<TypeSerializer>("flecs::meta::TypeSerializer");
+    world.component<Primitive>("flecs::meta::primitive");
+    world.component<Enum>("flecs::meta::enum");
+    world.component<Bitmask>("flecs::meta::bitmask");
+    world.component<Member>("flecs::meta::member");
+    world.component<MemberRanges>("flecs::meta::member_ranges");
+    world.component<Struct>("flecs::meta::struct");
+    world.component<Array>("flecs::meta::array");
+    world.component<Vector>("flecs::meta::vector");
 
-    world.component<Unit>("flecs::meta::Unit");
+    world.component<Unit>("flecs::meta::unit");
 
     // To support member<uintptr_t> and member<intptr_t> register components
     // (that do not have conflicting symbols with builtin ones) for platform
     // specific types.
 
     if (!flecs::is_same<i32_t, iptr_t>() && !flecs::is_same<i64_t, iptr_t>()) {
-        flecs::_::cpp_type<iptr_t>::init(flecs::Iptr, true);
+        flecs::_::type<iptr_t>::init(flecs::Iptr, true);
         ecs_assert(flecs::type_id<iptr_t>() == flecs::Iptr, 
             ECS_INTERNAL_ERROR, NULL);
         // Remove symbol to prevent validation errors, as it doesn't match with 
@@ -31299,7 +29777,7 @@ inline void init(flecs::world& world) {
     }
 
     if (!flecs::is_same<u32_t, uptr_t>() && !flecs::is_same<u64_t, uptr_t>()) {
-        flecs::_::cpp_type<uptr_t>::init(flecs::Uptr, true);
+        flecs::_::type<uptr_t>::init(flecs::Uptr, true);
         ecs_assert(flecs::type_id<uptr_t>() == flecs::Uptr, 
             ECS_INTERNAL_ERROR, NULL);
         // Remove symbol to prevent validation errors, as it doesn't match with 
@@ -31322,24 +29800,24 @@ inline void init(flecs::world& world) {
 
 
 inline flecs::entity cursor::get_type() const {
-    return flecs::entity(m_cursor.world, ecs_meta_get_type(&m_cursor));
+    return flecs::entity(cursor_.world, ecs_meta_get_type(&cursor_));
 }
 
 inline flecs::entity cursor::get_unit() const {
-    return flecs::entity(m_cursor.world, ecs_meta_get_unit(&m_cursor));
+    return flecs::entity(cursor_.world, ecs_meta_get_unit(&cursor_));
 }
 
 inline flecs::entity cursor::get_entity() const {
-    return flecs::entity(m_cursor.world, ecs_meta_get_entity(&m_cursor));
+    return flecs::entity(cursor_.world, ecs_meta_get_entity(&cursor_));
 }
 
 /** Create primitive type */
 inline flecs::entity world::primitive(flecs::meta::primitive_kind_t kind) {
     ecs_primitive_desc_t desc = {};
     desc.kind = kind;
-    flecs::entity_t eid = ecs_primitive_init(m_world, &desc);
+    flecs::entity_t eid = ecs_primitive_init(world_, &desc);
     ecs_assert(eid != 0, ECS_INVALID_OPERATION, NULL);
-    return flecs::entity(m_world, eid);
+    return flecs::entity(world_, eid);
 }
 
 /** Create array type. */
@@ -31347,28 +29825,28 @@ inline flecs::entity world::array(flecs::entity_t elem_id, int32_t array_count)
     ecs_array_desc_t desc = {};
     desc.type = elem_id;
     desc.count = array_count;
-    flecs::entity_t eid = ecs_array_init(m_world, &desc);
+    flecs::entity_t eid = ecs_array_init(world_, &desc);
     ecs_assert(eid != 0, ECS_INVALID_OPERATION, NULL);
-    return flecs::entity(m_world, eid);
+    return flecs::entity(world_, eid);
 }
 
 /** Create array type. */
 template <typename T>
 inline flecs::entity world::array(int32_t array_count) {
-    return this->array(_::cpp_type<T>::id(m_world), array_count);
+    return this->array(_::type<T>::id(world_), array_count);
 }
 
 inline flecs::entity world::vector(flecs::entity_t elem_id) {
     ecs_vector_desc_t desc = {};
     desc.type = elem_id;
-    flecs::entity_t eid = ecs_vector_init(m_world, &desc);
+    flecs::entity_t eid = ecs_vector_init(world_, &desc);
     ecs_assert(eid != 0, ECS_INVALID_OPERATION, NULL);
-    return flecs::entity(m_world, eid);
+    return flecs::entity(world_, eid);
 }
 
 template <typename T>
 inline flecs::entity world::vector() {
-    return this->vector(_::cpp_type<T>::id(m_world));
+    return this->vector(_::type<T>::id(world_));
 }
 
 } // namespace flecs
@@ -31379,7 +29857,7 @@ inline int ecs_serializer_t::value(ecs_entity_t type, const void *v) const {
 
 template <typename T>
 inline int ecs_serializer_t::value(const T& v) const {
-    return this->value(flecs::_::cpp_type<T>::id(
+    return this->value(flecs::_::type<T>::id(
         const_cast<flecs::world_t*>(this->world)), &v);
 }
 
@@ -31655,18 +30133,18 @@ inline metrics::metrics(flecs::world& world) {
 }
 
 inline metric_builder::~metric_builder() {
-    if (!m_created) {
-        ecs_metric_init(m_world, &m_desc);
+    if (!created_) {
+        ecs_metric_init(world_, &desc_);
     }
 }
 
 inline metric_builder& metric_builder::member(const char *name) {
     flecs::entity m;
-    if (m_desc.id) {
-        flecs::entity_t type = ecs_get_typeid(m_world, m_desc.id);
-        m = flecs::entity(m_world, type).lookup(name);
+    if (desc_.id) {
+        flecs::entity_t type = ecs_get_typeid(world_, desc_.id);
+        m = flecs::entity(world_, type).lookup(name);
     } else {
-        m = flecs::world(m_world).lookup(name);
+        m = flecs::world(world_).lookup(name);
     }
     if (!m) {
         flecs::log::err("member '%s' not found", name);
@@ -31676,7 +30154,7 @@ inline metric_builder& metric_builder::member(const char *name) {
 
 template <typename T>
 inline metric_builder& metric_builder::member(const char *name) {
-    flecs::entity e (m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e (world_, _::type<T>::id(world_));
     flecs::entity_t m = e.lookup(name);
     if (!m) {
         flecs::log::err("member '%s' not found in type '%s'", 
@@ -31687,32 +30165,32 @@ inline metric_builder& metric_builder::member(const char *name) {
 }
 
 inline metric_builder& metric_builder::dotmember(const char *expr) {
-    m_desc.dotmember = expr;
+    desc_.dotmember = expr;
     return *this;
 }
 
 template <typename T>
 inline metric_builder& metric_builder::dotmember(const char *expr) {
-    m_desc.dotmember = expr;
-    m_desc.id = _::cpp_type<T>::id(m_world);
+    desc_.dotmember = expr;
+    desc_.id = _::type<T>::id(world_);
     return *this;
 }
 
 inline metric_builder::operator flecs::entity() {
-    if (!m_created) {
-        m_created = true;
-        flecs::entity result(m_world, ecs_metric_init(m_world, &m_desc));
-        m_desc.entity = result;
+    if (!created_) {
+        created_ = true;
+        flecs::entity result(world_, ecs_metric_init(world_, &desc_));
+        desc_.entity = result;
         return result;
     } else {
-        return flecs::entity(m_world, m_desc.entity);
+        return flecs::entity(world_, desc_.entity);
     }
 }
 
 template <typename... Args>
 inline flecs::metric_builder world::metric(Args &&... args) const {
-    flecs::entity result(m_world, FLECS_FWD(args)...);
-    return flecs::metric_builder(m_world, result);
+    flecs::entity result(world_, FLECS_FWD(args)...);
+    return flecs::metric_builder(world_, result);
 }
 
 template <typename Kind>
@@ -31721,8 +30199,8 @@ inline untyped_component& untyped_component::metric(
     const char *brief, 
     const char *metric_name) 
 {
-    flecs::world w(m_world);
-    flecs::entity e(m_world, m_id);
+    flecs::world w(world_);
+    flecs::entity e(world_, id_);
 
     const flecs::member_t *m = ecs_cpp_last_member(w, e);
     if (!m) {
@@ -31785,25 +30263,25 @@ namespace flecs {
  * @ingroup cpp_addons_alerts
  */
 template<typename Base, typename ... Components>
-struct alert_builder_i : filter_builder_i<Base, Components ...> {
+struct alert_builder_i : query_builder_i<Base, Components ...> {
 private:
-    using BaseClass = filter_builder_i<Base, Components ...>;
-    
+    using BaseClass = query_builder_i<Base, Components ...>;
+
 public:
     alert_builder_i()
         : BaseClass(nullptr)
-        , m_desc(nullptr) { }
+        , desc_(nullptr) { }
 
     alert_builder_i(ecs_alert_desc_t *desc, int32_t term_index = 0) 
-        : BaseClass(&desc->filter, term_index)
-        , m_desc(desc) { }
+        : BaseClass(&desc->query, term_index)
+        , desc_(desc) { }
 
     /** Alert message.
      *
      * @see ecs_alert_desc_t::message
      */      
     Base& message(const char *message) {
-        m_desc->message = message;
+        desc_->message = message;
         return *this;
     }
 
@@ -31812,7 +30290,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      * @see ecs_alert_desc_t::brief
      */
     Base& brief(const char *brief) {
-        m_desc->brief = brief;
+        desc_->brief = brief;
         return *this;
     }
 
@@ -31821,7 +30299,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      * @see ecs_alert_desc_t::doc_name
      */
     Base& doc_name(const char *doc_name) {
-        m_desc->doc_name = doc_name;
+        desc_->doc_name = doc_name;
         return *this;
     }
 
@@ -31830,7 +30308,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      * @see ecs_alert_desc_t::severity
      */
     Base& severity(flecs::entity_t kind) {
-        m_desc->severity = kind;
+        desc_->severity = kind;
         return *this;
     }
 
@@ -31839,7 +30317,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      * @see ecs_alert_desc_t::retain_period
      */
     Base& retain_period(ecs_ftime_t period) {
-        m_desc->retain_period = period;
+        desc_->retain_period = period;
         return *this;
     }
 
@@ -31849,7 +30327,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      */
     template <typename Severity>
     Base& severity() {
-        return severity(_::cpp_type<Severity>::id(world_v()));
+        return severity(_::type<Severity>::id(world_v()));
     }
 
     /** Add severity filter */
@@ -31858,7 +30336,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
             ECS_INVALID_PARAMETER, "Maximum number of severity filters reached");
 
         ecs_alert_severity_filter_t *filter = 
-            &m_desc->severity_filters[severity_filter_count ++];
+            &desc_->severity_filters[severity_filter_count ++];
 
         filter->severity = kind;
         filter->with = with;
@@ -31869,14 +30347,14 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
     /** Add severity filter */
     template <typename Severity>
     Base& severity_filter(flecs::id_t with, const char *var = nullptr) {
-        return severity_filter(_::cpp_type<Severity>::id(world_v()), with, var);
+        return severity_filter(_::type<Severity>::id(world_v()), with, var);
     }
 
     /** Add severity filter */
     template <typename Severity, typename T, if_not_t< is_enum<T>::value > = 0>
     Base& severity_filter(const char *var = nullptr) {
-        return severity_filter(_::cpp_type<Severity>::id(world_v()), 
-            _::cpp_type<T>::id(world_v()), var);
+        return severity_filter(_::type<Severity>::id(world_v()), 
+            _::type<T>::id(world_v()), var);
     }
 
     /** Add severity filter */
@@ -31884,37 +30362,37 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
     Base& severity_filter(T with, const char *var = nullptr) {
         flecs::world w(world_v());
         flecs::entity constant = w.to_entity<T>(with);
-        return severity_filter(_::cpp_type<Severity>::id(world_v()), 
+        return severity_filter(_::type<Severity>::id(world_v()), 
             w.pair<T>(constant), var);
     }
 
     /** Set member to create an alert for out of range values */
     Base& member(flecs::entity_t m) {
-        m_desc->member = m;
+        desc_->member = m;
         return *this;
     }
 
     /** Set (component) id for member (optional). If .member() is set and id
      * is not set, the id will default to the member parent. */
     Base& id(flecs::id_t id) {
-        m_desc->id = id;
+        desc_->id = id;
         return *this;
     }
 
     /** Set member to create an alert for out of range values */
     template <typename T>
     Base& member(const char *m, const char *v = nullptr) {
-        flecs::entity_t id = _::cpp_type<T>::id(world_v());
+        flecs::entity_t id = _::type<T>::id(world_v());
         flecs::entity_t mid = ecs_lookup_path_w_sep(
             world_v(), id, m, "::", "::", false);
         ecs_assert(m != 0, ECS_INVALID_PARAMETER, NULL);
-        m_desc->var = v;
+        desc_->var = v;
         return this->member(mid);
     }
 
     /** Set source variable for member (optional, defaults to $this) */
     Base& var(const char *v) {
-        m_desc->var = v;
+        desc_->var = v;
         return *this;
     }
 
@@ -31926,7 +30404,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
         return *static_cast<Base*>(this);
     }
 
-    ecs_alert_desc_t *m_desc;
+    ecs_alert_desc_t *desc_;
     int32_t severity_filter_count = 0;
 };
 
@@ -31956,7 +30434,7 @@ struct alert_builder final : _::alert_builder_base<Components...> {
             entity_desc.name = name;
             entity_desc.sep = "::";
             entity_desc.root_sep = "::";
-            this->m_desc.entity = ecs_entity_init(world, &entity_desc);
+            this->desc_.entity = ecs_entity_init(world, &entity_desc);
         }
     }
 };
@@ -31972,18 +30450,13 @@ struct alert final : entity
     using entity::entity;
 
     explicit alert() {
-        m_id = 0;
-        m_world = nullptr;
+        id_ = 0;
+        world_ = nullptr;
     }
 
-    explicit alert(flecs::world_t *world, ecs_alert_desc_t *desc) 
-    {
-        m_world = world;
-        m_id = ecs_alert_init(world, desc);
-
-        if (desc->filter.terms_buffer) {
-            ecs_os_free(desc->filter.terms_buffer);
-        }
+    explicit alert(flecs::world_t *world, ecs_alert_desc_t *desc) {
+        world_ = world;
+        id_ = ecs_alert_init(world, desc);
     }
 };
 
@@ -32004,7 +30477,7 @@ inline alerts::alerts(flecs::world& world) {
 
 template <typename... Comps, typename... Args>
 inline flecs::alert_builder<Comps...> world::alert(Args &&... args) const {
-    return flecs::alert_builder<Comps...>(m_world, FLECS_FWD(args)...);
+    return flecs::alert_builder<Comps...>(world_, FLECS_FWD(args)...);
 }
 
 }
@@ -32028,16 +30501,16 @@ inline field<T>::field(iter &iter, int32_t index) {
 
 template <typename T>
 T& field<T>::operator[](size_t index) const {
-    ecs_assert(m_data != nullptr, ECS_INVALID_OPERATION, 
+    ecs_assert(data_ != nullptr, ECS_INVALID_OPERATION, 
         "invalid nullptr dereference of component type %s", 
             _::type_name<T>());
-    ecs_assert(index < m_count, ECS_COLUMN_INDEX_OUT_OF_RANGE,
+    ecs_assert(index < count_, ECS_COLUMN_INDEX_OUT_OF_RANGE,
         "index %d out of range for array of component type %s",
             index, _::type_name<T>());
-    ecs_assert(!index || !m_is_shared, ECS_INVALID_PARAMETER,
+    ecs_assert(!index || !is_shared_, ECS_INVALID_PARAMETER,
         "non-zero index invalid for shared field of component type %s",
             _::type_name<T>());
-    return m_data[index];
+    return data_[index];
 }
 
 /** Return first element of component array.
@@ -32047,10 +30520,10 @@ T& field<T>::operator[](size_t index) const {
  */
 template <typename T>
 T& field<T>::operator*() const {
-    ecs_assert(m_data != nullptr, ECS_INVALID_OPERATION, 
+    ecs_assert(data_ != nullptr, ECS_INVALID_OPERATION, 
         "invalid nullptr dereference of component type %s", 
             _::type_name<T>());
-    return *m_data;
+    return *data_;
 }
 
 /** Return first element of component array.
@@ -32060,14 +30533,14 @@ T& field<T>::operator*() const {
  */
 template <typename T>
 T* field<T>::operator->() const {
-    ecs_assert(m_data != nullptr, ECS_INVALID_OPERATION, 
+    ecs_assert(data_ != nullptr, ECS_INVALID_OPERATION, 
         "invalid nullptr dereference of component type %s", 
             _::type_name<T>());
-    ecs_assert(m_data != nullptr, ECS_INVALID_OPERATION, 
+    ecs_assert(data_ != nullptr, ECS_INVALID_OPERATION, 
         "-> operator invalid for array with >1 element of "
         "component type %s, use [row] instead",
             _::type_name<T>());
-    return m_data;
+    return data_;
 }
 
 }
@@ -32083,60 +30556,60 @@ namespace flecs
 {
 
 inline flecs::entity iter::system() const {
-    return flecs::entity(m_iter->world, m_iter->system);
+    return flecs::entity(iter_->world, iter_->system);
 }
 
 inline flecs::entity iter::event() const {
-    return flecs::entity(m_iter->world, m_iter->event);
+    return flecs::entity(iter_->world, iter_->event);
 }
 
 inline flecs::id iter::event_id() const {
-    return flecs::id(m_iter->world, m_iter->event_id);
+    return flecs::id(iter_->world, iter_->event_id);
 }
 
 inline flecs::world iter::world() const {
-    return flecs::world(m_iter->world);
+    return flecs::world(iter_->world);
 }
 
 inline flecs::entity iter::entity(size_t row) const {
-    ecs_assert(row < static_cast<size_t>(m_iter->count), 
+    ecs_assert(row < static_cast<size_t>(iter_->count), 
         ECS_COLUMN_INDEX_OUT_OF_RANGE, NULL);
-    return flecs::entity(m_iter->world, m_iter->entities[row]);
+    return flecs::entity(iter_->world, iter_->entities[row]);
 }
 
 inline flecs::entity iter::src(int32_t index) const {
-    return flecs::entity(m_iter->world, ecs_field_src(m_iter, index));
+    return flecs::entity(iter_->world, ecs_field_src(iter_, index));
 }
 
 inline flecs::id iter::id(int32_t index) const {
-    return flecs::id(m_iter->world, ecs_field_id(m_iter, index));
+    return flecs::id(iter_->world, ecs_field_id(iter_, index));
 }
 
 inline flecs::id iter::pair(int32_t index) const {
-    flecs::id_t id = ecs_field_id(m_iter, index);
+    flecs::id_t id = ecs_field_id(iter_, index);
     ecs_check(ECS_HAS_ID_FLAG(id, PAIR), ECS_INVALID_PARAMETER, NULL);
-    return flecs::id(m_iter->world, id);
+    return flecs::id(iter_->world, id);
 error:
     return flecs::id();
 }
 
 inline flecs::type iter::type() const {
-    return flecs::type(m_iter->world, ecs_table_get_type(m_iter->table));
+    return flecs::type(iter_->world, ecs_table_get_type(iter_->table));
 }
 
 inline flecs::table iter::table() const {
-    return flecs::table(m_iter->real_world, m_iter->table);
+    return flecs::table(iter_->real_world, iter_->table);
 }
 
 inline flecs::table_range iter::range() const {
-    return flecs::table_range(m_iter->real_world, m_iter->table, 
-        m_iter->offset, m_iter->count);
+    return flecs::table_range(iter_->real_world, iter_->table, 
+        iter_->offset, iter_->count);
 }
 
 template <typename T, typename A,
     typename std::enable_if<std::is_const<T>::value, void>::type*>
 inline flecs::field<A> iter::field(int32_t index) const {
-    ecs_assert(!(m_iter->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
+    ecs_assert(!(iter_->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
         "cannot .field from .each, use .field_at<const %s>(%d, row) instead",
             _::type_name<T>(), index);
     return get_field<A>(index);
@@ -32146,10 +30619,10 @@ template <typename T, typename A,
     typename std::enable_if<
         std::is_const<T>::value == false, void>::type*>
 inline flecs::field<A> iter::field(int32_t index) const {
-    ecs_assert(!(m_iter->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
+    ecs_assert(!(iter_->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
         "cannot .field from .each, use .field_at<%s>(%d, row) instead",
             _::type_name<T>(), index);
-    ecs_assert(!ecs_field_is_readonly(m_iter, index),
+    ecs_assert(!ecs_field_is_readonly(iter_, index),
         ECS_ACCESS_VIOLATION, NULL);
     return get_field<A>(index);
 }
@@ -32157,18 +30630,18 @@ inline flecs::field<A> iter::field(int32_t index) const {
 #ifdef FLECS_RULES
 inline flecs::entity iter::get_var(int var_id) const {
     ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, 0);
-    return flecs::entity(m_iter->world, ecs_iter_get_var(m_iter, var_id));
+    return flecs::entity(iter_->world, ecs_iter_get_var(iter_, var_id));
 }
 
 /** Get value of variable by name.
  * Get value of a query variable for current result.
  */
 inline flecs::entity iter::get_var(const char *name) const {
-    ecs_rule_iter_t *rit = &m_iter->priv.iter.rule;
-    const flecs::rule_t *r = rit->rule;
-    int var_id = ecs_rule_find_var(r, name);
+    ecs_query_iter_t *qit = &iter_->priv_.iter.query;
+    const flecs::query_t *q = qit->query;
+    int var_id = ecs_query_find_var(q, name);
     ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
-    return flecs::entity(m_iter->world, ecs_iter_get_var(m_iter, var_id));
+    return flecs::entity(iter_->world, ecs_iter_get_var(iter_, var_id));
 }
 #endif
 
@@ -32187,9 +30660,7 @@ namespace flecs
 inline void world::init_builtin_components() {
     this->component<Component>();
     this->component<Identifier>();
-    this->component<Iterable>("flecs::core::Iterable");
     this->component<Poly>();
-    this->component<FlattenTarget>();
 
 #   ifdef FLECS_SYSTEM
     _::system_init(*this);
@@ -32210,22 +30681,22 @@ inline void world::init_builtin_components() {
 
 template <typename T>
 inline flecs::entity world::use(const char *alias) const {
-    entity_t e = _::cpp_type<T>::id(m_world);
+    entity_t e = _::type<T>::id(world_);
     const char *name = alias;
     if (!name) {
         // If no name is defined, use the entity name without the scope
-        name = ecs_get_name(m_world, e);
+        name = ecs_get_name(world_, e);
     }
-    ecs_set_alias(m_world, e, name);
-    return flecs::entity(m_world, e);
+    ecs_set_alias(world_, e, name);
+    return flecs::entity(world_, e);
 }
 
 inline flecs::entity world::use(const char *name, const char *alias) const {
-    entity_t e = ecs_lookup_path_w_sep(m_world, 0, name, "::", "::", true);
+    entity_t e = ecs_lookup_path_w_sep(world_, 0, name, "::", "::", true);
     ecs_assert(e != 0, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_set_alias(m_world, e, alias);
-    return flecs::entity(m_world, e);
+    ecs_set_alias(world_, e, alias);
+    return flecs::entity(world_, e);
 }
 
 inline void world::use(flecs::entity e, const char *alias) const {
@@ -32233,163 +30704,163 @@ inline void world::use(flecs::entity e, const char *alias) const {
     const char *name = alias;
     if (!name) {
         // If no name is defined, use the entity name without the scope
-        name = ecs_get_name(m_world, eid);
+        name = ecs_get_name(world_, eid);
     }
-    ecs_set_alias(m_world, eid, name);
+    ecs_set_alias(world_, eid, name);
 }
 
 inline flecs::entity world::set_scope(const flecs::entity_t s) const {
-    return flecs::entity(ecs_set_scope(m_world, s));
+    return flecs::entity(ecs_set_scope(world_, s));
 }
 
 inline flecs::entity world::get_scope() const {
-    return flecs::entity(m_world, ecs_get_scope(m_world));
+    return flecs::entity(world_, ecs_get_scope(world_));
 }
 
 template <typename T>
 inline flecs::entity world::set_scope() const {
-    return set_scope( _::cpp_type<T>::id(m_world) ); 
+    return set_scope( _::type<T>::id(world_) ); 
 }
 
-inline entity world::lookup(const char *name, bool search_path) const {
-    auto e = ecs_lookup_path_w_sep(m_world, 0, name, "::", "::", search_path);
+inline entity world::lookup(const char *name, const char *sep, const char *root_sep, bool recursive) const {
+    auto e = ecs_lookup_path_w_sep(world_, 0, name, sep, root_sep, recursive);
     return flecs::entity(*this, e);
 }
 
 #ifndef ensure
 template <typename T>
 inline T& world::ensure() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.ensure<T>();
 }
 #endif
 
 template <typename T>
 inline void world::modified() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     e.modified<T>();
 }
 
 template <typename First, typename Second>
 inline void world::set(Second second, const First& value) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.set<First>(second, value);
 }
 
 template <typename First, typename Second>
 inline void world::set(Second second, First&& value) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.set<First>(second, value);
 }
 
 template <typename T>
 inline ref<T> world::get_ref() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.get_ref<T>();
 }
 
 template <typename T>
 inline const T* world::get() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.get<T>();
 }
 
 template <typename First, typename Second, typename P, typename A>
 const A* world::get() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.get<First, Second>();
 }
 
 template <typename First, typename Second>
 const First* world::get(Second second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.get<First>(second);
 }
 
 template <typename T>
 T* world::get_mut() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.get_mut<T>();
 }
 
 template <typename First, typename Second, typename P, typename A>
 A* world::get_mut() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.get_mut<First, Second>();
 }
 
 template <typename First, typename Second>
 First* world::get_mut(Second second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.get_mut<First>(second);
 }
 
 template <typename T>
 inline bool world::has() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.has<T>();
 }
 
 template <typename First, typename Second>
 inline bool world::has() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.has<First, Second>();
 }
 
 template <typename First>
 inline bool world::has(flecs::id_t second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.has<First>(second);
 }
 
 inline bool world::has(flecs::id_t first, flecs::id_t second) const {
-    flecs::entity e(m_world, first);
+    flecs::entity e(world_, first);
     return e.has(first, second);
 }
 
 template <typename T>
 inline void world::add() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     e.add<T>();
 }
 
 template <typename First, typename Second>
 inline void world::add() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.add<First, Second>();
 }
 
 template <typename First>
 inline void world::add(flecs::entity_t second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.add<First>(second);
 }
 
 inline void world::add(flecs::entity_t first, flecs::entity_t second) const {
-    flecs::entity e(m_world, first);
+    flecs::entity e(world_, first);
     e.add(first, second);
 }
 
 template <typename T>
 inline void world::remove() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     e.remove<T>();
 }
 
 template <typename First, typename Second>
 inline void world::remove() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.remove<First, Second>();
 }
 
 template <typename First>
 inline void world::remove(flecs::entity_t second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.remove<First>(second);
 }
 
 inline void world::remove(flecs::entity_t first, flecs::entity_t second) const {
-    flecs::entity e(m_world, first);
+    flecs::entity e(world_, first);
     e.remove(first, second);
 }
 
@@ -32400,14 +30871,14 @@ inline void world::children(Func&& f) const {
 
 template <typename T>
 inline flecs::entity world::singleton() const {
-    return flecs::entity(m_world, _::cpp_type<T>::id(m_world));
+    return flecs::entity(world_, _::type<T>::id(world_));
 }
 
 template <typename First>
 inline flecs::entity world::target(int32_t index) const
 {
-    return flecs::entity(m_world,
-        ecs_get_target(m_world, _::cpp_type<First>::id(m_world), _::cpp_type<First>::id(m_world), index));
+    return flecs::entity(world_,
+        ecs_get_target(world_, _::type<First>::id(world_), _::type<First>::id(world_), index));
 }
 
 template <typename T>
@@ -32415,40 +30886,40 @@ inline flecs::entity world::target(
     flecs::entity_t relationship,
     int32_t index) const
 {
-    return flecs::entity(m_world,
-        ecs_get_target(m_world, _::cpp_type<T>::id(m_world), relationship, index));
+    return flecs::entity(world_,
+        ecs_get_target(world_, _::type<T>::id(world_), relationship, index));
 }
 
 inline flecs::entity world::target(
     flecs::entity_t relationship,
     int32_t index) const
 {
-    return flecs::entity(m_world,
-        ecs_get_target(m_world, relationship, relationship, index));
+    return flecs::entity(world_,
+        ecs_get_target(world_, relationship, relationship, index));
 }
 
 template <typename Func, if_t< is_callable<Func>::value > >
 inline void world::get(const Func& func) const {
     static_assert(arity<Func>::value == 1, "singleton component must be the only argument");
     _::entity_with_delegate<Func>::invoke_get(
-        this->m_world, this->singleton<first_arg_t<Func>>(), func);
+        this->world_, this->singleton<first_arg_t<Func>>(), func);
 }
 
 template <typename Func, if_t< is_callable<Func>::value > >
 inline void world::set(const Func& func) const {
     static_assert(arity<Func>::value == 1, "singleton component must be the only argument");
     _::entity_with_delegate<Func>::invoke_ensure(
-        this->m_world, this->singleton<first_arg_t<Func>>(), func);
+        this->world_, this->singleton<first_arg_t<Func>>(), func);
 }
 
 inline flecs::entity world::get_alive(flecs::entity_t e) const {
-    e = ecs_get_alive(m_world, e);
-    return flecs::entity(m_world, e);
+    e = ecs_get_alive(world_, e);
+    return flecs::entity(world_, e);
 }
 
 inline flecs::entity world::make_alive(flecs::entity_t e) const {
-    ecs_make_alive(m_world, e);
-    return flecs::entity(m_world, e);
+    ecs_make_alive(world_, e);
+    return flecs::entity(world_, e);
 }
 
 template <typename E>
@@ -32465,7 +30936,7 @@ inline flecs::entity enum_data<E>::entity(underlying_type_t<E> value) const {
 #ifdef FLECS_META
     // Reflection data lookup failed. Try value lookup amongst flecs::Constant relationships
     flecs::world world = flecs::world(world_);
-    return world.filter_builder()
+    return world.query_builder()
         .with(flecs::ChildOf, world.id<E>())
         .with(flecs::Constant, world.id<int32_t>())
         .build()
@@ -32488,13 +30959,13 @@ inline flecs::entity enum_data<E>::entity(E value) const {
  * Operations need to be ran in a single statement.
  */
 inline flecs::scoped_world world::scope(id_t parent) const {
-    return scoped_world(m_world, parent);
+    return scoped_world(world_, parent);
 }
 
 template <typename T>
 inline flecs::scoped_world world::scope() const {
-    flecs::id_t parent = _::cpp_type<T>::id(m_world);
-    return scoped_world(m_world, parent);
+    flecs::id_t parent = _::type<T>::id(world_);
+    return scoped_world(world_, parent);
 }
 
 inline flecs::scoped_world world::scope(const char* name) const {
diff --git a/include/flecs.h b/include/flecs.h
index f81332f40..d8daaaa59 100644
--- a/include/flecs.h
+++ b/include/flecs.h
@@ -31,9 +31,9 @@
  */
 
 /* Flecs version macro */
-#define FLECS_VERSION_MAJOR 3
-#define FLECS_VERSION_MINOR 2
-#define FLECS_VERSION_PATCH 12
+#define FLECS_VERSION_MAJOR 4
+#define FLECS_VERSION_MINOR 0
+#define FLECS_VERSION_PATCH 0
 #define FLECS_VERSION FLECS_VERSION_IMPL(\
     FLECS_VERSION_MAJOR, FLECS_VERSION_MINOR, FLECS_VERSION_PATCH)
 
@@ -62,11 +62,6 @@
  */
 // #define FLECS_LEGACY
 
-/** @def FLECS_NO_DEPRECATED_WARNINGS
- * disables deprecated warnings
- */
-#define FLECS_NO_DEPRECATED_WARNINGS
-
 /** @def FLECS_ACCURATE_COUNTERS
  * Define to ensure that global counters used for statistics (such as the
  * allocation counters in the OS API) are accurate in multithreaded
@@ -130,7 +125,17 @@
  */
 // #define FLECS_KEEP_ASSERT
 
-/** @def FLECS_CUSTOM_BUILD
+/** \def FLECS_CPP_NO_AUTO_REGISTRATION
+ * When set, the C++ API will require that components are registered before they
+ * are used. This is useful in multithreaded applications, where components need
+ * to be registered beforehand, and to catch issues in projects where component 
+ * registration is mandatory. Disabling automatic component registration also
+ * slightly improves performance.
+ * The C API is not affected by this feature.
+ */
+// #define FLECS_CPP_NO_AUTO_REGISTRATION
+
+/** \def FLECS_CUSTOM_BUILD
  * This macro lets you customize which addons to build flecs with.
  * Without any addons Flecs is just a minimal ECS storage, but addons add
  * features such as systems, scheduling and reflection. If an addon is disabled,
@@ -173,10 +178,7 @@
 // #define FLECS_C          /**< C API convenience macros, always enabled */
 #define FLECS_CPP           /**< C++ API */
 #define FLECS_MODULE        /**< Module support */
-#define FLECS_PARSER        /**< String parser for queries */
-#define FLECS_PLECS         /**< ECS data definition format */
-#define FLECS_RULES         /**< Constraint solver for advanced queries */
-#define FLECS_SNAPSHOT      /**< Snapshot & restore ECS data */
+#define FLECS_SCRIPT         /**< ECS data definition format */
 #define FLECS_STATS         /**< Access runtime statistics */
 #define FLECS_MONITOR       /**< Track runtime statistics periodically */
 #define FLECS_METRICS       /**< Expose component data as statistics */
@@ -185,9 +187,7 @@
 #define FLECS_PIPELINE      /**< Pipeline support */
 #define FLECS_TIMER         /**< Timer support */
 #define FLECS_META          /**< Reflection support */
-#define FLECS_META_C        /**< Utilities for populating reflection data */
 #define FLECS_UNITS         /**< Builtin standard units */
-#define FLECS_EXPR          /**< Parsing strings to/from component values */
 #define FLECS_JSON          /**< Parsing JSON to/from component values */
 #define FLECS_DOC           /**< Document entities & components */
 #define FLECS_LOG           /**< When enabled ECS provides more detailed logs */
@@ -261,31 +261,50 @@
 #define FLECS_ID_DESC_MAX (32)
 #endif
 
-/** @def FLECS_TERM_DESC_MAX
- * Maximum number of terms in ecs_filter_desc_t */
-#define FLECS_TERM_DESC_MAX (16)
-
-/** @def FLECS_EVENT_DESC_MAX
+/** \def FLECS_EVENT_DESC_MAX
  * Maximum number of events in ecs_observer_desc_t */
+#ifndef FLECS_EVENT_DESC_MAX
 #define FLECS_EVENT_DESC_MAX (8)
+#endif
 
 /** @def FLECS_VARIABLE_COUNT_MAX
  * Maximum number of query variables per query */
 #define FLECS_VARIABLE_COUNT_MAX (64)
 
+/** \def FLECS_TERM_COUNT_MAX 
+ * Maximum number of terms in queries. Should not be set higher than 64. */
+#ifndef FLECS_TERM_COUNT_MAX
+#define FLECS_TERM_COUNT_MAX 16
+#endif
+
+/** \def FLECS_TERM_ARG_COUNT_MAX 
+ * Maximum number of arguments for a term. */
+#ifndef FLECS_TERM_ARG_COUNT_MAX
+#define FLECS_TERM_ARG_COUNT_MAX (16)
+#endif
+
+/** \def FLECS_QUERY_VARIABLE_COUNT_MAX
+ * Maximum number of query variables per query */
+#ifndef FLECS_QUERY_VARIABLE_COUNT_MAX
+#define FLECS_QUERY_VARIABLE_COUNT_MAX (64)
+#endif
+
 /** @def FLECS_QUERY_SCOPE_NESTING_MAX
  * Maximum nesting depth of query scopes */
+#ifndef FLECS_QUERY_SCOPE_NESTING_MAX
 #define FLECS_QUERY_SCOPE_NESTING_MAX (8)
+#endif
 
 /** @} */
 
 #include "flecs/private/api_defines.h"
-#include "flecs/private/vec.h"              /* Vector datatype */
-#include "flecs/private/sparse.h"           /* Sparse set */
-#include "flecs/private/block_allocator.h"  /* Block allocator */
-#include "flecs/private/map.h"              /* Map */
-#include "flecs/private/allocator.h"        /* Allocator */
-#include "flecs/private/strbuf.h"           /* String builder */
+#include "flecs/datastructures/vec.h"              /* Vector datatype */
+#include "flecs/datastructures/sparse.h"           /* Sparse set */
+#include "flecs/datastructures/block_allocator.h"  /* Block allocator */
+#include "flecs/datastructures/stack_allocator.h"  /* Stack allocator */
+#include "flecs/datastructures/map.h"              /* Map */
+#include "flecs/datastructures/allocator.h"        /* Allocator */
+#include "flecs/datastructures/strbuf.h"           /* String builder */
 #include "flecs/os_api.h"  /* Abstraction for operating system functions */
 
 #ifdef __cplusplus
@@ -361,60 +380,18 @@ typedef struct {
  * that forces the API to ignore the old component ids. */
 typedef struct ecs_world_t ecs_world_t;
 
+/** A stage enables modification while iterating and from multiple threads */
+typedef struct ecs_stage_t ecs_stage_t;
+
 /** A table stores entities and components for a specific type. */
 typedef struct ecs_table_t ecs_table_t;
 
 /** A term is a single element in a query. */
 typedef struct ecs_term_t ecs_term_t;
 
-/** A filter is an iterable data structure that describes a query.
- * Filters are used by the various query implementations in Flecs, like queries,
- * observers and rules, to describe a query. Filters themselves can also be
- * iterated. */
-typedef struct ecs_filter_t ecs_filter_t;
-
-/** A query that caches its results.
- * Queries are the fastest mechanism for finding and iterating over entities.
- * Queries cache results as a list of matching tables (vs. individual entities).
- *
- * This has several advantages:
- * - Matching is only performed when new tables are created, which is infrequent
- * - Iterating a query just walks over the cache, no actual searching is needed
- * - Iteration is table-based, which allows for direct iteration of underlying
- *   component arrays, providing good cache locality.
- *
- * While queries are the fastest mechanism to iterate entities, they are slower
- * to create than other mechanisms, as a result of having to build the cache
- * first. For this reason queries are best suited for use cases where a single
- * query can be reused many times (like is the case for systems).
- *
- * For ad-hoc queries it is recommended to use filters or rules instead, which
- * are slower to iterate, but much faster to create. Applications should at all
- * times avoid frequent creation/deletion of queries. */
+/** A query returns entities matching a list of constraints. */
 typedef struct ecs_query_t ecs_query_t;
 
-/** A rule is a query with advanced graph traversal features.
- * Rules are fast uncached queries with support for advanced graph features such
- * as the usage of query variables. A simple example of a rule that matches all
- * spaceship entities docked to a planet:
- *
- *     SpaceShip, (DockedTo, $planet), Planet($planet)
- *
- * Here, the rule traverses the DockedTo relationship, and matches Planet on the
- * target of this relationship. Through the usage of variables rules can match
- * arbitrary patterns against entity graphs. Other features supported
- * exclusively by rules are:
- * - Component inheritance
- * - Transitivity
- *
- * Rules have similar iteration performance to filters, but are slower than
- * queries. Rules and filters will eventually be merged into a single query
- * implementation. Features still lacking for rules are:
- * - Up traversal
- * - AndFrom, OrFrom, NotFrom operators
- */
-typedef struct ecs_rule_t ecs_rule_t;
-
 /** An observer is a system that is invoked when an event matches its query.
  * Observers allow applications to respond to specific events, such as adding or
  * removing a component. Observers are created by both specifying a query and
@@ -429,10 +406,9 @@ typedef struct ecs_rule_t ecs_rule_t;
  *   });
  * @endcode
  *
- * Observer queries can be as complex as filters. Observers only trigger when
- * the source of the event matches the full observer query. For example, an
- * OnAdd observer for Position, Velocity will only trigger after both components
- * have been added to the entity. */
+ * Observers only trigger when the source of the event matches the full observer 
+ * query. For example, an OnAdd observer for Position, Velocity will only 
+ * trigger after both components have been added to the entity. */
 typedef struct ecs_observer_t ecs_observer_t;
 
 /** An observable produces events that can be listened for by an observer.
@@ -440,10 +416,9 @@ typedef struct ecs_observer_t ecs_observer_t;
  * observable objects as well. */
 typedef struct ecs_observable_t ecs_observable_t;
 
-/* Type used for iterating iterable objects.
- * Iterators are a common interface across iterable objects (world, filters,
- * rules, queries, systems, observers) to provide applications with information
- * about the currently iterated result, and to store any state required for the
+/** Type used for iterating iterable objects.
+ * Iterators are objects that provide applications with information
+ * about the currently iterated result, and store any state required for the
  * iteration. */
 typedef struct ecs_iter_t ecs_iter_t;
 
@@ -479,16 +454,13 @@ typedef struct ecs_table_record_t ecs_table_record_t;
 /** A poly object.
  * A poly (short for polymorph) object is an object that has a variable list of
  * capabilities, determined by a mixin table. This is the current list of types
- * in the flecs API that can be used as an ecs_poly_t:
+ * in the flecs API that can be used as an flecs_poly_t:
  *
  * - ecs_world_t
  * - ecs_stage_t
  * - ecs_query_t
- * - ecs_filter_t
- * - ecs_rule_t
- * - (more to come)
  *
- * Functions that accept an ecs_poly_t argument can accept objects of these
+ * Functions that accept an flecs_poly_t argument can accept objects of these
  * types. If the object does not have the requested mixin the API will throw an
  * assert.
  *
@@ -498,15 +470,16 @@ typedef struct ecs_table_record_t ecs_table_record_t;
  * (in some ways it's like a mini-ECS). Additionally, each poly object has a
  * header that enables the API to do sanity checking on the input arguments.
  */
-typedef void ecs_poly_t;
+typedef void flecs_poly_t;
 
 /** Type that stores poly mixins */
 typedef struct ecs_mixins_t ecs_mixins_t;
 
-/** Header for ecs_poly_t objects. */
+/** Header for flecs_poly_t objects. */
 typedef struct ecs_header_t {
-    int32_t magic; /* Magic number verifying it's a flecs object */
-    int32_t type;  /* Magic number indicating which type of flecs object */
+    int32_t magic;    /* Magic number verifying it's a flecs object */
+    int32_t type;     /* Magic number indicating which type of flecs object */
+    int32_t refcount; /* Refcount, to enable RAII handles */
     ecs_mixins_t *mixins; /* Table with offsets to (optional) mixins */
 } ecs_header_t;
 
@@ -540,23 +513,6 @@ typedef void (*ecs_run_action_t)(
 typedef void (*ecs_iter_action_t)(
     ecs_iter_t *it);
 
-/** Function prototype for creating an iterator from a poly.
- * Used to create iterators from poly objects with the iterable mixin. When a
- * filter is provided, an array of two iterators must be passed to the function.
- * This allows the mixin implementation to create a chained iterator when
- * necessary, which requires two iterator objects.
- *
- * @param world The world or stage for which to create the iterator.
- * @param iterable An iterable poly object.
- * @param it The iterator to create (out parameter)
- * @param filter Optional term to filter results.
- */
-typedef void (*ecs_iter_init_action_t)(
-    const ecs_world_t *world,
-    const ecs_poly_t *iterable,
-    ecs_iter_t *it,
-    ecs_term_t *filter);
-
 /** Function prototype for iterating an iterator.
  * Stored inside initialized iterators. This allows an application to iterate
  * an iterator without needing to know what created it.
@@ -656,23 +612,8 @@ typedef void (*ecs_move_t)(
     const ecs_type_info_t *type_info);
 
 /* Destructor function for poly objects */
-typedef void (*ecs_poly_dtor_t)(
-    ecs_poly_t *poly);
-
-/** @} */
-
-/**
- * @defgroup mixins Poly mixin types.
- * Mixin types for poly mechanism.
- *
- * @{
- */
-
-/** Iterable mixin.
- * Allows its container to be iterated. */
-typedef struct ecs_iterable_t {
-    ecs_iter_init_action_t init; /**< Callback that creates iterator. */
-} ecs_iterable_t;
+typedef void (*flecs_poly_dtor_t)(
+    flecs_poly_t *poly);
 
 /** @} */
 
@@ -687,6 +628,7 @@ typedef struct ecs_iterable_t {
 typedef enum ecs_inout_kind_t {
     EcsInOutDefault,  /**< InOut for regular terms, In for shared terms */
     EcsInOutNone,     /**< Term is neither read nor written */
+    EcsInOutFilter,   /**< Same as InOutNOne + prevents term from triggering observers */
     EcsInOut,         /**< Term is both read and written */
     EcsIn,            /**< Term is only read */
     EcsOut,           /**< Term is only written */
@@ -703,39 +645,94 @@ typedef enum ecs_oper_kind_t {
     EcsNotFrom,       /**< Term must match none of the components from term id */
 } ecs_oper_kind_t;
 
+/** Specify cache policy for query */
+typedef enum ecs_query_cache_kind_t {
+    EcsQueryCacheDefault,   /**< Behavior determined by query creation context */
+    EcsQueryCacheAuto,      /**< Cache query terms that are cacheable */
+    EcsQueryCacheAll,       /**< Require that all query terms can be cached */
+    EcsQueryCacheNone,      /**< No caching */
+} ecs_query_cache_kind_t;
+
 /* Term id flags  */
-#define EcsSelf                       (1u << 1)  /**< Match on self */
-#define EcsUp                         (1u << 2)  /**< Match by traversing upwards */
-#define EcsDown                       (1u << 3)  /**< Match by traversing downwards (derived, cannot be set) */
-#define EcsTraverseAll                (1u << 4)  /**< Match all entities encountered through traversal */
-#define EcsCascade                    (1u << 5)  /**< Sort results breadth first */
-#define EcsDesc                       (1u << 6)  /**< Iterate groups in descending order  */
-#define EcsParent                     (1u << 7)  /**< Short for up(ChildOf) */
-#define EcsIsVariable                 (1u << 8)  /**< Term id is a variable */
-#define EcsIsEntity                   (1u << 9)  /**< Term id is an entity */
-#define EcsIsName                     (1u << 10) /**< Term id is a name (don't attempt to lookup as entity) */
-#define EcsFilter                     (1u << 11) /**< Prevent observer from triggering on term */
-#define EcsTraverseFlags              (EcsUp|EcsDown|EcsTraverseAll|EcsSelf|EcsCascade|EcsDesc|EcsParent)
-
-/* Term flags discovered & set during filter creation. Mostly used internally to
+
+/** Match on self.
+ * Can be combined with other term flags on the ecs_term_t::flags field.
+ * \ingroup queries
+ */
+#define EcsSelf                       (1llu << 63)
+
+/** Match by traversing upwards.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsUp                         (1llu << 62)
+
+/** Traverse relationship transitively.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsTrav                       (1llu << 61)
+
+/** Sort results breadth first.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsCascade                    (1llu << 60)
+
+/** Iterate groups in descending order.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsDesc                       (1llu << 59)
+
+/** Term id is a variable.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsIsVariable                 (1llu << 58)
+
+/** Term id is an entity.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsIsEntity                   (1llu << 57)
+
+/** Term id is a name (don't attempt to lookup as entity).
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsIsName                     (1llu << 56)
+
+/** All term traversal flags.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsTraverseFlags              (EcsSelf|EcsUp|EcsTrav|EcsCascade|EcsDesc)
+
+/** All term reference kind flags.
+ * Can be combined with other term flags on the ecs_term_ref_t::id field.
+ * \ingroup queries
+ */
+#define EcsTermRefFlags               (EcsTraverseFlags|EcsIsVariable|EcsIsEntity|EcsIsName)
+
+/* Term flags discovered & set during query creation. Mostly used internally to
  * store information relevant to queries. */
 #define EcsTermMatchAny               (1u << 0)
 #define EcsTermMatchAnySrc            (1u << 1)
-#define EcsTermSrcFirstEq             (1u << 2)
-#define EcsTermSrcSecondEq            (1u << 3)
-#define EcsTermTransitive             (1u << 4)
-#define EcsTermReflexive              (1u << 5)
-#define EcsTermIdInherited            (1u << 6)
-#define EcsTermIsTrivial              (1u << 7)
-#define EcsTermNoData                 (1u << 8)
-
-/* Term flags used for term iteration */
-#define EcsTermMatchDisabled          (1u << 7)
-#define EcsTermMatchPrefab            (1u << 8)
-
-/** Type that describes a single identifier in a term */
-typedef struct ecs_term_id_t {
-    ecs_entity_t id;            /**< Entity id. If left to 0 and flags does not
+#define EcsTermTransitive             (1u << 2)
+#define EcsTermReflexive              (1u << 3)
+#define EcsTermIdInherited            (1u << 4)
+#define EcsTermIsTrivial              (1u << 5)
+#define EcsTermNoData                 (1u << 6)
+#define EcsTermIsCacheable            (1u << 7)
+#define EcsTermIsScope                (1u << 8)
+#define EcsTermIsMember               (1u << 9)
+#define EcsTermIsToggle               (1u << 10)
+#define EcsTermKeepAlive              (1u << 11)
+
+/** Type that describes a reference to an entity or variable in a term. */
+typedef struct ecs_term_ref_t {
+    ecs_entity_t id;            /**< Entity id. If left to 0 and flags does not 
                                  * specify whether id is an entity or a variable
                                  * the id will be initialized to EcsThis.
                                  * To explicitly set the id to 0, leave the id
@@ -746,13 +743,7 @@ typedef struct ecs_term_id_t {
                                  * entity name. When ecs_term_t::move is true,
                                  * the API assumes ownership over the string and
                                  * will free it when the term is destroyed. */
-
-    ecs_entity_t trav;          /**< Relationship to traverse when looking for the
-                                 * component. The relationship must have
-                                 * the Traversable property. Default is IsA. */
-
-    ecs_flags32_t flags;        /**< Term flags */
-} ecs_term_id_t;
+} ecs_term_ref_t;
 
 /** Type that describes a term (single element in a query) */
 struct ecs_term_t {
@@ -761,59 +752,62 @@ struct ecs_term_t {
                                  * first/second members, which provide more
                                  * flexibility. */
 
-    ecs_term_id_t src;          /**< Source of term */
-    ecs_term_id_t first;        /**< Component or first element of pair */
-    ecs_term_id_t second;       /**< Second element of pair */
+    ecs_term_ref_t src;          /**< Source of term */
+    ecs_term_ref_t first;        /**< Component or first element of pair */
+    ecs_term_ref_t second;       /**< Second element of pair */
 
-    ecs_inout_kind_t inout;     /**< Access to contents matched by term */
-    ecs_oper_kind_t oper;       /**< Operator of term */
+    ecs_entity_t trav;          /**< Relationship to traverse when looking for the
+                                 * component. The relationship must have
+                                 * the Traversable property. Default is IsA. */
 
-    ecs_id_t id_flags;          /**< Id flags of term id */
-    char *name;                 /**< Name of term */
+    int16_t inout;              /**< Access to contents matched by term */
+    int16_t oper;               /**< Operator of term */
 
-    int32_t field_index;        /**< Index of field for term in iterator */
-    ecs_id_record_t *idr;       /**< Cached pointer to internal index */
+    int16_t field_index;        /**< Index of field for term in iterator */
+    ecs_flags16_t flags_;       /**< Flags that help eval, set by ecs_query_init */
+};
 
-    ecs_flags16_t flags;        /**< Flags that help eval, set by ecs_filter_init */
+/** Queries are lists of constraints (terms) that match entities. */
+struct ecs_query_t {
+    ecs_header_t hdr;
 
-    bool move;                  /**< Used by internals */
-};
+    ecs_term_t terms[FLECS_TERM_COUNT_MAX]; /**< Query terms */
+    int32_t sizes[FLECS_TERM_COUNT_MAX]; /**< Component sizes. Indexed by field */
+    ecs_id_t ids[FLECS_TERM_COUNT_MAX]; /**< Component ids. Indexed by field */
 
-/** Use $this variable to initialize user-allocated filter object */
-FLECS_API extern ecs_filter_t ECS_FILTER_INIT;
+    ecs_flags32_t flags;        /**< Query flags */
+    int8_t term_count;          /**< Number of query terms */
+    int8_t field_count;         /**< Number of fields returned by query */
 
-/** Filters allow for ad-hoc quick filtering of entity tables. */
-struct ecs_filter_t {
-    ecs_header_t hdr;
+    /* Bitmasks for quick field information lookups */
+    ecs_termset_t fixed_fields; /**< Fields with a fixed source */
+    ecs_termset_t data_fields;  /**< Fields that have data */
+    ecs_termset_t write_fields; /**< Fields that write data */
+    ecs_termset_t read_fields;  /**< Fields that read data */
+    ecs_termset_t shared_readonly_fields; /**< Fields that don't write shared data */
+    ecs_termset_t set_fields;   /**< Fields that will be set */
 
-    int8_t term_count;        /**< Number of elements in terms array */
-    int8_t field_count;       /**< Number of fields in iterator for filter */
-    ecs_flags32_t flags;      /**< Filter flags */
-    ecs_flags64_t data_fields; /**< Bitset with fields that have data */
+    ecs_query_cache_kind_t cache_kind;  /**< Caching policy of query */
 
-    ecs_term_t *terms;         /**< Array containing terms for filter */
-    char *variable_names[1];   /**< Placeholder variable names array */
-    int32_t *sizes;            /**< Field size (same for each result) */
-    ecs_id_t *ids;             /**< Array with field ids */
+    void *ctx;                  /**< User context to pass to callback */
+    void *binding_ctx;          /**< Context to be used for language bindings */
 
-    int32_t eval_count;        /**< Number of times query is evaluated */
+    ecs_entity_t entity;        /**< Entity associated with query (optional) */
+    ecs_world_t *world;         /**< World mixin */
+    ecs_stage_t *stage;         /**< Stage the query was created with */
 
-    /* Mixins */
-    ecs_entity_t entity;       /**< Entity associated with filter (optional) */
-    ecs_iterable_t iterable;   /**< Iterable mixin */
-    ecs_poly_dtor_t dtor;      /**< Dtor mixin */
-    ecs_world_t *world;        /**< World mixin */
+    int32_t eval_count;         /**< Number of times query is evaluated */
 };
 
-/* An observer reacts to events matching a filter */
+/* An observer reacts to events matching a query */
 struct ecs_observer_t {
     ecs_header_t hdr;
+    
+    ecs_query_t *query;        /**< Observer query */
 
-    ecs_filter_t filter;        /**< Query for observer */
-
-    /* Observer events */
+    /** Observer events */
     ecs_entity_t events[FLECS_EVENT_DESC_MAX];
-    int32_t event_count;
+    int32_t event_count;        /**< Number of events */
 
     ecs_iter_action_t callback; /**< See ecs_observer_desc_t::callback */
     ecs_run_action_t run;       /**< See ecs_observer_desc_t::run */
@@ -826,16 +820,8 @@ struct ecs_observer_t {
 
     ecs_observable_t *observable; /**< Observable for observer */
 
-    int32_t *last_event_id;     /**< Last handled event id */
-    int32_t last_event_id_storage;
-
-    ecs_id_t register_id;       /**< Id observer is registered with (single term observers only) */
-    int32_t term_index;         /**< Index of the term in parent observer (single term observers only) */
-
-    ecs_flags32_t flags;        /**< Observer flags */
-
-    /* Mixins */
-    ecs_poly_dtor_t dtor;
+    ecs_world_t *world;         /**< The world */
+    ecs_entity_t entity;        /**< Entity associated with observer */
 };
 
 /** @} */
@@ -903,8 +889,13 @@ struct ecs_type_info_t {
 
 #include "flecs/private/api_types.h"        /* Supporting API types */
 #include "flecs/private/api_support.h"      /* Supporting API functions */
-#include "flecs/private/vec.h"              /* Vector */
-#include "flecs/private/hashmap.h"          /* Hashmap */
+#include "flecs/datastructures/hashmap.h"   /* Hashmap */
+
+/* Utility to hold a value of a dynamic type */
+typedef struct ecs_value_t {
+    ecs_entity_t type;
+    void *ptr;
+} ecs_value_t;
 
 /** Used with ecs_entity_init().
  *
@@ -915,6 +906,8 @@ typedef struct ecs_entity_desc_t {
 
     ecs_entity_t id;      /**< Set to modify existing entity (optional) */
 
+    ecs_entity_t parent;  /**< Parent entity. */
+
     const char *name;     /**< Name of the entity. If no entity is provided, an
                            * entity with this name will be looked up first. When
                            * an entity is provided, the name will be verified
@@ -940,8 +933,11 @@ typedef struct ecs_entity_desc_t {
                            * components) will be used to create the entity, if
                            * no id is specified. */
 
-    /** Array of ids to add to the new or existing entity. */
-    ecs_id_t add[FLECS_ID_DESC_MAX];
+    /** 0-terminated array of ids to add to the entity. */
+    const ecs_id_t *add;
+
+    /** 0-terminated array of values to set on the entity. */
+    const ecs_value_t *set;
 
     /** String expression with components to add */
     const char *add_expr;
@@ -991,76 +987,182 @@ typedef struct ecs_component_desc_t {
     ecs_type_info_t type;
 } ecs_component_desc_t;
 
-/** Used with ecs_filter_init().
+/** Iterator.
+ * Used for iterating queries. The ecs_iter_t type contains all the information
+ * that is provided by a query, and contains all the state required for the
+ * iterator code.
+ * 
+ * Functions that create iterators accept as first argument the world, and as
+ * second argument the object they iterate. For example:
+ * 
+ * @code
+ * ecs_iter_t it = ecs_query_iter(world, q);
+ * @endcode
+ * 
+ * When this code is called from a system, it is important to use the world
+ * provided by its iterator object. For example:
+ * 
+ * @code
+ * void Collide(ecs_iter_t *it) {
+ *   ecs_iter_t qit = ecs_query_iter(it->world, Colliders);
+ * }
+ * @endcode
+ * 
+ * This ensures thread safe allocation and cleanup of any resources required by 
+ * the iterator.
  *
- * @ingroup filters
+ * @ingroup queries
  */
-typedef struct ecs_filter_desc_t {
-    int32_t _canary;
+struct ecs_iter_t {
+    /* World */
+    ecs_world_t *world;           /**< The world */
+    ecs_world_t *real_world;      /**< Actual world. This differs from world when in readonly mode */
+
+    /* Matched data */
+    ecs_entity_t *entities;       /**< Entity identifiers */
+    void **ptrs;                  /**< Pointers to components. Array if from this, pointer if not. */
+    const ecs_size_t *sizes;      /**< Component sizes */
+    ecs_table_t *table;           /**< Current table */
+    ecs_table_t *other_table;     /**< Prev or next table when adding/removing */
+    ecs_id_t *ids;                /**< (Component) ids */
+    ecs_var_t *variables;         /**< Values of variables (if any) */
+    int32_t *columns;             /**< Query term to table column mapping */
+    ecs_entity_t *sources;        /**< Entity on which the id was matched (0 if same as entities) */
+    ecs_ref_t *references;        /**< Cached refs to components (if iterating a cache) */
+    ecs_flags64_t constrained_vars; /**< Bitset that marks constrained variables */
+    uint64_t group_id;            /**< Group id for table, if group_by is used */
+    int32_t field_count;          /**< Number of fields in iterator */
+    ecs_termset_t set_fields;     /**< Fields that are set */
+    ecs_termset_t shared_fields;  /**< Bitset with shared fields */
+    ecs_termset_t up_fields;      /**< Bitset with fields matched through up traversal */
+
+    /* Input information */
+    ecs_entity_t system;          /**< The system (if applicable) */
+    ecs_entity_t event;           /**< The event (if applicable) */
+    ecs_id_t event_id;            /**< The (component) id for the event */
+    int32_t event_cur;            /**< Unique event id. Used to dedup observer calls */
+
+    /* Query information */
+    const ecs_query_t *query;     /**< Query being evaluated */
+    int32_t term_index;           /**< Index of term that emitted an event.
+                                   * This field will be set to the 'index' field
+                                   * of an observer term. */
+    int32_t variable_count;       /**< Number of variables for query */
+    char **variable_names;        /**< Names of variables (if any) */
+
+    /* Context */
+    void *param;                  /**< Param passed to ecs_run */
+    void *ctx;                    /**< System context */
+    void *binding_ctx;            /**< Binding context */
+
+    /* Time */
+    ecs_ftime_t delta_time;       /**< Time elapsed since last frame */
+    ecs_ftime_t delta_system_time;/**< Time elapsed since last system invocation */
+
+    /* Iterator counters */
+    int32_t frame_offset;         /**< Offset relative to start of iteration */
+    int32_t offset;               /**< Offset relative to current table */
+    int32_t count;                /**< Number of entities to iterate */
+    int32_t instance_count;       /**< Number of entities to iterate before next table */
+
+    /* Misc */
+    ecs_flags32_t flags;          /**< Iterator flags */
+    ecs_entity_t interrupted_by;  /**< When set, system execution is interrupted */
+    ecs_iter_private_t priv_;     /**< Private data */
+
+    /* Chained iterators */
+    ecs_iter_next_action_t next;  /**< Function to progress iterator */
+    ecs_iter_action_t callback;   /**< Callback of system or observer */
+    ecs_iter_fini_action_t fini;  /**< Function to cleanup iterator resources */
+    ecs_iter_t *chain_it;         /**< Optional, allows for creating iterator chains */
+};
 
-    /** Terms of the filter. If a filter has more terms than
-     * FLECS_TERM_DESC_MAX use terms_buffer */
-    ecs_term_t terms[FLECS_TERM_DESC_MAX];
 
-    /** For filters with lots of terms an outside array can be provided. */
-    ecs_term_t *terms_buffer;
+/** Query must match prefabs.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryMatchPrefab           (1u << 1u)
 
-    /** Number of terms in array provided in terms_buffer. */
-    int32_t terms_buffer_count;
+/** Query must match disabled entities.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryMatchDisabled         (1u << 2u)
 
-    /** External storage to prevent allocation of the filter object */
-    ecs_filter_t *storage;
+/** Query must match empty tables.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryMatchEmptyTables      (1u << 3u)
 
-    /** When true, terms returned by an iterator may either contain 1 or N
-     * elements, where terms with N elements are owned, and terms with 1 element
-     * are shared, for example from a parent or base entity. When false, the
-     * iterator will at most return 1 element when the result contains both
-     * owned and shared terms. */
-    bool instanced;
+/** Query won't provide component data.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryNoData                (1u << 4u)
 
-    /** Flags for advanced usage */
-    ecs_flags32_t flags;
+/** Query iteration is always instanced.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryIsInstanced           (1u << 5u)
 
-    /** Filter expression. Should not be set at the same time as terms array */
-    const char *expr;
+/** Query may have unresolved entity identifiers.
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryAllowUnresolvedByName (1u << 6u)
 
-    /** Entity associated with query (optional) */
-    ecs_entity_t entity;
-} ecs_filter_desc_t;
+/** Query only returns whole tables (ignores toggle/member fields).
+ * Can be combined with other query flags on the ecs_query_desc_t::flags field.
+ * \ingroup queries
+ */
+#define EcsQueryTableOnly             (1u << 7u)
 
-/** Used with ecs_query_init().
- *
- * @ingroup queries
+
+/** Used with ecs_query_init. 
+ * 
+ * \ingroup queries
  */
 typedef struct ecs_query_desc_t {
     int32_t _canary;
 
-    /** Filter for the query */
-    ecs_filter_desc_t filter;
+    /** Query terms */
+    ecs_term_t terms[FLECS_TERM_COUNT_MAX];
 
-    /** Component to be used by order_by */
-    ecs_entity_t order_by_component;
+    /** Query DSL expression (optional) */
+    const char *expr;
+
+    /** Caching policy of query */
+    ecs_query_cache_kind_t cache_kind;
+
+    /** Flags for enabling query features */
+    ecs_flags32_t flags;
 
     /** Callback used for ordering query results. If order_by_id is 0, the
      * pointer provided to the callback will be NULL. If the callback is not
      * set, results will not be ordered. */
-    ecs_order_by_action_t order_by;
+    ecs_order_by_action_t order_by_callback;
 
-    /** Callback used for ordering query results. Same as order_by,
+    /** Callback used for ordering query results. Same as order_by_callback,
      * but more efficient. */
-    ecs_sort_table_action_t sort_table;
+    ecs_sort_table_action_t order_by_table_callback;
 
-    /** Id to be used by group_by. This id is passed to the group_by function and
-     * can be used identify the part of an entity type that should be used for
-     * grouping. */
-    ecs_id_t group_by_id;
+    /** Component to sort on, used together with order_by_callback or
+     * order_by_table_callback. */
+    ecs_entity_t order_by;
+
+    /** Component id to be used for grouping. Used together with the
+     * group_by_callback. */
+    ecs_id_t group_by;
 
     /** Callback used for grouping results. If the callback is not set, results
      * will not be grouped. When set, this callback will be used to calculate a
      * "rank" for each entity (table) based on its components. This rank is then
      * used to sort entities (tables), so that entities (tables) of the same
      * rank are "grouped" together when iterated. */
-    ecs_group_by_action_t group_by;
+    ecs_group_by_action_t group_by_callback;
 
     /** Callback that is invoked when a new group is created. The return value of
      * the callback is stored as context for a group. */
@@ -1076,14 +1178,6 @@ typedef struct ecs_query_desc_t {
     /** Function to free group_by_ctx */
     ecs_ctx_free_t group_by_ctx_free;
 
-    /** If set, the query will be created as a subquery. A subquery matches at
-     * most a subset of its parent query. Subqueries do not directly receive
-     * (table) notifications from the world. Instead parent queries forward
-     * results to subqueries. This can improve matching performance, as fewer
-     * queries need to be matched with new tables.
-     * Subqueries can be nested. */
-    ecs_query_t *parent;
-
     /** User context to pass to callback */
     void *ctx;
 
@@ -1095,6 +1189,9 @@ typedef struct ecs_query_desc_t {
 
     /** Callback to free binding_ctx */
     ecs_ctx_free_t binding_ctx_free;
+
+    /** Entity associated with query (optional) */
+    ecs_entity_t entity;
 } ecs_query_desc_t;
 
 /** Used with ecs_observer_init().
@@ -1107,22 +1204,21 @@ typedef struct ecs_observer_desc_t {
     /** Existing entity to associate with observer (optional) */
     ecs_entity_t entity;
 
-    /** Filter for observer */
-    ecs_filter_desc_t filter;
+    /** Query for observer */
+    ecs_query_desc_t query;
 
     /** Events to observe (OnAdd, OnRemove, OnSet, UnSet) */
     ecs_entity_t events[FLECS_EVENT_DESC_MAX];
 
     /** When observer is created, generate events from existing data. For example,
-     * EcsOnAdd Position would match all existing instances of Position.
-     * This is only supported for events that are iterable (see EcsIterable) */
+     * EcsOnAdd Position would match all existing instances of Position. */
     bool yield_existing;
 
     /** Callback to invoke on an event, invoked when the observer matches. */
     ecs_iter_action_t callback;
 
     /** Callback invoked on an event. When left to NULL the default runner
-     * is used which matches the event with the observer's filter, and calls
+     * is used which matches the event with the observer's query, and calls
      * 'callback' when it matches.
      * A reason to override the run function is to improve performance, if there
      * are more efficient way to test whether an event matches the observer than
@@ -1142,7 +1238,7 @@ typedef struct ecs_observer_desc_t {
     ecs_ctx_free_t binding_ctx_free;
 
     /** Observable with which to register the observer */
-    ecs_poly_t *observable;
+    flecs_poly_t *observable;
 
     /** Optional shared last event id for multiple observers. Ensures only one
      * of the observers with the shared id gets triggered for an event */
@@ -1195,7 +1291,7 @@ typedef struct ecs_event_desc_t {
     const void *const_param;
 
     /** Observable (usually the world) */
-    ecs_poly_t *observable;
+    flecs_poly_t *observable;
 
     /** Event flags */
     ecs_flags32_t flags;
@@ -1209,12 +1305,6 @@ typedef struct ecs_event_desc_t {
  * @{
  */
 
-/* Utility to hold a value of a dynamic type */
-typedef struct ecs_value_t {
-    ecs_entity_t type;
-    void *ptr;
-} ecs_value_t;
-
 /** Type with information about the current Flecs build */
 typedef struct ecs_build_info_t {
     const char *compiler;           /**< Compiler used to compile flecs */
@@ -1320,17 +1410,17 @@ typedef struct EcsComponent {
 
 /** Component for storing a poly object */
 typedef struct EcsPoly {
-    ecs_poly_t *poly;          /**< Pointer to poly object */
+    flecs_poly_t *poly;          /**< Pointer to poly object */
 } EcsPoly;
 
-/** Target data for flattened relationships. */
-typedef struct EcsFlattenTarget {
-    int32_t count;
-    ecs_record_t *target;
-} EcsFlattenTarget;
-
-/** Component for iterable entities */
-typedef ecs_iterable_t EcsIterable;
+/** When added to an entity this informs serialization formats which component 
+ * to use when a value is assigned to an entity without specifying the 
+ * component. This is intended as a hint, serialization formats are not required 
+ * to use it. Adding this component does not change the behavior of core ECS 
+ * operations. */
+typedef struct EcsDefaultChildComponent {
+    ecs_id_t component;
+} EcsDefaultChildComponent;
 
 /** @} */
 /** @} */
@@ -1363,9 +1453,6 @@ FLECS_API extern const ecs_id_t ECS_OVERRIDE;
 /** Adds bitset to storage which allows component to be enabled/disabled */
 FLECS_API extern const ecs_id_t ECS_TOGGLE;
 
-/** Include all components from entity to which AND is applied */
-FLECS_API extern const ecs_id_t ECS_AND;
-
 /** @} */
 
 /**
@@ -1376,8 +1463,8 @@ FLECS_API extern const ecs_id_t ECS_AND;
 /* Builtin component ids */
 FLECS_API extern const ecs_entity_t ecs_id(EcsComponent);
 FLECS_API extern const ecs_entity_t ecs_id(EcsIdentifier);
-FLECS_API extern const ecs_entity_t ecs_id(EcsIterable);
 FLECS_API extern const ecs_entity_t ecs_id(EcsPoly);
+FLECS_API extern const ecs_entity_t ecs_id(EcsDefaultChildComponent);
 
 FLECS_API extern const ecs_entity_t EcsQuery;
 FLECS_API extern const ecs_entity_t EcsObserver;
@@ -1427,8 +1514,8 @@ FLECS_API extern const ecs_entity_t EcsTransitive;
 FLECS_API extern const ecs_entity_t EcsReflexive;
 
 /** Ensures that entity/component cannot be used as target in IsA relationship.
- * Final can improve the performance of rule-based queries, as they will not
- * attempt to substitute a final component with its subsets.
+ * Final can improve the performance of queries as they will not attempt to 
+ * substitute a final component with its subsets.
  *
  * Behavior:
  *   if IsA(X, Y) and Final(Y) throw error
@@ -1486,9 +1573,8 @@ FLECS_API extern const ecs_entity_t EcsWith;
  */
 FLECS_API extern const ecs_entity_t EcsOneOf;
 
-/** Can be added to relationship to indicate that it should never hold data,
- * even when it or the relationship target is a component. */
-FLECS_API extern const ecs_entity_t EcsTag;
+/** Mark a component as toggleable with enable_id/disable_id. */
+FLECS_API extern const ecs_entity_t EcsCanToggle;
 
 /** Can be added to components to indicate it is a trait. Traits are components
  * and/or tags that are added to other components to modify their behavior.
@@ -1511,10 +1597,9 @@ FLECS_API extern const ecs_entity_t EcsRelationship;
  */
 FLECS_API extern const ecs_entity_t EcsTarget;
 
-/** Tag to indicate that relationship is stored as union. Union relationships
- * enable changing the target of a union without switching tables. Union
- * relationships are also marked as exclusive. */
-FLECS_API extern const ecs_entity_t EcsUnion;
+/** Can be added to relationship to indicate that it should never hold data, 
+ * even when it or the relationship target is a component. */
+FLECS_API extern const ecs_entity_t EcsPairIsTag;
 
 /** Tag to indicate name identifier */
 FLECS_API extern const ecs_entity_t EcsName;
@@ -1551,6 +1636,11 @@ FLECS_API extern const ecs_entity_t EcsPrefab;
  * EcsDisabled is explicitly queried for. */
 FLECS_API extern const ecs_entity_t EcsDisabled;
 
+/** Trait added to entities that should never be returned by queries. Reserved
+ * for internal entities that have special meaning to the query engine, such as
+ * EcsThis, EcsWildcard, EcsAny. */
+FLECS_API extern const ecs_entity_t EcsNotQueryable;
+
 /** Event that triggers when an id is added to an entity */
 FLECS_API extern const ecs_entity_t EcsOnAdd;
 
@@ -1597,21 +1687,7 @@ FLECS_API extern const ecs_entity_t EcsDelete;
  * EcsOnDeleteTarget. */
 FLECS_API extern const ecs_entity_t EcsPanic;
 
-/** Component that stores data for flattened relationships */
-FLECS_API extern const ecs_entity_t ecs_id(EcsFlattenTarget);
-
-/** Tag added to root entity to indicate its subtree should be flattened. Used
- * together with assemblies. */
-FLECS_API extern const ecs_entity_t EcsFlatten;
-
-/** Used like (EcsDefaultChildComponent, Component). When added to an entity,
- * this informs serialization formats which component to use when a value is
- * assigned to an entity without specifying the component. This is intended as
- * a hint, serialization formats are not required to use it. Adding this
- * component does not change the behavior of core ECS operations. */
-FLECS_API extern const ecs_entity_t EcsDefaultChildComponent;
-
-/* Builtin predicates for comparing entity ids in queries. Only supported by rules */
+/* Builtin predicates for comparing entity ids in queries. Only supported by queries */
 FLECS_API extern const ecs_entity_t EcsPredEq;
 FLECS_API extern const ecs_entity_t EcsPredMatch;
 FLECS_API extern const ecs_entity_t EcsPredLookup;
@@ -1887,7 +1963,7 @@ void ecs_set_target_fps(
  * multithreaded applications the world needs to be entirely immutable. For this
  * purpose multi threaded readonly mode exists, which disallows all mutations on
  * the world. This means that in multi threaded applications, entity liveliness
- * operations, implicit component registration, and on-the-fly filter creation
+ * operations, implicit component registration, and on-the-fly query creation
  * are not guaranteed to work.
  * 
  * While in readonly mode, applications can still enqueue ECS operations on a
@@ -2018,27 +2094,6 @@ FLECS_API
 void ecs_defer_resume(
     ecs_world_t *world);
 
-/** Enable/disable auto-merging for world or stage.
- * When auto-merging is enabled, staged data will automatically be merged with
- * the world when staging ends. This happens at the end of ecs_progress(), at a
- * sync point or when ecs_readonly_end() is called.
- *
- * Applications can exercise more control over when data from a stage is merged
- * by disabling auto-merging. This requires an application to explicitly call
- * ecs_merge() on the stage.
- *
- * When this function is invoked on the world, it sets all current stages to
- * the provided value and sets the default for new stages. When this function is
- * invoked on a stage, auto-merging is only set for that specific stage.
- *
- * @param world The world.
- * @param automerge Whether to enable or disable auto-merging.
- */
-FLECS_API
-void ecs_set_automerge(
-    ecs_world_t *world,
-    bool automerge);
-
 /** Configure world to have N stages.
  * This initializes N stages, which allows applications to defer operations to
  * multiple isolated defer queues. This is typically used for applications with
@@ -2067,17 +2122,6 @@ FLECS_API
 int32_t ecs_get_stage_count(
     const ecs_world_t *world);
 
-/** Get current stage id.
- * The stage id can be used by an application to learn about which stage it is
- * using, which typically corresponds with the worker thread id.
- *
- * @param world The world.
- * @return The stage id.
- */
-FLECS_API
-int32_t ecs_get_stage_id(
-    const ecs_world_t *world);
-
 /** Get stage-specific world pointer.
  * Flecs threads can safely invoke the API as long as they have a private
  * context to write to, also referred to as the stage. This function returns a
@@ -2109,47 +2153,35 @@ FLECS_API
 bool ecs_stage_is_readonly(
     const ecs_world_t *world);
 
-/** Create asynchronous stage.
- * An asynchronous stage can be used to asynchronously queue operations for
- * later merging with the world. An asynchronous stage is similar to a regular
- * stage, except that it does not allow reading from the world.
- *
- * Asynchronous stages are never merged automatically, and must therefore be
- * manually merged with the ecs_merge() function. It is not necessary to call
- * ecs_defer_begin() or ecs_defer_end() before and after enqueuing commands, as an
- * asynchronous stage unconditionally defers operations.
- *
- * The application must ensure that no commands are added to the stage while the
- * stage is being merged.
- *
- * An asynchronous stage must be cleaned up by ecs_async_stage_free().
+/** Create unmanaged stage.
+ * Create a stage who's lifecycle is not managed by the world. Must be freed
+ * with ecs_stage_free.
  *
  * @param world The world.
  * @return The stage.
  */
 FLECS_API
-ecs_world_t* ecs_async_stage_new(
+ecs_world_t* ecs_stage_new(
     ecs_world_t *world);
 
-/** Free asynchronous stage.
- * The provided stage must be an asynchronous stage. If a non-asynchronous stage
- * is provided, the operation will fail.
+/** Free unmanaged stage.
  *
  * @param stage The stage to free.
  */
 FLECS_API
-void ecs_async_stage_free(
+void ecs_stage_free(
     ecs_world_t *stage);
 
-/** Test whether provided stage is asynchronous.
+/** Get stage id.
+ * The stage id can be used by an application to learn about which stage it is
+ * using, which typically corresponds with the worker thread id.
  *
- * @param stage The stage.
- * @return True when the stage is asynchronous, false for a regular stage or
- *         world.
+ * @param world The world.
+ * @return The stage id.
  */
 FLECS_API
-bool ecs_stage_is_async(
-    ecs_world_t *stage);
+int32_t ecs_stage_get_id(
+    const ecs_world_t *world);
 
 /** @} */
 
@@ -2236,7 +2268,7 @@ void ecs_dim(
     int32_t entity_count);
 
 /** Set a range for issuing new entity ids.
- * This function constrains the entity identifiers returned by ecs_new() to the
+ * This function constrains the entity identifiers returned by ecs_new_w() to the
  * specified range. This operation can be used to ensure that multiple processes
  * can run in the same simulation without requiring a central service that
  * coordinates issuing identifiers.
@@ -2346,7 +2378,7 @@ int32_t ecs_delete_empty_tables(
  */
 FLECS_API
 const ecs_world_t* ecs_get_world(
-    const ecs_poly_t *poly);
+    const flecs_poly_t *poly);
 
 /** Get entity from poly.
  *
@@ -2355,13 +2387,13 @@ const ecs_world_t* ecs_get_world(
  */
 FLECS_API
 ecs_entity_t ecs_get_entity(
-    const ecs_poly_t *poly);
+    const flecs_poly_t *poly);
 
 /** Test if pointer is of specified type.
  * Usage:
  *
  * @code
- * ecs_poly_is(ptr, ecs_world_t)
+ * flecs_poly_is(ptr, ecs_world_t)
  * @endcode
  *
  * This operation only works for poly types.
@@ -2371,12 +2403,12 @@ ecs_entity_t ecs_get_entity(
  * @return True if the pointer is of the specified type.
  */
 FLECS_API
-bool ecs_poly_is_(
-    const ecs_poly_t *object,
+bool flecs_poly_is_(
+    const flecs_poly_t *object,
     int32_t type);
 
-#define ecs_poly_is(object, type)\
-    ecs_poly_is_(object, type##_magic)
+#define flecs_poly_is(object, type)\
+    flecs_poly_is_(object, type##_magic)
 
 /** Make a pair id.
  * This function is equivalent to using the ecs_pair() macro, and is added for
@@ -2417,7 +2449,7 @@ ecs_id_t ecs_make_pair(
  * @return The new entity id.
  */
 FLECS_API
-ecs_entity_t ecs_new_id(
+ecs_entity_t ecs_new(
     ecs_world_t *world);
 
 /** Create new low id.
@@ -2999,23 +3031,30 @@ bool ecs_record_has_id(
     ecs_id_t id);
 
 /** Emplace a component.
- * Emplace is similar to ecs_ensure_id() except that the component constructor is not
- * invoked for the returned pointer, allowing the component to be "constructed"
- * directly in the storage.
- *
- * Emplace can only be used if the entity does not yet have the component. If
- * the entity has the component, the operation will fail.
+ * Emplace is similar to ecs_ensure_id() except that the component constructor
+ * is not invoked for the returned pointer, allowing the component to be 
+ * constructed directly in the storage.
+ * 
+ * When the is_new parameter is not provided, the operation will assert when the
+ * component already exists. When the is_new parameter is provided, it will
+ * indicate whether the returned storage has been constructed.
+ * 
+ * When is_new indicates that the storage has not yet been constructed, it must
+ * be constructed by the code invoking this operation. Not constructing the
+ * component will result in undefined behavior.
  *
  * @param world The world.
  * @param entity The entity.
  * @param id The component to obtain.
+ * @param is_new Whether this is an existing or new component.
  * @return The (uninitialized) component pointer.
  */
 FLECS_API
 void* ecs_emplace_id(
     ecs_world_t *world,
     ecs_entity_t entity,
-    ecs_id_t id);
+    ecs_id_t id,
+    bool *is_new);
 
 /** Signal that a component has been modified.
  * This operation is usually used after modifying a component value obtained by
@@ -3046,10 +3085,9 @@ void ecs_modified_id(
  * @param id The id of the component to set.
  * @param size The size of the pointed-to value.
  * @param ptr The pointer to the value.
- * @return The entity. A new entity if no entity was provided.
  */
 FLECS_API
-ecs_entity_t ecs_set_id(
+void ecs_set_id(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_id_t id,
@@ -3072,7 +3110,7 @@ ecs_entity_t ecs_set_id(
  * An entity is valid if it is not 0 and if it is alive.
  *
  * ecs_is_valid() will return true for ids that don't exist (alive or not alive). This
- * allows for using ids that have never been created by ecs_new() or similar. In
+ * allows for using ids that have never been created by ecs_new_w() or similar. In
  * this the function differs from ecs_is_alive(), which will return false for
  * entities that do not yet exist.
  *
@@ -3090,7 +3128,7 @@ bool ecs_is_valid(
 
 /** Test whether an entity is alive.
  * Entities are alive after they are created, and become not alive when they are
- * deleted. Operations that return alive ids are (amongst others) ecs_new_id(),
+ * deleted. Operations that return alive ids are (amongst others) ecs_new(),
  * ecs_new_low_id() and ecs_entity_init(). Ids can be made alive with the ecs_make_alive()
  * function.
  *
@@ -3099,12 +3137,12 @@ bool ecs_is_valid(
  * possible for the API to distinguish between the two. An example:
  *
  * @code
- * ecs_entity_t e1 = ecs_new_id(world);
+ * ecs_entity_t e1 = ecs_new(world);
  * ecs_is_alive(world, e1);             // true
  * ecs_delete(world, e1);
  * ecs_is_alive(world, e1);             // false
  *
- * ecs_entity_t e2 = ecs_new_id(world); // recycles e1
+ * ecs_entity_t e2 = ecs_new(world); // recycles e1
  * ecs_is_alive(world, e2);             // true
  * ecs_is_alive(world, e1);             // false
  * @endcode
@@ -3127,22 +3165,6 @@ FLECS_API
 ecs_id_t ecs_strip_generation(
     ecs_entity_t e);
 
-/** Override the generation of an entity.
- * The generation count of an entity is increased each time an entity is deleted
- * and is used to test whether an entity id is alive.
- *
- * This operation overrides the current generation of an entity with the
- * specified generation, which can be useful if an entity is externally managed,
- * like for external pools, savefiles or netcode.
- *
- * @param world The world.
- * @param entity Entity for which to set the generation with the new generation.
- */
-FLECS_API
-void ecs_set_entity_generation(
-    ecs_world_t *world,
-    ecs_entity_t entity);
-
 /** Get alive identifier.
  * In some cases an application may need to work with identifiers from which
  * the generation has been stripped. A typical scenario in which this happens is
@@ -3167,7 +3189,7 @@ ecs_entity_t ecs_get_alive(
 /** Ensure id is alive.
  * This operation ensures that the provided id is alive. This is useful in
  * scenarios where an application has an existing id that has not been created
- * with ecs_new() (such as a global constant or an id from a remote application).
+ * with ecs_new_w() (such as a global constant or an id from a remote application).
  *
  * When this operation is successful it guarantees that the provided id exists,
  * is valid and is alive.
@@ -3224,6 +3246,25 @@ bool ecs_exists(
     const ecs_world_t *world,
     ecs_entity_t entity);
 
+/** Override the generation of an entity.
+ * The generation count of an entity is increased each time an entity is deleted
+ * and is used to test whether an entity id is alive.
+ *
+ * This operation overrides the current generation of an entity with the
+ * specified generation, which can be useful if an entity is externally managed,
+ * like for external pools, savefiles or netcode.
+ * 
+ * This operation is similar to ecs_make_alive, except that it will also
+ * override the generation of an alive entity.
+ *
+ * @param world The world.
+ * @param entity Entity for which to set the generation with the new generation.
+ */
+FLECS_API
+void ecs_set_generation(
+    ecs_world_t *world,
+    ecs_entity_t entity);
+
 /** @} */
 
 /**
@@ -3406,48 +3447,6 @@ int32_t ecs_get_depth(
     ecs_entity_t entity,
     ecs_entity_t rel);
 
-typedef struct ecs_flatten_desc_t {
-    /* When true, the flatten operation will not remove names from entities in
-     * the flattened tree. This may fail if entities from different subtrees
-     * have the same name. */
-    bool keep_names;
-
-    /* When true, the flattened tree won't contain information about the
-     * original depth of the entities. This can reduce fragmentation, but may
-     * cause existing code, such as cascade queries, to no longer work. */
-    bool lose_depth;
-} ecs_flatten_desc_t;
-
-/** Recursively flatten relationship for target entity (experimental).
- * This operation combines entities in the subtree of the specified pair from
- * different parents in the same table. This can reduce memory fragmentation
- * and reduces the number of tables in the storage, which improves RAM
- * utilization and various other operations, such as entity cleanup.
- *
- * The lifecycle of entities in a fixed subtree are bound to the specified
- * parent. Entities in a fixed subtree cannot be deleted individually. Entities
- * can also not change the target of the fixed relationship, which includes
- * removing the relationship.
- *
- * Entities in a fixed subtree are still fragmented on subtree depth. This
- * ensures that entities can still be iterated in breadth-first order with the
- * cascade query modifier.
- *
- * The current implementation is limited to exclusive acyclic relationships, and
- * does not allow for adding/removing to entities in flattened tables. An entity
- * may only be flattened for a single relationship. Future iterations of the
- * feature may remove these limitations.
- *
- * @param world The world.
- * @param pair The relationship pair from which to start flattening.
- * @param desc Options for flattening the tree.
- */
-FLECS_API
-void ecs_flatten(
-    ecs_world_t *world,
-    ecs_id_t pair,
-    const ecs_flatten_desc_t *desc);
-
 /** Count entities that have the specified id.
  * Returns the number of entities that have the specified id.
  *
@@ -3882,7 +3881,7 @@ const ecs_type_hooks_t* ecs_get_hooks_id(
  * - it is an entity without the EcsComponent component
  * - it has an EcsComponent with size member set to 0
  * - it is a pair where both elements are a tag
- * - it is a pair where the first element has the EcsTag tag
+ * - it is a pair where the first element has the EcsPairIsTag tag
  *
  * @param world The world.
  * @param id The id.
@@ -3893,23 +3892,6 @@ bool ecs_id_is_tag(
     const ecs_world_t *world,
     ecs_id_t id);
 
-/** Return whether represents a union.
- * This operation returns whether the specified type represents a union. Only
- * pair ids can be unions.
- *
- * An id represents a union when:
- * - The first element of the pair is EcsUnion/flecs::Union
- * - The first element of the pair has EcsUnion/flecs::Union
- *
- * @param world The world.
- * @param id The id.
- * @return Whether the provided id represents a union.
- */
-FLECS_API
-bool ecs_id_is_union(
-    const ecs_world_t *world,
-    ecs_id_t id);
-
 /** Returns whether specified id is in use.
  * This operation returns whether an id is in use in the world. An id is in use
  * if it has been added to one or more tables.
@@ -3932,7 +3914,7 @@ bool ecs_id_in_use(
  * EcsComponent value with size 0, the operation will return 0.
  *
  * For a pair id the operation will return the type associated with the pair, by
- * applying the following rules in order:
+ * applying the following querys in order:
  * - The first pair element is returned if it is a component
  * - 0 is returned if the relationship entity has the Tag property
  * - The second pair element is returned if it is a component
@@ -4046,83 +4028,19 @@ void ecs_id_str_buf(
 /** @} */
 
 /**
- * @defgroup filters Filters
- * Functions for working with `ecs_term_t` and `ecs_filter_t`.
- *
+ * @defgroup queries Queries
+ * @brief Functions for working with `ecs_term_t` and `ecs_query_t`.
  * @{
  */
 
-/** Iterator for a single (component) id.
- * A term iterator returns all entities (tables) that match a single (component)
- * id. The search for the matching set of entities (tables) is performed in
- * constant time.
- *
- * @param world The world.
- * @param term The term.
- * @return The iterator.
- */
-FLECS_API
-ecs_iter_t ecs_term_iter(
-    const ecs_world_t *world,
-    ecs_term_t *term);
-
-/** Return a chained term iterator.
- * A chained iterator applies a filter to the results of the input iterator. The
- * resulting iterator must be iterated with ecs_term_next().
- *
- * @param it The input iterator
- * @param term The term filter to apply to the iterator.
- * @return The chained iterator.
- */
-FLECS_API
-ecs_iter_t ecs_term_chain_iter(
-    const ecs_iter_t *it,
-    ecs_term_t *term);
-
-/** Progress a term iterator.
- * This operation progresses the term iterator to the next table. The
- * iterator must have been initialized with ecs_term_iter(). This operation
- * must be invoked at least once before interpreting the contents of the
- * iterator.
- *
- * @param it The iterator.
- * @returns True if more data is available, false if not.
- */
-FLECS_API
-bool ecs_term_next(
-    ecs_iter_t *it);
-
-/** Iterator for a parent's children.
- * This operation is equivalent to a term iterator for (ChildOf, parent).
- * Iterate the result with ecs_children_next().
- *
- * @param world The world.
- * @param parent The parent for which to iterate the children.
- * @return The iterator.
- */
-FLECS_API
-ecs_iter_t ecs_children(
-    const ecs_world_t *world,
-    ecs_entity_t parent);
-
-/** Progress a children iterator.
- * Equivalent to ecs_term_next().
- *
- * @param it The iterator.
- * @returns True if more data is available, false if not.
- */
-FLECS_API
-bool ecs_children_next(
-    ecs_iter_t *it);
-
 /** Test whether term id is set.
  *
  * @param id The term id.
  * @return True when set, false when not set.
  */
-FLECS_API
-bool ecs_term_id_is_set(
-    const ecs_term_id_t *id);
+FLECS_API 
+bool ecs_term_ref_is_set(
+    const ecs_term_ref_t *id);
 
 /** Test whether a term is set.
  * This operation can be used to test whether a term has been initialized with
@@ -4173,139 +4091,6 @@ FLECS_API
 bool ecs_term_match_0(
     const ecs_term_t *term);
 
-/** Finalize term.
- * Ensure that all fields of a term are consistent and filled out. This
- * operation should be invoked before using and after assigning members to, or
- * parsing a term. When a term contains unresolved identifiers, this operation
- * will resolve and assign the identifiers. If the term contains any identifiers
- * that cannot be resolved, the operation will fail.
- *
- * An application generally does not need to invoke this operation as the APIs
- * that use terms (such as filters, queries and triggers) will finalize terms
- * when they are created.
- *
- * The name and expr parameters are optional, and only used for giving more
- * descriptive error messages.
- *
- * @param world The world.
- * @param term The term to finalize.
- * @return Zero if success, nonzero if an error occurred.
- */
-FLECS_API
-int ecs_term_finalize(
-    const ecs_world_t *world,
-    ecs_term_t *term);
-
-/** Copy resources of a term to another term.
- * This operation copies one term to another term. If the source term contains
- * allocated resources (such as identifiers), they will be duplicated so that
- * no memory is shared between the terms.
- *
- * @param src The term to copy from.
- * @return The destination term.
- */
-FLECS_API
-ecs_term_t ecs_term_copy(
-    const ecs_term_t *src);
-
-/** Move resources of a term to another term.
- * Same as copy, but moves resources from src, if src->move is set to true. If
- * src->move is not set to true, this operation will do a copy.
- *
- * The conditional move reduces redundant allocations in scenarios where a list
- * of terms is partially created with allocated resources.
- *
- * @param src The term to move from.
- * @return The destination term.
- */
-FLECS_API
-ecs_term_t ecs_term_move(
-    ecs_term_t *src);
-
-/** Free resources of term.
- * This operation frees all resources (such as identifiers) of a term. The term
- * itself is not freed.
- *
- * @param term The term to free.
- */
-FLECS_API
-void ecs_term_fini(
-    ecs_term_t *term);
-
-/** Initialize filter
- * A filter is a lightweight object that can be used to query for entities in
- * a world. Filters, as opposed to queries, do not cache results. They are
- * therefore slower to iterate, but are faster to create.
- *
- * When a filter is copied by value, make sure to use ecs_filter_move() to
- * ensure that the terms pointer still points to the inline array:
- *
- * @code
- * ecs_filter_move(&dst_filter, &src_filter)
- * @endcode
- *
- * Alternatively, the ecs_filter_move() function can be called with both arguments
- * set to the same filter, to ensure the pointer is valid:
- *
- * @code
- * ecs_filter_move(&f, &f)
- * @endcode
- *
- * It is possible to create a filter without allocating any memory, by setting
- * the .storage member in ecs_filter_desc_t. See the documentation for the
- * member for more details.
- *
- * @param world The world.
- * @param desc Properties for the filter to create.
- * @return The filter if successful, NULL if not successful.
- */
-FLECS_API
-ecs_filter_t * ecs_filter_init(
-    ecs_world_t *world,
-    const ecs_filter_desc_t *desc);
-
-/** Deinitialize filter.
- * Free resources associated with filter.
- *
- * @param filter The filter to deinitialize.
- */
-FLECS_API
-void ecs_filter_fini(
-    ecs_filter_t *filter);
-
-/** Finalize filter.
- * When manually assigning an array of terms to the filter struct (so not when
- * using ecs_filter_init()), this operation should be used to ensure that all
- * terms are assigned properly and all (derived) fields have been set.
- *
- * When ecs_filter_init() is used to create the filter, this function should not
- * be called. The purpose of this operation is to support creation of filters
- * without allocating memory.
- *
- * @param filter The filter to finalize.
- * @return Zero if filter is valid, non-zero if it contains errors.
- * @
- */
-FLECS_API
-int ecs_filter_finalize(
-    const ecs_world_t *world,
-    ecs_filter_t *filter);
-
-/** Find index for $this variable.
- * This operation looks up the index of the $this variable. This index can
- * be used in operations like ecs_iter_set_var() and ecs_iter_get_var().
- *
- * The operation will return -1 if the variable was not found. This happens when
- * a filter only has terms that are not matched on the $this variable, like a
- * filter that exclusively matches singleton components.
- *
- * @param filter The rule.
- * @return The index of the $this variable.
- */
-FLECS_API
-int32_t ecs_filter_find_this_var(
-    const ecs_filter_t *filter);
-
 /** Convert term to string expression.
  * Convert term to a string expression. The resulting expression is equivalent
  * to the same term, with the exception of And & Or operators.
@@ -4319,111 +4104,42 @@ char* ecs_term_str(
     const ecs_world_t *world,
     const ecs_term_t *term);
 
-/** Convert filter to string expression.
- * Convert filter terms to a string expression. The resulting expression can be
- * parsed to create the same filter.
- *
- * @param world The world.
- * @param filter The filter.
- * @return The filter converted to a string.
+/** Convert query to string expression.
+ * Convert query to a string expression. The resulting expression can be
+ * parsed to create the same query.
+ * 
+ * @param query The query.
+ * @return The query converted to a string.
  */
-FLECS_API
-char* ecs_filter_str(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter);
+FLECS_API 
+char* ecs_query_str(
+    const ecs_query_t *query); 
 
-/** Return a filter iterator.
- * A filter iterator lets an application iterate over entities that match the
- * specified filter.
- *
- * @param world The world.
- * @param filter The filter.
- * @return An iterator that can be used with ecs_filter_next().
- */
-FLECS_API
-ecs_iter_t ecs_filter_iter(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter);
+/** @} */
 
-/** Return a chained filter iterator.
- * A chained iterator applies a filter to the results of the input iterator. The
- * resulting iterator must be iterated with ecs_filter_next().
- *
- * @param it The input iterator
- * @param filter The filter to apply to the iterator.
- * @return The chained iterator.
+/**
+ * @defgroup each_iter Each iterator
+ * @brief Find all entities that have a single (component) id.
+ * @{
  */
-FLECS_API
-ecs_iter_t ecs_filter_chain_iter(
-    const ecs_iter_t *it,
-    const ecs_filter_t *filter);
 
-/** Get pivot term for filter.
- * The pivot term is the term that matches the smallest set of tables, and is
- * a good default starting point for a search.
- *
- * The following conditions must be met for a term to be considered as pivot:
- * - It must have a This subject
- * - It must have the And operator
- *
- * When a filter does not have any terms that match those conditions, it will
- * return -1.
- *
- * If one or more terms in the filter have no matching tables the filter won't
- * yield any results. In this case the operation will return -2 which gives a
- * search function the option to early out.
- *
- * @param world The world.
- * @param filter The filter.
- * @return Index of the pivot term (use with filter->terms)
- */
 FLECS_API
-int32_t ecs_filter_pivot_term(
+ecs_iter_t ecs_each_id(
     const ecs_world_t *world,
-    const ecs_filter_t *filter);
+    ecs_id_t id);
 
-/** Iterate tables matched by filter.
- * This operation progresses the filter iterator to the next table. The
- * iterator must have been initialized with ecs_filter_iter(). This operation
- * must be invoked at least once before interpreting the contents of the
- * iterator.
- *
- * @param it The iterator
- * @return True if more data is available, false if not.
- */
 FLECS_API
-bool ecs_filter_next(
+bool ecs_each_next(
     ecs_iter_t *it);
 
-/** Same as ecs_filter_next, but always instanced.
- * See instanced property of ecs_filter_desc_t.
- *
- * @param it The iterator
- * @return True if more data is available, false if not.
- */
 FLECS_API
-bool ecs_filter_next_instanced(
-    ecs_iter_t *it);
-
-/** Move resources of one filter to another.
- *
- * @param dst The destination filter.
- * @param src The source filter.
- */
-FLECS_API
-void ecs_filter_move(
-    ecs_filter_t *dst,
-    ecs_filter_t *src);
+ecs_iter_t ecs_children(
+    const ecs_world_t *world,
+    ecs_entity_t parent);
 
-/** Copy resources of one filter to another.
- *
- * @param dst The destination filter.
- * @param src The source filter.
- */
 FLECS_API
-void ecs_filter_copy(
-    ecs_filter_t *dst,
-    const ecs_filter_t *src);
+bool ecs_children_next(
+    ecs_iter_t *it);
 
 /** @} */
 
@@ -4435,48 +4151,17 @@ void ecs_filter_copy(
  */
 
 /** Create a query.
- * This operation creates a query. Queries are used to iterate over entities
- * that match a filter and are the fastest way to find and iterate over entities
- * and their components.
- *
- * Queries should be created once, and reused multiple times. While iterating a
- * query is a cheap operation, creating and deleting a query is expensive. The
- * reason for this is that queries are "pre-matched", which means that a query
- * stores state about which entities (or rather, tables) match with the query.
- * Building up this state happens during query creation.
- *
- * Once a query is created, matching only happens when new tables are created.
- * In most applications this is an infrequent process, since it only occurs when
- * a new combination of components is introduced. While matching is expensive,
- * it is important to note that matching does not happen on a per-entity basis,
- * but on a per-table basis. This means that the average time spent on matching
- * per frame should rapidly approach zero over the lifetime of an application.
- *
- * A query provides direct access to the component arrays. When an application
- * creates/deletes entities or adds/removes components, these arrays can shift
- * component values around, or may grow in size. This can cause unexpected or
- * undefined behavior to occur if these operations are performed while
- * iterating. To prevent this from happening an application should either not
- * perform these operations while iterating, or use deferred operations (see
- * ecs_defer_begin() and ecs_defer_end()).
- *
- * Queries can be created and deleted dynamically. If a query was not deleted
- * (using ecs_query_fini()) before the world is deleted, it will be deleted
- * automatically.
- *
+ * 
  * @param world The world.
- * @param desc A structure describing the query properties.
- * @return The new query.
+ * @param desc The descriptor (see ecs_query_desc_t)
+ * @return The query.
  */
 FLECS_API
 ecs_query_t* ecs_query_init(
     ecs_world_t *world,
     const ecs_query_desc_t *desc);
 
-/** Destroy a query.
- * This operation destroys a query and its resources. If the query is used as
- * the parent of subqueries, those subqueries will be orphaned and must be
- * deinitialized as well.
+/** Delete a query.
  *
  * @param query The query.
  */
@@ -4484,111 +4169,158 @@ FLECS_API
 void ecs_query_fini(
     ecs_query_t *query);
 
-/** Get filter from a query.
- * This operation obtains a pointer to the internally constructed filter
- * of the query and can be used to introspect the query terms.
+/** Return number of variables in query.
  *
  * @param query The query.
- * @return The filter.
+ * @return The number of variables/
  */
 FLECS_API
-const ecs_filter_t* ecs_query_get_filter(
+int32_t ecs_query_var_count(
     const ecs_query_t *query);
 
-/** Return a query iterator.
- * A query iterator lets an application iterate over entities that match the
- * specified query. If a sorting function is specified, the query will check
- * whether a resort is required upon creating the iterator.
- *
- * Creating a query iterator is a cheap operation that does not allocate any
- * resources. An application does not need to deinitialize or free a query
- * iterator before it goes out of scope.
+/** Find variable index.
+ * This operation looks up the index of a variable in the query. This index can
+ * be used in operations like ecs_iter_set_var() and ecs_iter_get_var().
  *
- * To iterate the iterator, an application should use ecs_query_next() to progress
- * the iterator and test if it has data.
+ * @param query The query.
+ * @param name The variable name.
+ * @return The variable index.
+ */
+FLECS_API
+int32_t ecs_query_find_var(
+    const ecs_query_t *query,
+    const char *name);    
+
+/** Get variable name.
+ * This operation returns the variable name for an index.
  *
- * Query iteration requires an outer and an inner loop. The outer loop uses
- * ecs_query_next() to test if new tables are available. The inner loop iterates
- * the entities in the table, and is usually a for loop that uses iter.count to
- * loop through the entities and component arrays.
+ * @param query The query.
+ * @param var_id The variable index.
+ */
+FLECS_API
+const char* ecs_query_var_name(
+    const ecs_query_t *query,
+    int32_t var_id);
+
+/** Test if variable is an entity.
+ * Internally the query engine has entity variables and table variables. When
+ * iterating through query variables (by using ecs_query_variable_count) only
+ * the values for entity variables are accessible. This operation enables an
+ * application to check if a variable is an entity variable.
  *
- * The two loops are necessary because of how data is stored internally.
- * Entities are grouped by the components they have, in tables. A single query
- * can (and often does) match with multiple tables. Because each table has its
- * own set of arrays, an application has to reobtain pointers to those arrays
- * for each matching table.
+ * @param query The query.
+ * @param var_id The variable id.
+ */
+FLECS_API
+bool ecs_query_var_is_entity(
+    const ecs_query_t *query,
+    int32_t var_id);  
+
+/** Iterate a query.
+ * Note that query iterators may allocate memory, and that unless the iterator
+ * is iterated until completion, it may still hold resources. When stopping
+ * iteration before ecs_query_next has returned false, use ecs_iter_fini to
+ * cleanup any remaining resources.
  *
- * @param world The world or stage, when iterating in readonly mode.
- * @param query The query to iterate.
- * @return The query iterator.
+ * @param world The world.
+ * @param query The query.
+ * @return An iterator.
  */
 FLECS_API
 ecs_iter_t ecs_query_iter(
     const ecs_world_t *world,
-    ecs_query_t *query);
+    const ecs_query_t *query);
 
-/** Progress the query iterator.
- * This operation progresses the query iterator to the next table. The
- * iterator must have been initialized with ecs_query_iter(). This operation
- * must be invoked at least once before interpreting the contents of the
- * iterator.
+/** Progress query iterator.
  *
- * @param iter The iterator.
- * @returns True if more data is available, false if not.
+ * @param it The iterator.
  */
 FLECS_API
 bool ecs_query_next(
-    ecs_iter_t *iter);
+    ecs_iter_t *it);
 
-/** Same as ecs_query_next, but always instanced.
- * See "instanced" property of ecs_filter_desc_t.
+/** Progress instanced iterator.
+ * Should not be called unless you know what you're doing :-)
  *
- * @param iter The iterator.
- * @returns True if more data is available, false if not.
+ * @param it The iterator.
  */
 FLECS_API
 bool ecs_query_next_instanced(
-    ecs_iter_t *iter);
+    ecs_iter_t *it);
 
-/** Fast alternative to ecs_query_next() that only returns matched tables.
- * This operation only populates the ecs_iter_t::table field. To access the
- * matched components, call ecs_query_populate().
- *
- * If this operation is used with a query that has inout/out terms, those terms
- * will not be marked dirty unless ecs_query_populate() is called.
- *
- * @param iter The iterator.
- * @returns True if more data is available, false if not.
+/** Returns true if query matches with entity. */
+FLECS_API
+bool ecs_query_has(
+    ecs_query_t *query,
+    ecs_entity_t entity,
+    ecs_iter_t *it);
+
+/** Returns true if query matches with table. */
+FLECS_API
+bool ecs_query_has_table(
+    ecs_query_t *query,
+    ecs_table_t *table,
+    ecs_iter_t *it);
+
+/** Returns true if query matches with table. */
+FLECS_API
+bool ecs_query_has_range(
+    ecs_query_t *query,
+    ecs_table_range_t *range,
+    ecs_iter_t *it);
+
+/** Returns how often a match event happened for a cached query. 
+ * This operation can be used to determine whether the query cache has been 
+ * updated with new tables.
  */
 FLECS_API
-bool ecs_query_next_table(
-    ecs_iter_t *iter);
+int32_t ecs_query_match_count(
+    const ecs_query_t *query);
 
-/** Populate iterator fields.
- * This operation can be combined with ecs_query_next_table() to populate the
- * iterator fields for the current table.
+/** Convert query to a string.
+ * This will convert the query program to a string which can aid in debugging
+ * the behavior of a query.
  *
- * Populating fields conditionally can save time when a query uses change
- * detection, and only needs iterator data when the table has changed. When this
- * operation is called, inout/out terms will be marked dirty.
+ * The returned string must be freed with ecs_os_free().
  *
- * In cases where inout/out terms are conditionally written and no changes
- * were made after calling ecs_query_populate(), the ecs_query_skip() function can
- * be called to prevent the matched table components from being marked dirty.
+ * @param query The query.
+ * @return The string
+ */
+FLECS_API
+char* ecs_query_plan(
+    const ecs_query_t *query);
+
+/** Convert query to string with profile.
+ * To use this you must set the EcsIterProfile flag on an iterator before
+ * starting iteration:
+ *   it.flags |= EcsIterProfile
  *
- * This operation does should not be used with queries that match disabled
- * components, union relationships, or with queries that use order_by.
+ * @param query The query.
+ * @return The string
+ */
+FLECS_API
+char* ecs_query_str_w_profile(
+    const ecs_query_t *query,
+    const ecs_iter_t *it);
+
+/** Populate variables from key-value string.
+ * Convenience function to set query variables from a key-value string separated
+ * by comma's. The string must have the following format:
+ *   var_a: value, var_b: value
  *
- * When the when_changed argument is set to true, the iterator data will only
- * populate when the data has changed, using query change detection.
+ * The key-value list may optionally be enclosed in parenthesis.
+ * 
+ * This function uses the script addon.
  *
- * @param iter The iterator.
- * @param when_changed Only populate data when result has changed.
+ * @param query The query.
+ * @param it The iterator for which to set the variables.
+ * @param expr The key-value expression.
  */
 FLECS_API
-int ecs_query_populate(
-    ecs_iter_t *iter,
-    bool when_changed);
+const char* ecs_query_args_parse(
+    ecs_query_t *query,
+    ecs_iter_t *it,
+    const char *expr);
 
 /** Returns whether the query data changed since the last iteration.
  * The operation will return true after:
@@ -4616,13 +4348,11 @@ int ecs_query_populate(
  * - The iterator must be instanced
  *
  * @param query The query (optional if 'it' is provided).
- * @param it The iterator result to test (optional if 'query' is provided).
  * @return true if entities changed, otherwise false.
  */
 FLECS_API
 bool ecs_query_changed(
-    ecs_query_t *query,
-    const ecs_iter_t *it);
+    ecs_query_t *query);
 
 /** Skip a table while iterating.
  * This operation lets the query iterator know that a table was skipped while
@@ -4635,7 +4365,7 @@ bool ecs_query_changed(
  * @param it The iterator result to skip.
  */
 FLECS_API
-void ecs_query_skip(
+void ecs_iter_skip(
     ecs_iter_t *it);
 
 /** Set group to iterate for query iterator.
@@ -4655,13 +4385,13 @@ void ecs_query_skip(
  *
  * The group to iterate must be set before the first call to ecs_query_next(). No
  * operations that can add/remove components should be invoked between calling
- * ecs_query_set_group() and ecs_query_next().
+ * ecs_iter_set_group() and ecs_query_next().
  *
  * @param it The query iterator.
  * @param group_id The group to iterate.
  */
 FLECS_API
-void ecs_query_set_group(
+void ecs_iter_set_group(
     ecs_iter_t *it,
     uint64_t group_id);
 
@@ -4691,74 +4421,31 @@ const ecs_query_group_info_t* ecs_query_get_group_info(
     const ecs_query_t *query,
     uint64_t group_id);
 
-/** Returns whether query is orphaned.
- * When the parent query of a subquery is deleted, it is left in an orphaned
- * state. The only valid operation on an orphaned query is deleting it. Only
- * subqueries can be orphaned.
- *
- * @param query The query.
- * @return true if query is orphaned, otherwise false.
- */
-FLECS_API
-bool ecs_query_orphaned(
-    const ecs_query_t *query);
-
-/** Convert query to string.
- *
- * @param query The query.
- * @return The query string.
- */
-FLECS_API
-char* ecs_query_str(
-    const ecs_query_t *query);
-
-/** Returns number of tables query matched with.
- *
- * @param query The query.
- * @return The number of matched tables.
- */
-FLECS_API
-int32_t ecs_query_table_count(
-    const ecs_query_t *query);
-
-/** Returns number of empty tables query matched with.
- *
- * @param query The query.
- * @return The number of matched empty tables.
- */
-FLECS_API
-int32_t ecs_query_empty_table_count(
-    const ecs_query_t *query);
+/** Struct returned by ecs_query_count. */
+typedef struct ecs_query_count_t {
+    int32_t results;
+    int32_t entities;
+    int32_t tables;
+    int32_t empty_tables;
+} ecs_query_count_t;
 
-/** Returns number of entities query matched with.
- * This operation iterates all non-empty tables in the query cache to find the
- * total number of entities.
+/** Returns number of entities and results the query matches with.
+ * Only entities matching the $this variable as source are counted.
  *
  * @param query The query.
  * @return The number of matched entities.
  */
 FLECS_API
-int32_t ecs_query_entity_count(
+ecs_query_count_t ecs_query_count(
     const ecs_query_t *query);
 
-/** Get query ctx.
- * Return the value set in ecs_query_desc_t::ctx.
- *
- * @param query The query.
- * @return The context.
- */
-FLECS_API
-void* ecs_query_get_ctx(
-    const ecs_query_t *query);
-
-/** Get query binding ctx.
- * Return the value set in ecs_query_desc_t::binding_ctx.
- *
+/** Does query return one or more results. 
+ * 
  * @param query The query.
- * @return The context.
+ * @return True if query matches anything, false if not.
  */
 FLECS_API
-void* ecs_query_get_binding_ctx(
+bool ecs_query_is_true(
     const ecs_query_t *query);
 
 /** @} */
@@ -4814,7 +4501,7 @@ ecs_entity_t ecs_observer_init(
 /** Default run action for observer.
  * This function can be called from a custom observer run action (see
  * ecs_observer_desc_t::run for more details). This function ensures that the
- * observer's filter is applied to the iterator's table, filters out duplicate
+ * observer's query is applied to the iterator's table, filters out duplicate
  * events and implements EcsMonitor logic.
  *
  * @param it The iterator.
@@ -4856,7 +4543,7 @@ void* ecs_observer_get_binding_ctx(
  * @return The observer query.
  */
 FLECS_API
-const ecs_filter_t* ecs_observer_get_filter(
+const ecs_query_t* ecs_observer_get_query(
     const ecs_world_t *world,
     ecs_entity_t observer);
 
@@ -4869,34 +4556,6 @@ const ecs_filter_t* ecs_observer_get_filter(
  * @{
  */
 
-/** Create iterator from poly object.
- * The provided poly object must have the iterable mixin. If an object is
- * provided that does not have the mixin, the function will assert.
- *
- * When a filter is provided, an array of two iterators must be passed to the
- * function. This allows the mixin implementation to create a chained iterator
- * when necessary, which requires two iterator objects.
- *
- * If a filter is provided, the first element in the array of two iterators is
- * the one that should be iterated. The mixin implementation may or may not set
- * the second element, depending on whether an iterator chain is required.
- *
- * Additionally, when a filter is provided the returned iterator will be for a
- * single term with the provided filter id. If the iterator is chained, the
- * previous iterator in the chain can be accessed through it->chain_it.
- *
- * @param world The world or stage for which to create the iterator.
- * @param poly The poly object from which to create the iterator.
- * @param iter The iterator (out, ecs_iter_t[2] when filter is set).
- * @param filter Optional term used for filtering the results.
- */
-FLECS_API
-void ecs_iter_poly(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter);
-
 /** Progress any iterator.
  * This operation is useful in combination with iterators for which it is not
  * known what created them. Example use cases are functions that should accept
@@ -4904,7 +4563,7 @@ void ecs_iter_poly(
  * objects.
  *
  * This operation is slightly slower than using a type-specific iterator (e.g.
- * ecs_filter_next(), ecs_query_next()) as it has to call a function pointer which
+ * ecs_query_next, ecs_query_next) as it has to call a function pointer which
  * introduces a level of indirection.
  *
  * @param it The iterator.
@@ -4944,8 +4603,8 @@ int32_t ecs_iter_count(
 
 /** Test if iterator is true.
  * This operation will return true if the iterator returns at least one result.
- * This is especially useful in combination with fact-checking rules (see the
- * rules addon).
+ * This is especially useful in combination with fact-checking querys (see the
+ * querys addon).
  *
  * The operation requires a valid iterator. After the operation is invoked, the
  * application should no longer invoke next on the iterator and should treat it
@@ -4977,20 +4636,20 @@ ecs_entity_t ecs_iter_first(
  * Example:
  *
  * @code
- * // Rule that matches (Eats, *)
- * ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+ * // Query that matches (Eats, *)
+ * ecs_query_t *q = ecs_query(world, {
  *   .terms = {
  *     { .first.id = Eats, .second.name = "$food" }
  *   }
  * });
- *
- * int food_var = ecs_rule_find_var(r, "food");
- *
+ * 
+ * int food_var = ecs_query_find_var(r, "food");
+ * 
  * // Set Food to Apples, so we're only matching (Eats, Apples)
- * ecs_iter_t it = ecs_rule_iter(world, r);
+ * ecs_iter_t it = ecs_query_iter(world, q);
  * ecs_iter_set_var(&it, food_var, Apples);
- *
- * while (ecs_rule_next(&it)) {
+ * 
+ * while (ecs_query_next(&it)) {
  *   for (int i = 0; i < it.count; i ++) {
  *     // iterate as usual
  *   }
@@ -5105,6 +4764,10 @@ bool ecs_iter_var_is_constrained(
     ecs_iter_t *it,
     int32_t var_id);
 
+FLECS_API
+bool ecs_iter_changed(
+    ecs_iter_t *it);
+
 /** Convert iterator to string.
  * Prints the contents of an iterator to a string. Useful for debugging and/or
  * testing the output of an iterator.
@@ -5275,7 +4938,7 @@ ecs_id_t ecs_field_id(
  * @return The index of the matched column, -1 if not matched.
  */
 FLECS_API
-int32_t ecs_field_column_index(
+int32_t ecs_field_column(
     const ecs_iter_t *it,
     int32_t index);
 
@@ -5748,7 +5411,7 @@ int32_t ecs_search_relation(
     int32_t offset,
     ecs_id_t id,
     ecs_entity_t rel,
-    ecs_flags32_t flags, /* EcsSelf and/or EcsUp */
+    ecs_flags64_t flags, /* EcsSelf and/or EcsUp */
     ecs_entity_t *subject_out,
     ecs_id_t *id_out,
     struct ecs_table_record_t **tr_out);
diff --git a/include/flecs/addons/alerts.h b/include/flecs/addons/alerts.h
index e0a34882e..b174f61ce 100644
--- a/include/flecs/addons/alerts.h
+++ b/include/flecs/addons/alerts.h
@@ -81,11 +81,11 @@ typedef struct ecs_alert_desc_t {
     /** Alert query. An alert will be created for each entity that matches the
      * specified query. The query must have at least one term that uses the
      * $this variable (default). */
-    ecs_filter_desc_t filter;
+    ecs_query_desc_t query;
 
     /** Template for alert message. This string is used to generate the alert
      * message and may refer to variables in the query result. The format for
-     * the template expressions is as specified by ecs_interpolate_string().
+     * the template expressions is as specified by ecs_script_string_interpolate().
      *
      * Examples:
      *
diff --git a/include/flecs/addons/cpp/c_types.hpp b/include/flecs/addons/cpp/c_types.hpp
index d56d34028..e0d17c5cb 100644
--- a/include/flecs/addons/cpp/c_types.hpp
+++ b/include/flecs/addons/cpp/c_types.hpp
@@ -17,17 +17,16 @@ namespace flecs {
 
 using world_t = ecs_world_t;
 using world_info_t = ecs_world_info_t;
-using query_group_info_t = ecs_query_group_info_t;
 using id_t = ecs_id_t;
 using entity_t = ecs_entity_t;
 using type_t = ecs_type_t;
 using table_t = ecs_table_t;
-using filter_t = ecs_filter_t;
-using observer_t = ecs_observer_t;
+using term_t = ecs_term_t;
 using query_t = ecs_query_t;
-using rule_t = ecs_rule_t;
-using ref_t = ecs_ref_t;
+using query_group_info_t = ecs_query_group_info_t;
+using observer_t = ecs_observer_t;
 using iter_t = ecs_iter_t;
+using ref_t = ecs_ref_t;
 using type_info_t = ecs_type_info_t;
 using type_hooks_t = ecs_type_hooks_t;
 using flags32_t = ecs_flags32_t;
@@ -35,6 +34,7 @@ using flags32_t = ecs_flags32_t;
 enum inout_kind_t {
     InOutDefault = EcsInOutDefault,
     InOutNone = EcsInOutNone,
+    InOutFilter = EcsInOutFilter,
     InOut = EcsInOut,
     In = EcsIn,
     Out = EcsOut
@@ -50,6 +50,13 @@ enum oper_kind_t {
     NotFrom = EcsNotFrom
 };
 
+enum query_cache_kind_t {
+    QueryCacheDefault = EcsQueryCacheDefault,
+    QueryCacheAuto = EcsQueryCacheAuto,
+    QueryCacheAll = EcsQueryCacheAll,
+    QueryCacheNone = EcsQueryCacheNone
+};
+
 /** Id flags */
 static const flecs::entity_t Pair = ECS_PAIR;
 static const flecs::entity_t Override = ECS_OVERRIDE;
@@ -62,9 +69,8 @@ static const flecs::entity_t Toggle = ECS_TOGGLE;
 /* Builtin components */
 using Component = EcsComponent;
 using Identifier = EcsIdentifier;
-using Iterable = EcsIterable;
 using Poly = EcsPoly;
-using FlattenTarget = EcsFlattenTarget;
+using DefaultChildComponent = EcsDefaultChildComponent;
 
 /* Builtin tags */
 static const flecs::entity_t Query = EcsQuery;
@@ -88,16 +94,16 @@ static const flecs::entity_t OnTableCreate = EcsOnTableCreate;
 static const flecs::entity_t OnTableDelete = EcsOnTableDelete;
 
 /* Builtin term flags */
-static const uint32_t Self = EcsSelf;
-static const uint32_t Up = EcsUp;
-static const uint32_t Down = EcsDown;
-static const uint32_t Cascade = EcsCascade;
-static const uint32_t Desc = EcsDesc;
-static const uint32_t Parent = EcsParent;
-static const uint32_t IsVariable = EcsIsVariable;
-static const uint32_t IsEntity = EcsIsEntity;
-static const uint32_t Filter = EcsFilter;
-static const uint32_t TraverseFlags = EcsTraverseFlags;
+static const uint64_t Self = EcsSelf;
+static const uint64_t Up = EcsUp;
+static const uint64_t Trav = EcsTrav;
+static const uint64_t Cascade = EcsCascade;
+static const uint64_t Desc = EcsDesc;
+static const uint64_t IsVariable = EcsIsVariable;
+static const uint64_t IsEntity = EcsIsEntity;
+static const uint64_t IsName = EcsIsName;
+static const uint64_t TraverseFlags = EcsTraverseFlags;
+static const uint64_t TermRefFlags = EcsTermRefFlags;
 
 /* Builtin entity ids */
 static const flecs::entity_t Flecs = EcsFlecs;
@@ -113,8 +119,7 @@ static const flecs::entity_t Reflexive = EcsReflexive;
 static const flecs::entity_t Final = EcsFinal;
 static const flecs::entity_t DontInherit = EcsDontInherit;
 static const flecs::entity_t AlwaysOverride = EcsAlwaysOverride;
-static const flecs::entity_t Tag = EcsTag;
-static const flecs::entity_t Union = EcsUnion;
+static const flecs::entity_t PairIsTag = EcsPairIsTag;
 static const flecs::entity_t Exclusive = EcsExclusive;
 static const flecs::entity_t Acyclic = EcsAcyclic;
 static const flecs::entity_t Traversable = EcsTraversable;
@@ -124,6 +129,7 @@ static const flecs::entity_t OneOf = EcsOneOf;
 static const flecs::entity_t Trait = EcsTrait;
 static const flecs::entity_t Relationship = EcsRelationship;
 static const flecs::entity_t Target = EcsTarget;
+static const flecs::entity_t CanToggle = EcsCanToggle;
 
 /* Builtin relationships */
 static const flecs::entity_t IsA = EcsIsA;
@@ -142,10 +148,6 @@ static const flecs::entity_t Remove = EcsRemove;
 static const flecs::entity_t Delete = EcsDelete;
 static const flecs::entity_t Panic = EcsPanic;
 
-/* Misc */
-static const flecs::entity_t Flatten = EcsFlatten;
-static const flecs::entity_t DefaultChildComponent = EcsDefaultChildComponent;
-
 /* Builtin predicates for comparing entity ids in queries. Only supported by rules */
 static const flecs::entity_t PredEq = EcsPredEq;
 static const flecs::entity_t PredMatch = EcsPredMatch;
diff --git a/include/flecs/addons/cpp/component.hpp b/include/flecs/addons/cpp/component.hpp
index 2193830a6..dd4f4fc4d 100644
--- a/include/flecs/addons/cpp/component.hpp
+++ b/include/flecs/addons/cpp/component.hpp
@@ -114,7 +114,7 @@ void register_lifecycle_actions(
 }
 
 // Class that manages component ids across worlds & binaries.
-// The cpp_type class stores the component id for a C++ type in a static global
+// The type class stores the component id for a C++ type in a static global
 // variable that is shared between worlds. Whenever a component is used this
 // class will check if it already has been registered (has the global id been
 // set), and if not, register the component with the world.
@@ -127,6 +127,7 @@ template <typename T>
 struct cpp_type_impl {
     static_assert(is_pointer<T>::value == false,
         "pointer types are not allowed for components");
+
     // Initialize component identifier
     static void init(
         entity_t entity,
@@ -253,7 +254,7 @@ struct cpp_type_impl {
         (void)name;
         (void)allow_tag;
 
-        ecs_assert(registered(world), ECS_INVALID_OPERATION,
+        ecs_assert(registered(world), ECS_INVALID_OPERATION, 
             "component '%s' was not registered before use",
             type_name<T>());
 #endif
@@ -318,18 +319,18 @@ template <typename T> int32_t       cpp_type_impl<T>::s_reset_count;
 
 // Regular type
 template <typename T>
-struct cpp_type<T, if_not_t< is_pair<T>::value >>
+struct type<T, if_not_t< is_pair<T>::value >>
     : cpp_type_impl<base_type_t<T>> { };
 
 // Pair type
 template <typename T>
-struct cpp_type<T, if_t< is_pair<T>::value >>
+struct type<T, if_t< is_pair<T>::value >>
 {
     // Override id method to return id of pair
     static id_t id(world_t *world = nullptr) {
         return ecs_pair(
-            cpp_type< pair_first_t<T> >::id(world),
-            cpp_type< pair_second_t<T> >::id(world));
+            type< pair_first_t<T> >::id(world),
+            type< pair_second_t<T> >::id(world));
     }
 };
 
@@ -387,14 +388,14 @@ struct component : untyped_component {
             implicit_name = true;
         }
 
-        if (_::cpp_type<T>::registered(world)) {
+        if (_::type<T>::registered(world)) {
             /* Obtain component id. Because the component is already registered,
              * this operation does nothing besides returning the existing id */
-            id = _::cpp_type<T>::id_explicit(world, name, allow_tag, id);
+            id = _::type<T>::id_explicit(world, name, allow_tag, id);
 
             ecs_cpp_component_validate(world, id, n, _::symbol_name<T>(),
-                _::cpp_type<T>::size(),
-                _::cpp_type<T>::alignment(),
+                _::type<T>::size(),
+                _::type<T>::alignment(),
                 implicit_name);
         } else {
             /* If component is registered from an existing scope, ignore the
@@ -412,6 +413,7 @@ struct component : untyped_component {
                         last_elem = ptr;
                     }
                 }
+
                 if (last_elem) {
                     name = last_elem + 1;
                 }
@@ -423,16 +425,16 @@ struct component : untyped_component {
                 ECS_SIZEOF(T), ECS_ALIGNOF(T), implicit_name, &existing);
 
             /* Initialize static component data */
-            id = _::cpp_type<T>::id_explicit(world, name, allow_tag, id);
+            id = _::type<T>::id_explicit(world, name, allow_tag, id);
 
             /* Initialize lifecycle actions (ctor, dtor, copy, move) */
-            if (_::cpp_type<T>::size() && !existing) {
+            if (_::type<T>::size() && !existing) {
                 _::register_lifecycle_actions<T>(world, id);
             }
         }
 
-        m_world = world;
-        m_id = id;
+        world_ = world;
+        id_ = id;
     }
 
     /** Register on_add hook. */
@@ -447,7 +449,7 @@ struct component : untyped_component {
         ctx->on_add = FLECS_NEW(Delegate)(FLECS_FWD(func));
         ctx->free_on_add = reinterpret_cast<ecs_ctx_free_t>(
             _::free_obj<Delegate>);
-        ecs_set_hooks_id(m_world, m_id, &h);
+        ecs_set_hooks_id(world_, id_, &h);
         return *this;
     }
 
@@ -464,7 +466,7 @@ struct component : untyped_component {
         ctx->on_remove = FLECS_NEW(Delegate)(FLECS_FWD(func));
         ctx->free_on_remove = reinterpret_cast<ecs_ctx_free_t>(
             _::free_obj<Delegate>);
-        ecs_set_hooks_id(m_world, m_id, &h);
+        ecs_set_hooks_id(world_, id_, &h);
         return *this;
     }
 
@@ -481,7 +483,7 @@ struct component : untyped_component {
         ctx->on_set = FLECS_NEW(Delegate)(FLECS_FWD(func));
         ctx->free_on_set = reinterpret_cast<ecs_ctx_free_t>(
             _::free_obj<Delegate>);
-        ecs_set_hooks_id(m_world, m_id, &h);
+        ecs_set_hooks_id(world_, id_, &h);
         return *this;
     }
 
@@ -504,7 +506,7 @@ struct component : untyped_component {
     }
 
     flecs::type_hooks_t get_hooks() {
-        const flecs::type_hooks_t* h = ecs_get_hooks_id(m_world, m_id);
+        const flecs::type_hooks_t* h = ecs_get_hooks_id(world_, id_);
         if (h) {
             return *h;
         } else {
@@ -517,8 +519,8 @@ struct component : untyped_component {
  * component yet, this operation will return 0. */
 template <typename T>
 flecs::entity_t type_id() {
-    if (_::cpp_type<T>::s_reset_count == ecs_cpp_reset_count_get()) {
-        return _::cpp_type<T>::s_id;
+    if (_::type<T>::s_reset_count == ecs_cpp_reset_count_get()) {
+        return _::type<T>::s_id;
     } else {
         return 0;
     }
diff --git a/include/flecs/addons/cpp/delegate.hpp b/include/flecs/addons/cpp/delegate.hpp
index 60e4f35dc..a3aa58242 100644
--- a/include/flecs/addons/cpp/delegate.hpp
+++ b/include/flecs/addons/cpp/delegate.hpp
@@ -50,7 +50,7 @@ struct term_ptrs {
                     *>(nullptr)...);
     }
 
-    array m_terms;
+    array terms_;
 
 private:
     /* Populate terms array without checking for references */
@@ -58,9 +58,9 @@ struct term_ptrs {
 
     template <typename T, typename... Targs>
     bool populate(const ecs_iter_t *iter, size_t index, T, Targs... comps) {
-        m_terms[index].ptr = iter->ptrs[index];
+        terms_[index].ptr = iter->ptrs[index];
         bool is_ref = iter->sources && iter->sources[index] != 0;
-        m_terms[index].is_ref = is_ref;
+        terms_[index].is_ref = is_ref;
         is_ref |= populate(iter, index + 1, comps ...);
         return is_ref;
     }  
@@ -76,11 +76,11 @@ struct each_column { };
 // Base class
 struct each_column_base {
     each_column_base(const _::term_ptr& term, size_t row) 
-        : m_term(term), m_row(row) { }
+        : term_(term), row_(row) { }
 
 protected:
-    const _::term_ptr& m_term;
-    size_t m_row;    
+    const _::term_ptr& term_;
+    size_t row_;    
 };
 
 // If type is not a pointer, return a reference to the type (default case)
@@ -93,7 +93,7 @@ struct each_column<T, if_t< !is_pointer<T>::value &&
         : each_column_base(term, row) { }
 
     T& get_row() {
-        return static_cast<T*>(this->m_term.ptr)[this->m_row];
+        return static_cast<T*>(this->term_.ptr)[this->row_];
     }  
 };
 
@@ -109,7 +109,7 @@ struct each_column<T, if_t< !is_pointer<T>::value &&
         : each_column_base(term, row) { }
 
     T get_row() {
-        return static_cast<actual_type_t<T>*>(this->m_term.ptr)[this->m_row];
+        return static_cast<actual_type_t<T>*>(this->term_.ptr)[this->row_];
     }  
 };
 
@@ -140,8 +140,8 @@ struct each_column<T, if_t< is_pointer<T>::value &&
         : each_column_base(term, row) { }
 
     actual_type_t<T> get_row() {
-        if (this->m_term.ptr) {
-            return &static_cast<actual_type_t<T>>(this->m_term.ptr)[this->m_row];
+        if (this->term_.ptr) {
+            return &static_cast<actual_type_t<T>>(this->term_.ptr)[this->row_];
         } else {
             // optional argument doesn't have a value
             return nullptr;
@@ -164,7 +164,7 @@ struct each_ref_column : public each_column<T> {
             // This check only happens when the current table being iterated
             // over caused the query to match a reference. The check is
             // performed once per iterated table.
-            this->m_row = 0;
+            this->row_ = 0;
         }
     }
 };
@@ -188,10 +188,10 @@ struct each_delegate : public delegate {
 
     template < if_not_t< is_same< decay_t<Func>, decay_t<Func>& >::value > = 0>
     explicit each_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     explicit each_delegate(const Func& func) noexcept 
-        : m_func(func) { }
+        : func_(func) { }
 
     // Invoke object directly. This operation is useful when the calling
     // function has just constructed the delegate, such as what happens when
@@ -202,10 +202,10 @@ struct each_delegate : public delegate {
         iter->flags |= EcsIterCppEach;
 
         if (terms.populate(iter)) {
-            invoke_callback< each_ref_column >(iter, m_func, 0, terms.m_terms);
+            invoke_callback< each_ref_column >(iter, func_, 0, terms.terms_);
         } else {
-            invoke_callback< each_column >(iter, m_func, 0, terms.m_terms);
-        }   
+            invoke_callback< each_column >(iter, func_, 0, terms.terms_);
+        }
     }
 
     // Static function that can be used as callback for systems/triggers
@@ -342,7 +342,7 @@ struct each_delegate : public delegate {
             iter, func, index + 1, columns, comps..., columns[index]);
     }    
 
-    Func m_func;
+    Func func_;
 };
 
 template <typename Func, typename ... Components>
@@ -364,10 +364,10 @@ struct find_delegate : public delegate {
 
     template < if_not_t< is_same< decay_t<Func>, decay_t<Func>& >::value > = 0>
     explicit find_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     explicit find_delegate(const Func& func) noexcept 
-        : m_func(func) { }
+        : func_(func) { }
 
     // Invoke object directly. This operation is useful when the calling
     // function has just constructed the delegate, such as what happens when
@@ -376,9 +376,9 @@ struct find_delegate : public delegate {
         term_ptrs<Components...> terms;
 
         if (terms.populate(iter)) {
-            return invoke_callback< each_ref_column >(iter, m_func, 0, terms.m_terms);
+            return invoke_callback< each_ref_column >(iter, func_, 0, terms.terms_);
         } else {
-            return invoke_callback< each_column >(iter, m_func, 0, terms.m_terms);
+            return invoke_callback< each_column >(iter, func_, 0, terms.terms_);
         }   
     }
 
@@ -496,7 +496,7 @@ struct find_delegate : public delegate {
             iter, func, index + 1, columns, comps..., columns[index]);
     }
 
-    Func m_func;
+    Func func_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -513,10 +513,10 @@ struct iter_delegate : delegate {
 public:
     template < if_not_t< is_same< decay_t<Func>, decay_t<Func>& >::value > = 0>
     explicit iter_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     explicit iter_delegate(const Func& func) noexcept 
-        : m_func(func) { }
+        : func_(func) { }
 
     // Invoke object directly. This operation is useful when the calling
     // function has just constructed the delegate, such as what happens when
@@ -524,7 +524,7 @@ struct iter_delegate : delegate {
     void invoke(ecs_iter_t *iter) const {
         term_ptrs<Components...> terms;
         terms.populate(iter);
-        invoke_callback(iter, m_func, 0, terms.m_terms);
+        invoke_callback(iter, func_, 0, terms.terms_);
     }
 
     // Static function that can be used as callback for systems/triggers
@@ -580,7 +580,7 @@ struct iter_delegate : delegate {
             columns[index]);
     }
 
-    Func m_func;
+    Func func_;
 };
 
 
@@ -591,7 +591,7 @@ struct iter_delegate : delegate {
 template <typename Func>
 struct entity_observer_delegate : delegate {
     explicit entity_observer_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     // Static function that can be used as callback for systems/triggers
     static void run(ecs_iter_t *iter) {
@@ -602,23 +602,23 @@ struct entity_observer_delegate : delegate {
     static void invoke(ecs_iter_t *iter) {
         auto self = static_cast<const entity_observer_delegate*>(iter->binding_ctx);
         ecs_assert(self != nullptr, ECS_INTERNAL_ERROR, NULL);
-        self->m_func(flecs::entity(iter->world, ecs_field_src(iter, 1)));
+        self->func_(flecs::entity(iter->world, ecs_field_src(iter, 0)));
     }
 
     template <typename F, if_t<arity<F>::value == 0> = 0>
     static void invoke(ecs_iter_t *iter) {
         auto self = static_cast<const entity_observer_delegate*>(iter->binding_ctx);
         ecs_assert(self != nullptr, ECS_INTERNAL_ERROR, NULL);
-        self->m_func();
+        self->func_();
     }
 
-    Func m_func;
+    Func func_;
 };
 
 template <typename Func, typename Event>
 struct entity_payload_observer_delegate : delegate {
     explicit entity_payload_observer_delegate(Func&& func) noexcept 
-        : m_func(FLECS_MOV(func)) { }
+        : func_(FLECS_MOV(func)) { }
 
     // Static function that can be used as callback for systems/triggers
     static void run(ecs_iter_t *iter) {
@@ -635,7 +635,7 @@ struct entity_payload_observer_delegate : delegate {
             "entity observer invoked without payload");
 
         Event *data = static_cast<Event*>(iter->param);
-        self->m_func(*data);
+        self->func_(*data);
     }
 
     template <typename F, if_t<arity<F>::value == 2> = 0>
@@ -647,10 +647,10 @@ struct entity_payload_observer_delegate : delegate {
             "entity observer invoked without payload");
 
         Event *data = static_cast<Event*>(iter->param);
-        self->m_func(flecs::entity(iter->world, ecs_field_src(iter, 1)), *data);
+        self->func_(flecs::entity(iter->world, ecs_field_src(iter, 0)), *data);
     }
 
-    Func m_func;
+    Func func_;
 };
 
 
@@ -696,7 +696,7 @@ struct entity_with_delegate_impl<arg_list<Args ...>> {
         /* Get column indices for components */
         ColumnArray columns ({
             ecs_table_get_column_index(real_world, table, 
-                _::cpp_type<Args>().id(world))...
+                _::type<Args>().id(world))...
         });
 
         /* Get pointers for columns for entity */
@@ -717,7 +717,7 @@ struct entity_with_delegate_impl<arg_list<Args ...>> {
         size_t i = 0;
         DummyArray dummy ({
             (ptrs[i ++] = ecs_ensure_id(world, e, 
-                _::cpp_type<Args>().id(world)), 0)...
+                _::type<Args>().id(world)), 0)...
         });
 
         return true;
diff --git a/include/flecs/addons/cpp/entity.hpp b/include/flecs/addons/cpp/entity.hpp
index ce1231b6c..2d4a063d5 100644
--- a/include/flecs/addons/cpp/entity.hpp
+++ b/include/flecs/addons/cpp/entity.hpp
@@ -37,8 +37,13 @@ struct entity : entity_builder<entity>
     explicit entity(world_t *world)
         : entity_builder()
     {
-        m_world = world;
-        m_id = ecs_new(world, 0);
+        world_ = world;
+        if (!ecs_get_scope(world_) && !ecs_get_with(world_)) {
+            id_ = ecs_new(world);
+        } else {
+            ecs_entity_desc_t desc = {};
+            id_ = ecs_entity_init(world_, &desc);
+        }
     }
 
     /** Wrap an existing entity id.
@@ -47,8 +52,8 @@ struct entity : entity_builder<entity>
      * @param id The entity id.
      */
     explicit entity(const flecs::world_t *world, flecs::entity_t id) {
-        m_world = const_cast<flecs::world_t*>(world);
-        m_id = id;
+        world_ = const_cast<flecs::world_t*>(world);
+        id_ = id;
     }
 
     /** Create a named entity.
@@ -63,13 +68,13 @@ struct entity : entity_builder<entity>
     explicit entity(world_t *world, const char *name)
         : entity_builder()
     {
-        m_world = world;
+        world_ = world;
 
         ecs_entity_desc_t desc = {};
         desc.name = name;
         desc.sep = "::";
         desc.root_sep = "::";
-        m_id = ecs_entity_init(world, &desc);
+        id_ = ecs_entity_init(world, &desc);
     }
 
     /** Conversion from flecs::entity_t to flecs::entity.
@@ -92,9 +97,10 @@ struct entity : entity_builder<entity>
      */
     template <typename T>
     T& ensure() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return *static_cast<T*>(ecs_ensure_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return *static_cast<T*>(ecs_ensure_id(world_, id_, comp_id));
     }
 
     /** Get mutable component value (untyped).
@@ -107,7 +113,7 @@ struct entity : entity_builder<entity>
      * @return Pointer to the component value.
      */
     void* ensure(entity_t comp) const {
-        return ecs_ensure_id(m_world, m_id, comp);
+        return ecs_ensure_id(world_, id_, comp);
     }
 
     /** Get mutable pointer for a pair.
@@ -119,9 +125,9 @@ struct entity : entity_builder<entity>
     template <typename First, typename Second, typename P = pair<First, Second>,
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     A& ensure() const {
-        return *static_cast<A*>(ecs_ensure_id(m_world, m_id, ecs_pair(
-            _::cpp_type<First>::id(m_world),
-            _::cpp_type<Second>::id(m_world))));
+        return *static_cast<A*>(ecs_ensure_id(world_, id_, ecs_pair(
+            _::type<First>::id(world_),
+            _::type<Second>::id(world_))));
     }
 
     /** Get mutable pointer for the first element of a pair.
@@ -132,10 +138,11 @@ struct entity : entity_builder<entity>
      */
     template <typename First>
     First& ensure(entity_t second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
-        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto comp_id = _::type<First>::id(world_);
+        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         return *static_cast<First*>(
-            ecs_ensure_id(m_world, m_id, ecs_pair(comp_id, second)));
+            ecs_ensure_id(world_, id_, ecs_pair(comp_id, second)));
     }
 
     /** Get mutable pointer for a pair (untyped).
@@ -147,11 +154,9 @@ struct entity : entity_builder<entity>
      * @param second The second element of the pair.
      */
     void* ensure(entity_t first, entity_t second) const {
-        return ecs_ensure_id(m_world, m_id, ecs_pair(first, second));
+        return ecs_ensure_id(world_, id_, ecs_pair(first, second));
     }
 
-    #endif
-
     /** Get mutable pointer for the second element of a pair.
      * This operation gets the value for a pair from the entity.
      *
@@ -160,20 +165,24 @@ struct entity : entity_builder<entity>
      */
     template <typename Second>
     Second& ensure_second(entity_t first) const {
-        auto second = _::cpp_type<Second>::id(m_world);
-        ecs_assert(_::cpp_type<Second>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto second = _::type<Second>::id(world_);
+        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         return *static_cast<Second*>(
-            ecs_ensure_id(m_world, m_id, ecs_pair(first, second)));
+            ecs_ensure_id(world_, id_, ecs_pair(first, second)));
     }
 
+    #endif
+
     /** Signal that component was modified.
      *
      * @tparam T component that was modified.
      */
     template <typename T>
     void modified() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         this->modified(comp_id);
     }
 
@@ -184,7 +193,7 @@ struct entity : entity_builder<entity>
      */
     template <typename First, typename Second>
     void modified() const {
-        this->modified<First>(_::cpp_type<Second>::id(m_world));
+        this->modified<First>(_::type<Second>::id(world_));
     }
 
     /** Signal that the first part of a pair was modified.
@@ -194,8 +203,9 @@ struct entity : entity_builder<entity>
      */
     template <typename First>
     void modified(entity_t second) const {
-        auto first = _::cpp_type<First>::id(m_world);
-        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto first = _::type<First>::id(world_);
+        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         this->modified(first, second);
     }
 
@@ -215,7 +225,7 @@ struct entity : entity_builder<entity>
      * @param comp component that was modified.
      */
     void modified(entity_t comp) const {
-        ecs_modified_id(m_world, m_id, comp);
+        ecs_modified_id(world_, id_, comp);
     }
 
     /** Get reference to component.
@@ -227,7 +237,7 @@ struct entity : entity_builder<entity>
      */
     template <typename T, if_t< is_actual<T>::value > = 0>
     ref<T> get_ref() const {
-        return ref<T>(m_world, m_id, _::cpp_type<T>::id(m_world));
+        return ref<T>(world_, id_, _::type<T>::id(world_));
     }
 
     /** Get reference to component.
@@ -241,37 +251,30 @@ struct entity : entity_builder<entity>
      */
     template <typename T, typename A = actual_type_t<T>, if_t< flecs::is_pair<T>::value > = 0>
     ref<A> get_ref() const {
-        return ref<A>(m_world, m_id,
-                      ecs_pair(_::cpp_type<typename T::first>::id(m_world),
-                               _::cpp_type<typename T::second>::id(m_world)));
+        return ref<A>(world_, id_,
+                      ecs_pair(_::type<typename T::first>::id(world_),
+                               _::type<typename T::second>::id(world_)));
     }
 
 
     template <typename First, typename Second, typename P = flecs::pair<First, Second>,
         typename A = actual_type_t<P>>
     ref<A> get_ref() const {
-        return ref<A>(m_world, m_id,
-            ecs_pair(_::cpp_type<First>::id(m_world),
-                _::cpp_type<Second>::id(m_world)));
+        return ref<A>(world_, id_,
+            ecs_pair(_::type<First>::id(world_),
+                _::type<Second>::id(world_)));
     }
 
     template <typename First>
     ref<First> get_ref(flecs::entity_t second) const {
-        return ref<First>(m_world, m_id,
-            ecs_pair(_::cpp_type<First>::id(m_world), second));
+        return ref<First>(world_, id_,
+            ecs_pair(_::type<First>::id(world_), second));
     }
 
     template <typename Second>
     ref<Second> get_ref_second(flecs::entity_t first) const {
-        return ref<Second>(m_world, m_id,
-            ecs_pair(first, _::cpp_type<Second>::id(m_world)));
-    }
-
-    /** Recursively flatten relationship.
-     * @see ecs_flatten
-     */
-    void flatten(flecs::entity_t r, const ecs_flatten_desc_t *desc = nullptr) {
-        ecs_flatten(m_world, ecs_pair(r, m_id), desc);
+        return ref<Second>(world_, id_,
+            ecs_pair(first, _::type<Second>::id(world_)));
     }
 
     /** Clear an entity.
@@ -279,7 +282,7 @@ struct entity : entity_builder<entity>
      * the entity id.
      */
     void clear() const {
-        ecs_clear(m_world, m_id);
+        ecs_clear(world_, id_);
     }
 
     /** Delete an entity.
@@ -287,7 +290,7 @@ struct entity : entity_builder<entity>
      * entity object goes out of scope.
      */
     void destruct() const {
-        ecs_delete(m_world, m_id);
+        ecs_delete(world_, id_);
     }
 
     /** Return entity as entity_view.
@@ -300,7 +303,7 @@ struct entity : entity_builder<entity>
      */
     flecs::entity_view view() const {
         return flecs::entity_view(
-            const_cast<flecs::world_t*>(ecs_get_world(m_world)), m_id);
+            const_cast<flecs::world_t*>(ecs_get_world(world_)), id_);
     }
 
     /** Entity id 0.
@@ -312,7 +315,7 @@ struct entity : entity_builder<entity>
     static
     flecs::entity null(const flecs::world_t *world) {
         flecs::entity result;
-        result.m_world = const_cast<flecs::world_t*>(world);
+        result.world_ = const_cast<flecs::world_t*>(world);
         return result;
     }
 
diff --git a/include/flecs/addons/cpp/entity_view.hpp b/include/flecs/addons/cpp/entity_view.hpp
index 43218934e..c54ea7dc9 100644
--- a/include/flecs/addons/cpp/entity_view.hpp
+++ b/include/flecs/addons/cpp/entity_view.hpp
@@ -48,7 +48,7 @@ struct entity_view : public id {
      * @return The integer entity id.
      */
     entity_t id() const {
-        return m_id;
+        return id_;
     }
 
     /** Check if entity is valid.
@@ -56,7 +56,7 @@ struct entity_view : public id {
      * @return True if the entity is alive, false otherwise.
      */
     bool is_valid() const {
-        return m_world && ecs_is_valid(m_world, m_id);
+        return world_ && ecs_is_valid(world_, id_);
     }
   
     explicit operator bool() const {
@@ -68,7 +68,7 @@ struct entity_view : public id {
      * @return True if the entity is alive, false otherwise.
      */
     bool is_alive() const {
-        return m_world && ecs_is_alive(m_world, m_id);
+        return world_ && ecs_is_alive(world_, id_);
     }
 
     /** Return the entity name.
@@ -76,7 +76,7 @@ struct entity_view : public id {
      * @return The entity name.
      */
     flecs::string_view name() const {
-        return flecs::string_view(ecs_get_name(m_world, m_id));
+        return flecs::string_view(ecs_get_name(world_, id_));
     }
 
     /** Return the entity symbol.
@@ -84,7 +84,7 @@ struct entity_view : public id {
      * @return The entity symbol.
      */
     flecs::string_view symbol() const {
-        return flecs::string_view(ecs_get_symbol(m_world, m_id));
+        return flecs::string_view(ecs_get_symbol(world_, id_));
     }
 
     /** Return the entity path.
@@ -100,7 +100,7 @@ struct entity_view : public id {
      * @return The relative hierarchical entity path.
      */
     flecs::string path_from(flecs::entity_t parent, const char *sep = "::", const char *init_sep = "::") const {
-        char *path = ecs_get_path_w_sep(m_world, parent, m_id, sep, init_sep);
+        char *path = ecs_get_path_w_sep(world_, parent, id_, sep, init_sep);
         return flecs::string(path);
     }
 
@@ -110,11 +110,11 @@ struct entity_view : public id {
      */
     template <typename Parent>
     flecs::string path_from(const char *sep = "::", const char *init_sep = "::") const {
-        return path_from(_::cpp_type<Parent>::id(m_world), sep, init_sep);
+        return path_from(_::type<Parent>::id(world_), sep, init_sep);
     }
 
     bool enabled() const {
-        return !ecs_has_id(m_world, m_id, flecs::Disabled);
+        return !ecs_has_id(world_, id_, flecs::Disabled);
     }
 
     /** Get the entity's type.
@@ -187,7 +187,7 @@ struct entity_view : public id {
      */
     template <typename First, typename Func>
     void each(const Func& func) const { 
-        return each(_::cpp_type<First>::id(m_world), func);
+        return each(_::type<First>::id(world_), func);
     }
 
     /** Iterate children for entity.
@@ -205,13 +205,15 @@ struct entity_view : public id {
         /* When the entity is a wildcard, this would attempt to query for all
          * entities with (ChildOf, *) or (ChildOf, _) instead of querying for
          * the children of the wildcard entity. */
-        if (m_id == flecs::Wildcard || m_id == flecs::Any) {
+        if (id_ == flecs::Wildcard || id_ == flecs::Any) {
             /* This is correct, wildcard entities don't have children */
             return;
         }
 
-        ecs_iter_t it = flecs_children(m_world, rel, m_id);
-        while (ecs_children_next(&it)) {
+        flecs::world world(world_);
+
+        ecs_iter_t it = ecs_each_id(world_, ecs_pair(rel, id_));
+        while (ecs_each_next(&it)) {
             _::each_delegate<Func>(FLECS_MOV(func)).invoke(&it);
         }
     }
@@ -228,7 +230,7 @@ struct entity_view : public id {
      */
     template <typename Rel, typename Func>
     void children(Func&& func) const {
-        children(_::cpp_type<Rel>::id(m_world), FLECS_MOV(func));
+        children(_::type<Rel>::id(world_), FLECS_MOV(func));
     }
 
     /** Iterate children for entity.
@@ -255,9 +257,10 @@ struct entity_view : public id {
      */
     template <typename T, if_t< is_actual<T>::value > = 0>
     const T* get() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return static_cast<const T*>(ecs_get_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return static_cast<const T*>(ecs_get_id(world_, id_, comp_id));
     }
 
     /** Get component value.
@@ -271,9 +274,10 @@ struct entity_view : public id {
     template <typename T, typename A = actual_type_t<T>, 
         if_t< flecs::is_pair<T>::value > = 0>
     const A* get() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<A>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return static_cast<const A*>(ecs_get_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<A>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return static_cast<const A*>(ecs_get_id(world_, id_, comp_id));
     }
 
     /** Get a pair.
@@ -296,10 +300,11 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_not_t< is_enum<Second>::value> = 0>
     const First* get(Second second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
-        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto comp_id = _::type<First>::id(world_);
+        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         return static_cast<const First*>(
-            ecs_get_id(m_world, m_id, ecs_pair(comp_id, second)));
+            ecs_get_id(world_, id_, ecs_pair(comp_id, second)));
     }
 
     /** Get a pair.
@@ -310,7 +315,7 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_t<is_enum<Second>::value> = 0>
     const First* get(Second constant) const {
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         flecs::entity_t target = et.entity(constant);
         return get<First>(target);
     }
@@ -322,7 +327,7 @@ struct entity_view : public id {
      *         have the component.
      */
     const void* get(flecs::id_t comp) const {
-        return ecs_get_id(m_world, m_id, comp);
+        return ecs_get_id(world_, id_, comp);
     }
 
     /** Get a pair (untyped).
@@ -334,7 +339,7 @@ struct entity_view : public id {
      * @param second The second element of the pair.
      */
     const void* get(flecs::entity_t first, flecs::entity_t second) const {
-        return ecs_get_id(m_world, m_id, ecs_pair(first, second));
+        return ecs_get_id(world_, id_, ecs_pair(first, second));
     }
 
     /** Get 1..N components.
@@ -391,10 +396,11 @@ struct entity_view : public id {
      */
     template<typename Second>
     const Second* get_second(flecs::entity_t first) const {
-        auto second = _::cpp_type<Second>::id(m_world);
-        ecs_assert(_::cpp_type<Second>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto second = _::type<Second>::id(world_);
+        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
         return static_cast<const Second*>(
-            ecs_get_id(m_world, m_id, ecs_pair(first, second)));
+            ecs_get_id(world_, id_, ecs_pair(first, second)));
     }
 
     /** Get the second part for a pair.
@@ -417,9 +423,10 @@ struct entity_view : public id {
      */
     template <typename T, if_t< is_actual<T>::value > = 0>
     T* get_mut() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return static_cast<T*>(ecs_get_mut_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return static_cast<T*>(ecs_get_mut_id(world_, id_, comp_id));
     }
 
     /** Get mutable component value.
@@ -433,9 +440,10 @@ struct entity_view : public id {
     template <typename T, typename A = actual_type_t<T>, 
         if_t< flecs::is_pair<T>::value > = 0>
     A* get_mut() const {
-        auto comp_id = _::cpp_type<T>::id(m_world);
-        ecs_assert(_::cpp_type<A>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-        return static_cast<A*>(ecs_get_mut_id(m_world, m_id, comp_id));
+        auto comp_id = _::type<T>::id(world_);
+        ecs_assert(_::type<A>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+        return static_cast<A*>(ecs_get_mut_id(world_, id_, comp_id));
     }
 
     /** Get a mutable pair.
@@ -458,10 +466,11 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_not_t< is_enum<Second>::value> = 0>
     First* get_mut(Second second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
-        ecs_assert(_::cpp_type<First>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto comp_id = _::type<First>::id(world_);
+        ecs_assert(_::type<First>::size() != 0, ECS_INVALID_PARAMETER, 
+            "operation invalid for empty type");
         return static_cast<First*>(
-            ecs_get_mut_id(m_world, m_id, ecs_pair(comp_id, second)));
+            ecs_get_mut_id(world_, id_, ecs_pair(comp_id, second)));
     }
 
     /** Get a mutable pair.
@@ -472,7 +481,7 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_t<is_enum<Second>::value> = 0>
     First* get_mut(Second constant) const {
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         flecs::entity_t target = et.entity(constant);
         return get_mut<First>(target);
     }
@@ -484,7 +493,7 @@ struct entity_view : public id {
      *         have the component.
      */
     void* get_mut(flecs::id_t comp) const {
-        return ecs_get_mut_id(m_world, m_id, comp);
+        return ecs_get_mut_id(world_, id_, comp);
     }
 
     /** Get a mutable pair (untyped).
@@ -496,7 +505,7 @@ struct entity_view : public id {
      * @param second The second element of the pair.
      */
     void* get_mut(flecs::entity_t first, flecs::entity_t second) const {
-        return ecs_get_mut_id(m_world, m_id, ecs_pair(first, second));
+        return ecs_get_mut_id(world_, id_, ecs_pair(first, second));
     }
 
     /** Get the second part for a pair.
@@ -508,10 +517,11 @@ struct entity_view : public id {
      */
     template<typename Second>
     Second* get_mut_second(flecs::entity_t first) const {
-        auto second = _::cpp_type<Second>::id(m_world);
-        ecs_assert(_::cpp_type<Second>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        auto second = _::type<Second>::id(world_);
+        ecs_assert(_::type<Second>::size() != 0, ECS_INVALID_PARAMETER, 
+            "operation invalid for empty type");
         return static_cast<Second*>(
-            ecs_get_mut_id(m_world, m_id, ecs_pair(first, second)));
+            ecs_get_mut_id(world_, id_, ecs_pair(first, second)));
     }
 
     /** Get the second part for a pair.
@@ -579,7 +589,7 @@ struct entity_view : public id {
      * @return The depth.
      */
     int32_t depth(flecs::entity_t rel) const {
-        return ecs_get_depth(m_world, m_id, rel);
+        return ecs_get_depth(world_, id_, rel);
     }
 
     /** Get depth for given relationship.
@@ -589,7 +599,7 @@ struct entity_view : public id {
      */
     template<typename Rel>
     int32_t depth() const {
-        return this->depth(_::cpp_type<Rel>::id(m_world));
+        return this->depth(_::type<Rel>::id(world_));
     }
 
     /** Get parent of entity.
@@ -615,7 +625,7 @@ struct entity_view : public id {
      * @return True if the entity has the provided entity, false otherwise.
      */
     bool has(flecs::id_t e) const {
-        return ecs_has_id(m_world, m_id, e);
+        return ecs_has_id(world_, id_, e);
     }     
 
     /** Check if entity has the provided component.
@@ -625,14 +635,14 @@ struct entity_view : public id {
      */
     template <typename T>
     bool has() const {
-        flecs::id_t cid = _::cpp_type<T>::id(m_world);
-        bool result = ecs_has_id(m_world, m_id, cid);
+        flecs::id_t cid = _::type<T>::id(world_);
+        bool result = ecs_has_id(world_, id_, cid);
         if (result) {
             return result;
         }
 
         if (is_enum<T>::value) {
-            return ecs_has_pair(m_world, m_id, cid, flecs::Wildcard);
+            return ecs_has_pair(world_, id_, cid, flecs::Wildcard);
         }
 
         return false;
@@ -646,12 +656,12 @@ struct entity_view : public id {
      */
     template <typename E, if_t< is_enum<E>::value > = 0>
     bool has(E value) const {
-        auto r = _::cpp_type<E>::id(m_world);
-        auto o = enum_type<E>(m_world).entity(value);
+        auto r = _::type<E>::id(world_);
+        auto o = enum_type<E>(world_).entity(value);
         ecs_assert(o, ECS_INVALID_PARAMETER,
             "Constant was not found in Enum reflection data."
             " Did you mean to use has<E>() instead of has(E)?");
-        return ecs_has_pair(m_world, m_id, r, o);
+        return ecs_has_pair(world_, id_, r, o);
     }
 
     /** Check if entity has the provided pair.
@@ -662,7 +672,7 @@ struct entity_view : public id {
      */
     template <typename First, typename Second>
     bool has() const {
-        return this->has<First>(_::cpp_type<Second>::id(m_world));
+        return this->has<First>(_::type<Second>::id(world_));
     }
 
     /** Check if entity has the provided pair.
@@ -673,8 +683,8 @@ struct entity_view : public id {
      */
     template<typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
     bool has(Second second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
-        return ecs_has_id(m_world, m_id, ecs_pair(comp_id, second));
+        auto comp_id = _::type<First>::id(world_);
+        return ecs_has_id(world_, id_, ecs_pair(comp_id, second));
     }
 
     /** Check if entity has the provided pair.
@@ -685,7 +695,7 @@ struct entity_view : public id {
      */
     template <typename Second>
     bool has_second(flecs::entity_t first) const {
-        return this->has(first, _::cpp_type<Second>::id(m_world));
+        return this->has(first, _::type<Second>::id(world_));
     }
 
     /** Check if entity has the provided pair.
@@ -696,7 +706,7 @@ struct entity_view : public id {
      */
     template<typename First, typename E, if_t< is_enum<E>::value > = 0>
     bool has(E value) const {
-        const auto& et = enum_type<E>(this->m_world);
+        const auto& et = enum_type<E>(this->world_);
         flecs::entity_t second = et.entity(value);
         return has<First>(second);
     }
@@ -708,7 +718,7 @@ struct entity_view : public id {
      * @return True if the entity has the provided component, false otherwise.
      */
     bool has(flecs::id_t first, flecs::id_t second) const {
-        return ecs_has_id(m_world, m_id, ecs_pair(first, second));
+        return ecs_has_id(world_, id_, ecs_pair(first, second));
     }
 
     /** Check if entity owns the provided entity.
@@ -718,7 +728,7 @@ struct entity_view : public id {
      * @return True if the entity owns the provided entity, false otherwise.
      */
     bool owns(flecs::id_t e) const {
-        return ecs_owns_id(m_world, m_id, e);
+        return ecs_owns_id(world_, id_, e);
     }
 
     /** Check if entity owns the provided pair.
@@ -729,7 +739,7 @@ struct entity_view : public id {
      */
     template <typename First>
     bool owns(flecs::id_t second) const {
-        auto comp_id = _::cpp_type<First>::id(m_world);
+        auto comp_id = _::type<First>::id(world_);
         return owns(ecs_pair(comp_id, second));
     }
 
@@ -751,7 +761,7 @@ struct entity_view : public id {
      */
     template <typename T>
     bool owns() const {
-        return owns(_::cpp_type<T>::id(m_world));
+        return owns(_::type<T>::id(world_));
     }
 
     /** Check if entity owns the provided pair.
@@ -764,8 +774,8 @@ struct entity_view : public id {
     template <typename First, typename Second>
     bool owns() const {
         return owns(
-            _::cpp_type<First>::id(m_world),
-            _::cpp_type<Second>::id(m_world));
+            _::type<First>::id(world_),
+            _::type<Second>::id(world_));
     }
 
     /** Test if id is enabled.
@@ -774,7 +784,7 @@ struct entity_view : public id {
      * @return True if enabled, false if not.
      */
     bool enabled(flecs::id_t id) const {
-        return ecs_is_enabled_id(m_world, m_id, id);
+        return ecs_is_enabled_id(world_, id_, id);
     }
 
     /** Test if component is enabled.
@@ -784,7 +794,7 @@ struct entity_view : public id {
      */
     template<typename T>
     bool enabled() const {
-        return this->enabled(_::cpp_type<T>::id(m_world));
+        return this->enabled(_::type<T>::id(world_));
     }
 
     /** Test if pair is enabled.
@@ -805,7 +815,7 @@ struct entity_view : public id {
      */
     template <typename First>
     bool enabled(flecs::id_t second) const {
-        return this->enabled(_::cpp_type<First>::id(m_world), second);
+        return this->enabled(_::type<First>::id(world_), second);
     }
 
     /** Test if pair is enabled.
@@ -816,7 +826,7 @@ struct entity_view : public id {
      */
     template <typename First, typename Second>
     bool enabled() const {
-        return this->enabled<First>(_::cpp_type<Second>::id(m_world));
+        return this->enabled<First>(_::type<Second>::id(world_));
     }
 
     flecs::entity clone(bool clone_value = true, flecs::entity_t dst_id = 0) const;
diff --git a/include/flecs/addons/cpp/field.hpp b/include/flecs/addons/cpp/field.hpp
index 67a5a09cc..cd30560f9 100644
--- a/include/flecs/addons/cpp/field.hpp
+++ b/include/flecs/addons/cpp/field.hpp
@@ -25,10 +25,10 @@ namespace flecs
  */
 struct untyped_field {
     untyped_field(void* array, size_t size, size_t count, bool is_shared = false)
-        : m_data(array)
-        , m_size(size)
-        , m_count(count)
-        , m_is_shared(is_shared) {}
+        : data_(array)
+        , size_(size)
+        , count_(count)
+        , is_shared_(is_shared) {}
 
     /** Return element in component array.
      * This operator may only be used if the field is not shared.
@@ -37,18 +37,18 @@ struct untyped_field {
      * @return Reference to element.
      */
     void* operator[](size_t index) const {
-        ecs_assert(!m_is_shared, ECS_INVALID_PARAMETER,
+        ecs_assert(!is_shared_, ECS_INVALID_PARAMETER,
             "invalid usage of [] operator for shared component field");
-        ecs_assert(index < m_count, ECS_COLUMN_INDEX_OUT_OF_RANGE,
+        ecs_assert(index < count_, ECS_COLUMN_INDEX_OUT_OF_RANGE,
             "index %d out of range for field", index);
-        return ECS_OFFSET(m_data, m_size * index);
+        return ECS_OFFSET(data_, size_ * index);
     }
 
 protected:
-    void* m_data;
-    size_t m_size;
-    size_t m_count;
-    bool m_is_shared;
+    void* data_;
+    size_t size_;
+    size_t count_;
+    bool is_shared_;
 };
 
 /** Wrapper class around a field.
@@ -69,9 +69,9 @@ struct field {
      * @param is_shared Is the component shared or not.
      */
     field(T* array, size_t count, bool is_shared = false)
-        : m_data(array)
-        , m_count(count)
-        , m_is_shared(is_shared) {}
+        : data_(array)
+        , count_(count)
+        , is_shared_(is_shared) {}
 
     /** Create field from iterator.
      *
@@ -103,9 +103,9 @@ struct field {
     T* operator->() const;
 
 protected:
-    T* m_data;
-    size_t m_count;
-    bool m_is_shared;
+    T* data_;
+    size_t count_;
+    bool is_shared_;
 };
 
 }
diff --git a/include/flecs/addons/cpp/flecs.hpp b/include/flecs/addons/cpp/flecs.hpp
index dd48953ee..4915c4060 100644
--- a/include/flecs/addons/cpp/flecs.hpp
+++ b/include/flecs/addons/cpp/flecs.hpp
@@ -32,7 +32,7 @@ struct component;
 namespace _
 {
 template <typename T, typename U = int>
-struct cpp_type;
+struct type;
 
 template <typename Func, typename ... Components>
 struct each_delegate;
@@ -49,9 +49,8 @@ struct each_delegate;
 // Mixin forward declarations
 #include "mixins/id/decl.hpp"
 #include "mixins/term/decl.hpp"
-#include "mixins/filter/decl.hpp"
-#include "mixins/event/decl.hpp"
 #include "mixins/query/decl.hpp"
+#include "mixins/event/decl.hpp"
 #include "mixins/observer/decl.hpp"
 #ifdef FLECS_SYSTEM
 #include "mixins/system/decl.hpp"
@@ -62,18 +61,12 @@ struct each_delegate;
 #ifdef FLECS_TIMER
 #include "mixins/timer/decl.hpp"
 #endif
-#ifdef FLECS_SNAPSHOT
-#include "mixins/snapshot/decl.hpp"
-#endif
 #ifdef FLECS_DOC
 #include "mixins/doc/decl.hpp"
 #endif
 #ifdef FLECS_REST
 #include "mixins/rest/decl.hpp"
 #endif
-#ifdef FLECS_RULES
-#include "mixins/rule/decl.hpp"
-#endif
 #ifdef FLECS_META
 #include "mixins/meta/decl.hpp"
 #endif
@@ -105,17 +98,16 @@ struct each_delegate;
 #include "iter.hpp"
 #include "entity.hpp"
 #include "delegate.hpp"
-#include "utils/iterable.hpp"
 #include "component.hpp"
 #include "type.hpp"
 #include "table.hpp"
+#include "utils/iterable.hpp"
 
 // Mixin implementations
 #include "mixins/id/impl.hpp"
 #include "mixins/entity/impl.hpp"
 #include "mixins/component/impl.hpp"
 #include "mixins/term/impl.hpp"
-#include "mixins/filter/impl.hpp"
 #include "mixins/query/impl.hpp"
 #include "mixins/observer/impl.hpp"
 #include "mixins/event/impl.hpp"
@@ -132,9 +124,6 @@ struct each_delegate;
 #ifdef FLECS_TIMER
 #include "mixins/timer/impl.hpp"
 #endif
-#ifdef FLECS_SNAPSHOT
-#include "mixins/snapshot/impl.hpp"
-#endif
 #ifdef FLECS_DOC
 #include "mixins/doc/impl.hpp"
 #endif
@@ -144,9 +133,6 @@ struct each_delegate;
 #ifdef FLECS_REST
 #include "mixins/rest/impl.hpp"
 #endif
-#ifdef FLECS_RULES
-#include "mixins/rule/impl.hpp"
-#endif
 #ifdef FLECS_META
 #include "mixins/meta/impl.hpp"
 #endif
diff --git a/include/flecs/addons/cpp/impl/field.hpp b/include/flecs/addons/cpp/impl/field.hpp
index 54c599615..3957a56a3 100644
--- a/include/flecs/addons/cpp/impl/field.hpp
+++ b/include/flecs/addons/cpp/impl/field.hpp
@@ -15,16 +15,16 @@ inline field<T>::field(iter &iter, int32_t index) {
 
 template <typename T>
 T& field<T>::operator[](size_t index) const {
-    ecs_assert(m_data != nullptr, ECS_INVALID_OPERATION, 
+    ecs_assert(data_ != nullptr, ECS_INVALID_OPERATION, 
         "invalid nullptr dereference of component type %s", 
             _::type_name<T>());
-    ecs_assert(index < m_count, ECS_COLUMN_INDEX_OUT_OF_RANGE,
+    ecs_assert(index < count_, ECS_COLUMN_INDEX_OUT_OF_RANGE,
         "index %d out of range for array of component type %s",
             index, _::type_name<T>());
-    ecs_assert(!index || !m_is_shared, ECS_INVALID_PARAMETER,
+    ecs_assert(!index || !is_shared_, ECS_INVALID_PARAMETER,
         "non-zero index invalid for shared field of component type %s",
             _::type_name<T>());
-    return m_data[index];
+    return data_[index];
 }
 
 /** Return first element of component array.
@@ -34,10 +34,10 @@ T& field<T>::operator[](size_t index) const {
  */
 template <typename T>
 T& field<T>::operator*() const {
-    ecs_assert(m_data != nullptr, ECS_INVALID_OPERATION, 
+    ecs_assert(data_ != nullptr, ECS_INVALID_OPERATION, 
         "invalid nullptr dereference of component type %s", 
             _::type_name<T>());
-    return *m_data;
+    return *data_;
 }
 
 /** Return first element of component array.
@@ -47,14 +47,14 @@ T& field<T>::operator*() const {
  */
 template <typename T>
 T* field<T>::operator->() const {
-    ecs_assert(m_data != nullptr, ECS_INVALID_OPERATION, 
+    ecs_assert(data_ != nullptr, ECS_INVALID_OPERATION, 
         "invalid nullptr dereference of component type %s", 
             _::type_name<T>());
-    ecs_assert(m_data != nullptr, ECS_INVALID_OPERATION, 
+    ecs_assert(data_ != nullptr, ECS_INVALID_OPERATION, 
         "-> operator invalid for array with >1 element of "
         "component type %s, use [row] instead",
             _::type_name<T>());
-    return m_data;
+    return data_;
 }
 
 }
diff --git a/include/flecs/addons/cpp/impl/iter.hpp b/include/flecs/addons/cpp/impl/iter.hpp
index 9f16e019a..945443e82 100644
--- a/include/flecs/addons/cpp/impl/iter.hpp
+++ b/include/flecs/addons/cpp/impl/iter.hpp
@@ -9,60 +9,60 @@ namespace flecs
 {
 
 inline flecs::entity iter::system() const {
-    return flecs::entity(m_iter->world, m_iter->system);
+    return flecs::entity(iter_->world, iter_->system);
 }
 
 inline flecs::entity iter::event() const {
-    return flecs::entity(m_iter->world, m_iter->event);
+    return flecs::entity(iter_->world, iter_->event);
 }
 
 inline flecs::id iter::event_id() const {
-    return flecs::id(m_iter->world, m_iter->event_id);
+    return flecs::id(iter_->world, iter_->event_id);
 }
 
 inline flecs::world iter::world() const {
-    return flecs::world(m_iter->world);
+    return flecs::world(iter_->world);
 }
 
 inline flecs::entity iter::entity(size_t row) const {
-    ecs_assert(row < static_cast<size_t>(m_iter->count), 
+    ecs_assert(row < static_cast<size_t>(iter_->count), 
         ECS_COLUMN_INDEX_OUT_OF_RANGE, NULL);
-    return flecs::entity(m_iter->world, m_iter->entities[row]);
+    return flecs::entity(iter_->world, iter_->entities[row]);
 }
 
 inline flecs::entity iter::src(int32_t index) const {
-    return flecs::entity(m_iter->world, ecs_field_src(m_iter, index));
+    return flecs::entity(iter_->world, ecs_field_src(iter_, index));
 }
 
 inline flecs::id iter::id(int32_t index) const {
-    return flecs::id(m_iter->world, ecs_field_id(m_iter, index));
+    return flecs::id(iter_->world, ecs_field_id(iter_, index));
 }
 
 inline flecs::id iter::pair(int32_t index) const {
-    flecs::id_t id = ecs_field_id(m_iter, index);
+    flecs::id_t id = ecs_field_id(iter_, index);
     ecs_check(ECS_HAS_ID_FLAG(id, PAIR), ECS_INVALID_PARAMETER, NULL);
-    return flecs::id(m_iter->world, id);
+    return flecs::id(iter_->world, id);
 error:
     return flecs::id();
 }
 
 inline flecs::type iter::type() const {
-    return flecs::type(m_iter->world, ecs_table_get_type(m_iter->table));
+    return flecs::type(iter_->world, ecs_table_get_type(iter_->table));
 }
 
 inline flecs::table iter::table() const {
-    return flecs::table(m_iter->real_world, m_iter->table);
+    return flecs::table(iter_->real_world, iter_->table);
 }
 
 inline flecs::table_range iter::range() const {
-    return flecs::table_range(m_iter->real_world, m_iter->table, 
-        m_iter->offset, m_iter->count);
+    return flecs::table_range(iter_->real_world, iter_->table, 
+        iter_->offset, iter_->count);
 }
 
 template <typename T, typename A,
     typename std::enable_if<std::is_const<T>::value, void>::type*>
 inline flecs::field<A> iter::field(int32_t index) const {
-    ecs_assert(!(m_iter->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
+    ecs_assert(!(iter_->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
         "cannot .field from .each, use .field_at<const %s>(%d, row) instead",
             _::type_name<T>(), index);
     return get_field<A>(index);
@@ -72,10 +72,10 @@ template <typename T, typename A,
     typename std::enable_if<
         std::is_const<T>::value == false, void>::type*>
 inline flecs::field<A> iter::field(int32_t index) const {
-    ecs_assert(!(m_iter->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
+    ecs_assert(!(iter_->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
         "cannot .field from .each, use .field_at<%s>(%d, row) instead",
             _::type_name<T>(), index);
-    ecs_assert(!ecs_field_is_readonly(m_iter, index),
+    ecs_assert(!ecs_field_is_readonly(iter_, index),
         ECS_ACCESS_VIOLATION, NULL);
     return get_field<A>(index);
 }
@@ -83,18 +83,18 @@ inline flecs::field<A> iter::field(int32_t index) const {
 #ifdef FLECS_RULES
 inline flecs::entity iter::get_var(int var_id) const {
     ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, 0);
-    return flecs::entity(m_iter->world, ecs_iter_get_var(m_iter, var_id));
+    return flecs::entity(iter_->world, ecs_iter_get_var(iter_, var_id));
 }
 
 /** Get value of variable by name.
  * Get value of a query variable for current result.
  */
 inline flecs::entity iter::get_var(const char *name) const {
-    ecs_rule_iter_t *rit = &m_iter->priv.iter.rule;
-    const flecs::rule_t *r = rit->rule;
-    int var_id = ecs_rule_find_var(r, name);
+    ecs_query_iter_t *qit = &iter_->priv_.iter.query;
+    const flecs::query_t *q = qit->query;
+    int var_id = ecs_query_find_var(q, name);
     ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
-    return flecs::entity(m_iter->world, ecs_iter_get_var(m_iter, var_id));
+    return flecs::entity(iter_->world, ecs_iter_get_var(iter_, var_id));
 }
 #endif
 
diff --git a/include/flecs/addons/cpp/impl/world.hpp b/include/flecs/addons/cpp/impl/world.hpp
index 55d24b0ee..18a53751d 100644
--- a/include/flecs/addons/cpp/impl/world.hpp
+++ b/include/flecs/addons/cpp/impl/world.hpp
@@ -11,9 +11,7 @@ namespace flecs
 inline void world::init_builtin_components() {
     this->component<Component>();
     this->component<Identifier>();
-    this->component<Iterable>("flecs::core::Iterable");
     this->component<Poly>();
-    this->component<FlattenTarget>();
 
 #   ifdef FLECS_SYSTEM
     _::system_init(*this);
@@ -34,22 +32,22 @@ inline void world::init_builtin_components() {
 
 template <typename T>
 inline flecs::entity world::use(const char *alias) const {
-    entity_t e = _::cpp_type<T>::id(m_world);
+    entity_t e = _::type<T>::id(world_);
     const char *name = alias;
     if (!name) {
         // If no name is defined, use the entity name without the scope
-        name = ecs_get_name(m_world, e);
+        name = ecs_get_name(world_, e);
     }
-    ecs_set_alias(m_world, e, name);
-    return flecs::entity(m_world, e);
+    ecs_set_alias(world_, e, name);
+    return flecs::entity(world_, e);
 }
 
 inline flecs::entity world::use(const char *name, const char *alias) const {
-    entity_t e = ecs_lookup_path_w_sep(m_world, 0, name, "::", "::", true);
+    entity_t e = ecs_lookup_path_w_sep(world_, 0, name, "::", "::", true);
     ecs_assert(e != 0, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_set_alias(m_world, e, alias);
-    return flecs::entity(m_world, e);
+    ecs_set_alias(world_, e, alias);
+    return flecs::entity(world_, e);
 }
 
 inline void world::use(flecs::entity e, const char *alias) const {
@@ -57,163 +55,163 @@ inline void world::use(flecs::entity e, const char *alias) const {
     const char *name = alias;
     if (!name) {
         // If no name is defined, use the entity name without the scope
-        name = ecs_get_name(m_world, eid);
+        name = ecs_get_name(world_, eid);
     }
-    ecs_set_alias(m_world, eid, name);
+    ecs_set_alias(world_, eid, name);
 }
 
 inline flecs::entity world::set_scope(const flecs::entity_t s) const {
-    return flecs::entity(ecs_set_scope(m_world, s));
+    return flecs::entity(ecs_set_scope(world_, s));
 }
 
 inline flecs::entity world::get_scope() const {
-    return flecs::entity(m_world, ecs_get_scope(m_world));
+    return flecs::entity(world_, ecs_get_scope(world_));
 }
 
 template <typename T>
 inline flecs::entity world::set_scope() const {
-    return set_scope( _::cpp_type<T>::id(m_world) ); 
+    return set_scope( _::type<T>::id(world_) ); 
 }
 
-inline entity world::lookup(const char *name, bool search_path) const {
-    auto e = ecs_lookup_path_w_sep(m_world, 0, name, "::", "::", search_path);
+inline entity world::lookup(const char *name, const char *sep, const char *root_sep, bool recursive) const {
+    auto e = ecs_lookup_path_w_sep(world_, 0, name, sep, root_sep, recursive);
     return flecs::entity(*this, e);
 }
 
 #ifndef ensure
 template <typename T>
 inline T& world::ensure() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.ensure<T>();
 }
 #endif
 
 template <typename T>
 inline void world::modified() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     e.modified<T>();
 }
 
 template <typename First, typename Second>
 inline void world::set(Second second, const First& value) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.set<First>(second, value);
 }
 
 template <typename First, typename Second>
 inline void world::set(Second second, First&& value) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.set<First>(second, value);
 }
 
 template <typename T>
 inline ref<T> world::get_ref() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.get_ref<T>();
 }
 
 template <typename T>
 inline const T* world::get() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.get<T>();
 }
 
 template <typename First, typename Second, typename P, typename A>
 const A* world::get() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.get<First, Second>();
 }
 
 template <typename First, typename Second>
 const First* world::get(Second second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.get<First>(second);
 }
 
 template <typename T>
 T* world::get_mut() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.get_mut<T>();
 }
 
 template <typename First, typename Second, typename P, typename A>
 A* world::get_mut() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.get_mut<First, Second>();
 }
 
 template <typename First, typename Second>
 First* world::get_mut(Second second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.get_mut<First>(second);
 }
 
 template <typename T>
 inline bool world::has() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     return e.has<T>();
 }
 
 template <typename First, typename Second>
 inline bool world::has() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.has<First, Second>();
 }
 
 template <typename First>
 inline bool world::has(flecs::id_t second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     return e.has<First>(second);
 }
 
 inline bool world::has(flecs::id_t first, flecs::id_t second) const {
-    flecs::entity e(m_world, first);
+    flecs::entity e(world_, first);
     return e.has(first, second);
 }
 
 template <typename T>
 inline void world::add() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     e.add<T>();
 }
 
 template <typename First, typename Second>
 inline void world::add() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.add<First, Second>();
 }
 
 template <typename First>
 inline void world::add(flecs::entity_t second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.add<First>(second);
 }
 
 inline void world::add(flecs::entity_t first, flecs::entity_t second) const {
-    flecs::entity e(m_world, first);
+    flecs::entity e(world_, first);
     e.add(first, second);
 }
 
 template <typename T>
 inline void world::remove() const {
-    flecs::entity e(m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e(world_, _::type<T>::id(world_));
     e.remove<T>();
 }
 
 template <typename First, typename Second>
 inline void world::remove() const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.remove<First, Second>();
 }
 
 template <typename First>
 inline void world::remove(flecs::entity_t second) const {
-    flecs::entity e(m_world, _::cpp_type<First>::id(m_world));
+    flecs::entity e(world_, _::type<First>::id(world_));
     e.remove<First>(second);
 }
 
 inline void world::remove(flecs::entity_t first, flecs::entity_t second) const {
-    flecs::entity e(m_world, first);
+    flecs::entity e(world_, first);
     e.remove(first, second);
 }
 
@@ -224,14 +222,14 @@ inline void world::children(Func&& f) const {
 
 template <typename T>
 inline flecs::entity world::singleton() const {
-    return flecs::entity(m_world, _::cpp_type<T>::id(m_world));
+    return flecs::entity(world_, _::type<T>::id(world_));
 }
 
 template <typename First>
 inline flecs::entity world::target(int32_t index) const
 {
-    return flecs::entity(m_world,
-        ecs_get_target(m_world, _::cpp_type<First>::id(m_world), _::cpp_type<First>::id(m_world), index));
+    return flecs::entity(world_,
+        ecs_get_target(world_, _::type<First>::id(world_), _::type<First>::id(world_), index));
 }
 
 template <typename T>
@@ -239,40 +237,40 @@ inline flecs::entity world::target(
     flecs::entity_t relationship,
     int32_t index) const
 {
-    return flecs::entity(m_world,
-        ecs_get_target(m_world, _::cpp_type<T>::id(m_world), relationship, index));
+    return flecs::entity(world_,
+        ecs_get_target(world_, _::type<T>::id(world_), relationship, index));
 }
 
 inline flecs::entity world::target(
     flecs::entity_t relationship,
     int32_t index) const
 {
-    return flecs::entity(m_world,
-        ecs_get_target(m_world, relationship, relationship, index));
+    return flecs::entity(world_,
+        ecs_get_target(world_, relationship, relationship, index));
 }
 
 template <typename Func, if_t< is_callable<Func>::value > >
 inline void world::get(const Func& func) const {
     static_assert(arity<Func>::value == 1, "singleton component must be the only argument");
     _::entity_with_delegate<Func>::invoke_get(
-        this->m_world, this->singleton<first_arg_t<Func>>(), func);
+        this->world_, this->singleton<first_arg_t<Func>>(), func);
 }
 
 template <typename Func, if_t< is_callable<Func>::value > >
 inline void world::set(const Func& func) const {
     static_assert(arity<Func>::value == 1, "singleton component must be the only argument");
     _::entity_with_delegate<Func>::invoke_ensure(
-        this->m_world, this->singleton<first_arg_t<Func>>(), func);
+        this->world_, this->singleton<first_arg_t<Func>>(), func);
 }
 
 inline flecs::entity world::get_alive(flecs::entity_t e) const {
-    e = ecs_get_alive(m_world, e);
-    return flecs::entity(m_world, e);
+    e = ecs_get_alive(world_, e);
+    return flecs::entity(world_, e);
 }
 
 inline flecs::entity world::make_alive(flecs::entity_t e) const {
-    ecs_make_alive(m_world, e);
-    return flecs::entity(m_world, e);
+    ecs_make_alive(world_, e);
+    return flecs::entity(world_, e);
 }
 
 template <typename E>
@@ -289,7 +287,7 @@ inline flecs::entity enum_data<E>::entity(underlying_type_t<E> value) const {
 #ifdef FLECS_META
     // Reflection data lookup failed. Try value lookup amongst flecs::Constant relationships
     flecs::world world = flecs::world(world_);
-    return world.filter_builder()
+    return world.query_builder()
         .with(flecs::ChildOf, world.id<E>())
         .with(flecs::Constant, world.id<int32_t>())
         .build()
@@ -312,13 +310,13 @@ inline flecs::entity enum_data<E>::entity(E value) const {
  * Operations need to be ran in a single statement.
  */
 inline flecs::scoped_world world::scope(id_t parent) const {
-    return scoped_world(m_world, parent);
+    return scoped_world(world_, parent);
 }
 
 template <typename T>
 inline flecs::scoped_world world::scope() const {
-    flecs::id_t parent = _::cpp_type<T>::id(m_world);
-    return scoped_world(m_world, parent);
+    flecs::id_t parent = _::type<T>::id(world_);
+    return scoped_world(world_, parent);
 }
 
 inline flecs::scoped_world world::scope(const char* name) const {
diff --git a/include/flecs/addons/cpp/iter.hpp b/include/flecs/addons/cpp/iter.hpp
index 3a6afde5f..b95e3d21d 100644
--- a/include/flecs/addons/cpp/iter.hpp
+++ b/include/flecs/addons/cpp/iter.hpp
@@ -30,26 +30,26 @@ template <typename T>
 struct range_iterator
 {
     explicit range_iterator(T value)
-        : m_value(value){}
+        : value_(value){}
 
     bool operator!=(range_iterator const& other) const
     {
-        return m_value != other.m_value;
+        return value_ != other.value_;
     }
 
     T const& operator*() const
     {
-        return m_value;
+        return value_;
     }
 
     range_iterator& operator++()
     {
-        ++m_value;
+        ++value_;
         return *this;
     }
 
 private:
-    T m_value;
+    T value_;
 };
 
 } // namespace _
@@ -75,17 +75,17 @@ struct iter {
      *
      * @param it Pointer to C iterator.
      */
-    iter(ecs_iter_t *it) : m_iter(it) {
-        m_begin = 0;
-        m_end = static_cast<std::size_t>(it->count);
+    iter(ecs_iter_t *it) : iter_(it) {
+        begin_ = 0;
+        end_ = static_cast<std::size_t>(it->count);
     }
 
     row_iterator begin() const {
-        return row_iterator(m_begin);
+        return row_iterator(begin_);
     }
 
     row_iterator end() const {
-        return row_iterator(m_end);
+        return row_iterator(end_);
     }
 
     flecs::entity system() const;
@@ -97,19 +97,19 @@ struct iter {
     flecs::world world() const;
 
     const flecs::iter_t* c_ptr() const {
-        return m_iter;
+        return iter_;
     }
 
     size_t count() const {
-        return static_cast<size_t>(m_iter->count);
+        return static_cast<size_t>(iter_->count);
     }
 
     ecs_ftime_t delta_time() const {
-        return m_iter->delta_time;
+        return iter_->delta_time;
     }
 
     ecs_ftime_t delta_system_time() const {
-        return m_iter->delta_system_time;
+        return iter_->delta_system_time;
     }
 
     flecs::type type() const;
@@ -122,7 +122,7 @@ struct iter {
      * ctx contains the context pointer assigned to a system.
      */
     void* ctx() {
-        return m_iter->ctx;
+        return iter_->ctx;
     }
 
     /** Access ctx.
@@ -130,14 +130,14 @@ struct iter {
      */
     template <typename T>
     T* ctx() {
-        return static_cast<T*>(m_iter->ctx);
+        return static_cast<T*>(iter_->ctx);
     }
 
     /** Access param.
      * param contains the pointer passed to the param argument of system::run
      */
     void* param() {
-        return m_iter->param;
+        return iter_->param;
     }
 
     /** Access param.
@@ -146,7 +146,7 @@ struct iter {
     template <typename T>
     T* param() {
         /* TODO: type check */
-        return static_cast<T*>(m_iter->param);
+        return static_cast<T*>(iter_->param);
     }
 
     /** Obtain mutable handle to entity being iterated over.
@@ -160,7 +160,7 @@ struct iter {
      * @param index The field index.
      */
     bool is_self(int32_t index) const {
-        return ecs_field_is_self(m_iter, index);
+        return ecs_field_is_self(iter_, index);
     }
 
     /** Returns whether field is set.
@@ -168,7 +168,7 @@ struct iter {
      * @param index The field index.
      */
     bool is_set(int32_t index) const {
-        return ecs_field_is_set(m_iter, index);
+        return ecs_field_is_set(iter_, index);
     }
 
     /** Returns whether field is readonly.
@@ -176,13 +176,13 @@ struct iter {
      * @param index The field index.
      */
     bool is_readonly(int32_t index) const {
-        return ecs_field_is_readonly(m_iter, index);
+        return ecs_field_is_readonly(iter_, index);
     }
 
     /** Number of fields in iterator.
      */
     int32_t field_count() const {
-        return m_iter->field_count;
+        return iter_->field_count;
     }
 
     /** Size of field data type.
@@ -190,7 +190,7 @@ struct iter {
      * @param index The field id.
      */
     size_t size(int32_t index) const {
-        return ecs_field_size(m_iter, index);
+        return ecs_field_size(iter_, index);
     }
 
     /** Obtain field source (0 if This).
@@ -217,13 +217,13 @@ struct iter {
      * @param index The field index.
      */
     int32_t column_index(int32_t index) const {
-        return ecs_field_column_index(m_iter, index);
+        return ecs_field_column(iter_, index);
     }
 
     /** Convert current iterator result to string.
      */
     flecs::string str() const {
-        char *s = ecs_iter_str(m_iter);
+        char *s = ecs_iter_str(iter_);
         return flecs::string(s);
     }
 
@@ -259,7 +259,7 @@ struct iter {
      * @param index The field index.
      */
     flecs::untyped_field field(int32_t index) const {
-        ecs_assert(!(m_iter->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
+        ecs_assert(!(iter_->flags & EcsIterCppEach), ECS_INVALID_OPERATION,
             "cannot .field from .each, use .field_at(%d, row) instead", index);
         return get_unchecked_field(index);
     }
@@ -281,7 +281,7 @@ struct iter {
         typename std::enable_if<
             std::is_const<T>::value == false, void>::type* = nullptr>
     A& field_at(int32_t index, size_t row) const {
-        ecs_assert(!ecs_field_is_readonly(m_iter, index),
+        ecs_assert(!ecs_field_is_readonly(iter_, index),
             ECS_ACCESS_VIOLATION, NULL);
         return get_field<A>(index)[row];
     }
@@ -291,18 +291,13 @@ struct iter {
      * @return The entity ids.
      */
     flecs::field<const flecs::entity_t> entities() const {
-        return flecs::field<const flecs::entity_t>(m_iter->entities, static_cast<size_t>(m_iter->count), false);
-    }
-
-    /** Obtain the total number of tables the iterator will iterate over. */
-    int32_t table_count() const {
-        return m_iter->table_count;
+        return flecs::field<const flecs::entity_t>(iter_->entities, static_cast<size_t>(iter_->count), false);
     }
 
     /** Check if the current table has changed since the last iteration.
      * Can only be used when iterating queries and/or systems. */
     bool changed() {
-        return ecs_query_changed(nullptr, m_iter);
+        return ecs_iter_changed(iter_);
     }
 
     /** Skip current table.
@@ -313,12 +308,12 @@ struct iter {
      * When this operation is invoked, the components of the current table will
      * not be marked dirty. */
     void skip() {
-        ecs_query_skip(m_iter);
+        ecs_iter_skip(iter_);
     }
 
     /* Return group id for current table (grouped queries only) */
     uint64_t group_id() const {
-        return m_iter->group_id;
+        return iter_->group_id;
     }
 
 #ifdef FLECS_RULES
@@ -339,14 +334,14 @@ struct iter {
     flecs::field<T> get_field(int32_t index) const {
 
 #ifndef FLECS_NDEBUG
-        ecs_entity_t term_id = ecs_field_id(m_iter, index);
+        ecs_entity_t term_id = ecs_field_id(iter_, index);
         ecs_assert(ECS_HAS_ID_FLAG(term_id, PAIR) ||
-            term_id == _::cpp_type<T>::id(m_iter->world),
+            term_id == _::type<T>::id(iter_->world),
             ECS_COLUMN_TYPE_MISMATCH, NULL);
 #endif
 
         size_t count;
-        bool is_shared = !ecs_field_is_self(m_iter, index);
+        bool is_shared = !ecs_field_is_self(iter_, index);
 
         /* If a shared column is retrieved with 'column', there will only be a
          * single value. Ensure that the application does not accidentally read
@@ -356,18 +351,18 @@ struct iter {
         } else {
             /* If column is owned, there will be as many values as there are
              * entities. */
-            count = static_cast<size_t>(m_iter->count);
+            count = static_cast<size_t>(iter_->count);
         }
 
         return flecs::field<A>(
-            static_cast<T*>(ecs_field_w_size(m_iter, sizeof(A), index)),
+            static_cast<T*>(ecs_field_w_size(iter_, sizeof(A), index)),
             count, is_shared);
     }
 
     flecs::untyped_field get_unchecked_field(int32_t index) const {
         size_t count;
-        size_t size = ecs_field_size(m_iter, index);
-        bool is_shared = !ecs_field_is_self(m_iter, index);
+        size_t size = ecs_field_size(iter_, index);
+        bool is_shared = !ecs_field_is_self(iter_, index);
 
         /* If a shared column is retrieved with 'column', there will only be a
          * single value. Ensure that the application does not accidentally read
@@ -377,16 +372,16 @@ struct iter {
         } else {
             /* If column is owned, there will be as many values as there are
              * entities. */
-            count = static_cast<size_t>(m_iter->count);
+            count = static_cast<size_t>(iter_->count);
         }
 
         return flecs::untyped_field(
-            ecs_field_w_size(m_iter, 0, index), size, count, is_shared);
+            ecs_field_w_size(iter_, 0, index), size, count, is_shared);
     }
 
-    flecs::iter_t *m_iter;
-    std::size_t m_begin;
-    std::size_t m_end;
+    flecs::iter_t *iter_;
+    std::size_t begin_;
+    std::size_t end_;
 };
 
 } // namespace flecs
diff --git a/include/flecs/addons/cpp/mixins/alerts/builder.hpp b/include/flecs/addons/cpp/mixins/alerts/builder.hpp
index 4f0ccdcc3..9c525b496 100644
--- a/include/flecs/addons/cpp/mixins/alerts/builder.hpp
+++ b/include/flecs/addons/cpp/mixins/alerts/builder.hpp
@@ -31,7 +31,7 @@ struct alert_builder final : _::alert_builder_base<Components...> {
             entity_desc.name = name;
             entity_desc.sep = "::";
             entity_desc.root_sep = "::";
-            this->m_desc.entity = ecs_entity_init(world, &entity_desc);
+            this->desc_.entity = ecs_entity_init(world, &entity_desc);
         }
     }
 };
diff --git a/include/flecs/addons/cpp/mixins/alerts/builder_i.hpp b/include/flecs/addons/cpp/mixins/alerts/builder_i.hpp
index c121eb56f..47d521edf 100644
--- a/include/flecs/addons/cpp/mixins/alerts/builder_i.hpp
+++ b/include/flecs/addons/cpp/mixins/alerts/builder_i.hpp
@@ -5,7 +5,7 @@
 
 #pragma once
 
-#include "../filter/builder_i.hpp"
+#include "../query/builder_i.hpp"
 
 namespace flecs {
 
@@ -14,25 +14,25 @@ namespace flecs {
  * @ingroup cpp_addons_alerts
  */
 template<typename Base, typename ... Components>
-struct alert_builder_i : filter_builder_i<Base, Components ...> {
+struct alert_builder_i : query_builder_i<Base, Components ...> {
 private:
-    using BaseClass = filter_builder_i<Base, Components ...>;
-    
+    using BaseClass = query_builder_i<Base, Components ...>;
+
 public:
     alert_builder_i()
         : BaseClass(nullptr)
-        , m_desc(nullptr) { }
+        , desc_(nullptr) { }
 
     alert_builder_i(ecs_alert_desc_t *desc, int32_t term_index = 0) 
-        : BaseClass(&desc->filter, term_index)
-        , m_desc(desc) { }
+        : BaseClass(&desc->query, term_index)
+        , desc_(desc) { }
 
     /** Alert message.
      *
      * @see ecs_alert_desc_t::message
      */      
     Base& message(const char *message) {
-        m_desc->message = message;
+        desc_->message = message;
         return *this;
     }
 
@@ -41,7 +41,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      * @see ecs_alert_desc_t::brief
      */
     Base& brief(const char *brief) {
-        m_desc->brief = brief;
+        desc_->brief = brief;
         return *this;
     }
 
@@ -50,7 +50,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      * @see ecs_alert_desc_t::doc_name
      */
     Base& doc_name(const char *doc_name) {
-        m_desc->doc_name = doc_name;
+        desc_->doc_name = doc_name;
         return *this;
     }
 
@@ -59,7 +59,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      * @see ecs_alert_desc_t::severity
      */
     Base& severity(flecs::entity_t kind) {
-        m_desc->severity = kind;
+        desc_->severity = kind;
         return *this;
     }
 
@@ -68,7 +68,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      * @see ecs_alert_desc_t::retain_period
      */
     Base& retain_period(ecs_ftime_t period) {
-        m_desc->retain_period = period;
+        desc_->retain_period = period;
         return *this;
     }
 
@@ -78,7 +78,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
      */
     template <typename Severity>
     Base& severity() {
-        return severity(_::cpp_type<Severity>::id(world_v()));
+        return severity(_::type<Severity>::id(world_v()));
     }
 
     /** Add severity filter */
@@ -87,7 +87,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
             ECS_INVALID_PARAMETER, "Maximum number of severity filters reached");
 
         ecs_alert_severity_filter_t *filter = 
-            &m_desc->severity_filters[severity_filter_count ++];
+            &desc_->severity_filters[severity_filter_count ++];
 
         filter->severity = kind;
         filter->with = with;
@@ -98,14 +98,14 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
     /** Add severity filter */
     template <typename Severity>
     Base& severity_filter(flecs::id_t with, const char *var = nullptr) {
-        return severity_filter(_::cpp_type<Severity>::id(world_v()), with, var);
+        return severity_filter(_::type<Severity>::id(world_v()), with, var);
     }
 
     /** Add severity filter */
     template <typename Severity, typename T, if_not_t< is_enum<T>::value > = 0>
     Base& severity_filter(const char *var = nullptr) {
-        return severity_filter(_::cpp_type<Severity>::id(world_v()), 
-            _::cpp_type<T>::id(world_v()), var);
+        return severity_filter(_::type<Severity>::id(world_v()), 
+            _::type<T>::id(world_v()), var);
     }
 
     /** Add severity filter */
@@ -113,37 +113,37 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
     Base& severity_filter(T with, const char *var = nullptr) {
         flecs::world w(world_v());
         flecs::entity constant = w.to_entity<T>(with);
-        return severity_filter(_::cpp_type<Severity>::id(world_v()), 
+        return severity_filter(_::type<Severity>::id(world_v()), 
             w.pair<T>(constant), var);
     }
 
     /** Set member to create an alert for out of range values */
     Base& member(flecs::entity_t m) {
-        m_desc->member = m;
+        desc_->member = m;
         return *this;
     }
 
     /** Set (component) id for member (optional). If .member() is set and id
      * is not set, the id will default to the member parent. */
     Base& id(flecs::id_t id) {
-        m_desc->id = id;
+        desc_->id = id;
         return *this;
     }
 
     /** Set member to create an alert for out of range values */
     template <typename T>
     Base& member(const char *m, const char *v = nullptr) {
-        flecs::entity_t id = _::cpp_type<T>::id(world_v());
+        flecs::entity_t id = _::type<T>::id(world_v());
         flecs::entity_t mid = ecs_lookup_path_w_sep(
             world_v(), id, m, "::", "::", false);
         ecs_assert(m != 0, ECS_INVALID_PARAMETER, NULL);
-        m_desc->var = v;
+        desc_->var = v;
         return this->member(mid);
     }
 
     /** Set source variable for member (optional, defaults to $this) */
     Base& var(const char *v) {
-        m_desc->var = v;
+        desc_->var = v;
         return *this;
     }
 
@@ -155,7 +155,7 @@ struct alert_builder_i : filter_builder_i<Base, Components ...> {
         return *static_cast<Base*>(this);
     }
 
-    ecs_alert_desc_t *m_desc;
+    ecs_alert_desc_t *desc_;
     int32_t severity_filter_count = 0;
 };
 
diff --git a/include/flecs/addons/cpp/mixins/alerts/entity_view.inl b/include/flecs/addons/cpp/mixins/alerts/entity_view.inl
index 6b8c83765..d46832b5b 100644
--- a/include/flecs/addons/cpp/mixins/alerts/entity_view.inl
+++ b/include/flecs/addons/cpp/mixins/alerts/entity_view.inl
@@ -9,5 +9,5 @@
  * @ingroup cpp_addons_alerts
  */
 int32_t alert_count(flecs::entity_t alert = 0) const {
-    return ecs_get_alert_count(m_world, m_id, alert);
+    return ecs_get_alert_count(world_, id_, alert);
 }
diff --git a/include/flecs/addons/cpp/mixins/alerts/impl.hpp b/include/flecs/addons/cpp/mixins/alerts/impl.hpp
index 120a7f108..b01c4dd6c 100644
--- a/include/flecs/addons/cpp/mixins/alerts/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/alerts/impl.hpp
@@ -15,18 +15,13 @@ struct alert final : entity
     using entity::entity;
 
     explicit alert() {
-        m_id = 0;
-        m_world = nullptr;
+        id_ = 0;
+        world_ = nullptr;
     }
 
-    explicit alert(flecs::world_t *world, ecs_alert_desc_t *desc) 
-    {
-        m_world = world;
-        m_id = ecs_alert_init(world, desc);
-
-        if (desc->filter.terms_buffer) {
-            ecs_os_free(desc->filter.terms_buffer);
-        }
+    explicit alert(flecs::world_t *world, ecs_alert_desc_t *desc) {
+        world_ = world;
+        id_ = ecs_alert_init(world, desc);
     }
 };
 
@@ -47,7 +42,7 @@ inline alerts::alerts(flecs::world& world) {
 
 template <typename... Comps, typename... Args>
 inline flecs::alert_builder<Comps...> world::alert(Args &&... args) const {
-    return flecs::alert_builder<Comps...>(m_world, FLECS_FWD(args)...);
+    return flecs::alert_builder<Comps...>(world_, FLECS_FWD(args)...);
 }
 
 }
diff --git a/include/flecs/addons/cpp/mixins/app/builder.hpp b/include/flecs/addons/cpp/mixins/app/builder.hpp
index 1748789c6..9058670ed 100644
--- a/include/flecs/addons/cpp/mixins/app/builder.hpp
+++ b/include/flecs/addons/cpp/mixins/app/builder.hpp
@@ -18,72 +18,74 @@ namespace flecs {
 /** App builder interface */
 struct app_builder {
     app_builder(flecs::world_t *world)
-        : m_world(world)
-        , m_desc{}
+        : world_(world)
+        , desc_{}
     {
         const ecs_world_info_t *stats = ecs_get_world_info(world);
-        m_desc.target_fps = stats->target_fps;
+        desc_.target_fps = stats->target_fps;
         ecs_ftime_t t_zero = 0.0;
-        if (ECS_EQ(m_desc.target_fps, t_zero)) {
-            m_desc.target_fps = 60;
+        if (ECS_EQ(desc_.target_fps, t_zero)) {
+            desc_.target_fps = 60;
         }
     }
 
     app_builder& target_fps(ecs_ftime_t value) {
-        m_desc.target_fps = value;
+        desc_.target_fps = value;
         return *this;
     }
 
     app_builder& delta_time(ecs_ftime_t value) {
-        m_desc.delta_time = value;
+        desc_.delta_time = value;
         return *this;
     }
 
     app_builder& threads(int32_t value) {
-        m_desc.threads = value;
+        desc_.threads = value;
         return *this;
     }
 
     app_builder& frames(int32_t value) {
-        m_desc.frames = value;
+        desc_.frames = value;
         return *this;
     }
 
     app_builder& enable_rest(uint16_t port = 0) {
-        m_desc.enable_rest = true;
-        m_desc.port = port;
+        desc_.enable_rest = true;
+        desc_.port = port;
         return *this;
     }
 
     app_builder& enable_monitor(bool value = true) {
-        m_desc.enable_monitor = value;
+        desc_.enable_monitor = value;
         return *this;
     }
 
     app_builder& init(ecs_app_init_action_t value) {
-        m_desc.init = value;
+        desc_.init = value;
         return *this;
     }
 
     app_builder& ctx(void *value) {
-        m_desc.ctx = value;
+        desc_.ctx = value;
         return *this;
     }
 
     int run() {
-        int result = ecs_app_run(m_world, &m_desc);
-        if (ecs_should_quit(m_world)) {
+        int result = ecs_app_run(world_, &desc_);
+        if (ecs_should_quit(world_)) {
             // Only free world if quit flag is set. This ensures that we won't
             // try to cleanup the world if the app is used in an environment
             // that takes over the main loop, like with emscripten.
-            ecs_fini(m_world);
+            if (!flecs_poly_release(world_)) {
+                ecs_fini(world_);
+            }
         }
         return result;
     }
 
 private:
-    flecs::world_t *m_world;
-    ecs_app_desc_t m_desc;
+    flecs::world_t *world_;
+    ecs_app_desc_t desc_;
 };
 
 /** @} */
diff --git a/include/flecs/addons/cpp/mixins/app/mixin.inl b/include/flecs/addons/cpp/mixins/app/mixin.inl
index daa7784d0..dee812985 100644
--- a/include/flecs/addons/cpp/mixins/app/mixin.inl
+++ b/include/flecs/addons/cpp/mixins/app/mixin.inl
@@ -17,8 +17,9 @@
  * required for frameworks like emscripten.
  */
 flecs::app_builder app() {
-    m_owned = false; // App takes ownership of world
-    return flecs::app_builder(m_world);
+    flecs::world_t *w = world_;
+    world_ = nullptr; // Take ownership
+    return flecs::app_builder(w);
 }
 
 /** @} */
diff --git a/include/flecs/addons/cpp/mixins/component/impl.hpp b/include/flecs/addons/cpp/mixins/component/impl.hpp
index 059e7ff84..fe77fcc57 100644
--- a/include/flecs/addons/cpp/mixins/component/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/component/impl.hpp
@@ -9,12 +9,12 @@ namespace flecs {
 
 template <typename T, typename... Args>
 inline flecs::component<T> world::component(Args &&... args) const {
-    return flecs::component<T>(m_world, FLECS_FWD(args)...);
+    return flecs::component<T>(world_, FLECS_FWD(args)...);
 }
 
 template <typename... Args>
 inline flecs::untyped_component world::component(Args &&... args) const {
-    return flecs::untyped_component(m_world, FLECS_FWD(args)...);
+    return flecs::untyped_component(world_, FLECS_FWD(args)...);
 }
 
 } // namespace flecs
diff --git a/include/flecs/addons/cpp/mixins/doc/entity_builder.inl b/include/flecs/addons/cpp/mixins/doc/entity_builder.inl
index 67a05c492..f43d96903 100644
--- a/include/flecs/addons/cpp/mixins/doc/entity_builder.inl
+++ b/include/flecs/addons/cpp/mixins/doc/entity_builder.inl
@@ -14,7 +14,7 @@
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_name(const char *name) {
-    ecs_doc_set_name(m_world, m_id, name);
+    ecs_doc_set_name(world_, id_, name);
     return to_base();
 }
 
@@ -29,7 +29,7 @@ Self& set_doc_name(const char *name) {
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_brief(const char *brief) {
-    ecs_doc_set_brief(m_world, m_id, brief);
+    ecs_doc_set_brief(world_, id_, brief);
     return to_base();
 }
 
@@ -44,7 +44,7 @@ Self& set_doc_brief(const char *brief) {
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_detail(const char *detail) {
-    ecs_doc_set_detail(m_world, m_id, detail);
+    ecs_doc_set_detail(world_, id_, detail);
     return to_base();
 }
 
@@ -59,7 +59,7 @@ Self& set_doc_detail(const char *detail) {
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_link(const char *link) {
-    ecs_doc_set_link(m_world, m_id, link);
+    ecs_doc_set_link(world_, id_, link);
     return to_base();
 }
 
@@ -74,6 +74,6 @@ Self& set_doc_link(const char *link) {
  * @ingroup cpp_addons_doc
  */
 Self& set_doc_color(const char *link) {
-    ecs_doc_set_color(m_world, m_id, link);
+    ecs_doc_set_color(world_, id_, link);
     return to_base();
 }
diff --git a/include/flecs/addons/cpp/mixins/doc/entity_view.inl b/include/flecs/addons/cpp/mixins/doc/entity_view.inl
index b83e7b607..f78c45309 100644
--- a/include/flecs/addons/cpp/mixins/doc/entity_view.inl
+++ b/include/flecs/addons/cpp/mixins/doc/entity_view.inl
@@ -13,7 +13,7 @@
  * @ingroup cpp_addons_doc
  */
 const char* doc_name() const {
-    return ecs_doc_get_name(m_world, m_id);
+    return ecs_doc_get_name(world_, id_);
 }
 
 /** Get brief description.
@@ -26,7 +26,7 @@ const char* doc_name() const {
  * @ingroup cpp_addons_doc
  */
 const char* doc_brief() const {
-    return ecs_doc_get_brief(m_world, m_id);
+    return ecs_doc_get_brief(world_, id_);
 }
 
 /** Get detailed description.
@@ -39,7 +39,7 @@ const char* doc_brief() const {
  * @ingroup cpp_addons_doc
  */
 const char* doc_detail() const {
-    return ecs_doc_get_detail(m_world, m_id);
+    return ecs_doc_get_detail(world_, id_);
 }
 
 /** Get link to external documentation.
@@ -52,7 +52,7 @@ const char* doc_detail() const {
  * @ingroup cpp_addons_doc
  */
 const char* doc_link() const {
-    return ecs_doc_get_link(m_world, m_id);
+    return ecs_doc_get_link(world_, id_);
 }
 
 /** Get color.
@@ -65,5 +65,5 @@ const char* doc_link() const {
  * @ingroup cpp_addons_doc
  */
 const char* doc_color() const {
-    return ecs_doc_get_color(m_world, m_id);
+    return ecs_doc_get_color(world_, id_);
 }
diff --git a/include/flecs/addons/cpp/mixins/entity/builder.hpp b/include/flecs/addons/cpp/mixins/entity/builder.hpp
index 6d8ab5f41..7232e3ca6 100644
--- a/include/flecs/addons/cpp/mixins/entity/builder.hpp
+++ b/include/flecs/addons/cpp/mixins/entity/builder.hpp
@@ -25,7 +25,7 @@ struct entity_builder : entity_view {
     Self& add() {
         flecs_static_assert(is_flecs_constructible<T>::value,
             "cannot default construct type: add T::T() or use emplace<T>()");
-        ecs_add_id(this->m_world, this->m_id, _::cpp_type<T>::id(this->m_world));
+        ecs_add_id(this->world_, this->id_, _::type<T>::id(this->world_));
         return to_base();
     }
 
@@ -40,8 +40,8 @@ struct entity_builder : entity_view {
      */
     template <typename E, if_t< is_enum<E>::value > = 0>
     Self& add(E value) {
-        flecs::entity_t first = _::cpp_type<E>::id(this->m_world);
-        const auto& et = enum_type<E>(this->m_world);
+        flecs::entity_t first = _::type<E>::id(this->world_);
+        const auto& et = enum_type<E>(this->world_);
         flecs::entity_t second = et.entity(value);
 
         ecs_assert(second, ECS_INVALID_PARAMETER, "Component was not found in reflection data.");
@@ -54,7 +54,7 @@ struct entity_builder : entity_view {
      * @param component The component to add.
      */
     Self& add(id_t component) {
-        ecs_add_id(this->m_world, this->m_id, component);
+        ecs_add_id(this->world_, this->id_, component);
         return to_base();
     }
 
@@ -65,7 +65,7 @@ struct entity_builder : entity_view {
      * @param second The second element of the pair.
      */
     Self& add(entity_t first, entity_t second) {
-        ecs_add_pair(this->m_world, this->m_id, first, second);
+        ecs_add_pair(this->world_, this->id_, first, second);
         return to_base();
     }
 
@@ -77,7 +77,7 @@ struct entity_builder : entity_view {
      */
     template<typename First, typename Second>
     Self& add() {
-        return this->add<First>(_::cpp_type<Second>::id(this->m_world));
+        return this->add<First>(_::type<Second>::id(this->world_));
     }
 
     /** Add a pair.
@@ -90,7 +90,7 @@ struct entity_builder : entity_view {
     Self& add(Second second) {
         flecs_static_assert(is_flecs_constructible<First>::value,
             "cannot default construct type: add T::T() or use emplace<T>()");
-        return this->add(_::cpp_type<First>::id(this->m_world), second);
+        return this->add(_::type<First>::id(this->world_), second);
     }
 
     /** Add a pair.
@@ -104,7 +104,7 @@ struct entity_builder : entity_view {
     Self& add(Second constant) {
         flecs_static_assert(is_flecs_constructible<First>::value,
             "cannot default construct type: add T::T() or use emplace<T>()");
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         return this->add<First>(et.entity(constant));
     }
 
@@ -116,7 +116,7 @@ struct entity_builder : entity_view {
      */
     template<typename Second>
     Self& add_second(flecs::entity_t first) {
-        return this->add(first, _::cpp_type<Second>::id(this->m_world));
+        return this->add(first, _::type<Second>::id(this->world_));
     }
 
     /** Conditional add.
@@ -163,7 +163,7 @@ struct entity_builder : entity_view {
              * second which will remove all instances of the relationship.
              * Replacing 0 with Wildcard will make it possible to use the second
              * as the condition. */
-            if (!second || ecs_has_id(this->m_world, first, flecs::Exclusive)) {
+            if (!second || ecs_has_id(this->world_, first, flecs::Exclusive)) {
                 second = flecs::Wildcard;
             }
             return this->remove(first, second);
@@ -179,7 +179,7 @@ struct entity_builder : entity_view {
      */
     template <typename First>
     Self& add_if(bool cond, flecs::entity_t second) {
-        return this->add_if(cond, _::cpp_type<First>::id(this->m_world), second);
+        return this->add_if(cond, _::type<First>::id(this->world_), second);
     }
 
     /** Conditional add.
@@ -191,7 +191,7 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Second>
     Self& add_if(bool cond) {
-        return this->add_if<First>(cond, _::cpp_type<Second>::id(this->m_world));
+        return this->add_if<First>(cond, _::type<Second>::id(this->world_));
     }
 
     /** Conditional add.
@@ -202,7 +202,7 @@ struct entity_builder : entity_view {
      */
     template <typename E, if_t< is_enum<E>::value > = 0>
     Self& add_if(bool cond, E constant) {
-        const auto& et = enum_type<E>(this->m_world);
+        const auto& et = enum_type<E>(this->world_);
         return this->add_if<E>(cond, et.entity(constant));
     }
 
@@ -220,7 +220,7 @@ struct entity_builder : entity_view {
      */
     template <typename T>
     Self& is_a() {
-        return this->add(flecs::IsA, _::cpp_type<T>::id(this->m_world));
+        return this->add(flecs::IsA, _::type<T>::id(this->world_));
     }
 
     /** Shortcut for add(ChildOf, entity).
@@ -246,7 +246,7 @@ struct entity_builder : entity_view {
     template <typename E, if_t<is_enum<E>::value> = 0>
     Self& depends_on(E second)
     {
-        const auto& et = enum_type<E>(this->m_world);
+        const auto& et = enum_type<E>(this->world_);
         flecs::entity_t target = et.entity(second);
         return depends_on(target);
     }
@@ -262,7 +262,7 @@ struct entity_builder : entity_view {
     /** Shortcut for add(SlotOf, target(ChildOf)).
      */
     Self& slot() {
-        ecs_check(ecs_get_target(m_world, m_id, flecs::ChildOf, 0), 
+        ecs_check(ecs_get_target(world_, id_, flecs::ChildOf, 0), 
             ECS_INVALID_PARAMETER, "add ChildOf pair before using slot()");
         return this->slot_of(this->target(flecs::ChildOf));
     error:
@@ -275,7 +275,7 @@ struct entity_builder : entity_view {
      */
     template <typename T>
     Self& child_of() {
-        return this->child_of(_::cpp_type<T>::id(this->m_world));
+        return this->child_of(_::type<T>::id(this->world_));
     }
  
     /** Shortcut for add(DependsOn, entity).
@@ -284,7 +284,7 @@ struct entity_builder : entity_view {
      */
     template <typename T>
     Self& depends_on() {
-        return this->depends_on(_::cpp_type<T>::id(this->m_world));
+        return this->depends_on(_::type<T>::id(this->world_));
     }
 
     /** Shortcut for add(SlotOf, entity).
@@ -293,7 +293,7 @@ struct entity_builder : entity_view {
      */
     template <typename T>
     Self& slot_of() {
-        return this->slot_of(_::cpp_type<T>::id(this->m_world));
+        return this->slot_of(_::type<T>::id(this->world_));
     }
 
     /** Remove a component from an entity.
@@ -302,7 +302,7 @@ struct entity_builder : entity_view {
      */
     template <typename T, if_not_t< is_enum<T>::value > = 0>
     Self& remove() {
-        ecs_remove_id(this->m_world, this->m_id, _::cpp_type<T>::id(this->m_world));
+        ecs_remove_id(this->world_, this->id_, _::type<T>::id(this->world_));
         return to_base();
     }
 
@@ -313,7 +313,7 @@ struct entity_builder : entity_view {
      */
     template <typename E, if_t< is_enum<E>::value > = 0>
     Self& remove() {
-        flecs::entity_t first = _::cpp_type<E>::id(this->m_world);
+        flecs::entity_t first = _::type<E>::id(this->world_);
         return this->remove(first, flecs::Wildcard);
     }
 
@@ -322,7 +322,7 @@ struct entity_builder : entity_view {
      * @param entity The entity to remove.
      */
     Self& remove(entity_t entity) {
-        ecs_remove_id(this->m_world, this->m_id, entity);
+        ecs_remove_id(this->world_, this->id_, entity);
         return to_base();
     }
 
@@ -333,7 +333,7 @@ struct entity_builder : entity_view {
      * @param second The second element of the pair.
      */
     Self& remove(entity_t first, entity_t second) {
-        ecs_remove_pair(this->m_world, this->m_id, first, second);
+        ecs_remove_pair(this->world_, this->id_, first, second);
         return to_base();
     }
 
@@ -345,7 +345,7 @@ struct entity_builder : entity_view {
      */
     template<typename First, typename Second>
     Self& remove() {
-        return this->remove<First>(_::cpp_type<Second>::id(this->m_world));
+        return this->remove<First>(_::type<Second>::id(this->world_));
     }
 
     /** Remove a pair.
@@ -356,7 +356,7 @@ struct entity_builder : entity_view {
      */
     template<typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
     Self& remove(Second second) {
-        return this->remove(_::cpp_type<First>::id(this->m_world), second);
+        return this->remove(_::type<First>::id(this->world_), second);
     }
 
     /** Removes a pair.
@@ -367,7 +367,7 @@ struct entity_builder : entity_view {
      */
     template<typename Second>
     Self& remove_second(flecs::entity_t first) {
-        return this->remove(first, _::cpp_type<Second>::id(this->m_world));
+        return this->remove(first, _::type<Second>::id(this->world_));
     }
 
     /** Remove a pair.
@@ -378,7 +378,7 @@ struct entity_builder : entity_view {
      */
     template<typename First, typename Second, if_t< is_enum<Second>::value > = 0>
     Self& remove(Second constant) {
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         flecs::entity_t second = et.entity(constant);
         return this->remove<First>(second);
     }  
@@ -411,7 +411,7 @@ struct entity_builder : entity_view {
      */     
     template <typename T>
     Self& override() {
-        return this->override(_::cpp_type<T>::id(this->m_world));
+        return this->override(_::type<T>::id(this->world_));
     }
 
     /** Mark pair for auto-overriding.
@@ -422,7 +422,7 @@ struct entity_builder : entity_view {
      */     
     template <typename First>
     Self& override(flecs::entity_t second) {
-        return this->override(_::cpp_type<First>::id(this->m_world), second);
+        return this->override(_::type<First>::id(this->world_), second);
     }
 
     /** Mark pair for auto-overriding.
@@ -433,7 +433,7 @@ struct entity_builder : entity_view {
      */     
     template <typename First, typename Second>
     Self& override() {
-        return this->override<First>(_::cpp_type<Second>::id(this->m_world));
+        return this->override<First>(_::type<Second>::id(this->world_));
     }
 
     /** Set component, mark component for auto-overriding.
@@ -517,8 +517,8 @@ struct entity_builder : entity_view {
     Self& emplace_override(Args&&... args) {
         this->override<T>();
 
-        flecs::emplace<T>(this->m_world, this->m_id, 
-            _::cpp_type<T>::id(this->m_world), FLECS_FWD(args)...);
+        flecs::emplace<T>(this->world_, this->id_, 
+            _::type<T>::id(this->world_), FLECS_FWD(args)...);
 
         return to_base();  
     }
@@ -535,9 +535,9 @@ struct entity_builder : entity_view {
     Self& emplace_override(Args&&... args) {
         this->override<First, Second>();
 
-        flecs::emplace<A>(this->m_world, this->m_id, 
-            ecs_pair(_::cpp_type<First>::id(this->m_world),
-                _::cpp_type<Second>::id(this->m_world)),
+        flecs::emplace<A>(this->world_, this->id_, 
+            ecs_pair(_::type<First>::id(this->world_),
+                _::type<Second>::id(this->world_)),
                     FLECS_FWD(args)...);
 
         return to_base();  
@@ -548,7 +548,7 @@ struct entity_builder : entity_view {
      * queries.
      */
     Self& enable() {
-        ecs_enable(this->m_world, this->m_id, true);
+        ecs_enable(this->world_, this->id_, true);
         return to_base();
     }
 
@@ -557,7 +557,7 @@ struct entity_builder : entity_view {
      * with queries, unless explicitly specified in the query expression.
      */
     Self& disable() {
-        ecs_enable(this->m_world, this->m_id, false);
+        ecs_enable(this->world_, this->id_, false);
         return to_base();
     }
 
@@ -569,7 +569,7 @@ struct entity_builder : entity_view {
      * @param toggle True to enable, false to disable (default = true).
      */   
     Self& enable(flecs::id_t id, bool toggle = true) {
-        ecs_enable_id(this->m_world, this->m_id, id, toggle);
+        ecs_enable_id(this->world_, this->id_, id, toggle);
         return to_base();       
     }
 
@@ -580,7 +580,7 @@ struct entity_builder : entity_view {
      */   
     template<typename T>
     Self& enable() {
-        return this->enable(_::cpp_type<T>::id(this->m_world));
+        return this->enable(_::type<T>::id(this->world_));
     }
 
     /** Enable a pair.
@@ -601,7 +601,7 @@ struct entity_builder : entity_view {
      */   
     template<typename First>
     Self& enable(flecs::id_t second) {
-        return this->enable(_::cpp_type<First>::id(), second);
+        return this->enable(_::type<First>::id(), second);
     }
 
     /** Enable a pair.
@@ -612,7 +612,7 @@ struct entity_builder : entity_view {
      */   
     template<typename First, typename Second>
     Self& enable() {
-        return this->enable<First>(_::cpp_type<Second>::id());
+        return this->enable<First>(_::type<Second>::id());
     }
 
     /** Disable an id.
@@ -632,7 +632,7 @@ struct entity_builder : entity_view {
      */   
     template<typename T>
     Self& disable() {
-        return this->disable(_::cpp_type<T>::id());
+        return this->disable(_::type<T>::id());
     }
 
     /** Disable a pair.
@@ -653,7 +653,7 @@ struct entity_builder : entity_view {
      */   
     template<typename First>
     Self& disable(flecs::id_t second) {
-        return this->disable(_::cpp_type<First>::id(), second);
+        return this->disable(_::type<First>::id(), second);
     }
 
     /** Disable a pair.
@@ -664,17 +664,17 @@ struct entity_builder : entity_view {
      */   
     template<typename First, typename Second>
     Self& disable() {
-        return this->disable<First>(_::cpp_type<Second>::id());
+        return this->disable<First>(_::type<Second>::id());
     }
 
     Self& set_ptr(entity_t comp, size_t size, const void *ptr) {
-        ecs_set_id(this->m_world, this->m_id, comp, size, ptr);
+        ecs_set_id(this->world_, this->id_, comp, size, ptr);
         return to_base();
     }
 
     Self& set_ptr(entity_t comp, const void *ptr) {
         const flecs::Component *cptr = ecs_get(
-            this->m_world, comp, EcsComponent);
+            this->world_, comp, EcsComponent);
 
         /* Can't set if it's not a component */
         ecs_assert(cptr != NULL, ECS_INVALID_PARAMETER, NULL);
@@ -682,31 +682,29 @@ struct entity_builder : entity_view {
         return set_ptr(comp, cptr->size, ptr);
     }
 
-    template<typename T, if_t< 
-        !is_callable<T>::value && is_actual<T>::value> = 0 >
+    template<typename T, if_t<is_actual<T>::value> = 0 >
     Self& set(T&& value) {
-        flecs::set<T>(this->m_world, this->m_id, FLECS_FWD(value));
+        flecs::set<T>(this->world_, this->id_, FLECS_FWD(value));
         return to_base();
     }
 
-    template<typename T, if_t< 
-        !is_callable<T>::value && is_actual<T>::value > = 0>
+    template<typename T, if_t<is_actual<T>::value > = 0>
     Self& set(const T& value) {
-        flecs::set<T>(this->m_world, this->m_id, value);
+        flecs::set<T>(this->world_, this->id_, value);
         return to_base();
     }
 
     template<typename T, typename A = actual_type_t<T>, if_not_t< 
-        is_callable<T>::value || is_actual<T>::value > = 0>
+        is_actual<T>::value > = 0>
     Self& set(A&& value) {
-        flecs::set<T>(this->m_world, this->m_id, FLECS_FWD(value));
+        flecs::set<T>(this->world_, this->id_, FLECS_FWD(value));
         return to_base();
     }
 
     template<typename T, typename A = actual_type_t<T>, if_not_t<
-        is_callable<T>::value || is_actual<T>::value > = 0>
+        is_actual<T>::value > = 0>
     Self& set(const A& value) {
-        flecs::set<T>(this->m_world, this->m_id, value);
+        flecs::set<T>(this->world_, this->id_, value);
         return to_base();
     }
 
@@ -721,7 +719,7 @@ struct entity_builder : entity_view {
     template <typename First, typename Second, typename P = pair<First, Second>, 
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     Self& set(A&& value) {
-        flecs::set<P>(this->m_world, this->m_id, FLECS_FWD(value));
+        flecs::set<P>(this->world_, this->id_, FLECS_FWD(value));
         return to_base();
     }
 
@@ -736,7 +734,7 @@ struct entity_builder : entity_view {
     template <typename First, typename Second, typename P = pair<First, Second>, 
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     Self& set(const A& value) {
-        flecs::set<P>(this->m_world, this->m_id, value);
+        flecs::set<P>(this->world_, this->id_, value);
         return to_base();
     }
 
@@ -750,8 +748,8 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
     Self& set(Second second, const First& value) {
-        auto first = _::cpp_type<First>::id(this->m_world);
-        flecs::set(this->m_world, this->m_id, value, 
+        auto first = _::type<First>::id(this->world_);
+        flecs::set(this->world_, this->id_, value, 
             ecs_pair(first, second));
         return to_base();
     }
@@ -766,8 +764,8 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Second, if_not_t< is_enum<Second>::value > = 0>
     Self& set(Second second, First&& value) {
-        auto first = _::cpp_type<First>::id(this->m_world);
-        flecs::set(this->m_world, this->m_id, FLECS_FWD(value), 
+        auto first = _::type<First>::id(this->world_);
+        flecs::set(this->world_, this->id_, FLECS_FWD(value), 
             ecs_pair(first, second));
         return to_base();
     }
@@ -782,7 +780,7 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Second, if_t< is_enum<Second>::value > = 0>
     Self& set(Second constant, const First& value) {
-        const auto& et = enum_type<Second>(this->m_world);
+        const auto& et = enum_type<Second>(this->world_);
         flecs::entity_t second = et.entity(constant);
         return set<First>(second, value);
     }
@@ -797,8 +795,8 @@ struct entity_builder : entity_view {
      */
     template <typename Second>
     Self& set_second(entity_t first, const Second& value) {
-        auto second = _::cpp_type<Second>::id(this->m_world);
-        flecs::set(this->m_world, this->m_id, value, 
+        auto second = _::type<Second>::id(this->world_);
+        flecs::set(this->world_, this->id_, value, 
             ecs_pair(first, second));
         return to_base();
     }
@@ -813,15 +811,15 @@ struct entity_builder : entity_view {
      */
     template <typename Second>
     Self& set_second(entity_t first, Second&& value) {
-        auto second = _::cpp_type<Second>::id(this->m_world);
-        flecs::set(this->m_world, this->m_id, FLECS_FWD(value), 
+        auto second = _::type<Second>::id(this->world_);
+        flecs::set(this->world_, this->id_, FLECS_FWD(value), 
             ecs_pair(first, second));
         return to_base();
     }
 
     template <typename First, typename Second>
     Self& set_second(const Second& value) {
-        flecs::set<pair_object<First, Second>>(this->m_world, this->m_id, value);
+        flecs::set<pair_object<First, Second>>(this->world_, this->id_, value);
         return to_base();
     }    
 
@@ -840,8 +838,8 @@ struct entity_builder : entity_view {
      *
      * @param func The callback to invoke.
      */
-    template <typename Func, if_t< is_callable<Func>::value > = 0>
-    Self& set(const Func& func);
+    template <typename Func>
+    Self& insert(const Func& func);
 
     /** Emplace component.
      * Emplace constructs a component in the storage, which prevents calling the
@@ -866,33 +864,33 @@ struct entity_builder : entity_view {
      */
     template<typename T, typename ... Args, typename A = actual_type_t<T>>
     Self& emplace(Args&&... args) {
-        flecs::emplace<A>(this->m_world, this->m_id, 
-            _::cpp_type<T>::id(this->m_world), FLECS_FWD(args)...);
+        flecs::emplace<A>(this->world_, this->id_, 
+            _::type<T>::id(this->world_), FLECS_FWD(args)...);
         return to_base();
     }
 
     template <typename First, typename Second, typename ... Args, typename P = pair<First, Second>, 
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     Self& emplace(Args&&... args) {
-        flecs::emplace<A>(this->m_world, this->m_id, 
-            ecs_pair(_::cpp_type<First>::id(this->m_world),
-                _::cpp_type<Second>::id(this->m_world)),
+        flecs::emplace<A>(this->world_, this->id_, 
+            ecs_pair(_::type<First>::id(this->world_),
+                _::type<Second>::id(this->world_)),
             FLECS_FWD(args)...);
         return to_base();
     }
 
     template <typename First, typename ... Args>
     Self& emplace_first(flecs::entity_t second, Args&&... args) {
-        flecs::emplace<First>(this->m_world, this->m_id, 
-            ecs_pair(_::cpp_type<First>::id(this->m_world), second),
+        flecs::emplace<First>(this->world_, this->id_, 
+            ecs_pair(_::type<First>::id(this->world_), second),
             FLECS_FWD(args)...);
         return to_base();
     }
 
     template <typename Second, typename ... Args>
     Self& emplace_second(flecs::entity_t first, Args&&... args) {
-        flecs::emplace<Second>(this->m_world, this->m_id, 
-            ecs_pair(first, _::cpp_type<Second>::id(this->m_world)),
+        flecs::emplace<Second>(this->world_, this->id_, 
+            ecs_pair(first, _::type<Second>::id(this->world_)),
             FLECS_FWD(args)...);
         return to_base();
     }
@@ -904,9 +902,9 @@ struct entity_builder : entity_view {
      */
     template <typename Func>
     Self& with(const Func& func) {
-        ecs_id_t prev = ecs_set_with(this->m_world, this->m_id);
+        ecs_id_t prev = ecs_set_with(this->world_, this->id_);
         func();
-        ecs_set_with(this->m_world, prev);
+        ecs_set_with(this->world_, prev);
         return to_base();
     }
 
@@ -918,7 +916,7 @@ struct entity_builder : entity_view {
      */
     template <typename First, typename Func>
     Self& with(const Func& func) {
-        with(_::cpp_type<First>::id(this->m_world), func);
+        with(_::type<First>::id(this->world_), func);
         return to_base();
     }
 
@@ -930,38 +928,38 @@ struct entity_builder : entity_view {
      */
     template <typename Func>
     Self& with(entity_t first, const Func& func) {
-        ecs_id_t prev = ecs_set_with(this->m_world, 
-            ecs_pair(first, this->m_id));
+        ecs_id_t prev = ecs_set_with(this->world_, 
+            ecs_pair(first, this->id_));
         func();
-        ecs_set_with(this->m_world, prev);
+        ecs_set_with(this->world_, prev);
         return to_base();
     }
 
     /** The function will be ran with the scope set to the current entity. */
     template <typename Func>
     Self& scope(const Func& func) {
-        ecs_entity_t prev = ecs_set_scope(this->m_world, this->m_id);
+        ecs_entity_t prev = ecs_set_scope(this->world_, this->id_);
         func();
-        ecs_set_scope(this->m_world, prev);
+        ecs_set_scope(this->world_, prev);
         return to_base();
     }
 
     /** Return world scoped to entity */
     scoped_world scope() const {
-        return scoped_world(m_world, m_id);
+        return scoped_world(world_, id_);
     }
 
     /* Set the entity name.
      */
     Self& set_name(const char *name) {
-        ecs_set_name(this->m_world, this->m_id, name);
+        ecs_set_name(this->world_, this->id_, name);
         return to_base();
     }
 
     /* Set entity alias.
      */
     Self& set_alias(const char *name) {
-        ecs_set_alias(this->m_world, this->m_id, name);
+        ecs_set_alias(this->world_, this->id_, name);
         return to_base();
     }
 
diff --git a/include/flecs/addons/cpp/mixins/entity/impl.hpp b/include/flecs/addons/cpp/mixins/entity/impl.hpp
index 921be38e2..b53e8aafa 100644
--- a/include/flecs/addons/cpp/mixins/entity/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/entity/impl.hpp
@@ -9,65 +9,65 @@ namespace flecs {
 
 template <typename T>
 flecs::entity ref<T>::entity() const {
-    return flecs::entity(m_world, m_ref.entity);
+    return flecs::entity(world_, ref_.entity);
 }
 
 template <typename Self>
-template <typename Func, if_t< is_callable<Func>::value > >
-inline Self& entity_builder<Self>::set(const Func& func) {
+template <typename Func>
+inline Self& entity_builder<Self>::insert(const Func& func) {
     _::entity_with_delegate<Func>::invoke_ensure(
-        this->m_world, this->m_id, func);
+        this->world_, this->id_, func);
     return to_base();
 }
 
 template <typename T, if_t< is_enum<T>::value > >
 const T* entity_view::get() const {
-    entity_t r = _::cpp_type<T>::id(m_world);
-    entity_t c = ecs_get_target(m_world, m_id, r, 0);
+    entity_t r = _::type<T>::id(world_);
+    entity_t c = ecs_get_target(world_, id_, r, 0);
 
     if (c) {
         // Get constant value from constant entity
-        const T* v = static_cast<const T*>(ecs_get_id(m_world, c, r));
+        const T* v = static_cast<const T*>(ecs_get_id(world_, c, r));
         ecs_assert(v != NULL, ECS_INTERNAL_ERROR, 
             "missing enum constant value");
         return v;
     } else {
         // If there is no matching pair for (r, *), try just r
-        return static_cast<const T*>(ecs_get_id(m_world, m_id, r));
+        return static_cast<const T*>(ecs_get_id(world_, id_, r));
     }
 }
 
 template<typename First>
 inline flecs::entity entity_view::target(int32_t index) const 
 {
-    return flecs::entity(m_world, 
-        ecs_get_target(m_world, m_id, _::cpp_type<First>::id(m_world), index));
+    return flecs::entity(world_, 
+        ecs_get_target(world_, id_, _::type<First>::id(world_), index));
 }
 
 inline flecs::entity entity_view::target(
     flecs::entity_t relationship, 
     int32_t index) const 
 {
-    return flecs::entity(m_world, 
-        ecs_get_target(m_world, m_id, relationship, index));
+    return flecs::entity(world_, 
+        ecs_get_target(world_, id_, relationship, index));
 }
 
 inline flecs::entity entity_view::target_for(
     flecs::entity_t relationship, 
     flecs::id_t id) const 
 {
-    return flecs::entity(m_world, 
-        ecs_get_target_for_id(m_world, m_id, relationship, id));
+    return flecs::entity(world_, 
+        ecs_get_target_for_id(world_, id_, relationship, id));
 }
 
 template <typename T>
 inline flecs::entity entity_view::target_for(flecs::entity_t relationship) const {
-    return target_for(relationship, _::cpp_type<T>::id(m_world));
+    return target_for(relationship, _::type<T>::id(world_));
 }
 
 template <typename First, typename Second>
 inline flecs::entity entity_view::target_for(flecs::entity_t relationship) const {
-    return target_for(relationship, _::cpp_type<First, Second>::id(m_world));
+    return target_for(relationship, _::type<First, Second>::id(world_));
 }
 
 inline flecs::entity entity_view::parent() const {
@@ -77,37 +77,37 @@ inline flecs::entity entity_view::parent() const {
 inline flecs::entity entity_view::mut(const flecs::world& stage) const {
     ecs_assert(!stage.is_readonly(), ECS_INVALID_PARAMETER, 
         "cannot use readonly world/stage to create mutable handle");
-    return flecs::entity(m_id).set_stage(stage.c_ptr());
+    return flecs::entity(id_).set_stage(stage.c_ptr());
 }
 
 inline flecs::entity entity_view::mut(const flecs::iter& it) const {
     ecs_assert(!it.world().is_readonly(), ECS_INVALID_PARAMETER, 
         "cannot use iterator created for readonly world/stage to create mutable handle");
-    return flecs::entity(m_id).set_stage(it.world().c_ptr());
+    return flecs::entity(id_).set_stage(it.world().c_ptr());
 }
 
 inline flecs::entity entity_view::mut(const flecs::entity_view& e) const {
     ecs_assert(!e.world().is_readonly(), ECS_INVALID_PARAMETER, 
         "cannot use entity created for readonly world/stage to create mutable handle");
-    return flecs::entity(m_id).set_stage(e.m_world);
+    return flecs::entity(id_).set_stage(e.world_);
 }
 
 inline flecs::entity entity_view::set_stage(world_t *stage) {
-    return flecs::entity(stage, m_id);
+    return flecs::entity(stage, id_);
 }   
 
 inline flecs::type entity_view::type() const {
-    return flecs::type(m_world, ecs_get_type(m_world, m_id));
+    return flecs::type(world_, ecs_get_type(world_, id_));
 }
 
 inline flecs::table entity_view::table() const {
-    return flecs::table(m_world, ecs_get_table(m_world, m_id));
+    return flecs::table(world_, ecs_get_table(world_, id_));
 }
 
 inline flecs::table_range entity_view::range() const {
-    ecs_record_t *r = ecs_record_find(m_world, m_id);
+    ecs_record_t *r = ecs_record_find(world_, id_);
     if (r) {
-        return flecs::table_range(m_world, r->table, 
+        return flecs::table_range(world_, r->table, 
             ECS_RECORD_TO_ROW(r->row), 1);
     }
     return flecs::table_range();
@@ -115,7 +115,7 @@ inline flecs::table_range entity_view::range() const {
 
 template <typename Func>
 inline void entity_view::each(const Func& func) const {
-    const ecs_type_t *type = ecs_get_type(m_world, m_id);
+    const ecs_type_t *type = ecs_get_type(world_, id_);
     if (!type) {
         return;
     }
@@ -125,24 +125,17 @@ inline void entity_view::each(const Func& func) const {
 
     for (int i = 0; i < count; i ++) {
         ecs_id_t id = ids[i];
-        flecs::id ent(m_world, id);
+        flecs::id ent(world_, id);
         func(ent); 
-
-        // Union object is not stored in type, so handle separately
-        if (ECS_PAIR_FIRST(id) == EcsUnion) {
-            ent = flecs::id(m_world, ECS_PAIR_SECOND(id),
-                ecs_get_target(m_world, m_id, ECS_PAIR_SECOND(id), 0));
-            func(ent);
-        }
     }
 }
 
 template <typename Func>
 inline void entity_view::each(flecs::id_t pred, flecs::id_t obj, const Func& func) const {
     flecs::world_t *real_world = const_cast<flecs::world_t*>(
-        ecs_get_world(m_world));
+        ecs_get_world(world_));
 
-    const ecs_table_t *table = ecs_get_table(m_world, m_id);
+    const ecs_table_t *table = ecs_get_table(world_, id_);
     if (!table) {
         return;
     }
@@ -162,7 +155,7 @@ inline void entity_view::each(flecs::id_t pred, flecs::id_t obj, const Func& fun
     
     while (-1 != (cur = ecs_search_offset(real_world, table, cur, pattern, 0)))
     {
-        flecs::id ent(m_world, ids[cur]);
+        flecs::id ent(world_, ids[cur]);
         func(ent);
         cur ++;
     }
@@ -178,59 +171,59 @@ inline void entity_view::each(const flecs::entity_view& rel, const Func& func) c
 
 template <typename Func, if_t< is_callable<Func>::value > >
 inline bool entity_view::get(const Func& func) const {
-    return _::entity_with_delegate<Func>::invoke_get(m_world, m_id, func);
+    return _::entity_with_delegate<Func>::invoke_get(world_, id_, func);
 } 
 
 inline flecs::entity entity_view::lookup(const char *path, bool search_path) const {
-    ecs_assert(m_id != 0, ECS_INVALID_PARAMETER, "invalid lookup from null handle");
-    auto id = ecs_lookup_path_w_sep(m_world, m_id, path, "::", "::", search_path);
-    return flecs::entity(m_world, id);
+    ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, "invalid lookup from null handle");
+    auto id = ecs_lookup_path_w_sep(world_, id_, path, "::", "::", search_path);
+    return flecs::entity(world_, id);
 }
 
 inline flecs::entity entity_view::clone(bool copy_value, flecs::entity_t dst_id) const {
     if (!dst_id) {
-        dst_id = ecs_new_id(m_world);
+        dst_id = ecs_new(world_);
     }
 
-    flecs::entity dst = flecs::entity(m_world, dst_id);
-    ecs_clone(m_world, dst_id, m_id, copy_value);
+    flecs::entity dst = flecs::entity(world_, dst_id);
+    ecs_clone(world_, dst_id, id_, copy_value);
     return dst;
 }
 
 // Entity mixin implementation
 template <typename... Args>
 inline flecs::entity world::entity(Args &&... args) const {
-    return flecs::entity(m_world, FLECS_FWD(args)...);
+    return flecs::entity(world_, FLECS_FWD(args)...);
 }
 
 template <typename E, if_t< is_enum<E>::value >>
 inline flecs::id world::id(E value) const {
-    flecs::entity_t constant = enum_type<E>(m_world).entity(value);
-    return flecs::id(m_world, constant);
+    flecs::entity_t constant = enum_type<E>(world_).entity(value);
+    return flecs::id(world_, constant);
 }
 
 template <typename E, if_t< is_enum<E>::value >>
 inline flecs::entity world::entity(E value) const {
-    flecs::entity_t constant = enum_type<E>(m_world).entity(value);
-    return flecs::entity(m_world, constant);
+    flecs::entity_t constant = enum_type<E>(world_).entity(value);
+    return flecs::entity(world_, constant);
 }
 
 template <typename T>
 inline flecs::entity world::entity(const char *name) const {
-    return flecs::entity(m_world, 
-        _::cpp_type<T>::id_explicit(m_world, name, true, 0, false) );
+    return flecs::entity(world_, 
+        _::type<T>::id_explicit(world_, name, true, 0, false) );
 }
 
 template <typename... Args>
 inline flecs::entity world::prefab(Args &&... args) const {
-    flecs::entity result = flecs::entity(m_world, FLECS_FWD(args)...);
+    flecs::entity result = flecs::entity(world_, FLECS_FWD(args)...);
     result.add(flecs::Prefab);
     return result;
 }
 
 template <typename T>
 inline flecs::entity world::prefab(const char *name) const {
-    flecs::entity result = flecs::component<T>(m_world, name, true);
+    flecs::entity result = flecs::component<T>(world_, name, true);
     result.add(flecs::Prefab);
     return result;
 }
diff --git a/include/flecs/addons/cpp/mixins/enum/impl.hpp b/include/flecs/addons/cpp/mixins/enum/impl.hpp
index 76e04039c..b3523487c 100644
--- a/include/flecs/addons/cpp/mixins/enum/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/enum/impl.hpp
@@ -16,8 +16,8 @@ inline E entity_view::to_constant() const {
 
 template <typename E, if_t< is_enum<E>::value >>
 inline flecs::entity world::to_entity(E constant) const {
-    const auto& et = enum_type<E>(m_world);
-    return flecs::entity(m_world, et.entity(constant));
+    const auto& et = enum_type<E>(world_);
+    return flecs::entity(world_, et.entity(constant));
 }
 
 }
\ No newline at end of file
diff --git a/include/flecs/addons/cpp/mixins/event/builder.hpp b/include/flecs/addons/cpp/mixins/event/builder.hpp
index 3759bfaf2..24fd0efbc 100644
--- a/include/flecs/addons/cpp/mixins/event/builder.hpp
+++ b/include/flecs/addons/cpp/mixins/event/builder.hpp
@@ -18,20 +18,20 @@ namespace flecs {
 template <typename Base, typename E>
 struct event_builder_base {
     event_builder_base(flecs::world_t *world, flecs::entity_t event)
-        : m_world(world)
-        , m_desc{}
-        , m_ids{}
-        , m_ids_array{}
+        : world_(world)
+        , desc_{}
+        , ids_{}
+        , ids_array_{}
     {
-        m_desc.event = event;
+        desc_.event = event;
     }
 
     /** Add component to emit for */
     template <typename T>
     Base& id() {
-        m_ids.array = m_ids_array;
-        m_ids.array[m_ids.count] = _::cpp_type<T>().id(m_world);
-        m_ids.count ++;
+        ids_.array = ids_array_;
+        ids_.array[ids_.count] = _::type<T>().id(world_);
+        ids_.count ++;
         return *this;
     }
     
@@ -43,8 +43,8 @@ struct event_builder_base {
     template <typename First, typename Second>
     Base& id() {
         return id(
-            ecs_pair(_::cpp_type<First>::id(this->m_world), 
-                _::cpp_type<Second>::id(this->m_world)));
+            ecs_pair(_::type<First>::id(this->world_), 
+                _::type<Second>::id(this->world_)));
     }
 
     /** 
@@ -54,7 +54,7 @@ struct event_builder_base {
      */
     template <typename First>
     Base& id(entity_t second) {
-        return id(ecs_pair(_::cpp_type<First>::id(this->m_world), second));
+        return id(ecs_pair(_::type<First>::id(this->world_), second));
     }
 
     /** 
@@ -68,57 +68,57 @@ struct event_builder_base {
 
     /** Add (component) id to emit for */
     Base& id(flecs::id_t id) {
-        m_ids.array = m_ids_array;
-        m_ids.array[m_ids.count] = id;
-        m_ids.count ++;
+        ids_.array = ids_array_;
+        ids_.array[ids_.count] = id;
+        ids_.count ++;
         return *this;
     }
 
     /** Set entity for which to emit event */
     Base& entity(flecs::entity_t e) {
-        m_desc.entity = e;
+        desc_.entity = e;
         return *this;
     }
 
     /* Set table for which to emit event */
     Base& table(flecs::table_t *t, int32_t offset = 0, int32_t count = 0) {
-        m_desc.table = t;
-        m_desc.offset = offset;
-        m_desc.count = count;
+        desc_.table = t;
+        desc_.offset = offset;
+        desc_.count = count;
         return *this;
     }
 
     /* Set event data */
     Base& ctx(const E* ptr) {
-        m_desc.const_param = ptr;
+        desc_.const_param = ptr;
         return *this;
     }
 
     /* Set event data */
     Base& ctx(E* ptr) {
-        m_desc.param = ptr;
+        desc_.param = ptr;
         return *this;
     }
 
     void emit() {
-        m_ids.array = m_ids_array;
-        m_desc.ids = &m_ids;
-        m_desc.observable = const_cast<flecs::world_t*>(ecs_get_world(m_world));
-        ecs_emit(m_world, &m_desc);
+        ids_.array = ids_array_;
+        desc_.ids = &ids_;
+        desc_.observable = const_cast<flecs::world_t*>(ecs_get_world(world_));
+        ecs_emit(world_, &desc_);
     }
 
     void enqueue() {
-        m_ids.array = m_ids_array;
-        m_desc.ids = &m_ids;
-        m_desc.observable = const_cast<flecs::world_t*>(ecs_get_world(m_world));
-        ecs_enqueue(m_world, &m_desc);
+        ids_.array = ids_array_;
+        desc_.ids = &ids_;
+        desc_.observable = const_cast<flecs::world_t*>(ecs_get_world(world_));
+        ecs_enqueue(world_, &desc_);
     }
 
 protected:
-    flecs::world_t *m_world;
-    ecs_event_desc_t m_desc;
-    flecs::type_t m_ids;
-    flecs::id_t m_ids_array[ECS_EVENT_DESC_ID_COUNT_MAX];
+    flecs::world_t *world_;
+    ecs_event_desc_t desc_;
+    flecs::type_t ids_;
+    flecs::id_t ids_array_[ECS_EVENT_DESC_ID_COUNT_MAX];
 
 private:
     operator Base&() {
@@ -140,13 +140,13 @@ struct event_builder_typed : event_builder_base<event_builder_typed<E>, E> {
 
     /* Set event data */
     Class& ctx(const E& ptr) {
-        this->m_desc.const_param = &ptr;
+        this->desc_.const_param = &ptr;
         return *this;
     }
 
     /* Set event data */
     Class& ctx(E&& ptr) {
-        this->m_desc.param = &ptr;
+        this->desc_.param = &ptr;
         return *this;
     }
 };
diff --git a/include/flecs/addons/cpp/mixins/event/entity_view.inl b/include/flecs/addons/cpp/mixins/event/entity_view.inl
index 7612a5e91..203e9bf71 100644
--- a/include/flecs/addons/cpp/mixins/event/entity_view.inl
+++ b/include/flecs/addons/cpp/mixins/event/entity_view.inl
@@ -10,9 +10,9 @@
  * @param evt The event to emit.
  */
 void emit(flecs::entity_t evt) {
-    flecs::world(m_world)
+    flecs::world(world_)
         .event(evt)
-        .entity(m_id)
+        .entity(id_)
         .emit();
 }
 
@@ -32,7 +32,7 @@ void emit(flecs::entity evt);
  */
 template <typename Evt, if_t<is_empty<Evt>::value> = 0>
 void emit() {
-    this->emit(_::cpp_type<Evt>::id(m_world));
+    this->emit(_::type<Evt>::id(world_));
 }
 
 /** Emit event with payload for entity.
@@ -43,9 +43,9 @@ void emit() {
  */
 template <typename Evt, if_not_t<is_empty<Evt>::value> = 0>
 void emit(const Evt& payload) {
-    flecs::world(m_world)
-        .event(_::cpp_type<Evt>::id(m_world))
-        .entity(m_id)
+    flecs::world(world_)
+        .event(_::type<Evt>::id(world_))
+        .entity(id_)
         .ctx(&payload)
         .emit();
 }
@@ -58,9 +58,9 @@ void emit(const Evt& payload) {
  * @param evt The event to enqueue.
  */
 void enqueue(flecs::entity_t evt) {
-    flecs::world(m_world)
+    flecs::world(world_)
         .event(evt)
-        .entity(m_id)
+        .entity(id_)
         .enqueue();
 }
 
@@ -80,7 +80,7 @@ void enqueue(flecs::entity evt);
  */
 template <typename Evt, if_t<is_empty<Evt>::value> = 0>
 void enqueue() {
-    this->enqueue(_::cpp_type<Evt>::id(m_world));
+    this->enqueue(_::type<Evt>::id(world_));
 }
 
 /** Enqueue event with payload for entity.
@@ -91,9 +91,9 @@ void enqueue() {
  */
 template <typename Evt, if_not_t<is_empty<Evt>::value> = 0>
 void enqueue(const Evt& payload) {
-    flecs::world(m_world)
-        .event(_::cpp_type<Evt>::id(m_world))
-        .entity(m_id)
+    flecs::world(world_)
+        .event(_::type<Evt>::id(world_))
+        .entity(id_)
         .ctx(&payload)
         .enqueue();
 }
diff --git a/include/flecs/addons/cpp/mixins/event/impl.hpp b/include/flecs/addons/cpp/mixins/event/impl.hpp
index 299769ceb..1efff9787 100644
--- a/include/flecs/addons/cpp/mixins/event/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/event/impl.hpp
@@ -13,12 +13,12 @@ namespace flecs
 // Mixin implementation
 
 inline flecs::event_builder world::event(flecs::entity_t evt) const {
-    return flecs::event_builder(m_world, evt);
+    return flecs::event_builder(world_, evt);
 }
 
 template <typename E>
 inline flecs::event_builder_typed<E> world::event() const {
-    return flecs::event_builder_typed<E>(m_world, _::cpp_type<E>().id(m_world));
+    return flecs::event_builder_typed<E>(world_, _::type<E>().id(world_));
 }
 
 namespace _ {
@@ -32,8 +32,8 @@ namespace _ {
     {
         ecs_observer_desc_t desc = {};
         desc.events[0] = event;
-        desc.filter.terms[0].id = EcsAny;
-        desc.filter.terms[0].src.id = entity;
+        desc.query.terms[0].id = EcsAny;
+        desc.query.terms[0].src.id = entity;
         desc.callback = callback;
         desc.binding_ctx = binding_ctx;
         desc.binding_ctx_free = binding_ctx_free;
@@ -52,7 +52,7 @@ namespace _ {
         {
             using Delegate = _::entity_observer_delegate<Func>;
             auto ctx = FLECS_NEW(Delegate)(FLECS_FWD(f));
-            entity_observer_create(world, _::cpp_type<Evt>::id(world), entity, Delegate::run, ctx, 
+            entity_observer_create(world, _::type<Evt>::id(world), entity, Delegate::run, ctx, 
                 reinterpret_cast<ecs_ctx_free_t>(_::free_obj<Delegate>));
         }
 
@@ -64,7 +64,7 @@ namespace _ {
         {
             using Delegate = _::entity_payload_observer_delegate<Func, Evt>;
             auto ctx = FLECS_NEW(Delegate)(FLECS_FWD(f));
-            entity_observer_create(world, _::cpp_type<Evt>::id(world), entity, Delegate::run, ctx, 
+            entity_observer_create(world, _::type<Evt>::id(world), entity, Delegate::run, ctx, 
                 reinterpret_cast<ecs_ctx_free_t>(_::free_obj<Delegate>));
         }
     };
@@ -76,7 +76,7 @@ inline Self& entity_builder<Self>::observe(flecs::entity_t evt, Func&& f) {
     using Delegate = _::entity_observer_delegate<Func>;
     auto ctx = FLECS_NEW(Delegate)(FLECS_FWD(f));
 
-    _::entity_observer_create(m_world, evt, m_id, Delegate::run, ctx,
+    _::entity_observer_create(world_, evt, id_, Delegate::run, ctx,
         reinterpret_cast<ecs_ctx_free_t>(_::free_obj<Delegate>));
 
     return to_base();
@@ -86,7 +86,7 @@ template <typename Self>
 template <typename Evt, typename Func>
 inline Self& entity_builder<Self>::observe(Func&& f) {
     _::entity_observer_factory<Func>::template create<Evt>(
-        m_world, m_id, FLECS_FWD(f));
+        world_, id_, FLECS_FWD(f));
     return to_base();
 }
 
diff --git a/include/flecs/addons/cpp/mixins/filter/builder.hpp b/include/flecs/addons/cpp/mixins/filter/builder.hpp
deleted file mode 100644
index 7ad33fd38..000000000
--- a/include/flecs/addons/cpp/mixins/filter/builder.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * @file addons/cpp/mixins/filter/builder.hpp
- * @brief Filter builder.
- */
-
-#pragma once
-
-#include "../../utils/builder.hpp"
-#include "builder_i.hpp"
-
-namespace flecs {
-namespace _ {
-    template <typename ... Components>
-    using filter_builder_base = builder<
-        filter, ecs_filter_desc_t, filter_builder<Components...>, 
-        filter_builder_i, Components ...>;
-}
-
-/** Filter builder.
- * 
- * @ingroup cpp_core_filters
- */
-template <typename ... Components>
-struct filter_builder final : _::filter_builder_base<Components...> {
-    filter_builder(flecs::world_t* world, const char *name = nullptr)
-        : _::filter_builder_base<Components...>(world)
-    {
-        _::sig<Components...>(world).populate(this);
-        if (name != nullptr) {
-            ecs_entity_desc_t entity_desc = {};
-            entity_desc.name = name;
-            entity_desc.sep = "::";
-            entity_desc.root_sep = "::";
-            this->m_desc.entity = ecs_entity_init(world, &entity_desc);
-        }
-    }
-
-    template <typename Func>
-    void each(Func&& func) {
-        this->build().each(FLECS_FWD(func));
-    }
-};
-
-}
diff --git a/include/flecs/addons/cpp/mixins/filter/builder_i.hpp b/include/flecs/addons/cpp/mixins/filter/builder_i.hpp
deleted file mode 100644
index 04dbb7bbc..000000000
--- a/include/flecs/addons/cpp/mixins/filter/builder_i.hpp
+++ /dev/null
@@ -1,263 +0,0 @@
-/**
- * @file addons/cpp/mixins/filter/builder_i.hpp
- * @brief Filter builder interface.
- */
-
-#pragma once
-
-#include "../term/builder_i.hpp"
-
-namespace flecs 
-{
-
-/** Filter builder interface.
- * 
- * @ingroup cpp_core_filters
- */
-template<typename Base, typename ... Components>
-struct filter_builder_i : term_builder_i<Base> {
-    filter_builder_i(ecs_filter_desc_t *desc, int32_t term_index = 0) 
-        : m_term_index(term_index)
-        , m_expr_count(0)
-        , m_desc(desc) { }
-
-    Base& instanced() {
-        m_desc->instanced = true;
-        return *this;
-    }
-
-    Base& filter_flags(ecs_flags32_t flags) {
-        m_desc->flags |= flags;
-        return *this;
-    }
-
-    Base& expr(const char *expr) {
-        ecs_check(m_expr_count == 0, ECS_INVALID_OPERATION,
-            "filter_builder::expr() called more than once");
-        m_desc->expr = expr;
-        m_expr_count ++;
-
-    error:
-        return *this;
-    }
-
-    /* With/without shorthand notation. */
-
-    template <typename ... Args>
-    Base& with(Args&&... args) {
-        return this->term(FLECS_FWD(args)...).inout_none();
-    }
-
-    template <typename T, typename ... Args>
-    Base& with(Args&&... args) {
-        return this->term<T>(FLECS_FWD(args)...).inout_none();
-    }
-
-    template <typename First, typename Second>
-    Base& with() {
-        return this->term<First, Second>().inout_none();
-    }
-
-    template <typename ... Args>
-    Base& without(Args&&... args) {
-        return this->term(FLECS_FWD(args)...).not_();
-    }
-
-    template <typename T, typename ... Args>
-    Base& without(Args&&... args) {
-        return this->term<T>(FLECS_FWD(args)...).not_();
-    }
-
-    template <typename First, typename Second>
-    Base& without() {
-        return this->term<First, Second>().not_();
-    }
-
-    /* Write/read shorthand notation */
-
-    Base& write() {
-        term_builder_i<Base>::write();
-        return *this;
-    }
-
-    template <typename ... Args>
-    Base& write(Args&&... args) {
-        return this->term(FLECS_FWD(args)...).write();
-    }
-
-    template <typename T, typename ... Args>
-    Base& write(Args&&... args) {
-        return this->term<T>(FLECS_FWD(args)...).write();
-    }
-
-    template <typename First, typename Second>
-    Base& write() {
-        return this->term<First, Second>().write();
-    }
-
-    Base& read() {
-        term_builder_i<Base>::read();
-        return *this;
-    }
-
-    template <typename ... Args>
-    Base& read(Args&&... args) {
-        return this->term(FLECS_FWD(args)...).read();
-    }
-
-    template <typename T, typename ... Args>
-    Base& read(Args&&... args) {
-        return this->term<T>(FLECS_FWD(args)...).read();
-    }
-
-    template <typename First, typename Second>
-    Base& read() {
-        return this->term<First, Second>().read();
-    }
-
-    /* Scope_open/scope_close shorthand notation. */
-    Base& scope_open() {
-        return this->with(flecs::ScopeOpen).entity(0);
-    }
-
-    Base& scope_close() {
-        return this->with(flecs::ScopeClose).entity(0);
-    }
-
-    /* Term notation for more complex query features */
-
-    Base& term() {
-        if (this->m_term) {
-            ecs_check(ecs_term_is_initialized(this->m_term), 
-                ECS_INVALID_OPERATION, 
-                    "filter_builder::term() called without initializing term");
-        }
-
-        if (m_term_index >= FLECS_TERM_DESC_MAX) {
-            if (m_term_index == FLECS_TERM_DESC_MAX) {
-                m_desc->terms_buffer = ecs_os_calloc_n(
-                    ecs_term_t, m_term_index + 1);
-                ecs_os_memcpy_n(m_desc->terms_buffer, m_desc->terms, 
-                    ecs_term_t, m_term_index);
-                ecs_os_memset_n(m_desc->terms, 0, 
-                    ecs_term_t, FLECS_TERM_DESC_MAX);
-            } else {
-                m_desc->terms_buffer = ecs_os_realloc_n(m_desc->terms_buffer, 
-                    ecs_term_t, m_term_index + 1);
-            }
-
-            m_desc->terms_buffer_count = m_term_index + 1;
-
-            this->set_term(&m_desc->terms_buffer[m_term_index]);
-        } else {
-            this->set_term(&m_desc->terms[m_term_index]);
-        }
-
-        m_term_index ++;
-    
-    error:
-        return *this;
-    }
-
-    Base& term_at(int32_t term_index) {
-        ecs_assert(term_index > 0, ECS_INVALID_PARAMETER, NULL);
-        int32_t prev_index = m_term_index;
-        m_term_index = term_index - 1;
-        this->term();
-        m_term_index = prev_index;
-        ecs_assert(ecs_term_is_initialized(this->m_term), 
-            ECS_INVALID_PARAMETER, NULL);
-        return *this;
-    }
-
-    Base& arg(int32_t term_index) {
-        return this->term_at(term_index);
-    }
-
-    template<typename T>
-    Base& term() {
-        this->term();
-        *this->m_term = flecs::term(_::cpp_type<T>::id(this->world_v())).move();
-        this->m_term->inout = static_cast<ecs_inout_kind_t>(
-            _::type_to_inout<T>());
-        return *this;
-    }
-
-    Base& term(id_t id) {
-        this->term();
-        *this->m_term = flecs::term(id).move();
-        return *this;
-    }
-
-    Base& term(const char *name) {
-        this->term();
-        *this->m_term = flecs::term().first(name).move();
-        return *this;
-    }
-
-    Base& term(const char *first, const char *second) {
-        this->term();
-        *this->m_term = flecs::term().first(first).second(second).move();
-        return *this;
-    }
-
-    Base& term(entity_t r, entity_t o) {
-        this->term();
-        *this->m_term = flecs::term(r, o).move();
-        return *this;
-    }
-
-    Base& term(entity_t r, const char *o) {
-        this->term();
-        *this->m_term = flecs::term(r).second(o).move();
-        return *this;
-    }
-
-    template<typename First>
-    Base& term(id_t o) {
-        return this->term(_::cpp_type<First>::id(this->world_v()), o);
-    }
-
-    template<typename First>
-    Base& term(const char *second) {
-        return this->term(_::cpp_type<First>::id(this->world_v())).second(second);
-    }
-
-    template<typename First, typename Second>
-    Base& term() {
-        return this->term<First>(_::cpp_type<Second>::id(this->world_v()));
-    }
-
-    template <typename E, if_t< is_enum<E>::value > = 0>
-    Base& term(E value) {
-        flecs::entity_t r = _::cpp_type<E>::id(this->world_v());
-        auto o = enum_type<E>(this->world_v()).entity(value);
-        return this->term(r, o);
-    }
-
-    Base& term(flecs::term& term) {
-        this->term();
-        *this->m_term = term.move();
-        return *this;
-    }
-
-    Base& term(flecs::term&& term) {
-        this->term();
-        *this->m_term = term.move();
-        return *this;
-    }
-
-protected:
-    virtual flecs::world_t* world_v() = 0;
-    int32_t m_term_index;
-    int32_t m_expr_count;
-
-private:
-    operator Base&() {
-        return *static_cast<Base*>(this);
-    }
-
-    ecs_filter_desc_t *m_desc;
-};
-
-}
diff --git a/include/flecs/addons/cpp/mixins/filter/decl.hpp b/include/flecs/addons/cpp/mixins/filter/decl.hpp
deleted file mode 100644
index c71cec403..000000000
--- a/include/flecs/addons/cpp/mixins/filter/decl.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * @file addons/cpp/mixins/filter/decl.hpp
- * @brief Filter declarations.
- */
-
-#pragma once
-
-namespace flecs {
-
-/**
- * @defgroup cpp_core_filters Filters
- * @ingroup cpp_core
- * Filters are cheaper to create, but slower to iterate than flecs::query.
- *
- * @{
- */
-
-struct filter_base;
-
-template<typename ... Components>
-struct filter;
-
-template<typename ... Components>
-struct filter_builder;
-
-/** @} */
-
-}
diff --git a/include/flecs/addons/cpp/mixins/filter/impl.hpp b/include/flecs/addons/cpp/mixins/filter/impl.hpp
deleted file mode 100644
index 238c69afa..000000000
--- a/include/flecs/addons/cpp/mixins/filter/impl.hpp
+++ /dev/null
@@ -1,272 +0,0 @@
-/**
- * @file addons/cpp/mixins/filter/impl.hpp
- * @brief Filter implementation.
- */
-
-#pragma once
-
-#include "builder.hpp"
-
-namespace flecs 
-{
-
-struct filter_base {
-    filter_base()
-        : m_world(nullptr)
-        , m_filter({})
-        , m_filter_ptr(nullptr) { }
-
-    filter_base(world_t *world, const ecs_filter_t *filter)
-        : m_world(world)
-        , m_filter({})
-        , m_filter_ptr(filter) { }
-
-    filter_base(world_t *world, ecs_filter_t *filter)
-        : m_world(world)
-        , m_filter_ptr(&m_filter) {
-            ecs_filter_move(&m_filter, filter);
-        }
-
-    filter_base(world_t *world, ecs_filter_desc_t *desc) 
-        : m_world(world)
-    {
-        desc->storage = &m_filter;
-
-        if (ecs_filter_init(world, desc) == NULL) {
-            ecs_abort(ECS_INVALID_PARAMETER, NULL);
-        }
-
-        if (desc->terms_buffer) {
-            ecs_os_free(desc->terms_buffer);
-        }
-
-        m_filter_ptr = &m_filter;
-    }
-
-    filter_base(const filter_base& obj) {
-        this->m_world = obj.m_world;
-        if (obj.m_filter_ptr) {
-            this->m_filter_ptr = &this->m_filter;
-        } else {
-            this->m_filter_ptr = nullptr;
-        }
-        ecs_filter_copy(&m_filter, &obj.m_filter);
-    }
-
-    filter_base& operator=(const filter_base& obj) {
-        this->m_world = obj.m_world;
-        if (obj.m_filter_ptr) {
-            this->m_filter_ptr = &this->m_filter;
-        } else {
-            this->m_filter_ptr = nullptr;
-        }
-        ecs_filter_copy(&m_filter, &obj.m_filter);
-        return *this; 
-    }
-
-    filter_base(filter_base&& obj) noexcept {
-        this->m_world = obj.m_world;
-        if (obj.m_filter_ptr) {
-            this->m_filter_ptr = &this->m_filter;
-        } else {
-            this->m_filter_ptr = nullptr;
-        }
-        ecs_filter_move(&m_filter, &obj.m_filter);
-    }
-
-    filter_base& operator=(filter_base&& obj) noexcept {
-        this->m_world = obj.m_world;
-        if (obj.m_filter_ptr) {
-            this->m_filter_ptr = &this->m_filter;
-        } else {
-            this->m_filter_ptr = nullptr;
-        }
-        ecs_filter_move(&m_filter, &obj.m_filter);
-        return *this; 
-    }
-
-    flecs::entity entity() {
-        return flecs::entity(m_world, ecs_get_entity(m_filter_ptr));
-    }
-
-    operator const flecs::filter_t*() const {
-        return m_filter_ptr;
-    }
-
-    /** Free the filter.
-     */
-    ~filter_base() {
-        if ((&m_filter == m_filter_ptr) && m_filter_ptr) {
-            ecs_filter_fini(&m_filter);
-        }
-    }
-
-    template <typename Func>
-    void each_term(const Func& func) {
-        for (int i = 0; i < m_filter_ptr->term_count; i ++) {
-            flecs::term t(m_world, m_filter_ptr->terms[i]);
-            func(t);
-            t.reset(); // prevent freeing resources
-        }
-    }
-
-    flecs::term term(int32_t index) {
-        return flecs::term(m_world, m_filter_ptr->terms[index]);
-    }
-
-    int32_t field_count() {
-        return m_filter_ptr->term_count;
-    }
-
-    flecs::string str() {
-        char *result = ecs_filter_str(m_world, m_filter_ptr);
-        return flecs::string(result);
-    }
-
-    operator filter<>() const;
-
-protected:
-    world_t *m_world = nullptr;
-    filter_t m_filter = ECS_FILTER_INIT;
-    const filter_t *m_filter_ptr;
-};
-
-template<typename ... Components>
-struct filter : filter_base, iterable<Components...> {
-private:
-    using Terms = typename _::term_ptrs<Components...>::array;
-
-public:
-    using filter_base::filter_base;
-
-    filter() : filter_base() { } // necessary not to confuse msvc
-
-    filter(const filter& obj) : filter_base(obj) { }
-
-    filter& operator=(const filter& obj) {
-        filter_base::operator=(obj);
-        return *this;
-    }
-
-    filter(filter&& obj) noexcept : filter_base(FLECS_MOV(obj)) { }
-
-    filter& operator=(filter&& obj) noexcept {
-        filter_base::operator=(FLECS_FWD(obj));
-        return *this;
-    }
-
-private:
-    ecs_iter_t get_iter(flecs::world_t *world) const override {
-        if (!world) {
-            world = m_world;
-        }
-        return ecs_filter_iter(world, m_filter_ptr);
-    }
-
-    ecs_iter_next_action_t next_action() const override {
-        return ecs_filter_next;
-    }
-
-    ecs_iter_next_action_t next_each_action() const override {
-        return ecs_filter_next_instanced;
-    }
-};
-
-// World mixin implementation
-template <typename... Comps, typename... Args>
-inline flecs::filter<Comps...> world::filter(Args &&... args) const {
-    return flecs::filter_builder<Comps...>(m_world, FLECS_FWD(args)...)
-        .build();
-}
-
-template <typename... Comps, typename... Args>
-inline flecs::filter_builder<Comps...> world::filter_builder(Args &&... args) const {
-    return flecs::filter_builder<Comps...>(m_world, FLECS_FWD(args)...);
-}
-
-// world::each
-namespace _ {
-
-// Each with entity parameter
-template<typename Func, typename ... Args>
-struct filter_delegate_w_ent;
-
-template<typename Func, typename E, typename ... Args>
-struct filter_delegate_w_ent<Func, arg_list<E, Args ...> >
-{
-    filter_delegate_w_ent(const flecs::world& world, Func&& func) {
-        auto f = world.filter<Args ...>();
-        f.each(FLECS_MOV(func));
-    }
-};
-
-// Each without entity parameter
-template<typename Func, typename ... Args>
-struct filter_delegate_no_ent;
-
-template<typename Func, typename ... Args>
-struct filter_delegate_no_ent<Func, arg_list<Args ...> >
-{
-    filter_delegate_no_ent(const flecs::world& world, Func&& func) {
-        auto f = world.filter<Args ...>();
-        f.each(FLECS_MOV(func));
-    }
-};
-
-// Switch between function with & without entity parameter
-template<typename Func, typename T = int>
-struct filter_delegate;
-
-template <typename Func>
-struct filter_delegate<Func, if_t<is_same<first_arg_t<Func>, flecs::entity>::value> > {
-    filter_delegate(const flecs::world& world, Func&& func) {
-        filter_delegate_w_ent<Func, arg_list_t<Func>>(world, FLECS_MOV(func));
-    }
-};
-
-template <typename Func>
-struct filter_delegate<Func, if_not_t<is_same<first_arg_t<Func>, flecs::entity>::value> > {
-    filter_delegate(const flecs::world& world, Func&& func) {
-        filter_delegate_no_ent<Func, arg_list_t<Func>>(world, FLECS_MOV(func));
-    }
-};
-
-}
-
-template <typename Func>
-inline void world::each(Func&& func) const {
-    _::filter_delegate<Func> f_delegate(*this, FLECS_MOV(func));
-}
-
-template <typename T, typename Func>
-inline void world::each(Func&& func) const {
-    ecs_term_t t = {};
-    t.id = _::cpp_type<T>::id();
-    ecs_iter_t it = ecs_term_iter(m_world, &t);
-
-    while (ecs_term_next(&it)) {
-        _::each_delegate<Func, T>(func).invoke(&it);
-    }
-}
-
-template <typename Func>
-inline void world::each(flecs::id_t term_id, Func&& func) const {
-    ecs_term_t t = {};
-    t.id = term_id;
-    ecs_iter_t it = ecs_term_iter(m_world, &t);
-
-    while (ecs_term_next(&it)) {
-        _::each_delegate<Func>(func).invoke(&it);
-    }
-}
-
-// filter_base implementation
-inline filter_base::operator flecs::filter<> () const {
-    flecs::filter<> f;
-    ecs_filter_copy(&f.m_filter, &this->m_filter);
-    f.m_filter_ptr = &f.m_filter;
-    f.m_world = this->m_world;
-    return f;
-}
-
-}
diff --git a/include/flecs/addons/cpp/mixins/filter/mixin.inl b/include/flecs/addons/cpp/mixins/filter/mixin.inl
deleted file mode 100644
index fbde350d6..000000000
--- a/include/flecs/addons/cpp/mixins/filter/mixin.inl
+++ /dev/null
@@ -1,65 +0,0 @@
-/**
- * @file addons/cpp/mixins/filter/mixin.inl
- * @brief Filter world mixin.
- */
-
-/**
- * @memberof flecs::world
- * @ingroup cpp_core_filters
- *
- * @{
- */
-
-/** Create a filter.
- * 
- * @see ecs_filter_init
- */
-template <typename... Comps, typename... Args>
-flecs::filter<Comps...> filter(Args &&... args) const;
-
-/** Create a filter builder.
- * 
- * @see ecs_filter_init
- */
-template <typename... Comps, typename... Args>
-flecs::filter_builder<Comps...> filter_builder(Args &&... args) const;
-
-/** Iterate over all entities with components in argument list of function.
- * The function parameter must match the following signature:
- *
- * @code
- * void(*)(T&, U&, ...)
- * @endcode
- *
- * or:
- *
- * @code
- * void(*)(flecs::entity, T&, U&, ...)
- * @endcode
- * 
- */
-template <typename Func>
-void each(Func&& func) const;
-
-/** Iterate over all entities with provided component.
- * The function parameter must match the following signature:
- *
- * @code
- * void(*)(T&)
- * @endcode
- *
- * or:
- *
- * @code
- * void(*)(flecs::entity, T&)
- * @endcode
- * 
- */
-template <typename T, typename Func>
-void each(Func&& func) const;
-
-/** Iterate over all entities with provided (component) id. */
-template <typename Func>
-void each(flecs::id_t term_id, Func&& func) const;
-
-/** @} */
diff --git a/include/flecs/addons/cpp/mixins/id/decl.hpp b/include/flecs/addons/cpp/mixins/id/decl.hpp
index 6bf6dc3b0..6ca8661d9 100644
--- a/include/flecs/addons/cpp/mixins/id/decl.hpp
+++ b/include/flecs/addons/cpp/mixins/id/decl.hpp
@@ -26,42 +26,42 @@ struct entity;
  */
 struct id {
     id()
-        : m_world(nullptr)
-        , m_id(0) { }
+        : world_(nullptr)
+        , id_(0) { }
 
     explicit id(flecs::id_t value)
-        : m_world(nullptr)
-        , m_id(value) { }
+        : world_(nullptr)
+        , id_(value) { }
 
     explicit id(flecs::world_t *world, flecs::id_t value = 0)
-        : m_world(world)
-        , m_id(value) { }
+        : world_(world)
+        , id_(value) { }
 
     explicit id(flecs::world_t *world, flecs::id_t first, flecs::id_t second)
-        : m_world(world)
-        , m_id(ecs_pair(first, second)) { }
+        : world_(world)
+        , id_(ecs_pair(first, second)) { }
 
     explicit id(flecs::id_t first, flecs::id_t second)
-        : m_world(nullptr)
-        , m_id(ecs_pair(first, second)) { }
+        : world_(nullptr)
+        , id_(ecs_pair(first, second)) { }
 
     explicit id(const flecs::id& first, const flecs::id& second)
-        : m_world(first.m_world)
-        , m_id(ecs_pair(first.m_id, second.m_id)) { }
+        : world_(first.world_)
+        , id_(ecs_pair(first.id_, second.id_)) { }
 
     /** Test if id is pair (has first, second) */
     bool is_pair() const {
-        return (m_id & ECS_ID_FLAGS_MASK) == flecs::Pair;
+        return (id_ & ECS_ID_FLAGS_MASK) == flecs::Pair;
     }
 
     /** Test if id is a wildcard */
     bool is_wildcard() const {
-        return ecs_id_is_wildcard(m_id);
+        return ecs_id_is_wildcard(id_);
     }
 
     /** Test if id is entity */
     bool is_entity() const {
-        return !(m_id & ECS_ID_FLAGS_MASK);
+        return !(id_ & ECS_ID_FLAGS_MASK);
     }
 
     /** Return id as entity (only allowed when id is valid entity) */
@@ -84,12 +84,12 @@ struct id {
 
     /** Test if id has specified role */
     bool has_flags(flecs::id_t flags) const {
-        return ((m_id & flags) == flags);
+        return ((id_ & flags) == flags);
     }
 
     /** Test if id has any role */
     bool has_flags() const {
-        return (m_id & ECS_ID_FLAGS_MASK) != 0;
+        return (id_ & ECS_ID_FLAGS_MASK) != 0;
     }
 
     /** Return id flags set on id */
@@ -100,7 +100,7 @@ struct id {
         if (!is_pair()) {
             return false;
         }
-        return ECS_PAIR_FIRST(m_id) == first;
+        return ECS_PAIR_FIRST(id_) == first;
     }
 
     /** Get first element from a pair.
@@ -117,21 +117,21 @@ struct id {
 
     /* Convert id to string */
     flecs::string str() const {
-        return flecs::string(ecs_id_str(m_world, m_id));
+        return flecs::string(ecs_id_str(world_, id_));
     }
 
     /** Convert role of id to string. */
     flecs::string flags_str() const {
-        return flecs::string_view( ecs_id_flag_str(m_id & ECS_ID_FLAGS_MASK));
+        return flecs::string_view( ecs_id_flag_str(id_ & ECS_ID_FLAGS_MASK));
     }
 
     /** Return flecs::id_t value */
     flecs::id_t raw_id() const {
-        return m_id;
+        return id_;
     }
 
     operator flecs::id_t() const {
-        return m_id;
+        return id_;
     }
 
     flecs::world world() const;
@@ -139,8 +139,8 @@ struct id {
 protected:
     /* World is optional, but guarantees that entity identifiers extracted from
      * the id are valid */
-    flecs::world_t *m_world;
-    flecs::id_t m_id;
+    flecs::world_t *world_;
+    flecs::id_t id_;
 };
 
 /** @} */
diff --git a/include/flecs/addons/cpp/mixins/id/impl.hpp b/include/flecs/addons/cpp/mixins/id/impl.hpp
index b043ce676..3e3736661 100644
--- a/include/flecs/addons/cpp/mixins/id/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/id/impl.hpp
@@ -10,57 +10,57 @@ namespace flecs {
 inline flecs::entity id::entity() const {
     ecs_assert(!is_pair(), ECS_INVALID_OPERATION, NULL);
     ecs_assert(!flags(), ECS_INVALID_OPERATION, NULL);
-    return flecs::entity(m_world, m_id);
+    return flecs::entity(world_, id_);
 }
 
 inline flecs::entity id::flags() const {
-    return flecs::entity(m_world, m_id & ECS_ID_FLAGS_MASK);
+    return flecs::entity(world_, id_ & ECS_ID_FLAGS_MASK);
 }
 
 inline flecs::entity id::first() const {
     ecs_assert(is_pair(), ECS_INVALID_OPERATION, NULL);
 
-    flecs::entity_t e = ECS_PAIR_FIRST(m_id);
-    if (m_world) {
-        return flecs::entity(m_world, ecs_get_alive(m_world, e));
+    flecs::entity_t e = ECS_PAIR_FIRST(id_);
+    if (world_) {
+        return flecs::entity(world_, ecs_get_alive(world_, e));
     } else {
         return flecs::entity(e);
     }
 }
 
 inline flecs::entity id::second() const {
-    flecs::entity_t e = ECS_PAIR_SECOND(m_id);
-    if (m_world) {
-        return flecs::entity(m_world, ecs_get_alive(m_world, e));
+    flecs::entity_t e = ECS_PAIR_SECOND(id_);
+    if (world_) {
+        return flecs::entity(world_, ecs_get_alive(world_, e));
     } else {
         return flecs::entity(e);
     }
 }
 
 inline flecs::entity id::add_flags(flecs::id_t flags) const {
-    return flecs::entity(m_world, m_id | flags);
+    return flecs::entity(world_, id_ | flags);
 }
 
 inline flecs::entity id::remove_flags(flecs::id_t flags) const {
     (void)flags;
-    ecs_assert((m_id & ECS_ID_FLAGS_MASK) == flags, ECS_INVALID_PARAMETER, NULL);
-    return flecs::entity(m_world, m_id & ECS_COMPONENT_MASK);
+    ecs_assert((id_ & ECS_ID_FLAGS_MASK) == flags, ECS_INVALID_PARAMETER, NULL);
+    return flecs::entity(world_, id_ & ECS_COMPONENT_MASK);
 }
 
 inline flecs::entity id::remove_flags() const {
-    return flecs::entity(m_world, m_id & ECS_COMPONENT_MASK);
+    return flecs::entity(world_, id_ & ECS_COMPONENT_MASK);
 }
 
 inline flecs::entity id::remove_generation() const {
-    return flecs::entity(m_world, static_cast<uint32_t>(m_id));
+    return flecs::entity(world_, static_cast<uint32_t>(id_));
 }
 
 inline flecs::world id::world() const {
-    return flecs::world(m_world);
+    return flecs::world(world_);
 }
 
 inline flecs::entity id::type_id() const {
-    return flecs::entity(m_world, ecs_get_typeid(m_world, m_id));
+    return flecs::entity(world_, ecs_get_typeid(world_, id_));
 }
 
 
@@ -68,21 +68,21 @@ inline flecs::entity id::type_id() const {
 
 template <typename T>
 inline flecs::id world::id() const {
-    return flecs::id(m_world, _::cpp_type<T>::id(m_world));
+    return flecs::id(world_, _::type<T>::id(world_));
 }
 
 template <typename ... Args>
 inline flecs::id world::id(Args&&... args) const {
-    return flecs::id(m_world, FLECS_FWD(args)...);
+    return flecs::id(world_, FLECS_FWD(args)...);
 }
 
 template <typename First, typename Second>
 inline flecs::id world::pair() const {
     return flecs::id(
-        m_world, 
+        world_, 
         ecs_pair(
-            _::cpp_type<First>::id(m_world), 
-            _::cpp_type<Second>::id(m_world)));
+            _::type<First>::id(world_), 
+            _::type<Second>::id(world_)));
 }
 
 template <typename First>
@@ -91,9 +91,9 @@ inline flecs::id world::pair(entity_t o) const {
         "cannot create nested pairs");
 
     return flecs::id(
-        m_world,
+        world_,
         ecs_pair(
-            _::cpp_type<First>::id(m_world), 
+            _::type<First>::id(world_), 
             o));
 }
 
@@ -102,7 +102,7 @@ inline flecs::id world::pair(entity_t r, entity_t o) const {
         "cannot create nested pairs");
 
     return flecs::id(
-        m_world,
+        world_,
         ecs_pair(r, o));
 }
 
diff --git a/include/flecs/addons/cpp/mixins/json/entity.inl b/include/flecs/addons/cpp/mixins/json/entity.inl
index 00f0aa381..a893e0618 100644
--- a/include/flecs/addons/cpp/mixins/json/entity.inl
+++ b/include/flecs/addons/cpp/mixins/json/entity.inl
@@ -5,5 +5,5 @@
  * @ingroup cpp_addons_json
  */
 const char* from_json(const char *json) {
-    return ecs_entity_from_json(m_world, m_id, json, nullptr);
+    return ecs_entity_from_json(world_, id_, json, nullptr);
 }
diff --git a/include/flecs/addons/cpp/mixins/json/entity_builder.inl b/include/flecs/addons/cpp/mixins/json/entity_builder.inl
index 66919dfee..d4279d1bb 100644
--- a/include/flecs/addons/cpp/mixins/json/entity_builder.inl
+++ b/include/flecs/addons/cpp/mixins/json/entity_builder.inl
@@ -13,16 +13,16 @@ Self& set_json(
     const char *json, 
     flecs::from_json_desc_t *desc = nullptr) 
 {
-    flecs::entity_t type = ecs_get_typeid(m_world, e);
+    flecs::entity_t type = ecs_get_typeid(world_, e);
     if (!type) {
         ecs_err("id is not a type");
         return to_base();
     }
 
-    void *ptr = ecs_ensure_id(m_world, m_id, e);
+    void *ptr = ecs_ensure_id(world_, id_, e);
     ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_ptr_from_json(m_world, type, ptr, json, desc);
-    ecs_modified_id(m_world, m_id, e);
+    ecs_ptr_from_json(world_, type, ptr, json, desc);
+    ecs_modified_id(world_, id_, e);
 
     return to_base();
 }
@@ -51,7 +51,7 @@ Self& set_json(
     const char *json, 
     flecs::from_json_desc_t *desc = nullptr) 
 {
-    return set_json(_::cpp_type<T>::id(m_world), json, desc);
+    return set_json(_::type<T>::id(world_), json, desc);
 }
 
 /** Set pair from JSON.
@@ -65,8 +65,8 @@ Self& set_json(
     flecs::from_json_desc_t *desc = nullptr) 
 {
     return set_json(
-        _::cpp_type<R>::id(m_world), 
-        _::cpp_type<T>::id(m_world),
+        _::type<R>::id(world_), 
+        _::type<T>::id(world_),
         json, desc);
 }
 
@@ -82,7 +82,7 @@ Self& set_json(
     flecs::from_json_desc_t *desc = nullptr) 
 {
     return set_json(
-        _::cpp_type<R>::id(m_world), t,
+        _::type<R>::id(world_), t,
         json, desc);
 }
 
@@ -98,6 +98,6 @@ Self& set_json_second(
     flecs::from_json_desc_t *desc = nullptr) 
 {
     return set_json(
-        r, _::cpp_type<T>::id(m_world),
+        r, _::type<T>::id(world_),
         json, desc);
 }
diff --git a/include/flecs/addons/cpp/mixins/json/entity_view.inl b/include/flecs/addons/cpp/mixins/json/entity_view.inl
index bbae32361..5180bbf61 100644
--- a/include/flecs/addons/cpp/mixins/json/entity_view.inl
+++ b/include/flecs/addons/cpp/mixins/json/entity_view.inl
@@ -9,6 +9,6 @@
  * @ingroup cpp_addons_json
  */
 flecs::string to_json(const flecs::entity_to_json_desc_t *desc = nullptr) const {
-    char *json = ecs_entity_to_json(m_world, m_id, desc);
+    char *json = ecs_entity_to_json(world_, id_, desc);
     return flecs::string(json);
 }
diff --git a/include/flecs/addons/cpp/mixins/json/iterable.inl b/include/flecs/addons/cpp/mixins/json/iterable.inl
index 1e1a0dc81..612c92a94 100644
--- a/include/flecs/addons/cpp/mixins/json/iterable.inl
+++ b/include/flecs/addons/cpp/mixins/json/iterable.inl
@@ -9,6 +9,6 @@
  * @ingroup cpp_addons_json
  */
 flecs::string to_json(flecs::iter_to_json_desc_t *desc = nullptr) {
-    char *json = ecs_iter_to_json(m_it.real_world, &m_it, desc);
+    char *json = ecs_iter_to_json(&it_, desc);
     return flecs::string(json);
 }
diff --git a/include/flecs/addons/cpp/mixins/json/world.inl b/include/flecs/addons/cpp/mixins/json/world.inl
index 041686eaa..f441e8dd4 100644
--- a/include/flecs/addons/cpp/mixins/json/world.inl
+++ b/include/flecs/addons/cpp/mixins/json/world.inl
@@ -9,7 +9,7 @@
  * @ingroup cpp_addons_json
  */
 flecs::string to_json(flecs::entity_t tid, const void* value) {
-    char *json = ecs_ptr_to_json(m_world, tid, value);
+    char *json = ecs_ptr_to_json(world_, tid, value);
     return flecs::string(json);
 }
 
@@ -20,7 +20,7 @@ flecs::string to_json(flecs::entity_t tid, const void* value) {
  */
 template <typename T>
 flecs::string to_json(const T* value) {
-    flecs::entity_t tid = _::cpp_type<T>::id(m_world);
+    flecs::entity_t tid = _::type<T>::id(world_);
     return to_json(tid, value);
 }
 
@@ -30,7 +30,7 @@ flecs::string to_json(const T* value) {
  * @ingroup cpp_addons_json
  */
 flecs::string to_json() {
-    return flecs::string( ecs_world_to_json(m_world, nullptr) );
+    return flecs::string( ecs_world_to_json(world_, nullptr) );
 }
 
 /** Deserialize value from JSON.
@@ -39,7 +39,7 @@ flecs::string to_json() {
  * @ingroup cpp_addons_json
  */
 const char* from_json(flecs::entity_t tid, void* value, const char *json, flecs::from_json_desc_t *desc = nullptr) {
-    return ecs_ptr_from_json(m_world, tid, value, json, desc);
+    return ecs_ptr_from_json(world_, tid, value, json, desc);
 }
 
 /** Deserialize value from JSON.
@@ -49,7 +49,7 @@ const char* from_json(flecs::entity_t tid, void* value, const char *json, flecs:
  */
 template <typename T>
 const char* from_json(T* value, const char *json, flecs::from_json_desc_t *desc = nullptr) {
-    return ecs_ptr_from_json(m_world, _::cpp_type<T>::id(m_world),
+    return ecs_ptr_from_json(world_, _::type<T>::id(world_),
         value, json, desc);
 }
 
@@ -59,7 +59,7 @@ const char* from_json(T* value, const char *json, flecs::from_json_desc_t *desc
  * @ingroup cpp_addons_json
  */
 const char* from_json(const char *json, flecs::from_json_desc_t *desc = nullptr) {
-    return ecs_world_from_json(m_world, json, desc);
+    return ecs_world_from_json(world_, json, desc);
 }
 
 /** Deserialize JSON file into world.
@@ -68,5 +68,5 @@ const char* from_json(const char *json, flecs::from_json_desc_t *desc = nullptr)
  * @ingroup cpp_addons_json
  */
 const char* from_json_file(const char *json, flecs::from_json_desc_t *desc = nullptr) {
-    return ecs_world_from_json_file(m_world, json, desc);
+    return ecs_world_from_json_file(world_, json, desc);
 }
diff --git a/include/flecs/addons/cpp/mixins/meta/component.inl b/include/flecs/addons/cpp/mixins/meta/component.inl
index b88ed4e97..39e6ca2cd 100644
--- a/include/flecs/addons/cpp/mixins/meta/component.inl
+++ b/include/flecs/addons/cpp/mixins/meta/component.inl
@@ -2,15 +2,15 @@
 /** Register opaque type interface */
 template <typename Func>
 component& opaque(const Func& type_support) {
-    flecs::world world(m_world);
+    flecs::world world(world_);
     auto ts = type_support(world);
-    ts.desc.entity = _::cpp_type<T>::id(m_world);
-    ecs_opaque_init(m_world, &ts.desc);
+    ts.desc.entity = _::type<T>::id(world_);
+    ecs_opaque_init(world_, &ts.desc);
     return *this;
 }
 
 flecs::opaque<T> opaque(flecs::entity_t as_type) {
-    return flecs::opaque<T>(m_world).as_type(as_type);
+    return flecs::opaque<T>(world_).as_type(as_type);
 }
 
 flecs::opaque<T> opaque(flecs::entity as_type) {
@@ -24,7 +24,7 @@ flecs::opaque<T> opaque(flecs::untyped_component as_type) {
 /** Return opaque type builder for collection type */
 template <typename ElemType>
 flecs::opaque<T, ElemType> opaque(flecs::id_t as_type) {
-    return flecs::opaque<T, ElemType>(m_world).as_type(as_type);
+    return flecs::opaque<T, ElemType>(world_).as_type(as_type);
 }
 
 /** Add constant. */
diff --git a/include/flecs/addons/cpp/mixins/meta/cursor.hpp b/include/flecs/addons/cpp/mixins/meta/cursor.hpp
index 6c699e501..868621c2d 100644
--- a/include/flecs/addons/cpp/mixins/meta/cursor.hpp
+++ b/include/flecs/addons/cpp/mixins/meta/cursor.hpp
@@ -21,42 +21,42 @@ namespace flecs {
  */
 struct cursor {
     cursor(flecs::world_t *world, flecs::entity_t type_id, void *ptr) {
-        m_cursor = ecs_meta_cursor(world, type_id, ptr);
+        cursor_ = ecs_meta_cursor(world, type_id, ptr);
     }
 
     /** Push value scope (such as a nested struct) */
     int push() {
-        return ecs_meta_push(&m_cursor);
+        return ecs_meta_push(&cursor_);
     }
 
     /** Pop value scope */
     int pop() {
-        return ecs_meta_pop(&m_cursor);
+        return ecs_meta_pop(&cursor_);
     }
 
     /** Move to next member/element */
     int next() {
-        return ecs_meta_next(&m_cursor);
+        return ecs_meta_next(&cursor_);
     }
 
     /** Move to member by name */
     int member(const char *name) {
-        return ecs_meta_member(&m_cursor, name);
+        return ecs_meta_member(&cursor_, name);
     }
 
     /** Move to element by index */
     int elem(int32_t elem) {
-        return ecs_meta_elem(&m_cursor, elem);
+        return ecs_meta_elem(&cursor_, elem);
     }
 
     /** Test if current scope is a collection type */
     bool is_collection() {
-        return ecs_meta_is_collection(&m_cursor);
+        return ecs_meta_is_collection(&cursor_);
     }
 
     /** Get member name */
     flecs::string_view get_member() const {
-        return flecs::string_view(ecs_meta_get_member(&m_cursor));
+        return flecs::string_view(ecs_meta_get_member(&cursor_));
     }
 
     /** Get type of value */
@@ -67,94 +67,94 @@ struct cursor {
 
     /** Get untyped pointer to value */
     void* get_ptr() {
-        return ecs_meta_get_ptr(&m_cursor);
+        return ecs_meta_get_ptr(&cursor_);
     }
 
     /** Set boolean value */
     int set_bool(bool value) {
-        return ecs_meta_set_bool(&m_cursor, value);
+        return ecs_meta_set_bool(&cursor_, value);
     }
 
     /** Set char value */
     int set_char(char value) {
-        return ecs_meta_set_char(&m_cursor, value);
+        return ecs_meta_set_char(&cursor_, value);
     }
 
     /** Set signed int value */
     int set_int(int64_t value) {
-        return ecs_meta_set_int(&m_cursor, value);
+        return ecs_meta_set_int(&cursor_, value);
     }
 
     /** Set unsigned int value */
     int set_uint(uint64_t value) {
-        return ecs_meta_set_uint(&m_cursor, value);
+        return ecs_meta_set_uint(&cursor_, value);
     }
 
     /** Set float value */
     int set_float(double value) {
-        return ecs_meta_set_float(&m_cursor, value);
+        return ecs_meta_set_float(&cursor_, value);
     }
 
     /** Set string value */
     int set_string(const char *value) {
-        return ecs_meta_set_string(&m_cursor, value);
+        return ecs_meta_set_string(&cursor_, value);
     }
 
     /** Set string literal value */
     int set_string_literal(const char *value) {
-        return ecs_meta_set_string_literal(&m_cursor, value);
+        return ecs_meta_set_string_literal(&cursor_, value);
     }
 
     /** Set entity value */
     int set_entity(flecs::entity_t value) {
-        return ecs_meta_set_entity(&m_cursor, value);
+        return ecs_meta_set_entity(&cursor_, value);
     }
 
     /** Set (component) id value */
     int set_id(flecs::id_t value) {
-        return ecs_meta_set_id(&m_cursor, value);
+        return ecs_meta_set_id(&cursor_, value);
     }
 
     /** Set null value */
     int set_null() {
-        return ecs_meta_set_null(&m_cursor);
+        return ecs_meta_set_null(&cursor_);
     }
 
     /** Get boolean value */
     bool get_bool() const {
-        return ecs_meta_get_bool(&m_cursor);
+        return ecs_meta_get_bool(&cursor_);
     }
 
     /** Get char value */
     char get_char() const {
-        return ecs_meta_get_char(&m_cursor);
+        return ecs_meta_get_char(&cursor_);
     }
 
     /** Get signed int value */
     int64_t get_int() const {
-        return ecs_meta_get_int(&m_cursor);
+        return ecs_meta_get_int(&cursor_);
     }
 
     /** Get unsigned int value */
     uint64_t get_uint() const {
-        return ecs_meta_get_uint(&m_cursor);
+        return ecs_meta_get_uint(&cursor_);
     }
 
     /** Get float value */
     double get_float() const {
-        return ecs_meta_get_float(&m_cursor);
+        return ecs_meta_get_float(&cursor_);
     }
 
     /** Get string value */
     const char *get_string() const {
-        return ecs_meta_get_string(&m_cursor);
+        return ecs_meta_get_string(&cursor_);
     }
 
     /** Get entity value */
     flecs::entity get_entity() const;
 
     /** Cursor object */
-    ecs_meta_cursor_t m_cursor;
+    ecs_meta_cursor_t cursor_;
 };
 
 /** @} */
diff --git a/include/flecs/addons/cpp/mixins/meta/decl.hpp b/include/flecs/addons/cpp/mixins/meta/decl.hpp
index 2fccd82e6..0e7c93deb 100644
--- a/include/flecs/addons/cpp/mixins/meta/decl.hpp
+++ b/include/flecs/addons/cpp/mixins/meta/decl.hpp
@@ -37,8 +37,8 @@ using enum_constant_t = ecs_enum_constant_t;
 using bitmask_constant_t = ecs_bitmask_constant_t;
 
 /* Components */
-using MetaType = EcsMetaType;
-using MetaTypeSerialized = EcsMetaTypeSerialized;
+using Type = EcsType;
+using TypeSerializer = EcsTypeSerializer;
 using Primitive = EcsPrimitive;
 using Enum = EcsEnum;
 using Bitmask = EcsBitmask;
diff --git a/include/flecs/addons/cpp/mixins/meta/entity_builder.inl b/include/flecs/addons/cpp/mixins/meta/entity_builder.inl
index ea94fa1f7..0077b1703 100644
--- a/include/flecs/addons/cpp/mixins/meta/entity_builder.inl
+++ b/include/flecs/addons/cpp/mixins/meta/entity_builder.inl
@@ -20,7 +20,7 @@ Self& unit(
     int32_t power = 0) 
 {
     ecs_unit_desc_t desc = {};
-    desc.entity = this->m_id;
+    desc.entity = this->id_;
     desc.symbol = const_cast<char*>(symbol); /* safe, will be copied in */
     desc.base = base;
     desc.over = over;
@@ -41,7 +41,7 @@ Self& unit(
     int32_t power = 0) 
 {
     ecs_unit_desc_t desc = {};
-    desc.entity = this->m_id;
+    desc.entity = this->id_;
     desc.base = base;
     desc.over = over;
     desc.prefix = prefix;
@@ -59,7 +59,7 @@ Self& unit_prefix(
     int32_t power = 0) 
 {
     ecs_unit_prefix_desc_t desc = {};
-    desc.entity = this->m_id;
+    desc.entity = this->id_;
     desc.symbol = const_cast<char*>(symbol); /* safe, will be copied in */
     desc.translation.factor = factor;
     desc.translation.power = power;
@@ -77,7 +77,7 @@ Self& quantity(flecs::entity_t quantity) {
 /** Make entity a unity prefix */
 template <typename Quantity>
 Self& quantity() {
-    return this->quantity(_::cpp_type<Quantity>::id(this->world()));
+    return this->quantity(_::type<Quantity>::id(this->world()));
 }
 
 /** Make entity a quantity */
diff --git a/include/flecs/addons/cpp/mixins/meta/impl.hpp b/include/flecs/addons/cpp/mixins/meta/impl.hpp
index 6296ae0d6..e6f18a843 100644
--- a/include/flecs/addons/cpp/mixins/meta/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/meta/impl.hpp
@@ -43,29 +43,29 @@ inline void init(flecs::world& world) {
 
     world.component<type_kind_t>("flecs::meta::type_kind");
     world.component<primitive_kind_t>("flecs::meta::primitive_kind");
-    world.component<member_t>("flecs::meta::member");
+    world.component<member_t>("flecs::meta::member_t");
     world.component<enum_constant_t>("flecs::meta::enum_constant");
     world.component<bitmask_constant_t>("flecs::meta::bitmask_constant");
 
-    world.component<MetaType>("flecs::meta::MetaType");
-    world.component<MetaTypeSerialized>("flecs::meta::MetaTypeSerialized");
-    world.component<Primitive>("flecs::meta::Primitive");
-    world.component<Enum>("flecs::meta::Enum");
-    world.component<Bitmask>("flecs::meta::Bitmask");
-    world.component<Member>("flecs::meta::Member");
-    world.component<MemberRanges>("flecs::meta::MemberRanges");
-    world.component<Struct>("flecs::meta::Struct");
-    world.component<Array>("flecs::meta::Array");
-    world.component<Vector>("flecs::meta::Vector");
+    world.component<Type>("flecs::meta::type");
+    world.component<TypeSerializer>("flecs::meta::TypeSerializer");
+    world.component<Primitive>("flecs::meta::primitive");
+    world.component<Enum>("flecs::meta::enum");
+    world.component<Bitmask>("flecs::meta::bitmask");
+    world.component<Member>("flecs::meta::member");
+    world.component<MemberRanges>("flecs::meta::member_ranges");
+    world.component<Struct>("flecs::meta::struct");
+    world.component<Array>("flecs::meta::array");
+    world.component<Vector>("flecs::meta::vector");
 
-    world.component<Unit>("flecs::meta::Unit");
+    world.component<Unit>("flecs::meta::unit");
 
     // To support member<uintptr_t> and member<intptr_t> register components
     // (that do not have conflicting symbols with builtin ones) for platform
     // specific types.
 
     if (!flecs::is_same<i32_t, iptr_t>() && !flecs::is_same<i64_t, iptr_t>()) {
-        flecs::_::cpp_type<iptr_t>::init(flecs::Iptr, true);
+        flecs::_::type<iptr_t>::init(flecs::Iptr, true);
         ecs_assert(flecs::type_id<iptr_t>() == flecs::Iptr, 
             ECS_INTERNAL_ERROR, NULL);
         // Remove symbol to prevent validation errors, as it doesn't match with 
@@ -74,7 +74,7 @@ inline void init(flecs::world& world) {
     }
 
     if (!flecs::is_same<u32_t, uptr_t>() && !flecs::is_same<u64_t, uptr_t>()) {
-        flecs::_::cpp_type<uptr_t>::init(flecs::Uptr, true);
+        flecs::_::type<uptr_t>::init(flecs::Uptr, true);
         ecs_assert(flecs::type_id<uptr_t>() == flecs::Uptr, 
             ECS_INTERNAL_ERROR, NULL);
         // Remove symbol to prevent validation errors, as it doesn't match with 
@@ -97,24 +97,24 @@ inline void init(flecs::world& world) {
 
 
 inline flecs::entity cursor::get_type() const {
-    return flecs::entity(m_cursor.world, ecs_meta_get_type(&m_cursor));
+    return flecs::entity(cursor_.world, ecs_meta_get_type(&cursor_));
 }
 
 inline flecs::entity cursor::get_unit() const {
-    return flecs::entity(m_cursor.world, ecs_meta_get_unit(&m_cursor));
+    return flecs::entity(cursor_.world, ecs_meta_get_unit(&cursor_));
 }
 
 inline flecs::entity cursor::get_entity() const {
-    return flecs::entity(m_cursor.world, ecs_meta_get_entity(&m_cursor));
+    return flecs::entity(cursor_.world, ecs_meta_get_entity(&cursor_));
 }
 
 /** Create primitive type */
 inline flecs::entity world::primitive(flecs::meta::primitive_kind_t kind) {
     ecs_primitive_desc_t desc = {};
     desc.kind = kind;
-    flecs::entity_t eid = ecs_primitive_init(m_world, &desc);
+    flecs::entity_t eid = ecs_primitive_init(world_, &desc);
     ecs_assert(eid != 0, ECS_INVALID_OPERATION, NULL);
-    return flecs::entity(m_world, eid);
+    return flecs::entity(world_, eid);
 }
 
 /** Create array type. */
@@ -122,28 +122,28 @@ inline flecs::entity world::array(flecs::entity_t elem_id, int32_t array_count)
     ecs_array_desc_t desc = {};
     desc.type = elem_id;
     desc.count = array_count;
-    flecs::entity_t eid = ecs_array_init(m_world, &desc);
+    flecs::entity_t eid = ecs_array_init(world_, &desc);
     ecs_assert(eid != 0, ECS_INVALID_OPERATION, NULL);
-    return flecs::entity(m_world, eid);
+    return flecs::entity(world_, eid);
 }
 
 /** Create array type. */
 template <typename T>
 inline flecs::entity world::array(int32_t array_count) {
-    return this->array(_::cpp_type<T>::id(m_world), array_count);
+    return this->array(_::type<T>::id(world_), array_count);
 }
 
 inline flecs::entity world::vector(flecs::entity_t elem_id) {
     ecs_vector_desc_t desc = {};
     desc.type = elem_id;
-    flecs::entity_t eid = ecs_vector_init(m_world, &desc);
+    flecs::entity_t eid = ecs_vector_init(world_, &desc);
     ecs_assert(eid != 0, ECS_INVALID_OPERATION, NULL);
-    return flecs::entity(m_world, eid);
+    return flecs::entity(world_, eid);
 }
 
 template <typename T>
 inline flecs::entity world::vector() {
-    return this->vector(_::cpp_type<T>::id(m_world));
+    return this->vector(_::type<T>::id(world_));
 }
 
 } // namespace flecs
@@ -154,7 +154,7 @@ inline int ecs_serializer_t::value(ecs_entity_t type, const void *v) const {
 
 template <typename T>
 inline int ecs_serializer_t::value(const T& v) const {
-    return this->value(flecs::_::cpp_type<T>::id(
+    return this->value(flecs::_::type<T>::id(
         const_cast<flecs::world_t*>(this->world)), &v);
 }
 
diff --git a/include/flecs/addons/cpp/mixins/meta/opaque.hpp b/include/flecs/addons/cpp/mixins/meta/opaque.hpp
index 7ff9f3614..d1f23803c 100644
--- a/include/flecs/addons/cpp/mixins/meta/opaque.hpp
+++ b/include/flecs/addons/cpp/mixins/meta/opaque.hpp
@@ -32,7 +32,7 @@ template <typename T, typename ElemType = void>
 struct opaque {
     opaque(flecs::world_t *w = nullptr) : world(w) {
         if (world) {
-            desc.entity = _::cpp_type<T>::id(world);
+            desc.entity = _::type<T>::id(world);
         }
     }
 
diff --git a/include/flecs/addons/cpp/mixins/meta/untyped_component.inl b/include/flecs/addons/cpp/mixins/meta/untyped_component.inl
index 7df9faea9..00733daf6 100644
--- a/include/flecs/addons/cpp/mixins/meta/untyped_component.inl
+++ b/include/flecs/addons/cpp/mixins/meta/untyped_component.inl
@@ -14,11 +14,11 @@
 untyped_component& member(flecs::entity_t type_id, flecs::entity_t unit, const char *name, int32_t count = 0, size_t offset = 0) {
     ecs_entity_desc_t desc = {};
     desc.name = name;
-    desc.add[0] = ecs_pair(flecs::ChildOf, m_id);
-    ecs_entity_t eid = ecs_entity_init(m_world, &desc);
+    desc.parent = id_;
+    ecs_entity_t eid = ecs_entity_init(world_, &desc);
     ecs_assert(eid != 0, ECS_INTERNAL_ERROR, NULL);
 
-    flecs::entity e(m_world, eid);
+    flecs::entity e(world_, eid);
 
     Member m = {};
     m.type = type_id;
@@ -38,29 +38,29 @@ untyped_component& member(flecs::entity_t type_id, const char* name, int32_t cou
 /** Add member. */
 template <typename MemberType>
 untyped_component& member(const char *name, int32_t count = 0, size_t offset = 0) {
-    flecs::entity_t type_id = _::cpp_type<MemberType>::id(m_world);
+    flecs::entity_t type_id = _::type<MemberType>::id(world_);
     return member(type_id, name, count, offset);
 }
 
 /** Add member with unit. */
 template <typename MemberType>
 untyped_component& member(flecs::entity_t unit, const char *name, int32_t count = 0, size_t offset = 0) {
-    flecs::entity_t type_id = _::cpp_type<MemberType>::id(m_world);
+    flecs::entity_t type_id = _::type<MemberType>::id(world_);
     return member(type_id, unit, name, count, offset);
 }
 
 /** Add member with unit. */
 template <typename MemberType, typename UnitType>
 untyped_component& member(const char *name, int32_t count = 0, size_t offset = 0) {
-    flecs::entity_t type_id = _::cpp_type<MemberType>::id(m_world);
-    flecs::entity_t unit_id = _::cpp_type<UnitType>::id(m_world);
+    flecs::entity_t type_id = _::type<MemberType>::id(world_);
+    flecs::entity_t unit_id = _::type<UnitType>::id(world_);
     return member(type_id, unit_id, name, count, offset);
 }
 
 /** Add member using pointer-to-member. */
 template <typename MemberType, typename ComponentType, typename RealType = typename std::remove_extent<MemberType>::type>
 untyped_component& member(const char* name, const MemberType ComponentType::* ptr) {
-    flecs::entity_t type_id = _::cpp_type<RealType>::id(m_world);
+    flecs::entity_t type_id = _::type<RealType>::id(world_);
     size_t offset = reinterpret_cast<size_t>(&(static_cast<ComponentType*>(nullptr)->*ptr));
     return member(type_id, name, std::extent<MemberType>::value, offset);
 }
@@ -68,7 +68,7 @@ untyped_component& member(const char* name, const MemberType ComponentType::* pt
 /** Add member with unit using pointer-to-member. */
 template <typename MemberType, typename ComponentType, typename RealType = typename std::remove_extent<MemberType>::type>
 untyped_component& member(flecs::entity_t unit, const char* name, const MemberType ComponentType::* ptr) {
-    flecs::entity_t type_id = _::cpp_type<RealType>::id(m_world);
+    flecs::entity_t type_id = _::type<RealType>::id(world_);
     size_t offset = reinterpret_cast<size_t>(&(static_cast<ComponentType*>(nullptr)->*ptr));
     return member(type_id, unit, name, std::extent<MemberType>::value, offset);
 }
@@ -76,23 +76,23 @@ untyped_component& member(flecs::entity_t unit, const char* name, const MemberTy
 /** Add member with unit using pointer-to-member. */
 template <typename UnitType, typename MemberType, typename ComponentType, typename RealType = typename std::remove_extent<MemberType>::type>
 untyped_component& member(const char* name, const MemberType ComponentType::* ptr) {
-    flecs::entity_t type_id = _::cpp_type<RealType>::id(m_world);
-    flecs::entity_t unit_id = _::cpp_type<UnitType>::id(m_world);
+    flecs::entity_t type_id = _::type<RealType>::id(world_);
+    flecs::entity_t unit_id = _::type<UnitType>::id(world_);
     size_t offset = reinterpret_cast<size_t>(&(static_cast<ComponentType*>(nullptr)->*ptr));
     return member(type_id, unit_id, name, std::extent<MemberType>::value, offset);
 }
 
 /** Add constant. */
 untyped_component& constant(const char *name, int32_t value) {
-    ecs_add_id(m_world, m_id, _::cpp_type<flecs::Enum>::id(m_world));
+    ecs_add_id(world_, id_, _::type<flecs::Enum>::id(world_));
 
     ecs_entity_desc_t desc = {};
     desc.name = name;
-    desc.add[0] = ecs_pair(flecs::ChildOf, m_id);
-    ecs_entity_t eid = ecs_entity_init(m_world, &desc);
+    desc.parent = id_;
+    ecs_entity_t eid = ecs_entity_init(world_, &desc);
     ecs_assert(eid != 0, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_set_id(m_world, eid, 
+    ecs_set_id(world_, eid, 
         ecs_pair(flecs::Constant, flecs::I32), sizeof(int32_t),
         &value);
 
@@ -101,15 +101,15 @@ untyped_component& constant(const char *name, int32_t value) {
 
 /** Add bitmask constant. */
 untyped_component& bit(const char *name, uint32_t value) {
-    ecs_add_id(m_world, m_id, _::cpp_type<flecs::Bitmask>::id(m_world));
+    ecs_add_id(world_, id_, _::type<flecs::Bitmask>::id(world_));
 
     ecs_entity_desc_t desc = {};
     desc.name = name;
-    desc.add[0] = ecs_pair(flecs::ChildOf, m_id);
-    ecs_entity_t eid = ecs_entity_init(m_world, &desc);
+    desc.parent = id_;
+    ecs_entity_t eid = ecs_entity_init(world_, &desc);
     ecs_assert(eid != 0, ECS_INTERNAL_ERROR, NULL);
 
-    ecs_set_id(m_world, eid, 
+    ecs_set_id(world_, eid, 
         ecs_pair(flecs::Constant, flecs::U32), sizeof(uint32_t),
         &value);
 
@@ -120,21 +120,21 @@ untyped_component& bit(const char *name, uint32_t value) {
 template <typename Elem>
 untyped_component& array(int32_t elem_count) {
     ecs_array_desc_t desc = {};
-    desc.entity = m_id;
-    desc.type = _::cpp_type<Elem>::id(m_world);
+    desc.entity = id_;
+    desc.type = _::type<Elem>::id(world_);
     desc.count = elem_count;
-    ecs_array_init(m_world, &desc);
+    ecs_array_init(world_, &desc);
     return *this;
 }
 
 /** Add member value range */
 untyped_component& range(double min, double max) {
-    const flecs::member_t *m = ecs_cpp_last_member(m_world, m_id);
+    const flecs::member_t *m = ecs_cpp_last_member(world_, id_);
     if (!m) {
         return *this;
     }
 
-    flecs::world w(m_world);
+    flecs::world w(world_);
     flecs::entity me = w.entity(m->member);
 
     // Don't use C++ ensure because Unreal defines a macro called ensure
@@ -148,12 +148,12 @@ untyped_component& range(double min, double max) {
 
 /** Add member warning range */
 untyped_component& warning_range(double min, double max) {
-    const flecs::member_t *m = ecs_cpp_last_member(m_world, m_id);
+    const flecs::member_t *m = ecs_cpp_last_member(world_, id_);
     if (!m) {
         return *this;
     }
 
-    flecs::world w(m_world);
+    flecs::world w(world_);
     flecs::entity me = w.entity(m->member);
 
     // Don't use C++ ensure because Unreal defines a macro called ensure
@@ -167,12 +167,12 @@ untyped_component& warning_range(double min, double max) {
 
 /** Add member error range */
 untyped_component& error_range(double min, double max) {
-    const flecs::member_t *m = ecs_cpp_last_member(m_world, m_id);
+    const flecs::member_t *m = ecs_cpp_last_member(world_, id_);
     if (!m) {
         return *this;
     }
 
-    flecs::world w(m_world);
+    flecs::world w(world_);
     flecs::entity me = w.entity(m->member);
 
     // Don't use C++ ensure because Unreal defines a macro called ensure
diff --git a/include/flecs/addons/cpp/mixins/meta/world.inl b/include/flecs/addons/cpp/mixins/meta/world.inl
index 9d0b5d69d..707f94c30 100644
--- a/include/flecs/addons/cpp/mixins/meta/world.inl
+++ b/include/flecs/addons/cpp/mixins/meta/world.inl
@@ -10,28 +10,15 @@
  * @{
  */
 
-/** Convert value to string */
-flecs::string to_expr(flecs::entity_t tid, const void* value) {
-    char *expr = ecs_ptr_to_expr(m_world, tid, value);
-    return flecs::string(expr);
-}
-
-/** Convert value to string */
-template <typename T>
-flecs::string to_expr(const T* value) {
-    flecs::entity_t tid = _::cpp_type<T>::id(m_world);
-    return to_expr(tid, value);
-}
-
 /** Return meta cursor to value */
 flecs::cursor cursor(flecs::entity_t tid, void *ptr) {
-    return flecs::cursor(m_world, tid, ptr);
+    return flecs::cursor(world_, tid, ptr);
 }
 
 /** Return meta cursor to value */
 template <typename T>
 flecs::cursor cursor(void *ptr) {
-    flecs::entity_t tid = _::cpp_type<T>::id(m_world);
+    flecs::entity_t tid = _::type<T>::id(world_);
     return cursor(tid, ptr);
 }
 
diff --git a/include/flecs/addons/cpp/mixins/metrics/builder.hpp b/include/flecs/addons/cpp/mixins/metrics/builder.hpp
index 0ffb133d3..b8cc961b1 100644
--- a/include/flecs/addons/cpp/mixins/metrics/builder.hpp
+++ b/include/flecs/addons/cpp/mixins/metrics/builder.hpp
@@ -17,15 +17,15 @@ namespace flecs {
 /** Event builder interface */
 struct metric_builder {
     metric_builder(flecs::world_t *world, flecs::entity_t entity) 
-        : m_world(world) 
+        : world_(world) 
     {
-        m_desc.entity = entity;
+        desc_.entity = entity;
     }
 
     ~metric_builder();
 
     metric_builder& member(flecs::entity_t e) {
-        m_desc.member = e;
+        desc_.member = e;
         return *this;
     }
 
@@ -40,61 +40,61 @@ struct metric_builder {
     metric_builder& dotmember(const char *name);
 
     metric_builder& id(flecs::id_t the_id) {
-        m_desc.id = the_id;
+        desc_.id = the_id;
         return *this;
     }
 
     metric_builder& id(flecs::entity_t first, flecs::entity_t second) {
-        m_desc.id = ecs_pair(first, second);
+        desc_.id = ecs_pair(first, second);
         return *this;
     }
 
     template <typename T>
     metric_builder& id() {
-        return id(_::cpp_type<T>::id(m_world));
+        return id(_::type<T>::id(world_));
     }
 
     template <typename First>
     metric_builder& id(flecs::entity_t second) {
-        return id(_::cpp_type<First>::id(m_world), second);
+        return id(_::type<First>::id(world_), second);
     }
 
     template <typename Second>
     metric_builder& id_second(flecs::entity_t first) {
-        return id(first, _::cpp_type<Second>::id(m_world));
+        return id(first, _::type<Second>::id(world_));
     }
 
     template <typename First, typename Second>
     metric_builder& id() {
-        return id<First>(_::cpp_type<Second>::id(m_world));
+        return id<First>(_::type<Second>::id(world_));
     }
 
     metric_builder& targets(bool value = true) {
-        m_desc.targets = value;
+        desc_.targets = value;
         return *this;
     }
 
     metric_builder& kind(flecs::entity_t the_kind) {
-        m_desc.kind = the_kind;
+        desc_.kind = the_kind;
         return *this;
     }
 
     template <typename Kind>
     metric_builder& kind() {
-        return kind(_::cpp_type<Kind>::id(m_world));
+        return kind(_::type<Kind>::id(world_));
     }
 
     metric_builder& brief(const char *b) {
-        m_desc.brief = b;
+        desc_.brief = b;
         return *this;
     }
 
     operator flecs::entity();
 
 protected:
-    flecs::world_t *m_world;
-    ecs_metric_desc_t m_desc = {};
-    bool m_created = false;
+    flecs::world_t *world_;
+    ecs_metric_desc_t desc_ = {};
+    bool created_ = false;
 };
 
 /**
diff --git a/include/flecs/addons/cpp/mixins/metrics/impl.hpp b/include/flecs/addons/cpp/mixins/metrics/impl.hpp
index a4e41bcaa..e8b5b6132 100644
--- a/include/flecs/addons/cpp/mixins/metrics/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/metrics/impl.hpp
@@ -25,18 +25,18 @@ inline metrics::metrics(flecs::world& world) {
 }
 
 inline metric_builder::~metric_builder() {
-    if (!m_created) {
-        ecs_metric_init(m_world, &m_desc);
+    if (!created_) {
+        ecs_metric_init(world_, &desc_);
     }
 }
 
 inline metric_builder& metric_builder::member(const char *name) {
     flecs::entity m;
-    if (m_desc.id) {
-        flecs::entity_t type = ecs_get_typeid(m_world, m_desc.id);
-        m = flecs::entity(m_world, type).lookup(name);
+    if (desc_.id) {
+        flecs::entity_t type = ecs_get_typeid(world_, desc_.id);
+        m = flecs::entity(world_, type).lookup(name);
     } else {
-        m = flecs::world(m_world).lookup(name);
+        m = flecs::world(world_).lookup(name);
     }
     if (!m) {
         flecs::log::err("member '%s' not found", name);
@@ -46,7 +46,7 @@ inline metric_builder& metric_builder::member(const char *name) {
 
 template <typename T>
 inline metric_builder& metric_builder::member(const char *name) {
-    flecs::entity e (m_world, _::cpp_type<T>::id(m_world));
+    flecs::entity e (world_, _::type<T>::id(world_));
     flecs::entity_t m = e.lookup(name);
     if (!m) {
         flecs::log::err("member '%s' not found in type '%s'", 
@@ -57,32 +57,32 @@ inline metric_builder& metric_builder::member(const char *name) {
 }
 
 inline metric_builder& metric_builder::dotmember(const char *expr) {
-    m_desc.dotmember = expr;
+    desc_.dotmember = expr;
     return *this;
 }
 
 template <typename T>
 inline metric_builder& metric_builder::dotmember(const char *expr) {
-    m_desc.dotmember = expr;
-    m_desc.id = _::cpp_type<T>::id(m_world);
+    desc_.dotmember = expr;
+    desc_.id = _::type<T>::id(world_);
     return *this;
 }
 
 inline metric_builder::operator flecs::entity() {
-    if (!m_created) {
-        m_created = true;
-        flecs::entity result(m_world, ecs_metric_init(m_world, &m_desc));
-        m_desc.entity = result;
+    if (!created_) {
+        created_ = true;
+        flecs::entity result(world_, ecs_metric_init(world_, &desc_));
+        desc_.entity = result;
         return result;
     } else {
-        return flecs::entity(m_world, m_desc.entity);
+        return flecs::entity(world_, desc_.entity);
     }
 }
 
 template <typename... Args>
 inline flecs::metric_builder world::metric(Args &&... args) const {
-    flecs::entity result(m_world, FLECS_FWD(args)...);
-    return flecs::metric_builder(m_world, result);
+    flecs::entity result(world_, FLECS_FWD(args)...);
+    return flecs::metric_builder(world_, result);
 }
 
 template <typename Kind>
@@ -91,8 +91,8 @@ inline untyped_component& untyped_component::metric(
     const char *brief, 
     const char *metric_name) 
 {
-    flecs::world w(m_world);
-    flecs::entity e(m_world, m_id);
+    flecs::world w(world_);
+    flecs::entity e(world_, id_);
 
     const flecs::member_t *m = ecs_cpp_last_member(w, e);
     if (!m) {
diff --git a/include/flecs/addons/cpp/mixins/module/impl.hpp b/include/flecs/addons/cpp/mixins/module/impl.hpp
index c8b689b6e..8a772ad9b 100644
--- a/include/flecs/addons/cpp/mixins/module/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/module/impl.hpp
@@ -18,17 +18,17 @@ ecs_entity_t do_import(world& world, const char *symbol) {
 
     // Initialize module component type & don't allow it to be registered as a
     // tag, as this would prevent calling emplace()
-    auto m_c = component<T>(world, nullptr, false);
-    ecs_add_id(world, m_c, EcsModule);
+    auto c_ = component<T>(world, nullptr, false);
+    ecs_add_id(world, c_, EcsModule);
 
-    ecs_set_scope(world, m_c);
+    ecs_set_scope(world, c_);
     world.emplace<T>(world);
     ecs_set_scope(world, scope);
 
     // It should now be possible to lookup the module
     ecs_entity_t m = ecs_lookup_symbol(world, symbol, false, false);
     ecs_assert(m != 0, ECS_MODULE_UNDEFINED, symbol);
-    ecs_assert(m == m_c, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(m == c_, ECS_INTERNAL_ERROR, NULL);
 
     ecs_log_pop();
 
@@ -41,11 +41,11 @@ flecs::entity import(world& world) {
 
     ecs_entity_t m = ecs_lookup_symbol(world, symbol, true, false);
 
-    if (!_::cpp_type<T>::registered(world)) {
+    if (!_::type<T>::registered(world)) {
 
         /* Module is registered with world, initialize static data */
         if (m) {
-            _::cpp_type<T>::init(m, false);
+            _::type<T>::init(m, false);
 
         /* Module is not yet registered, register it now */
         } else {
@@ -73,12 +73,12 @@ flecs::entity import(world& world) {
 
 template <typename Module>
 inline flecs::entity world::module(const char *name) const {
-    flecs::id_t result = _::cpp_type<Module>::id(m_world, nullptr, false);
+    flecs::id_t result = _::type<Module>::id(world_, nullptr, false);
     if (name) {
-        ecs_add_path_w_sep(m_world, result, 0, name, "::", "::");
+        ecs_add_path_w_sep(world_, result, 0, name, "::", "::");
     }
-    ecs_set_scope(m_world, result);
-    return flecs::entity(m_world, result);
+    ecs_set_scope(world_, result);
+    return flecs::entity(world_, result);
 }
 
 template <typename Module>
diff --git a/include/flecs/addons/cpp/mixins/observer/builder_i.hpp b/include/flecs/addons/cpp/mixins/observer/builder_i.hpp
index a4582371b..fd27b68bc 100644
--- a/include/flecs/addons/cpp/mixins/observer/builder_i.hpp
+++ b/include/flecs/addons/cpp/mixins/observer/builder_i.hpp
@@ -5,7 +5,7 @@
 
 #pragma once
 
-#include "../filter/builder_i.hpp"
+#include "../query/builder_i.hpp"
 
 namespace flecs {
 
@@ -14,23 +14,23 @@ namespace flecs {
  * @ingroup cpp_observers
  */
 template<typename Base, typename ... Components>
-struct observer_builder_i : filter_builder_i<Base, Components ...> {
-    using BaseClass = filter_builder_i<Base, Components ...>;
+struct observer_builder_i : query_builder_i<Base, Components ...> {
+    using BaseClass = query_builder_i<Base, Components ...>;
     observer_builder_i()
         : BaseClass(nullptr)
-        , m_desc(nullptr)
-        , m_event_count(0) { }
+        , desc_(nullptr)
+        , event_count_(0) { }
 
     observer_builder_i(ecs_observer_desc_t *desc) 
-        : BaseClass(&desc->filter)
-        , m_desc(desc)
-        , m_event_count(0) { }
+        : BaseClass(&desc->query)
+        , desc_(desc)
+        , event_count_(0) { }
 
     /** Specify the event(s) for when the observer should run.
      * @param evt The event.
      */
     Base& event(entity_t evt) {
-        m_desc->events[m_event_count ++] = evt;
+        desc_->events[event_count_ ++] = evt;
         return *this;
     }
 
@@ -39,25 +39,25 @@ struct observer_builder_i : filter_builder_i<Base, Components ...> {
      */
     template <typename E>
     Base& event() {
-        m_desc->events[m_event_count ++] = _::cpp_type<E>().id(world_v());
+        desc_->events[event_count_ ++] = _::type<E>().id(world_v());
         return *this;
     }
 
-    /** Invoke observer for anything that matches its filter on creation */
+    /** Invoke observer for anything that matches its query on creation */
     Base& yield_existing(bool value = true) {
-        m_desc->yield_existing = value;
+        desc_->yield_existing = value;
         return *this;
     }
 
     /** Set observer context */
     Base& ctx(void *ptr) {
-        m_desc->ctx = ptr;
+        desc_->ctx = ptr;
         return *this;
     }
 
     /** Set observer run callback */
     Base& run(ecs_iter_action_t action) {
-        m_desc->run = action;
+        desc_->run = action;
         return *this;
     }
 
@@ -69,8 +69,8 @@ struct observer_builder_i : filter_builder_i<Base, Components ...> {
         return *static_cast<Base*>(this);
     }
 
-    ecs_observer_desc_t *m_desc;
-    int32_t m_event_count;
+    ecs_observer_desc_t *desc_;
+    int32_t event_count_;
 };
 
 }
diff --git a/include/flecs/addons/cpp/mixins/observer/impl.hpp b/include/flecs/addons/cpp/mixins/observer/impl.hpp
index 506305c6a..72a0d05eb 100644
--- a/include/flecs/addons/cpp/mixins/observer/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/observer/impl.hpp
@@ -18,44 +18,38 @@ struct observer final : entity
 
     observer(flecs::world_t *world, ecs_observer_desc_t *desc, bool instanced) 
     {
-        if (!desc->filter.instanced) {
-            desc->filter.instanced = instanced;
+        if (!(desc->query.flags & EcsQueryIsInstanced)) {
+            ECS_BIT_COND(desc->query.flags, EcsQueryIsInstanced, instanced);
         }
 
-        m_world = world;
-        m_id = ecs_observer_init(world, desc);
-
-        if (desc->filter.terms_buffer) {
-            ecs_os_free(desc->filter.terms_buffer);
-        }
+        world_ = world;
+        id_ = ecs_observer_init(world, desc);
     }
 
     void ctx(void *ctx) {
         ecs_observer_desc_t desc = {};
-        desc.entity = m_id;
+        desc.entity = id_;
         desc.ctx = ctx;
-        ecs_observer_init(m_world, &desc);
+        ecs_observer_init(world_, &desc);
     }
 
     void* ctx() const {
-        return ecs_observer_get_ctx(m_world, m_id);
+        return ecs_observer_get_ctx(world_, id_);
     }
 
-    flecs::filter<> query() const {
-        const flecs::Poly *poly = this->get<flecs::Poly>(flecs::Observer);
-        const ecs_observer_t *ob = static_cast<const flecs::observer_t*>(poly->poly);
-        return flecs::filter<>(m_world, &ob->filter);
+    flecs::query<> query() const {
+        return flecs::query<>(ecs_observer_get_query(world_, id_));
     }
 };
 
 // Mixin implementation
 inline observer world::observer(flecs::entity e) const {
-    return flecs::observer(m_world, e);
+    return flecs::observer(world_, e);
 }
 
 template <typename... Comps, typename... Args>
 inline observer_builder<Comps...> world::observer(Args &&... args) const {
-    return flecs::observer_builder<Comps...>(m_world, FLECS_FWD(args)...);
+    return flecs::observer_builder<Comps...>(world_, FLECS_FWD(args)...);
 }
 
 } // namespace flecs
diff --git a/include/flecs/addons/cpp/mixins/pipeline/builder.hpp b/include/flecs/addons/cpp/mixins/pipeline/builder.hpp
index d08e7cf77..4e99fc00d 100644
--- a/include/flecs/addons/cpp/mixins/pipeline/builder.hpp
+++ b/include/flecs/addons/cpp/mixins/pipeline/builder.hpp
@@ -26,7 +26,7 @@ struct pipeline_builder final : _::pipeline_builder_base<Components...> {
         : _::pipeline_builder_base<Components...>(world)
     {
         _::sig<Components...>(world).populate(this);
-        this->m_desc.entity = id;
+        this->desc_.entity = id;
     }
 };
 
diff --git a/include/flecs/addons/cpp/mixins/pipeline/builder_i.hpp b/include/flecs/addons/cpp/mixins/pipeline/builder_i.hpp
index cb6d18473..e3349da13 100644
--- a/include/flecs/addons/cpp/mixins/pipeline/builder_i.hpp
+++ b/include/flecs/addons/cpp/mixins/pipeline/builder_i.hpp
@@ -17,10 +17,10 @@ template<typename Base>
 struct pipeline_builder_i : query_builder_i<Base> {
     pipeline_builder_i(ecs_pipeline_desc_t *desc, int32_t term_index = 0) 
         : query_builder_i<Base>(&desc->query, term_index)
-        , m_desc(desc) { }
+        , desc_(desc) { }
 
 private:
-    ecs_pipeline_desc_t *m_desc;
+    ecs_pipeline_desc_t *desc_;
 };
 
 }
diff --git a/include/flecs/addons/cpp/mixins/pipeline/impl.hpp b/include/flecs/addons/cpp/mixins/pipeline/impl.hpp
index f9595d7b6..e75b20880 100644
--- a/include/flecs/addons/cpp/mixins/pipeline/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/pipeline/impl.hpp
@@ -14,79 +14,75 @@ struct pipeline : entity {
     pipeline(world_t *world, ecs_pipeline_desc_t *desc) 
         : entity(world)
     {
-        m_id = ecs_pipeline_init(world, desc);
+        id_ = ecs_pipeline_init(world, desc);
 
-        if (!m_id) {
+        if (!id_) {
             ecs_abort(ECS_INVALID_PARAMETER, NULL);
         }
-
-        if (desc->query.filter.terms_buffer) {
-            ecs_os_free(desc->query.filter.terms_buffer);
-        }
     }
 };
 
 inline flecs::pipeline_builder<> world::pipeline() const {
-    return flecs::pipeline_builder<>(m_world);
+    return flecs::pipeline_builder<>(world_);
 }
 
 template <typename Pipeline, if_not_t< is_enum<Pipeline>::value >>
 inline flecs::pipeline_builder<> world::pipeline() const {
-    return flecs::pipeline_builder<>(m_world, _::cpp_type<Pipeline>::id(m_world));
+    return flecs::pipeline_builder<>(world_, _::type<Pipeline>::id(world_));
 }
 
 inline void world::set_pipeline(const flecs::entity pip) const {
-    return ecs_set_pipeline(m_world, pip);
+    return ecs_set_pipeline(world_, pip);
 }
 
 template <typename Pipeline>
 inline void world::set_pipeline() const {
-    return ecs_set_pipeline(m_world, _::cpp_type<Pipeline>::id(m_world));
+    return ecs_set_pipeline(world_, _::type<Pipeline>::id(world_));
 }
 
 inline flecs::entity world::get_pipeline() const {
-    return flecs::entity(m_world, ecs_get_pipeline(m_world));
+    return flecs::entity(world_, ecs_get_pipeline(world_));
 }
 
 inline bool world::progress(ecs_ftime_t delta_time) const {
-    return ecs_progress(m_world, delta_time);
+    return ecs_progress(world_, delta_time);
 }
 
 inline void world::run_pipeline(const flecs::entity_t pip, ecs_ftime_t delta_time) const {
-    return ecs_run_pipeline(m_world, pip, delta_time);
+    return ecs_run_pipeline(world_, pip, delta_time);
 }
 
 template <typename Pipeline, if_not_t< is_enum<Pipeline>::value >>
 inline void world::run_pipeline(ecs_ftime_t delta_time) const {
-    return ecs_run_pipeline(m_world, _::cpp_type<Pipeline>::id(m_world), delta_time);
+    return ecs_run_pipeline(world_, _::type<Pipeline>::id(world_), delta_time);
 }
 
 inline void world::set_time_scale(ecs_ftime_t mul) const {
-    ecs_set_time_scale(m_world, mul);
+    ecs_set_time_scale(world_, mul);
 }
 
 inline void world::set_target_fps(ecs_ftime_t target_fps) const {
-    ecs_set_target_fps(m_world, target_fps);
+    ecs_set_target_fps(world_, target_fps);
 }
 
 inline void world::reset_clock() const {
-    ecs_reset_clock(m_world);
+    ecs_reset_clock(world_);
 }
 
 inline void world::set_threads(int32_t threads) const {
-    ecs_set_threads(m_world, threads);
+    ecs_set_threads(world_, threads);
 }
 
 inline int32_t world::get_threads() const {
-    return ecs_get_stage_count(m_world);
+    return ecs_get_stage_count(world_);
 }
 
 inline void world::set_task_threads(int32_t task_threads) const {
-    ecs_set_task_threads(m_world, task_threads);
+    ecs_set_task_threads(world_, task_threads);
 }
 
 inline bool world::using_task_threads() const {
-    return ecs_using_task_threads(m_world);
+    return ecs_using_task_threads(world_);
 }
 
 }
diff --git a/include/flecs/addons/cpp/mixins/plecs/mixin.inl b/include/flecs/addons/cpp/mixins/plecs/mixin.inl
deleted file mode 100644
index d97c73426..000000000
--- a/include/flecs/addons/cpp/mixins/plecs/mixin.inl
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * @file addons/cpp/mixins/plecs/mixin.inl
- * @brief Plecs world mixin.
- */
-
-/**
- * @defgroup cpp_addons_plecs Plecs
- * @ingroup cpp_addons
- * Data definition format for loading entity data.
- *
- * @{
- */
-
-/** Load plecs string.
- * @see ecs_plecs_from_str
- */
-int plecs_from_str(const char *name, const char *str) const {
-    return ecs_plecs_from_str(m_world, name, str);
-}
-
-/** Load plecs from file.
- * @see ecs_plecs_from_file
- */
-int plecs_from_file(const char *filename) const {
-    return ecs_plecs_from_file(m_world, filename);
-}
-
-/** @} */
diff --git a/include/flecs/addons/cpp/mixins/query/builder.hpp b/include/flecs/addons/cpp/mixins/query/builder.hpp
index 91b232dd2..7cbd2cfa9 100644
--- a/include/flecs/addons/cpp/mixins/query/builder.hpp
+++ b/include/flecs/addons/cpp/mixins/query/builder.hpp
@@ -22,6 +22,13 @@ namespace _ {
  */
 template <typename ... Components>
 struct query_builder final : _::query_builder_base<Components...> {
+    query_builder(flecs::world_t* world, flecs::entity query_entity)
+        : _::query_builder_base<Components...>(world)
+    {
+        _::sig<Components...>(world).populate(this);
+        this->desc_.entity = query_entity.id();
+    }
+
     query_builder(flecs::world_t* world, const char *name = nullptr)
         : _::query_builder_base<Components...>(world)
     {
@@ -31,9 +38,14 @@ struct query_builder final : _::query_builder_base<Components...> {
             entity_desc.name = name;
             entity_desc.sep = "::";
             entity_desc.root_sep = "::";
-            this->m_desc.filter.entity = ecs_entity_init(world, &entity_desc);
+            this->desc_.entity = ecs_entity_init(world, &entity_desc);
         }
     }
+
+    template <typename Func>
+    void each(Func&& func) {
+        this->build().each(FLECS_FWD(func));
+    }
 };
 
 }
diff --git a/include/flecs/addons/cpp/mixins/query/builder_i.hpp b/include/flecs/addons/cpp/mixins/query/builder_i.hpp
index bd098d00d..98224d4f7 100644
--- a/include/flecs/addons/cpp/mixins/query/builder_i.hpp
+++ b/include/flecs/addons/cpp/mixins/query/builder_i.hpp
@@ -5,27 +5,242 @@
 
 #pragma once
 
-#include "../filter/builder_i.hpp"
+#include "../term/builder_i.hpp"
 
-namespace flecs {
+namespace flecs 
+{
 
 /** Query builder interface.
  * 
  * @ingroup cpp_core_queries
  */
 template<typename Base, typename ... Components>
-struct query_builder_i : filter_builder_i<Base, Components ...> {
-private:
-    using BaseClass = filter_builder_i<Base, Components ...>;
+struct query_builder_i : term_builder_i<Base> {
+    query_builder_i(ecs_query_desc_t *desc, int32_t term_index = 0) 
+        : term_index_(term_index)
+        , expr_count_(0)
+        , desc_(desc) { }
+
+    Base& instanced() {
+        desc_->flags |= EcsQueryIsInstanced;
+        return *this;
+    }
+
+    Base& flags(ecs_flags32_t flags) {
+        desc_->flags |= flags;
+        return *this;
+    }
+
+    Base& cache_kind(query_cache_kind_t kind) {
+        desc_->cache_kind = static_cast<ecs_query_cache_kind_t>(kind);
+        return *this;
+    }
+
+    Base& cached() {
+        return cache_kind(flecs::QueryCacheAuto);
+    }
+
+    Base& expr(const char *expr) {
+        ecs_check(expr_count_ == 0, ECS_INVALID_OPERATION,
+            "query_builder::expr() called more than once");
+        desc_->expr = expr;
+        expr_count_ ++;
+
+    error:
+        return *this;
+    }
+
+    /* With methods */
+
+    template<typename T>
+    Base& with() {
+        this->term();
+        *this->term_ = flecs::term(_::type<T>::id(this->world_v()));
+        this->term_->inout = static_cast<ecs_inout_kind_t>(
+            _::type_to_inout<T>());
+            if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
+        }
+        return *this;
+    }
+
+    Base& with(id_t id) {
+        this->term();
+        *this->term_ = flecs::term(id);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
+        }
+        return *this;
+    }
+
+    Base& with(const char *name) {
+        this->term();
+        *this->term_ = flecs::term().first(name);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
+        }
+        return *this;
+    }
+
+    Base& with(const char *first, const char *second) {
+        this->term();
+        *this->term_ = flecs::term().first(first).second(second);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
+        }
+        return *this;
+    }
+
+    Base& with(entity_t r, entity_t o) {
+        this->term();
+        *this->term_ = flecs::term(r, o);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
+        }
+        return *this;
+    }
+
+    Base& with(entity_t r, const char *o) {
+        this->term();
+        *this->term_ = flecs::term(r).second(o);
+        if (this->term_->inout == EcsInOutDefault) {
+            this->inout_none();
+        }
+        return *this;
+    }
+
+    template<typename First>
+    Base& with(id_t o) {
+        return this->with(_::type<First>::id(this->world_v()), o);
+    }
+
+    template<typename First>
+    Base& with(const char *second) {
+        return this->with(_::type<First>::id(this->world_v())).second(second);
+    }
+
+    template<typename First, typename Second>
+    Base& with() {
+        return this->with<First>(_::type<Second>::id(this->world_v()));
+    }
+
+    template <typename E, if_t< is_enum<E>::value > = 0>
+    Base& with(E value) {
+        flecs::entity_t r = _::type<E>::id(this->world_v());
+        auto o = enum_type<E>(this->world_v()).entity(value);
+        return this->with(r, o);
+    }
+
+    Base& with(flecs::term& term) {
+        this->term();
+        *this->term_ = term;
+        return *this;
+    }
+
+    Base& with(flecs::term&& term) {
+        this->term();
+        *this->term_ = term;
+        return *this;
+    }
+
+    /* Without methods, shorthand for .with(...).not_(). */
+
+    template <typename ... Args>
+    Base& without(Args&&... args) {
+        return this->with(FLECS_FWD(args)...).not_();
+    }
+
+    template <typename T, typename ... Args>
+    Base& without(Args&&... args) {
+        return this->with<T>(FLECS_FWD(args)...).not_();
+    }
+
+    template <typename First, typename Second>
+    Base& without() {
+        return this->with<First, Second>().not_();
+    }
+
+    /* Write/read methods */
+
+    Base& write() {
+        term_builder_i<Base>::write();
+        return *this;
+    }
+
+    template <typename ... Args>
+    Base& write(Args&&... args) {
+        return this->with(FLECS_FWD(args)...).write();
+    }
+
+    template <typename T, typename ... Args>
+    Base& write(Args&&... args) {
+        return this->with<T>(FLECS_FWD(args)...).write();
+    }
+
+    template <typename First, typename Second>
+    Base& write() {
+        return this->with<First, Second>().write();
+    }
+
+    Base& read() {
+        term_builder_i<Base>::read();
+        return *this;
+    }
+
+    template <typename ... Args>
+    Base& read(Args&&... args) {
+        return this->with(FLECS_FWD(args)...).read();
+    }
+
+    template <typename T, typename ... Args>
+    Base& read(Args&&... args) {
+        return this->with<T>(FLECS_FWD(args)...).read();
+    }
+
+    template <typename First, typename Second>
+    Base& read() {
+        return this->with<First, Second>().read();
+    }
+
+    /* Scope_open/scope_close shorthand notation. */
+    Base& scope_open() {
+        return this->with(flecs::ScopeOpen).entity(0);
+    }
+
+    Base& scope_close() {
+        return this->with(flecs::ScopeClose).entity(0);
+    }
+
+    /* Term notation for more complex query features */
+
+    Base& term() {
+        if (this->term_) {
+            ecs_check(ecs_term_is_initialized(this->term_), 
+                ECS_INVALID_OPERATION, 
+                    "query_builder::term() called without initializing term");
+        }
+
+        ecs_check(term_index_ < FLECS_TERM_COUNT_MAX, 
+            ECS_INVALID_PARAMETER, "maximum number of terms exceeded");
+
+        this->set_term(&desc_->terms[term_index_]);
+
+        term_index_ ++;
     
-public:
-    query_builder_i()
-        : BaseClass(nullptr)
-        , m_desc(nullptr) { }
+    error:
+        return *this;
+    }
 
-    query_builder_i(ecs_query_desc_t *desc, int32_t term_index = 0) 
-        : BaseClass(&desc->filter, term_index)
-        , m_desc(desc) { }
+    Base& term_at(int32_t term_index) {
+        ecs_assert(term_index >= 0, ECS_INVALID_PARAMETER, NULL);
+        int32_t prev_index = term_index_;
+        term_index_ = term_index;
+        this->term();
+        term_index_ = prev_index;
+        ecs_assert(ecs_term_is_initialized(this->term_), 
+            ECS_INVALID_PARAMETER, NULL);
+        return *this;
+    }
 
     /** Sort the output of a query.
      * This enables sorting of entities across matched tables. As a result of this
@@ -48,7 +263,7 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
     template <typename T>
     Base& order_by(int(*compare)(flecs::entity_t, const T*, flecs::entity_t, const T*)) {
         ecs_order_by_action_t cmp = reinterpret_cast<ecs_order_by_action_t>(compare);
-        return this->order_by(_::cpp_type<T>::id(this->world_v()), cmp);
+        return this->order_by(_::type<T>::id(this->world_v()), cmp);
     }
 
     /** Sort the output of a query.
@@ -58,8 +273,8 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
      * @param compare The compare function used to sort the components.
      */    
     Base& order_by(flecs::entity_t component, int(*compare)(flecs::entity_t, const void*, flecs::entity_t, const void*)) {
-        m_desc->order_by = reinterpret_cast<ecs_order_by_action_t>(compare);
-        m_desc->order_by_component = component;
+        desc_->order_by_callback = reinterpret_cast<ecs_order_by_action_t>(compare);
+        desc_->order_by = component;
         return *this;
     }
 
@@ -83,7 +298,7 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
     template <typename T>
     Base& group_by(uint64_t(*group_by_action)(flecs::world_t*, flecs::table_t *table, flecs::id_t id, void* ctx)) {
         ecs_group_by_action_t action = reinterpret_cast<ecs_group_by_action_t>(group_by_action);
-        return this->group_by(_::cpp_type<T>::id(this->world_v()), action);
+        return this->group_by(_::type<T>::id(this->world_v()), action);
     }
 
     /** Group and sort matched tables.
@@ -93,8 +308,8 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
      * @param group_by_action Callback that determines group id for table.
      */
     Base& group_by(flecs::entity_t component, uint64_t(*group_by_action)(flecs::world_t*, flecs::table_t *table, flecs::id_t id, void* ctx)) {
-        m_desc->group_by = reinterpret_cast<ecs_group_by_action_t>(group_by_action);
-        m_desc->group_by_id = component;
+        desc_->group_by_callback = reinterpret_cast<ecs_group_by_action_t>(group_by_action);
+        desc_->group_by = component;
         return *this;
     }
 
@@ -105,7 +320,7 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
      */
     template <typename T>
     Base& group_by() {
-        return this->group_by(_::cpp_type<T>::id(this->world_v()), nullptr);
+        return this->group_by(_::type<T>::id(this->world_v()), nullptr);
     }
 
     /** Group and sort matched tables.
@@ -123,37 +338,36 @@ struct query_builder_i : filter_builder_i<Base, Components ...> {
      * @param ctx_free Function to cleanup context (called when query is deleted).
      */
     Base& group_by_ctx(void *ctx, ecs_ctx_free_t ctx_free = nullptr) {
-        m_desc->group_by_ctx = ctx;
-        m_desc->group_by_ctx_free = ctx_free;
+        desc_->group_by_ctx = ctx;
+        desc_->group_by_ctx_free = ctx_free;
         return *this;
     }
 
     /** Specify on_group_create action.
      */
     Base& on_group_create(ecs_group_create_action_t action) {
-        m_desc->on_group_create = action;
+        desc_->on_group_create = action;
         return *this;
     }
 
     /** Specify on_group_delete action.
      */
     Base& on_group_delete(ecs_group_delete_action_t action) {
-        m_desc->on_group_delete = action;
+        desc_->on_group_delete = action;
         return *this;
     }
 
-    /** Specify parent query (creates subquery) */
-    Base& observable(const query_base& parent);
-    
 protected:
     virtual flecs::world_t* world_v() = 0;
+    int32_t term_index_;
+    int32_t expr_count_;
 
 private:
     operator Base&() {
         return *static_cast<Base*>(this);
     }
 
-    ecs_query_desc_t *m_desc;
+    ecs_query_desc_t *desc_;
 };
 
 }
diff --git a/include/flecs/addons/cpp/mixins/query/decl.hpp b/include/flecs/addons/cpp/mixins/query/decl.hpp
index caf96f7af..a89e88a35 100644
--- a/include/flecs/addons/cpp/mixins/query/decl.hpp
+++ b/include/flecs/addons/cpp/mixins/query/decl.hpp
@@ -10,7 +10,6 @@ namespace flecs {
 /**
  * @defgroup cpp_core_queries Queries
  * @ingroup cpp_core
- * Cached query implementation. Fast to iterate, but slower to create than flecs::filter.
  *
  * @{
  */
diff --git a/include/flecs/addons/cpp/mixins/query/impl.hpp b/include/flecs/addons/cpp/mixins/query/impl.hpp
index 452b0c8c1..3eb6355a4 100644
--- a/include/flecs/addons/cpp/mixins/query/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/query/impl.hpp
@@ -7,37 +7,93 @@
 
 #include "builder.hpp"
 
-namespace flecs {
-
-////////////////////////////////////////////////////////////////////////////////
-//// Persistent queries
-////////////////////////////////////////////////////////////////////////////////
+namespace flecs 
+{
 
 struct query_base {
-    query_base()
-        : m_world(nullptr)
-        , m_query(nullptr) { }    
-    
-    query_base(world_t *world, query_t *query = nullptr)
-        : m_world(world)
-        , m_query(query) { }
-
-    query_base(world_t *world, ecs_query_desc_t *desc) 
-        : m_world(world)
-    {
-        m_query = ecs_query_init(world, desc);
-
-        if (!m_query) {
-            ecs_abort(ECS_INVALID_PARAMETER, NULL);
+    query_base() { }
+
+    query_base(query_t *q)
+        : query_(q) { 
+            flecs_poly_claim(q);
         }
 
-        if (desc->filter.terms_buffer) {
-            ecs_os_free(desc->filter.terms_buffer);
+    query_base(const query_t *q)
+        : query_(ECS_CONST_CAST(query_t*, q)) { 
+            flecs_poly_claim(q);
         }
+
+    query_base(world_t *world, ecs_query_desc_t *desc) {
+        if (desc->entity && desc->terms[0].id == 0) {
+            const flecs::Poly *query_poly = ecs_get_pair(
+                world, desc->entity, EcsPoly, EcsQuery);
+            if (query_poly) {
+                query_ = static_cast<flecs::query_t*>(query_poly->poly);
+                flecs_poly_claim(query_);
+                return;
+            }
+        }
+
+        query_ = ecs_query_init(world, desc);
+    }
+
+    query_base(const query_base& obj) {
+        this->query_ = obj.query_;
+        flecs_poly_claim(this->query_);
+    }
+
+    query_base& operator=(const query_base& obj) {
+        this->query_ = obj.query_;
+        flecs_poly_claim(this->query_);
+        return *this; 
+    }
+
+    query_base(query_base&& obj) noexcept {
+        this->query_ = obj.query_;
+        obj.query_ = nullptr;
+    }
+
+    query_base& operator=(query_base&& obj) noexcept {
+        this->query_ = obj.query_;
+        obj.query_ = nullptr;
+        return *this; 
+    }
+
+    flecs::entity entity() {
+        return flecs::entity(query_->world, query_->entity);
+    }
+
+    operator const flecs::query_t*() const {
+        return query_;
+    }
+
+    operator bool() const {
+        return query_ != nullptr;
+    }
+
+    /** Free persistent query.
+     * A persistent query is a query that is associated with an entity, such as
+     * system queries and named queries. Persistent queries must be deleted with
+     * destruct(), or will be deleted automatically at world cleanup. 
+     */
+    void destruct() {
+        ecs_assert(query_->entity != 0, ECS_INVALID_OPERATION, "destruct() "
+            "should only be called on queries associated with entities");
+        ecs_query_fini(query_);
+        query_ = nullptr;
     }
 
-    operator query_t*() const {
-        return m_query;
+    ~query_base() {
+        /* Only free if query is not associated with entity, such as system
+         * queries and named queries. Named queries have to be either explicitly
+         * deleted with the .destruct() method, or will be deleted when the
+         * world is deleted. */
+        if (query_ && !query_->entity) {
+            if (!flecs_poly_release(query_)) {
+                ecs_query_fini(query_);
+                query_ = nullptr;
+            }
+        }
     }
 
     /** Returns whether the query data changed since the last iteration.
@@ -50,18 +106,7 @@ struct query_base {
      * @return true if entities changed, otherwise false.
      */
     bool changed() const {
-        return ecs_query_changed(m_query, 0);
-    }
-
-    /** Returns whether query is orphaned.
-     * When the parent query of a subquery is deleted, it is left in an orphaned
-     * state. The only valid operation on an orphaned query is deleting it. Only
-     * subqueries can be orphaned.
-     *
-     * @return true if query is orphaned, otherwise false.
-     */
-    bool orphaned() const {
-        return ecs_query_orphaned(m_query);
+        return ecs_query_changed(query_);
     }
 
     /** Get info for group. 
@@ -70,7 +115,7 @@ struct query_base {
      * @return The group info.
      */
     const flecs::query_group_info_t* group_info(uint64_t group_id) const {
-        return ecs_query_get_group_info(m_query, group_id);
+        return ecs_query_get_group_info(query_, group_id);
     }
 
     /** Get context for group. 
@@ -87,66 +132,81 @@ struct query_base {
         }
     }
 
-    /** Free the query.
-     */
-    void destruct() {
-        ecs_query_fini(m_query);
-        m_world = nullptr;
-        m_query = nullptr;
+    template <typename Func>
+    void each_term(const Func& func) {
+        for (int i = 0; i < query_->term_count; i ++) {
+            flecs::term t(query_->world, query_->terms[i]);
+            func(t);
+            t.reset(); // prevent freeing resources
+        }
     }
 
-    template <typename Func>
-    void each_term(const Func& func) const {
-        this->filter().each_term(func);
+    flecs::term term(int32_t index) {
+        return flecs::term(query_->world, query_->terms[index]);
     }
 
-    filter_base filter() const {
-        return filter_base(m_world, ecs_query_get_filter(m_query));
+    int32_t term_count() {
+        return query_->term_count;
     }
 
-    flecs::term term(int32_t index) const {
-        const ecs_filter_t *f = ecs_query_get_filter(m_query);
-        ecs_assert(f != NULL, ECS_INVALID_PARAMETER, NULL);
-        return flecs::term(m_world, f->terms[index]);
+    int32_t field_count() {
+        return query_->field_count;
     }
 
-    int32_t field_count() const {
-        const ecs_filter_t *f = ecs_query_get_filter(m_query);
-        return f->term_count;   
+    int32_t find_var(const char *name) {
+        return ecs_query_find_var(query_, name);
     }
 
-    flecs::string str() const {
-        const ecs_filter_t *f = ecs_query_get_filter(m_query);
-        char *result = ecs_filter_str(m_world, f);
+    flecs::string str() {
+        char *result = ecs_query_str(query_);
         return flecs::string(result);
     }
 
-    flecs::entity entity() const {
-        return flecs::entity(m_world, ecs_get_entity(m_query));
+    /** Returns a string representing the query plan.
+     * This can be used to analyze the behavior & performance of the query.
+     * @see ecs_query_plan
+     */
+    flecs::string plan() const {
+        char *result = ecs_query_plan(query_);
+        return flecs::string(result);
     }
-    
+
     operator query<>() const;
 
 protected:
-    world_t *m_world;
-    query_t *m_query;
+    query_t *query_ = nullptr;
 };
 
 template<typename ... Components>
-struct query final : query_base, iterable<Components...> {
-public:
-    flecs::world world() const {
-        return flecs::world(m_world);
-    }
-    
+struct query : query_base, iterable<Components...> {
 private:
     using Terms = typename _::term_ptrs<Components...>::array;
 
+public:
+    using query_base::query_base;
+
+    query() : query_base() { } // necessary not to confuse msvc
+
+    query(const query& obj) : query_base(obj) { }
+
+    query& operator=(const query& obj) {
+        query_base::operator=(obj);
+        return *this;
+    }
+
+    query(query&& obj) noexcept : query_base(FLECS_MOV(obj)) { }
+
+    query& operator=(query&& obj) noexcept {
+        query_base::operator=(FLECS_FWD(obj));
+        return *this;
+    }
+
+private:
     ecs_iter_t get_iter(flecs::world_t *world) const override {
         if (!world) {
-            world = m_world;
+            world = query_->world;
         }
-        return ecs_query_iter(world, m_query);
+        return ecs_query_iter(world, query_);
     }
 
     ecs_iter_next_action_t next_action() const override {
@@ -156,33 +216,101 @@ struct query final : query_base, iterable<Components...> {
     ecs_iter_next_action_t next_each_action() const override {
         return ecs_query_next_instanced;
     }
-
-public:
-    using query_base::query_base;
 };
 
-// Mixin implementation
+// World mixin implementation
 template <typename... Comps, typename... Args>
 inline flecs::query<Comps...> world::query(Args &&... args) const {
-    return flecs::query_builder<Comps...>(m_world, FLECS_FWD(args)...)
+    return flecs::query_builder<Comps...>(world_, FLECS_FWD(args)...)
         .build();
 }
 
+inline flecs::query<> world::query(flecs::entity query_entity) const {
+    ecs_query_desc_t desc = {};
+    desc.entity = query_entity;
+    return flecs::query<>(world_, &desc);
+}
+
 template <typename... Comps, typename... Args>
 inline flecs::query_builder<Comps...> world::query_builder(Args &&... args) const {
-    return flecs::query_builder<Comps...>(m_world, FLECS_FWD(args)...);
+    return flecs::query_builder<Comps...>(world_, FLECS_FWD(args)...);
+}
+
+// world::each
+namespace _ {
+
+// Each with entity parameter
+template<typename Func, typename ... Args>
+struct query_delegate_w_ent;
+
+template<typename Func, typename E, typename ... Args>
+struct query_delegate_w_ent<Func, arg_list<E, Args ...> >
+{
+    query_delegate_w_ent(const flecs::world& world, Func&& func) {
+        auto f = world.query<Args ...>();
+        f.each(FLECS_MOV(func));
+    }
+};
+
+// Each without entity parameter
+template<typename Func, typename ... Args>
+struct query_delegate_no_ent;
+
+template<typename Func, typename ... Args>
+struct query_delegate_no_ent<Func, arg_list<Args ...> >
+{
+    query_delegate_no_ent(const flecs::world& world, Func&& func) {
+        auto f = world.query<Args ...>();
+        f.each(FLECS_MOV(func));
+    }
+};
+
+// Switch between function with & without entity parameter
+template<typename Func, typename T = int>
+struct query_delegate;
+
+template <typename Func>
+struct query_delegate<Func, if_t<is_same<first_arg_t<Func>, flecs::entity>::value> > {
+    query_delegate(const flecs::world& world, Func&& func) {
+        query_delegate_w_ent<Func, arg_list_t<Func>>(world, FLECS_MOV(func));
+    }
+};
+
+template <typename Func>
+struct query_delegate<Func, if_not_t<is_same<first_arg_t<Func>, flecs::entity>::value> > {
+    query_delegate(const flecs::world& world, Func&& func) {
+        query_delegate_no_ent<Func, arg_list_t<Func>>(world, FLECS_MOV(func));
+    }
+};
+
+}
+
+template <typename Func>
+inline void world::each(Func&& func) const {
+    _::query_delegate<Func> f_delegate(*this, FLECS_MOV(func));
+}
+
+template <typename T, typename Func>
+inline void world::each(Func&& func) const {
+    ecs_iter_t it = ecs_each_id(world_, _::type<T>::id());
+
+    while (ecs_each_next(&it)) {
+        _::each_delegate<Func, T>(func).invoke(&it);
+    }
 }
 
-// Builder implementation
-template <typename Base, typename ... Components>
-inline Base& query_builder_i<Base, Components ...>::observable(const query_base& parent) {
-    m_desc->parent = parent;
-    return *static_cast<Base*>(this);
+template <typename Func>
+inline void world::each(flecs::id_t each_id, Func&& func) const {
+    ecs_iter_t it = ecs_each_id(world_, each_id);
+
+    while (ecs_each_next(&it)) {
+        _::each_delegate<Func>(func).invoke(&it);
+    }
 }
 
 // query_base implementation
-inline query_base::operator query<>() const {
-    return flecs::query<>(m_world, m_query);
+inline query_base::operator flecs::query<> () const {
+    return flecs::query<>(query_);
 }
 
-} // namespace flecs
+}
diff --git a/include/flecs/addons/cpp/mixins/query/mixin.inl b/include/flecs/addons/cpp/mixins/query/mixin.inl
index 8ec941ea9..21d5e8e8c 100644
--- a/include/flecs/addons/cpp/mixins/query/mixin.inl
+++ b/include/flecs/addons/cpp/mixins/query/mixin.inl
@@ -11,21 +11,61 @@
  */
 
 /** Create a query.
+ * 
  * @see ecs_query_init
  */
 template <typename... Comps, typename... Args>
 flecs::query<Comps...> query(Args &&... args) const;
 
-/** Create a subquery.
+/** Create a query from entity.
+ * 
  * @see ecs_query_init
  */
-template <typename... Comps, typename... Args>
-flecs::query<Comps...> query(flecs::query_base& parent, Args &&... args) const;
+flecs::query<> query(flecs::entity query_entity) const;
 
 /** Create a query builder.
+ * 
  * @see ecs_query_init
  */
 template <typename... Comps, typename... Args>
 flecs::query_builder<Comps...> query_builder(Args &&... args) const;
 
+/** Iterate over all entities with components in argument list of function.
+ * The function parameter must match the following signature:
+ *
+ * @code
+ * void(*)(T&, U&, ...)
+ * @endcode
+ *
+ * or:
+ *
+ * @code
+ * void(*)(flecs::entity, T&, U&, ...)
+ * @endcode
+ * 
+ */
+template <typename Func>
+void each(Func&& func) const;
+
+/** Iterate over all entities with provided component.
+ * The function parameter must match the following signature:
+ *
+ * @code
+ * void(*)(T&)
+ * @endcode
+ *
+ * or:
+ *
+ * @code
+ * void(*)(flecs::entity, T&)
+ * @endcode
+ * 
+ */
+template <typename T, typename Func>
+void each(Func&& func) const;
+
+/** Iterate over all entities with provided (component) id. */
+template <typename Func>
+void each(flecs::id_t term_id, Func&& func) const;
+
 /** @} */
diff --git a/include/flecs/addons/cpp/mixins/rule/builder.hpp b/include/flecs/addons/cpp/mixins/rule/builder.hpp
deleted file mode 100644
index ac93c5941..000000000
--- a/include/flecs/addons/cpp/mixins/rule/builder.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * @file addons/cpp/mixins/rule/builder.hpp
- * @brief Rule builder.
- */
-
-#pragma once
-
-#include "../filter/builder_i.hpp"
-
-namespace flecs {
-namespace _ {
-    template <typename ... Components>
-    using rule_builder_base = builder<
-        rule, ecs_filter_desc_t, rule_builder<Components...>, 
-        filter_builder_i, Components ...>;
-}
-
-/** Rule builder.
- * 
- * @ingroup cpp_addons_rules
- */
-template <typename ... Components>
-struct rule_builder final : _::rule_builder_base<Components...> {
-    rule_builder(flecs::world_t* world, const char *name = nullptr)
-        : _::rule_builder_base<Components...>(world)
-    {
-        _::sig<Components...>(world).populate(this);
-        if (name != nullptr) {
-            ecs_entity_desc_t entity_desc = {};
-            entity_desc.name = name;
-            entity_desc.sep = "::";
-            entity_desc.root_sep = "::";
-            this->m_desc.entity = ecs_entity_init(world, &entity_desc);
-        }
-    }
-};
-
-}
diff --git a/include/flecs/addons/cpp/mixins/rule/decl.hpp b/include/flecs/addons/cpp/mixins/rule/decl.hpp
deleted file mode 100644
index 96fd9fd90..000000000
--- a/include/flecs/addons/cpp/mixins/rule/decl.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * @file addons/cpp/mixins/rule/decl.hpp
- * @brief Rule declarations.
- */
-
-#pragma once
-
-namespace flecs {
-
-/**
- * @defgroup cpp_addons_rules Rules
- * @ingroup cpp_addons
- * Rules are an advanced query engine for matching against entity graphs.
- *
- * @{
- */
-
-struct rule_base;
-
-template<typename ... Components>
-struct rule;
-
-template<typename ... Components>
-struct rule_builder;
-
-/** @} */
-
-}
diff --git a/include/flecs/addons/cpp/mixins/rule/impl.hpp b/include/flecs/addons/cpp/mixins/rule/impl.hpp
deleted file mode 100644
index b9a8e9fe9..000000000
--- a/include/flecs/addons/cpp/mixins/rule/impl.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-/**
- * @file addons/cpp/mixins/rule/impl.hpp
- * @brief Rule implementation.
- */
-
-#pragma once
-
-#include "builder.hpp"
-
-namespace flecs {
-
-////////////////////////////////////////////////////////////////////////////////
-//// Persistent queries
-////////////////////////////////////////////////////////////////////////////////
-
-struct rule_base {
-    rule_base()
-        : m_world(nullptr)
-        , m_rule(nullptr) { }    
-    
-    rule_base(world_t *world, rule_t *rule = nullptr)
-        : m_world(world)
-        , m_rule(rule) { }
-
-    rule_base(world_t *world, ecs_filter_desc_t *desc) 
-        : m_world(world)
-    {
-        m_rule = ecs_rule_init(world, desc);
-        if (desc->terms_buffer) {
-            ecs_os_free(desc->terms_buffer);
-        }
-    }
-
-    bool is_valid() const {
-        return m_rule != nullptr;
-    }
-
-    operator rule_t*() const {
-        return m_rule;
-    }
-
-    flecs::entity entity() {
-        return flecs::entity(m_world, ecs_get_entity(m_rule));
-    }
-
-    /** Free the rule. */
-    void destruct() {
-        if (m_rule) {
-            ecs_rule_fini(m_rule);
-            m_world = nullptr;
-            m_rule = nullptr;
-        }
-    }
-
-    template <typename Func>
-    void each_term(const Func& func) const {
-        this->filter().each_term(func);
-    }
-
-    /** Move the rule. */
-    void move(flecs::rule_base&& obj) {
-        this->destruct();
-        this->m_world = obj.m_world;
-        this->m_rule = obj.m_rule;
-        obj.m_world = nullptr;
-        obj.m_rule = nullptr;
-    }
-
-    flecs::filter_base filter() const {
-        return filter_base(m_world, ecs_rule_get_filter(m_rule));
-    }
-
-    /** Converts this rule to a string expression
-     * @see ecs_filter_str
-     */
-    flecs::string str() const {
-        const ecs_filter_t *f = ecs_rule_get_filter(m_rule);
-        char *result = ecs_filter_str(m_world, f);
-        return flecs::string(result);
-    }
-
-
-    /** Converts this rule to a string that can be used to aid debugging
-     * the behavior of the rule.
-     * @see ecs_rule_str
-     */
-    flecs::string rule_str() const {
-        char *result = ecs_rule_str(m_rule);
-        return flecs::string(result);
-    }
-
-    operator rule<>() const;
-
-protected:
-    world_t *m_world;
-    rule_t *m_rule;
-};
-
-template<typename ... Components>
-struct rule final : rule_base, iterable<Components...> {
-private:
-    using Terms = typename _::term_ptrs<Components...>::array;
-
-    ecs_iter_t get_iter(flecs::world_t *world) const override {
-        if (!world) {
-            world = m_world;
-        }
-        return ecs_rule_iter(world, m_rule);
-    }
-
-    ecs_iter_next_action_t next_action() const override {
-        return ecs_rule_next;
-    }
-
-    ecs_iter_next_action_t next_each_action() const override {
-        return ecs_rule_next_instanced;
-    }
-
-public:
-    using rule_base::rule_base;
-
-    int32_t find_var(const char *name) {
-        return ecs_rule_find_var(m_rule, name);
-    }
-};
-
-// Mixin implementation
-template <typename... Comps, typename... Args>
-inline flecs::rule<Comps...> world::rule(Args &&... args) const {
-    return flecs::rule_builder<Comps...>(m_world, FLECS_FWD(args)...)
-        .build();
-}
-
-template <typename... Comps, typename... Args>
-inline flecs::rule_builder<Comps...> world::rule_builder(Args &&... args) const {
-    return flecs::rule_builder<Comps...>(m_world, FLECS_FWD(args)...);
-}
-
-// rule_base implementation
-inline rule_base::operator rule<>() const {
-    return flecs::rule<>(m_world, m_rule);
-}
-
-} // namespace flecs
diff --git a/include/flecs/addons/cpp/mixins/rule/iterable.inl b/include/flecs/addons/cpp/mixins/rule/iterable.inl
deleted file mode 100644
index 406a78df4..000000000
--- a/include/flecs/addons/cpp/mixins/rule/iterable.inl
+++ /dev/null
@@ -1,21 +0,0 @@
-/**
- * @file addons/cpp/mixins/rule/iterable.inl
- * @brief Rule iterable mixin.
- */
-
-/**
- * @memberof flecs::iter
- * @ingroup cpp_addons_rules
- *
- * @{
- */
-
-iter_iterable<Components...>& set_var(const char *name, flecs::entity_t value) {
-    ecs_rule_iter_t *rit = &m_it.priv.iter.rule;
-    int var_id = ecs_rule_find_var(rit->rule, name);
-    ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
-    ecs_iter_set_var(&m_it, var_id, value);
-    return *this;
-}
-
-/** @} */
diff --git a/include/flecs/addons/cpp/mixins/rule/mixin.inl b/include/flecs/addons/cpp/mixins/rule/mixin.inl
deleted file mode 100644
index 36cfcab0e..000000000
--- a/include/flecs/addons/cpp/mixins/rule/mixin.inl
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * @file addons/cpp/mixins/rule/mixin.inl
- * @brief Rule world mixin.
- */
-
-/**
- * @memberof flecs::world
- * @ingroup cpp_addons_rules
- *
- * @{
- */
-
-/** Create a rule.
- * @see ecs_rule_init
- */
-template <typename... Comps, typename... Args>
-flecs::rule<Comps...> rule(Args &&... args) const;
-
-/** Create a subrule.
- * @see ecs_rule_init
- */
-template <typename... Comps, typename... Args>
-flecs::rule<Comps...> rule(flecs::rule_base& parent, Args &&... args) const;
-
-/** Create a rule builder.
- * @see ecs_rule_init
- */
-template <typename... Comps, typename... Args>
-flecs::rule_builder<Comps...> rule_builder(Args &&... args) const;
-
-/** @} */
diff --git a/include/flecs/addons/cpp/mixins/script/mixin.inl b/include/flecs/addons/cpp/mixins/script/mixin.inl
new file mode 100644
index 000000000..7005f45e6
--- /dev/null
+++ b/include/flecs/addons/cpp/mixins/script/mixin.inl
@@ -0,0 +1,42 @@
+/**
+ * @file addons/cpp/mixins/script/mixin.inl
+ * @brief Script world mixin.
+ */
+
+/**
+ * @defgroup cpp_addons_script Script
+ * @ingroup cpp_addons
+ * Data definition format for loading entity data.
+ *
+ * @{
+ */
+
+/** Run script.
+ * @see ecs_script_run
+ */
+int script_run(const char *name, const char *str) const {
+    return ecs_script_run(world_, name, str);
+}
+
+/** Run script from file.
+ * @see ecs_script_run_file
+ */
+int script_run_file(const char *filename) const {
+    return ecs_script_run_file(world_, filename);
+}
+
+/** Convert value to string */
+flecs::string to_expr(flecs::entity_t tid, const void* value) {
+    char *expr = ecs_ptr_to_expr(world_, tid, value);
+    return flecs::string(expr);
+}
+
+/** Convert value to string */
+template <typename T>
+flecs::string to_expr(const T* value) {
+    flecs::entity_t tid = _::type<T>::id(world_);
+    return to_expr(tid, value);
+}
+
+
+/** @} */
diff --git a/include/flecs/addons/cpp/mixins/snapshot/decl.hpp b/include/flecs/addons/cpp/mixins/snapshot/decl.hpp
deleted file mode 100644
index 8bf190257..000000000
--- a/include/flecs/addons/cpp/mixins/snapshot/decl.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * @file addons/cpp/mixins/snapshot/decl.hpp
- * @brief Snapshot module declarations.
- */
-
-#pragma once
-
-namespace flecs {
-
-/**
- * @defgroup cpp_addons_snapshots Snapshots
- * @ingroup cpp_addons
- * Save & restore world.
- *
- * @{
- */
-
-using snapshot_t = ecs_snapshot_t;
-
-struct snapshot;
-
-/** @} */
-
-}
diff --git a/include/flecs/addons/cpp/mixins/snapshot/impl.hpp b/include/flecs/addons/cpp/mixins/snapshot/impl.hpp
deleted file mode 100644
index 800d06b84..000000000
--- a/include/flecs/addons/cpp/mixins/snapshot/impl.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/**
- * @file addons/cpp/mixins/snapshot/impl.hpp
- * @brief Snapshot module implementation.
- */
-
-#pragma once
-
-namespace flecs {
-
-struct snapshot final {
-    explicit snapshot(const world& world)
-        : m_world( world )
-        , m_snapshot( nullptr ) { }
-
-    snapshot(const snapshot& obj) 
-        : m_world( obj.m_world )
-    { 
-        ecs_iter_t it = ecs_snapshot_iter(obj.m_snapshot);
-        m_snapshot = ecs_snapshot_take_w_iter(&it);
-    }
-
-    snapshot(snapshot&& obj) noexcept
-        : m_world(obj.m_world)
-        , m_snapshot(obj.m_snapshot)
-    {
-        obj.m_snapshot = nullptr;
-    }
-
-    snapshot& operator=(const snapshot& obj) {
-        ecs_assert(m_world.c_ptr() == obj.m_world.c_ptr(), ECS_INVALID_PARAMETER, NULL);
-        ecs_iter_t it = ecs_snapshot_iter(obj.m_snapshot);
-        m_snapshot = ecs_snapshot_take_w_iter(&it);        
-        return *this;
-    }
-
-    snapshot& operator=(snapshot&& obj) noexcept {
-        ecs_assert(m_world.c_ptr() == obj.m_world.c_ptr(), ECS_INVALID_PARAMETER, NULL);
-        m_snapshot = obj.m_snapshot;
-        obj.m_snapshot = nullptr;
-        return *this;
-    }
-
-    void take() {
-        if (m_snapshot) {
-            ecs_snapshot_free(m_snapshot);
-        }
-
-        m_snapshot = ecs_snapshot_take(m_world.c_ptr());
-    }
-
-    template <typename F>
-    void take(const F& f) {
-        if (m_snapshot) {
-            ecs_snapshot_free(m_snapshot);
-        }
-
-        ecs_iter_t it = ecs_filter_iter(m_world, f.c_ptr());
-
-        m_snapshot = ecs_snapshot_take_w_iter(&it);
-    }    
-
-    void restore() {
-        if (m_snapshot) {
-            ecs_snapshot_restore(m_world.c_ptr(), m_snapshot);
-            m_snapshot = nullptr;
-        }
-    }
-
-    ~snapshot() {
-        if (m_snapshot) {
-            ecs_snapshot_free(m_snapshot);
-        }
-    }
-
-    snapshot_t* c_ptr() const {
-        return m_snapshot;
-    }
-
-private:
-    const world& m_world;
-    snapshot_t *m_snapshot;
-};
-
-// Snapshot mixin implementation
-template <typename... Args>
-inline flecs::snapshot world::snapshot(Args &&... args) const {
-    return flecs::snapshot(*this, FLECS_FWD(args)...);
-}
-
-}
diff --git a/include/flecs/addons/cpp/mixins/snapshot/mixin.inl b/include/flecs/addons/cpp/mixins/snapshot/mixin.inl
deleted file mode 100644
index 13f8dd761..000000000
--- a/include/flecs/addons/cpp/mixins/snapshot/mixin.inl
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
- * @file addons/cpp/mixins/snapshot/mixin.inl
- * @brief Snapshot world mixin.
- */
-
-/**
- * @memberof flecs::world
- * @ingroup cpp_addons_snapshots
- *
- * @{
- */
-
-/** Create a snapshot.
- */
-template <typename... Args>
-flecs::snapshot snapshot(Args &&... args) const;
-
-/** @} */
diff --git a/include/flecs/addons/cpp/mixins/system/builder.hpp b/include/flecs/addons/cpp/mixins/system/builder.hpp
index 226053d6a..e819cadb7 100644
--- a/include/flecs/addons/cpp/mixins/system/builder.hpp
+++ b/include/flecs/addons/cpp/mixins/system/builder.hpp
@@ -28,8 +28,8 @@ struct system_builder final : _::system_builder_base<Components...> {
         _::sig<Components...>(world).populate(this);
 
 #ifdef FLECS_PIPELINE
-        ecs_add_id(world, this->m_desc.entity, ecs_dependson(flecs::OnUpdate));
-        ecs_add_id(world, this->m_desc.entity, flecs::OnUpdate);
+        ecs_add_id(world, this->desc_.entity, ecs_dependson(flecs::OnUpdate));
+        ecs_add_id(world, this->desc_.entity, flecs::OnUpdate);
 #endif
     }
 };
diff --git a/include/flecs/addons/cpp/mixins/system/builder_i.hpp b/include/flecs/addons/cpp/mixins/system/builder_i.hpp
index 40d8ad59f..608bd03dc 100644
--- a/include/flecs/addons/cpp/mixins/system/builder_i.hpp
+++ b/include/flecs/addons/cpp/mixins/system/builder_i.hpp
@@ -22,7 +22,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
 public:
     system_builder_i(ecs_system_desc_t *desc) 
         : BaseClass(&desc->query)
-        , m_desc(desc) { }
+        , desc_(desc) { }
 
     /** Specify in which phase the system should run.
      *
@@ -30,14 +30,14 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      */
     Base& kind(entity_t phase) {
         flecs::entity_t cur_phase = ecs_get_target(
-            world_v(), m_desc->entity, EcsDependsOn, 0);
+            world_v(), desc_->entity, EcsDependsOn, 0);
         if (cur_phase) {
-            ecs_remove_id(world_v(), m_desc->entity, ecs_dependson(cur_phase));
-            ecs_remove_id(world_v(), m_desc->entity, cur_phase);
+            ecs_remove_id(world_v(), desc_->entity, ecs_dependson(cur_phase));
+            ecs_remove_id(world_v(), desc_->entity, cur_phase);
         }
         if (phase) {
-            ecs_add_id(world_v(), m_desc->entity, ecs_dependson(phase));
-            ecs_add_id(world_v(), m_desc->entity, phase);
+            ecs_add_id(world_v(), desc_->entity, ecs_dependson(phase));
+            ecs_add_id(world_v(), desc_->entity, phase);
         }
         return *this;
     }
@@ -56,7 +56,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      */
     template <typename Phase>
     Base& kind() {
-        return this->kind(_::cpp_type<Phase>::id(world_v()));
+        return this->kind(_::type<Phase>::id(world_v()));
     }
 
     /** Specify whether system can run on multiple threads.
@@ -64,7 +64,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param value If false system will always run on a single thread.
      */
     Base& multi_threaded(bool value = true) {
-        m_desc->multi_threaded = value;
+        desc_->multi_threaded = value;
         return *this;
     }
 
@@ -72,8 +72,8 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      *
      * @param value If false system will always run staged.
      */
-    Base& no_readonly(bool value = true) {
-        m_desc->no_readonly = value;
+    Base& immediate(bool value = true) {
+        desc_->immediate = value;
         return *this;
     }
 
@@ -85,7 +85,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param interval The interval value.
      */
     Base& interval(ecs_ftime_t interval) {
-        m_desc->interval = interval;
+        desc_->interval = interval;
         return *this;
     }
 
@@ -98,8 +98,8 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param rate The multiple at which to run the system.
      */
     Base& rate(const entity_t tick_source, int32_t rate) {
-        m_desc->rate = rate;
-        m_desc->tick_source = tick_source;
+        desc_->rate = rate;
+        desc_->tick_source = tick_source;
         return *this;
     }
 
@@ -111,7 +111,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param rate The multiple at which to run the system.
      */
     Base& rate(int32_t rate) {
-        m_desc->rate = rate;
+        desc_->rate = rate;
         return *this;
     }
 
@@ -122,7 +122,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      */
     template<typename T>
     Base& tick_source() {
-        m_desc->tick_source = _::cpp_type<T>::id(world_v());
+        desc_->tick_source = _::type<T>::id(world_v());
         return *this;
     }
 
@@ -132,19 +132,19 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
      * @param tick_source The tick source to use for the system.
      */
     Base& tick_source(flecs::entity_t tick_source) {
-        m_desc->tick_source = tick_source;
+        desc_->tick_source = tick_source;
         return *this;
     }
 
     /** Set system context */
     Base& ctx(void *ptr) {
-        m_desc->ctx = ptr;
+        desc_->ctx = ptr;
         return *this;
     }
 
     /** Set system run callback */
     Base& run(ecs_iter_action_t action) {
-        m_desc->run = action;
+        desc_->run = action;
         return *this;
     }
 
@@ -156,7 +156,7 @@ struct system_builder_i : query_builder_i<Base, Components ...> {
         return *static_cast<Base*>(this);
     }
 
-    ecs_system_desc_t *m_desc;
+    ecs_system_desc_t *desc_;
 };
 
 }
diff --git a/include/flecs/addons/cpp/mixins/system/impl.hpp b/include/flecs/addons/cpp/mixins/system/impl.hpp
index da13f5e3b..4c9d65e69 100644
--- a/include/flecs/addons/cpp/mixins/system/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/system/impl.hpp
@@ -18,50 +18,47 @@ struct system_runner_fluent {
         int32_t stage_count, 
         ecs_ftime_t delta_time, 
         void *param)
-        : m_stage(world)
-        , m_id(id)
-        , m_delta_time(delta_time)
-        , m_param(param)
-        , m_offset(0)
-        , m_limit(0)
-        , m_stage_current(stage_current)
-        , m_stage_count(stage_count) { }
+        : stage_(world)
+        , id_(id)
+        , delta_time_(delta_time)
+        , param_(param)
+        , stage_current_(stage_current)
+        , stage_count_(stage_count) { }
 
     system_runner_fluent& offset(int32_t offset) {
-        m_offset = offset;
+        offset_ = offset;
         return *this;
     }
 
     system_runner_fluent& limit(int32_t limit) {
-        m_limit = limit;
+        limit_ = limit;
         return *this;
     }
 
     system_runner_fluent& stage(flecs::world& stage) {
-        m_stage = stage.c_ptr();
+        stage_ = stage.c_ptr();
         return *this;
     }
 
     ~system_runner_fluent() {
-        if (m_stage_count) {
+        if (stage_count_) {
             ecs_run_worker(
-                m_stage, m_id, m_stage_current, m_stage_count, m_delta_time,
-                m_param);            
+                stage_, id_, stage_current_, stage_count_, delta_time_,
+                param_);            
         } else {
-            ecs_run_w_filter(
-                m_stage, m_id, m_delta_time, m_offset, m_limit, m_param);
+            ecs_run(stage_, id_, delta_time_, param_);
         }
     }
 
 private:
-    world_t *m_stage;
-    entity_t m_id;
-    ecs_ftime_t m_delta_time;
-    void *m_param;
-    int32_t m_offset;
-    int32_t m_limit;
-    int32_t m_stage_current;
-    int32_t m_stage_count;
+    world_t *stage_;
+    entity_t id_;
+    ecs_ftime_t delta_time_;
+    void *param_;
+    int32_t offset_;
+    int32_t limit_;
+    int32_t stage_current_;
+    int32_t stage_count_;
 };
 
 struct system final : entity
@@ -69,41 +66,37 @@ struct system final : entity
     using entity::entity;
 
     explicit system() {
-        m_id = 0;
-        m_world = nullptr;
+        id_ = 0;
+        world_ = nullptr;
     }
 
     explicit system(flecs::world_t *world, ecs_system_desc_t *desc, bool instanced) 
     {
-        if (!desc->query.filter.instanced) {
-            desc->query.filter.instanced = instanced;
+        if (!(desc->query.flags & EcsQueryIsInstanced)) {
+            ECS_BIT_COND(desc->query.flags, EcsQueryIsInstanced, instanced);
         }
 
-        m_world = world;
-        m_id = ecs_system_init(world, desc);
-
-        if (desc->query.filter.terms_buffer) {
-            ecs_os_free(desc->query.filter.terms_buffer);
-        }
+        world_ = world;
+        id_ = ecs_system_init(world, desc);
     }
 
     void ctx(void *ctx) {
         ecs_system_desc_t desc = {};
-        desc.entity = m_id;
+        desc.entity = id_;
         desc.ctx = ctx;
-        ecs_system_init(m_world, &desc);
+        ecs_system_init(world_, &desc);
     }
 
     void* ctx() const {
-        return ecs_system_get_ctx(m_world, m_id);
+        return ecs_system_get_ctx(world_, id_);
     }
 
     flecs::query<> query() const {
-        return flecs::query<>(m_world, ecs_system_get_query(m_world, m_id));
+        return flecs::query<>(ecs_system_get_query(world_, id_));
     }
 
     system_runner_fluent run(ecs_ftime_t delta_time = 0.0f, void *param = nullptr) const {
-        return system_runner_fluent(m_world, m_id, 0, 0, delta_time, param);
+        return system_runner_fluent(world_, id_, 0, 0, delta_time, param);
     }
 
     system_runner_fluent run_worker(
@@ -113,7 +106,7 @@ struct system final : entity
         void *param = nullptr) const 
     {
         return system_runner_fluent(
-            m_world, m_id, stage_current, stage_count, delta_time, param);
+            world_, id_, stage_current, stage_count, delta_time, param);
     }
 
 #   ifdef FLECS_TIMER
@@ -124,12 +117,12 @@ struct system final : entity
 
 // Mixin implementation
 inline system world::system(flecs::entity e) const {
-    return flecs::system(m_world, e);
+    return flecs::system(world_, e);
 }
 
 template <typename... Comps, typename... Args>
 inline system_builder<Comps...> world::system(Args &&... args) const {
-    return flecs::system_builder<Comps...>(m_world, FLECS_FWD(args)...);
+    return flecs::system_builder<Comps...>(world_, FLECS_FWD(args)...);
 }
 
 namespace _ {
diff --git a/include/flecs/addons/cpp/mixins/term/builder_i.hpp b/include/flecs/addons/cpp/mixins/term/builder_i.hpp
index ed12c987b..7464b4b2b 100644
--- a/include/flecs/addons/cpp/mixins/term/builder_i.hpp
+++ b/include/flecs/addons/cpp/mixins/term/builder_i.hpp
@@ -15,80 +15,25 @@ namespace flecs
  * descriptions can reference entities by id, name or by variable, which means
  * the entity will be resolved when the term is evaluated.
  * 
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  */
 template<typename Base>
 struct term_id_builder_i {
-    term_id_builder_i() : m_term_id(nullptr) { }
+    term_id_builder_i() : term_id_(nullptr) { }
 
     virtual ~term_id_builder_i() { }
 
     /* The self flag indicates the term identifier itself is used */
     Base& self() {
         this->assert_term_id();
-        m_term_id->flags |= flecs::Self;
-        return *this;
-    }
-
-    /* The up flag indicates that the term identifier may be substituted by
-     * traversing a relationship upwards. For example: substitute the identifier
-     * with its parent by traversing the ChildOf relationship. */
-    Base& up(flecs::entity_t trav = 0) {
-        this->assert_term_id();
-        m_term_id->flags |= flecs::Up;
-        if (trav) {
-            m_term_id->trav = trav;
-        }
-        return *this;
-    }
-
-    template <typename Trav>
-    Base& up() {
-        return this->up(_::cpp_type<Trav>::id(this->world_v()));
-    }
-
-    /* The cascade flag is like up, but returns results in breadth-first order.
-     * Only supported for flecs::query */
-    Base& cascade(flecs::entity_t trav = 0) {
-        this->assert_term_id();
-        m_term_id->flags |= flecs::Cascade;
-        if (trav) {
-            m_term_id->trav = trav;
-        }
-        return *this;
-    }
-
-    template <typename Trav>
-    Base& cascade() {
-        return this->cascade(_::cpp_type<Trav>::id(this->world_v()));
-    }
-
-    /* Use with cascade to iterate results in descending (bottom -> top) order */
-    Base& desc() {
-        this->assert_term_id();
-        m_term_id->flags |= flecs::Desc;
-        return *this;
-    }
-
-    /* The parent flag is short for up(flecs::ChildOf) */
-    Base& parent() {
-        this->assert_term_id();
-        m_term_id->flags |= flecs::Parent;
-        return *this;
-    }
-
-    /* Specify relationship to traverse, and flags to indicate direction */
-    Base& trav(flecs::entity_t trav, flecs::flags32_t flags = 0) {
-        this->assert_term_id();
-        m_term_id->trav = trav;
-        m_term_id->flags |= flags;
+        term_id_->id |= flecs::Self;
         return *this;
     }
 
     /* Specify value of identifier by id */
     Base& id(flecs::entity_t id) {
         this->assert_term_id();
-        m_term_id->id = id;
+        term_id_->id = id;
         return *this;
     }
 
@@ -102,45 +47,44 @@ struct term_id_builder_i {
      */
     Base& entity(flecs::entity_t entity) {
         this->assert_term_id();
-        m_term_id->flags = flecs::IsEntity;
-        m_term_id->id = entity;
+        term_id_->id = entity | flecs::IsEntity;
         return *this;
     }
 
     /* Specify value of identifier by name */
     Base& name(const char *name) {
         this->assert_term_id();
-        m_term_id->flags |= flecs::IsEntity;
-        m_term_id->name = const_cast<char*>(name);
+        term_id_->id |= flecs::IsEntity;
+        term_id_->name = const_cast<char*>(name);
         return *this;
     }
 
     /* Specify identifier is a variable (resolved at query evaluation time) */
     Base& var(const char *var_name) {
         this->assert_term_id();
-        m_term_id->flags |= flecs::IsVariable;
-        m_term_id->name = const_cast<char*>(var_name);
+        term_id_->id |= flecs::IsVariable;
+        term_id_->name = const_cast<char*>(var_name);
         return *this;
     }
 
     /* Override term id flags */
     Base& flags(flecs::flags32_t flags) {
         this->assert_term_id();
-        m_term_id->flags = flags;
+        term_id_->id = flags;
         return *this;
     }
 
-    ecs_term_id_t *m_term_id;
-    
+    ecs_term_ref_t *term_id_;
+
 protected:
     virtual flecs::world_t* world_v() = 0;
 
-private:
     void assert_term_id() {
-        ecs_assert(m_term_id != NULL, ECS_INVALID_PARAMETER, 
+        ecs_assert(term_id_ != NULL, ECS_INVALID_PARAMETER, 
             "no active term (call .term() first)");
     }
 
+private:
     operator Base&() {
         return *static_cast<Base*>(this);
     }
@@ -149,11 +93,11 @@ struct term_id_builder_i {
 /** Term builder interface. 
  * A term is a single element of a query expression. 
  * 
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  */
 template<typename Base>
 struct term_builder_i : term_id_builder_i<Base> {
-    term_builder_i() : m_term(nullptr) { }
+    term_builder_i() : term_(nullptr) { }
 
     term_builder_i(ecs_term_t *term_ptr) { 
         set_term(term_ptr);
@@ -166,7 +110,7 @@ struct term_builder_i : term_id_builder_i<Base> {
     /* Call prior to setting values for src identifier */
     Base& src() {
         this->assert_term();
-        this->m_term_id = &m_term->src;
+        this->term_id_ = &term_->src;
         return *this;
     }
 
@@ -175,7 +119,7 @@ struct term_builder_i : term_id_builder_i<Base> {
      * populated as well). */
     Base& first() {
         this->assert_term();
-        this->m_term_id = &m_term->first;
+        this->term_id_ = &term_->first;
         return *this;
     }
 
@@ -183,7 +127,7 @@ struct term_builder_i : term_id_builder_i<Base> {
      * element of a pair. Requires that first() is populated as well. */
     Base& second() {
         this->assert_term();
-        this->m_term_id = &m_term->second;
+        this->term_id_ = &term_->second;
         return *this;
     }
 
@@ -197,7 +141,7 @@ struct term_builder_i : term_id_builder_i<Base> {
     /* Select src identifier, initialize it with id associated with type */
     template<typename T>
     Base& src() {
-        this->src(_::cpp_type<T>::id(this->world_v()));
+        this->src(_::type<T>::id(this->world_v()));
         return *this;
     }
 
@@ -224,7 +168,7 @@ struct term_builder_i : term_id_builder_i<Base> {
     /* Select first identifier, initialize it with id associated with type */
     template<typename T>
     Base& first() {
-        this->first(_::cpp_type<T>::id(this->world_v()));
+        this->first(_::type<T>::id(this->world_v()));
         return *this;
     }
 
@@ -251,7 +195,7 @@ struct term_builder_i : term_id_builder_i<Base> {
     /* Select second identifier, initialize it with id associated with type */
     template<typename T>
     Base& second() {
-        this->second(_::cpp_type<T>::id(this->world_v()));
+        this->second(_::type<T>::id(this->world_v()));
         return *this;
     }
 
@@ -268,17 +212,70 @@ struct term_builder_i : term_id_builder_i<Base> {
         return *this;
     }
 
-    /** Set role of term. */
-    Base& role(id_t role) {
+    /* The up flag indicates that the term identifier may be substituted by
+     * traversing a relationship upwards. For example: substitute the identifier
+     * with its parent by traversing the ChildOf relationship. */
+    Base& up(flecs::entity_t trav = 0) {
+        this->assert_term_id();
+        this->term_id_->id |= flecs::Up;
+        if (trav) {
+            term_->trav = trav;
+        }
+        return *this;
+    }
+
+    template <typename Trav>
+    Base& up() {
+        return this->up(_::type<Trav>::id(this->world_v()));
+    }
+
+    /* The cascade flag is like up, but returns results in breadth-first order.
+     * Only supported for flecs::query */
+    Base& cascade(flecs::entity_t trav = 0) {
+        this->assert_term_id();
+        this->term_id_->id |= flecs::Cascade;
+        if (trav) {
+            term_->trav = trav;
+        }
+        return *this;
+    }
+
+    template <typename Trav>
+    Base& cascade() {
+        return this->cascade(_::type<Trav>::id(this->world_v()));
+    }
+
+    /* Use with cascade to iterate results in descending (bottom -> top) order */
+    Base& desc() {
+        this->assert_term_id();
+        this->term_id_->id |= flecs::Desc;
+        return *this;
+    }
+
+    /* Same as up(), exists for backwards compatibility */
+    Base& parent() {
+        return this->up();
+    }
+
+    /* Specify relationship to traverse, and flags to indicate direction */
+    Base& trav(flecs::entity_t trav, flecs::flags32_t flags = 0) {
+        this->assert_term_id();
+        term_->trav = trav;
+        this->term_id_->id |= flags;
+        return *this;
+    }
+
+    /** Set id flags for term. */
+    Base& id_flags(id_t flags) {
         this->assert_term();
-        m_term->id_flags = role;
+        term_->id |= flags;
         return *this;
     }
 
     /** Set read/write access of term. */
     Base& inout(flecs::inout_kind_t inout) {
         this->assert_term();
-        m_term->inout = static_cast<ecs_inout_kind_t>(inout);
+        term_->inout = static_cast<ecs_inout_kind_t>(inout);
         return *this;
     }
 
@@ -292,8 +289,8 @@ struct term_builder_i : term_id_builder_i<Base> {
      */
     Base& inout_stage(flecs::inout_kind_t inout) {
         this->assert_term();
-        m_term->inout = static_cast<ecs_inout_kind_t>(inout);
-        if (m_term->oper != EcsNot) {
+        term_->inout = static_cast<ecs_inout_kind_t>(inout);
+        if (term_->oper != EcsNot) {
             this->src().entity(0);
         }
         return *this;
@@ -343,7 +340,7 @@ struct term_builder_i : term_id_builder_i<Base> {
     /** Set operator of term. */
     Base& oper(flecs::oper_kind_t oper) {
         this->assert_term();
-        m_term->oper = static_cast<ecs_oper_kind_t>(oper);
+        term_->oper = static_cast<ecs_oper_kind_t>(oper);
         return *this;
     }
 
@@ -385,47 +382,47 @@ struct term_builder_i : term_id_builder_i<Base> {
     /** Match singleton. */
     Base& singleton() {
         this->assert_term();
-        ecs_assert(m_term->id || m_term->first.id, ECS_INVALID_PARAMETER, 
+        ecs_assert(term_->id || term_->first.id, ECS_INVALID_PARAMETER, 
                 "no component specified for singleton");
         
-        flecs::id_t sid = m_term->id;
+        flecs::id_t sid = term_->id;
         if (!sid) {
-            sid = m_term->first.id;
+            sid = term_->first.id;
         }
 
         ecs_assert(sid != 0, ECS_INVALID_PARAMETER, NULL);
 
         if (!ECS_IS_PAIR(sid)) {
-            m_term->src.id = sid;
+            term_->src.id = sid;
         } else {
-            m_term->src.id = ecs_pair_first(world(), sid);
+            term_->src.id = ecs_pair_first(world(), sid);
         }
         return *this;
     }
 
-    /* Filter terms are not triggered on by observers */
+    /* Query terms are not triggered on by observers */
     Base& filter() {
-        m_term->src.flags |= flecs::Filter;
+        term_->inout = EcsInOutFilter;
         return *this;
     }
 
-    ecs_term_t *m_term;
+    ecs_term_t *term_;
 
 protected:
     virtual flecs::world_t* world_v() = 0;
 
     void set_term(ecs_term_t *term) {
-        m_term = term;
+        term_ = term;
         if (term) {
-            this->m_term_id = &m_term->src; // default to subject
+            this->term_id_ = &term_->src; // default to subject
         } else {
-            this->m_term_id = nullptr;
+            this->term_id_ = nullptr;
         }
     }
 
 private:
     void assert_term() {
-        ecs_assert(m_term != NULL, ECS_INVALID_PARAMETER, 
+        ecs_assert(term_ != NULL, ECS_INVALID_PARAMETER, 
             "no active term (call .term() first)");
     }
 
diff --git a/include/flecs/addons/cpp/mixins/term/decl.hpp b/include/flecs/addons/cpp/mixins/term/decl.hpp
index 83cdb0087..b5a1bdbd5 100644
--- a/include/flecs/addons/cpp/mixins/term/decl.hpp
+++ b/include/flecs/addons/cpp/mixins/term/decl.hpp
@@ -8,7 +8,7 @@
 namespace flecs {
 
 /**
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  *
  * @{
  */
diff --git a/include/flecs/addons/cpp/mixins/term/impl.hpp b/include/flecs/addons/cpp/mixins/term/impl.hpp
index 2136c719a..347fb6f38 100644
--- a/include/flecs/addons/cpp/mixins/term/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/term/impl.hpp
@@ -11,119 +11,76 @@ namespace flecs {
 
 /** Class that describes a term.
  * 
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  */
 struct term final : term_builder_i<term> {
     term()
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(nullptr) { value.move = true; }
+        , world_(nullptr) { }
 
     term(flecs::world_t *world_ptr) 
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(world_ptr) { value.move = true; }
+        , world_(world_ptr) { }
 
     term(flecs::world_t *world_ptr, ecs_term_t t)
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(world_ptr) {
+        , world_(world_ptr) {
             value = t;
-            value.move = false;
             this->set_term(&value);
         }
 
     term(flecs::world_t *world_ptr, id_t id)
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(world_ptr) {
+        , world_(world_ptr) {
             if (id & ECS_ID_FLAGS_MASK) {
                 value.id = id;
             } else {
                 value.first.id = id;
             }
-            value.move = false;
             this->set_term(&value);
         }
 
     term(flecs::world_t *world_ptr, entity_t r, entity_t o)
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(world_ptr) {
+        , world_(world_ptr) {
             value.id = ecs_pair(r, o);
-            value.move = false;
             this->set_term(&value);
         }
 
     term(id_t id) 
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(nullptr) { 
+        , world_(nullptr) { 
             if (id & ECS_ID_FLAGS_MASK) {
                 value.id = id;
             } else {
                 value.first.id = id;
             }
-            value.move = true; 
         }
 
     term(id_t r, id_t o) 
         : term_builder_i<term>(&value)
         , value({})
-        , m_world(nullptr) { 
+        , world_(nullptr) { 
             value.id = ecs_pair(r, o);
-            value.move = true; 
         }
 
-    term(const term& t) : term_builder_i<term>(&value) {
-        m_world = t.m_world;
-        value = ecs_term_copy(&t.value);
-        this->set_term(&value);
-    }
-
-    term(term&& t) noexcept : term_builder_i<term>(&value) {
-        m_world = t.m_world;
-        value = ecs_term_move(&t.value);
-        t.reset();
-        this->set_term(&value);
-    }
-
-    term& operator=(const term& t) {
-        ecs_assert(m_world == t.m_world, ECS_INVALID_PARAMETER, NULL);
-        ecs_term_fini(&value);
-        value = ecs_term_copy(&t.value);
-        this->set_term(&value);
-        return *this;
-    }
-
-    term& operator=(term&& t) noexcept {
-        ecs_assert(m_world == t.m_world, ECS_INVALID_PARAMETER, NULL);
-        ecs_term_fini(&value);
-        value = t.value;
-        this->set_term(&value);
-        t.reset();
-        return *this;
-    }   
-
-    ~term() {
-        ecs_term_fini(&value);
-    }
-
     void reset() {
         value = {};
         this->set_term(nullptr);
     }
 
-    int finalize() {
-        return ecs_term_finalize(m_world, &value);
-    }
-
     bool is_set() {
         return ecs_term_is_initialized(&value);
     }
 
     flecs::id id() {
-        return flecs::id(m_world, value.id);
+        return flecs::id(world_, value.id);
     }
 
     flecs::inout_kind_t inout() {
@@ -135,46 +92,46 @@ struct term final : term_builder_i<term> {
     }
 
     flecs::entity get_src() {
-        return flecs::entity(m_world, value.src.id);
+        return flecs::entity(world_, ECS_TERM_REF_ID(&value.src));
     }
 
     flecs::entity get_first() {
-        return flecs::entity(m_world, value.first.id);
+        return flecs::entity(world_, ECS_TERM_REF_ID(&value.first));
     }
 
     flecs::entity get_second() {
-        return flecs::entity(m_world, value.second.id);
+        return flecs::entity(world_, ECS_TERM_REF_ID(&value.second));
     }
 
-    ecs_term_t move() { /* explicit move to ecs_term_t */
-        return ecs_term_move(&value);
+    operator flecs::term_t() const {
+        return value;
     }
 
-    ecs_term_t value;
+    flecs::term_t value;
 
 protected:
-    flecs::world_t* world_v() override { return m_world; }
+    flecs::world_t* world_v() override { return world_; }
 
 private:
-    flecs::world_t *m_world;
+    flecs::world_t *world_;
 };
 
 // Term mixin implementation
 template <typename... Args>
 inline flecs::term world::term(Args &&... args) const {
-    return flecs::term(m_world, FLECS_FWD(args)...);
+    return flecs::term(world_, FLECS_FWD(args)...);
 }
 
 template <typename T>
 inline flecs::term world::term() const {
-    return flecs::term(m_world, _::cpp_type<T>::id(m_world));
+    return flecs::term(world_, _::type<T>::id(world_));
 }
 
 template <typename First, typename Second>
 inline flecs::term world::term() const {
-    return flecs::term(m_world, ecs_pair(
-        _::cpp_type<First>::id(m_world),
-        _::cpp_type<Second>::id(m_world)));
+    return flecs::term(world_, ecs_pair(
+        _::type<First>::id(world_),
+        _::type<Second>::id(world_)));
 }
 
 }
diff --git a/include/flecs/addons/cpp/mixins/term/mixin.inl b/include/flecs/addons/cpp/mixins/term/mixin.inl
index 8c05566dc..2c34e9984 100644
--- a/include/flecs/addons/cpp/mixins/term/mixin.inl
+++ b/include/flecs/addons/cpp/mixins/term/mixin.inl
@@ -5,7 +5,7 @@
 
 /**
  * @memberof flecs::world
- * @ingroup cpp_core_filters
+ * @ingroup cpp_core_queries
  *
  * @{
  */
diff --git a/include/flecs/addons/cpp/mixins/timer/impl.hpp b/include/flecs/addons/cpp/mixins/timer/impl.hpp
index 72ece82bb..e26c19db8 100644
--- a/include/flecs/addons/cpp/mixins/timer/impl.hpp
+++ b/include/flecs/addons/cpp/mixins/timer/impl.hpp
@@ -12,86 +12,86 @@ struct timer final : entity {
     using entity::entity;
 
     timer& interval(ecs_ftime_t interval) {
-        ecs_set_interval(m_world, m_id, interval);
+        ecs_set_interval(world_, id_, interval);
         return *this;
     }
 
     ecs_ftime_t interval() {
-        return ecs_get_interval(m_world, m_id);
+        return ecs_get_interval(world_, id_);
     }
 
     timer& timeout(ecs_ftime_t timeout) {
-        ecs_set_timeout(m_world, m_id, timeout);
+        ecs_set_timeout(world_, id_, timeout);
         return *this;
     }
 
     ecs_ftime_t timeout() {
-        return ecs_get_timeout(m_world, m_id);
+        return ecs_get_timeout(world_, id_);
     }
 
     timer& rate(int32_t rate, flecs::entity_t tick_source = 0) {
-        ecs_set_rate(m_world, m_id, rate, tick_source);
+        ecs_set_rate(world_, id_, rate, tick_source);
         return *this;
     }
 
     void start() {
-        ecs_start_timer(m_world, m_id);
+        ecs_start_timer(world_, id_);
     }
 
     void stop() {
-        ecs_stop_timer(m_world, m_id);
+        ecs_stop_timer(world_, id_);
     }
 };
 
 template <typename T>
 inline flecs::timer world::timer() const {
-    return flecs::timer(m_world, _::cpp_type<T>::id(m_world));
+    return flecs::timer(world_, _::type<T>::id(world_));
 }
 
 template <typename... Args>
 inline flecs::timer world::timer(Args &&... args) const {
-    return flecs::timer(m_world, FLECS_FWD(args)...);
+    return flecs::timer(world_, FLECS_FWD(args)...);
 }
 
 inline void world::randomize_timers() const {
-    ecs_randomize_timers(m_world);
+    ecs_randomize_timers(world_);
 }
 
 inline void system::interval(ecs_ftime_t interval) {
-    ecs_set_interval(m_world, m_id, interval);
+    ecs_set_interval(world_, id_, interval);
 }
 
 inline ecs_ftime_t system::interval() {
-    return ecs_get_interval(m_world, m_id);
+    return ecs_get_interval(world_, id_);
 }
 
 inline void system::timeout(ecs_ftime_t timeout) {
-    ecs_set_timeout(m_world, m_id, timeout);
+    ecs_set_timeout(world_, id_, timeout);
 }
 
 inline ecs_ftime_t system::timeout() {
-    return ecs_get_timeout(m_world, m_id);
+    return ecs_get_timeout(world_, id_);
 }
 
 inline void system::rate(int32_t rate) {
-    ecs_set_rate(m_world, m_id, rate, 0);
+    ecs_set_rate(world_, id_, rate, 0);
 }
 
 inline void system::start() {
-    ecs_start_timer(m_world, m_id);
+    ecs_start_timer(world_, id_);
 }
 
 inline void system::stop() {
-    ecs_stop_timer(m_world, m_id);
+    ecs_stop_timer(world_, id_);
 }
 
 template<typename T>
 inline void system::set_tick_source() {
-    ecs_set_tick_source(m_world, m_id, _::cpp_type<T>::id(m_world));
+    ecs_set_tick_source(world_, id_, _::type<T>::id(world_));
 }
 
 inline void system::set_tick_source(flecs::entity e) {
-    ecs_set_tick_source(m_world, m_id, e);
+    ecs_set_tick_source(world_, id_, e);
 }
 
 namespace _ {
diff --git a/include/flecs/addons/cpp/ref.hpp b/include/flecs/addons/cpp/ref.hpp
index 7cb26dfbf..ad2aaa3cd 100644
--- a/include/flecs/addons/cpp/ref.hpp
+++ b/include/flecs/addons/cpp/ref.hpp
@@ -21,40 +21,42 @@ namespace flecs
  */
 template <typename T>
 struct ref {
-    ref() : m_world(nullptr), m_ref{} { }
+    ref() : world_(nullptr), ref_{} { }
 
     ref(world_t *world, entity_t entity, flecs::id_t id = 0)
-        : m_ref()
+        : ref_()
     {
         // the world we were called with may be a stage; convert it to a world
         // here if that is the case
-        m_world = world ? const_cast<flecs::world_t *>(ecs_get_world(world))
+        world_ = world ? const_cast<flecs::world_t *>(ecs_get_world(world))
             : nullptr;
         if (!id) {
-            id = _::cpp_type<T>::id(world);
+            id = _::type<T>::id(world);
         }
 
-        ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+        ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
-        m_ref = ecs_ref_init_id(m_world, entity, id);
+        ref_ = ecs_ref_init_id(world_, entity, id);
     }
 
     T* operator->() {
         T* result = static_cast<T*>(ecs_ref_get_id(
-            m_world, &m_ref, this->m_ref.id));
+            world_, &ref_, this->ref_.id));
 
-        ecs_assert(result != NULL, ECS_INVALID_PARAMETER, NULL);
+        ecs_assert(result != NULL, ECS_INVALID_PARAMETER,
+            "nullptr dereference by flecs::ref");
 
         return result;
     }
 
     T* get() {
         return static_cast<T*>(ecs_ref_get_id(
-            m_world, &m_ref, this->m_ref.id));
+            world_, &ref_, this->ref_.id));
     }
 
     T* try_get() {
-        if (!m_world || !m_ref.entity) {
+        if (!world_ || !ref_.entity) {
             return nullptr;
         }
 
@@ -64,8 +66,8 @@ struct ref {
     flecs::entity entity() const;
 
 private:
-    world_t *m_world;
-    flecs::ref_t m_ref;
+    world_t *world_;
+    flecs::ref_t ref_;
 };
 
 /** @} */
diff --git a/include/flecs/addons/cpp/table.hpp b/include/flecs/addons/cpp/table.hpp
index c74df3a7a..0b3d81c0a 100644
--- a/include/flecs/addons/cpp/table.hpp
+++ b/include/flecs/addons/cpp/table.hpp
@@ -16,27 +16,27 @@ namespace flecs {
  */
 
 struct table {
-    table() : m_world(nullptr), m_table(nullptr) { }
+    table() : world_(nullptr), table_(nullptr) { }
 
     table(world_t *world, table_t *t)
-        : m_world(world)
-        , m_table(t) { }
+        : world_(world)
+        , table_(t) { }
 
     virtual ~table() { }
 
     /** Convert table type to string. */
     flecs::string str() const {
-        return flecs::string(ecs_table_str(m_world, m_table));
+        return flecs::string(ecs_table_str(world_, table_));
     }
 
     /** Get table type. */
     flecs::type type() const {
-        return flecs::type(m_world, ecs_table_get_type(m_table));
+        return flecs::type(world_, ecs_table_get_type(table_));
     }
 
     /** Get table count. */
     int32_t count() const {
-        return ecs_table_count(m_table);
+        return ecs_table_count(table_);
     }
 
     /** Find type index for (component) id.
@@ -45,7 +45,7 @@ struct table {
      * @return The index of the id in the table type, -1 if not found/
      */
     int32_t type_index(flecs::id_t id) const {
-        return ecs_table_get_type_index(m_world, m_table, id);
+        return ecs_table_get_type_index(world_, table_, id);
     }
 
     /** Find type index for type.
@@ -55,7 +55,7 @@ struct table {
      */
     template <typename T>
     int32_t type_index() const {
-        return type_index(_::cpp_type<T>::id(m_world));
+        return type_index(_::type<T>::id(world_));
     }
 
     /** Find type index for pair.
@@ -74,7 +74,7 @@ struct table {
      */
     template <typename First>
     int32_t type_index(flecs::entity_t second) const {
-        return type_index(_::cpp_type<First>::id(m_world), second);
+        return type_index(_::type<First>::id(world_), second);
     }
 
     /** Find type index for pair.
@@ -84,7 +84,7 @@ struct table {
      */
     template <typename First, typename Second>
     int32_t type_index() const {
-        return type_index<First>(_::cpp_type<Second>::id(m_world));
+        return type_index<First>(_::type<Second>::id(world_));
     }
 
     /** Find column index for (component) id.
@@ -93,7 +93,7 @@ struct table {
      * @return The index of the id in the table type, -1 if not found/
      */
     int32_t column_index(flecs::id_t id) const {
-        return ecs_table_get_column_index(m_world, m_table, id);
+        return ecs_table_get_column_index(world_, table_, id);
     }
 
     /** Find column index for type.
@@ -103,7 +103,7 @@ struct table {
      */
     template <typename T>
     int32_t column_index() const {
-        return column_index(_::cpp_type<T>::id(m_world));
+        return column_index(_::type<T>::id(world_));
     }
 
     /** Find column index for pair.
@@ -122,7 +122,7 @@ struct table {
      */
     template <typename First>
     int32_t column_index(flecs::entity_t second) const {
-        return column_index(_::cpp_type<First>::id(m_world), second);
+        return column_index(_::type<First>::id(world_), second);
     }
 
     /** Find column index for pair.
@@ -132,7 +132,7 @@ struct table {
      */
     template <typename First, typename Second>
     int32_t column_index() const {
-        return column_index<First>(_::cpp_type<Second>::id(m_world));
+        return column_index<First>(_::type<Second>::id(world_));
     }
 
     /** Test if table has (component) id.
@@ -192,7 +192,7 @@ struct table {
      * @return Pointer to the column, NULL if not a component.
      */
     virtual void* get_column(int32_t index) const {
-        return ecs_table_get_column(m_table, index, 0);
+        return ecs_table_get_column(table_, index, 0);
     }
 
     /** Get pointer to component array by component.
@@ -225,7 +225,7 @@ struct table {
      */
     template <typename T, if_t< is_actual<T>::value > = 0>
     T* get() const {
-        return static_cast<T*>(get(_::cpp_type<T>::id(m_world)));
+        return static_cast<T*>(get(_::type<T>::id(world_)));
     }
 
     /** Get pointer to component array by (enum) component.
@@ -235,7 +235,7 @@ struct table {
      */
     template <typename T, if_t< is_enum<T>::value > = 0>
     T* get() const {
-        return static_cast<T*>(get(_::cpp_type<T>::id(m_world)));
+        return static_cast<T*>(get(_::type<T>::id(world_)));
     }
 
     /** Get pointer to component array by component.
@@ -246,7 +246,7 @@ struct table {
     template <typename T, typename A = actual_type_t<T>,
         if_t< flecs::is_pair<T>::value > = 0>
     A* get() const {
-        return static_cast<A*>(get(_::cpp_type<T>::id(m_world)));
+        return static_cast<A*>(get(_::type<T>::id(world_)));
     }
 
     /** Get pointer to component array by pair.
@@ -257,7 +257,7 @@ struct table {
      */
     template <typename First>
     First* get(flecs::entity_t second) const {
-        return static_cast<First*>(get(_::cpp_type<First>::id(m_world), second));
+        return static_cast<First*>(get(_::type<First>::id(world_), second));
     }
 
     /** Get pointer to component array by pair.
@@ -269,12 +269,12 @@ struct table {
     template <typename First, typename Second, typename P = flecs::pair<First, Second>,
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     A* get() const {
-        return static_cast<A*>(get<First>(_::cpp_type<Second>::id(m_world)));
+        return static_cast<A*>(get<First>(_::type<Second>::id(world_)));
     }
 
     /** Get column size */
     size_t column_size(int32_t index) {
-        return ecs_table_get_column_size(m_table, index);
+        return ecs_table_get_column_size(table_, index);
     }
 
     /** Get depth for given relationship.
@@ -283,7 +283,7 @@ struct table {
      * @return The depth.
      */
     int32_t depth(flecs::entity_t rel) {
-        return ecs_table_get_depth(m_world, m_table, rel);
+        return ecs_table_get_depth(world_, table_, rel);
     }
 
     /** Get depth for given relationship.
@@ -293,36 +293,44 @@ struct table {
      */
     template <typename Rel>
     int32_t depth() {
-        return depth(_::cpp_type<Rel>::id(m_world));
+        return depth(_::type<Rel>::id(world_));
+    }
+
+    /** Get table.
+     *
+     * @return The table.
+     */
+    table_t* get_table() const {
+        return table_;
     }
 
     /* Implicit conversion to table_t */
     operator table_t*() const {
-        return m_table;
+        return table_;
     }
 
 protected:
-    world_t *m_world;
-    table_t *m_table;
+    world_t *world_;
+    table_t *table_;
 };
 
 struct table_range : table {
     table_range()
         : table()
-        , m_offset(0)
-        , m_count(0) { }
+        , offset_(0)
+        , count_(0) { }
 
     table_range(world_t *world, table_t *t, int32_t offset, int32_t count)
         : table(world, t)
-        , m_offset(offset)
-        , m_count(count) { }
+        , offset_(offset)
+        , count_(count) { }
 
     int32_t offset() const {
-        return m_offset;
+        return offset_;
     }
 
     int32_t count() const {
-        return m_count;
+        return count_;
     }
 
     /** Get pointer to component array by column index.
@@ -331,12 +339,12 @@ struct table_range : table {
      * @return Pointer to the column, NULL if not a component.
      */
     void* get_column(int32_t index) const override {
-        return ecs_table_get_column(m_table, index, m_offset);
+        return ecs_table_get_column(table_, index, offset_);
     }
 
 private:
-    int32_t m_offset = 0;
-    int32_t m_count = 0;
+    int32_t offset_ = 0;
+    int32_t count_ = 0;
 };
 
 /** @} */
diff --git a/include/flecs/addons/cpp/type.hpp b/include/flecs/addons/cpp/type.hpp
index 2d21938b5..8a903fc4c 100644
--- a/include/flecs/addons/cpp/type.hpp
+++ b/include/flecs/addons/cpp/type.hpp
@@ -19,58 +19,58 @@ namespace flecs {
  * A type is a vector of component ids which can be requested from entities or tables.
  */
 struct type {
-    type() : m_world(nullptr), m_type(nullptr) { }
+    type() : world_(nullptr), type_(nullptr) { }
 
     type(world_t *world, const type_t *t)
-        : m_world(world)
-        , m_type(t) { }
+        : world_(world)
+        , type_(t) { }
 
     /** Convert type to comma-separated string */
     flecs::string str() const {
-        return flecs::string(ecs_type_str(m_world, m_type));
+        return flecs::string(ecs_type_str(world_, type_));
     }
 
     /** Return number of ids in type */
     int32_t count() const {
-        if (!m_type) {
+        if (!type_) {
             return 0;
         }
-        return m_type->count;
+        return type_->count;
     }
 
     /** Return pointer to array. */
     flecs::id_t* array() const {
-        if (!m_type) {
+        if (!type_) {
             return nullptr;
         }
-        return m_type->array;
+        return type_->array;
     }
 
     /** Get id at specified index in type */
     flecs::id get(int32_t index) const {
-        ecs_assert(m_type != NULL, ECS_INVALID_PARAMETER, NULL);
-        ecs_assert(m_type->count > index, ECS_OUT_OF_RANGE, NULL);
-        if (!m_type) {
+        ecs_assert(type_ != NULL, ECS_INVALID_PARAMETER, NULL);
+        ecs_assert(type_->count > index, ECS_OUT_OF_RANGE, NULL);
+        if (!type_) {
             return flecs::id();
         }
-        return flecs::id(m_world, m_type->array[index]);
+        return flecs::id(world_, type_->array[index]);
     }
 
     flecs::id_t* begin() const {
-        return m_type->array;
+        return type_->array;
     }
 
     flecs::id_t* end() const {
-        return &m_type->array[m_type->count];
+        return &type_->array[type_->count];
     }
 
     /** Implicit conversion to type_t */
     operator const type_t*() const {
-        return m_type;
+        return type_;
     }
 private:
-    world_t *m_world;
-    const type_t *m_type;
+    world_t *world_;
+    const type_t *type_;
 };
 
 /** #} */
diff --git a/include/flecs/addons/cpp/utils/array.hpp b/include/flecs/addons/cpp/utils/array.hpp
index 57abd2c17..b90579788 100644
--- a/include/flecs/addons/cpp/utils/array.hpp
+++ b/include/flecs/addons/cpp/utils/array.hpp
@@ -12,29 +12,29 @@ template <typename T>
 struct array_iterator
 {
     explicit array_iterator(T* value, int index) {
-        m_value = value;
-        m_index = index;
+        value_ = value;
+        index_ = index;
     }
 
     bool operator!=(array_iterator const& other) const
     {
-        return m_index != other.m_index;
+        return index_ != other.index_;
     }
 
     T & operator*() const
     {
-        return m_value[m_index];
+        return value_[index_];
     }
 
     array_iterator& operator++()
     {
-        ++m_index;
+        ++index_;
         return *this;
     }
 
 private:
-    T* m_value;
-    int m_index;
+    T* value_;
+    int index_;
 };
 
 template <typename T, size_t Size, class Enable = void> 
@@ -52,19 +52,19 @@ struct array<T, Size, enable_if_t<Size != 0> > final {
     }
 
     T& operator[](int index) {
-        return m_array[index];
+        return array_[index];
     }
 
     T& operator[](size_t index) {
-        return m_array[index];
+        return array_[index];
     }
 
     array_iterator<T> begin() {
-        return array_iterator<T>(m_array, 0);
+        return array_iterator<T>(array_, 0);
     }
 
     array_iterator<T> end() {
-        return array_iterator<T>(m_array, Size);
+        return array_iterator<T>(array_, Size);
     }
 
     size_t size() {
@@ -72,7 +72,7 @@ struct array<T, Size, enable_if_t<Size != 0> > final {
     }
 
     T* ptr() {
-        return m_array;
+        return array_;
     }
 
     template <typename Func>
@@ -83,7 +83,7 @@ struct array<T, Size, enable_if_t<Size != 0> > final {
     }
 
 private:
-    T m_array[Size];
+    T array_[Size];
 };
 
 template<typename T, size_t Size>
diff --git a/include/flecs/addons/cpp/utils/builder.hpp b/include/flecs/addons/cpp/utils/builder.hpp
index 3af497d33..c45d22724 100644
--- a/include/flecs/addons/cpp/utils/builder.hpp
+++ b/include/flecs/addons/cpp/utils/builder.hpp
@@ -21,32 +21,32 @@ struct builder : IBuilder<Base, Components ...>
 
 public:
     builder(flecs::world_t *world)
-        : IBase(&m_desc)
-        , m_desc{}
-        , m_world(world) { }
+        : IBase(&desc_)
+        , desc_{}
+        , world_(world) { }
 
     builder(const builder& f) 
-        : IBase(&m_desc, f.m_term_index)
+        : IBase(&desc_, f.term_index_)
     {
-        m_world = f.m_world;
-        m_desc = f.m_desc;
+        world_ = f.world_;
+        desc_ = f.desc_;
     }
 
     builder(builder&& f)  noexcept
         : builder<T, TDesc, Base, IBuilder, Components...>(f) { }
 
     operator TDesc*() {
-        return &m_desc;
+        return &desc_;
     }
 
     T<Components ...> build() {
-        return T<Components...>(m_world, *static_cast<Base*>(this));
+        return T<Components...>(world_, *static_cast<Base*>(this));
     }
 
 protected:
-    flecs::world_t* world_v() override { return m_world; }
-    TDesc m_desc;
-    flecs::world_t *m_world;
+    flecs::world_t* world_v() override { return world_; }
+    TDesc desc_;
+    flecs::world_t *world_;
 };
 
 #undef FLECS_TBUILDER
diff --git a/include/flecs/addons/cpp/utils/enum.hpp b/include/flecs/addons/cpp/utils/enum.hpp
index a3b96387e..14a8182a6 100644
--- a/include/flecs/addons/cpp/utils/enum.hpp
+++ b/include/flecs/addons/cpp/utils/enum.hpp
@@ -484,7 +484,7 @@ struct enum_data {
 /** Convenience function for getting enum reflection data */
 template <typename E>
 enum_data<E> enum_type(flecs::world_t *world) {
-    _::cpp_type<E>::id(world); // Ensure enum is registered
+    _::type<E>::id(world); // Ensure enum is registered
     auto& ref = _::enum_type<E>::get();
     return enum_data<E>(world, ref.data);
 }
diff --git a/include/flecs/addons/cpp/utils/iterable.hpp b/include/flecs/addons/cpp/utils/iterable.hpp
index 74ed23474..07d70ddad 100644
--- a/include/flecs/addons/cpp/utils/iterable.hpp
+++ b/include/flecs/addons/cpp/utils/iterable.hpp
@@ -129,6 +129,37 @@ struct iterable {
         return this->iter().first();
     }
 
+    iter_iterable<Components...> set_var(int var_id, flecs::entity_t value) {
+        return this->iter().set_var(var_id, value);
+    }
+
+    iter_iterable<Components...> set_var(const char *name, flecs::entity_t value) {
+        return this->iter().set_var(name, value);
+    }
+
+    iter_iterable<Components...> set_var(const char *name, flecs::table_t *value) {
+        return this->iter().set_var(name, value);
+    }
+
+    iter_iterable<Components...> set_var(const char *name, ecs_table_range_t value) {
+        return this->iter().set_var(name, value);
+    }
+
+    iter_iterable<Components...> set_var(const char *name, flecs::table_range value) {
+        return this->iter().set_var(name, value);
+    }
+
+    // Limit results to tables with specified group id (grouped queries only)
+    iter_iterable<Components...> set_group(uint64_t group_id) {
+        return this->iter().set_group(group_id);
+    }
+
+    // Limit results to tables with specified group id (grouped queries only)
+    template <typename Group>
+    iter_iterable<Components...> set_group() {
+        return this->iter().template set_group<Group>();
+    }
+
     virtual ~iterable() { }
 protected:
     friend iter_iterable<Components...>;
@@ -174,20 +205,51 @@ struct iter_iterable final : iterable<Components...> {
     template <typename Iterable>
     iter_iterable(Iterable *it, flecs::world_t *world) 
     {
-        m_it = it->get_iter(world);
-        m_next = it->next_action();
-        m_next_each = it->next_action();
+        it_ = it->get_iter(world);
+        next_ = it->next_action();
+        next_each_ = it->next_action();
+        ecs_assert(next_ != nullptr, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(next_each_ != nullptr, ECS_INTERNAL_ERROR, NULL);
     }
 
     iter_iterable<Components...>& set_var(int var_id, flecs::entity_t value) {
         ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, 0);
-        ecs_iter_set_var(&m_it, var_id, value);
+        ecs_iter_set_var(&it_, var_id, value);
         return *this;
     }
 
-#   ifdef FLECS_RULES
-#   include "../mixins/rule/iterable.inl"
-#   endif
+    iter_iterable<Components...>& set_var(const char *name, flecs::entity_t value) {
+        ecs_query_iter_t *qit = &it_.priv_.iter.query;
+        int var_id = ecs_query_find_var(qit->query, name);
+        ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
+        ecs_iter_set_var(&it_, var_id, value);
+        return *this;
+    }
+
+    iter_iterable<Components...>& set_var(const char *name, flecs::table_t *value) {
+        ecs_query_iter_t *qit = &it_.priv_.iter.query;
+        int var_id = ecs_query_find_var(qit->query, name);
+        ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
+        ecs_iter_set_var_as_table(&it_, var_id, value);
+        return *this;
+    }
+
+    iter_iterable<Components...>& set_var(const char *name, ecs_table_range_t value) {
+        ecs_query_iter_t *qit = &it_.priv_.iter.query;
+        int var_id = ecs_query_find_var(qit->query, name);
+        ecs_assert(var_id != -1, ECS_INVALID_PARAMETER, name);
+        ecs_iter_set_var_as_range(&it_, var_id, &value);
+        return *this;
+    }
+
+    iter_iterable<Components...>& set_var(const char *name, flecs::table_range value) {
+        ecs_table_range_t range;
+        range.table = value.get_table();
+        range.offset = value.offset();
+        range.count = value.count();
+        return set_var(name, range);
+    }
+
 #   ifdef FLECS_JSON
 #   include "../mixins/json/iterable.inl"
 #   endif
@@ -195,17 +257,17 @@ struct iter_iterable final : iterable<Components...> {
     // Return total number of entities in result.
     int32_t count() {
         int32_t result = 0;
-        while (m_next_each(&m_it)) {
-            result += m_it.count;
+        while (next_each_(&it_)) {
+            result += it_.count;
         }
         return result;
     }
 
     // Returns true if iterator yields at least once result.
     bool is_true() {
-        bool result = m_next_each(&m_it);
+        bool result = next_each_(&it_);
         if (result) {
-            ecs_iter_fini(&m_it);
+            ecs_iter_fini(&it_);
         }
         return result;
     }
@@ -213,48 +275,48 @@ struct iter_iterable final : iterable<Components...> {
     // Return first matching entity.
     flecs::entity first() {
         flecs::entity result;
-        if (m_next_each(&m_it) && m_it.count) {
-            result = flecs::entity(m_it.world, m_it.entities[0]);
-            ecs_iter_fini(&m_it);
+        if (next_each_(&it_) && it_.count) {
+            result = flecs::entity(it_.world, it_.entities[0]);
+            ecs_iter_fini(&it_);
         }
         return result;
     }
 
     // Limit results to tables with specified group id (grouped queries only)
     iter_iterable<Components...>& set_group(uint64_t group_id) {
-        ecs_query_set_group(&m_it, group_id);
+        ecs_iter_set_group(&it_, group_id);
         return *this;
     }
 
     // Limit results to tables with specified group id (grouped queries only)
     template <typename Group>
     iter_iterable<Components...>& set_group() {
-        ecs_query_set_group(&m_it, _::cpp_type<Group>().id(m_it.real_world));
+        ecs_iter_set_group(&it_, _::type<Group>().id(it_.real_world));
         return *this;
     }
 
 protected:
     ecs_iter_t get_iter(flecs::world_t *world) const {
         if (world) {
-            ecs_iter_t result = m_it;
+            ecs_iter_t result = it_;
             result.world = world;
             return result;
         }
-        return m_it;
+        return it_;
     }
 
     ecs_iter_next_action_t next_action() const {
-        return m_next;
+        return next_;
     }
 
     ecs_iter_next_action_t next_each_action() const {
-        return m_next_each;
+        return next_each_;
     }
 
 private:
-    ecs_iter_t m_it;
-    ecs_iter_next_action_t m_next;
-    ecs_iter_next_action_t m_next_each;
+    ecs_iter_t it_;
+    ecs_iter_next_action_t next_;
+    ecs_iter_next_action_t next_each_;
 };
 
 template <typename ... Components>
@@ -267,15 +329,15 @@ template <typename ... Components>
 struct page_iterable final : iterable<Components...> {
     template <typename Iterable>
     page_iterable(int32_t offset, int32_t limit, Iterable *it) 
-        : m_offset(offset)
-        , m_limit(limit)
+        : offset_(offset)
+        , limit_(limit)
     {
-        m_chain_it = it->get_iter(nullptr);
+        chain_it_ = it->get_iter(nullptr);
     }
 
 protected:
     ecs_iter_t get_iter(flecs::world_t*) const {
-        return ecs_page_iter(&m_chain_it, m_offset, m_limit);
+        return ecs_page_iter(&chain_it_, offset_, limit_);
     }
 
     ecs_iter_next_action_t next_action() const {
@@ -287,9 +349,9 @@ struct page_iterable final : iterable<Components...> {
     }
 
 private:
-    ecs_iter_t m_chain_it;
-    int32_t m_offset;
-    int32_t m_limit;
+    ecs_iter_t chain_it_;
+    int32_t offset_;
+    int32_t limit_;
 };
 
 template <typename ... Components>
@@ -303,15 +365,15 @@ page_iterable<Components...> iterable<Components...>::page(
 template <typename ... Components>
 struct worker_iterable final : iterable<Components...> {
     worker_iterable(int32_t offset, int32_t limit, iterable<Components...> *it) 
-        : m_offset(offset)
-        , m_limit(limit)
+        : offset_(offset)
+        , limit_(limit)
     {
-        m_chain_it = it->get_iter(nullptr);
+        chain_it_ = it->get_iter(nullptr);
     }
 
 protected:
     ecs_iter_t get_iter(flecs::world_t*) const {
-        return ecs_worker_iter(&m_chain_it, m_offset, m_limit);
+        return ecs_worker_iter(&chain_it_, offset_, limit_);
     }
 
     ecs_iter_next_action_t next_action() const {
@@ -323,9 +385,9 @@ struct worker_iterable final : iterable<Components...> {
     }
 
 private:
-    ecs_iter_t m_chain_it;
-    int32_t m_offset;
-    int32_t m_limit;
+    ecs_iter_t chain_it_;
+    int32_t offset_;
+    int32_t limit_;
 };
 
 template <typename ... Components>
diff --git a/include/flecs/addons/cpp/utils/node_builder.hpp b/include/flecs/addons/cpp/utils/node_builder.hpp
index 4c9fa9aee..ff4e356c5 100644
--- a/include/flecs/addons/cpp/utils/node_builder.hpp
+++ b/include/flecs/addons/cpp/utils/node_builder.hpp
@@ -18,16 +18,16 @@ struct node_builder : IBuilder<Base, Components ...>
 
 public:
     explicit node_builder(flecs::world_t* world, const char *name = nullptr)
-        : IBase(&m_desc)
-        , m_desc{}
-        , m_world(world)
-        , m_instanced(false)
+        : IBase(&desc_)
+        , desc_{}
+        , world_(world)
+        , instanced_(false)
     {
         ecs_entity_desc_t entity_desc = {};
         entity_desc.name = name;
         entity_desc.sep = "::";
         entity_desc.root_sep = "::";
-        m_desc.entity = ecs_entity_init(m_world, &entity_desc);
+        desc_.entity = ecs_entity_init(world_, &entity_desc);
     }
 
     /* Iter (or each) is mandatory and always the last thing that 
@@ -46,26 +46,26 @@ struct node_builder : IBuilder<Base, Components ...>
     T each(Func&& func) {
         using Delegate = typename _::each_delegate<
             typename std::decay<Func>::type, Components...>;
-        m_instanced = true;
+        instanced_ = true;
         return build<Delegate>(FLECS_FWD(func));
     }
 
 protected:
-    flecs::world_t* world_v() override { return m_world; }
-    TDesc m_desc;
-    flecs::world_t *m_world;
-    bool m_instanced;
+    flecs::world_t* world_v() override { return world_; }
+    TDesc desc_;
+    flecs::world_t *world_;
+    bool instanced_;
 
 private:
     template <typename Delegate, typename Func>
     T build(Func&& func) {
         auto ctx = FLECS_NEW(Delegate)(FLECS_FWD(func));
-        m_desc.callback = Delegate::run;
-        m_desc.binding_ctx = ctx;
-        m_desc.binding_ctx_free = reinterpret_cast<
+        desc_.callback = Delegate::run;
+        desc_.binding_ctx = ctx;
+        desc_.binding_ctx_free = reinterpret_cast<
             ecs_ctx_free_t>(_::free_obj<Delegate>);
         
-        return T(m_world, &m_desc, m_instanced);
+        return T(world_, &desc_, instanced_);
     }
 };
 
diff --git a/include/flecs/addons/cpp/utils/signature.hpp b/include/flecs/addons/cpp/utils/signature.hpp
index d17f6ad90..e3a0f0e57 100644
--- a/include/flecs/addons/cpp/utils/signature.hpp
+++ b/include/flecs/addons/cpp/utils/signature.hpp
@@ -17,7 +17,7 @@ namespace _ {
 
     template <typename T, if_t< is_reference<T>::value > = 0>
     static constexpr flecs::inout_kind_t type_to_inout() {
-        return flecs::Out;
+        return flecs::InOut;
     }
 
     template <typename T, if_not_t< 
@@ -39,13 +39,13 @@ namespace _ {
     template <typename ... Components>
     struct sig {
         sig(flecs::world_t *world) 
-            : m_world(world)
-            , ids({ (_::cpp_type<remove_pointer_t<Components>>::id(world))... })
+            : world_(world)
+            , ids({ (_::type<remove_pointer_t<Components>>::id(world))... })
             , inout ({ (type_to_inout<Components>())... })
             , oper ({ (type_to_oper<Components>())... }) 
         { }
 
-        flecs::world_t *m_world;
+        flecs::world_t *world_;
         flecs::array<flecs::id_t, sizeof...(Components)> ids;
         flecs::array<flecs::inout_kind_t, sizeof...(Components)> inout;
         flecs::array<flecs::oper_kind_t, sizeof...(Components)> oper;
@@ -54,23 +54,7 @@ namespace _ {
         void populate(const Builder& b) {
             size_t i = 0;
             for (auto id : ids) {
-                if (!(id & ECS_ID_FLAGS_MASK)) {
-                    const flecs::type_info_t *ti = ecs_get_type_info(m_world, id);
-                    if (ti) {
-                        // Union relationships always return a value of type
-                        // flecs::entity_t which holds the target id of the 
-                        // union relationship.
-                        // If a union component with a non-zero size (like an 
-                        // enum) is added to the query signature, the each/iter
-                        // functions would accept a parameter of the component
-                        // type instead of flecs::entity_t, which would cause
-                        // an assert.
-                        ecs_assert(!ti->size || !ecs_has_id(m_world, id, flecs::Union),
-                            ECS_INVALID_PARAMETER,
-                            "use term() method to add union relationship");
-                    }
-                }
-                b->term(id).inout(inout[i]).oper(oper[i]);
+                b->with(id).inout(inout[i]).oper(oper[i]);
                 i ++;
             }
         }
diff --git a/include/flecs/addons/cpp/utils/string.hpp b/include/flecs/addons/cpp/utils/string.hpp
index 3ae5cc080..41c8a5d9e 100644
--- a/include/flecs/addons/cpp/utils/string.hpp
+++ b/include/flecs/addons/cpp/utils/string.hpp
@@ -12,43 +12,43 @@ struct string_view;
 // wrapping in an std::string.
 struct string {
     explicit string() 
-        : m_str(nullptr)
-        , m_const_str("")
-        , m_length(0) { }
+        : str_(nullptr)
+        , const_str_("")
+        , length_(0) { }
 
     explicit string(char *str) 
-        : m_str(str)
-        , m_const_str(str ? str : "")
-        , m_length(str ? ecs_os_strlen(str) : 0) { }
+        : str_(str)
+        , const_str_(str ? str : "")
+        , length_(str ? ecs_os_strlen(str) : 0) { }
 
     ~string() {
         // If flecs is included in a binary but is not used, it is possible that
         // the OS API is not initialized. Calling ecs_os_free in that case could
         // crash the application during exit. However, if a string has been set
         // flecs has been used, and OS API should have been initialized.
-        if (m_str) {
-            ecs_os_free(m_str);
+        if (str_) {
+            ecs_os_free(str_);
         }
     }
 
     string(string&& str) noexcept {
-        ecs_os_free(m_str);
-        m_str = str.m_str;
-        m_const_str = str.m_const_str;
-        m_length = str.m_length;
-        str.m_str = nullptr;
+        ecs_os_free(str_);
+        str_ = str.str_;
+        const_str_ = str.const_str_;
+        length_ = str.length_;
+        str.str_ = nullptr;
     }
 
     operator const char*() const {
-        return m_const_str;
+        return const_str_;
     }
 
     string& operator=(string&& str) noexcept {
-        ecs_os_free(m_str);
-        m_str = str.m_str;
-        m_const_str = str.m_const_str;
-        m_length = str.m_length;
-        str.m_str = nullptr;
+        ecs_os_free(str_);
+        str_ = str.str_;
+        const_str_ = str.const_str_;
+        length_ = str.length_;
+        str.str_ = nullptr;
         return *this;
     }
 
@@ -57,19 +57,19 @@ struct string {
     string(const string& str) = delete;
 
     bool operator==(const flecs::string& str) const {
-        if (str.m_const_str == m_const_str) {
+        if (str.const_str_ == const_str_) {
             return true;
         }
 
-        if (!m_const_str || !str.m_const_str) {
+        if (!const_str_ || !str.const_str_) {
             return false;
         }
 
-        if (str.m_length != m_length) {
+        if (str.length_ != length_) {
             return false;
         }
 
-        return ecs_os_strcmp(str, m_const_str) == 0;
+        return ecs_os_strcmp(str, const_str_) == 0;
     }
 
     bool operator!=(const flecs::string& str) const {
@@ -77,15 +77,15 @@ struct string {
     }    
 
     bool operator==(const char *str) const {
-        if (m_const_str == str) {
+        if (const_str_ == str) {
             return true;
         }
 
-        if (!m_const_str || !str) {
+        if (!const_str_ || !str) {
             return false;
         }
 
-        return ecs_os_strcmp(str, m_const_str) == 0;
+        return ecs_os_strcmp(str, const_str_) == 0;
     }
 
     bool operator!=(const char *str) const {
@@ -93,11 +93,11 @@ struct string {
     }    
 
     const char* c_str() const {
-        return m_const_str;
+        return const_str_;
     }
 
     std::size_t length() const {
-        return static_cast<std::size_t>(m_length);
+        return static_cast<std::size_t>(length_);
     }
 
     template <size_t N>
@@ -110,14 +110,14 @@ struct string {
     }
 
     void clear() {
-        ecs_os_free(m_str);
-        m_str = nullptr;
-        m_const_str = nullptr;
+        ecs_os_free(str_);
+        str_ = nullptr;
+        const_str_ = nullptr;
     }
 
     bool contains(const char *substr) {
-        if (m_const_str) {
-            return strstr(m_const_str, substr) != nullptr;
+        if (const_str_) {
+            return strstr(const_str_, substr) != nullptr;
         } else {
             return false;
         }
@@ -130,13 +130,13 @@ struct string {
     // Making this constructor private forces the code to explicitly create a
     // string_view which emphasizes that the string won't be freed by the class.
     string(const char *str)
-        : m_str(nullptr)
-        , m_const_str(str ? str : "")
-        , m_length(str ? ecs_os_strlen(str) : 0) { }
+        : str_(nullptr)
+        , const_str_(str ? str : "")
+        , length_(str ? ecs_os_strlen(str) : 0) { }
 
-    char *m_str = nullptr;
-    const char *m_const_str;
-    ecs_size_t m_length;
+    char *str_ = nullptr;
+    const char *const_str_;
+    ecs_size_t length_;
 };
 
 // For consistency, the API returns a string_view where it could have returned
diff --git a/include/flecs/addons/cpp/utils/stringstream.hpp b/include/flecs/addons/cpp/utils/stringstream.hpp
index 6c22cc8c4..964d51698 100644
--- a/include/flecs/addons/cpp/utils/stringstream.hpp
+++ b/include/flecs/addons/cpp/utils/stringstream.hpp
@@ -7,22 +7,22 @@ namespace flecs {
 
 struct stringstream {
     explicit stringstream() 
-        : m_buf({}) { }
+        : buf_({}) { }
 
     ~stringstream() {
-        ecs_strbuf_reset(&m_buf);
+        ecs_strbuf_reset(&buf_);
     }
 
     stringstream(stringstream&& str) noexcept {
-        ecs_strbuf_reset(&m_buf);
-        m_buf = str.m_buf;
-        str.m_buf = {};
+        ecs_strbuf_reset(&buf_);
+        buf_ = str.buf_;
+        str.buf_ = {};
     }
 
     stringstream& operator=(stringstream&& str) noexcept {
-        ecs_strbuf_reset(&m_buf);
-        m_buf = str.m_buf;
-        str.m_buf = {};
+        ecs_strbuf_reset(&buf_);
+        buf_ = str.buf_;
+        str.buf_ = {};
         return *this;
     }
 
@@ -31,16 +31,16 @@ struct stringstream {
     stringstream(const stringstream& str) = delete;    
 
     stringstream& operator<<(const char* str) {
-        ecs_strbuf_appendstr(&m_buf, str);
+        ecs_strbuf_appendstr(&buf_, str);
         return *this;
     }
 
     flecs::string str() {
-        return flecs::string(ecs_strbuf_get(&m_buf));
+        return flecs::string(ecs_strbuf_get(&buf_));
     }
 
 private:
-    ecs_strbuf_t m_buf;
+    ecs_strbuf_t buf_;
 };
 
 }
diff --git a/include/flecs/addons/cpp/world.hpp b/include/flecs/addons/cpp/world.hpp
index d5e2dd576..b21c44421 100644
--- a/include/flecs/addons/cpp/world.hpp
+++ b/include/flecs/addons/cpp/world.hpp
@@ -13,7 +13,8 @@ namespace flecs
 // set(T&&), T = constructible
 template <typename T, if_t< is_flecs_constructible<T>::value > = 0>
 inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t id) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
     if (!ecs_is_deferred(world)) {
         T& dst = *static_cast<T*>(ecs_ensure_id(world, entity, id));
@@ -29,7 +30,8 @@ inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t i
 // set(const T&), T = constructible
 template <typename T, if_t< is_flecs_constructible<T>::value > = 0>
 inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::id_t id) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
     if (!ecs_is_deferred(world)) {
         T& dst = *static_cast<T*>(ecs_ensure_id(world, entity, id));
@@ -45,7 +47,8 @@ inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::i
 // set(T&&), T = not constructible
 template <typename T, if_not_t< is_flecs_constructible<T>::value > = 0>
 inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t id) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
     if (!ecs_is_deferred(world)) {
         T& dst = *static_cast<remove_reference_t<T>*>(ecs_ensure_id(world, entity, id));
@@ -61,7 +64,8 @@ inline void set(world_t *world, flecs::entity_t entity, T&& value, flecs::id_t i
 // set(const T&), T = not constructible
 template <typename T, if_not_t< is_flecs_constructible<T>::value > = 0>
 inline void set(world_t *world, flecs::entity_t entity, const T& value, flecs::id_t id) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
 
     if (!ecs_is_deferred(world)) {
         T& dst = *static_cast<remove_reference_t<T>*>(ecs_ensure_id(world, entity, id));
@@ -79,8 +83,9 @@ template <typename T, typename ... Args, if_t<
     std::is_constructible<actual_type_t<T>, Args...>::value ||
     std::is_default_constructible<actual_type_t<T>>::value > = 0>
 inline void emplace(world_t *world, flecs::entity_t entity, flecs::id_t id, Args&&... args) {
-    ecs_assert(_::cpp_type<T>::size() != 0, ECS_INVALID_PARAMETER, NULL);
-    T& dst = *static_cast<T*>(ecs_emplace_id(world, entity, id));
+    ecs_assert(_::type<T>::size() != 0, ECS_INVALID_PARAMETER,
+            "operation invalid for empty type");
+    T& dst = *static_cast<T*>(ecs_emplace_id(world, entity, id, nullptr));
 
     FLECS_PLACEMENT_NEW(&dst, T{FLECS_FWD(args)...});
 
@@ -90,14 +95,14 @@ inline void emplace(world_t *world, flecs::entity_t entity, flecs::id_t id, Args
 // set(T&&)
 template <typename T, typename A>
 inline void set(world_t *world, entity_t entity, A&& value) {
-    id_t id = _::cpp_type<T>::id(world);
+    id_t id = _::type<T>::id(world);
     flecs::set(world, entity, FLECS_FWD(value), id);
 }
 
 // set(const T&)
 template <typename T, typename A>
 inline void set(world_t *world, entity_t entity, const A& value) {
-    id_t id = _::cpp_type<T>::id(world);
+    id_t id = _::type<T>::id(world);
     flecs::set(world, entity, value, id);
 }
 
@@ -133,91 +138,99 @@ struct world {
     /** Create world.
      */
     explicit world()
-        : m_world( ecs_init() )
-        , m_owned( true ) { init_builtin_components(); }
+        : world_( ecs_init() ) { 
+            init_builtin_components(); 
+        }
 
     /** Create world with command line arguments.
      * Currently command line arguments are not interpreted, but they may be
      * used in the future to configure Flecs parameters.
      */
     explicit world(int argc, char *argv[])
-        : m_world( ecs_init_w_args(argc, argv) )
-        , m_owned( true ) { init_builtin_components(); }
+        : world_( ecs_init_w_args(argc, argv) ) { 
+            init_builtin_components(); 
+        }
 
     /** Create world from C world.
      */
     explicit world(world_t *w)
-        : m_world( w )
-        , m_owned( false ) { }
+        : world_( w ) { 
+            if (w) {
+                flecs_poly_claim(w);
+            }
+        }
 
     /** Not allowed to copy a world. May only take a reference.
      */
-    world(const world& obj) = delete;
-
-    world(world&& obj) noexcept {
-        m_world = obj.m_world;
-        m_owned = obj.m_owned;
-        obj.m_world = nullptr;
-        obj.m_owned = false;
+    world(const world& obj) {
+        this->world_ = obj.world_;
+        flecs_poly_claim(this->world_);
     }
 
-    /* Implicit conversion to world_t* */
-    operator world_t*() const { return m_world; }
+    world& operator=(const world& obj) noexcept {
+        this->world_ = obj.world_;
+        flecs_poly_claim(this->world_);
+        return *this;
+    }
 
-    /** Not allowed to copy a world. May only take a reference.
-     */
-    world& operator=(const world& obj) = delete;
+    world(world&& obj) noexcept {
+        world_ = obj.world_;
+        obj.world_ = nullptr;
+    }
 
     world& operator=(world&& obj) noexcept {
-        this->~world();
-
-        m_world = obj.m_world;
-        m_owned = obj.m_owned;
-        obj.m_world = nullptr;
-        obj.m_owned = false;
+        world_ = obj.world_;
+        obj.world_ = nullptr;
         return *this;
     }
 
     ~world() {
-        if (m_owned && ecs_stage_is_async(m_world)) {
-            ecs_async_stage_free(m_world);
-        } else
-        if (m_owned && m_world) {
-            ecs_fini(m_world);
+        if (world_) {
+            if (!flecs_poly_release(world_)) {
+                if (ecs_stage_get_id(world_) == -1) {
+                    ecs_stage_free(world_);
+                } else {
+                    ecs_fini(world_);
+                }
+            }
         }
     }
 
+    /* Implicit conversion to world_t* */
+    operator world_t*() const { return world_; }
+
     /** Deletes and recreates the world. */
     void reset() {
-        // Can only reset the world if we own the world object.
-        ecs_assert(this->m_owned, ECS_INVALID_OPERATION, NULL);
-        ecs_fini(m_world);
-        m_world = ecs_init();
+        /* Make sure there's only one reference to the world */
+        ecs_assert(flecs_poly_refcount(world_) == 1, ECS_INVALID_OPERATION,
+            "reset would invalidate other handles");
+        ecs_fini(world_);
+        world_ = ecs_init();
     }
 
     /** Obtain pointer to C world object.
      */
     world_t* c_ptr() const {
-        return m_world;
+        return world_;
     }
 
     /** Signal application should quit.
      * After calling this operation, the next call to progress() returns false.
      */
     void quit() const {
-        ecs_quit(m_world);
+        ecs_quit(world_);
     }
 
     /** Register action to be executed when world is destroyed.
      */
     void atfini(ecs_fini_action_t action, void *ctx = nullptr) const {
-        ecs_atfini(m_world, action, ctx);
+        ecs_atfini(world_, action, ctx);
     }
 
     /** Test if quit() has been called.
      */
     bool should_quit() const {
-        return ecs_should_quit(m_world);
+        return ecs_should_quit(world_);
     }
 
     /** Begin frame.
@@ -239,7 +252,7 @@ struct world {
      * @return The provided delta_time, or measured time if 0 was provided.
      */
     ecs_ftime_t frame_begin(float delta_time = 0) const {
-        return ecs_frame_begin(m_world, delta_time);
+        return ecs_frame_begin(world_, delta_time);
     }
 
     /** End frame.
@@ -249,7 +262,7 @@ struct world {
      * This function should only be ran from the main thread.
      */
     void frame_end() const {
-        ecs_frame_end(m_world);
+        ecs_frame_end(world_);
     }
 
     /** Begin readonly mode.
@@ -259,7 +272,7 @@ struct world {
      * @return Whether world is currently staged.
      */
     bool readonly_begin(bool multi_threaded = false) const {
-        return ecs_readonly_begin(m_world, multi_threaded);
+        return ecs_readonly_begin(world_, multi_threaded);
     }
 
     /** End readonly mode.
@@ -267,7 +280,7 @@ struct world {
      * @see ecs_readonly_end
      */
     void readonly_end() const {
-        ecs_readonly_end(m_world);
+        ecs_readonly_end(world_);
     }
 
     /** Defer operations until end of frame.
@@ -277,7 +290,7 @@ struct world {
      * This operation is thread safe.
      */
     bool defer_begin() const {
-        return ecs_defer_begin(m_world);
+        return ecs_defer_begin(world_);
     }
 
     /** End block of operations to defer.
@@ -286,13 +299,13 @@ struct world {
      * This operation is thread safe.
      */
     bool defer_end() const {
-        return ecs_defer_end(m_world);
+        return ecs_defer_end(world_);
     }
 
     /** Test whether deferring is enabled.
      */
     bool is_deferred() const {
-        return ecs_is_deferred(m_world);
+        return ecs_is_deferred(world_);
     }
 
     /** Configure world to have N stages.
@@ -308,7 +321,7 @@ struct world {
      * @param stages The number of stages.
      */
     void set_stage_count(int32_t stages) const {
-        ecs_set_stage_count(m_world, stages);
+        ecs_set_stage_count(world_, stages);
     }
 
     /** Get number of configured stages.
@@ -317,7 +330,7 @@ struct world {
      * @return The number of stages used for threading.
      */
     int32_t get_stage_count() const {
-        return ecs_get_stage_count(m_world);
+        return ecs_get_stage_count(world_);
     }
 
     /** Get current stage id.
@@ -327,7 +340,7 @@ struct world {
      * @return The stage id.
      */
     int32_t get_stage_id() const {
-        return ecs_get_stage_id(m_world);
+        return ecs_stage_get_id(world_);
     }
 
     /** Test if is a stage.
@@ -338,30 +351,11 @@ struct world {
      */
     bool is_stage() const {
         ecs_assert(
-            ecs_poly_is(m_world, ecs_world_t) ||
-            ecs_poly_is(m_world, ecs_stage_t),
-                ECS_INVALID_PARAMETER, NULL);
-        return ecs_poly_is(m_world, ecs_stage_t);
-    }
-
-    /** Enable/disable auto-merging for world or stage.
-     * When auto-merging is enabled, staged data will automatically be merged
-     * with the world when staging ends. This happens at the end of progress(),
-     * at a sync point or when readonly_end() is called.
-     *
-     * Applications can exercise more control over when data from a stage is
-     * merged by disabling auto-merging. This requires an application to
-     * explicitly call merge() on the stage.
-     *
-     * When this function is invoked on the world, it sets all current stages to
-     * the provided value and sets the default for new stages. When this
-     * function is invoked on a stage, auto-merging is only set for that specific
-     * stage.
-     *
-     * @param automerge Whether to enable or disable auto-merging.
-     */
-    void set_automerge(bool automerge) const {
-        ecs_set_automerge(m_world, automerge);
+            flecs_poly_is(world_, ecs_world_t) ||
+            flecs_poly_is(world_, ecs_stage_t), 
+                ECS_INVALID_PARAMETER, 
+                "flecs::world instance contains invalid reference to world or stage");
+        return flecs_poly_is(world_, ecs_stage_t);
     }
 
     /** Merge world or stage.
@@ -373,7 +367,7 @@ struct world {
      * This operation may be called on an already merged stage or world.
      */
     void merge() const {
-        ecs_merge(m_world);
+        ecs_merge(world_);
     }
 
     /** Get stage-specific world pointer.
@@ -391,7 +385,7 @@ struct world {
      * @return A thread-specific pointer to the world.
      */
     flecs::world get_stage(int32_t stage_id) const {
-        return flecs::world(ecs_get_stage(m_world, stage_id));
+        return flecs::world(ecs_get_stage(world_, stage_id));
     }
 
     /** Create asynchronous stage.
@@ -407,14 +401,12 @@ struct world {
      * The application must ensure that no commands are added to the stage while the
      * stage is being merged.
      *
-     * An asynchronous stage must be cleaned up by ecs_async_stage_free.
-     *
      * @return The stage.
      */
     flecs::world async_stage() const {
-        auto result = flecs::world(ecs_async_stage_new(m_world));
-        result.m_owned = true;
-        return result;
+        ecs_world_t *as = ecs_stage_new(world_);
+        flecs_poly_release(as); // world object will claim
+        return flecs::world(as);
     }
 
     /** Get actual world.
@@ -426,7 +418,7 @@ struct world {
     flecs::world get_world() const {
         /* Safe cast, mutability is checked */
         return flecs::world(
-            m_world ? const_cast<flecs::world_t*>(ecs_get_world(m_world)) : nullptr);
+            world_ ? const_cast<flecs::world_t*>(ecs_get_world(world_)) : nullptr);
     }
 
     /** Test whether the current world object is readonly.
@@ -436,7 +428,7 @@ struct world {
      * @return True if the world or stage is readonly.
      */
     bool is_readonly() const {
-        return ecs_stage_is_readonly(m_world);
+        return ecs_stage_is_readonly(world_);
     }
 
     /** Set world context.
@@ -446,7 +438,7 @@ struct world {
      * @param ctx The world context.
      */
     void set_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
-        ecs_set_ctx(m_world, ctx, ctx_free);
+        ecs_set_ctx(world_, ctx, ctx_free);
     }
 
     /** Get world context.
@@ -454,7 +446,7 @@ struct world {
      * @return The configured world context.
      */
     void* get_ctx() const {
-        return ecs_get_ctx(m_world);
+        return ecs_get_ctx(world_);
     }
 
     /** Set world binding context.
@@ -464,7 +456,7 @@ struct world {
      * @param ctx The world context.
      */
     void set_binding_ctx(void* ctx, ecs_ctx_free_t ctx_free = nullptr) const {
-        ecs_set_binding_ctx(m_world, ctx, ctx_free);
+        ecs_set_binding_ctx(world_, ctx, ctx_free);
     }
 
     /** Get world binding context.
@@ -472,7 +464,7 @@ struct world {
      * @return The configured world context.
      */
     void* get_binding_ctx() const {
-        return ecs_get_binding_ctx(m_world);
+        return ecs_get_binding_ctx(world_);
     }
 
     /** Preallocate memory for number of entities.
@@ -481,7 +473,7 @@ struct world {
      * @param entity_count Number of entities to preallocate memory for.
      */
     void dim(int32_t entity_count) const {
-        ecs_dim(m_world, entity_count);
+        ecs_dim(world_, entity_count);
     }
 
     /** Set entity range.
@@ -491,7 +483,7 @@ struct world {
      * @param max Maximum entity id issued.
      */
     void set_entity_range(entity_t min, entity_t max) const {
-        ecs_set_entity_range(m_world, min, max);
+        ecs_set_entity_range(world_, min, max);
     }
 
     /** Enforce that operations cannot modify entities outside of range.
@@ -503,7 +495,7 @@ struct world {
      * @param enabled True if range check should be enabled, false if not.
      */
     void enable_range_check(bool enabled) const {
-        ecs_enable_range_check(m_world, enabled);
+        ecs_enable_range_check(world_, enabled);
     }
 
     /** Set current scope.
@@ -531,29 +523,29 @@ struct world {
      *  @see ecs_set_lookup_path
      */
     flecs::entity_t* set_lookup_path(const flecs::entity_t *search_path) const {
-        return ecs_set_lookup_path(m_world, search_path);
+        return ecs_set_lookup_path(world_, search_path);
     }
 
     /** Lookup entity by name.
      *
      * @param name Entity name.
-     * @param search_path When false, only the current scope is searched.
+     * @param recursive When false, only the current scope is searched.
      * @result The entity if found, or 0 if not found.
      */
-    flecs::entity lookup(const char *name, bool search_path = true) const;
+    flecs::entity lookup(const char *name, const char *sep = "::", const char *root_sep = "::", bool recursive = true) const;
 
     /** Set singleton component.
      */
     template <typename T, if_t< !is_callable<T>::value > = 0>
     void set(const T& value) const {
-        flecs::set<T>(m_world, _::cpp_type<T>::id(m_world), value);
+        flecs::set<T>(world_, _::type<T>::id(world_), value);
     }
 
     /** Set singleton component.
      */
     template <typename T, if_t< !is_callable<T>::value > = 0>
     void set(T&& value) const {
-        flecs::set<T>(m_world, _::cpp_type<T>::id(m_world),
+        flecs::set<T>(world_, _::type<T>::id(world_),
             FLECS_FWD(value));
     }
 
@@ -562,7 +554,7 @@ struct world {
     template <typename First, typename Second, typename P = flecs::pair<First, Second>,
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     void set(const A& value) const {
-        flecs::set<P>(m_world, _::cpp_type<First>::id(m_world), value);
+        flecs::set<P>(world_, _::type<First>::id(world_), value);
     }
 
     /** Set singleton pair.
@@ -570,7 +562,7 @@ struct world {
     template <typename First, typename Second, typename P = flecs::pair<First, Second>,
         typename A = actual_type_t<P>, if_not_t< flecs::is_pair<First>::value> = 0>
     void set(A&& value) const {
-        flecs::set<P>(m_world, _::cpp_type<First>::id(m_world), FLECS_FWD(value));
+        flecs::set<P>(world_, _::type<First>::id(world_), FLECS_FWD(value));
     }
 
     /** Set singleton pair.
@@ -590,9 +582,8 @@ struct world {
 
     template <typename T, typename ... Args>
     void emplace(Args&&... args) const {
-        flecs::id_t component_id = _::cpp_type<T>::id(m_world);
-        flecs::emplace<T>(m_world, component_id, component_id,
-            FLECS_FWD(args)...);
+        flecs::id_t component_id = _::type<T>::id(world_);
+        flecs::emplace<T>(world_, component_id, component_id, FLECS_FWD(args)...);
     }
 
     /** Ensure singleton component.
@@ -808,7 +799,7 @@ struct world {
      * @param component_id The component id.
      */
     int count(flecs::id_t component_id) const {
-        return ecs_count_id(m_world, component_id);
+        return ecs_count_id(world_, component_id);
     }
 
     /** Count entities matching a pair.
@@ -817,7 +808,7 @@ struct world {
      * @param second The second element of the pair.
      */
     int count(flecs::entity_t first, flecs::entity_t second) const {
-        return ecs_count_id(m_world, ecs_pair(first, second));
+        return ecs_count_id(world_, ecs_pair(first, second));
     }
 
     /** Count entities matching a component.
@@ -826,7 +817,7 @@ struct world {
      */
     template <typename T>
     int count() const {
-        return count(_::cpp_type<T>::id(m_world));
+        return count(_::type<T>::id(world_));
     }
 
     /** Count entities matching a pair.
@@ -836,7 +827,7 @@ struct world {
      */
     template <typename First>
     int count(flecs::entity_t second) const {
-        return count(_::cpp_type<First>::id(m_world), second);
+        return count(_::type<First>::id(world_), second);
     }
 
     /** Count entities matching a pair.
@@ -847,17 +838,17 @@ struct world {
     template <typename First, typename Second>
     int count() const {
         return count(
-            _::cpp_type<First>::id(m_world),
-            _::cpp_type<Second>::id(m_world));
+            _::type<First>::id(world_),
+            _::type<Second>::id(world_));
     }
 
     /** All entities created in function are created with id.
      */
     template <typename Func>
     void with(id_t with_id, const Func& func) const {
-        ecs_id_t prev = ecs_set_with(m_world, with_id);
+        ecs_id_t prev = ecs_set_with(world_, with_id);
         func();
-        ecs_set_with(m_world, prev);
+        ecs_set_with(world_, prev);
     }
 
     /** All entities created in function are created with type.
@@ -893,16 +884,16 @@ struct world {
      */
     template <typename Func>
     void scope(id_t parent, const Func& func) const {
-        ecs_entity_t prev = ecs_set_scope(m_world, parent);
+        ecs_entity_t prev = ecs_set_scope(world_, parent);
         func();
-        ecs_set_scope(m_world, prev);
+        ecs_set_scope(world_, prev);
     }
 
     /** Same as scope(parent, func), but with T as parent.
      */
     template <typename T, typename Func>
     void scope(const Func& func) const {
-        flecs::id_t parent = _::cpp_type<T>::id(m_world);
+        flecs::id_t parent = _::type<T>::id(world_);
         scope(parent, func);
     }
 
@@ -918,7 +909,7 @@ struct world {
 
     /** Delete all entities with specified id. */
     void delete_with(id_t the_id) const {
-        ecs_delete_with(m_world, the_id);
+        ecs_delete_with(world_, the_id);
     }
 
     /** Delete all entities with specified pair. */
@@ -929,24 +920,24 @@ struct world {
     /** Delete all entities with specified component. */
     template <typename T>
     void delete_with() const {
-        delete_with(_::cpp_type<T>::id(m_world));
+        delete_with(_::type<T>::id(world_));
     }
 
     /** Delete all entities with specified pair. */
     template <typename First, typename Second>
     void delete_with() const {
-        delete_with(_::cpp_type<First>::id(m_world), _::cpp_type<Second>::id(m_world));
+        delete_with(_::type<First>::id(world_), _::type<Second>::id(world_));
     }
 
     /** Delete all entities with specified pair. */
     template <typename First>
     void delete_with(entity_t second) const {
-        delete_with(_::cpp_type<First>::id(m_world), second);
+        delete_with(_::type<First>::id(world_), second);
     }
 
     /** Remove all instances of specified id. */
     void remove_all(id_t the_id) const {
-        ecs_remove_all(m_world, the_id);
+        ecs_remove_all(world_, the_id);
     }
 
     /** Remove all instances of specified pair. */
@@ -957,19 +948,19 @@ struct world {
     /** Remove all instances of specified component. */
     template <typename T>
     void remove_all() const {
-        remove_all(_::cpp_type<T>::id(m_world));
+        remove_all(_::type<T>::id(world_));
     }
 
     /** Remove all instances of specified pair. */
     template <typename First, typename Second>
     void remove_all() const {
-        remove_all(_::cpp_type<First>::id(m_world), _::cpp_type<Second>::id(m_world));
+        remove_all(_::type<First>::id(world_), _::type<Second>::id(world_));
     }
 
     /** Remove all instances of specified pair. */
     template <typename First>
     void remove_all(entity_t second) const {
-        remove_all(_::cpp_type<First>::id(m_world), second);
+        remove_all(_::type<First>::id(world_), second);
     }
 
     /** Defer all operations called in function. If the world is already in
@@ -977,9 +968,9 @@ struct world {
      */
     template <typename Func>
     void defer(const Func& func) const {
-        ecs_defer_begin(m_world);
+        ecs_defer_begin(world_);
         func();
-        ecs_defer_end(m_world);
+        ecs_defer_end(world_);
     }
 
     /** Suspend deferring operations.
@@ -987,7 +978,7 @@ struct world {
      * @see ecs_defer_suspend
      */
     void defer_suspend() const {
-        ecs_defer_suspend(m_world);
+        ecs_defer_suspend(world_);
     }
 
     /** Resume deferring operations.
@@ -995,7 +986,7 @@ struct world {
      * @see ecs_defer_suspend
      */
     void defer_resume() const {
-        ecs_defer_resume(m_world);
+        ecs_defer_resume(world_);
     }
 
     /** Check if entity id exists in the world.
@@ -1003,7 +994,7 @@ struct world {
      * @see ecs_exists
      */
     bool exists(flecs::entity_t e) const {
-        return ecs_exists(m_world, e);
+        return ecs_exists(world_, e);
     }
 
     /** Check if entity id exists in the world.
@@ -1011,7 +1002,7 @@ struct world {
      * @see ecs_is_alive
      */
     bool is_alive(flecs::entity_t e) const {
-        return ecs_is_alive(m_world, e);
+        return ecs_is_alive(world_, e);
     }
 
     /** Check if entity id is valid.
@@ -1020,7 +1011,7 @@ struct world {
      * @see ecs_is_valid
      */
     bool is_valid(flecs::entity_t e) const {
-        return ecs_is_valid(m_world, e);
+        return ecs_is_valid(world_, e);
     }
 
     /** Get alive entity for id.
@@ -1034,14 +1025,14 @@ struct world {
 
     /* Run callback after completing frame */
     void run_post_frame(ecs_fini_action_t action, void *ctx) const {
-        ecs_run_post_frame(m_world, action, ctx);
+        ecs_run_post_frame(world_, action, ctx);
     }
 
     /** Get the world info.
      * @see ecs_get_world_info
      */
     const flecs::world_info_t* get_info() const{
-        return ecs_get_world_info(m_world);
+        return ecs_get_world_info(world_);
     }
 
     /** Get delta_time */
@@ -1054,7 +1045,6 @@ struct world {
 #   include "mixins/entity/mixin.inl"
 #   include "mixins/event/mixin.inl"
 #   include "mixins/term/mixin.inl"
-#   include "mixins/filter/mixin.inl"
 #   include "mixins/observer/mixin.inl"
 #   include "mixins/query/mixin.inl"
 #   include "mixins/enum/mixin.inl"
@@ -1065,20 +1055,14 @@ struct world {
 #   ifdef FLECS_PIPELINE
 #   include "mixins/pipeline/mixin.inl"
 #   endif
-#   ifdef FLECS_SNAPSHOT
-#   include "mixins/snapshot/mixin.inl"
-#   endif
 #   ifdef FLECS_SYSTEM
 #   include "mixins/system/mixin.inl"
 #   endif
 #   ifdef FLECS_TIMER
 #   include "mixins/timer/mixin.inl"
 #   endif
-#   ifdef FLECS_RULES
-#   include "mixins/rule/mixin.inl"
-#   endif
-#   ifdef FLECS_PLECS
-#   include "mixins/plecs/mixin.inl"
+#   ifdef FLECS_SCRIPT
+#   include "mixins/script/mixin.inl"
 #   endif
 #   ifdef FLECS_META
 #   include "mixins/meta/world.inl"
@@ -1099,8 +1083,7 @@ struct world {
 public:
     void init_builtin_components();
 
-    world_t *m_world;
-    bool m_owned;
+    world_t *world_;
 };
 
 /** Scoped world.
@@ -1109,24 +1092,22 @@ struct world {
 struct scoped_world : world {
     scoped_world(
         flecs::world_t *w,
-        flecs::entity_t s) : world(nullptr)
+        flecs::entity_t s) : world(w)
     {
-        m_prev_scope = ecs_set_scope(w, s);
-        m_world = w;
-        m_owned = false;
+        prev_scope_ = ecs_set_scope(w, s);
     }
 
     ~scoped_world() {
-        ecs_set_scope(m_world, m_prev_scope);
+        ecs_set_scope(world_, prev_scope_);
     }
 
     scoped_world(const scoped_world& obj) : world(nullptr) {
-        m_prev_scope = obj.m_prev_scope;
-        m_world = obj.m_world;
-        m_owned = obj.m_owned;
+        prev_scope_ = obj.prev_scope_;
+        world_ = obj.world_;
+        flecs_poly_claim(world_);
     }
 
-    flecs::entity_t m_prev_scope;
+    flecs::entity_t prev_scope_;
 };
 
 /** @} */
diff --git a/include/flecs/addons/expr.h b/include/flecs/addons/expr.h
deleted file mode 100644
index f966a4593..000000000
--- a/include/flecs/addons/expr.h
+++ /dev/null
@@ -1,379 +0,0 @@
-/**
- * @file addons/expr.h
- * @brief Flecs expression parser addon.
- *
- * Parse expression strings into component values. The notation is similar to
- * JSON but with a smaller footprint, native support for (large) integer types,
- * character types, enumerations, bitmasks and entity identifiers.
- *
- * Examples:
- *
- * Member names:
- *
- *     {x: 10, y: 20}
- *
- * No member names (uses member ordering):
- *
- *     {10, 20}
- *
- * Enum values:
- *
- *     {color: Red}
- *
- * Bitmask values:
- *
- *     {toppings: Lettuce|Tomato}
- *
- * Collections:
- *
- *     {points: [10, 20, 30]}
- *
- * Nested objects:
- *
- *     {start: {x: 10, y: 20}, stop: {x: 30, y: 40}}
- *
- */
-
-#ifdef FLECS_EXPR
-
-#ifndef FLECS_META
-#define FLECS_META
-#endif
-
-#ifndef FLECS_PARSER
-#define FLECS_PARSER
-#endif
-
-#ifndef FLECS_EXPR_H
-#define FLECS_EXPR_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @defgroup c_addons_expr Expr
- * @ingroup c_addons
- * Serialize/deserialize values to string.
- *
- * @{
- */
-
-/** Write an escaped character.
- * Write a character to an output string, insert escape character if necessary.
- *
- * @param out The string to write the character to.
- * @param in The input character.
- * @param delimiter The delimiter used (for example '"')
- * @return Pointer to the character after the last one written.
- */
-FLECS_API
-char* ecs_chresc(
-    char *out,
-    char in,
-    char delimiter);
-
-/** Parse an escaped character.
- * Parse a character with a potential escape sequence.
- *
- * @param in Pointer to character in input string.
- * @param out Output string.
- * @return Pointer to the character after the last one read.
- */
-const char* ecs_chrparse(
-    const char *in,
-    char *out);
-
-/** Write an escaped string.
- * Write an input string to an output string, escape characters where necessary.
- * To determine the size of the output string, call the operation with a NULL
- * argument for 'out', and use the returned size to allocate a string that is
- * large enough.
- *
- * @param out Pointer to output string (must be).
- * @param size Maximum number of characters written to output.
- * @param delimiter The delimiter used (for example '"').
- * @param in The input string.
- * @return The number of characters that (would) have been written.
- */
-FLECS_API
-ecs_size_t ecs_stresc(
-    char *out,
-    ecs_size_t size,
-    char delimiter,
-    const char *in);
-
-/** Return escaped string.
- * Return escaped version of input string. Same as ecs_stresc(), but returns an
- * allocated string of the right size.
- *
- * @param delimiter The delimiter used (for example '"').
- * @param in The input string.
- * @return Escaped string.
- */
-FLECS_API
-char* ecs_astresc(
-    char delimiter,
-    const char *in);
-
-/** Storage for parser variables. Variables make it possible to parameterize
- * expression strings, and are referenced with the $ operator (e.g. $var). */
-typedef struct ecs_expr_var_t {
-    char *name;
-    ecs_value_t value;
-    bool owned; /* Set to false if ecs_vars_t should not take ownership of var */
-} ecs_expr_var_t;
-
-typedef struct ecs_expr_var_scope_t {
-    ecs_hashmap_t var_index;
-    ecs_vec_t vars;
-    struct ecs_expr_var_scope_t *parent;
-} ecs_expr_var_scope_t;
-
-typedef struct ecs_vars_t {
-    ecs_world_t *world;
-    ecs_expr_var_scope_t root;
-    ecs_expr_var_scope_t *cur;
-} ecs_vars_t;
-
-/** Init variable storage */
-FLECS_API
-void ecs_vars_init(
-    ecs_world_t *world,
-    ecs_vars_t *vars);
-
-/** Cleanup variable storage */
-FLECS_API
-void ecs_vars_fini(
-    ecs_vars_t *vars);
-
-/** Push variable scope */
-FLECS_API
-void ecs_vars_push(
-    ecs_vars_t *vars);
-
-/** Pop variable scope */
-FLECS_API
-int ecs_vars_pop(
-    ecs_vars_t *vars);
-
-/** Declare variable in current scope */
-FLECS_API
-ecs_expr_var_t* ecs_vars_declare(
-    ecs_vars_t *vars,
-    const char *name,
-    ecs_entity_t type);
-
-/** Declare variable in current scope from value.
- * This operation takes ownership of the value. The value pointer must be
- * allocated with ecs_value_new().
- */
-FLECS_API
-ecs_expr_var_t* ecs_vars_declare_w_value(
-    ecs_vars_t *vars,
-    const char *name,
-    ecs_value_t *value);
-
-/** Lookup variable in scope and parent scopes */
-FLECS_API
-ecs_expr_var_t* ecs_vars_lookup(
-    const ecs_vars_t *vars,
-    const char *name);
-
-/** Used with ecs_parse_expr(). */
-typedef struct ecs_parse_expr_desc_t {
-    const char *name;
-    const char *expr;
-    ecs_entity_t (*lookup_action)(
-        const ecs_world_t*,
-        const char *value,
-        void *ctx);
-    void *lookup_ctx;
-    ecs_vars_t *vars;
-} ecs_parse_expr_desc_t;
-
-/** Parse expression into value.
- * This operation parses a flecs expression into the provided pointer. The
- * memory pointed to must be large enough to contain a value of the used type.
- *
- * If no type and pointer are provided for the value argument, the operation
- * will discover the type from the expression and allocate storage for the
- * value. The allocated value must be freed with ecs_value_free().
- *
- * @param world The world.
- * @param ptr The pointer to the expression to parse.
- * @param value The value containing type & pointer to write to.
- * @param desc Configuration parameters for deserializer.
- * @return Pointer to the character after the last one read, or NULL if failed.
- */
-FLECS_API
-const char* ecs_parse_expr(
-    ecs_world_t *world,
-    const char *ptr,
-    ecs_value_t *value,
-    const ecs_parse_expr_desc_t *desc);
-
-/** Serialize value into expression string.
- * This operation serializes a value of the provided type to a string. The
- * memory pointed to must be large enough to contain a value of the used type.
- *
- * @param world The world.
- * @param type The type of the value to serialize.
- * @param data The value to serialize.
- * @return String with expression, or NULL if failed.
- */
-FLECS_API
-char* ecs_ptr_to_expr(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *data);
-
-/** Serialize value into expression buffer.
- * Same as ecs_ptr_to_expr(), but serializes to an ecs_strbuf_t instance.
- *
- * @param world The world.
- * @param type The type of the value to serialize.
- * @param data The value to serialize.
- * @param buf The strbuf to append the string to.
- * @return Zero if success, non-zero if failed.
- */
-FLECS_API
-int ecs_ptr_to_expr_buf(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *data,
-    ecs_strbuf_t *buf);
-
-/** Similar as ecs_ptr_to_expr(), but serializes values to string.
- * Whereas the output of ecs_ptr_to_expr() is a valid expression, the output of
- * ecs_ptr_to_str() is a string representation of the value. In most cases the
- * output of the two operations is the same, but there are some differences:
- * - Strings are not quoted
- *
- * @param world The world.
- * @param type The type of the value to serialize.
- * @param data The value to serialize.
- * @return String with result, or NULL if failed.
- */
-FLECS_API
-char* ecs_ptr_to_str(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *data);
-
-/** Serialize value into string buffer.
- * Same as ecs_ptr_to_str(), but serializes to an ecs_strbuf_t instance.
- *
- * @param world The world.
- * @param type The type of the value to serialize.
- * @param data The value to serialize.
- * @param buf The strbuf to append the string to.
- * @return Zero if success, non-zero if failed.
- */
-FLECS_API
-int ecs_ptr_to_str_buf(
-    const ecs_world_t *world,
-    ecs_entity_t type,
-    const void *data,
-    ecs_strbuf_t *buf);
-
-/** Serialize primitive value into string buffer.
- * Serializes a primitive value to an ecs_strbuf_t instance. This operation can
- * be reused by other serializers to avoid having to write boilerplate code that
- * serializes primitive values to a string.
- *
- * @param world The world.
- * @param kind The kind of primitive value.
- * @param data The value to serialize
- * @param buf The strbuf to append the string to.
- * @return Zero if success, non-zero if failed.
- */
-FLECS_API
-int ecs_primitive_to_expr_buf(
-    const ecs_world_t *world,
-    ecs_primitive_kind_t kind,
-    const void *data,
-    ecs_strbuf_t *buf);
-
-/** Parse expression token.
- * Expression tokens can contain more characters (such as '|') than tokens
- * parsed by the query (term) parser.
- *
- * @param name The name of the expression (used for debug logs).
- * @param expr The full expression (used for debug logs).
- * @param ptr The pointer to the expression to parse.
- * @param token The buffer to write to (must have size ECS_MAX_TOKEN_SIZE)
- * @return Pointer to the character after the last one read, or NULL if failed.
- */
-FLECS_API
-const char *ecs_parse_expr_token(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token);
-
-/** Evaluate interpolated expressions in string.
- * This operation evaluates expressions in a string, and replaces them with
- * their evaluated result. Supported expression formats are:
- *  - $variable_name
- *  - {expression}
- *
- * The $, { and } characters can be escaped with a backslash (\).
- *
- * @param world The world.
- * @param str The string to evaluate.
- * @param vars The variables to use for evaluation.
- */
-FLECS_API
-char* ecs_interpolate_string(
-    ecs_world_t *world,
-    const char *str,
-    const ecs_vars_t *vars);
-
-/** Convert iterator to vars
- * This operation converts an iterator to a variable array. This allows for
- * using iterator results in expressions. The operation only converts a
- * single result at a time, and does not progress the iterator.
- *
- * Iterator fields with data will be made available as variables with as name
- * the field index (e.g. "$1"). The operation does not check if reflection data
- * is registered for a field type. If no reflection data is registered for the
- * type, using the field variable in expressions will fail.
- *
- * Field variables will only contain single elements, even if the iterator
- * returns component arrays. The offset parameter can be used to specify which
- * element in the component arrays to return. The offset parameter must be
- * smaller than it->count.
- *
- * The operation will create a variable for query variables that contain a
- * single entity.
- *
- * The operation will attempt to use existing variables. If a variable does not
- * yet exist, the operation will create it. If an existing variable exists with
- * a mismatching type, the operation will fail.
- *
- * Accessing variables after progressing the iterator or after the iterator is
- * destroyed will result in undefined behavior.
- *
- * If vars contains a variable that is not present in the iterator, the variable
- * will not be modified.
- *
- * @param it The iterator to convert to variables.
- * @param vars The variables to write to.
- * @param offset The offset to the current element.
- */
-FLECS_API
-void ecs_iter_to_vars(
-    const ecs_iter_t *it,
-    ecs_vars_t *vars,
-    int offset);
-
-/** @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-#endif
diff --git a/include/flecs/addons/flecs_c.h b/include/flecs/addons/flecs_c.h
index 0a23b46c2..4ce3740f0 100644
--- a/include/flecs/addons/flecs_c.h
+++ b/include/flecs/addons/flecs_c.h
@@ -44,7 +44,7 @@
         desc.add_expr = #__VA_ARGS__; \
         id_ = ecs_entity_init(world, &desc); \
         ecs_id(id_) = id_; \
-        ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, NULL); \
+        ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, "failed to create entity %s", #id_); \
     } \
     (void)id_; \
     (void)ecs_id(id_)
@@ -132,7 +132,7 @@
         desc.type.alignment = ECS_ALIGNOF(id_); \
         ecs_id(id_) = ecs_component_init(world, &desc);\
     }\
-    ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, NULL)
+    ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, "failed to create component %s", #id_)
 
 /** Declare & define a component.
  *
@@ -166,10 +166,10 @@
         edesc.name = #id_; \
         desc.entity = ecs_entity_init(world, &edesc); \
         desc.callback = id_;\
-        desc.filter.expr = #__VA_ARGS__;\
+        desc.query.expr = #__VA_ARGS__;\
         desc.events[0] = kind;\
         ecs_id(id_) = ecs_observer_init(world, &desc);\
-        ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, NULL);\
+        ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, "failed to create observer %s", #id_);\
     }
 
 /** Declare & define an observer.
@@ -187,6 +187,41 @@
     (void)ecs_id(id);\
     (void)id
 
+/* Forward declare a query. */
+#define ECS_QUERY_DECLARE(name)         ecs_query_t* name
+
+/** Define a forward declared observer.
+ *
+ * Example:
+ *
+ * @code
+ * ECS_QUERY_DEFINE(world, AddPosition, Position);
+ * @endcode
+ */
+#define ECS_QUERY_DEFINE(world, name_, ...)\
+    {\
+        ecs_query_desc_t desc = {0};\
+        ecs_entity_desc_t edesc = {0}; \
+        edesc.name = #name_; \
+        desc.entity = ecs_entity_init(world, &edesc); \
+        desc.expr = #__VA_ARGS__;\
+        name_ = ecs_query_init(world, &desc);\
+        ecs_assert(name_ != NULL, ECS_INVALID_PARAMETER, "failed to create query %s", #name_);\
+    }
+
+/** Declare & define an observer.
+ *
+ * Example:
+ *
+ * @code
+ * ECS_OBSERVER(world, AddPosition, EcsOnAdd, Position);
+ * @endcode
+ */
+#define ECS_QUERY(world, name, ...)\
+    ecs_query_t* name = NULL; \
+    ECS_QUERY_DEFINE(world, name, __VA_ARGS__);\
+    (void)name
+
 /** Shorthand for creating an entity with ecs_entity_init().
  *
  * Example:
@@ -233,28 +268,12 @@
         .type.alignment = ECS_ALIGNOF(T) \
     })
 
-/** Shorthand for creating a filter with ecs_filter_init().
+/** Shorthand for creating a query with ecs_query_cache_init.
  *
  * Example:
- *
- * @code
- * ecs_filter(world, {
- *   .terms = {{ ecs_id(Position) }}
- * });
- * @endcode
- */
-#define ecs_filter(world, ...)\
-    ecs_filter_init(world, &(ecs_filter_desc_t) __VA_ARGS__ )
-
-/** Shorthand for creating a query with ecs_query_init().
- *
- * Example:
- *
- * @code
- * ecs_query(world, {
- *   .filter.terms = {{ ecs_id(Position) }}
- * });
- * @endcode
+ *   ecs_query(world, {
+ *     .terms = {{ ecs_id(Position) }}
+ *   });
  */
 #define ecs_query(world, ...)\
     ecs_query_init(world, &(ecs_query_desc_t) __VA_ARGS__ )
@@ -265,7 +284,7 @@
  *
  * @code
  * ecs_observer(world, {
- *   .filter.terms = {{ ecs_id(Position) }},
+ *   .terms = {{ ecs_id(Position) }},
  *   .events = { EcsOnAdd },
  *   .callback = AddPosition
  * });
@@ -293,7 +312,7 @@
  * @{
  */
 
-#define ecs_new(world, T) ecs_new_w_id(world, ecs_id(T))
+#define ecs_new_w(world, T) ecs_new_w_id(world, ecs_id(T))
 
 #define ecs_new_w_pair(world, first, second)\
     ecs_new_w_id(world, ecs_pair(first, second))
@@ -301,20 +320,6 @@
 #define ecs_bulk_new(world, component, count)\
     ecs_bulk_new_w_id(world, ecs_id(component), count)
 
-#define ecs_new_entity(world, n)\
-    ecs_entity_init(world, &(ecs_entity_desc_t){\
-        .name = n,\
-    })
-
-#define ecs_new_prefab(world, n)\
-    ecs_entity_init(world, &(ecs_entity_desc_t){\
-        .name = n,\
-        .add = {EcsPrefab}\
-    })
-
-#define ecs_delete_children(world, parent)\
-    ecs_delete_with(world, ecs_pair(EcsChildOf, parent))
-
 /** @} */
 
 /**
@@ -349,6 +354,10 @@
  * @{
  */
 
+/* insert */
+#define ecs_insert(world, ...)\
+    ecs_entity(world, { .set = ecs_values(__VA_ARGS__)})
+
 /* set */
 
 #define ecs_set_ptr(world, entity, component, ptr)\
@@ -367,19 +376,17 @@
         ecs_pair(first, ecs_id(Second)),\
         sizeof(Second), &(Second)__VA_ARGS__)
 
-#define ecs_set_pair_object ecs_set_pair_second
-
 #define ecs_set_override(world, entity, T, ...)\
     ecs_add_id(world, entity, ECS_OVERRIDE | ecs_id(T));\
     ecs_set(world, entity, T, __VA_ARGS__)
 
 /* emplace */
 
-#define ecs_emplace(world, entity, T)\
-    (ECS_CAST(T*, ecs_emplace_id(world, entity, ecs_id(T))))
+#define ecs_emplace(world, entity, T, is_new)\
+    (ECS_CAST(T*, ecs_emplace_id(world, entity, ecs_id(T), is_new)))
 
-#define ecs_emplace_pair(world, entity, First, second)\
-    (ECS_CAST(First*, ecs_emplace_id(world, entity, ecs_pair_t(First, second))))
+#define ecs_emplace_pair(world, entity, First, second, is_new)\
+    (ECS_CAST(First*, ecs_emplace_id(world, entity, ecs_pair_t(First, second), is_new)))
 
 /* get */
 
@@ -394,8 +401,6 @@
     (ECS_CAST(const Second*, ecs_get_id(world, subject,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_get_pair_object ecs_get_pair_second
-
 /* get_mut */
 
 #define ecs_get_mut(world, entity, T)\
@@ -409,8 +414,6 @@
     (ECS_CAST(Second*, ecs_get_mut_id(world, subject,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_get_mut_pair_object ecs_get_mut_pair_second
-
 #define ecs_get_mut(world, entity, T)\
     (ECS_CAST(T*, ecs_get_mut_id(world, entity, ecs_id(T))))
 
@@ -427,8 +430,6 @@
     (ECS_CAST(Second*, ecs_ensure_id(world, subject,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_ensure_pair_object ecs_ensure_pair_second
-
 #define ecs_ensure(world, entity, T)\
     (ECS_CAST(T*, ecs_ensure_id(world, entity, ecs_id(T))))
 
@@ -440,8 +441,6 @@
     (ECS_CAST(Second*, ecs_ensure_id(world, subject,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_ensure_pair_object ecs_ensure_pair_second
-
 /* modified */
 
 #define ecs_modified(world, entity, component)\
@@ -477,8 +476,6 @@
     (ECS_CAST(Second*, ecs_record_ensure_id(world, record,\
         ecs_pair(first, ecs_id(Second)))))
 
-#define ecs_record_ensure_pair_object ecs_record_ensure_pair_second
-
 #define ecs_ref_init(world, entity, T)\
     ecs_ref_init_id(world, entity, ecs_id(T))
 
@@ -552,7 +549,7 @@
 #define ecs_enable_component(world, entity, T, enable)\
     ecs_enable_id(world, entity, ecs_id(T), enable)
 
-#define ecs_is_enabled_component(world, entity, T)\
+#define ecs_is_enabled(world, entity, T)\
     ecs_is_enabled_id(world, entity, ecs_id(T))
 
 #define ecs_enable_pair(world, entity, First, second, enable)\
@@ -571,10 +568,6 @@
 #define ecs_lookup_path(world, parent, path)\
     ecs_lookup_path_w_sep(world, parent, path, ".", NULL, true)
 
-/* Deprecated: use ecs_lookup instead */
-#define ecs_lookup_fullpath(world, path)\
-    ecs_lookup(world, path)
-
 #define ecs_get_path(world, parent, child)\
     ecs_get_path_w_sep(world, parent, child, ".", NULL)
 
@@ -587,9 +580,6 @@
 #define ecs_new_from_path(world, parent, path)\
     ecs_new_from_path_w_sep(world, parent, path, ".", NULL)
 
-#define ecs_new_from_fullpath(world, path)\
-    ecs_new_from_path_w_sep(world, 0, path, ".", NULL)
-
 #define ecs_add_path(world, entity, parent, path)\
     ecs_add_path_w_sep(world, entity, parent, path, ".", NULL)
 
@@ -717,9 +707,27 @@
  * @{
  */
 
-#define ecs_value(T, ptr) ((ecs_value_t){ecs_id(T), ptr})
+/** Convenience macro for creating compound literal id array */
+#define ecs_ids(...) (ecs_id_t[]){ __VA_ARGS__, 0 }
+
+/** Convenience macro for creating compound literal values array */
+#define ecs_values(...) (ecs_value_t[]){ __VA_ARGS__, {0, 0}}
+
+/** Convenience macro for creating compound literal value */
+#define ecs_value_ptr(T, ptr) ((ecs_value_t){ecs_id(T), ptr})
+
+/** Convenience macro for creating compound literal pair value */
+#define ecs_value_pair(R, t, ...) ((ecs_value_t){ecs_pair_t(R, t), &(R)__VA_ARGS__})
+
+/** Convenience macro for creating compound literal pair value */
+#define ecs_value_pair_2nd(r, T, ...) ((ecs_value_t){ecs_pair(r, ecs_id(T)), &(T)__VA_ARGS__})
+
+/** Convenience macro for creating heap allocated value */
 #define ecs_value_new_t(world, T) ecs_value_new(world, ecs_id(T))
 
+/** Convenience macro for creating compound literal value literal */
+#define ecs_value(T, ...) ((ecs_value_t){ecs_id(T), &(T)__VA_ARGS__})
+
 /** @} */
 
 /** @} */
@@ -857,16 +865,11 @@
 #define ecs_isa(e)       ecs_pair(EcsIsA, e)
 #define ecs_childof(e)   ecs_pair(EcsChildOf, e)
 #define ecs_dependson(e) ecs_pair(EcsDependsOn, e)
+#define ecs_with(e)      ecs_pair(EcsWith, e)
 
-#define ecs_query_new(world, q_expr)\
-    ecs_query_init(world, &(ecs_query_desc_t){\
-        .filter.expr = q_expr\
-    })
-
-#define ecs_rule_new(world, q_expr)\
-    ecs_rule_init(world, &(ecs_filter_desc_t){\
-        .expr = q_expr\
-    })
+#define ecs_each(world, id) ecs_each_id(world, ecs_id(id))
+#define ecs_each_pair(world, r, t) ecs_each_id(world, ecs_pair(r, t))
+#define ecs_each_pair_t(world, R, t) ecs_each_id(world, ecs_pair(ecs_id(R), t))
 
 /** @} */
 
diff --git a/include/flecs/addons/json.h b/include/flecs/addons/json.h
index 2636a6130..4de739de6 100644
--- a/include/flecs/addons/json.h
+++ b/include/flecs/addons/json.h
@@ -10,8 +10,8 @@
 
 #ifdef FLECS_JSON
 
-#ifndef FLECS_EXPR
-#define FLECS_EXPR
+#ifndef FLECS_META
+#define FLECS_META
 #endif
 
 #ifndef FLECS_JSON_H
@@ -289,7 +289,7 @@ typedef struct ecs_iter_to_json_desc_t {
     bool serialize_query_plan;      /**< Serialize query plan */
     bool serialize_query_profile;   /**< Profile query performance */
     bool dont_serialize_results;    /**< If true, query won't be evaluated */
-    ecs_poly_t *query;              /**< Query object (required for serialize_query_[plan|profile]). */
+    flecs_poly_t *query;              /**< Query object (required for serialize_query_[plan|profile]). */
 } ecs_iter_to_json_desc_t;
 
 #define ECS_ITER_TO_JSON_INIT (ecs_iter_to_json_desc_t){\
@@ -323,27 +323,23 @@ typedef struct ecs_iter_to_json_desc_t {
  * This operation will iterate the contents of the iterator and serialize them
  * to JSON. The function accepts iterators from any source.
  *
- * @param world The world.
  * @param iter The iterator to serialize to JSON.
  * @return A JSON string with the serialized iterator data, or NULL if failed.
  */
 FLECS_API
 char* ecs_iter_to_json(
-    const ecs_world_t *world,
     ecs_iter_t *iter,
     const ecs_iter_to_json_desc_t *desc);
 
 /** Serialize iterator into JSON string buffer.
  * Same as ecs_iter_to_json(), but serializes to an ecs_strbuf_t instance.
  *
- * @param world The world.
  * @param iter The iterator to serialize.
  * @param buf_out The strbuf to append the string to.
  * @return Zero if success, non-zero if failed.
  */
 FLECS_API
 int ecs_iter_to_json_buf(
-    const ecs_world_t *world,
     ecs_iter_t *iter,
     ecs_strbuf_t *buf_out,
     const ecs_iter_to_json_desc_t *desc);
@@ -357,15 +353,15 @@ typedef struct ecs_world_to_json_desc_t {
 /** Serialize world into JSON string.
  * This operation iterates the contents of the world to JSON. The operation is
  * equivalent to the following code:
- *
+ * 
  * @code
- * ecs_filter_t *f = ecs_filter(world, {
+ * ecs_query_t *f = ecs_query(world, {
  *   .terms = {{ .id = EcsAny }}
  * });
- *
- * ecs_iter_t it = ecs_filter_init(world, &f);
+ * 
+ * ecs_iter_t it = ecs_query_init(world, &f);
  * ecs_iter_to_json_desc_t desc = { .serialize_table = true };
- * ecs_iter_to_json(world, iter, &desc);
+ * ecs_iter_to_json(iter, &desc);
  * @endcode
  *
  * @param world The world to serialize.
diff --git a/include/flecs/addons/meta.h b/include/flecs/addons/meta.h
index 8528f6adc..b375997e3 100644
--- a/include/flecs/addons/meta.h
+++ b/include/flecs/addons/meta.h
@@ -7,13 +7,13 @@
  * two components:
  *
  * - EcsComponent: core component, contains size & alignment
- * - EcsMetaType:  component that indicates what kind of type the entity is
+ * - EcsType:  component that indicates what kind of type the entity is
  *
  * Additionally the type may have an additional component that contains the
  * reflection data for the type. For example, structs have these components:
  *
  * - EcsComponent
- * - EcsMetaType
+ * - EcsType
  * - EcsStruct
  *
  * Structs can be populated by adding child entities with the EcsMember
@@ -34,7 +34,7 @@
  * components for the types.
  *
  * When a type is created it automatically receives the EcsComponent and
- * EcsMetaType components. The former means that the resulting type can be
+ * EcsType components. The former means that the resulting type can be
  * used as a regular component:
  *
  * @code
@@ -89,7 +89,7 @@ extern "C" {
  * Or a more useful example (create an enum constant with a manual value):
  *
  * @code
- * ecs_set_pair_object(world, e, EcsConstant, ecs_i32_t, {10});
+ * ecs_set_pair_second(world, e, EcsConstant, ecs_i32_t, {10});
  * @endcode
  */
 typedef bool ecs_bool_t;
@@ -110,8 +110,8 @@ typedef double ecs_f64_t;
 typedef char* ecs_string_t;
 
 /* Meta module component ids */
-FLECS_API extern const ecs_entity_t ecs_id(EcsMetaType);
-FLECS_API extern const ecs_entity_t ecs_id(EcsMetaTypeSerialized);
+FLECS_API extern const ecs_entity_t ecs_id(EcsType);
+FLECS_API extern const ecs_entity_t ecs_id(EcsTypeSerializer);
 FLECS_API extern const ecs_entity_t ecs_id(EcsPrimitive);
 FLECS_API extern const ecs_entity_t ecs_id(EcsEnum);
 FLECS_API extern const ecs_entity_t ecs_id(EcsBitmask);
@@ -159,11 +159,11 @@ typedef enum ecs_type_kind_t {
 } ecs_type_kind_t;
 
 /** Component that is automatically added to every type with the right kind. */
-typedef struct EcsMetaType {
+typedef struct EcsType {
     ecs_type_kind_t kind;
     bool existing;         /**< Did the type exist or is it populated from reflection */
     bool partial;          /**< Is the reflection data a partial type description */
-} EcsMetaType;
+} EcsType;
 
 /** Primitive type kinds supported by meta addon */
 typedef enum ecs_primitive_kind_t {
@@ -516,9 +516,9 @@ typedef struct ecs_meta_type_op_t {
     ecs_hashmap_t *members; /**< string -> member index (structs only) */
 } ecs_meta_type_op_t;
 
-typedef struct EcsMetaTypeSerialized {
+typedef struct EcsTypeSerializer {
     ecs_vec_t ops;      /**< vector<ecs_meta_type_op_t> */
-} EcsMetaTypeSerialized;
+} EcsTypeSerializer;
 
 
 /* Deserializer utilities */
@@ -945,6 +945,7 @@ ecs_entity_t ecs_quantity_init(
 #define ecs_quantity(world, ...)\
     ecs_quantity_init(world, &(ecs_entity_desc_t) __VA_ARGS__ )
 
+
 /* Module import */
 FLECS_API
 void FlecsMetaImport(
@@ -954,6 +955,8 @@ void FlecsMetaImport(
 }
 #endif
 
+#include "meta_c.h"
+
 #endif
 
 /** @} */
diff --git a/include/flecs/addons/meta_c.h b/include/flecs/addons/meta_c.h
index 7663c9bb4..94d919bc2 100644
--- a/include/flecs/addons/meta_c.h
+++ b/include/flecs/addons/meta_c.h
@@ -3,7 +3,7 @@
  * @brief Utility macros for populating reflection data in C.
  */
 
-#ifdef FLECS_META_C
+#ifdef FLECS_META
 
 /**
  * @defgroup c_addons_meta_c Meta Utilities
@@ -13,14 +13,6 @@
  * @{
  */
 
-#ifndef FLECS_META
-#define FLECS_META
-#endif
-
-#ifndef FLECS_PARSER
-#define FLECS_PARSER
-#endif
-
 #ifndef FLECS_META_C_H
 #define FLECS_META_C_H
 
@@ -149,8 +141,8 @@ int ecs_meta_from_desc(
 }
 #endif
 
-#endif // FLECS_META_C_H
+#endif // FLECS_META_H
 
 /** @} */
 
-#endif // FLECS_META_C
+#endif // FLECS_META
diff --git a/include/flecs/addons/parser.h b/include/flecs/addons/parser.h
deleted file mode 100644
index 7b22788db..000000000
--- a/include/flecs/addons/parser.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- * @file addons/parser.h
- * @brief Parser addon.
- *
- * The parser addon parses string expressions into lists of terms, and can be
- * used to construct filters, queries and types.
- */
-
-#ifdef FLECS_PARSER
-
-/**
- * @defgroup c_addons_parser Parser
- * @ingroup c_addons
- * Query DSL parser and parsing utilities.
- *
- * @{
- */
-
-#ifndef FLECS_PARSER_H
-#define FLECS_PARSER_H
-
-/** Maximum number of extra arguments in term expression */
-#define ECS_PARSER_MAX_ARGS (16)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Skip whitespace characters.
- * This function skips whitespace characters. Does not skip newlines.
- *
- * @param ptr Pointer to (potential) whitespaces to skip.
- * @return Pointer to the next non-whitespace character.
- */
-FLECS_API
-const char* ecs_parse_ws(
-    const char *ptr);
-
-/** Skip whitespace and newline characters.
- * This function skips whitespace characters.
- *
- * @param ptr Pointer to (potential) whitespaces to skip.
- * @return Pointer to the next non-whitespace character.
- */
-FLECS_API
-const char* ecs_parse_ws_eol(
-    const char *ptr);
-
-/** Utility function to parse an identifier */
-const char* ecs_parse_identifier(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token_out);
-
-/** Parse digit.
- * This function will parse until the first non-digit character is found. The
- * provided expression must contain at least one digit character.
- *
- * @param ptr The expression to parse.
- * @param token The output buffer.
- * @return Pointer to the first non-digit character.
- */
-FLECS_API
-const char* ecs_parse_digit(
-    const char *ptr,
-    char *token);
-
-/** Parse a single token.
- * This function can be used as simple tokenizer by other parsers.
- *
- * @param name of program (used for logging).
- * @param expr pointer to token to parse.
- * @param ptr pointer to first character to parse.
- * @param token_out Parsed token (buffer should be ECS_MAX_TOKEN_SIZE large)
- * @return Pointer to the next token, or NULL if error occurred.
- */
-FLECS_API
-const char* ecs_parse_token(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token_out,
-    char delim);
-
-/** Parse term in expression.
- * This operation parses a single term in an expression and returns a pointer
- * to the next term expression.
- *
- * If the returned pointer points to the 0-terminator, the expression is fully
- * parsed. The function would typically be called in a while loop:
- *
- * @code
- * const char *ptr = expr;
- * while (ptr[0] && (ptr = ecs_parse_term(world, name, expr, ptr, &term))) { }
- * @endcode
- *
- * The operation does not attempt to find entity ids from the names in the
- * expression. Use the ecs_term_resolve_ids() function to resolve the identifiers
- * in the parsed term.
- *
- * The returned term will in most cases contain allocated resources, which
- * should freed (or used) by the application. To free the resources for a term,
- * use the ecs_term_free() function.
- *
- * The parser accepts expressions in the legacy string format.
- *
- * @param world The world.
- * @param name The name of the expression (optional, improves error logs)
- * @param expr The expression to parse (optional, improves error logs)
- * @param ptr The pointer to the current term (must be in expr).
- * @param term_out Out parameter for the term.
- * @param extra_args Out array for extra args, must be of size ECS_PARSER_MAX_ARGS.
- * @return pointer to next term if successful, NULL if failed.
- */
-FLECS_API
-char* ecs_parse_term(
-    const ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_term_t *term_out,
-    ecs_oper_kind_t *extra_oper,
-    ecs_term_id_t *extra_args,
-    bool allow_newline);
-
-#ifdef __cplusplus
-}
-#endif // __cplusplus
-
-#endif // FLECS_PARSER_H
-
-/** @} */
-
-#endif // FLECS_PARSER
diff --git a/include/flecs/addons/pipeline.h b/include/flecs/addons/pipeline.h
index 237210e29..7f24f4d65 100644
--- a/include/flecs/addons/pipeline.h
+++ b/include/flecs/addons/pipeline.h
@@ -51,11 +51,11 @@ extern "C" {
         edesc.id = id_;\
         edesc.name = #id_;\
         desc.entity = ecs_entity_init(world, &edesc);\
-        desc.query.filter.expr = #__VA_ARGS__; \
+        desc.query.expr = #__VA_ARGS__; \
         id_ = ecs_pipeline_init(world, &desc); \
         ecs_id(id_) = id_;\
     } \
-    ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(id_ != 0, ECS_INVALID_PARAMETER, "failed to create pipeline");
 
 #define ECS_PIPELINE(world, id, ...) \
     ecs_entity_t id = 0, ecs_id(id) = 0; ECS_PIPELINE_DEFINE(world, id, __VA_ARGS__);\
diff --git a/include/flecs/addons/plecs.h b/include/flecs/addons/plecs.h
deleted file mode 100644
index b80464f3f..000000000
--- a/include/flecs/addons/plecs.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/**
- * @file addons/plecs.h
- * @brief Flecs script module.
- *
- * For script, see examples/plecs.
- */
-
-#ifdef FLECS_PLECS
-
-/**
- * @defgroup c_addons_plecs Flecs script
- * @ingroup c_addons
- * Data definition format for loading entity data.
- *
- * @{
- */
-
-#ifndef FLECS_MODULE
-#define FLECS_MODULE
-#endif
-
-#ifndef FLECS_PARSER
-#define FLECS_PARSER
-#endif
-
-#ifndef FLECS_EXPR
-#define FLECS_EXPR
-#endif
-
-#ifndef FLECS_PLECS_H
-#define FLECS_PLECS_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-FLECS_API
-extern ECS_COMPONENT_DECLARE(EcsScript);
-
-/* Script component */
-typedef struct EcsScript {
-    ecs_vec_t using_;
-    char *script;
-    ecs_vec_t prop_defaults;
-    ecs_world_t *world;
-} EcsScript;
-
-/** Parse plecs string.
- * This parses a plecs string and instantiates the entities in the world.
- *
- * @param world The world.
- * @param name The script name (typically the file).
- * @param str The plecs string.
- * @return Zero if success, non-zero otherwise.
- */
-FLECS_API
-int ecs_plecs_from_str(
-    ecs_world_t *world,
-    const char *name,
-    const char *str);
-
-/** Parse plecs file.
- * This parses a plecs file and instantiates the entities in the world. This
- * operation is equivalent to loading the file contents and passing it to
- * ecs_plecs_from_str().
- *
- * @param world The world.
- * @param filename The plecs file name.
- * @return Zero if success, non-zero otherwise.
- */
-FLECS_API
-int ecs_plecs_from_file(
-    ecs_world_t *world,
-    const char *filename);
-
-/** Used with ecs_script_init() */
-typedef struct ecs_script_desc_t {
-    ecs_entity_t entity;      /* Set to customize entity handle associated with script */
-    const char *filename;     /* Set to load script from file */
-    const char *str;          /* Set to parse script from string */
-} ecs_script_desc_t;
-
-/** Load managed script.
- * A managed script tracks which entities it creates, and keeps those entities
- * synchronized when the contents of the script are updated. When the script is
- * updated, entities that are no longer in the new version will be deleted.
- *
- * This feature is experimental.
- *
- * @param world The world.
- * @param desc Script descriptor.
- */
-FLECS_API
-ecs_entity_t ecs_script_init(
-    ecs_world_t *world,
-    const ecs_script_desc_t *desc);
-
-#define ecs_script(world, ...)\
-    ecs_script_init(world, &(ecs_script_desc_t) __VA_ARGS__)
-
-/** Update script with new code.
- *
- * @param world The world.
- * @param script The script entity.
- * @param instance An assembly instance (optional).
- * @param str The script code.
- * @param vars Optional preset variables for script parameterization.
- */
-FLECS_API
-int ecs_script_update(
-    ecs_world_t *world,
-    ecs_entity_t script,
-    ecs_entity_t instance,
-    const char *str,
-    ecs_vars_t *vars);
-
-/** Clear all entities associated with script.
- *
- * @param world The world.
- * @param script The script entity.
- * @param instance The script instance.
- */
-FLECS_API
-void ecs_script_clear(
-    ecs_world_t *world,
-    ecs_entity_t script,
-    ecs_entity_t instance);
-
-/* Module import */
-FLECS_API
-void FlecsScriptImport(
-    ecs_world_t *world);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-/** @} */
-
-#endif
diff --git a/include/flecs/addons/rules.h b/include/flecs/addons/rules.h
deleted file mode 100644
index 1a37624a5..000000000
--- a/include/flecs/addons/rules.h
+++ /dev/null
@@ -1,233 +0,0 @@
-/**
- * @file addons/rules.h
- * @brief Rule query engine addon.
- *
- * Rules are advanced queries that in addition to the capabilities of regular
- * queries and filters have the following features:
- *
- * - query for all components of an entity (vs. all entities for a component)
- * - query for all relationship pairs of an entity
- * - support for query variables that are resolved at evaluation time
- * - automatic traversal of transitive relationships
- */
-
-#ifdef FLECS_RULES
-
-/**
- * @defgroup c_addons_rules Rules
- * @ingroup c_addons
- * Rules are an advanced query engine for matching against entity graphs.
- *
- * @{
- */
-
-#ifndef FLECS_RULES_H
-#define FLECS_RULES_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Convenience macro for rule creation */
-#define ecs_rule(world, ...)\
-    ecs_rule_init(world, &(ecs_filter_desc_t) __VA_ARGS__ )
-
-/** Create a rule.
- * A rule accepts the same descriptor as a filter, but has the additional
- * ability to use query variables.
- *
- * Query variables can be used to constrain wildcards across multiple terms to
- * the same entity. Regular ECS queries do this in a limited form, as querying
- * for Position, Velocity only returns entities that have both components.
- *
- * Query variables expand this to constrain entities that are resolved while the
- * query is being matched. Consider a query for all entities and the mission
- * they are on:
- *   (Mission, *)
- *
- * If an entity is on multiple missions, the wildcard will match it multiple
- * times. Now say we want to only list combat missions. Naively we could try:
- *   (Mission, *), CombatMission(*)
- *
- * But this doesn't work, as term 1 returns entities with missions, and term 2
- * returns all combat missions for all entities. Query variables make it
- * possible to apply CombatMission to the found mission:
- *   (Mission, $M), CombatMission($M)
- *
- * By using the same variable ('M') we ensure that CombatMission is applied to
- * the mission found in the current result.
- *
- * Variables can be used in each part of the term (predicate, subject, object).
- * This is a valid query:
- *   Likes($X, $Y), Likes($Y, $X)
- *
- * This is also a valid query:
- *   _Component, Serializable(_Component)
- *
- * In the query expression syntax, variables are prefixed with a $. When using
- * the descriptor, specify the variable kind:
- *   desc.terms[0].second = { .name = "X", .var = EcsVarIsVariable }
- *
- * Different terms with the same variable name are automatically correlated by
- * the query engine.
- *
- * A rule needs to be explicitly deleted with ecs_rule_fini().
- *
- * @param world The world.
- * @param desc The descriptor (see ecs_filter_desc_t)
- * @return The rule.
- */
-FLECS_API
-ecs_rule_t* ecs_rule_init(
-    ecs_world_t *world,
-    const ecs_filter_desc_t *desc);
-
-/** Delete a rule.
- *
- * @param rule The rule.
- */
-FLECS_API
-void ecs_rule_fini(
-    ecs_rule_t *rule);
-
-/** Obtain filter from rule.
- * This operation returns the filter with which the rule was created.
- *
- * @param rule The rule.
- * @return The filter.
- */
-FLECS_API
-const ecs_filter_t* ecs_rule_get_filter(
-    const ecs_rule_t *rule);
-
-/** Return number of variables in rule.
- *
- * @param rule The rule.
- * @return The number of variables/
- */
-FLECS_API
-int32_t ecs_rule_var_count(
-    const ecs_rule_t *rule);
-
-/** Find variable index.
- * This operation looks up the index of a variable in the rule. This index can
- * be used in operations like ecs_iter_set_var() and ecs_iter_get_var().
- *
- * @param rule The rule.
- * @param name The variable name.
- * @return The variable index.
- */
-FLECS_API
-int32_t ecs_rule_find_var(
-    const ecs_rule_t *rule,
-    const char *name);
-
-/** Get variable name.
- * This operation returns the variable name for an index.
- *
- * @param rule The rule.
- * @param var_id The variable index.
- */
-FLECS_API
-const char* ecs_rule_var_name(
-    const ecs_rule_t *rule,
-    int32_t var_id);
-
-/** Test if variable is an entity.
- * Internally the rule engine has entity variables and table variables. When
- * iterating through rule variables (by using ecs_rule_variable_count()) only
- * the values for entity variables are accessible. This operation enables an
- * application to check if a variable is an entity variable.
- *
- * @param rule The rule.
- * @param var_id The variable id.
- */
-FLECS_API
-bool ecs_rule_var_is_entity(
-    const ecs_rule_t *rule,
-    int32_t var_id);
-
-/** Iterate a rule.
- * Note that rule iterators may allocate memory, and that unless the iterator
- * is iterated until completion, it may still hold resources. When stopping
- * iteration before ecs_rule_next() has returned false, use ecs_iter_fini() to
- * cleanup any remaining resources.
- *
- * @param world The world.
- * @param rule The rule.
- * @return An iterator.
- */
-FLECS_API
-ecs_iter_t ecs_rule_iter(
-    const ecs_world_t *world,
-    const ecs_rule_t *rule);
-
-/** Progress rule iterator.
- *
- * @param it The iterator.
- */
-FLECS_API
-bool ecs_rule_next(
-    ecs_iter_t *it);
-
-/** Progress instanced iterator.
- * Should not be called unless you know what you're doing :-)
- *
- * @param it The iterator.
- */
-FLECS_API
-bool ecs_rule_next_instanced(
-    ecs_iter_t *it);
-
-/** Convert rule to a string.
- * This will convert the rule program to a string which can aid in debugging
- * the behavior of a rule.
- *
- * The returned string must be freed with ecs_os_free().
- *
- * @param rule The rule.
- * @return The string
- */
-FLECS_API
-char* ecs_rule_str(
-    const ecs_rule_t *rule);
-
-/** Convert rule to string with profile.
- * To use this you must set the EcsIterProfile flag on an iterator before
- * starting iteration:
- *   it.flags |= EcsIterProfile
- *
- * @param rule The rule.
- * @return The string
- */
-FLECS_API
-char* ecs_rule_str_w_profile(
-    const ecs_rule_t *rule,
-    const ecs_iter_t *it);
-
-/** Populate variables from key-value string.
- * Convenience function to set rule variables from a key-value string separated
- * by comma's. The string must have the following format:
- *   var_a: value, var_b: value
- *
- * The key-value list may optionally be enclosed in parenthesis.
- *
- * @param rule The rule.
- * @param it The iterator for which to set the variables.
- * @param expr The key-value expression.
- */
-FLECS_API
-const char* ecs_rule_parse_vars(
-    ecs_rule_t *rule,
-    ecs_iter_t *it,
-    const char *expr);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // FLECS_RULES_H
-
-/** @} */
-
-#endif // FLECS_RULES
diff --git a/include/flecs/addons/script.h b/include/flecs/addons/script.h
new file mode 100644
index 000000000..7cf41f24a
--- /dev/null
+++ b/include/flecs/addons/script.h
@@ -0,0 +1,508 @@
+/**
+ * @file addons/script.h
+ * @brief Flecs script module.
+ *
+ * For script, see examples/script.
+ */
+
+#ifdef FLECS_SCRIPT
+
+/**
+ * @defgroup c_addons_script Flecs script
+ * @ingroup c_addons
+ * DSL for loading scenes, assets and configuration.
+ *
+ * @{
+ */
+
+#ifndef FLECS_META
+#define FLECS_META
+#endif
+
+#ifndef FLECS_DOC
+#define FLECS_DOC
+#endif
+
+
+#ifndef FLECS_SCRIPT_H
+#define FLECS_SCRIPT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+FLECS_API
+extern ECS_COMPONENT_DECLARE(EcsScript);
+
+typedef struct ecs_script_t ecs_script_t;
+typedef struct ecs_script_assembly_t ecs_script_assembly_t;
+
+/** Script variable. */
+typedef struct ecs_script_var_t {
+    const char *name;
+    ecs_value_t value;
+    const ecs_type_info_t *type_info;
+} ecs_script_var_t;
+
+/** Script variable scope. */
+typedef struct ecs_script_vars_t {
+    struct ecs_script_vars_t *parent;
+    ecs_hashmap_t var_index;
+    ecs_vec_t vars;
+
+    const ecs_world_t *world;
+    struct ecs_stack_t *stack;
+    ecs_stack_cursor_t *cursor;
+    ecs_allocator_t *allocator;
+} ecs_script_vars_t;
+
+/** Script component. 
+ * This component is added to the entities of managed scripts and assemblies.
+ */
+typedef struct EcsScript {
+    ecs_script_t *script;
+    ecs_script_assembly_t *assembly; /* Only set for assembly scripts */
+} EcsScript;
+
+
+/* Parsing & running scripts */
+
+/** Parse script.
+ * This operation parses a script and returns a script object upon success. To
+ * run the script, call ecs_script_eval().
+ * 
+ * @param world The world.
+ * @param name Name of the script (typically a file/module name).
+ * @param code The script code.
+ * @return Script object if success, NULL if failed.
+*/
+FLECS_API
+ecs_script_t* ecs_script_parse(
+    ecs_world_t *world,
+    const char *name,
+    const char *code);
+
+/** Evaluate script.
+ * This operation evaluates (runs) a parsed script.
+ * 
+ * @param script The script.
+ * @return Zero if success, non-zero if failed.
+*/
+FLECS_API
+int ecs_script_eval(
+    ecs_script_t *script);
+
+/** Free script.
+ * This operation frees a script object.
+ * 
+ * Assemblies created by the script rely upon resources in the script object,
+ * and for that reason keep the script alive until all assemblies created by the
+ * script are deleted.
+ *
+ * @param script The script.
+ */
+FLECS_API
+void ecs_script_free(
+    ecs_script_t *script);
+
+/** Parse script.
+ * This parses a script and instantiates the entities in the world.
+ * This operation is the equivalent to doing:
+ * 
+ * @code
+ * ecs_script_t *script = ecs_script_parse(world, name, code);
+ * ecs_script_eval(script);
+ * ecs_script_free(script);
+ * @endcode
+ * 
+ * @param world The world.
+ * @param name The script name (typically the file).
+ * @param code The script.
+ * @return Zero if success, non-zero otherwise.
+ */
+FLECS_API
+int ecs_script_run(
+    ecs_world_t *world,
+    const char *name,
+    const char *code);
+
+/** Parse script file.
+ * This parses a script file and instantiates the entities in the world. This
+ * operation is equivalent to loading the file contents and passing it to
+ * ecs_script_run().
+ *
+ * @param world The world.
+ * @param filename The script file name.
+ * @return Zero if success, non-zero if failed.
+ */
+FLECS_API
+int ecs_script_run_file(
+    ecs_world_t *world,
+    const char *filename);
+
+/** Convert script AST to string.
+ * This operation converts the script abstract syntax tree to a string, which
+ * can be used to debug a script.
+ * 
+ * @param script The script.
+ * @param buf The buffer to write to.
+ * @return Zero if success, non-zero if failed.
+ */
+FLECS_API
+int ecs_script_ast_to_buf(
+    ecs_script_t *script,
+    ecs_strbuf_t *buf);
+
+/** Convert script AST to string.
+ * This operation converts the script abstract syntax tree to a string, which
+ * can be used to debug a script.
+ * 
+ * @param script The script.
+ * @return The string if success, NULL if failed.
+ */
+FLECS_API
+char* ecs_script_ast_to_str(
+    ecs_script_t *script);
+
+
+/* Managed scripts (script associated with entity that outlives the function) */
+
+/** Used with ecs_script_init() */
+typedef struct ecs_script_desc_t {
+    ecs_entity_t entity;   /* Set to customize entity handle associated with script */
+    const char *filename;  /* Set to load script from file */
+    const char *code;      /* Set to parse script from string */
+} ecs_script_desc_t;
+
+/** Load managed script.
+ * A managed script tracks which entities it creates, and keeps those entities
+ * synchronized when the contents of the script are updated. When the script is
+ * updated, entities that are no longer in the new version will be deleted.
+ *
+ * This feature is experimental.
+ *
+ * @param world The world.
+ * @param desc Script descriptor.
+ */
+FLECS_API
+ecs_entity_t ecs_script_init(
+    ecs_world_t *world,
+    const ecs_script_desc_t *desc);
+
+#define ecs_script(world, ...)\
+    ecs_script_init(world, &(ecs_script_desc_t) __VA_ARGS__)
+
+/** Update script with new code.
+ *
+ * @param world The world.
+ * @param script The script entity.
+ * @param instance An assembly instance (optional).
+ * @param code The script code.
+ */
+FLECS_API
+int ecs_script_update(
+    ecs_world_t *world,
+    ecs_entity_t script,
+    ecs_entity_t instance,
+    const char *code);
+
+/** Clear all entities associated with script.
+ *
+ * @param world The world.
+ * @param script The script entity.
+ * @param instance The script instance.
+ */
+FLECS_API
+void ecs_script_clear(
+    ecs_world_t *world,
+    ecs_entity_t script,
+    ecs_entity_t instance);
+
+
+/* Script variables */
+
+/** Create new variable scope.
+ * Create root variable scope. A variable scope contains one or more variables. 
+ * Scopes can be nested, which allows variables in different scopes to have the 
+ * same name. Variables from parent scopes will be shadowed by variables in 
+ * child scopes with the same name.
+ * 
+ * Use the `ecs_script_vars_push()` and `ecs_script_vars_pop()` functions to
+ * push and pop variable scopes.
+ * 
+ * When a variable contains allocated resources (e.g. a string), its resources
+ * will be freed when `ecs_script_vars_pop()` is called on the scope, the
+ * ecs_script_vars_t::type_info field is initialized for the variable, and 
+ * `ecs_type_info_t::hooks::dtor` is set.
+ * 
+ * @param world The world.
+ */
+FLECS_API
+ecs_script_vars_t* ecs_script_vars_init(
+    ecs_world_t *world);
+
+/** Free variable scope.
+ * Free root variable scope. The provided scope should not have a parent. This
+ * operation calls `ecs_script_vars_pop()` on the scope.
+ *
+ * @param vars The variable scope.
+ */
+FLECS_API
+void ecs_script_vars_fini(
+    ecs_script_vars_t *vars);
+
+/** Push new variable scope.
+ * 
+ * Scopes created with ecs_script_vars_push() must be cleaned up with
+ * ecs_script_vars_pop().
+ * 
+ * If the stack and allocator arguments are left to NULL, their values will be
+ * copied from the parent.
+ *
+ * @param parent The parent scope (provide NULL for root scope).
+ * @return The new variable scope.
+ */
+FLECS_API
+ecs_script_vars_t* ecs_script_vars_push(
+    ecs_script_vars_t *parent);
+
+/** Pop variable scope.
+ * This frees up the resources for a variable scope. The scope must be at the
+ * top of a vars stack. Calling ecs_script_vars_pop() on a scope that is not the
+ * last scope causes undefined behavior.
+ *
+ * @param vars The scope to free.
+ * @return The parent scope.
+ */
+FLECS_API
+ecs_script_vars_t* ecs_script_vars_pop(
+    ecs_script_vars_t *vars);
+
+/** Declare a variable.
+ * This operation declares a new variable in the current scope. If a variable
+ * with the specified name already exists, the operation will fail.
+ * 
+ * This operation does not allocate storage for the variable. This is done to
+ * allow for variables that point to existing storage, which prevents having
+ * to copy existing values to a variable scope.
+ * 
+ * @param vars The variable scope.
+ * @param name The variable name.
+ * @return The new variable, or NULL if the operation failed.
+ */
+FLECS_API
+ecs_script_var_t* ecs_script_vars_declare(
+    ecs_script_vars_t *vars,
+    const char *name);
+
+/** Define a variable.
+ * This operation calls `ecs_script_vars_declare()` and allocates storage for
+ * the variable. If the type has a ctor, it will be called on the new storage.
+ * 
+ * The scope's stack allocator will be used to allocate the storage. After 
+ * `ecs_script_vars_pop()` is called on the scope, the variable storage will no
+ * longer be valid.
+ * 
+ * The operation will fail if the type argument is not a type.
+ * 
+ * @param vars The variable scope.
+ * @param name The variable name.
+ * @param type The variable type.
+ * @return The new variable, or NULL if the operation failed.
+ */
+FLECS_API
+ecs_script_var_t* ecs_script_vars_define_id(
+    ecs_script_vars_t *vars,
+    const char *name,
+    ecs_entity_t type);
+
+#define ecs_script_vars_define(vars, name, type)\
+    ecs_script_vars_define_id(vars, name, ecs_id(type))
+
+/** Lookup a variable.
+ * This operation looks up a variable in the current scope. If the variable 
+ * can't be found in the current scope, the operation will recursively search
+ * the parent scopes.
+ * 
+ * @param vars The variable scope.
+ * @param name The variable name.
+ * @return The variable, or NULL if a one with the provided name does not exist.
+ */
+FLECS_API
+ecs_script_var_t* ecs_script_vars_lookup(
+    const ecs_script_vars_t *vars,
+    const char *name);
+
+/** Convert iterator to vars
+ * This operation converts an iterator to a variable array. This allows for
+ * using iterator results in expressions. The operation only converts a
+ * single result at a time, and does not progress the iterator.
+ *
+ * Iterator fields with data will be made available as variables with as name
+ * the field index (e.g. "$1"). The operation does not check if reflection data
+ * is registered for a field type. If no reflection data is registered for the
+ * type, using the field variable in expressions will fail.
+ *
+ * Field variables will only contain single elements, even if the iterator
+ * returns component arrays. The offset parameter can be used to specify which
+ * element in the component arrays to return. The offset parameter must be
+ * smaller than it->count.
+ *
+ * The operation will create a variable for query variables that contain a
+ * single entity.
+ *
+ * The operation will attempt to use existing variables. If a variable does not
+ * yet exist, the operation will create it. If an existing variable exists with
+ * a mismatching type, the operation will fail.
+ *
+ * Accessing variables after progressing the iterator or after the iterator is
+ * destroyed will result in undefined behavior.
+ *
+ * If vars contains a variable that is not present in the iterator, the variable
+ * will not be modified.
+ *
+ * @param it The iterator to convert to variables.
+ * @param vars The variables to write to.
+ * @param offset The offset to the current element.
+ */
+FLECS_API
+void ecs_script_vars_from_iter(
+    const ecs_iter_t *it,
+    ecs_script_vars_t *vars,
+    int offset);
+
+
+/* Standalone expression evaluation */
+
+/** Used with ecs_script_expr_run(). */
+typedef struct ecs_script_expr_run_desc_t {
+    const char *name;
+    const char *expr;
+    ecs_entity_t (*lookup_action)(
+        const ecs_world_t*,
+        const char *value,
+        void *ctx);
+    void *lookup_ctx;
+    ecs_script_vars_t *vars;
+} ecs_script_expr_run_desc_t;
+
+/** Parse standalone expression into value.
+ * This operation parses a flecs expression into the provided pointer. The
+ * memory pointed to must be large enough to contain a value of the used type.
+ *
+ * If no type and pointer are provided for the value argument, the operation
+ * will discover the type from the expression and allocate storage for the
+ * value. The allocated value must be freed with ecs_value_free().
+ *
+ * @param world The world.
+ * @param ptr The pointer to the expression to parse.
+ * @param value The value containing type & pointer to write to.
+ * @param desc Configuration parameters for deserializer.
+ * @return Pointer to the character after the last one read, or NULL if failed.
+ */
+FLECS_API
+const char* ecs_script_expr_run(
+    ecs_world_t *world,
+    const char *ptr,
+    ecs_value_t *value,
+    const ecs_script_expr_run_desc_t *desc);
+
+/** Evaluate interpolated expressions in string.
+ * This operation evaluates expressions in a string, and replaces them with
+ * their evaluated result. Supported expression formats are:
+ *  - $variable_name
+ *  - {expression}
+ *
+ * The $, { and } characters can be escaped with a backslash (\).
+ *
+ * @param world The world.
+ * @param str The string to evaluate.
+ * @param vars The variables to use for evaluation.
+ */
+FLECS_API
+char* ecs_script_string_interpolate(
+    ecs_world_t *world,
+    const char *str,
+    const ecs_script_vars_t *vars);
+
+
+/* Value serialization */
+
+/** Serialize value into expression string.
+ * This operation serializes a value of the provided type to a string. The
+ * memory pointed to must be large enough to contain a value of the used type.
+ *
+ * @param world The world.
+ * @param type The type of the value to serialize.
+ * @param data The value to serialize.
+ * @return String with expression, or NULL if failed.
+ */
+FLECS_API
+char* ecs_ptr_to_expr(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *data);
+
+/** Serialize value into expression buffer.
+ * Same as ecs_ptr_to_expr(), but serializes to an ecs_strbuf_t instance.
+ *
+ * @param world The world.
+ * @param type The type of the value to serialize.
+ * @param data The value to serialize.
+ * @param buf The strbuf to append the string to.
+ * @return Zero if success, non-zero if failed.
+ */
+FLECS_API
+int ecs_ptr_to_expr_buf(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *data,
+    ecs_strbuf_t *buf);
+
+/** Similar as ecs_ptr_to_expr(), but serializes values to string.
+ * Whereas the output of ecs_ptr_to_expr() is a valid expression, the output of
+ * ecs_ptr_to_str() is a string representation of the value. In most cases the
+ * output of the two operations is the same, but there are some differences:
+ * - Strings are not quoted
+ *
+ * @param world The world.
+ * @param type The type of the value to serialize.
+ * @param data The value to serialize.
+ * @return String with result, or NULL if failed.
+ */
+FLECS_API
+char* ecs_ptr_to_str(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *data);
+
+/** Serialize value into string buffer.
+ * Same as ecs_ptr_to_str(), but serializes to an ecs_strbuf_t instance.
+ *
+ * @param world The world.
+ * @param type The type of the value to serialize.
+ * @param data The value to serialize.
+ * @param buf The strbuf to append the string to.
+ * @return Zero if success, non-zero if failed.
+ */
+FLECS_API
+int ecs_ptr_to_str_buf(
+    const ecs_world_t *world,
+    ecs_entity_t type,
+    const void *data,
+    ecs_strbuf_t *buf);
+
+/* Module import */
+FLECS_API
+void FlecsScriptImport(
+    ecs_world_t *world);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/** @} */
+
+#endif
diff --git a/include/flecs/addons/snapshot.h b/include/flecs/addons/snapshot.h
deleted file mode 100644
index 4630b8a26..000000000
--- a/include/flecs/addons/snapshot.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/**
- * @file addons/snapshot.h
- * @brief Snapshot addon.
- *
- * A snapshot records the state of a world in a way so that it can be restored
- * later. Snapshots work with POD components and non-POD components, provided
- * that the appropriate lifecycle actions are registered for non-POD components.
- *
- * A snapshot is tightly coupled to a world. It is not possible to restore a
- * snapshot from world A into world B.
- */
-
-#ifdef FLECS_SNAPSHOT
-
-/**
- * @defgroup c_addons_snapshot Snapshot
- * @ingroup c_addons
- * @brief Save & restore world.
- *
- * @{
- */
-
-#ifndef FLECS_SNAPSHOT_H
-#define FLECS_SNAPSHOT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** A snapshot stores the state of a world in a particular point in time. */
-typedef struct ecs_snapshot_t ecs_snapshot_t;
-
-/** Create a snapshot.
- * This operation makes a copy of the current state of the world.
- *
- * @param world The world to snapshot.
- * @return The snapshot.
- */
-FLECS_API
-ecs_snapshot_t* ecs_snapshot_take(
-    ecs_world_t *world);
-
-/** Create a filtered snapshot.
- * This operation is the same as ecs_snapshot_take(), but accepts an iterator so
- * an application can control what is stored by the snapshot.
- *
- * @param iter An iterator to the data to be stored by the snapshot.
- * @return The snapshot.
- */
-FLECS_API
-ecs_snapshot_t* ecs_snapshot_take_w_iter(
-    ecs_iter_t *iter);
-
-/** Restore a snapshot.
- * This operation restores the world to the state it was in when the specified
- * snapshot was taken. A snapshot can only be used once for restoring, as its
- * data replaces the data that is currently in the world.
- * This operation also resets the last issued entity handle, so any calls to
- * ecs_new() may return entity ids that have been issued before restoring the
- * snapshot.
- *
- * The world in which the snapshot is restored must be the same as the world in
- * which the snapshot is taken.
- *
- * @param world The world to restore the snapshot to.
- * @param snapshot The snapshot to restore.
- */
-FLECS_API
-void ecs_snapshot_restore(
-    ecs_world_t *world,
-    ecs_snapshot_t *snapshot);
-
-/** Obtain iterator to snapshot data.
- *
- * @param snapshot The snapshot to iterate over.
- * @return Iterator to snapshot data. */
-FLECS_API
-ecs_iter_t ecs_snapshot_iter(
-    ecs_snapshot_t *snapshot);
-
-/** Progress snapshot iterator.
- *
- * @param iter The snapshot iterator.
- * @return True if more data is available, otherwise false.
- */
-FLECS_API
-bool ecs_snapshot_next(
-    ecs_iter_t *iter);
-
-/** Free snapshot resources.
- * This frees resources associated with a snapshot without restoring it.
- *
- * @param snapshot The snapshot to free.
- */
-FLECS_API
-void ecs_snapshot_free(
-    ecs_snapshot_t *snapshot);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-/** @} */
-
-#endif
diff --git a/include/flecs/addons/stats.h b/include/flecs/addons/stats.h
index 1750d655d..8dc5b133a 100644
--- a/include/flecs/addons/stats.h
+++ b/include/flecs/addons/stats.h
@@ -152,17 +152,18 @@ typedef struct ecs_world_stats_t {
     int32_t t;
 } ecs_world_stats_t;
 
-/** Statistics for a single query (use ecs_query_stats_get()) */
+/** Statistics for a single query (use ecs_query_cache_stats_get) */
 typedef struct ecs_query_stats_t {
     int64_t first_;
-    ecs_metric_t matched_table_count;       /**< Matched non-empty tables */
-    ecs_metric_t matched_empty_table_count; /**< Matched empty tables */
+    ecs_metric_t result_count;              /**< Number of query results */
+    ecs_metric_t matched_table_count;       /**< Number of matched tables */
+    ecs_metric_t matched_empty_table_count; /**< Number of matched empty tables */
     ecs_metric_t matched_entity_count;      /**< Number of matched entities */
     ecs_metric_t eval_count;                /**< Number of times query is evaluated */
     int64_t last_;
 
-    /** Current position in ring buffer */
-    int32_t t;
+    /** Current position in ringbuffer */
+    int32_t t; 
 } ecs_query_stats_t;
 
 /** Statistics for a single system (use ecs_system_stats_get()) */
@@ -185,7 +186,7 @@ typedef struct ecs_sync_stats_t {
 
     int32_t system_count;
     bool multi_threaded;
-    bool no_readonly;
+    bool immediate;
 } ecs_sync_stats_t;
 
 /** Statistics for all systems in a pipeline. */
@@ -265,26 +266,26 @@ void ecs_query_stats_get(
     ecs_query_stats_t *stats);
 
 /** Reduce source measurement window into single destination measurement. */
-FLECS_API
-void ecs_query_stats_reduce(
+FLECS_API 
+void ecs_query_cache_stats_reduce(
     ecs_query_stats_t *dst,
     const ecs_query_stats_t *src);
 
 /** Reduce last measurement into previous measurement, restore old value. */
 FLECS_API
-void ecs_query_stats_reduce_last(
+void ecs_query_cache_stats_reduce_last(
     ecs_query_stats_t *stats,
     const ecs_query_stats_t *old,
     int32_t count);
 
 /** Repeat last measurement. */
 FLECS_API
-void ecs_query_stats_repeat_last(
+void ecs_query_cache_stats_repeat_last(
     ecs_query_stats_t *stats);
 
 /** Copy last measurement from source to destination. */
 FLECS_API
-void ecs_query_stats_copy_last(
+void ecs_query_cache_stats_copy_last(
     ecs_query_stats_t *dst,
     const ecs_query_stats_t *src);
 
diff --git a/include/flecs/addons/system.h b/include/flecs/addons/system.h
index df4d9d039..d5ad2ac3d 100644
--- a/include/flecs/addons/system.h
+++ b/include/flecs/addons/system.h
@@ -50,9 +50,8 @@ typedef struct ecs_system_desc_t {
      *
      * It should not be assumed that the input iterator can always be iterated
      * with ecs_query_next(). When a system is multithreaded and/or paged, the
-     * iterator can be either a worker or paged iterator. Future use cases may
-     * introduce additional inputs for a system, such as rules and filters. The
-     * correct function to use for iteration is ecs_iter_next().
+     * iterator can be either a worker or paged iterator. The correct function 
+     * to use for iteration is ecs_iter_next().
      *
      * An implementation can test whether the iterator is a query iterator by
      * testing whether the it->next value is equal to ecs_query_next(). */
@@ -89,7 +88,7 @@ typedef struct ecs_system_desc_t {
 
     /** If true, system will have access to the actual world. Cannot be true at the
      * same time as multi_threaded. */
-    bool no_readonly;
+    bool immediate;
 } ecs_system_desc_t;
 
 /** Create a system */
@@ -115,16 +114,20 @@ ecs_entity_t ecs_system_init(
     { \
         ecs_system_desc_t desc = {0}; \
         ecs_entity_desc_t edesc = {0}; \
+        ecs_id_t add_ids[3] = {\
+            ((phase) ? ecs_pair(EcsDependsOn, (phase)) : 0), \
+            (phase), \
+            0 \
+        };\
         edesc.id = ecs_id(id_);\
         edesc.name = #id_;\
-        edesc.add[0] = ((phase) ? ecs_pair(EcsDependsOn, (phase)) : 0); \
-        edesc.add[1] = (phase); \
+        edesc.add = add_ids;\
         desc.entity = ecs_entity_init(world, &edesc);\
-        desc.query.filter.expr = #__VA_ARGS__; \
+        desc.query.expr = #__VA_ARGS__; \
         desc.callback = id_; \
         ecs_id(id_) = ecs_system_init(world, &desc); \
     } \
-    ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, NULL)
+    ecs_assert(ecs_id(id_) != 0, ECS_INVALID_PARAMETER, "failed to create system %s", #id_)
 
 /** Declare & define a system.
  *
@@ -148,9 +151,9 @@ ecs_entity_t ecs_system_init(
  * ecs_system(world, {
  *   .entity = ecs_entity(world, {
  *     .name = "MyEntity",
- *     .add = { ecs_dependson(EcsOnUpdate) }
+ *     .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
  *   }),
- *   .query.filter.terms = {
+ *   .query.terms = {
  *     { ecs_id(Position) },
  *     { ecs_id(Velocity) }
  *   },
@@ -216,35 +219,6 @@ ecs_entity_t ecs_run_worker(
     ecs_ftime_t delta_time,
     void *param);
 
-/** Run system with offset/limit and type filter.
- * This operation is the same as ecs_run(), but filters the entities that will be
- * iterated by the system.
- *
- * Entities can be filtered in two ways. Offset and limit control the range of
- * entities that is iterated over. The range is applied to all entities matched
- * with the system, thus may cover multiple archetypes.
- *
- * The type filter controls which entity types the system will evaluate. Only
- * types that contain all components in the type filter will be iterated over. A
- * type filter is only evaluated once per table, which makes filtering cheap if
- * the number of entities is large and the number of tables is small, but not as
- * cheap as filtering in the system signature.
- *
- * @param world The world.
- * @param system The system to invoke.
- * @param delta_time The time passed since the last system invocation.
- * @param param A user-defined parameter to pass to the system.
- * @return handle to last evaluated entity if system was interrupted.
- */
-FLECS_API
-ecs_entity_t ecs_run_w_filter(
-    ecs_world_t *world,
-    ecs_entity_t system,
-    ecs_ftime_t delta_time,
-    int32_t offset,
-    int32_t limit,
-    void *param);
-
 /** Get the query object for a system.
  * Systems use queries under the hood. This enables an application to get access
  * to the underlying query object of a system. This can be useful when, for
diff --git a/include/flecs/private/allocator.h b/include/flecs/datastructures/allocator.h
similarity index 83%
rename from include/flecs/private/allocator.h
rename to include/flecs/datastructures/allocator.h
index bd4b85cb5..f61a34755 100644
--- a/include/flecs/private/allocator.h
+++ b/include/flecs/datastructures/allocator.h
@@ -6,7 +6,7 @@
 #ifndef FLECS_ALLOCATOR_H
 #define FLECS_ALLOCATOR_H
 
-#include "api_defines.h"
+#include "../private/api_defines.h"
 
 FLECS_DBG_API extern int64_t ecs_block_allocator_alloc_count;
 FLECS_DBG_API extern int64_t ecs_block_allocator_free_count;
@@ -57,9 +57,13 @@ void* flecs_dup(
 #define flecs_calloc_t(a, T) flecs_calloc(a, ECS_SIZEOF(T))
 #define flecs_calloc_n(a, T, count) flecs_calloc(a, ECS_SIZEOF(T) * (count))
 
-#define flecs_free(a, size, ptr) flecs_bfree(flecs_allocator_get(a, size), ptr)
-#define flecs_free_t(a, T, ptr) flecs_free(a, ECS_SIZEOF(T), ptr)
-#define flecs_free_n(a, T, count, ptr) flecs_free(a, ECS_SIZEOF(T) * (count), ptr)
+#define flecs_free(a, size, ptr)\
+    flecs_bfree(flecs_allocator_get(a, size), ptr)
+#define flecs_free_t(a, T, ptr)\
+    flecs_bfree_w_dbg_info(flecs_allocator_get(a, ECS_SIZEOF(T)), ptr, #T)
+#define flecs_free_n(a, T, count, ptr)\
+    flecs_bfree_w_dbg_info(flecs_allocator_get(a, ECS_SIZEOF(T) * (count))\
+        , ptr, #T)
 
 #define flecs_realloc(a, size_dst, size_src, ptr)\
     flecs_brealloc(flecs_allocator_get(a, size_dst),\
diff --git a/include/flecs/private/bitset.h b/include/flecs/datastructures/bitset.h
similarity index 97%
rename from include/flecs/private/bitset.h
rename to include/flecs/datastructures/bitset.h
index 8c9e5c943..7e2707daa 100644
--- a/include/flecs/private/bitset.h
+++ b/include/flecs/datastructures/bitset.h
@@ -6,7 +6,7 @@
 #ifndef FLECS_BITSET_H
 #define FLECS_BITSET_H
 
-#include "flecs/private/api_defines.h"
+#include "../private/api_defines.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/include/flecs/private/block_allocator.h b/include/flecs/datastructures/block_allocator.h
similarity index 91%
rename from include/flecs/private/block_allocator.h
rename to include/flecs/datastructures/block_allocator.h
index c6fec180d..ff3a7298e 100644
--- a/include/flecs/private/block_allocator.h
+++ b/include/flecs/datastructures/block_allocator.h
@@ -6,7 +6,7 @@
 #ifndef FLECS_BLOCK_ALLOCATOR_H
 #define FLECS_BLOCK_ALLOCATOR_H
 
-#include "api_defines.h"
+#include "../private/api_defines.h"
 
 typedef struct ecs_block_allocator_block_t {
     void *memory;
@@ -68,6 +68,12 @@ void flecs_bfree(
     ecs_block_allocator_t *allocator, 
     void *memory);
 
+FLECS_API
+void flecs_bfree_w_dbg_info(
+    ecs_block_allocator_t *allocator, 
+    void *memory,
+    const char *type_name);
+
 FLECS_API
 void* flecs_brealloc(
     ecs_block_allocator_t *dst, 
diff --git a/include/flecs/private/hashmap.h b/include/flecs/datastructures/hashmap.h
similarity index 98%
rename from include/flecs/private/hashmap.h
rename to include/flecs/datastructures/hashmap.h
index ddb0c66c6..06e6eab2b 100644
--- a/include/flecs/private/hashmap.h
+++ b/include/flecs/datastructures/hashmap.h
@@ -6,7 +6,7 @@
 #ifndef FLECS_HASHMAP_H
 #define FLECS_HASHMAP_H
 
-#include "api_defines.h"
+#include "../private/api_defines.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/include/flecs/private/map.h b/include/flecs/datastructures/map.h
similarity index 99%
rename from include/flecs/private/map.h
rename to include/flecs/datastructures/map.h
index 59a756266..969125f67 100644
--- a/include/flecs/private/map.h
+++ b/include/flecs/datastructures/map.h
@@ -6,7 +6,7 @@
 #ifndef FLECS_MAP_H
 #define FLECS_MAP_H
 
-#include "api_defines.h"
+#include "../private/api_defines.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/include/flecs/private/sparse.h b/include/flecs/datastructures/sparse.h
similarity index 99%
rename from include/flecs/private/sparse.h
rename to include/flecs/datastructures/sparse.h
index b5e5d71dc..c52bd5efb 100644
--- a/include/flecs/private/sparse.h
+++ b/include/flecs/datastructures/sparse.h
@@ -6,7 +6,7 @@
 #ifndef FLECS_SPARSE_H
 #define FLECS_SPARSE_H
 
-#include "flecs/private/api_defines.h"
+#include "../private/api_defines.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/src/datastructures/stack_allocator.h b/include/flecs/datastructures/stack_allocator.h
similarity index 89%
rename from src/datastructures/stack_allocator.h
rename to include/flecs/datastructures/stack_allocator.h
index 740147bc7..9e2e5cd00 100644
--- a/src/datastructures/stack_allocator.h
+++ b/include/flecs/datastructures/stack_allocator.h
@@ -16,6 +16,16 @@ typedef struct ecs_stack_page_t {
     uint32_t id;
 } ecs_stack_page_t;
 
+typedef struct ecs_stack_cursor_t {
+    struct ecs_stack_cursor_t *prev;
+    struct ecs_stack_page_t *page;
+    int16_t sp;
+    bool is_free;
+#ifdef FLECS_DEBUG
+    struct ecs_stack_t *owner;
+#endif
+} ecs_stack_cursor_t;
+
 typedef struct ecs_stack_t {
     ecs_stack_page_t first;
     ecs_stack_page_t *tail_page;
diff --git a/include/flecs/private/strbuf.h b/include/flecs/datastructures/strbuf.h
similarity index 99%
rename from include/flecs/private/strbuf.h
rename to include/flecs/datastructures/strbuf.h
index adb167081..a16e73afc 100644
--- a/include/flecs/private/strbuf.h
+++ b/include/flecs/datastructures/strbuf.h
@@ -6,7 +6,7 @@
 #ifndef FLECS_STRBUF_H_
 #define FLECS_STRBUF_H_
 
-#include "api_defines.h"
+#include "../private/api_defines.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/include/flecs/private/vec.h b/include/flecs/datastructures/vec.h
similarity index 99%
rename from include/flecs/private/vec.h
rename to include/flecs/datastructures/vec.h
index a550bb7cf..906be3323 100644
--- a/include/flecs/private/vec.h
+++ b/include/flecs/datastructures/vec.h
@@ -6,7 +6,7 @@
 #ifndef FLECS_VEC_H
 #define FLECS_VEC_H
 
-#include "flecs/private/api_defines.h"
+#include "../private/api_defines.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/include/flecs/os_api.h b/include/flecs/os_api.h
index bfcbb8a09..3ce1acac1 100644
--- a/include/flecs/os_api.h
+++ b/include/flecs/os_api.h
@@ -376,16 +376,16 @@ void ecs_os_set_api_defaults(void);
 #endif
 
 #define ecs_os_memcpy_t(ptr1, ptr2, T) ecs_os_memcpy(ptr1, ptr2, ECS_SIZEOF(T))
-#define ecs_os_memcpy_n(ptr1, ptr2, T, count) ecs_os_memcpy(ptr1, ptr2, ECS_SIZEOF(T) * count)
+#define ecs_os_memcpy_n(ptr1, ptr2, T, count) ecs_os_memcpy(ptr1, ptr2, ECS_SIZEOF(T) * (size_t)count)
 #define ecs_os_memcmp_t(ptr1, ptr2, T) ecs_os_memcmp(ptr1, ptr2, ECS_SIZEOF(T))
 
 #define ecs_os_memmove_t(ptr1, ptr2, T) ecs_os_memmove(ptr1, ptr2, ECS_SIZEOF(T))
-#define ecs_os_memmove_n(ptr1, ptr2, T, count) ecs_os_memmove(ptr1, ptr2, ECS_SIZEOF(T) * count)
+#define ecs_os_memmove_n(ptr1, ptr2, T, count) ecs_os_memmove(ptr1, ptr2, ECS_SIZEOF(T) * (size_t)count)
 #define ecs_os_memmove_t(ptr1, ptr2, T) ecs_os_memmove(ptr1, ptr2, ECS_SIZEOF(T))
 
 #define ecs_os_strcmp(str1, str2) strcmp(str1, str2)
 #define ecs_os_memset_t(ptr, value, T) ecs_os_memset(ptr, value, ECS_SIZEOF(T))
-#define ecs_os_memset_n(ptr, value, T, count) ecs_os_memset(ptr, value, ECS_SIZEOF(T) * count)
+#define ecs_os_memset_n(ptr, value, T, count) ecs_os_memset(ptr, value, ECS_SIZEOF(T) * (size_t)count)
 #define ecs_os_zeromem(ptr) ecs_os_memset(ptr, 0, ECS_SIZEOF(*ptr))
 
 #define ecs_os_memdup_t(ptr, T) ecs_os_memdup(ptr, ECS_SIZEOF(T))
diff --git a/include/flecs/private/addons.h b/include/flecs/private/addons.h
index 55bc8958b..e01559e41 100644
--- a/include/flecs/private/addons.h
+++ b/include/flecs/private/addons.h
@@ -15,17 +15,8 @@
 #ifdef FLECS_NO_MODULE
 #undef FLECS_MODULE
 #endif
-#ifdef FLECS_NO_PARSER
-#undef FLECS_PARSER
-#endif
-#ifdef FLECS_NO_PLECS
-#undef FLECS_PLECS
-#endif
-#ifdef FLECS_NO_RULES
-#undef FLECS_RULES
-#endif
-#ifdef FLECS_NO_SNAPSHOT
-#undef FLECS_SNAPSHOT
+#ifdef FLECS_NO_SCRIPT
+#undef FLECS_SCRIPT
 #endif
 #ifdef FLECS_NO_MONITOR
 #undef FLECS_MONITOR
@@ -45,15 +36,9 @@
 #ifdef FLECS_NO_META
 #undef FLECS_META
 #endif
-#ifdef FLECS_NO_META_C
-#undef FLECS_META_C
-#endif
 #ifdef FLECS_NO_UNITS
 #undef FLECS_UNITS
 #endif
-#ifdef FLECS_NO_EXPR
-#undef FLECS_EXPR
-#endif
 #ifdef FLECS_NO_JSON
 #undef FLECS_JSON
 #endif
@@ -102,12 +87,6 @@
 #endif
 #endif
 
-#ifdef FLECS_PLECS
-#ifndef FLECS_EXPR
-#define FLECS_EXPR
-#endif
-#endif
-
 #ifdef FLECS_APP
 #ifdef FLECS_NO_APP
 #error "FLECS_NO_APP failed: APP is required by other addons"
@@ -178,13 +157,6 @@
 #include "../addons/monitor.h"
 #endif
 
-#ifdef FLECS_DOC
-#ifdef FLECS_NO_DOC
-#error "FLECS_NO_DOC failed: DOC is required by other addons"
-#endif
-#include "../addons/doc.h"
-#endif
-
 #ifdef FLECS_JSON
 #ifdef FLECS_NO_JSON
 #error "FLECS_NO_JSON failed: JSON is required by other addons"
@@ -192,11 +164,6 @@
 #include "../addons/json.h"
 #endif
 
-#if defined(FLECS_EXPR) || defined(FLECS_META_C)
-#ifndef FLECS_META
-#define FLECS_META
-#endif
-#endif
 #ifdef FLECS_UNITS
 #ifdef FLECS_NO_UNITS
 #error "FLECS_NO_UNITS failed: UNITS is required by other addons"
@@ -204,53 +171,25 @@
 #include "../addons/units.h"
 #endif
 
-#ifdef FLECS_META
-#ifdef FLECS_NO_META
-#error "FLECS_NO_META failed: META is required by other addons"
+#ifdef FLECS_SCRIPT
+#ifdef FLECS_NO_SCRIPT
+#error "FLECS_NO_SCRIPT failed: SCRIPT is required by other addons"
 #endif
-#include "../addons/meta.h"
+#include "../addons/script.h"
 #endif
 
-#ifdef FLECS_EXPR
-#ifdef FLECS_NO_EXPR
-#error "FLECS_NO_EXPR failed: EXPR is required by other addons"
-#endif
-#include "../addons/expr.h"
-#endif
-
-#ifdef FLECS_META_C
-#ifdef FLECS_NO_META_C
-#error "FLECS_NO_META_C failed: META_C is required by other addons"
-#endif
-#include "../addons/meta_c.h"
-#endif
-
-#ifdef FLECS_PLECS
-#ifdef FLECS_NO_PLECS
-#error "FLECS_NO_PLECS failed: PLECS is required by other addons"
-#endif
-#include "../addons/plecs.h"
-#endif
-
-#ifdef FLECS_RULES
-#ifdef FLECS_NO_RULES
-#error "FLECS_NO_RULES failed: RULES is required by other addons"
-#endif
-#include "../addons/rules.h"
-#endif
-
-#ifdef FLECS_SNAPSHOT
-#ifdef FLECS_NO_SNAPSHOT
-#error "FLECS_NO_SNAPSHOT failed: SNAPSHOT is required by other addons"
+#ifdef FLECS_DOC
+#ifdef FLECS_NO_DOC
+#error "FLECS_NO_DOC failed: DOC is required by other addons"
 #endif
-#include "../addons/snapshot.h"
+#include "../addons/doc.h"
 #endif
 
-#ifdef FLECS_PARSER
-#ifdef FLECS_NO_PARSER
-#error "FLECS_NO_PARSER failed: PARSER is required by other addons"
+#ifdef FLECS_META
+#ifdef FLECS_NO_META
+#error "FLECS_NO_META failed: META is required by other addons"
 #endif
-#include "../addons/parser.h"
+#include "../addons/meta.h"
 #endif
 
 #ifdef FLECS_OS_API_IMPL
diff --git a/include/flecs/private/api_defines.h b/include/flecs/private/api_defines.h
index c04e7f4ea..75b07ce7c 100644
--- a/include/flecs/private/api_defines.h
+++ b/include/flecs/private/api_defines.h
@@ -192,6 +192,20 @@ typedef uint16_t ecs_flags16_t;
 typedef uint32_t ecs_flags32_t;
 typedef uint64_t ecs_flags64_t;
 
+/* Bitmask type with compile-time defined size */
+#define ecs_flagsn_t_(bits) ecs_flags##bits##_t
+#define ecs_flagsn_t(bits) ecs_flagsn_t_(bits)
+
+/* Bitset type that can store exactly as many bits as there are terms */
+#define ecs_termset_t ecs_flagsn_t(FLECS_TERM_COUNT_MAX)
+
+/* Utility macro's for setting/clearing termset bits */
+#define ECS_TERMSET_SET(set, flag) ((set) |= (ecs_termset_t)(flag))
+#define ECS_TERMSET_CLEAR(set, flag) ((set) &= (ecs_termset_t)~(flag))
+#define ECS_TERMSET_COND(set, flag, cond) ((cond) \
+    ? (ECS_TERMSET_SET(set, flag)) \
+    : (ECS_TERMSET_CLEAR(set, flag)))
+
 /* Keep unsigned integers out of the codebase as they do more harm than good */
 typedef int32_t ecs_size_t;
 
@@ -271,11 +285,7 @@ typedef struct ecs_allocator_t ecs_allocator_t;
 /* Magic number to identify the type of the object */
 #define ecs_world_t_magic     (0x65637377)
 #define ecs_stage_t_magic     (0x65637373)
-#define ecs_query_t_magic     (0x65637371)
-#define ecs_rule_t_magic      (0x65637375)
-#define ecs_table_t_magic     (0x65637374)
-#define ecs_filter_t_magic    (0x65637366)
-#define ecs_trigger_t_magic   (0x65637372)
+#define ecs_query_t_magic     (0x65637375)
 #define ecs_observer_t_magic  (0x65637362)
 
 
@@ -301,6 +311,8 @@ typedef struct ecs_allocator_t ecs_allocator_t;
 #define ECS_PAIR_SECOND(e)            (ecs_entity_t_lo(e))
 #define ECS_HAS_RELATION(e, rel)      (ECS_HAS_ID_FLAG(e, PAIR) && (ECS_PAIR_FIRST(e) == rel))
 
+#define ECS_TERM_REF_FLAGS(ref)       ((ref)->id & EcsTermRefFlags)
+#define ECS_TERM_REF_ID(ref)          ((ref)->id & ~EcsTermRefFlags)
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Convert between C typenames and variables
@@ -323,9 +335,9 @@ typedef struct ecs_allocator_t ecs_allocator_t;
 #define ecs_pair_first(world, pair) ecs_get_alive(world, ECS_PAIR_FIRST(pair))
 #define ecs_pair_second(world, pair) ecs_get_alive(world, ECS_PAIR_SECOND(pair))
 #define ecs_pair_relation ecs_pair_first
-#define ecs_pair_object ecs_pair_second
+#define ecs_pair_target ecs_pair_second
 
-#define ecs_poly_id(tag) ecs_pair(ecs_id(EcsPoly), tag)
+#define flecs_poly_id(tag) ecs_pair(ecs_id(EcsPoly), tag)
 
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/include/flecs/private/api_flags.h b/include/flecs/private/api_flags.h
index eec1c9129..e1856dc58 100644
--- a/include/flecs/private/api_flags.h
+++ b/include/flecs/private/api_flags.h
@@ -66,8 +66,8 @@ extern "C" {
 #define EcsIdTraversable               (1u << 8)
 #define EcsIdTag                       (1u << 9)
 #define EcsIdWith                      (1u << 10)
-#define EcsIdUnion                     (1u << 11)
 #define EcsIdAlwaysOverride            (1u << 12)
+#define EcsIdCanToggle                 (1u << 13)
 
 #define EcsIdHasOnAdd                  (1u << 16) /* Same values as table flags */
 #define EcsIdHasOnRemove               (1u << 17) 
@@ -100,49 +100,53 @@ extern "C" {
 #define EcsIterIsValid                 (1u << 0u)  /* Does iterator contain valid result */
 #define EcsIterNoData                  (1u << 1u)  /* Does iterator provide (component) data */
 #define EcsIterIsInstanced             (1u << 2u)  /* Is iterator instanced */
-#define EcsIterHasShared               (1u << 3u)  /* Does result have shared terms */
-#define EcsIterTableOnly               (1u << 4u)  /* Result only populates table */
-#define EcsIterEntityOptional          (1u << 5u)  /* Treat terms with entity subject as optional */
-#define EcsIterNoResults               (1u << 6u)  /* Iterator has no results */
-#define EcsIterIgnoreThis              (1u << 7u)  /* Only evaluate non-this terms */
-#define EcsIterMatchVar                (1u << 8u)  
-#define EcsIterHasCondSet              (1u << 10u) /* Does iterator have conditionally set fields */
-#define EcsIterProfile                 (1u << 11u) /* Profile iterator performance */
-#define EcsIterTrivialSearch           (1u << 12u) /* Trivial iterator mode */
-#define EcsIterTrivialSearchNoData     (1u << 13u) /* Trivial iterator w/no data */
-#define EcsIterTrivialTest             (1u << 14u) /* Trivial test mode (constrained $this) */
-#define EcsIterTrivialSearchWildcard   (1u << 15u) /* Trivial search with wildcard ids */
-#define EcsIterCppEach                 (1u << 16u) /* Uses C++ 'each' iterator */
+#define EcsIterNoResults               (1u << 3u)  /* Iterator has no results */
+#define EcsIterIgnoreThis              (1u << 4u)  /* Only evaluate non-this terms */
+#define EcsIterHasCondSet              (1u << 6u)  /* Does iterator have conditionally set fields */
+#define EcsIterProfile                 (1u << 7u)  /* Profile iterator performance */
+#define EcsIterTrivialSearch           (1u << 8u)  /* Trivial iterator mode */
+#define EcsIterTrivialSearchNoData     (1u << 9u)  /* Trivial iterator w/no data */
+#define EcsIterTrivialTest             (1u << 10u) /* Trivial test mode (constrained $this) */
+#define EcsIterTrivialTestWildcard     (1u << 11u) /* Trivial test w/wildcards */
+#define EcsIterTrivialSearchWildcard   (1u << 12u) /* Trivial search with wildcard ids */
+#define EcsIterCacheSearch             (1u << 13u) /* Cache search */
+#define EcsIterFixedInChangeComputed   (1u << 14u) /* Change detection for fixed in terms is done */
+#define EcsIterFixedInChanged          (1u << 15u) /* Fixed in terms changed */
+#define EcsIterSkip                    (1u << 16u) /* Result was skipped for change detection */
+#define EcsIterCppEach                 (1u << 17u) /* Uses C++ 'each' iterator */
+
+/* Same as event flags */
+#define EcsIterTableOnly               (1u << 18u)  /* Result only populates table */
+
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Event flags (used by ecs_event_decs_t::flags)
 ////////////////////////////////////////////////////////////////////////////////
 
-#define EcsEventTableOnly              (1u << 4u)   /* Table event (no data, same as iter flags) */
-#define EcsEventNoOnSet                (1u << 16u)  /* Don't emit OnSet/UnSet for inherited ids */
+#define EcsEventTableOnly              (1u << 18u) /* Table event (no data, same as iter flags) */
+#define EcsEventNoOnSet                (1u << 16u) /* Don't emit OnSet/UnSet for inherited ids */
+
 
 ////////////////////////////////////////////////////////////////////////////////
-//// Filter flags (used by ecs_filter_t::flags)
+//// Query flags (used by ecs_query_t::flags)
 ////////////////////////////////////////////////////////////////////////////////
 
-#define EcsFilterMatchThis             (1u << 1u)  /* Has terms that match This */
-#define EcsFilterMatchOnlyThis         (1u << 2u)  /* Has only terms that match This */
-#define EcsFilterMatchPrefab           (1u << 3u)  /* Does filter match prefabs */
-#define EcsFilterMatchDisabled         (1u << 4u)  /* Does filter match disabled entities */
-#define EcsFilterMatchEmptyTables      (1u << 5u)  /* Does filter return empty tables */
-#define EcsFilterMatchAnything         (1u << 6u)  /* False if filter has no/only Not terms */
-#define EcsFilterNoData                (1u << 7u)  /* When true, data fields won't be populated */
-#define EcsFilterIsInstanced           (1u << 8u)  /* Is filter instanced (see ecs_filter_desc_t) */
-#define EcsFilterPopulate              (1u << 9u)  /* Populate data, ignore non-matching fields */
-#define EcsFilterHasCondSet            (1u << 10u) /* Does filter have conditionally set fields */
-#define EcsFilterUnresolvedByName      (1u << 11u) /* Use by-name matching for unresolved entity identifiers */
-#define EcsFilterHasPred               (1u << 12u) /* Filter has equality predicates */
-#define EcsFilterHasScopes             (1u << 13u) /* Filter has query scopes */
-#define EcsFilterIsTrivial             (1u << 14u) /* Trivial filter */
-#define EcsFilterMatchOnlySelf         (1u << 15u) /* Filter has no up traversal */
-#define EcsFilterHasWildcards          (1u << 16u) /* Filter has no up traversal */
-#define EcsFilterOwnsStorage           (1u << 17u) /* Is ecs_filter_t object owned by filter */
-#define EcsFilterOwnsTermsStorage      (1u << 18u) /* Is terms array owned by filter */
+/* Flags that can only be set by the query implementation */
+#define EcsQueryMatchThis             (1u << 11u) /* Query has terms with $this source */
+#define EcsQueryMatchOnlyThis         (1u << 12u) /* Query only has terms with $this source */
+#define EcsQueryMatchOnlySelf         (1u << 13u) /* Query has no terms with up traversal */
+#define EcsQueryMatchWildcards        (1u << 14u) /* Query matches wildcards */
+#define EcsQueryHasCondSet            (1u << 15u) /* Query has conditionally set fields */
+#define EcsQueryHasPred               (1u << 16u) /* Query has equality predicates */
+#define EcsQueryHasScopes             (1u << 17u) /* Query has query scopes */
+#define EcsQueryHasRefs               (1u << 18u) /* Query has terms with static source */
+#define EcsQueryHasOutTerms           (1u << 19u) /* Query has [out] terms */
+#define EcsQueryHasNonThisOutTerms    (1u << 20u) /* Query has [out] terms with no $this source */
+#define EcsQueryHasMonitor            (1u << 21u) /* Query has monitor for change detection */
+#define EcsQueryIsTrivial             (1u << 22u) /* Query can use trivial evaluation function */
+#define EcsQueryHasCacheable          (1u << 23u) /* Query has cacheable terms */
+#define EcsQueryIsCacheable           (1u << 24u) /* All terms of query are cacheable */
+
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Observer flags (used by ecs_observer_t::flags)
@@ -165,11 +169,11 @@ extern "C" {
 #define EcsTableHasPairs               (1u << 6u)  /* Does the table type have pairs */
 #define EcsTableHasModule              (1u << 7u)  /* Does the table have module data */
 #define EcsTableIsDisabled             (1u << 8u)  /* Does the table type has EcsDisabled */
-#define EcsTableHasCtors               (1u << 9u)
-#define EcsTableHasDtors               (1u << 10u)
-#define EcsTableHasCopy                (1u << 11u)
-#define EcsTableHasMove                (1u << 12u)
-#define EcsTableHasUnion               (1u << 13u)
+#define EcsTableNotQueryable           (1u << 9u)  /* Table should never be returned by queries */
+#define EcsTableHasCtors               (1u << 10u)
+#define EcsTableHasDtors               (1u << 11u)
+#define EcsTableHasCopy                (1u << 12u)
+#define EcsTableHasMove                (1u << 13u)
 #define EcsTableHasToggle              (1u << 14u)
 #define EcsTableHasOverrides           (1u << 15u)
 
@@ -183,30 +187,15 @@ extern "C" {
 #define EcsTableHasOnTableDelete       (1u << 23u)
 
 #define EcsTableHasTraversable         (1u << 25u)
-#define EcsTableHasTarget              (1u << 26u)
-
 #define EcsTableMarkedForDelete        (1u << 30u)
 
 /* Composite table flags */
 #define EcsTableHasLifecycle        (EcsTableHasCtors | EcsTableHasDtors)
-#define EcsTableIsComplex           (EcsTableHasLifecycle | EcsTableHasUnion | EcsTableHasToggle)
-#define EcsTableHasAddActions       (EcsTableHasIsA | EcsTableHasUnion | EcsTableHasCtors | EcsTableHasOnAdd | EcsTableHasOnSet)
+#define EcsTableIsComplex           (EcsTableHasLifecycle | EcsTableHasToggle)
+#define EcsTableHasAddActions       (EcsTableHasIsA | EcsTableHasCtors | EcsTableHasOnAdd | EcsTableHasOnSet)
 #define EcsTableHasRemoveActions    (EcsTableHasIsA | EcsTableHasDtors | EcsTableHasOnRemove | EcsTableHasUnSet)
 
 
-////////////////////////////////////////////////////////////////////////////////
-//// Query flags (used by ecs_query_t::flags)
-////////////////////////////////////////////////////////////////////////////////
-
-#define EcsQueryHasRefs                (1u << 1u)  /* Does query have references */
-#define EcsQueryIsSubquery             (1u << 2u)  /* Is query a subquery */
-#define EcsQueryIsOrphaned             (1u << 3u)  /* Is subquery orphaned */
-#define EcsQueryHasOutTerms            (1u << 4u)  /* Does query have out terms */
-#define EcsQueryHasNonThisOutTerms     (1u << 5u)  /* Does query have non-this out terms */
-#define EcsQueryHasMonitor             (1u << 6u)  /* Does query track changes */
-#define EcsQueryTrivialIter            (1u << 7u)  /* Does the query require special features to iterate */
-
-
 ////////////////////////////////////////////////////////////////////////////////
 //// Aperiodic action flags (used by ecs_run_aperiodic)
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/include/flecs/private/api_support.h b/include/flecs/private/api_support.h
index e3004654c..9b2a69731 100644
--- a/include/flecs/private/api_support.h
+++ b/include/flecs/private/api_support.h
@@ -32,35 +32,112 @@ extern "C" {
 //// Global type handles
 ////////////////////////////////////////////////////////////////////////////////
 
-/** This allows passing 0 as type to functions that accept ids */
-#define FLECS_ID0ID_ 0
-
 FLECS_API
-char* ecs_module_path_from_c(
+char* flecs_module_path_from_c(
     const char *c_name);
 
-bool ecs_identifier_is_0(
+bool flecs_identifier_is_0(
     const char *id);
 
 /* Constructor that zeromem's a component value */
 FLECS_API
-void ecs_default_ctor(
+void flecs_default_ctor(
     void *ptr, 
     int32_t count, 
     const ecs_type_info_t *ctx);
 
 /* Create allocated string from format */
 FLECS_DBG_API
-char* ecs_vasprintf(
+char* flecs_vasprintf(
     const char *fmt,
     va_list args);
 
 /* Create allocated string from format */
 FLECS_API
-char* ecs_asprintf(
+char* flecs_asprintf(
     const char *fmt,
     ...);
 
+/** Write an escaped character.
+ * Write a character to an output string, insert escape character if necessary.
+ *
+ * @param out The string to write the character to.
+ * @param in The input character.
+ * @param delimiter The delimiter used (for example '"')
+ * @return Pointer to the character after the last one written.
+ */
+FLECS_API
+char* flecs_chresc(
+    char *out,
+    char in,
+    char delimiter);
+
+/** Parse an escaped character.
+ * Parse a character with a potential escape sequence.
+ *
+ * @param in Pointer to character in input string.
+ * @param out Output string.
+ * @return Pointer to the character after the last one read.
+ */
+const char* flecs_chrparse(
+    const char *in,
+    char *out);
+
+/** Write an escaped string.
+ * Write an input string to an output string, escape characters where necessary.
+ * To determine the size of the output string, call the operation with a NULL
+ * argument for 'out', and use the returned size to allocate a string that is
+ * large enough.
+ *
+ * @param out Pointer to output string (must be).
+ * @param size Maximum number of characters written to output.
+ * @param delimiter The delimiter used (for example '"').
+ * @param in The input string.
+ * @return The number of characters that (would) have been written.
+ */
+FLECS_API
+ecs_size_t flecs_stresc(
+    char *out,
+    ecs_size_t size,
+    char delimiter,
+    const char *in);
+
+/** Return escaped string.
+ * Return escaped version of input string. Same as flecs_stresc(), but returns an
+ * allocated string of the right size.
+ *
+ * @param delimiter The delimiter used (for example '"').
+ * @param in The input string.
+ * @return Escaped string.
+ */
+FLECS_API
+char* flecs_astresc(
+    char delimiter,
+    const char *in);
+
+/** Skip whitespace and newline characters.
+ * This function skips whitespace characters.
+ *
+ * @param ptr Pointer to (potential) whitespaces to skip.
+ * @return Pointer to the next non-whitespace character.
+ */
+FLECS_API
+const char* flecs_parse_ws_eol(
+    const char *ptr);
+
+/** Parse digit.
+ * This function will parse until the first non-digit character is found. The
+ * provided expression must contain at least one digit character.
+ *
+ * @param ptr The expression to parse.
+ * @param token The output buffer.
+ * @return Pointer to the first non-digit character.
+ */
+FLECS_API
+const char* flecs_parse_digit(
+    const char *ptr,
+    char *token);
+
 /* Convert identifier to snake case */
 FLECS_API
 char* flecs_to_snake_case(
@@ -74,11 +151,55 @@ FLECS_DBG_API
 void flecs_dump_backtrace(
     void *stream);
 
+/* Suspend/resume readonly state. To fully support implicit registration of
+ * components, it should be possible to register components while the world is
+ * in readonly mode. It is not uncommon that a component is used first from
+ * within a system, which are often ran while in readonly mode.
+ * 
+ * Suspending readonly mode is only allowed when the world is not multithreaded.
+ * When a world is multithreaded, it is not safe to (even temporarily) leave
+ * readonly mode, so a multithreaded application should always explicitly
+ * register components in advance. 
+ * 
+ * These operations also suspend deferred mode.
+ */
+typedef struct ecs_suspend_readonly_state_t {
+    bool is_readonly;
+    bool is_deferred;
+    int32_t defer_count;
+    ecs_entity_t scope;
+    ecs_entity_t with;
+    ecs_vec_t commands;
+    ecs_stack_t defer_stack;
+    ecs_stage_t *stage;
+} ecs_suspend_readonly_state_t;
+
+FLECS_API
+ecs_world_t* flecs_suspend_readonly(
+    const ecs_world_t *world,
+    ecs_suspend_readonly_state_t *state);
+
+FLECS_API
+void flecs_resume_readonly(
+    ecs_world_t *world,
+    ecs_suspend_readonly_state_t *state);
+
 FLECS_API
-ecs_iter_t flecs_children(
-    const ecs_world_t *stage,
-    ecs_entity_t rel,
-    ecs_entity_t parent);
+int32_t flecs_poly_claim_(
+    flecs_poly_t *poly);
+
+FLECS_API
+int32_t flecs_poly_release_(
+    flecs_poly_t *poly);
+
+FLECS_API
+int32_t flecs_poly_refcount(
+    flecs_poly_t *poly);
+
+#define flecs_poly_claim(poly) \
+    flecs_poly_claim_(ECS_CONST_CAST(void*, reinterpret_cast<const void*>(poly)))
+#define flecs_poly_release(poly) \
+    flecs_poly_release_(ECS_CONST_CAST(void*, reinterpret_cast<const void*>(poly)))
 
 /** Calculate offset from address */
 #ifdef __cplusplus
@@ -97,8 +218,18 @@ ecs_iter_t flecs_children(
 #define ECS_BIT_COND(flags, bit, cond) ((cond) \
     ? (ECS_BIT_SET(flags, bit)) \
     : (ECS_BIT_CLEAR(flags, bit)))
+
+#define ECS_BIT_CLEAR16(flags, bit) (flags) &= (ecs_flags16_t)~(bit)   
+#define ECS_BIT_COND16(flags, bit, cond) ((cond) \
+    ? (ECS_BIT_SET(flags, bit)) \
+    : (ECS_BIT_CLEAR16(flags, bit)))
+
 #define ECS_BIT_IS_SET(flags, bit) ((flags) & (bit))
 
+#define ECS_BIT_SETN(flags, n) ECS_BIT_SET(flags, 1llu << n)
+#define ECS_BIT_CLEARN(flags, n) ECS_BIT_CLEAR(flags, 1llu << n)
+#define ECS_BIT_CONDN(flags, n, cond) ECS_BIT_COND(flags, 1llu << n, cond)
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/flecs/private/api_types.h b/include/flecs/private/api_types.h
index 916893fda..0b2014388 100644
--- a/include/flecs/private/api_types.h
+++ b/include/flecs/private/api_types.h
@@ -20,23 +20,16 @@ extern "C" {
 //// Opaque types
 ////////////////////////////////////////////////////////////////////////////////
 
-/** A stage enables modification while iterating and from multiple threads */
-typedef struct ecs_stage_t ecs_stage_t;
-
 /** Table data */
 typedef struct ecs_data_t ecs_data_t;
 
-/* Switch list */
-typedef struct ecs_switch_t ecs_switch_t;
-
 /* Cached query table data */
-typedef struct ecs_query_table_match_t ecs_query_table_match_t;
+typedef struct ecs_query_cache_table_match_t ecs_query_cache_table_match_t;
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Non-opaque types
 ////////////////////////////////////////////////////////////////////////////////
 
-/** Mixin for emitting events to triggers/observers */
 /** All observers for a specific event */
 typedef struct ecs_event_record_t {
     struct ecs_event_id_record_t *any;
@@ -60,7 +53,7 @@ struct ecs_record_t {
     ecs_id_record_t *idr; /* Id record to (*, entity) for target entities */
     ecs_table_t *table;   /* Identifies a type (and table) in world */
     uint32_t row;         /* Table row of the entity */
-    int32_t dense;        /* Index in dense array */    
+    int32_t dense;        /* Index in dense array of entity index */    
 };
 
 /** Range in table */
@@ -90,18 +83,6 @@ struct ecs_ref_t {
     ecs_record_t *record;   /* Entity index record */
 };
 
-/* Cursor to stack allocator. Type is public to allow for white box testing. */
-struct ecs_stack_page_t;
-
-typedef struct ecs_stack_cursor_t {
-    struct ecs_stack_cursor_t *prev;
-    struct ecs_stack_page_t *page;
-    int16_t sp;
-    bool is_free;
-#ifdef FLECS_DEBUG
-    struct ecs_stack_t *owner;
-#endif
-} ecs_stack_cursor_t;
 
 /* Page-iterator specific data */
 typedef struct ecs_page_iter_t {
@@ -122,86 +103,40 @@ typedef struct ecs_table_cache_iter_t {
     struct ecs_table_cache_hdr_t *next_list;
 } ecs_table_cache_iter_t;
 
-/** Term-iterator specific data */
-typedef struct ecs_term_iter_t {
-    ecs_term_t term;
-    ecs_id_record_t *self_index;
-    ecs_id_record_t *set_index;
-
-    ecs_id_record_t *cur;
+/** Each iterator */
+typedef struct ecs_each_iter_t {
     ecs_table_cache_iter_t it;
-    int32_t index;
-    int32_t observed_table_count;
-    
-    ecs_table_t *table;
-    int32_t cur_match;
-    int32_t match_count;
-    int32_t last_column;
 
-    bool empty_tables;
+    /* Storage for iterator fields */
+    ecs_id_t ids;
+    ecs_entity_t sources;
+    ecs_size_t sizes;
+    int32_t columns;
+    void *ptrs;
+} ecs_each_iter_t;
 
-    /* Storage */
-    ecs_id_t id;
-    int32_t column;
-    ecs_entity_t subject;
-    ecs_size_t size;
-    void *ptr;
-} ecs_term_iter_t;
-
-typedef enum ecs_iter_kind_t {
-    EcsIterEvalCondition,
-    EcsIterEvalTables,
-    EcsIterEvalChain,
-    EcsIterEvalNone
-} ecs_iter_kind_t;
-
-/** Filter-iterator specific data */
-typedef struct ecs_filter_iter_t {
-    const ecs_filter_t *filter;
-    ecs_iter_kind_t kind; 
-    ecs_term_iter_t term_iter;
-    int32_t matches_left;
-    int32_t pivot_term;
-} ecs_filter_iter_t;
-
-/** Query-iterator specific data */
-typedef struct ecs_query_iter_t {
-    ecs_query_t *query;
-    ecs_query_table_match_t *node, *prev, *last;
-    int32_t sparse_smallest;
-    int32_t sparse_first;
-    int32_t bitset_first;
-    int32_t skip_count;
-} ecs_query_iter_t;
-
-/** Snapshot-iterator specific data */
-typedef struct ecs_snapshot_iter_t {
-    ecs_filter_t filter;
-    ecs_vec_t tables; /* ecs_table_leaf_t */
-    int32_t index;
-} ecs_snapshot_iter_t;
-
-typedef struct ecs_rule_op_profile_t {
+typedef struct ecs_query_op_profile_t {
     int32_t count[2]; /* 0 = enter, 1 = redo */
-} ecs_rule_op_profile_t;
+} ecs_query_op_profile_t;
 
-/** Rule-iterator specific data */
-typedef struct ecs_rule_iter_t {
-    const ecs_rule_t *rule;
-    struct ecs_var_t *vars;              /* Variable storage */
-    const struct ecs_rule_var_t *rule_vars;
-    const struct ecs_rule_op_t *ops;
-    struct ecs_rule_op_ctx_t *op_ctx;    /* Operation-specific state */
+/** Query iterator */
+typedef struct ecs_query_iter_t {
+    const ecs_query_t *query;
+    struct ecs_var_t *vars;               /* Variable storage */
+    const struct ecs_query_var_t *query_vars;
+    const struct ecs_query_op_t *ops;
+    struct ecs_query_op_ctx_t *op_ctx;    /* Operation-specific state */
+    ecs_query_cache_table_match_t *node, *prev, *last; /* For cached iteration */
     uint64_t *written;
-    ecs_flags32_t source_set;
+    int32_t skip_count;
 
 #ifdef FLECS_DEBUG
-    ecs_rule_op_profile_t *profile;
+    ecs_query_op_profile_t *profile;
 #endif
 
     int16_t op;
     int16_t sp;
-} ecs_rule_iter_t;
+} ecs_query_iter_t;
 
 /* Bits for tracking whether a cache was used/whether the array was allocated.
  * Used by flecs_iter_init, flecs_iter_validate and ecs_iter_fini. 
@@ -210,8 +145,7 @@ typedef struct ecs_rule_iter_t {
 #define flecs_iter_cache_columns       (1u << 1u)
 #define flecs_iter_cache_sources       (1u << 2u)
 #define flecs_iter_cache_ptrs          (1u << 3u)
-#define flecs_iter_cache_match_indices (1u << 4u)
-#define flecs_iter_cache_variables     (1u << 5u)
+#define flecs_iter_cache_variables     (1u << 4u)
 #define flecs_iter_cache_all           (255)
 
 /* Inline iterator arrays to prevent allocations for small array sizes */
@@ -225,88 +159,16 @@ typedef struct ecs_iter_cache_t {
  * progress & to provide builtin storage. */
 typedef struct ecs_iter_private_t {
     union {
-        ecs_term_iter_t term;
-        ecs_filter_iter_t filter;
         ecs_query_iter_t query;
-        ecs_rule_iter_t rule;
-        ecs_snapshot_iter_t snapshot;
         ecs_page_iter_t page;
         ecs_worker_iter_t worker;
+        ecs_each_iter_t each;
     } iter;                       /* Iterator specific data */
 
-    void *entity_iter;            /* Filter applied after matching a table */
+    void *entity_iter;            /* Query applied after matching a table */
     ecs_iter_cache_t cache;       /* Inline arrays to reduce allocations */
 } ecs_iter_private_t;
 
-/** Iterator */
-struct ecs_iter_t {
-    /* World */
-    ecs_world_t *world;           /* The world */
-    ecs_world_t *real_world;      /* Actual world. This differs from world when in readonly mode */
-
-    /* Matched data */
-    ecs_entity_t *entities;       /* Entity identifiers */
-    void **ptrs;                  /* Pointers to components. Array if from this, pointer if not. */
-    ecs_size_t *sizes;            /* Component sizes */
-    ecs_table_t *table;           /* Current table */
-    ecs_table_t *other_table;     /* Prev or next table when adding/removing */
-    ecs_id_t *ids;                /* (Component) ids */
-    ecs_var_t *variables;         /* Values of variables (if any) */
-    int32_t *columns;             /* Query term to table column mapping */
-    ecs_entity_t *sources;        /* Entity on which the id was matched (0 if same as entities) */
-    int32_t *match_indices;       /* Indices of current match for term. Allows an iterator to iterate
-                                   * all permutations of wildcards in query. */
-    ecs_ref_t *references;        /* Cached refs to components (if iterating a cache) */
-    ecs_flags64_t constrained_vars; /* Bitset that marks constrained variables */
-    uint64_t group_id;            /* Group id for table, if group_by is used */
-    int32_t field_count;          /* Number of fields in iterator */
-
-    /* Input information */
-    ecs_entity_t system;          /* The system (if applicable) */
-    ecs_entity_t event;           /* The event (if applicable) */
-    ecs_id_t event_id;            /* The (component) id for the event */
-    int32_t event_cur;            /* Unique event id. Used to dedup observer calls */
-
-    /* Query information */
-    const ecs_filter_t *query;    /* Query being evaluated */
-    ecs_term_t *terms;            /* Term array of query being evaluated */
-    int32_t table_count;          /* Active table count for query */
-    int32_t term_index;           /* Index of term that emitted an event.
-                                   * This field will be set to the 'index' field
-                                   * of an observer term. */
-    int32_t variable_count;       /* Number of variables for query */
-    char **variable_names;        /* Names of variables (if any) */
-
-    /* Context */
-    void *param;                  /* Param passed to ecs_run */
-    void *ctx;                    /* System context */
-    void *binding_ctx;            /* Binding context */
-
-    /* Time */
-    ecs_ftime_t delta_time;       /* Time elapsed since last frame */
-    ecs_ftime_t delta_system_time;/* Time elapsed since last system invocation */
-
-    /* Iterator counters */
-    int32_t frame_offset;         /* Offset relative to start of iteration */
-    int32_t offset;               /* Offset relative to current table */
-    int32_t count;                /* Number of entities to iterate */
-    int32_t instance_count;       /* Number of entities to iterate before next table */
-
-    /* Iterator flags */
-    ecs_flags32_t flags;
-
-    ecs_entity_t interrupted_by;  /* When set, system execution is interrupted */
-
-    ecs_iter_private_t priv;      /* Private data */
-
-    /* Chained iterators */
-    ecs_iter_next_action_t next;  /* Function to progress iterator */
-    ecs_iter_action_t callback;   /* Callback of system or observer */
-    ecs_iter_action_t set_var;    /* Invoked after setting variable (optionally set) */
-    ecs_iter_fini_action_t fini;  /* Function to cleanup iterator resources */
-    ecs_iter_t *chain_it;         /* Optional, allows for creating iterator chains */
-};
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/flecs/private/switch_list.h b/include/flecs/private/switch_list.h
deleted file mode 100644
index 55fb1533a..000000000
--- a/include/flecs/private/switch_list.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/**
- * @file switch_list.h
- * @brief Interleaved linked list for storing mutually exclusive values.
- */
-
-#ifndef FLECS_SWITCH_LIST_H
-#define FLECS_SWITCH_LIST_H
-
-#include "flecs/private/api_defines.h"
-
-typedef struct ecs_switch_header_t {
-    int32_t element;    /* First element for value */
-    int32_t count;      /* Number of elements for value */
-} ecs_switch_header_t;
-
-typedef struct ecs_switch_node_t {
-    int32_t next;       /* Next node in list */
-    int32_t prev;       /* Prev node in list */
-} ecs_switch_node_t;
-
-struct ecs_switch_t {    
-    ecs_map_t hdrs;     /* map<uint64_t, ecs_switch_header_t> */
-    ecs_vec_t nodes;    /* vec<ecs_switch_node_t> */
-    ecs_vec_t values;   /* vec<uint64_t> */
-};
-
-/** Init new switch. */
-FLECS_DBG_API
-void flecs_switch_init(
-    ecs_switch_t* sw,
-    ecs_allocator_t *allocator,
-    int32_t elements);
-
-/** Fini switch. */
-FLECS_DBG_API
-void flecs_switch_fini(
-    ecs_switch_t *sw);
-
-/** Remove all values. */
-FLECS_DBG_API
-void flecs_switch_clear(
-    ecs_switch_t *sw);
-
-/** Add element to switch, initialize value to 0 */
-FLECS_DBG_API
-void flecs_switch_add(
-    ecs_switch_t *sw);
-
-/** Set number of elements in switch list */
-FLECS_DBG_API
-void flecs_switch_set_count(
-    ecs_switch_t *sw,
-    int32_t count);
-
-/** Get number of elements */
-FLECS_DBG_API
-int32_t flecs_switch_count(
-    ecs_switch_t *sw);
-
-/** Ensure that element exists. */
-FLECS_DBG_API
-void flecs_switch_ensure(
-    ecs_switch_t *sw,
-    int32_t count);
-
-/** Add n elements. */
-FLECS_DBG_API
-void flecs_switch_addn(
-    ecs_switch_t *sw,
-    int32_t count);    
-
-/** Set value of element. */
-FLECS_DBG_API
-void flecs_switch_set(
-    ecs_switch_t *sw,
-    int32_t element,
-    uint64_t value);
-
-/** Remove element. */
-FLECS_DBG_API
-void flecs_switch_remove(
-    ecs_switch_t *sw,
-    int32_t element);
-
-/** Get value for element. */
-FLECS_DBG_API
-uint64_t flecs_switch_get(
-    const ecs_switch_t *sw,
-    int32_t element);
-
-/** Swap element. */
-FLECS_DBG_API
-void flecs_switch_swap(
-    ecs_switch_t *sw,
-    int32_t elem_1,
-    int32_t elem_2);
-
-/** Get vector with all values. Use together with count(). */
-FLECS_DBG_API
-ecs_vec_t* flecs_switch_values(
-    const ecs_switch_t *sw);    
-
-/** Return number of different values. */
-FLECS_DBG_API
-int32_t flecs_switch_case_count(
-    const ecs_switch_t *sw,
-    uint64_t value);
-
-/** Return first element for value. */
-FLECS_DBG_API
-int32_t flecs_switch_first(
-    const ecs_switch_t *sw,
-    uint64_t value);
-
-/** Return next element for value. Use with first(). */
-FLECS_DBG_API
-int32_t flecs_switch_next(
-    const ecs_switch_t *sw,
-    int32_t elem);
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/meson.build b/meson.build
index c57bc27f7..51ae722fe 100644
--- a/meson.build
+++ b/meson.build
@@ -21,10 +21,6 @@ endif
 flecs_src = files(
     'src/addons/alerts.c',
     'src/addons/doc.c',
-    'src/addons/expr/deserialize.c',
-    'src/addons/expr/serialize.c',
-    'src/addons/expr/utils.c',
-    'src/addons/expr/vars.c',
     'src/addons/flecs_cpp.c',
     'src/addons/http.c',
     'src/addons/journal.c',
@@ -41,24 +37,28 @@ flecs_src = files(
     'src/addons/meta/meta.c',
     'src/addons/meta/serialized.c',
     'src/addons/meta/cursor.c',
-    'src/addons/meta_c.c',
+    'src/addons/meta/c_utils.c',
     'src/addons/metrics.c',
     'src/addons/module.c',
     'src/addons/monitor.c',
     'src/addons/os_api_impl/os_api_impl.c',
-    'src/addons/parser.c',
     'src/addons/pipeline/pipeline.c',
     'src/addons/pipeline/worker.c',
-    'src/addons/plecs.c',
     'src/addons/rest.c',
-    'src/addons/rules/api.c',
-    'src/addons/rules/compile.c',
-    'src/addons/rules/engine.c',
-    'src/addons/rules/trav_cache.c',
-    'src/addons/rules/trav_down_cache.c',
-    'src/addons/rules/trav_up_cache.c',
-    'src/addons/rules/trivial_iter.c',
-    'src/addons/snapshot.c',
+    'src/addons/script/assembly.c',
+    'src/addons/script/ast.c',
+    'src/addons/script/expr.c',
+    'src/addons/script/interpolate.c',
+    'src/addons/script/parser.c',
+    'src/addons/script/query_parser.c',
+    'src/addons/script/script.c',
+    'src/addons/script/serialize.c',
+    'src/addons/script/tokenizer.c',
+    'src/addons/script/vars.c',
+    'src/addons/script/visit_eval.c',
+    'src/addons/script/visit_free.c',
+    'src/addons/script/visit_to_str.c',
+    'src/addons/script/visit.c',
     'src/addons/stats.c',
     'src/addons/system/system.c',
     'src/addons/timer.c',
@@ -73,25 +73,37 @@ flecs_src = files(
     'src/datastructures/name_index.c',
     'src/datastructures/sparse.c',
     'src/datastructures/strbuf.c',
-    'src/datastructures/switch_list.c',
     'src/datastructures/vec.c',
     'src/storage/entity_index.c',
     'src/storage/id_index.c',
     'src/storage/table.c',
     'src/storage/table_cache.c',
     'src/storage/table_graph.c',
+    'src/query/api.c',
+    'src/query/cache_iter.c',
+    'src/query/cache_order_by.c',
+    'src/query/cache.c',
+    'src/query/change_detection.c',
+    'src/query/compiler_term.c',
+    'src/query/compiler.c',
+    'src/query/engine.c',
+    'src/query/trav_cache.c',
+    'src/query/trav_down_cache.c',
+    'src/query/trav_up_cache.c',
+    'src/query/trivial_iter.c',
+    'src/query/util.c',
+    'src/query/validator.c',
     'src/bootstrap.c',
-    'src/entity.c',
-    'src/entity_filter.c',
+    'src/each.c',
     'src/entity_name.c',
-    'src/filter.c',
+    'src/entity.c',
+    'src/id.c',
     'src/iter.c',
     'src/misc.c',
     'src/observable.c',
     'src/observer.c',
     'src/os_api.c',
     'src/poly.c',
-    'src/query.c',
     'src/stage.c',
     'src/search.c',
     'src/value.c',
diff --git a/src/addons/alerts.c b/src/addons/alerts.c
index ae30a817b..f745d58b9 100644
--- a/src/addons/alerts.c
+++ b/src/addons/alerts.c
@@ -239,20 +239,20 @@ ecs_entity_t flecs_alert_out_of_range_kind(
 static
 void MonitorAlerts(ecs_iter_t *it) {
     ecs_world_t *world = it->real_world;
-    EcsAlert *alert = ecs_field(it, EcsAlert, 1);
-    EcsPoly *poly = ecs_field(it, EcsPoly, 2);
+    EcsAlert *alert = ecs_field(it, EcsAlert, 0);
+    EcsPoly *poly = ecs_field(it, EcsPoly, 1);
 
     int32_t i, count = it->count;
     for (i = 0; i < count; i ++) {
         ecs_entity_t a = it->entities[i]; /* Alert entity */
         ecs_entity_t default_severity = ecs_get_target(
             world, a, ecs_id(EcsAlert), 0);
-        ecs_rule_t *rule = poly[i].poly;
-        if (!rule) {
+        ecs_query_t *q = poly[i].poly;
+        if (!q) {
             continue;
         }
 
-        ecs_poly_assert(rule, ecs_rule_t);
+        flecs_poly_assert(q, ecs_query_t);
 
         ecs_id_t member_id = alert[i].id;
         const EcsMemberRanges *ranges = NULL;
@@ -260,11 +260,11 @@ void MonitorAlerts(ecs_iter_t *it) {
             ranges = ecs_ref_get(world, &alert[i].ranges, EcsMemberRanges);
         }
 
-        ecs_iter_t rit = ecs_rule_iter(world, rule);
+        ecs_iter_t rit = ecs_query_iter(world, q);
         rit.flags |= EcsIterNoData;
         rit.flags |= EcsIterIsInstanced;
 
-        while (ecs_rule_next(&rit)) {
+        while (ecs_query_next(&rit)) {
             ecs_entity_t severity = flecs_alert_get_severity(
                 world, &rit, &alert[i]);
             if (!severity) {
@@ -350,10 +350,10 @@ void MonitorAlerts(ecs_iter_t *it) {
 static
 void MonitorAlertInstances(ecs_iter_t *it) {
     ecs_world_t *world = it->real_world;
-    EcsAlertInstance *alert_instance = ecs_field(it, EcsAlertInstance, 1);
-    EcsMetricSource *source = ecs_field(it, EcsMetricSource, 2);
-    EcsMetricValue *value = ecs_field(it, EcsMetricValue, 3);
-    EcsAlertTimeout *timeout = ecs_field(it, EcsAlertTimeout, 4);
+    EcsAlertInstance *alert_instance = ecs_field(it, EcsAlertInstance, 0);
+    EcsMetricSource *source = ecs_field(it, EcsMetricSource, 1);
+    EcsMetricValue *value = ecs_field(it, EcsMetricValue, 2);
+    EcsAlertTimeout *timeout = ecs_field(it, EcsAlertTimeout, 3);
 
     /* Get alert component from alert instance parent (the alert) */
     ecs_id_t childof_pair;
@@ -361,20 +361,23 @@ void MonitorAlertInstances(ecs_iter_t *it) {
         ecs_err("alert instances must be a child of an alert");
         return;
     }
+
     ecs_entity_t parent = ecs_pair_second(world, childof_pair);
     ecs_assert(parent != 0, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(ecs_has(world, parent, EcsAlert), ECS_INVALID_OPERATION,
         "alert entity does not have Alert component");
+
     EcsAlert *alert = ecs_ensure(world, parent, EcsAlert);
     const EcsPoly *poly = ecs_get_pair(world, parent, EcsPoly, EcsQuery);
     ecs_assert(poly != NULL, ECS_INVALID_OPERATION, 
         "alert entity does not have (Poly, Query) component");
-    ecs_rule_t *rule = poly->poly;
-    if (!rule) {
+
+    ecs_query_t *query = poly->poly;
+    if (!query) {
         return;
     }
 
-    ecs_poly_assert(rule, ecs_rule_t);
+    flecs_poly_assert(query, ecs_query_t);
 
     ecs_id_t member_id = alert->id;
     const EcsMemberRanges *ranges = NULL;
@@ -382,9 +385,7 @@ void MonitorAlertInstances(ecs_iter_t *it) {
         ranges = ecs_ref_get(world, &alert->ranges, EcsMemberRanges);
     }
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
+    ecs_script_vars_t *vars = ecs_script_vars_init(it->world);
     int32_t i, count = it->count;
     for (i = 0; i < count; i ++) {
         ecs_entity_t ai = it->entities[i];
@@ -397,13 +398,13 @@ void MonitorAlertInstances(ecs_iter_t *it) {
             continue;
         }
 
-        /* Check if alert instance still matches rule */
-        ecs_iter_t rit = ecs_rule_iter(world, rule);
+        /* Check if alert instance still matches query */
+        ecs_iter_t rit = ecs_query_iter(world, query);
         rit.flags |= EcsIterNoData;
         rit.flags |= EcsIterIsInstanced;
         ecs_iter_set_var(&rit, 0, e);
 
-        if (ecs_rule_next(&rit)) {
+        if (ecs_query_next(&rit)) {
             bool match = true;
 
             /* If alert is monitoring member range, test value against range */
@@ -435,7 +436,7 @@ void MonitorAlertInstances(ecs_iter_t *it) {
                 if (generate_message) {
                     if (alert_instance[i].message) {
                         /* If a message was already generated, only regenerate if
-                        * rule has multiple variables. Variable values could have 
+                        * query has multiple variables. Variable values could have 
                         * changed, this ensures the message remains up to date. */
                         generate_message = rit.variable_count > 1;
                     }
@@ -446,9 +447,9 @@ void MonitorAlertInstances(ecs_iter_t *it) {
                         ecs_os_free(alert_instance[i].message);
                     }
 
-                    ecs_iter_to_vars(&rit, &vars, 0);
-                    alert_instance[i].message = ecs_interpolate_string(
-                        world, alert->message, &vars);
+                    ecs_script_vars_from_iter(&rit, vars, 0);
+                    alert_instance[i].message = ecs_script_string_interpolate(
+                        world, alert->message, vars);
                 }
 
                 if (timeout) {
@@ -460,7 +461,7 @@ void MonitorAlertInstances(ecs_iter_t *it) {
                     timeout[i].inactive_time = 0;
                 }
 
-                /* Alert instance still matches rule, keep it alive */
+                /* Alert instance still matches query, keep it alive */
                 ecs_iter_fini(&rit);
                 continue;
             }
@@ -469,7 +470,6 @@ void MonitorAlertInstances(ecs_iter_t *it) {
         }
 
         /* Alert instance is no longer active */
-
         if (timeout) {
             if (ECS_EQZERO(timeout[i].inactive_time)) {
                 /* The alert just became inactive. Add Disabled tag */
@@ -479,49 +479,49 @@ void MonitorAlertInstances(ecs_iter_t *it) {
             ecs_ftime_t t = timeout[i].inactive_time;
             timeout[i].inactive_time += it->delta_system_time;
             if (t < timeout[i].expire_time) {
-                /* Alert instance no longer matches rule, but is still
+                /* Alert instance no longer matches query, but is still
                     * within the timeout period. Keep it alive. */
                 continue;
             }
         }
 
-        /* Alert instance no longer matches rule, remove it */        
+        /* Alert instance no longer matches query, remove it */ 
         flecs_alerts_remove_alert_from_src(world, e, parent);
         ecs_map_remove(&alert->instances, e);
         ecs_delete(world, ai);
     }
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 }
 
 ecs_entity_t ecs_alert_init(
     ecs_world_t *world,
     const ecs_alert_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!desc->filter.entity || desc->entity == desc->filter.entity, 
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_alert_desc_t was not initialized to zero");
+    ecs_check(!desc->query.entity || desc->entity == desc->query.entity, 
         ECS_INVALID_PARAMETER, NULL);
 
     ecs_entity_t result = desc->entity;
     if (!result) {
-        result = ecs_new(world, 0);
+        result = ecs_new(world);
     }
 
-    ecs_filter_desc_t private_desc = desc->filter;
+    ecs_query_desc_t private_desc = desc->query;
     private_desc.entity = result;
 
-    ecs_rule_t *rule = ecs_rule_init(world, &private_desc);
-    if (!rule) {
+    ecs_query_t *q = ecs_query_init(world, &private_desc);
+    if (!q) {
         ecs_err("failed to create alert filter");
         return 0;
     }
 
-    const ecs_filter_t *filter = ecs_rule_get_filter(rule);
-    if (!(filter->flags & EcsFilterMatchThis)) {
+    if (!(q->flags & EcsQueryMatchThis)) {
         ecs_err("alert filter must have at least one '$this' term");
-        ecs_rule_fini(rule);
+        ecs_query_fini(q);
         return 0;
     }
 
@@ -543,7 +543,7 @@ ecs_entity_t ecs_alert_init(
                 &alert->severity_filters, ecs_alert_severity_filter_t);
             *sf = desc->severity_filters[i];
             if (sf->var) {
-                sf->_var_index = ecs_rule_find_var(rule, sf->var);
+                sf->_var_index = ecs_query_find_var(q, sf->var);
                 if (sf->_var_index == -1) {
                     ecs_err("unresolved variable '%s' in alert severity filter", 
                         sf->var);
@@ -606,7 +606,7 @@ ecs_entity_t ecs_alert_init(
 
         int32_t var_id = 0;
         if (desc->var) {
-            var_id = ecs_rule_find_var(rule, desc->var);
+            var_id = ecs_query_find_var(q, desc->var);
             if (var_id == -1) {
                 ecs_err("unresolved variable '%s' in alert member", desc->var);
                 goto error;
@@ -665,7 +665,7 @@ int32_t ecs_get_alert_count(
     ecs_entity_t entity,
     ecs_entity_t alert)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
     ecs_check(!alert || ecs_has(world, alert, EcsAlert), 
         ECS_INVALID_PARAMETER, NULL);
@@ -689,7 +689,7 @@ ecs_entity_t ecs_get_alert(
     ecs_entity_t entity,
     ecs_entity_t alert)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
     ecs_check(alert != 0, ECS_INVALID_PARAMETER, NULL);
 
@@ -731,7 +731,7 @@ void FlecsAlertsImport(ecs_world_t *world) {
     ECS_TAG_DEFINE(world, EcsAlertError);
     ECS_TAG_DEFINE(world, EcsAlertCritical);
 
-    ecs_add_id(world, ecs_id(EcsAlert), EcsTag);
+    ecs_add_id(world, ecs_id(EcsAlert), EcsPairIsTag);
     ecs_add_id(world, ecs_id(EcsAlert), EcsExclusive);
     ecs_add_id(world, ecs_id(EcsAlertsActive), EcsPrivate);
 
@@ -755,7 +755,7 @@ void FlecsAlertsImport(ecs_world_t *world) {
     });
 
     ecs_set_hooks(world, EcsAlertInstance, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(EcsAlertInstance),
         .move = ecs_move(EcsAlertInstance),
         .copy = ecs_copy(EcsAlertInstance)
@@ -770,13 +770,19 @@ void FlecsAlertsImport(ecs_world_t *world) {
         }
     });
 
-    ECS_SYSTEM(world, MonitorAlerts, EcsPreStore, Alert, (Poly, Query));
+    ECS_SYSTEM(world, MonitorAlerts, EcsPreStore, 
+        Alert, 
+        (Poly, Query));
+
     ECS_SYSTEM(world, MonitorAlertInstances, EcsOnStore, Instance, 
-        flecs.metrics.Source, flecs.metrics.Value, ?EcsAlertTimeout, ?Disabled);
+        flecs.metrics.Source, 
+        flecs.metrics.Value, 
+        ?Timeout,
+        ?Disabled);
 
     ecs_system(world, {
         .entity = ecs_id(MonitorAlerts),
-        .no_readonly = true,
+        .immediate = true,
         .interval = (ecs_ftime_t)0.5
     });
 
diff --git a/src/addons/app.c b/src/addons/app.c
index c038649d0..edd162b97 100644
--- a/src/addons/app.c
+++ b/src/addons/app.c
@@ -70,7 +70,7 @@ char* flecs_explorer_request(const char *method, char *request) {
         if (body) {
             return body;
         } else {
-            return ecs_asprintf(
+            return flecs_asprintf(
                 "{\"error\": \"bad request (code %d)\"}", reply.code);
         }
     }
diff --git a/src/addons/doc.c b/src/addons/doc.c
index b6d139163..01aa1d89b 100644
--- a/src/addons/doc.c
+++ b/src/addons/doc.c
@@ -162,11 +162,7 @@ void flecs_doc_import_core_definitions(
     ecs_doc_set_brief(world, EcsDisabled, "Tag that is added to disabled entities");
     ecs_doc_set_brief(world, EcsPrivate, "Tag that is added to private components");
     ecs_doc_set_brief(world, EcsFlag, "Internal tag for tracking ids with special id flags");
-    ecs_doc_set_brief(world, ecs_id(EcsIterable), "Internal component to make (query) entities iterable");
     ecs_doc_set_brief(world, ecs_id(EcsPoly), "Internal component that stores pointer to poly objects");
-    
-    ecs_doc_set_brief(world, ecs_id(EcsFlattenTarget), "Internal component that stores information for flattened trees");
-    ecs_doc_set_brief(world, EcsFlatten, "Tag that when added to assembly automatically flattens tree");
 
     ecs_doc_set_brief(world, ecs_id(EcsIdentifier), "Component used for entity names");
     ecs_doc_set_brief(world, EcsName, "Tag used with EcsIdentifier to store entity name");
@@ -180,21 +176,20 @@ void flecs_doc_import_core_definitions(
     ecs_doc_set_brief(world, EcsReflexive, "Trait that enables reflexive evaluation of relationships");
     ecs_doc_set_brief(world, EcsFinal, "Trait that indicates an entity cannot be inherited from");
     ecs_doc_set_brief(world, EcsDontInherit, "Trait that indicates it should not be inherited");
-    ecs_doc_set_brief(world, EcsTag, "Trait that ensures a pair cannot contain a value");
+    ecs_doc_set_brief(world, EcsPairIsTag, "Trait that ensures a pair cannot contain a value");
     ecs_doc_set_brief(world, EcsAcyclic, "Trait that indicates a relationship is acyclic");
     ecs_doc_set_brief(world, EcsTraversable, "Trait that indicates a relationship is traversable");
     ecs_doc_set_brief(world, EcsExclusive, "Trait that ensures a relationship can only have one target");
     ecs_doc_set_brief(world, EcsSymmetric, "Trait that causes a relationship to be two-way");
     ecs_doc_set_brief(world, EcsWith, "Trait for adding additional components when a component is added");
     ecs_doc_set_brief(world, EcsAlwaysOverride, "Trait that indicates a component should always be overridden");
-    ecs_doc_set_brief(world, EcsUnion, "Trait for creating a non-fragmenting relationship");
     ecs_doc_set_brief(world, EcsOneOf, "Trait that enforces target of relationship is a child of <specified>");
     ecs_doc_set_brief(world, EcsOnDelete, "Cleanup trait for specifying what happens when component is deleted");
     ecs_doc_set_brief(world, EcsOnDeleteTarget, "Cleanup trait for specifying what happens when pair target is deleted");
     ecs_doc_set_brief(world, EcsRemove, "Cleanup action used with OnDelete/OnDeleteTarget");
     ecs_doc_set_brief(world, EcsDelete, "Cleanup action used with OnDelete/OnDeleteTarget");
     ecs_doc_set_brief(world, EcsPanic, "Cleanup action used with OnDelete/OnDeleteTarget");
-    ecs_doc_set_brief(world, EcsDefaultChildComponent, "Sets default component hint for children of entity");
+    ecs_doc_set_brief(world, ecs_id(EcsDefaultChildComponent), "Sets default component hint for children of entity");
     ecs_doc_set_brief(world, EcsIsA, "Relationship used for expressing inheritance");
     ecs_doc_set_brief(world, EcsChildOf, "Relationship used for expressing hierarchies");
     ecs_doc_set_brief(world, EcsDependsOn, "Relationship used for expressing dependencies");
@@ -254,7 +249,7 @@ void FlecsDocImport(
     flecs_bootstrap_tag(world, EcsDocColor);
 
     ecs_set_hooks(world, EcsDocDescription, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsDocDescription),
         .copy = ecs_copy(EcsDocDescription),
         .dtor = ecs_dtor(EcsDocDescription)
diff --git a/src/addons/expr/utils.c b/src/addons/expr/utils.c
deleted file mode 100644
index f5b9c138c..000000000
--- a/src/addons/expr/utils.c
+++ /dev/null
@@ -1,436 +0,0 @@
-/**
- * @file expr/utils.c
- * @brief String parsing utilities.
- */
-
-#include "../../private_api.h"
-
-#ifdef FLECS_EXPR
-
-#include <ctype.h>
-
-char* ecs_chresc(
-    char *out, 
-    char in, 
-    char delimiter) 
-{
-    char *bptr = out;
-    switch(in) {
-    case '\a':
-        *bptr++ = '\\';
-        *bptr = 'a';
-        break;
-    case '\b':
-        *bptr++ = '\\';
-        *bptr = 'b';
-        break;
-    case '\f':
-        *bptr++ = '\\';
-        *bptr = 'f';
-        break;
-    case '\n':
-        *bptr++ = '\\';
-        *bptr = 'n';
-        break;
-    case '\r':
-        *bptr++ = '\\';
-        *bptr = 'r';
-        break;
-    case '\t':
-        *bptr++ = '\\';
-        *bptr = 't';
-        break;
-    case '\v':
-        *bptr++ = '\\';
-        *bptr = 'v';
-        break;
-    case '\\':
-        *bptr++ = '\\';
-        *bptr = '\\';
-        break;
-    case '\033':
-        *bptr = '['; /* Used for terminal colors */
-        break;
-    default:
-        if (in == delimiter) {
-            *bptr++ = '\\';
-            *bptr = delimiter;
-        } else {
-            *bptr = in;
-        }
-        break;
-    }
-
-    *(++bptr) = '\0';
-
-    return bptr;
-}
-
-const char* ecs_chrparse(
-    const char *in, 
-    char *out) 
-{
-    const char *result = in + 1;
-    char ch;
-
-    if (in[0] == '\\') {
-        result ++;
-
-        switch(in[1]) {
-        case 'a':
-            ch = '\a';
-            break;
-        case 'b':
-            ch = '\b';
-            break;
-        case 'f':
-            ch = '\f';
-            break;
-        case 'n':
-            ch = '\n';
-            break;
-        case 'r':
-            ch = '\r';
-            break;
-        case 't':
-            ch = '\t';
-            break;
-        case 'v':
-            ch = '\v';
-            break;
-        case '\\':
-            ch = '\\';
-            break;
-        case '"':
-            ch = '"';
-            break;
-        case '0':
-            ch = '\0';
-            break;
-        case ' ':
-            ch = ' ';
-            break;
-        case '$':
-            ch = '$';
-            break;
-        default:
-            goto error;
-        }
-    } else {
-        ch = in[0];
-    }
-
-    if (out) {
-        *out = ch;
-    }
-
-    return result;
-error:
-    return NULL;
-}
-
-ecs_size_t ecs_stresc(
-    char *out, 
-    ecs_size_t n, 
-    char delimiter, 
-    const char *in) 
-{
-    const char *ptr = in;
-    char ch, *bptr = out, buff[3];
-    ecs_size_t written = 0;
-    while ((ch = *ptr++)) {
-        if ((written += (ecs_size_t)(ecs_chresc(
-            buff, ch, delimiter) - buff)) <= n) 
-        {
-            /* If size != 0, an out buffer must be provided. */
-            ecs_check(out != NULL, ECS_INVALID_PARAMETER, NULL);
-            *bptr++ = buff[0];
-            if ((ch = buff[1])) {
-                *bptr = ch;
-                bptr++;
-            }
-        }
-    }
-
-    if (bptr) {
-        while (written < n) {
-            *bptr = '\0';
-            bptr++;
-            written++;
-        }
-    }
-    return written;
-error:
-    return 0;
-}
-
-char* ecs_astresc(
-    char delimiter, 
-    const char *in)
-{
-    if (!in) {
-        return NULL;
-    }
-
-    ecs_size_t len = ecs_stresc(NULL, 0, delimiter, in);
-    char *out = ecs_os_malloc_n(char, len + 1);
-    ecs_stresc(out, len, delimiter, in);
-    out[len] = '\0';
-    return out;
-}
-
-static
-const char* flecs_parse_var_name(
-    const char *ptr,
-    char *token_out)
-{
-    char ch, *bptr = token_out;
-
-    while ((ch = *ptr)) {
-        if (bptr - token_out > ECS_MAX_TOKEN_SIZE) {
-            goto error;
-        }
-
-        if (isalpha(ch) || isdigit(ch) || ch == '_') {
-            *bptr = ch;
-            bptr ++;
-            ptr ++;
-        } else {
-            break;
-        }
-    }
-
-    if (bptr == token_out) {
-        goto error;
-    }
-
-    *bptr = '\0';
-
-    return ptr;
-error:
-    return NULL;
-}
-
-static
-const char* flecs_parse_interpolated_str(
-    const char *ptr,
-    char *token_out)
-{
-    char ch, *bptr = token_out;
-
-    while ((ch = *ptr)) {
-        if (bptr - token_out > ECS_MAX_TOKEN_SIZE) {
-            goto error;
-        }
-
-        if (ch == '\\') {
-            if (ptr[1] == '}') {
-                *bptr = '}';
-                bptr ++;
-                ptr += 2;
-                continue;
-            }
-        }
-
-        if (ch != '}') {
-            *bptr = ch;
-            bptr ++;
-            ptr ++;
-        } else {
-            ptr ++;
-            break;
-        }
-    }
-
-    if (bptr == token_out) {
-        goto error;
-    }
-
-    *bptr = '\0';
-
-    return ptr;
-error:
-    return NULL;
-}
-
-char* ecs_interpolate_string(
-    ecs_world_t *world,
-    const char *str,
-    const ecs_vars_t *vars)
-{
-    char token[ECS_MAX_TOKEN_SIZE];
-    ecs_strbuf_t result = ECS_STRBUF_INIT;
-    const char *ptr;
-    char ch;
-
-    for(ptr = str; (ch = *ptr); ptr++) {
-        if (ch == '\\') {
-            ptr ++;
-            if (ptr[0] == '$') {
-                ecs_strbuf_appendch(&result, '$');
-                continue;
-            }
-            if (ptr[0] == '\\') {
-                ecs_strbuf_appendch(&result, '\\');
-                continue;
-            }
-            if (ptr[0] == '{') {
-                ecs_strbuf_appendch(&result, '{');
-                continue;
-            }
-            if (ptr[0] == '}') {
-                ecs_strbuf_appendch(&result, '}');
-                continue;
-            }
-            ptr --;
-        }
-
-        if (ch == '$') {
-            ptr = flecs_parse_var_name(ptr + 1, token);
-            if (!ptr) {
-                ecs_parser_error(NULL, str, ptr - str, 
-                    "invalid variable name '%s'", ptr);
-                goto error;
-            }
-
-            ecs_expr_var_t *var = ecs_vars_lookup(vars, token);
-            if (!var) {
-                ecs_parser_error(NULL, str, ptr - str, 
-                    "unresolved variable '%s'", token);
-                goto error;
-            }
-
-            if (ecs_ptr_to_str_buf(
-                world, var->value.type, var->value.ptr, &result)) 
-            {
-                goto error;
-            }
-
-            ptr --;
-        } else if (ch == '{') {
-            ptr = flecs_parse_interpolated_str(ptr + 1, token);
-            if (!ptr) {
-                ecs_parser_error(NULL, str, ptr - str, 
-                    "invalid interpolated expression");
-                goto error;
-            }
-
-            ecs_parse_expr_desc_t expr_desc = { 
-                .vars = ECS_CONST_CAST(ecs_vars_t*, vars) 
-            };
-            ecs_value_t expr_result = {0};
-            if (!ecs_parse_expr(world, token, &expr_result, &expr_desc)) {
-                goto error;
-            }
-
-            if (ecs_ptr_to_str_buf(
-                world, expr_result.type, expr_result.ptr, &result)) 
-            {
-                goto error;
-            }
-
-            ecs_value_free(world, expr_result.type, expr_result.ptr);
-
-            ptr --;
-        } else {
-            ecs_strbuf_appendch(&result, ch);
-        }
-    }
-
-    return ecs_strbuf_get(&result);
-error:
-    return NULL;
-}
-
-void ecs_iter_to_vars(
-    const ecs_iter_t *it,
-    ecs_vars_t *vars,
-    int offset)
-{
-    ecs_check(vars != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!offset || offset < it->count, ECS_INVALID_PARAMETER, NULL);
-
-    /* Set variable for $this */
-    if (it->count) {
-        ecs_expr_var_t *var = ecs_vars_lookup(vars, "this");
-        if (!var) {
-            ecs_value_t v = { 
-                .ptr = &it->entities[offset], 
-                .type = ecs_id(ecs_entity_t) 
-            };
-            var = ecs_vars_declare_w_value(vars, "this", &v);
-            var->owned = false;
-        } else {
-            var->value.ptr = &it->entities[offset];
-        }
-    }
-
-    /* Set variables for fields */
-    {
-        int32_t i, field_count = it->field_count;
-        for (i = 0; i < field_count; i ++) {
-            ecs_size_t size = it->sizes[i];
-            if (!size) {
-                continue;
-            }
-
-            void *ptr = it->ptrs[i];
-            if (!ptr) {
-                continue;
-            }
-
-            ptr = ECS_OFFSET(ptr, offset * size);
-
-            char name[16];
-            ecs_os_sprintf(name, "%d", i + 1);
-            ecs_expr_var_t *var = ecs_vars_lookup(vars, name);
-            if (!var) {
-                ecs_value_t v = { .ptr = ptr, .type = it->ids[i] };
-                var = ecs_vars_declare_w_value(vars, name, &v);
-                var->owned = false;
-            } else {
-                ecs_check(var->value.type == it->ids[i], 
-                    ECS_INVALID_PARAMETER, NULL);
-                var->value.ptr = ptr;
-            }
-        }
-    }
-
-    /* Set variables for query variables */
-    {
-        int32_t i, var_count = it->variable_count;
-        for (i = 1 /* skip this variable */ ; i < var_count; i ++) {
-            ecs_entity_t *e_ptr = NULL;
-            ecs_var_t *query_var = &it->variables[i];
-            if (query_var->entity) {
-                e_ptr = &query_var->entity;
-            } else {
-                ecs_table_range_t *range = &query_var->range;
-                if (range->count == 1) {
-                    ecs_entity_t *entities = range->table->data.entities.array;
-                    e_ptr = &entities[range->offset];
-                }
-            }
-            if (!e_ptr) {
-                continue;
-            }
-
-            ecs_expr_var_t *var = ecs_vars_lookup(vars, it->variable_names[i]);
-            if (!var) {
-                ecs_value_t v = { .ptr = e_ptr, .type = ecs_id(ecs_entity_t) };
-                var = ecs_vars_declare_w_value(vars, it->variable_names[i], &v);
-                var->owned = false;
-            } else {
-                ecs_check(var->value.type == ecs_id(ecs_entity_t), 
-                    ECS_INVALID_PARAMETER, NULL);
-                var->value.ptr = e_ptr;
-            }
-        }
-    }
-
-error:
-    return;
-}
-
-#endif
diff --git a/src/addons/expr/vars.c b/src/addons/expr/vars.c
deleted file mode 100644
index 8e2b51613..000000000
--- a/src/addons/expr/vars.c
+++ /dev/null
@@ -1,175 +0,0 @@
-/**
- * @file expr/vars.c
- * @brief Utilities for variable substitution in flecs string expressions.
- */
-
-#include "../../private_api.h"
-
-#ifdef FLECS_EXPR
-
-static
-void flecs_expr_var_scope_init(
-    ecs_world_t *world,
-    ecs_expr_var_scope_t *scope,
-    ecs_expr_var_scope_t *parent)
-{
-    flecs_name_index_init(&scope->var_index, &world->allocator);
-    ecs_vec_init_t(&world->allocator, &scope->vars, ecs_expr_var_t, 0);
-    scope->parent = parent;
-}
-
-static
-void flecs_expr_var_scope_fini(
-    ecs_world_t *world,
-    ecs_expr_var_scope_t *scope)
-{
-    ecs_vec_t *vars = &scope->vars;
-    int32_t i, count = vars->count;
-    for (i = 0; i < count; i++) {
-        ecs_expr_var_t *var = ecs_vec_get_t(vars, ecs_expr_var_t, i);
-        if (var->owned) {
-            ecs_value_free(world, var->value.type, var->value.ptr);
-        }
-        flecs_strfree(&world->allocator, var->name);
-    }
-
-    ecs_vec_fini_t(&world->allocator, &scope->vars, ecs_expr_var_t);
-    flecs_name_index_fini(&scope->var_index);
-}
-
-void ecs_vars_init(
-    ecs_world_t *world,
-    ecs_vars_t *vars)
-{
-    flecs_expr_var_scope_init(world, &vars->root, NULL);
-    vars->world = world;
-    vars->cur = &vars->root;
-}
-
-void ecs_vars_fini(
-    ecs_vars_t *vars)
-{
-    ecs_expr_var_scope_t *cur = vars->cur, *next;
-    do {
-        next = cur->parent;
-        flecs_expr_var_scope_fini(vars->world, cur);
-        if (cur != &vars->root) {
-            flecs_free_t(&vars->world->allocator, ecs_expr_var_scope_t, cur);
-        } else {
-            break;
-        }
-    } while ((cur = next));
-}
-
-void ecs_vars_push(
-    ecs_vars_t *vars)
-{
-    ecs_expr_var_scope_t *scope = flecs_calloc_t(&vars->world->allocator, 
-        ecs_expr_var_scope_t);
-    flecs_expr_var_scope_init(vars->world, scope, vars->cur);
-    vars->cur = scope;
-}
-
-int ecs_vars_pop(
-    ecs_vars_t *vars)
-{
-    ecs_expr_var_scope_t *scope = vars->cur;
-    ecs_check(scope != &vars->root, ECS_INVALID_OPERATION, NULL);
-    vars->cur = scope->parent;
-    flecs_expr_var_scope_fini(vars->world, scope);
-    flecs_free_t(&vars->world->allocator, ecs_expr_var_scope_t, scope);
-    return 0;
-error:
-    return 1;
-}
-
-ecs_expr_var_t* ecs_vars_declare(
-    ecs_vars_t *vars,
-    const char *name,
-    ecs_entity_t type)
-{
-    ecs_assert(vars != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(name != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(type != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_expr_var_scope_t *scope = vars->cur;
-    ecs_hashmap_t *var_index = &scope->var_index;
-
-    if (flecs_name_index_find(var_index, name, 0, 0) != 0) {
-        ecs_err("variable %s redeclared", name);
-        goto error;
-    }
-
-    ecs_expr_var_t *var = ecs_vec_append_t(&vars->world->allocator, 
-        &scope->vars, ecs_expr_var_t);
-    
-    var->value.ptr = ecs_value_new(vars->world, type);
-    if (!var->value.ptr) {
-        goto error;
-    }
-    var->value.type = type;
-    var->name = flecs_strdup(&vars->world->allocator, name);
-    var->owned = true;
-
-    flecs_name_index_ensure(var_index, 
-        flecs_ito(uint64_t, ecs_vec_count(&scope->vars)), var->name, 0, 0);
-    return var;
-error:
-    return NULL;
-}
-
-ecs_expr_var_t* ecs_vars_declare_w_value(
-    ecs_vars_t *vars,
-    const char *name,
-    ecs_value_t *value)
-{
-    ecs_assert(vars != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(name != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(value != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_expr_var_scope_t *scope = vars->cur;
-    ecs_hashmap_t *var_index = &scope->var_index;
-
-    if (flecs_name_index_find(var_index, name, 0, 0) != 0) {
-        ecs_err("variable %s redeclared", name);
-        ecs_value_free(vars->world, value->type, value->ptr);
-        goto error;
-    }
-
-    ecs_expr_var_t *var = ecs_vec_append_t(&vars->world->allocator, 
-        &scope->vars, ecs_expr_var_t);
-    var->value = *value;
-    var->name = flecs_strdup(&vars->world->allocator, name);
-    var->owned = true;
-    value->ptr = NULL; /* Take ownership, prevent double free */
-
-    flecs_name_index_ensure(var_index, 
-        flecs_ito(uint64_t, ecs_vec_count(&scope->vars)), var->name, 0, 0);
-    return var;
-error:
-    return NULL;
-}
-
-static
-ecs_expr_var_t* flecs_vars_scope_lookup(
-    ecs_expr_var_scope_t *scope,
-    const char *name)
-{
-    uint64_t var_id = flecs_name_index_find(&scope->var_index, name, 0, 0);
-    if (var_id == 0) {
-        if (scope->parent) {
-            return flecs_vars_scope_lookup(scope->parent, name);
-        }
-        return NULL;
-    }
-
-    return ecs_vec_get_t(&scope->vars, ecs_expr_var_t, 
-        flecs_uto(int32_t, var_id - 1));
-}
-
-ecs_expr_var_t* ecs_vars_lookup(
-    const ecs_vars_t *vars,
-    const char *name)
-{
-    return flecs_vars_scope_lookup(vars->cur, name);
-}
-
-#endif
diff --git a/src/addons/flecs_cpp.c b/src/addons/flecs_cpp.c
index 90faf532b..cc147eed9 100644
--- a/src/addons/flecs_cpp.c
+++ b/src/addons/flecs_cpp.c
@@ -186,9 +186,12 @@ const char* ecs_cpp_trim_module(
         if (!ecs_os_strncmp(path, type_name, len)) {
             // Type is a child of current parent, trim name of parent
             type_name += len;
-            ecs_assert(type_name[0], ECS_INVALID_PARAMETER, NULL);
-            ecs_assert(type_name[0] == ':', ECS_INVALID_PARAMETER, NULL);
-            ecs_assert(type_name[1] == ':', ECS_INVALID_PARAMETER, NULL);
+            ecs_assert(type_name[0], ECS_INVALID_PARAMETER, 
+                "invalid C++ type name");
+            ecs_assert(type_name[0] == ':', ECS_INVALID_PARAMETER,
+                "invalid C++ type name");
+            ecs_assert(type_name[1] == ':', ECS_INVALID_PARAMETER,
+                "invalid C++ type name");
             type_name += 2;
         } else {
             // Type is not a child of current parent, trim entire path
@@ -399,14 +402,16 @@ ecs_entity_t ecs_cpp_component_register_explicit(
             .symbol = symbol,
             .use_low_id = true
         });
-        ecs_assert(entity != 0, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(entity != 0, ECS_INVALID_OPERATION, 
+            "registration failed for component %s", name);
 
         entity = ecs_component_init(world, &(ecs_component_desc_t){
             .entity = entity,
             .type.size = flecs_uto(int32_t, size),
             .type.alignment = flecs_uto(int32_t, alignment)
         });
-        ecs_assert(entity != 0, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(entity != 0, ECS_INVALID_OPERATION, 
+            "registration failed for component %s", name);
     } else {
         entity = ecs_entity(world, {
             .id = s_id,
diff --git a/src/addons/http.c b/src/addons/http.c
index 901f925ec..5ae074e45 100644
--- a/src/addons/http.c
+++ b/src/addons/http.c
@@ -1551,8 +1551,10 @@ void ecs_http_server_stop(
     ecs_http_server_t* srv) 
 {
     ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(srv->initialized, ECS_INVALID_OPERATION, NULL);
-    ecs_check(srv->should_run, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(srv->initialized, ECS_INVALID_OPERATION, 
+        "cannot stop HTTP server: not initialized");
+    ecs_check(srv->should_run, ECS_INVALID_PARAMETER, 
+        "cannot stop HTTP server: already stopped/stopping");
 
     /* Stop server thread */
     ecs_dbg("http: shutting down server thread");
diff --git a/src/addons/journal.c b/src/addons/journal.c
index 69e219615..85e643754 100644
--- a/src/addons/journal.c
+++ b/src/addons/journal.c
@@ -15,13 +15,13 @@ char* flecs_journal_entitystr(
     char *path;
     const char *_path = ecs_get_symbol(world, entity);
     if (_path && !strchr(_path, '.')) {
-        path = ecs_asprintf("#[blue]%s", _path);
+        path = flecs_asprintf("#[blue]%s", _path);
     } else {
         uint32_t gen = entity >> 32;
         if (gen) {
-            path = ecs_asprintf("#[normal]_%u_%u", (uint32_t)entity, gen);
+            path = flecs_asprintf("#[normal]_%u_%u", (uint32_t)entity, gen);
         } else {
-            path = ecs_asprintf("#[normal]_%u", (uint32_t)entity);
+            path = flecs_asprintf("#[normal]_%u", (uint32_t)entity);
         }
     }
     return path;
@@ -37,7 +37,7 @@ char* flecs_journal_idstr(
             ecs_pair_first(world, id));
         char *second_path = flecs_journal_entitystr(world, 
             ecs_pair_second(world, id));
-        char *result = ecs_asprintf("#[cyan]ecs_pair#[normal](%s, %s)",
+        char *result = flecs_asprintf("#[cyan]ecs_pair#[normal](%s, %s)",
             first_path, second_path);
         ecs_os_free(first_path);
         ecs_os_free(second_path);
diff --git a/src/addons/json/deserialize.c b/src/addons/json/deserialize.c
index 089f8c6ce..1b5836a94 100644
--- a/src/addons/json/deserialize.c
+++ b/src/addons/json/deserialize.c
@@ -338,7 +338,7 @@ const char* ecs_entity_from_json(
                     ecs_parser_error(name, expr, values - expr, "expected ']'");
                     goto error;
                 }
-                json = ecs_parse_ws_eol(values + 1);
+                json = flecs_parse_ws_eol(values + 1);
             } else {
                 json = ids;
             }
@@ -433,7 +433,7 @@ const char* ecs_entity_from_json(
                     "expected ',' or ']'");
                 goto error;
             } else {
-                values = ecs_parse_ws_eol(values);
+                values = flecs_parse_ws_eol(values);
             }
 
             ecs_modified_id(world, e, id);
@@ -454,7 +454,7 @@ ecs_entity_t flecs_json_new_id(
     if (ser_id < FLECS_HI_COMPONENT_ID) {
         return ecs_new_low_id(world);
     } else {
-        return ecs_new_id(world);
+        return ecs_new(world);
     }
 }
 
diff --git a/src/addons/json/json.c b/src/addons/json/json.c
index b9ebf00d5..ed44b2894 100644
--- a/src/addons/json/json.c
+++ b/src/addons/json/json.c
@@ -41,7 +41,7 @@ const char* flecs_json_parse(
     char *token)
 {
     ecs_assert(json != NULL, ECS_INTERNAL_ERROR, NULL);
-    json = ecs_parse_ws_eol(json);
+    json = flecs_parse_ws_eol(json);
 
     char ch = json[0];
 
@@ -81,7 +81,7 @@ const char* flecs_json_parse(
                 break;
             }
 
-            json = ecs_chrparse(json, token_ptr ++);
+            json = flecs_chrparse(json, token_ptr ++);
         }
 
         if (!ch) {
@@ -93,7 +93,7 @@ const char* flecs_json_parse(
         }
     } else if (isdigit(ch) || (ch == '-')) {
         token_kind[0] = JsonNumber;
-        const char *result = ecs_parse_digit(json, token);
+        const char *result = flecs_parse_digit(json, token);
         
         /* Cheap initial check if parsed token could represent large int */
         if (result - json > 15) {
@@ -146,7 +146,7 @@ const char* flecs_json_parse_large_string(
             break;
         }
 
-        json = ecs_chrparse(json, &ch_out);
+        json = flecs_chrparse(json, &ch_out);
         ecs_strbuf_appendch(buf, ch_out);
     }
 
@@ -282,7 +282,7 @@ const char* flecs_json_skip_string(
             break;
         }
 
-        json = ecs_chrparse(json, &ch_out);
+        json = flecs_chrparse(json, &ch_out);
     }
 
     if (!ch) {
@@ -433,14 +433,14 @@ void flecs_json_string_escape(
     ecs_strbuf_t *buf,
     const char *value)
 {
-    ecs_size_t length = ecs_stresc(NULL, 0, '"', value);
+    ecs_size_t length = flecs_stresc(NULL, 0, '"', value);
     if (length == ecs_os_strlen(value)) {
         ecs_strbuf_appendch(buf, '"');
         ecs_strbuf_appendstrn(buf, value, length);
         ecs_strbuf_appendch(buf, '"');
     } else {
         char *out = ecs_os_malloc(length + 3);
-        ecs_stresc(out + 1, length, '"', value);
+        flecs_stresc(out + 1, length, '"', value);
         out[0] = '"';
         out[length + 1] = '"';
         out[length + 2] = '\0';
diff --git a/src/addons/json/json.h b/src/addons/json/json.h
index 171d1dd6a..fcbef7527 100644
--- a/src/addons/json/json.h
+++ b/src/addons/json/json.h
@@ -31,7 +31,7 @@ typedef enum ecs_json_token_t {
 
 typedef struct ecs_json_value_ser_ctx_t {
     ecs_entity_t type;
-    const EcsMetaTypeSerialized *ser;
+    const EcsTypeSerializer *ser;
     char *id_label;
     bool initialized;
 } ecs_json_value_ser_ctx_t;
@@ -190,14 +190,14 @@ bool flecs_json_skip_variable(
 void flecs_json_serialize_field(
     const ecs_world_t *world,
     const ecs_iter_t *it,
-    const ecs_filter_t *q,
+    const ecs_query_t *q,
     int field,
     ecs_strbuf_t *buf,
     ecs_json_ser_ctx_t *ctx);
 
 void flecs_json_serialize_query(
     const ecs_world_t *world,
-    const ecs_filter_t *q,
+    const ecs_query_t *q,
     ecs_strbuf_t *buf);
 
 int flecs_json_ser_type(
diff --git a/src/addons/json/serialize.c b/src/addons/json/serialize.c
index d3bb5bf83..5e152586a 100644
--- a/src/addons/json/serialize.c
+++ b/src/addons/json/serialize.c
@@ -4,6 +4,7 @@
  */
 
 #include "json.h"
+#include "../meta/meta.h"
 
 #ifdef FLECS_JSON
 
@@ -145,8 +146,8 @@ int flecs_json_ser_type_elements(
     ecs_strbuf_t *str,
     bool is_array)
 {
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
     ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL);
 
     const EcsComponent *comp = ecs_get(world, type, EcsComponent);
@@ -234,13 +235,20 @@ int json_ser_custom_type(
     ecs_strbuf_t *str)
 {
     const EcsOpaque *ct = ecs_get(world, op->type, EcsOpaque);
-    ecs_assert(ct != NULL, ECS_INVALID_OPERATION, NULL);
-    ecs_assert(ct->as_type != 0, ECS_INVALID_OPERATION, NULL);
-    ecs_assert(ct->serialize != NULL, ECS_INVALID_OPERATION, 
-        ecs_get_name(world, op->type));
-
-    const EcsMetaType *pt = ecs_get(world, ct->as_type, EcsMetaType);
-    ecs_assert(pt != NULL, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(ct != NULL, ECS_INVALID_OPERATION, 
+        "entity %s in opaque type serializer instruction is not an opaque type",
+            ecs_get_name(world, op->type));
+    ecs_assert(ct->as_type != 0, ECS_INVALID_OPERATION, 
+        "opaque type %s has not populated as_type field",
+            ecs_get_name(world, op->type));
+    ecs_assert(ct->serialize != NULL, ECS_INVALID_OPERATION,
+        "opaque type %s does not have serialize interface", 
+            ecs_get_name(world, op->type));
+
+    const EcsType *pt = ecs_get(world, ct->as_type, EcsType);
+    ecs_assert(pt != NULL, ECS_INVALID_OPERATION, 
+        "opaque type %s is missing flecs.meta.Type component",
+            ecs_get_name(world, op->type));
 
     ecs_type_kind_t kind = pt->kind;
     bool is_collection = false;
@@ -376,9 +384,9 @@ int flecs_json_ser_type_op(
     case EcsOpUPtr:
     case EcsOpIPtr:
     case EcsOpString:
-        if (ecs_primitive_to_expr_buf(world, 
+        if (flecs_expr_ser_primitive(world, 
             flecs_json_op_to_primitive_kind(op->kind), 
-            ECS_OFFSET(ptr, op->offset), str)) 
+            ECS_OFFSET(ptr, op->offset), str, true)) 
         {
             ecs_throw(ECS_INTERNAL_ERROR, NULL);
         }
@@ -498,7 +506,7 @@ int array_to_json_buf_w_type_data(
     int32_t count,
     ecs_strbuf_t *buf,
     const EcsComponent *comp,
-    const EcsMetaTypeSerialized *ser)
+    const EcsTypeSerializer *ser)
 {
     if (count) {
         ecs_size_t size = comp->size;
@@ -539,8 +547,8 @@ int ecs_array_to_json_buf(
         return -1;
     }
 
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
     if (!ser) {
         char *path = ecs_get_fullpath(world, type);
         ecs_err("cannot serialize to JSON, '%s' has no reflection data", path);
@@ -665,17 +673,6 @@ int flecs_json_append_type_labels(
             continue;
         }
 
-        if (obj && (pred == EcsUnion)) {
-            pred = obj;
-            obj = ecs_get_target(world, ent, pred, 0);
-            if (!ecs_is_alive(world, obj)) {
-                /* Union relationships aren't automatically cleaned up, so they
-                 * can contain invalid entity ids. Don't serialize value until
-                 * relationship is valid again. */
-                continue;
-            }
-        }
-
         if (desc && desc->serialize_id_labels) {
             flecs_json_next(buf);
 
@@ -728,8 +725,8 @@ int flecs_json_append_type_values(
             bool serialized = false;
             ecs_entity_t typeid = ecs_get_typeid(world, id);
             if (typeid) {
-                const EcsMetaTypeSerialized *ser = ecs_get(
-                    world, typeid, EcsMetaTypeSerialized);
+                const EcsTypeSerializer *ser = ecs_get(
+                    world, typeid, EcsTypeSerializer);
                 if (ser) {
                     const void *ptr = ecs_get_id(world, ent, id);
                     ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
@@ -879,17 +876,6 @@ int flecs_json_append_type(
                 continue;
             }
 
-            if (obj && (pred == EcsUnion)) {
-                pred = obj;
-                obj = ecs_get_target(world, ent, pred, 0);
-                if (!ecs_is_alive(world, obj)) {
-                    /* Union relationships aren't automatically cleaned up, so they
-                    * can contain invalid entity ids. Don't serialize value until
-                    * relationship is valid again. */
-                    continue;
-                }
-            }
-
             flecs_json_next(buf);
             flecs_json_array_push(buf);
             flecs_json_next(buf);
@@ -1024,14 +1010,12 @@ int flecs_json_serialize_children_alerts(
     ecs_strbuf_t *buf,
     ecs_entity_t entity)
 {
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter(ECS_CONST_CAST(ecs_world_t*, world), {
-        .storage = &f,
+    ecs_query_t *q = ecs_query(ECS_CONST_CAST(ecs_world_t*, world), {
         .terms = {{ .id = ecs_pair(EcsChildOf, entity) }}
     });
 
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    while (ecs_filter_next(&it)) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
         EcsAlertsActive *alerts = ecs_table_get_id(
             world, it.table, ecs_id(EcsAlertsActive), it.offset);
 
@@ -1057,7 +1041,7 @@ int flecs_json_serialize_children_alerts(
         }
     }
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     return 0;
 error:
@@ -1169,13 +1153,12 @@ int flecs_json_serialize_matches(
                 int32_t i, count = ecs_table_count(table);
                 ecs_entity_t *entities = ecs_vec_first(&table->data.entities);
                 for (i = 0; i < count; i ++) {
-                    ecs_poly_t *q = queries[i].poly;
+                    flecs_poly_t *q = queries[i].poly;
                     if (!q) {
                         continue;
                     }
 
-                    ecs_iter_t qit;
-                    ecs_iter_poly(world, q, &qit, NULL);
+                    ecs_iter_t qit = ecs_query_iter(world, q);
                     if (!qit.variables) {
                         ecs_iter_fini(&qit);
                         continue;
@@ -1383,7 +1366,7 @@ void flecs_json_serialize_iter_ids(
 
     for (int i = 0; i < field_count; i ++) {
         flecs_json_next(buf);
-        flecs_json_serialize_id(world, it->terms[i].id, buf);
+        flecs_json_serialize_id(world, it->query->terms[i].id, buf);
     }
 
     flecs_json_array_pop(buf);
@@ -1405,7 +1388,7 @@ void flecs_json_serialize_iter_id_labels(
 
     for (int i = 0; i < field_count; i ++) {
         flecs_json_next(buf);
-        flecs_json_serialize_id_label(world, it->terms[i].id, buf);
+        flecs_json_serialize_id_label(world, it->query->terms[i].id, buf);
     }
 
     flecs_json_array_pop(buf);
@@ -1454,15 +1437,15 @@ void flecs_json_serialize_type_info(
     for (int i = 0; i < field_count; i ++) {
         flecs_json_next(buf);
         ecs_entity_t typeid = 0;
-        if (it->terms[i].inout != EcsInOutNone) {
-            typeid = ecs_get_typeid(world, it->terms[i].id);
+        if (it->query->terms[i].inout != EcsInOutNone) {
+            typeid = ecs_get_typeid(world, it->query->terms[i].id);
         }
         if (typeid) {
             flecs_json_serialize_id_str(world, typeid, buf);
             ecs_strbuf_appendch(buf, ':');
             ecs_type_info_to_json_buf(world, typeid, buf);
         } else {
-            flecs_json_serialize_id_str(world, it->terms[i].id, buf);
+            flecs_json_serialize_id_str(world, it->query->terms[i].id, buf);
             ecs_strbuf_appendlit(buf, ":0");
         }
     }
@@ -1482,7 +1465,7 @@ void flecs_json_serialize_field_info(
         return;
     }
 
-    const ecs_filter_t *q = it->query;
+    const ecs_query_t *q = it->query;
 
     flecs_json_memberl(buf, "field_info");
     flecs_json_array_push(buf);
@@ -1506,7 +1489,7 @@ void flecs_json_serialize_query_info(
         return;
     }
 
-    const ecs_filter_t *q = it->query;
+    const ecs_query_t *q = it->query;
     flecs_json_memberl(buf, "query_info");
     flecs_json_serialize_query(world, q, buf);
 }
@@ -1521,26 +1504,20 @@ void flecs_json_serialize_query_plan(
     (void)buf;
     (void)desc;
 
-#ifdef FLECS_RULES
     if (!desc->query) {
         return;
     }
 
-    if (!ecs_poly_is(desc->query, ecs_rule_t)) {
-        return;
-    }
-
-    const ecs_rule_t *q = desc->query;
-    ecs_poly_assert(q, ecs_rule_t);
+    const ecs_query_t *q = desc->query;
+    flecs_poly_assert(q, ecs_query_t);
 
     flecs_json_memberl(buf, "query_plan");
 
     bool prev_color = ecs_log_enable_colors(true);
-    char *plan = ecs_rule_str(q);
+    char *plan = ecs_query_plan(q);
     flecs_json_string_escape(buf, plan);
     ecs_os_free(plan);
     ecs_log_enable_colors(prev_color);
-#endif
 }
 
 static
@@ -1566,21 +1543,20 @@ void flecs_json_serialize_query_profile(
         component_bytes = 0;
         shared_component_bytes = 0;
 
-        ecs_iter_t pit;
-        ecs_iter_poly(world, desc->query, &pit, NULL);
-        pit.flags |= EcsIterIsInstanced;
+        ecs_iter_t qit = ecs_query_iter(world, desc->query);
+        qit.flags |= EcsIterIsInstanced;
     
-        while (ecs_iter_next(&pit)) {
+        while (ecs_iter_next(&qit)) {
             result_count ++;
-            entity_count += pit.count;
+            entity_count += qit.count;
 
-            int32_t f, field_count = pit.field_count;
+            int32_t f, field_count = qit.field_count;
             for (f = 0; f < field_count; f ++) {
-                size_t size = ecs_field_size(&pit, f + 1);
-                if (ecs_field_is_set(&pit, f + 1) && size) {
-                    if (ecs_field_is_self(&pit, f + 1)) {
+                size_t size = ecs_field_size(&qit, f);
+                if (ecs_field_is_set(&qit, f) && size) {
+                    if (ecs_field_is_self(&qit, f)) {
                         component_bytes += 
-                            flecs_uto(ecs_size_t, size) * pit.count;
+                            flecs_uto(ecs_size_t, size) * qit.count;
                     } else {
                         shared_component_bytes += flecs_uto(ecs_size_t, size);
                     }
@@ -1614,7 +1590,7 @@ void flecs_json_serialize_query_profile(
     flecs_json_object_push(buf);
     if (it->query) {
         /* Correct for profiler */
-        ECS_CONST_CAST(ecs_filter_t*, it->query)->eval_count -= i;
+        ECS_CONST_CAST(ecs_query_t*, it->query)->eval_count -= i;
         flecs_json_memberl(buf, "eval_count");
         flecs_json_number(buf, it->query->eval_count);
     }
@@ -1674,7 +1650,7 @@ void flecs_json_serialize_iter_result_ids(
 
     for (int i = 0; i < it->field_count; i ++) {
         flecs_json_next(buf);
-        flecs_json_serialize_id(world, ecs_field_id(it, i + 1), buf);
+        flecs_json_serialize_id(world, ecs_field_id(it, i), buf);
     }
 
     flecs_json_array_pop(buf);
@@ -1691,7 +1667,7 @@ void flecs_json_serialize_iter_result_id_labels(
 
     for (int i = 0; i < it->field_count; i ++) {
         flecs_json_next(buf);
-        flecs_json_serialize_id_label(world, ecs_field_id(it, i + 1), buf);
+        flecs_json_serialize_id_label(world, ecs_field_id(it, i), buf);
     }
 
     flecs_json_array_pop(buf);
@@ -1789,7 +1765,7 @@ bool flecs_json_serialize_iter_result_is_set(
 
     for (int i = 0; i < it->field_count; i ++) {
         ecs_strbuf_list_next(buf);
-        if (ecs_field_is_set(it, i + 1)) {
+        if (ecs_field_is_set(it, i)) {
             flecs_json_true(buf);
         } else {
             flecs_json_false(buf);
@@ -2094,13 +2070,13 @@ int flecs_json_serialize_iter_result_values(
 
         if (!ptr) {
             /* No data in column. Append 0 if this is not an optional term */
-            if (ecs_field_is_set(it, i + 1)) {
+            if (ecs_field_is_set(it, i)) {
                 ecs_strbuf_appendch(buf, '0');
                 continue;
             }
         }
 
-        if (ecs_field_is_writeonly(it, i + 1)) {
+        if (ecs_field_is_writeonly(it, i)) {
             ecs_strbuf_appendch(buf, '0');
             continue;
         }
@@ -2121,8 +2097,8 @@ int flecs_json_serialize_iter_result_values(
             continue;
         }
 
-        const EcsMetaTypeSerialized *ser = ecs_get(
-            world, type, EcsMetaTypeSerialized);
+        const EcsTypeSerializer *ser = ecs_get(
+            world, type, EcsTypeSerializer);
         if (!ser) {
             /* Not odd, component just has no reflection data */
             ecs_strbuf_appendch(buf, '0');
@@ -2131,13 +2107,13 @@ int flecs_json_serialize_iter_result_values(
 
         /* If term is not set, append empty array. This indicates that the term
          * could have had data but doesn't */
-        if (!ecs_field_is_set(it, i + 1)) {
+        if (!ecs_field_is_set(it, i)) {
             flecs_json_array_push(buf);
             flecs_json_array_pop(buf);
             continue;
         }
 
-        if (ecs_field_is_self(it, i + 1)) {
+        if (ecs_field_is_self(it, i)) {
             int32_t count = it->count;
             if (array_to_json_buf_w_type_data(world, ptr, count, buf, comp, ser)) {
                 return -1;
@@ -2209,8 +2185,8 @@ int flecs_json_serialize_iter_result_columns(
             continue;
         }
 
-        const EcsMetaTypeSerialized *ser = ecs_get(
-            world, typeid, EcsMetaTypeSerialized);
+        const EcsTypeSerializer *ser = ecs_get(
+            world, typeid, EcsTypeSerializer);
         if (!ser) {
             ecs_strbuf_appendch(buf, '0');
             continue;
@@ -2332,11 +2308,11 @@ int flecs_json_serialize_iter_result(
 }
 
 int ecs_iter_to_json_buf(
-    const ecs_world_t *world,
     ecs_iter_t *it,
     ecs_strbuf_t *buf,
     const ecs_iter_to_json_desc_t *desc)
 {
+    ecs_world_t *world = it->real_world;
     ecs_time_t duration = {0};
     if (desc && desc->measure_eval_duration) {
         ecs_time_measure(&duration);
@@ -2440,13 +2416,12 @@ int ecs_iter_to_json_buf(
 }
 
 char* ecs_iter_to_json(
-    const ecs_world_t *world,
     ecs_iter_t *it,
     const ecs_iter_to_json_desc_t *desc)
 {
     ecs_strbuf_t buf = ECS_STRBUF_INIT;
 
-    if (ecs_iter_to_json_buf(world, it, &buf, desc)) {
+    if (ecs_iter_to_json_buf(it, &buf, desc)) {
         ecs_strbuf_reset(&buf);
         return NULL;
     }
@@ -2459,37 +2434,36 @@ int ecs_world_to_json_buf(
     ecs_strbuf_t *buf_out,
     const ecs_world_to_json_desc_t *desc)
 {
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_desc_t filter_desc = {0};
-    filter_desc.storage = &f;
+    ecs_query_desc_t query_desc = {0};
 
     if (desc && desc->serialize_builtin && desc->serialize_modules) {
-        filter_desc.terms[0].id = EcsAny;
+        query_desc.terms[0].id = EcsAny;
     } else {
         bool serialize_builtin = desc && desc->serialize_builtin;
         bool serialize_modules = desc && desc->serialize_modules;
         int32_t term_id = 0;
 
         if (!serialize_builtin) {
-            filter_desc.terms[term_id].id = ecs_pair(EcsChildOf, EcsFlecs);
-            filter_desc.terms[term_id].oper = EcsNot;
-            filter_desc.terms[term_id].src.flags = EcsSelf | EcsParent;
+            query_desc.terms[term_id].id = ecs_pair(EcsChildOf, EcsFlecs);
+            query_desc.terms[term_id].oper = EcsNot;
+            query_desc.terms[term_id].src.id = EcsSelf | EcsUp;
             term_id ++;
         }
         if (!serialize_modules) {
-            filter_desc.terms[term_id].id = EcsModule;
-            filter_desc.terms[term_id].oper = EcsNot;
-            filter_desc.terms[term_id].src.flags = EcsSelf | EcsParent;
+            query_desc.terms[term_id].id = EcsModule;
+            query_desc.terms[term_id].oper = EcsNot;
+            query_desc.terms[term_id].src.id = EcsSelf | EcsUp;
         }
     }
 
-    filter_desc.flags = EcsFilterMatchDisabled|EcsFilterMatchPrefab;
+    query_desc.flags = EcsQueryMatchDisabled|EcsQueryMatchPrefab;
 
-    if (ecs_filter_init(world, &filter_desc) == NULL) {
+    ecs_query_t *q = ecs_query_init(world, &query_desc);
+    if (!q) {
         return -1;
     }
 
-    ecs_iter_t it = ecs_filter_iter(world, &f);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t json_desc = { 
         .serialize_table = true,
         .serialize_ids = true,
@@ -2497,8 +2471,8 @@ int ecs_world_to_json_buf(
         .serialize_private = true
     };
 
-    int ret = ecs_iter_to_json_buf(world, &it, buf_out, &json_desc);
-    ecs_filter_fini(&f);
+    int ret = ecs_iter_to_json_buf(&it, buf_out, &json_desc);
+    ecs_query_fini(q);
     return ret;
 }
 
diff --git a/src/addons/json/serialize_field_info.c b/src/addons/json/serialize_field_info.c
index 0955bed39..9b62ca651 100644
--- a/src/addons/json/serialize_field_info.c
+++ b/src/addons/json/serialize_field_info.c
@@ -10,7 +10,7 @@
 void flecs_json_serialize_field(
     const ecs_world_t *world,
     const ecs_iter_t *it,
-    const ecs_filter_t *q,
+    const ecs_query_t *q,
     int field,
     ecs_strbuf_t *buf,
     ecs_json_ser_ctx_t *ctx)
@@ -40,8 +40,8 @@ void flecs_json_serialize_field(
             }
 
             if (ECS_IS_PAIR(term->id)) {
-                if (term->first.flags & EcsIsEntity && term->first.id) {
-                    if (ecs_has_id(world, term->first.id, EcsExclusive)) {
+                if ((term->first.id & EcsIsEntity) && ECS_TERM_REF_ID(&term->first)) {
+                    if (ecs_has_id(world, ECS_TERM_REF_ID(&term->first), EcsExclusive)) {
                         flecs_json_memberl(buf, "exclusive");
                         flecs_json_bool(buf, true);
                     }
diff --git a/src/addons/json/serialize_iter_rows.c b/src/addons/json/serialize_iter_rows.c
index 667ee521b..a1892f39a 100644
--- a/src/addons/json/serialize_iter_rows.c
+++ b/src/addons/json/serialize_iter_rows.c
@@ -19,7 +19,7 @@ bool flecs_json_serialize_row_tags(
     
     int32_t tag_count = 0;
     for (f = 0; f < field_count; f ++) {
-        if (!ecs_field_is_set(it, f + 1)) {
+        if (!ecs_field_is_set(it, f)) {
             continue;
         }
 
@@ -61,7 +61,7 @@ bool flecs_json_serialize_row_pairs(
     
     int32_t pair_count = 0;
     for (f = 0; f < field_count; f ++) {
-        if (!ecs_field_is_set(it, f + 1)) {
+        if (!ecs_field_is_set(it, f)) {
             continue;
         }
 
@@ -312,7 +312,7 @@ bool flecs_json_serialize_get_value_ctx(
         }
 
         ctx->type = type;
-        ctx->ser = ecs_get(world, type, EcsMetaTypeSerialized);
+        ctx->ser = ecs_get(world, type, EcsTypeSerializer);
         if (!ctx->ser) {
             return false;
         }
@@ -355,7 +355,7 @@ int flecs_json_serialize_row_components(
 
     int32_t f, field_count = it->field_count, component_count = 0;
     for (f = 0; f < field_count; f ++) {
-        if (!ecs_field_is_set(it, f + 1)) {
+        if (!ecs_field_is_set(it, f)) {
             continue;
         }
 
@@ -364,7 +364,7 @@ int flecs_json_serialize_row_components(
             continue;
         }
 
-        if (ecs_field_is_self(it, f + 1)) {
+        if (ecs_field_is_self(it, f)) {
             ptr = ECS_ELEM(ptr, it->sizes[f], row);
         }
 
diff --git a/src/addons/json/serialize_query_info.c b/src/addons/json/serialize_query_info.c
index b7af1607b..bbb1e96df 100644
--- a/src/addons/json/serialize_query_info.c
+++ b/src/addons/json/serialize_query_info.c
@@ -9,13 +9,14 @@
 
 static
 const char* flecs_json_inout_str(
-    ecs_inout_kind_t kind)
+    int16_t kind)
 {
     switch(kind) {
     case EcsIn: return "in";
     case EcsOut: return "out";
     case EcsInOut: return "inout";
     case EcsInOutNone: return "none";
+    case EcsInOutFilter: return "filter";
     case EcsInOutDefault: return "default";
     default: return "unknown";
     }
@@ -23,7 +24,7 @@ const char* flecs_json_inout_str(
 
 static
 const char* flecs_json_oper_str(
-    ecs_oper_kind_t kind)
+    int16_t kind)
 {
     switch(kind) {
     case EcsAnd: return "and";
@@ -63,24 +64,24 @@ void flecs_json_serialize_term_entity(
 static
 void flecs_json_serialize_term_ref(
     const ecs_world_t *world,
-    const ecs_term_id_t *ref,
+    const ecs_term_ref_t *ref,
     ecs_strbuf_t *buf)
 {
     flecs_json_object_push(buf);
-    if (ref->flags & EcsIsEntity) {
-        flecs_json_serialize_term_entity(world, ref->id, buf);
-    } else if (ref->flags & EcsIsVariable) {
+    if (ref->id & EcsIsEntity) {
+        flecs_json_serialize_term_entity(world, ECS_TERM_REF_ID(ref), buf);
+    } else if (ref->id & EcsIsVariable) {
         flecs_json_memberl(buf, "var");
         if (ref->name) {
             flecs_json_string(buf, ref->name);
         } else if (ref->id) {
-            if (ref->id == EcsThis) {
+            if (ECS_TERM_REF_ID(ref) == EcsThis) {
                 flecs_json_string(buf, "this");
             } else {
-                flecs_json_path(buf, world, ref->id);
+                flecs_json_path(buf, world, ECS_TERM_REF_ID(ref));
             }
         }
-    } else if (ref->flags & EcsIsName) {
+    } else if (ref->id & EcsIsName) {
         flecs_json_memberl(buf, "name");
         flecs_json_string(buf, ref->name);
     }
@@ -93,24 +94,24 @@ void flecs_json_serialize_term_trav(
     const ecs_term_t *term,
     ecs_strbuf_t *buf)
 {
-    if (term->src.trav) {
+    if (term->trav) {
         flecs_json_memberl(buf, "trav");
         flecs_json_object_push(buf);
-        flecs_json_serialize_term_entity(world, term->src.trav, buf);
+        flecs_json_serialize_term_entity(world, term->trav, buf);
         flecs_json_object_pop(buf);
     }
 
     flecs_json_memberl(buf, "flags");
     flecs_json_array_push(buf);
-    if (term->src.flags & EcsSelf) {
+    if (term->src.id & EcsSelf) {
         flecs_json_next(buf);
         flecs_json_string(buf, "self");
     }
-    if (term->src.flags & EcsCascade) {
+    if (term->src.id & EcsCascade) {
         flecs_json_next(buf);
         flecs_json_string(buf, "cascade");
     } else
-    if (term->src.flags & EcsUp) {
+    if (term->src.id & EcsUp) {
         flecs_json_next(buf);
         flecs_json_string(buf, "up");
     }
@@ -120,21 +121,21 @@ void flecs_json_serialize_term_trav(
 static
 void flecs_json_serialize_term(
     const ecs_world_t *world,
-    const ecs_filter_t *q,
+    const ecs_query_t *q,
     int t,
     ecs_strbuf_t *buf)
 {
-    ecs_term_t *term = &q->terms[t];
+    const ecs_term_t *term = &q->terms[t];
 
     flecs_json_object_push(buf);
     flecs_json_memberl(buf, "inout");
     flecs_json_string(buf, flecs_json_inout_str(term->inout));
 
     flecs_json_memberl(buf, "has_data");
-    flecs_json_bool(buf, 0 == (term->flags & EcsTermNoData));
+    flecs_json_bool(buf, 0 == (term->flags_ & EcsTermNoData));
 
-    if (term->first.flags & EcsIsEntity && term->first.id) {
-        if (ecs_has_id(world, term->first.id, EcsDontInherit)) {
+    if (term->first.id & EcsIsEntity && term->first.id) {
+        if (ecs_has_id(world, ECS_TERM_REF_ID(&term->first), EcsDontInherit)) {
             flecs_json_memberl(buf, "dont_inherit");
             flecs_json_true(buf);
         }
@@ -149,7 +150,7 @@ void flecs_json_serialize_term(
     flecs_json_memberl(buf, "first");
     flecs_json_serialize_term_ref(world, &term->first, buf);
     
-    if (term->second.id || term->second.name || term->second.flags & EcsIsEntity) {
+    if (ECS_TERM_REF_ID(&term->second) || term->second.name || term->second.id & EcsIsEntity) {
         flecs_json_memberl(buf, "second");
         flecs_json_serialize_term_ref(world, &term->second, buf);
     }
@@ -161,7 +162,7 @@ void flecs_json_serialize_term(
 
 void flecs_json_serialize_query(
     const ecs_world_t *world,
-    const ecs_filter_t *q,
+    const ecs_query_t *q,
     ecs_strbuf_t *buf)
 {
     flecs_json_object_push(buf);
diff --git a/src/addons/json/serialize_type_info.c b/src/addons/json/serialize_type_info.c
index 2c9bda916..897aada6d 100644
--- a/src/addons/json/serialize_type_info.c
+++ b/src/addons/json/serialize_type_info.c
@@ -64,11 +64,8 @@ void json_typeinfo_ser_constants(
     ecs_entity_t type,
     ecs_strbuf_t *str)
 {
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t) {
-        .id = ecs_pair(EcsChildOf, type)
-    });
-
-    while (ecs_term_next(&it)) {
+    ecs_iter_t it = ecs_each_id(world, ecs_pair(EcsChildOf, type));
+    while (ecs_each_next(&it)) {
         int32_t i, count = it.count;
         for (i = 0; i < count; i ++) {
             flecs_json_next(str);
@@ -217,7 +214,8 @@ int json_typeinfo_ser_type_op(
     case EcsOpPush:
     case EcsOpPop:
         /* Should not be parsed as single op */
-        ecs_throw(ECS_INVALID_PARAMETER, NULL);
+        ecs_throw(ECS_INVALID_PARAMETER, 
+            "unexpected push/pop serializer instruction");
         break;
     case EcsOpEnum:
         json_typeinfo_ser_enum(world, op->type, str);
@@ -395,8 +393,8 @@ int json_typeinfo_ser_type(
         return 0;
     }
 
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
     if (!ser) {
         ecs_strbuf_appendch(buf, '0');
         return 0;
diff --git a/src/addons/log.c b/src/addons/log.c
index 2de4a2f2c..427508546 100644
--- a/src/addons/log.c
+++ b/src/addons/log.c
@@ -149,7 +149,7 @@ void ecs_printv_(
 
     /* Apply color. Even if we don't want color, we still need to call the
      * colorize function to get rid of the color tags (e.g. #[green]) */
-    char *msg_nocolor = ecs_vasprintf(fmt, args);
+    char *msg_nocolor = flecs_vasprintf(fmt, args);
     flecs_colorize_buf(msg_nocolor, 
         ecs_os_api.flags_ & EcsOsApiLogWithColors, &msg_buf);
     ecs_os_free(msg_nocolor);
@@ -238,11 +238,24 @@ void ecs_parser_errorv_(
          * function is called with (expr - ptr), and expr is NULL. */
         column_arg = 0;
     }
+    
     int32_t column = flecs_itoi32(column_arg);
 
     if (ecs_os_api.log_level_ >= -2) {
         ecs_strbuf_t msg_buf = ECS_STRBUF_INIT;
 
+        /* Count number of newlines up until column_arg */
+        int32_t i, line = 1;
+        if (expr) {
+            for (i = 0; i < column; i ++) {
+                if (expr[i] == '\n') {
+                    line ++;
+                }
+            }
+            
+            ecs_strbuf_append(&msg_buf, "%d: ", line);
+        }
+
         ecs_strbuf_vappend(&msg_buf, fmt, args);
 
         if (expr) {
@@ -252,15 +265,23 @@ void ecs_parser_errorv_(
              * last occurring newline */
             if (column != -1) {
                 const char *ptr = &expr[column];
+                if (ptr[0] == '\n') {
+                    ptr --;
+                }
+
                 while (ptr[0] != '\n' && ptr > expr) {
                     ptr --;
                 }
+                
+                if (ptr[0] == '\n') {
+                    ptr ++;
+                }
 
                 if (ptr == expr) {
                     /* ptr is already at start of line */
                 } else {
-                    column -= (int32_t)(ptr - expr + 1);
-                    expr = ptr + 1;
+                    column -= (int32_t)(ptr - expr);
+                    expr = ptr;
                 }
             }
 
@@ -316,7 +337,7 @@ void ecs_abort_(
     if (fmt) {
         va_list args;
         va_start(args, fmt);
-        char *msg = ecs_vasprintf(fmt, args);
+        char *msg = flecs_vasprintf(fmt, args);
         va_end(args);
         ecs_fatal_(file, line, "%s (%s)", msg, ecs_strerror(err));
         ecs_os_free(msg);
@@ -337,7 +358,7 @@ void ecs_assert_log_(
     if (fmt) {
         va_list args;
         va_start(args, fmt);
-        char *msg = ecs_vasprintf(fmt, args);
+        char *msg = flecs_vasprintf(fmt, args);
         va_end(args);
         ecs_fatal_(file, line, "assert: %s %s (%s)",
             cond_str, msg, ecs_strerror(err));
diff --git a/src/addons/meta/api.c b/src/addons/meta/api.c
index 9b72a8a3b..d474e2213 100644
--- a/src/addons/meta/api.c
+++ b/src/addons/meta/api.c
@@ -44,6 +44,126 @@ bool flecs_type_is_number(
     }
 }
 
+/* Serialize a primitive value */
+int flecs_expr_ser_primitive(
+    const ecs_world_t *world,
+    ecs_primitive_kind_t kind,
+    const void *base, 
+    ecs_strbuf_t *str,
+    bool is_expr) 
+{
+    switch(kind) {
+    case EcsBool:
+        if (*(const bool*)base) {
+            ecs_strbuf_appendlit(str, "true");
+        } else {
+            ecs_strbuf_appendlit(str, "false");
+        }
+        break;
+    case EcsChar: {
+        char chbuf[3];
+        char ch = *(const char*)base;
+        if (ch) {
+            flecs_chresc(chbuf, *(const char*)base, '"');
+            if (is_expr) ecs_strbuf_appendch(str, '"');
+            ecs_strbuf_appendstr(str, chbuf);
+            if (is_expr) ecs_strbuf_appendch(str, '"');
+        } else {
+            ecs_strbuf_appendch(str, '0');
+        }
+        break;
+    }
+    case EcsByte:
+        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint8_t*)base));
+        break;
+    case EcsU8:
+        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint8_t*)base));
+        break;
+    case EcsU16:
+        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint16_t*)base));
+        break;
+    case EcsU32:
+        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint32_t*)base));
+        break;
+    case EcsU64:
+        ecs_strbuf_append(str, "%llu", *(const uint64_t*)base);
+        break;
+    case EcsI8:
+        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int8_t*)base));
+        break;
+    case EcsI16:
+        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int16_t*)base));
+        break;
+    case EcsI32:
+        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int32_t*)base));
+        break;
+    case EcsI64:
+        ecs_strbuf_appendint(str, *(const int64_t*)base);
+        break;
+    case EcsF32:
+        ecs_strbuf_appendflt(str, (double)*(const float*)base, 0);
+        break;
+    case EcsF64:
+        ecs_strbuf_appendflt(str, *(const double*)base, 0);
+        break;
+    case EcsIPtr:
+        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const intptr_t*)base));
+        break;
+    case EcsUPtr:
+        ecs_strbuf_append(str, "%u", *(const uintptr_t*)base);
+        break;
+    case EcsString: {
+        const char *value = *ECS_CONST_CAST(const char**, base);
+        if (value) {
+            if (!is_expr) {
+                ecs_strbuf_appendstr(str, value);
+            } else {
+                ecs_size_t length = flecs_stresc(NULL, 0, '"', value);
+                if (length == ecs_os_strlen(value)) {
+                    ecs_strbuf_appendch(str, '"');
+                    ecs_strbuf_appendstrn(str, value, length);
+                    ecs_strbuf_appendch(str, '"');
+                } else {
+                    char *out = ecs_os_malloc(length + 3);
+                    flecs_stresc(out + 1, length, '"', value);
+                    out[0] = '"';
+                    out[length + 1] = '"';
+                    out[length + 2] = '\0';
+                    ecs_strbuf_appendstr(str, out);
+                    ecs_os_free(out);
+                }
+            }
+        } else {
+            ecs_strbuf_appendlit(str, "null");
+        }
+        break;
+    }
+    case EcsEntity: {
+        ecs_entity_t e = *(const ecs_entity_t*)base;
+        if (!e) {
+            ecs_strbuf_appendch(str, '0');
+        } else {
+            ecs_get_path_w_sep_buf(world, 0, e, ".", NULL, str);
+        }
+        break;
+    }
+    case EcsId: {
+        ecs_id_t id = *(const ecs_id_t*)base;
+        if (!id) {
+            ecs_strbuf_appendch(str, '0');
+        } else {
+            ecs_id_str_buf(world, id, str);
+        }
+        break;
+    }
+    default:
+        ecs_err("invalid primitive kind");
+        return -1;
+    }
+
+    return 0;
+}
+
 ecs_entity_t ecs_primitive_init(
     ecs_world_t *world,
     const ecs_primitive_desc_t *desc)
@@ -92,7 +212,7 @@ ecs_entity_t ecs_enum_init(
         if (!m_desc->value) {
             ecs_add_id(world, c, EcsConstant);
         } else {
-            ecs_set_pair_object(world, c, EcsConstant, ecs_i32_t, 
+            ecs_set_pair_second(world, c, EcsConstant, ecs_i32_t, 
                 {m_desc->value});
         }
     }
@@ -139,7 +259,7 @@ ecs_entity_t ecs_bitmask_init(
         if (!m_desc->value) {
             ecs_add_id(world, c, EcsConstant);
         } else {
-            ecs_set_pair_object(world, c, EcsConstant, ecs_u32_t, 
+            ecs_set_pair_second(world, c, EcsConstant, ecs_u32_t, 
                 {m_desc->value});
         }
     }
diff --git a/src/addons/meta_c.c b/src/addons/meta/c_utils.c
similarity index 94%
rename from src/addons/meta_c.c
rename to src/addons/meta/c_utils.c
index 104d56afa..46f9799d6 100644
--- a/src/addons/meta_c.c
+++ b/src/addons/meta/c_utils.c
@@ -3,9 +3,9 @@
  * @brief C utilities for meta addon.
  */
 
-#include "../private_api.h"
+#include "../../private_api.h"
 
-#ifdef FLECS_META_C
+#ifdef FLECS_META
 
 #include <ctype.h>
 
@@ -93,15 +93,15 @@ const char* parse_c_digit(
     int64_t *value_out)
 {
     char token[24];
-    ptr = ecs_parse_ws_eol(ptr);
-    ptr = ecs_parse_digit(ptr, token);
+    ptr = flecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_digit(ptr, token);
     if (!ptr) {
         goto error;
     }
 
     *value_out = strtol(token, NULL, 0);
 
-    return ecs_parse_ws_eol(ptr);
+    return flecs_parse_ws_eol(ptr);
 error:
     return NULL;
 }
@@ -124,7 +124,7 @@ const char* parse_c_identifier(
     }
 
     /* Ignore whitespaces */
-    ptr = ecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_ws_eol(ptr);
     ch = *ptr;
 
     if (!isalpha(ch) && (ch != '_')) {
@@ -172,7 +172,7 @@ const char * meta_open_scope(
     meta_parse_ctx_t *ctx)    
 {
     /* Skip initial whitespaces */
-    ptr = ecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_ws_eol(ptr);
 
     /* Is this the start of the type definition? */
     if (ctx->desc == ptr) {
@@ -182,7 +182,7 @@ const char * meta_open_scope(
         }
 
         ptr ++;
-        ptr = ecs_parse_ws_eol(ptr);
+        ptr = flecs_parse_ws_eol(ptr);
     }
 
     /* Is this the end of the type definition? */
@@ -193,7 +193,7 @@ const char * meta_open_scope(
 
     /* Is this the end of the type definition? */
     if (*ptr == '}') {
-        ptr = ecs_parse_ws_eol(ptr + 1);
+        ptr = flecs_parse_ws_eol(ptr + 1);
         if (*ptr) {
             ecs_meta_error(ctx, ptr, 
                 "stray characters after struct definition");
@@ -226,7 +226,7 @@ const char* meta_parse_constant(
         return NULL;
     }
 
-    ptr = ecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_ws_eol(ptr);
     if (!ptr) {
         return NULL;
     }
@@ -263,7 +263,7 @@ const char* meta_parse_type(
     token->is_ptr = false;
     token->is_const = false;
 
-    ptr = ecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_ws_eol(ptr);
 
     /* Parse token, expect type identifier or ECS_PROPERTY */
     ptr = parse_c_identifier(ptr, token->type, token->params, ctx);
@@ -286,7 +286,7 @@ const char* meta_parse_type(
     }
 
     /* Check if type is a pointer */
-    ptr = ecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_ws_eol(ptr);
     if (*ptr == '*') {
         token->is_ptr = true;
         ptr ++;
@@ -330,7 +330,7 @@ const char* meta_parse_member(
     }
 
     /* Skip whitespace between member and [ or ; */
-    ptr = ecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_ws_eol(ptr);
 
     /* Check if this is an array */
     char *array_start = strchr(token->name, '[');
@@ -386,7 +386,7 @@ int meta_parse_desc(
     token->is_key_value = false;
     token->is_fixed_size = false;
 
-    ptr = ecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_ws_eol(ptr);
     if (*ptr != '(' && *ptr != '<') {
         ecs_meta_error(ctx, ptr, 
             "expected '(' at start of collection definition");
@@ -401,11 +401,11 @@ int meta_parse_desc(
         goto error;
     }
 
-    ptr = ecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_ws_eol(ptr);
 
     /* If next token is a ',' the first type was a key type */
     if (*ptr == ',') {
-        ptr = ecs_parse_ws_eol(ptr + 1);
+        ptr = flecs_parse_ws_eol(ptr + 1);
         
         if (isdigit(*ptr)) {
             int64_t value;
@@ -421,7 +421,7 @@ int meta_parse_desc(
 
             /* Parse element type */
             ptr = meta_parse_type(ptr, &token->type, ctx);
-            ptr = ecs_parse_ws_eol(ptr);
+            ptr = flecs_parse_ws_eol(ptr);
 
             token->is_key_value = true;
         }
@@ -480,12 +480,14 @@ ecs_entity_t meta_lookup_array(
     }
 
     if (!e) {
-        e = ecs_new_id(world);
+        e = ecs_new(world);
     }
 
     ecs_check(params.count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL);
 
-    return ecs_set(world, e, EcsArray, { element_type, (int32_t)params.count });
+    ecs_set(world, e, EcsArray, { element_type, (int32_t)params.count });
+
+    return e;
 error:
     return 0;
 }
@@ -517,10 +519,12 @@ ecs_entity_t meta_lookup_vector(
         world, &params.type, params_decl, 1, &param_ctx);
 
     if (!e) {
-        e = ecs_new_id(world);
+        e = ecs_new(world);
     }
 
-    return ecs_set(world, e, EcsVector, { element_type });
+    ecs_set(world, e, EcsVector, { element_type });
+
+    return e;
 error:
     return 0;
 }
@@ -562,7 +566,7 @@ ecs_entity_t meta_lookup_bitmask(
 
 #ifndef FLECS_NDEBUG
     /* Make sure this is a bitmask type */
-    const EcsMetaType *type_ptr = ecs_get(world, bitmask_type, EcsMetaType);
+    const EcsType *type_ptr = ecs_get(world, bitmask_type, EcsType);
     ecs_check(type_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(type_ptr->kind == EcsBitmaskType, ECS_INVALID_PARAMETER, NULL);
 #endif
@@ -665,7 +669,7 @@ ecs_entity_t meta_lookup(
     if (count != 1) {
         ecs_check(count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL);
 
-        type = ecs_set(world, 0, EcsArray, {type, (int32_t)count});
+        type = ecs_insert(world, ecs_value(EcsArray, {type, (int32_t)count}));
     }
 
     if (!type) {
@@ -773,10 +777,10 @@ int meta_parse_constants(
         });
 
         if (!is_bitmask) {
-            ecs_set_pair_object(world, c, EcsConstant, ecs_i32_t, 
+            ecs_set_pair_second(world, c, EcsConstant, ecs_i32_t, 
                 {(ecs_i32_t)last_value});
         } else {
-            ecs_set_pair_object(world, c, EcsConstant, ecs_u32_t, 
+            ecs_set_pair_second(world, c, EcsConstant, ecs_u32_t, 
                 {(ecs_u32_t)last_value});
         }
 
diff --git a/src/addons/meta/cursor.c b/src/addons/meta/cursor.c
index 7b13804e4..8f19f7b3a 100644
--- a/src/addons/meta/cursor.c
+++ b/src/addons/meta/cursor.c
@@ -7,8 +7,8 @@
 #include <ctype.h>
 
 #ifdef FLECS_META
-#ifdef FLECS_PARSER
-#include "flecs/addons/parser.h"
+#ifdef FLECS_SCRIPT
+#include "../script/script.h"
 #endif
 
 static
@@ -79,7 +79,8 @@ static
 ecs_meta_type_op_t* flecs_meta_cursor_get_op(
     ecs_meta_scope_t *scope)
 {
-    ecs_assert(scope->ops != NULL, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(scope->ops != NULL, ECS_INVALID_OPERATION, 
+        "type serializer is missing instructions");
     return &scope->ops[scope->op_cur];
 }
 
@@ -175,8 +176,8 @@ int flecs_meta_cursor_push_type(
     ecs_entity_t type,
     void *ptr)
 {
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
     if (ser == NULL) {
         char *str = ecs_id_str(world, type);
         ecs_err("cannot open scope for '%s' (missing reflection data)", str);
@@ -318,11 +319,33 @@ int ecs_meta_member(
     return 0;
 }
 
+static
+const char* flecs_meta_parse_member(
+    const char *start,
+    char *token_out)
+{
+    const char *ptr;
+    char ch;
+    for (ptr = start; (ch = *ptr); ptr ++) {
+        if (ch == '.') {
+            break;
+        }
+    }
+
+    int32_t len = flecs_ito(int32_t, ptr - start);
+    ecs_os_memcpy(token_out, start, len);
+    token_out[len] = '\0';
+    if (ch == '.') {
+        ptr ++;
+    }
+
+    return ptr;
+}
+
 int ecs_meta_dotmember(
     ecs_meta_cursor_t *cursor,
     const char *name)
 {
-#ifdef FLECS_PARSER
     ecs_meta_scope_t *cur_scope = flecs_meta_cursor_get_scope(cursor);
     flecs_meta_cursor_restore_scope(cursor, cur_scope);
 
@@ -331,13 +354,7 @@ int ecs_meta_dotmember(
 
     char token[ECS_MAX_TOKEN_SIZE];
     const char *ptr = name;
-    while ((ptr = ecs_parse_token(NULL, NULL, ptr, token, '.'))) {
-        if (ptr[0] != '.' && ptr[0]) {
-            ecs_parser_error(NULL, name, ptr - name, 
-                "expected '.' or end of string");
-            goto error;
-        }
-
+    while ((ptr = flecs_meta_parse_member(ptr, token))) {
         if (dotcount) {
             ecs_meta_push(cursor);
         }
@@ -350,8 +367,6 @@ int ecs_meta_dotmember(
             break;   
         }
 
-        ptr ++; /* Skip . */
-
         dotcount ++;
     }
 
@@ -363,12 +378,6 @@ int ecs_meta_dotmember(
     return 0;
 error:
     return -1;
-#else
-    (void)cursor;
-    (void)name;
-    ecs_err("the FLECS_PARSER addon is required for ecs_meta_dotmember");
-    return -1;
-#endif
 }
 
 int ecs_meta_push(
@@ -484,7 +493,7 @@ int ecs_meta_push(
     case EcsOpOpaque: {
         const EcsOpaque *type_ptr = ecs_get(world, op->type, EcsOpaque);
         ecs_entity_t as_type = type_ptr->as_type;
-        const EcsMetaType *mtype_ptr = ecs_get(world, as_type, EcsMetaType);
+        const EcsType *mtype_ptr = ecs_get(world, as_type, EcsType);
 
         /* Check what kind of type the opaque type represents */
         switch(mtype_ptr->kind) {
@@ -631,8 +640,8 @@ int ecs_meta_pop(
         } else if (op->kind == EcsOpOpaque) {
             const EcsOpaque *opaque = scope->opaque;
             if (scope->is_collection) {
-                const EcsMetaType *mtype = ecs_get(cursor->world, 
-                    opaque->as_type, EcsMetaType);
+                const EcsType *mtype = ecs_get(cursor->world, 
+                    opaque->as_type, EcsType);
                 ecs_assert(mtype != NULL, ECS_INTERNAL_ERROR, NULL);
 
                 /* When popping a opaque collection type, call resize to make 
@@ -917,7 +926,9 @@ int ecs_meta_set_char(
     cases_T_signed(ptr, value, ecs_meta_bounds_signed);
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_char) { /* preferred operation */
             opaque->assign_char(ptr, value);
             break;
@@ -974,7 +985,9 @@ int ecs_meta_set_int(
     cases_T_float(ptr, value);
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_int) { /* preferred operation */
             opaque->assign_int(ptr, value);
             break;
@@ -1025,7 +1038,9 @@ int ecs_meta_set_uint(
     cases_T_float(ptr, value);
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_uint) { /* preferred operation */
             opaque->assign_uint(ptr, value);
             break;
@@ -1081,7 +1096,9 @@ int ecs_meta_set_float(
     cases_T_float(ptr, value);
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_float) { /* preferred operation */
             opaque->assign_float(ptr, value);
             break;
@@ -1126,7 +1143,7 @@ int ecs_meta_set_value(
     ecs_check(value != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_entity_t type = value->type;
     ecs_check(type != 0, ECS_INVALID_PARAMETER, NULL);
-    const EcsMetaType *mt = ecs_get(cursor->world, type, EcsMetaType);
+    const EcsType *mt = ecs_get(cursor->world, type, EcsType);
     if (!mt) {
         ecs_err("type of value does not have reflection data");
         return -1;
@@ -1200,7 +1217,7 @@ int flecs_meta_add_bitmask_constant(
         return -1;
     }
 
-    const ecs_u32_t *v = ecs_get_pair_object(
+    const ecs_u32_t *v = ecs_get_pair_second(
         cursor->world, c, EcsConstant, ecs_u32_t);
     if (v == NULL) {
         char *path = ecs_get_fullpath(cursor->world, op->type);
@@ -1267,6 +1284,13 @@ int flecs_meta_cursor_lookup(
     return 0;
 }
 
+static
+bool flecs_meta_valid_digit(
+    const char *str)
+{
+    return str[0] == '-' || isdigit(str[0]);
+}
+
 int ecs_meta_set_string(
     ecs_meta_cursor_t *cursor,
     const char *value)
@@ -1275,6 +1299,41 @@ int ecs_meta_set_string(
     ecs_meta_type_op_t *op = flecs_meta_cursor_get_op(scope);
     void *ptr = flecs_meta_cursor_get_ptr(cursor->world, scope);
 
+    switch(op->kind) {
+    case EcsOpI8:
+    case EcsOpU8:
+    case EcsOpByte:
+    case EcsOpI16:
+    case EcsOpU16:
+    case EcsOpI32:
+    case EcsOpU32:
+    case EcsOpI64:
+    case EcsOpU64:
+    case EcsOpIPtr:
+    case EcsOpUPtr:
+    case EcsOpF32:
+    case EcsOpF64:
+        if (!flecs_meta_valid_digit(value)) {
+            ecs_err("expected number, got '%s'", value);
+            goto error;
+        }
+    case EcsOpEnum:
+    case EcsOpBitmask:
+    case EcsOpArray:
+    case EcsOpVector:
+    case EcsOpOpaque:
+    case EcsOpPush:
+    case EcsOpPop:
+    case EcsOpPrimitive:
+    case EcsOpBool:
+    case EcsOpChar:
+    case EcsOpString:
+    case EcsOpEntity:
+    case EcsOpId:
+    case EcsOpScope:
+        break;
+    }
+
     switch(op->kind) {
     case EcsOpBool:
         if (!ecs_os_strcmp(value, "true")) {
@@ -1339,7 +1398,7 @@ int ecs_meta_set_string(
             goto error;
         }
 
-        const ecs_i32_t *v = ecs_get_pair_object(
+        const ecs_i32_t *v = ecs_get_pair_second(
             cursor->world, c, EcsConstant, ecs_i32_t);
         if (v == NULL) {
             char *path = ecs_get_fullpath(cursor->world, op->type);
@@ -1365,25 +1424,16 @@ int ecs_meta_set_string(
         break;
     }
     case EcsOpId: {
+    #ifdef FLECS_SCRIPT
         ecs_id_t id = 0;
-#ifdef FLECS_PARSER
-        ecs_term_t term = {0};
-        if (ecs_parse_term(
-            cursor->world, NULL, value, value, &term, NULL, NULL, false)) 
-        {
-            if (ecs_term_finalize(cursor->world, &term)) {
-                ecs_term_fini(&term);
-                goto error;
-            }
-            id = term.id;
-            ecs_term_fini(&term);
-        } else {
-            ecs_term_fini(&term);
+        if (flecs_id_parse(cursor->world, NULL, value, &id) == NULL) {
             goto error;
         }
-#endif
-        set_T(ecs_id_t, ptr, id);
 
+        set_T(ecs_id_t, ptr, id);
+    #else
+        ecs_err("cannot parse component expression: script addon required");
+    #endif
         break;
     }
     case EcsOpPop:
@@ -1391,7 +1441,9 @@ int ecs_meta_set_string(
         goto error;
     case EcsOpOpaque: {
         const EcsOpaque *opaque = ecs_get(cursor->world, op->type, EcsOpaque);
-        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, NULL);
+        ecs_assert(opaque != NULL, ECS_INVALID_OPERATION, 
+            "entity %s is not an opaque type but serializer thinks so",
+                ecs_get_name(cursor->world, op->type));
         if (opaque->assign_string) { /* preferred */
             opaque->assign_string(ptr, value);
             break;
diff --git a/src/addons/meta/definitions.c b/src/addons/meta/definitions.c
index e9487a871..5c6406671 100644
--- a/src/addons/meta/definitions.c
+++ b/src/addons/meta/definitions.c
@@ -43,8 +43,18 @@ void flecs_meta_import_core_definitions(
         }
     });
 
+    ecs_struct(world, {
+        .entity = ecs_id(EcsDefaultChildComponent),
+        .members = {
+            { .name = "component", .type = ecs_id(ecs_entity_t) }
+        }
+    });
+
     ecs_entity_t string_vec = ecs_vector(world, {
-        .entity = ecs_entity(world, { .name = "flecs.core.string_vec_t "}),
+        .entity = ecs_entity(world, { 
+            .name = "flecs.core.string_vec_t",
+            .root_sep = ""
+        }),
         .type = ecs_id(ecs_string_t)
     });
 
@@ -117,7 +127,7 @@ void flecs_meta_import_meta_definitions(
     });
 
     ecs_struct_init(world, &(ecs_struct_desc_t){
-        .entity = ecs_id(EcsMetaType),
+        .entity = ecs_id(EcsType),
         .members = {
             { .name = "kind", .type = type_kind }
         }
@@ -235,8 +245,8 @@ void flecs_meta_import_meta_definitions(
     ecs_entity_t meta = ecs_lookup(world, "flecs.meta");
     ecs_doc_set_brief(world, meta, "Flecs module with reflection components");
 
-    ecs_doc_set_brief(world, ecs_id(EcsMetaType), "Component added to types");
-    ecs_doc_set_brief(world, ecs_id(EcsMetaTypeSerialized), "Component that stores reflection data in an optimized format");
+    ecs_doc_set_brief(world, ecs_id(EcsType), "Component added to types");
+    ecs_doc_set_brief(world, ecs_id(EcsTypeSerializer), "Component that stores reflection data in an optimized format");
     ecs_doc_set_brief(world, ecs_id(EcsPrimitive), "Component added to primitive types");
     ecs_doc_set_brief(world, ecs_id(EcsEnum), "Component added to enumeration types");
     ecs_doc_set_brief(world, ecs_id(EcsBitmask), "Component added to bitmask types");
diff --git a/src/addons/meta/meta.c b/src/addons/meta/meta.c
index f5738be2d..e2a03b2b6 100644
--- a/src/addons/meta/meta.c
+++ b/src/addons/meta/meta.c
@@ -26,10 +26,10 @@ static ECS_DTOR(ecs_string_t, ptr, {
 })
 
 
-/* EcsMetaTypeSerialized lifecycle */
+/* EcsTypeSerializer lifecycle */
 
 void ecs_meta_dtor_serialized(
-    EcsMetaTypeSerialized *ptr) 
+    EcsTypeSerializer *ptr) 
 {
     int32_t i, count = ecs_vec_count(&ptr->ops);
     ecs_meta_type_op_t *ops = ecs_vec_first(&ptr->ops);
@@ -44,7 +44,7 @@ void ecs_meta_dtor_serialized(
     ecs_vec_fini_t(NULL, &ptr->ops, ecs_meta_type_op_t);
 }
 
-static ECS_COPY(EcsMetaTypeSerialized, dst, src, {
+static ECS_COPY(EcsTypeSerializer, dst, src, {
     ecs_meta_dtor_serialized(dst);
 
     dst->ops = ecs_vec_copy_t(NULL, &src->ops, ecs_meta_type_op_t);
@@ -60,13 +60,13 @@ static ECS_COPY(EcsMetaTypeSerialized, dst, src, {
     }
 })
 
-static ECS_MOVE(EcsMetaTypeSerialized, dst, src, {
+static ECS_MOVE(EcsTypeSerializer, dst, src, {
     ecs_meta_dtor_serialized(dst);
     dst->ops = src->ops;
     src->ops = (ecs_vec_t){0};
 })
 
-static ECS_DTOR(EcsMetaTypeSerialized, ptr, { 
+static ECS_DTOR(EcsTypeSerializer, ptr, { 
     ecs_meta_dtor_serialized(ptr);
 })
 
@@ -257,7 +257,7 @@ int flecs_init_type(
     ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(type != 0, ECS_INTERNAL_ERROR, NULL);
 
-    EcsMetaType *meta_type = ecs_ensure(world, type, EcsMetaType);
+    EcsType *meta_type = ecs_ensure(world, type, EcsType);
     if (meta_type->kind == 0) {
         meta_type->existing = ecs_has(world, type, EcsComponent);
 
@@ -265,7 +265,7 @@ int flecs_init_type(
          * serializers on uninitialized values. */
         ecs_type_info_t *ti = flecs_type_info_ensure(world, type);
         if (!ti->hooks.ctor) {
-            ti->hooks.ctor = ecs_default_ctor;
+            ti->hooks.ctor = flecs_default_ctor;
         }
     } else {
         if (meta_type->kind != kind) {
@@ -306,7 +306,7 @@ int flecs_init_type(
     }
 
     meta_type->kind = kind;
-    ecs_modified(world, type, EcsMetaType);
+    ecs_modified(world, type, EcsType);
 
     return 0;
 }
@@ -544,7 +544,7 @@ int flecs_add_member_to_struct(
 
     ecs_modified(world, type, EcsStruct);
 
-    /* Do this last as it triggers the update of EcsMetaTypeSerialized */
+    /* Do this last as it triggers the update of EcsTypeSerializer */
     if (flecs_init_type(world, type, EcsStructType, size, alignment)) {
         return -1;
     }
@@ -593,7 +593,7 @@ int flecs_add_constant_to_enum(
             return -1;
         }
 
-        const int32_t *value_ptr = ecs_get_pair_object(
+        const int32_t *value_ptr = ecs_get_pair_second(
             world, e, EcsConstant, ecs_i32_t);
         ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL);
         value = *value_ptr;
@@ -626,7 +626,7 @@ int flecs_add_constant_to_enum(
     c->value = value;
     c->constant = e;
 
-    ecs_i32_t *cptr = ecs_ensure_pair_object(
+    ecs_i32_t *cptr = ecs_ensure_pair_second(
         world, e, EcsConstant, ecs_i32_t);
     ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL);
     cptr[0] = value;
@@ -666,7 +666,7 @@ int flecs_add_constant_to_bitmask(
             return -1;
         }
 
-        const uint32_t *value_ptr = ecs_get_pair_object(
+        const uint32_t *value_ptr = ecs_get_pair_second(
             world, e, EcsConstant, ecs_u32_t);
         ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL);
         value = *value_ptr;
@@ -695,7 +695,7 @@ int flecs_add_constant_to_bitmask(
     c->value = value;
     c->constant = e;
 
-    ecs_u32_t *cptr = ecs_ensure_pair_object(
+    ecs_u32_t *cptr = ecs_ensure_pair_second(
         world, e, EcsConstant, ecs_u32_t);
     ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL);
     cptr[0] = value;
@@ -709,7 +709,7 @@ int flecs_add_constant_to_bitmask(
 static
 void flecs_set_primitive(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsPrimitive *type = ecs_field(it, EcsPrimitive, 1);
+    EcsPrimitive *type = ecs_field(it, EcsPrimitive, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -776,7 +776,7 @@ void flecs_set_primitive(ecs_iter_t *it) {
 static
 void flecs_set_member(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsMember *member = ecs_field(it, EcsMember, 1);
+    EcsMember *member = ecs_field(it, EcsMember, 0);
     EcsMemberRanges *ranges = ecs_table_get_id(world, it->table, 
         ecs_id(EcsMemberRanges), it->offset);
 
@@ -797,7 +797,7 @@ void flecs_set_member(ecs_iter_t *it) {
 static
 void flecs_set_member_ranges(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsMemberRanges *ranges = ecs_field(it, EcsMemberRanges, 1);
+    EcsMemberRanges *ranges = ecs_field(it, EcsMemberRanges, 0);
     EcsMember *member = ecs_table_get_id(world, it->table, 
         ecs_id(EcsMember), it->offset);
     if (!member) {
@@ -832,7 +832,7 @@ void flecs_add_enum(ecs_iter_t *it) {
 
         ecs_add_id(world, e, EcsExclusive);
         ecs_add_id(world, e, EcsOneOf);
-        ecs_add_id(world, e, EcsTag);
+        ecs_add_id(world, e, EcsPairIsTag);
     }
 }
 
@@ -874,7 +874,7 @@ void flecs_add_constant(ecs_iter_t *it) {
 static
 void flecs_set_array(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsArray *array = ecs_field(it, EcsArray, 1);
+    EcsArray *array = ecs_field(it, EcsArray, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -904,7 +904,7 @@ void flecs_set_array(ecs_iter_t *it) {
 static
 void flecs_set_vector(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsVector *array = ecs_field(it, EcsVector, 1);
+    EcsVector *array = ecs_field(it, EcsVector, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -925,7 +925,7 @@ void flecs_set_vector(ecs_iter_t *it) {
 static
 void flecs_set_custom_type(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsOpaque *serialize = ecs_field(it, EcsOpaque, 1);
+    EcsOpaque *serialize = ecs_field(it, EcsOpaque, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -1074,7 +1074,7 @@ bool flecs_unit_validate(
 
 static
 void flecs_set_unit(ecs_iter_t *it) {
-    EcsUnit *u = ecs_field(it, EcsUnit, 1);
+    EcsUnit *u = ecs_field(it, EcsUnit, 0);
 
     ecs_world_t *world = it->world;
 
@@ -1106,7 +1106,7 @@ void flecs_unit_quantity_monitor(ecs_iter_t *it) {
 static
 void ecs_meta_type_init_default_ctor(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsMetaType *type = ecs_field(it, EcsMetaType, 1);
+    EcsType *type = ecs_field(it, EcsType, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -1120,7 +1120,7 @@ void ecs_meta_type_init_default_ctor(ecs_iter_t *it) {
             if (!ti || !ti->hooks.ctor) {
                 ecs_set_hooks_id(world, e, 
                     &(ecs_type_hooks_t){ 
-                        .ctor = ecs_default_ctor
+                        .ctor = flecs_default_ctor
                     });
             }
         }
@@ -1145,71 +1145,164 @@ void FlecsMetaImport(
 
     ecs_set_name_prefix(world, "Ecs");
 
-    flecs_bootstrap_component(world, EcsMetaType);
-    flecs_bootstrap_component(world, EcsMetaTypeSerialized);
-    flecs_bootstrap_component(world, EcsPrimitive);
-    flecs_bootstrap_component(world, EcsEnum);
-    flecs_bootstrap_component(world, EcsBitmask);
-    flecs_bootstrap_component(world, EcsMember);
-    flecs_bootstrap_component(world, EcsMemberRanges);
-    flecs_bootstrap_component(world, EcsStruct);
-    flecs_bootstrap_component(world, EcsArray);
-    flecs_bootstrap_component(world, EcsVector);
-    flecs_bootstrap_component(world, EcsOpaque);
-    flecs_bootstrap_component(world, EcsUnit);
-    flecs_bootstrap_component(world, EcsUnitPrefix);
-
-    flecs_bootstrap_tag(world, EcsConstant);
-    flecs_bootstrap_tag(world, EcsQuantity);
-
-    ecs_set_hooks(world, EcsMetaType, { .ctor = ecs_default_ctor });
-
-    ecs_set_hooks(world, EcsMetaTypeSerialized, { 
-        .ctor = ecs_default_ctor,
-        .move = ecs_move(EcsMetaTypeSerialized),
-        .copy = ecs_copy(EcsMetaTypeSerialized),
-        .dtor = ecs_dtor(EcsMetaTypeSerialized)
+    flecs_bootstrap_component(world, EcsTypeSerializer);
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsType),
+            .name = "type", .symbol = "EcsType"
+        }),
+        .type.size = sizeof(EcsType),
+        .type.alignment = ECS_ALIGNOF(EcsType)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsPrimitive),
+            .name = "primitive", .symbol = "EcsPrimitive"
+        }),
+        .type.size = sizeof(EcsPrimitive),
+        .type.alignment = ECS_ALIGNOF(EcsPrimitive)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = EcsConstant,
+            .name = "constant", .symbol = "EcsConstant"
+        })
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsEnum),
+            .name = "enum", .symbol = "EcsEnum"
+        }),
+        .type.size = sizeof(EcsEnum),
+        .type.alignment = ECS_ALIGNOF(EcsEnum)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsBitmask),
+            .name = "bitmask", .symbol = "EcsBitmask"
+        }),
+        .type.size = sizeof(EcsBitmask),
+        .type.alignment = ECS_ALIGNOF(EcsBitmask)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsMember),
+            .name = "member", .symbol = "EcsMember"
+        }),
+        .type.size = sizeof(EcsMember),
+        .type.alignment = ECS_ALIGNOF(EcsMember)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsMemberRanges),
+            .name = "member_ranges", .symbol = "EcsMemberRanges"
+        }),
+        .type.size = sizeof(EcsMemberRanges),
+        .type.alignment = ECS_ALIGNOF(EcsMemberRanges)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsStruct),
+            .name = "struct", .symbol = "EcsStruct"
+        }),
+        .type.size = sizeof(EcsStruct),
+        .type.alignment = ECS_ALIGNOF(EcsStruct)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsArray),
+            .name = "array", .symbol = "EcsArray"
+        }),
+        .type.size = sizeof(EcsArray),
+        .type.alignment = ECS_ALIGNOF(EcsArray)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsVector),
+            .name = "vector", .symbol = "EcsVector"
+        }),
+        .type.size = sizeof(EcsVector),
+        .type.alignment = ECS_ALIGNOF(EcsVector)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsOpaque),
+            .name = "opaque", .symbol = "EcsOpaque"
+        }),
+        .type.size = sizeof(EcsOpaque),
+        .type.alignment = ECS_ALIGNOF(EcsOpaque)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsUnit),
+            .name = "unit", .symbol = "EcsUnit"
+        }),
+        .type.size = sizeof(EcsUnit),
+        .type.alignment = ECS_ALIGNOF(EcsUnit)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = ecs_id(EcsUnitPrefix),
+            .name = "unit_prefix", .symbol = "EcsUnitPrefix"
+        }),
+        .type.size = sizeof(EcsUnitPrefix),
+        .type.alignment = ECS_ALIGNOF(EcsUnitPrefix)
+    });
+
+    ecs_component(world, {
+        .entity = ecs_entity(world, { .id = EcsQuantity,
+            .name = "quantity", .symbol = "EcsQuantity"
+        })
+    });
+
+    ecs_set_hooks(world, EcsType, { .ctor = flecs_default_ctor });
+
+    ecs_set_hooks(world, EcsTypeSerializer, { 
+        .ctor = flecs_default_ctor,
+        .move = ecs_move(EcsTypeSerializer),
+        .copy = ecs_copy(EcsTypeSerializer),
+        .dtor = ecs_dtor(EcsTypeSerializer)
     });
 
     ecs_set_hooks(world, EcsStruct, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsStruct),
         .copy = ecs_copy(EcsStruct),
         .dtor = ecs_dtor(EcsStruct)
     });
 
     ecs_set_hooks(world, EcsMember, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .on_set = flecs_member_on_set
     });
 
     ecs_set_hooks(world, EcsMemberRanges, { 
-        .ctor = ecs_default_ctor
+        .ctor = flecs_default_ctor
     });
 
     ecs_set_hooks(world, EcsEnum, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsEnum),
         .copy = ecs_copy(EcsEnum),
         .dtor = ecs_dtor(EcsEnum)
     });
 
     ecs_set_hooks(world, EcsBitmask, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsBitmask),
         .copy = ecs_copy(EcsBitmask),
         .dtor = ecs_dtor(EcsBitmask)
     });
 
     ecs_set_hooks(world, EcsUnit, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsUnit),
         .copy = ecs_copy(EcsUnit),
         .dtor = ecs_dtor(EcsUnit)
     });
 
     ecs_set_hooks(world, EcsUnitPrefix, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsUnitPrefix),
         .copy = ecs_copy(EcsUnitPrefix),
         .dtor = ecs_dtor(EcsUnitPrefix)
@@ -1219,85 +1312,85 @@ void FlecsMetaImport(
     ecs_entity_t old_scope = ecs_set_scope( /* Keep meta scope clean */
         world, EcsFlecsInternals);
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsPrimitive), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsPrimitive), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_primitive
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsMember), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsMember), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_member
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsMemberRanges), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsMemberRanges), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_member_ranges
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsEnum), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsEnum), .src.id = EcsSelf },
         .events = {EcsOnAdd},
         .callback = flecs_add_enum
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsBitmask), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsBitmask), .src.id = EcsSelf },
         .events = {EcsOnAdd},
         .callback = flecs_add_bitmask
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = EcsConstant, .src.flags = EcsSelf },
+        .query.terms[0] = { .id = EcsConstant, .src.id = EcsSelf },
         .events = {EcsOnAdd},
         .callback = flecs_add_constant
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_pair(EcsConstant, EcsWildcard), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_pair(EcsConstant, EcsWildcard), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_add_constant
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsArray), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsArray), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_array
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsVector), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsVector), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_vector
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsOpaque), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsOpaque), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_custom_type
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsUnit), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsUnit), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = flecs_set_unit
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsMetaType), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsType), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = ecs_meta_type_serialized_init
     });
 
     ecs_observer(world, {
-        .filter.terms[0] = { .id = ecs_id(EcsMetaType), .src.flags = EcsSelf },
+        .query.terms[0] = { .id = ecs_id(EcsType), .src.id = EcsSelf },
         .events = {EcsOnSet},
         .callback = ecs_meta_type_init_default_ctor
     });
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(EcsUnit) },
             { .id = EcsQuantity }
         },
@@ -1338,28 +1431,21 @@ void FlecsMetaImport(
     #undef ECS_PRIMITIVE
 
     ecs_set_hooks(world, ecs_string_t, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .copy = ecs_copy(ecs_string_t),
         .move = ecs_move(ecs_string_t),
         .dtor = ecs_dtor(ecs_string_t)
     });
 
     /* Set default child components */
-    ecs_add_pair(world, ecs_id(EcsStruct), 
-        EcsDefaultChildComponent, ecs_id(EcsMember));
-
-    ecs_add_pair(world, ecs_id(EcsMember), 
-        EcsDefaultChildComponent, ecs_id(EcsMember));
-
-    ecs_add_pair(world, ecs_id(EcsEnum), 
-        EcsDefaultChildComponent, EcsConstant);
-
-    ecs_add_pair(world, ecs_id(EcsBitmask), 
-        EcsDefaultChildComponent, EcsConstant);
+    ecs_set(world, ecs_id(EcsStruct),  EcsDefaultChildComponent, {ecs_id(EcsMember)});
+    ecs_set(world, ecs_id(EcsMember),  EcsDefaultChildComponent, {ecs_id(EcsMember)});
+    ecs_set(world, ecs_id(EcsEnum),    EcsDefaultChildComponent, {EcsConstant});
+    ecs_set(world, ecs_id(EcsBitmask), EcsDefaultChildComponent, {EcsConstant});
 
     /* Relationship properties */
     ecs_add_id(world, EcsQuantity, EcsExclusive);
-    ecs_add_id(world, EcsQuantity, EcsTag);
+    ecs_add_id(world, EcsQuantity, EcsPairIsTag);
 
     /* Import reflection definitions for builtin types */
     flecs_meta_import_definitions(world);
diff --git a/src/addons/meta/meta.h b/src/addons/meta/meta.h
index 284e4efe1..188c678ed 100644
--- a/src/addons/meta/meta.h
+++ b/src/addons/meta/meta.h
@@ -14,7 +14,7 @@ void ecs_meta_type_serialized_init(
     ecs_iter_t *it);
 
 void ecs_meta_dtor_serialized(
-    EcsMetaTypeSerialized *ptr);
+    EcsTypeSerializer *ptr);
 
 ecs_meta_type_op_kind_t flecs_meta_primitive_to_op_kind(
     ecs_primitive_kind_t kind);
@@ -27,6 +27,13 @@ bool flecs_unit_validate(
 void flecs_meta_import_definitions(
     ecs_world_t *world);
 
+int flecs_expr_ser_primitive(
+    const ecs_world_t *world,
+    ecs_primitive_kind_t kind,
+    const void *base, 
+    ecs_strbuf_t *str,
+    bool is_expr);
+
 #endif
 
 #endif
diff --git a/src/addons/meta/serialized.c b/src/addons/meta/serialized.c
index 914e251ee..99a1b4990 100644
--- a/src/addons/meta/serialized.c
+++ b/src/addons/meta/serialized.c
@@ -231,10 +231,10 @@ int flecs_meta_serialize_type(
     ecs_size_t offset,
     ecs_vec_t *ops)
 {
-    const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType);
+    const EcsType *ptr = ecs_get(world, type, EcsType);
     if (!ptr) {
         char *path = ecs_get_fullpath(world, type);
-        ecs_err("missing EcsMetaType for type %s'", path);
+        ecs_err("missing EcsType for type %s'", path);
         ecs_os_free(path);
         return -1;
     }
@@ -258,10 +258,10 @@ int flecs_meta_serialize_component(
     ecs_entity_t type,
     ecs_vec_t *ops)
 {
-    const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType);
+    const EcsType *ptr = ecs_get(world, type, EcsType);
     if (!ptr) {
         char *path = ecs_get_fullpath(world, type);
-        ecs_err("missing EcsMetaType for type %s'", path);
+        ecs_err("missing EcsType for type %s'", path);
         ecs_os_free(path);
         return -1;
     }
@@ -285,8 +285,8 @@ void ecs_meta_type_serialized_init(
         ecs_vec_init_t(NULL, &ops, ecs_meta_type_op_t, 0);
         flecs_meta_serialize_component(world, e, &ops);
 
-        EcsMetaTypeSerialized *ptr = ecs_ensure(
-            world, e, EcsMetaTypeSerialized);
+        EcsTypeSerializer *ptr = ecs_ensure(
+            world, e, EcsTypeSerializer);
         if (ptr->ops.array) {
             ecs_meta_dtor_serialized(ptr);
         }
diff --git a/src/addons/metrics.c b/src/addons/metrics.c
index 8c0c49855..41c8721c3 100644
--- a/src/addons/metrics.c
+++ b/src/addons/metrics.c
@@ -153,7 +153,7 @@ static ECS_MOVE(EcsMetricCountTargets, dst, src, {
 static void flecs_metrics_on_member_metric(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
     ecs_member_metric_ctx_t *ctx = it->ctx;
-    ecs_id_t id = ecs_field_id(it, 1);
+    ecs_id_t id = ecs_field_id(it, 0);
 
     int32_t i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -161,7 +161,7 @@ static void flecs_metrics_on_member_metric(ecs_iter_t *it) {
         ecs_entity_t m = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
 
         EcsMetricMemberInstance *src = ecs_emplace(
-            world, m, EcsMetricMemberInstance);
+            world, m, EcsMetricMemberInstance, NULL);
         src->ref = ecs_ref_init_id(world, e, id);
         src->ctx = ctx;
         ecs_modified(world, m, EcsMetricMemberInstance);
@@ -182,7 +182,8 @@ static void flecs_metrics_on_id_metric(ecs_iter_t *it) {
         ecs_entity_t e = it->entities[i];
         ecs_entity_t m = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
 
-        EcsMetricIdInstance *src = ecs_emplace(world, m, EcsMetricIdInstance);
+        EcsMetricIdInstance *src = ecs_emplace(
+            world, m, EcsMetricIdInstance, NULL);
         src->r = ecs_record_find(world, e);
         src->ctx = ctx;
         ecs_modified(world, m, EcsMetricIdInstance);
@@ -207,7 +208,8 @@ static void flecs_metrics_on_oneof_metric(ecs_iter_t *it) {
         ecs_entity_t e = it->entities[i];
         ecs_entity_t m = ecs_new_w_pair(world, EcsChildOf, ctx->metric.metric);
 
-        EcsMetricOneOfInstance *src = ecs_emplace(world, m, EcsMetricOneOfInstance);
+        EcsMetricOneOfInstance *src = ecs_emplace(
+            world, m, EcsMetricOneOfInstance, NULL);
         src->r = ecs_record_find(world, e);
         src->ctx = ctx;
         ecs_modified(world, m, EcsMetricOneOfInstance);
@@ -222,7 +224,7 @@ static void flecs_metrics_on_oneof_metric(ecs_iter_t *it) {
 #ifdef FLECS_DOC
 static void SetMetricDocName(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsMetricSource *src = ecs_field(it, EcsMetricSource, 1);
+    EcsMetricSource *src = ecs_field(it, EcsMetricSource, 0);
 
     int32_t i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -238,7 +240,7 @@ static void SetMetricDocName(ecs_iter_t *it) {
 /** Delete metric instances for entities that are no longer alive */
 static void ClearMetricInstance(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsMetricSource *src = ecs_field(it, EcsMetricSource, 1);
+    EcsMetricSource *src = ecs_field(it, EcsMetricSource, 0);
 
     int32_t i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -252,8 +254,8 @@ static void ClearMetricInstance(ecs_iter_t *it) {
 /** Update member metric */
 static void UpdateMemberInstance(ecs_iter_t *it, bool counter) {
     ecs_world_t *world = it->real_world;
-    EcsMetricValue *m = ecs_field(it, EcsMetricValue, 1);
-    EcsMetricMemberInstance *mi = ecs_field(it, EcsMetricMemberInstance, 2);
+    EcsMetricValue *m = ecs_field(it, EcsMetricValue, 0);
+    EcsMetricMemberInstance *mi = ecs_field(it, EcsMetricMemberInstance, 1);
     ecs_ftime_t dt = it->delta_time;
 
     int32_t i, count = it->count;
@@ -294,8 +296,8 @@ static void UpdateCounterIncrementMemberInstance(ecs_iter_t *it) {
 /** Update id metric */
 static void UpdateIdInstance(ecs_iter_t *it, bool counter) {
     ecs_world_t *world = it->real_world;
-    EcsMetricValue *m = ecs_field(it, EcsMetricValue, 1);
-    EcsMetricIdInstance *mi = ecs_field(it, EcsMetricIdInstance, 2);
+    EcsMetricValue *m = ecs_field(it, EcsMetricValue, 0);
+    EcsMetricIdInstance *mi = ecs_field(it, EcsMetricIdInstance, 1);
     ecs_ftime_t dt = it->delta_time;
 
     int32_t i, count = it->count;
@@ -313,7 +315,7 @@ static void UpdateIdInstance(ecs_iter_t *it, bool counter) {
 
         ecs_id_metric_ctx_t *ctx = mi[i].ctx;
         ecs_id_record_t *idr = ctx->idr;
-        if (flecs_search_w_idr(world, table, idr->id, NULL, idr) != -1) {
+        if (flecs_search_w_idr(world, table, NULL, idr) != -1) {
             if (!counter) {
                 m[i].value = 1.0;
             } else {
@@ -338,8 +340,8 @@ static void UpdateOneOfInstance(ecs_iter_t *it, bool counter) {
     ecs_world_t *world = it->real_world;
     ecs_table_t *table = it->table;
     void *m = ecs_table_get_column(table, 
-        ecs_table_type_to_column_index(table, it->columns[0] - 1), it->offset);
-    EcsMetricOneOfInstance *mi = ecs_field(it, EcsMetricOneOfInstance, 2);
+        ecs_table_type_to_column_index(table, it->columns[0]), it->offset);
+    EcsMetricOneOfInstance *mi = ecs_field(it, EcsMetricOneOfInstance, 1);
     ecs_ftime_t dt = it->delta_time;
 
     int32_t i, count = it->count;
@@ -364,7 +366,7 @@ static void UpdateOneOfInstance(ecs_iter_t *it, bool counter) {
 
         ecs_id_record_t *idr = ctx->idr;
         ecs_id_t id;
-        if (flecs_search_w_idr(world, mtable, idr->id, &id, idr) == -1) {
+        if (flecs_search_w_idr(world, mtable, &id, idr) == -1) {
             ecs_delete(it->world, it->entities[i]);
             continue;
         }
@@ -396,7 +398,7 @@ static void UpdateCounterOneOfInstance(ecs_iter_t *it) {
 
 static void UpdateCountTargets(ecs_iter_t *it) {
     ecs_world_t *world = it->real_world;
-    EcsMetricCountTargets *m = ecs_field(it, EcsMetricCountTargets, 1);
+    EcsMetricCountTargets *m = ecs_field(it, EcsMetricCountTargets, 0);
 
     int32_t i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -427,8 +429,8 @@ static void UpdateCountTargets(ecs_iter_t *it) {
 
 static void UpdateCountIds(ecs_iter_t *it) {
     ecs_world_t *world = it->real_world;
-    EcsMetricCountIds *m = ecs_field(it, EcsMetricCountIds, 1);
-    EcsMetricValue *v = ecs_field(it, EcsMetricValue, 2);
+    EcsMetricCountIds *m = ecs_field(it, EcsMetricCountIds, 0);
+    EcsMetricValue *v = ecs_field(it, EcsMetricValue, 1);
 
     int32_t i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -540,7 +542,7 @@ int flecs_member_metric_init(
         goto error;
     }
 
-    const EcsMetaType *mt = ecs_get(world, type, EcsMetaType);
+    const EcsType *mt = ecs_get(world, type, EcsType);
     if (!mt) {
         char *metric_name = ecs_get_fullpath(world, metric);
         char *member_name = ecs_get_fullpath(world, desc->member);
@@ -570,9 +572,9 @@ int flecs_member_metric_init(
     ecs_observer(world, {
         .entity = metric,
         .events = { EcsOnAdd },
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = id,
-            .src.flags = EcsSelf,
+            .src.id = EcsSelf,
             .inout = EcsInOutNone
         },
         .callback = flecs_metrics_on_member_metric,
@@ -600,14 +602,14 @@ int flecs_id_metric_init(
     ctx->metric.metric = metric;
     ctx->metric.kind = desc->kind;
     ctx->idr = flecs_id_record_ensure(world, desc->id);
-    ecs_check(ctx->idr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ctx->idr != NULL, ECS_INTERNAL_ERROR, NULL);
 
     ecs_observer(world, {
         .entity = metric,
         .events = { EcsOnAdd },
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = desc->id,
-            .src.flags = EcsSelf,
+            .src.id = EcsSelf,
             .inout = EcsInOutNone
         },
         .callback = flecs_metrics_on_id_metric,
@@ -636,7 +638,7 @@ int flecs_oneof_metric_init(
     ctx->metric.metric = metric;
     ctx->metric.kind = desc->kind;
     ctx->idr = flecs_id_record_ensure(world, desc->id);
-    ecs_check(ctx->idr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ctx->idr != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_map_init(&ctx->target_offset, NULL);
 
     /* Add member for each child of oneof to metric, so it can be used as metric
@@ -657,7 +659,7 @@ int flecs_oneof_metric_init(
 
             ecs_entity_t mbr = ecs_entity(world, {
                 .name = to_snake_case,
-                .add = { ecs_childof(metric) }
+                .parent = ecs_childof(metric)
             });
 
             ecs_os_free(to_snake_case);
@@ -680,9 +682,9 @@ int flecs_oneof_metric_init(
     ecs_observer(world, {
         .entity = metric,
         .events = { EcsMonitor },
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = desc->id,
-            .src.flags = EcsSelf,
+            .src.id = EcsSelf,
             .inout = EcsInOutNone
         },
         .callback = flecs_metrics_on_oneof_metric,
@@ -709,7 +711,7 @@ int flecs_count_id_targets_metric_init(
     ctx->metric.metric = metric;
     ctx->metric.kind = desc->kind;
     ctx->idr = flecs_id_record_ensure(world, desc->id);
-    ecs_check(ctx->idr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ctx->idr != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_map_init(&ctx->targets, NULL);
 
     ecs_set(world, metric, EcsMetricCountTargets, { .ctx = ctx });
@@ -737,12 +739,13 @@ ecs_entity_t ecs_metric_init(
     const ecs_metric_desc_t *desc)
 {
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_poly_assert(world, ecs_world_t);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_metric_desc_t was not initialized to zero");
+    flecs_poly_assert(world, ecs_world_t);
 
     ecs_entity_t result = desc->entity;
     if (!result) {
-        result = ecs_new_id(world);
+        result = ecs_new(world);
     }
 
     ecs_entity_t kind = desc->kind;
@@ -888,25 +891,25 @@ void FlecsMetricsImport(ecs_world_t *world) {
     });
 
     ecs_set_hooks(world, EcsMetricMember, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(EcsMetricMember),
         .move = ecs_move(EcsMetricMember)
     });
 
     ecs_set_hooks(world, EcsMetricId, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(EcsMetricId),
         .move = ecs_move(EcsMetricId)
     });
 
     ecs_set_hooks(world, EcsMetricOneOf, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(EcsMetricOneOf),
         .move = ecs_move(EcsMetricOneOf)
     });
 
     ecs_set_hooks(world, EcsMetricCountTargets, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(EcsMetricCountTargets),
         .move = ecs_move(EcsMetricCountTargets)
     });
@@ -914,7 +917,8 @@ void FlecsMetricsImport(ecs_world_t *world) {
     ecs_add_id(world, EcsMetric, EcsOneOf);
 
 #ifdef FLECS_DOC
-    ECS_OBSERVER(world, SetMetricDocName, EcsOnSet, EcsMetricSource);
+    ECS_OBSERVER(world, SetMetricDocName, EcsOnSet, 
+        Source);
 #endif
 
     ECS_SYSTEM(world, ClearMetricInstance, EcsPreStore,
diff --git a/src/addons/module.c b/src/addons/module.c
index 9ba1569d2..6c1bc4965 100644
--- a/src/addons/module.c
+++ b/src/addons/module.c
@@ -10,7 +10,7 @@
 #include "../private_api.h"
 #include <ctype.h>
 
-char* ecs_module_path_from_c(
+char* flecs_module_path_from_c(
     const char *c_name)
 {
     ecs_strbuf_t str = ECS_STRBUF_INIT;
@@ -42,7 +42,7 @@ ecs_entity_t ecs_import(
     ecs_entity_t old_scope = ecs_set_scope(world, 0);
     const char *old_name_prefix = world->info.name_prefix;
 
-    char *path = ecs_module_path_from_c(module_name);
+    char *path = flecs_module_path_from_c(module_name);
     ecs_entity_t e = ecs_lookup(world, path);
     ecs_os_free(path);
     
@@ -74,7 +74,7 @@ ecs_entity_t ecs_import_c(
     ecs_module_action_t module,
     const char *c_name)
 {
-    char *name = ecs_module_path_from_c(c_name);
+    char *name = flecs_module_path_from_c(c_name);
     ecs_entity_t e = ecs_import(world, module, name);
     ecs_os_free(name);
     return e;
@@ -195,18 +195,18 @@ ecs_entity_t ecs_module_init(
     const ecs_component_desc_t *desc)
 {
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     ecs_entity_t old_scope = ecs_set_scope(world, 0);
 
     ecs_entity_t e = desc->entity;
     if (!e) {
-        char *module_path = ecs_module_path_from_c(c_name);
-        e = ecs_new_from_fullpath(world, module_path);
+        char *module_path = flecs_module_path_from_c(c_name);
+        e = ecs_entity(world, { .name = module_path });
         ecs_set_symbol(world, e, module_path);
         ecs_os_free(module_path);
     } else if (!ecs_exists(world, e)) {
-        char *module_path = ecs_module_path_from_c(c_name);
+        char *module_path = flecs_module_path_from_c(c_name);
         ecs_make_alive(world, e);
         ecs_add_fullpath(world, e, module_path);
         ecs_set_symbol(world, e, module_path);
diff --git a/src/addons/monitor.c b/src/addons/monitor.c
index 84245e70f..8a2d56d7e 100644
--- a/src/addons/monitor.c
+++ b/src/addons/monitor.c
@@ -42,7 +42,7 @@ ECS_DTOR(EcsPipelineStats, ptr, {
 
 static
 void UpdateWorldSummary(ecs_iter_t *it) {
-    EcsWorldSummary *summary = ecs_field(it, EcsWorldSummary, 1);
+    EcsWorldSummary *summary = ecs_field(it, EcsWorldSummary, 0);
 
     const ecs_world_info_t *info = ecs_get_world_info(it->world);
 
@@ -79,8 +79,8 @@ static
 void MonitorStats(ecs_iter_t *it) {
     ecs_world_t *world = it->real_world;
 
-    EcsStatsHeader *hdr = ecs_field_w_size(it, 0, 1);
-    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 1));
+    EcsStatsHeader *hdr = ecs_field_w_size(it, 0, 0);
+    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 0));
     void *stats = ECS_OFFSET_T(hdr, EcsStatsHeader);
 
     ecs_ftime_t elapsed = hdr->elapsed;
@@ -138,10 +138,10 @@ void MonitorStats(ecs_iter_t *it) {
 
 static
 void ReduceStats(ecs_iter_t *it) {
-    void *dst = ecs_field_w_size(it, 0, 1);
-    void *src = ecs_field_w_size(it, 0, 2);
+    void *dst = ecs_field_w_size(it, 0, 0);
+    void *src = ecs_field_w_size(it, 0, 1);
 
-    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 1));
+    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 0));
 
     dst = ECS_OFFSET_T(dst, EcsStatsHeader);
     src = ECS_OFFSET_T(src, EcsStatsHeader);
@@ -157,13 +157,13 @@ static
 void AggregateStats(ecs_iter_t *it) {
     int32_t interval = *(int32_t*)it->ctx;
 
-    EcsStatsHeader *dst_hdr = ecs_field_w_size(it, 0, 1);
-    EcsStatsHeader *src_hdr = ecs_field_w_size(it, 0, 2);
+    EcsStatsHeader *dst_hdr = ecs_field_w_size(it, 0, 0);
+    EcsStatsHeader *src_hdr = ecs_field_w_size(it, 0, 1);
 
     void *dst = ECS_OFFSET_T(dst_hdr, EcsStatsHeader);
     void *src = ECS_OFFSET_T(src_hdr, EcsStatsHeader);
 
-    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 1));
+    ecs_id_t kind = ecs_pair_first(it->world, ecs_field_id(it, 0));
 
     ecs_world_stats_t last_world = {0};
     ecs_pipeline_stats_t last_pipeline = {0};
@@ -211,15 +211,14 @@ void AggregateStats(ecs_iter_t *it) {
 static
 void flecs_stats_monitor_import(
     ecs_world_t *world,
-    ecs_id_t kind,
-    size_t size)
+    ecs_id_t kind)
 {
     ecs_entity_t prev = ecs_set_scope(world, kind);
 
     // Called each frame, collects 60 measurements per second
     ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1s", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
+        .entity = ecs_entity(world, { .name = "Monitor1s", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
             .id = ecs_pair(kind, EcsPeriod1s),
             .src.id = EcsWorld 
         }},
@@ -228,8 +227,8 @@ void flecs_stats_monitor_import(
 
     // Called each second, reduces into 60 measurements per minute
     ecs_entity_t mw1m = ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1m", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
+        .entity = ecs_entity(world, { .name = "Monitor1m", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
             .id = ecs_pair(kind, EcsPeriod1m),
             .src.id = EcsWorld 
         }, {
@@ -242,8 +241,8 @@ void flecs_stats_monitor_import(
 
     // Called each minute, reduces into 60 measurements per hour
     ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1h", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
+        .entity = ecs_entity(world, { .name = "Monitor1h", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
             .id = ecs_pair(kind, EcsPeriod1h),
             .src.id = EcsWorld 
         }, {
@@ -257,8 +256,8 @@ void flecs_stats_monitor_import(
 
     // Called each minute, reduces into 60 measurements per day
     ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1d", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
+        .entity = ecs_entity(world, { .name = "Monitor1d", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
             .id = ecs_pair(kind, EcsPeriod1d),
             .src.id = EcsWorld 
         }, {
@@ -273,8 +272,8 @@ void flecs_stats_monitor_import(
 
     // Called each hour, reduces into 60 measurements per week
     ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "Monitor1w", .add = {ecs_dependson(EcsPreFrame)} }),
-        .query.filter.terms = {{
+        .entity = ecs_entity(world, { .name = "Monitor1w", .add = ecs_ids(ecs_dependson(EcsPreFrame)) }),
+        .query.terms = {{
             .id = ecs_pair(kind, EcsPeriod1w),
             .src.id = EcsWorld 
         }, {
@@ -289,11 +288,11 @@ void flecs_stats_monitor_import(
 
     ecs_set_scope(world, prev);
 
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1s), size, NULL);
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1m), size, NULL);
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1h), size, NULL);
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1d), size, NULL);
-    ecs_set_id(world, EcsWorld, ecs_pair(kind, EcsPeriod1w), size, NULL);
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1s);
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1m);
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1h);
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1d);
+    ecs_add_pair(world, EcsWorld, kind, EcsPeriod1w);
 }
 
 static
@@ -302,8 +301,11 @@ void flecs_world_monitor_import(
 {
     ECS_COMPONENT_DEFINE(world, EcsWorldStats);
 
-    flecs_stats_monitor_import(world, ecs_id(EcsWorldStats), 
-        sizeof(EcsWorldStats));
+    ecs_set_hooks(world, EcsWorldStats, {
+        .ctor = flecs_default_ctor
+    });
+
+    flecs_stats_monitor_import(world, ecs_id(EcsWorldStats));
 }
 
 static
@@ -313,14 +315,13 @@ void flecs_pipeline_monitor_import(
     ECS_COMPONENT_DEFINE(world, EcsPipelineStats);
 
     ecs_set_hooks(world, EcsPipelineStats, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .copy = ecs_copy(EcsPipelineStats),
         .move = ecs_move(EcsPipelineStats),
         .dtor = ecs_dtor(EcsPipelineStats)
     });
 
-    flecs_stats_monitor_import(world, ecs_id(EcsPipelineStats),
-        sizeof(EcsPipelineStats));
+    flecs_stats_monitor_import(world, ecs_id(EcsPipelineStats));
 }
 
 void FlecsMonitorImport(
@@ -343,11 +344,11 @@ void FlecsMonitorImport(
 
     ecs_set_name_prefix(world, "Ecs");
 
-    EcsPeriod1s = ecs_new_entity(world, "EcsPeriod1s");
-    EcsPeriod1m = ecs_new_entity(world, "EcsPeriod1m");
-    EcsPeriod1h = ecs_new_entity(world, "EcsPeriod1h");
-    EcsPeriod1d = ecs_new_entity(world, "EcsPeriod1d");
-    EcsPeriod1w = ecs_new_entity(world, "EcsPeriod1w");
+    EcsPeriod1s = ecs_entity(world, { .name = "EcsPeriod1s" });
+    EcsPeriod1m = ecs_entity(world, { .name = "EcsPeriod1m" });
+    EcsPeriod1h = ecs_entity(world, { .name = "EcsPeriod1h" });
+    EcsPeriod1d = ecs_entity(world, { .name = "EcsPeriod1d" });
+    EcsPeriod1w = ecs_entity(world, { .name = "EcsPeriod1w" });
 
     ECS_COMPONENT_DEFINE(world, EcsWorldSummary);
 
@@ -373,9 +374,9 @@ void FlecsMonitorImport(
     ecs_system(world, {
         .entity = ecs_entity(world, { 
             .name = "UpdateWorldSummary", 
-            .add = {ecs_dependson(EcsPreFrame)} 
+            .add = ecs_ids(ecs_dependson(EcsPreFrame)) 
         }),
-        .query.filter.terms[0] = { .id = ecs_id(EcsWorldSummary) },
+        .query.terms[0] = { .id = ecs_id(EcsWorldSummary) },
         .callback = UpdateWorldSummary
     });
 
diff --git a/src/addons/parser.c b/src/addons/parser.c
deleted file mode 100644
index 5e6b1860f..000000000
--- a/src/addons/parser.c
+++ /dev/null
@@ -1,1187 +0,0 @@
-/**
- * @file addons/parser.c
- * @brief Parser addon.
- */
-
-#include "flecs.h"
-
-#ifdef FLECS_PARSER
-
-#include "../private_api.h"
-#include <ctype.h>
-
-#define TOK_COLON ':'
-#define TOK_AND ','
-#define TOK_OR "||"
-#define TOK_NOT '!'
-#define TOK_OPTIONAL '?'
-#define TOK_BITWISE_OR '|'
-#define TOK_BRACKET_OPEN '['
-#define TOK_BRACKET_CLOSE ']'
-#define TOK_SCOPE_OPEN '{'
-#define TOK_SCOPE_CLOSE '}'
-#define TOK_VARIABLE '$'
-#define TOK_PAREN_OPEN '('
-#define TOK_PAREN_CLOSE ')'
-#define TOK_EQ "=="
-#define TOK_NEQ "!="
-#define TOK_MATCH "~="
-#define TOK_EXPR_STRING '"'
-
-#define TOK_SELF "self"
-#define TOK_UP "up"
-#define TOK_DOWN "down"
-#define TOK_CASCADE "cascade"
-#define TOK_PARENT "parent"
-#define TOK_DESC "desc"
-
-#define TOK_OVERRIDE "OVERRIDE"
-#define TOK_ROLE_AND "AND"
-#define TOK_ROLE_OR "OR"
-#define TOK_ROLE_NOT "NOT"
-#define TOK_ROLE_TOGGLE "TOGGLE"
-
-#define TOK_IN "in"
-#define TOK_OUT "out"
-#define TOK_INOUT "inout"
-#define TOK_INOUT_NONE "none"
-
-static
-const ecs_id_t ECS_OR =                                            (1ull << 59);
-
-static
-const ecs_id_t ECS_NOT =                                           (1ull << 58);
-
-#define ECS_MAX_TOKEN_SIZE (256)
-
-typedef char ecs_token_t[ECS_MAX_TOKEN_SIZE];
-
-const char* ecs_parse_ws_eol(
-    const char *ptr)
-{
-    while (isspace(*ptr)) {
-        ptr ++;
-    }
-
-    return ptr;
-}
-
-const char* ecs_parse_ws(
-    const char *ptr)
-{
-    while ((*ptr != '\n') && isspace(*ptr)) {
-        ptr ++;
-    }
-
-    return ptr;
-}
-
-const char* ecs_parse_digit(
-    const char *ptr,
-    char *token)
-{
-    char *tptr = token;
-    char ch = ptr[0];
-
-    if (!isdigit(ch) && ch != '-') {
-        ecs_parser_error(NULL, NULL, 0, "invalid start of number '%s'", ptr);
-        return NULL;
-    }
-
-    tptr[0] = ch;
-    tptr ++;
-    ptr ++;
-
-    for (; (ch = *ptr); ptr ++) {
-        if (!isdigit(ch) && (ch != '.') && (ch != 'e')) {
-            break;
-        }
-
-        tptr[0] = ch;
-        tptr ++;
-    }
-
-    tptr[0] = '\0';
-    
-    return ptr;
-}
-
-/* -- Private functions -- */
-
-bool flecs_isident(
-    char ch)
-{
-    return isalpha(ch) || (ch == '_');
-}
-
-static
-bool flecs_valid_identifier_start_char(
-    char ch)
-{
-    if (ch && (flecs_isident(ch) || (ch == '*') ||
-        (ch == '0') || (ch == TOK_VARIABLE) || isdigit(ch))) 
-    {
-        return true;
-    }
-
-    return false;
-}
-
-static
-bool flecs_valid_token_start_char(
-    char ch)
-{
-    if ((ch == '"') || (ch == '{') || (ch == '}') || (ch == ',') || (ch == '-')
-        || (ch == '[') || (ch == ']') || (ch == '`') || 
-        flecs_valid_identifier_start_char(ch))
-    {
-        return true;
-    }
-
-    return false;
-}
-
-static
-bool flecs_valid_token_char(
-    char ch)
-{
-    if (ch && (flecs_isident(ch) || isdigit(ch) || ch == '.' || ch == '"')) {
-        return true;
-    }
-
-    return false;
-}
-
-static
-bool flecs_valid_operator_char(
-    char ch)
-{
-    if (ch == TOK_OPTIONAL || ch == TOK_NOT) {
-        return true;
-    }
-
-    return false;
-}
-
-const char* ecs_parse_token(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token_out,
-    char delim)
-{
-    int64_t column = ptr - expr;
-
-    ptr = ecs_parse_ws(ptr);
-    char *tptr = token_out, ch = ptr[0];
-
-    if (!flecs_valid_token_start_char(ch)) {
-        if (ch == '\0' || ch == '\n') {
-            ecs_parser_error(name, expr, column, 
-                "unexpected end of expression");
-        } else {
-            ecs_parser_error(name, expr, column, 
-                "invalid start of token '%s'", ptr);
-        }
-        return NULL;
-    }
-
-    tptr[0] = ch;
-    tptr ++;
-    ptr ++;
-
-    if (ch == '{' || ch == '}' || ch == '[' || ch == ']' || ch == ',' || ch == '`') {
-        tptr[0] = 0;
-        return ptr;
-    }
-
-    int tmpl_nesting = 0;
-    bool in_str = ch == '"';
-
-    for (; (ch = *ptr); ptr ++) {
-        if (ch == '<') {
-            tmpl_nesting ++;
-        } else if (ch == '>') {
-            if (!tmpl_nesting) {
-                break;
-            }
-            tmpl_nesting --;
-        } else if (ch == '"') {
-            in_str = !in_str;
-        } else if (ch == '\\') {
-            ptr ++;
-            tptr[0] = ptr[0];
-            tptr ++;
-            continue;
-        } else if (!flecs_valid_token_char(ch) && !in_str) {
-            break;
-        }
-
-        if (delim && (ch == delim)) {
-            break;
-        }
-
-        tptr[0] = ch;
-        tptr ++;
-    }
-
-    tptr[0] = '\0';
-
-    if (tmpl_nesting != 0) {
-        ecs_parser_error(name, expr, column, 
-            "identifier '%s' has mismatching < > pairs", ptr);
-        return NULL;
-    }
-
-    const char *next_ptr = ecs_parse_ws(ptr);
-    if (next_ptr[0] == ':' && next_ptr != ptr) {
-        /* Whitespace between token and : is significant */
-        ptr = next_ptr - 1;
-    } else {
-        ptr = next_ptr;
-    }
-
-    return ptr;
-}
-
-const char* ecs_parse_identifier(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char *token_out)
-{
-    if (!flecs_valid_identifier_start_char(ptr[0]) && (ptr[0] != '"')) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "expected start of identifier");
-        return NULL;
-    }
-
-    ptr = ecs_parse_token(name, expr, ptr, token_out, 0);
-
-    return ptr;
-}
-
-static
-int flecs_parse_identifier(
-    const char *token,
-    ecs_term_id_t *out)
-{
-    const char *tptr = token;
-    if (tptr[0] == TOK_VARIABLE && tptr[1]) {
-        out->flags |= EcsIsVariable;
-        tptr ++;
-    }
-    if (tptr[0] == TOK_EXPR_STRING && tptr[1]) {
-        out->flags |= EcsIsName;
-        tptr ++;
-        if (tptr[0] == TOK_NOT) {
-            /* Already parsed */
-            tptr ++;
-        }
-    }
-
-    char *name = ecs_os_strdup(tptr);
-    out->name = name;
-
-    ecs_size_t len = ecs_os_strlen(name);
-    if (out->flags & EcsIsName) {
-        if (name[len - 1] != TOK_EXPR_STRING) {
-            ecs_parser_error(NULL, token, 0, "missing '\"' at end of string");
-            return -1;
-        } else {
-            name[len - 1] = '\0';
-        }
-    }
-
-    return 0;
-}
-
-static
-ecs_entity_t flecs_parse_role(
-    const char *name,
-    const char *sig,
-    int64_t column,
-    const char *token)
-{
-    if (!ecs_os_strcmp(token, TOK_ROLE_AND)) {
-        return ECS_AND;
-    } else if (!ecs_os_strcmp(token, TOK_ROLE_OR)) {
-        return ECS_OR;
-    } else if (!ecs_os_strcmp(token, TOK_ROLE_NOT)) {
-        return ECS_NOT;
-    } else if (!ecs_os_strcmp(token, TOK_OVERRIDE)) {
-        return ECS_OVERRIDE;
-    } else if (!ecs_os_strcmp(token, TOK_ROLE_TOGGLE)) {
-        return ECS_TOGGLE;        
-    } else {
-        ecs_parser_error(name, sig, column, "invalid role '%s'", token);
-        return 0;
-    }
-}
-
-static
-ecs_oper_kind_t flecs_parse_operator(
-    char ch)
-{
-    if (ch == TOK_OPTIONAL) {
-        return EcsOptional;
-    } else if (ch == TOK_NOT) {
-        return EcsNot;
-    } else {
-        ecs_throw(ECS_INTERNAL_ERROR, NULL);
-    }
-error:
-    return 0;
-}
-
-static
-const char* flecs_parse_annotation(
-    const char *name,
-    const char *sig,
-    int64_t column,
-    const char *ptr, 
-    ecs_inout_kind_t *inout_kind_out)
-{
-    char token[ECS_MAX_TOKEN_SIZE];
-
-    ptr = ecs_parse_identifier(name, sig, ptr, token);
-    if (!ptr) {
-        return NULL;
-    }
-
-    if (!ecs_os_strcmp(token, TOK_IN)) {
-        *inout_kind_out = EcsIn;
-    } else
-    if (!ecs_os_strcmp(token, TOK_OUT)) {
-        *inout_kind_out = EcsOut;
-    } else
-    if (!ecs_os_strcmp(token, TOK_INOUT)) {
-        *inout_kind_out = EcsInOut;
-    } else if (!ecs_os_strcmp(token, TOK_INOUT_NONE)) {
-        *inout_kind_out = EcsInOutNone;
-    }
-
-    ptr = ecs_parse_ws(ptr);
-
-    if (ptr[0] != TOK_BRACKET_CLOSE) {
-        ecs_parser_error(name, sig, column, "expected ]");
-        return NULL;
-    }
-
-    return ptr + 1;
-}
-
-static
-uint8_t flecs_parse_set_token(
-    const char *token)
-{
-    if (!ecs_os_strcmp(token, TOK_SELF)) {
-        return EcsSelf;
-    } else if (!ecs_os_strcmp(token, TOK_UP)) {
-        return EcsUp;
-    } else if (!ecs_os_strcmp(token, TOK_DOWN)) {
-        return EcsDown;
-    } else if (!ecs_os_strcmp(token, TOK_CASCADE)) {
-        return EcsCascade;
-    } else if (!ecs_os_strcmp(token, TOK_DESC)) {
-        return EcsDesc;
-    } else if (!ecs_os_strcmp(token, TOK_PARENT)) {
-        return EcsParent;
-    } else {
-        return 0;
-    }
-}
-
-static
-const char* flecs_parse_term_flags(
-    const ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    int64_t column,
-    const char *ptr,
-    char *token,
-    ecs_term_id_t *id,
-    char tok_end)
-{
-    char token_buf[ECS_MAX_TOKEN_SIZE] = {0};
-    if (!token) {
-        token = token_buf;
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            return NULL;
-        }
-    }
-
-    do {
-        uint8_t tok = flecs_parse_set_token(token);
-        if (!tok) {
-            ecs_parser_error(name, expr, column, 
-                "invalid set token '%s'", token);
-            return NULL;
-        }
-
-        if (id->flags & tok) {
-            ecs_parser_error(name, expr, column, 
-                "duplicate set token '%s'", token);
-            return NULL;            
-        }
-        
-        id->flags |= tok;
-
-        if (ptr[0] == TOK_PAREN_OPEN) {
-            ptr ++;
-
-            /* Relationship (overrides IsA default) */
-            if (!isdigit(ptr[0]) && flecs_valid_token_start_char(ptr[0])) {
-                ptr = ecs_parse_identifier(name, expr, ptr, token);
-                if (!ptr) {
-                    return NULL;
-                }         
-
-                id->trav = ecs_lookup(world, token);
-                if (!id->trav) {
-                    ecs_parser_error(name, expr, column, 
-                        "unresolved identifier '%s'", token);
-                    return NULL;
-                }
-
-                if (ptr[0] == TOK_AND) {
-                    ptr = ecs_parse_ws(ptr + 1);
-                } else if (ptr[0] != TOK_PAREN_CLOSE) {
-                    ecs_parser_error(name, expr, column, 
-                        "expected ',' or ')'");
-                    return NULL;
-                }
-            }
-
-            if (ptr[0] != TOK_PAREN_CLOSE) {
-                ecs_parser_error(name, expr, column, "expected ')', got '%c'",
-                    ptr[0]);
-                return NULL;                
-            } else {
-                ptr = ecs_parse_ws(ptr + 1);
-                if (ptr[0] != tok_end && ptr[0] != TOK_AND && ptr[0] != 0) {
-                    ecs_parser_error(name, expr, column, 
-                        "expected end of set expr");
-                    return NULL;
-                }
-            }
-        }
-
-        /* Next token in set expression */
-        if (ptr[0] == TOK_BITWISE_OR) {
-            ptr ++;
-            if (flecs_valid_token_start_char(ptr[0])) {
-                ptr = ecs_parse_identifier(name, expr, ptr, token);
-                if (!ptr) {
-                    return NULL;
-                }
-            }
-
-        /* End of set expression */
-        } else if (ptr[0] == tok_end || ptr[0] == TOK_AND || !ptr[0]) {
-            break;
-        }
-    } while (true);
-
-    return ptr;
-}
-
-static
-const char* flecs_parse_arguments(
-    const ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    int64_t column,
-    const char *ptr,
-    char *token,
-    ecs_term_t *term,
-    ecs_oper_kind_t *extra_oper,
-    ecs_term_id_t *extra_args)
-{
-    (void)column;
-
-    int32_t i, arg = 0;
-
-    if (extra_args) {
-        ecs_os_memset_n(extra_args, 0, ecs_term_id_t, ECS_PARSER_MAX_ARGS);
-    }
-
-    if (!term) {
-        arg = 2;
-    }
-
-    do {
-        if (flecs_valid_token_start_char(ptr[0])) {
-            if ((arg == ECS_PARSER_MAX_ARGS) || (!extra_args && arg == 2)) {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "too many arguments in term");
-                goto error;
-            }
-
-            ptr = ecs_parse_identifier(name, expr, ptr, token);
-            if (!ptr) {
-                goto error;
-            }
-
-            ptr = ecs_parse_ws_eol(ptr);
-
-            ecs_term_id_t *term_id = NULL;
-            if (arg == 0) {
-                term_id = &term->src;
-            } else if (arg == 1) {
-                term_id = &term->second;
-            } else {
-                term_id = &extra_args[arg - 2];
-            }
-
-            /* If token is a colon, the token is an identifier followed by a
-             * set expression. */
-            if (ptr[0] == TOK_COLON) {
-                if (flecs_parse_identifier(token, term_id)) {
-                    ecs_parser_error(name, expr, (ptr - expr), 
-                        "invalid identifier '%s'", token);
-                    goto error;
-                }
-
-                ptr = ecs_parse_ws_eol(ptr + 1);
-                ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr,
-                    NULL, term_id, TOK_PAREN_CLOSE);
-                if (!ptr) {
-                    goto error;
-                }
-
-            /* Check for term flags */
-            } else if (!ecs_os_strcmp(token, TOK_CASCADE) ||
-                !ecs_os_strcmp(token, TOK_DESC) ||
-                !ecs_os_strcmp(token, TOK_SELF) || 
-                !ecs_os_strcmp(token, TOK_UP) || 
-                !ecs_os_strcmp(token, TOK_DOWN) || 
-                !(ecs_os_strcmp(token, TOK_PARENT)))
-            {
-                ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr, 
-                    token, term_id, TOK_PAREN_CLOSE);
-                if (!ptr) {
-                    goto error;
-                }
-
-            /* Regular identifier */
-            } else if (flecs_parse_identifier(token, term_id)) {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "invalid identifier '%s'", token);
-                goto error;
-            }
-
-            if (ptr[0] == TOK_AND) {
-                if (extra_oper && *extra_oper != EcsAnd) {
-                    ecs_parser_error(name, expr, (ptr - expr), 
-                        "cannot mix ',' and '||' in term arguments");
-                    goto error;
-                }
-                ptr = ecs_parse_ws_eol(ptr + 1);
-
-                if (term) {
-                    term->id_flags = ECS_PAIR;
-                }
-
-            } else if (ptr[0] == TOK_PAREN_CLOSE) {
-                ptr = ecs_parse_ws(ptr + 1);
-                break;
-
-            } else if (extra_oper && ptr[0] == TOK_OR[0] && ptr[1] == TOK_OR[1]){
-                if (arg >= 2 && *extra_oper != EcsOr) {
-                    ecs_parser_error(name, expr, (ptr - expr), 
-                        "cannot mix ',' and '||' in term arguments");
-                    goto error;
-                }
-
-                *extra_oper = EcsOr;
-                ptr = ecs_parse_ws_eol(ptr + 2);
-
-                if (term) {
-                    term->id_flags = ECS_PAIR;
-                }
-            } else {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "expected ',' or ')'");
-                goto error;
-            }
-
-        } else {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "expected identifier or set expression");
-            goto error;
-        }
-
-        arg ++;
-
-    } while (true);
-
-    return ptr;
-error:
-    if (term && term->src.name) {
-        ecs_os_free(ECS_CONST_CAST(char*, term->src.name));
-        term->src.name = NULL;
-    }
-    if (term && term->second.name) {
-        ecs_os_free(ECS_CONST_CAST(char*, term->second.name));
-        term->second.name = NULL;
-    }
-    if (extra_args) {
-        for (i = 2; i < arg + 1; i ++) {
-            if (extra_args[i - 2].name) {
-                ecs_os_free(ECS_CONST_CAST(char*, extra_args[i - 2].name));
-                extra_args[i - 2].name = NULL;
-            }
-        }
-    }
-    return NULL;
-}
-
-static
-void flecs_parser_unexpected_char(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    char ch)
-{
-    if (ch && (ch != '\n')) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "unexpected character '%c'", ch);
-    } else {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "unexpected end of term");
-    }
-}
-
-static
-const char* flecs_parse_term(
-    const ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    ecs_term_t *term_out,
-    ecs_oper_kind_t *extra_oper,
-    ecs_term_id_t *extra_args)
-{
-    const char *ptr = expr;
-    char token[ECS_MAX_TOKEN_SIZE] = {0};
-    ecs_term_t term = { .move = true /* parser never owns resources */ };
-
-    ptr = ecs_parse_ws(ptr);
-
-    /* Inout specifiers always come first */
-    if (ptr[0] == TOK_BRACKET_OPEN) {
-        ptr = flecs_parse_annotation(name, expr, (ptr - expr), ptr + 1, &term.inout);
-        if (!ptr) {
-            goto error;
-        }
-        ptr = ecs_parse_ws_eol(ptr);
-    }
-
-    if (flecs_valid_operator_char(ptr[0])) {
-        term.oper = flecs_parse_operator(ptr[0]);
-        ptr = ecs_parse_ws(ptr + 1);
-    }
-
-    /* If next token is the start of an identifier, it could be either a type
-     * role, source or component identifier */
-    if (flecs_valid_identifier_start_char(ptr[0])) {
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            goto error;
-        }
-
-        /* Is token a type role? */
-        if (ptr[0] == TOK_BITWISE_OR && ptr[1] != TOK_BITWISE_OR) {
-            ptr ++;
-            goto flecs_parse_role;
-        }
-
-        /* Is token a predicate? */
-        if (ptr[0] == TOK_PAREN_OPEN) {
-            goto parse_predicate;    
-        }
-
-        /* Next token must be a predicate */
-        goto parse_predicate;
-
-    /* Pair with implicit subject */
-    } else if (ptr[0] == TOK_PAREN_OPEN) {
-        goto parse_pair;
-
-    /* Open query scope */
-    } else if (ptr[0] == TOK_SCOPE_OPEN) {
-        term.first.id = EcsScopeOpen;
-        term.src.id = 0;
-        term.src.flags = EcsIsEntity;
-        term.inout = EcsInOutNone;
-        goto parse_done;
-
-    /* Close query scope */
-    } else if (ptr[0] == TOK_SCOPE_CLOSE) {
-        term.first.id = EcsScopeClose;
-        term.src.id = 0;
-        term.src.flags = EcsIsEntity;
-        term.inout = EcsInOutNone;
-        ptr = ecs_parse_ws(ptr + 1);
-        goto parse_done;
-
-    /* Nothing else expected here */
-    } else {
-        flecs_parser_unexpected_char(name, expr, ptr, ptr[0]);
-        goto error;
-    }
-
-flecs_parse_role:
-    term.id_flags = flecs_parse_role(name, expr, (ptr - expr), token);
-    if (!term.id_flags) {
-        goto error;
-    }
-
-    ptr = ecs_parse_ws(ptr);
-
-    /* If next token is the source token, this is an empty source */
-    if (flecs_valid_token_start_char(ptr[0])) {
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            goto error;
-        }
-
-        /* If not, it's a predicate */
-        goto parse_predicate;
-
-    } else if (ptr[0] == TOK_PAREN_OPEN) {
-        goto parse_pair;
-    } else {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "expected identifier after role");
-        goto error;
-    }
-
-parse_predicate:
-    if (flecs_parse_identifier(token, &term.first)) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "invalid identifier '%s'", token); 
-        goto error;
-    }
-
-    /* Set expression */
-    if (ptr[0] == TOK_COLON) {
-        ptr = ecs_parse_ws(ptr + 1);
-        ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr, NULL, 
-            &term.first, TOK_COLON);
-        if (!ptr) {
-            goto error;
-        }
-
-        ptr = ecs_parse_ws(ptr);
-
-        if (ptr[0] == TOK_AND || !ptr[0]) {
-            goto parse_done;
-        }
-
-        if (ptr[0] != TOK_COLON) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unexpected token '%c' after predicate set expression", ptr[0]);
-            goto error;
-        }
-
-        ptr = ecs_parse_ws(ptr + 1);
-    } else if (!ecs_os_strncmp(ptr, TOK_EQ, 2)) {
-        ptr = ecs_parse_ws(ptr + 2);
-        goto parse_eq;
-    } else if (!ecs_os_strncmp(ptr, TOK_NEQ, 2)) {
-        ptr = ecs_parse_ws(ptr + 2);
-        goto parse_neq;
-    } else if (!ecs_os_strncmp(ptr, TOK_MATCH, 2)) {
-        ptr = ecs_parse_ws(ptr + 2);
-        goto parse_match;
-    } else {
-        ptr = ecs_parse_ws(ptr);
-    }
-
-    if (ptr[0] == TOK_PAREN_OPEN) {
-        ptr = ecs_parse_ws_eol(ptr + 1);
-        if (ptr[0] == TOK_PAREN_CLOSE) {
-            term.src.flags = EcsIsEntity;
-            term.src.id = 0;
-            ptr ++;
-            ptr = ecs_parse_ws(ptr);
-        } else {
-            ptr = flecs_parse_arguments(world, name, expr, (ptr - expr), ptr, 
-                token, &term, extra_oper, extra_args);
-        }
-
-        goto parse_done;
-    }
-
-    goto parse_done;
-
-parse_eq:
-    term.src = term.first;
-    term.first = (ecs_term_id_t){0};
-    term.first.id = EcsPredEq;
-    goto parse_right_operand;
-
-parse_neq:
-    term.src = term.first;
-    term.first = (ecs_term_id_t){0};
-    term.first.id = EcsPredEq;
-    if (term.oper != EcsAnd) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "invalid operator combination");
-        goto error;
-    }
-    term.oper = EcsNot;
-    goto parse_right_operand;
-    
-parse_match:
-    term.src = term.first;
-    term.first = (ecs_term_id_t){0};
-    term.first.id = EcsPredMatch;
-    goto parse_right_operand;
-
-parse_right_operand:
-    if (flecs_valid_token_start_char(ptr[0])) {
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            goto error;
-        }
-
-        if (term.first.id == EcsPredMatch) {
-            if (token[0] == '"' && token[1] == '!') {
-                term.oper = EcsNot;
-            }
-        }
-
-        if (flecs_parse_identifier(token, &term.second)) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "invalid identifier '%s'", token); 
-            goto error;
-        }
-
-        term.src.flags &= ~EcsTraverseFlags;
-        term.src.flags |= EcsSelf;
-        term.inout = EcsInOutNone;
-    } else {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "expected identifier");
-        goto error;
-    }
-    goto parse_done;
-parse_pair:
-    ptr = ecs_parse_identifier(name, expr, ptr + 1, token);
-    if (!ptr) {
-        goto error;
-    }
-
-    if (ptr[0] == TOK_COLON) {
-        ptr = ecs_parse_ws(ptr + 1);
-        ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr,
-            NULL, &term.first, TOK_PAREN_CLOSE);
-        if (!ptr) {
-            goto error;
-        }
-    }
-
-    if (ptr[0] == TOK_AND) {
-        ptr = ecs_parse_ws(ptr + 1);
-        if (ptr[0] == TOK_PAREN_CLOSE) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "expected identifier for second element of pair"); 
-            goto error;
-        }
-        
-        term.src.id = EcsThis;
-        term.src.flags |= EcsIsVariable;
-        goto parse_pair_predicate;
-    } else if (ptr[0] == TOK_PAREN_CLOSE) {
-        term.src.id = EcsThis;
-        term.src.flags |= EcsIsVariable;
-        goto parse_pair_predicate;
-    } else {
-        flecs_parser_unexpected_char(name, expr, ptr, ptr[0]);
-        goto error;
-    }
-
-parse_pair_predicate:
-    if (flecs_parse_identifier(token, &term.first)) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "invalid identifier '%s'", token); 
-        goto error;
-    }
-
-    ptr = ecs_parse_ws(ptr);
-    if (flecs_valid_token_start_char(ptr[0])) {
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            goto error;
-        }
-
-        if (ptr[0] == TOK_COLON) {
-            ptr = ecs_parse_ws(ptr + 1);
-            ptr = flecs_parse_term_flags(world, name, expr, (ptr - expr), ptr,
-                NULL, &term.second, TOK_PAREN_CLOSE);
-            if (!ptr) {
-                goto error;
-            }
-        }
-
-        if (ptr[0] == TOK_PAREN_CLOSE || ptr[0] == TOK_AND || ptr[0] == TOK_OR[0]) {
-            goto parse_pair_object;
-        } else {
-            flecs_parser_unexpected_char(name, expr, ptr, ptr[0]);
-            goto error;
-        }
-    } else if (ptr[0] == TOK_PAREN_CLOSE) {
-        /* No object */
-        ptr ++;
-        goto parse_done;
-    } else {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "expected pair object or ')'");
-        goto error;
-    }
-
-parse_pair_object:
-    if (flecs_parse_identifier(token, &term.second)) {
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "invalid identifier '%s'", token); 
-        goto error;
-    }
-
-    if (term.id_flags == 0) {
-        term.id_flags = ECS_PAIR;
-    }
-
-    if (ptr[0] == TOK_AND) {
-        ptr = ecs_parse_ws(ptr + 1);
-        ptr = flecs_parse_arguments(world, name, expr, (ptr - expr), ptr, token, 
-            NULL, extra_oper, extra_args);
-        if (!ptr) {
-            goto error;
-        }
-    } else if (extra_oper && ptr[0] == TOK_OR[0] && ptr[1] == TOK_OR[1]) {
-        ptr = ecs_parse_ws_eol(ptr + 2);
-        *extra_oper = EcsOr;
-        ptr = flecs_parse_arguments(world, name, expr, (ptr - expr), ptr, token, 
-            NULL, extra_oper, extra_args);
-        if (!ptr) {
-            goto error;
-        }
-    } else {
-        ptr ++;
-    }
-
-    ptr = ecs_parse_ws(ptr);
-    goto parse_done;
-
-parse_done:
-    *term_out = term;
-    return ptr;
-
-error:
-    ecs_term_fini(&term);
-    *term_out = (ecs_term_t){0};
-    return NULL;
-}
-
-static
-bool flecs_is_valid_end_of_term(
-    const char *ptr)
-{
-    if ((ptr[0] == TOK_AND) ||    /* another term with And operator */
-        (ptr[0] == TOK_OR[0]) ||  /* another term with Or operator */
-        (ptr[0] == '\n') ||       /* newlines are valid */
-        (ptr[0] == '\0') ||       /* end of string */
-        (ptr[0] == '/') ||        /* comment (in plecs) */
-        (ptr[0] == '{') ||        /* scope (in plecs) */
-        (ptr[0] == '}') ||
-        (ptr[0] == '[') ||        /* collection scope (in plecs) */
-        (ptr[0] == ']') ||
-        (ptr[0] == ':') ||        /* inheritance (in plecs) */
-        (ptr[0] == '='))          /* assignment (in plecs) */
-    {
-        return true;
-    }
-    return false;
-}
-
-char* ecs_parse_term(
-    const ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_term_t *term,
-    ecs_oper_kind_t *extra_oper,
-    ecs_term_id_t *extra_args,
-    bool allow_newline)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    if (extra_oper) {
-        *extra_oper = EcsAnd;
-    }
-
-    ecs_term_id_t *src = &term->src;
-
-    if (ptr != expr) {
-        if (ptr[0]) {
-            if (ptr[0] == ',') {
-                ptr ++;
-            } else if (ptr[0] == '|') {
-                ptr += 2;
-            } else if (ptr[0] == '{') {
-                ptr ++;
-            } else if (ptr[0] == '}') {
-                /* nothing to be done */
-            } else {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "invalid preceding token");
-            }
-        }
-    }
-
-    ptr = ecs_parse_ws_eol(ptr);
-    if (!ptr[0]) {
-        *term = (ecs_term_t){0};
-        return ECS_CONST_CAST(char*, ptr);
-    }
-
-    if (ptr == expr && !strcmp(expr, "0")) {
-        return ECS_CONST_CAST(char*, &ptr[1]);
-    }
-
-    /* Parse next element */
-    ptr = flecs_parse_term(world, name, ptr, term, extra_oper, extra_args);
-    if (!ptr) {
-        goto error;
-    }
-
-    /* Check for $() notation */
-    if (term->first.name && !ecs_os_strcmp(term->first.name, "$")) {
-        if (term->src.name) {
-            /* Safe, parser owns name */
-            ecs_os_free(ECS_CONST_CAST(char*, term->first.name));
-            
-            term->first = term->src;
-
-            if (term->second.name) {
-                term->src = term->second;       
-            } else {
-                term->src.id = EcsThis;
-                term->src.name = NULL;
-                term->src.flags |= EcsIsVariable;
-            }
-
-            const char *var_name = strrchr(term->first.name, '.');
-            if (var_name) {
-                var_name ++;
-            } else {
-                var_name = term->first.name;
-            }
-
-            term->second.name = ecs_os_strdup(var_name);
-            term->second.flags |= EcsIsVariable;
-        }
-    }
-
-    /* Post-parse consistency checks */
-
-    /* If next token is OR, term is part of an OR expression */
-    if (!ecs_os_strncmp(ptr, TOK_OR, 2)) {
-        /* An OR operator must always follow an AND or another OR */
-        if (term->oper != EcsAnd) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "cannot combine || with other operators");
-            goto error;
-        }
-
-        term->oper = EcsOr;
-    }
-
-    /* Term must either end in end of expression, AND or OR token */
-    if (!flecs_is_valid_end_of_term(ptr)) {
-        if (!flecs_isident(ptr[0]) || ((ptr != expr) && (ptr[-1] != ' '))) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "expected end of expression or next term");
-            goto error;
-        }
-    }
-
-    /* If the term just contained a 0, the expression has nothing. Ensure
-     * that after the 0 nothing else follows */
-    if (term->first.name && !ecs_os_strcmp(term->first.name, "0")) {
-        if (ptr[0]) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unexpected term after 0"); 
-            goto error;
-        }
-
-        if (src->flags != 0) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "invalid combination of 0 with non-default subject");
-            goto error;
-        }
-
-        src->flags = EcsIsEntity;
-        src->id = 0;
-        /* Safe, parser owns string */
-        ecs_os_free(ECS_CONST_CAST(char*, term->first.name));
-        term->first.name = NULL;
-    }
-
-    /* Cannot combine EcsIsEntity/0 with operators other than AND */
-    if (term->oper != EcsAnd && ecs_term_match_0(term)) {
-        if (term->first.id != EcsScopeOpen && term->first.id != EcsScopeClose) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "invalid operator for empty source"); 
-            goto error;
-        }
-    }
-
-    /* Automatically assign This if entity is not assigned and the set is
-     * nothing */
-    if (!(src->flags & EcsIsEntity)) {
-        if (!src->name) {
-            if (!src->id) {
-                src->id = EcsThis;
-                src->flags |= EcsIsVariable;
-            }
-        }
-    }
-
-    if (src->name && !ecs_os_strcmp(src->name, "0")) {
-        src->id = 0;
-        src->flags = EcsIsEntity;
-    }
-
-    /* Process role */
-    if (term->id_flags == ECS_AND) {
-        term->oper = EcsAndFrom;
-        term->id_flags = 0;
-    } else if (term->id_flags == ECS_OR) {
-        term->oper = EcsOrFrom;
-        term->id_flags = 0;
-    } else if (term->id_flags == ECS_NOT) {
-        term->oper = EcsNotFrom;
-        term->id_flags = 0;
-    }
-
-    if (allow_newline) {
-        ptr = ecs_parse_ws_eol(ptr);
-    } else {
-        ptr = ecs_parse_ws(ptr);
-    }
-
-    return ECS_CONST_CAST(char*, ptr);
-error:
-    if (term) {
-        ecs_term_fini(term);
-    }
-    return NULL;
-}
-
-#endif
diff --git a/src/addons/pipeline/pipeline.c b/src/addons/pipeline/pipeline.c
index f2729a975..a2c89305b 100644
--- a/src/addons/pipeline/pipeline.c
+++ b/src/addons/pipeline/pipeline.c
@@ -13,7 +13,7 @@ static void flecs_pipeline_free(
     ecs_pipeline_state_t *p) 
 {
     if (p) {
-        ecs_world_t *world = p->query->filter.world;
+        ecs_world_t *world = p->query->world;
         ecs_allocator_t *a = &world->allocator;
         ecs_vec_fini_t(a, &p->ops, ecs_pipeline_op_t);
         ecs_vec_fini_t(a, &p->systems, ecs_entity_t);
@@ -130,17 +130,17 @@ bool flecs_pipeline_check_term(
 {
     (void)world;
 
-    ecs_term_id_t *src = &term->src;
-    if (src->flags & EcsInOutNone) {
+    ecs_term_ref_t *src = &term->src;
+    if (term->inout == EcsInOutNone || term->inout == EcsInOutFilter) {
         return false;
     }
 
     ecs_id_t id = term->id;
-    ecs_oper_kind_t oper = term->oper;
-    ecs_inout_kind_t inout = term->inout;
+    int16_t oper = term->oper;
+    int16_t inout = term->inout;
     bool from_any = ecs_term_match_0(term);
     bool from_this = ecs_term_match_this(term);
-    bool is_shared = !from_any && (!from_this || !(src->flags & EcsSelf));
+    bool is_shared = !from_any && (!from_this || !(src->id & EcsSelf));
 
     ecs_write_kind_t ws = flecs_pipeline_get_write_state(write_state, id);
 
@@ -183,6 +183,7 @@ bool flecs_pipeline_check_term(
             break;
         case EcsInOutDefault:
         case EcsInOutNone:
+        case EcsInOutFilter:
         case EcsIn:
             break;
         }
@@ -198,6 +199,7 @@ bool flecs_pipeline_check_term(
             /* fall through */
         case EcsInOutDefault:
         case EcsInOutNone:
+        case EcsInOutFilter:
         case EcsOut:
             break;
         }
@@ -209,13 +211,13 @@ bool flecs_pipeline_check_term(
 static
 bool flecs_pipeline_check_terms(
     ecs_world_t *world,
-    ecs_filter_t *filter,
+    ecs_query_t *query,
     bool is_active,
     ecs_write_state_t *ws)
 {
     bool needs_merge = false;
-    ecs_term_t *terms = filter->terms;
-    int32_t t, term_count = filter->term_count;
+    ecs_term_t *terms = query->terms;
+    int32_t t, term_count = query->term_count;
 
     /* Check This terms first. This way if a term indicating writing to a stage
      * was added before the term, it won't cause merging. */
@@ -242,7 +244,7 @@ EcsPoly* flecs_pipeline_term_system(
     ecs_iter_t *it)
 {
     int32_t index = ecs_table_get_column_index(
-        it->real_world, it->table, ecs_poly_id(EcsSystem));
+        it->real_world, it->table, flecs_poly_id(EcsSystem));
     ecs_assert(index != -1, ECS_INTERNAL_ERROR, NULL);
     EcsPoly *poly = ecs_table_get_column(it->table, index, it->offset);
     ecs_assert(poly != NULL, ECS_INTERNAL_ERROR, NULL);
@@ -256,7 +258,8 @@ bool flecs_pipeline_build(
 {
     ecs_iter_t it = ecs_query_iter(world, pq->query);
 
-    if (pq->match_count == pq->query->match_count) {
+    int32_t new_match_count = ecs_query_match_count(pq->query);
+    if (pq->match_count == new_match_count) {
         /* No need to rebuild the pipeline */
         ecs_iter_fini(&it);
         return false;
@@ -275,7 +278,7 @@ bool flecs_pipeline_build(
     ecs_vec_reset_t(a, &pq->systems, ecs_entity_t);
 
     bool multi_threaded = false;
-    bool no_readonly = false;
+    bool immediate = false;
     bool first = true;
 
     /* Iterate systems in pipeline, add ops for running / merging */
@@ -286,18 +289,18 @@ bool flecs_pipeline_build(
 
         int32_t i;
         for (i = 0; i < it.count; i ++) {
-            ecs_poly_assert(poly[i].poly, ecs_system_t);
+            flecs_poly_assert(poly[i].poly, ecs_system_t);
             ecs_system_t *sys = (ecs_system_t*)poly[i].poly;
             ecs_query_t *q = sys->query;
 
             bool needs_merge = false;
             needs_merge = flecs_pipeline_check_terms(
-                world, &q->filter, is_active, &ws);
+                world, q, is_active, &ws);
 
             if (is_active) {
                 if (first) {
                     multi_threaded = sys->multi_threaded;
-                    no_readonly = sys->no_readonly;
+                    immediate = sys->immediate;
                     first = false;
                 }
 
@@ -305,13 +308,13 @@ bool flecs_pipeline_build(
                     needs_merge = true;
                     multi_threaded = sys->multi_threaded;
                 }
-                if (sys->no_readonly != no_readonly) {
+                if (sys->immediate != immediate) {
                     needs_merge = true;
-                    no_readonly = sys->no_readonly;
+                    immediate = sys->immediate;
                 }
             }
 
-            if (no_readonly) {
+            if (immediate) {
                 needs_merge = true;
             }
 
@@ -334,7 +337,7 @@ bool flecs_pipeline_build(
                 needs_merge = false;
                 if (is_active) {
                     needs_merge = flecs_pipeline_check_terms(
-                        world, &q->filter, true, &ws);
+                        world, q, true, &ws);
                 }
 
                 /* The component states were just reset, so if we conclude that
@@ -347,7 +350,7 @@ bool flecs_pipeline_build(
                 op->offset = ecs_vec_count(&pq->systems);
                 op->count = 0;
                 op->multi_threaded = false;
-                op->no_readonly = false;
+                op->immediate = false;
                 op->time_spent = 0;
                 op->commands_enqueued = 0;
             }
@@ -359,7 +362,7 @@ bool flecs_pipeline_build(
                     it.entities[i];
                 if (!op->count) {
                     op->multi_threaded = multi_threaded;
-                    op->no_readonly = no_readonly;
+                    op->immediate = immediate;
                 }
                 op->count ++;
             }
@@ -384,7 +387,7 @@ bool flecs_pipeline_build(
         ecs_log_push_1();
 
         ecs_dbg("#[green]schedule#[reset]: threading: %d, staging: %d:", 
-            op->multi_threaded, !op->no_readonly);
+            op->multi_threaded, !op->immediate);
         ecs_log_push_1();
 
         int32_t i, count = ecs_vec_count(&pq->systems);
@@ -393,7 +396,7 @@ bool flecs_pipeline_build(
         for (i = 0; i < count; i ++) {
             ecs_entity_t system = systems[i];
             const EcsPoly *poly = ecs_get_pair(world, system, EcsPoly, EcsSystem);
-            ecs_poly_assert(poly->poly, ecs_system_t);
+            flecs_poly_assert(poly->poly, ecs_system_t);
             ecs_system_t *sys = (ecs_system_t*)poly->poly;
 
 #ifdef FLECS_LOG_1
@@ -428,7 +431,7 @@ bool flecs_pipeline_build(
                         "#[green]schedule#[reset]: "
                         "threading: %d, staging: %d:",
                         op[op_index].multi_threaded, 
-                        !op[op_index].no_readonly);
+                        !op[op_index].immediate);
                 }
                 ecs_log_push_1();
             }
@@ -448,7 +451,7 @@ bool flecs_pipeline_build(
         ecs_log_pop_1();
     }
 
-    pq->match_count = pq->query->match_count;
+    pq->match_count = new_match_count;
 
     ecs_assert(pq->cur_op <= ecs_vec_last_t(&pq->ops, ecs_pipeline_op_t),
         ECS_INTERNAL_ERROR, NULL);
@@ -478,8 +481,9 @@ bool flecs_pipeline_update(
     ecs_pipeline_state_t *pq,
     bool start_of_frame)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, 
+        "cannot update pipeline while world is in readonly mode");
 
     /* If any entity mutations happened that could have affected query matching
      * notify appropriate queries so caches are up to date. This includes the
@@ -552,7 +556,7 @@ int32_t flecs_run_pipeline_ops(
     for (; i < count; i++) {
         ecs_entity_t system = systems[i];
         const EcsPoly* poly = ecs_get_pair(world, system, EcsPoly, EcsSystem);
-        ecs_poly_assert(poly->poly, ecs_system_t);
+        flecs_poly_assert(poly->poly, ecs_system_t);
         ecs_system_t* sys = (ecs_system_t*)poly->poly;
 
         /* Keep track of the last frame for which the system has ran, so we
@@ -561,14 +565,14 @@ int32_t flecs_run_pipeline_ops(
         sys->last_frame = world->info.frame_count_total + 1;
 
         ecs_stage_t* s = NULL;
-        if (!op->no_readonly) {
-            /* If system is no_readonly it operates on the actual world, not
+        if (!op->immediate) {
+            /* If system is immediate it operates on the actual world, not
              * the stage. Only pass stage to system if it's readonly. */
             s = stage;
         }
 
-        ecs_run_intern(world, s, system, sys, stage_index,
-            stage_count, delta_time, 0, 0, NULL);
+        flecs_run_intern(world, s, system, sys, stage_index,
+            stage_count, delta_time, NULL);
 
         world->info.systems_ran_frame++;
         ran_since_merge++;
@@ -587,17 +591,18 @@ void flecs_run_pipeline(
     ecs_pipeline_state_t *pq,
     ecs_ftime_t delta_time)
 {
-    ecs_assert(world != NULL, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(pq->query != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_poly_assert(world, ecs_stage_t);
+    flecs_poly_assert(world, ecs_stage_t);
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);  
-    int32_t stage_index = ecs_get_stage_id(stage->thread_ctx);
+    int32_t stage_index = ecs_stage_get_id(stage->thread_ctx);
     int32_t stage_count = ecs_get_stage_count(world);
     bool multi_threaded = world->worker_cond != 0;
 
-    ecs_assert(!stage_index, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(!stage_index, ECS_INVALID_OPERATION, 
+        "cannot run pipeline on stage");
 
     // Update the pipeline the workers will execute
     world->pq = pq;
@@ -613,12 +618,12 @@ void flecs_run_pipeline(
             continue;
         }
 
-        bool no_readonly = pq->cur_op->no_readonly;
+        bool immediate = pq->cur_op->immediate;
         bool op_multi_threaded = multi_threaded && pq->cur_op->multi_threaded;
 
-        pq->no_readonly = no_readonly;
+        pq->immediate = immediate;
 
-        if (!no_readonly) {
+        if (!immediate) {
             ecs_readonly_begin(world, multi_threaded);
         }
 
@@ -647,7 +652,7 @@ void flecs_run_pipeline(
             flecs_wait_for_sync(world);
         }
 
-        if (!no_readonly) {
+        if (!immediate) {
             ecs_time_t mt = { 0 };
             if (measure_time) {
                 ecs_time_measure(&mt);
@@ -655,7 +660,7 @@ void flecs_run_pipeline(
 
             int32_t si;
             for (si = 0; si < stage_count; si ++) {
-                ecs_stage_t *s = &world->stages[si];
+                ecs_stage_t *s = world->stages[si];
                 pq->cur_op->commands_enqueued += ecs_vec_count(&s->cmd->queue);
             }
 
@@ -696,14 +701,14 @@ void flecs_run_startup_systems(
     ecs_log_push_2();
     ecs_entity_t start_pip = ecs_pipeline_init(world, &(ecs_pipeline_desc_t){
         .query = {
-            .filter.terms = {
+            .terms = {
                 { .id = EcsSystem },
-                { .id = EcsPhase, .src.flags = EcsCascade, .src.trav = EcsDependsOn },
-                { .id = ecs_dependson(EcsOnStart), .src.trav = EcsDependsOn },
-                { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsDependsOn, .oper = EcsNot },
-                { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsChildOf, .oper = EcsNot }
+                { .id = EcsPhase, .src.id = EcsCascade, .trav = EcsDependsOn },
+                { .id = ecs_dependson(EcsOnStart), .trav = EcsDependsOn },
+                { .id = EcsDisabled, .src.id = EcsUp, .trav = EcsDependsOn, .oper = EcsNot },
+                { .id = EcsDisabled, .src.id = EcsUp, .trav = EcsChildOf, .oper = EcsNot }
             },
-            .order_by = flecs_entity_compare
+            .order_by_callback = flecs_entity_compare
         }
     });
     ecs_log_pop_2();
@@ -713,7 +718,8 @@ void flecs_run_startup_systems(
     ecs_log_push_2();
     ecs_assert(start_pip != 0, ECS_INTERNAL_ERROR, NULL);
     const EcsPipeline *p = ecs_get(world, start_pip, EcsPipeline);
-    ecs_check(p != NULL, ECS_INVALID_OPERATION, NULL);
+    ecs_check(p != NULL, ECS_INVALID_OPERATION, 
+        "pipeline entity is missing flecs.pipeline.Pipeline component");
     flecs_workers_progress(world, p->state, 0);
     ecs_log_pop_2();
 
@@ -748,7 +754,8 @@ bool ecs_progress(
     ecs_dbg_3("#[bold]progress#[reset](dt = %.2f)", (double)delta_time);
     ecs_log_push_3();
     const EcsPipeline *p = ecs_get(world, world->pipeline, EcsPipeline);
-    ecs_check(p != NULL, ECS_INVALID_OPERATION, NULL);
+    ecs_check(p != NULL, ECS_INVALID_OPERATION,
+        "pipeline entity is missing flecs.pipeline.Pipeline component");
     flecs_workers_progress(world, p->state, delta_time);
     ecs_log_pop_3();
 
@@ -782,7 +789,7 @@ void ecs_set_pipeline(
     ecs_world_t *world,
     ecs_entity_t pipeline)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check( ecs_get(world, pipeline, EcsPipeline) != NULL, 
         ECS_INVALID_PARAMETER, "not a pipeline");
 
@@ -805,19 +812,19 @@ ecs_entity_t ecs_pipeline_init(
     ecs_world_t *world,
     const ecs_pipeline_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
 
     ecs_entity_t result = desc->entity;
     if (!result) {
-        result = ecs_new(world, 0);
+        result = ecs_new(world);
     }
 
     ecs_query_desc_t qd = desc->query;
-    if (!qd.order_by) {
-        qd.order_by = flecs_entity_compare;
+    if (!qd.order_by_callback) {
+        qd.order_by_callback = flecs_entity_compare;
     }
-    qd.filter.entity = result;
+    qd.entity = result;
 
     ecs_query_t *query = ecs_query_init(world, &qd);
     if (!query) {
@@ -825,9 +832,9 @@ ecs_entity_t ecs_pipeline_init(
         return 0;
     }
 
-    ecs_check(query->filter.terms != NULL, ECS_INVALID_PARAMETER, 
+    ecs_check(query->terms != NULL, ECS_INVALID_PARAMETER, 
         "pipeline query cannot be empty");
-    ecs_check(query->filter.terms[0].id == EcsSystem,
+    ecs_check(query->terms[0].id == EcsSystem,
         ECS_INVALID_PARAMETER, "pipeline must start with System term");
 
     ecs_pipeline_state_t *pq = ecs_os_calloc_t(ecs_pipeline_state_t);
@@ -890,17 +897,17 @@ void FlecsPipelineImport(
      * relationships. This ensures that, for example, EcsOnUpdate doesn't have a
      * direct DependsOn relationship on EcsPreUpdate, which ensures that when
      * the EcsPreUpdate phase is disabled, EcsOnUpdate still runs. */
-    ecs_entity_t phase_0 = ecs_new(world, 0);
-    ecs_entity_t phase_1 = ecs_new_w_pair(world, EcsDependsOn, phase_0);
-    ecs_entity_t phase_2 = ecs_new_w_pair(world, EcsDependsOn, phase_1);
-    ecs_entity_t phase_3 = ecs_new_w_pair(world, EcsDependsOn, phase_2);
-    ecs_entity_t phase_4 = ecs_new_w_pair(world, EcsDependsOn, phase_3);
-    ecs_entity_t phase_5 = ecs_new_w_pair(world, EcsDependsOn, phase_4);
-    ecs_entity_t phase_6 = ecs_new_w_pair(world, EcsDependsOn, phase_5);
-    ecs_entity_t phase_7 = ecs_new_w_pair(world, EcsDependsOn, phase_6);
-    ecs_entity_t phase_8 = ecs_new_w_pair(world, EcsDependsOn, phase_7);
-
-    flecs_bootstrap_phase(world, EcsOnStart,   0);
+    ecs_entity_t phase_0 = ecs_entity(world, {0});
+    ecs_entity_t phase_1 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_0)) });
+    ecs_entity_t phase_2 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_1)) });
+    ecs_entity_t phase_3 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_2)) });
+    ecs_entity_t phase_4 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_3)) });
+    ecs_entity_t phase_5 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_4)) });
+    ecs_entity_t phase_6 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_5)) });
+    ecs_entity_t phase_7 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_6)) });
+    ecs_entity_t phase_8 = ecs_entity(world, { .add = ecs_ids(ecs_dependson(phase_7)) });
+
+    flecs_bootstrap_phase(world, EcsOnStart,    0);
     flecs_bootstrap_phase(world, EcsPreFrame,   0);
     flecs_bootstrap_phase(world, EcsOnLoad,     phase_0);
     flecs_bootstrap_phase(world, EcsPostLoad,   phase_1);
@@ -913,7 +920,7 @@ void FlecsPipelineImport(
     flecs_bootstrap_phase(world, EcsPostFrame,  phase_8);
 
     ecs_set_hooks(world, EcsPipeline, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(EcsPipeline),
         .move = ecs_move(EcsPipeline)
     });
@@ -921,14 +928,14 @@ void FlecsPipelineImport(
     world->pipeline = ecs_pipeline(world, {
         .entity = ecs_entity(world, { .name = "BuiltinPipeline" }),
         .query = {
-            .filter.terms = {
+            .terms = {
                 { .id = EcsSystem },
-                { .id = EcsPhase, .src.flags = EcsCascade, .src.trav = EcsDependsOn },
-                { .id = ecs_dependson(EcsOnStart), .src.trav = EcsDependsOn, .oper = EcsNot },
-                { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsDependsOn, .oper = EcsNot },
-                { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsChildOf, .oper = EcsNot }
+                { .id = EcsPhase, .src.id = EcsCascade, .trav = EcsDependsOn },
+                { .id = ecs_dependson(EcsOnStart), .trav = EcsDependsOn, .oper = EcsNot },
+                { .id = EcsDisabled, .src.id = EcsUp, .trav = EcsDependsOn, .oper = EcsNot },
+                { .id = EcsDisabled, .src.id = EcsUp, .trav = EcsChildOf, .oper = EcsNot }
             },
-            .order_by = flecs_entity_compare
+            .order_by_callback = flecs_entity_compare
         }
     });
 
diff --git a/src/addons/pipeline/pipeline.h b/src/addons/pipeline/pipeline.h
index 3319365ac..12aa8bb20 100644
--- a/src/addons/pipeline/pipeline.h
+++ b/src/addons/pipeline/pipeline.h
@@ -16,7 +16,7 @@ typedef struct ecs_pipeline_op_t {
     double time_spent;          /* Time spent merging commands for sync point */
     int64_t commands_enqueued;  /* Number of commands enqueued for sync point */
     bool multi_threaded;        /* Whether systems can be ran multi threaded */
-    bool no_readonly;           /* Whether systems are staged or not */
+    bool immediate;           /* Whether systems are staged or not */
 } ecs_pipeline_op_t;
 
 struct ecs_pipeline_state_t {
@@ -35,7 +35,7 @@ struct ecs_pipeline_state_t {
     ecs_pipeline_op_t *cur_op;  /* Current pipeline op */
     int32_t cur_i;              /* Index in current result */
     int32_t ran_since_merge;    /* Index in current op */
-    bool no_readonly;           /* Is pipeline in readonly mode */
+    bool immediate;           /* Is pipeline in readonly mode */
 };
 
 typedef struct EcsPipeline {
diff --git a/src/addons/pipeline/worker.c b/src/addons/pipeline/worker.c
index 95bd1e151..5f2c7fed8 100644
--- a/src/addons/pipeline/worker.c
+++ b/src/addons/pipeline/worker.c
@@ -37,8 +37,8 @@ void* flecs_worker(void *arg) {
     ecs_stage_t *stage = arg;
     ecs_world_t *world = stage->world;
 
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_assert(stage, ecs_stage_t);
+    flecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(stage, ecs_stage_t);
 
     ecs_dbg_2("worker %d: start", stage->id);
 
@@ -80,13 +80,13 @@ void* flecs_worker(void *arg) {
 void flecs_create_worker_threads(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     int32_t stages = ecs_get_stage_count(world);
 
     for (int32_t i = 1; i < stages; i ++) {
         ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i);
         ecs_assert(stage != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_poly_assert(stage, ecs_stage_t);
+        flecs_poly_assert(stage, ecs_stage_t);
 
         ecs_assert(stage->thread == 0, ECS_INTERNAL_ERROR, NULL);
         if (ecs_using_task_threads(world)) {
@@ -97,7 +97,8 @@ void flecs_create_worker_threads(
             /* workers are using long-running os threads */
             stage->thread = ecs_os_thread_new(flecs_worker, stage);
         }
-        ecs_assert(stage->thread != 0, ECS_OPERATION_FAILED, NULL);
+        ecs_assert(stage->thread != 0, ECS_OPERATION_FAILED,
+            "failed to create thread");
     }
 }
 
@@ -120,7 +121,7 @@ static
 void flecs_wait_for_workers(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     int32_t stage_count = ecs_get_stage_count(world);
     if (stage_count <= 1) {
@@ -181,15 +182,14 @@ void flecs_signal_workers(
 void flecs_join_worker_threads(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     bool threads_active = false;
 
     /* Test if threads are created. Cannot use workers_running, since this is
      * a potential race if threads haven't spun up yet. */
-    ecs_stage_t *stages = world->stages;
     int i, count = world->stage_count;
     for (i = 1; i < count; i ++) {
-        ecs_stage_t *stage = &stages[i];
+        ecs_stage_t *stage = world->stages[i];
         if (stage->thread) {
             threads_active = true;
             break;
@@ -210,12 +210,13 @@ void flecs_join_worker_threads(
 
     /* Join all threads with main */
     for (i = 1; i < count; i ++) {
+        ecs_stage_t *stage = world->stages[i];
         if (ecs_using_task_threads(world)) {
-            ecs_os_task_join(stages[i].thread);
+            ecs_os_task_join(stage->thread);
         } else {
-            ecs_os_thread_join(stages[i].thread);
+            ecs_os_thread_join(stage->thread);
         }
-        stages[i].thread = 0;
+        stage->thread = 0;
     }
 
     world->flags &= ~EcsWorldQuitWorkers;
@@ -228,8 +229,9 @@ void flecs_workers_progress(
     ecs_pipeline_state_t *pq,
     ecs_ftime_t delta_time)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(!ecs_is_deferred(world), ECS_INVALID_OPERATION, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(!ecs_is_deferred(world), ECS_INVALID_OPERATION, 
+        "cannot call progress while world is deferred");
 
     /* Make sure workers are running and ready */
     flecs_wait_for_workers(world);
diff --git a/src/addons/plecs.c b/src/addons/plecs.c
deleted file mode 100644
index 35f69a59e..000000000
--- a/src/addons/plecs.c
+++ /dev/null
@@ -1,2272 +0,0 @@
-/**
- * @file addons/plecs.c
- * @brief Plecs addon.
- */
-
-#include "flecs.h"
-
-#ifdef FLECS_PLECS
-
-ECS_COMPONENT_DECLARE(EcsScript);
-
-#include "../private_api.h"
-#include <ctype.h>
-
-#define TOK_NEWLINE '\n'
-#define TOK_USING "using"
-#define TOK_MODULE "module"
-#define TOK_WITH "with"
-#define TOK_CONST "const"
-#define TOK_PROP "prop"
-#define TOK_ASSEMBLY "assembly"
-
-#define STACK_MAX_SIZE (64)
-
-typedef struct {
-    ecs_value_t value;
-    bool owned;
-} plecs_with_value_t;
-
-typedef struct {
-    const char *name;
-    const char *code;
-
-    ecs_entity_t last_predicate;
-    ecs_entity_t last_subject;
-    ecs_entity_t last_object;
-
-    ecs_id_t last_assign_id;
-    ecs_entity_t assign_to;
-
-    ecs_entity_t scope[STACK_MAX_SIZE];
-    ecs_entity_t default_scope_type[STACK_MAX_SIZE];
-    ecs_entity_t with[STACK_MAX_SIZE];
-    ecs_entity_t using[STACK_MAX_SIZE];
-    int32_t with_frames[STACK_MAX_SIZE];
-    plecs_with_value_t with_value_frames[STACK_MAX_SIZE];
-    int32_t using_frames[STACK_MAX_SIZE];
-    int32_t sp;
-    int32_t with_frame;
-    int32_t using_frame;
-    ecs_entity_t global_with;
-    ecs_entity_t assembly;
-    const char *assembly_start, *assembly_stop;
-
-    char *annot[STACK_MAX_SIZE];
-    int32_t annot_count;
-
-    ecs_vars_t vars;
-    char var_name[256];
-    ecs_entity_t var_type;
-
-    bool with_stmt;
-    bool scope_assign_stmt;
-    bool assign_stmt;
-    bool assembly_stmt;
-    bool assembly_instance;
-    bool isa_stmt;
-    bool decl_stmt;
-    bool decl_type;
-    bool var_stmt;
-    bool var_is_prop;
-    bool is_module;
-
-    int32_t errors;
-} plecs_state_t;
-
-static
-int flecs_plecs_parse(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    ecs_vars_t *vars,
-    ecs_entity_t script,
-    ecs_entity_t instance);
-
-static void flecs_dtor_script(EcsScript *ptr) {
-    ecs_os_free(ptr->script);
-    ecs_vec_fini_t(NULL, &ptr->using_, ecs_entity_t);
-
-    int i, count = ptr->prop_defaults.count;
-    ecs_value_t *values = ptr->prop_defaults.array;
-    for (i = 0; i < count; i ++) {
-        ecs_value_free(ptr->world, values[i].type, values[i].ptr);
-    }
-
-    ecs_vec_fini_t(NULL, &ptr->prop_defaults, ecs_value_t);
-}
-
-static
-ECS_MOVE(EcsScript, dst, src, {
-    flecs_dtor_script(dst);
-    dst->using_ = src->using_;
-    dst->prop_defaults = src->prop_defaults;
-    dst->script = src->script;
-    dst->world = src->world;
-    ecs_os_zeromem(&src->using_);
-    ecs_os_zeromem(&src->prop_defaults);
-    src->script = NULL;
-    src->world = NULL;
-})
-
-static
-ECS_DTOR(EcsScript, ptr, {
-    flecs_dtor_script(ptr);
-})
-
-/* Assembly ctor to initialize with default property values */
-static
-void flecs_assembly_ctor(
-    void *ptr,
-    int32_t count,
-    const ecs_type_info_t *ti)
-{
-    ecs_world_t *world = ti->hooks.ctx;
-    ecs_entity_t assembly = ti->component;
-    const EcsStruct *st = ecs_get(world, assembly, EcsStruct);
-
-    if (!st) {
-        ecs_err("assembly '%s' is not a struct, cannot construct", ti->name);
-        return;
-    }
-
-    const EcsScript *script = ecs_get(world, assembly, EcsScript);
-    if (!script) {
-        ecs_err("assembly '%s' is not a script, cannot construct", ti->name);
-        return;
-    }
-
-    if (st->members.count != script->prop_defaults.count) {
-        ecs_err("number of props (%d) of assembly '%s' does not match members"
-            " (%d), cannot construct", script->prop_defaults.count, 
-                ti->name, st->members.count);
-        return;
-    }
-
-    const ecs_member_t *members = st->members.array;
-    int32_t i, m, member_count = st->members.count;
-    ecs_value_t *values = script->prop_defaults.array;
-    for (m = 0; m < member_count; m ++) {
-        const ecs_member_t *member = &members[m];
-        ecs_value_t *value = &values[m];
-        const ecs_type_info_t *mti = ecs_get_type_info(world, member->type);
-        if (!mti) {
-            ecs_err("failed to get type info for prop '%s' of assembly '%s'",
-                member->name, ti->name);
-            return;
-        }
-
-        for (i = 0; i < count; i ++) {
-            void *el = ECS_ELEM(ptr, ti->size, i);
-            ecs_value_copy_w_type_info(world, mti, 
-                ECS_OFFSET(el, member->offset), value->ptr);
-        }
-    }
-}
-
-/* Assembly on_set handler to update contents for new property values */
-static
-void flecs_assembly_on_set(
-    ecs_iter_t *it)
-{
-    if (it->table->flags & EcsTableIsPrefab) {
-        /* Don't instantiate assemblies for prefabs */
-        return;
-    }
-
-    ecs_world_t *world = it->world;
-    ecs_entity_t assembly = ecs_field_id(it, 1);
-    const char *name = ecs_get_name(world, assembly);
-    ecs_record_t *r = ecs_record_find(world, assembly);
-
-    const EcsComponent *ct = ecs_record_get(world, r, EcsComponent);
-    ecs_get(world, assembly, EcsComponent);
-    if (!ct) {
-        ecs_err("assembly '%s' is not a component", name);
-        return;
-    }
-
-    const EcsStruct *st = ecs_record_get(world, r, EcsStruct);
-    if (!st) {
-        ecs_err("assembly '%s' is not a struct", name);
-        return;
-    }
-
-    const EcsScript *script = ecs_record_get(world, r, EcsScript);
-    if (!script) {
-        ecs_err("assembly '%s' is missing a script", name);
-        return;
-    }
-
-    void *data = ecs_field_w_size(it, flecs_ito(size_t, ct->size), 1);
-
-    int32_t i, m;
-    for (i = 0; i < it->count; i ++) {
-        /* Create variables to hold assembly properties */
-        ecs_vars_t vars = {0};
-        ecs_vars_init(world, &vars);
-
-        /* Populate properties from assembly members */
-        const ecs_member_t *members = st->members.array;
-        for (m = 0; m < st->members.count; m ++) {
-            const ecs_member_t *member = &members[m];
-
-            ecs_value_t v = {0}; /* Prevent allocating value */
-            ecs_expr_var_t *var = ecs_vars_declare_w_value(
-                &vars, member->name, &v);
-            if (var == NULL) {
-                ecs_err("could not create prop '%s' for assembly '%s'", 
-                    member->name, name);
-                break;
-            }
-
-            /* Assign assembly property from assembly instance */
-            var->value.type = member->type;
-            var->value.ptr = ECS_OFFSET(data, member->offset);
-            var->owned = false;
-        }
-
-        /* Populate $this variable with instance entity */
-        ecs_entity_t instance = it->entities[i];
-        ecs_value_t v = {0};
-        ecs_expr_var_t *var = ecs_vars_declare_w_value(
-            &vars, "this", &v);
-        var->value.type = ecs_id(ecs_entity_t);
-        var->value.ptr = &instance;
-        var->owned = false;
-
-        /* Update script with new code/properties */
-        ecs_script_update(world, assembly, instance, script->script, &vars);
-        ecs_vars_fini(&vars);
-
-        if (ecs_record_has_id(world, r, EcsFlatten)) {
-            ecs_flatten(it->real_world, ecs_childof(instance), NULL);
-        }
-
-        data = ECS_OFFSET(data, ct->size);
-    }
-}
-
-/* Delete contents of assembly instance */
-static
-void flecs_assembly_on_remove(
-    ecs_iter_t *it)
-{
-    int32_t i;
-    for (i = 0; i < it->count; i ++) {
-        ecs_entity_t instance = it->entities[i];
-        ecs_script_clear(it->world, 0, instance);
-    }
-}
-
-/* Set default property values on assembly Script component */
-static
-int flecs_assembly_init_defaults(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_entity_t assembly,
-    EcsScript *script,
-    plecs_state_t *state)
-{
-    const EcsStruct *st = ecs_get(world, assembly, EcsStruct);
-    int32_t i, count = st->members.count;
-    const ecs_member_t *members = st->members.array;
-
-    ecs_vec_init_t(NULL, &script->prop_defaults, ecs_value_t, count);
-
-    for (i = 0; i < count; i ++) {
-        const ecs_member_t *member = &members[i];
-        ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, member->name);
-        if (!var) {
-            char *assembly_name = ecs_get_fullpath(world, assembly);
-            ecs_parser_error(name, expr, ptr - expr, 
-                "missing property '%s' for assembly '%s'", 
-                    member->name, assembly_name);
-            ecs_os_free(assembly_name);
-            return -1;
-        }
-
-        if (member->type != var->value.type) {
-            char *assembly_name = ecs_get_fullpath(world, assembly);
-            ecs_parser_error(name, expr, ptr - expr, 
-                "property '%s' for assembly '%s' has mismatching type", 
-                    member->name, assembly_name);
-            ecs_os_free(assembly_name);
-            return -1;
-        }
-
-        ecs_value_t *pv = ecs_vec_append_t(NULL, 
-            &script->prop_defaults, ecs_value_t);
-        pv->type = member->type;
-        pv->ptr = var->value.ptr;
-        var->owned = false; /* Transfer ownership */
-    }
-
-    return 0;
-}
-
-/* Create new assembly */
-static
-int flecs_assembly_create(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    ecs_entity_t assembly,
-    char *script_code,
-    plecs_state_t *state)
-{
-    const EcsStruct *st = ecs_get(world, assembly, EcsStruct);
-    if (!st || !st->members.count) {
-        char *assembly_name = ecs_get_fullpath(world, assembly);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "assembly '%s' has no properties", assembly_name);
-        ecs_os_free(assembly_name);
-        ecs_os_free(script_code);
-        return -1;
-    }
-
-    ecs_add_id(world, assembly, EcsAlwaysOverride);
-
-    EcsScript *script = ecs_ensure(world, assembly, EcsScript);
-    flecs_dtor_script(script);
-    script->world = world;
-    script->script = script_code;
-    ecs_vec_reset_t(NULL, &script->using_, ecs_entity_t);
-
-    ecs_entity_t scope = ecs_get_scope(world);
-    if (scope && (scope = ecs_get_target(world, scope, EcsChildOf, 0))) {
-        ecs_vec_append_t(NULL, &script->using_, ecs_entity_t)[0] = scope;
-    }
-
-    int i, count = state->using_frame;
-    for (i = 0; i < count; i ++) {
-        ecs_vec_append_t(NULL, &script->using_, ecs_entity_t)[0] = 
-            state->using[i];
-    }
-
-    if (flecs_assembly_init_defaults(
-        world, name, expr, ptr, assembly, script, state)) 
-    {
-        return -1;    
-    }
-
-    ecs_modified(world, assembly, EcsScript);
-
-    ecs_set_hooks_id(world, assembly, &(ecs_type_hooks_t) {
-        .ctor = flecs_assembly_ctor,
-        .on_set = flecs_assembly_on_set,
-        .on_remove = flecs_assembly_on_remove,
-        .ctx = world
-    });
-
-    return 0;
-}
-
-/* Parser */
-
-static
-bool plecs_is_newline_comment(
-    const char *ptr)
-{
-    if (ptr[0] == '/' && ptr[1] == '/') {
-        return true;
-    }
-    return false;
-}
-
-static
-const char* plecs_parse_fluff(
-    const char *ptr)
-{
-    do {
-        /* Skip whitespaces before checking for a comment */
-        ptr = ecs_parse_ws(ptr);
-
-        /* Newline comment, skip until newline character */
-        if (plecs_is_newline_comment(ptr)) {
-            ptr += 2;
-
-            while (ptr[0] && ptr[0] != TOK_NEWLINE) {
-                ptr ++;
-            }
-        }
-
-        /* If a newline character is found, skip it */
-        if (ptr[0] == TOK_NEWLINE) {
-            ptr ++;
-        }
-
-    } while (isspace(ptr[0]) || plecs_is_newline_comment(ptr));
-
-    return ptr;
-}
-
-static
-ecs_entity_t plecs_lookup(
-    const ecs_world_t *world,
-    const char *path,
-    plecs_state_t *state,
-    ecs_entity_t rel,
-    bool is_subject)
-{
-    ecs_entity_t e = 0;
-
-    if (!is_subject) {
-        ecs_entity_t oneof = 0;
-        if (rel) {
-            if (ecs_has_id(world, rel, EcsOneOf)) {
-                oneof = rel;
-            } else {
-                oneof = ecs_get_target(world, rel, EcsOneOf, 0);
-            }
-            if (oneof) {
-                return ecs_lookup_path_w_sep(
-                    world, oneof, path, NULL, NULL, false);
-            }
-        }
-        int using_scope = state->using_frame - 1;
-        for (; using_scope >= 0; using_scope--) {
-            e = ecs_lookup_path_w_sep(
-                world, state->using[using_scope], path, NULL, NULL, false);
-            if (e) {
-                break;
-            }
-        }
-    }
-
-    if (!e) {
-        e = ecs_lookup_path_w_sep(world, 0, path, NULL, NULL, !is_subject);
-    }
-
-    return e;
-}
-
-/* Lookup action used for deserializing entity refs in component values */
-static
-ecs_entity_t plecs_lookup_action(
-    const ecs_world_t *world,
-    const char *path,
-    void *ctx)
-{
-    return plecs_lookup(world, path, ctx, 0, false);
-}
-
-static
-void plecs_apply_with_frame(
-    ecs_world_t *world,
-    plecs_state_t *state,
-    ecs_entity_t e)
-{
-    int32_t i, frame_count = state->with_frames[state->sp];
-    for (i = 0; i < frame_count; i ++) {
-        ecs_id_t id = state->with[i];
-        plecs_with_value_t *v = &state->with_value_frames[i];
-        if (v->value.type) {
-            void *ptr = ecs_ensure_id(world, e, id);
-            ecs_value_copy(world, v->value.type, ptr, v->value.ptr);
-            ecs_modified_id(world, e, id);
-        } else {
-            ecs_add_id(world, e, id);
-        }
-    }
-}
-
-static
-ecs_entity_t plecs_ensure_entity(
-    ecs_world_t *world,
-    plecs_state_t *state,
-    const char *path,
-    ecs_entity_t rel,
-    bool is_subject)
-{
-    if (!path) {
-        return 0;
-    }
-
-    ecs_entity_t e = 0;
-    bool is_anonymous = !ecs_os_strcmp(path, "_");
-    bool is_new = false;
-    if (is_anonymous) {
-        path = NULL;
-        e = ecs_new_id(world);
-        is_new = true;
-    }
-
-    if (!e) {
-        e = plecs_lookup(world, path, state, rel, is_subject);
-    }
-
-    if (!e) {
-        is_new = true;
-        if (rel && flecs_get_oneof(world, rel)) {
-            /* If relationship has oneof and entity was not found, don't proceed
-             * with creating an entity as this can cause asserts later on */
-            char *relstr = ecs_get_fullpath(world, rel);
-            ecs_parser_error(state->name, 0, 0, 
-                "invalid identifier '%s' for relationship '%s'", path, relstr);
-            ecs_os_free(relstr);
-            return 0;
-        }
-
-        ecs_entity_t prev_scope = 0;
-        ecs_entity_t prev_with = 0;
-        if (!is_subject) {
-            /* Don't apply scope/with for non-subject entities */
-            prev_scope = ecs_set_scope(world, 0);
-            prev_with = ecs_set_with(world, 0);
-        }
-
-        e = ecs_add_path(world, e, 0, path);
-        ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL);
-
-        if (prev_scope) {
-            ecs_set_scope(world, prev_scope);
-        }
-        if (prev_with) {
-            ecs_set_with(world, prev_with);
-        }
-    } else {
-        /* If entity exists, make sure it gets the right scope and with */
-        if (is_subject) {
-            ecs_entity_t scope = ecs_get_scope(world);
-            if (scope) {
-                ecs_add_pair(world, e, EcsChildOf, scope);
-            }
-
-            ecs_entity_t with = ecs_get_with(world);
-            if (with) {
-                ecs_add_id(world, e, with);
-            }
-        }
-    }
-
-    if (is_new) {
-        if (state->assembly && !state->assembly_instance) {
-            ecs_add_id(world, e, EcsPrefab);
-        }
-
-        if (state->global_with) {
-            ecs_add_id(world, e, state->global_with);
-        }
-    }
-
-    return e;
-}
-
-static
-ecs_entity_t plecs_ensure_term_id(
-    ecs_world_t *world,
-    plecs_state_t *state,
-    ecs_term_id_t *term_id,
-    const char *expr,
-    int64_t column,
-    ecs_entity_t pred,
-    bool is_subject)
-{
-    ecs_entity_t result = 0;
-    const char *name = term_id->name;
-    if (term_id->flags & EcsIsVariable) {
-        if (name != NULL) {
-            ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, name);
-            if (!var) {
-                ecs_parser_error(name, expr, column,
-                    "unresolved variable '%s'", name);
-                return 0;
-            }
-            if (var->value.type != ecs_id(ecs_entity_t)) {
-                ecs_parser_error(name, expr, column,
-                    "variable '%s' is not an entity", name);
-                return 0;
-            }
-            result = *(ecs_entity_t*)var->value.ptr;
-            if (!result) {
-                ecs_parser_error(name, expr, column,
-                    "variable '%s' is not initialized with valid entity", name);
-                return 0;
-            }
-        } else if (term_id->id) {
-            result = term_id->id;
-        } else {
-            ecs_parser_error(name, expr, column, "invalid variable in term");
-            return 0;
-        }
-    } else {
-        result = plecs_ensure_entity(world, state, name, pred, is_subject);
-    }
-    return result;
-}
-
-static
-bool plecs_pred_is_subj(
-    ecs_term_t *term,
-    plecs_state_t *state)
-{
-    if (term->src.name != NULL) {
-        return false;
-    }
-    if (term->second.name != NULL) {
-        return false;
-    }
-    if (ecs_term_match_0(term)) {
-        return false;
-    }
-    if (state->with_stmt) {
-        return false;
-    }
-    if (state->assign_stmt) {
-        return false;
-    }
-    if (state->isa_stmt) {
-        return false;
-    }
-    if (state->decl_type) {
-        return false;
-    }
-
-    return true;
-}
-
-/* Set masks aren't useful in plecs, so translate them back to entity names */
-static
-const char* plecs_set_mask_to_name(
-    ecs_flags32_t flags) 
-{
-    flags &= EcsTraverseFlags;
-    if (flags == EcsSelf) {
-        return "self";
-    } else if (flags == EcsUp) {
-        return "up";
-    } else if (flags == EcsDown) {
-        return "down";
-    } else if (flags == EcsCascade || flags == (EcsUp|EcsCascade)) {
-        return "cascade";
-    } else if (flags == EcsParent) {
-        return "parent";
-    }
-    return NULL;
-}
-
-#ifdef FLECS_DOC
-static
-char* plecs_trim_annot(
-    char *annot)
-{
-    annot = ECS_CONST_CAST(char*, ecs_parse_ws(annot));
-    int32_t len = ecs_os_strlen(annot) - 1;
-    while (isspace(annot[len]) && (len > 0)) {
-        annot[len] = '\0';
-        len --;
-    }
-    return annot;
-}
-#endif
-
-static
-void plecs_apply_annotations(
-    ecs_world_t *world,
-    ecs_entity_t subj,
-    plecs_state_t *state)
-{
-    (void)world;
-    (void)subj;
-    (void)state;
-#ifdef FLECS_DOC
-    int32_t i = 0, count = state->annot_count;
-    for (i = 0; i < count; i ++) {
-        char *annot = state->annot[i];
-        if (!ecs_os_strncmp(annot, "@brief ", 7)) {
-            annot = plecs_trim_annot(annot + 7);
-            ecs_doc_set_brief(world, subj, annot);
-        } else if (!ecs_os_strncmp(annot, "@link ", 6)) {
-            annot = plecs_trim_annot(annot + 6);
-            ecs_doc_set_link(world, subj, annot);
-        } else if (!ecs_os_strncmp(annot, "@name ", 6)) {
-            annot = plecs_trim_annot(annot + 6);
-            ecs_doc_set_name(world, subj, annot);
-        } else if (!ecs_os_strncmp(annot, "@color ", 7)) {
-            annot = plecs_trim_annot(annot + 7);
-            ecs_doc_set_color(world, subj, annot);
-        }
-    }
-#else
-    ecs_warn("cannot apply annotations, doc addon is missing");
-#endif
-}
-
-static
-int plecs_create_term(
-    ecs_world_t *world, 
-    ecs_term_t *term,
-    const char *name,
-    const char *expr,
-    int64_t column,
-    plecs_state_t *state)
-{
-    state->last_subject = 0;
-    state->last_predicate = 0;
-    state->last_object = 0;
-    state->last_assign_id = 0;
-
-    const char *subj_name = term->src.name;
-    if (!subj_name) {
-        subj_name = plecs_set_mask_to_name(term->src.flags);
-    }
-
-    if (!ecs_term_id_is_set(&term->first)) {
-        ecs_parser_error(name, expr, column, "missing term in expression");
-        return -1;
-    }
-
-    if (state->assign_stmt && !ecs_term_match_this(term)) {
-        ecs_parser_error(name, expr, column, 
-            "invalid statement in assign statement");
-        return -1;
-    }
-
-    bool pred_as_subj = plecs_pred_is_subj(term, state);
-    ecs_entity_t subj = 0, obj = 0, pred = plecs_ensure_term_id(
-        world, state, &term->first, expr, column, 0, pred_as_subj);
-    if (!pred) {
-        return -1;
-    }
-
-    subj = plecs_ensure_entity(world, state, subj_name, pred, true);
-
-    if (ecs_term_id_is_set(&term->second)) {
-        obj = plecs_ensure_term_id(world, state, &term->second, expr, column, 
-            pred, !state->assign_stmt && !state->with_stmt);
-        if (!obj) {
-            return -1;
-        }
-    }
-
-    if (state->assign_stmt || state->isa_stmt) {
-        subj = state->assign_to;
-    }
-
-    if (state->isa_stmt && obj) {
-        ecs_parser_error(name, expr, column, 
-            "invalid object in inheritance statement");
-        return -1;
-    }
-
-    if (state->isa_stmt) {
-        pred = ecs_pair(EcsIsA, pred);
-    }
-
-    if (subj == EcsVariable) {
-        subj = pred;
-    }
-
-    if (subj) {
-        ecs_id_t id;
-        if (!obj) {
-            id = term->id_flags | pred;
-        } else {
-            id = term->id_flags | ecs_pair(pred, obj);
-            state->last_object = obj;
-        }
-        state->last_assign_id = id;
-        state->last_predicate = pred;
-        state->last_subject = subj;
-        ecs_add_id(world, subj, id);
-
-        pred_as_subj = false;
-    } else {
-        if (!obj) {
-            /* If no subject or object were provided, use predicate as subj 
-             * unless the expression explicitly excluded the subject */
-            if (pred_as_subj) {
-                state->last_subject = pred;
-                subj = pred;
-            } else {
-                state->last_predicate = pred;
-                pred_as_subj = false;
-            }
-        } else {
-            state->last_predicate = pred;
-            state->last_object = obj;
-            pred_as_subj = false;
-        }
-    }
-
-    /* If this is a with clause (the list of entities between 'with' and scope
-     * open), add subject to the array of with frames */
-    if (state->with_stmt) {
-        ecs_assert(pred != 0, ECS_INTERNAL_ERROR, NULL);
-        ecs_id_t id;
-
-        if (obj) {
-            id = ecs_pair(pred, obj);
-        } else {
-            id = pred;
-        }
-
-        state->with[state->with_frame ++] = id;
-    } else {
-        if (subj && !state->scope_assign_stmt) {
-            plecs_apply_with_frame(world, state, subj);
-        }
-    }
-
-    /* If an id was provided by itself, add default scope type to it */
-    ecs_entity_t default_scope_type = state->default_scope_type[state->sp];
-    if (pred_as_subj && default_scope_type) {
-        ecs_add_id(world, subj, default_scope_type);
-    }
-
-    /* If annotations preceded the statement, append */
-    if (!state->decl_type && state->annot_count) {
-        if (!subj) {
-            ecs_parser_error(name, expr, column, 
-                "missing subject for annotations");
-            return -1;
-        }
-
-        plecs_apply_annotations(world, subj, state);
-    }
-
-    return 0;
-}
-
-static
-const char* plecs_parse_inherit_stmt(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    if (state->isa_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "cannot nest inheritance");
-        return NULL;
-    }
-
-    if (!state->last_subject) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing entity to assign inheritance to");
-        return NULL;
-    }
-    
-    state->isa_stmt = true;
-    state->assign_to = state->last_subject;
-
-    return ptr;
-}
-
-static
-const char* plecs_parse_assign_var_expr(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state,
-    ecs_expr_var_t *var)
-{
-    ecs_value_t value = {0};
-
-    if (state->last_assign_id) {
-        value.type = state->last_assign_id;
-        value.ptr = ecs_value_new(world, state->last_assign_id);
-        if (!var && state->assembly_instance) {
-            var = ecs_vars_lookup(&state->vars, state->var_name);
-        }
-    }
-
-    ptr = ecs_parse_expr(world, ptr, &value, 
-        &(ecs_parse_expr_desc_t){
-            .name = name,
-            .expr = expr,
-            .lookup_action = plecs_lookup_action,
-            .lookup_ctx = state,
-            .vars = &state->vars
-        });
-    if (!ptr) {
-        if (state->last_assign_id) {
-            ecs_value_free(world, value.type, value.ptr);
-        }
-        goto error;
-    }
-
-    if (var) {
-        bool ignore = state->var_is_prop && state->assembly_instance;
-        if (!ignore) {
-            if (var->value.ptr) {
-                ecs_value_free(world, var->value.type, var->value.ptr);
-                var->value.ptr = value.ptr;
-                var->value.type = value.type;
-            }
-        } else {
-            ecs_value_free(world, value.type, value.ptr);
-        }
-    } else {
-        var = ecs_vars_declare_w_value(
-            &state->vars, state->var_name, &value);
-        if (!var) {
-            goto error;
-        }
-    }
-
-    state->var_is_prop = false;
-    return ptr;
-error:
-    return NULL;
-}
-
-static
-const char* plecs_parse_assign_expr(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state,
-    ecs_expr_var_t *var) 
-{
-    (void)world;
-    
-    if (state->var_stmt) {
-        return plecs_parse_assign_var_expr(world, name, expr, ptr, state, var);
-    }
-
-    if (!state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr,
-            "unexpected value outside of assignment statement");
-        return NULL;
-    }
-
-    ecs_id_t assign_id = state->last_assign_id;
-    if (!assign_id) {
-        ecs_parser_error(name, expr, ptr - expr,
-            "missing type for assignment statement");
-        return NULL;
-    }
-
-    ecs_entity_t assign_to = state->assign_to;
-    if (!assign_to) {
-        assign_to = state->last_subject;
-    }
-
-    if (!assign_to) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing entity to assign to");
-        return NULL;
-    }
-
-    ecs_entity_t type = ecs_get_typeid(world, assign_id);
-    if (!type) {
-        char *id_str = ecs_id_str(world, assign_id);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid assignment, '%s' is not a type", id_str);
-        ecs_os_free(id_str);
-        return NULL;
-    }
-
-    if (assign_to == EcsVariable) {
-        assign_to = type;
-    }
-
-    void *value_ptr = ecs_ensure_id(world, assign_to, assign_id);
-
-    ptr = ecs_parse_expr(world, ptr, &(ecs_value_t){type, value_ptr}, 
-        &(ecs_parse_expr_desc_t){
-            .name = name,
-            .expr = expr,
-            .lookup_action = plecs_lookup_action,
-            .lookup_ctx = state,
-            .vars = &state->vars
-        });
-    if (!ptr) {
-        return NULL;
-    }
-
-    ecs_modified_id(world, assign_to, assign_id);
-
-    return ptr;
-}
-
-static
-const char* plecs_parse_assign_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
-{
-    (void)world;
-
-    state->isa_stmt = false;
-
-    /* Component scope (add components to entity) */
-    if (!state->assign_to) {
-        if (!state->last_subject) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "missing entity to assign to");
-            return NULL;
-        }
-        state->assign_to = state->last_subject;
-    }
-
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid assign statement in assign statement");
-        return NULL;
-    }
-
-    state->assign_stmt = true;
-    
-    /* Assignment without a preceding component */
-    if (ptr[0] == '{') {
-        ecs_entity_t type = 0;
-
-        /* If we're in a scope & last_subject is a type, assign to scope */
-        if (ecs_get_scope(world) != 0) {
-            type = ecs_get_typeid(world, state->last_subject);
-            if (type != 0) {
-                type = state->last_subject;
-            }
-        }
-
-        /* If type hasn't been set yet, check if scope has default type */
-        if (!type && !state->scope_assign_stmt) {
-            type = state->default_scope_type[state->sp];
-        }
-
-        /* If no type has been found still, check if last with id is a type */
-        if (!type && !state->scope_assign_stmt) {
-            int32_t with_frame_count = state->with_frames[state->sp];
-            if (with_frame_count) {
-                type = state->with[with_frame_count - 1];
-            }
-        }
-
-        if (!type) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "missing type for assignment");
-            return NULL;
-        }
-
-        state->last_assign_id = type;
-    }
-
-    return ptr;
-}
-
-static
-const char* plecs_parse_assign_with_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    int32_t with_frame = state->with_frame - 1;
-    if (with_frame < 0) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing type in with value");
-        return NULL;
-    }
-
-    ecs_id_t id = state->with[with_frame];
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    const ecs_type_info_t *ti = idr ? idr->type_info : NULL;
-    if (!ti) {
-        char *typename = ecs_id_str(world, id);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "id '%s' in with value is not a type", typename);
-        ecs_os_free(typename);
-        return NULL;
-    }
-
-    plecs_with_value_t *v = &state->with_value_frames[with_frame];
-    v->value.type = ti->component;
-    v->value.ptr = ecs_value_new(world, ti->component);
-    v->owned = true;
-    if (!v->value.ptr) {
-        char *typename = ecs_id_str(world, id);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "failed to create value for '%s'", typename);
-        ecs_os_free(typename);
-        return NULL;
-    }
-
-    ptr = ecs_parse_expr(world, ptr, &v->value,
-        &(ecs_parse_expr_desc_t){
-            .name = name,
-            .expr = expr,
-            .lookup_action = plecs_lookup_action,
-            .lookup_ctx = state,
-            .vars = &state->vars
-        });
-    if (!ptr) {
-        return NULL;
-    }
-
-    return ptr;
-}
-
-static
-const char* plecs_parse_assign_with_var(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    ecs_assert(ptr[0] == '$', ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(state->with_stmt, ECS_INTERNAL_ERROR, NULL);
-
-    char var_name[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr;
-    ptr = ecs_parse_token(name, expr, ptr + 1, var_name, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "unresolved variable '%s'", var_name);
-        return NULL;
-    }
-
-    ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, var_name);
-    if (!var) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unresolved variable '%s'", var_name);
-        return NULL;
-    }
-
-    int32_t with_frame = state->with_frame;
-    state->with[with_frame] = var->value.type;
-    state->with_value_frames[with_frame].value = var->value;
-    state->with_value_frames[with_frame].owned = false;
-    state->with_frame ++;
-
-    return ptr;
-}
-
-static
-const char* plecs_parse_var_as_component(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    ecs_assert(ptr[0] == '$', ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!state->var_stmt, ECS_INTERNAL_ERROR, NULL);
-    char var_name[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr;
-    ptr = ecs_parse_token(name, expr, ptr + 1, var_name, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "unresolved variable '%s'", var_name);
-        return NULL;
-    }
-
-    ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, var_name);
-    if (!var) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unresolved variable '%s'", var_name);
-        return NULL;
-    }
-
-    if (!state->assign_to) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "missing lvalue for variable assignment '%s'", var_name);
-        return NULL;
-    }
-
-    /* Use type of variable as component */
-    ecs_entity_t type = var->value.type;
-    ecs_entity_t assign_to = state->assign_to;
-    if (!assign_to) {
-        assign_to = state->last_subject;
-    }
-
-    void *dst = ecs_ensure_id(world, assign_to, type);
-    if (!dst) {
-        char *type_name = ecs_get_fullpath(world, type);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "failed to obtain component for type '%s' of variable '%s'",    
-                type_name, var_name);
-        ecs_os_free(type_name);
-        return NULL;
-    }
-
-    if (ecs_value_copy(world, type, dst, var->value.ptr)) {
-        char *type_name = ecs_get_fullpath(world, type);
-        ecs_parser_error(name, expr, ptr - expr, 
-            "failed to copy value for variable '%s' of type '%s'",    
-                var_name, type_name);
-        ecs_os_free(type_name);
-        return NULL;
-    }
-
-    ecs_modified_id(world, assign_to, type);
-
-    return ptr;
-}
-
-static
-void plecs_push_using(
-    ecs_entity_t scope,
-    plecs_state_t *state)
-{
-    for (int i = 0; i < state->using_frame; i ++) {
-        if (state->using[i] == scope) {
-            return;
-        }
-    }
-
-    state->using[state->using_frame ++] = scope;
-}
-
-static
-const char* plecs_parse_using_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
-{
-    if (state->isa_stmt || state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid usage of using keyword");
-        return NULL;
-    }
-
-    char using_path[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr + 1;
-    ptr = ecs_parse_token(name, expr, ptr + 5, using_path, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "expected identifier for using statement");
-        return NULL;
-    }
-
-    ecs_size_t len = ecs_os_strlen(using_path);
-    if (!len) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "missing identifier for using statement");
-        return NULL;
-    }
-
-    /* Lookahead as * is not matched by parse_token */
-    if (ptr[0] == '*') {
-        using_path[len] = '*';
-        using_path[len + 1] = '\0';
-        len ++;
-        ptr ++;
-    }
-
-    ecs_entity_t scope;
-    if (len > 2 && !ecs_os_strcmp(&using_path[len - 2], ".*")) {
-        using_path[len - 2] = '\0';
-        scope = ecs_lookup(world, using_path);
-        if (!scope) {
-            ecs_parser_error(name, expr, ptr - expr,
-                "unresolved identifier '%s' in using statement", using_path);
-            return NULL;
-        }
-
-        /* Add each child of the scope to using stack */
-        ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ 
-            .id = ecs_childof(scope) });
-        while (ecs_term_next(&it)) {
-            int32_t i, count = it.count;
-            for (i = 0; i < count; i ++) {
-                plecs_push_using(it.entities[i], state);
-            }
-        }
-    } else {
-        scope = plecs_ensure_entity(world, state, using_path, 0, false);
-        if (!scope) {
-            ecs_parser_error(name, expr, ptr - expr,
-                "unresolved identifier '%s' in using statement", using_path);
-            return NULL;
-        }
-
-        plecs_push_using(scope, state);
-    }
-
-    state->using_frames[state->sp] = state->using_frame;
-    return ptr;
-}
-
-static
-const char* plecs_parse_module_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    const char *expr_start = ecs_parse_ws_eol(expr);
-    if (expr_start != ptr) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "module must be first statement of script");
-        return NULL;
-    }
-
-    char module_path[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr + 1;
-    ptr = ecs_parse_token(name, expr, ptr + 6, module_path, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "expected identifier for module statement");
-        return NULL;
-    }
-
-    ecs_component_desc_t desc = {0};
-    desc.entity = ecs_entity(world, { .name = module_path });
-    ecs_entity_t module = ecs_module_init(world, NULL, &desc);
-    if (!module) {
-        return NULL;
-    }
-
-    state->is_module = true;
-    state->sp ++;
-    state->scope[state->sp] = module;
-    ecs_set_scope(world, module);
-    return ptr;
-}
-
-static
-const char* plecs_parse_with_stmt(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
-{
-    if (state->isa_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid with after inheritance");
-        return NULL;
-    }
-
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid with in assign_stmt");
-        return NULL;
-    }
-
-    /* Add following expressions to with list */
-    state->with_stmt = true;
-    return ptr + 5;
-}
-
-static
-const char* plecs_parse_assembly_stmt(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
-{
-    if (state->isa_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid with after inheritance");
-        return NULL;
-    }
-
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid with in assign_stmt");
-        return NULL;
-    }
-
-    state->assembly_stmt = true;
-
-    return ptr + 9;
-}
-
-static
-const char* plecs_parse_var_type(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state,
-    ecs_entity_t *type_out)
-{
-    char prop_type_name[ECS_MAX_TOKEN_SIZE];
-    const char *tmp = ptr + 1;
-    ptr = ecs_parse_token(name, expr, ptr + 1, prop_type_name, 0);
-    if (!ptr) {
-        ecs_parser_error(name, expr, tmp - expr, 
-            "expected type for prop declaration");
-        return NULL;
-    }
-
-    ecs_entity_t prop_type = plecs_lookup(world, prop_type_name, state, 0, false);
-    if (!prop_type) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unresolved property type '%s'", prop_type_name);
-        return NULL;
-    }
-
-    *type_out = prop_type;
-
-    return ptr;
-}
-
-static
-const char* plecs_parse_const_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    ptr = ecs_parse_token(name, expr, ptr + 5, state->var_name, 0);
-    if (!ptr) {
-        return NULL;
-    }
-
-    ptr = ecs_parse_ws(ptr);
-
-    if (ptr[0] == ':') {
-        ptr = plecs_parse_var_type(
-            world, name, expr, ptr, state, &state->last_assign_id);
-        if (!ptr) {
-            return NULL;
-        }
-
-        ptr = ecs_parse_ws(ptr);
-    }
-
-    if (ptr[0] != '=') {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "expected '=' after const declaration");
-        return NULL;
-    }
-
-    state->var_stmt = true;
-    return ptr + 1;
-}
-
-static
-const char* plecs_parse_prop_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    char prop_name[ECS_MAX_TOKEN_SIZE];
-    ptr = ecs_parse_token(name, expr, ptr + 5, prop_name, 0);
-    if (!ptr) {
-        return NULL;
-    }
-
-    ptr = ecs_parse_ws(ptr);
-
-    if (ptr[0] != ':') {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "expected ':' after prop declaration");
-        return NULL;
-    }
-
-    ecs_entity_t prop_type;
-    ptr = plecs_parse_var_type(world, name, expr, ptr, state, &prop_type);
-    if (!ptr) {
-        return NULL;
-    }
-
-    ecs_entity_t assembly = state->assembly;
-    if (!assembly) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unexpected prop '%s' outside of assembly", prop_name);
-        return NULL;
-    }
-
-    if (!state->assembly_instance) {
-        ecs_entity_t prop_member = ecs_entity(world, {
-            .name = prop_name,
-            .add = { ecs_childof(assembly) }
-        });
-
-        if (!prop_member) {
-            return NULL;
-        }
-
-        ecs_set(world, prop_member, EcsMember, {
-            .type = prop_type
-        });
-    }
-
-    if (ptr[0] != '=') {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "expected '=' after prop type");
-        return NULL;
-    }
-
-    ecs_os_strcpy(state->var_name, prop_name);
-    state->last_assign_id = prop_type;
-    state->var_stmt = true;
-    state->var_is_prop = true;
-
-    return plecs_parse_fluff(ptr + 1);
-}
-
-static
-const char* plecs_parse_scope_open(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
-{
-    state->isa_stmt = false;
-
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid scope in assign_stmt");
-        return NULL;
-    }
-
-    state->sp ++;
-
-    ecs_entity_t scope = 0;
-    ecs_entity_t default_scope_type = 0;
-    bool assembly_stmt = false;
-
-    if (!state->with_stmt) {
-        if (state->last_subject) {
-            scope = state->last_subject;
-            ecs_set_scope(world, state->last_subject);
-
-            /* Check if scope has a default child component */
-            ecs_entity_t def_type_src = ecs_get_target_for_id(world, scope, 
-                0, ecs_pair(EcsDefaultChildComponent, EcsWildcard));
-
-            if (def_type_src) {
-                default_scope_type = ecs_get_target(
-                    world, def_type_src, EcsDefaultChildComponent, 0);
-            }
-        } else {
-            if (state->last_object) {
-                scope = ecs_pair(
-                    state->last_predicate, state->last_object);
-                ecs_set_with(world, scope);
-            } else {
-                if (state->last_predicate) {
-                    scope = ecs_pair(EcsChildOf, state->last_predicate);
-                }
-                ecs_set_scope(world, state->last_predicate);
-            }
-        }
-
-        state->scope[state->sp] = scope;
-        state->default_scope_type[state->sp] = default_scope_type;
-
-        if (state->assembly_stmt) {
-            assembly_stmt = true;
-            if (state->assembly) {
-                ecs_parser_error(name, expr, ptr - expr, 
-                    "invalid nested assembly");
-                return NULL;
-            }
-            state->assembly = scope;
-            state->assembly_stmt = false;
-            state->assembly_start = ptr;
-        }
-    } else {
-        state->scope[state->sp] = state->scope[state->sp - 1];
-        state->default_scope_type[state->sp] = 
-            state->default_scope_type[state->sp - 1];
-        state->assign_to = 0;
-    }
-
-    state->using_frames[state->sp] = state->using_frame;
-    state->with_frames[state->sp] = state->with_frame;
-    state->with_stmt = false;
-
-    ecs_vars_push(&state->vars);
-
-    /* Declare variable to hold assembly instance during instantiation */
-    if (assembly_stmt) {
-        ecs_value_t val = {0};
-        ecs_expr_var_t *var = ecs_vars_declare_w_value(
-            &state->vars, "this", &val);
-        var->value.ptr = ECS_CONST_CAST(void*, &EcsThis); /* Dummy value */
-        var->value.type = ecs_id(ecs_entity_t);
-        var->owned = false;
-    }
-
-    return ptr;
-}
-
-static
-void plecs_free_with_frame(
-    ecs_world_t *world,
-    plecs_state_t *state)
-{
-    int32_t i, prev_with = state->with_frames[state->sp];
-    for (i = prev_with; i < state->with_frame; i ++) {
-        plecs_with_value_t *v = &state->with_value_frames[i];
-        if (!v->owned) {
-            continue;
-        }
-        if (v->value.type) {
-            ecs_value_free(world, v->value.type, v->value.ptr);
-            v->value.type = 0;
-            v->value.ptr = NULL;
-            v->owned = false;
-        }
-    }
-}
-
-static
-void plecs_free_all_with_frames(
-    ecs_world_t *world,
-    plecs_state_t *state)
-{
-    int32_t i;
-    for (i = state->sp - 1; i >= 0; i --) {
-        state->sp = i;
-        plecs_free_with_frame(world, state);
-    }    
-}
-
-static
-const char* plecs_parse_scope_close(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state) 
-{
-    if (state->isa_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "invalid '}' after inheritance statement");
-        return NULL;
-    }
-
-    if (state->assign_stmt) {
-        ecs_parser_error(name, expr, ptr - expr, 
-            "unfinished assignment before }");
-        return NULL;
-    }
-
-    ecs_entity_t cur = state->scope[state->sp], assembly = state->assembly;
-    if (state->sp && (cur == state->scope[state->sp - 1])) {
-        /* Previous scope is also from the assembly, not found the end yet */
-        cur = 0;
-    }
-    if (cur && cur == assembly) {
-        ecs_size_t assembly_len = flecs_ito(ecs_size_t, ptr - state->assembly_start);
-        if (assembly_len) {
-            assembly_len --;
-            char *script = ecs_os_malloc_n(char, assembly_len + 1);
-            ecs_os_memcpy(script, state->assembly_start, assembly_len);
-            script[assembly_len] = '\0';
-            state->assembly = 0;
-            state->assembly_start = NULL;
-            if (flecs_assembly_create(world, name, expr, ptr, assembly, script, state)) {
-                return NULL;
-            }
-        } else {
-            ecs_parser_error(name, expr, ptr - expr, "empty assembly");
-            return NULL;
-        }
-    }
-
-    state->scope[state->sp] = 0;
-    state->default_scope_type[state->sp] = 0;
-    state->sp --;
-
-    if (state->sp < 0) {
-        ecs_parser_error(name, expr, ptr - expr, "invalid } without a {");
-        return NULL;
-    }
-
-    ecs_id_t id = state->scope[state->sp];
-    if (!id || ECS_HAS_ID_FLAG(id, PAIR)) {
-        ecs_set_with(world, id);
-    }
-
-    if (!id || !ECS_HAS_ID_FLAG(id, PAIR)) {
-        ecs_set_scope(world, id);
-    }
-
-    plecs_free_with_frame(world, state);
-
-    state->with_frame = state->with_frames[state->sp];
-    state->using_frame = state->using_frames[state->sp];
-    state->last_subject = 0;
-    state->assign_stmt = false;
-
-    ecs_vars_pop(&state->vars);
-
-    return plecs_parse_fluff(ptr + 1);
-}
-
-static
-const char *plecs_parse_plecs_term(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    ecs_term_t term = {0};
-    ecs_entity_t decl_id = 0;
-    if (state->decl_stmt) {
-        decl_id = state->last_predicate;
-    }
-
-    ptr = ecs_parse_term(world, name, expr, ptr, &term, NULL, NULL, false);
-    if (!ptr) {
-        return NULL;
-    }
-
-    if (flecs_isident(ptr[0])) {
-        state->decl_type = true;
-    }
-
-    if (!ecs_term_is_initialized(&term)) {
-        ecs_parser_error(name, expr, ptr - expr, "expected identifier");
-        return NULL; /* No term found */
-    }
-
-    if (plecs_create_term(world, &term, name, expr, (ptr - expr), state)) {
-        ecs_term_fini(&term);
-        return NULL; /* Failed to create term */
-    }
-
-    if (decl_id && state->last_subject) {
-        ecs_add_id(world, state->last_subject, decl_id);
-    }
-
-    state->decl_type = false;
-
-    ecs_term_fini(&term);
-
-    return ptr;
-}
-
-static
-const char* plecs_parse_annotation(
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    do {
-        if(state->annot_count >= STACK_MAX_SIZE) {
-            ecs_parser_error(name, expr, ptr - expr, 
-                "max number of annotations reached");
-            return NULL;
-        }
-
-        char ch;
-        const char *start = ptr;
-        for (; (ch = *ptr) && ch != '\n'; ptr ++) { }
-
-        int32_t len = (int32_t)(ptr - start);
-        char *annot = ecs_os_malloc_n(char, len + 1);
-        ecs_os_memcpy_n(annot, start, char, len);
-        annot[len] = '\0';
-
-        state->annot[state->annot_count] = annot;
-        state->annot_count ++;
-
-        ptr = plecs_parse_fluff(ptr);
-    } while (ptr[0] == '@');
-
-    return ptr;
-}
-
-static
-void plecs_clear_annotations(
-    plecs_state_t *state)
-{
-    int32_t i, count = state->annot_count;
-    for (i = 0; i < count; i ++) {
-        ecs_os_free(state->annot[i]);
-    }
-    state->annot_count = 0;
-}
-
-static
-const char* plecs_parse_stmt(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    const char *ptr,
-    plecs_state_t *state)
-{
-    state->assign_stmt = false;
-    state->scope_assign_stmt = false;
-    state->isa_stmt = false;
-    state->with_stmt = false;
-    state->decl_stmt = false;
-    state->var_stmt = false;
-    state->last_subject = 0;
-    state->last_predicate = 0;
-    state->last_object = 0;
-    state->assign_to = 0;
-    state->last_assign_id = 0;
-
-    plecs_clear_annotations(state);
-
-    ptr = plecs_parse_fluff(ptr);
-
-    char ch = ptr[0];
-
-    if (!ch) {
-        goto done;
-    } else if (ch == '{') {
-        ptr = plecs_parse_fluff(ptr + 1);
-        goto scope_open;
-    } else if (ch == '}') {
-        goto scope_close;
-    } else if (ch == '-') {
-        ptr = plecs_parse_fluff(ptr + 1);
-        state->assign_to = ecs_get_scope(world);
-        state->scope_assign_stmt = true;
-        goto assign_stmt;
-    } else if (ch == '@') {
-        ptr = plecs_parse_annotation(name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto term_expr;
-    } else if (!ecs_os_strncmp(ptr, TOK_USING " ", 5)) {
-        ptr = plecs_parse_using_stmt(world, name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto done;
-    } else if (!ecs_os_strncmp(ptr, TOK_MODULE " ", 6)) {
-        ptr = plecs_parse_module_stmt(world, name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto done;
-    } else if (!ecs_os_strncmp(ptr, TOK_WITH " ", 5)) {
-        ptr = plecs_parse_with_stmt(name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto term_expr;
-    } else if (!ecs_os_strncmp(ptr, TOK_CONST " ", 6)) {
-        ptr = plecs_parse_const_stmt(world, name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto assign_expr;
-    } else if (!ecs_os_strncmp(ptr, TOK_ASSEMBLY " ", 9)) {
-        ptr = plecs_parse_assembly_stmt(name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto decl_stmt;
-    } else if (!ecs_os_strncmp(ptr, TOK_PROP " ", 5)) {
-        ptr = plecs_parse_prop_stmt(world, name, expr, ptr, state);
-        if (!ptr) goto error;
-        goto assign_expr;
-    } else {
-        goto term_expr;
-    }
-
-term_expr:
-    if (!ptr[0]) {
-        goto done;
-    }
-
-    if (ptr[0] == '$' && !isspace(ptr[1])) {
-        if (state->with_stmt) {
-            ptr = plecs_parse_assign_with_var(name, expr, ptr, state);
-            if (!ptr) {
-                return NULL;
-            }
-        } else if (!state->var_stmt) {
-            goto assign_var_as_component;
-        }
-    } else if (!(ptr = plecs_parse_plecs_term(world, name, ptr, ptr, state))) {
-        goto error;
-    }
-
-
-    const char *tptr = ecs_parse_ws(ptr);
-    if (flecs_isident(tptr[0])) {
-        if (state->decl_stmt) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unexpected ' ' in declaration statement");
-            goto error;
-        }
-        ptr = tptr;
-        goto decl_stmt;
-    }
-
-next_term:
-    ptr = plecs_parse_fluff(ptr);
-
-    if (ptr[0] == ':' && ptr[1] == '-') {
-        ptr = plecs_parse_fluff(ptr + 2);
-        goto assign_stmt;
-    } else if (ptr[0] == ':') {
-        ptr = plecs_parse_fluff(ptr + 1);
-        goto inherit_stmt;
-    } else if (ptr[0] == ',') {
-        ptr = plecs_parse_fluff(ptr + 1);
-        goto term_expr;
-    } else if (ptr[0] == '{' || ptr[0] == '[') {
-        if (state->assign_stmt) {
-            goto assign_expr;
-        } else if (state->with_stmt && !isspace(ptr[-1])) {
-            /* If this is a { in a with statement which directly follows a
-                * non-whitespace character, the with id has a value */
-            ptr = plecs_parse_assign_with_stmt(world, name, expr, ptr, state);
-            if (!ptr) {
-                goto error;
-            }
-
-            goto next_term;
-        } else {
-            ptr = plecs_parse_fluff(ptr + 1);
-            goto scope_open;
-        }
-    }
-
-    state->assign_stmt = false;
-    goto done;
-
-decl_stmt:
-    state->decl_stmt = true;
-    goto term_expr;
-
-inherit_stmt:
-    ptr = plecs_parse_inherit_stmt(name, expr, ptr, state);
-    if (!ptr) goto error;
-
-    /* Expect base identifier */
-    goto term_expr;
-
-assign_stmt:
-    ptr = plecs_parse_assign_stmt(world, name, expr, ptr, state);
-    if (!ptr) goto error;
-
-    ptr = plecs_parse_fluff(ptr);
-
-    /* Assignment without a preceding component */
-    if (ptr[0] == '{' || ptr[0] == '[') {
-        goto assign_expr;
-    }
-
-    /* Expect component identifiers */
-    goto term_expr;
-
-assign_expr:
-    ptr = plecs_parse_assign_expr(world, name, expr, ptr, state, NULL);
-    if (!ptr) goto error;
-
-    ptr = plecs_parse_fluff(ptr);
-    if (ptr[0] == ',') {
-        ptr ++;
-        goto term_expr;
-    } else if (ptr[0] == '{') {
-        if (state->var_stmt) {
-            ecs_expr_var_t *var = ecs_vars_lookup(&state->vars, state->var_name);
-            if (var && var->value.type == ecs_id(ecs_entity_t)) {
-                ecs_assert(var->value.ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-                /* The code contained an entity{...} variable assignment, use
-                 * the assigned entity id as type for parsing the expression */
-                state->last_assign_id = *(ecs_entity_t*)var->value.ptr;
-                ptr = plecs_parse_assign_expr(world, name, expr, ptr, state, var);
-                goto done;
-            }
-        }
-        ecs_parser_error(name, expr, (ptr - expr), 
-            "unexpected '{' after assignment");
-        goto error;
-    }
-
-    state->assign_stmt = false;
-    state->assign_to = 0;
-    goto done;
-
-assign_var_as_component: {
-    ptr = plecs_parse_var_as_component(world, name, expr, ptr, state);
-    if (!ptr) {
-        goto error;
-    }
-    state->assign_stmt = false;
-    state->assign_to = 0;
-    goto done;
-}
-
-scope_open:
-    ptr = plecs_parse_scope_open(world, name, expr, ptr, state);
-    if (!ptr) goto error;
-    goto done;
-
-scope_close:
-    ptr = plecs_parse_scope_close(world, name, expr, ptr, state);
-    if (!ptr) goto error;
-    goto done;
-
-done:
-    return ptr;
-error:
-    return NULL;
-}
-
-static
-int flecs_plecs_parse(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr,
-    ecs_vars_t *vars,
-    ecs_entity_t script,
-    ecs_entity_t instance)
-{
-    const char *ptr = expr;
-    ecs_term_t term = {0};
-    plecs_state_t state = {0};
-
-    if (!expr) {
-        return 0;
-    }
-
-    state.scope[0] = 0;
-    ecs_entity_t prev_scope = ecs_set_scope(world, 0);
-    ecs_entity_t prev_with = ecs_set_with(world, 0);
-
-    if (ECS_IS_PAIR(prev_with) && ECS_PAIR_FIRST(prev_with) == EcsChildOf) {
-        ecs_set_scope(world, ECS_PAIR_SECOND(prev_with));
-        state.scope[0] = ecs_pair_second(world, prev_with);
-    } else {
-        state.global_with = prev_with;
-    }
-
-    ecs_vars_init(world, &state.vars);
-
-    if (script) {
-        const EcsScript *s = ecs_get(world, script, EcsScript);
-        if (!s) {
-            ecs_err("%s: provided script entity is not a script", name);
-            goto error;
-        }
-        if (s && ecs_has(world, script, EcsStruct)) {
-            state.assembly = script;
-            state.assembly_instance = true;
-
-            if (s->using_.count) {
-                ecs_os_memcpy_n(state.using, s->using_.array, 
-                    ecs_entity_t, s->using_.count);
-                state.using_frame = s->using_.count;
-                state.using_frames[0] = s->using_.count;
-            }
-
-            if (instance) {
-                ecs_set_scope(world, instance);
-            }
-        }
-    }
-
-    if (vars) {
-        state.vars.root.parent = vars->cur;
-    }
-
-    do {
-        expr = ptr = plecs_parse_stmt(world, name, expr, ptr, &state);
-        if (!ptr) {
-            goto error;
-        }
-
-        if (!ptr[0]) {
-            break; /* End of expression */
-        }
-    } while (true);
-
-    ecs_set_scope(world, prev_scope);
-    ecs_set_with(world, prev_with);
-    plecs_clear_annotations(&state);
-
-    if (state.is_module) {
-        state.sp --;
-    }
-
-    if (state.sp != 0) {
-        ecs_parser_error(name, expr, 0, "missing end of scope");
-        goto error;
-    }
-
-    if (state.assign_stmt) {
-        ecs_parser_error(name, expr, 0, "unfinished assignment");
-        goto error;
-    }
-
-    if (state.errors) {
-        goto error;
-    }
-
-    ecs_vars_fini(&state.vars);
-
-    return 0;
-error:
-    plecs_free_all_with_frames(world, &state);
-    ecs_vars_fini(&state.vars);
-    ecs_set_scope(world, state.scope[0]);
-    ecs_set_with(world, prev_with);
-    ecs_term_fini(&term);
-    return -1;
-}
-
-int ecs_plecs_from_str(
-    ecs_world_t *world,
-    const char *name,
-    const char *expr)
-{
-    return flecs_plecs_parse(world, name, expr, NULL, 0, 0);
-}
-
-int ecs_plecs_from_file(
-    ecs_world_t *world,
-    const char *filename) 
-{
-    char *script = flecs_load_from_file(filename);
-    if (!script) {
-        return -1;
-    }
-
-    int result = ecs_plecs_from_str(world, filename, script);
-    ecs_os_free(script);
-    return result;
-}
-
-static
-ecs_id_t flecs_script_tag(
-    ecs_entity_t script,
-    ecs_entity_t instance)
-{
-    if (!instance) {
-        return ecs_pair_t(EcsScript, script);
-    } else {
-        return ecs_pair(EcsChildOf, instance);
-    }
-}
-
-void ecs_script_clear(
-    ecs_world_t *world,
-    ecs_entity_t script,
-    ecs_entity_t instance)
-{
-    ecs_delete_with(world, flecs_script_tag(script, instance));
-}
-
-int ecs_script_update(
-    ecs_world_t *world,
-    ecs_entity_t e,
-    ecs_entity_t instance,
-    const char *script,
-    ecs_vars_t *vars)
-{
-    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(script != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    int result = 0;
-    bool is_defer = ecs_is_deferred(world);
-    ecs_suspend_readonly_state_t srs;
-    ecs_world_t *real_world = NULL;
-    if (is_defer) {
-        ecs_assert(ecs_poly_is(world, ecs_world_t), ECS_INTERNAL_ERROR, NULL);
-        real_world = flecs_suspend_readonly(world, &srs);
-        ecs_assert(real_world != NULL, ECS_INTERNAL_ERROR, NULL);
-    }
-
-    ecs_script_clear(world, e, instance);
-
-    EcsScript *s = ecs_ensure(world, e, EcsScript);
-    if (!s->script || ecs_os_strcmp(s->script, script)) {
-        s->script = ecs_os_strdup(script);
-        ecs_modified(world, e, EcsScript);
-    }
-
-    ecs_entity_t prev = ecs_set_with(world, flecs_script_tag(e, instance));
-    if (flecs_plecs_parse(world, ecs_get_name(world, e), script, vars, e, instance)) {
-        ecs_delete_with(world, ecs_pair_t(EcsScript, e));
-        result = -1;
-    }
-    ecs_set_with(world, prev);
-
-    if (is_defer) {
-        flecs_resume_readonly(real_world, &srs);
-    }
-
-    return result;
-}
-
-ecs_entity_t ecs_script_init(
-    ecs_world_t *world,
-    const ecs_script_desc_t *desc)
-{
-    const char *script = NULL;
-    ecs_entity_t e = desc->entity;
-    
-    ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_check(desc != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    if (!e) {
-        if (desc->filename) {
-            e = ecs_new_from_path_w_sep(world, 0, desc->filename, "/", NULL);
-        } else {
-            e = ecs_new_id(world);
-        }
-    }
-
-    script = desc->str;
-    if (!script && desc->filename) {
-        script = flecs_load_from_file(desc->filename);
-        if (!script) {
-            goto error;
-        }
-    }
-
-    if (ecs_script_update(world, e, 0, script, NULL)) {
-        goto error;
-    }
-
-    if (script != desc->str) {
-        /* Safe cast, only happens when script is loaded from file */
-        ecs_os_free(ECS_CONST_CAST(char*, script));
-    }
-
-    return e;
-error:
-    if (script != desc->str) {
-        /* Safe cast, only happens when script is loaded from file */
-        ecs_os_free(ECS_CONST_CAST(char*, script));
-    }
-    if (!desc->entity) {
-        ecs_delete(world, e);
-    }
-    return 0;
-}
-
-void FlecsScriptImport(
-    ecs_world_t *world)
-{
-    ECS_MODULE(world, FlecsScript);
-    ECS_IMPORT(world, FlecsMeta);
-#ifdef FLECS_DOC
-    ECS_IMPORT(world, FlecsDoc);
-    ecs_doc_set_brief(world, ecs_id(FlecsScript), 
-        "Module with components for managing Flecs scripts");
-#endif
-
-    ecs_set_name_prefix(world, "Ecs");
-    ECS_COMPONENT_DEFINE(world, EcsScript);
-
-    ecs_set_hooks(world, EcsScript, {
-        .ctor = ecs_default_ctor,
-        .move = ecs_move(EcsScript),
-        .dtor = ecs_dtor(EcsScript)
-    });
-
-    ecs_add_id(world, ecs_id(EcsScript), EcsTag);
-    ecs_add_id(world, ecs_id(EcsScript), EcsPrivate);
-
-    ecs_struct(world, {
-        .entity = ecs_id(EcsScript),
-        .members = {
-            { .name = "using", .type = ecs_vector(world, { 
-                    .entity = ecs_entity(world, { .name = "UsingVector" }),
-                    .type = ecs_id(ecs_entity_t)
-                }),
-                .count = 0
-            },
-            { .name = "script", .type = ecs_id(ecs_string_t), .count = 0 }
-        }
-    });
-}
-
-#endif
diff --git a/src/addons/rest.c b/src/addons/rest.c
index bdd470415..fc4332ed0 100644
--- a/src/addons/rest.c
+++ b/src/addons/rest.c
@@ -63,7 +63,7 @@ static ecs_os_api_log_t rest_prev_log;
 static 
 void flecs_rest_capture_log(
     int32_t level, 
-    const char *file, 
+    const char *file,
     int32_t line, 
     const char *msg)
 {
@@ -341,7 +341,7 @@ bool flecs_rest_script(
     (void)world;
     (void)req;
     (void)reply;
-#ifdef FLECS_PLECS
+#ifdef FLECS_SCRIPT
     const char *data = ecs_http_get_param(req, "data");
     if (!data) {
         flecs_reply_error(reply, "missing data parameter");
@@ -354,13 +354,17 @@ bool flecs_rest_script(
 
     ecs_entity_t script = ecs_script(world, {
         .entity = ecs_entity(world, { .name = "scripts.main" }),
-        .str = data
+        .code = data
     });
 
     if (!script) {
         char *err = flecs_rest_get_captured_log();
-        char *escaped_err = ecs_astresc('"', err);
-        flecs_reply_error(reply, escaped_err);
+        char *escaped_err = flecs_astresc('"', err);
+        if (escaped_err) {
+            flecs_reply_error(reply, escaped_err);
+        } else {
+            flecs_reply_error(reply, "error parsing script");
+        }
         reply->code = 400; /* bad request */
         ecs_os_free(escaped_err);
         ecs_os_free(err);
@@ -381,7 +385,7 @@ void flecs_rest_reply_set_captured_log(
 {
     char *err = flecs_rest_get_captured_log();
     if (err) {
-        char *escaped_err = ecs_astresc('"', err);
+        char *escaped_err = flecs_astresc('"', err);
         flecs_reply_error(reply, escaped_err);
         ecs_os_free(escaped_err);
         ecs_os_free(err);
@@ -392,10 +396,9 @@ void flecs_rest_reply_set_captured_log(
 
 static
 void flecs_rest_iter_to_reply(
-    ecs_world_t *world,
     const ecs_http_request_t* req,
     ecs_http_reply_t *reply,
-    ecs_poly_t *query,
+    flecs_poly_t *query,
     ecs_iter_t *it)
 {
     ecs_iter_to_json_desc_t desc = {0};
@@ -416,7 +419,7 @@ void flecs_rest_iter_to_reply(
     }
 
     ecs_iter_t pit = ecs_page_iter(it, offset, limit);
-    if (ecs_iter_to_json_buf(world, &pit, &reply->body, &desc)) {
+    if (ecs_iter_to_json_buf(&pit, &reply->body, &desc)) {
         flecs_rest_reply_set_captured_log(reply);
     }
 
@@ -430,19 +433,19 @@ bool flecs_rest_reply_existing_query(
     ecs_http_reply_t *reply,
     const char *name)
 {
-    ecs_entity_t q = ecs_lookup(world, name);
-    if (!q) {
+    ecs_entity_t qe = ecs_lookup(world, name);
+    if (!qe) {
         flecs_reply_error(reply, "unresolved identifier '%s'", name);
         reply->code = 404;
         return true;
     }
 
-    ecs_poly_t *poly = NULL;
-    const EcsPoly *poly_comp = ecs_get_pair(world, q, EcsPoly, EcsQuery);
+    ecs_query_t *q = NULL;
+    const EcsPoly *poly_comp = ecs_get_pair(world, qe, EcsPoly, EcsQuery);
     if (!poly_comp) {
-        poly_comp = ecs_get_pair(world, q, EcsPoly, EcsObserver);
+        poly_comp = ecs_get_pair(world, qe, EcsPoly, EcsObserver);
         if (poly_comp) {
-            poly = &((ecs_observer_t*)poly_comp->poly)->filter;
+            q = ((ecs_observer_t*)poly_comp->poly)->query;
         } else {
             flecs_reply_error(reply, 
                 "resolved identifier '%s' is not a query", name);
@@ -450,38 +453,38 @@ bool flecs_rest_reply_existing_query(
             return true;
         }
     } else {
-        poly = poly_comp->poly;
+        q = poly_comp->poly;
     }
 
-    if (!poly) {
+    if (!q) {
         flecs_reply_error(reply, "query '%s' is not initialized", name);
         reply->code = 400;
         return true;
     }
 
-    ecs_iter_t it;
-    ecs_iter_poly(world, poly, &it, NULL);
+    ecs_iter_t it = ecs_query_iter(world, q);
 
-    ecs_dbg_2("rest: request query '%s'", q);
+    ecs_dbg_2("rest: request query '%s'", name);
     bool prev_color = ecs_log_enable_colors(false);
     rest_prev_log = ecs_os_api.log_;
     ecs_os_api.log_ = flecs_rest_capture_log;
 
     const char *vars = ecs_http_get_param(req, "vars");
     if (vars) {
-        if (!ecs_poly_is(poly, ecs_rule_t)) {
-            flecs_reply_error(reply, 
-                "variables are only supported for rule queries");
-            reply->code = 400;
-            return true;
-        }
-        if (ecs_rule_parse_vars(poly, &it, vars) == NULL) {
+    #ifdef FLECS_SCRIPT
+        if (ecs_query_args_parse(q, &it, vars) == NULL) {
             flecs_rest_reply_set_captured_log(reply);
             return true;
         }
+    #else
+        flecs_reply_error(reply,
+            "cannot parse query arg expression: script addon required");
+        reply->code = 400;
+        return true;
+    #endif
     }
 
-    flecs_rest_iter_to_reply(world, req, reply, poly, &it);
+    flecs_rest_iter_to_reply(req, reply, q, &it);
 
     ecs_os_api.log_ = rest_prev_log;
     ecs_log_enable_colors(prev_color);    
@@ -500,8 +503,8 @@ bool flecs_rest_reply_query(
         return flecs_rest_reply_existing_query(world, req, reply, q_name);
     }
 
-    const char *q = ecs_http_get_param(req, "q");
-    if (!q) {
+    const char *expr = ecs_http_get_param(req, "q");
+    if (!expr) {
         ecs_strbuf_appendlit(&reply->body, "Missing parameter 'q'");
         reply->code = 400; /* bad request */
         return true;
@@ -510,24 +513,22 @@ bool flecs_rest_reply_query(
     bool try = false;
     flecs_rest_bool_param(req, "try", &try);
 
-    ecs_dbg_2("rest: request query '%s'", q);
+    ecs_dbg_2("rest: request query '%s'", expr);
     bool prev_color = ecs_log_enable_colors(false);
     rest_prev_log = ecs_os_api.log_;
     ecs_os_api.log_ = flecs_rest_capture_log;
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
-        .expr = q
-    });
-    if (!r) {
+    ecs_query_t *q = ecs_query(world, { .expr = expr });
+    if (!q) {
         flecs_rest_reply_set_captured_log(reply);
         if (try) {
             /* If client is trying queries, don't spam console with errors */
             reply->code = 200;
         }
     } else {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        flecs_rest_iter_to_reply(world, req, reply, r, &it);
-        ecs_rule_fini(r);
+        ecs_iter_t it = ecs_query_iter(world, q);
+        flecs_rest_iter_to_reply(req, reply, q, &it);
+        ecs_query_fini(q);
     }
 
     ecs_os_api.log_ = rest_prev_log;
@@ -746,8 +747,8 @@ void flecs_pipeline_stats_to_json(
             ecs_strbuf_list_appendlit(reply, "\"multi_threaded\":");
             ecs_strbuf_appendbool(reply, sync_stats->multi_threaded);
 
-            ecs_strbuf_list_appendlit(reply, "\"no_readonly\":");
-            ecs_strbuf_appendbool(reply, sync_stats->no_readonly);
+            ecs_strbuf_list_appendlit(reply, "\"immediate\":");
+            ecs_strbuf_appendbool(reply, sync_stats->immediate);
 
             ECS_GAUGE_APPEND_T(reply, sync_stats, 
                 time_spent, stats->stats.t, "");
@@ -774,7 +775,7 @@ bool flecs_rest_reply_stats(
 
     ecs_entity_t period = EcsPeriod1s;
     if (period_str) {
-        char *period_name = ecs_asprintf("Period%s", period_str);
+        char *period_name = flecs_asprintf("Period%s", period_str);
         period = ecs_lookup_child(world, ecs_id(FlecsMonitor), period_name);
         ecs_os_free(period_name);
         if (!period) {
@@ -1320,7 +1321,7 @@ void flecs_on_set_rest(ecs_iter_t *it) {
 
 static
 void DequeueRest(ecs_iter_t *it) {
-    EcsRest *rest = ecs_field(it, EcsRest, 1);
+    EcsRest *rest = ecs_field(it, EcsRest, 0);
 
     if (it->delta_system_time > (ecs_ftime_t)1.0) {
         ecs_warn(
@@ -1342,15 +1343,12 @@ static
 void DisableRest(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
 
-    ecs_iter_t rit = ecs_term_iter(world, &(ecs_term_t){
-        .id = ecs_id(EcsRest),
-        .src.flags = EcsSelf
-    });
+    ecs_iter_t rit = ecs_each_id(world, ecs_id(EcsRest));
 
     if (it->event == EcsOnAdd) {
         /* REST module was disabled */
-        while (ecs_term_next(&rit)) {
-            EcsRest *rest = ecs_field(&rit, EcsRest, 1);
+        while (ecs_each_next(&rit)) {
+            EcsRest *rest = ecs_field(&rit, EcsRest, 0);
             int i;
             for (i = 0; i < rit.count; i ++) {
                 ecs_rest_ctx_t *ctx = rest[i].impl;
@@ -1359,8 +1357,8 @@ void DisableRest(ecs_iter_t *it) {
         }
     } else if (it->event == EcsOnRemove) {
         /* REST module was enabled */
-        while (ecs_term_next(&rit)) {
-            EcsRest *rest = ecs_field(&rit, EcsRest, 1);
+        while (ecs_each_next(&rit)) {
+            EcsRest *rest = ecs_field(&rit, EcsRest, 0);
             int i;
             for (i = 0; i < rit.count; i ++) {
                 ecs_rest_ctx_t *ctx = rest[i].impl;
@@ -1376,7 +1374,7 @@ void FlecsRestImport(
     ECS_MODULE(world, FlecsRest);
 
     ECS_IMPORT(world, FlecsPipeline);
-#ifdef FLECS_PLECS
+#ifdef FLECS_SCRIPT
     ECS_IMPORT(world, FlecsScript);
 #endif
 #ifdef FLECS_DOC
@@ -1390,22 +1388,24 @@ void FlecsRestImport(
     flecs_bootstrap_component(world, EcsRest);
 
     ecs_set_hooks(world, EcsRest, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .move = ecs_move(EcsRest),
         .copy = ecs_copy(EcsRest),
         .dtor = ecs_dtor(EcsRest),
         .on_set = flecs_on_set_rest
     });
 
-    ECS_SYSTEM(world, DequeueRest, EcsPostFrame, EcsRest);
-
     ecs_system(world, {
-        .entity = ecs_id(DequeueRest),
-        .no_readonly = true
+        .entity = ecs_entity(world, {.name = "DequeueRest", .add = ecs_ids( ecs_dependson(EcsPostFrame))}),
+        .query.terms = {
+            { .id = ecs_id(EcsRest) },
+        },
+        .callback = DequeueRest,
+        .immediate = true
     });
 
     ecs_observer(world, {
-        .filter = { 
+        .query = { 
             .terms = {{ .id = EcsDisabled, .src.id = ecs_id(FlecsRest) }}
         },
         .events = {EcsOnAdd, EcsOnRemove},
diff --git a/src/addons/rules/api.c b/src/addons/rules/api.c
deleted file mode 100644
index 35e493586..000000000
--- a/src/addons/rules/api.c
+++ /dev/null
@@ -1,422 +0,0 @@
- /**
- * @file addons/rules/api.c
- * @brief User facing API for rules.
- */
-
-#include "rules.h"
-#include <ctype.h>
-
-#ifdef FLECS_RULES
-
-static ecs_mixins_t ecs_rule_t_mixins = {
-    .type_name = "ecs_rule_t",
-    .elems = {
-        [EcsMixinWorld] = offsetof(ecs_rule_t, filter.world),
-        [EcsMixinEntity] = offsetof(ecs_rule_t, filter.entity),
-        [EcsMixinIterable] = offsetof(ecs_rule_t, iterable),
-        [EcsMixinDtor] = offsetof(ecs_rule_t, dtor)
-    }
-};
-
-const char* flecs_rule_op_str(
-    uint16_t kind)
-{
-    switch(kind) {
-    case EcsRuleAnd:           return "and     ";
-    case EcsRuleAndId:         return "andid   ";
-    case EcsRuleAndAny:        return "andany  ";
-    case EcsRuleTriv:          return "triv    ";
-    case EcsRuleTrivData:      return "trivpop ";
-    case EcsRuleTrivWildcard:  return "trivwc  ";
-    case EcsRuleSelectAny:     return "any     ";
-    case EcsRuleUp:            return "up      ";
-    case EcsRuleUpId:          return "upid    ";
-    case EcsRuleSelfUp:        return "selfup  ";
-    case EcsRuleSelfUpId:      return "selfupid";
-    case EcsRuleWith:          return "with    ";
-    case EcsRuleTrav:          return "trav    ";
-    case EcsRuleIds:           return "ids     ";
-    case EcsRuleIdsRight:      return "idsr    ";
-    case EcsRuleIdsLeft:       return "idsl    ";
-    case EcsRuleEach:          return "each    ";
-    case EcsRuleStore:         return "store   ";
-    case EcsRuleReset:         return "reset   ";
-    case EcsRuleOr:            return "or      ";
-    case EcsRuleOptional:      return "option  ";
-    case EcsRuleIf:            return "if      ";
-    case EcsRuleEnd:           return "end     ";
-    case EcsRuleNot:           return "not     ";
-    case EcsRulePredEq:        return "eq      ";
-    case EcsRulePredNeq:       return "neq     ";
-    case EcsRulePredEqName:    return "eq_nm   ";
-    case EcsRulePredNeqName:   return "neq_nm  ";
-    case EcsRulePredEqMatch:   return "eq_m    ";
-    case EcsRulePredNeqMatch:  return "neq_m   ";
-    case EcsRuleLookup:        return "lookup  ";
-    case EcsRuleSetVars:       return "setvars ";
-    case EcsRuleSetThis:       return "setthis ";
-    case EcsRuleSetFixed:      return "setfix  ";
-    case EcsRuleSetIds:        return "setids  ";
-    case EcsRuleSetId:         return "setid   ";
-    case EcsRuleContain:       return "contain ";
-    case EcsRulePairEq:        return "pair_eq ";
-    case EcsRulePopulate:      return "pop     ";
-    case EcsRulePopulateSelf:  return "popself ";
-    case EcsRuleYield:         return "yield   ";
-    case EcsRuleNothing:       return "nothing ";
-    default:                   return "!invalid";
-    }
-}
-
-/* Implementation for iterable mixin */
-static
-void flecs_rule_iter_mixin_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter)
-{
-    ecs_poly_assert(poly, ecs_rule_t);
-
-    if (filter) {
-        iter[1] = ecs_rule_iter(world, ECS_CONST_CAST(ecs_rule_t*, poly));
-        iter[0] = ecs_term_chain_iter(&iter[1], filter);
-    } else {
-        iter[0] = ecs_rule_iter(world, ECS_CONST_CAST(ecs_rule_t*, poly));
-    }
-}
-
-static
-void flecs_rule_fini(
-    ecs_rule_t *rule)
-{
-    if (rule->vars != &rule->vars_cache.var) {
-        ecs_os_free(rule->vars);
-    }
-
-    ecs_os_free(rule->ops);
-    ecs_os_free(rule->src_vars);
-    flecs_name_index_fini(&rule->tvar_index);
-    flecs_name_index_fini(&rule->evar_index);
-    ecs_filter_fini(&rule->filter);
-
-    ecs_poly_free(rule, ecs_rule_t);
-}
-
-void ecs_rule_fini(
-    ecs_rule_t *rule)
-{
-    if (rule->filter.entity) {
-        /* If filter is associated with entity, use poly dtor path */
-        ecs_delete(rule->filter.world, rule->filter.entity);
-    } else {
-        flecs_rule_fini(rule);
-    }
-}
-
-ecs_rule_t* ecs_rule_init(
-    ecs_world_t *world, 
-    const ecs_filter_desc_t *const_desc)
-{
-    ecs_rule_t *result = ecs_poly_new(ecs_rule_t);
-    ecs_stage_t *stage = flecs_stage_from_world(&world);
-
-    /* Initialize the query */
-    ecs_filter_desc_t desc = *const_desc;
-    desc.storage = &result->filter; /* Use storage of rule */
-    result->filter = ECS_FILTER_INIT;
-    if (ecs_filter_init(world, &desc) == NULL) {
-        goto error;
-    }
-
-    result->iterable.init = flecs_rule_iter_mixin_init;
-
-    /* Compile filter to operations */
-    if (flecs_rule_compile(world, stage, result)) {
-        goto error;
-    }
-
-    ecs_entity_t entity = const_desc->entity;
-    result->dtor = (ecs_poly_dtor_t)flecs_rule_fini;
-
-    if (entity) {
-        EcsPoly *poly = ecs_poly_bind(world, entity, ecs_rule_t);
-        poly->poly = result;
-        ecs_poly_modified(world, entity, ecs_rule_t);
-    }
-
-    return result;
-error:
-    ecs_rule_fini(result);
-    return NULL;
-}
-
-static
-int32_t flecs_rule_op_ref_str(
-    const ecs_rule_t *rule,
-    ecs_rule_ref_t *ref,
-    ecs_flags16_t flags,
-    ecs_strbuf_t *buf)
-{
-    int32_t color_chars = 0;
-    if (flags & EcsRuleIsVar) {
-        ecs_assert(ref->var < rule->var_count, ECS_INTERNAL_ERROR, NULL);
-        ecs_rule_var_t *var = &rule->vars[ref->var];
-        ecs_strbuf_appendlit(buf, "#[green]$#[reset]");
-        if (var->kind == EcsVarTable) {
-            ecs_strbuf_appendch(buf, '[');
-        }
-        ecs_strbuf_appendlit(buf, "#[green]");
-        if (var->name) {
-            ecs_strbuf_appendstr(buf, var->name);
-        } else {
-            if (var->id) {
-#ifdef FLECS_DEBUG
-                if (var->label) {
-                    ecs_strbuf_appendstr(buf, var->label);
-                    ecs_strbuf_appendch(buf, '\'');
-                }
-#endif
-                ecs_strbuf_append(buf, "%d", var->id);
-            } else {
-                ecs_strbuf_appendlit(buf, "this");
-            }
-        }
-        ecs_strbuf_appendlit(buf, "#[reset]");
-        if (var->kind == EcsVarTable) {
-            ecs_strbuf_appendch(buf, ']');
-        }
-        color_chars = ecs_os_strlen("#[green]#[reset]#[green]#[reset]");
-    } else if (flags & EcsRuleIsEntity) {
-        char *path = ecs_get_fullpath(rule->filter.world, ref->entity);
-        ecs_strbuf_appendlit(buf, "#[blue]");
-        ecs_strbuf_appendstr(buf, path);
-        ecs_strbuf_appendlit(buf, "#[reset]");
-        ecs_os_free(path);
-        color_chars = ecs_os_strlen("#[blue]#[reset]");
-    }
-    return color_chars;
-}
-
-char* ecs_rule_str_w_profile(
-    const ecs_rule_t *rule,
-    const ecs_iter_t *it)
-{
-    ecs_poly_assert(rule, ecs_rule_t);
-
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
-    ecs_rule_op_t *ops = rule->ops;
-    int32_t i, count = rule->op_count, indent = 0;
-
-    for (i = 0; i < count; i ++) {
-        ecs_rule_op_t *op = &ops[i];
-        ecs_flags16_t flags = op->flags;
-        ecs_flags16_t src_flags = flecs_rule_ref_flags(flags, EcsRuleSrc);
-        ecs_flags16_t first_flags = flecs_rule_ref_flags(flags, EcsRuleFirst);
-        ecs_flags16_t second_flags = flecs_rule_ref_flags(flags, EcsRuleSecond);
-
-        if (it) {
-#ifdef FLECS_DEBUG
-            const ecs_rule_iter_t *rit = &it->priv.iter.rule;
-            ecs_strbuf_append(&buf, 
-                "#[green]%4d -> #[red]%4d <- #[grey]  |   ",
-                rit->profile[i].count[0],
-                rit->profile[i].count[1]);
-#endif
-        }
-
-        ecs_strbuf_append(&buf, 
-            "#[normal]%2d. [#[grey]%2d#[reset], #[green]%2d#[reset]]  ", 
-                i, op->prev, op->next);
-        int32_t hidden_chars, start = ecs_strbuf_written(&buf);
-        if (op->kind == EcsRuleEnd) {
-            indent --;
-        }
-
-        ecs_strbuf_append(&buf, "%*s", indent, "");
-        ecs_strbuf_appendstr(&buf, flecs_rule_op_str(op->kind));
-        ecs_strbuf_appendstr(&buf, " ");
-
-        int32_t written = ecs_strbuf_written(&buf);
-        for (int32_t j = 0; j < (12 - (written - start)); j ++) {
-            ecs_strbuf_appendch(&buf, ' ');
-        }
-    
-        hidden_chars = flecs_rule_op_ref_str(rule, &op->src, src_flags, &buf);
-
-        if (op->kind == EcsRuleNot || 
-            op->kind == EcsRuleOr || 
-            op->kind == EcsRuleOptional || 
-            op->kind == EcsRuleIf) 
-        {
-            indent ++;
-        }
-
-        if (!first_flags && !second_flags) {
-            ecs_strbuf_appendstr(&buf, "\n");
-            continue;
-        }
-
-        written = ecs_strbuf_written(&buf) - hidden_chars;
-        for (int32_t j = 0; j < (30 - (written - start)); j ++) {
-            ecs_strbuf_appendch(&buf, ' ');
-        }
-
-        if (!first_flags && !second_flags) {
-            ecs_strbuf_appendstr(&buf, "\n");
-            continue;
-        }
-
-        ecs_strbuf_appendstr(&buf, "(");
-        flecs_rule_op_ref_str(rule, &op->first, first_flags, &buf);
-
-        if (second_flags) {
-            ecs_strbuf_appendstr(&buf, ", ");
-            flecs_rule_op_ref_str(rule, &op->second, second_flags, &buf);
-        } else {
-            switch (op->kind) {
-            case EcsRulePredEqName:
-            case EcsRulePredNeqName:
-            case EcsRulePredEqMatch:
-            case EcsRulePredNeqMatch: {
-                int8_t term_index = op->term_index;
-                ecs_strbuf_appendstr(&buf, ", #[yellow]\"");
-                ecs_strbuf_appendstr(&buf, rule->filter.terms[term_index].second.name);
-                ecs_strbuf_appendstr(&buf, "\"#[reset]");
-                break;
-            }
-            case EcsRuleLookup: {
-                ecs_var_id_t src_id = op->src.var;
-                ecs_strbuf_appendstr(&buf, ", #[yellow]\"");
-                ecs_strbuf_appendstr(&buf, rule->vars[src_id].lookup);
-                ecs_strbuf_appendstr(&buf, "\"#[reset]");
-                break;
-            }
-            default:
-                break;
-            }
-        }
-
-        ecs_strbuf_appendch(&buf, ')');
-
-        ecs_strbuf_appendch(&buf, '\n');
-    }
-
-#ifdef FLECS_LOG    
-    char *str = ecs_strbuf_get(&buf);
-    flecs_colorize_buf(str, ecs_os_api.flags_ & EcsOsApiLogWithColors, &buf);
-    ecs_os_free(str);
-#endif
-    return ecs_strbuf_get(&buf);
-}
-
-char* ecs_rule_str(
-    const ecs_rule_t *rule)
-{
-    return ecs_rule_str_w_profile(rule, NULL);
-}
-
-const ecs_filter_t* ecs_rule_get_filter(
-    const ecs_rule_t *rule)
-{
-    return &rule->filter;
-}
-
-const char* ecs_rule_parse_vars(
-    ecs_rule_t *rule,
-    ecs_iter_t *it,
-    const char *expr)
-{
-    ecs_poly_assert(rule, ecs_rule_t);
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(expr != NULL, ECS_INVALID_PARAMETER, NULL)
-    char token[ECS_MAX_TOKEN_SIZE];
-    const char *ptr = expr;
-    bool paren = false;
-
-    const char *name = NULL;
-    if (rule->filter.entity) {
-        name = ecs_get_name(rule->filter.world, rule->filter.entity);
-    }
-
-    ptr = ecs_parse_ws_eol(ptr);
-    if (!ptr[0]) {
-        return ptr;
-    }
-
-    if (ptr[0] == '(') {
-        paren = true;
-        ptr = ecs_parse_ws_eol(ptr + 1);
-        if (ptr[0] == ')') {
-            return ptr + 1;
-        }
-    }
-
-    do {
-        ptr = ecs_parse_ws_eol(ptr);
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            return NULL;
-        }
-
-        int var = ecs_rule_find_var(rule, token);
-        if (var == -1) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unknown variable '%s'", token);
-            return NULL;
-        }
-
-        ptr = ecs_parse_ws_eol(ptr);
-        if (ptr[0] != ':') {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "missing ':'");
-            return NULL;
-        }
-
-        ptr = ecs_parse_ws_eol(ptr + 1);
-        ptr = ecs_parse_identifier(name, expr, ptr, token);
-        if (!ptr) {
-            return NULL;
-        }
-
-        ecs_entity_t val = ecs_lookup(rule->filter.world, token);
-        if (!val) {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "unresolved entity '%s'", token);
-            return NULL;
-        }
-
-        ecs_iter_set_var(it, var, val);
-
-        ptr = ecs_parse_ws_eol(ptr);
-        if (ptr[0] == ')') {
-            if (!paren) {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "unexpected closing parenthesis");
-                return NULL;
-            }
-
-            ptr ++;
-            break;
-        } else if (ptr[0] == ',') {
-            ptr ++;
-        } else if (!ptr[0]) {
-            if (paren) {
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "missing closing parenthesis");
-                return NULL;
-            }
-            break;
-        } else {
-            ecs_parser_error(name, expr, (ptr - expr), 
-                "expected , or end of string");
-            return NULL;
-        }
-    } while (true);
-
-    return ptr;
-error:
-    return NULL;
-}
-
-#endif
diff --git a/src/addons/rules/compile.c b/src/addons/rules/compile.c
deleted file mode 100644
index 99d049caa..000000000
--- a/src/addons/rules/compile.c
+++ /dev/null
@@ -1,2207 +0,0 @@
-/**
- * @file addons/rules/compile.c
- * @brief Compile rule program from filter.
- */
-
-#include "rules.h"
-
-#ifdef FLECS_RULES
-
-#define FlecsRuleOrMarker ((int16_t)-2) /* Marks instruction in OR chain */
-
-ecs_rule_lbl_t flecs_itolbl(int64_t val) {
-    return flecs_ito(int16_t, val);
-}
-
-static
-ecs_var_id_t flecs_itovar(int64_t val) {
-    return flecs_ito(uint8_t, val);
-}
-
-static
-ecs_var_id_t flecs_utovar(uint64_t val) {
-    return flecs_uto(uint8_t, val);
-}
-
-#ifdef FLECS_DEBUG
-#define flecs_set_var_label(var, lbl) (var)->label = lbl
-#else
-#define flecs_set_var_label(var, lbl)
-#endif
-
-static
-bool flecs_rule_is_builtin_pred(
-    ecs_term_t *term)
-{
-    if (term->first.flags & EcsIsEntity) {
-        ecs_entity_t id = term->first.id;
-        if (id == EcsPredEq || id == EcsPredMatch || id == EcsPredLookup) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool flecs_rule_is_written(
-    ecs_var_id_t var_id,
-    uint64_t written)
-{
-    if (var_id == EcsVarNone) {
-        return true;
-    }
-
-    ecs_assert(var_id < EcsRuleMaxVarCount, ECS_INTERNAL_ERROR, NULL);
-    return (written & (1ull << var_id)) != 0;
-}
-
-static
-void flecs_rule_write(
-    ecs_var_id_t var_id,
-    uint64_t *written)
-{
-    ecs_assert(var_id < EcsRuleMaxVarCount, ECS_INTERNAL_ERROR, NULL);
-    *written |= (1ull << var_id);
-}
-
-static
-void flecs_rule_write_ctx(
-    ecs_var_id_t var_id,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
-{
-    bool is_written = flecs_rule_is_written(var_id, ctx->written);
-    flecs_rule_write(var_id, &ctx->written);
-    if (!is_written) {
-        if (cond_write) {
-            flecs_rule_write(var_id, &ctx->cond_written);
-        }
-    }
-}
-
-ecs_flags16_t flecs_rule_ref_flags(
-    ecs_flags16_t flags,
-    ecs_flags16_t kind)
-{
-    return (flags >> kind) & (EcsRuleIsVar | EcsRuleIsEntity);
-}
-
-bool flecs_ref_is_written(
-    const ecs_rule_op_t *op,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t kind,
-    uint64_t written)
-{
-    ecs_flags16_t flags = flecs_rule_ref_flags(op->flags, kind);
-    if (flags & EcsRuleIsEntity) {
-        ecs_assert(!(flags & EcsRuleIsVar), ECS_INTERNAL_ERROR, NULL);
-        if (ref->entity) {
-            return true;
-        }
-    } else if (flags & EcsRuleIsVar) {
-        return flecs_rule_is_written(ref->var, written);
-    }
-    return false;
-}
-
-static
-bool flecs_rule_var_is_anonymous(
-    const ecs_rule_t *rule,
-    ecs_var_id_t var_id)
-{
-    ecs_rule_var_t *var = &rule->vars[var_id];
-    return var->anonymous;
-}
-
-static
-ecs_var_id_t flecs_rule_find_var_id(
-    const ecs_rule_t *rule,
-    const char *name,
-    ecs_var_kind_t kind)
-{
-    ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    /* Backwards compatibility */
-    if (!ecs_os_strcmp(name, "This")) {
-        name = "this";
-    }
-
-    if (kind == EcsVarTable) {
-        if (!ecs_os_strcmp(name, EcsThisName)) {
-            if (rule->has_table_this) {
-                return 0;
-            } else {
-                return EcsVarNone;
-            }
-        }
-
-        if (!flecs_name_index_is_init(&rule->tvar_index)) {
-            return EcsVarNone;
-        }
-
-        uint64_t index = flecs_name_index_find(
-            &rule->tvar_index, name, 0, 0);
-        if (index == 0) {
-            return EcsVarNone;
-        }
-        return flecs_utovar(index);
-    }
-
-    if (kind == EcsVarEntity) {
-        if (!flecs_name_index_is_init(&rule->evar_index)) {
-            return EcsVarNone;
-        }
-
-        uint64_t index = flecs_name_index_find(
-            &rule->evar_index, name, 0, 0);
-        if (index == 0) {
-            return EcsVarNone;
-        }
-        return flecs_utovar(index);
-    }
-
-    ecs_assert(kind == EcsVarAny, ECS_INTERNAL_ERROR, NULL);
-
-    /* If searching for any kind of variable, start with most specific */
-    ecs_var_id_t index = flecs_rule_find_var_id(rule, name, EcsVarEntity);
-    if (index != EcsVarNone) {
-        return index;
-    }
-
-    return flecs_rule_find_var_id(rule, name, EcsVarTable);
-}
-
-int32_t ecs_rule_var_count(
-    const ecs_rule_t *rule)
-{
-    return rule->var_pub_count;
-}
-
-int32_t ecs_rule_find_var(
-    const ecs_rule_t *rule,
-    const char *name)
-{
-    ecs_var_id_t var_id = flecs_rule_find_var_id(rule, name, EcsVarEntity);
-    if (var_id == EcsVarNone) {
-        if (rule->filter.flags & EcsFilterMatchThis) {
-            if (!ecs_os_strcmp(name, "This")) {
-                name = "this";
-            }
-            if (!ecs_os_strcmp(name, EcsThisName)) {
-                var_id = 0;
-            }
-        }
-        if (var_id == EcsVarNone) {
-            return -1;
-        }
-    }
-    return (int32_t)var_id;
-}
-
-const char* ecs_rule_var_name(
-    const ecs_rule_t *rule,
-    int32_t var_id)
-{
-    if (var_id) {
-        return rule->vars[var_id].name;
-    } else {
-        return EcsThisName;
-    }
-}
-
-bool ecs_rule_var_is_entity(
-    const ecs_rule_t *rule,
-    int32_t var_id)
-{
-    return rule->vars[var_id].kind == EcsVarEntity;
-}
-
-static
-const char* flecs_term_id_var_name(
-    ecs_term_id_t *term_id)
-{
-    if (!(term_id->flags & EcsIsVariable)) {
-        return NULL;
-    }
-
-    if (term_id->id == EcsThis) {
-        return EcsThisName;
-    }
-
-    return term_id->name;
-}
-
-static
-bool flecs_term_id_is_wildcard(
-    ecs_term_id_t *term_id)
-{
-    if ((term_id->flags & EcsIsVariable) && 
-        ((term_id->id == EcsWildcard) || (term_id->id == EcsAny))) 
-    {
-        return true;
-    }
-    return false;
-}
-
-static
-ecs_var_id_t flecs_rule_add_var(
-    ecs_rule_t *rule,
-    const char *name,
-    ecs_vec_t *vars,
-    ecs_var_kind_t kind)
-{
-    const char *dot = NULL;
-    if (name) {
-        dot = strchr(name, '.');
-        if (dot) {
-            kind = EcsVarEntity; /* lookup variables are always entities */
-        }
-    }
-
-    ecs_hashmap_t *var_index = NULL;
-    ecs_var_id_t var_id = EcsVarNone;
-    if (name) {
-        if (kind == EcsVarAny) {
-            var_id = flecs_rule_find_var_id(rule, name, EcsVarEntity);
-            if (var_id != EcsVarNone) {
-                return var_id;
-            }
-
-            var_id = flecs_rule_find_var_id(rule, name, EcsVarTable);
-            if (var_id != EcsVarNone) {
-                return var_id;
-            }
-
-            kind = EcsVarTable;
-        } else {
-            var_id = flecs_rule_find_var_id(rule, name, kind);
-            if (var_id != EcsVarNone) {
-                return var_id;
-            }
-        }
-
-        if (kind == EcsVarTable) {
-            var_index = &rule->tvar_index;
-        } else {
-            var_index = &rule->evar_index;
-        }
-
-        /* If we're creating an entity var, check if it has a table variant */
-        if (kind == EcsVarEntity && var_id == EcsVarNone) {
-            var_id = flecs_rule_find_var_id(rule, name, EcsVarTable);
-        }
-    }
-
-    ecs_rule_var_t *var;
-    ecs_var_id_t result;
-    if (vars) {
-        var = ecs_vec_append_t(NULL, vars, ecs_rule_var_t);
-        result = var->id = flecs_itovar(ecs_vec_count(vars));
-    } else {
-        ecs_dbg_assert(rule->var_count < rule->var_size, 
-            ECS_INTERNAL_ERROR, NULL);
-        var = &rule->vars[rule->var_count];
-        result = var->id = flecs_itovar(rule->var_count);
-        rule->var_count ++;
-    }
-
-    var->kind = flecs_ito(int8_t, kind);
-    var->name = name;
-    var->table_id = var_id;
-    var->base_id = 0;
-    var->lookup = NULL;
-    flecs_set_var_label(var, NULL);
-
-    if (name) {
-        flecs_name_index_init_if(var_index, NULL);
-        flecs_name_index_ensure(var_index, var->id, name, 0, 0);
-        var->anonymous = name[0] == '_';
-
-        /* Handle variables that require a by-name lookup, e.g. $this.wheel */
-        if (dot != NULL) {
-            ecs_assert(var->table_id == EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-            var->lookup = dot + 1;
-        }
-    }
-
-    return result;
-}
-
-static
-ecs_var_id_t flecs_rule_add_var_for_term_id(
-    ecs_rule_t *rule,
-    ecs_term_id_t *term_id,
-    ecs_vec_t *vars,
-    ecs_var_kind_t kind)
-{
-    const char *name = flecs_term_id_var_name(term_id);
-    if (!name) {
-        return EcsVarNone;
-    }
-
-    return flecs_rule_add_var(rule, name, vars, kind);
-}
-
-/* This function walks over terms to discover which variables are used in the
- * query. It needs to provide the following functionality:
- * - create table vars for all variables used as source
- * - create entity vars for all variables not used as source
- * - create entity vars for all non-$this vars
- * - create anonymous vars to store the content of wildcards
- * - create anonymous vars to store result of lookups (for $var.child_name)
- * - create anonymous vars for resolving component inheritance
- * - create array that stores the source variable for each field
- * - ensure table vars for non-$this variables are anonymous
- * - ensure variables created inside scopes are anonymous
- * - place anonymous variables after public variables in vars array
- */
-static
-int flecs_rule_discover_vars(
-    ecs_stage_t *stage,
-    ecs_rule_t *rule)
-{
-    ecs_vec_t *vars = &stage->variables; /* Buffer to reduce allocs */
-    ecs_vec_reset_t(NULL, vars, ecs_rule_var_t);
-
-    ecs_term_t *terms = rule->filter.terms;
-    int32_t a, i, anonymous_count = 0, count = rule->filter.term_count;
-    int32_t anonymous_table_count = 0, scope = 0, scoped_var_index = 0;
-    bool table_this = false, entity_before_table_this = false;
-
-    /* For This table lookups during discovery. This will be overwritten after
-     * discovery with whether the rule actually has a This table variable. */
-    rule->has_table_this = true;
-
-    for (i = 0; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-        ecs_term_id_t *first = &term->first;
-        ecs_term_id_t *second = &term->second;
-        ecs_term_id_t *src = &term->src;
-
-        if (first->id == EcsScopeOpen) {
-            /* Keep track of which variables are first used in scope, so that we
-             * can mark them as anonymous. Terms inside a scope are collapsed 
-             * into a single result, which means that outside of the scope the
-             * value of those variables is undefined. */
-            if (!scope) {
-                scoped_var_index = ecs_vec_count(vars);
-            }
-            scope ++;
-            continue;
-        } else if (first->id == EcsScopeClose) {
-            if (!--scope) {
-                /* Any new variables declared after entering a scope should be
-                 * marked as anonymous. */
-                int32_t v;
-                for (v = scoped_var_index; v < ecs_vec_count(vars); v ++) {
-                    ecs_vec_get_t(vars, ecs_rule_var_t, v)->anonymous = true;
-                }
-            }
-            continue;
-        }
-
-        ecs_var_id_t first_var_id = flecs_rule_add_var_for_term_id(
-            rule, first, vars, EcsVarEntity);
-        if (first_var_id == EcsVarNone) {
-            /* If first is not a variable, check if we need to insert anonymous
-             * variable for resolving component inheritance */
-            if (term->flags & EcsTermIdInherited) {
-                anonymous_count += 2; /* table & entity variable */
-            }
-
-            /* If first is a wildcard, insert anonymous variable */
-            if (flecs_term_id_is_wildcard(first)) {
-                anonymous_count ++;
-            }
-        }
-
-        if ((src->flags & EcsIsVariable) && (src->id != EcsThis)) {
-            const char *var_name = flecs_term_id_var_name(src);
-            if (var_name) {
-                ecs_var_id_t var_id = flecs_rule_find_var_id(
-                    rule, var_name, EcsVarEntity);
-                if (var_id == EcsVarNone || var_id == first_var_id) {
-                    var_id = flecs_rule_add_var(
-                        rule, var_name, vars, EcsVarEntity);
-                }
-
-                if (var_id != EcsVarNone) {
-                    /* Mark variable as one for which we need to create a table
-                     * variable. Don't create table variable now, so that we can
-                     * store it in the non-public part of the variable array. */
-                    ecs_rule_var_t *var = ecs_vec_get_t(
-                        vars, ecs_rule_var_t, (int32_t)var_id - 1);
-                    ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL);
-                    if (!var->lookup) {
-                        var->kind = EcsVarAny;
-                        anonymous_table_count ++;
-                    }
-
-                    if (!(term->flags & EcsTermNoData)) {
-                        /* Can't have an anonymous variable as source of a term
-                         * that returns a component. We need to return each
-                         * instance of the component, whereas anonymous 
-                         * variables are not guaranteed to be resolved to 
-                         * individual entities. */
-                        if (var->anonymous) {
-                            ecs_err(
-                                "can't use anonymous variable '%s' as source of "
-                                "data term", var->name);
-                            goto error;
-                        }
-                    }
-
-                    /* Track which variable ids are used as field source */
-                    if (!rule->src_vars) {
-                        rule->src_vars = ecs_os_calloc_n(ecs_var_id_t,
-                            rule->filter.field_count);
-                    }
-
-                    rule->src_vars[term->field_index] = var_id;
-                }
-            } else {
-                if (flecs_term_id_is_wildcard(src)) {
-                    anonymous_count ++;
-                }
-            }
-        } else if ((src->flags & EcsIsVariable) && (src->id == EcsThis)) {
-            if (flecs_rule_is_builtin_pred(term) && term->oper == EcsOr) {
-                flecs_rule_add_var(rule, EcsThisName, vars, EcsVarEntity);
-            }
-        }
-
-        if (flecs_rule_add_var_for_term_id(
-            rule, second, vars, EcsVarEntity) == EcsVarNone)
-        {
-            /* If second is a wildcard, insert anonymous variable */
-            if (flecs_term_id_is_wildcard(second)) {
-                anonymous_count ++;
-            }
-        }
-
-        if (src->flags & EcsIsVariable && second->flags & EcsIsVariable) {
-            if (term->flags & EcsTermTransitive) {
-                /* Anonymous variable to store temporary id for finding 
-                 * targets for transitive relationship, see compile_term. */
-                anonymous_count ++;
-            }
-        }
-
-        /* Track if a This entity variable is used before a potential This table 
-         * variable. If this happens, the rule has no This table variable */
-        if (src->id == EcsThis) {
-            table_this = true;
-        }
-        if (first->id == EcsThis || second->id == EcsThis) {
-            if (!table_this) {
-                entity_before_table_this = true;
-            }
-        }
-    }
-
-    int32_t var_count = ecs_vec_count(vars);
-    ecs_var_id_t placeholder = EcsVarNone - 1;
-    bool replace_placeholders = false;
-
-    /* Ensure lookup variables have table and/or entity variables */
-    for (i = 0; i < var_count; i ++) {
-        ecs_rule_var_t *var = ecs_vec_get_t(vars, ecs_rule_var_t, i);
-        if (var->lookup) {
-            char *var_name = ecs_os_strdup(var->name);
-            var_name[var->lookup - var->name - 1] = '\0';
-
-            ecs_var_id_t base_table_id = flecs_rule_find_var_id(
-                rule, var_name, EcsVarTable);
-            if (base_table_id != EcsVarNone) {
-                var->table_id = base_table_id;
-            } else if (anonymous_table_count) {
-                /* Scan for implicit anonymous table variables that haven't been
-                 * inserted yet (happens after this step). Doing this here vs.
-                 * ensures that anonymous variables are appended at the end of
-                 * the variable array, while also ensuring that variable ids are
-                 * stable (no swapping of table var ids that are in use). */
-                for (a = 0; a < var_count; a ++) {
-                    ecs_rule_var_t *avar = ecs_vec_get_t(
-                        vars, ecs_rule_var_t, a);
-                    if (avar->kind == EcsVarAny) {
-                        if (!ecs_os_strcmp(avar->name, var_name)) {
-                            base_table_id = (ecs_var_id_t)(a + 1);
-                            break;
-                        }
-                    }
-                }
-                if (base_table_id != EcsVarNone) {
-                    /* Set marker so we can set the new table id afterwards */
-                    var->table_id = placeholder;
-                    replace_placeholders = true;
-                }
-            }
-
-            ecs_var_id_t base_entity_id = flecs_rule_find_var_id(
-                rule, var_name, EcsVarEntity);
-            if (base_entity_id == EcsVarNone) {
-                /* Get name from table var (must exist). We can't use allocated
-                 * name since variables don't own names. */
-                const char *base_name = NULL;
-                if (base_table_id != EcsVarNone && base_table_id) {
-                    ecs_rule_var_t *base_table_var = ecs_vec_get_t(
-                        vars, ecs_rule_var_t, (int32_t)base_table_id - 1);
-                    base_name = base_table_var->name;
-                } else {
-                    base_name = EcsThisName;
-                }
-
-                base_entity_id = flecs_rule_add_var(
-                    rule, base_name, vars, EcsVarEntity);
-                var = ecs_vec_get_t(vars, ecs_rule_var_t, i);
-            }
-
-            var->base_id = base_entity_id;
-
-            ecs_os_free(var_name);
-        }
-    }
-    var_count = ecs_vec_count(vars);
-
-    /* Add non-This table variables */
-    if (anonymous_table_count) {
-        anonymous_table_count = 0;
-        for (i = 0; i < var_count; i ++) {
-            ecs_rule_var_t *var = ecs_vec_get_t(vars, ecs_rule_var_t, i);
-            if (var->kind == EcsVarAny) {
-                var->kind = EcsVarEntity;
-
-                ecs_var_id_t var_id = flecs_rule_add_var(
-                    rule, var->name, vars, EcsVarTable);
-                ecs_vec_get_t(vars, ecs_rule_var_t, i)->table_id = var_id;
-                anonymous_table_count ++;
-            }
-        }
-
-        var_count = ecs_vec_count(vars);
-    }
-
-    /* If any forward references to newly added anonymous tables exist, replace
-     * them with the actual table variable ids. */
-    if (replace_placeholders) {
-        for (i = 0; i < var_count; i ++) {
-            ecs_rule_var_t *var = ecs_vec_get_t(vars, ecs_rule_var_t, i);
-            if (var->table_id == placeholder) {
-                char *var_name = ecs_os_strdup(var->name);
-                var_name[var->lookup - var->name - 1] = '\0';
-
-                var->table_id = flecs_rule_find_var_id(
-                    rule, var_name, EcsVarTable);
-                ecs_assert(var->table_id != EcsVarNone, 
-                    ECS_INTERNAL_ERROR, NULL);
-
-                ecs_os_free(var_name);
-            }
-        }
-    }
-
-    /* Always include spot for This variable, even if rule doesn't use it */
-    var_count ++;
-
-    ecs_rule_var_t *rule_vars = &rule->vars_cache.var;
-    if ((var_count + anonymous_count) > 1) {
-        rule_vars = ecs_os_malloc(
-            (ECS_SIZEOF(ecs_rule_var_t) + ECS_SIZEOF(char*)) * 
-                (var_count + anonymous_count));
-    }
-
-    rule->vars = rule_vars;
-    rule->var_count = var_count;
-    rule->var_pub_count = var_count;
-    rule->has_table_this = !entity_before_table_this;
-
-#ifdef FLECS_DEBUG
-    rule->var_size = var_count + anonymous_count;
-#endif
-
-    char **var_names = ECS_ELEM(rule_vars, ECS_SIZEOF(ecs_rule_var_t), 
-        var_count + anonymous_count);
-    rule->var_names = (char**)var_names;
-
-    rule_vars[0].kind = EcsVarTable;
-    rule_vars[0].name = NULL;
-    flecs_set_var_label(&rule_vars[0], NULL);
-    rule_vars[0].id = 0;
-    rule_vars[0].table_id = EcsVarNone;
-    rule_vars[0].lookup = NULL;
-    var_names[0] = ECS_CONST_CAST(char*, rule_vars[0].name);
-    rule_vars ++;
-    var_names ++;
-    var_count --;
-
-    if (var_count) {
-        ecs_rule_var_t *user_vars = ecs_vec_first_t(vars, ecs_rule_var_t);
-        ecs_os_memcpy_n(rule_vars, user_vars, ecs_rule_var_t, var_count);
-        for (i = 0; i < var_count; i ++) {
-            var_names[i] = ECS_CONST_CAST(char*, rule_vars[i].name);
-        }
-    }
-
-    /* Hide anonymous table variables from application */
-    rule->var_pub_count -= anonymous_table_count;
-
-    /* Sanity check to make sure that the public part of the variable array only
-     * contains entity variables. */
-#ifdef FLECS_DEBUG
-    for (i = 1 /* first element = $this */; i < rule->var_pub_count; i ++) {
-        ecs_assert(rule->vars[i].kind == EcsVarEntity, ECS_INTERNAL_ERROR, NULL);
-    }
-#endif
-
-    return 0;
-error:
-    return -1;
-}
-
-static
-ecs_var_id_t flecs_rule_most_specific_var(
-    ecs_rule_t *rule,
-    const char *name,
-    ecs_var_kind_t kind,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    if (kind == EcsVarTable || kind == EcsVarEntity) {
-        return flecs_rule_find_var_id(rule, name, kind);
-    }
-
-    ecs_var_id_t evar = flecs_rule_find_var_id(rule, name, EcsVarEntity);
-    if ((evar != EcsVarNone) && flecs_rule_is_written(evar, ctx->written)) {
-        /* If entity variable is available and written to, it contains the most
-         * specific result and should be used. */
-        return evar;
-    }
-
-    ecs_var_id_t tvar = flecs_rule_find_var_id(rule, name, EcsVarTable);
-    if ((tvar != EcsVarNone) && !flecs_rule_is_written(tvar, ctx->written)) {
-        /* If variable of any kind is requested and variable hasn't been written
-         * yet, write to table variable */
-        return tvar;
-    }
-
-    /* If table var is written, and entity var doesn't exist or is not written,
-     * return table var */
-    if (tvar != EcsVarNone) {
-        return tvar;
-    } else {
-        return evar;
-    }
-}
-
-static
-ecs_rule_lbl_t flecs_rule_op_insert(
-    ecs_rule_op_t *op,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t *elem = ecs_vec_append_t(NULL, ctx->ops, ecs_rule_op_t);
-    int32_t count = ecs_vec_count(ctx->ops);
-    *elem = *op;
-    if (count > 1) {
-        if (ctx->cur->lbl_begin == -1) {
-            /* Variables written by previous instruction can't be written by
-             * this instruction, except when this is a union. */
-            elem->written &= ~elem[-1].written;
-        }
-    }
-
-    elem->next = flecs_itolbl(count);
-    elem->prev = flecs_itolbl(count - 2);
-    return flecs_itolbl(count - 1);
-}
-
-static
-ecs_rule_op_t* flecs_rule_begin_block(
-    ecs_rule_op_kind_t kind,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t op = {0};
-    op.kind = flecs_ito(uint8_t, kind);
-    ctx->cur->lbl_begin = flecs_rule_op_insert(&op, ctx);
-    return ecs_vec_get_t(ctx->ops, ecs_rule_op_t, ctx->cur->lbl_begin);
-}
-
-static
-void flecs_rule_end_block(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t new_op = {0};
-    new_op.kind = EcsRuleEnd;
-    ecs_rule_lbl_t end = flecs_rule_op_insert(&new_op, ctx);
-    
-    ecs_rule_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_rule_op_t);
-    ops[ctx->cur->lbl_begin].next = end;
-
-    ecs_rule_op_t *end_op = &ops[end];
-    if (ctx->cur->lbl_query != -1) {
-        ecs_rule_op_t *query_op = &ops[ctx->cur->lbl_query];
-        end_op->prev = ctx->cur->lbl_begin;
-        end_op->src = query_op->src;
-        end_op->first = query_op->first;
-        end_op->second = query_op->second;
-        end_op->flags = query_op->flags;
-        end_op->field_index = query_op->field_index;
-    } else {
-        end_op->prev = ctx->cur->lbl_begin;
-        end_op->field_index = -1;
-    }
-
-    ctx->cur->lbl_begin = -1;
-}
-
-static
-void flecs_rule_begin_block_cond_eval(
-    ecs_rule_op_t *op,
-    ecs_rule_compile_ctx_t *ctx,
-    ecs_write_flags_t cond_write_state)
-{
-    ecs_var_id_t first_var = EcsVarNone, second_var = EcsVarNone, src_var = EcsVarNone;
-    ecs_write_flags_t cond_mask = 0;
-
-    if (flecs_rule_ref_flags(op->flags, EcsRuleFirst) == EcsRuleIsVar) {
-        first_var = op->first.var;
-        ecs_assert(first_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-        cond_mask |= (1ull << first_var);
-    }
-    if (flecs_rule_ref_flags(op->flags, EcsRuleSecond) == EcsRuleIsVar) {
-        second_var = op->second.var;
-        ecs_assert(second_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-        cond_mask |= (1ull << second_var);
-    }
-    if (flecs_rule_ref_flags(op->flags, EcsRuleSrc) == EcsRuleIsVar) {
-        src_var = op->src.var;
-        ecs_assert(src_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-        cond_mask |= (1ull << src_var);
-    }
-
-    /* Variables set in an OR chain are marked as conditional writes. However, 
-     * writes from previous terms in the current OR chain shouldn't be treated
-     * as variables that are conditionally set, so instead use the write mask 
-     * from before the chain started. */
-    if (ctx->ctrlflow->in_or) {
-        cond_write_state = ctx->ctrlflow->cond_written_or;
-    }
-
-    /* If this term uses conditionally set variables, insert instruction that
-     * jumps over the term if the variables weren't set yet. */
-    if (cond_mask & cond_write_state) {
-        ctx->cur->lbl_cond_eval = flecs_itolbl(ecs_vec_count(ctx->ops));
-
-        ecs_rule_op_t jmp_op = {0};
-        jmp_op.kind = EcsRuleIf;
-
-        if ((first_var != EcsVarNone) && cond_write_state & (1ull << first_var)) {
-            jmp_op.flags |= (EcsRuleIsVar << EcsRuleFirst);
-            jmp_op.first.var = first_var;
-        }
-        if ((second_var != EcsVarNone) && cond_write_state & (1ull << second_var)) {
-            jmp_op.flags |= (EcsRuleIsVar << EcsRuleSecond);
-            jmp_op.second.var = second_var;
-        }
-        if ((src_var != EcsVarNone) && cond_write_state & (1ull << src_var)) {
-            jmp_op.flags |= (EcsRuleIsVar << EcsRuleSrc);
-            jmp_op.src.var = src_var;
-        }
-
-        flecs_rule_op_insert(&jmp_op, ctx);
-    } else {
-        ctx->cur->lbl_cond_eval = -1;
-    }
-}
-
-static
-void flecs_rule_end_block_cond_eval(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    if (ctx->cur->lbl_cond_eval == -1) {
-        return;
-    }
-
-    ecs_assert(ctx->cur->lbl_query >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_rule_op_t end_op = {0};
-    end_op.kind = EcsRuleEnd;
-    ecs_rule_lbl_t end = flecs_rule_op_insert(&end_op, ctx);
-
-    ecs_rule_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_rule_op_t);
-    ops[ctx->cur->lbl_cond_eval].next = end;
-
-    ecs_rule_op_t *end_op_ptr = &ops[end];
-    ecs_rule_op_t *query_op = &ops[ctx->cur->lbl_query];
-    end_op_ptr->prev = ctx->cur->lbl_cond_eval;
-    end_op_ptr->src = query_op->src;
-    end_op_ptr->first = query_op->first;
-    end_op_ptr->second = query_op->second;
-    end_op_ptr->flags = query_op->flags;
-    end_op_ptr->field_index = query_op->field_index;
-}
-
-static
-void flecs_rule_begin_block_or(
-    ecs_rule_op_t *op,
-    ecs_term_t *term,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t *or_op = flecs_rule_begin_block(EcsRuleNot, ctx);
-    or_op->kind = EcsRuleOr;
-
-    /* Set the source of the evaluate terms as source of the Or instruction. 
-     * This lets the engine determine whether the variable has already been
-     * written. When the source is not yet written, an OR operation needs to
-     * take the union of all the terms in the OR chain. When the variable is
-     * known, it will return after the first matching term.
-     * 
-     * In case a term in the OR expression is an equality predicate which 
-     * compares the left hand side with a variable, the variable acts as an 
-     * alias, so we can always assume that it's written. */
-    bool add_src = true;
-    if (term->first.id == EcsPredEq && term->second.flags & EcsIsVariable) {
-        if (!(flecs_rule_is_written(op->src.var, ctx->written))) {
-            add_src = false;
-        }
-    }
-
-    if (add_src) {
-        if (op->flags & (EcsRuleIsVar << EcsRuleSrc)) {
-            or_op->flags = (EcsRuleIsVar << EcsRuleSrc);
-            or_op->src = op->src;
-        }
-    }
-}
-
-static
-void flecs_rule_end_block_or(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t op = {0};
-    op.kind = EcsRuleEnd;
-    ecs_rule_lbl_t end = flecs_rule_op_insert(&op, ctx);
-    
-    ecs_rule_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_rule_op_t);
-    int32_t i, j, prev_or = -2;
-    for (i = ctx->cur->lbl_begin + 1; i < end; i ++) {
-        if (ops[i].next == FlecsRuleOrMarker) {
-            if (prev_or != -2) {
-                ops[prev_or].prev = flecs_itolbl(i);
-            }
-            ops[i].next = flecs_itolbl(end);
-            prev_or = i;
-        } else {
-            /* Combine operation with next OR marker. This supports OR chains 
-             * with terms that require multiple operations to test. */
-            for (j = i + 1; j < end; j ++) {
-                if (ops[j].next == FlecsRuleOrMarker) {
-                    if (j == (end - 1)) {
-                        ops[i].prev = ctx->cur->lbl_begin;
-                    } else {
-                        ops[i].prev = flecs_itolbl(j + 1);
-                    }
-                    break;
-                }
-            }
-        }
-    }
-
-    ops[ctx->cur->lbl_begin].next = flecs_itolbl(end);
-    ops[end].prev = ctx->cur->lbl_begin;
-    ops[end - 1].prev = ctx->cur->lbl_begin;
-
-    /* Scan which variables were conditionally written in the OR chain and 
-     * reset instructions after the OR chain. If a variable is set in part one
-     * of a chain but not part two, there would be nothing writing to the
-     * variable in part two, leaving it to the previous value. To address this
-     * a reset is inserted that resets the variable value on redo. */
-    for (i = 1; i < (8 * ECS_SIZEOF(ecs_write_flags_t)); i ++) {
-        ecs_write_flags_t prev = 1 & (ctx->ctrlflow->cond_written_or >> i);
-        ecs_write_flags_t cur = 1 & (ctx->cond_written >> i);
-
-        if (!prev && cur) {
-            ecs_rule_op_t reset_op = {0};
-            reset_op.kind = EcsRuleReset;
-            reset_op.flags |= (EcsRuleIsVar << EcsRuleSrc);
-            reset_op.src.var = flecs_itovar(i);
-            flecs_rule_op_insert(&reset_op, ctx);
-        }
-    }
-
-    ctx->ctrlflow->in_or = false;
-    ctx->cur->lbl_begin = -1;
-}
-
-static
-void flecs_rule_insert_each(
-    ecs_var_id_t tvar,
-    ecs_var_id_t evar,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
-{
-    ecs_rule_op_t each = {0};
-    each.kind = EcsRuleEach;
-    each.src.var = evar;
-    each.first.var = tvar;
-    each.flags = (EcsRuleIsVar << EcsRuleSrc) | 
-                 (EcsRuleIsVar << EcsRuleFirst);
-    flecs_rule_write_ctx(evar, ctx, cond_write);
-    flecs_rule_write(evar, &each.written);
-    flecs_rule_op_insert(&each, ctx);
-}
-
-static
-void flecs_rule_insert_lookup(
-    ecs_var_id_t base_var,
-    ecs_var_id_t evar,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
-{
-    ecs_rule_op_t lookup = {0};
-    lookup.kind = EcsRuleLookup;
-    lookup.src.var = evar;
-    lookup.first.var = base_var;
-    lookup.flags = (EcsRuleIsVar << EcsRuleSrc) | 
-                 (EcsRuleIsVar << EcsRuleFirst);
-    flecs_rule_write_ctx(evar, ctx, cond_write);
-    flecs_rule_write(evar, &lookup.written);
-    flecs_rule_op_insert(&lookup, ctx);
-}
-
-static
-void flecs_rule_insert_unconstrained_transitive(
-    ecs_rule_t *rule,
-    ecs_rule_op_t *op,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
-{
-    /* Create anonymous variable to store the target ids. This will return the
-     * list of targets without constraining the variable of the term, which
-     * needs to stay variable to find all transitive relationships for a src. */
-    ecs_var_id_t tgt = flecs_rule_add_var(rule, NULL, NULL, EcsVarEntity);
-    flecs_set_var_label(&rule->vars[tgt], rule->vars[op->second.var].name);
-
-    /* First, find ids to start traversal from. This fixes op.second. */
-    ecs_rule_op_t find_ids = {0};
-    find_ids.kind = EcsRuleIdsRight;
-    find_ids.field_index = -1;
-    find_ids.first = op->first;
-    find_ids.second = op->second;
-    find_ids.flags = op->flags;
-    find_ids.flags &= (ecs_flags8_t)~((EcsRuleIsVar|EcsRuleIsEntity) << EcsRuleSrc);
-    find_ids.second.var = tgt;
-    flecs_rule_write_ctx(tgt, ctx, cond_write);
-    flecs_rule_write(tgt, &find_ids.written);
-    flecs_rule_op_insert(&find_ids, ctx);
-
-    /* Next, iterate all tables for the ids. This fixes op.src */
-    ecs_rule_op_t and_op = {0};
-    and_op.kind = EcsRuleAnd;
-    and_op.field_index = op->field_index;
-    and_op.first = op->first;
-    and_op.second = op->second;
-    and_op.src = op->src;
-    and_op.flags = op->flags | EcsRuleIsSelf;
-    and_op.second.var = tgt;
-    flecs_rule_write_ctx(and_op.src.var, ctx, cond_write);
-    flecs_rule_write(and_op.src.var, &and_op.written);
-    flecs_rule_op_insert(&and_op, ctx);
-}
-
-static
-void flecs_rule_insert_inheritance(
-    ecs_rule_t *rule,
-    ecs_term_t *term,
-    ecs_rule_op_t *op,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write)
-{
-    /* Anonymous variable to store the resolved component ids */
-    ecs_var_id_t tvar = flecs_rule_add_var(rule, NULL, NULL, EcsVarTable);
-    ecs_var_id_t evar = flecs_rule_add_var(rule, NULL, NULL, EcsVarEntity);
-    flecs_set_var_label(&rule->vars[tvar], ecs_get_name(rule->filter.world, term->first.id));
-    flecs_set_var_label(&rule->vars[evar], ecs_get_name(rule->filter.world, term->first.id));
-
-    ecs_rule_op_t trav_op = {0};
-    trav_op.kind = EcsRuleTrav;
-    trav_op.field_index = -1;
-    trav_op.first.entity = term->first.trav;
-    trav_op.second.entity = term->first.id;
-    trav_op.src.var = tvar;
-    trav_op.flags = EcsRuleIsSelf;
-    trav_op.flags |= (EcsRuleIsEntity << EcsRuleFirst);
-    trav_op.flags |= (EcsRuleIsEntity << EcsRuleSecond);
-    trav_op.flags |= (EcsRuleIsVar << EcsRuleSrc);
-    trav_op.written |= (1ull << tvar);
-    if (term->first.flags & EcsSelf) {
-        trav_op.match_flags |= EcsTermReflexive;
-    }
-    flecs_rule_op_insert(&trav_op, ctx);
-    flecs_rule_insert_each(tvar, evar, ctx, cond_write);
-
-    ecs_rule_ref_t r = { .var = evar };
-    op->first = r;
-    op->flags &= (ecs_flags8_t)~(EcsRuleIsEntity << EcsRuleFirst);
-    op->flags |= (EcsRuleIsVar << EcsRuleFirst);
-}
-
-static
-void flecs_rule_compile_term_id(
-    ecs_world_t *world,
-    ecs_rule_t *rule,
-    ecs_rule_op_t *op,
-    ecs_term_id_t *term_id,
-    ecs_rule_ref_t *ref,
-    ecs_flags8_t ref_kind,
-    ecs_var_kind_t kind,
-    ecs_rule_compile_ctx_t *ctx,
-    bool create_wildcard_vars)
-{
-    (void)world;
-
-    if (!ecs_term_id_is_set(term_id)) {
-        return;
-    }
-
-    if (term_id->flags & EcsIsVariable) {
-        op->flags |= (ecs_flags8_t)(EcsRuleIsVar << ref_kind);
-        const char *name = flecs_term_id_var_name(term_id);
-        if (name) {
-            ref->var = flecs_rule_most_specific_var(rule, name, kind, ctx);
-            ecs_assert(ref->var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-        } else if (create_wildcard_vars) {
-            bool is_wildcard = flecs_term_id_is_wildcard(term_id);
-            if (is_wildcard && (kind == EcsVarAny)) {
-                ref->var = flecs_rule_add_var(rule, NULL, NULL, EcsVarTable);
-            } else {
-                ref->var = flecs_rule_add_var(rule, NULL, NULL, EcsVarEntity);
-            }
-            if (is_wildcard) {
-                flecs_set_var_label(&rule->vars[ref->var], 
-                    ecs_get_name(world, term_id->id));
-            }
-            ecs_assert(ref->var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-        }
-    }
-
-    if (term_id->flags & EcsIsEntity) {
-        op->flags |= (ecs_flags8_t)(EcsRuleIsEntity << ref_kind);
-        ref->entity = term_id->id;
-    }
-}
-
-static
-int flecs_rule_compile_ensure_vars(
-    ecs_rule_t *rule,
-    ecs_rule_op_t *op,
-    ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write,
-    bool *written_out)
-{
-    ecs_flags16_t flags = flecs_rule_ref_flags(op->flags, ref_kind);
-    bool written = false;
-
-    if (flags & EcsRuleIsVar) {
-        ecs_var_id_t var_id = ref->var;
-        ecs_rule_var_t *var = &rule->vars[var_id];
-
-        if (var->kind == EcsVarEntity && 
-            !flecs_rule_is_written(var_id, ctx->written)) 
-        {
-            /* If entity variable is not yet written but a table variant exists
-             * that has been written, insert each operation to translate from
-             * entity variable to table */
-            ecs_var_id_t tvar = var->table_id;
-            if ((tvar != EcsVarNone) && 
-                flecs_rule_is_written(tvar, ctx->written)) 
-            {
-                if (var->lookup) {
-                    if (!flecs_rule_is_written(tvar, ctx->written)) {
-                        ecs_err("dependent variable of '$%s' is not written", 
-                            var->name);
-                        return -1;
-                    }
-
-                    if (!flecs_rule_is_written(var->base_id, ctx->written)) {
-                        flecs_rule_insert_each(
-                            tvar, var->base_id, ctx, cond_write);
-                    }
-                } else {
-                    flecs_rule_insert_each(tvar, var_id, ctx, cond_write);
-                }
-
-                /* Variable was written, just not as entity */
-                written = true;
-            } else if (var->lookup) {
-                if (!flecs_rule_is_written(var->base_id, ctx->written)) {
-                    ecs_err("dependent variable of '$%s' is not written", 
-                        var->name);
-                    return -1;
-                }
-            }
-        }
-
-        written |= flecs_rule_is_written(var_id, ctx->written);
-    } else {
-        /* If it's not a variable, it's always written */
-        written = true;
-    }
-
-    if (written_out) {
-        *written_out = written;
-    }
-
-    return 0;
-}
-
-static
-bool flecs_rule_compile_lookup(
-    ecs_rule_t *rule,
-    ecs_var_id_t var_id,
-    ecs_rule_compile_ctx_t *ctx,
-    bool cond_write) 
-{
-    ecs_rule_var_t *var = &rule->vars[var_id];
-    if (var->lookup) {
-        flecs_rule_insert_lookup(var->base_id, var_id, ctx, cond_write);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-static
-void flecs_rule_insert_contains(
-    ecs_rule_t *rule,
-    ecs_var_id_t src_var,
-    ecs_var_id_t other_var,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t contains = {0};
-    if ((src_var != other_var) && (src_var == rule->vars[other_var].table_id)) {
-        contains.kind = EcsRuleContain;
-        contains.src.var = src_var;
-        contains.first.var = other_var;
-        contains.flags |= (EcsRuleIsVar << EcsRuleSrc) | 
-                          (EcsRuleIsVar << EcsRuleFirst);
-        flecs_rule_op_insert(&contains, ctx);
-    }
-}
-
-static
-void flecs_rule_insert_pair_eq(
-    int32_t field_index,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_op_t contains = {0};
-    contains.kind = EcsRulePairEq;
-    contains.field_index = flecs_ito(int8_t, field_index);
-    flecs_rule_op_insert(&contains, ctx);
-}
-
-static
-bool flecs_rule_term_fixed_id(
-    ecs_filter_t *filter,
-    ecs_term_t *term)
-{
-    /* Transitive/inherited terms have variable ids */
-    if (term->flags & (EcsTermTransitive|EcsTermIdInherited)) {
-        return false;
-    }
-
-    /* Or terms can match different ids */
-    if (term->oper == EcsOr) {
-        return false;
-    }
-    if ((term != filter->terms) && term[-1].oper == EcsOr) {
-        return false;
-    }
-
-    /* Wildcards can assume different ids */
-    if (ecs_id_is_wildcard(term->id)) {
-        return false;
-    }
-
-    /* Any terms can have fixed ids, but they require special handling */
-    if (term->flags & (EcsTermMatchAny|EcsTermMatchAnySrc)) {
-        return false;
-    }
-
-    /* First terms that are Not or Optional require special handling */
-    if (term->oper == EcsNot || term->oper == EcsOptional) {
-        if (term == filter->terms) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-static
-int flecs_rule_compile_builtin_pred(
-    ecs_rule_t *rule,
-    ecs_term_t *term,
-    ecs_rule_op_t *op,
-    ecs_write_flags_t write_state)
-{
-    ecs_entity_t id = term->first.id;
-
-    ecs_rule_op_kind_t eq[] = {EcsRulePredEq, EcsRulePredNeq};
-    ecs_rule_op_kind_t eq_name[] = {EcsRulePredEqName, EcsRulePredNeqName};
-    ecs_rule_op_kind_t eq_match[] = {EcsRulePredEqMatch, EcsRulePredNeqMatch};
-    
-    ecs_flags16_t flags_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
-
-    if (id == EcsPredEq) {
-        if (term->second.flags & EcsIsName) {
-            op->kind = flecs_ito(uint8_t, eq_name[term->oper == EcsNot]);
-        } else {
-            op->kind = flecs_ito(uint8_t, eq[term->oper == EcsNot]);
-        }
-    } else if (id == EcsPredMatch) {
-        op->kind = flecs_ito(uint8_t, eq_match[term->oper == EcsNot]);
-    }
-
-    op->first = op->src;
-    op->src = (ecs_rule_ref_t){0};
-    op->flags &= (ecs_flags8_t)~((EcsRuleIsEntity|EcsRuleIsVar) << EcsRuleSrc);
-    op->flags &= (ecs_flags8_t)~((EcsRuleIsEntity|EcsRuleIsVar) << EcsRuleFirst);
-    op->flags |= EcsRuleIsVar << EcsRuleFirst;
-
-    if (flags_2nd & EcsRuleIsVar) {
-        if (!(write_state & (1ull << op->second.var))) {
-            ecs_err("uninitialized variable '%s' on right-hand side of "
-                "equality operator", 
-                    ecs_rule_var_name(rule, op->second.var));
-            return -1;
-        }
-    }
-
-    if (!(write_state & (1ull << op->first.var))) {
-        /* If this is an == operator with a right-hand side that resolves to a
-         * single entity, the left-hand side is allowed to be undefined, as the
-         * instruction will be evaluated as an assignment. */
-        if (op->kind != EcsRulePredEq && op->kind != EcsRulePredEqName) {
-            ecs_err("uninitialized variable '%s' on left-hand side of "
-                "equality operator", 
-                    ecs_rule_var_name(rule, op->first.var));
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
-static
-int flecs_rule_ensure_scope_var(
-    ecs_rule_t *rule,
-    ecs_rule_op_t *op,
-    ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_var_id_t var = ref->var;
-
-    if (rule->vars[var].kind == EcsVarEntity && 
-        !flecs_rule_is_written(var, ctx->written)) 
-    {
-        ecs_var_id_t table_var = rule->vars[var].table_id;
-        if (table_var != EcsVarNone && 
-            flecs_rule_is_written(table_var, ctx->written)) 
-        {
-            if (flecs_rule_compile_ensure_vars(
-                rule, op, ref, ref_kind, ctx, false, NULL))
-            {
-                goto error;
-            }
-
-        }
-    }
-
-    return 0;
-error:
-    return -1;
-}
-
-static
-int flecs_rule_ensure_scope_vars(
-    ecs_world_t *world,
-    ecs_rule_t *rule,
-    ecs_rule_compile_ctx_t *ctx,
-    ecs_term_t *term)
-{
-    /* If the scope uses variables as entity that have only been written as
-     * table, resolve them as entities before entering the scope. */
-    ecs_term_t *cur = term;
-    while(cur->first.id != EcsScopeClose) {
-        /* Dummy operation to obtain variable information for term */
-        ecs_rule_op_t op = {0};
-        flecs_rule_compile_term_id(world, rule, &op, &cur->first, 
-            &op.first, EcsRuleFirst, EcsVarEntity, ctx, false);
-        flecs_rule_compile_term_id(world, rule, &op, &cur->second, 
-            &op.second, EcsRuleSecond, EcsVarEntity, ctx, false);
-
-        if (op.flags & (EcsRuleIsVar << EcsRuleFirst)) {
-            if (flecs_rule_ensure_scope_var(
-                rule, &op, &op.first, EcsRuleFirst, ctx))
-            {
-                goto error;
-            }
-        }
-        if (op.flags & (EcsRuleIsVar << EcsRuleSecond)) {
-            if (flecs_rule_ensure_scope_var(
-                rule, &op, &op.second, EcsRuleSecond, ctx))
-            {
-                goto error;
-            }
-        }
-
-        cur ++;
-    }
-
-    return 0;
-error:
-    return -1;
-}
-
-static
-void flecs_rule_compile_push(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ctx->cur = &ctx->ctrlflow[++ ctx->scope];
-    ctx->cur->lbl_begin = -1;
-    ctx->cur->lbl_begin = -1;
-}
-
-static
-void flecs_rule_compile_pop(
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ctx->cur = &ctx->ctrlflow[-- ctx->scope];
-}
-
-static
-bool flecs_rule_term_is_or(
-    const ecs_filter_t *filter,
-    const ecs_term_t *term)
-{
-    bool first_term = term == filter->terms;
-    return (term->oper == EcsOr) || (!first_term && term[-1].oper == EcsOr);
-}
-
-static
-int flecs_rule_compile_term(
-    ecs_world_t *world,
-    ecs_rule_t *rule,
-    ecs_term_t *term,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_filter_t *filter = &rule->filter;
-    bool first_term = term == filter->terms;
-    bool first_is_var = term->first.flags & EcsIsVariable;
-    bool second_is_var = term->second.flags & EcsIsVariable;
-    bool src_is_var = term->src.flags & EcsIsVariable;
-    bool builtin_pred = flecs_rule_is_builtin_pred(term);
-    bool is_not = (term->oper == EcsNot) && !builtin_pred;
-    bool is_or = flecs_rule_term_is_or(filter, term);
-    bool first_or = false, last_or = false;
-    bool cond_write = term->oper == EcsOptional || is_or;
-    ecs_rule_op_t op = {0};
-
-    if (is_or) {
-        first_or = first_term || (term[-1].oper != EcsOr);
-        last_or = term->oper != EcsOr;
-    }
-
-    /* !_ (don't match anything) terms always return nothing. */
-    if (is_not && term->id == EcsAny) {
-        op.kind = EcsRuleNothing;
-        flecs_rule_op_insert(&op, ctx);
-        return 0;
-    }
-
-    if (is_or && (first_term || term[-1].oper != EcsOr)) {
-        ctx->ctrlflow->cond_written_or = ctx->cond_written;
-        ctx->ctrlflow->in_or = true;
-    }
-
-    if (!term->src.id && term->src.flags & EcsIsEntity) {
-        /* If the term has a 0 source, check if it's a scope open/close */
-        if (term->first.id == EcsScopeOpen) {
-            if (flecs_rule_ensure_scope_vars(world, rule, ctx, term)) {
-                goto error;
-            }
-            if (term->oper == EcsNot) {
-                ctx->scope_is_not |= (ecs_flags32_t)(1ull << ctx->scope);
-                flecs_rule_begin_block(EcsRuleNot, ctx);
-            } else {
-                ctx->scope_is_not &= (ecs_flags32_t)~(1ull << ctx->scope);
-            }
-            flecs_rule_compile_push(ctx);
-        } else if (term->first.id == EcsScopeClose) {
-            flecs_rule_compile_pop(ctx);
-            if (ctx->scope_is_not & (ecs_flags32_t)(1ull << (ctx->scope))) {
-                ctx->cur->lbl_query = -1;
-                flecs_rule_end_block(ctx);
-            }
-        } else {
-            /* Noop */
-        }
-        return 0;
-    }
-
-    if (builtin_pred) {
-        if (term->second.id == EcsWildcard || term->second.id == EcsAny) {
-            /* Noop */
-            return 0;
-        }
-    }
-
-    /* Default instruction for And operators. If the source is fixed (like for
-     * singletons or terms with an entity source), use With, which like And but
-     * just matches against a source (vs. finding a source). */
-    op.kind = src_is_var ? EcsRuleAnd : EcsRuleWith;
-    op.field_index = flecs_ito(int8_t, term->field_index);
-    op.term_index = flecs_ito(int8_t, term - filter->terms);
-
-    /* If rule is transitive, use Trav(ersal) instruction */
-    if (term->flags & EcsTermTransitive) {
-        ecs_assert(ecs_term_id_is_set(&term->second), ECS_INTERNAL_ERROR, NULL);
-        op.kind = EcsRuleTrav;
-    } else {
-        /* Ignore cascade & parent flags */
-        ecs_flags32_t trav_flags = EcsTraverseFlags & ~(EcsCascade|EcsParent);
-        if (term->flags & (EcsTermMatchAny|EcsTermMatchAnySrc)) {
-            op.kind = EcsRuleAndAny;
-        } else if ((term->src.flags & trav_flags) == EcsUp) {
-            op.kind = EcsRuleUp;
-        } else if ((term->src.flags & trav_flags) == (EcsSelf|EcsUp)) {
-            op.kind = EcsRuleSelfUp;
-        }
-    }
-
-    /* If term has fixed id, insert simpler instruction that skips dealing with
-     * wildcard terms and variables */
-    if (flecs_rule_term_fixed_id(filter, term)) {
-        if (op.kind == EcsRuleAnd) {
-            op.kind = EcsRuleAndId;
-        } else if (op.kind == EcsRuleSelfUp) {
-            op.kind = EcsRuleSelfUpId;
-        } else if (op.kind == EcsRuleUp) {
-            op.kind = EcsRuleUpId;
-        }
-    }
-
-    /* Save write state at start of term so we can use it to reliably track
-     * variables got written by this term. */
-    ecs_write_flags_t cond_write_state = ctx->cond_written;
-
-    /* Resolve component inheritance if necessary */
-    ecs_var_id_t first_var = EcsVarNone, second_var = EcsVarNone, src_var = EcsVarNone;
-
-    /* Resolve variables and entities for operation arguments */
-    flecs_rule_compile_term_id(world, rule, &op, &term->first, 
-        &op.first, EcsRuleFirst, EcsVarEntity, ctx, true);
-    flecs_rule_compile_term_id(world, rule, &op, &term->second, 
-        &op.second, EcsRuleSecond, EcsVarEntity, ctx, true);
-
-    if (first_is_var) first_var = op.first.var;
-    if (second_is_var) second_var = op.second.var;
-
-    flecs_rule_compile_term_id(world, rule, &op, &term->src, 
-        &op.src, EcsRuleSrc, EcsVarAny, ctx, true);
-    if (src_is_var) src_var = op.src.var;
-    bool src_written = flecs_rule_is_written(src_var, ctx->written);
-
-    /* Insert each instructions for table -> entity variable if needed */
-    bool first_written, second_written;
-    if (flecs_rule_compile_ensure_vars(
-        rule, &op, &op.first, EcsRuleFirst, ctx, cond_write, &first_written)) 
-    {
-        goto error;    
-    }
-    if (flecs_rule_compile_ensure_vars(
-        rule, &op, &op.second, EcsRuleSecond, ctx, cond_write, &second_written))
-    {
-        goto error;
-    }
-
-    /* If the query starts with a Not or Optional term, insert an operation that
-     * matches all entities. */
-    if (first_term && src_is_var && !src_written && term->src.id != EcsAny) {
-        bool pred_match = builtin_pred && term->first.id == EcsPredMatch;
-        if (term->oper == EcsNot || term->oper == EcsOptional || pred_match) {
-            ecs_rule_op_t match_any = {0};
-            match_any.kind = EcsAnd;
-            match_any.flags = EcsRuleIsSelf | (EcsRuleIsEntity << EcsRuleFirst);
-            match_any.flags |= (EcsRuleIsVar << EcsRuleSrc);
-            match_any.src = op.src;
-            match_any.field_index = -1;
-            if (!pred_match) {
-                match_any.first.entity = EcsAny;
-            } else {
-                /* If matching by name, instead of finding all tables, just find
-                 * the ones with a name. */
-                match_any.first.entity = ecs_id(EcsIdentifier);
-                match_any.second.entity = EcsName;
-                match_any.flags |= (EcsRuleIsEntity << EcsRuleSecond);
-            }
-            match_any.written = (1ull << src_var);
-            flecs_rule_op_insert(&match_any, ctx);
-            flecs_rule_write_ctx(op.src.var, ctx, false);
-
-            /* Update write administration */
-            src_written = true;
-        }
-    }
-
-    /* A bit of special logic for OR expressions and equality predicates. If the
-     * left-hand of an equality operator is a table, and there are multiple
-     * operators in an Or expression, the Or chain should match all entities in
-     * the table that match the right hand sides of the operator expressions. 
-     * For this to work, the src variable needs to be resolved as entity, as an
-     * Or chain would otherwise only yield the first match from a table. */
-    if (src_is_var && src_written && builtin_pred && term->oper == EcsOr) {
-        /* Or terms are required to have the same source, so we don't have to
-         * worry about the last term in the chain. */
-        if (rule->vars[src_var].kind == EcsVarTable) {
-            flecs_rule_compile_term_id(world, rule, &op, &term->src, 
-                    &op.src, EcsRuleSrc, EcsVarEntity, ctx, true);
-            src_var = op.src.var;
-        }
-    }
-
-    if (flecs_rule_compile_ensure_vars(
-        rule, &op, &op.src, EcsRuleSrc, ctx, cond_write, NULL)) 
-    {
-        goto error;
-    }
-
-    /* If source is Any (_) and first and/or second are unconstrained, insert an
-     * ids instruction instead of an And */
-    if (term->flags & EcsTermMatchAnySrc) {
-        op.kind = EcsRuleIds;
-        /* Use up-to-date written values after potentially inserting each */
-        if (!first_written || !second_written) {
-            if (!first_written) {
-                /* If first is unknown, traverse left: <- (*, t) */
-                if (term->first.id != EcsAny) {
-                    op.kind = EcsRuleIdsLeft;
-                }
-            } else {
-                /* If second is wildcard, traverse right: (r, *) -> */
-                if (term->second.id != EcsAny) {
-                    op.kind = EcsRuleIdsRight;
-                }
-            }
-            op.src.entity = 0;
-            op.flags &= (ecs_flags8_t)~(EcsRuleIsVar << EcsRuleSrc); /* ids has no src */
-            op.flags &= (ecs_flags8_t)~(EcsRuleIsEntity << EcsRuleSrc);
-        }
-
-    /* If source variable is not written and we're querying just for Any, insert
-     * a dedicated instruction that uses the Any record in the id index. Any 
-     * queries that are evaluated against written sources can use Wildcard 
-     * records, which is what the AndAny instruction does. */
-    } else if (!src_written && term->id == EcsAny && op.kind == EcsRuleAndAny) {
-        /* Lookup variables ($var.child_name) are always written */
-        if (!rule->vars[src_var].lookup) {
-            op.kind = EcsRuleSelectAny; /* Uses Any (_) id record */
-        }
-    }
-
-    /* If this is a transitive term and both the target and source are unknown,
-     * find the targets for the relationship first. This clusters together 
-     * tables for the same target, which allows for more efficient usage of the
-     * traversal caches. */
-    if (term->flags & EcsTermTransitive && src_is_var && second_is_var) {
-        if (!src_written && !second_written) {
-            flecs_rule_insert_unconstrained_transitive(
-                rule, &op, ctx, cond_write);
-        }
-    }
-
-    /* Check if this term has variables that have been conditionally written,
-     * like variables written by an optional term. */
-    if (ctx->cond_written) {
-        if (!is_or || first_or) {
-            flecs_rule_begin_block_cond_eval(&op, ctx, cond_write_state);
-        }
-    }
-
-    /* Handle Not, Optional, Or operators */
-    if (is_not) {
-        flecs_rule_begin_block(EcsRuleNot, ctx);
-    } else if (term->oper == EcsOptional) {
-        flecs_rule_begin_block(EcsRuleOptional, ctx);
-    } else if (first_or) {
-        flecs_rule_begin_block_or(&op, term, ctx);
-    }
-
-    /* If term has component inheritance enabled, insert instruction to walk
-     * down the relationship tree of the id. */
-    if (term->flags & EcsTermIdInherited) {
-        flecs_rule_insert_inheritance(rule, term, &op, ctx, cond_write);
-    }
-
-    op.match_flags = term->flags;
-
-    if (first_is_var) {
-        op.first.var = first_var;
-        op.flags &= (ecs_flags8_t)~(EcsRuleIsEntity << EcsRuleFirst);
-        op.flags |= (EcsRuleIsVar << EcsRuleFirst);
-    }
-
-    if (term->src.flags & EcsSelf) {
-        op.flags |= EcsRuleIsSelf;
-    }
-
-    /* Insert instructions for lookup variables */
-    ecs_write_flags_t write_state = ctx->written;
-    if (first_is_var) {
-        if (flecs_rule_compile_lookup(rule, first_var, ctx, cond_write)) {
-            write_state |= (1ull << first_var); // lookups are resolved inline
-        }
-    }
-    if (src_is_var) {
-        if (flecs_rule_compile_lookup(rule, src_var, ctx, cond_write)) {
-            write_state |= (1ull << src_var); // lookups are resolved inline
-        }
-    }
-    if (second_is_var) {
-        if (flecs_rule_compile_lookup(rule, second_var, ctx, cond_write)) {
-            write_state |= (1ull << second_var); // lookups are resolved inline
-        }
-    }
-
-    if (builtin_pred) {
-        if (flecs_rule_compile_builtin_pred(rule, term, &op, write_state)) {
-            goto error;
-        }
-    }
-
-    /* If we're writing the $this variable, filter out disabled/prefab entities
-     * unless the filter explicitly matches them.
-     * This could've been done with regular With instructions, but since 
-     * filtering out disabled/prefab entities is the default and this check is
-     * cheap to perform on table flags, it's worth special casing. */
-    if (!src_written && src_var == 0) {
-        ecs_flags32_t filter_flags = filter->flags;
-        if (!(filter_flags & EcsFilterMatchDisabled) || 
-            !(filter_flags & EcsFilterMatchPrefab)) 
-        {
-            ecs_flags32_t table_flags = 0;
-            if (!(filter_flags & EcsFilterMatchDisabled)) {
-                table_flags |= EcsTableIsDisabled;
-            }
-            if (!(filter_flags & EcsFilterMatchPrefab)) {
-                table_flags |= EcsTableIsPrefab;
-            }
-
-            op.other = flecs_itolbl(table_flags);
-        }
-    }
-
-    /* After evaluating a term, a used variable is always written */
-    if (src_is_var) {
-        flecs_rule_write(src_var, &op.written);
-        flecs_rule_write_ctx(op.src.var, ctx, cond_write);
-    }
-    if (first_is_var) {
-        flecs_rule_write(first_var, &op.written);
-        flecs_rule_write_ctx(first_var, ctx, cond_write);
-    }
-    if (second_is_var) {
-        flecs_rule_write(second_var, &op.written);
-        flecs_rule_write_ctx(second_var, ctx, cond_write);
-    }
-    flecs_rule_op_insert(&op, ctx);
-
-    ctx->cur->lbl_query = flecs_itolbl(ecs_vec_count(ctx->ops) - 1);
-    if (is_or) {
-        ecs_rule_op_t *op_ptr = ecs_vec_get_t(ctx->ops, ecs_rule_op_t, 
-            ctx->cur->lbl_query);
-        op_ptr->next = FlecsRuleOrMarker;
-    }
-
-    /* Handle self-references between src and first/second variables */
-    if (src_is_var) {
-        if (first_is_var) {
-            flecs_rule_insert_contains(rule, src_var, first_var, ctx);
-        }
-        if (second_is_var && first_var != second_var) {
-            flecs_rule_insert_contains(rule, src_var, second_var, ctx);
-        }
-    }
-
-    /* Handle self references between first and second variables */
-    if (first_is_var && !first_written && (first_var == second_var)) {
-        flecs_rule_insert_pair_eq(term->field_index, ctx);
-    }
-
-    /* Handle closing of Not, Optional and Or operators */
-    if (is_not) {
-        flecs_rule_end_block(ctx);
-    } else if (term->oper == EcsOptional) {
-        flecs_rule_end_block(ctx);
-    } else if (last_or) {
-        flecs_rule_end_block_or(ctx);
-    }
-
-    /* Handle closing of conditional evaluation */
-    if (ctx->cur->lbl_cond_eval && (first_is_var || second_is_var || src_is_var)) {
-        if (!is_or || last_or) {
-            flecs_rule_end_block_cond_eval(ctx);
-        }
-    }
-
-    /* Ensure that term id is set after evaluating Not */
-    if (term->flags & EcsTermIdInherited) {
-        if (is_not) {
-            ecs_rule_op_t set_id = {0};
-            set_id.kind = EcsRuleSetId;
-            set_id.first.entity = term->id;
-            set_id.flags = (EcsRuleIsEntity << EcsRuleFirst);
-            set_id.field_index = flecs_ito(int8_t, term->field_index);
-            flecs_rule_op_insert(&set_id, ctx);
-        }
-    }
-
-    return 0;
-error:
-    return -1;
-}
-
-static
-bool flecs_rule_var_is_unknown(
-    ecs_rule_t *rule,
-    ecs_var_id_t var_id,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_rule_var_t *vars = rule->vars;
-    if (ctx->written & (1ull << var_id)) {
-        return false;
-    } else {
-        ecs_var_id_t table_var = vars[var_id].table_id;
-        if (table_var != EcsVarNone) {
-            return flecs_rule_var_is_unknown(rule, table_var, ctx);
-        }
-    }
-    return true;
-}
-
-/* Returns whether term is unkown. A term is unknown when it has variable 
- * elements (first, second, src) that are all unknown. */
-static
-bool flecs_rule_term_is_unknown(
-    ecs_rule_t *rule, 
-    ecs_term_t *term, 
-    ecs_rule_compile_ctx_t *ctx) 
-{
-    ecs_rule_op_t dummy = {0};
-    flecs_rule_compile_term_id(NULL, rule, &dummy, &term->first, 
-        &dummy.first, EcsRuleFirst, EcsVarEntity, ctx, false);
-    flecs_rule_compile_term_id(NULL, rule, &dummy, &term->second, 
-        &dummy.second, EcsRuleSecond, EcsVarEntity, ctx, false);
-    flecs_rule_compile_term_id(NULL, rule, &dummy, &term->src, 
-        &dummy.src, EcsRuleSrc, EcsVarAny, ctx, false);
-
-    bool has_vars = dummy.flags & 
-        ((EcsRuleIsVar << EcsRuleFirst) |
-         (EcsRuleIsVar << EcsRuleSecond) |
-         (EcsRuleIsVar << EcsRuleSrc));
-    if (!has_vars) {
-        /* If term has no variables (typically terms with a static src) there
-         * can't be anything that's unknown. */
-        return false;
-    }
-
-    if (dummy.flags & (EcsRuleIsVar << EcsRuleFirst)) {
-        if (!flecs_rule_var_is_unknown(rule, dummy.first.var, ctx)) {
-            return false;
-        }
-    }
-    if (dummy.flags & (EcsRuleIsVar << EcsRuleSecond)) {
-        if (!flecs_rule_var_is_unknown(rule, dummy.second.var, ctx)) {
-            return false;
-        }
-    }
-    if (dummy.flags & (EcsRuleIsVar << EcsRuleSrc)) {
-        if (!flecs_rule_var_is_unknown(rule, dummy.src.var, ctx)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/* Find the next known term from specified offset. This function is used to find
- * a term that can be evaluated before a term that is unknown. Evaluating known
- * before unknown terms can significantly decrease the search space. */
-static
-int32_t flecs_rule_term_next_known(
-    ecs_rule_t *rule, 
-    ecs_rule_compile_ctx_t *ctx,
-    int32_t offset,
-    ecs_flags64_t compiled) 
-{
-    ecs_filter_t *filter = &rule->filter;
-    ecs_term_t *terms = filter->terms;
-    int32_t i, count = filter->term_count;
-
-    for (i = offset; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (compiled & (1ull << i)) {
-            continue;
-        }
-
-        /* Only evaluate And terms */
-        if (term->oper != EcsAnd || flecs_rule_term_is_or(&rule->filter, term)){
-            continue;
-        }
-
-        /* Don't reorder terms before/after scopes */
-        if (term->first.id == EcsScopeOpen || term->first.id == EcsScopeClose) {
-            return -1;
-        }
-
-        if (flecs_rule_term_is_unknown(rule, term, ctx)) {
-            continue;
-        }
-
-        return i;
-    }
-
-    return -1;
-}
-
-/* If the first part of a query contains more than one trivial term, insert a
- * special instruction which batch-evaluates multiple terms. */
-static
-int32_t flecs_rule_insert_trivial_search(
-    ecs_rule_t *rule,
-    ecs_rule_compile_ctx_t *ctx)
-{
-    ecs_filter_t *filter = &rule->filter;
-    ecs_term_t *terms = filter->terms;
-    int32_t i, term_count = filter->term_count;
-
-    /* Find trivial terms, which can be handled in single instruction */
-    int32_t trivial_wildcard_terms = 0;
-    int32_t trivial_data_terms = 0;
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (!(term->flags & EcsTermIsTrivial)) {
-            break;
-        }
-
-        /* We can only add trivial terms to plan if they no up traversal */
-        if ((term->src.flags & EcsTraverseFlags) != EcsSelf) {
-            break;
-        }
-
-        if (ecs_id_is_wildcard(term->id)) {
-            trivial_wildcard_terms ++;
-        }
-
-        if (!(term->flags & EcsTermNoData)) {
-            trivial_data_terms ++;
-        }
-    }
-
-    int32_t trivial_terms = i;
-    if (trivial_terms >= 2) {
-        /* If there's more than 1 trivial term, batch them in trivial search */
-        ecs_rule_op_t trivial = {0};
-        if (trivial_wildcard_terms) {
-            trivial.kind = EcsRuleTrivWildcard;
-        } else {
-            if (trivial_data_terms) {
-                /* Check to see if there are remaining data terms. If there are,
-                 * we'll have to insert an instruction later that populates all
-                 * fields, so don't do double work here. */
-                for (i = trivial_terms; i < term_count; i ++) {
-                    ecs_term_t *term = &terms[i];
-                    if (!(term->flags & EcsTermIsTrivial)) {
-                        break;
-                    }
-                }
-                if (trivial_terms == term_count || i != term_count) {
-                    /* Nobody else is going to set the data fields, so we should
-                     * do it here. */
-                    trivial.kind = EcsRuleTrivData;
-                }
-            }
-            if (!trivial.kind) {
-                trivial.kind = EcsRuleTriv;
-            }
-        }
-
-        /* Store on the operation how many trivial terms should be evaluated */
-        trivial.other = (ecs_rule_lbl_t)trivial_terms;
-        flecs_rule_op_insert(&trivial, ctx);
-    } else {
-        /* If fewer than 1 trivial term, there's no point in batching them */
-        trivial_terms = 0;
-    }
-
-    return trivial_terms;
-}
-
-/* Insert instruction to populate data fields. */
-static
-void flecs_rule_insert_populate(
-    ecs_rule_t *rule,
-    ecs_rule_compile_ctx_t *ctx,
-    int32_t trivial_terms)
-{
-    ecs_filter_t *filter = &rule->filter;
-    int32_t i, term_count = filter->term_count;
-
-    /* Insert instruction that populates data. This instruction does not
-     * have to be inserted if the filter provides no data, or if all terms
-     * of the filter are trivial, in which case the trivial search operation
-     * also sets the data. */
-    if (!(filter->flags & EcsFilterNoData) && (trivial_terms != term_count)) {
-        int32_t data_fields = 0;
-        bool only_self = true;
-
-        /* There are two instructions for setting data fields, a fast one 
-         * that only supports owned fields, and one that supports any kind
-         * of field. Loop through (remaining) terms to check which one we
-         * need to use. */
-        for (i = trivial_terms; i < term_count; i ++) {
-            ecs_term_t *term = &filter->terms[i];
-            if (term->flags & EcsTermNoData) {
-                /* Don't care about terms that have no data */
-                continue;
-            }
-
-            data_fields ++;
-
-            if (!ecs_term_match_this(term)) {
-                break;
-            }
-
-            if (term->src.flags & EcsUp) {
-                break;
-            }
-        }
-
-        if (i != filter->term_count) {
-            only_self = false; /* Needs the more complex operation */
-        }
-
-        if (data_fields) {
-            if (only_self) {
-                ecs_rule_op_t nothing = {0};
-                nothing.kind = EcsRulePopulateSelf;
-                flecs_rule_op_insert(&nothing, ctx);
-            } else {
-                ecs_rule_op_t nothing = {0};
-                nothing.kind = EcsRulePopulate;
-                flecs_rule_op_insert(&nothing, ctx);
-            }
-        }
-    }
-}
-
-int flecs_rule_compile(
-    ecs_world_t *world,
-    ecs_stage_t *stage,
-    ecs_rule_t *rule)
-{
-    ecs_filter_t *filter = &rule->filter;
-    ecs_term_t *terms = filter->terms;
-    ecs_rule_compile_ctx_t ctx = {0};
-    ecs_vec_reset_t(NULL, &stage->operations, ecs_rule_op_t);
-    ctx.ops = &stage->operations;
-    ctx.cur = ctx.ctrlflow;
-    ctx.cur->lbl_begin = -1;
-    ctx.cur->lbl_begin = -1;
-    ecs_vec_clear(ctx.ops);
-
-    /* Find all variables defined in query */
-    if (flecs_rule_discover_vars(stage, rule)) {
-        return -1;
-    }
-
-    /* If rule contains fixed source terms, insert operation to set sources */
-    int32_t i, term_count = filter->term_count;
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (term->src.flags & EcsIsEntity) {
-            ecs_rule_op_t set_fixed = {0};
-            set_fixed.kind = EcsRuleSetFixed;
-            flecs_rule_op_insert(&set_fixed, &ctx);
-            break;
-        }
-    }
-
-    /* If the rule contains terms with fixed ids (no wildcards, variables), 
-     * insert instruction that initializes ecs_iter_t::ids. This allows for the
-     * insertion of simpler instructions later on. */
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (flecs_rule_term_fixed_id(filter, term) || 
-           (term->src.flags & EcsIsEntity && !term->src.id)) 
-        {
-            ecs_rule_op_t set_ids = {0};
-            set_ids.kind = EcsRuleSetIds;
-            flecs_rule_op_insert(&set_ids, &ctx);
-            break;
-        }
-    }
-
-    /* Insert trivial term search if query allows for it */
-    int32_t trivial_terms = flecs_rule_insert_trivial_search(rule, &ctx);
-
-    /* Compile remaining query terms to instructions */
-    ecs_flags64_t compiled = 0;
-    for (i = trivial_terms; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        int32_t compile = i;
-
-        if (compiled & (1ull << i)) {
-            continue; /* Already compiled */
-        }
-
-        bool can_reorder = true;
-        if (term->oper != EcsAnd || flecs_rule_term_is_or(&rule->filter, term)){
-            can_reorder = false;
-        }
-
-        /* If variables have been written, but this term has no known variables,
-         * first try to resolve terms that have known variables. This can 
-         * significantly reduce the search space. 
-         * Only perform this optimization after at least one variable has been
-         * written to, as all terms are unknown otherwise. */
-        if (can_reorder && ctx.written && 
-            flecs_rule_term_is_unknown(rule, term, &ctx)) 
-        {
-            int32_t term_index = flecs_rule_term_next_known(
-                rule, &ctx, i + 1, compiled);
-            if (term_index != -1) {
-                term = &rule->filter.terms[term_index];
-                compile = term_index;
-                i --; /* Repeat current term */
-            }
-        }
-
-        if (flecs_rule_compile_term(world, rule, term, &ctx)) {
-            return -1;
-        }
-
-        compiled |= (1ull << compile);
-    }
-
-    ecs_var_id_t this_id = flecs_rule_find_var_id(rule, "This", EcsVarEntity);
-
-    /* If This variable has been written as entity, insert an operation to 
-     * assign it to it.entities for consistency. */
-    if (this_id != EcsVarNone && (ctx.written & (1ull << this_id))) {
-        ecs_rule_op_t set_this = {0};
-        set_this.kind = EcsRuleSetThis;
-        set_this.flags |= (EcsRuleIsVar << EcsRuleFirst);
-        set_this.first.var = this_id;
-        flecs_rule_op_insert(&set_this, &ctx);
-    }
-
-    /* Make sure non-This variables are written as entities */
-    if (rule->vars) {
-        for (i = 0; i < rule->var_count; i ++) {
-            ecs_rule_var_t *var = &rule->vars[i];
-            if (var->id && var->kind == EcsVarTable && var->name) {
-                ecs_var_id_t var_id = flecs_rule_find_var_id(rule, var->name,
-                    EcsVarEntity);
-                if (!flecs_rule_is_written(var_id, ctx.written)) {
-                    /* Skip anonymous variables */
-                    if (!flecs_rule_var_is_anonymous(rule, var_id)) {
-                        flecs_rule_insert_each(var->id, var_id, &ctx, false);
-                    }
-                }
-            }
-        }
-    }
-
-    /* If rule contains non-This variables as term source, build lookup array */
-    if (rule->src_vars) {
-        ecs_assert(rule->vars != NULL, ECS_INTERNAL_ERROR, NULL);
-        bool only_anonymous = true;
-
-        for (i = 0; i < filter->field_count; i ++) {
-            ecs_var_id_t var_id = rule->src_vars[i];
-            if (!var_id) {
-                continue;
-            }
-
-            if (!flecs_rule_var_is_anonymous(rule, var_id)) {
-                only_anonymous = false;
-                break;
-            } else {
-                /* Don't fetch component data for anonymous variables. Because
-                 * not all metadata (such as it.sources) is initialized for
-                 * anonymous variables, and because they may only be available
-                 * as table variables (each is not guaranteed to be inserted for
-                 * anonymous variables) the iterator may not have sufficient
-                 * information to resolve component data. */
-                for (int32_t t = 0; t < filter->term_count; t ++) {
-                    ecs_term_t *term = &filter->terms[t];
-                    if (term->field_index == i) {
-                        term->inout = EcsInOutNone;
-                    }
-                }
-            }
-        }
-
-        /* Don't insert setvar instruction if all vars are anonymous */
-        if (!only_anonymous) {
-            ecs_rule_op_t set_vars = {0};
-            set_vars.kind = EcsRuleSetVars;
-            flecs_rule_op_insert(&set_vars, &ctx);
-        }
-
-        for (i = 0; i < filter->field_count; i ++) {
-            ecs_var_id_t var_id = rule->src_vars[i];
-            if (!var_id) {
-                continue;
-            }
-
-            if (rule->vars[var_id].kind == EcsVarTable) {
-                var_id = flecs_rule_find_var_id(rule, rule->vars[var_id].name,
-                    EcsVarEntity);
-
-                /* Variables used as source that aren't This must be entities */
-                ecs_assert(var_id != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
-            }
-
-            rule->src_vars[i] = var_id;
-        }
-    }
-
-    /* If filter is empty, insert Nothing instruction */
-    if (!term_count) {
-        ecs_rule_op_t nothing = {0};
-        nothing.kind = EcsRuleNothing;
-        flecs_rule_op_insert(&nothing, &ctx);
-    } else {
-        /* Insert instruction to populate data fields */
-        flecs_rule_insert_populate(rule, &ctx, trivial_terms);
-
-        /* Insert yield. If program reaches this operation, a result was found */
-        ecs_rule_op_t yield = {0};
-        yield.kind = EcsRuleYield;
-        flecs_rule_op_insert(&yield, &ctx);
-    }
-
-    int32_t op_count = ecs_vec_count(ctx.ops);
-    if (op_count) {
-        rule->op_count = op_count;
-        rule->ops = ecs_os_malloc_n(ecs_rule_op_t, op_count);
-        ecs_rule_op_t *rule_ops = ecs_vec_first_t(ctx.ops, ecs_rule_op_t);
-        ecs_os_memcpy_n(rule->ops, rule_ops, ecs_rule_op_t, op_count);
-    }
-
-    return 0;
-}
-
-#endif
diff --git a/src/addons/rules/engine.c b/src/addons/rules/engine.c
deleted file mode 100644
index edd2d07b3..000000000
--- a/src/addons/rules/engine.c
+++ /dev/null
@@ -1,2793 +0,0 @@
-/**
- * @file addons/rules/engine.c
- * @brief Rules engine implementation.
- */
-
-#include "rules.h"
-
-#ifdef FLECS_RULES
-
-static
-bool flecs_rule_dispatch(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx);
-
-static
-bool flecs_rule_run_until(
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    const ecs_rule_op_t *ops,
-    ecs_rule_lbl_t first,
-    ecs_rule_lbl_t cur,
-    ecs_rule_op_kind_t until);
-
-ecs_allocator_t* flecs_rule_get_allocator(
-    const ecs_iter_t *it)
-{
-    ecs_world_t *world = it->world;
-    if (ecs_poly_is(world, ecs_world_t)) {
-        return &world->allocator;
-    } else {
-        ecs_assert(ecs_poly_is(world, ecs_stage_t), ECS_INTERNAL_ERROR, NULL);
-        return &((ecs_stage_t*)world)->allocator;
-    }
-}
-
-static
-ecs_rule_op_ctx_t* flecs_op_ctx_(
-    const ecs_rule_run_ctx_t *ctx)
-{
-    return &ctx->op_ctx[ctx->op_index];
-}
-
-#define flecs_op_ctx(ctx, op_kind) (&flecs_op_ctx_(ctx)->is.op_kind)
-
-static
-void flecs_reset_source_set_flag(
-    const ecs_rule_run_ctx_t *ctx,
-    int32_t field_index)
-{
-    ecs_assert(field_index != -1, ECS_INTERNAL_ERROR, NULL);
-    (*ctx->source_set) &= ~(1u << field_index);
-}
-
-static
-void flecs_set_source_set_flag(
-    const ecs_rule_run_ctx_t *ctx,
-    int32_t field_index)
-{
-    ecs_assert(field_index != -1, ECS_INTERNAL_ERROR, NULL);
-    (*ctx->source_set) |= (1u << field_index);
-}
-
-static
-ecs_table_range_t flecs_range_from_entity(
-    ecs_entity_t e,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_record_t *r = flecs_entities_get(ctx->world, e);
-    if (!r) {
-        return (ecs_table_range_t){ 0 };
-    }
-    return (ecs_table_range_t){
-        .table = r->table,
-        .offset = ECS_RECORD_TO_ROW(r->row),
-        .count = 1
-    };
-}
-
-static
-ecs_table_range_t flecs_rule_var_get_range(
-    int32_t var_id,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_assert(var_id < ctx->rule->var_count, ECS_INTERNAL_ERROR, NULL);
-    ecs_var_t *var = &ctx->vars[var_id];
-    ecs_table_t *table = var->range.table;
-    if (table) {
-        return var->range;
-    }
-
-    ecs_entity_t entity = var->entity;
-    if (entity && entity != EcsWildcard) {
-        var->range = flecs_range_from_entity(entity, ctx);
-        return var->range;
-    }
-
-    return (ecs_table_range_t){ 0 };
-}
-
-static
-ecs_table_t* flecs_rule_var_get_table(
-    int32_t var_id,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_var_t *var = &ctx->vars[var_id];
-    ecs_table_t *table = var->range.table;
-    if (table) {
-        return table;
-    }
-
-    ecs_entity_t entity = var->entity;
-    if (entity && entity != EcsWildcard) {
-        var->range = flecs_range_from_entity(entity, ctx);
-        return var->range.table;
-    }
-
-    return NULL;
-}
-
-static
-ecs_table_t* flecs_rule_get_table(
-    const ecs_rule_op_t *op,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t flags = flecs_rule_ref_flags(op->flags, ref_kind);
-    if (flags & EcsRuleIsEntity) {
-        return ecs_get_table(ctx->world, ref->entity);
-    } else {
-        return flecs_rule_var_get_table(ref->var, ctx);
-    }
-}
-
-static
-ecs_table_range_t flecs_rule_get_range(
-    const ecs_rule_op_t *op,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t flags = flecs_rule_ref_flags(op->flags, ref_kind);
-    if (flags & EcsRuleIsEntity) {
-        ecs_assert(!(flags & EcsRuleIsVar), ECS_INTERNAL_ERROR, NULL);
-        return flecs_range_from_entity(ref->entity, ctx);
-    } else {
-        ecs_var_t *var = &ctx->vars[ref->var];
-        if (var->range.table) {
-            return ctx->vars[ref->var].range;
-        } else if (var->entity) {
-            return flecs_range_from_entity(var->entity, ctx);
-        }
-    }
-    return (ecs_table_range_t){0};
-}
-
-static
-ecs_entity_t flecs_rule_var_get_entity(
-    ecs_var_id_t var_id,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_assert(var_id < (ecs_var_id_t)ctx->rule->var_count, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_var_t *var = &ctx->vars[var_id];
-    ecs_entity_t entity = var->entity;
-    if (entity) {
-        return entity;
-    }
-
-    ecs_assert(var->range.count == 1, ECS_INTERNAL_ERROR, NULL);
-    ecs_table_t *table = var->range.table;
-    ecs_entity_t *entities = table->data.entities.array;
-    var->entity = entities[var->range.offset];
-    return var->entity;
-}
-
-static
-void flecs_rule_var_reset(
-    ecs_var_id_t var_id,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ctx->vars[var_id].entity = EcsWildcard;
-    ctx->vars[var_id].range.table = NULL;
-}
-
-static
-void flecs_rule_var_set_table(
-    const ecs_rule_op_t *op,
-    ecs_var_id_t var_id,
-    ecs_table_t *table,
-    int32_t offset,
-    int32_t count,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    ecs_assert(ctx->rule_vars[var_id].kind == EcsVarTable, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(flecs_rule_is_written(var_id, op->written), 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_var_t *var = &ctx->vars[var_id];
-    var->entity = 0;
-    var->range = (ecs_table_range_t){ 
-        .table = table,
-        .offset = offset,
-        .count = count
-    };
-}
-
-static
-void flecs_rule_var_set_entity(
-    const ecs_rule_op_t *op,
-    ecs_var_id_t var_id,
-    ecs_entity_t entity,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    ecs_assert(var_id < (ecs_var_id_t)ctx->rule->var_count, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(flecs_rule_is_written(var_id, op->written), 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_var_t *var = &ctx->vars[var_id];
-    var->range.table = NULL;
-    var->entity = entity;
-}
-
-static
-void flecs_rule_set_vars(
-    const ecs_rule_op_t *op,
-    ecs_id_t id,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t flags_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t flags_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
-
-    if (flags_1st & EcsRuleIsVar) {
-        ecs_var_id_t var = op->first.var;
-        if (op->written & (1ull << var)) {
-            if (ECS_IS_PAIR(id)) {
-                flecs_rule_var_set_entity(
-                    op, var, ecs_get_alive(ctx->world, ECS_PAIR_FIRST(id)), ctx);
-            } else {
-                flecs_rule_var_set_entity(op, var, id, ctx);
-            }
-        }
-    }
-    if (flags_2nd & EcsRuleIsVar) {
-        ecs_var_id_t var = op->second.var;
-        if (op->written & (1ull << var)) {
-            flecs_rule_var_set_entity(
-                op, var, ecs_get_alive(ctx->world, ECS_PAIR_SECOND(id)), ctx);
-        }
-    }
-}
-
-static
-ecs_table_range_t flecs_get_ref_range(
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t flag,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (flag & EcsRuleIsEntity) {
-        return flecs_range_from_entity(ref->entity, ctx);
-    } else if (flag & EcsRuleIsVar) {
-        return flecs_rule_var_get_range(ref->var, ctx);
-    }
-    return (ecs_table_range_t){0};
-}
-
-static
-ecs_entity_t flecs_get_ref_entity(
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t flag,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (flag & EcsRuleIsEntity) {
-        return ref->entity;
-    } else if (flag & EcsRuleIsVar) {
-        return flecs_rule_var_get_entity(ref->var, ctx);
-    }
-    return 0;
-}
-
-static
-ecs_id_t flecs_rule_op_get_id_w_written(
-    const ecs_rule_op_t *op,
-    uint64_t written,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t flags_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t flags_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
-    ecs_entity_t first = 0, second = 0;
-
-    if (flags_1st) {
-        if (flecs_ref_is_written(op, &op->first, EcsRuleFirst, written)) {
-            first = flecs_get_ref_entity(&op->first, flags_1st, ctx);
-        } else if (flags_1st & EcsRuleIsVar) {
-            first = EcsWildcard;
-        }
-    }
-    if (flags_2nd) {
-        if (flecs_ref_is_written(op, &op->second, EcsRuleSecond, written)) {
-            second = flecs_get_ref_entity(&op->second, flags_2nd, ctx);
-        } else if (flags_2nd & EcsRuleIsVar) {
-            second = EcsWildcard;
-        }
-    }
-
-    if (flags_2nd & (EcsRuleIsVar | EcsRuleIsEntity)) {
-        return ecs_pair(first, second);
-    } else {
-        return flecs_entities_get_alive(ctx->world, first);
-    }
-}
-
-static
-ecs_id_t flecs_rule_op_get_id(
-    const ecs_rule_op_t *op,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    return flecs_rule_op_get_id_w_written(op, written, ctx);
-}
-
-static
-int16_t flecs_rule_next_column(
-    ecs_table_t *table,
-    ecs_id_t id,
-    int32_t column)
-{
-    if (!ECS_IS_PAIR(id) || (ECS_PAIR_FIRST(id) != EcsWildcard)) {
-        column = column + 1;
-    } else {
-        ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
-        column = ecs_search_offset(NULL, table, column + 1, id, NULL);
-        ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL);
-    }
-    return flecs_ito(int16_t, column);
-}
-
-static
-void flecs_rule_it_set_column(
-    ecs_iter_t *it,
-    int32_t field_index,
-    int32_t column)
-{
-    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(field_index >= 0, ECS_INTERNAL_ERROR, NULL);
-    it->columns[field_index] = column + 1;
-}
-
-static
-ecs_id_t flecs_rule_it_set_id(
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    int32_t field_index,
-    int32_t column)
-{
-    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(field_index >= 0, ECS_INTERNAL_ERROR, NULL);
-    return it->ids[field_index] = table->type.array[column];
-}
-
-static
-void flecs_rule_set_match(
-    const ecs_rule_op_t *op,
-    ecs_table_t *table,
-    int32_t column,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
-    int32_t field_index = op->field_index;
-    if (field_index == -1) {
-        return;
-    }
-
-    ecs_iter_t *it = ctx->it;
-    flecs_rule_it_set_column(it, field_index, column);
-    ecs_id_t matched = flecs_rule_it_set_id(it, table, field_index, column);
-    flecs_rule_set_vars(op, matched, ctx);
-}
-
-static
-void flecs_rule_set_trav_match(
-    const ecs_rule_op_t *op,
-    int32_t column,
-    ecs_entity_t trav,
-    ecs_entity_t second,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    int32_t field_index = op->field_index;
-    if (field_index == -1) {
-        return;
-    }
-
-    ecs_iter_t *it = ctx->it;
-    ecs_id_t matched = ecs_pair(trav, second);
-    it->ids[op->field_index] = matched;
-    if (column != -1) {
-        flecs_rule_it_set_column(it, op->field_index, column);
-    }
-    flecs_rule_set_vars(op, matched, ctx);
-}
-
-static
-bool flecs_rule_table_filter(
-    ecs_table_t *table,
-    ecs_rule_lbl_t other,
-    ecs_flags32_t filter_mask)
-{
-    uint32_t filter = flecs_ito(uint32_t, other);
-    return (table->flags & filter_mask & filter) != 0;
-}
-
-static
-bool flecs_rule_select_w_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_id_t id,
-    ecs_flags32_t filter_mask)
-{
-    ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-    ecs_id_record_t *idr = op_ctx->idr;
-    ecs_table_record_t *tr;
-    ecs_table_t *table;
-
-    if (!redo) {
-        if (!idr || idr->id != id) {
-            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
-            if (!idr) {
-                return false;
-            }
-        }
-
-        if (ctx->rule->filter.flags & EcsFilterMatchEmptyTables) {
-            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)) {
-                return false;
-            }
-        } else {
-            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
-                return false;
-            }
-        }
-    }
-
-repeat:
-    if (!redo || !op_ctx->remaining) {
-        tr = flecs_table_cache_next(&op_ctx->it, ecs_table_record_t);
-        if (!tr) {
-            return false;
-        }
-
-        op_ctx->column = flecs_ito(int16_t, tr->index);
-        op_ctx->remaining = flecs_ito(int16_t, tr->count - 1);
-        table = tr->hdr.table;
-        flecs_rule_var_set_table(op, op->src.var, table, 0, 0, ctx);
-    } else {
-        tr = (ecs_table_record_t*)op_ctx->it.cur;
-        ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-        table = tr->hdr.table;
-        op_ctx->column = flecs_rule_next_column(table, idr->id, op_ctx->column);
-        op_ctx->remaining --;
-    }
-
-    if (flecs_rule_table_filter(table, op->other, filter_mask)) {
-        goto repeat;
-    }
-
-    flecs_rule_set_match(op, table, op_ctx->column, ctx);
-    return true;
-}
-
-static
-bool flecs_rule_select(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_id_t id = 0;
-    if (!redo) {
-        id = flecs_rule_op_get_id(op, ctx);
-    }
-    return flecs_rule_select_w_id(op, redo, ctx, id, 
-        (EcsTableIsPrefab|EcsTableIsDisabled));
-}
-
-static
-bool flecs_rule_with(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-    ecs_id_record_t *idr = op_ctx->idr;
-    const ecs_table_record_t *tr;
-
-    ecs_table_t *table = flecs_rule_get_table(op, &op->src, EcsRuleSrc, ctx);
-    if (!table) {
-        return false;
-    }
-
-    if (!redo) {
-        ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-        if (!idr || idr->id != id) {
-            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
-            if (!idr) {
-                return false;
-            }
-        }
-
-        tr = flecs_id_record_get_table(idr, table);
-        if (!tr) {
-            return false;
-        }
-
-        op_ctx->column = flecs_ito(int16_t, tr->index);
-        op_ctx->remaining = flecs_ito(int16_t, tr->count);
-    } else {
-        if (--op_ctx->remaining <= 0) {
-            return false;
-        }
-
-        op_ctx->column = flecs_rule_next_column(table, idr->id, op_ctx->column);
-        ecs_assert(op_ctx->column != -1, ECS_INTERNAL_ERROR, NULL);
-    }
-
-    flecs_rule_set_match(op, table, op_ctx->column, ctx);
-    return true;
-}
-
-static
-bool flecs_rule_and(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (written & (1ull << op->src.var)) {
-        return flecs_rule_with(op, redo, ctx);
-    } else {
-        return flecs_rule_select(op, redo, ctx);
-    }
-}
-
-static
-bool flecs_rule_select_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_flags32_t table_filter)
-{
-    ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-    ecs_iter_t *it = ctx->it;
-    int8_t field = op->field_index;
-    ecs_assert(field != -1, ECS_INTERNAL_ERROR, NULL);
-
-    if (!redo) {
-        ecs_id_t id = it->ids[field];
-        ecs_id_record_t *idr = op_ctx->idr;
-        if (!idr || idr->id != id) {
-            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
-            if (!idr) {
-                return false;
-            }
-        }
-
-        if (ctx->rule->filter.flags & EcsFilterMatchEmptyTables) {
-            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)) {
-                return false;
-            }
-        } else {
-            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
-                return false;
-            }
-        }
-    }
-
-repeat: {}
-    const ecs_table_record_t *tr = flecs_table_cache_next(
-        &op_ctx->it, ecs_table_record_t);
-    if (!tr) {
-        return false;
-    }
-
-    ecs_table_t *table = tr->hdr.table;
-    if (flecs_rule_table_filter(table, op->other, table_filter)) {
-        goto repeat;
-    }
-
-    flecs_rule_var_set_table(op, op->src.var, table, 0, 0, ctx);
-    flecs_rule_it_set_column(it, field, tr->index);
-    return true;
-}
-
-static
-bool flecs_rule_with_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (redo) {
-        return false;
-    }
-
-    ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-    ecs_iter_t *it = ctx->it;
-    int8_t field = op->field_index;
-    ecs_assert(field != -1, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_table_t *table = flecs_rule_get_table(op, &op->src, EcsRuleSrc, ctx);
-    if (!table) {
-        return false;
-    }
-
-    ecs_id_t id = it->ids[field];
-    ecs_id_record_t *idr = op_ctx->idr;
-    if (!idr || idr->id != id) {
-        idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
-        if (!idr) {
-            return false;
-        }
-    }
-
-    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-    if (!tr) {
-        return false;
-    }
-
-    flecs_rule_it_set_column(it, field, tr->index);
-    return true;
-}
-
-static
-bool flecs_rule_and_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (written & (1ull << op->src.var)) {
-        return flecs_rule_with_id(op, redo, ctx);
-    } else {
-        return flecs_rule_select_id(op, redo, ctx, 
-            (EcsTableIsPrefab|EcsTableIsDisabled));
-    }
-}
-
-static
-bool flecs_rule_up_select(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx,
-    bool self,
-    bool id_only)
-{
-    ecs_rule_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
-    ecs_world_t *world = ctx->world;
-    ecs_iter_t *it = ctx->it;
-    bool redo_select = redo;
-    const ecs_filter_t *filter = &ctx->rule->filter;
-
-    /* Early out if traversal relationship doesn't exist */
-    op_ctx->trav = filter->terms[op->term_index].src.trav;
-    if (!op_ctx->idr_trav) {
-        op_ctx->idr_trav = flecs_id_record_get(ctx->world, 
-            ecs_pair(op_ctx->trav, EcsWildcard));
-    }
-    if (!op_ctx->idr_trav || !flecs_table_cache_count(&op_ctx->idr_trav->cache)){
-        if (!self) {
-            return false;
-        } else if (id_only) {
-            return flecs_rule_select_id(op, redo, ctx,
-                (EcsTableIsPrefab|EcsTableIsDisabled));
-        } else {
-            return flecs_rule_select(op, redo, ctx);
-        }
-    }
-
-    if (!redo) {
-        op_ctx->with = flecs_rule_op_get_id(op, ctx);
-        op_ctx->idr_with = flecs_id_record_get(ctx->world, op_ctx->with);
-        if (!op_ctx->idr_with) {
-            return false;
-        }
-
-        op_ctx->down = NULL;
-        op_ctx->cache_elem = 0;
-    }
-
-    ecs_trav_down_t *down = op_ctx->down;
-
-    do {
-        while (!down) {
-            ecs_table_t *table = op_ctx->table;
-            if (!table) {
-                ecs_table_range_t range;
-                it->sources[op->field_index] = 0;
-                do {
-                    bool result;
-                    if (id_only) {
-                        result = flecs_rule_select_id(op, redo_select, ctx, 0);
-                    } else {
-                        result = flecs_rule_select_w_id(op, redo_select, ctx, 
-                            op_ctx->with, 0);
-                    }
-                    if (!result) {
-                        return false;
-                    }
-
-                    redo_select = true;
-
-                    range = flecs_rule_get_range(
-                        op, &op->src, EcsRuleSrc, ctx);
-                    ecs_assert(range.table != NULL, ECS_INTERNAL_ERROR, NULL);
-                } while (!self && range.table->_->traversable_count == 0);
-
-                if (!range.count) {
-                    range.count = ecs_table_count(range.table);
-                }
-
-                table = op_ctx->table = range.table;
-                op_ctx->row = range.offset;
-                op_ctx->end = range.offset + range.count;
-                op_ctx->matched = it->ids[op->field_index];
-
-                if (self) {
-                    if (!flecs_rule_table_filter(table, op->other, 
-                        (EcsTableIsPrefab|EcsTableIsDisabled)))
-                    {
-                        flecs_reset_source_set_flag(ctx, op->field_index);
-                        op_ctx->row --;
-                        return true;
-                    }
-                }
-
-                redo_select = true;
-            } else {
-                op_ctx->row ++;
-            }
-
-            if (table->_->traversable_count == 0) {
-                op_ctx->table = NULL;
-                continue;
-            } else {
-                int32_t row;
-                ecs_entity_t entity = 0;
-                ecs_entity_t *entities = flecs_table_entities_array(table);
-
-                for (row = op_ctx->row; row < op_ctx->end; row ++) {
-                    entity = entities[row];
-                    ecs_record_t *record = flecs_entities_get(world, entity);
-                    if (record->row & EcsEntityIsTraversable) {
-                        it->sources[op->field_index] = entity;
-                        break;
-                    }
-                }
-
-                if (row == op_ctx->end) {
-                    op_ctx->table = NULL;
-                    continue;
-                }
-
-                down = op_ctx->down = flecs_rule_get_down_cache(ctx, &op_ctx->cache, 
-                    op_ctx->trav, entity, op_ctx->idr_with, self);
-                op_ctx->cache_elem = -1;
-            }
-        }
-
-next_elem:
-        if ((++ op_ctx->cache_elem) >= ecs_vec_count(&down->elems)) {
-            down = NULL;
-            continue;
-        }
-
-        ecs_trav_down_elem_t *elem = ecs_vec_get_t(
-            &down->elems, ecs_trav_down_elem_t, op_ctx->cache_elem);
-
-        flecs_rule_var_set_table(op, op->src.var, elem->table, 0, 0, ctx);
-        flecs_rule_set_vars(op, op_ctx->matched, ctx);
-
-        if (flecs_rule_table_filter(elem->table, op->other, 
-            (EcsTableIsPrefab|EcsTableIsDisabled)))
-        {
-            goto next_elem;
-        }
-
-        break;
-    } while (true);
-
-    flecs_set_source_set_flag(ctx, op->field_index);
-
-    return true;
-}
-
-static
-bool flecs_rule_up_with(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    const ecs_filter_t *filter = &ctx->rule->filter;
-    ecs_rule_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
-    ecs_iter_t *it = ctx->it;
-
-    /* Early out if traversal relationship doesn't exist */
-    op_ctx->trav = filter->terms[op->term_index].src.trav;
-    if (!op_ctx->idr_trav) {
-        op_ctx->idr_trav = flecs_id_record_get(ctx->world, 
-            ecs_pair(op_ctx->trav, EcsWildcard));
-    }
-    if (!op_ctx->idr_trav || !flecs_table_cache_count(&op_ctx->idr_trav->cache)){
-        return false;
-    }
-
-    if (!redo) {
-        op_ctx->trav = filter->terms[op->term_index].src.trav;
-        op_ctx->with = flecs_rule_op_get_id(op, ctx);
-        op_ctx->idr_with = flecs_id_record_get(ctx->world, op_ctx->with);
-
-        if (!op_ctx->idr_with) {
-            return false;
-        }
-
-        ecs_table_range_t range = flecs_rule_get_range(
-            op, &op->src, EcsRuleSrc, ctx);
-        if (!range.table) {
-            return false;
-        }
-
-        ecs_trav_up_t *up = flecs_rule_get_up_cache(ctx, &op_ctx->cache, 
-            range.table, op_ctx->with, op_ctx->trav, op_ctx->idr_with,
-            op_ctx->idr_trav);
-
-        if (!up) {
-            return false;
-        }
-
-        it->sources[op->field_index] = flecs_entities_get_alive(
-            ctx->world, up->src);
-        it->columns[op->field_index] = up->column + 1;
-        it->ids[op->field_index] = up->id;
-        flecs_rule_set_vars(op, up->id, ctx);
-        flecs_set_source_set_flag(ctx, op->field_index);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-static
-bool flecs_rule_self_up_with(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx,
-    bool id_only)
-{
-    if (!redo) {
-        bool result;
-        if (id_only) {
-            result = flecs_rule_with_id(op, redo, ctx);
-        } else {
-            result = flecs_rule_with(op, redo, ctx);
-        }
-        if (result) {
-            ecs_rule_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
-            op_ctx->trav = 0;
-            if (flecs_rule_ref_flags(op->flags, EcsRuleSrc) & EcsRuleIsVar) {
-                ecs_iter_t *it = ctx->it;
-                it->sources[op->field_index] = 0;
-            }
-            return true;
-        }
-
-        flecs_reset_source_set_flag(ctx, op->field_index);
-
-        return flecs_rule_up_with(op, redo, ctx);
-    } else {
-        ecs_rule_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
-        if (op_ctx->trav == 0) {
-            return flecs_rule_with(op, redo, ctx);
-        }
-    }
-
-    return false;
-}
-
-static
-bool flecs_rule_up(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        return flecs_rule_up_with(op, redo, ctx);
-    } else {
-        return flecs_rule_up_select(op, redo, ctx, false, false);
-    }
-}
-
-static
-bool flecs_rule_self_up(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        return flecs_rule_self_up_with(op, redo, ctx, false);
-    } else {
-        return flecs_rule_up_select(op, redo, ctx, true, false);
-    }
-}
-
-static
-bool flecs_rule_up_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        return flecs_rule_up_with(op, redo, ctx);
-    } else {
-        return flecs_rule_up_select(op, redo, ctx, false, true);
-    }
-}
-
-static
-bool flecs_rule_self_up_id(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        return flecs_rule_self_up_with(op, redo, ctx, true);
-    } else {
-        return flecs_rule_up_select(op, redo, ctx, true, true);
-    }
-}
-
-static
-bool flecs_rule_select_any(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    return flecs_rule_select_w_id(op, redo, ctx, EcsAny, 
-        (EcsTableIsPrefab|EcsTableIsDisabled));
-}
-
-static
-bool flecs_rule_and_any(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t match_flags = op->match_flags;
-    if (redo) {
-        if (match_flags & EcsTermMatchAnySrc) {
-            return false;
-        }
-    }
-
-    uint64_t written = ctx->written[ctx->op_index];
-    int32_t remaining = 1;
-    bool result;
-    if (flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        result = flecs_rule_with(op, redo, ctx);
-    } else {
-        result = flecs_rule_select(op, redo, ctx);
-        remaining = 0;
-    }
-
-    if (!redo) {
-        ecs_rule_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
-        if (match_flags & EcsTermMatchAny && op_ctx->remaining) {
-            op_ctx->remaining = flecs_ito(int16_t, remaining);
-        }
-    }
-
-    int32_t field = op->field_index;
-    if (field != -1) {
-        ctx->it->ids[field] = flecs_rule_op_get_id(op, ctx);
-    }
-
-    return result;
-}
-
-static
-bool flecs_rule_triv(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
-    int32_t until = flecs_ito(int32_t, op->other);
-    uint64_t written = ctx->written[ctx->op_index];
-    ctx->written[ctx->op_index + 1] |= 1ull;
-    if (written & 1ull) {
-        return flecs_rule_trivial_test(ctx->rule, ctx, !redo, until);
-    } else {
-        return flecs_rule_trivial_search_nodata(ctx->rule, ctx, op_ctx, !redo, until);
-    }
-}
-
-static
-bool flecs_rule_triv_data(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
-    int32_t until = flecs_ito(int32_t, op->other);
-    uint64_t written = ctx->written[ctx->op_index];
-    ctx->written[ctx->op_index + 1] |= 1ull;
-    if (written & 1ull) {
-        return flecs_rule_trivial_test(ctx->rule, ctx, !redo, until);
-    } else {
-        return flecs_rule_trivial_search(ctx->rule, ctx, op_ctx, !redo, until);
-    }
-}
-
-static
-bool flecs_rule_triv_wildcard(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
-    int32_t until = flecs_ito(int32_t, op->other);
-    uint64_t written = ctx->written[ctx->op_index];
-    ctx->written[ctx->op_index + 1] |= 1ull;
-    if (written & 1ull) {
-        return flecs_rule_trivial_test_w_wildcards(ctx->rule, ctx, !redo, until);
-    } else {
-        return flecs_rule_trivial_search_w_wildcards(ctx->rule, ctx, op_ctx, !redo, until);
-    }
-}
-
-static
-bool flecs_rule_trav_fixed_src_reflexive(
-    const ecs_rule_op_t *op,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_table_range_t *range,
-    ecs_entity_t trav,
-    ecs_entity_t second)
-{
-    ecs_table_t *table = range->table;
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_entity_t *entities = table->data.entities.array;
-    int32_t count = range->count;
-    if (!count) {
-        count = ecs_table_count(table);
-    }
-
-    int32_t i = range->offset, end = i + count;
-    for (; i < end; i ++) {
-        if (entities[i] == second) {
-            /* Even though table doesn't have the specific relationship 
-             * pair, the relationship is reflexive and the target entity
-             * is stored in the table. */
-            break;
-        }
-    }
-    if (i == end) {
-        /* Table didn't contain target entity */
-        return false;
-    }
-    if (count > 1) {
-        /* If the range contains more than one entity, set the range to
-         * return only the entity matched by the reflexive property. */
-        ecs_assert(flecs_rule_ref_flags(op->flags, EcsRuleSrc) & EcsRuleIsVar, 
-            ECS_INTERNAL_ERROR, NULL);
-        ecs_var_t *var = &ctx->vars[op->src.var];
-        ecs_table_range_t *var_range = &var->range;
-        var_range->offset = i;
-        var_range->count = 1;
-        var->entity = entities[i];
-    }
-
-    flecs_rule_set_trav_match(op, -1, trav, second, ctx);
-    return true;
-}
-
-static
-bool flecs_rule_trav_unknown_src_reflexive(
-    const ecs_rule_op_t *op,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_entity_t trav,
-    ecs_entity_t second)
-{
-    ecs_assert(flecs_rule_ref_flags(op->flags, EcsRuleSrc) & EcsRuleIsVar,
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_var_id_t src_var = op->src.var;
-    flecs_rule_var_set_entity(op, src_var, second, ctx);
-    flecs_rule_var_get_table(src_var, ctx);
-    flecs_rule_set_trav_match(op, -1, trav, second, ctx);
-    return true;
-}
-
-static
-bool flecs_rule_trav_fixed_src_up_fixed_second(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (redo) {
-        return false; /* If everything's fixed, can only have a single result */
-    }
-
-    ecs_flags16_t f_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t f_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
-    ecs_flags16_t f_src = flecs_rule_ref_flags(op->flags, EcsRuleSrc);
-    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
-    ecs_entity_t second = flecs_get_ref_entity(&op->second, f_2nd, ctx);
-    ecs_table_range_t range = flecs_get_ref_range(&op->src, f_src, ctx);
-    ecs_table_t *table = range.table;
-
-    /* Check if table has transitive relationship by traversing upwards */
-    int32_t column = ecs_search_relation(ctx->world, table, 0, 
-        ecs_pair(trav, second), trav, EcsSelf|EcsUp, NULL, NULL, NULL);
-    if (column == -1) {
-        if (op->match_flags & EcsTermReflexive) {
-            return flecs_rule_trav_fixed_src_reflexive(op, ctx,
-                &range, trav, second);
-        } else {
-            return false;
-        }
-    }
-
-    flecs_rule_set_trav_match(op, column, trav, second, ctx);
-    return true;
-}
-
-static
-bool flecs_rule_trav_unknown_src_up_fixed_second(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t f_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t f_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
-    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
-    ecs_entity_t second = flecs_get_ref_entity(&op->second, f_2nd, ctx);
-    ecs_rule_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
-
-    if (!redo) {
-        ecs_record_t *r_second = flecs_entities_get(ctx->world, second);
-        bool traversable = r_second && r_second->row & EcsEntityIsTraversable;
-        bool reflexive = op->match_flags & EcsTermReflexive;
-        if (!traversable && !reflexive) {
-            trav_ctx->cache.id = 0;
-
-            /* If there's no record for the entity, it can't have a subtree so
-             * forward operation to a regular select. */
-            return flecs_rule_select(op, redo, ctx);
-        }
-
-        /* Entity is traversable, which means it could have a subtree */
-        flecs_rule_get_trav_down_cache(ctx, &trav_ctx->cache, trav, second);
-        trav_ctx->index = 0;
-
-        if (op->match_flags & EcsTermReflexive) {
-            trav_ctx->index = -1;
-            return flecs_rule_trav_unknown_src_reflexive(
-                op, ctx, trav, second);
-        }
-    } else {
-        if (!trav_ctx->cache.id) {
-            /* No traversal cache, which means this is a regular select */
-            return flecs_rule_select(op, redo, ctx);
-        }
-    }
-
-    if (trav_ctx->index == -1) {
-        redo = false; /* First result after handling reflexive relationship */
-        trav_ctx->index = 0;
-    }
-
-    /* Forward to select */
-    int32_t count = ecs_vec_count(&trav_ctx->cache.entities);
-    ecs_trav_elem_t *elems = ecs_vec_first(&trav_ctx->cache.entities);
-    for (; trav_ctx->index < count; trav_ctx->index ++) {
-        ecs_trav_elem_t *el = &elems[trav_ctx->index];
-        trav_ctx->and.idr = el->idr; /* prevents lookup by select */
-        if (flecs_rule_select_w_id(op, redo, ctx, ecs_pair(trav, el->entity),
-            (EcsTableIsPrefab|EcsTableIsDisabled))) 
-        {
-            return true;
-        }
-        
-        redo = false;
-    }
-
-    return false;
-}
-
-static
-bool flecs_rule_trav_yield_reflexive_src(
-    const ecs_rule_op_t *op,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_table_range_t *range,
-    ecs_entity_t trav)
-{
-    ecs_var_t *vars = ctx->vars;
-    ecs_rule_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
-    int32_t offset = trav_ctx->offset, count = trav_ctx->count;
-    bool src_is_var = op->flags & (EcsRuleIsVar << EcsRuleSrc);
-
-    if (trav_ctx->index >= (offset + count)) {
-        /* Restore previous offset, count */
-        if (src_is_var) {
-            ecs_var_id_t src_var = op->src.var;
-            vars[src_var].range.offset = offset;
-            vars[src_var].range.count = count;
-            vars[src_var].entity = 0;
-        }
-        return false;
-    }
-
-    ecs_entity_t entity = ecs_vec_get_t(
-        &range->table->data.entities, ecs_entity_t, trav_ctx->index)[0];
-    flecs_rule_set_trav_match(op, -1, trav, entity, ctx);
-
-    /* Hijack existing variable to return one result at a time */
-    if (src_is_var) {
-        ecs_var_id_t src_var = op->src.var;
-        ecs_table_t *table = vars[src_var].range.table;
-        ecs_assert(!table || table == ecs_get_table(ctx->world, entity),
-            ECS_INTERNAL_ERROR, NULL);
-        (void)table;
-        vars[src_var].entity = entity;
-        vars[src_var].range = flecs_range_from_entity(entity, ctx);
-    }
-
-    return true;
-}
-
-static
-bool flecs_rule_trav_fixed_src_up_unknown_second(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_flags16_t f_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t f_src = flecs_rule_ref_flags(op->flags, EcsRuleSrc);
-    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
-    ecs_table_range_t range = flecs_get_ref_range(&op->src, f_src, ctx);
-    ecs_table_t *table = range.table;
-    ecs_rule_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
-
-    if (!redo) {
-        flecs_rule_get_trav_up_cache(ctx, &trav_ctx->cache, trav, table);
-        trav_ctx->index = 0;
-        if (op->match_flags & EcsTermReflexive) {
-            trav_ctx->yield_reflexive = true;
-            trav_ctx->index = range.offset;
-            trav_ctx->offset = range.offset;
-            trav_ctx->count = range.count ? range.count : ecs_table_count(table);
-        }
-    } else {
-        trav_ctx->index ++;
-    }
-
-    if (trav_ctx->yield_reflexive) {
-        if (flecs_rule_trav_yield_reflexive_src(op, ctx, &range, trav)) {
-            return true;
-        }
-        trav_ctx->yield_reflexive = false;
-        trav_ctx->index = 0;
-    }
-
-    if (trav_ctx->index >= ecs_vec_count(&trav_ctx->cache.entities)) {
-        return false;
-    }
-
-    ecs_trav_elem_t *el = ecs_vec_get_t(
-        &trav_ctx->cache.entities, ecs_trav_elem_t, trav_ctx->index);
-    flecs_rule_set_trav_match(op, el->column, trav, el->entity, ctx);
-    return true;
-}
-
-static
-bool flecs_rule_trav(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index];
-
-    if (!flecs_ref_is_written(op, &op->src, EcsRuleSrc, written)) {
-        if (!flecs_ref_is_written(op, &op->second, EcsRuleSecond, written)) {
-            /* This can't happen, src or second should have been resolved */
-            ecs_abort(ECS_INTERNAL_ERROR, 
-                "invalid instruction sequence: unconstrained traversal");
-        } else {
-            return flecs_rule_trav_unknown_src_up_fixed_second(op, redo, ctx);
-        }
-    } else {
-        if (!flecs_ref_is_written(op, &op->second, EcsRuleSecond, written)) {
-            return flecs_rule_trav_fixed_src_up_unknown_second(op, redo, ctx);
-        } else {
-            return flecs_rule_trav_fixed_src_up_fixed_second(op, redo, ctx);
-        }
-    }
-}
-
-static
-bool flecs_rule_ids(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (redo) {
-        return false;
-    }
-
-    ecs_id_record_t *cur;
-    ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-
-    {
-        cur = flecs_id_record_get(ctx->world, id);
-        if (!cur || !cur->cache.tables.count) {
-            return false;
-        }
-    }
-
-    flecs_rule_set_vars(op, cur->id, ctx);
-
-    if (op->field_index != -1) {
-        ecs_iter_t *it = ctx->it;
-        it->ids[op->field_index] = id;
-        it->sources[op->field_index] = EcsWildcard;
-        it->columns[op->field_index] = -1; /* Mark field as set */
-    }
-
-    return true;
-}
-
-static
-bool flecs_rule_idsright(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_ids_ctx_t *op_ctx = flecs_op_ctx(ctx, ids);
-    ecs_id_record_t *cur;
-
-    if (!redo) {
-        ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-        if (!ecs_id_is_wildcard(id)) {
-            /* If id is not a wildcard, we can directly return it. This can 
-             * happen if a variable was constrained by an iterator. */
-            op_ctx->cur = NULL;
-            flecs_rule_set_vars(op, id, ctx);
-            return true;
-        }
-
-        cur = op_ctx->cur = flecs_id_record_get(ctx->world, id);
-        if (!cur) {
-            return false;
-        }
-    } else {
-        if (!op_ctx->cur) {
-            return false;
-        }
-    }
-
-    do {
-        cur = op_ctx->cur = op_ctx->cur->first.next;
-    } while (cur && !cur->cache.tables.count); /* Skip empty ids */
-
-    if (!cur) {
-        return false;
-    }
-
-    flecs_rule_set_vars(op, cur->id, ctx);
-
-    if (op->field_index != -1) {
-        ecs_iter_t *it = ctx->it;
-        ecs_id_t id = flecs_rule_op_get_id_w_written(op, op->written, ctx);
-        it->ids[op->field_index] = id;
-        it->sources[op->field_index] = EcsWildcard;
-        it->columns[op->field_index] = -1; /* Mark field as set */
-    }
-
-    return true;
-}
-
-static
-bool flecs_rule_idsleft(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_ids_ctx_t *op_ctx = flecs_op_ctx(ctx, ids);
-    ecs_id_record_t *cur;
-
-    if (!redo) {
-        ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-        if (!ecs_id_is_wildcard(id)) {
-            /* If id is not a wildcard, we can directly return it. This can 
-             * happen if a variable was constrained by an iterator. */
-            op_ctx->cur = NULL;
-            flecs_rule_set_vars(op, id, ctx);
-            return true;
-        }
-
-        cur = op_ctx->cur = flecs_id_record_get(ctx->world, id);
-        if (!cur) {
-            return false;
-        }
-    } else {
-        if (!op_ctx->cur) {
-            return false;
-        }
-    }
-
-    do {
-        cur = op_ctx->cur = op_ctx->cur->second.next;
-    } while (cur && !cur->cache.tables.count); /* Skip empty ids */
-
-    if (!cur) {
-        return false;
-    }
-
-    flecs_rule_set_vars(op, cur->id, ctx);
-
-    if (op->field_index != -1) {
-        ecs_iter_t *it = ctx->it;
-        ecs_id_t id = flecs_rule_op_get_id_w_written(op, op->written, ctx);
-        it->ids[op->field_index] = id;
-        it->sources[op->field_index] = EcsWildcard;
-        it->columns[op->field_index] = -1; /* Mark field as set */
-    }
-
-    return true;
-}
-
-static
-bool flecs_rule_each(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_each_ctx_t *op_ctx = flecs_op_ctx(ctx, each);
-    int32_t row;
-
-    ecs_table_range_t range = flecs_rule_var_get_range(op->first.var, ctx);
-    ecs_table_t *table = range.table;
-    if (!table) {
-        return false;
-    }
-
-    if (!redo) {
-        row = op_ctx->row = range.offset;
-    } else {
-        int32_t end = range.count;
-        if (end) {
-            end += range.offset;
-        } else {
-            end = table->data.entities.count;
-        }
-        row = ++ op_ctx->row;
-        if (op_ctx->row >= end) {
-            return false;
-        }
-    }
-
-    ecs_assert(row < ecs_table_count(table), ECS_INTERNAL_ERROR, NULL);
-
-    ecs_entity_t *entities = table->data.entities.array;
-    ecs_entity_t e;
-    do {
-        if (row == ecs_table_count(table)) {
-            return false;
-        }
-        e = entities[row ++];
-        ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL);
-    
-        /* Exclude entities that are used as markers by rule engine */
-    } while ((e == EcsWildcard) || (e == EcsAny) || 
-        (e == EcsThis) || (e == EcsVariable));
-
-    flecs_rule_var_set_entity(op, op->src.var, e, ctx);
-
-    return true;
-}
-
-static
-bool flecs_rule_store(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (!redo) {
-        flecs_rule_var_set_entity(op, op->src.var, op->first.entity, ctx);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-static
-bool flecs_rule_reset(
-    const ecs_rule_op_t *op,
-    bool redo,
-    const ecs_rule_run_ctx_t *ctx)
-{
-    if (!redo) {
-        return true;
-    } else {
-        flecs_rule_var_reset(op->src.var, ctx);
-        return false;
-    }
-}
-
-static
-void flecs_rule_reset_after_block(
-    const ecs_rule_op_t *start_op,
-    ecs_rule_run_ctx_t *ctx,
-    ecs_rule_ctrl_ctx_t *op_ctx)
-{
-    ecs_rule_lbl_t op_index = start_op->next;
-    const ecs_rule_op_t *op = &ctx->rit->ops[op_index];
-    ctx->written[op_index] = ctx->written[ctx->op_index];
-    ctx->op_index = op_index;
-
-    int32_t field = op->field_index;
-    if (field == -1) {
-        goto done;
-    }
-
-    ecs_iter_t *it = ctx->it;
-
-    /* Not terms return no data */
-    it->columns[field] = 0;
-
-    /* Ignore variables written by Not operation */
-    uint64_t *written = ctx->written;
-    uint64_t written_cur = written[op->prev + 1];
-    ecs_flags16_t flags_1st = flecs_rule_ref_flags(op->flags, EcsRuleFirst);
-    ecs_flags16_t flags_2nd = flecs_rule_ref_flags(op->flags, EcsRuleSecond);
-
-    /* Overwrite id with cleared out variables */
-    ecs_id_t id = flecs_rule_op_get_id(op, ctx);
-    if (id) {
-        it->ids[field] = id;
-    }
-
-    /* Reset variables */
-    if (flags_1st & EcsRuleIsVar) {
-        if (!flecs_ref_is_written(op, &op->first, EcsRuleFirst, written_cur)){
-            flecs_rule_var_reset(op->first.var, ctx);
-        }
-    }
-    if (flags_2nd & EcsRuleIsVar) {
-        if (!flecs_ref_is_written(op, &op->second, EcsRuleSecond, written_cur)){
-            flecs_rule_var_reset(op->second.var, ctx);
-        }
-    }
-
-    /* If term has entity src, set it because no other instruction might */
-    if (op->flags & (EcsRuleIsEntity << EcsRuleSrc)) {
-        it->sources[field] = op->src.entity;
-    }
-
-done:
-    op_ctx->op_index = op_index;
-}
-
-static
-const char* flecs_rule_name_arg(
-    const ecs_rule_op_t *op,
-    ecs_rule_run_ctx_t *ctx)
-{
-    int8_t term_index = op->term_index;
-    ecs_term_t *term = &ctx->rule->filter.terms[term_index];
-    return term->second.name;
-}
-
-static
-bool flecs_rule_compare_range(
-    const ecs_table_range_t *l,
-    const ecs_table_range_t *r)
-{
-    if (l->table != r->table) {
-        return false;
-    }
-
-    if (l->count) {
-        int32_t l_end = l->offset + l->count;
-        int32_t r_end = r->offset + r->count;
-        if (r->offset < l->offset) {
-            return false;
-        }
-        if (r_end > l_end) {
-            return false;
-        }
-    } else {
-        /* Entire table is matched */
-    }
-
-    return true;
-}
-
-static
-bool flecs_rule_pred_eq_w_range(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    ecs_table_range_t r)
-{
-    if (redo) {
-        return false;
-    }
-
-    uint64_t written = ctx->written[ctx->op_index];
-    ecs_var_id_t first_var = op->first.var;
-    if (!(written & (1ull << first_var))) {
-        /* left = unknown, right = known. Assign right-hand value to left */
-        ecs_var_id_t l = first_var;
-        ctx->vars[l].range = r;
-        if (r.count == 1) {
-            ctx->vars[l].entity = ecs_vec_get_t(&r.table->data.entities, 
-                ecs_entity_t, r.offset)[0];
-        }
-        return true;
-    } else {
-        ecs_table_range_t l = flecs_rule_get_range(
-            op, &op->first, EcsRuleFirst, ctx);
-
-        if (!flecs_rule_compare_range(&l, &r)) {
-            return false;
-        }
-
-        ctx->vars[first_var].range.offset = r.offset;
-        ctx->vars[first_var].range.count = r.count;
-        return true;
-    }
-}
-
-static
-bool flecs_rule_pred_eq(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index]; (void)written;
-    ecs_assert(flecs_ref_is_written(op, &op->second, EcsRuleSecond, written),
-        ECS_INTERNAL_ERROR, 
-            "invalid instruction sequence: uninitialized eq operand");
-
-    ecs_table_range_t r = flecs_rule_get_range(
-        op, &op->second, EcsRuleSecond, ctx);
-    return flecs_rule_pred_eq_w_range(op, redo, ctx, r);
-}
-
-static
-bool flecs_rule_pred_eq_name(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    const char *name = flecs_rule_name_arg(op, ctx);
-    ecs_entity_t e = ecs_lookup(ctx->world, name);
-    if (!e) {
-        /* Entity doesn't exist */
-        return false;
-    }
-
-    ecs_table_range_t r = flecs_range_from_entity(e, ctx);
-    return flecs_rule_pred_eq_w_range(op, redo, ctx, r);
-}
-
-static
-bool flecs_rule_pred_neq_w_range(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    ecs_table_range_t r)
-{
-    ecs_rule_eq_ctx_t *op_ctx = flecs_op_ctx(ctx, eq);
-    ecs_var_id_t first_var = op->first.var;
-    ecs_table_range_t l = flecs_rule_get_range(
-        op, &op->first, EcsRuleFirst, ctx);
-
-    /* If tables don't match, neq always returns once */
-    if (l.table != r.table) {
-        return true && !redo;
-    }
-
-    int32_t l_offset;
-    int32_t l_count;
-    if (!redo) {
-        /* Make sure we're working with the correct table count */
-        if (!l.count && l.table) {
-            l.count = ecs_table_count(l.table);
-        }
-
-        l_offset = l.offset;
-        l_count = l.count;
-
-        /* Cache old value */
-        op_ctx->range = l;
-    } else {
-        l_offset = op_ctx->range.offset;
-        l_count = op_ctx->range.count;
-    }
-
-    /* If the table matches, a Neq returns twice: once for the slice before the
-     * excluded slice, once for the slice after the excluded slice. If the right
-     * hand range starts & overlaps with the left hand range, there is only
-     * one slice. */
-    ecs_var_t *var = &ctx->vars[first_var];
-    if (!redo && r.offset > l_offset) {
-        int32_t end = r.offset;
-        if (end > l_count) {
-            end = l_count;
-        }
-
-        /* Return first slice */
-        var->range.table = l.table;
-        var->range.offset = l_offset;
-        var->range.count = end - l_offset;
-        op_ctx->redo = false;
-        return true;
-    } else if (!op_ctx->redo) {
-        int32_t l_end = op_ctx->range.offset + l_count;
-        int32_t r_end = r.offset + r.count;
-
-        if (l_end <= r_end) {
-            /* If end of existing range falls inside the excluded range, there's
-             * nothing more to return */
-            var->range = l;
-            return false;
-        }
-
-        /* Return second slice */
-        var->range.table = l.table;
-        var->range.offset = r_end;
-        var->range.count = l_end - r_end;
-
-        /* Flag so we know we're done the next redo */
-        op_ctx->redo = true;
-        return true;
-    } else {
-        /* Restore previous value */
-        var->range = l;
-        return false;
-    }
-}
-
-static
-bool flecs_rule_pred_match(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    bool is_neq)
-{
-    ecs_rule_eq_ctx_t *op_ctx = flecs_op_ctx(ctx, eq);
-    uint64_t written = ctx->written[ctx->op_index];
-    ecs_assert(flecs_ref_is_written(op, &op->first, EcsRuleFirst, written),
-        ECS_INTERNAL_ERROR, 
-            "invalid instruction sequence: uninitialized match operand");
-    (void)written;
-
-    ecs_var_id_t first_var = op->first.var;
-    const char *match = flecs_rule_name_arg(op, ctx);
-    ecs_table_range_t l;
-    if (!redo) {
-        l = flecs_rule_get_range(op, &op->first, EcsRuleFirst, ctx);
-        if (!l.table) {
-            return false;
-        }
-
-        if (!l.count) {
-            l.count = ecs_table_count(l.table);
-        }
-
-        op_ctx->range = l;
-        op_ctx->index = l.offset;
-        op_ctx->name_col = flecs_ito(int16_t,   
-            ecs_table_get_type_index(ctx->world, l.table, 
-                ecs_pair(ecs_id(EcsIdentifier), EcsName)));
-        if (op_ctx->name_col == -1) {
-            return is_neq;
-        }
-        op_ctx->name_col = flecs_ito(int16_t, 
-            l.table->column_map[op_ctx->name_col]);
-        ecs_assert(op_ctx->name_col != -1, ECS_INTERNAL_ERROR, NULL);
-    } else {
-        if (op_ctx->name_col == -1) {
-            /* Table has no name */
-            return false;
-        }
-
-        l = op_ctx->range;
-    }
-
-    const EcsIdentifier *names = l.table->data.columns[op_ctx->name_col].data.array;
-    int32_t count = l.offset + l.count, offset = -1;
-    for (; op_ctx->index < count; op_ctx->index ++) {
-        const char *name = names[op_ctx->index].value;
-        bool result = strstr(name, match);
-        if (is_neq) {
-            result = !result;
-        }
-
-        if (!result) {
-            if (offset != -1) {
-                break;
-            }
-        } else {
-            if (offset == -1) {
-                offset = op_ctx->index;
-            }
-        }
-    }
-
-    if (offset == -1) {
-        ctx->vars[first_var].range = op_ctx->range;
-        return false;
-    }
-
-    ctx->vars[first_var].range.offset = offset;
-    ctx->vars[first_var].range.count = (op_ctx->index - offset);
-    return true;
-}
-
-static
-bool flecs_rule_pred_eq_match(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    return flecs_rule_pred_match(op, redo, ctx, false);
-}
-
-static
-bool flecs_rule_pred_neq_match(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    return flecs_rule_pred_match(op, redo, ctx, true);
-}
-
-static
-bool flecs_rule_pred_neq(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    uint64_t written = ctx->written[ctx->op_index]; (void)written;
-    ecs_assert(flecs_ref_is_written(op, &op->second, EcsRuleSecond, written),
-        ECS_INTERNAL_ERROR, 
-            "invalid instruction sequence: uninitialized neq operand");
-
-    ecs_table_range_t r = flecs_rule_get_range(
-        op, &op->second, EcsRuleSecond, ctx);
-    return flecs_rule_pred_neq_w_range(op, redo, ctx, r);
-}
-
-static
-bool flecs_rule_pred_neq_name(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    const char *name = flecs_rule_name_arg(op, ctx);
-    ecs_entity_t e = ecs_lookup(ctx->world, name);
-    if (!e) {
-        /* Entity doesn't exist */
-        return true && !redo;
-    }
-
-    ecs_table_range_t r = flecs_range_from_entity(e, ctx);
-    return flecs_rule_pred_neq_w_range(op, redo, ctx, r);
-}
-
-static
-bool flecs_rule_lookup(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    if (redo) {
-        return false;
-    }
-
-    const ecs_rule_t *rule = ctx->rule;
-    ecs_entity_t first = flecs_rule_var_get_entity(op->first.var, ctx);
-    ecs_rule_var_t *var = &rule->vars[op->src.var];
-
-    ecs_entity_t result = ecs_lookup_path_w_sep(ctx->world, first, var->lookup,
-        NULL, NULL, false);
-    if (!result) {
-        flecs_rule_var_set_entity(op, op->src.var, EcsWildcard, ctx);
-        return false;
-    }
-
-    flecs_rule_var_set_entity(op, op->src.var, result, ctx);
-
-    return true;
-}
-
-static
-bool flecs_rule_setvars(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-
-    const ecs_rule_t *rule = ctx->rule;
-    const ecs_filter_t *filter = &rule->filter;
-    ecs_var_id_t *src_vars = rule->src_vars;
-    ecs_iter_t *it = ctx->it;
-
-    if (redo) {
-        return false;
-    }
-
-    int32_t i;
-    ecs_flags32_t source_set = *ctx->source_set;
-    for (i = 0; i < filter->field_count; i ++) {
-        ecs_var_id_t var_id = src_vars[i];
-        if (!var_id) {
-            continue;
-        }
-
-        if (source_set & (1u << i)) {
-            continue;
-        }
-
-        it->sources[i] = flecs_rule_var_get_entity(var_id, ctx);
-    }
-
-    return true;
-}
-
-static
-bool flecs_rule_setthis(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_setthis_ctx_t *op_ctx = flecs_op_ctx(ctx, setthis);
-    ecs_var_t *vars = ctx->vars;
-    ecs_var_t *this_var = &vars[op->first.var];
-
-    if (!redo) {
-        /* Save values so we can restore them later */
-        op_ctx->range = vars[0].range;
-
-        /* Constrain This table variable to a single entity from the table */
-        vars[0].range = flecs_range_from_entity(this_var->entity, ctx);
-        vars[0].entity = this_var->entity;
-        return true;
-    } else {
-        /* Restore previous values, so that instructions that are operating on
-         * the table variable use all the entities in the table. */
-        vars[0].range = op_ctx->range;
-        vars[0].entity = 0;
-        return false;
-    }
-}
-
-static
-bool flecs_rule_setfixed(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    const ecs_rule_t *rule = ctx->rule;
-    const ecs_filter_t *filter = &rule->filter;
-    ecs_iter_t *it = ctx->it;
-
-    if (redo) {
-        return false;
-    }
-
-    int32_t i;
-    for (i = 0; i < filter->term_count; i ++) {
-        ecs_term_t *term = &filter->terms[i];
-        ecs_term_id_t *src = &term->src;
-        if (src->flags & EcsIsEntity) {
-            it->sources[term->field_index] = src->id;
-        }
-    }
-
-    return true;
-}
-
-static
-bool flecs_rule_setids(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    const ecs_rule_t *rule = ctx->rule;
-    const ecs_filter_t *filter = &rule->filter;
-    ecs_iter_t *it = ctx->it;
-
-    if (redo) {
-        return false;
-    }
-
-    int32_t i;
-    for (i = 0; i < filter->term_count; i ++) {
-        ecs_term_t *term = &filter->terms[i];
-        it->ids[term->field_index] = term->id;
-    }
-
-    return true;
-}
-
-static
-bool flecs_rule_setid(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    if (redo) {
-        return false;
-    }
-
-    ecs_assert(op->field_index != -1, ECS_INTERNAL_ERROR, NULL);
-    ctx->it->ids[op->field_index] = op->first.entity;
-    return true;
-}
-
-/* Check if entity is stored in table */
-static
-bool flecs_rule_contain(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    if (redo) {
-        return false;
-    }
-
-    ecs_var_id_t src_id = op->src.var;
-    ecs_var_id_t first_id = op->first.var;
-
-    ecs_table_t *table = flecs_rule_var_get_table(src_id, ctx);
-
-    ecs_entity_t e = flecs_rule_var_get_entity(first_id, ctx);
-    return table == ecs_get_table(ctx->world, e);
-}
-
-/* Check if first and second id of pair from last operation are the same */
-static
-bool flecs_rule_pair_eq(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    if (redo) {
-        return false;
-    }
-
-    ecs_iter_t *it = ctx->it;
-    ecs_id_t id = it->ids[op->field_index];
-    return ECS_PAIR_FIRST(id) == ECS_PAIR_SECOND(id);
-}
-
-static
-bool flecs_rule_select_or(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    ecs_iter_t *it = ctx->it;
-    ecs_rule_iter_t *rit = &it->priv.iter.rule;
-    ecs_rule_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
-
-    ecs_rule_lbl_t first = flecs_itolbl(ctx->op_index + 1);
-    if (!redo) {
-        op_ctx->op_index = first;
-    }
-
-    const ecs_rule_op_t *cur = &rit->ops[op_ctx->op_index];
-    bool result = false;
-    
-    /* Evaluate operations in OR chain one by one. */
-
-    do {
-        ctx->op_index = op_ctx->op_index;
-        ctx->written[op_ctx->op_index] = op->written;
-
-        result = flecs_rule_dispatch(cur, redo, ctx);
-        if (result) {
-            ctx->written[op_ctx->op_index] |= cur->written;
-
-            /* If a previous operation in the OR chain returned a result for the
-             * same matched source, skip it so we don't yield for each matching
-             * element in the chain. */
-            ecs_rule_lbl_t prev_index;
-            for (prev_index = first; prev_index < op_ctx->op_index; 
-                prev_index ++) 
-            {
-                const ecs_rule_op_t *prev = &rit->ops[prev_index];
-                ctx->op_index = prev_index;
-                ctx->written[prev_index] = ctx->written[op_ctx->op_index];
-                if (flecs_rule_dispatch(prev, false, ctx)) {
-                    break;
-                }
-            }
-
-            if (prev_index != op_ctx->op_index) {
-                /* Duplicate match was found, redo search */
-                redo = true;
-                continue;
-            }
-            break;
-        }
-
-        /* No result was found, go to next operation in chain */
-        op_ctx->op_index ++;
-        cur = &rit->ops[op_ctx->op_index];
-        redo = false;
-    } while (cur->kind != EcsRuleEnd);
-
-    return result;
-}
-
-static
-bool flecs_rule_run_block(
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    ecs_rule_ctrl_ctx_t *op_ctx)
-{
-    ecs_iter_t *it = ctx->it;
-    ecs_rule_iter_t *rit = &it->priv.iter.rule;
-
-    if (!redo) {
-        op_ctx->op_index = flecs_itolbl(ctx->op_index + 1);
-    } else if (ctx->rit->ops[op_ctx->op_index].kind == EcsRuleEnd) {
-        return false;
-    }
-
-    ctx->written[ctx->op_index + 1] = ctx->written[ctx->op_index];
-
-    return flecs_rule_run_until(
-        redo, ctx, rit->ops, ctx->op_index, op_ctx->op_index, EcsRuleEnd);
-}
-
-static
-bool flecs_rule_with_or(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
-
-    bool result = flecs_rule_run_block(redo, ctx, op_ctx);
-    if (result) {
-        /* If a match was found, no need to keep searching for this source */
-        op_ctx->op_index = op->next;
-    }
-
-    return result;
-}
-
-static
-bool flecs_rule_or(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    if (op->flags & (EcsRuleIsVar << EcsRuleSrc)) {
-        uint64_t written = ctx->written[ctx->op_index];
-        if (!(written & (1ull << op->src.var))) {
-            return flecs_rule_select_or(op, redo, ctx);
-        }
-    }
-
-    return flecs_rule_with_or(op, redo, ctx);
-}
-
-static
-bool flecs_rule_run_block_w_reset(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    ecs_rule_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
-    bool result = flecs_rule_run_block(redo, ctx, op_ctx);
-    if (!result) {
-        flecs_rule_reset_after_block(op, ctx, op_ctx);
-    }
-    return result;
-}
-
-static
-bool flecs_rule_not(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    if (redo) {
-        return false;
-    }
-
-    return !flecs_rule_run_block_w_reset(op, redo, ctx);
-}
-
-static
-bool flecs_rule_optional(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{   
-    bool result = flecs_rule_run_block_w_reset(op, redo, ctx);
-    if (!redo) {
-        return true; /* Return at least once */
-    } else {
-        return result;
-    }
-}
-
-static
-bool flecs_rule_eval_if(
-    const ecs_rule_op_t *op,
-    ecs_rule_run_ctx_t *ctx,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t ref_kind)
-{
-    if (flecs_rule_ref_flags(op->flags, ref_kind) == EcsRuleIsVar) {
-        if (ctx->vars[ref->var].entity == EcsWildcard) {
-            ecs_rule_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
-            flecs_rule_reset_after_block(op, ctx, op_ctx);
-            return false;
-        }
-    }
-    return true;
-}
-
-static
-bool flecs_rule_if(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    if (!redo) {
-        if (!flecs_rule_eval_if(op, ctx, &op->src, EcsRuleSrc) ||
-            !flecs_rule_eval_if(op, ctx, &op->first, EcsRuleFirst) ||
-            !flecs_rule_eval_if(op, ctx, &op->second, EcsRuleSecond))
-        {
-            return true;
-        }
-    }
-
-    return flecs_rule_run_block_w_reset(op, redo, ctx);
-}
-
-static
-bool flecs_rule_end(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    (void)op; (void)ctx;
-    return !redo;
-}
-
-static
-bool flecs_rule_populate(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    if (!redo) {
-        ecs_iter_t *it = ctx->it;
-        if (it->flags & EcsIterNoData) {
-            return true;
-        }
-
-        ECS_BIT_CLEAR(it->flags, EcsIterHasShared);
-
-        const ecs_rule_t *rule = ctx->rule;
-        const ecs_filter_t *filter = &rule->filter;
-        int32_t i, field_count = filter->field_count;
-        ecs_flags64_t data_fields = filter->data_fields;
-        ecs_table_range_t *range = &ctx->vars[0].range;
-        ecs_table_t *table = range->table;
-        if (table && !range->count) {
-            range->count = ecs_table_count(table);
-        }
-
-        for (i = 0; i < field_count; i ++) {
-            if (!(data_fields & (1llu << i))) {
-                continue;
-            }
-
-            int32_t index = it->columns[i];
-            ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
-            if (!index) {
-                continue;
-            }
-    
-            ecs_entity_t src = it->sources[i];
-            if (!src) {
-                ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-                if (range->count && table->column_map) {
-                    int32_t column = table->column_map[index - 1];
-                    if (column != -1) {
-                        it->ptrs[i] = ECS_ELEM(
-                            table->data.columns[column].data.array,
-                            it->sizes[i],
-                            range->offset);
-                        continue;
-                    }
-                }
-            } else {
-                ecs_record_t *r = flecs_entities_get(ctx->world, src);
-                ecs_table_t *src_table = r->table;
-                if (src_table->column_map) {
-                    int32_t column = src_table->column_map[index - 1];
-                    if (column != -1) {
-                        it->ptrs[i] = ecs_vec_get(
-                            &src_table->data.columns[column].data,
-                            it->sizes[i],
-                            ECS_RECORD_TO_ROW(r->row));
-                        ECS_BIT_SET(it->flags, EcsIterHasShared);
-                        continue;
-                    }
-                }
-            }
-        }
-
-        return true;
-    } else {
-        return false;
-    }
-}
-
-static
-bool flecs_rule_populate_self(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    (void)op;
-    if (!redo) {
-        const ecs_rule_t *rule = ctx->rule;
-        const ecs_filter_t *filter = &rule->filter;
-        int32_t i, field_count = filter->field_count;
-        ecs_flags64_t data_fields = filter->data_fields;
-        ecs_iter_t *it = ctx->it;
-
-        ecs_table_range_t *range = &ctx->vars[0].range;
-        ecs_table_t *table = range->table;
-        if (!table->column_map) {
-            return true;
-        }
-
-        if (!ecs_table_count(table)) {
-            return true;
-        }
-
-        for (i = 0; i < field_count; i ++) {
-            if (!(data_fields & (1llu << i))) {
-                continue;
-            }
-
-            int32_t index = it->columns[i];
-            ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL); /* Only owned */
-            if (!index) {
-                continue;
-            }
-
-            int32_t column = table->column_map[index - 1];
-            if (column != -1) {
-                it->ptrs[i] = ECS_ELEM(
-                    table->data.columns[column].data.array,
-                    it->sizes[i],
-                    range->offset);
-            }
-        }
-
-        return true;
-    } else {
-        return false;
-    }
-}
-
-static
-bool flecs_rule_dispatch(
-    const ecs_rule_op_t *op,
-    bool redo,
-    ecs_rule_run_ctx_t *ctx)
-{
-    switch(op->kind) {
-    case EcsRuleAnd: return flecs_rule_and(op, redo, ctx);
-    case EcsRuleAndId: return flecs_rule_and_id(op, redo, ctx);
-    case EcsRuleAndAny: return flecs_rule_and_any(op, redo, ctx);
-    case EcsRuleTriv: return flecs_rule_triv(op, redo, ctx);
-    case EcsRuleTrivData: return flecs_rule_triv_data(op, redo, ctx);
-    case EcsRuleTrivWildcard: return flecs_rule_triv_wildcard(op, redo, ctx);
-    case EcsRuleSelectAny: return flecs_rule_select_any(op, redo, ctx);
-    case EcsRuleUp: return flecs_rule_up(op, redo, ctx);
-    case EcsRuleUpId: return flecs_rule_up_id(op, redo, ctx);
-    case EcsRuleSelfUp: return flecs_rule_self_up(op, redo, ctx);
-    case EcsRuleSelfUpId: return flecs_rule_self_up_id(op, redo, ctx);
-    case EcsRuleWith: return flecs_rule_with(op, redo, ctx);
-    case EcsRuleTrav: return flecs_rule_trav(op, redo, ctx);
-    case EcsRuleIds: return flecs_rule_ids(op, redo, ctx);
-    case EcsRuleIdsRight: return flecs_rule_idsright(op, redo, ctx);
-    case EcsRuleIdsLeft: return flecs_rule_idsleft(op, redo, ctx);
-    case EcsRuleEach: return flecs_rule_each(op, redo, ctx);
-    case EcsRuleStore: return flecs_rule_store(op, redo, ctx);
-    case EcsRuleReset: return flecs_rule_reset(op, redo, ctx);
-    case EcsRuleOr: return flecs_rule_or(op, redo, ctx);
-    case EcsRuleOptional: return flecs_rule_optional(op, redo, ctx);
-    case EcsRuleIf: return flecs_rule_if(op, redo, ctx);
-    case EcsRuleEnd: return flecs_rule_end(op, redo, ctx);
-    case EcsRuleNot: return flecs_rule_not(op, redo, ctx);
-    case EcsRulePredEq: return flecs_rule_pred_eq(op, redo, ctx);
-    case EcsRulePredNeq: return flecs_rule_pred_neq(op, redo, ctx);
-    case EcsRulePredEqName: return flecs_rule_pred_eq_name(op, redo, ctx);
-    case EcsRulePredNeqName: return flecs_rule_pred_neq_name(op, redo, ctx);
-    case EcsRulePredEqMatch: return flecs_rule_pred_eq_match(op, redo, ctx);
-    case EcsRulePredNeqMatch: return flecs_rule_pred_neq_match(op, redo, ctx);
-    case EcsRuleLookup: return flecs_rule_lookup(op, redo, ctx);
-    case EcsRuleSetVars: return flecs_rule_setvars(op, redo, ctx);
-    case EcsRuleSetThis: return flecs_rule_setthis(op, redo, ctx);
-    case EcsRuleSetFixed: return flecs_rule_setfixed(op, redo, ctx);
-    case EcsRuleSetIds: return flecs_rule_setids(op, redo, ctx);
-    case EcsRuleSetId: return flecs_rule_setid(op, redo, ctx);
-    case EcsRuleContain: return flecs_rule_contain(op, redo, ctx);
-    case EcsRulePairEq: return flecs_rule_pair_eq(op, redo, ctx);
-    case EcsRulePopulate: return flecs_rule_populate(op, redo, ctx);
-    case EcsRulePopulateSelf: return flecs_rule_populate_self(op, redo, ctx);
-    case EcsRuleYield: return false;
-    case EcsRuleNothing: return false;
-    }
-    return false;
-}
-
-static
-bool flecs_rule_run_until(
-    bool redo,
-    ecs_rule_run_ctx_t *ctx,
-    const ecs_rule_op_t *ops,
-    ecs_rule_lbl_t first,
-    ecs_rule_lbl_t cur,
-    ecs_rule_op_kind_t until)
-{
-    ecs_assert(first >= -1, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(cur >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(cur > first, ECS_INTERNAL_ERROR, NULL);
-
-    ctx->op_index = cur;
-    const ecs_rule_op_t *op = &ops[ctx->op_index];
-    ecs_assert(op->kind != until, ECS_INTERNAL_ERROR, NULL);
-
-    do {
-        #ifdef FLECS_DEBUG
-        ctx->rit->profile[ctx->op_index].count[redo] ++;
-        #endif
-
-        bool result = flecs_rule_dispatch(op, redo, ctx);
-        cur = (&op->prev)[result];
-        redo = cur < ctx->op_index;
-
-        if (!redo) {
-            ctx->written[cur] |= ctx->written[ctx->op_index] | op->written;
-        }
-
-        ctx->op_index = cur;
-        op = &ops[ctx->op_index];
-
-        if (cur <= first) {
-            return false;
-        }
-        if (op->kind == until) {
-            return true;
-        }
-    } while (true);
-}
-
-static
-void flecs_rule_iter_init(
-    ecs_rule_run_ctx_t *ctx)
-{
-    ecs_assert(ctx->written != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_iter_t *it = ctx->it;
-
-    const ecs_rule_t *rule = ctx->rule;
-    ecs_flags64_t it_written = it->constrained_vars;
-    ctx->written[0] = it_written;
-    if (it_written && ctx->rule->src_vars) {
-        /* If variables were constrained, check if there are any table
-         * variables that have a constrained entity variable. */
-        ecs_var_t *vars = ctx->vars;
-        int32_t i, count = rule->filter.field_count;
-        for (i = 0; i < count; i ++) {
-            ecs_var_id_t var_id = rule->src_vars[i];
-            ecs_rule_var_t *var = &rule->vars[var_id];
-
-            if (!(it_written & (1ull << var_id)) || 
-                (var->kind == EcsVarTable) || (var->table_id == EcsVarNone)) 
-            {
-                continue;
-            }
-
-            /* Initialize table variable with constrained entity variable */
-            ecs_var_t *tvar = &vars[var->table_id];
-            tvar->range = flecs_range_from_entity(vars[var_id].entity, ctx);
-            ctx->written[0] |= (1ull << var->table_id); /* Mark as written */
-        }
-    }
-
-    ecs_flags32_t flags = rule->filter.flags;
-    if (flags & EcsFilterIsTrivial) {
-        if ((flags & EcsFilterMatchOnlySelf) || 
-            !flecs_table_cache_count(&ctx->world->idr_isa_wildcard->cache)) 
-        {
-            if (it_written) {
-                it->offset = ctx->vars[0].range.offset;
-                it->count = ctx->vars[0].range.count;
-                if (!it->count) {
-                    ecs_assert(!it->offset, ECS_INVALID_PARAMETER, NULL);
-                    it->count = ecs_table_count(ctx->vars[0].range.table);
-                }
-
-                it->flags |= EcsIterTrivialTest;
-                flecs_rule_setids(&rule->ops[0], false, ctx);
-            } else {
-                if (flags & EcsFilterHasWildcards) {
-                    it->flags |= EcsIterTrivialSearchWildcard;
-                    flecs_rule_setids(&rule->ops[0], false, ctx);
-                } else if (flags & EcsFilterNoData) {
-                    it->flags |= EcsIterTrivialSearchNoData;
-                    flecs_rule_setids(&rule->ops[0], false, ctx);
-                } else {
-                    it->flags |= EcsIterTrivialSearch;
-                    flecs_rule_setids(&rule->ops[0], false, ctx);
-                }
-            }
-        }
-    }
-
-    flecs_iter_validate(it);
-}
-
-bool ecs_rule_next_instanced(
-    ecs_iter_t *it)
-{
-    ecs_assert(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(it->next == ecs_rule_next, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_rule_iter_t *rit = &it->priv.iter.rule;
-    ecs_rule_run_ctx_t ctx;
-    ctx.world = it->real_world;
-    ctx.rule = rit->rule;
-    ctx.it = it;
-    ctx.vars = rit->vars;
-    ctx.rule_vars = rit->rule_vars;
-    ctx.written = rit->written;
-    ctx.op_ctx = rit->op_ctx;
-    ctx.source_set = &rit->source_set;
-    ctx.rit = rit;
-    const ecs_rule_op_t *ops = rit->ops;
-
-    bool redo = true;
-    if (!(it->flags & EcsIterIsValid)) {
-        ecs_assert(ctx.rule != NULL, ECS_INVALID_PARAMETER, NULL);
-        flecs_rule_iter_init(&ctx);
-        redo = false;
-    } else {
-        it->frame_offset += it->count;
-    }
-
-    /* Specialized iterator modes for trivial queries */
-    if (it->flags & EcsIterTrivialSearch) {
-        ecs_rule_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
-        int32_t fields = ctx.rule->filter.term_count;
-        if (!flecs_rule_trivial_search(ctx.rule, &ctx, op_ctx, !redo, fields)) {
-            goto done;
-        }
-        it->table = ctx.vars[0].range.table;
-        it->count = ecs_table_count(it->table);
-        it->entities = flecs_table_entities_array(it->table);
-        return true;
-    } else if (it->flags & EcsIterTrivialSearchNoData) {
-        ecs_rule_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
-        int32_t fields = ctx.rule->filter.term_count;
-        if (!flecs_rule_trivial_search_nodata(ctx.rule, &ctx, op_ctx, !redo, fields)) {
-            goto done;
-        }
-        it->table = ctx.vars[0].range.table;
-        it->count = ecs_table_count(it->table);
-        it->entities = flecs_table_entities_array(it->table);
-        return true;
-    } else if (it->flags & EcsIterTrivialTest) {
-        int32_t fields = ctx.rule->filter.term_count;
-        if (!flecs_rule_trivial_test(ctx.rule, &ctx, !redo, fields)) {
-            goto done;
-        }
-        return true;
-    } else if (it->flags & EcsIterTrivialSearchWildcard) {
-        ecs_rule_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
-        int32_t fields = ctx.rule->filter.term_count;
-        if (!flecs_rule_trivial_search_w_wildcards(ctx.rule, &ctx, op_ctx, !redo, fields)) {
-            goto done;
-        }
-        it->table = ctx.vars[0].range.table;
-        it->count = ecs_table_count(it->table);
-        it->entities = flecs_table_entities_array(it->table);
-        return true;
-    }
-
-    /* Default iterator mode */
-    if (flecs_rule_run_until(redo, &ctx, ops, -1, rit->op, EcsRuleYield)) {
-        ecs_assert(ops[ctx.op_index].kind == EcsRuleYield, 
-            ECS_INTERNAL_ERROR, NULL);
-        ecs_table_range_t *range = &ctx.vars[0].range;
-        ecs_table_t *table = range->table;
-        int32_t count = range->count;
-        if (table) {
-            if (!count) {
-                count = ecs_table_count(table);
-            }
-            it->table = table;
-            it->offset = range->offset;
-            it->count = count;
-            it->entities = ECS_ELEM_T(
-                table->data.entities.array, ecs_entity_t, it->offset);
-        } else if (count == 1) {
-            it->count = 1;
-            it->entities = &ctx.vars[0].entity;
-        }
-
-        rit->op = flecs_itolbl(ctx.op_index - 1);
-        return true;
-    }
-
-done:
-    ecs_iter_fini(it);
-    return false;
-}
-
-bool ecs_rule_next(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_rule_next, ECS_INVALID_PARAMETER, NULL);
-
-    if (flecs_iter_next_row(it)) {
-        return true;
-    }
-
-    return flecs_iter_next_instanced(it, ecs_rule_next_instanced(it));
-error:
-    return false;
-}
-
-static
-void flecs_rule_iter_fini_ctx(
-    ecs_iter_t *it,
-    ecs_rule_iter_t *rit)
-{
-    const ecs_rule_t *rule = rit->rule;
-    int32_t i, count = rule->op_count;
-    ecs_rule_op_t *ops = rule->ops;
-    ecs_rule_op_ctx_t *ctx = rit->op_ctx;
-    ecs_allocator_t *a = flecs_rule_get_allocator(it);
-
-    for (i = 0; i < count; i ++) {
-        ecs_rule_op_t *op = &ops[i];
-        switch(op->kind) {
-        case EcsRuleTrav:
-            flecs_rule_trav_cache_fini(a, &ctx[i].is.trav.cache);
-            break;
-        case EcsRuleUp:
-        case EcsRuleSelfUp:
-        case EcsRuleUpId:
-        case EcsRuleSelfUpId: {
-            ecs_trav_up_cache_t *cache = &ctx[i].is.up.cache;
-            if (cache->dir == EcsDown) {
-                flecs_rule_down_cache_fini(a, cache);
-            } else {
-                flecs_rule_up_cache_fini(cache);
-            }
-            break;
-        }
-        default:
-            break;
-        }
-    }
-}
-
-static
-void flecs_rule_iter_fini(
-    ecs_iter_t *it)
-{
-    ecs_rule_iter_t *rit = &it->priv.iter.rule;
-    ecs_assert(rit->rule != NULL, ECS_INVALID_OPERATION, NULL);
-    ecs_poly_assert(rit->rule, ecs_rule_t);
-    int32_t op_count = rit->rule->op_count;
-    int32_t var_count = rit->rule->var_count;
-
-#ifdef FLECS_DEBUG
-    if (it->flags & EcsIterProfile) {
-        char *str = ecs_rule_str_w_profile(rit->rule, it);
-        printf("%s\n", str);
-        ecs_os_free(str);
-    }
-
-    flecs_iter_free_n(rit->profile, ecs_rule_op_profile_t, op_count);
-#endif
-
-    flecs_rule_iter_fini_ctx(it, rit);
-    flecs_iter_free_n(rit->vars, ecs_var_t, var_count);
-    flecs_iter_free_n(rit->written, ecs_write_flags_t, op_count);
-    flecs_iter_free_n(rit->op_ctx, ecs_rule_op_ctx_t, op_count);
-    rit->vars = NULL;
-    rit->written = NULL;
-    rit->op_ctx = NULL;
-    rit->rule = NULL;
-}
-
-ecs_iter_t ecs_rule_iter(
-    const ecs_world_t *world,
-    const ecs_rule_t *rule)
-{
-    ecs_iter_t it = {0};
-    ecs_rule_iter_t *rit = &it.priv.iter.rule;
-    ecs_check(rule != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    // Ok, only for stats
-    ECS_CONST_CAST(ecs_rule_t*, rule)->filter.eval_count ++;
-
-    ecs_run_aperiodic(rule->filter.world, EcsAperiodicEmptyTables);
-
-    int32_t i, var_count = rule->var_count, op_count = rule->op_count;
-    it.world = ECS_CONST_CAST(ecs_world_t*, world);
-    it.real_world = rule->filter.world;
-    it.query = &rule->filter;
-    it.terms = rule->filter.terms;
-    it.next = ecs_rule_next;
-    it.fini = flecs_rule_iter_fini;
-    it.field_count = rule->filter.field_count;
-    it.sizes = rule->filter.sizes;
-    it.system = rule->filter.entity;
-    flecs_filter_apply_iter_flags(&it, &rule->filter);
-
-    flecs_iter_init(world, &it, 
-        flecs_iter_cache_ids |
-        flecs_iter_cache_columns |
-        flecs_iter_cache_sources |
-        flecs_iter_cache_ptrs);
-
-    rit->rule = rule;
-    rit->rule_vars = rule->vars;
-    rit->ops = rule->ops;
-    rit->source_set = 0;
-    if (var_count) {
-        rit->vars = flecs_iter_calloc_n(&it, ecs_var_t, var_count);
-    }
-    if (op_count) {
-        rit->written = flecs_iter_calloc_n(&it, ecs_write_flags_t, op_count);
-        rit->op_ctx = flecs_iter_calloc_n(&it, ecs_rule_op_ctx_t, op_count);
-    }
-
-#ifdef FLECS_DEBUG
-    rit->profile = flecs_iter_calloc_n(&it, ecs_rule_op_profile_t, op_count);
-#endif
-
-    for (i = 1; i < var_count; i ++) {
-        rit->vars[i].entity = EcsWildcard;
-    }
-
-    it.variables = rit->vars;
-    it.variable_count = rule->var_pub_count;
-    it.variable_names = rule->var_names;
-
-error:
-    return it;
-}
-
-#endif
diff --git a/src/addons/rules/rules.h b/src/addons/rules/rules.h
deleted file mode 100644
index f1b3a6513..000000000
--- a/src/addons/rules/rules.h
+++ /dev/null
@@ -1,439 +0,0 @@
- /**
- * @file addons/rules/rules.h
- * @brief Internal types and functions for rules addon.
- */
-
-#ifndef FLECS_RULES_PRIVATE_H
-#define FLECS_RULES_PRIVATE_H
-
-#include "../../private_api.h"
-
-#ifdef FLECS_RULES
-
-typedef uint8_t ecs_var_id_t;
-typedef int16_t ecs_rule_lbl_t;
-typedef ecs_flags64_t ecs_write_flags_t;
-
-#define EcsRuleMaxVarCount      (64)
-#define EcsVarNone              ((ecs_var_id_t)-1)
-#define EcsThisName             "this"
-
-/* -- Variable types -- */
-typedef enum {
-    EcsVarEntity,          /* Variable that stores an entity id */
-    EcsVarTable,           /* Variable that stores a table */
-    EcsVarAny              /* Used when requesting either entity or table var */
-} ecs_var_kind_t;
-
-typedef struct ecs_rule_var_t {
-    int8_t kind;           /* variable kind (EcsVarEntity or EcsVarTable) */
-    bool anonymous;        /* variable is anonymous */
-    ecs_var_id_t id;       /* variable id */
-    ecs_var_id_t table_id; /* id to table variable, if any */
-    ecs_var_id_t base_id;  /* id to base entity variable, for lookups */
-    const char *name;      /* variable name */
-    const char *lookup;    /* Lookup string for variable */
-#ifdef FLECS_DEBUG
-    const char *label;     /* for debugging */
-#endif
-} ecs_rule_var_t;
-
-/* -- Instruction kinds -- */
-typedef enum {
-    EcsRuleAnd,            /* And operator: find or match id against variable source */
-    EcsRuleAndId,          /* And operator for fixed id (no wildcards/variables) */
-    EcsRuleAndAny,         /* And operator with support for matching Any src/id */
-    EcsRuleTriv,           /* Trivial search */
-    EcsRuleTrivData,       /* Trivial search with setting data fields */
-    EcsRuleTrivWildcard,   /* Trivial search with (exclusive) wildcard ids */
-    EcsRuleSelectAny,      /* Dedicated instruction for _ queries where the src is unknown */
-    EcsRuleUp,             /* Up traversal */
-    EcsRuleUpId,           /* Up traversal for fixed id (like AndId) */
-    EcsRuleSelfUp,         /* Self|up traversal */
-    EcsRuleSelfUpId,       /* Self|up traversal for fixed id (like AndId) */
-    EcsRuleWith,           /* Match id against fixed or variable source */
-    EcsRuleTrav,           /* Support for transitive/reflexive queries */
-    EcsRuleIds,            /* Test for existence of ids matching wildcard */
-    EcsRuleIdsRight,       /* Find ids in use that match (R, *) wildcard */
-    EcsRuleIdsLeft,        /* Find ids in use that match (*, T) wildcard */
-    EcsRuleEach,           /* Iterate entities in table, populate entity variable */
-    EcsRuleStore,          /* Store table or entity in variable */
-    EcsRuleReset,          /* Reset value of variable to wildcard (*) */
-    EcsRuleOr,             /* Or operator */
-    EcsRuleOptional,       /* Optional operator */
-    EcsRuleIf,             /* Conditional execution */
-    EcsRuleNot,            /* Sets iterator state after term was not matched */
-    EcsRuleEnd,            /* End of control flow block */
-    EcsRulePredEq,         /* Test if variable is equal to, or assign to if not set */
-    EcsRulePredNeq,        /* Test if variable is not equal to */
-    EcsRulePredEqName,     /* Same as EcsRulePredEq but with matching by name */
-    EcsRulePredNeqName,    /* Same as EcsRulePredNeq but with matching by name */
-    EcsRulePredEqMatch,    /* Same as EcsRulePredEq but with fuzzy matching by name */
-    EcsRulePredNeqMatch,   /* Same as EcsRulePredNeq but with fuzzy matching by name */
-    EcsRuleLookup,         /* Lookup relative to variable */
-    EcsRuleSetVars,        /* Populate it.sources from variables */
-    EcsRuleSetThis,        /* Populate This entity variable */
-    EcsRuleSetFixed,       /* Set fixed source entity ids */
-    EcsRuleSetIds,         /* Set fixed (component) ids */
-    EcsRuleSetId,          /* Set id if not set */
-    EcsRuleContain,        /* Test if table contains entity */
-    EcsRulePairEq,         /* Test if both elements of pair are the same */
-    EcsRulePopulate,       /* Populate any data fields */
-    EcsRulePopulateSelf,   /* Populate only self (owned) data fields */
-    EcsRuleYield,          /* Yield result back to application */
-    EcsRuleNothing         /* Must be last */
-} ecs_rule_op_kind_t;
-
-/* Op flags to indicate if ecs_rule_ref_t is entity or variable */
-#define EcsRuleIsEntity  (1 << 0)
-#define EcsRuleIsVar     (1 << 1)
-#define EcsRuleIsSelf    (1 << 6)
-
-/* Op flags used to shift EcsRuleIsEntity and EcsRuleIsVar */
-#define EcsRuleSrc     0
-#define EcsRuleFirst   2
-#define EcsRuleSecond  4
-
-/* References to variable or entity */
-typedef union {
-    ecs_var_id_t var;
-    ecs_entity_t entity;
-} ecs_rule_ref_t;
-
-/* Query instruction */
-typedef struct ecs_rule_op_t {
-    uint8_t kind;              /* Instruction kind */
-    ecs_flags8_t flags;        /* Flags storing whether 1st/2nd are variables */
-    int8_t field_index;        /* Query field corresponding with operation */
-    int8_t term_index;         /* Query term corresponding with operation */
-    ecs_rule_lbl_t prev;       /* Backtracking label (no data) */
-    ecs_rule_lbl_t next;       /* Forwarding label. Must come after prev */
-    ecs_rule_lbl_t other;      /* Misc register used for control flow */
-    ecs_flags16_t match_flags; /* Flags that modify matching behavior */
-    ecs_rule_ref_t src;
-    ecs_rule_ref_t first;
-    ecs_rule_ref_t second;
-    ecs_flags64_t written;     /* Bitset with variables written by op */
-} ecs_rule_op_t;
-
- /* And context */
-typedef struct {
-    ecs_id_record_t *idr;
-    ecs_table_cache_iter_t it;
-    int16_t column;
-    int16_t remaining;
-} ecs_rule_and_ctx_t;
-
-/* Down traversal cache (for resolving up queries w/unknown source) */
-typedef struct {
-    ecs_table_t *table;
-    bool leaf; /* Table owns and inherits id (for Up queries without Self) */
-} ecs_trav_down_elem_t;
-
-typedef struct {
-    ecs_vec_t elems;      /* vector<ecs_trav_down_elem_t> */
-    bool ready;
-} ecs_trav_down_t;
-
-typedef struct {
-    ecs_entity_t src;
-    ecs_id_t id;
-    int32_t column;
-    bool ready;
-} ecs_trav_up_t;
-
-typedef struct {
-    ecs_map_t src;        /* map<entity, trav_down_t> or map<table_id, trav_up_t> */
-    ecs_id_t with;
-    ecs_flags32_t dir;
-} ecs_trav_up_cache_t;
-
-/* And up context */
-typedef struct {
-    ecs_rule_and_ctx_t and;
-    ecs_table_t *table;
-    int32_t row;
-    int32_t end;
-    ecs_entity_t trav;
-    ecs_id_t with;
-    ecs_id_t matched;
-    ecs_id_record_t *idr_with;
-    ecs_id_record_t *idr_trav;
-    ecs_trav_down_t *down;
-    int32_t cache_elem;
-    ecs_trav_up_cache_t cache;
-} ecs_rule_up_ctx_t;
-
-/* Cache for storing results of upward/downward "all" traversal. This type of
- * traversal iterates and caches the entire tree. */
-typedef struct {
-    ecs_entity_t entity;
-    ecs_id_record_t *idr;
-    int32_t column;
-} ecs_trav_elem_t;
-
-typedef struct {
-    ecs_id_t id;
-    ecs_id_record_t *idr;
-    ecs_vec_t entities;
-    bool up;
-} ecs_trav_cache_t;
-
-/* Trav context */
-typedef struct {
-    ecs_rule_and_ctx_t and;
-    int32_t index;
-    int32_t offset;
-    int32_t count;
-    ecs_trav_cache_t cache;
-    bool yield_reflexive;
-} ecs_rule_trav_ctx_t;
-
- /* Eq context */
-typedef struct {
-    ecs_table_range_t range;
-    int32_t index;
-    int16_t name_col;
-    bool redo;
-} ecs_rule_eq_ctx_t;
-
- /* Each context */
-typedef struct {
-    int32_t row;
-} ecs_rule_each_ctx_t;
-
- /* Setthis context */
-typedef struct {
-    ecs_table_range_t range;
-} ecs_rule_setthis_ctx_t;
-
-/* Ids context */
-typedef struct {
-    ecs_id_record_t *cur;
-} ecs_rule_ids_ctx_t;
-
-/* Control flow context */
-typedef struct {
-    ecs_rule_lbl_t op_index;
-    ecs_id_t field_id;
-} ecs_rule_ctrl_ctx_t;
-
-/* Trivial context */
-typedef struct {
-    ecs_table_cache_iter_t it;
-    const ecs_table_record_t *tr;
-} ecs_rule_trivial_ctx_t;
-
-typedef struct ecs_rule_op_ctx_t {
-    union {
-        ecs_rule_and_ctx_t and;
-        ecs_rule_up_ctx_t up;
-        ecs_rule_trav_ctx_t trav;
-        ecs_rule_ids_ctx_t ids;
-        ecs_rule_eq_ctx_t eq;
-        ecs_rule_each_ctx_t each;
-        ecs_rule_setthis_ctx_t setthis;
-        ecs_rule_ctrl_ctx_t ctrl;
-        ecs_rule_trivial_ctx_t trivial;
-    } is;
-} ecs_rule_op_ctx_t;
-
-typedef struct {
-    /* Labels used for control flow */
-    ecs_rule_lbl_t lbl_query; /* Used to find the op that does the actual searching */
-    ecs_rule_lbl_t lbl_begin;
-    ecs_rule_lbl_t lbl_cond_eval;
-    ecs_write_flags_t cond_written_or; /* Cond written flags at start of or chain */
-    bool in_or; /* Whether we're in an or chain */
-} ecs_rule_compile_ctrlflow_t;
-
-/* Rule compiler state */
-typedef struct {
-    ecs_vec_t *ops;
-    ecs_write_flags_t written; /* Bitmask to check which variables have been written */
-    ecs_write_flags_t cond_written; /* Track conditional writes (optional operators) */
-
-    /* Maintain control flow per scope */
-    ecs_rule_compile_ctrlflow_t ctrlflow[FLECS_QUERY_SCOPE_NESTING_MAX];
-    ecs_rule_compile_ctrlflow_t *cur; /* Current scope */
-
-    int32_t scope; /* Nesting level of query scopes */
-    ecs_flags32_t scope_is_not; /* Whether scope is prefixed with not */
-} ecs_rule_compile_ctx_t;
-
-/* Rule run state */
-typedef struct {
-    uint64_t *written;            /* Bitset to check which variables have been written */
-    ecs_rule_lbl_t op_index;      /* Currently evaluated operation */
-    ecs_var_t *vars;              /* Variable storage */
-    ecs_iter_t *it;               /* Iterator */
-    ecs_rule_op_ctx_t *op_ctx;    /* Operation context (stack) */
-    ecs_world_t *world;           /* Reference to world */
-    const ecs_rule_t *rule;       /* Reference to rule */
-    const ecs_rule_var_t *rule_vars; /* Reference to rule variable array */
-    ecs_flags32_t *source_set;    /* Whether ecs_iter_t::sources is written by instruction */
-    ecs_rule_iter_t *rit;
-} ecs_rule_run_ctx_t;
-
-typedef struct {
-    ecs_rule_var_t var;
-    const char *name;
-} ecs_rule_var_cache_t;
-
-struct ecs_rule_t {
-    ecs_header_t hdr;             /* Poly header */
-    ecs_filter_t filter;          /* Filter */
-
-    /* Variables */
-    ecs_rule_var_t *vars;         /* Variables */
-    int32_t var_count;            /* Number of variables */
-    int32_t var_pub_count;        /* Number of public variables */
-    bool has_table_this;          /* Does rule have [$this] */
-    ecs_hashmap_t tvar_index;     /* Name index for table variables */
-    ecs_hashmap_t evar_index;     /* Name index for entity variables */
-    ecs_rule_var_cache_t vars_cache; /* For trivial rules with only This variables */
-    char **var_names;             /* Array with variable names for iterator */
-
-    ecs_var_id_t *src_vars;       /* Array with ids to source variables for fields */
-    ecs_rule_op_t *ops;           /* Operations */
-    int32_t op_count;             /* Number of operations */
-
-    /* Mixins */
-    ecs_iterable_t iterable;
-    ecs_poly_dtor_t dtor;
-
-#ifdef FLECS_DEBUG
-    int32_t var_size;             /* Used for out of bounds check during compilation */
-#endif
-};
-
-/* Convert integer to label */
-ecs_rule_lbl_t flecs_itolbl(
-    int64_t val);
-
-/* Get ref flags (IsEntity) or IsVar) for ref (Src, First, Second) */
-ecs_flags16_t flecs_rule_ref_flags(
-    ecs_flags16_t flags,
-    ecs_flags16_t kind);
-
-/* Check if variable is written */
-bool flecs_rule_is_written(
-    ecs_var_id_t var_id,
-    uint64_t written);
-
-/* Check if ref is written (calls flecs_rule_is_written)*/
-bool flecs_ref_is_written(
-    const ecs_rule_op_t *op,
-    const ecs_rule_ref_t *ref,
-    ecs_flags16_t kind,
-    uint64_t written);
-
-/* Compile filter to list of operations */
-int flecs_rule_compile(
-    ecs_world_t *world,
-    ecs_stage_t *stage,
-    ecs_rule_t *rule);
-
-/* Get allocator from iterator */
-ecs_allocator_t* flecs_rule_get_allocator(
-    const ecs_iter_t *it);
-
-
-/* Traversal cache for transitive queries. Finds all reachable entities by
- * following a relationship */
-
-/* Find all entities when traversing downwards */
-void flecs_rule_get_trav_down_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_entity_t entity);
-
-/* Find all entities when traversing upwards */
-void flecs_rule_get_trav_up_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_table_t *table);
-
-/* Free traversal cache */
-void flecs_rule_trav_cache_fini(
-    ecs_allocator_t *a,
-    ecs_trav_cache_t *cache);
-
-/* Traversal caches for up traversal. Enables searching upwards until an entity
- * with the queried for id has been found. */
-
-/* Traverse downwards from starting entity to find all tables for which the
- * specified entity is the source of the queried for id ('with'). */
-ecs_trav_down_t* flecs_rule_get_down_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_up_cache_t *cache,
-    ecs_entity_t trav,
-    ecs_entity_t entity,
-    ecs_id_record_t *idr_with,
-    bool self);
-
-/* Free down traversal cache */
-void flecs_rule_down_cache_fini(
-    ecs_allocator_t *a,
-    ecs_trav_up_cache_t *cache);
-
-ecs_trav_up_t* flecs_rule_get_up_cache(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_trav_up_cache_t *cache,
-    ecs_table_t *table,
-    ecs_id_t with,
-    ecs_entity_t trav,
-    ecs_id_record_t *idr_with,
-    ecs_id_record_t *idr_trav);
-
-/* Free up traversal cache */
-void flecs_rule_up_cache_fini(
-    ecs_trav_up_cache_t *cache);
-
-/* Convert instruction kind to string */
-const char* flecs_rule_op_str(
-    uint16_t kind);
-
-/* Iterator for trivial queries. */
-bool flecs_rule_trivial_search(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t until);
-
-/* Iterator for trivial queries. */
-bool flecs_rule_trivial_search_nodata(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t until);
-
-/* Iterator for trivial queries with wildcard matching. */
-bool flecs_rule_trivial_search_w_wildcards(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t until);
-
-/* Trivial test for constrained $this. */
-bool flecs_rule_trivial_test(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    bool first,
-    int32_t term_count);
-
-/* Trivial test for constrained $this with wildcard matching. */
-bool flecs_rule_trivial_test_w_wildcards(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    bool first,
-    int32_t term_count);
-
-#endif
-
-#endif /* FLECS_RULES_PRIVATE_H */
diff --git a/src/addons/rules/trivial_iter.c b/src/addons/rules/trivial_iter.c
deleted file mode 100644
index 17ca2a15f..000000000
--- a/src/addons/rules/trivial_iter.c
+++ /dev/null
@@ -1,254 +0,0 @@
-/**
- * @file addons/rules/engine.c
- * @brief Iterator for trivial queries.
- */
-
-#include "rules.h"
-
-#ifdef FLECS_RULES
-
-static
-bool flecs_rule_trivial_init(
-    ecs_world_t *world,
-    const ecs_filter_t *filter)
-{
-    int32_t t, count = filter->term_count;
-    ecs_term_t *terms = filter->terms;
-
-    for (t = 0; t < count; t ++) {
-        ecs_term_t *term = &terms[t];
-        if (!term->idr) {
-            term->idr = flecs_id_record_get(world, term->id);
-            if (!term->idr) {
-                /* Id doesn't exist, so query can't match */
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-bool flecs_rule_trivial_test(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    bool first,
-    int32_t term_count)
-{
-    if (first) {
-        const ecs_filter_t *filter = &rule->filter;
-        int32_t t;
-        ecs_term_t *terms = filter->terms;
-        ecs_iter_t *it = ctx->it;
-
-        if (!flecs_rule_trivial_init(ctx->world, filter)) {
-            return false;
-        }
-
-        ecs_table_t *table = ctx->vars[0].range.table;
-        ecs_assert(table != NULL, ECS_INVALID_OPERATION, NULL);
-
-        for (t = 0; t < term_count; t ++) {
-            ecs_term_t *term = &terms[t];
-            const ecs_table_record_t *tr = flecs_id_record_get_table(
-                term->idr, table);
-            if (!tr) {
-                return false;
-            }
-
-            it->columns[t] = tr->index + 1;
-            if (it->count && tr->column != -1) {
-                it->ptrs[t] = ecs_vec_get(
-                    &table->data.columns[tr->column].data,
-                    it->sizes[t],
-                    it->offset);
-            }
-        }
-
-        it->table = table;
-        it->entities = &flecs_table_entities_array(table)[it->offset];
-        return true;
-    } else {
-        return false;
-    }
-}
-
-static
-bool flecs_rule_trivial_search_init(
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    const ecs_filter_t *filter,
-    bool first)
-{
-    if (first) {
-        ecs_term_t *terms = filter->terms;
-        if (!flecs_rule_trivial_init(ctx->world, filter)) {
-            return false;
-        }
-
-        if (filter->flags & EcsFilterMatchEmptyTables) {
-            if (!flecs_table_cache_all_iter(&terms[0].idr->cache, &op_ctx->it)){
-                return false;
-            }
-        } else {
-            if (!flecs_table_cache_iter(&terms[0].idr->cache, &op_ctx->it)) {
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-bool flecs_rule_trivial_search(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t term_count)
-{
-    const ecs_filter_t *filter = &rule->filter;
-    int32_t t;
-    ecs_term_t *terms = filter->terms;
-    ecs_iter_t *it = ctx->it;
-
-    if (!flecs_rule_trivial_search_init(ctx, op_ctx, filter, first)) {
-        return false;
-    }
-
-    do {
-        const ecs_table_record_t *tr = flecs_table_cache_next(
-            &op_ctx->it, ecs_table_record_t);
-        if (!tr) {
-            return false;
-        }
-
-        ecs_table_t *table = tr->hdr.table;
-        if (table->flags & (EcsTableIsPrefab|EcsTableIsDisabled)) {
-            continue;
-        }
-
-        for (t = 1; t < term_count; t ++) {
-            ecs_term_t *term = &terms[t];
-            const ecs_table_record_t *tr_with = flecs_id_record_get_table(
-                term->idr, table);
-            if (!tr_with) {
-                break;
-            }
-
-            it->columns[t] = tr_with->index + 1;
-            if (tr_with->column != -1) {
-                it->ptrs[t] = ecs_vec_first(
-                    &table->data.columns[tr_with->column].data);
-            }
-        }
-
-        if (t == term_count) {
-            ctx->vars[0].range.table = table;
-            ctx->vars[0].range.count = 0;
-            ctx->vars[0].range.offset = 0;
-            it->columns[0] = tr->index + 1;
-            if (tr->column != -1) {
-                it->ptrs[0] = ecs_vec_first(
-                    &table->data.columns[tr->column].data);
-            }
-            break;
-        }
-    } while (true);
-
-    return true;
-}
-
-bool flecs_rule_trivial_search_w_wildcards(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t term_count)
-{
-    bool result = flecs_rule_trivial_search(
-        rule, ctx, op_ctx, first, term_count);
-    if (result) {
-        ecs_iter_t *it = ctx->it;
-        ecs_table_t *table = ctx->vars[0].range.table;
-        int32_t t;
-        for (t = 0; t < term_count; t ++) {
-            it->ids[t] = table->type.array[it->columns[t] - 1];
-        }
-    }
-
-    return result;
-}
-
-bool flecs_rule_trivial_test_w_wildcards(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    bool first,
-    int32_t term_count)
-{
-    bool result = flecs_rule_trivial_test(
-        rule, ctx, first, term_count);
-    if (result) {
-        ecs_iter_t *it = ctx->it;
-        ecs_table_t *table = ctx->vars[0].range.table;
-        int32_t t;
-        for (t = 0; t < term_count; t ++) {
-            it->ids[t] = table->type.array[it->columns[t] - 1];
-        }
-    }
-
-    return result;
-}
-
-bool flecs_rule_trivial_search_nodata(
-    const ecs_rule_t *rule,
-    const ecs_rule_run_ctx_t *ctx,
-    ecs_rule_trivial_ctx_t *op_ctx,
-    bool first,
-    int32_t term_count)
-{
-    const ecs_filter_t *filter = &rule->filter;
-    int32_t t;
-    ecs_term_t *terms = filter->terms;
-    ecs_iter_t *it = ctx->it;
-
-    if (!flecs_rule_trivial_search_init(ctx, op_ctx, filter, first)) {
-        return false;
-    }
-
-    do {
-        const ecs_table_record_t *tr = flecs_table_cache_next(
-            &op_ctx->it, ecs_table_record_t);
-        if (!tr) {
-            return false;
-        }
-
-        ecs_table_t *table = tr->hdr.table;
-        if (table->flags & (EcsTableIsPrefab|EcsTableIsDisabled)) {
-            continue;
-        }
-
-        for (t = 1; t < term_count; t ++) {
-            ecs_term_t *term = &terms[t];
-            const ecs_table_record_t *tr_with = flecs_id_record_get_table(
-                term->idr, table);
-            if (!tr_with) {
-                break;
-            }
-
-            it->columns[t] = tr_with->index + 1;
-        }
-
-        if (t == term_count) {
-            ctx->vars[0].range.table = table;
-            ctx->vars[0].range.count = 0;
-            ctx->vars[0].range.offset = 0;
-            it->columns[0] = tr->index + 1;
-            break;
-        }
-    } while (true);
-
-    return true;
-}
-
-#endif
diff --git a/src/addons/script/assembly.c b/src/addons/script/assembly.c
new file mode 100644
index 000000000..bc4f00ac8
--- /dev/null
+++ b/src/addons/script/assembly.c
@@ -0,0 +1,376 @@
+/**
+ * @file addons/script/assembly.c
+ * @brief Script assembly implementation.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+
+/* Assembly ctor to initialize with default property values */
+static
+void flecs_script_assembly_ctor(
+    void *ptr,
+    int32_t count,
+    const ecs_type_info_t *ti)
+{
+    ecs_world_t *world = ti->hooks.ctx;
+    ecs_entity_t assembly_entity = ti->component;
+    
+    const EcsStruct *st = ecs_get(world, assembly_entity, EcsStruct);
+    if (!st) {
+        ecs_os_memset(ptr, 0, count * ti->size);
+        return;
+    }
+
+    const EcsScript *script = ecs_get(world, assembly_entity, EcsScript);
+    if (!script) {
+        ecs_err("assembly '%s' is not a script, cannot construct", ti->name);
+        return;
+    }
+
+    ecs_script_assembly_t *assembly = script->assembly;
+    ecs_assert(assembly != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (st->members.count != assembly->prop_defaults.count) {
+        ecs_err("number of props (%d) of assembly '%s' does not match members"
+            " (%d), cannot construct", assembly->prop_defaults.count, 
+                ti->name, st->members.count);
+        return;
+    }
+
+    const ecs_member_t *members = st->members.array;
+    int32_t i, m, member_count = st->members.count;
+    ecs_script_var_t *values = assembly->prop_defaults.array;
+    for (m = 0; m < member_count; m ++) {
+        const ecs_member_t *member = &members[m];
+        ecs_script_var_t *value = &values[m];
+        const ecs_type_info_t *mti = value->type_info;
+        ecs_assert(mti != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        for (i = 0; i < count; i ++) {
+            void *el = ECS_ELEM(ptr, ti->size, i);
+            ecs_value_copy_w_type_info(world, mti, 
+                ECS_OFFSET(el, member->offset), value->value.ptr);
+        }
+    }
+}
+
+/* Assembly on_set handler to update contents for new property values */
+static
+void flecs_script_assembly_on_set(
+    ecs_iter_t *it)
+{
+    if (it->table->flags & EcsTableIsPrefab) {
+        /* Don't instantiate assemblies for prefabs */
+        return;
+    }
+
+    ecs_world_t *world = it->world;
+    ecs_entity_t assembly_entity = ecs_field_id(it, 0);
+    ecs_record_t *r = ecs_record_find(world, assembly_entity);
+    if (!r) {
+        ecs_err("assembly entity is empty (should never happen)");
+        return;
+    }
+
+    const EcsScript *script = ecs_record_get(world, r, EcsScript);
+    if (!script) {
+        ecs_err("assembly is missing script component");
+        return;
+    }
+
+    ecs_script_assembly_t *assembly = script->assembly;
+    ecs_assert(assembly != NULL, ECS_INTERNAL_ERROR, NULL);
+    const ecs_type_info_t *ti = assembly->type_info;
+    ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+    const EcsStruct *st = ecs_record_get(world, r, EcsStruct);
+
+    void *data = ecs_field_w_size(it, flecs_ito(size_t, ti->size), 0);
+
+    ecs_script_eval_visitor_t v;
+    flecs_script_eval_visit_init(script->script, &v);
+    ecs_vec_t prev_using = v.using;
+    v.using = assembly->using_;
+
+    ecs_script_scope_t *scope = assembly->node->scope;
+
+    /* Dummy entity node for instance */
+    ecs_script_entity_t instance_node = {
+        .node = {
+            .kind = EcsAstEntity,
+            .pos = assembly->node->node.pos
+        },
+        .scope = scope
+    };
+
+    v.entity = &instance_node;
+
+    int32_t i, m;
+    for (i = 0; i < it->count; i ++) {
+        v.parent = it->entities[i];
+        instance_node.eval = it->entities[i];
+
+        /* Create variables to hold assembly properties */
+        ecs_script_vars_t *vars = flecs_script_vars_push(
+            NULL, &v.stack, v.allocator);
+
+        /* Populate properties from assembly members */
+        if (st) {
+            const ecs_member_t *members = st->members.array;
+            for (m = 0; m < st->members.count; m ++) {
+                const ecs_member_t *member = &members[m];
+
+                /* Assign assembly property from assembly instance */
+                ecs_script_var_t *var = ecs_script_vars_declare(vars, member->name);
+                var->value.type = member->type;
+                var->value.ptr = ECS_OFFSET(data, member->offset);
+            }
+        }
+
+        /* Populate $this variable with instance entity */
+        ecs_entity_t instance = it->entities[i];
+        ecs_script_var_t *var = ecs_script_vars_declare(vars, "this");
+        var->value.type = ecs_id(ecs_entity_t);
+        var->value.ptr = &instance;
+
+        bool is_defer = ecs_is_deferred(world);
+        ecs_suspend_readonly_state_t srs;
+        ecs_world_t *real_world = NULL;
+        if (is_defer) {
+            ecs_assert(flecs_poly_is(world, ecs_world_t), ECS_INTERNAL_ERROR, NULL);
+            real_world = flecs_suspend_readonly(world, &srs);
+            ecs_assert(real_world != NULL, ECS_INTERNAL_ERROR, NULL);
+        }
+
+        ecs_script_clear(world, assembly_entity, instance);
+
+        /* Run assembly code */
+        v.vars = vars;
+        ecs_script_visit_scope(&v, scope);
+
+        if (is_defer) {
+            flecs_resume_readonly(real_world, &srs);
+        }
+
+        /* Pop variable scope */
+        ecs_script_vars_pop(vars);
+
+        data = ECS_OFFSET(data, ti->size);
+    }
+
+    v.using = prev_using;
+    flecs_script_eval_visit_fini(&v);
+}
+
+static
+int flecs_script_eval_prop(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_var_node_t *node)
+{
+    ecs_script_assembly_t *assembly = v->assembly;
+    ecs_script_var_t *var = ecs_script_vars_declare(v->vars, node->name);
+    if (!var) {
+        flecs_script_eval_error(v, node, 
+            "variable '%s' redeclared", node->name);
+        return -1;
+    }
+
+    if (node->type) {
+        ecs_entity_t type = flecs_script_find_entity(v, 0, node->type);
+        if (!type) {
+            flecs_script_eval_error(v, node,
+                "unresolved type '%s' for const variable '%s'", 
+                    node->type, node->name);
+            return -1;
+        }
+
+        const ecs_type_info_t *ti = flecs_script_get_type_info(v, node, type);
+        if (!ti) {
+            return -1;
+        }
+
+        var->value.type = type;
+        var->value.ptr = flecs_stack_alloc(&v->stack, ti->size, ti->alignment);
+        var->type_info = ti;
+
+        if (flecs_script_eval_expr(v, node->expr, &var->value)) {
+            return -1;
+        }
+
+        ecs_script_var_t *value = ecs_vec_append_t(&v->base.script->allocator, 
+            &assembly->prop_defaults, ecs_script_var_t);
+        value->value.ptr = flecs_calloc(&v->base.script->allocator, ti->size);
+        value->value.type = type;
+        value->type_info = ti;
+        ecs_value_copy_w_type_info(
+            v->world, ti, value->value.ptr, var->value.ptr);
+
+        ecs_entity_t mbr = ecs_entity(v->world, {
+            .name = node->name,
+            .parent = assembly->entity
+        });
+
+        ecs_set(v->world, mbr, EcsMember, { .type = var->value.type });
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_assembly_eval(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node)
+{
+    switch(node->kind) {
+    case EcsAstProp:
+        return flecs_script_eval_prop(v, (ecs_script_var_node_t*)node);
+    case EcsAstScope:
+    case EcsAstTag:
+    case EcsAstComponent:
+    case EcsAstVarComponent:
+    case EcsAstDefaultComponent:
+    case EcsAstWithVar:
+    case EcsAstWithTag:
+    case EcsAstWithComponent:
+    case EcsAstWith:
+    case EcsAstUsing:
+    case EcsAstModule:
+    case EcsAstAnnotation:
+    case EcsAstAssembly:
+    case EcsAstConst:
+    case EcsAstEntity:
+    case EcsAstPairScope:
+    case EcsAstIf:
+        break;
+    }
+
+    return flecs_script_eval_node(v, node);
+}
+
+static
+int flecs_script_assembly_preprocess(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_assembly_t *assembly)
+{
+    v->assembly = assembly;
+    v->base.visit = (ecs_visit_action_t)flecs_script_assembly_eval;
+    v->vars = flecs_script_vars_push(v->vars, &v->stack, v->allocator);
+    int result = ecs_script_visit_scope(v, assembly->node->scope);
+    v->vars = ecs_script_vars_pop(v->vars);
+    v->assembly = NULL;
+    return result;
+}
+
+static
+int flecs_script_assembly_hoist_using(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_assembly_t *assembly)
+{
+    if (v->module) {
+        ecs_vec_append_t(
+            v->allocator, &assembly->using_, ecs_entity_t)[0] = v->module;
+    }
+
+    int i, count = ecs_vec_count(&v->using);
+    for (i = 0; i < count; i ++) {
+        ecs_vec_append_t(v->allocator, &assembly->using_, ecs_entity_t)[0] = 
+            ecs_vec_get_t(&v->using, ecs_entity_t, i)[0];
+    }
+
+    return 0;
+}
+
+ecs_script_assembly_t* flecs_script_assembly_init(
+    ecs_script_t *script)
+{
+    ecs_allocator_t *a = &script->allocator;
+    ecs_script_assembly_t *result = flecs_alloc_t(a, ecs_script_assembly_t);
+    ecs_vec_init_t(NULL, &result->prop_defaults, ecs_script_var_t, 0);
+    ecs_vec_init_t(NULL, &result->using_, ecs_entity_t, 0);
+    return result;
+}
+
+void flecs_script_assembly_fini(
+    ecs_script_t *script,
+    ecs_script_assembly_t *assembly)
+{
+    ecs_assert(script != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_allocator_t *a = &script->allocator;
+
+    int32_t i, count = ecs_vec_count(&assembly->prop_defaults);
+    ecs_script_var_t *values = ecs_vec_first(&assembly->prop_defaults);
+    for (i = 0; i < count; i ++) {
+        ecs_script_var_t *value = &values[i];
+        const ecs_type_info_t *ti = value->type_info;
+        if (ti->hooks.dtor) {
+            ti->hooks.dtor(value->value.ptr, 1, ti);
+        }
+        flecs_free(a, ti->size, value->value.ptr);
+    }
+
+    ecs_vec_fini_t(a, &assembly->prop_defaults, ecs_script_var_t);
+    ecs_vec_fini_t(a, &assembly->using_, ecs_entity_t);
+    flecs_free_t(a, ecs_script_assembly_t, assembly);
+}
+
+/* Create new assembly */
+int flecs_script_eval_assembly(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_assembly_node_t *node)
+{
+    ecs_entity_t assembly_entity = flecs_script_create_entity(v, node->name);
+    if (!assembly_entity) {
+        return -1;
+    }
+
+    ecs_script_assembly_t *assembly = flecs_script_assembly_init(v->base.script);
+    assembly->entity = assembly_entity;
+    assembly->node = node;
+
+    if (flecs_script_assembly_preprocess(v, assembly)) {
+        goto error;
+    }
+
+    if (flecs_script_assembly_hoist_using(v, assembly)) {
+        goto error;
+    }
+
+    /* If assembly has no props, give assembly dummy size so we can register
+     * hooks for it. */
+    if (!ecs_has(v->world, assembly_entity, EcsComponent)) {
+        ecs_set(v->world, assembly_entity, EcsComponent, {1, 1});
+    }
+
+    assembly->type_info = ecs_get_type_info(v->world, assembly_entity);
+
+    ecs_add_id(v->world, assembly_entity, EcsAlwaysOverride);
+
+    EcsScript *script = ecs_ensure(v->world, assembly_entity, EcsScript);
+    if (script->script) {
+        if (script->assembly) {
+            flecs_script_assembly_fini(script->script, script->assembly);
+        }
+        ecs_script_free(script->script);
+    }
+
+    script->script = v->base.script;
+    script->assembly = assembly;
+    ecs_modified(v->world, assembly_entity, EcsScript);
+
+    ecs_set_hooks_id(v->world, assembly_entity, &(ecs_type_hooks_t) {
+        .ctor = flecs_script_assembly_ctor,
+        .on_set = flecs_script_assembly_on_set,
+        .ctx = v->world
+    });
+
+    /* Keep script alive for as long as assembly is alive */
+    v->base.script->refcount ++;
+
+    return 0;
+error:
+    flecs_script_assembly_fini(v->base.script, assembly);
+    return -1;
+}
+
+#endif
diff --git a/src/addons/script/ast.c b/src/addons/script/ast.c
new file mode 100644
index 000000000..9beb20b32
--- /dev/null
+++ b/src/addons/script/ast.c
@@ -0,0 +1,301 @@
+/**
+ * @file addons/script/ast.c
+ * @brief Script AST implementation.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+
+#define flecs_ast_strdup(parser, str)\
+    (str ? flecs_strdup(&parser->script->allocator, str) : NULL)
+#define flecs_ast_new(parser, T, kind)\
+    (T*)flecs_ast_new_(parser, ECS_SIZEOF(T), kind)
+#define flecs_ast_vec(parser, vec, T) \
+    ecs_vec_init_t(&parser->script->allocator, &vec, T*, 0)
+#define flecs_ast_append(parser, vec, T, node) \
+    ecs_vec_append_t(&parser->script->allocator, &vec, T*)[0] = node
+
+static
+void* flecs_ast_new_(
+    ecs_script_parser_t *parser,
+    ecs_size_t size, 
+    ecs_script_node_kind_t kind)
+{
+    ecs_assert(parser->script != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_allocator_t *a = &parser->script->allocator;
+    ecs_script_node_t *result = flecs_calloc(a, size);
+    result->kind = kind;
+    result->pos = parser->pos;
+    return result;
+}
+
+ecs_script_scope_t* flecs_script_scope_new(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *result = flecs_ast_new(
+        parser, ecs_script_scope_t, EcsAstScope);
+    flecs_ast_vec(parser, result->stmts, ecs_script_node_t);
+    return result;
+}
+
+bool flecs_scope_is_empty(
+    ecs_script_scope_t *scope)
+{
+    return ecs_vec_count(&scope->stmts) == 0;
+}
+
+ecs_script_scope_t* flecs_script_insert_scope(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_script_scope_t *result = flecs_script_scope_new(parser);
+    flecs_ast_append(parser, scope->stmts, ecs_script_scope_t, result);
+    return result;
+}
+
+ecs_script_entity_t* flecs_script_insert_entity(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_entity_t *result = flecs_ast_new(
+        parser, ecs_script_entity_t, EcsAstEntity);
+
+    if (name && !ecs_os_strcmp(name, "_")) {
+        name = NULL;
+    }
+
+    result->name = name;
+
+    ecs_script_scope_t *entity_scope = flecs_script_scope_new(parser);
+    ecs_assert(entity_scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    result->scope = entity_scope;
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_entity_t, result);
+    return result;
+}
+
+static
+void flecs_script_set_id(
+    ecs_script_id_t *id,
+    const char *first,
+    const char *second)
+{
+    ecs_assert(first != NULL, ECS_INTERNAL_ERROR, NULL);
+    id->first = first;
+    id->second = second;
+}
+
+ecs_script_pair_scope_t* flecs_script_insert_pair_scope(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_script_pair_scope_t *result = flecs_ast_new(
+        parser, ecs_script_pair_scope_t, EcsAstPairScope);
+    flecs_script_set_id(&result->id, first, second);
+    result->scope = flecs_script_scope_new(parser);
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_pair_scope_t, result);
+    return result;
+}
+
+ecs_script_tag_t* flecs_script_insert_pair_tag(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_tag_t *result = flecs_ast_new(
+        parser, ecs_script_tag_t, EcsAstTag);
+    flecs_script_set_id(&result->id, first, second);
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_tag_t, result);
+
+    return result;
+}
+
+ecs_script_tag_t* flecs_script_insert_tag(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    return flecs_script_insert_pair_tag(parser, name, NULL);
+}
+
+ecs_script_component_t* flecs_script_insert_pair_component(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_component_t *result = flecs_ast_new(
+            parser, ecs_script_component_t, EcsAstComponent);
+    flecs_script_set_id(&result->id, first, second);
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_component_t, result);
+
+    return result;
+}
+
+ecs_script_component_t* flecs_script_insert_component(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    return flecs_script_insert_pair_component(parser, name, NULL);
+}
+
+ecs_script_default_component_t* flecs_script_insert_default_component(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_default_component_t *result = flecs_ast_new(
+            parser, ecs_script_default_component_t, EcsAstDefaultComponent);
+
+    flecs_ast_append(parser, scope->stmts, 
+        ecs_script_default_component_t, result);
+
+    return result;
+}
+
+ecs_script_var_component_t* flecs_script_insert_var_component(
+    ecs_script_parser_t *parser,
+    const char *var_name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(var_name != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_var_component_t *result = flecs_ast_new(
+            parser, ecs_script_var_component_t, EcsAstVarComponent);
+    result->name = var_name;
+
+    flecs_ast_append(parser, scope->stmts, 
+        ecs_script_var_component_t, result);
+    return result;
+}
+
+ecs_script_with_t* flecs_script_insert_with(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_with_t *result = flecs_ast_new(
+        parser, ecs_script_with_t, EcsAstWith);
+
+    result->expressions = flecs_script_scope_new(parser);
+    result->scope = flecs_script_scope_new(parser);
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_with_t, result);
+    return result;
+}
+
+ecs_script_using_t* flecs_script_insert_using(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_using_t *result = flecs_ast_new(
+        parser, ecs_script_using_t, EcsAstUsing);
+
+    result->name = name;
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_using_t, result);
+    return result;
+}
+
+ecs_script_module_t* flecs_script_insert_module(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_module_t *result = flecs_ast_new(
+        parser, ecs_script_module_t, EcsAstModule);
+
+    result->name = name;
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_module_t, result);
+    return result;
+}
+
+ecs_script_annot_t* flecs_script_insert_annot(
+    ecs_script_parser_t *parser,
+    const char *name,
+    const char *expr)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_annot_t *result = flecs_ast_new(
+        parser, ecs_script_annot_t, EcsAstAnnotation);
+
+    result->name = name;
+    result->expr = expr;
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_annot_t, result);
+    return result;
+}
+
+ecs_script_assembly_node_t* flecs_script_insert_assembly(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_assembly_node_t *result = flecs_ast_new(
+        parser, ecs_script_assembly_node_t, EcsAstAssembly);
+    result->name = name;
+    result->scope = flecs_script_scope_new(parser);
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_assembly_node_t, result);
+    return result;
+}
+
+ecs_script_var_node_t* flecs_script_insert_var(
+    ecs_script_parser_t *parser,
+    const char *name)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_var_node_t *result = flecs_ast_new(
+        parser, ecs_script_var_node_t, EcsAstConst);
+    result->name = name;
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_var_node_t, result);
+    return result;
+}
+
+ecs_script_if_t* flecs_script_insert_if(
+    ecs_script_parser_t *parser)
+{
+    ecs_script_scope_t *scope = parser->scope;
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_if_t *result = flecs_ast_new(
+        parser, ecs_script_if_t, EcsAstIf);
+    result->if_true = flecs_script_scope_new(parser);
+    result->if_false = flecs_script_scope_new(parser);
+
+    flecs_ast_append(parser, scope->stmts, ecs_script_if_t, result);
+    return result;
+}
+
+#endif
diff --git a/src/addons/script/ast.h b/src/addons/script/ast.h
new file mode 100644
index 000000000..e80a215e2
--- /dev/null
+++ b/src/addons/script/ast.h
@@ -0,0 +1,209 @@
+/**
+ * @file addons/script/ast.h
+ * @brief Script AST.
+ */
+
+#ifndef FLECS_SCRIPT_AST_H
+#define FLECS_SCRIPT_AST_H
+
+typedef enum ecs_script_node_kind_t {
+    EcsAstScope,
+    EcsAstTag,
+    EcsAstComponent,
+    EcsAstDefaultComponent,
+    EcsAstVarComponent,
+    EcsAstWithVar,
+    EcsAstWithTag,
+    EcsAstWithComponent,
+    EcsAstWith,
+    EcsAstUsing,
+    EcsAstModule,
+    EcsAstAnnotation,
+    EcsAstAssembly,
+    EcsAstProp,
+    EcsAstConst,
+    EcsAstEntity,
+    EcsAstPairScope,
+    EcsAstIf,
+} ecs_script_node_kind_t;
+
+typedef struct ecs_script_node_t {
+    ecs_script_node_kind_t kind;
+    const char *pos;
+} ecs_script_node_t;
+
+struct ecs_script_scope_t {
+    ecs_script_node_t node;
+    ecs_vec_t stmts;
+    ecs_script_scope_t *parent;
+    ecs_id_t default_component_eval;
+};
+
+typedef struct ecs_script_id_t {
+    const char *first;
+    const char *second;
+    ecs_id_t eval;
+} ecs_script_id_t;
+
+typedef struct ecs_script_tag_t {
+    ecs_script_node_t node;
+    ecs_script_id_t id;
+} ecs_script_tag_t;
+
+typedef struct ecs_script_component_t {
+    ecs_script_node_t node;
+    ecs_script_id_t id;
+    const char *expr;
+    ecs_value_t eval;
+    bool is_collection;
+} ecs_script_component_t;
+
+typedef struct ecs_script_default_component_t {
+    ecs_script_node_t node;
+    const char *expr;
+    ecs_value_t eval;
+} ecs_script_default_component_t;
+
+typedef struct ecs_script_var_component_t {
+    ecs_script_node_t node;
+    const char *name;
+} ecs_script_var_component_t;
+
+struct ecs_script_entity_t {
+    ecs_script_node_t node;
+    const char *kind;
+    const char *name;
+    bool name_is_var;
+    bool kind_w_expr;
+    ecs_script_scope_t *scope;
+
+    // Populated during eval
+    ecs_script_entity_t *parent;
+    ecs_entity_t eval;
+    ecs_entity_t eval_kind;
+};
+
+typedef struct ecs_script_with_t {
+    ecs_script_node_t node;
+    ecs_script_scope_t *expressions;
+    ecs_script_scope_t *scope;
+} ecs_script_with_t;
+
+typedef struct ecs_script_inherit_t {
+    ecs_script_node_t node;
+    ecs_script_scope_t *base_list;
+} ecs_script_inherit_t;
+
+typedef struct ecs_script_pair_scope_t {
+    ecs_script_node_t node;
+    ecs_script_id_t id;
+    ecs_script_scope_t *scope;
+} ecs_script_pair_scope_t;
+
+typedef struct ecs_script_using_t {
+    ecs_script_node_t node;
+    const char *name;
+} ecs_script_using_t;
+
+typedef struct ecs_script_module_t {
+    ecs_script_node_t node;
+    const char *name;
+} ecs_script_module_t;
+
+typedef struct ecs_script_annot_t {
+    ecs_script_node_t node;
+    const char *name;
+    const char *expr;
+} ecs_script_annot_t;
+
+typedef struct ecs_script_assembly_node_t {
+    ecs_script_node_t node;
+    const char *name;
+    ecs_script_scope_t* scope;
+} ecs_script_assembly_node_t;
+
+typedef struct ecs_script_var_node_t {
+    ecs_script_node_t node;
+    const char *name;
+    const char *type;
+    const char *expr;
+} ecs_script_var_node_t;
+
+typedef struct ecs_script_if_t {
+    ecs_script_node_t node;
+    ecs_script_scope_t *if_true;
+    ecs_script_scope_t *if_false;
+    const char *expr;
+} ecs_script_if_t;
+
+#define ecs_script_node(kind, node)\
+    ((ecs_script_##kind##_t*)node)
+
+bool flecs_scope_is_empty(
+    ecs_script_scope_t *scope);
+
+ecs_script_scope_t* flecs_script_insert_scope(
+    ecs_script_parser_t *parser);
+
+ecs_script_entity_t* flecs_script_insert_entity(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_pair_scope_t* flecs_script_insert_pair_scope(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second);
+
+ecs_script_with_t* flecs_script_insert_with(
+    ecs_script_parser_t *parser);
+
+ecs_script_using_t* flecs_script_insert_using(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_module_t* flecs_script_insert_module(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_assembly_node_t* flecs_script_insert_assembly(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_annot_t* flecs_script_insert_annot(
+    ecs_script_parser_t *parser,
+    const char *name,
+    const char *expr);
+
+ecs_script_var_node_t* flecs_script_insert_var(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_tag_t* flecs_script_insert_tag(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_tag_t* flecs_script_insert_pair_tag(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second);
+
+ecs_script_component_t* flecs_script_insert_component(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_component_t* flecs_script_insert_pair_component(
+    ecs_script_parser_t *parser,
+    const char *first,
+    const char *second);
+
+ecs_script_default_component_t* flecs_script_insert_default_component(
+    ecs_script_parser_t *parser);
+
+ecs_script_var_component_t* flecs_script_insert_var_component(
+    ecs_script_parser_t *parser,
+    const char *name);
+
+ecs_script_if_t* flecs_script_insert_if(
+    ecs_script_parser_t *parser);
+
+#endif
diff --git a/src/addons/expr/deserialize.c b/src/addons/script/expr.c
similarity index 89%
rename from src/addons/expr/deserialize.c
rename to src/addons/script/expr.c
index 189fb0c8c..4c56a4a53 100644
--- a/src/addons/expr/deserialize.c
+++ b/src/addons/script/expr.c
@@ -1,14 +1,15 @@
 /**
- * @file expr/deserialize.c
- * @brief Deserialize flecs string format into (component) values.
+ * @file addons/script/expr.c
+ * @brief Evaluate script expressions.
  */
 
-#include "../../private_api.h"
-#include <ctype.h>
+#include "flecs.h"
 
-#ifdef FLECS_EXPR
+#ifdef FLECS_SCRIPT
+#include <ctype.h>
+#include "script.h"
 
-/* String deserializer for values & simple expressions */
+/* String deserializer for script expressions */
 
 /* Order in enumeration is important, as it is used for precedence */
 typedef enum ecs_expr_oper_t {
@@ -32,7 +33,7 @@ typedef enum ecs_expr_oper_t {
 } ecs_expr_oper_t;
 
 /* Used to track temporary values */
-#define EXPR_MAX_STACK_SIZE (256)
+#define FLECS_EXPR_MAX_STACK_SIZE (256)
 
 typedef struct ecs_expr_value_t {
     const ecs_type_info_t *ti;
@@ -40,7 +41,7 @@ typedef struct ecs_expr_value_t {
 } ecs_expr_value_t;
 
 typedef struct ecs_value_stack_t {
-    ecs_expr_value_t values[EXPR_MAX_STACK_SIZE];
+    ecs_expr_value_t values[FLECS_EXPR_MAX_STACK_SIZE];
     ecs_stack_cursor_t *cursor;
     ecs_stack_t *stack;
     ecs_stage_t *stage;
@@ -48,13 +49,155 @@ typedef struct ecs_value_stack_t {
 } ecs_value_stack_t;
 
 static
-const char* flecs_parse_expr(
+const char* flecs_script_expr_run(
     ecs_world_t *world,
     ecs_value_stack_t *stack,
     const char *ptr,
     ecs_value_t *value,
     ecs_expr_oper_t op,
-    const ecs_parse_expr_desc_t *desc);
+    const ecs_script_expr_run_desc_t *desc);
+
+#define TOK_VARIABLE '$'
+
+/* -- Private functions -- */
+
+static
+bool flecs_isident(
+    char ch)
+{
+    return isalpha(ch) || (ch == '_');
+}
+
+static
+bool flecs_valid_identifier_start_char(
+    char ch)
+{
+    if (ch && (flecs_isident(ch) || (ch == '*') ||
+        (ch == '0') || (ch == TOK_VARIABLE) || isdigit(ch))) 
+    {
+        return true;
+    }
+
+    return false;
+}
+
+static
+bool flecs_valid_token_start_char(
+    char ch)
+{
+    if ((ch == '"') || (ch == '{') || (ch == '}') || (ch == ',') || (ch == '-')
+        || (ch == '[') || (ch == ']') || (ch == '`') || 
+        flecs_valid_identifier_start_char(ch))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+static
+bool flecs_valid_token_char(
+    char ch)
+{
+    if (ch && (flecs_isident(ch) || isdigit(ch) || ch == '.' || ch == '"')) {
+        return true;
+    }
+
+    return false;
+}
+
+static
+const char* flecs_parse_ws(
+    const char *ptr)
+{
+    while ((*ptr != '\n') && isspace(*ptr)) {
+        ptr ++;
+    }
+
+    return ptr;
+}
+
+static
+const char* flecs_parse_expr_token(
+    const char *name,
+    const char *expr,
+    const char *ptr,
+    char *token_out,
+    char delim)
+{
+    int64_t column = ptr - expr;
+
+    ptr = flecs_parse_ws(ptr);
+    char *tptr = token_out, ch = ptr[0];
+
+    if (!flecs_valid_token_start_char(ch)) {
+        if (ch == '\0' || ch == '\n') {
+            ecs_parser_error(name, expr, column, 
+                "unexpected end of expression");
+        } else {
+            ecs_parser_error(name, expr, column, 
+                "invalid start of token '%s'", ptr);
+        }
+        return NULL;
+    }
+
+    tptr[0] = ch;
+    tptr ++;
+    ptr ++;
+
+    if (ch == '{' || ch == '}' || ch == '[' || ch == ']' || ch == ',' || ch == '`') {
+        tptr[0] = 0;
+        return ptr;
+    }
+
+    int tmpl_nesting = 0;
+    bool in_str = ch == '"';
+
+    for (; (ch = *ptr); ptr ++) {
+        if (ch == '<') {
+            tmpl_nesting ++;
+        } else if (ch == '>') {
+            if (!tmpl_nesting) {
+                break;
+            }
+            tmpl_nesting --;
+        } else if (ch == '"') {
+            in_str = !in_str;
+        } else if (ch == '\\') {
+            ptr ++;
+            tptr[0] = ptr[0];
+            tptr ++;
+            continue;
+        } else if (!flecs_valid_token_char(ch) && !in_str) {
+            break;
+        }
+
+        if (delim && (ch == delim)) {
+            break;
+        }
+
+        tptr[0] = ch;
+        tptr ++;
+    }
+
+    tptr[0] = '\0';
+
+    if (tmpl_nesting != 0) {
+        ecs_parser_error(name, expr, column, 
+            "identifier '%s' has mismatching < > pairs", ptr);
+        return NULL;
+    }
+
+    const char *next_ptr = flecs_parse_ws(ptr);
+    if (next_ptr[0] == ':' && next_ptr != ptr) {
+        /* Whitespace between token and : is significant */
+        ptr = next_ptr - 1;
+    } else {
+        ptr = next_ptr;
+    }
+
+    return ptr;
+}
 
 static
 void* flecs_expr_value_new(
@@ -143,7 +286,8 @@ const char* flecs_str_to_expr_oper(
     return NULL;
 }
 
-const char *ecs_parse_expr_token(
+static
+const char *flecs_script_expr_parse_token(
     const char *name,
     const char *expr,
     const char *ptr,
@@ -157,13 +301,13 @@ const char *ecs_parse_expr_token(
             // Single line comment
             for (ptr = &ptr[2]; (ch = ptr[0]) && (ch != '\n'); ptr ++) {}
             token[0] = 0;
-            return ecs_parse_ws_eol(ptr);
+            return flecs_parse_ws_eol(ptr);
         } else if (ptr[1] == '*') {
             // Multi line comment
             for (ptr = &ptr[2]; (ch = ptr[0]); ptr ++) {
                 if (ch == '*' && ptr[1] == '/') {
                     token[0] = 0;
-                    return ecs_parse_ws_eol(ptr + 2);
+                    return flecs_parse_ws_eol(ptr + 2);
                 }
             }
 
@@ -186,7 +330,7 @@ const char *ecs_parse_expr_token(
         }
     }
 
-    while ((ptr = ecs_parse_token(name, expr, ptr, token_ptr, 0))) {
+    while ((ptr = flecs_parse_expr_token(name, expr, ptr, token_ptr, 0))) {
         if (ptr[0] == '|' && ptr[1] != '|') {
             token_ptr = &token_ptr[ecs_os_strlen(token_ptr)];
             token_ptr[0] = '|';
@@ -257,7 +401,7 @@ bool flecs_parse_is_float(
 static
 ecs_value_t flecs_dotresolve_var(
     ecs_world_t *world,
-    ecs_vars_t *vars,
+    ecs_script_vars_t *vars,
     char *token)
 {
     char *dot = strchr(token, '.');
@@ -267,7 +411,7 @@ ecs_value_t flecs_dotresolve_var(
 
     dot[0] = '\0';
 
-    const ecs_expr_var_t *var = ecs_vars_lookup(vars, token);
+    const ecs_script_var_t *var = ecs_script_vars_lookup(vars, token);
     if (!var) {
         return (ecs_value_t){0};
     }
@@ -351,7 +495,7 @@ ecs_entity_t flecs_parse_discover_type(
     const char *expr,
     const char *ptr,
     ecs_entity_t input_type,
-    const ecs_parse_expr_desc_t *desc)
+    const ecs_script_expr_run_desc_t *desc)
 {
     /* String literal */
     if (ptr[0] == '"' || ptr[0] == '`') {
@@ -391,11 +535,11 @@ ecs_entity_t flecs_parse_discover_type(
             return 0;
         }
         char token[ECS_MAX_TOKEN_SIZE];
-        if (ecs_parse_expr_token(name, expr, &ptr[1], token) == NULL) {
+        if (flecs_script_expr_parse_token(name, expr, &ptr[1], token) == NULL) {
             return 0;
         }
 
-        const ecs_expr_var_t *var = ecs_vars_lookup(desc->vars, token);
+        const ecs_script_var_t *var = ecs_script_vars_lookup(desc->vars, token);
         if (!var) {
             ecs_size_t len = ecs_os_strlen(token);
             if (ptr[len + 1] == '(') {
@@ -902,7 +1046,7 @@ const char* flecs_binary_expr_parse(
     ecs_value_t *lvalue,
     ecs_value_t *result,
     ecs_expr_oper_t left_op,
-    const ecs_parse_expr_desc_t *desc)
+    const ecs_script_expr_run_desc_t *desc)
 {
     ecs_entity_t result_type = result->type;
     do {
@@ -913,10 +1057,10 @@ const char* flecs_binary_expr_parse(
             return NULL;
         }
 
-        ptr = ecs_parse_ws_eol(ptr);
+        ptr = flecs_parse_ws_eol(ptr);
 
         ecs_value_t rvalue = {0};
-        const char *rptr = flecs_parse_expr(world, stack, ptr, &rvalue, op, desc);
+        const char *rptr = flecs_script_expr_run(world, stack, ptr, &rvalue, op, desc);
         if (!rptr) {
             return NULL;
         }
@@ -963,7 +1107,7 @@ const char* flecs_funccall_parse(
     ecs_meta_cursor_t *cur,
     ecs_value_t *value,
     bool isvar,
-    const ecs_parse_expr_desc_t *desc)
+    const ecs_script_expr_run_desc_t *desc)
 {
     char *sep = strrchr(token, '.');
     if (!sep) {
@@ -980,7 +1124,7 @@ const char* flecs_funccall_parse(
             goto error;
         }
     } else {
-        const ecs_expr_var_t *var = ecs_vars_lookup(desc->vars, token);
+        const ecs_script_var_t *var = ecs_script_vars_lookup(desc->vars, token);
         ecs_meta_set_value(cur, &var->value);
     }
 
@@ -1032,13 +1176,13 @@ const char* flecs_funccall_parse(
 }
 
 static
-const char* flecs_parse_expr(
+const char* flecs_script_expr_run(
     ecs_world_t *world,
     ecs_value_stack_t *stack,
     const char *ptr,
     ecs_value_t *value,
     ecs_expr_oper_t left_op,
-    const ecs_parse_expr_desc_t *desc)
+    const ecs_script_expr_run_desc_t *desc)
 {
     ecs_assert(value != NULL, ECS_INTERNAL_ERROR, NULL);
     char token[ECS_MAX_TOKEN_SIZE];
@@ -1050,13 +1194,13 @@ const char* flecs_parse_expr(
     token[0] = '\0';
     expr = expr ? expr : ptr;
 
-    ptr = ecs_parse_ws_eol(ptr);
+    ptr = flecs_parse_ws_eol(ptr);
 
     /* Check for postfix operators */
     ecs_expr_oper_t unary_op = EcsExprOperUnknown;
     if (ptr[0] == '-' && !isdigit(ptr[1])) {
         unary_op = EcsMin;
-        ptr = ecs_parse_ws_eol(ptr + 1);
+        ptr = flecs_parse_ws_eol(ptr + 1);
     }
 
     /* Initialize storage and cursor. If expression starts with a '(' storage
@@ -1085,7 +1229,7 @@ const char* flecs_parse_expr(
     }
 
     /* Loop that parses all values in a value scope */
-    while ((ptr = ecs_parse_expr_token(name, expr, ptr, token))) {
+    while ((ptr = flecs_script_expr_parse_token(name, expr, ptr, token))) {
         /* Used to track of the result of the parsed token can be used as the
          * lvalue for a binary expression */
         bool is_lvalue = false;
@@ -1107,13 +1251,13 @@ const char* flecs_parse_expr(
             }
 
             /* Parenthesis, parse nested expression */
-            ptr = flecs_parse_expr(world, stack, ptr, out, EcsLeftParen, desc);
+            ptr = flecs_script_expr_run(world, stack, ptr, out, EcsLeftParen, desc);
             if (ptr[0] != ')') {
                 ecs_parser_error(name, expr, ptr - expr, 
                     "missing closing parenthesis");
                 return NULL;
             }
-            ptr = ecs_parse_ws(ptr + 1);
+            ptr = flecs_parse_ws(ptr + 1);
             is_lvalue = true;
 
         } else if (!ecs_os_strcmp(token, "{")) {
@@ -1233,7 +1377,7 @@ const char* flecs_parse_expr(
                 ecs_os_strcpy(&token[1], member);
             }
 
-            const ecs_expr_var_t *var = ecs_vars_lookup(desc->vars, &token[1]);
+            const ecs_script_var_t *var = ecs_script_vars_lookup(desc->vars, &token[1]);
             if (!var) {
                 if (ptr[0] == '(') {
                     /* Function */
@@ -1256,9 +1400,8 @@ const char* flecs_parse_expr(
                 ecs_meta_set_value(&cur, &var->value);
             }
             is_lvalue = true;
-
         } else {
-            const char *tptr = ecs_parse_ws(ptr);
+            const char *tptr = flecs_parse_ws(ptr);
             for (; ptr != tptr; ptr ++) {
                 if (ptr[0] == '\n') {
                     newline = true;
@@ -1358,7 +1501,7 @@ const char* flecs_parse_expr(
             break;
         }
 
-        ptr = ecs_parse_ws_eol(ptr);
+        ptr = flecs_parse_ws_eol(ptr);
     }
 
     if (!value->ptr) {
@@ -1379,11 +1522,11 @@ const char* flecs_parse_expr(
     return NULL;
 }
 
-const char* ecs_parse_expr(
+const char* ecs_script_expr_run(
     ecs_world_t *world,
     const char *ptr,
     ecs_value_t *value,
-    const ecs_parse_expr_desc_t *desc)
+    const ecs_script_expr_run_desc_t *desc)
 {
     /* Prepare storage for temporary values */
     ecs_stage_t *stage = flecs_stage_from_world(&world);
@@ -1395,7 +1538,7 @@ const char* ecs_parse_expr(
 
     /* Parse expression */
     bool storage_provided = value->ptr != NULL;
-    ptr = flecs_parse_expr(world, &stack, ptr, value, EcsExprOperUnknown, desc);
+    ptr = flecs_script_expr_run(world, &stack, ptr, value, EcsExprOperUnknown, desc);
 
     /* If no result value was provided, allocate one as we can't return a 
      * pointer to a temporary storage */
diff --git a/src/addons/script/interpolate.c b/src/addons/script/interpolate.c
new file mode 100644
index 000000000..641c96901
--- /dev/null
+++ b/src/addons/script/interpolate.c
@@ -0,0 +1,176 @@
+/**
+ * @file addons/script/interpolate.c
+ * @brief String interpolation.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include <ctype.h>
+#include "script.h"
+
+static
+const char* flecs_parse_var_name(
+    const char *ptr,
+    char *token_out)
+{
+    char ch, *bptr = token_out;
+
+    while ((ch = *ptr)) {
+        if (bptr - token_out > ECS_MAX_TOKEN_SIZE) {
+            goto error;
+        }
+
+        if (isalpha(ch) || isdigit(ch) || ch == '_') {
+            *bptr = ch;
+            bptr ++;
+            ptr ++;
+        } else {
+            break;
+        }
+    }
+
+    if (bptr == token_out) {
+        goto error;
+    }
+
+    *bptr = '\0';
+
+    return ptr;
+error:
+    return NULL;
+}
+
+static
+const char* flecs_parse_interpolated_str(
+    const char *ptr,
+    char *token_out)
+{
+    char ch, *bptr = token_out;
+
+    while ((ch = *ptr)) {
+        if (bptr - token_out > ECS_MAX_TOKEN_SIZE) {
+            goto error;
+        }
+
+        if (ch == '\\') {
+            if (ptr[1] == '}') {
+                *bptr = '}';
+                bptr ++;
+                ptr += 2;
+                continue;
+            }
+        }
+
+        if (ch != '}') {
+            *bptr = ch;
+            bptr ++;
+            ptr ++;
+        } else {
+            ptr ++;
+            break;
+        }
+    }
+
+    if (bptr == token_out) {
+        goto error;
+    }
+
+    *bptr = '\0';
+
+    return ptr;
+error:
+    return NULL;
+}
+
+char* ecs_script_string_interpolate(
+    ecs_world_t *world,
+    const char *str,
+    const ecs_script_vars_t *vars)
+{
+    char token[ECS_MAX_TOKEN_SIZE];
+    ecs_strbuf_t result = ECS_STRBUF_INIT;
+    const char *ptr;
+    char ch;
+
+    for(ptr = str; (ch = *ptr); ptr++) {
+        if (ch == '\\') {
+            ptr ++;
+            if (ptr[0] == '$') {
+                ecs_strbuf_appendch(&result, '$');
+                continue;
+            }
+            if (ptr[0] == '\\') {
+                ecs_strbuf_appendch(&result, '\\');
+                continue;
+            }
+            if (ptr[0] == '{') {
+                ecs_strbuf_appendch(&result, '{');
+                continue;
+            }
+            if (ptr[0] == '}') {
+                ecs_strbuf_appendch(&result, '}');
+                continue;
+            }
+            ptr --;
+        }
+
+        if (ch == '$') {
+            ptr = flecs_parse_var_name(ptr + 1, token);
+            if (!ptr) {
+                ecs_parser_error(NULL, str, ptr - str, 
+                    "invalid variable name '%s'", ptr);
+                goto error;
+            }
+
+            ecs_script_var_t *var = ecs_script_vars_lookup(vars, token);
+            if (!var) {
+                ecs_parser_error(NULL, str, ptr - str, 
+                    "unresolved variable '%s'", token);
+                goto error;
+            }
+
+            if (ecs_ptr_to_str_buf(
+                world, var->value.type, var->value.ptr, &result)) 
+            {
+                goto error;
+            }
+
+            ptr --;
+        } else if (ch == '{') {
+            ptr = flecs_parse_interpolated_str(ptr + 1, token);
+            if (!ptr) {
+                ecs_parser_error(NULL, str, ptr - str, 
+                    "invalid interpolated expression");
+                goto error;
+            }
+
+            ecs_script_expr_run_desc_t expr_desc = { 
+                .vars = ECS_CONST_CAST(ecs_script_vars_t*, vars) 
+            };
+
+            ecs_value_t expr_result = {0};
+            if (!ecs_script_expr_run(world, token, &expr_result, &expr_desc)) {
+                goto error;
+            }
+
+            if (ecs_ptr_to_str_buf(
+                world, expr_result.type, expr_result.ptr, &result)) 
+            {
+                goto error;
+            }
+
+            ecs_value_free(world, expr_result.type, expr_result.ptr);
+
+            ptr --;
+        } else {
+            ecs_strbuf_appendch(&result, ch);
+        }
+    }
+
+    return ecs_strbuf_get(&result);
+error:
+    return NULL;
+}
+
+#endif
diff --git a/src/addons/script/parser.c b/src/addons/script/parser.c
new file mode 100644
index 000000000..1e15dcece
--- /dev/null
+++ b/src/addons/script/parser.c
@@ -0,0 +1,753 @@
+/**
+ * @file addons/script/parser.c
+ * @brief Script grammar parser.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+#include "parser.h"
+
+#define EcsTokEndOfStatement\
+    case ';':\
+    case '\n':\
+    case '\0'
+
+static
+const char* flecs_script_stmt(
+    ecs_script_parser_t *parser,
+    const char *pos);
+
+/* Parse scope (statements inside {}) */
+static
+const char* flecs_script_scope(
+    ecs_script_parser_t *parser,
+    ecs_script_scope_t *scope,
+    const char *pos)
+{
+    ParserBegin;
+
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(pos[-1] == '{', ECS_INTERNAL_ERROR, NULL);
+
+    ecs_script_scope_t *prev = parser->scope;
+    parser->scope = scope;
+
+    Loop(
+        LookAhead(
+            case EcsTokScopeClose:
+                pos = lookahead;
+                goto scope_close;
+            case EcsTokEnd:
+                Error("unexpected end of script");
+                goto error;
+        )
+
+        pos = flecs_script_stmt(parser, pos);
+        if (!pos) {
+            goto error;
+        }
+    )
+
+scope_close:
+    parser->scope = prev;
+
+    ecs_assert(pos[-1] == '}', ECS_INTERNAL_ERROR, NULL);
+    return pos;
+
+    ParserEnd;
+}
+
+/* Parse comma expression (expressions separated by ',') */
+static
+const char* flecs_script_comma_expr(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    bool is_base_list)
+{
+    ParserBegin;
+
+    Loop(
+        LookAhead(
+            case '\n':
+                pos = lookahead;
+                continue;
+
+            case EcsTokIdentifier:
+                pos = lookahead;
+
+                if (is_base_list) {
+                    flecs_script_insert_pair_tag(parser, "IsA", Token(0));
+                } else {
+                    flecs_script_insert_entity(parser, Token(0));
+                }
+
+                LookAhead_1(',',
+                    pos = lookahead;
+                    continue;
+                )
+        )
+
+        break;
+    )
+
+    return pos;
+}
+
+/* Parse with expression (expression after 'with' keyword) */
+static
+const char* flecs_script_with_expr(
+    ecs_script_parser_t *parser,
+    const char *pos)
+{
+    ParserBegin;
+
+    Parse(
+        // Position
+        case EcsTokIdentifier: {
+            // Position (
+            LookAhead_1('(',
+                pos = lookahead;
+
+                // Position ( expr )
+                Expr(')',
+                    ecs_script_component_t *component =
+                        flecs_script_insert_component(parser, Token(0));
+                    component->node.kind = EcsAstWithComponent;
+                    component->expr = Token(2);
+                    EndOfRule;
+                )
+            )
+
+            if (Token(0)[0] == '$') {
+                ecs_script_var_component_t *var = 
+                    flecs_script_insert_var_component(parser, &Token(0)[1]);
+                var->node.kind = EcsAstWithVar;
+            } else {
+                ecs_script_tag_t *tag =
+                    flecs_script_insert_tag(parser, Token(0));
+                tag->node.kind = EcsAstWithTag;
+            }
+
+            EndOfRule;
+        }
+
+        // (
+        case '(':
+            // (Eats, Apples)
+            Parse_4(EcsTokIdentifier, ',', EcsTokIdentifier, ')',
+                // (Eats, Apples) ( expr
+                LookAhead_1('(',
+                    pos = lookahead;
+
+                    // (Eats, Apples) ( expr )
+                    Expr(')',
+                        ecs_script_component_t *component =
+                            flecs_script_insert_pair_component(parser, 
+                                Token(1), Token(3));
+                        component->node.kind = EcsAstWithComponent;
+                        component->expr = Token(6);
+                        EndOfRule;
+                    )
+                )
+
+                ecs_script_tag_t *tag = 
+                    flecs_script_insert_pair_tag(parser, Token(1), Token(3));
+                tag->node.kind = EcsAstWithTag;
+                EndOfRule;
+            )
+    )
+
+    ParserEnd;
+}
+
+/* Parse with expression list (expression list after 'with' keyword) */
+static
+const char* flecs_script_with(
+    ecs_script_parser_t *parser,
+    ecs_script_with_t *with,
+    const char *pos)
+{
+    ParserBegin;
+
+    bool has_next;
+    do {
+        Scope(with->expressions, 
+            pos = flecs_script_with_expr(parser, pos);
+        )
+
+        if (!pos) {
+            goto error;
+        }
+
+        Parse(
+            case ',': {
+                has_next = true;
+                break;
+            }
+            case '{': {
+                return flecs_script_scope(parser, with->scope, pos);
+            }
+        )
+    } while (has_next);
+
+    ParserEnd;
+}
+
+/* Parse a single statement */
+static
+const char* flecs_script_stmt(
+    ecs_script_parser_t *parser,
+    const char *pos) 
+{
+    ParserBegin;
+
+    Parse(
+        case EcsTokIdentifier:        goto identifier;
+        case '{':                     return flecs_script_scope(parser, 
+                                        flecs_script_insert_scope(parser), pos);
+        case '(':                     goto paren;
+        case '@':                     goto annotation;
+        case EcsTokKeywordWith:       goto with_stmt;
+        case EcsTokKeywordModule:     goto module_stmt;
+        case EcsTokKeywordUsing:      goto using_stmt;
+        case EcsTokKeywordAssembly:   goto assembly_stmt;
+        case EcsTokKeywordProp:       goto prop_var;
+        case EcsTokKeywordConst:      goto const_var;
+        case EcsTokKeywordIf:         goto if_stmt;
+        EcsTokEndOfStatement:         EndOfRule;
+    );
+
+identifier: {
+    // enterprise } (end of scope)
+    LookAhead_1('}',
+        goto insert_tag;
+    )
+
+    Parse(
+        // enterprise {
+        case '{': {
+            return flecs_script_scope(parser, 
+                flecs_script_insert_entity(
+                    parser, Token(0))->scope, pos);
+        }
+
+        // Red,
+        case ',': {
+            flecs_script_insert_entity(parser, Token(0));
+            pos = flecs_script_comma_expr(parser, pos, false);
+            EndOfRule;
+        }
+
+        // Npc\n
+        EcsTokEndOfStatement: {
+            // Npc\n{
+            LookAhead_1('{',
+                pos = lookahead;
+                return flecs_script_scope(parser, 
+                    flecs_script_insert_entity(
+                        parser, Token(0))->scope, pos);
+            )
+
+            goto insert_tag;
+        }
+
+        // Position:
+        case ':': {
+            goto identifier_colon;
+        }
+
+        // x =
+        case '=': {
+            goto identifier_assign;
+        }
+
+        // SpaceShip(
+        case '(': {
+            goto identifier_paren;
+        }
+
+        // Spaceship enterprise
+        case EcsTokIdentifier: {
+            goto identifier_identifier;
+        }
+    )
+}
+
+insert_tag: {
+    if (Token(0)[0] == '$') {
+        if (!flecs_script_insert_var_component(parser, &Token(0)[1])) {
+            Error(
+                "invalid context for variable component '%s': must be "
+                    "part of entity", tokens[0].value);
+        }
+    } else {
+        if (!flecs_script_insert_tag(parser, Token(0))) {
+            Error(
+                "invalid context for tag '%s': must be part of entity", 
+                tokens[0].value);
+        }
+    }
+
+    EndOfRule;
+}
+
+// @
+annotation: {
+    // @brief
+    Parse_1(EcsTokIdentifier,
+        // $brief expr
+        Until('\n', 
+            flecs_script_insert_annot(parser, Token(1), Token(2));
+            EndOfRule;
+        )
+    )
+}
+
+// with
+with_stmt: {
+    ecs_script_with_t *with = flecs_script_insert_with(parser);
+    pos = flecs_script_with(parser, with, pos);
+    EndOfRule;
+}
+
+// using
+using_stmt: {
+    // using flecs.meta\n
+    Parse_2(EcsTokIdentifier, '\n',
+        flecs_script_insert_using(parser, Token(1));
+        EndOfRule;
+    )
+}
+
+// module
+module_stmt: {
+    // using flecs.meta\n
+    Parse_2(EcsTokIdentifier, '\n',
+        flecs_script_insert_module(parser, Token(1));
+        EndOfRule;
+    )
+}
+
+// assembly
+assembly_stmt: {
+    // assembly SpaceShip
+    Parse_1(EcsTokIdentifier, 
+        ecs_script_assembly_node_t *assembly = flecs_script_insert_assembly(
+            parser, Token(1));
+
+        Parse(
+            // assembly SpaceShip {
+            case '{':
+                return flecs_script_scope(parser, assembly->scope, pos);
+
+            // assembly SpaceShip\n
+            EcsTokEndOfStatement:
+                EndOfRule;
+        )
+    )
+}
+
+// prop
+prop_var: {
+    // prop color = Color:
+    Parse_4(EcsTokIdentifier, '=', EcsTokIdentifier, ':',
+        ecs_script_var_node_t *var = flecs_script_insert_var(
+            parser, Token(1));
+        var->node.kind = EcsAstProp;
+        var->type = Token(3);
+
+        // prop color = Color : {
+        LookAhead_1('{',
+            // prop color = Color: {expr}
+            pos = lookahead;
+            Expr('}',
+                var->expr = Token(6);
+                EndOfRule;
+            )
+        )
+
+        // prop color = Color : expr\n
+        Expr('\n',
+            var->expr = Token(5);
+            EndOfRule;
+        )
+    )
+}
+
+// const
+const_var: {
+    // const color
+    Parse_1(EcsTokIdentifier,
+        ecs_script_var_node_t *var = flecs_script_insert_var(
+            parser, Token(1));
+        var->node.kind = EcsAstConst;
+
+        Parse(
+            // const color =
+            case '=': {
+                // const color = Color :
+                LookAhead_2(EcsTokIdentifier, ':',
+                    pos = lookahead;
+
+                    var->type = Token(3);
+
+                    // const color = Color: {
+                    LookAhead_1('{',
+                        // const color = Color: {expr}
+                        pos = lookahead;
+                        Expr('}',
+                            var->expr = Token(6);
+                            EndOfRule;
+                        )
+                    )
+
+                    // const color = Color: expr\n
+                    Expr('\n',
+                        var->expr = Token(5);
+                        EndOfRule;
+                    )
+                )
+
+                // const PI = expr\n
+                Expr('\n',
+                    var->expr = Token(3);
+                    EndOfRule;
+                )
+            }
+        )
+    )
+}
+
+// if
+if_stmt: {
+    // if expr {
+    Expr('{',
+        ecs_script_if_t *stmt = flecs_script_insert_if(parser);
+        stmt->expr = Token(1);
+        pos = flecs_script_scope(parser, stmt->if_true, pos);
+        if (!pos) {
+            goto error;
+        }
+
+        // if expr { } else
+        LookAhead_1(EcsTokKeywordElse, 
+            pos = lookahead;
+
+            // if expr { } else {
+            Parse_1('{',
+                return flecs_script_scope(parser, stmt->if_false, pos);
+            )
+        )
+
+        EndOfRule;
+    )
+}
+
+// (
+paren: {
+    // (Likes, Apples)
+    Parse_4(EcsTokIdentifier, ',', EcsTokIdentifier, ')',
+        goto pair;
+    )
+}
+
+// (Likes, Apples)
+pair: {
+    // (Likes, Apples) } (end of scope)
+    LookAhead_1('}',
+        flecs_script_insert_pair_tag(parser, Token(1), Token(3));
+        EndOfRule;
+    )
+
+    Parse(
+        // (Likes, Apples)\n
+        EcsTokEndOfStatement: {
+            flecs_script_insert_pair_tag(parser, Token(1), Token(3));
+            EndOfRule;
+        }
+
+        // (Eats, Apples):
+        case ':': {
+            // (Eats, Apples): {
+            Parse_1('{',
+                // (Eats, Apples): { expr }
+                Expr('}',
+                    ecs_script_component_t *comp = 
+                        flecs_script_insert_pair_component(
+                            parser, Token(1), Token(3));
+                    comp->expr = Token(7);
+                    EndOfRule;
+                )
+            )
+        }
+
+        // (IsA, Machine) {
+        case '{': {
+            ecs_script_pair_scope_t *ps = flecs_script_insert_pair_scope(
+                parser, Token(1), Token(3));
+            return flecs_script_scope(parser, ps->scope, pos);
+        }
+    )
+}
+
+// Position:
+identifier_colon: {
+    {
+        // Position: {
+        LookAhead_1('{',
+            pos = lookahead;
+            goto component_expr_scope;
+        )
+    }
+
+    {
+        // Position: {
+        LookAhead_1('[',
+            pos = lookahead;
+            goto component_expr_collection;
+        )
+    }
+
+    // enterprise : SpaceShip
+    Parse_1(EcsTokIdentifier, {
+        ecs_script_entity_t *entity = flecs_script_insert_entity(
+            parser, Token(0));
+
+        Scope(entity->scope, 
+            flecs_script_insert_pair_tag(parser, "IsA", Token(2));
+
+            LookAhead_1(',', {
+                pos = lookahead;
+                pos = flecs_script_comma_expr(parser, pos, true);
+            })
+        )
+
+        Parse(
+            // enterprise : SpaceShip\n
+            EcsTokEndOfStatement:
+                EndOfRule;
+
+            // enterprise : SpaceShip {
+            case '{':
+                return flecs_script_scope(parser, entity->scope, pos);
+        )
+    })
+}
+
+// x =
+identifier_assign: {
+    ecs_script_entity_t *entity = flecs_script_insert_entity(
+        parser, Token(0));
+
+    // x = Position: {
+    LookAhead_2(EcsTokIdentifier, ':',
+        pos = lookahead;
+
+        Parse_1('{', {
+            // x = Position: {expr}
+            Expr('}', 
+                Scope(entity->scope, 
+                    ecs_script_component_t *comp = 
+                        flecs_script_insert_component(parser, Token(2));
+                    comp->expr = Token(5);
+                )
+
+                // x = Position: {expr}\n
+                Parse(
+                    EcsTokEndOfStatement:
+                        EndOfRule;
+                )
+            )
+        })
+    )
+
+    // x = f32\n
+    Expr('\n',
+        Scope(entity->scope, 
+            ecs_script_default_component_t *comp = 
+                flecs_script_insert_default_component(parser);
+            comp->expr = Token(2);
+        )
+        
+        EndOfRule;
+    )
+}
+
+// Spaceship enterprise
+identifier_identifier: {
+    Parse(
+        // Spaceship enterprise\n
+        EcsTokEndOfStatement: {
+            ecs_script_entity_t *entity = flecs_script_insert_entity(
+                parser, Token(1));
+            entity->kind = Token(0);
+            EndOfRule;
+        }
+
+        // Spaceship enterprise {
+        case '{': {
+            ecs_script_entity_t *entity = flecs_script_insert_entity(
+                parser, Token(1));
+            entity->kind = Token(0);
+            return flecs_script_scope(parser, entity->scope, pos);
+        }
+
+        // Spaceship enterprise(
+        case '(': {
+            goto component_expr_paren;
+        }
+    )
+}
+
+// SpaceShip(
+identifier_paren: {
+    // SpaceShip()
+    Expr(')', 
+        Parse(
+            // SpaceShip(expr)\n
+            EcsTokEndOfStatement: {
+                ecs_script_entity_t *entity = flecs_script_insert_entity(
+                    parser, NULL);
+
+                Scope(entity->scope, 
+                    ecs_script_component_t *comp = 
+                        flecs_script_insert_component(parser, Token(0)); 
+                    comp->expr = Token(2);
+                    if (!ecs_os_strcmp(comp->expr, "{}")) {
+                        comp->expr = NULL;
+                    }
+                )
+
+                EndOfRule;
+            }
+
+            // SpaceShip(expr) {
+            case '{': {
+                ecs_script_entity_t *entity = flecs_script_insert_entity(
+                    parser, NULL);
+
+                Scope(entity->scope, 
+                    ecs_script_component_t *comp = 
+                        flecs_script_insert_component(parser, Token(0)); 
+                    comp->expr = Token(2);
+                )
+
+                return flecs_script_scope(parser, entity->scope, pos);
+            }
+        )
+    )
+}
+
+// Position: {
+component_expr_scope: {
+
+    // Position: {expr}
+    Expr('}', {
+        ecs_script_component_t *comp = flecs_script_insert_component(
+            parser, Token(0));
+        comp->expr = Token(3);
+        EndOfRule; 
+    })
+}
+
+// Points: [
+component_expr_collection: {
+    // Position: [expr]
+    Expr(']', {
+        ecs_script_component_t *comp = flecs_script_insert_component(
+            parser, Token(0));
+        comp->expr = Token(3);
+        comp->is_collection = true;
+        EndOfRule; 
+    })
+}
+
+// Position spaceship (
+component_expr_paren: {
+    // Position spaceship (expr)
+    Expr(')',
+        ecs_script_entity_t *entity = flecs_script_insert_entity(
+            parser, Token(1));
+        entity->kind = Token(0);
+        entity->kind_w_expr = true;
+
+        Scope(entity->scope, 
+            ecs_script_component_t *component = 
+                flecs_script_insert_component(parser, Token(0));
+            component->expr = Token(3);
+        )
+
+        Parse(
+            // Position spaceship (expr)\n
+            EcsTokEndOfStatement: {
+                EndOfRule;
+            }
+
+            // Position spaceship (expr) {
+            case '{': {
+                return flecs_script_scope(parser, entity->scope, pos);
+            }
+        )
+    )
+
+    ParserEnd;
+}
+
+}
+
+/* Parse script */
+ecs_script_t* ecs_script_parse(
+    ecs_world_t *world,
+    const char *name,
+    const char *code) 
+{
+    if (!code) {
+        code = "";
+    }
+
+    ecs_script_t *script = flecs_script_new(world);
+    script->name = name;
+    script->code = code;
+
+    ecs_script_parser_t parser = {
+        .script = script,
+        .scope = script->root,
+        .significant_newline = true
+    };
+
+    /* Allocate a buffer that is able to store all parsed tokens. Multiply the
+     * size of the script by two so that there is enough space to add \0
+     * terminators and expression deliminators ('""') 
+     * The token buffer will exist for as long as the script object exists, and
+     * ensures that AST nodes don't need to do separate allocations for the data
+     * they contain. */
+    script->token_buffer_size = ecs_os_strlen(code) * 2 + 1;
+    script->token_buffer = flecs_alloc(
+        &script->allocator, script->token_buffer_size);
+    parser.token_cur = script->token_buffer;
+
+    /* Start parsing code */
+    const char *pos = code;
+
+    do {
+        pos = flecs_script_stmt(&parser, pos);
+        if (!pos) {
+            /* NULL means error */
+            goto error;
+        }
+
+        if (!pos[0]) {
+            /* \0 means end of input */
+            break;
+        }
+    } while (true);
+
+    return script;
+error:
+    ecs_script_free(script);
+    return NULL;
+}
+
+#endif
diff --git a/src/addons/script/parser.h b/src/addons/script/parser.h
new file mode 100644
index 000000000..ae088b503
--- /dev/null
+++ b/src/addons/script/parser.h
@@ -0,0 +1,210 @@
+/**
+ * @file addons/script/parser.h
+ * @brief Script grammar parser.
+ * 
+ * Macro utilities that facilitate a simple recursive descent parser.
+ */
+
+#ifndef FLECS_SCRIPT_PARSER_H
+#define FLECS_SCRIPT_PARSER_H
+
+#if defined(ECS_TARGET_CLANG)
+/* Ignore unused enum constants in switch as it would blow up the parser code */
+#pragma clang diagnostic ignored "-Wswitch-enum"
+/* To allow for nested Parse statements */
+#pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
+/* Create script & parser structs with static token buffer */
+#define EcsParserFixedBuffer(w, script_name, expr, tokens, tokens_len)\
+    ecs_script_t script = {\
+        .world = ECS_CONST_CAST(ecs_world_t*, w),\
+        .name = script_name,\
+        .code = expr\
+    };\
+    ecs_script_parser_t parser = {\
+        .script = &script,\
+        .pos = expr,\
+        .token_cur = tokens\
+    }
+
+/* Definitions for parser functions */
+#define ParserBegin\
+    ecs_script_tokens_t token_stack = {0};\
+    ecs_script_token_t *tokens = token_stack.tokens;\
+    (void)tokens
+
+#define ParserEnd\
+        Error("unexpected end of rule (parser error)");\
+    error:\
+        return NULL
+
+/* Get token */
+#define Token(n) (tokens[n].value)
+
+/* Error */
+#define Error(...)\
+    ecs_parser_error(parser->script->name, parser->script->code,\
+        (pos - parser->script->code) - 1, __VA_ARGS__);\
+    goto error
+
+/* Parse expression */
+#define Expr(until, ...)\
+    {\
+        ecs_assert(token_stack.count < 256, ECS_INTERNAL_ERROR, NULL);\
+        ecs_script_token_t *t = &token_stack.tokens[token_stack.count ++];\
+        if (!(pos = flecs_script_expr(parser, pos, t, until))) {\
+            goto error;\
+        }\
+        if (!t->value[0] && (until == '\n' || until == '{')) {\
+            pos ++;\
+            Error("empty expression");\
+        }\
+    }\
+    Parse_1(until, __VA_ARGS__)
+
+/* Parse token until character */
+#define Until(until, ...)\
+    {\
+        ecs_assert(token_stack.count < 256, ECS_INTERNAL_ERROR, NULL);\
+        ecs_script_token_t *t = &token_stack.tokens[token_stack.count ++];\
+        if (!(pos = flecs_script_until(parser, pos, t, until))) {\
+            goto error;\
+        }\
+    }\
+    Parse_1(until, __VA_ARGS__)
+
+/* Parse next token */
+#define Parse(...)\
+    {\
+        ecs_assert(token_stack.count < 256, ECS_INTERNAL_ERROR, NULL);\
+        ecs_script_token_t *t = &token_stack.tokens[token_stack.count ++];\
+        if (!(pos = flecs_script_token(parser, pos, t, false))) {\
+            goto error;\
+        }\
+        switch(t->kind) {\
+            __VA_ARGS__\
+        default:\
+            if (t->value) {\
+                Error("unexpected %s'%s'", \
+                    flecs_script_token_kind_str(t->kind), t->value);\
+            } else {\
+                Error("unexpected %s", \
+                    flecs_script_token_kind_str(t->kind));\
+            }\
+        }\
+    }
+
+/* Parse N consecutive tokens */
+#define Parse_1(tok, ...)\
+    Parse(\
+        case tok: {\
+            __VA_ARGS__\
+        }\
+    )
+
+#define Parse_2(tok1, tok2, ...)\
+    Parse_1(tok1, \
+        Parse(\
+            case tok2: {\
+                __VA_ARGS__\
+            }\
+        )\
+    )
+
+#define Parse_3(tok1, tok2, tok3, ...)\
+    Parse_2(tok1, tok2, \
+        Parse(\
+            case tok3: {\
+                __VA_ARGS__\
+            }\
+        )\
+    )
+
+#define Parse_4(tok1, tok2, tok3, tok4, ...)\
+    Parse_3(tok1, tok2, tok3, \
+        Parse(\
+            case tok4: {\
+                __VA_ARGS__\
+            }\
+        )\
+    )
+
+#define Parse_5(tok1, tok2, tok3, tok4, tok5, ...)\
+    Parse_4(tok1, tok2, tok3, tok4, \
+        Parse(\
+            case tok5: {\
+                __VA_ARGS__\
+            }\
+        )\
+    )
+
+/* Same as Parse, but doesn't error out if token is not in handled cases */
+#define LookAhead(...)\
+    const char *lookahead;\
+    ecs_script_token_t lookahead_token;\
+    if ((lookahead = flecs_script_token(parser, pos, &lookahead_token, true))) {\
+        token_stack.tokens[token_stack.count ++] = lookahead_token;\
+        switch(lookahead_token.kind) {\
+            __VA_ARGS__\
+        default:\
+            token_stack.count --;\
+            break;\
+        }\
+    }
+
+/* Lookahead N consecutive tokens */
+#define LookAhead_1(tok, ...)\
+    LookAhead(\
+        case tok: {\
+            __VA_ARGS__\
+        }\
+    )
+
+#define LookAhead_2(tok1, tok2, ...)\
+    LookAhead_1(tok1, \
+        const char *old_ptr = pos;\
+        pos = lookahead;\
+        LookAhead(\
+            case tok2: {\
+                __VA_ARGS__\
+            }\
+        )\
+        pos = old_ptr;\
+    )
+
+#define LookAhead_3(tok1, tok2, tok3, ...)\
+    LookAhead_2(tok1, tok2, \
+        const char *old_ptr = pos;\
+        pos = lookahead;\
+        LookAhead(\
+            case tok3: {\
+                __VA_ARGS__\
+            }\
+        )\
+        pos = old_ptr;\
+    )
+
+/* Open scope */
+#define Scope(s, ...) {\
+        ecs_script_scope_t *old_scope = parser->scope;\
+        parser->scope = s;\
+        __VA_ARGS__\
+        parser->scope = old_scope;\
+    }
+
+/* Parser loop */
+#define Loop(...)\
+    int32_t token_stack_count = token_stack.count;\
+    do {\
+        token_stack.count = token_stack_count;\
+        __VA_ARGS__\
+    } while (true);
+
+#define EndOfRule return pos
+
+#endif
diff --git a/src/addons/script/query_parser.c b/src/addons/script/query_parser.c
new file mode 100644
index 000000000..6aab723ec
--- /dev/null
+++ b/src/addons/script/query_parser.c
@@ -0,0 +1,759 @@
+/**
+ * @file addons/script/query_parser.c
+ * @brief Script grammar parser.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+#include "parser.h"
+
+#define EcsTokTermIdentifier\
+    EcsTokIdentifier:\
+    case EcsTokNumber:\
+    case EcsTokMul
+
+#define EcsTokEndOfTerm\
+    '}':\
+        pos --; /* Give token back to parser */\
+    case EcsTokOr:\
+        if (t->kind == EcsTokOr) {\
+            if (parser->term->oper != EcsAnd) {\
+                Error("cannot mix operators in || expression");\
+            }\
+            parser->term->oper = EcsOr;\
+        }\
+    case ',':\
+    case '\n':\
+    case '\0'
+
+// $this ==
+static
+const char* flecs_query_parse_term_equality_pred(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_entity_t pred) 
+{
+    ParserBegin;
+
+    if (parser->term->oper != EcsAnd) {
+        Error("cannot mix operator with equality expression");
+    }
+
+    parser->term->src = parser->term->first;
+    parser->term->first = (ecs_term_ref_t){0};
+    parser->term->first.id = pred;
+
+    Parse(
+        // $this == foo
+        //          ^
+        case EcsTokTermIdentifier: {
+            parser->term->second.name = Token(0);
+            Parse( case EcsTokEndOfTerm: EndOfRule; )
+        }
+
+        // $this == "foo"
+        //          ^
+        case EcsTokString: {
+            parser->term->second.name = Token(0);
+            parser->term->second.id = EcsIsName;
+
+            if (pred == EcsPredMatch) {
+                if (Token(0)[0] == '!') {
+                    /* If match expression starts with !, set Not operator. The
+                     * reason the ! is embedded in the expression is because 
+                     * there is only a single match (~=) operator. */
+                    parser->term->second.name ++;
+                    parser->term->oper = EcsNot;
+                }
+            }
+
+            Parse( 
+                case EcsTokEndOfTerm:
+                    EndOfRule; 
+            )
+        }
+    )
+
+    ParserEnd;
+}
+
+static
+ecs_entity_t flecs_query_parse_trav_flags(
+    const char *tok)
+{
+         if (!ecs_os_strcmp(tok, "self"))    return EcsSelf;
+    else if (!ecs_os_strcmp(tok, "up"))      return EcsUp;
+    else if (!ecs_os_strcmp(tok, "cascade")) return EcsCascade;
+    else if (!ecs_os_strcmp(tok, "desc"))    return EcsDesc;
+    else return 0;
+}
+
+static
+const char* flecs_query_parse_term_trav(
+    ecs_script_parser_t *parser,
+    ecs_term_ref_t *ref,
+    const char *pos) 
+{
+    ParserBegin;
+
+    Loop(
+        // self
+        Parse_1(EcsTokIdentifier,
+            ref->id |= flecs_query_parse_trav_flags(Token(0));
+
+            LookAhead(
+                // self|
+                case '|':
+                    pos = lookahead;
+                    continue;
+
+                // self IsA
+                case EcsTokIdentifier:
+                    pos = lookahead;
+                    parser->term->trav = ecs_lookup(
+                        parser->script->world, Token(1));
+                    if (!parser->term->trav) {
+                        Error(
+                            "unresolved traversal relationship '%s'", Token(1));
+                        goto error;
+                    }
+
+                    EndOfRule;
+            )
+
+            EndOfRule;
+        )
+    )
+
+    ParserEnd;
+}
+
+// Position(
+static
+const char* flecs_query_parse_term_arg(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    int32_t arg)
+{
+    ParserBegin;
+
+    ecs_term_ref_t *ref = NULL;
+
+    // Position(src
+    if (arg == 0) {
+        ref = &parser->term->src;
+
+    // Position(src, tgt
+    } else if (arg == 1) {
+        ref = &parser->term->second;
+    } else {
+        if (arg > FLECS_TERM_ARG_COUNT_MAX) {
+            Error("too many arguments in term");
+        }
+        ref = &parser->extra_args[arg - 2];
+    }
+
+    bool is_trav_flag = false;
+    LookAhead_1(EcsTokIdentifier, 
+        is_trav_flag = flecs_query_parse_trav_flags(Token(0)) != 0;
+    )
+
+    if (is_trav_flag) {
+        // Position(self|up
+        //          ^
+        pos = flecs_query_parse_term_trav(parser, ref, pos);
+        if (!pos) {
+            goto error;
+        }
+    } else {
+        // Position(src
+        //          ^
+        Parse(
+            case EcsTokTermIdentifier: {
+                ref->name = Token(0);
+
+                // Position(src|
+                //          ^
+                LookAhead_1('|',
+                    pos = lookahead;
+                    pos = flecs_query_parse_term_trav(parser, ref, pos);
+                    if (!pos) {
+                        goto error;
+                    }
+
+                    // Position(src|up IsA
+                    //          ^
+                    LookAhead_1(EcsTokIdentifier,
+                        pos = lookahead;
+                        parser->term->trav = ecs_lookup(
+                            parser->script->world, Token(1));
+                        if (!parser->term->trav) {
+                            Error(
+                                "unresolved trav identifier '%s'", Token(1));
+                        }
+                    )
+                )
+
+                break;
+            }
+        )
+    }
+
+    Parse(
+        // Position(src,
+        //          ^
+        case ',':
+            if ((arg > 1) && parser->extra_oper != EcsAnd) {
+                Error("cannot mix operators in extra term arguments");
+            }
+            parser->extra_oper = EcsAnd;
+            return flecs_query_parse_term_arg(parser, pos, arg + 1);
+
+        // Position(src, second ||
+        //          ^
+        case EcsTokOr:
+            if ((arg > 1) && parser->extra_oper != EcsOr) {
+                Error("cannot mix operators in extra term arguments");
+            }
+            parser->extra_oper = EcsOr;
+            return flecs_query_parse_term_arg(parser, pos, arg + 1);
+
+        // Position(src)
+        //          ^
+        case ')':
+            Parse(
+                case EcsTokEndOfTerm:
+                    EndOfRule;
+            )
+    )
+
+    ParserEnd;
+}
+
+// Position
+static
+const char* flecs_query_parse_term_id(
+    ecs_script_parser_t *parser,
+    const char *pos) 
+{
+    ParserBegin;
+
+    Parse(
+        case EcsTokEq:
+            return flecs_query_parse_term_equality_pred(
+                parser, pos, EcsPredEq);
+        case EcsTokNeq: {
+            const char *ret = flecs_query_parse_term_equality_pred(
+                parser, pos, EcsPredEq);
+            if (ret) {
+                parser->term->oper = EcsNot;
+            }
+            return ret;
+        }
+        case EcsTokMatch:
+            return flecs_query_parse_term_equality_pred(
+                parser, pos, EcsPredMatch);
+
+        // Position|
+        case '|': {
+            pos = flecs_query_parse_term_trav(parser, &parser->term->first, pos);
+            if (!pos) {
+                goto error;
+            }
+
+            // Position|self(
+            Parse(
+                case '(':
+                    return flecs_query_parse_term_arg(parser, pos, 0);
+                case EcsTokEndOfTerm:
+                    EndOfRule;
+            )
+        }
+
+        // Position(
+        case '(': {
+            // Position()
+            LookAhead_1(')',
+                pos = lookahead;
+                parser->term->src.id = EcsIsEntity;
+
+                Parse(
+                    case EcsTokEndOfTerm:
+                        EndOfRule;
+                )
+            )
+
+            return flecs_query_parse_term_arg(parser, pos, 0);
+        }
+
+        case EcsTokEndOfTerm: 
+            EndOfRule;
+    )
+
+    ParserEnd;
+}
+
+// (
+static const char* flecs_query_parse_term_pair(
+    ecs_script_parser_t *parser,
+    const char *pos)
+{
+    ParserBegin;
+
+    // (Position
+    //  ^
+    Parse(
+        case EcsTokTermIdentifier: {
+            parser->term->first.name = Token(0);
+
+            LookAhead_1('|',
+                // (Position|self
+                pos = lookahead;
+                pos = flecs_query_parse_term_trav(
+                    parser, &parser->term->first, pos);
+                if (!pos) {
+                    goto error;
+                }
+            )
+
+            // (Position,
+            Parse_1(',',
+                return flecs_query_parse_term_arg(parser, pos, 1);
+            )
+        }
+    )
+
+    ParserEnd;
+}
+
+// AND
+static
+const char* flecs_query_parse_term_flags(
+    ecs_script_parser_t *parser,
+    const char *token_0,
+    const char *pos) 
+{
+    ecs_assert(token_0 != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ParserBegin;
+
+    ecs_id_t flag = 0;
+    int16_t oper = 0;
+    ecs_term_t *term = parser->term;
+
+    // AND
+    if      (!ecs_os_strcmp(token_0, "AND"))      oper = EcsAndFrom;
+    else if (!ecs_os_strcmp(token_0, "OR"))       oper = EcsOrFrom;
+    else if (!ecs_os_strcmp(token_0, "NOT"))      oper = EcsNotFrom;
+    else if (!ecs_os_strcmp(token_0, "OVERRIDE")) flag = ECS_OVERRIDE;
+    else if (!ecs_os_strcmp(token_0, "TOGGLE"))   flag = ECS_TOGGLE;
+    else {
+        // Position
+        term->first.name = token_0;
+        return flecs_query_parse_term_id(parser, pos);
+    }
+
+    if (oper || flag) {
+        // AND |
+        //     ^
+        Parse_1('|', 
+            Parse(
+                // AND | Position
+                //     ^
+                case EcsTokTermIdentifier: { 
+                    if (oper) {
+                        term->oper = oper;
+                    } else if (flag) {
+                        term->id = flag;
+                    }
+
+                    term->first.name = Token(1);
+
+                    return flecs_query_parse_term_id(parser, pos);
+                }
+
+                // AND | (
+                //     ^
+                case '(': {
+                    return flecs_query_parse_term_pair(parser, pos);
+                }
+            )
+        )
+    }
+
+    ParserEnd;
+}
+
+// !
+static
+const char* flecs_query_parse_term_unary(
+    ecs_script_parser_t *parser,
+    const char *pos)
+{
+    ParserBegin;
+
+    Parse(
+        // !(
+        case '(': {
+            return flecs_query_parse_term_pair(parser, pos);
+        }
+
+        // !{
+        case '{': {
+            parser->term->first.id = EcsScopeOpen;
+            parser->term->src.id = EcsIsEntity;
+            parser->term->inout = EcsInOutNone;
+            EndOfRule;
+        }
+
+        // !Position
+        //  ^
+        case EcsTokTermIdentifier: {
+            parser->term->first.name = Token(0);
+            return flecs_query_parse_term_id(parser, pos);
+        }
+    )
+
+    ParserEnd;
+}
+
+// [
+static
+const char* flecs_query_parse_term_inout(
+    ecs_script_parser_t *parser,
+    const char *pos)
+{
+    ParserBegin;
+
+    ecs_term_t *term = parser->term;
+
+    // [inout]
+    //  ^
+    Parse_2(EcsTokIdentifier, ']',
+        if      (!ecs_os_strcmp(Token(0), "default")) term->inout = EcsInOutDefault;
+        else if (!ecs_os_strcmp(Token(0), "none"))    term->inout = EcsInOutNone;
+        else if (!ecs_os_strcmp(Token(0), "filter"))  term->inout = EcsInOutFilter;
+        else if (!ecs_os_strcmp(Token(0), "inout"))   term->inout = EcsInOut;
+        else if (!ecs_os_strcmp(Token(0), "in"))      term->inout = EcsIn;
+        else if (!ecs_os_strcmp(Token(0), "out"))     term->inout = EcsOut;
+
+        Parse(
+            // [inout] Position
+            //  ^
+            case EcsTokTermIdentifier: { 
+                return flecs_query_parse_term_flags(parser, Token(2), pos);
+            }
+
+            // [inout] !Position
+            //  ^
+            case '!':
+                term->oper = EcsNot;
+                return flecs_query_parse_term_unary(parser, pos);
+            case '?':
+                term->oper = EcsOptional;
+                return flecs_query_parse_term_unary(parser, pos);
+
+            // [inout] (
+            //  ^
+            case '(': {
+                return flecs_query_parse_term_pair(parser, pos);
+            }
+        )
+    )
+
+    ParserEnd;
+}
+
+static
+const char* flecs_query_parse_term(
+    ecs_script_parser_t *parser,
+    const char *pos) 
+{
+    ParserBegin;
+
+    Parse(
+        case '[':
+            return flecs_query_parse_term_inout(parser, pos);
+        case EcsTokTermIdentifier:   
+            return flecs_query_parse_term_flags(parser, Token(0), pos);
+        case '(':
+            return flecs_query_parse_term_pair(parser, pos);
+        case '!':
+            parser->term->oper = EcsNot;
+            return flecs_query_parse_term_unary(parser, pos);
+        case '?':
+            parser->term->oper = EcsOptional;
+            return flecs_query_parse_term_unary(parser, pos);
+        case '{':
+            parser->term->first.id = EcsScopeOpen;
+            parser->term->src.id = EcsIsEntity;
+            parser->term->inout = EcsInOutNone;
+            EndOfRule;
+        case '}':
+            parser->term->first.id = EcsScopeClose;
+            parser->term->src.id = EcsIsEntity;
+            parser->term->inout = EcsInOutNone;
+            LookAhead_1(',',
+                pos = lookahead;
+            )
+            EndOfRule;
+        case '\n':\
+        case '\0':
+            EndOfRule;
+    );
+
+    ParserEnd;
+}
+
+int flecs_terms_parse(
+    ecs_script_t *script,
+    ecs_term_t *terms,
+    int32_t *term_count_out)
+{
+    if (!ecs_os_strcmp(script->code, "0")) {
+        *term_count_out = 0;
+        return 0;
+    }
+
+    ecs_script_parser_t parser = {
+        .script = script,
+        .pos = script->code
+    };
+
+    parser.token_cur = script->token_buffer;
+
+    int32_t term_count = 0;
+    const char *ptr = script->code;
+    ecs_term_ref_t extra_args[FLECS_TERM_ARG_COUNT_MAX];
+    ecs_os_memset_n(extra_args, 0, ecs_term_ref_t, 
+        FLECS_TERM_ARG_COUNT_MAX);
+
+    parser.extra_args = extra_args;
+    parser.extra_oper = 0;
+
+    do {
+        if (term_count == FLECS_TERM_COUNT_MAX) {
+            ecs_err("max number of terms (%d) reached, increase "
+                "FLECS_TERM_COUNT_MAX to support more",
+                FLECS_TERM_COUNT_MAX);
+            goto error;
+        }
+
+        /* Parse next term */
+        ecs_term_t *term = &terms[term_count];
+        parser.term = term;
+        ecs_os_memset_t(term, 0, ecs_term_t);
+        ecs_os_memset_n(extra_args, 0, ecs_term_ref_t, FLECS_TERM_ARG_COUNT_MAX);
+        parser.extra_oper = 0;
+
+        ptr = flecs_query_parse_term(&parser, ptr);
+        if (!ptr) {
+            /* Parser error */
+            goto error;
+        }
+
+        if (!ecs_term_is_initialized(term)) {
+            /* Last term parsed */
+            break;
+        }
+
+        term_count ++;
+
+        /* Unpack terms with more than two args into multiple terms so that:
+         *   Rel(X, Y, Z)
+         *  becomes:
+         *   Rel(X, Y), Rel(Y, Z) */
+        int32_t arg = 0;
+        while (ecs_term_ref_is_set(&extra_args[arg ++])) {
+            ecs_assert(arg <= FLECS_TERM_ARG_COUNT_MAX, 
+                ECS_INTERNAL_ERROR, NULL);
+
+            if (term_count == FLECS_TERM_COUNT_MAX) {
+                ecs_err("max number of terms (%d) reached, increase "
+                    "FLECS_TERM_COUNT_MAX to support more",
+                    FLECS_TERM_COUNT_MAX);
+                goto error;
+            }
+
+            term = &terms[term_count ++];
+            *term = term[-1];
+
+            if (parser.extra_oper == EcsAnd) {
+                term->src = term[-1].second;
+                term->second = extra_args[arg - 1];
+            } else if (parser.extra_oper == EcsOr) {
+                term->src = term[-1].src;
+                term->second = extra_args[arg - 1];
+                term[-1].oper = EcsOr;
+            }
+
+            if (term->first.name != NULL) {
+                term->first.name = term->first.name;
+            }
+    
+            if (term->src.name != NULL) {
+                term->src.name = term->src.name;
+            }
+        }
+
+        if (arg) {
+            ecs_os_memset_n(extra_args, 0, ecs_term_ref_t, 
+                FLECS_TERM_ARG_COUNT_MAX);
+        }
+    } while (ptr[0]);
+
+    (*term_count_out) += term_count;
+
+    return 0;
+error:
+    return -1;
+}
+
+const char* flecs_id_parse(
+    const ecs_world_t *world,
+    const char *name,
+    const char *expr,
+    ecs_id_t *id)
+{
+    char token_buffer[256];
+    ecs_term_t term = {0};
+    EcsParserFixedBuffer(world, name, expr, token_buffer, 256);
+    parser.term = &term;
+
+    expr = flecs_scan_whitespace(&parser, expr);
+    if (!ecs_os_strcmp(expr, "0")) {
+        *id = 0;
+        return &expr[1];
+    }
+
+    const char *result = flecs_query_parse_term(&parser, expr);
+    if (!result) {
+        return NULL;
+    }
+
+    if (ecs_term_finalize(world, &term)) {
+        return NULL;
+    }
+
+    if (!ecs_id_is_valid(world, term.id)) {
+        ecs_parser_error(name, expr, (result - expr), 
+            "invalid term for add expression");
+        return NULL;
+    }
+
+    if (term.oper != EcsAnd) {
+        ecs_parser_error(name, expr, (result - expr), 
+            "invalid operator for add expression");
+        return NULL;
+    }
+
+    if ((term.src.id & ~EcsTraverseFlags) != (EcsThis|EcsIsVariable)) {
+        ecs_parser_error(name, expr, (result - expr), 
+            "invalid source for add expression (must be $this)");
+        return NULL;
+    }
+
+    *id = term.id;
+    
+    return result;
+}
+
+static
+const char* flecs_query_arg_parse(
+    ecs_script_parser_t *parser,
+    ecs_query_t *q,
+    ecs_iter_t *it,
+    const char *pos)
+{
+    ParserBegin;
+
+    Parse_3(EcsTokIdentifier, ':', EcsTokIdentifier, {
+        int var = ecs_query_find_var(q, Token(0));
+        if (var == -1) {
+            Error("unknown variable '%s'", Token(0));
+        }
+
+        ecs_entity_t val = ecs_lookup(q->world, Token(2));
+        if (!val) {
+            Error("unresolved entity '%s'", Token(2));
+        }
+
+        ecs_iter_set_var(it, var, val);
+
+        EndOfRule;
+    })
+
+    ParserEnd;
+}
+
+static
+const char* flecs_query_args_parse(
+    ecs_script_parser_t *parser,
+    ecs_query_t *q,
+    ecs_iter_t *it,
+    const char *pos)
+{
+    ParserBegin;
+
+    bool has_paren = false;
+    LookAhead(
+        case '\0':
+            pos = lookahead;
+            EndOfRule;
+        case '(': {
+            pos = lookahead;
+            has_paren = true;
+            LookAhead_1(')',
+                pos = lookahead;
+                EndOfRule;
+            )
+        }
+    )
+
+    Loop(
+        pos = flecs_query_arg_parse(parser, q, it, pos);
+        if (!pos) {
+            goto error;
+        }
+
+        Parse(
+            case ',':
+                continue;
+            case '\0':
+                EndOfRule;
+            case ')':
+                if (!has_paren) {
+                    Error("unexpected ')' without opening '(')");
+                }
+                EndOfRule;
+        )
+    )
+
+    ParserEnd;
+}
+
+const char* ecs_query_args_parse(
+    ecs_query_t *q,
+    ecs_iter_t *it,
+    const char *expr)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(expr != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    const char *q_name = q->entity ? ecs_get_name(q->world, q->entity) : NULL;
+    if (ecs_os_strlen(expr) > 512) {
+        ecs_parser_error(q_name, expr, 0, "query argument expression too long");
+        return NULL;
+    }
+
+    char token_buffer[1024];
+    EcsParserFixedBuffer(q->world, q_name, expr, token_buffer, 256);
+    return flecs_query_args_parse(&parser, q, it, expr);
+error:
+    return NULL;
+}
+
+#endif
diff --git a/src/addons/script/script.c b/src/addons/script/script.c
new file mode 100644
index 000000000..3daf9aeb8
--- /dev/null
+++ b/src/addons/script/script.c
@@ -0,0 +1,252 @@
+/**
+ * @file addons/script/script.c
+ * @brief Script API.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+
+ECS_COMPONENT_DECLARE(EcsScript);
+
+static
+ECS_MOVE(EcsScript, dst, src, {
+    if (dst->script && (dst->script != src->script)) {
+        if (dst->assembly && (dst->assembly != src->assembly)) {
+            flecs_script_assembly_fini(dst->script, dst->assembly);
+        }
+        ecs_script_free(dst->script);
+    }
+    dst->script = src->script;
+    dst->assembly = src->assembly;
+    src->script = NULL;
+    src->assembly = NULL;
+})
+
+static
+ECS_DTOR(EcsScript, ptr, {
+    if (ptr->assembly) {
+        flecs_script_assembly_fini(ptr->script, ptr->assembly);
+    }
+    if (ptr->script) {
+        ecs_script_free(ptr->script);
+    }
+})
+
+static
+ecs_id_t flecs_script_tag(
+    ecs_entity_t script,
+    ecs_entity_t instance)
+{
+    if (!instance) {
+        return ecs_pair_t(EcsScript, script);
+    } else {
+        return ecs_pair(EcsChildOf, instance);
+    }
+}
+
+ecs_script_t* flecs_script_new(
+    ecs_world_t *world) 
+{
+    ecs_script_t *result = ecs_os_calloc_t(ecs_script_t);
+    flecs_allocator_init(&result->allocator);
+    ecs_script_parser_t parser = { .script = result };
+    result->root = flecs_script_scope_new(&parser);
+    result->world = world;
+    result->refcount = 1;
+    return result;
+}
+
+void ecs_script_clear(
+    ecs_world_t *world,
+    ecs_entity_t script,
+    ecs_entity_t instance)
+{
+    ecs_delete_with(world, flecs_script_tag(script, instance));
+}
+
+int ecs_script_run(
+    ecs_world_t *world,
+    const char *name,
+    const char *code)
+{
+    ecs_script_t *script = ecs_script_parse(world, name, code);
+    if (!script) {
+        goto error;
+    }
+
+    ecs_entity_t prev_scope = ecs_set_scope(world, 0);
+
+    if (ecs_script_eval(script)) {
+        goto error_free;
+    }
+
+    ecs_set_scope(world, prev_scope);
+
+    ecs_script_free(script);
+    return 0;
+error_free:
+    ecs_script_free(script);
+error:
+    return -1;
+}
+
+int ecs_script_run_file(
+    ecs_world_t *world,
+    const char *filename) 
+{
+    char *script = flecs_load_from_file(filename);
+    if (!script) {
+        return -1;
+    }
+
+    int result = ecs_script_run(world, filename, script);
+    ecs_os_free(script);
+    return result;
+}
+
+void ecs_script_free(
+    ecs_script_t *script)
+{
+    ecs_check(script->refcount > 0, ECS_INVALID_OPERATION, NULL);
+    if (!--script->refcount) {
+        flecs_script_visit_free(script);
+        flecs_free(&script->allocator, 
+            script->token_buffer_size, script->token_buffer);
+        flecs_allocator_fini(&script->allocator);
+        ecs_os_free(script);
+    }
+error:
+    return;
+}
+
+int ecs_script_update(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    ecs_entity_t instance,
+    const char *code)
+{
+    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(code != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    const char *name = ecs_get_name(world, e);
+    EcsScript *s = ecs_ensure(world, e, EcsScript);
+    if (s->assembly) {
+        char *assembly_name = ecs_get_fullpath(world, s->assembly->entity);
+        ecs_err("cannot update scripts for individual assemblies, "
+            "update parent script instead (tried to update '%s')",
+                assembly_name);
+        ecs_os_free(assembly_name);
+        return -1;
+    }
+
+    if (s->script) {
+        ecs_script_free(s->script);
+    }
+
+    s->script = ecs_script_parse(world, name, code);
+    if (!s->script) {
+        return -1;
+    }
+
+    int result = 0;
+    bool is_defer = ecs_is_deferred(world);
+    ecs_suspend_readonly_state_t srs;
+    ecs_world_t *real_world = NULL;
+    if (is_defer) {
+        ecs_assert(flecs_poly_is(world, ecs_world_t), ECS_INTERNAL_ERROR, NULL);
+        real_world = flecs_suspend_readonly(world, &srs);
+        ecs_assert(real_world != NULL, ECS_INTERNAL_ERROR, NULL);
+    }
+
+    ecs_script_clear(world, e, instance);
+
+    ecs_entity_t prev = ecs_set_with(world, flecs_script_tag(e, instance));
+
+    if (ecs_script_eval(s->script)) {
+        ecs_delete_with(world, ecs_pair_t(EcsScript, e));
+        result = -1;
+    }
+
+    ecs_set_with(world, prev);
+
+    if (is_defer) {
+        flecs_resume_readonly(real_world, &srs);
+    }
+
+    return result;
+}
+
+ecs_entity_t ecs_script_init(
+    ecs_world_t *world,
+    const ecs_script_desc_t *desc)
+{
+    const char *script = NULL;
+    ecs_entity_t e = desc->entity;
+    
+    ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_check(desc != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    if (!e) {
+        if (desc->filename) {
+            e = ecs_new_from_path_w_sep(world, 0, desc->filename, "/", NULL);
+        } else {
+            e = ecs_new(world);
+        }
+    }
+
+    script = desc->code;
+    if (!script && desc->filename) {
+        script = flecs_load_from_file(desc->filename);
+        if (!script) {
+            goto error;
+        }
+    }
+
+    if (ecs_script_update(world, e, 0, script)) {
+        goto error;
+    }
+
+    if (script != desc->code) {
+        /* Safe cast, only happens when script is loaded from file */
+        ecs_os_free(ECS_CONST_CAST(char*, script));
+    }
+
+    return e;
+error:
+    if (script != desc->code) {
+        /* Safe cast, only happens when script is loaded from file */
+        ecs_os_free(ECS_CONST_CAST(char*, script));
+    }
+    if (!desc->entity) {
+        ecs_delete(world, e);
+    }
+    return 0;
+}
+
+void FlecsScriptImport(
+    ecs_world_t *world)
+{
+    ECS_MODULE(world, FlecsScript);
+    ECS_IMPORT(world, FlecsMeta);
+#ifdef FLECS_DOC
+    ECS_IMPORT(world, FlecsDoc);
+    ecs_doc_set_brief(world, ecs_id(FlecsScript), 
+        "Module with components for managing Flecs scripts");
+#endif
+
+    ecs_set_name_prefix(world, "Ecs");
+    ECS_COMPONENT_DEFINE(world, EcsScript);
+
+    ecs_set_hooks(world, EcsScript, {
+        .ctor = flecs_default_ctor,
+        .move = ecs_move(EcsScript),
+        .dtor = ecs_dtor(EcsScript)
+    });
+
+    ecs_add_id(world, ecs_id(EcsScript), EcsPairIsTag);
+    ecs_add_id(world, ecs_id(EcsScript), EcsPrivate);
+}
+
+#endif
diff --git a/src/addons/script/script.h b/src/addons/script/script.h
new file mode 100644
index 000000000..a8433655e
--- /dev/null
+++ b/src/addons/script/script.h
@@ -0,0 +1,96 @@
+/**
+ * @file addons/script/script.h
+ * @brief Flecs script implementation.
+ */
+
+#ifndef FLECS_SCRIPT_PRIVATE_H
+#define FLECS_SCRIPT_PRIVATE_H
+
+#include "../../private_api.h"
+
+#ifdef FLECS_SCRIPT
+
+#include <ctype.h>
+
+typedef struct ecs_script_scope_t ecs_script_scope_t;
+typedef struct ecs_script_entity_t ecs_script_entity_t;
+
+struct ecs_script_t {
+    ecs_world_t *world;
+    const char *name;
+    const char *code;
+    ecs_allocator_t allocator;
+    ecs_script_scope_t *root;
+    char *token_buffer;
+    int32_t token_buffer_size;
+    int32_t refcount;
+};
+
+typedef struct ecs_script_parser_t ecs_script_parser_t;
+
+#include "tokenizer.h"
+
+struct ecs_script_parser_t {
+    ecs_script_t *script;
+    ecs_script_scope_t *scope;
+    const char *pos;
+    char *token_cur;
+    bool significant_newline;
+
+    /* For term parser */
+    ecs_term_t *term;
+    ecs_oper_kind_t extra_oper;
+    ecs_term_ref_t *extra_args;
+};
+
+#include "ast.h"
+#include "visit.h"
+#include "visit_eval.h"
+
+struct ecs_script_assembly_t {
+    /* Assembly handle */
+    ecs_entity_t entity;
+
+    /* Assembly AST node */
+    ecs_script_assembly_node_t *node;
+
+    /* Hoisted using statements */
+    ecs_vec_t using_;
+
+    /* Hoisted variables */
+    ecs_vec_t vars;
+
+    /* Default values for props */
+    ecs_vec_t prop_defaults;
+
+    /* Type info for assembly component */
+    const ecs_type_info_t *type_info;
+};
+
+ecs_script_t* flecs_script_new(
+    ecs_world_t *world);
+
+ecs_script_scope_t* flecs_script_scope_new(
+    ecs_script_parser_t *parser);
+
+int flecs_script_visit_free(
+    ecs_script_t *script);
+
+ecs_script_vars_t* flecs_script_vars_push(
+    ecs_script_vars_t *parent,
+    ecs_stack_t *stack,
+    ecs_allocator_t *allocator);
+
+int flecs_terms_parse(
+    ecs_script_t *script,
+    ecs_term_t *terms,
+    int32_t *term_count_out);
+
+const char* flecs_id_parse(
+    const ecs_world_t *world,
+    const char *name,
+    const char *expr,
+    ecs_id_t *id);
+
+#endif // FLECS_SCRIPT
+#endif // FLECS_SCRIPT_PRIVATE_H
diff --git a/src/addons/expr/serialize.c b/src/addons/script/serialize.c
similarity index 71%
rename from src/addons/expr/serialize.c
rename to src/addons/script/serialize.c
index 3202c32a3..eaa28022b 100644
--- a/src/addons/expr/serialize.c
+++ b/src/addons/script/serialize.c
@@ -1,11 +1,13 @@
 /**
- * @file expr/serialize.c
- * @brief Serialize (component) values to flecs string format.
+ * @file addons/script/serialize.c
+ * @brief Serialize values to string.
  */
 
-#include "../../private_api.h"
+#include "flecs.h"
+#include "../meta/meta.h"
 
-#ifdef FLECS_EXPR
+#ifdef FLECS_SCRIPT
+#include "script.h"
 
 static
 int flecs_expr_ser_type(
@@ -38,127 +40,6 @@ ecs_primitive_kind_t flecs_expr_op_to_primitive_kind(ecs_meta_type_op_kind_t kin
     return kind - EcsOpPrimitive;
 }
 
-/* Serialize a primitive value */
-static
-int flecs_expr_ser_primitive(
-    const ecs_world_t *world,
-    ecs_primitive_kind_t kind,
-    const void *base, 
-    ecs_strbuf_t *str,
-    bool is_expr) 
-{
-    switch(kind) {
-    case EcsBool:
-        if (*(const bool*)base) {
-            ecs_strbuf_appendlit(str, "true");
-        } else {
-            ecs_strbuf_appendlit(str, "false");
-        }
-        break;
-    case EcsChar: {
-        char chbuf[3];
-        char ch = *(const char*)base;
-        if (ch) {
-            ecs_chresc(chbuf, *(const char*)base, '"');
-            if (is_expr) ecs_strbuf_appendch(str, '"');
-            ecs_strbuf_appendstr(str, chbuf);
-            if (is_expr) ecs_strbuf_appendch(str, '"');
-        } else {
-            ecs_strbuf_appendch(str, '0');
-        }
-        break;
-    }
-    case EcsByte:
-        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint8_t*)base));
-        break;
-    case EcsU8:
-        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint8_t*)base));
-        break;
-    case EcsU16:
-        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint16_t*)base));
-        break;
-    case EcsU32:
-        ecs_strbuf_appendint(str, flecs_uto(int64_t, *(const uint32_t*)base));
-        break;
-    case EcsU64:
-        ecs_strbuf_append(str, "%llu", *(const uint64_t*)base);
-        break;
-    case EcsI8:
-        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int8_t*)base));
-        break;
-    case EcsI16:
-        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int16_t*)base));
-        break;
-    case EcsI32:
-        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const int32_t*)base));
-        break;
-    case EcsI64:
-        ecs_strbuf_appendint(str, *(const int64_t*)base);
-        break;
-    case EcsF32:
-        ecs_strbuf_appendflt(str, (double)*(const float*)base, 0);
-        break;
-    case EcsF64:
-        ecs_strbuf_appendflt(str, *(const double*)base, 0);
-        break;
-    case EcsIPtr:
-        ecs_strbuf_appendint(str, flecs_ito(int64_t, *(const intptr_t*)base));
-        break;
-    case EcsUPtr:
-        ecs_strbuf_append(str, "%u", *(const uintptr_t*)base);
-        break;
-    case EcsString: {
-        const char *value = *ECS_CONST_CAST(const char**, base);
-        if (value) {
-            if (!is_expr) {
-                ecs_strbuf_appendstr(str, value);
-            } else {
-                ecs_size_t length = ecs_stresc(NULL, 0, '"', value);
-                if (length == ecs_os_strlen(value)) {
-                    ecs_strbuf_appendch(str, '"');
-                    ecs_strbuf_appendstrn(str, value, length);
-                    ecs_strbuf_appendch(str, '"');
-                } else {
-                    char *out = ecs_os_malloc(length + 3);
-                    ecs_stresc(out + 1, length, '"', value);
-                    out[0] = '"';
-                    out[length + 1] = '"';
-                    out[length + 2] = '\0';
-                    ecs_strbuf_appendstr(str, out);
-                    ecs_os_free(out);
-                }
-            }
-        } else {
-            ecs_strbuf_appendlit(str, "null");
-        }
-        break;
-    }
-    case EcsEntity: {
-        ecs_entity_t e = *(const ecs_entity_t*)base;
-        if (!e) {
-            ecs_strbuf_appendch(str, '0');
-        } else {
-            ecs_get_path_w_sep_buf(world, 0, e, ".", NULL, str);
-        }
-        break;
-    }
-    case EcsId: {
-        ecs_id_t id = *(const ecs_id_t*)base;
-        if (!id) {
-            ecs_strbuf_appendch(str, '0');
-        } else {
-            ecs_id_str_buf(world, id, str);
-        }
-        break;
-    }
-    default:
-        ecs_err("invalid primitive kind");
-        return -1;
-    }
-
-    return 0;
-}
-
 /* Serialize enumeration */
 static
 int flecs_expr_ser_enum(
@@ -280,8 +161,8 @@ int expr_ser_type_elements(
     ecs_strbuf_t *str,
     bool is_array)
 {
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
     ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL);
 
     const EcsComponent *comp = ecs_get(world, type, EcsComponent);
@@ -502,8 +383,8 @@ int ecs_ptr_to_expr_buf(
     const void *ptr,
     ecs_strbuf_t *buf_out)
 {
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
     if (ser == NULL) {
         char *path = ecs_get_fullpath(world, type);
         ecs_err("cannot serialize value for type '%s'", path);
@@ -541,8 +422,8 @@ int ecs_ptr_to_str_buf(
     const void *ptr,
     ecs_strbuf_t *buf_out)
 {
-    const EcsMetaTypeSerialized *ser = ecs_get(
-        world, type, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *ser = ecs_get(
+        world, type, EcsTypeSerializer);
     if (ser == NULL) {
         char *path = ecs_get_fullpath(world, type);
         ecs_err("cannot serialize value for type '%s'", path);
@@ -574,13 +455,4 @@ char* ecs_ptr_to_str(
     return ecs_strbuf_get(&str);
 }
 
-int ecs_primitive_to_expr_buf(
-    const ecs_world_t *world,
-    ecs_primitive_kind_t kind,
-    const void *base, 
-    ecs_strbuf_t *str)
-{
-    return flecs_expr_ser_primitive(world, kind, base, str, true);
-}
-
 #endif
diff --git a/src/addons/script/tokenizer.c b/src/addons/script/tokenizer.c
new file mode 100644
index 000000000..a384c2b39
--- /dev/null
+++ b/src/addons/script/tokenizer.c
@@ -0,0 +1,526 @@
+/**
+ * @file addons/script/tokenizer.c
+ * @brief Script tokenizer.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+
+#define Keyword(keyword, _kind)\
+    } else if (!ecs_os_strncmp(pos, keyword " ", ecs_os_strlen(keyword) + 1)) {\
+        out->value = keyword;\
+        out->kind = _kind;\
+        return pos + ecs_os_strlen(keyword);
+
+#define OperatorMultiChar(oper, _kind)\
+    } else if (!ecs_os_strncmp(pos, oper, ecs_os_strlen(oper))) {\
+        out->value = oper;\
+        out->kind = _kind;\
+        return pos + ecs_os_strlen(oper);
+
+#define Operator(oper, _kind)\
+    } else if (pos[0] == oper[0]) {\
+        out->value = oper;\
+        out->kind = _kind;\
+        return pos + 1;
+
+const char* flecs_script_token_kind_str(
+    ecs_script_token_kind_t kind)
+{
+    switch(kind) {
+    case EcsTokUnknown:
+        return "unknown token ";
+    case EcsTokColon:
+    case EcsTokScopeOpen:
+    case EcsTokScopeClose:
+    case EcsTokParenOpen:
+    case EcsTokParenClose:
+    case EcsTokBracketOpen:
+    case EcsTokBracketClose:
+    case EcsTokAnnotation:
+    case EcsTokComma:
+    case EcsTokSemiColon:
+    case EcsTokMul:
+    case EcsTokAssign:
+    case EcsTokBitwiseOr:
+    case EcsTokNot:
+    case EcsTokOptional:
+    case EcsTokEq:
+    case EcsTokNeq:
+    case EcsTokMatch:
+    case EcsTokOr:
+        return "";
+    case EcsTokKeywordWith:
+    case EcsTokKeywordUsing:
+    case EcsTokKeywordAssembly:
+    case EcsTokKeywordProp:
+    case EcsTokKeywordConst:
+    case EcsTokKeywordIf:
+    case EcsTokKeywordElse:
+    case EcsTokKeywordModule:
+        return "keyword ";
+    case EcsTokIdentifier:
+        return "identifier ";
+    case EcsTokString:
+        return "string ";
+    case EcsTokNumber:
+        return "number ";
+    case EcsTokNewline:
+        return "newline";
+    case EcsTokEnd:
+        return "end of script";
+    default:
+        return "<corrupt>";
+    }
+}
+
+const char* flecs_scan_whitespace(
+    ecs_script_parser_t *parser,
+    const char *pos) 
+{
+    (void)parser;
+
+    if (parser->significant_newline) {
+        while (pos[0] && isspace(pos[0]) && pos[0] != '\n') {
+            pos ++;
+        }
+    } else {
+        while (pos[0] && isspace(pos[0])) {
+            pos ++;
+        }
+    }
+
+    return pos;
+}
+
+static
+const char* flecs_scan_whitespace_and_comment(
+    ecs_script_parser_t *parser,
+    const char *pos) 
+{
+repeat_skip_whitespace_comment:
+    pos = flecs_scan_whitespace(parser, pos);
+    if (pos[0] == '/') {
+        if (pos[1] == '/') {
+            for (pos = pos + 2; pos[0] && pos[0] != '\n'; pos ++) { }
+            if (pos[0] == '\n') {
+                pos ++;
+                goto repeat_skip_whitespace_comment;
+            }
+        } else if (pos[1] == '*') {
+            for (pos = &pos[2]; pos[0] != 0; pos ++) {
+                if (pos[0] == '*' && pos[1] == '/') {
+                    pos += 2;
+                    goto repeat_skip_whitespace_comment;
+                }
+            }
+
+            ecs_parser_error(parser->script->name, parser->script->code, 
+                pos - parser->script->code, "missing */ for multiline comment");
+        }
+    }
+
+    return pos;
+}
+
+// Identifier token
+static
+bool flecs_script_is_identifier(
+    char c)
+{
+    return isalpha(c) || (c == '_') || (c == '$');
+}
+
+static
+const char* flecs_script_identifier(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out) 
+{
+    out->kind = EcsTokIdentifier;
+    out->value = parser->token_cur;
+
+    ecs_assert(flecs_script_is_identifier(pos[0]), ECS_INTERNAL_ERROR, NULL);
+    char *outpos = parser->token_cur;
+    do {
+        char c = pos[0];
+        bool is_ident = flecs_script_is_identifier(c) || 
+            isdigit(c) || (c == '.') || (c == '*');
+
+        if (!is_ident) {
+            if (c == '\\') {
+                pos ++;
+            } else if (c == '<') {
+                int32_t indent = 0;
+                do {
+                    c = *pos;
+
+                    if (c == '<') {
+                        indent ++;
+                    } else if (c == '>') {
+                        indent --;
+                    } else if (!c) {
+                        ecs_parser_error(parser->script->name, 
+                            parser->script->code, pos - parser->script->code, 
+                                "< without > in identifier");
+                        return NULL;
+                    }
+
+                    *outpos = c;
+                    outpos ++;
+                    pos ++;
+
+                    if (!indent) {
+                        break;
+                    }
+                } while (true);
+
+                *outpos = '\0';
+                parser->token_cur = outpos + 1;
+                return pos;
+            } else if (c == '>') {
+                ecs_parser_error(parser->script->name, parser->script->code,
+                    pos - parser->script->code, "> without < in identifier");
+                return NULL;
+            } else {
+                *outpos = '\0';
+                parser->token_cur = outpos + 1;
+                return pos;
+            }
+        }
+
+        *outpos = *pos;
+        outpos ++;
+        pos ++;
+    } while (true);
+}
+
+// Number token
+static
+bool flecs_script_is_number(
+    char c)
+{
+    return isdigit(c) || (c == '-');
+}
+
+static
+const char* flecs_script_number(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out) 
+{
+    out->kind = EcsTokNumber;
+    out->value = parser->token_cur;
+
+    ecs_assert(flecs_script_is_number(pos[0]), ECS_INTERNAL_ERROR, NULL);
+    char *outpos = parser->token_cur;
+    do {
+        char c = pos[0];
+        if (!isdigit(c)) {
+            *outpos = '\0';
+            parser->token_cur = outpos + 1;
+            break;
+        }
+
+        outpos[0] = pos[0];
+        outpos ++;
+        pos ++;
+    } while (true);
+
+    return pos;
+}
+
+static
+const char* flecs_script_skip_string(
+    ecs_script_parser_t *parser,
+    const char *pos, 
+    char delim)
+{
+    char ch;
+    for (; (ch = pos[0]) && pos[0] != delim; pos ++) {
+        if (ch == '\\') {
+            pos ++;
+        }
+    }
+
+    if (!pos[0]) {
+        ecs_parser_error(parser->script->name, parser->script->code,
+            pos - parser->script->code, "unterminated string");
+        return NULL;
+    }
+
+    return pos;
+}
+
+static
+const char* flecs_script_string(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out) 
+{
+    const char *end = flecs_script_skip_string(parser, pos + 1, '"');
+    if (!end) {
+        return NULL;
+    }
+
+    ecs_assert(end[0] == '"', ECS_INTERNAL_ERROR, NULL);
+    end --;
+
+    int32_t len = flecs_ito(int32_t, end - pos);
+    ecs_os_memcpy(parser->token_cur, pos + 1, len);
+    parser->token_cur[len] = '\0';
+
+    out->kind = EcsTokString;
+    out->value = parser->token_cur;
+    parser->token_cur += len + 1;
+    return end + 2;
+}
+
+const char* flecs_script_expr(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out,
+    char until)
+{
+    parser->pos = pos;
+
+    int32_t scope_depth = until == '}' ? 1 : 0;
+    int32_t paren_depth = until == ')' ? 1 : 0;
+    
+    const char *start = pos = flecs_scan_whitespace(parser, pos);
+    char ch;
+
+    for (; (ch = pos[0]); pos ++) {
+        if (ch == '{') {
+            if (ch == until) {
+                break;
+            }
+            scope_depth ++;
+        } else 
+        if (ch == '}') {
+            scope_depth --;
+            if (!scope_depth && until == '}') {
+                break;
+            }
+            if (scope_depth < 0) {
+                ecs_parser_error(parser->script->name, parser->script->code,
+                    pos - parser->script->code, "mismatching { }");
+                return NULL;
+            }
+        } else
+        if (ch == '(') {
+            paren_depth ++;
+        } else
+        if (ch == ')') {
+            paren_depth --;
+            if (!paren_depth && until == ')') {
+                break;
+            }
+            if (paren_depth < 0) {
+                ecs_parser_error(parser->script->name, parser->script->code,
+                    pos - parser->script->code, "mismatching ( )");
+                return NULL;
+            }
+        } else
+        if (ch == '"') {
+            pos = flecs_script_skip_string(parser, pos + 1, '"');
+            if (!pos) {
+                return NULL;
+            }
+        } else
+        if (ch == '`') {
+            pos = flecs_script_skip_string(parser, pos + 1, '`');
+            if (!pos) {
+                return NULL;
+            }
+        } else
+        if (ch == until) {
+            break;
+        }
+    }
+
+    if (!pos[0]) {
+        if (until == '\0') {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected end of script");
+            return NULL;
+        } else
+        if (until == '\n') {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected newline");
+            return NULL;
+        } else {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected '%c'", until);
+            return NULL;
+        }
+    }
+
+    if (scope_depth) {
+        ecs_parser_error(parser->script->name, parser->script->code,
+            pos - parser->script->code, "mismatching { }");
+        return NULL;
+    }
+    if (paren_depth) {
+        ecs_parser_error(parser->script->name, parser->script->code,
+            pos - parser->script->code, "mismatching ( )");
+        return NULL;
+    }
+
+    if (until != ']') {
+        parser->token_cur[0] = '{';
+    } else {
+        parser->token_cur[0] = '[';
+    }
+    
+    int32_t len = flecs_ito(int32_t, pos - start);
+    ecs_os_memcpy(parser->token_cur + 1, start, len);
+    out->value = parser->token_cur;
+    parser->token_cur += len + 1;
+
+    while (isspace(parser->token_cur[-1])) {
+        parser->token_cur --;
+    }
+
+    if (until != ']') {
+        parser->token_cur[0] = '}';
+    } else {
+        parser->token_cur[0] = ']';
+    }
+
+    parser->token_cur ++;
+
+    parser->token_cur[0] = '\0';
+    parser->token_cur ++;
+
+    return pos;
+}
+
+const char* flecs_script_until(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out,
+    char until)
+{
+    parser->pos = pos;
+    
+    const char *start = pos = flecs_scan_whitespace(parser, pos);
+    char ch;
+
+    for (; (ch = pos[0]); pos ++) {
+        if (ch == until) {
+            break;
+        }
+    }
+
+    if (!pos[0]) {
+        if (until == '\0') {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected end of script");
+            return NULL;
+        } else
+        if (until == '\n') {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected newline");
+            return NULL;
+        } else {
+            ecs_parser_error(parser->script->name, parser->script->code,
+                pos - parser->script->code, "expected '%c'", until);
+            return NULL;
+        }
+    }
+
+    int32_t len = flecs_ito(int32_t, pos - start);
+    ecs_os_memcpy(parser->token_cur, start, len);
+    out->value = parser->token_cur;
+    parser->token_cur += len;
+
+    while (isspace(parser->token_cur[-1])) {
+        parser->token_cur --;
+    }
+
+    parser->token_cur[0] = '\0';
+    parser->token_cur ++;
+
+    return pos;
+}
+
+const char* flecs_script_token(
+    ecs_script_parser_t *parser,
+    const char *pos,
+    ecs_script_token_t *out,
+    bool is_lookahead)
+{
+    parser->pos = pos;
+
+    // Skip whitespace and comments
+    pos = flecs_scan_whitespace_and_comment(parser, pos);
+
+    out->kind = EcsTokUnknown;
+    out->value = NULL;
+
+    if (pos[0] == '\0') {
+        out->kind = EcsTokEnd;
+        return pos;
+    } else if (pos[0] == '\n') {
+        out->kind = EcsTokNewline;
+        
+        // Parse multiple newlines/whitespaces as a single token
+        pos = flecs_scan_whitespace_and_comment(parser, pos + 1);
+        if (pos[0] == '\n') {
+            pos ++;
+        }
+        return pos;
+
+    Operator          (":",        EcsTokColon)
+    Operator          ("{",        EcsTokScopeOpen)
+    Operator          ("}",        EcsTokScopeClose)
+    Operator          ("(",        EcsTokParenOpen)
+    Operator          (")",        EcsTokParenClose)
+    Operator          ("[",        EcsTokBracketOpen)
+    Operator          ("]",        EcsTokBracketClose)
+    Operator          ("@",        EcsTokAnnotation)
+    Operator          (",",        EcsTokComma)
+    Operator          (";",        EcsTokSemiColon)
+    Operator          ("*",        EcsTokMul)
+    Operator          ("?",        EcsTokOptional)
+
+    OperatorMultiChar ("==",       EcsTokEq)
+    OperatorMultiChar ("!=",       EcsTokNeq)
+    OperatorMultiChar ("~=",       EcsTokMatch)
+    OperatorMultiChar ("||",       EcsTokOr)
+
+    OperatorMultiChar ("!",        EcsTokNot)
+    OperatorMultiChar ("=",        EcsTokAssign)
+    OperatorMultiChar ("|",        EcsTokBitwiseOr)
+
+    Keyword           ("with",     EcsTokKeywordWith)
+    Keyword           ("using",    EcsTokKeywordUsing)
+    Keyword           ("assembly", EcsTokKeywordAssembly)
+    Keyword           ("prop",     EcsTokKeywordProp)
+    Keyword           ("const",    EcsTokKeywordConst)
+    Keyword           ("if",       EcsTokKeywordIf)
+    Keyword           ("else",     EcsTokKeywordElse)
+    Keyword           ("module",   EcsTokKeywordModule)
+
+    } else if (pos[0] == '"') {
+        return flecs_script_string(parser, pos, out);
+
+    } else if (flecs_script_is_number(pos[0])) {
+        return flecs_script_number(parser, pos, out);
+
+    } else if (flecs_script_is_identifier(pos[0])) {
+        return flecs_script_identifier(parser, pos, out);
+    }
+
+    if (!is_lookahead) {
+        ecs_parser_error(parser->script->name, parser->script->code,
+            pos - parser->script->code, "unknown token '%c'", pos[0]);
+    }
+
+    return NULL;
+}
+
+#endif
diff --git a/src/addons/script/tokenizer.h b/src/addons/script/tokenizer.h
new file mode 100644
index 000000000..2c4e8a07e
--- /dev/null
+++ b/src/addons/script/tokenizer.h
@@ -0,0 +1,81 @@
+/**
+ * @file addons/script/tokenizer.h
+ * @brief Script tokenizer.
+ */
+
+#ifndef FLECS_SCRIPT_TOKENIZER_H
+#define FLECS_SCRIPT_TOKENIZER_H
+
+/* Tokenizer */
+typedef enum ecs_script_token_kind_t {
+    EcsTokEnd = '\0',
+    EcsTokUnknown,
+    EcsTokScopeOpen = '{',
+    EcsTokScopeClose = '}',
+    EcsTokParenOpen = '(',
+    EcsTokParenClose = ')',
+    EcsTokBracketOpen = '[',
+    EcsTokBracketClose = ']',
+    EcsTokMul = '*',
+    EcsTokComma = ',',
+    EcsTokSemiColon = ';',
+    EcsTokColon = ':',
+    EcsTokAssign = '=',
+    EcsTokBitwiseOr = '|',
+    EcsTokNot = '!',
+    EcsTokOptional = '?',
+    EcsTokAnnotation = '@',
+    EcsTokNewline = '\n',
+    EcsTokEq,
+    EcsTokNeq,
+    EcsTokMatch,
+    EcsTokOr,
+    EcsTokIdentifier,
+    EcsTokString,
+    EcsTokNumber,
+    EcsTokKeywordModule,
+    EcsTokKeywordUsing,
+    EcsTokKeywordWith,
+    EcsTokKeywordIf,
+    EcsTokKeywordElse,
+    EcsTokKeywordAssembly,
+    EcsTokKeywordProp,
+    EcsTokKeywordConst,
+} ecs_script_token_kind_t;
+
+typedef struct ecs_script_token_t {
+    const char *value;
+    ecs_script_token_kind_t kind;
+} ecs_script_token_t;
+
+typedef struct ecs_script_tokens_t {
+    int32_t count;
+    ecs_script_token_t tokens[256];
+} ecs_script_tokens_t;
+
+const char* flecs_script_expr(
+    ecs_script_parser_t *parser,
+    const char *ptr,
+    ecs_script_token_t *out,
+    char until);
+
+const char* flecs_script_until(
+    ecs_script_parser_t *parser,
+    const char *ptr,
+    ecs_script_token_t *out,
+    char until);
+
+const char* flecs_script_token_kind_str(
+    ecs_script_token_kind_t kind);
+
+const char* flecs_script_token(
+    ecs_script_parser_t *parser,
+    const char *ptr,
+    ecs_script_token_t *out,
+    bool is_lookahead);
+
+const char* flecs_scan_whitespace(
+    ecs_script_parser_t *parser,
+    const char *pos);
+
+#endif
diff --git a/src/addons/script/vars.c b/src/addons/script/vars.c
new file mode 100644
index 000000000..1d11689b6
--- /dev/null
+++ b/src/addons/script/vars.c
@@ -0,0 +1,280 @@
+/**
+ * @file addons/script/vars.c
+ * @brief Script variables.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+
+ecs_script_vars_t* flecs_script_vars_push(
+    ecs_script_vars_t *parent,
+    ecs_stack_t *stack,
+    ecs_allocator_t *allocator)
+{
+    ecs_check(stack || parent, ECS_INVALID_PARAMETER, 
+        "must provide either parent scope or stack allocator");
+    ecs_check(allocator || parent, ECS_INVALID_PARAMETER, 
+        "must provide either parent scope or allocator");
+
+    if (!stack) {
+        stack = parent->stack;
+    } else if (parent) {
+        ecs_check(stack == parent->stack, ECS_INVALID_PARAMETER, 
+            "provided stack allocator is different from parent scope");
+    }
+    if (!allocator) {
+        allocator = parent->allocator;
+    } else if (parent) {
+        ecs_check(allocator == parent->allocator, ECS_INVALID_PARAMETER, 
+            "provided allocator is different from parent scope");        
+    }
+
+    ecs_stack_cursor_t *cursor = flecs_stack_get_cursor(stack);
+    ecs_script_vars_t *result = flecs_stack_calloc_t(stack, ecs_script_vars_t);
+    ecs_vec_init_t(allocator, &result->vars, ecs_script_var_t, 0);
+    result->parent = parent;
+    if (parent) {
+        result->world = parent->world;
+    }
+    result->stack = stack;
+    result->allocator = allocator;
+    result->cursor = cursor;
+    return result;
+error:
+    return NULL;
+}
+
+ecs_script_vars_t* ecs_script_vars_init(
+    ecs_world_t *world)
+{
+    ecs_script_vars_t *result = flecs_script_vars_push(NULL, 
+        flecs_stage_get_stack_allocator(world),
+        flecs_stage_get_allocator(world));
+    result->world = ecs_get_world(world); /* Provided world can be stage */
+    return result;
+}
+
+void ecs_script_vars_fini(
+    ecs_script_vars_t *vars)
+{
+    ecs_check(vars->parent == NULL, ECS_INVALID_PARAMETER,
+        "ecs_script_vars_fini can only be called on the roots cope");
+    ecs_script_vars_pop(vars);
+error:
+    return;
+}
+
+ecs_script_vars_t* ecs_script_vars_push(
+    ecs_script_vars_t *parent)
+{
+    ecs_check(parent != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_stack_t *stack = parent->stack;
+    ecs_allocator_t *allocator = parent->allocator;
+    ecs_check(stack != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(allocator != NULL, ECS_INVALID_PARAMETER, NULL);
+    return flecs_script_vars_push(parent, stack, allocator);
+error:
+    return NULL;
+}
+
+ecs_script_vars_t* ecs_script_vars_pop(
+    ecs_script_vars_t *vars)
+{
+    ecs_script_vars_t *parent = vars->parent;
+    ecs_stack_cursor_t *cursor = vars->cursor;
+    int32_t i, count = ecs_vec_count(&vars->vars);
+    if (count) {
+        ecs_script_var_t *var_array = ecs_vec_first(&vars->vars);
+        for (i = 0; i < count; i ++) {
+            ecs_script_var_t *var = &var_array[i];
+            if (!var->value.ptr) {
+                continue;
+            }
+
+            if (!var->type_info || !var->type_info->hooks.dtor) {
+                continue;
+            }
+
+            var->type_info->hooks.dtor(var->value.ptr, 1, var->type_info);
+        }
+
+        flecs_name_index_fini(&vars->var_index);
+    }
+
+    ecs_vec_fini_t(vars->allocator, &vars->vars, ecs_script_var_t);
+    flecs_stack_restore_cursor(vars->stack, cursor);
+    return parent;
+}
+
+ecs_script_var_t* ecs_script_vars_declare(
+    ecs_script_vars_t *vars,
+    const char *name)
+{
+    if (!ecs_vec_count(&vars->vars)) {
+        flecs_name_index_init(&vars->var_index, vars->allocator);
+    } else {
+        if (flecs_name_index_find(&vars->var_index, name, 0, 0) != 0) {
+            goto error;
+        }
+    }
+
+    ecs_script_var_t *var = ecs_vec_append_t(
+        vars->allocator, &vars->vars, ecs_script_var_t);
+    var->name = name;
+    var->value.ptr = NULL;
+    var->value.type = 0;
+    var->type_info = NULL;
+
+    flecs_name_index_ensure(&vars->var_index,
+        flecs_ito(uint64_t, ecs_vec_count(&vars->vars)), name, 0, 0);
+
+    return var;
+error:
+    return NULL;
+}
+
+ecs_script_var_t* ecs_script_vars_define_id(
+    ecs_script_vars_t *vars,
+    const char *name,
+    ecs_entity_t type)
+{
+    ecs_check(vars->world != NULL, ECS_INVALID_OPERATION, "variable scope is "
+        "not associated with world, create scope with ecs_script_vars_init");
+
+    const ecs_type_info_t *ti = ecs_get_type_info(vars->world, type);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, 
+        "the entity provided for the type parameter is not a type");
+
+    ecs_script_var_t *result = ecs_script_vars_declare(vars, name);
+    if (!result) {
+        return NULL;
+    }
+
+    result->value.type = type;
+    result->value.ptr = flecs_stack_alloc(vars->stack, ti->size, ti->alignment);
+    result->type_info = ti;
+
+    if (ti->hooks.ctor) {
+        ti->hooks.ctor(result->value.ptr, 1, ti);
+    }
+
+    return result;
+error:
+    return NULL;
+}
+
+ecs_script_var_t* ecs_script_vars_lookup(
+    const ecs_script_vars_t *vars,
+    const char *name)
+{
+    uint64_t var_id = 0;
+    if (ecs_vec_count(&vars->vars)) {
+        var_id = flecs_name_index_find(&vars->var_index, name, 0, 0);
+    }
+
+    if (!var_id) {
+        if (vars->parent) {
+            return ecs_script_vars_lookup(vars->parent, name);
+        }
+        return NULL;
+    }
+
+    return ecs_vec_get_t(&vars->vars, ecs_script_var_t, 
+        flecs_uto(int32_t, var_id - 1));
+}
+
+/* Static names for iterator fields */
+static const char* flecs_script_iter_field_names[] = {
+    "0", "1",  "2",  "3",  "4",  "5",  "6",  "7",
+    "8", "9", "10", "11", "12", "13", "14", "15"
+};
+
+void ecs_script_vars_from_iter(
+    const ecs_iter_t *it,
+    ecs_script_vars_t *vars,
+    int offset)
+{
+    ecs_check(vars != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!offset || offset < it->count, ECS_INVALID_PARAMETER, NULL);
+
+    /* Set variable for $this */
+    if (it->count) {
+        ecs_script_var_t *var = ecs_script_vars_lookup(vars, "this");
+        if (!var) {
+            var = ecs_script_vars_declare(vars, "this");
+            var->value.type = ecs_id(ecs_entity_t);
+        }
+        var->value.ptr = &it->entities[offset];
+    }
+
+    /* Set variables for fields */
+    {
+        int32_t i, field_count = it->field_count;
+        for (i = 0; i < field_count; i ++) {
+            ecs_size_t size = it->sizes[i];
+            if (!size) {
+                continue;
+            }
+
+            void *ptr = it->ptrs[i];
+            if (!ptr) {
+                continue;
+            }
+
+            ptr = ECS_OFFSET(ptr, offset * size);
+
+            const char *name = flecs_script_iter_field_names[i];
+            ecs_script_var_t *var = ecs_script_vars_lookup(vars, name);
+            if (!var) {
+                var = ecs_script_vars_declare(vars, name);
+                ecs_assert(ecs_script_vars_lookup(vars, name) != NULL,  
+                    ECS_INTERNAL_ERROR, NULL);
+                var->value.type = it->ids[i];
+            } else {
+                ecs_check(var->value.type == it->ids[i], 
+                    ECS_INVALID_PARAMETER, NULL);
+            }
+            var->value.ptr = ptr;
+        }
+    }
+
+    /* Set variables for query variables */
+    {
+        int32_t i, var_count = it->variable_count;
+        for (i = 1 /* skip this variable */ ; i < var_count; i ++) {
+            ecs_entity_t *e_ptr = NULL;
+            ecs_var_t *query_var = &it->variables[i];
+            if (query_var->entity) {
+                e_ptr = &query_var->entity;
+            } else {
+                ecs_table_range_t *range = &query_var->range;
+                if (range->count == 1) {
+                    ecs_entity_t *entities = range->table->data.entities.array;
+                    e_ptr = &entities[range->offset];
+                }
+            }
+            if (!e_ptr) {
+                continue;
+            }
+
+            ecs_script_var_t *var = ecs_script_vars_lookup(
+                vars, it->variable_names[i]);
+            if (!var) {
+                var = ecs_script_vars_declare(vars, it->variable_names[i]);
+                var->value.type = ecs_id(ecs_entity_t);
+            } else {
+                ecs_check(var->value.type == ecs_id(ecs_entity_t), 
+                    ECS_INVALID_PARAMETER, NULL);
+            }
+            var->value.ptr = e_ptr;
+        }
+    }
+
+error:
+    return;
+}
+
+#endif
diff --git a/src/addons/script/visit.c b/src/addons/script/visit.c
new file mode 100644
index 000000000..61ea51a08
--- /dev/null
+++ b/src/addons/script/visit.c
@@ -0,0 +1,139 @@
+/**
+ * @file addons/script/visit.c
+ * @brief Script AST visitor utilities.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+
+ecs_script_node_t* ecs_script_parent_node_(
+    ecs_script_visit_t *v)
+{
+    if (v->depth > 1) {
+        return v->nodes[v->depth - 2]; /* Last node is current node */
+    } else {
+        return NULL;
+    }
+}
+
+ecs_script_scope_t* ecs_script_current_scope_(
+    ecs_script_visit_t *v)
+{
+    int32_t depth;
+    for(depth = v->depth - 1; depth >= 0; depth --) {
+        ecs_script_node_t *node = v->nodes[depth];
+        if (node->kind == EcsAstScope) {
+            return (ecs_script_scope_t*)node;
+        }
+    }
+
+    return NULL;
+}
+
+ecs_script_node_t* ecs_script_parent_(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *child)
+{
+    int32_t depth;
+    for(depth = v->depth - 1; depth >= 0; depth --) {
+        ecs_script_node_t *node = v->nodes[depth];
+        if (node == child && depth) {
+            return v->nodes[depth - 1];
+        }
+    }
+
+    return NULL;
+}
+
+int32_t ecs_script_node_line_number_(
+    ecs_script_t *script,
+    ecs_script_node_t *node)
+{
+    const char *ptr;
+    int32_t line_count = 1;
+    for (ptr = script->code; ptr < node->pos; ptr ++) {
+        ecs_assert(ptr[0] != 0, ECS_INTERNAL_ERROR, NULL);
+        if (ptr[0] == '\n') {
+            line_count ++;
+        }
+    }
+
+    return line_count;
+}
+
+int ecs_script_visit_scope_(
+    ecs_script_visit_t *v,
+    ecs_script_scope_t *scope)
+{
+    ecs_script_node_t **nodes = ecs_vec_first_t(
+        &scope->stmts, ecs_script_node_t*);
+
+    v->nodes[v->depth ++] = (ecs_script_node_t*)scope;
+
+    int32_t i, count = ecs_vec_count(&scope->stmts);
+    for (i = 0; i < count; i ++) {
+        if (!i) {
+            v->prev = NULL;
+        } else {
+            v->prev = nodes[i - 1];
+        }
+
+        if (i != (count - 1)) {
+            v->next = nodes[i + 1];
+        } else {
+            v->next = NULL;
+        }
+
+        v->nodes[v->depth ++] = nodes[i];
+
+        if (v->visit(v, nodes[i])) {
+            return -1;
+        }
+
+        v->depth --;
+    }
+
+    v->depth --;
+
+    return 0;
+}
+
+int ecs_script_visit_node_(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *node)
+{
+    v->nodes[v->depth ++] = node;
+
+    if (v->visit(v, node)) {
+        return -1;
+    }
+
+    v->depth --;
+
+    return 0;
+}
+
+int ecs_script_visit_(
+    ecs_script_visit_t *visitor,
+    ecs_visit_action_t visit,
+    ecs_script_t *script)
+{
+    visitor->script = script;
+    visitor->visit = visit;
+    visitor->depth = 0;
+    int result = ecs_script_visit_node(visitor, script->root);
+    if (result) {
+        return -1;
+    }
+
+    if (visitor->depth) {
+        ecs_parser_error(script->name, NULL, 0, "unexpected end of script");
+        return -1;
+    }
+
+    return 0;
+}
+
+#endif
diff --git a/src/addons/script/visit.h b/src/addons/script/visit.h
new file mode 100644
index 000000000..98793d210
--- /dev/null
+++ b/src/addons/script/visit.h
@@ -0,0 +1,80 @@
+/**
+ * @file addons/script/visit.h
+ * @brief Script AST visitor utilities.
+ */
+
+#ifndef FLECS_SCRIPT_VISIT_H
+#define FLECS_SCRIPT_VISIT_H
+
+typedef struct ecs_script_visit_t ecs_script_visit_t;
+
+typedef int (*ecs_visit_action_t)(
+    ecs_script_visit_t *visitor, 
+    ecs_script_node_t *node);
+
+struct ecs_script_visit_t {
+    ecs_script_t *script;
+    ecs_visit_action_t visit;
+    ecs_script_node_t* nodes[256];
+    ecs_script_node_t *prev, *next;
+    int32_t depth;
+};
+
+int ecs_script_visit_(
+    ecs_script_visit_t *visitor,
+    ecs_visit_action_t visit,
+    ecs_script_t *script);
+
+#define ecs_script_visit(script, visitor, visit) \
+    ecs_script_visit_((ecs_script_visit_t*)visitor,\
+        (ecs_visit_action_t)visit,\
+        script)
+
+int ecs_script_visit_node_(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *node);
+
+#define ecs_script_visit_node(visitor, node) \
+    ecs_script_visit_node_((ecs_script_visit_t*)visitor, \
+        (ecs_script_node_t*)node)
+
+int ecs_script_visit_scope_(
+    ecs_script_visit_t *v,
+    ecs_script_scope_t *node);
+
+#define ecs_script_visit_scope(visitor, node) \
+    ecs_script_visit_scope_((ecs_script_visit_t*)visitor, node)
+
+ecs_script_node_t* ecs_script_parent_node_(
+    ecs_script_visit_t *v);
+
+#define ecs_script_parent_node(visitor) \
+    ecs_script_parent_node_((ecs_script_visit_t*)visitor)
+
+ecs_script_scope_t* ecs_script_current_scope_(
+    ecs_script_visit_t *v);
+
+#define ecs_script_current_scope(visitor) \
+    ecs_script_current_scope_((ecs_script_visit_t*)visitor)
+
+ecs_script_node_t* ecs_script_parent_(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *node);
+
+#define ecs_script_parent(visitor, node) \
+    ecs_script_parent_((ecs_script_visit_t*)visitor, (ecs_script_node_t*)node)
+
+ecs_script_node_t* ecs_script_next_node_(
+    ecs_script_visit_t *v);
+
+#define ecs_script_next_node(visitor) \
+    ecs_script_next_node_((ecs_script_visit_t*)visitor)
+
+int32_t ecs_script_node_line_number_(
+    ecs_script_t *script,
+    ecs_script_node_t *node);
+
+#define ecs_script_node_line_number(script, node) \
+    ecs_script_node_line_number_(script, (ecs_script_node_t*)node)
+
+#endif
diff --git a/src/addons/script/visit_eval.c b/src/addons/script/visit_eval.c
new file mode 100644
index 000000000..5bd5cde43
--- /dev/null
+++ b/src/addons/script/visit_eval.c
@@ -0,0 +1,1119 @@
+/**
+ * @file addons/script/visit_eval.c
+ * @brief Script evaluation visitor.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+
+void flecs_script_eval_error_(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node,
+    const char *fmt,
+    ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    char *msg = flecs_vasprintf(fmt, args);
+    va_end(args);
+
+    if (node) {
+        int32_t line = ecs_script_node_line_number(v->base.script, node);
+        ecs_parser_error(v->base.script->name, NULL, 0, "%d: %s", line, msg);
+    } else {
+        ecs_parser_error(v->base.script->name, NULL, 0, "%s", msg);
+    }
+
+    ecs_os_free(msg);
+}
+
+static
+ecs_value_t* flecs_script_with_append(
+    ecs_allocator_t *a,
+    ecs_script_eval_visitor_t *v)
+{
+    if (ecs_vec_count(&v->with)) {
+        ecs_assert(ecs_vec_last_t(&v->with, ecs_value_t)->type == 0, 
+            ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(ecs_vec_last_t(&v->with, ecs_value_t)->ptr == NULL, 
+            ECS_INTERNAL_ERROR, NULL);
+        ecs_vec_remove_last(&v->with);
+    }
+
+    ecs_vec_append_t(a, &v->with, ecs_value_t);
+    ecs_value_t *last = ecs_vec_append_t(a, &v->with, ecs_value_t);
+    ecs_os_memset_t(last, 0, ecs_value_t);
+    return ecs_vec_get_t(&v->with, ecs_value_t, ecs_vec_count(&v->with) - 2);
+}
+
+static
+void flecs_script_with_set_count(
+    ecs_allocator_t *a,
+    ecs_script_eval_visitor_t *v,
+    int32_t count)
+{
+    if (count) {
+        ecs_value_t *last = ecs_vec_get_t(&v->with, ecs_value_t, count);
+        ecs_os_memset_t(last, 0, ecs_value_t);
+        ecs_vec_set_count_t(a, &v->with, ecs_value_t, count + 1);
+    } else {
+        ecs_vec_set_count_t(a, &v->with, ecs_value_t, 0);
+    }
+}
+
+static
+ecs_value_t* flecs_script_with_last(
+    ecs_script_eval_visitor_t *v)
+{
+    int32_t count = ecs_vec_count(&v->with);
+    if (count) {
+        return ecs_vec_get_t(&v->with, ecs_value_t, count - 2);
+    }
+    return NULL;
+}
+
+static
+int32_t flecs_script_with_count(
+    ecs_script_eval_visitor_t *v)
+{
+    if (ecs_vec_count(&v->with)) {
+        ecs_assert(ecs_vec_last_t(&v->with, ecs_value_t)->type == 0, 
+            ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(ecs_vec_last_t(&v->with, ecs_value_t)->ptr == NULL, 
+            ECS_INTERNAL_ERROR, NULL);
+        return ecs_vec_count(&v->with) - 1;
+    }
+    return 0;
+}
+
+const ecs_type_info_t* flecs_script_get_type_info(
+    ecs_script_eval_visitor_t *v,
+    void *node,
+    ecs_id_t id)
+{
+    ecs_id_record_t *idr = flecs_id_record_ensure(v->world, id);
+    if (!idr) {
+        goto error;
+    }
+
+    if (!idr->type_info) {
+        goto error;
+    }
+
+    return idr->type_info;
+error:
+    {
+        char *idstr = ecs_id_str(v->world, id);
+        flecs_script_eval_error(v, node, 
+            "cannot set value of '%s': not a component", idstr);
+        ecs_os_free(idstr);
+    }
+    return NULL;
+}
+
+ecs_entity_t flecs_script_find_entity(
+    ecs_script_eval_visitor_t *v,
+    ecs_entity_t from,
+    const char *path)
+{
+    if (!path) {
+        return 0;
+    }
+
+    if (path[0] == '$') {
+        const ecs_script_var_t *var = ecs_script_vars_lookup(v->vars, &path[1]);
+        if (!var) {
+            return 0;
+        }
+
+        if (var->value.type != ecs_id(ecs_entity_t)) {
+            char *type_str = ecs_id_str(v->world, var->value.type);
+            flecs_script_eval_error(v, NULL, 
+                "variable '%s' must be of type entity, got '%s'", 
+                    path, type_str);
+            ecs_os_free(type_str);
+            return 0;
+        }
+
+        if (var->value.ptr == NULL) {
+            flecs_script_eval_error(v, NULL, 
+                "variable '%s' is not initialized", path);
+            return 0;
+        }
+
+        ecs_entity_t result = *(ecs_entity_t*)var->value.ptr;
+        if (!result) {
+            flecs_script_eval_error(v, NULL, 
+                "variable '%s' contains invalid entity id (0)", path);
+            return 0;
+        }
+
+        return result;
+    }
+
+    if (from) {
+        return ecs_lookup_path_w_sep(v->world, from, path, NULL, NULL, false);
+    } else {
+        int32_t i, using_count = ecs_vec_count(&v->using);
+        if (using_count) {
+            ecs_entity_t *using = ecs_vec_first(&v->using);
+            for (i = using_count - 1; i >= 0; i --) {
+                ecs_entity_t e = ecs_lookup_path_w_sep(
+                    v->world, using[i], path, NULL, NULL, false);
+                if (e) {
+                    return e;
+                }
+            }
+        }
+
+        return ecs_lookup_path_w_sep(
+            v->world, v->parent, path, NULL, NULL, true);
+    }
+}
+
+ecs_entity_t flecs_script_create_entity(
+    ecs_script_eval_visitor_t *v,
+    const char *name)
+{
+    ecs_value_t *with = NULL;
+    if (flecs_script_with_count(v)) {
+        with = ecs_vec_first_t(&v->with, ecs_value_t);
+    }
+
+    if (name || with) {
+        ecs_entity_desc_t desc = {0};
+        desc.name = name;
+        desc.parent = v->parent;
+        desc.set = with;
+        return ecs_entity_init(v->world, &desc);
+    } else if (v->parent) {
+        return ecs_new_w_pair(v->world, EcsChildOf, v->parent);
+    } else {
+        return ecs_new(v->world);
+    }
+}
+
+static
+ecs_entity_t flecs_script_find_entity_action(
+    const ecs_world_t *world,
+    const char *path,
+    void *ctx)
+{
+    (void)world;
+    ecs_script_eval_visitor_t *v = ctx;
+    return flecs_script_find_entity(v, 0, path);
+}
+
+static
+int flecs_script_eval_id(
+    ecs_script_eval_visitor_t *v,
+    void *node,
+    ecs_script_id_t *id)
+{
+    ecs_entity_t second_from = 0;
+
+    if (!id->first) {
+        flecs_script_eval_error(v, node, 
+            "invalid component/tag identifier");
+        return -1;
+    }
+
+    if (v->assembly) {
+        /* Can't resolve variables while preprocessing assembly scope */
+        if (id->first[0] == '$') {
+            return 0;
+        }
+        if (id->second && id->second[0] == '$') {
+            return 0;
+        }
+    }
+
+    ecs_entity_t first = flecs_script_find_entity(v, 0, id->first);
+    if (!first) {
+        if (id->first[0] == '$') {
+            flecs_script_eval_error(v, node, 
+                "unresolved variable '%s'", id->first);
+            return -1;
+        }
+
+        /* Tags/components must be created in advance for assemblies */
+        if (v->assembly) {
+            flecs_script_eval_error(v, node, 
+                "'%s' must be defined outside of assembly scope", id->first);
+            return -1;
+        }
+
+        first = ecs_entity(v->world, {
+            .name = id->first,
+            .parent = v->module,
+        });
+        
+        if (!first) {
+            return -1;
+        }
+    } else if (id->second) {
+        second_from = flecs_get_oneof(v->world, first);
+    }
+
+    if (id->second) {
+        ecs_entity_t second = flecs_script_find_entity(
+            v, second_from, id->second);
+        if (!second) {
+            if (id->second[0] == '$') {
+                flecs_script_eval_error(v, node, 
+                    "unresolved variable '%s'", id->second);
+                return -1;
+            }
+
+            /* Tags/components must be created in advance for assemblies */
+            if (v->assembly) {
+                flecs_script_eval_error(v, node, 
+                    "'%s' must be defined outside of assembly scope", 
+                        id->second);
+                return -1;
+            }
+
+            if (second_from) {
+                char *parent_str = ecs_id_str(v->world, second_from);
+                flecs_script_eval_error(v, node, "target '%s' not found in "
+                    "parent '%s'", id->second, parent_str);
+                ecs_os_free(parent_str);
+                return -1;
+            }
+
+            second = ecs_entity(v->world, {
+                .name = id->second,
+                .parent = v->module,
+            });
+
+            if (!second) {
+                return -1;
+            }
+        }
+
+        id->eval = ecs_pair(first, second);
+    } else {
+        id->eval = first;
+    }
+
+    return 0;
+}
+
+int flecs_script_eval_expr(
+    ecs_script_eval_visitor_t *v,
+    const char *expr,
+    ecs_value_t *value)
+{
+    if (!value->type && expr[0] == '{') {
+        expr ++;
+    }
+
+    ecs_script_expr_run_desc_t desc = {
+        .name = v->base.script->name,
+        .expr = expr,
+        .lookup_action = flecs_script_find_entity_action,
+        .lookup_ctx = v,
+        .vars = v->vars
+    };
+
+    if (!ecs_script_expr_run(v->world, expr, value, &desc)) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_eval_scope(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_scope_t *node)
+{
+    ecs_script_node_t *scope_parent = ecs_script_parent_node(v);
+    ecs_entity_t prev_eval_parent = v->parent;
+    int32_t prev_using_count = ecs_vec_count(&v->using);
+
+    for (int i = v->base.depth - 2; i >= 0; i --) {
+        if (v->base.nodes[i]->kind == EcsAstScope) {
+            node->parent = (ecs_script_scope_t*)v->base.nodes[i];
+            break;
+        }
+    }
+
+    ecs_allocator_t *a = v->allocator;
+    v->vars = flecs_script_vars_push(v->vars, &v->stack, a);
+
+    if (scope_parent && (scope_parent->kind == EcsAstEntity)) {
+        v->parent = ecs_script_node(entity, scope_parent)->eval;
+    }
+
+    int result = ecs_script_visit_scope(v, node);
+
+    ecs_vec_set_count_t(a, &v->using, ecs_entity_t, prev_using_count);
+    v->vars = ecs_script_vars_pop(v->vars);
+    v->parent = prev_eval_parent;
+
+    return result;
+}
+
+static
+int flecs_script_apply_annot(
+    ecs_script_eval_visitor_t *v,
+    ecs_entity_t entity,
+    ecs_script_annot_t *node)
+{
+    if (!ecs_os_strcmp(node->name, "name")) {
+        ecs_doc_set_name(v->world, entity, node->expr);
+    } else
+    if (!ecs_os_strcmp(node->name, "brief")) {
+        ecs_doc_set_brief(v->world, entity, node->expr);
+    } else 
+    if (!ecs_os_strcmp(node->name, "detail")) {
+        ecs_doc_set_detail(v->world, entity, node->expr);
+    } else
+    if (!ecs_os_strcmp(node->name, "link")) {
+        ecs_doc_set_link(v->world, entity, node->expr);
+    } else
+    if (!ecs_os_strcmp(node->name, "color")) {
+        ecs_doc_set_color(v->world, entity, node->expr);
+    } else {
+        flecs_script_eval_error(v, node, "unknown annotation '%s'",
+            node->name);
+        return -1;
+    }
+    
+    return 0;
+}
+
+static
+int flecs_script_eval_entity(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_entity_t *node)
+{
+    /* Inherit kind from parent kind's DefaultChildComponent, if it existst */
+    if (node->kind) {
+        ecs_script_id_t id = {
+            .first = node->kind
+        };
+
+        if (flecs_script_eval_id(v, node, &id)) {
+            return -1;
+        }
+
+        node->eval_kind = id.eval;
+    } else {
+        ecs_script_scope_t *scope = ecs_script_current_scope(v);
+        if (scope && scope->default_component_eval) {
+            node->eval_kind = scope->default_component_eval;
+        }
+    }
+
+    if (v->assembly) {
+        return 0;
+    }
+
+    node->eval = flecs_script_create_entity(v, node->name);
+    node->parent = v->entity;
+
+    const EcsDefaultChildComponent *default_comp = NULL;
+    ecs_script_entity_t *old_entity = v->entity;
+    v->entity = node;
+
+    if (node->eval_kind) {
+        ecs_add_id(v->world, node->eval, node->eval_kind);
+
+        default_comp = 
+            ecs_get(v->world, node->eval_kind, EcsDefaultChildComponent);
+        if (default_comp) {
+            if (!default_comp->component) {
+                flecs_script_eval_error(v, node, "entity '%s' has kind '%s' "
+                    "with uninitialized DefaultChildComponent",
+                        node->name, node->kind);
+                return -1;
+            }
+
+            node->scope->default_component_eval = default_comp->component;
+        }
+    }
+
+    int32_t i, count = ecs_vec_count(&v->annot);
+    if (count) {
+        ecs_script_annot_t **annots = ecs_vec_first(&v->annot);
+        for (i = 0; i < count ; i ++) {
+            flecs_script_apply_annot(v, node->eval, annots[i]);
+        }
+        ecs_vec_clear(&v->annot);
+    }
+
+    if (ecs_script_visit_node(v, node->scope)) {
+        return -1;
+    }
+
+    if (node->eval_kind) {
+        if (!node->kind_w_expr) {
+            if (ecs_get_type_info(v->world, node->eval_kind) != NULL) {
+                ecs_modified_id(v->world, node->eval, node->eval_kind);
+            }
+        }
+    }
+
+    v->entity = old_entity;
+
+    return 0;
+}
+
+static
+ecs_entity_t flecs_script_get_src(
+    ecs_script_eval_visitor_t *v,
+    ecs_entity_t entity,
+    ecs_id_t id)
+{
+    if (entity == EcsVariable) { // Singleton ($)
+        if (ECS_IS_PAIR(id)) {
+            return ecs_pair_first(v->world, id);
+        } else {
+            return id & ECS_COMPONENT_MASK;
+        }
+    }
+    return entity;
+}
+
+static
+int flecs_script_eval_tag(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_tag_t *node)
+{
+    if (flecs_script_eval_id(v, node, &node->id)) {
+        return -1;
+    }
+
+    if (v->assembly) {
+        return 0;
+    }
+
+    if (!v->entity) {
+        if (node->id.second) {
+            flecs_script_eval_error(
+                v, node, "missing entity for pair (%s, %s)",
+                node->id.first, node->id.second);
+        } else {
+            flecs_script_eval_error(v, node, "missing entity for tag %s", 
+                node->id.first);
+        }
+        return -1;
+    }
+
+    ecs_entity_t src = flecs_script_get_src(
+        v, v->entity->eval, node->id.eval);
+    ecs_add_id(v->world, src, node->id.eval);
+
+    return 0;
+}
+
+static
+int flecs_script_eval_component(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_component_t *node)
+{
+    if (flecs_script_eval_id(v, node, &node->id)) {
+        return -1;
+    }
+
+    if (v->assembly) {
+        return 0;
+    }
+
+    if (!v->entity) {
+        if (node->id.second) {
+            flecs_script_eval_error(v, node, "missing entity for pair (%s, %s)",
+                node->id.first, node->id.second);
+        } else {
+            flecs_script_eval_error(v, node, "missing entity for component %s", 
+                node->id.first);
+        }
+        return -1;
+    }
+
+    ecs_entity_t src = flecs_script_get_src(v, v->entity->eval, node->id.eval);
+
+    if (node->expr && node->expr[0]) {
+        const ecs_type_info_t *ti = flecs_script_get_type_info(
+            v, node, node->id.eval);
+        if (!ti) {
+            return -1;
+        }
+
+        const EcsType *type = ecs_get(v->world, ti->component, EcsType);
+        if (type) {
+            bool is_collection = false;
+
+            switch(type->kind) {
+            case EcsPrimitiveType:
+            case EcsBitmaskType:
+            case EcsEnumType:
+            case EcsStructType:
+            case EcsOpaqueType:
+                break;
+            case EcsArrayType:
+            case EcsVectorType:
+                is_collection = true;
+                break;
+            }
+
+            if (node->is_collection != is_collection) {
+                char *id_str = ecs_id_str(v->world, ti->component);
+                if (node->is_collection && !is_collection) {
+                    flecs_script_eval_error(v, node, 
+                        "type %s is not a collection (use '%s: {...}')", 
+                            id_str, id_str);
+                } else {
+                    flecs_script_eval_error(v, node, 
+                        "type %s is a collection (use '%s: [...]')", 
+                            id_str, id_str);
+                }
+                ecs_os_free(id_str);
+                return -1;
+            }
+        }
+ 
+        ecs_value_t value = {
+            .ptr = ecs_ensure_id(v->world, src, node->id.eval),
+            .type = ti->component
+        };
+
+        if (ecs_os_strcmp(node->expr, "{}")) {
+            if (flecs_script_eval_expr(v, node->expr, &value)) {
+                return -1;
+            }
+        }
+
+        ecs_modified_id(v->world, src, node->id.eval);
+    } else {
+        ecs_add_id(v->world, src, node->id.eval);
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_eval_var_component(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_var_component_t *node)
+{
+    ecs_script_var_t *var = ecs_script_vars_lookup(v->vars, node->name);
+    if (!var) {
+        flecs_script_eval_error(v, node, 
+            "unresolved variable '%s'", node->name);
+        return -1;
+    }
+
+    ecs_id_t var_id = var->value.type;
+
+    if (var->value.ptr) {
+        const ecs_type_info_t *ti = flecs_script_get_type_info(
+            v, node, var_id);
+        if (!ti) {
+            return -1;
+        }
+
+        ecs_value_t value = {
+            .ptr = ecs_ensure_id(v->world, v->entity->eval, var_id),
+            .type = var_id
+        };
+
+        ecs_value_copy_w_type_info(v->world, ti, value.ptr, var->value.ptr);
+
+        ecs_modified_id(v->world, v->entity->eval, var_id);
+    } else {
+        ecs_add_id(v->world, v->entity->eval, var_id);
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_eval_default_component(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_default_component_t *node)
+{
+    if (!v->entity) {
+        flecs_script_eval_error(v, node, 
+            "missing entity for default component");
+        return -1;
+    }
+
+    ecs_script_scope_t *scope = ecs_script_current_scope(v);
+    ecs_assert(scope != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(scope->node.kind == EcsAstScope, ECS_INTERNAL_ERROR, NULL);
+    scope = scope->parent;
+
+    if (!scope) {
+        flecs_script_eval_error(v, node,
+            "entity '%s' is in root scope which cannot have a default type",
+                v->entity->name); 
+        return -1;
+    }
+
+    ecs_id_t default_type = scope->default_component_eval;
+    if (!default_type) {
+        flecs_script_eval_error(v, node,
+            "scope for entity '%s' does not have a default type",
+                v->entity->name);
+        return -1;
+    }
+
+    if (ecs_get_type_info(v->world, default_type) == NULL) {
+        char *id_str = ecs_id_str(v->world, default_type);
+        flecs_script_eval_error(v, node,
+            "cannot use tag '%s' as default type in assignment",
+                id_str);
+        ecs_os_free(id_str);
+        return -1;
+    }
+
+    ecs_value_t value = {
+        .ptr = ecs_ensure_id(v->world, v->entity->eval, default_type),
+        .type = default_type
+    };
+
+    if (flecs_script_eval_expr(v, node->expr, &value)) {
+        return -1;
+    }
+
+    ecs_modified_id(v->world, v->entity->eval, default_type);
+
+    return 0;
+}
+
+static
+int flecs_script_eval_with_var(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_var_node_t *node)
+{
+    ecs_script_var_t *var = ecs_script_vars_lookup(v->vars, node->name);
+    if (!var) {
+        flecs_script_eval_error(v, node, 
+            "unresolved variable '%s'", node->name);
+        return -1;
+    }
+
+    ecs_allocator_t *a = v->allocator;
+    ecs_value_t *value = flecs_script_with_append(a, v);
+    *value = var->value;
+
+    return 0;
+}
+
+static
+int flecs_script_eval_with_tag(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_tag_t *node)
+{
+    if (flecs_script_eval_id(v, node, &node->id)) {
+        return -1;
+    }
+
+    ecs_allocator_t *a = v->allocator;
+    ecs_value_t *value = flecs_script_with_append(a, v);
+    value->type = node->id.eval;
+    value->ptr = NULL;
+
+    return 0;
+}
+
+static
+int flecs_script_eval_with_component(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_component_t *node)
+{
+    if (flecs_script_eval_id(v, node, &node->id)) {
+        return -1;
+    }
+
+    ecs_allocator_t *a = v->allocator;
+    ecs_value_t *value = flecs_script_with_append(a, v);
+    value->type = node->id.eval;
+    value->ptr = NULL;
+
+    if (node->expr && node->expr[0]) {
+        const ecs_type_info_t *ti = flecs_script_get_type_info(
+            v, node, node->id.eval);
+        if (!ti) {
+            return -1;
+        }
+
+        value->ptr = flecs_stack_alloc(&v->stack, ti->size, ti->alignment);
+        value->type = ti->component; // Expression parser needs actual type
+
+        if (flecs_script_eval_expr(v, node->expr, value)) {
+            return -1;
+        }
+
+        value->type = node->id.eval; // Restore so we're adding actual id
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_eval_with(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_with_t *node)
+{
+    ecs_allocator_t *a = v->allocator;
+    int32_t prev_with_count = flecs_script_with_count(v);
+    ecs_stack_cursor_t *prev_stack_cursor = flecs_stack_get_cursor(&v->stack);
+    int result = 0;
+
+    if (ecs_script_visit_scope(v, node->expressions)) {
+        result = -1;
+        goto error;
+    }
+
+    ecs_value_t *value = flecs_script_with_last(v);
+    if (!value->ptr) {
+        if (ecs_is_valid(v->world, value->type)) {
+            node->scope->default_component_eval = value->type;
+        }
+    }
+
+    if (ecs_script_visit_scope(v, node->scope)) {
+        result = -1;
+        goto error;
+    }
+
+error:
+    flecs_script_with_set_count(a, v, prev_with_count);
+    flecs_stack_restore_cursor(&v->stack, prev_stack_cursor);
+    return result;
+}
+
+static
+int flecs_script_eval_using(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_using_t *node)
+{
+    ecs_allocator_t *a = v->allocator;
+    int32_t len = ecs_os_strlen(node->name);
+
+    if (len > 2 && !ecs_os_strcmp(&node->name[len - 2], ".*")) {
+        char *path = flecs_strdup(a, node->name);
+        path[len - 2] = '\0';
+
+        ecs_entity_t from = ecs_lookup(v->world, path);
+        if (!from) {
+            flecs_script_eval_error(v, node, 
+                "unresolved path '%s' in using statement", path);
+            flecs_strfree(a, path);
+            return -1;
+        }
+
+        /* Add each child of the scope to using stack */
+        ecs_iter_t it = ecs_children(v->world, from);
+        while (ecs_children_next(&it)) {
+            int32_t i, count = it.count;
+            for (i = 0; i < count; i ++) {
+                ecs_vec_append_t(
+                    a, &v->using, ecs_entity_t)[0] = it.entities[i];
+            }
+        }
+
+        flecs_strfree(a, path);
+    } else {
+        ecs_entity_t from = ecs_lookup_path_w_sep(
+            v->world, 0, node->name, NULL, NULL, false);
+        if (!from) {
+            from = ecs_entity(v->world, {
+                .name = node->name,
+                .root_sep = ""
+            });
+
+            if (!from) {
+                return -1;
+            }
+        }
+
+        ecs_vec_append_t(a, &v->using, ecs_entity_t)[0] = from;
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_eval_module(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_module_t *node)
+{
+    ecs_entity_t m = flecs_script_create_entity(v, node->name);
+    if (!m) {
+        return -1;
+    }
+
+    ecs_add_id(v->world, m, EcsModule);
+
+    v->module = m;
+    v->parent = m;
+
+    return 0;
+}
+
+static
+int flecs_script_eval_const(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_var_node_t *node)
+{
+    ecs_script_var_t *var = ecs_script_vars_declare(v->vars, node->name);
+    if (!var) {
+        flecs_script_eval_error(v, node, 
+            "variable '%s' redeclared", node->name);
+        return -1;
+    }
+
+    if (node->type) {
+        ecs_entity_t type = flecs_script_find_entity(v, 0, node->type);
+        if (!type) {
+            flecs_script_eval_error(v, node,
+                "unresolved type '%s' for const variable '%s'", 
+                    node->type, node->name);
+            return -1;
+        }
+
+        const ecs_type_info_t *ti = flecs_script_get_type_info(v, node, type);
+        if (!ti) {
+            return -1;
+        }
+
+        var->value.ptr = flecs_stack_calloc(&v->stack, ti->size, ti->alignment);
+        var->value.type = type;
+        var->type_info = ti;
+
+        if (flecs_script_eval_expr(v, node->expr, &var->value)) {
+            return -1;
+        }
+    } else {
+        /* We don't know the type yet, so we can't create a storage for it yet.
+         * Run the expression first to deduce the type. */
+        ecs_value_t value = {0};
+        if (flecs_script_eval_expr(v, node->expr, &value)) {
+            return -1;
+        }
+
+        ecs_assert(value.type != 0, ECS_INTERNAL_ERROR, NULL);
+        const ecs_type_info_t *ti = ecs_get_type_info(v->world, value.type);
+        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        var->value.ptr = flecs_stack_calloc(&v->stack, ti->size, ti->alignment);
+        var->value.type = value.type;
+        var->type_info = ti;
+
+        ecs_value_copy_w_type_info(v->world, ti, var->value.ptr, value.ptr);
+        ecs_value_fini_w_type_info(v->world, ti, value.ptr);
+        flecs_free(&v->world->allocator, ti->size, value.ptr);
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_eval_pair_scope(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_pair_scope_t *node)
+{
+    ecs_entity_t first = flecs_script_create_entity(v, node->id.first);
+    if (!first) {
+        return -1;
+    }
+
+    ecs_entity_t second = flecs_script_create_entity(v, node->id.second);
+    if (!second) {
+        return -1;
+    }
+
+    ecs_allocator_t *a = v->allocator;
+    ecs_entity_t prev_first = v->with_relationship;
+    ecs_entity_t prev_second = 0;
+    int32_t prev_with_relationship_sp = v->with_relationship_sp;
+
+    v->with_relationship = first;
+
+    if (prev_first != first) {
+        /* Append new element to with stack */
+        ecs_value_t *value = flecs_script_with_append(a, v);
+        value->type = ecs_pair(first, second);
+        value->ptr = NULL;
+        v->with_relationship_sp = flecs_script_with_count(v) - 1;
+    } else {
+        /* Get existing with element for current relationhip stack */
+        ecs_value_t *value = ecs_vec_get_t(
+            &v->with, ecs_value_t, v->with_relationship_sp);
+        ecs_assert(ECS_PAIR_FIRST(value->type) == (uint32_t)first, 
+            ECS_INTERNAL_ERROR, NULL);
+        prev_second = ECS_PAIR_SECOND(value->type);
+        value->type = ecs_pair(first, second);
+        value->ptr = NULL;
+    }
+
+    if (ecs_script_visit_scope(v, node->scope)) {
+        return -1;
+    }
+
+    if (prev_second) {
+        ecs_value_t *value = ecs_vec_get_t(
+            &v->with, ecs_value_t, v->with_relationship_sp);
+        value->type = ecs_pair(first, prev_second);
+    } else {
+        flecs_script_with_set_count(a, v, v->with_relationship_sp);
+    }
+
+    v->with_relationship = prev_first;
+    v->with_relationship_sp = prev_with_relationship_sp;
+
+    return 0;
+}
+
+static
+int flecs_script_eval_if(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_if_t *node)
+{
+    bool cond = false;
+    ecs_value_t condval = { .type = ecs_id(ecs_bool_t), .ptr = &cond };
+
+    if (flecs_script_eval_expr(v, node->expr, &condval)) {
+        return -1;
+    }
+
+    if (flecs_script_eval_scope(v, cond ? node->if_true : node->if_false)) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static
+int flecs_script_eval_annot(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_annot_t *node)
+{
+    if (!v->base.next) {
+        flecs_script_eval_error(v, node,
+            "annotation '%s' is not applied to anything", node->name);
+        return -1;
+    }
+
+    ecs_script_node_kind_t kind = v->base.next->kind;
+    if (kind != EcsAstEntity && kind != EcsAstAnnotation) {
+        flecs_script_eval_error(v, node,
+            "annotation must be applied to an entity");
+        return -1;
+    }
+
+    ecs_allocator_t *a = v->allocator;
+    ecs_vec_append_t(a, &v->annot, ecs_script_annot_t*)[0] = node;
+
+    return 0;
+}
+
+int flecs_script_eval_node(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node)
+{
+    switch(node->kind) {
+    case EcsAstScope:
+        return flecs_script_eval_scope(
+            v, (ecs_script_scope_t*)node);
+    case EcsAstTag:
+        return flecs_script_eval_tag(
+            v, (ecs_script_tag_t*)node);
+    case EcsAstComponent:
+        return flecs_script_eval_component(
+            v, (ecs_script_component_t*)node);
+    case EcsAstVarComponent:
+        return flecs_script_eval_var_component(
+            v, (ecs_script_var_component_t*)node);
+    case EcsAstDefaultComponent:
+        return flecs_script_eval_default_component(
+            v, (ecs_script_default_component_t*)node);
+    case EcsAstWithVar:
+        return flecs_script_eval_with_var(
+            v, (ecs_script_var_node_t*)node);
+    case EcsAstWithTag:
+        return flecs_script_eval_with_tag(
+            v, (ecs_script_tag_t*)node);
+    case EcsAstWithComponent:
+        return flecs_script_eval_with_component(
+            v, (ecs_script_component_t*)node);
+    case EcsAstWith:
+        return flecs_script_eval_with(
+            v, (ecs_script_with_t*)node);
+    case EcsAstUsing:
+        return flecs_script_eval_using(
+            v, (ecs_script_using_t*)node);
+    case EcsAstModule:
+        return flecs_script_eval_module(
+            v, (ecs_script_module_t*)node);
+    case EcsAstAnnotation:
+        return flecs_script_eval_annot(
+            v, (ecs_script_annot_t*)node);
+    case EcsAstAssembly:
+        return flecs_script_eval_assembly(
+            v, (ecs_script_assembly_node_t*)node);
+    case EcsAstProp:
+        return 0;
+    case EcsAstConst:
+        return flecs_script_eval_const(
+            v, (ecs_script_var_node_t*)node);
+    case EcsAstEntity:
+        return flecs_script_eval_entity(
+            v, (ecs_script_entity_t*)node);
+    case EcsAstPairScope:
+        return flecs_script_eval_pair_scope(
+            v, (ecs_script_pair_scope_t*)node);
+    case EcsAstIf:
+        return flecs_script_eval_if(
+            v, (ecs_script_if_t*)node);
+    }
+
+    ecs_abort(ECS_INTERNAL_ERROR, "corrupt AST node kind");
+}
+
+void flecs_script_eval_visit_init(
+    ecs_script_t *script,
+    ecs_script_eval_visitor_t *v)
+{
+    *v = (ecs_script_eval_visitor_t){
+        .base = {
+            .script = script,
+            .visit = (ecs_visit_action_t)flecs_script_eval_node
+        },  
+        .world = script->world,
+        .allocator = &script->allocator
+    };
+
+    flecs_stack_init(&v->stack);
+    ecs_vec_init_t(v->allocator, &v->using, ecs_entity_t, 0);
+    ecs_vec_init_t(v->allocator, &v->with, ecs_value_t, 0);
+    ecs_vec_init_t(v->allocator, &v->annot, ecs_script_annot_t*, 0);
+}
+
+void flecs_script_eval_visit_fini(
+    ecs_script_eval_visitor_t *v)
+{
+    ecs_vec_fini_t(v->allocator, &v->annot, ecs_script_annot_t*);
+    ecs_vec_fini_t(v->allocator, &v->with, ecs_value_t);
+    ecs_vec_fini_t(v->allocator, &v->using, ecs_entity_t);
+    flecs_stack_fini(&v->stack);
+}
+
+int ecs_script_eval(
+    ecs_script_t *script)
+{
+    ecs_script_eval_visitor_t v;
+    flecs_script_eval_visit_init(script, &v);
+    int result = ecs_script_visit(script, &v, flecs_script_eval_node);
+    flecs_script_eval_visit_fini(&v);
+    return result;
+}
+
+#endif
diff --git a/src/addons/script/visit_eval.h b/src/addons/script/visit_eval.h
new file mode 100644
index 000000000..0d8a99348
--- /dev/null
+++ b/src/addons/script/visit_eval.h
@@ -0,0 +1,76 @@
+/**
+ * @file addons/script/visit_eval.h
+ * @brief Script evaluation visitor.
+ */
+
+#ifndef FLECS_SCRIPT_VISIT_EVAL_H
+#define FLECS_SCRIPT_VISIT_EVAL_H
+
+typedef struct ecs_script_eval_visitor_t {
+    ecs_script_visit_t base;
+    ecs_world_t *world;
+    ecs_allocator_t *allocator;
+    ecs_script_assembly_t *assembly;
+    ecs_entity_t module;
+    ecs_entity_t parent;
+    ecs_script_entity_t *entity;
+    ecs_vec_t using;
+    ecs_vec_t with;
+    ecs_vec_t annot;
+    ecs_entity_t with_relationship;
+    int32_t with_relationship_sp;
+    ecs_script_vars_t *vars;
+    ecs_stack_t stack;
+} ecs_script_eval_visitor_t;
+
+void flecs_script_eval_error_(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node,
+    const char *fmt,
+    ...);
+
+#define flecs_script_eval_error(v, node, ...)\
+    flecs_script_eval_error_(v, (ecs_script_node_t*)node, __VA_ARGS__)
+
+ecs_entity_t flecs_script_find_entity(
+    ecs_script_eval_visitor_t *v,
+    ecs_entity_t from,
+    const char *path);
+
+ecs_entity_t flecs_script_create_entity(
+    ecs_script_eval_visitor_t *v,
+    const char *name);
+
+const ecs_type_info_t* flecs_script_get_type_info(
+    ecs_script_eval_visitor_t *v,
+    void *node,
+    ecs_id_t id);
+
+int flecs_script_eval_expr(
+    ecs_script_eval_visitor_t *v,
+    const char *expr,
+    ecs_value_t *value);
+
+int flecs_script_eval_assembly(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_assembly_node_t *assembly);
+
+ecs_script_assembly_t* flecs_script_assembly_init(
+    ecs_script_t *script);
+
+void flecs_script_assembly_fini(
+    ecs_script_t *script,
+    ecs_script_assembly_t *assembly);
+
+void flecs_script_eval_visit_init(
+    ecs_script_t *script,
+    ecs_script_eval_visitor_t *v);
+
+void flecs_script_eval_visit_fini(
+    ecs_script_eval_visitor_t *v);
+
+int flecs_script_eval_node(
+    ecs_script_eval_visitor_t *v,
+    ecs_script_node_t *node);
+
+#endif
diff --git a/src/addons/script/visit_free.c b/src/addons/script/visit_free.c
new file mode 100644
index 000000000..d45892dc8
--- /dev/null
+++ b/src/addons/script/visit_free.c
@@ -0,0 +1,149 @@
+/**
+ * @file addons/script/visit_free.c
+ * @brief Script free visitor (frees AST resources).
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+
+static
+void flecs_script_scope_free(
+    ecs_script_visit_t *v,
+    ecs_script_scope_t *node)
+{
+    ecs_script_visit_scope(v, node);
+    ecs_vec_fini_t(&v->script->allocator, &node->stmts, ecs_script_node_t*);
+    flecs_free_t(&v->script->allocator, ecs_script_scope_t, node);
+}
+
+static
+void flecs_script_with_free(
+    ecs_script_visit_t *v,
+    ecs_script_with_t *node)
+{
+    flecs_script_scope_free(v, node->expressions);
+    flecs_script_scope_free(v, node->scope);
+}
+
+static
+void flecs_script_assembly_free(
+    ecs_script_visit_t *v,
+    ecs_script_assembly_node_t *node)
+{
+    flecs_script_scope_free(v, node->scope);
+}
+
+static
+void flecs_script_entity_free(
+    ecs_script_visit_t *v,
+    ecs_script_entity_t *node)
+{
+    flecs_script_scope_free(v, node->scope);
+}
+
+static
+void flecs_script_pair_scope_free(
+    ecs_script_visit_t *v,
+    ecs_script_pair_scope_t *node)
+{
+    flecs_script_scope_free(v, node->scope);
+}
+
+static
+void flecs_script_if_free(
+    ecs_script_visit_t *v,
+    ecs_script_if_t *node)
+{
+    flecs_script_scope_free(v, node->if_true);
+    flecs_script_scope_free(v, node->if_false);
+}
+
+static
+int flecs_script_stmt_free(
+    ecs_script_visit_t *v,
+    ecs_script_node_t *node)
+{
+    ecs_allocator_t *a = &v->script->allocator;
+    switch(node->kind) {
+    case EcsAstScope:
+        flecs_script_scope_free(v, (ecs_script_scope_t*)node);
+        break;
+    case EcsAstWith:
+        flecs_script_with_free(v, (ecs_script_with_t*)node);
+        flecs_free_t(a, ecs_script_with_t, node);
+        break;
+    case EcsAstAssembly:
+        flecs_script_assembly_free(v, (ecs_script_assembly_node_t*)node);
+        flecs_free_t(a, ecs_script_assembly_node_t, node);
+        break;
+    case EcsAstEntity:
+        flecs_script_entity_free(v, (ecs_script_entity_t*)node);
+        flecs_free_t(a, ecs_script_entity_t, node);
+        break;
+    case EcsAstPairScope:
+        flecs_script_pair_scope_free(v, (ecs_script_pair_scope_t*)node);
+        flecs_free_t(a, ecs_script_pair_scope_t, node);
+        break;
+    case EcsAstIf:
+        flecs_script_if_free(v, (ecs_script_if_t*)node);
+        flecs_free_t(a, ecs_script_if_t, node);
+        break;
+    case EcsAstTag:
+        flecs_free_t(a, ecs_script_tag_t, node);
+        break;
+    case EcsAstComponent:
+        flecs_free_t(a, ecs_script_component_t, node);
+        break;
+    case EcsAstDefaultComponent:
+        flecs_free_t(a, ecs_script_default_component_t, node);
+        break;
+    case EcsAstVarComponent:
+        flecs_free_t(a, ecs_script_var_component_t, node);
+        break;
+    case EcsAstWithVar:
+        flecs_free_t(a, ecs_script_var_component_t, node);
+        break;
+    case EcsAstWithTag:
+        flecs_free_t(a, ecs_script_tag_t, node);
+        break;
+    case EcsAstWithComponent:
+        flecs_free_t(a, ecs_script_component_t, node);
+        break;
+    case EcsAstUsing:
+        flecs_free_t(a, ecs_script_using_t, node);
+        break;
+    case EcsAstModule:
+        flecs_free_t(a, ecs_script_module_t, node);
+        break;
+    case EcsAstAnnotation:
+        flecs_free_t(a, ecs_script_annot_t, node);
+        break;
+    case EcsAstProp:
+    case EcsAstConst:
+        flecs_free_t(a, ecs_script_var_node_t, node);
+        break;
+    }
+
+    return 0;
+}
+
+int flecs_script_visit_free(
+    ecs_script_t *script)
+{
+    ecs_check(script != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_script_visit_t v = {
+        .script = script
+    };
+
+    if (ecs_script_visit(script, &v, flecs_script_stmt_free)) {
+        goto error;
+    }
+
+    return 0;
+error:
+    return - 1;
+}
+
+#endif
diff --git a/src/addons/script/visit_to_str.c b/src/addons/script/visit_to_str.c
new file mode 100644
index 000000000..e13bac62f
--- /dev/null
+++ b/src/addons/script/visit_to_str.c
@@ -0,0 +1,410 @@
+/**
+ * @file addons/script/visit_to_str.c
+ * @brief Script AST to string visitor.
+ */
+
+#include "flecs.h"
+
+#ifdef FLECS_SCRIPT
+#include "script.h"
+
+typedef struct ecs_script_str_visitor_t {
+    ecs_script_visit_t base;
+    ecs_strbuf_t *buf;
+    int32_t depth;
+    bool newline;
+} ecs_script_str_visitor_t;
+
+static
+int flecs_script_scope_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_scope_t *scope);
+
+static
+void flecs_scriptbuf_append(
+    ecs_script_str_visitor_t *v,
+    const char *fmt,
+    ...)
+{
+    if (v->newline) {
+        ecs_strbuf_append(v->buf, "%*s", v->depth * 2, "");
+        v->newline = false;
+    }
+
+    va_list args;
+    va_start(args, fmt);
+    ecs_strbuf_vappend(v->buf, fmt, args);
+    va_end(args);
+
+    if (fmt[strlen(fmt) - 1] == '\n') {
+        v->newline = true;
+    }
+}
+
+static
+void flecs_scriptbuf_appendstr(
+    ecs_script_str_visitor_t *v,
+    const char *str)
+{
+    if (v->newline) {
+        ecs_strbuf_append(v->buf, "%*s", v->depth * 2, "");
+        v->newline = false;
+    }
+
+    ecs_strbuf_appendstr(v->buf, str);
+
+    if (str[strlen(str) - 1] == '\n') {
+        v->newline = true;
+    }
+}
+
+static
+void flecs_script_id_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_id_t *id)
+{
+    if (id->second) {
+        flecs_scriptbuf_append(v, "(%s, %s)", 
+            id->first, id->second);
+    } else {
+        flecs_scriptbuf_appendstr(v, id->first);
+    }
+}
+
+static
+void flecs_script_expr_to_str(
+    ecs_script_str_visitor_t *v,
+    const char *expr)
+{
+    if (expr) {
+        flecs_scriptbuf_append(v, "%s%s%s", ECS_GREEN, expr, ECS_NORMAL);
+    } else {
+        flecs_scriptbuf_appendstr(v, "{}");
+    }
+}
+
+static
+const char* flecs_script_node_to_str(
+    ecs_script_node_t *node)
+{
+    switch(node->kind) {
+    case EcsAstScope:              return "scope";
+    case EcsAstWithTag:
+    case EcsAstTag:                return "tag";
+    case EcsAstWithComponent:
+    case EcsAstComponent:          return "component";
+    case EcsAstWithVar:
+    case EcsAstVarComponent:       return "var";
+    case EcsAstDefaultComponent:   return "default_component";
+    case EcsAstWith:               return "with";
+    case EcsAstUsing:              return "using";
+    case EcsAstModule:             return "module";
+    case EcsAstAnnotation:         return "annot";
+    case EcsAstAssembly:           return "assembly";
+    case EcsAstProp:               return "prop";
+    case EcsAstConst:              return "const";
+    case EcsAstEntity:             return "entity";
+    case EcsAstPairScope:          return "pair_scope";
+    case EcsAstIf:                 return "if";
+    }
+    return "???";
+}
+
+static
+void flecs_scriptbuf_node(
+    ecs_script_str_visitor_t *v,
+    ecs_script_node_t *node)
+{
+    flecs_scriptbuf_append(v, "%s%s%s: ", 
+        ECS_BLUE, flecs_script_node_to_str(node), ECS_NORMAL);
+}
+
+static
+void flecs_script_tag_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_tag_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_script_id_to_str(v, &node->id);
+    flecs_scriptbuf_appendstr(v, "\n");
+}
+
+static
+void flecs_script_component_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_component_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_script_id_to_str(v, &node->id);
+    if (node->expr) {
+        flecs_scriptbuf_appendstr(v, ": ");
+        flecs_script_expr_to_str(v, node->expr);
+    }
+    flecs_scriptbuf_appendstr(v, "\n");
+}
+
+static
+void flecs_script_default_component_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_default_component_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    if (node->expr) {
+        flecs_script_expr_to_str(v, node->expr);
+    }
+    flecs_scriptbuf_appendstr(v, "\n");
+}
+
+static
+void flecs_script_with_var_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_var_component_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s ", node->name);
+    flecs_scriptbuf_appendstr(v, "\n");
+}
+
+static
+void flecs_script_with_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_with_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    
+    flecs_scriptbuf_appendstr(v, "{\n");
+    v->depth ++;
+    flecs_scriptbuf_append(v, "%sexpressions%s: ", ECS_CYAN, ECS_NORMAL);
+    flecs_script_scope_to_str(v, node->expressions);
+    flecs_scriptbuf_append(v, "%sscope%s: ", ECS_CYAN, ECS_NORMAL);
+    flecs_script_scope_to_str(v, node->scope);
+    v->depth --;
+    flecs_scriptbuf_appendstr(v, "}\n");
+}
+
+static
+void flecs_script_using_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_using_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s\n", node->name);
+}
+
+static
+void flecs_script_module_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_module_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s\n", node->name);
+}
+
+static
+void flecs_script_annot_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_annot_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s = %s\"%s\"%s", node->name, 
+        ECS_GREEN, node->expr, ECS_NORMAL);
+    flecs_scriptbuf_appendstr(v, "\n");
+}
+
+static
+void flecs_script_assembly_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_assembly_node_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_scriptbuf_append(v, "%s ", node->name);
+    flecs_script_scope_to_str(v, node->scope);
+}
+
+static
+void flecs_script_var_node_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_var_node_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    if (node->type) {
+        flecs_scriptbuf_append(v, "%s : %s = ", 
+            node->name,
+            node->type);
+    } else {
+        flecs_scriptbuf_append(v, "%s = ", 
+            node->name);
+    }
+    flecs_script_expr_to_str(v, node->expr);
+    flecs_scriptbuf_appendstr(v, "\n");
+}
+
+static
+void flecs_script_entity_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_entity_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    if (node->kind) {
+        flecs_scriptbuf_append(v, "%s ", node->kind);
+    }
+    if (node->name) {
+        flecs_scriptbuf_append(v, "%s ", node->name);
+    } else {
+        flecs_scriptbuf_appendstr(v, "<anon> ");
+    }
+
+    if (!flecs_scope_is_empty(node->scope)) {
+        flecs_script_scope_to_str(v, node->scope);
+    } else {
+        flecs_scriptbuf_appendstr(v, "\n");
+    }
+}
+
+static
+void flecs_script_pair_scope_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_pair_scope_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_script_id_to_str(v, &node->id);
+    flecs_scriptbuf_appendstr(v, " ");
+    flecs_script_scope_to_str(v, node->scope);
+}
+
+static
+void flecs_script_if_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_if_t *node)
+{
+    flecs_scriptbuf_node(v, &node->node);
+    flecs_script_expr_to_str(v, node->expr);
+
+    flecs_scriptbuf_appendstr(v, " {\n");
+    v->depth ++;
+    flecs_scriptbuf_append(v, "%strue%s: ", ECS_CYAN, ECS_NORMAL);
+    flecs_script_scope_to_str(v, node->if_true);
+    flecs_scriptbuf_append(v, "%sfalse%s: ", ECS_CYAN, ECS_NORMAL);
+    flecs_script_scope_to_str(v, node->if_false);
+    v->depth --;
+    flecs_scriptbuf_appendstr(v, "}\n");
+}
+
+static
+int flecs_script_scope_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_scope_t *scope)
+{
+    if (!ecs_vec_count(&scope->stmts)) {
+        flecs_scriptbuf_appendstr(v, "{}\n");
+        return 0;
+    }
+
+    flecs_scriptbuf_appendstr(v, "{\n");
+
+    v->depth ++;
+
+    if (ecs_script_visit_scope(v, scope)) {
+        return -1;
+    }
+
+    v->depth --;
+
+    flecs_scriptbuf_appendstr(v, "}\n");
+
+    return 0;
+}
+
+static
+int flecs_script_stmt_to_str(
+    ecs_script_str_visitor_t *v,
+    ecs_script_node_t *node)
+{
+    switch(node->kind) {
+    case EcsAstScope:
+        if (flecs_script_scope_to_str(v, (ecs_script_scope_t*)node)) {
+            return -1;
+        }
+        break;
+    case EcsAstTag:
+    case EcsAstWithTag:
+        flecs_script_tag_to_str(v, (ecs_script_tag_t*)node);
+        break;
+    case EcsAstComponent:
+    case EcsAstWithComponent:
+        flecs_script_component_to_str(v, (ecs_script_component_t*)node);
+        break;
+    case EcsAstVarComponent:
+    case EcsAstWithVar:
+        flecs_script_with_var_to_str(v, 
+            (ecs_script_var_component_t*)node);
+        break;
+    case EcsAstDefaultComponent:
+        flecs_script_default_component_to_str(v, 
+            (ecs_script_default_component_t*)node);
+        break;
+    case EcsAstWith:
+        flecs_script_with_to_str(v, (ecs_script_with_t*)node);
+        break;
+    case EcsAstUsing:
+        flecs_script_using_to_str(v, (ecs_script_using_t*)node);
+        break;
+    case EcsAstModule:
+        flecs_script_module_to_str(v, (ecs_script_module_t*)node);
+        break;
+    case EcsAstAnnotation:
+        flecs_script_annot_to_str(v, (ecs_script_annot_t*)node);
+        break;
+    case EcsAstAssembly:
+        flecs_script_assembly_to_str(v, (ecs_script_assembly_node_t*)node);
+        break;
+    case EcsAstConst:
+    case EcsAstProp:
+        flecs_script_var_node_to_str(v, (ecs_script_var_node_t*)node);
+        break;
+    case EcsAstEntity:
+        flecs_script_entity_to_str(v, (ecs_script_entity_t*)node);
+        break;
+    case EcsAstPairScope:
+        flecs_script_pair_scope_to_str(v, (ecs_script_pair_scope_t*)node);
+        break;
+    case EcsAstIf:
+        flecs_script_if_to_str(v, (ecs_script_if_t*)node);
+        break;
+    }
+
+    return 0;
+}
+
+int ecs_script_ast_to_buf(
+    ecs_script_t *script,
+    ecs_strbuf_t *buf)
+{
+    ecs_check(script != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(buf != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_script_str_visitor_t v = { .buf = buf };
+    if (ecs_script_visit(script, &v, flecs_script_stmt_to_str)) {
+        goto error;
+    }
+
+    return 0;
+error:
+    ecs_strbuf_reset(buf);
+    return - 1;
+}
+
+char* ecs_script_ast_to_str(
+    ecs_script_t *script)
+{
+    ecs_check(script != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    if (ecs_script_ast_to_buf(script, &buf)) {
+        goto error;
+    }
+
+    return ecs_strbuf_get(&buf);
+error:
+    return NULL;
+}
+
+#endif
diff --git a/src/addons/snapshot.c b/src/addons/snapshot.c
deleted file mode 100644
index 77ff2b156..000000000
--- a/src/addons/snapshot.c
+++ /dev/null
@@ -1,442 +0,0 @@
-/**
- * @file addons/snapshot.c
- * @brief Snapshot addon.
- */
-
-#include "flecs.h"
-
-#ifdef FLECS_SNAPSHOT
-
-#include "../private_api.h"
-
-/* World snapshot */
-struct ecs_snapshot_t {
-    ecs_world_t *world;
-    ecs_entity_index_t entity_index;
-    ecs_vec_t tables;
-    uint64_t last_id;
-};
-
-/** Small footprint data structure for storing data associated with a table. */
-typedef struct ecs_table_leaf_t {
-    ecs_table_t *table;
-    ecs_type_t type;
-    ecs_data_t *data;
-} ecs_table_leaf_t;
-
-static
-ecs_data_t* flecs_duplicate_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *main_data)
-{
-    int32_t count = ecs_table_count(table);
-    if (!count) {
-        return NULL;
-    }
-
-    ecs_data_t *result = ecs_os_calloc_t(ecs_data_t);
-    int32_t i, column_count = table->column_count;
-    result->columns = flecs_wdup_n(world, ecs_column_t, column_count,
-        main_data->columns);
-
-    /* Copy entities */
-    ecs_allocator_t *a = &world->allocator;
-    result->entities = ecs_vec_copy_shrink_t(a, &main_data->entities, ecs_entity_t);
-
-    /* Copy each column */
-    for (i = 0; i < column_count; i ++) {
-        ecs_column_t *column = &result->columns[i];
-        ecs_type_info_t *ti = column->ti;
-        ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL);
-        int32_t size = ti->size;
-        ecs_copy_t copy = ti->hooks.copy_ctor;
-        if (copy) {
-            void *src_ptr = ecs_vec_first(&column->data);
-
-            ecs_vec_t dst;
-            ecs_vec_init(a, &dst, size, count);
-            ecs_vec_set_count(a, &dst, size, count);
-            void *dst_ptr = ecs_vec_first(&dst);
-
-            copy(dst_ptr, src_ptr, count, ti);
-
-            column->data = dst;
-        } else {
-            column->data = ecs_vec_copy_shrink(a, &column->data, size);
-        }
-    }
-
-    return result;
-}
-
-static
-void snapshot_table(
-    const ecs_world_t *world,
-    ecs_snapshot_t *snapshot,
-    ecs_table_t *table)
-{
-    if (table->flags & EcsTableHasBuiltins) {
-        return;
-    }
-    
-    ecs_table_leaf_t *l = ecs_vec_get_t(
-        &snapshot->tables, ecs_table_leaf_t, (int32_t)table->id);
-    ecs_assert(l != NULL, ECS_INTERNAL_ERROR, NULL);
-    
-    l->table = table;
-    l->type = flecs_type_copy(
-        ECS_CONST_CAST(ecs_world_t*, world), &table->type);
-    l->data = flecs_duplicate_data(
-        ECS_CONST_CAST(ecs_world_t*, world), table, &table->data);
-}
-
-static
-ecs_snapshot_t* snapshot_create(
-    const ecs_world_t *world,
-    const ecs_entity_index_t *entity_index,
-    ecs_iter_t *iter,
-    ecs_iter_next_action_t next)
-{
-    ecs_snapshot_t *result = ecs_os_calloc_t(ecs_snapshot_t);
-    ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL);
-
-    ecs_run_aperiodic(ECS_CONST_CAST(ecs_world_t*, world), 0);
-
-    result->world = ECS_CONST_CAST(ecs_world_t*, world);
-
-    /* If no iterator is provided, the snapshot will be taken of the entire
-     * world, and we can simply copy the entity index as it will be restored
-     * entirely upon snapshote restore. */
-    if (!iter && entity_index) {
-        flecs_entities_copy(&result->entity_index, entity_index);
-    }
-
-    /* Create vector with as many elements as tables, so we can store the
-     * snapshot tables at their element ids. When restoring a snapshot, the code
-     * will run a diff between the tables in the world and the snapshot, to see
-     * which of the world tables still exist, no longer exist, or need to be
-     * deleted. */
-    uint64_t t, table_count = flecs_sparse_last_id(&world->store.tables) + 1;
-    ecs_vec_init_t(NULL, &result->tables, ecs_table_leaf_t, (int32_t)table_count);
-    ecs_vec_set_count_t(NULL, &result->tables, ecs_table_leaf_t, (int32_t)table_count);
-    ecs_table_leaf_t *arr = ecs_vec_first_t(&result->tables, ecs_table_leaf_t);
-
-    /* Array may have holes, so initialize with 0 */
-    ecs_os_memset_n(arr, 0, ecs_table_leaf_t, table_count);
-
-    /* Iterate tables in iterator */
-    if (iter) {
-        while (next(iter)) {
-            ecs_table_t *table = iter->table;
-            snapshot_table(world, result, table);
-        }
-    } else {
-        for (t = 1; t < table_count; t ++) {
-            ecs_table_t *table = flecs_sparse_get_t(
-                &world->store.tables, ecs_table_t, t);
-            snapshot_table(world, result, table);
-        }
-    }
-
-    return result;
-}
-
-/** Create a snapshot */
-ecs_snapshot_t* ecs_snapshot_take(
-    ecs_world_t *stage)
-{
-    const ecs_world_t *world = ecs_get_world(stage);
-
-    ecs_snapshot_t *result = snapshot_create(
-        world, ecs_eis(world), NULL, NULL);
-
-    result->last_id = flecs_entities_max_id(world);
-
-    return result;
-}
-
-/** Create a filtered snapshot */
-ecs_snapshot_t* ecs_snapshot_take_w_iter(
-    ecs_iter_t *iter)
-{
-    ecs_world_t *world = iter->world;
-    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_snapshot_t *result = snapshot_create(
-        world, ecs_eis(world), iter, iter ? iter->next : NULL);
-
-    result->last_id = flecs_entities_max_id(world);
-
-    return result;
-}
-
-/* Restoring an unfiltered snapshot restores the world to the exact state it was
- * when the snapshot was taken. */
-static
-void restore_unfiltered(
-    ecs_world_t *world,
-    ecs_snapshot_t *snapshot)
-{
-    flecs_entity_index_restore(ecs_eis(world), &snapshot->entity_index);
-    flecs_entity_index_fini(&snapshot->entity_index);
-    
-    flecs_entities_max_id(world) = snapshot->last_id;
-
-    ecs_table_leaf_t *leafs = ecs_vec_first_t(&snapshot->tables, ecs_table_leaf_t);
-    int32_t i, count = (int32_t)flecs_sparse_last_id(&world->store.tables);
-    int32_t snapshot_count = ecs_vec_count(&snapshot->tables);
-
-    for (i = 1; i <= count; i ++) {
-        ecs_table_t *world_table = flecs_sparse_get_t(
-            &world->store.tables, ecs_table_t, (uint32_t)i);
-
-        if (world_table && (world_table->flags & EcsTableHasBuiltins)) {
-            continue;
-        }
-
-        ecs_table_leaf_t *snapshot_table = NULL;
-        if (i < snapshot_count) {
-            snapshot_table = &leafs[i];
-            if (!snapshot_table->table) {
-                snapshot_table = NULL;
-            }
-        }
-
-        /* If the world table no longer exists but the snapshot table does,
-         * reinsert it */
-        if (!world_table && snapshot_table) {
-            ecs_table_t *table = flecs_table_find_or_create(world, 
-                &snapshot_table->type);
-            ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-
-            if (snapshot_table->data) {
-                flecs_table_replace_data(world, table, snapshot_table->data);
-            }
-
-        /* If the world table still exists, replace its data */
-        } else if (world_table && snapshot_table) {
-            ecs_assert(snapshot_table->table == world_table, 
-                ECS_INTERNAL_ERROR, NULL);
-
-            if (snapshot_table->data) {
-                flecs_table_replace_data(
-                    world, world_table, snapshot_table->data);
-            } else {
-                flecs_table_clear_data(
-                    world, world_table, &world_table->data);
-                flecs_table_init_data(world, world_table);
-            }
-        
-        /* If the snapshot table doesn't exist, this table was created after the
-         * snapshot was taken and needs to be deleted */
-        } else if (world_table && !snapshot_table) {
-            /* Deleting a table invokes OnRemove triggers & updates the entity
-             * index. That is not what we want, since entities may no longer be
-             * valid (if they don't exist in the snapshot) or may have been
-             * restored in a different table. Therefore first clear the data
-             * from the table (which doesn't invoke triggers), and then delete
-             * the table. */
-            flecs_table_clear_data(world, world_table, &world_table->data);
-            flecs_delete_table(world, world_table);
-        
-        /* If there is no world & snapshot table, nothing needs to be done */
-        } else { }
-
-        if (snapshot_table) {
-            ecs_os_free(snapshot_table->data);
-            flecs_type_free(world, &snapshot_table->type);
-        }
-    }
-
-    /* Now that all tables have been restored and world is in a consistent
-     * state, run OnSet systems */
-    int32_t world_count = flecs_sparse_count(&world->store.tables);
-    for (i = 0; i < world_count; i ++) {
-        ecs_table_t *table = flecs_sparse_get_dense_t(
-            &world->store.tables, ecs_table_t, i);
-        if (table->flags & EcsTableHasBuiltins) {
-            continue;
-        }
-
-        int32_t tcount = ecs_table_count(table);
-        if (tcount) {
-            int32_t j, storage_count = table->column_count;
-            for (j = 0; j < storage_count; j ++) {
-                ecs_type_t type = {
-                    .array = &table->data.columns[j].id,
-                    .count = 1
-                };
-                flecs_notify_on_set(world, table, 0, tcount, &type, true);
-            }
-        }
-    }
-}
-
-/* Restoring a filtered snapshots only restores the entities in the snapshot
- * to their previous state. */
-static
-void restore_filtered(
-    ecs_world_t *world,
-    ecs_snapshot_t *snapshot)
-{
-    ecs_table_leaf_t *leafs = ecs_vec_first_t(&snapshot->tables, ecs_table_leaf_t);
-    int32_t l = 0, snapshot_count = ecs_vec_count(&snapshot->tables);
-
-    for (l = 0; l < snapshot_count; l ++) {
-        ecs_table_leaf_t *snapshot_table = &leafs[l];
-        ecs_table_t *table = snapshot_table->table;
-
-        if (!table) {
-            continue;
-        }
-
-        ecs_data_t *data = snapshot_table->data;
-        if (!data) {
-            flecs_type_free(world, &snapshot_table->type);
-            continue;
-        }
-
-        /* Delete entity from storage first, so that when we restore it to the
-         * current table we can be sure that there won't be any duplicates */
-        int32_t i, entity_count = ecs_vec_count(&data->entities);
-        ecs_entity_t *entities = ecs_vec_first(
-            &snapshot_table->data->entities);
-        for (i = 0; i < entity_count; i ++) {
-            ecs_entity_t e = entities[i];
-            ecs_record_t *r = flecs_entities_try(world, e);
-            if (r && r->table) {
-                flecs_table_delete(world, r->table, 
-                    ECS_RECORD_TO_ROW(r->row), true);
-            } else {
-                /* Make sure that the entity has the same generation count */
-                flecs_entities_make_alive(world, e);
-            }
-        }
-
-        /* Merge data from snapshot table with world table */
-        int32_t old_count = ecs_table_count(snapshot_table->table);
-        int32_t new_count = flecs_table_data_count(snapshot_table->data);
-
-        flecs_table_merge(world, table, table, &table->data, snapshot_table->data);
-
-        /* Run OnSet systems for merged entities */
-        if (new_count) {
-            int32_t j, storage_count = table->column_count;
-            for (j = 0; j < storage_count; j ++) {
-                ecs_type_t type = {
-                    .array = &table->data.columns[j].id,
-                    .count = 1
-                };
-                flecs_notify_on_set(
-                    world, table, old_count, new_count, &type, true);
-            }
-        }
-
-        flecs_wfree_n(world, ecs_column_t, table->column_count,
-            snapshot_table->data->columns);
-        ecs_os_free(snapshot_table->data);
-        flecs_type_free(world, &snapshot_table->type);
-    }
-}
-
-/** Restore a snapshot */
-void ecs_snapshot_restore(
-    ecs_world_t *world,
-    ecs_snapshot_t *snapshot)
-{
-    ecs_run_aperiodic(world, 0);
-    
-    if (flecs_entity_index_count(&snapshot->entity_index) > 0) {
-        /* Unfiltered snapshots have a copy of the entity index which is
-         * copied back entirely when the snapshot is restored */
-        restore_unfiltered(world, snapshot);
-    } else {
-        restore_filtered(world, snapshot);
-    }
-
-    ecs_vec_fini_t(NULL, &snapshot->tables, ecs_table_leaf_t);
-
-    ecs_os_free(snapshot);
-}
-
-ecs_iter_t ecs_snapshot_iter(
-    ecs_snapshot_t *snapshot)
-{
-    ecs_snapshot_iter_t iter = {
-        .tables = snapshot->tables,
-        .index = 0
-    };
-
-    return (ecs_iter_t){
-        .world = snapshot->world,
-        .table_count = ecs_vec_count(&snapshot->tables),
-        .priv.iter.snapshot = iter,
-        .next = ecs_snapshot_next
-    };
-}
-
-bool ecs_snapshot_next(
-    ecs_iter_t *it)
-{
-    ecs_snapshot_iter_t *iter = &it->priv.iter.snapshot;
-    ecs_table_leaf_t *tables = ecs_vec_first_t(&iter->tables, ecs_table_leaf_t);
-    int32_t count = ecs_vec_count(&iter->tables);
-    int32_t i;
-
-    for (i = iter->index; i < count; i ++) {
-        ecs_table_t *table = tables[i].table;
-        if (!table) {
-            continue;
-        }
-
-        ecs_data_t *data = tables[i].data;
-
-        it->table = table;
-        it->count = ecs_table_count(table);
-        if (data) {
-            it->entities = ecs_vec_first(&data->entities);
-        } else {
-            it->entities = NULL;
-        }
-
-        ECS_BIT_SET(it->flags, EcsIterIsValid);
-        iter->index = i + 1;
-        
-        goto yield;
-    }
-
-    ECS_BIT_CLEAR(it->flags, EcsIterIsValid);
-    return false;
-
-yield:
-    ECS_BIT_CLEAR(it->flags, EcsIterIsValid);
-    return true;    
-}
-
-/** Cleanup snapshot */
-void ecs_snapshot_free(
-    ecs_snapshot_t *snapshot)
-{
-    flecs_entity_index_fini(&snapshot->entity_index);
-
-    ecs_table_leaf_t *tables = ecs_vec_first_t(&snapshot->tables, ecs_table_leaf_t);
-    int32_t i, count = ecs_vec_count(&snapshot->tables);
-    for (i = 0; i < count; i ++) {
-        ecs_table_leaf_t *snapshot_table = &tables[i];
-        ecs_table_t *table = snapshot_table->table;
-        if (table) {
-            ecs_data_t *data = snapshot_table->data;
-            if (data) {
-                flecs_table_clear_data(snapshot->world, table, data);
-                ecs_os_free(data);
-            }
-            flecs_type_free(snapshot->world, &snapshot_table->type);
-        }
-    }    
-
-    ecs_vec_fini_t(NULL, &snapshot->tables, ecs_table_leaf_t);
-    ecs_os_free(snapshot);
-}
-
-#endif
diff --git a/src/addons/stats.c b/src/addons/stats.c
index d01e45c09..c72481d5b 100644
--- a/src/addons/stats.c
+++ b/src/addons/stats.c
@@ -379,34 +379,23 @@ void ecs_query_stats_get(
     const ecs_query_t *query,
     ecs_query_stats_t *s)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL);
     (void)world;
 
-    int32_t t = s->t = t_next(s->t);
-
-    if (query->filter.flags & EcsFilterMatchThis) {
-        ECS_GAUGE_RECORD(&s->matched_entity_count, t, 
-            ecs_query_entity_count(query));
-        ECS_GAUGE_RECORD(&s->matched_table_count, t, 
-            ecs_query_table_count(query));
-        ECS_GAUGE_RECORD(&s->matched_empty_table_count, t, 
-            ecs_query_empty_table_count(query));
-    } else {
-        ECS_GAUGE_RECORD(&s->matched_entity_count, t, 0);
-        ECS_GAUGE_RECORD(&s->matched_table_count, t, 0);
-        ECS_GAUGE_RECORD(&s->matched_empty_table_count, t, 0);
-    }
-    
-    const ecs_filter_t *f = ecs_query_get_filter(query);
-    ECS_COUNTER_RECORD(&s->eval_count, t, f->eval_count);
+    int32_t t = s->t = t_next(s->t);    
+    ecs_query_count_t counts = ecs_query_count(query);
+    ECS_COUNTER_RECORD(&s->result_count, t, counts.results);
+    ECS_COUNTER_RECORD(&s->matched_table_count, t, counts.tables);
+    ECS_COUNTER_RECORD(&s->matched_empty_table_count, t, counts.empty_tables);
+    ECS_COUNTER_RECORD(&s->matched_entity_count, t, counts.entities);
+    ECS_COUNTER_RECORD(&s->eval_count, t, query->eval_count);
 
 error:
     return;
 }
 
-void ecs_query_stats_reduce(
+void ecs_query_cache_stats_reduce(
     ecs_query_stats_t *dst,
     const ecs_query_stats_t *src)
 {
@@ -414,7 +403,7 @@ void ecs_query_stats_reduce(
         ECS_METRIC_FIRST(src), (dst->t = t_next(dst->t)), src->t);
 }
 
-void ecs_query_stats_reduce_last(
+void ecs_query_cache_stats_reduce_last(
     ecs_query_stats_t *dst,
     const ecs_query_stats_t *src,
     int32_t count)
@@ -423,14 +412,14 @@ void ecs_query_stats_reduce_last(
         ECS_METRIC_FIRST(src), (dst->t = t_prev(dst->t)), src->t, count);
 }
 
-void ecs_query_stats_repeat_last(
+void ecs_query_cache_stats_repeat_last(
     ecs_query_stats_t *stats)
 {
     flecs_stats_repeat_last(ECS_METRIC_FIRST(stats), ECS_METRIC_LAST(stats),
         (stats->t = t_next(stats->t)));
 }
 
-void ecs_query_stats_copy_last(
+void ecs_query_cache_stats_copy_last(
     ecs_query_stats_t *dst,
     const ecs_query_stats_t *src)
 {
@@ -451,7 +440,7 @@ bool ecs_system_stats_get(
 
     world = ecs_get_world(world);
 
-    const ecs_system_t *ptr = ecs_poly_get(world, system, ecs_system_t);
+    const ecs_system_t *ptr = flecs_poly_get(world, system, ecs_system_t);
     if (!ptr) {
         return false;
     }
@@ -461,7 +450,7 @@ bool ecs_system_stats_get(
 
     ECS_COUNTER_RECORD(&s->time_spent, t, ptr->time_spent);
 
-    s->task = !(ptr->query->filter.flags & EcsFilterMatchThis);
+    s->task = !(ptr->query->flags & EcsQueryMatchThis);
 
     return true;
 error:
@@ -472,7 +461,7 @@ void ecs_system_stats_reduce(
     ecs_system_stats_t *dst,
     const ecs_system_stats_t *src)
 {
-    ecs_query_stats_reduce(&dst->query, &src->query);
+    ecs_query_cache_stats_reduce(&dst->query, &src->query);
     dst->task = src->task;
     flecs_stats_reduce(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
         ECS_METRIC_FIRST(src), dst->query.t, src->query.t);
@@ -483,7 +472,7 @@ void ecs_system_stats_reduce_last(
     const ecs_system_stats_t *src,
     int32_t count)
 {
-    ecs_query_stats_reduce_last(&dst->query, &src->query, count);
+    ecs_query_cache_stats_reduce_last(&dst->query, &src->query, count);
     dst->task = src->task;
     flecs_stats_reduce_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst), 
         ECS_METRIC_FIRST(src), dst->query.t, src->query.t, count);
@@ -492,7 +481,7 @@ void ecs_system_stats_reduce_last(
 void ecs_system_stats_repeat_last(
     ecs_system_stats_t *stats)
 {
-    ecs_query_stats_repeat_last(&stats->query);
+    ecs_query_cache_stats_repeat_last(&stats->query);
     flecs_stats_repeat_last(ECS_METRIC_FIRST(stats), ECS_METRIC_LAST(stats),
         (stats->query.t));
 }
@@ -501,7 +490,7 @@ void ecs_system_stats_copy_last(
     ecs_system_stats_t *dst,
     const ecs_system_stats_t *src)
 {
-    ecs_query_stats_copy_last(&dst->query, &src->query);
+    ecs_query_cache_stats_copy_last(&dst->query, &src->query);
     dst->task = src->task;
     flecs_stats_copy_last(ECS_METRIC_FIRST(dst), ECS_METRIC_LAST(dst),
         ECS_METRIC_FIRST(src), dst->query.t, t_next(src->query.t));
@@ -611,7 +600,7 @@ bool ecs_pipeline_stats_get(
 
                 el->system_count = cur->count;
                 el->multi_threaded = cur->multi_threaded;
-                el->no_readonly = cur->no_readonly;
+                el->immediate = cur->immediate;
             }
         }
     }
@@ -625,6 +614,7 @@ bool ecs_pipeline_stats_get(
             ecs_system_stats_t *stats = ecs_map_ensure_alloc_t(&s->system_stats, 
                 ecs_system_stats_t, it.entities[i]);
             stats->query.t = s->t;
+
             ecs_system_stats_get(world, it.entities[i], stats);
         }
     }
@@ -672,7 +662,7 @@ void ecs_pipeline_stats_reduce(
             ECS_METRIC_FIRST(src_el), dst->t, src->t);
         dst_el->system_count = src_el->system_count;
         dst_el->multi_threaded = src_el->multi_threaded;
-        dst_el->no_readonly = src_el->no_readonly;
+        dst_el->immediate = src_el->immediate;
     }
 
     ecs_map_init_if(&dst->system_stats, NULL);
@@ -704,7 +694,7 @@ void ecs_pipeline_stats_reduce_last(
             ECS_METRIC_FIRST(src_el), dst->t, src->t, count);
         dst_el->system_count = src_el->system_count;
         dst_el->multi_threaded = src_el->multi_threaded;
-        dst_el->no_readonly = src_el->no_readonly;
+        dst_el->immediate = src_el->immediate;
     }
 
     ecs_map_init_if(&dst->system_stats, NULL);
@@ -757,7 +747,7 @@ void ecs_pipeline_stats_copy_last(
             ECS_METRIC_FIRST(src_el), dst->t, t_next(src->t));
         dst_el->system_count = src_el->system_count;
         dst_el->multi_threaded = src_el->multi_threaded;
-        dst_el->no_readonly = src_el->no_readonly;
+        dst_el->immediate = src_el->immediate;
     }
 
     ecs_map_init_if(&dst->system_stats, NULL);
diff --git a/src/addons/system/system.c b/src/addons/system/system.c
index e4b04b3d2..83ca32c3f 100644
--- a/src/addons/system/system.c
+++ b/src/addons/system/system.c
@@ -21,7 +21,7 @@ ecs_mixins_t ecs_system_t_mixins = {
 
 /* -- Public API -- */
 
-ecs_entity_t ecs_run_intern(
+ecs_entity_t flecs_run_intern(
     ecs_world_t *world,
     ecs_stage_t *stage,
     ecs_entity_t system,
@@ -29,8 +29,6 @@ ecs_entity_t ecs_run_intern(
     int32_t stage_index,
     int32_t stage_count,    
     ecs_ftime_t delta_time,
-    int32_t offset,
-    int32_t limit,
     void *param) 
 {
     ecs_ftime_t time_elapsed = delta_time;
@@ -77,28 +75,22 @@ ecs_entity_t ecs_run_intern(
     if (stage) {
         thread_ctx = stage->thread_ctx;
     } else {
-        stage = &world->stages[0];
+        stage = world->stages[0];
     }
 
     /* Prepare the query iterator */
-    ecs_iter_t pit, wit, qit = ecs_query_iter(thread_ctx, system_data->query);
+    ecs_iter_t wit, qit = ecs_query_iter(thread_ctx, system_data->query);
     ecs_iter_t *it = &qit;
 
     qit.system = system;
     qit.delta_time = delta_time;
     qit.delta_system_time = time_elapsed;
-    qit.frame_offset = offset;
     qit.param = param;
     qit.ctx = system_data->ctx;
     qit.binding_ctx = system_data->binding_ctx;
 
     flecs_defer_begin(world, stage);
 
-    if (offset || limit) {
-        pit = ecs_page_iter(it, offset, limit);
-        it = &pit;
-    }
-
     if (stage_count > 1 && system_data->multi_threaded) {
         wit = ecs_worker_iter(it, stage_index, stage_count);
         it = &wit;
@@ -111,7 +103,7 @@ ecs_entity_t ecs_run_intern(
     ecs_run_action_t run = system_data->run;
     if (run) {
         run(it);
-    } else if (system_data->query->filter.term_count) {
+    } else if (system_data->query->term_count) {
         if (it == &qit) {
             while (ecs_query_next(&qit)) {
                 action(&qit);
@@ -139,21 +131,6 @@ ecs_entity_t ecs_run_intern(
 
 /* -- Public API -- */
 
-ecs_entity_t ecs_run_w_filter(
-    ecs_world_t *world,
-    ecs_entity_t system,
-    ecs_ftime_t delta_time,
-    int32_t offset,
-    int32_t limit,
-    void *param)
-{
-    ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_system_t *system_data = ecs_poly_get(world, system, ecs_system_t);
-    ecs_assert(system_data != NULL, ECS_INVALID_PARAMETER, NULL);
-    return ecs_run_intern(world, stage, system, system_data, 0, 0, delta_time, 
-        offset, limit, param);
-}
-
 ecs_entity_t ecs_run_worker(
     ecs_world_t *world,
     ecs_entity_t system,
@@ -163,12 +140,12 @@ ecs_entity_t ecs_run_worker(
     void *param)
 {
     ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_system_t *system_data = ecs_poly_get(world, system, ecs_system_t);
+    ecs_system_t *system_data = flecs_poly_get(world, system, ecs_system_t);
     ecs_assert(system_data != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    return ecs_run_intern(
+    return flecs_run_intern(
         world, stage, system, system_data, stage_index, stage_count, 
-        delta_time, 0, 0, param);
+        delta_time, param);
 }
 
 ecs_entity_t ecs_run(
@@ -177,14 +154,18 @@ ecs_entity_t ecs_run(
     ecs_ftime_t delta_time,
     void *param)
 {
-    return ecs_run_w_filter(world, system, delta_time, 0, 0, param);
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
+    ecs_system_t *system_data = flecs_poly_get(world, system, ecs_system_t);
+    ecs_assert(system_data != NULL, ECS_INVALID_PARAMETER, NULL);
+    return flecs_run_intern(
+        world, stage, system, system_data, 0, 0, delta_time, param);
 }
 
 ecs_query_t* ecs_system_get_query(
     const ecs_world_t *world,
     ecs_entity_t system)
 {
-    const ecs_system_t *s = ecs_poly_get(world, system, ecs_system_t);
+    const ecs_system_t *s = flecs_poly_get(world, system, ecs_system_t);
     if (s) {
         return s->query;
     } else {
@@ -196,7 +177,7 @@ void* ecs_system_get_ctx(
     const ecs_world_t *world,
     ecs_entity_t system)
 {
-    const ecs_system_t *s = ecs_poly_get(world, system, ecs_system_t);
+    const ecs_system_t *s = flecs_poly_get(world, system, ecs_system_t);
     if (s) {
         return s->ctx;
     } else {
@@ -208,7 +189,7 @@ void* ecs_system_get_binding_ctx(
     const ecs_world_t *world,
     ecs_entity_t system)
 {
-    const ecs_system_t *s = ecs_poly_get(world, system, ecs_system_t);
+    const ecs_system_t *s = flecs_poly_get(world, system, ecs_system_t);
     if (s) {
         return s->binding_ctx;
     } else {
@@ -227,7 +208,7 @@ void flecs_system_fini(ecs_system_t *sys) {
         sys->binding_ctx_free(sys->binding_ctx);
     }
 
-    ecs_poly_free(sys, ecs_system_t);
+    flecs_poly_free(sys, ecs_system_t);
 }
 
 static
@@ -265,28 +246,30 @@ ecs_entity_t ecs_system_init(
     ecs_world_t *world,
     const ecs_system_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_system_desc_t was not initialized to zero");
     ecs_assert(!(world->flags & EcsWorldReadonly), 
         ECS_INVALID_WHILE_READONLY, NULL);
 
     ecs_entity_t entity = desc->entity;
     if (!entity) {
-        entity = ecs_new(world, 0);
+        entity = ecs_entity(world, {0});
     }
-    EcsPoly *poly = ecs_poly_bind(world, entity, ecs_system_t);
+
+    EcsPoly *poly = flecs_poly_bind(world, entity, ecs_system_t);
     if (!poly->poly) {
-        ecs_system_t *system = ecs_poly_new(ecs_system_t);
+        ecs_system_t *system = flecs_poly_new(ecs_system_t);
         ecs_assert(system != NULL, ECS_INTERNAL_ERROR, NULL);
         
         poly->poly = system;
         system->world = world;
-        system->dtor = (ecs_poly_dtor_t)flecs_system_fini;
+        system->dtor = (flecs_poly_dtor_t)flecs_system_fini;
         system->entity = entity;
 
         ecs_query_desc_t query_desc = desc->query;
-        query_desc.filter.entity = entity;
+        query_desc.entity = entity;
 
         ecs_query_t *query = ecs_query_init(world, &query_desc);
         if (!query) {
@@ -295,10 +278,10 @@ ecs_entity_t ecs_system_init(
         }
 
         /* Prevent the system from moving while we're initializing */
-        flecs_defer_begin(world, &world->stages[0]);
+        flecs_defer_begin(world, world->stages[0]);
 
         system->query = query;
-        system->query_entity = query->filter.entity;
+        system->query_entity = query->entity;
 
         system->run = desc->run;
         system->action = desc->callback;
@@ -312,7 +295,7 @@ ecs_entity_t ecs_system_init(
         system->tick_source = desc->tick_source;
 
         system->multi_threaded = desc->multi_threaded;
-        system->no_readonly = desc->no_readonly;
+        system->immediate = desc->immediate;
 
         flecs_system_init_timer(world, entity, desc);
 
@@ -323,7 +306,7 @@ ecs_entity_t ecs_system_init(
 
         ecs_defer_end(world);            
     } else {
-        ecs_poly_assert(poly->poly, ecs_system_t);
+        flecs_poly_assert(poly->poly, ecs_system_t);
         ecs_system_t *system = (ecs_system_t*)poly->poly;
 
         if (desc->run) {
@@ -356,20 +339,20 @@ ecs_entity_t ecs_system_init(
         if (desc->binding_ctx_free) {
             system->binding_ctx_free = desc->binding_ctx_free;
         }
-        if (desc->query.filter.instanced) {
-            ECS_BIT_SET(system->query->filter.flags, EcsFilterIsInstanced);
+        if (desc->query.flags & EcsQueryIsInstanced) {
+            ECS_BIT_SET(system->query->flags, EcsQueryIsInstanced);
         }
         if (desc->multi_threaded) {
             system->multi_threaded = desc->multi_threaded;
         }
-        if (desc->no_readonly) {
-            system->no_readonly = desc->no_readonly;
+        if (desc->immediate) {
+            system->immediate = desc->immediate;
         }
 
         flecs_system_init_timer(world, entity, desc);
     }
 
-    ecs_poly_modified(world, entity, ecs_system_t);
+    flecs_poly_modified(world, entity, ecs_system_t);
 
     return entity;
 error:
diff --git a/src/addons/system/system.h b/src/addons/system/system.h
index 95d23c7ed..f08ec38de 100644
--- a/src/addons/system/system.h
+++ b/src/addons/system/system.h
@@ -27,7 +27,7 @@ typedef struct ecs_system_t {
     
     /* Schedule parameters */
     bool multi_threaded;
-    bool no_readonly;
+    bool immediate;
 
     ecs_ftime_t time_spent;         /* Time spent on running system */
     ecs_ftime_t time_passed;        /* Time passed since last invocation */
@@ -42,7 +42,7 @@ typedef struct ecs_system_t {
     /* Mixins */
     ecs_world_t *world;
     ecs_entity_t entity;
-    ecs_poly_dtor_t dtor;      
+    flecs_poly_dtor_t dtor;      
 } ecs_system_t;
 
 /* Invoked when system becomes active / inactive */
@@ -53,7 +53,7 @@ void ecs_system_activate(
     const ecs_system_t *system_data);
 
 /* Internal function to run a system */
-ecs_entity_t ecs_run_intern(
+ecs_entity_t flecs_run_intern(
     ecs_world_t *world,
     ecs_stage_t *stage,
     ecs_entity_t system,
@@ -61,8 +61,6 @@ ecs_entity_t ecs_run_intern(
     int32_t stage_current,
     int32_t stage_count,
     ecs_ftime_t delta_time,
-    int32_t offset,
-    int32_t limit,
     void *param);
 
 #endif
diff --git a/src/addons/timer.c b/src/addons/timer.c
index 36601773d..9b9632e18 100644
--- a/src/addons/timer.c
+++ b/src/addons/timer.c
@@ -19,8 +19,8 @@ void AddTickSource(ecs_iter_t *it) {
 
 static
 void ProgressTimers(ecs_iter_t *it) {
-    EcsTimer *timer = ecs_field(it, EcsTimer, 1);
-    EcsTickSource *tick_source = ecs_field(it, EcsTickSource, 2);
+    EcsTimer *timer = ecs_field(it, EcsTimer, 0);
+    EcsTickSource *tick_source = ecs_field(it, EcsTickSource, 1);
 
     ecs_assert(timer != NULL, ECS_INTERNAL_ERROR, NULL);
 
@@ -58,8 +58,8 @@ void ProgressTimers(ecs_iter_t *it) {
 
 static
 void ProgressRateFilters(ecs_iter_t *it) {
-    EcsRateFilter *filter = ecs_field(it, EcsRateFilter, 1);
-    EcsTickSource *tick_dst = ecs_field(it, EcsTickSource, 2);
+    EcsRateFilter *filter = ecs_field(it, EcsRateFilter, 0);
+    EcsTickSource *tick_dst = ecs_field(it, EcsTickSource, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -97,7 +97,7 @@ void ProgressRateFilters(ecs_iter_t *it) {
 
 static
 void ProgressTickSource(ecs_iter_t *it) {
-    EcsTickSource *tick_src = ecs_field(it, EcsTickSource, 1);
+    EcsTickSource *tick_src = ecs_field(it, EcsTickSource, 0);
 
     /* If tick source has no filters, tick unconditionally */
     int i;
@@ -114,13 +114,17 @@ ecs_entity_t ecs_set_timeout(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    timer = ecs_set(world, timer, EcsTimer, {
+    if (!timer) {
+        timer = ecs_entity(world, {0});
+    }
+
+    ecs_set(world, timer, EcsTimer, {
         .timeout = timeout,
         .single_shot = true,
         .active = true
     });
 
-    ecs_system_t *system_data = ecs_poly_get(world, timer, ecs_system_t);
+    ecs_system_t *system_data = flecs_poly_get(world, timer, ecs_system_t);
     if (system_data) {
         system_data->tick_source = timer;
     }
@@ -152,16 +156,16 @@ ecs_entity_t ecs_set_interval(
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
     if (!timer) {
-        timer = ecs_new(world, EcsTimer);
+        timer = ecs_new_w(world, EcsTimer);
     }
 
     EcsTimer *t = ecs_ensure(world, timer, EcsTimer);
-    ecs_check(t != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(t != NULL, ECS_INTERNAL_ERROR, NULL);
     t->timeout = interval;
     t->active = true;
     ecs_modified(world, timer, EcsTimer);
 
-    ecs_system_t *system_data = ecs_poly_get(world, timer, ecs_system_t);
+    ecs_system_t *system_data = flecs_poly_get(world, timer, ecs_system_t);
     if (system_data) {
         system_data->tick_source = timer;
     }
@@ -192,7 +196,7 @@ void ecs_start_timer(
     ecs_entity_t timer)
 {
     EcsTimer *ptr = ecs_ensure(world, timer, EcsTimer);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
     ptr->active = true;
     ptr->time = 0;
 error:
@@ -204,7 +208,7 @@ void ecs_stop_timer(
     ecs_entity_t timer)
 {
     EcsTimer *ptr = ecs_ensure(world, timer, EcsTimer);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
     ptr->active = false;
 error:
     return;
@@ -215,7 +219,7 @@ void ecs_reset_timer(
     ecs_entity_t timer)
 {
     EcsTimer *ptr = ecs_ensure(world, timer, EcsTimer);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ptr != NULL, ECS_INTERNAL_ERROR, NULL);
     ptr->time = 0;
 error:
     return;   
@@ -229,12 +233,16 @@ ecs_entity_t ecs_set_rate(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    filter = ecs_set(world, filter, EcsRateFilter, {
+    if (!filter) {
+        filter = ecs_entity(world, {0});
+    }
+
+    ecs_set(world, filter, EcsRateFilter, {
         .rate = rate,
         .src = source
     });
 
-    ecs_system_t *system_data = ecs_poly_get(world, filter, ecs_system_t);
+    ecs_system_t *system_data = flecs_poly_get(world, filter, ecs_system_t);
     if (system_data) {
         system_data->tick_source = filter;
     }  
@@ -252,7 +260,7 @@ void ecs_set_tick_source(
     ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL);
     ecs_check(tick_source != 0, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_system_t *system_data = ecs_poly_get(world, system, ecs_system_t);
+    ecs_system_t *system_data = flecs_poly_get(world, system, ecs_system_t);
     ecs_check(system_data != NULL, ECS_INVALID_PARAMETER, NULL);
 
     system_data->tick_source = tick_source;
@@ -262,7 +270,7 @@ void ecs_set_tick_source(
 
 static
 void RandomizeTimers(ecs_iter_t *it) {
-    EcsTimer *timer = ecs_field(it, EcsTimer, 1);
+    EcsTimer *timer = ecs_field(it, EcsTimer, 0);
     int32_t i;
     for (i = 0; i < it->count; i ++) {
         timer[i].time = 
@@ -275,7 +283,7 @@ void ecs_randomize_timers(
 {
     ecs_observer(world, {
         .entity = ecs_entity(world, { .name = "flecs.timer.RandomizeTimers" }),
-        .filter.terms = {{
+        .query.terms = {{
             .id = ecs_id(EcsTimer)
         }},
         .events = {EcsOnSet},
@@ -301,13 +309,13 @@ void FlecsTimerImport(
     flecs_bootstrap_component(world, EcsRateFilter);
 
     ecs_set_hooks(world, EcsTimer, {
-        .ctor = ecs_default_ctor
+        .ctor = flecs_default_ctor
     });
 
     /* Add EcsTickSource to timers and rate filters */
     ecs_system(world, {
-        .entity = ecs_entity(world, {.name = "AddTickSource", .add = { ecs_dependson(EcsPreFrame) }}),
-        .query.filter.terms = {
+        .entity = ecs_entity(world, {.name = "AddTickSource", .add = ecs_ids( ecs_dependson(EcsPreFrame) )}),
+        .query.terms = {
             { .id = ecs_id(EcsTimer), .oper = EcsOr, .inout = EcsIn },
             { .id = ecs_id(EcsRateFilter), .oper = EcsAnd, .inout = EcsIn },
             { .id = ecs_id(EcsTickSource), .oper = EcsNot, .inout = EcsOut}
@@ -317,8 +325,8 @@ void FlecsTimerImport(
 
     /* Timer handling */
     ecs_system(world, {
-        .entity = ecs_entity(world, {.name = "ProgressTimers", .add = { ecs_dependson(EcsPreFrame)}}),
-        .query.filter.terms = {
+        .entity = ecs_entity(world, {.name = "ProgressTimers", .add = ecs_ids( ecs_dependson(EcsPreFrame))}),
+        .query.terms = {
             { .id = ecs_id(EcsTimer) },
             { .id = ecs_id(EcsTickSource) }
         },
@@ -327,8 +335,8 @@ void FlecsTimerImport(
 
     /* Rate filter handling */
     ecs_system(world, {
-        .entity = ecs_entity(world, {.name = "ProgressRateFilters", .add = { ecs_dependson(EcsPreFrame)}}),
-        .query.filter.terms = {
+        .entity = ecs_entity(world, {.name = "ProgressRateFilters", .add = ecs_ids( ecs_dependson(EcsPreFrame))}),
+        .query.terms = {
             { .id = ecs_id(EcsRateFilter), .inout = EcsIn },
             { .id = ecs_id(EcsTickSource), .inout = EcsOut }
         },
@@ -337,8 +345,8 @@ void FlecsTimerImport(
 
     /* TickSource without a timer or rate filter just increases each frame */
     ecs_system(world, {
-        .entity = ecs_entity(world, { .name = "ProgressTickSource", .add = { ecs_dependson(EcsPreFrame)}}),
-        .query.filter.terms = {
+        .entity = ecs_entity(world, { .name = "ProgressTickSource", .add = ecs_ids( ecs_dependson(EcsPreFrame))}),
+        .query.terms = {
             { .id = ecs_id(EcsTickSource), .inout = EcsOut },
             { .id = ecs_id(EcsRateFilter), .oper = EcsNot },
             { .id = ecs_id(EcsTimer), .oper = EcsNot }
diff --git a/src/addons/units.c b/src/addons/units.c
index 36a820589..e7bdd1358 100644
--- a/src/addons/units.c
+++ b/src/addons/units.c
@@ -22,7 +22,7 @@ void FlecsUnitsImport(
 
     EcsUnitPrefixes = ecs_entity(world, {
         .name = "prefixes",
-        .add = { EcsModule }
+        .add = ecs_ids( EcsModule )
     });
 
     /* Initialize unit prefixes */
diff --git a/src/bootstrap.c b/src/bootstrap.c
index f8b205e22..0d5e3ec66 100644
--- a/src/bootstrap.c
+++ b/src/bootstrap.c
@@ -48,7 +48,7 @@ static ECS_MOVE(EcsIdentifier, dst, src, {
 
 static
 void ecs_on_set(EcsIdentifier)(ecs_iter_t *it) {
-    EcsIdentifier *ptr = ecs_field(it, EcsIdentifier, 1);
+    EcsIdentifier *ptr = ecs_field(it, EcsIdentifier, 0);
     
     ecs_world_t *world = it->real_world;
     ecs_entity_t evt = it->event;
@@ -130,7 +130,7 @@ static ECS_COPY(EcsPoly, dst, src, {
 
 static ECS_MOVE(EcsPoly, dst, src, {
     if (dst->poly && (dst->poly != src->poly)) {
-        ecs_poly_dtor_t *dtor = ecs_get_dtor(dst->poly);
+        flecs_poly_dtor_t *dtor = ecs_get_dtor(dst->poly);
         ecs_assert(dtor != NULL, ECS_INTERNAL_ERROR, NULL);
         dtor[0](dst->poly);
     }
@@ -141,7 +141,7 @@ static ECS_MOVE(EcsPoly, dst, src, {
 
 static ECS_DTOR(EcsPoly, ptr, {
     if (ptr->poly) {
-        ecs_poly_dtor_t *dtor = ecs_get_dtor(ptr->poly);
+        flecs_poly_dtor_t *dtor = ecs_get_dtor(ptr->poly);
         ecs_assert(dtor != NULL, ECS_INTERNAL_ERROR, NULL);
         dtor[0](ptr->poly);
     }
@@ -172,9 +172,7 @@ void flecs_assert_relation_unused(
     }
 
     bool in_use = ecs_id_in_use(world, ecs_pair(rel, EcsWildcard));
-    if (property != EcsUnion) {
-        in_use |= ecs_id_in_use(world, rel);
-    }
+    in_use |= ecs_id_in_use(world, rel);
     if (in_use) {
         char *r_str = ecs_get_fullpath(world, rel);
         char *p_str = ecs_get_fullpath(world, property);
@@ -283,7 +281,7 @@ void flecs_register_final(ecs_iter_t *it) {
 
 static
 void flecs_register_on_delete(ecs_iter_t *it) {
-    ecs_id_t id = ecs_field_id(it, 1);
+    ecs_id_t id = ecs_field_id(it, 0);
     flecs_register_id_flag_for_relation(it, EcsOnDelete, 
         ECS_ID_ON_DELETE_FLAG(ECS_PAIR_SECOND(id)),
         EcsIdOnDeleteMask,
@@ -292,7 +290,7 @@ void flecs_register_on_delete(ecs_iter_t *it) {
 
 static
 void flecs_register_on_delete_object(ecs_iter_t *it) {
-    ecs_id_t id = ecs_field_id(it, 1);
+    ecs_id_t id = ecs_field_id(it, 0);
     flecs_register_id_flag_for_relation(it, EcsOnDeleteTarget, 
         ECS_ID_ON_DELETE_TARGET_FLAG(ECS_PAIR_SECOND(id)),
         EcsIdOnDeleteObjectMask,
@@ -307,7 +305,7 @@ void flecs_register_traversable(ecs_iter_t *it) {
 
 static
 void flecs_register_tag(ecs_iter_t *it) {
-    flecs_register_id_flag_for_relation(it, EcsTag, EcsIdTag, ~EcsIdTag, 0);
+    flecs_register_id_flag_for_relation(it, EcsPairIsTag, EcsIdTag, ~EcsIdTag, 0);
 
     /* Ensure that all id records for tag have type info set to NULL */
     ecs_world_t *world = it->real_world;
@@ -321,7 +319,7 @@ void flecs_register_tag(ecs_iter_t *it) {
             ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
             do {
                 if (idr->type_info != NULL) {
-                    flecs_assert_relation_unused(world, e, EcsTag);
+                    flecs_assert_relation_unused(world, e, EcsPairIsTag);
                 }
                 idr->type_info = NULL;
             } while ((idr = idr->first.next));
@@ -348,26 +346,19 @@ void flecs_register_always_override(ecs_iter_t *it) {
 }
 
 static
-void flecs_register_with(ecs_iter_t *it) {
-    flecs_register_id_flag_for_relation(it, EcsWith, EcsIdWith, 0, 0);
-}
-
-static
-void flecs_register_union(ecs_iter_t *it) {
-    flecs_register_id_flag_for_relation(it, EcsUnion, EcsIdUnion, 0, 0);
+void flecs_register_can_toggle(ecs_iter_t *it) {
+    flecs_register_id_flag_for_relation(it, EcsCanToggle, 
+        EcsIdCanToggle, EcsIdCanToggle, 0);
 }
 
 static
-void flecs_register_slot_of(ecs_iter_t *it) {
-    int i, count = it->count;
-    for (i = 0; i < count; i ++) {
-        ecs_add_id(it->world, it->entities[i], EcsUnion);
-    }
+void flecs_register_with(ecs_iter_t *it) {
+    flecs_register_id_flag_for_relation(it, EcsWith, EcsIdWith, 0, 0);
 }
 
 static
 void flecs_on_symmetric_add_remove(ecs_iter_t *it) {
-    ecs_entity_t pair = ecs_field_id(it, 1);
+    ecs_entity_t pair = ecs_field_id(it, 0);
 
     if (!ECS_HAS_ID_FLAG(pair, PAIR)) {
         /* If relationship was not added as a pair, there's nothing to do */
@@ -406,8 +397,8 @@ void flecs_register_symmetric(ecs_iter_t *it) {
         /* Create observer that adds the reverse relationship when R(X, Y) is
          * added, or remove the reverse relationship when R(X, Y) is removed. */
         ecs_observer(world, {
-            .entity = ecs_entity(world, {.add = {ecs_childof(r)}}),
-            .filter.terms[0] = { .id = ecs_pair(r, EcsWildcard) },
+            .entity = ecs_entity(world, { .parent = r }),
+            .query.terms[0] = { .id = ecs_pair(r, EcsWildcard) },
             .callback = flecs_on_symmetric_add_remove,
             .events = {EcsOnAdd, EcsOnRemove}
         });
@@ -417,7 +408,7 @@ void flecs_register_symmetric(ecs_iter_t *it) {
 static
 void flecs_on_component(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    EcsComponent *c = ecs_field(it, EcsComponent, 1);
+    EcsComponent *c = ecs_field(it, EcsComponent, 0);
 
     int i, count = it->count;
     for (i = 0; i < count; i ++) {
@@ -461,40 +452,6 @@ void flecs_ensure_module_tag(ecs_iter_t *it) {
     }
 }
 
-static
-void flecs_observer_set_disable_bit(
-    ecs_world_t *world,
-    ecs_entity_t e,
-    ecs_flags32_t bit,
-    bool cond)
-{
-    const EcsPoly *poly = ecs_get_pair(world, e, EcsPoly, EcsObserver);
-    if (!poly || !poly->poly) {
-        return;
-    }
-
-    ecs_observer_t *o = poly->poly;
-    if (o->flags & EcsObserverIsMulti) {
-        /* If this is a multi-component observer, set flag on single-term
-         * observer children. */
-        ecs_iter_t child_it = ecs_children(world, e);
-        while (ecs_children_next(&child_it)) {
-            ecs_table_t *table = child_it.table;
-            if (ecs_table_has_id(world, table, EcsObserver)) {
-                int32_t i;
-                for (i = 0; i < child_it.count; i ++) {
-                    flecs_observer_set_disable_bit(
-                        world, child_it.entities[i], bit, cond);
-
-                }
-            }
-        }
-    } else {
-        ecs_poly_assert(o, ecs_observer_t);
-        ECS_BIT_COND(o->flags, bit, cond);
-    }
-}
-
 static
 void flecs_disable_observer(
     ecs_iter_t *it) 
@@ -551,18 +508,6 @@ void flecs_disable_module(ecs_iter_t *it) {
     }
 }
 
-/* -- Iterable mixins -- */
-
-static
-void flecs_on_event_iterable_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly, /* Observable */
-    ecs_iter_t *it,
-    ecs_term_t *filter)
-{
-    ecs_iter_poly(world, poly, it, filter);
-}
-
 /* -- Bootstrapping -- */
 
 #define flecs_bootstrap_builtin_t(world, table, name)\
@@ -721,17 +666,21 @@ void flecs_bootstrap(
     ecs_make_alive(world, EcsIsA);
     ecs_make_alive(world, EcsWildcard);
     ecs_make_alive(world, EcsAny);
-    ecs_make_alive(world, EcsTag);
+    ecs_make_alive(world, EcsPairIsTag);
+    ecs_make_alive(world, EcsCanToggle);
+    ecs_make_alive(world, EcsTrait);
+    ecs_make_alive(world, EcsRelationship);
+    ecs_make_alive(world, EcsTarget);
 
     /* Register type information for builtin components */
     flecs_type_info_init(world, EcsComponent, { 
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .on_set = flecs_on_component,
         .on_remove = flecs_on_component
     });
 
     flecs_type_info_init(world, EcsIdentifier, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(EcsIdentifier),
         .copy = ecs_copy(EcsIdentifier),
         .move = ecs_move(EcsIdentifier),
@@ -740,14 +689,15 @@ void flecs_bootstrap(
     });
 
     flecs_type_info_init(world, EcsPoly, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .copy = ecs_copy(EcsPoly),
         .move = ecs_move(EcsPoly),
         .dtor = ecs_dtor(EcsPoly)
     });
 
-    flecs_type_info_init(world, EcsIterable, { 0 });
-    flecs_type_info_init(world, EcsFlattenTarget, { 0 });
+    flecs_type_info_init(world, EcsDefaultChildComponent, { 
+        .ctor = flecs_default_ctor,
+    });
 
     /* Create and cache often used id records on world */
     flecs_init_id_records(world);
@@ -761,28 +711,19 @@ void flecs_bootstrap(
     /* Bootstrap builtin components */
     flecs_bootstrap_builtin_t(world, table, EcsIdentifier);
     flecs_bootstrap_builtin_t(world, table, EcsComponent);
-    flecs_bootstrap_builtin_t(world, table, EcsIterable);
     flecs_bootstrap_builtin_t(world, table, EcsPoly);
-    flecs_bootstrap_builtin_t(world, table, EcsFlattenTarget);
-
-    /* Patch up symbol of EcsIterable. The type is a typedef, which causes a
-     * symbol mismatch when registering the type with the C++ API. */
-    ecs_set_symbol(world, ecs_id(EcsIterable), "ecs_iterable_t");
+    flecs_bootstrap_builtin_t(world, table, EcsDefaultChildComponent);
 
     /* Initialize default entity id range */
     world->info.last_component_id = EcsFirstUserComponentId;
     flecs_entities_max_id(world) = EcsFirstUserEntityId;
     world->info.min_id = 0;
     world->info.max_id = 0;
-
-    /* Make EcsOnAdd, EcsOnSet events iterable to enable .yield_existing */
-    ecs_set(world, EcsOnAdd, EcsIterable, { .init = flecs_on_event_iterable_init });
-    ecs_set(world, EcsOnSet, EcsIterable, { .init = flecs_on_event_iterable_init });
-
-    /* Register observer for tag property before adding EcsTag */
+    
+    /* Register observer for tag property before adding EcsPairIsTag */
     ecs_observer(world, {
-        .entity = ecs_entity(world, {.add = { ecs_childof(EcsFlecsInternals)}}),
-        .filter.terms[0] = { .id = EcsTag, .src.flags = EcsSelf },
+        .entity = ecs_entity(world, { .parent = EcsFlecsInternals }),
+        .query.terms[0] = { .id = EcsPairIsTag, .src.id = EcsSelf },
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_tag,
         .yield_existing = true
@@ -803,6 +744,7 @@ void flecs_bootstrap(
     flecs_bootstrap_tag(world, EcsPrefab);
     flecs_bootstrap_tag(world, EcsSlotOf);
     flecs_bootstrap_tag(world, EcsDisabled);
+    flecs_bootstrap_tag(world, EcsNotQueryable);
     flecs_bootstrap_tag(world, EcsEmpty);
 
     /* Initialize builtin modules */
@@ -840,27 +782,23 @@ void flecs_bootstrap(
     flecs_bootstrap_trait(world, EcsFinal);
     flecs_bootstrap_trait(world, EcsDontInherit);
     flecs_bootstrap_trait(world, EcsAlwaysOverride);
-    flecs_bootstrap_trait(world, EcsTag);
-    flecs_bootstrap_trait(world, EcsUnion);
+    flecs_bootstrap_trait(world, EcsPairIsTag);
     flecs_bootstrap_trait(world, EcsExclusive);
     flecs_bootstrap_trait(world, EcsAcyclic);
     flecs_bootstrap_trait(world, EcsTraversable);
     flecs_bootstrap_trait(world, EcsWith);
     flecs_bootstrap_trait(world, EcsOneOf);
+    flecs_bootstrap_trait(world, EcsCanToggle);
     flecs_bootstrap_trait(world, EcsTrait);
     flecs_bootstrap_trait(world, EcsRelationship);
     flecs_bootstrap_trait(world, EcsTarget);
     flecs_bootstrap_trait(world, EcsOnDelete);
     flecs_bootstrap_trait(world, EcsOnDeleteTarget);
-    ecs_add_id(world, ecs_id(EcsFlattenTarget), EcsTrait);
 
     flecs_bootstrap_tag(world, EcsRemove);
     flecs_bootstrap_tag(world, EcsDelete);
     flecs_bootstrap_tag(world, EcsPanic);
 
-    flecs_bootstrap_tag(world, EcsFlatten);
-    flecs_bootstrap_tag(world, EcsDefaultChildComponent);
-
     /* Builtin predicates */
     flecs_bootstrap_tag(world, EcsPredEq);
     flecs_bootstrap_tag(world, EcsPredMatch);
@@ -884,22 +822,23 @@ void flecs_bootstrap(
     flecs_bootstrap_entity(world, EcsOnTableEmpty, "OnTableEmpty", EcsFlecsCore);
     flecs_bootstrap_entity(world, EcsOnTableFill, "OnTableFilled", EcsFlecsCore);
 
+    /* Unqueryable entities */
+    ecs_add_id(world, EcsThis, EcsNotQueryable);
+    ecs_add_id(world, EcsWildcard, EcsNotQueryable);
+    ecs_add_id(world, EcsAny, EcsNotQueryable);
+
     /* Tag relationships (relationships that should never have data) */
-    ecs_add_id(world, EcsIsA, EcsTag);
-    ecs_add_id(world, EcsChildOf, EcsTag);
-    ecs_add_id(world, EcsSlotOf, EcsTag);
-    ecs_add_id(world, EcsDependsOn, EcsTag);
-    ecs_add_id(world, EcsFlatten, EcsTag);
-    ecs_add_id(world, EcsDefaultChildComponent, EcsTag);
-    ecs_add_id(world, EcsUnion, EcsTag);
-    ecs_add_id(world, EcsFlag, EcsTag);
-    ecs_add_id(world, EcsWith, EcsTag);
+    ecs_add_id(world, EcsIsA, EcsPairIsTag);
+    ecs_add_id(world, EcsChildOf, EcsPairIsTag);
+    ecs_add_id(world, EcsSlotOf, EcsPairIsTag);
+    ecs_add_id(world, EcsDependsOn, EcsPairIsTag);
+    ecs_add_id(world, EcsFlag, EcsPairIsTag);
+    ecs_add_id(world, EcsWith, EcsPairIsTag);
 
     /* Exclusive properties */
     ecs_add_id(world, EcsChildOf, EcsExclusive);
     ecs_add_id(world, EcsOnDelete, EcsExclusive);
     ecs_add_id(world, EcsOnDeleteTarget, EcsExclusive);
-    ecs_add_id(world, EcsDefaultChildComponent, EcsExclusive);
 
     /* Relationships */
     ecs_add_id(world, EcsChildOf, EcsRelationship);
@@ -913,6 +852,7 @@ void flecs_bootstrap(
 
     /* Sync properties of ChildOf and Identifier with bootstrapped flags */
     ecs_add_pair(world, EcsChildOf, EcsOnDeleteTarget, EcsDelete);
+    ecs_add_id(world, EcsChildOf, EcsTrait);
     ecs_add_id(world, EcsChildOf, EcsAcyclic);
     ecs_add_id(world, EcsChildOf, EcsTraversable);
     ecs_add_id(world, EcsChildOf, EcsDontInherit);
@@ -921,112 +861,99 @@ void flecs_bootstrap(
     /* Create triggers in internals scope */
     ecs_set_scope(world, EcsFlecsInternals);
 
-    /* Term used to also match prefabs */
-    ecs_term_t match_prefab = { 
-        .id = EcsPrefab, 
-        .oper = EcsOptional,
-        .src.flags = EcsSelf 
-    };
-
     /* Register observers for components/relationship properties. Most observers
      * set flags on an id record when a property is added to a component, which
      * allows for quick property testing in various operations. */
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsFinal, .src.flags = EcsSelf }, match_prefab },
+        .query.terms = {{ .id = EcsFinal, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_register_final
     });
 
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(EcsOnDelete, EcsWildcard), .src.flags = EcsSelf },
-            match_prefab
+        .query.terms = {
+            { .id = ecs_pair(EcsOnDelete, EcsWildcard), .src.id = EcsSelf }
         },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_on_delete
     });
 
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(EcsOnDeleteTarget, EcsWildcard), .src.flags = EcsSelf },
-            match_prefab
+        .query.terms = {
+            { .id = ecs_pair(EcsOnDeleteTarget, EcsWildcard), .src.id = EcsSelf }
         },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_on_delete_object
     });
 
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = EcsTraversable, .src.flags = EcsSelf },
-            match_prefab
-        },
+        .query.terms = { { .id = EcsTraversable, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_traversable
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsExclusive, .src.flags = EcsSelf  }, match_prefab },
+        .query.terms = {{ .id = EcsExclusive, .src.id = EcsSelf  } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_register_exclusive
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsSymmetric, .src.flags = EcsSelf  }, match_prefab },
+        .query.terms = {{ .id = EcsSymmetric, .src.id = EcsSelf  } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_register_symmetric
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsDontInherit, .src.flags = EcsSelf }, match_prefab },
+        .query.terms = {{ .id = EcsDontInherit, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_register_dont_inherit
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAlwaysOverride, .src.flags = EcsSelf } },
+        .query.terms = {{ .id = EcsAlwaysOverride, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_register_always_override
     });
 
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(EcsWith, EcsWildcard), .src.flags = EcsSelf },
-            match_prefab
-        },
+        .query.terms = {{ .id = EcsCanToggle, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
-        .callback = flecs_register_with
+        .callback = flecs_register_can_toggle
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsUnion, .src.flags = EcsSelf }, match_prefab },
-        .events = {EcsOnAdd},
-        .callback = flecs_register_union
-    });
-
-    /* Entities used as slot are marked as exclusive to ensure a slot can always
-     * only point to a single entity. */
-    ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(EcsSlotOf, EcsWildcard), .src.flags = EcsSelf },
-            match_prefab
+        .query.terms = {
+            { .id = ecs_pair(EcsWith, EcsWildcard), .src.id = EcsSelf },
         },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
-        .callback = flecs_register_slot_of
+        .callback = flecs_register_with
     });
 
     /* Define observer to make sure that adding a module to a child entity also
      * adds it to the parent. */
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsModule, .src.flags = EcsSelf }, match_prefab},
+        .query.terms = {{ .id = EcsModule, .src.id = EcsSelf } },
+        .query.flags = EcsQueryMatchPrefab,
         .events = {EcsOnAdd},
         .callback = flecs_ensure_module_tag
     });
 
     /* Observer that tracks whether observers are disabled */
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = EcsObserver, .src.flags = EcsSelf|EcsFilter },
-            { .id = EcsDisabled, .src.flags = EcsSelf },
+        .query.terms = {
+            { .id = EcsObserver, .src.id = EcsSelf, .inout = EcsInOutFilter },
+            { .id = EcsDisabled, .src.id = EcsSelf },
         },
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_disable_observer
@@ -1034,9 +961,9 @@ void flecs_bootstrap(
 
     /* Observer that tracks whether modules are disabled */
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = EcsModule, .src.flags = EcsSelf|EcsFilter },
-            { .id = EcsDisabled, .src.flags = EcsSelf },
+        .query.terms = {
+            { .id = EcsModule, .src.id = EcsSelf, .inout = EcsInOutFilter },
+            { .id = EcsDisabled, .src.id = EcsSelf },
         },
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = flecs_disable_module
@@ -1068,7 +995,6 @@ void flecs_bootstrap(
     /* Exclusive properties */
     ecs_add_id(world, EcsSlotOf, EcsExclusive);
     ecs_add_id(world, EcsOneOf, EcsExclusive);
-    ecs_add_id(world, EcsFlatten, EcsExclusive);
 
     /* Private properties */
     ecs_add_id(world, ecs_id(EcsPoly), EcsPrivate);
diff --git a/src/datastructures/block_allocator.c b/src/datastructures/block_allocator.c
index 241cdbadf..77e7c7129 100644
--- a/src/datastructures/block_allocator.c
+++ b/src/datastructures/block_allocator.c
@@ -101,6 +101,7 @@ void flecs_ballocator_fini(
         ecs_os_linc(&ecs_block_allocator_free_count);
         block = next;
     }
+
     ba->block_head = NULL;
 }
 
@@ -158,8 +159,19 @@ void* flecs_bcalloc(
 
 void flecs_bfree(
     ecs_block_allocator_t *ba, 
-    void *memory) 
+    void *memory)
+{
+    flecs_bfree_w_dbg_info(ba, memory, NULL);
+}
+
+FLECS_API
+void flecs_bfree_w_dbg_info(
+    ecs_block_allocator_t *ba, 
+    void *memory,
+    const char *type_name)
 {
+    (void)type_name;
+
 #ifdef FLECS_USE_OS_ALLOC
     (void)ba;
     ecs_os_free(memory);
@@ -177,9 +189,15 @@ void flecs_bfree(
 #ifdef FLECS_SANITIZE
     memory = ECS_OFFSET(memory, -ECS_SIZEOF(int64_t));
     if (*(int64_t*)memory != ba->chunk_size) {
-        ecs_err("chunk %p returned to wrong allocator "
-            "(chunk = %ub, allocator = %ub)",
-                memory, *(int64_t*)memory, ba->chunk_size);
+        if (type_name) {
+            ecs_err("chunk %p returned to wrong allocator "
+                "(chunk = %ub, allocator = %ub, type = %s)",
+                    memory, *(int64_t*)memory, ba->chunk_size, type_name);
+        } else {
+            ecs_err("chunk %p returned to wrong allocator "
+                "(chunk = %ub, allocator = %ub)",
+                    memory, *(int64_t*)memory, ba->chunk_size);
+        }
         ecs_abort(ECS_INTERNAL_ERROR, NULL);
     }
 
diff --git a/src/datastructures/sparse.c b/src/datastructures/sparse.c
index 706174134..e80ff015d 100644
--- a/src/datastructures/sparse.c
+++ b/src/datastructures/sparse.c
@@ -366,6 +366,9 @@ void* flecs_sparse_ensure(
 
             /* First unused element is now last used element */
             sparse->count ++;
+
+            /* Set dense element to new generation */
+            ecs_vec_first_t(&sparse->dense, uint64_t)[dense] = index | gen;
         } else {
             /* Dense is already alive, nothing to be done */
         }
diff --git a/src/datastructures/stack_allocator.c b/src/datastructures/stack_allocator.c
index f5cba73cd..e41b16457 100644
--- a/src/datastructures/stack_allocator.c
+++ b/src/datastructures/stack_allocator.c
@@ -33,6 +33,8 @@ void* flecs_stack_alloc(
     ecs_size_t size,
     ecs_size_t align)
 {
+    ecs_assert(size > 0, ECS_INTERNAL_ERROR, NULL);
+
     ecs_stack_page_t *page = stack->tail_page;
     if (page == &stack->first && !page->data) {
         page->data = ecs_os_malloc(ECS_STACK_PAGE_SIZE);
@@ -91,6 +93,8 @@ void flecs_stack_free(
 ecs_stack_cursor_t* flecs_stack_get_cursor(
     ecs_stack_t *stack)
 {
+    ecs_assert(stack != NULL, ECS_INTERNAL_ERROR, NULL);
+
     ecs_stack_page_t *page = stack->tail_page;
     int16_t sp = stack->tail_page->sp;
     ecs_stack_cursor_t *result = flecs_stack_alloc_t(stack, ecs_stack_cursor_t);
@@ -108,6 +112,10 @@ ecs_stack_cursor_t* flecs_stack_get_cursor(
     return result;
 }
 
+#define FLECS_STACK_LEAK_MSG \
+    "a stack allocator leak is most likely due to an unterminated " \
+    "iteration: call ecs_iter_fini to fix"
+
 void flecs_stack_restore_cursor(
     ecs_stack_t *stack,
     ecs_stack_cursor_t *cursor)
@@ -116,9 +124,12 @@ void flecs_stack_restore_cursor(
         return;
     }
 
-    ecs_dbg_assert(stack == cursor->owner, ECS_INVALID_OPERATION, NULL);
-    ecs_dbg_assert(stack->cursor_count > 0, ECS_DOUBLE_FREE, NULL);
-    ecs_assert(cursor->is_free == false, ECS_DOUBLE_FREE, NULL);
+    ecs_dbg_assert(stack == cursor->owner, ECS_INVALID_OPERATION, 
+        "attempting to restore a cursor for the wrong stack");
+    ecs_dbg_assert(stack->cursor_count > 0, ECS_DOUBLE_FREE, 
+        "double free detected in stack allocator");
+    ecs_assert(cursor->is_free == false, ECS_DOUBLE_FREE,
+        "double free detected in stack allocator");
 
     cursor->is_free = true;
 
@@ -148,13 +159,14 @@ void flecs_stack_restore_cursor(
      * if the cursor count is non-zero, stack should not be empty */
     ecs_dbg_assert((stack->cursor_count == 0) == 
         (stack->tail_page == &stack->first && stack->tail_page->sp == 0), 
-            ECS_LEAK_DETECTED, NULL);
+            ECS_LEAK_DETECTED, FLECS_STACK_LEAK_MSG);
 }
 
 void flecs_stack_reset(
     ecs_stack_t *stack)
 {
-    ecs_dbg_assert(stack->cursor_count == 0, ECS_LEAK_DETECTED, NULL);
+    ecs_dbg_assert(stack->cursor_count == 0, ECS_LEAK_DETECTED, 
+        FLECS_STACK_LEAK_MSG);
     stack->tail_page = &stack->first;
     stack->first.sp = 0;
     stack->tail_cursor = NULL;
@@ -172,9 +184,12 @@ void flecs_stack_fini(
     ecs_stack_t *stack)
 {
     ecs_stack_page_t *next, *cur = &stack->first;
-    ecs_dbg_assert(stack->cursor_count == 0, ECS_LEAK_DETECTED, NULL);
-    ecs_assert(stack->tail_page == &stack->first, ECS_LEAK_DETECTED, NULL);
-    ecs_assert(stack->tail_page->sp == 0, ECS_LEAK_DETECTED, NULL);
+    ecs_dbg_assert(stack->cursor_count == 0, ECS_LEAK_DETECTED, 
+        FLECS_STACK_LEAK_MSG);
+    ecs_assert(stack->tail_page == &stack->first, ECS_LEAK_DETECTED, 
+        FLECS_STACK_LEAK_MSG);
+    ecs_assert(stack->tail_page->sp == 0, ECS_LEAK_DETECTED, 
+        FLECS_STACK_LEAK_MSG);
 
     do {
         next = cur->next;
diff --git a/src/datastructures/strbuf.c b/src/datastructures/strbuf.c
index ac9a54c04..02baff318 100644
--- a/src/datastructures/strbuf.c
+++ b/src/datastructures/strbuf.c
@@ -478,10 +478,11 @@ void ecs_strbuf_list_push(
     ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_assert(list_open != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_assert(separator != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(b->list_sp >= 0, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(b->list_sp >= 0, ECS_INVALID_OPERATION, 
+        "strbuf list is corrupt");
     b->list_sp ++;
     ecs_assert(b->list_sp < ECS_STRBUF_MAX_LIST_DEPTH, 
-        ECS_INVALID_OPERATION, NULL);
+        ECS_INVALID_OPERATION, "max depth for strbuf list stack exceeded");
 
     b->list_stack[b->list_sp].count = 0;
     b->list_stack[b->list_sp].separator = separator;
@@ -502,7 +503,8 @@ void ecs_strbuf_list_pop(
 {
     ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_assert(list_close != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(b->list_sp > 0, ECS_INVALID_OPERATION, NULL);
+    ecs_assert(b->list_sp > 0, ECS_INVALID_OPERATION, 
+        "pop called more often than push for strbuf list");
 
     b->list_sp --;
     
diff --git a/src/datastructures/switch_list.c b/src/datastructures/switch_list.c
deleted file mode 100644
index cdea1bf98..000000000
--- a/src/datastructures/switch_list.c
+++ /dev/null
@@ -1,383 +0,0 @@
-/**
- * @file datastructures/switch_list.c
- * @brief Interleaved linked list for storing mutually exclusive values.
- * 
- * Data structure that stores N interleaved linked lists in an array.
- * This allows for efficient storage of elements with mutually exclusive values.
- * Each linked list has a header element which points to the index in the array
- * that stores the first node of the list. Each list node points to the next
- * array element.
- *
- * The data structure allows for efficient storage and retrieval for values with
- * mutually exclusive values, such as enumeration values. The linked list allows
- * an application to obtain all elements for a given (enumeration) value without
- * having to search.
- *
- * While the list accepts 64 bit values, it only uses the lower 32bits of the
- * value for selecting the correct linked list.
- * 
- * The switch list is used to store union relationships.
- */
-
-#include "../private_api.h"
-
-#ifdef FLECS_SANITIZE
-static 
-void flecs_switch_verify_nodes(
-    ecs_switch_header_t *hdr,
-    ecs_switch_node_t *nodes)
-{
-    if (!hdr) {
-        return;
-    }
-
-    int32_t prev = -1, elem = hdr->element, count = 0;
-    while (elem != -1) {
-        ecs_assert(prev == nodes[elem].prev, ECS_INTERNAL_ERROR, NULL);
-        prev = elem;
-        elem = nodes[elem].next;
-        count ++;
-    }
-
-    ecs_assert(count == hdr->count, ECS_INTERNAL_ERROR, NULL);
-}
-#else
-#define flecs_switch_verify_nodes(hdr, nodes)
-#endif
-
-static
-ecs_switch_header_t* flecs_switch_get_header(
-    const ecs_switch_t *sw,
-    uint64_t value)
-{
-    if (value == 0) {
-        return NULL;
-    }
-    return (ecs_switch_header_t*)ecs_map_get(&sw->hdrs, value);
-}
-
-static
-ecs_switch_header_t *flecs_switch_ensure_header(
-    ecs_switch_t *sw,
-    uint64_t value)
-{
-    ecs_switch_header_t *node = flecs_switch_get_header(sw, value);
-    if (!node && (value != 0)) {
-        node = (ecs_switch_header_t*)ecs_map_ensure(&sw->hdrs, value);
-        node->count = 0;
-        node->element = -1;
-    }
-
-    return node;
-}
-
-static
-void flecs_switch_remove_node(
-    ecs_switch_header_t *hdr,
-    ecs_switch_node_t *nodes,
-    ecs_switch_node_t *node,
-    int32_t element)
-{
-    ecs_assert(&nodes[element] == node, ECS_INTERNAL_ERROR, NULL);
-
-    /* Update previous node/header */
-    if (hdr->element == element) {
-        ecs_assert(node->prev == -1, ECS_INVALID_PARAMETER, NULL);
-        /* If this is the first node, update the header */
-        hdr->element = node->next;
-    } else {
-        /* If this is not the first node, update the previous node to the 
-         * removed node's next ptr */
-        ecs_assert(node->prev != -1, ECS_INVALID_PARAMETER, NULL);
-        ecs_switch_node_t *prev_node = &nodes[node->prev];
-        prev_node->next = node->next;
-    }
-
-    /* Update next node */
-    int32_t next = node->next;
-    if (next != -1) {
-        ecs_assert(next >= 0, ECS_INVALID_PARAMETER, NULL);
-        /* If this is not the last node, update the next node to point to the
-         * removed node's prev ptr */
-        ecs_switch_node_t *next_node = &nodes[next];
-        next_node->prev = node->prev;
-    }
-
-    /* Decrease count of current header */
-    hdr->count --;
-    ecs_assert(hdr->count >= 0, ECS_INTERNAL_ERROR, NULL);
-}
-
-void flecs_switch_init(
-    ecs_switch_t *sw,
-    ecs_allocator_t *allocator,
-    int32_t elements)
-{
-    ecs_map_init(&sw->hdrs, allocator);
-    ecs_vec_init_t(allocator, &sw->nodes, ecs_switch_node_t, elements);
-    ecs_vec_init_t(allocator, &sw->values, uint64_t, elements);
-
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
-    uint64_t *values = ecs_vec_first(&sw->values);
-
-    int i;
-    for (i = 0; i < elements; i ++) {
-        nodes[i].prev = -1;
-        nodes[i].next = -1;
-        values[i] = 0;
-    }
-}
-
-void flecs_switch_clear(
-    ecs_switch_t *sw)
-{
-    ecs_map_clear(&sw->hdrs);
-    ecs_vec_fini_t(sw->hdrs.allocator, &sw->nodes, ecs_switch_node_t);
-    ecs_vec_fini_t(sw->hdrs.allocator, &sw->values, uint64_t);
-}
-
-void flecs_switch_fini(
-    ecs_switch_t *sw)
-{
-    ecs_map_fini(&sw->hdrs);
-    ecs_vec_fini_t(sw->hdrs.allocator, &sw->nodes, ecs_switch_node_t);
-    ecs_vec_fini_t(sw->hdrs.allocator, &sw->values, uint64_t);
-}
-
-void flecs_switch_add(
-    ecs_switch_t *sw)
-{
-    ecs_switch_node_t *node = ecs_vec_append_t(sw->hdrs.allocator, 
-        &sw->nodes, ecs_switch_node_t);
-    uint64_t *value = ecs_vec_append_t(sw->hdrs.allocator, 
-        &sw->values, uint64_t);
-    node->prev = -1;
-    node->next = -1;
-    *value = 0;
-}
-
-void flecs_switch_set_count(
-    ecs_switch_t *sw,
-    int32_t count)
-{
-    int32_t old_count = ecs_vec_count(&sw->nodes);
-    if (old_count == count) {
-        return;
-    }
-
-    ecs_vec_set_count_t(sw->hdrs.allocator, &sw->nodes, ecs_switch_node_t, count);
-    ecs_vec_set_count_t(sw->hdrs.allocator, &sw->values, uint64_t, count);
-
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
-    uint64_t *values = ecs_vec_first(&sw->values);
-
-    int32_t i;
-    for (i = old_count; i < count; i ++) {
-        ecs_switch_node_t *node = &nodes[i];
-        node->prev = -1;
-        node->next = -1;
-        values[i] = 0;
-    }
-}
-
-int32_t flecs_switch_count(
-    ecs_switch_t *sw)
-{
-    ecs_assert(ecs_vec_count(&sw->values) == ecs_vec_count(&sw->nodes),
-        ECS_INTERNAL_ERROR, NULL);
-    return ecs_vec_count(&sw->values);
-}
-
-void flecs_switch_ensure(
-    ecs_switch_t *sw,
-    int32_t count)
-{
-    int32_t old_count = ecs_vec_count(&sw->nodes);
-    if (old_count >= count) {
-        return;
-    }
-
-    flecs_switch_set_count(sw, count);
-}
-
-void flecs_switch_addn(
-    ecs_switch_t *sw,
-    int32_t count)
-{
-    int32_t old_count = ecs_vec_count(&sw->nodes);
-    flecs_switch_set_count(sw, old_count + count);
-}
-
-void flecs_switch_set(
-    ecs_switch_t *sw,
-    int32_t element,
-    uint64_t value)
-{
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->nodes), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->values), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element >= 0, ECS_INVALID_PARAMETER, NULL);
-
-    uint64_t *values = ecs_vec_first(&sw->values);
-    uint64_t cur_value = values[element];
-
-    /* If the node is already assigned to the value, nothing to be done */
-    if (cur_value == value) {
-        return;
-    }
-
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
-    ecs_switch_node_t *node = &nodes[element];
-
-    ecs_switch_header_t *dst_hdr = flecs_switch_ensure_header(sw, value);
-    ecs_switch_header_t *cur_hdr = flecs_switch_get_header(sw, cur_value);
-
-    flecs_switch_verify_nodes(cur_hdr, nodes);
-    flecs_switch_verify_nodes(dst_hdr, nodes);
-
-    /* If value is not 0, and dst_hdr is NULL, then this is not a valid value
-     * for this switch */
-    ecs_assert(dst_hdr != NULL || !value, ECS_INVALID_PARAMETER, NULL);
-
-    if (cur_hdr) {
-        flecs_switch_remove_node(cur_hdr, nodes, node, element);
-    }
-
-    /* Now update the node itself by adding it as the first node of dst */
-    node->prev = -1;
-    values[element] = value;
-
-    if (dst_hdr) {
-        node->next = dst_hdr->element;
-
-        /* Also update the dst header */
-        int32_t first = dst_hdr->element;
-        if (first != -1) {
-            ecs_assert(first >= 0, ECS_INTERNAL_ERROR, NULL);
-            ecs_switch_node_t *first_node = &nodes[first];
-            first_node->prev = element;
-        }
-
-        dst_hdr->element = element;
-        dst_hdr->count ++;        
-    }
-}
-
-void flecs_switch_remove(
-    ecs_switch_t *sw,
-    int32_t elem)
-{
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(elem < ecs_vec_count(&sw->nodes), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(elem >= 0, ECS_INVALID_PARAMETER, NULL);
-
-    uint64_t *values = ecs_vec_first(&sw->values);
-    uint64_t value = values[elem];
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
-    ecs_switch_node_t *node = &nodes[elem];
-
-    /* If node is currently assigned to a case, remove it from the list */
-    if (value != 0) {
-        ecs_switch_header_t *hdr = flecs_switch_get_header(sw, value);
-        ecs_assert(hdr != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        flecs_switch_verify_nodes(hdr, nodes);
-        flecs_switch_remove_node(hdr, nodes, node, elem);
-    }
-
-    int32_t last_elem = ecs_vec_count(&sw->nodes) - 1;
-    if (last_elem != elem) {
-        ecs_switch_node_t *last = ecs_vec_last_t(&sw->nodes, ecs_switch_node_t);
-        int32_t next = last->next, prev = last->prev;
-        if (next != -1) {
-            ecs_switch_node_t *n = &nodes[next];
-            n->prev = elem;
-        }
-
-        if (prev != -1) {
-            ecs_switch_node_t *n = &nodes[prev];
-            n->next = elem;
-        } else {
-            ecs_switch_header_t *hdr = flecs_switch_get_header(sw, values[last_elem]);
-            if (hdr && hdr->element != -1) {
-                ecs_assert(hdr->element == last_elem, 
-                    ECS_INTERNAL_ERROR, NULL);
-                hdr->element = elem;
-            }
-        }
-    }
-
-    /* Remove element from arrays */
-    ecs_vec_remove_t(&sw->nodes, ecs_switch_node_t, elem);
-    ecs_vec_remove_t(&sw->values, uint64_t, elem);
-}
-
-uint64_t flecs_switch_get(
-    const ecs_switch_t *sw,
-    int32_t element)
-{
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->nodes), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->values), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element >= 0, ECS_INVALID_PARAMETER, NULL);
-
-    uint64_t *values = ecs_vec_first(&sw->values);
-    return values[element];
-}
-
-ecs_vec_t* flecs_switch_values(
-    const ecs_switch_t *sw)
-{
-    return ECS_CONST_CAST(ecs_vec_t*, &sw->values);
-}
-
-int32_t flecs_switch_case_count(
-    const ecs_switch_t *sw,
-    uint64_t value)
-{
-    ecs_switch_header_t *hdr = flecs_switch_get_header(sw, value);
-    if (!hdr) {
-        return 0;
-    }
-
-    return hdr->count;
-}
-
-void flecs_switch_swap(
-    ecs_switch_t *sw,
-    int32_t elem_1,
-    int32_t elem_2)
-{
-    uint64_t v1 = flecs_switch_get(sw, elem_1);
-    uint64_t v2 = flecs_switch_get(sw, elem_2);
-
-    flecs_switch_set(sw, elem_2, v1);
-    flecs_switch_set(sw, elem_1, v2);
-}
-
-int32_t flecs_switch_first(
-    const ecs_switch_t *sw,
-    uint64_t value)
-{
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    
-    ecs_switch_header_t *hdr = flecs_switch_get_header(sw, value);
-    if (!hdr) {
-        return -1;
-    }
-
-    return hdr->element;
-}
-
-int32_t flecs_switch_next(
-    const ecs_switch_t *sw,
-    int32_t element)
-{
-    ecs_assert(sw != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element < ecs_vec_count(&sw->nodes), ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(element >= 0, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_switch_node_t *nodes = ecs_vec_first(&sw->nodes);
-
-    return nodes[element].next;
-}
diff --git a/src/datastructures/vec.c b/src/datastructures/vec.c
index a054aa2a2..a68e619a8 100644
--- a/src/datastructures/vec.c
+++ b/src/datastructures/vec.c
@@ -301,6 +301,7 @@ void* ecs_vec_get(
     int32_t index)
 {
     ecs_san_assert(size == v->elem_size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(index >= 0, ECS_OUT_OF_RANGE, NULL);
     ecs_assert(index < v->count, ECS_OUT_OF_RANGE, NULL);
     return ECS_ELEM(v->array, size, index);
 }
diff --git a/src/each.c b/src/each.c
new file mode 100644
index 000000000..703b8883c
--- /dev/null
+++ b/src/each.c
@@ -0,0 +1,87 @@
+/**
+ * @file query/each.c
+ * @brief Simple iterator for a single component id.
+ */
+
+#include "private_api.h"
+
+ecs_iter_t ecs_each_id(
+    const ecs_world_t *stage,
+    ecs_id_t id)
+{
+    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(id != 0, ECS_INVALID_PARAMETER, NULL);
+
+    const ecs_world_t *world = ecs_get_world(stage);
+
+    flecs_process_pending_tables(world);
+
+    ecs_iter_t it = {
+        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
+        .world = ECS_CONST_CAST(ecs_world_t*, stage),
+        .field_count = 1,
+        .next = ecs_each_next
+    };
+
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return it;
+    }
+
+    ecs_each_iter_t *each_iter = &it.priv_.iter.each;
+    each_iter->ids = id;
+    each_iter->sizes = 0;
+    if (idr->type_info) {
+        each_iter->sizes = idr->type_info->size;
+    }
+
+    each_iter->sources = 0;
+    flecs_table_cache_iter((ecs_table_cache_t*)idr, &each_iter->it);
+
+    return it;
+error:
+    return (ecs_iter_t){0};
+}
+
+bool ecs_each_next(
+    ecs_iter_t *it)
+{
+    ecs_each_iter_t *each_iter = &it->priv_.iter.each;
+    ecs_table_record_t *next = flecs_table_cache_next(
+        &each_iter->it, ecs_table_record_t);
+    it->flags |= EcsIterIsValid;
+    if (next) {
+        ecs_table_t *table = next->hdr.table;
+        it->table = table;
+        it->count = ecs_table_count(table);
+        it->entities = flecs_table_entities_array(table);
+        it->ids = &table->type.array[next->index];
+        it->columns = &each_iter->columns;
+        it->sources = &each_iter->sources;
+        it->sizes = &each_iter->sizes;
+        it->ptrs = &each_iter->ptrs;
+        it->set_fields = 1;
+        each_iter->columns = next->index;
+
+        if (next->column != -1) {
+            each_iter->ptrs = ecs_vec_first(
+                &it->table->data.columns[next->column].data);
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+ecs_iter_t ecs_children(
+    const ecs_world_t *stage,
+    ecs_entity_t parent)
+{
+    return ecs_each_id(stage, ecs_childof(parent));
+}
+
+bool ecs_children_next(
+    ecs_iter_t *it)
+{
+    return ecs_each_next(it);
+}
diff --git a/src/entity.c b/src/entity.c
index e1e96ba68..771cbe27c 100644
--- a/src/entity.c
+++ b/src/entity.c
@@ -13,6 +13,10 @@
 #include "private_api.h"
 #include <ctype.h>
 
+#ifdef FLECS_SCRIPT
+#include "addons/script/script.h"
+#endif
+
 static
 const ecs_entity_t* flecs_bulk_new(
     ecs_world_t *world,
@@ -58,7 +62,10 @@ flecs_component_ptr_t flecs_get_component_ptr(
 
     ecs_table_record_t *tr = flecs_table_record_get(world, table, id);
     if (!tr || (tr->column == -1)) {
-        ecs_check(tr == NULL, ECS_NOT_A_COMPONENT, NULL);
+        char *idstr = ecs_id_str(world, id);
+        ecs_check(tr == NULL, ECS_NOT_A_COMPONENT, 
+            "cannot get '%s' as a component", idstr);
+        ecs_os_free(idstr);
         return (flecs_component_ptr_t){0};
     }
 
@@ -84,8 +91,8 @@ void* flecs_get_base_component(
     ecs_id_record_t *table_index,
     int32_t recur_depth)
 {
-    /* Cycle detected in IsA relationship */
-    ecs_check(recur_depth < ECS_MAX_RECURSION, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(recur_depth < ECS_MAX_RECURSION, ECS_INVALID_PARAMETER,
+        "cycle detected in IsA relationship");
 
     /* Table (and thus entity) does not have component, look for base */
     if (!(table->flags & EcsTableHasIsA)) {
@@ -322,16 +329,6 @@ void flecs_instantiate_children(
         if ((id != ecs_pair(ecs_id(EcsIdentifier), EcsName)) &&
             ECS_PAIR_FIRST(id) != EcsChildOf) 
         {
-            if (id == EcsUnion) {
-                /* This should eventually be handled by the DontInherit property
-                 * but right now there is no way to selectively apply it to
-                 * EcsUnion itself: it would also apply to (Union, *) pairs,
-                 * which would make all union relationships uninheritable. 
-                 * 
-                 * The reason this is explicitly skipped is so that slot 
-                 * instances don't all end up with the Union property. */
-                continue;
-            }
             ecs_table_record_t *tr = &child_table->_->records[i];
             ecs_id_record_t *idr = (ecs_id_record_t*)tr->hdr.cache;
             if (idr->flags & EcsIdDontInherit) {
@@ -385,7 +382,6 @@ void flecs_instantiate_children(
     /* Instantiate the prefab child table for each new instance */
     ecs_entity_t *instances = ecs_vec_first(&table->data.entities);
     int32_t child_count = ecs_vec_count(&child_data->entities);
-    bool has_union = child_table->flags & EcsTableHasUnion;
 
     for (i = row; i < count + row; i ++) {
         ecs_entity_t instance = instances[i];
@@ -409,7 +405,8 @@ void flecs_instantiate_children(
 #ifdef FLECS_DEBUG
         for (j = 0; j < child_count; j ++) {
             ecs_entity_t child = children[j];        
-            ecs_check(child != instance, ECS_INVALID_PARAMETER, NULL);
+            ecs_check(child != instance, ECS_INVALID_PARAMETER, 
+                "cycle detected in IsA relationship");
         }
 #else
         /* Bit of boilerplate to ensure that we don't get warnings about the
@@ -422,25 +419,6 @@ void flecs_instantiate_children(
         const ecs_entity_t *i_children = flecs_bulk_new(world, i_table, NULL, 
             &diff.added, child_count, component_data, false, &child_row, &diff);
 
-        /* If children have union relationships, initialize */
-        if (has_union) {
-            ecs_table__t *meta = child_table->_;
-            ecs_assert(meta != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(i_table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-            int32_t u, u_count = meta->sw_count;
-            for (u = 0; u < u_count; u ++) {
-                ecs_switch_t *src_sw = &meta->sw_columns[i];
-                ecs_switch_t *dst_sw = &i_table->_->sw_columns[i];
-                ecs_vec_t *v_src_values = flecs_switch_values(src_sw);
-                ecs_vec_t *v_dst_values = flecs_switch_values(dst_sw);
-                uint64_t *src_values = ecs_vec_first(v_src_values);
-                uint64_t *dst_values = ecs_vec_first(v_dst_values);
-                for (j = 0; j < child_count; j ++) {
-                    dst_values[j] = src_values[j];
-                }
-            }
-        }
-
         /* If children are slots, add slot relationships to parent */
         if (slot_of) {
             for (j = 0; j < child_count; j ++) {
@@ -486,43 +464,6 @@ void flecs_instantiate(
     }
 }
 
-static
-void flecs_set_union(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    int32_t row,
-    int32_t count,    
-    const ecs_type_t *ids)
-{
-    ecs_id_t *array = ids->array;
-    int32_t i, id_count = ids->count;
-
-    for (i = 0; i < id_count; i ++) {
-        ecs_id_t id = array[i];
-
-        if (ECS_HAS_ID_FLAG(id, PAIR)) {
-            ecs_id_record_t *idr = flecs_id_record_get(world, 
-                ecs_pair(EcsUnion, ECS_PAIR_FIRST(id)));
-            if (!idr) {
-                continue;
-            }
-
-            ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-            ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-            int32_t column = tr->index - table->_->sw_offset;
-            ecs_switch_t *sw = &table->_->sw_columns[column];
-            ecs_entity_t union_case = 0;
-            union_case = ecs_pair_second(world, id);
-
-            int32_t r;
-            for (r = 0; r < count; r ++) {
-                flecs_switch_set(sw, row + r, union_case);
-            }
-        }
-    }
-}
-
 static
 void flecs_notify_on_add(
     ecs_world_t *world,
@@ -538,10 +479,6 @@ void flecs_notify_on_add(
     if (added->count) {
         ecs_flags32_t table_flags = table->flags;
 
-        if (table_flags & EcsTableHasUnion) {
-            flecs_set_union(world, table, row, count, added);
-        }
-
         if (table_flags & (EcsTableHasOnAdd|EcsTableHasIsA|EcsTableHasTraversable)) {
             flecs_emit(world, world, &(ecs_event_desc_t){
                 .event = EcsOnAdd,
@@ -877,7 +814,7 @@ const ecs_entity_t* flecs_bulk_new(
         r->row = ECS_ROW_TO_RECORD(row + i, 0);
     }
 
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
 
     flecs_notify_on_add(world, table, NULL, row, count, &diff->added, 
         (component_data == NULL) ? 0 : EcsEventNoOnSet);
@@ -930,7 +867,7 @@ const ecs_entity_t* flecs_bulk_new(
         }
     }
 
-    flecs_defer_end(world, &world->stages[0]);
+    flecs_defer_end(world, world->stages[0]);
 
     if (row_out) {
         *row_out = row;
@@ -1018,11 +955,12 @@ flecs_component_ptr_t flecs_ensure(
 {
     flecs_component_ptr_t dst = {0};
 
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(id != 0, ECS_INVALID_PARAMETER, NULL);
     ecs_check(r != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check((id & ECS_COMPONENT_MASK) == id || 
-        ECS_HAS_ID_FLAG(id, PAIR), ECS_INVALID_PARAMETER, NULL);
+        ECS_HAS_ID_FLAG(id, PAIR), ECS_INVALID_PARAMETER,
+            "invalid component id specified for ensure");
 
     if (r->table) {
         dst = flecs_get_component_ptr(
@@ -1036,8 +974,8 @@ flecs_component_ptr_t flecs_ensure(
     flecs_add_id_w_record(world, entity, r, id, true);
 
     /* Flush commands so the pointer we're fetching is stable */
-    flecs_defer_end(world, &world->stages[0]);
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_end(world, world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
 
     ecs_assert(r->table != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(r->table->column_count != 0, ECS_INTERNAL_ERROR, NULL);
@@ -1059,9 +997,9 @@ void flecs_invoke_hook(
     ecs_entity_t event,
     ecs_iter_action_t hook)
 {
-    int32_t defer = world->stages[0].defer;
+    int32_t defer = world->stages[0]->defer;
     if (defer < 0) {
-        world->stages[0].defer *= -1;
+        world->stages[0]->defer *= -1;
     }
 
     ecs_iter_t it = { .field_count = 1};
@@ -1084,7 +1022,7 @@ void flecs_invoke_hook(
     hook(&it);
     ecs_iter_fini(&it);
 
-    world->stages[0].defer = defer;
+    world->stages[0]->defer = defer;
 }
 
 void flecs_notify_on_set(
@@ -1176,7 +1114,8 @@ bool ecs_commit(
     const ecs_type_t *removed)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!ecs_is_deferred(world), ECS_INVALID_OPERATION, NULL);
+    ecs_check(!ecs_is_deferred(world), ECS_INVALID_OPERATION, 
+        "commit cannot be called on stage or while world is deferred");
 
     ecs_table_t *src_table = NULL;
     if (!record) {
@@ -1225,13 +1164,11 @@ ecs_id_t ecs_get_with(
     return 0;
 }
 
-ecs_entity_t ecs_new_id(
+ecs_entity_t ecs_new(
     ecs_world_t *world)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    const ecs_stage_t *stage = flecs_stage_from_readonly_world(world);
-
     /* It is possible that the world passed to this function is a stage, so
      * make sure we have the actual world. Cast away const since this is one of
      * the few functions that may modify the world while it is in readonly mode,
@@ -1240,14 +1177,15 @@ ecs_entity_t ecs_new_id(
         ECS_CONST_CAST(ecs_world_t*, ecs_get_world(world));
 
     ecs_entity_t entity;
-    if (stage->async || (unsafe_world->flags & EcsWorldMultiThreaded)) {
-        /* When using an async stage or world is in multithreading mode, make
-         * sure OS API has threading functions initialized */
-        ecs_assert(ecs_os_has_threading(), ECS_INVALID_OPERATION, NULL);
+    if (unsafe_world->flags & EcsWorldMultiThreaded) {
+        /* When world is in multithreading mode, make sure OS API has threading 
+         * functions initialized */
+        ecs_assert(ecs_os_has_threading(), ECS_INVALID_OPERATION, 
+            "thread safe id creation unavailable: threading API not available");
 
         /* Can't atomically increase number above max int */
         ecs_assert(flecs_entities_max_id(unsafe_world) < UINT_MAX, 
-            ECS_INVALID_OPERATION, NULL);
+            ECS_INVALID_OPERATION, "thread safe ids exhausted");
         entity = (ecs_entity_t)ecs_os_ainc(
             (int32_t*)&flecs_entities_max_id(unsafe_world));
     } else {
@@ -1291,7 +1229,7 @@ ecs_entity_t ecs_new_low_id(
 
     if (!id || id >= FLECS_HI_COMPONENT_ID) {
         /* If the low component ids are depleted, return a regular entity id */
-        id = ecs_new_id(unsafe_world);
+        id = ecs_new(unsafe_world);
     } else {
         flecs_entities_ensure(world, id);
     }
@@ -1308,60 +1246,27 @@ ecs_entity_t ecs_new_w_id(
     ecs_id_t id)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!id || ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);    
-    ecs_entity_t entity = ecs_new_id(world);
-
-    ecs_id_t ids[3];
-    ecs_type_t to_add = { .array = ids, .count = 0 };
-
-    if (id) {
-        ids[to_add.count ++] = id;
-    }
-
-    ecs_id_t with = stage->with;
-    if (with) {
-        ids[to_add.count ++] = with;
-    }
+    ecs_entity_t entity = ecs_new(world);
 
-    ecs_entity_t scope = stage->scope;
-    if (scope) {
-        if (!id || !ECS_HAS_RELATION(id, EcsChildOf)) {
-            ids[to_add.count ++] = ecs_pair(EcsChildOf, scope);
-        }
+    if (flecs_defer_add(stage, entity, id)) {
+        return entity;
     }
-    if (to_add.count) {
-        if (flecs_defer_add(stage, entity, to_add.array[0])) {
-            int i;
-            for (i = 1; i < to_add.count; i ++) {
-                flecs_defer_add(stage, entity, to_add.array[i]);
-            }
-            return entity;
-        }
 
-        int32_t i, count = to_add.count;
-        ecs_table_t *table = &world->store.root;
-        
-        ecs_table_diff_builder_t diff = ECS_TABLE_DIFF_INIT;
-        flecs_table_diff_builder_init(world, &diff);
-        for (i = 0; i < count; i ++) {
-            table = flecs_find_table_add(
-                world, table, to_add.array[i], &diff);
-        }
+    ecs_table_diff_builder_t diff_builder = ECS_TABLE_DIFF_INIT;
+    flecs_table_diff_builder_init(world, &diff_builder);
+    ecs_table_t *table = flecs_find_table_add(
+        world, &world->store.root, id, &diff_builder);
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
 
-        ecs_table_diff_t table_diff;
-        flecs_table_diff_build_noalloc(&diff, &table_diff);
-        ecs_record_t *r = flecs_entities_get(world, entity);
-        flecs_new_entity(world, entity, r, table, &table_diff, true, true);
-        flecs_table_diff_builder_fini(world, &diff);
-    } else {
-        if (flecs_defer_cmd(stage)) {
-            return entity;
-        }
+    ecs_table_diff_t diff;
+    flecs_table_diff_build_noalloc(&diff_builder, &diff);
+    ecs_record_t *r = flecs_entities_get(world, entity);
+    flecs_new_entity(world, entity, r, table, &diff, true, 0);
+    flecs_table_diff_builder_fini(world, &diff_builder);
 
-        flecs_entities_ensure(world, entity);
-    }
     flecs_defer_end(world, stage);
 
     return entity;
@@ -1376,82 +1281,83 @@ ecs_entity_t ecs_new_w_table(
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
     flecs_stage_from_world(&world);    
-    ecs_entity_t entity = ecs_new_id(world);
+    ecs_entity_t entity = ecs_new(world);
     ecs_record_t *r = flecs_entities_get(world, entity);
 
     ecs_table_diff_t table_diff = { .added = table->type };
-    flecs_new_entity(world, entity, r, table, &table_diff, true, true);
+    flecs_new_entity(world, entity, r, table, &table_diff, true, 0);
     return entity;
 error:
     return 0;
 }
 
-#ifdef FLECS_PARSER
+static
+void flecs_copy_id(
+    ecs_world_t *world,
+    ecs_record_t *r,
+    ecs_id_t id,
+    size_t size,
+    void *dst_ptr,
+    void *src_ptr,
+    const ecs_type_info_t *ti)
+{
+    ecs_check(dst_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(src_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    ecs_copy_t copy = ti->hooks.copy;
+    if (copy) {
+        copy(dst_ptr, src_ptr, 1, ti);
+    } else {
+        ecs_os_memcpy(dst_ptr, src_ptr, flecs_utosize(size));
+    }
+
+    flecs_table_mark_dirty(world, r->table, id);
+
+    ecs_table_t *table = r->table;
+    if (table->flags & EcsTableHasOnSet || ti->hooks.on_set) {
+        ecs_type_t ids = { .array = &id, .count = 1 };
+        flecs_notify_on_set(
+            world, table, ECS_RECORD_TO_ROW(r->row), 1, &ids, true);
+    }
+error:
+    return;
+}
 
 /* Traverse table graph by either adding or removing identifiers parsed from the
  * passed in expression. */
 static
-ecs_table_t *flecs_traverse_from_expr(
+int flecs_traverse_from_expr(
     ecs_world_t *world,
-    ecs_table_t *table,
     const char *name,
     const char *expr,
-    ecs_table_diff_builder_t *diff,
-    bool replace_and,
-    bool *error)
+    ecs_vec_t *ids)
 {
+#ifdef FLECS_SCRIPT
     const char *ptr = expr;
     if (ptr) {
-        ecs_term_t term = {0};
-        while (ptr[0] && (ptr = ecs_parse_term(
-            world, name, expr, ptr, &term, NULL, NULL, false)))
-        {
-            if (!ecs_term_is_initialized(&term)) {
+        ecs_id_t id = 0;
+        while (ptr[0] && (ptr = flecs_id_parse(world, name, ptr, &id))) {
+            if (!id) {
                 break;
             }
-
-            if (!(term.first.flags & (EcsSelf|EcsUp))) {
-                term.first.flags = EcsSelf;
-            }
-            if (!(term.second.flags & (EcsSelf|EcsUp))) {
-                term.second.flags = EcsSelf;
-            }
-            if (!(term.src.flags & (EcsSelf|EcsUp))) {
-                term.src.flags = EcsSelf;
-            }
-
-            if (ecs_term_finalize(world, &term)) {
-                ecs_term_fini(&term);
-                if (error) {
-                    *error = true;
-                }
-                return NULL;
-            }
-
-            if (!ecs_id_is_valid(world, term.id)) {
-                ecs_term_fini(&term);
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "invalid term for add expression");
-                return NULL;
-            }
-
-            if (term.oper == EcsAnd || !replace_and) {
-                /* Regular AND expression */
-                table = flecs_find_table_add(world, table, term.id, diff);
-            }
-
-            ecs_term_fini(&term);
+            ecs_vec_append_t(&world->allocator, ids, ecs_id_t)[0] = id;
         }
 
         if (!ptr) {
-            if (error) {
-                *error = true;
-            }
-            return NULL;
+            goto error;
         }
     }
-
-    return table;
+    return 0;
+#else
+    (void)world;
+    (void)name;
+    (void)expr;
+    (void)ids;
+    ecs_err("cannot parse component expression: script addon required");
+    goto error;
+#endif
+error:
+    return -1;
 }
 
 /* Add/remove components based on the parsed expression. This operation is 
@@ -1461,45 +1367,27 @@ void flecs_defer_from_expr(
     ecs_world_t *world,
     ecs_entity_t entity,
     const char *name,
-    const char *expr,
-    bool is_add,
-    bool replace_and)
+    const char *expr)
 {
+#ifdef FLECS_SCRIPT
     const char *ptr = expr;
     if (ptr) {
-        ecs_term_t term = {0};
-        while (ptr[0] && (ptr = ecs_parse_term(world, name, expr, ptr, &term, 
-            NULL, NULL, false))) 
-        {
-            if (!ecs_term_is_initialized(&term)) {
+        ecs_id_t id = 0;
+        while (ptr[0] && (ptr = flecs_id_parse(world, name, ptr, &id))) {
+            if (!id) {
                 break;
             }
-
-            if (ecs_term_finalize(world, &term)) {
-                return;
-            }
-
-            if (!ecs_id_is_valid(world, term.id)) {
-                ecs_term_fini(&term);
-                ecs_parser_error(name, expr, (ptr - expr), 
-                    "invalid term for add expression");
-                return;
-            }
-
-            if (term.oper == EcsAnd || !replace_and) {
-                /* Regular AND expression */
-                if (is_add) {
-                    ecs_add_id(world, entity, term.id);
-                } else {
-                    ecs_remove_id(world, entity, term.id);
-                }
-            }
-
-            ecs_term_fini(&term);
+            ecs_add_id(world, entity, id);
         }
     }
-}
+#else
+    (void)world;
+    (void)entity;
+    (void)name;
+    (void)expr;
+    ecs_err("cannot parse component expression: script addon required");
 #endif
+}
 
 /* If operation is not deferred, add components by finding the target
  * table and moving the entity towards it. */
@@ -1511,51 +1399,70 @@ int flecs_traverse_add(
     const ecs_entity_desc_t *desc,
     ecs_entity_t scope,
     ecs_id_t with,
-    bool flecs_new_entity,
+    bool new_entity,
     bool name_assigned)
 {
     const char *sep = desc->sep;
     const char *root_sep = desc->root_sep;
     ecs_table_diff_builder_t diff = ECS_TABLE_DIFF_INIT;
     flecs_table_diff_builder_init(world, &diff);
+    ecs_vec_t ids;
+
+    /* Add components from the 'add_expr' expression. Look up before naming 
+     * entity, so that expression can't resolve to self. */
+    ecs_vec_init_t(&world->allocator, &ids, ecs_id_t, 0);
+    if (desc->add_expr && ecs_os_strcmp(desc->add_expr, "0")) {
+        if (flecs_traverse_from_expr(world, name, desc->add_expr, &ids)) {
+            goto error;
+        }
+    }
+
+    /* If a name is provided but not yet assigned, add the Name component */
+    if (name && !name_assigned) {
+        ecs_add_path_w_sep(world, result, scope, name, sep, root_sep);
+    } else if (new_entity && scope) {
+        ecs_add_pair(world, result, EcsChildOf, scope);
+    }
 
     /* Find existing table */
     ecs_table_t *src_table = NULL, *table = NULL;
     ecs_record_t *r = flecs_entities_get(world, result);
     table = r->table;
 
-    /* If a name is provided but not yet assigned, add the Name component */
-    if (name && !name_assigned) {
-        table = flecs_find_table_add(world, table, 
-            ecs_pair(ecs_id(EcsIdentifier), EcsName), &diff);
-    }
+    /* Add components from the 'add' array */
+    if (desc->add) {
+        int32_t i = 0;
+        ecs_id_t id;
 
-    /* Add components from the 'add' id array */
-    int32_t i = 0;
-    ecs_id_t id;
-    const ecs_id_t *ids = desc->add;
-    while ((i < FLECS_ID_DESC_MAX) && (id = ids[i ++])) {
-        bool should_add = true;
-        if (ECS_HAS_ID_FLAG(id, PAIR) && ECS_PAIR_FIRST(id) == EcsChildOf) {
-            scope = ECS_PAIR_SECOND(id);
-            if ((!desc->id && desc->name) || (name && !name_assigned)) {
-                /* If name is added to entity, pass scope to add_path instead
-                 * of adding it to the table. The provided name may have nested
-                 * elements, in which case the parent provided here is not the
-                 * parent the entity will end up with. */
-                should_add = false;
-            }
+        while ((id = desc->add[i ++])) {
+            table = flecs_find_table_add(world, table, id, &diff);
         }
-        if (should_add) {
+    }
+
+    /* Add components from the 'set' array */
+    if (desc->set) {
+        int32_t i = 0;
+        ecs_id_t id;
+
+        while ((id = desc->set[i ++].type)) {
             table = flecs_find_table_add(world, table, id, &diff);
         }
     }
 
+    /* Add ids from .expr */
+    {
+        int32_t i, count = ecs_vec_count(&ids);
+        ecs_id_t *expr_ids = ecs_vec_first(&ids);
+        for (i = 0; i < count; i ++) {
+            table = flecs_find_table_add(world, table, expr_ids[i], &diff);
+        }
+    }
+
     /* Find destination table */
     /* If this is a new entity without a name, add the scope. If a name is
      * provided, the scope will be added by the add_path_w_sep function */
-    if (flecs_new_entity) {
-        if (flecs_new_entity && scope && !name && !name_assigned) {
+    if (new_entity) {
+        if (new_entity && scope && !name && !name_assigned) {
             table = flecs_find_table_add(
                 world, table, ecs_pair(EcsChildOf, scope), &diff);
         }
@@ -1564,38 +1471,17 @@ int flecs_traverse_add(
         }
     }
 
-    /* Add components from the 'add_expr' expression */
-    if (desc->add_expr && ecs_os_strcmp(desc->add_expr, "0")) {
-#ifdef FLECS_PARSER
-        bool error = false;
-        table = flecs_traverse_from_expr(
-            world, table, name, desc->add_expr, &diff, true, &error);
-        if (error) {
-            flecs_table_diff_builder_fini(world, &diff);
-            return -1;
-        }
-#else
-        ecs_abort(ECS_UNSUPPORTED, "parser addon is not available");
-#endif
-    }
-
     /* Commit entity to destination table */
     if (src_table != table) {
-        flecs_defer_begin(world, &world->stages[0]);
+        flecs_defer_begin(world, world->stages[0]);
         ecs_table_diff_t table_diff;
         flecs_table_diff_build_noalloc(&diff, &table_diff);
         flecs_commit(world, result, r, table, &table_diff, true, 0);
         flecs_table_diff_builder_fini(world, &diff);
-        flecs_defer_end(world, &world->stages[0]);
-    }
-
-    /* Set name */
-    if (name && !name_assigned) {
-        ecs_add_path_w_sep(world, result, scope, name, sep, root_sep);
-        ecs_assert(ecs_get_name(world, result) != NULL,
-            ECS_INTERNAL_ERROR, NULL);
+        flecs_defer_end(world, world->stages[0]);
     }
 
+    /* Set symbol */
     if (desc->symbol && desc->symbol[0]) {
         const char *sym = ecs_get_symbol(world, result);
         if (sym) {
@@ -1606,8 +1492,36 @@ int flecs_traverse_add(
         }
     }
 
+    /* Set component values */
+    if (desc->set) {
+        table = r->table;
+        ecs_assert(r->table != NULL, ECS_INTERNAL_ERROR, NULL);
+        int32_t i = 0, row = ECS_RECORD_TO_ROW(r->row);
+        const ecs_value_t *v;
+        
+        flecs_defer_begin(world, world->stages[0]);
+
+        while ((void)(v = &desc->set[i ++]), v->type) {
+            if (!v->ptr) {
+                continue;
+            }
+            ecs_assert(ECS_RECORD_TO_ROW(r->row) == row, ECS_INTERNAL_ERROR, NULL);
+            flecs_component_ptr_t ptr = flecs_get_component_ptr(
+                world, table, row, v->type);
+            ecs_check(ptr.ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+            flecs_copy_id(world, r, v->type, 
+                flecs_itosize(ptr.ti->size), ptr.ptr, v->ptr, ptr.ti);
+        }
+
+        flecs_defer_end(world, world->stages[0]);
+    }
+
     flecs_table_diff_builder_fini(world, &diff);
+    ecs_vec_fini_t(&world->allocator, &ids, ecs_id_t);
     return 0;
+error:
+    ecs_vec_fini_t(&world->allocator, &ids, ecs_id_t);
+    return -1;
 }
 
 /* When in deferred mode, we need to add/remove components one by one using
@@ -1639,31 +1553,42 @@ void flecs_deferred_add_remove(
     }
 
     /* Add components from the 'add' id array */
-    int32_t i = 0;
-    ecs_id_t id;
-    const ecs_id_t *ids = desc->add;
-    while ((i < FLECS_ID_DESC_MAX) && (id = ids[i ++])) {
-        bool defer = true;
-        if (ECS_HAS_ID_FLAG(id, PAIR) && ECS_PAIR_FIRST(id) == EcsChildOf) {
-            scope = ECS_PAIR_SECOND(id);
-            if (name && (!desc->id || !name_assigned)) {
-                /* New named entities are created by temporarily going out of
-                 * readonly mode to ensure no duplicates are created. */
-                defer = false;
+    if (desc->add) {
+        int32_t i = 0;
+        ecs_id_t id;
+
+        while ((id = desc->add[i ++])) {
+            bool defer = true;
+            if (ECS_HAS_ID_FLAG(id, PAIR) && ECS_PAIR_FIRST(id) == EcsChildOf) {
+                scope = ECS_PAIR_SECOND(id);
+                if (name && (!desc->id || !name_assigned)) {
+                    /* New named entities are created by temporarily going out of
+                     * readonly mode to ensure no duplicates are created. */
+                    defer = false;
+                }
+            }
+            if (defer) {
+                ecs_add_id(world, entity, id);
             }
         }
-        if (defer) {
-            ecs_add_id(world, entity, id);
+    }
+
+    /* Set component values */
+    if (desc->set) {
+        int32_t i = 0;
+        const ecs_value_t *v;
+        while ((void)(v = &desc->set[i ++]), v->type) {
+            if (v->ptr) {
+                ecs_set_id(world, entity, v->type, 0, v->ptr);
+            } else {
+                ecs_add_id(world, entity, v->type);
+            }
         }
     }
 
     /* Add components from the 'add_expr' expression */
     if (desc->add_expr) {
-#ifdef FLECS_PARSER
-        flecs_defer_from_expr(world, entity, name, desc->add_expr, true, true);
-#else
-        ecs_abort(ECS_UNSUPPORTED, "parser addon is not available");
-#endif
+        flecs_defer_from_expr(world, entity, name, desc->add_expr);
     }
 
     int32_t thread_count = ecs_get_stage_count(world);
@@ -1695,13 +1620,35 @@ ecs_entity_t ecs_entity_init(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_entity_desc_t was not initialized to zero");
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
     ecs_entity_t scope = stage->scope;
     ecs_id_t with = ecs_get_with(world);
     ecs_entity_t result = desc->id;
 
+#ifdef FLECS_DEBUG
+    if (desc->add) {
+        ecs_id_t id;
+        int32_t i = 0;
+        while ((id = desc->add[i ++])) {
+            if (ECS_HAS_ID_FLAG(id, PAIR) && 
+                (ECS_PAIR_FIRST(id) == EcsChildOf))
+            {
+                if (desc->name) {
+                    ecs_check(false, ECS_INVALID_PARAMETER, "%s: cannot set parent in "
+                        "ecs_entity_desc_t::add, use ecs_entity_desc_t::parent",
+                            desc->name);
+                } else {
+                    ecs_check(false, ECS_INVALID_PARAMETER, "cannot set parent in "
+                        "ecs_entity_desc_t::add, use ecs_entity_desc_t::parent");
+                }
+            }
+        }
+    }
+#endif
+
     const char *name = desc->name;
     const char *sep = desc->sep;
     if (!sep) {
@@ -1750,21 +1697,15 @@ ecs_entity_t ecs_entity_init(
         }
     }
 
+    /* Parent field takes precedence over scope */
+    if (desc->parent) {
+        scope = desc->parent;
+    }
+
     /* Find or create entity */
     if (!result) {
         if (name) {
             /* If add array contains a ChildOf pair, use it as scope instead */
-            const ecs_id_t *ids = desc->add;
-            ecs_id_t id;
-            int32_t i = 0;
-            while ((i < FLECS_ID_DESC_MAX) && (id = ids[i ++])) {
-                if (ECS_HAS_ID_FLAG(id, PAIR) && 
-                    (ECS_PAIR_FIRST(id) == EcsChildOf))
-                {
-                    scope = ECS_PAIR_SECOND(id);
-                }
-            }
-
             result = ecs_lookup_path_w_sep(
                 world, scope, name, sep, root_sep, false);
             if (result) {
@@ -1776,7 +1717,7 @@ ecs_entity_t ecs_entity_init(
             if (desc->use_low_id) {
                 result = ecs_new_low_id(world);
             } else {
-                result = ecs_new_id(world);
+                result = ecs_new(world);
             }
             flecs_new_entity = true;
             ecs_assert(ecs_get_type(world, result) == NULL,
@@ -1849,10 +1790,11 @@ const ecs_entity_t* ecs_bulk_init(
     ecs_world_t *world,
     const ecs_bulk_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INTERNAL_ERROR, NULL);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_bulk_desc_t was not initialized to zero");
 
     const ecs_entity_t *entities = desc->entities;
     int32_t count = desc->count;
@@ -1937,7 +1879,8 @@ ecs_entity_t ecs_component_init(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_component_desc_t was not initialized to 0");
 
     /* If existing entity is provided, check if it is already registered as a
      * component and matches the size/alignment. This can prevent having to
@@ -2000,9 +1943,6 @@ ecs_entity_t ecs_component_init(
         world->info.last_component_id = result + 1;
     }
 
-    /* Ensure components cannot be deleted */
-    ecs_add_pair(world, result, EcsOnDelete, EcsPanic);
-
     flecs_resume_readonly(world, &readonly_state);
     
     ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL);
@@ -2391,8 +2331,7 @@ void flecs_remove_from_table(
                 ecs_log_pop_3();
             }
 
-            flecs_table_merge(world, dst_table, table, 
-                &dst_table->data, &table->data);
+            flecs_table_merge(world, dst_table, table);
         }
     }
 
@@ -2434,9 +2373,9 @@ bool flecs_on_delete_clear_tables(
             }
 
             /* Run commands so children get notified before parent is deleted */
-            if (world->stages[0].defer) {
-                flecs_defer_end(world, &world->stages[0]);
-                flecs_defer_begin(world, &world->stages[0]);
+            if (world->stages[0]->defer) {
+                flecs_defer_end(world, world->stages[0]);
+                flecs_defer_begin(world, world->stages[0]);
             }
 
             /* User code (from triggers) could have enqueued more ids to delete,
@@ -2708,7 +2647,7 @@ ecs_entity_t ecs_clone(
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
     if (!dst) {
-        dst = ecs_new_id(world);
+        dst = ecs_new(world);
     }
 
     if (flecs_defer_clone(stage, dst, src, copy_value)) {
@@ -2731,7 +2670,7 @@ ecs_entity_t ecs_clone(
     ecs_type_t dst_type = dst_table->type;
     ecs_table_diff_t diff = { .added = dst_type };
     ecs_record_t *dst_r = flecs_entities_get(world, dst);
-    flecs_new_entity(world, dst, dst_r, dst_table, &diff, true, true);
+    flecs_new_entity(world, dst, dst_r, dst_table, &diff, true, 0);
     int32_t row = ECS_RECORD_TO_ROW(dst_r->row);
 
     if (copy_value) {
@@ -2761,8 +2700,6 @@ const void* ecs_get_id(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(flecs_stage_from_readonly_world(world)->async == false, 
-        ECS_INVALID_PARAMETER, NULL);
 
     world = ecs_get_world(world);
 
@@ -2799,8 +2736,6 @@ void* ecs_get_mut_id(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(flecs_stage_from_readonly_world(world)->async == false, 
-        ECS_INVALID_PARAMETER, NULL);
 
     world = ecs_get_world(world);
 
@@ -2839,7 +2774,8 @@ void* ecs_ensure_id(
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
     if (flecs_defer_cmd(stage)) {
-        return flecs_defer_set(world, stage, EcsCmdEnsure, entity, id, 0, NULL);
+        return flecs_defer_set(
+            world, stage, EcsCmdEnsure, entity, id, 0, NULL, NULL);
     }
 
     ecs_record_t *r = flecs_entities_get(world, entity);
@@ -2865,7 +2801,7 @@ void* ecs_ensure_modified_id(
     ecs_stage_t *stage = flecs_stage_from_world(&world);
     ecs_check(flecs_defer_cmd(stage), ECS_INVALID_PARAMETER, NULL);
 
-    return flecs_defer_set(world, stage, EcsCmdSet, entity, id, 0, NULL);
+    return flecs_defer_set(world, stage, EcsCmdSet, entity, id, 0, NULL, NULL);
 error:
     return NULL;
 }
@@ -3027,7 +2963,7 @@ bool flecs_ref_needs_sync(
 {
     ecs_assert(ref != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    return !tr || tr->hdr.table != table || ref->table_id != table->id;
+    return !tr || ref->table_id != table->id || tr->hdr.table != table;
 }
 
 void ecs_ref_update(
@@ -3067,10 +3003,10 @@ void* ecs_ref_get_id(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ref != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ref->entity != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ref->id != 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ref->record != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(id == ref->id, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ref->entity != 0, ECS_INVALID_PARAMETER, "ref not initialized");
+    ecs_check(ref->id != 0, ECS_INVALID_PARAMETER, "ref not initialized");
+    ecs_check(ref->record != NULL, ECS_INVALID_PARAMETER, "ref not initialized");
+    ecs_check(id == ref->id, ECS_INVALID_PARAMETER, "ref not initialized");
 
     ecs_record_t *r = ref->record;
     ecs_table_t *table = r->table;
@@ -3102,26 +3038,35 @@ void* ecs_ref_get_id(
 void* ecs_emplace_id(
     ecs_world_t *world,
     ecs_entity_t entity,
-    ecs_id_t id)
+    ecs_id_t id,
+    bool *is_new)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!ecs_has_id(world, entity, id), ECS_INVALID_PARAMETER, 
+    ecs_check(is_new || !ecs_has_id(world, entity, id), ECS_INVALID_PARAMETER, 
         "cannot emplace a component the entity already has");
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
 
     if (flecs_defer_cmd(stage)) {
-        return flecs_defer_set(world, stage, EcsCmdEmplace, entity, id, 0, NULL);
+        return flecs_defer_set(
+            world, stage, EcsCmdEmplace, entity, id, 0, NULL, is_new);
     }
 
     ecs_record_t *r = flecs_entities_get(world, entity);
+    ecs_table_t *table = r->table;
     flecs_add_id_w_record(world, entity, r, id, false /* Add without ctor */);
     flecs_defer_end(world, stage);
 
     void *ptr = flecs_get_component(world, r->table, ECS_RECORD_TO_ROW(r->row), id);
-    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, 
+        "emplaced component was removed during operation, make sure to not "
+        "remove component T in on_add(T) hook/OnAdd(T) observer");
+
+    if (is_new) {
+        *is_new = table != r->table;
+    }
 
     return ptr;
 error:
@@ -3194,7 +3139,7 @@ void ecs_modified_id(
 }
 
 static
-void flecs_copy_ptr_w_id(
+void flecs_set_id_copy(
     ecs_world_t *world,
     ecs_stage_t *stage,
     ecs_entity_t entity,
@@ -3204,42 +3149,20 @@ void flecs_copy_ptr_w_id(
 {
     if (flecs_defer_cmd(stage)) {
         flecs_defer_set(world, stage, EcsCmdSet, entity, id, 
-            flecs_utosize(size), ptr);
+            flecs_utosize(size), ptr, NULL);
         return;
     }
 
     ecs_record_t *r = flecs_entities_get(world, entity);
     flecs_component_ptr_t dst = flecs_ensure(world, entity, id, r);
-    const ecs_type_info_t *ti = dst.ti;
-    ecs_check(dst.ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    if (ptr) {
-        ecs_copy_t copy = ti->hooks.copy;
-        if (copy) {
-            copy(dst.ptr, ptr, 1, ti);
-        } else {
-            ecs_os_memcpy(dst.ptr, ptr, flecs_utosize(size));
-        }
-    } else {
-        ecs_os_memset(dst.ptr, 0, size);
-    }
-
-    flecs_table_mark_dirty(world, r->table, id);
 
-    ecs_table_t *table = r->table;
-    if (table->flags & EcsTableHasOnSet || ti->hooks.on_set) {
-        ecs_type_t ids = { .array = &id, .count = 1 };
-        flecs_notify_on_set(
-            world, table, ECS_RECORD_TO_ROW(r->row), 1, &ids, true);
-    }
+    flecs_copy_id(world, r, id, size, dst.ptr, ptr, dst.ti);
 
     flecs_defer_end(world, stage);
-error:
-    return;
 }
 
 static
-void flecs_move_ptr_w_id(
+void flecs_set_id_move(
     ecs_world_t *world,
     ecs_stage_t *stage,
     ecs_entity_t entity,
@@ -3250,7 +3173,7 @@ void flecs_move_ptr_w_id(
 {
     if (flecs_defer_cmd(stage)) {
         flecs_defer_set(world, stage, cmd_kind, entity, id, 
-            flecs_utosize(size), ptr);
+            flecs_utosize(size), ptr, NULL);
         return;
     }
 
@@ -3289,7 +3212,7 @@ void flecs_move_ptr_w_id(
     return;
 }
 
-ecs_entity_t ecs_set_id(
+void ecs_set_id(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_id_t id,
@@ -3297,26 +3220,32 @@ ecs_entity_t ecs_set_id(
     const void *ptr)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!entity || ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_is_alive(world, entity), ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
 
-    if (!entity) {
-        entity = ecs_new_id(world);
-        ecs_entity_t scope = stage->scope;
-        if (scope) {
-            ecs_add_pair(world, entity, EcsChildOf, scope);
-        }
-    }
-
     /* Safe to cast away const: function won't modify if move arg is false */
-    flecs_copy_ptr_w_id(world, stage, entity, id, size, 
+    flecs_set_id_copy(world, stage, entity, id, size, 
         ECS_CONST_CAST(void*, ptr));
-    return entity;
 error:
-    return 0;
+    return;
+}
+
+#if defined(FLECS_DEBUG) || defined(FLECS_KEEP_ASSERT)
+static
+bool flecs_can_toggle(
+    ecs_world_t *world,
+    ecs_id_t id)
+{
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (!idr) {
+        return false;
+    }
+
+    return (idr->flags & EcsIdCanToggle) != 0;
 }
+#endif
 
 void ecs_enable_id(
     ecs_world_t *world,
@@ -3327,6 +3256,8 @@ void ecs_enable_id(
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_is_valid(world, entity), ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(flecs_can_toggle(world, id), ECS_INVALID_OPERATION, 
+        "add CanToggle trait to component");
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
 
@@ -3356,7 +3287,7 @@ void ecs_enable_id(
     index -= table->_->bs_offset;
     ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
 
-    /* Data cannot be NULl, since entity is stored in the table */
+    /* Data cannot be NULL, since entity is stored in the table */
     ecs_bitset_t *bs = &table->_->bs_columns[index];
     ecs_assert(bs != NULL, ECS_INTERNAL_ERROR, NULL);
 
@@ -3430,7 +3361,7 @@ bool ecs_has_id(
         }
     }
 
-    if (!(table->flags & (EcsTableHasUnion|EcsTableHasIsA))) {
+    if (!(table->flags & EcsTableHasIsA)) {
         return false;
     }
 
@@ -3441,20 +3372,6 @@ bool ecs_has_id(
         return false;
     }
 
-    table = tr->hdr.table;
-    if ((table->flags & EcsTableHasUnion) && ECS_HAS_ID_FLAG(id, PAIR) &&
-        ECS_PAIR_SECOND(id) != EcsWildcard) 
-    {
-        if (ECS_PAIR_FIRST(table->type.array[column]) == EcsUnion) {
-            ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_switch_t *sw = &table->_->sw_columns[
-                column - table->_->sw_offset];
-            int32_t row = ECS_RECORD_TO_ROW(r->row);
-            uint64_t value = flecs_switch_get(sw, row);
-            return value == ecs_pair_second(world, id);
-        }
-    }
-    
     return true;
 error:
     return false;
@@ -3494,30 +3411,11 @@ ecs_entity_t ecs_get_target(
         tr = flecs_id_record_get_table(idr, table);
     }
     if (!tr) {
-        if (table->flags & EcsTableHasUnion) {
-            wc = ecs_pair(EcsUnion, rel);
-            tr = flecs_table_record_get(world, table, wc);
-            if (tr) {
-                ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-                ecs_switch_t *sw = &table->_->sw_columns[
-                    tr->index - table->_->sw_offset];
-                int32_t row = ECS_RECORD_TO_ROW(r->row);
-                return flecs_switch_get(sw, row);
-                
-            }
-        }
-
         if (!idr || !(idr->flags & EcsIdDontInherit)) {
             goto look_in_base;
         } else {
             return 0;
         }
-    } else if (table->flags & EcsTableHasTarget) {
-        EcsFlattenTarget *tf = ecs_table_get_id(world, table, 
-            ecs_pair_t(EcsFlattenTarget, rel), ECS_RECORD_TO_ROW(r->row));
-        if (tf) {
-            return ecs_record_get_entity(tf->target);
-        }
     }
 
     if (index >= tr->count) {
@@ -3618,7 +3516,9 @@ int32_t ecs_get_depth(
     ecs_entity_t rel)
 {
     ecs_check(ecs_is_valid(world, rel), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_has_id(world, rel, EcsAcyclic), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_has_id(world, rel, EcsAcyclic), ECS_INVALID_PARAMETER, 
+        "cannot safely determine depth for relationship that is not acyclic "
+            "(add Acyclic property to relationship)");
 
     ecs_table_t *table = ecs_get_table(world, entity);
     if (table) {
@@ -3630,195 +3530,6 @@ int32_t ecs_get_depth(
     return -1;
 }
 
-static
-ecs_entity_t flecs_id_for_depth(
-    ecs_world_t *world,
-    int32_t depth)
-{
-    ecs_vec_t *depth_ids = &world->store.depth_ids;
-    int32_t i, count = ecs_vec_count(depth_ids);
-    for (i = count; i <= depth; i ++) {
-        ecs_entity_t *el = ecs_vec_append_t(
-            &world->allocator, depth_ids, ecs_entity_t);
-        el[0] = ecs_new_w_pair(world, EcsChildOf, EcsFlecsInternals);
-        ecs_map_val_t *v = ecs_map_ensure(&world->store.entity_to_depth, el[0]);
-        v[0] = flecs_ito(uint64_t, i);
-    }
-
-    return ecs_vec_get_t(&world->store.depth_ids, ecs_entity_t, depth)[0];
-}
-
-static
-int32_t flecs_depth_for_id(
-    ecs_world_t *world,
-    ecs_entity_t id)
-{
-    ecs_map_val_t *v = ecs_map_get(&world->store.entity_to_depth, id);
-    ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL);
-    return flecs_uto(int32_t, v[0]);
-}
-
-static
-int32_t flecs_depth_for_flat_table(
-    ecs_world_t *world,
-    ecs_table_t *table)
-{
-    ecs_assert(table->flags & EcsTableHasTarget, ECS_INTERNAL_ERROR, NULL);
-    ecs_id_t id;
-    int32_t col = ecs_search(world, table, 
-        ecs_pair(EcsFlatten, EcsWildcard), &id);
-    ecs_assert(col != -1, ECS_INTERNAL_ERROR, NULL);
-    (void)col;
-    return flecs_depth_for_id(world, ECS_PAIR_SECOND(id));
-}
-
-static
-void flecs_flatten(
-    ecs_world_t *world,
-    ecs_entity_t root,
-    ecs_id_t pair,
-    int32_t depth,
-    const ecs_flatten_desc_t *desc)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, pair);
-    if (!idr) {
-        return;
-    }
-
-    ecs_entity_t depth_id = flecs_id_for_depth(world, depth);
-    ecs_id_t root_pair = ecs_pair(EcsChildOf, root);
-    ecs_id_t tgt_pair = ecs_pair_t(EcsFlattenTarget, EcsChildOf);
-    ecs_id_t depth_pair = ecs_pair(EcsFlatten, depth_id);
-    ecs_id_t name_pair = ecs_pair_t(EcsIdentifier, EcsName);
-
-    ecs_entity_t rel = ECS_PAIR_FIRST(pair);
-    ecs_table_cache_iter_t it;
-    if (idr && flecs_table_cache_iter((ecs_table_cache_t*)idr, &it)) {
-        const ecs_table_record_t *tr;
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            ecs_table_t *table = tr->hdr.table;
-            int32_t i, count = ecs_table_count(table);
-            bool has_tgt = table->flags & EcsTableHasTarget;
-            flecs_emit_propagate_invalidate(world, table, 0, count);
-
-            ecs_entity_t *entities = table->data.entities.array;
-            for (i = 0; i < count; i ++) {
-                ecs_record_t *record = flecs_entities_get(world, entities[i]);
-                ecs_flags32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
-                if (flags & EcsEntityIsTarget) {
-                    flecs_flatten(world, root, ecs_pair(rel, entities[i]), 
-                        depth + 1, desc);
-                }
-            }
-
-            ecs_table_diff_t tmpdiff;
-            ecs_table_diff_builder_t diff = ECS_TABLE_DIFF_INIT;
-            flecs_table_diff_builder_init(world, &diff);
-            ecs_table_t *dst;
-
-            dst = flecs_table_traverse_add(world, table, &root_pair, &tmpdiff);
-            flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-
-            dst = flecs_table_traverse_add(world, dst, &tgt_pair, &tmpdiff);
-            flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-
-            if (!desc->lose_depth) {
-                if (!has_tgt) {
-                    dst = flecs_table_traverse_add(world, dst, &depth_pair, &tmpdiff);
-                    flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-                } else {
-                    int32_t cur_depth = flecs_depth_for_flat_table(world, table);
-                    cur_depth += depth;
-                    ecs_entity_t e_depth = flecs_id_for_depth(world, cur_depth);
-                    ecs_id_t p_depth = ecs_pair(EcsFlatten, e_depth);
-                    dst = flecs_table_traverse_add(world, dst, &p_depth, &tmpdiff);
-                    flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-                }
-            }
-
-            if (!desc->keep_names) {
-                dst = flecs_table_traverse_remove(world, dst, &name_pair, &tmpdiff);
-                flecs_table_diff_build_append_table(world, &diff, &tmpdiff);
-            }
-
-            int32_t dst_count = ecs_table_count(dst);
-
-            ecs_table_diff_t td;
-            flecs_table_diff_build_noalloc(&diff, &td);
-            flecs_notify_on_remove(world, table, NULL, 0, count, &td.removed);
-            flecs_table_merge(world, dst, table, &dst->data, &table->data);
-            flecs_notify_on_add(world, dst, NULL, dst_count, count,
-                &td.added, 0);
-            flecs_table_diff_builder_fini(world, &diff);
-
-            EcsFlattenTarget *fh = ecs_table_get_id(world, dst, tgt_pair, 0);
-            ecs_assert(fh != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(count != 0, ECS_INTERNAL_ERROR, NULL);
-            int32_t remain = count;
-
-            for (i = dst_count; i < (dst_count + count); i ++) {
-                if (!has_tgt) {
-                    fh[i].target = flecs_entities_get_any(world, 
-                        ECS_PAIR_SECOND(pair));
-                    fh[i].count = remain;
-                    remain --;
-                }
-                ecs_assert(fh[i].target != NULL, ECS_INTERNAL_ERROR, NULL);
-            }
-        }
-    }
-
-    ecs_delete_with(world, pair);
-    flecs_id_record_release(world, idr);
-}
-
-void ecs_flatten(
-    ecs_world_t *world,
-    ecs_id_t pair,
-    const ecs_flatten_desc_t *desc)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_entity_t rel = ECS_PAIR_FIRST(pair);
-    ecs_entity_t root = ecs_pair_second(world, pair);
-    ecs_flatten_desc_t private_desc = {0};
-    if (desc) {
-        private_desc = *desc;
-    }
-    
-    ecs_run_aperiodic(world, 0);
-    ecs_defer_begin(world);
-
-    ecs_id_record_t *idr = flecs_id_record_get(world, pair);
-
-    ecs_table_cache_iter_t it;
-    if (idr && flecs_table_cache_iter((ecs_table_cache_t*)idr, &it)) {
-        const ecs_table_record_t *tr;
-        while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
-            ecs_table_t *table = tr->hdr.table;
-            if (!table->_->traversable_count) {
-                continue;
-            }
-
-            if (table->flags & EcsTableIsPrefab) {
-                continue;
-            }
-
-            int32_t i, count = ecs_table_count(table);
-            ecs_entity_t *entities = table->data.entities.array;
-            for (i = 0; i < count; i ++) {
-                ecs_record_t *record = flecs_entities_get(world, entities[i]);
-                ecs_flags32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row);
-                if (flags & EcsEntityIsTarget) {
-                    flecs_flatten(world, root, ecs_pair(rel, entities[i]), 1, 
-                        &private_desc);
-                }
-            }
-        }
-    }
-
-    ecs_defer_end(world);
-}
-
 static
 const char* flecs_get_identifier(
     const ecs_world_t *world,
@@ -3871,7 +3582,7 @@ ecs_entity_t flecs_set_identifier(
     ecs_check(entity != 0 || name != NULL, ECS_INVALID_PARAMETER, NULL);
 
     if (!entity) {
-        entity = ecs_new_id(world);
+        entity = ecs_new(world);
     }
 
     if (!name) {
@@ -4045,7 +3756,8 @@ void ecs_make_alive(
     /* The entity index can be mutated while in staged/readonly mode, as long as
      * the world is not multithreaded. */
     ecs_assert(!(world->flags & EcsWorldMultiThreaded), 
-        ECS_INVALID_OPERATION, NULL);
+        ECS_INVALID_OPERATION, 
+            "cannot make entity alive while world is in multithreaded mode");
 
     /* Check if a version of the provided id is alive */
     ecs_entity_t any = ecs_get_alive(world, (uint32_t)entity);
@@ -4055,7 +3767,8 @@ void ecs_make_alive(
     }
 
     /* If the id is currently alive but did not match the argument, fail */
-    ecs_check(!any, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!any, ECS_INVALID_PARAMETER, 
+        "entity is alive with different generation");
 
     /* Set generation if not alive. The sparse set checks if the provided
      * id matches its own generation which is necessary for alive ids. This
@@ -4078,7 +3791,7 @@ void ecs_make_alive_id(
     ecs_world_t *world,
     ecs_id_t id)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     if (ECS_HAS_ID_FLAG(id, PAIR)) {
         ecs_entity_t r = ECS_PAIR_FIRST(id);
         ecs_entity_t o = ECS_PAIR_SECOND(id);
@@ -4117,6 +3830,26 @@ bool ecs_exists(
     return false;
 }
 
+void ecs_set_generation(
+    ecs_world_t *world,
+    ecs_entity_t entity_with_generation)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION,
+        "cannot change entity generation when world is in readonly mode");
+    ecs_assert(!(ecs_is_deferred(world)), ECS_INVALID_OPERATION, 
+        "cannot change entity generation while world is deferred");
+
+    flecs_entities_make_alive(world, entity_with_generation);
+
+    ecs_record_t *r = flecs_entities_get(world, entity_with_generation);
+    if (r && r->table) {
+        int32_t row = ECS_RECORD_TO_ROW(r->row);
+        ecs_entity_t *entities = r->table->data.entities.array;
+        entities[row] = entity_with_generation;
+    }
+}
+
 ecs_table_t* ecs_get_table(
     const ecs_world_t *world,
     ecs_entity_t entity)
@@ -4163,7 +3896,7 @@ const ecs_type_info_t* ecs_get_type_info(
         }
         if (!idr) {
             ecs_entity_t first = ecs_pair_first(world, id);
-            if (!first || !ecs_has_id(world, first, EcsTag)) {
+            if (!first || !ecs_has_id(world, first, EcsPairIsTag)) {
                 idr = flecs_id_record_get(world, 
                     ecs_pair(EcsWildcard, ECS_PAIR_SECOND(id)));
                 if (!idr || !idr->type_info) {
@@ -4207,7 +3940,7 @@ bool ecs_id_is_tag(
             if (ECS_PAIR_FIRST(id) != EcsWildcard) {
                 ecs_entity_t rel = ecs_pair_first(world, id);
                 if (ecs_is_valid(world, rel)) {
-                    if (ecs_has_id(world, rel, EcsTag)) {
+                    if (ecs_has_id(world, rel, EcsPairIsTag)) {
                         return true;
                     }
                 } else {
@@ -4233,24 +3966,6 @@ bool ecs_id_is_tag(
     return false;
 }
 
-bool ecs_id_is_union(
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    if (!ECS_IS_PAIR(id)) {
-        return false;
-    } else if (ECS_PAIR_FIRST(id) == EcsUnion) {
-        return true;
-    } else {
-        ecs_entity_t first = ecs_pair_first(world, id);
-        if (ecs_has_id(world, first, EcsUnion)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
 int32_t ecs_count_id(
     const ecs_world_t *world,
     ecs_entity_t id)
@@ -4262,16 +3977,8 @@ int32_t ecs_count_id(
     }
 
     int32_t count = 0;
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t) { 
-        .id = id,
-        .src.flags = EcsSelf,
-        .flags = EcsTermMatchDisabled|EcsTermMatchPrefab
-    });
-
-    it.flags |= EcsIterNoData;
-    it.flags |= EcsIterEvalTables;
-
-    while (ecs_term_next(&it)) {
+    ecs_iter_t it = ecs_each_id(world, id);
+    while (ecs_each_next(&it)) {
         count += it.count;
     }
 
@@ -4331,9 +4038,11 @@ void ecs_defer_suspend(
     ecs_world_t *world)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_is_deferred(world), ECS_INVALID_OPERATION, NULL);
+    ecs_check(ecs_is_deferred(world), ECS_INVALID_OPERATION, 
+        "world/stage must be deferred before it can be suspended");
     ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_check(stage->defer > 0, ECS_INVALID_OPERATION, NULL);
+    ecs_check(stage->defer > 0, ECS_INVALID_OPERATION, 
+        "world/stage is already suspended");
     stage->defer = -stage->defer;
 error:
     return;
@@ -4344,7 +4053,8 @@ void ecs_defer_resume(
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_stage_t *stage = flecs_stage_from_world(&world);
-    ecs_check(stage->defer < 0, ECS_INVALID_OPERATION, NULL);
+    ecs_check(stage->defer < 0, ECS_INVALID_OPERATION,
+        "world/stage must be suspended before it can be resumed");
     stage->defer = -stage->defer;
 error:
     return;
@@ -4359,9 +4069,6 @@ const char* ecs_id_flag_str(
     if (ECS_HAS_ID_FLAG(entity, TOGGLE)) {
         return "TOGGLE";
     } else
-    if (ECS_HAS_ID_FLAG(entity, AND)) {
-        return "AND";
-    } else
     if (ECS_HAS_ID_FLAG(entity, OVERRIDE)) {
         return "OVERRIDE";
     } else {
@@ -4388,11 +4095,6 @@ void ecs_id_str_buf(
         ecs_strbuf_appendch(buf, '|');
     }
 
-    if (ECS_HAS_ID_FLAG(id, AND)) {
-        ecs_strbuf_appendstr(buf, ecs_id_flag_str(ECS_AND));
-        ecs_strbuf_appendch(buf, '|');
-    }
-
     if (ECS_HAS_ID_FLAG(id, PAIR)) {
         ecs_entity_t rel = ECS_PAIR_FIRST(id);
         ecs_entity_t obj = ECS_PAIR_SECOND(id);
@@ -4818,9 +4520,9 @@ void flecs_cmd_batch_for_entity(
 
     /* Move entity to destination table in single operation */
     flecs_table_diff_build_noalloc(diff, &table_diff);
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
     flecs_commit(world, entity, r, table, &table_diff, true, 0);
-    flecs_defer_end(world, &world->stages[0]);
+    flecs_defer_end(world, world->stages[0]);
     flecs_table_diff_builder_clear(diff);
 
     /* If the batch contains set commands, copy the component value from the 
@@ -4909,8 +4611,8 @@ bool flecs_defer_end(
     ecs_world_t *world,
     ecs_stage_t *stage)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_assert(stage, ecs_stage_t);
+    flecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(stage, ecs_stage_t);
 
     if (stage->defer < 0) {
         /* Defer suspending makes it possible to do operations on the storage
@@ -4924,8 +4626,8 @@ bool flecs_defer_end(
         /* Test whether we're flushing to another queue or whether we're 
          * flushing to the storage */
         bool merge_to_world = false;
-        if (ecs_poly_is(world, ecs_world_t)) {
-            merge_to_world = world->stages[0].defer == 0;
+        if (flecs_poly_is(world, ecs_world_t)) {
+            merge_to_world = world->stages[0]->defer == 0;
         }
 
         ecs_stage_t *dst_stage = flecs_stage_from_world(&world);
@@ -5002,22 +4704,26 @@ bool flecs_defer_end(
                     world->info.cmd.other_count ++;
                     break;
                 case EcsCmdSet:
-                    flecs_move_ptr_w_id(world, dst_stage, e, 
+                    flecs_set_id_move(world, dst_stage, e, 
                         cmd->id, flecs_itosize(cmd->is._1.size), 
                         cmd->is._1.value, kind);
                     world->info.cmd.set_count ++;
                     break;
                 case EcsCmdEmplace:
                     if (merge_to_world) {
-                        ecs_emplace_id(world, e, id);
+                        bool is_new;
+                        ecs_emplace_id(world, e, id, &is_new);
+                        if (!is_new) {
+                            kind = EcsCmdEnsure;
+                        }
                     }
-                    flecs_move_ptr_w_id(world, dst_stage, e, 
+                    flecs_set_id_move(world, dst_stage, e, 
                         cmd->id, flecs_itosize(cmd->is._1.size), 
                         cmd->is._1.value, kind);
                     world->info.cmd.ensure_count ++;
                     break;
                 case EcsCmdEnsure:
-                    flecs_move_ptr_w_id(world, dst_stage, e, 
+                    flecs_set_id_move(world, dst_stage, e, 
                         cmd->id, flecs_itosize(cmd->is._1.size), 
                         cmd->is._1.value, kind);
                     world->info.cmd.ensure_count ++;
diff --git a/src/entity_filter.c b/src/entity_filter.c
deleted file mode 100644
index b859af8be..000000000
--- a/src/entity_filter.c
+++ /dev/null
@@ -1,650 +0,0 @@
-/**
- * @file entity_filter.c
- * @brief Filters that are applied to entities in a table.
- * 
- * After a table has been matched by a query, additional filters may have to
- * be applied before returning entities to the application. The two scenarios
- * under which this happens are queries for union relationship pairs (entities
- * for multiple targets are stored in the same table) and toggles (components 
- * that are enabled/disabled with a bitset).
- */
-
-#include "private_api.h"
-
-static
-int flecs_entity_filter_find_smallest_term(
-    ecs_table_t *table,
-    ecs_entity_filter_iter_t *iter)
-{
-    ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-    flecs_switch_term_t *sw_terms = ecs_vec_first(&iter->entity_filter->sw_terms);
-    int32_t i, count = ecs_vec_count(&iter->entity_filter->sw_terms);
-    int32_t min = INT_MAX, index = 0;
-
-    for (i = 0; i < count; i ++) {
-        /* The array with sparse queries for the matched table */
-        flecs_switch_term_t *sparse_column = &sw_terms[i];
-
-        /* Pointer to the switch column struct of the table */
-        ecs_switch_t *sw = sparse_column->sw_column;
-
-        /* If the sparse column pointer hadn't been retrieved yet, do it now */
-        if (!sw) {
-            /* Get the table column index from the signature column index */
-            int32_t table_column_index = iter->columns[
-                sparse_column->signature_column_index];
-
-            /* Translate the table column index to switch column index */
-            table_column_index -= table->_->sw_offset;
-            ecs_assert(table_column_index >= 1, ECS_INTERNAL_ERROR, NULL);
-
-            /* Get the sparse column */
-            sw = sparse_column->sw_column = 
-                &table->_->sw_columns[table_column_index - 1];
-        }
-
-        /* Find the smallest column */
-        int32_t case_count = flecs_switch_case_count(sw, sparse_column->sw_case);
-        if (case_count < min) {
-            min = case_count;
-            index = i + 1;
-        }
-    }
-
-    return index;
-}
-
-static
-int flecs_entity_filter_switch_next(
-    ecs_table_t *table,
-    ecs_entity_filter_iter_t *iter,
-    bool filter)
-{
-    bool first_iteration = false;
-    int32_t switch_smallest;
-
-    if (!(switch_smallest = iter->sw_smallest)) {
-        switch_smallest = iter->sw_smallest = 
-            flecs_entity_filter_find_smallest_term(table, iter);
-        first_iteration = true;
-    }
-
-    switch_smallest -= 1;
-
-    flecs_switch_term_t *columns = ecs_vec_first(&iter->entity_filter->sw_terms);
-    flecs_switch_term_t *column = &columns[switch_smallest];
-    ecs_switch_t *sw, *sw_smallest = column->sw_column;
-    ecs_entity_t case_smallest = column->sw_case;
-
-    /* Find next entity to iterate in sparse column */
-    int32_t first, sparse_first = iter->sw_offset;
-
-    if (!filter) {
-        if (first_iteration) {
-            first = flecs_switch_first(sw_smallest, case_smallest);
-        } else {
-            first = flecs_switch_next(sw_smallest, sparse_first);
-        }
-    } else {
-        int32_t cur_first = iter->range.offset, cur_count = iter->range.count;
-        first = cur_first;
-        while (flecs_switch_get(sw_smallest, first) != case_smallest) {
-            first ++;
-            if (first >= (cur_first + cur_count)) {
-                first = -1;
-                break;
-            }
-        }
-    }
-
-    if (first == -1) {
-        goto done;
-    }
-
-    /* Check if entity matches with other sparse columns, if any */
-    int32_t i, count = ecs_vec_count(&iter->entity_filter->sw_terms);
-    do {
-        for (i = 0; i < count; i ++) {
-            if (i == switch_smallest) {
-                /* Already validated this one */
-                continue;
-            }
-
-            column = &columns[i];
-            sw = column->sw_column;
-
-            if (flecs_switch_get(sw, first) != column->sw_case) {
-                first = flecs_switch_next(sw_smallest, first);
-                if (first == -1) {
-                    goto done;
-                }
-            }
-        }
-    } while (i != count);
-
-    iter->range.offset = iter->sw_offset = first;
-    iter->range.count = 1;
-
-    return 0;
-done:
-    /* Iterated all elements in the sparse list, we should move to the
-     * next matched table. */
-    iter->sw_smallest = 0;
-    iter->sw_offset = 0;
-
-    return -1;
-}
-
-#define BS_MAX ((uint64_t)0xFFFFFFFFFFFFFFFF)
-
-static
-int flecs_entity_filter_bitset_next(
-    ecs_table_t *table,
-    ecs_entity_filter_iter_t *iter)
-{
-    /* Precomputed single-bit test */
-    static const uint64_t bitmask[64] = {
-    (uint64_t)1 << 0, (uint64_t)1 << 1, (uint64_t)1 << 2, (uint64_t)1 << 3,
-    (uint64_t)1 << 4, (uint64_t)1 << 5, (uint64_t)1 << 6, (uint64_t)1 << 7,
-    (uint64_t)1 << 8, (uint64_t)1 << 9, (uint64_t)1 << 10, (uint64_t)1 << 11,
-    (uint64_t)1 << 12, (uint64_t)1 << 13, (uint64_t)1 << 14, (uint64_t)1 << 15,
-    (uint64_t)1 << 16, (uint64_t)1 << 17, (uint64_t)1 << 18, (uint64_t)1 << 19,
-    (uint64_t)1 << 20, (uint64_t)1 << 21, (uint64_t)1 << 22, (uint64_t)1 << 23,
-    (uint64_t)1 << 24, (uint64_t)1 << 25, (uint64_t)1 << 26, (uint64_t)1 << 27,  
-    (uint64_t)1 << 28, (uint64_t)1 << 29, (uint64_t)1 << 30, (uint64_t)1 << 31,
-    (uint64_t)1 << 32, (uint64_t)1 << 33, (uint64_t)1 << 34, (uint64_t)1 << 35,  
-    (uint64_t)1 << 36, (uint64_t)1 << 37, (uint64_t)1 << 38, (uint64_t)1 << 39,
-    (uint64_t)1 << 40, (uint64_t)1 << 41, (uint64_t)1 << 42, (uint64_t)1 << 43,
-    (uint64_t)1 << 44, (uint64_t)1 << 45, (uint64_t)1 << 46, (uint64_t)1 << 47,  
-    (uint64_t)1 << 48, (uint64_t)1 << 49, (uint64_t)1 << 50, (uint64_t)1 << 51,
-    (uint64_t)1 << 52, (uint64_t)1 << 53, (uint64_t)1 << 54, (uint64_t)1 << 55,  
-    (uint64_t)1 << 56, (uint64_t)1 << 57, (uint64_t)1 << 58, (uint64_t)1 << 59,
-    (uint64_t)1 << 60, (uint64_t)1 << 61, (uint64_t)1 << 62, (uint64_t)1 << 63
-    };
-
-    /* Precomputed test to verify if remainder of block is set (or not) */
-    static const uint64_t bitmask_remain[64] = {
-    BS_MAX, BS_MAX - (BS_MAX >> 63), BS_MAX - (BS_MAX >> 62),
-    BS_MAX - (BS_MAX >> 61), BS_MAX - (BS_MAX >> 60), BS_MAX - (BS_MAX >> 59),
-    BS_MAX - (BS_MAX >> 58), BS_MAX - (BS_MAX >> 57), BS_MAX - (BS_MAX >> 56), 
-    BS_MAX - (BS_MAX >> 55), BS_MAX - (BS_MAX >> 54), BS_MAX - (BS_MAX >> 53), 
-    BS_MAX - (BS_MAX >> 52), BS_MAX - (BS_MAX >> 51), BS_MAX - (BS_MAX >> 50), 
-    BS_MAX - (BS_MAX >> 49), BS_MAX - (BS_MAX >> 48), BS_MAX - (BS_MAX >> 47), 
-    BS_MAX - (BS_MAX >> 46), BS_MAX - (BS_MAX >> 45), BS_MAX - (BS_MAX >> 44), 
-    BS_MAX - (BS_MAX >> 43), BS_MAX - (BS_MAX >> 42), BS_MAX - (BS_MAX >> 41), 
-    BS_MAX - (BS_MAX >> 40), BS_MAX - (BS_MAX >> 39), BS_MAX - (BS_MAX >> 38), 
-    BS_MAX - (BS_MAX >> 37), BS_MAX - (BS_MAX >> 36), BS_MAX - (BS_MAX >> 35), 
-    BS_MAX - (BS_MAX >> 34), BS_MAX - (BS_MAX >> 33), BS_MAX - (BS_MAX >> 32), 
-    BS_MAX - (BS_MAX >> 31), BS_MAX - (BS_MAX >> 30), BS_MAX - (BS_MAX >> 29), 
-    BS_MAX - (BS_MAX >> 28), BS_MAX - (BS_MAX >> 27), BS_MAX - (BS_MAX >> 26), 
-    BS_MAX - (BS_MAX >> 25), BS_MAX - (BS_MAX >> 24), BS_MAX - (BS_MAX >> 23), 
-    BS_MAX - (BS_MAX >> 22), BS_MAX - (BS_MAX >> 21), BS_MAX - (BS_MAX >> 20), 
-    BS_MAX - (BS_MAX >> 19), BS_MAX - (BS_MAX >> 18), BS_MAX - (BS_MAX >> 17), 
-    BS_MAX - (BS_MAX >> 16), BS_MAX - (BS_MAX >> 15), BS_MAX - (BS_MAX >> 14), 
-    BS_MAX - (BS_MAX >> 13), BS_MAX - (BS_MAX >> 12), BS_MAX - (BS_MAX >> 11), 
-    BS_MAX - (BS_MAX >> 10), BS_MAX - (BS_MAX >> 9), BS_MAX - (BS_MAX >> 8), 
-    BS_MAX - (BS_MAX >> 7), BS_MAX - (BS_MAX >> 6), BS_MAX - (BS_MAX >> 5), 
-    BS_MAX - (BS_MAX >> 4), BS_MAX - (BS_MAX >> 3), BS_MAX - (BS_MAX >> 2),
-    BS_MAX - (BS_MAX >> 1)
-    };
-
-    int32_t i, count = ecs_vec_count(&iter->entity_filter->bs_terms);
-    flecs_bitset_term_t *terms = ecs_vec_first(&iter->entity_filter->bs_terms);
-    int32_t bs_offset = table->_->bs_offset;
-    int32_t first = iter->bs_offset;
-    int32_t last = 0;
-
-    for (i = 0; i < count; i ++) {
-        flecs_bitset_term_t *column = &terms[i];
-        ecs_bitset_t *bs = terms[i].bs_column;
-
-        if (!bs) {
-            int32_t index = column->column_index;
-            ecs_assert((index - bs_offset >= 0), ECS_INTERNAL_ERROR, NULL);
-            bs = &table->_->bs_columns[index - bs_offset];
-            terms[i].bs_column = bs;
-        }
-        
-        int32_t bs_elem_count = bs->count;
-        int32_t bs_block = first >> 6;
-        int32_t bs_block_count = ((bs_elem_count - 1) >> 6) + 1;
-
-        if (bs_block >= bs_block_count) {
-            goto done;
-        }
-
-        uint64_t *data = bs->data;
-        int32_t bs_start = first & 0x3F;
-
-        /* Step 1: find the first non-empty block */
-        uint64_t v = data[bs_block];
-        uint64_t remain = bitmask_remain[bs_start];
-        while (!(v & remain)) {
-            /* If no elements are remaining, move to next block */
-            if ((++bs_block) >= bs_block_count) {
-                /* No non-empty blocks left */
-                goto done;
-            }
-
-            bs_start = 0;
-            remain = BS_MAX; /* Test the full block */
-            v = data[bs_block];
-        }
-
-        /* Step 2: find the first non-empty element in the block */
-        while (!(v & bitmask[bs_start])) {
-            bs_start ++;
-
-            /* Block was not empty, so bs_start must be smaller than 64 */
-            ecs_assert(bs_start < 64, ECS_INTERNAL_ERROR, NULL);
-        }
-
-        /* Step 3: Find number of contiguous enabled elements after start */
-        int32_t bs_end = bs_start, bs_block_end = bs_block;
-
-        remain = bitmask_remain[bs_end];
-        while ((v & remain) == remain) {
-            bs_end = 0;
-            bs_block_end ++;
-
-            if (bs_block_end == bs_block_count) {
-                break;
-            }
-
-            v = data[bs_block_end];
-            remain = BS_MAX; /* Test the full block */
-        }
-
-        /* Step 4: find remainder of enabled elements in current block */
-        if (bs_block_end != bs_block_count) {
-            while ((v & bitmask[bs_end])) {
-                bs_end ++;
-            }
-        }
-
-        /* Block was not 100% occupied, so bs_start must be smaller than 64 */
-        ecs_assert(bs_end < 64, ECS_INTERNAL_ERROR, NULL);
-
-        /* Step 5: translate to element start/end and make sure that each column
-         * range is a subset of the previous one. */
-        first = bs_block * 64 + bs_start;
-        int32_t cur_last = bs_block_end * 64 + bs_end;
-        
-        /* No enabled elements found in table */
-        if (first == cur_last) {
-            goto done;
-        }
-
-        /* If multiple bitsets are evaluated, make sure each subsequent range
-         * is equal or a subset of the previous range */
-        if (i) {
-            /* If the first element of a subsequent bitset is larger than the
-             * previous last value, start over. */
-            if (first >= last) {
-                i = -1;
-                continue;
-            }
-
-            /* Make sure the last element of the range doesn't exceed the last
-             * element of the previous range. */
-            if (cur_last > last) {
-                cur_last = last;
-            }
-        }
-
-        last = cur_last;
-        int32_t elem_count = last - first;
-
-        /* Make sure last element doesn't exceed total number of elements in 
-         * the table */
-        if (elem_count > (bs_elem_count - first)) {
-            elem_count = (bs_elem_count - first);
-            if (!elem_count) {
-                iter->bs_offset = 0;
-                goto done;
-            }
-        }
-        
-        iter->range.offset = first;
-        iter->range.count = elem_count;
-        iter->bs_offset = first;
-    }
-
-    /* Keep track of last processed element for iteration */ 
-    iter->bs_offset = last;
-
-    return 0;
-done:
-    iter->sw_smallest = 0;
-    iter->sw_offset = 0;
-    return -1;
-}
-
-#undef BS_MAX
-
-static
-int32_t flecs_get_flattened_target(
-    ecs_world_t *world,
-    EcsFlattenTarget *cur,
-    ecs_entity_t rel,
-    ecs_id_t id,
-    ecs_entity_t *src_out,
-    ecs_table_record_t **tr_out)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return -1;
-    }
-
-    ecs_record_t *r = cur->target;
-    ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_table_t *table = r->table;
-    if (!table) {
-        return -1;
-    }
-
-    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
-    if (tr) {
-        *src_out = ecs_record_get_entity(r);
-        *tr_out = tr;
-        return tr->index;
-    }
-
-    if (table->flags & EcsTableHasTarget) {
-        int32_t col = table->column_map[table->_->ft_offset];
-        ecs_assert(col != -1, ECS_INTERNAL_ERROR, NULL);
-        EcsFlattenTarget *next = table->data.columns[col].data.array;
-        next = ECS_ELEM_T(next, EcsFlattenTarget, ECS_RECORD_TO_ROW(r->row));
-        return flecs_get_flattened_target(
-            world, next, rel, id, src_out, tr_out);
-    }
-
-    return ecs_search_relation(
-        world, table, 0, id, rel, EcsSelf|EcsUp, src_out, NULL, tr_out);
-}
-
-void flecs_entity_filter_init(
-    ecs_world_t *world,
-    ecs_entity_filter_t **entity_filter,
-    const ecs_filter_t *filter,
-    const ecs_table_t *table,
-    ecs_id_t *ids,
-    int32_t *columns)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(entity_filter != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(filter != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(ids != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(columns != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_allocator_t *a = &world->allocator;
-    ecs_entity_filter_t ef;
-    ecs_os_zeromem(&ef);
-    ecs_vec_t *sw_terms = &ef.sw_terms;
-    ecs_vec_t *bs_terms = &ef.bs_terms;
-    ecs_vec_t *ft_terms = &ef.ft_terms;
-    if (*entity_filter) {
-        ef.sw_terms = (*entity_filter)->sw_terms;
-        ef.bs_terms = (*entity_filter)->bs_terms;
-        ef.ft_terms = (*entity_filter)->ft_terms;
-    }
-    ecs_vec_reset_t(a, sw_terms, flecs_switch_term_t);
-    ecs_vec_reset_t(a, bs_terms, flecs_bitset_term_t);
-    ecs_vec_reset_t(a, ft_terms, flecs_flat_table_term_t);
-    ecs_term_t *terms = filter->terms;
-    int32_t i, term_count = filter->term_count;
-    bool has_filter = false;
-    ef.flat_tree_column = -1;
-
-    /* Look for union fields */
-    if (table->flags & EcsTableHasUnion) {
-        for (i = 0; i < term_count; i ++) {
-            if (ecs_term_match_0(&terms[i])) {
-                continue;
-            }
-
-            ecs_id_t id = terms[i].id;
-            if (ECS_HAS_ID_FLAG(id, PAIR) && ECS_PAIR_SECOND(id) == EcsWildcard) {
-                continue;
-            }
-            
-            int32_t field = terms[i].field_index;
-            int32_t column = columns[field];
-            if (column <= 0) {
-                continue;
-            }
-
-            ecs_id_t table_id = table->type.array[column - 1];
-            if (ECS_PAIR_FIRST(table_id) != EcsUnion) {
-                continue;
-            }
-
-            flecs_switch_term_t *el = ecs_vec_append_t(a, sw_terms, 
-                flecs_switch_term_t);
-            el->signature_column_index = field;
-            el->sw_case = ecs_pair_second(world, id);
-            el->sw_column = NULL;
-            ids[field] = id;
-            has_filter = true;
-        }
-    }
-
-    /* Look for disabled fields */
-    if (table->flags & EcsTableHasToggle) {
-        for (i = 0; i < term_count; i ++) {
-            if (ecs_term_match_0(&terms[i])) {
-                continue;
-            }
-
-            int32_t field = terms[i].field_index;
-            ecs_id_t id = ids[field];
-            ecs_id_t bs_id = ECS_TOGGLE | id;
-            int32_t bs_index = ecs_table_get_type_index(world, table, bs_id);
-
-            if (bs_index != -1) {
-                flecs_bitset_term_t *bc = ecs_vec_append_t(a, bs_terms, 
-                    flecs_bitset_term_t);
-                bc->column_index = bs_index;
-                bc->bs_column = NULL;
-                has_filter = true;
-            }
-        }
-    }
-
-    /* Look for flattened fields */
-    if (table->flags & EcsTableHasTarget) {
-        const ecs_table_record_t *tr = flecs_table_record_get(world, table, 
-            ecs_pair_t(EcsFlattenTarget, EcsWildcard));
-        ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-        int32_t column = tr->index;
-        ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL);
-        ecs_entity_t rel = ecs_pair_second(world, table->type.array[column]);
-
-        for (i = 0; i < term_count; i ++) {
-            if (ecs_term_match_0(&terms[i])) {
-                continue;
-            }
-
-            if (terms[i].src.trav == rel) {
-                ef.flat_tree_column = table->column_map[column];
-                ecs_assert(ef.flat_tree_column != -1, 
-                    ECS_INTERNAL_ERROR, NULL);
-                has_filter = true;
-                
-                flecs_flat_table_term_t *term = ecs_vec_append_t(
-                    a, ft_terms, flecs_flat_table_term_t);
-                term->field_index = terms[i].field_index;
-                term->term = &terms[i];
-                ecs_os_zeromem(&term->monitor);
-            }
-        }
-    }
-
-    if (has_filter) {
-        if (!*entity_filter) {
-            *entity_filter = ecs_os_malloc_t(ecs_entity_filter_t);
-        }
-        ecs_assert(*entity_filter != NULL, ECS_OUT_OF_MEMORY, NULL);
-        **entity_filter = ef;
-    }
-}
-
-void flecs_entity_filter_fini(
-    ecs_world_t *world,
-    ecs_entity_filter_t *ef)
-{
-    if (!ef) {
-        return;
-    }
-
-    ecs_allocator_t *a = &world->allocator;
-
-    flecs_flat_table_term_t *fields = ecs_vec_first(&ef->ft_terms);
-    int32_t i, term_count = ecs_vec_count(&ef->ft_terms);
-    for (i = 0; i < term_count; i ++) {
-        ecs_vec_fini_t(NULL, &fields[i].monitor, flecs_flat_monitor_t);
-    }
-
-    ecs_vec_fini_t(a, &ef->sw_terms, flecs_switch_term_t);
-    ecs_vec_fini_t(a, &ef->bs_terms, flecs_bitset_term_t);
-    ecs_vec_fini_t(a, &ef->ft_terms, flecs_flat_table_term_t);
-    ecs_os_free(ef);
-}
-
-int flecs_entity_filter_next(
-    ecs_entity_filter_iter_t *it)
-{
-    ecs_table_t *table = it->range.table;
-    flecs_switch_term_t *sw_terms = ecs_vec_first(&it->entity_filter->sw_terms);
-    flecs_bitset_term_t *bs_terms = ecs_vec_first(&it->entity_filter->bs_terms);
-    ecs_entity_filter_t *ef = it->entity_filter;
-    int32_t flat_tree_column = ef->flat_tree_column;
-    ecs_table_range_t *range = &it->range;
-    int32_t range_end = range->offset + range->count;
-    int result = EcsIterNext;
-    bool found = false;
-
-    do {
-        found = false;
-
-        if (bs_terms) {
-            if (flecs_entity_filter_bitset_next(table, it) == -1) {
-                /* No more enabled components for table */
-                it->bs_offset = 0;
-                break;
-            } else {
-                result = EcsIterYield;
-                found = true;
-            }
-        }
-
-        if (sw_terms) {
-            if (flecs_entity_filter_switch_next(table, it, found) == -1) {
-                /* No more elements in sparse column */
-                if (found) {
-                    /* Try again */
-                    result = EcsIterNext;
-                    found = false;
-                } else {
-                    /* Nothing found */
-                    it->bs_offset = 0;
-                    break;
-                }
-            } else {
-                result = EcsIterYield;
-                found = true;
-                it->bs_offset = range->offset + range->count;
-            }
-        }
-
-        if (flat_tree_column != -1) {
-            bool first_for_table = it->prev != table;
-            ecs_iter_t *iter = it->it;
-            ecs_world_t *world = iter->real_world;
-            EcsFlattenTarget *ft = table->data.columns[flat_tree_column].data.array;
-            int32_t ft_offset;
-            int32_t ft_count;
-
-            if (first_for_table) {
-                ft_offset = it->flat_tree_offset = range->offset;
-                it->target_count = 1;
-            } else {
-                it->flat_tree_offset += ft[it->flat_tree_offset].count;
-                ft_offset = it->flat_tree_offset;
-                it->target_count ++;
-            }
-
-            ecs_assert(ft_offset < ecs_table_count(table), 
-                ECS_INTERNAL_ERROR, NULL);
-
-            EcsFlattenTarget *cur = &ft[ft_offset];
-            ft_count = cur->count;
-            bool is_last = (ft_offset + ft_count) >= range_end;
-
-            int32_t i, field_count = ecs_vec_count(&ef->ft_terms);
-            flecs_flat_table_term_t *fields = ecs_vec_first(&ef->ft_terms);
-            for (i = 0; i < field_count; i ++) {
-                flecs_flat_table_term_t *field = &fields[i];
-                ecs_vec_init_if_t(&field->monitor, flecs_flat_monitor_t);
-                int32_t field_index = field->field_index;
-                ecs_id_t id = it->it->ids[field_index];
-                ecs_id_t flat_pair = table->type.array[flat_tree_column];
-                ecs_entity_t rel = ECS_PAIR_FIRST(flat_pair);
-                ecs_entity_t tgt;
-                ecs_table_record_t *tr;
-                int32_t tgt_col = flecs_get_flattened_target(
-                    world, cur, rel, id, &tgt, &tr);
-                if (tgt_col != -1) {
-                    iter->sources[field_index] = tgt;
-                    iter->columns[field_index] = /* encode flattened field */
-                        -(iter->field_count + tgt_col + 1);
-                    ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
-
-                    /* Keep track of maximum value encountered in target table
-                     * dirty state so this doesn't have to be recomputed when
-                     * synchronizing the query monitor. */
-                    ecs_vec_set_min_count_zeromem_t(NULL, &field->monitor, 
-                        flecs_flat_monitor_t, it->target_count);
-                    ecs_table_t *tgt_table = tr->hdr.table;
-                    int32_t *ds = flecs_table_get_dirty_state(world, tgt_table);
-                    ecs_assert(ds != NULL, ECS_INTERNAL_ERROR, NULL);
-                    ecs_vec_get_t(&field->monitor, flecs_flat_monitor_t, 
-                        it->target_count - 1)->table_state = ds[tgt_col + 1];
-                } else {
-                    if (field->term->oper == EcsOptional) {
-                        iter->columns[field_index] = 0;
-                        iter->ptrs[field_index] = NULL;
-                    } else {
-                        it->prev = NULL;
-                        break;
-                    }
-                }
-            }
-            if (i != field_count) {
-                if (is_last) {
-                    break;
-                }
-            } else {
-                found = true;
-                if ((ft_offset + ft_count) == range_end) {
-                    result = EcsIterNextYield;
-                } else {
-                    result = EcsIterYield;
-                }
-            }
-
-            range->offset = ft_offset;
-            range->count = ft_count;
-            it->prev = table;
-        }
-    } while (!found);
-
-    it->prev = table;
-
-    if (!found) {
-        return EcsIterNext;
-    } else {
-        return result;
-    }
-}
diff --git a/src/entity_name.c b/src/entity_name.c
index 9d7d68b07..c36fb7e16 100644
--- a/src/entity_name.c
+++ b/src/entity_name.c
@@ -17,7 +17,7 @@ bool flecs_path_append(
     const char *prefix,
     ecs_strbuf_t *buf)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(sep[0] != 0, ECS_INVALID_PARAMETER, NULL);
 
     ecs_entity_t cur = 0;
@@ -212,7 +212,7 @@ ecs_entity_t flecs_get_parent_from_path(
 
 static
 void flecs_on_set_symbol(ecs_iter_t *it) {
-    EcsIdentifier *n = ecs_field(it, EcsIdentifier, 1);
+    EcsIdentifier *n = ecs_field(it, EcsIdentifier, 0);
     ecs_world_t *world = it->world;
 
     int i;
@@ -225,10 +225,10 @@ void flecs_on_set_symbol(ecs_iter_t *it) {
 
 void flecs_bootstrap_hierarchy(ecs_world_t *world) {
     ecs_observer(world, {
-        .entity = ecs_entity(world, {.add = {ecs_childof(EcsFlecsInternals)}}),
-        .filter.terms[0] = {
+        .entity = ecs_entity(world, { .parent = EcsFlecsInternals }),
+        .query.terms[0] = {
             .id = ecs_pair(ecs_id(EcsIdentifier), EcsSymbol), 
-            .src.flags = EcsSelf 
+            .src.id = EcsSelf 
         },
         .callback = flecs_on_set_symbol,
         .events = {EcsOnSet},
@@ -510,7 +510,7 @@ const char* ecs_set_name_prefix(
     ecs_world_t *world,
     const char *prefix)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     const char *old_prefix = world->info.name_prefix;
     world->info.name_prefix = prefix;
     return old_prefix;
@@ -560,7 +560,7 @@ ecs_entity_t ecs_add_path_w_sep(
 
     if (!path) {
         if (!entity) {
-            entity = ecs_new_id(world);
+            entity = ecs_new(world);
         }
 
         if (parent) {
@@ -623,10 +623,10 @@ ecs_entity_t ecs_add_path_w_sep(
                 if (!e) {
                     if (last_elem) {
                         ecs_entity_t prev = ecs_set_scope(world, 0);
-                        e = ecs_new(world, 0);
+                        e = ecs_entity(world, {0});
                         ecs_set_scope(world, prev);
                     } else {
-                        e = ecs_new_id(world);
+                        e = ecs_new(world);
                     }
                 }
 
diff --git a/src/filter.c b/src/filter.c
deleted file mode 100644
index 0be6c4da7..000000000
--- a/src/filter.c
+++ /dev/null
@@ -1,3357 +0,0 @@
-/**
- * @file filter.c
- * @brief Uncached query implementation.
- * 
- * Uncached queries (filters) are stateless objects that do not cache their 
- * results. This file contains the creation and validation of uncached queries
- * and code for query iteration.
- * 
- * There file contains the implementation for term queries and filters. Term 
- * queries are uncached queries that only apply to a single term. Filters are
- * uncached queries that support multiple terms. Filters are built on top of
- * term queries: before iteration a filter will first find a "pivot" term (the
- * term with the smallest number of elements), and create a term iterator for
- * it. The output of that term iterator is then evaluated against the rest of
- * the terms of the filter.
- * 
- * Cached queries and observers are built using filters.
- */
-
-#include "private_api.h"
-#include <ctype.h>
-
-ecs_filter_t ECS_FILTER_INIT = { .hdr = { .magic = ecs_filter_t_magic }};
-
-/* Helper type for passing around context required for error messages */
-typedef struct {
-    const ecs_world_t *world;
-    ecs_filter_t *filter;
-    ecs_term_t *term;
-    int32_t term_index;
-} ecs_filter_finalize_ctx_t;
-
-static
-char* flecs_filter_str(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter,
-    const ecs_filter_finalize_ctx_t *ctx,
-    int32_t *term_start_out);
-
-static
-void flecs_filter_error(
-    const ecs_filter_finalize_ctx_t *ctx,
-    const char *fmt,
-    ...)
-{
-    va_list args;
-    va_start(args, fmt);
-
-    int32_t term_start = 0;
-
-    char *expr = NULL;
-    if (ctx->filter) {
-        expr = flecs_filter_str(ctx->world, ctx->filter, ctx, &term_start);
-    } else {
-        expr = ecs_term_str(ctx->world, ctx->term);
-    }
-    const char *name = NULL;
-    if (ctx->filter && ctx->filter->entity) {
-        name = ecs_get_name(ctx->filter->world, ctx->filter->entity);
-    }
-    ecs_parser_errorv(name, expr, term_start, fmt, args);
-    ecs_os_free(expr);
-
-    va_end(args);
-}
-
-static
-int flecs_term_id_finalize_flags(
-    ecs_term_id_t *term_id,
-    ecs_filter_finalize_ctx_t *ctx)
-{
-    if ((term_id->flags & EcsIsEntity) && (term_id->flags & EcsIsVariable)) {
-        flecs_filter_error(ctx, "cannot set both IsEntity and IsVariable");
-        return -1;
-    }
-
-    if (term_id->name && term_id->name[0] == '$' && term_id->name[1]) {
-        term_id->flags |= EcsIsVariable;
-    }
-
-    if (!(term_id->flags & (EcsIsEntity|EcsIsVariable|EcsIsName))) {
-        if (term_id->id || term_id->name) {
-            if (term_id->id == EcsThis || 
-                term_id->id == EcsWildcard || 
-                term_id->id == EcsAny || 
-                term_id->id == EcsVariable) 
-            {
-                /* Builtin variable ids default to variable */
-                term_id->flags |= EcsIsVariable;
-            } else {
-                term_id->flags |= EcsIsEntity;
-            }
-        }
-    }
-
-    if (term_id->flags & EcsParent) {
-        term_id->flags |= EcsUp;
-        term_id->trav = EcsChildOf;
-    }
-
-    if ((term_id->flags & EcsCascade) && !(term_id->flags & (EcsUp|EcsDown))) {
-        term_id->flags |= EcsUp;
-    }
-
-    if ((term_id->flags & (EcsUp|EcsDown)) && !term_id->trav) {
-        term_id->trav = EcsIsA;
-    }
-
-    if (term_id->trav && !(term_id->flags & EcsTraverseFlags)) {
-        term_id->flags |= EcsUp;
-    }
-
-    return 0;
-}
-
-static
-int flecs_term_id_lookup(
-    const ecs_world_t *world,
-    ecs_entity_t scope,
-    ecs_term_id_t *term_id,
-    bool free_name,
-    ecs_filter_finalize_ctx_t *ctx)
-{
-    const char *name = term_id->name;
-    if (!name) {
-        return 0;
-    }
-
-    if (term_id->flags & EcsIsVariable) {
-        if (!ecs_os_strcmp(name, "This") || !ecs_os_strcmp(name, "this")) {
-            term_id->id = EcsThis;
-            if (free_name) {
-                /* Safe, if free_name is true the filter owns the name */
-                ecs_os_free(ECS_CONST_CAST(char*, term_id->name));
-            }
-            term_id->name = NULL;
-        }
-        return 0;
-    } else if (term_id->flags & EcsIsName) {
-        return 0;
-    }
-
-    ecs_assert(term_id->flags & EcsIsEntity, ECS_INTERNAL_ERROR, NULL);
-
-    if (ecs_identifier_is_0(name)) {
-        if (term_id->id) {
-            flecs_filter_error(ctx, "name '0' does not match entity id");
-            return -1;
-        }
-        return 0;
-    }
-
-    ecs_entity_t e;
-    if (scope) {
-        e = ecs_lookup_child(world, scope, name);
-        if (!e) {
-            /* Support wildcards and fully qualified paths */
-            e = ecs_lookup_symbol(world, name, true, true);
-        }
-    } else {
-        e = ecs_lookup_symbol(world, name, true, true);
-    }
-
-    if (!e) {
-        if (ctx->filter && (ctx->filter->flags & EcsFilterUnresolvedByName)) {
-            term_id->flags |= EcsIsName;
-            term_id->flags &= ~EcsIsEntity;
-        } else {
-            flecs_filter_error(ctx, "unresolved identifier '%s'", name);
-            return -1;
-        }
-    }
-
-    if (term_id->id && term_id->id != e) {
-        char *e_str = ecs_get_fullpath(world, term_id->id);
-        flecs_filter_error(ctx, "name '%s' does not match term.id '%s'", 
-            name, e_str);
-        ecs_os_free(e_str);
-        return -1;
-    }
-
-    term_id->id = e;
-
-    if (!ecs_os_strcmp(name, "*") || !ecs_os_strcmp(name, "_") || 
-        !ecs_os_strcmp(name, "$")) 
-    {
-        term_id->flags &= ~EcsIsEntity;
-        term_id->flags |= EcsIsVariable;
-    }
-
-    /* Check if looked up id is alive (relevant for numerical ids) */
-    if (!(term_id->flags & EcsIsName)) {
-        if (!ecs_is_alive(world, term_id->id)) {
-            flecs_filter_error(ctx, "identifier '%s' is not alive", term_id->name);
-            return -1;
-        }
-
-        if (free_name) {
-            /* Safe, if free_name is true, the filter owns the name */
-            ecs_os_free(ECS_CONST_CAST(char*, name));
-        }
-
-        term_id->name = NULL;
-    }
-
-    return 0;
-}
-
-static
-int flecs_term_ids_finalize(
-    const ecs_world_t *world,
-    ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
-{
-    ecs_term_id_t *src = &term->src;
-    ecs_term_id_t *first = &term->first;
-    ecs_term_id_t *second = &term->second;
-
-    /* Include inherited components (like from prefabs) by default for src */
-    if (!(src->flags & EcsTraverseFlags)) {
-        src->flags |= EcsSelf | EcsUp;
-    }
-
-    /* Include subsets for component by default, to support inheritance */
-    if (!(first->flags & EcsTraverseFlags)) {
-        first->flags |= EcsSelf;
-        if (first->id && first->flags & EcsIsEntity) {
-            if (flecs_id_record_get(world, ecs_pair(EcsIsA, first->id))) {
-                first->flags |= EcsDown;
-            }
-        }
-    }
-
-    /* Traverse Self by default for pair target */
-    if (!(second->flags & EcsTraverseFlags)) {
-        second->flags |= EcsSelf;
-    }
-
-    /* Source defaults to This */
-    if ((src->id == 0) && (src->name == NULL) && !(src->flags & EcsIsEntity)) {
-        src->id = EcsThis;
-        src->flags |= EcsIsVariable;
-    }
-
-    /* Initialize term identifier flags */
-    if (flecs_term_id_finalize_flags(src, ctx)) {
-        return -1;
-    }
-    if (flecs_term_id_finalize_flags(first, ctx)) {
-        return -1;
-    }
-
-    if (flecs_term_id_finalize_flags(second, ctx)) {
-        return -1;
-    }
-
-    /* Lookup term identifiers by name */
-    if (flecs_term_id_lookup(world, 0, src, term->move, ctx)) {
-        return -1;
-    }
-    if (flecs_term_id_lookup(world, 0, first, term->move, ctx)) {
-        return -1;
-    }
-
-    ecs_entity_t first_id = 0;
-    ecs_entity_t oneof = 0;
-    if (first->flags & EcsIsEntity) {
-        first_id = first->id;
-
-        /* If first element of pair has OneOf property, lookup second element of
-         * pair in the value of the OneOf property */
-        oneof = flecs_get_oneof(world, first_id);
-    }
-
-    if (flecs_term_id_lookup(world, oneof, &term->second, term->move, ctx)) {
-        return -1;
-    }
-
-    /* If source is 0, reset traversal flags */
-    if (src->id == 0 && src->flags & EcsIsEntity) {
-        src->flags &= ~EcsTraverseFlags;
-        src->trav = 0;
-    }
-    /* If second is 0, reset traversal flags */
-    if (second->id == 0 && second->flags & EcsIsEntity) {
-        second->flags &= ~EcsTraverseFlags;
-        second->trav = 0;
-    }
-
-    /* If source is wildcard, term won't return any data */
-    if ((src->flags & EcsIsVariable) && ecs_id_is_wildcard(src->id)) {
-        term->inout = EcsInOutNone;
-    }
-
-    return 0;
-}
-
-static
-ecs_entity_t flecs_term_id_get_entity(
-    const ecs_term_id_t *term_id)
-{
-    if (term_id->flags & EcsIsEntity) {
-        return term_id->id; /* Id is known */
-    } else if (term_id->flags & EcsIsVariable) {
-        /* Return wildcard for variables, as they aren't known yet */
-        if (term_id->id != EcsAny) {
-            /* Any variable should not use wildcard, as this would return all
-             * ids matching a wildcard, whereas Any returns the first match */
-            return EcsWildcard;
-        } else {
-            return EcsAny;
-        }
-    } else {
-        return 0; /* Term id is uninitialized */
-    }
-}
-
-static
-int flecs_term_populate_id(
-    ecs_term_t *term)
-{
-    ecs_entity_t first = flecs_term_id_get_entity(&term->first);
-    ecs_entity_t second = flecs_term_id_get_entity(&term->second);
-    ecs_id_t role = term->id_flags;
-
-    if (first & ECS_ID_FLAGS_MASK) {
-        return -1;
-    }
-    if (second & ECS_ID_FLAGS_MASK) {
-        return -1;
-    }
-
-    if ((second || term->second.flags == EcsIsEntity)) {
-        role = term->id_flags |= ECS_PAIR;
-    }
-
-    if (!second && !ECS_HAS_ID_FLAG(role, PAIR)) {
-        term->id = first | role;
-    } else {
-        term->id = ecs_pair(first, second) | role;
-    }
-
-    return 0;
-}
-
-static
-int flecs_term_populate_from_id(
-    const ecs_world_t *world,
-    ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
-{
-    ecs_entity_t first = 0;
-    ecs_entity_t second = 0;
-    ecs_id_t role = term->id & ECS_ID_FLAGS_MASK;
-
-    if (!role && term->id_flags) {
-        role = term->id_flags;
-        term->id |= role;
-    }
-
-    if (term->id_flags && term->id_flags != role) {
-        flecs_filter_error(ctx, "mismatch between term.id & term.id_flags");
-        return -1;
-    }
-
-    term->id_flags = role;
-
-    if (ECS_HAS_ID_FLAG(term->id, PAIR)) {
-        first = ECS_PAIR_FIRST(term->id);
-        second = ECS_PAIR_SECOND(term->id);
-
-        if (!first) {
-            flecs_filter_error(ctx, "missing first element in term.id");
-            return -1;
-        }
-        if (!second) {
-            if (first != EcsChildOf) {
-                flecs_filter_error(ctx, "missing second element in term.id");
-                return -1;
-            } else {
-                /* (ChildOf, 0) is allowed so filter can be used to efficiently
-                 * query for root entities */
-            }
-        }
-    } else {
-        first = term->id & ECS_COMPONENT_MASK;
-        if (!first) {
-            flecs_filter_error(ctx, "missing first element in term.id");
-            return -1;
-        }
-    }
-
-    ecs_entity_t term_first = flecs_term_id_get_entity(&term->first);
-    if (term_first) {
-        if ((uint32_t)term_first != (uint32_t)first) {
-            flecs_filter_error(ctx, "mismatch between term.id and term.first");
-            return -1;
-        }
-    } else {
-        if (!(term->first.id = ecs_get_alive(world, first))) {
-            term->first.id = first;
-        }
-    }
-
-    ecs_entity_t term_second = flecs_term_id_get_entity(&term->second);
-    if (term_second) {
-        if ((uint32_t)term_second != second) {
-            flecs_filter_error(ctx, "mismatch between term.id and term.second");
-            return -1;
-        }
-    } else if (second) {
-        if (!(term->second.id = ecs_get_alive(world, second))) {
-            term->second.id = second;
-        }
-    }
-
-    return 0;
-}
-
-static
-int flecs_term_verify_eq_pred(
-    const ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
-{
-    ecs_entity_t first_id = term->first.id;
-    const ecs_term_id_t *second = &term->second;
-    const ecs_term_id_t *src = &term->src;
-
-    if (term->oper != EcsAnd && term->oper != EcsNot && term->oper != EcsOr) {
-        flecs_filter_error(ctx, "invalid operator combination");
-        goto error;
-    }
-
-    if ((src->flags & EcsIsName) && (second->flags & EcsIsName)) {
-        flecs_filter_error(ctx, "both sides of operator cannot be a name");
-        goto error;
-    }
-
-    if ((src->flags & EcsIsEntity) && (second->flags & EcsIsEntity)) {
-        flecs_filter_error(ctx, "both sides of operator cannot be an entity");
-        goto error;
-    }
-
-    if (!(src->flags & EcsIsVariable)) {
-        flecs_filter_error(ctx, "left-hand of operator must be a variable");
-        goto error;
-    }
-
-    if (first_id == EcsPredMatch && !(second->flags & EcsIsName)) {
-        flecs_filter_error(ctx, "right-hand of match operator must be a string");
-        goto error;
-    }
-
-    if ((src->flags & EcsIsVariable) && (second->flags & EcsIsVariable)) {
-        if (src->id && src->id == second->id) {
-            flecs_filter_error(ctx, "both sides of operator are equal");
-            goto error;
-        }
-        if (src->name && second->name && !ecs_os_strcmp(src->name, second->name)) {
-            flecs_filter_error(ctx, "both sides of operator are equal");
-            goto error;
-        }
-    }
-
-    return 0;
-error:
-    return -1;
-}
-
-static
-int flecs_term_verify(
-    const ecs_world_t *world,
-    const ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
-{
-    const ecs_term_id_t *first = &term->first;
-    const ecs_term_id_t *second = &term->second;
-    const ecs_term_id_t *src = &term->src;
-    ecs_entity_t first_id = 0, second_id = 0;
-    ecs_id_t role = term->id_flags;
-    ecs_id_t id = term->id;
-
-    if ((src->flags & EcsIsName) && (second->flags & EcsIsName)) {
-        flecs_filter_error(ctx, "mismatch between term.id_flags & term.id");
-        return -1;
-    }
-
-    if (first->flags & EcsIsEntity) {
-        first_id = first->id;
-    }
-    if (second->flags & EcsIsEntity) {
-        second_id = second->id;
-    }
-
-    if (first_id == EcsPredEq || first_id == EcsPredMatch || first_id == EcsPredLookup) {
-        return flecs_term_verify_eq_pred(term, ctx);
-    }
-
-    if (role != (id & ECS_ID_FLAGS_MASK)) {
-        flecs_filter_error(ctx, "mismatch between term.id_flags & term.id");
-        return -1;
-    }
-
-    if (ecs_term_id_is_set(second) && !ECS_HAS_ID_FLAG(role, PAIR)) {
-        flecs_filter_error(ctx, "expected PAIR flag for term with pair");
-        return -1;
-    } else if (!ecs_term_id_is_set(second) && ECS_HAS_ID_FLAG(role, PAIR)) {
-        if (first_id != EcsChildOf) {
-            flecs_filter_error(ctx, "unexpected PAIR flag for term without pair");
-            return -1;
-        } else {
-            /* Exception is made for ChildOf so we can use (ChildOf, 0) to match
-             * all entities in the root */
-        }
-    }
-
-    if (!ecs_term_id_is_set(src)) {
-        flecs_filter_error(ctx, "term.src is not initialized");
-        return -1;
-    }
-
-    if (!ecs_term_id_is_set(first)) {
-        flecs_filter_error(ctx, "term.first is not initialized");
-        return -1;
-    }
-
-    if (ECS_HAS_ID_FLAG(role, PAIR)) {
-        if (!ECS_PAIR_FIRST(id)) {
-            flecs_filter_error(ctx, "invalid 0 for first element in pair id");
-            return -1;
-        }
-        if ((ECS_PAIR_FIRST(id) != EcsChildOf) && !ECS_PAIR_SECOND(id)) {
-            flecs_filter_error(ctx, "invalid 0 for second element in pair id");
-            return -1;
-        }
-
-        if ((first->flags & EcsIsEntity) && 
-            (ecs_entity_t_lo(first_id) != ECS_PAIR_FIRST(id))) 
-        {
-            flecs_filter_error(ctx, "mismatch between term.id and term.first");
-            return -1;
-        }
-        if ((first->flags & EcsIsVariable) && 
-            !ecs_id_is_wildcard(ECS_PAIR_FIRST(id)))
-        {
-            char *id_str = ecs_id_str(world, id);
-            flecs_filter_error(ctx, 
-                "expected wildcard for variable term.first (got %s)", id_str);
-            ecs_os_free(id_str);
-            return -1;
-        }
-
-        if ((second->flags & EcsIsEntity) && 
-            (ecs_entity_t_lo(second_id) != ECS_PAIR_SECOND(id))) 
-        {
-            flecs_filter_error(ctx, "mismatch between term.id and term.second");
-            return -1;
-        }
-        if ((second->flags & EcsIsVariable) && 
-            !ecs_id_is_wildcard(ECS_PAIR_SECOND(id))) 
-        {
-            char *id_str = ecs_id_str(world, id);
-            flecs_filter_error(ctx, 
-                "expected wildcard for variable term.second (got %s)", id_str);
-            ecs_os_free(id_str);
-            return -1;
-        }
-    } else {
-        ecs_entity_t component = id & ECS_COMPONENT_MASK;
-        if (!component) {
-            flecs_filter_error(ctx, "missing component id");
-            return -1;
-        }
-        if ((first->flags & EcsIsEntity) && 
-            (ecs_entity_t_lo(first_id) != ecs_entity_t_lo(component))) 
-        {
-            flecs_filter_error(ctx, "mismatch between term.id and term.first");
-            return -1;
-        }
-        if ((first->flags & EcsIsVariable) && !ecs_id_is_wildcard(component)) {
-            char *id_str = ecs_id_str(world, id);
-            flecs_filter_error(ctx, 
-                "expected wildcard for variable term.first (got %s)", id_str);
-            ecs_os_free(id_str);
-            return -1;
-        }
-    }
-
-    if (first_id) {
-        if (ecs_term_id_is_set(second)) {
-            ecs_flags32_t mask = EcsIsEntity | EcsIsVariable;
-            if ((src->flags & mask) == (second->flags & mask)) {
-                bool is_same = false;
-                if (src->flags & EcsIsEntity) {
-                    is_same = src->id == second->id;
-                } else if (src->name && second->name) {
-                    is_same = !ecs_os_strcmp(src->name, second->name);
-                }
-
-                if (is_same && ecs_has_id(world, first_id, EcsAcyclic)
-                    && !(term->flags & EcsTermReflexive)) 
-                {
-                    char *pred_str = ecs_get_fullpath(world, term->first.id);
-                    flecs_filter_error(ctx, "term with acyclic relationship"
-                        " '%s' cannot have same subject and object",
-                            pred_str);
-                    ecs_os_free(pred_str);
-                    return -1;
-                }
-            }
-        }
-
-        if (second_id && !ecs_id_is_wildcard(second_id)) {
-            ecs_entity_t oneof = flecs_get_oneof(world, first_id);
-            if (oneof) {
-                if (!ecs_has_pair(world, second_id, EcsChildOf, oneof)) {
-                    char *second_str = ecs_get_fullpath(world, second_id);
-                    char *oneof_str = ecs_get_fullpath(world, oneof);
-                    char *id_str = ecs_id_str(world, term->id);
-                    flecs_filter_error(ctx, 
-                        "invalid target '%s' for %s: must be child of '%s'",
-                            second_str, id_str, oneof_str);
-                    ecs_os_free(second_str);
-                    ecs_os_free(oneof_str);
-                    ecs_os_free(id_str);
-                    return -1;
-                }
-            }
-        }
-    }
-
-    if (term->src.trav) {
-        if (!ecs_has_id(world, term->src.trav, EcsTraversable)) {
-            char *r_str = ecs_get_fullpath(world, term->src.trav);
-            flecs_filter_error(ctx, 
-                "cannot traverse non-traversable relationship '%s'", r_str);
-            ecs_os_free(r_str);
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
-static
-int flecs_term_finalize(
-    const ecs_world_t *world,
-    ecs_term_t *term,
-    ecs_filter_finalize_ctx_t *ctx)
-{
-    ctx->term = term;
-
-    ecs_term_id_t *src = &term->src;
-    ecs_term_id_t *first = &term->first;
-    ecs_term_id_t *second = &term->second;
-    ecs_flags32_t first_flags = first->flags;
-    ecs_flags32_t src_flags = src->flags;
-    ecs_flags32_t second_flags = second->flags;
-
-    if (term->id) {
-        if (flecs_term_populate_from_id(world, term, ctx)) {
-            return -1;
-        }
-    }
-
-    if (flecs_term_ids_finalize(world, term, ctx)) {
-        return -1;
-    }
-
-    if ((first->flags & EcsIsVariable) && (term->first.id == EcsAny)) {
-        term->flags |= EcsTermMatchAny;
-    }
-    if ((second->flags & EcsIsVariable) && (term->second.id == EcsAny)) {
-        term->flags |= EcsTermMatchAny;
-    }
-    if ((src->flags & EcsIsVariable) && (term->src.id == EcsAny)) {
-        term->flags |= EcsTermMatchAnySrc;
-    }
-
-    /* If EcsVariable is used by itself, assign to predicate (singleton) */
-    if ((src->id == EcsVariable) && (src->flags & EcsIsVariable)) {
-        src->id = first->id;
-        src->flags &= ~(EcsIsVariable | EcsIsEntity);
-        src->flags |= first->flags & (EcsIsVariable | EcsIsEntity);
-    }
-    if ((second->id == EcsVariable) && (second->flags & EcsIsVariable)) {
-        second->id = first->id;
-        second->flags &= ~(EcsIsVariable | EcsIsEntity);
-        second->flags |= first->flags & (EcsIsVariable | EcsIsEntity);
-    }
-
-    ecs_flags32_t mask = EcsIsEntity | EcsIsVariable;
-    if ((src->flags & mask) == (second->flags & mask)) {
-        bool is_same = false;
-        if (src->flags & EcsIsEntity) {
-            is_same = src->id == second->id;
-        } else if (src->name && second->name) {
-            is_same = !ecs_os_strcmp(src->name, second->name);
-        }
-        if (is_same) {
-            term->flags |= EcsTermSrcSecondEq;
-        }
-    }
-    if ((src->flags & mask) == (first->flags & mask)) {
-        bool is_same = false;
-        if (src->flags & EcsIsEntity) {
-            is_same = src->id == first->id;
-        } else if (src->name && first->name) {
-            is_same = !ecs_os_strcmp(src->name, first->name);
-        }
-        if (is_same) {
-            term->flags |= EcsTermSrcFirstEq;
-        }
-    }
-
-    if (!term->id) {
-        if (flecs_term_populate_id(term)) {
-            return -1;
-        }
-    }
-
-    /* If term queries for !(ChildOf, _), translate it to the builtin 
-     * (ChildOf, 0) index which is a cheaper way to find root entities */
-    if (term->oper == EcsNot && term->id == ecs_pair(EcsChildOf, EcsAny)) {
-        /* Only if the source is not EcsAny */
-        if (!(term->src.id == EcsAny && (term->src.flags & EcsIsVariable))) {
-            term->oper = EcsAnd;
-            term->id = ecs_pair(EcsChildOf, 0);
-            second->id = 0;
-            second->flags |= EcsIsEntity;
-            second->flags &= ~EcsIsVariable;
-        }
-    }
-
-    ecs_entity_t first_id = 0;
-    if (first->flags & EcsIsEntity) {
-        first_id = first->id;
-    }
-
-    term->idr = flecs_query_id_record_get(world, term->id);
-    ecs_flags32_t id_flags = term->idr ? term->idr->flags : 0;
-
-    if (first_id) {
-        ecs_entity_t first_trav = first->trav;
-
-        /* If component is inherited from, set correct traversal flags */
-        ecs_flags32_t first_trav_flags = first_flags & EcsTraverseFlags;
-        if (!first_trav && first_trav_flags != EcsSelf) {
-            /* Inheritance uses IsA by default, but can use any relationship */
-            first_trav = EcsIsA;
-        }
-
-        ecs_record_t *trav_record = NULL;
-        ecs_table_t *trav_table = NULL;
-        if (first_trav) {
-            trav_record = flecs_entities_get(world, first_trav);
-            trav_table = trav_record ? trav_record->table : NULL;
-            if (first_trav != EcsIsA) {
-                if (!trav_table || !ecs_table_has_id(world, trav_table, EcsTraversable)) {
-                    flecs_filter_error(ctx, "first.trav is not traversable");
-                    return -1;
-                }
-            }
-        }
-
-        /* Only enable inheritance for ids which are inherited from at the time
-         * of filter creation. To force component inheritance to be evaluated,
-         * an application can explicitly set traversal flags. */
-        if ((first_trav_flags & EcsDown) || 
-            flecs_id_record_get(world, ecs_pair(first_trav, first->id))) 
-        {
-            if (first_trav_flags == EcsSelf) {
-                flecs_filter_error(ctx, "first.trav specified with self");
-                return -1;
-            }
-
-            if (!first_trav_flags || (first_trav_flags & EcsDown)) {
-                term->flags |= EcsTermIdInherited;
-                first->trav = first_trav;
-                if (!first_trav_flags) {
-                    first->flags &= ~EcsTraverseFlags;
-                    first->flags |= EcsDown;
-                    ecs_assert(trav_table != NULL, ECS_INTERNAL_ERROR, NULL);
-                    if ((first_trav == EcsIsA) || ecs_table_has_id(
-                        world, trav_table, EcsReflexive)) 
-                    {
-                        first->flags |= EcsSelf;
-                    }
-                }
-            }
-        }
-
-        /* Don't traverse ids that cannot be inherited */
-        if ((id_flags & EcsIdDontInherit) && (src->trav == EcsIsA)) {
-            if (src_flags & (EcsUp | EcsDown)) {
-                flecs_filter_error(ctx, 
-                    "traversing not allowed for id that can't be inherited");
-                return -1;
-            }
-            src->flags &= ~(EcsUp | EcsDown);
-            src->trav = 0;
-        }
-
-        /* If component id is final, don't attempt component inheritance */
-        ecs_record_t *first_record = flecs_entities_get(world, first_id);
-        ecs_table_t *first_table = first_record ? first_record->table : NULL;
-        if (first_table) {
-            if (ecs_table_has_id(world, first_table, EcsFinal)) {
-                if (first_flags & EcsDown) {
-                    flecs_filter_error(ctx, "final id cannot be traversed down");
-                    return -1;
-                }
-            }
-
-            /* Add traversal flags for transitive relationships */
-            if (!(second_flags & EcsTraverseFlags) && ecs_term_id_is_set(second)) {
-                if (!((src->flags & EcsIsVariable) && (src->id == EcsAny))) {
-                    if (!((second->flags & EcsIsVariable) && (second->id == EcsAny))) {
-                        if (ecs_table_has_id(world, first_table, EcsTransitive)) {
-                            second->flags |= EcsSelf|EcsUp|EcsTraverseAll;
-                            second->trav = first_id;
-                            term->flags |= EcsTermTransitive;
-                        }
-                    }
-                }
-            }
-
-            if (ecs_table_has_id(world, first_table, EcsReflexive)) {
-                term->flags |= EcsTermReflexive;
-            }
-        }
-    }
-
-    if (first->id == EcsVariable) {
-        flecs_filter_error(ctx, "invalid $ for term.first");
-        return -1;
-    }
-
-    if (term->id_flags & ECS_AND) {
-        term->oper = EcsAndFrom;
-        term->id &= ECS_COMPONENT_MASK;
-        term->id_flags = 0;
-    }
-
-    if (term->oper == EcsAndFrom || term->oper == EcsOrFrom || term->oper == EcsNotFrom) {
-        if (term->inout != EcsInOutDefault && term->inout != EcsInOutNone) {
-            flecs_filter_error(ctx, 
-                "invalid inout value for AndFrom/OrFrom/NotFrom term");
-            return -1;
-        }
-    }
-
-    /* Is term trivial */
-    bool trivial_term = true;
-    if (term->oper != EcsAnd) {
-        trivial_term = false;
-    }
-    if (ecs_id_is_wildcard(term->id)) {
-        if (!(term->idr && term->idr->flags & EcsIdExclusive)) {
-            trivial_term = false;
-        }
-        if (first->flags & EcsIsVariable) {
-            if (!ecs_id_is_wildcard(first->id) || first->id == EcsAny) {
-                trivial_term = false;
-            }
-        }
-        if (second->flags & EcsIsVariable) {
-            if (!ecs_id_is_wildcard(second->id) || second->id == EcsAny) {
-                trivial_term = false;
-            }
-        }
-    }
-    if (!ecs_term_match_this(term)) {
-        trivial_term = false;
-    }
-    if (term->flags & EcsTermIdInherited) {
-        trivial_term = false;
-    }
-    if (src->trav && src->trav != EcsIsA) {
-        trivial_term = false;
-    }
-    if (first->trav && first->trav != EcsIsA) {
-        trivial_term = false;
-    }
-    if (second->trav && second->trav != EcsIsA) {
-        trivial_term = false;
-    }
-    if (!(src->flags & EcsSelf)) {
-        trivial_term = false;
-    }
-    if (((term->first.id == EcsPredEq) || (term->first.id == EcsPredMatch)) && 
-        (term->first.flags & EcsIsEntity)) 
-    {
-        trivial_term = false;
-    }
-
-    if (trivial_term) {
-        ECS_BIT_SET(term->flags, EcsTermIsTrivial);
-    }
-
-    if (flecs_term_verify(world, term, ctx)) {
-        return -1;
-    }
-
-    return 0;
-}
-
-ecs_id_t flecs_to_public_id(
-    ecs_id_t id)
-{
-    if (ECS_PAIR_FIRST(id) == EcsUnion) {
-        return ecs_pair(ECS_PAIR_SECOND(id), EcsWildcard);
-    } else {
-        return id;
-    }
-}
-
-ecs_id_t flecs_from_public_id(
-    ecs_world_t *world,
-    ecs_id_t id)
-{
-    if (ECS_HAS_ID_FLAG(id, PAIR)) {
-        ecs_entity_t first = ECS_PAIR_FIRST(id);
-        ecs_id_record_t *idr = flecs_id_record_ensure(world, 
-            ecs_pair(first, EcsWildcard));
-        if (idr->flags & EcsIdUnion) {
-            return ecs_pair(EcsUnion, first);
-        }
-    }
-
-    return id;
-}
-
-bool ecs_identifier_is_0(
-    const char *id)
-{
-    return id[0] == '0' && !id[1];
-}
-
-bool ecs_id_match(
-    ecs_id_t id,
-    ecs_id_t pattern)
-{
-    if (id == pattern) {
-        return true;
-    }
-
-    if (ECS_HAS_ID_FLAG(pattern, PAIR)) {
-        if (!ECS_HAS_ID_FLAG(id, PAIR)) {
-            return false;
-        }
-
-        ecs_entity_t id_rel = ECS_PAIR_FIRST(id);
-        ecs_entity_t id_obj = ECS_PAIR_SECOND(id);
-        ecs_entity_t pattern_rel = ECS_PAIR_FIRST(pattern);
-        ecs_entity_t pattern_obj = ECS_PAIR_SECOND(pattern);
-
-        ecs_check(id_rel != 0, ECS_INVALID_PARAMETER, NULL);
-        ecs_check(id_obj != 0, ECS_INVALID_PARAMETER, NULL);
-
-        ecs_check(pattern_rel != 0, ECS_INVALID_PARAMETER, NULL);
-        ecs_check(pattern_obj != 0, ECS_INVALID_PARAMETER, NULL);
-        
-        if (pattern_rel == EcsWildcard) {
-            if (pattern_obj == EcsWildcard || pattern_obj == id_obj) {
-                return true;
-            }
-        } else if (pattern_rel == EcsFlag) {
-            /* Used for internals, helps to keep track of which ids are used in
-             * pairs that have additional flags (like OVERRIDE and TOGGLE) */
-            if (ECS_HAS_ID_FLAG(id, PAIR) && !ECS_IS_PAIR(id)) {
-                if (ECS_PAIR_FIRST(id) == pattern_obj) {
-                    return true;
-                }
-                if (ECS_PAIR_SECOND(id) == pattern_obj) {
-                    return true;
-                }
-            }
-        } else if (pattern_obj == EcsWildcard) {
-            if (pattern_rel == id_rel) {
-                return true;
-            }
-        }
-    } else {
-        if ((id & ECS_ID_FLAGS_MASK) != (pattern & ECS_ID_FLAGS_MASK)) {
-            return false;
-        }
-
-        if ((ECS_COMPONENT_MASK & pattern) == EcsWildcard) {
-            return true;
-        }
-    }
-
-error:
-    return false;
-}
-
-bool ecs_id_is_pair(
-    ecs_id_t id)
-{
-    return ECS_HAS_ID_FLAG(id, PAIR);
-}
-
-bool ecs_id_is_wildcard(
-    ecs_id_t id)
-{
-    if ((id == EcsWildcard) || (id == EcsAny)) {
-        return true;
-    }
-
-    bool is_pair = ECS_IS_PAIR(id);
-    if (!is_pair) {
-        return false;
-    }
-
-    ecs_entity_t first = ECS_PAIR_FIRST(id);
-    ecs_entity_t second = ECS_PAIR_SECOND(id);
-
-    return (first == EcsWildcard) || (second == EcsWildcard) ||
-           (first == EcsAny) || (second == EcsAny);
-}
-
-bool ecs_id_is_valid(
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    if (!id) {
-        return false;
-    }
-    if (ecs_id_is_wildcard(id)) {
-        return false;
-    }
-
-    if (ECS_HAS_ID_FLAG(id, PAIR)) {
-        if (!ECS_PAIR_FIRST(id)) {
-            return false;
-        }
-        if (!ECS_PAIR_SECOND(id)) {
-            return false;
-        }
-    } else if (id & ECS_ID_FLAGS_MASK) {
-        if (!ecs_is_valid(world, id & ECS_COMPONENT_MASK)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-ecs_flags32_t ecs_id_get_flags(
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (idr) {
-        return idr->flags;
-    } else {
-        return 0;
-    }
-}
-
-bool ecs_term_id_is_set(
-    const ecs_term_id_t *id)
-{
-    return id->id != 0 || id->name != NULL || id->flags & EcsIsEntity;
-}
-
-bool ecs_term_is_initialized(
-    const ecs_term_t *term)
-{
-    return term->id != 0 || ecs_term_id_is_set(&term->first);
-}
-
-bool ecs_term_match_this(
-    const ecs_term_t *term)
-{
-    return (term->src.flags & EcsIsVariable) && (term->src.id == EcsThis);
-}
-
-bool ecs_term_match_0(
-    const ecs_term_t *term)
-{
-    return (term->src.id == 0) && (term->src.flags & EcsIsEntity);
-}
-
-int ecs_term_finalize(
-    const ecs_world_t *world,
-    ecs_term_t *term)
-{
-    ecs_filter_finalize_ctx_t ctx = {0};
-    ctx.world = world;
-    ctx.term = term;
-    return flecs_term_finalize(world, term, &ctx);
-}
-
-ecs_term_t ecs_term_copy(
-    const ecs_term_t *src)
-{
-    ecs_term_t dst = *src;
-    dst.name = ecs_os_strdup(src->name);
-    dst.first.name = ecs_os_strdup(src->first.name);
-    dst.src.name = ecs_os_strdup(src->src.name);
-    dst.second.name = ecs_os_strdup(src->second.name);
-    return dst;
-}
-
-ecs_term_t ecs_term_move(
-    ecs_term_t *src)
-{
-    if (src->move) {
-        ecs_term_t dst = *src;
-        src->name = NULL;
-        src->first.name = NULL;
-        src->src.name = NULL;
-        src->second.name = NULL;
-        dst.move = false;
-        return dst;
-    } else {
-        ecs_term_t dst = ecs_term_copy(src);
-        dst.move = false;
-        return dst;
-    }
-}
-
-void ecs_term_fini(
-    ecs_term_t *term)
-{
-    /* Safe, values are owned by term */
-    ecs_os_free(ECS_CONST_CAST(char*, term->first.name));
-    ecs_os_free(ECS_CONST_CAST(char*, term->src.name));
-    ecs_os_free(ECS_CONST_CAST(char*, term->second.name));
-    ecs_os_free(term->name);
-
-    term->first.name = NULL;
-    term->src.name = NULL;
-    term->second.name = NULL;
-    term->name = NULL;
-}
-
-static
-ecs_term_t* flecs_filter_or_other_type(
-    ecs_filter_t *f,
-    int32_t t)
-{
-    ecs_term_t *term = &f->terms[t];
-    ecs_term_t *first = NULL;
-    while (t--) {
-        if (f->terms[t].oper != EcsOr) {
-            break;
-        }
-
-        first = &f->terms[t];
-    }
-
-    if (first) {
-        ecs_world_t *world = f->world;
-        const ecs_type_info_t *first_type;
-
-        if (first->idr) {
-            first_type = first->idr->type_info;
-        } else {
-            first_type = ecs_get_type_info(world, first->id);
-        }
-
-        const ecs_type_info_t *term_type;
-        if (term->idr) {
-            term_type = term->idr->type_info;
-        } else {
-            term_type = ecs_get_type_info(world, term->id);
-        }
-
-        if (first_type == term_type) {
-            return NULL;
-        }
-
-        return first;
-    } else {
-        return NULL;
-    }
-}
-
-int ecs_filter_finalize(
-    const ecs_world_t *world,
-    ecs_filter_t *f)
-{
-    int32_t i, term_count = f->term_count, field_count = 0;
-    ecs_term_t *terms = f->terms;
-    int32_t filter_terms = 0, scope_nesting = 0;
-    bool cond_set = false;
-
-    ecs_filter_finalize_ctx_t ctx = {0};
-    ctx.world = world;
-    ctx.filter = f;
-
-    f->flags |= EcsFilterMatchOnlyThis;
-
-    for (i = 0; i < term_count; i ++) {
-        bool filter_term = false;
-        ecs_term_t *term = &terms[i];
-        ctx.term_index = i;
-        if (flecs_term_finalize(world, term, &ctx)) {
-            return -1;
-        }
-
-        if (i && term[-1].oper == EcsOr) {
-            if (term[-1].src.id != term->src.id) {
-                flecs_filter_error(&ctx, "mismatching src.id for OR terms");
-                return -1;
-            }
-            if (term->oper != EcsOr && term->oper != EcsAnd) {
-                flecs_filter_error(&ctx, 
-                    "term after OR operator must use AND operator");
-                return -1;
-            }
-        } else {
-            field_count ++;
-        }
-
-        term->field_index = field_count - 1;
-
-        if (ecs_id_is_wildcard(term->id)) {
-            f->flags |= EcsFilterHasWildcards;
-        }
-
-        if (ecs_term_match_this(term)) {
-            ECS_BIT_SET(f->flags, EcsFilterMatchThis);
-        } else {
-            ECS_BIT_CLEAR(f->flags, EcsFilterMatchOnlyThis);
-        }
-
-        if (term->id == EcsPrefab) {
-            ECS_BIT_SET(f->flags, EcsFilterMatchPrefab);
-        }
-        if (term->id == EcsDisabled && (term->src.flags & EcsSelf)) {
-            ECS_BIT_SET(f->flags, EcsFilterMatchDisabled);
-        }
-
-        if (ECS_BIT_IS_SET(f->flags, EcsFilterNoData)) {
-            term->inout = EcsInOutNone;
-        }
-        
-        if (term->oper == EcsNot && term->inout == EcsInOutDefault) {
-            term->inout = EcsInOutNone;
-        }
-
-        if ((term->id == EcsWildcard) || (term->id == 
-            ecs_pair(EcsWildcard, EcsWildcard))) 
-        {
-            /* If term type is unknown beforehand, default the inout type to
-             * none. This prevents accidentally requesting lots of components,
-             * which can put stress on serializer code. */
-            if (term->inout == EcsInOutDefault) {
-                term->inout = EcsInOutNone;
-            }
-        }
-
-        if (term->inout == EcsInOutNone) {
-            filter_term = true;
-        } else if (term->idr) {
-            if (!term->idr->type_info && !(term->idr->flags & EcsIdUnion)) {
-                filter_term = true;
-            }
-        } else if (!ecs_id_is_union(world, term->id)) {
-            /* Union ids aren't filters because they return their target
-             * as component value with type ecs_entity_t */
-            if (ecs_id_is_tag(world, term->id)) {
-                filter_term = true;
-            } else if ((ECS_PAIR_SECOND(term->id) == EcsWildcard) ||
-                       (ECS_PAIR_SECOND(term->id) == EcsAny)) 
-            {
-                /* If the second element of a pair is a wildcard and the first
-                 * element is not a type, we can't know in advance what the
-                 * type of the term is, so it can't provide data. */
-                if (!ecs_get_type_info(world, ecs_pair_first(world, term->id))) {
-                    filter_term = true;
-                }
-            }
-        }
-    
-        if (!filter_term) {
-            if (term->oper == EcsOr || (i && term[-1].oper == EcsOr)) {
-                ecs_term_t *first = flecs_filter_or_other_type(f, i);
-                if (first) {
-                    if (first == &term[-1]) {
-                        if (!(term[-1].flags & EcsTermNoData)) {
-                            filter_terms ++;
-                        }
-                    }
-                    filter_term = true;
-                }
-            }
-        }
-
-        if (filter_term) {
-            filter_terms ++;
-            term->flags |= EcsTermNoData;
-        } else {
-            f->data_fields |= (1llu << term->field_index);
-        }
-
-        if (term->oper != EcsNot || !ecs_term_match_this(term)) {
-            ECS_BIT_CLEAR(f->flags, EcsFilterMatchAnything);
-        }
-
-        if (term->idr) {
-            if (ecs_os_has_threading()) {
-                ecs_os_ainc(&term->idr->keep_alive);
-            } else {
-                term->idr->keep_alive ++;
-            }
-        }
-
-        if (term->oper == EcsOptional || term->oper == EcsNot) {
-            cond_set = true;
-        }
-
-        if (term->first.id == EcsPredEq || term->first.id == EcsPredMatch ||
-            term->first.id == EcsPredLookup)
-        {
-            f->flags |= EcsFilterHasPred;
-        }
-
-        if (term->first.id == EcsScopeOpen) {
-            f->flags |= EcsFilterHasScopes;
-            scope_nesting ++;
-        }
-
-        if (term->first.id == EcsScopeClose) {
-            if (i && terms[i - 1].first.id == EcsScopeOpen) {
-                flecs_filter_error(&ctx, "invalid empty scope");
-                return -1;
-            }
-
-            f->flags |= EcsFilterHasScopes;
-            scope_nesting --;
-        }
-        if (scope_nesting < 0) {
-            flecs_filter_error(&ctx, "'}' without matching '{'");
-        }
-    }
-
-    if (scope_nesting != 0) {
-        flecs_filter_error(&ctx, "missing '}'");
-        return -1;
-    }
-
-    if (term_count && (terms[term_count - 1].oper == EcsOr)) {
-        flecs_filter_error(&ctx, "last term of filter can't have OR operator");
-        return -1;
-    }
-
-    f->field_count = flecs_ito(int8_t, field_count);
-
-    if (field_count) {
-        for (i = 0; i < term_count; i ++) {
-            ecs_term_t *term = &terms[i];
-            ecs_id_record_t *idr = term->idr;
-            int32_t field = term->field_index;
-            f->ids[field] = term->id;
-
-            if (term->oper == EcsOr || (i && (term[-1].oper == EcsOr))) {
-                if (flecs_filter_or_other_type(f, i)) {
-                    f->sizes[field] = 0;
-                    f->ids[field] = 0;
-                    continue;
-                }
-            }
-
-            if (idr) {
-                if (!ECS_IS_PAIR(idr->id) || ECS_PAIR_FIRST(idr->id) != EcsWildcard) {
-                    if (idr->flags & EcsIdUnion) {
-                        f->sizes[field] = ECS_SIZEOF(ecs_entity_t);
-#ifdef FLECS_META
-                        f->ids[field] = ecs_id(ecs_entity_t);
-#endif
-                    } else if (idr->type_info) {
-                        f->sizes[field] = idr->type_info->size;
-                        f->ids[field] = idr->id;
-                    }
-                }
-            } else {
-                bool is_union = false;
-                if (ECS_IS_PAIR(term->id)) {
-                    ecs_entity_t first = ecs_pair_first(world, term->id);
-                    if (ecs_has_id(world, first, EcsUnion)) {
-                        is_union = true;
-                    }
-                }
-                if (is_union) {
-                    f->sizes[field] = ECS_SIZEOF(ecs_entity_t);
-#ifdef FLECS_META
-                    f->ids[field] = ecs_id(ecs_entity_t);
-#endif
-                } else {
-                    const ecs_type_info_t *ti = ecs_get_type_info(
-                        world, term->id);
-                    if (ti) {
-                        f->sizes[field] = ti->size;
-                        f->ids[field] = term->id;
-                    }
-                }
-            }
-        }
-    } else {
-        f->sizes = NULL;
-        f->ids = NULL;
-    }
-
-    ecs_assert(filter_terms <= term_count, ECS_INTERNAL_ERROR, NULL);
-    if (filter_terms == term_count) {
-        ECS_BIT_SET(f->flags, EcsFilterNoData);
-    }
-
-    ECS_BIT_COND(f->flags, EcsFilterHasCondSet, cond_set);
-
-    /* Check if this is a trivial filter */
-    if ((f->flags & EcsFilterMatchOnlyThis)) {
-        if (!(f->flags & 
-            (EcsFilterHasPred|EcsFilterMatchDisabled|EcsFilterMatchPrefab))) 
-        {
-            ECS_BIT_SET(f->flags, EcsFilterMatchOnlySelf);
-
-            for (i = 0; i < term_count; i ++) {
-                ecs_term_t *term = &terms[i];
-                ecs_term_id_t *src = &term->src;
-
-                if (src->flags & EcsUp) {
-                    ECS_BIT_CLEAR(f->flags, EcsFilterMatchOnlySelf);
-                }
-
-                if (!(term->flags & EcsTermIsTrivial)) {
-                    break;
-                }
-
-                if (!(f->flags & EcsFilterNoData)) {
-                    if (term->inout == EcsInOutNone) {
-                        break;
-                    }
-                }
-            }
-            if (term_count && (i == term_count)) {
-                ECS_BIT_SET(f->flags, EcsFilterIsTrivial);
-            }
-        }
-    }
-
-    return 0;
-}
-
-/* Implementation for iterable mixin */
-static
-void flecs_filter_iter_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter)
-{
-    ecs_poly_assert(poly, ecs_filter_t);
-
-    if (filter) {
-        iter[1] = ecs_filter_iter(world, ECS_CONST_CAST(ecs_filter_t*, poly));
-        iter[0] = ecs_term_chain_iter(&iter[1], filter);
-    } else {
-        iter[0] = ecs_filter_iter(world, ECS_CONST_CAST(ecs_filter_t*, poly));
-    }
-}
-
-/* Implementation for dtor mixin */
-static
-void flecs_filter_fini(
-    ecs_filter_t *filter)
-{
-    if (filter->terms) {
-        int i, count = filter->term_count;
-        for (i = 0; i < count; i ++) {
-            ecs_term_t *term = &filter->terms[i];
-            if (term->idr) {
-                if (!(filter->world->flags & EcsWorldQuit)) {
-                    if (ecs_os_has_threading()) {
-                        ecs_os_adec(&term->idr->keep_alive);
-                    } else {
-                        term->idr->keep_alive --;
-                    }
-                }
-            }
-            ecs_term_fini(&filter->terms[i]);
-        }
-
-        if (filter->flags & EcsFilterOwnsTermsStorage) {
-            /* Memory allocated for both terms & sizes */
-            ecs_os_free(filter->terms);
-        } else {
-            ecs_os_free(filter->sizes);
-            ecs_os_free(filter->ids);
-        }
-    }
-
-    filter->terms = NULL;
-
-    if (filter->flags & EcsFilterOwnsStorage) {
-        ecs_os_free(filter);
-    }
-}
-
-void ecs_filter_fini(
-    ecs_filter_t *filter) 
-{
-    if ((filter->flags & EcsFilterOwnsStorage) && filter->entity) {
-        /* If filter is associated with entity, use poly dtor path */
-        ecs_delete(filter->world, filter->entity);
-    } else {
-        flecs_filter_fini(filter);
-    }
-}
-
-static
-void flecs_normalize_term_name(
-    ecs_term_id_t *ref) 
-{
-    if (ref->name && ref->name[0] == '$' && ref->name[1]) {
-        ecs_assert(ref->flags & EcsIsVariable, ECS_INTERNAL_ERROR, NULL);
-        const char *old = ref->name;
-        ref->name = ecs_os_strdup(&old[1]);
-        ecs_os_free(ECS_CONST_CAST(char*, old)); /* safe, filter owns name */
-    }
-}
-
-ecs_filter_t* ecs_filter_init(
-    ecs_world_t *world,
-    const ecs_filter_desc_t *desc)    
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    flecs_stage_from_world(&world);
-
-    ecs_filter_t *f = desc->storage;
-    int32_t i, term_count = desc->terms_buffer_count, storage_count = 0, expr_count = 0;
-    const ecs_term_t *terms = desc->terms_buffer;
-    ecs_term_t *storage_terms = NULL, *expr_terms = NULL;
-
-    if (f) {
-        ecs_check(f->hdr.magic == ecs_filter_t_magic, 
-            ECS_INVALID_PARAMETER, NULL);
-        storage_count = f->term_count;
-        storage_terms = f->terms;
-        ecs_poly_init(f, ecs_filter_t);
-    } else {
-        f = ecs_poly_new(ecs_filter_t);
-        f->flags |= EcsFilterOwnsStorage;
-    }
-    if (!storage_terms) {
-        f->flags |= EcsFilterOwnsTermsStorage;
-    }
-
-    ECS_BIT_COND(f->flags, EcsFilterIsInstanced, desc->instanced);
-    ECS_BIT_SET(f->flags, EcsFilterMatchAnything);
-    f->flags |= desc->flags;
-    f->world = world;
-
-    /* If terms_buffer was not set, count number of initialized terms in
-     * static desc::terms array */
-    if (!terms) {
-        ecs_check(term_count == 0, ECS_INVALID_PARAMETER, NULL);
-        terms = desc->terms;
-        for (i = 0; i < FLECS_TERM_DESC_MAX; i ++) {
-            if (!ecs_term_is_initialized(&terms[i])) {
-                break;
-            }
-            term_count ++;
-        }
-    } else {
-        ecs_check(term_count != 0, ECS_INVALID_PARAMETER, NULL);
-    }
-
-    /* If expr is set, parse query expression */
-    const char *expr = desc->expr;
-    ecs_entity_t entity = desc->entity;
-    if (expr) {
-#ifdef FLECS_PARSER
-        const char *name = NULL;
-        const char *ptr = desc->expr;
-        ecs_term_t term = {0};
-        ecs_term_id_t extra_args[ECS_PARSER_MAX_ARGS];
-        ecs_oper_kind_t extra_oper = 0;
-        int32_t expr_size = 0;
-
-        ecs_os_zeromem(extra_args);
-
-        if (entity) {
-            name = ecs_get_name(world, entity);
-        }
-
-        while (ptr[0] && (ptr = ecs_parse_term(
-            world, name, expr, ptr, &term, &extra_oper, extra_args, true)))
-        {
-            if (!ecs_term_is_initialized(&term)) {
-                break;
-            }
-
-            int32_t arg = 0;
-
-            do {
-                ecs_assert(arg <= ECS_PARSER_MAX_ARGS, ECS_INTERNAL_ERROR, NULL);
-
-                if (expr_count == expr_size) {
-                    expr_size = expr_size ? expr_size * 2 : 8;
-                    expr_terms = ecs_os_realloc_n(expr_terms, ecs_term_t, expr_size);
-                }
-
-                ecs_term_t *expr_term = &expr_terms[expr_count ++];
-                *expr_term = term;
-
-                if (arg) {
-                    if (extra_oper == EcsAnd) {
-                        expr_term->src = expr_term[-1].second;
-                        expr_term->second = extra_args[arg - 1];
-                    } else if (extra_oper == EcsOr) {
-                        expr_term->src = expr_term[-1].src;
-                        expr_term->second = extra_args[arg - 1];
-                        expr_term[-1].oper = EcsOr;
-                    }
-                    if (expr_term->first.name != NULL) {
-                        expr_term->first.name = ecs_os_strdup(
-                            expr_term->first.name);
-                    }
-                    if (expr_term->src.name != NULL) {
-                        expr_term->src.name = ecs_os_strdup(
-                            expr_term->src.name);
-                    }
-                }
-            } while (ecs_term_id_is_set(&extra_args[arg ++]));
-
-            if (ptr[0] == '\n') {
-                break;
-            }
-
-            ecs_os_zeromem(extra_args);
-        }
-
-        if (!ptr) {
-            /* Set terms in filter object to make sur they get cleaned up */
-            f->terms = expr_terms;
-            f->term_count = flecs_ito(int8_t, expr_count);
-            f->flags |= EcsFilterOwnsTermsStorage;
-            goto error;
-        }
-#else
-        (void)expr;
-        ecs_abort(ECS_UNSUPPORTED, "parser addon is not available");
-#endif
-    }
-
-    /* If storage is provided, make sure it's large enough */
-    ecs_check(!storage_terms || storage_count >= (term_count + expr_count),
-        ECS_INVALID_PARAMETER, NULL);
-
-    if (term_count || expr_count) {
-        /* Allocate storage for terms and sizes array */
-        if (!storage_terms) {
-            ecs_assert(f->flags & EcsFilterOwnsTermsStorage, 
-                ECS_INTERNAL_ERROR, NULL);
-            f->term_count = flecs_ito(int8_t, term_count + expr_count);
-            ecs_size_t terms_size = ECS_SIZEOF(ecs_term_t) * f->term_count;
-            ecs_size_t ids_size = ECS_SIZEOF(ecs_id_t) * f->term_count;
-            ecs_size_t sizes_size = ECS_SIZEOF(int32_t) * f->term_count;
-            f->terms = ecs_os_calloc(terms_size + sizes_size + ids_size);
-            f->ids = ECS_OFFSET(f->terms, terms_size);
-            f->sizes = ECS_OFFSET(f->terms, terms_size + ids_size);
-        } else {
-            f->terms = storage_terms;
-            f->term_count = flecs_ito(int8_t, storage_count);
-            f->sizes = ecs_os_calloc_n(ecs_size_t, term_count);
-            f->ids = ecs_os_calloc_n(ecs_id_t, term_count);
-        }
-
-        /* Copy terms to filter storage */
-        for (i = 0; i < term_count; i ++) {
-            f->terms[i] = ecs_term_copy(&terms[i]);
-            /* Allow freeing resources from expr parser during finalization */
-            f->terms[i].move = true;
-        }
-
-        /* Move expr terms to filter storage */
-        for (i = 0; i < expr_count; i ++) {
-            f->terms[i + term_count] = ecs_term_move(&expr_terms[i]);
-            /* Allow freeing resources from expr parser during finalization */
-            f->terms[i + term_count].move = true;
-        }
-        ecs_os_free(expr_terms);
-    }
-
-    /* Ensure all fields are consistent and properly filled out */
-    if (ecs_filter_finalize(world, f)) {
-        goto error;
-    }
-
-    /* Any allocated resources remaining in terms are now owned by filter */
-    for (i = 0; i < f->term_count; i ++) {
-        ecs_term_t *term = &f->terms[i];
-        /* Post process term names in case they were used to create variables */
-        flecs_normalize_term_name(&term->first);
-        flecs_normalize_term_name(&term->second);
-        flecs_normalize_term_name(&term->src);
-        term->move = false;
-    }
-
-    f->variable_names[0] = NULL;
-    f->iterable.init = flecs_filter_iter_init;
-    f->dtor = (ecs_poly_dtor_t)flecs_filter_fini;
-    f->entity = entity;
-    f->eval_count = 0;
-
-    if (entity && (f->flags & EcsFilterOwnsStorage)) {
-        EcsPoly *poly = ecs_poly_bind(world, entity, ecs_filter_t);
-        poly->poly = f;
-        ecs_poly_modified(world, entity, ecs_filter_t);
-    }
-
-    return f;
-error:
-    ecs_filter_fini(f);
-    return NULL;
-}
-
-void ecs_filter_copy(
-    ecs_filter_t *dst,
-    const ecs_filter_t *src)   
-{
-    if (src == dst) {
-        return;
-    }
-
-    if (src) {
-        *dst = *src;
-
-        int32_t i, term_count = src->term_count;
-        ecs_size_t terms_size = ECS_SIZEOF(ecs_term_t) * term_count;
-        ecs_size_t sizes_size = ECS_SIZEOF(int32_t) * term_count;
-        ecs_size_t ids_size = ECS_SIZEOF(ecs_id_t) * term_count;
-        dst->terms = ecs_os_malloc(terms_size + sizes_size + ids_size);
-        dst->ids = ECS_OFFSET(dst->terms, terms_size);
-        dst->sizes = ECS_OFFSET(dst->terms, terms_size + ids_size);
-        dst->flags |= EcsFilterOwnsTermsStorage;
-        ecs_os_memcpy_n(dst->sizes, src->sizes, int32_t, term_count);
-        ecs_os_memcpy_n(dst->ids, src->ids, int32_t, term_count);
-
-        for (i = 0; i < term_count; i ++) {
-            dst->terms[i] = ecs_term_copy(&src->terms[i]);
-        }
-    } else {
-        ecs_os_memset_t(dst, 0, ecs_filter_t);
-    }
-}
-
-void ecs_filter_move(
-    ecs_filter_t *dst,
-    ecs_filter_t *src)   
-{
-    if (src == dst) {
-        return;
-    }
-
-    if (src) {
-        *dst = *src;
-        if (src->flags & EcsFilterOwnsTermsStorage) {
-            dst->terms = src->terms;
-            dst->sizes = src->sizes;
-            dst->ids = src->ids;
-            dst->flags |= EcsFilterOwnsTermsStorage;
-        } else {
-            ecs_filter_copy(dst, src);
-        }
-        src->terms = NULL;
-        src->sizes = NULL;
-        src->ids = NULL;
-        src->term_count = 0;
-    } else {
-        ecs_os_memset_t(dst, 0, ecs_filter_t);
-    }
-}
-
-static
-void flecs_filter_str_add_id(
-    const ecs_world_t *world,
-    ecs_strbuf_t *buf,
-    const ecs_term_id_t *id,
-    bool is_subject,
-    ecs_flags32_t default_traverse_flags)
-{
-    bool is_added = false;
-    if (!is_subject || id->id != EcsThis) {
-        if (id->flags & EcsIsVariable && !ecs_id_is_wildcard(id->id)) {
-            ecs_strbuf_appendlit(buf, "$");
-        }
-        if (id->id) {
-            char *path = ecs_get_fullpath(world, id->id);
-            ecs_strbuf_appendstr(buf, path);
-            ecs_os_free(path);
-        } else if (id->name) {
-            ecs_strbuf_appendstr(buf, id->name);
-        } else {
-            ecs_strbuf_appendlit(buf, "0");
-        }
-        is_added = true;
-    }
-
-    ecs_flags32_t flags = id->flags;
-    if (!(flags & EcsTraverseFlags)) {
-        /* If flags haven't been set yet, initialize with defaults. This can
-         * happen if an error is thrown while the term is being finalized */
-        flags |= default_traverse_flags;
-    }
-
-    if ((flags & EcsTraverseFlags) != default_traverse_flags) {
-        if (is_added) {
-            ecs_strbuf_list_push(buf, ":", "|");
-        } else {
-            ecs_strbuf_list_push(buf, "", "|");
-        }
-        if (id->flags & EcsSelf) {
-            ecs_strbuf_list_appendstr(buf, "self");
-        }
-        if (id->flags & EcsUp) {
-            ecs_strbuf_list_appendstr(buf, "up");
-        }
-        if (id->flags & EcsDown) {
-            ecs_strbuf_list_appendstr(buf, "down");
-        }
-
-        if (id->trav && (id->trav != EcsIsA)) {
-            ecs_strbuf_list_push(buf, "(", "");
-
-            char *rel_path = ecs_get_fullpath(world, id->trav);
-            ecs_strbuf_appendstr(buf, rel_path);
-            ecs_os_free(rel_path);
-
-            ecs_strbuf_list_pop(buf, ")");
-        }
-
-        ecs_strbuf_list_pop(buf, "");
-    }
-}
-
-static
-void flecs_term_str_w_strbuf(
-    const ecs_world_t *world,
-    const ecs_term_t *term,
-    ecs_strbuf_t *buf,
-    int32_t t)
-{
-    const ecs_term_id_t *src = &term->src;
-    const ecs_term_id_t *second = &term->second;
-
-    uint8_t def_src_mask = EcsSelf|EcsUp;
-    uint8_t def_first_mask = EcsSelf;
-    uint8_t def_second_mask = EcsSelf;
-
-    bool pred_set = ecs_term_id_is_set(&term->first);
-    bool subj_set = !ecs_term_match_0(term);
-    bool obj_set = ecs_term_id_is_set(second);
-
-    if (term->first.id == EcsScopeOpen) {
-        ecs_strbuf_appendlit(buf, "{");
-        return;
-    } else if (term->first.id == EcsScopeClose) {
-        ecs_strbuf_appendlit(buf, "}");
-        return;
-    }
-
-    if (((term->first.id == EcsPredEq) || (term->first.id == EcsPredMatch)) && 
-        (term->first.flags & EcsIsEntity)) 
-    {
-        ecs_strbuf_appendlit(buf, "$");
-        if (term->src.id == EcsThis && term->src.flags & EcsIsVariable) {
-            ecs_strbuf_appendlit(buf, "this");
-        } else if (term->src.flags & EcsIsVariable) {
-            ecs_strbuf_appendstr(buf, term->src.name);
-        } else {
-            /* Shouldn't happen */
-        }
-
-        if (term->first.id == EcsPredEq) {
-            if (term->oper == EcsNot) {
-                ecs_strbuf_appendlit(buf, " != ");
-            } else {
-                ecs_strbuf_appendlit(buf, " == ");
-            }
-        } else if (term->first.id == EcsPredMatch) {
-            ecs_strbuf_appendlit(buf, " ~= ");
-        }
-
-        if (term->second.flags & EcsIsEntity) {
-            if (term->second.id != 0) {
-                ecs_get_path_w_sep_buf(
-                    world, 0, term->second.id, ".", NULL, buf);
-            }
-        } else {
-            if (term->second.flags & EcsIsVariable) {
-                ecs_strbuf_appendlit(buf, "$");
-                if (term->second.name) {
-                    ecs_strbuf_appendstr(buf, term->second.name);
-                } else if (term->second.id == EcsThis) {
-                    ecs_strbuf_appendlit(buf, "this");
-                }
-            } else if (term->second.flags & EcsIsName) {
-                ecs_strbuf_appendlit(buf, "\"");
-                if (term->first.id == EcsPredMatch && term->oper == EcsNot) {
-                    ecs_strbuf_appendlit(buf, "!");
-                }
-                ecs_strbuf_appendstr(buf, term->second.name);
-                ecs_strbuf_appendlit(buf, "\"");
-            }
-        }
-
-        return;
-    }
-
-    if (!t || !(term[-1].oper == EcsOr)) {
-        if (term->inout == EcsIn) {
-            ecs_strbuf_appendlit(buf, "[in] ");
-        } else if (term->inout == EcsInOut) {
-            ecs_strbuf_appendlit(buf, "[inout] ");
-        } else if (term->inout == EcsOut) {
-            ecs_strbuf_appendlit(buf, "[out] ");
-        } else if (term->inout == EcsInOutNone && term->oper != EcsNot) {
-            ecs_strbuf_appendlit(buf, "[none] ");
-        }
-    }
-
-    if (term->first.flags & EcsIsEntity && term->first.id != 0) {
-        if (ecs_has_id(world, term->first.id, EcsDontInherit)) {
-            def_src_mask = EcsSelf;
-        }
-    }
-
-    if (term->oper == EcsNot) {
-        ecs_strbuf_appendlit(buf, "!");
-    } else if (term->oper == EcsOptional) {
-        ecs_strbuf_appendlit(buf, "?");
-    }
-
-    if (!subj_set) {
-        flecs_filter_str_add_id(world, buf, &term->first, false, 
-            def_first_mask);
-        if (!obj_set) {
-            ecs_strbuf_appendlit(buf, "()");
-        } else {
-            ecs_strbuf_appendlit(buf, "(0,");
-            flecs_filter_str_add_id(world, buf, &term->second, false, 
-                def_second_mask);
-            ecs_strbuf_appendlit(buf, ")");
-        }
-    } else if (ecs_term_match_this(term) && 
-        (src->flags & EcsTraverseFlags) == def_src_mask)
-    {
-        if (pred_set) {
-            if (obj_set) {
-                ecs_strbuf_appendlit(buf, "(");
-            }
-            flecs_filter_str_add_id(world, buf, &term->first, false, def_first_mask);   
-            if (obj_set) {
-                ecs_strbuf_appendlit(buf, ",");
-                flecs_filter_str_add_id(
-                    world, buf, &term->second, false, def_second_mask);
-                ecs_strbuf_appendlit(buf, ")");
-            }
-        } else if (term->id) {
-            char *str = ecs_id_str(world, term->id);
-            ecs_strbuf_appendstr(buf, str);
-            ecs_os_free(str);
-        }
-    } else {
-        if (term->id_flags && !ECS_HAS_ID_FLAG(term->id_flags, PAIR)) {
-            ecs_strbuf_appendstr(buf, ecs_id_flag_str(term->id_flags));
-            ecs_strbuf_appendch(buf, '|');
-        }
-
-        flecs_filter_str_add_id(world, buf, &term->first, false, def_first_mask);
-        ecs_strbuf_appendlit(buf, "(");
-        if (term->src.flags & EcsIsEntity && term->src.id == term->first.id) {
-            ecs_strbuf_appendlit(buf, "$");
-        } else {
-            flecs_filter_str_add_id(world, buf, &term->src, true, def_src_mask);
-        }
-        if (obj_set) {
-            ecs_strbuf_appendlit(buf, ",");
-            flecs_filter_str_add_id(world, buf, &term->second, false, def_second_mask);
-        }
-        ecs_strbuf_appendlit(buf, ")");
-    }
-}
-
-char* ecs_term_str(
-    const ecs_world_t *world,
-    const ecs_term_t *term)
-{
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
-    flecs_term_str_w_strbuf(world, term, &buf, 0);
-    return ecs_strbuf_get(&buf);
-}
-
-static
-char* flecs_filter_str(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter,
-    const ecs_filter_finalize_ctx_t *ctx,
-    int32_t *term_start_out)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_strbuf_t buf = ECS_STRBUF_INIT;
-    ecs_term_t *terms = filter->terms;
-    int32_t i, count = filter->term_count;
-
-    for (i = 0; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-
-        if (term_start_out && ctx) {
-            if (ctx->term_index == i) {
-                term_start_out[0] = ecs_strbuf_written(&buf);
-                if (i) {
-                    term_start_out[0] += 2; /* whitespace  + , */
-                }
-            }
-        }
-
-        flecs_term_str_w_strbuf(world, term, &buf, i);
-
-        if (i != (count - 1)) {
-            if (term->oper == EcsOr) {
-                ecs_strbuf_appendlit(&buf, " || ");
-            } else {
-                if (term->first.id != EcsScopeOpen) {
-                    if (term[1].first.id != EcsScopeClose) {
-                        ecs_strbuf_appendlit(&buf, ", ");
-                    }
-                }
-            }
-        }
-    }
-
-    return ecs_strbuf_get(&buf);
-error:
-    return NULL;
-}
-
-char* ecs_filter_str(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter)
-{
-    return flecs_filter_str(world, filter, NULL, NULL);
-}
-
-int32_t ecs_filter_find_this_var(
-    const ecs_filter_t *filter)
-{
-    ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL);
-    
-    if (ECS_BIT_IS_SET(filter->flags, EcsFilterMatchThis)) {
-        /* Filters currently only support the This variable at index 0. Only
-         * return 0 if filter actually has terms for the This variable. */
-        return 0;
-    }
-
-error:
-    return -1;
-}
-
-/* Check if the id is a pair that has Any as first or second element. Any 
- * pairs behave just like Wildcard pairs and reuses the same data structures,
- * with as only difference that the number of results returned for an Any pair
- * is never more than one. This function is used to tell the difference. */
-static
-bool is_any_pair(
-    ecs_id_t id)
-{
-    if (!ECS_HAS_ID_FLAG(id, PAIR)) {
-        return false;
-    }
-
-    if (ECS_PAIR_FIRST(id) == EcsAny) {
-        return true;
-    }
-    if (ECS_PAIR_SECOND(id) == EcsAny) {
-        return true;
-    }
-
-    return false;
-}
-
-static
-bool flecs_n_term_match_table(
-    ecs_world_t *world,
-    const ecs_term_t *term,
-    const ecs_table_t *table,
-    ecs_entity_t type_id,
-    ecs_oper_kind_t oper,
-    ecs_id_t *id_out,
-    int32_t *column_out,
-    ecs_entity_t *subject_out,
-    int32_t *match_index_out,
-    bool first,
-    ecs_flags32_t iter_flags)
-{
-    (void)column_out;
-
-    const ecs_type_t *type = ecs_get_type(world, type_id);
-    ecs_assert(type != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_id_t *ids = type->array;
-    int32_t i, count = type->count;
-    ecs_term_t temp = *term;
-    temp.oper = EcsAnd;
-
-    for (i = 0; i < count; i ++) {
-        ecs_id_t id = ids[i];
-        if (ecs_id_get_flags(world, id) & EcsIdDontInherit) {
-            continue;
-        }
-        bool result;
-        if (ECS_HAS_ID_FLAG(id, AND)) {
-            ecs_oper_kind_t id_oper = EcsAndFrom;
-            result = flecs_n_term_match_table(world, term, table, 
-                id & ECS_COMPONENT_MASK, id_oper, id_out, column_out, 
-                subject_out, match_index_out, first, iter_flags);
-        } else {
-            temp.id = id;
-            result = flecs_term_match_table(world, &temp, table, id_out, 
-                0, subject_out, match_index_out, first, iter_flags);
-        }
-        if (!result && oper == EcsAndFrom) {
-            return false;
-        } else
-        if (result && oper == EcsOrFrom) {
-            return true;
-        }
-    }
-
-    if (oper == EcsAndFrom) {
-        if (id_out) {
-            id_out[0] = type_id;
-        }
-        return true;
-    } else
-    if (oper == EcsOrFrom) {
-        return false;
-    }
-
-    return false;
-}
-
-bool flecs_term_match_table(
-    ecs_world_t *world,
-    const ecs_term_t *term,
-    const ecs_table_t *table,
-    ecs_id_t *id_out,
-    int32_t *column_out,
-    ecs_entity_t *subject_out,
-    int32_t *match_index_out,
-    bool first,
-    ecs_flags32_t iter_flags)
-{
-    ecs_assert(term != NULL, ECS_INTERNAL_ERROR, NULL);
-    const ecs_term_id_t *src = &term->src;
-    ecs_oper_kind_t oper = term->oper;
-    const ecs_table_t *match_table = table;
-    ecs_id_t id = term->id;
-
-    ecs_entity_t src_id = src->id;
-    if (ecs_term_match_0(term)) {
-        if (id_out) {
-            id_out[0] = id; /* If no entity is matched, just set id */
-        }
-        return true;
-    }
-
-    if (oper == EcsAndFrom || oper == EcsOrFrom) {
-        return flecs_n_term_match_table(world, term, table, term->id, 
-            term->oper, id_out, column_out, subject_out, match_index_out, first, 
-            iter_flags);
-    }
-
-    /* If source is not This, search in table of source */
-    if (!ecs_term_match_this(term)) {
-        if (iter_flags & EcsIterEntityOptional) {
-            /* Treat entity terms as optional */
-            oper = EcsOptional;
-        }
-
-        if (ecs_is_alive(world, src_id)) {
-            match_table = ecs_get_table(world, src_id);
-        } else {
-            match_table = NULL;
-        }
-
-        if (match_table) {
-        } else if (oper != EcsOptional) {
-            return false;
-        }
-    } else {
-        /* If filter contains This terms, a table must be provided */
-        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    }
-
-    if (!match_table) {
-        return false;
-    }
-
-    ecs_entity_t source = 0;
-
-    /* If first = false, we're searching from an offset. This supports returning
-     * multiple results when using wildcard filters. */
-    int32_t column = 0;
-    if (!first && column_out && column_out[0] != 0) {
-        column = column_out[0];
-        if (column < 0) {
-            /* In case column is not from This, flip sign */
-            column = -column;
-        }
-
-        /* Remove base 1 offset */
-        column --;
-    }
-
-    /* Find location, source and id of match in table type */
-    ecs_table_record_t *tr = 0;
-    bool is_any = is_any_pair(id);
-
-    ecs_id_record_t *idr = term->idr;
-    if (world->flags & EcsWorldQuit) {
-        /* During world cleanup the keep_alive assert for id records is no 
-         * longer enforced */
-        idr = NULL;
-    }
-    column = flecs_search_relation_w_idr(world, match_table,
-        column, id, src->trav, src->flags, &source, id_out, &tr, idr);
-
-    if (tr && match_index_out) {
-        if (!is_any) {
-            match_index_out[0] = tr->count;
-        } else {
-            match_index_out[0] = 1;
-        }
-    }
-
-    bool result = column != -1;
-
-    if (oper == EcsNot) {
-        if (match_index_out) {
-            match_index_out[0] = 1;
-        }
-        result = !result;
-    }
-
-    if (oper == EcsOptional) {
-        result = true;
-    }
-
-    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-    if ((column == -1) && (src->flags & EcsUp) && (table->flags & EcsTableHasTarget)) {
-        ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_id_t rel = ECS_PAIR_SECOND(table->type.array[table->_->ft_offset]);
-        if (rel == (uint32_t)src->trav) {
-            result = true;
-        }
-    }
-
-    if (!result) {
-        if (iter_flags & EcsFilterPopulate) {
-            column = 0;
-        } else {
-            return false;
-        }
-    }
-
-    if (!ecs_term_match_this(term)) {
-        if (!source) {
-            source = src_id;
-        }
-    }
-
-    if (id_out && column < 0) {
-        id_out[0] = id;
-    }
-
-    if (column_out) {
-        if (column >= 0) {
-            column ++;
-            if (source != 0) {
-                column *= -1; 
-            }
-            column_out[0] = column;
-        } else {
-            column_out[0] = 0;
-        }
-    }
-
-    if (subject_out) {
-        subject_out[0] = source;
-    }
-
-    return result;
-}
-
-bool flecs_filter_match_table(
-    ecs_world_t *world,
-    const ecs_filter_t *filter,
-    const ecs_table_t *table,
-    ecs_id_t *ids,
-    int32_t *columns,
-    ecs_entity_t *sources,
-    int32_t *match_indices,
-    int32_t *matches_left,
-    bool first,
-    int32_t skip_term,
-    ecs_flags32_t iter_flags)
-{
-    ecs_term_t *terms = filter->terms;
-    int32_t i, count = filter->term_count;
-    int32_t match_count = 1;
-    bool result = true;
-
-    if (matches_left) {
-        match_count = *matches_left;
-    }
-
-    for (i = 0; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-        ecs_oper_kind_t oper = term->oper;
-        if (i == skip_term) {
-            if (oper != EcsAndFrom && oper != EcsOrFrom && oper != EcsNotFrom) {
-                continue;
-            }
-        }
-
-        ecs_term_id_t *src = &term->src;
-        const ecs_table_t *match_table = table;
-        int32_t t_i = term->field_index;
-
-        ecs_entity_t src_id = src->id;
-        if (!src_id) {
-            if (ids) {
-                ids[t_i] = term->id;
-            }
-            continue;
-        }
-
-        if (!ecs_term_match_this(term)) {
-            if (ecs_is_alive(world, src_id)) {
-                match_table = ecs_get_table(world, src_id);
-            } else {
-                match_table = NULL;
-            }
-        } else {
-            if (ECS_BIT_IS_SET(iter_flags, EcsIterIgnoreThis)) {
-                continue;
-            }
-            
-            /* If filter contains This terms, table must be provided */
-            ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-        }
-
-        int32_t match_index = 0;
-        if (!i || term[-1].oper != EcsOr) {
-            result = false;
-        } else {
-            if (result) {
-                continue; /* Already found matching OR term */
-            }
-        }
-
-        bool term_result = flecs_term_match_table(world, term, match_table,
-            ids ? &ids[t_i] : NULL, 
-            columns ? &columns[t_i] : NULL, 
-            sources ? &sources[t_i] : NULL, 
-            &match_index,
-            first,
-            iter_flags);
-
-        if (i && term[-1].oper == EcsOr) {
-            result |= term_result;
-        } else {
-            result = term_result;
-        }
-
-        if (oper != EcsOr && !result) {
-            return false;
-        }
-
-        if (first && match_index) {
-            match_count *= match_index;
-        }
-
-        if (match_indices) {
-            match_indices[t_i] = match_index;
-        }
-    }
-
-    if (matches_left) {
-        *matches_left = match_count;
-    }
-
-    return true;
-}
-
-static
-void term_iter_init_no_data(
-    ecs_term_iter_t *iter)
-{
-    iter->term = (ecs_term_t){ .field_index = -1 };
-    iter->self_index = NULL;
-    iter->index = 0;
-}
-
-static
-void term_iter_init_w_idr(
-    const ecs_term_t *term,
-    ecs_term_iter_t *iter, 
-    ecs_id_record_t *idr, 
-    bool empty_tables)
-{
-    if (idr) {
-        if (empty_tables) {
-            flecs_table_cache_all_iter(&idr->cache, &iter->it);
-        } else {
-            flecs_table_cache_iter(&idr->cache, &iter->it);
-        }
-    } else {
-        term_iter_init_no_data(iter);
-    }
-
-    iter->index = 0;
-    iter->empty_tables = empty_tables;
-    iter->size = 0;
-    if (term && term->idr && term->idr->type_info) {
-        iter->size = term->idr->type_info->size;
-    }
-}
-
-static
-void term_iter_init_wildcard(
-    const ecs_world_t *world,
-    ecs_term_iter_t *iter,
-    bool empty_tables)
-{
-    iter->term = (ecs_term_t){ .field_index = -1 };
-    iter->self_index = flecs_id_record_get(world, EcsAny);
-    ecs_id_record_t *idr = iter->cur = iter->self_index;
-    term_iter_init_w_idr(NULL, iter, idr, empty_tables);
-}
-
-static
-void term_iter_init(
-    const ecs_world_t *world,
-    ecs_term_t *term,
-    ecs_term_iter_t *iter,
-    bool empty_tables)
-{    
-    const ecs_term_id_t *src = &term->src;
-
-    iter->term = *term;
-
-    if (src->flags & EcsSelf) {
-        iter->self_index = term->idr;
-        if (!iter->self_index) {
-            iter->self_index = flecs_query_id_record_get(world, term->id);
-        }
-    }
-
-    if (src->flags & EcsUp) {
-        iter->set_index = flecs_id_record_get(world, 
-            ecs_pair(src->trav, EcsWildcard));
-    }
-
-    ecs_id_record_t *idr;
-    if (iter->self_index) {
-        idr = iter->cur = iter->self_index;
-    } else {
-        idr = iter->cur = iter->set_index;
-    }
-
-    term_iter_init_w_idr(term, iter, idr, empty_tables);
-}
-
-ecs_iter_t ecs_term_iter(
-    const ecs_world_t *stage,
-    ecs_term_t *term)
-{
-    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    const ecs_world_t *world = ecs_get_world(stage);
-
-    flecs_process_pending_tables(world);
-
-    if (ecs_term_finalize(world, term)) {
-        ecs_throw(ECS_INVALID_PARAMETER, NULL);
-    }
-
-    ecs_iter_t it = {
-        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .field_count = 1,
-        .next = ecs_term_next
-    };
-
-    /* Term iter populates the iterator with arrays from its own cache, ensure 
-     * they don't get overwritten by flecs_iter_validate.
-     *
-     * Note: the reason the term iterator doesn't use the iterator cache itself
-     * (which could easily accommodate a single term) is that the filter iterator
-     * is built on top of the term iterator. The private cache of the term
-     * iterator keeps the filter iterator code simple, as it doesn't need to
-     * worry about the term iter overwriting the iterator fields. */
-    flecs_iter_init(stage, &it, 0);
-    term_iter_init(world, term, &it.priv.iter.term, false);
-    ECS_BIT_COND(it.flags, EcsIterNoData, it.priv.iter.term.size == 0);
-
-    return it;
-error:
-    return (ecs_iter_t){ 0 };
-}
-
-ecs_iter_t ecs_term_chain_iter(
-    const ecs_iter_t *chain_it,
-    ecs_term_t *term)
-{
-    ecs_check(chain_it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_world_t *world = chain_it->real_world;
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    if (ecs_term_finalize(world, term)) {
-        ecs_throw(ECS_INVALID_PARAMETER, NULL);
-    }
-
-    ecs_iter_t it = {
-        .real_world = world,
-        .world = chain_it->world,
-        .terms = term,
-        .field_count = 1,
-        .chain_it = ECS_CONST_CAST(ecs_iter_t*, chain_it),
-        .next = ecs_term_next
-    };
-
-    flecs_iter_init(chain_it->world, &it, flecs_iter_cache_all);
-
-    term_iter_init(world, term, &it.priv.iter.term, false);
-
-    return it;
-error:
-    return (ecs_iter_t){ 0 };
-}
-
-ecs_iter_t flecs_children(
-    const ecs_world_t *stage,
-    ecs_entity_t rel,
-    ecs_entity_t parent)
-{
-    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    const ecs_world_t *world = ecs_get_world(stage);
-
-    flecs_process_pending_tables(world);
-
-    ecs_iter_t it = {
-        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .field_count = 1,
-        .next = ecs_children_next
-    };
-    
-    ecs_id_t id = ecs_pair(rel, parent);
-
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return it;
-    }
-
-    ecs_term_iter_t *each_iter = &it.priv.iter.term;
-    each_iter->id = id;
-    each_iter->subject = 0;
-    each_iter->size = 0;
-    flecs_table_cache_iter((ecs_table_cache_t*)idr, &each_iter->it);
-
-    return it;
-error:
-    return (ecs_iter_t){0};
-}
-
-ecs_iter_t ecs_children(
-    const ecs_world_t *stage,
-    ecs_entity_t parent)
-{
-    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    const ecs_world_t *world = ecs_get_world(stage);
-
-    flecs_process_pending_tables(world);
-
-    ecs_iter_t it = {
-        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .field_count = 1,
-        .next = ecs_children_next
-    };
-    
-    ecs_id_t id = ecs_childof(parent);
-
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        return it;
-    }
-
-    ecs_term_iter_t *each_iter = &it.priv.iter.term;
-    each_iter->id = id;
-    each_iter->subject = 0;
-    each_iter->size = 0;
-    flecs_table_cache_iter((ecs_table_cache_t*)idr, &each_iter->it);
-
-    return it;
-error:
-    return (ecs_iter_t){0};
-}
-
-bool ecs_children_next(
-    ecs_iter_t *it)
-{
-    ecs_term_iter_t *each_iter = &it->priv.iter.term;
-    ecs_table_record_t *next = flecs_table_cache_next(
-        &each_iter->it, ecs_table_record_t);
-    it->flags |= EcsIterIsValid;
-    if (next) {
-        ecs_table_t *table = next->hdr.table;
-        it->table = table;
-        it->count = ecs_table_count(table);
-        it->entities = flecs_table_entities_array(table);
-        it->ids = &table->type.array[next->index];
-        it->sources = &each_iter->subject;
-        it->sizes = &each_iter->size;
-        it->columns = NULL;
-        it->ptrs = NULL;
-        return true;
-    } else {
-        return false;
-    }
-}
-
-static
-const ecs_table_record_t *flecs_term_iter_next_table(
-    ecs_term_iter_t *iter)
-{
-    ecs_id_record_t *idr = iter->cur;
-    if (!idr) {
-        return NULL;
-    }
-
-    return flecs_table_cache_next(&iter->it, ecs_table_record_t);
-}
-
-static
-bool flecs_term_iter_find_superset(
-    ecs_world_t *world, 
-    ecs_table_t *table, 
-    ecs_term_t *term, 
-    ecs_entity_t *source, 
-    ecs_id_t *id, 
-    int32_t *column)
-{
-    ecs_term_id_t *src = &term->src;
-
-    /* Test if following the relationship finds the id */
-    ecs_id_record_t *idr = term->idr;
-    if (world->flags & EcsWorldQuit) {
-        /* During world cleanup the keep_alive assert for id records is no 
-         * longer enforced */
-        idr = NULL;
-    }
-    int32_t index = flecs_search_relation_w_idr(world, table, 0, 
-        term->id, src->trav, src->flags, source, id, 0, idr);
-
-    if (index == -1) {
-        *source = 0;
-        return false;
-    }
-
-    ecs_assert(*source != 0, ECS_INTERNAL_ERROR, NULL);
-
-    *column = (index + 1) * -1;
-
-    return true;
-}
-
-static
-bool flecs_term_iter_next(
-    ecs_world_t *world,
-    ecs_term_iter_t *iter,
-    bool match_prefab,
-    bool match_disabled)
-{
-    ecs_table_t *table = iter->table;
-    ecs_entity_t source = 0;
-    const ecs_table_record_t *tr;
-    ecs_term_t *term = &iter->term;
-
-    do {
-        if (table) {
-            iter->cur_match ++;
-            if (iter->cur_match >= iter->match_count) {
-                table = NULL;
-            } else {
-                iter->last_column = ecs_search_offset(
-                    world, table, iter->last_column + 1, term->id, 0);
-                iter->column = iter->last_column + 1;
-                if (iter->last_column >= 0) {
-                    iter->id = table->type.array[iter->last_column];
-                }
-            }
-        }
-
-        if (!table) {
-            if (!(tr = flecs_term_iter_next_table(iter))) {
-                if (iter->cur != iter->set_index && iter->set_index != NULL) {
-                    if (iter->observed_table_count != 0) {
-                        iter->cur = iter->set_index;
-                        if (iter->empty_tables) {
-                            flecs_table_cache_all_iter(
-                                &iter->set_index->cache, &iter->it);
-                        } else {
-                            flecs_table_cache_iter(
-                                &iter->set_index->cache, &iter->it);
-                        }
-                        iter->index = 0;
-                        tr = flecs_term_iter_next_table(iter);
-                    }
-                }
-
-                if (!tr) {
-                    return false;
-                }
-            }
-
-            table = tr->hdr.table;
-            if (table->_->traversable_count) {
-                iter->observed_table_count ++;
-            }
-
-            if (!match_prefab && (table->flags & EcsTableIsPrefab)) {
-                continue;
-            }
-
-            if (!match_disabled && (table->flags & EcsTableIsDisabled)) {
-                continue;
-            }
-
-            iter->table = table;
-            iter->match_count = tr->count;
-            if (is_any_pair(term->id)) {
-                iter->match_count = 1;
-            }
-
-            iter->cur_match = 0;
-            iter->last_column = tr->index;
-            iter->column = tr->index + 1;
-            iter->id = flecs_to_public_id(table->type.array[tr->index]);
-        }
-
-        if (iter->cur == iter->set_index) {
-            if (iter->self_index) {
-                if (flecs_id_record_get_table(iter->self_index, table) != NULL) {
-                    /* If the table has the id itself and this term matched Self
-                     * we already matched it */
-                    continue;
-                }
-            }
-
-            if (!flecs_term_iter_find_superset(
-                world, table, term, &source, &iter->id, &iter->column)) 
-            {
-                continue;
-            }
-
-            /* The tr->count field refers to the number of relationship instances,
-             * not to the number of matches. Superset terms can only yield a
-             * single match. */
-            iter->match_count = 1;
-        }
-
-        break;
-    } while (true);
-
-    iter->subject = source;
-
-    return true;
-}
-
-static
-bool flecs_term_iter_set_table(
-    ecs_world_t *world,
-    ecs_term_iter_t *iter,
-    ecs_table_t *table)
-{
-    const ecs_table_record_t *tr = NULL;
-    const ecs_id_record_t *idr = iter->self_index;
-    if (idr) {
-        tr = ecs_table_cache_get(&idr->cache, table);
-        if (tr) {
-            iter->match_count = tr->count;
-            iter->last_column = tr->index;
-            iter->column = tr->index + 1;
-            iter->id = flecs_to_public_id(table->type.array[tr->index]);
-        }
-    }
-
-    if (!tr) {
-        idr = iter->set_index;
-        if (idr) {
-            tr = ecs_table_cache_get(&idr->cache, table);
-            if (!flecs_term_iter_find_superset(world, table, &iter->term, 
-                &iter->subject, &iter->id, &iter->column)) 
-            {
-                return false;
-            }
-            iter->match_count = 1;
-        }
-    }
-
-    if (!tr) {
-        return false;
-    }
-
-    /* Populate fields as usual */
-    iter->table = table;
-    iter->cur_match = 0;
-
-    return true;
-}
-
-bool ecs_term_next(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_term_next, ECS_INVALID_PARAMETER, NULL);
-
-    flecs_iter_validate(it);
-
-    ecs_term_iter_t *iter = &it->priv.iter.term;
-    ecs_term_t *term = &iter->term;
-    ecs_world_t *world = it->real_world;
-    ecs_table_t *table;
-
-    it->ids = &iter->id;
-    it->sources = &iter->subject;
-    it->columns = &iter->column;
-    it->terms = &iter->term;
-    it->sizes = &iter->size;
-    it->ptrs = &iter->ptr;
-
-    ecs_iter_t *chain_it = it->chain_it;
-    if (chain_it) {
-        ecs_iter_next_action_t next = chain_it->next;
-        bool match;
-
-        do {
-            if (!next(chain_it)) {
-                goto done;
-            }
-
-            table = chain_it->table;
-            match = flecs_term_match_table(world, term, table,
-                it->ids, it->columns, it->sources, it->match_indices, true,
-                it->flags);
-        } while (!match);
-        goto yield;
-
-    } else {
-        if (!flecs_term_iter_next(world, iter, 
-                (term->flags & EcsTermMatchPrefab) != 0, 
-                (term->flags & EcsTermMatchDisabled) != 0)) 
-        {
-            goto done;
-        }
-
-        table = iter->table;
-
-        /* Source must either be 0 (EcsThis) or nonzero in case of substitution */
-        ecs_assert(iter->subject || iter->cur != iter->set_index, 
-            ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(iter->table != NULL, ECS_INTERNAL_ERROR, NULL);
-    }
-
-yield:
-    flecs_iter_populate_data(world, it, table, 0, ecs_table_count(table), 
-        it->ptrs);
-    ECS_BIT_SET(it->flags, EcsIterIsValid);
-    return true;
-done:
-    ecs_iter_fini(it);
-error:
-    return false;
-}
-
-static
-void flecs_init_filter_iter(
-    ecs_iter_t *it,
-    const ecs_filter_t *filter)
-{
-    ecs_assert(filter != NULL, ECS_INTERNAL_ERROR, NULL);
-    it->priv.iter.filter.filter = filter;
-    it->field_count = filter->field_count;
-}
-
-int32_t ecs_filter_pivot_term(
-    const ecs_world_t *world,
-    const ecs_filter_t *filter)
-{
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_term_t *terms = filter->terms;
-    int32_t i, term_count = filter->term_count;
-    int32_t pivot_term = -1, min_count = -1, self_pivot_term = -1;
-
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        ecs_id_t id = term->id;
-
-        if ((term->oper != EcsAnd) || (i && (term[-1].oper == EcsOr))) {
-            continue;
-        }
-
-        if (!ecs_term_match_this(term)) {
-            continue;
-        }
-
-        ecs_id_record_t *idr = flecs_query_id_record_get(world, id);
-        if (!idr) {
-            /* If one of the terms does not match with any data, iterator 
-             * should not return anything */
-            return -2; /* -2 indicates filter doesn't match anything */
-        }
-
-        int32_t table_count = flecs_table_cache_count(&idr->cache);
-        if (min_count == -1 || table_count < min_count) {
-            min_count = table_count;
-            pivot_term = i;
-            if ((term->src.flags & EcsTraverseFlags) == EcsSelf) {
-                self_pivot_term = i;
-            }
-        }
-    }
-
-    if (self_pivot_term != -1) {
-        pivot_term = self_pivot_term;
-    }
-
-    return pivot_term;
-error:
-    return -2;
-}
-
-void flecs_filter_apply_iter_flags(
-    ecs_iter_t *it,
-    const ecs_filter_t *filter)
-{
-    ECS_BIT_COND(it->flags, EcsIterIsInstanced, 
-        ECS_BIT_IS_SET(filter->flags, EcsFilterIsInstanced));
-    ECS_BIT_COND(it->flags, EcsIterNoData,
-        ECS_BIT_IS_SET(filter->flags, EcsFilterNoData));
-    ECS_BIT_COND(it->flags, EcsIterHasCondSet, 
-        ECS_BIT_IS_SET(filter->flags, EcsFilterHasCondSet));
-}
-
-ecs_iter_t flecs_filter_iter_w_flags(
-    const ecs_world_t *stage,
-    const ecs_filter_t *filter,
-    ecs_flags32_t flags)
-{
-    ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(filter->flags & (EcsFilterHasPred|EcsFilterHasScopes)),
-        ECS_UNSUPPORTED, NULL);
-    const ecs_world_t *world = ecs_get_world(stage);
-    
-    if (!(flags & EcsIterMatchVar)) {
-        flecs_process_pending_tables(world);
-    }
-
-    ecs_iter_t it = {
-        .real_world = ECS_CONST_CAST(ecs_world_t*, world),
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .query = filter,
-        .terms = filter ? filter->terms : NULL,
-        .next = ecs_filter_next,
-        .flags = flags,
-        .sizes = filter->sizes,
-        .system = filter->entity
-    };
-
-    ecs_filter_iter_t *iter = &it.priv.iter.filter;
-    iter->pivot_term = -1;
-
-    flecs_init_filter_iter(&it, filter);
-    flecs_filter_apply_iter_flags(&it, filter);
-
-    /* Find term that represents smallest superset */
-    if (ECS_BIT_IS_SET(flags, EcsIterIgnoreThis)) {
-        term_iter_init_no_data(&iter->term_iter);
-    } else if (ECS_BIT_IS_SET(filter->flags, EcsFilterMatchThis)) {
-        ecs_term_t *terms = filter->terms;
-        int32_t pivot_term = -1;
-        ecs_check(terms != NULL, ECS_INVALID_PARAMETER, NULL);
-
-        pivot_term = ecs_filter_pivot_term(world, filter);
-        iter->kind = EcsIterEvalTables;
-        iter->pivot_term = pivot_term;
-
-        if (pivot_term == -2) {
-            /* One or more terms have no matching results */
-            term_iter_init_no_data(&iter->term_iter);
-        } else if (pivot_term == -1) {
-            /* No terms meet the criteria to be a pivot term, evaluate filter
-             * against all tables */
-            term_iter_init_wildcard(world, &iter->term_iter, 
-                ECS_BIT_IS_SET(filter->flags, EcsFilterMatchEmptyTables));
-        } else {
-            ecs_assert(pivot_term >= 0, ECS_INTERNAL_ERROR, NULL);
-            term_iter_init(world, &terms[pivot_term], &iter->term_iter,
-                ECS_BIT_IS_SET(filter->flags, EcsFilterMatchEmptyTables));
-        }
-    } else {
-        if (!ECS_BIT_IS_SET(filter->flags, EcsFilterMatchAnything)) {
-            term_iter_init_no_data(&iter->term_iter);
-        } else {
-            iter->kind = EcsIterEvalNone;
-        }
-    }
-
-    ECS_BIT_COND(it.flags, EcsIterNoData, 
-        ECS_BIT_IS_SET(filter->flags, EcsFilterNoData));
-
-    if (ECS_BIT_IS_SET(filter->flags, EcsFilterMatchThis)) {
-        /* Make space for one variable if the filter has terms for This var */ 
-        it.variable_count = 1;
-
-        /* Set variable name array */
-        it.variable_names = ECS_CONST_CAST(char**, filter->variable_names);
-    }
-
-    flecs_iter_init(stage, &it, flecs_iter_cache_all);
-
-    return it;
-error:
-    return (ecs_iter_t){ 0 };
-}
-
-ecs_iter_t ecs_filter_iter(
-    const ecs_world_t *stage,
-    const ecs_filter_t *filter)
-{
-    if (filter) {
-        // Ok, only for stats
-        ECS_CONST_CAST(ecs_filter_t*, filter)->eval_count ++;
-    }
-
-    return flecs_filter_iter_w_flags(stage, filter, 0);
-}
-
-ecs_iter_t ecs_filter_chain_iter(
-    const ecs_iter_t *chain_it,
-    const ecs_filter_t *filter)
-{
-    ecs_iter_t it = {
-        .query = filter,
-        .terms = filter->terms,
-        .field_count = filter->field_count,
-        .world = chain_it->world,
-        .real_world = chain_it->real_world,
-        .chain_it = ECS_CONST_CAST(ecs_iter_t*, chain_it),
-        .next = ecs_filter_next,
-        .sizes = filter->sizes,
-        .system = filter->entity
-    };
-
-    flecs_iter_init(chain_it->world, &it, flecs_iter_cache_all);
-    ecs_filter_iter_t *iter = &it.priv.iter.filter;
-    flecs_init_filter_iter(&it, filter);
-
-    iter->kind = EcsIterEvalChain;
-
-    return it;
-}
-
-bool ecs_filter_next(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_filter_next, ECS_INVALID_PARAMETER, NULL);
-
-    if (flecs_iter_next_row(it)) {
-        return true;
-    }
-
-    return flecs_iter_next_instanced(it, ecs_filter_next_instanced(it));
-error:
-    return false;
-}
-
-bool ecs_filter_next_instanced(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_filter_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->chain_it != it, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_filter_iter_t *iter = &it->priv.iter.filter;
-    const ecs_filter_t *filter = iter->filter;
-    ecs_world_t *world = it->real_world;
-    ecs_table_t *table = NULL;
-    bool match;
-
-    flecs_iter_validate(it);
-
-    ecs_iter_t *chain_it = it->chain_it;
-    ecs_iter_kind_t kind = iter->kind;
-
-    if (chain_it) {
-        ecs_assert(kind == EcsIterEvalChain, ECS_INVALID_PARAMETER, NULL);
-        
-        ecs_iter_next_action_t next = chain_it->next;
-        do {
-            if (!next(chain_it)) {
-                goto done;
-            }
-
-            table = chain_it->table;
-            match = flecs_filter_match_table(world, filter, table,
-                it->ids, it->columns, it->sources, it->match_indices, NULL, 
-                true, -1, it->flags);
-        } while (!match);
-
-        goto yield;
-    } else if (kind == EcsIterEvalTables || kind == EcsIterEvalCondition) {
-        ecs_term_iter_t *term_iter = &iter->term_iter;
-        ecs_term_t *term = &term_iter->term;
-        int32_t pivot_term = iter->pivot_term;
-        bool first;
-
-        /* Check if the This variable has been set on the iterator. If set,
-         * the filter should only be applied to the variable value */
-        ecs_var_t *this_var = NULL;
-        ecs_table_t *this_table = NULL;
-        if (it->variable_count) {
-            if (ecs_iter_var_is_constrained(it, 0)) {
-                this_var = it->variables;
-                this_table = this_var->range.table;
-
-                /* If variable is constrained, make sure it's a value that's
-                 * pointing to a table, as a filter can't iterate single
-                 * entities (yet) */
-                ecs_assert(this_table != NULL, ECS_INVALID_OPERATION, NULL);
-
-                /* Can't set variable for filter that does not iterate tables */
-                ecs_assert(kind == EcsIterEvalTables, 
-                    ECS_INVALID_OPERATION, NULL);
-            }
-        }
-
-        do {
-            /* If there are no matches left for the previous table, this is the
-             * first match of the next table. */
-            first = iter->matches_left == 0;
-
-            if (first) {
-                if (kind != EcsIterEvalCondition) {
-                    /* Check if this variable was constrained */
-                    if (this_table != NULL) {                        
-                        /* If this is the first match of a new result and the
-                         * previous result was equal to the value of a 
-                         * constrained var, there's nothing left to iterate */
-                        if (it->table == this_table) {
-                            goto done;
-                        }
-
-                        /* If table doesn't match term iterator, it doesn't
-                         * match filter. */
-                        if (!flecs_term_iter_set_table(
-                            world, term_iter, this_table))
-                        {
-                            goto done;
-                        }
-
-                        it->offset = this_var->range.offset;
-                        it->count = this_var->range.count;
-
-                        /* But if it does, forward it to filter matching */
-                        ecs_assert(term_iter->table == this_table,
-                            ECS_INTERNAL_ERROR, NULL);
-
-                    /* If This variable is not constrained, iterate as usual */
-                    } else {
-                        it->offset = 0;
-                        it->count = 0;
-
-                        /* Find new match, starting with the leading term */
-                        if (!flecs_term_iter_next(world, term_iter, 
-                            ECS_BIT_IS_SET(filter->flags, 
-                                EcsFilterMatchPrefab), 
-                            ECS_BIT_IS_SET(filter->flags, 
-                                EcsFilterMatchDisabled))) 
-                        {
-                            goto done;
-                        }
-                    }
-
-                    ecs_assert(term_iter->match_count != 0, 
-                        ECS_INTERNAL_ERROR, NULL);
-
-                    if (pivot_term == -1) {
-                        /* Without a pivot term, we're iterating all tables with
-                         * a wildcard, so the match count is meaningless. */
-                        term_iter->match_count = 1;
-                    } else {
-                        it->match_indices[pivot_term] = term_iter->match_count;
-                    }
-
-                    iter->matches_left = term_iter->match_count;
-
-                    /* Filter iterator takes control over iterating all the
-                     * permutations that match the wildcard. */
-                    term_iter->match_count = 1;
-
-                    table = term_iter->table;
-
-                    if (pivot_term != -1) {
-                        int32_t index = term->field_index;
-                        it->ids[index] = term_iter->id;
-                        it->sources[index] = term_iter->subject;
-                        it->columns[index] = term_iter->column;
-                    }
-                } else {
-                    /* Progress iterator to next match for table, if any */
-                    table = it->table;
-                    if (term_iter->index == 0) {
-                        iter->matches_left = 1;
-                        term_iter->index = 1; /* prevents looping again */
-                    } else {
-                        goto done;
-                    }
-                }
-
-                /* Match the remainder of the terms */
-                int32_t skip_term = pivot_term;
-                if (pivot_term != -1) {
-                    if (ecs_id_is_wildcard(filter->terms[pivot_term].id)) {
-                        skip_term = -1;
-                        iter->matches_left = 1;
-                    }
-                }
-
-                match = flecs_filter_match_table(world, filter, table,
-                    it->ids, it->columns, it->sources,
-                    it->match_indices, &iter->matches_left, first, 
-                    skip_term, it->flags);
-                if (!match) {
-                    it->table = table;
-                    iter->matches_left = 0;
-                    continue;
-                }
-
-                /* Table got matched, set This variable */
-                if (table) {
-                    ecs_assert(it->variable_count == 1, ECS_INTERNAL_ERROR, NULL);
-                    ecs_assert(it->variables != NULL, ECS_INTERNAL_ERROR, NULL);
-                    it->variables[0].range.table = table;
-                }
-
-                ecs_assert(iter->matches_left != 0, ECS_INTERNAL_ERROR, NULL);
-            }
-
-            /* If this is not the first result for the table, and the table
-             * is matched more than once, iterate remaining matches */
-            if (!first && (iter->matches_left > 0)) {
-                table = it->table;
-
-                /* Find first term that still has matches left */
-                int32_t i, j, count = it->field_count;
-                for (i = count - 1; i >= 0; i --) {
-                    int32_t mi = -- it->match_indices[i];
-                    if (mi) {
-                        if (mi < 0) {
-                            continue;
-                        }
-                        break;
-                    }
-                }
-
-                /* If matches_left > 0 we should've found at least one match */
-                ecs_assert(i >= 0, ECS_INTERNAL_ERROR, NULL);
-
-                /* Progress first term to next match (must be at least one) */
-                int32_t column = it->columns[i];
-                if (column < 0) {
-                    /* If this term was matched on a non-This entity, reconvert
-                     * the column back to a positive value */
-                    column = -column;
-                }
-
-                int32_t t, term_count = filter->term_count;
-                ecs_term_t *cur_term = NULL;
-                for (t = 0; t < term_count; t ++) {
-                    if (filter->terms[t].field_index == i) {
-                        cur_term = &filter->terms[t];
-                        break;
-                    }
-                }
-
-                ecs_assert(term != NULL, ECS_INTERNAL_ERROR, NULL);
-
-                it->columns[i] = column + 1;
-                flecs_term_match_table(world, cur_term, table, 
-                    &it->ids[i], &it->columns[i], &it->sources[i],
-                    &it->match_indices[i], false, it->flags);
-
-                /* Reset remaining terms (if any) to first match */
-                for (j = i + 1; j < count; j ++) {
-                    flecs_term_match_table(world, &filter->terms[j], table, 
-                        &it->ids[j], &it->columns[j], &it->sources[j], 
-                        &it->match_indices[j], true, it->flags);
-                }
-            }
-
-            match = iter->matches_left != 0;
-            iter->matches_left --;
-
-            ecs_assert(iter->matches_left >= 0, ECS_INTERNAL_ERROR, NULL);
-        } while (!match);
-
-        goto yield;
-    }
-
-done:
-error:
-    ecs_iter_fini(it);
-    return false;
-
-yield:
-    if (!it->count && table) {
-        it->count = ecs_table_count(table);
-    }
-    flecs_iter_populate_data(world, it, table, it->offset, it->count, it->ptrs);
-    ECS_BIT_SET(it->flags, EcsIterIsValid);
-    return true;    
-}
diff --git a/src/id.c b/src/id.c
new file mode 100644
index 000000000..0ba628125
--- /dev/null
+++ b/src/id.c
@@ -0,0 +1,132 @@
+/**
+ * @file id.c
+ * @brief Id utilities.
+ */
+
+#include "private_api.h"
+
+bool ecs_id_match(
+    ecs_id_t id,
+    ecs_id_t pattern)
+{
+    if (id == pattern) {
+        return true;
+    }
+
+    if (ECS_HAS_ID_FLAG(pattern, PAIR)) {
+        if (!ECS_HAS_ID_FLAG(id, PAIR)) {
+            return false;
+        }
+
+        ecs_entity_t id_first = ECS_PAIR_FIRST(id);
+        ecs_entity_t id_second = ECS_PAIR_SECOND(id);
+        ecs_entity_t pattern_first = ECS_PAIR_FIRST(pattern);
+        ecs_entity_t pattern_second = ECS_PAIR_SECOND(pattern);
+
+        ecs_check(id_first != 0, ECS_INVALID_PARAMETER, 
+            "first element of pair cannot be 0");
+        ecs_check(id_second != 0, ECS_INVALID_PARAMETER, 
+            "second element of pair cannot be 0");
+
+        ecs_check(pattern_first != 0, ECS_INVALID_PARAMETER,
+            "first element of pair cannot be 0");
+        ecs_check(pattern_second != 0, ECS_INVALID_PARAMETER,
+            "second element of pair cannot be 0");
+        
+        if (pattern_first == EcsWildcard) {
+            if (pattern_second == EcsWildcard || pattern_second == id_second) {
+                return true;
+            }
+        } else if (pattern_first == EcsFlag) {
+            /* Used for internals, helps to keep track of which ids are used in
+             * pairs that have additional flags (like OVERRIDE and TOGGLE) */
+            if (ECS_HAS_ID_FLAG(id, PAIR) && !ECS_IS_PAIR(id)) {
+                if (ECS_PAIR_FIRST(id) == pattern_second) {
+                    return true;
+                }
+                if (ECS_PAIR_SECOND(id) == pattern_second) {
+                    return true;
+                }
+            }
+        } else if (pattern_second == EcsWildcard) {
+            if (pattern_first == id_first) {
+                return true;
+            }
+        }
+    } else {
+        if ((id & ECS_ID_FLAGS_MASK) != (pattern & ECS_ID_FLAGS_MASK)) {
+            return false;
+        }
+
+        if ((ECS_COMPONENT_MASK & pattern) == EcsWildcard) {
+            return true;
+        }
+    }
+
+error:
+    return false;
+}
+
+bool ecs_id_is_pair(
+    ecs_id_t id)
+{
+    return ECS_HAS_ID_FLAG(id, PAIR);
+}
+
+bool ecs_id_is_wildcard(
+    ecs_id_t id)
+{
+    if ((id == EcsWildcard) || (id == EcsAny)) {
+        return true;
+    }
+
+    bool is_pair = ECS_IS_PAIR(id);
+    if (!is_pair) {
+        return false;
+    }
+
+    ecs_entity_t first = ECS_PAIR_FIRST(id);
+    ecs_entity_t second = ECS_PAIR_SECOND(id);
+
+    return (first == EcsWildcard) || (second == EcsWildcard) ||
+           (first == EcsAny) || (second == EcsAny);
+}
+
+bool ecs_id_is_valid(
+    const ecs_world_t *world,
+    ecs_id_t id)
+{
+    if (!id) {
+        return false;
+    }
+    if (ecs_id_is_wildcard(id)) {
+        return false;
+    }
+
+    if (ECS_HAS_ID_FLAG(id, PAIR)) {
+        if (!ECS_PAIR_FIRST(id)) {
+            return false;
+        }
+        if (!ECS_PAIR_SECOND(id)) {
+            return false;
+        }
+    } else if (id & ECS_ID_FLAGS_MASK) {
+        if (!ecs_is_valid(world, id & ECS_COMPONENT_MASK)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+ecs_flags32_t ecs_id_get_flags(
+    const ecs_world_t *world,
+    ecs_id_t id)
+{
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
+    if (idr) {
+        return idr->flags;
+    } else {
+        return 0;
+    }
+}
diff --git a/src/iter.c b/src/iter.c
index 69afe838d..a9d797c15 100644
--- a/src/iter.c
+++ b/src/iter.c
@@ -18,12 +18,12 @@
 #define INIT_CACHE(it, stack, fields, f, T, count)\
     if (!it->f && (fields & flecs_iter_cache_##f) && count) {\
         it->f = flecs_stack_calloc_n(stack, T, count);\
-        it->priv.cache.used |= flecs_iter_cache_##f;\
+        it->priv_.cache.used |= flecs_iter_cache_##f;\
     }
 
 /* If array is allocated, free it when finalizing the iterator */
 #define FINI_CACHE(it, f, T, count)\
-    if (it->priv.cache.used & flecs_iter_cache_##f) {\
+    if (it->priv_.cache.used & flecs_iter_cache_##f) {\
         flecs_stack_free_n((void*)it->f, T, count);\
     }
 
@@ -57,15 +57,12 @@ void flecs_iter_init(
         ECS_CONST_CAST(ecs_world_t**, &world));
     ecs_stack_t *stack = &stage->allocators.iter_stack;
 
-    it->priv.cache.used = 0;
-    it->priv.cache.allocated = 0;
-    it->priv.cache.stack_cursor = flecs_stack_get_cursor(stack);
-    it->priv.entity_iter = flecs_stack_calloc_t(
-        stack, ecs_entity_filter_iter_t);
+    it->priv_.cache.used = 0;
+    it->priv_.cache.allocated = 0;
+    it->priv_.cache.stack_cursor = flecs_stack_get_cursor(stack);
 
     INIT_CACHE(it, stack, fields, ids, ecs_id_t, it->field_count);
     INIT_CACHE(it, stack, fields, sources, ecs_entity_t, it->field_count);
-    INIT_CACHE(it, stack, fields, match_indices, int32_t, it->field_count);
     INIT_CACHE(it, stack, fields, columns, int32_t, it->field_count);
     INIT_CACHE(it, stack, fields, variables, ecs_var_t, it->variable_count);
     INIT_CACHE(it, stack, fields, ptrs, void*, it->field_count);
@@ -78,7 +75,7 @@ void flecs_iter_validate(
 
     /* Make sure multithreaded iterator isn't created for real world */
     ecs_world_t *world = it->real_world;
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(!(world->flags & EcsWorldMultiThreaded) || it->world != it->real_world,
         ECS_INVALID_PARAMETER, 
             "create iterator for stage when world is in multithreaded mode");
@@ -103,193 +100,13 @@ void ecs_iter_fini(
 
     FINI_CACHE(it, ids, ecs_id_t, it->field_count);
     FINI_CACHE(it, sources, ecs_entity_t, it->field_count);
-    FINI_CACHE(it, match_indices, int32_t, it->field_count);
     FINI_CACHE(it, columns, int32_t, it->field_count);
     FINI_CACHE(it, variables, ecs_var_t, it->variable_count);
     FINI_CACHE(it, ptrs, void*, it->field_count);
-    flecs_stack_free_t(it->priv.entity_iter, ecs_entity_filter_iter_t);
 
     ecs_stage_t *stage = flecs_stage_from_world(&world);
     flecs_stack_restore_cursor(&stage->allocators.iter_stack, 
-        it->priv.cache.stack_cursor);
-}
-
-static
-bool flecs_iter_populate_term_data(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    int32_t t,
-    int32_t column,
-    void **ptr_out)
-{
-    bool is_shared = false;
-    ecs_table_t *table;
-    void *data;
-    int32_t row, u_index;
-
-    if (!column) {
-        /* Term has no data. This includes terms that have Not operators. */
-        goto no_data;
-    }
-
-    /* Filter terms may match with data but don't return it */
-    if (it->terms[t].inout == EcsInOutNone) {
-        goto no_data;
-    }
-
-    ecs_assert(it->sizes != NULL, ECS_INTERNAL_ERROR, NULL);
-    int32_t size = it->sizes[t];
-    if (!size) {
-        goto no_data;
-    }
-
-    if (column < 0) {
-        table = it->table;
-        is_shared = true;
-
-        /* Data is not from This */
-        if (it->references && (!table || !(table->flags & EcsTableHasTarget))) {
-            /* The reference array is used only for components matched on a
-             * table (vs. individual entities). Remaining components should be
-             * assigned outside of this function */
-            if (ecs_term_match_this(&it->terms[t])) {
-
-                /* Iterator provides cached references for non-This terms */
-                ecs_ref_t *ref = &it->references[-column - 1];
-                if (ptr_out) {
-                    if (ref->id) {
-                        ptr_out[0] = (void*)ecs_ref_get_id(world, ref, ref->id);
-                    } else {
-                        ptr_out[0] = NULL;
-                    }
-                }
-
-                if (!ref->id) {
-                    is_shared = false;
-                }
-
-                return is_shared;
-            }
-
-            return true;
-        } else {
-            ecs_entity_t subj = it->sources[t];
-            ecs_assert(subj != 0, ECS_INTERNAL_ERROR, NULL);
-
-            /* Don't use ecs_get_id directly. Instead, go directly to the
-             * storage so that we can get both the pointer and size */
-            ecs_record_t *r = flecs_entities_get(world, subj);
-            ecs_assert(r != NULL && r->table != NULL, ECS_INTERNAL_ERROR, NULL);
-
-            row = ECS_RECORD_TO_ROW(r->row);
-            table = r->table;
-
-            ecs_id_t id = it->ids[t];
-            ecs_table_record_t *tr;
-
-            if (!(tr = flecs_table_record_get(world, table, id)) || (tr->column == -1)) {
-                u_index = flecs_table_column_to_union_index(table, -column - 1);
-                if (u_index != -1) {
-                    goto has_union;
-                }
-                goto no_data;
-            }
-
-            /* We now have row and column, so we can get the storage for the id
-             * which gives us the pointer and size */
-            column = tr->column;
-            ecs_vec_t *s = &table->data.columns[column].data;
-            data = ecs_vec_first(s);
-            /* Fallthrough to has_data */
-        }
-    } else {
-        /* Data is from This, use table from iterator */
-        table = it->table;
-        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        row = it->offset;
-
-        int32_t storage_column = ecs_table_type_to_column_index(
-            table, column - 1);
-        if (storage_column == -1) {
-            u_index = flecs_table_column_to_union_index(table, column - 1);
-            if (u_index != -1) {
-                goto has_union;
-            }
-            goto no_data;
-        }
-
-        if (!it->count) {
-            goto no_data;
-        }
-
-        ecs_vec_t *s = &table->data.columns[storage_column].data;
-        data = ecs_vec_first(s);
-
-        /* Fallthrough to has_data */
-    }
-
-has_data:
-    if (ptr_out) ptr_out[0] = ECS_ELEM(data, size, row);
-    return is_shared;
-
-has_union: {
-        /* Edge case: if column is a switch we should return the vector with case
-         * identifiers. Will be replaced in the future with pluggable storage */
-        ecs_assert(table->_ != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_switch_t *sw = &table->_->sw_columns[u_index];
-        data = ecs_vec_first(flecs_switch_values(sw));
-        goto has_data;
-    }
-
-no_data:
-    if (ptr_out) ptr_out[0] = NULL;
-    return false;
-}
-
-void flecs_iter_populate_data(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    int32_t offset,
-    int32_t count,
-    void **ptrs)
-{
-    ecs_table_t *prev_table = it->table;
-    if (prev_table) {
-        it->frame_offset += ecs_table_count(prev_table);
-    }
-
-    it->table = table;
-    it->offset = offset;
-    it->count = count;
-    if (table) {
-        ecs_assert(count != 0 || !ecs_table_count(table) || (it->flags & EcsIterTableOnly), 
-            ECS_INTERNAL_ERROR, NULL);
-        if (count) {
-            it->entities = ecs_vec_get_t(
-                &table->data.entities, ecs_entity_t, offset);
-        } else {
-            it->entities = NULL;
-        }
-    }
-
-    int t, field_count = it->field_count;
-    if (ECS_BIT_IS_SET(it->flags, EcsIterNoData)) {
-        ECS_BIT_CLEAR(it->flags, EcsIterHasShared);
-        return;
-    }
-
-    bool has_shared = false;
-    if (ptrs) {
-        for (t = 0; t < field_count; t ++) {
-            int32_t column = it->columns[t];
-            has_shared |= flecs_iter_populate_term_data(world, it, t, column,
-                &ptrs[t]);
-        }
-    }
-
-    ECS_BIT_COND(it->flags, EcsIterHasShared, has_shared);
+        it->priv_.cache.stack_cursor);
 }
 
 bool flecs_iter_next_row(
@@ -335,8 +152,8 @@ bool flecs_iter_next_instanced(
 {
     it->instance_count = it->count;
     bool is_instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
-    bool has_shared = ECS_BIT_IS_SET(it->flags, EcsIterHasShared);
-    if (result && !is_instanced && it->count && has_shared) {
+
+    if (result && !is_instanced && it->count && it->shared_fields) {
         it->count = 1;
     }
 
@@ -350,15 +167,18 @@ void* ecs_field_w_size(
     size_t size,
     int32_t index)
 {
-    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-
+    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER,
+        "operation invalid before calling next()");
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
     ecs_check(!size || ecs_field_size(it, index) == size ||
-        (!ecs_field_size(it, index) && (!it->ptrs[index - 1])),
-            ECS_INVALID_PARAMETER, NULL);
+        (!ecs_field_size(it, index) && (!it->ptrs[index])),
+            ECS_INVALID_PARAMETER, "mismatching size for field %d", index);
     (void)size;
 
-    return it->ptrs[index - 1];
+    return it->ptrs[index];
 error:
     return NULL;
 }
@@ -367,9 +187,16 @@ bool ecs_field_is_readonly(
     const ecs_iter_t *it,
     int32_t index)
 {
-    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    ecs_term_t *term = &it->terms[index - 1];
+    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER,
+        "operation invalid before calling next()");
+    ecs_check(it->query != NULL, ECS_INVALID_PARAMETER,
+        "operation only valid for query iterators");
+    ecs_check(it->query->terms != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+    const ecs_term_t *term = &it->query->terms[index];
 
     if (term->inout == EcsIn) {
         return true;
@@ -378,8 +205,8 @@ bool ecs_field_is_readonly(
             return true;
         }
 
-        ecs_term_id_t *src = &term->src;
-        if (!(src->flags & EcsSelf)) {
+        const ecs_term_ref_t *src = &term->src;
+        if (!(src->id & EcsSelf)) {
             return true;
         }
     }
@@ -391,9 +218,17 @@ bool ecs_field_is_writeonly(
     const ecs_iter_t *it,
     int32_t index)
 {
-    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    ecs_term_t *term = &it->terms[index - 1];
+    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER,
+        "operation invalid before calling next()");
+    ecs_check(it->query != NULL, ECS_INVALID_PARAMETER,
+        "operation only valid for query iterators");
+    ecs_check(it->query->terms != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
+    const ecs_term_t *term = &it->query->terms[index];
     return term->inout == EcsOut;
 error:
     return false;
@@ -403,21 +238,14 @@ bool ecs_field_is_set(
     const ecs_iter_t *it,
     int32_t index)
 {
-    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    int32_t column = it->columns[index - 1];
-    if (!column) {
-        return false;
-    } else if (column < 0) {
-        if (it->references) {
-            column = -column - 1;
-            ecs_ref_t *ref = &it->references[column];
-            return ref->entity != 0;
-        } else {
-            return true;
-        }
-    }
-    return true;
+    ecs_check(it->flags & EcsIterIsValid, ECS_INVALID_PARAMETER,
+        "operation invalid before calling next()");
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
+    return it->set_fields & (1llu << (index));
 error:
     return false;
 }
@@ -426,49 +254,74 @@ bool ecs_field_is_self(
     const ecs_iter_t *it,
     int32_t index)
 {
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    return it->sources == NULL || it->sources[index - 1] == 0;
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
+    return it->sources == NULL || it->sources[index] == 0;
+error:
+    return false;
 }
 
 ecs_id_t ecs_field_id(
     const ecs_iter_t *it,
     int32_t index)
 {
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    return it->ids[index - 1];
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
+    return it->ids[index];
+error:
+    return 0;
 }
 
-int32_t ecs_field_column_index(
+int32_t ecs_field_column(
     const ecs_iter_t *it,
     int32_t index)
 {
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    int32_t result = it->columns[index - 1];
-    if (result <= 0) {
-        return -1;
-    } else {
-        return result - 1;
-    }
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
+    return it->columns[index];
+error:
+    return 0;
 }
 
 ecs_entity_t ecs_field_src(
     const ecs_iter_t *it,
     int32_t index)
 {
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
     if (it->sources) {
-        return it->sources[index - 1];
+        return it->sources[index];
     } else {
         return 0;
     }
+error:
+    return 0;
 }
 
 size_t ecs_field_size(
     const ecs_iter_t *it,
     int32_t index)
 {
-    ecs_assert(index >= 1, ECS_INVALID_PARAMETER, NULL);
-    return (size_t)it->sizes[index - 1];
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
+    ecs_check(index < it->field_count, ECS_INVALID_PARAMETER, 
+        "field index %d out of bounds", index);
+
+    return (size_t)it->sizes[index];
+error:
+    return 0;
 }
 
 char* ecs_iter_str(
@@ -485,7 +338,7 @@ char* ecs_iter_str(
     if (it->field_count) {
         ecs_strbuf_list_push(&buf, "id:  ", ",");
         for (i = 0; i < it->field_count; i ++) {
-            ecs_id_t id = ecs_field_id(it, i + 1);
+            ecs_id_t id = ecs_field_id(it, i);
             char *str = ecs_id_str(world, id);
             ecs_strbuf_list_appendstr(&buf, str);
             ecs_os_free(str);
@@ -494,7 +347,7 @@ char* ecs_iter_str(
 
         ecs_strbuf_list_push(&buf, "src: ", ",");
         for (i = 0; i < it->field_count; i ++) {
-            ecs_entity_t subj = ecs_field_src(it, i + 1);
+            ecs_entity_t subj = ecs_field_src(it, i);
             char *str = ecs_get_fullpath(world, subj);
             ecs_strbuf_list_appendstr(&buf, str);
             ecs_os_free(str);
@@ -503,7 +356,7 @@ char* ecs_iter_str(
 
         ecs_strbuf_list_push(&buf, "set: ", ",");
         for (i = 0; i < it->field_count; i ++) {
-            if (ecs_field_is_set(it, i + 1)) {
+            if (ecs_field_is_set(it, i)) {
                 ecs_strbuf_list_appendlit(&buf, "true");
             } else {
                 ecs_strbuf_list_appendlit(&buf, "false");
@@ -516,7 +369,7 @@ char* ecs_iter_str(
         int32_t actual_count = 0;
         for (i = 0; i < it->variable_count; i ++) {
             const char *var_name = it->variable_names[i];
-            if (!var_name || var_name[0] == '_' || !strcmp(var_name, "This")) {
+            if (!var_name || var_name[0] == '_' || !strcmp(var_name, "this")) {
                 /* Skip anonymous variables */
                 continue;
             }
@@ -557,16 +410,6 @@ char* ecs_iter_str(
     return ecs_strbuf_get(&buf);
 }
 
-void ecs_iter_poly(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter_out,
-    ecs_term_t *filter)
-{
-    ecs_iterable_t *iterable = ecs_get_iterable(poly);
-    iterable->init(world, poly, iter_out, filter);
-}
-
 bool ecs_iter_next(
     ecs_iter_t *iter)
 {
@@ -634,8 +477,10 @@ ecs_entity_t ecs_iter_get_var(
     ecs_iter_t *it,
     int32_t var_id)
 {
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER,
+        "variable index %d out of bounds", var_id);
     ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL);
 
     ecs_var_t *var = &it->variables[var_id];
@@ -666,8 +511,10 @@ ecs_table_t* ecs_iter_get_var_as_table(
     ecs_iter_t *it,
     int32_t var_id)
 {
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, 
+        "variable index %d out of bounds", var_id);
     ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL);
 
     ecs_var_t *var = &it->variables[var_id];
@@ -712,8 +559,10 @@ ecs_table_range_t ecs_iter_get_var_as_range(
     ecs_iter_t *it,
     int32_t var_id)
 {
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, 
+        "variable index %d out of bounds", var_id);
     ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL);
 
     ecs_table_range_t result = { 0 };
@@ -754,12 +603,14 @@ void ecs_iter_set_var(
     ecs_entity_t entity)
 {
     ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < FLECS_VARIABLE_COUNT_MAX, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < FLECS_QUERY_VARIABLE_COUNT_MAX, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, 
+        "variable index %d out of bounds", var_id);
     ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL);
-    /* Can't set variable while iterating */
-    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_PARAMETER,
+        "cannot constrain variable while iterating");
     ecs_check(it->variables != NULL, ECS_INTERNAL_ERROR, NULL);
 
     ecs_var_t *var = &it->variables[var_id];
@@ -778,10 +629,6 @@ void ecs_iter_set_var(
 
     it->constrained_vars |= flecs_ito(uint64_t, 1 << var_id);
 
-    if (it->set_var) {
-        it->set_var(it);
-    }
-
 error:
     return;
 }
@@ -801,9 +648,10 @@ void ecs_iter_set_var_as_range(
     const ecs_table_range_t *range)
 {
     ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < FLECS_VARIABLE_COUNT_MAX, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(var_id >= 0, ECS_INVALID_PARAMETER, 
+        "invalid variable index %d", var_id);
+    ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, 
+        "variable index %d out of bounds", var_id);
     ecs_check(range != 0, ECS_INVALID_PARAMETER, NULL);
     ecs_check(range->table != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(!range->offset || range->offset < ecs_table_count(range->table), 
@@ -811,8 +659,8 @@ void ecs_iter_set_var_as_range(
     ecs_check((range->offset + range->count) <= ecs_table_count(range->table), 
         ECS_INVALID_PARAMETER, NULL);
 
-    /* Can't set variable while iterating */
-    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_OPERATION, NULL);
+    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_OPERATION, 
+        "cannot set query variables while iterating");
 
     ecs_var_t *var = &it->variables[var_id];
     var->range = *range;
@@ -859,9 +707,9 @@ ecs_iter_t ecs_page_iter(
     ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL);
 
     ecs_iter_t result = *it;
-    result.priv.cache.stack_cursor = NULL; /* Don't copy allocator cursor */
+    result.priv_.cache.stack_cursor = NULL; /* Don't copy allocator cursor */
 
-    result.priv.iter.page = (ecs_page_iter_t){
+    result.priv_.iter.page = (ecs_page_iter_t){
         .offset = offset,
         .limit = limit,
         .remaining = limit
@@ -916,10 +764,10 @@ bool ecs_page_next_instanced(
             goto depleted;
         }
 
-        ecs_page_iter_t *iter = &it->priv.iter.page;
+        ecs_page_iter_t *iter = &it->priv_.iter.page;
         
         /* Copy everything up to the private iterator data */
-        ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv));
+        ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv_));
 
         /* Keep instancing setting from original iterator */
         ECS_BIT_COND(it->flags, EcsIterIsInstanced, instanced);
@@ -1008,13 +856,14 @@ ecs_iter_t ecs_worker_iter(
     ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(count > 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(index >= 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(index >= 0, ECS_INVALID_PARAMETER, 
+        "invalid field index %d", index);
     ecs_check(index < count, ECS_INVALID_PARAMETER, NULL);
 
     ecs_iter_t result = *it;
-    result.priv.cache.stack_cursor = NULL; /* Don't copy allocator cursor */
+    result.priv_.cache.stack_cursor = NULL; /* Don't copy allocator cursor */
     
-    result.priv.iter.worker = (ecs_worker_iter_t){
+    result.priv_.iter.worker = (ecs_worker_iter_t){
         .index = index,
         .count = count
     };
@@ -1038,7 +887,7 @@ bool ecs_worker_next_instanced(
     bool instanced = ECS_BIT_IS_SET(it->flags, EcsIterIsInstanced);
 
     ecs_iter_t *chain_it = it->chain_it;
-    ecs_worker_iter_t *iter = &it->priv.iter.worker;
+    ecs_worker_iter_t *iter = &it->priv_.iter.worker;
     int32_t res_count = iter->count, res_index = iter->index;
     int32_t per_worker, instances_per_worker, first;
 
@@ -1048,7 +897,7 @@ bool ecs_worker_next_instanced(
         }
 
         /* Copy everything up to the private iterator data */
-        ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv));
+        ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv_));
 
         /* Keep instancing setting from original iterator */
         ECS_BIT_COND(it->flags, EcsIterIsInstanced, instanced);
diff --git a/src/iter.h b/src/iter.h
index e07418c65..0e94da5c8 100644
--- a/src/iter.h
+++ b/src/iter.h
@@ -14,14 +14,6 @@ void flecs_iter_init(
 void flecs_iter_validate(
     ecs_iter_t *it);
 
-void flecs_iter_populate_data(
-    ecs_world_t *world,
-    ecs_iter_t *it,
-    ecs_table_t *table,
-    int32_t offset,
-    int32_t count,
-    void **ptrs);
-
 bool flecs_iter_next_row(
     ecs_iter_t *it);
 
diff --git a/src/misc.c b/src/misc.c
index b24898205..8712cf40b 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -141,7 +141,7 @@ uint64_t flecs_string_hash(
     return str->hash;
 }
 
-char* ecs_vasprintf(
+char* flecs_vasprintf(
     const char *fmt,
     va_list args)
 {
@@ -170,13 +170,13 @@ char* ecs_vasprintf(
     return result;
 }
 
-char* ecs_asprintf(
+char* flecs_asprintf(
     const char *fmt,
     ...)
 {
     va_list args;
     va_start(args, fmt);
-    char *result = ecs_vasprintf(fmt, args);
+    char *result = flecs_vasprintf(fmt, args);
     va_end(args);
     return result;
 }
@@ -255,3 +255,213 @@ char* flecs_load_from_file(
     ecs_os_free(content);
     return NULL;
 }
+
+char* flecs_chresc(
+    char *out, 
+    char in, 
+    char delimiter) 
+{
+    char *bptr = out;
+    switch(in) {
+    case '\a':
+        *bptr++ = '\\';
+        *bptr = 'a';
+        break;
+    case '\b':
+        *bptr++ = '\\';
+        *bptr = 'b';
+        break;
+    case '\f':
+        *bptr++ = '\\';
+        *bptr = 'f';
+        break;
+    case '\n':
+        *bptr++ = '\\';
+        *bptr = 'n';
+        break;
+    case '\r':
+        *bptr++ = '\\';
+        *bptr = 'r';
+        break;
+    case '\t':
+        *bptr++ = '\\';
+        *bptr = 't';
+        break;
+    case '\v':
+        *bptr++ = '\\';
+        *bptr = 'v';
+        break;
+    case '\\':
+        *bptr++ = '\\';
+        *bptr = '\\';
+        break;
+    case '\033':
+        *bptr = '['; /* Used for terminal colors */
+        break;
+    default:
+        if (in == delimiter) {
+            *bptr++ = '\\';
+            *bptr = delimiter;
+        } else {
+            *bptr = in;
+        }
+        break;
+    }
+
+    *(++bptr) = '\0';
+
+    return bptr;
+}
+
+const char* flecs_chrparse(
+    const char *in, 
+    char *out) 
+{
+    const char *result = in + 1;
+    char ch;
+
+    if (in[0] == '\\') {
+        result ++;
+
+        switch(in[1]) {
+        case 'a':
+            ch = '\a';
+            break;
+        case 'b':
+            ch = '\b';
+            break;
+        case 'f':
+            ch = '\f';
+            break;
+        case 'n':
+            ch = '\n';
+            break;
+        case 'r':
+            ch = '\r';
+            break;
+        case 't':
+            ch = '\t';
+            break;
+        case 'v':
+            ch = '\v';
+            break;
+        case '\\':
+            ch = '\\';
+            break;
+        case '"':
+            ch = '"';
+            break;
+        case '0':
+            ch = '\0';
+            break;
+        case ' ':
+            ch = ' ';
+            break;
+        case '$':
+            ch = '$';
+            break;
+        default:
+            goto error;
+        }
+    } else {
+        ch = in[0];
+    }
+
+    if (out) {
+        *out = ch;
+    }
+
+    return result;
+error:
+    return NULL;
+}
+
+ecs_size_t flecs_stresc(
+    char *out, 
+    ecs_size_t n, 
+    char delimiter, 
+    const char *in) 
+{
+    const char *ptr = in;
+    char ch, *bptr = out, buff[3];
+    ecs_size_t written = 0;
+    while ((ch = *ptr++)) {
+        if ((written += (ecs_size_t)(flecs_chresc(
+            buff, ch, delimiter) - buff)) <= n) 
+        {
+            /* If size != 0, an out buffer must be provided. */
+            ecs_check(out != NULL, ECS_INVALID_PARAMETER, NULL);
+            *bptr++ = buff[0];
+            if ((ch = buff[1])) {
+                *bptr = ch;
+                bptr++;
+            }
+        }
+    }
+
+    if (bptr) {
+        while (written < n) {
+            *bptr = '\0';
+            bptr++;
+            written++;
+        }
+    }
+    return written;
+error:
+    return 0;
+}
+
+char* flecs_astresc(
+    char delimiter, 
+    const char *in)
+{
+    if (!in) {
+        return NULL;
+    }
+
+    ecs_size_t len = flecs_stresc(NULL, 0, delimiter, in);
+    char *out = ecs_os_malloc_n(char, len + 1);
+    flecs_stresc(out, len, delimiter, in);
+    out[len] = '\0';
+    return out;
+}
+
+const char* flecs_parse_digit(
+    const char *ptr,
+    char *token)
+{
+    char *tptr = token;
+    char ch = ptr[0];
+
+    if (!isdigit(ch) && ch != '-') {
+        ecs_parser_error(NULL, NULL, 0, "invalid start of number '%s'", ptr);
+        return NULL;
+    }
+
+    tptr[0] = ch;
+    tptr ++;
+    ptr ++;
+
+    for (; (ch = *ptr); ptr ++) {
+        if (!isdigit(ch) && (ch != '.') && (ch != 'e')) {
+            break;
+        }
+
+        tptr[0] = ch;
+        tptr ++;
+    }
+
+    tptr[0] = '\0';
+    
+    return ptr;
+}
+
+const char* flecs_parse_ws_eol(
+    const char *ptr)
+{
+    while (isspace(*ptr)) {
+        ptr ++;
+    }
+
+    return ptr;
+}
diff --git a/src/observable.c b/src/observable.c
index 565d41f4e..9d0e561e5 100644
--- a/src/observable.c
+++ b/src/observable.c
@@ -40,7 +40,7 @@ void flecs_observable_fini(
         ecs_assert(er != NULL, ECS_INTERNAL_ERROR, NULL);
         (void)er;
 
-        /* All triggers should've unregistered by now */
+        /* All observers should've unregistered by now */
         ecs_assert(!ecs_map_is_init(&er->event_ids), 
             ECS_INTERNAL_ERROR, NULL);
     }
@@ -611,14 +611,14 @@ void flecs_emit_forward_id(
     it->sources[0] = tgt;
     it->event_id = id;
     it->ptrs[0] = NULL;
-    it->sizes[0] = 0;
+    ECS_CONST_CAST(int32_t*, it->sizes)[0] = 0; /* safe, owned by observer */
 
     int32_t storage_i = ecs_table_type_to_column_index(tgt_table, column);
     if (storage_i != -1) {
         ecs_assert(idr->type_info != NULL, ECS_INTERNAL_ERROR, NULL);
         ecs_column_t *c = &tgt_table->data.columns[storage_i];
         it->ptrs[0] = ecs_vec_get(&c->data, c->ti->size, offset);
-        it->sizes[0] = c->ti->size;
+        ECS_CONST_CAST(int32_t*, it->sizes)[0] = c->ti->size; /* safe, see above */
     }
 
     ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
@@ -1097,7 +1097,7 @@ void flecs_emit(
     ecs_world_t *stage,
     ecs_event_desc_t *desc)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(desc->event != 0, ECS_INVALID_PARAMETER, NULL);
     ecs_check(desc->event != EcsWildcard, ECS_INVALID_PARAMETER, NULL);
@@ -1120,9 +1120,9 @@ void flecs_emit(
     ecs_flags32_t table_flags = table->flags;
 
     /* Deferring cannot be suspended for observers */
-    int32_t defer = world->stages[0].defer;
+    int32_t defer = world->stages[0]->defer;
     if (defer < 0) {
-        world->stages[0].defer *= -1;
+        world->stages[0]->defer *= -1;
     }
 
     /* Table events are emitted for internal table operations only, and do not
@@ -1246,14 +1246,14 @@ void flecs_emit(
         /* Check if this id is a pair of an traversable relationship. If so, we 
          * may have to forward ids from the pair's target. */
         if ((can_forward && is_pair) || can_override) {
-            idr = flecs_query_id_record_get(world, id);
+            idr = flecs_id_record_get(world, id);
             ecs_flags32_t idr_flags = idr->flags;
 
             if (is_pair && (idr_flags & EcsIdTraversable)) {
                 const ecs_event_record_t *er_fwd = NULL;
                 if (ECS_PAIR_FIRST(id) == EcsIsA) {
                     if (event == EcsOnAdd) {
-                        if (!world->stages[0].base) {
+                        if (!world->stages[0]->base) {
                             /* Adding an IsA relationship can trigger prefab
                              * instantiation, which can instantiate prefab 
                              * hierarchies for the entity to which the 
@@ -1263,9 +1263,9 @@ void flecs_emit(
                             /* Setting this value prevents flecs_instantiate 
                              * from being called recursively, in case prefab
                              * children also have IsA relationships. */
-                            world->stages[0].base = tgt;
+                            world->stages[0]->base = tgt;
                             flecs_instantiate(world, tgt, table, offset, count);
-                            world->stages[0].base = 0;
+                            world->stages[0]->base = 0;
                         }
 
                         /* Adding an IsA relationship will emit OnSet events for
@@ -1310,14 +1310,14 @@ void flecs_emit(
              * example, both observers for (ChildOf, p) and (ChildOf, *) would
              * match an event for (ChildOf, p). */
             ider_count = flecs_event_observers_get(er, id, iders);
-            idr = idr ? idr : flecs_query_id_record_get(world, id);
+            idr = idr ? idr : flecs_id_record_get(world, id);
             ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
         }
 
         if (can_unset) {
             /* Increase UnSet count in case this is a component (has data). This
              * will cause the event loop to be ran again as UnSet event. */
-            idr = idr ? idr : flecs_query_id_record_get(world, id);
+            idr = idr ? idr : flecs_id_record_get(world, id);
             ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
             unset_count += (idr->type_info != NULL);
         }
@@ -1339,7 +1339,7 @@ void flecs_emit(
         int32_t column = tr->index, storage_i;
         it.columns[0] = column + 1;
         it.ptrs[0] = NULL;
-        it.sizes[0] = 0;
+        ECS_CONST_CAST(int32_t*, it.sizes)[0] = 0; /* safe, owned by observer */
         it.event_id = id;
         it.ids[0] = id;
 
@@ -1351,7 +1351,8 @@ void flecs_emit(
                 ecs_column_t *c = &columns[storage_i];
                 ecs_size_t size = c->ti->size;
                 void *ptr = ecs_vec_get(&c->data, size, offset);
-                it.sizes[0] = size;
+                /* safe, owned by observer */
+                ECS_CONST_CAST(int32_t*, it.sizes)[0] = size;
 
                 if (override_ptr) {
                     if (event == EcsOnAdd) {
@@ -1439,7 +1440,7 @@ void flecs_emit(
     }
 
 error:
-    world->stages[0].defer = defer;
+    world->stages[0]->defer = defer;
 
     if (measure_time) {
         world->info.emit_time_total += (ecs_ftime_t)ecs_time_measure(&t);
diff --git a/src/observable.h b/src/observable.h
index 300f9ca77..18d59a9ab 100644
--- a/src/observable.h
+++ b/src/observable.h
@@ -6,6 +6,47 @@
 #ifndef FLECS_OBSERVABLE_H
 #define FLECS_OBSERVABLE_H
 
+/** All observers for a specific (component) id */
+typedef struct ecs_event_id_record_t {
+    /* Triggers for Self */
+    ecs_map_t self;                  /* map<trigger_id, trigger_t> */
+    ecs_map_t self_up;               /* map<trigger_id, trigger_t> */
+    ecs_map_t up;                    /* map<trigger_id, trigger_t> */
+
+    ecs_map_t observers;             /* map<trigger_id, trigger_t> */
+
+    /* Triggers for SuperSet, SubSet */
+    ecs_map_t set_observers;         /* map<trigger_id, trigger_t> */
+
+    /* Triggers for Self with non-This subject */
+    ecs_map_t entity_observers;      /* map<trigger_id, trigger_t> */
+
+    /* Number of active observers for (component) id */
+    int32_t observer_count;
+} ecs_event_id_record_t;
+
+typedef struct ecs_observer_impl_t {
+    ecs_observer_t pub;
+
+    int32_t *last_event_id;     /**< Last handled event id */
+    int32_t last_event_id_storage;
+
+    ecs_id_t register_id;       /**< Id observer is registered with (single term observers only) */
+    int32_t term_index;         /**< Index of the term in parent observer (single term observers only) */
+
+    ecs_flags32_t flags;        /**< Observer flags */
+    uint64_t id;                /**< Internal id (not entity id) */
+    ecs_vec_t children;         /**< If multi observer, vector stores child observers */
+
+    ecs_query_t *not_query;     /**< Query used to populate observer data when a
+                                     term with a not operator triggers. */
+
+    /* Mixins */
+    flecs_poly_dtor_t dtor;
+} ecs_observer_impl_t;
+
+#define flecs_observer_impl(observer) (ECS_CONST_CAST(ecs_observer_impl_t*, observer))
+
 ecs_event_record_t* flecs_event_record_get(
     const ecs_observable_t *o,
     ecs_entity_t event);
@@ -38,6 +79,11 @@ bool flecs_observers_exist(
     ecs_id_t id,
     ecs_entity_t event);
 
+ecs_observer_t* flecs_observer_init(
+    ecs_world_t *world,
+    ecs_entity_t entity,
+    const ecs_observer_desc_t *desc);
+
 void flecs_observer_fini(
     ecs_observer_t *observer);
 
@@ -62,4 +108,10 @@ void flecs_emit_propagate_invalidate(
     int32_t offset,
     int32_t count);
 
+void flecs_observer_set_disable_bit(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    ecs_flags32_t bit,
+    bool cond);
+
 #endif
diff --git a/src/observer.c b/src/observer.c
index a8f409665..e0b994dd5 100644
--- a/src/observer.c
+++ b/src/observer.c
@@ -126,17 +126,18 @@ static
 void flecs_register_observer_for_id(
     ecs_world_t *world,
     ecs_observable_t *observable,
-    ecs_observer_t *observer,
+    ecs_observer_t *o,
     size_t offset)
 {
-    ecs_id_t term_id = flecs_observer_id(observer->register_id);
-    ecs_term_t *term = &observer->filter.terms[0];
-    ecs_entity_t trav = term->src.trav;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    ecs_id_t term_id = flecs_observer_id(impl->register_id);
+    ecs_term_t *term = &o->query->terms[0];
+    ecs_entity_t trav = term->trav;
 
     int i;
-    for (i = 0; i < observer->event_count; i ++) {
+    for (i = 0; i < o->event_count; i ++) {
         ecs_entity_t event = flecs_get_observer_event(
-            term, observer->events[i]);
+            term, o->events[i]);
 
         /* Get observers for event */
         ecs_event_record_t *er = flecs_event_record_ensure(observable, event);
@@ -149,7 +150,7 @@ void flecs_register_observer_for_id(
 
         ecs_map_t *observers = ECS_OFFSET(idt, offset);
         ecs_map_init_w_params_if(observers, &world->allocators.ptr);
-        ecs_map_insert_ptr(observers, observer->filter.entity, observer);
+        ecs_map_insert_ptr(observers, impl->id, o);
 
         flecs_inc_observer_count(world, event, er, term_id, 1);
         if (trav) {
@@ -163,20 +164,20 @@ static
 void flecs_uni_observer_register(
     ecs_world_t *world,
     ecs_observable_t *observable,
-    ecs_observer_t *observer)
+    ecs_observer_t *o)
 {
-    ecs_term_t *term = &observer->filter.terms[0];
-    ecs_flags32_t flags = term->src.flags;
+    ecs_term_t *term = &o->query->terms[0];
+    ecs_flags64_t flags = ECS_TERM_REF_FLAGS(&term->src);
 
     if ((flags & (EcsSelf|EcsUp)) == (EcsSelf|EcsUp)) {
-        flecs_register_observer_for_id(world, observable, observer,
+        flecs_register_observer_for_id(world, observable, o,
             offsetof(ecs_event_id_record_t, self_up));
     } else if (flags & EcsSelf) {
-        flecs_register_observer_for_id(world, observable, observer,
+        flecs_register_observer_for_id(world, observable, o,
             offsetof(ecs_event_id_record_t, self));
     } else if (flags & EcsUp) {
-        ecs_assert(term->src.trav != 0, ECS_INTERNAL_ERROR, NULL);
-        flecs_register_observer_for_id(world, observable, observer,
+        ecs_assert(term->trav != 0, ECS_INTERNAL_ERROR, NULL);
+        flecs_register_observer_for_id(world, observable, o,
             offsetof(ecs_event_id_record_t, up));
     }
 }
@@ -185,17 +186,18 @@ static
 void flecs_unregister_observer_for_id(
     ecs_world_t *world,
     ecs_observable_t *observable,
-    ecs_observer_t *observer,
+    ecs_observer_t *o,
     size_t offset)
 {
-    ecs_id_t term_id = flecs_observer_id(observer->register_id);
-    ecs_term_t *term = &observer->filter.terms[0];
-    ecs_entity_t trav = term->src.trav;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    ecs_id_t term_id = flecs_observer_id(impl->register_id);
+    ecs_term_t *term = &o->query->terms[0];
+    ecs_entity_t trav = term->trav;
 
     int i;
-    for (i = 0; i < observer->event_count; i ++) {
+    for (i = 0; i < o->event_count; i ++) {
         ecs_entity_t event = flecs_get_observer_event(
-            term, observer->events[i]);
+            term, o->events[i]);
 
         /* Get observers for event */
         ecs_event_record_t *er = flecs_event_record_get(observable, event);
@@ -206,7 +208,7 @@ void flecs_unregister_observer_for_id(
         ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL);
 
         ecs_map_t *id_observers = ECS_OFFSET(idt, offset);
-        ecs_map_remove(id_observers, observer->filter.entity);
+        ecs_map_remove(id_observers, impl->id);
         if (!ecs_map_count(id_observers)) {
             ecs_map_fini(id_observers);
         }
@@ -223,53 +225,53 @@ static
 void flecs_unregister_observer(
     ecs_world_t *world,
     ecs_observable_t *observable,
-    ecs_observer_t *observer)
+    ecs_observer_t *o)
 {
-    ecs_assert(observer != NULL, ECS_INTERNAL_ERROR, NULL);
-    if (!observer->filter.terms) {
-        ecs_assert(observer->filter.term_count == 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (o->query->term_count == 0) {
         return;
     }
 
-    ecs_term_t *term = &observer->filter.terms[0];
-    ecs_flags32_t flags = term->src.flags;
+    ecs_term_t *term = &o->query->terms[0];
+    ecs_flags64_t flags = ECS_TERM_REF_FLAGS(&term->src);
 
     if ((flags & (EcsSelf|EcsUp)) == (EcsSelf|EcsUp)) {
-        flecs_unregister_observer_for_id(world, observable, observer,
+        flecs_unregister_observer_for_id(world, observable, o,
             offsetof(ecs_event_id_record_t, self_up));
     } else if (flags & EcsSelf) {
-        flecs_unregister_observer_for_id(world, observable, observer,
+        flecs_unregister_observer_for_id(world, observable, o,
             offsetof(ecs_event_id_record_t, self));
     } else if (flags & EcsUp) {
-        flecs_unregister_observer_for_id(world, observable, observer,
+        flecs_unregister_observer_for_id(world, observable, o,
             offsetof(ecs_event_id_record_t, up));
     }
 }
 
 static
 bool flecs_ignore_observer(
-    ecs_observer_t *observer,
+    ecs_observer_t *o,
     ecs_table_t *table,
     ecs_iter_t *it)
 {
-    ecs_assert(observer != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
 
-    int32_t *last_event_id = observer->last_event_id;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    int32_t *last_event_id = impl->last_event_id;
     if (last_event_id && last_event_id[0] == it->event_cur) {
         return true;
     }
 
-    if (observer->flags & (EcsObserverIsDisabled|EcsObserverIsParentDisabled)) {
+    if (impl->flags & (EcsObserverIsDisabled|EcsObserverIsParentDisabled)) {
         return true;
     }
 
-    ecs_flags32_t table_flags = table->flags, filter_flags = observer->filter.flags;
+    ecs_flags32_t table_flags = table->flags, query_flags = o->query->flags;
 
     bool result = (table_flags & EcsTableIsPrefab) &&
-        !(filter_flags & EcsFilterMatchPrefab);
+        !(query_flags & EcsQueryMatchPrefab);
     result = result || ((table_flags & EcsTableIsDisabled) &&
-        !(filter_flags & EcsFilterMatchDisabled));
+        !(query_flags & EcsQueryMatchDisabled));
 
     return result;
 }
@@ -285,7 +287,7 @@ static
 void flecs_observer_invoke(
     ecs_world_t *world,
     ecs_iter_t *it,
-    ecs_observer_t *observer,
+    ecs_observer_t *o,
     ecs_iter_action_t callback,
     int32_t term_index,
     bool simple_result) 
@@ -301,26 +303,27 @@ void flecs_observer_invoke(
     ecs_log_push_3();
 
     ecs_entity_t old_system = flecs_stage_set_system(
-        &world->stages[0], observer->filter.entity);
+        world->stages[0], o->entity);
     world->info.observers_ran_frame ++;
 
-    ecs_filter_t *filter = &observer->filter;
-    ecs_assert(term_index < filter->term_count, ECS_INTERNAL_ERROR, NULL);
-    ecs_term_t *term = &filter->terms[term_index];
-    if (term->oper != EcsNot) {
+    ecs_query_t *query = o->query;
+    ecs_assert(term_index < query->term_count, ECS_INTERNAL_ERROR, NULL);
+    ecs_term_t *term = &query->terms[term_index];
+    if (it->table && (term->oper != EcsNot)) {
         ecs_assert((it->offset + it->count) <= ecs_table_count(it->table), 
             ECS_INTERNAL_ERROR, NULL);
     }
 
-    bool instanced = filter->flags & EcsFilterIsInstanced;
-    bool match_this = filter->flags & EcsFilterMatchThis;
+    bool instanced = query->flags & EcsQueryIsInstanced;
+    bool match_this = query->flags & EcsQueryMatchThis;
     bool table_only = it->flags & EcsIterTableOnly;
+
     if (match_this && (simple_result || instanced || table_only)) {
         callback(it);
-        filter->eval_count ++;
+        query->eval_count ++;
     } else {
-        ecs_entity_t observer_src = term->src.id;
-        if (observer_src && !(term->src.flags & EcsIsEntity)) {
+        ecs_entity_t observer_src = ECS_TERM_REF_ID(&term->src);
+        if (observer_src && !(term->src.id & EcsIsEntity)) {
             observer_src = 0;
         }
 
@@ -333,7 +336,7 @@ void flecs_observer_invoke(
             it->entities = &e;
             if (!observer_src) {
                 callback(it);
-                filter->eval_count ++;
+                query->eval_count ++;
             } else if (observer_src == e) {
                 ecs_entity_t dummy = 0;
                 it->entities = &dummy;
@@ -342,7 +345,7 @@ void flecs_observer_invoke(
                 }
 
                 callback(it);
-                filter->eval_count ++;
+                query->eval_count ++;
                 it->sources[0] = src;
                 break;
             }
@@ -351,7 +354,7 @@ void flecs_observer_invoke(
         it->count = count;
     }
 
-    flecs_stage_set_system(&world->stages[0], old_system);
+    flecs_stage_set_system(world->stages[0], old_system);
 
     ecs_log_pop_3();
 }
@@ -377,45 +380,45 @@ void flecs_default_uni_observer_run_callback(ecs_iter_t *it) {
 static
 void flecs_uni_observer_invoke(
     ecs_world_t *world,
-    ecs_observer_t *observer,
+    ecs_observer_t *o,
     ecs_iter_t *it,
     ecs_table_t *table,
     ecs_entity_t trav,
     bool simple_result)
 {
-    ecs_filter_t *filter = &observer->filter;
-    ecs_term_t *term = &filter->terms[0];
-    if (flecs_ignore_observer(observer, table, it)) {
+    ecs_query_t *query = o->query;
+    ecs_term_t *term = &query->terms[0];
+    if (flecs_ignore_observer(o, table, it)) {
         return;
     }
 
     ecs_assert(trav == 0 || it->sources[0] != 0, ECS_INTERNAL_ERROR, NULL);
-    if (trav && term->src.trav != trav) {
+    if (trav && term->trav != trav) {
         return;
     }
 
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
     bool is_filter = term->inout == EcsInOutNone;
     ECS_BIT_COND(it->flags, EcsIterNoData, is_filter);
-    it->system = observer->filter.entity;
-    it->ctx = observer->ctx;
-    it->binding_ctx = observer->binding_ctx;
-    it->term_index = observer->term_index;
-    it->query = &observer->filter;
-    it->terms = observer->filter.terms;
+    it->system = o->entity;
+    it->ctx = o->ctx;
+    it->binding_ctx = o->binding_ctx;
+    it->term_index = impl->term_index;
+    it->query = o->query;
 
     ecs_entity_t event = it->event;
     int32_t event_cur = it->event_cur;
     it->event = flecs_get_observer_event(term, event);
 
-    if (observer->run) {
+    if (o->run) {
         it->next = flecs_default_observer_next_callback;
         it->callback = flecs_default_uni_observer_run_callback;
-        it->ctx = observer;
-        observer->run(it);
+        it->ctx = o;
+        o->run(it);
     } else {
-        ecs_iter_action_t callback = observer->callback;
+        ecs_iter_action_t callback = o->callback;
         it->callback = callback;
-        flecs_observer_invoke(world, it, observer, callback, 0, simple_result);
+        flecs_observer_invoke(world, it, o, callback, 0, simple_result);
     }
 
     it->event = event;
@@ -450,111 +453,117 @@ bool flecs_multi_observer_invoke(
     ecs_iter_t *it) 
 {
     ecs_observer_t *o = it->ctx;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
     ecs_world_t *world = it->real_world;
-
-    if (o->last_event_id[0] == it->event_cur) {
+    
+    if (impl->last_event_id[0] == it->event_cur) {
         /* Already handled this event */
         return false;
     }
 
-    o->last_event_id[0] = world->event_id;
-
-    ecs_iter_t user_it = *it;
-    user_it.field_count = o->filter.field_count;
-    user_it.query = &o->filter;
-    user_it.terms = o->filter.terms;
-    user_it.flags = 0;
-    ECS_BIT_COND(user_it.flags, EcsIterNoData,    
-        ECS_BIT_IS_SET(o->filter.flags, EcsFilterNoData));
-    user_it.ids = NULL;
-    user_it.columns = NULL;
-    user_it.sources = NULL;
-    user_it.sizes = NULL;
-    user_it.ptrs = NULL;
-
-    flecs_iter_init(it->world, &user_it, flecs_iter_cache_all);
-    user_it.flags |= (it->flags & EcsIterTableOnly);
+    impl->last_event_id[0] = world->event_id;
 
     ecs_table_t *table = it->table;
     ecs_table_t *prev_table = it->other_table;
     int32_t pivot_term = it->term_index;
-    ecs_term_t *term = &o->filter.terms[pivot_term];
+    ecs_term_t *term = &o->query->terms[pivot_term];
 
-    int32_t column = it->columns[0];
-    if (term->oper == EcsNot) {
+    bool is_not = term->oper == EcsNot;
+    if (is_not) {
         table = it->other_table;
         prev_table = it->table;
     }
 
-    if (!table) {
-        table = &world->store.root;
-    }
-    if (!prev_table) {
-        prev_table = &world->store.root;
-    }
+    table = table ? table : &world->store.root;
+    prev_table = prev_table ? prev_table : &world->store.root;
 
-    if (column < 0) {
-        column = -column;
-    }
+    ecs_iter_t user_it;
+
+    bool match;
+    if (is_not) {
+        match = ecs_query_has_table(o->query, table, &user_it);
+        if (match) {
+            /* The target table matches but the entity hasn't moved to it yet. 
+             * Now match the not_query, which will populate the iterator with
+             * data from the table the entity is still stored in. */
+            ecs_iter_fini(&user_it);
+            match = ecs_query_has_table(impl->not_query, prev_table, &user_it);
 
-    user_it.columns[0] = 0;
-    user_it.columns[pivot_term] = column;
-    user_it.sources[pivot_term] = it->sources[0];
-    user_it.sizes = o->filter.sizes;
+            /* A not query replaces Not terms with Optional terms, so if the 
+             * regular query matches, the not_query should also match. */
+            ecs_assert(match, ECS_INTERNAL_ERROR, NULL);
+        }
+    } else {
+        ecs_table_range_t range = {
+            .table = table,
+            .offset = it->offset,
+            .count = it->count
+        };
+        match = ecs_query_has_range(o->query, &range, &user_it);
+    }
 
-    if (flecs_filter_match_table(world, &o->filter, table, user_it.ids, 
-        user_it.columns, user_it.sources, NULL, NULL, false, pivot_term, 
-        user_it.flags))
-    {
-        /* Monitor observers only invoke when the filter matches for the first
+    if (match) {
+        /* Monitor observers only invoke when the query matches for the first
          * time with an entity */
-        if (o->flags & EcsObserverIsMonitor) {
-            if (flecs_filter_match_table(world, &o->filter, prev_table, 
-                NULL, NULL, NULL, NULL, NULL, true, -1, user_it.flags)) 
-            {
+        if (impl->flags & EcsObserverIsMonitor) {
+            ecs_iter_t table_it;
+            if (ecs_query_has_table(o->query, prev_table, &table_it)) {
+                ecs_iter_fini(&table_it);
+                ecs_iter_fini(&user_it);
                 goto done;
             }
         }
 
-        /* While filter matching needs to be reversed for a Not term, the
-         * component data must be fetched from the table we got notified for.
-         * Repeat the matching process for the non-matching table so we get the
-         * correct column ids and sources, which we need for populate_data */
-        if (term->oper == EcsNot) {
-            flecs_filter_match_table(world, &o->filter, prev_table, user_it.ids, 
-                user_it.columns, user_it.sources, NULL, NULL, false, -1, 
-                user_it.flags | EcsFilterPopulate);
-        }
-
-        flecs_iter_populate_data(world, &user_it, it->table, it->offset, 
-            it->count, user_it.ptrs);
-
-        user_it.ptrs[pivot_term] = it->ptrs[0];
-        user_it.ids[pivot_term] = it->event_id;
-        user_it.system = o->filter.entity;
+        ECS_BIT_COND(user_it.flags, EcsIterNoData,    
+            ECS_BIT_IS_SET(o->query->flags, EcsQueryNoData));
+
+        /* Patch data from original iterator. If the observer query has 
+         * wildcards which triggered the original event, the component id that
+         * got matched by ecs_query_has_range may not be the same as the one
+         * that caused the event. We need to make sure to communicate the
+         * component id that actually triggered the observer. */
+        int32_t pivot_field = term->field_index;
+        ecs_assert(pivot_field >= 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(pivot_field < user_it.field_count, ECS_INTERNAL_ERROR, NULL);
+        user_it.ids[pivot_field] = it->event_id;
+        user_it.ptrs[pivot_field] = it->ptrs[0];
+        user_it.columns[pivot_field] = it->columns[0];
         user_it.term_index = pivot_term;
+
         user_it.ctx = o->ctx;
         user_it.binding_ctx = o->binding_ctx;
-        user_it.field_count = o->filter.field_count;
+        user_it.param = it->param;
         user_it.callback = o->callback;
+        user_it.system = o->entity;
+        user_it.event = it->event;
+        user_it.event_id = it->event_id;
+        user_it.other_table = it->other_table;
 
-        flecs_iter_validate(&user_it);
+        ecs_entity_t old_system = flecs_stage_set_system(
+            world->stages[0], o->entity);
         ecs_table_lock(it->world, table);
-        flecs_observer_invoke(world, &user_it, o, o->callback, 
-            pivot_term, flecs_is_simple_result(&user_it));
+
+        user_it.callback(&user_it);
+
         ecs_table_unlock(it->world, table);
+        flecs_stage_set_system(world->stages[0], old_system);
+
         ecs_iter_fini(&user_it);
         return true;
+    } else {
+        /* While the observer query was strictly speaking evaluated, it's more
+         * useful to measure how often the observer was actually invoked. */
+        o->query->eval_count --;
     }
 
 done:
-    ecs_iter_fini(&user_it);
     return false;
 }
 
 bool ecs_observer_default_run_action(ecs_iter_t *it) {
     ecs_observer_t *o = it->ctx;
-    if (o->flags & EcsObserverIsMulti) {
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    if (impl->flags & EcsObserverIsMulti) {
         return flecs_multi_observer_invoke(it);
     } else {
         it->ctx = o->ctx;
@@ -580,6 +589,7 @@ bool flecs_default_observer_next_callback(ecs_iter_t *it) {
         return false;
     } else {
         /* Use interrupted_by to signal the next iteration must return false */
+        ecs_assert(it->system != 0, ECS_INTERNAL_ERROR, NULL);
         it->interrupted_by = it->system;
         return true;
     }
@@ -588,8 +598,8 @@ bool flecs_default_observer_next_callback(ecs_iter_t *it) {
 /* Run action for children of multi observer */
 static
 void flecs_multi_observer_builtin_run(ecs_iter_t *it) {
-    ecs_observer_t *observer = it->ctx;
-    ecs_run_action_t run = observer->run;
+    ecs_observer_t *o = it->ctx;
+    ecs_run_action_t run = o->run;
 
     if (run) {
         it->next = flecs_default_observer_next_callback;
@@ -602,49 +612,11 @@ void flecs_multi_observer_builtin_run(ecs_iter_t *it) {
 }
 
 static
-void flecs_uni_observer_yield_existing(
-    ecs_world_t *world,
-    ecs_observer_t *observer)
-{
-    ecs_iter_action_t callback = observer->callback;
-
-    ecs_defer_begin(world);
-
-    /* If yield existing is enabled, observer for each thing that matches
-     * the event, if the event is iterable. */
-    int i, count = observer->event_count;
-    for (i = 0; i < count; i ++) {
-        ecs_entity_t evt = observer->events[i];
-        const EcsIterable *iterable = ecs_get(world, evt, EcsIterable);
-        if (!iterable) {
-            continue;
-        }
-
-        ecs_iter_t it;
-        iterable->init(world, &observer->filter, &it, NULL);
-        it.system = observer->filter.entity;
-        it.ctx = observer->ctx;
-        it.binding_ctx = observer->binding_ctx;
-        it.event = evt;
-
-        ecs_iter_next_action_t next = it.next;
-        ecs_assert(next != NULL, ECS_INTERNAL_ERROR, NULL);
-        while (next(&it)) {
-            it.event_id = it.ids[0];
-            it.event_cur = ++ world->event_id;
-            callback(&it);
-        }
-    }
-
-    ecs_defer_end(world);
-}
-
-static
-void flecs_multi_observer_yield_existing(
+void flecs_observer_yield_existing(
     ecs_world_t *world,
-    ecs_observer_t *observer)
+    ecs_observer_t *o)
 {
-    ecs_run_action_t run = observer->run;
+    ecs_run_action_t run = o->run;
     if (!run) {
         run = flecs_default_multi_observer_run_callback;
     }
@@ -653,35 +625,16 @@ void flecs_multi_observer_yield_existing(
 
     ecs_defer_begin(world);
 
-    int32_t pivot_term = ecs_filter_pivot_term(world, &observer->filter);
-    if (pivot_term < 0) {
-        pivot_term = 0; /* Observer has no this terms */
-    }
-
     /* If yield existing is enabled, invoke for each thing that matches
      * the event, if the event is iterable. */
-    int i, count = observer->event_count;
+    int i, count = o->event_count;
     for (i = 0; i < count; i ++) {
-        ecs_entity_t evt = observer->events[i];
-        const EcsIterable *iterable = ecs_get(world, evt, EcsIterable);
-        if (!iterable) {
-            continue;
-        }
-
-        ecs_iter_t it;
-        iterable->init(world, world, &it, &observer->filter.terms[pivot_term]);
-        it.query = &observer->filter;
-        it.terms = observer->filter.terms;
-        it.field_count = 1;
-        it.term_index = pivot_term;
-        it.system = observer->filter.entity;
-        it.ctx = observer;
-        it.binding_ctx = observer->binding_ctx;
-        it.event = evt;
-
-        ecs_iter_next_action_t next = it.next;
-        ecs_assert(next != NULL, ECS_INTERNAL_ERROR, NULL);
-        while (next(&it)) {
+        ecs_iter_t it = ecs_query_iter(world, o->query);
+        it.system = o->entity;
+        it.ctx = o;
+        it.binding_ctx = o->binding_ctx;
+        it.event = o->events[i];;
+        while (ecs_query_next(&it)) {
             it.event_id = it.ids[0];
             it.event_cur = ++ world->event_id;
             run(&it);
@@ -694,127 +647,156 @@ void flecs_multi_observer_yield_existing(
 static
 int flecs_uni_observer_init(
     ecs_world_t *world,
-    ecs_observer_t *observer,
+    ecs_observer_t *o,
     const ecs_observer_desc_t *desc)
 {
-    ecs_term_t *term = &observer->filter.terms[0];
-    observer->last_event_id = desc->last_event_id;    
-    if (!observer->last_event_id) {
-        observer->last_event_id = &observer->last_event_id_storage;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    ecs_term_t *term = &o->query->terms[0];
+    impl->last_event_id = desc->last_event_id;    
+    if (!impl->last_event_id) {
+        impl->last_event_id = &impl->last_event_id_storage;
     }
-    observer->register_id = flecs_from_public_id(world, term->id);
-    term->field_index = desc->term_index;
+    impl->register_id = term->id;
+    term->field_index = flecs_ito(int16_t, desc->term_index);
 
     if (ecs_id_is_tag(world, term->id)) {
         /* If id is a tag, downgrade OnSet/UnSet to OnAdd/OnRemove. */
-        int32_t e, count = observer->event_count;
+        int32_t e, count = o->event_count;
         bool has_on_add = false;
         bool has_on_remove = false;
         for (e = 0; e < count; e ++) {
-            if (observer->events[e] == EcsOnAdd) {
+            if (o->events[e] == EcsOnAdd) {
                 has_on_add = true;
             }
-            if (observer->events[e] == EcsOnRemove) {
+            if (o->events[e] == EcsOnRemove) {
                 has_on_remove = true;
             }
         }
 
         for (e = 0; e < count; e ++) {
-            if (observer->events[e] == EcsOnSet) {
+            if (o->events[e] == EcsOnSet) {
                 if (has_on_add) {
                     /* Already registered */
-                    observer->events[e] = 0;
+                    o->events[e] = 0;
                 } else {
-                    observer->events[e] = EcsOnAdd;
+                    o->events[e] = EcsOnAdd;
                 }
             } else
-            if (observer->events[e] == EcsUnSet) {
+            if (o->events[e] == EcsUnSet) {
                 if (has_on_remove) {
                     /* Already registered */
-                    observer->events[e] = 0;
+                    o->events[e] = 0;
                 } else {
-                    observer->events[e] = EcsOnRemove;
+                    o->events[e] = EcsOnRemove;
                 }
             }
         }
     }
 
-    flecs_uni_observer_register(world, observer->observable, observer);
+    flecs_uni_observer_register(world, o->observable, o);
 
-    if (desc->yield_existing) {
-        flecs_uni_observer_yield_existing(world, observer);
+    return 0;
+}
+
+static
+int flecs_observer_add_child(
+    ecs_world_t *world,
+    ecs_observer_t *o,
+    const ecs_observer_desc_t *child_desc)
+{
+    ecs_observer_t *child_observer = flecs_observer_init(
+        world, 0, child_desc);
+    if (!child_observer) {
+        return -1;
     }
 
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    ecs_vec_append_t(&world->allocator, &impl->children, 
+        ecs_observer_t*)[0] = child_observer;
+    child_observer->entity = o->entity;
     return 0;
 }
 
 static
 int flecs_multi_observer_init(
     ecs_world_t *world,
-    ecs_observer_t *observer,
+    ecs_observer_t *o,
     const ecs_observer_desc_t *desc)
 {
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+
     /* Create last event id for filtering out the same event that arrives from
      * more than one term */
-    observer->last_event_id = ecs_os_calloc_t(int32_t);
+    impl->last_event_id = ecs_os_calloc_t(int32_t);
     
     /* Mark observer as multi observer */
-    observer->flags |= EcsObserverIsMulti;
+    impl->flags |= EcsObserverIsMulti;
+
+    /* Vector that stores a single-component observer for each query term */
+    ecs_vec_init_t(&world->allocator, &impl->children, ecs_observer_t*, 2);
 
-    /* Create a child observer for each term in the filter */
-    ecs_filter_t *filter = &observer->filter;
+    /* Create a child observer for each term in the query */
+    ecs_query_t *query = o->query;
     ecs_observer_desc_t child_desc = *desc;
-    child_desc.last_event_id = observer->last_event_id;
+    child_desc.last_event_id = impl->last_event_id;
     child_desc.run = NULL;
     child_desc.callback = flecs_multi_observer_builtin_run;
-    child_desc.ctx = observer;
+    child_desc.ctx = o;
     child_desc.ctx_free = NULL;
-    child_desc.filter.expr = NULL;
-    child_desc.filter.terms_buffer = NULL;
-    child_desc.filter.terms_buffer_count = 0;
+    child_desc.query.expr = NULL;
     child_desc.binding_ctx = NULL;
     child_desc.binding_ctx_free = NULL;
     child_desc.yield_existing = false;
     ecs_os_zeromem(&child_desc.entity);
-    ecs_os_zeromem(&child_desc.filter.terms);
-    ecs_os_memcpy_n(child_desc.events, observer->events, 
-        ecs_entity_t, observer->event_count);
-
-    int i, term_count = filter->term_count;
-    bool optional_only = filter->flags & EcsFilterMatchThis;
+    ecs_os_zeromem(&child_desc.query.terms);
+    ecs_os_zeromem(&child_desc.query);
+    ecs_os_memcpy_n(child_desc.events, o->events, 
+        ecs_entity_t, o->event_count);
+
+    int i, term_count = query->term_count;
+    bool optional_only = query->flags & EcsQueryMatchThis;
+    bool has_not = false;
     for (i = 0; i < term_count; i ++) {
-        if (filter->terms[i].oper != EcsOptional) {
-            if (ecs_term_match_this(&filter->terms[i])) {
+        if (query->terms[i].oper != EcsOptional) {
+            if (ecs_term_match_this(&query->terms[i])) {
                 optional_only = false;
             }
         }
-    }
 
-    if (filter->flags & EcsFilterMatchPrefab) {
-        child_desc.filter.flags |= EcsFilterMatchPrefab;
+        if ((query->terms[i].oper == EcsNot) && 
+            (query->terms[i].inout != EcsInOutFilter)) 
+        {
+            has_not = true;
+        }
     }
-    if (filter->flags & EcsFilterMatchDisabled) {
-        child_desc.filter.flags |= EcsFilterMatchDisabled;
+
+    if (query->flags & EcsQueryMatchPrefab) {
+        child_desc.query.flags |= EcsQueryMatchPrefab;
     }
 
-    /* Create observers as children of observer */
-    ecs_entity_t old_scope = ecs_set_scope(world, observer->filter.entity);
+    if (query->flags & EcsQueryMatchDisabled) {
+        child_desc.query.flags |= EcsQueryMatchDisabled;
+    }
 
     for (i = 0; i < term_count; i ++) {
-        if (filter->terms[i].src.flags & EcsFilter) {
+        if (query->terms[i].inout == EcsInOutFilter) {
             continue;
         }
 
-        ecs_term_t *term = &child_desc.filter.terms[0];
-        child_desc.term_index = filter->terms[i].field_index;
-        *term = filter->terms[i];
+        ecs_term_t *term = &child_desc.query.terms[0];
+        child_desc.term_index = query->terms[i].field_index;
+        *term = query->terms[i];
 
-        ecs_oper_kind_t oper = term->oper;
+        int16_t oper = term->oper;
         ecs_id_t id = term->id;
 
         /* AndFrom & OrFrom terms insert multiple observers */
         if (oper == EcsAndFrom || oper == EcsOrFrom) {
             const ecs_type_t *type = ecs_get_type(world, id);
+            if (!type) {
+                continue;
+            }
+
             int32_t ti, ti_count = type->count;
             ecs_id_t *ti_ids = type->array;
 
@@ -832,7 +814,7 @@ int flecs_multi_observer_init(
                 term->first.id = ti_ids[ti];
                 term->id = ti_ids[ti];
 
-                if (ecs_observer_init(world, &child_desc) == 0) {
+                if (flecs_observer_add_child(world, o, &child_desc)) {
                     goto error;
                 }
             }
@@ -848,13 +830,13 @@ int flecs_multi_observer_init(
         if (optional_only) {
             term->id = EcsAny;
             term->first.id = EcsAny;
-            term->src.id = EcsThis;
-            term->src.flags = EcsIsVariable;
+            term->src.id = EcsThis | EcsIsVariable;
             term->second.id = 0;
         } else if (term->oper == EcsOptional) {
             continue;
         }
-        if (ecs_observer_init(world, &child_desc) == 0) {
+
+        if (flecs_observer_add_child(world, o, &child_desc)) {
             goto error;
         }
 
@@ -863,10 +845,25 @@ int flecs_multi_observer_init(
         }
     }
 
-    ecs_set_scope(world, old_scope);
+    /* If observer has Not terms, we need to create a query that replaces Not
+     * with Optional which we can use to populate the observer data for the 
+     * table that the entity moved away from (or to, if it's an OnRemove 
+     * observer). */
+    if (has_not) {
+        ecs_query_desc_t not_desc = desc->query;
+        not_desc.expr = NULL;
+
+        ecs_os_memcpy_n(not_desc.terms, o->query->terms, 
+            ecs_term_t, term_count); /* cast suppresses warning */
+  
+        for (i = 0; i < term_count; i ++) {
+            if (not_desc.terms[i].oper == EcsNot) {
+                not_desc.terms[i].oper = EcsOptional;
+            }
+        }
 
-    if (desc->yield_existing) {
-        flecs_multi_observer_yield_existing(world, observer);
+        flecs_observer_impl(o)->not_query = 
+            ecs_query_init(world, &not_desc);
     }
 
     return 0; 
@@ -874,159 +871,197 @@ int flecs_multi_observer_init(
     return -1;
 }
 
-ecs_entity_t ecs_observer_init(
+ecs_observer_t* flecs_observer_init(
     ecs_world_t *world,
+    ecs_entity_t entity,
     const ecs_observer_desc_t *desc)
 {
-    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, NULL);
-
-    ecs_entity_t entity = desc->entity;
-    if (!entity) {
-        entity = ecs_new(world, 0);
+    ecs_check(desc->callback != NULL || desc->run != NULL, 
+        ECS_INVALID_OPERATION,
+            "cannot create observer: must at least specify callback or run");
+
+    ecs_observer_impl_t *impl = flecs_sparse_add_t(
+        &world->store.observers, ecs_observer_impl_t);
+    ecs_assert(impl != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_init(impl, ecs_observer_t);
+    ecs_observer_t *o = &impl->pub;
+    impl->id = flecs_sparse_last_id(&world->store.observers);
+    impl->dtor = (flecs_poly_dtor_t)flecs_observer_fini;
+
+    /* Make writeable copy of query desc so that we can set name. This will
+     * make debugging easier, as any error messages related to creating the
+     * query will have the name of the observer. */
+    ecs_query_desc_t query_desc = desc->query;
+    query_desc.entity = 0;
+    query_desc.cache_kind = EcsQueryCacheNone;
+
+    /* Create query */
+    ecs_query_t *query = o->query = ecs_query_init(
+        world, &query_desc);
+    if (query == NULL) {
+        flecs_observer_fini(o);
+        return 0;
     }
 
-    EcsPoly *poly = ecs_poly_bind(world, entity, ecs_observer_t);
-    if (!poly->poly) {
-        ecs_check(desc->callback != NULL || desc->run != NULL, 
-            ECS_INVALID_OPERATION, NULL);
-
-        ecs_observer_t *observer = ecs_poly_new(ecs_observer_t);
-        ecs_assert(observer != NULL, ECS_INTERNAL_ERROR, NULL);
-        observer->dtor = (ecs_poly_dtor_t)flecs_observer_fini;
-
-        /* Make writeable copy of filter desc so that we can set name. This will
-         * make debugging easier, as any error messages related to creating the
-         * filter will have the name of the observer. */
-        ecs_filter_desc_t filter_desc = desc->filter;
-        filter_desc.entity = entity;
-        ecs_filter_t *filter = filter_desc.storage = &observer->filter;
-        *filter = ECS_FILTER_INIT;
-
-        /* Parse filter */
-        if (ecs_filter_init(world, &filter_desc) == NULL) {
-            flecs_observer_fini(observer);
-            return 0;
-        }
+    flecs_poly_assert(query, ecs_query_t);
 
-        /* Observer must have at least one term */
-        ecs_check(observer->filter.term_count > 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(o->query->term_count > 0, ECS_INVALID_PARAMETER,
+        "observer must have at least one term");
 
-        poly->poly = observer;
+    ecs_observable_t *observable = desc->observable;
+    if (!observable) {
+        observable = ecs_get_observable(world);
+    }
 
-        ecs_observable_t *observable = desc->observable;
-        if (!observable) {
-            observable = ecs_get_observable(world);
+    o->run = desc->run;
+    o->callback = desc->callback;
+    o->ctx = desc->ctx;
+    o->binding_ctx = desc->binding_ctx;
+    o->ctx_free = desc->ctx_free;
+    o->binding_ctx_free = desc->binding_ctx_free;
+    o->observable = observable;
+    o->entity = entity;
+    impl->term_index = desc->term_index;
+
+    /* Check if observer is monitor. Monitors are created as multi observers
+     * since they require pre/post checking of the filter to test if the
+     * entity is entering/leaving the monitor. */
+    int i;
+    for (i = 0; i < FLECS_EVENT_DESC_MAX; i ++) {
+        ecs_entity_t event = desc->events[i];
+        if (!event) {
+            break;
         }
 
-        observer->run = desc->run;
-        observer->callback = desc->callback;
-        observer->ctx = desc->ctx;
-        observer->binding_ctx = desc->binding_ctx;
-        observer->ctx_free = desc->ctx_free;
-        observer->binding_ctx_free = desc->binding_ctx_free;
-        observer->term_index = desc->term_index;
-        observer->observable = observable;
-
-        /* Check if observer is monitor. Monitors are created as multi observers
-         * since they require pre/post checking of the filter to test if the
-         * entity is entering/leaving the monitor. */
-        int i;
-        for (i = 0; i < FLECS_EVENT_DESC_MAX; i ++) {
-            ecs_entity_t event = desc->events[i];
-            if (!event) {
-                break;
-            }
+        if (event == EcsMonitor) {
+            ecs_check(i == 0, ECS_INVALID_PARAMETER,
+                "monitor observers can only have a single Monitor event");
 
-            if (event == EcsMonitor) {
-                /* Monitor event must be first and last event */
-                ecs_check(i == 0, ECS_INVALID_PARAMETER, NULL);
+            o->events[0] = EcsOnAdd;
+            o->events[1] = EcsOnRemove;
+            o->event_count ++;
+            impl->flags |= EcsObserverIsMonitor;
+        } else {
+            o->events[i] = event;
+        }
 
-                observer->events[0] = EcsOnAdd;
-                observer->events[1] = EcsOnRemove;
-                observer->event_count ++;
-                observer->flags |= EcsObserverIsMonitor;
-            } else {
-                observer->events[i] = event;
-            }
+        o->event_count ++;
+    }
 
-            observer->event_count ++;
+    /* Observer must have at least one event */
+    ecs_check(o->event_count != 0, ECS_INVALID_PARAMETER,
+        "observer must have at least one event");
+
+    bool multi = false;
+
+    if (query->term_count == 1 && !desc->last_event_id) {
+        ecs_term_t *term = &query->terms[0];
+        /* If the query has a single term but it is a *From operator, we
+         * need to create a multi observer */
+        multi |= (term->oper == EcsAndFrom) || (term->oper == EcsOrFrom);
+        
+        /* An observer with only optional terms is a special case that is
+         * only handled by multi observers */
+        multi |= term->oper == EcsOptional;
+    }
+
+    bool is_monitor = impl->flags & EcsObserverIsMonitor;
+    if (query->term_count == 1 && !is_monitor && !multi) {
+        if (flecs_uni_observer_init(world, o, desc)) {
+            goto error;
         }
+    } else {
+        if (flecs_multi_observer_init(world, o, desc)) {
+            goto error;
+        }
+    }
 
-        /* Observer must have at least one event */
-        ecs_check(observer->event_count != 0, ECS_INVALID_PARAMETER, NULL);
+    if (desc->yield_existing) {
+        flecs_observer_yield_existing(world, o);
+    }
 
-        bool multi = false;
+    return o;
+error:
+    return NULL;
+}
 
-        if (filter->term_count == 1 && !desc->last_event_id) {
-            ecs_term_t *term = &filter->terms[0];
-            /* If the filter has a single term but it is a *From operator, we
-             * need to create a multi observer */
-            multi |= (term->oper == EcsAndFrom) || (term->oper == EcsOrFrom);
-            
-            /* An observer with only optional terms is a special case that is
-             * only handled by multi observers */
-            multi |= term->oper == EcsOptional;
-        }
+ecs_entity_t ecs_observer_init(
+    ecs_world_t *world,
+    const ecs_observer_desc_t *desc)
+{
+    ecs_entity_t entity = 0;
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_observer_desc_t was not initialized to zero");
+    ecs_check(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, 
+        "cannot create observer while world is being deleted");
 
-        bool is_monitor = observer->flags & EcsObserverIsMonitor;
-        if (filter->term_count == 1 && !is_monitor && !multi) {
-            if (flecs_uni_observer_init(world, observer, desc)) {
-                goto error;
-            }
-        } else {
-            if (flecs_multi_observer_init(world, observer, desc)) {
-                goto error;
-            }
-        }
+    entity = desc->entity;
+    if (!entity) {
+        entity = ecs_entity(world, {0});
+    }
+
+    EcsPoly *poly = flecs_poly_bind(world, entity, ecs_observer_t);
+    if (!poly->poly) {
+        ecs_observer_t *o = flecs_observer_init(world, entity, desc);
+        ecs_assert(o->entity == entity, ECS_INTERNAL_ERROR, NULL);
+        poly->poly = o;
 
         if (ecs_get_name(world, entity)) {
             ecs_trace("#[green]observer#[reset] %s created", 
                 ecs_get_name(world, entity));
         }
     } else {
-        ecs_poly_assert(poly->poly, ecs_observer_t);
-        ecs_observer_t *observer = (ecs_observer_t*)poly->poly;
+        flecs_poly_assert(poly->poly, ecs_observer_t);
+        ecs_observer_t *o = (ecs_observer_t*)poly->poly;
 
         if (desc->run) {
-            observer->run = desc->run;
+            o->run = desc->run;
         }
+
         if (desc->callback) {
-            observer->callback = desc->callback;
+            o->callback = desc->callback;
         }
 
-        if (observer->ctx_free) {
-            if (observer->ctx && observer->ctx != desc->ctx) {
-                observer->ctx_free(observer->ctx);
+        if (o->ctx_free) {
+            if (o->ctx && o->ctx != desc->ctx) {
+                o->ctx_free(o->ctx);
             }
         }
-        if (observer->binding_ctx_free) {
-            if (observer->binding_ctx && observer->binding_ctx != desc->binding_ctx) {
-                observer->binding_ctx_free(observer->binding_ctx);
+
+        if (o->binding_ctx_free) {
+            if (o->binding_ctx && 
+                o->binding_ctx != desc->binding_ctx) 
+            {
+                o->binding_ctx_free(o->binding_ctx);
             }
         }
 
         if (desc->ctx) {
-            observer->ctx = desc->ctx;
+            o->ctx = desc->ctx;
         }
+
         if (desc->binding_ctx) {
-            observer->binding_ctx = desc->binding_ctx;
+            o->binding_ctx = desc->binding_ctx;
         }
+
         if (desc->ctx_free) {
-            observer->ctx_free = desc->ctx_free;
+            o->ctx_free = desc->ctx_free;
         }
+
         if (desc->binding_ctx_free) {
-            observer->binding_ctx_free = desc->binding_ctx_free;
+            o->binding_ctx_free = desc->binding_ctx_free;
         }
     }
 
-    ecs_poly_modified(world, entity, ecs_observer_t);
+    flecs_poly_modified(world, entity, ecs_observer_t);
 
     return entity;
 error:
-    ecs_delete(world, entity);
+    if (entity) {
+        ecs_delete(world, entity);
+    }
     return 0;
 }
 
@@ -1034,9 +1069,9 @@ void* ecs_observer_get_ctx(
     const ecs_world_t *world,
     ecs_entity_t observer)
 {
-    const EcsPoly *o = ecs_poly_bind_get(world, observer, ecs_observer_t);
+    const EcsPoly *o = flecs_poly_bind_get(world, observer, ecs_observer_t);
     if (o) {
-        ecs_poly_assert(o->poly, ecs_observer_t);
+        flecs_poly_assert(o->poly, ecs_observer_t);
         return ((ecs_observer_t*)o->poly)->ctx;
     } else {
         return NULL;
@@ -1047,53 +1082,98 @@ void* ecs_observer_get_binding_ctx(
     const ecs_world_t *world,
     ecs_entity_t observer)
 {
-    const EcsPoly *o = ecs_poly_bind_get(world, observer, ecs_observer_t);
+    const EcsPoly *o = flecs_poly_bind_get(world, observer, ecs_observer_t);
     if (o) {
-        ecs_poly_assert(o->poly, ecs_observer_t);
+        flecs_poly_assert(o->poly, ecs_observer_t);
         return ((ecs_observer_t*)o->poly)->binding_ctx;
     } else {
         return NULL;
     }      
 }
 
-const ecs_filter_t* ecs_observer_get_filter(
+const ecs_query_t* ecs_observer_get_query(
     const ecs_world_t *world,
     ecs_entity_t observer)
 {
-    const EcsPoly *o = ecs_poly_bind_get(world, observer, ecs_observer_t);
+    const EcsPoly *o = flecs_poly_bind_get(world, observer, ecs_observer_t);
     if (o) {
-        ecs_poly_assert(o->poly, ecs_observer_t);
-        return &((ecs_observer_t*)o->poly)->filter;
+        flecs_poly_assert(o->poly, ecs_observer_t);
+        return ((ecs_observer_t*)o->poly)->query;
     } else {
         return NULL;
     }   
 }
 
 void flecs_observer_fini(
-    ecs_observer_t *observer)
+    ecs_observer_t *o)
 {
-    if (observer->flags & EcsObserverIsMulti) {
-        ecs_os_free(observer->last_event_id);
+    ecs_assert(o != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(o->query != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_world_t *world = o->query->world;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+
+    if (impl->flags & EcsObserverIsMulti) {
+        ecs_observer_t **children = ecs_vec_first(&impl->children);
+        int32_t i, children_count = ecs_vec_count(&impl->children);
+
+        for (i = 0; i < children_count; i ++) {
+            flecs_observer_fini(children[i]);
+        }
+
+        ecs_os_free(impl->last_event_id);
     } else {
-        if (observer->filter.term_count) {
-            flecs_unregister_observer(
-                observer->filter.world, observer->observable, observer);
+        if (o->query->term_count) {
+            flecs_unregister_observer(world, o->observable, o);
         } else {
-            /* Observer creation failed while creating filter */
+            /* Observer creation failed while creating query */
         }
     }
 
-    /* Cleanup filters */
-    ecs_filter_fini(&observer->filter);
+    ecs_vec_fini_t(&world->allocator, &impl->children, ecs_observer_t*);
+
+    /* Cleanup queries */
+    ecs_query_fini(o->query);
+    if (impl->not_query) {
+        ecs_query_fini(impl->not_query);
+    }
 
     /* Cleanup context */
-    if (observer->ctx_free) {
-        observer->ctx_free(observer->ctx);
+    if (o->ctx_free) {
+        o->ctx_free(o->ctx);
+    }
+
+    if (o->binding_ctx_free) {
+        o->binding_ctx_free(o->binding_ctx);
     }
 
-    if (observer->binding_ctx_free) {
-        observer->binding_ctx_free(observer->binding_ctx);
+    flecs_poly_fini(o, ecs_observer_t);
+    flecs_sparse_remove_t(
+        &world->store.observers, ecs_observer_impl_t, impl->id);
+}
+
+void flecs_observer_set_disable_bit(
+    ecs_world_t *world,
+    ecs_entity_t e,
+    ecs_flags32_t bit,
+    bool cond)
+{
+    const EcsPoly *poly = ecs_get_pair(world, e, EcsPoly, EcsObserver);
+    if (!poly || !poly->poly) {
+        return;
     }
 
-    ecs_poly_free(observer, ecs_observer_t);
+    ecs_observer_t *o = poly->poly;
+    ecs_observer_impl_t *impl = flecs_observer_impl(o);
+    if (impl->flags & EcsObserverIsMulti) {
+        ecs_observer_t **children = ecs_vec_first(&impl->children);
+        int32_t i, children_count = ecs_vec_count(&impl->children);
+        if (children_count) {
+            for (i = 0; i < children_count; i ++) {
+                ECS_BIT_COND(flecs_observer_impl(children[i])->flags, bit, cond);
+            }
+        }
+    } else {
+        flecs_poly_assert(o, ecs_observer_t);
+        ECS_BIT_COND(impl->flags, bit, cond);
+    }
 }
diff --git a/src/os_api.c b/src/os_api.c
index 3a80c5d34..fec0efa60 100644
--- a/src/os_api.c
+++ b/src/os_api.c
@@ -232,7 +232,7 @@ void flecs_log_msg(
 }
 
 void ecs_os_dbg(
-    const char *file, 
+    const char *file,
     int32_t line, 
     const char *msg)
 {
diff --git a/src/poly.c b/src/poly.c
index 48ee1b72f..665cea6c3 100644
--- a/src/poly.c
+++ b/src/poly.c
@@ -10,10 +10,6 @@
  * Mixins are like a vtable, but for members. Each type populates the table with
  * offsets to the members that correspond with the mixin. If an entry in the
  * mixin table is not set, the type does not support the mixin.
- * 
- * An example is the Iterable mixin, which makes it possible to create an 
- * iterator for any poly object (like filters, queries, the world) that 
- * implements the Iterable mixin.
  */
 
 #include "private_api.h"
@@ -22,7 +18,6 @@ static const char* mixin_kind_str[] = {
     [EcsMixinWorld] = "world",
     [EcsMixinEntity] = "entity",
     [EcsMixinObservable] = "observable",
-    [EcsMixinIterable] = "iterable",
     [EcsMixinDtor] = "dtor",
     [EcsMixinMax] = "max (should never be requested by application)"
 };
@@ -32,7 +27,6 @@ ecs_mixins_t ecs_world_t_mixins = {
     .elems = {
         [EcsMixinWorld] = offsetof(ecs_world_t, self),
         [EcsMixinObservable] = offsetof(ecs_world_t, observable),
-        [EcsMixinIterable] = offsetof(ecs_world_t, iterable)
     }
 };
 
@@ -43,38 +37,18 @@ ecs_mixins_t ecs_stage_t_mixins = {
     }
 };
 
-ecs_mixins_t ecs_query_t_mixins = {
-    .type_name = "ecs_query_t",
-    .elems = {
-        [EcsMixinWorld] = offsetof(ecs_query_t, filter.world),
-        [EcsMixinEntity] = offsetof(ecs_query_t, filter.entity),
-        [EcsMixinIterable] = offsetof(ecs_query_t, iterable),
-        [EcsMixinDtor] = offsetof(ecs_query_t, dtor)
-    }
-};
-
 ecs_mixins_t ecs_observer_t_mixins = {
     .type_name = "ecs_observer_t",
     .elems = {
-        [EcsMixinWorld] = offsetof(ecs_observer_t, filter.world),
-        [EcsMixinEntity] = offsetof(ecs_observer_t, filter.entity),
-        [EcsMixinDtor] = offsetof(ecs_observer_t, dtor)
-    }
-};
-
-ecs_mixins_t ecs_filter_t_mixins = {
-    .type_name = "ecs_filter_t",
-    .elems = {
-        [EcsMixinWorld] = offsetof(ecs_filter_t, world),
-        [EcsMixinEntity] = offsetof(ecs_filter_t, entity),
-        [EcsMixinIterable] = offsetof(ecs_filter_t, iterable),
-        [EcsMixinDtor] = offsetof(ecs_filter_t, dtor)
+        [EcsMixinWorld] = offsetof(ecs_observer_t, world),
+        [EcsMixinEntity] = offsetof(ecs_observer_t, entity),
+        [EcsMixinDtor] = offsetof(ecs_observer_impl_t, dtor)
     }
 };
 
 static
 void* assert_mixin(
-    const ecs_poly_t *poly,
+    const flecs_poly_t *poly,
     ecs_mixin_kind_t kind)
 {
     ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
@@ -82,7 +56,8 @@ void* assert_mixin(
     
     const ecs_header_t *hdr = poly;
     ecs_assert(hdr != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
 
     const ecs_mixins_t *mixins = hdr->mixins;
     ecs_assert(mixins != NULL, ECS_INVALID_PARAMETER, NULL);
@@ -97,8 +72,8 @@ void* assert_mixin(
     return ECS_OFFSET(hdr, offset);
 }
 
-void* ecs_poly_init_(
-    ecs_poly_t *poly,
+void* flecs_poly_init_(
+    flecs_poly_t *poly,
     int32_t type,
     ecs_size_t size,
     ecs_mixins_t *mixins)
@@ -110,13 +85,14 @@ void* ecs_poly_init_(
 
     hdr->magic = ECS_OBJECT_MAGIC;
     hdr->type = type;
+    hdr->refcount = 1;
     hdr->mixins = mixins;
 
     return poly;
 }
 
-void ecs_poly_fini_(
-    ecs_poly_t *poly,
+void flecs_poly_fini_(
+    flecs_poly_t *poly,
     int32_t type)
 {
     ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
@@ -125,12 +101,52 @@ void ecs_poly_fini_(
     ecs_header_t *hdr = poly;
 
     /* Don't deinit poly that wasn't initialized */
-    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(hdr->type == type, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
+    ecs_assert(hdr->type == type, ECS_INVALID_PARAMETER,
+        "incorrect function called to free flecs object");
     hdr->magic = 0;
 }
 
-EcsPoly* ecs_poly_bind_(
+int32_t flecs_poly_claim_(
+    flecs_poly_t *poly)
+{
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_header_t *hdr = poly;
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
+    if (ecs_os_has_threading()) {
+        return ecs_os_ainc(&hdr->refcount);
+    } else {
+        return ++hdr->refcount;
+    }
+}
+
+int32_t flecs_poly_release_(
+    flecs_poly_t *poly)
+{
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_header_t *hdr = poly;
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
+    if (ecs_os_has_threading()) {
+        return ecs_os_adec(&hdr->refcount);
+    } else {
+        return --hdr->refcount;
+    }
+}
+
+int32_t flecs_poly_refcount(
+    flecs_poly_t *poly)
+{
+    ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_header_t *hdr = poly;
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
+    return hdr->refcount;
+}
+
+EcsPoly* flecs_poly_bind_(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_entity_t tag)
@@ -159,7 +175,7 @@ EcsPoly* ecs_poly_bind_(
     return result;
 }
 
-void ecs_poly_modified_(
+void flecs_poly_modified_(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_entity_t tag)
@@ -167,7 +183,7 @@ void ecs_poly_modified_(
     ecs_modified_pair(world, entity, ecs_id(EcsPoly), tag);
 }
 
-const EcsPoly* ecs_poly_bind_get_(
+const EcsPoly* flecs_poly_bind_get_(
     const ecs_world_t *world,
     ecs_entity_t entity,
     ecs_entity_t tag)
@@ -175,43 +191,38 @@ const EcsPoly* ecs_poly_bind_get_(
     return ecs_get_pair(world, entity, EcsPoly, tag);
 }
 
-ecs_poly_t* ecs_poly_get_(
+flecs_poly_t* flecs_poly_get_(
     const ecs_world_t *world,
     ecs_entity_t entity,
     ecs_entity_t tag)
 {
-    const EcsPoly *p = ecs_poly_bind_get_(world, entity, tag);
+    const EcsPoly *p = flecs_poly_bind_get_(world, entity, tag);
     if (p) {
         return p->poly;
     }
     return NULL;
 }
 
-bool ecs_poly_is_(
-    const ecs_poly_t *poly,
+bool flecs_poly_is_(
+    const flecs_poly_t *poly,
     int32_t type)
 {
     ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL);
 
     const ecs_header_t *hdr = poly;
-    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER,
+        "invalid/freed pointer to flecs object detected");
     return hdr->type == type;    
 }
 
-ecs_iterable_t* ecs_get_iterable(
-    const ecs_poly_t *poly)
-{
-    return (ecs_iterable_t*)assert_mixin(poly, EcsMixinIterable);
-}
-
 ecs_observable_t* ecs_get_observable(
-    const ecs_poly_t *poly)
+    const flecs_poly_t *poly)
 {
     return (ecs_observable_t*)assert_mixin(poly, EcsMixinObservable);
 }
 
 const ecs_world_t* ecs_get_world(
-    const ecs_poly_t *poly)
+    const flecs_poly_t *poly)
 {
     if (((const ecs_header_t*)poly)->type == ecs_world_t_magic) {
         return poly;
@@ -220,13 +231,13 @@ const ecs_world_t* ecs_get_world(
 }
 
 ecs_entity_t ecs_get_entity(
-    const ecs_poly_t *poly)
+    const flecs_poly_t *poly)
 {
     return *(ecs_entity_t*)assert_mixin(poly, EcsMixinEntity);
 }
 
-ecs_poly_dtor_t* ecs_get_dtor(
-    const ecs_poly_t *poly)
+flecs_poly_dtor_t* ecs_get_dtor(
+    const flecs_poly_t *poly)
 {
-    return (ecs_poly_dtor_t*)assert_mixin(poly, EcsMixinDtor);
+    return (flecs_poly_dtor_t*)assert_mixin(poly, EcsMixinDtor);
 }
diff --git a/src/poly.h b/src/poly.h
index 5cc8af160..38fe2c31b 100644
--- a/src/poly.h
+++ b/src/poly.h
@@ -9,68 +9,68 @@
 #include <stddef.h>
 
 /* Initialize poly */
-void* ecs_poly_init_(
-    ecs_poly_t *object,
+void* flecs_poly_init_(
+    flecs_poly_t *object,
     int32_t kind,
     ecs_size_t size,
     ecs_mixins_t *mixins);
 
-#define ecs_poly_init(object, type)\
-    ecs_poly_init_(object, type##_magic, sizeof(type), &type##_mixins)
+#define flecs_poly_init(object, type)\
+    flecs_poly_init_(object, type##_magic, sizeof(type), &type##_mixins)
 
 /* Deinitialize object for specified type */
-void ecs_poly_fini_(
-    ecs_poly_t *object,
+void flecs_poly_fini_(
+    flecs_poly_t *object,
     int32_t kind);
 
-#define ecs_poly_fini(object, type)\
-    ecs_poly_fini_(object, type##_magic)
+#define flecs_poly_fini(object, type)\
+    flecs_poly_fini_(object, type##_magic)
 
 /* Utility functions for creating an object on the heap */
-#define ecs_poly_new(type)\
-    (type*)ecs_poly_init(ecs_os_calloc_t(type), type)
+#define flecs_poly_new(type)\
+    (type*)flecs_poly_init(ecs_os_calloc_t(type), type)
 
-#define ecs_poly_free(obj, type)\
-    ecs_poly_fini(obj, type);\
+#define flecs_poly_free(obj, type)\
+    flecs_poly_fini(obj, type);\
     ecs_os_free(obj)
 
 /* Get or create poly component for an entity */
-EcsPoly* ecs_poly_bind_(
+EcsPoly* flecs_poly_bind_(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_entity_t tag);
 
-#define ecs_poly_bind(world, entity, T) \
-    ecs_poly_bind_(world, entity, T##_tag)
+#define flecs_poly_bind(world, entity, T) \
+    flecs_poly_bind_(world, entity, T##_tag)
 
-void ecs_poly_modified_(
+void flecs_poly_modified_(
     ecs_world_t *world,
     ecs_entity_t entity,
     ecs_entity_t tag);
 
-#define ecs_poly_modified(world, entity, T) \
-    ecs_poly_modified_(world, entity, T##_tag)
+#define flecs_poly_modified(world, entity, T) \
+    flecs_poly_modified_(world, entity, T##_tag)
 
 /* Get poly component for an entity */
-const EcsPoly* ecs_poly_bind_get_(
+const EcsPoly* flecs_poly_bind_get_(
     const ecs_world_t *world,
     ecs_entity_t entity,
     ecs_entity_t tag);
 
-#define ecs_poly_bind_get(world, entity, T) \
-    ecs_poly_bind_get_(world, entity, T##_tag)
+#define flecs_poly_bind_get(world, entity, T) \
+    flecs_poly_bind_get_(world, entity, T##_tag)
 
-ecs_poly_t* ecs_poly_get_(
+flecs_poly_t* flecs_poly_get_(
     const ecs_world_t *world,
     ecs_entity_t entity,
     ecs_entity_t tag);
 
-#define ecs_poly_get(world, entity, T) \
-    ((T*)ecs_poly_get_(world, entity, T##_tag))
+#define flecs_poly_get(world, entity, T) \
+    ((T*)flecs_poly_get_(world, entity, T##_tag))
 
 /* Utilities for testing/asserting an object type */
 #ifndef FLECS_NDEBUG
-#define ecs_poly_assert(object, ty)\
+#define flecs_poly_assert(object, ty)\
     do {\
         ecs_assert(object != NULL, ECS_INVALID_PARAMETER, NULL);\
         const ecs_header_t *hdr = (const ecs_header_t *)object;\
@@ -79,17 +79,13 @@ ecs_poly_t* ecs_poly_get_(
         ecs_assert(hdr->type == ty##_magic, ECS_INVALID_PARAMETER, type_name);\
     } while (0)
 #else
-#define ecs_poly_assert(object, ty)
+#define flecs_poly_assert(object, ty)
 #endif
 
-/* Utility functions for getting a mixin from an object */
-ecs_iterable_t* ecs_get_iterable(
-    const ecs_poly_t *poly);
-
 ecs_observable_t* ecs_get_observable(
-    const ecs_poly_t *object);
+    const flecs_poly_t *object);
 
-ecs_poly_dtor_t* ecs_get_dtor(
-    const ecs_poly_t *poly);
+flecs_poly_dtor_t* ecs_get_dtor(
+    const flecs_poly_t *poly);
 
 #endif
diff --git a/src/private_api.h b/src/private_api.h
index 5216065a0..cb5aea7d9 100644
--- a/src/private_api.h
+++ b/src/private_api.h
@@ -9,6 +9,7 @@
 #include "private_types.h"
 #include "storage/table_cache.h"
 #include "storage/id_index.h"
+#include "query/query.h"
 #include "observable.h"
 #include "iter.h"
 #include "poly.h"
@@ -118,52 +119,9 @@ void flecs_invoke_hook(
 //// Query API
 ////////////////////////////////////////////////////////////////////////////////
 
-/* Match table with term */
-bool flecs_term_match_table(
-    ecs_world_t *world,
-    const ecs_term_t *term,
-    const ecs_table_t *table,
-    ecs_id_t *id_out,
-    int32_t *column_out,
-    ecs_entity_t *subject_out,
-    int32_t *match_indices,
-    bool first,
-    ecs_flags32_t iter_flags);
-
-/* Match table with filter */
-bool flecs_filter_match_table(
-    ecs_world_t *world,
-    const ecs_filter_t *filter,
-    const ecs_table_t *table,
-    ecs_id_t *ids,
-    int32_t *columns,
-    ecs_entity_t *sources,
-    int32_t *match_indices,
-    int32_t *matches_left,
-    bool first,
-    int32_t skip_term,
-    ecs_flags32_t iter_flags);
-
-ecs_iter_t flecs_filter_iter_w_flags(
-    const ecs_world_t *stage,
-    const ecs_filter_t *filter,
-    ecs_flags32_t flags);
-
-void flecs_query_notify(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_event_t *event);
-
-ecs_id_t flecs_to_public_id(
-    ecs_id_t id);
-
-ecs_id_t flecs_from_public_id(
-    ecs_world_t *world,
-    ecs_id_t id);
-
-void flecs_filter_apply_iter_flags(
+void flecs_query_apply_iter_flags(
     ecs_iter_t *it,
-    const ecs_filter_t *filter);
+    const ecs_query_t *query);
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Safe(r) integer casting
@@ -223,25 +181,6 @@ uint64_t flecs_ito_(
 #define flecs_itoi16(value) flecs_ito(int16_t, (value))
 #define flecs_itoi32(value) flecs_ito(int32_t, (value))
 
-////////////////////////////////////////////////////////////////////////////////
-//// Entity filter
-////////////////////////////////////////////////////////////////////////////////
-
-void flecs_entity_filter_init(
-    ecs_world_t *world,
-    ecs_entity_filter_t **entity_filter,
-    const ecs_filter_t *filter,
-    const ecs_table_t *table,
-    ecs_id_t *ids,
-    int32_t *columns);
-
-void flecs_entity_filter_fini(
-    ecs_world_t *world,
-    ecs_entity_filter_t *entity_filter);
-
-int flecs_entity_filter_next(
-    ecs_entity_filter_iter_t *it);
-
 ////////////////////////////////////////////////////////////////////////////////
 //// Utilities
 ////////////////////////////////////////////////////////////////////////////////
@@ -313,13 +252,9 @@ void flecs_colorize_buf(
     bool enable_colors,
     ecs_strbuf_t *buf);
 
-bool flecs_isident(
-    char ch);
-
 int32_t flecs_search_w_idr(
     const ecs_world_t *world,
     const ecs_table_t *table,
-    ecs_id_t id,
     ecs_id_t *id_out,
     ecs_id_record_t *idr);
 
@@ -329,7 +264,7 @@ int32_t flecs_search_relation_w_idr(
     int32_t offset,
     ecs_id_t id,
     ecs_entity_t rel,
-    ecs_flags32_t flags,
+    ecs_flags64_t flags,
     ecs_entity_t *subject_out,
     ecs_id_t *id_out,
     struct ecs_table_record_t **tr_out,
@@ -341,4 +276,12 @@ bool flecs_type_can_inherit_id(
     const ecs_id_record_t *idr,
     ecs_id_t id);
 
+int ecs_term_finalize(
+    const ecs_world_t *world,
+    ecs_term_t *term);
+
+int32_t flecs_query_pivot_term(
+    const ecs_world_t *world,
+    const ecs_query_t *query);
+
 #endif
diff --git a/src/private_types.h b/src/private_types.h
index 3f0fe8569..503f09002 100644
--- a/src/private_types.h
+++ b/src/private_types.h
@@ -18,9 +18,7 @@
 
 #include "flecs.h"
 #include "storage/entity_index.h"
-#include "datastructures/stack_allocator.h"
-#include "flecs/private/bitset.h"
-#include "flecs/private/switch_list.h"
+#include "flecs/datastructures/bitset.h"
 #include "storage/table.h"
 
 /* Used in id records to keep track of entities used with id flags */
@@ -36,9 +34,6 @@ extern const ecs_entity_t EcsFlag;
 #define ecs_world_t_tag     invalid
 #define ecs_stage_t_tag     invalid
 #define ecs_query_t_tag     EcsQuery
-#define ecs_rule_t_tag      EcsQuery
-#define ecs_table_t_tag     invalid
-#define ecs_filter_t_tag    EcsQuery
 #define ecs_observer_t_tag  EcsObserver
 
 /* Mixin kinds */
@@ -46,7 +41,6 @@ typedef enum ecs_mixin_kind_t {
     EcsMixinWorld,
     EcsMixinEntity,
     EcsMixinObservable,
-    EcsMixinIterable,
     EcsMixinDtor,
     EcsMixinMax
 } ecs_mixin_kind_t;
@@ -63,9 +57,7 @@ struct ecs_mixins_t {
 /* Mixin tables */
 extern ecs_mixins_t ecs_world_t_mixins;
 extern ecs_mixins_t ecs_stage_t_mixins;
-extern ecs_mixins_t ecs_filter_t_mixins;
 extern ecs_mixins_t ecs_query_t_mixins;
-extern ecs_mixins_t ecs_trigger_t_mixins;
 extern ecs_mixins_t ecs_observer_t_mixins;
 
 /* Types that have no mixins */
@@ -103,194 +95,6 @@ typedef struct ecs_table_cache_t {
     ecs_table_cache_list_t empty_tables;
 } ecs_table_cache_t;
 
-/* Sparse query term */
-typedef struct flecs_switch_term_t {
-    ecs_switch_t *sw_column;
-    ecs_entity_t sw_case; 
-    int32_t signature_column_index;
-} flecs_switch_term_t;
-
-/* Bitset query term */
-typedef struct flecs_bitset_term_t {
-    ecs_bitset_t *bs_column;
-    int32_t column_index;
-} flecs_bitset_term_t;
-
-typedef struct flecs_flat_monitor_t {
-    int32_t table_state;
-    int32_t monitor;
-} flecs_flat_monitor_t;
-
-/* Flat table term */
-typedef struct flecs_flat_table_term_t {
-    int32_t field_index; /* Iterator field index */
-    ecs_term_t *term;
-    ecs_vec_t monitor;
-} flecs_flat_table_term_t;
-
-/* Entity filter. This filters the entities of a matched table, for example when
- * it has disabled components or union relationships (switch). */
-typedef struct ecs_entity_filter_t {
-    ecs_vec_t sw_terms;              /* Terms with switch (union) entity filter */
-    ecs_vec_t bs_terms;              /* Terms with bitset (toggle) entity filter */
-    ecs_vec_t ft_terms;              /* Terms with components from flattened tree */
-    int32_t flat_tree_column;
-} ecs_entity_filter_t;
-
-typedef struct ecs_entity_filter_iter_t {
-    ecs_entity_filter_t *entity_filter;
-    ecs_iter_t *it;
-    int32_t *columns;
-    ecs_table_t *prev;
-    ecs_table_range_t range;
-    int32_t bs_offset;
-    int32_t sw_offset;
-    int32_t sw_smallest;
-    int32_t flat_tree_offset;
-    int32_t target_count;
-} ecs_entity_filter_iter_t;
-
-/** Table match data.
- * Each table matched by the query is represented by a ecs_query_table_match_t
- * instance, which are linked together in a list. A table may match a query
- * multiple times (due to wildcard queries) with different columns being matched
- * by the query. */
-struct ecs_query_table_match_t {
-    ecs_query_table_match_t *next, *prev;
-    ecs_table_t *table;              /* The current table. */
-    int32_t offset;                  /* Starting point in table  */
-    int32_t count;                   /* Number of entities to iterate in table */
-    int32_t *columns;                /* Mapping from query fields to table columns */
-    int32_t *storage_columns;        /* Mapping from query fields to storage columns */
-    ecs_id_t *ids;                   /* Resolved (component) ids for current table */
-    ecs_entity_t *sources;           /* Subjects (sources) of ids */
-    ecs_vec_t refs;                  /* Cached components for non-this terms */
-    uint64_t group_id;               /* Value used to organize tables in groups */
-    int32_t *monitor;                /* Used to monitor table for changes */
-    ecs_entity_filter_t *entity_filter; /* Entity specific filters */
-
-    /* Next match in cache for same table (includes empty tables) */
-    ecs_query_table_match_t *next_match;
-};
-
-/** Table record type for query table cache. A query only has one per table. */
-typedef struct ecs_query_table_t {
-    ecs_table_cache_hdr_t hdr;       /* Header for ecs_table_cache_t */
-    ecs_query_table_match_t *first;  /* List with matches for table */
-    ecs_query_table_match_t *last;   /* Last discovered match for table */
-    uint64_t table_id;
-    int32_t rematch_count;           /* Track whether table was rematched */
-} ecs_query_table_t;
-
-/** Points to the beginning & ending of a query group */
-typedef struct ecs_query_table_list_t {
-    ecs_query_table_match_t *first;
-    ecs_query_table_match_t *last;
-    ecs_query_group_info_t info;
-} ecs_query_table_list_t;
-
-/* Query event type for notifying queries of world events */
-typedef enum ecs_query_eventkind_t {
-    EcsQueryTableMatch,
-    EcsQueryTableRematch,
-    EcsQueryTableUnmatch,
-    EcsQueryOrphan
-} ecs_query_eventkind_t;
-
-typedef struct ecs_query_event_t {
-    ecs_query_eventkind_t kind;
-    ecs_table_t *table;
-    ecs_query_t *parent_query;
-} ecs_query_event_t;
-
-/* Query level block allocators have sizes that depend on query field count */
-typedef struct ecs_query_allocators_t {
-    ecs_block_allocator_t columns;
-    ecs_block_allocator_t ids;
-    ecs_block_allocator_t sources;
-    ecs_block_allocator_t monitors;
-} ecs_query_allocators_t;
-
-/** Query that is automatically matched against tables */
-struct ecs_query_t {
-    ecs_header_t hdr;
-
-    /* Query filter */
-    ecs_filter_t filter;
-
-    /* Tables matched with query */
-    ecs_table_cache_t cache;
-
-    /* Linked list with all matched non-empty tables, in iteration order */
-    ecs_query_table_list_t list;
-
-    /* Contains head/tail to nodes of query groups (if group_by is used) */
-    ecs_map_t groups;
-
-    /* Table sorting */
-    ecs_entity_t order_by_component;
-    ecs_order_by_action_t order_by;
-    ecs_sort_table_action_t sort_table;
-    ecs_vec_t table_slices;
-    int32_t order_by_term;
-
-    /* Table grouping */
-    ecs_entity_t group_by_id;
-    ecs_group_by_action_t group_by;
-    ecs_group_create_action_t on_group_create;
-    ecs_group_delete_action_t on_group_delete;
-    void *group_by_ctx;
-    ecs_ctx_free_t group_by_ctx_free;
-
-    /* Subqueries */
-    ecs_query_t *parent;
-    ecs_vec_t subqueries;
-
-    /* Flags for query properties */
-    ecs_flags32_t flags;
-
-    /* Monitor generation */
-    int32_t monitor_generation;
-
-    int32_t cascade_by;              /* Identify cascade term */
-    int32_t match_count;             /* How often have tables been (un)matched */
-    int32_t prev_match_count;        /* Track if sorting is needed */
-    int32_t rematch_count;           /* Track which tables were added during rematch */
-
-    /* User context */
-    void *ctx;                       /* User context to pass to callback */
-    void *binding_ctx;               /* Context to be used for language bindings */
-     
-    ecs_ctx_free_t ctx_free;         /** Callback to free ctx */
-    ecs_ctx_free_t binding_ctx_free; /** Callback to free binding_ctx */
-
-    /* Mixins */
-    ecs_iterable_t iterable;
-    ecs_poly_dtor_t dtor;
-
-    /* Query-level allocators */
-    ecs_query_allocators_t allocators;
-};
-
-/** All observers for a specific (component) id */
-typedef struct ecs_event_id_record_t {
-    /* Triggers for Self */
-    ecs_map_t self;                  /* map<trigger_id, trigger_t> */
-    ecs_map_t self_up;               /* map<trigger_id, trigger_t> */
-    ecs_map_t up;                    /* map<trigger_id, trigger_t> */
-
-    ecs_map_t observers;             /* map<trigger_id, trigger_t> */
-
-    /* Triggers for SuperSet, SubSet */
-    ecs_map_t set_observers;         /* map<trigger_id, trigger_t> */
-
-    /* Triggers for Self with non-This subject */
-    ecs_map_t entity_observers;      /* map<trigger_id, trigger_t> */
-
-    /* Number of active observers for (component) id */
-    int32_t observer_count;
-} ecs_event_id_record_t;
-
 /* World level allocators are for operations that are not multithreaded */
 typedef struct ecs_world_allocators_t {
     ecs_map_params_t ptr;
@@ -314,6 +118,8 @@ typedef struct ecs_stage_allocators_t {
     ecs_stack_t iter_stack;
     ecs_stack_t deser_stack;
     ecs_block_allocator_t cmd_entry_chunk;
+    ecs_block_allocator_t query_impl;
+    ecs_block_allocator_t query_cache;
 } ecs_stage_allocators_t;
 
 /** Types for deferred operations */
@@ -387,7 +193,13 @@ typedef void (*ecs_on_commands_action_t)(
 /** A stage is a context that allows for safely using the API from multiple 
  * threads. Stage pointers can be passed to the world argument of API 
  * operations, which causes the operation to be ran on the stage instead of the
- * world. */
+ * world. The features provided by a stage are:
+ * 
+ *  - A command queue for deferred ECS operations and events
+ *  - Thread specific allocators
+ *  - Thread specific world state (like current scope, with, current system)
+ *  - Thread specific buffers for preventing allocations
+ */
 struct ecs_stage_t {
     ecs_header_t hdr;
 
@@ -419,22 +231,23 @@ struct ecs_stage_t {
     /* Running system */
     ecs_entity_t system;
 
-    /* Properties */
-    bool auto_merge;                 /* Should this stage automatically merge? */
-    bool async;                      /* Is stage asynchronous? (write only) */
-
     /* Thread specific allocators */
     ecs_stage_allocators_t allocators;
     ecs_allocator_t allocator;
 
-    /* Caches for rule creation */
+    /* Caches for query creation */
     ecs_vec_t variables;
     ecs_vec_t operations;
+
+    /* Temporary token storage for DSL parser. This allows for parsing and 
+     * interpreting a term without having to do allocations. */
+    char parser_tokens[1024];
+    char *parser_token; /* Pointer to next token */
 };
 
 /* Component monitor */
 typedef struct ecs_monitor_t {
-    ecs_vec_t queries;               /* vector<ecs_query_t*> */
+    ecs_vec_t queries;               /* vector<ecs_query_cache_t*> */
     bool is_dirty;                   /* Should queries be rematched? */
 } ecs_monitor_t;
 
@@ -456,7 +269,7 @@ typedef struct ecs_store_t {
     /* Entity lookup */
     ecs_entity_index_t entity_index;
 
-    /* Table lookup by id */
+    /* Tables */
     ecs_sparse_t tables;             /* sparse<table_id, ecs_table_t> */
 
     /* Table lookup by hash */
@@ -465,6 +278,9 @@ typedef struct ecs_store_t {
     /* Root table */
     ecs_table_t root;
 
+    /* Observers */
+    ecs_sparse_t observers;          /* sparse<table_id, ecs_table_t> */
+
     /* Records cache */
     ecs_vec_t records;
 
@@ -506,7 +322,6 @@ struct ecs_world_t {
     /* -- Mixins -- */
     ecs_world_t *self;
     ecs_observable_t observable;
-    ecs_iterable_t iterable;
 
     /* Unique id per generated event used to prevent duplicate notifications */
     int32_t event_id;
@@ -532,7 +347,7 @@ struct ecs_world_t {
     ecs_hashmap_t symbols;
 
     /* -- Staging -- */
-    ecs_stage_t *stages;             /* Stages */
+    ecs_stage_t **stages;            /* Stages */
     int32_t stage_count;             /* Number of stages */
 
     /* Internal callback for command inspection. Only one callback can be set at
diff --git a/src/query.c b/src/query.c
deleted file mode 100644
index 06e419269..000000000
--- a/src/query.c
+++ /dev/null
@@ -1,2820 +0,0 @@
-/**
- * @file query.c
- * @brief Cached query implementation.
- * 
- * Cached queries store a list of matched tables. The inputs for a cached query
- * are a filter and an observer. The filter is used to initially populate the
- * cache, and an observer is used to keep the cacne up to date.
- * 
- * Cached queries additionally support features like sorting and grouping. 
- * With sorting, an application can iterate over entities that can be sorted by
- * a component. Grouping allows an application to group matched tables, which is
- * used internally to implement the cascade feature, and can additionally be 
- * used to implement things like world cells.
- */
-
-#include "private_api.h"
-
-static
-uint64_t flecs_query_get_group_id(
-    ecs_query_t *query,
-    ecs_table_t *table)
-{
-    if (query->group_by) {
-        return query->group_by(query->filter.world, table, 
-            query->group_by_id, query->group_by_ctx);
-    } else {
-        return 0;
-    }
-}
-
-static
-void flecs_query_compute_group_id(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    if (query->group_by) {
-        ecs_table_t *table = match->table;
-        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        match->group_id = flecs_query_get_group_id(query, table);
-    } else {
-        match->group_id = 0;
-    }
-}
-
-static
-ecs_query_table_list_t* flecs_query_get_group(
-    const ecs_query_t *query,
-    uint64_t group_id)
-{
-    return ecs_map_get_deref(&query->groups, ecs_query_table_list_t, group_id);
-}
-
-static
-ecs_query_table_list_t* flecs_query_ensure_group(
-    ecs_query_t *query,
-    uint64_t id)
-{
-    ecs_query_table_list_t *group = ecs_map_get_deref(&query->groups, 
-        ecs_query_table_list_t, id);
-
-    if (!group) {
-        group = ecs_map_insert_alloc_t(&query->groups, 
-            ecs_query_table_list_t, id);
-        ecs_os_zeromem(group);
-        if (query->on_group_create) {
-            group->info.ctx = query->on_group_create(
-                query->filter.world, id, query->group_by_ctx);
-        }
-    }
-
-    return group;
-}
-
-static
-void flecs_query_remove_group(
-    ecs_query_t *query,
-    uint64_t id)
-{
-    if (query->on_group_delete) {
-        ecs_query_table_list_t *group = ecs_map_get_deref(&query->groups, 
-            ecs_query_table_list_t, id);
-        if (group) {
-            query->on_group_delete(query->filter.world, id, 
-                group->info.ctx, query->group_by_ctx);
-        }
-    }
-
-    ecs_map_remove_free(&query->groups, id);
-}
-
-static
-uint64_t flecs_query_default_group_by(
-    ecs_world_t *world, 
-    ecs_table_t *table, 
-    ecs_id_t id, 
-    void *ctx) 
-{
-    (void)ctx;
-
-    ecs_id_t match;
-    if (ecs_search(world, table, ecs_pair(id, EcsWildcard), &match) != -1) {
-        return ecs_pair_second(world, match);
-    }
-    return 0;
-}
-
-/* Find the last node of the group after which this group should be inserted */
-static
-ecs_query_table_match_t* flecs_query_find_group_insertion_node(
-    ecs_query_t *query,
-    uint64_t group_id)
-{
-    /* Grouping must be enabled */
-    ecs_assert(query->group_by != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_map_iter_t it = ecs_map_iter(&query->groups);
-    ecs_query_table_list_t *list, *closest_list = NULL;
-    uint64_t id, closest_id = 0;
-    
-    bool desc = false;
-
-    if (query->cascade_by) {
-        desc = (query->filter.terms[
-            query->cascade_by - 1].src.flags & EcsDesc) != 0;
-    }
-
-    /* Find closest smaller group id */
-    while (ecs_map_next(&it)) {
-        id = ecs_map_key(&it);
-
-        if (!desc) {
-            if (id >= group_id) {
-                continue;
-            }
-        } else {
-            if (id <= group_id) {
-                continue;
-            }
-        }
-
-        list = ecs_map_ptr(&it);
-        if (!list->last) {
-            ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL);
-            continue;
-        }
-
-        bool comp;
-        if (!desc) {
-            comp = ((group_id - id) < (group_id - closest_id));
-        } else {
-            comp = ((group_id - id) > (group_id - closest_id));
-        }
-
-        if (!closest_list || comp) {
-            closest_id = id;
-            closest_list = list;
-        }
-    }
-
-    if (closest_list) {
-        return closest_list->last;
-    } else {
-        return NULL; /* Group should be first in query */
-    }
-}
-
-/* Initialize group with first node */
-static
-void flecs_query_create_group(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    uint64_t group_id = match->group_id;
-
-    /* If query has grouping enabled & this is a new/empty group, find
-     * the insertion point for the group */
-    ecs_query_table_match_t *insert_after = flecs_query_find_group_insertion_node(
-        query, group_id);
-
-    if (!insert_after) {
-        /* This group should appear first in the query list */
-        ecs_query_table_match_t *query_first = query->list.first;
-        if (query_first) {
-            /* If this is not the first match for the query, insert before it */
-            match->next = query_first;
-            query_first->prev = match;
-            query->list.first = match;
-        } else {
-            /* If this is the first match of the query, initialize its list */
-            ecs_assert(query->list.last == NULL, ECS_INTERNAL_ERROR, NULL);
-            query->list.first = match;
-            query->list.last = match;
-        }
-    } else {
-        ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        /* This group should appear after another group */
-        ecs_query_table_match_t *insert_before = insert_after->next;
-        match->prev = insert_after;
-        insert_after->next = match;
-        match->next = insert_before;
-        if (insert_before) {
-            insert_before->prev = match;
-        } else {
-            ecs_assert(query->list.last == insert_after, 
-                ECS_INTERNAL_ERROR, NULL);
-                
-            /* This group should appear last in the query list */
-            query->list.last = match;
-        }
-    }
-}
-
-/* Find the list the node should be part of */
-static
-ecs_query_table_list_t* flecs_query_get_node_list(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    if (query->group_by) {
-        return flecs_query_get_group(query, match->group_id);
-    } else {
-        return &query->list;
-    }
-}
-
-/* Find or create the list the node should be part of */
-static
-ecs_query_table_list_t* flecs_query_ensure_node_list(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    if (query->group_by) {
-        return flecs_query_ensure_group(query, match->group_id);
-    } else {
-        return &query->list;
-    }
-}
-
-/* Remove node from list */
-static
-void flecs_query_remove_table_node(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    ecs_query_table_match_t *prev = match->prev;
-    ecs_query_table_match_t *next = match->next;
-
-    ecs_assert(prev != match, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(next != match, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!prev || prev != next, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_query_table_list_t *list = flecs_query_get_node_list(query, match);
-
-    if (!list || !list->first) {
-        /* If list contains no matches, the match must be empty */
-        ecs_assert(!list || list->last == NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL);
-        return;
-    }
-
-    ecs_assert(prev != NULL || query->list.first == match, 
-        ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(next != NULL || query->list.last == match, 
-        ECS_INTERNAL_ERROR, NULL);
-
-    if (prev) {
-        prev->next = next;
-    }
-    if (next) {
-        next->prev = prev;
-    }
-
-    ecs_assert(list->info.table_count > 0, ECS_INTERNAL_ERROR, NULL);
-    list->info.table_count --;
-
-    if (query->group_by) {
-        uint64_t group_id = match->group_id;
-
-        /* Make sure query.list is updated if this is the first or last group */
-        if (query->list.first == match) {
-            ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL);
-            query->list.first = next;
-            prev = next;
-        }
-        if (query->list.last == match) {
-            ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL);
-            query->list.last = prev;
-            next = prev;
-        }
-
-        ecs_assert(query->list.info.table_count > 0, ECS_INTERNAL_ERROR, NULL);
-        query->list.info.table_count --;
-        list->info.match_count ++;
-
-        /* Make sure group list only contains nodes that belong to the group */
-        if (prev && prev->group_id != group_id) {
-            /* The previous node belonged to another group */
-            prev = next;
-        }
-        if (next && next->group_id != group_id) {
-            /* The next node belonged to another group */
-            next = prev;
-        }
-
-        /* Do check again, in case both prev & next belonged to another group */
-        if ((!prev && !next) || (prev && prev->group_id != group_id)) {
-            /* There are no more matches left in this group */
-            flecs_query_remove_group(query, group_id);
-            list = NULL;
-        }
-    }
-
-    if (list) {
-        if (list->first == match) {
-            list->first = next;
-        }
-        if (list->last == match) {
-            list->last = prev;
-        }
-    }
-
-    match->prev = NULL;
-    match->next = NULL;
-
-    query->match_count ++;
-}
-
-/* Add node to list */
-static
-void flecs_query_insert_table_node(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    /* Node should not be part of an existing list */
-    ecs_assert(match->prev == NULL && match->next == NULL, 
-        ECS_INTERNAL_ERROR, NULL);
-
-    /* If this is the first match, activate system */
-    if (!query->list.first && query->filter.entity) {
-        ecs_remove_id(query->filter.world, query->filter.entity, EcsEmpty);
-    }
-
-    flecs_query_compute_group_id(query, match);
-
-    ecs_query_table_list_t *list = flecs_query_ensure_node_list(query, match);
-    if (list->last) {
-        ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL);
-
-        ecs_query_table_match_t *last = list->last;
-        ecs_query_table_match_t *last_next = last->next;
-
-        match->prev = last;
-        match->next = last_next;
-        last->next = match;
-
-        if (last_next) {
-            last_next->prev = match;
-        }
-
-        list->last = match;
-
-        if (query->group_by) {
-            /* Make sure to update query list if this is the last group */
-            if (query->list.last == last) {
-                query->list.last = match;
-            }
-        }
-    } else {
-        ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL);
-
-        list->first = match;
-        list->last = match;
-
-        if (query->group_by) {
-            /* Initialize group with its first node */
-            flecs_query_create_group(query, match);
-        }
-    }
-
-    if (query->group_by) {
-        list->info.table_count ++;
-        list->info.match_count ++;
-    }
-
-    query->list.info.table_count ++;
-    query->match_count ++;
-
-    ecs_assert(match->prev != match, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(match->next != match, ECS_INTERNAL_ERROR, NULL);
-
-    ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(list->last != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(list->last == match, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query->list.first->prev == NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(query->list.last->next == NULL, ECS_INTERNAL_ERROR, NULL);
-}
-
-static
-ecs_query_table_match_t* flecs_query_cache_add(
-    ecs_world_t *world,
-    ecs_query_table_t *elem)
-{
-    ecs_query_table_match_t *result = 
-        flecs_bcalloc(&world->allocators.query_table_match);
-
-    if (!elem->first) {
-        elem->first = result;
-        elem->last = result;
-    } else {
-        ecs_assert(elem->last != NULL, ECS_INTERNAL_ERROR, NULL);
-        elem->last->next_match = result;
-        elem->last = result;
-    }
-
-    return result;
-}
-
-typedef struct {
-    ecs_table_t *table;
-    int32_t column;
-} flecs_table_column_t;
-
-static
-void flecs_query_get_column_for_term(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match,
-    int32_t t,
-    flecs_table_column_t *out)
-{
-    const ecs_filter_t *filter = &query->filter;
-    ecs_world_t *world = filter->world;
-    ecs_term_t *term = &filter->terms[t];
-    int32_t field = term->field_index;
-    ecs_entity_t src = match->sources[field];
-    ecs_table_t *table = NULL;
-    int32_t column = -1;
-
-    if (term->oper != EcsNot) {
-        if (!src) {
-            if (term->src.flags != EcsIsEntity) {
-                table = match->table;
-                column = match->storage_columns[field];
-                if (column == -2) {
-                    /* Shared field */
-                    column = -1;
-                }
-            }
-        } else {
-            table = ecs_get_table(world, src);
-            if (ecs_term_match_this(term)) {
-                int32_t ref_index = -match->columns[field] - 1;
-                ecs_ref_t *ref = ecs_vec_get_t(&match->refs, ecs_ref_t, ref_index);
-                if (ref->id != 0) {
-                    ecs_ref_update(world, ref);
-                    column = ref->tr->column;
-                }
-            } else {
-                column = -(match->columns[field] + 1);
-            }
-        }
-    }
-
-    out->table = table;
-    out->column = column;
-}
-
-/* Get match monitor. Monitors are used to keep track of whether components 
- * matched by the query in a table have changed. */
-static
-bool flecs_query_get_match_monitor(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    if (match->monitor) {
-        return false;
-    }
-
-    int32_t *monitor = flecs_balloc(&query->allocators.monitors);
-    monitor[0] = 0;
-
-    /* Mark terms that don't need to be monitored. This saves time when reading
-     * and/or updating the monitor. */
-    const ecs_filter_t *f = &query->filter;
-    int32_t i, field = -1, term_count = f->term_count;
-    flecs_table_column_t tc;
-
-    for (i = 0; i < term_count; i ++) {
-        if (field == f->terms[i].field_index) {
-            if (monitor[field + 1] != -1) {
-                continue;
-            }
-        }
-
-        field = f->terms[i].field_index;
-        monitor[field + 1] = -1;
-
-        if (f->terms[i].inout != EcsIn && 
-            f->terms[i].inout != EcsInOut &&
-            f->terms[i].inout != EcsInOutDefault) {
-            continue; /* If term isn't read, don't monitor */
-        }
-
-        int32_t column = match->columns[field];
-        if (column == 0) {
-            continue; /* Don't track terms that aren't matched */
-        }
-
-        flecs_query_get_column_for_term(query, match, i, &tc);
-        if (tc.column == -1) {
-            continue; /* Don't track terms that aren't stored */
-        }
-
-        monitor[field + 1] = 0;
-    }
-
-    /* If matched table needs entity filter, make sure to test fields that could
-     * be matched by flattened parents. */
-    ecs_entity_filter_t *ef = match->entity_filter;
-    if (ef && ef->flat_tree_column != -1) {
-        int32_t *fields = ecs_vec_first(&ef->ft_terms);
-        int32_t field_count = ecs_vec_count(&ef->ft_terms);
-        for (i = 0; i < field_count; i ++) {
-            monitor[fields[i] + 1] = 0;
-        }
-    }
-
-    match->monitor = monitor;
-
-    query->flags |= EcsQueryHasMonitor;
-
-    return true;
-}
-
-/* Synchronize match monitor with table dirty state */
-static
-void flecs_query_sync_match_monitor(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match)
-{
-    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
-    if (!match->monitor) {
-        if (query->flags & EcsQueryHasMonitor) {
-            flecs_query_get_match_monitor(query, match);
-        } else {
-            return;
-        }
-    }
-
-    int32_t *monitor = match->monitor;
-    ecs_table_t *table = match->table;
-    if (table) {
-        int32_t *dirty_state = flecs_table_get_dirty_state(
-            query->filter.world, table);
-        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
-        monitor[0] = dirty_state[0]; /* Did table gain/lose entities */
-    }
-
-    ecs_filter_t *filter = &query->filter;
-    {
-        flecs_table_column_t tc;
-        int32_t t, term_count = filter->term_count;
-        for (t = 0; t < term_count; t ++) {
-            int32_t field = filter->terms[t].field_index;
-            if (monitor[field + 1] == -1) {
-                continue;
-            }
-
-            flecs_query_get_column_for_term(query, match, t, &tc);
-
-            monitor[field + 1] = flecs_table_get_dirty_state(
-                filter->world, tc.table)[tc.column + 1];
-        }
-    }
-
-    ecs_entity_filter_t *ef = match->entity_filter;
-    if (ef && ef->flat_tree_column != -1) {
-        flecs_flat_table_term_t *fields = ecs_vec_first(&ef->ft_terms);
-        int32_t f, field_count = ecs_vec_count(&ef->ft_terms);
-        for (f = 0; f < field_count; f ++) {
-            flecs_flat_table_term_t *field = &fields[f];
-            flecs_flat_monitor_t *tgt_mon = ecs_vec_first(&field->monitor);
-            int32_t tgt, tgt_count = ecs_vec_count(&field->monitor);
-            for (tgt = 0; tgt < tgt_count; tgt ++) {
-                tgt_mon[tgt].monitor = tgt_mon[tgt].table_state;
-            }
-        }
-    }
-
-    query->prev_match_count = query->match_count;
-}
-
-/* Check if single match term has changed */
-static
-bool flecs_query_check_match_monitor_term(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match,
-    int32_t term)
-{
-    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    if (flecs_query_get_match_monitor(query, match)) {
-        return true;
-    }
-    
-    int32_t *monitor = match->monitor;
-    int32_t state = monitor[term];
-    if (state == -1) {
-        return false;
-    }
-
-    ecs_table_t *table = match->table;
-    if (table) {
-        int32_t *dirty_state = flecs_table_get_dirty_state(
-            query->filter.world, table);
-        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
-        if (!term) {
-            return monitor[0] != dirty_state[0];
-        }
-    } else if (!term) {
-        return false;
-    }
-
-    flecs_table_column_t cur;
-    flecs_query_get_column_for_term(query, match, term - 1, &cur);
-    ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL);
-
-    return monitor[term] != flecs_table_get_dirty_state(
-        query->filter.world, cur.table)[cur.column + 1];
-}
-
-/* Check if any term for match has changed */
-static
-bool flecs_query_check_match_monitor(
-    ecs_query_t *query,
-    ecs_query_table_match_t *match,
-    const ecs_iter_t *it)
-{
-    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    if (flecs_query_get_match_monitor(query, match)) {
-        return true;
-    }
-
-    int32_t *monitor = match->monitor;
-    ecs_table_t *table = match->table;
-    int32_t *dirty_state = NULL;
-    if (table) {
-        dirty_state = flecs_table_get_dirty_state(
-            query->filter.world, table);
-        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
-        if (monitor[0] != dirty_state[0]) {
-            return true;
-        }
-    }
-
-    bool has_flat = false, is_this = false;
-    const ecs_filter_t *filter = &query->filter;
-    ecs_world_t *world = filter->world;
-    int32_t i, j, field_count = filter->field_count;
-    int32_t *storage_columns = match->storage_columns;
-    int32_t *columns = it ? it->columns : NULL;
-    if (!columns) {
-        columns = match->columns;
-    }
-    ecs_vec_t *refs = &match->refs;
-    for (i = 0; i < field_count; i ++) {
-        int32_t mon = monitor[i + 1];
-        if (mon == -1) {
-            continue;
-        }
-
-        int32_t column = storage_columns[i];
-        if (columns[i] >= 0) {
-            /* owned component */
-            ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
-            if (mon != dirty_state[column + 1]) {
-                return true;
-            }
-            continue;
-        } else if (column == -1) {
-            continue; /* owned but not a component */
-        }
-
-        column = columns[i];
-        if (!column) {
-            /* Not matched */
-            continue;
-        }
-
-        ecs_assert(column < 0, ECS_INTERNAL_ERROR, NULL);
-        column = -column;
-
-        /* Find term index from field index, which differ when using || */
-        int32_t term_index = i;
-        if (filter->terms[i].field_index != i) {
-            for (j = i; j < filter->term_count; j ++) {
-                if (filter->terms[j].field_index == i) {
-                    term_index = j;
-                    break;
-                }
-            }
-        }
-
-        is_this = ecs_term_match_this(&filter->terms[term_index]);
-
-        /* Flattened fields are encoded by adding field_count to the column
-         * index of the parent component. */
-        if (is_this && it && (column > field_count)) {
-            has_flat = true;
-        } else {
-            if (is_this) {
-                /* Component reached through traversal from this */
-                int32_t ref_index = column - 1;
-                ecs_ref_t *ref = ecs_vec_get_t(refs, ecs_ref_t, ref_index);
-                if (ref->id != 0) {
-                    ecs_ref_update(world, ref);
-                    ecs_table_record_t *tr = ref->tr;
-                    ecs_table_t *src_table = tr->hdr.table;
-                    column = tr->index;
-                    column = ecs_table_type_to_column_index(src_table, column);
-                    int32_t *src_dirty_state = flecs_table_get_dirty_state(
-                        world, src_table);
-                    if (mon != src_dirty_state[column + 1]) {
-                        return true;
-                    }
-                }
-            } else {
-                /* Component from static source */
-                ecs_entity_t src = match->sources[i];
-                ecs_table_t *src_table = ecs_get_table(world, src);
-                ecs_assert(src_table != NULL, ECS_INTERNAL_ERROR, NULL);
-                column = ecs_table_type_to_column_index(src_table, column - 1);
-                int32_t *src_dirty_state = flecs_table_get_dirty_state(
-                    world, src_table);
-                if (mon != src_dirty_state[column + 1]) {
-                    return true;
-                }
-            }
-        }
-    }
-
-    if (has_flat) {
-        ecs_entity_filter_t *ef = match->entity_filter;
-        flecs_flat_table_term_t *fields = ecs_vec_first(&ef->ft_terms);
-        ecs_entity_filter_iter_t *ent_it = it->priv.entity_iter;
-        int32_t cur_tgt = ent_it->target_count - 1;
-        field_count = ecs_vec_count(&ef->ft_terms);
-
-        for (i = 0; i < field_count; i ++) {
-            flecs_flat_table_term_t *field = &fields[i];
-            flecs_flat_monitor_t *fmon = ecs_vec_get_t(&field->monitor, 
-                flecs_flat_monitor_t, cur_tgt);
-            if (fmon->monitor != fmon->table_state) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-/* Check if any term for matched table has changed */
-static
-bool flecs_query_check_table_monitor(
-    ecs_query_t *query,
-    ecs_query_table_t *table,
-    int32_t term)
-{
-    ecs_query_table_match_t *cur, *end = table->last->next;
-
-    for (cur = table->first; cur != end; cur = cur->next) {
-        ecs_query_table_match_t *match = (ecs_query_table_match_t*)cur;
-        if (term == -1) {
-            if (flecs_query_check_match_monitor(query, match, NULL)) {
-                return true;
-            }
-        } else {
-            if (flecs_query_check_match_monitor_term(query, match, term)) {
-                return true;
-            } 
-        }
-    }
-
-    return false;
-}
-
-static
-bool flecs_query_check_query_monitor(
-    ecs_query_t *query)
-{
-    ecs_table_cache_iter_t it;
-    if (flecs_table_cache_iter(&query->cache, &it)) {
-        ecs_query_table_t *qt;
-        while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) {
-            if (flecs_query_check_table_monitor(query, qt, -1)) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-static
-void flecs_query_init_query_monitors(
-    ecs_query_t *query)
-{
-    ecs_query_table_match_t *cur = query->list.first;
-
-    /* Ensure each match has a monitor */
-    for (; cur != NULL; cur = cur->next) {
-        ecs_query_table_match_t *match = (ecs_query_table_match_t*)cur;
-        flecs_query_get_match_monitor(query, match);
-    }
-}
-
-/* The group by function for cascade computes the tree depth for the table type.
- * This causes tables in the query cache to be ordered by depth, which ensures
- * breadth-first iteration order. */
-static
-uint64_t flecs_query_group_by_cascade(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_id_t id,
-    void *ctx)
-{
-    (void)id;
-    ecs_term_t *term = ctx;
-    ecs_entity_t rel = term->src.trav;
-    int32_t depth = flecs_relation_depth(world, rel, table);
-    return flecs_ito(uint64_t, depth);
-}
-
-static
-void flecs_query_add_ref(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_table_match_t *qm,
-    ecs_entity_t component,
-    ecs_entity_t entity,
-    ecs_size_t size)
-{
-    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_ref_t *ref = ecs_vec_append_t(&world->allocator, &qm->refs, ecs_ref_t);
-    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
-    
-    if (size) {
-        *ref = ecs_ref_init_id(world, entity, component);
-    } else {
-        *ref = (ecs_ref_t){
-            .entity = entity,
-            .id = 0
-        };
-    }
-
-    query->flags |= EcsQueryHasRefs;
-}
-
-static
-ecs_query_table_match_t* flecs_query_add_table_match(
-    ecs_query_t *query,
-    ecs_query_table_t *qt,
-    ecs_table_t *table)
-{
-    /* Add match for table. One table can have more than one match, if
-     * the query contains wildcards. */
-    ecs_query_table_match_t *qm = flecs_query_cache_add(query->filter.world, qt);
-    qm->table = table;
-
-    qm->columns = flecs_balloc(&query->allocators.columns);
-    qm->storage_columns = flecs_balloc(&query->allocators.columns);
-    qm->ids = flecs_balloc(&query->allocators.ids);
-    qm->sources = flecs_balloc(&query->allocators.sources);
-
-    /* Insert match to iteration list if table is not empty */
-    if (!table || ecs_table_count(table) != 0) {
-        flecs_query_insert_table_node(query, qm);
-    }
-
-    return qm;
-}
-
-static
-void flecs_query_set_table_match(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_table_match_t *qm,
-    ecs_table_t *table,
-    ecs_iter_t *it)
-{
-    ecs_allocator_t *a = &world->allocator;
-    ecs_filter_t *filter = &query->filter;
-    int32_t i, term_count = filter->term_count;
-    int32_t field_count = filter->field_count;
-    ecs_term_t *terms = filter->terms;
-
-    /* Reset resources in case this is an existing record */
-    ecs_vec_reset_t(a, &qm->refs, ecs_ref_t);
-    ecs_os_memcpy_n(qm->columns, it->columns, int32_t, field_count);
-    ecs_os_memcpy_n(qm->ids, it->ids, ecs_id_t, field_count);
-    ecs_os_memcpy_n(qm->sources, it->sources, ecs_entity_t, field_count);
-
-    if (table) {
-        /* Initialize storage columns for faster access to component storage */
-        for (i = 0; i < field_count; i ++) {
-            if (terms[i].inout == EcsInOutNone) {
-                qm->storage_columns[i] = -1;
-                continue;
-            }
-
-            int32_t column = qm->columns[i];
-            if (column > 0) {
-                qm->storage_columns[i] = ecs_table_type_to_column_index(table,
-                    qm->columns[i] - 1);
-            } else {
-                /* Shared field (not from table) */
-                qm->storage_columns[i] = -2;
-            }
-        }
-
-        flecs_entity_filter_init(world, &qm->entity_filter, filter, 
-            table, qm->ids, qm->columns);
-
-        if (qm->entity_filter) {
-            query->flags &= ~EcsQueryTrivialIter;
-        }
-        if (table->flags & EcsTableHasUnion) {
-            query->flags &= ~EcsQueryTrivialIter;
-        }
-    }
-
-    /* Add references for substituted terms */
-    for (i = 0; i < term_count; i ++) {
-        ecs_term_t *term = &terms[i];
-        if (!ecs_term_match_this(term)) {
-            /* non-This terms are set during iteration */
-            continue;
-        }
-
-        int32_t field = terms[i].field_index;
-        ecs_entity_t src = it->sources[field];
-        ecs_size_t size = 0;
-        if (it->sizes) {
-            size = it->sizes[field];
-        }
-        if (src) {
-            ecs_id_t id = it->ids[field];
-            ecs_assert(ecs_is_valid(world, src), ECS_INTERNAL_ERROR, NULL);
-
-            if (id) {
-                flecs_query_add_ref(world, query, qm, id, src, size);
-
-                /* Use column index to bind term and ref */
-                if (qm->columns[field] != 0) {
-                    qm->columns[field] = -ecs_vec_count(&qm->refs);
-                }
-            }
-        }
-    }
-}
-
-static
-ecs_query_table_t* flecs_query_table_insert(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_table_t *table)
-{
-    ecs_query_table_t *qt = flecs_bcalloc(&world->allocators.query_table);
-    if (table) {
-        qt->table_id = table->id;
-    } else {
-        qt->table_id = 0;
-    }
-    ecs_table_cache_insert(&query->cache, table, &qt->hdr);
-    return qt;
-}
-
-/** Populate query cache with tables */
-static
-void flecs_query_match_tables(
-    ecs_world_t *world,
-    ecs_query_t *query)
-{
-    ecs_table_t *table = NULL;
-    ecs_query_table_t *qt = NULL;
-
-    ecs_iter_t it = flecs_filter_iter_w_flags(world, &query->filter, 0);
-    ECS_BIT_SET(it.flags, EcsIterIsInstanced);
-    ECS_BIT_SET(it.flags, EcsIterNoData);
-    ECS_BIT_SET(it.flags, EcsIterTableOnly);
-    ECS_BIT_SET(it.flags, EcsIterEntityOptional);
-
-    while (ecs_filter_next(&it)) {
-        if ((table != it.table) || (!it.table && !qt)) {
-            /* New table matched, add record to cache */
-            table = it.table;
-            qt = flecs_query_table_insert(world, query, table);
-        }
-
-        ecs_query_table_match_t *qm = flecs_query_add_table_match(query, qt, table);
-        flecs_query_set_table_match(world, query, qm, table, &it);
-    }
-}
-
-static
-bool flecs_query_match_table(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_table_t *table)
-{
-    if (!ecs_map_is_init(&query->cache.index)) {
-        return false;
-    }
-
-    ecs_query_table_t *qt = NULL;
-    ecs_filter_t *filter = &query->filter;
-    int var_id = ecs_filter_find_this_var(filter);
-    if (var_id == -1) {
-        /* If query doesn't match with This term, it can't match with tables */
-        return false;
-    }
-
-    ecs_iter_t it = flecs_filter_iter_w_flags(world, filter, EcsIterMatchVar|
-        EcsIterIsInstanced|EcsIterNoData|EcsIterEntityOptional);
-    ecs_iter_set_var_as_table(&it, var_id, table);
-
-    while (ecs_filter_next(&it)) {
-        ecs_assert(it.table == table, ECS_INTERNAL_ERROR, NULL);
-        if (qt == NULL) {
-            table = it.table;
-            qt = flecs_query_table_insert(world, query, table);
-        }
-
-        ecs_query_table_match_t *qm = flecs_query_add_table_match(query, qt, table);
-        flecs_query_set_table_match(world, query, qm, table, &it);
-    }
-
-    return qt != NULL;
-}
-
-ECS_SORT_TABLE_WITH_COMPARE(_, flecs_query_sort_table_generic, order_by, static)
-
-static
-void flecs_query_sort_table(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    int32_t column_index,
-    ecs_order_by_action_t compare,
-    ecs_sort_table_action_t sort)
-{
-    ecs_data_t *data = &table->data;
-    if (!ecs_vec_count(&data->entities)) {
-        /* Nothing to sort */
-        return;
-    }
-
-    int32_t count = flecs_table_data_count(data);
-    if (count < 2) {
-        return;
-    }
-
-    ecs_entity_t *entities = ecs_vec_first(&data->entities);
-
-    void *ptr = NULL;
-    int32_t size = 0;
-    if (column_index != -1) {
-        ecs_column_t *column = &data->columns[column_index];
-        ecs_type_info_t *ti = column->ti;
-        size = ti->size;
-        ptr = ecs_vec_first(&column->data);
-    }
-
-    if (sort) {
-        sort(world, table, entities, ptr, size, 0, count - 1, compare);
-    } else {
-        flecs_query_sort_table_generic(world, table, entities, ptr, size, 0, count - 1, compare);
-    }
-}
-
-/* Helper struct for building sorted table ranges */
-typedef struct sort_helper_t {
-    ecs_query_table_match_t *match;
-    ecs_entity_t *entities;
-    const void *ptr;
-    int32_t row;
-    int32_t elem_size;
-    int32_t count;
-    bool shared;
-} sort_helper_t;
-
-static
-const void* ptr_from_helper(
-    sort_helper_t *helper)
-{
-    ecs_assert(helper->row < helper->count, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(helper->elem_size >= 0, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(helper->row >= 0, ECS_INTERNAL_ERROR, NULL);
-    if (helper->shared) {
-        return helper->ptr;
-    } else {
-        return ECS_ELEM(helper->ptr, helper->elem_size, helper->row);
-    }
-}
-
-static
-ecs_entity_t e_from_helper(
-    sort_helper_t *helper)
-{
-    if (helper->row < helper->count) {
-        return helper->entities[helper->row];
-    } else {
-        return 0;
-    }
-}
-
-static
-void flecs_query_build_sorted_table_range(
-    ecs_query_t *query,
-    ecs_query_table_list_t *list)
-{
-    ecs_world_t *world = query->filter.world;
-    ecs_assert(!(world->flags & EcsWorldMultiThreaded), ECS_UNSUPPORTED,
-        "cannot sort query in multithreaded mode");
-
-    ecs_entity_t id = query->order_by_component;
-    ecs_order_by_action_t compare = query->order_by;
-    int32_t table_count = list->info.table_count;
-    if (!table_count) {
-        return;
-    }
-
-    ecs_vec_init_if_t(&query->table_slices, ecs_query_table_match_t);
-    int32_t to_sort = 0;
-    int32_t order_by_term = query->order_by_term;
-
-    sort_helper_t *helper = flecs_alloc_n(
-        &world->allocator, sort_helper_t, table_count);
-    ecs_query_table_match_t *cur, *end = list->last->next;
-    for (cur = list->first; cur != end; cur = cur->next) {
-        ecs_table_t *table = cur->table;
-        ecs_data_t *data = &table->data;
-
-        ecs_assert(ecs_table_count(table) != 0, ECS_INTERNAL_ERROR, NULL);
-
-        if (id) {
-            const ecs_term_t *term = &query->filter.terms[order_by_term];
-            int32_t field = term->field_index;
-            int32_t column = cur->columns[field];
-            ecs_size_t size = query->filter.sizes[field];
-            ecs_assert(column != 0, ECS_INTERNAL_ERROR, NULL);
-            if (column >= 0) {
-                column = table->column_map[column - 1];
-                ecs_vec_t *vec = &data->columns[column].data;
-                helper[to_sort].ptr = ecs_vec_first(vec);
-                helper[to_sort].elem_size = size;
-                helper[to_sort].shared = false;
-            } else {
-                ecs_entity_t src = cur->sources[field];
-                ecs_assert(src != 0, ECS_INTERNAL_ERROR, NULL);
-                ecs_record_t *r = flecs_entities_get(world, src);
-                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
-                ecs_assert(r->table != NULL, ECS_INTERNAL_ERROR, NULL);
-
-                if (term->src.flags & EcsUp) {
-                    ecs_entity_t base = 0;
-                    ecs_search_relation(world, r->table, 0, id, 
-                        EcsIsA, term->src.flags & EcsTraverseFlags, &base, 0, 0);
-                    if (base && base != src) { /* Component could be inherited */
-                        r = flecs_entities_get(world, base);
-                    }
-                }
-
-                helper[to_sort].ptr = ecs_table_get_id(
-                    world, r->table, id, ECS_RECORD_TO_ROW(r->row));
-                helper[to_sort].elem_size = size;
-                helper[to_sort].shared = true;
-            }
-            ecs_assert(helper[to_sort].ptr != NULL, ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(helper[to_sort].elem_size != 0, ECS_INTERNAL_ERROR, NULL);
-        } else {
-            helper[to_sort].ptr = NULL;
-            helper[to_sort].elem_size = 0;
-            helper[to_sort].shared = false;
-        }
-
-        helper[to_sort].match = cur;
-        helper[to_sort].entities = ecs_vec_first(&data->entities);
-        helper[to_sort].row = 0;
-        helper[to_sort].count = ecs_table_count(table);
-        to_sort ++;      
-    }
-
-    ecs_assert(to_sort != 0, ECS_INTERNAL_ERROR, NULL);
-
-    bool proceed;
-    do {
-        int32_t j, min = 0;
-        proceed = true;
-
-        ecs_entity_t e1;
-        while (!(e1 = e_from_helper(&helper[min]))) {
-            min ++;
-            if (min == to_sort) {
-                proceed = false;
-                break;
-            }
-        }
-
-        if (!proceed) {
-            break;
-        }
-
-        for (j = min + 1; j < to_sort; j++) {
-            ecs_entity_t e2 = e_from_helper(&helper[j]);
-            if (!e2) {
-                continue;
-            }
-
-            const void *ptr1 = ptr_from_helper(&helper[min]);
-            const void *ptr2 = ptr_from_helper(&helper[j]);
-
-            if (compare(e1, ptr1, e2, ptr2) > 0) {
-                min = j;
-                e1 = e_from_helper(&helper[min]);
-            }
-        }
-
-        sort_helper_t *cur_helper = &helper[min];
-        if (!cur || cur->columns != cur_helper->match->columns) {
-            cur = ecs_vec_append_t(NULL, &query->table_slices, 
-                ecs_query_table_match_t);
-            *cur = *(cur_helper->match);
-            cur->offset = cur_helper->row;
-            cur->count = 1;
-        } else {
-            cur->count ++;
-        }
-
-        cur_helper->row ++;
-    } while (proceed);
-
-    /* Iterate through the vector of slices to set the prev/next ptrs. This
-     * can't be done while building the vector, as reallocs may occur */
-    int32_t i, count = ecs_vec_count(&query->table_slices);    
-    ecs_query_table_match_t *nodes = ecs_vec_first(&query->table_slices);
-    for (i = 0; i < count; i ++) {
-        nodes[i].prev = &nodes[i - 1];
-        nodes[i].next = &nodes[i + 1];
-    }
-
-    nodes[0].prev = NULL;
-    nodes[i - 1].next = NULL;
-
-    flecs_free_n(&world->allocator, sort_helper_t, table_count, helper);
-}
-
-static
-void flecs_query_build_sorted_tables(
-    ecs_query_t *query)
-{
-    ecs_vec_clear(&query->table_slices);
-
-    if (query->group_by) {
-        /* Populate sorted node list in grouping order */
-        ecs_query_table_match_t *cur = query->list.first;
-        if (cur) {
-            do {
-                /* Find list for current group */
-                uint64_t group_id = cur->group_id;
-                ecs_query_table_list_t *list = ecs_map_get_deref(
-                    &query->groups, ecs_query_table_list_t, group_id);
-                ecs_assert(list != NULL, ECS_INTERNAL_ERROR, NULL);
-
-                /* Sort tables in current group */
-                flecs_query_build_sorted_table_range(query, list);
-
-                /* Find next group to sort */
-                cur = list->last->next;
-            } while (cur);
-        }
-    } else {
-        flecs_query_build_sorted_table_range(query, &query->list);
-    }
-}
-
-static
-void flecs_query_sort_tables(
-    ecs_world_t *world,
-    ecs_query_t *query)
-{
-    ecs_order_by_action_t compare = query->order_by;
-    if (!compare) {
-        return;
-    }
-
-    ecs_sort_table_action_t sort = query->sort_table;
-    ecs_entity_t order_by_component = query->order_by_component;
-    int32_t order_by_term = query->order_by_term;
-
-    /* Iterate over non-empty tables. Don't bother with empty tables as they
-     * have nothing to sort */
-
-    bool tables_sorted = false;
-
-    ecs_id_record_t *idr = flecs_id_record_get(world, order_by_component);
-    ecs_table_cache_iter_t it;
-    ecs_query_table_t *qt;
-    flecs_table_cache_iter(&query->cache, &it);
-
-    while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) {
-        ecs_table_t *table = qt->hdr.table;
-        bool dirty = false;
-
-        if (flecs_query_check_table_monitor(query, qt, 0)) {
-            tables_sorted = true; /* Ensure ranges are rebuilt */
-            dirty = true;
-        }
-
-        int32_t column = -1;
-        if (order_by_component) {
-            if (flecs_query_check_table_monitor(query, qt, order_by_term + 1)) {
-                dirty = true;
-            }
-
-            if (dirty) {
-                column = -1;
-
-                const ecs_table_record_t *tr = flecs_id_record_get_table(
-                    idr, table);
-                if (tr) {
-                    column = tr->column;
-                }
-
-                if (column == -1) {
-                    /* Component is shared, no sorting is needed */
-                    dirty = false;
-                }
-            }
-        }
-
-        if (!dirty) {
-            continue;
-        }
-
-        /* Something has changed, sort the table. Prefers using 
-         * flecs_query_sort_table when available */
-        flecs_query_sort_table(world, table, column, compare, sort);
-        tables_sorted = true;
-    }
-
-    if (tables_sorted || query->match_count != query->prev_match_count) {
-        flecs_query_build_sorted_tables(query);
-        query->match_count ++; /* Increase version if tables changed */
-    }
-}
-
-static
-bool flecs_query_has_refs(
-    ecs_query_t *query)
-{
-    ecs_term_t *terms = query->filter.terms;
-    int32_t i, count = query->filter.term_count;
-    for (i = 0; i < count; i ++) {
-        if (terms[i].src.flags & (EcsUp | EcsIsEntity)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static
-void flecs_query_for_each_component_monitor(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    void(*callback)(
-        ecs_world_t* world,
-        ecs_id_t id,
-        ecs_query_t *query))
-{
-    ecs_term_t *terms = query->filter.terms;
-    int32_t i, count = query->filter.term_count;
-
-    for (i = 0; i < count; i++) {
-        ecs_term_t *term = &terms[i];
-        ecs_term_id_t *src = &term->src;
-
-        if (src->flags & EcsUp) {
-            callback(world, ecs_pair(src->trav, EcsWildcard), query);
-            if (src->trav != EcsIsA) {
-                callback(world, ecs_pair(EcsIsA, EcsWildcard), query);
-            }
-            callback(world, term->id, query);
-
-        } else if (src->flags & EcsSelf && !ecs_term_match_this(term)) {
-            callback(world, term->id, query);
-        }
-    }
-}
-
-static
-bool flecs_query_is_term_id_supported(
-    ecs_term_id_t *term_id)
-{
-    if (!(term_id->flags & EcsIsVariable)) {
-        return true;
-    }
-    if (ecs_id_is_wildcard(term_id->id)) {
-        return true;
-    }
-    return false;
-}
-
-static
-int flecs_query_process_signature(
-    ecs_world_t *world,
-    ecs_query_t *query)
-{
-    ecs_term_t *terms = query->filter.terms;
-    int32_t i, count = query->filter.term_count;
-
-    for (i = 0; i < count; i ++) {
-        ecs_term_t *term = &terms[i];
-        ecs_term_id_t *first = &term->first;
-        ecs_term_id_t *src = &term->src;
-        ecs_term_id_t *second = &term->second;
-        ecs_inout_kind_t inout = term->inout;
-
-        bool is_src_ok = flecs_query_is_term_id_supported(src);
-        bool is_first_ok = flecs_query_is_term_id_supported(first);
-        bool is_second_ok = flecs_query_is_term_id_supported(second);
-
-        (void)first;
-        (void)second;
-        (void)is_src_ok;
-        (void)is_first_ok;
-        (void)is_second_ok;
-
-        /* Queries do not support named variables */
-        ecs_check(is_src_ok || ecs_term_match_this(term),
-            ECS_UNSUPPORTED, NULL);
-        ecs_check(is_first_ok, ECS_UNSUPPORTED, NULL);
-        ecs_check(is_second_ok,  ECS_UNSUPPORTED, NULL);
-        ecs_check(!(src->flags & EcsFilter), ECS_INVALID_PARAMETER,
-            "invalid usage of Filter for query");
-
-        if (inout != EcsIn && inout != EcsInOutNone) {
-            /* Non-this terms default to EcsIn */
-            if (ecs_term_match_this(term) || inout != EcsInOutDefault) {
-                query->flags |= EcsQueryHasOutTerms;
-            }
-
-            bool match_non_this = !ecs_term_match_this(term) || 
-                (term->src.flags & EcsUp);
-            if (match_non_this && inout != EcsInOutDefault) {
-                query->flags |= EcsQueryHasNonThisOutTerms;
-            }
-        }
-
-        if (src->flags & EcsCascade) {
-            /* Query can only have one cascade column */
-            ecs_assert(query->cascade_by == 0, ECS_INVALID_PARAMETER, NULL);
-            query->cascade_by = i + 1;
-        }
-    }
-
-    query->flags |= (ecs_flags32_t)(flecs_query_has_refs(query) * EcsQueryHasRefs);
-
-    if (!(query->flags & EcsQueryIsSubquery)) {
-        flecs_query_for_each_component_monitor(world, query, flecs_monitor_register);
-    }
-
-    return 0;
-error:
-    return -1;
-}
-
-/** When a table becomes empty remove it from the query list, or vice versa. */
-static
-void flecs_query_update_table(
-    ecs_query_t *query,
-    ecs_table_t *table,
-    bool empty)
-{
-    int32_t prev_count = ecs_query_table_count(query);
-    ecs_table_cache_set_empty(&query->cache, table, empty);
-    int32_t cur_count = ecs_query_table_count(query);
-
-    if (prev_count != cur_count) {
-        ecs_query_table_t *qt = ecs_table_cache_get(&query->cache, table);
-        ecs_assert(qt != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_query_table_match_t *cur, *next;
-
-        for (cur = qt->first; cur != NULL; cur = next) {
-            next = cur->next_match;
-
-            if (empty) {
-                ecs_assert(ecs_table_count(table) == 0, 
-                    ECS_INTERNAL_ERROR, NULL);
-
-                flecs_query_remove_table_node(query, cur);
-            } else {
-                ecs_assert(ecs_table_count(table) != 0, 
-                    ECS_INTERNAL_ERROR, NULL);
-                flecs_query_insert_table_node(query, cur);
-            }
-        }
-    }
-
-    ecs_assert(cur_count || query->list.first == NULL, 
-        ECS_INTERNAL_ERROR, NULL);
-}
-
-static
-void flecs_query_add_subquery(
-    ecs_world_t *world, 
-    ecs_query_t *parent, 
-    ecs_query_t *subquery) 
-{
-    ecs_vec_init_if_t(&parent->subqueries, ecs_query_t*);
-    ecs_query_t **elem = ecs_vec_append_t(
-        NULL, &parent->subqueries, ecs_query_t*);
-    *elem = subquery;
-
-    ecs_table_cache_t *cache = &parent->cache;
-    ecs_table_cache_iter_t it;
-    ecs_query_table_t *qt;
-    flecs_table_cache_all_iter(cache, &it);
-    while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) {
-        flecs_query_match_table(world, subquery, qt->hdr.table);
-    }
-}
-
-static
-void flecs_query_notify_subqueries(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_event_t *event)
-{
-    if (query->subqueries.array) {
-        ecs_query_t **queries = ecs_vec_first(&query->subqueries);
-        int32_t i, count = ecs_vec_count(&query->subqueries);
-
-        ecs_query_event_t sub_event = *event;
-        sub_event.parent_query = query;
-
-        for (i = 0; i < count; i ++) {
-            ecs_query_t *sub = queries[i];
-            flecs_query_notify(world, sub, &sub_event);
-        }
-    }
-}
-
-/* Remove table */
-static
-void flecs_query_table_match_free(
-    ecs_query_t *query,
-    ecs_query_table_t *elem,
-    ecs_query_table_match_t *first)
-{
-    ecs_query_table_match_t *cur, *next;
-    ecs_world_t *world = query->filter.world;
-
-    for (cur = first; cur != NULL; cur = next) {
-        flecs_bfree(&query->allocators.columns, cur->columns);
-        flecs_bfree(&query->allocators.columns, cur->storage_columns);
-        flecs_bfree(&query->allocators.ids, cur->ids);
-        flecs_bfree(&query->allocators.sources, cur->sources);
-
-        if (cur->monitor) {
-            flecs_bfree(&query->allocators.monitors, cur->monitor);
-        }
-        if (!elem->hdr.empty) {
-            flecs_query_remove_table_node(query, cur);
-        }
-        
-        ecs_vec_fini_t(&world->allocator, &cur->refs, ecs_ref_t);
-        flecs_entity_filter_fini(world, cur->entity_filter);
-
-        next = cur->next_match;
-
-        flecs_bfree(&world->allocators.query_table_match, cur);
-    }
-}
-
-static
-void flecs_query_table_free(
-    ecs_query_t *query,
-    ecs_query_table_t *elem)
-{
-    flecs_query_table_match_free(query, elem, elem->first);
-    flecs_bfree(&query->filter.world->allocators.query_table, elem);
-}
-
-static
-void flecs_query_unmatch_table(
-    ecs_query_t *query,
-    ecs_table_t *table,
-    ecs_query_table_t *elem)
-{
-    if (!elem) {
-        elem = ecs_table_cache_get(&query->cache, table);
-    }
-    if (elem) {
-        ecs_table_cache_remove(&query->cache, elem->table_id, &elem->hdr);
-        flecs_query_table_free(query, elem);
-    }
-}
-
-/* Rematch system with tables after a change happened to a watched entity */
-static
-void flecs_query_rematch_tables(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_t *parent_query)
-{
-    ecs_iter_t it, parent_it;
-    ecs_table_t *table = NULL;
-    ecs_query_table_t *qt = NULL;
-    ecs_query_table_match_t *qm = NULL;
-
-    if (query->monitor_generation == world->monitor_generation) {
-        return;
-    }
-
-    query->monitor_generation = world->monitor_generation;
-
-    if (parent_query) {
-        parent_it = ecs_query_iter(world, parent_query);
-        it = ecs_filter_chain_iter(&parent_it, &query->filter);
-    } else {
-        it = flecs_filter_iter_w_flags(world, &query->filter, 0);
-    }
-
-    ECS_BIT_SET(it.flags, EcsIterIsInstanced);
-    ECS_BIT_SET(it.flags, EcsIterNoData);
-    ECS_BIT_SET(it.flags, EcsIterEntityOptional);
-
-    world->info.rematch_count_total ++;
-    int32_t rematch_count = ++ query->rematch_count;
-
-    ecs_time_t t = {0};
-    if (world->flags & EcsWorldMeasureFrameTime) {
-        ecs_time_measure(&t);
-    }
-
-    while (ecs_filter_next(&it)) {
-        if ((table != it.table) || (!it.table && !qt)) {
-            if (qm && qm->next_match) {
-                flecs_query_table_match_free(query, qt, qm->next_match);
-                qm->next_match = NULL;
-            }
-
-            table = it.table;
-
-            qt = ecs_table_cache_get(&query->cache, table);
-            if (!qt) {
-                qt = flecs_query_table_insert(world, query, table);
-            }
-
-            ecs_assert(qt->hdr.table == table, ECS_INTERNAL_ERROR, NULL);
-            qt->rematch_count = rematch_count;
-            qm = NULL;
-        }
-        if (!qm) {
-            qm = qt->first;
-        } else {
-            qm = qm->next_match;
-        }
-        if (!qm) {
-            qm = flecs_query_add_table_match(query, qt, table);
-        }
-
-        flecs_query_set_table_match(world, query, qm, table, &it);
-
-        if (table && ecs_table_count(table) && query->group_by) {
-            if (flecs_query_get_group_id(query, table) != qm->group_id) {
-                /* Update table group */
-                flecs_query_remove_table_node(query, qm);
-                flecs_query_insert_table_node(query, qm);
-            }
-        }
-    }
-
-    if (qm && qm->next_match) {
-        flecs_query_table_match_free(query, qt, qm->next_match);
-        qm->next_match = NULL;
-    }
-
-    /* Iterate all tables in cache, remove ones that weren't just matched */
-    ecs_table_cache_iter_t cache_it;
-    if (flecs_table_cache_all_iter(&query->cache, &cache_it)) {
-        while ((qt = flecs_table_cache_next(&cache_it, ecs_query_table_t))) {
-            if (qt->rematch_count != rematch_count) {
-                flecs_query_unmatch_table(query, qt->hdr.table, qt);
-            }
-        }
-    }
-
-    if (world->flags & EcsWorldMeasureFrameTime) {
-        world->info.rematch_time_total += (ecs_ftime_t)ecs_time_measure(&t);
-    }
-}
-
-static
-void flecs_query_remove_subquery(
-    ecs_query_t *parent, 
-    ecs_query_t *sub)
-{
-    ecs_assert(parent != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(sub != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(parent->subqueries.array, ECS_INTERNAL_ERROR, NULL);
-
-    int32_t i, count = ecs_vec_count(&parent->subqueries);
-    ecs_query_t **sq = ecs_vec_first(&parent->subqueries);
-
-    for (i = 0; i < count; i ++) {
-        if (sq[i] == sub) {
-            break;
-        }
-    }
-
-    ecs_vec_remove_t(&parent->subqueries, ecs_query_t*, i);
-}
-
-/* -- Private API -- */
-
-void flecs_query_notify(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_query_event_t *event)
-{
-    bool notify = true;
-
-    switch(event->kind) {
-    case EcsQueryTableMatch:
-        /* Creation of new table */
-        if (flecs_query_match_table(world, query, event->table)) {
-            if (query->subqueries.array) {
-                flecs_query_notify_subqueries(world, query, event);
-            }
-        }
-        notify = false;
-        break;
-    case EcsQueryTableUnmatch:
-        /* Deletion of table */
-        flecs_query_unmatch_table(query, event->table, NULL);
-        break;
-    case EcsQueryTableRematch:
-        /* Rematch tables of query */
-        flecs_query_rematch_tables(world, query, event->parent_query);
-        break;        
-    case EcsQueryOrphan:
-        ecs_assert(query->flags & EcsQueryIsSubquery, ECS_INTERNAL_ERROR, NULL);
-        query->flags |= EcsQueryIsOrphaned;
-        query->parent = NULL;
-        break;
-    }
-
-    if (notify) {
-        flecs_query_notify_subqueries(world, query, event);
-    }
-}
-
-static
-void flecs_query_order_by(
-    ecs_world_t *world,
-    ecs_query_t *query,
-    ecs_entity_t order_by_component,
-    ecs_order_by_action_t order_by,
-    ecs_sort_table_action_t action)
-{
-    ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(query->flags & EcsQueryIsOrphaned), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!ecs_id_is_wildcard(order_by_component), 
-        ECS_INVALID_PARAMETER, NULL);
-
-    /* Find order_by_component term & make sure it is queried for */
-    const ecs_filter_t *filter = &query->filter;
-    int32_t i, count = filter->term_count;
-    int32_t order_by_term = -1;
-
-    if (order_by_component) {
-        for (i = 0; i < count; i ++) {
-            ecs_term_t *term = &filter->terms[i];
-            
-            /* Only And terms are supported */
-            if (term->id == order_by_component && term->oper == EcsAnd) {
-                order_by_term = i;
-                break;
-            }
-        }
-
-        ecs_check(order_by_term != -1, ECS_INVALID_PARAMETER, 
-            "sorted component not is queried for");
-    }
-
-    query->order_by_component = order_by_component;
-    query->order_by = order_by;
-    query->order_by_term = order_by_term;
-    query->sort_table = action;
-
-    ecs_vec_fini_t(NULL, &query->table_slices, ecs_query_table_match_t);
-    flecs_query_sort_tables(world, query);  
-
-    if (!query->table_slices.array) {
-        flecs_query_build_sorted_tables(query);
-    }
-
-    query->flags &= ~EcsQueryTrivialIter;
-error:
-    return;
-}
-
-static
-void flecs_query_group_by(
-    ecs_query_t *query,
-    ecs_entity_t sort_component,
-    ecs_group_by_action_t group_by)
-{   
-    /* Cannot change grouping once a query has been created */
-    ecs_check(query->group_by_id == 0, ECS_INVALID_OPERATION, NULL);
-    ecs_check(query->group_by == 0, ECS_INVALID_OPERATION, NULL);
-
-    if (!group_by) {
-        /* Builtin function that groups by relationship */
-        group_by = flecs_query_default_group_by;   
-    }
-
-    query->group_by_id = sort_component;
-    query->group_by = group_by;
-
-    ecs_map_init_w_params(&query->groups, 
-        &query->filter.world->allocators.query_table_list);
-error:
-    return;
-}
-
-/* Implementation for iterable mixin */
-static
-void flecs_query_iter_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter)
-{
-    ecs_poly_assert(poly, ecs_query_t);
-
-    if (filter) {
-        iter[1] = ecs_query_iter(world, ECS_CONST_CAST(ecs_query_t*, poly));
-        iter[0] = ecs_term_chain_iter(&iter[1], filter);
-    } else {
-        iter[0] = ecs_query_iter(world, ECS_CONST_CAST(ecs_query_t*, poly));
-    }
-}
-
-static
-void flecs_query_on_event(
-    ecs_iter_t *it)
-{
-    /* Because this is the observer::run callback, checking if this is event is
-     * already handled is not done for us. */
-    ecs_world_t *world = it->world;
-    ecs_observer_t *o = it->ctx;
-    if (o->last_event_id) {
-        if (o->last_event_id[0] == world->event_id) {
-            return;
-        }
-        o->last_event_id[0] = world->event_id;
-    }
-
-    ecs_query_t *query = o->ctx;
-    ecs_table_t *table = it->table;
-    ecs_entity_t event = it->event;
-
-    if (event == EcsOnTableCreate) {
-        /* Creation of new table */
-        if (flecs_query_match_table(world, query, table)) {
-            if (query->subqueries.array) {
-                ecs_query_event_t evt = {
-                    .kind = EcsQueryTableMatch,
-                    .table = table,
-                    .parent_query = query
-                };
-                flecs_query_notify_subqueries(world, query, &evt);
-            }
-        }
-        return;
-    }
-
-    ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL);
-
-    /* The observer isn't doing the matching because the query can do it more
-     * efficiently by checking the table with the query cache. */
-    if (ecs_table_cache_get(&query->cache, table) == NULL) {
-        return;
-    }
-
-    if (event == EcsOnTableEmpty) {
-        flecs_query_update_table(query, table, true);
-    } else
-    if (event == EcsOnTableFill) {
-        flecs_query_update_table(query, table, false);
-    } else if (event == EcsOnTableDelete) {
-        /* Deletion of table */
-        flecs_query_unmatch_table(query, table, NULL);
-        if (query->subqueries.array) {
-                ecs_query_event_t evt = {
-                    .kind = EcsQueryTableUnmatch,
-                    .table = table,
-                    .parent_query = query
-                };
-                flecs_query_notify_subqueries(world, query, &evt);
-        }
-        return;
-    }
-}
-
-static
-void flecs_query_table_cache_free(
-    ecs_query_t *query)
-{
-    ecs_table_cache_iter_t it;
-    ecs_query_table_t *qt;
-
-    if (flecs_table_cache_all_iter(&query->cache, &it)) {
-        while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) {
-            flecs_query_table_free(query, qt);
-        }
-    }
-
-    ecs_table_cache_fini(&query->cache);
-}
-
-static
-void flecs_query_allocators_init(
-    ecs_query_t *query)
-{
-    int32_t field_count = query->filter.field_count;
-    if (field_count) {
-        flecs_ballocator_init(&query->allocators.columns, 
-            field_count * ECS_SIZEOF(int32_t));
-        flecs_ballocator_init(&query->allocators.ids, 
-            field_count * ECS_SIZEOF(ecs_id_t));
-        flecs_ballocator_init(&query->allocators.sources,
-            field_count * ECS_SIZEOF(ecs_entity_t));
-        flecs_ballocator_init(&query->allocators.monitors,
-            (1 + field_count) * ECS_SIZEOF(int32_t));
-    }
-}
-
-static
-void flecs_query_allocators_fini(
-    ecs_query_t *query)
-{
-    int32_t field_count = query->filter.field_count;
-    if (field_count) {
-        flecs_ballocator_fini(&query->allocators.columns);
-        flecs_ballocator_fini(&query->allocators.ids);
-        flecs_ballocator_fini(&query->allocators.sources);
-        flecs_ballocator_fini(&query->allocators.monitors);
-    }
-}
-
-static
-void flecs_query_fini(
-    ecs_query_t *query)
-{
-    ecs_world_t *world = query->filter.world;
-
-    ecs_group_delete_action_t on_delete = query->on_group_delete;
-    if (on_delete) {
-        ecs_map_iter_t it = ecs_map_iter(&query->groups);
-        while (ecs_map_next(&it)) {
-            ecs_query_table_list_t *group = ecs_map_ptr(&it);
-            uint64_t group_id = ecs_map_key(&it);
-            on_delete(world, group_id, group->info.ctx, query->group_by_ctx);
-        }
-        query->on_group_delete = NULL;
-    }
-
-    if (query->group_by_ctx_free) {
-        if (query->group_by_ctx) {
-            query->group_by_ctx_free(query->group_by_ctx);
-        }
-    }
-
-    if ((query->flags & EcsQueryIsSubquery) &&
-        !(query->flags & EcsQueryIsOrphaned))
-    {
-        flecs_query_remove_subquery(query->parent, query);
-    }
-
-    flecs_query_notify_subqueries(world, query, &(ecs_query_event_t){
-        .kind = EcsQueryOrphan
-    });
-
-    flecs_query_for_each_component_monitor(world, query, 
-        flecs_monitor_unregister);
-    flecs_query_table_cache_free(query);
-
-    ecs_map_fini(&query->groups);
-
-    ecs_vec_fini_t(NULL, &query->subqueries, ecs_query_t*);
-    ecs_vec_fini_t(NULL, &query->table_slices, ecs_query_table_match_t);
-    ecs_filter_fini(&query->filter);
-
-    flecs_query_allocators_fini(query);
-
-    if (query->ctx_free) {
-        query->ctx_free(query->ctx);
-    }
-    if (query->binding_ctx_free) {
-        query->binding_ctx_free(query->binding_ctx);
-    }
-
-    ecs_poly_free(query, ecs_query_t);
-}
-
-/* -- Public API -- */
-
-ecs_query_t* ecs_query_init(
-    ecs_world_t *world,
-    const ecs_query_desc_t *desc)
-{
-    ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, NULL);
-
-    ecs_query_t *result = ecs_poly_new(ecs_query_t);
-    ecs_observer_desc_t observer_desc = { .filter = desc->filter };
-    ecs_entity_t entity = desc->filter.entity;
-
-    observer_desc.filter.flags = EcsFilterMatchEmptyTables;
-    observer_desc.filter.storage = &result->filter;
-    result->filter = ECS_FILTER_INIT;
-
-    if (ecs_filter_init(world, &observer_desc.filter) == NULL) {
-        goto error;
-    }
-
-    ECS_BIT_COND(result->flags, EcsQueryTrivialIter, 
-        !!(result->filter.flags & EcsFilterMatchOnlyThis));
-
-    flecs_query_allocators_init(result);
-
-    if (result->filter.term_count) {
-        observer_desc.entity = entity;
-        observer_desc.run = flecs_query_on_event;
-        observer_desc.ctx = result;
-        observer_desc.events[0] = EcsOnTableEmpty;
-        observer_desc.events[1] = EcsOnTableFill;
-        if (!desc->parent) {
-            observer_desc.events[2] = EcsOnTableCreate;
-            observer_desc.events[3] = EcsOnTableDelete;
-        }
-        observer_desc.filter.flags |= EcsFilterNoData;
-        observer_desc.filter.instanced = true;
-
-        /* ecs_filter_init could have moved away resources from the terms array
-         * in the descriptor, so use the terms array from the filter. */
-        observer_desc.filter.terms_buffer = result->filter.terms;
-        observer_desc.filter.terms_buffer_count = result->filter.term_count;
-        observer_desc.filter.expr = NULL; /* Already parsed */
-
-        entity = ecs_observer_init(world, &observer_desc);
-        if (!entity) {
-            goto error;
-        }
-    }
-
-    result->iterable.init = flecs_query_iter_init;
-    result->dtor = (ecs_poly_dtor_t)flecs_query_fini;
-    result->prev_match_count = -1;
-
-    result->ctx = desc->ctx;
-    result->binding_ctx = desc->binding_ctx;
-    result->ctx_free = desc->ctx_free;
-    result->binding_ctx_free = desc->binding_ctx_free;
-
-    if (ecs_should_log_1()) {
-        char *filter_expr = ecs_filter_str(world, &result->filter);
-        ecs_dbg_1("#[green]query#[normal] [%s] created", 
-            filter_expr ? filter_expr : "");
-        ecs_os_free(filter_expr);
-    }
-
-    ecs_log_push_1();
-
-    if (flecs_query_process_signature(world, result)) {
-        goto error;
-    }
-
-    /* Group before matching so we won't have to move tables around later */
-    int32_t cascade_by = result->cascade_by;
-    if (cascade_by) {
-        flecs_query_group_by(result, result->filter.terms[cascade_by - 1].id,
-            flecs_query_group_by_cascade);
-        result->group_by_ctx = &result->filter.terms[cascade_by - 1];
-    }
-
-    if (desc->group_by || desc->group_by_id) {
-        /* Can't have a cascade term and group by at the same time, as cascade
-         * uses the group_by mechanism */
-        ecs_check(!result->cascade_by, ECS_INVALID_PARAMETER, NULL);
-        flecs_query_group_by(result, desc->group_by_id, desc->group_by);
-        result->group_by_ctx = desc->group_by_ctx;
-        result->on_group_create = desc->on_group_create;
-        result->on_group_delete = desc->on_group_delete;
-        result->group_by_ctx_free = desc->group_by_ctx_free;
-    }
-
-    if (desc->parent != NULL) {
-        result->flags |= EcsQueryIsSubquery;
-    }
-
-    /* If the query refers to itself, add the components that were queried for
-     * to the query itself. */
-    if (entity)  {
-        int32_t t, term_count = result->filter.term_count;
-        ecs_term_t *terms = result->filter.terms;
-
-        for (t = 0; t < term_count; t ++) {
-            ecs_term_t *term = &terms[t];
-            if (term->src.id == entity) {
-                ecs_add_id(world, entity, term->id);
-            }
-        }        
-    }
-
-    if (!entity) {
-        entity = ecs_new_id(world);
-    }
-
-    EcsPoly *poly = ecs_poly_bind(world, entity, ecs_query_t);
-    if (poly->poly) {
-        /* If entity already had poly query, delete previous */
-        flecs_query_fini(poly->poly);
-    }
-    poly->poly = result;
-    result->filter.entity = entity;
-
-    /* Ensure that while initially populating the query with tables, they are
-     * in the right empty/non-empty list. This ensures the query won't miss
-     * empty/non-empty events for tables that are currently out of sync, but
-     * change back to being in sync before processing pending events. */
-    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
-
-    ecs_table_cache_init(world, &result->cache);
-
-    if (!desc->parent) {
-        flecs_query_match_tables(world, result);
-    } else {
-        flecs_query_add_subquery(world, desc->parent, result);
-        result->parent = desc->parent;
-    }
-
-    if (desc->order_by) {
-        flecs_query_order_by(
-            world, result, desc->order_by_component, desc->order_by,
-            desc->sort_table);
-    }
-
-    if (!ecs_query_table_count(result) && result->filter.term_count) {
-        ecs_add_id(world, entity, EcsEmpty);
-    }
-
-    ecs_poly_modified(world, entity, ecs_query_t);
-
-    ecs_log_pop_1();
-
-    return result;
-error:
-    if (result) {
-        ecs_filter_fini(&result->filter);
-        ecs_os_free(result);
-    }
-    return NULL;
-}
-
-void ecs_query_fini(
-    ecs_query_t *query)
-{
-    ecs_poly_assert(query, ecs_query_t);
-    ecs_delete(query->filter.world, query->filter.entity);
-}
-
-const ecs_filter_t* ecs_query_get_filter(
-    const ecs_query_t *query)
-{
-    ecs_poly_assert(query, ecs_query_t);
-    return &query->filter;
-}
-
-static
-void flecs_query_set_var(
-    ecs_iter_t *it)
-{
-    ecs_check(it->constrained_vars == 1, ECS_INVALID_OPERATION, 
-        "can only set $this variable for queries");
-
-    ecs_var_t *var = &it->variables[0];
-    ecs_table_t *table = var->range.table;
-    if (!table) {
-        goto nodata;
-    }
-
-    ecs_query_iter_t *qit = &it->priv.iter.query;
-    ecs_query_t *query = qit->query;
-    ecs_query_table_t *qt = ecs_table_cache_get(&query->cache, table);
-    if (!qt) {
-        goto nodata;
-    }
-
-    qit->node = qt->first;
-    qit->last = qt->last->next_match;
-    it->offset = var->range.offset;
-    it->count = var->range.count;
-    return;
-error:
-nodata:
-    it->priv.iter.query.node = NULL;
-    it->priv.iter.query.last = NULL;
-    return;
-}
-
-ecs_iter_t ecs_query_iter(
-    const ecs_world_t *stage,
-    ecs_query_t *query)
-{
-    ecs_poly_assert(query, ecs_query_t);
-    ecs_check(!(query->flags & EcsQueryIsOrphaned),
-        ECS_INVALID_PARAMETER, NULL);
-
-    ecs_world_t *world = query->filter.world;
-    ecs_poly_assert(world, ecs_world_t);
-
-    query->filter.eval_count ++;
-
-    /* Process table events to ensure that the list of iterated tables doesn't
-     * contain empty tables. */
-    flecs_process_pending_tables(world);
-
-    /* If query has order_by, apply sort */
-    flecs_query_sort_tables(world, query);
-
-    /* If monitors changed, do query rematching */
-    if (!(world->flags & EcsWorldReadonly) && query->flags & EcsQueryHasRefs) {
-        flecs_eval_component_monitors(world);
-    }
-
-    /* Prepare iterator */
-
-    int32_t table_count;
-    if (ecs_vec_count(&query->table_slices)) {
-        table_count = ecs_vec_count(&query->table_slices);
-    } else {
-        table_count = ecs_query_table_count(query);
-    }
-
-    ecs_query_iter_t it = {
-        .query = query,
-        .node = query->list.first,
-        .last = NULL
-    };
-
-    if (query->order_by && query->list.info.table_count) {
-        it.node = ecs_vec_first(&query->table_slices);
-    }
-
-    ecs_iter_t result = {
-        .real_world = world,
-        .world = ECS_CONST_CAST(ecs_world_t*, stage),
-        .query = &query->filter,
-        .terms = query->filter.terms,
-        .field_count = query->filter.field_count,
-        .table_count = table_count,
-        .variable_count = 1,
-        .priv.iter.query = it,
-        .next = ecs_query_next,
-        .set_var = flecs_query_set_var,
-        .system = query->filter.entity
-    };
-
-    flecs_filter_apply_iter_flags(&result, &query->filter);
-
-    ecs_filter_t *filter = &query->filter;
-    ecs_iter_t fit;
-    if (!(query->flags & EcsQueryTrivialIter)) {
-        /* Check if non-This terms (like singleton terms) still match */
-        if (!(filter->flags & EcsFilterMatchOnlyThis)) {
-            fit = flecs_filter_iter_w_flags(ECS_CONST_CAST(ecs_world_t*, stage),
-                &query->filter, EcsIterIgnoreThis);
-            if (!ecs_filter_next(&fit)) {
-                /* No match, so return nothing */
-                goto noresults;
-            }
-        }
-
-        flecs_iter_init(stage, &result, flecs_iter_cache_all);
-
-        /* Copy the data */
-        if (!(filter->flags & EcsFilterMatchOnlyThis)) {
-            int32_t field_count = filter->field_count;
-            if (field_count) {
-                if (result.ptrs) {
-                    ecs_os_memcpy_n(result.ptrs, fit.ptrs, void*, field_count);
-                }
-                ecs_os_memcpy_n(result.ids, fit.ids, ecs_id_t, field_count);
-                ecs_os_memcpy_n(result.columns, fit.columns, int32_t, field_count);
-                ecs_os_memcpy_n(result.sources, fit.sources, int32_t, field_count);
-            }
-            ecs_iter_fini(&fit);
-        }
-    } else {
-        /* Trivial iteration, use arrays from query cache */
-        flecs_iter_init(stage, &result, 
-            flecs_iter_cache_ptrs|flecs_iter_cache_variables);
-    }
-
-    result.sizes = query->filter.sizes;
-
-    return result;
-error:
-noresults:
-    result.priv.iter.query.node = NULL;
-    return result;
-}
-
-void ecs_query_set_group(
-    ecs_iter_t *it,
-    uint64_t group_id)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_PARAMETER, NULL);
-
-    ecs_query_iter_t *qit = &it->priv.iter.query;
-    ecs_query_t *q = qit->query;
-    ecs_check(q != NULL, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_query_table_list_t *node = flecs_query_get_group(q, group_id);
-    if (!node) {
-        qit->node = NULL;
-        return;
-    }
-
-    ecs_query_table_match_t *first = node->first;
-    if (first) {
-        qit->node = node->first;
-        qit->last = node->last->next;
-    } else {
-        qit->node = NULL;
-        qit->last = NULL;
-    }
-    
-error:
-    return;
-}
-
-const ecs_query_group_info_t* ecs_query_get_group_info(
-    const ecs_query_t *query,
-    uint64_t group_id)
-{
-    ecs_query_table_list_t *node = flecs_query_get_group(query, group_id);
-    if (!node) {
-        return NULL;
-    }
-    
-    return &node->info;
-}
-
-void* ecs_query_get_group_ctx(
-    const ecs_query_t *query,
-    uint64_t group_id)
-{
-    const ecs_query_group_info_t *info = 
-        ecs_query_get_group_info(query, group_id);
-    if (!info) {
-        return NULL;
-    } else {
-        return info->ctx;
-    }
-}
-
-static
-void flecs_query_mark_columns_dirty(
-    ecs_query_t *query,
-    ecs_query_table_match_t *qm)
-{
-    ecs_table_t *table = qm->table;
-    ecs_filter_t *filter = &query->filter;
-    if ((table && table->dirty_state) || (query->flags & EcsQueryHasNonThisOutTerms)) {
-        ecs_term_t *terms = filter->terms;
-        int32_t i, count = filter->term_count;
-
-        for (i = 0; i < count; i ++) {
-            ecs_term_t *term = &terms[i];
-            ecs_inout_kind_t inout = term->inout;
-            if (inout == EcsIn || inout == EcsInOutNone) {
-                /* Don't mark readonly terms dirty */
-                continue;
-            }
-
-            flecs_table_column_t tc;
-            flecs_query_get_column_for_term(query, qm, i, &tc);
-
-            if (tc.column == -1) {
-                continue;
-            }
-
-            ecs_assert(tc.table != NULL, ECS_INTERNAL_ERROR, NULL);
-            int32_t *dirty_state = tc.table->dirty_state;
-            if (!dirty_state) {
-                continue;
-            }
-
-            if (table != tc.table) {
-                if (inout == EcsInOutDefault) {
-                    continue;
-                }
-            }
-
-            ecs_assert(tc.column >= 0, ECS_INTERNAL_ERROR, NULL);
-
-            dirty_state[tc.column + 1] ++;
-        }
-    }
-}
-
-bool ecs_query_next_table(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-
-    flecs_iter_validate(it);
-
-    ecs_query_iter_t *iter = &it->priv.iter.query;
-    ecs_query_table_match_t *node = iter->node;
-    ecs_query_t *query = iter->query;
-
-    ecs_query_table_match_t *prev = iter->prev;
-    if (prev) {
-        if (query->flags & EcsQueryHasMonitor) {
-            flecs_query_sync_match_monitor(query, prev);
-        }
-        if (query->flags & EcsQueryHasOutTerms) {
-            if (it->count) {
-                flecs_query_mark_columns_dirty(query, prev);
-            }
-        }
-    }
-
-    if (node != iter->last) {
-        it->table = node->table;
-        it->group_id = node->group_id;
-        it->count = 0;
-        iter->node = node->next;
-        iter->prev = node;
-        return true;
-    }
-
-error:
-    query->match_count = query->prev_match_count;
-    ecs_iter_fini(it);
-    return false;
-}
-
-static
-void flecs_query_populate_trivial(
-    ecs_iter_t *it,
-    ecs_query_table_match_t *match)
-{;
-    ecs_table_t *table = match->table;
-    int32_t offset, count;
-    if (!it->constrained_vars) {
-        it->offset = offset = 0;
-        it->count = count = ecs_table_count(table);
-    } else {
-        offset = it->offset;
-        count = it->count;
-    }
-
-    it->ids = match->ids;
-    it->sources = match->sources;
-    it->columns = match->columns;
-    it->group_id = match->group_id;
-    it->instance_count = 0;
-    it->references = ecs_vec_first(&match->refs);
-
-    if (!it->references) {
-        ecs_data_t *data = &table->data;
-        if (!(it->flags & EcsIterNoData)) {
-            int32_t i;
-            for (i = 0; i < it->field_count; i ++) {
-                int32_t column = match->storage_columns[i];
-                if (column < 0) {
-                    it->ptrs[i] = NULL;
-                    continue;
-                }
-
-                ecs_size_t size = it->sizes[i];
-                if (!size) {
-                    it->ptrs[i] = NULL;
-                    continue;
-                }
-
-                it->ptrs[i] = ecs_vec_get(&data->columns[column].data,
-                    it->sizes[i], offset);
-            }
-        }
-
-        it->frame_offset += it->table ? ecs_table_count(it->table) : 0;
-        it->table = table;
-        it->entities = ecs_vec_get_t(&data->entities, ecs_entity_t, offset);
-    } else {
-        flecs_iter_populate_data(
-            it->real_world, it, table, offset, count, it->ptrs);
-    }
-}
-
-int ecs_query_populate(
-    ecs_iter_t *it,
-    bool when_changed)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
-        ECS_INVALID_PARAMETER, NULL);
-
-    ecs_query_iter_t *iter = &it->priv.iter.query;
-    ecs_query_t *query = iter->query;
-    ecs_query_table_match_t *match = iter->prev;
-    ecs_assert(match != NULL, ECS_INVALID_OPERATION, NULL);
-    if (query->flags & EcsQueryTrivialIter) {
-        flecs_query_populate_trivial(it, match);
-        return EcsIterNextYield;
-    }
-
-    ecs_table_t *table = match->table;
-    ecs_world_t *world = query->filter.world;
-    const ecs_filter_t *filter = &query->filter;
-    ecs_entity_filter_iter_t *ent_it = it->priv.entity_iter;
-    ecs_assert(ent_it != NULL, ECS_INTERNAL_ERROR, NULL);
-    ecs_table_range_t *range = &ent_it->range;
-    int32_t t, term_count = filter->term_count;
-    int result;
-
-repeat:
-    result = EcsIterNextYield;
-
-    ecs_os_memcpy_n(it->sources, match->sources, ecs_entity_t, 
-        filter->field_count);
-
-    for (t = 0; t < term_count; t ++) {
-        ecs_term_t *term = &filter->terms[t];
-        int32_t field = term->field_index;
-        if (!ecs_term_match_this(term)) {
-            continue;
-        }
-
-        it->ids[field] = match->ids[field];
-        it->columns[field] = match->columns[field];
-    }
-
-    if (table) {
-        range->offset = match->offset;
-        range->count = match->count;
-        if (!range->count) {
-            range->count = ecs_table_count(table);
-            ecs_assert(range->count != 0, ECS_INTERNAL_ERROR, NULL);
-        }
-
-        if (match->entity_filter) {
-            ent_it->entity_filter = match->entity_filter;
-            ent_it->columns = match->columns;
-            ent_it->range.table = table;
-            ent_it->it = it;
-            result = flecs_entity_filter_next(ent_it);
-            if (result == EcsIterNext) {
-                goto done;
-            }
-        }
-
-        it->group_id = match->group_id;
-    } else {
-        range->offset = 0;
-        range->count = 0;
-    }
-
-    if (when_changed) {
-        if (!ecs_query_changed(NULL, it)) {
-            if (result == EcsIterYield) {
-                goto repeat;
-            } else {
-                result = EcsIterNext;
-                goto done;
-            }
-        }
-    }
-
-    it->references = ecs_vec_first(&match->refs);
-    it->instance_count = 0;
-
-    flecs_iter_populate_data(world, it, table, range->offset, range->count,
-        it->ptrs);
-
-error:
-done:
-    return result;
-}
-
-bool ecs_query_next(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-
-    if (flecs_iter_next_row(it)) {
-        return true;
-    }
-
-    return flecs_iter_next_instanced(it, ecs_query_next_instanced(it));
-error:
-    return false;
-}
-
-bool ecs_query_next_instanced(
-    ecs_iter_t *it)
-{
-    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-
-    ecs_query_iter_t *iter = &it->priv.iter.query;
-    ecs_query_t *query = iter->query;
-    ecs_flags32_t flags = query->flags;
-
-    ecs_query_table_match_t *prev, *next, *cur = iter->node, *last = iter->last;
-    if ((prev = iter->prev)) {
-        /* Match has been iterated, update monitor for change tracking */
-        if (flags & EcsQueryHasMonitor) {
-            flecs_query_sync_match_monitor(query, prev);
-        }
-        if (flags & EcsQueryHasOutTerms) {
-            flecs_query_mark_columns_dirty(query, prev);
-        }
-    }
-
-    flecs_iter_validate(it);
-    iter->skip_count = 0;
-
-    /* Trivial iteration: each entry in the cache is a full match and ids are
-     * only matched on $this or through traversal starting from $this. */
-    if (flags & EcsQueryTrivialIter) {
-        if (cur == last) {
-            goto done;
-        }
-        iter->node = cur->next;
-        iter->prev = cur;
-        flecs_query_populate_trivial(it, cur);
-        return true;
-    }
-
-    /* Non-trivial iteration: query matches with static sources, or matches with
-     * tables that require per-entity filtering. */
-    for (; cur != last; cur = next) {
-        next = cur->next;
-        iter->prev = cur;
-        switch(ecs_query_populate(it, false)) {
-        case EcsIterNext: iter->node = next; continue;
-        case EcsIterYield: next = cur; /* fall through */
-        case EcsIterNextYield: goto yield;
-        default: ecs_abort(ECS_INTERNAL_ERROR, NULL);
-        }
-    }
-
-done: error:
-    query->match_count = query->prev_match_count;
-    ecs_iter_fini(it);
-    return false;
-
-yield:
-    iter->node = next;
-    iter->prev = cur;
-    return true;
-}
-
-bool ecs_query_changed(
-    ecs_query_t *query,
-    const ecs_iter_t *it)
-{
-    if (it) {
-        ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-        ecs_check(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
-            ECS_INVALID_PARAMETER, NULL);
-
-        ecs_query_table_match_t *qm = 
-            (ecs_query_table_match_t*)it->priv.iter.query.prev;
-        ecs_assert(qm != NULL, ECS_INVALID_PARAMETER, NULL);
-
-        if (!query) {
-            query = it->priv.iter.query.query;
-        } else {
-            ecs_check(query == it->priv.iter.query.query, 
-                ECS_INVALID_PARAMETER, NULL);
-        }
-
-        ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
-        ecs_poly_assert(query, ecs_query_t);
-
-        return flecs_query_check_match_monitor(query, qm, it);
-    }
-
-    ecs_poly_assert(query, ecs_query_t);
-    ecs_check(!(query->flags & EcsQueryIsOrphaned), 
-        ECS_INVALID_PARAMETER, NULL);
-
-    flecs_process_pending_tables(query->filter.world);
-
-    if (!(query->flags & EcsQueryHasMonitor)) {
-        query->flags |= EcsQueryHasMonitor;
-        flecs_query_init_query_monitors(query);
-        return true; /* Monitors didn't exist yet */
-    }
-
-    if (query->match_count != query->prev_match_count) {
-        return true;
-    }
-
-    return flecs_query_check_query_monitor(query);
-error:
-    return false;
-}
-
-void ecs_query_skip(
-    ecs_iter_t *it)
-{
-    ecs_assert(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
-    ecs_assert(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
-        ECS_INVALID_PARAMETER, NULL);
-
-    if (it->instance_count > it->count) {
-        it->priv.iter.query.skip_count ++;
-        if (it->priv.iter.query.skip_count == it->instance_count) {
-            /* For non-instanced queries, make sure all entities are skipped */
-            it->priv.iter.query.prev = NULL;
-        }
-    } else {
-        it->priv.iter.query.prev = NULL;
-    }
-}
-
-bool ecs_query_orphaned(
-    const ecs_query_t *query)
-{
-    ecs_poly_assert(query, ecs_query_t);
-    return query->flags & EcsQueryIsOrphaned;
-}
-
-char* ecs_query_str(
-    const ecs_query_t *query)
-{
-    return ecs_filter_str(query->filter.world, &query->filter);
-}
-
-int32_t ecs_query_table_count(
-    const ecs_query_t *query)
-{
-    ecs_run_aperiodic(query->filter.world, EcsAperiodicEmptyTables);
-    return query->cache.tables.count;
-}
-
-int32_t ecs_query_empty_table_count(
-    const ecs_query_t *query)
-{
-    ecs_run_aperiodic(query->filter.world, EcsAperiodicEmptyTables);
-    return query->cache.empty_tables.count;
-}
-
-int32_t ecs_query_entity_count(
-    const ecs_query_t *query)
-{
-    ecs_run_aperiodic(query->filter.world, EcsAperiodicEmptyTables);
-    
-    int32_t result = 0;
-    ecs_table_cache_hdr_t *cur, *last = query->cache.tables.last;
-    if (!last) {
-        return 0;
-    }
-
-    for (cur = query->cache.tables.first; cur != NULL; cur = cur->next) {
-        result += ecs_table_count(cur->table);
-    }
-
-    return result;
-}
-
-void* ecs_query_get_ctx(
-    const ecs_query_t *query)
-{
-    return query->ctx;
-}
-
-void* ecs_query_get_binding_ctx(
-    const ecs_query_t *query)
-{
-    return query->binding_ctx;
-}
diff --git a/src/query/api.c b/src/query/api.c
new file mode 100644
index 000000000..552b0f3d0
--- /dev/null
+++ b/src/query/api.c
@@ -0,0 +1,540 @@
+ /**
+ * @file addons/rules/api.c
+ * @brief User facing API for rules.
+ */
+
+#include "../private_api.h"
+#include <ctype.h>
+
+ecs_mixins_t ecs_query_t_mixins = {
+    .type_name = "ecs_query_t",
+    .elems = {
+        [EcsMixinWorld] = offsetof(ecs_query_impl_t, pub.world),
+        [EcsMixinEntity] = offsetof(ecs_query_impl_t, pub.entity),
+        [EcsMixinDtor] = offsetof(ecs_query_impl_t, dtor)
+    }
+};
+
+int32_t ecs_query_var_count(
+    const ecs_query_t *q)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    return flecs_query_impl(q)->var_pub_count;
+}
+
+int32_t ecs_query_find_var(
+    const ecs_query_t *q,
+    const char *name)
+{
+    flecs_poly_assert(q, ecs_query_t);
+
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    ecs_var_id_t var_id = flecs_query_find_var_id(impl, name, EcsVarEntity);
+    if (var_id == EcsVarNone) {
+        if (q->flags & EcsQueryMatchThis) {
+            if (!ecs_os_strcmp(name, EcsThisName)) {
+                var_id = 0;
+            }
+        }
+        if (var_id == EcsVarNone) {
+            return -1;
+        }
+    }
+    return (int32_t)var_id;
+}
+
+const char* ecs_query_var_name(
+    const ecs_query_t *q,
+    int32_t var_id)
+{
+    flecs_poly_assert(q, ecs_query_t);
+
+    if (var_id) {
+        ecs_assert(var_id < flecs_query_impl(q)->var_count, 
+            ECS_INVALID_PARAMETER, NULL);
+        return flecs_query_impl(q)->vars[var_id].name;
+    } else {
+        return EcsThisName;
+    }
+}
+
+bool ecs_query_var_is_entity(
+    const ecs_query_t *q,
+    int32_t var_id)
+{
+    flecs_poly_assert(q, ecs_query_t);
+
+    return flecs_query_impl(q)->vars[var_id].kind == EcsVarEntity;
+}
+
+static
+int flecs_query_set_caching_policy(
+    ecs_query_impl_t *impl,
+    const ecs_query_desc_t *desc)
+{
+    ecs_query_cache_kind_t kind = desc->cache_kind;
+
+    /* If caching policy is default, try to pick a policy that does the right
+     * thing in most cases. */
+    if (kind == EcsQueryCacheDefault) {
+        if (desc->entity || desc->group_by || desc->group_by_callback || 
+            desc->order_by || desc->order_by_callback)
+        {
+            /* If the query is created with an entity handle (typically 
+             * indicating that the query is named or belongs to a system) the
+             * chance is very high that the query will be reused, so enable
+             * caching. 
+             * Additionally, if the query uses features that require a cache
+             * such as group_by/order_by, also enable caching. */
+            kind = EcsQueryCacheAuto;
+        } else {
+            /* Be conservative in other scenario's, as caching adds significant
+             * overhead to the cost of query creation which doesn't offset the
+             * benefit of faster iteration if it's only used once. */
+            kind = EcsQueryCacheNone;
+        }
+    }
+
+    /* Don't cache query, even if it has cacheable terms */
+    if (kind == EcsQueryCacheNone) {
+        impl->pub.cache_kind = EcsQueryCacheNone;
+        if (desc->group_by || desc->order_by) {
+            ecs_err("cannot create uncached query with group_by/order_by");
+            return -1;
+        }
+        return 0;
+    }
+
+    /* Entire query must be cached */
+    if (desc->cache_kind == EcsQueryCacheAll) {
+        if (impl->pub.flags & EcsQueryIsCacheable) {
+            impl->pub.cache_kind = EcsQueryCacheAll;
+            return 0;
+        } else {
+            ecs_err("cannot enforce QueryCacheAll, "
+                "query contains uncacheable terms");
+            return -1;
+        }
+    }
+
+    /* Only cache terms that are cacheable */
+    if (kind == EcsQueryCacheAuto) {
+        if (impl->pub.flags & EcsQueryIsCacheable) {
+            /* If all terms of the query are cacheable, just set the policy to 
+             * All which simplifies work for the compiler. */
+            impl->pub.cache_kind = EcsQueryCacheAll;
+        } else if (!(impl->pub.flags & EcsQueryHasCacheable)) {
+            /* Same for when the query has no cacheable terms */
+            impl->pub.cache_kind = EcsQueryCacheNone;
+        } else {
+            /* Part of the query is cacheable */
+            impl->pub.cache_kind = EcsQueryCacheAuto;
+        }
+    }
+
+    return 0;
+}
+
+static
+int flecs_query_create_cache(
+    ecs_query_impl_t *impl,
+    ecs_query_desc_t *desc)
+{
+    ecs_query_t *q = &impl->pub;
+    if (flecs_query_set_caching_policy(impl, desc)) {
+        return -1;
+    }
+
+    if ((q->cache_kind != EcsQueryCacheNone) && !q->entity) {
+        /* Cached queries need an entity handle for observer components */
+        q->entity = ecs_new(q->world);
+        desc->entity = q->entity;
+    }
+
+    if (q->cache_kind == EcsQueryCacheAll) {
+        /* Create query cache for all terms */
+        if (!flecs_query_cache_init(impl, desc)) {
+            goto error;
+        }
+    } else if (q->cache_kind == EcsQueryCacheAuto) {
+        /* Query is partially cached */
+        ecs_query_desc_t cache_desc = *desc;
+        ecs_os_memset_n(&cache_desc.terms, 0, ecs_term_t, FLECS_TERM_COUNT_MAX);
+        cache_desc.expr = NULL;
+
+        /* Maps field indices from cache to query */
+        int8_t field_map[FLECS_TERM_COUNT_MAX];
+
+        int32_t i, count = q->term_count, dst_count = 0, dst_field = 0;
+        ecs_term_t *terms = q->terms;
+        for (i = 0; i < count; i ++) {
+            ecs_term_t *term = &terms[i];
+            if (term->flags_ & EcsTermIsCacheable) {
+                cache_desc.terms[dst_count] = *term;
+                field_map[dst_field] = flecs_ito(int8_t, term->field_index);
+                dst_count ++;
+                if (i) {
+                    dst_field += term->field_index != term[-1].field_index;
+                } else {
+                    dst_field ++;
+                }
+            }
+        }
+
+        if (dst_count) {
+            if (!flecs_query_cache_init(impl, &cache_desc)) {
+                goto error;
+            }
+
+            impl->field_map = flecs_alloc_n(&impl->pub.stage->allocator,
+                int8_t, FLECS_TERM_COUNT_MAX);
+
+            ecs_os_memcpy_n(impl->field_map, field_map, int8_t, dst_count);
+        }
+    }
+
+    return 0;
+error:
+    return -1;
+}
+
+static
+void flecs_query_fini(
+    ecs_query_impl_t *impl)
+{
+    ecs_stage_t *stage = impl->pub.stage;
+    ecs_assert(stage != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_allocator_t *a = &stage->allocator;
+
+    if (impl->ctx_free) {
+        impl->ctx_free(impl->pub.ctx);
+    }
+
+    if (impl->binding_ctx_free) {
+        impl->binding_ctx_free(impl->pub.binding_ctx);
+    }
+
+    if (impl->vars != &impl->vars_cache.var) {
+        flecs_free(a, (ECS_SIZEOF(ecs_query_var_t) + ECS_SIZEOF(char*)) * 
+            impl->var_size, impl->vars);
+    }
+
+    flecs_free_n(a, ecs_query_op_t, impl->op_count, impl->ops);
+    flecs_free_n(a, ecs_var_id_t, impl->pub.field_count, impl->src_vars);
+    flecs_free_n(a, int32_t, impl->pub.field_count, impl->monitor);
+    flecs_free_n(a, int8_t, FLECS_TERM_COUNT_MAX, impl->field_map);
+    flecs_name_index_fini(&impl->tvar_index);
+    flecs_name_index_fini(&impl->evar_index);
+
+    ecs_query_t *q = &impl->pub;
+    int i, count = q->term_count;
+    for (i = 0; i < count; i ++) {
+        ecs_term_t *term = &q->terms[i];
+        if (!(term->flags_ & EcsTermKeepAlive)) {
+            continue;
+        }
+
+        ecs_id_record_t *idr = flecs_id_record_get(q->world, term->id);
+        if (idr) {
+            if (!(q->world->flags & EcsWorldQuit)) {
+                if (ecs_os_has_threading()) {
+                    int32_t idr_keep_alive = ecs_os_adec(&idr->keep_alive);
+                    ecs_assert(idr_keep_alive >= 0, ECS_INTERNAL_ERROR, NULL);
+                    (void)idr_keep_alive;
+                } else {
+                    idr->keep_alive --;
+                    ecs_assert(idr->keep_alive >= 0, ECS_INTERNAL_ERROR, NULL);
+                }
+            }
+        }
+    }
+
+    if (impl->tokens) {
+        flecs_free(&q->stage->allocator, impl->tokens_len, impl->tokens);
+    }
+
+    if (impl->cache) {
+        flecs_query_cache_fini(impl);
+    }
+
+    flecs_poly_fini(impl, ecs_query_t);
+    flecs_bfree(&stage->allocators.query_impl, impl);
+}
+
+static
+char* flecs_query_append_token(
+    char *dst,
+    const char *src)
+{
+    int32_t len = ecs_os_strlen(src);
+    ecs_os_memcpy(dst, src, len + 1);
+    return dst + len + 1;
+}
+
+static
+void flecs_query_populate_tokens(
+    ecs_query_impl_t *impl)
+{
+    ecs_query_t *q = &impl->pub;
+    int32_t i, term_count = q->term_count;
+
+    char *old_tokens = impl->tokens;
+    int32_t old_tokens_len = impl->tokens_len;
+    impl->tokens = NULL;
+    impl->tokens_len = 0;
+    
+    /* Step 1: determine size of token buffer */
+    int32_t len = 0;
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &q->terms[i];
+        
+        if (term->first.name) {
+            len += ecs_os_strlen(term->first.name) + 1;
+        }
+        if (term->second.name) {
+            len += ecs_os_strlen(term->second.name) + 1;
+        }
+        if (term->src.name) {
+            len += ecs_os_strlen(term->src.name) + 1;
+        }
+    }
+
+    /* Step 2: reassign term tokens to buffer */
+    if (len) {
+        impl->tokens = flecs_alloc(&q->stage->allocator, len);
+        impl->tokens_len = flecs_ito(int16_t, len);
+        char *token = impl->tokens, *next;
+
+        for (i = 0; i < term_count; i ++) {
+            ecs_term_t *term = &q->terms[i];
+            if (term->first.name) {
+                next = flecs_query_append_token(token, term->first.name);
+                term->first.name = token;
+                token = next;
+            }
+            if (term->second.name) {
+                next = flecs_query_append_token(token, term->second.name);
+                term->second.name = token;
+                token = next;
+            }
+            if (term->src.name) {
+                next = flecs_query_append_token(token, term->src.name);
+                term->src.name = token;
+                token = next;
+            }
+        }
+    }
+
+    if (old_tokens) {
+        flecs_free(&q->stage->allocator, old_tokens_len, old_tokens);
+    }
+}
+
+static
+void flecs_query_add_self_ref(
+    ecs_query_t *q)
+{
+    if (q->entity) {
+        int32_t t, term_count = q->term_count;
+        ecs_term_t *terms = q->terms;
+
+        for (t = 0; t < term_count; t ++) {
+            ecs_term_t *term = &terms[t];
+            if (ECS_TERM_REF_ID(&term->src) == q->entity) {
+                ecs_add_id(q->world, q->entity, term->id);
+            }
+        }
+    }
+}
+
+void ecs_query_fini(
+    ecs_query_t *q)
+{
+    flecs_poly_assert(q, ecs_query_t);
+
+    if (q->entity) {
+        /* If query is associated with entity, use poly dtor path */
+        ecs_delete(q->world, q->entity);
+    } else {
+        flecs_query_fini(flecs_query_impl(q));
+    }
+}
+
+ecs_query_t* ecs_query_init(
+    ecs_world_t *world, 
+    const ecs_query_desc_t *const_desc)
+{
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
+    ecs_query_impl_t *result = flecs_bcalloc(&stage->allocators.query_impl);
+    flecs_poly_init(result, ecs_query_t);
+    
+    ecs_query_desc_t desc = *const_desc;
+    ecs_entity_t entity = const_desc->entity;
+
+    if (entity) {
+        /* Remove existing query if entity has one */
+        ecs_remove_pair(world, entity, ecs_id(EcsPoly), EcsQuery);
+    }
+
+    /* Initialize the query */
+    result->pub.entity = entity;
+    result->pub.world = world;
+    result->pub.stage = stage;
+    if (flecs_query_finalize_query(world, &result->pub, &desc)) {
+        goto error;
+    }
+
+    /* If query terms have itself as source, add term ids to self */
+    flecs_query_add_self_ref(&result->pub);
+
+    /* Store remaining string tokens in terms (after entity lookups) in single
+     * token buffer which simplifies memory management & reduces allocations. */
+    flecs_query_populate_tokens(result);
+
+    /* Initialize static context & mixins */
+    result->pub.stage = stage;
+    result->pub.ctx = const_desc->ctx;
+    result->pub.binding_ctx = const_desc->binding_ctx;
+    result->ctx_free = const_desc->ctx_free;
+    result->binding_ctx_free = const_desc->binding_ctx_free;
+    result->dtor = (flecs_poly_dtor_t)flecs_query_fini;
+    result->cache = NULL;
+
+    /* Initialize query cache if necessary */
+    if (flecs_query_create_cache(result, &desc)) {
+        goto error;
+    }
+
+    /* Compile query to operations */
+    if (flecs_query_compile(world, stage, result)) {
+        goto error;
+    }
+
+    /* Entity could've been set by finalize query if query is cached */
+    entity = result->pub.entity;
+    if (entity) {
+        EcsPoly *poly = flecs_poly_bind(world, entity, ecs_query_t);
+        poly->poly = result;
+        flecs_poly_modified(world, entity, ecs_query_t);
+    }
+
+    return &result->pub;
+error:
+    result->pub.entity = 0;
+    ecs_query_fini(&result->pub);
+    return NULL;
+}
+
+bool ecs_query_has(
+    ecs_query_t *q,
+    ecs_entity_t entity,
+    ecs_iter_t *it)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_check(q->flags & EcsQueryMatchThis, ECS_INVALID_PARAMETER, NULL);
+
+    *it = ecs_query_iter(q->world, q);
+    ecs_iter_set_var(it, 0, entity);
+    return ecs_query_next(it);
+error:
+    return false;
+}
+
+bool ecs_query_has_table(
+    ecs_query_t *q,
+    ecs_table_t *table,
+    ecs_iter_t *it)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_check(q->flags & EcsQueryMatchThis, ECS_INVALID_PARAMETER, NULL);
+
+    *it = ecs_query_iter(q->world, q);
+    ecs_iter_set_var_as_table(it, 0, table);
+    return ecs_query_next(it);
+error:
+    return false;
+}
+
+bool ecs_query_has_range(
+    ecs_query_t *q,
+    ecs_table_range_t *range,
+    ecs_iter_t *it)
+{
+    flecs_poly_assert(q, ecs_query_t);
+
+    if (q->flags & EcsQueryMatchThis) {
+        if (range->table) {
+            if ((range->offset + range->count) > ecs_table_count(range->table)) {
+                return false;
+            }
+        }
+    }
+
+    *it = ecs_query_iter(q->world, q);
+    if (q->flags & EcsQueryMatchThis) {
+        ecs_iter_set_var_as_range(it, 0, range);
+    }
+
+    return ecs_query_next(it);
+}
+
+ecs_query_count_t ecs_query_count(
+    const ecs_query_t *q)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_count_t result = {0};
+
+    if (!(q->flags & EcsQueryMatchThis)) {
+        return result;
+    }
+
+    ecs_run_aperiodic(q->world, EcsAperiodicEmptyTables);
+
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    if (impl->cache && q->flags & EcsQueryIsCacheable) {
+        result.results = flecs_query_cache_table_count(impl->cache);
+        result.entities = flecs_query_cache_entity_count(impl->cache);
+        result.tables = flecs_query_cache_table_count(impl->cache);
+        result.empty_tables = flecs_query_cache_empty_table_count(impl->cache);
+    } else {
+        ecs_iter_t it = flecs_query_iter(q->world, q);
+        it.flags |= EcsIterIsInstanced;
+        it.flags |= EcsIterNoData;
+
+        while (ecs_query_next_instanced(&it)) {
+            result.results ++;
+            result.entities += it.count;
+        }
+    }
+
+    return result;
+}
+
+bool ecs_query_is_true(
+    const ecs_query_t *q)
+{
+    flecs_poly_assert(q, ecs_query_t);
+
+    ecs_run_aperiodic(q->world, EcsAperiodicEmptyTables);
+
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    if (impl->cache && q->flags & EcsQueryIsCacheable) {
+        return flecs_query_cache_table_count(impl->cache) != 0;
+    } else {
+        ecs_iter_t it = flecs_query_iter(q->world, q);
+        return ecs_iter_is_true(&it);
+    }
+}
+
+int32_t ecs_query_match_count(
+    const ecs_query_t *q)
+{
+    flecs_poly_assert(q, ecs_query_t);
+
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    if (!impl->cache) {
+        return 0;
+    } else {
+        return impl->cache->match_count;
+    }
+}
diff --git a/src/query/cache.c b/src/query/cache.c
new file mode 100644
index 000000000..6758312bf
--- /dev/null
+++ b/src/query/cache.c
@@ -0,0 +1,1421 @@
+/**
+ * @file query/cache.c
+ * @brief Cached query implementation.
+ */
+
+#include "../private_api.h"
+
+int32_t flecs_query_cache_table_count(
+    ecs_query_cache_t *cache)
+{
+    ecs_run_aperiodic(cache->query->world, EcsAperiodicEmptyTables);
+    return cache->cache.tables.count;
+}
+
+int32_t flecs_query_cache_empty_table_count(
+    ecs_query_cache_t *cache)
+{
+    ecs_run_aperiodic(cache->query->world, EcsAperiodicEmptyTables);
+    return cache->cache.empty_tables.count;
+}
+
+int32_t flecs_query_cache_entity_count(
+    const ecs_query_cache_t *cache)
+{
+    ecs_run_aperiodic(cache->query->world, EcsAperiodicEmptyTables);
+    
+    int32_t result = 0;
+    ecs_table_cache_hdr_t *cur, *last = cache->cache.tables.last;
+    if (!last) {
+        return 0;
+    }
+
+    for (cur = cache->cache.tables.first; cur != NULL; cur = cur->next) {
+        result += ecs_table_count(cur->table);
+    }
+
+    return result;
+}
+
+static
+uint64_t flecs_query_cache_get_group_id(
+    ecs_query_cache_t *cache,
+    ecs_table_t *table)
+{
+    if (cache->group_by_callback) {
+        return cache->group_by_callback(cache->query->world, table, 
+            cache->group_by, cache->group_by_ctx);
+    } else {
+        return 0;
+    }
+}
+
+static
+void flecs_query_cache_compute_group_id(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
+{
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    if (cache->group_by_callback) {
+        ecs_table_t *table = match->table;
+        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        match->group_id = flecs_query_cache_get_group_id(cache, table);
+    } else {
+        match->group_id = 0;
+    }
+}
+
+static
+ecs_query_cache_table_list_t* flecs_query_cache_get_group(
+    const ecs_query_cache_t *cache,
+    uint64_t group_id)
+{
+    return ecs_map_get_deref(
+        &cache->groups, ecs_query_cache_table_list_t, group_id);
+}
+
+static
+ecs_query_cache_table_list_t* flecs_query_cache_ensure_group(
+    ecs_query_cache_t *cache,
+    uint64_t id)
+{
+    ecs_query_cache_table_list_t *group = ecs_map_get_deref(&cache->groups, 
+        ecs_query_cache_table_list_t, id);
+
+    if (!group) {
+        group = ecs_map_insert_alloc_t(&cache->groups, 
+            ecs_query_cache_table_list_t, id);
+        ecs_os_zeromem(group);
+        if (cache->on_group_create) {
+            group->info.ctx = cache->on_group_create(
+                cache->query->world, id, cache->group_by_ctx);
+        }
+    }
+
+    return group;
+}
+
+static
+void flecs_query_cache_remove_group(
+    ecs_query_cache_t *cache,
+    uint64_t id)
+{
+    if (cache->on_group_delete) {
+        ecs_query_cache_table_list_t *group = ecs_map_get_deref(&cache->groups, 
+            ecs_query_cache_table_list_t, id);
+        if (group) {
+            cache->on_group_delete(cache->query->world, id, 
+                group->info.ctx, cache->group_by_ctx);
+        }
+    }
+
+    ecs_map_remove_free(&cache->groups, id);
+}
+
+static
+uint64_t flecs_query_cache_default_group_by(
+    ecs_world_t *world, 
+    ecs_table_t *table, 
+    ecs_id_t id, 
+    void *ctx) 
+{
+    (void)ctx;
+
+    ecs_id_t match;
+    if (ecs_search(world, table, ecs_pair(id, EcsWildcard), &match) != -1) {
+        return ecs_pair_second(world, match);
+    }
+    return 0;
+}
+
+/* Find the last node of the group after which this group should be inserted */
+static
+ecs_query_cache_table_match_t* flecs_query_cache_find_group_insertion_node(
+    ecs_query_cache_t *cache,
+    uint64_t group_id)
+{
+    /* Grouping must be enabled */
+    ecs_assert(cache->group_by_callback != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_map_iter_t it = ecs_map_iter(&cache->groups);
+    ecs_query_cache_table_list_t *list, *closest_list = NULL;
+    uint64_t id, closest_id = 0;
+    
+    bool desc = false;
+
+    if (cache->cascade_by) {
+        desc = (cache->query->terms[
+            cache->cascade_by - 1].src.id & EcsDesc) != 0;
+    }
+
+    /* Find closest smaller group id */
+    while (ecs_map_next(&it)) {
+        id = ecs_map_key(&it);
+
+        if (!desc) {
+            if (id >= group_id) {
+                continue;
+            }
+        } else {
+            if (id <= group_id) {
+                continue;
+            }
+        }
+
+        list = ecs_map_ptr(&it);
+        if (!list->last) {
+            ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL);
+            continue;
+        }
+
+        bool comp;
+        if (!desc) {
+            comp = ((group_id - id) < (group_id - closest_id));
+        } else {
+            comp = ((group_id - id) > (group_id - closest_id));
+        }
+
+        if (!closest_list || comp) {
+            closest_id = id;
+            closest_list = list;
+        }
+    }
+
+    if (closest_list) {
+        return closest_list->last;
+    } else {
+        return NULL; /* Group should be first in query */
+    }
+}
+
+/* Initialize group with first node */
+static
+void flecs_query_cache_create_group(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
+{
+    uint64_t group_id = match->group_id;
+
+    /* If query has grouping enabled & this is a new/empty group, find
+     * the insertion point for the group */
+    ecs_query_cache_table_match_t *insert_after = 
+        flecs_query_cache_find_group_insertion_node(cache, group_id);
+
+    if (!insert_after) {
+        /* This group should appear first in the query list */
+        ecs_query_cache_table_match_t *query_first = cache->list.first;
+        if (query_first) {
+            /* If this is not the first match for the query, insert before it */
+            match->next = query_first;
+            query_first->prev = match;
+            cache->list.first = match;
+        } else {
+            /* If this is the first match of the query, initialize its list */
+            ecs_assert(cache->list.last == NULL, ECS_INTERNAL_ERROR, NULL);
+            cache->list.first = match;
+            cache->list.last = match;
+        }
+    } else {
+        ecs_assert(cache->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(cache->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        /* This group should appear after another group */
+        ecs_query_cache_table_match_t *insert_before = insert_after->next;
+        match->prev = insert_after;
+        insert_after->next = match;
+        match->next = insert_before;
+        if (insert_before) {
+            insert_before->prev = match;
+        } else {
+            ecs_assert(cache->list.last == insert_after, 
+                ECS_INTERNAL_ERROR, NULL);
+                
+            /* This group should appear last in the query list */
+            cache->list.last = match;
+        }
+    }
+}
+
+/* Find the list the node should be part of */
+static
+ecs_query_cache_table_list_t* flecs_query_cache_get_node_list(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
+{
+    if (cache->group_by_callback) {
+        return flecs_query_cache_get_group(cache, match->group_id);
+    } else {
+        return &cache->list;
+    }
+}
+
+/* Find or create the list the node should be part of */
+static
+ecs_query_cache_table_list_t* flecs_query_cache_ensure_node_list(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
+{
+    if (cache->group_by_callback) {
+        return flecs_query_cache_ensure_group(cache, match->group_id);
+    } else {
+        return &cache->list;
+    }
+}
+
+/* Remove node from list */
+static
+void flecs_query_cache_remove_table_node(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
+{
+    ecs_query_cache_table_match_t *prev = match->prev;
+    ecs_query_cache_table_match_t *next = match->next;
+
+    ecs_assert(prev != match, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(next != match, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(!prev || prev != next, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_query_cache_table_list_t *list = 
+        flecs_query_cache_get_node_list(cache, match);
+
+    if (!list || !list->first) {
+        /* If list contains no matches, the match must be empty */
+        ecs_assert(!list || list->last == NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL);
+        return;
+    }
+
+    ecs_assert(prev != NULL || cache->list.first == match, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(next != NULL || cache->list.last == match, 
+        ECS_INTERNAL_ERROR, NULL);
+
+    if (prev) {
+        prev->next = next;
+    }
+    if (next) {
+        next->prev = prev;
+    }
+
+    ecs_assert(list->info.table_count > 0, ECS_INTERNAL_ERROR, NULL);
+    list->info.table_count --;
+
+    if (cache->group_by_callback) {
+        uint64_t group_id = match->group_id;
+
+        /* Make sure query.list is updated if this is the first or last group */
+        if (cache->list.first == match) {
+            ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL);
+            cache->list.first = next;
+            prev = next;
+        }
+        if (cache->list.last == match) {
+            ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL);
+            cache->list.last = prev;
+            next = prev;
+        }
+
+        ecs_assert(cache->list.info.table_count > 0, ECS_INTERNAL_ERROR, NULL);
+        cache->list.info.table_count --;
+        list->info.match_count ++;
+
+        /* Make sure group list only contains nodes that belong to the group */
+        if (prev && prev->group_id != group_id) {
+            /* The previous node belonged to another group */
+            prev = next;
+        }
+        if (next && next->group_id != group_id) {
+            /* The next node belonged to another group */
+            next = prev;
+        }
+
+        /* Do check again, in case both prev & next belonged to another group */
+        if ((!prev && !next) || (prev && prev->group_id != group_id)) {
+            /* There are no more matches left in this group */
+            flecs_query_cache_remove_group(cache, group_id);
+            list = NULL;
+        }
+    }
+
+    if (list) {
+        if (list->first == match) {
+            list->first = next;
+        }
+        if (list->last == match) {
+            list->last = prev;
+        }
+    }
+
+    match->prev = NULL;
+    match->next = NULL;
+
+    cache->match_count ++;
+}
+
+/* Add node to list */
+static
+void flecs_query_cache_insert_table_node(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *match)
+{
+    /* Node should not be part of an existing list */
+    ecs_assert(match->prev == NULL && match->next == NULL, 
+        ECS_INTERNAL_ERROR, NULL);
+
+    /* If this is the first match, activate system */
+    if (!cache->list.first && cache->entity) {
+        ecs_remove_id(cache->query->world, cache->entity, EcsEmpty);
+    }
+
+    flecs_query_cache_compute_group_id(cache, match);
+
+    ecs_query_cache_table_list_t *list = 
+        flecs_query_cache_ensure_node_list(cache, match);
+    if (list->last) {
+        ecs_assert(cache->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(cache->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        ecs_query_cache_table_match_t *last = list->last;
+        ecs_query_cache_table_match_t *last_next = last->next;
+
+        match->prev = last;
+        match->next = last_next;
+        last->next = match;
+
+        if (last_next) {
+            last_next->prev = match;
+        }
+
+        list->last = match;
+
+        if (cache->group_by_callback) {
+            /* Make sure to update query list if this is the last group */
+            if (cache->list.last == last) {
+                cache->list.last = match;
+            }
+        }
+    } else {
+        ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL);
+
+        list->first = match;
+        list->last = match;
+
+        if (cache->group_by_callback) {
+            /* Initialize group with its first node */
+            flecs_query_cache_create_group(cache, match);
+        }
+    }
+
+    if (cache->group_by_callback) {
+        list->info.table_count ++;
+        list->info.match_count ++;
+    }
+
+    cache->list.info.table_count ++;
+    cache->match_count ++;
+
+    ecs_assert(match->prev != match, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(match->next != match, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(list->last != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(list->last == match, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cache->list.first != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cache->list.last != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cache->list.first->prev == NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cache->list.last->next == NULL, ECS_INTERNAL_ERROR, NULL);
+}
+
+static
+ecs_query_cache_table_match_t* flecs_query_cache_cache_add(
+    ecs_world_t *world,
+    ecs_query_cache_table_t *elem)
+{
+    ecs_query_cache_table_match_t *result = 
+        flecs_bcalloc(&world->allocators.query_table_match);
+
+    if (!elem->first) {
+        elem->first = result;
+        elem->last = result;
+    } else {
+        ecs_assert(elem->last != NULL, ECS_INTERNAL_ERROR, NULL);
+        elem->last->next_match = result;
+        elem->last = result;
+    }
+
+    return result;
+}
+
+/* The group by function for cascade computes the tree depth for the table type.
+ * This causes tables in the query cache to be ordered by depth, which ensures
+ * breadth-first iteration order. */
+static
+uint64_t flecs_query_cache_group_by_cascade(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_id_t id,
+    void *ctx)
+{
+    (void)id;
+    ecs_term_t *term = ctx;
+    ecs_entity_t rel = term->trav;
+    int32_t depth = flecs_relation_depth(world, rel, table);
+    return flecs_ito(uint64_t, depth);
+}
+
+static
+void flecs_query_cache_add_ref(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *qm,
+    ecs_entity_t component,
+    ecs_entity_t entity,
+    ecs_size_t size)
+{
+    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_ref_t *ref = ecs_vec_append_t(&world->allocator, &qm->refs, ecs_ref_t);
+    ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL);
+    
+    if (size) {
+        *ref = ecs_ref_init_id(world, entity, component);
+    } else {
+        *ref = (ecs_ref_t){
+            .entity = entity,
+            .id = 0
+        };
+    }
+
+    impl->pub.flags |= EcsQueryHasRefs;
+}
+
+static
+ecs_query_cache_table_match_t* flecs_query_cache_add_table_match(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_t *qt,
+    ecs_table_t *table)
+{
+    /* Add match for table. One table can have more than one match, if
+     * the query contains wildcards. */
+    ecs_query_cache_table_match_t *qm = flecs_query_cache_cache_add(
+        cache->query->world, qt);
+    qm->table = table;
+
+    qm->columns = flecs_balloc(&cache->allocators.columns);
+    qm->storage_columns = flecs_balloc(&cache->allocators.columns);
+    qm->ids = flecs_balloc(&cache->allocators.ids);
+    qm->sources = flecs_balloc(&cache->allocators.sources);
+
+    /* Insert match to iteration list if table is not empty */
+    if (!table || ecs_table_count(table) != 0) {
+        flecs_query_cache_insert_table_node(cache, qm);
+    }
+
+    return qm;
+}
+
+static
+void flecs_query_cache_set_table_match(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_match_t *qm,
+    ecs_table_t *table,
+    ecs_iter_t *it)
+{
+    ecs_allocator_t *a = &world->allocator;
+    ecs_query_t *query = cache->query;
+    int32_t i, term_count = query->term_count;
+    int32_t field_count = query->field_count;
+    ecs_term_t *terms = query->terms;
+
+    /* Reset resources in case this is an existing record */
+    ecs_vec_reset_t(a, &qm->refs, ecs_ref_t);
+    ecs_os_memcpy_n(qm->columns, it->columns, int32_t, field_count);
+    ecs_os_memcpy_n(qm->ids, it->ids, ecs_id_t, field_count);
+    ecs_os_memcpy_n(qm->sources, it->sources, ecs_entity_t, field_count);
+    qm->set_fields = it->set_fields;
+    qm->up_fields = it->up_fields;
+
+    if (table) {
+        /* Initialize storage columns for faster access to component storage */
+        for (i = 0; i < field_count; i ++) {
+            int32_t column = it->columns[i];
+            if (!ecs_field_is_set(it, i) || terms[i].inout == EcsInOutNone) {
+                qm->storage_columns[i] = -1;
+                continue;
+            }
+
+            ecs_entity_t src = it->sources[i];
+            if (!src) {
+                qm->storage_columns[i] = ecs_table_type_to_column_index(
+                    table, column);
+            } else {
+                /* Shared field (not from table) */
+                qm->storage_columns[i] = -2;
+            }
+        }
+    }
+
+    /* Add references for substituted terms */
+    for (i = 0; i < term_count; i ++) {
+        int32_t field = terms[i].field_index;
+        ecs_entity_t src = it->sources[field];
+        ecs_size_t size = 0;
+        if (it->sizes) {
+            size = it->sizes[field];
+        }
+        if (src) {
+            ecs_id_t id = it->ids[field];
+            ecs_assert(ecs_is_valid(world, src), ECS_INTERNAL_ERROR, NULL);
+
+            if (id) {
+                flecs_query_cache_add_ref(
+                    world, impl, qm, id, src, size);
+
+                /* Use column index to bind term and ref */
+                if (qm->set_fields & (1llu << field)) {
+                    qm->columns[field] = ecs_vec_count(&qm->refs) - 1;
+                }
+            }
+        }
+    }
+}
+
+static
+ecs_query_cache_table_t* flecs_query_cache_table_insert(
+    ecs_world_t *world,
+    ecs_query_cache_t *cache,
+    ecs_table_t *table)
+{
+    ecs_query_cache_table_t *qt = flecs_bcalloc(&world->allocators.query_table);
+    if (table) {
+        qt->table_id = table->id;
+    } else {
+        qt->table_id = 0;
+    }
+    ecs_table_cache_insert(&cache->cache, table, &qt->hdr);
+    return qt;
+}
+
+/** Populate query cache with tables */
+static
+void flecs_query_cache_match_tables(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache)
+{
+    ecs_table_t *table = NULL;
+    ecs_query_cache_table_t *qt = NULL;
+
+    ecs_iter_t it = ecs_query_iter(world, cache->query);
+    ECS_BIT_SET(it.flags, EcsIterIsInstanced);
+    ECS_BIT_SET(it.flags, EcsIterNoData);
+    ECS_BIT_SET(it.flags, EcsIterTableOnly);
+
+    while (ecs_query_next(&it)) {
+        if ((table != it.table) || (!it.table && !qt)) {
+            /* New table matched, add record to cache */
+            table = it.table;
+            qt = flecs_query_cache_table_insert(world, cache, table);
+        }
+
+        ecs_query_cache_table_match_t *qm = 
+            flecs_query_cache_add_table_match(cache, qt, table);
+        flecs_query_cache_set_table_match(world, impl, cache, qm, table, &it);
+    }
+}
+
+static
+bool flecs_query_cache_match_table(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache,
+    ecs_table_t *table)
+{
+    if (!ecs_map_is_init(&cache->cache.index)) {
+        return false;
+    }
+
+    ecs_query_cache_table_t *qt = NULL;
+    ecs_query_t *q = cache->query;
+
+    /* Iterate uncached query for table to check if it matches. If this is a
+     * wildcard query, a table can match multiple times. */
+    ecs_iter_t it = flecs_query_iter(world, q);
+    it.flags |= EcsIterIsInstanced;
+    it.flags |= EcsIterNoData;
+    ecs_iter_set_var_as_table(&it, 0, table);
+
+    while (ecs_query_next(&it)) {
+        ecs_assert(it.table == table, ECS_INTERNAL_ERROR, NULL);
+        if (qt == NULL) {
+            table = it.table;
+            qt = flecs_query_cache_table_insert(world, cache, table);
+        }
+
+        ecs_query_cache_table_match_t *qm = flecs_query_cache_add_table_match(
+            cache, qt, table);
+        flecs_query_cache_set_table_match(world, impl, cache, qm, table, &it);
+    }
+
+    return qt != NULL;
+}
+
+static
+bool flecs_query_cache_has_refs(
+    ecs_query_cache_t *cache)
+{
+    ecs_term_t *terms = cache->query->terms;
+    int32_t i, count = cache->query->term_count;
+    for (i = 0; i < count; i ++) {
+        if (terms[i].src.id & (EcsUp | EcsIsEntity)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static
+void flecs_query_cache_for_each_component_monitor(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache,
+    void(*callback)(
+        ecs_world_t* world,
+        ecs_id_t id,
+        ecs_query_t *q))
+{
+    ecs_query_t *q = &impl->pub;
+    ecs_term_t *terms = cache->query->terms;
+    int32_t i, count = cache->query->term_count;
+
+    for (i = 0; i < count; i++) {
+        ecs_term_t *term = &terms[i];
+        ecs_term_ref_t *src = &term->src;
+
+        if (src->id & EcsUp) {
+            callback(world, ecs_pair(term->trav, EcsWildcard), q);
+            if (term->trav != EcsIsA) {
+                callback(world, ecs_pair(EcsIsA, EcsWildcard), q);
+            }
+            callback(world, term->id, q);
+
+        } else if (src->id & EcsSelf && !ecs_term_match_this(term)) {
+            callback(world, term->id, q);
+        }
+    }
+}
+
+static
+bool flecs_query_cache_is_term_ref_supported(
+    ecs_term_ref_t *ref)
+{
+    if (!(ref->id & EcsIsVariable)) {
+        return true;
+    }
+    if (ecs_id_is_wildcard(ref->id)) {
+        return true;
+    }
+    return false;
+}
+
+static
+int flecs_query_cache_process_signature(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_cache_t *cache)
+{
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_term_t *terms = cache->query->terms;
+    int32_t i, count = cache->query->term_count;
+
+    for (i = 0; i < count; i ++) {
+        ecs_term_t *term = &terms[i];
+        ecs_term_ref_t *first = &term->first;
+        ecs_term_ref_t *src = &term->src;
+        ecs_term_ref_t *second = &term->second;
+
+        bool is_src_ok = flecs_query_cache_is_term_ref_supported(src);
+        bool is_first_ok = flecs_query_cache_is_term_ref_supported(first);
+        bool is_second_ok = flecs_query_cache_is_term_ref_supported(second);
+
+        (void)first;
+        (void)second;
+        (void)is_src_ok;
+        (void)is_first_ok;
+        (void)is_second_ok;
+
+        /* Queries do not support named variables */
+        ecs_check(is_src_ok || ecs_term_match_this(term),
+            ECS_UNSUPPORTED, NULL);
+        ecs_check(is_first_ok, ECS_UNSUPPORTED, NULL);
+        ecs_check(is_second_ok,  ECS_UNSUPPORTED, NULL);
+        ecs_check(term->inout != EcsInOutFilter, ECS_INVALID_PARAMETER,
+            "invalid usage of InOutFilter for query");
+
+        if (src->id & EcsCascade) {
+            ecs_assert(cache->cascade_by == 0, ECS_INVALID_PARAMETER,
+                "query can only have one cascade term");
+            cache->cascade_by = i + 1;
+        }
+    }
+
+    impl->pub.flags |= 
+        (ecs_flags32_t)(flecs_query_cache_has_refs(cache) * EcsQueryHasRefs);
+
+    flecs_query_cache_for_each_component_monitor(
+        world, impl, cache, flecs_monitor_register);
+
+    return 0;
+error:
+    return -1;
+}
+
+/** When a table becomes empty remove it from the query list, or vice versa. */
+static
+void flecs_query_cache_update_table(
+    ecs_query_cache_t *cache,
+    ecs_table_t *table,
+    bool empty)
+{
+    int32_t prev_count = flecs_query_cache_table_count(cache);
+    ecs_table_cache_set_empty(&cache->cache, table, empty);
+    int32_t cur_count = flecs_query_cache_table_count(cache);
+
+    if (prev_count != cur_count) {
+        ecs_query_cache_table_t *qt = ecs_table_cache_get(&cache->cache, table);
+        ecs_assert(qt != NULL, ECS_INTERNAL_ERROR, NULL);
+        ecs_query_cache_table_match_t *cur, *next;
+
+        for (cur = qt->first; cur != NULL; cur = next) {
+            next = cur->next_match;
+
+            if (empty) {
+                ecs_assert(ecs_table_count(table) == 0, 
+                    ECS_INTERNAL_ERROR, NULL);
+
+                flecs_query_cache_remove_table_node(cache, cur);
+            } else {
+                ecs_assert(ecs_table_count(table) != 0, 
+                    ECS_INTERNAL_ERROR, NULL);
+
+                flecs_query_cache_insert_table_node(cache, cur);
+            }
+        }
+    }
+
+    ecs_assert(cur_count || cache->list.first == NULL, 
+        ECS_INTERNAL_ERROR, NULL);
+}
+
+/* Remove table */
+static
+void flecs_query_cache_table_match_free(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_t *elem,
+    ecs_query_cache_table_match_t *first)
+{
+    ecs_query_cache_table_match_t *cur, *next;
+    ecs_world_t *world = cache->query->world;
+
+    for (cur = first; cur != NULL; cur = next) {
+        flecs_bfree(&cache->allocators.columns, cur->columns);
+        flecs_bfree(&cache->allocators.columns, cur->storage_columns);
+        flecs_bfree(&cache->allocators.ids, cur->ids);
+        flecs_bfree(&cache->allocators.sources, cur->sources);
+
+        if (cur->monitor) {
+            flecs_bfree(&cache->allocators.monitors, cur->monitor);
+        }
+        if (!elem->hdr.empty) {
+            flecs_query_cache_remove_table_node(cache, cur);
+        }
+        
+        ecs_vec_fini_t(&world->allocator, &cur->refs, ecs_ref_t);
+
+        next = cur->next_match;
+
+        flecs_bfree(&world->allocators.query_table_match, cur);
+    }
+}
+
+static
+void flecs_query_cache_table_free(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_t *elem)
+{
+    flecs_query_cache_table_match_free(cache, elem, elem->first);
+    flecs_bfree(&cache->query->world->allocators.query_table, elem);
+}
+
+static
+void flecs_query_cache_unmatch_table(
+    ecs_query_cache_t *cache,
+    ecs_table_t *table,
+    ecs_query_cache_table_t *elem)
+{
+    if (!elem) {
+        elem = ecs_table_cache_get(&cache->cache, table);
+    }
+    if (elem) {
+        ecs_table_cache_remove(&cache->cache, elem->table_id, &elem->hdr);
+        flecs_query_cache_table_free(cache, elem);
+    }
+}
+
+/* Rematch system with tables after a change happened to a watched entity */
+static
+void flecs_query_cache_rematch_tables(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl)
+{
+    ecs_iter_t it;
+    ecs_table_t *table = NULL;
+    ecs_query_cache_table_t *qt = NULL;
+    ecs_query_cache_table_match_t *qm = NULL;
+    ecs_query_cache_t *cache = impl->cache;
+
+    if (cache->monitor_generation == world->monitor_generation) {
+        return;
+    }
+
+    cache->monitor_generation = world->monitor_generation;
+
+    it = ecs_query_iter(world, cache->query);
+    ECS_BIT_SET(it.flags, EcsIterIsInstanced);
+    ECS_BIT_SET(it.flags, EcsIterNoData);
+
+    world->info.rematch_count_total ++;
+    int32_t rematch_count = ++ cache->rematch_count;
+
+    ecs_time_t t = {0};
+    if (world->flags & EcsWorldMeasureFrameTime) {
+        ecs_time_measure(&t);
+    }
+
+    while (ecs_query_next(&it)) {
+        if ((table != it.table) || (!it.table && !qt)) {
+            if (qm && qm->next_match) {
+                flecs_query_cache_table_match_free(cache, qt, qm->next_match);
+                qm->next_match = NULL;
+            }
+
+            table = it.table;
+
+            qt = ecs_table_cache_get(&cache->cache, table);
+            if (!qt) {
+                qt = flecs_query_cache_table_insert(world, cache, table);
+            }
+
+            ecs_assert(qt->hdr.table == table, ECS_INTERNAL_ERROR, NULL);
+            qt->rematch_count = rematch_count;
+            qm = NULL;
+        }
+        if (!qm) {
+            qm = qt->first;
+        } else {
+            qm = qm->next_match;
+        }
+        if (!qm) {
+            qm = flecs_query_cache_add_table_match(cache, qt, table);
+        }
+
+        flecs_query_cache_set_table_match(world, impl, cache, qm, table, &it);
+
+        if (table && ecs_table_count(table) && cache->group_by_callback) {
+            if (flecs_query_cache_get_group_id(cache, table) != qm->group_id) {
+                /* Update table group */
+                flecs_query_cache_remove_table_node(cache, qm);
+                flecs_query_cache_insert_table_node(cache, qm);
+            }
+        }
+    }
+
+    if (qm && qm->next_match) {
+        flecs_query_cache_table_match_free(cache, qt, qm->next_match);
+        qm->next_match = NULL;
+    }
+
+    /* Iterate all tables in cache, remove ones that weren't just matched */
+    ecs_table_cache_iter_t cache_it;
+    if (flecs_table_cache_all_iter(&cache->cache, &cache_it)) {
+        while ((qt = flecs_table_cache_next(&cache_it, ecs_query_cache_table_t))) {
+            if (qt->rematch_count != rematch_count) {
+                flecs_query_cache_unmatch_table(cache, qt->hdr.table, qt);
+            }
+        }
+    }
+
+    if (world->flags & EcsWorldMeasureFrameTime) {
+        world->info.rematch_time_total += (ecs_ftime_t)ecs_time_measure(&t);
+    }
+}
+
+/* -- Private API -- */
+
+void flecs_query_cache_notify(
+    ecs_world_t *world,
+    ecs_query_t *q,
+    ecs_query_cache_event_t *event)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    ecs_query_cache_t *cache = impl->cache;
+
+    switch(event->kind) {
+    case EcsQueryTableMatch:
+        /* Creation of new table */
+        flecs_query_cache_match_table(world, impl, cache, event->table);
+        break;
+    case EcsQueryTableUnmatch:
+        /* Deletion of table */
+        flecs_query_cache_unmatch_table(cache, event->table, NULL);
+        break;
+    case EcsQueryTableRematch:
+        /* Rematch tables of query */
+        flecs_query_cache_rematch_tables(world, impl);
+        break;
+    }
+}
+
+static
+int flecs_query_cache_order_by(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_entity_t order_by,
+    ecs_order_by_action_t order_by_callback,
+    ecs_sort_table_action_t action)
+{
+    ecs_check(impl != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_check(cache != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!ecs_id_is_wildcard(order_by), 
+        ECS_INVALID_PARAMETER, NULL);
+
+    /* Find order_by term & make sure it is queried for */
+    const ecs_query_t *query = cache->query;
+    int32_t i, count = query->term_count;
+    int32_t order_by_term = -1;
+
+    if (order_by) {
+        for (i = 0; i < count; i ++) {
+            const ecs_term_t *term = &query->terms[i];
+            
+            /* Only And terms are supported */
+            if (term->id == order_by && term->oper == EcsAnd) {
+                order_by_term = i;
+                break;
+            }
+        }
+
+        if (order_by_term == -1) {
+            char *id_str = ecs_id_str(world, order_by);
+            ecs_err("order_by component '%s' is not queried for", id_str);
+            ecs_os_free(id_str);
+            goto error;
+        }
+    }
+
+    cache->order_by = order_by;
+    cache->order_by_callback = order_by_callback;
+    cache->order_by_term = order_by_term;
+    cache->order_by_table_callback = action;
+
+    ecs_vec_fini_t(NULL, &cache->table_slices, ecs_query_cache_table_match_t);
+    flecs_query_cache_sort_tables(world, impl);
+
+    if (!cache->table_slices.array) {
+        flecs_query_cache_build_sorted_tables(cache);
+    }
+
+    return 0;
+error:
+    return -1;
+}
+
+static
+void flecs_query_cache_group_by(
+    ecs_query_cache_t *cache,
+    ecs_entity_t sort_component,
+    ecs_group_by_action_t group_by)
+{   
+    ecs_check(cache->group_by == 0, ECS_INVALID_OPERATION,
+        "query is already grouped");
+    ecs_check(cache->group_by_callback == 0, ECS_INVALID_OPERATION,
+        "query is already grouped");
+
+    if (!group_by) {
+        /* Builtin function that groups by relationship */
+        group_by = flecs_query_cache_default_group_by;   
+    }
+
+    cache->group_by = sort_component;
+    cache->group_by_callback = group_by;
+
+    ecs_map_init_w_params(&cache->groups, 
+        &cache->query->world->allocators.query_table_list);
+error:
+    return;
+}
+
+static
+void flecs_query_cache_on_event(
+    ecs_iter_t *it)
+{
+    /* Because this is the observer::run callback, checking if this is event is
+     * already handled is not done for us. */
+    ecs_world_t *world = it->world;
+    ecs_observer_t *o = it->ctx;
+    ecs_observer_impl_t *o_impl = flecs_observer_impl(o);
+    if (o_impl->last_event_id) {
+        if (o_impl->last_event_id[0] == world->event_id) {
+            return;
+        }
+        o_impl->last_event_id[0] = world->event_id;
+    }
+
+    ecs_query_impl_t *impl = o->ctx;
+    flecs_poly_assert(impl, ecs_query_t);
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_table_t *table = it->table;
+    ecs_entity_t event = it->event;
+
+    if (event == EcsOnTableCreate) {
+        /* Creation of new table */
+        if (flecs_query_cache_match_table(world, impl, cache, table)) {
+            if (ecs_should_log_3()) {
+                char *table_str = ecs_table_str(world, table);
+                ecs_dbg_3("query cache event: %s for [%s]", 
+                    ecs_get_name(world, event),
+                    table_str);
+                ecs_os_free(table_str);
+            }
+        }
+        return;
+    }
+
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    /* The observer isn't doing the matching because the query can do it more
+     * efficiently by checking the table with the query cache. */
+    if (ecs_table_cache_get(&cache->cache, table) == NULL) {
+        return;
+    }
+
+    if (ecs_should_log_3()) {
+        char *table_str = ecs_table_str(world, table);
+        ecs_dbg_3("query cache event: %s for [%s]", 
+            ecs_get_name(world, event),
+            table_str);
+        ecs_os_free(table_str);
+    }
+
+    if (event == EcsOnTableEmpty) {
+        flecs_query_cache_update_table(cache, table, true);
+    } else
+    if (event == EcsOnTableFill) {
+        flecs_query_cache_update_table(cache, table, false);
+    } else if (event == EcsOnTableDelete) {
+        /* Deletion of table */
+        flecs_query_cache_unmatch_table(cache, table, NULL);
+        return;
+    }
+}
+
+static
+void flecs_query_cache_table_cache_free(
+    ecs_query_cache_t *cache)
+{
+    ecs_table_cache_iter_t it;
+    ecs_query_cache_table_t *qt;
+
+    if (flecs_table_cache_all_iter(&cache->cache, &it)) {
+        while ((qt = flecs_table_cache_next(&it, ecs_query_cache_table_t))) {
+            flecs_query_cache_table_free(cache, qt);
+        }
+    }
+
+    ecs_table_cache_fini(&cache->cache);
+}
+
+static
+void flecs_query_cache_allocators_init(
+    ecs_query_cache_t *cache)
+{
+    int32_t field_count = cache->query->field_count;
+    if (field_count) {
+        flecs_ballocator_init(&cache->allocators.columns, 
+            field_count * ECS_SIZEOF(int32_t));
+        flecs_ballocator_init(&cache->allocators.ids, 
+            field_count * ECS_SIZEOF(ecs_id_t));
+        flecs_ballocator_init(&cache->allocators.sources,
+            field_count * ECS_SIZEOF(ecs_entity_t));
+        flecs_ballocator_init(&cache->allocators.monitors,
+            (1 + field_count) * ECS_SIZEOF(int32_t));
+    }
+}
+
+static
+void flecs_query_cache_allocators_fini(
+    ecs_query_cache_t *cache)
+{
+    int32_t field_count = cache->query->field_count;
+    if (field_count) {
+        flecs_ballocator_fini(&cache->allocators.columns);
+        flecs_ballocator_fini(&cache->allocators.ids);
+        flecs_ballocator_fini(&cache->allocators.sources);
+        flecs_ballocator_fini(&cache->allocators.monitors);
+    }
+}
+
+void flecs_query_cache_fini(
+    ecs_query_impl_t *impl)
+{
+    ecs_world_t *world = impl->pub.world;
+    ecs_stage_t *stage = impl->pub.stage;
+    ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    if (cache->observer) {
+        flecs_observer_fini(cache->observer);
+    }
+
+    ecs_group_delete_action_t on_delete = cache->on_group_delete;
+    if (on_delete) {
+        ecs_map_iter_t it = ecs_map_iter(&cache->groups);
+        while (ecs_map_next(&it)) {
+            ecs_query_cache_table_list_t *group = ecs_map_ptr(&it);
+            uint64_t group_id = ecs_map_key(&it);
+            on_delete(world, group_id, group->info.ctx, cache->group_by_ctx);
+        }
+        cache->on_group_delete = NULL;
+    }
+
+    if (cache->group_by_ctx_free) {
+        if (cache->group_by_ctx) {
+            cache->group_by_ctx_free(cache->group_by_ctx);
+        }
+    }
+
+    flecs_query_cache_for_each_component_monitor(world, impl, cache,
+        flecs_monitor_unregister);
+    flecs_query_cache_table_cache_free(cache);
+
+    ecs_map_fini(&cache->groups);
+
+    ecs_vec_fini_t(NULL, &cache->table_slices, ecs_query_cache_table_match_t);
+    flecs_query_cache_allocators_fini(cache);
+    ecs_query_fini(cache->query);
+
+    flecs_bfree(&stage->allocators.query_cache, cache);
+}
+
+/* -- Public API -- */
+
+ecs_query_cache_t* flecs_query_cache_init(
+    ecs_query_impl_t *impl,
+    const ecs_query_desc_t *const_desc)
+{
+    ecs_world_t *world = impl->pub.world;
+    ecs_stage_t *stage = impl->pub.stage;
+    ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_check(const_desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(const_desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_query_desc_t was not initialized to zero");
+    ecs_check(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, 
+        "cannot create query during world fini");
+
+    /* Create private version of desc to create the uncached query that will
+     * populate the query cache. */
+    ecs_query_desc_t desc = *const_desc;
+    ecs_entity_t entity = desc.entity;
+    desc.cache_kind = EcsQueryCacheNone; /* Don't create caches recursively */
+    desc.group_by_callback = NULL;
+    desc.group_by = 0;
+    desc.order_by_callback = NULL;
+    desc.order_by = 0;
+    desc.entity = 0;
+    
+    /* Don't pass ctx/binding_ctx to uncached query */
+    desc.ctx = NULL;
+    desc.binding_ctx = NULL;
+    desc.ctx_free = NULL;
+    desc.binding_ctx_free = NULL;
+
+    ecs_query_cache_t *result = flecs_bcalloc(&stage->allocators.query_cache);
+    result->entity = entity;
+    impl->cache = result;
+
+    ecs_observer_desc_t observer_desc = { .query = desc };
+
+    desc.flags |= EcsQueryMatchEmptyTables | EcsQueryTableOnly;
+    ecs_query_t *q = result->query = ecs_query_init(world, &desc);
+    if (!q) {
+        goto error;
+    }
+
+    flecs_query_cache_allocators_init(result);
+
+    if (q->term_count) {
+        observer_desc.run = flecs_query_cache_on_event;
+        observer_desc.ctx = impl;
+        observer_desc.events[0] = EcsOnTableEmpty;
+        observer_desc.events[1] = EcsOnTableFill;
+        observer_desc.events[2] = EcsOnTableCreate;
+        observer_desc.events[3] = EcsOnTableDelete;
+        observer_desc.query.flags |= EcsQueryNoData|EcsQueryIsInstanced;
+
+        /* ecs_query_init could have moved away resources from the terms array
+         * in the descriptor, so use the terms array from the query. */
+        ecs_os_memcpy_n(observer_desc.query.terms, q->terms, 
+            ecs_term_t, FLECS_TERM_COUNT_MAX);
+        observer_desc.query.expr = NULL; /* Already parsed */
+
+        result->observer = flecs_observer_init(world, entity, &observer_desc);
+        if (!result->observer) {
+            goto error;
+        }
+    }
+
+    result->prev_match_count = -1;
+
+    if (ecs_should_log_1()) {
+        char *query_expr = ecs_query_str(result->query);
+        ecs_dbg_1("#[green]query#[normal] [%s] created", 
+            query_expr ? query_expr : "");
+        ecs_os_free(query_expr);
+    }
+
+    ecs_log_push_1();
+
+    if (flecs_query_cache_process_signature(world, impl, result)) {
+        goto error;
+    }
+
+    /* Group before matching so we won't have to move tables around later */
+    int32_t cascade_by = result->cascade_by;
+    if (cascade_by) {
+        flecs_query_cache_group_by(result, result->query->terms[cascade_by - 1].id,
+            flecs_query_cache_group_by_cascade);
+        result->group_by_ctx = &result->query->terms[cascade_by - 1];
+    }
+
+    if (const_desc->group_by_callback || const_desc->group_by) {
+        ecs_check(!result->cascade_by, ECS_INVALID_PARAMETER,
+            "cannot mix cascade and group_by");
+        flecs_query_cache_group_by(result, 
+            const_desc->group_by, const_desc->group_by_callback);
+        result->group_by_ctx = const_desc->group_by_ctx;
+        result->on_group_create = const_desc->on_group_create;
+        result->on_group_delete = const_desc->on_group_delete;
+        result->group_by_ctx_free = const_desc->group_by_ctx_free;
+    }
+
+    /* Ensure that while initially populating the query with tables, they are
+     * in the right empty/non-empty list. This ensures the query won't miss
+     * empty/non-empty events for tables that are currently out of sync, but
+     * change back to being in sync before processing pending events. */
+    ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
+    ecs_table_cache_init(world, &result->cache);
+    flecs_query_cache_match_tables(world, impl, result);
+
+    if (const_desc->order_by_callback) {
+        if (flecs_query_cache_order_by(world, impl, 
+            const_desc->order_by, const_desc->order_by_callback,
+            const_desc->order_by_table_callback))
+        {
+            goto error;
+        }
+    }
+
+    if (entity) {
+        if (!flecs_query_cache_table_count(result) && result->query->term_count){
+            ecs_add_id(world, entity, EcsEmpty);
+        }
+    }
+
+    ecs_log_pop_1();
+
+    return result;
+error:
+    return NULL;
+}
+
+ecs_query_cache_table_t* flecs_query_cache_get_table(
+    ecs_query_cache_t *cache,
+    ecs_table_t *table)
+{
+    return ecs_table_cache_get(&cache->cache, table);
+}
+
+void ecs_iter_set_group(
+    ecs_iter_t *it,
+    uint64_t group_id)
+{
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(!(it->flags & EcsIterIsValid), ECS_INVALID_PARAMETER, NULL);
+
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_impl_t *q = flecs_query_impl(qit->query);
+    ecs_check(q != NULL, ECS_INVALID_PARAMETER, NULL);
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_cache_t *cache = q->cache;
+    ecs_check(cache != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    ecs_query_cache_table_list_t *node = flecs_query_cache_get_group(
+        cache, group_id);
+    if (!node) {
+        qit->node = NULL;
+        qit->last = NULL;
+        return;
+    }
+
+    ecs_query_cache_table_match_t *first = node->first;
+    if (first) {
+        qit->node = node->first;
+        qit->last = node->last;
+    } else {
+        qit->node = NULL;
+        qit->last = NULL;
+    }
+    
+error:
+    return;
+}
+
+const ecs_query_group_info_t* ecs_query_get_group_info(
+    const ecs_query_t *query,
+    uint64_t group_id)
+{
+    flecs_poly_assert(query, ecs_query_t);
+    ecs_query_cache_table_list_t *node = flecs_query_cache_get_group(
+        flecs_query_impl(query)->cache, group_id);
+    if (!node) {
+        return NULL;
+    }
+    
+    return &node->info;
+}
+
+void* ecs_query_get_group_ctx(
+    const ecs_query_t *query,
+    uint64_t group_id)
+{
+    flecs_poly_assert(query, ecs_query_t);
+    const ecs_query_group_info_t *info = ecs_query_get_group_info(
+        query, group_id);
+    if (!info) {
+        return NULL;
+    } else {
+        return info->ctx;
+    }
+}
diff --git a/src/query/cache.h b/src/query/cache.h
new file mode 100644
index 000000000..21541197a
--- /dev/null
+++ b/src/query/cache.h
@@ -0,0 +1,44 @@
+ /**
+ * @file query/cache.h
+ * @brief Query cache functions.
+ */
+
+/* Create query cache */
+ecs_query_cache_t* flecs_query_cache_init(
+    ecs_query_impl_t *impl,
+    const ecs_query_desc_t *desc);
+
+/* Destroy query cache */
+void flecs_query_cache_fini(
+    ecs_query_impl_t *impl);
+
+/* Notify query cache of event (separate from query observer) */
+void flecs_query_cache_notify(
+    ecs_world_t *world,
+    ecs_query_t *q,
+    ecs_query_cache_event_t *event);
+
+/* Get cache entry for table */
+ecs_query_cache_table_t* flecs_query_cache_get_table(
+    ecs_query_cache_t *query,
+    ecs_table_t *table);
+
+/* Sort tables (order_by implementation) */
+void flecs_query_cache_sort_tables(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl);
+
+void flecs_query_cache_build_sorted_tables(
+    ecs_query_cache_t *cache);
+
+/* Return number of tables in cache */
+int32_t flecs_query_cache_table_count(
+    ecs_query_cache_t *cache);
+
+/* Return number of empty tables in cache */
+int32_t flecs_query_cache_empty_table_count(
+    ecs_query_cache_t *cache);
+
+/* Return number of entities in cache (requires iterating tables) */
+int32_t flecs_query_cache_entity_count(
+    const ecs_query_cache_t *cache);
diff --git a/src/query/cache_iter.c b/src/query/cache_iter.c
new file mode 100644
index 000000000..4e02da97b
--- /dev/null
+++ b/src/query/cache_iter.c
@@ -0,0 +1,376 @@
+#include "../private_api.h"
+
+static
+ecs_query_cache_table_match_t* flecs_query_next(
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_cache_table_match_t *node = qit->node;
+    ecs_query_cache_table_match_t *prev = qit->prev;
+
+    if (prev != qit->last) {
+        ecs_assert(node != NULL, ECS_INTERNAL_ERROR, NULL);
+        ctx->vars[0].range.table = node->table;
+        it->group_id = node->group_id;
+        it->instance_count = 0;
+        it->references = ecs_vec_first(&node->refs);
+        qit->node = node->next;
+        qit->prev = node;
+        return node;
+    }
+
+    return NULL;
+}
+
+static
+ecs_query_cache_table_match_t* flecs_query_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
+{
+    ecs_iter_t *it = ctx->it;
+    if (first) {
+        ecs_var_t *var = &ctx->vars[0];
+        ecs_table_t *table = var->range.table;
+        ecs_assert(table != NULL, ECS_INVALID_OPERATION, 
+            "the variable set on the iterator is missing a table");
+
+        ecs_query_cache_table_t *qt = flecs_query_cache_get_table(
+            impl->cache, table);
+        if (!qt) {
+            return NULL;
+        }
+
+        ecs_query_iter_t *qit = &it->priv_.iter.query;
+        qit->prev = NULL;
+        qit->node = qt->first;
+        qit->last = qt->last;
+    }
+
+    return flecs_query_next(ctx);
+}
+
+static
+void flecs_query_populate_ptrs(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t offset,
+    ecs_query_cache_table_match_t *node)
+{
+    int32_t i, field_count = it->field_count;
+    ecs_data_t *data = &table->data;
+    for (i = 0; i < field_count; i ++) {
+        ECS_TERMSET_CLEAR(it->shared_fields, 1u << i);
+
+        int32_t storage_column = node->storage_columns[i];
+        ecs_size_t size = it->sizes[i];
+        if (storage_column < 0 || !size) {
+            /* Tag / no data */
+            it->ptrs[i] = NULL;
+            continue;
+        }
+
+        it->ptrs[i] = ecs_vec_get(&data->columns[storage_column].data,
+            it->sizes[i], offset);
+    }
+}
+
+static
+void flecs_query_populate_ptrs_w_field_map(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t offset,
+    ecs_query_cache_table_match_t *node,
+    int8_t *field_map,
+    int32_t field_count)
+{
+    int32_t i;
+    ecs_data_t *data = &table->data;
+    for (i = 0; i < field_count; i ++) {
+        int32_t storage_column = node->storage_columns[i];
+        int8_t field_index = field_map[i];
+        ecs_size_t size = it->sizes[field_index];
+        if (storage_column < 0 || !size) {
+            /* Tag / no data */
+            it->ptrs[field_index] = NULL;
+            continue;
+        }
+
+        it->ptrs[field_index] = ecs_vec_get(&data->columns[storage_column].data,
+            size, offset);
+    }
+}
+
+static
+void flecs_query_populate_ptrs_w_shared(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t offset,
+    ecs_query_cache_table_match_t *node,
+    int8_t *field_map,
+    int8_t field_count)
+{
+    int8_t i;
+
+    for (i = 0; i < field_count; i ++) {
+        int32_t column = node->columns[i];
+        int8_t field_index = i;
+        if (field_map) {
+            field_index = field_map[i];
+        }
+
+        ecs_size_t size = it->sizes[field_index];
+        if (!ecs_field_is_set(it, i) || !size) {
+            /* Tag / no data */
+            it->ptrs[field_index] = NULL;
+            continue;
+        }
+
+        ecs_entity_t src = it->sources[i];
+        if (src != 0) {
+            ecs_ref_t *ref = &it->references[column];
+            if (ref->id) {
+                it->ptrs[field_index] = (void*)ecs_ref_get_id(
+                    it->real_world, ref, ref->id);
+                ECS_TERMSET_SET(it->shared_fields, 1u << i);
+            } else {
+                it->ptrs[field_index] = NULL;
+            }
+        } else {
+            int32_t storage_column = node->storage_columns[i];
+            if (storage_column < 0) {
+                it->ptrs[field_index] = NULL;
+                continue;
+            }
+            ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+            it->ptrs[field_index] = ecs_vec_get(
+                &table->data.columns[storage_column].data, size, offset);
+            ECS_TERMSET_CLEAR(it->shared_fields, 1u << i);
+        }
+    }
+}
+
+/* Populate for query that is partially cached.
+ * This requires a mapping from cached fields to query fields. */
+static
+void flecs_query_cache_data_populate(
+    const ecs_query_impl_t *impl,
+    ecs_iter_t *it,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_cache_table_match_t *node)
+{
+    ecs_table_t *table = node->table;
+    ecs_var_t *var = &ctx->vars[0];
+    int32_t count = var->range.count, offset = var->range.offset;
+
+    if (!count) {
+        count = ecs_table_count(table);
+    }
+
+    /* If NoData flag is set on iterator, don't populate fields */
+    if (ECS_BIT_IS_SET(it->flags, EcsIterNoData) || !count) {
+        return;
+    }
+
+    ecs_query_t *cache_query = impl->cache->query;
+    if (!it->references) {
+        flecs_query_populate_ptrs_w_field_map(
+            it, table, offset, node, impl->field_map, cache_query->field_count);
+    } else {
+        flecs_query_populate_ptrs_w_shared(
+            it, table, offset, node, impl->field_map, cache_query->field_count);
+    }
+}
+
+/* Populate for query that is entirely cached.
+ * Cached fields the same as query fields. */
+static
+void flecs_query_is_cache_data_populate(
+    ecs_iter_t *it,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_cache_table_match_t *node)
+{
+    ecs_table_t *table = node->table;
+    ecs_var_t *var = &ctx->vars[0];
+    int32_t count = var->range.count, offset = var->range.offset;
+
+    if (!count) {
+        count = ecs_table_count(table);
+    }
+
+    /* If NoData flag is set on iterator, don't populate fields */
+    if (ECS_BIT_IS_SET(it->flags, EcsIterNoData) || !count) {
+        return;
+    }
+
+    if (!it->references) {
+        flecs_query_populate_ptrs(it, table, offset, node);
+    } else {
+        flecs_query_populate_ptrs_w_shared(it, table, offset, node, NULL, 
+            flecs_ito(int8_t, it->field_count));
+    }
+}
+
+static
+void flecs_query_cache_init_mapped_fields(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_cache_table_match_t *node)
+{
+    ecs_iter_t *it = ctx->it;
+    ecs_query_cache_t *cache = impl->cache;
+    int32_t i, field_count = cache->query->field_count;
+    int8_t *field_map = impl->field_map;
+
+    for (i = 0; i < field_count; i ++) {
+        int8_t field_index = field_map[i];
+        it->columns[field_index] = node->columns[i];
+        it->ids[field_index] = node->ids[i];
+        it->sources[field_index] = node->sources[i];
+
+        ecs_termset_t bit = (ecs_termset_t)(1u << i);
+        ecs_termset_t field_bit = (ecs_termset_t)(1u << field_index);
+
+        ECS_TERMSET_COND(it->set_fields, field_bit, node->set_fields & bit);
+        ECS_TERMSET_COND(it->up_fields, field_bit, node->up_fields & bit);
+    }
+}
+
+/* Iterate cache for query that's partially cached */
+bool flecs_query_cache_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_cache_table_match_t *node = flecs_query_next(ctx);
+    if (!node) {
+        return false;
+    }
+
+    flecs_query_cache_init_mapped_fields(impl, ctx, node);
+
+    ctx->vars[0].range.count = node->count;
+    ctx->vars[0].range.offset = node->offset;
+    return true;
+}
+
+/* Iterate cache for query that's entirely cached */
+bool flecs_query_is_cache_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx)
+{
+    (void)impl;
+
+    ecs_query_cache_table_match_t *node = flecs_query_next(ctx);
+    if (!node) {
+        return false;
+    }
+
+    ecs_iter_t *it = ctx->it;
+    it->columns = node->columns;
+    it->ids = node->ids;
+    it->sources = node->sources;
+    it->set_fields = node->set_fields;
+    it->up_fields = node->up_fields;
+
+    ctx->vars[0].range.count = node->count;
+    ctx->vars[0].range.offset = node->offset;
+    return true;
+}
+
+/* Iterate cache for query that's partially cached with data */
+bool flecs_query_cache_data_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (!flecs_query_cache_search(impl, ctx)) {
+        return false;
+    }
+
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    flecs_query_cache_data_populate(impl, it, ctx, qit->prev);
+    return true;
+}
+
+/* Iterate cache for query that's entirely cached with data */
+bool flecs_query_is_cache_data_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (!flecs_query_is_cache_search(impl, ctx)) {
+        return false;
+    }
+
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    flecs_query_is_cache_data_populate(it, ctx, qit->prev);
+    return true;
+}
+
+/* Test if query that is entirely cached matches constrained $this */
+bool flecs_query_cache_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
+{
+    ecs_query_cache_table_match_t *node = flecs_query_test(impl, ctx, first);
+    if (!node) {
+        return false;
+    }
+
+    flecs_query_cache_init_mapped_fields(impl, ctx, node);
+
+    return true;
+}
+
+/* Test if query that is entirely cached matches constrained $this */
+bool flecs_query_is_cache_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
+{
+    ecs_query_cache_table_match_t *node = flecs_query_test(impl, ctx, first);
+    if (!node) {
+        return false;
+    }
+
+    ecs_iter_t *it = ctx->it;
+    it->columns = node->columns;
+    it->ids = node->ids;
+    it->sources = node->sources;
+
+    return true;
+}
+
+/* Test if query that is partially cached matches constrained $this */
+bool flecs_query_cache_data_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
+{
+    if (!flecs_query_cache_test(impl, ctx, first)) {
+        return false;
+    }
+
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    flecs_query_cache_data_populate(impl, it, ctx, qit->prev);
+    return true;
+}
+
+/* Test if query that is entirely cached matches constrained $this with data */
+bool flecs_query_is_cache_data_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first)
+{
+    if (!flecs_query_is_cache_test(impl, ctx, first)) {
+        return false;
+    }
+
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    flecs_query_is_cache_data_populate(it, ctx, qit->prev);
+    return true;
+}
diff --git a/src/query/cache_iter.h b/src/query/cache_iter.h
new file mode 100644
index 000000000..fe96740f6
--- /dev/null
+++ b/src/query/cache_iter.h
@@ -0,0 +1,50 @@
+/**
+ * @file query/cache_iter.h
+ * @brief Cache iterator functions.
+ */
+
+#include "types.h"
+
+/* Cache search without data */
+bool flecs_query_cache_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx);
+
+/* Cache search with data */
+bool flecs_query_cache_data_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx);
+
+/* Cache search without data where entire query is cached */
+bool flecs_query_is_cache_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx);
+
+/* Cache search with data where entire query is cached */
+bool flecs_query_is_cache_data_search(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx);
+
+/* Cache test without data */
+bool flecs_query_cache_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first);
+
+/* Cache test without data where entire query is cached */
+bool flecs_query_is_cache_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first);
+
+/* Cache test with data */
+bool flecs_query_cache_data_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first);
+
+/* Cache test with data where entire query is cached */
+bool flecs_query_is_cache_data_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first);
diff --git a/src/query/cache_order_by.c b/src/query/cache_order_by.c
new file mode 100644
index 000000000..14751c24e
--- /dev/null
+++ b/src/query/cache_order_by.c
@@ -0,0 +1,322 @@
+/**
+ * @file query/cache_order_by.c
+ * @brief Order by implementation
+ */
+
+#include "../private_api.h"
+
+ECS_SORT_TABLE_WITH_COMPARE(_, flecs_query_cache_sort_table_generic, order_by, static)
+
+static
+void flecs_query_cache_sort_table(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    int32_t column_index,
+    ecs_order_by_action_t compare,
+    ecs_sort_table_action_t sort)
+{
+    ecs_data_t *data = &table->data;
+    if (!ecs_vec_count(&data->entities)) {
+        /* Nothing to sort */
+        return;
+    }
+
+    int32_t count = flecs_table_data_count(data);
+    if (count < 2) {
+        return;
+    }
+
+    ecs_entity_t *entities = ecs_vec_first(&data->entities);
+
+    void *ptr = NULL;
+    int32_t size = 0;
+    if (column_index != -1) {
+        ecs_column_t *column = &data->columns[column_index];
+        ecs_type_info_t *ti = column->ti;
+        size = ti->size;
+        ptr = ecs_vec_first(&column->data);
+    }
+
+    if (sort) {
+        sort(world, table, entities, ptr, size, 0, count - 1, compare);
+    } else {
+        flecs_query_cache_sort_table_generic(
+            world, table, entities, ptr, size, 0, count - 1, compare);
+    }
+}
+
+/* Helper struct for building sorted table ranges */
+typedef struct sort_helper_t {
+    ecs_query_cache_table_match_t *match;
+    ecs_entity_t *entities;
+    const void *ptr;
+    int32_t row;
+    int32_t elem_size;
+    int32_t count;
+    bool shared;
+} sort_helper_t;
+
+static
+const void* ptr_from_helper(
+    sort_helper_t *helper)
+{
+    ecs_assert(helper->row < helper->count, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(helper->elem_size >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(helper->row >= 0, ECS_INTERNAL_ERROR, NULL);
+    if (helper->shared) {
+        return helper->ptr;
+    } else {
+        return ECS_ELEM(helper->ptr, helper->elem_size, helper->row);
+    }
+}
+
+static
+ecs_entity_t e_from_helper(
+    sort_helper_t *helper)
+{
+    if (helper->row < helper->count) {
+        return helper->entities[helper->row];
+    } else {
+        return 0;
+    }
+}
+
+static
+void flecs_query_cache_build_sorted_table_range(
+    ecs_query_cache_t *cache,
+    ecs_query_cache_table_list_t *list)
+{
+    ecs_world_t *world = cache->query->world;
+    ecs_assert(!(world->flags & EcsWorldMultiThreaded), ECS_UNSUPPORTED,
+        "cannot sort query in multithreaded mode");
+
+    ecs_entity_t id = cache->order_by;
+    ecs_order_by_action_t compare = cache->order_by_callback;
+    int32_t table_count = list->info.table_count;
+    if (!table_count) {
+        return;
+    }
+
+    ecs_vec_init_if_t(&cache->table_slices, ecs_query_cache_table_match_t);
+    int32_t to_sort = 0;
+    int32_t order_by_term = cache->order_by_term;
+
+    sort_helper_t *helper = flecs_alloc_n(
+        &world->allocator, sort_helper_t, table_count);
+    ecs_query_cache_table_match_t *cur, *end = list->last->next;
+    for (cur = list->first; cur != end; cur = cur->next) {
+        ecs_table_t *table = cur->table;
+        ecs_data_t *data = &table->data;
+
+        ecs_assert(ecs_table_count(table) != 0, ECS_INTERNAL_ERROR, NULL);
+
+        if (id) {
+            const ecs_term_t *term = &cache->query->terms[order_by_term];
+            int32_t field = term->field_index;
+            int32_t column = cur->columns[field];
+            ecs_size_t size = cache->query->sizes[field];
+            ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+            ecs_entity_t src = cur->sources[field];
+            if (src == 0) {
+                column = table->column_map[column];
+                ecs_vec_t *vec = &data->columns[column].data;
+                helper[to_sort].ptr = ecs_vec_first(vec);
+                helper[to_sort].elem_size = size;
+                helper[to_sort].shared = false;
+            } else {
+                ecs_record_t *r = flecs_entities_get(world, src);
+                ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL);
+                ecs_assert(r->table != NULL, ECS_INTERNAL_ERROR, NULL);
+
+                if (term->src.id & EcsUp) {
+                    ecs_entity_t base = 0;
+                    ecs_search_relation(world, r->table, 0, id, 
+                        EcsIsA, term->src.id & EcsTraverseFlags, &base, 0, 0);
+                    if (base && base != src) { /* Component could be inherited */
+                        r = flecs_entities_get(world, base);
+                    }
+                }
+
+                helper[to_sort].ptr = ecs_table_get_id(
+                    world, r->table, id, ECS_RECORD_TO_ROW(r->row));
+                helper[to_sort].elem_size = size;
+                helper[to_sort].shared = true;
+            }
+            ecs_assert(helper[to_sort].ptr != NULL, ECS_INTERNAL_ERROR, NULL);
+            ecs_assert(helper[to_sort].elem_size != 0, ECS_INTERNAL_ERROR, NULL);
+        } else {
+            helper[to_sort].ptr = NULL;
+            helper[to_sort].elem_size = 0;
+            helper[to_sort].shared = false;
+        }
+
+        helper[to_sort].match = cur;
+        helper[to_sort].entities = ecs_vec_first(&data->entities);
+        helper[to_sort].row = 0;
+        helper[to_sort].count = ecs_table_count(table);
+        to_sort ++;      
+    }
+
+    ecs_assert(to_sort != 0, ECS_INTERNAL_ERROR, NULL);
+
+    bool proceed;
+    do {
+        int32_t j, min = 0;
+        proceed = true;
+
+        ecs_entity_t e1;
+        while (!(e1 = e_from_helper(&helper[min]))) {
+            min ++;
+            if (min == to_sort) {
+                proceed = false;
+                break;
+            }
+        }
+
+        if (!proceed) {
+            break;
+        }
+
+        for (j = min + 1; j < to_sort; j++) {
+            ecs_entity_t e2 = e_from_helper(&helper[j]);
+            if (!e2) {
+                continue;
+            }
+
+            const void *ptr1 = ptr_from_helper(&helper[min]);
+            const void *ptr2 = ptr_from_helper(&helper[j]);
+
+            if (compare(e1, ptr1, e2, ptr2) > 0) {
+                min = j;
+                e1 = e_from_helper(&helper[min]);
+            }
+        }
+
+        sort_helper_t *cur_helper = &helper[min];
+        if (!cur || cur->columns != cur_helper->match->columns) {
+            cur = ecs_vec_append_t(NULL, &cache->table_slices, 
+                ecs_query_cache_table_match_t);
+            *cur = *(cur_helper->match);
+            cur->offset = cur_helper->row;
+            cur->count = 1;
+        } else {
+            cur->count ++;
+        }
+
+        cur_helper->row ++;
+    } while (proceed);
+
+    /* Iterate through the vector of slices to set the prev/next ptrs. This
+     * can't be done while building the vector, as reallocs may occur */
+    int32_t i, count = ecs_vec_count(&cache->table_slices);    
+    ecs_query_cache_table_match_t *nodes = ecs_vec_first(&cache->table_slices);
+    for (i = 0; i < count; i ++) {
+        nodes[i].prev = &nodes[i - 1];
+        nodes[i].next = &nodes[i + 1];
+    }
+
+    nodes[0].prev = NULL;
+    nodes[i - 1].next = NULL;
+
+    flecs_free_n(&world->allocator, sort_helper_t, table_count, helper);
+}
+
+void flecs_query_cache_build_sorted_tables(
+    ecs_query_cache_t *cache)
+{
+    ecs_vec_clear(&cache->table_slices);
+
+    if (cache->group_by_callback) {
+        /* Populate sorted node list in grouping order */
+        ecs_query_cache_table_match_t *cur = cache->list.first;
+        if (cur) {
+            do {
+                /* Find list for current group */
+                uint64_t group_id = cur->group_id;
+                ecs_query_cache_table_list_t *list = ecs_map_get_deref(
+                    &cache->groups, ecs_query_cache_table_list_t, group_id);
+                ecs_assert(list != NULL, ECS_INTERNAL_ERROR, NULL);
+
+                /* Sort tables in current group */
+                flecs_query_cache_build_sorted_table_range(cache, list);
+
+                /* Find next group to sort */
+                cur = list->last->next;
+            } while (cur);
+        }
+    } else {
+        flecs_query_cache_build_sorted_table_range(cache, &cache->list);
+    }
+}
+
+void flecs_query_cache_sort_tables(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl)
+{
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_order_by_action_t compare = cache->order_by_callback;
+    if (!compare) {
+        return;
+    }
+
+    ecs_sort_table_action_t sort = cache->order_by_table_callback;
+    
+    ecs_entity_t order_by = cache->order_by;
+    int32_t order_by_term = cache->order_by_term;
+
+    /* Iterate over non-empty tables. Don't bother with empty tables as they
+     * have nothing to sort */
+
+    bool tables_sorted = false;
+
+    ecs_id_record_t *idr = flecs_id_record_get(world, order_by);
+    ecs_table_cache_iter_t it;
+    ecs_query_cache_table_t *qt;
+    flecs_table_cache_iter(&cache->cache, &it);
+
+    while ((qt = flecs_table_cache_next(&it, ecs_query_cache_table_t))) {
+        ecs_table_t *table = qt->hdr.table;
+        bool dirty = false;
+
+        if (flecs_query_check_table_monitor(impl, qt, 0)) {
+            tables_sorted = true;
+            dirty = true;
+        }
+
+        int32_t column = -1;
+        if (order_by) {
+            if (flecs_query_check_table_monitor(impl, qt, order_by_term + 1)) {
+                dirty = true;
+            }
+
+            if (dirty) {
+                column = -1;
+
+                const ecs_table_record_t *tr = flecs_id_record_get_table(
+                    idr, table);
+                if (tr) {
+                    column = tr->column;
+                }
+
+                if (column == -1) {
+                    /* Component is shared, no sorting is needed */
+                    dirty = false;
+                }
+            }
+        }
+
+        if (!dirty) {
+            continue;
+        }
+
+        /* Something has changed, sort the table. Prefers using 
+         * flecs_query_cache_sort_table when available */
+        flecs_query_cache_sort_table(world, table, column, compare, sort);
+        tables_sorted = true;
+    }
+
+    if (tables_sorted || cache->match_count != cache->prev_match_count) {
+        flecs_query_cache_build_sorted_tables(cache);
+        cache->match_count ++; /* Increase version if tables changed */
+    }
+}
diff --git a/src/query/change_detection.c b/src/query/change_detection.c
new file mode 100644
index 000000000..cf5aa0a86
--- /dev/null
+++ b/src/query/change_detection.c
@@ -0,0 +1,640 @@
+#include "../private_api.h"
+
+typedef struct {
+    ecs_table_t *table;
+    int32_t column;
+} flecs_table_column_t;
+
+static
+void flecs_query_get_column_for_field(
+    const ecs_query_t *q,
+    ecs_query_cache_table_match_t *match,
+    int32_t field,
+    flecs_table_column_t *out)
+{
+    ecs_assert(field >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(field < q->field_count, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_entity_t src = match->sources[field];
+    ecs_table_t *table = NULL;
+    int32_t column = -1;
+
+    if (!src) {
+        table = match->table;
+        column = match->storage_columns[field];
+        if (column == -2) {
+            /* Shared field */
+            column = -1;
+        }
+    } else {
+        ecs_record_t *r = flecs_entities_get(q->world, src);
+        table = r->table;
+
+        int32_t ref_index = match->columns[field];
+        ecs_ref_t *ref = ecs_vec_get_t(&match->refs, ecs_ref_t, ref_index);
+        if (ref->id != 0) {
+            ecs_ref_update(q->world, ref);
+            column = ref->tr->column;
+        }
+    }
+
+    out->table = table;
+    out->column = column;
+}
+
+/* Get match monitor. Monitors are used to keep track of whether components 
+ * matched by the query in a table have changed. */
+static
+bool flecs_query_get_match_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match)
+{
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (match->monitor) {
+        return false;
+    }
+
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    int32_t *monitor = flecs_balloc(&cache->allocators.monitors);
+    monitor[0] = 0;
+
+    /* Mark terms that don't need to be monitored. This saves time when reading
+     * and/or updating the monitor. */
+    const ecs_query_t *q = cache->query;
+    int32_t i, field = -1, term_count = q->term_count;
+    flecs_table_column_t tc;
+
+    for (i = 0; i < term_count; i ++) {
+        if (field == q->terms[i].field_index) {
+            if (monitor[field + 1] != -1) {
+                continue;
+            }
+        }
+
+        field = q->terms[i].field_index;
+        monitor[field + 1] = -1;
+
+        /* If term isn't read, don't monitor */
+        if (q->terms[i].inout != EcsIn && 
+            q->terms[i].inout != EcsInOut &&
+            q->terms[i].inout != EcsInOutDefault) {
+            continue;
+        }
+
+        /* Don't track fields that aren't set */
+        if (!(match->set_fields & (1llu << field))) {
+            continue;
+        }
+
+        ecs_assert(match->columns != NULL, ECS_INTERNAL_ERROR, NULL);
+        int32_t column = match->columns[field];
+        ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+        (void)column;
+
+        flecs_query_get_column_for_field(q, match, field, &tc);
+        if (tc.column == -1) {
+            continue; /* Don't track terms that aren't stored */
+        }
+
+        monitor[field + 1] = 0;
+    }
+
+    match->monitor = monitor;
+
+    impl->pub.flags |= EcsQueryHasMonitor;
+
+    return true;
+}
+
+/* Get monitor for fixed query terms. Fixed terms are handled separately as they
+ * don't require a query cache, and fixed terms aren't stored in the cache. */
+static
+bool flecs_query_get_fixed_monitor(
+    ecs_query_impl_t *impl,
+    bool check)
+{
+    ecs_query_t *q = &impl->pub;
+    ecs_world_t *world = q->world;
+    ecs_term_t *terms = q->terms;
+    int32_t i, term_count = q->term_count;
+
+    if (!impl->monitor) {
+        impl->monitor = flecs_alloc_n(&impl->pub.stage->allocator, 
+            int32_t, q->field_count);
+        check = false; /* If the monitor is new, initialize it with dirty state */
+    }
+
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
+        int32_t field_index = term->field_index;
+
+        if (!(q->read_fields & (1 << field_index))) {
+            continue; /* If term doesn't read data there's nothing to track */
+        }
+
+        if (!(term->src.id & EcsIsEntity)) {
+            continue; /* Not a term with a fixed source */
+        }
+
+        ecs_entity_t src = ECS_TERM_REF_ID(&term->src);
+        ecs_assert(src != 0, ECS_INTERNAL_ERROR, NULL);
+
+        ecs_record_t *r = flecs_entities_get(world, src);
+        if (!r || !r->table) {
+            continue; /* Entity is empty, nothing to track */
+        }
+
+        ecs_id_record_t *idr = flecs_id_record_get(world, term->id);
+        if (!idr) {
+            continue; /* If id doesn't exist, entity can't have it */
+        }
+
+        ecs_table_record_t *tr = flecs_id_record_get_table(idr, r->table);
+        if (!tr) {
+            continue; /* Entity doesn't have the component */
+        }
+
+        /* Copy/check column dirty state from table */
+        int32_t *dirty_state = flecs_table_get_dirty_state(world, r->table);
+        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+
+        if (!check) {
+            impl->monitor[field_index] = dirty_state[tr->column + 1];
+        } else {
+            if (impl->monitor[field_index] != dirty_state[tr->column + 1]) {
+                return true;
+            }
+        }
+    }
+
+    return !check;
+}
+
+bool flecs_query_update_fixed_monitor(
+    ecs_query_impl_t *impl)
+{
+    return flecs_query_get_fixed_monitor(impl, false);
+}
+
+bool flecs_query_check_fixed_monitor(
+    ecs_query_impl_t *impl)
+{
+    return flecs_query_get_fixed_monitor(impl, true);
+}
+
+
+/* Check if single match term has changed */
+static
+bool flecs_query_check_match_monitor_term(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match,
+    int32_t field)
+{
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    if (flecs_query_get_match_monitor(impl, match)) {
+        return true;
+    }
+
+    int32_t *monitor = match->monitor;
+    int32_t state = monitor[field];
+    if (state == -1) {
+        return false;
+    }
+
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_table_t *table = match->table;
+    if (table) {
+        int32_t *dirty_state = flecs_table_get_dirty_state(
+            cache->query->world, table);
+        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (!field) {
+            return monitor[0] != dirty_state[0];
+        }
+    } else if (!field) {
+        return false;
+    }
+
+    flecs_table_column_t cur;
+    flecs_query_get_column_for_field(
+        &impl->pub, match, field - 1, &cur);
+    ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL);
+
+    return monitor[field] != flecs_table_get_dirty_state(
+        cache->query->world, cur.table)[cur.column + 1];
+}
+
+static
+bool flecs_query_check_cache_monitor(
+    ecs_query_impl_t *impl)
+{
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    /* If the match count changed, tables got matched/unmatched for the
+     * cache, so return that the query has changed. */
+    if (cache->match_count != cache->prev_match_count) {
+        return true;
+    }
+
+    ecs_table_cache_iter_t it;
+    if (flecs_table_cache_iter(&cache->cache, &it)) {
+        ecs_query_cache_table_t *qt;
+        while ((qt = flecs_table_cache_next(&it, ecs_query_cache_table_t))) {
+            if (flecs_query_check_table_monitor(impl, qt, -1)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+static
+void flecs_query_init_query_monitors(
+    ecs_query_impl_t *impl)
+{
+    /* Change monitor for cache */
+    ecs_query_cache_t *cache = impl->cache;
+    if (cache) {
+        ecs_query_cache_table_match_t *cur = cache->list.first;
+
+        /* Ensure each match has a monitor */
+        for (; cur != NULL; cur = cur->next) {
+            ecs_query_cache_table_match_t *match = 
+                (ecs_query_cache_table_match_t*)cur;
+            flecs_query_get_match_monitor(impl, match);
+        }
+    }
+}
+
+static
+bool flecs_query_check_match_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match,
+    const ecs_iter_t *it)
+{
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    if (flecs_query_get_match_monitor(impl, match)) {
+        return true;
+    }
+
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    int32_t *monitor = match->monitor;
+    ecs_table_t *table = match->table;
+    int32_t *dirty_state = NULL;
+    if (table) {
+        dirty_state = flecs_table_get_dirty_state(
+            cache->query->world, table);
+        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+        if (monitor[0] != dirty_state[0]) {
+            return true;
+        }
+    }
+
+    bool is_this = false;
+    const ecs_query_t *query = cache->query;
+    ecs_world_t *world = query->world;
+    int32_t i, j, field_count = query->field_count;
+    int32_t *storage_columns = match->storage_columns;
+    ecs_entity_t *sources = match->sources;
+    int32_t *columns = it ? it->columns : match->columns;
+    ecs_flags64_t set_fields = it ? it->set_fields : match->set_fields;
+    
+    ecs_assert(columns != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_vec_t *refs = &match->refs;
+    for (i = 0; i < field_count; i ++) {
+        int32_t mon = monitor[i + 1];
+        if (mon == -1) {
+            continue;
+        }
+
+        if (!(set_fields & (1llu << i))) {
+            continue;
+        }
+
+        int32_t column = storage_columns[i];
+        ecs_entity_t src = sources[i];
+        if (!src) {
+            if (column >= 0) {
+                /* owned component */
+                ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+                if (mon != dirty_state[column + 1]) {
+                    return true;
+                }
+                continue;
+            } else if (column == -1) {
+                continue; /* owned but not a component */
+            }
+        }
+
+        column = columns[i];
+        ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+
+        /* Find term index from field index, which differ when using || */
+        int32_t term_index = i;
+        if (query->terms[i].field_index != i) {
+            for (j = i; j < query->term_count; j ++) {
+                if (query->terms[j].field_index == i) {
+                    term_index = j;
+                    break;
+                }
+            }
+        }
+
+        is_this = ecs_term_match_this(&query->terms[term_index]);
+
+        /* Flattened fields are encoded by adding field_count to the column
+         * index of the parent component. */
+        ecs_assert(column <= field_count, ECS_INTERNAL_ERROR, NULL);
+
+        if (is_this) {
+            /* Component reached through traversal from this */
+            int32_t ref_index = column;
+            ecs_ref_t *ref = ecs_vec_get_t(refs, ecs_ref_t, ref_index);
+            if (ref->id != 0) {
+                ecs_ref_update(world, ref);
+                ecs_table_record_t *tr = ref->tr;
+                ecs_table_t *src_table = tr->hdr.table;
+                column = tr->index;
+                column = ecs_table_type_to_column_index(src_table, column);
+                int32_t *src_dirty_state = flecs_table_get_dirty_state(
+                    world, src_table);
+                if (mon != src_dirty_state[column + 1]) {
+                    return true;
+                }
+            }
+        } else {
+            /* Component from static source */
+            ecs_entity_t fixed_src = match->sources[i];
+            ecs_table_t *src_table = ecs_get_table(world, fixed_src);
+            ecs_assert(src_table != NULL, ECS_INTERNAL_ERROR, NULL);
+            column = ecs_table_type_to_column_index(src_table, column);
+            int32_t *src_dirty_state = flecs_table_get_dirty_state(
+                world, src_table);
+            if (mon != src_dirty_state[column + 1]) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+/* Check if any term for matched table has changed */
+bool flecs_query_check_table_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_t *table,
+    int32_t field)
+{
+    ecs_query_cache_table_match_t *cur, *end = table->last->next;
+
+    for (cur = table->first; cur != end; cur = cur->next) {
+        ecs_query_cache_table_match_t *match = 
+            (ecs_query_cache_table_match_t*)cur;
+        if (field == -1) {
+            if (flecs_query_check_match_monitor(impl, match, NULL)) {
+                return true;
+            }
+        } else {
+            if (flecs_query_check_match_monitor_term(impl, match, field)) {
+                return true;
+            } 
+        }
+    }
+
+    return false;
+}
+
+void flecs_query_mark_fields_dirty(
+    ecs_query_impl_t *impl,
+    ecs_iter_t *it)
+{
+    ecs_query_t *q = &impl->pub;
+
+    /* Evaluate all writeable non-fixed fields, settable fields */
+    ecs_termset_t write_fields = 
+        (ecs_termset_t)(q->write_fields & ~q->fixed_fields & q->set_fields);
+    if (!write_fields) {
+        return;
+    }
+
+    ecs_world_t *world = q->world;
+    int32_t i, field_count = q->field_count;
+    for (i = 0; i < field_count; i ++) {
+        if (!(write_fields & (1 << i))) {
+            continue; /* If term doesn't write data there's nothing to track */
+        }
+
+        ecs_entity_t src = it->sources[i];
+        ecs_table_t *table;
+        if (!src) {
+            table = it->table;
+        } else {
+            ecs_record_t *r = flecs_entities_get(world, src);
+            if (!r || !(table = r->table)) {
+                continue;
+            }
+
+            if (q->shared_readonly_fields & (1 << i)) {
+                /* Shared fields that aren't marked explicitly as out/inout 
+                 * default to readonly */
+                continue;
+            }
+        }
+
+        int32_t type_index = it->columns[i];
+        ecs_assert(type_index >= 0, ECS_INTERNAL_ERROR, NULL);
+        
+        ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+        int32_t *dirty_state = table->dirty_state;
+        if (!dirty_state) {
+            continue;
+        }
+
+        int32_t column = table->column_map[type_index];
+        dirty_state[column + 1] ++;
+    }
+}
+
+void flecs_query_mark_fixed_fields_dirty(
+    ecs_query_impl_t *impl,
+    ecs_iter_t *it)
+{
+    /* This function marks fields dirty for terms with fixed sources. */
+    ecs_query_t *q = &impl->pub;
+    ecs_termset_t fixed_write_fields = q->write_fields & q->fixed_fields;
+    if (!fixed_write_fields) {
+        return;
+    }
+
+    ecs_world_t *world = q->world;
+    int32_t i, field_count = q->field_count;
+    for (i = 0; i < field_count; i ++) {
+        if (!(fixed_write_fields & (1 << i))) {
+            continue; /* If term doesn't write data there's nothing to track */
+        }
+
+        ecs_entity_t src = it->sources[i];
+        ecs_assert(src != 0, ECS_INTERNAL_ERROR, NULL);
+        ecs_record_t *r = flecs_entities_get(world, src);
+        ecs_table_t *table;
+        if (!r || !(table = r->table)) {
+            /* If the field is optional, it's possible that it didn't match */
+            continue;
+        }
+
+        int32_t *dirty_state = table->dirty_state;
+        if (!dirty_state) {
+            continue;
+        }
+
+        ecs_assert(it->columns[i] >= 0, ECS_INTERNAL_ERROR, NULL);
+        int32_t column = table->column_map[it->columns[i]];
+        dirty_state[column + 1] ++;
+    }
+}
+
+/* Synchronize match monitor with table dirty state */
+void flecs_query_sync_match_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match)
+{
+    ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (!match->monitor) {
+        if (impl->pub.flags & EcsQueryHasMonitor) {
+            flecs_query_get_match_monitor(impl, match);
+        } else {
+            return;
+        }
+    }
+
+    ecs_query_cache_t *cache = impl->cache;
+    ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL);
+    int32_t *monitor = match->monitor;
+    ecs_table_t *table = match->table;
+    if (table) {
+        int32_t *dirty_state = flecs_table_get_dirty_state(
+            cache->query->world, table);
+        ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL);
+        monitor[0] = dirty_state[0]; /* Did table gain/lose entities */
+    }
+
+    ecs_query_t *q = cache->query;
+    {
+        flecs_table_column_t tc;
+        int32_t t, term_count = q->term_count;
+        for (t = 0; t < term_count; t ++) {
+            int32_t field = q->terms[t].field_index;
+            if (monitor[field + 1] == -1) {
+                continue;
+            }
+
+            flecs_query_get_column_for_field(q, match, field, &tc);
+
+            monitor[field + 1] = flecs_table_get_dirty_state(
+                q->world, tc.table)[tc.column + 1];
+        }
+    }
+
+    cache->prev_match_count = cache->match_count;
+}
+
+bool ecs_query_changed(
+    ecs_query_t *q)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+
+    ecs_assert(q->cache_kind != EcsQueryCacheNone, ECS_INVALID_OPERATION, 
+        "change detection is only supported on cached queries");
+
+    /* If query reads terms with fixed sources, check those first as that's 
+     * cheaper than checking entries in the cache. */
+    if (impl->monitor) {
+        if (flecs_query_check_fixed_monitor(impl)) {
+            return true;
+        }
+    }
+
+    /* Check cache for changes. We can't detect changes for terms that are not
+     * cached/cacheable and don't have a fixed source, since that requires 
+     * storing state per result, which doesn't happen for uncached queries. */
+    if (impl->cache) {
+        /* If we're checking the cache, make sure that tables are in the correct
+         * empty/non-empty lists. */
+        flecs_process_pending_tables(q->world);
+
+        if (!(impl->pub.flags & EcsQueryHasMonitor)) {
+            flecs_query_init_query_monitors(impl);
+        }
+
+        /* Check cache entries for changes */
+        return flecs_query_check_cache_monitor(impl);
+    }
+
+    return false;
+}
+
+bool ecs_iter_changed(
+    ecs_iter_t *it)
+{
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_query_next, ECS_UNSUPPORTED, NULL);
+    ecs_check(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
+        ECS_INVALID_PARAMETER, NULL);
+
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_impl_t *impl = flecs_query_impl(qit->query);
+    ecs_query_t *q = &impl->pub;
+
+    /* First check for changes for terms with fixed sources, if query has any */
+    if (q->read_fields & q->fixed_fields) {
+        /* Detecting changes for uncached terms is costly, so only do it once 
+         * per iteration. */
+        if (!(it->flags & EcsIterFixedInChangeComputed)) {
+            it->flags |= EcsIterFixedInChangeComputed;
+            ECS_BIT_COND(it->flags, EcsIterFixedInChanged, 
+                flecs_query_check_fixed_monitor(impl));
+        }
+
+        if (it->flags & EcsIterFixedInChanged) {
+            return true;
+        }
+    }
+
+    /* If query has a cache, check for changes in current matched result */
+    if (impl->cache) {
+        ecs_query_cache_table_match_t *qm = 
+            (ecs_query_cache_table_match_t*)it->priv_.iter.query.prev;
+        ecs_check(qm != NULL, ECS_INVALID_PARAMETER, NULL);
+        return flecs_query_check_match_monitor(impl, qm, it);
+    }
+
+error:
+    return false;
+}
+
+void ecs_iter_skip(
+    ecs_iter_t *it)
+{
+    ecs_assert(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(ECS_BIT_IS_SET(it->flags, EcsIterIsValid), 
+        ECS_INVALID_PARAMETER, NULL);
+
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    if (it->instance_count > it->count) {
+        qit->skip_count ++;
+        if (qit->skip_count == it->instance_count) {
+            /* For non-instanced queries, make sure all entities are skipped */
+            it->flags |= EcsIterSkip;
+        }
+    } else {
+        it->flags |= EcsIterSkip;
+    }
+}
diff --git a/src/query/change_detection.h b/src/query/change_detection.h
new file mode 100644
index 000000000..5b09e633e
--- /dev/null
+++ b/src/query/change_detection.h
@@ -0,0 +1,35 @@
+/**
+ * @file query/change_detection.h
+ * @brief Query change detection functions.
+ */
+
+#include "types.h"
+
+/* Sychronize cache monitor with table dirty state */
+void flecs_query_sync_match_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_match_t *match);
+
+/* Mark iterated out fields dirty */
+void flecs_query_mark_fields_dirty(
+    ecs_query_impl_t *impl,
+    ecs_iter_t *it);
+
+/* Compare cache monitor with table dirty state to detect changes */
+bool flecs_query_check_table_monitor(
+    ecs_query_impl_t *impl,
+    ecs_query_cache_table_t *table,
+    int32_t term);
+
+/* Mark out fields with fixed source dirty */
+void flecs_query_mark_fixed_fields_dirty(
+    ecs_query_impl_t *impl,
+    ecs_iter_t *it);
+
+/* Synchronize fixed source monitor */
+bool flecs_query_update_fixed_monitor(
+    ecs_query_impl_t *impl);
+
+/* Compare fixed source monitor */
+bool flecs_query_check_fixed_monitor(
+    ecs_query_impl_t *impl);
diff --git a/src/query/compiler.c b/src/query/compiler.c
new file mode 100644
index 000000000..4f01cf898
--- /dev/null
+++ b/src/query/compiler.c
@@ -0,0 +1,1145 @@
+/**
+ * @file addons/querys/compile.c
+ * @brief Compile query program from query.
+ */
+
+#include "../private_api.h"
+
+static
+bool flecs_query_var_is_anonymous(
+    const ecs_query_impl_t *query,
+    ecs_var_id_t var_id)
+{
+    ecs_query_var_t *var = &query->vars[var_id];
+    return var->anonymous;
+}
+
+ecs_var_id_t flecs_query_add_var(
+    ecs_query_impl_t *query,
+    const char *name,
+    ecs_vec_t *vars,
+    ecs_var_kind_t kind)
+{
+    const char *dot = NULL;
+    if (name) {
+        dot = strchr(name, '.');
+        if (dot) {
+            kind = EcsVarEntity; /* lookup variables are always entities */
+        }
+    }
+
+    ecs_hashmap_t *var_index = NULL;
+    ecs_var_id_t var_id = EcsVarNone;
+    if (name) {
+        if (kind == EcsVarAny) {
+            var_id = flecs_query_find_var_id(query, name, EcsVarEntity);
+            if (var_id != EcsVarNone) {
+                return var_id;
+            }
+
+            var_id = flecs_query_find_var_id(query, name, EcsVarTable);
+            if (var_id != EcsVarNone) {
+                return var_id;
+            }
+
+            kind = EcsVarTable;
+        } else {
+            var_id = flecs_query_find_var_id(query, name, kind);
+            if (var_id != EcsVarNone) {
+                return var_id;
+            }
+        }
+
+        if (kind == EcsVarTable) {
+            var_index = &query->tvar_index;
+        } else {
+            var_index = &query->evar_index;
+        }
+
+        /* If we're creating an entity var, check if it has a table variant */
+        if (kind == EcsVarEntity && var_id == EcsVarNone) {
+            var_id = flecs_query_find_var_id(query, name, EcsVarTable);
+        }
+    }
+
+    ecs_query_var_t *var;
+    ecs_var_id_t result;
+    if (vars) {
+        var = ecs_vec_append_t(NULL, vars, ecs_query_var_t);
+        result = var->id = flecs_itovar(ecs_vec_count(vars));
+    } else {
+        ecs_dbg_assert(query->var_count < query->var_size, 
+            ECS_INTERNAL_ERROR, NULL);
+        var = &query->vars[query->var_count];
+        result = var->id = flecs_itovar(query->var_count);
+        query->var_count ++;
+    }
+
+    var->kind = flecs_ito(int8_t, kind);
+    var->name = name;
+    var->table_id = var_id;
+    var->base_id = 0;
+    var->lookup = NULL;
+    flecs_set_var_label(var, NULL);
+
+    if (name) {
+        flecs_name_index_init_if(var_index, NULL);
+        flecs_name_index_ensure(var_index, var->id, name, 0, 0);
+        var->anonymous = name[0] == '_';
+
+        /* Handle variables that require a by-name lookup, e.g. $this.wheel */
+        if (dot != NULL) {
+            ecs_assert(var->table_id == EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+            var->lookup = dot + 1;
+        }
+    }
+
+    return result;
+}
+
+static
+ecs_var_id_t flecs_query_add_var_for_term_id(
+    ecs_query_impl_t *query,
+    ecs_term_ref_t *term_id,
+    ecs_vec_t *vars,
+    ecs_var_kind_t kind)
+{
+    const char *name = flecs_term_ref_var_name(term_id);
+    if (!name) {
+        return EcsVarNone;
+    }
+
+    return flecs_query_add_var(query, name, vars, kind);
+}
+
+/* This function walks over terms to discover which variables are used in the
+ * query. It needs to provide the following functionality:
+ * - create table vars for all variables used as source
+ * - create entity vars for all variables not used as source
+ * - create entity vars for all non-$this vars
+ * - create anonymous vars to store the content of wildcards
+ * - create anonymous vars to store result of lookups (for $var.child_name)
+ * - create anonymous vars for resolving component inheritance
+ * - create array that stores the source variable for each field
+ * - ensure table vars for non-$this variables are anonymous
+ * - ensure variables created inside scopes are anonymous
+ * - place anonymous variables after public variables in vars array
+ */
+static
+int flecs_query_discover_vars(
+    ecs_stage_t *stage,
+    ecs_query_impl_t *query)
+{
+    ecs_vec_t *vars = &stage->variables; /* Buffer to reduce allocs */
+    ecs_vec_reset_t(NULL, vars, ecs_query_var_t);
+
+    ecs_term_t *terms = query->pub.terms;
+    int32_t a, i, anonymous_count = 0, count = query->pub.term_count;
+    int32_t anonymous_table_count = 0, scope = 0, scoped_var_index = 0;
+    bool table_this = false, entity_before_table_this = false;
+
+    /* For This table lookups during discovery. This will be overwritten after
+     * discovery with whether the query actually has a This table variable. */
+    query->has_table_this = true;
+
+    for (i = 0; i < count; i ++) {
+        ecs_term_t *term = &terms[i];
+        ecs_term_ref_t *first = &term->first;
+        ecs_term_ref_t *second = &term->second;
+        ecs_term_ref_t *src = &term->src;
+
+        if (ECS_TERM_REF_ID(first) == EcsScopeOpen) {
+            /* Keep track of which variables are first used in scope, so that we
+             * can mark them as anonymous. Terms inside a scope are collapsed 
+             * into a single result, which means that outside of the scope the
+             * value of those variables is undefined. */
+            if (!scope) {
+                scoped_var_index = ecs_vec_count(vars);
+            }
+            scope ++;
+            continue;
+        } else if (ECS_TERM_REF_ID(first) == EcsScopeClose) {
+            if (!--scope) {
+                /* Any new variables declared after entering a scope should be
+                 * marked as anonymous. */
+                int32_t v;
+                for (v = scoped_var_index; v < ecs_vec_count(vars); v ++) {
+                    ecs_vec_get_t(vars, ecs_query_var_t, v)->anonymous = true;
+                }
+            }
+            continue;
+        }
+
+        ecs_var_id_t first_var_id = flecs_query_add_var_for_term_id(
+            query, first, vars, EcsVarEntity);
+        if (first_var_id == EcsVarNone) {
+            /* If first is not a variable, check if we need to insert anonymous
+             * variable for resolving component inheritance */
+            if (term->flags_ & EcsTermIdInherited) {
+                anonymous_count += 2; /* table & entity variable */
+            }
+
+            /* If first is a wildcard, insert anonymous variable */
+            if (flecs_term_ref_is_wildcard(first)) {
+                anonymous_count ++;
+            }
+        }
+
+        if ((src->id & EcsIsVariable) && (ECS_TERM_REF_ID(src) != EcsThis)) {
+            const char *var_name = flecs_term_ref_var_name(src);
+            if (var_name) {
+                ecs_var_id_t var_id = flecs_query_find_var_id(
+                    query, var_name, EcsVarEntity);
+                if (var_id == EcsVarNone || var_id == first_var_id) {
+                    var_id = flecs_query_add_var(
+                        query, var_name, vars, EcsVarEntity);
+                }
+
+                if (var_id != EcsVarNone) {
+                    /* Mark variable as one for which we need to create a table
+                     * variable. Don't create table variable now, so that we can
+                     * store it in the non-public part of the variable array. */
+                    ecs_query_var_t *var = ecs_vec_get_t(
+                        vars, ecs_query_var_t, (int32_t)var_id - 1);
+                    ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL);
+                    if (!var->lookup) {
+                        var->kind = EcsVarAny;
+                        anonymous_table_count ++;
+                    }
+
+                    if (!(term->flags_ & EcsTermNoData)) {
+                        /* Can't have an anonymous variable as source of a term
+                         * that returns a component. We need to return each
+                         * instance of the component, whereas anonymous 
+                         * variables are not guaranteed to be resolved to 
+                         * individual entities. */
+                        if (var->anonymous) {
+                            ecs_err(
+                                "can't use anonymous variable '%s' as source of "
+                                "data term", var->name);
+                            goto error;
+                        }
+                    }
+
+                    /* Track which variable ids are used as field source */
+                    if (!query->src_vars) {
+                        query->src_vars = flecs_calloc_n(&stage->allocator,
+                            ecs_var_id_t, query->pub.field_count);
+                    }
+
+                    query->src_vars[term->field_index] = var_id;
+                }
+            } else {
+                if (flecs_term_ref_is_wildcard(src)) {
+                    anonymous_count ++;
+                }
+            }
+        } else if ((src->id & EcsIsVariable) && (ECS_TERM_REF_ID(src) == EcsThis)) {
+            if (flecs_term_is_builtin_pred(term) && term->oper == EcsOr) {
+                flecs_query_add_var(query, EcsThisName, vars, EcsVarEntity);
+            }
+        }
+
+        if (flecs_query_add_var_for_term_id(
+            query, second, vars, EcsVarEntity) == EcsVarNone)
+        {
+            /* If second is a wildcard, insert anonymous variable */
+            if (flecs_term_ref_is_wildcard(second)) {
+                anonymous_count ++;
+            }
+        }
+
+        if (src->id & EcsIsVariable && second->id & EcsIsVariable) {
+            if (term->flags_ & EcsTermTransitive) {
+                /* Anonymous variable to store temporary id for finding 
+                 * targets for transitive relationship, see compile_term. */
+                anonymous_count ++;
+            }
+        }
+
+        /* If member term, make sure source is available as entity */
+        if (term->flags_ & EcsTermIsMember) {
+            flecs_query_add_var_for_term_id(query, src, vars, EcsVarEntity);
+        }
+
+        /* Track if a This entity variable is used before a potential This table 
+         * variable. If this happens, the query has no This table variable */
+        if (ECS_TERM_REF_ID(src) == EcsThis) {
+            table_this = true;
+        }
+
+        if (ECS_TERM_REF_ID(first) == EcsThis || ECS_TERM_REF_ID(second) == EcsThis) {
+            if (!table_this) {
+                entity_before_table_this = true;
+            }
+        }
+    }
+
+    int32_t var_count = ecs_vec_count(vars);
+    ecs_var_id_t placeholder = EcsVarNone - 1;
+    bool replace_placeholders = false;
+
+    /* Ensure lookup variables have table and/or entity variables */
+    for (i = 0; i < var_count; i ++) {
+        ecs_query_var_t *var = ecs_vec_get_t(vars, ecs_query_var_t, i);
+        if (var->lookup) {
+            char *var_name = ecs_os_strdup(var->name);
+            var_name[var->lookup - var->name - 1] = '\0';
+
+            ecs_var_id_t base_table_id = flecs_query_find_var_id(
+                query, var_name, EcsVarTable);
+            if (base_table_id != EcsVarNone) {
+                var->table_id = base_table_id;
+            } else if (anonymous_table_count) {
+                /* Scan for implicit anonymous table variables that haven't been
+                 * inserted yet (happens after this step). Doing this here vs.
+                 * ensures that anonymous variables are appended at the end of
+                 * the variable array, while also ensuring that variable ids are
+                 * stable (no swapping of table var ids that are in use). */
+                for (a = 0; a < var_count; a ++) {
+                    ecs_query_var_t *avar = ecs_vec_get_t(
+                        vars, ecs_query_var_t, a);
+                    if (avar->kind == EcsVarAny) {
+                        if (!ecs_os_strcmp(avar->name, var_name)) {
+                            base_table_id = (ecs_var_id_t)(a + 1);
+                            break;
+                        }
+                    }
+                }
+                if (base_table_id != EcsVarNone) {
+                    /* Set marker so we can set the new table id afterwards */
+                    var->table_id = placeholder;
+                    replace_placeholders = true;
+                }
+            }
+
+            ecs_var_id_t base_entity_id = flecs_query_find_var_id(
+                query, var_name, EcsVarEntity);
+            if (base_entity_id == EcsVarNone) {
+                /* Get name from table var (must exist). We can't use allocated
+                 * name since variables don't own names. */
+                const char *base_name = NULL;
+                if (base_table_id != EcsVarNone && base_table_id) {
+                    ecs_query_var_t *base_table_var = ecs_vec_get_t(
+                        vars, ecs_query_var_t, (int32_t)base_table_id - 1);
+                    base_name = base_table_var->name;
+                } else {
+                    base_name = EcsThisName;
+                }
+
+                base_entity_id = flecs_query_add_var(
+                    query, base_name, vars, EcsVarEntity);
+                var = ecs_vec_get_t(vars, ecs_query_var_t, i);
+            }
+
+            var->base_id = base_entity_id;
+
+            ecs_os_free(var_name);
+        }
+    }
+    var_count = ecs_vec_count(vars);
+
+    /* Add non-This table variables */
+    if (anonymous_table_count) {
+        anonymous_table_count = 0;
+        for (i = 0; i < var_count; i ++) {
+            ecs_query_var_t *var = ecs_vec_get_t(vars, ecs_query_var_t, i);
+            if (var->kind == EcsVarAny) {
+                var->kind = EcsVarEntity;
+
+                ecs_var_id_t var_id = flecs_query_add_var(
+                    query, var->name, vars, EcsVarTable);
+                ecs_vec_get_t(vars, ecs_query_var_t, i)->table_id = var_id;
+                anonymous_table_count ++;
+            }
+        }
+
+        var_count = ecs_vec_count(vars);
+    }
+
+    /* If any forward references to newly added anonymous tables exist, replace
+     * them with the actual table variable ids. */
+    if (replace_placeholders) {
+        for (i = 0; i < var_count; i ++) {
+            ecs_query_var_t *var = ecs_vec_get_t(vars, ecs_query_var_t, i);
+            if (var->table_id == placeholder) {
+                char *var_name = ecs_os_strdup(var->name);
+                var_name[var->lookup - var->name - 1] = '\0';
+
+                var->table_id = flecs_query_find_var_id(
+                    query, var_name, EcsVarTable);
+                ecs_assert(var->table_id != EcsVarNone, 
+                    ECS_INTERNAL_ERROR, NULL);
+
+                ecs_os_free(var_name);
+            }
+        }
+    }
+
+    /* Always include spot for This variable, even if query doesn't use it */
+    var_count ++;
+
+    ecs_query_var_t *query_vars = &query->vars_cache.var;
+    if ((var_count + anonymous_count) > 1) {
+        query_vars = flecs_alloc(&stage->allocator,
+            (ECS_SIZEOF(ecs_query_var_t) + ECS_SIZEOF(char*)) * 
+                (var_count + anonymous_count));
+    }
+
+    query->vars = query_vars;
+    query->var_count = var_count;
+    query->var_pub_count = var_count;
+    query->has_table_this = !entity_before_table_this;
+    query->var_size = var_count + anonymous_count;
+
+    char **var_names = ECS_ELEM(query_vars, ECS_SIZEOF(ecs_query_var_t), 
+        var_count + anonymous_count);
+    query->var_names = (char**)var_names;
+
+    query_vars[0].kind = EcsVarTable;
+    query_vars[0].name = NULL;
+    flecs_set_var_label(&query_vars[0], NULL);
+    query_vars[0].id = 0;
+    query_vars[0].table_id = EcsVarNone;
+    query_vars[0].lookup = NULL;
+    var_names[0] = ECS_CONST_CAST(char*, query_vars[0].name);
+    query_vars ++;
+    var_names ++;
+    var_count --;
+
+    if (var_count) {
+        ecs_query_var_t *user_vars = ecs_vec_first_t(vars, ecs_query_var_t);
+        ecs_os_memcpy_n(query_vars, user_vars, ecs_query_var_t, var_count);
+        for (i = 0; i < var_count; i ++) {
+            var_names[i] = ECS_CONST_CAST(char*, query_vars[i].name);
+        }
+    }
+
+    /* Hide anonymous table variables from application */
+    query->var_pub_count -= anonymous_table_count;
+
+    /* Sanity check to make sure that the public part of the variable array only
+     * contains entity variables. */
+#ifdef FLECS_DEBUG
+    for (i = 1 /* first element = $this */; i < query->var_pub_count; i ++) {
+        ecs_assert(query->vars[i].kind == EcsVarEntity, ECS_INTERNAL_ERROR, NULL);
+    }
+#endif
+
+    return 0;
+error:
+    return -1;
+}
+
+static
+bool flecs_query_var_is_unknown(
+    ecs_query_impl_t *query,
+    ecs_var_id_t var_id,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_var_t *vars = query->vars;
+    if (ctx->written & (1ull << var_id)) {
+        return false;
+    } else {
+        ecs_var_id_t table_var = vars[var_id].table_id;
+        if (table_var != EcsVarNone) {
+            return flecs_query_var_is_unknown(query, table_var, ctx);
+        }
+    }
+    return true;
+}
+
+/* Returns whether term is unkown. A term is unknown when it has variable 
+ * elements (first, second, src) that are all unknown. */
+static
+bool flecs_query_term_is_unknown(
+    ecs_query_impl_t *query, 
+    ecs_term_t *term, 
+    ecs_query_compile_ctx_t *ctx) 
+{
+    ecs_query_op_t dummy = {0};
+    flecs_query_compile_term_ref(NULL, query, &dummy, &term->first, 
+        &dummy.first, EcsQueryFirst, EcsVarEntity, ctx, false);
+    flecs_query_compile_term_ref(NULL, query, &dummy, &term->second, 
+        &dummy.second, EcsQuerySecond, EcsVarEntity, ctx, false);
+    flecs_query_compile_term_ref(NULL, query, &dummy, &term->src, 
+        &dummy.src, EcsQuerySrc, EcsVarAny, ctx, false);
+
+    bool has_vars = dummy.flags & 
+        ((EcsQueryIsVar << EcsQueryFirst) |
+         (EcsQueryIsVar << EcsQuerySecond) |
+         (EcsQueryIsVar << EcsQuerySrc));
+    if (!has_vars) {
+        /* If term has no variables (typically terms with a static src) there
+         * can't be anything that's unknown. */
+        return false;
+    }
+
+    if (dummy.flags & (EcsQueryIsVar << EcsQueryFirst)) {
+        if (!flecs_query_var_is_unknown(query, dummy.first.var, ctx)) {
+            return false;
+        }
+    }
+    if (dummy.flags & (EcsQueryIsVar << EcsQuerySecond)) {
+        if (!flecs_query_var_is_unknown(query, dummy.second.var, ctx)) {
+            return false;
+        }
+    }
+    if (dummy.flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        if (!flecs_query_var_is_unknown(query, dummy.src.var, ctx)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/* Find the next known term from specified offset. This function is used to find
+ * a term that can be evaluated before a term that is unknown. Evaluating known
+ * before unknown terms can significantly decrease the search space. */
+static
+int32_t flecs_query_term_next_known(
+    ecs_query_impl_t *query, 
+    ecs_query_compile_ctx_t *ctx,
+    int32_t offset,
+    ecs_flags64_t compiled) 
+{
+    ecs_query_t *q = &query->pub;
+    ecs_term_t *terms = q->terms;
+    int32_t i, count = q->term_count;
+
+    for (i = offset; i < count; i ++) {
+        ecs_term_t *term = &terms[i];
+        if (compiled & (1ull << i)) {
+            continue;
+        }
+
+        /* Only evaluate And terms */
+        if (term->oper != EcsAnd || flecs_term_is_or(q, term)){
+            continue;
+        }
+
+        /* Don't reorder terms in scopes */
+        if (term->flags_ & EcsTermIsScope) {
+            continue;
+        }
+
+        if (flecs_query_term_is_unknown(query, term, ctx)) {
+            continue;
+        }
+
+        return i;
+    }
+
+    return -1;
+}
+
+/* If the first part of a query contains more than one trivial term, insert a
+ * special instruction which batch-evaluates multiple terms. */
+static
+void flecs_query_insert_trivial_search(
+    ecs_query_impl_t *query,
+    ecs_flags64_t *compiled,
+    ecs_flags64_t *populated,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_t *q = &query->pub;
+    ecs_term_t *terms = q->terms;
+    int32_t i, term_count = q->term_count;
+    ecs_flags64_t trivial_set = 0;
+
+    /* Trivial search always ignores prefabs and disabled entities */
+    if (query->pub.flags & (EcsQueryMatchPrefab|EcsQueryMatchDisabled)) {
+        return;
+    }
+
+    /* Find trivial terms, which can be handled in single instruction */
+    int32_t trivial_wildcard_terms = 0;
+    int32_t trivial_data_terms = 0;
+    int32_t trivial_terms = 0;
+    for (i = 0; i < term_count; i ++) {
+        /* Term is already compiled */
+        if (*compiled & (1ull << i)) {
+            continue;
+        }
+
+        ecs_term_t *term = &terms[i];
+        if (!(term->flags_ & EcsTermIsTrivial)) {
+            continue;
+        }
+
+        /* We can only add trivial terms to plan if they no up traversal */
+        if ((term->src.id & EcsTraverseFlags) != EcsSelf) {
+            continue;
+        }
+
+        trivial_set |= (1llu << i);
+
+        if (ecs_id_is_wildcard(term->id)) {
+            trivial_wildcard_terms ++;
+        }
+
+        if (q->data_fields & (1llu << term->field_index)) {
+            trivial_data_terms ++;
+        }
+
+        trivial_terms ++;
+    }
+
+    if (trivial_terms >= 2) {
+        /* Mark terms as compiled & populated */
+        for (i = 0; i < q->term_count; i ++) {
+            if (trivial_set & (1llu << i)) {
+                *compiled |= (1ull << i);
+                *populated |= (1ull << terms[i].field_index);
+            }
+        }
+
+        /* If there's more than 1 trivial term, batch them in trivial search */
+        ecs_query_op_t trivial = {0};
+        if (trivial_wildcard_terms) {
+            trivial.kind = EcsQueryTrivWildcard;
+        } else {
+            if (trivial_data_terms) {
+                trivial.kind = EcsQueryTrivData;
+            }
+            if (!trivial.kind) {
+                trivial.kind = EcsQueryTriv;
+            }
+        }
+
+        /* Store the bitset with trivial terms on the instruction */
+        trivial.src.entity = trivial_set;
+        flecs_query_op_insert(&trivial, ctx);
+    }
+}
+
+static
+void flecs_query_insert_cache_search(
+    ecs_query_impl_t *query,
+    ecs_flags64_t *compiled,
+    ecs_flags64_t *populated,
+    ecs_query_compile_ctx_t *ctx)
+{
+    if (!query->cache) {
+        return;
+    }
+
+    ecs_query_t *q = &query->pub;
+    bool populate = true;
+
+    if (q->cache_kind == EcsQueryCacheAll) {
+        /* If all terms are cacheable, make sure no other terms are compiled */
+        *compiled = 0xFFFFFFFFFFFFFFFF;
+        *populated = 0xFFFFFFFFFFFFFFFF;
+    } else if (q->cache_kind == EcsQueryCacheAuto) {
+        /* The query is partially cacheable */
+        ecs_term_t *terms = q->terms;
+        int32_t i, count = q->term_count;
+
+        for (i = 0; i < count; i ++) {
+            ecs_term_t *term = &terms[i];
+            if (term->flags_ & (EcsTermIsToggle | EcsTermIsMember)) {
+                /* If query returns individual entities, let dedicated populate
+                 * instruction handle populating data fields */
+                populate = false;
+                break;
+            }
+        }
+
+        for (i = 0; i < count; i ++) {
+            ecs_term_t *term = &terms[i];
+            int16_t field = term->field_index;
+            if ((*compiled) & (1ull << i)) {
+                continue;
+            }
+
+            if (!(term->flags_ & EcsTermIsCacheable)) {
+                continue;
+            }
+
+            *compiled |= (1ull << i);
+
+            if (populate) {
+                *populated |= (1ull << field);
+            }
+        }
+    }
+
+    /* Insert the operation for cache traversal */
+    ecs_query_op_t op = {0};
+    if (!populate || (q->flags & EcsQueryNoData)) {
+        if (q->flags & EcsQueryIsCacheable) {
+            op.kind = EcsQueryIsCache;
+        } else {
+            op.kind = EcsQueryCache;
+        }
+    } else {
+        if (q->flags & EcsQueryIsCacheable) {
+            op.kind = EcsQueryIsCacheData;
+        } else {
+            op.kind = EcsQueryCacheData;
+        }
+    }
+
+    flecs_query_write(0, &op.written);
+    flecs_query_write_ctx(0, ctx, false);
+    flecs_query_op_insert(&op, ctx);
+}
+
+static
+bool flecs_term_ref_match_multiple(
+    ecs_term_ref_t *ref)
+{
+    return (ref->id & EcsIsVariable) && (ECS_TERM_REF_ID(ref) != EcsAny);
+}
+
+static
+bool flecs_term_match_multiple(
+    ecs_term_t *term)
+{
+    return flecs_term_ref_match_multiple(&term->first) ||
+        flecs_term_ref_match_multiple(&term->second);
+}
+
+/* Insert instruction to populate data fields. */
+void flecs_query_insert_populate(
+    ecs_query_impl_t *query,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_flags64_t populated)
+{
+    ecs_query_t *q = &query->pub;
+    int32_t i, term_count = q->term_count;
+
+    if (populated && !(q->flags & EcsQueryNoData)) {
+        int32_t populate_count = 0;
+        int32_t self_count = 0;
+
+        /* Figure out which populate instruction to use */
+        for (i = 0; i < term_count; i ++) {
+            ecs_term_t *term = &q->terms[i];
+            int16_t field = term->field_index;
+
+            if (!(populated & (1ull << field))) {
+                /* Only check fields that need to be populated */
+                continue;
+            }
+
+            populate_count ++;
+
+            /* Callee is asking us to populate a term without data */
+            if (ecs_term_match_this(term) && !(term->src.id & EcsUp)) {
+                self_count ++;
+            }
+        }
+
+        ecs_assert(populate_count != 0, ECS_INTERNAL_ERROR, NULL);
+
+        ecs_query_op_kind_t kind = EcsQueryPopulate;
+        if (populate_count == self_count) {
+            kind = EcsQueryPopulateSelf;
+        }
+
+        ecs_query_op_t op = {0};
+        op.kind = flecs_ito(uint8_t, kind);
+        op.src.entity = populated; /* Abuse for bitset w/fields to populate */
+        flecs_query_op_insert(&op, ctx);
+    }
+}
+
+static
+int flecs_query_insert_toggle(
+    ecs_query_impl_t *impl,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_t *q = &impl->pub;
+    int32_t i, j, term_count = q->term_count;
+    ecs_term_t *terms = q->terms;
+    ecs_flags64_t fields_done = 0;
+
+    for (i = 0; i < term_count; i ++) {
+        if (fields_done & (1llu << i)) {
+            continue;
+        }
+
+        ecs_term_t *term = &terms[i];
+        if (term->flags_ & EcsTermIsToggle) {
+            ecs_query_op_t cur = {0};
+            flecs_query_compile_term_ref(NULL, impl, &cur, &term->src, 
+                &cur.src, EcsQuerySrc, EcsVarAny, ctx, false);
+
+            ecs_flags64_t and_toggles = 0;
+            ecs_flags64_t not_toggles = 0;
+            ecs_flags64_t optional_toggles = 0;
+
+            for (j = i; j < term_count; j ++) {
+                if (fields_done & (1llu << j)) {
+                    continue;
+                }
+
+                /* Also includes term[i], so flags get set correctly */
+                term = &terms[j];
+
+                /* If term is not for the same src, skip */
+                ecs_query_op_t next = {0};
+                flecs_query_compile_term_ref(NULL, impl, &next, &term->src,
+                    &next.src, EcsQuerySrc, EcsVarAny, ctx, false);
+                if (next.src.entity != cur.src.entity || 
+                    next.flags != cur.flags) 
+                {
+                    continue;
+                }
+
+                /* Source matches, set flag */
+                if (term->oper == EcsNot) {
+                    not_toggles |= (1llu << j);
+                } else if (term->oper == EcsOptional) {
+                    optional_toggles |= (1llu << j);
+                } else {
+                    and_toggles |= (1llu << j);
+                }
+
+                fields_done |= (1llu << j);
+            }
+
+            if (and_toggles || not_toggles) {
+                ecs_query_op_t op = {0};
+                op.kind = EcsQueryToggle;
+                op.src = cur.src;
+                op.flags = cur.flags;
+
+                if (op.flags & (EcsQueryIsVar << EcsQuerySrc)) {
+                    flecs_query_write(op.src.var, &op.written);
+                }
+
+                /* Encode fields:
+                 * - first.entity is the fields that match enabled bits
+                 * - second.entity is the fields that match disabled bits
+                 */
+                op.first.entity = and_toggles;
+                op.second.entity = not_toggles;
+                flecs_query_op_insert(&op, ctx);
+            }
+
+            /* Insert separate instructions for optional terms. To make sure
+             * entities are returned in batches where fields are never partially 
+             * set or unset, the result must be split up into batches that have 
+             * the exact same toggle masks. Instead of complicating the toggle 
+             * instruction with code to scan for blocks that have the same bits 
+             * set, separate instructions let the query engine backtrack to get 
+             * the right results. */
+            if (optional_toggles) {
+                for (j = i; j < term_count; j ++) {
+                    uint64_t field_bit = 1ull << j;
+                    if (!(optional_toggles & field_bit)) {
+                        continue;
+                    }
+
+                    ecs_query_op_t op = {0};
+                    op.kind = EcsQueryToggleOption;
+                    op.src = cur.src;
+                    op.first.entity = field_bit;
+                    op.flags = cur.flags;
+                    flecs_query_op_insert(&op, ctx);
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static
+int flecs_query_insert_fixed_src_terms(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_flags64_t *compiled,
+    ecs_flags64_t *populated_out,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_t *q = &impl->pub;
+    int32_t i, term_count = q->term_count;
+    ecs_term_t *terms = q->terms;
+    ecs_flags64_t populated = 0;
+
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
+
+        if (term->oper ==  EcsNot) {
+            /* If term has not operator and variables for first/second, we can't
+             * put the term first as this could prevent us from getting back
+             * valid results. For example:
+             *   !$var(e), Tag($var)
+             * 
+             * Here, the first term would evaluate to false (and cause the 
+             * entire query not to match) if 'e' has any components.
+             * 
+             * However, when reordering we get results:
+             *   Tag($var), !$var(e)
+             * 
+             * Now the query returns all entities with Tag, that 'e' does not
+             * have as component. For this reason, queries should never use
+             * unwritten variables in not terms- and we should also not reorder
+             * terms in a way that results in doing this. */
+            if (flecs_term_match_multiple(term)) {
+                continue;
+            }
+        }
+
+        /* Don't reorder terms in scopes */
+        if (term->flags_ & EcsTermIsScope) {
+            continue;
+        }
+
+        if (term->src.id & EcsIsEntity && ECS_TERM_REF_ID(&term->src)) {
+            if (flecs_query_compile_term(world, impl, term, populated_out, ctx)) {
+                return -1;
+            }
+
+            *compiled |= (1llu << i);
+
+            /* If this is a data field, track it. This will let us insert an
+             * instruction specifically for populating data fields of terms with
+             * fixed source (see below). */
+            if (q->data_fields & (1llu << term->field_index)) {
+                populated |= (1llu << term->field_index);
+            }
+        }
+    }
+
+    if (populated) {
+        /* If data fields with a fixed source were evaluated, insert a populate
+         * instruction that just populates those fields. The advantage of doing
+         * this before the rest of the query is evaluated, is that we only 
+         * populate data for static fields once vs. for each returned result of
+         * the query, which would be wasteful since this data doesn't change. */
+        flecs_query_insert_populate(impl, ctx, populated);
+    }
+
+    *populated_out |= populated;
+
+    return 0;
+}
+
+int flecs_query_compile(
+    ecs_world_t *world,
+    ecs_stage_t *stage,
+    ecs_query_impl_t *query)
+{
+    ecs_query_t *q = &query->pub;
+    ecs_term_t *terms = q->terms;
+    ecs_query_compile_ctx_t ctx = {0};
+    ecs_vec_reset_t(NULL, &stage->operations, ecs_query_op_t);
+    ctx.ops = &stage->operations;
+    ctx.cur = ctx.ctrlflow;
+    ctx.cur->lbl_begin = -1;
+    ctx.cur->lbl_begin = -1;
+    ecs_vec_clear(ctx.ops);
+
+    /* Find all variables defined in query */
+    if (flecs_query_discover_vars(stage, query)) {
+        return -1;
+    }
+
+    /* If query contains fixed source terms, insert operation to set sources */
+    int32_t i, term_count = q->term_count;
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
+        if (term->src.id & EcsIsEntity) {
+            ecs_query_op_t set_fixed = {0};
+            set_fixed.kind = EcsQuerySetFixed;
+            flecs_query_op_insert(&set_fixed, &ctx);
+            break;
+        }
+    }
+
+    /* If the query contains terms with fixed ids (no wildcards, variables), 
+     * insert instruction that initializes ecs_iter_t::ids. This allows for the
+     * insertion of simpler instructions later on. 
+     * If the query is entirely cacheable, ids are populated by the cache. */
+    if (q->cache_kind != EcsQueryCacheAll) {
+        for (i = 0; i < term_count; i ++) {
+            ecs_term_t *term = &terms[i];
+            if (flecs_term_is_fixed_id(q, term) || 
+                (term->src.id & EcsIsEntity && 
+                    !(term->src.id & ~EcsTermRefFlags))) 
+            {
+                ecs_query_op_t set_ids = {0};
+                set_ids.kind = EcsQuerySetIds;
+                flecs_query_op_insert(&set_ids, &ctx);
+                break;
+            }
+        }
+    }
+
+    ecs_flags64_t compiled = 0;
+    ecs_flags64_t populated = 0;
+
+    /* Always evaluate terms with fixed source before other terms */
+    flecs_query_insert_fixed_src_terms(
+        world, query, &compiled, &populated, &ctx);
+
+    /* Compile cacheable terms */
+    flecs_query_insert_cache_search(
+        query, &compiled, &populated, &ctx);
+
+    /* Insert trivial term search if query allows for it */
+    flecs_query_insert_trivial_search(
+        query, &compiled, &populated, &ctx);
+
+    /* Compile remaining query terms to instructions */
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
+        int32_t compile = i;
+
+        if (compiled & (1ull << i)) {
+            continue; /* Already compiled */
+        }
+
+        bool can_reorder = true;
+        if (term->oper != EcsAnd || flecs_term_is_or(q, term)){
+            can_reorder = false;
+        }
+
+        /* If variables have been written, but this term has no known variables,
+         * first try to resolve terms that have known variables. This can 
+         * significantly reduce the search space. 
+         * Only perform this optimization after at least one variable has been
+         * written to, as all terms are unknown otherwise. */
+        if (can_reorder && ctx.written && 
+            flecs_query_term_is_unknown(query, term, &ctx)) 
+        {
+            int32_t term_index = flecs_query_term_next_known(
+                query, &ctx, i + 1, compiled);
+            if (term_index != -1) {
+                term = &q->terms[term_index];
+                compile = term_index;
+                i --; /* Repeat current term */
+            }
+        }
+
+        if (flecs_query_compile_term(world, query, term, &populated, &ctx)) {
+            return -1;
+        }
+
+        compiled |= (1ull << compile);
+    }
+
+    ecs_var_id_t this_id = flecs_query_find_var_id(query, "this", EcsVarEntity);
+
+    /* If This variable has been written as entity, insert an operation to 
+     * assign it to it.entities for consistency. */
+    if (this_id != EcsVarNone && (ctx.written & (1ull << this_id))) {
+        ecs_query_op_t set_this = {0};
+        set_this.kind = EcsQuerySetThis;
+        set_this.flags |= (EcsQueryIsVar << EcsQueryFirst);
+        set_this.first.var = this_id;
+        flecs_query_op_insert(&set_this, &ctx);
+    }
+
+    /* Make sure non-This variables are written as entities */
+    if (query->vars) {
+        for (i = 0; i < query->var_count; i ++) {
+            ecs_query_var_t *var = &query->vars[i];
+            if (var->id && var->kind == EcsVarTable && var->name) {
+                ecs_var_id_t var_id = flecs_query_find_var_id(query, var->name,
+                    EcsVarEntity);
+                if (!flecs_query_is_written(var_id, ctx.written)) {
+                    /* Skip anonymous variables */
+                    if (!flecs_query_var_is_anonymous(query, var_id)) {
+                        flecs_query_insert_each(var->id, var_id, &ctx, false);
+                    }
+                }
+            }
+        }
+    }
+
+    /* If query contains non-This variables as term source, build lookup array */
+    if (query->src_vars) {
+        ecs_assert(query->vars != NULL, ECS_INTERNAL_ERROR, NULL);
+        bool only_anonymous = true;
+
+        for (i = 0; i < q->field_count; i ++) {
+            ecs_var_id_t var_id = query->src_vars[i];
+            if (!var_id) {
+                continue;
+            }
+
+            if (!flecs_query_var_is_anonymous(query, var_id)) {
+                only_anonymous = false;
+                break;
+            } else {
+                /* Don't fetch component data for anonymous variables. Because
+                 * not all metadata (such as it.sources) is initialized for
+                 * anonymous variables, and because they may only be available
+                 * as table variables (each is not guaranteed to be inserted for
+                 * anonymous variables) the iterator may not have sufficient
+                 * information to resolve component data. */
+                for (int32_t t = 0; t < q->term_count; t ++) {
+                    ecs_term_t *term = &q->terms[t];
+                    if (term->field_index == i) {
+                        term->inout = EcsInOutNone;
+                    }
+                }
+            }
+        }
+
+        /* Don't insert setvar instruction if all vars are anonymous */
+        if (!only_anonymous) {
+            ecs_query_op_t set_vars = {0};
+            set_vars.kind = EcsQuerySetVars;
+            flecs_query_op_insert(&set_vars, &ctx);
+        }
+
+        for (i = 0; i < q->field_count; i ++) {
+            ecs_var_id_t var_id = query->src_vars[i];
+            if (!var_id) {
+                continue;
+            }
+
+            if (query->vars[var_id].kind == EcsVarTable) {
+                var_id = flecs_query_find_var_id(query, query->vars[var_id].name,
+                    EcsVarEntity);
+
+                /* Variables used as source that aren't This must be entities */
+                ecs_assert(var_id != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+            }
+
+            query->src_vars[i] = var_id;
+        }
+    }
+
+    ecs_assert((term_count - ctx.skipped) >= 0, ECS_INTERNAL_ERROR, NULL);
+
+    /* If query is empty, insert Nothing instruction */
+    if (!(term_count - ctx.skipped)) {
+        ecs_vec_clear(ctx.ops);
+        ecs_query_op_t nothing = {0};
+        nothing.kind = EcsQueryNothing;
+        flecs_query_op_insert(&nothing, &ctx);
+    } else {
+        /* If query contains terms for toggleable components, insert toggle */
+        if (!(q->flags & EcsQueryTableOnly)) {
+            flecs_query_insert_toggle(query, &ctx);
+        }
+
+        /* Insert instruction to populate remaining data fields */
+        ecs_flags64_t remaining = q->data_fields & ~populated;
+        flecs_query_insert_populate(query, &ctx, remaining);
+
+        /* Insert yield. If program reaches this operation, a result was found */
+        ecs_query_op_t yield = {0};
+        yield.kind = EcsQueryYield;
+        flecs_query_op_insert(&yield, &ctx);
+    }
+
+    int32_t op_count = ecs_vec_count(ctx.ops);
+    if (op_count) {
+        query->op_count = op_count;
+        query->ops = flecs_alloc_n(&stage->allocator, ecs_query_op_t, op_count);
+        ecs_query_op_t *query_ops = ecs_vec_first_t(ctx.ops, ecs_query_op_t);
+        ecs_os_memcpy_n(query->ops, query_ops, ecs_query_op_t, op_count);
+    }
+
+    return 0;
+}
diff --git a/src/query/compiler.h b/src/query/compiler.h
new file mode 100644
index 000000000..fa186d9b9
--- /dev/null
+++ b/src/query/compiler.h
@@ -0,0 +1,83 @@
+/**
+ * @file query/compiler.h
+ * @brief Query compiler functions.
+ */
+
+#include "types.h"
+
+/* Compile query to list of operations */
+int flecs_query_compile(
+    ecs_world_t *world,
+    ecs_stage_t *stage,
+    ecs_query_impl_t *query);
+
+/* Compile single term */
+int flecs_query_compile_term(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_term_t *term,
+    ecs_flags64_t *populated,
+    ecs_query_compile_ctx_t *ctx);
+
+/* Compile term ref (first, second or src) */
+void flecs_query_compile_term_ref(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_term_ref_t *term_ref,
+    ecs_query_ref_t *ref,
+    ecs_flags8_t ref_kind,
+    ecs_var_kind_t kind,
+    ecs_query_compile_ctx_t *ctx,
+    bool create_wildcard_vars);
+
+/* Mark variable as written */
+void flecs_query_write(
+    ecs_var_id_t var_id,
+    uint64_t *written);
+
+/* Mark variable as written in compiler context */
+void flecs_query_write_ctx(
+    ecs_var_id_t var_id,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write);
+
+/* Add operation to query plan */
+ecs_query_lbl_t flecs_query_op_insert(
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx);
+
+/* Insert each instruction */
+void flecs_query_insert_each(
+    ecs_var_id_t tvar,
+    ecs_var_id_t evar,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write);
+
+/* Insert instruction that populates field */
+void flecs_query_insert_populate(
+    ecs_query_impl_t *query,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_flags64_t populated);
+
+/* Add discovered variable */
+ecs_var_id_t flecs_query_add_var(
+    ecs_query_impl_t *query,
+    const char *name,
+    ecs_vec_t *vars,
+    ecs_var_kind_t kind);
+
+/* Find variable by name/kind */
+ecs_var_id_t flecs_query_find_var_id(
+    const ecs_query_impl_t *query,
+    const char *name,
+    ecs_var_kind_t kind);
+
+ecs_query_op_t* flecs_query_begin_block(
+    ecs_query_op_kind_t kind,
+    ecs_query_compile_ctx_t *ctx);
+
+void flecs_query_end_block(
+    ecs_query_compile_ctx_t *ctx,
+    bool reset);
+
diff --git a/src/query/compiler_term.c b/src/query/compiler_term.c
new file mode 100644
index 000000000..ebeaf329b
--- /dev/null
+++ b/src/query/compiler_term.c
@@ -0,0 +1,1461 @@
+/**
+ * @file addons/querys/compiler_term.c
+ * @brief Compile query term.
+ */
+
+#include "../private_api.h"
+
+#define FlecsRuleOrMarker ((int16_t)-2) /* Marks instruction in OR chain */
+
+ecs_var_id_t flecs_query_find_var_id(
+    const ecs_query_impl_t *query,
+    const char *name,
+    ecs_var_kind_t kind)
+{
+    ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    if (kind == EcsVarTable) {
+        if (!ecs_os_strcmp(name, EcsThisName)) {
+            if (query->has_table_this) {
+                return 0;
+            } else {
+                return EcsVarNone;
+            }
+        }
+
+        if (!flecs_name_index_is_init(&query->tvar_index)) {
+            return EcsVarNone;
+        }
+
+        uint64_t index = flecs_name_index_find(
+            &query->tvar_index, name, 0, 0);
+        if (index == 0) {
+            return EcsVarNone;
+        }
+        return flecs_utovar(index);
+    }
+
+    if (kind == EcsVarEntity) {
+        if (!flecs_name_index_is_init(&query->evar_index)) {
+            return EcsVarNone;
+        }
+
+        uint64_t index = flecs_name_index_find(
+            &query->evar_index, name, 0, 0);
+        if (index == 0) {
+            return EcsVarNone;
+        }
+        return flecs_utovar(index);
+    }
+
+    ecs_assert(kind == EcsVarAny, ECS_INTERNAL_ERROR, NULL);
+
+    /* If searching for any kind of variable, start with most specific */
+    ecs_var_id_t index = flecs_query_find_var_id(query, name, EcsVarEntity);
+    if (index != EcsVarNone) {
+        return index;
+    }
+
+    return flecs_query_find_var_id(query, name, EcsVarTable);
+}
+
+static
+ecs_var_id_t flecs_query_most_specific_var(
+    ecs_query_impl_t *query,
+    const char *name,
+    ecs_var_kind_t kind,
+    ecs_query_compile_ctx_t *ctx)
+{
+    if (kind == EcsVarTable || kind == EcsVarEntity) {
+        return flecs_query_find_var_id(query, name, kind);
+    }
+
+    ecs_var_id_t evar = flecs_query_find_var_id(query, name, EcsVarEntity);
+    if ((evar != EcsVarNone) && flecs_query_is_written(evar, ctx->written)) {
+        /* If entity variable is available and written to, it contains the most
+         * specific result and should be used. */
+        return evar;
+    }
+
+    ecs_var_id_t tvar = flecs_query_find_var_id(query, name, EcsVarTable);
+    if ((tvar != EcsVarNone) && !flecs_query_is_written(tvar, ctx->written)) {
+        /* If variable of any kind is requested and variable hasn't been written
+         * yet, write to table variable */
+        return tvar;
+    }
+
+    /* If table var is written, and entity var doesn't exist or is not written,
+     * return table var */
+    if (tvar != EcsVarNone) {
+        return tvar;
+    } else {
+        return evar;
+    }
+}
+
+ecs_query_lbl_t flecs_query_op_insert(
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t *elem = ecs_vec_append_t(NULL, ctx->ops, ecs_query_op_t);
+    int32_t count = ecs_vec_count(ctx->ops);
+    *elem = *op;
+    if (count > 1) {
+        if (ctx->cur->lbl_begin == -1) {
+            /* Variables written by previous instruction can't be written by
+             * this instruction, except when this is part of an OR chain. */
+            elem->written &= ~elem[-1].written;
+        }
+    }
+
+    elem->next = flecs_itolbl(count);
+    elem->prev = flecs_itolbl(count - 2);
+    return flecs_itolbl(count - 1);
+}
+
+ecs_query_op_t* flecs_query_begin_block(
+    ecs_query_op_kind_t kind,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t op = {0};
+    op.kind = flecs_ito(uint8_t, kind);
+    ctx->cur->lbl_begin = flecs_query_op_insert(&op, ctx);
+    return ecs_vec_get_t(ctx->ops, ecs_query_op_t, ctx->cur->lbl_begin);
+}
+
+void flecs_query_end_block(
+    ecs_query_compile_ctx_t *ctx,
+    bool reset)
+{
+    ecs_query_op_t new_op = {0};
+    new_op.kind = EcsQueryEnd;
+    ecs_query_lbl_t end = flecs_query_op_insert(&new_op, ctx);
+    
+    ecs_query_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_query_op_t);
+    ops[ctx->cur->lbl_begin].next = end;
+
+    ecs_query_op_t *end_op = &ops[end];
+    if (reset && ctx->cur->lbl_query != -1) {
+        ecs_query_op_t *query_op = &ops[ctx->cur->lbl_query];
+        end_op->prev = ctx->cur->lbl_begin;
+        end_op->src = query_op->src;
+        end_op->first = query_op->first;
+        end_op->second = query_op->second;
+        end_op->flags = query_op->flags;
+        end_op->field_index = query_op->field_index;
+    } else {
+        end_op->prev = ctx->cur->lbl_begin;
+        end_op->field_index = -1;
+    }
+
+    ctx->cur->lbl_begin = -1;
+}
+
+static
+void flecs_query_begin_block_cond_eval(
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_write_flags_t cond_write_state)
+{
+    ecs_var_id_t first_var = EcsVarNone, second_var = EcsVarNone, src_var = EcsVarNone;
+    ecs_write_flags_t cond_mask = 0;
+
+    if (flecs_query_ref_flags(op->flags, EcsQueryFirst) == EcsQueryIsVar) {
+        first_var = op->first.var;
+        ecs_assert(first_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        cond_mask |= (1ull << first_var);
+    }
+    if (flecs_query_ref_flags(op->flags, EcsQuerySecond) == EcsQueryIsVar) {
+        second_var = op->second.var;
+        ecs_assert(second_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        cond_mask |= (1ull << second_var);
+    }
+    if (flecs_query_ref_flags(op->flags, EcsQuerySrc) == EcsQueryIsVar) {
+        src_var = op->src.var;
+        ecs_assert(src_var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        cond_mask |= (1ull << src_var);
+    }
+
+    /* Variables set in an OR chain are marked as conditional writes. However, 
+     * writes from previous terms in the current OR chain shouldn't be treated
+     * as variables that are conditionally set, so instead use the write mask 
+     * from before the chain started. */
+    if (ctx->ctrlflow->in_or) {
+        cond_write_state = ctx->ctrlflow->cond_written_or;
+    }
+
+    /* If this term uses conditionally set variables, insert instruction that
+     * jumps over the term if the variables weren't set yet. */
+    if (cond_mask & cond_write_state) {
+        ctx->cur->lbl_cond_eval = flecs_itolbl(ecs_vec_count(ctx->ops));
+
+        ecs_query_op_t jmp_op = {0};
+        jmp_op.kind = EcsQueryIfVar;
+
+        if ((first_var != EcsVarNone) && cond_write_state & (1ull << first_var)) {
+            jmp_op.flags |= (EcsQueryIsVar << EcsQueryFirst);
+            jmp_op.first.var = first_var;
+        }
+        if ((second_var != EcsVarNone) && cond_write_state & (1ull << second_var)) {
+            jmp_op.flags |= (EcsQueryIsVar << EcsQuerySecond);
+            jmp_op.second.var = second_var;
+        }
+        if ((src_var != EcsVarNone) && cond_write_state & (1ull << src_var)) {
+            jmp_op.flags |= (EcsQueryIsVar << EcsQuerySrc);
+            jmp_op.src.var = src_var;
+        }
+
+        flecs_query_op_insert(&jmp_op, ctx);
+    } else {
+        ctx->cur->lbl_cond_eval = -1;
+    }
+}
+
+static
+void flecs_query_end_block_cond_eval(
+    ecs_query_compile_ctx_t *ctx)
+{
+    if (ctx->cur->lbl_cond_eval == -1) {
+        return;
+    }
+
+    ecs_assert(ctx->cur->lbl_query >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_query_op_t end_op = {0};
+    end_op.kind = EcsQueryEnd;
+    ecs_query_lbl_t end = flecs_query_op_insert(&end_op, ctx);
+
+    ecs_query_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_query_op_t);
+    ops[ctx->cur->lbl_cond_eval].next = end;
+
+    ecs_query_op_t *end_op_ptr = &ops[end];
+    ecs_query_op_t *query_op = &ops[ctx->cur->lbl_query];
+    end_op_ptr->prev = ctx->cur->lbl_cond_eval;
+    end_op_ptr->src = query_op->src;
+    end_op_ptr->first = query_op->first;
+    end_op_ptr->second = query_op->second;
+    end_op_ptr->flags = query_op->flags;
+    end_op_ptr->field_index = query_op->field_index;
+}
+
+static
+void flecs_query_begin_block_or(
+    ecs_query_op_t *op,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t *or_op = flecs_query_begin_block(EcsQueryNot, ctx);
+    or_op->kind = EcsQueryOr;
+
+    /* Set the source of the evaluate terms as source of the Or instruction. 
+     * This lets the engine determine whether the variable has already been
+     * written. When the source is not yet written, an OR operation needs to
+     * take the union of all the terms in the OR chain. When the variable is
+     * known, it will return after the first matching term.
+     * 
+     * In case a term in the OR expression is an equality predicate which 
+     * compares the left hand side with a variable, the variable acts as an 
+     * alias, so we can always assume that it's written. */
+    bool add_src = true;
+    if (ECS_TERM_REF_ID(&term->first) == EcsPredEq && term->second.id & EcsIsVariable) {
+        if (!(flecs_query_is_written(op->src.var, ctx->written))) {
+            add_src = false;
+        }
+    }
+
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        if (add_src) {
+            or_op->flags = (EcsQueryIsVar << EcsQuerySrc);
+            or_op->src = op->src;
+            ctx->cur->src_or = op->src;
+        }
+
+        ctx->cur->src_written_or = flecs_query_is_written(
+            op->src.var, ctx->written);
+    }
+}
+
+static
+void flecs_query_end_block_or(
+    ecs_query_impl_t *impl,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t op = {0};
+    op.kind = EcsQueryEnd;
+    ecs_query_lbl_t end = flecs_query_op_insert(&op, ctx);
+
+    ecs_query_op_t *ops = ecs_vec_first_t(ctx->ops, ecs_query_op_t);
+    int32_t i, prev_or = ctx->cur->lbl_begin + 1;
+    for (i = ctx->cur->lbl_begin + 1; i < end; i ++) {
+        if (ops[i].next == FlecsRuleOrMarker) {
+            if (i == (end - 1)) {
+                ops[prev_or].prev = ctx->cur->lbl_begin;
+            } else {
+                ops[prev_or].prev = flecs_itolbl(i + 1);
+            }
+
+            ops[i].next = flecs_itolbl(end);
+
+            prev_or = i + 1;
+        }
+    }
+
+    ecs_query_op_t *first = &ops[ctx->cur->lbl_begin];
+    bool src_is_var = first->flags & (EcsQueryIsVar << EcsQuerySrc);
+    first->next = flecs_itolbl(end);
+    ops[end].prev = ctx->cur->lbl_begin;
+    ops[end - 1].prev = ctx->cur->lbl_begin;
+
+    ctx->ctrlflow->in_or = false;
+    ctx->cur->lbl_begin = -1;
+    if (src_is_var) {
+        ecs_var_id_t src_var = first->src.var;
+        ctx->written |= (1llu << src_var);
+
+        /* If src is a table variable, it is possible that this was resolved to
+         * an entity variable in all of the OR terms. If this is the case, mark
+         * entity variable as written as well. */
+        ecs_query_var_t *var = &impl->vars[src_var];
+        if (var->kind == EcsVarTable) {
+            const char *name = var->name;
+            if (!name) {
+                name = "this";
+            }
+
+            ecs_var_id_t evar = flecs_query_find_var_id(
+                impl, name, EcsVarEntity);
+            if (evar != EcsVarNone && (ctx->cond_written & (1llu << evar))) {
+                ctx->written |= (1llu << evar);
+                ctx->cond_written &= ~(1llu << evar);
+            }
+        }
+    }
+    ctx->written |= ctx->cond_written;
+
+    /* Scan which variables were conditionally written in the OR chain and 
+     * reset instructions after the OR chain. If a variable is set in part one
+     * of a chain but not part two, there would be nothing writing to the
+     * variable in part two, leaving it to the previous value. To address this
+     * a reset is inserted that resets the variable value on redo. */
+    for (i = 1; i < (8 * ECS_SIZEOF(ecs_write_flags_t)); i ++) {
+        ecs_write_flags_t prev = 1 & (ctx->ctrlflow->cond_written_or >> i);
+        ecs_write_flags_t cur = 1 & (ctx->cond_written >> i);
+
+        /* Skip variable if it's the source for the OR chain */
+        if (src_is_var && (i == first->src.var)) {
+            continue;
+        }
+
+        if (!prev && cur) {
+            ecs_query_op_t reset_op = {0};
+            reset_op.kind = EcsQueryReset;
+            reset_op.flags |= (EcsQueryIsVar << EcsQuerySrc);
+            reset_op.src.var = flecs_itovar(i);
+            flecs_query_op_insert(&reset_op, ctx);
+        }
+    }
+}
+
+void flecs_query_insert_each(
+    ecs_var_id_t tvar,
+    ecs_var_id_t evar,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
+{
+    ecs_query_op_t each = {0};
+    each.kind = EcsQueryEach;
+    each.src.var = evar;
+    each.first.var = tvar;
+    each.flags = (EcsQueryIsVar << EcsQuerySrc) | 
+                 (EcsQueryIsVar << EcsQueryFirst);
+    flecs_query_write_ctx(evar, ctx, cond_write);
+    flecs_query_write(evar, &each.written);
+    flecs_query_op_insert(&each, ctx);
+}
+
+static
+void flecs_query_insert_lookup(
+    ecs_var_id_t base_var,
+    ecs_var_id_t evar,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
+{
+    ecs_query_op_t lookup = {0};
+    lookup.kind = EcsQueryLookup;
+    lookup.src.var = evar;
+    lookup.first.var = base_var;
+    lookup.flags = (EcsQueryIsVar << EcsQuerySrc) | 
+                 (EcsQueryIsVar << EcsQueryFirst);
+    flecs_query_write_ctx(evar, ctx, cond_write);
+    flecs_query_write(evar, &lookup.written);
+    flecs_query_op_insert(&lookup, ctx);
+}
+
+static
+void flecs_query_insert_unconstrained_transitive(
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
+{
+    /* Create anonymous variable to store the target ids. This will return the
+     * list of targets without constraining the variable of the term, which
+     * needs to stay variable to find all transitive relationships for a src. */
+    ecs_var_id_t tgt = flecs_query_add_var(query, NULL, NULL, EcsVarEntity);
+    flecs_set_var_label(&query->vars[tgt], query->vars[op->second.var].name);
+
+    /* First, find ids to start traversal from. This fixes op.second. */
+    ecs_query_op_t find_ids = {0};
+    find_ids.kind = EcsQueryIdsRight;
+    find_ids.field_index = -1;
+    find_ids.first = op->first;
+    find_ids.second = op->second;
+    find_ids.flags = op->flags;
+    find_ids.flags &= (ecs_flags8_t)~((EcsQueryIsVar|EcsQueryIsEntity) << EcsQuerySrc);
+    find_ids.second.var = tgt;
+    flecs_query_write_ctx(tgt, ctx, cond_write);
+    flecs_query_write(tgt, &find_ids.written);
+    flecs_query_op_insert(&find_ids, ctx);
+
+    /* Next, iterate all tables for the ids. This fixes op.src */
+    ecs_query_op_t and_op = {0};
+    and_op.kind = EcsQueryAnd;
+    and_op.field_index = op->field_index;
+    and_op.first = op->first;
+    and_op.second = op->second;
+    and_op.src = op->src;
+    and_op.flags = op->flags | EcsQueryIsSelf;
+    and_op.second.var = tgt;
+    flecs_query_write_ctx(and_op.src.var, ctx, cond_write);
+    flecs_query_write(and_op.src.var, &and_op.written);
+    flecs_query_op_insert(&and_op, ctx);
+}
+
+static
+void flecs_query_insert_inheritance(
+    ecs_query_impl_t *query,
+    ecs_term_t *term,
+    ecs_query_op_t *op,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
+{
+    /* Anonymous variable to store the resolved component ids */
+    ecs_var_id_t tvar = flecs_query_add_var(query, NULL, NULL, EcsVarTable);
+    ecs_var_id_t evar = flecs_query_add_var(query, NULL, NULL, EcsVarEntity);
+
+    flecs_set_var_label(&query->vars[tvar], ecs_get_name(query->pub.world, 
+        ECS_TERM_REF_ID(&term->first)));
+    flecs_set_var_label(&query->vars[evar], ecs_get_name(query->pub.world, 
+        ECS_TERM_REF_ID(&term->first)));
+
+    ecs_query_op_t trav_op = {0};
+    trav_op.kind = EcsQueryTrav;
+    trav_op.field_index = -1;
+    trav_op.first.entity = EcsIsA;
+    trav_op.second.entity = ECS_TERM_REF_ID(&term->first);
+    trav_op.src.var = tvar;
+    trav_op.flags = EcsQueryIsSelf;
+    trav_op.flags |= (EcsQueryIsEntity << EcsQueryFirst);
+    trav_op.flags |= (EcsQueryIsEntity << EcsQuerySecond);
+    trav_op.flags |= (EcsQueryIsVar << EcsQuerySrc);
+    trav_op.written |= (1ull << tvar);
+    if (term->first.id & EcsSelf) {
+        trav_op.match_flags |= EcsTermReflexive;
+    }
+    flecs_query_op_insert(&trav_op, ctx);
+    flecs_query_insert_each(tvar, evar, ctx, cond_write);
+
+    ecs_query_ref_t r = { .var = evar };
+    op->first = r;
+    op->flags &= (ecs_flags8_t)~(EcsQueryIsEntity << EcsQueryFirst);
+    op->flags |= (EcsQueryIsVar << EcsQueryFirst);
+}
+
+void flecs_query_compile_term_ref(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_term_ref_t *term_ref,
+    ecs_query_ref_t *ref,
+    ecs_flags8_t ref_kind,
+    ecs_var_kind_t kind,
+    ecs_query_compile_ctx_t *ctx,
+    bool create_wildcard_vars)
+{
+    (void)world;
+
+    if (!ecs_term_ref_is_set(term_ref)) {
+        return;
+    }
+
+    if (term_ref->id & EcsIsVariable) {
+        op->flags |= (ecs_flags8_t)(EcsQueryIsVar << ref_kind);
+        const char *name = flecs_term_ref_var_name(term_ref);
+        if (name) {
+            ref->var = flecs_query_most_specific_var(query, name, kind, ctx);
+            ecs_assert(ref->var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        } else if (create_wildcard_vars) {
+            bool is_wildcard = flecs_term_ref_is_wildcard(term_ref);
+            if (is_wildcard && (kind == EcsVarAny)) {
+                ref->var = flecs_query_add_var(query, NULL, NULL, EcsVarTable);
+            } else {
+                ref->var = flecs_query_add_var(query, NULL, NULL, EcsVarEntity);
+            }
+            if (is_wildcard) {
+                flecs_set_var_label(&query->vars[ref->var], 
+                    ecs_get_name(world, ECS_TERM_REF_ID(term_ref)));
+            }
+            ecs_assert(ref->var != EcsVarNone, ECS_INTERNAL_ERROR, NULL);
+        }
+    }
+
+    if (term_ref->id & EcsIsEntity) {
+        op->flags |= (ecs_flags8_t)(EcsQueryIsEntity << ref_kind);
+        ref->entity = ECS_TERM_REF_ID(term_ref);
+    }
+}
+
+static
+int flecs_query_compile_ensure_vars(
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write,
+    bool *written_out)
+{
+    ecs_flags16_t flags = flecs_query_ref_flags(op->flags, ref_kind);
+    bool written = false;
+
+    if (flags & EcsQueryIsVar) {
+        ecs_var_id_t var_id = ref->var;
+        ecs_query_var_t *var = &query->vars[var_id];
+
+        if (var->kind == EcsVarEntity && 
+            !flecs_query_is_written(var_id, ctx->written)) 
+        {
+            /* If entity variable is not yet written but a table variant exists
+             * that has been written, insert each operation to translate from
+             * entity variable to table */
+            ecs_var_id_t tvar = var->table_id;
+            if ((tvar != EcsVarNone) && 
+                flecs_query_is_written(tvar, ctx->written)) 
+            {
+                if (var->lookup) {
+                    if (!flecs_query_is_written(tvar, ctx->written)) {
+                        ecs_err("dependent variable of '$%s' is not written", 
+                            var->name);
+                        return -1;
+                    }
+
+                    if (!flecs_query_is_written(var->base_id, ctx->written)) {
+                        flecs_query_insert_each(
+                            tvar, var->base_id, ctx, cond_write);
+                    }
+                } else {
+                    flecs_query_insert_each(tvar, var_id, ctx, cond_write);
+                }
+
+                /* Variable was written, just not as entity */
+                written = true;
+            } else if (var->lookup) {
+                if (!flecs_query_is_written(var->base_id, ctx->written)) {
+                    ecs_err("dependent variable of '$%s' is not written", 
+                        var->name);
+                    return -1;
+                }
+            }
+        }
+
+        written |= flecs_query_is_written(var_id, ctx->written);
+    } else {
+        /* If it's not a variable, it's always written */
+        written = true;
+    }
+
+    if (written_out) {
+        *written_out = written;
+    }
+
+    return 0;
+}
+
+static
+bool flecs_query_compile_lookup(
+    ecs_query_impl_t *query,
+    ecs_var_id_t var_id,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write) 
+{
+    ecs_query_var_t *var = &query->vars[var_id];
+    if (var->lookup) {
+        flecs_query_insert_lookup(var->base_id, var_id, ctx, cond_write);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+static
+void flecs_query_insert_contains(
+    ecs_query_impl_t *query,
+    ecs_var_id_t src_var,
+    ecs_var_id_t other_var,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t contains = {0};
+    if ((src_var != other_var) && (src_var == query->vars[other_var].table_id)) {
+        contains.kind = EcsQueryContain;
+        contains.src.var = src_var;
+        contains.first.var = other_var;
+        contains.flags |= (EcsQueryIsVar << EcsQuerySrc) | 
+                          (EcsQueryIsVar << EcsQueryFirst);
+        flecs_query_op_insert(&contains, ctx);
+    }
+}
+
+static
+void flecs_query_insert_pair_eq(
+    int32_t field_index,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t contains = {0};
+    contains.kind = EcsQueryPairEq;
+    contains.field_index = flecs_ito(int8_t, field_index);
+    flecs_query_op_insert(&contains, ctx);
+}
+
+static
+int flecs_query_compile_builtin_pred(
+    ecs_query_t *q,
+    ecs_term_t *term,
+    ecs_query_op_t *op,
+    ecs_write_flags_t write_state)
+{
+    ecs_entity_t id = ECS_TERM_REF_ID(&term->first);
+
+    ecs_query_op_kind_t eq[] = {EcsQueryPredEq, EcsQueryPredNeq};
+    ecs_query_op_kind_t eq_name[] = {EcsQueryPredEqName, EcsQueryPredNeqName};
+    ecs_query_op_kind_t eq_match[] = {EcsQueryPredEqMatch, EcsQueryPredNeqMatch};
+    
+    ecs_flags16_t flags_src = flecs_query_ref_flags(op->flags, EcsQuerySrc);
+    ecs_flags16_t flags_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+
+    if (id == EcsPredEq) {
+        if (term->second.id & EcsIsName) {
+            op->kind = flecs_ito(uint8_t, eq_name[term->oper == EcsNot]);
+        } else {
+            op->kind = flecs_ito(uint8_t, eq[term->oper == EcsNot]);
+        }
+    } else if (id == EcsPredMatch) {
+        op->kind = flecs_ito(uint8_t, eq_match[term->oper == EcsNot]);
+    }
+
+    if (flags_2nd & EcsQueryIsVar) {
+        if (!(write_state & (1ull << op->second.var))) {
+            ecs_err("uninitialized variable '%s' on right-hand side of "
+                "equality operator", ecs_query_var_name(q, op->second.var));
+            return -1;
+        }
+    }
+
+    ecs_assert(flags_src & EcsQueryIsVar, ECS_INTERNAL_ERROR, NULL);
+    (void)flags_src;
+
+    if (!(write_state & (1ull << op->src.var))) {
+        /* If this is an == operator with a right-hand side that resolves to a
+         * single entity, the left-hand side is allowed to be undefined, as the
+         * instruction will be evaluated as an assignment. */
+        if (op->kind != EcsQueryPredEq && op->kind != EcsQueryPredEqName) {
+            ecs_err("uninitialized variable '%s' on left-hand side of "
+                "equality operator", ecs_query_var_name(q, op->src.var));
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+static
+int flecs_query_ensure_scope_var(
+    ecs_query_impl_t *query,
+    ecs_query_op_t *op,
+    ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_var_id_t var = ref->var;
+
+    if (query->vars[var].kind == EcsVarEntity && 
+        !flecs_query_is_written(var, ctx->written)) 
+    {
+        ecs_var_id_t table_var = query->vars[var].table_id;
+        if (table_var != EcsVarNone && 
+            flecs_query_is_written(table_var, ctx->written)) 
+        {
+            if (flecs_query_compile_ensure_vars(
+                query, op, ref, ref_kind, ctx, false, NULL))
+            {
+                goto error;
+            }
+        }
+    }
+
+    return 0;
+error:
+    return -1;
+}
+
+static
+int flecs_query_ensure_scope_vars(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_term_t *term)
+{
+    /* If the scope uses variables as entity that have only been written as
+     * table, resolve them as entities before entering the scope. */
+    ecs_term_t *cur = term;
+    while(ECS_TERM_REF_ID(&cur->first) != EcsScopeClose) {
+        /* Dummy operation to obtain variable information for term */
+        ecs_query_op_t op = {0};
+        flecs_query_compile_term_ref(world, query, &op, &cur->first, 
+            &op.first, EcsQueryFirst, EcsVarEntity, ctx, false);
+        flecs_query_compile_term_ref(world, query, &op, &cur->second, 
+            &op.second, EcsQuerySecond, EcsVarEntity, ctx, false);
+
+        if (op.flags & (EcsQueryIsVar << EcsQueryFirst)) {
+            if (flecs_query_ensure_scope_var(
+                query, &op, &op.first, EcsQueryFirst, ctx))
+            {
+                goto error;
+            }
+        }
+        if (op.flags & (EcsQueryIsVar << EcsQuerySecond)) {
+            if (flecs_query_ensure_scope_var(
+                query, &op, &op.second, EcsQuerySecond, ctx))
+            {
+                goto error;
+            }
+        }
+
+        cur ++;
+    }
+
+    return 0;
+error:
+    return -1;
+}
+
+static
+void flecs_query_compile_push(
+    ecs_query_compile_ctx_t *ctx)
+{
+    ctx->cur = &ctx->ctrlflow[++ ctx->scope];
+    ctx->cur->lbl_begin = -1;
+    ctx->cur->lbl_begin = -1;
+}
+
+static
+void flecs_query_compile_pop(
+    ecs_query_compile_ctx_t *ctx)
+{
+    ctx->cur = &ctx->ctrlflow[-- ctx->scope];
+}
+
+static
+int flecs_query_compile_0_src(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx)
+{
+    /* If the term has a 0 source, check if it's a scope open/close */
+    if (ECS_TERM_REF_ID(&term->first) == EcsScopeOpen) {
+        if (flecs_query_ensure_scope_vars(world, impl, ctx, term)) {
+            goto error;
+        }
+        if (term->oper == EcsNot) {
+            ctx->scope_is_not |= (ecs_flags32_t)(1ull << ctx->scope);
+            flecs_query_begin_block(EcsQueryNot, ctx);
+        } else {
+            ctx->scope_is_not &= (ecs_flags32_t)~(1ull << ctx->scope);
+        }
+        flecs_query_compile_push(ctx);
+    } else if (ECS_TERM_REF_ID(&term->first) == EcsScopeClose) {
+        flecs_query_compile_pop(ctx);
+        if (ctx->scope_is_not & (ecs_flags32_t)(1ull << (ctx->scope))) {
+            flecs_query_end_block(ctx, false);
+        }
+    } else {
+        /* Noop */
+    }
+
+    return 0;
+error:
+    return -1;
+}
+
+static
+bool flecs_query_select_all(
+    ecs_term_t *term,
+    ecs_query_op_t *op,
+    ecs_var_id_t src_var,
+    ecs_query_compile_ctx_t *ctx)
+{
+    bool builtin_pred = flecs_term_is_builtin_pred(term);
+    bool pred_match = builtin_pred && ECS_TERM_REF_ID(&term->first) == EcsPredMatch;
+
+    if (term->oper == EcsNot || term->oper == EcsOptional || 
+        term->oper == EcsNotFrom || pred_match) 
+    {
+        ecs_query_op_t match_any = {0};
+        match_any.kind = EcsAnd;
+        match_any.flags = EcsQueryIsSelf | (EcsQueryIsEntity << EcsQueryFirst);
+        match_any.flags |= (EcsQueryIsVar << EcsQuerySrc);
+        match_any.src = op->src;
+        match_any.field_index = -1;
+        if (!pred_match) {
+            match_any.first.entity = EcsAny;
+        } else {
+            /* If matching by name, instead of finding all tables, just find
+             * the ones with a name. */
+            match_any.first.entity = ecs_id(EcsIdentifier);
+            match_any.second.entity = EcsName;
+            match_any.flags |= (EcsQueryIsEntity << EcsQuerySecond);
+        }
+        match_any.written = (1ull << src_var);
+        flecs_query_op_insert(&match_any, ctx);
+        flecs_query_write_ctx(op->src.var, ctx, false);
+
+        /* Update write administration */
+        return true;
+    }
+    return false;
+}
+
+#ifdef FLECS_META
+static
+int flecs_query_compile_begin_member_term(
+    ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_entity_t first_id)
+{
+    ecs_assert(first_id != 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(first_id & EcsIsEntity, ECS_INTERNAL_ERROR, NULL);
+
+    first_id = ECS_TERM_REF_ID(&term->first);
+
+    /* First compile as if it's a regular term, to match the component */
+    term->flags_ &= (ecs_termset_t)~EcsTermIsMember;
+
+    /* Replace term id with member parent (the component) */
+    ecs_entity_t component = ecs_get_parent(world, first_id);
+    if (!component) {
+        ecs_err("member without parent in query");
+        return -1;
+    }
+
+    if (!ecs_has(world, component, EcsComponent)) {
+        ecs_err("parent of member is not a component");
+        return -1;
+    }
+
+    bool second_wildcard = ECS_TERM_REF_ID(&term->second) == EcsWildcard &&
+        (term->second.id & EcsIsVariable) && !term->second.name;
+
+    term->first.id = component | ECS_TERM_REF_FLAGS(&term->first);
+    term->second.id = 0;
+    term->id = component;
+
+    ctx->oper = (ecs_oper_kind_t)term->oper;
+    if (term->oper == EcsNot && !second_wildcard) {
+        /* When matching a member term with not operator, we need to cover both
+         * the case where an entity doesn't have the component, and where it 
+         * does have the component, but doesn't match the member. */
+        term->oper = EcsOptional;
+    }
+
+    return 0;
+}
+
+static
+int flecs_query_compile_end_member_term(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_op_t *op,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_id_t term_id,
+    ecs_entity_t first_id,
+    ecs_entity_t second_id,
+    bool cond_write)
+{
+    ecs_entity_t component = ECS_TERM_REF_ID(&term->first);
+    const EcsComponent *comp = ecs_get(world, component, EcsComponent);
+    ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    /* Restore term values */
+    term->id = term_id;
+    term->first.id = first_id;
+    term->second.id = second_id;
+    term->flags_ |= EcsTermIsMember;
+    term->oper = flecs_ito(int16_t, ctx->oper);
+
+    first_id = ECS_TERM_REF_ID(&term->first);
+    const EcsMember *member = ecs_get(world, first_id, EcsMember);
+    ecs_assert(member != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_query_var_t *var = &impl->vars[op->src.var];
+    const char *var_name = flecs_term_ref_var_name(&term->src);
+    ecs_var_id_t evar = flecs_query_find_var_id(
+        impl, var_name, EcsVarEntity);
+    bool second_wildcard = ECS_TERM_REF_ID(&term->second) == EcsWildcard &&
+        (term->second.id & EcsIsVariable) && !term->second.name;
+
+    if (term->oper == EcsOptional) {
+        second_wildcard = true;
+    }
+
+    ecs_query_op_t mbr_op = *op;
+    mbr_op.kind = EcsQueryMemberEq;
+    mbr_op.first.entity = /* Encode type size and member offset */
+        flecs_ito(uint32_t, member->offset) | 
+        (flecs_ito(uint64_t, comp->size) << 32);
+
+    /* If this is a term with a Not operator, conditionally evaluate member on
+     * whether term was set by previous operation (see begin_member_term). */
+    if (ctx->oper == EcsNot || ctx->oper == EcsOptional) {
+        if (second_wildcard && ctx->oper == EcsNot) {
+            /* A !(T.value, *) term doesn't need special operations */
+            return 0;
+        }
+
+        /* Resolve to entity variable before entering if block, so that we 
+         * don't have different branches of the query working with different
+         * versions of the same variable. */
+        if (var->kind == EcsVarTable) {
+            flecs_query_insert_each(op->src.var, evar, ctx, cond_write);
+            var = &impl->vars[evar];
+        }
+
+        ecs_query_op_t *if_op = flecs_query_begin_block(EcsQueryIfSet, ctx);
+        if_op->other = term->field_index;
+
+        if (ctx->oper == EcsNot) {
+            mbr_op.kind = EcsQueryMemberNeq;
+        }
+    }
+
+    if (var->kind == EcsVarTable) {
+        /* If MemberEq is called on table variable, store it on .other member.
+         * This causes MemberEq to do double duty as 'each' instruction,
+         * which is faster than having to go back & forth between instructions
+         * while finding matching values. */
+        mbr_op.other = flecs_itolbl(op->src.var + 1);
+
+        /* Mark entity variable as written */
+        flecs_query_write_ctx(evar, ctx, cond_write);
+        flecs_query_write(evar, &mbr_op.written);
+    }
+
+    flecs_query_compile_term_ref(world, impl, &mbr_op, &term->src, 
+        &mbr_op.src, EcsQuerySrc, EcsVarEntity, ctx, true);
+
+    if (second_wildcard) {
+        mbr_op.flags |= (EcsQueryIsEntity << EcsQuerySecond);
+        mbr_op.second.entity = EcsWildcard;
+    } else {
+        flecs_query_compile_term_ref(world, impl, &mbr_op, &term->second, 
+            &mbr_op.second, EcsQuerySecond, EcsVarEntity, ctx, true);
+        
+        if (term->second.id & EcsIsVariable) {
+            if (flecs_query_compile_ensure_vars(impl, &mbr_op, &mbr_op.second, 
+                EcsQuerySecond, ctx, cond_write, NULL)) 
+            {
+                goto error;
+            }
+
+            flecs_query_write_ctx(mbr_op.second.var, ctx, cond_write);
+            flecs_query_write(mbr_op.second.var, &mbr_op.written);
+        }
+    }
+
+    flecs_query_op_insert(&mbr_op, ctx);
+
+    if (ctx->oper == EcsNot || ctx->oper == EcsOptional) {
+        flecs_query_end_block(ctx, false);
+    }
+
+    return 0;
+error:
+    return -1;
+}
+#else
+static
+int flecs_query_compile_begin_member_term(
+    ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_entity_t first_id)
+{
+    (void)world; (void)term; (void)ctx; (void)first_id;
+    return 0;
+}
+
+static
+int flecs_query_compile_end_member_term(
+    ecs_world_t *world,
+    ecs_query_impl_t *impl,
+    ecs_query_op_t *op,
+    ecs_term_t *term,
+    ecs_query_compile_ctx_t *ctx,
+    ecs_id_t term_id,
+    ecs_entity_t first_id,
+    ecs_entity_t second_id,
+    bool cond_write)
+{
+    (void)world; (void)impl; (void)op; (void)term; (void)ctx; (void)term_id;
+    (void)first_id; (void)second_id; (void)cond_write;
+    return 0;
+}
+#endif
+
+static
+void flecs_query_mark_last_or_op(
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_query_op_t *op_ptr = ecs_vec_last_t(ctx->ops, ecs_query_op_t);
+    op_ptr->next = FlecsRuleOrMarker;
+}
+
+static
+void flecs_query_set_op_kind(
+    ecs_query_t *q,
+    ecs_query_op_t *op,
+    ecs_term_t *term,
+    bool src_is_var,
+    bool member_term)
+{
+    /* Default instruction for And operators. If the source is fixed (like for
+     * singletons or terms with an entity source), use With, which like And but
+     * just matches against a source (vs. finding a source). */
+    op->kind = src_is_var ? EcsQueryAnd : EcsQueryWith;
+
+    /* Handle *From operators */
+    if (term->oper == EcsAndFrom) {
+        op->kind = EcsQueryAndFrom;
+    } else if (term->oper == EcsOrFrom) {
+        op->kind = EcsQueryOrFrom;
+    } else if (term->oper == EcsNotFrom) {
+        op->kind = EcsQueryNotFrom;
+
+    /* If query is transitive, use Trav(ersal) instruction */
+    } else if (term->flags_ & EcsTermTransitive) {
+        ecs_assert(ecs_term_ref_is_set(&term->second), ECS_INTERNAL_ERROR, NULL);
+        op->kind = EcsQueryTrav;
+    } else {
+        /* Ignore cascade flag */
+        ecs_entity_t trav_flags = EcsTraverseFlags & ~(EcsCascade|EcsDesc);
+        if (term->flags_ & (EcsTermMatchAny|EcsTermMatchAnySrc)) {
+            op->kind = EcsQueryAndAny;
+        } else if ((term->src.id & trav_flags) == EcsUp) {
+            op->kind = EcsQueryUp;
+        } else if ((term->src.id & trav_flags) == (EcsSelf|EcsUp)) {
+            op->kind = EcsQuerySelfUp;
+        }
+    }
+
+    /* If term has fixed id, insert simpler instruction that skips dealing with
+     * wildcard terms and variables */
+    if (flecs_term_is_fixed_id(q, term) && !member_term) {
+        if (op->kind == EcsQueryAnd) {
+            op->kind = EcsQueryAndId;
+        } else if (op->kind == EcsQuerySelfUp) {
+            op->kind = EcsQuerySelfUpId;
+        } else if (op->kind == EcsQueryUp) {
+            op->kind = EcsQueryUpId;
+        }
+    }
+}
+
+int flecs_query_compile_term(
+    ecs_world_t *world,
+    ecs_query_impl_t *query,
+    ecs_term_t *term,
+    ecs_flags64_t *populated,
+    ecs_query_compile_ctx_t *ctx)
+{
+    ecs_id_t term_id = term->id;
+    ecs_entity_t first_id = term->first.id;
+    ecs_entity_t second_id = term->second.id;
+    bool toggle_term = (term->flags_ & EcsTermIsToggle) != 0;
+    bool member_term = (term->flags_ & EcsTermIsMember) != 0;
+    if (member_term) {
+        (*populated) |= (1llu << term->field_index);
+        flecs_query_compile_begin_member_term(world, term, ctx, first_id);
+    }
+
+    ecs_query_t *q = &query->pub;
+    bool first_term = term == q->terms;
+    bool first_is_var = term->first.id & EcsIsVariable;
+    bool second_is_var = term->second.id & EcsIsVariable;
+    bool src_is_var = term->src.id & EcsIsVariable;
+    bool src_is_wildcard = src_is_var && 
+        (ECS_TERM_REF_ID(&term->src) == EcsWildcard ||
+            ECS_TERM_REF_ID(&term->src) == EcsAny);
+    bool src_is_lookup = false;
+    bool builtin_pred = flecs_term_is_builtin_pred(term);
+    bool is_not = (term->oper == EcsNot) && !builtin_pred;
+    bool is_optional = (term->oper == EcsOptional);
+    bool is_or = flecs_term_is_or(q, term);
+    bool first_or = false, last_or = false;
+    bool cond_write = term->oper == EcsOptional || is_or;
+    ecs_query_op_t op = {0};
+
+    if (is_or) {
+        first_or = first_term || (term[-1].oper != EcsOr);
+        last_or = term->oper != EcsOr;
+    }
+
+    if (term->oper == EcsAndFrom || term->oper == EcsOrFrom || 
+        term->oper == EcsNotFrom) 
+    {
+        const ecs_type_t *type = ecs_get_type(world, term->id);
+        if (!type) {
+            /* Empty type for id in *From operation is a noop */
+            ctx->skipped ++;
+            return 0;
+        }
+
+        int32_t i, count = type->count;
+        ecs_id_t *ti_ids = type->array;
+
+        for (i = 0; i < count; i ++) {
+            ecs_id_t ti_id = ti_ids[i];
+            ecs_id_record_t *idr = flecs_id_record_get(world, ti_id);
+            if (!(idr->flags & EcsIdDontInherit)) {
+                break;
+            }
+        }
+
+        if (i == count) {
+            /* Type did not contain any ids to perform operation on */
+            ctx->skipped ++;
+            return 0;
+        }
+    }
+
+    /* !_ (don't match anything) terms always return nothing. */
+    if (is_not && term->id == EcsAny) {
+        op.kind = EcsQueryNothing;
+        flecs_query_op_insert(&op, ctx);
+        return 0;
+    }
+
+    if (first_or) {
+        ctx->ctrlflow->cond_written_or = ctx->cond_written;
+        ctx->ctrlflow->in_or = true;
+    } else if (is_or) {
+        ctx->written = ctx->ctrlflow->written_or;
+    }
+
+    if (!ECS_TERM_REF_ID(&term->src) && term->src.id & EcsIsEntity) {
+        if (flecs_query_compile_0_src(world, query, term, ctx)) {
+            goto error;
+        }
+        return 0;
+    }
+
+    if (builtin_pred) {
+        ecs_entity_t id_noflags = ECS_TERM_REF_ID(&term->second);
+        if (id_noflags == EcsWildcard || id_noflags == EcsAny) {
+            /* Noop */
+            return 0;
+        }
+    }
+
+    op.field_index = flecs_ito(int8_t, term->field_index);
+    op.term_index = flecs_ito(int8_t, term - q->terms);
+
+    flecs_query_set_op_kind(q, &op, term, src_is_var, member_term);
+
+    /* Save write state at start of term so we can use it to reliably track
+     * variables got written by this term. */
+    ecs_write_flags_t cond_write_state = ctx->cond_written;
+
+    /* Resolve variables and entities for operation arguments */
+    flecs_query_compile_term_ref(world, query, &op, &term->first, 
+        &op.first, EcsQueryFirst, EcsVarEntity, ctx, true);
+    flecs_query_compile_term_ref(world, query, &op, &term->second, 
+        &op.second, EcsQuerySecond, EcsVarEntity, ctx, true);
+    flecs_query_compile_term_ref(world, query, &op, &term->src, 
+        &op.src, EcsQuerySrc, EcsVarAny, ctx, true);
+
+    bool src_written = true;
+    if (src_is_var) {
+        src_is_lookup = query->vars[op.src.var].lookup != NULL;
+        src_written = flecs_query_is_written(op.src.var, ctx->written);
+    }
+
+    /* Insert each instructions for table -> entity variable if needed */
+    bool first_written, second_written;
+    if (flecs_query_compile_ensure_vars(
+        query, &op, &op.first, EcsQueryFirst, ctx, cond_write, &first_written)) 
+    {
+        goto error;    
+    }
+
+    if (flecs_query_compile_ensure_vars(
+        query, &op, &op.second, EcsQuerySecond, ctx, cond_write, &second_written))
+    {
+        goto error;
+    }
+
+    /* Store write state of variables for first OR term in chain which will get
+     * restored for the other terms in the chain, so that all OR terms make the
+     * same assumptions about which variables were already written. */
+    if (first_or) {
+        ctx->ctrlflow->written_or = ctx->written;
+    }
+
+    /* If an optional or not term is inserted for a source that's not been 
+     * written to yet, insert instruction that selects all entities so we have
+     * something to match the optional/not against. */
+    if (src_is_var && !src_written && !src_is_wildcard && !src_is_lookup) {
+        src_written = flecs_query_select_all(term, &op, op.src.var, ctx);
+    }
+
+    /* A bit of special logic for OR expressions and equality predicates. If the
+     * left-hand of an equality operator is a table, and there are multiple
+     * operators in an Or expression, the Or chain should match all entities in
+     * the table that match the right hand sides of the operator expressions. 
+     * For this to work, the src variable needs to be resolved as entity, as an
+     * Or chain would otherwise only yield the first match from a table. */
+    if (src_is_var && src_written && (builtin_pred || member_term) && term->oper == EcsOr) {
+        if (query->vars[op.src.var].kind == EcsVarTable) {
+            flecs_query_compile_term_ref(world, query, &op, &term->src, 
+                    &op.src, EcsQuerySrc, EcsVarEntity, ctx, true);
+            ctx->ctrlflow->written_or |= (1llu << op.src.var);
+        }
+    }
+
+    if (flecs_query_compile_ensure_vars(
+        query, &op, &op.src, EcsQuerySrc, ctx, cond_write, NULL)) 
+    {
+        goto error;
+    }
+
+    /* If source is Any (_) and first and/or second are unconstrained, insert an
+     * ids instruction instead of an And */
+    if (term->flags_ & EcsTermMatchAnySrc) {
+        op.kind = EcsQueryIds;
+        /* Use up-to-date written values after potentially inserting each */
+        if (!first_written || !second_written) {
+            if (!first_written) {
+                /* If first is unknown, traverse left: <- (*, t) */
+                if (ECS_TERM_REF_ID(&term->first) != EcsAny) {
+                    op.kind = EcsQueryIdsLeft;
+                }
+            } else {
+                /* If second is wildcard, traverse right: (r, *) -> */
+                if (ECS_TERM_REF_ID(&term->second) != EcsAny) {
+                    op.kind = EcsQueryIdsRight;
+                }
+            }
+            op.src.entity = 0;
+            src_is_var = false;
+            op.flags &= (ecs_flags8_t)~(EcsQueryIsVar << EcsQuerySrc); /* ids has no src */
+            op.flags &= (ecs_flags8_t)~(EcsQueryIsEntity << EcsQuerySrc);
+        }
+
+    /* If source variable is not written and we're querying just for Any, insert
+     * a dedicated instruction that uses the Any record in the id index. Any 
+     * queries that are evaluated against written sources can use Wildcard 
+     * records, which is what the AndAny instruction does. */
+    } else if (!src_written && term->id == EcsAny && op.kind == EcsQueryAndAny) {
+        /* Lookup variables ($var.child_name) are always written */
+        if (!src_is_lookup) {
+            op.kind = EcsQuerySelectAny; /* Uses Any (_) id record */
+        }
+    }
+
+    /* If this is a transitive term and both the target and source are unknown,
+     * find the targets for the relationship first. This clusters together 
+     * tables for the same target, which allows for more efficient usage of the
+     * traversal caches. */
+    if (term->flags_ & EcsTermTransitive && src_is_var && second_is_var) {
+        if (!src_written && !second_written) {
+            flecs_query_insert_unconstrained_transitive(
+                query, &op, ctx, cond_write);
+        }
+    }
+
+    /* Check if this term has variables that have been conditionally written,
+     * like variables written by an optional term. */
+    if (ctx->cond_written) {
+        if (!is_or || first_or) {
+            flecs_query_begin_block_cond_eval(&op, ctx, cond_write_state);
+        }
+    }
+
+    /* If term can toggle and is Not, change operator to Optional as we
+     * have to match entities that have the component but disabled. */
+    if (toggle_term && is_not) {
+        is_not = false;
+        is_optional = true;
+    }
+
+    /* Handle Not, Optional, Or operators */
+    if (is_not) {
+        flecs_query_begin_block(EcsQueryNot, ctx);
+    } else if (is_optional) {
+        flecs_query_begin_block(EcsQueryOptional, ctx);
+    } else if (first_or) {
+        flecs_query_begin_block_or(&op, term, ctx);
+    }
+
+    /* If term has component inheritance enabled, insert instruction to walk
+     * down the relationship tree of the id. */
+    if (term->flags_ & EcsTermIdInherited) {
+        flecs_query_insert_inheritance(query, term, &op, ctx, cond_write);
+    }
+
+    op.match_flags = term->flags_;
+
+    ecs_write_flags_t write_state = ctx->written;
+    if (first_is_var) {
+        op.flags &= (ecs_flags8_t)~(EcsQueryIsEntity << EcsQueryFirst);
+        op.flags |= (EcsQueryIsVar << EcsQueryFirst);
+    }
+
+    if (term->src.id & EcsSelf) {
+        op.flags |= EcsQueryIsSelf;
+    }
+
+    /* Insert instructions for lookup variables */
+    if (first_is_var) {
+        if (flecs_query_compile_lookup(query, op.first.var, ctx, cond_write)) {
+            write_state |= (1ull << op.first.var); // lookups are resolved inline
+        }
+    }
+    if (src_is_var) {
+        if (flecs_query_compile_lookup(query, op.src.var, ctx, cond_write)) {
+            write_state |= (1ull << op.src.var); // lookups are resolved inline
+        }
+    }
+    if (second_is_var) {
+        if (flecs_query_compile_lookup(query, op.second.var, ctx, cond_write)) {
+            write_state |= (1ull << op.second.var); // lookups are resolved inline
+        }
+    }
+
+    if (builtin_pred) {
+        if (flecs_query_compile_builtin_pred(q, term, &op, write_state)) {
+            goto error;
+        }
+    }
+
+    /* If we're writing the $this variable, filter out disabled/prefab entities
+     * unless the query explicitly matches them.
+     * This could've been done with regular With instructions, but since 
+     * filtering out disabled/prefab entities is the default and this check is
+     * cheap to perform on table flags, it's worth special casing. */
+    if (!src_written && op.src.var == 0) {
+        ecs_flags32_t query_flags = q->flags;
+        if (!(query_flags & EcsQueryMatchDisabled) || 
+            !(query_flags & EcsQueryMatchPrefab)) 
+        {
+            ecs_flags32_t table_flags = EcsTableNotQueryable;
+            if (!(query_flags & EcsQueryMatchDisabled)) {
+                table_flags |= EcsTableIsDisabled;
+            }
+            if (!(query_flags & EcsQueryMatchPrefab)) {
+                table_flags |= EcsTableIsPrefab;
+            }
+
+            op.other = flecs_itolbl(table_flags);
+        }
+    }
+
+    /* After evaluating a term, a used variable is always written */
+    if (src_is_var) {
+        flecs_query_write(op.src.var, &op.written);
+        flecs_query_write_ctx(op.src.var, ctx, cond_write);
+    }
+    if (first_is_var) {
+        flecs_query_write(op.first.var, &op.written);
+        flecs_query_write_ctx(op.first.var, ctx, cond_write);
+    }
+    if (second_is_var) {
+        flecs_query_write(op.second.var, &op.written);
+        flecs_query_write_ctx(op.second.var, ctx, cond_write);
+    }
+    
+    flecs_query_op_insert(&op, ctx);
+
+    ctx->cur->lbl_query = flecs_itolbl(ecs_vec_count(ctx->ops) - 1);
+    if (is_or && !member_term) {
+        flecs_query_mark_last_or_op(ctx);
+    }
+
+    /* Handle self-references between src and first/second variables */
+    if (src_is_var) {
+        if (first_is_var) {
+            flecs_query_insert_contains(query, op.src.var, op.first.var, ctx);
+        }
+        if (second_is_var && op.first.var != op.second.var) {
+            flecs_query_insert_contains(query, op.src.var, op.second.var, ctx);
+        }
+    }
+
+    /* Handle self references between first and second variables */
+    if (!ecs_id_is_wildcard(first_id)) {
+        if (first_is_var && !first_written && (op.first.var == op.second.var)) {
+            flecs_query_insert_pair_eq(term->field_index, ctx);
+        }
+    }
+
+    /* Handle closing of Not, Optional and Or operators */
+    if (is_not) {
+        flecs_query_end_block(ctx, true);
+    } else if (is_optional) {
+        flecs_query_end_block(ctx, true);
+    }
+
+    /* Now that the term is resolved, evaluate member of component */
+    if (member_term) {
+        flecs_query_compile_end_member_term(world, query, &op, term, ctx, 
+            term_id, first_id, second_id, cond_write);
+        if (is_or) {
+            flecs_query_mark_last_or_op(ctx);
+        }
+    }
+
+    if (last_or) {
+        flecs_query_end_block_or(query, ctx);
+    }
+
+    /* Handle closing of conditional evaluation */
+    if (ctx->cur->lbl_cond_eval && (first_is_var || second_is_var || src_is_var)) {
+        if (!is_or || last_or) {
+            flecs_query_end_block_cond_eval(ctx);
+        }
+    }
+
+    /* Ensure that term id is set after evaluating Not */
+    if (term->flags_ & EcsTermIdInherited) {
+        if (is_not) {
+            ecs_query_op_t set_id = {0};
+            set_id.kind = EcsQuerySetId;
+            set_id.first.entity = term->id;
+            set_id.flags = (EcsQueryIsEntity << EcsQueryFirst);
+            set_id.field_index = flecs_ito(int8_t, term->field_index);
+            flecs_query_op_insert(&set_id, ctx);
+        }
+    }
+
+    return 0;
+error:
+    return -1;
+}
diff --git a/src/query/engine.c b/src/query/engine.c
new file mode 100644
index 000000000..4377fad6e
--- /dev/null
+++ b/src/query/engine.c
@@ -0,0 +1,3805 @@
+/**
+ * @file addons/querys/engine.c
+ * @brief Query engine implementation.
+ */
+
+#include "../private_api.h"
+
+// #define FLECS_QUERY_TRACE
+
+#ifdef FLECS_QUERY_TRACE
+static int flecs_query_trace_indent = 0;
+#endif
+
+static
+bool flecs_query_dispatch(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx);
+
+static
+bool flecs_query_run_until(
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    const ecs_query_op_t *ops,
+    ecs_query_lbl_t first,
+    ecs_query_lbl_t cur,
+    int32_t last);
+
+static
+void flecs_query_populate_field(
+    ecs_iter_t *it,
+    ecs_table_range_t *range,
+    int8_t field_index,
+    ecs_query_run_ctx_t *ctx);
+
+static
+void flecs_query_populate_field_from_range(
+    ecs_iter_t *it,
+    ecs_table_range_t *range,
+    int8_t field_index,
+    int32_t index);
+
+static
+void flecs_query_set_iter_this(
+    ecs_iter_t *it,
+    const ecs_query_run_ctx_t *ctx)
+{
+    const ecs_table_range_t *range = &ctx->vars[0].range;
+    ecs_table_t *table = range->table;
+    int32_t count = range->count;
+    if (table) {
+        if (!count) {
+            count = ecs_table_count(table);
+        }
+        it->table = table;
+        it->offset = range->offset;
+        it->count = count;
+        it->entities = ECS_ELEM_T(
+            table->data.entities.array, ecs_entity_t, it->offset);
+    } else if (count == 1) {
+        it->count = 1;
+        it->entities = &ctx->vars[0].entity;
+    }
+}
+
+static
+ecs_query_op_ctx_t* flecs_op_ctx_(
+    const ecs_query_run_ctx_t *ctx)
+{
+    return &ctx->op_ctx[ctx->op_index];
+}
+
+#define flecs_op_ctx(ctx, op_kind) (&flecs_op_ctx_(ctx)->is.op_kind)
+
+static
+void flecs_reset_source_set_flag(
+    ecs_iter_t *it,
+    int32_t field_index)
+{
+    ecs_assert(field_index != -1, ECS_INTERNAL_ERROR, NULL);
+    ECS_TERMSET_CLEAR(it->up_fields, 1u << field_index);
+}
+
+static
+void flecs_set_source_set_flag(
+    ecs_iter_t *it,
+    int32_t field_index)
+{
+    ecs_assert(field_index != -1, ECS_INTERNAL_ERROR, NULL);
+    ECS_TERMSET_SET(it->up_fields, 1u << field_index);
+}
+
+static
+ecs_table_range_t flecs_range_from_entity(
+    ecs_entity_t e,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_record_t *r = flecs_entities_get(ctx->world, e);
+    if (!r) {
+        return (ecs_table_range_t){ 0 };
+    }
+    return (ecs_table_range_t){
+        .table = r->table,
+        .offset = ECS_RECORD_TO_ROW(r->row),
+        .count = 1
+    };
+}
+
+static
+ecs_table_range_t flecs_query_var_get_range(
+    int32_t var_id,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_assert(var_id < ctx->query->var_count, ECS_INTERNAL_ERROR, NULL);
+    ecs_var_t *var = &ctx->vars[var_id];
+    ecs_table_t *table = var->range.table;
+    if (table) {
+        return var->range;
+    }
+
+    ecs_entity_t entity = var->entity;
+    if (entity && entity != EcsWildcard) {
+        var->range = flecs_range_from_entity(entity, ctx);
+        return var->range;
+    }
+
+    return (ecs_table_range_t){ 0 };
+}
+
+static
+ecs_table_t* flecs_query_var_get_table(
+    int32_t var_id,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_var_t *var = &ctx->vars[var_id];
+    ecs_table_t *table = var->range.table;
+    if (table) {
+        return table;
+    }
+
+    ecs_entity_t entity = var->entity;
+    if (entity && entity != EcsWildcard) {
+        var->range = flecs_range_from_entity(entity, ctx);
+        return var->range.table;
+    }
+
+    return NULL;
+}
+
+static
+ecs_table_t* flecs_query_get_table(
+    const ecs_query_op_t *op,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t flags = flecs_query_ref_flags(op->flags, ref_kind);
+    if (flags & EcsQueryIsEntity) {
+        return ecs_get_table(ctx->world, ref->entity);
+    } else {
+        return flecs_query_var_get_table(ref->var, ctx);
+    }
+}
+
+static
+ecs_table_range_t flecs_query_get_range(
+    const ecs_query_op_t *op,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t flags = flecs_query_ref_flags(op->flags, ref_kind);
+    if (flags & EcsQueryIsEntity) {
+        ecs_assert(!(flags & EcsQueryIsVar), ECS_INTERNAL_ERROR, NULL);
+        return flecs_range_from_entity(ref->entity, ctx);
+    } else {
+        ecs_var_t *var = &ctx->vars[ref->var];
+        if (var->range.table) {
+            return ctx->vars[ref->var].range;
+        } else if (var->entity) {
+            return flecs_range_from_entity(var->entity, ctx);
+        }
+    }
+    return (ecs_table_range_t){0};
+}
+
+static
+ecs_entity_t flecs_query_var_get_entity(
+    ecs_var_id_t var_id,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_assert(var_id < (ecs_var_id_t)ctx->query->var_count, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_var_t *var = &ctx->vars[var_id];
+    ecs_entity_t entity = var->entity;
+    if (entity) {
+        return entity;
+    }
+
+    ecs_assert(var->range.count == 1, ECS_INTERNAL_ERROR, NULL);
+    ecs_table_t *table = var->range.table;
+    ecs_entity_t *entities = table->data.entities.array;
+    var->entity = entities[var->range.offset];
+    return var->entity;
+}
+
+static
+void flecs_query_var_reset(
+    ecs_var_id_t var_id,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ctx->vars[var_id].entity = EcsWildcard;
+    ctx->vars[var_id].range.table = NULL;
+}
+
+static
+void flecs_query_var_set_range(
+    const ecs_query_op_t *op,
+    ecs_var_id_t var_id,
+    ecs_table_t *table,
+    int32_t offset,
+    int32_t count,
+    const ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    ecs_assert(ctx->query_vars[var_id].kind == EcsVarTable, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(flecs_query_is_written(var_id, op->written), 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_var_t *var = &ctx->vars[var_id];
+    var->entity = 0;
+    var->range = (ecs_table_range_t){ 
+        .table = table,
+        .offset = offset,
+        .count = count
+    };
+}
+
+static
+void flecs_query_var_narrow_range(
+    ecs_var_id_t var_id,
+    ecs_table_t *table,
+    int32_t offset,
+    int32_t count,
+    const ecs_query_run_ctx_t *ctx)
+{    
+    ecs_var_t *var = &ctx->vars[var_id];
+    
+    var->entity = 0;
+    var->range = (ecs_table_range_t){ 
+        .table = table,
+        .offset = offset,
+        .count = count
+    };
+
+    if (ctx->query_vars[var_id].kind != EcsVarTable) {    
+        ecs_assert(count == 1, ECS_INTERNAL_ERROR, NULL);
+        var->entity = flecs_table_entities_array(table)[offset];
+    }
+}
+
+static
+void flecs_query_var_set_entity(
+    const ecs_query_op_t *op,
+    ecs_var_id_t var_id,
+    ecs_entity_t entity,
+    const ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    ecs_assert(var_id < (ecs_var_id_t)ctx->query->var_count, 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(flecs_query_is_written(var_id, op->written), 
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_var_t *var = &ctx->vars[var_id];
+    var->range.table = NULL;
+    var->entity = entity;
+}
+
+static
+void flecs_query_set_vars(
+    const ecs_query_op_t *op,
+    ecs_id_t id,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t flags_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t flags_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+
+    if (flags_1st & EcsQueryIsVar) {
+        ecs_var_id_t var = op->first.var;
+        if (op->written & (1ull << var)) {
+            if (ECS_IS_PAIR(id)) {
+                flecs_query_var_set_entity(
+                    op, var, ecs_get_alive(ctx->world, ECS_PAIR_FIRST(id)), ctx);
+            } else {
+                flecs_query_var_set_entity(op, var, id, ctx);
+            }
+        }
+    }
+
+    if (flags_2nd & EcsQueryIsVar) {
+        ecs_var_id_t var = op->second.var;
+        if (op->written & (1ull << var)) {
+            flecs_query_var_set_entity(
+                op, var, ecs_get_alive(ctx->world, ECS_PAIR_SECOND(id)), ctx);
+        }
+    }
+}
+
+static
+ecs_table_range_t flecs_get_ref_range(
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t flag,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (flag & EcsQueryIsEntity) {
+        return flecs_range_from_entity(ref->entity, ctx);
+    } else if (flag & EcsQueryIsVar) {
+        return flecs_query_var_get_range(ref->var, ctx);
+    }
+    return (ecs_table_range_t){0};
+}
+
+static
+ecs_entity_t flecs_get_ref_entity(
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t flag,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (flag & EcsQueryIsEntity) {
+        return ref->entity;
+    } else if (flag & EcsQueryIsVar) {
+        return flecs_query_var_get_entity(ref->var, ctx);
+    }
+    return 0;
+}
+
+static
+ecs_id_t flecs_query_op_get_id_w_written(
+    const ecs_query_op_t *op,
+    uint64_t written,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t flags_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t flags_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+    ecs_entity_t first = 0, second = 0;
+
+    if (flags_1st) {
+        if (flecs_ref_is_written(op, &op->first, EcsQueryFirst, written)) {
+            first = flecs_get_ref_entity(&op->first, flags_1st, ctx);
+        } else if (flags_1st & EcsQueryIsVar) {
+            first = EcsWildcard;
+        }
+    }
+    if (flags_2nd) {
+        if (flecs_ref_is_written(op, &op->second, EcsQuerySecond, written)) {
+            second = flecs_get_ref_entity(&op->second, flags_2nd, ctx);
+        } else if (flags_2nd & EcsQueryIsVar) {
+            second = EcsWildcard;
+        }
+    }
+
+    if (flags_2nd & (EcsQueryIsVar | EcsQueryIsEntity)) {
+        return ecs_pair(first, second);
+    } else {
+        return flecs_entities_get_alive(ctx->world, first);
+    }
+}
+
+static
+ecs_id_t flecs_query_op_get_id(
+    const ecs_query_op_t *op,
+    const ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index];
+    return flecs_query_op_get_id_w_written(op, written, ctx);
+}
+
+static
+int16_t flecs_query_next_column(
+    ecs_table_t *table,
+    ecs_id_t id,
+    int32_t column)
+{
+    if (!ECS_IS_PAIR(id) || (ECS_PAIR_FIRST(id) != EcsWildcard)) {
+        column = column + 1;
+    } else {
+        ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+        column = ecs_search_offset(NULL, table, column + 1, id, NULL);
+        ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL);
+    }
+    return flecs_ito(int16_t, column);
+}
+
+static
+void flecs_query_it_set_column(
+    ecs_iter_t *it,
+    int32_t field_index,
+    int32_t column)
+{
+    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(field_index >= 0, ECS_INTERNAL_ERROR, NULL);
+    it->columns[field_index] = column;
+}
+
+static
+ecs_id_t flecs_query_it_set_id(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t field_index,
+    int32_t column)
+{
+    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(field_index >= 0, ECS_INTERNAL_ERROR, NULL);
+    return it->ids[field_index] = table->type.array[column];
+}
+
+static
+void flecs_query_set_match(
+    const ecs_query_op_t *op,
+    ecs_table_t *table,
+    int32_t column,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+    int32_t field_index = op->field_index;
+    if (field_index == -1) {
+        return;
+    }
+
+    ecs_iter_t *it = ctx->it;
+    flecs_query_it_set_column(it, field_index, column);
+    ecs_id_t matched = flecs_query_it_set_id(it, table, field_index, column);
+    flecs_query_set_vars(op, matched, ctx);
+}
+
+static
+void flecs_query_set_trav_match(
+    const ecs_query_op_t *op,
+    int32_t column,
+    ecs_entity_t trav,
+    ecs_entity_t second,
+    const ecs_query_run_ctx_t *ctx)
+{
+    int32_t field_index = op->field_index;
+    if (field_index == -1) {
+        return;
+    }
+
+    ecs_iter_t *it = ctx->it;
+    ecs_id_t matched = ecs_pair(trav, second);
+    it->ids[op->field_index] = matched;
+    if (column != -1) {
+        flecs_query_it_set_column(it, op->field_index, column);
+    }
+    flecs_query_set_vars(op, matched, ctx);
+}
+
+static
+bool flecs_query_table_filter(
+    ecs_table_t *table,
+    ecs_query_lbl_t other,
+    ecs_flags32_t filter_mask)
+{
+    uint32_t filter = flecs_ito(uint32_t, other);
+    return (table->flags & filter_mask & filter) != 0;
+}
+
+static
+bool flecs_query_select_w_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_id_t id,
+    ecs_flags32_t filter_mask)
+{
+    ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+    ecs_id_record_t *idr = op_ctx->idr;
+    ecs_table_record_t *tr;
+    ecs_table_t *table;
+
+    if (!redo) {
+        if (!idr || idr->id != id) {
+            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
+            if (!idr) {
+                return false;
+            }
+        }
+
+        if (ctx->query->pub.flags & EcsQueryMatchEmptyTables) {
+            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
+        } else {
+            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
+        }
+    }
+
+repeat:
+    if (!redo || !op_ctx->remaining) {
+        tr = flecs_table_cache_next(&op_ctx->it, ecs_table_record_t);
+        if (!tr) {
+            return false;
+        }
+
+        op_ctx->column = flecs_ito(int16_t, tr->index);
+        op_ctx->remaining = flecs_ito(int16_t, tr->count - 1);
+        table = tr->hdr.table;
+        flecs_query_var_set_range(op, op->src.var, table, 0, 0, ctx);
+    } else {
+        tr = (ecs_table_record_t*)op_ctx->it.cur;
+        ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL);
+        table = tr->hdr.table;
+        op_ctx->column = flecs_query_next_column(table, idr->id, op_ctx->column);
+        op_ctx->remaining --;
+    }
+
+    if (flecs_query_table_filter(table, op->other, filter_mask)) {
+        goto repeat;
+    }
+
+    flecs_query_set_match(op, table, op_ctx->column, ctx);
+    return true;
+}
+
+static
+bool flecs_query_select(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_id_t id = 0;
+    if (!redo) {
+        id = flecs_query_op_get_id(op, ctx);
+    }
+    return flecs_query_select_w_id(op, redo, ctx, id, 
+        (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled));
+}
+
+static
+bool flecs_query_with(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+    ecs_id_record_t *idr = op_ctx->idr;
+    const ecs_table_record_t *tr;
+
+    ecs_table_t *table = flecs_query_get_table(op, &op->src, EcsQuerySrc, ctx);
+    if (!table) {
+        return false;
+    }
+
+    if (!redo) {
+        ecs_id_t id = flecs_query_op_get_id(op, ctx);
+        if (!idr || idr->id != id) {
+            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
+            if (!idr) {
+                return false;
+            }
+        }
+
+        tr = flecs_id_record_get_table(idr, table);
+        if (!tr) {
+            return false;
+        }
+
+        op_ctx->column = flecs_ito(int16_t, tr->index);
+        op_ctx->remaining = flecs_ito(int16_t, tr->count);
+    } else {
+        if (--op_ctx->remaining <= 0) {
+            return false;
+        }
+
+        op_ctx->column = flecs_query_next_column(table, idr->id, op_ctx->column);
+        ecs_assert(op_ctx->column != -1, ECS_INTERNAL_ERROR, NULL);
+    }
+
+    flecs_query_set_match(op, table, op_ctx->column, ctx);
+    return true;
+}
+
+static
+bool flecs_query_and(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index];
+    if (written & (1ull << op->src.var)) {
+        return flecs_query_with(op, redo, ctx);
+    } else {
+        return flecs_query_select(op, redo, ctx);
+    }
+}
+
+static
+bool flecs_query_select_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_flags32_t table_filter)
+{
+    ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+    ecs_iter_t *it = ctx->it;
+    int8_t field = op->field_index;
+    ecs_assert(field != -1, ECS_INTERNAL_ERROR, NULL);
+
+    if (!redo) {
+        ecs_id_t id = it->ids[field];
+        ecs_id_record_t *idr = op_ctx->idr;
+        if (!idr || idr->id != id) {
+            idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
+            if (!idr) {
+                return false;
+            }
+        }
+
+        if (ctx->query->pub.flags & EcsQueryMatchEmptyTables) {
+            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
+        } else {
+            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
+        }
+    }
+
+repeat: {}
+    const ecs_table_record_t *tr = flecs_table_cache_next(
+        &op_ctx->it, ecs_table_record_t);
+    if (!tr) {
+        return false;
+    }
+
+    ecs_table_t *table = tr->hdr.table;
+    if (flecs_query_table_filter(table, op->other, table_filter)) {
+        goto repeat;
+    }
+
+    flecs_query_var_set_range(op, op->src.var, table, 0, 0, ctx);
+    flecs_query_it_set_column(it, field, tr->index);
+    return true;
+}
+
+static
+bool flecs_query_with_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (redo) {
+        return false;
+    }
+
+    ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+    ecs_iter_t *it = ctx->it;
+    int8_t field = op->field_index;
+    ecs_assert(field != -1, ECS_INTERNAL_ERROR, NULL);
+
+    ecs_table_t *table = flecs_query_get_table(op, &op->src, EcsQuerySrc, ctx);
+    if (!table) {
+        return false;
+    }
+
+    ecs_id_t id = it->ids[field];
+    ecs_id_record_t *idr = op_ctx->idr;
+    if (!idr || idr->id != id) {
+        idr = op_ctx->idr = flecs_id_record_get(ctx->world, id);
+        if (!idr) {
+            return false;
+        }
+    }
+
+    ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+    if (!tr) {
+        return false;
+    }
+
+    flecs_query_it_set_column(it, field, tr->index);
+    return true;
+}
+
+static
+bool flecs_query_and_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index];
+    if (written & (1ull << op->src.var)) {
+        return flecs_query_with_id(op, redo, ctx);
+    } else {
+        return flecs_query_select_id(op, redo, ctx, 
+            (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled));
+    }
+}
+
+static
+bool flecs_query_up_select(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    bool self,
+    bool id_only)
+{
+    ecs_query_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
+    ecs_world_t *world = ctx->world;
+    ecs_iter_t *it = ctx->it;
+    bool redo_select = redo;
+    const ecs_query_t *q = &ctx->query->pub;
+
+    /* Early out if traversal relationship doesn't exist */
+    op_ctx->trav = q->terms[op->term_index].trav;
+    if (!op_ctx->idr_trav) {
+        op_ctx->idr_trav = flecs_id_record_get(ctx->world, 
+            ecs_pair(op_ctx->trav, EcsWildcard));
+    }
+    if (!op_ctx->idr_trav || !flecs_table_cache_count(&op_ctx->idr_trav->cache)){
+        if (!self) {
+            return false;
+        } else if (id_only) {
+            return flecs_query_select_id(op, redo, ctx,
+                (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled));
+        } else {
+            return flecs_query_select(op, redo, ctx);
+        }
+    }
+
+    if (!redo) {
+        op_ctx->with = flecs_query_op_get_id(op, ctx);
+        op_ctx->idr_with = flecs_id_record_get(ctx->world, op_ctx->with);
+        if (!op_ctx->idr_with) {
+            return false;
+        }
+
+        op_ctx->down = NULL;
+        op_ctx->cache_elem = 0;
+    }
+
+    ecs_trav_down_t *down = op_ctx->down;
+
+    do {
+        while (!down) {
+            ecs_table_t *table = op_ctx->table;
+            if (!table) {
+                ecs_table_range_t range;
+                it->sources[op->field_index] = 0;
+                do {
+                    bool result;
+                    if (id_only) {
+                        result = flecs_query_select_id(op, redo_select, ctx, 0);
+                    } else {
+                        result = flecs_query_select_w_id(op, redo_select, ctx, 
+                            op_ctx->with, 0);
+                    }
+                    if (!result) {
+                        return false;
+                    }
+
+                    redo_select = true;
+
+                    range = flecs_query_get_range(
+                        op, &op->src, EcsQuerySrc, ctx);
+                    ecs_assert(range.table != NULL, ECS_INTERNAL_ERROR, NULL);
+                } while (!self && range.table->_->traversable_count == 0);
+
+                if (!range.count) {
+                    range.count = ecs_table_count(range.table);
+                }
+
+                table = op_ctx->table = range.table;
+                op_ctx->row = range.offset;
+                op_ctx->end = range.offset + range.count;
+                op_ctx->matched = it->ids[op->field_index];
+
+                if (self) {
+                    if (!flecs_query_table_filter(table, op->other, 
+                        (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)))
+                    {
+                        flecs_reset_source_set_flag(it, op->field_index);
+                        op_ctx->row --;
+                        return true;
+                    }
+                }
+
+                redo_select = true;
+            } else {
+                op_ctx->row ++;
+            }
+
+            if (table->_->traversable_count == 0) {
+                op_ctx->table = NULL;
+                continue;
+            } else {
+                int32_t row;
+                ecs_entity_t entity = 0;
+                ecs_entity_t *entities = flecs_table_entities_array(table);
+
+                for (row = op_ctx->row; row < op_ctx->end; row ++) {
+                    entity = entities[row];
+                    ecs_record_t *record = flecs_entities_get(world, entity);
+                    if (record->row & EcsEntityIsTraversable) {
+                        it->sources[op->field_index] = entity;
+                        break;
+                    }
+                }
+
+                if (row == op_ctx->end) {
+                    op_ctx->table = NULL;
+                    continue;
+                }
+
+                bool match_empty = (q->flags & EcsQueryMatchEmptyTables) != 0;
+                down = op_ctx->down = flecs_query_get_down_cache(ctx, &op_ctx->cache, 
+                    op_ctx->trav, entity, op_ctx->idr_with, self, match_empty);
+                op_ctx->cache_elem = -1;
+            }
+        }
+
+next_elem:
+        if ((++ op_ctx->cache_elem) >= ecs_vec_count(&down->elems)) {
+            down = NULL;
+            continue;
+        }
+
+        ecs_trav_down_elem_t *elem = ecs_vec_get_t(
+            &down->elems, ecs_trav_down_elem_t, op_ctx->cache_elem);
+
+        flecs_query_var_set_range(op, op->src.var, elem->table, 0, 0, ctx);
+        flecs_query_set_vars(op, op_ctx->matched, ctx);
+
+        if (flecs_query_table_filter(elem->table, op->other, 
+            (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)))
+        {
+            goto next_elem;
+        }
+
+        break;
+    } while (true);
+
+    flecs_set_source_set_flag(it, op->field_index);
+
+    return true;
+}
+
+static
+bool flecs_query_up_with(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    const ecs_query_t *q = &ctx->query->pub;
+    ecs_query_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
+    ecs_iter_t *it = ctx->it;
+
+    /* Early out if traversal relationship doesn't exist */
+    op_ctx->trav = q->terms[op->term_index].trav;
+    if (!op_ctx->idr_trav) {
+        op_ctx->idr_trav = flecs_id_record_get(ctx->world, 
+            ecs_pair(op_ctx->trav, EcsWildcard));
+    }
+    if (!op_ctx->idr_trav || !flecs_table_cache_all_count(&op_ctx->idr_trav->cache)){
+        return false;
+    }
+
+    if (!redo) {
+        op_ctx->trav = q->terms[op->term_index].trav;
+        op_ctx->with = flecs_query_op_get_id(op, ctx);
+        op_ctx->idr_with = flecs_id_record_get(ctx->world, op_ctx->with);
+
+        if (!op_ctx->idr_with) {
+            return false;
+        }
+
+        ecs_table_range_t range = flecs_query_get_range(
+            op, &op->src, EcsQuerySrc, ctx);
+        if (!range.table) {
+            return false;
+        }
+
+        ecs_trav_up_t *up = flecs_query_get_up_cache(ctx, &op_ctx->cache, 
+            range.table, op_ctx->with, op_ctx->trav, op_ctx->idr_with,
+            op_ctx->idr_trav);
+
+        if (!up) {
+            return false;
+        }
+
+        it->sources[op->field_index] = flecs_entities_get_alive(
+            ctx->world, up->src);
+        it->columns[op->field_index] = up->column;
+        it->ids[op->field_index] = up->id;
+        flecs_query_set_vars(op, up->id, ctx);
+        flecs_set_source_set_flag(it, op->field_index);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+static
+bool flecs_query_self_up_with(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    bool id_only)
+{
+    if (!redo) {
+        bool result;
+        if (id_only) {
+            result = flecs_query_with_id(op, redo, ctx);
+        } else {
+            result = flecs_query_with(op, redo, ctx);
+        }
+
+        flecs_reset_source_set_flag(ctx->it, op->field_index);
+
+        if (result) {
+            ecs_query_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
+            op_ctx->trav = 0;
+            if (flecs_query_ref_flags(op->flags, EcsQuerySrc) & EcsQueryIsVar) {
+                ecs_iter_t *it = ctx->it;
+                it->sources[op->field_index] = 0;
+            }
+            return true;
+        }
+
+        return flecs_query_up_with(op, redo, ctx);
+    } else {
+        ecs_query_up_ctx_t *op_ctx = flecs_op_ctx(ctx, up);
+        if (op_ctx->trav == 0) {
+            return flecs_query_with(op, redo, ctx);
+        }
+    }
+
+    return false;
+}
+
+static
+bool flecs_query_up(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index];
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        return flecs_query_up_with(op, redo, ctx);
+    } else {
+        return flecs_query_up_select(op, redo, ctx, false, false);
+    }
+}
+
+static
+bool flecs_query_self_up(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index];
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        return flecs_query_self_up_with(op, redo, ctx, false);
+    } else {
+        return flecs_query_up_select(op, redo, ctx, true, false);
+    }
+}
+
+static
+bool flecs_query_up_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index];
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        return flecs_query_up_with(op, redo, ctx);
+    } else {
+        return flecs_query_up_select(op, redo, ctx, false, true);
+    }
+}
+
+static
+bool flecs_query_self_up_id(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index];
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        return flecs_query_self_up_with(op, redo, ctx, true);
+    } else {
+        return flecs_query_up_select(op, redo, ctx, true, true);
+    }
+}
+
+static
+bool flecs_query_select_any(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_select_w_id(op, redo, ctx, EcsAny, 
+        (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled));
+}
+
+static
+bool flecs_query_and_any(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t match_flags = op->match_flags;
+    if (redo) {
+        if (match_flags & EcsTermMatchAnySrc) {
+            return false;
+        }
+    }
+
+    uint64_t written = ctx->written[ctx->op_index];
+    int32_t remaining = 1;
+    bool result;
+    if (flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        result = flecs_query_with(op, redo, ctx);
+    } else {
+        result = flecs_query_select(op, redo, ctx);
+        remaining = 0;
+    }
+
+    if (!redo) {
+        ecs_query_and_ctx_t *op_ctx = flecs_op_ctx(ctx, and);
+        if (match_flags & EcsTermMatchAny && op_ctx->remaining) {
+            op_ctx->remaining = flecs_ito(int16_t, remaining);
+        }
+    }
+
+    int32_t field = op->field_index;
+    if (field != -1) {
+        ctx->it->ids[field] = flecs_query_op_get_id(op, ctx);
+    }
+
+    return result;
+}
+
+static
+bool flecs_query_triv(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
+    ecs_flags64_t termset = op->src.entity;
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        flecs_query_set_iter_this(ctx->it, ctx);
+        return flecs_query_trivial_test(
+            ctx->query, ctx, !redo, termset);
+    } else {
+        return flecs_query_trivial_search_nodata(
+            ctx->query, ctx, op_ctx, !redo, termset);
+    }
+}
+
+static
+bool flecs_query_triv_data(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
+    ecs_flags64_t termset = op->src.entity;
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        flecs_query_set_iter_this(ctx->it, ctx);
+        return flecs_query_trivial_test(
+            ctx->query, ctx, !redo, termset);
+    } else {
+        return flecs_query_trivial_search(
+            ctx->query, ctx, op_ctx, !redo, termset);
+    }
+}
+
+static
+bool flecs_query_triv_wildcard(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_trivial_ctx_t *op_ctx = flecs_op_ctx(ctx, trivial);
+    ecs_flags64_t termset = op->src.entity;
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        flecs_query_set_iter_this(ctx->it, ctx);
+        return flecs_query_trivial_test_w_wildcards(
+            ctx->query, ctx, !redo, termset);
+    } else {
+        return flecs_query_trivial_search_w_wildcards(
+            ctx->query, ctx, op_ctx, !redo, termset);
+    }
+}
+
+static
+bool flecs_query_cache(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    (void)redo;
+
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        return flecs_query_cache_test(ctx->query, ctx, !redo);
+    } else {
+        return flecs_query_cache_search(ctx->query, ctx);
+    }
+}
+
+static
+bool flecs_query_cache_data(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    (void)redo;
+
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        return flecs_query_cache_data_test(ctx->query, ctx, !redo);
+    } else {
+        return flecs_query_cache_data_search(ctx->query, ctx);
+    }
+}
+
+static
+bool flecs_query_is_cache(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        return flecs_query_is_cache_test(ctx->query, ctx, !redo);
+    } else {
+        return flecs_query_is_cache_search(ctx->query, ctx);
+    }
+}
+
+static
+bool flecs_query_is_cache_data(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+
+    uint64_t written = ctx->written[ctx->op_index];
+    ctx->written[ctx->op_index + 1] |= 1ull;
+    if (written & 1ull) {
+        return flecs_query_is_cache_data_test(ctx->query, ctx, !redo);
+    } else {
+        return flecs_query_is_cache_data_search(ctx->query, ctx);
+    }
+}
+
+static
+bool flecs_query_trav_fixed_src_reflexive(
+    const ecs_query_op_t *op,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_table_range_t *range,
+    ecs_entity_t trav,
+    ecs_entity_t second)
+{
+    ecs_table_t *table = range->table;
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_entity_t *entities = table->data.entities.array;
+    int32_t count = range->count;
+    if (!count) {
+        count = ecs_table_count(table);
+    }
+
+    int32_t i = range->offset, end = i + count;
+    for (; i < end; i ++) {
+        if (entities[i] == second) {
+            /* Even though table doesn't have the specific relationship 
+             * pair, the relationship is reflexive and the target entity
+             * is stored in the table. */
+            break;
+        }
+    }
+    if (i == end) {
+        /* Table didn't contain target entity */
+        return false;
+    }
+    if (count > 1) {
+        /* If the range contains more than one entity, set the range to
+         * return only the entity matched by the reflexive property. */
+        ecs_assert(flecs_query_ref_flags(op->flags, EcsQuerySrc) & EcsQueryIsVar, 
+            ECS_INTERNAL_ERROR, NULL);
+        ecs_var_t *var = &ctx->vars[op->src.var];
+        ecs_table_range_t *var_range = &var->range;
+        var_range->offset = i;
+        var_range->count = 1;
+        var->entity = entities[i];
+    }
+
+    flecs_query_set_trav_match(op, -1, trav, second, ctx);
+    return true;
+}
+
+static
+bool flecs_query_trav_unknown_src_reflexive(
+    const ecs_query_op_t *op,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_entity_t trav,
+    ecs_entity_t second)
+{
+    ecs_assert(flecs_query_ref_flags(op->flags, EcsQuerySrc) & EcsQueryIsVar,
+        ECS_INTERNAL_ERROR, NULL);
+    ecs_var_id_t src_var = op->src.var;
+    flecs_query_var_set_entity(op, src_var, second, ctx);
+    flecs_query_var_get_table(src_var, ctx);
+
+    ecs_table_t *table = ctx->vars[src_var].range.table;
+    if (table) {
+        if (flecs_query_table_filter(table, op->other, 
+            (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)))
+        {
+            return false;
+        }
+    }
+
+    flecs_query_set_trav_match(op, -1, trav, second, ctx);
+    return true;
+}
+
+static
+bool flecs_query_trav_fixed_src_up_fixed_second(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (redo) {
+        return false; /* If everything's fixed, can only have a single result */
+    }
+
+    ecs_flags16_t f_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t f_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+    ecs_flags16_t f_src = flecs_query_ref_flags(op->flags, EcsQuerySrc);
+    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
+    ecs_entity_t second = flecs_get_ref_entity(&op->second, f_2nd, ctx);
+    ecs_table_range_t range = flecs_get_ref_range(&op->src, f_src, ctx);
+    ecs_table_t *table = range.table;
+
+    /* Check if table has transitive relationship by traversing upwards */
+    int32_t column = ecs_search_relation(ctx->world, table, 0, 
+        ecs_pair(trav, second), trav, EcsSelf|EcsUp, NULL, NULL, NULL);
+    if (column == -1) {
+        if (op->match_flags & EcsTermReflexive) {
+            return flecs_query_trav_fixed_src_reflexive(op, ctx,
+                &range, trav, second);
+        } else {
+            return false;
+        }
+    }
+
+    flecs_query_set_trav_match(op, column, trav, second, ctx);
+    return true;
+}
+
+static
+bool flecs_query_trav_unknown_src_up_fixed_second(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t f_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t f_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
+    ecs_entity_t second = flecs_get_ref_entity(&op->second, f_2nd, ctx);
+    ecs_query_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
+
+    if (!redo) {
+        ecs_record_t *r_second = flecs_entities_get(ctx->world, second);
+        bool traversable = r_second && r_second->row & EcsEntityIsTraversable;
+        bool reflexive = op->match_flags & EcsTermReflexive;
+        if (!traversable && !reflexive) {
+            trav_ctx->cache.id = 0;
+
+            /* If there's no record for the entity, it can't have a subtree so
+             * forward operation to a regular select. */
+            return flecs_query_select(op, redo, ctx);
+        }
+
+        /* Entity is traversable, which means it could have a subtree */
+        flecs_query_get_trav_down_cache(ctx, &trav_ctx->cache, trav, second);
+        trav_ctx->index = 0;
+
+        if (op->match_flags & EcsTermReflexive) {
+            trav_ctx->index = -1;
+            if(flecs_query_trav_unknown_src_reflexive(
+                op, ctx, trav, second))
+            {
+                /* It's possible that we couldn't return the entity required for
+                 * reflexive matching, like when it's a prefab or disabled. */
+                return true;
+            }
+        }
+    } else {
+        if (!trav_ctx->cache.id) {
+            /* No traversal cache, which means this is a regular select */
+            return flecs_query_select(op, redo, ctx);
+        }
+    }
+
+    if (trav_ctx->index == -1) {
+        redo = false; /* First result after handling reflexive relationship */
+        trav_ctx->index = 0;
+    }
+
+    /* Forward to select */
+    int32_t count = ecs_vec_count(&trav_ctx->cache.entities);
+    ecs_trav_elem_t *elems = ecs_vec_first(&trav_ctx->cache.entities);
+    for (; trav_ctx->index < count; trav_ctx->index ++) {
+        ecs_trav_elem_t *el = &elems[trav_ctx->index];
+        trav_ctx->and.idr = el->idr; /* prevents lookup by select */
+        if (flecs_query_select_w_id(op, redo, ctx, ecs_pair(trav, el->entity),
+            (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled))) 
+        {
+            return true;
+        }
+        
+        redo = false;
+    }
+
+    return false;
+}
+
+static
+bool flecs_query_trav_yield_reflexive_src(
+    const ecs_query_op_t *op,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_table_range_t *range,
+    ecs_entity_t trav)
+{
+    ecs_var_t *vars = ctx->vars;
+    ecs_query_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
+    int32_t offset = trav_ctx->offset, count = trav_ctx->count;
+    bool src_is_var = op->flags & (EcsQueryIsVar << EcsQuerySrc);
+
+    if (trav_ctx->index >= (offset + count)) {
+        /* Restore previous offset, count */
+        if (src_is_var) {
+            ecs_var_id_t src_var = op->src.var;
+            vars[src_var].range.offset = offset;
+            vars[src_var].range.count = count;
+            vars[src_var].entity = 0;
+        }
+        return false;
+    }
+
+    ecs_entity_t entity = ecs_vec_get_t(
+        &range->table->data.entities, ecs_entity_t, trav_ctx->index)[0];
+    flecs_query_set_trav_match(op, -1, trav, entity, ctx);
+
+    /* Hijack existing variable to return one result at a time */
+    if (src_is_var) {
+        ecs_var_id_t src_var = op->src.var;
+        ecs_table_t *table = vars[src_var].range.table;
+        ecs_assert(!table || table == ecs_get_table(ctx->world, entity),
+            ECS_INTERNAL_ERROR, NULL);
+        (void)table;
+        vars[src_var].entity = entity;
+        vars[src_var].range = flecs_range_from_entity(entity, ctx);
+    }
+
+    return true;
+}
+
+static
+bool flecs_query_trav_fixed_src_up_unknown_second(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_flags16_t f_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t f_src = flecs_query_ref_flags(op->flags, EcsQuerySrc);
+    ecs_entity_t trav = flecs_get_ref_entity(&op->first, f_1st, ctx);
+    ecs_table_range_t range = flecs_get_ref_range(&op->src, f_src, ctx);
+    ecs_table_t *table = range.table;
+    ecs_query_trav_ctx_t *trav_ctx = flecs_op_ctx(ctx, trav);
+
+    if (!redo) {
+        flecs_query_get_trav_up_cache(ctx, &trav_ctx->cache, trav, table);
+        trav_ctx->index = 0;
+        if (op->match_flags & EcsTermReflexive) {
+            trav_ctx->yield_reflexive = true;
+            trav_ctx->index = range.offset;
+            trav_ctx->offset = range.offset;
+            trav_ctx->count = range.count ? range.count : ecs_table_count(table);
+        }
+    } else {
+        trav_ctx->index ++;
+    }
+
+    if (trav_ctx->yield_reflexive) {
+        if (flecs_query_trav_yield_reflexive_src(op, ctx, &range, trav)) {
+            return true;
+        }
+        trav_ctx->yield_reflexive = false;
+        trav_ctx->index = 0;
+    }
+
+    if (trav_ctx->index >= ecs_vec_count(&trav_ctx->cache.entities)) {
+        return false;
+    }
+
+    ecs_trav_elem_t *el = ecs_vec_get_t(
+        &trav_ctx->cache.entities, ecs_trav_elem_t, trav_ctx->index);
+    flecs_query_set_trav_match(op, el->column, trav, el->entity, ctx);
+    return true;
+}
+
+static
+bool flecs_query_trav(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index];
+
+    if (!flecs_ref_is_written(op, &op->src, EcsQuerySrc, written)) {
+        if (!flecs_ref_is_written(op, &op->second, EcsQuerySecond, written)) {
+            /* This can't happen, src or second should have been resolved */
+            ecs_abort(ECS_INTERNAL_ERROR, 
+                "invalid instruction sequence: unconstrained traversal");
+        } else {
+            return flecs_query_trav_unknown_src_up_fixed_second(op, redo, ctx);
+        }
+    } else {
+        if (!flecs_ref_is_written(op, &op->second, EcsQuerySecond, written)) {
+            return flecs_query_trav_fixed_src_up_unknown_second(op, redo, ctx);
+        } else {
+            return flecs_query_trav_fixed_src_up_fixed_second(op, redo, ctx);
+        }
+    }
+}
+
+static
+int32_t flecs_query_next_inheritable_id(
+    ecs_world_t *world,
+    ecs_type_t *type,
+    int32_t index)
+{
+    int32_t i;
+    for (i = index; i < type->count; i ++) {
+        ecs_id_record_t *idr = flecs_id_record_get(world, type->array[i]);
+        if (!(idr->flags & EcsIdDontInherit)) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+static
+bool flecs_query_x_from(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_oper_kind_t oper)
+{
+    ecs_query_xfrom_ctx_t *op_ctx = flecs_op_ctx(ctx, xfrom);
+    ecs_world_t *world = ctx->world;
+    ecs_type_t *type;
+    int32_t i;
+
+    if (!redo) {
+        /* Find entity that acts as the template from which we match the ids */
+        ecs_id_t id = flecs_query_op_get_id(op, ctx);
+        ecs_assert(ecs_is_alive(world, id), ECS_INTERNAL_ERROR, NULL);
+        ecs_record_t *r = flecs_entities_get(world, id);
+        ecs_table_t *table;
+        if (!r || !(table = r->table)) {
+            /* Nothing to match */
+            return false;
+        }
+
+        /* Find first id to test against. Skip ids with DontInherit flag. */
+        type = op_ctx->type = &table->type;
+        op_ctx->first_id_index = flecs_query_next_inheritable_id(
+            world, type, 0);
+        op_ctx->cur_id_index = op_ctx->first_id_index;
+
+        if (op_ctx->cur_id_index == -1) {
+            return false; /* No ids to filter on */
+        }
+    } else {
+        type = op_ctx->type;
+    }
+
+    ecs_id_t *ids = type->array;
+
+    /* Check if source is variable, and if it's already written */
+    bool src_written = true;
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        uint64_t written = ctx->written[ctx->op_index];
+        src_written = written & (1ull << op->src.var);
+    }
+
+    do {
+        int32_t id_index = op_ctx->cur_id_index;
+
+        /* If source is not yet written, find tables with first id */
+        if (!src_written) {
+            ecs_entity_t first_id = ids[id_index];
+
+            if (!flecs_query_select_w_id(op, redo, ctx, 
+                first_id, (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)))
+            {
+                if (oper == EcsOrFrom) {
+                    id_index = flecs_query_next_inheritable_id(
+                        world, type, id_index + 1);
+                    if (id_index != -1) {
+                        op_ctx->cur_id_index = id_index;
+                        redo = false;
+                        continue;
+                    }
+                }
+
+                return false;
+            }
+
+            id_index ++; /* First id got matched */
+        } else if (redo && src_written) {
+            return false;
+        }
+
+        ecs_table_t *src_table = flecs_query_get_table(
+            op, &op->src, EcsQuerySrc, ctx);
+        if (!src_table) {
+            continue;
+        }
+        
+        redo = true;
+
+        if (!src_written && oper == EcsOrFrom) {
+            /* Eliminate duplicate matches from tables that have multiple 
+             * components from the type list */
+            if (op_ctx->cur_id_index != op_ctx->first_id_index) {
+                for (i = op_ctx->first_id_index; i < op_ctx->cur_id_index; i ++) {
+                    ecs_id_record_t *idr = flecs_id_record_get(world, ids[i]);
+                    if (!idr) {
+                        continue;
+                    }
+
+                    if (idr->flags & EcsIdDontInherit) {
+                        continue;
+                    }
+                    
+                    if (flecs_id_record_get_table(idr, src_table) != NULL) {
+                        /* Already matched */
+                        break;
+                    }
+                }
+                if (i != op_ctx->cur_id_index) {
+                    continue;
+                }
+            }
+            return true;
+        }
+
+        if (oper == EcsAndFrom || oper == EcsNotFrom || src_written) {
+            for (i = id_index; i < type->count; i ++) {
+                ecs_id_record_t *idr = flecs_id_record_get(world, ids[i]);
+                if (!idr) {
+                    if (oper == EcsAndFrom) {
+                        return false;
+                    } else {
+                        continue;
+                    }
+                }
+
+                if (idr->flags & EcsIdDontInherit) {
+                    continue;
+                }
+
+                if (flecs_id_record_get_table(idr, src_table) == NULL) {
+                    if (oper == EcsAndFrom) {
+                        break; /* Must have all ids */
+                    }
+                } else {
+                    if (oper == EcsNotFrom) {
+                        break; /* Must have none of the ids */
+                    } else if (oper == EcsOrFrom) {
+                        return true; /* Single match is enough */
+                    }
+                }
+            }
+
+            if (i == type->count) {
+                if (oper == EcsAndFrom || oper == EcsNotFrom) {
+                    break; /* All ids matched */
+                }
+            }
+        }
+    } while (true);
+
+    return true;
+}
+
+static
+bool flecs_query_and_from(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_x_from(op, redo, ctx, EcsAndFrom);
+}
+
+static
+bool flecs_query_not_from(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_x_from(op, redo, ctx, EcsNotFrom);
+}
+
+static
+bool flecs_query_or_from(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_x_from(op, redo, ctx, EcsOrFrom);
+}
+
+static
+bool flecs_query_ids(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (redo) {
+        return false;
+    }
+
+    ecs_id_record_t *cur;
+    ecs_id_t id = flecs_query_op_get_id(op, ctx);
+
+    {
+        cur = flecs_id_record_get(ctx->world, id);
+        if (!cur || !cur->cache.tables.count) {
+            return false;
+        }
+    }
+
+    flecs_query_set_vars(op, cur->id, ctx);
+
+    if (op->field_index != -1) {
+        ecs_iter_t *it = ctx->it;
+        it->ids[op->field_index] = id;
+        it->sources[op->field_index] = EcsWildcard;
+        it->columns[op->field_index] = -1; /* Mark field as set */
+    }
+
+    return true;
+}
+
+static
+bool flecs_query_idsright(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_ids_ctx_t *op_ctx = flecs_op_ctx(ctx, ids);
+    ecs_id_record_t *cur;
+
+    if (!redo) {
+        ecs_id_t id = flecs_query_op_get_id(op, ctx);
+        if (!ecs_id_is_wildcard(id)) {
+            /* If id is not a wildcard, we can directly return it. This can 
+             * happen if a variable was constrained by an iterator. */
+            op_ctx->cur = NULL;
+            flecs_query_set_vars(op, id, ctx);
+            return true;
+        }
+
+        cur = op_ctx->cur = flecs_id_record_get(ctx->world, id);
+        if (!cur) {
+            return false;
+        }
+    } else {
+        if (!op_ctx->cur) {
+            return false;
+        }
+    }
+
+    do {
+        cur = op_ctx->cur = op_ctx->cur->first.next;
+    } while (cur && !cur->cache.tables.count); /* Skip empty ids */
+
+    if (!cur) {
+        return false;
+    }
+
+    flecs_query_set_vars(op, cur->id, ctx);
+
+    if (op->field_index != -1) {
+        ecs_iter_t *it = ctx->it;
+        ecs_id_t id = flecs_query_op_get_id_w_written(op, op->written, ctx);
+        it->ids[op->field_index] = id;
+        it->sources[op->field_index] = EcsWildcard;
+        ECS_TERMSET_SET(it->set_fields, 1u << op->field_index);
+    }
+
+    return true;
+}
+
+static
+bool flecs_query_idsleft(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_ids_ctx_t *op_ctx = flecs_op_ctx(ctx, ids);
+    ecs_id_record_t *cur;
+
+    if (!redo) {
+        ecs_id_t id = flecs_query_op_get_id(op, ctx);
+        if (!ecs_id_is_wildcard(id)) {
+            /* If id is not a wildcard, we can directly return it. This can 
+             * happen if a variable was constrained by an iterator. */
+            op_ctx->cur = NULL;
+            flecs_query_set_vars(op, id, ctx);
+            return true;
+        }
+
+        cur = op_ctx->cur = flecs_id_record_get(ctx->world, id);
+        if (!cur) {
+            return false;
+        }
+    } else {
+        if (!op_ctx->cur) {
+            return false;
+        }
+    }
+
+    do {
+        cur = op_ctx->cur = op_ctx->cur->second.next;
+    } while (cur && !cur->cache.tables.count); /* Skip empty ids */ 
+
+    if (!cur) {
+        return false;
+    }
+
+    flecs_query_set_vars(op, cur->id, ctx);
+
+    if (op->field_index != -1) {
+        ecs_iter_t *it = ctx->it;
+        ecs_id_t id = flecs_query_op_get_id_w_written(op, op->written, ctx);
+        it->ids[op->field_index] = id;
+        it->sources[op->field_index] = EcsWildcard;
+        ECS_TERMSET_SET(it->set_fields, 1u << op->field_index);
+    }
+
+    return true;
+}
+
+static
+bool flecs_query_each(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_each_ctx_t *op_ctx = flecs_op_ctx(ctx, each);
+    int32_t row;
+
+    ecs_table_range_t range = flecs_query_var_get_range(op->first.var, ctx);
+    ecs_table_t *table = range.table;
+    if (!table) {
+        return false;
+    }
+
+    if (!redo) {
+        row = op_ctx->row = range.offset;
+    } else {
+        int32_t end = range.count;
+        if (end) {
+            end += range.offset;
+        } else {
+            end = table->data.entities.count;
+        }
+        row = ++ op_ctx->row;
+        if (op_ctx->row >= end) {
+            return false;
+        }
+    }
+
+    ecs_assert(row < ecs_table_count(table), ECS_INTERNAL_ERROR, NULL);
+    ecs_entity_t *entities = table->data.entities.array;
+    flecs_query_var_set_entity(op, op->src.var, entities[row], ctx);
+
+    return true;
+}
+
+static
+bool flecs_query_store(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (!redo) {
+        flecs_query_var_set_entity(op, op->src.var, op->first.entity, ctx);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+static
+bool flecs_query_reset(
+    const ecs_query_op_t *op,
+    bool redo,
+    const ecs_query_run_ctx_t *ctx)
+{
+    if (!redo) {
+        return true;
+    } else {
+        flecs_query_var_reset(op->src.var, ctx);
+        return false;
+    }
+}
+
+static
+const char* flecs_query_name_arg(
+    const ecs_query_op_t *op,
+    ecs_query_run_ctx_t *ctx)
+{
+    int8_t term_index = op->term_index;
+    const ecs_term_t *term = &ctx->query->pub.terms[term_index];
+    return term->second.name;
+}
+
+static
+bool flecs_query_compare_range(
+    const ecs_table_range_t *l,
+    const ecs_table_range_t *r)
+{
+    if (l->table != r->table) {
+        return false;
+    }
+
+    if (l->count) {
+        int32_t l_end = l->offset + l->count;
+        int32_t r_end = r->offset + r->count;
+        if (r->offset < l->offset) {
+            return false;
+        }
+        if (r_end > l_end) {
+            return false;
+        }
+    } else {
+        /* Entire table is matched */
+    }
+
+    return true;
+}
+
+static
+bool flecs_query_pred_eq_w_range(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    ecs_table_range_t r)
+{
+    if (redo) {
+        return false;
+    }
+
+    uint64_t written = ctx->written[ctx->op_index];
+    ecs_var_id_t src_var = op->src.var;
+    if (!(written & (1ull << src_var))) {
+        /* left = unknown, right = known. Assign right-hand value to left */
+        ecs_var_id_t l = src_var;
+        ctx->vars[l].range = r;
+        if (r.count == 1) {
+            ctx->vars[l].entity = ecs_vec_get_t(&r.table->data.entities, 
+                ecs_entity_t, r.offset)[0];
+        }
+        return true;
+    } else {
+        ecs_table_range_t l = flecs_query_get_range(
+            op, &op->src, EcsQuerySrc, ctx);
+
+        if (!flecs_query_compare_range(&l, &r)) {
+            return false;
+        }
+
+        ctx->vars[src_var].range.offset = r.offset;
+        ctx->vars[src_var].range.count = r.count;
+        return true;
+    }
+}
+
+static
+bool flecs_query_pred_eq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index]; (void)written;
+    ecs_assert(flecs_ref_is_written(op, &op->second, EcsQuerySecond, written),
+        ECS_INTERNAL_ERROR, 
+            "invalid instruction sequence: uninitialized eq operand");
+
+    ecs_table_range_t r = flecs_query_get_range(
+        op, &op->second, EcsQuerySecond, ctx);
+    return flecs_query_pred_eq_w_range(op, redo, ctx, r);
+}
+
+static
+bool flecs_query_pred_eq_name(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    const char *name = flecs_query_name_arg(op, ctx);
+    ecs_entity_t e = ecs_lookup(ctx->world, name);
+    if (!e) {
+        /* Entity doesn't exist */
+        return false;
+    }
+
+    ecs_table_range_t r = flecs_range_from_entity(e, ctx);
+    return flecs_query_pred_eq_w_range(op, redo, ctx, r);
+}
+
+static
+bool flecs_query_pred_neq_w_range(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    ecs_table_range_t r)
+{
+    ecs_query_eq_ctx_t *op_ctx = flecs_op_ctx(ctx, eq);
+    ecs_var_id_t src_var = op->src.var;
+    ecs_table_range_t l = flecs_query_get_range(
+        op, &op->src, EcsQuerySrc, ctx);
+
+    /* If tables don't match, neq always returns once */
+    if (l.table != r.table) {
+        return true && !redo;
+    }
+
+    int32_t l_offset;
+    int32_t l_count;
+    if (!redo) {
+        /* Make sure we're working with the correct table count */
+        if (!l.count && l.table) {
+            l.count = ecs_table_count(l.table);
+        }
+
+        l_offset = l.offset;
+        l_count = l.count;
+
+        /* Cache old value */
+        op_ctx->range = l;
+    } else {
+        l_offset = op_ctx->range.offset;
+        l_count = op_ctx->range.count;
+    }
+
+    /* If the table matches, a Neq returns twice: once for the slice before the
+     * excluded slice, once for the slice after the excluded slice. If the right
+     * hand range starts & overlaps with the left hand range, there is only
+     * one slice. */
+    ecs_var_t *var = &ctx->vars[src_var];
+    if (!redo && r.offset > l_offset) {
+        int32_t end = r.offset;
+        if (end > l_count) {
+            end = l_count;
+        }
+
+        /* Return first slice */
+        var->range.table = l.table;
+        var->range.offset = l_offset;
+        var->range.count = end - l_offset;
+        op_ctx->redo = false;
+        return true;
+    } else if (!op_ctx->redo) {
+        int32_t l_end = op_ctx->range.offset + l_count;
+        int32_t r_end = r.offset + r.count;
+
+        if (l_end <= r_end) {
+            /* If end of existing range falls inside the excluded range, there's
+             * nothing more to return */
+            var->range = l;
+            return false;
+        }
+
+        /* Return second slice */
+        var->range.table = l.table;
+        var->range.offset = r_end;
+        var->range.count = l_end - r_end;
+
+        /* Flag so we know we're done the next redo */
+        op_ctx->redo = true;
+        return true;
+    } else {
+        /* Restore previous value */
+        var->range = l;
+        return false;
+    }
+}
+
+static
+bool flecs_query_pred_match(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    bool is_neq)
+{
+    ecs_query_eq_ctx_t *op_ctx = flecs_op_ctx(ctx, eq);
+    uint64_t written = ctx->written[ctx->op_index];
+    ecs_assert(flecs_ref_is_written(op, &op->src, EcsQuerySrc, written),
+        ECS_INTERNAL_ERROR, 
+            "invalid instruction sequence: uninitialized match operand");
+    (void)written;
+
+    ecs_var_id_t src_var = op->src.var;
+    const char *match = flecs_query_name_arg(op, ctx);
+    ecs_table_range_t l;
+    if (!redo) {
+        l = flecs_query_get_range(op, &op->src, EcsQuerySrc, ctx);
+        if (!l.table) {
+            return false;
+        }
+
+        if (!l.count) {
+            l.count = ecs_table_count(l.table);
+        }
+
+        op_ctx->range = l;
+        op_ctx->index = l.offset;
+        op_ctx->name_col = flecs_ito(int16_t,   
+            ecs_table_get_type_index(ctx->world, l.table, 
+                ecs_pair(ecs_id(EcsIdentifier), EcsName)));
+        if (op_ctx->name_col == -1) {
+            return is_neq;
+        }
+        op_ctx->name_col = flecs_ito(int16_t, 
+            l.table->column_map[op_ctx->name_col]);
+        ecs_assert(op_ctx->name_col != -1, ECS_INTERNAL_ERROR, NULL);
+    } else {
+        if (op_ctx->name_col == -1) {
+            /* Table has no name */
+            return false;
+        }
+
+        l = op_ctx->range;
+    }
+
+    const EcsIdentifier *names = l.table->data.columns[op_ctx->name_col].data.array;
+    int32_t count = l.offset + l.count, offset = -1;
+    for (; op_ctx->index < count; op_ctx->index ++) {
+        const char *name = names[op_ctx->index].value;
+        bool result = strstr(name, match);
+        if (is_neq) {
+            result = !result;
+        }
+
+        if (!result) {
+            if (offset != -1) {
+                break;
+            }
+        } else {
+            if (offset == -1) {
+                offset = op_ctx->index;
+            }
+        }
+    }
+
+    if (offset == -1) {
+        ctx->vars[src_var].range = op_ctx->range;
+        return false;
+    }
+
+    ctx->vars[src_var].range.offset = offset;
+    ctx->vars[src_var].range.count = (op_ctx->index - offset);
+    return true;
+}
+
+static
+bool flecs_query_pred_eq_match(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_pred_match(op, redo, ctx, false);
+}
+
+static
+bool flecs_query_pred_neq_match(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_pred_match(op, redo, ctx, true);
+}
+
+static
+bool flecs_query_member_cmp(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    bool neq)
+{
+    ecs_table_range_t range;
+    if (op->other) {
+        ecs_var_id_t table_var = flecs_itovar(op->other - 1);
+        range = flecs_query_var_get_range(table_var, ctx);
+    } else {
+        range = flecs_query_get_range(op, &op->src, EcsQuerySrc, ctx);
+    }
+
+    ecs_table_t *table = range.table;
+    if (!table) {
+        return false;
+    }
+
+    ecs_query_membereq_ctx_t *op_ctx = flecs_op_ctx(ctx, membereq);
+    ecs_iter_t *it = ctx->it;
+    int8_t field_index = op->field_index;
+
+    if (!range.count) {
+        range.count = ecs_table_count(range.table); 
+    }
+
+    int32_t row, end = range.count;
+    if (end) {
+        end += range.offset;
+    } else {
+        end = ecs_table_count(range.table);
+    }
+
+    void *data;
+    if (!redo) {
+        row = op_ctx->each.row = range.offset;
+
+        /* Get data ptr starting from offset 0 so we can use row to index */
+        range.offset = 0;
+
+        /* Populate data field so we have the array we can compare the member
+         * value against. */
+        void *old_data = it->ptrs[field_index];
+        flecs_query_populate_field_from_range(
+            it, &range, field_index, it->columns[field_index]);
+        data = op_ctx->data = it->ptrs[field_index];
+
+        /* Ensure we only write ptrs when we match data */
+        it->ptrs[field_index] = old_data;
+
+        /* Member fields are of type ecs_entity_t */
+        #ifdef FLECS_META
+        it->ids[field_index] = ecs_id(ecs_entity_t);
+        #else
+        it->ids[field_index] = 0;
+        #endif
+    } else {
+        row = ++ op_ctx->each.row;
+        if (op_ctx->each.row >= end) {
+            return false;
+        }
+
+        data = op_ctx->data;
+    }
+
+    int32_t offset = (int32_t)op->first.entity;
+    int32_t size = (int32_t)(op->first.entity >> 32);
+    ecs_entity_t *entities = table->data.entities.array;
+    ecs_entity_t e = 0;
+    ecs_entity_t *val;
+
+    ecs_assert(row < ecs_table_count(table), ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); /* Must be written */
+    ecs_assert(entities != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    bool second_written = true;
+    if (op->flags & (EcsQueryIsVar << EcsQuerySecond)) {
+        uint64_t written = ctx->written[ctx->op_index];
+        second_written = written & (1ull << op->second.var);
+    }
+
+    if (second_written) {
+        ecs_flags16_t second_flags = flecs_query_ref_flags(
+            op->flags, EcsQuerySecond);
+        ecs_entity_t second = flecs_get_ref_entity(
+            &op->second, second_flags, ctx);
+
+        do {
+            e = entities[row];
+
+            val = ECS_OFFSET(ECS_ELEM(data, size, row), offset);
+            if (val[0] == second || second == EcsWildcard) {
+                if (!neq) {
+                    goto match;
+                }
+            } else {
+                if (neq) {
+                    goto match;
+                }
+            }
+
+            row ++;
+        } while (row < end);
+
+        return false;
+    } else {
+        e = entities[row];
+        val = ECS_OFFSET(ECS_ELEM(data, size, row), offset);
+        flecs_query_var_set_entity(op, op->second.var, val[0], ctx);
+    }
+
+match:
+    if (op->other) {
+        ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL);
+        flecs_query_var_set_entity(op, op->src.var, e, ctx);
+    }
+
+    it->ptrs[field_index] = val;
+    op_ctx->each.row = row;
+
+    return true;
+}
+
+static
+bool flecs_query_member_eq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_member_cmp(op, redo, ctx, false);
+}
+
+static
+bool flecs_query_member_neq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    return flecs_query_member_cmp(op, redo, ctx, true);
+}
+
+typedef struct {
+    ecs_flags64_t mask;
+    bool has_bitset;
+} flecs_query_row_mask_t;
+
+static
+flecs_query_row_mask_t flecs_query_get_row_mask(
+    ecs_iter_t *it,
+    ecs_table_t *table,
+    int32_t block_index,
+    ecs_flags64_t and_fields,
+    ecs_flags64_t not_fields,
+    ecs_query_toggle_ctx_t *op_ctx)
+{
+    ecs_flags64_t mask = UINT64_MAX;
+    int32_t i, field_count = it->field_count;
+    ecs_flags64_t fields = and_fields | not_fields;
+    bool has_bitset = false;
+
+    for (i = 0; i < field_count; i ++) {
+        uint64_t field_bit = 1llu << i;
+        if (!(fields & field_bit)) {
+            continue;
+        }
+
+        if (not_fields & field_bit) {
+            it->set_fields &= (ecs_termset_t)~field_bit;
+        } else if (and_fields & field_bit) {
+            ecs_assert(it->set_fields & field_bit, ECS_INTERNAL_ERROR, NULL);
+        } else {
+            ecs_abort(ECS_INTERNAL_ERROR, NULL);
+        }
+
+        ecs_id_t id = it->ids[i];
+        ecs_bitset_t *bs = flecs_table_get_toggle(table, id);
+        if (!bs) {
+            if (not_fields & field_bit) {
+                if (op_ctx->prev_set_fields & field_bit) {
+                    has_bitset = false;
+                    break;
+                }
+            }
+            continue;
+        }
+
+        ecs_assert((64 * block_index) < bs->size, ECS_INTERNAL_ERROR, NULL);
+        ecs_flags64_t block = bs->data[block_index];
+
+        if (not_fields & field_bit) {
+            block = ~block;
+        }
+        mask &= block;
+        has_bitset = true;
+    }
+
+    return (flecs_query_row_mask_t){ mask, has_bitset };
+}
+
+static
+bool flecs_query_toggle_for_up(
+    ecs_iter_t *it,
+    ecs_flags64_t and_fields,
+    ecs_flags64_t not_fields)
+{
+    int32_t i, field_count = it->field_count;
+    ecs_flags64_t fields = (and_fields | not_fields) & it->up_fields;
+
+    for (i = 0; i < field_count; i ++) {
+        uint64_t field_bit = 1llu << i;
+        if (!(fields & field_bit)) {
+            continue;
+        }
+
+        bool match = false;
+        if ((it->set_fields & field_bit)) {
+            ecs_entity_t src = it->sources[i];
+            ecs_assert(src != 0, ECS_INTERNAL_ERROR, NULL);
+            match = ecs_is_enabled_id(it->world, src, it->ids[i]);
+        }
+
+        if (field_bit & not_fields) {
+            match = !match;
+        }
+
+        if (!match) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static
+bool flecs_query_toggle_cmp(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    ecs_flags64_t and_fields,
+    ecs_flags64_t not_fields)
+{
+    ecs_iter_t *it = ctx->it;
+    ecs_query_toggle_ctx_t *op_ctx = flecs_op_ctx(ctx, toggle);
+    ecs_table_range_t range = flecs_query_get_range(
+        op, &op->src, EcsQuerySrc, ctx);
+    ecs_table_t *table = range.table;
+    ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
+
+    if ((and_fields & op_ctx->prev_set_fields) != and_fields) {
+        /* If not all fields matching and toggles are set, table can't match */
+        return false;
+    }
+
+    ecs_flags32_t up_fields = it->up_fields;
+    if (!redo) {
+        if (up_fields & (and_fields|not_fields)) {
+            /* If there are toggle fields that were matched with query 
+             * traversal, evaluate those separately. */
+            if (!flecs_query_toggle_for_up(it, and_fields, not_fields)) {
+                return false;
+            }
+
+            it->set_fields &= (ecs_termset_t)~(not_fields & up_fields);
+        }
+    }
+
+    /* Shared fields are evaluated, can be ignored from now on */
+    // and_fields &= ~up_fields;
+    not_fields &= ~up_fields;
+
+    if (!(table->flags & EcsTableHasToggle)) {
+        if (not_fields) {
+            /* If any of the toggle fields with a not operator are for fields
+             * that are set, without a bitset those fields can't match. */
+            return false;
+        } else {
+            /* If table doesn't have toggles but query matched toggleable 
+             * components, all entities match. */
+            if (!redo) {            
+                return true;
+            } else {
+                return false;
+            }
+        }
+    }
+
+    if (table && !range.count) {
+        range.count = ecs_table_count(table);
+        if (!range.count) {
+            return false;
+        }
+    }
+
+    int32_t i, j;
+    int32_t first, last, block_index, cur;
+    uint64_t block = 0;
+    if (!redo) {
+        op_ctx->range = range;
+        cur = op_ctx->cur = range.offset;
+        block_index = op_ctx->block_index = -1;
+        first = range.offset;
+        last = range.offset + range.count;
+    } else {
+        if (!op_ctx->has_bitset) {
+            goto done;
+        }
+
+        last = op_ctx->range.offset + op_ctx->range.count;
+        cur = op_ctx->cur;
+        ecs_assert(cur <= last, ECS_INTERNAL_ERROR, NULL);
+        if (cur == last) {
+            goto done;
+        }
+
+        first = cur;
+        block_index = op_ctx->block_index;
+        block = op_ctx->block;
+    }
+
+    /* If end of last iteration is start of new block, compute new block */    
+    int32_t new_block_index = cur / 64, row = first;
+    if (new_block_index != block_index) {
+compute_block:
+        block_index = op_ctx->block_index = new_block_index;
+
+        flecs_query_row_mask_t row_mask = flecs_query_get_row_mask(
+            it, table, block_index, and_fields, not_fields, op_ctx);
+
+        /* If table doesn't have bitset columns, all columns match */
+        if (!(op_ctx->has_bitset = row_mask.has_bitset)) {
+            if (!not_fields) {
+                return true;
+            } else {
+                goto done;
+            }
+        }
+
+        /* No enabled bits */
+        block = row_mask.mask;
+        if (!block) {
+next_block:
+            new_block_index ++;
+            cur = new_block_index * 64;
+            if (cur >= last) {
+                /* No more rows */
+                goto done;
+            }
+
+            op_ctx->cur = cur;
+            goto compute_block;
+        }
+
+        op_ctx->block = block;
+    }
+
+    /* Find first enabled bit (TODO: use faster bitmagic) */
+    int32_t first_bit = cur - (block_index * 64);
+    int32_t last_bit = ECS_MIN(64, last - (block_index * 64));
+    ecs_assert(first_bit >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(first_bit < 64, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(last_bit >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(last_bit <= 64, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(last_bit >= first_bit, ECS_INTERNAL_ERROR, NULL);
+
+    for (i = first_bit; i < last_bit; i ++) {
+        uint64_t bit = (1ull << i);
+        bool cond = 0 != (block & bit);
+        if (cond) {
+            /* Find last enabled bit */
+            for (j = i; j < last_bit; j ++) {
+                bit = (1ull << j);
+                cond = !(block & bit);
+                if (cond) {
+                    break;
+                }
+            }
+
+            row = i + (block_index * 64);
+            cur = j + (block_index * 64);
+            break;
+        }
+    }
+
+    if (i == last_bit) {
+        goto next_block;
+    }
+
+    ecs_assert(row >= first, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cur <= last, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cur >= first, ECS_INTERNAL_ERROR, NULL);
+
+    if (!(cur - row)) {
+        goto done;
+    }
+
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        flecs_query_var_narrow_range(op->src.var, table, row, cur - row, ctx);
+    }
+    op_ctx->cur = cur;
+
+    return true;
+
+done:
+    /* Restore range & set fields */
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        flecs_query_var_narrow_range(op->src.var, 
+            table, op_ctx->range.offset, op_ctx->range.count, ctx);
+    }
+
+    it->set_fields = op_ctx->prev_set_fields;
+    return false;
+}
+
+static
+bool flecs_query_toggle(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    ecs_iter_t *it = ctx->it;
+    ecs_query_toggle_ctx_t *op_ctx = flecs_op_ctx(ctx, toggle);
+    if (!redo) {
+        op_ctx->prev_set_fields = it->set_fields;
+    }
+
+    ecs_flags64_t and_fields = op->first.entity;
+    ecs_flags64_t not_fields = op->second.entity & op_ctx->prev_set_fields;
+
+    return flecs_query_toggle_cmp(
+        op, redo, ctx, and_fields, not_fields);
+}
+
+static
+bool flecs_query_toggle_option(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    ecs_iter_t *it = ctx->it;
+    ecs_query_toggle_ctx_t *op_ctx = flecs_op_ctx(ctx, toggle);
+    if (!redo) {
+        op_ctx->prev_set_fields = it->set_fields;
+        op_ctx->optional_not = false;
+        op_ctx->has_bitset = false;
+    }
+
+repeat: {}
+    ecs_flags64_t and_fields = 0, not_fields = 0;
+    if (op_ctx->optional_not) {
+        not_fields = op->first.entity & op_ctx->prev_set_fields;
+    } else {
+        and_fields = op->first.entity;
+    }
+
+    bool result = flecs_query_toggle_cmp(
+        op, redo, ctx, and_fields, not_fields);
+    if (!result) {
+        if (!op_ctx->optional_not) {
+            /* Run the not-branch of optional fields */
+            op_ctx->optional_not = true;
+            it->set_fields = op_ctx->prev_set_fields;
+            redo = false;
+            goto repeat;
+        }
+    }
+
+    return result;
+}
+
+static
+bool flecs_query_pred_neq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    uint64_t written = ctx->written[ctx->op_index]; (void)written;
+    ecs_assert(flecs_ref_is_written(op, &op->second, EcsQuerySecond, written),
+        ECS_INTERNAL_ERROR, 
+            "invalid instruction sequence: uninitialized neq operand");
+
+    ecs_table_range_t r = flecs_query_get_range(
+        op, &op->second, EcsQuerySecond, ctx);
+    return flecs_query_pred_neq_w_range(op, redo, ctx, r);
+}
+
+static
+bool flecs_query_pred_neq_name(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    const char *name = flecs_query_name_arg(op, ctx);
+    ecs_entity_t e = ecs_lookup(ctx->world, name);
+    if (!e) {
+        /* Entity doesn't exist */
+        return true && !redo;
+    }
+
+    ecs_table_range_t r = flecs_range_from_entity(e, ctx);
+    return flecs_query_pred_neq_w_range(op, redo, ctx, r);
+}
+
+static
+bool flecs_query_lookup(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    if (redo) {
+        return false;
+    }
+
+    const ecs_query_impl_t *query = ctx->query;
+    ecs_entity_t first = flecs_query_var_get_entity(op->first.var, ctx);
+    ecs_query_var_t *var = &query->vars[op->src.var];
+
+    ecs_entity_t result = ecs_lookup_path_w_sep(ctx->world, first, var->lookup,
+        NULL, NULL, false);
+    if (!result) {
+        flecs_query_var_set_entity(op, op->src.var, EcsWildcard, ctx);
+        return false;
+    }
+
+    flecs_query_var_set_entity(op, op->src.var, result, ctx);
+
+    return true;
+}
+
+static
+bool flecs_query_setvars(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+
+    const ecs_query_impl_t *query = ctx->query;
+    const ecs_query_t *q = &query->pub;
+    ecs_var_id_t *src_vars = query->src_vars;
+    ecs_iter_t *it = ctx->it;
+
+    if (redo) {
+        return false;
+    }
+
+    int32_t i;
+    ecs_flags32_t up_fields = it->up_fields;
+    for (i = 0; i < q->field_count; i ++) {
+        ecs_var_id_t var_id = src_vars[i];
+        if (!var_id) {
+            continue;
+        }
+
+        if (up_fields & (1u << i)) {
+            continue;
+        }
+
+        it->sources[i] = flecs_query_var_get_entity(var_id, ctx);
+    }
+
+    return true;
+}
+
+static
+bool flecs_query_setthis(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_setthis_ctx_t *op_ctx = flecs_op_ctx(ctx, setthis);
+    ecs_var_t *vars = ctx->vars;
+    ecs_var_t *this_var = &vars[op->first.var];
+
+    if (!redo) {
+        /* Save values so we can restore them later */
+        op_ctx->range = vars[0].range;
+
+        /* Constrain This table variable to a single entity from the table */
+        vars[0].range = flecs_range_from_entity(this_var->entity, ctx);
+        vars[0].entity = this_var->entity;
+        return true;
+    } else {
+        /* Restore previous values, so that instructions that are operating on
+         * the table variable use all the entities in the table. */
+        vars[0].range = op_ctx->range;
+        vars[0].entity = 0;
+        return false;
+    }
+}
+
+static
+bool flecs_query_setfixed(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    const ecs_query_impl_t *query = ctx->query;
+    const ecs_query_t *q = &query->pub;
+    ecs_iter_t *it = ctx->it;
+
+    if (redo) {
+        return false;
+    }
+
+    int32_t i;
+    for (i = 0; i < q->term_count; i ++) {
+        const ecs_term_t *term = &q->terms[i];
+        const ecs_term_ref_t *src = &term->src;
+        if (src->id & EcsIsEntity) {
+            it->sources[term->field_index] = ECS_TERM_REF_ID(src);
+        }
+    }
+
+    return true;
+}
+
+static
+bool flecs_query_setids(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    const ecs_query_impl_t *query = ctx->query;
+    const ecs_query_t *q = &query->pub;
+    ecs_iter_t *it = ctx->it;
+
+    if (redo) {
+        return false;
+    }
+
+    int32_t i;
+    for (i = 0; i < q->term_count; i ++) {
+        const ecs_term_t *term = &q->terms[i];
+        it->ids[term->field_index] = term->id;
+    }
+
+    return true;
+}
+
+static
+bool flecs_query_setid(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    if (redo) {
+        return false;
+    }
+
+    ecs_assert(op->field_index != -1, ECS_INTERNAL_ERROR, NULL);
+    ctx->it->ids[op->field_index] = op->first.entity;
+    return true;
+}
+
+/* Check if entity is stored in table */
+static
+bool flecs_query_contain(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    if (redo) {
+        return false;
+    }
+
+    ecs_var_id_t src_id = op->src.var;
+    ecs_var_id_t first_id = op->first.var;
+
+    ecs_table_t *table = flecs_query_var_get_table(src_id, ctx);
+
+    ecs_entity_t e = flecs_query_var_get_entity(first_id, ctx);
+    return table == ecs_get_table(ctx->world, e);
+}
+
+/* Check if first and second id of pair from last operation are the same */
+static
+bool flecs_query_pair_eq(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    if (redo) {
+        return false;
+    }
+
+    ecs_iter_t *it = ctx->it;
+    ecs_id_t id = it->ids[op->field_index];
+    return ECS_PAIR_FIRST(id) == ECS_PAIR_SECOND(id);
+}
+
+static
+void flecs_query_reset_after_block(
+    const ecs_query_op_t *start_op,
+    ecs_query_run_ctx_t *ctx,
+    ecs_query_ctrl_ctx_t *op_ctx,
+    bool result)
+{
+    ecs_query_lbl_t op_index = start_op->next;
+    const ecs_query_op_t *op = &ctx->qit->ops[op_index];
+
+    int32_t field = op->field_index;
+    if (field == -1) {
+        goto done;
+    }
+
+    /* Set/unset field */
+    ecs_iter_t *it = ctx->it;
+    if (result) {
+        ECS_TERMSET_SET(it->set_fields, 1u << field);
+        return;
+    }
+
+    /* Reset state after a field was not matched */
+    ctx->written[op_index] = ctx->written[ctx->op_index];
+    ctx->op_index = op_index;
+    ECS_TERMSET_CLEAR(it->set_fields, 1u << field);
+
+    /* Ignore variables written by Not operation */
+    uint64_t *written = ctx->written;
+    uint64_t written_cur = written[op->prev + 1];
+    ecs_flags16_t flags_1st = flecs_query_ref_flags(op->flags, EcsQueryFirst);
+    ecs_flags16_t flags_2nd = flecs_query_ref_flags(op->flags, EcsQuerySecond);
+
+    /* Overwrite id with cleared out variables */
+    ecs_id_t id = flecs_query_op_get_id(op, ctx);
+    if (id) {
+        it->ids[field] = id;
+    }
+
+    /* Reset variables */
+    if (flags_1st & EcsQueryIsVar) {
+        if (!flecs_ref_is_written(op, &op->first, EcsQueryFirst, written_cur)){
+            flecs_query_var_reset(op->first.var, ctx);
+        }
+    }
+    if (flags_2nd & EcsQueryIsVar) {
+        if (!flecs_ref_is_written(op, &op->second, EcsQuerySecond, written_cur)){
+            flecs_query_var_reset(op->second.var, ctx);
+        }
+    }
+
+    /* If term has entity src, set it because no other instruction might */
+    if (op->flags & (EcsQueryIsEntity << EcsQuerySrc)) {
+        it->sources[field] = op->src.entity;
+    }
+
+done:
+    op_ctx->op_index = op_index;
+}
+
+static
+bool flecs_query_run_block(
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    ecs_query_ctrl_ctx_t *op_ctx)
+{
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+
+    if (!redo) {
+        op_ctx->op_index = flecs_itolbl(ctx->op_index + 1);
+    } else if (ctx->qit->ops[op_ctx->op_index].kind == EcsQueryEnd) {
+        return false;
+    }
+
+    ctx->written[ctx->op_index + 1] = ctx->written[ctx->op_index];
+
+    const ecs_query_op_t *op = &ctx->qit->ops[ctx->op_index];
+    bool result = flecs_query_run_until(
+        redo, ctx, qit->ops, ctx->op_index, op_ctx->op_index, op->next);
+
+    op_ctx->op_index = flecs_itolbl(ctx->op_index - 1);
+    return result;
+}
+
+static
+ecs_query_lbl_t flecs_query_last_op_for_or_cond(
+    const ecs_query_op_t *ops,
+    ecs_query_lbl_t cur,
+    ecs_query_lbl_t last)
+{
+    const ecs_query_op_t *cur_op, *last_op = &ops[last];
+
+    do {
+        cur_op = &ops[cur];
+        cur ++;
+    } while (cur_op->next != last && cur_op != last_op);
+
+    return cur;
+}
+
+static
+bool flecs_query_run_until_for_select_or(
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    const ecs_query_op_t *ops,
+    ecs_query_lbl_t first,
+    ecs_query_lbl_t cur,
+    int32_t last)
+{
+    ecs_query_lbl_t last_for_cur = flecs_query_last_op_for_or_cond(
+        ops, cur, flecs_itolbl(last));
+    if (redo) {
+        /* If redoing, start from the last instruction of the last executed 
+         * sequence */
+        cur = flecs_itolbl(last_for_cur - 1);
+    }
+
+    flecs_query_run_until(redo, ctx, ops, first, cur, last_for_cur);
+#ifdef FLECS_QUERY_TRACE
+    printf("%*s%s (or)\n", (flecs_query_trace_indent + 1)*2, "",
+        ctx->op_index == last ? "true" : "false");
+#endif
+    return ctx->op_index == last;
+}
+
+static
+bool flecs_query_select_or(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    ecs_iter_t *it = ctx->it;
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+
+    ecs_query_lbl_t first = flecs_itolbl(ctx->op_index + 1);
+    if (!redo) {
+        op_ctx->op_index = first;
+    }
+
+    const ecs_query_op_t *ops = qit->ops;
+    const ecs_query_op_t *first_op = &ops[first - 1];
+    ecs_query_lbl_t last = first_op->next;
+    const ecs_query_op_t *last_op = &ops[last];
+    const ecs_query_op_t *cur_op = &ops[op_ctx->op_index];
+    bool result = false;
+
+    do {
+        ecs_query_lbl_t cur = op_ctx->op_index;
+        ctx->op_index = cur;
+        ctx->written[cur] = op->written;
+
+        result = flecs_query_run_until_for_select_or(
+            redo, ctx, ops, flecs_itolbl(first - 1), cur, last);
+
+        if (result) {
+            if (first == cur) {
+                break;
+            }
+
+            /* If a previous operation in the OR chain returned a result for the
+             * same matched source, skip it so we don't yield for each matching
+             * element in the chain. */
+
+            /* Copy written status so that the variables we just wrote will show
+             * up as written for the test. This ensures that the instructions
+             * match against the result we already found, vs. starting a new
+             * search (the difference between select & with). */
+            ecs_query_lbl_t prev = first;
+            bool dup_found = false;
+
+            /* While terms of an OR chain always operate on the same source, it
+             * is possible that a table variable is resolved to an entity 
+             * variable. When checking for duplicates, copy the entity variable
+             * to the table, to ensure we're only testing the found entity. */
+            const ecs_query_op_t *prev_op = &ops[cur - 1];
+            ecs_var_t old_table_var;
+            ecs_os_memset_t(&old_table_var, 0, ecs_var_t);
+            bool restore_table_var = false;
+            
+            if (prev_op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+                if (first_op->src.var != prev_op->src.var) {
+                    restore_table_var = true;
+                    old_table_var = ctx->vars[first_op->src.var];
+                    ctx->vars[first_op->src.var] = 
+                        ctx->vars[prev_op->src.var];
+                }
+            }
+
+            do {
+                ctx->written[prev] = ctx->written[last];
+
+                flecs_query_run_until(false, ctx, ops, flecs_itolbl(first - 1), 
+                    prev, cur);
+
+                if (ctx->op_index == last) {
+                    /* Duplicate match was found, find next result */
+                    redo = true;
+                    dup_found = true;
+                    break;
+                }
+
+                break;
+            } while (true);
+
+            /* Restore table variable to full range for next result */
+            if (restore_table_var) {
+                ctx->vars[first_op->src.var] = old_table_var;
+            }
+
+            if (dup_found) {
+                continue;
+            }
+
+            break;
+        }
+
+        /* No result was found, go to next operation in chain */
+        op_ctx->op_index = flecs_query_last_op_for_or_cond(
+            ops, op_ctx->op_index, last);
+        cur_op = &qit->ops[op_ctx->op_index];
+
+        redo = false;
+    } while (cur_op != last_op);
+
+    return result;
+}
+
+static
+bool flecs_query_with_or(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+
+    bool result = flecs_query_run_block(redo, ctx, op_ctx);
+    if (result) {
+        /* If a match was found, no need to keep searching for this source */
+        op_ctx->op_index = op->next;
+    }
+
+    return result;
+}
+
+static
+bool flecs_query_or(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    if (op->flags & (EcsQueryIsVar << EcsQuerySrc)) {
+        uint64_t written = ctx->written[ctx->op_index];
+        if (!(written & (1ull << op->src.var))) {
+            return flecs_query_select_or(op, redo, ctx);
+        }
+    }
+
+    return flecs_query_with_or(op, redo, ctx);
+}
+
+static
+bool flecs_query_run_block_w_reset(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+
+    bool result = flecs_query_run_block(redo, ctx, op_ctx);
+    flecs_query_reset_after_block(op, ctx, op_ctx, result);
+    return result;
+}
+
+static
+bool flecs_query_not(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    if (redo) {
+        return false;
+    }
+
+    return !flecs_query_run_block_w_reset(op, redo, ctx);
+}
+
+static
+bool flecs_query_optional(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{   
+    bool result = flecs_query_run_block_w_reset(op, redo, ctx);
+    if (!redo) {
+        return true; /* Return at least once */
+    } else {
+        return result;
+    }
+}
+
+static
+bool flecs_query_eval_if(
+    const ecs_query_op_t *op,
+    ecs_query_run_ctx_t *ctx,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t ref_kind)
+{
+    bool result = true;
+    if (flecs_query_ref_flags(op->flags, ref_kind) == EcsQueryIsVar) {
+        result = ctx->vars[ref->var].entity != EcsWildcard;
+        ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+        flecs_query_reset_after_block(op, ctx, op_ctx, result);
+        return result;
+    }
+    return true;
+}
+
+static
+bool flecs_query_if_var(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    if (!redo) {
+        if (!flecs_query_eval_if(op, ctx, &op->src, EcsQuerySrc) ||
+            !flecs_query_eval_if(op, ctx, &op->first, EcsQueryFirst) ||
+            !flecs_query_eval_if(op, ctx, &op->second, EcsQuerySecond))
+        {
+            return true;
+        }
+    }
+
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+    return flecs_query_run_block(redo, ctx, op_ctx);
+}
+
+static
+bool flecs_query_if_set(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    ecs_iter_t *it = ctx->it;
+    uint8_t field_index = flecs_ito(uint8_t, op->other);
+
+    ecs_query_ctrl_ctx_t *op_ctx = flecs_op_ctx(ctx, ctrl);
+    if (!redo) {
+        op_ctx->is_set = ecs_field_is_set(it, field_index);
+    }
+
+    if (!op_ctx->is_set) {
+        return !redo;
+    }
+
+    return flecs_query_run_block(redo, ctx, op_ctx);
+}
+
+static
+bool flecs_query_end(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    (void)op; (void)ctx;
+    return !redo;
+}
+
+static
+void flecs_query_populate_field_from_range(
+    ecs_iter_t *it,
+    ecs_table_range_t *range,
+    int8_t field_index,
+    int32_t index)
+{
+    ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(range->table != NULL, ECS_INTERNAL_ERROR, NULL);
+    if (range->count && range->table->column_map) {
+        int32_t column = range->table->column_map[index];
+        if (column != -1) {
+            it->ptrs[field_index] = ECS_ELEM(
+                range->table->data.columns[column].data.array,
+                it->sizes[field_index],
+                range->offset);
+        }
+    }
+}
+
+static
+void flecs_query_populate_field(
+    ecs_iter_t *it,
+    ecs_table_range_t *range,
+    int8_t field_index,
+    ecs_query_run_ctx_t *ctx)
+{
+    int32_t index = it->columns[field_index];
+    ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(ecs_field_is_set(it, field_index), ECS_INTERNAL_ERROR, NULL);
+
+    ecs_entity_t src = it->sources[field_index];
+    if (!src) {
+        flecs_query_populate_field_from_range(it, range, field_index, index);
+        ECS_TERMSET_CLEAR(it->shared_fields, 1u << field_index);
+    } else {
+        ecs_record_t *r = flecs_entities_get(ctx->world, src);
+        ecs_table_t *src_table = r->table;
+        if (src_table->column_map) {
+            int32_t column = src_table->column_map[index];
+            if (column != -1) {
+                it->ptrs[field_index] = ecs_vec_get(
+                    &src_table->data.columns[column].data,
+                    it->sizes[field_index],
+                    ECS_RECORD_TO_ROW(r->row));
+
+                ECS_TERMSET_SET(it->shared_fields, 1u << field_index);
+            }
+        }
+    }
+}
+
+static
+bool flecs_query_populate(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    if (!redo) {
+        ecs_iter_t *it = ctx->it;
+        if (it->flags & EcsIterNoData) {
+            return true;
+        }
+
+        const ecs_query_impl_t *query = ctx->query;
+        const ecs_query_t *q = &query->pub;
+        int8_t i, field_count = q->field_count;
+        ecs_flags64_t data_fields = op->src.entity; /* Bitset with fields to set */
+        ecs_table_range_t *range = &ctx->vars[0].range;
+        ecs_table_t *table = range->table;
+        if (table && !range->count) {
+            range->count = ecs_table_count(table);
+        }
+
+        /* Only populate fields that are set */
+        data_fields &= it->set_fields;
+        for (i = 0; i < field_count; i ++) {
+            if (!(data_fields & (1llu << i))) {
+                continue;
+            }
+
+            flecs_query_populate_field(it, range, i, ctx);
+        }
+
+        return true;
+    } else {
+        return false;
+    }
+}
+
+static
+bool flecs_query_populate_self(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    (void)op;
+    if (!redo) {
+        const ecs_query_impl_t *query = ctx->query;
+        const ecs_query_t *q = &query->pub;
+        int32_t i, field_count = q->field_count;
+        ecs_flags64_t data_fields = op->src.entity; /* Bitset with fields to set */
+        ecs_iter_t *it = ctx->it;
+
+        ecs_table_range_t *range = &ctx->vars[0].range;
+        ecs_table_t *table = range->table;
+        if (!table->column_map) {
+            return true;
+        }
+
+        if (!ecs_table_count(table)) {
+            return true;
+        }
+
+        /* Only populate fields that can be set */
+        data_fields &= it->set_fields;
+        for (i = 0; i < field_count; i ++) {
+            if (!(data_fields & (1llu << i))) {
+                continue;
+            }
+
+            int32_t index = it->columns[i];
+            ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL);
+
+            int32_t column = table->column_map[index];
+            if (column != -1) {
+                it->ptrs[i] = ECS_ELEM(
+                    table->data.columns[column].data.array,
+                    it->sizes[i],
+                    range->offset);
+            }
+        }
+
+        return true;
+    } else {
+        return false;
+    }
+}
+
+static
+bool flecs_query_dispatch(
+    const ecs_query_op_t *op,
+    bool redo,
+    ecs_query_run_ctx_t *ctx)
+{
+    switch(op->kind) {
+    case EcsQueryAnd: return flecs_query_and(op, redo, ctx);
+    case EcsQueryAndId: return flecs_query_and_id(op, redo, ctx);
+    case EcsQueryAndAny: return flecs_query_and_any(op, redo, ctx);
+    case EcsQueryTriv: return flecs_query_triv(op, redo, ctx);
+    case EcsQueryTrivData: return flecs_query_triv_data(op, redo, ctx);
+    case EcsQueryTrivWildcard: return flecs_query_triv_wildcard(op, redo, ctx);
+    case EcsQueryCache: return flecs_query_cache(op, redo, ctx);
+    case EcsQueryIsCache: return flecs_query_is_cache(op, redo, ctx);
+    case EcsQueryCacheData: return flecs_query_cache_data(op, redo, ctx);
+    case EcsQueryIsCacheData: return flecs_query_is_cache_data(op, redo, ctx);
+    case EcsQuerySelectAny: return flecs_query_select_any(op, redo, ctx);
+    case EcsQueryUp: return flecs_query_up(op, redo, ctx);
+    case EcsQueryUpId: return flecs_query_up_id(op, redo, ctx);
+    case EcsQuerySelfUp: return flecs_query_self_up(op, redo, ctx);
+    case EcsQuerySelfUpId: return flecs_query_self_up_id(op, redo, ctx);
+    case EcsQueryWith: return flecs_query_with(op, redo, ctx);
+    case EcsQueryTrav: return flecs_query_trav(op, redo, ctx);
+    case EcsQueryAndFrom: return flecs_query_and_from(op, redo, ctx);
+    case EcsQueryNotFrom: return flecs_query_not_from(op, redo, ctx);
+    case EcsQueryOrFrom: return flecs_query_or_from(op, redo, ctx);
+    case EcsQueryIds: return flecs_query_ids(op, redo, ctx);
+    case EcsQueryIdsRight: return flecs_query_idsright(op, redo, ctx);
+    case EcsQueryIdsLeft: return flecs_query_idsleft(op, redo, ctx);
+    case EcsQueryEach: return flecs_query_each(op, redo, ctx);
+    case EcsQueryStore: return flecs_query_store(op, redo, ctx);
+    case EcsQueryReset: return flecs_query_reset(op, redo, ctx);
+    case EcsQueryOr: return flecs_query_or(op, redo, ctx);
+    case EcsQueryOptional: return flecs_query_optional(op, redo, ctx);
+    case EcsQueryIfVar: return flecs_query_if_var(op, redo, ctx);
+    case EcsQueryIfSet: return flecs_query_if_set(op, redo, ctx);
+    case EcsQueryEnd: return flecs_query_end(op, redo, ctx);
+    case EcsQueryNot: return flecs_query_not(op, redo, ctx);
+    case EcsQueryPredEq: return flecs_query_pred_eq(op, redo, ctx);
+    case EcsQueryPredNeq: return flecs_query_pred_neq(op, redo, ctx);
+    case EcsQueryPredEqName: return flecs_query_pred_eq_name(op, redo, ctx);
+    case EcsQueryPredNeqName: return flecs_query_pred_neq_name(op, redo, ctx);
+    case EcsQueryPredEqMatch: return flecs_query_pred_eq_match(op, redo, ctx);
+    case EcsQueryPredNeqMatch: return flecs_query_pred_neq_match(op, redo, ctx);
+    case EcsQueryMemberEq: return flecs_query_member_eq(op, redo, ctx);
+    case EcsQueryMemberNeq: return flecs_query_member_neq(op, redo, ctx);
+    case EcsQueryToggle: return flecs_query_toggle(op, redo, ctx);
+    case EcsQueryToggleOption: return flecs_query_toggle_option(op, redo, ctx);
+    case EcsQueryLookup: return flecs_query_lookup(op, redo, ctx);
+    case EcsQuerySetVars: return flecs_query_setvars(op, redo, ctx);
+    case EcsQuerySetThis: return flecs_query_setthis(op, redo, ctx);
+    case EcsQuerySetFixed: return flecs_query_setfixed(op, redo, ctx);
+    case EcsQuerySetIds: return flecs_query_setids(op, redo, ctx);
+    case EcsQuerySetId: return flecs_query_setid(op, redo, ctx);
+    case EcsQueryContain: return flecs_query_contain(op, redo, ctx);
+    case EcsQueryPairEq: return flecs_query_pair_eq(op, redo, ctx);
+    case EcsQueryPopulate: return flecs_query_populate(op, redo, ctx);
+    case EcsQueryPopulateSelf: return flecs_query_populate_self(op, redo, ctx);
+    case EcsQueryYield: return false;
+    case EcsQueryNothing: return false;
+    }
+    return false;
+}
+
+static
+bool flecs_query_run_until(
+    bool redo,
+    ecs_query_run_ctx_t *ctx,
+    const ecs_query_op_t *ops,
+    ecs_query_lbl_t first,
+    ecs_query_lbl_t cur,
+    int32_t last)
+{
+    ecs_assert(first >= -1, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cur >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(cur > first, ECS_INTERNAL_ERROR, NULL);
+
+    ctx->op_index = cur;
+    const ecs_query_op_t *op = &ops[ctx->op_index];
+    const ecs_query_op_t *last_op = &ops[last];
+    ecs_assert(last > first, ECS_INTERNAL_ERROR, NULL);
+
+#ifdef FLECS_QUERY_TRACE
+    printf("%*sblock:\n", flecs_query_trace_indent*2, "");
+    flecs_query_trace_indent ++;
+#endif
+
+    do {
+        #ifdef FLECS_DEBUG
+        ctx->qit->profile[ctx->op_index].count[redo] ++;
+        #endif
+
+#ifdef FLECS_QUERY_TRACE
+        printf("%*s%d: %s\n", flecs_query_trace_indent*2, "", 
+            ctx->op_index, flecs_query_op_str(op->kind));
+#endif
+
+        bool result = flecs_query_dispatch(op, redo, ctx);
+        cur = (&op->prev)[result];
+        redo = cur < ctx->op_index;
+
+        if (!redo) {
+            ctx->written[cur] |= ctx->written[ctx->op_index] | op->written;
+        }
+
+        ctx->op_index = cur;
+        op = &ops[ctx->op_index];
+
+        if (cur <= first) {
+#ifdef FLECS_QUERY_TRACE
+            printf("%*sfalse\n", flecs_query_trace_indent*2, "");
+            flecs_query_trace_indent --;
+#endif
+            return false;
+        }
+    } while (op < last_op);
+    
+#ifdef FLECS_QUERY_TRACE
+        printf("%*strue\n", flecs_query_trace_indent*2, "");
+        flecs_query_trace_indent --;
+#endif
+
+    return true;
+}
+
+static
+void flecs_query_iter_init(
+    ecs_query_run_ctx_t *ctx)
+{
+    ecs_assert(ctx->written != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_iter_t *it = ctx->it;
+
+    const ecs_query_impl_t *query = ctx->query;
+    const ecs_query_t *q = &query->pub;
+    ecs_flags64_t it_written = it->constrained_vars;
+    ctx->written[0] = it_written;
+    if (it_written && ctx->query->src_vars) {
+        /* If variables were constrained, check if there are any table
+         * variables that have a constrained entity variable. */
+        ecs_var_t *vars = ctx->vars;
+        int32_t i, count = q->field_count;
+        for (i = 0; i < count; i ++) {
+            ecs_var_id_t var_id = query->src_vars[i];
+            ecs_query_var_t *var = &query->vars[var_id];
+
+            if (!(it_written & (1ull << var_id)) || 
+                (var->kind == EcsVarTable) || (var->table_id == EcsVarNone)) 
+            {
+                continue;
+            }
+
+            /* Initialize table variable with constrained entity variable */
+            ecs_var_t *tvar = &vars[var->table_id];
+            tvar->range = flecs_range_from_entity(vars[var_id].entity, ctx);
+            ctx->written[0] |= (1ull << var->table_id); /* Mark as written */
+        }
+    }
+
+    ecs_flags32_t flags = q->flags;
+    ecs_query_cache_t *cache = query->cache;
+    if (flags & EcsQueryIsTrivial && !cache) {
+        if ((flags & EcsQueryMatchOnlySelf) || 
+            !flecs_table_cache_all_count(&ctx->world->idr_isa_wildcard->cache)) 
+        {
+            if (it_written) {
+                flecs_query_set_iter_this(it, ctx);
+
+                if (flags & EcsQueryMatchWildcards) {
+                    it->flags |= EcsIterTrivialTestWildcard;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                } else {
+                    it->flags |= EcsIterTrivialTest;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                }
+            } else {
+                if (flags & EcsQueryMatchWildcards) {
+                    it->flags |= EcsIterTrivialSearchWildcard;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                } else if (flags & EcsQueryNoData) {
+                    it->flags |= EcsIterTrivialSearchNoData;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                } else {
+                    it->flags |= EcsIterTrivialSearch;
+                    flecs_query_setids(&query->ops[0], false, ctx);
+                }
+            }
+        }
+    }
+
+    if (cache) {
+        cache->prev_match_count = cache->match_count;
+    }
+
+    flecs_iter_validate(it);
+}
+
+bool ecs_query_next_instanced(
+    ecs_iter_t *it)
+{
+    ecs_assert(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_query_impl_t *impl = ECS_CONST_CAST(ecs_query_impl_t*, qit->query);
+    ecs_query_run_ctx_t ctx;
+    ctx.world = it->real_world;
+    ctx.query = impl;
+    ctx.it = it;
+    ctx.vars = qit->vars;
+    ctx.query_vars = qit->query_vars;
+    ctx.written = qit->written;
+    ctx.op_ctx = qit->op_ctx;
+    ctx.qit = qit;
+    const ecs_query_op_t *ops = qit->ops;
+
+    bool redo = true;
+    if (!(it->flags & EcsIterIsValid)) {
+        ecs_assert(impl != NULL, ECS_INVALID_PARAMETER, NULL);
+        flecs_query_iter_init(&ctx);
+        redo = false;
+    } else {
+        it->frame_offset += it->count;
+
+        if (!(it->flags & EcsIterSkip)) {
+            flecs_query_mark_fields_dirty(impl, it);
+            if (qit->prev) {
+                if (ctx.query->pub.flags & EcsQueryHasMonitor) {
+                    flecs_query_sync_match_monitor(impl, qit->prev);
+                }
+            }
+        }
+
+        it->flags &= ~EcsIterSkip;
+    }
+
+    /* Specialized iterator modes for trivial queries */
+    if (it->flags & EcsIterTrivialSearch) {
+        ecs_query_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_search(ctx.query, &ctx, op_ctx, !redo, mask)) {
+            goto done;
+        }
+        it->table = ctx.vars[0].range.table;
+        it->count = ecs_table_count(it->table);
+        it->entities = flecs_table_entities_array(it->table);
+        return true;
+    } else if (it->flags & EcsIterTrivialSearchNoData) {
+        ecs_query_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_search_nodata(ctx.query, &ctx, op_ctx, !redo, mask)) {
+            goto done;
+        }
+        it->table = ctx.vars[0].range.table;
+        it->count = ecs_table_count(it->table);
+        it->entities = flecs_table_entities_array(it->table);
+        return true;
+    } else if (it->flags & EcsIterTrivialSearchWildcard) {
+        ecs_query_trivial_ctx_t *op_ctx = &ctx.op_ctx[0].is.trivial;
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_search_w_wildcards(ctx.query, &ctx, op_ctx, !redo, mask)) {
+            goto done;
+        }
+        it->table = ctx.vars[0].range.table;
+        it->count = ecs_table_count(it->table);
+        it->entities = flecs_table_entities_array(it->table);
+        return true;
+    } else if (it->flags & EcsIterTrivialTest) {
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_test(ctx.query, &ctx, !redo, mask)) {
+            goto done;
+        }
+        return true;
+    } else if (it->flags & EcsIterTrivialTestWildcard) {
+        int32_t fields = ctx.query->pub.term_count;
+        ecs_flags64_t mask = (2llu << (fields - 1)) - 1;
+        if (!flecs_query_trivial_test_w_wildcards(ctx.query, &ctx, !redo, mask)) {
+            goto done;
+        }
+        return true;
+    }
+
+    /* Default iterator mode */
+    if (flecs_query_run_until(redo, &ctx, ops, -1, qit->op, impl->op_count - 1)) {
+        ecs_assert(ops[ctx.op_index].kind == EcsQueryYield, 
+            ECS_INTERNAL_ERROR, NULL);
+        flecs_query_set_iter_this(it, &ctx);
+        ecs_assert(it->count >= 0, ECS_INTERNAL_ERROR, NULL);
+        qit->op = flecs_itolbl(ctx.op_index - 1);
+        return true;
+    }
+
+done:
+    flecs_query_mark_fixed_fields_dirty(impl, it);
+    if (ctx.query->monitor) {
+        flecs_query_update_fixed_monitor(
+            ECS_CONST_CAST(ecs_query_impl_t*, ctx.query));
+    }
+
+    ecs_iter_fini(it);
+    return false;
+}
+
+bool ecs_query_next(
+    ecs_iter_t *it)
+{
+    ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL);
+
+    if (flecs_iter_next_row(it)) {
+        return true;
+    }
+
+    return flecs_iter_next_instanced(it, ecs_query_next_instanced(it));
+error:
+    return false;
+}
+
+static
+void flecs_query_iter_fini_ctx(
+    ecs_iter_t *it,
+    ecs_query_iter_t *qit)
+{
+    const ecs_query_impl_t *query = flecs_query_impl(qit->query);
+    int32_t i, count = query->op_count;
+    ecs_query_op_t *ops = query->ops;
+    ecs_query_op_ctx_t *ctx = qit->op_ctx;
+    ecs_allocator_t *a = flecs_query_get_allocator(it);
+
+    for (i = 0; i < count; i ++) {
+        ecs_query_op_t *op = &ops[i];
+        switch(op->kind) {
+        case EcsQueryTrav:
+            flecs_query_trav_cache_fini(a, &ctx[i].is.trav.cache);
+            break;
+        case EcsQueryUp:
+        case EcsQuerySelfUp:
+        case EcsQueryUpId:
+        case EcsQuerySelfUpId: {
+            ecs_trav_up_cache_t *cache = &ctx[i].is.up.cache;
+            if (cache->dir == EcsTravDown) {
+                flecs_query_down_cache_fini(a, cache);
+            } else {
+                flecs_query_up_cache_fini(cache);
+            }
+            break;
+        }
+        default:
+            break;
+        }
+    }
+}
+
+static
+void flecs_query_iter_fini(
+    ecs_iter_t *it)
+{
+    ecs_query_iter_t *qit = &it->priv_.iter.query;
+    ecs_assert(qit->query != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(qit->query, ecs_query_t);
+    int32_t op_count = flecs_query_impl(qit->query)->op_count;
+    int32_t var_count = flecs_query_impl(qit->query)->var_count;
+
+#ifdef FLECS_DEBUG
+    if (it->flags & EcsIterProfile) {
+        char *str = ecs_query_str_w_profile(qit->query, it);
+        printf("%s\n", str);
+        ecs_os_free(str);
+    }
+
+    flecs_iter_free_n(qit->profile, ecs_query_op_profile_t, op_count);
+#endif
+
+    flecs_query_iter_fini_ctx(it, qit);
+    flecs_iter_free_n(qit->vars, ecs_var_t, var_count);
+    flecs_iter_free_n(qit->written, ecs_write_flags_t, op_count);
+    flecs_iter_free_n(qit->op_ctx, ecs_query_op_ctx_t, op_count);
+    qit->vars = NULL;
+    qit->written = NULL;
+    qit->op_ctx = NULL;
+    qit->query = NULL;
+}
+
+ecs_iter_t flecs_query_iter(
+    const ecs_world_t *world,
+    const ecs_query_t *q)
+{
+    ecs_iter_t it = {0};
+    ecs_query_iter_t *qit = &it.priv_.iter.query;
+    ecs_check(q != NULL, ECS_INVALID_PARAMETER, NULL);
+    
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+
+    int32_t i, var_count = impl->var_count, op_count = impl->op_count;
+    it.world = ECS_CONST_CAST(ecs_world_t*, world);
+    it.real_world = q->world;
+    it.query = q;
+    it.system = q->entity;
+    it.next = ecs_query_next;
+    it.fini = flecs_query_iter_fini;
+    it.field_count = q->field_count;
+    it.sizes = q->sizes;
+    it.set_fields = q->set_fields;
+    it.up_fields = 0;
+    flecs_query_apply_iter_flags(&it, q);
+
+    flecs_iter_init(world, &it, 
+        flecs_iter_cache_ids |
+        flecs_iter_cache_columns |
+        flecs_iter_cache_sources |
+        flecs_iter_cache_ptrs);
+
+    qit->query = q;
+    qit->query_vars = impl->vars;
+    qit->ops = impl->ops;
+
+    ecs_query_cache_t *cache = impl->cache;
+    if (cache) {
+        qit->node = cache->list.first;
+        qit->last = cache->list.last;
+
+        if (cache->order_by_callback && cache->list.info.table_count) {
+            flecs_query_cache_sort_tables(it.real_world, impl);
+            qit->node = ecs_vec_first(&cache->table_slices);
+            qit->last = ecs_vec_last_t(
+                &cache->table_slices, ecs_query_cache_table_match_t);
+        }
+    }
+
+    if (var_count) {
+        qit->vars = flecs_iter_calloc_n(&it, ecs_var_t, var_count);
+    }
+
+    if (op_count) {
+        qit->written = flecs_iter_calloc_n(&it, ecs_write_flags_t, op_count);
+        qit->op_ctx = flecs_iter_calloc_n(&it, ecs_query_op_ctx_t, op_count);
+    }
+
+#ifdef FLECS_DEBUG
+    qit->profile = flecs_iter_calloc_n(&it, ecs_query_op_profile_t, op_count);
+#endif
+
+    for (i = 1; i < var_count; i ++) {
+        qit->vars[i].entity = EcsWildcard;
+    }
+
+    it.variables = qit->vars;
+    it.variable_count = impl->var_pub_count;
+    it.variable_names = impl->var_names;
+
+error:
+    return it;
+}
+
+ecs_iter_t ecs_query_iter(
+    const ecs_world_t *world,
+    const ecs_query_t *q)
+{
+    ecs_run_aperiodic(q->world, EcsAperiodicEmptyTables);
+
+    /* Ok, only for stats */
+    ECS_CONST_CAST(ecs_query_t*, q)->eval_count ++;
+
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+    ecs_query_cache_t *cache = impl->cache;
+    if (cache) {
+        /* If monitors changed, do query rematching */
+        ecs_flags32_t flags = q->flags;
+        if (!(world->flags & EcsWorldReadonly) && flags & EcsQueryHasRefs) {
+            flecs_eval_component_monitors(q->world);
+        }
+    }
+
+    return flecs_query_iter(world, q);
+}
diff --git a/src/query/query.h b/src/query/query.h
new file mode 100644
index 000000000..d154f32dc
--- /dev/null
+++ b/src/query/query.h
@@ -0,0 +1,29 @@
+ /**
+ * @file query/query.h
+ * @brief Query implementation.
+ */
+
+#include "compiler.h"
+#include "cache.h"
+#include "cache_iter.h"
+#include "change_detection.h"
+#include "trav_cache.h"
+#include "trivial_iter.h"
+#include "util.h"
+
+#ifdef FLECS_DEBUG
+#define flecs_set_var_label(var, lbl) (var)->label = lbl
+#else
+#define flecs_set_var_label(var, lbl)
+#endif
+
+/* Finalize query data & validate */
+int flecs_query_finalize_query(
+    ecs_world_t *world,
+    ecs_query_t *q,
+    const ecs_query_desc_t *desc);
+
+/* Internal function for creating iterator, doesn't run aperiodic tasks */
+ecs_iter_t flecs_query_iter(
+    const ecs_world_t *world,
+    const ecs_query_t *q);
diff --git a/src/addons/rules/trav_cache.c b/src/query/trav_cache.c
similarity index 82%
rename from src/addons/rules/trav_cache.c
rename to src/query/trav_cache.c
index 74855b865..71690c9f3 100644
--- a/src/addons/rules/trav_cache.c
+++ b/src/query/trav_cache.c
@@ -3,15 +3,13 @@
  * @brief Cache that stores the result of graph traversal.
  */
 
-#include "rules.h"
-
-#ifdef FLECS_RULES
+#include "../private_api.h"
 
 static
-void flecs_rule_build_down_cache(
+void flecs_query_build_down_cache(
     ecs_world_t *world,
     ecs_allocator_t *a,
-    const ecs_rule_run_ctx_t *ctx,
+    const ecs_query_run_ctx_t *ctx,
     ecs_trav_cache_t *cache,
     ecs_entity_t trav,
     ecs_entity_t entity)
@@ -41,7 +39,7 @@ void flecs_rule_build_down_cache(
             for (i = 0; i < count; i ++) {
                 ecs_record_t *r = flecs_entities_get(world, entities[i]);
                 if (r->row & EcsEntityIsTraversable) {
-                    flecs_rule_build_down_cache(
+                    flecs_query_build_down_cache(
                         world, a, ctx, cache, trav, entities[i]);
                 }
             }
@@ -50,10 +48,10 @@ void flecs_rule_build_down_cache(
 }
 
 static
-void flecs_rule_build_up_cache(
+void flecs_query_build_up_cache(
     ecs_world_t *world,
     ecs_allocator_t *a,
-    const ecs_rule_run_ctx_t *ctx,
+    const ecs_query_run_ctx_t *ctx,
     ecs_trav_cache_t *cache,
     ecs_entity_t trav,
     ecs_table_t *table,
@@ -83,44 +81,44 @@ void flecs_rule_build_up_cache(
             if (!r_tr) {
                 return;
             }
-            flecs_rule_build_up_cache(world, a, ctx, cache, trav, r->table, 
+            flecs_query_build_up_cache(world, a, ctx, cache, trav, r->table, 
                 r_tr, root_column);
         }
     }
 }
 
-void flecs_rule_trav_cache_fini(
+void flecs_query_trav_cache_fini(
     ecs_allocator_t *a,
     ecs_trav_cache_t *cache)
 {
     ecs_vec_fini_t(a, &cache->entities, ecs_trav_elem_t);
 }
 
-void flecs_rule_get_trav_down_cache(
-    const ecs_rule_run_ctx_t *ctx,
+void flecs_query_get_trav_down_cache(
+    const ecs_query_run_ctx_t *ctx,
     ecs_trav_cache_t *cache,
     ecs_entity_t trav,
     ecs_entity_t entity)
 {
     if (cache->id != ecs_pair(trav, entity) || cache->up) {
         ecs_world_t *world = ctx->it->real_world;
-        ecs_allocator_t *a = flecs_rule_get_allocator(ctx->it);
+        ecs_allocator_t *a = flecs_query_get_allocator(ctx->it);
         ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
-        flecs_rule_build_down_cache(world, a, ctx, cache, trav, entity);
+        flecs_query_build_down_cache(world, a, ctx, cache, trav, entity);
         cache->id = ecs_pair(trav, entity);
         cache->up = false;
     }
 }
 
-void flecs_rule_get_trav_up_cache(
-    const ecs_rule_run_ctx_t *ctx,
+void flecs_query_get_trav_up_cache(
+    const ecs_query_run_ctx_t *ctx,
     ecs_trav_cache_t *cache,
     ecs_entity_t trav,
     ecs_table_t *table)
 {
     ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_world_t *world = ctx->it->real_world;
-    ecs_allocator_t *a = flecs_rule_get_allocator(ctx->it);
+    ecs_allocator_t *a = flecs_query_get_allocator(ctx->it);
 
     ecs_id_record_t *idr = cache->idr;
     if (!idr || idr->id != ecs_pair(trav, EcsWildcard)) {
@@ -142,10 +140,8 @@ void flecs_rule_get_trav_up_cache(
 
     if (cache->id != id || !cache->up) {
         ecs_vec_reset_t(a, &cache->entities, ecs_trav_elem_t);
-        flecs_rule_build_up_cache(world, a, ctx, cache, trav, table, tr, -1);
+        flecs_query_build_up_cache(world, a, ctx, cache, trav, table, tr, -1);
         cache->id = id;
         cache->up = true;
     }
 }
-
-#endif
diff --git a/src/query/trav_cache.h b/src/query/trav_cache.h
new file mode 100644
index 000000000..f8aadfd1e
--- /dev/null
+++ b/src/query/trav_cache.h
@@ -0,0 +1,60 @@
+/**
+ * @file query/trav_cache.h
+ * @brief Traversal cache functions
+ */
+
+#include "types.h"
+
+/* Traversal cache for transitive queries. Finds all reachable entities by
+ * following a relationship */
+
+/* Find all entities when traversing downwards */
+void flecs_query_get_trav_down_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_entity_t entity);
+
+/* Find all entities when traversing upwards */
+void flecs_query_get_trav_up_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_table_t *table);
+
+/* Free traversal cache */
+void flecs_query_trav_cache_fini(
+    ecs_allocator_t *a,
+    ecs_trav_cache_t *cache);
+
+/* Traversal caches for up traversal. Enables searching upwards until an entity
+ * with the queried for id has been found. */
+
+/* Traverse downwards from starting entity to find all tables for which the 
+ * specified entity is the source of the queried for id ('with'). */
+ecs_trav_down_t* flecs_query_get_down_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_up_cache_t *cache,
+    ecs_entity_t trav,
+    ecs_entity_t entity,
+    ecs_id_record_t *idr_with,
+    bool self,
+    bool empty);
+
+/* Free down traversal cache */
+void flecs_query_down_cache_fini(
+    ecs_allocator_t *a,
+    ecs_trav_up_cache_t *cache);
+
+ecs_trav_up_t* flecs_query_get_up_cache(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_trav_up_cache_t *cache,
+    ecs_table_t *table,
+    ecs_id_t with,
+    ecs_entity_t trav,
+    ecs_id_record_t *idr_with,
+    ecs_id_record_t *idr_trav);
+
+/* Free up traversal cache */
+void flecs_query_up_cache_fini(
+    ecs_trav_up_cache_t *cache);
diff --git a/src/addons/rules/trav_down_cache.c b/src/query/trav_down_cache.c
similarity index 86%
rename from src/addons/rules/trav_down_cache.c
rename to src/query/trav_down_cache.c
index ad1bb1ca7..f092622a8 100644
--- a/src/addons/rules/trav_down_cache.c
+++ b/src/query/trav_down_cache.c
@@ -1,6 +1,4 @@
-#include "rules.h"
-
-#ifdef FLECS_RULES
+#include "../private_api.h"
 
 static
 void flecs_trav_entity_down_isa(
@@ -11,7 +9,8 @@ void flecs_trav_entity_down_isa(
     ecs_entity_t trav,
     ecs_entity_t entity,
     ecs_id_record_t *idr_with,
-    bool self);
+    bool self,
+    bool empty);
 
 static
 ecs_trav_down_t* flecs_trav_entity_down(
@@ -23,11 +22,12 @@ ecs_trav_down_t* flecs_trav_entity_down(
     ecs_entity_t entity,
     ecs_id_record_t *idr_trav,
     ecs_id_record_t *idr_with,
-    bool self);
+    bool self,
+    bool empty);
 
 static
 ecs_trav_down_t* flecs_trav_down_ensure(
-    const ecs_rule_run_ctx_t *ctx,
+    const ecs_query_run_ctx_t *ctx,
     ecs_trav_up_cache_t *cache,
     ecs_entity_t entity)
 {
@@ -50,7 +50,8 @@ ecs_trav_down_t* flecs_trav_table_down(
     ecs_entity_t trav,
     const ecs_table_t *table,
     ecs_id_record_t *idr_with,
-    bool self)
+    bool self,
+    bool empty)
 {
     ecs_assert(table->id != 0, ECS_INTERNAL_ERROR, NULL);
 
@@ -78,7 +79,7 @@ ecs_trav_down_t* flecs_trav_table_down(
             }
 
             flecs_trav_entity_down(world, a, cache, dst, 
-                trav, entity, idr_trav, idr_with, self);
+                trav, entity, idr_trav, idr_with, self, empty);
         }
     }
 
@@ -94,7 +95,8 @@ void flecs_trav_entity_down_isa(
     ecs_entity_t trav,
     ecs_entity_t entity,
     ecs_id_record_t *idr_with,
-    bool self)
+    bool self,
+    bool empty)
 {
     if (trav == EcsIsA || !world->idr_isa_wildcard) {
         return;
@@ -107,7 +109,7 @@ void flecs_trav_entity_down_isa(
     }
 
     ecs_table_cache_iter_t it;
-    if (flecs_table_cache_all_iter(&idr_isa->cache, &it)) {
+    if (flecs_table_cache_iter(&idr_isa->cache, &it)) {
         ecs_table_record_t *tr;
         while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
             ecs_table_t *table = tr->hdr.table;
@@ -129,7 +131,7 @@ void flecs_trav_entity_down_isa(
                     ecs_id_record_t *idr_trav = flecs_id_record_get(world, 
                         ecs_pair(trav, e));
                     flecs_trav_entity_down(world, a, cache, dst, trav, e,
-                        idr_trav, idr_with, self);
+                        idr_trav, idr_with, self, empty);
                 }
             }
         }
@@ -146,18 +148,25 @@ ecs_trav_down_t* flecs_trav_entity_down(
     ecs_entity_t entity,
     ecs_id_record_t *idr_trav,
     ecs_id_record_t *idr_with,
-    bool self)
+    bool self,
+    bool empty)
 {
     ecs_assert(dst != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(idr_with != NULL, ECS_INTERNAL_ERROR, NULL);
 
     flecs_trav_entity_down_isa(
-        world, a, cache, dst, trav, entity, idr_with, self);
+        world, a, cache, dst, trav, entity, idr_with, self, empty);
 
     int32_t first = ecs_vec_count(&dst->elems);
 
     ecs_table_cache_iter_t it;
-    if (flecs_table_cache_iter(&idr_trav->cache, &it)) {
+    bool result;
+    if (empty) {
+        result = flecs_table_cache_all_iter(&idr_trav->cache, &it);
+    } else {
+        result = flecs_table_cache_iter(&idr_trav->cache, &it);
+    }
+    if (result) {
         ecs_table_record_t *tr; 
         while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
             ecs_assert(tr->count == 1, ECS_INTERNAL_ERROR, NULL);
@@ -203,26 +212,27 @@ ecs_trav_down_t* flecs_trav_entity_down(
             &dst->elems, ecs_trav_down_elem_t, t);
         if (!elem->leaf) {
             flecs_trav_table_down(world, a, cache, dst, trav,
-                elem->table, idr_with, self);
+                elem->table, idr_with, self, empty);
         }
     }
 
     return dst;
 }
 
-ecs_trav_down_t* flecs_rule_get_down_cache(
-    const ecs_rule_run_ctx_t *ctx,
+ecs_trav_down_t* flecs_query_get_down_cache(
+    const ecs_query_run_ctx_t *ctx,
     ecs_trav_up_cache_t *cache,
     ecs_entity_t trav,
     ecs_entity_t e,
     ecs_id_record_t *idr_with,
-    bool self)
+    bool self,
+    bool empty)
 {
     ecs_world_t *world = ctx->it->real_world;
-    ecs_assert(!(cache->dir & EcsUp), ECS_INTERNAL_ERROR, NULL);
-    cache->dir = EcsDown;
+    ecs_assert(cache->dir != EcsTravUp, ECS_INTERNAL_ERROR, NULL);
+    cache->dir = EcsTravDown;
 
-    ecs_allocator_t *a = flecs_rule_get_allocator(ctx->it);
+    ecs_allocator_t *a = flecs_query_get_allocator(ctx->it);
     ecs_map_init_if(&cache->src, a);
 
     ecs_trav_down_t *result = flecs_trav_down_ensure(ctx, cache, e);
@@ -234,7 +244,7 @@ ecs_trav_down_t* flecs_rule_get_down_cache(
     if (!idr_trav) {
         if (trav != EcsIsA) {
             flecs_trav_entity_down_isa(
-                world, a, cache, result, trav, e, idr_with, self);
+                world, a, cache, result, trav, e, idr_with, self, empty);
         }
         result->ready = true;
         return result;
@@ -242,13 +252,13 @@ ecs_trav_down_t* flecs_rule_get_down_cache(
 
     ecs_vec_init_t(a, &result->elems, ecs_trav_down_elem_t, 0);
     flecs_trav_entity_down(
-        world, a, cache, result, trav, e, idr_trav, idr_with, self);
+        world, a, cache, result, trav, e, idr_trav, idr_with, self, empty);
     result->ready = true;
 
     return result;
 }
 
-void flecs_rule_down_cache_fini(
+void flecs_query_down_cache_fini(
     ecs_allocator_t *a,
     ecs_trav_up_cache_t *cache)
 {
@@ -259,5 +269,3 @@ void flecs_rule_down_cache_fini(
     }
     ecs_map_fini(&cache->src);
 }
-
-#endif
diff --git a/src/addons/rules/trav_up_cache.c b/src/query/trav_up_cache.c
similarity index 91%
rename from src/addons/rules/trav_up_cache.c
rename to src/query/trav_up_cache.c
index 0cebd5a93..7ef0d327e 100644
--- a/src/addons/rules/trav_up_cache.c
+++ b/src/query/trav_up_cache.c
@@ -1,10 +1,8 @@
-#include "rules.h"
-
-#ifdef FLECS_RULES
+#include "../private_api.h"
 
 static
 ecs_trav_up_t* flecs_trav_up_ensure(
-    const ecs_rule_run_ctx_t *ctx,
+    const ecs_query_run_ctx_t *ctx,
     ecs_trav_up_cache_t *cache,
     uint64_t table_id)
 {
@@ -46,7 +44,7 @@ int32_t flecs_trav_type_offset_search(
     while (offset < type->count) {
         ecs_id_t type_id = type->array[offset ++];
         if (ecs_id_match(type_id, with)) {
-            up->id = flecs_to_public_id(type_id);
+            up->id = type_id;
             return up->column = offset - 1;
         }
     }
@@ -56,7 +54,7 @@ int32_t flecs_trav_type_offset_search(
 
 static
 ecs_trav_up_t* flecs_trav_table_up(
-    const ecs_rule_run_ctx_t *ctx,
+    const ecs_query_run_ctx_t *ctx,
     ecs_allocator_t *a,
     ecs_trav_up_cache_t *cache,
     const ecs_world_t *world,
@@ -148,8 +146,8 @@ ecs_trav_up_t* flecs_trav_table_up(
     return up;
 }
 
-ecs_trav_up_t* flecs_rule_get_up_cache(
-    const ecs_rule_run_ctx_t *ctx,
+ecs_trav_up_t* flecs_query_get_up_cache(
+    const ecs_query_run_ctx_t *ctx,
     ecs_trav_up_cache_t *cache,
     ecs_table_t *table,
     ecs_id_t with,
@@ -158,15 +156,15 @@ ecs_trav_up_t* flecs_rule_get_up_cache(
     ecs_id_record_t *idr_trav)
 {
     if (cache->with && cache->with != with) {
-        flecs_rule_up_cache_fini(cache);
+        flecs_query_up_cache_fini(cache);
     }
 
     ecs_world_t *world = ctx->it->real_world;
-    ecs_allocator_t *a = flecs_rule_get_allocator(ctx->it);
+    ecs_allocator_t *a = flecs_query_get_allocator(ctx->it);
     ecs_map_init_if(&cache->src, a);
 
-    ecs_assert(!(cache->dir & EcsDown), ECS_INTERNAL_ERROR, NULL);
-    cache->dir = EcsUp;
+    ecs_assert(cache->dir != EcsTravDown, ECS_INTERNAL_ERROR, NULL);
+    cache->dir = EcsTravUp;
     cache->with = with;
 
     ecs_assert(idr_with != NULL, ECS_INTERNAL_ERROR, NULL);
@@ -191,10 +189,8 @@ ecs_trav_up_t* flecs_rule_get_up_cache(
     return NULL;
 }
 
-void flecs_rule_up_cache_fini(
+void flecs_query_up_cache_fini(
     ecs_trav_up_cache_t *cache)
 {
     ecs_map_fini(&cache->src);
 }
-
-#endif
diff --git a/src/query/trivial_iter.c b/src/query/trivial_iter.c
new file mode 100644
index 000000000..9e255ed1e
--- /dev/null
+++ b/src/query/trivial_iter.c
@@ -0,0 +1,283 @@
+/**
+ * @file addons/querys/engine.c
+ * @brief Iterator for trivial queries.
+ */
+
+#include "../private_api.h"
+
+static
+bool flecs_query_trivial_search_init(
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    const ecs_query_t *query,
+    bool first,
+    ecs_flags64_t term_set)
+{
+    if (first) {
+        /* Find first trivial term*/
+        int32_t t;
+        for (t = 0; t < query->term_count; t ++) {
+            if (term_set & (1llu << t)) {
+                break;
+            }
+        }
+
+        ecs_assert(t != query->term_count, ECS_INTERNAL_ERROR, NULL);
+
+        const ecs_term_t *term = &query->terms[t];
+        ecs_id_record_t *idr = flecs_id_record_get(ctx->world, term->id);
+        if (!idr) {
+            return false;
+        }
+
+        if (query->flags & EcsQueryMatchEmptyTables) {
+            if (!flecs_table_cache_all_iter(&idr->cache, &op_ctx->it)){
+                return false;
+            }
+        } else {
+            if (!flecs_table_cache_iter(&idr->cache, &op_ctx->it)) {
+                return false;
+            }
+        }
+
+        /* Find next term to evaluate once */
+        for (; t < query->term_count; t ++) {
+            if (term_set & (1llu << t)) {
+                break;
+            }
+        }
+
+        op_ctx->first_to_eval = t;
+    }
+
+    return true;
+}
+
+bool flecs_query_trivial_search(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t term_set)
+{
+    const ecs_query_t *q = &query->pub;
+    const ecs_term_t *terms = q->terms;
+    ecs_iter_t *it = ctx->it;
+    int32_t t, term_count = query->pub.term_count;
+
+    if (!flecs_query_trivial_search_init(ctx, op_ctx, q, first, term_set)) {
+        return false;
+    }
+
+    do {
+        const ecs_table_record_t *tr = flecs_table_cache_next(
+            &op_ctx->it, ecs_table_record_t);
+        if (!tr) {
+            return false;
+        }
+
+        ecs_table_t *table = tr->hdr.table;
+        if (table->flags & (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)) {
+            continue;
+        }
+
+        for (t = op_ctx->first_to_eval; t < term_count; t ++) {
+            if (!(term_set & (1llu << t))) {
+                continue;
+            }
+
+            const ecs_term_t *term = &terms[t];
+            ecs_id_record_t *idr = flecs_id_record_get(ctx->world, term->id);
+            if (!idr) {
+                return false;
+            }
+
+            const ecs_table_record_t *tr_with = flecs_id_record_get_table(
+                idr, table);
+            if (!tr_with) {
+                break;
+            }
+
+            it->columns[t] = tr_with->index;
+            if (tr_with->column != -1) {
+                it->ptrs[t] = ecs_vec_first(
+                    &table->data.columns[tr_with->column].data);
+            }
+        }
+
+        if (t == term_count) {
+            ctx->vars[0].range.table = table;
+            ctx->vars[0].range.count = 0;
+            ctx->vars[0].range.offset = 0;
+            it->columns[0] = tr->index;
+            if (tr->column != -1) {
+                it->ptrs[0] = ecs_vec_first(
+                    &table->data.columns[tr->column].data);
+            }
+            break;
+        }
+    } while (true);
+
+    return true;
+}
+
+bool flecs_query_trivial_search_w_wildcards(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t term_set)
+{
+    bool result = flecs_query_trivial_search(
+        query, ctx, op_ctx, first, term_set);
+    if (result) {
+        ecs_iter_t *it = ctx->it;
+        ecs_table_t *table = ctx->vars[0].range.table;
+        int32_t t, term_count = query->pub.term_count;
+        for (t = 0; t < term_count; t ++) {
+            if (term_set & (1llu << t)) {
+                int32_t column = it->columns[t];
+                ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+                it->ids[t] = table->type.array[column];
+            }
+        }
+    }
+
+    return result;
+}
+
+bool flecs_query_trivial_search_nodata(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t term_set)
+{
+    const ecs_query_t *q = &query->pub;
+    const ecs_term_t *terms = q->terms;
+    ecs_iter_t *it = ctx->it;
+    int32_t t, term_count = query->pub.term_count;
+
+    if (!flecs_query_trivial_search_init(ctx, op_ctx, q, first, term_set)) {
+        return false;
+    }
+
+    do {
+        const ecs_table_record_t *tr = flecs_table_cache_next(
+            &op_ctx->it, ecs_table_record_t);
+        if (!tr) {
+            return false;
+        }
+
+        ecs_table_t *table = tr->hdr.table;
+        if (table->flags & (EcsTableNotQueryable|EcsTableIsPrefab|EcsTableIsDisabled)) {
+            continue;
+        }
+
+        for (t = op_ctx->first_to_eval; t < term_count; t ++) {
+            if (!(term_set & (1llu << t))) {
+                continue;
+            }
+
+            const ecs_term_t *term = &terms[t];
+            ecs_id_record_t *idr = flecs_id_record_get(ctx->world, term->id);
+            if (!idr) {
+                break;
+            }
+
+            const ecs_table_record_t *tr_with = flecs_id_record_get_table(
+                idr, table);
+            if (!tr_with) {
+                break;
+            }
+
+            it->columns[t] = tr_with->index;
+        }
+
+        if (t == term_count) {
+            ctx->vars[0].range.table = table;
+            ctx->vars[0].range.count = 0;
+            ctx->vars[0].range.offset = 0;
+            it->columns[0] = tr->index;
+            break;
+        }
+    } while (true);
+
+    return true;
+}
+
+bool flecs_query_trivial_test(
+    const ecs_query_impl_t *impl,
+    const ecs_query_run_ctx_t *ctx,
+    bool first,
+    ecs_flags64_t term_set)
+{
+    if (first) {
+        const ecs_query_t *q = &impl->pub;
+        const ecs_term_t *terms = q->terms;
+        ecs_iter_t *it = ctx->it;
+        int32_t t, term_count = impl->pub.term_count;
+
+        ecs_table_t *table = it->table;
+        ecs_assert(table != NULL, ECS_INVALID_OPERATION,
+            "the variable set on the iterator is missing a table");
+
+        for (t = 0; t < term_count; t ++) {
+            if (!(term_set & (1llu << t))) {
+                continue;
+            }
+
+            const ecs_term_t *term = &terms[t];
+            ecs_id_record_t *idr = flecs_id_record_get(q->world, term->id);
+            if (!idr) {
+                return false;
+            }
+
+            const ecs_table_record_t *tr = flecs_id_record_get_table(idr, table);
+            if (!tr) {
+                return false;
+            }
+
+            it->columns[t] = tr->index;
+            if (it->count && tr->column != -1) {
+                it->ptrs[t] = ecs_vec_get(
+                    &table->data.columns[tr->column].data,
+                    it->sizes[t],
+                    it->offset);
+            }
+        }
+
+        it->entities = flecs_table_entities_array(table);
+        if (it->entities) {
+            it->entities = &it->entities[it->offset];
+        }
+
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool flecs_query_trivial_test_w_wildcards(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    bool first,
+    ecs_flags64_t term_set)
+{
+    int32_t t, term_count = query->pub.term_count;
+    bool result = flecs_query_trivial_test(
+        query, ctx, first, term_set);
+    if (result) {
+        ecs_iter_t *it = ctx->it;
+        ecs_table_t *table = ctx->vars[0].range.table;
+        for (t = 0; t < term_count; t ++) {
+            if (term_set & (1llu << t)) {
+                int32_t column = it->columns[t];
+                ecs_assert(column >= 0, ECS_INTERNAL_ERROR, NULL);
+                it->ids[t] = table->type.array[column];
+            }
+        }
+    }
+
+    return result;
+}
diff --git a/src/query/trivial_iter.h b/src/query/trivial_iter.h
new file mode 100644
index 000000000..b4103ffd8
--- /dev/null
+++ b/src/query/trivial_iter.h
@@ -0,0 +1,44 @@
+/**
+ * @file query/trivial_iter.h
+ * @brief Trivial iterator functions.
+ */
+
+#include "types.h"
+
+/* Iterator for trivial queries. */
+bool flecs_query_trivial_search(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t field_set);
+
+/* Iterator for trivial queries. */
+bool flecs_query_trivial_search_nodata(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t field_set);
+
+/* Iterator for trivial queries with wildcard matching. */
+bool flecs_query_trivial_search_w_wildcards(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    ecs_query_trivial_ctx_t *op_ctx,
+    bool first,
+    ecs_flags64_t field_set);
+
+/* Trivial test for constrained $this. */
+bool flecs_query_trivial_test(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    bool first,
+    ecs_flags64_t field_set);
+
+/* Trivial test for constrained $this with wildcard matching. */
+bool flecs_query_trivial_test_w_wildcards(
+    const ecs_query_impl_t *query,
+    const ecs_query_run_ctx_t *ctx,
+    bool first,
+    ecs_flags64_t field_set);
diff --git a/src/query/types.h b/src/query/types.h
new file mode 100644
index 000000000..9e41c5403
--- /dev/null
+++ b/src/query/types.h
@@ -0,0 +1,480 @@
+ /**
+ * @file query/types.h
+ * @brief Internal types and functions for queries.
+ */
+
+#ifndef FLECS_QUERY_TYPES
+#define FLECS_QUERY_TYPES
+
+typedef struct ecs_query_impl_t ecs_query_impl_t;
+typedef uint8_t ecs_var_id_t;
+typedef int16_t ecs_query_lbl_t;
+typedef ecs_flags64_t ecs_write_flags_t;
+
+#define flecs_query_impl(query) (ECS_CONST_CAST(ecs_query_impl_t*, query))
+
+#define EcsQueryMaxVarCount     (64)
+#define EcsVarNone              ((ecs_var_id_t)-1)
+#define EcsThisName             "this"
+
+/* -- Variable types -- */
+typedef enum {
+    EcsVarEntity,          /* Variable that stores an entity id */
+    EcsVarTable,           /* Variable that stores a table */
+    EcsVarAny              /* Used when requesting either entity or table var */
+} ecs_var_kind_t;
+
+typedef struct ecs_query_var_t {
+    int8_t kind;           /* variable kind (EcsVarEntity or EcsVarTable) */
+    bool anonymous;        /* variable is anonymous */
+    ecs_var_id_t id;       /* variable id */
+    ecs_var_id_t table_id; /* id to table variable, if any */
+    ecs_var_id_t base_id;  /* id to base entity variable, for lookups */
+    const char *name;      /* variable name */
+    const char *lookup;    /* Lookup string for variable */
+#ifdef FLECS_DEBUG
+    const char *label;     /* for debugging */
+#endif
+} ecs_query_var_t;
+
+/* -- Instruction kinds -- */
+typedef enum {
+    EcsQueryAnd,            /* And operator: find or match id against variable source */
+    EcsQueryAndId,          /* And operator for fixed id (no wildcards/variables) */
+    EcsQueryAndAny,         /* And operator with support for matching Any src/id */
+    EcsQuerySelectAny,      /* Dedicated instruction for _ queries where the src is unknown */
+    EcsQueryTriv,           /* Trivial search (batches multiple terms) */
+    EcsQueryTrivData,       /* Trivial search with setting data fields */
+    EcsQueryTrivWildcard,   /* Trivial search with (exclusive) wildcard ids */
+    EcsQueryCache,          /* Cached search */
+    EcsQueryCacheData,      /* Cached search with setting data fields */
+    EcsQueryIsCache,        /* Cached search for queries that are entirely cached */
+    EcsQueryIsCacheData,    /* Same as EcsQueryIsCache with data fields */
+    EcsQueryUp,             /* Up traversal */
+    EcsQueryUpId,           /* Up traversal for fixed id (like AndId) */
+    EcsQuerySelfUp,         /* Self|up traversal */
+    EcsQuerySelfUpId,       /* Self|up traversal for fixed id (like AndId) */
+    EcsQueryWith,           /* Match id against fixed or variable source */
+    EcsQueryTrav,           /* Support for transitive/reflexive queries */
+    EcsQueryAndFrom,        /* AndFrom operator */
+    EcsQueryOrFrom,         /* OrFrom operator */
+    EcsQueryNotFrom,        /* NotFrom operator */
+    EcsQueryIds,            /* Test for existence of ids matching wildcard */
+    EcsQueryIdsRight,       /* Find ids in use that match (R, *) wildcard */
+    EcsQueryIdsLeft,        /* Find ids in use that match (*, T) wildcard */
+    EcsQueryEach,           /* Iterate entities in table, populate entity variable */
+    EcsQueryStore,          /* Store table or entity in variable */
+    EcsQueryReset,          /* Reset value of variable to wildcard (*) */
+    EcsQueryOr,             /* Or operator */
+    EcsQueryOptional,       /* Optional operator */
+    EcsQueryIfVar,          /* Conditional execution on whether variable is set */
+    EcsQueryIfSet,          /* Conditional execution on whether term is set */
+    EcsQueryNot,            /* Sets iterator state after term was not matched */
+    EcsQueryEnd,            /* End of control flow block */
+    EcsQueryPredEq,         /* Test if variable is equal to, or assign to if not set */
+    EcsQueryPredNeq,        /* Test if variable is not equal to */
+    EcsQueryPredEqName,     /* Same as EcsQueryPredEq but with matching by name */
+    EcsQueryPredNeqName,    /* Same as EcsQueryPredNeq but with matching by name */
+    EcsQueryPredEqMatch,    /* Same as EcsQueryPredEq but with fuzzy matching by name */
+    EcsQueryPredNeqMatch,   /* Same as EcsQueryPredNeq but with fuzzy matching by name */
+    EcsQueryMemberEq,       /* Compare member value */
+    EcsQueryMemberNeq,      /* Compare member value */
+    EcsQueryToggle,         /* Evaluate toggle bitset, if present */
+    EcsQueryToggleOption,   /* Toggle for optional terms */
+    EcsQueryLookup,         /* Lookup relative to variable */
+    EcsQuerySetVars,        /* Populate it.sources from variables */
+    EcsQuerySetThis,        /* Populate This entity variable */
+    EcsQuerySetFixed,       /* Set fixed source entity ids */
+    EcsQuerySetIds,         /* Set fixed (component) ids */
+    EcsQuerySetId,          /* Set id if not set */
+    EcsQueryContain,        /* Test if table contains entity */
+    EcsQueryPairEq,         /* Test if both elements of pair are the same */
+    EcsQueryPopulate,       /* Populate any data fields */
+    EcsQueryPopulateSelf,   /* Populate only self (owned) data fields */
+    EcsQueryYield,          /* Yield result back to application */
+    EcsQueryNothing         /* Must be last */
+} ecs_query_op_kind_t;
+
+/* Op flags to indicate if ecs_query_ref_t is entity or variable */
+#define EcsQueryIsEntity  (1 << 0)
+#define EcsQueryIsVar     (1 << 1)
+#define EcsQueryIsSelf    (1 << 6)
+
+/* Op flags used to shift EcsQueryIsEntity and EcsQueryIsVar */
+#define EcsQuerySrc     0
+#define EcsQueryFirst   2
+#define EcsQuerySecond  4
+
+/* References to variable or entity */
+typedef union {
+    ecs_var_id_t var;
+    ecs_entity_t entity;
+} ecs_query_ref_t;
+
+/* Query instruction */
+typedef struct ecs_query_op_t {
+    uint8_t kind;              /* Instruction kind */
+    ecs_flags8_t flags;        /* Flags storing whether 1st/2nd are variables */
+    int8_t field_index;        /* Query field corresponding with operation */
+    int8_t term_index;         /* Query term corresponding with operation */
+    ecs_query_lbl_t prev;      /* Backtracking label (no data) */
+    ecs_query_lbl_t next;      /* Forwarding label. Must come after prev */
+    ecs_query_lbl_t other;     /* Misc register used for control flow */
+    ecs_flags16_t match_flags; /* Flags that modify matching behavior */
+    ecs_query_ref_t src;
+    ecs_query_ref_t first;
+    ecs_query_ref_t second;
+    ecs_flags64_t written;     /* Bitset with variables written by op */
+} ecs_query_op_t;
+
+ /* And context */
+typedef struct {
+    ecs_id_record_t *idr;
+    ecs_table_cache_iter_t it;
+    int16_t column;
+    int16_t remaining;
+} ecs_query_and_ctx_t;
+
+/* Down traversal cache (for resolving up queries w/unknown source) */
+typedef struct {
+    ecs_table_t *table;
+    bool leaf; /* Table owns and inherits id (for Up queries without Self) */
+} ecs_trav_down_elem_t;
+
+typedef struct {
+    ecs_vec_t elems;      /* vector<ecs_trav_down_elem_t> */
+    bool ready;
+} ecs_trav_down_t;
+
+typedef struct {
+    ecs_entity_t src;
+    ecs_id_t id;
+    int32_t column;
+    bool ready;
+} ecs_trav_up_t;
+
+typedef enum {
+    EcsTravUp = 1,
+    EcsTravDown = 2
+} ecs_trav_direction_t;
+
+typedef struct {
+    ecs_map_t src;        /* map<entity, trav_down_t> or map<table_id, trav_up_t> */
+    ecs_id_t with;
+    ecs_trav_direction_t dir;
+} ecs_trav_up_cache_t;
+
+/* And up context */
+typedef struct {
+    ecs_query_and_ctx_t and;
+    ecs_table_t *table;
+    int32_t row;
+    int32_t end;
+    ecs_entity_t trav;
+    ecs_id_t with;
+    ecs_id_t matched;
+    ecs_id_record_t *idr_with;
+    ecs_id_record_t *idr_trav;
+    ecs_trav_down_t *down;
+    int32_t cache_elem;
+    ecs_trav_up_cache_t cache;
+} ecs_query_up_ctx_t;
+
+/* Cache for storing results of upward/downward "all" traversal. This type of 
+ * traversal iterates and caches the entire tree. */
+typedef struct {
+    ecs_entity_t entity;
+    ecs_id_record_t *idr;
+    int32_t column;
+} ecs_trav_elem_t;
+
+typedef struct {
+    ecs_id_t id;
+    ecs_id_record_t *idr;
+    ecs_vec_t entities;
+    bool up;
+} ecs_trav_cache_t;
+
+/* Trav context */
+typedef struct {
+    ecs_query_and_ctx_t and;
+    int32_t index;
+    int32_t offset;
+    int32_t count;
+    ecs_trav_cache_t cache;
+    bool yield_reflexive;
+} ecs_query_trav_ctx_t;
+
+ /* Eq context */
+typedef struct {
+    ecs_table_range_t range;
+    int32_t index;
+    int16_t name_col;
+    bool redo;
+} ecs_query_eq_ctx_t;
+
+ /* Each context */
+typedef struct {
+    int32_t row;
+} ecs_query_each_ctx_t;
+
+ /* Setthis context */
+typedef struct {
+    ecs_table_range_t range;
+} ecs_query_setthis_ctx_t;
+
+/* Ids context */
+typedef struct {
+    ecs_id_record_t *cur;
+} ecs_query_ids_ctx_t;
+
+/* Control flow context */
+typedef struct {
+    ecs_query_lbl_t op_index;
+    ecs_id_t field_id;
+    bool is_set;
+} ecs_query_ctrl_ctx_t;
+
+/* Trivial iterator context */
+typedef struct {
+    ecs_table_cache_iter_t it;
+    const ecs_table_record_t *tr;
+    int32_t first_to_eval;
+} ecs_query_trivial_ctx_t;
+
+/* *From operator iterator context */
+typedef struct {
+    ecs_query_and_ctx_t and;
+    ecs_type_t *type;
+    int32_t first_id_index;
+    int32_t cur_id_index;
+} ecs_query_xfrom_ctx_t;
+
+/* Member equality context */
+typedef struct {
+    ecs_query_each_ctx_t each;
+    void *data;
+} ecs_query_membereq_ctx_t;
+
+/* Toggle context */
+typedef struct {
+    ecs_table_range_t range;
+    int32_t cur;
+    int32_t block_index;
+    ecs_flags64_t block;
+    ecs_termset_t prev_set_fields;
+    bool optional_not;
+    bool has_bitset;
+} ecs_query_toggle_ctx_t;
+
+typedef struct ecs_query_op_ctx_t {
+    union {
+        ecs_query_and_ctx_t and;
+        ecs_query_xfrom_ctx_t xfrom;
+        ecs_query_up_ctx_t up;
+        ecs_query_trav_ctx_t trav;
+        ecs_query_ids_ctx_t ids;
+        ecs_query_eq_ctx_t eq;
+        ecs_query_each_ctx_t each;
+        ecs_query_setthis_ctx_t setthis;
+        ecs_query_ctrl_ctx_t ctrl;
+        ecs_query_trivial_ctx_t trivial;
+        ecs_query_membereq_ctx_t membereq;
+        ecs_query_toggle_ctx_t toggle;
+    } is;
+} ecs_query_op_ctx_t;
+
+typedef struct {
+    /* Labels used for control flow */
+    ecs_query_lbl_t lbl_query; /* Used to find the op that does the actual searching */
+    ecs_query_lbl_t lbl_begin;
+    ecs_query_lbl_t lbl_cond_eval;
+    ecs_write_flags_t written_or; /* Cond written flags at start of or chain */
+    ecs_write_flags_t cond_written_or; /* Cond written flags at start of or chain */
+    ecs_query_ref_t src_or;  /* Source for terms in current or chain */
+    bool src_written_or; /* Was src populated before OR chain */
+    bool in_or; /* Whether we're in an or chain */
+} ecs_query_compile_ctrlflow_t;
+
+/* Query compiler state */
+typedef struct {
+    ecs_vec_t *ops;
+    ecs_write_flags_t written; /* Bitmask to check which variables have been written */
+    ecs_write_flags_t cond_written; /* Track conditional writes (optional operators) */
+
+    /* Maintain control flow per scope */
+    ecs_query_compile_ctrlflow_t ctrlflow[FLECS_QUERY_SCOPE_NESTING_MAX];
+    ecs_query_compile_ctrlflow_t *cur; /* Current scope */
+
+    int32_t scope; /* Nesting level of query scopes */
+    ecs_flags32_t scope_is_not; /* Whether scope is prefixed with not */
+    ecs_oper_kind_t oper; /* Temp storage to track current operator for term */
+    int32_t skipped; /* Term skipped during compilation */
+} ecs_query_compile_ctx_t;    
+
+/* Query run state */
+typedef struct {
+    uint64_t *written;                 /* Bitset to check which variables have been written */
+    ecs_query_lbl_t op_index;          /* Currently evaluated operation */
+    ecs_var_t *vars;                   /* Variable storage */
+    ecs_iter_t *it;                    /* Iterator */
+    ecs_query_op_ctx_t *op_ctx;        /* Operation context (stack) */
+    ecs_world_t *world;                /* Reference to world */
+    const ecs_query_impl_t *query;     /* Reference to query */
+    const ecs_query_var_t *query_vars; /* Reference to query variable array */
+    ecs_query_iter_t *qit;
+} ecs_query_run_ctx_t;
+
+typedef struct {
+    ecs_query_var_t var;
+    const char *name;
+} ecs_query_var_cache_t;
+
+struct ecs_query_impl_t {
+    ecs_query_t pub;              /* Public query data */
+
+    /* Variables */
+    ecs_query_var_t *vars;        /* Variables */
+    int32_t var_count;            /* Number of variables */
+    int32_t var_pub_count;        /* Number of public variables */
+    int32_t var_size;             /* Size of variable array */
+    bool has_table_this;          /* Does query have [$this] */
+    ecs_hashmap_t tvar_index;     /* Name index for table variables */
+    ecs_hashmap_t evar_index;     /* Name index for entity variables */
+    ecs_query_var_cache_t vars_cache; /* For trivial queries with only This variables */
+    char **var_names;             /* Array with variable names for iterator */
+    ecs_var_id_t *src_vars;       /* Array with ids to source variables for fields */
+
+    /* Query plan */
+    ecs_query_op_t *ops;          /* Operations */
+    int32_t op_count;             /* Number of operations */
+
+    /* Query cache */
+    struct ecs_query_cache_t *cache; /* Cache, if query contains cached terms */
+    int8_t *field_map;            /* Map field indices from cache to query */
+
+    /* Change detection */
+    int32_t *monitor;             /* Change monitor for fields with fixed src */
+
+    /* Misc */
+    int16_t tokens_len;           /* Length of tokens buffer */
+    char *tokens;                 /* Buffer with string tokens used by terms */
+
+    /* User context */
+    ecs_ctx_free_t ctx_free;         /* Callback to free ctx */
+    ecs_ctx_free_t binding_ctx_free; /* Callback to free binding_ctx */
+
+    /* Mixins */
+    flecs_poly_dtor_t dtor;
+};
+
+
+/* Query cache types */
+
+/** Table match data.
+ * Each table matched by the query is represented by a ecs_query_cache_table_match_t
+ * instance, which are linked together in a list. A table may match a query
+ * multiple times (due to wildcard queries) with different columns being matched
+ * by the query. */
+struct ecs_query_cache_table_match_t {
+    ecs_query_cache_table_match_t *next, *prev;
+    ecs_table_t *table;              /* The current table. */
+    int32_t offset;                  /* Starting point in table  */
+    int32_t count;                   /* Number of entities to iterate in table */
+    int32_t *columns;                /* Mapping from query fields to table columns */
+    int32_t *storage_columns;        /* Mapping from query fields to storage columns */
+    ecs_id_t *ids;                   /* Resolved (component) ids for current table */
+    ecs_entity_t *sources;           /* Subjects (sources) of ids */
+    ecs_vec_t refs;                  /* Cached components for non-this terms */
+    ecs_termset_t set_fields;        /* Fields that are set */
+    ecs_termset_t up_fields;         /* Fields that are matched through traversal */
+    uint64_t group_id;               /* Value used to organize tables in groups */
+    int32_t *monitor;                /* Used to monitor table for changes */
+
+    /* Next match in cache for same table (includes empty tables) */
+    ecs_query_cache_table_match_t *next_match;
+};
+
+/** Table record type for query table cache. A query only has one per table. */
+typedef struct ecs_query_cache_table_t {
+    ecs_table_cache_hdr_t hdr;       /* Header for ecs_table_cache_t */
+    ecs_query_cache_table_match_t *first;  /* List with matches for table */
+    ecs_query_cache_table_match_t *last;   /* Last discovered match for table */
+    uint64_t table_id;
+    int32_t rematch_count;           /* Track whether table was rematched */
+} ecs_query_cache_table_t;
+
+/** Points to the beginning & ending of a query group */
+typedef struct ecs_query_cache_table_list_t {
+    ecs_query_cache_table_match_t *first;
+    ecs_query_cache_table_match_t *last;
+    ecs_query_group_info_t info;
+} ecs_query_cache_table_list_t;
+
+/* Query event type for notifying queries of world events */
+typedef enum ecs_query_cache_eventkind_t {
+    EcsQueryTableMatch,
+    EcsQueryTableRematch,
+    EcsQueryTableUnmatch,
+} ecs_query_cache_eventkind_t;
+
+typedef struct ecs_query_cache_event_t {
+    ecs_query_cache_eventkind_t kind;
+    ecs_table_t *table;
+} ecs_query_cache_event_t;
+
+/* Query level block allocators have sizes that depend on query field count */
+typedef struct ecs_query_cache_allocators_t {
+    ecs_block_allocator_t columns;
+    ecs_block_allocator_t ids;
+    ecs_block_allocator_t sources;
+    ecs_block_allocator_t monitors;
+} ecs_query_cache_allocators_t;
+
+/** Query that is automatically matched against tables */
+typedef struct ecs_query_cache_t {
+    /* Uncached query used to populate the cache */
+    ecs_query_t *query;
+
+    /* Observer to keep the cache in sync */
+    ecs_observer_t *observer;
+
+    /* Tables matched with query */
+    ecs_table_cache_t cache;
+
+    /* Linked list with all matched non-empty tables, in iteration order */
+    ecs_query_cache_table_list_t list;
+
+    /* Contains head/tail to nodes of query groups (if group_by is used) */
+    ecs_map_t groups;
+
+    /* Table sorting */
+    ecs_entity_t order_by;
+    ecs_order_by_action_t order_by_callback;
+    ecs_sort_table_action_t order_by_table_callback;
+    ecs_vec_t table_slices;
+    int32_t order_by_term;
+
+    /* Table grouping */
+    ecs_entity_t group_by;
+    ecs_group_by_action_t group_by_callback;
+    ecs_group_create_action_t on_group_create;
+    ecs_group_delete_action_t on_group_delete;
+    void *group_by_ctx;
+    ecs_ctx_free_t group_by_ctx_free;
+
+    /* Monitor generation */
+    int32_t monitor_generation;
+
+    int32_t cascade_by;              /* Identify cascade term */
+    int32_t match_count;             /* How often have tables been (un)matched */
+    int32_t prev_match_count;        /* Track if sorting is needed */
+    int32_t rematch_count;           /* Track which tables were added during rematch */
+    
+    ecs_entity_t entity;
+
+    /* Query-level allocators */
+    ecs_query_cache_allocators_t allocators;
+} ecs_query_cache_t;
+
+#endif
diff --git a/src/query/util.c b/src/query/util.c
new file mode 100644
index 000000000..62eeaa67f
--- /dev/null
+++ b/src/query/util.c
@@ -0,0 +1,801 @@
+ /**
+ * @file query/util.c
+ * @brief Query utilities.
+ */
+
+#include "../private_api.h"
+
+ecs_query_lbl_t flecs_itolbl(int64_t val) {
+    return flecs_ito(int16_t, val);
+}
+
+ecs_var_id_t flecs_itovar(int64_t val) {
+    return flecs_ito(uint8_t, val);
+}
+
+ecs_var_id_t flecs_utovar(uint64_t val) {
+    return flecs_uto(uint8_t, val);
+}
+
+bool flecs_term_is_builtin_pred(
+    ecs_term_t *term)
+{
+    if (term->first.id & EcsIsEntity) {
+        ecs_entity_t id = ECS_TERM_REF_ID(&term->first);
+        if (id == EcsPredEq || id == EcsPredMatch || id == EcsPredLookup) {
+            return true;
+        }
+    }
+    return false;
+}
+
+const char* flecs_term_ref_var_name(
+    ecs_term_ref_t *ref)
+{
+    if (!(ref->id & EcsIsVariable)) {
+        return NULL;
+    }
+
+    if (ECS_TERM_REF_ID(ref) == EcsThis) {
+        return EcsThisName;
+    }
+
+    return ref->name;
+}
+
+bool flecs_term_ref_is_wildcard(
+    ecs_term_ref_t *ref)
+{
+    if ((ref->id & EcsIsVariable) && 
+        ((ECS_TERM_REF_ID(ref) == EcsWildcard) || (ECS_TERM_REF_ID(ref) == EcsAny))) 
+    {
+        return true;
+    }
+    return false;
+}
+
+bool flecs_term_is_fixed_id(
+    ecs_query_t *q,
+    ecs_term_t *term)
+{
+    /* Transitive/inherited terms have variable ids */
+    if (term->flags_ & (EcsTermTransitive|EcsTermIdInherited)) {
+        return false;
+    }
+
+    /* Or terms can match different ids */
+    if (term->oper == EcsOr) {
+        return false;
+    }
+    if ((term != q->terms) && term[-1].oper == EcsOr) {
+        return false;
+    }
+
+    /* Wildcards can assume different ids */
+    if (ecs_id_is_wildcard(term->id)) {
+        return false;
+    }
+
+    /* Any terms can have fixed ids, but they require special handling */
+    if (term->flags_ & (EcsTermMatchAny|EcsTermMatchAnySrc)) {
+        return false;
+    }
+
+    /* First terms that are Not or Optional require special handling */
+    if (term->oper == EcsNot || term->oper == EcsOptional) {
+        if (term == q->terms) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool flecs_term_is_or(
+    const ecs_query_t *q,
+    const ecs_term_t *term)
+{
+    bool first_term = term == q->terms;
+    return (term->oper == EcsOr) || (!first_term && term[-1].oper == EcsOr);
+}
+
+ecs_flags16_t flecs_query_ref_flags(
+    ecs_flags16_t flags,
+    ecs_flags16_t kind)
+{
+    return (flags >> kind) & (EcsQueryIsVar | EcsQueryIsEntity);
+}
+
+bool flecs_query_is_written(
+    ecs_var_id_t var_id,
+    uint64_t written)
+{
+    if (var_id == EcsVarNone) {
+        return true;
+    }
+
+    ecs_assert(var_id < EcsQueryMaxVarCount, ECS_INTERNAL_ERROR, NULL);
+    return (written & (1ull << var_id)) != 0;
+}
+
+void flecs_query_write(
+    ecs_var_id_t var_id,
+    uint64_t *written)
+{
+    ecs_assert(var_id < EcsQueryMaxVarCount, ECS_INTERNAL_ERROR, NULL);
+    *written |= (1ull << var_id);
+}
+
+void flecs_query_write_ctx(
+    ecs_var_id_t var_id,
+    ecs_query_compile_ctx_t *ctx,
+    bool cond_write)
+{
+    bool is_written = flecs_query_is_written(var_id, ctx->written);
+    flecs_query_write(var_id, &ctx->written);
+    if (!is_written) {
+        if (cond_write) {
+            flecs_query_write(var_id, &ctx->cond_written);
+        }
+    }
+}
+
+bool flecs_ref_is_written(
+    const ecs_query_op_t *op,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t kind,
+    uint64_t written)
+{
+    ecs_flags16_t flags = flecs_query_ref_flags(op->flags, kind);
+    if (flags & EcsQueryIsEntity) {
+        ecs_assert(!(flags & EcsQueryIsVar), ECS_INTERNAL_ERROR, NULL);
+        if (ref->entity) {
+            return true;
+        }
+    } else if (flags & EcsQueryIsVar) {
+        return flecs_query_is_written(ref->var, written);
+    }
+    return false;
+}
+
+ecs_allocator_t* flecs_query_get_allocator(
+    const ecs_iter_t *it)
+{
+    ecs_world_t *world = it->world;
+    if (flecs_poly_is(world, ecs_world_t)) {
+        return &world->allocator;
+    } else {
+        ecs_assert(flecs_poly_is(world, ecs_stage_t), ECS_INTERNAL_ERROR, NULL);
+        return &((ecs_stage_t*)world)->allocator;
+    }
+}
+
+const char* flecs_query_op_str(
+    uint16_t kind)
+{
+    switch(kind) {
+    case EcsQueryAnd:           return "and       ";
+    case EcsQueryAndId:         return "andid     ";
+    case EcsQueryAndAny:        return "andany    ";
+    case EcsQueryTriv:          return "triv      ";
+    case EcsQueryTrivData:      return "trivpop   ";
+    case EcsQueryTrivWildcard:  return "trivwc    ";
+    case EcsQueryCache:         return "cache     ";
+    case EcsQueryCacheData:     return "cachepop  ";
+    case EcsQueryIsCache:       return "xcache    ";
+    case EcsQueryIsCacheData:   return "xcachepop ";
+    case EcsQuerySelectAny:     return "any       ";
+    case EcsQueryUp:            return "up        ";
+    case EcsQueryUpId:          return "upid      ";
+    case EcsQuerySelfUp:        return "selfup    ";
+    case EcsQuerySelfUpId:      return "selfupid  ";
+    case EcsQueryWith:          return "with      ";
+    case EcsQueryTrav:          return "trav      ";
+    case EcsQueryAndFrom:       return "andfrom   ";
+    case EcsQueryOrFrom:        return "orfrom    ";
+    case EcsQueryNotFrom:       return "notfrom   ";
+    case EcsQueryIds:           return "ids       ";
+    case EcsQueryIdsRight:      return "idsr      ";
+    case EcsQueryIdsLeft:       return "idsl      ";
+    case EcsQueryEach:          return "each      ";
+    case EcsQueryStore:         return "store     ";
+    case EcsQueryReset:         return "reset     ";
+    case EcsQueryOr:            return "or        ";
+    case EcsQueryOptional:      return "option    ";
+    case EcsQueryIfVar:         return "ifvar     ";
+    case EcsQueryIfSet:         return "ifset     ";
+    case EcsQueryEnd:           return "end       ";
+    case EcsQueryNot:           return "not       ";
+    case EcsQueryPredEq:        return "eq        ";
+    case EcsQueryPredNeq:       return "neq       ";
+    case EcsQueryPredEqName:    return "eq_nm     ";
+    case EcsQueryPredNeqName:   return "neq_nm    ";
+    case EcsQueryPredEqMatch:   return "eq_m      ";
+    case EcsQueryPredNeqMatch:  return "neq_m     ";
+    case EcsQueryMemberEq:      return "membereq  ";
+    case EcsQueryMemberNeq:     return "memberneq ";
+    case EcsQueryToggle:        return "toggle    ";
+    case EcsQueryToggleOption:  return "togglopt  ";
+    case EcsQueryLookup:        return "lookup    ";
+    case EcsQuerySetVars:       return "setvars   ";
+    case EcsQuerySetThis:       return "setthis   ";
+    case EcsQuerySetFixed:      return "setfix    ";
+    case EcsQuerySetIds:        return "setids    ";
+    case EcsQuerySetId:         return "setid     ";
+    case EcsQueryContain:       return "contain   ";
+    case EcsQueryPairEq:        return "pair_eq   ";
+    case EcsQueryPopulate:      return "pop       ";
+    case EcsQueryPopulateSelf:  return "popself   ";
+    case EcsQueryYield:         return "yield     ";
+    case EcsQueryNothing:       return "nothing   ";
+    default:                   return "!invalid  ";
+    }
+}
+
+static
+int32_t flecs_query_op_ref_str(
+    const ecs_query_impl_t *query,
+    ecs_query_ref_t *ref,
+    ecs_flags16_t flags,
+    ecs_strbuf_t *buf)
+{
+    int32_t color_chars = 0;
+    if (flags & EcsQueryIsVar) {
+        ecs_assert(ref->var < query->var_count, ECS_INTERNAL_ERROR, NULL);
+        ecs_query_var_t *var = &query->vars[ref->var];
+        ecs_strbuf_appendlit(buf, "#[green]$#[reset]");
+        if (var->kind == EcsVarTable) {
+            ecs_strbuf_appendch(buf, '[');
+        }
+        ecs_strbuf_appendlit(buf, "#[green]");
+        if (var->name) {
+            ecs_strbuf_appendstr(buf, var->name);
+        } else {
+            if (var->id) {
+#ifdef FLECS_DEBUG
+                if (var->label) {
+                    ecs_strbuf_appendstr(buf, var->label);
+                    ecs_strbuf_appendch(buf, '\'');
+                }
+#endif
+                ecs_strbuf_append(buf, "%d", var->id);
+            } else {
+                ecs_strbuf_appendlit(buf, "this");
+            }
+        }
+        ecs_strbuf_appendlit(buf, "#[reset]");
+        if (var->kind == EcsVarTable) {
+            ecs_strbuf_appendch(buf, ']');
+        }
+        color_chars = ecs_os_strlen("#[green]#[reset]#[green]#[reset]");
+    } else if (flags & EcsQueryIsEntity) {
+        char *path = ecs_get_fullpath(query->pub.world, ref->entity);
+        ecs_strbuf_appendlit(buf, "#[blue]");
+        ecs_strbuf_appendstr(buf, path);
+        ecs_strbuf_appendlit(buf, "#[reset]");
+        ecs_os_free(path);
+        color_chars = ecs_os_strlen("#[blue]#[reset]");
+    }
+    return color_chars;
+}
+
+static
+void flecs_query_str_append_bitset(
+    ecs_strbuf_t *buf,
+    ecs_flags64_t bitset)
+{
+    ecs_strbuf_list_push(buf, "{", ",");
+    int8_t b;
+    for (b = 0; b < 64; b ++) {
+        if (bitset & (1llu << b)) {
+            ecs_strbuf_list_append(buf, "%d", b);
+        }
+    }
+    ecs_strbuf_list_pop(buf, "}");
+}
+
+char* ecs_query_str_w_profile(
+    const ecs_query_t *q,
+    const ecs_iter_t *it)
+{
+    flecs_poly_assert(q, ecs_query_t);
+    ecs_query_impl_t *impl = flecs_query_impl(q);
+
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    ecs_query_op_t *ops = impl->ops;
+    int32_t i, count = impl->op_count, indent = 0;
+    for (i = 0; i < count; i ++) {
+        ecs_query_op_t *op = &ops[i];
+        ecs_flags16_t flags = op->flags;
+        ecs_flags16_t src_flags = flecs_query_ref_flags(flags, EcsQuerySrc);
+        ecs_flags16_t first_flags = flecs_query_ref_flags(flags, EcsQueryFirst);
+        ecs_flags16_t second_flags = flecs_query_ref_flags(flags, EcsQuerySecond);
+
+        if (it) {
+#ifdef FLECS_DEBUG
+            const ecs_query_iter_t *rit = &it->priv_.iter.query;
+            ecs_strbuf_append(&buf, 
+                "#[green]%4d -> #[red]%4d <- #[grey]  |   ",
+                rit->profile[i].count[0],
+                rit->profile[i].count[1]);
+#endif
+        }
+
+        ecs_strbuf_append(&buf, 
+            "#[normal]%2d. [#[grey]%2d#[reset], #[green]%2d#[reset]]  ", 
+                i, op->prev, op->next);
+        int32_t hidden_chars, start = ecs_strbuf_written(&buf);
+        if (op->kind == EcsQueryEnd) {
+            indent --;
+        }
+
+        ecs_strbuf_append(&buf, "%*s", indent, "");
+        ecs_strbuf_appendstr(&buf, flecs_query_op_str(op->kind));
+        ecs_strbuf_appendstr(&buf, " ");
+
+        int32_t written = ecs_strbuf_written(&buf);
+        for (int32_t j = 0; j < (12 - (written - start)); j ++) {
+            ecs_strbuf_appendch(&buf, ' ');
+        }
+    
+        hidden_chars = flecs_query_op_ref_str(impl, &op->src, src_flags, &buf);
+
+        if (op->kind == EcsQueryNot || 
+            op->kind == EcsQueryOr || 
+            op->kind == EcsQueryOptional || 
+            op->kind == EcsQueryIfVar ||
+            op->kind == EcsQueryIfSet) 
+        {
+            indent ++;
+        }
+
+        if (op->kind == EcsQueryPopulate || 
+            op->kind == EcsQueryPopulateSelf ||
+            op->kind == EcsQueryTriv ||
+            op->kind == EcsQueryTrivData ||
+            op->kind == EcsQueryTrivWildcard)
+        {
+            flecs_query_str_append_bitset(&buf, op->src.entity);
+        }
+
+        if (op->kind == EcsQueryIfSet) {
+            ecs_strbuf_append(&buf, "[%d]\n", op->other);
+            continue;
+        }
+
+        bool is_toggle = op->kind == EcsQueryToggle || 
+            op->kind == EcsQueryToggleOption;
+
+        if (!first_flags && !second_flags && !is_toggle) {
+            ecs_strbuf_appendstr(&buf, "\n");
+            continue;
+        }
+
+        written = ecs_strbuf_written(&buf) - hidden_chars;
+        for (int32_t j = 0; j < (30 - (written - start)); j ++) {
+            ecs_strbuf_appendch(&buf, ' ');
+        }
+
+        if (is_toggle) {
+            if (op->first.entity) {
+                flecs_query_str_append_bitset(&buf, op->first.entity);
+            }
+            if (op->second.entity) {
+                if (op->first.entity) {
+                    ecs_strbuf_appendlit(&buf, ", !");
+                }
+                flecs_query_str_append_bitset(&buf, op->second.entity);
+            }
+            ecs_strbuf_appendstr(&buf, "\n");
+            continue;
+        }
+
+        ecs_strbuf_appendstr(&buf, "(");
+        if (op->kind == EcsQueryMemberEq || op->kind == EcsQueryMemberNeq) {
+            uint32_t offset = (uint32_t)op->first.entity;
+            uint32_t size = (uint32_t)(op->first.entity >> 32);
+            ecs_strbuf_append(&buf, "#[yellow]elem#[reset]([%d], 0x%x, 0x%x)", 
+                op->field_index, size, offset);
+        } else {
+            flecs_query_op_ref_str(impl, &op->first, first_flags, &buf);
+        }
+
+        if (second_flags) {
+            ecs_strbuf_appendstr(&buf, ", ");
+            flecs_query_op_ref_str(impl, &op->second, second_flags, &buf);
+        } else {
+            switch (op->kind) {
+            case EcsQueryPredEqName:
+            case EcsQueryPredNeqName:
+            case EcsQueryPredEqMatch:
+            case EcsQueryPredNeqMatch: {
+                int8_t term_index = op->term_index;
+                ecs_strbuf_appendstr(&buf, ", #[yellow]\"");
+                ecs_strbuf_appendstr(&buf, q->terms[term_index].second.name);
+                ecs_strbuf_appendstr(&buf, "\"#[reset]");
+                break;
+            }
+            case EcsQueryLookup: {
+                ecs_var_id_t src_id = op->src.var;
+                ecs_strbuf_appendstr(&buf, ", #[yellow]\"");
+                ecs_strbuf_appendstr(&buf, impl->vars[src_id].lookup);
+                ecs_strbuf_appendstr(&buf, "\"#[reset]");
+                break;
+            }
+            default:
+                break;
+            }
+        }
+
+        ecs_strbuf_appendch(&buf, ')');
+
+        ecs_strbuf_appendch(&buf, '\n');
+    }
+
+#ifdef FLECS_LOG    
+    char *str = ecs_strbuf_get(&buf);
+    flecs_colorize_buf(str, ecs_os_api.flags_ & EcsOsApiLogWithColors, &buf);
+    ecs_os_free(str);
+#endif
+    return ecs_strbuf_get(&buf);
+}
+
+char* ecs_query_plan(
+    const ecs_query_t *q)
+{
+    return ecs_query_str_w_profile(q, NULL);
+}
+
+static
+void flecs_query_str_add_id(
+    const ecs_world_t *world,
+    ecs_strbuf_t *buf,
+    const ecs_term_t *term,
+    const ecs_term_ref_t *ref,
+    bool is_src,
+    ecs_flags64_t default_traverse_flags)
+{
+    bool is_added = false;
+    ecs_entity_t ref_id = ECS_TERM_REF_ID(ref);
+    if (!is_src || ref_id != EcsThis) {
+        if (ref->id & EcsIsVariable && !ecs_id_is_wildcard(ref_id)){
+            ecs_strbuf_appendlit(buf, "$");
+        }
+        if (ref_id) {
+            char *path = ecs_get_fullpath(world, ref_id);
+            ecs_strbuf_appendstr(buf, path);
+            ecs_os_free(path);
+        } else if (ref->name) {
+            ecs_strbuf_appendstr(buf, ref->name);
+        } else {
+            ecs_strbuf_appendlit(buf, "0");
+        }
+        is_added = true;
+    }
+
+    ecs_flags64_t flags = ECS_TERM_REF_FLAGS(ref);
+    if (!(flags & EcsTraverseFlags)) {
+        /* If flags haven't been set yet, initialize with defaults. This can
+         * happen if an error is thrown while the term is being finalized */
+        flags |= default_traverse_flags;
+    }
+
+    if ((flags & EcsTraverseFlags) != default_traverse_flags) {
+        if (is_added) {
+            ecs_strbuf_list_push(buf, ":", "|");
+        } else {
+            ecs_strbuf_list_push(buf, "", "|");
+        }
+        if (is_src) {
+            if (flags & EcsSelf) {
+                ecs_strbuf_list_appendstr(buf, "self");
+            }
+
+            if (flags & EcsCascade) {
+                ecs_strbuf_list_appendstr(buf, "cascade");
+            } else if (flags & EcsUp) {
+                ecs_strbuf_list_appendstr(buf, "up");
+            }
+
+            if (flags & EcsDesc) {
+                ecs_strbuf_list_appendstr(buf, "desc");
+            }
+
+            if (term->trav && (term->trav != EcsIsA)) {
+                ecs_strbuf_list_push(buf, "(", "");
+
+                char *rel_path = ecs_get_fullpath(world, term->trav);
+                ecs_strbuf_appendstr(buf, rel_path);
+                ecs_os_free(rel_path);
+
+                ecs_strbuf_list_pop(buf, ")");
+            }
+        }
+
+        ecs_strbuf_list_pop(buf, "");
+    }
+}
+
+static
+void flecs_term_str_w_strbuf(
+    const ecs_world_t *world,
+    const ecs_term_t *term,
+    ecs_strbuf_t *buf,
+    int32_t t)
+{
+    const ecs_term_ref_t *src = &term->src;
+    const ecs_term_ref_t *first = &term->first;
+    const ecs_term_ref_t *second = &term->second;
+
+    ecs_entity_t src_id = ECS_TERM_REF_ID(src);
+    ecs_entity_t first_id = ECS_TERM_REF_ID(first);
+
+    uint64_t def_src_mask = EcsSelf|EcsUp;
+    uint64_t def_first_mask = EcsSelf;
+    uint64_t def_second_mask = EcsSelf;
+
+    bool src_set = !ecs_term_match_0(term);
+    bool first_set = ecs_term_ref_is_set(first);
+    bool second_set = ecs_term_ref_is_set(second);
+
+    if (first_id == EcsScopeOpen) {
+        ecs_strbuf_appendlit(buf, "{");
+        return;
+    } else if (first_id == EcsScopeClose) {
+        ecs_strbuf_appendlit(buf, "}");
+        return;
+    }
+
+    if (((ECS_TERM_REF_ID(&term->first) == EcsPredEq) || 
+         (ECS_TERM_REF_ID(&term->first) == EcsPredMatch)) && 
+        (term->first.id & EcsIsEntity)) 
+    {
+        ecs_strbuf_appendlit(buf, "$");
+        if (ECS_TERM_REF_ID(&term->src) == EcsThis && 
+           (term->src.id & EcsIsVariable))
+        {
+            ecs_strbuf_appendlit(buf, "this");
+        } else if (term->src.id & EcsIsVariable) {
+            ecs_strbuf_appendstr(buf, term->src.name);
+        } else {
+            /* Shouldn't happen */
+        }
+
+        if (ECS_TERM_REF_ID(&term->first) == EcsPredEq) {
+            if (term->oper == EcsNot) {
+                ecs_strbuf_appendlit(buf, " != ");
+            } else {
+                ecs_strbuf_appendlit(buf, " == ");
+            }
+        } else if (ECS_TERM_REF_ID(&term->first) == EcsPredMatch) {
+            ecs_strbuf_appendlit(buf, " ~= ");
+        }
+
+        if (term->second.id & EcsIsEntity) {
+            if (term->second.id != 0) {
+                ecs_get_path_w_sep_buf(
+                    world, 0, ECS_TERM_REF_ID(&term->second), ".", NULL, buf);
+            }
+        } else {
+            if (term->second.id & EcsIsVariable) {
+                ecs_strbuf_appendlit(buf, "$");
+                if (term->second.name) {
+                    ecs_strbuf_appendstr(buf, term->second.name);
+                } else if (ECS_TERM_REF_ID(&term->second) == EcsThis) {
+                    ecs_strbuf_appendlit(buf, "this");
+                }
+            } else if (term->second.id & EcsIsName) {
+                ecs_strbuf_appendlit(buf, "\"");
+                if ((ECS_TERM_REF_ID(&term->first) == EcsPredMatch) && 
+                    (term->oper == EcsNot)) 
+                {
+                    ecs_strbuf_appendlit(buf, "!");
+                }
+                ecs_strbuf_appendstr(buf, term->second.name);
+                ecs_strbuf_appendlit(buf, "\"");
+            }
+        }
+
+        return;
+    }
+
+    if (!t || !(term[-1].oper == EcsOr)) {
+        if (term->inout == EcsIn) {
+            ecs_strbuf_appendlit(buf, "[in] ");
+        } else if (term->inout == EcsInOut) {
+            ecs_strbuf_appendlit(buf, "[inout] ");
+        } else if (term->inout == EcsOut) {
+            ecs_strbuf_appendlit(buf, "[out] ");
+        } else if (term->inout == EcsInOutNone && term->oper != EcsNot) {
+            ecs_strbuf_appendlit(buf, "[none] ");
+        }
+    }
+
+    if (term->first.id & EcsIsEntity && first_id) {
+        if (ecs_has_id(world, first_id, EcsDontInherit)) {
+            def_src_mask = EcsSelf;
+        }
+    }
+
+    if (term->oper == EcsNot) {
+        ecs_strbuf_appendlit(buf, "!");
+    } else if (term->oper == EcsOptional) {
+        ecs_strbuf_appendlit(buf, "?");
+    }
+
+    if (!src_set) {
+        flecs_query_str_add_id(world, buf, term, &term->first, false, 
+            def_first_mask);
+        if (!second_set) {
+            ecs_strbuf_appendlit(buf, "()");
+        } else {
+            ecs_strbuf_appendlit(buf, "(0,");
+            flecs_query_str_add_id(world, buf, term, &term->second, false, 
+                def_second_mask);
+            ecs_strbuf_appendlit(buf, ")");
+        }
+    } else if (ecs_term_match_this(term) && 
+        (src->id & EcsTraverseFlags) == def_src_mask)
+    {
+        if (first_set) {
+            if (second_set) {
+                ecs_strbuf_appendlit(buf, "(");
+            }
+            flecs_query_str_add_id(world, buf, term, &term->first, false, 
+                def_first_mask);
+            if (second_set) {
+                ecs_strbuf_appendlit(buf, ",");
+                flecs_query_str_add_id(
+                    world, buf, term, &term->second, false, def_second_mask);
+                ecs_strbuf_appendlit(buf, ")");
+            }
+        } else if (term->id) {
+            char *str = ecs_id_str(world, term->id);
+            ecs_strbuf_appendstr(buf, str);
+            ecs_os_free(str);
+        }
+    } else {
+        ecs_id_t flags = term->id & ECS_ID_FLAGS_MASK;
+        if (flags && !ECS_HAS_ID_FLAG(flags, PAIR)) {
+            ecs_strbuf_appendstr(buf, ecs_id_flag_str(flags));
+            ecs_strbuf_appendch(buf, '|');
+        }
+
+        flecs_query_str_add_id(world, buf, term, &term->first, false, 
+            def_first_mask);
+        ecs_strbuf_appendlit(buf, "(");
+        if (term->src.id & EcsIsEntity && src_id == first_id) {
+            ecs_strbuf_appendlit(buf, "$");
+        } else {
+            flecs_query_str_add_id(world, buf, term, &term->src, true, 
+                def_src_mask);
+        }
+        if (second_set) {
+            ecs_strbuf_appendlit(buf, ",");
+            flecs_query_str_add_id(world, buf, term, &term->second, false, 
+                def_second_mask);
+        }
+        ecs_strbuf_appendlit(buf, ")");
+    }
+}
+
+char* ecs_term_str(
+    const ecs_world_t *world,
+    const ecs_term_t *term)
+{
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    flecs_term_str_w_strbuf(world, term, &buf, 0);
+    return ecs_strbuf_get(&buf);
+}
+
+char* flecs_query_str(
+    const ecs_world_t *world,
+    const ecs_query_t *query,
+    const ecs_query_validator_ctx_t *ctx,
+    int32_t *term_start_out)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    ecs_strbuf_t buf = ECS_STRBUF_INIT;
+    const ecs_term_t *terms = query->terms;
+    int32_t i, count = query->term_count;
+
+    for (i = 0; i < count; i ++) {
+        const ecs_term_t *term = &terms[i];
+
+        if (term_start_out && ctx) {
+            if (ctx->term_index == i) {
+                term_start_out[0] = ecs_strbuf_written(&buf);
+                if (i) {
+                    term_start_out[0] += 2; /* whitespace  + , */
+                }
+            }
+        }
+
+        flecs_term_str_w_strbuf(world, term, &buf, i);
+
+        if (i != (count - 1)) {
+            if (term->oper == EcsOr) {
+                ecs_strbuf_appendlit(&buf, " || ");
+            } else {
+                if (ECS_TERM_REF_ID(&term->first) != EcsScopeOpen) {
+                    if (ECS_TERM_REF_ID(&term[1].first) != EcsScopeClose) {
+                        ecs_strbuf_appendlit(&buf, ", ");
+                    }
+                }
+            }
+        }
+    }
+
+    return ecs_strbuf_get(&buf);
+error:
+    return NULL;
+}
+
+char* ecs_query_str(
+    const ecs_query_t *q)
+{
+    return flecs_query_str(q->world, q, NULL, NULL);
+}
+
+int32_t flecs_query_pivot_term(
+    const ecs_world_t *world,
+    const ecs_query_t *query)
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL);
+
+    const ecs_term_t *terms = query->terms;
+    int32_t i, term_count = query->term_count;
+    int32_t pivot_term = -1, min_count = -1, self_pivot_term = -1;
+
+    for (i = 0; i < term_count; i ++) {
+        const ecs_term_t *term = &terms[i];
+        ecs_id_t id = term->id;
+
+        if ((term->oper != EcsAnd) || (i && (term[-1].oper == EcsOr))) {
+            continue;
+        }
+
+        if (!ecs_term_match_this(term)) {
+            continue;
+        }
+
+        ecs_id_record_t *idr = flecs_id_record_get(world, id);
+        if (!idr) {
+            /* If one of the terms does not match with any data, iterator 
+             * should not return anything */
+            return -2; /* -2 indicates query doesn't match anything */
+        }
+
+        int32_t table_count = flecs_table_cache_count(&idr->cache);
+        if (min_count == -1 || table_count < min_count) {
+            min_count = table_count;
+            pivot_term = i;
+            if ((term->src.id & EcsTraverseFlags) == EcsSelf) {
+                self_pivot_term = i;
+            }
+        }
+    }
+
+    if (self_pivot_term != -1) {
+        pivot_term = self_pivot_term;
+    }
+
+    return pivot_term;
+error:
+    return -2;
+}
+
+void flecs_query_apply_iter_flags(
+    ecs_iter_t *it,
+    const ecs_query_t *query)
+{
+    ECS_BIT_COND(it->flags, EcsIterIsInstanced, 
+        ECS_BIT_IS_SET(query->flags, EcsQueryIsInstanced));
+    ECS_BIT_COND(it->flags, EcsIterNoData,
+        ECS_BIT_IS_SET(query->flags, EcsQueryNoData));
+    ECS_BIT_COND(it->flags, EcsIterHasCondSet, 
+        ECS_BIT_IS_SET(query->flags, EcsQueryHasCondSet));
+}
diff --git a/src/query/util.h b/src/query/util.h
new file mode 100644
index 000000000..d135a7a63
--- /dev/null
+++ b/src/query/util.h
@@ -0,0 +1,80 @@
+/**
+ * @file query/util.h
+ * @brief Utility functions
+ */
+
+#include "types.h"
+
+/* Helper type for passing around context required for error messages */
+typedef struct {
+    const ecs_world_t *world;
+    ecs_query_t *query;
+    ecs_term_t *term;
+    int32_t term_index;
+} ecs_query_validator_ctx_t;
+
+/* Convert integer to label */
+ecs_query_lbl_t flecs_itolbl(
+    int64_t val);
+
+/* Convert integer to variable id */
+ecs_var_id_t flecs_itovar(
+    int64_t val);
+
+/* Convert unsigned integer to variable id */
+ecs_var_id_t flecs_utovar(
+    uint64_t val);
+
+/* Get name for term ref */
+const char* flecs_term_ref_var_name(
+    ecs_term_ref_t *ref);
+
+/* Is term ref wildcard */
+bool flecs_term_ref_is_wildcard(
+    ecs_term_ref_t *ref);
+
+/* Does term use builtin predicates (eq, neq, ...)*/
+bool flecs_term_is_builtin_pred(
+    ecs_term_t *term);
+
+/* Does term have fixed id */
+bool flecs_term_is_fixed_id(
+    ecs_query_t *q,
+    ecs_term_t *term);
+
+/* Is term part of OR chain */
+bool flecs_term_is_or(
+    const ecs_query_t *q,
+    const ecs_term_t *term);
+
+/* Get ref flags (IsEntity) or IsVar) for ref (Src, First, Second) */
+ecs_flags16_t flecs_query_ref_flags(
+    ecs_flags16_t flags,
+    ecs_flags16_t kind);
+
+/* Check if variable is written */
+bool flecs_query_is_written(
+    ecs_var_id_t var_id,
+    uint64_t written);
+
+/* Check if ref is written (calls flecs_query_is_written)*/
+bool flecs_ref_is_written(
+    const ecs_query_op_t *op,
+    const ecs_query_ref_t *ref,
+    ecs_flags16_t kind,
+    uint64_t written);
+
+/* Get allocator from iterator */
+ecs_allocator_t* flecs_query_get_allocator(
+    const ecs_iter_t *it);
+
+/* Convert query to string */
+char* flecs_query_str(
+    const ecs_world_t *world,
+    const ecs_query_t *query,
+    const ecs_query_validator_ctx_t *ctx,
+    int32_t *term_start_out);
+
+/* Convert instruction kind to string */
+const char* flecs_query_op_str(
+    uint16_t kind);
diff --git a/src/query/validator.c b/src/query/validator.c
new file mode 100644
index 000000000..c9e1761da
--- /dev/null
+++ b/src/query/validator.c
@@ -0,0 +1,1396 @@
+/**
+ * @file validator.c
+ * @brief Validate and finalize queries.
+ */
+
+#include "../private_api.h"
+#include <ctype.h>
+
+#ifdef FLECS_SCRIPT
+#include "../addons/script/script.h"
+#endif
+
+static
+void flecs_query_validator_error(
+    const ecs_query_validator_ctx_t *ctx,
+    const char *fmt,
+    ...)
+{
+    va_list args;
+    va_start(args, fmt);
+
+    int32_t term_start = 0;
+
+    char *expr = NULL;
+    if (ctx->query) {
+        expr = flecs_query_str(ctx->world, ctx->query, ctx, &term_start);
+    } else {
+        expr = ecs_term_str(ctx->world, ctx->term);
+    }
+    const char *name = NULL;
+    if (ctx->query && ctx->query->entity) {
+        name = ecs_get_name(ctx->query->world, ctx->query->entity);
+    }
+    ecs_parser_errorv(name, expr, term_start, fmt, args);
+    ecs_os_free(expr);
+
+    va_end(args);
+}
+
+static
+int flecs_term_ref_finalize_flags(
+    ecs_term_ref_t *ref,
+    ecs_query_validator_ctx_t *ctx)
+{
+    if ((ref->id & EcsIsEntity) && (ref->id & EcsIsVariable)) {
+        flecs_query_validator_error(ctx, "cannot set both IsEntity and IsVariable");
+        return -1;
+    }
+
+    if (ref->name && ref->name[0] == '$') {
+        if (!ref->name[1]) {
+            if (ref->id & ~EcsTermRefFlags) {
+                flecs_query_validator_error(ctx, 
+                    "conflicting values for .name and .id");
+                return -1;
+            }
+
+            ref->id |= EcsVariable;
+        } else {
+            ref->name = &ref->name[1];
+        }
+
+        ref->id |= EcsIsVariable;
+    } 
+
+    if (!(ref->id & (EcsIsEntity|EcsIsVariable|EcsIsName))) {
+        if (ECS_TERM_REF_ID(ref) || ref->name) {
+            if (ECS_TERM_REF_ID(ref) == EcsThis || 
+                ECS_TERM_REF_ID(ref) == EcsWildcard || 
+                ECS_TERM_REF_ID(ref) == EcsAny || 
+                ECS_TERM_REF_ID(ref) == EcsVariable) 
+            {
+                /* Builtin variable ids default to variable */
+                ref->id |= EcsIsVariable;
+            } else {
+                ref->id |= EcsIsEntity;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static
+int flecs_term_ref_lookup(
+    const ecs_world_t *world,
+    ecs_entity_t scope,
+    ecs_term_ref_t *ref,
+    ecs_query_validator_ctx_t *ctx)
+{
+    const char *name = ref->name;
+    if (!name) {
+        return 0;
+    }
+
+    if (ref->id & EcsIsVariable) {
+        if (!ecs_os_strcmp(name, "this")) {
+            ref->id = EcsThis | ECS_TERM_REF_FLAGS(ref);
+            ref->name = NULL;
+            return 0;
+        }
+        return 0;
+    } else if (ref->id & EcsIsName) {
+        if (ref->name == NULL) {
+            flecs_query_validator_error(ctx, "IsName flag specified without name");
+            return -1;
+        }
+        return 0;
+    }
+
+    ecs_assert(ref->id & EcsIsEntity, ECS_INTERNAL_ERROR, NULL);
+
+    if (flecs_identifier_is_0(name)) {
+        if (ECS_TERM_REF_ID(ref)) {
+            flecs_query_validator_error(
+                ctx, "name '0' does not match entity id");
+            return -1;
+        }
+        ref->name = NULL;
+        return 0;
+    }
+
+    ecs_entity_t e = 0;
+    if (scope) {
+        e = ecs_lookup_child(world, scope, name);
+    }
+
+    if (!e) {
+        e = ecs_lookup(world, name);
+    }
+
+    if (!e) {
+        if (ctx->query && (ctx->query->flags & EcsQueryAllowUnresolvedByName)) {
+            ref->id |= EcsIsName;
+            ref->id &= ~EcsIsEntity;
+            return 0;
+        } else {
+            flecs_query_validator_error(ctx, "unresolved identifier '%s'", name);
+            return -1;
+        }
+    }
+
+    ecs_entity_t ref_id = ECS_TERM_REF_ID(ref);
+    if (ref_id && ref_id != e) {
+        char *e_str = ecs_get_fullpath(world, ref_id);
+        flecs_query_validator_error(ctx, "name '%s' does not match term.id '%s'", 
+            name, e_str);
+        ecs_os_free(e_str);
+        return -1;
+    }
+
+    ref->id = e | ECS_TERM_REF_FLAGS(ref);
+    ref_id = ECS_TERM_REF_ID(ref);
+
+    if (!ecs_os_strcmp(name, "*") || !ecs_os_strcmp(name, "_") || 
+        !ecs_os_strcmp(name, "$")) 
+    {
+        ref->id &= ~EcsIsEntity;
+        ref->id |= EcsIsVariable;
+    }
+
+    /* Check if looked up id is alive (relevant for numerical ids) */
+    if (!(ref->id & EcsIsName) && ref_id) {
+        if (!ecs_is_alive(world, ref_id)) {
+            flecs_query_validator_error(ctx, "identifier '%s' is not alive", ref->name);
+            return -1;
+        }
+
+        ref->name = NULL;
+        return 0;
+    }
+
+    return 0;
+}
+
+static
+int flecs_term_refs_finalize(
+    const ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
+{
+    ecs_term_ref_t *src = &term->src;
+    ecs_term_ref_t *first = &term->first;
+    ecs_term_ref_t *second = &term->second;
+
+    if ((term->src.id & EcsCascade) && !(term->src.id & EcsUp)) {
+        /* If cascade is specified without up/down, add up */
+        term->src.id |= EcsUp;
+    }
+
+    if (!(src->id & EcsTraverseFlags)) {
+        /* When no traversal flags are specified, the default traversal 
+         * relationship is IsA so inherited components are matched by default */
+        src->id |= EcsSelf | EcsUp;
+        if (!term->trav) {
+            term->trav = EcsIsA;
+        }
+    } else if ((src->id & EcsUp) && !term->trav) {
+        /* When traversal flags are specified but no traversal relationship,
+         * default to ChildOf, which is the most common kind of traversal. */
+        term->trav = EcsChildOf;
+    }
+
+    /* Include subsets for component by default, to support inheritance */
+    if (!(first->id & EcsTraverseFlags)) {
+        first->id |= EcsSelf;
+    }
+
+    /* Traverse Self by default for pair target */
+    if (!(second->id & EcsTraverseFlags)) {
+        if (ECS_TERM_REF_ID(second) || second->name || (second->id & EcsIsEntity)) {
+            second->id |= EcsSelf;
+        }
+    }
+
+    /* Source defaults to This */
+    if (!ECS_TERM_REF_ID(src) && (src->name == NULL) && !(src->id & EcsIsEntity)) {
+        src->id = EcsThis | ECS_TERM_REF_FLAGS(src);
+        src->id |= EcsIsVariable;
+    }
+
+    /* Initialize term identifier flags */
+    if (flecs_term_ref_finalize_flags(src, ctx)) {
+        return -1;
+    }
+
+    if (flecs_term_ref_finalize_flags(first, ctx)) {
+        return -1;
+    }
+
+    if (flecs_term_ref_finalize_flags(second, ctx)) {
+        return -1;
+    }
+
+    /* Lookup term identifiers by name */
+    if (flecs_term_ref_lookup(world, 0, src, ctx)) {
+        return -1;
+    }
+    if (flecs_term_ref_lookup(world, 0, first, ctx)) {
+        return -1;
+    }
+
+    ecs_entity_t first_id = 0;
+    ecs_entity_t oneof = 0;
+    if (first->id & EcsIsEntity) {
+        first_id = ECS_TERM_REF_ID(first);
+
+        if (!first_id) {
+            flecs_query_validator_error(ctx, "invalid \"0\" for first.name");
+            return -1;
+        }
+
+        /* If first element of pair has OneOf property, lookup second element of
+         * pair in the value of the OneOf property */
+        oneof = flecs_get_oneof(world, first_id);
+    }
+
+    if (flecs_term_ref_lookup(world, oneof, &term->second, ctx)) {
+        return -1;
+    }
+
+    /* If source is 0, reset traversal flags */
+    if (ECS_TERM_REF_ID(src) == 0 && src->id & EcsIsEntity) {
+        src->id &= ~EcsTraverseFlags;
+        term->trav = 0;
+    }
+
+    /* If source is wildcard, term won't return any data */
+    if ((src->id & EcsIsVariable) && ecs_id_is_wildcard(ECS_TERM_REF_ID(src))) {
+        term->inout = EcsInOutNone;
+    }
+
+    return 0;
+}
+
+static
+ecs_entity_t flecs_term_ref_get_entity(
+    const ecs_term_ref_t *ref)
+{
+    if (ref->id & EcsIsEntity) {
+        return ECS_TERM_REF_ID(ref); /* Id is known */
+    } else if (ref->id & EcsIsVariable) {
+        /* Return wildcard for variables, as they aren't known yet */
+        if (ECS_TERM_REF_ID(ref) != EcsAny) {
+            /* Any variable should not use wildcard, as this would return all
+             * ids matching a wildcard, whereas Any returns the first match */
+            return EcsWildcard;
+        } else {
+            return EcsAny;
+        }
+    } else {
+        return 0; /* Term id is uninitialized */
+    }
+}
+
+static
+int flecs_term_populate_id(
+    ecs_term_t *term)
+{
+    ecs_entity_t first = flecs_term_ref_get_entity(&term->first);
+    ecs_entity_t second = flecs_term_ref_get_entity(&term->second);
+    ecs_id_t flags = term->id & ECS_ID_FLAGS_MASK;
+
+    if (first & ECS_ID_FLAGS_MASK) {
+        return -1;
+    }
+    if (second & ECS_ID_FLAGS_MASK) {
+        return -1;
+    }
+
+    if ((second || (term->second.id & EcsIsEntity))) {
+        flags |= ECS_PAIR;
+    }
+
+    if (!second && !ECS_HAS_ID_FLAG(flags, PAIR)) {
+        term->id = first | flags;
+    } else {
+        term->id = ecs_pair(first, second) | flags;
+    }
+
+    return 0;
+}
+
+static
+int flecs_term_populate_from_id(
+    const ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
+{
+    ecs_entity_t first = 0;
+    ecs_entity_t second = 0;
+
+    if (ECS_HAS_ID_FLAG(term->id, PAIR)) {
+        first = ECS_PAIR_FIRST(term->id);
+        second = ECS_PAIR_SECOND(term->id);
+
+        if (!first) {
+            flecs_query_validator_error(ctx, "missing first element in term.id");
+            return -1;
+        }
+        if (!second) {
+            if (first != EcsChildOf) {
+                flecs_query_validator_error(ctx, "missing second element in term.id");
+                return -1;
+            } else {
+                /* (ChildOf, 0) is allowed so query can be used to efficiently
+                 * query for root entities */
+            }
+        }
+    } else {
+        first = term->id & ECS_COMPONENT_MASK;
+        if (!first) {
+            flecs_query_validator_error(ctx, "missing first element in term.id");
+            return -1;
+        }
+    }
+
+    ecs_entity_t term_first = flecs_term_ref_get_entity(&term->first);
+    if (term_first) {
+        if ((uint32_t)term_first != (uint32_t)first) {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.first");
+            return -1;
+        }
+    } else {
+        ecs_entity_t first_id = ecs_get_alive(world, first);
+        if (!first_id) {
+            term->first.id = first | ECS_TERM_REF_FLAGS(&term->first);
+        } else {
+            term->first.id = first_id | ECS_TERM_REF_FLAGS(&term->first);
+        }
+    }
+
+    ecs_entity_t term_second = flecs_term_ref_get_entity(&term->second);
+    if (term_second) {
+        if ((uint32_t)term_second != second) {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.second");
+            return -1;
+        }
+    } else if (second) {
+        ecs_entity_t second_id = ecs_get_alive(world, second);
+        if (!second_id) {
+            term->second.id = second | ECS_TERM_REF_FLAGS(&term->second);
+        } else {
+            term->second.id = second_id | ECS_TERM_REF_FLAGS(&term->second);
+        }
+    }
+
+    return 0;
+}
+
+static
+int flecs_term_verify_eq_pred(
+    const ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
+{
+    const ecs_term_ref_t *second = &term->second;
+    const ecs_term_ref_t *src = &term->src;
+    ecs_entity_t first_id = ECS_TERM_REF_ID(&term->first);
+    ecs_entity_t second_id = ECS_TERM_REF_ID(&term->second);
+    ecs_entity_t src_id = ECS_TERM_REF_ID(&term->src);
+
+    if (term->oper != EcsAnd && term->oper != EcsNot && term->oper != EcsOr) {
+        flecs_query_validator_error(ctx, "invalid operator combination");
+        goto error;
+    }
+
+    if ((src->id & EcsIsName) && (second->id & EcsIsName)) {
+        flecs_query_validator_error(ctx, "both sides of operator cannot be a name");
+        goto error;
+    }
+
+    if ((src->id & EcsIsEntity) && (second->id & EcsIsEntity)) {
+        flecs_query_validator_error(ctx, "both sides of operator cannot be an entity");
+        goto error;
+    }
+
+    if (!(src->id & EcsIsVariable)) {
+        flecs_query_validator_error(ctx, "left-hand of operator must be a variable");
+        goto error;
+    }
+
+    if (first_id == EcsPredMatch && !(second->id & EcsIsName)) {
+        flecs_query_validator_error(ctx, "right-hand of match operator must be a string");
+        goto error;
+    }
+
+    if ((src->id & EcsIsVariable) && (second->id & EcsIsVariable)) {
+        if (src_id && src_id == second_id) {
+            flecs_query_validator_error(ctx, "both sides of operator are equal");
+            goto error;
+        }
+        if (src->name && second->name && !ecs_os_strcmp(src->name, second->name)) {
+            flecs_query_validator_error(ctx, "both sides of operator are equal");
+            goto error;
+        }
+    }
+
+    return 0;
+error:
+    return -1;
+}
+
+static
+int flecs_term_verify(
+    const ecs_world_t *world,
+    const ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
+{
+    const ecs_term_ref_t *first = &term->first;
+    const ecs_term_ref_t *second = &term->second;
+    const ecs_term_ref_t *src = &term->src;
+    ecs_entity_t first_id = 0, second_id = 0;
+    ecs_id_t flags = term->id & ECS_ID_FLAGS_MASK;
+    ecs_id_t id = term->id;
+
+    if ((src->id & EcsIsName) && (second->id & EcsIsName)) {
+        flecs_query_validator_error(ctx, "mismatch between term.id_flags & term.id");
+        return -1;
+    }
+
+    ecs_entity_t src_id = ECS_TERM_REF_ID(src);
+    if (first->id & EcsIsEntity) {
+        first_id = ECS_TERM_REF_ID(first);
+    }
+
+    if (second->id & EcsIsEntity) {
+        second_id = ECS_TERM_REF_ID(second);
+    }
+
+    if (first_id == EcsPredEq || first_id == EcsPredMatch || first_id == EcsPredLookup) {
+        return flecs_term_verify_eq_pred(term, ctx);
+    }
+
+    if (ecs_term_ref_is_set(second) && !ECS_HAS_ID_FLAG(flags, PAIR)) {
+        flecs_query_validator_error(ctx, "expected PAIR flag for term with pair");
+        return -1;
+    } else if (!ecs_term_ref_is_set(second) && ECS_HAS_ID_FLAG(flags, PAIR)) {
+        if (first_id != EcsChildOf) {
+            flecs_query_validator_error(ctx, "unexpected PAIR flag for term without pair");
+            return -1;
+        } else {
+            /* Exception is made for ChildOf so we can use (ChildOf, 0) to match
+             * all entities in the root */
+        }
+    }
+
+    if (!ecs_term_ref_is_set(src)) {
+        flecs_query_validator_error(ctx, "term.src is not initialized");
+        return -1;
+    }
+
+    if (!ecs_term_ref_is_set(first)) {
+        flecs_query_validator_error(ctx, "term.first is not initialized");
+        return -1;
+    }
+
+    if (ECS_HAS_ID_FLAG(flags, PAIR)) {
+        if (!ECS_PAIR_FIRST(id)) {
+            flecs_query_validator_error(ctx, "invalid 0 for first element in pair id");
+            return -1;
+        }
+        if ((ECS_PAIR_FIRST(id) != EcsChildOf) && !ECS_PAIR_SECOND(id)) {
+            flecs_query_validator_error(ctx, "invalid 0 for second element in pair id");
+            return -1;
+        }
+
+        if ((first->id & EcsIsEntity) && 
+            (ecs_entity_t_lo(first_id) != ECS_PAIR_FIRST(id))) 
+        {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.first");
+            return -1;
+        }
+        if ((first->id & EcsIsVariable) && 
+            !ecs_id_is_wildcard(ECS_PAIR_FIRST(id)))
+        {
+            char *id_str = ecs_id_str(world, id);
+            flecs_query_validator_error(ctx, 
+                "expected wildcard for variable term.first (got %s)", id_str);
+            ecs_os_free(id_str);
+            return -1;
+        }
+
+        if ((second->id & EcsIsEntity) && 
+            (ecs_entity_t_lo(second_id) != ECS_PAIR_SECOND(id))) 
+        {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.second");
+            return -1;
+        }
+        if ((second->id & EcsIsVariable) && 
+            !ecs_id_is_wildcard(ECS_PAIR_SECOND(id))) 
+        {
+            char *id_str = ecs_id_str(world, id);
+            flecs_query_validator_error(ctx, 
+                "expected wildcard for variable term.second (got %s)", id_str);
+            ecs_os_free(id_str);
+            return -1;
+        }
+    } else {
+        ecs_entity_t component = id & ECS_COMPONENT_MASK;
+        if (!component) {
+            flecs_query_validator_error(ctx, "missing component id");
+            return -1;
+        }
+        if ((first->id & EcsIsEntity) && 
+            (ecs_entity_t_lo(first_id) != ecs_entity_t_lo(component))) 
+        {
+            flecs_query_validator_error(ctx, "mismatch between term.id and term.first");
+            return -1;
+        }
+        if ((first->id & EcsIsVariable) && !ecs_id_is_wildcard(component)) {
+            char *id_str = ecs_id_str(world, id);
+            flecs_query_validator_error(ctx, 
+                "expected wildcard for variable term.first (got %s)", id_str);
+            ecs_os_free(id_str);
+            return -1;
+        }
+    }
+
+    if (first_id) {
+        if (ecs_term_ref_is_set(second)) {
+            ecs_flags64_t mask = EcsIsEntity | EcsIsVariable;
+            if ((src->id & mask) == (second->id & mask)) {
+                bool is_same = false;
+                if (src->id & EcsIsEntity) {
+                    is_same = src_id == second_id;
+                } else if (src->name && second->name) {
+                    is_same = !ecs_os_strcmp(src->name, second->name);
+                }
+
+                if (is_same && ecs_has_id(world, first_id, EcsAcyclic)
+                    && !(term->flags_ & EcsTermReflexive)) 
+                {
+                    char *pred_str = ecs_get_fullpath(world, term->first.id);
+                    flecs_query_validator_error(ctx, "term with acyclic relationship"
+                        " '%s' cannot have same subject and object",
+                            pred_str);
+                    ecs_os_free(pred_str);
+                    return -1;
+                }
+            }
+        }
+
+        if (second_id && !ecs_id_is_wildcard(second_id)) {
+            ecs_entity_t oneof = flecs_get_oneof(world, first_id);
+            if (oneof) {
+                if (!ecs_has_pair(world, second_id, EcsChildOf, oneof)) {
+                    char *second_str = ecs_get_fullpath(world, second_id);
+                    char *oneof_str = ecs_get_fullpath(world, oneof);
+                    char *id_str = ecs_id_str(world, term->id);
+                    flecs_query_validator_error(ctx, 
+                        "invalid target '%s' for %s: must be child of '%s'",
+                            second_str, id_str, oneof_str);
+                    ecs_os_free(second_str);
+                    ecs_os_free(oneof_str);
+                    ecs_os_free(id_str);
+                    return -1;
+                }
+            }
+        }
+    }
+
+    if (term->trav) {
+        if (!ecs_has_id(world, term->trav, EcsTraversable)) {
+            char *r_str = ecs_get_fullpath(world, term->trav);
+            flecs_query_validator_error(ctx, 
+                "cannot traverse non-traversable relationship '%s'", r_str);
+            ecs_os_free(r_str);
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+static
+int flecs_term_finalize(
+    const ecs_world_t *world,
+    ecs_term_t *term,
+    ecs_query_validator_ctx_t *ctx)
+{
+    ctx->term = term;
+
+    ecs_term_ref_t *src = &term->src;
+    ecs_term_ref_t *first = &term->first;
+    ecs_term_ref_t *second = &term->second;
+    ecs_flags64_t src_flags = ECS_TERM_REF_FLAGS(src);
+    ecs_flags64_t first_flags = ECS_TERM_REF_FLAGS(first);
+    ecs_flags64_t second_flags = ECS_TERM_REF_FLAGS(second);
+
+    if (first->name && (first->id & ~EcsTermRefFlags)) {
+        flecs_query_validator_error(ctx, 
+            "first.name and first.id have competing values");
+        return -1;
+    }
+    if (src->name && (src->id & ~EcsTermRefFlags)) {
+        flecs_query_validator_error(ctx, 
+            "src.name and src.id have competing values");
+        return -1;
+    }
+    if (second->name && (second->id & ~EcsTermRefFlags)) {
+        flecs_query_validator_error(ctx, 
+            "second.name and second.id have competing values");
+        return -1;
+    }
+
+
+    if (term->id & ~ECS_ID_FLAGS_MASK) {
+        if (flecs_term_populate_from_id(world, term, ctx)) {
+            return -1;
+        }
+    }
+
+    if (flecs_term_refs_finalize(world, term, ctx)) {
+        return -1;
+    }
+
+    ecs_entity_t first_id = ECS_TERM_REF_ID(first);
+    ecs_entity_t second_id = ECS_TERM_REF_ID(second);
+    ecs_entity_t src_id = ECS_TERM_REF_ID(src);
+
+    if ((first->id & EcsIsVariable) && (first_id == EcsAny)) {
+        term->flags_ |= EcsTermMatchAny;
+    }
+
+    if ((second->id & EcsIsVariable) && (second_id == EcsAny)) {
+        term->flags_ |= EcsTermMatchAny;
+    }
+
+    if ((src->id & EcsIsVariable) && (src_id == EcsAny)) {
+        term->flags_ |= EcsTermMatchAnySrc;
+    }
+
+    ecs_flags64_t ent_var_mask = EcsIsEntity | EcsIsVariable;
+
+    /* If EcsVariable is used by itself, assign to predicate (singleton) */
+    if ((ECS_TERM_REF_ID(src) == EcsVariable) && (src->id & EcsIsVariable)) {
+        src->id = first->id | ECS_TERM_REF_FLAGS(src);
+        src->id &= ~ent_var_mask;
+        src->id |= first->id & ent_var_mask;
+        src->name = first->name;
+    }
+
+    if ((ECS_TERM_REF_ID(second) == EcsVariable) && (second->id & EcsIsVariable)) {
+        second->id = first->id | ECS_TERM_REF_FLAGS(second);
+        second->id &= ~ent_var_mask;
+        second->id |= first->id & ent_var_mask;
+        second->name = first->name;
+    }
+
+    if (!(term->id & ~ECS_ID_FLAGS_MASK)) {
+        if (flecs_term_populate_id(term)) {
+            return -1;
+        }
+    }
+
+    /* If term queries for !(ChildOf, _), translate it to the builtin 
+     * (ChildOf, 0) index which is a cheaper way to find root entities */
+    if (term->oper == EcsNot && term->id == ecs_pair(EcsChildOf, EcsAny)) {
+        /* Only if the source is not EcsAny */
+        if (!(ECS_TERM_REF_ID(&term->src) == EcsAny && (term->src.id & EcsIsVariable))) {
+            term->oper = EcsAnd;
+            term->id = ecs_pair(EcsChildOf, 0);
+            second->id = 0;
+            second->id |= EcsSelf|EcsIsEntity;
+        }
+    }
+
+    ecs_entity_t first_entity = 0;
+    if ((first->id & EcsIsEntity)) {
+        first_entity = first_id;
+    }
+
+    ecs_id_record_t *idr = flecs_id_record_get(world, term->id);
+    ecs_flags32_t id_flags = idr ? idr->flags : 0;
+
+    if (first_entity) {
+        /* Only enable inheritance for ids which are inherited from at the time
+         * of query creation. To force component inheritance to be evaluated,
+         * an application can explicitly set traversal flags. */
+        if (flecs_id_record_get(world, ecs_pair(EcsIsA, first->id))) {
+            if (!((first_flags & EcsTraverseFlags) == EcsSelf)) {
+                term->flags_ |= EcsTermIdInherited;
+            }
+        }
+
+        /* Don't traverse ids that cannot be inherited */
+        if ((id_flags & EcsIdDontInherit) && (term->trav == EcsIsA)) {
+            if (src_flags & EcsUp) {
+                flecs_query_validator_error(ctx, 
+                    "traversing not allowed for id that can't be inherited");
+                return -1;
+            }
+            src->id &= ~EcsUp;
+            term->trav = 0;
+        }
+
+        /* If component id is final, don't attempt component inheritance */
+        ecs_record_t *first_record = flecs_entities_get(world, first_entity);
+        ecs_table_t *first_table = first_record ? first_record->table : NULL;
+        if (first_table) {
+            /* Add traversal flags for transitive relationships */
+            if (ecs_term_ref_is_set(second) && !((second_flags & EcsTraverseFlags) == EcsSelf)) {
+                if (!((src->id & EcsIsVariable) && (src_id == EcsAny))) {
+                    if (!((second->id & EcsIsVariable) && (second_id == EcsAny))) {
+                        if (ecs_table_has_id(world, first_table, EcsTransitive)) {
+                            term->flags_ |= EcsTermTransitive;
+                        }
+                    }
+                }
+            }
+
+            if (ecs_table_has_id(world, first_table, EcsReflexive)) {
+                term->flags_ |= EcsTermReflexive;
+            }
+        }
+
+        /* Check if term has toggleable component */
+        if (id_flags & EcsIdCanToggle) {
+            term->flags_ |= EcsTermIsToggle;
+        }
+
+        /* Check if this is a member query */
+#ifdef FLECS_META
+        if (ecs_id(EcsMember) != 0) {
+            if (first_entity) {
+                if (ecs_has(world, first_entity, EcsMember)) {
+                    term->flags_ |= EcsTermIsMember;
+                }
+            }
+        }
+#endif
+    }
+
+    if (ECS_TERM_REF_ID(first) == EcsVariable) {
+        flecs_query_validator_error(ctx, "invalid $ for term.first");
+        return -1;
+    }
+
+    if (term->oper == EcsAndFrom || term->oper == EcsOrFrom || term->oper == EcsNotFrom) {
+        if (term->inout != EcsInOutDefault && term->inout != EcsInOutNone) {
+            flecs_query_validator_error(ctx, 
+                "invalid inout value for AndFrom/OrFrom/NotFrom term");
+            return -1;
+        }
+    }
+
+    /* Is term trivial/cacheable */
+    bool cacheable_term = true;
+    bool trivial_term = true;
+    if (term->oper != EcsAnd) {
+        trivial_term = false;
+    }
+
+    if (ecs_id_is_wildcard(term->id)) {
+        if (!(id_flags & EcsIdExclusive)) {
+            trivial_term = false;
+        }
+
+        if (first->id & EcsIsVariable) {
+            if (!ecs_id_is_wildcard(first_id) || first_id == EcsAny) {
+                trivial_term = false;
+                cacheable_term = false;
+            }
+        }
+
+        if (second->id & EcsIsVariable) {
+            if (!ecs_id_is_wildcard(second_id) || second_id == EcsAny) {
+                trivial_term = false;
+                cacheable_term = false;
+            }
+        }
+    }
+
+    if (!ecs_term_match_this(term)) {
+        trivial_term = false;
+    }
+    if (term->flags_ & EcsTermTransitive) {
+        trivial_term = false;
+        cacheable_term = false;
+    }
+    if (term->flags_ & EcsTermIdInherited) {
+        trivial_term = false;
+        cacheable_term = false;
+    }
+    if (term->flags_ & EcsTermIsScope) {
+        cacheable_term = false;
+    }
+    if (term->trav && term->trav != EcsIsA) {
+        trivial_term = false;
+    }
+    if (!(src->id & EcsSelf)) {
+        trivial_term = false;
+    }
+    if (((ECS_TERM_REF_ID(&term->first) == EcsPredEq) || 
+         (ECS_TERM_REF_ID(&term->first) == EcsPredMatch) || 
+         (ECS_TERM_REF_ID(&term->first) == EcsPredLookup)) && 
+        (term->first.id & EcsIsEntity)) 
+    {
+        trivial_term = false;
+        cacheable_term = false;
+    }
+    if (ECS_TERM_REF_ID(src) != EcsThis) {
+        cacheable_term = false;
+    }
+    if (term->id == ecs_childof(0)) {
+        cacheable_term = false;
+    }
+    if (term->flags_ & EcsTermIsMember) {
+        trivial_term = false;
+        cacheable_term = false;
+
+    }
+    if (term->flags_ & EcsTermIsToggle) {
+        trivial_term = false;
+    }
+
+    ECS_BIT_COND16(term->flags_, EcsTermIsTrivial, trivial_term);
+    ECS_BIT_COND16(term->flags_, EcsTermIsCacheable, cacheable_term);
+
+    if (flecs_term_verify(world, term, ctx)) {
+        return -1;
+    }
+
+    return 0;
+}
+
+bool flecs_identifier_is_0(
+    const char *id)
+{
+    return id[0] == '0' && !id[1];
+}
+
+bool ecs_term_ref_is_set(
+    const ecs_term_ref_t *ref)
+{
+    return ECS_TERM_REF_ID(ref) != 0 || ref->name != NULL || ref->id & EcsIsEntity;
+}
+
+bool ecs_term_is_initialized(
+    const ecs_term_t *term)
+{
+    return term->id != 0 || ecs_term_ref_is_set(&term->first);
+}
+
+bool ecs_term_match_this(
+    const ecs_term_t *term)
+{
+    return (term->src.id & EcsIsVariable) && 
+        (ECS_TERM_REF_ID(&term->src) == EcsThis);
+}
+
+bool ecs_term_match_0(
+    const ecs_term_t *term)
+{
+    return (!ECS_TERM_REF_ID(&term->src) && (term->src.id & EcsIsEntity));
+}
+
+int ecs_term_finalize(
+    const ecs_world_t *world,
+    ecs_term_t *term)
+{
+    ecs_query_validator_ctx_t ctx = {0};
+    ctx.world = world;
+    ctx.term = term;
+    return flecs_term_finalize(world, term, &ctx);
+}
+
+static
+ecs_term_t* flecs_query_or_other_type(
+    ecs_query_t *q,
+    int32_t t)
+{
+    ecs_term_t *term = &q->terms[t];
+    ecs_term_t *first = NULL;
+    while (t--) {
+        if (q->terms[t].oper != EcsOr) {
+            break;
+        }
+        first = &q->terms[t];
+    }
+
+    if (first) {
+        ecs_world_t *world = q->world;
+        const ecs_type_info_t *first_type = ecs_get_type_info(world, first->id);
+        const ecs_type_info_t *term_type = ecs_get_type_info(world, term->id);
+        if (first_type == term_type) {
+            return NULL;
+        }
+        return first;
+    } else {
+        return NULL;
+    }
+}
+
+static
+void flecs_normalize_term_name(
+    ecs_term_ref_t *ref) 
+{
+    if (ref->name && ref->name[0] == '$' && ref->name[1]) {
+        ecs_assert(ref->id & EcsIsVariable, ECS_INTERNAL_ERROR, NULL);
+        const char *old = ref->name;
+        ref->name = &old[1];
+
+        if (!ecs_os_strcmp(ref->name, "this")) {
+            ref->name = NULL;
+            ref->id |= EcsThis;
+        }
+    }
+}
+
+static
+int flecs_query_finalize_terms(
+    const ecs_world_t *world,
+    ecs_query_t *q)
+{
+    int32_t i, term_count = q->term_count, field_count = 0;
+    ecs_term_t *terms = q->terms;
+    int32_t nodata_terms = 0, scope_nesting = 0, cacheable_terms = 0;
+    bool cond_set = false;
+
+    ecs_query_validator_ctx_t ctx = {0};
+    ctx.world = world;
+    ctx.query = q;
+
+    q->flags |= EcsQueryMatchOnlyThis;
+
+    bool cacheable = true;
+    for (i = 0; i < term_count; i ++) {
+        ecs_term_t *term = &terms[i];
+        bool prev_is_or = i && term[-1].oper == EcsOr;
+        bool nodata_term = false;
+        ctx.term_index = i;
+        if (flecs_term_finalize(world, term, &ctx)) {
+            return -1;
+        }
+
+        if (scope_nesting) {
+            /* Terms inside a scope are not cacheable */
+            ECS_BIT_CLEAR16(term->flags_, EcsTermIsCacheable);
+        }
+
+        /* If one of the terms in an OR chain isn't cacheable, none are */
+        if (term->flags_ & EcsTermIsCacheable) {
+            /* Current term is marked as cacheable. Check if it is part of an OR
+             * chain, and if so, the previous term was also cacheable. */
+            if (prev_is_or) {
+                if (term[-1].flags_ & EcsTermIsCacheable) {
+                    cacheable_terms ++;
+                } else {
+                    ECS_BIT_CLEAR16(term->flags_, EcsTermIsCacheable);
+                }
+            } else {
+                cacheable_terms ++;
+            }
+
+            /* Toggle terms may be cacheable for fetching the initial component, 
+             * but require an additional toggle instruction for evaluation. */
+            if (term->flags_ & EcsTermIsToggle) {
+                cacheable = false;
+            }
+        } else if (prev_is_or) {
+            /* Current term is not cacheable. If it is part of an OR chain, mark
+             * previous terms in the chain as also not cacheable. */
+            int32_t j;
+            for (j = i - 1; j >= 0; j --) {
+                if (terms[j].oper != EcsOr) {
+                    break;
+                }
+                if (terms[j].flags_ & EcsTermIsCacheable) {
+                    cacheable_terms --;
+                    ECS_BIT_CLEAR16(terms[j].flags_, EcsTermIsCacheable);
+                }
+            }
+        }
+
+        if (prev_is_or) {
+            if (ECS_TERM_REF_ID(&term[-1].src) != ECS_TERM_REF_ID(&term->src)) {
+                flecs_query_validator_error(&ctx, "mismatching src.id for OR terms");
+                return -1;
+            }
+            if (term->oper != EcsOr && term->oper != EcsAnd) {
+                flecs_query_validator_error(&ctx, 
+                    "term after OR operator must use AND operator");
+                return -1;
+            }
+        } else {
+            field_count ++;
+        }
+
+        term->field_index = flecs_ito(int16_t, field_count - 1);
+
+        if (ecs_id_is_wildcard(term->id)) {
+            q->flags |= EcsQueryMatchWildcards;
+        }
+
+        if (ecs_term_match_this(term)) {
+            ECS_BIT_SET(q->flags, EcsQueryMatchThis);
+        } else {
+            ECS_BIT_CLEAR(q->flags, EcsQueryMatchOnlyThis);
+        }
+
+        if (ECS_TERM_REF_ID(term) == EcsPrefab) {
+            ECS_BIT_SET(q->flags, EcsQueryMatchPrefab);
+        }
+        if (ECS_TERM_REF_ID(term) == EcsDisabled && (term->src.id & EcsSelf)) {
+            ECS_BIT_SET(q->flags, EcsQueryMatchDisabled);
+        }
+
+        if (ECS_BIT_IS_SET(q->flags, EcsQueryNoData)) {
+            term->inout = EcsInOutNone;
+        }
+        
+        if (term->oper == EcsNot && term->inout == EcsInOutDefault) {
+            term->inout = EcsInOutNone;
+        }
+
+        if ((term->id == EcsWildcard) || (term->id == 
+            ecs_pair(EcsWildcard, EcsWildcard))) 
+        {
+            /* If term type is unknown beforehand, default the inout type to
+             * none. This prevents accidentally requesting lots of components,
+             * which can put stress on serializer code. */
+            if (term->inout == EcsInOutDefault) {
+                term->inout = EcsInOutNone;
+            }
+        }
+
+        if (term->inout == EcsInOutNone) {
+            nodata_term = true;
+        } else if (!ecs_get_type_info(world, term->id)) {
+            nodata_term = true;
+        } else {
+            if (ecs_id_is_tag(world, term->id)) {
+                nodata_term = true;
+            } else if ((ECS_PAIR_SECOND(term->id) == EcsWildcard) ||
+                       (ECS_PAIR_SECOND(term->id) == EcsAny)) 
+            {
+                /* If the second element of a pair is a wildcard and the first
+                 * element is not a type, we can't know in advance what the
+                 * type of the term is, so it can't provide data. */
+                if (!ecs_get_type_info(world, ecs_pair_first(world, term->id))) {
+                    nodata_term = true;
+                }
+            }
+        }
+
+        if (term->inout != EcsIn && term->inout != EcsInOutNone) {
+            /* Non-this terms default to EcsIn */
+            if (ecs_term_match_this(term) || term->inout != EcsInOutDefault) {
+                q->flags |= EcsQueryHasOutTerms;
+            }
+
+            bool match_non_this = !ecs_term_match_this(term) || 
+                (term->src.id & EcsUp);
+            if (match_non_this && term->inout != EcsInOutDefault) {
+                q->flags |= EcsQueryHasNonThisOutTerms;
+            }
+        }
+
+        if (!nodata_term) {
+            /* If terms in an OR chain do not all return the same type, the 
+             * field will not provide any data */
+            if (term->oper == EcsOr || (i && term[-1].oper == EcsOr)) {
+                ecs_term_t *first = flecs_query_or_other_type(q, i);
+                if (first) {
+                    if (first == &term[-1]) {
+                        if (!(term[-1].flags_ & EcsTermNoData)) {
+                            nodata_terms ++;
+                        }
+                    }
+                    nodata_term = true;
+                }
+                q->data_fields &= (ecs_termset_t)~(1llu << term->field_index);
+            }
+        }
+
+        if (term->flags_ & EcsTermIsMember) {
+            nodata_term = false;
+        }
+
+        if (nodata_term) {
+            nodata_terms ++;
+            term->flags_ |= EcsTermNoData;
+        } else if (term->oper != EcsNot) {
+            ECS_TERMSET_SET(q->data_fields, 1u << term->field_index);
+
+            if (term->inout != EcsIn) {
+                ECS_TERMSET_SET(q->write_fields, 1u << term->field_index);
+            }
+            if (term->inout != EcsOut) {
+                ECS_TERMSET_SET(q->read_fields, 1u << term->field_index);
+            }
+            if (term->inout == EcsInOutDefault) {
+                ECS_TERMSET_SET(q->shared_readonly_fields, 
+                    1u << term->field_index);
+            }
+        }
+
+        if (ECS_TERM_REF_ID(&term->src) && (term->src.id & EcsIsEntity)) {
+            ECS_TERMSET_SET(q->fixed_fields, 1u << term->field_index);
+        }
+
+        ecs_id_record_t *idr = flecs_id_record_get(world, term->id);
+        if (idr) {
+            if (ecs_os_has_threading()) {
+                ecs_os_ainc(&idr->keep_alive);
+            } else {
+                idr->keep_alive ++;
+            }
+            term->flags_ |= EcsTermKeepAlive;
+        }
+
+        if (term->oper == EcsOptional || term->oper == EcsNot) {
+            cond_set = true;
+        }
+
+        ecs_entity_t first_id = ECS_TERM_REF_ID(&term->first);
+        if (first_id == EcsPredEq || first_id == EcsPredMatch ||
+            first_id == EcsPredLookup)
+        {
+            q->flags |= EcsQueryHasPred;
+            term->src.id = (term->src.id & ~EcsTraverseFlags) | EcsSelf;
+            term->inout = EcsInOutNone;
+        } else {
+            if (!ecs_term_match_0(term) && term->oper != EcsNot && 
+                term->oper != EcsNotFrom) 
+            {
+                ECS_TERMSET_SET(q->set_fields, 1u << term->field_index);
+            }
+        }
+
+        if (first_id == EcsScopeOpen) {
+            q->flags |= EcsQueryHasScopes;
+            scope_nesting ++;
+        }
+
+        if (scope_nesting) {
+            term->flags_ |= EcsTermIsScope;
+        }
+
+        if (first_id == EcsScopeClose) {
+            if (i && ECS_TERM_REF_ID(&terms[i - 1].first) == EcsScopeOpen) {
+                flecs_query_validator_error(&ctx, "invalid empty scope");
+                return -1;
+            }
+
+            q->flags |= EcsQueryHasScopes;
+            scope_nesting --;
+        }
+
+        if (scope_nesting < 0) {
+            flecs_query_validator_error(&ctx, "'}' without matching '{'");
+        }
+    }
+
+    if (scope_nesting != 0) {
+        flecs_query_validator_error(&ctx, "missing '}'");
+        return -1;
+    }
+
+    if (term_count && (terms[term_count - 1].oper == EcsOr)) {
+        flecs_query_validator_error(&ctx, 
+            "last term of query can't have OR operator");
+        return -1;
+    }
+
+    q->field_count = flecs_ito(int8_t, field_count);
+
+    if (field_count) {
+        for (i = 0; i < term_count; i ++) {
+            ecs_term_t *term = &terms[i];
+            int32_t field = term->field_index;
+            q->ids[field] = term->id;
+
+            if (term->oper == EcsOr || (i && (term[-1].oper == EcsOr))) {
+                if (flecs_query_or_other_type(q, i)) {
+                    q->sizes[field] = 0;
+                    q->ids[field] = 0;
+                    continue;
+                }
+            }
+
+            ecs_id_record_t *idr = flecs_id_record_get(world, term->id);
+            if (idr) {
+                if (!ECS_IS_PAIR(idr->id) || ECS_PAIR_FIRST(idr->id) != EcsWildcard) {
+                    if (idr->type_info) {
+                        q->sizes[field] = idr->type_info->size;
+                        q->ids[field] = idr->id;
+                    }
+                }
+            } else {
+                const ecs_type_info_t *ti = ecs_get_type_info(
+                    world, term->id);
+                if (ti) {
+                    q->sizes[field] = ti->size;
+                    q->ids[field] = term->id;
+                }
+            }
+
+            if (term->flags_ & EcsTermIsMember) {
+                q->sizes[field] = ECS_SIZEOF(ecs_entity_t);
+#ifdef FLECS_META
+                q->ids[field] = ecs_id(ecs_entity_t);
+#endif
+            }
+        }
+    }
+
+    ecs_assert(nodata_terms <= term_count, ECS_INTERNAL_ERROR, NULL);
+    if (nodata_terms == term_count) {
+        ECS_BIT_SET(q->flags, EcsQueryNoData);
+    }
+
+    ECS_BIT_COND(q->flags, EcsQueryHasCondSet, cond_set);
+
+    /* Check if this is a trivial query */
+    if ((q->flags & EcsQueryMatchOnlyThis)) {
+        if (!(q->flags & 
+            (EcsQueryHasPred|EcsQueryMatchDisabled|EcsQueryMatchPrefab))) 
+        {
+            ECS_BIT_SET(q->flags, EcsQueryMatchOnlySelf);
+
+            for (i = 0; i < term_count; i ++) {
+                ecs_term_t *term = &terms[i];
+                ecs_term_ref_t *src = &term->src;
+
+                if (src->id & EcsUp) {
+                    ECS_BIT_CLEAR(q->flags, EcsQueryMatchOnlySelf);
+                }
+
+                if (!(term->flags_ & EcsTermIsTrivial)) {
+                    break;
+                }
+
+                if (!(q->flags & EcsQueryNoData)) {
+                    if (term->inout == EcsInOutNone) {
+                        break;
+                    }
+                }
+            }
+
+            if (term_count && (i == term_count)) {
+                ECS_BIT_SET(q->flags, EcsQueryIsTrivial);
+            }
+        }
+    }
+
+    /* Set cacheable flags */
+    if (!(q->flags & EcsQueryMatchEmptyTables)) {
+        ECS_BIT_COND(q->flags, EcsQueryHasCacheable, 
+            cacheable_terms != 0);
+        ECS_BIT_COND(q->flags, EcsQueryIsCacheable, 
+            cacheable && (cacheable_terms == term_count));
+    }
+
+    for (i = 0; i < q->term_count; i ++) {
+        ecs_term_t *term = &q->terms[i];
+        /* Post process term names in case they were used to create variables */
+        flecs_normalize_term_name(&term->first);
+        flecs_normalize_term_name(&term->second);
+        flecs_normalize_term_name(&term->src);
+    }
+
+    return 0;
+}
+
+static
+int flecs_query_query_populate_terms(
+    ecs_world_t *world,
+    ecs_stage_t *stage,
+    ecs_query_t *q,
+    const ecs_query_desc_t *desc)
+{
+    /* Count number of initialized terms in desc->terms */
+    int32_t i, term_count = 0;
+    for (i = 0; i < FLECS_TERM_COUNT_MAX; i ++) {
+        if (!ecs_term_is_initialized(&desc->terms[i])) {
+            break;
+        }
+        term_count ++;
+    }
+
+    /* Copy terms from array to query */
+    if (term_count) {
+        ecs_os_memcpy_n(&q->terms, desc->terms, ecs_term_t, term_count);
+    }
+
+    /* Parse query expression if set */
+    const char *expr = desc->expr;
+    if (expr && expr[0]) {
+    #ifdef FLECS_SCRIPT
+        ecs_script_t script = {
+            .world = world,
+            .name = desc->entity ? ecs_get_name(world, desc->entity) : NULL,
+            .code = expr
+        };
+
+        /* Allocate buffer that's large enough to tokenize the query string */
+        script.token_buffer_size = ecs_os_strlen(expr) * 2 + 1;
+        script.token_buffer = flecs_alloc(
+            &stage->allocator, script.token_buffer_size);
+
+        if (flecs_terms_parse(&script, &q->terms[term_count], 
+            &term_count))
+        {
+            flecs_free(&stage->allocator, 
+                script.token_buffer_size, script.token_buffer);
+            goto error;
+        }
+
+        /* Store on query object so we can free later */
+        flecs_query_impl(q)->tokens = script.token_buffer;
+        flecs_query_impl(q)->tokens_len = 
+            flecs_ito(int16_t, script.token_buffer_size);
+    #else
+        (void)world;
+        (void)stage;
+        ecs_err("cannot parse query expression: script addon required");
+        goto error;
+    #endif
+    }
+
+    q->term_count = flecs_ito(int8_t, term_count);
+
+    return 0;
+error:  
+    return -1;
+}
+
+int flecs_query_finalize_query(
+    ecs_world_t *world,
+    ecs_query_t *q,
+    const ecs_query_desc_t *desc)    
+{
+    ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER,
+        "ecs_query_desc_t was not initialized to zero");
+    ecs_stage_t *stage = flecs_stage_from_world(&world);
+
+    q->flags |= desc->flags;
+
+    /* Populate term array from desc terms & DSL expression */
+    if (flecs_query_query_populate_terms(world, stage, q, desc)) {
+        goto error;
+    }
+
+    /* Ensure all fields are consistent and properly filled out */
+    if (flecs_query_finalize_terms(world, q)) {
+        goto error;
+    }
+
+    return 0;
+error:
+    return -1;
+}
diff --git a/src/search.c b/src/search.c
index 5f864a4c2..b0d742356 100644
--- a/src/search.c
+++ b/src/search.c
@@ -12,7 +12,6 @@
 static
 int32_t flecs_type_search(
     const ecs_table_t *table,
-    ecs_id_t search_id,
     ecs_id_record_t *idr,
     ecs_id_t *ids,
     ecs_id_t *id_out,
@@ -23,11 +22,7 @@ int32_t flecs_type_search(
         int32_t r = tr->index;
         if (tr_out) tr_out[0] = tr;
         if (id_out) {
-            if (ECS_PAIR_FIRST(search_id) == EcsUnion) {
-                id_out[0] = ids[r];
-            } else {
-                id_out[0] = flecs_to_public_id(ids[r]);
-            }
+            id_out[0] = ids[r];
         }
         return r;
     }
@@ -52,7 +47,7 @@ int32_t flecs_type_offset_search(
         ecs_id_t type_id = ids[offset ++];
         if (ecs_id_match(type_id, id)) {
             if (id_out) {
-                id_out[0] = flecs_to_public_id(type_id);
+                id_out[0] = type_id;
             }
             return offset - 1;
         }
@@ -109,7 +104,7 @@ int32_t flecs_type_search_relation(
                 return r;
             }
         } else {
-            int32_t r = flecs_type_search(table, id, idr, ids, id_out, tr_out);
+            int32_t r = flecs_type_search(table, idr, ids, id_out, tr_out);
             if (r != -1) {
                 return r;
             }
@@ -142,7 +137,7 @@ int32_t flecs_type_search_relation(
         if (offset) {
             r_column = flecs_type_offset_search(offset, rel, ids, count, &id_r);
         } else {
-            r_column = flecs_type_search(table, id, idr_r, ids, &id_r, 0);
+            r_column = flecs_type_search(table, idr_r, ids, &id_r, 0);
         }
         while (r_column != -1) {
             ecs_entity_t obj = ECS_PAIR_SECOND(id_r);
@@ -191,7 +186,7 @@ int32_t flecs_search_relation_w_idr(
     int32_t offset,
     ecs_id_t id,
     ecs_entity_t rel,
-    ecs_flags32_t flags,
+    ecs_flags64_t flags,
     ecs_entity_t *subject_out,
     ecs_id_t *id_out,
     struct ecs_table_record_t **tr_out,
@@ -199,13 +194,13 @@ int32_t flecs_search_relation_w_idr(
 {
     if (!table) return -1;
 
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
 
     flags = flags ? flags : (EcsSelf|EcsUp);
 
     if (!idr) {
-        idr = flecs_query_id_record_get(world, id);
+        idr = flecs_id_record_get(world, id);
         if (!idr) {
             return -1;
         }
@@ -217,7 +212,7 @@ int32_t flecs_search_relation_w_idr(
             return ecs_search_offset(world, table, offset, id, id_out);
         } else {
             return flecs_type_search(
-                table, id, idr, table->type.array, id_out, tr_out);
+                table, idr, table->type.array, id_out, tr_out);
         }
     }
 
@@ -234,14 +229,14 @@ int32_t ecs_search_relation(
     int32_t offset,
     ecs_id_t id,
     ecs_entity_t rel,
-    ecs_flags32_t flags,
+    ecs_flags64_t flags,
     ecs_entity_t *subject_out,
     ecs_id_t *id_out,
     struct ecs_table_record_t **tr_out)
 {
     if (!table) return -1;
 
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
 
     flags = flags ? flags : (EcsSelf|EcsUp);
@@ -251,7 +246,7 @@ int32_t ecs_search_relation(
         return ecs_search_offset(world, table, offset, id, id_out);
     }
 
-    ecs_id_record_t *idr = flecs_query_id_record_get(world, id);
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
     if (!idr) {
         return -1;
     }
@@ -266,19 +261,17 @@ int32_t ecs_search_relation(
 int32_t flecs_search_w_idr(
     const ecs_world_t *world,
     const ecs_table_t *table,
-    ecs_id_t id,
     ecs_id_t *id_out,
     ecs_id_record_t *idr)
 {
     if (!table) return -1;
 
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
+    flecs_poly_assert(world, ecs_world_t);
     (void)world;
 
     ecs_type_t type = table->type;
     ecs_id_t *ids = type.array;
-    return flecs_type_search(table, id, idr, ids, id_out, 0);
+    return flecs_type_search(table, idr, ids, id_out, 0);
 }
 
 int32_t ecs_search(
@@ -289,17 +282,17 @@ int32_t ecs_search(
 {
     if (!table) return -1;
 
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL);
 
-    ecs_id_record_t *idr = flecs_query_id_record_get(world, id);
+    ecs_id_record_t *idr = flecs_id_record_get(world, id);
     if (!idr) {
         return -1;
     }
 
     ecs_type_t type = table->type;
     ecs_id_t *ids = type.array;
-    return flecs_type_search(table, id, idr, ids, id_out, 0);
+    return flecs_type_search(table, idr, ids, id_out, 0);
 }
 
 int32_t ecs_search_offset(
@@ -310,7 +303,7 @@ int32_t ecs_search_offset(
     ecs_id_t *id_out)
 {
     if (!offset) {
-        ecs_poly_assert(world, ecs_world_t);
+        flecs_poly_assert(world, ecs_world_t);
         return ecs_search(world, table, id, id_out);
     }
 
@@ -366,25 +359,5 @@ int32_t flecs_relation_depth(
         return 0;
     }
 
-    int32_t depth_offset = 0;
-    if (table->flags & EcsTableHasTarget) {
-        if (ecs_table_get_type_index(world, table, 
-            ecs_pair_t(EcsFlattenTarget, r)) != -1)
-        {
-            ecs_id_t id;
-            int32_t col = ecs_search(world, table, 
-                ecs_pair(EcsFlatten, EcsWildcard), &id);
-            if (col == -1) {
-                return 0;
-            }
-
-            ecs_entity_t did = ecs_pair_second(world, id);
-            ecs_assert(did != 0, ECS_INTERNAL_ERROR, NULL);
-            uint64_t *val = ecs_map_get(&world->store.entity_to_depth, did);
-            ecs_assert(val != NULL, ECS_INTERNAL_ERROR, NULL);
-            depth_offset = flecs_uto(int32_t, val[0]);
-        }
-    }
-
-    return flecs_relation_depth_walk(world, idr, table, table) + depth_offset;
+    return flecs_relation_depth_walk(world, idr, table, table);
 }
diff --git a/src/stage.c b/src/stage.c
index 2a3df43f2..14da4bd8a 100644
--- a/src/stage.c
+++ b/src/stage.c
@@ -70,11 +70,10 @@ ecs_cmd_t* flecs_cmd_new_batched(
 }
 
 static
-void flecs_stages_merge(
-    ecs_world_t *world,
-    bool force_merge)
+void flecs_stage_merge(
+    ecs_world_t *world)
 {
-    bool is_stage = ecs_poly_is(world, ecs_stage_t);
+    bool is_stage = flecs_poly_is(world, ecs_stage_t);
     ecs_stage_t *stage = flecs_stage_from_world(&world);
 
     bool measure_frame_time = ECS_BIT_IS_SET(world->flags, 
@@ -92,21 +91,17 @@ void flecs_stages_merge(
         /* Check for consistency if force_merge is enabled. In practice this
          * function will never get called with force_merge disabled for just
          * a single stage. */
-        if (force_merge || stage->auto_merge) {
-            ecs_assert(stage->defer == 1, ECS_INVALID_OPERATION, 
-                "mismatching defer_begin/defer_end detected");
-            flecs_defer_end(world, stage);
-        }
+        ecs_assert(stage->defer == 1, ECS_INVALID_OPERATION, 
+            "mismatching defer_begin/defer_end detected");
+        flecs_defer_end(world, stage);
     } else {
         /* Merge stages. Only merge if the stage has auto_merging turned on, or 
          * if this is a forced merge (like when ecs_merge is called) */
         int32_t i, count = ecs_get_stage_count(world);
         for (i = 0; i < count; i ++) {
             ecs_stage_t *s = (ecs_stage_t*)ecs_get_stage(world, i);
-            ecs_poly_assert(s, ecs_stage_t);
-            if (force_merge || s->auto_merge) {
-                flecs_defer_end(world, s);
-            }
+            flecs_poly_assert(s, ecs_stage_t);
+            flecs_defer_end(world, s);
         }
     }
 
@@ -118,34 +113,20 @@ void flecs_stages_merge(
 
     world->info.merge_count_total ++; 
 
-    /* If stage is asynchronous, deferring is always enabled */
-    if (stage->async) {
+    /* If stage is unmanaged, deferring is always enabled */
+    if (stage->id == -1) {
         flecs_defer_begin(world, stage);
     }
     
     ecs_log_pop_3();
 }
 
-static
-void flecs_stage_auto_merge(
-    ecs_world_t *world)
-{
-    flecs_stages_merge(world, false);
-}
-
-static
-void flecs_stage_manual_merge(
-    ecs_world_t *world)
-{
-    flecs_stages_merge(world, true);
-}
-
 bool flecs_defer_begin(
     ecs_world_t *world,
     ecs_stage_t *stage)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_assert(stage, ecs_stage_t);
+    flecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(stage, ecs_stage_t);
     (void)world;
     if (stage->defer < 0) return false;
     return (++ stage->defer) == 1;
@@ -283,7 +264,7 @@ bool flecs_defer_bulk_new(
         /* Use ecs_new_id as this is thread safe */
         int i;
         for (i = 0; i < count; i ++) {
-            ids[i] = ecs_new_id(world);
+            ids[i] = ecs_new(world);
         }
 
         *ids_out = ids;
@@ -339,7 +320,8 @@ void* flecs_defer_set(
     ecs_entity_t entity,
     ecs_id_t id,
     ecs_size_t size,
-    void *value)
+    void *value,
+    bool *is_new)
 {
     ecs_cmd_t *cmd = flecs_cmd_new_batched(stage, entity);
 
@@ -349,9 +331,8 @@ void* flecs_defer_set(
     if (!idr) {
         /* If idr doesn't exist yet, create it but only if the 
          * application is not multithreaded. */
-        if (stage->async || (world->flags & EcsWorldMultiThreaded)) {
+        if (world->flags & EcsWorldMultiThreaded) {
             ti = ecs_get_type_info(world, id);
-            ecs_assert(ti != NULL, ECS_INVALID_PARAMETER, NULL);
         } else {
             /* When not in multi threaded mode, it's safe to find or 
              * create the id record. */
@@ -369,10 +350,12 @@ void* flecs_defer_set(
     }
 
     /* If the id isn't associated with a type, we can't set anything */
-    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ti != NULL, ECS_INVALID_PARAMETER, 
+        "provided component is not a type");
 
     /* Make sure the size of the value equals the type size */
-    ecs_assert(!size || size == ti->size, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(!size || size == ti->size, ECS_INVALID_PARAMETER,
+        "mismatching size specified for component in ensure/emplace/set");
     size = ti->size;
 
     /* Find existing component. Make sure it's owned, so that we won't use the
@@ -483,6 +466,10 @@ void* flecs_defer_set(
         cmd->entity = entity;
         cmd->is._1.size = size;
         cmd->is._1.value = cmd_value;
+
+        if (is_new) {
+            *is_new = true;
+        }
     } else {
         /* If component already exists, still insert an Add command to ensure
          * that any preceding remove commands won't remove the component. If the
@@ -494,6 +481,10 @@ void* flecs_defer_set(
         }
         cmd->id = id;
         cmd->entity = entity;
+
+        if (is_new) {
+            *is_new = false;
+        }
     }
 
     return cmd_value;
@@ -611,23 +602,33 @@ void flecs_commands_pop(
     stage->cmd = &stage->cmd_stack[sp];
 }
 
-void flecs_stage_init(
-    ecs_world_t *world,
-    ecs_stage_t *stage)
+ecs_entity_t flecs_stage_set_system(
+    ecs_stage_t *stage,
+    ecs_entity_t system)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_init(stage, ecs_stage_t);
+    ecs_entity_t old = stage->system;
+    stage->system = system;
+    return old;
+}
+
+static
+ecs_stage_t* flecs_stage_new(
+    ecs_world_t *world)
+{
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_stage_t *stage = ecs_os_calloc(sizeof(ecs_stage_t));
+    flecs_poly_init(stage, ecs_stage_t);
 
     stage->world = world;
     stage->thread_ctx = world;
-    stage->auto_merge = true;
-    stage->async = false;
 
     flecs_stack_init(&stage->allocators.iter_stack);
     flecs_stack_init(&stage->allocators.deser_stack);
     flecs_allocator_init(&stage->allocator);
     flecs_ballocator_init_n(&stage->allocators.cmd_entry_chunk, ecs_cmd_entry_t,
         FLECS_SPARSE_PAGE_SIZE);
+    flecs_ballocator_init_t(&stage->allocators.query_impl, ecs_query_impl_t);
+    flecs_ballocator_init_t(&stage->allocators.query_cache, ecs_query_cache_t);
 
     ecs_allocator_t *a = &stage->allocator;
     ecs_vec_init_t(a, &stage->post_frame_actions, ecs_action_elem_t, 0);
@@ -638,17 +639,19 @@ void flecs_stage_init(
     }
 
     stage->cmd = &stage->cmd_stack[0];
+    return stage;
 }
 
-void flecs_stage_fini(
+static
+void flecs_stage_free(
     ecs_world_t *world,
     ecs_stage_t *stage)
 {
     (void)world;
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_poly_assert(stage, ecs_stage_t);
+    flecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(stage, ecs_stage_t);
 
-    ecs_poly_fini(stage, ecs_stage_t);
+    flecs_poly_fini(stage, ecs_stage_t);
 
     ecs_allocator_t *a = &stage->allocator;
     
@@ -664,52 +667,87 @@ void flecs_stage_fini(
     flecs_stack_fini(&stage->allocators.iter_stack);
     flecs_stack_fini(&stage->allocators.deser_stack);
     flecs_ballocator_fini(&stage->allocators.cmd_entry_chunk);
+    flecs_ballocator_fini(&stage->allocators.query_impl);
+    flecs_ballocator_fini(&stage->allocators.query_cache);
     flecs_allocator_fini(&stage->allocator);
+
+    ecs_os_free(stage);
+}
+
+ecs_allocator_t* flecs_stage_get_allocator(
+    ecs_world_t *world)
+{
+    ecs_stage_t *stage = flecs_stage_from_world(
+        ECS_CONST_CAST(ecs_world_t**, &world));
+    return &stage->allocator;
+}
+
+ecs_stack_t* flecs_stage_get_stack_allocator(
+    ecs_world_t *world)
+{
+    ecs_stage_t *stage = flecs_stage_from_world(
+        ECS_CONST_CAST(ecs_world_t**, &world));
+    return &stage->allocators.iter_stack;
+}
+
+ecs_world_t* ecs_stage_new(
+    ecs_world_t *world)
+{
+    ecs_stage_t *stage = flecs_stage_new(world);
+    stage->id = -1;
+
+    flecs_defer_begin(world, stage);
+
+    return (ecs_world_t*)stage;
+}
+
+void ecs_stage_free(
+    ecs_world_t *world)
+{
+    flecs_poly_assert(world, ecs_stage_t);
+    ecs_stage_t *stage = (ecs_stage_t*)world;
+    ecs_check(stage->id == -1, ECS_INVALID_PARAMETER, 
+        "cannot free stage that's owned by world");
+    flecs_stage_free(stage->world, stage);
+error:
+    return;
 }
 
 void ecs_set_stage_count(
     ecs_world_t *world,
     int32_t stage_count)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     /* World must have at least one default stage */
     ecs_assert(stage_count >= 1 || (world->flags & EcsWorldFini), 
         ECS_INTERNAL_ERROR, NULL);
 
-    bool auto_merge = true;
     const ecs_entity_t *lookup_path = NULL;
-    ecs_entity_t scope = 0;
-    ecs_entity_t with = 0;
     if (world->stage_count >= 1) {
-        auto_merge = world->stages[0].auto_merge;
-        lookup_path = world->stages[0].lookup_path;
-        scope = world->stages[0].scope;
-        with = world->stages[0].with;
+        lookup_path = world->stages[0]->lookup_path;
     }
 
     int32_t i, count = world->stage_count;
-    if (count && count != stage_count) {
-        ecs_stage_t *stages = world->stages;
-
-        for (i = 0; i < count; i ++) {
+    if (stage_count < count) {
+        for (i = stage_count; i < count; i ++) {
             /* If stage contains a thread handle, ecs_set_threads was used to
-             * create the stages. ecs_set_threads and ecs_set_stage_count should not
-             * be mixed. */
-            ecs_poly_assert(&stages[i], ecs_stage_t);
-            ecs_check(stages[i].thread == 0, ECS_INVALID_OPERATION, NULL);
-            flecs_stage_fini(world, &stages[i]);
+             * create the stages. ecs_set_threads and ecs_set_stage_count should 
+             * not be mixed. */
+            ecs_stage_t *stage = world->stages[i];
+            flecs_poly_assert(stage, ecs_stage_t);
+            ecs_check(stage->thread == 0, ECS_INVALID_OPERATION, 
+                "cannot mix using set_stage_count and set_threads");
+            flecs_stage_free(world, stage);
         }
-
-        ecs_os_free(world->stages);
     }
 
     if (stage_count) {
-        world->stages = ecs_os_malloc_n(ecs_stage_t, stage_count);
+        world->stages = ecs_os_realloc_n(
+            world->stages, ecs_stage_t*, stage_count);
 
-        for (i = 0; i < stage_count; i ++) {
-            ecs_stage_t *stage = &world->stages[i];
-            flecs_stage_init(world, stage);
+        for (i = count; i < stage_count; i ++) {
+            ecs_stage_t *stage = world->stages[i] = flecs_stage_new(world);
             stage->id = i;
 
             /* Set thread_ctx to stage, as this stage might be used in a
@@ -719,6 +757,7 @@ void ecs_set_stage_count(
         }
     } else {
         /* Set to NULL to prevent double frees */
+        ecs_os_free(world->stages);
         world->stages = NULL;
     }
 
@@ -726,10 +765,7 @@ void ecs_set_stage_count(
      * ecs_set_stage_count function is called, all stages inherit the auto_merge
      * property from the world */
     for (i = 0; i < stage_count; i ++) {
-        world->stages[i].auto_merge = auto_merge;
-        world->stages[i].lookup_path = lookup_path;
-        world->stages[0].scope = scope;
-        world->stages[0].with = with;
+        world->stages[i]->lookup_path = lookup_path;
     }
 
     world->stage_count = stage_count;
@@ -744,17 +780,17 @@ int32_t ecs_get_stage_count(
     return world->stage_count;
 }
 
-int32_t ecs_get_stage_id(
+int32_t ecs_stage_get_id(
     const ecs_world_t *world)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
 
-    if (ecs_poly_is(world, ecs_stage_t)) {
+    if (flecs_poly_is(world, ecs_stage_t)) {
         ecs_stage_t *stage = ECS_CONST_CAST(ecs_stage_t*, world);
 
         /* Index 0 is reserved for main stage */
         return stage->id;
-    } else if (ecs_poly_is(world, ecs_world_t)) {
+    } else if (flecs_poly_is(world, ecs_world_t)) {
         return 0;
     } else {
         ecs_throw(ECS_INTERNAL_ERROR, NULL);
@@ -767,9 +803,9 @@ ecs_world_t* ecs_get_stage(
     const ecs_world_t *world,
     int32_t stage_id)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(world->stage_count > stage_id, ECS_INVALID_PARAMETER, NULL);
-    return (ecs_world_t*)&world->stages[stage_id];
+    return (ecs_world_t*)world->stages[stage_id];
 error:
     return NULL;
 }
@@ -778,7 +814,7 @@ bool ecs_readonly_begin(
     ecs_world_t *world,
     bool multi_threaded)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     flecs_process_pending_tables(world);
 
@@ -787,8 +823,8 @@ bool ecs_readonly_begin(
 
     int32_t i, count = ecs_get_stage_count(world);
     for (i = 0; i < count; i ++) {
-        ecs_stage_t *stage = &world->stages[i];
-        stage->lookup_path = world->stages[0].lookup_path;
+        ecs_stage_t *stage = world->stages[i];
+        stage->lookup_path = world->stages[0]->lookup_path;
         ecs_assert(stage->defer == 0, ECS_INVALID_OPERATION, 
             "deferred mode cannot be enabled when entering readonly mode");
         flecs_defer_begin(world, stage);
@@ -807,8 +843,9 @@ bool ecs_readonly_begin(
 void ecs_readonly_end(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(world->flags & EcsWorldReadonly, ECS_INVALID_OPERATION, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(world->flags & EcsWorldReadonly, ECS_INVALID_OPERATION,
+        "world is not in readonly mode");
 
     /* After this it is safe again to mutate the world directly */
     ECS_BIT_CLEAR(world->flags, EcsWorldReadonly);
@@ -816,7 +853,7 @@ void ecs_readonly_end(
 
     ecs_log_pop_3();
 
-    flecs_stage_auto_merge(world);
+    flecs_stage_merge(world);
 error:
     return;
 }
@@ -825,57 +862,31 @@ void ecs_merge(
     ecs_world_t *world)
 {
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_poly_is(world, ecs_world_t) || 
-               ecs_poly_is(world, ecs_stage_t), ECS_INVALID_PARAMETER, NULL);
-    flecs_stage_manual_merge(world);
+    ecs_check(flecs_poly_is(world, ecs_world_t) || 
+               flecs_poly_is(world, ecs_stage_t), ECS_INVALID_PARAMETER, NULL);
+    flecs_stage_merge(world);
 error:
     return;
 }
 
-void ecs_set_automerge(
-    ecs_world_t *world,
-    bool auto_merge)
-{
-    /* If a world is provided, set auto_merge globally for the world. This
-     * doesn't actually do anything (the main stage never merges) but it serves
-     * as the default for when stages are created. */
-    if (ecs_poly_is(world, ecs_world_t)) {
-        world->stages[0].auto_merge = auto_merge;
-
-        /* Propagate change to all stages */
-        int i, stage_count = ecs_get_stage_count(world);
-        for (i = 0; i < stage_count; i ++) {
-            ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i);
-            stage->auto_merge = auto_merge;
-        }
-
-    /* If a stage is provided, override the auto_merge value for the individual
-     * stage. This allows an application to control per-stage which stage should
-     * be automatically merged and which one shouldn't */
-    } else {
-        ecs_poly_assert(world, ecs_stage_t);
-        ecs_stage_t *stage = (ecs_stage_t*)world;
-        stage->auto_merge = auto_merge;
-    }
-}
-
 bool ecs_stage_is_readonly(
     const ecs_world_t *stage)
 {
     const ecs_world_t *world = ecs_get_world(stage);
 
-    if (ecs_poly_is(stage, ecs_stage_t)) {
-        if (((const ecs_stage_t*)stage)->async) {
+    if (flecs_poly_is(stage, ecs_stage_t)) {
+        if (((const ecs_stage_t*)stage)->id == -1) {
+            /* Stage is not owned by world, so never readonly */
             return false;
         }
     }
 
     if (world->flags & EcsWorldReadonly) {
-        if (ecs_poly_is(stage, ecs_world_t)) {
+        if (flecs_poly_is(stage, ecs_world_t)) {
             return true;
         }
     } else {
-        if (ecs_poly_is(stage, ecs_stage_t)) {
+        if (flecs_poly_is(stage, ecs_stage_t)) {
             return true;
         }
     }
@@ -883,47 +894,6 @@ bool ecs_stage_is_readonly(
     return false;
 }
 
-ecs_world_t* ecs_async_stage_new(
-    ecs_world_t *world)
-{
-    ecs_stage_t *stage = ecs_os_calloc(sizeof(ecs_stage_t));
-    flecs_stage_init(world, stage);
-
-    stage->id = -1;
-    stage->auto_merge = false;
-    stage->async = true;
-
-    flecs_defer_begin(world, stage);
-
-    return (ecs_world_t*)stage;
-}
-
-void ecs_async_stage_free(
-    ecs_world_t *world)
-{
-    ecs_poly_assert(world, ecs_stage_t);
-    ecs_stage_t *stage = (ecs_stage_t*)world;
-    ecs_check(stage->async == true, ECS_INVALID_PARAMETER, NULL);
-    flecs_stage_fini(stage->world, stage);
-    ecs_os_free(stage);
-error:
-    return;
-}
-
-bool ecs_stage_is_async(
-    ecs_world_t *stage)
-{
-    if (!stage) {
-        return false;
-    }
-    
-    if (!ecs_poly_is(stage, ecs_stage_t)) {
-        return false;
-    }
-
-    return ((ecs_stage_t*)stage)->async;
-}
-
 bool ecs_is_deferred(
     const ecs_world_t *world)
 {
@@ -933,12 +903,3 @@ bool ecs_is_deferred(
 error:
     return false;
 }
-
-ecs_entity_t flecs_stage_set_system(
-    ecs_stage_t *stage,
-    ecs_entity_t system)
-{
-    ecs_entity_t old = stage->system;
-    stage->system = system;
-    return old;
-}
diff --git a/src/stage.h b/src/stage.h
index 575388212..7311eb3c3 100644
--- a/src/stage.h
+++ b/src/stage.h
@@ -6,16 +6,6 @@
 #ifndef FLECS_STAGE_H
 #define FLECS_STAGE_H
 
-/* Initialize stage data structures */
-void flecs_stage_init(
-    ecs_world_t *world,
-    ecs_stage_t *stage);
-
-/* Deinitialize stage */
-void flecs_stage_fini(
-    ecs_world_t *world,
-    ecs_stage_t *stage);
-
 /* Post-frame merge actions */
 void flecs_stage_merge_post_frame(
     ecs_world_t *world,
@@ -88,7 +78,8 @@ void* flecs_defer_set(
     ecs_entity_t entity,
     ecs_entity_t component,
     ecs_size_t size,
-    void *value);
+    void *value,
+    bool *is_new);
 
 bool flecs_defer_end(
     ecs_world_t *world,
@@ -113,4 +104,10 @@ ecs_entity_t flecs_stage_set_system(
     ecs_stage_t *stage,
     ecs_entity_t system);
 
+ecs_allocator_t* flecs_stage_get_allocator(
+    ecs_world_t *world);
+
+ecs_stack_t* flecs_stage_get_stack_allocator(
+    ecs_world_t *world);
+
 #endif
diff --git a/src/storage/entity_index.c b/src/storage/entity_index.c
index 8074e67eb..51ee2cfde 100644
--- a/src/storage/entity_index.c
+++ b/src/storage/entity_index.c
@@ -59,7 +59,8 @@ ecs_record_t* flecs_entity_index_get_any(
     ecs_entity_index_page_t *page = ecs_vec_get_t(&index->pages, 
         ecs_entity_index_page_t*, page_index)[0];
     ecs_record_t *r = &page->records[id & FLECS_ENTITY_PAGE_MASK];
-    ecs_assert(r->dense != 0, ECS_INVALID_PARAMETER, NULL);
+    ecs_assert(r->dense != 0, ECS_INVALID_PARAMETER, 
+        "entity %u does not exist", (uint32_t)entity);
     return r;
 }
 
@@ -70,7 +71,7 @@ ecs_record_t* flecs_entity_index_get(
     ecs_record_t *r = flecs_entity_index_get_any(index, entity);
     ecs_assert(r->dense < index->alive_count, ECS_INVALID_PARAMETER, NULL);
     ecs_assert(ecs_vec_get_t(&index->dense, uint64_t, r->dense)[0] == entity, 
-        ECS_INVALID_PARAMETER, NULL);
+        ECS_INVALID_PARAMETER, "mismatching liveliness generation for entity");
     return r;
 }
 
diff --git a/src/storage/id_index.c b/src/storage/id_index.c
index a8587bbb4..325936e23 100644
--- a/src/storage/id_index.c
+++ b/src/storage/id_index.c
@@ -252,10 +252,6 @@ ecs_id_record_t* flecs_id_record_new(
 
             idr_t = flecs_id_record_ensure(world, ecs_pair(EcsWildcard, tgt));
             flecs_insert_id_elem(world, idr, ecs_pair(EcsWildcard, tgt), idr_t);
-
-            if (rel == EcsUnion) {
-                idr->flags |= EcsIdUnion;
-            }
         }
     } else {
         rel = id & ECS_COMPONENT_MASK;
@@ -367,13 +363,13 @@ void flecs_id_record_free(
     ecs_world_t *world,
     ecs_id_record_t *idr)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_id_t id = idr->id;
 
     flecs_id_record_assert_empty(idr);
 
-    /* Id is still in use by a filter, query, rule or observer */
+    /* Id is still in use by a query */
     ecs_assert((world->flags & EcsWorldQuit) || (idr->keep_alive == 0), 
         ECS_ID_IN_USE, "cannot delete id that is queried for");
 
@@ -456,7 +452,7 @@ ecs_id_record_t* flecs_id_record_get(
     const ecs_world_t *world,
     ecs_id_t id)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     if (id == ecs_pair(EcsIsA, EcsWildcard)) {
         return world->idr_isa_wildcard;
     } else if (id == ecs_pair(EcsChildOf, EcsWildcard)) {
@@ -479,29 +475,6 @@ ecs_id_record_t* flecs_id_record_get(
     return idr;
 }
 
-ecs_id_record_t* flecs_query_id_record_get(
-    const ecs_world_t *world,
-    ecs_id_t id)
-{
-    ecs_id_record_t *idr = flecs_id_record_get(world, id);
-    if (!idr) {
-        ecs_entity_t first = ECS_PAIR_FIRST(id);
-        if (ECS_IS_PAIR(id) && (first != EcsWildcard)) {
-            idr = flecs_id_record_get(world, ecs_pair(EcsUnion, first));
-        }
-        return idr;
-    }
-    if (ECS_IS_PAIR(id) && 
-        ECS_PAIR_SECOND(id) == EcsWildcard && 
-        (idr->flags & EcsIdUnion)) 
-    {
-        idr = flecs_id_record_get(world, 
-            ecs_pair(EcsUnion, ECS_PAIR_FIRST(id)));
-    }
-
-    return idr;
-}
-
 void flecs_id_record_claim(
     ecs_world_t *world,
     ecs_id_record_t *idr)
@@ -537,7 +510,7 @@ void flecs_id_record_release_tables(
         ecs_table_record_t *tr;
         while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
             /* Release current table */
-            flecs_table_free(world, tr->hdr.table);
+            flecs_table_fini(world, tr->hdr.table);
         }
     }
 }
@@ -584,7 +557,7 @@ ecs_hashmap_t* flecs_id_name_index_ensure(
     ecs_world_t *world,
     ecs_id_t id)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     ecs_id_record_t *idr = flecs_id_record_get(world, id);
     ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL);
@@ -596,7 +569,7 @@ ecs_hashmap_t* flecs_id_name_index_get(
     const ecs_world_t *world,
     ecs_id_t id)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     ecs_id_record_t *idr = flecs_id_record_get(world, id);
     if (!idr) {
@@ -611,7 +584,7 @@ ecs_table_record_t* flecs_table_record_get(
     const ecs_table_t *table,
     ecs_id_t id)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     ecs_id_record_t* idr = flecs_id_record_get(world, id);
     if (!idr) {
diff --git a/src/storage/id_index.h b/src/storage/id_index.h
index b33f7a91c..5e577219a 100644
--- a/src/storage/id_index.h
+++ b/src/storage/id_index.h
@@ -78,13 +78,6 @@ ecs_id_record_t* flecs_id_record_get(
     const ecs_world_t *world,
     ecs_id_t id);
 
-/* Get id record for id for searching.
- * Same as flecs_id_record_get, but replaces (R, *) with (Union, R) if R is a
- * union relationship. */
-ecs_id_record_t* flecs_query_id_record_get(
-    const ecs_world_t *world,
-    ecs_id_t id);
-
 /* Ensure id record for id */
 ecs_id_record_t* flecs_id_record_ensure(
     ecs_world_t *world,
diff --git a/src/storage/table.c b/src/storage/table.c
index 7eed2c117..9ca9c4396 100644
--- a/src/storage/table.c
+++ b/src/storage/table.c
@@ -35,14 +35,11 @@ void flecs_table_check_sanity(ecs_table_t *table) {
     int32_t count = ecs_vec_count(&table->data.entities);
 
     int32_t i;
-    int32_t sw_offset = table->_ ? table->_->sw_offset : 0;
-    int32_t sw_count = table->_ ? table->_->sw_count : 0;
     int32_t bs_offset = table->_ ? table->_->bs_offset : 0;
     int32_t bs_count = table->_ ? table->_->bs_count : 0;
     int32_t type_count = table->type.count;
     ecs_id_t *ids = table->type.array;
 
-    ecs_assert((sw_count + sw_offset) <= type_count, ECS_INTERNAL_ERROR, NULL);
     ecs_assert((bs_count + bs_offset) <= type_count, ECS_INTERNAL_ERROR, NULL);
 
     if (table->column_count) {
@@ -65,18 +62,6 @@ void flecs_table_check_sanity(ecs_table_t *table) {
         ecs_assert(table->column_map == NULL, ECS_INTERNAL_ERROR, NULL);
     }
 
-    if (sw_count) {
-        ecs_assert(table->_->sw_columns != NULL, 
-            ECS_INTERNAL_ERROR, NULL);
-        for (i = 0; i < sw_count; i ++) {
-            ecs_switch_t *sw = &table->_->sw_columns[i];
-            ecs_assert(ecs_vec_count(&sw->values) == count, 
-                ECS_INTERNAL_ERROR, NULL);
-            ecs_assert(ECS_PAIR_FIRST(ids[i + sw_offset]) == EcsUnion,
-                ECS_INTERNAL_ERROR, NULL);
-        }
-    }
-
     if (bs_count) {
         ecs_assert(table->_->bs_columns != NULL, 
             ECS_INTERNAL_ERROR, NULL);
@@ -190,16 +175,7 @@ void flecs_table_init_data(
     flecs_table_init_columns(world, table, table->column_count);
 
     ecs_table__t *meta = table->_;
-    int32_t i, sw_count = meta->sw_count;
-    int32_t bs_count = meta->bs_count;
-
-    if (sw_count) {
-        meta->sw_columns = flecs_wcalloc_n(world, ecs_switch_t, sw_count);
-        for (i = 0; i < sw_count; i ++) {
-            flecs_switch_init(&meta->sw_columns[i], 
-                &world->allocator, 0);
-        }
-    }
+    int32_t i, bs_count = meta->bs_count;
 
     if (bs_count) {
         meta->bs_columns = flecs_wcalloc_n(world, ecs_bitset_t, bs_count);
@@ -235,6 +211,8 @@ void flecs_table_init_flags(
             table->flags |= EcsTableIsPrefab;
         } else if (id == EcsDisabled) {
             table->flags |= EcsTableIsDisabled;
+        } else if (id == EcsNotQueryable) {
+            table->flags |= EcsTableNotQueryable;
         } else {
             if (ECS_IS_PAIR(id)) {
                 ecs_entity_t r = ECS_PAIR_FIRST(id);
@@ -258,18 +236,6 @@ void flecs_table_init_flags(
                     }
                 } else if (id == ecs_pair_t(EcsIdentifier, EcsName)) {
                     table->flags |= EcsTableHasName;
-                } else if (r == EcsUnion) {
-                    ecs_table__t *meta = table->_;
-                    table->flags |= EcsTableHasUnion;
-
-                    if (!meta->sw_count) {
-                        meta->sw_offset = flecs_ito(int16_t, i);
-                    }
-                    meta->sw_count ++;
-                } else if (r == ecs_id(EcsFlattenTarget)) {
-                    ecs_table__t *meta = table->_;
-                    table->flags |= EcsTableHasTarget;
-                    meta->ft_offset = flecs_ito(int16_t, i);
                 } else if (r == ecs_id(EcsPoly)) {
                     table->flags |= EcsTableHasBuiltins;
                 }
@@ -318,6 +284,20 @@ void flecs_table_append_to_records(
     ecs_assert(tr->hdr.cache != NULL, ECS_INTERNAL_ERROR, NULL);
 }
 
+void flecs_table_emit(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_entity_t event)
+{
+    flecs_emit(world, world, &(ecs_event_desc_t) {
+        .ids = &table->type,
+        .event = event,
+        .table = table,
+        .flags = EcsEventTableOnly,
+        .observable = world
+    });
+}
+
 /* Main table initialization function */
 void flecs_table_init(
     ecs_world_t *world,
@@ -584,13 +564,7 @@ void flecs_table_init(
     }
 
     if (table->flags & EcsTableHasOnTableCreate) {
-        flecs_emit(world, world, &(ecs_event_desc_t) {
-            .ids = &table->type,
-            .event = EcsOnTableCreate,
-            .table = table,
-            .flags = EcsEventTableOnly,
-            .observable = world
-        });
+        flecs_table_emit(world, table, EcsOnTableCreate);
     }
 }
 
@@ -767,12 +741,8 @@ void flecs_table_dtor_all(
     ecs_data_t *data,
     int32_t row,
     int32_t count,
-    bool update_entity_index,
     bool is_delete)
 {
-    /* Can't delete and not update the entity index */
-    ecs_assert(!is_delete || update_entity_index, ECS_INTERNAL_ERROR, NULL);
-
     int32_t ids_count = table->column_count;
     ecs_entity_t *entities = data->entities.array;
     int32_t i, c, end = row + count;
@@ -809,31 +779,26 @@ void flecs_table_dtor_all(
         for (i = row; i < end; i ++) {
             /* Update entity index after invoking destructors so that entity can
              * be safely used in destructor callbacks. */
-            if (update_entity_index) {
-                ecs_entity_t e = entities[i];
-                ecs_assert(!e || ecs_is_valid(world, e), 
-                    ECS_INTERNAL_ERROR, NULL);
+            ecs_entity_t e = entities[i];
+            ecs_assert(!e || ecs_is_valid(world, e), 
+                ECS_INTERNAL_ERROR, NULL);
 
-                if (is_delete) {
-                    flecs_entities_remove(world, e);
-                    ecs_assert(ecs_is_valid(world, e) == false, 
-                        ECS_INTERNAL_ERROR, NULL);
-                } else {
-                    // If this is not a delete, clear the entity index record
-                    ecs_record_t *record = flecs_entities_get(world, e);
-                    record->table = NULL;
-                    record->row = 0;
-                }
+            if (is_delete) {
+                flecs_entities_remove(world, e);
+                ecs_assert(ecs_is_valid(world, e) == false, 
+                    ECS_INTERNAL_ERROR, NULL);
             } else {
-                /* This should only happen in rare cases, such as when the data
-                 * cleaned up is not part of the world (like with snapshots) */
+                // If this is not a delete, clear the entity index record
+                ecs_record_t *record = flecs_entities_get(world, e);
+                record->table = NULL;
+                record->row = 0;
             }
         }
 
         table->_->lock = false;
 
     /* If table does not have destructors, just update entity index */
-    } else if (update_entity_index) {
+    } else {
         if (is_delete) {
             for (i = row; i < end; i ++) {
                 ecs_entity_t e = entities[i];
@@ -861,7 +826,6 @@ void flecs_table_fini_data(
     ecs_table_t *table,
     ecs_data_t *data,
     bool do_on_remove,
-    bool update_entity_index,
     bool is_delete,
     bool deactivate)
 {
@@ -877,8 +841,7 @@ void flecs_table_fini_data(
 
     int32_t count = flecs_table_data_count(data);
     if (count) {
-        flecs_table_dtor_all(world, table, data, 0, count, 
-            update_entity_index, is_delete);
+        flecs_table_dtor_all(world, table, data, 0, count, is_delete);
     }
 
     ecs_column_t *columns = data->columns;
@@ -896,16 +859,6 @@ void flecs_table_fini_data(
     }
 
     ecs_table__t *meta = table->_;
-    ecs_switch_t *sw_columns = meta->sw_columns;
-    if (sw_columns) {
-        int32_t c, column_count = meta->sw_count;
-        for (c = 0; c < column_count; c ++) {
-            flecs_switch_fini(&sw_columns[c]);
-        }
-        flecs_wfree_n(world, ecs_switch_t, column_count, sw_columns);
-        meta->sw_columns = NULL;
-    }
-
     ecs_bitset_t *bs_columns = meta->bs_columns;
     if (bs_columns) {
         int32_t c, column_count = meta->bs_count;
@@ -938,21 +891,12 @@ ecs_entity_t* flecs_table_entities_array(
     return ecs_vec_first(flecs_table_entities(table));
 }
 
-/* Cleanup, no OnRemove, don't update entity index, don't deactivate table */
-void flecs_table_clear_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data)
-{
-    flecs_table_fini_data(world, table, data, false, false, false, false);
-}
-
 /* Cleanup, no OnRemove, clear entity index, deactivate table */
 void flecs_table_clear_entities_silent(
     ecs_world_t *world,
     ecs_table_t *table)
 {
-    flecs_table_fini_data(world, table, &table->data, false, true, false, true);
+    flecs_table_fini_data(world, table, &table->data, false, false, true);
 }
 
 /* Cleanup, run OnRemove, clear entity index, deactivate table */
@@ -960,7 +904,7 @@ void flecs_table_clear_entities(
     ecs_world_t *world,
     ecs_table_t *table)
 {
-    flecs_table_fini_data(world, table, &table->data, true, true, false, true);
+    flecs_table_fini_data(world, table, &table->data, true, false, true);
 }
 
 /* Cleanup, run OnRemove, delete from entity index, deactivate table */
@@ -968,7 +912,7 @@ void flecs_table_delete_entities(
     ecs_world_t *world,
     ecs_table_t *table)
 {
-    flecs_table_fini_data(world, table, &table->data, true, true, true, true);
+    flecs_table_fini_data(world, table, &table->data, true, true, true);
 }
 
 /* Unset all components in table. This function is called before a table is 
@@ -982,7 +926,7 @@ void flecs_table_remove_actions(
 }
 
 /* Free table resources. */
-void flecs_table_free(
+void flecs_table_fini(
     ecs_world_t *world,
     ecs_table_t *table)
 {
@@ -995,13 +939,7 @@ void flecs_table_free(
 
     if (!is_root && !(world->flags & EcsWorldQuit)) {
         if (table->flags & EcsTableHasOnTableDelete) {
-            flecs_emit(world, world, &(ecs_event_desc_t) {
-                .ids = &table->type,
-                .event = EcsOnTableDelete,
-                .table = table,
-                .flags = EcsEventTableOnly,
-                .observable = world
-            });
+            flecs_table_emit(world, table, EcsOnTableDelete);
         }
     }
 
@@ -1017,7 +955,7 @@ void flecs_table_free(
     world->info.empty_table_count -= (ecs_table_count(table) == 0);
 
     /* Cleanup data, no OnRemove, delete from entity index, don't deactivate */
-    flecs_table_fini_data(world, table, &table->data, false, true, true, false);
+    flecs_table_fini_data(world, table, &table->data, false, true, false);
     flecs_table_clear_edges(world, table);
 
     if (!is_root) {
@@ -1128,7 +1066,7 @@ int32_t* flecs_table_get_dirty_state(
     ecs_world_t *world,
     ecs_table_t *table)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
     if (!table->dirty_state) {
         int32_t column_count = table->column_count;
@@ -1142,81 +1080,6 @@ int32_t* flecs_table_get_dirty_state(
     return table->dirty_state;
 }
 
-/* Table move logic for switch (union relationship) column */
-static
-void flecs_table_move_switch_columns(
-    ecs_table_t *dst_table, 
-    int32_t dst_index,
-    ecs_table_t *src_table, 
-    int32_t src_index,
-    int32_t count,
-    bool clear)
-{
-    ecs_table__t *dst_meta = dst_table->_;
-    ecs_table__t *src_meta = src_table->_;
-    if (!dst_meta && !src_meta) {
-        return;
-    }
-
-    int32_t i_old = 0, src_column_count = src_meta ? src_meta->sw_count : 0;
-    int32_t i_new = 0, dst_column_count = dst_meta ? dst_meta->sw_count : 0;
-    if (!src_column_count && !dst_column_count) {
-        return;
-    }
-
-    ecs_switch_t *src_columns = src_meta ? src_meta->sw_columns : NULL;
-    ecs_switch_t *dst_columns = dst_meta ? dst_meta->sw_columns : NULL;
-
-    ecs_type_t dst_type = dst_table->type;
-    ecs_type_t src_type = src_table->type;
-
-    int32_t offset_new = dst_meta ? dst_meta->sw_offset : 0;
-    int32_t offset_old = src_meta ? src_meta->sw_offset : 0;
-
-    ecs_id_t *dst_ids = dst_type.array;
-    ecs_id_t *src_ids = src_type.array;
-
-    for (; (i_new < dst_column_count) && (i_old < src_column_count);) {
-        ecs_entity_t dst_id = dst_ids[i_new + offset_new];
-        ecs_entity_t src_id = src_ids[i_old + offset_old];
-
-        if (dst_id == src_id) {
-            ecs_switch_t *src_switch = &src_columns[i_old];
-            ecs_switch_t *dst_switch = &dst_columns[i_new];
-
-            flecs_switch_ensure(dst_switch, dst_index + count);
-
-            int i;
-            for (i = 0; i < count; i ++) {
-                uint64_t value = flecs_switch_get(src_switch, src_index + i);
-                flecs_switch_set(dst_switch, dst_index + i, value);
-            }
-
-            if (clear) {
-                ecs_assert(count == flecs_switch_count(src_switch), 
-                    ECS_INTERNAL_ERROR, NULL);
-                flecs_switch_clear(src_switch);
-            }
-        } else if (dst_id > src_id) {
-            ecs_switch_t *src_switch = &src_columns[i_old];
-            flecs_switch_clear(src_switch);
-        }
-
-        i_new += dst_id <= src_id;
-        i_old += dst_id >= src_id;
-    }
-
-    /* Clear remaining columns */
-    if (clear) {
-        for (; (i_old < src_column_count); i_old ++) {
-            ecs_switch_t *src_switch = &src_columns[i_old];
-            ecs_assert(count == flecs_switch_count(src_switch), 
-                ECS_INTERNAL_ERROR, NULL);
-            flecs_switch_clear(src_switch);
-        }
-    }
-}
-
 /* Table move logic for bitset (toggle component) column */
 static
 void flecs_table_move_bitset_columns(
@@ -1405,17 +1268,9 @@ int32_t flecs_table_grow_data(
     }
 
     ecs_table__t *meta = table->_;
-    int32_t sw_count = meta->sw_count;
     int32_t bs_count = meta->bs_count;
-    ecs_switch_t *sw_columns = meta->sw_columns;
     ecs_bitset_t *bs_columns = meta->bs_columns; 
 
-    /* Add elements to each switch column */
-    for (i = 0; i < sw_count; i ++) {
-        ecs_switch_t *sw = &sw_columns[i];
-        flecs_switch_addn(sw, to_add);
-    }
-
     /* Add elements to each bitset column */
     for (i = 0; i < bs_count; i ++) {
         ecs_bitset_t *bs = &bs_columns[i];
@@ -1458,8 +1313,6 @@ int32_t flecs_table_append(
 {
     ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(!(table->flags & EcsTableHasTarget), 
-        ECS_INVALID_OPERATION, NULL);
 
     flecs_table_check_sanity(table);
 
@@ -1515,18 +1368,9 @@ int32_t flecs_table_append(
     }
 
     ecs_table__t *meta = table->_;
-    int32_t sw_count = meta->sw_count;
     int32_t bs_count = meta->bs_count;
-    ecs_switch_t *sw_columns = meta->sw_columns;
     ecs_bitset_t *bs_columns = meta->bs_columns;
 
-    /* Add element to each switch column */
-    for (i = 0; i < sw_count; i ++) {
-        ecs_assert(sw_columns != NULL, ECS_INTERNAL_ERROR, NULL);
-        ecs_switch_t *sw = &sw_columns[i];
-        flecs_switch_add(sw);
-    }
-
     /* Add element to each bitset column */
     for (i = 0; i < bs_count; i ++) {
         ecs_assert(bs_columns != NULL, ECS_INTERNAL_ERROR, NULL);
@@ -1581,8 +1425,6 @@ void flecs_table_delete(
     ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    ecs_assert(!(table->flags & EcsTableHasTarget), 
-        ECS_INVALID_OPERATION, NULL);
 
     flecs_table_check_sanity(table);
 
@@ -1689,15 +1531,8 @@ void flecs_table_delete(
         }
     }
 
-    /* Remove elements from switch columns */
-    ecs_table__t *meta = table->_;
-    ecs_switch_t *sw_columns = meta->sw_columns;
-    int32_t sw_count = meta->sw_count;
-    for (i = 0; i < sw_count; i ++) {
-        flecs_switch_remove(&sw_columns[i], index);
-    }
-
     /* Remove elements from bitset columns */
+    ecs_table__t *meta = table->_;
     ecs_bitset_t *bs_columns = meta->bs_columns;
     int32_t bs_count = meta->bs_count;
     for (i = 0; i < bs_count; i ++) {
@@ -1768,7 +1603,6 @@ void flecs_table_move(
         return;
     }
 
-    flecs_table_move_switch_columns(dst_table, dst_index, src_table, src_index, 1, false);
     flecs_table_move_bitset_columns(dst_table, dst_index, src_table, src_index, 1, false);
 
     /* If the source and destination entities are the same, move component 
@@ -1922,26 +1756,6 @@ int32_t flecs_table_data_count(
     return data ? data->entities.count : 0;
 }
 
-/* Swap operation for switch (union relationship) columns */
-static
-void flecs_table_swap_switch_columns(
-    ecs_table_t *table,
-    int32_t row_1,
-    int32_t row_2)
-{
-    int32_t i = 0, column_count = table->_->sw_count;
-    if (!column_count) {
-        return;
-    }
-
-    ecs_switch_t *columns = table->_->sw_columns;
-
-    for (i = 0; i < column_count; i ++) {
-        ecs_switch_t *sw = &columns[i];
-        flecs_switch_swap(sw, row_1, row_2);
-    }
-}
-
 /* Swap operation for bitset (toggle component) columns */
 static
 void flecs_table_swap_bitset_columns(
@@ -2004,7 +1818,6 @@ void flecs_table_swap(
     record_ptr_1->row = ECS_ROW_TO_RECORD(row_2, flags_1);
     record_ptr_2->row = ECS_ROW_TO_RECORD(row_1, flags_2);
 
-    flecs_table_swap_switch_columns(table, row_1, row_2);
     flecs_table_swap_bitset_columns(table, row_1, row_2);
 
     ecs_column_t *columns = table->data.columns;
@@ -2183,7 +1996,6 @@ void flecs_table_merge_data(
         }
     }
 
-    flecs_table_move_switch_columns(dst_table, dst_count, src_table, 0, src_count, true);
     flecs_table_move_bitset_columns(dst_table, dst_count, src_table, 0, src_count, true);
 
     /* Initialize remaining columns */
@@ -2213,38 +2025,18 @@ void flecs_table_merge_data(
 void flecs_table_merge(
     ecs_world_t *world,
     ecs_table_t *dst_table,
-    ecs_table_t *src_table,
-    ecs_data_t *dst_data,
-    ecs_data_t *src_data)
+    ecs_table_t *src_table)
 {
     ecs_assert(src_table != NULL, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(dst_table != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(!src_table->_->lock, ECS_LOCKED_STORAGE, NULL);
+    ecs_assert(!dst_table->_->lock, ECS_LOCKED_STORAGE, NULL);
 
     flecs_table_check_sanity(src_table);
     flecs_table_check_sanity(dst_table);
-    
-    bool move_data = false;
-    
-    /* If there is nothing to merge to, just clear the old table */
-    if (!dst_table) {
-        flecs_table_clear_data(world, src_table, src_data);
-        flecs_table_check_sanity(src_table);
-        return;
-    } else {
-        ecs_assert(!dst_table->_->lock, ECS_LOCKED_STORAGE, NULL);
-    }
-
-    /* If there is no data to merge, drop out */
-    if (!src_data) {
-        return;
-    }
 
-    if (!dst_data) {
-        dst_data = &dst_table->data;
-        if (dst_table == src_table) {
-            move_data = true;
-        }
-    }
+    ecs_data_t *dst_data = &dst_table->data;
+    ecs_data_t *src_data = &src_table->data;
 
     ecs_entity_t *src_entities = src_data->entities.array;
     int32_t src_count = src_data->entities.count;
@@ -2260,12 +2052,8 @@ void flecs_table_merge(
     }
 
     /* Merge table columns */
-    if (move_data) {
-        *dst_data = *src_data;
-    } else {
-        flecs_table_merge_data(world, dst_table, src_table, src_count, dst_count, 
-            src_data, dst_data);
-    }
+    flecs_table_merge_data(world, dst_table, src_table, src_count, dst_count, 
+        src_data, dst_data);
 
     if (src_count) {
         if (!dst_count) {
@@ -2282,40 +2070,6 @@ void flecs_table_merge(
     flecs_table_check_sanity(dst_table);
 }
 
-/* Replace data with other data. Used by snapshots to restore previous state. */
-void flecs_table_replace_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data)
-{
-    int32_t prev_count = 0;
-    ecs_data_t *table_data = &table->data;
-    ecs_assert(!data || data != table_data, ECS_INTERNAL_ERROR, NULL);
-    ecs_assert(!table->_->lock, ECS_LOCKED_STORAGE, NULL);
-
-    flecs_table_check_sanity(table);
-
-    prev_count = table_data->entities.count;
-    flecs_table_notify_on_remove(world, table, table_data);
-    flecs_table_clear_data(world, table, table_data);
-
-    if (data) {
-        table->data = *data;
-    } else {
-        flecs_table_init_data(world, table);
-    }
-
-    int32_t count = ecs_table_count(table);
-
-    if (!prev_count && count) {
-        flecs_table_set_empty(world, table);
-    } else if (prev_count && !count) {
-        flecs_table_set_empty(world, table);
-    }
-
-    flecs_table_check_sanity(table);
-}
-
 /* Internal mechanism for propagating information to tables */
 void flecs_table_notify(
     ecs_world_t *world,
@@ -2335,6 +2089,37 @@ void flecs_table_notify(
     }
 }
 
+int32_t flecs_table_get_toggle_column(
+    ecs_table_t *table,
+    ecs_id_t id)
+{
+    ecs_id_t *ids = table->type.array;
+    int32_t i = table->_->bs_offset, end = i + table->_->bs_count;
+
+    for (; i < end; i ++) {
+        if (ids[i] == (ECS_TOGGLE | id)) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+ecs_bitset_t* flecs_table_get_toggle(
+    ecs_table_t *table,
+    ecs_id_t id)
+{
+    int32_t toggle_column = flecs_table_get_toggle_column(table, id);
+    if (toggle_column == -1) {
+        return NULL;
+    }
+
+    toggle_column -= table->_->bs_offset;
+    ecs_assert(toggle_column >= 0, ECS_INTERNAL_ERROR, NULL);
+    ecs_assert(toggle_column < table->_->bs_count, ECS_INTERNAL_ERROR, NULL);
+    return &table->_->bs_columns[toggle_column];
+}
+
 /* -- Public API -- */
 
 void ecs_table_lock(
@@ -2342,7 +2127,7 @@ void ecs_table_lock(
     ecs_table_t *table)
 {
     if (table) {
-        if (ecs_poly_is(world, ecs_world_t) && !(world->flags & EcsWorldReadonly)) {
+        if (flecs_poly_is(world, ecs_world_t) && !(world->flags & EcsWorldReadonly)) {
             table->_->lock ++;
         }
     }
@@ -2353,9 +2138,10 @@ void ecs_table_unlock(
     ecs_table_t *table)
 {
     if (table) {
-        if (ecs_poly_is(world, ecs_world_t) && !(world->flags & EcsWorldReadonly)) {
+        if (flecs_poly_is(world, ecs_world_t) && !(world->flags & EcsWorldReadonly)) {
             table->_->lock --;
-            ecs_assert(table->_->lock >= 0, ECS_INVALID_OPERATION, NULL);
+            ecs_assert(table->_->lock >= 0, ECS_INVALID_OPERATION, 
+                "table_unlock called more often than table_lock");
         }
     }
 }
@@ -2375,7 +2161,7 @@ int32_t ecs_table_get_type_index(
     const ecs_table_t *table,
     ecs_id_t id)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
 
@@ -2399,7 +2185,7 @@ int32_t ecs_table_get_column_index(
     const ecs_table_t *table,
     ecs_id_t id)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_id_is_valid(world, id), ECS_INVALID_PARAMETER, NULL);
 
@@ -2527,7 +2313,9 @@ int32_t ecs_table_get_depth(
     ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(table != NULL, ECS_INVALID_PARAMETER, NULL);
     ecs_check(ecs_id_is_valid(world, rel), ECS_INVALID_PARAMETER, NULL);
-    ecs_check(ecs_has_id(world, rel, EcsAcyclic), ECS_INVALID_PARAMETER, NULL);
+    ecs_check(ecs_has_id(world, rel, EcsAcyclic), ECS_INVALID_PARAMETER,
+        "cannot safely determine depth for relationship that is not acyclic "
+            "(add Acyclic property to relationship)");
 
     world = ecs_get_world(world);
 
@@ -2543,20 +2331,6 @@ bool ecs_table_has_flags(
     return (table->flags & flags) == flags;
 }
 
-int32_t flecs_table_column_to_union_index(
-    const ecs_table_t *table,
-    int32_t column)
-{
-    int32_t sw_count = table->_->sw_count;
-    if (sw_count) {
-        int32_t sw_offset = table->_->sw_offset;
-        if (column >= sw_offset && column < (sw_offset + sw_count)){
-            return column - sw_offset;
-        }
-    }
-    return -1;
-}
-
 void ecs_table_swap_rows(
     ecs_world_t* world,
     ecs_table_t* table,
diff --git a/src/storage/table.h b/src/storage/table.h
index fba284c67..f5052d6fb 100644
--- a/src/storage/table.h
+++ b/src/storage/table.h
@@ -17,9 +17,6 @@ typedef enum ecs_table_eventkind_t {
 typedef struct ecs_table_event_t {
     ecs_table_eventkind_t kind;
 
-    /* Query event */
-    ecs_query_t *query;
-
     /* Component info event */
     ecs_entity_t component;
 
@@ -42,10 +39,7 @@ typedef struct ecs_table__t {
     struct ecs_table_record_t *records; /* Array with table records */
     ecs_hashmap_t *name_index;       /* Cached pointer to name index */
 
-    ecs_switch_t *sw_columns;        /* Switch columns */
     ecs_bitset_t *bs_columns;        /* Bitset columns */
-    int16_t sw_count;
-    int16_t sw_offset;
     int16_t bs_count;
     int16_t bs_offset;
     int16_t ft_offset;
@@ -128,12 +122,6 @@ void flecs_table_clear_entities_silent(
     ecs_world_t *world,
     ecs_table_t *table);
 
-/* Clear table data. Don't call OnRemove handlers. */
-void flecs_table_clear_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data);    
-
 /* Return number of entities in data */
 int32_t flecs_table_data_count(
     const ecs_data_t *data);
@@ -204,7 +192,7 @@ void flecs_table_remove_actions(
     ecs_table_t *table);
 
 /* Free table */
-void flecs_table_free(
+void flecs_table_fini(
     ecs_world_t *world,
     ecs_table_t *table); 
 
@@ -212,20 +200,12 @@ void flecs_table_free(
 void flecs_table_free_type(
     ecs_world_t *world,
     ecs_table_t *table);     
-    
-/* Replace data */
-void flecs_table_replace_data(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_data_t *data);
 
 /* Merge data of one table into another table */
 void flecs_table_merge(
     ecs_world_t *world,
     ecs_table_t *new_table,
-    ecs_table_t *old_table,
-    ecs_data_t *new_data,
-    ecs_data_t *old_data);
+    ecs_table_t *old_table);
 
 void flecs_table_swap(
     ecs_world_t *world,
@@ -247,10 +227,6 @@ void flecs_table_delete_entities(
     ecs_world_t *world,
     ecs_table_t *table);
 
-int32_t flecs_table_column_to_union_index(
-    const ecs_table_t *table,
-    int32_t column);
-
 /* Increase observer count of table */
 void flecs_table_traversable_add(
     ecs_table_t *table,
@@ -262,4 +238,17 @@ ecs_vec_t* flecs_table_entities(
 ecs_entity_t* flecs_table_entities_array(
     ecs_table_t *table);
 
+void flecs_table_emit(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_entity_t event);
+
+int32_t flecs_table_get_toggle_column(
+    ecs_table_t *table,
+    ecs_id_t id);
+
+ecs_bitset_t* flecs_table_get_toggle(
+    ecs_table_t *table,
+    ecs_id_t id);
+
 #endif
diff --git a/src/storage/table_cache.h b/src/storage/table_cache.h
index 18e1767e5..dea56b0b3 100644
--- a/src/storage/table_cache.h
+++ b/src/storage/table_cache.h
@@ -42,6 +42,7 @@ bool ecs_table_cache_is_empty(
 
 #define flecs_table_cache_count(cache) (cache)->tables.count
 #define flecs_table_cache_empty_count(cache) (cache)->empty_tables.count
+#define flecs_table_cache_all_count(cache) ((cache)->tables.count + (cache)->empty_tables.count)
 
 bool flecs_table_cache_iter(
     ecs_table_cache_t *cache,
diff --git a/src/storage/table_graph.c b/src/storage/table_graph.c
index 977258978..fe013dc9f 100644
--- a/src/storage/table_graph.c
+++ b/src/storage/table_graph.c
@@ -531,7 +531,7 @@ void flecs_init_table(
 }
 
 static
-ecs_table_t *flecs_create_table(
+ecs_table_t *flecs_table_new(
     ecs_world_t *world,
     ecs_type_t *type,
     flecs_hashmap_result_t table_elem,
@@ -599,7 +599,7 @@ ecs_table_t* flecs_table_ensure(
     bool own_type,
     ecs_table_t *prev)
 {    
-    ecs_poly_assert(world, ecs_world_t);   
+    flecs_poly_assert(world, ecs_world_t);   
 
     int32_t id_count = type->count;
     if (!id_count) {
@@ -622,11 +622,11 @@ ecs_table_t* flecs_table_ensure(
 
     /* If we get here, the table has not been found, so create it. */
     if (own_type) {
-        return flecs_create_table(world, type, elem, prev);
+        return flecs_table_new(world, type, elem, prev);
     }
 
     ecs_type_t copy = flecs_type_copy(world, type);
-    return flecs_create_table(world, &copy, elem, prev);
+    return flecs_table_new(world, &copy, elem, prev);
 }
 
 static
@@ -656,23 +656,6 @@ void flecs_compute_table_diff(
     ecs_graph_edge_t *edge,
     ecs_id_t id)
 {
-    if (ECS_IS_PAIR(id)) {
-        ecs_id_record_t *idr = flecs_id_record_get(world, ecs_pair(
-            ECS_PAIR_FIRST(id), EcsWildcard));
-        if (idr->flags & EcsIdUnion) {
-            if (node != next) {
-                id = ecs_pair(EcsUnion, ECS_PAIR_FIRST(id));
-            } else {
-                ecs_table_diff_t *diff = flecs_bcalloc(
-                    &world->allocators.table_diff);
-                diff->added.count = 1;
-                diff->added.array = flecs_wdup_n(world, ecs_id_t, 1, &id);
-                edge->diff = diff;
-                return;
-            }
-        }
-    }
-
     ecs_type_t node_type = node->type;
     ecs_type_t next_type = next->type;
 
@@ -865,17 +848,7 @@ ecs_table_t* flecs_find_table_with(
         r = ECS_PAIR_FIRST(with);
         o = ECS_PAIR_SECOND(with);
         idr = flecs_id_record_ensure(world, ecs_pair(r, EcsWildcard));
-        if (idr->flags & EcsIdUnion) {
-            ecs_type_t dst_type;
-            ecs_id_t union_id = ecs_pair(EcsUnion, r);
-            int res = flecs_type_new_with(
-                world, &dst_type, &node->type, union_id);
-            if (res == -1) {
-                return node;
-            }
-
-            return flecs_table_ensure(world, &dst_type, true, node);
-        } else if (idr->flags & EcsIdExclusive) {
+        if (idr->flags & EcsIdExclusive) {
             /* Relationship is exclusive, check if table already has it */
             ecs_table_record_t *tr = flecs_id_record_get_table(idr, node);
             if (tr) {
@@ -925,16 +898,6 @@ ecs_table_t* flecs_find_table_without(
     ecs_table_t *node,
     ecs_id_t without)
 {
-    if (ECS_IS_PAIR(without)) {
-        ecs_entity_t r = 0;
-        ecs_id_record_t *idr = NULL;
-        r = ECS_PAIR_FIRST(without);
-        idr = flecs_id_record_get(world, ecs_pair(r, EcsWildcard));
-        if (idr && idr->flags & EcsIdUnion) {
-            without = ecs_pair(EcsUnion, r);
-        }
-    }
-
     /* Create sequence with new id */
     ecs_type_t dst_type;
     int res = flecs_type_new_without(world, &dst_type, &node->type, without);
@@ -975,7 +938,7 @@ void flecs_init_edge_for_add(
 
     flecs_table_ensure_hi_edge(world, &table->node.add, id);
 
-    if (table != to || table->flags & EcsTableHasUnion) {
+    if (table != to) {
         /* Add edges are appended to refs.next */
         ecs_graph_edge_hdr_t *to_refs = &to->node.refs;
         ecs_graph_edge_hdr_t *next = to_refs->next;
@@ -1051,7 +1014,7 @@ ecs_table_t* flecs_table_traverse_remove(
     ecs_id_t *id_ptr,
     ecs_table_diff_t *diff)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     node = node ? node : &world->store.root;
 
@@ -1090,7 +1053,7 @@ ecs_table_t* flecs_table_traverse_add(
     ecs_id_t *id_ptr,
     ecs_table_diff_t *diff)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(diff != NULL, ECS_INTERNAL_ERROR, NULL);
 
     node = node ? node : &world->store.root;
@@ -1128,14 +1091,14 @@ ecs_table_t* flecs_table_find_or_create(
     ecs_world_t *world,
     ecs_type_t *type)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     return flecs_table_ensure(world, type, false, NULL);
 }
 
 void flecs_init_root_table(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     world->store.root.type = (ecs_type_t){0};
     world->store.root._ = flecs_calloc_t(&world->allocator, ecs_table__t);
@@ -1152,7 +1115,7 @@ void flecs_table_clear_edges(
     ecs_table_t *table)
 {
     (void)world;
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     ecs_log_push_1();
 
diff --git a/src/value.c b/src/value.c
index 70bd05cf4..324b6d9cf 100644
--- a/src/value.c
+++ b/src/value.c
@@ -10,7 +10,7 @@ int ecs_value_init_w_type_info(
     const ecs_type_info_t *ti,
     void *ptr)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
     (void)world;
 
@@ -31,7 +31,7 @@ int ecs_value_init(
     ecs_entity_t type,
     void *ptr)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     const ecs_type_info_t *ti = ecs_get_type_info(world, type);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
     return ecs_value_init_w_type_info(world, ti, ptr);
@@ -43,7 +43,7 @@ void* ecs_value_new_w_type_info(
     ecs_world_t *world,
     const ecs_type_info_t *ti)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
     (void)world;
 
@@ -62,7 +62,7 @@ void* ecs_value_new(
     ecs_world_t *world,
     ecs_entity_t type)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     const ecs_type_info_t *ti = ecs_get_type_info(world, type);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
 
@@ -76,7 +76,7 @@ int ecs_value_fini_w_type_info(
     const ecs_type_info_t *ti,
     void *ptr)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
     (void)world;
 
@@ -95,7 +95,7 @@ int ecs_value_fini(
     ecs_entity_t type,
     void* ptr)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     (void)world;
     const ecs_type_info_t *ti = ecs_get_type_info(world, type);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
@@ -109,7 +109,7 @@ int ecs_value_free(
     ecs_entity_t type,
     void* ptr)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     const ecs_type_info_t *ti = ecs_get_type_info(world, type);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
     if (ecs_value_fini_w_type_info(world, ti, ptr) != 0) {
@@ -129,7 +129,7 @@ int ecs_value_copy_w_type_info(
     void* dst,
     const void *src)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
     (void)world;
 
@@ -151,7 +151,7 @@ int ecs_value_copy(
     void* dst,
     const void *src)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     const ecs_type_info_t *ti = ecs_get_type_info(world, type);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
     return ecs_value_copy_w_type_info(world, ti, dst, src);
@@ -165,7 +165,7 @@ int ecs_value_move_w_type_info(
     void* dst,
     void *src)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
     (void)world;
 
@@ -187,7 +187,7 @@ int ecs_value_move(
     void* dst,
     void *src)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     const ecs_type_info_t *ti = ecs_get_type_info(world, type);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
     return ecs_value_move_w_type_info(world, ti, dst, src);
@@ -201,7 +201,7 @@ int ecs_value_move_ctor_w_type_info(
     void* dst,
     void *src)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, NULL);
     (void)world;
 
@@ -223,7 +223,7 @@ int ecs_value_move_ctor(
     void* dst,
     void *src)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     const ecs_type_info_t *ti = ecs_get_type_info(world, type);
     ecs_check(ti != NULL, ECS_INVALID_PARAMETER, "entity is not a type");
     return ecs_value_move_w_type_info(world, ti, dst, src);
diff --git a/src/world.c b/src/world.c
index efd9447a4..8f31b603c 100644
--- a/src/world.c
+++ b/src/world.c
@@ -9,13 +9,11 @@
 const ecs_id_t ECS_PAIR =                                          (1ull << 63);
 const ecs_id_t ECS_OVERRIDE =                                      (1ull << 62);
 const ecs_id_t ECS_TOGGLE =                                        (1ull << 61);
-const ecs_id_t ECS_AND =                                           (1ull << 60);
 
 /** Builtin component ids */
 const ecs_entity_t ecs_id(EcsComponent) =                                   1;
 const ecs_entity_t ecs_id(EcsIdentifier) =                                  2;
-const ecs_entity_t ecs_id(EcsIterable) =                                    3;
-const ecs_entity_t ecs_id(EcsPoly) =                                        4;
+const ecs_entity_t ecs_id(EcsPoly) =                                        3;
 
 /* Poly target components */
 const ecs_entity_t EcsQuery =                                               5;
@@ -31,53 +29,57 @@ const ecs_entity_t EcsModule =                      FLECS_HI_COMPONENT_ID + 4;
 const ecs_entity_t EcsPrivate =                     FLECS_HI_COMPONENT_ID + 5;
 const ecs_entity_t EcsPrefab =                      FLECS_HI_COMPONENT_ID + 6;
 const ecs_entity_t EcsDisabled =                    FLECS_HI_COMPONENT_ID + 7;
-
-const ecs_entity_t EcsSlotOf =                      FLECS_HI_COMPONENT_ID + 8;
-const ecs_entity_t EcsFlag =                        FLECS_HI_COMPONENT_ID + 9;
-
-/* Relationship properties */
-const ecs_entity_t EcsWildcard =                    FLECS_HI_COMPONENT_ID + 10;
-const ecs_entity_t EcsAny =                         FLECS_HI_COMPONENT_ID + 11;
-const ecs_entity_t EcsThis =                        FLECS_HI_COMPONENT_ID + 12;
-const ecs_entity_t EcsVariable =                    FLECS_HI_COMPONENT_ID + 13;
-const ecs_entity_t EcsTransitive =                  FLECS_HI_COMPONENT_ID + 14;
-const ecs_entity_t EcsReflexive =                   FLECS_HI_COMPONENT_ID + 15;
-const ecs_entity_t EcsSymmetric =                   FLECS_HI_COMPONENT_ID + 16;
-const ecs_entity_t EcsFinal =                       FLECS_HI_COMPONENT_ID + 17;
-const ecs_entity_t EcsDontInherit =                 FLECS_HI_COMPONENT_ID + 18;
-const ecs_entity_t EcsAlwaysOverride =              FLECS_HI_COMPONENT_ID + 19;
-const ecs_entity_t EcsTag =                         FLECS_HI_COMPONENT_ID + 20;
-const ecs_entity_t EcsUnion =                       FLECS_HI_COMPONENT_ID + 21;
+const ecs_entity_t EcsNotQueryable =                FLECS_HI_COMPONENT_ID + 8;
+
+const ecs_entity_t EcsSlotOf =                      FLECS_HI_COMPONENT_ID + 9;
+const ecs_entity_t EcsFlag =                        FLECS_HI_COMPONENT_ID + 10;
+
+/* Marker entities for query encoding */
+const ecs_entity_t EcsWildcard =                    FLECS_HI_COMPONENT_ID + 11;
+const ecs_entity_t EcsAny =                         FLECS_HI_COMPONENT_ID + 12;
+const ecs_entity_t EcsThis =                        FLECS_HI_COMPONENT_ID + 13;
+const ecs_entity_t EcsVariable =                    FLECS_HI_COMPONENT_ID + 14;
+
+/* Traits */
+const ecs_entity_t EcsTransitive =                  FLECS_HI_COMPONENT_ID + 15;
+const ecs_entity_t EcsReflexive =                   FLECS_HI_COMPONENT_ID + 16;
+const ecs_entity_t EcsSymmetric =                   FLECS_HI_COMPONENT_ID + 17;
+const ecs_entity_t EcsFinal =                       FLECS_HI_COMPONENT_ID + 18;
+const ecs_entity_t EcsDontInherit =                 FLECS_HI_COMPONENT_ID + 19;
+const ecs_entity_t EcsAlwaysOverride =              FLECS_HI_COMPONENT_ID + 20;
+const ecs_entity_t EcsPairIsTag =                   FLECS_HI_COMPONENT_ID + 21;
 const ecs_entity_t EcsExclusive =                   FLECS_HI_COMPONENT_ID + 22;
 const ecs_entity_t EcsAcyclic =                     FLECS_HI_COMPONENT_ID + 23;
 const ecs_entity_t EcsTraversable =                 FLECS_HI_COMPONENT_ID + 24;
 const ecs_entity_t EcsWith =                        FLECS_HI_COMPONENT_ID + 25;
 const ecs_entity_t EcsOneOf =                       FLECS_HI_COMPONENT_ID + 26;
-const ecs_entity_t EcsTrait =                       FLECS_HI_COMPONENT_ID + 27;
-const ecs_entity_t EcsRelationship =            FLECS_HI_COMPONENT_ID + 28;
-const ecs_entity_t EcsTarget =                  FLECS_HI_COMPONENT_ID + 29;
+const ecs_entity_t EcsCanToggle =                   FLECS_HI_COMPONENT_ID + 27;
+const ecs_entity_t EcsTrait =                       FLECS_HI_COMPONENT_ID + 28;
+const ecs_entity_t EcsRelationship =                FLECS_HI_COMPONENT_ID + 29;
+const ecs_entity_t EcsTarget =                      FLECS_HI_COMPONENT_ID + 30;
+
 
 /* Builtin relationships */
-const ecs_entity_t EcsChildOf =                     FLECS_HI_COMPONENT_ID + 30;
-const ecs_entity_t EcsIsA =                         FLECS_HI_COMPONENT_ID + 31;
-const ecs_entity_t EcsDependsOn =                   FLECS_HI_COMPONENT_ID + 32;
+const ecs_entity_t EcsChildOf =                     FLECS_HI_COMPONENT_ID + 31;
+const ecs_entity_t EcsIsA =                         FLECS_HI_COMPONENT_ID + 32;
+const ecs_entity_t EcsDependsOn =                   FLECS_HI_COMPONENT_ID + 33;
 
 /* Identifier tags */
-const ecs_entity_t EcsName =                        FLECS_HI_COMPONENT_ID + 33;
-const ecs_entity_t EcsSymbol =                      FLECS_HI_COMPONENT_ID + 34;
-const ecs_entity_t EcsAlias =                       FLECS_HI_COMPONENT_ID + 35;
+const ecs_entity_t EcsName =                        FLECS_HI_COMPONENT_ID + 34;
+const ecs_entity_t EcsSymbol =                      FLECS_HI_COMPONENT_ID + 35;
+const ecs_entity_t EcsAlias =                       FLECS_HI_COMPONENT_ID + 36;
 
 /* Events */
-const ecs_entity_t EcsOnAdd =                       FLECS_HI_COMPONENT_ID + 36;
-const ecs_entity_t EcsOnRemove =                    FLECS_HI_COMPONENT_ID + 37;
-const ecs_entity_t EcsOnSet =                       FLECS_HI_COMPONENT_ID + 38;
-const ecs_entity_t EcsUnSet =                       FLECS_HI_COMPONENT_ID + 39;
-const ecs_entity_t EcsOnDelete =                    FLECS_HI_COMPONENT_ID + 40;
-const ecs_entity_t EcsOnTableCreate =               FLECS_HI_COMPONENT_ID + 41;
-const ecs_entity_t EcsOnTableDelete =               FLECS_HI_COMPONENT_ID + 42;
-const ecs_entity_t EcsOnTableEmpty =                FLECS_HI_COMPONENT_ID + 43;
-const ecs_entity_t EcsOnTableFill =                 FLECS_HI_COMPONENT_ID + 44;
-const ecs_entity_t EcsOnDeleteTarget =              FLECS_HI_COMPONENT_ID + 46;
+const ecs_entity_t EcsOnAdd =                       FLECS_HI_COMPONENT_ID + 37;
+const ecs_entity_t EcsOnRemove =                    FLECS_HI_COMPONENT_ID + 38;
+const ecs_entity_t EcsOnSet =                       FLECS_HI_COMPONENT_ID + 39;
+const ecs_entity_t EcsUnSet =                       FLECS_HI_COMPONENT_ID + 40;
+const ecs_entity_t EcsOnDelete =                    FLECS_HI_COMPONENT_ID + 41;
+const ecs_entity_t EcsOnDeleteTarget =              FLECS_HI_COMPONENT_ID + 42;
+const ecs_entity_t EcsOnTableCreate =               FLECS_HI_COMPONENT_ID + 43;
+const ecs_entity_t EcsOnTableDelete =               FLECS_HI_COMPONENT_ID + 44;
+const ecs_entity_t EcsOnTableEmpty =                FLECS_HI_COMPONENT_ID + 45;
+const ecs_entity_t EcsOnTableFill =                 FLECS_HI_COMPONENT_ID + 46;
 
 /* Timers */
 const ecs_entity_t ecs_id(EcsTickSource) =          FLECS_HI_COMPONENT_ID + 47;
@@ -90,11 +92,9 @@ const ecs_entity_t EcsDelete =                      FLECS_HI_COMPONENT_ID + 51;
 const ecs_entity_t EcsPanic =                       FLECS_HI_COMPONENT_ID + 52;
 
 /* Misc */
-const ecs_entity_t ecs_id(EcsFlattenTarget) =       FLECS_HI_COMPONENT_ID + 53;
-const ecs_entity_t EcsFlatten =                     FLECS_HI_COMPONENT_ID + 54;
-const ecs_entity_t EcsDefaultChildComponent =       FLECS_HI_COMPONENT_ID + 55;
+const ecs_entity_t ecs_id(EcsDefaultChildComponent) = FLECS_HI_COMPONENT_ID + 55;
 
-/* Builtin predicate ids (used by rule engine) */
+/* Builtin predicate ids (used by query engine) */
 const ecs_entity_t EcsPredEq =                      FLECS_HI_COMPONENT_ID + 56;
 const ecs_entity_t EcsPredMatch =                   FLECS_HI_COMPONENT_ID + 57;
 const ecs_entity_t EcsPredLookup =                  FLECS_HI_COMPONENT_ID + 58;
@@ -119,6 +119,7 @@ const ecs_entity_t EcsPostFrame =                   FLECS_HI_COMPONENT_ID + 74;
 const ecs_entity_t EcsPhase =                       FLECS_HI_COMPONENT_ID + 75;
 
 /* Meta primitive components (don't use low ids to save id space) */
+#ifdef FLECS_META
 const ecs_entity_t ecs_id(ecs_bool_t) =             FLECS_HI_COMPONENT_ID + 80;
 const ecs_entity_t ecs_id(ecs_char_t) =             FLECS_HI_COMPONENT_ID + 81;
 const ecs_entity_t ecs_id(ecs_byte_t) =             FLECS_HI_COMPONENT_ID + 82;
@@ -139,8 +140,8 @@ const ecs_entity_t ecs_id(ecs_entity_t) =           FLECS_HI_COMPONENT_ID + 96;
 const ecs_entity_t ecs_id(ecs_id_t) =               FLECS_HI_COMPONENT_ID + 97;
 
 /** Meta module component ids */
-const ecs_entity_t ecs_id(EcsMetaType) =            FLECS_HI_COMPONENT_ID + 98;
-const ecs_entity_t ecs_id(EcsMetaTypeSerialized) =  FLECS_HI_COMPONENT_ID + 99;
+const ecs_entity_t ecs_id(EcsType) =                FLECS_HI_COMPONENT_ID + 98;
+const ecs_entity_t ecs_id(EcsTypeSerializer) =      FLECS_HI_COMPONENT_ID + 99;
 const ecs_entity_t ecs_id(EcsPrimitive) =           FLECS_HI_COMPONENT_ID + 100;
 const ecs_entity_t ecs_id(EcsEnum) =                FLECS_HI_COMPONENT_ID + 101;
 const ecs_entity_t ecs_id(EcsBitmask) =             FLECS_HI_COMPONENT_ID + 102;
@@ -154,16 +155,21 @@ const ecs_entity_t ecs_id(EcsUnit) =                FLECS_HI_COMPONENT_ID + 109;
 const ecs_entity_t ecs_id(EcsUnitPrefix) =          FLECS_HI_COMPONENT_ID + 110;
 const ecs_entity_t EcsConstant =                    FLECS_HI_COMPONENT_ID + 111;
 const ecs_entity_t EcsQuantity =                    FLECS_HI_COMPONENT_ID + 112;
+#endif
 
 /* Doc module components */
+#ifdef FLECS_DOC
 const ecs_entity_t ecs_id(EcsDocDescription) =      FLECS_HI_COMPONENT_ID + 113;
 const ecs_entity_t EcsDocBrief =                    FLECS_HI_COMPONENT_ID + 114;
 const ecs_entity_t EcsDocDetail =                   FLECS_HI_COMPONENT_ID + 115;
 const ecs_entity_t EcsDocLink =                     FLECS_HI_COMPONENT_ID + 116;
 const ecs_entity_t EcsDocColor =                    FLECS_HI_COMPONENT_ID + 117;
+#endif
 
 /* REST module components */
+#ifdef FLECS_REST
 const ecs_entity_t ecs_id(EcsRest) =                FLECS_HI_COMPONENT_ID + 118;
+#endif
 
 /* Default lookup path */
 static ecs_entity_t ecs_default_lookup_path[2] = { 0, 0 };
@@ -316,18 +322,17 @@ ECS_DECLARE(EcsUri);
 
 /* -- Private functions -- */
 
-const ecs_stage_t* flecs_stage_from_readonly_world(
+ecs_stage_t* flecs_stage_from_readonly_world(
     const ecs_world_t *world)
 {
-    ecs_assert(ecs_poly_is(world, ecs_world_t) ||
-               ecs_poly_is(world, ecs_stage_t),
+    ecs_assert(flecs_poly_is(world, ecs_world_t) ||
+               flecs_poly_is(world, ecs_stage_t),
                ECS_INTERNAL_ERROR,
                NULL);
 
-    if (ecs_poly_is(world, ecs_world_t)) {
-        return &world->stages[0];
-
-    } else if (ecs_poly_is(world, ecs_stage_t)) {
+    if (flecs_poly_is(world, ecs_world_t)) {
+        return ECS_CONST_CAST(ecs_stage_t*, world->stages[0]);
+    } else if (flecs_poly_is(world, ecs_stage_t)) {
         return ECS_CONST_CAST(ecs_stage_t*, world);
     }
 
@@ -339,13 +344,13 @@ ecs_stage_t* flecs_stage_from_world(
 {
     ecs_world_t *world = *world_ptr;
 
-    ecs_assert(ecs_poly_is(world, ecs_world_t) ||
-               ecs_poly_is(world, ecs_stage_t),
+    ecs_assert(flecs_poly_is(world, ecs_world_t) ||
+               flecs_poly_is(world, ecs_stage_t),
                ECS_INTERNAL_ERROR,
                NULL);
 
-    if (ecs_poly_is(world, ecs_world_t)) {
-        return &world->stages[0];
+    if (flecs_poly_is(world, ecs_world_t)) {
+        return world->stages[0];
     }
 
     *world_ptr = ((ecs_stage_t*)world)->world;
@@ -361,7 +366,7 @@ ecs_world_t* flecs_suspend_readonly(
 
     ecs_world_t *world =
         ECS_CONST_CAST(ecs_world_t*, ecs_get_world(stage_world));
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     bool is_readonly = ECS_BIT_IS_SET(world->flags, EcsWorldReadonly);
     ecs_world_t *temp_world = world;
@@ -402,7 +407,7 @@ void flecs_resume_readonly(
     ecs_world_t *world,
     ecs_suspend_readonly_state_t *state)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(state != NULL, ECS_INTERNAL_ERROR, NULL);
 
     ecs_world_t *temp_world = world;
@@ -433,7 +438,7 @@ static
 void flecs_eval_component_monitor(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     if (!world->monitors.is_dirty) {
         return;
@@ -454,7 +459,8 @@ void flecs_eval_component_monitor(
         ecs_query_t **elems = ecs_vec_first(&m->queries);
         for (i = 0; i < count; i ++) {
             ecs_query_t *q = elems[i];
-            flecs_query_notify(world, q, &(ecs_query_event_t) {
+            flecs_poly_assert(q, ecs_query_t);
+            flecs_query_cache_notify(world, q, &(ecs_query_cache_event_t) {
                 .kind = EcsQueryTableRematch
             });
         }
@@ -489,6 +495,7 @@ void flecs_monitor_register(
     ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(query, ecs_query_t);
 
     ecs_map_t *monitors = &world->monitors.monitors;
     ecs_map_init_if(monitors, &world->allocator);
@@ -507,6 +514,7 @@ void flecs_monitor_unregister(
     ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL);
+    flecs_poly_assert(query, ecs_query_t);
 
     ecs_map_t *monitors = &world->monitors.monitors;
     if (!ecs_map_is_init(monitors)) {
@@ -553,15 +561,19 @@ void flecs_init_store(
     /* Initialize entity index */
     flecs_entities_init(world);
 
-    /* Initialize root table */
-    flecs_sparse_init_t(&world->store.tables,
+    /* Initialize table sparse set */
+    flecs_sparse_init_t(&world->store.tables, 
         a, &world->allocators.sparse_chunk, ecs_table_t);
 
     /* Initialize table map */
     flecs_table_hashmap_init(world, &world->store.table_map);
 
-    /* Initialize one root table per stage */
+    /* Initialize root table */
     flecs_init_root_table(world);
+
+    /* Initilaize observer sparse set */
+    flecs_sparse_init_t(&world->store.observers,
+        a, &world->allocators.sparse_chunk, ecs_observer_impl_t);
 }
 
 static
@@ -579,7 +591,7 @@ void flecs_clean_tables(
     for (i = 1; i < count; i ++) {
         ecs_table_t *t = flecs_sparse_get_dense_t(&world->store.tables,
             ecs_table_t, i);
-        flecs_table_free(world, t);
+        flecs_table_fini(world, t);
     }
 
     /* Free table types separately so that if application destructors rely on
@@ -612,7 +624,7 @@ void flecs_fini_root_tables(
     while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) {
         ecs_table_t *table = tr->hdr.table;
         if (table->flags & EcsTableHasBuiltins) {
-            continue; /* Filter out modules */
+            continue; /* Query out modules */
         }
 
         int32_t i, count = table->data.entities.count;
@@ -655,23 +667,27 @@ void flecs_fini_roots(
      * regular entities first, which reduces the chance of components getting
      * destructed in random order because it got deleted before entities,
      * thereby bypassing the OnDeleteTarget policy. */
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
     flecs_fini_root_tables(world, idr, true);
-    flecs_defer_end(world, &world->stages[0]);
+    flecs_defer_end(world, world->stages[0]);
 
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
     flecs_fini_root_tables(world, idr, false);
-    flecs_defer_end(world, &world->stages[0]);
+    flecs_defer_end(world, world->stages[0]);
 }
 
 static
 void flecs_fini_store(ecs_world_t *world) {
     flecs_clean_tables(world);
     flecs_sparse_fini(&world->store.tables);
-    flecs_table_free(world, &world->store.root);
+    flecs_table_fini(world, &world->store.root);
     flecs_entities_clear(world);
     flecs_hashmap_fini(&world->store.table_map);
 
+    ecs_assert(flecs_sparse_count(&world->store.observers) == 0, 
+        ECS_INTERNAL_ERROR, NULL);
+    flecs_sparse_fini(&world->store.observers);
+
     ecs_allocator_t *a = &world->allocator;
     ecs_vec_fini_t(a, &world->store.records, ecs_table_record_t);
     ecs_vec_fini_t(a, &world->store.marked_ids, ecs_marked_id_t);
@@ -679,47 +695,7 @@ void flecs_fini_store(ecs_world_t *world) {
     ecs_map_fini(&world->store.entity_to_depth);
 }
 
-/* Implementation for iterable mixin */
-static
-bool flecs_world_iter_next(
-    ecs_iter_t *it)
-{
-    if (ECS_BIT_IS_SET(it->flags, EcsIterIsValid)) {
-        ECS_BIT_CLEAR(it->flags, EcsIterIsValid);
-        ecs_iter_fini(it);
-        return false;
-    }
-
-    ecs_world_t *world = it->real_world;
-    it->entities = ECS_CONST_CAST(ecs_entity_t*, flecs_entities_ids(world));
-    it->count = flecs_entities_count(world);
-    flecs_iter_validate(it);
-
-    return true;
-}
-
-static
-void flecs_world_iter_init(
-    const ecs_world_t *world,
-    const ecs_poly_t *poly,
-    ecs_iter_t *iter,
-    ecs_term_t *filter)
-{
-    ecs_poly_assert(poly, ecs_world_t);
-    (void)poly;
-
-    if (filter) {
-        iter[0] = ecs_term_iter(world, filter);
-    } else {
-        iter[0] = (ecs_iter_t){
-            .world = ECS_CONST_CAST(ecs_world_t*, world),
-            .real_world = ECS_CONST_CAST(ecs_world_t*, ecs_get_world(world)),
-            .next = flecs_world_iter_next
-        };
-    }
-}
-
-static
+static 
 void flecs_world_allocators_init(
     ecs_world_t *world)
 {
@@ -730,8 +706,8 @@ void flecs_world_allocators_init(
     ecs_map_params_init(&a->ptr, &world->allocator);
     ecs_map_params_init(&a->query_table_list, &world->allocator);
 
-    flecs_ballocator_init_t(&a->query_table, ecs_query_table_t);
-    flecs_ballocator_init_t(&a->query_table_match, ecs_query_table_match_t);
+    flecs_ballocator_init_t(&a->query_table, ecs_query_cache_table_t);
+    flecs_ballocator_init_t(&a->query_table_match, ecs_query_cache_table_match_t);
     flecs_ballocator_init_n(&a->graph_edge_lo, ecs_graph_edge_t, FLECS_HI_COMPONENT_ID);
     flecs_ballocator_init_t(&a->graph_edge, ecs_graph_edge_t);
     flecs_ballocator_init_t(&a->id_record, ecs_id_record_t);
@@ -750,7 +726,6 @@ void flecs_world_allocators_fini(
 
     ecs_map_params_fini(&a->ptr);
     ecs_map_params_fini(&a->query_table_list);
-
     flecs_ballocator_fini(&a->query_table);
     flecs_ballocator_fini(&a->query_table_match);
     flecs_ballocator_fini(&a->graph_edge_lo);
@@ -788,18 +763,12 @@ static const char *flecs_addons_info[] = {
 #ifdef FLECS_MODULE
     "FLECS_MODULE",
 #endif
-#ifdef FLECS_PARSER
-    "FLECS_PARSER",
-#endif
-#ifdef FLECS_PLECS
-    "FLECS_PLECS",
+#ifdef FLECS_SCRIPT
+    "FLECS_SCRIPT",
 #endif
 #ifdef FLECS_RULES
     "FLECS_RULES",
 #endif
-#ifdef FLECS_SNAPSHOT
-    "FLECS_SNAPSHOT",
-#endif
 #ifdef FLECS_STATS
     "FLECS_STATS",
 #endif
@@ -824,15 +793,9 @@ static const char *flecs_addons_info[] = {
 #ifdef FLECS_META
     "FLECS_META",
 #endif
-#ifdef FLECS_META_C
-    "FLECS_META_C",
-#endif
 #ifdef FLECS_UNITS
     "FLECS_UNITS",
 #endif
-#ifdef FLECS_EXPR
-    "FLECS_EXPR",
-#endif
 #ifdef FLECS_JSON
     "FLECS_JSON",
 #endif
@@ -950,7 +913,7 @@ ecs_world_t *ecs_mini(void) {
 
     ecs_world_t *world = ecs_os_calloc_t(ecs_world_t);
     ecs_assert(world != NULL, ECS_OUT_OF_MEMORY, NULL);
-    ecs_poly_init(world, ecs_world_t);
+    flecs_poly_init(world, ecs_world_t);
 
     world->flags |= EcsWorldInit;
 
@@ -963,7 +926,6 @@ ecs_world_t *ecs_mini(void) {
     ecs_map_init_w_params(&world->id_index_hi, &world->allocators.ptr);
     world->id_index_lo = ecs_os_calloc_n(ecs_id_record_t, FLECS_HI_ID_RECORD_ID);
     flecs_observable_init(&world->observable);
-    world->iterable.init = flecs_world_iter_init;
 
     world->pending_tables = ecs_os_calloc_t(ecs_sparse_t);
     flecs_sparse_init_t(world->pending_tables, a,
@@ -1084,7 +1046,7 @@ void flecs_notify_tables(
     ecs_id_t id,
     ecs_table_event_t *event)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     /* If no id is specified, broadcast to all tables */
     if (!id) {
@@ -1112,9 +1074,9 @@ void flecs_notify_tables(
     }
 }
 
-void ecs_default_ctor(
-    void *ptr,
-    int32_t count,
+void flecs_default_ctor(
+    void *ptr, 
+    int32_t count, 
     const ecs_type_info_t *ti)
 {
     ecs_os_memset(ptr, 0, ti->size * count);
@@ -1215,9 +1177,10 @@ void ecs_set_hooks_id(
             world, component, EcsComponent);
 
         /* Cannot register lifecycle actions for things that aren't a component */
-        ecs_check(component_ptr != NULL, ECS_INVALID_PARAMETER, NULL);
-        /* Cannot register lifecycle actions for components with size 0 */
-        ecs_check(component_ptr->size != 0, ECS_INVALID_PARAMETER, NULL);
+        ecs_check(component_ptr != NULL, ECS_INVALID_PARAMETER, 
+            "provided entity is not a component");
+        ecs_check(component_ptr->size != 0, ECS_INVALID_PARAMETER,
+            "cannot register type hooks for type with size 0");
 
         ti->size = component_ptr->size;
         ti->alignment = component_ptr->alignment;
@@ -1246,7 +1209,7 @@ void ecs_set_hooks_id(
      * ease of use, if no constructor is specified, set a default one that
      * initializes the component to 0. */
     if (!h->ctor && (h->dtor || h->copy || h->move)) {
-        ti->hooks.ctor = ecs_default_ctor;
+        ti->hooks.ctor = flecs_default_ctor;   
     }
 
     /* Set default copy ctor, move ctor and merge */
@@ -1321,7 +1284,7 @@ void ecs_atfini(
     ecs_fini_action_t action,
     void *ctx)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(action != NULL, ECS_INVALID_PARAMETER, NULL);
 
     ecs_action_elem_t *elem = ecs_vec_append_t(NULL, &world->fini_actions,
@@ -1415,10 +1378,12 @@ ecs_entity_t flecs_get_oneof(
 int ecs_fini(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
-    ecs_assert(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION, NULL);
-    ecs_assert(world->stages[0].defer == 0, ECS_INVALID_OPERATION,
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION,
+        "cannot fini world while it is in readonly mode");
+    ecs_assert(!(world->flags & EcsWorldFini), ECS_INVALID_OPERATION,
+        "cannot fini world when it is already being deleted");
+    ecs_assert(world->stages[0]->defer == 0, ECS_INVALID_OPERATION, 
         "call defer_end before destroying world");
 
     ecs_trace("#[bold]shutting down world");
@@ -1447,7 +1412,7 @@ int ecs_fini(
 
     /* Operations invoked during UnSet/OnRemove/destructors are deferred and
      * will be discarded after world cleanup */
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
 
     /* Run UnSet/OnRemove actions for components while the store is still
      * unmodified by cleanup. */
@@ -1458,7 +1423,7 @@ int ecs_fini(
 
     /* Purge deferred operations from the queue. This discards operations but
      * makes sure that any resources in the queue are freed */
-    flecs_defer_purge(world, &world->stages[0]);
+    flecs_defer_purge(world, world->stages[0]);
     ecs_log_pop_1();
 
     /* All queries are cleaned up, so monitors should've been cleaned up too */
@@ -1493,7 +1458,7 @@ int ecs_fini(
     flecs_world_allocators_fini(world);
 
     /* End of the world */
-    ecs_poly_free(world, ecs_world_t);
+    flecs_poly_free(world, ecs_world_t);
     ecs_os_fini();
 
     ecs_trace("world destroyed, bye!");
@@ -1514,15 +1479,15 @@ void ecs_dim(
     ecs_world_t *world,
     int32_t entity_count)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     flecs_entities_set_size(world, entity_count + FLECS_HI_COMPONENT_ID);
 }
 
 void flecs_eval_component_monitors(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    flecs_process_pending_tables(world);
+    flecs_poly_assert(world, ecs_world_t); 
+    flecs_process_pending_tables(world);  
     flecs_eval_component_monitor(world);
 }
 
@@ -1530,7 +1495,7 @@ void ecs_measure_frame_time(
     ecs_world_t *world,
     bool enable)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL);
 
     if (ECS_EQZERO(world->info.target_fps) || enable) {
@@ -1544,7 +1509,7 @@ void ecs_measure_system_time(
     ecs_world_t *world,
     bool enable)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL);
     ECS_BIT_COND(world->flags, EcsWorldMeasureSystemTime, enable);
 error:
@@ -1555,7 +1520,7 @@ void ecs_set_target_fps(
     ecs_world_t *world,
     ecs_ftime_t fps)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL);
 
     ecs_measure_frame_time(world, true);
@@ -1589,7 +1554,7 @@ void ecs_set_ctx(
     void *ctx,
     ecs_ctx_free_t ctx_free)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     world->ctx = ctx;
     world->ctx_free = ctx_free;
 }
@@ -1599,7 +1564,7 @@ void ecs_set_binding_ctx(
     void *ctx,
     ecs_ctx_free_t ctx_free)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     world->binding_ctx = ctx;
     world->binding_ctx_free = ctx_free;
 }
@@ -1609,7 +1574,7 @@ void ecs_set_entity_range(
     ecs_entity_t id_start,
     ecs_entity_t id_end)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_check(!id_end || id_end > id_start, ECS_INVALID_PARAMETER, NULL);
     ecs_check(!id_end || id_end > flecs_entities_max_id(world),
         ECS_INVALID_PARAMETER, NULL);
@@ -1631,7 +1596,7 @@ bool ecs_enable_range_check(
     ecs_world_t *world,
     bool enable)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);    
     bool old_value = world->range_check_enabled;
     world->range_check_enabled = enable;
     return old_value;
@@ -1647,29 +1612,11 @@ ecs_entity_t ecs_get_max_id(
     return 0;
 }
 
-void ecs_set_entity_generation(
-    ecs_world_t *world,
-    ecs_entity_t entity_with_generation)
-{
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
-    ecs_assert(!(ecs_is_deferred(world)), ECS_INVALID_OPERATION, NULL);
-
-    flecs_entities_make_alive(world, entity_with_generation);
-
-    ecs_record_t *r = flecs_entities_get(world, entity_with_generation);
-    if (r && r->table) {
-        int32_t row = ECS_RECORD_TO_ROW(r->row);
-        ecs_entity_t *entities = r->table->data.entities.array;
-        entities[row] = entity_with_generation;
-    }
-}
-
 const ecs_type_info_t* flecs_type_info_get(
     const ecs_world_t *world,
     ecs_entity_t component)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);   
 
     ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL);
     ecs_assert(!(component & ECS_ID_FLAGS_MASK), ECS_INTERNAL_ERROR, NULL);
@@ -1681,7 +1628,7 @@ ecs_type_info_t* flecs_type_info_ensure(
     ecs_world_t *world,
     ecs_entity_t component)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL);
 
     const ecs_type_info_t *ti = flecs_type_info_get(world, component);
@@ -1815,7 +1762,7 @@ ecs_ftime_t flecs_insert_sleep(
     ecs_world_t *world,
     ecs_time_t *stop)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);  
 
     ecs_time_t start = *stop, now = start;
     ecs_ftime_t delta_time = (ecs_ftime_t)ecs_time_measure(stop);
@@ -1856,7 +1803,7 @@ ecs_ftime_t flecs_start_measure_frame(
     ecs_world_t *world,
     ecs_ftime_t user_delta_time)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);  
 
     ecs_ftime_t delta_time = 0;
 
@@ -1898,7 +1845,7 @@ static
 void flecs_stop_measure_frame(
     ecs_world_t* world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);  
 
     if (world->flags & EcsWorldMeasureFrameTime) {
         ecs_time_t t = world->frame_start_time;
@@ -1910,9 +1857,10 @@ ecs_ftime_t ecs_frame_begin(
     ecs_world_t *world,
     ecs_ftime_t user_delta_time)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
-    ecs_check(ECS_NEQZERO(user_delta_time) || ecs_os_has_time(),
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, 
+        "cannot begin frame while world is in readonly mode");
+    ecs_check(ECS_NEQZERO(user_delta_time) || ecs_os_has_time(), 
         ECS_MISSING_OS_API, "get_time");
 
     /* Start measuring total frame time */
@@ -1944,15 +1892,15 @@ ecs_ftime_t ecs_frame_begin(
 void ecs_frame_end(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    ecs_check(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, NULL);
+    flecs_poly_assert(world, ecs_world_t);
+    ecs_check(!(world->flags & EcsWorldReadonly), ECS_INVALID_OPERATION, 
+        "cannot end frame while world is in readonly mode");
 
     world->info.frame_count_total ++;
-
-    ecs_stage_t *stages = world->stages;
+    
     int32_t i, count = world->stage_count;
     for (i = 0; i < count; i ++) {
-        flecs_stage_merge_post_frame(world, &stages[i]);
+        flecs_stage_merge_post_frame(world, world->stages[i]);
     }
 
     flecs_stop_measure_frame(world);
@@ -1968,15 +1916,15 @@ void flecs_delete_table(
     ecs_world_t *world,
     ecs_table_t *table)
 {
-    ecs_poly_assert(world, ecs_world_t);
-    flecs_table_free(world, table);
+    flecs_poly_assert(world, ecs_world_t); 
+    flecs_table_fini(world, table);
 }
 
 static
 void flecs_process_empty_queries(
     ecs_world_t *world)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t); 
 
     ecs_id_record_t *idr = flecs_id_record_get(world,
         ecs_pair(ecs_id(EcsPoly), EcsQuery));
@@ -1988,7 +1936,7 @@ void flecs_process_empty_queries(
 
     /* Make sure that we defer adding the inactive tags until after iterating
      * the query */
-    flecs_defer_begin(world, &world->stages[0]);
+    flecs_defer_begin(world, world->stages[0]);
 
     ecs_table_cache_iter_t it;
     const ecs_table_record_t *tr;
@@ -2001,21 +1949,21 @@ void flecs_process_empty_queries(
             for (i = 0; i < count; i ++) {
                 ecs_query_t *query = queries[i].poly;
                 ecs_entity_t *entities = table->data.entities.array;
-                if (!ecs_query_table_count(query)) {
+                if (!ecs_query_is_true(query)) {
                     ecs_add_id(world, entities[i], EcsEmpty);
                 }
             }
         }
     }
 
-    flecs_defer_end(world, &world->stages[0]);
+    flecs_defer_end(world, world->stages[0]);
 }
 
 /** Walk over tables that had a state change which requires bookkeeping */
 void flecs_process_pending_tables(
     const ecs_world_t *world_r)
 {
-    ecs_poly_assert(world_r, ecs_world_t);
+    flecs_poly_assert(world_r, ecs_world_t);
 
     /* We can't update the administration while in readonly mode, but we can
      * ensure that when this function is called there are no pending events. */
@@ -2058,7 +2006,7 @@ void flecs_process_pending_tables(
         /* Make sure that any ECS operations that occur while delivering the
          * events does not cause inconsistencies, like sending an Empty
          * notification for a table that just became non-empty. */
-        flecs_defer_begin(world, &world->stages[0]);
+        flecs_defer_begin(world, world->stages[0]);
 
         for (i = 0; i < count; i ++) {
             ecs_table_t *table = flecs_sparse_get_dense_t(
@@ -2087,13 +2035,7 @@ void flecs_process_pending_tables(
 
                     ecs_log_push_3();
 
-                    flecs_emit(world, world, &(ecs_event_desc_t){
-                        .event = evt,
-                        .table = table,
-                        .ids = &table->type,
-                        .observable = world,
-                        .flags = EcsEventTableOnly
-                    });
+                    flecs_table_emit(world, table, evt);
 
                     ecs_log_pop_3();
                 }
@@ -2114,7 +2056,7 @@ void flecs_table_set_empty(
     ecs_world_t *world,
     ecs_table_t *table)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
     ecs_assert(!(world->flags & EcsWorldReadonly), ECS_INTERNAL_ERROR, NULL);
     ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL);
 
@@ -2142,14 +2084,16 @@ void ecs_run_aperiodic(
     ecs_world_t *world,
     ecs_flags32_t flags)
 {
-    ecs_poly_assert(world, ecs_world_t);
-
+    flecs_poly_assert(world, ecs_world_t);
+    
     if (!flags || (flags & EcsAperiodicEmptyTables)) {
         flecs_process_pending_tables(world);
     }
+
     if ((flags & EcsAperiodicEmptyQueries)) {
         flecs_process_empty_queries(world);
     }
+
     if (!flags || (flags & EcsAperiodicComponentMonitors)) {
         flecs_eval_component_monitors(world);
     }
@@ -2163,7 +2107,7 @@ int32_t ecs_delete_empty_tables(
     int32_t min_id_count,
     double time_budget_seconds)
 {
-    ecs_poly_assert(world, ecs_world_t);
+    flecs_poly_assert(world, ecs_world_t);
 
     /* Make sure empty tables are in the empty table lists */
     ecs_run_aperiodic(world, EcsAperiodicEmptyTables);
@@ -2205,7 +2149,7 @@ int32_t ecs_delete_empty_tables(
 
             uint16_t gen = ++ table->_->generation;
             if (delete_generation && (gen > delete_generation)) {
-                flecs_table_free(world, table);
+                flecs_table_fini(world, table);
                 delete_count ++;
             } else if (clear_generation && (gen > clear_generation)) {
                 if (flecs_table_shrink(world, table)) {
diff --git a/src/world.h b/src/world.h
index def797307..3504c9a8d 100644
--- a/src/world.h
+++ b/src/world.h
@@ -11,7 +11,7 @@ ecs_stage_t* flecs_stage_from_world(
     ecs_world_t **world_ptr);
 
 /* Get current thread-specific stage from readonly world */
-const ecs_stage_t* flecs_stage_from_readonly_world(
+ecs_stage_t* flecs_stage_from_readonly_world(
     const ecs_world_t *world);
 
 /* Get component callbacks */
@@ -83,37 +83,6 @@ void flecs_delete_table(
 void flecs_process_pending_tables(
     const ecs_world_t *world);
 
-/* Suspend/resume readonly state. To fully support implicit registration of
- * components, it should be possible to register components while the world is
- * in readonly mode. It is not uncommon that a component is used first from
- * within a system, which are often ran while in readonly mode.
- * 
- * Suspending readonly mode is only allowed when the world is not multithreaded.
- * When a world is multithreaded, it is not safe to (even temporarily) leave
- * readonly mode, so a multithreaded application should always explicitly
- * register components in advance. 
- * 
- * These operations also suspend deferred mode.
- */
-typedef struct ecs_suspend_readonly_state_t {
-    bool is_readonly;
-    bool is_deferred;
-    int32_t defer_count;
-    ecs_entity_t scope;
-    ecs_entity_t with;
-    ecs_vec_t commands;
-    ecs_stack_t defer_stack;
-    ecs_stage_t *stage;
-} ecs_suspend_readonly_state_t;
-
-ecs_world_t* flecs_suspend_readonly(
-    const ecs_world_t *world,
-    ecs_suspend_readonly_state_t *state);
-
-void flecs_resume_readonly(
-    ecs_world_t *world,
-    ecs_suspend_readonly_state_t *state);
-
 /* Convenience macro's for world allocator */
 #define flecs_walloc(world, size)\
     flecs_alloc(&world->allocator, size)
diff --git a/test/.gitignore b/test/.gitignore
deleted file mode 100644
index 4cfc12ad8..000000000
--- a/test/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-bake/
diff --git a/test/BUILD.bazel b/test/BUILD.bazel
index dadce385b..8cafe0818 100644
--- a/test/BUILD.bazel
+++ b/test/BUILD.bazel
@@ -21,11 +21,11 @@ cc_test(
 )
 
 cc_test(
-    name = "cpp_api",
+    name = "cpp",
     deps = ["//:flecs", "@bake//:driver-test"],
     
-    srcs = glob(["cpp_api/src/*.cpp", "cpp_api/**/*.h"]),
-    includes = ["cpp_api/include"],
+    srcs = glob(["cpp/src/*.cpp", "cpp/**/*.h"]),
+    includes = ["cpp/include"],
 
     timeout = "short",
 )
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9e1534e7b..b487801fc 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -83,7 +83,9 @@ if(UNIX AND NOT APPLE)
   target_link_libraries(bake_base PUBLIC m)
 endif()
 
+add_flecs_test("${CMAKE_CURRENT_LIST_DIR}/core")
 add_flecs_test("${CMAKE_CURRENT_LIST_DIR}/addons")
-add_flecs_test("${CMAKE_CURRENT_LIST_DIR}/api")
+add_flecs_test("${CMAKE_CURRENT_LIST_DIR}/query")
+add_flecs_test("${CMAKE_CURRENT_LIST_DIR}/meta")
 add_flecs_test("${CMAKE_CURRENT_LIST_DIR}/collections")
-add_flecs_test("${CMAKE_CURRENT_LIST_DIR}/cpp_api")
+add_flecs_test("${CMAKE_CURRENT_LIST_DIR}/cpp")
diff --git a/test/addons/include/addons.h b/test/addons/include/addons.h
index e6fbcb805..7a4754ed9 100644
--- a/test/addons/include/addons.h
+++ b/test/addons/include/addons.h
@@ -75,35 +75,6 @@ void probe_has_entity(Probe *probe, ecs_entity_t e);
 
 void install_test_abort(void);
 
-#define ITER_MAX_ENTITIES (64)
-#define ITER_MAX_TERMS (16)
-#define ITER_MAX_VARIABLES (16)
-
-typedef struct test_iter_result_t {
-    ecs_entity_t entities[ITER_MAX_ENTITIES];
-    ecs_id_t term_ids[ITER_MAX_ENTITIES][ITER_MAX_TERMS];
-    void *term_columns[ITER_MAX_TERMS];
-    
-    int32_t table_count_expect;
-    int32_t table_count_actual;
-
-    char *entity_names[ITER_MAX_ENTITIES];
-    char *term_ids_expr[ITER_MAX_ENTITIES][ITER_MAX_TERMS];
-    int32_t matched[ITER_MAX_ENTITIES];
-
-    struct {
-        int32_t id;
-        ecs_entity_t entities[ITER_MAX_ENTITIES];
-        char *entity_names[ITER_MAX_ENTITIES];
-    } variables[ITER_MAX_VARIABLES];
-} test_iter_result_t;
-
-// Utility for doing order-independent validation of iterator output
-bool test_iter(
-    ecs_iter_t *it, 
-    ecs_iter_next_action_t next, 
-    test_iter_result_t *expect);
-
 const ecs_entity_t* bulk_new_w_type(
     ecs_world_t *world, ecs_entity_t type_ent, int32_t count);
 
diff --git a/test/addons/project.json b/test/addons/project.json
index 55a1d5668..b2e63252c 100644
--- a/test/addons/project.json
+++ b/test/addons/project.json
@@ -5,519 +5,12 @@
         "author": "Sander Mertens",
         "description": "Test project for flecs addons",
         "public": false,
-        "coverage": false,
         "use": [
             "flecs"
         ]
     },
     "test": {
         "testsuites": [{
-            "id": "Parser",
-            "testcases": [
-                "resolve_this",
-                "resolve_wildcard",
-                "resolve_any",
-                "resolve_is_a",
-                "0",
-                "component_implicit_subject",
-                "component_explicit_subject",
-                "component_explicit_subject_this",
-                "component_explicit_subject_this_by_name",
-                "component_explicit_subject_this_by_var_name",
-                "component_explicit_subject_wildcard",
-                "component_explicit_subject_any",
-                "component_explicit_subject_0",
-                "this_as_predicate",
-                "this_var_as_predicate",
-                "this_lowercase_var_as_predicate",
-                "this_as_object",
-                "this_var_as_object",
-                "pair_implicit_subject",
-                "pair_implicit_subject_wildcard_pred",
-                "pair_implicit_subject_wildcard_obj",
-                "pair_implicit_subject_any_pred",
-                "pair_implicit_subject_any_obj",
-                "pair_implicit_subject_this_pred",
-                "pair_implicit_subject_this_obj",
-                "pair_implicit_subject_pred_w_self",
-                "pair_implicit_subject_obj_w_self",
-                "pair_implicit_subject_pred_w_up",
-                "pair_implicit_subject_obj_w_up",
-                "pair_implicit_subject_pred_w_self_up",
-                "pair_implicit_subject_obj_w_self_up",
-                "pair_implicit_subject_pred_w_up_trav",
-                "pair_implicit_subject_obj_w_up_trav",
-                "pair_implicit_subject_pred_w_invalid_flags",
-                "pair_implicit_subject_obj_w_invalid_flags",
-                "pair_explicit_subject",
-                "pair_explicit_subject_this",
-                "pair_explicit_subject_this_by_name",
-                "pair_explicit_subject_this_by_var_name",
-                "pair_explicit_subject_wildcard_pred",
-                "pair_explicit_subject_wildcard_subj",
-                "pair_explicit_subject_wildcard_obj",
-                "pair_implicit_subject_0_object",
-                "pair_explicit_subject_0_object",
-                "pair_explicit_subject_0",
-                "in_component_implicit_subject",
-                "in_component_explicit_subject",
-                "in_pair_implicit_subject",
-                "in_pair_explicit_subject",
-                "inout_component_implicit_subject",
-                "inout_component_explicit_subject",
-                "inout_pair_implicit_subject",
-                "inout_pair_explicit_subject",   
-                "out_component_implicit_subject",
-                "out_component_explicit_subject",
-                "out_pair_implicit_subject",
-                "out_pair_explicit_subject",
-                "inout_filter_component",
-                "component_singleton",
-                "this_singleton",
-                "component_implicit_no_subject",
-                "component_explicit_no_subject",
-                "pair_no_subject",
-                "variable_single_char",
-                "variable_multi_char",
-                "variable_multi_char_w_underscore",
-                "variable_multi_char_w_number",
-                "variable_multi_char_not_allcaps",
-                "pred_var",
-                "obj_var",
-                "component_not",
-                "pair_implicit_subject_not",
-                "pair_explicit_subject_not",
-                "2_component_not",
-                "2_component_not_no_space",
-                "component_optional",
-                "2_component_optional",
-                "2_component_optional_no_space",
-                "from_and",
-                "from_or",
-                "from_not",
-                "pair_implicit_subject_optional",
-                "pair_explicit_subject_optional",                
-                "pred_implicit_subject_w_role",
-                "pred_explicit_subject_w_role",
-                "pred_no_subject_w_role",
-                "pair_implicit_subject_w_role",
-                "pair_explicit_subject_w_role",
-                "inout_role_pred_implicit_subject",
-                "inout_role_pred_no_subject",
-                "inout_role_pred_explicit_subject",
-                "inout_role_pair_implicit_subject",
-                "inout_role_pair_explicit_subject",
-                "2_pred_implicit_subject",
-                "2_pred_no_subject",
-                "2_pred_explicit_subject",
-                "2_pair_implicit_subject",
-                "2_pair_explicit_subject",
-                "2_pred_role",
-                "2_pair_implicit_subj_role",
-                "2_pair_explicit_subj_role",
-                "2_or_pred_implicit_subj",
-                "2_or_pred_explicit_subj",
-                "2_or_pair_implicit_subj",
-                "2_or_pair_explicit_subj",
-                "2_or_pred_inout",
-                "1_digit_pred_implicit_subj",
-                "1_digit_pred_no_subj",
-                "1_digit_pred_explicit_subj",
-                "1_digit_pair_implicit_subj",
-                "1_digit_pair_explicit_subj",
-                "pred_implicit_subject_self",
-                "pred_implicit_subject_superset",
-                "pred_implicit_subject_subset",
-                "pred_implicit_subject_superset_inclusive",
-                "pred_implicit_subject_subset_inclusive",
-                "pred_implicit_subject_superset_cascade",
-                "pred_implicit_subject_subset_cascade",
-                "pred_implicit_subject_superset_inclusive_cascade",
-                "pred_implicit_subject_subset_inclusive_cascade",
-                "pred_implicit_subject_implicit_superset_cascade",         
-                "pred_implicit_subject_implicit_superset_inclusive_cascade",
-                "pred_implicit_subject_implicit_superset_cascade_w_rel",         
-                "pred_implicit_subject_implicit_superset_inclusive_cascade_w_rel",
-                "pred_implicit_subject_superset_childof",
-                "pred_implicit_subject_cascade_superset_childof",
-                "pred_implicit_subject_superset_cascade_childof",
-                "pred_implicit_subject_superset_cascade_childof_optional",
-                "expr_w_symbol",
-                "expr_w_newline",
-                "subj_entity_w_explicit_self",
-                "subj_entity_w_explicit_self_superset",
-                "subj_entity_w_explicit_superset_relation",
-                "subj_entity_w_explicit_self_superset_relation",
-                "obj_entity_w_explicit_self",
-                "obj_entity_w_explicit_self_superset",
-                "obj_entity_w_explicit_superset_relation",
-                "obj_entity_w_explicit_self_superset_relation",
-                "pred_entity_w_explicit_self",
-                "pred_entity_w_explicit_self_superset",
-                "pred_entity_w_explicit_superset_relation",
-                "pred_entity_w_explicit_self_superset_relation",
-                "pred_entity_no_args_w_explicit_self",
-                "pred_entity_no_args_w_explicit_self_superset",
-                "pred_entity_no_args_w_explicit_superset_relation",
-                "pred_entity_no_args_w_explicit_self_superset_relation",
-                "pred_entity_no_args_2_terms_w_explicit_self",
-                "pred_entity_no_args_2_terms_w_explicit_self_superset",
-                "pred_entity_no_args_2_terms_w_explicit_superset_relation",
-                "pred_entity_no_args_2_terms_w_explicit_self_superset_relation",
-                "newline",
-                "2_newlines",
-                "3_newlines",
-                "space",
-                "2_spaces",
-                "trailing_newline",
-                "2_trailing_newlines",
-                "trailing_space",
-                "2_trailing_spaces",
-                "template_type",
-                "predicate_w_parens",
-                "not_alive_pred",
-                "not_alive_subj",
-                "not_alive_obj",
-                "this_subj_var_kind",
-                "this_obj_var_kind",
-                "this_subj_obj_var_kind",
-                "var_w_name",
-                "entity_pred_no_name",
-                "entity_subj_no_name",
-                "entity_obj_no_name",
-                "this_pred_no_name",
-                "this_subj_no_name",
-                "this_obj_no_name",
-                "auto_object_variable",
-                "auto_object_variable_w_subj",
-                "auto_scoped_variable",
-                "invalid_variable_only",
-                "oneof_self_pred_w_relative_obj",
-                "oneof_other_pred_w_relative_obj",
-                "oneof_self_pred_w_invalid_obj",
-                "oneof_other_pred_w_invalid_obj",
-                "oneof_w_other_entity_w_same_name",
-                "oneof_w_other_entity_w_same_name_w_set_scope",
-                "oneof_w_wildcard",
-                "oneof_w_any",
-                "oneof_w_fullpath",
-                "pair_implicit_src_missing_rel",
-                "pair_implicit_src_missing_obj",
-                "pair_explicit_src_missing_src",
-                "pair_explicit_src_missing_obj",
-                "eq_id",
-                "eq_id_var",
-                "eq_var_id",
-                "eq_var",
-                "neq_id",
-                "neq_id_var",
-                "neq_var_id",
-                "neq_var",
-                "eq_name",
-                "eq_name_var",
-                "eq_var_name",
-                "eq_var",
-                "neq_name",
-                "neq_name_var",
-                "neq_var_name",
-                "neq_var",
-                "match_name",
-                "match_name_var",
-                "match_var_name",
-                "match_var",
-                "nmatch_name",
-                "nmatch_name_var",
-                "nmatch_var_name",
-                "eq_same_var",
-                "neq_same_var",
-                "eq_same_var_this",
-                "neq_same_var_this",
-                "eq_w_optional",
-                "neq_w_optional",
-                "match_w_optional",
-                "query_scope_1_term",
-                "query_scope_1_term_spaces",
-                "query_scope_2_terms",
-                "query_nested_scope",
-                "query_nested_scope_spaces",
-                "query_scope_unbalanced",
-                "query_not_scope",
-                "query_empty_scope",
-                "query_scope_newline_after_open",
-                "query_scope_newline_after_close",
-                "override_tag",
-                "override_pair",
-                "pair_3_args",
-                "pair_3_args_implicit_this",
-                "pair_4_args",
-                "pair_4_args_implicit_this",
-                "pair_3_args_2_terms",
-                "pair_3_args_this_tgt",
-                "pair_3_args_2_terms_this_tgt",
-                "pair_3_args_2_terms_this_tgt_implicit_this",
-                "pair_3_or_args",
-                "pair_3_or_args_implicit_this",
-                "pair_4_or_args",
-                "pair_4_or_args_implicit_this",
-                "pair_or_before_and_oper",
-                "pair_and_before_or_oper",
-                "cascade_desc",
-                "newline_after_inout",
-                "newline_after_term_open",
-                "newline_after_term_src",
-                "newline_after_term_src_pair",
-                "newline_after_term_pair_comma",
-                "newline_after_term_pair_second",
-                "tag_w_space_implicit_this",
-                "tag_w_space",
-                "pair_first_w_space_implicit_this",
-                "pair_first_w_space",
-                "pair_second_w_space_implicit_this",
-                "pair_second_w_space",
-                "pair_src_w_space"
-            ]
-        }, {
-            "id": "Plecs",
-            "testcases": [
-                "null",
-                "empty",
-                "space",
-                "space_newline",
-                "two_empty_newlines",
-                "three_empty_newlines",
-                "newline_trailing_space",
-                "newline_trailing_spaces",
-                "multiple_trailing_newlines",
-                "entity",
-                "entity_w_entity",
-                "entity_w_pair",
-                "2_entities",
-                "2_entities_w_entities",
-                "3_entities_w_pairs",
-                "line_comment",
-                "line_comment_before_stmt",
-                "line_comment_after_stmt",
-                "line_comment_between_stmt",
-                "multiple_line_comment",
-                "line_comment_after_stmt_same_line",
-                "comma_separated_pred",
-                "comma_separated_pred_w_subj",
-                "comma_separated_pred_w_subj_obj",
-                "comma_separated_pred_trailing_comma",
-                "comma_separated_pred_trailing_comma_newline",
-                "comma_separated_pred_trailing_comma_newline_multiline",
-                "hierarchy_1_child",
-                "hierarchy_2_children",
-                "hierarchy_1_child_same_line",
-                "hierarchy_2_children_same_line",
-                "entity_after_hierarchy",
-                "newline_before_scope_open",
-                "comment_before_scope_open",
-                "comment_after_newline_before_scope_open",
-                "hierarchy_2_levels",
-                "hierarchy_2_levels_2_subtrees",
-                "missing_end_of_scope",
-                "missing_end_of_predicate_scope",
-                "create_in_scope",
-                "hierarchy_w_pred_subj",
-                "hierarchy_custom_relation",
-                "hierarchy_custom_relation_2_levels",
-                "hierarchy_custom_relation_apply_to_object",
-                "hierarchy_custom_relation_apply_to_object_2_levels",
-                "entity_after_hierarchy_custom_relation",
-                "entity_after_hierarchy_custom_relation_2_levels",
-                "pred_scope",
-                "pred_scope_2_levels",
-                "pred_scope_inside_with",
-                "pred_scope_nested_w_subj_scope",
-                "with_tag",
-                "with_tag_2_entities",
-                "with_tag_same_line",
-                "with_tag_2_entities_same_line",
-                "with_tag_2_levels",
-                "with_tag_2_levels_2_subtrees",
-                "with_n_tags",
-                "with_n_tags_2_levels",
-                "with_after_scope",
-                "with_after_with",
-                "scope_inside_with_inside_scope",
-                "with_inside_scope",
-                "assignment_w_1",
-                "assignment_w_2",
-                "assignment_w_pair",
-                "assignment_w_invalid_subject",
-                "assignment_w_invalid_with",
-                "inherit_w_colon",
-                "inherit_w_colon_w_scope",
-                "inherit_w_colon_w_assign",
-                "assign_component_value",
-                "assign_2_component_values",
-                "assign_component_value_in_assign_scope",
-                "assign_2_component_values_in_assign_scope",
-                "type_and_assign_in_plecs",
-                "type_and_assign_in_plecs_w_2_members",
-                "type_and_assign_in_plecs_w_3_members",
-                "type_and_assign_in_plecs_w_enum",
-                "type_and_assign_in_plecs_w_enum_using_meta",
-                "type_and_assign_in_plecs_w_enum_primitive_using_meta",
-                "type_and_assign_in_plecs_w_enum_primitive_and_struct",
-                "type_and_assign_in_plecs_nested_member",
-                "dot_assign_nested_member",
-                "dot_assign_binary_expr",
-                "open_scope_no_parent",
-                "create_subject_in_root_scope_w_resolvable_id",
-                "create_subject_in_scope_w_resolvable_id",
-                "create_subject_in_scope_w_resolvable_id_using",
-                "using_scope",
-                "using_nested_scope",
-                "using_nested_in_scope",
-                "using_with_scope",
-                "using_w_entity_ref_in_value_2_members",
-                "using_w_entity_ref_in_value_3_members",
-                "2_using_scope",
-                "2_using_in_different_scope",
-                "empty_scope_after_using",
-                "assignment_to_non_component",
-                "struct_w_member_w_assignment_to_nothing",
-                "struct_w_member_w_assignment_to_empty_scope",
-                "scope_after_assign",
-                "assign_after_inherit",
-                "multiple_assignments_single_line",
-                "2_stmts_in_scope_w_no_parent",
-                "scope_after_assign_1_tag",
-                "scope_after_assign_2_tags",
-                "invalid_nested_assignment",
-                "invalid_partial_pair_assignment",
-                "empty_assignment",
-                "assign_tag_to_parent",
-                "assign_component_to_parent",
-                "empty_assignment_before_end_of_scope",
-                "assign_to_parent_pair_w_new_entities_in_scope",
-                "assign_to_parent_pair_w_existing_entities_in_scope",
-                "default_child_component",
-                "default_child_component_w_assign",
-                "struct_type_w_default_child_component",
-                "struct_type_w_default_child_component_nested_member",
-                "enum_type_w_default_child_component",
-                "default_type_from_with",
-                "scope_w_1_subj_and_2_pairs",
-                "inherit_from_multiple",
-                "assign_pair_component",
-                "assign_pair_component_in_scope",
-                "assign_pair_component_in_script",
-                "assign_pair_component_in_script_update",
-                "set_entity_names",
-                "oneof",
-                "invalid_oneof",
-                "brief_annotation",
-                "name_annotation",
-                "link_annotation",
-                "color_annotation",
-                "multiple_annotations",
-                "annotation_w_trailing_space",
-                "multiline_string",
-                "unterminated_multiline_string",
-                "declaration_w_underscore_name",
-                "annotate_declaration",
-                "anonymous_entity",
-                "anonymous_entity_in_scope",
-                "anonymous_declaration",
-                "const_var_int",
-                "const_var_float",
-                "const_var_bool",
-                "const_var_string",
-                "const_var_struct",
-                "const_var_redeclare",
-                "const_var_scoped",
-                "assign_component_from_var",
-                "assign_component_from_var_in_scope",
-                "scope_w_component_after_const_var",
-                "component_after_const_paren_expr",
-                "component_after_const_add_expr",
-                "component_after_const_sub_expr",
-                "component_after_const_mul_expr",
-                "component_after_const_div_expr",
-                "parse_with",
-                "parse_with_w_with",
-                "parse_with_w_tag",
-                "parse_with_value",
-                "parse_with_2_values",
-                "parse_with_2_nested_values",
-                "parse_with_var",
-                "parse_with_2_vars",
-                "parse_with_2_nested_vars",
-                "parse_with_var_in_scope",
-                "assign_const_w_expr",
-                "const_w_type",
-                "assembly_no_scope",
-                "assembly_empty",
-                "assembly_no_props",
-                "assembly_prop_no_type",
-                "assembly_prop_no_default",
-                "assembly_prop",
-                "assembly_prop_space_colon",
-                "assembly_2_props",
-                "assembly_instance_w_default_values",
-                "assembly_instance_w_assign_default_values",
-                "assembly_instance_w_overridden_values",
-                "assembly_w_child",
-                "assembly_w_child_parse_script",
-                "assembly_w_child_parse_script_twice",
-                "assembly_w_child_update_after_parse",
-                "assembly_w_nested_child",
-                "assembly_w_prefab",
-                "assembly_w_prefab_tree",
-                "assembly_w_nested_assembly",
-                "instantiate_prefab_w_assembly",
-                "assembly_w_prefab_w_assembly",
-                "3_assemblies",
-                "assembly_nested_w_default_var",
-                "assembly_w_anonymous",
-                "assembly_w_anonymous_parse_again",
-                "typed_const_w_composite_type_invalid_assignment",
-                "typed_const_w_composite_type",
-                "assign_var_to_typed_const_w_composite_type",
-                "typed_const_w_composite_type_invalid_assignment",
-                "assembly_w_composite_prop_invalid_assignment",
-                "assembly_w_composite_prop",
-                "assembly_with_with",
-                "using_wildcard",
-                "single_line_comment_in_value",
-                "single_line_comment_in_value_after_scope",
-                "multi_line_comment_in_value",
-                "multi_line_comment_in_value_after_scope",
-                "unterminated_multi_line_comment_in_value",
-                "module_stmt",
-                "nested_module_stmt",
-                "module_stmt_w_scope",
-                "module_stmt_w_nested_scope",
-                "module_w_assembly",
-                "module_w_nested_assembly",
-                "assign_singleton_tag",
-                "assign_singleton_component",
-                "assign_singleton_tag_w_scope",
-                "assign_singleton_2_tags_w_scope",
-                "assign_singleton_component_w_scope",
-                "assign_singleton_2_components_w_scope",
-                "with_pair_in_scope",
-                "assembly_redeclare_prop_as_const",
-                "assembly_redeclare_prop_as_prop",
-                "assembly_redeclare_const_as_const",
-                "add_auto_override",
-                "add_auto_override_pair",
-                "scope_w_auto_override",
-                "scope_w_auto_override_pair",
-                "pair_w_rel_var",
-                "pair_w_tgt_var",
-                "assembly_w_pair_w_this_var",
-                "with_value_not_a_component",
-                "component_in_with_scope",
-                "component_in_with_scope_nested",
-                "component_in_with_scope_in_scope",
-                "assign_after_with_in_scope",
-                "array_component"
-            ]
-        }, {
             "id": "Doc",
             "testcases": [
                 "get_set_name",
@@ -623,7 +116,6 @@
                 "invalid_not_without_id",
                 "invalid_optional_without_id",
                 "invalid_entity_without_id",
-                "invalid_empty_without_id",
                 "invalid_empty_element",
                 "invalid_empty_element_w_space",
                 "invalid_empty_or",
@@ -644,7 +136,6 @@
                 "table_columns_access",
                 "dont_enable_after_rematch",
                 "ensure_single_merge",
-                "table_count",
                 "match_system",
                 "system_initial_state",
                 "add_own_component",
@@ -654,8 +145,6 @@
                 "add_to_system_in_progress",
                 "redefine_null_signature",
                 "redefine_0_signature",
-                "one_named_column_of_two",
-                "two_named_columns_of_two",
                 "redeclare_system_explicit_id",
                 "redeclare_system_explicit_id_null_expr",
                 "redeclare_system_explicit_id_no_name",
@@ -679,7 +168,6 @@
                 "delete_system_w_ctx",
                 "update_ctx",
                 "run_custom_run_action",
-                "run_w_offset_limit_custom_run_action",
                 "pipeline_custom_run_action",
                 "change_custom_run_action",
                 "custom_run_action_call_next",
@@ -687,758 +175,8 @@
                 "update_interval_w_system_init",
                 "update_rate_w_system_init",
                 "system_w_interval_rate_stop_timer",
-                "system_same_interval_same_tick"
-            ]
-        }, {
-            "id": "RulesBasic",
-            "testcases": [
-                "1_fact_w_tag",
-                "1_fact_w_component",
-                "1_fact_w_tag_pair",
-                "1_fact_w_component_pair",
-                "2_facts_same_src_w_tag",
-                "2_facts_same_src_w_component",
-                "2_facts_same_src_w_tag_pair",
-                "2_facts_same_src_w_component_pair",
-                "2_facts_other_src_w_tag",
-                "2_facts_other_src_w_component",
-                "2_facts_other_src_w_tag_pair",
-                "2_facts_other_src_w_component_pair",
-                "1_fact_w_any",
-                "1_fact_w_pair_any_tgt",
-                "1_fact_w_pair_any_rel",
-                "1_fact_w_pair_any_rel_tgt",
-                "2_facts_same_src_w_any",
-                "2_facts_same_src_w_pair_any_tgt",
-                "2_facts_same_src_w_pair_any_rel",
-                "2_facts_same_src_w_pair_any_rel_tgt",
-                "2_facts_other_src_w_any",
-                "2_facts_other_src_w_pair_any_tgt",
-                "2_facts_other_src_w_pair_any_rel",
-                "2_facts_other_src_w_pair_any_rel_tgt",
-                "1_this_src_w_tag",
-                "1_this_src_w_component",
-                "1_this_src_w_tag_pair",
-                "1_this_src_w_component_pair",
-                "1_this_src_w_tag_2_tables",
-                "1_this_src_w_component_2_tables",
-                "1_this_src_w_tag_pair_2_tables",
-                "1_this_src_w_component_pair_2_tables",
-                "2_this_src_w_tag",
-                "2_this_src_w_component",
-                "2_this_src_ent_src_w_tag",
-                "2_this_src_ent_src_w_component",
-                "2_ent_src_this_src_w_tag",
-                "2_ent_src_this_src_w_component",
-                "recycled_tag",
-                "recycled_src",
-                "recycled_pair_rel",
-                "recycled_pair_tgt",
-                "this_src_w_wildcard",
-                "this_src_w_pair_rel_wildcard",
-                "this_src_w_pair_tgt_wildcard",
-                "this_src_w_pair_rel_tgt_wildcard",
-                "this_src_w_any",
-                "this_src_w_any_written",
-                "this_src_w_pair_rel_any",
-                "this_src_w_pair_tgt_any",
-                "this_src_w_pair_rel_tgt_any",
-                "ent_src_w_wildcard",
-                "ent_src_w_pair_rel_wildcard",
-                "ent_src_w_pair_tgt_wildcard",
-                "ent_src_w_pair_rel_tgt_wildcard",
-                "1_wildcard_src",
-                "1_wildcard_src_w_pair",
-                "2_wildcard_src",
-                "2_wildcard_src_w_pair",
-                "1_wildcard_src_w_pair_tgt_var",
-                "1_wildcard_src_w_pair_rel_var",
-                "1_wildcard_src_w_pair_tgt_this",
-                "1_wildcard_src_w_pair_rel_this",
-                "1_any_src",
-                "1_any_src_component",
-                "1_any_src_component_w_this_component",
-                "1_any_src_w_pair",
-                "2_any_src",
-                "2_any_src_w_pair",
-                "1_any_src_w_pair_tgt_var",
-                "1_any_src_w_pair_rel_var",
-                "1_any_src_w_pair_tgt_this",
-                "1_any_src_w_pair_rel_this",
-                "1_any_src_any_tgt_w_rel_fixed",
-                "1_any_src_any_rel_w_tgt_fixed",
-                "1_any_src_w_childof_pair_any_tgt",
-                "1_any_src_empty",
-                "1_any_src_pair_tgt_wildcard_empty",
-                "1_any_src_pair_rel_wildcard_empty",
-                "1_any_src_any_tgt_w_rel_fixed_empty",
-                "1_any_src_any_rel_w_tgt_fixed_empty",
-                "1_any_src_pair_w_tag_query_empty",
-                "1_any_src_tag_w_pair_query_empty",
-                "not_any",
-                "rule_w_iter_next",
-                "empty_rule",
-                "invalid_rule",
-                "not_instanced_table_src",
-                "not_instanced_entity_src",
-                "not_instanced_mixed_src",
-                "instanced_table_src",
-                "instanced_entity_src",
-                "instanced_mixed_src",
-                "in_term",
-                "out_term",
-                "inout_term",
-                "nodata_term",
-                "find_this_lowercase",
-                "find_this_uppercase",
-                "find_this_tgt_lowercase",
-                "find_this_tgt_uppercase",
-                "get_filter",
-                "iter_empty_source",
-                "iter_empty_source_2_terms",
-                "iter_empty_source_wildcard",
-                "iter_empty_source_pair",
-                "iter_empty_source_pair_wildcard",
-                "iter_empty_source_2_terms_pair",
-                "iter_empty_source_2_terms_mixed",
-                "iter_empty_source_2_terms_mixed_pair",
-                "iter_empty_source_2_terms_mixed_pair_wildcard",
-                "this_var_w_empty_entity",
-                "match_disabled",
-                "match_prefab",
-                "match_disabled_prefab",
-                "match_disabled_this_tgt",
-                "match_prefab_this_tgt",
-                "match_disabled_prefab_this_tgt",
-                "match_self_disabled",
-                "match_self_prefab",
-                "match_self_disabled_prefab",
-                "inout_none_first_term",
-                "inout_none_second_term",
-                "no_data_rule",
-                "frame_offset",
-                "frame_offset_no_data",
-                "match_empty_tables",
-                "match_empty_tables_no_data",
-                "match_empty_tables_w_not",
-                "match_empty_tables_w_wildcard",
-                "match_empty_tables_w_no_empty_tables",
-                "match_empty_tables_trivial",
-                "oneof_wildcard",
-                "oneof_any",
-                "instanced_w_singleton",
-                "instanced_w_base",
-                "not_instanced_w_singleton",
-                "not_instanced_w_base",
-                "unknown_before_known",
-                "unknown_before_known_after_or",
-                "unknown_before_known_after_not",
-                "unknown_before_known_after_optional",
-                "unknown_before_known_after_scope",
-                "reordered_plan_1",
-                "reordered_plan_2",
-                "1_trivial_plan",
-                "2_trivial_plan",
-                "1_trivial_plan_component",
-                "2_trivial_plan_component",
-                "2_trivial_plan_w_wildcard",
-                "3_trivial_plan_w_pair",
-                "3_trivial_plan_w_wildcard",
-                "3_trivial_plan_w_any",
-                "3_trivial_plan_w_pair_component",
-                "3_trivial_plan_w_wildcard_component",
-                "3_trivial_plan_w_any_component",
-                "1_trivial_component_w_none",
-                "2_trivial_component_w_none",
-                "2_trivial_mixed_2_tables",
-                "2_trivial_mixed_2_tables_component",
-                "2_trivial_mixed_2_tables_wildcard",
-                "1_plan_any_src",
-                "1_plan_not_any_src",
-                "1_plan_optional_any_src"
-            ]
-        }, {
-            "id": "RulesVariables",
-            "testcases": [
-                "1_ent_src_w_var",
-                "1_ent_src_w_pair_rel_var",
-                "1_ent_src_w_pair_tgt_var",
-                "1_ent_src_w_pair_rel_tgt_var",
-                "1_ent_src_w_pair_rel_tgt_same_var",
-                "1_ent_src_w_pair_rel_tgt_same_var_after_write",
-                "1_this_src_w_var",
-                "1_this_src_w_pair_rel_var",
-                "1_this_src_w_pair_tgt_var",
-                "1_this_src_w_pair_rel_tgt_var",
-                "1_this_src_w_pair_rel_tgt_same_var",
-                "1_this_src_w_pair_rel_tgt_same_var_after_write",
-                "1_src_id_same_var",
-                "1_src_pair_first_same_var",
-                "1_src_pair_second_same_var",
-                "1_src_pair_first_and_second_same_var",
-                "1_src_id_same_var_after_write",
-                "1_src_pair_first_same_var_after_write",
-                "1_src_pair_second_same_var_after_write",
-                "1_src_pair_first_and_second_same_var_after_write",
-                "1_src_pair_first_same_var_this",
-                "1_src_pair_second_same_var_this",
-                "1_src_pair_first_and_second_same_var_this",
-                "1_src_id_same_var_this_after_write",
-                "1_src_pair_first_same_var_this_after_write",
-                "1_src_pair_second_same_var_this_after_write",
-                "1_src_pair_first_and_second_same_var_this_after_write",
-                "1_ent_src_w_this_var",
-                "1_ent_src_w_pair_this_rel",
-                "1_ent_src_w_pair_this_tgt",
-                "1_ent_src_w_pair_this_rel_tgt",
-                "1_this_src_w_this",
-                "1_this_src_w_pair_this_rel_tgt",
-                "1_this_src_w_this_after_write",
-                "1_this_src_w_pair_this_rel_tgt_after_write",
-                "2_constrain_src_from_src",
-                "2_constrain_rel_from_src_w_ent",
-                "2_constrain_rel_from_src_w_var",
-                "2_constrain_rel_from_src_w_this",
-                "2_constrain_pair_rel_from_src_w_ent",
-                "2_constrain_pair_rel_from_src_w_var",
-                "2_constrain_pair_rel_from_src_w_this",
-                "2_constrain_pair_tgt_from_src_w_ent",
-                "2_constrain_pair_tgt_from_src_w_var",
-                "2_constrain_pair_tgt_from_src_w_this",
-                "2_constrain_pair_rel_tgt_from_src_w_ent",
-                "2_constrain_pair_rel_tgt_from_src_w_var",
-                "2_constrain_pair_rel_tgt_from_src_w_this",
-                "1_ent_src_set_rel_var",
-                "1_ent_src_set_pair_rel_var",
-                "1_ent_src_set_pair_tgt_var",
-                "1_set_src_var",
-                "1_set_src_var_w_pair",
-                "1_set_src_var_w_pair_set_rel",
-                "1_set_src_var_w_pair_set_tgt",
-                "1_set_src_var_w_pair_set_rel_tgt",
-                "1_set_src_this",
-                "1_set_src_this_w_pair",
-                "1_set_src_this_w_pair_set_rel",
-                "1_set_src_this_w_pair_set_tgt",
-                "1_set_src_this_w_pair_set_rel_tgt",
-                "1_set_src_this_to_empty_table",
-                "1_set_src_this_to_empty_table_w_component",
-                "1_set_src_this_to_empty_table_w_component_self",
-                "1_set_src_this_to_entiy_in_table",
-                "1_set_src_this_to_entiy_in_table_self",
-                "2_set_src_this",
-                "2_set_src_this_self",
-                "2_set_src_this_component",
-                "2_set_src_this_self_component",
-                "2_set_src_this_w_up",
-                "2_set_src_this_self_w_up",
-                "2_set_src_this_component_w_up",
-                "2_set_src_this_self_component_w_up",
-                "2_set_src_this_w_exclusive_wildcard",
-                "2_set_src_this_self_w_exclusive_wildcard",
-                "1_src_this_var_as_entity",
-                "1_src_this_var_as_table",
-                "1_src_this_var_as_table_range",
-                "2_join_by_rel_var",
-                "2_join_by_pair_rel_var",
-                "2_join_by_pair_tgt_var",
-                "2_cycle_w_var",
-                "2_cycle_w_this_var",
-                "2_cycle_w_var_this",
-                "2_cycle_pair_w_var",
-                "2_cycle_pair_w_this_var_var",
-                "2_cycle_pair_w_var_this_var",
-                "2_cycle_pair_w_var_var_this",
-                "2_cycle_pair_ent_var_var",
-                "2_cycle_pair_ent_this_var",
-                "2_cycle_pair_ent_var_this",
-                "parse_0_var",
-                "parse_1_var",
-                "parse_2_vars",
-                "parse_0_var_paren",
-                "parse_1_var_paren",
-                "parse_2_vars_paren",
-                "parse_1_vars_w_path",
-                "parse_missing_close_paren",
-                "parse_missing_open_paren",
-                "parse_missing_value",
-                "parse_0_var_w_spaces",
-                "parse_1_var_w_spaces",
-                "parse_2_vars_w_spaces",
-                "parse_0_var_paren_w_spaces",
-                "parse_1_var_paren_w_spaces",
-                "parse_2_vars_paren_w_spaces",
-                "var_count",
-                "var_name",
-                "var_is_entity",
-                "no_this_anonymous_src",
-                "no_this_anonymous_src_w_pair",
-                "no_this_anonymous_component_src",
-                "no_this_anonymous_component_src_w_pair",
-                "lookup_from_table_this",
-                "lookup_from_entity_this",
-                "lookup_from_table",
-                "lookup_from_entity",
-                "lookup_from_not_written",
-                "lookup_from_table_this_component",
-                "lookup_from_entity_this_component",
-                "lookup_from_table_component",
-                "lookup_from_entity_component",
-                "lookup_from_table_two_children",
-                "lookup_from_entity_two_children",
-                "lookup_from_table_same_child_twice",
-                "lookup_from_entity_same_child_twice",
-                "lookup_from_table_not",
-                "lookup_from_entity_not",
-                "lookup_from_table_w_any_component",
-                "lookup_from_entity_w_any_component",
-                "lookup_as_tag",
-                "lookup_as_relationship",
-                "lookup_as_target",
-                "lookup_assign_var",
-                "lookup_eq_var",
-                "lookup_neq_var",
-                "lookup_unresolved_dependent",
-                "check_vars_this",
-                "check_vars_var",
-                "check_vars_wildcard",
-                "check_vars_any",
-                "check_vars_var_as_tgt",
-                "check_vars_this_as_tgt",
-                "check_vars_anonymous_var_as_tgt",
-                "check_vars_wildcard_as_tgt",
-                "check_vars_any_as_tgt",
-                "check_vars_this_w_lookup_var",
-                "check_vars_var_w_lookup_var",
-                "1_trivial_1_var",
-                "2_trivial_1_var",
-                "1_trivial_1_var_component",
-                "2_trivial_1_var_component",
-                "1_trivial_1_wildcard",
-                "2_trivial_1_wildcard",
-                "1_trivial_1_wildcard_component",
-                "2_trivial_1_wildcard_component",
-                "1_trivial_1_any",
-                "2_trivial_1_any",
-                "1_trivial_1_any_component",
-                "2_trivial_1_any_component"
-            ]
-        }, {
-            "id": "RulesOperators",
-            "testcases": [
-                "2_and_not",
-                "3_and_not_not",
-                "2_and_not_pair_rel_wildcard",
-                "2_and_not_pair_tgt_wildcard",
-                "2_and_not_pair_rel_tgt_wildcard",
-                "2_and_not_pair_rel_var",
-                "2_and_not_pair_tgt_var",
-                "2_and_not_pair_rel_tgt_var",
-                "2_and_not_pair_rel_tgt_same_var",
-                "2_and_not_pair_rel_var_written",
-                "2_and_not_pair_tgt_var_written",
-                "2_and_not_pair_rel_tgt_var_written",
-                "2_and_not_pair_rel_tgt_same_var_written",
-                "2_and_not_pair_rel_src_tgt_same_var_written",
-                "2_and_not_pair_any_rel",
-                "2_and_not_pair_any_tgt",
-                "2_and_not_pair_any_src",
-                "1_not_any_src_fixed_first",
-                "1_not_any_src_any_tgt_fixed_first",
-                "1_not_any_src_any_first_fixed_tgt",
-                "1_not_any_src_any_childof_pair_any_tgt",
-                "1_not_any_src_any_isa_pair_any_tgt",
-                "2_and_optional",
-                "3_and_optional_optional",
-                "2_and_optional_pair_rel_wildcard",
-                "2_and_optional_pair_tgt_wildcard",
-                "2_and_optional_pair_rel_var",
-                "2_and_optional_pair_tgt_var",
-                "2_and_optional_pair_rel_tgt_var",
-                "2_and_optional_pair_rel_tgt_same_var",
-                "2_and_optional_pair_rel_var_written",
-                "2_and_optional_pair_tgt_var_written",
-                "2_and_optional_pair_rel_tgt_var_written",
-                "2_and_optional_pair_rel_tgt_same_var_written",
-                "2_and_optional_pair_rel_src_tgt_same_var_written",
-                "3_and_optional_optional_pair_w_var",
-                "2_and_optional_pair_any_rel",
-                "2_and_optional_pair_any_tgt",
-                "2_and_optional_pair_any_src",
-                "3_and_optional_dependent_and_pair_rel",
-                "3_and_optional_dependent_and_pair_tgt",
-                "3_and_optional_dependent_and_pair_rel_tgt",
-                "3_and_optional_dependent_and_pair_rel_tgt_same_var",
-                "3_and_optional_dependent_and_pair_rel_tgt_same_other_var",
-                "3_and_optional_dependent_and_pair_src",
-                "3_and_optional_dependent_optional_pair_rel",
-                "3_and_optional_dependent_optional_pair_tgt",
-                "3_and_optional_dependent_optional_pair_src",
-                "3_and_optional_dependent_not_pair_rel",
-                "3_and_optional_dependent_not_pair_tgt",
-                "3_and_optional_dependent_not_pair_src",
-                "1_optional_any_src_fixed_first",
-                "1_optional_any_src_any_tgt_fixed_first",
-                "1_optional_any_src_any_first_fixed_tgt",
-                "1_optional_any_src_any_childof_pair_any_tgt",
-                "1_optional_any_src_any_isa_pair_any_tgt",
-                "2_or",
-                "3_or",
-                "2_or_written",
-                "3_or_written",
-                "2_or_written_w_rel_var",
-                "3_or_written_w_rel_var",
-                "2_or_written_w_tgt_var",
-                "2_or_written_w_rel_tgt_var",
-                "2_or_written_w_rel_tgt_same_var",
-                "3_or_written_w_tgt_var",
-                "2_or_chains",
-                "2_or_chains_written",
-                "2_or_dependent",
-                "2_or_dependent_reverse",
-                "2_or_dependent_2_vars",
-                "2_or_written_dependent",
-                "2_or_written_dependent_2_vars",
-                "2_or_w_dependent",
-                "2_or_w_both",
-                "3_or_w_both",
-                "2_not_first",
-                "2_optional_first",
-                "root_entities_empty",
-                "root_entities",
-                "root_entities_w_children",
-                "root_entities_w_optional_children",
-                "core_entities_w_optional_children",
-                "root_entities_w_not_children",
-                "core_entities_w_not_children",
-                "1_ent_src_not",
-                "1_ent_src_not_pair",
-                "1_ent_src_not_pair_rel_wildcard",
-                "1_ent_src_not_pair_tgt_wildcard",
-                "1_ent_src_not_pair_rel_tgt_wildcard",
-                "1_ent_src_not_pair_rel_any",
-                "1_ent_src_not_pair_tgt_any",
-                "1_ent_src_not_pair_rel_tgt_any",
-                "1_ent_src_not_pair_rel_var",
-                "1_ent_src_not_pair_tgt_var",
-                "1_ent_src_not_pair_rel_tgt_var",
-                "1_ent_src_not_pair_rel_tgt_same_var",
-                "1_this_src_not_pair_rel_var",
-                "1_this_src_not_pair_tgt_var",
-                "1_this_src_not_pair_rel_tgt_var",
-                "1_this_src_not_pair_rel_tgt_same_var",
-                "1_ent_src_not_pair_rel_var_written",
-                "1_ent_src_not_pair_tgt_var_written",
-                "1_ent_src_not_pair_rel_tgt_var_written",
-                "1_ent_src_not_pair_rel_tgt_same_var_written"
-            ]
-        }, {
-            "id": "RulesTransitive",
-            "testcases": [
-                "1_fact_0_lvl_true",
-                "1_fact_1_lvl_true",
-                "1_fact_2_lvl_true",
-                "1_fact_0_lvl_false",
-                "1_fact_1_lvl_false",
-                "1_fact_2_lvl_false",
-                "1_fact_reflexive",
-                "1_this_src_written_0_lvl",
-                "1_this_src_written_1_lvl",
-                "1_this_src_written_2_lvl",
-                "1_this_src_written_reflexive",
-                "1_this_src_0_lvl",
-                "1_this_src_1_lvl",
-                "1_this_src_2_lvl",
-                "1_this_src_reflexive",
-                "1_ent_src_tgt_var_0_lvl",
-                "1_ent_src_tgt_var_1_lvl",
-                "1_ent_src_tgt_var_2_lvl",
-                "1_ent_src_tgt_var_reflexive",
-                "1_this_src_tgt_var",
-                "1_this_src_tgt_var_reflexive",
-                "1_var_src_written_0_lvl",
-                "1_var_src_written_1_lvl",
-                "1_var_src_written_2_lvl",
-                "1_var_src_written_reflexive",
-                "1_var_src_0_lvl",
-                "1_var_src_1_lvl",
-                "1_var_src_2_lvl",
-                "1_var_src_reflexive",
-                "1_var_src_tgt_var",
-                "1_var_src_tgt_var_reflexive",
-                "1_ent_src_tgt_this_0_lvl",
-                "1_ent_src_tgt_this_1_lvl",
-                "1_ent_src_tgt_this_2_lvl",
-                "1_ent_src_tgt_this_reflexive",
-                "1_var_src_tgt_this",
-                "1_var_src_tgt_this_reflexive",
-                "2_ent_src_constrain_tgt_var_before_0_lvl",
-                "2_ent_src_constrain_tgt_var_before_1_lvl",
-                "2_ent_src_constrain_tgt_var_before_2_lvl",
-                "2_ent_src_constrain_tgt_var_after_0_lvl",
-                "2_ent_src_constrain_tgt_var_after_1_lvl",
-                "2_ent_src_constrain_tgt_var_after_2_lvl",
-                "2_this_src_constrain_tgt_var_before_0_lvl",
-                "2_this_src_constrain_tgt_var_before_1_lvl",
-                "2_this_src_constrain_tgt_var_before_2_lvl",
-                "2_this_src_constrain_tgt_var_after_0_lvl",
-                "2_this_src_constrain_tgt_var_after_1_lvl",
-                "2_this_src_constrain_tgt_var_after_2_lvl",
-                "1_src_tgt_same_var",
-                "1_src_tgt_same_var_reflexive",
-                "1_src_tgt_same_this_var_reflexive",
-                "1_any_src_tgt_var",
-                "not_transitive_ent_tgt",
-                "not_transitive_var_tgt",
-                "not_transitive_ent_tgt_written",
-                "not_transitive_var_tgt_written",
-                "optional_transitive_ent_tgt",
-                "optional_transitive_var_tgt",
-                "optional_transitive_ent_tgt_written",
-                "optional_transitive_var_tgt_written",
-                "2_var_src_w_same_tgt_ent",
-                "self_target",
-                "any_target"
-            ]
-        }, {
-            "id": "RulesComponentInheritance",
-            "testcases": [
-                "1_ent_0_lvl",
-                "1_ent_1_lvl",
-                "1_ent_2_lvl",
-                "1_ent_3_lvl",
-                "1_this_0_lvl",
-                "1_this_1_lvl",
-                "1_this_2_lvl",
-                "1_this_3_lvl",
-                "1_this_0_lvl_written",
-                "1_this_1_lvl_written",
-                "1_this_2_lvl_written",
-                "1_this_3_lvl_written",
-                "1_var_0_lvl",
-                "1_var_1_lvl",
-                "1_var_2_lvl",
-                "1_var_3_lvl",
-                "1_var_0_lvl_written",
-                "1_var_1_lvl_written",
-                "1_var_2_lvl_written",
-                "1_var_3_lvl_written",
-                "1_ent_1_lvl_self",
-                "1_this_1_lvl_self",
-                "1_this_1_lvl_written_self",
-                "1_var_1_lvl_self",
-                "1_var_1_lvl_written_self",
-                "1_ent_src_not",
-                "1_this_src_not",
-                "1_var_src_not",
-                "1_this_src_not_written",
-                "1_var_src_not_written",
-                "first_self",
-                "first_down",
-                "first_self_down",
-                "first_rel_self",
-                "first_rel_down",
-                "first_rel_self_down"
-            ]
-        }, {
-            "id": "RulesRecycled",
-            "testcases": [
-                "recycled_vars",
-                "recycled_pair_vars",
-                "recycled_this_ent_var",
-                "has_recycled_id_from_pair"
-            ]
-        }, {
-            "id": "RulesBuiltinPredicates",
-            "testcases": [
-                "this_eq_id",
-                "this_eq_name",
-                "this_eq_var",
-                "this_eq_id_written",
-                "this_eq_id_written_no_match",
-                "this_eq_name_written",
-                "this_eq_name_written_no_match",
-                "this_eq_var_written",
-                "var_eq_id",
-                "var_eq_name",
-                "var_eq_var",
-                "var_eq_id_written",
-                "var_eq_id_written_no_match",
-                "var_eq_name_written",
-                "var_eq_name_written_no_match",
-                "var_eq_var_written",
-                "var_eq_this",
-                "this_neq_id",
-                "this_neq_name",
-                "this_neq_var",
-                "this_neq_id_written",
-                "this_neq_id_written_no_match",
-                "this_neq_name_written",
-                "this_neq_name_written_no_match",
-                "this_neq_var_written",
-                "var_neq_id",
-                "var_neq_name",
-                "var_neq_var",
-                "var_neq_id_written",
-                "var_neq_id_written_no_match",
-                "var_neq_name_written",
-                "var_neq_name_written_no_match",
-                "var_neq_var_written",
-                "var_neq_this",
-                "this_2_neq_id",
-                "this_2_neq_name",
-                "var_2_neq_id",
-                "var_2_neq_name",
-                "this_2_neq_id_written",
-                "this_2_neq_name_written",
-                "var_2_neq_id_written",
-                "var_2_neq_name_written",
-                "this_2_or_id",
-                "this_2_or_name",
-                "var_2_or_id",
-                "var_2_or_name",
-                "this_2_or_id_written",
-                "this_2_or_name_written",
-                "var_2_or_id_written",
-                "var_2_or_name_written",
-                "this_match_eq",
-                "var_match_eq",
-                "this_match_eq_written",
-                "this_match_eq_written_self",
-                "var_match_eq_written",
-                "this_match_neq",
-                "var_match_neq",
-                "this_match_neq_written",
-                "var_match_neq_written",
-                "this_match_2_neq",
-                "var_match_2_neq",
-                "this_match_2_neq_written",
-                "var_match_2_neq_written",
-                "this_match_2_or",
-                "this_match_2_or_written",
-                "this_match_3_or",
-                "this_match_3_or_written",
-                "unresolved_by_name",
-                "var_eq_wildcard",
-                "var_eq_any",
-                "var_eq_wildcard_after_write",
-                "var_eq_any_after_write",
-                "var_eq_after_var_0_src",
-                "2_or_w_eq_this",
-                "2_or_w_eq_lookup_var",
-                "3_or_w_eq_lookup_var",
-                "unwritten_var_error_neq",
-                "unwritten_var_error_match"
-            ]
-        }, {
-            "id": "RulesScopes",
-            "testcases": [
-                "term_w_not_scope_1_term",
-                "term_w_not_scope_2_terms",
-                "term_w_not_scope_1_term_w_not",
-                "term_w_not_scope_2_terms_w_not",
-                "term_w_not_scope_1_term_w_var",
-                "term_w_not_scope_2_terms_w_var",
-                "term_w_not_scope_1_term_w_not_w_var",
-                "term_w_not_scope_2_terms_w_not_w_var",
-                "term_w_not_scope_2_terms_w_or",
-                "term_w_not_scope_3_terms_w_or"
-            ]
-        }, {
-            "id": "RulesTraversal",
-            "testcases": [
-                "this_self_up_childof",
-                "this_up_childof",
-                "this_written_self_up_childof",
-                "this_written_up_childof",
-                "var_self_up_childof",
-                "var_up_childof",
-                "var_written_self_up_childof",
-                "var_written_up_childof",
-                "set_var_self_up_childof",
-                "set_var_up_childof",
-                "set_var_written_self_up_childof",
-                "set_var_written_up_childof",
-                "ent_self_up_childof",
-                "ent_up_childof",
-                "implicit_this_self_up_isa",
-                "implicit_this_up_isa",
-                "implicit_var_self_up_isa",
-                "implicit_var_up_isa",
-                "implicit_ent_self_up_isa",
-                "implicit_ent_up_isa",
-                "self_up_2_targets",
-                "up_2_targets",
-                "self_up_2_targets_diamond",
-                "up_2_targets_diamond",
-                "written_self_up_2_targets",
-                "written_up_2_targets",
-                "written_self_up_2_targets_diamond",
-                "written_up_2_targets_diamond",
-                "2_self_up_terms",
-                "2_self_up_terms_2_targets",
-                "self_up_empty_table",
-                "up_empty_table",
-                "self_up_all_owned",
-                "up_all_owned",
-                "this_self_up_childof_inherited",
-                "this_up_childof_inherited",
-                "this_written_self_up_childof_inherited",
-                "this_written_up_childof_inherited",
-                "var_self_up_childof_inherited",
-                "var_up_childof_inherited",
-                "var_written_self_up_childof_inherited",
-                "var_written_up_childof_inherited",
-                "ent_self_up_childof_inherited",
-                "ent_up_childof_inherited",
-                "ent_written_self_up_childof_inherited",
-                "ent_written_up_childof_inherited",
-                "this_self_up_childof_component",
-                "this_up_childof_component",
-                "this_written_self_up_childof_component",
-                "this_written_up_childof_component",
-                "var_self_up_childof_component",
-                "var_up_childof_component",
-                "var_written_self_up_childof_component",
-                "var_written_up_childof_component",
-                "this_self_up_childof_recycled_parent",
-                "this_up_childof_recycled_parent",
-                "this_written_self_up_childof_recycled_parent",
-                "this_written_up_childof_recycled_parent",
-                "this_self_up_childof_recycled_parent_component",
-                "this_up_childof_recycled_parent_component",
-                "this_written_self_up_childof_recycled_parent_component",
-                "this_written_up_childof_recycled_parent_component",
-                "this_self_up_childof_pair",
-                "this_up_childof_pair",
-                "this_written_self_up_childof_pair",
-                "this_written_up_childof_pair",
-                "this_self_up_childof_pair_wildcard",
-                "this_up_childof_pair_wildcard",
-                "this_written_self_up_childof_pair_wildcard",
-                "this_written_up_childof_pair_wildcard",
-                "this_self_up_childof_pair_tgt_var",
-                "this_written_self_up_childof_pair_tgt_var",
-                "this_self_up_childof_pair_rel_var",
-                "this_written_self_up_childof_pair_rel_var",
-                "this_self_up_childof_pair_for_var_written",
-                "this_up_childof_pair_for_var_written",
-                "this_written_self_up_childof_pair_for_var_written",
-                "this_self_up_childof_pair_for_var_written_n_targets",
-                "this_written_self_up_childof_pair_for_var_written_n_targets",
-                "self_up_2_levels",
-                "not_up_disabled",
-                "up_2_rel_instances",
-                "up_2_rel_instances_match_2nd",
-                "up_only_w_owned",
-                "this_self_cascade_childof",
-                "this_cascade_childof",
-                "this_written_self_cascade_childof",
-                "this_written_cascade_childof",
-                "this_self_cascade_childof_w_parent_flag",
-                "this_cascade_childof_w_parent_flag",
-                "this_written_self_cascade_childof_w_parent_flag",
-                "this_written_cascade_childof_w_parent_flag"
+                "system_same_interval_same_tick",
+                "system_no_id_in_scope"
             ]
         }, {
             "id": "SystemPeriodic",
@@ -1532,7 +270,6 @@
             "setup": true,
             "testcases": [
                 "1_type_1_component",
-                "no_automerge",
                 "dont_run_w_unmatching_entity_query"
             ]
         }, {
@@ -1610,28 +347,15 @@
                 "run",
                 "run_w_param",
                 "run_no_match",
-                "run_w_offset",
-                "run_w_offset_skip_1_archetype",
-                "run_w_offset_skip_1_archetype_plus_one",
-                "run_w_offset_skip_2_archetypes",
-                "run_w_limit_skip_1_archetype",
-                "run_w_limit_skip_1_archetype_minus_one",
-                "run_w_limit_skip_2_archetypes",
-                "run_w_offset_1_limit_max",
-                "run_w_offset_1_limit_minus_1",
-                "run_w_offset_2_type_limit_max",
-                "run_w_offset_2_type_limit_minus_1",
-                "run_w_limit_1_all_offsets",
-                "run_w_offset_out_of_bounds",
-                "run_w_limit_out_of_bounds",
-                "run_comb_10_entities_1_type",
-                "run_comb_10_entities_2_types",
                 "run_w_interrupt",
                 "run_staging"
             ]
         }, {
             "id": "MultiThread",
             "setup": true,
+            "params": {
+                "worker_kind": ["thread", "task"]
+            },
             "testcases": [
                 "2_thread_1_entity",
                 "2_thread_2_entity",
@@ -1687,6 +411,9 @@
         }, {
             "id": "MultiThreadStaging",
             "setup": true,
+            "params": {
+                "worker_kind": ["thread", "task"]
+            },
             "testcases": [
                 "2_threads_add_to_current",
                 "3_threads_add_to_current",
@@ -1696,117 +423,11 @@
                 "2_threads_on_add",
                 "new_w_count",
                 "custom_thread_auto_merge",
-                "custom_thread_manual_merge",
-                "custom_thread_partial_manual_merge",
-                "set_pair_w_new_target_readonly",
-                "set_pair_w_new_target_tgt_component_readonly",
-                "set_pair_w_new_target_defer",
-                "set_pair_w_new_target_tgt_component_defer"
-            ]
-        }, {
-            "id": "MultiTaskThread",
-            "setup": true,
-            "testcases": [
-                "2_thread_1_entity",
-                "2_thread_2_entity",
-                "2_thread_5_entity",
-                "2_thread_10_entity",
-                "3_thread_1_entity",
-                "3_thread_2_entity",
-                "3_thread_5_entity",
-                "3_thread_10_entity",
-                "4_thread_1_entity",
-                "4_thread_2_entity",
-                "4_thread_5_entity",
-                "4_thread_10_entity",
-                "5_thread_1_entity",
-                "5_thread_2_entity",
-                "5_thread_5_entity",
-                "5_thread_10_entity",
-                "6_thread_1_entity",
-                "6_thread_2_entity",
-                "6_thread_5_entity",
-                "6_thread_10_entity",
-                "2_thread_1_entity_instanced",
-                "2_thread_5_entity_instanced",
-                "2_thread_10_entity_instanced",
-                "2_thread_test_combs_100_entity_w_next_worker",
-                "2_thread_test_combs_100_entity",
-                "3_thread_test_combs_100_entity",
-                "4_thread_test_combs_100_entity",
-                "5_thread_test_combs_100_entity",
-                "6_thread_test_combs_100_entity",
-                "2_thread_test_combs_100_entity_2_types",
-                "3_thread_test_combs_100_entity_2_types",
-                "4_thread_test_combs_100_entity_2_types",
-                "5_thread_test_combs_100_entity_2_types",
-                "6_thread_test_combs_100_entity_2_types",
-                "change_thread_count",
-                "multithread_quit",
-                "schedule_w_tasks",
-                "reactive_system",
-                "fini_after_set_threads",
-                "2_threads_single_threaded_system",
-                "no_staging_w_multithread",
-                "multithread_w_monitor_addon",
-                "get_ctx",
-                "get_binding_ctx",
-                "get_ctx_w_run",
-                "get_binding_ctx_w_run",
-                "bulk_new_in_no_readonly_w_multithread",
-                "bulk_new_in_no_readonly_w_multithread_2",
-                "run_first_worker_on_main",
-                "run_single_thread_on_main"
-            ]
-        }, {
-            "id": "MultiTaskThreadStaging",
-            "setup": true,
-            "testcases": [
-                "2_threads_add_to_current",
-                "3_threads_add_to_current",
-                "4_threads_add_to_current",
-                "5_threads_add_to_current",
-                "6_threads_add_to_current",
-                "2_threads_on_add",
-                "new_w_count",
-                "custom_thread_auto_merge",
-                "custom_thread_manual_merge",
-                "custom_thread_partial_manual_merge",
                 "set_pair_w_new_target_readonly",
                 "set_pair_w_new_target_tgt_component_readonly",
                 "set_pair_w_new_target_defer",
                 "set_pair_w_new_target_tgt_component_defer"
             ]
-        }, {
-            "id": "Snapshot",
-            "testcases": [
-                "simple_snapshot",
-                "snapshot_after_new",
-                "snapshot_after_delete",
-                "snapshot_after_new_type",
-                "snapshot_after_add",
-                "snapshot_after_remove",
-                "snapshot_w_include_filter",
-                "snapshot_w_exclude_filter",
-                "snapshot_w_filter_after_new",
-                "snapshot_w_filter_after_delete",
-                "snapshot_free_empty",
-                "snapshot_free",
-                "snapshot_free_filtered",
-                "snapshot_free_filtered_w_dtor",
-                "snapshot_activate_table_w_filter",
-                "snapshot_copy",
-                "snapshot_get_ref_after_restore",
-                "new_after_snapshot",
-                "new_empty_after_snapshot",
-                "add_after_snapshot",
-                "delete_after_snapshot",
-                "set_after_snapshot",
-                "restore_recycled",
-                "snapshot_w_new_in_onset",
-                "snapshot_w_new_in_onset_in_snapshot_table",
-                "snapshot_from_stage"
-            ]
         }, {
             "id": "Modules",
             "setup": true,
@@ -1869,7 +490,8 @@
                 "request_commands_2_syncs",
                 "request_commands_no_frames",
                 "request_commands_no_commands",
-                "request_commands_garbage_collect"
+                "request_commands_garbage_collect",
+                "script_error"
             ]
         }, {
             "id": "Metrics",
diff --git a/test/addons/src/Alerts.c b/test/addons/src/Alerts.c
index 1748a6ac1..82d0014ab 100644
--- a/test/addons/src/Alerts.c
+++ b/test/addons/src/Alerts.c
@@ -8,16 +8,16 @@ void Alerts_one_active_alert(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity"
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity"
     });
     test_assert(alert != 0);
 
@@ -29,9 +29,9 @@ void Alerts_one_active_alert(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -44,8 +44,8 @@ void Alerts_one_active_alert(void) {
         test_assert(source != NULL);
         test_int(source->entity, e2);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_progress(world, 1.0);
@@ -57,9 +57,9 @@ void Alerts_one_active_alert(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -72,8 +72,8 @@ void Alerts_one_active_alert(void) {
         test_assert(source != NULL);
         test_int(source->entity, e2);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add(world, e2, Velocity);
@@ -97,8 +97,8 @@ void Alerts_two_active_alerts(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Velocity);
@@ -106,13 +106,13 @@ void Alerts_two_active_alerts(void) {
     ecs_add(world, e2, Position);
 
     ecs_entity_t alert_1 = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity"
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity"
     });
 
     ecs_entity_t alert_2 = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_mass"),
-        .filter.expr = "Position, !Mass"
+        .entity = ecs_entity(world, { .name = "position_without_mass" }),
+        .query.expr = "Position, !Mass"
     });
 
     ecs_progress(world, 1.0);
@@ -125,9 +125,9 @@ void Alerts_two_active_alerts(void) {
         test_assert(ecs_get_alert_count(world, e2, alert_2) == 1);
         test_assert(ecs_get_alert_count(world, e2, 0) == 2);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         test_assert(it.entities[0] != 0);
         test_assert(ecs_get_parent(world, it.entities[0]) == alert_1);
@@ -140,7 +140,7 @@ void Alerts_two_active_alerts(void) {
             test_int(source->entity, e2);
         }
 
-        test_bool(ecs_filter_next(&it), true);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         test_assert(it.entities[0] != 0);
         test_assert(ecs_get_parent(world, it.entities[0]) == alert_2);
@@ -153,8 +153,8 @@ void Alerts_two_active_alerts(void) {
             test_int(source->entity, e2);
         }
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_progress(world, 1.0);
@@ -168,9 +168,9 @@ void Alerts_two_active_alerts(void) {
         test_assert(ecs_get_alert_count(world, e2, alert_2) == 1);
         test_assert(ecs_get_alert_count(world, e2, 0) == 2);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         test_assert(it.entities[0] != 0);
         test_assert(ecs_get_parent(world, it.entities[0]) == alert_1);
@@ -183,7 +183,7 @@ void Alerts_two_active_alerts(void) {
             test_int(source->entity, e2);
         }
 
-        test_bool(ecs_filter_next(&it), true);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         test_assert(it.entities[0] != 0);
         test_assert(ecs_get_parent(world, it.entities[0]) == alert_2);
@@ -196,8 +196,8 @@ void Alerts_two_active_alerts(void) {
             test_int(source->entity, e2);
         }
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add(world, e2, Mass);
@@ -213,9 +213,9 @@ void Alerts_two_active_alerts(void) {
         test_assert(ecs_get_alert_count(world, e2, alert_2) == 0);
         test_assert(ecs_get_alert_count(world, e2, 0) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -228,8 +228,8 @@ void Alerts_two_active_alerts(void) {
         test_assert(source != NULL);
         test_int(source->entity, e2);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add(world, e2, Velocity);
@@ -252,16 +252,16 @@ void Alerts_alert_message(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .message = "missing velocity"
     });
     test_assert(alert != 0);
@@ -274,9 +274,9 @@ void Alerts_alert_message(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -290,8 +290,8 @@ void Alerts_alert_message(void) {
         test_assert(source != NULL);
         test_int(source->entity, e2);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -305,16 +305,16 @@ void Alerts_alert_message_w_this_var(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .message = "$this: missing velocity"
     });
     test_assert(alert != 0);
@@ -327,9 +327,9 @@ void Alerts_alert_message_w_this_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -343,8 +343,8 @@ void Alerts_alert_message_w_this_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e2);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -357,11 +357,11 @@ void Alerts_alert_message_w_var(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t parent_1 = ecs_new_entity(world, "p1");
+    ecs_entity_t parent_1 = ecs_entity(world, { .name = "p1" });
     ecs_add(world, parent_1, Position);
-    ecs_entity_t parent_2 = ecs_new_entity(world, "p2");
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t parent_2 = ecs_entity(world, { .name = "p2" });
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_pair(world, e1, EcsChildOf, parent_1);
     ecs_add_pair(world, e2, EcsChildOf, parent_2);
 
@@ -369,8 +369,8 @@ void Alerts_alert_message_w_var(void) {
     ecs_add(world, e2, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position($this), ChildOf($this, $parent), !Position($parent)",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position($this), ChildOf($this, $parent), !Position($parent)",
         .message = "$this: parent $parent does not have Position"
     });
     test_assert(alert != 0);
@@ -383,9 +383,9 @@ void Alerts_alert_message_w_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -399,8 +399,8 @@ void Alerts_alert_message_w_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e2);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -413,12 +413,12 @@ void Alerts_alert_message_w_changed_var(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t parent_1 = ecs_new_entity(world, "p1");
+    ecs_entity_t parent_1 = ecs_entity(world, { .name = "p1" });
     ecs_add(world, parent_1, Position);
-    ecs_entity_t parent_2 = ecs_new_entity(world, "p2");
-    ecs_entity_t parent_3 = ecs_new_entity(world, "p3");
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t parent_2 = ecs_entity(world, { .name = "p2" });
+    ecs_entity_t parent_3 = ecs_entity(world, { .name = "p3" });
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_pair(world, e1, EcsChildOf, parent_1);
     ecs_add_pair(world, e2, EcsChildOf, parent_2);
 
@@ -426,8 +426,8 @@ void Alerts_alert_message_w_changed_var(void) {
     ecs_add(world, e2, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position($this), ChildOf($this, $parent), !Position($parent)",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position($this), ChildOf($this, $parent), !Position($parent)",
         .message = "$this: parent $parent does not have Position"
     });
     test_assert(alert != 0);
@@ -440,9 +440,9 @@ void Alerts_alert_message_w_changed_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -456,8 +456,8 @@ void Alerts_alert_message_w_changed_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e2);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add_pair(world, e2, EcsChildOf, parent_3);
@@ -470,9 +470,9 @@ void Alerts_alert_message_w_changed_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -485,8 +485,8 @@ void Alerts_alert_message_w_changed_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e2);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -500,8 +500,8 @@ void Alerts_set_brief(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "has_position"),
-        .filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "has_position" }),
+        .query.expr = "Position",
         .brief = "Entity has Position"
     });
     test_assert(alert != 0);
@@ -518,8 +518,8 @@ void Alerts_set_doc_name(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "has_position"),
-        .filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "has_position" }),
+        .query.expr = "Position",
         .doc_name = "Has Position"
     });
     test_assert(alert != 0);
@@ -536,12 +536,12 @@ void Alerts_alert_instance_has_doc_name(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add(world, e2, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity"
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity"
     });
     test_assert(alert != 0);
 
@@ -552,9 +552,9 @@ void Alerts_alert_instance_has_doc_name(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -569,8 +569,8 @@ void Alerts_alert_instance_has_doc_name(void) {
 
         test_str(ecs_doc_get_name(world, it.entities[0]), "e2");
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -584,13 +584,13 @@ void Alerts_reraise_alert(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
     ecs_add(world, e1, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity"
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity"
     });
     test_assert(alert != 0);
 
@@ -601,9 +601,9 @@ void Alerts_reraise_alert(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -616,8 +616,8 @@ void Alerts_reraise_alert(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     /* Clear the alert */
@@ -639,9 +639,9 @@ void Alerts_reraise_alert(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -654,8 +654,8 @@ void Alerts_reraise_alert(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -669,12 +669,12 @@ void Alerts_info_severity(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .severity = EcsAlertInfo
     });
     test_assert(alert != 0);
@@ -687,9 +687,9 @@ void Alerts_info_severity(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -702,8 +702,8 @@ void Alerts_info_severity(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -717,12 +717,12 @@ void Alerts_warning_severity(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .severity = EcsAlertWarning
     });
     test_assert(alert != 0);
@@ -735,9 +735,9 @@ void Alerts_warning_severity(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -750,8 +750,8 @@ void Alerts_warning_severity(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -765,12 +765,12 @@ void Alerts_error_severity(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .severity = EcsAlertError
     });
     test_assert(alert != 0);
@@ -783,9 +783,9 @@ void Alerts_error_severity(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -798,8 +798,8 @@ void Alerts_error_severity(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -813,16 +813,16 @@ void Alerts_expire_after_retain(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .retain_period = 1.0
     });
     test_assert(alert != 0);
@@ -836,9 +836,9 @@ void Alerts_expire_after_retain(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -855,8 +855,8 @@ void Alerts_expire_after_retain(void) {
         test_assert(ecs_has(world, ai, EcsMetricValue));
         test_int(ecs_get(world, ai, EcsMetricValue)->value, 1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_progress(world, 1.0);
@@ -905,16 +905,16 @@ void Alerts_revive_w_retain(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .retain_period = 1.0
     });
     test_assert(alert != 0);
@@ -928,9 +928,9 @@ void Alerts_revive_w_retain(void) {
     {
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -947,8 +947,8 @@ void Alerts_revive_w_retain(void) {
         test_assert(ecs_has(world, ai, EcsMetricValue));
         test_int(ecs_get(world, ai, EcsMetricValue)->value, 1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_progress(world, 1.0);
@@ -1015,12 +1015,12 @@ void Alerts_severity_filter(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .severity_filters[0] = {
             .severity = EcsAlertWarning,
             .with = ecs_id(Mass)
@@ -1036,9 +1036,9 @@ void Alerts_severity_filter(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1051,8 +1051,8 @@ void Alerts_severity_filter(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add(world, e1, Mass);
@@ -1063,9 +1063,9 @@ void Alerts_severity_filter(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1078,8 +1078,8 @@ void Alerts_severity_filter(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_remove(world, e1, Mass);
@@ -1090,9 +1090,9 @@ void Alerts_severity_filter(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1105,8 +1105,8 @@ void Alerts_severity_filter(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -1122,12 +1122,12 @@ void Alerts_two_severity_filters(void) {
     ECS_COMPONENT(world, Mass);
     ECS_COMPONENT(world, Rotation);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .severity_filters[0] = {
             .severity = EcsAlertWarning,
             .with = ecs_id(Mass)
@@ -1147,9 +1147,9 @@ void Alerts_two_severity_filters(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1162,8 +1162,8 @@ void Alerts_two_severity_filters(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add(world, e1, Mass);
@@ -1174,9 +1174,9 @@ void Alerts_two_severity_filters(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1189,8 +1189,8 @@ void Alerts_two_severity_filters(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_remove(world, e1, Mass);
@@ -1202,9 +1202,9 @@ void Alerts_two_severity_filters(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1217,8 +1217,8 @@ void Alerts_two_severity_filters(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_remove(world, e1, Rotation);
@@ -1230,9 +1230,9 @@ void Alerts_two_severity_filters(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1245,8 +1245,8 @@ void Alerts_two_severity_filters(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -1261,16 +1261,16 @@ void Alerts_severity_filter_w_var(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Mass);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity, (ChildOf, $parent)",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity, (ChildOf, $parent)",
         .severity_filters[0] = {
             .severity = EcsAlertWarning,
             .with = ecs_id(Mass),
@@ -1287,9 +1287,9 @@ void Alerts_severity_filter_w_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
 
         test_assert(it.entities[0] != 0);
@@ -1302,8 +1302,8 @@ void Alerts_severity_filter_w_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add(world, parent, Mass);
@@ -1314,9 +1314,9 @@ void Alerts_severity_filter_w_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1329,8 +1329,8 @@ void Alerts_severity_filter_w_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_remove(world, parent, Mass);
@@ -1341,9 +1341,9 @@ void Alerts_severity_filter_w_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1356,8 +1356,8 @@ void Alerts_severity_filter_w_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -1372,18 +1372,18 @@ void Alerts_severity_filter_w_var_change_var(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t parent_1 = ecs_new_id(world);
-    ecs_entity_t parent_2 = ecs_new_id(world);
+    ecs_entity_t parent_1 = ecs_new(world);
+    ecs_entity_t parent_2 = ecs_new(world);
     ecs_add(world, parent_2, Mass);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add_pair(world, e1, EcsChildOf, parent_1);
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Mass);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity, (ChildOf, $parent)",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity, (ChildOf, $parent)",
         .severity_filters[0] = {
             .severity = EcsAlertWarning,
             .with = ecs_id(Mass),
@@ -1400,9 +1400,9 @@ void Alerts_severity_filter_w_var_change_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
 
         test_assert(it.entities[0] != 0);
@@ -1415,8 +1415,8 @@ void Alerts_severity_filter_w_var_change_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add_pair(world, e1, EcsChildOf, parent_2);
@@ -1427,9 +1427,9 @@ void Alerts_severity_filter_w_var_change_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1442,8 +1442,8 @@ void Alerts_severity_filter_w_var_change_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add_pair(world, e1, EcsChildOf, parent_1);
@@ -1454,9 +1454,9 @@ void Alerts_severity_filter_w_var_change_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1469,8 +1469,8 @@ void Alerts_severity_filter_w_var_change_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -1488,15 +1488,15 @@ void Alerts_member_range_warning(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .warning_range = { 0, 100 }}}
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Mass, {50});
 
     ecs_entity_t member = ecs_lookup(world, "Mass.value");
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = member
     });
     test_assert(alert != 0);
@@ -1515,9 +1515,9 @@ void Alerts_member_range_warning(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1530,8 +1530,8 @@ void Alerts_member_range_warning(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_set(world, e1, Mass, {25});
@@ -1556,15 +1556,15 @@ void Alerts_member_range_error(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .error_range = { 0, 100 }}}
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Mass, {50});
 
     ecs_entity_t member = ecs_lookup(world, "Mass.value");
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = member
     });
     test_assert(alert != 0);
@@ -1583,9 +1583,9 @@ void Alerts_member_range_error(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1598,8 +1598,8 @@ void Alerts_member_range_error(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_set(world, e1, Mass, {25});
@@ -1624,15 +1624,15 @@ void Alerts_member_range_warning_error(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .warning_range = {0, 50}, .error_range = { 0, 100 }}}
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Mass, {25});
 
     ecs_entity_t member = ecs_lookup(world, "Mass.value");
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = member
     });
     test_assert(alert != 0);
@@ -1651,9 +1651,9 @@ void Alerts_member_range_warning_error(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1666,8 +1666,8 @@ void Alerts_member_range_warning_error(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_set(world, e1, Mass, {125});
@@ -1679,9 +1679,9 @@ void Alerts_member_range_warning_error(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -1694,8 +1694,8 @@ void Alerts_member_range_warning_error(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_set(world, e1, Mass, {25});
@@ -1720,15 +1720,15 @@ void Alerts_member_range_error_w_warning_severity(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .error_range = { 0, 100 }}}
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Mass, {50});
 
     ecs_entity_t member = ecs_lookup(world, "Mass.value");
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .severity = EcsAlertWarning,
         .member = member
     });
@@ -1748,9 +1748,9 @@ void Alerts_member_range_error_w_warning_severity(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
 
         test_assert(it.entities[0] != 0);
@@ -1763,8 +1763,8 @@ void Alerts_member_range_error_w_warning_severity(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_set(world, e1, Mass, {25});
@@ -1790,15 +1790,15 @@ void Alerts_member_range_error_w_severity_filter(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .error_range = { 0, 100 }}}
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Mass, {50});
 
     ecs_entity_t member = ecs_lookup(world, "Mass.value");
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .severity = EcsAlertWarning,
         .severity_filters[0] = {
             .with = Tag,
@@ -1822,9 +1822,9 @@ void Alerts_member_range_error_w_severity_filter(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
 
         test_assert(it.entities[0] != 0);
@@ -1837,8 +1837,8 @@ void Alerts_member_range_error_w_severity_filter(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add(world, e1, Tag);
@@ -1850,9 +1850,9 @@ void Alerts_member_range_error_w_severity_filter(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
 
         test_assert(it.entities[0] != 0);
@@ -1865,8 +1865,8 @@ void Alerts_member_range_error_w_severity_filter(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -1885,15 +1885,15 @@ void Alerts_member_range_warning_w_severity_filter(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .warning_range = { 0, 100 }}}
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Mass, {50});
 
     ecs_entity_t member = ecs_lookup(world, "Mass.value");
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .severity = EcsAlertWarning,
         .severity_filters[0] = {
             .with = Tag,
@@ -1917,9 +1917,9 @@ void Alerts_member_range_warning_w_severity_filter(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
 
         test_assert(it.entities[0] != 0);
@@ -1932,8 +1932,8 @@ void Alerts_member_range_warning_w_severity_filter(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add(world, e1, Tag);
@@ -1945,9 +1945,9 @@ void Alerts_member_range_warning_w_severity_filter(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
 
         test_assert(it.entities[0] != 0);
@@ -1960,8 +1960,8 @@ void Alerts_member_range_warning_w_severity_filter(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_fini(world);
@@ -1980,15 +1980,15 @@ void Alerts_member_range_pair_id(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .error_range = { 0, 100 }}}
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Mass, {50});
 
     ecs_entity_t member = ecs_lookup(world, "Mass.value");
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = member,
         .id = ecs_pair_t(Mass, Tag)
     });
@@ -2008,9 +2008,9 @@ void Alerts_member_range_pair_id(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -2023,8 +2023,8 @@ void Alerts_member_range_pair_id(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_set_pair(world, e1, Mass, Tag, {25});
@@ -2055,8 +2055,8 @@ void Alerts_member_range_invalid_member(void) {
 
     ecs_log_set_level(-4);
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = Tag,
     });
     test_assert(alert == 0);
@@ -2083,8 +2083,8 @@ void Alerts_member_range_invalid_member_child(void) {
 
     ecs_log_set_level(-4);
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = child,
     });
     test_assert(alert == 0);
@@ -2110,8 +2110,8 @@ void Alerts_member_range_invalid_type(void) {
 
     ecs_log_set_level(-4);
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = member,
         .id = Tag
     });
@@ -2133,7 +2133,7 @@ void Alerts_member_range_invalid_member_type(void) {
     });
 
     ecs_struct(world, {
-        .entity = ecs_new_entity(world, "Foo"),
+        .entity = ecs_entity(world, { .name = "Foo" }),
         .members = {{ "value", ecs_id(Mass) }}
     });
 
@@ -2142,8 +2142,8 @@ void Alerts_member_range_invalid_member_type(void) {
 
     ecs_log_set_level(-4);
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = member,
     });
     test_assert(alert == 0);
@@ -2168,8 +2168,8 @@ void Alerts_member_range_no_range(void) {
 
     ecs_log_set_level(-4);
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = member,
     });
     test_assert(alert == 0);
@@ -2189,17 +2189,17 @@ void Alerts_member_range_alert_two_instances(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .error_range = { 0, 100 }}}
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Mass, {50});
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Mass, {50});
 
     ecs_entity_t member = ecs_lookup(world, "Mass.value");
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_mass"),
-        .filter.expr = "Mass",
+        .entity = ecs_entity(world, { .name = "high_mass" }),
+        .query.expr = "Mass",
         .member = member,
     });
     test_assert(alert != 0);
@@ -2222,9 +2222,9 @@ void Alerts_member_range_alert_two_instances(void) {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 2);
 
         test_assert(it.entities[0] != 0);
@@ -2244,8 +2244,8 @@ void Alerts_member_range_alert_two_instances(void) {
             test_int(source->entity, e2);
         }
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_progress(world, 1.0);
@@ -2257,9 +2257,9 @@ void Alerts_member_range_alert_two_instances(void) {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
         test_assert(ecs_get_alert_count(world, e2, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 2);
 
         test_assert(it.entities[0] != 0);
@@ -2279,8 +2279,8 @@ void Alerts_member_range_alert_two_instances(void) {
             test_int(source->entity, e2);
         }
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_set(world, e1, Mass, {25});
@@ -2306,7 +2306,7 @@ void Alerts_member_range_from_var(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .error_range = { 0, 100 }}}
     });
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
     ecs_set(world, p, Mass, {50});
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p);
 
@@ -2314,8 +2314,8 @@ void Alerts_member_range_from_var(void) {
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_parent_mass"),
-        .filter.expr = "(ChildOf, $parent), Mass($parent)",
+        .entity = ecs_entity(world, { .name = "high_parent_mass" }),
+        .query.expr = "(ChildOf, $parent), Mass($parent)",
         .member = member,
         .var = "parent"
     });
@@ -2335,9 +2335,9 @@ void Alerts_member_range_from_var(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -2350,8 +2350,8 @@ void Alerts_member_range_from_var(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_set(world, p, Mass, {25});
@@ -2376,7 +2376,7 @@ void Alerts_member_range_from_var_after_remove(void) {
         .members = {{ "value", ecs_id(ecs_f32_t), .error_range = { 0, 100 }}}
     });
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
     ecs_set(world, p, Mass, {50});
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p);
 
@@ -2384,8 +2384,8 @@ void Alerts_member_range_from_var_after_remove(void) {
     test_assert(member != 0);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "high_parent_mass"),
-        .filter.expr = "(ChildOf, $parent), Mass($parent)",
+        .entity = ecs_entity(world, { .name = "high_parent_mass" }),
+        .query.expr = "(ChildOf, $parent), Mass($parent)",
         .member = member,
         .var = "parent"
     });
@@ -2405,9 +2405,9 @@ void Alerts_member_range_from_var_after_remove(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] != 0);
@@ -2420,8 +2420,8 @@ void Alerts_member_range_from_var_after_remove(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_remove(world, p, Mass);
@@ -2442,12 +2442,12 @@ void Alerts_retained_alert_w_dead_source(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Position);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .severity = EcsAlertError,
         .retain_period = 10
     });
@@ -2462,9 +2462,9 @@ void Alerts_retained_alert_w_dead_source(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 1);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
 
         ai = it.entities[0];
@@ -2479,8 +2479,8 @@ void Alerts_retained_alert_w_dead_source(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_add(world, e1, Velocity);
@@ -2492,9 +2492,9 @@ void Alerts_retained_alert_w_dead_source(void) {
     {
         test_assert(ecs_get_alert_count(world, e1, alert) == 0);
 
-        ecs_filter_t *alerts = ecs_filter(world, { .expr = "flecs.alerts.Instance, ?Disabled" });
-        ecs_iter_t it = ecs_filter_iter(world, alerts);
-        test_bool(ecs_filter_next(&it), true);
+        ecs_query_t *alerts = ecs_query(world, { .expr = "flecs.alerts.Instance, ?Disabled" });
+        ecs_iter_t it = ecs_query_iter(world, alerts);
+        test_bool(ecs_query_next(&it), true);
         test_int(it.count, 1);
         
         test_assert(it.entities[0] == ai);
@@ -2507,8 +2507,8 @@ void Alerts_retained_alert_w_dead_source(void) {
         test_assert(source != NULL);
         test_int(source->entity, e1);
 
-        test_bool(ecs_filter_next(&it), false);
-        ecs_filter_fini(alerts);
+        test_bool(ecs_query_next(&it), false);
+        ecs_query_fini(alerts);
     }
 
     ecs_delete(world, e1);
@@ -2529,18 +2529,18 @@ void Alerts_alert_counts(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Position);
 
     ecs_entity_t alert_1 = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity"
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity"
     });
     test_assert(alert_1 != 0);
 
     ecs_entity_t alert_2 = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_mass"),
-        .filter.expr = "Position, !Mass",
+        .entity = ecs_entity(world, { .name = "position_without_mass" }),
+        .query.expr = "Position, !Mass",
         .severity = EcsAlertWarning
     });
     test_assert(alert_2 != 0);
diff --git a/test/addons/src/Doc.c b/test/addons/src/Doc.c
index 7e3f1fa8a..a1d00d549 100644
--- a/test/addons/src/Doc.c
+++ b/test/addons/src/Doc.c
@@ -3,7 +3,7 @@
 void Doc_get_set_name(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_doc_set_name(world, e, "Human readable name");
 
@@ -66,7 +66,7 @@ void Doc_get_set_link(void) {
 void Doc_set_name_nullptr(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_doc_set_name(world, e, "foo");
     test_assert( ecs_has_pair(world, e, ecs_id(EcsDocDescription), EcsName));
@@ -80,7 +80,7 @@ void Doc_set_name_nullptr(void) {
 void Doc_set_brief_nullptr(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_doc_set_brief(world, e, "foo");
     test_assert( ecs_has_pair(world, e, ecs_id(EcsDocDescription), EcsDocBrief));
@@ -94,7 +94,7 @@ void Doc_set_brief_nullptr(void) {
 void Doc_set_detail_nullptr(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_doc_set_detail(world, e, "foo");
     test_assert( ecs_has_pair(world, e, ecs_id(EcsDocDescription), EcsDocDetail));
@@ -108,7 +108,7 @@ void Doc_set_detail_nullptr(void) {
 void Doc_set_link_nullptr(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_doc_set_link(world, e, "foo");
     test_assert( ecs_has_pair(world, e, ecs_id(EcsDocDescription), EcsDocLink));
@@ -122,7 +122,7 @@ void Doc_set_link_nullptr(void) {
 void Doc_set_color_nullptr(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_doc_set_color(world, e, "foo");
     test_assert( ecs_has_pair(world, e, ecs_id(EcsDocDescription), EcsDocColor));
diff --git a/test/addons/src/Metrics.c b/test/addons/src/Metrics.c
index 81d0bc180..9ad801fc7 100644
--- a/test/addons/src/Metrics.c
+++ b/test/addons/src/Metrics.c
@@ -21,7 +21,7 @@ void Metrics_member_gauge_1_entity(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_progress(world, 0);
     
@@ -65,8 +65,8 @@ void Metrics_member_gauge_2_entities(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
 
     ecs_progress(world, 0);
     
@@ -113,7 +113,7 @@ void Metrics_member_gauge_2_entities_1_existing(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_entity_t m = ecs_metric(world, {
         .entity = ecs_entity(world, { .name = "metrics.position_y" }),
@@ -122,7 +122,7 @@ void Metrics_member_gauge_2_entities_1_existing(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
 
     ecs_progress(world, 0);
     
@@ -176,8 +176,8 @@ void Metrics_member_gauge_2_entities_update(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
 
     ecs_progress(world, 0);
     
@@ -265,8 +265,8 @@ void Metrics_member_gauge_w_remove(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
     ecs_add(world, e1, Foo);
     ecs_add(world, e2, Foo);
 
@@ -344,8 +344,8 @@ void Metrics_member_gauge_w_clear(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
     ecs_add(world, e1, Foo);
     ecs_add(world, e2, Foo);
 
@@ -423,8 +423,8 @@ void Metrics_member_gauge_w_delete(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
     ecs_add(world, e1, Foo);
     ecs_add(world, e2, Foo);
 
@@ -493,7 +493,7 @@ void Metrics_id_gauge_1_entity(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
 
     ecs_progress(world, 0);
     
@@ -529,8 +529,8 @@ void Metrics_id_gauge_2_entities(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
 
     ecs_progress(world, 0);
     
@@ -569,7 +569,7 @@ void Metrics_id_gauge_2_entities_1_existing(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
 
     ecs_entity_t m = ecs_metric(world, {
         .entity = ecs_entity(world, { .name = "metrics.has_foo" }),
@@ -578,7 +578,7 @@ void Metrics_id_gauge_2_entities_1_existing(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e2 = ecs_new(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
 
     ecs_progress(world, 0);
     
@@ -625,8 +625,8 @@ void Metrics_id_gauge_w_remove(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
     ecs_add(world, e1, Bar);
     ecs_add(world, e2, Bar);
 
@@ -696,8 +696,8 @@ void Metrics_id_gauge_w_clear(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
     ecs_add(world, e1, Bar);
     ecs_add(world, e2, Bar);
 
@@ -767,8 +767,8 @@ void Metrics_id_gauge_w_delete(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
     ecs_add(world, e1, Bar);
     ecs_add(world, e2, Bar);
 
@@ -847,7 +847,7 @@ void Metrics_oneof_gauge_3_entities(void) {
 
     ecs_progress(world, 0);
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_childof(m) },
             { .id = ecs_pair(EcsMetric, EcsGauge) }
@@ -855,8 +855,8 @@ void Metrics_oneof_gauge_3_entities(void) {
     });
     test_assert(f != NULL);
 
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    test_bool(true, ecs_filter_next(&it));
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
     test_uint(it.count, 3);
     {
         ecs_entity_t e = it.entities[0];
@@ -891,9 +891,9 @@ void Metrics_oneof_gauge_3_entities(void) {
         test_int(((double*)inst)[1], 0);
         test_int(((double*)inst)[2], 1);
     }
-    test_bool(false, ecs_filter_next(&it));
+    test_bool(false, ecs_query_next(&it));
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -922,7 +922,7 @@ void Metrics_oneof_gauge_3_entities_1_existing(void) {
 
     ecs_progress(world, 0);
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_childof(m) },
             { .id = ecs_pair(EcsMetric, EcsGauge) }
@@ -930,8 +930,8 @@ void Metrics_oneof_gauge_3_entities_1_existing(void) {
     });
     test_assert(f != NULL);
 
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    test_bool(true, ecs_filter_next(&it));
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
     test_uint(it.count, 3);
     {
         ecs_entity_t e = it.entities[0];
@@ -966,9 +966,9 @@ void Metrics_oneof_gauge_3_entities_1_existing(void) {
         test_int(((double*)inst)[1], 0);
         test_int(((double*)inst)[2], 1);
     }
-    test_bool(false, ecs_filter_next(&it));
+    test_bool(false, ecs_query_next(&it));
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -1000,7 +1000,7 @@ void Metrics_oneof_gauge_w_remove(void) {
     
     ecs_progress(world, 0);
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_childof(m) },
             { .id = ecs_pair(EcsMetric, EcsGauge) }
@@ -1009,8 +1009,8 @@ void Metrics_oneof_gauge_w_remove(void) {
     test_assert(f != NULL);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 3);
         {
             ecs_entity_t e = it.entities[0];
@@ -1045,15 +1045,15 @@ void Metrics_oneof_gauge_w_remove(void) {
             test_int(((double*)inst)[1], 0);
             test_int(((double*)inst)[2], 1);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_remove_pair(world, e2, Color, EcsWildcard);
     ecs_progress(world, 0);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 2);
         {
             ecs_entity_t e = it.entities[0];
@@ -1077,10 +1077,10 @@ void Metrics_oneof_gauge_w_remove(void) {
             test_int(((double*)inst)[1], 0);
             test_int(((double*)inst)[2], 1);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -1112,7 +1112,7 @@ void Metrics_oneof_gauge_w_clear(void) {
     
     ecs_progress(world, 0);
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_childof(m) },
             { .id = ecs_pair(EcsMetric, EcsGauge) }
@@ -1121,8 +1121,8 @@ void Metrics_oneof_gauge_w_clear(void) {
     test_assert(f != NULL);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 3);
         {
             ecs_entity_t e = it.entities[0];
@@ -1157,15 +1157,15 @@ void Metrics_oneof_gauge_w_clear(void) {
             test_int(((double*)inst)[1], 0);
             test_int(((double*)inst)[2], 1);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_clear(world, e2);
     ecs_progress(world, 0);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 2);
         {
             ecs_entity_t e = it.entities[0];
@@ -1189,10 +1189,10 @@ void Metrics_oneof_gauge_w_clear(void) {
             test_int(((double*)inst)[1], 0);
             test_int(((double*)inst)[2], 1);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -1224,7 +1224,7 @@ void Metrics_oneof_gauge_w_delete(void) {
     
     ecs_progress(world, 0);
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_childof(m) },
             { .id = ecs_pair(EcsMetric, EcsGauge) }
@@ -1233,8 +1233,8 @@ void Metrics_oneof_gauge_w_delete(void) {
     test_assert(f != NULL);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 3);
         {
             ecs_entity_t e = it.entities[0];
@@ -1269,15 +1269,15 @@ void Metrics_oneof_gauge_w_delete(void) {
             test_int(((double*)inst)[1], 0);
             test_int(((double*)inst)[2], 1);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_delete(world, e2);
     ecs_progress(world, 0);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 2);
         {
             ecs_entity_t e = it.entities[0];
@@ -1301,10 +1301,10 @@ void Metrics_oneof_gauge_w_delete(void) {
             test_int(((double*)inst)[1], 0);
             test_int(((double*)inst)[2], 1);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -1360,7 +1360,7 @@ void Metrics_member_counter(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_progress(world, 1.0);
     
     {
@@ -1423,7 +1423,7 @@ void Metrics_member_auto_counter(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_progress(world, 1.0);
     
     {
@@ -1478,7 +1478,7 @@ void Metrics_id_counter(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
 
     ecs_progress(world, 1.0);
 
@@ -1542,7 +1542,7 @@ void Metrics_oneof_counter(void) {
 
     ecs_progress(world, 1.0);
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_childof(m) },
             { .id = ecs_pair(EcsMetric, EcsCounter) }
@@ -1551,8 +1551,8 @@ void Metrics_oneof_counter(void) {
     test_assert(f != NULL);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 1);
         {
             ecs_entity_t e = it.entities[0];
@@ -1565,15 +1565,15 @@ void Metrics_oneof_counter(void) {
             test_int(((double*)inst)[1], 0);
             test_int(((double*)inst)[2], 0);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, Color, Green);
     ecs_progress(world, 1.0);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 1);
         {
             ecs_entity_t e = it.entities[0];
@@ -1586,15 +1586,15 @@ void Metrics_oneof_counter(void) {
             test_int(((double*)inst)[1], 1);
             test_int(((double*)inst)[2], 0);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, Color, Blue);
     ecs_progress(world, 1.0);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 1);
         {
             ecs_entity_t e = it.entities[0];
@@ -1607,14 +1607,14 @@ void Metrics_oneof_counter(void) {
             test_int(((double*)inst)[1], 1);
             test_int(((double*)inst)[2], 1);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_progress(world, 1.0);
 
     {
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_bool(true, ecs_filter_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_bool(true, ecs_query_next(&it));
         test_uint(it.count, 1);
         {
             ecs_entity_t e = it.entities[0];
@@ -1627,10 +1627,10 @@ void Metrics_oneof_counter(void) {
             test_int(((double*)inst)[1], 1);
             test_int(((double*)inst)[2], 2);
         }
-        test_bool(false, ecs_filter_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -1660,7 +1660,7 @@ void Metrics_metric_description(void) {
 
     test_str(ecs_doc_get_brief(world, m), "Position y");
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_progress(world, 0);
     
@@ -1697,7 +1697,7 @@ void Metrics_id_count(void) {
     });
     test_assert(m != 0);
 
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_progress(world, 1);
 
@@ -1707,8 +1707,8 @@ void Metrics_id_count(void) {
         test_int(v->value, 1);
     }
 
-    ecs_set(world, 0, Position, {10, 20});
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_progress(world, 1);
 
@@ -1739,12 +1739,12 @@ void Metrics_id_target_count(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_pair(world, e1, Color, Red);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_pair(world, e2, Color, Green);
     ecs_add_pair(world, e2, Color, Blue);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e3 = ecs_new(world);
     ecs_add_pair(world, e3, Color, Blue);
 
     ecs_progress(world, 1);
@@ -1797,7 +1797,7 @@ void Metrics_metric_instance_has_doc_name(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
     ecs_progress(world, 0);
@@ -1864,7 +1864,7 @@ void Metrics_metric_nested_member(void) {
 
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, {20, 30}});
 
     ecs_progress(world, 0);
@@ -1931,7 +1931,7 @@ void Metrics_metric_nested_member_counter(void) {
 
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, {20, 30}});
 
     ecs_progress(world, 0);
@@ -1998,7 +1998,7 @@ void Metrics_metric_nested_member_counter_increment(void) {
 
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, {20, 30}});
 
     ecs_progress(world, 1);
@@ -2070,7 +2070,7 @@ void Metrics_id_w_member_same_type(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_progress(world, 0);
     
@@ -2144,7 +2144,7 @@ void Metrics_pair_member_rel_type(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set_pair(world, 0, Position, Foo, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value_pair(Position, Foo, {10, 20}));
     ecs_set_pair(world, e1, Position, Bar, {1, 2});
 
     ecs_progress(world, 0);
@@ -2192,8 +2192,9 @@ void Metrics_pair_member_tgt_type(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set_pair_second(world, 0, Foo, Position, {10, 20});
-    ecs_set_pair_second(world, e1, Bar, Position, {1, 2});
+    ecs_entity_t e1 = ecs_insert(world, 
+        ecs_value_pair_2nd(Foo, Position, {10, 20}),
+        ecs_value_pair_2nd(Bar, Position, {1, 2}));
 
     ecs_progress(world, 0);
     
@@ -2258,7 +2259,7 @@ void Metrics_pair_dotmember_rel_type(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set_pair(world, 0, Position, Foo, {0, {10, 20}});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value_pair(Position, Foo, {0, {10, 20}}));
     ecs_set_pair(world, e1, Position, Bar, {0, {1, 2}});
 
     ecs_progress(world, 0);
@@ -2324,8 +2325,9 @@ void Metrics_pair_dotmember_tgt_type(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set_pair_second(world, 0, Foo, Position, {0, {10, 20}});
-    ecs_set_pair_second(world, e1, Bar, Position, {0, {1, 2}});
+    ecs_entity_t e1 = ecs_insert(world, 
+        ecs_value_pair_2nd(Foo, Position, {0, {10, 20}}),
+        ecs_value_pair_2nd(Bar, Position, {0, {1, 2}}));
 
     ecs_progress(world, 0);
     
@@ -2372,7 +2374,7 @@ void Metrics_pair_member_counter_increment(void) {
     });
     test_assert(m != 0);
 
-    ecs_entity_t e1 = ecs_set_pair(world, 0, Position, Foo, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value_pair(Position, Foo, {10, 20}));
     ecs_set_pair(world, e1, Position, Bar, {1, 2});
 
     ecs_progress(world, 1);
diff --git a/test/addons/src/Modules.c b/test/addons/src/Modules.c
index de57eeebb..d2a2ebe28 100644
--- a/test/addons/src/Modules.c
+++ b/test/addons/src/Modules.c
@@ -83,7 +83,7 @@ void Modules_simple_module(void) {
 
     ECS_IMPORT(world, SimpleModule);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert( ecs_has(world, e, Position));
     
@@ -107,7 +107,7 @@ void Modules_import_module_from_system(void) {
     ECS_IMPORT(world, SimpleModule);
     ECS_SYSTEM(world, AddVtoP, EcsOnUpdate, simple.module.Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert( ecs_has(world, e, Position));
 
@@ -325,7 +325,7 @@ void Modules_module_tag_on_namespace(void) {
 void Modules_module_tag_on_namespace_on_add(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -341,7 +341,7 @@ void Modules_module_tag_on_namespace_on_add(void) {
 void Modules_module_tag_on_namespace_on_add_2_levels(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     test_assert(root != 0);
 
     ecs_entity_t parent = ecs_new_w_pair(world, EcsChildOf, root);
@@ -369,14 +369,14 @@ void Modules_import_2_worlds(void) {
     test_assert(ecs_lookup(world_2, "simple.module") != 0);
 
     {
-        ecs_entity_t e = ecs_new(world_1, Position);
+        ecs_entity_t e = ecs_new_w(world_1, Position);
         test_assert(e != 0);
         test_assert( ecs_has(world_1, e, Position));
         ecs_add(world_1, e, Velocity);
         test_assert( ecs_has(world_1, e, Velocity));
     }
     {
-        ecs_entity_t e = ecs_new(world_2, Position);
+        ecs_entity_t e = ecs_new_w(world_2, Position);
         test_assert(e != 0);
         test_assert( ecs_has(world_2, e, Position));
         ecs_add(world_2, e, Velocity);
@@ -414,7 +414,7 @@ void Modules_import_monitor_after_mini(void) {
 void Modules_component_parent_becomes_module(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t comp = ecs_new_w_pair(world, EcsChildOf, parent);
 
     test_assert(!ecs_has_id(world, parent, EcsModule));
diff --git a/test/addons/src/MultiTaskThread.c b/test/addons/src/MultiTaskThread.c
deleted file mode 100644
index 88496766c..000000000
--- a/test/addons/src/MultiTaskThread.c
+++ /dev/null
@@ -1,1384 +0,0 @@
-#include <addons.h>
-
-static ECS_COMPONENT_DECLARE(Position);
-static ECS_DECLARE(Tag);
-
-void MultiTaskThread_setup(void) {
-    ecs_log_set_level(-3);
-}
-
-void MultiTaskThread_Progress(ecs_iter_t *it) {
-    Position *pos = ecs_field(it, Position, 1);
-    int row;
-    for (row = 0; row < it->count; row ++) {
-        Position *p = &pos[row];
-        p->x ++;
-    }
-}
-
-static
-ecs_world_t* init_world(void) {
-    ecs_world_t *world = ecs_init();
-    ECS_COMPONENT_DEFINE(world, Position);
-
-    ECS_SYSTEM(world, MultiTaskThread_Progress, EcsOnUpdate, Position);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = MultiTaskThread_Progress,
-        .multi_threaded = true
-    });
-
-    return world;
-}
-
-void MultiTaskThread_2_thread_10_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 10, THREADS = 2;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_2_thread_1_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 1, THREADS = 2;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_2_thread_2_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 2, THREADS = 2;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_2_thread_5_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 5, THREADS = 2;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_3_thread_10_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 10, THREADS = 3;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_3_thread_1_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 1, THREADS = 3;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_3_thread_2_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 2, THREADS = 3;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_3_thread_5_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 5, THREADS = 3;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_4_thread_10_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 10, THREADS = 4;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_4_thread_1_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 1, THREADS = 4;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_4_thread_2_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 2, THREADS = 4;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_4_thread_5_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 5, THREADS = 4;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_5_thread_10_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 10, THREADS = 5;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_5_thread_1_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 1, THREADS = 5;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_5_thread_2_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 2, THREADS = 5;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_5_thread_5_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 5, THREADS = 5;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_6_thread_10_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 10, THREADS = 6;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_6_thread_1_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 1, THREADS = 6;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-
-void MultiTaskThread_6_thread_2_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 2, THREADS = 6;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_6_thread_5_entity(void) {
-    ecs_world_t *world = init_world();
-
-    int i, ENTITIES = 5, THREADS = 6;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_2_thread_1_entity_instanced(void) {
-    ecs_world_t *world = ecs_init();
-    ECS_COMPONENT_DEFINE(world, Position);
-
-    ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
-        .callback = MultiTaskThread_Progress,
-        .query.filter = {
-            .expr = "Position",
-            .instanced = true
-        },
-        .multi_threaded = true
-    });
-    test_assert(s != 0);
-
-    int i, ENTITIES = 1, THREADS = 2;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_2_thread_5_entity_instanced(void) {
-    ecs_world_t *world = ecs_init();
-    ECS_COMPONENT_DEFINE(world, Position);
-
-    ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
-        .callback = MultiTaskThread_Progress,
-        .query.filter = {
-            .expr = "Position",
-            .instanced = true
-        },
-        .multi_threaded = true
-    });
-    test_assert(s != 0);
-
-    int i, ENTITIES = 5, THREADS = 2;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_2_thread_10_entity_instanced(void) {
-    ecs_world_t *world = ecs_init();
-    ECS_COMPONENT_DEFINE(world, Position);
-
-    ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
-        .callback = MultiTaskThread_Progress,
-        .query.filter = {
-            .expr = "Position",
-            .instanced = true
-        },
-        .multi_threaded = true
-    });
-    test_assert(s != 0);
-
-    int i, ENTITIES = 10, THREADS = 2;
-    ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
-        ecs_set(world, handles[i], Position, {0});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 1);
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        test_int(ecs_get(world, handles[i], Position)->x, 2);
-    }
-
-    ecs_fini(world);
-}
-
-typedef struct Param {
-    ecs_entity_t entity;
-    int count;
-} Param;
-
-static
-void TestSubset(ecs_iter_t *it) {
-    Param *param = it->param;
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        test_assert(param->entity != it->entities[i]);
-        param->count ++;
-    }    
-}
-
-static
-void TestAll(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-
-    ecs_entity_t TestSubset = ecs_field_id(it, 2);
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        Param param = {.entity = it->entities[i], 0};
-        ecs_run_w_filter(it->world, TestSubset, 1, it->frame_offset + i + 1, 0, &param);
-        p[i].x += param.count;
-    }
-}
-
-static
-void test_combs_100_entity(int THREADS) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-
-    ECS_SYSTEM(world, TestSubset, 0, Position);
-    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position, TestSubset());
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = TestAll,
-        .multi_threaded = true
-    });
-
-    int i, ENTITIES = 100;
-
-    const ecs_entity_t *ids = ecs_bulk_new(world, Position, ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        ecs_set(world, ids[i], Position, {1, 2});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        const Position *p = ecs_get(world, ids[i], Position);
-        test_int(p->x, ENTITIES - i);
-    }
-
-    ecs_fini(world);    
-}
-
-void MultiTaskThread_2_thread_test_combs_100_entity_w_next_worker(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-
-    ECS_SYSTEM(world, TestSubset, 0, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, TestSubset()");
-
-    int i, ENTITIES = 100;
-
-    const ecs_entity_t *ids = ecs_bulk_new(world, Position, ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        ecs_set(world, ids[i], Position, {1, 2});
-    }
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    ecs_iter_t wit = ecs_worker_iter(&it, 0, 2);
-    while (ecs_worker_next(&wit)) {
-        TestAll(&wit);
-    }
-
-    it = ecs_query_iter(world, q);
-    wit = ecs_worker_iter(&it, 1, 2);
-    while (ecs_worker_next(&wit)) {
-        TestAll(&wit);
-    }
-
-    for (i = 0; i < ENTITIES; i ++) {
-        const Position *p = ecs_get(world, ids[i], Position);
-        test_int(p->x, ENTITIES - i);
-    }
-
-    ecs_fini(world); 
-}
-
-void MultiTaskThread_2_thread_test_combs_100_entity(void) {
-    test_combs_100_entity(2);
-}
-
-void MultiTaskThread_3_thread_test_combs_100_entity(void) {
-    test_combs_100_entity(3);
-}
-
-void MultiTaskThread_4_thread_test_combs_100_entity(void) {
-    test_combs_100_entity(4);
-}
-
-void MultiTaskThread_5_thread_test_combs_100_entity(void) {
-    test_combs_100_entity(5);
-}
-
-void MultiTaskThread_6_thread_test_combs_100_entity(void) {
-    test_combs_100_entity(6);
-}
-
-static
-void test_combs_100_entity_2_types(int THREADS) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_PREFAB(world, Type, Position, Velocity);
-
-    ECS_SYSTEM(world, TestSubset, 0, Position);
-    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position, TestSubset());
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = TestAll,
-        .multi_threaded = true
-    });
-
-    int i, ENTITIES = 100;
-
-    const ecs_entity_t *temp_ids_1 = ecs_bulk_new(world, Position, ENTITIES / 2);
-    ecs_entity_t ids_1[50];
-    memcpy(ids_1, temp_ids_1, sizeof(ecs_entity_t) * ENTITIES / 2);
-    const ecs_entity_t *ids_2 = bulk_new_w_type(world, Type, ENTITIES / 2);
-
-    for (i = 0; i < ENTITIES / 2; i ++) {
-        ecs_set(world, ids_1[i], Position, {1, 2});
-        ecs_set(world, ids_2[i], Position, {1, 2});
-    }
-
-    ecs_set_task_threads(world, THREADS);
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES / 2; i ++) {
-        const Position *p = ecs_get(world, ids_1[i], Position);
-        test_int(p->x, ENTITIES - i);
-
-        p = ecs_get(world, ids_2[i], Position);
-        test_int(p->x, ENTITIES - (i + ENTITIES / 2));
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_2_thread_test_combs_100_entity_2_types(void) {
-    test_combs_100_entity_2_types(2);
-}
-
-void MultiTaskThread_3_thread_test_combs_100_entity_2_types(void) {
-    test_combs_100_entity_2_types(3);
-}
-
-void MultiTaskThread_4_thread_test_combs_100_entity_2_types(void) {
-    test_combs_100_entity_2_types(4);
-}
-
-void MultiTaskThread_5_thread_test_combs_100_entity_2_types(void) {
-    test_combs_100_entity_2_types(5);
-}
-
-void MultiTaskThread_6_thread_test_combs_100_entity_2_types(void) {
-    test_combs_100_entity_2_types(6);
-}
-
-void MultiTaskThread_change_thread_count(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_PREFAB(world, Type, Position, Velocity);
-
-    ECS_SYSTEM(world, TestSubset, 0, Position);
-    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position, TestSubset());
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = TestAll,
-        .multi_threaded = true
-    });
-
-    int i, ENTITIES = 100;
-
-    const ecs_entity_t *temp_ids_1 = ecs_bulk_new(world, Position, ENTITIES / 2);
-    ecs_entity_t ids_1[50];
-    memcpy(ids_1, temp_ids_1, sizeof(ecs_entity_t) * ENTITIES / 2);
-    const ecs_entity_t *ids_2 = bulk_new_w_type(world, Type, ENTITIES / 2);
-
-    for (i = 0; i < ENTITIES / 2; i ++) {
-        ecs_set(world, ids_1[i], Position, {1, 2});
-        ecs_set(world, ids_2[i], Position, {1, 2});
-    }
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES / 2; i ++) {
-        Position *p = ecs_ensure(world, ids_1[i], Position);
-        test_int(p->x, ENTITIES - i);
-        p->x = 1;
-
-        p = ecs_ensure(world, ids_2[i], Position);
-        test_int(p->x, ENTITIES - (i + ENTITIES / 2));
-        p->x = 1;
-    }
-
-    ecs_set_task_threads(world, 3);
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES / 2; i ++) {
-        const Position *p = ecs_get(world, ids_1[i], Position);
-        test_int(p->x, ENTITIES - i);
-
-        p = ecs_get(world, ids_2[i], Position);
-        test_int(p->x, ENTITIES - (i + ENTITIES / 2));
-    }    
-
-    ecs_fini(world);
-}
-
-static
-void QuitSystem(ecs_iter_t *it) {
-    ecs_quit(it->world);
-}
-
-void MultiTaskThread_multithread_quit(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-
-    ECS_SYSTEM(world, QuitSystem, EcsOnUpdate, Position);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = QuitSystem,
-        .multi_threaded = true
-    });
-
-    ecs_bulk_new(world, Position, 100);
-
-    ecs_set_task_threads(world, 2);
-
-    test_assert( ecs_progress(world, 0) == 0);
-
-    ecs_fini(world);
-}
-
-static bool has_ran = false;
-
-static
-void MtTask(ecs_iter_t *it) {
-    has_ran = true;
-}
-
-void MultiTaskThread_schedule_w_tasks(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_SYSTEM(world, MtTask, EcsOnUpdate, 0);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = MtTask,
-        .multi_threaded = true
-    });
-
-    ecs_set_task_threads(world, 2);
-
-    test_assert( ecs_progress(world, 0) != 0);
-
-    test_assert( has_ran == true);
-
-    ecs_fini(world);
-}
-
-static
-void ReactiveDummySystem(ecs_iter_t * it) {
-    has_ran = true;
-}
-
-static
-void PeriodicDummySystem(ecs_iter_t * it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
-    
-    int i;
-    for (i = 0; i < it->count; i++ ) {
-        ecs_set(it->world, it->entities[i], Position, {0});
-    }
-}
-
-void MultiTaskThread_reactive_system(void) {    
-    ecs_world_t * world = ecs_init();
-
-    ECS_COMPONENT_DEFINE(world, Position);        
-    ECS_SYSTEM(world, PeriodicDummySystem, EcsOnUpdate, Position);
-    ECS_OBSERVER(world, ReactiveDummySystem, EcsOnSet, Position);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = PeriodicDummySystem,
-        .multi_threaded = true
-    });
-
-    ecs_bulk_new(world, Position, 2);
-    ecs_set_task_threads(world, 2);
-
-    test_assert(has_ran == false);
-
-    ecs_progress(world, 0);
-
-    test_assert(has_ran == true);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_fini_after_set_threads(void) {
-    ecs_world_t * world = ecs_init();
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_fini(world);
-
-    // Make sure code doesn't crash
-    test_assert(true);
-}
-
-static
-void SingleThreadedSystem(ecs_iter_t * it) {
-    Position *p = ecs_field(it, Position, 1);
-    
-    int i;
-    for (i = 0; i < it->count; i++ ) {
-        p[i].x ++;
-        p[i].y ++;
-    }
-}
-
-void MultiTaskThread_2_threads_single_threaded_system(void) {
-    ecs_world_t * world = ecs_init();
-
-    ECS_COMPONENT_DEFINE(world, Position);        
-    ECS_SYSTEM(world, SingleThreadedSystem, EcsOnUpdate, Position);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = SingleThreadedSystem,
-        .multi_threaded = false
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_progress(world, 0);
-
-    const Position *p = ecs_get(world, e1, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 11);
-    test_int(p->y, 21);
-
-    p = ecs_get(world, e2, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 21);
-    test_int(p->y, 31);
-
-    ecs_fini(world);
-}
-
-static int create_query_invoked = 0;
-
-static
-void CreateQuery(ecs_iter_t *it) {
-    ecs_query_new(it->world, "0");
-    create_query_invoked ++;
-}
-
-void MultiTaskThread_no_staging_w_multithread(void) {
-    for (int i = 0; i < 10; i ++) {
-        ecs_world_t *world = ecs_init();
-
-        ecs_set_task_threads(world, 32);
-
-        ecs_system_init(world, &(ecs_system_desc_t){
-            .callback = CreateQuery,
-            .no_readonly = true,
-            .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}})
-        });
-
-        create_query_invoked = 0;
-        ecs_progress(world, 0);
-        test_int(create_query_invoked, 1);
-
-        ecs_fini(world);
-    }
-
-    test_assert(true);
-}
-
-void MultiTaskThread_multithread_w_monitor_addon(void) {
-    ecs_world_t *world = ecs_init();
-    ECS_IMPORT(world, FlecsMonitor);
-    ecs_set_task_threads(world, 4);
-    ecs_progress(world, 0);
-    ecs_fini(world);
-
-    /* Make sure monitor could be run in multithreaded mode */
-    test_assert(true);
-}
-
-static int system_ctx = 0;
-
-static
-void System_w_ctx(ecs_iter_t *it) {
-    test_assert(it->ctx == &system_ctx);
-    test_assert(it->system != 0);
-    test_assert(it->delta_time != 0);
-    system_ctx ++;
-}
-
-static
-void System_run_w_ctx(ecs_iter_t *it) {
-    System_w_ctx(it);
-    ecs_iter_fini(it);
-}
-
-static
-void System_w_binding_ctx(ecs_iter_t *it) {
-    test_assert(it->binding_ctx == &system_ctx);
-    test_assert(it->system != 0);
-    test_assert(it->delta_time != 0);
-    system_ctx ++;
-}
-
-static
-void System_run_w_binding_ctx(ecs_iter_t *it) {
-    System_w_binding_ctx(it);
-    ecs_iter_fini(it);
-}
-
-void MultiTaskThread_get_ctx(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) } }),
-        .callback = System_w_ctx,
-        .multi_threaded = true,
-        .ctx = &system_ctx
-    });
-
-    ecs_progress(world, 0);
-
-    test_assert(system_ctx != 0);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_get_binding_ctx(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) } }),
-        .callback = System_w_binding_ctx,
-        .multi_threaded = true,
-        .binding_ctx = &system_ctx
-    });
-
-    ecs_progress(world, 0);
-
-    test_assert(system_ctx != 0);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_get_ctx_w_run(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) } }),
-        .run = System_run_w_ctx,
-        .multi_threaded = true,
-        .ctx = &system_ctx
-    });
-
-    ecs_progress(world, 0);
-
-    test_assert(system_ctx != 0);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_get_binding_ctx_w_run(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) } }),
-        .run = System_run_w_binding_ctx,
-        .multi_threaded = true,
-        .binding_ctx = &system_ctx
-    });
-
-    ecs_progress(world, 0);
-
-    test_assert(system_ctx != 0);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_sys(ecs_iter_t *it) { }
-
-void MultiTaskThread_sys_bulk_init(ecs_iter_t *it) {
-    ecs_bulk_init(it->world, &(ecs_bulk_desc_t){
-        .count = 10,
-        .ids = {Tag}
-    });
-}
-
-void MultiTaskThread_bulk_new_in_no_readonly_w_multithread(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG_DEFINE(world, Tag);
-
-    ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
-        .no_readonly = true,
-        .callback = MultiTaskThread_sys_bulk_init
-    });
-
-    ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
-        .multi_threaded = true,
-        .callback = MultiTaskThread_sys
-    });
-
-    ecs_set_task_threads(world, 80);
-
-    for (int i = 0; i < 100; i ++) {
-        ecs_progress(world, 0);
-    }
-
-    test_int(ecs_count(world, Tag), 100 * 10);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_sys_bulk_init_2(ecs_iter_t *it) {
-    ecs_bulk_init(it->world, &(ecs_bulk_desc_t){
-        .count = 1,
-        .ids = {ecs_id(Position)}
-    });
-
-    ecs_iter_t qit = ecs_query_iter(it->world, it->ctx);
-    ecs_iter_fini(&qit);
-}
-
-void MultiTaskThread_bulk_new_in_no_readonly_w_multithread_2(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-
-    ecs_set_task_threads(world, 64);
-
-    ecs_system(world, {
-        .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
-        }),
-        .query.filter.terms = {{ ecs_id(Position) }},
-        .callback = MultiTaskThread_sys
-    });
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_system(world, {
-        .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
-        }),
-        .callback = MultiTaskThread_sys_bulk_init_2,
-        .no_readonly = true,
-        .ctx = q
-    });
-
-    ecs_system(world, {
-        .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
-        }),
-        .callback = MultiTaskThread_sys
-    });
-
-    ecs_progress(world, 0);
-
-    test_int(ecs_count(world, Position), 1);
-
-    ecs_fini(world);
-}
-
-static ecs_os_thread_id_t main_thread;
-static int invoked_count = 0;
-static int invoked_main_count = 0;
-
-static void dummy(ecs_iter_t *it) {
-    int stage_id = ecs_get_stage_id(it->world);
-
-    if (stage_id == 0) {
-        test_assert(main_thread == ecs_os_thread_self());
-        ecs_os_ainc(&invoked_main_count);
-    } else {
-        test_assert(main_thread != ecs_os_thread_self());
-    }
-
-    ecs_os_ainc(&invoked_count);
-}
-
-void MultiTaskThread_run_first_worker_on_main(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
-        .multi_threaded = true,
-        .callback = dummy
-    });
-
-    ecs_set_task_threads(world, 3);
-
-    main_thread = ecs_os_thread_self();
-
-    ecs_progress(world, 0);
-
-    test_int(invoked_count, 3);
-    test_int(invoked_main_count, 1);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThread_run_single_thread_on_main(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
-        .multi_threaded = false,
-        .callback = dummy
-    });
-
-    ecs_set_task_threads(world, 3);
-
-    main_thread = ecs_os_thread_self();
-
-    ecs_progress(world, 0);
-
-    test_int(invoked_count, 1);
-    test_int(invoked_main_count, 1);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/MultiTaskThreadStaging.c b/test/addons/src/MultiTaskThreadStaging.c
deleted file mode 100644
index bdb789d9e..000000000
--- a/test/addons/src/MultiTaskThreadStaging.c
+++ /dev/null
@@ -1,613 +0,0 @@
-#include <addons.h>
-
-void MultiTaskThreadStaging_setup(void) {
-    ecs_log_set_level(-3);
-}
-
-static
-void MultiTaskThread_Add_to_current(ecs_iter_t *it) {
-    IterData *ctx = ecs_get_ctx(it->world);
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        if (ctx->component) {
-            ecs_add_id(it->world, it->entities[i], ctx->component);
-        }
-
-        if (ctx->component_2) {
-            ecs_add_id(it->world, it->entities[i], ctx->component_2);
-        }
-
-        ctx->entity_count ++;
-    }
-}
-
-void MultiTaskThreadStaging_2_threads_add_to_current(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Rotation);
-    ECS_PREFAB(world, Type, Position, Velocity);
-
-    ECS_SYSTEM(world, MultiTaskThread_Add_to_current, EcsOnUpdate, Position);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = MultiTaskThread_Add_to_current,
-        .multi_threaded = true
-    });
-
-    IterData ctx = {.component = ecs_id(Rotation)};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    ecs_entity_t ids_1[100];
-    const ecs_entity_t *temp_ids_1 = ecs_bulk_new(world, Position, 100);
-    memcpy(ids_1, temp_ids_1, sizeof(ecs_entity_t) * 100);
-
-    const ecs_entity_t *ids_2 = bulk_new_w_type(world, Type, 100);
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_progress(world, 1);
-
-    int i;
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_1[i], Position));
-        test_assert( ecs_has(world, ids_1[i], Rotation));
-        test_assert( !ecs_has(world, ids_1[i], Velocity));
-    }
-
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_2[i], Position));
-        test_assert( ecs_has(world, ids_2[i], Rotation));
-        test_assert( ecs_has(world, ids_2[i], Velocity));
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_3_threads_add_to_current(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Rotation);
-    ECS_PREFAB(world, Type, Position, Velocity);
-
-    ECS_SYSTEM(world, MultiTaskThread_Add_to_current, EcsOnUpdate, Position);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = MultiTaskThread_Add_to_current,
-        .multi_threaded = true
-    });
-
-    IterData ctx = {.component = ecs_id(Rotation)};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    ecs_entity_t ids_1[100];
-    const ecs_entity_t *temp_ids_1 = ecs_bulk_new(world, Position, 100);
-    memcpy(ids_1, temp_ids_1, sizeof(ecs_entity_t) * 100);
-
-    const ecs_entity_t *ids_2 = bulk_new_w_type(world, Type, 100);
-
-    ecs_set_task_threads(world, 3);
-
-    ecs_progress(world, 1);
-
-    int i;
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_1[i], Position));
-        test_assert( ecs_has(world, ids_1[i], Rotation));
-        test_assert( !ecs_has(world, ids_1[i], Velocity));
-    }
-
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_2[i], Position));
-        test_assert( ecs_has(world, ids_2[i], Rotation));
-        test_assert( ecs_has(world, ids_2[i], Velocity));
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_4_threads_add_to_current(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Rotation);
-    ECS_PREFAB(world, Type, Position, Velocity);
-
-    ECS_SYSTEM(world, MultiTaskThread_Add_to_current, EcsOnUpdate, Position);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = MultiTaskThread_Add_to_current,
-        .multi_threaded = true
-    });
-
-    IterData ctx = {.component = ecs_id(Rotation)};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    ecs_entity_t ids_1[100];
-    const ecs_entity_t *temp_ids_1 = ecs_bulk_new(world, Position, 100);
-    memcpy(ids_1, temp_ids_1, sizeof(ecs_entity_t) * 100);
-
-    const ecs_entity_t *ids_2 = bulk_new_w_type(world, Type, 100);
-
-    ecs_set_task_threads(world, 4);
-
-    ecs_progress(world, 1);
-
-    int i;
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_1[i], Position));
-        test_assert( ecs_has(world, ids_1[i], Rotation));
-        test_assert( !ecs_has(world, ids_1[i], Velocity));
-    }
-
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_2[i], Position));
-        test_assert( ecs_has(world, ids_2[i], Rotation));
-        test_assert( ecs_has(world, ids_2[i], Velocity));
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_5_threads_add_to_current(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Rotation);
-    ECS_PREFAB(world, Type, Position, Velocity);
-
-    ECS_SYSTEM(world, MultiTaskThread_Add_to_current, EcsOnUpdate, Position);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = MultiTaskThread_Add_to_current,
-        .multi_threaded = true
-    });
-
-    IterData ctx = {.component = ecs_id(Rotation)};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    ecs_entity_t ids_1[100];
-    const ecs_entity_t *temp_ids_1 = ecs_bulk_new(world, Position, 100);
-    memcpy(ids_1, temp_ids_1, sizeof(ecs_entity_t) * 100);
-
-    const ecs_entity_t *ids_2 = bulk_new_w_type(world, Type, 100);
-
-    ecs_set_task_threads(world, 5);
-
-    ecs_progress(world, 1);
-
-    int i;
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_1[i], Position));
-        test_assert( ecs_has(world, ids_1[i], Rotation));
-        test_assert( !ecs_has(world, ids_1[i], Velocity));
-    }
-
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_2[i], Position));
-        test_assert( ecs_has(world, ids_2[i], Rotation));
-        test_assert( ecs_has(world, ids_2[i], Velocity));
-    }
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_6_threads_add_to_current(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Rotation);
-    ECS_PREFAB(world, Type, Position, Velocity);
-
-    ECS_SYSTEM(world, MultiTaskThread_Add_to_current, EcsOnUpdate, Position);
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = MultiTaskThread_Add_to_current,
-        .multi_threaded = true
-    });
-
-    IterData ctx = {.component = ecs_id(Rotation)};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    ecs_entity_t ids_1[100];
-    const ecs_entity_t *temp_ids_1 = ecs_bulk_new(world, Position, 100);
-    memcpy(ids_1, temp_ids_1, sizeof(ecs_entity_t) * 100);
-
-    const ecs_entity_t *ids_2 = bulk_new_w_type(world, Type, 100);
-
-    ecs_set_task_threads(world, 6);
-
-    ecs_progress(world, 1);
-
-    int i;
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_1[i], Position));
-        test_assert( ecs_has(world, ids_1[i], Rotation));
-        test_assert( !ecs_has(world, ids_1[i], Velocity));
-    }
-
-    for (i = 0; i < 100; i ++) {
-        test_assert( ecs_has(world, ids_2[i], Position));
-        test_assert( ecs_has(world, ids_2[i], Rotation));
-        test_assert( ecs_has(world, ids_2[i], Velocity));
-    }
-
-    ecs_fini(world);
-}
-
-static
-void InitVelocity(ecs_iter_t *it) {
-    Velocity *v = ecs_field(it, Velocity, 1);
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        v[i].x = 10;
-        v[i].y = 20;
-    }
-}
-
-static
-void AddVelocity(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        ecs_add(it->world, it->entities[i], Velocity);
-    }
-}
-
-void MultiTaskThreadStaging_2_threads_on_add(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ECS_OBSERVER(world, InitVelocity, EcsOnAdd, Velocity);
-    ECS_SYSTEM(world, AddVelocity, EcsOnUpdate, Position, Velocity());
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = AddVelocity,
-        .multi_threaded = true
-    });
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    const ecs_entity_t *ids = ecs_bulk_new(world, Position, 10);
-    test_assert(ids != NULL);
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_progress(world, 0);
-
-    int i;
-    for (i = 0; i < 10; i ++) {
-        ecs_entity_t e = ids[i];
-        test_assert( ecs_has(world, e, Velocity));
-        const Velocity *v = ecs_get(world, e, Velocity);
-        test_assert(v != NULL);
-        test_int(v->x, 10);
-        test_int(v->y, 20);
-    }
-
-    ecs_fini(world);
-}
-
-static
-void New_w_count(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
-
-    ecs_bulk_new(it->world, Position, 10);
-}
-
-void MultiTaskThreadStaging_new_w_count(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_SYSTEM(world, New_w_count, EcsOnUpdate, Position());
-
-    ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = New_w_count,
-        .multi_threaded = true
-    });
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_progress(world, 0);
-
-    test_int( ecs_count(world, Position), 10);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_custom_thread_auto_merge(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_set_stage_count(world, 2);
-
-    ecs_world_t *ctx_1 = ecs_get_stage(world, 0);
-    ecs_world_t *ctx_2 = ecs_get_stage(world, 1);
-
-    ecs_frame_begin(world, 0);
-    ecs_readonly_begin(world, true);
-
-    /* thread 1 */
-    ecs_defer_begin(ctx_1);
-    ecs_set(ctx_1, e1, Position, {10, 20});
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    ecs_defer_end(ctx_1);
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    
-    /* thread 2 */
-    ecs_defer_begin(ctx_2);
-    ecs_set(ctx_2, e2, Position, {20, 30});
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-    ecs_defer_end(ctx_2);
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-
-    ecs_readonly_end(world);
-    ecs_frame_end(world);
-
-    test_assert(ecs_has(world, e1, Position));
-    test_assert(ecs_has(world, e2, Position));
-
-    const Position *p1 = ecs_get(world, e1, Position);
-    test_int(p1->x, 10);
-    test_int(p1->y, 20);
-
-    const Position *p2 = ecs_get(world, e2, Position);
-    test_int(p2->x, 20);
-    test_int(p2->y, 30);    
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_custom_thread_manual_merge(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_set_automerge(world, false);
-
-    ecs_set_stage_count(world, 2);
-
-    ecs_world_t *ctx_1 = ecs_get_stage(world, 0);
-    ecs_world_t *ctx_2 = ecs_get_stage(world, 1);
-
-    ecs_frame_begin(world, 0);
-    ecs_readonly_begin(world, true);
-
-    /* thread 1 */
-    ecs_defer_begin(ctx_1);
-    ecs_set(ctx_1, e1, Position, {10, 20});
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    ecs_defer_end(ctx_1);
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    
-    /* thread 2 */
-    ecs_defer_begin(ctx_2);
-    ecs_set(ctx_2, e2, Position, {20, 30});
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-    ecs_defer_end(ctx_2);
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-
-    ecs_readonly_end(world);
-    ecs_frame_end(world);
-
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(world, e2, Position));
-
-    ecs_merge(world);
-
-    test_assert(ecs_has(world, e1, Position));
-    test_assert(ecs_has(world, e2, Position));
-
-    const Position *p1 = ecs_get(world, e1, Position);
-    test_int(p1->x, 10);
-    test_int(p1->y, 20);
-
-    const Position *p2 = ecs_get(world, e2, Position);
-    test_int(p2->x, 20);
-    test_int(p2->y, 30);    
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_custom_thread_partial_manual_merge(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_set_stage_count(world, 2);
-
-    ecs_world_t *ctx_1 = ecs_get_stage(world, 0);
-    ecs_world_t *ctx_2 = ecs_get_stage(world, 1);
-
-    /* Only disable auto-merging for ctx_2 */
-    ecs_set_automerge(ctx_2, false);
-
-    ecs_frame_begin(world, 0);
-    ecs_readonly_begin(world, true);
-
-    /* thread 1 */
-    ecs_defer_begin(ctx_1);
-    ecs_set(ctx_1, e1, Position, {10, 20});
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    ecs_defer_end(ctx_1);
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    
-    /* thread 2 */
-    ecs_defer_begin(ctx_2);
-    ecs_set(ctx_2, e2, Position, {20, 30});
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-    ecs_defer_end(ctx_2);
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-
-    ecs_readonly_end(world);
-    ecs_frame_end(world);
-
-    test_assert(ecs_has(world, e1, Position));
-    test_assert(!ecs_has(world, e2, Position));
-
-    const Position *p1 = ecs_get(world, e1, Position);
-    test_int(p1->x, 10);
-    test_int(p1->y, 20);    
-
-    ecs_merge(ctx_2);
-
-    test_assert(ecs_has(world, e1, Position));
-    test_assert(ecs_has(world, e2, Position));
-
-    p1 = ecs_get(world, e1, Position);
-    test_int(p1->x, 10);
-    test_int(p1->y, 20);
-
-    const Position *p2 = ecs_get(world, e2, Position);
-    test_int(p2->x, 20);
-    test_int(p2->y, 30);    
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_set_pair_w_new_target_readonly(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_world_t *thr_1 = ecs_get_stage(world, 0);
-
-    ecs_frame_begin(world, 0);
-    ecs_readonly_begin(world, true);
-
-    ecs_entity_t tgt = ecs_new_id(thr_1);
-    ecs_set_pair(thr_1, e, Position, tgt, {10, 20});
-
-    ecs_readonly_end(world);
-    ecs_frame_end(world);
-
-    test_assert(ecs_has_pair(world, e, ecs_id(Position), tgt));
-
-    const Position *p = ecs_get_pair(world, e, Position, tgt);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_set_pair_w_new_target_tgt_component_readonly(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_world_t *thr_1 = ecs_get_stage(world, 0);
-
-    ecs_frame_begin(world, 0);
-    ecs_readonly_begin(world, true);
-
-    ecs_entity_t tgt = ecs_new_id(thr_1);
-    ecs_set_pair_second(thr_1, e, tgt, Position, {10, 20});
-
-    ecs_readonly_end(world);
-    ecs_frame_end(world);
-
-    test_assert(ecs_has_pair(world, e, tgt, ecs_id(Position)));
-
-    const Position *p = ecs_get_pair_second(world, e, tgt, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_set_pair_w_new_target_defer(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_defer_begin(world);
-
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_set_pair(world, e, Position, tgt, {10, 20});
-
-    ecs_defer_end(world);
-
-    test_assert(ecs_has_pair(world, e, ecs_id(Position), tgt));
-
-    const Position *p = ecs_get_pair(world, e, Position, tgt);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    ecs_fini(world);
-}
-
-void MultiTaskThreadStaging_set_pair_w_new_target_tgt_component_defer(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_set_task_threads(world, 2);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_defer_begin(world);
-
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_set_pair_second(world, e, tgt, Position, {10, 20});
-
-    ecs_defer_end(world);
-
-    test_assert(ecs_has_pair(world, e, tgt, ecs_id(Position)));
-
-    const Position *p = ecs_get_pair_second(world, e, tgt, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/MultiThread.c b/test/addons/src/MultiThread.c
index 2b880b688..27bff3525 100644
--- a/test/addons/src/MultiThread.c
+++ b/test/addons/src/MultiThread.c
@@ -7,8 +7,18 @@ void MultiThread_setup(void) {
     ecs_log_set_level(-3);
 }
 
+static
+void set_worker_kind(ecs_world_t *world, int32_t thread_count) {
+    const char *worker_kind = test_param("worker_kind");
+    if (!worker_kind || !strcmp(worker_kind, "thread")) {
+        ecs_set_threads(world, thread_count);
+    } else if (!strcmp(worker_kind, "task")) {
+        ecs_set_task_threads(world, thread_count);
+    }
+}
+
 void Progress(ecs_iter_t *it) {
-    Position *pos = ecs_field(it, Position, 1);
+    Position *pos = ecs_field(it, Position, 0);
     int row;
     for (row = 0; row < it->count; row ++) {
         Position *p = &pos[row];
@@ -38,11 +48,11 @@ void MultiThread_2_thread_10_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -66,11 +76,11 @@ void MultiThread_2_thread_1_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -93,11 +103,11 @@ void MultiThread_2_thread_2_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -120,11 +130,11 @@ void MultiThread_2_thread_5_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -148,11 +158,11 @@ void MultiThread_3_thread_10_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -176,11 +186,11 @@ void MultiThread_3_thread_1_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -204,11 +214,11 @@ void MultiThread_3_thread_2_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -232,11 +242,11 @@ void MultiThread_3_thread_5_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -260,11 +270,11 @@ void MultiThread_4_thread_10_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -288,11 +298,11 @@ void MultiThread_4_thread_1_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -316,11 +326,11 @@ void MultiThread_4_thread_2_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -344,11 +354,11 @@ void MultiThread_4_thread_5_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -372,11 +382,11 @@ void MultiThread_5_thread_10_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -400,11 +410,11 @@ void MultiThread_5_thread_1_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -428,11 +438,11 @@ void MultiThread_5_thread_2_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -456,11 +466,11 @@ void MultiThread_5_thread_5_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -484,11 +494,11 @@ void MultiThread_6_thread_10_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -512,11 +522,11 @@ void MultiThread_6_thread_1_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -540,11 +550,11 @@ void MultiThread_6_thread_2_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -567,11 +577,11 @@ void MultiThread_6_thread_5_entity(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -592,11 +602,11 @@ void MultiThread_2_thread_1_entity_instanced(void) {
     ECS_COMPONENT_DEFINE(world, Position);
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
         .callback = Progress,
-        .query.filter = {
+        .query = {
             .expr = "Position",
-            .instanced = true
+            .flags = EcsQueryIsInstanced
         },
         .multi_threaded = true
     });
@@ -606,11 +616,11 @@ void MultiThread_2_thread_1_entity_instanced(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -631,11 +641,11 @@ void MultiThread_2_thread_5_entity_instanced(void) {
     ECS_COMPONENT_DEFINE(world, Position);
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
         .callback = Progress,
-        .query.filter = {
+        .query = {
             .expr = "Position",
-            .instanced = true
+            .flags = EcsQueryIsInstanced
         },
         .multi_threaded = true
     });
@@ -645,11 +655,11 @@ void MultiThread_2_thread_5_entity_instanced(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -670,11 +680,11 @@ void MultiThread_2_thread_10_entity_instanced(void) {
     ECS_COMPONENT_DEFINE(world, Position);
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
         .callback = Progress,
-        .query.filter = {
+        .query = {
             .expr = "Position",
-            .instanced = true
+            .flags = EcsQueryIsInstanced
         },
         .multi_threaded = true
     });
@@ -684,11 +694,11 @@ void MultiThread_2_thread_10_entity_instanced(void) {
     ecs_entity_t *handles = ecs_os_alloca(sizeof(ecs_entity_t) * ENTITIES);
 
     for (i = 0; i < ENTITIES; i ++) {
-        handles[i] = ecs_new(world, Position);
+        handles[i] = ecs_new_w(world, Position);
         ecs_set(world, handles[i], Position, {0});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
     ecs_progress(world, 0);
 
     for (i = 0; i < ENTITIES; i ++) {
@@ -709,27 +719,29 @@ typedef struct Param {
     int count;
 } Param;
 
-static
-void TestSubset(ecs_iter_t *it) {
-    Param *param = it->param;
+static ECS_QUERY_DECLARE(qTestSubset);
 
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        test_assert(param->entity != it->entities[i]);
-        param->count ++;
-    }    
+static
+void TestSubset(ecs_world_t *world, ecs_query_t *q, int32_t offset, int32_t count, Param *param) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, offset, count);
+    while (ecs_page_next(&pit)) {
+        int i;
+        for (i = 0; i < pit.count; i ++) {
+            test_assert(param->entity != pit.entities[i]);
+            param->count ++;
+        }
+    }
 }
 
 static
 void TestAll(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-
-    ecs_entity_t TestSubset = ecs_field_id(it, 2);
+    Position *p = ecs_field(it, Position, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
         Param param = {.entity = it->entities[i], 0};
-        ecs_run_w_filter(it->world, TestSubset, 1, it->frame_offset + i + 1, 0, &param);
+        TestSubset(it->world, qTestSubset, it->frame_offset + i + 1, 0, &param);
         p[i].x += param.count;
     }
 }
@@ -740,8 +752,8 @@ void test_combs_100_entity(int THREADS) {
 
     ECS_COMPONENT_DEFINE(world, Position);
 
-    ECS_SYSTEM(world, TestSubset, 0, Position);
-    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position, TestSubset());
+    ECS_QUERY_DEFINE(world, qTestSubset, Position);
+    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position);
 
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = TestAll,
@@ -756,7 +768,7 @@ void test_combs_100_entity(int THREADS) {
         ecs_set(world, ids[i], Position, {1, 2});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
 
     ecs_progress(world, 0);
 
@@ -773,9 +785,9 @@ void MultiThread_2_thread_test_combs_100_entity_w_next_worker(void) {
 
     ECS_COMPONENT_DEFINE(world, Position);
 
-    ECS_SYSTEM(world, TestSubset, 0, Position);
+    ECS_QUERY_DEFINE(world, qTestSubset, Position);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, TestSubset()");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position" });
 
     int i, ENTITIES = 100;
 
@@ -802,6 +814,8 @@ void MultiThread_2_thread_test_combs_100_entity_w_next_worker(void) {
         test_int(p->x, ENTITIES - i);
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world); 
 }
 
@@ -833,8 +847,8 @@ void test_combs_100_entity_2_types(int THREADS) {
     ECS_COMPONENT(world, Velocity);
     ECS_PREFAB(world, Type, Position, Velocity);
 
-    ECS_SYSTEM(world, TestSubset, 0, Position);
-    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position, TestSubset());
+    ECS_QUERY_DEFINE(world, qTestSubset, Position);
+    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position);
 
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = TestAll,
@@ -853,7 +867,7 @@ void test_combs_100_entity_2_types(int THREADS) {
         ecs_set(world, ids_2[i], Position, {1, 2});
     }
 
-    ecs_set_threads(world, THREADS);
+    set_worker_kind(world, THREADS);
 
     ecs_progress(world, 0);
 
@@ -895,8 +909,8 @@ void MultiThread_change_thread_count(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_PREFAB(world, Type, Position, Velocity);
 
-    ECS_SYSTEM(world, TestSubset, 0, Position);
-    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position, TestSubset());
+    ECS_QUERY_DEFINE(world, qTestSubset, Position);
+    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position);
 
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = TestAll,
@@ -915,7 +929,7 @@ void MultiThread_change_thread_count(void) {
         ecs_set(world, ids_2[i], Position, {1, 2});
     }
 
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     ecs_progress(world, 0);
 
@@ -929,7 +943,7 @@ void MultiThread_change_thread_count(void) {
         p->x = 1;
     }
 
-    ecs_set_threads(world, 3);
+    set_worker_kind(world, 3);
 
     ecs_progress(world, 0);
 
@@ -963,7 +977,7 @@ void MultiThread_multithread_quit(void) {
 
     ecs_bulk_new(world, Position, 100);
 
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     test_assert( ecs_progress(world, 0) == 0);
 
@@ -987,7 +1001,7 @@ void MultiThread_schedule_w_tasks(void) {
         .multi_threaded = true
     });
 
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     test_assert( ecs_progress(world, 0) != 0);
 
@@ -1003,7 +1017,7 @@ void ReactiveDummySystem(ecs_iter_t * it) {
 
 static
 void PeriodicDummySystem(ecs_iter_t * it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
     
     int i;
     for (i = 0; i < it->count; i++ ) {
@@ -1024,7 +1038,7 @@ void MultiThread_reactive_system(void) {
     });
 
     ecs_bulk_new(world, Position, 2);
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     test_assert(has_ran == false);
 
@@ -1038,7 +1052,7 @@ void MultiThread_reactive_system(void) {
 void MultiThread_fini_after_set_threads(void) {
     ecs_world_t * world = ecs_init();
 
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     ecs_fini(world);
 
@@ -1048,7 +1062,7 @@ void MultiThread_fini_after_set_threads(void) {
 
 static
 void SingleThreadedSystem(ecs_iter_t * it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     
     int i;
     for (i = 0; i < it->count; i++ ) {
@@ -1068,10 +1082,10 @@ void MultiThread_2_threads_single_threaded_system(void) {
         .multi_threaded = false
     });
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
 
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     ecs_progress(world, 0);
 
@@ -1092,7 +1106,8 @@ static int create_query_invoked = 0;
 
 static
 void CreateQuery(ecs_iter_t *it) {
-    ecs_query_new(it->world, "0");
+    ecs_query_t *q = ecs_query(it->world, { .expr = "0" });
+    ecs_query_fini(q);
     create_query_invoked ++;
 }
 
@@ -1100,12 +1115,12 @@ void MultiThread_no_staging_w_multithread(void) {
     for (int i = 0; i < 10; i ++) {
         ecs_world_t *world = ecs_init();
 
-        ecs_set_threads(world, 32);
+        set_worker_kind(world, 32);
 
         ecs_system_init(world, &(ecs_system_desc_t){
             .callback = CreateQuery,
-            .no_readonly = true,
-            .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}})
+            .immediate = true,
+            .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))})
         });
 
         create_query_invoked = 0;
@@ -1121,7 +1136,7 @@ void MultiThread_no_staging_w_multithread(void) {
 void MultiThread_multithread_w_monitor_addon(void) {
     ecs_world_t *world = ecs_init();
     ECS_IMPORT(world, FlecsMonitor);
-    ecs_set_threads(world, 4);
+    set_worker_kind(world, 4);
     ecs_progress(world, 0);
     ecs_fini(world);
 
@@ -1162,10 +1177,10 @@ void System_run_w_binding_ctx(ecs_iter_t *it) {
 void MultiThread_get_ctx(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) } }),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) ) }),
         .callback = System_w_ctx,
         .multi_threaded = true,
         .ctx = &system_ctx
@@ -1181,10 +1196,10 @@ void MultiThread_get_ctx(void) {
 void MultiThread_get_binding_ctx(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) } }),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) ) }),
         .callback = System_w_binding_ctx,
         .multi_threaded = true,
         .binding_ctx = &system_ctx
@@ -1200,10 +1215,10 @@ void MultiThread_get_binding_ctx(void) {
 void MultiThread_get_ctx_w_run(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) } }),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) ) }),
         .run = System_run_w_ctx,
         .multi_threaded = true,
         .ctx = &system_ctx
@@ -1219,10 +1234,10 @@ void MultiThread_get_ctx_w_run(void) {
 void MultiThread_get_binding_ctx_w_run(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_set_threads(world, 2);
+    set_worker_kind(world, 2);
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) } }),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) ) }),
         .run = System_run_w_binding_ctx,
         .multi_threaded = true,
         .binding_ctx = &system_ctx
@@ -1250,18 +1265,18 @@ void MultiThread_bulk_new_in_no_readonly_w_multithread(void) {
     ECS_TAG_DEFINE(world, Tag);
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
-        .no_readonly = true,
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
+        .immediate = true,
         .callback = sys_bulk_init
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .multi_threaded = true,
         .callback = sys
     });
 
-    ecs_set_threads(world, 80);
+    set_worker_kind(world, 80);
 
     for (int i = 0; i < 100; i ++) {
         ecs_progress(world, 0);
@@ -1287,32 +1302,32 @@ void MultiThread_bulk_new_in_no_readonly_w_multithread_2(void) {
 
     ECS_COMPONENT_DEFINE(world, Position);
 
-    ecs_set_threads(world, 64);
+    set_worker_kind(world, 64);
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {{ ecs_id(Position) }},
+        .query.terms = {{ ecs_id(Position) }},
         .callback = sys
     });
 
     ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ ecs_id(Position) }}
+        .terms = {{ ecs_id(Position) }}
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
         .callback = sys_bulk_init_2,
-        .no_readonly = true,
+        .immediate = true,
         .ctx = q
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
         .callback = sys
     });
@@ -1321,6 +1336,8 @@ void MultiThread_bulk_new_in_no_readonly_w_multithread_2(void) {
 
     test_int(ecs_count(world, Position), 1);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1329,7 +1346,7 @@ static int invoked_count = 0;
 static int invoked_main_count = 0;
 
 static void dummy(ecs_iter_t *it) {
-    int stage_id = ecs_get_stage_id(it->world);
+    int stage_id = ecs_stage_get_id(it->world);
 
     if (stage_id == 0) {
         test_assert(main_thread == ecs_os_thread_self());
@@ -1345,12 +1362,12 @@ void MultiThread_run_first_worker_on_main(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .multi_threaded = true,
         .callback = dummy
     });
 
-    ecs_set_threads(world, 3);
+    set_worker_kind(world, 3);
 
     main_thread = ecs_os_thread_self();
 
@@ -1366,12 +1383,12 @@ void MultiThread_run_single_thread_on_main(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .multi_threaded = false,
         .callback = dummy
     });
 
-    ecs_set_threads(world, 3);
+    set_worker_kind(world, 3);
 
     main_thread = ecs_os_thread_self();
 
diff --git a/test/addons/src/MultiThreadStaging.c b/test/addons/src/MultiThreadStaging.c
index bb0a15ef2..a35a57d55 100644
--- a/test/addons/src/MultiThreadStaging.c
+++ b/test/addons/src/MultiThreadStaging.c
@@ -244,7 +244,7 @@ void MultiThreadStaging_6_threads_add_to_current(void) {
 
 static
 void InitVelocity(ecs_iter_t *it) {
-    Velocity *v = ecs_field(it, Velocity, 1);
+    Velocity *v = ecs_field(it, Velocity, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -255,7 +255,7 @@ void InitVelocity(ecs_iter_t *it) {
 
 static
 void AddVelocity(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -302,7 +302,7 @@ void MultiThreadStaging_2_threads_on_add(void) {
 
 static
 void New_w_count(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     ecs_bulk_new(it->world, Position, 10);
 }
@@ -333,8 +333,8 @@ void MultiThreadStaging_custom_thread_auto_merge(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_set_stage_count(world, 2);
 
@@ -379,127 +379,6 @@ void MultiThreadStaging_custom_thread_auto_merge(void) {
     ecs_fini(world);
 }
 
-void MultiThreadStaging_custom_thread_manual_merge(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_set_automerge(world, false);
-
-    ecs_set_stage_count(world, 2);
-
-    ecs_world_t *ctx_1 = ecs_get_stage(world, 0);
-    ecs_world_t *ctx_2 = ecs_get_stage(world, 1);
-
-    ecs_frame_begin(world, 0);
-    ecs_readonly_begin(world, true);
-
-    /* thread 1 */
-    ecs_defer_begin(ctx_1);
-    ecs_set(ctx_1, e1, Position, {10, 20});
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    ecs_defer_end(ctx_1);
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    
-    /* thread 2 */
-    ecs_defer_begin(ctx_2);
-    ecs_set(ctx_2, e2, Position, {20, 30});
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-    ecs_defer_end(ctx_2);
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-
-    ecs_readonly_end(world);
-    ecs_frame_end(world);
-
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(world, e2, Position));
-
-    ecs_merge(world);
-
-    test_assert(ecs_has(world, e1, Position));
-    test_assert(ecs_has(world, e2, Position));
-
-    const Position *p1 = ecs_get(world, e1, Position);
-    test_int(p1->x, 10);
-    test_int(p1->y, 20);
-
-    const Position *p2 = ecs_get(world, e2, Position);
-    test_int(p2->x, 20);
-    test_int(p2->y, 30);    
-
-    ecs_fini(world);
-}
-
-void MultiThreadStaging_custom_thread_partial_manual_merge(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_set_stage_count(world, 2);
-
-    ecs_world_t *ctx_1 = ecs_get_stage(world, 0);
-    ecs_world_t *ctx_2 = ecs_get_stage(world, 1);
-
-    /* Only disable auto-merging for ctx_2 */
-    ecs_set_automerge(ctx_2, false);
-
-    ecs_frame_begin(world, 0);
-    ecs_readonly_begin(world, true);
-
-    /* thread 1 */
-    ecs_defer_begin(ctx_1);
-    ecs_set(ctx_1, e1, Position, {10, 20});
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    ecs_defer_end(ctx_1);
-    test_assert(!ecs_has(world, e1, Position));
-    test_assert(!ecs_has(ctx_1, e1, Position));
-    
-    /* thread 2 */
-    ecs_defer_begin(ctx_2);
-    ecs_set(ctx_2, e2, Position, {20, 30});
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-    ecs_defer_end(ctx_2);
-    test_assert(!ecs_has(world, e2, Position));
-    test_assert(!ecs_has(ctx_2, e2, Position));
-
-    ecs_readonly_end(world);
-    ecs_frame_end(world);
-
-    test_assert(ecs_has(world, e1, Position));
-    test_assert(!ecs_has(world, e2, Position));
-
-    const Position *p1 = ecs_get(world, e1, Position);
-    test_int(p1->x, 10);
-    test_int(p1->y, 20);    
-
-    ecs_merge(ctx_2);
-
-    test_assert(ecs_has(world, e1, Position));
-    test_assert(ecs_has(world, e2, Position));
-
-    p1 = ecs_get(world, e1, Position);
-    test_int(p1->x, 10);
-    test_int(p1->y, 20);
-
-    const Position *p2 = ecs_get(world, e2, Position);
-    test_int(p2->x, 20);
-    test_int(p2->y, 30);    
-
-    ecs_fini(world);
-}
-
 void MultiThreadStaging_set_pair_w_new_target_readonly(void) {
     ecs_world_t *world = ecs_init();
 
@@ -507,14 +386,14 @@ void MultiThreadStaging_set_pair_w_new_target_readonly(void) {
 
     ecs_set_threads(world, 2);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_world_t *thr_1 = ecs_get_stage(world, 0);
 
     ecs_frame_begin(world, 0);
     ecs_readonly_begin(world, true);
 
-    ecs_entity_t tgt = ecs_new_id(thr_1);
+    ecs_entity_t tgt = ecs_new(thr_1);
     ecs_set_pair(thr_1, e, Position, tgt, {10, 20});
 
     ecs_readonly_end(world);
@@ -537,14 +416,14 @@ void MultiThreadStaging_set_pair_w_new_target_tgt_component_readonly(void) {
 
     ecs_set_threads(world, 2);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_world_t *thr_1 = ecs_get_stage(world, 0);
 
     ecs_frame_begin(world, 0);
     ecs_readonly_begin(world, true);
 
-    ecs_entity_t tgt = ecs_new_id(thr_1);
+    ecs_entity_t tgt = ecs_new(thr_1);
     ecs_set_pair_second(thr_1, e, tgt, Position, {10, 20});
 
     ecs_readonly_end(world);
@@ -567,11 +446,11 @@ void MultiThreadStaging_set_pair_w_new_target_defer(void) {
 
     ecs_set_threads(world, 2);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
 
-    ecs_entity_t tgt = ecs_new_id(world);
+    ecs_entity_t tgt = ecs_new(world);
     ecs_set_pair(world, e, Position, tgt, {10, 20});
 
     ecs_defer_end(world);
@@ -593,11 +472,11 @@ void MultiThreadStaging_set_pair_w_new_target_tgt_component_defer(void) {
 
     ecs_set_threads(world, 2);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
 
-    ecs_entity_t tgt = ecs_new_id(world);
+    ecs_entity_t tgt = ecs_new(world);
     ecs_set_pair_second(world, e, tgt, Position, {10, 20});
 
     ecs_defer_end(world);
diff --git a/test/addons/src/Pipeline.c b/test/addons/src/Pipeline.c
index c27944ba8..2b66d32be 100644
--- a/test/addons/src/Pipeline.c
+++ b/test/addons/src/Pipeline.c
@@ -78,6 +78,8 @@ void Pipeline_system_order_same_phase(void) {
     ECS_SYSTEM(world, SysC, EcsOnUpdate, Position);
 
     const ecs_world_info_t *stats = ecs_get_world_info(world);
+    
+    test_int(stats->pipeline_build_count_total, 0);
 
     ecs_progress(world, 1);
 
@@ -267,7 +269,7 @@ void Pipeline_system_order_after_new_system_lower_id(void) {
 
     ECS_ENTITY(world, E, Position);
 
-    ecs_entity_t Sys = ecs_new(world, 0);
+    ecs_entity_t Sys = ecs_new(world);
     ECS_SYSTEM(world, SysB, EcsOnUpdate, Position);
     ECS_SYSTEM(world, SysC, EcsOnUpdate, Position);
 
@@ -275,8 +277,8 @@ void Pipeline_system_order_after_new_system_lower_id(void) {
 
     /* Create new system with Sys id */
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = Sys, .name = "SysA", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, {.id = Sys, .name = "SysA", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysA
     });
 
@@ -305,15 +307,15 @@ void Pipeline_system_order_after_new_system_inbetween_id(void) {
     ECS_ENTITY(world, E, Position);
 
     ECS_SYSTEM(world, SysA, EcsOnUpdate, Position);
-    ecs_entity_t Sys = ecs_new(world, 0);
+    ecs_entity_t Sys = ecs_new(world);
     ECS_SYSTEM(world, SysC, EcsOnUpdate, Position);
 
     const ecs_world_info_t *stats = ecs_get_world_info(world);
 
     /* Create new system with Sys id */
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = Sys, .name = "SysB", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, {.id = Sys, .name = "SysB", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysB
     });
 
@@ -343,14 +345,14 @@ void Pipeline_system_order_after_new_system_higher_id(void) {
 
     ECS_SYSTEM(world, SysA, EcsOnUpdate, Position);
     ECS_SYSTEM(world, SysB, EcsOnUpdate, Position);
-    ecs_entity_t Sys = ecs_new(world, 0);
+    ecs_entity_t Sys = ecs_new(world);
 
     const ecs_world_info_t *stats = ecs_get_world_info(world);
 
     /* Create new system with Sys id */
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = Sys, .name = "SysC", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, {.id = Sys, .name = "SysC", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysC
     });
 
@@ -374,7 +376,7 @@ static int sys_out_invoked;
 static int sys_in_invoked;
 
 static void SysOut(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     sys_out_invoked ++;
 
@@ -385,7 +387,7 @@ static void SysOut(ecs_iter_t *it) {
 }
 
 static void SysOutMain(ecs_iter_t *it) {
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     sys_out_invoked ++;
 
@@ -397,7 +399,7 @@ static void SysOutMain(ecs_iter_t *it) {
 }
 
 static void SysIn(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 0);
 
     test_assert(sys_out_invoked != 0);
     sys_in_invoked ++;
@@ -414,8 +416,8 @@ static void SysIn(ecs_iter_t *it) {
 }
 
 static void SysInMain(ecs_iter_t *it) {
-    Velocity *v = ecs_field(it, Velocity, 1);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
+    Velocity *v = ecs_field(it, Velocity, 0);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 0);
 
     test_assert(sys_out_invoked != 0);
     sys_in_invoked ++;
@@ -635,7 +637,7 @@ void Pipeline_switch_pipeline(void) {
 
     ecs_add(world, ecs_id(SysC), Tag);
 
-    ECS_PIPELINE(world, P1, flecs.system.System, flecs.pipeline.Phase(cascade(DependsOn)), !Tag);
+    ECS_PIPELINE(world, P1, flecs.system.System, flecs.pipeline.Phase(cascade DependsOn), !Tag);
 
     ecs_progress(world, 1);
 
@@ -667,7 +669,7 @@ void Pipeline_run_pipeline(void) {
 
     ecs_add(world, ecs_id(SysC), Tag);
 
-    ECS_PIPELINE(world, P1, flecs.system.System, flecs.pipeline.Phase(cascade(DependsOn)), !Tag);
+    ECS_PIPELINE(world, P1, flecs.system.System, flecs.pipeline.Phase(cascade DependsOn), !Tag);
 
     const ecs_world_info_t *stats = ecs_get_world_info(world);
 
@@ -714,18 +716,18 @@ void Pipeline_3_systems_3_types(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysA", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysA", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysA
     });
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = NULL, .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = NULL, .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysB
     });
     ecs_entity_t s3 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysC", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position()",
+        .entity = ecs_entity(world, { .name = "SysC", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position()",
         .callback = SysC
     });
 
@@ -735,7 +737,7 @@ void Pipeline_3_systems_3_types(void) {
 
     ecs_add_id(world, s3, Tag);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_progress(world, 1);  
 
@@ -748,7 +750,7 @@ void Pipeline_3_systems_3_types(void) {
 
 static
 void RandomWrite(ecs_iter_t *it) {
-    ecs_entity_t ecs_id(Position) = ecs_field_id(it, 2);
+    ecs_entity_t ecs_id(Position) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -799,7 +801,7 @@ void RandomReadAfterRW(ecs_iter_t *it) {
 
 static
 void RandomRead_Not(ecs_iter_t *it) {
-    ecs_entity_t ecs_id(Position) = ecs_field_id(it, 2);
+    ecs_entity_t ecs_id(Position) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -818,7 +820,7 @@ void Pipeline_random_read_after_random_write_out_in(void) {
     ECS_SYSTEM(world, RandomWrite, EcsOnUpdate, Tag, [out] Position());
     ECS_SYSTEM(world, RandomRead, EcsOnUpdate, Tag, [in] Position());
     
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 1);  
 
@@ -839,7 +841,7 @@ void Pipeline_random_read_after_random_write_inout_in(void) {
     ECS_SYSTEM(world, RandomWrite, EcsOnUpdate, Tag, [inout] Position());
     ECS_SYSTEM(world, RandomRead, EcsOnUpdate, Tag, [in] Position());
     
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 1);  
 
@@ -860,7 +862,7 @@ void Pipeline_random_read_after_random_write_out_inout(void) {
     ECS_SYSTEM(world, RandomWrite, EcsOnUpdate, Tag, [out] Position());
     ECS_SYSTEM(world, RandomRead, EcsOnUpdate, Tag, [inout] Position());
     
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 1);  
 
@@ -881,7 +883,7 @@ void Pipeline_random_read_after_random_write_inout_inout(void) {
     ECS_SYSTEM(world, RandomWrite, EcsOnUpdate, Tag, [inout] Position());
     ECS_SYSTEM(world, RandomRead, EcsOnUpdate, Tag, [inout] Position());
     
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 1);  
 
@@ -902,7 +904,7 @@ void Pipeline_random_read_after_random_write_w_not_write(void) {
     ECS_SYSTEM(world, RandomWrite, EcsOnUpdate, Tag, [out] !Position);
     ECS_SYSTEM(world, RandomRead, EcsOnUpdate, Tag, [in] Position());
     
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 1);  
 
@@ -923,7 +925,7 @@ void Pipeline_random_read_after_random_write_w_not_read(void) {
     ECS_SYSTEM(world, RandomWrite, EcsOnUpdate, Tag, [out] Position());
     ECS_SYSTEM(world, RandomRead_Not, EcsOnUpdate, Tag, [in] !Position);
     
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 1);
 
@@ -944,7 +946,7 @@ void Pipeline_random_read_after_random_write_w_wildcard(void) {
     ECS_SYSTEM(world, RandomWrite, EcsOnUpdate, Tag, [out] Position());
     ECS_SYSTEM(world, RandomRead, EcsOnUpdate, Tag, [in] *());
     
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 1);
 
@@ -966,7 +968,7 @@ void Pipeline_random_in_after_random_inout_after_random_out(void) {
     ECS_SYSTEM(world, RandomReadWrite, EcsOnUpdate, Tag, [inout] Position());
     ECS_SYSTEM(world, RandomReadAfterRW, EcsOnUpdate, Tag, [in] Position());
     
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 1);
 
@@ -1010,26 +1012,26 @@ void Pipeline_system_reverse_order_by_phase_custom_pipeline(void) {
     ecs_add_pair(world, OnFrame, EcsDependsOn, PreFrame);
     ecs_add_pair(world, PostFrame, EcsDependsOn, OnFrame);
 
-    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade(DependsOn)), Tag);
+    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade DependsOn), Tag);
 
     int count = 0;
 
     ecs_system_init(world, &(ecs_system_desc_t){
         .callback = cb_third,
         .ctx = &count,
-        .entity = ecs_entity(world, {.add = {Tag, ecs_pair(EcsDependsOn, PostFrame)}})
+        .entity = ecs_entity(world, {.add = ecs_ids(Tag, ecs_pair(EcsDependsOn, PostFrame))})
     });
 
     ecs_system_init(world, &(ecs_system_desc_t){
         .callback = cb_second,
         .ctx = &count,
-        .entity = ecs_entity(world, {.add = {Tag, ecs_pair(EcsDependsOn, OnFrame)}})
+        .entity = ecs_entity(world, {.add = ecs_ids(Tag, ecs_pair(EcsDependsOn, OnFrame))})
     });
 
     ecs_system_init(world, &(ecs_system_desc_t){
         .callback = cb_first,
         .ctx = &count,
-        .entity = ecs_entity(world, {.add = {Tag, ecs_pair(EcsDependsOn, PreFrame)}})
+        .entity = ecs_entity(world, {.add = ecs_ids(Tag, ecs_pair(EcsDependsOn, PreFrame))})
     });
 
     test_int(count, 0);
@@ -1050,29 +1052,29 @@ void Pipeline_stage_write_before_read(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysA", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysA", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysA
     });
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysB", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "[out] Position(), Position",
+        .entity = ecs_entity(world, { .name = "SysB", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "[out] Position(), Position",
         .callback = SysB
     });
     ecs_entity_t s3 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysC", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysC", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysC
     });
 
-    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade(DependsOn)), Tag);
+    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade DependsOn), Tag);
     ecs_set_pipeline(world, P);
 
     test_assert(s1 != 0);
     test_assert(s2 != 0);
     test_assert(s3 != 0);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_progress(world, 1);  
 
@@ -1104,40 +1106,40 @@ void Pipeline_mixed_multithreaded_internal(bool task_threads) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysA", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysA", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysA,
         .multi_threaded = true
     });
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysB", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysB", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysB
     });
     ecs_entity_t s3 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysC", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysC", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysC
     });
     ecs_entity_t s4 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysD", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysD", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysD,
         .multi_threaded = true
     });
     ecs_entity_t s5 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysE", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysE", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysE,
         .multi_threaded = true
     });
     ecs_entity_t s6 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysF", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysF", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysF
     });
 
-    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade(DependsOn)), Tag);
+    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade DependsOn), Tag);
     ecs_set_pipeline(world, P);
 
     test_assert(s1 != 0);
@@ -1147,8 +1149,8 @@ void Pipeline_mixed_multithreaded_internal(bool task_threads) {
     test_assert(s5 != 0);
     test_assert(s6 != 0);
 
-    ecs_new(world, Position);
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
 
     if (task_threads)
     {
@@ -1204,40 +1206,40 @@ void Pipeline_mixed_staging(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysA", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysA", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysA,
-        .no_readonly = true
+        .immediate = true
     });
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysB", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysB", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysB
     });
     ecs_entity_t s3 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysC", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysC", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysC
     });
     ecs_entity_t s4 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysD", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysD", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysD,
-        .no_readonly = true
+        .immediate = true
     });
     ecs_entity_t s5 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysE", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysE", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysE,
-        .no_readonly = true
+        .immediate = true
     });
     ecs_entity_t s6 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysF", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysF", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysF
     });
 
-    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade(DependsOn)), Tag);
+    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade DependsOn), Tag);
     ecs_set_pipeline(world, P);
 
     test_assert(s1 != 0);
@@ -1247,8 +1249,8 @@ void Pipeline_mixed_staging(void) {
     test_assert(s5 != 0);
     test_assert(s6 != 0);
 
-    ecs_new(world, Position);
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_progress(world, 1);
     test_int(sys_a_invoked, 1);
@@ -1315,7 +1317,7 @@ void Pipeline_mixed_staging(void) {
 static
 void WritePosition(ecs_iter_t *it) {
     if (*(bool*)it->ctx) {
-        ecs_entity_t ecs_id(Position) = ecs_field_id(it, 2);
+        ecs_entity_t ecs_id(Position) = ecs_field_id(it, 1);
         for (int i = 0; i < it->count; i ++) {
             ecs_add(it->world, it->entities[i], Position);
         }
@@ -1331,33 +1333,33 @@ void Pipeline_single_threaded_pipeline_change(void) {
     bool write_position = false;
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysA", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, !Position",
+        .entity = ecs_entity(world, { .name = "SysA", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, !Position",
         .callback = SysA
     });
 
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysB", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, Position",
+        .entity = ecs_entity(world, { .name = "SysB", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, Position",
         .callback = SysB
     });
 
     ecs_entity_t s3 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "WritePosition", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, [out] Position()",
+        .entity = ecs_entity(world, { .name = "WritePosition", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, [out] Position()",
         .callback = WritePosition,
         .ctx = &write_position
     });
 
     ecs_entity_t s4 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysC", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, Position",
+        .entity = ecs_entity(world, { .name = "SysC", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, Position",
         .callback = SysC
     });
 
     ecs_entity_t s5 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysD", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, !Position",
+        .entity = ecs_entity(world, { .name = "SysD", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, !Position",
         .callback = SysD
     });
 
@@ -1367,8 +1369,8 @@ void Pipeline_single_threaded_pipeline_change(void) {
     sys_c_invoked = 1;
     sys_d_invoked = 1;
 
-    ecs_new(world, Tag);
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
+    ecs_new_w(world, Tag);
 
     test_assert(s1 != 0);
     test_assert(s2 != 0);
@@ -1414,37 +1416,37 @@ void Pipeline_multi_threaded_pipeline_change_internal(bool task_threads) {
     bool write_position = false;
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysA", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, !Position",
+        .entity = ecs_entity(world, { .name = "SysA", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, !Position",
         .callback = SysA,
         .multi_threaded = true
     });
 
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysB", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, Position, [out] Position()",
+        .entity = ecs_entity(world, { .name = "SysB", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, Position, [out] Position()",
         .callback = SysB,
         .multi_threaded = true
     });
 
     ecs_entity_t s3 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "WritePosition", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, [out] Position(), [in] ?Position",
+        .entity = ecs_entity(world, { .name = "WritePosition", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, [out] Position(), [in] ?Position",
         .callback = WritePosition,
         .ctx = &write_position,
         .multi_threaded = true
     });
 
     ecs_entity_t s4 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysC", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, Position",
+        .entity = ecs_entity(world, { .name = "SysC", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, Position",
         .callback = SysC,
         .multi_threaded = true
     });
 
     ecs_entity_t s5 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysD", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, !Position",
+        .entity = ecs_entity(world, { .name = "SysD", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, !Position",
         .callback = SysD,
         .multi_threaded = true
     });
@@ -1461,8 +1463,8 @@ void Pipeline_multi_threaded_pipeline_change_internal(bool task_threads) {
     sys_c_invoked = 1;
     sys_d_invoked = 1;
 
-    ecs_new(world, Tag);
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
+    ecs_new_w(world, Tag);
 
     test_assert(s1 != 0);
     test_assert(s2 != 0);
@@ -1515,19 +1517,19 @@ void Pipeline_activate_after_add(void) {
     bool write_position = false;
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "WritePosition", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Tag, [out] Position()",
+        .entity = ecs_entity(world, { .name = "WritePosition", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Tag, [out] Position()",
         .callback = WritePosition,
         .ctx = &write_position
     });
 
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysA", .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysA", .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysA
     });
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     test_assert(s1 != 0);
     test_assert(s2 != 0);
@@ -1552,7 +1554,8 @@ static ecs_query_t *q_result;
 static
 void CreateQuery(ecs_iter_t *it) {
     test_assert(it->real_world == it->world);
-    q_result = ecs_query_new(it->world, "Position");
+    q_result = ecs_query(it->world, { .expr = "Position" });
+    ecs_query_fini(q_result);
 }
 
 void Pipeline_no_staging_system_create_query(void) {
@@ -1562,12 +1565,12 @@ void Pipeline_no_staging_system_create_query(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "CreateQuery", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
+        .entity = ecs_entity(world, { .name = "CreateQuery", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
         .callback = CreateQuery,
-        .no_readonly = true
+        .immediate = true
     });
 
-    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade(DependsOn)), Tag);
+    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade DependsOn), Tag);
     ecs_set_pipeline(world, P);
 
     test_assert(s != 0);
@@ -1613,20 +1616,20 @@ void Pipeline_match_all_after_pipeline_rebuild(void) {
     ECS_TAG_DEFINE(world, TagB);
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "[out] TagB()",
+        .entity = ecs_entity(world, { .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "[out] TagB()",
         .callback = set_singleton
     });
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "TagB",
+        .entity = ecs_entity(world, { .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "TagB",
         .callback = match_singleton
     });
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = {ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "?TagA",
+        .entity = ecs_entity(world, { .add = ecs_ids(ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "?TagA",
         .callback = match_all
     });
 
@@ -1683,7 +1686,7 @@ void Pipeline_pipeline_w_short_notation(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t p = ecs_pipeline(world, {
-        .query.filter.expr = "flecs.system.System, Tag"
+        .query.expr = "flecs.system.System, Tag"
     });
 
     test_assert(p != 0);
@@ -1699,23 +1702,23 @@ void Pipeline_stack_allocator_after_progress(void) {
 
     ECS_SYSTEM(world, SysA, EcsOnUpdate, Position);
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {{ ecs_id(Position) }}
     });
 
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_stack_cursor_t cursor = *it.priv.cache.stack_cursor;
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_stack_cursor_t cursor = *it.priv_.cache.stack_cursor;
     ecs_iter_fini(&it);
 
     ecs_progress(world, 1);
     test_int(sys_a_invoked, 1);
 
-    it = ecs_filter_iter(world, f);
-    test_assert(it.priv.cache.stack_cursor->page == cursor.page);
-    test_assert(it.priv.cache.stack_cursor->sp == cursor.sp);
+    it = ecs_query_iter(world, f);
+    test_assert(it.priv_.cache.stack_cursor->page == cursor.page);
+    test_assert(it.priv_.cache.stack_cursor->sp == cursor.sp);
     ecs_iter_fini(&it);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -1729,21 +1732,21 @@ void Pipeline_stack_allocator_after_progress_w_pipeline_change(void) {
     ECS_SYSTEM(world, SysA, EcsOnUpdate, Position);
     ECS_SYSTEM(world, SysB, EcsOnUpdate, Position);
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {{ ecs_id(Position) }}
     });
 
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_stack_cursor_t cursor = *it.priv.cache.stack_cursor;
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_stack_cursor_t cursor = *it.priv_.cache.stack_cursor;
     ecs_iter_fini(&it);
 
     ecs_progress(world, 1);
     test_int(sys_a_invoked, 1);
     test_int(sys_b_invoked, 1);
 
-    it = ecs_filter_iter(world, f);
-    test_assert(it.priv.cache.stack_cursor->page == cursor.page);
-    test_assert(it.priv.cache.stack_cursor->sp == cursor.sp);
+    it = ecs_query_iter(world, f);
+    test_assert(it.priv_.cache.stack_cursor->page == cursor.page);
+    test_assert(it.priv_.cache.stack_cursor->sp == cursor.sp);
     ecs_iter_fini(&it);
 
     ecs_enable(world, SysB, false);
@@ -1752,28 +1755,28 @@ void Pipeline_stack_allocator_after_progress_w_pipeline_change(void) {
     test_int(sys_a_invoked, 2);
     test_int(sys_b_invoked, 1);
 
-    it = ecs_filter_iter(world, f);
-    test_assert(it.priv.cache.stack_cursor->page == cursor.page);
-    test_assert(it.priv.cache.stack_cursor->sp == cursor.sp);
+    it = ecs_query_iter(world, f);
+    test_assert(it.priv_.cache.stack_cursor->page == cursor.page);
+    test_assert(it.priv_.cache.stack_cursor->sp == cursor.sp);
     ecs_iter_fini(&it);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
 
 static
 void Sys_w_MainWorldIter(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
-    ecs_filter_t *f = ecs_filter(it->real_world, {
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
+    ecs_query_t *f = ecs_query(it->real_world, {
         .terms = {{ ecs_id(Position) }}
     });
 
-    ecs_iter_t fit = ecs_filter_iter(it->real_world, f);
-    test_bool(true, ecs_filter_next(&fit));
+    ecs_iter_t fit = ecs_query_iter(it->real_world, f);
+    test_bool(true, ecs_query_next(&fit));
     test_int(1, fit.count);
-    test_bool(false, ecs_filter_next(&fit));
-    ecs_filter_fini(f);
+    test_bool(false, ecs_query_next(&fit));
+    ecs_query_fini(f);
 }
 
 static
@@ -1782,7 +1785,7 @@ void Pipeline_iter_from_world_in_singlethread_system_multitead_app_internal(bool
 
     ECS_COMPONENT(world, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ECS_SYSTEM(world, Sys_w_MainWorldIter, EcsOnUpdate, Position());
 
@@ -1828,26 +1831,26 @@ void Pipeline_no_staging_after_inactive_system(void) {
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
-        .query.filter.terms = {{ Tag, .oper = EcsNot }},
+        .query.terms = {{ Tag, .oper = EcsNot }},
         .callback = StagingSystem
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
-        .query.filter.terms = {{ ecs_id(Position) }, { Tag, .oper = EcsNot }},
+        .query.terms = {{ ecs_id(Position) }, { Tag, .oper = EcsNot }},
         .callback = StagingSystem
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
         .callback = NoStagingSystem,
-        .no_readonly = true
+        .immediate = true
     });
 
     ecs_progress(world, 0);
@@ -1873,20 +1876,20 @@ static int no_staging_create_velocity_invoked = 0;
 static void NoStagingSystemCreatePosition(ecs_iter_t *it) {
     ecs_defer_end(it->world);
     
-    create_position_e = ecs_new_id(it->world);
+    create_position_e = ecs_new(it->world);
     ecs_set(it->world, create_position_e, Position, {0, 0});
     
-    ecs_filter_t *f = ecs_filter(it->world, {
+    ecs_query_t *f = ecs_query(it->world, {
         .terms = {{ ecs_id(Position) }}
     });
 
-    ecs_iter_t fit = ecs_filter_iter(it->world, f);
-    test_bool(true, ecs_filter_next(&fit));
+    ecs_iter_t fit = ecs_query_iter(it->world, f);
+    test_bool(true, ecs_query_next(&fit));
     test_int(fit.count, 1);
     test_uint(fit.entities[0], create_position_e);
-    test_bool(false, ecs_filter_next(&fit));
+    test_bool(false, ecs_query_next(&fit));
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_defer_begin(it->world);
     no_staging_create_position_invoked ++;
@@ -1895,20 +1898,20 @@ static void NoStagingSystemCreatePosition(ecs_iter_t *it) {
 static void NoStagingSystemCreateVelocity(ecs_iter_t *it) {
     ecs_defer_end(it->world);
     
-    create_velocity_e = ecs_new_id(it->world);
+    create_velocity_e = ecs_new(it->world);
     ecs_set(it->world, create_velocity_e, Velocity, {0, 0});
     
-    ecs_filter_t *f = ecs_filter(it->world, {
+    ecs_query_t *f = ecs_query(it->world, {
         .terms = {{ ecs_id(Velocity) }}
     });
 
-    ecs_iter_t fit = ecs_filter_iter(it->world, f);
-    test_bool(true, ecs_filter_next(&fit));
+    ecs_iter_t fit = ecs_query_iter(it->world, f);
+    test_bool(true, ecs_query_next(&fit));
     test_int(fit.count, 1);
     test_uint(fit.entities[0], create_velocity_e);
-    test_bool(false, ecs_filter_next(&fit));
+    test_bool(false, ecs_query_next(&fit));
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_defer_begin(it->world);
     no_staging_create_velocity_invoked ++;
@@ -1931,17 +1934,17 @@ void Pipeline_inactive_system_after_no_staging_system_no_defer_w_filter(void) {
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
         .callback = NoStagingSystemCreatePosition,
-        .no_readonly = true
+        .immediate = true
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
-        .query.filter.terms = {{ ecs_id(Position) }},
+        .query.terms = {{ ecs_id(Position) }},
         .callback = ReadPosition
     });
 
@@ -1967,26 +1970,26 @@ void Pipeline_inactive_system_after_no_staging_system_no_defer_w_filter_w_no_sta
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
         .callback = NoStagingSystemCreatePosition,
-        .no_readonly = true
+        .immediate = true
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
-        .query.filter.terms = {{ ecs_id(Position) }},
+        .query.terms = {{ ecs_id(Position) }},
         .callback = ReadPosition
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
         .callback = SysA,
-        .no_readonly = true
+        .immediate = true
     });
 
     ecs_progress(world, 0);
@@ -2012,33 +2015,33 @@ void Pipeline_inactive_system_after_2_no_staging_system_no_defer_w_filter(void)
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
         .callback = NoStagingSystemCreatePosition,
-        .no_readonly = true
+        .immediate = true
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
         .callback = NoStagingSystemCreateVelocity,
-        .no_readonly = true
+        .immediate = true
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
-        .query.filter.terms = {{ ecs_id(Position) }},
+        .query.terms = {{ ecs_id(Position) }},
         .callback = ReadPosition
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
-        .query.filter.terms = {{ ecs_id(Velocity) }},
+        .query.terms = {{ ecs_id(Velocity) }},
         .callback = ReadVelocity
     });
 
@@ -2074,17 +2077,17 @@ void Pipeline_inactive_multithread_system_after_no_staging_system_no_defer_inter
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
         .callback = NoStagingSystemCreatePosition,
-        .no_readonly = true
+        .immediate = true
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
-        .query.filter.terms = {{ ecs_id(Position) }},
+        .query.terms = {{ ecs_id(Position) }},
         .callback = ReadPosition,
         .multi_threaded = true
     });
@@ -2130,27 +2133,27 @@ void Pipeline_inactive_multithread_system_after_no_staging_system_no_defer_w_no_
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
         .callback = NoStagingSystemCreatePosition,
-        .no_readonly = true
+        .immediate = true
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
-        .query.filter.terms = {{ ecs_id(Position) }},
+        .query.terms = {{ ecs_id(Position) }},
         .callback = ReadPosition,
         .multi_threaded = true
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate )}
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate ))
         }),
         .callback = ReadPosition,
-        .no_readonly = true
+        .immediate = true
     });
 
     if (task_threads)
@@ -2190,7 +2193,7 @@ static int foo_system_invoked = 0;
 
 static void AddId(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    ecs_id_t id = ecs_field_id(it, 1);
+    ecs_id_t id = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i++) {
@@ -2223,7 +2226,7 @@ void Pipeline_multi_threaded_pipeline_change_w_only_singlethreaded_internal(bool
         ecs_set_threads(world, 2);
     }
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 0);
 
@@ -2243,7 +2246,7 @@ void Pipeline_multi_threaded_tasks_pipeline_change_w_only_singlethreaded(void) {
 }
 
 static void SetPosition(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     for (int i = 0; i < it->count; i ++) {
         p[i].x = 10;
@@ -2260,7 +2263,7 @@ void Pipeline_sync_after_not_out_for_out(void) {
     ECS_SYSTEM(world, AddId,       EcsOnUpdate, [out] !Position, Tag);
     ECS_SYSTEM(world, SetPosition, EcsOnUpdate, [out] Position);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     const ecs_world_info_t *wi = ecs_get_world_info(world);
 
@@ -2286,7 +2289,7 @@ void Pipeline_pair_wildcard_read_after_staged_write(void) {
     ECS_SYSTEM(world, AddId, EcsOnUpdate, [out] !(Rel, Position), Tag);
     ECS_SYSTEM(world, SysA,  EcsOnUpdate, [in]  (Rel, *));
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     const ecs_world_info_t *wi = ecs_get_world_info(world);
 
@@ -2304,7 +2307,7 @@ static int add_pair_invoked = 0;
 
 static void AddPair(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
-    ecs_id_t id = ecs_field_id(it, 1);
+    ecs_id_t id = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i++) {
@@ -2325,7 +2328,7 @@ void Pipeline_pair_read_after_staged_wildcard_write(void) {
     ECS_SYSTEM(world, AddPair, EcsOnUpdate, [out] !(Rel, *), Tag);
     ECS_SYSTEM(world, SysA,    EcsOnUpdate, [in]  (Rel, Position));
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     const ecs_world_info_t *wi = ecs_get_world_info(world);
 
@@ -2350,7 +2353,7 @@ void Pipeline_no_sync_after_pair_wildcard_read_after_unmatching_staged_write(voi
     ECS_SYSTEM(world, AddPair, EcsOnUpdate, [out] !(Rel2, Position), Tag);
     ECS_SYSTEM(world, SysA,    EcsOnUpdate, [in] (Rel, *));
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     const ecs_world_info_t *wi = ecs_get_world_info(world);
 
@@ -2375,7 +2378,7 @@ void Pipeline_no_merge_after_from_nothing_w_default_inout(void) {
     ECS_SYSTEM(world, SysA, EcsOnUpdate, Tag, Position());
     ECS_SYSTEM(world, SysB, EcsOnUpdate, Tag, Position);
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
     
     const ecs_world_info_t *wi = ecs_get_world_info(world);
 
@@ -2393,8 +2396,8 @@ static int sys_add_tag_invoked = 0;
 static int sys_no_readonly_invoked = 0;
 
 static void sys_add_tag(ecs_iter_t *it) {
-  ecs_new(it->world, TagA);
-  ecs_new(it->world, TagB);
+  ecs_new_w(it->world, TagA);
+  ecs_new_w(it->world, TagB);
   sys_add_tag_invoked ++;
   test_assert(sys_a_invoked == 0);
 }
@@ -2414,23 +2417,23 @@ void Pipeline_on_merge_activate_system_before_merge(void) {
 
     // system is annotated with TagA but writes both TagA, TagB
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
-        .query.filter.terms = {{ TagA, .inout = EcsOut, .src.flags = EcsIsEntity }},
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
+        .query.terms = {{ TagA, .inout = EcsOut, .src.id = EcsIsEntity }},
         .callback = sys_add_tag
     });
 
     // no merge inserted between systems, but system activates after merge
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
-        .query.filter.terms = {{ TagB, .inout = EcsIn }},
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
+        .query.terms = {{ TagB, .inout = EcsIn }},
         .callback = SysA
     });
 
     // read TagA, causes insertion of merge
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
-        .query.filter.terms = {{ TagA, .inout = EcsIn }},
-        .no_readonly = true,
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
+        .query.terms = {{ TagA, .inout = EcsIn }},
+        .immediate = true,
         .callback = sys_no_readonly
     });
 
@@ -2450,12 +2453,12 @@ void Pipeline_disable_phase(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .callback = SysA
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsPostUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsPostUpdate) )}),
         .callback = SysB
     });
 
@@ -2492,16 +2495,22 @@ void Pipeline_disable_phase(void) {
 void Pipeline_disable_parent(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t p1 = ecs_new_id(world);
-    ecs_entity_t p2 = ecs_new_id(world);
+    ecs_entity_t p1 = ecs_new(world);
+    ecs_entity_t p2 = ecs_new(world);
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_childof(p1), ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, {
+            .parent = p1,
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
+        }),
         .callback = SysA
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_childof(p2), ecs_dependson(EcsPostUpdate) }}),
+        .entity = ecs_entity(world, {
+            .parent = p2,
+            .add = ecs_ids( ecs_dependson(EcsPostUpdate) )
+        }),
         .callback = SysB
     });
 
@@ -2541,7 +2550,7 @@ static void NoReadonlyAddPosition(ecs_iter_t *it) {
     test_assert(it->world == it->real_world);
     no_staging_add_position_invoked ++;
 
-    ecs_entity_t e = ecs_new_id(it->world);
+    ecs_entity_t e = ecs_new(it->world);
     ecs_add(it->world, e, Position);
 }
 
@@ -2561,15 +2570,15 @@ void Pipeline_multi_threaded_no_staging_w_add_after_read_internal(bool task_thre
     }
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
-        .query.filter = { .terms = {{ ecs_id(Position) }}},
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
+        .query = { .terms = {{ ecs_id(Position) }}},
         .callback = SysA
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .callback = NoReadonlyAddPosition,
-        .no_readonly = true
+        .immediate = true
     });
 
     ecs_progress(world, 0);
@@ -2601,12 +2610,12 @@ void Pipeline_1_startup_system(void) {
     const ecs_world_info_t *stats = ecs_get_world_info(world);
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnStart) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnStart) )}),
         .callback = SysA
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .callback = SysB
     });
 
@@ -2634,17 +2643,17 @@ void Pipeline_2_startup_systems(void) {
     const ecs_world_info_t *stats = ecs_get_world_info(world);
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnStart) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnStart) )}),
         .callback = SysA
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnStart) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnStart) )}),
         .callback = SysB
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .callback = SysC
     });
 
@@ -2678,17 +2687,17 @@ void Pipeline_2_startup_phases(void) {
     ecs_add_pair(world, AfterStart, EcsDependsOn, EcsOnStart);
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(AfterStart) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(AfterStart) )}),
         .callback = SysB
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnStart) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnStart) )}),
         .callback = SysA
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .callback = SysC
     });
 
@@ -2718,24 +2727,24 @@ void Pipeline_2_startup_systems_w_merge(void) {
 
     ECS_COMPONENT(world, Position);
     
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     const ecs_world_info_t *stats = ecs_get_world_info(world);
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnStart) }}),
-        .query.filter = { .terms = {{ ecs_id(Position), .src.flags = EcsIsEntity, .inout = EcsOut }}},
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnStart) )}),
+        .query = { .terms = {{ ecs_id(Position), .src.id = EcsIsEntity, .inout = EcsOut }}},
         .callback = SysA
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnStart) }}),
-        .query.filter = { .terms = {{ ecs_id(Position) }}},
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnStart) )}),
+        .query = { .terms = {{ ecs_id(Position) }}},
         .callback = SysB
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, { .add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .callback = SysC
     });
 
@@ -2769,29 +2778,29 @@ void Pipeline_inactive_last_system_merge_count(void) {
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { TagA },
-            { TagB, .src.flags = EcsIsEntity, .inout = EcsOut }
+            { TagB, .src.id = EcsIsEntity, .inout = EcsOut }
         },
         .callback = SysA
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { TagB },
-            { TagC, .src.flags = EcsIsEntity, .inout = EcsOut }
+            { TagC, .src.id = EcsIsEntity, .inout = EcsOut }
         },
         .callback = SysB
     });
 
     test_int(stats->merge_count_total, 0);
 
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
 
     ecs_progress(world, 0);
 
@@ -2815,42 +2824,42 @@ void Pipeline_inactive_middle_system_merge_count(void) {
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { TagA },
-            { TagB, .src.flags = EcsIsEntity, .inout = EcsOut }
+            { TagB, .src.id = EcsIsEntity, .inout = EcsOut }
         },
         .callback = SysA
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { TagB },
-            { TagC, .src.flags = EcsIsEntity, .inout = EcsOut }
+            { TagC, .src.id = EcsIsEntity, .inout = EcsOut }
         },
         .callback = SysC
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { TagC },
-            { TagD, .src.flags = EcsIsEntity, .inout = EcsOut }
+            { TagD, .src.id = EcsIsEntity, .inout = EcsOut }
         },
         .callback = SysD
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { TagD }
         },
         .callback = SysB
@@ -2858,8 +2867,8 @@ void Pipeline_inactive_middle_system_merge_count(void) {
 
     test_int(stats->merge_count_total, 0);
 
-    ecs_new(world, TagA);
-    ecs_new(world, TagD);
+    ecs_new_w(world, TagA);
+    ecs_new_w(world, TagD);
 
     ecs_progress(world, 0);
 
@@ -2875,7 +2884,7 @@ void Pipeline_inactive_middle_system_merge_count(void) {
 
 static
 void CreateEntity(ecs_iter_t *it) {
-    ecs_id_t tag = ecs_field_id(it, 1);
+    ecs_id_t tag = ecs_field_id(it, 0);
     ecs_new_w_id(it->world, tag);
 }
 
@@ -2891,30 +2900,30 @@ void Pipeline_last_no_readonly_system_merge_count(void) {
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { TagA },
-            { TagB, .src.flags = EcsIsEntity, .inout = EcsOut }
+            { TagB, .src.id = EcsIsEntity, .inout = EcsOut }
         },
         .callback = SysA
     });
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { ecs_dependson(EcsOnUpdate) }
+            .add = ecs_ids( ecs_dependson(EcsOnUpdate) )
         }),
-        .query.filter.terms = {
+        .query.terms = {
             { TagD }
         },
         .callback = CreateEntity,
-        .no_readonly = true
+        .immediate = true
     });
 
     test_int(stats->merge_count_total, 0);
 
-    ecs_new(world, TagA);
-    ecs_new(world, TagD);
+    ecs_new_w(world, TagA);
+    ecs_new_w(world, TagD);
 
     test_int(1, ecs_count(world, TagD));
 
@@ -2935,7 +2944,7 @@ void Pipeline_2_pipelines_1_system(void) {
 
     ecs_entity_t p1 = ecs_pipeline(world, {
         .query = {
-            .filter.terms = {
+            .terms = {
                 { .id = EcsSystem },
                 { .id = Phase1 }
             }
@@ -2944,7 +2953,7 @@ void Pipeline_2_pipelines_1_system(void) {
 
     ecs_entity_t p2 = ecs_pipeline(world, {
         .query = {
-            .filter.terms = {
+            .terms = {
                 { .id = EcsSystem },
                 { .id = Phase2 }
             }
@@ -2953,7 +2962,7 @@ void Pipeline_2_pipelines_1_system(void) {
 
     ecs_system(world, {
         .entity = ecs_entity(world, {
-            .add = { Phase1 }
+            .add = ecs_ids( Phase1 )
         }),
         .callback = SysA
     });
@@ -2980,12 +2989,11 @@ void Pipeline_builtin_pipeline_w_self_system_term(void) {
 
     const EcsPoly *p = ecs_get_pair(world, pipeline, EcsPoly, EcsQuery);
     test_assert(p != NULL);
-    test_assert(ecs_poly_is(p->poly, ecs_query_t));
+    test_assert(flecs_poly_is(p->poly, ecs_query_t));
 
     ecs_query_t *q = p->poly;
-    const ecs_filter_t *f = ecs_query_get_filter(q);
-    test_assert(f != NULL);
-    test_assert((f->terms[0].src.flags & EcsTraverseFlags) == EcsSelf);
+    test_assert(q != NULL);
+    test_assert((q->terms[0].src.id & EcsTraverseFlags) == EcsSelf);
 
     ecs_fini(world);
 }
@@ -2996,7 +3004,7 @@ void Pipeline_custom_pipeline_w_self_system_term(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t pipeline = ecs_pipeline(world, {
-        .query.filter.terms = {
+        .query.terms = {
             { EcsSystem },
             { Tag }
         }
@@ -3005,12 +3013,11 @@ void Pipeline_custom_pipeline_w_self_system_term(void) {
 
     const EcsPoly *p = ecs_get_pair(world, pipeline, EcsPoly, EcsQuery);
     test_assert(p != NULL);
-    test_assert(ecs_poly_is(p->poly, ecs_query_t));
+    test_assert(flecs_poly_is(p->poly, ecs_query_t));
 
     ecs_query_t *q = p->poly;
-    const ecs_filter_t *f = ecs_query_get_filter(q);
-    test_assert(f != NULL);
-    test_assert((f->terms[0].src.flags & EcsTraverseFlags) == EcsSelf);
+    test_assert(q != NULL);
+    test_assert((q->terms[0].src.id & EcsTraverseFlags) == EcsSelf);
 
     ecs_fini(world);
 }
@@ -3021,15 +3028,15 @@ void Pipeline_switch_from_threads_to_tasks(void) {
     ECS_COMPONENT_DEFINE(world, Position);
 
     ecs_system(world, {
-        .entity = ecs_entity(world, {.add = { ecs_dependson(EcsOnUpdate) }}),
-        .query.filter = {.terms = {{ ecs_id(Position) }}},
+        .entity = ecs_entity(world, {.add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
+        .query = {.terms = {{ ecs_id(Position) }}},
         .callback = SysA
         });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, {.add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, {.add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .callback = NoReadonlyAddPosition,
-        .no_readonly = true
+        .immediate = true
         });
 
     ecs_set_threads(world, 2);
@@ -3057,15 +3064,15 @@ void Pipeline_switch_from_tasks_to_threads(void) {
     ECS_COMPONENT_DEFINE(world, Position);
 
     ecs_system(world, {
-        .entity = ecs_entity(world, {.add = { ecs_dependson(EcsOnUpdate) }}),
-        .query.filter = {.terms = {{ ecs_id(Position) }}},
+        .entity = ecs_entity(world, {.add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
+        .query = {.terms = {{ ecs_id(Position) }}},
         .callback = SysA
         });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, {.add = { ecs_dependson(EcsOnUpdate) }}),
+        .entity = ecs_entity(world, {.add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
         .callback = NoReadonlyAddPosition,
-        .no_readonly = true
+        .immediate = true
         });
 
     ecs_set_threads(world, 2);
@@ -3094,40 +3101,40 @@ void Pipeline_run_pipeline_multithreaded_internal(bool task_threads) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysA", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysA", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysA,
         .multi_threaded = true
     });
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysB", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysB", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysB
     });
     ecs_entity_t s3 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysC", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysC", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysC
     });
     ecs_entity_t s4 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysD", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysD", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysD,
         .multi_threaded = true
     });
     ecs_entity_t s5 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysE", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysE", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysE,
         .multi_threaded = true
     });
     ecs_entity_t s6 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "SysF", .add = {Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)} }),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "SysF", .add = ecs_ids(Tag, ecs_pair(EcsDependsOn, EcsOnUpdate)) }),
+        .query.expr = "Position",
         .callback = SysF
     });
 
-    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade(DependsOn)), Tag);
+    ECS_PIPELINE(world, P, flecs.system.System, flecs.pipeline.Phase(cascade DependsOn), Tag);
 
     test_assert(s1 != 0);
     test_assert(s2 != 0);
@@ -3136,8 +3143,8 @@ void Pipeline_run_pipeline_multithreaded_internal(bool task_threads) {
     test_assert(s5 != 0);
     test_assert(s6 != 0);
 
-    ecs_new(world, Position);
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
 
     if (task_threads)
     {
@@ -3203,6 +3210,6 @@ void Pipeline_pipeline_init_no_system_term(void) {
 
     test_expect_abort();
     ecs_pipeline(world, {
-        .query.filter.terms = {{ ecs_id(Position) }}
+        .query.terms = {{ ecs_id(Position) }}
     });
 }
diff --git a/test/addons/src/Rest.c b/test/addons/src/Rest.c
index c60db560c..9fc08adc4 100644
--- a/test/addons/src/Rest.c
+++ b/test/addons/src/Rest.c
@@ -149,7 +149,7 @@ void Rest_query(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
     ecs_set(world, e, Position, {10, 20});
 
     ecs_http_reply_t reply = ECS_HTTP_REPLY_INIT;
@@ -177,13 +177,13 @@ void Rest_named_query(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_query(world, {
-        .filter.entity = ecs_entity(world, { .name = "position_query" }),
-        .filter.terms = {
+        .entity = ecs_entity(world, { .name = "position_query" }),
+        .terms = {
             { .id = ecs_id(Position) }
         }
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
     ecs_set(world, e, Position, {10, 20});
 
     ecs_http_reply_t reply = ECS_HTTP_REPLY_INIT;
@@ -242,8 +242,8 @@ void Rest_request_commands(void) {
         ecs_os_free(reply_str);
     }
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_frame_begin(world, 0);
     ecs_defer_begin(world);
@@ -288,8 +288,8 @@ void Rest_request_commands_2_syncs(void) {
         ecs_os_free(reply_str);
     }
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_frame_begin(world, 0);
     ecs_defer_begin(world);
@@ -401,8 +401,8 @@ void Rest_request_commands_garbage_collect(void) {
         ecs_os_free(reply_str);
     }
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_frame_begin(world, 0);
     ecs_defer_begin(world);
@@ -463,3 +463,28 @@ void Rest_request_commands_garbage_collect(void) {
 
     ecs_fini(world);
 }
+
+void Rest_script_error(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_http_server_t *srv = ecs_rest_server_init(world, NULL);
+    test_assert(srv != NULL);
+
+    {
+        ecs_http_reply_t reply = ECS_HTTP_REPLY_INIT;
+        ecs_log_set_level(-4);
+        test_int(-1, ecs_http_server_request(srv, "PUT",
+            "/script/?data=struct%20Position%20%7B%0A%20%20x%20%3A%0A%7D",
+            &reply));
+        test_int(reply.code, 400);
+        char *reply_str = ecs_strbuf_get(&reply.body);
+        test_assert(reply_str != NULL);
+        ecs_os_free(reply_str);
+    }
+
+    ecs_rest_server_fini(srv);
+
+    ecs_fini(world);
+}
diff --git a/test/addons/src/RulesBasic.c b/test/addons/src/RulesBasic.c
deleted file mode 100644
index 8955e8248..000000000
--- a/test/addons/src/RulesBasic.c
+++ /dev/null
@@ -1,7696 +0,0 @@
-#include <addons.h>
-
-void RulesBasic_1_fact_w_tag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_fact_w_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Position, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_fact_w_tag_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_fact_w_component_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set_pair(world, ent, Position, TgtA, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_same_src_w_tag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent), RelB(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_same_src_w_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(ent), Velocity(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Position, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Velocity, {1, 2});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 2));
-        const Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_same_src_w_tag_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, TgtA), RelA(ent, TgtB)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_same_src_w_component_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(ent, TgtA), Position(ent, TgtB)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set_pair(world, ent, Position, TgtA, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set_pair(world, ent, Position, TgtB, {30, 40});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ecs_pair(ecs_id(Position), TgtB), ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_other_src_w_tag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent1 = ecs_new_entity(world, "ent1");
-    ecs_entity_t ent2 = ecs_new_entity(world, "ent2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent1), RelB(ent2)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent1, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent2, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent1, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(ent2, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_other_src_w_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t ent1 = ecs_new_entity(world, "ent1");
-    ecs_entity_t ent2 = ecs_new_entity(world, "ent2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(ent1), Velocity(ent2)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent1, Position, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent2, Velocity, {1, 2});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ent1, ecs_field_src(&it, 1));
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(ent2, ecs_field_src(&it, 2));
-        const Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_other_src_w_tag_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent1 = ecs_new_entity(world, "ent1");
-    ecs_entity_t ent2 = ecs_new_entity(world, "ent2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent1, TgtA), RelA(ent2, TgtB)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent1, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent2, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent1, ecs_field_src(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(ent2, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_other_src_w_component_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent1 = ecs_new_entity(world, "ent1");
-    ecs_entity_t ent2 = ecs_new_entity(world, "ent2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(ent1, TgtA), Position(ent2, TgtB)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set_pair(world, ent1, Position, TgtA, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set_pair(world, ent2, Position, TgtB, {30, 40});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 1));
-        test_uint(ent1, ecs_field_src(&it, 1));
-        test_uint(ecs_pair(ecs_id(Position), TgtB), ecs_field_id(&it, 2));
-        test_uint(ent2, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_fact_w_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelA);
-    ecs_add(world, ent, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(EcsWildcard, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_fact_w_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_fact_w_pair_any_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_fact_w_pair_any_rel_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelB, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(ent, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_same_src_w_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(ent), _(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelA);
-    ecs_add(world, ent, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(EcsWildcard, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(EcsWildcard, ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_same_src_w_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, _), RelA(ent, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_same_src_w_pair_any_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(ent, TgtA), _(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_same_src_w_pair_any_rel_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelB, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(ent, _), _(ent, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_other_src_w_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent1 = ecs_new_entity(world, "ent1");
-    ecs_entity_t ent2 = ecs_new_entity(world, "ent2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(ent1), _(ent2)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent1, RelA);
-    ecs_add(world, ent1, RelB);
-    ecs_add(world, ent2, RelA);
-    ecs_add(world, ent2, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(EcsWildcard, ecs_field_id(&it, 1));
-        test_uint(ent1, ecs_field_src(&it, 1));
-        test_uint(EcsWildcard, ecs_field_id(&it, 2));
-        test_uint(ent2, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_other_src_w_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent1 = ecs_new_entity(world, "ent1");
-    ecs_entity_t ent2 = ecs_new_entity(world, "ent2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent1, _), RelA(ent2, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent1, RelA, TgtA);
-    ecs_add_pair(world, ent1, RelA, TgtB);
-    ecs_add_pair(world, ent2, RelA, TgtA);
-    ecs_add_pair(world, ent2, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(ent1, ecs_field_src(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ent2, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_other_src_w_pair_any_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent1 = ecs_new_entity(world, "ent1");
-    ecs_entity_t ent2 = ecs_new_entity(world, "ent2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent1, _), RelA(ent2, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent1, RelA, TgtA);
-    ecs_add_pair(world, ent1, RelA, TgtB);
-    ecs_add_pair(world, ent2, RelA, TgtA);
-    ecs_add_pair(world, ent2, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(ent1, ecs_field_src(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ent2, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_facts_other_src_w_pair_any_rel_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent1 = ecs_new_entity(world, "ent1");
-    ecs_add_pair(world, ent1, RelA, TgtA);
-    ecs_add_pair(world, ent1, RelB, TgtA);
-    ecs_entity_t ent2 = ecs_new_entity(world, "ent2");
-    ecs_add_pair(world, ent2, RelA, TgtA);
-    ecs_add_pair(world, ent2, RelB, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(ent1, _), _(ent2, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(ent1, ecs_field_src(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ent2, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_this_src_w_tag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e2, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_this_src_w_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_set(world, e2, Position, {30, 40});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10); test_int(p[0].y, 20);
-        test_int(p[1].x, 30); test_int(p[1].y, 40);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_this_src_w_tag_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_this_src_w_component_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set_pair(world, e1, Position, TgtA, {10, 20});
-    ecs_set_pair(world, e2, Position, TgtA, {30, 40});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10); test_int(p[0].y, 20);
-        test_int(p[1].x, 30); test_int(p[1].y, 40);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_this_src_w_tag_2_tables(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, FragmentA);
-    ECS_TAG(world, FragmentB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_add(world, e1, FragmentA);
-    ecs_add(world, e2, FragmentB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e2, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_this_src_w_component_2_tables(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, FragmentA);
-    ECS_TAG(world, FragmentB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_add(world, e1, FragmentA);
-    ecs_add(world, e2, FragmentB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_set(world, e2, Position, {30, 40});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-        {
-            const Position *p = ecs_field(&it, Position, 1);
-            test_assert(p != NULL);
-            test_int(p[0].x, 10); test_int(p[0].y, 20);
-        }
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        {
-            const Position *p = ecs_field(&it, Position, 1);
-            test_assert(p != NULL);
-            test_int(p[0].x, 30); test_int(p[0].y, 40);
-        }
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_this_src_w_tag_pair_2_tables(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, FragmentA);
-    ECS_TAG(world, FragmentB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_add(world, e1, FragmentA);
-    ecs_add(world, e2, FragmentB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_this_src_w_component_pair_2_tables(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, FragmentA);
-    ECS_TAG(world, FragmentB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_add(world, e1, FragmentA);
-    ecs_add(world, e2, FragmentB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set_pair(world, e1, Position, TgtA, {10, 20});
-    ecs_set_pair(world, e2, Position, TgtA, {30, 40});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-        {
-            const Position *p = ecs_field(&it, Position, 1);
-            test_assert(p != NULL);
-            test_int(p[0].x, 10); test_int(p[0].y, 20);
-        }
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        {
-            const Position *p = ecs_field(&it, Position, 1);
-            test_assert(p != NULL);
-            test_int(p[0].x, 30); test_int(p[0].y, 40);
-        }
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_this_src_w_tag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), RelB($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e2, RelA);
-    ecs_add(world, e1, RelB);
-    ecs_add(world, e2, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_this_src_w_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this), Velocity($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_set(world, e2, Position, {30, 40});
-
-    ecs_set(world, e1, Velocity, {1, 2});
-    ecs_set(world, e2, Velocity, {3, 4});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10); test_int(p[0].y, 20);
-        test_int(p[1].x, 30); test_int(p[1].y, 40);
-        const Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v[0].x, 1); test_int(v[0].y, 2);
-        test_int(v[1].x, 3); test_int(v[1].y, 4);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_this_src_ent_src_w_tag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), RelB(e3)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e2, RelA);
-    ecs_add(world, e3, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_this_src_ent_src_w_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this), Velocity(e3)",
-        .instanced = true
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_set(world, e2, Position, {30, 40});
-    ecs_set(world, e3, Velocity, {1, 2});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10); test_int(p[0].y, 20);
-        test_int(p[1].x, 30); test_int(p[1].y, 40);
-        const Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v[0].x, 1); test_int(v[0].y, 2);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_ent_src_this_src_w_tag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB(e3), RelA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e2, RelA);
-    ecs_add(world, e3, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_ent_src_this_src_w_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Velocity(e3), Position($this)",
-        .instanced = true
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_set(world, e2, Position, {30, 40});
-    ecs_set(world, e3, Velocity, {1, 2});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        const Velocity *v = ecs_field(&it, Velocity, 1);
-        test_assert(v != NULL);
-        test_int(v[0].x, 1); test_int(v[0].y, 2);
-        const Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10); test_int(p[0].y, 20);
-        test_int(p[1].x, 30); test_int(p[1].y, 40);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_recycled_tag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_delete(world, ecs_new_id(world));
-    ECS_TAG(world, RelA);
-    test_assert((uint32_t)RelA != RelA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_recycled_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-    test_assert((uint32_t)ent != ent);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_recycled_pair_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_delete(world, ecs_new_id(world));
-    ECS_TAG(world, RelA);
-    test_assert((uint32_t)RelA != RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_recycled_pair_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ecs_delete(world, ecs_new_id(world));
-    ECS_TAG(world, TgtA);
-    test_assert((uint32_t)TgtA != TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_src_w_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), *($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e1, RelB);
-    
-    ecs_add(world, e2, RelA);
-    ecs_add(world, e2, RelB);
-    ecs_add(world, e2, RelC);
-
-    ecs_add(world, e3, RelA);
-    ecs_add(world, e3, RelB);
-    ecs_add(world, e3, RelC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelC, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_src_w_pair_rel_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, TgtA), *($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtB);
-    
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-    ecs_add_pair(world, e2, RelC, TgtA);
-    ecs_add_pair(world, e2, RelC, TgtB);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-    ecs_add_pair(world, e3, RelC, TgtA);
-    ecs_add_pair(world, e3, RelC, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_src_w_pair_tgt_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, TgtA), RelA($this, *)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtB);
-    ecs_add_pair(world, e2, RelA, TgtC);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-    ecs_add_pair(world, e3, RelA, TgtC);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_src_w_pair_rel_tgt_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, TgtA), *($this, *)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtB);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_src_w_any(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_"
-    });
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, Tgt);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    ecs_entity_t prev = 0;
-    int32_t count = 0, e1_matched = 0;
-    while (ecs_rule_next(&it)) {
-        test_assert(it.count > 0);
-        test_assert(!prev || prev != it.entities[0]);
-        prev = it.entities[0];
-        if (it.entities[0] == e1) {
-            e1_matched ++;
-        }
-        count ++;
-    }
-
-    test_assert(count > 0);
-    test_int(e1_matched, 1);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_not_any(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!_"
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_src_w_any_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), _($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e1, RelB);
-    
-    ecs_add(world, e2, RelA);
-    ecs_add(world, e2, RelB);
-    ecs_add(world, e2, RelC);
-
-    ecs_add(world, e3, RelA);
-    ecs_add(world, e3, RelB);
-    ecs_add(world, e3, RelC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_src_w_pair_rel_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, TgtA), _($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtB);
-    
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-    ecs_add_pair(world, e2, RelC, TgtA);
-    ecs_add_pair(world, e2, RelC, TgtB);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-    ecs_add_pair(world, e3, RelC, TgtA);
-    ecs_add_pair(world, e3, RelC, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_src_w_pair_tgt_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, TgtA), RelA($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtB);
-    ecs_add_pair(world, e2, RelA, TgtC);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-    ecs_add_pair(world, e3, RelA, TgtC);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_src_w_pair_rel_tgt_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, TgtA), _($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtB);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_ent_src_w_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "*(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e1, RelB);
-    ecs_add(world, e1, RelC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelC, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_ent_src_w_pair_rel_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "*(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e1, RelC, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_ent_src_w_pair_tgt_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, *)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add_pair(world, e1, RelA, TgtC);
-    ecs_add_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_ent_src_w_pair_rel_tgt_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "ent");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add_pair(world, e1, RelB, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "*(ent, *)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_wildcard_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(*)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_add_id(world, e1, Tag);
-    ecs_new(world, RelA);
-    ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_wildcard_src_w_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(*, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_add(world, e1, Tag);
-    ecs_new_w_pair(world, RelA, TgtA);
-    ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_wildcard_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(*), RelB(*)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_add_id(world, e1, Tag);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelB);
-    ecs_add(world, e2, RelB);
-    ecs_add(world, e3, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_wildcard_src_w_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(*, TgtA), RelB(*, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_add(world, e1, Tag);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-    
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_rule_w_iter_next(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_iter_next(&it));
-    }
-
-    ecs_add(world, ent, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_iter_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_iter_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_wildcard_src_w_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(*, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, Rel, TgtA);
-    ecs_new_w_pair(world, Rel, TgtB);
-    ecs_new_w_pair(world, Rel, TgtC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_wildcard_src_w_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(*, Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, Tgt);
-    ecs_new_w_pair(world, RelB, Tgt);
-    ecs_new_w_pair(world, RelC, Tgt);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 1));
-        test_uint(RelC, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_wildcard_src_w_pair_tgt_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(*, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, Rel, TgtA);
-    ecs_new_w_pair(world, Rel, TgtB);
-    ecs_new_w_pair(world, Rel, TgtC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, this_var));
-        test_uint(TgtA, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, this_var));
-        test_uint(TgtB, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-        test_uint(TgtC, ecs_iter_get_var(&it, this_var));
-        test_uint(TgtC, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_wildcard_src_w_pair_rel_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this(*, Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, Tgt);
-    ecs_new_w_pair(world, RelB, Tgt);
-    ecs_new_w_pair(world, RelC, Tgt);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, this_var));
-        test_uint(RelA, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, this_var));
-        test_uint(RelB, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 1));
-        test_uint(RelC, ecs_iter_get_var(&it, this_var));
-        test_uint(RelC, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_add_id(world, e1, Tag);
-    ecs_new(world, RelA);
-    ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(_)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_add_id(world, e1, Tag);
-    ecs_new(world, Position);
-    ecs_new(world, Position);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_assert(NULL == ecs_field(&it, Position, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_component_w_this_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(_), Velocity"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e = ecs_set(world, 0, Velocity, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_add_id(world, e1, Tag);
-    ecs_new(world, Position);
-    ecs_new(world, Position);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e, it.entities[0]);
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_assert(NULL == ecs_field(&it, Position, 1));
-        {
-            Velocity *v = ecs_field(&it, Velocity, 2);
-            test_assert(v != NULL);
-            test_int(v->x, 10);
-            test_int(v->y, 20);
-        }
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_w_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_add(world, e1, Tag);
-    ecs_new_w_pair(world, RelA, TgtA);
-    ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_any_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_), RelB(_)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_add_id(world, e1, Tag);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelB);
-    ecs_add(world, e2, RelB);
-    ecs_add(world, e3, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_any_src_w_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_, TgtA), RelB(_, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_add(world, e1, Tag);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_w_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(_, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, Rel, TgtA);
-    ecs_new_w_pair(world, Rel, TgtB);
-    ecs_new_w_pair(world, Rel, TgtC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_w_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(_, Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, Tgt);
-    ecs_new_w_pair(world, RelB, Tgt);
-    ecs_new_w_pair(world, RelC, Tgt);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelC, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_w_pair_tgt_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(_, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, Rel, TgtA);
-    ecs_new_w_pair(world, Rel, TgtB);
-    ecs_new_w_pair(world, Rel, TgtC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-        test_uint(TgtC, ecs_iter_get_var(&it, this_var));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_uint(TgtC, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, this_var));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_uint(TgtB, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, this_var));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_uint(TgtA, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_w_pair_rel_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this(_, Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, Tgt);
-    ecs_new_w_pair(world, RelB, Tgt);
-    ecs_new_w_pair(world, RelC, Tgt);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 1));
-        test_uint(RelC, ecs_iter_get_var(&it, this_var));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_uint(RelC, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, this_var));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_uint(RelB, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, this_var));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_uint(RelA, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_any_tgt_w_rel_fixed(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_any_rel_w_tgt_fixed(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(_, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_w_childof_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "ChildOf(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_empty(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_delete(world, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_pair_tgt_wildcard_empty(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_, *)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_delete(world, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e3);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_pair_rel_wildcard_empty(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "*(_, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelC, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_delete(world, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e3);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_any_tgt_w_rel_fixed_empty(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_any_rel_w_tgt_fixed_empty(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_(_, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_pair_w_tag_query_empty(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_any_src_tag_w_pair_query_empty(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_delete(world, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_empty_rule(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = ""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_iter_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_invalid_rule(void) {
-    ecs_log_set_level(-4);
-
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo"
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_not_instanced_table_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    {
-        test_bool(true, ecs_iter_next(&it));
-        test_int(3, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-
-        const Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 10); test_int(p[0].y, 20);
-        test_int(p[1].x, 20); test_int(p[1].y, 30);
-        test_int(p[2].x, 30); test_int(p[2].y, 40);
-    }
-
-    test_bool(false, ecs_iter_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_not_instanced_entity_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(e1)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set(world, e1, Position, {10, 20});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    {
-        test_bool(true, ecs_iter_next(&it));
-        test_int(0, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-
-        const Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-
-    test_bool(false, ecs_iter_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_not_instanced_mixed_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e0 = ecs_new_entity(world, "e0");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this), Velocity(e0)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_set(world, e0, Velocity, {1, 2});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    {
-        test_bool(true, ecs_iter_next(&it));
-        test_int(1, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        const Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-
-        const Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    {
-        test_bool(true, ecs_iter_next(&it));
-        test_int(1, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e2, it.entities[0]);
-
-        const Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-
-        const Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    {
-        test_bool(true, ecs_iter_next(&it));
-        test_int(1, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, it.entities[0]);
-
-        const Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 30);
-        test_int(p->y, 40);
-
-        const Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_bool(false, ecs_iter_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_instanced_table_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this)",
-        .instanced = true
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    {
-        test_bool(true, ecs_iter_next(&it));
-        test_int(3, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-
-        const Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 10); test_int(p[0].y, 20);
-        test_int(p[1].x, 20); test_int(p[1].y, 30);
-        test_int(p[2].x, 30); test_int(p[2].y, 40);
-    }
-
-    test_bool(false, ecs_iter_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_instanced_entity_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(e1)",
-        .instanced = true
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set(world, e1, Position, {10, 20});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    {
-        test_bool(true, ecs_iter_next(&it));
-        test_int(0, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-
-        const Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-
-    test_bool(false, ecs_iter_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_instanced_mixed_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e0 = ecs_new_entity(world, "e0");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($this), Velocity(e0)",
-        .instanced = true
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_set(world, e0, Velocity, {1, 2});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    {
-        test_bool(true, ecs_iter_next(&it));
-        test_int(3, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-
-        const Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 10); test_int(p[0].y, 20);
-        test_int(p[1].x, 20); test_int(p[1].y, 30);
-        test_int(p[2].x, 30); test_int(p[2].y, 40);
-
-        const Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_bool(false, ecs_iter_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_in_term(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "[in] Position(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Position, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_readonly(&it, 1));
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_out_term(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "[out] Position(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Position, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_readonly(&it, 1));
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_inout_term(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "[inout] Position(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Position, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_readonly(&it, 1));
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_nodata_term(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "[none] Position(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Position, {10, 20});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_readonly(&it, 1));
-        const Position *p = ecs_field(&it, Position, 1);
-        test_assert(p == NULL);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_find_this_lowercase(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "this");
-    test_assert(this_var != -1);
-    test_assert(this_var == 0);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_find_this_uppercase(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var == 0);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_find_this_tgt_lowercase(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(*, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "this");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_find_this_tgt_uppercase(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(*, $This)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "this");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_get_filter(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel"
-    });
-
-    test_assert(r != NULL);
-
-    const ecs_filter_t *f = ecs_rule_get_filter(r);
-    test_assert(f != NULL);
-    test_int(f->term_count, 1);
-    test_uint(f->terms[0].id, Rel);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_iter_empty_source(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo()"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_id(Foo), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_iter_empty_source_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "*()"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(EcsWildcard, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_iter_empty_source_2_terms(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(), Bar()"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_id(Foo), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Bar), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_iter_empty_source_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(0, Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Foo, Tgt), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_iter_empty_source_pair_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "*(0, Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, Tgt), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_iter_empty_source_2_terms_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(0, Tgt), Bar(0, Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Foo, Tgt), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Bar, Tgt), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_iter_empty_source_2_terms_mixed(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, Bar()"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add(world, e, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e, it.entities[0]);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_iter_empty_source_2_terms_mixed_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Foo, Tgt), Bar(0, Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Foo, Tgt);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e, it.entities[0]);
-        test_uint(ecs_pair(Foo, Tgt), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Bar, Tgt), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_iter_empty_source_2_terms_mixed_pair_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Foo, Tgt), *(0, Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Foo, Tgt);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e, it.entities[0]);
-        test_uint(ecs_pair(Foo, Tgt), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, Tgt), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_this_var_w_empty_entity(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_entity_t t = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, Rel, t);
-
-    ecs_rule_t *r = ecs_rule(world, { .expr = "Rel($x, $this)"});
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_uint(1, it.count);
-    test_uint(t, it.entities[0]);
-    test_uint(ecs_pair(Rel, t), ecs_field_id(&it, 1));
-    test_uint(e, ecs_iter_get_var(&it, x_var));
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_disabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, EcsDisabled);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
-    ecs_add_id(world, e_3, EcsPrefab);
-
-    ecs_rule_t *r_1 = ecs_rule(world, {
-        .expr = "TagA"
-    });
-
-    ecs_rule_t *r_2 = ecs_rule(world, {
-        .expr = "TagA, ?Disabled"
-    });
-
-    test_assert(r_1 != NULL);
-    test_assert(r_2 != NULL);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchDisabled, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchDisabled, true);
-
-    ecs_iter_t it = ecs_rule_iter(world, r_1);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    it = ecs_rule_iter(world, r_2);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_2);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r_1);
-    ecs_rule_fini(r_2);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_prefab(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, EcsDisabled);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
-    ecs_add_id(world, e_3, EcsPrefab);
-
-    ecs_rule_t *r_1 = ecs_rule(world, {
-        .expr = "TagA"
-    });
-
-    ecs_rule_t *r_2 = ecs_rule(world, {
-        .expr = "TagA, ?Prefab"
-    });
-
-    test_assert(r_1 != NULL);
-    test_assert(r_2 != NULL);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchPrefab, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchPrefab, true);
-
-    ecs_iter_t it = ecs_rule_iter(world, r_1);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    it = ecs_rule_iter(world, r_2);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_3);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r_1);
-    ecs_rule_fini(r_2);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_disabled_prefab(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, EcsDisabled);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
-    ecs_add_id(world, e_3, EcsPrefab);
-    ecs_entity_t e_4 = ecs_new(world, TagA);
-    ecs_add_id(world, e_4, EcsPrefab);
-    ecs_add_id(world, e_4, EcsDisabled);
-
-    ecs_rule_t *r_1 = ecs_rule(world, {
-        .expr = "TagA"
-    });
-
-    ecs_rule_t *r_2 = ecs_rule(world, {
-        .expr = "TagA, ?Disabled"
-    });
-
-    ecs_rule_t *r_3 = ecs_rule(world, {
-        .expr = "TagA, ?Prefab"
-    });
-
-    ecs_rule_t *r_4 = ecs_rule(world, {
-        .expr = "TagA, ?Prefab, ?Disabled"
-    });
-
-    test_assert(r_1 != NULL);
-    test_assert(r_2 != NULL);
-    test_assert(r_3 != NULL);
-    test_assert(r_4 != NULL);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchDisabled, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchDisabled, true);
-    test_bool(ecs_rule_get_filter(r_3)->flags & EcsFilterMatchDisabled, false);
-    test_bool(ecs_rule_get_filter(r_4)->flags & EcsFilterMatchDisabled, true);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchPrefab, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchPrefab, false);
-    test_bool(ecs_rule_get_filter(r_3)->flags & EcsFilterMatchPrefab, true);
-    test_bool(ecs_rule_get_filter(r_4)->flags & EcsFilterMatchPrefab, true);
-
-    ecs_iter_t it = ecs_rule_iter(world, r_1);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    {
-        it = ecs_rule_iter(world, r_2);
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_1);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_2);
-        test_int(ecs_field_id(&it, 1), TagA);
-        test_assert(!ecs_rule_next(&it));
-    }
-
-    {
-        it = ecs_rule_iter(world, r_3);
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_1);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_3);
-        test_int(ecs_field_id(&it, 1), TagA);
-        test_assert(!ecs_rule_next(&it));
-    }
-
-    {
-        it = ecs_rule_iter(world, r_4);
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_1);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_2);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_3);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_4);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(!ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r_1);
-    ecs_rule_fini(r_2);
-    ecs_rule_fini(r_3);
-    ecs_rule_fini(r_4);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_disabled_this_tgt(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, EcsDisabled);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
-    ecs_add_id(world, e_3, EcsPrefab);
-
-    ecs_new_w_pair(world, EcsChildOf, e_1);
-    ecs_new_w_pair(world, EcsChildOf, e_2);
-    ecs_new_w_pair(world, EcsChildOf, e_3);
-
-    ecs_rule_t *r_1 = ecs_rule(world, {
-        .expr = "TagA, ChildOf($child, $this)"
-    });
-
-    ecs_rule_t *r_2 = ecs_rule(world, {
-        .expr = "TagA, ChildOf($child, $this), ?Disabled"
-    });
-
-    test_assert(r_1 != NULL);
-    test_assert(r_2 != NULL);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchDisabled, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchDisabled, true);
-
-    ecs_iter_t it = ecs_rule_iter(world, r_1);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    it = ecs_rule_iter(world, r_2);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_2);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r_1);
-    ecs_rule_fini(r_2);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_prefab_this_tgt(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, EcsDisabled);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
-    ecs_add_id(world, e_3, EcsPrefab);
-
-    ecs_new_w_pair(world, EcsChildOf, e_1);
-    ecs_new_w_pair(world, EcsChildOf, e_2);
-    ecs_new_w_pair(world, EcsChildOf, e_3);
-
-    ecs_rule_t *r_1 = ecs_rule(world, {
-        .expr = "TagA, ChildOf($child, $this)"
-    });
-
-    ecs_rule_t *r_2 = ecs_rule(world, {
-        .expr = "TagA, ChildOf($child, $this), ?Prefab"
-    });
-
-    test_assert(r_1 != NULL);
-    test_assert(r_2 != NULL);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchPrefab, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchPrefab, true);
-
-    ecs_iter_t it = ecs_rule_iter(world, r_1);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    it = ecs_rule_iter(world, r_2);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_3);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r_1);
-    ecs_rule_fini(r_2);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_disabled_prefab_this_tgt(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, EcsDisabled);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
-    ecs_add_id(world, e_3, EcsPrefab);
-    ecs_entity_t e_4 = ecs_new(world, TagA);
-    ecs_add_id(world, e_4, EcsPrefab);
-    ecs_add_id(world, e_4, EcsDisabled);
-
-    ecs_new_w_pair(world, EcsChildOf, e_1);
-    ecs_new_w_pair(world, EcsChildOf, e_2);
-    ecs_new_w_pair(world, EcsChildOf, e_3);
-    ecs_new_w_pair(world, EcsChildOf, e_4);
-
-    ecs_rule_t *r_1 = ecs_rule(world, {
-        .expr = "TagA, ChildOf($child, $this)"
-    });
-
-    ecs_rule_t *r_2 = ecs_rule(world, {
-        .expr = "TagA, ChildOf($child, $this), ?Disabled"
-    });
-
-    ecs_rule_t *r_3 = ecs_rule(world, {
-        .expr = "TagA, ChildOf($child, $this), ?Prefab"
-    });
-
-    ecs_rule_t *r_4 = ecs_rule(world, {
-        .expr = "TagA, ChildOf($child, $this), ?Prefab, ?Disabled"
-    });
-
-    test_assert(r_1 != NULL);
-    test_assert(r_2 != NULL);
-    test_assert(r_3 != NULL);
-    test_assert(r_4 != NULL);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchDisabled, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchDisabled, true);
-    test_bool(ecs_rule_get_filter(r_3)->flags & EcsFilterMatchDisabled, false);
-    test_bool(ecs_rule_get_filter(r_4)->flags & EcsFilterMatchDisabled, true);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchPrefab, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchPrefab, false);
-    test_bool(ecs_rule_get_filter(r_3)->flags & EcsFilterMatchPrefab, true);
-    test_bool(ecs_rule_get_filter(r_4)->flags & EcsFilterMatchPrefab, true);
-
-    ecs_iter_t it = ecs_rule_iter(world, r_1);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    {
-        it = ecs_rule_iter(world, r_2);
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_1);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_2);
-        test_int(ecs_field_id(&it, 1), TagA);
-        test_assert(!ecs_rule_next(&it));
-    }
-
-    {
-        it = ecs_rule_iter(world, r_3);
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_1);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_3);
-        test_int(ecs_field_id(&it, 1), TagA);
-        test_assert(!ecs_rule_next(&it));
-    }
-
-    {
-        it = ecs_rule_iter(world, r_4);
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_1);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_2);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_3);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_4);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(!ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r_1);
-    ecs_rule_fini(r_2);
-    ecs_rule_fini(r_3);
-    ecs_rule_fini(r_4);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_self_disabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, EcsDisabled);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
-    ecs_add_id(world, e_3, EcsPrefab);
-
-    ecs_rule_t *r_1 = ecs_rule(world, {
-        .expr = "TagA(self)"
-    });
-
-    ecs_rule_t *r_2 = ecs_rule(world, {
-        .expr = "TagA(self), ?Disabled(self)"
-    });
-
-    test_assert(r_1 != NULL);
-    test_assert(r_2 != NULL);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchDisabled, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchDisabled, true);
-
-    ecs_iter_t it = ecs_rule_iter(world, r_1);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    it = ecs_rule_iter(world, r_2);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_2);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r_1);
-    ecs_rule_fini(r_2);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_self_prefab(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, EcsDisabled);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
-    ecs_add_id(world, e_3, EcsPrefab);
-
-    ecs_rule_t *r_1 = ecs_rule(world, {
-        .expr = "TagA(self)"
-    });
-
-    ecs_rule_t *r_2 = ecs_rule(world, {
-        .expr = "TagA(self), ?Prefab(self)"
-    });
-
-    test_assert(r_1 != NULL);
-    test_assert(r_2 != NULL);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchPrefab, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchPrefab, true);
-
-    ecs_iter_t it = ecs_rule_iter(world, r_1);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    it = ecs_rule_iter(world, r_2);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_3);
-    test_int(ecs_field_id(&it, 1), TagA);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r_1);
-    ecs_rule_fini(r_2);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_self_disabled_prefab(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, EcsDisabled);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
-    ecs_add_id(world, e_3, EcsPrefab);
-    ecs_entity_t e_4 = ecs_new(world, TagA);
-    ecs_add_id(world, e_4, EcsPrefab);
-    ecs_add_id(world, e_4, EcsDisabled);
-
-    ecs_rule_t *r_1 = ecs_rule(world, {
-        .expr = "TagA(self)"
-    });
-
-    ecs_rule_t *r_2 = ecs_rule(world, {
-        .expr = "TagA(self), ?Disabled(self)"
-    });
-
-    ecs_rule_t *r_3 = ecs_rule(world, {
-        .expr = "TagA(self), ?Prefab(self)"
-    });
-
-    ecs_rule_t *r_4 = ecs_rule(world, {
-        .expr = "TagA(self), ?Prefab(self), ?Disabled(self)"
-    });
-
-    test_assert(r_1 != NULL);
-    test_assert(r_2 != NULL);
-    test_assert(r_3 != NULL);
-    test_assert(r_4 != NULL);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchDisabled, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchDisabled, true);
-    test_bool(ecs_rule_get_filter(r_3)->flags & EcsFilterMatchDisabled, false);
-    test_bool(ecs_rule_get_filter(r_4)->flags & EcsFilterMatchDisabled, true);
-
-    test_bool(ecs_rule_get_filter(r_1)->flags & EcsFilterMatchPrefab, false);
-    test_bool(ecs_rule_get_filter(r_2)->flags & EcsFilterMatchPrefab, false);
-    test_bool(ecs_rule_get_filter(r_3)->flags & EcsFilterMatchPrefab, true);
-    test_bool(ecs_rule_get_filter(r_4)->flags & EcsFilterMatchPrefab, true);
-
-    ecs_iter_t it = ecs_rule_iter(world, r_1);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_assert(!ecs_rule_next(&it));
-
-    {
-        it = ecs_rule_iter(world, r_2);
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_1);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_2);
-        test_int(ecs_field_id(&it, 1), TagA);
-        test_assert(!ecs_rule_next(&it));
-    }
-
-    {
-        it = ecs_rule_iter(world, r_3);
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_1);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_3);
-        test_int(ecs_field_id(&it, 1), TagA);
-        test_assert(!ecs_rule_next(&it));
-    }
-
-    {
-        it = ecs_rule_iter(world, r_4);
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_1);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_2);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_3);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_int(it.entities[0], e_4);
-        test_int(ecs_field_id(&it, 1), TagA);
-
-        test_assert(!ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r_1);
-    ecs_rule_fini(r_2);
-    ecs_rule_fini(r_3);
-    ecs_rule_fini(r_4);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_inout_none_first_term(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .terms = {
-            { .id = ecs_id(Position), .inout = EcsInOutNone },
-            { .id = ecs_id(Velocity) }
-        }
-    });
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_set(world, e1, Velocity, {1, 2});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p == NULL);
-    }
-    {
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_inout_none_second_term(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Velocity), .inout = EcsInOutNone }
-        }
-    });
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_set(world, e1, Velocity, {1, 2});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-    {
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v == NULL);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_no_data_rule(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Velocity) }
-        },
-        .flags = EcsFilterNoData
-    });
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_set(world, e1, Velocity, {1, 2});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p == NULL);
-    }
-    {
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v == NULL);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_frame_offset(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {
-            { .id = ecs_id(Position), }
-        },
-    });
-
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
-    ecs_entity_t e4 = ecs_new(world, Position);
-    ecs_entity_t e5 = ecs_new(world, Position);
-
-    ecs_add(world, e3, TagB);
-    ecs_add(world, e4, TagB);
-    ecs_add(world, e5, TagC);
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-
-    test_bool(ecs_rule_next(&it), true);
-    test_int(it.count, 2);
-    test_int(it.frame_offset, 0);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e1);
-    test_assert(it.entities[1] == e2);
-    test_assert(it.ids[0] == ecs_id(Position));
-
-    test_bool(ecs_rule_next(&it), true);
-    test_int(it.count, 2);
-    test_int(it.frame_offset, 2);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e3);
-    test_assert(it.entities[1] == e4);
-    test_assert(it.ids[0] == ecs_id(Position));
-
-    test_bool(ecs_rule_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.frame_offset, 4);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e5);
-    test_assert(it.ids[0] == ecs_id(Position));
-
-    test_bool(ecs_rule_next(&it), false);
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_frame_offset_no_data(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {
-            { .id = TagA, }
-        },
-    });
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_entity_t e4 = ecs_new(world, TagA);
-    ecs_entity_t e5 = ecs_new(world, TagA);
-
-    ecs_add(world, e3, TagB);
-    ecs_add(world, e4, TagB);
-    ecs_add(world, e5, TagC);
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-
-    test_bool(ecs_rule_next(&it), true);
-    test_int(it.count, 2);
-    test_int(it.frame_offset, 0);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e1);
-    test_assert(it.entities[1] == e2);
-    test_assert(it.ids[0] == TagA);
-
-    test_bool(ecs_rule_next(&it), true);
-    test_int(it.count, 2);
-    test_int(it.frame_offset, 2);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e3);
-    test_assert(it.entities[1] == e4);
-    test_assert(it.ids[0] == TagA);
-
-    test_bool(ecs_rule_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.frame_offset, 4);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e5);
-    test_assert(it.ids[0] == TagA);
-
-    test_bool(ecs_rule_next(&it), false);
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_empty_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
-    ecs_entity_t e4 = ecs_new(world, Position);
-
-    ecs_add(world, e2, TagA);
-    ecs_add(world, e3, TagB);
-    ecs_add(world, e4, TagC);
-
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    ecs_table_t *t2 = ecs_get_table(world, e2);
-    ecs_table_t *t3 = ecs_get_table(world, e3);
-    ecs_table_t *t4 = ecs_get_table(world, e4);
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ ecs_id(Position) }},
-        .flags = EcsFilterMatchEmptyTables
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t1);
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t2);
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t3);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t4);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e4);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-
-    test_bool( ecs_rule_next(&it), false);
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_empty_tables_no_data(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_entity_t e4 = ecs_new(world, Foo);
-
-    ecs_add(world, e2, TagA);
-    ecs_add(world, e3, TagB);
-    ecs_add(world, e4, TagC);
-
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    ecs_table_t *t2 = ecs_get_table(world, e2);
-    ecs_table_t *t3 = ecs_get_table(world, e3);
-    ecs_table_t *t4 = ecs_get_table(world, e4);
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ Foo }},
-        .flags = EcsFilterMatchEmptyTables
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t1);
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), Foo);
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t2);
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), Foo);
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t3);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    test_uint(ecs_field_id(&it, 1), Foo);
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t4);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e4);
-    test_uint(ecs_field_id(&it, 1), Foo);
-
-    test_bool( ecs_rule_next(&it), false);
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_empty_tables_w_not(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_entity_t e4 = ecs_new(world, Foo);
-
-    ecs_add(world, e2, TagA);
-    ecs_add(world, e3, TagB);
-    ecs_add(world, e4, TagC);
-
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    ecs_get_table(world, e2);
-    ecs_table_t *t3 = ecs_get_table(world, e3);
-    ecs_table_t *t4 = ecs_get_table(world, e4);
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ Foo }, { TagA, .oper = EcsNot }},
-        .flags = EcsFilterMatchEmptyTables
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t1);
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), Foo);
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t3);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    test_uint(ecs_field_id(&it, 1), Foo);
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t4);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e4);
-    test_uint(ecs_field_id(&it, 1), Foo);
-
-    test_bool( ecs_rule_next(&it), false);
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_empty_tables_w_wildcard(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, TgtD);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtD);
-
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    ecs_table_t *t2 = ecs_get_table(world, e2);
-    ecs_table_t *t3 = ecs_get_table(world, e3);
-    ecs_table_t *t4 = ecs_get_table(world, e4);
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ ecs_pair(Rel, EcsWildcard) }},
-        .flags = EcsFilterMatchEmptyTables
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t1);
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Rel, TgtA));
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t2);
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Rel, TgtB));
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t3);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Rel, TgtC));
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t4);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e4);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Rel, TgtD));
-
-    test_bool( ecs_rule_next(&it), false);
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_empty_tables_w_no_empty_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {
-            { Foo }
-        },
-        .flags = EcsFilterMatchEmptyTables
-    });
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_add(world, e2, Bar);
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_match_empty_tables_trivial(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
-    ecs_entity_t e4 = ecs_new(world, Position);
-
-    ecs_add(world, e2, TagA);
-    ecs_add(world, e3, TagB);
-    ecs_add(world, e4, TagC);
-
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    ecs_table_t *t2 = ecs_get_table(world, e2);
-    ecs_table_t *t3 = ecs_get_table(world, e3);
-    ecs_table_t *t4 = ecs_get_table(world, e4);
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ ecs_id(Position), .src.flags = EcsSelf }},
-        .flags = EcsFilterMatchEmptyTables
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t1);
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t2);
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t3);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-
-    test_bool( ecs_rule_next(&it), true);
-    test_assert(it.table == t4);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e4);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-
-    test_bool( ecs_rule_next(&it), false);
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_oneof_wildcard(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Parent);
-    ECS_ENTITY(world, Rel, (OneOf, Parent));
-    ECS_ENTITY(world, ObjA, (ChildOf, Parent));
-    ECS_ENTITY(world, ObjB, (ChildOf, Parent));
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
-    test_assert( ecs_has_pair(world, e1, Rel, ObjA));
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
-    test_assert( ecs_has_pair(world, e2, Rel, ObjB));
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{
-            .id = ecs_pair(Rel, EcsWildcard)
-        }}
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_oneof_any(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Parent);
-    ECS_ENTITY(world, Rel, (OneOf, Parent));
-    ECS_ENTITY(world, ObjA, (ChildOf, Parent));
-    ECS_ENTITY(world, ObjB, (ChildOf, Parent));
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
-    test_assert( ecs_has_pair(world, e1, Rel, ObjA));
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
-    test_assert( ecs_has_pair(world, e2, Rel, ObjB));
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{
-            .id = ecs_pair(Rel, EcsAny)
-        }}
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, EcsWildcard), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, EcsWildcard), ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_instanced_w_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-    
-    ECS_TAG(world, Tag);
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {50, 60});
-
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .expr = "Position, Velocity($)",
-        .instanced = true
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_assert(ecs_rule_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 3);
-        test_int(it.entities[0], e1);
-        test_int(it.entities[1], e2);
-        test_int(it.entities[2], e3);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-        test_int(p[1].x, 20);
-        test_int(p[1].y, 30);
-        test_int(p[2].x, 30);
-        test_int(p[2].y, 40);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 2);
-        test_int(it.entities[0], e4);
-        test_int(it.entities[1], e5);
-        test_int(p[0].x, 40);
-        test_int(p[0].y, 50);
-        test_int(p[1].x, 50);
-        test_int(p[1].y, 60);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_instanced_w_base(void) {
-    ecs_world_t *world = ecs_mini();
-    
-    ECS_TAG(world, Tag);
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t base_1 = ecs_set(world, 0, Velocity, {1, 2});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {80, 90});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {50, 60});
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-
-    ecs_add_pair(world, e1, EcsIsA, base_1);
-    ecs_add_pair(world, e2, EcsIsA, base_1);
-    ecs_add_pair(world, e3, EcsIsA, base_1);
-    ecs_add_pair(world, e4, EcsIsA, base_1);
-    ecs_add_pair(world, e5, EcsIsA, base_1);
-
-    ecs_entity_t e6 = ecs_set(world, 0, Position, {60, 70});
-    ecs_entity_t e7 = ecs_set(world, 0, Position, {70, 80});
-    ecs_set(world, e6, Velocity, {2, 3});
-    ecs_set(world, e7, Velocity, {4, 5});
-
-    ecs_entity_t e8 = ecs_set(world, 0, Velocity, {6, 7});
-    ecs_entity_t e9 = ecs_set(world, 0, Velocity, {8, 9});
-    ecs_add_pair(world, e8, EcsIsA, base_2);
-    ecs_add_pair(world, e9, EcsIsA, base_2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .expr = "Position, Velocity",
-        .instanced = true
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), false);
-        test_bool(ecs_field_is_self(&it, 2), true);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 2);
-        test_int(it.entities[0], e8);
-        test_int(it.entities[1], e9);
-        test_int(p->x, 80);
-        test_int(p->y, 90);
-        test_int(v[0].x, 6);
-        test_int(v[0].y, 7);
-        test_int(v[1].x, 8);
-        test_int(v[1].y, 9);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), true);
-        test_bool(ecs_field_is_self(&it, 2), false);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-
-        test_int(it.count, 3);
-        test_int(it.entities[0], e1);
-        test_int(it.entities[1], e2);
-        test_int(it.entities[2], e3);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-        test_int(p[1].x, 20);
-        test_int(p[1].y, 30);
-        test_int(p[2].x, 30);
-        test_int(p[2].y, 40);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), true);
-        test_bool(ecs_field_is_self(&it, 2), false);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 2);
-        test_int(it.entities[0], e4);
-        test_int(it.entities[1], e5);
-        test_int(p[0].x, 40);
-        test_int(p[0].y, 50);
-        test_int(p[1].x, 50);
-        test_int(p[1].y, 60);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), true);
-        test_bool(ecs_field_is_self(&it, 2), true);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 2);
-        test_int(it.entities[0], e6);
-        test_int(p[0].x, 60);
-        test_int(p[0].y, 70);
-        test_int(v[0].x, 2);
-        test_int(v[0].y, 3);
-
-        test_int(it.entities[1], e7);
-        test_int(p[1].x, 70);
-        test_int(p[1].y, 80);
-        test_int(v[1].x, 4);
-        test_int(v[1].y, 5);
-    }
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_not_instanced_w_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-    
-    ECS_TAG(world, Tag);
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {50, 60});
-
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .expr = "Position, Velocity($)"
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_assert(ecs_rule_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e1);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_src(&it, 2));
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e2);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_src(&it, 2));
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e3);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_src(&it, 2));
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e4);
-        test_int(p[0].x, 40);
-        test_int(p[0].y, 50);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_src(&it, 2));
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e5);
-        test_int(p[0].x, 50);
-        test_int(p[0].y, 60);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_src(&it, 2));
-    }
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_not_instanced_w_base(void) {
-    ecs_world_t *world = ecs_mini();
-    
-    ECS_TAG(world, Tag);
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t base_1 = ecs_set(world, 0, Velocity, {1, 2});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {80, 90});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {50, 60});
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-
-    ecs_add_pair(world, e1, EcsIsA, base_1);
-    ecs_add_pair(world, e2, EcsIsA, base_1);
-    ecs_add_pair(world, e3, EcsIsA, base_1);
-    ecs_add_pair(world, e4, EcsIsA, base_1);
-    ecs_add_pair(world, e5, EcsIsA, base_1);
-
-    ecs_entity_t e6 = ecs_set(world, 0, Position, {60, 70});
-    ecs_entity_t e7 = ecs_set(world, 0, Position, {70, 80});
-    ecs_set(world, e6, Velocity, {2, 3});
-    ecs_set(world, e7, Velocity, {4, 5});
-
-    ecs_entity_t e8 = ecs_set(world, 0, Velocity, {6, 7});
-    ecs_entity_t e9 = ecs_set(world, 0, Velocity, {8, 9});
-    ecs_add_pair(world, e8, EcsIsA, base_2);
-    ecs_add_pair(world, e9, EcsIsA, base_2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .expr = "Position, Velocity"
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), false);
-        test_bool(ecs_field_is_self(&it, 2), true);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e8);
-        test_int(p->x, 80);
-        test_int(p->y, 90);
-        test_int(v[0].x, 6);
-        test_int(v[0].y, 7);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), false);
-        test_bool(ecs_field_is_self(&it, 2), true);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e9);
-        test_int(p->x, 80);
-        test_int(p->y, 90);
-        test_int(v[0].x, 8);
-        test_int(v[0].y, 9);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), true);
-        test_bool(ecs_field_is_self(&it, 2), false);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-
-        test_int(it.count, 1);
-        test_int(it.entities[0], e1);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), true);
-        test_bool(ecs_field_is_self(&it, 2), false);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-
-        test_int(it.count, 1);
-        test_int(it.entities[0], e2);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), true);
-        test_bool(ecs_field_is_self(&it, 2), false);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-
-        test_int(it.count, 1);
-        test_int(it.entities[0], e3);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), true);
-        test_bool(ecs_field_is_self(&it, 2), false);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e4);
-        test_int(p[0].x, 40);
-        test_int(p[0].y, 50);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), true);
-        test_bool(ecs_field_is_self(&it, 2), false);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e5);
-        test_int(p[0].x, 50);
-        test_int(p[0].y, 60);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_rule_next(&it));
-    {
-        test_bool(ecs_field_is_self(&it, 1), true);
-        test_bool(ecs_field_is_self(&it, 2), true);
-
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 2);
-        test_int(it.entities[0], e6);
-        test_int(p[0].x, 60);
-        test_int(p[0].y, 70);
-        test_int(v[0].x, 2);
-        test_int(v[0].y, 3);
-
-        test_int(it.entities[1], e7);
-        test_int(p[1].x, 70);
-        test_int(p[1].y, 80);
-        test_int(v[1].x, 4);
-        test_int(v[1].y, 5);
-    }
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_unknown_before_known(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, ChildOf($gc, $c), ChildOf($c, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int c_var = ecs_rule_find_var(r, "c");
-    test_assert(c_var != -1);
-    int gc_var = ecs_rule_find_var(r, "gc");
-    test_assert(gc_var != -1);
-
-    ecs_entity_t p = ecs_new(world, Foo);
-    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
-    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t gc = ecs_new_w_pair(world, EcsChildOf, c);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 2));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
-    test_uint(c, ecs_iter_get_var(&it, c_var));
-    test_uint(gc, ecs_iter_get_var(&it, gc_var));
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-    
-    ecs_fini(world);
-}
-
-void RulesBasic_unknown_before_known_after_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, ChildOf($gc, $c), Foo($gc) || Bar($gc), ChildOf($c, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int c_var = ecs_rule_find_var(r, "c");
-    test_assert(c_var != -1);
-    int gc_var = ecs_rule_find_var(r, "gc");
-    test_assert(gc_var != -1);
-
-    ecs_entity_t p = ecs_new(world, Foo);
-    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
-    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t gc1 = ecs_new_w_pair(world, EcsChildOf, c);
-    ecs_add(world, gc1, Foo);
-    ecs_entity_t gc2 = ecs_new_w_pair(world, EcsChildOf, c);
-    ecs_add(world, gc2, Bar);
-    /* ecs_entity_t gc3 = */ ecs_new_w_pair(world, EcsChildOf, c);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 2));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 4));
-    test_uint(c, ecs_iter_get_var(&it, c_var));
-    test_uint(gc1, ecs_iter_get_var(&it, gc_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 2));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 4));
-    test_uint(c, ecs_iter_get_var(&it, c_var));
-    test_uint(gc2, ecs_iter_get_var(&it, gc_var));
-    test_assert(!ecs_rule_next(&it));
-    
-    ecs_rule_fini(r);
-    
-    ecs_fini(world);
-}
-
-void RulesBasic_unknown_before_known_after_not(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, ChildOf($gc, $c), !Foo($gc), ChildOf($c, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int c_var = ecs_rule_find_var(r, "c");
-    test_assert(c_var != -1);
-    int gc_var = ecs_rule_find_var(r, "gc");
-    test_assert(gc_var != -1);
-
-    ecs_entity_t p = ecs_new(world, Foo);
-    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
-    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t gc1 = ecs_new_w_pair(world, EcsChildOf, c);
-    ecs_entity_t gc2 = ecs_new_w_pair(world, EcsChildOf, c);
-    ecs_add(world, gc2, Foo);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 2));
-    test_uint(Foo, ecs_field_id(&it, 3));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 4));
-    test_uint(c, ecs_iter_get_var(&it, c_var));
-    test_uint(gc1, ecs_iter_get_var(&it, gc_var));
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-    
-    ecs_fini(world);
-}
-
-void RulesBasic_unknown_before_known_after_optional(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, ChildOf($gc, $c), ?Foo($gc), ChildOf($c, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int c_var = ecs_rule_find_var(r, "c");
-    test_assert(c_var != -1);
-    int gc_var = ecs_rule_find_var(r, "gc");
-    test_assert(gc_var != -1);
-
-    ecs_entity_t p = ecs_new(world, Foo);
-    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
-    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t gc1 = ecs_new_w_pair(world, EcsChildOf, c);
-    ecs_entity_t gc2 = ecs_new_w_pair(world, EcsChildOf, c);
-    ecs_add(world, gc2, Foo);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 2));
-    test_uint(Foo, ecs_field_id(&it, 3));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 4));
-    test_bool(false, ecs_field_is_set(&it, 3));
-    test_uint(c, ecs_iter_get_var(&it, c_var));
-    test_uint(gc1, ecs_iter_get_var(&it, gc_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 2));
-    test_uint(Foo, ecs_field_id(&it, 3));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 4));
-    test_bool(true, ecs_field_is_set(&it, 3));
-    test_uint(c, ecs_iter_get_var(&it, c_var));
-    test_uint(gc2, ecs_iter_get_var(&it, gc_var));
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-    
-    ecs_fini(world);
-}
-
-void RulesBasic_unknown_before_known_after_scope(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, ChildOf($gc, $c), !{Foo($gc) || Bar($gc)}, ChildOf($c, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int c_var = ecs_rule_find_var(r, "c");
-    test_assert(c_var != -1);
-    int gc_var = ecs_rule_find_var(r, "gc");
-    test_assert(gc_var != -1);
-
-    ecs_entity_t p = ecs_new(world, Foo);
-    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
-    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t gc1 = ecs_new_w_pair(world, EcsChildOf, c);
-    ecs_entity_t gc2 = ecs_new_w_pair(world, EcsChildOf, c);
-    ecs_add(world, gc2, Foo);
-    ecs_entity_t gc3 = ecs_new_w_pair(world, EcsChildOf, c);
-    ecs_add(world, gc3, Bar);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(c, ecs_iter_get_var(&it, c_var));
-    test_uint(gc1, ecs_iter_get_var(&it, gc_var));
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-    
-    ecs_fini(world);
-}
-
-void RulesBasic_reordered_plan_1(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, ChildOf($this, $p, $gp, $ggp), Bar($ggp)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      "
-    LINE " 1. [ 0,  2]  selfupid    $[this]           (Foo)"
-    LINE " 2. [ 1,  3]  and         $[this]           (ChildOf, $p)"
-    LINE " 3. [ 2,  4]  and         $p                (ChildOf, $gp)"
-    LINE " 4. [ 3,  5]  and         $gp               (ChildOf, $ggp)"
-    LINE " 5. [ 4,  6]  selfupid    $ggp              (Bar)"
-    LINE " 6. [ 5,  7]  setvars     "
-    LINE " 7. [ 6,  8]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_reordered_plan_2(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($ggp), ChildOf($this, $p, $gp, $ggp), Bar($this)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      "
-    LINE " 1. [ 0,  2]  selfupid    $[ggp]            (Foo)"
-    LINE " 2. [ 1,  3]  each        $ggp              ($[ggp])"
-    LINE " 3. [ 2,  4]  and         $[gp]             (ChildOf, $ggp)"
-    LINE " 4. [ 3,  5]  each        $gp               ($[gp])"
-    LINE " 5. [ 4,  6]  and         $[p]              (ChildOf, $gp)"
-    LINE " 6. [ 5,  7]  each        $p                ($[p])"
-    LINE " 7. [ 6,  8]  and         $[this]           (ChildOf, $p)"
-    LINE " 8. [ 7,  9]  selfupid    $[this]           (Bar)"
-    LINE " 9. [ 8, 10]  setvars     "
-    LINE "10. [ 9, 11]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_trivial_plan(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  andid       $[this]           (Foo)"
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_trivial_plan(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), Bar(self)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  triv        "
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_trivial_plan_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  andid       $[this]           (Position)"
-    LINE " 2. [ 1,  3]  popself     "
-    LINE " 3. [ 2,  4]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_trivial_plan_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), Velocity(self)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  trivpop     "
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_trivial_plan_w_wildcard(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), ChildOf(self, *)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  trivwc      "
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_3_trivial_plan_w_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_new_entity(world, "p");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), Bar(self), ChildOf(self, p)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  triv        "
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_3_trivial_plan_w_wildcard(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_new_entity(world, "p");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), Bar(self), ChildOf(self, *)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  trivwc      "
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_3_trivial_plan_w_any(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_new_entity(world, "p");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), Bar(self), ChildOf(self, _)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  triv        "
-    LINE " 2. [ 1,  3]  andany      $[this]           (ChildOf, $_'1)"
-    LINE " 3. [ 2,  4]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_3_trivial_plan_w_pair_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_new_entity(world, "p");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), Velocity(self), ChildOf(self, p)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  trivpop     "
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_3_trivial_plan_w_wildcard_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_new_entity(world, "p");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), Velocity(self), ChildOf(self, *)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  trivwc      "
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_3_trivial_plan_w_any_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_new_entity(world, "p");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), Velocity(self), ChildOf(self, _)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  trivpop     "
-    LINE " 2. [ 1,  3]  andany      $[this]           (ChildOf, $_'1)"
-    LINE " 3. [ 2,  4]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-
-void RulesBasic_1_plan_any_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(_)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  ids         $[_'1]            (RelA)"
-    LINE " 1. [ 0,  2]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_plan_not_any_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!RelA(_)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  2]  not         "
-    LINE " 1. [ 0,  2]   ids        $[_'1]            (RelA)"
-    LINE " 2. [ 0,  3]  end         $[_'1]            (RelA)"
-    LINE " 3. [ 2,  4]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_plan_optional_any_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "?RelA(_)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  2]  option      "
-    LINE " 1. [ 0,  2]   ids        $[_'1]            (RelA)"
-    LINE " 2. [ 0,  3]  end         $[_'1]            (RelA)"
-    LINE " 3. [ 2,  4]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_1_trivial_component_w_none(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_new_entity(world, "p");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "[none] Position(self)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  andid       $[this]           (Position)"
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_trivial_component_w_none(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_new_entity(world, "p");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "[none] Position(self), [none] Velocity(self)"
-    });
-
-    ecs_log_enable_colors(false);
-
-    const char *expect = 
-    HEAD " 0. [-1,  1]  setids      " 
-    LINE " 1. [ 0,  2]  triv        "
-    LINE " 2. [ 1,  3]  yield       "
-    LINE "";
-    char *plan = ecs_rule_str(r);
-
-    test_str(expect, plan);
-    ecs_os_free(plan);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_trivial_mixed_2_tables(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Mass);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), Bar(self), Mass(ent:self)",
-        .instanced = true
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add(world, e1, Foo);
-    ecs_add(world, e1, Bar);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add(world, e2, Foo);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_add(world, e3, Foo);
-    ecs_add(world, e3, Bar);
-    ecs_add(world, e3, Tag);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Mass, {100});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 3));
-
-        {
-            Mass *m = ecs_field(&it, Mass, 3);
-            test_assert(m != NULL);
-            test_int(*m, 100);
-        }
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e3, it.entities[0]);
-
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 3));
-
-        {
-            Mass *m = ecs_field(&it, Mass, 3);
-            test_assert(m != NULL);
-            test_int(*m, 100);
-        }
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_trivial_mixed_2_tables_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), Velocity(self), Mass(ent:self)",
-        .instanced = true
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_set(world, e1, Velocity, {1, 2});
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_set(world, e2, Position, {20, 30});
-    ecs_set(world, e2, Velocity, {2, 3});
-
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_set(world, e3, Position, {30, 40});
-    ecs_set(world, e3, Velocity, {3, 4});
-    ecs_add(world, e3, Tag);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Mass, {100});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 3));
-
-        {
-            Position *p = ecs_field(&it, Position, 1);
-            test_assert(p != NULL);
-            test_int(p[0].x, 10); test_int(p[0].y, 20);
-            test_int(p[1].x, 20); test_int(p[1].y, 30);
-
-            Velocity *v = ecs_field(&it, Velocity, 2);
-            test_assert(v != NULL);
-            test_int(v[0].x, 1); test_int(v[0].y, 2);
-            test_int(v[1].x, 2); test_int(v[1].y, 3);
-
-            Mass *m = ecs_field(&it, Mass, 3);
-            test_assert(m != NULL);
-            test_int(*m, 100);
-        }
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e3, it.entities[0]);
-
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 3));
-
-        {
-            Position *p = ecs_field(&it, Position, 1);
-            test_assert(p != NULL);
-            test_int(p[0].x, 30); test_int(p[0].y, 40);
-
-            Velocity *v = ecs_field(&it, Velocity, 2);
-            test_assert(v != NULL);
-            test_int(v[0].x, 3); test_int(v[0].y, 4);
-
-            Mass *m = ecs_field(&it, Mass, 3);
-            test_assert(m != NULL);
-            test_int(*m, 100);
-        }
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBasic_2_trivial_mixed_2_tables_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Mass);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), ChildOf(self, *), Mass(ent:self)",
-        .instanced = true
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add(world, e1, Foo);
-    ecs_add_pair(world, e1, EcsChildOf, TgtA);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add(world, e2, Foo);
-    ecs_add_pair(world, e2, EcsChildOf, TgtA);
-
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_add(world, e3, Foo);
-    ecs_add_pair(world, e3, EcsChildOf, TgtA);
-    ecs_add(world, e3, Tag);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_set(world, ent, Mass, {100});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 3));
-
-        {
-            Mass *m = ecs_field(&it, Mass, 3);
-            test_assert(m != NULL);
-            test_int(*m, 100);
-        }
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e3, it.entities[0]);
-
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 3));
-
-        {
-            Mass *m = ecs_field(&it, Mass, 3);
-            test_assert(m != NULL);
-            test_int(*m, 100);
-        }
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/RulesBuiltinPredicates.c b/test/addons/src/RulesBuiltinPredicates.c
deleted file mode 100644
index 048220466..000000000
--- a/test/addons/src/RulesBuiltinPredicates.c
+++ /dev/null
@@ -1,3236 +0,0 @@
-#include <addons.h>
-
-void RulesBuiltinPredicates_this_eq_id(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this == ent"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_eq_name(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this == \"ent\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_eq_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_log_set_level(-4);
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this == $x"
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_eq_id_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this == ent_2"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_eq_id_written_no_match(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB($this), $this == ent_2"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_eq_name_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this == \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_eq_name_written_no_match(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB($this), $this == \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_eq_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add_pair(world, ent_1, RelA, ent_2);
-    ecs_add_pair(world, ent_2, RelA, ent_2);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add_pair(world, ent_3, RelA, ent_2);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $x), $this == $x"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-        test_uint(ent_2, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_id(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x == ent"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_name(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x == \"ent\""
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_log_set_level(-4);
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x == $y"
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_id_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x == ent_2"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_id_written_no_match(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB($x), $x == ent_2"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_name_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x == \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_name_written_no_match(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB($x), $x == \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add_pair(world, ent_1, RelA, ent_2);
-    ecs_add_pair(world, ent_2, RelA, ent_2);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add_pair(world, ent_3, RelA, ent_2);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x, $y), $x == $y"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-        test_uint(ent_2, ecs_iter_get_var(&it, y_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_add(world, e1, Bar);
-    /* ecs_entity_t e2 = */ ecs_new(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($this), $x == $this, Bar($x)"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_neq_id(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this != ent_2"
-    });
-
-    test_assert(r != NULL);
-
-    bool ent_1_found = false;
-    bool ent_3_found = false;
-    bool ent_4_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != ent_2);
-            if (it.entities[i] == ent_1) {
-                ent_1_found = true;
-            }
-            if (it.entities[i] == ent_3) {
-                ent_3_found = true;
-            }
-            if (it.entities[i] == ent_4) {
-                ent_4_found = true;
-            }
-        }
-    }
-
-    test_bool(ent_1_found, true);
-    test_bool(ent_3_found, true);
-    test_bool(ent_4_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_neq_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this != \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-
-    bool ent_1_found = false;
-    bool ent_3_found = false;
-    bool ent_4_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != ent_2);
-            if (it.entities[i] == ent_1) {
-                ent_1_found = true;
-            }
-            if (it.entities[i] == ent_3) {
-                ent_3_found = true;
-            }
-            if (it.entities[i] == ent_4) {
-                ent_4_found = true;
-            }
-        }
-    }
-
-    test_bool(ent_1_found, true);
-    test_bool(ent_3_found, true);
-    test_bool(ent_4_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_neq_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_log_set_level(-4);
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this != $x"
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_neq_id_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this != ent_2"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_neq_id_written_no_match(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB($this), $this != ent_2"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_neq_name_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this != \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_neq_name_written_no_match(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB($this), $this != \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_neq_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add_pair(world, ent_1, RelA, ent_2);
-    ecs_add_pair(world, ent_2, RelA, ent_2);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add_pair(world, ent_3, RelA, ent_2);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $x), $this != $x"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_neq_id(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x != ent_2"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    bool ent_1_found = false;
-    bool ent_3_found = false;
-    bool ent_4_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_uint(it.count, 0);
-        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
-        test_assert(e != ent_2);
-        if (e == ent_1) {
-            ent_1_found = true;
-        }
-        if (e == ent_3) {
-            ent_3_found = true;
-        }
-        if (e == ent_4) {
-            ent_4_found = true;
-        }
-    }
-
-    test_bool(ent_1_found, true);
-    test_bool(ent_3_found, true);
-    test_bool(ent_4_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_neq_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x != \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    bool ent_1_found = false;
-    bool ent_3_found = false;
-    bool ent_4_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_uint(it.count, 0);
-        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
-        test_assert(e != ent_2);
-        if (e == ent_1) {
-            ent_1_found = true;
-        }
-        if (e == ent_3) {
-            ent_3_found = true;
-        }
-        if (e == ent_4) {
-            ent_4_found = true;
-        }
-    }
-
-    test_bool(ent_1_found, true);
-    test_bool(ent_3_found, true);
-    test_bool(ent_4_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_neq_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_log_set_level(-4);
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x != $y"
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_neq_id_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x != ent_2"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_neq_id_written_no_match(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB($x), $x != ent_2"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_neq_name_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x != \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_neq_name_written_no_match(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB($x), $x != \"ent_2\""
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_neq_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add_pair(world, ent_1, RelA, ent_2);
-    ecs_add_pair(world, ent_2, RelA, ent_2);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add_pair(world, ent_3, RelA, ent_2);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x, $y), $x != $y"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
-        test_uint(ent_2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
-        test_uint(ent_2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_neq_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tgt);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add_pair(world, e2, Rel, e2);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel($this, $x), $x != $this"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(Tgt, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_2_neq_id(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this != ent_2, $this != ent_3"
-    });
-
-    test_assert(r != NULL);
-
-    bool ent_1_found = false;
-    bool ent_4_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != ent_2);
-            test_assert(it.entities[i] != ent_3);
-            if (it.entities[i] == ent_1) {
-                ent_1_found = true;
-            }
-            if (it.entities[i] == ent_4) {
-                ent_4_found = true;
-            }
-            if (it.entities[i] == ent_5) {
-                ent_5_found = true;
-            }
-        }
-    }
-
-    test_bool(ent_1_found, true);
-    test_bool(ent_4_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_2_neq_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this != \"ent_2\", $this != \"ent_3\""
-    });
-
-    test_assert(r != NULL);
-
-    bool ent_1_found = false;
-    bool ent_4_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != ent_2);
-            test_assert(it.entities[i] != ent_3);
-            if (it.entities[i] == ent_1) {
-                ent_1_found = true;
-            }
-            if (it.entities[i] == ent_4) {
-                ent_4_found = true;
-            }
-            if (it.entities[i] == ent_5) {
-                ent_5_found = true;
-            }
-        }
-    }
-
-    test_bool(ent_1_found, true);
-    test_bool(ent_4_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_2_neq_id(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x != ent_2, $x != ent_3"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    bool ent_1_found = false;
-    bool ent_4_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_uint(it.count, 0);
-        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
-        test_assert(e != ent_2);
-        test_assert(e != ent_3);
-        if (e == ent_1) {
-            ent_1_found = true;
-        }
-        if (e == ent_4) {
-            ent_4_found = true;
-        }
-        if (e == ent_5) {
-            ent_5_found = true;
-        }
-    }
-
-    test_bool(ent_1_found, true);
-    test_bool(ent_4_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_2_neq_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x != \"ent_2\", $x != \"ent_3\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    bool ent_1_found = false;
-    bool ent_4_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_uint(it.count, 0);
-        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
-        test_assert(e != ent_2);
-        test_assert(e != ent_3);
-        if (e == ent_1) {
-            ent_1_found = true;
-        }
-        if (e == ent_4) {
-            ent_4_found = true;
-        }
-        if (e == ent_5) {
-            ent_5_found = true;
-        }
-    }
-
-    test_bool(ent_1_found, true);
-    test_bool(ent_4_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_2_neq_id_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this != ent_2, $this != ent_3"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_4, it.entities[0]);
-        test_uint(ent_5, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_2_neq_name_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this != \"ent_2\", $this != \"ent_3\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_4, it.entities[0]);
-        test_uint(ent_5, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_2_neq_id_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x != ent_2, $x != ent_3"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_2_neq_name_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x != \"ent_2\", $x != \"ent_3\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_2_or_id(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    /* ecs_entity_t ent_1 = */ ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    /* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
-    /* ecs_entity_t ent_5 = */ ecs_new_entity(world, "ent_5");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this == ent_2 || $this == ent_3"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_2_or_name(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    /* ecs_entity_t ent_1 = */ ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    /* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
-    /* ecs_entity_t ent_5 = */ ecs_new_entity(world, "ent_5");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this == \"ent_2\" || $this == \"ent_3\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_2_or_id(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    /* ecs_entity_t ent_1 = */ ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    /* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
-    /* ecs_entity_t ent_5 = */ ecs_new_entity(world, "ent_5");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x == ent_2 || $x == ent_3"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_2_or_name(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    /* ecs_entity_t ent_1 = */ ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    /* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
-    /* ecs_entity_t ent_5 = */ ecs_new_entity(world, "ent_5");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x == \"ent_2\" || $x == \"ent_3\""
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_2_or_id_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this == ent_2 || $this == ent_3"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_2_or_name_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this == \"ent_2\" || $this == \"ent_3\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_2_or_id_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x == ent_2 || $x == ent_3"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_2_or_name_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
-    ecs_add(world, ent_5, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x == \"ent_2\" || $x == \"ent_3\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_eq(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    /* ecs_entity_t ent_2 = */ ecs_new_entity(world, "ent2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, Tag);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this ~= \"nt_\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_3, it.entities[0]);
-        test_uint(ent_4, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_6, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_match_eq(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    /* ecs_entity_t ent_2 = */ ecs_new_entity(world, "ent2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, Tag);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x ~= \"nt_\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_6, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_eq_written(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, RelA);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, RelA);
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this ~= \"nt_\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, it.entities[0]);
-        test_uint(ent_4, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_6, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_eq_written_self(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, RelA);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, RelA);
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this:self), $this ~= \"nt_\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, it.entities[0]);
-        test_uint(ent_4, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_6, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_match_eq_written(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, RelA);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, RelA);
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x ~= \"nt_\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_6, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_neq(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, Tag);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this ~= \"!nt_\""
-    });
-
-    test_assert(r != NULL);
-
-    bool ent_2_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != ent_1);
-            test_assert(it.entities[i] != ent_3);
-            test_assert(it.entities[i] != ent_4);
-            test_assert(it.entities[i] != ent_6);
-            if (it.entities[i] == ent_2) {
-                ent_2_found = true;
-            }
-            if (it.entities[i] == ent_5) {
-                ent_5_found = true;
-            }
-        }
-    }
-
-    test_bool(ent_2_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_match_neq(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, Tag);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x ~= \"!nt_\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    bool ent_2_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_uint(it.count, 0);
-        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
-        test_assert(e != ent_1);
-        test_assert(e != ent_3);
-        test_assert(e != ent_4);
-        test_assert(e != ent_6);
-        if (e == ent_2) {
-            ent_2_found = true;
-        }
-        if (e == ent_5) {
-            ent_5_found = true;
-        }
-    }
-
-    test_bool(ent_2_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_neq_written(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, RelA);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, RelA);
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this ~= \"!nt_\""
-    });
-
-    test_assert(r != NULL);
-
-    bool ent_2_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != ent_1);
-            test_assert(it.entities[i] != ent_3);
-            test_assert(it.entities[i] != ent_4);
-            test_assert(it.entities[i] != ent_6);
-            if (it.entities[i] == ent_2) {
-                ent_2_found = true;
-            }
-            if (it.entities[i] == ent_5) {
-                ent_5_found = true;
-            }
-        }
-    }
-
-    test_bool(ent_2_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_match_neq_written(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, RelA);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, RelA);
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x ~= \"!nt_\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    bool ent_2_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_uint(it.count, 0);
-        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
-        test_assert(e != ent_1);
-        test_assert(e != ent_3);
-        test_assert(e != ent_4);
-        test_assert(e != ent_6);
-        if (e == ent_2) {
-            ent_2_found = true;
-        }
-        if (e == ent_5) {
-            ent_5_found = true;
-        }
-    }
-
-    test_bool(ent_2_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_2_neq(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, Tag);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this ~= \"!nt_\", $this ~= \"!_3\""
-    });
-
-    test_assert(r != NULL);
-
-    bool ent_2_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != ent_1);
-            test_assert(it.entities[i] != ent_3);
-            test_assert(it.entities[i] != ent_4);
-            test_assert(it.entities[i] != ent_6);
-            if (it.entities[i] == ent_2) {
-                ent_2_found = true;
-            }
-            if (it.entities[i] == ent_5) {
-                ent_5_found = true;
-            }
-        }
-    }
-
-    test_bool(ent_2_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_match_2_neq(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, Tag);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x ~= \"!nt_\", $x ~= \"!_3\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    bool ent_2_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
-        test_assert(e != ent_1);
-        test_assert(e != ent_3);
-        test_assert(e != ent_4);
-        test_assert(e != ent_6);
-        if (e == ent_2) {
-            ent_2_found = true;
-        }
-        if (e == ent_5) {
-            ent_5_found = true;
-        }
-    }
-
-    test_bool(ent_2_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_2_neq_written(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, RelA);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, RelA);
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this ~= \"!nt_\", $this ~= \"!_3\""
-    });
-
-    test_assert(r != NULL);
-
-    bool ent_2_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != ent_1);
-            test_assert(it.entities[i] != ent_3);
-            test_assert(it.entities[i] != ent_4);
-            test_assert(it.entities[i] != ent_6);
-            if (it.entities[i] == ent_2) {
-                ent_2_found = true;
-            }
-            if (it.entities[i] == ent_5) {
-                ent_5_found = true;
-            }
-        }
-    }
-
-    test_bool(ent_2_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_match_2_neq_written(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, RelA);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, RelA);
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x ~= \"!nt_\", $x ~= \"!_3\""
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    bool ent_2_found = false;
-    bool ent_5_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
-        test_assert(e != ent_1);
-        test_assert(e != ent_3);
-        test_assert(e != ent_4);
-        test_assert(e != ent_6);
-        if (e == ent_2) {
-            ent_2_found = true;
-        }
-        if (e == ent_5) {
-            ent_5_found = true;
-        }
-    }
-
-    test_bool(ent_2_found, true);
-    test_bool(ent_5_found, true);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_2_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    /* ecs_entity_t ent_2 = */ ecs_new_entity(world, "ent2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    /* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, Tag);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this ~= \"1\" || $this ~= \"_3\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_2_or_written(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, RelA);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, RelA);
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this ~= \"1\" || $this ~= \"_3\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_3_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    /* ecs_entity_t ent_2 = */ ecs_new_entity(world, "ent2");
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    /* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, Tag);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this ~= \"1\" || $this ~= \"_3\" || $this ~= \"nt_6\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent_6, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_this_match_3_or_written(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
-    ecs_add(world, ent_1, RelA);
-    ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
-    ecs_add(world, ent_2, RelA);
-    ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
-    ecs_add(world, ent_3, RelA);
-    ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
-    ecs_add(world, ent_4, RelA);
-    ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
-    ecs_add(world, ent_5, RelA);
-    ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
-    ecs_add(world, ent_6, RelA);
-    ecs_add(world, ent_6, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $this ~= \"1\" || $this ~= \"_3\" || $this ~= \"nt_6\""
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(false, ecs_field_is_set(&it, 2));
-        test_uint(ent_6, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_unresolved_by_name(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this == ent",
-        .flags = EcsFilterUnresolvedByName
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(false, ecs_field_is_set(&it, 1));
-        test_uint(ent, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x == *, (Rel, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e, it.entities[0]);
-        test_uint(tgt, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x == _, (Rel, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e, it.entities[0]);
-        test_uint(tgt, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_wildcard_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Rel, $x), $x == *"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e, it.entities[0]);
-        test_uint(tgt, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_any_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Rel, $x), $x == _"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e, it.entities[0]);
-        test_uint(tgt, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_var_eq_after_var_0_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(), $x == flecs"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(EcsFlecs, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_2_or_w_eq_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Bar);
-
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_add_pair(world, e1, Rel, e1);
-
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_add_pair(world, e2, Rel, e1);
-
-    ecs_entity_t e3 = ecs_new(world, 0);
-    ecs_add_pair(world, e3, Rel, Rel);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel($this, $x), $x == $this || $x == Rel"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(ecs_pair(Rel, e1), ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e3, it.entities[0]);
-        test_uint(ecs_pair(Rel, Rel), ecs_field_id(&it, 1));
-        test_uint(true, ecs_field_is_set(&it, 1));
-        test_uint(Rel, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_2_or_w_eq_lookup_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Hello);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_new(world, Foo);
-
-    ecs_entity_t child1 = ecs_new_entity(world, "hello");
-    ecs_add_pair(world, child1, EcsChildOf, e1);
-    ecs_add(world, child1, Bar);
-
-    ecs_entity_t child2 = ecs_new_entity(world, "world");
-    ecs_add_pair(world, child2, EcsChildOf, e2);
-    ecs_add(world, child2, Bar);
-
-    ecs_entity_t child3_1 = ecs_new_entity(world, "hello");
-    ecs_add_pair(world, child3_1, EcsChildOf, e3);
-    ecs_add(world, child3_1, Bar);
-
-    ecs_entity_t child3_2 = ecs_new_entity(world, "world");
-    ecs_add_pair(world, child3_2, EcsChildOf, e3);
-    ecs_add(world, child3_2, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($this), $x == $this.hello || $x == $this.world, Bar($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int hello_var = ecs_rule_find_var(r, "this.hello");
-    test_assert(hello_var != -1);
-
-    int world_var = ecs_rule_find_var(r, "this.world");
-    test_assert(world_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(child1, ecs_iter_get_var(&it, x_var));
-    test_uint(child1, ecs_iter_get_var(&it, hello_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(child2, ecs_iter_get_var(&it, x_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, hello_var));
-    test_uint(child2, ecs_iter_get_var(&it, world_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(child3_1, ecs_iter_get_var(&it, x_var));
-    test_uint(child3_1, ecs_iter_get_var(&it, hello_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_3_or_w_eq_lookup_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Hello);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_entity_t e4 = ecs_new(world, Foo);
-    ecs_new(world, Foo);
-
-    ecs_entity_t child1 = ecs_new_entity(world, "hello");
-    ecs_add_pair(world, child1, EcsChildOf, e1);
-    ecs_add(world, child1, Bar);
-
-    ecs_entity_t child2 = ecs_new_entity(world, "world");
-    ecs_add_pair(world, child2, EcsChildOf, e2);
-    ecs_add(world, child2, Bar);
-
-    ecs_entity_t child3_1 = ecs_new_entity(world, "hello");
-    ecs_add_pair(world, child3_1, EcsChildOf, e3);
-    ecs_add(world, child3_1, Bar);
-
-    ecs_entity_t child3_2 = ecs_new_entity(world, "world");
-    ecs_add_pair(world, child3_2, EcsChildOf, e3);
-    ecs_add(world, child3_2, Bar);
-
-    ecs_entity_t child4 = ecs_new_entity(world, "zoo");
-    ecs_add_pair(world, child4, EcsChildOf, e4);
-    ecs_add(world, child4, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($this), $x == $this.hello || $x == $this.world || $x == $this.zoo, Bar($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int hello_var = ecs_rule_find_var(r, "this.hello");
-    test_assert(hello_var != -1);
-
-    int world_var = ecs_rule_find_var(r, "this.world");
-    test_assert(world_var != -1);
-
-    int zoo_var = ecs_rule_find_var(r, "this.zoo");
-    test_assert(zoo_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(child1, ecs_iter_get_var(&it, x_var));
-    test_uint(child1, ecs_iter_get_var(&it, hello_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, zoo_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(child2, ecs_iter_get_var(&it, x_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, hello_var));
-    test_uint(child2, ecs_iter_get_var(&it, world_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, zoo_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(child3_1, ecs_iter_get_var(&it, x_var));
-    test_uint(child3_1, ecs_iter_get_var(&it, hello_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, zoo_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(child4, ecs_iter_get_var(&it, x_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, hello_var));
-    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
-    test_uint(child4, ecs_iter_get_var(&it, zoo_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_unwritten_var_error_neq(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_log_set_level(-4);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(ChildOf, $p), $q != \"e\""
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesBuiltinPredicates_unwritten_var_error_match(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_log_set_level(-4);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(ChildOf, $p), $q ~= \"e\""
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/RulesComponentInheritance.c b/test/addons/src/RulesComponentInheritance.c
deleted file mode 100644
index 8869e0ffc..000000000
--- a/test/addons/src/RulesComponentInheritance.c
+++ /dev/null
@@ -1,3656 +0,0 @@
-#include <addons.h>
-
-ECS_TAG_DECLARE(Unit);
-ECS_TAG_DECLARE(MeleeUnit);
-ECS_TAG_DECLARE(RangedUnit);
-ECS_TAG_DECLARE(Warrior);
-ECS_TAG_DECLARE(Archer);
-ECS_TAG_DECLARE(Wizard);
-ECS_TAG_DECLARE(Warlock);
-
-static
-void populate_facts(ecs_world_t *world) {
-    ECS_TAG_DEFINE(world, Unit);
-    ECS_ENTITY_DEFINE(world, MeleeUnit, (IsA, Unit));
-    ECS_ENTITY_DEFINE(world, RangedUnit, (IsA, Unit));
-    ECS_ENTITY_DEFINE(world, Warrior, (IsA, MeleeUnit));
-    ECS_ENTITY_DEFINE(world, Archer, (IsA, RangedUnit));
-    ECS_ENTITY_DEFINE(world, Wizard, (IsA, RangedUnit));
-    ECS_ENTITY_DEFINE(world, Warlock, (IsA, Wizard), (IsA, Warrior));
-}
-
-void RulesComponentInheritance_1_ent_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Warlock(e1)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_ent_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Warrior(e1)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_ent_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "MeleeUnit(e1)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_ent_3_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Unit(e1)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it)); /* not ideal, diamond problem */
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1)); 
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-
-void RulesComponentInheritance_1_this_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    ecs_entity_t e2 = ecs_new(world, Wizard);
-    ecs_entity_t e3 = ecs_new(world, Warrior);
-    ecs_entity_t e4 = ecs_new(world, Archer);
-    ecs_entity_t e5 = ecs_new(world, MeleeUnit);
-    ecs_entity_t e6 = ecs_new(world, RangedUnit);
-    ecs_entity_t e7 = ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Unit($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Unit, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e7, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(MeleeUnit, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e5, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RangedUnit, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e6, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warrior, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Archer, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Wizard, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    /* ecs_entity_t e2 = */ ecs_new(world, Wizard);
-    ecs_entity_t e3 = ecs_new(world, Warrior);
-    /* ecs_entity_t e4 = */ ecs_new(world, Archer);
-    ecs_entity_t e5 = ecs_new(world, MeleeUnit);
-    /* ecs_entity_t e6 = */ ecs_new(world, RangedUnit);
-    /* ecs_entity_t e7 = */ ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "MeleeUnit($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(MeleeUnit, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e5, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warrior, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    /* ecs_entity_t e2 = */ ecs_new(world, Wizard);
-    ecs_entity_t e3 = ecs_new(world, Warrior);
-    /* ecs_entity_t e4 = */ ecs_new(world, Archer);
-    /* ecs_entity_t e5 = */ ecs_new(world, MeleeUnit);
-    /* ecs_entity_t e6 = */ ecs_new(world, RangedUnit);
-    /* ecs_entity_t e7 = */ ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Warrior($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warrior, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_3_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    /* ecs_entity_t e2 = */ ecs_new(world, Wizard);
-    /* ecs_entity_t e3 = */ ecs_new(world, Warrior);
-    /* ecs_entity_t e4 = */ ecs_new(world, Archer);
-    /* ecs_entity_t e5 = */ ecs_new(world, MeleeUnit);
-    /* ecs_entity_t e6 = */ ecs_new(world, RangedUnit);
-    /* ecs_entity_t e7 = */ ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Warlock($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_0_lvl_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this), Unit($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Wizard, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warrior, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Archer, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(MeleeUnit, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e5, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RangedUnit, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e6, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Unit, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e7, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_1_lvl_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this), MeleeUnit($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warrior, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(MeleeUnit, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e5, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_2_lvl_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this), Warrior($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warrior, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_3_lvl_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this), Warlock($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    ecs_entity_t e2 = ecs_new(world, Wizard);
-    ecs_entity_t e3 = ecs_new(world, Warrior);
-    ecs_entity_t e4 = ecs_new(world, Archer);
-    ecs_entity_t e5 = ecs_new(world, MeleeUnit);
-    ecs_entity_t e6 = ecs_new(world, RangedUnit);
-    ecs_entity_t e7 = ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Unit($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Unit, ecs_field_id(&it, 1));
-        test_uint(e7, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e7, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(MeleeUnit, ecs_field_id(&it, 1));
-        test_uint(e5, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RangedUnit, ecs_field_id(&it, 1));
-        test_uint(e6, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warrior, ecs_field_id(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Archer, ecs_field_id(&it, 1));
-        test_uint(e4, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Wizard, ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    /* ecs_entity_t e2 = */ ecs_new(world, Wizard);
-    ecs_entity_t e3 = ecs_new(world, Warrior);
-    /* ecs_entity_t e4 = */ ecs_new(world, Archer);
-    ecs_entity_t e5 = ecs_new(world, MeleeUnit);
-    /* ecs_entity_t e6 = */ ecs_new(world, RangedUnit);
-    /* ecs_entity_t e7 = */ ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "MeleeUnit($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(MeleeUnit, ecs_field_id(&it, 1));
-        test_uint(e5, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warrior, ecs_field_id(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    /* ecs_entity_t e2 = */ ecs_new(world, Wizard);
-    ecs_entity_t e3 = ecs_new(world, Warrior);
-    /* ecs_entity_t e4 = */ ecs_new(world, Archer);
-    /* ecs_entity_t e5 = */ ecs_new(world, MeleeUnit);
-    /* ecs_entity_t e6 = */ ecs_new(world, RangedUnit);
-    /* ecs_entity_t e7 = */ ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Warrior($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warrior, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_3_lvl(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    /* ecs_entity_t e2 = */ ecs_new(world, Wizard);
-    /* ecs_entity_t e3 = */ ecs_new(world, Warrior);
-    /* ecs_entity_t e4 = */ ecs_new(world, Archer);
-    /* ecs_entity_t e5 = */ ecs_new(world, MeleeUnit);
-    /* ecs_entity_t e6 = */ ecs_new(world, RangedUnit);
-    /* ecs_entity_t e7 = */ ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Warlock($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_0_lvl_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x), Unit($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Wizard, ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warrior, ecs_field_id(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Archer, ecs_field_id(&it, 2));
-        test_uint(e4, ecs_field_src(&it, 1));
-        test_uint(e4, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(MeleeUnit, ecs_field_id(&it, 2));
-        test_uint(e5, ecs_field_src(&it, 1));
-        test_uint(e5, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RangedUnit, ecs_field_id(&it, 2));
-        test_uint(e6, ecs_field_src(&it, 1));
-        test_uint(e6, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Unit, ecs_field_id(&it, 2));
-        test_uint(e7, ecs_field_src(&it, 1));
-        test_uint(e7, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e7, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_1_lvl_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x), MeleeUnit($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warrior, ecs_field_id(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(MeleeUnit, ecs_field_id(&it, 2));
-        test_uint(e5, ecs_field_src(&it, 1));
-        test_uint(e5, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_2_lvl_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x), Warrior($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warrior, ecs_field_id(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_3_lvl_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x), Warlock($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_ent_1_lvl_self(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Warrior(e1:self)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_1_lvl_self(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    /* ecs_entity_t e2 = */ ecs_new(world, Wizard);
-    ecs_entity_t e3 = ecs_new(world, Warrior);
-    /* ecs_entity_t e4 = */ ecs_new(world, Archer);
-    ecs_entity_t e5 = ecs_new(world, MeleeUnit);
-    /* ecs_entity_t e6 = */ ecs_new(world, RangedUnit);
-    /* ecs_entity_t e7 = */ ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "MeleeUnit(self)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(MeleeUnit, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e5, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warrior, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_1_lvl_written_self(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), MeleeUnit(self)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warrior, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(MeleeUnit, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e5, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_1_lvl_self(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Warlock);
-    /* ecs_entity_t e2 = */ ecs_new(world, Wizard);
-    ecs_entity_t e3 = ecs_new(world, Warrior);
-    /* ecs_entity_t e4 = */ ecs_new(world, Archer);
-    ecs_entity_t e5 = ecs_new(world, MeleeUnit);
-    /* ecs_entity_t e6 = */ ecs_new(world, RangedUnit);
-    /* ecs_entity_t e7 = */ ecs_new(world, Unit);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "MeleeUnit($x:self)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(MeleeUnit, ecs_field_id(&it, 1));
-        test_uint(e5, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warrior, ecs_field_id(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Warlock, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_1_lvl_written_self(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Warlock);
-    ecs_add(world, e2, Wizard);
-    ecs_add(world, e3, Warrior);
-    ecs_add(world, e4, Archer);
-    ecs_add(world, e5, MeleeUnit);
-    ecs_add(world, e6, RangedUnit);
-    ecs_add(world, e7, Unit);
-
-    /* entities that don't match query */
-    ecs_new(world, Unit);
-    ecs_new(world, MeleeUnit);
-    ecs_new(world, Warrior);
-    ecs_new(world, Warlock);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x), MeleeUnit($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warlock, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Warrior, ecs_field_id(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(MeleeUnit, ecs_field_id(&it, 2));
-        test_uint(e5, ecs_field_src(&it, 1));
-        test_uint(e5, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_ent_src_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warrior);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Unit(e1)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!MeleeUnit(e1)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Warrior(e1)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Warlock(e1)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!RangedUnit(e1)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(RangedUnit, ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Archer(e1)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Wizard(e1)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_src_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Unit);
-    ecs_add(world, e2, MeleeUnit);
-    ecs_add(world, e3, RangedUnit);
-    ecs_add(world, e4, Warrior);
-    ecs_add(world, e5, Archer);
-    ecs_add(world, e6, Wizard);
-    ecs_add(world, e7, Warlock);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Unit($this), Tag($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!MeleeUnit($this), Tag($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(MeleeUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(MeleeUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(MeleeUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e5, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(MeleeUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e6, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Warrior($this), Tag($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e5, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e6, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Warlock($this), Tag($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e4, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e5, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e6, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!RangedUnit($this), Tag($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(RangedUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(RangedUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(RangedUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e4, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Archer($this), Tag($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e4, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e6, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e7, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Wizard($this), Tag($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e4, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e5, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_src_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Unit);
-    ecs_add(world, e2, MeleeUnit);
-    ecs_add(world, e3, RangedUnit);
-    ecs_add(world, e4, Warrior);
-    ecs_add(world, e5, Archer);
-    ecs_add(world, e6, Wizard);
-    ecs_add(world, e7, Warlock);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Unit($x), Tag($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!MeleeUnit($x), Tag($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(MeleeUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(MeleeUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(MeleeUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e5, ecs_field_src(&it, 1));
-            test_uint(e5, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(MeleeUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e6, ecs_field_src(&it, 1));
-            test_uint(e6, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Warrior($x), Tag($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e5, ecs_field_src(&it, 1));
-            test_uint(e5, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e6, ecs_field_src(&it, 1));
-            test_uint(e6, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Warlock($x), Tag($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e4, ecs_field_src(&it, 1));
-            test_uint(e4, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e5, ecs_field_src(&it, 1));
-            test_uint(e5, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e6, ecs_field_src(&it, 1));
-            test_uint(e6, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!RangedUnit($x), Tag($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(RangedUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(RangedUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(RangedUnit, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e4, ecs_field_src(&it, 1));
-            test_uint(e4, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Archer($x), Tag($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e4, ecs_field_src(&it, 1));
-            test_uint(e4, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e6, ecs_field_src(&it, 1));
-            test_uint(e6, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Archer, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e7, ecs_field_src(&it, 1));
-            test_uint(e7, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e7, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "!Wizard($x), Tag($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e4, ecs_field_src(&it, 1));
-            test_uint(e4, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Wizard, ecs_field_id(&it, 1));
-            test_uint(Tag, ecs_field_id(&it, 2));
-            test_uint(e5, ecs_field_src(&it, 1));
-            test_uint(e5, ecs_field_src(&it, 2));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 2));
-            test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_this_src_not_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Unit);
-    ecs_add(world, e2, MeleeUnit);
-    ecs_add(world, e3, RangedUnit);
-    ecs_add(world, e4, Warrior);
-    ecs_add(world, e5, Archer);
-    ecs_add(world, e6, Wizard);
-    ecs_add(world, e7, Warlock);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($this), !Unit($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($this), !MeleeUnit($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(e1, it.entities[0]);
-            test_uint(Tag, ecs_field_id(&it, 1));
-
-            test_uint(MeleeUnit, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(e3, it.entities[0]);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(MeleeUnit, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(e5, it.entities[0]);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(MeleeUnit, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(e6, it.entities[0]);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(MeleeUnit, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($this), !Warrior($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e3, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e5, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e6, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($this), !Warlock($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e3, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e4, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e5, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e6, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($this), !RangedUnit($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(RangedUnit, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(RangedUnit, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(RangedUnit, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e4, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($this), !Archer($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e3, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e4, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e6, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e7, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($this), !Wizard($this)" });
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e3, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e4, it.entities[0]);
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(1, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(0, ecs_field_src(&it, 1));
-            test_uint(0, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e5, it.entities[0]);
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_1_var_src_not_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Unit);
-    ecs_add(world, e2, MeleeUnit);
-    ecs_add(world, e3, RangedUnit);
-    ecs_add(world, e4, Warrior);
-    ecs_add(world, e5, Archer);
-    ecs_add(world, e6, Wizard);
-    ecs_add(world, e7, Warlock);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($x), !Unit($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($x), !MeleeUnit($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(MeleeUnit, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(MeleeUnit, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(MeleeUnit, ecs_field_id(&it, 2));
-            test_uint(e5, ecs_field_src(&it, 1));
-            test_uint(e5, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(MeleeUnit, ecs_field_id(&it, 2));
-            test_uint(e6, ecs_field_src(&it, 1));
-            test_uint(e6, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($x), !Warrior($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(e5, ecs_field_src(&it, 1));
-            test_uint(e5, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warrior, ecs_field_id(&it, 2));
-            test_uint(e6, ecs_field_src(&it, 1));
-            test_uint(e6, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($x), !Warlock($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(e4, ecs_field_src(&it, 1));
-            test_uint(e4, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(e5, ecs_field_src(&it, 1));
-            test_uint(e5, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Warlock, ecs_field_id(&it, 2));
-            test_uint(e6, ecs_field_src(&it, 1));
-            test_uint(e6, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($x), !RangedUnit($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(RangedUnit, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(RangedUnit, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(RangedUnit, ecs_field_id(&it, 2));
-            test_uint(e4, ecs_field_src(&it, 1));
-            test_uint(e4, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($x), !Archer($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(e4, ecs_field_src(&it, 1));
-            test_uint(e4, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(e6, ecs_field_src(&it, 1));
-            test_uint(e6, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Archer, ecs_field_id(&it, 2));
-            test_uint(e7, ecs_field_src(&it, 1));
-            test_uint(e7, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e7, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, { .expr = "Tag($x), !Wizard($x)" });
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(e2, ecs_field_src(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(e3, ecs_field_src(&it, 1));
-            test_uint(e3, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(e4, ecs_field_src(&it, 1));
-            test_uint(e4, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Tag, ecs_field_id(&it, 1));
-            test_uint(Wizard, ecs_field_id(&it, 2));
-            test_uint(e5, ecs_field_src(&it, 1));
-            test_uint(e5, ecs_field_src(&it, 2));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 2));
-            test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_first_self(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_add(world, e2, Warrior);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:self:(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warlock:self:(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:self:(e2)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_first_down(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_add(world, e2, Warrior);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:down:(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warlock:down:(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:down:(e2)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_first_self_down(void) {
-    ecs_world_t *world = ecs_init();
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_add(world, e2, Warrior);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:self|down:(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warlock:self|down:(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:self|down:(e2)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_first_rel_self(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Rel, Traversable);
-    ECS_TAG(world, Warrior);
-    ECS_ENTITY(world, Warlock, (Rel, Warrior));
-
-    populate_facts(world);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-
-    ecs_log_set_level(-4);
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Warrior:self(Rel):(e1)"
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_first_rel_down(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Rel, Traversable);
-    ECS_TAG(world, Warrior);
-    ECS_ENTITY(world, Warlock, (Rel, Warrior));
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_add(world, e2, Warrior);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:down(Rel):(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warlock:down(Rel):(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:down(Rel):(e2)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesComponentInheritance_first_rel_self_down(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Rel, Traversable);
-    ECS_TAG(world, Warrior);
-    ECS_ENTITY(world, Warlock, (Rel, Warrior));
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, Warlock);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_add(world, e2, Warrior);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:self|down(Rel):(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warlock:self|down(Rel):(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warlock, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "Warrior:self|down(Rel):(e2)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(Warrior, ecs_field_id(&it, 1));
-            test_bool(true, ecs_field_is_set(&it, 1));
-            test_uint(e2, ecs_field_src(&it, 1));
-
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/RulesOperators.c b/test/addons/src/RulesOperators.c
deleted file mode 100644
index fd7a8401d..000000000
--- a/test/addons/src/RulesOperators.c
+++ /dev/null
@@ -1,6987 +0,0 @@
-#include <addons.h>
-
-void RulesOperators_2_and_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !RelB($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add(world, e1, RelB);
-    ecs_add(world, e2, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, e1, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_not_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !RelB($this), !RelC($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add(world, e1, RelB);
-    ecs_add(world, e2, RelB);
-    ecs_add(world, e1, RelC);
-    ecs_add(world, e2, RelC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, e1, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, e2, RelC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, e1, RelC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_rel_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !*($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_tgt_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !RelA($this, *)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add_pair(world, e2, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_rel_tgt_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !*($this, *)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add_pair(world, e2, RelA, TgtB);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !$x($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !RelA($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add_pair(world, e2, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_rel_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int32_t y_var = ecs_rule_find_var(r, "x");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_rel_tgt_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !$x($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add_pair(world, e1, RelA, RelA);
-    ecs_add_pair(world, e2, RelA, RelA);
-    ecs_add_pair(world, e1, RelB, RelB);
-    ecs_add_pair(world, e2, RelB, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelB, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_rel_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), !$x($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelB);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e2, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_tgt_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), !RelA($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e2, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_rel_tgt_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), !$x($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
-    ecs_add_pair(world, e1, TgtA, TgtA);
-    ecs_add_pair(world, e1, TgtB, TgtB);
-    ecs_add_pair(world, e2, TgtA, TgtA);
-    ecs_add_pair(world, e2, TgtB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, TgtA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e2, TgtB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_rel_tgt_same_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), !$x($this, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
-    ecs_add_pair(world, e1, TgtA, e1);
-    ecs_add_pair(world, e1, TgtB, e1);
-    ecs_add_pair(world, e2, TgtA, e2);
-    ecs_add_pair(world, e2, TgtB, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, TgtA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, e1), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e2, TgtB, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, e1), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtB, e2), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-
-void RulesOperators_2_and_not_pair_rel_src_tgt_same_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), !$x($x, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add_pair(world, e1, e1, e1);
-    ecs_add_pair(world, e2, e2, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e2, e2, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_any_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !_($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), !RelA($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_not_pair_any_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), !RelA(_, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_new_w_pair(world, Tag, TgtB);
-    ecs_new_w_pair(world, Tag, TgtC);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, RelA, TgtB);
-    ecs_add_pair(world, e4, RelA, TgtC);
-    ecs_new_w_pair(world, RelA, TgtC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_not_any_src_fixed_first(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!RelA(_)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_not_any_src_any_tgt_fixed_first(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!RelA(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_not_any_src_any_first_fixed_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!_(_, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_not_any_src_any_childof_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!ChildOf(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_not_any_src_any_isa_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!IsA(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsIsA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, EcsIsA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelB($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add(world, e2, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);   
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_optional(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelB($this), ?RelC($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_add(world, e2, RelB);
-    ecs_add(world, e3, RelC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_rel_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?*($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_tgt_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, *)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?$x($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_rel_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_rel_tgt_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?$x($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    ecs_add_pair(world, e2, TgtA, TgtA);
-    ecs_add_pair(world, e3, TgtA, TgtA);
-    ecs_add_pair(world, e3, RelA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e2, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e3, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, RelA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e3, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_rel_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), ?$x($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_add_pair(world, e3, Tag, RelB);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_tgt_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), ?RelA($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_add_pair(world, e3, Tag, TgtB);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtB);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_rel_tgt_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), ?$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_add_pair(world, e3, Tag, RelB);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_rel_tgt_same_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), ?$x($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_add_pair(world, e3, Tag, RelA);
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    ecs_add_pair(world, e2, TgtA, TgtA);
-    ecs_add_pair(world, e3, TgtA, TgtA);
-    ecs_add_pair(world, e3, RelA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, RelA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_rel_src_tgt_same_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), ?$x($x, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_add_pair(world, e2, e2, e2);
-    ecs_add_pair(world, e3, e3, e3);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e3, e3), ecs_field_id(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_optional_pair_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelB($this, $x), ?RelC($this, $y)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int32_t y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-    ecs_add_pair(world, e3, RelC, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelC, EcsWildcard), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelC, EcsWildcard), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelC, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_any_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?_($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_and_optional_pair_any_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), ?RelA(_, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtC);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, RelA, TgtB);
-    ecs_add_pair(world, e4, RelA, TgtC);
-    ecs_new_w_pair(world, RelA, TgtC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtC), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_and_pair_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?$x($this, TgtA), $x($this, TgtB)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_entity_t e4 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-
-    ecs_add_pair(world, e2, RelA, TgtB);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-    ecs_add_pair(world, e3, RelB, TgtB);
-
-    ecs_add_pair(world, e4, RelA, TgtA);
-    ecs_add_pair(world, e4, RelA, TgtB);
-    ecs_add_pair(world, e4, RelB, TgtA);
-    ecs_add_pair(world, e4, RelB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_and_pair_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, $x), RelB($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_entity_t e4 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtB);
-
-    ecs_add_pair(world, e4, RelA, TgtA);
-    ecs_add_pair(world, e4, RelA, TgtB);
-    ecs_add_pair(world, e4, RelB, TgtA);
-    ecs_add_pair(world, e4, RelB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_and_pair_rel_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?$x($this, $y), $y($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TgtA, RelA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, RelA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(RelA, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_and_pair_rel_tgt_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, $x), $x($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, TgtA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_and_pair_rel_tgt_same_other_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, $x), $y($x, $y)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new_w_pair(world, TgtA, TgtA);
-    ecs_entity_t t3 = ecs_new_w_pair(world, TgtB, TgtB);
-    ecs_add_pair(world, t3, TgtC, TgtC);
-
-    ecs_add_pair(world, e2, RelA, t1);
-    ecs_add_pair(world, e3, RelA, t2);
-    ecs_add_pair(world, e3, RelA, t3);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(EcsWildcard, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t2), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t2, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(t2, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t3), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t3, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(t3, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t3), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TgtC, TgtC), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t3, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(t3, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_and_pair_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, $x), Tag($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new(world, Tag);
-    ecs_entity_t t3 = ecs_new(world, Tag);
-
-    ecs_add_pair(world, e2, RelA, t1);
-    ecs_add_pair(world, e3, RelA, t2);
-    ecs_add_pair(world, e3, RelA, t3);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(EcsWildcard, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t2), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t2, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(t2, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t3), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t3, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(t3, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_optional_pair_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?$x($this, TgtA), ?$x($this, TgtB)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_entity_t e4 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-
-    ecs_add_pair(world, e2, RelA, TgtB);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-    ecs_add_pair(world, e3, RelB, TgtB);
-
-    ecs_add_pair(world, e4, RelA, TgtA);
-    ecs_add_pair(world, e4, RelA, TgtB);
-    ecs_add_pair(world, e4, RelB, TgtA);
-    ecs_add_pair(world, e4, RelB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e2, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e3, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e4, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e4, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_optional_pair_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, $x), ?RelB($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_entity_t e4 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtB);
-
-    ecs_add_pair(world, e4, RelA, TgtA);
-    ecs_add_pair(world, e4, RelA, TgtB);
-    ecs_add_pair(world, e4, RelB, TgtA);
-    ecs_add_pair(world, e4, RelB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_optional_pair_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, $x), ?Tag($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new(world, Tag);
-    ecs_entity_t t3 = ecs_new(world, Tag);
-
-    ecs_add_pair(world, e2, RelA, t1);
-    ecs_add_pair(world, e3, RelA, t2);
-    ecs_add_pair(world, e3, RelA, t3);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(EcsWildcard, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t1), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t1, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(t1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t2), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t2, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(t2, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t3), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t3, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(t3, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_not_pair_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?$x($this, TgtA), !$x($this, TgtB)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtB);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-    ecs_add_pair(world, e3, RelB, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-    
-    ecs_remove_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e3, RelB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_not_pair_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, $x), !RelB($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    ecs_add_pair(world, e3, RelA, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtB);
-    ecs_add_pair(world, e3, RelB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-    
-    ecs_remove_pair(world, e3, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e3, RelB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_and_optional_dependent_not_pair_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), ?RelA($this, $x), !Tag($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_entity_t t1 = ecs_new(world, Tag);
-    ecs_entity_t t2 = ecs_new(world, Tag);
-    ecs_entity_t t3 = ecs_new(world, Tag);
-
-    ecs_add_pair(world, e2, RelA, t1);
-    ecs_add_pair(world, e3, RelA, t2);
-    ecs_add_pair(world, e3, RelA, t3);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(EcsWildcard, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, t1, Tag);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(EcsWildcard, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e2, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t1), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t1, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(t1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e3, RelA, t2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(EcsWildcard, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e2, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t1), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t1, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(t1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove_pair(world, e3, RelA, t3);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(EcsWildcard, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e2, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, t1), ecs_field_id(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(t1, ecs_field_src(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(t1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_optional_any_src_fixed_first(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "?RelA(_)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new(world, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_optional_any_src_any_tgt_fixed_first(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "?RelA(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_optional_any_src_any_first_fixed_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "?_(_, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, TgtA, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_optional_any_src_any_childof_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "?ChildOf(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_optional_any_src_any_isa_pair_any_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "?IsA(_, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsIsA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_new_w_pair(world, EcsIsA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(EcsIsA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this) || RelB($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelB);
-    ecs_new(world, RelC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_or(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, RelD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this) || RelB($this) || RelC($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelB);
-    ecs_entity_t e3 = ecs_new(world, RelC);
-    ecs_new(world, RelD);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelC, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this), RelA($this) || RelB($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e2, RelA);
-    ecs_add(world, e2, RelB);
-    ecs_add(world, e3, RelB);
-    ecs_add(world, e4, RelC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_or_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, RelD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this), RelA($this) || RelB($this) || RelC($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e2, RelB);
-    ecs_add(world, e3, RelB);
-    ecs_add(world, e3, RelC);
-    ecs_add(world, e4, RelC);
-    ecs_add(world, e5, RelD);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelC, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_written_w_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), $x($this, TgtA) || $x($this, TgtB)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, RelC);
-    ecs_entity_t e4 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtB);
-    ecs_add_pair(world, e3, RelC, TgtA);
-    ecs_add_pair(world, e3, RelC, TgtB);
-    ecs_add_pair(world, e4, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelC), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelC, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_or_written_w_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, RelD);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), $x($this, TgtA) || $x($this, TgtB) || $x($this, TgtC)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, RelC);
-    ecs_entity_t e4 = ecs_new_w_pair(world, Tag, RelD);
-    ecs_entity_t e5 = ecs_new_w_pair(world, Tag, RelA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtB);
-    ecs_add_pair(world, e3, RelC, TgtA);
-    ecs_add_pair(world, e3, RelC, TgtB);
-    ecs_add_pair(world, e4, RelD, TgtC);
-    ecs_add_pair(world, e5, RelD, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelC), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelC, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, RelD), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelD, TgtC), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(RelD, ecs_iter_get_var(&it, x_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_written_w_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), RelA($this, $x) || RelB($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtC);
-    ecs_entity_t e4 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtB);
-    ecs_add_pair(world, e3, RelA, TgtC);
-    ecs_add_pair(world, e3, RelB, TgtC);
-    ecs_add_pair(world, e4, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtC), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_written_w_rel_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, TgtD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $x), RelB($this, $y), $x($this, $y) || $y($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtC);
-    ecs_entity_t e4 = ecs_new_w_pair(world, RelA, TgtD);
-
-    ecs_add_pair(world, e1, RelB, TgtD);
-    ecs_add_pair(world, e2, RelB, TgtC);
-    ecs_add_pair(world, e3, RelB, TgtB);
-    ecs_add_pair(world, e4, RelB, TgtA);
-
-    ecs_add_pair(world, e2, TgtB, TgtC);
-    ecs_add_pair(world, e3, TgtB, TgtC);
-    ecs_add_pair(world, e4, TgtD, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtC), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TgtB, TgtC), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtC, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TgtB, TgtC), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtD), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TgtD, TgtA), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtD, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_written_w_rel_tgt_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, TgtD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $x), $x($this, $x) || RelB($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtC);
-    ecs_new_w_pair(world, RelA, TgtC);
-
-    ecs_add_pair(world, e1, TgtA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtB);
-    ecs_add_pair(world, e3, TgtC, TgtC);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtC, TgtC), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_or_written_w_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, TgtD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this, $x), RelA($this, $x) || RelB($this, $x) || RelC($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtC);
-    ecs_entity_t e4 = ecs_new_w_pair(world, Tag, TgtD);
-    ecs_entity_t e5 = ecs_new_w_pair(world, Tag, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelB, TgtB);
-    ecs_add_pair(world, e3, RelA, TgtC);
-    ecs_add_pair(world, e3, RelB, TgtC);
-    ecs_add_pair(world, e4, RelC, TgtD);
-    ecs_add_pair(world, e5, RelA, TgtD);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtC), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Tag, TgtD), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelC, TgtD), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(TgtD, ecs_iter_get_var(&it, x_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_chains_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, RelD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this), RelA($this) || RelB($this), RelC($this) || RelD($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e2, RelC);
-
-    ecs_add(world, e3, RelA);
-    ecs_add(world, e3, RelC);
-
-    ecs_add(world, e4, RelA);
-    ecs_add(world, e4, RelD);
-
-    ecs_add(world, e5, RelB);
-    ecs_add(world, e5, RelC);
-
-    ecs_add(world, e6, RelB);
-    ecs_add(world, e6, RelD);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(RelD, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e5, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(RelD, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e6, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_chains(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, RelD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this) || RelB($this), RelC($this) || RelD($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-    ecs_entity_t e5 = ecs_new_id(world);
-    ecs_entity_t e6 = ecs_new_id(world);
-
-    ecs_add(world, e1, RelA);
-    ecs_add(world, e2, RelC);
-
-    ecs_add(world, e3, RelA);
-    ecs_add(world, e3, RelC);
-
-    ecs_add(world, e4, RelA);
-    ecs_add(world, e4, RelD);
-
-    ecs_add(world, e5, RelB);
-    ecs_add(world, e5, RelC);
-
-    ecs_add(world, e6, RelB);
-    ecs_add(world, e6, RelD);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e3, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelC, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e4, it.entities[0]);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelD, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e5, it.entities[0]);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(RelC, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e6, it.entities[0]);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(RelD, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_dependent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelB($this) || RelA($this, $tgt), RelC($tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    int tgt_var = ecs_rule_find_var(r, "tgt");
-    test_assert(tgt_var != -1);
-
-    ecs_entity_t tgt = ecs_new(world, RelC);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add(world, e1, RelB);
-    ecs_add_pair(world, e2, RelA, tgt);
-    ecs_add(world, e3, RelB);
-    ecs_add(world, e3, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, tgt), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, it.entities[0]);
-        test_uint(tgt, ecs_iter_get_var(&it, tgt_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_dependent_reverse(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $tgt) || RelB($this), RelC($tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    int tgt_var = ecs_rule_find_var(r, "tgt");
-    test_assert(tgt_var != -1);
-
-    ecs_entity_t tgt = ecs_new(world, RelC);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add(world, e1, RelB);
-    ecs_add_pair(world, e2, RelA, tgt);
-    ecs_add(world, e3, RelB);
-    ecs_add(world, e3, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, tgt), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, it.entities[0]);
-        test_uint(tgt, ecs_iter_get_var(&it, tgt_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_dependent_2_vars(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, RelD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $x) || RelB($this, $y), RelC($x), RelD($y)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_entity_t tgt_a = ecs_new(world, RelC);
-    ecs_entity_t tgt_b = ecs_new(world, RelD);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, RelA, tgt_a);
-    ecs_add_pair(world, e2, RelB, tgt_b);
-
-    ecs_add_pair(world, e3, RelA, tgt_b);
-    ecs_add_pair(world, e4, RelB, tgt_a);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, tgt_a), ecs_field_id(&it, 1));
-        test_uint(RelC, ecs_field_id(&it, 2));
-        test_uint(RelD, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(e1, it.entities[0]);
-        test_uint(tgt_a, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelB, tgt_b), ecs_field_id(&it, 1));
-        test_uint(RelC, ecs_field_id(&it, 2));
-        test_uint(RelD, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(e2, it.entities[0]);
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(tgt_b, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_written_dependent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag, RelA($this, $tgt) || RelB($this), RelC($tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    int tgt_var = ecs_rule_find_var(r, "tgt");
-    test_assert(tgt_var != -1);
-
-    ecs_entity_t tgt = ecs_new(world, RelC);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, RelB);
-    ecs_add_pair(world, e2, RelA, tgt);
-    ecs_add(world, e3, RelB);
-    ecs_add(world, e3, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(e1, it.entities[0]);
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, tgt), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(e2, it.entities[0]);
-        test_uint(tgt, ecs_iter_get_var(&it, tgt_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(e3, it.entities[0]);
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_written_dependent_2_vars(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, RelD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag, RelA($this, $x) || RelB($this, $y), RelC($x), RelD($y)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_entity_t tgt_a = ecs_new(world, RelC);
-    ecs_entity_t tgt_b = ecs_new(world, RelD);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-
-    ecs_add_pair(world, e1, RelA, tgt_a);
-    ecs_add_pair(world, e2, RelB, tgt_b);
-
-    ecs_add_pair(world, e3, RelA, tgt_b);
-    ecs_add_pair(world, e4, RelB, tgt_a);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, tgt_a), ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_id(&it, 3));
-        test_uint(RelD, ecs_field_id(&it, 4));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_bool(false, ecs_field_is_set(&it, 4));
-        test_uint(e1, it.entities[0]);
-        test_uint(tgt_a, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, tgt_b), ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_id(&it, 3));
-        test_uint(RelD, ecs_field_id(&it, 4));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_bool(true, ecs_field_is_set(&it, 4));
-        test_uint(e2, it.entities[0]);
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(tgt_b, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_w_dependent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, RelD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag, ?RelA($this, $x), RelB($x) || RelC($x)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t tgt_a = ecs_new(world, RelB);
-    ecs_entity_t tgt_b = ecs_new(world, RelC);
-    ecs_entity_t tgt_c = ecs_new(world, RelD);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-
-    ecs_add_pair(world, e2, RelA, tgt_a);
-    ecs_add_pair(world, e3, RelA, tgt_b);
-    ecs_add_pair(world, e4, RelA, tgt_c);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 2));
-        // test_uint(RelC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 3));
-        test_uint(e1, it.entities[0]);
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, tgt_a), ecs_field_id(&it, 2));
-        test_uint(RelB, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(e2, it.entities[0]);
-        test_uint(tgt_a, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, tgt_b), ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 3));
-        test_uint(e3, it.entities[0]);
-        test_uint(tgt_b, ecs_iter_get_var(&it, x_var));
-
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_or_w_both(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA || RelB"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add(world, e2, RelB);
-    ecs_entity_t e3 = ecs_new(world, RelB);
-    ecs_new(world, RelC);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(RelA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(RelA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(RelB, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_3_or_w_both(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, RelD);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA || RelB || RelC"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_add(world, e2, RelB);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-    ecs_add(world, e3, RelD);
-
-    ecs_entity_t e4 = ecs_new(world, RelB);
-    ecs_entity_t e5 = ecs_new(world, RelB);
-    ecs_add(world, e5, RelC);
-    ecs_entity_t e6 = ecs_new(world, RelB);
-    ecs_add(world, e6, RelD);
-
-    ecs_entity_t e7 = ecs_new(world, RelC);
-    ecs_entity_t e8 = ecs_new(world, RelC);
-    ecs_add(world, e8, RelD);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(RelA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(RelA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(RelA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(RelB, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(RelB, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(RelB, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(RelC, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e8, it.entities[0]);
-    test_uint(RelC, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_not_first(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-
-    ecs_add(world, e1, TagB);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e3, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!TagB($this), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, e1, TagB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagB, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, e2, TagB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(TagB, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_2_optional_first(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-
-    ecs_add(world, e1, TagB);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e3, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "?TagB($this), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(3, it.count);
-        test_uint(TagB, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, e3, TagB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(TagB, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagB, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_root_entities_empty(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!ChildOf($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(EcsFlecs, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_root_entities(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!ChildOf($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_new_entity(world, "e1.e2");
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(EcsFlecs, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_root_entities_w_children(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!ChildOf($this, _), ChildOf(_, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_add_pair(world, e3, EcsChildOf, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, EcsFlecs), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(EcsFlecs, ecs_iter_get_var(&it, this_var));
-        test_uint(EcsFlecs, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, e2), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_root_entities_w_optional_children(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!ChildOf($this, _), ?ChildOf(_, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_add_pair(world, e3, EcsChildOf, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, EcsFlecs), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(EcsFlecs, ecs_iter_get_var(&it, this_var));
-        test_uint(EcsFlecs, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, Tag), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(Tag, ecs_iter_get_var(&it, this_var));
-        test_uint(Tag, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, e1), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, e2), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, e4), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e4, ecs_iter_get_var(&it, this_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_core_entities_w_optional_children(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "ChildOf($this, flecs.core), ?ChildOf(_, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        while (ecs_rule_next(&it)) {
-            test_assert(ecs_field_is_set(&it, 1));
-            for (int i = 0; i < it.count; i ++) {
-                test_assert(ecs_has_pair(
-                    world, it.entities[i], EcsChildOf, EcsFlecsCore));
-                if (ecs_field_is_set(&it, 2)) {
-                    test_assert(ecs_count_id(
-                        world, ecs_pair(EcsChildOf, it.entities[i])) != 0);
-                } else {
-                    test_assert(ecs_count_id(
-                        world, ecs_pair(EcsChildOf, it.entities[i])) == 0);
-                }
-            }
-        }
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_root_entities_w_not_children(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!ChildOf($this, _), !ChildOf(_, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_add_pair(world, e3, EcsChildOf, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, Tag), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(Tag, ecs_iter_get_var(&it, this_var));
-        test_uint(Tag, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, e1), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, e4), ecs_field_id(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(e4, ecs_iter_get_var(&it, this_var));
-        test_uint(e4, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_core_entities_w_not_children(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "ChildOf($this, flecs.core), !ChildOf(_, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        while (ecs_rule_next(&it)) {
-            test_assert(ecs_field_is_set(&it, 1));
-            test_assert(!ecs_field_is_set(&it, 2));
-            for (int i = 0; i < it.count; i ++) {
-                test_assert(ecs_has_pair(
-                    world, it.entities[i], EcsChildOf, EcsFlecsCore));
-                test_assert(ecs_count_id(
-                    world, ecs_pair(EcsChildOf, it.entities[i])) == 0);
-            }
-        }
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add(world, e1, RelA);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelA(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelB(e1)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(RelB, ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, Tgt);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, Tgt);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelA(e1, Tgt)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelB(e1, Tgt)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!*(e1, TgtA)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!*(e1, TgtB)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_tgt_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelA(e1, *)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelB(e1, *)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_tgt_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!*(e1, *)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!_(e1, TgtA)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!_(e1, TgtB)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_tgt_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelA(e1, _)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelB(e1, _)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_tgt_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!_(e1, _)"
-        });
-
-        test_assert(r != NULL);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!$x(e1, TgtA)"
-        });
-
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!$x(e1, TgtB)"
-        });
-
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelA(e1, $x)"
-        });
-
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!RelB(e1, $x)"
-        });
-
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!$x(e1, $y)"
-        });
-
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-        int y_var = ecs_rule_find_var(r, "y");
-        test_assert(y_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_tgt_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    {
-        ecs_rule_t *r = ecs_rule(world, {
-            .expr = "!$x(e1, $x)"
-        });
-
-        test_assert(r != NULL);
-
-        int x_var = ecs_rule_find_var(r, "x");
-        test_assert(x_var != -1);
-
-        {
-            ecs_iter_t it = ecs_rule_iter(world, r);
-            test_bool(true, ecs_rule_next(&it));
-            test_uint(0, it.count);
-            test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
-            test_uint(e1, ecs_field_src(&it, 1));
-            test_bool(false, ecs_field_is_set(&it, 1));
-            test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-            test_bool(false, ecs_rule_next(&it));
-        }
-
-        ecs_rule_fini(r);
-    }
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_this_src_not_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!$x($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add_pair(world, e2, RelA, TgtB);
-
-    bool e2_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_assert(it.count != 0);
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != e1);
-            if (it.entities[i] == e2) {
-                e2_found = true;
-            }
-        }
-
-        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-    }
-
-    test_assert(e2_found);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_this_src_not_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!RelA($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add_pair(world, e2, RelB, TgtA);
-
-    bool e2_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_assert(it.count != 0);
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != e1);
-            if (it.entities[i] == e2) {
-                e2_found = true;
-            }
-        }
-
-        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-    }
-
-    test_assert(e2_found);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_this_src_not_pair_rel_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add(world, e2, TgtA);
-
-    bool e2_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_assert(it.count != 0);
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != e1);
-            if (it.entities[i] == e2) {
-                e2_found = true;
-            }
-        }
-
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
-    }
-
-    test_assert(e2_found);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_this_src_not_pair_rel_tgt_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, RelA);
-
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_add(world, e3, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "!$x($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    bool e1_found = false;
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    while (ecs_rule_next(&it)) {
-        test_assert(it.count != 0);
-        for (int i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != e2);
-            if (it.entities[i] == e1) {
-                e1_found = true;
-            }
-        }
-
-        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
-    }
-
-    test_assert(e1_found);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_ENTITY(world, RelA, Tag);
-    ECS_ENTITY(world, RelB, Tag);
-    ECS_ENTITY(world, RelC, Tag);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtB);
-    ecs_add_pair(world, e1, RelC, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x), !$x(e1, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(RelC, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_tgt_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_ENTITY(world, TgtA, Tag);
-    ECS_ENTITY(world, TgtB, Tag);
-    ECS_ENTITY(world, TgtC, Tag);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add_pair(world, e1, RelB, TgtB);
-    ecs_add_pair(world, e1, RelB, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x), !RelA(e1, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 2));
-        test_uint(TgtC, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_tgt_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_ENTITY(world, RelA, (Tag, TgtA));
-    ECS_ENTITY(world, RelB, (Tag, TgtA));
-    ECS_ENTITY(world, RelC, (Tag, TgtB));
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e1, RelC, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x, $y), !$x(e1, $y)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelC, TgtB), ecs_field_id(&it, 2));
-        test_uint(RelC, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(RelC, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesOperators_1_ent_src_not_pair_rel_tgt_same_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelA);
-    ECS_ENTITY(world, RelB, Tag);
-    ECS_ENTITY(world, TgtA, Tag);
-    ECS_ENTITY(world, TgtB, Tag);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e1, TgtA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtB);
-    ecs_add_pair(world, e1, TgtB, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x), !$x(e1, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, RelB), ecs_field_id(&it, 2));
-        test_uint(RelB, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/RulesRecycled.c b/test/addons/src/RulesRecycled.c
deleted file mode 100644
index d8864108e..000000000
--- a/test/addons/src/RulesRecycled.c
+++ /dev/null
@@ -1,208 +0,0 @@
-#include <addons.h>
-
-static ecs_entity_t recycled_id(ecs_world_t *world, const char *name) {
-    ecs_entity_t result = ecs_new_id(world);
-    ecs_delete(world, result);
-    ecs_entity_t result_2 = ecs_new_id(world);
-    test_assert(result_2 != (uint32_t)result);
-    ecs_set_name(world, result_2, name);
-    return result_2;
-}
-
-void RulesRecycled_recycled_vars(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    
-    ecs_entity_t src = recycled_id(world, "src");
-    ecs_entity_t rel = recycled_id(world, "rel");
-    ecs_add(world, src, Tag);
-    ecs_add_id(world, src, rel);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($y), Tag($y)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_uint(0, it.count);
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 2));
-    test_uint(src, ecs_field_src(&it, 1));
-    test_uint(src, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_iter_get_var(&it, x_var));
-    test_uint(src, ecs_iter_get_var(&it, y_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_uint(0, it.count);
-    test_uint(rel, ecs_field_id(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 2));
-    test_uint(src, ecs_field_src(&it, 1));
-    test_uint(src, ecs_field_src(&it, 2));
-    test_uint(rel, ecs_iter_get_var(&it, x_var));
-    test_uint(src, ecs_iter_get_var(&it, y_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesRecycled_recycled_pair_vars(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    
-    ecs_entity_t src = recycled_id(world, "src");
-    ecs_entity_t rel = recycled_id(world, "rel");
-    ecs_entity_t tgt = recycled_id(world, "tgt");
-    ecs_add(world, src, Tag);
-    ecs_add_pair(world, src, rel, tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($y, $z), Tag($y)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-    int32_t z_var = ecs_rule_find_var(r, "z");
-    test_assert(z_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_uint(0, it.count);
-    test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 2));
-    test_uint(src, ecs_field_src(&it, 1));
-    test_uint(src, ecs_field_src(&it, 2));
-    test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
-    test_uint(src, ecs_iter_get_var(&it, y_var));
-    test_uint(EcsName, ecs_iter_get_var(&it, z_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_uint(0, it.count);
-    test_uint(ecs_pair(rel, tgt), ecs_field_id(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 2));
-    test_uint(src, ecs_field_src(&it, 1));
-    test_uint(src, ecs_field_src(&it, 2));
-    test_uint(rel, ecs_iter_get_var(&it, x_var));
-    test_uint(src, ecs_iter_get_var(&it, y_var));
-    test_uint(tgt, ecs_iter_get_var(&it, z_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesRecycled_recycled_this_ent_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    
-    ecs_entity_t src = recycled_id(world, "src");
-    ecs_entity_t rel = recycled_id(world, "rel");
-    ecs_entity_t tgt = recycled_id(world, "tgt");
-    ecs_add(world, src, Tag);
-    ecs_add_pair(world, src, rel, tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($y, $this), Tag($y)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-    int32_t this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_uint(1, it.count);
-    test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 2));
-    test_uint(src, ecs_field_src(&it, 1));
-    test_uint(src, ecs_field_src(&it, 2));
-    test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
-    test_uint(src, ecs_iter_get_var(&it, y_var));
-    test_uint(EcsName, ecs_iter_get_var(&it, this_var));
-    test_uint(EcsName, it.entities[0]);
-
-    test_bool(true, ecs_rule_next(&it));
-    test_uint(1, it.count);
-    test_uint(ecs_pair(rel, tgt), ecs_field_id(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 2));
-    test_uint(src, ecs_field_src(&it, 1));
-    test_uint(src, ecs_field_src(&it, 2));
-    test_uint(rel, ecs_iter_get_var(&it, x_var));
-    test_uint(src, ecs_iter_get_var(&it, y_var));
-    test_uint(tgt, ecs_iter_get_var(&it, this_var));
-    test_uint(tgt, it.entities[0]);
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesRecycled_has_recycled_id_from_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-    
-    ecs_entity_t src = recycled_id(world, "src");
-    ecs_entity_t rel = recycled_id(world, "rel");
-    ecs_entity_t tgt = recycled_id(world, "tgt");
-    ecs_add_pair(world, src, rel, tgt);
-    ecs_add_id(world, src, tgt);
-    ecs_add(world, src, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($y, $z), $z($y), Tag($y)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-    int32_t z_var = ecs_rule_find_var(r, "z");
-    test_assert(z_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_uint(0, it.count);
-    test_uint(ecs_pair(rel, tgt), ecs_field_id(&it, 1));
-    test_uint(tgt, ecs_field_id(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 3));
-    test_uint(src, ecs_field_src(&it, 1));
-    test_uint(src, ecs_field_src(&it, 2));
-    test_uint(src, ecs_field_src(&it, 3));
-    test_uint(rel, ecs_iter_get_var(&it, x_var));
-    test_uint(src, ecs_iter_get_var(&it, y_var));
-    test_uint(tgt, ecs_iter_get_var(&it, z_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/RulesScopes.c b/test/addons/src/RulesScopes.c
deleted file mode 100644
index a410ba049..000000000
--- a/test/addons/src/RulesScopes.c
+++ /dev/null
@@ -1,405 +0,0 @@
-#include <addons.h>
-
-void RulesScopes_term_w_not_scope_1_term(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t parent_1 = ecs_new(world, Root);
-    ecs_add(world, parent_1, TagA);
-
-    ecs_entity_t parent_2 = ecs_new(world, Root);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ TagA }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(parent_2, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesScopes_term_w_not_scope_2_terms(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t parent_1 = ecs_new(world, Root);
-    ecs_add(world, parent_1, TagA);
-
-    ecs_entity_t parent_2 = ecs_new(world, Root);
-    ecs_add(world, parent_2, TagB);
-
-    ecs_entity_t parent_3 = ecs_new(world, Root);
-    ecs_add(world, parent_3, TagA);
-    ecs_add(world, parent_3, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ TagA, TagB }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(parent_1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(parent_2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesScopes_term_w_not_scope_1_term_w_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t parent_1 = ecs_new(world, Root);
-    ecs_add(world, parent_1, TagA);
-
-    ecs_new(world, Root);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ !TagA }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(parent_1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesScopes_term_w_not_scope_2_terms_w_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t parent_1 = ecs_new(world, Root);
-    ecs_add(world, parent_1, TagA);
-
-    ecs_entity_t parent_2 = ecs_new(world, Root);
-    ecs_add(world, parent_2, TagB);
-
-    ecs_entity_t parent_3 = ecs_new(world, Root);
-    ecs_add(world, parent_3, TagA);
-    ecs_add(world, parent_3, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ TagA, !TagB }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(parent_2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(parent_3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesScopes_term_w_not_scope_1_term_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-
-    ecs_entity_t parent_1 = ecs_new(world, Root);
-    ecs_new_w_pair(world, EcsChildOf, parent_1);
-    ecs_new_w_pair(world, EcsChildOf, parent_1);
-
-    ecs_entity_t parent_2 = ecs_new(world, Root);
-    ecs_new_w_pair(world, EcsChildOf, parent_2);
-
-    ecs_entity_t parent_3 = ecs_new(world, Root);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ ChildOf($child, $this) }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(parent_3, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesScopes_term_w_not_scope_2_terms_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t parent_0 = ecs_new(world, Root);
-    {
-        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_0);
-        ecs_set(world, child_1, Position, {10, 20});
-        ecs_entity_t child_2 = ecs_new_w_pair(world, EcsChildOf, parent_0);
-        ecs_set(world, child_2, Position, {10, 20});
-    }
-
-    ecs_entity_t parent_1 = ecs_new(world, Root);
-    {
-        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_1);
-        ecs_set(world, child_1, Position, {10, 20});
-        ecs_new_w_pair(world, EcsChildOf, parent_1);
-    }
-
-    ecs_entity_t parent_2 = ecs_new(world, Root);
-    {
-        ecs_new_w_pair(world, EcsChildOf, parent_2);
-        ecs_new_w_pair(world, EcsChildOf, parent_2);
-    }
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ ChildOf($child, $this), Position($child) }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(parent_2, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesScopes_term_w_not_scope_1_term_w_not_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-
-    ecs_entity_t parent_0 = ecs_new(world, Root);
-    {
-        ecs_new_w_pair(world, EcsChildOf, parent_0);
-        ecs_new_w_pair(world, EcsChildOf, parent_0);
-    }
-
-    ecs_new(world, Root);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ !ChildOf($child, $this) }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(parent_0, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesScopes_term_w_not_scope_2_terms_w_not_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent_0 = ecs_new(world, Root);
-    {
-        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_0);
-        ecs_set(world, child_1, Position, {10, 20});
-        ecs_entity_t child_2 = ecs_new_w_pair(world, EcsChildOf, parent_0);
-        ecs_set(world, child_2, Position, {10, 20});
-        ecs_entity_t child_3 = ecs_new_w_pair(world, EcsChildOf, parent_0);
-        ecs_set(world, child_3, Position, {10, 20});
-        ecs_add(world, child_3, Foo);
-    }
-
-    ecs_entity_t parent_1 = ecs_new(world, Root);
-    {
-        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_1);
-        ecs_set(world, child_1, Position, {10, 20});
-        ecs_new_w_pair(world, EcsChildOf, parent_1);
-    }
-
-    ecs_entity_t parent_2 = ecs_new(world, Root);
-    {
-        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_2);
-        ecs_add(world, child_1, Foo);
-        ecs_new_w_pair(world, EcsChildOf, parent_2);
-    }
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ ChildOf($child, $this), !Position($child) }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(parent_0, it.entities[0]);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesScopes_term_w_not_scope_2_terms_w_or(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new(world, Root);
-    ecs_add(world, e1, TagA);
-    ecs_entity_t e2 = ecs_new(world, Root);
-    ecs_add(world, e2, TagB);
-    ecs_entity_t e3 = ecs_new(world, Root);
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e3, TagB);
-    ecs_entity_t e4 = ecs_new(world, Root);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ TagA || TagB }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e4, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesScopes_term_w_not_scope_3_terms_w_or(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Root);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t e1 = ecs_new(world, Root);
-    ecs_add(world, e1, TagA);
-    ecs_entity_t e2 = ecs_new(world, Root);
-    ecs_add(world, e2, TagB);
-    ecs_entity_t e3 = ecs_new(world, Root);
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e3, TagB);
-    ecs_entity_t e4 = ecs_new(world, Root);
-    ecs_add(world, e4, TagC);
-    ecs_entity_t e5 = ecs_new(world, Root);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Root, !{ TagA || TagB || TagC }"
-    });
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Root, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e5, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/RulesTraversal.c b/test/addons/src/RulesTraversal.c
deleted file mode 100644
index 0c93b65b1..000000000
--- a/test/addons/src/RulesTraversal.c
+++ /dev/null
@@ -1,8202 +0,0 @@
-#include <addons.h>
-
-void RulesTraversal_this_self_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_self_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($x:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($x:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_written_self_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x:self), Foo($x:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(p1, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(p2, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(p3, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e1, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e2, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e3, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e4, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e5, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e6, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e7, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_written_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x:self), Foo($x:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e1, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e2, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e3, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e4, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e5, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e6, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e7, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_set_var_self_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($x:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_entity_t e8 = ecs_new_w_pair(world, EcsChildOf, p0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, p2);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(p2, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(p2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(p1, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e3);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(p2, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e5);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(p1, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e8);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_set_var_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($x:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_entity_t e8 = ecs_new_w_pair(world, EcsChildOf, p0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, p2);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(p1, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e3);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(p2, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e5);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(p1, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e8);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_set_var_written_self_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x:self), Foo($x:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_entity_t e8 = ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, p2);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(p2, ecs_field_src(&it, 1));
-        test_uint(p2, ecs_field_src(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 2));
-        test_uint(p2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(p1, ecs_field_src(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e3);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(p2, ecs_field_src(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e5);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(e5, ecs_field_src(&it, 1));
-        test_uint(p1, ecs_field_src(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 2));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e8);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_set_var_written_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x:self), Foo($x:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_entity_t e8 = ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, p2);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(p1, ecs_field_src(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e3);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(p2, ecs_field_src(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e5);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(e5, ecs_field_src(&it, 1));
-        test_uint(p1, ecs_field_src(&it, 2));
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 2));
-        test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e8);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_ent_self_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(ent:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(e, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, e, Foo);
-    ecs_add_pair(world, e, EcsChildOf, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, parent, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(parent, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_ent_up_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(ent:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e, EcsChildOf, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, parent, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(parent, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_implicit_this_self_up_isa(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsIsA, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsIsA, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsIsA, p3);
-
-    ecs_new_w_pair(world, EcsIsA, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_implicit_this_up_isa(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsIsA, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsIsA, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsIsA, p3);
-
-    ecs_new_w_pair(world, EcsIsA, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_implicit_var_self_up_isa(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsIsA, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsIsA, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsIsA, p3);
-
-    ecs_new_w_pair(world, EcsIsA, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(p1, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(p2, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(p3, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_implicit_var_up_isa(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($x:up)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsIsA, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsIsA, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsIsA, p3);
-
-    ecs_new_w_pair(world, EcsIsA, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_implicit_ent_self_up_isa(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(ent:self|up)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(e, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_remove(world, e, Foo);
-    ecs_add_pair(world, e, EcsIsA, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, parent, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(parent, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_implicit_ent_up_isa(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(ent:up)"
-    });
-
-    test_assert(r != NULL);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e, EcsIsA, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, parent, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(parent, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_self_up_2_targets(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self|up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t parent_a = ecs_new_id(world);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_entity_t parent_c = ecs_new(world, Foo);
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, e_1, EcsIsA, parent_b);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_4 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_add_pair(world, e_4, EcsIsA, parent_c);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(parent_b, it.entities[0]);
-    test_uint(parent_c, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(parent_b, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(parent_b, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_4, it.entities[0]);
-    test_uint(parent_b, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_up_2_targets(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t parent_a = ecs_new_id(world);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_entity_t parent_c = ecs_new(world, Foo);
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, e_1, EcsIsA, parent_b);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_4 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_add_pair(world, e_4, EcsIsA, parent_c);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(parent_b, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(parent_b, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_4, it.entities[0]);
-    test_uint(parent_b, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_self_up_2_targets_diamond(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self|up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t parent_root = ecs_new(world, Foo);
-    ecs_entity_t parent_a = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_b = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_c = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
-
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_entity_t e_3 = ecs_new_w_pair(world, EcsIsA, parent_c);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_root, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(parent_b, it.entities[1]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_c, it.entities[0]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_3, it.entities[0]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_up_2_targets_diamond(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t parent_root = ecs_new(world, Foo);
-    ecs_entity_t parent_a = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_b = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_c = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
-
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_entity_t e_3 = ecs_new_w_pair(world, EcsIsA, parent_c);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(parent_b, it.entities[1]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_c, it.entities[0]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_3, it.entities[0]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_written_self_up_2_targets(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(self|up)"
-    });
-
-    test_assert(r != NULL);
-    
-    ecs_set_with(world, Tag);
-    ecs_entity_t parent_a = ecs_new_id(world);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_entity_t parent_c = ecs_new(world, Foo);
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, e_1, EcsIsA, parent_b);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_4 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_add_pair(world, e_4, EcsIsA, parent_c);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(parent_b, it.entities[0]);
-    test_uint(parent_c, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_written_up_2_targets(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(up)"
-    });
-
-    test_assert(r != NULL);
-    
-    ecs_set_with(world, Tag);
-    ecs_entity_t parent_a = ecs_new_id(world);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_entity_t parent_c = ecs_new(world, Foo);
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, e_1, EcsIsA, parent_b);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_4 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_add_pair(world, e_4, EcsIsA, parent_c);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_written_self_up_2_targets_diamond(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(self|up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t parent_root = ecs_new(world, Foo);
-    ecs_entity_t parent_a = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_b = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_c = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
-
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_entity_t e_3 = ecs_new_w_pair(world, EcsIsA, parent_c);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_root, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(parent_b, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_c, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_written_up_2_targets_diamond(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t parent_root = ecs_new(world, Foo);
-    ecs_entity_t parent_a = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_b = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_c = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
-
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_entity_t e_3 = ecs_new_w_pair(world, EcsIsA, parent_c);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(parent_b, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_c, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_root, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_2_self_up_terms(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag, Foo(self|up)"
-    });
-
-    test_assert(r != NULL);
-    
-    ecs_set_with(world, Tag);
-    ecs_entity_t parent_a = ecs_new_id(world);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_entity_t e_3 = ecs_new_w_pair(world, EcsIsA, e_2);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_b, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_2_self_up_terms_2_targets(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag, Foo(self|up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t parent_a = ecs_new_id(world);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_entity_t parent_c = ecs_new(world, Foo);
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, e_1, EcsIsA, parent_b);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_4 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_add_pair(world, e_4, EcsIsA, parent_c);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(parent_b, it.entities[0]);
-    test_uint(parent_c, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(parent_b, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_self_up_empty_table(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self|up)"
-    });
-
-    test_assert(r != NULL);
-    
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
-    ecs_delete(world, e2);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_up_empty_table(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(up)"
-    });
-
-    test_assert(r != NULL);
-    
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
-    ecs_delete(world, e2);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_self_up_all_owned(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self|up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t parent_root = ecs_new(world, 0);
-    ecs_entity_t parent_a = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_b = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_c = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
-
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_entity_t e_3 = ecs_new_w_pair(world, EcsIsA, parent_c);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_root, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(parent_b, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_c, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_up_all_owned(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t parent_root = ecs_new(world, 0);
-    ecs_entity_t parent_a = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_b = ecs_new_w_pair(world, EcsIsA, parent_root);
-    ecs_entity_t parent_c = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
-
-    ecs_entity_t e_1 = ecs_new_w_pair(world, EcsIsA, parent_a);
-    ecs_entity_t e_2 = ecs_new_w_pair(world, EcsIsA, parent_b);
-    ecs_entity_t e_3 = ecs_new_w_pair(world, EcsIsA, parent_c);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(parent_b, it.entities[1]);
-    test_uint(parent_root, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_1, it.entities[0]);
-    test_uint(parent_a, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_c, it.entities[0]);
-    test_uint(parent_a, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_2, it.entities[0]);
-    test_uint(parent_b, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e_3, it.entities[0]);
-    test_uint(parent_c, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(base, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(base, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(base, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    ecs_set_with(world, 0);
-    
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(base, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(base, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    ecs_set_with(world, 0);
-    
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(base, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_self_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($x:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(base, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(base, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(base, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(child, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($x:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(base, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(child, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_written_self_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x:self), Foo($x:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    ecs_set_with(world, 0);
-    
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(base, ecs_field_src(&it, 1));
-    test_uint(base, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(base, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(child, ecs_field_src(&it, 1));
-    test_uint(base, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(child, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_written_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x:self), Foo($x:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    ecs_set_with(world, 0);
-    
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(child, ecs_field_src(&it, 1));
-    test_uint(base, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_uint(child, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_ent_self_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    ecs_set_name(world, parent, "parent");
-    ecs_set_name(world, child, "child");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(parent.child:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-    
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(base, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, child, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(child, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_ent_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    ecs_set_name(world, parent, "parent");
-    ecs_set_name(world, child, "child");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(parent.child:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-    
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(base, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, child, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(base, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_ent_written_self_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    ecs_set_name(world, parent, "parent");
-    ecs_set_name(world, child, "child");
-    ecs_set_with(world, 0);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(parent.child:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-    
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(base, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, child, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(child, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_ent_written_up_childof_inherited(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tag);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t base = ecs_new(world, Foo);
-    ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    ecs_set_name(world, parent, "parent");
-    ecs_set_name(world, child, "child");
-    ecs_set_with(world, 0);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(parent.child:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-    
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(base, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, child, Foo);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(0, it.count);
-        test_uint(base, ecs_field_src(&it, 1));
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t p2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t p3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-        test_int(p[1].x, 20);
-        test_int(p[1].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_up_childof_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t p2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t p3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Position(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_set(world, ecs_new(world, Tag), Position, {10, 20});
-    ecs_entity_t p2 = ecs_set(world, ecs_new(world, Tag), Position, {20, 30});
-    ecs_entity_t p3 = ecs_set(world, ecs_new(world, Tag), Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-        test_int(p[1].x, 20);
-        test_int(p[1].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_up_childof_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Position(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_set(world, ecs_new(world, Tag), Position, {10, 20});
-    ecs_entity_t p2 = ecs_set(world, ecs_new(world, Tag), Position, {20, 30});
-    ecs_entity_t p3 = ecs_set(world, ecs_new(world, Tag), Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_self_up_childof_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($x:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t p2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t p3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(p3, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_up_childof_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($x:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t p2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t p3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_written_self_up_childof_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x:self), Position($x:self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_set(world, ecs_new(world, Tag), Position, {10, 20});
-    ecs_entity_t p2 = ecs_set(world, ecs_new(world, Tag), Position, {20, 30});
-    ecs_entity_t p3 = ecs_set(world, ecs_new(world, Tag), Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    test_uint(p1, ecs_iter_get_var(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    test_uint(p2, ecs_iter_get_var(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(p3, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e1, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e2, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e3, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e4, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e5, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e6, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e7, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_var_written_up_childof_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($x:self), Position($x:up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_set(world, ecs_new(world, Tag), Position, {10, 20});
-    ecs_entity_t p2 = ecs_set(world, ecs_new(world, Tag), Position, {20, 30});
-    ecs_entity_t p3 = ecs_set(world, ecs_new(world, Tag), Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e1, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e1, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e2, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e2, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e3, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e3, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e4, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e4, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e5, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e5, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e6, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e6, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(0, it.count);
-    test_uint(e7, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(e7, ecs_iter_get_var(&it, x_var));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_recycled_parent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    test_assert((uint32_t)p0 != p0);
-    test_assert((uint32_t)p1 != p1);
-    test_assert((uint32_t)p2 != p2);
-    test_assert((uint32_t)p3 != p3);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_up_childof_recycled_parent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    test_assert((uint32_t)p0 != p0);
-    test_assert((uint32_t)p1 != p1);
-    test_assert((uint32_t)p2 != p2);
-    test_assert((uint32_t)p3 != p3);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_recycled_parent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    test_assert((uint32_t)p0 != p0);
-    test_assert((uint32_t)p1 != p1);
-    test_assert((uint32_t)p2 != p2);
-    test_assert((uint32_t)p3 != p3);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_up_childof_recycled_parent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    test_assert((uint32_t)p0 != p0);
-    test_assert((uint32_t)p1 != p1);
-    test_assert((uint32_t)p2 != p2);
-    test_assert((uint32_t)p3 != p3);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_recycled_parent_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    test_assert((uint32_t)p0 != p0);
-    test_assert((uint32_t)p1 != p1);
-    test_assert((uint32_t)p2 != p2);
-    test_assert((uint32_t)p3 != p3);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-        test_int(p[1].x, 20);
-        test_int(p[1].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_up_childof_recycled_parent_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    test_assert((uint32_t)p0 != p0);
-    test_assert((uint32_t)p1 != p1);
-    test_assert((uint32_t)p2 != p2);
-    test_assert((uint32_t)p3 != p3);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_recycled_parent_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Position(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p1 = ecs_set(world, ecs_new(world, Tag), Position, {10, 20});
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p2 = ecs_set(world, ecs_new(world, Tag), Position, {20, 30});
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p3 = ecs_set(world, ecs_new(world, Tag), Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    test_assert((uint32_t)p0 != p0);
-    test_assert((uint32_t)p1 != p1);
-    test_assert((uint32_t)p2 != p2);
-    test_assert((uint32_t)p3 != p3);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-        test_int(p[1].x, 20);
-        test_int(p[1].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_up_childof_recycled_parent_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Position(up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p1 = ecs_set(world, ecs_new(world, Tag), Position, {10, 20});
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p2 = ecs_set(world, ecs_new(world, Tag), Position, {20, 30});
-    ecs_delete(world, ecs_new_id(world));
-    ecs_entity_t p3 = ecs_set(world, ecs_new(world, Tag), Position, {30, 40});
-    ecs_add(world, p3, Bar);
-
-    test_assert((uint32_t)p0 != p0);
-    test_assert((uint32_t)p1 != p1);
-    test_assert((uint32_t)p2 != p2);
-    test_assert((uint32_t)p3 != p3);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 10);
-        test_int(p[0].y, 20);
-    }
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 2);
-        test_assert(p != NULL);
-        test_int(p[0].x, 30);
-        test_int(p[0].y, 40);
-    }
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(self|up(ChildOf), Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_up_childof_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(up(ChildOf), Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Rel(self|up(ChildOf), Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_up_childof_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Rel(up(ChildOf), Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, Tgt);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_pair_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(self|up(ChildOf), *)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add_pair(world, p3, EcsChildOf, p2);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_up_childof_pair_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(up(ChildOf), *)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add_pair(world, p3, EcsChildOf, p2);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_pair_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Rel(self|up(ChildOf), *)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add(world, p3, Bar);
-    ecs_add_pair(world, p3, EcsChildOf, p2);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_up_childof_pair_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Rel(up(ChildOf), *)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add(world, p3, Bar);
-    ecs_add_pair(world, p3, EcsChildOf, p2);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(self|up(ChildOf), $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add_pair(world, p3, EcsChildOf, p2);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-    test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-    test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Rel(self|up(ChildOf), $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add(world, p3, Bar);
-    ecs_add_pair(world, p3, EcsChildOf, p2);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 2));
-    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 2));
-    test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 2));
-    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 2));
-    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 2));
-    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 2));
-    test_uint(TgtC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(self|up(ChildOf), Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, RelA, Tgt);
-    ecs_entity_t p2 = ecs_new_w_pair(world, RelB, Tgt);
-    ecs_entity_t p3 = ecs_new_w_pair(world, RelC, Tgt);
-    ecs_add_pair(world, p3, EcsChildOf, p2);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 1));
-    test_uint(RelC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, Tgt);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), $x(self|up(ChildOf), Tgt)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new_w_pair(world, RelA, Tgt);
-    ecs_entity_t p2 = ecs_new_w_pair(world, RelB, Tgt);
-    ecs_entity_t p3 = ecs_new_w_pair(world, RelC, Tgt);
-    ecs_add(world, p3, Bar);
-    ecs_add_pair(world, p3, EcsChildOf, p2);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 2));
-    test_uint(RelC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_pair_for_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ECS_ENTITY(world, ent, (Rel, TagA), (Rel, TagB), (Rel, TagC));
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(ent, $x), $x(self|up)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p1 = ecs_new(world, TagA);
-    ecs_entity_t p2 = ecs_new(world, TagB);
-    ecs_entity_t p3 = ecs_new(world, TagC);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_add_pair(world, e1, EcsIsA, p2);
-    ecs_add_pair(world, e1, EcsIsA, p3);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p2, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 1));
-    test_uint(TagB, ecs_field_id(&it, 2));
-    test_uint(TagB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 1));
-    test_uint(TagB, ecs_field_id(&it, 2));
-    test_uint(TagB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 1));
-    test_uint(TagC, ecs_field_id(&it, 2));
-    test_uint(TagC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 1));
-    test_uint(TagC, ecs_field_id(&it, 2));
-    test_uint(TagC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_up_childof_pair_for_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ECS_ENTITY(world, ent, (Rel, TagA), (Rel, TagB), (Rel, TagC));
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(ent, $x), $x(up)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p1 = ecs_new(world, TagA);
-    ecs_entity_t p2 = ecs_new(world, TagB);
-    ecs_entity_t p3 = ecs_new(world, TagC);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_add_pair(world, e1, EcsIsA, p2);
-    ecs_add_pair(world, e1, EcsIsA, p3);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 1));
-    test_uint(TagB, ecs_field_id(&it, 2));
-    test_uint(TagB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 1));
-    test_uint(TagC, ecs_field_id(&it, 2));
-    test_uint(TagC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_pair_for_var_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(self, $x), $x(self|up(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new(world, 0);
-    ecs_entity_t p1 = ecs_new(world, TagA);
-    ecs_entity_t p2 = ecs_new(world, TagB);
-    ecs_entity_t p3 = ecs_new(world, TagC);
-
-    ecs_entity_t e0 = ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_add_pair(world, e0, Rel, TagA);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add_pair(world, e1, Rel, TagA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add_pair(world, e2, Rel, TagB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p3);
-    ecs_add_pair(world, e3, Rel, TagC);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_new_w_pair(world, Rel, TagB);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 1));
-    test_uint(TagB, ecs_field_id(&it, 2));
-    test_uint(TagB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 1));
-    test_uint(TagC, ecs_field_id(&it, 2));
-    test_uint(TagC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_up_childof_pair_for_var_written_n_targets(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ECS_ENTITY(world, ent, (Rel, TagA), (Rel, TagB), (Rel, TagC));
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(ent, $x), $x(self|up)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p0 = ecs_new(world, 0);
-    ecs_entity_t p0_a = ecs_new(world, TagA);
-    ecs_entity_t p0_b = ecs_new(world, TagB);
-    ecs_add(world, p0_b, Foo);
-    ecs_entity_t p0_c = ecs_new(world, TagC);
-    ecs_add(world, p0_c, Foo);
-    ecs_add(world, p0_c, Bar);
-    ecs_entity_t p1 = ecs_new_id(world);
-    ecs_add_pair(world, p1, EcsIsA, p0_a);
-    ecs_add_pair(world, p1, EcsIsA, p0_b);
-    ecs_add_pair(world, p1, EcsIsA, p0_c);
-
-    ecs_new_w_pair(world, EcsIsA, p0);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TagA);
-    ecs_add(world, e2, TagA);
-    ecs_new_w_pair(world, Rel, TagB);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p0_a, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p0_a, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p0_a, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p0_b, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 1));
-    test_uint(TagB, ecs_field_id(&it, 2));
-    test_uint(TagB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p0_b, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 1));
-    test_uint(TagB, ecs_field_id(&it, 2));
-    test_uint(TagB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p0_b, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 1));
-    test_uint(TagB, ecs_field_id(&it, 2));
-    test_uint(TagB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p0_c, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 1));
-    test_uint(TagC, ecs_field_id(&it, 2));
-    test_uint(TagC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p0_c, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 1));
-    test_uint(TagC, ecs_field_id(&it, 2));
-    test_uint(TagC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ent, ecs_field_src(&it, 1));
-    test_uint(p0_c, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 1));
-    test_uint(TagC, ecs_field_id(&it, 2));
-    test_uint(TagC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_up_childof_pair_for_var_written_n_targets(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel(self, $x), $x(self|up)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new(world, 0);
-    ecs_entity_t p1 = ecs_new(world, TagA);
-    ecs_entity_t p2 = ecs_new(world, TagB);
-    ecs_entity_t p3 = ecs_new(world, TagC);
-
-    ecs_entity_t e0 = ecs_new_w_pair(world, EcsIsA, p0);
-    ecs_add_pair(world, e0, Rel, TagA);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_add_pair(world, e1, EcsIsA, p2);
-    ecs_add_pair(world, e1, EcsIsA, p3);
-    ecs_add_pair(world, e1, Rel, TagA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_add_pair(world, e2, EcsIsA, p2);
-    ecs_add_pair(world, e2, EcsIsA, p3);
-    ecs_add_pair(world, e2, Rel, TagB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, p1);
-    ecs_add_pair(world, e3, EcsIsA, p2);
-    ecs_add_pair(world, e3, EcsIsA, p3);
-    ecs_add_pair(world, e3, Rel, TagC);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_new_w_pair(world, Rel, TagB);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 1));
-    test_uint(TagB, ecs_field_id(&it, 2));
-    test_uint(TagB, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 1));
-    test_uint(TagC, ecs_field_id(&it, 2));
-    test_uint(TagC, ecs_iter_get_var(&it, x_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 1));
-    test_uint(TagA, ecs_field_id(&it, 2));
-    test_uint(TagA, ecs_iter_get_var(&it, x_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_self_up_2_levels(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t base = ecs_new_w_id(world, EcsPrefab);
-    ecs_set(world, base, Position, {10, 20});
-
-    ecs_entity_t base_2 = ecs_new_w_id(world, EcsPrefab);
-    ecs_add_pair(world, base_2, EcsIsA, base);
-
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base_2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = ecs_id(Position) }
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(inst, it.entities[0]);
-    test_uint(base, it.sources[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    Position *p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_not_up_disabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {
-            { TagA },
-            { .id = EcsDisabled, .src.flags = EcsUp, .src.trav = EcsChildOf, .oper = EcsNot }
-        }
-    });
-    test_assert(f != NULL);
-
-    ecs_entity_t parent = ecs_new_w_id(world, EcsDisabled);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add_id(world, e2, EcsDisabled);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, EcsChildOf, parent);
-    
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, it.ids[0]);
-    test_uint(0, it.sources[0]);
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-    
-    ecs_fini(world);
-}
-
-void RulesTraversal_up_2_rel_instances(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, Rel);
-
-    ecs_add_id(world, Rel, EcsTraversable);
-
-    ecs_entity_t b1 = ecs_new(world, TagA);
-    ecs_entity_t b2 = ecs_new(world, TagA);
-    ecs_add(world, b1, TagB);
-    ecs_add(world, b2, TagB);
-    ecs_add(world, b1, TagC);
-    ecs_add(world, b2, TagC);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Rel, b1);
-    ecs_add_pair(world, e, Rel, b2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {
-            {TagC, .src.flags = EcsUp, .src.trav = Rel }
-        }
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e);
-    test_uint(it.sources[0], b1);
-    test_uint(it.ids[0], TagC);
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_up_2_rel_instances_match_2nd(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, Rel);
-
-    ecs_add_id(world, Rel, EcsTraversable);
-
-    ecs_entity_t b1 = ecs_new(world, TagA);
-    ecs_entity_t b2 = ecs_new(world, TagA);
-    ecs_add(world, b1, TagB);
-    ecs_add(world, b2, TagB);
-    ecs_add(world, b2, TagC);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Rel, b1);
-    ecs_add_pair(world, e, Rel, b2);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {
-            { TagC, .src.flags = EcsUp, .src.trav = Rel }
-        }
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e);
-    test_uint(it.sources[0], b2);
-    test_uint(it.ids[0], TagC);
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_up_only_w_owned(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, R, EcsTraversable);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e_0 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e_1 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e_2 = ecs_set(world, 0, Position, {50, 60});
-    ecs_entity_t e_3 = ecs_set(world, 0, Position, {70, 80});
-
-    ecs_add_pair(world, e_3, R, e_2);
-    ecs_add_pair(world, e_2, R, e_1);
-    ecs_add_pair(world, e_1, R, e_0);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .expr = "Position(up(R))"
-    });
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_1);
-    test_uint(it.sources[0], e_0);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_3);
-    test_uint(it.sources[0], e_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 50);
-    test_int(p[0].y, 60);
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_2);
-    test_uint(it.sources[0], e_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_cascade_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self|cascade(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_cascade_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(cascade(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_cascade_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(self|cascade(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_cascade_childof(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(cascade(ChildOf))"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_self_cascade_childof_w_parent_flag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self|cascade|parent)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_cascade_childof_w_parent_flag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(cascade|parent)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(p1, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(p2, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(p3, ecs_field_src(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_self_cascade_childof_w_parent_flag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(self|cascade|parent)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(2, it.count);
-    test_uint(p1, it.entities[0]);
-    test_uint(p2, it.entities[1]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(p3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(0, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesTraversal_this_written_cascade_childof_w_parent_flag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag(self), Foo(cascade|parent)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_set_with(world, Tag);
-    ecs_entity_t p0 = ecs_new_id(world);
-    ecs_entity_t p1 = ecs_new(world, Foo);
-    ecs_entity_t p2 = ecs_new(world, Foo);
-    ecs_entity_t p3 = ecs_new(world, Foo);
-    ecs_add(world, p3, Bar);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
-    ecs_add(world, e4, Bar);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
-    ecs_add(world, e6, Bar);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
-
-    ecs_new_w_pair(world, EcsChildOf, p0);
-    ecs_set_with(world, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p2, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p1, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e7, it.entities[0]);
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(p3, ecs_field_src(&it, 2));
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/RulesVariables.c b/test/addons/src/RulesVariables.c
deleted file mode 100644
index fa3eb93ab..000000000
--- a/test/addons/src/RulesVariables.c
+++ /dev/null
@@ -1,9188 +0,0 @@
-#include <addons.h>
-
-void RulesVariables_1_ent_src_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_w_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_w_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_w_pair_rel_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(ent, $y)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
-        test_uint(EcsName, ecs_iter_get_var(&it, y_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
-        test_uint(EcsName, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
-        test_uint(EcsName, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
-        test_uint(EcsName, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_w_pair_rel_tgt_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(ent, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, TgtA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, TgtB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_w_pair_rel_tgt_same_var_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(ent), $x(ent, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, TgtA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TgtA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, TgtB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TgtA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TgtA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TgtB, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 2));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this), $x($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(3, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e2, RelB);
-    ecs_add(world, e3, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtB);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(3, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelB, TgtA);
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelB, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(3, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, TgtB);
-    ecs_add_pair(world, e3, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_pair_rel_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Tag($this), $x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int32_t y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(3, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, TgtB);
-    ecs_add_pair(world, e3, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_pair_rel_tgt_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelB, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, TgtA, TgtA);
-    ecs_add_pair(world, e2, TgtA, TgtA);
-    ecs_add_pair(world, e3, TgtA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(3, it.count);
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, TgtB, TgtB);
-    ecs_add_pair(world, e3, TgtB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_pair_rel_tgt_same_var_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelB, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this), $x($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, TgtA);
-    ecs_add_pair(world, e2, RelA, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, TgtA, TgtA);
-    ecs_add_pair(world, e2, TgtA, TgtA);
-    ecs_add_pair(world, e3, TgtA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, TgtA);
-    ecs_add(world, e2, TgtA);
-    ecs_add(world, e3, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(3, it.count);
-        test_uint(TgtA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(e3, it.entities[2]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, TgtB, TgtB);
-    ecs_add_pair(world, e3, TgtB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TgtA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(TgtA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e2, TgtB);
-    ecs_add(world, e3, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TgtA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(TgtA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(TgtB, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_id_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_id(world, e3, e1);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($x), TagA($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(e1, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(e1, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(e2, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_first_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, e1, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($x, TgtA), TagA($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e2, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_second_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, RelA, e1);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x, $x), TagA($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_first_and_second_same_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, e1, e1);
-    ecs_entity_t e4 = ecs_new(world, TagA);
-    ecs_add_pair(world, e4, e4, e1);
-    ecs_entity_t e5 = ecs_new(world, TagA);
-    ecs_add_pair(world, e5, e1, e5);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($x, $x), TagA($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e2, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_id_same_var_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_id(world, e3, e1);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($x), $x($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_first_same_var_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, e1, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($x), $x($x, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e2, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_second_same_var_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, RelA, e1);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($x), RelA($x, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_first_and_second_same_var_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, e1, e1);
-    ecs_entity_t e4 = ecs_new(world, TagA);
-    ecs_add_pair(world, e4, e4, e1);
-    ecs_entity_t e5 = ecs_new(world, TagA);
-    ecs_add_pair(world, e5, e1, e5);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($x), $x($x, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e2, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_first_same_var_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_id(world, e3, e1);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this($this), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e2, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_second_same_var_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, e1, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this($this, TgtA), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e2, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-
-}
-
-void RulesVariables_1_src_pair_first_and_second_same_var_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, RelA, e1);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $this), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_id_same_var_this_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_id(world, e3, e1);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($this), $this($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_first_same_var_this_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, e1, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($this), $this($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e2, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_second_same_var_this_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, RelA, e1);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($this), RelA($this, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_pair_first_and_second_same_var_this_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, e1, e1);
-    ecs_entity_t e4 = ecs_new(world, TagA);
-    ecs_add_pair(world, e4, e4, e1);
-    ecs_entity_t e5 = ecs_new(world, TagA);
-    ecs_add_pair(world, e5, e1, e5);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($this), $this($this, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, RelA, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e2, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_w_this_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, RelA);
-    ecs_add(world, ent, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, this_var));
-        test_uint(RelA, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, this_var));
-        test_uint(RelB, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_w_pair_this_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, TgtA);
-    ecs_add(world, ent, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelB, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, this_var));
-        test_uint(RelA, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, this_var));
-        test_uint(RelB, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_w_pair_this_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, TgtA);
-    ecs_add(world, ent, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, this_var));
-        test_uint(TgtA, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, this_var));
-        test_uint(TgtB, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_w_pair_this_rel_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this(ent, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, TgtA);
-    ecs_add(world, ent, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelA, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, TgtA, TgtA);
-    ecs_add_pair(world, ent, TgtB, TgtB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, this_var));
-        test_uint(TgtA, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, this_var));
-        test_uint(TgtB, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t ent = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this($this), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, TagB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-    
-    ecs_add_id(world, ent, ent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ent, ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ent, ecs_iter_get_var(&it, this_var));
-        test_uint(ent, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_pair_this_rel_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t ent = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this($this, $this), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, TagB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-    
-    ecs_add_id(world, ent, ent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, ent, ent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(ent, ent), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ent, ecs_iter_get_var(&it, this_var));
-        test_uint(ent, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_this_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t ent = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($this), $this($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, TagB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-    
-    ecs_add_id(world, ent, ent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ent, ecs_iter_get_var(&it, this_var));
-        test_uint(ent, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_this_src_w_pair_this_rel_tgt_after_write(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t ent = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($this), $this($this, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, ent, TagB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-    
-    ecs_add_id(world, ent, ent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, ent, ent, ent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(ent, ent), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ent, ecs_iter_get_var(&it, this_var));
-        test_uint(ent, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_src_from_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), RelB($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e1, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add(world, e2, RelB);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_rel_from_src_w_ent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x(e2)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_rel_from_src_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x($y)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_rel_from_src_w_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_pair_rel_from_src_w_ent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x(e2, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_pair_rel_from_src_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x($y, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_pair_rel_from_src_w_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, e1, TgtA);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_pair_tgt_from_src_w_ent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), RelA(e2, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_pair_tgt_from_src_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), RelA($y, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_pair_tgt_from_src_w_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), RelA($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_pair_rel_tgt_from_src_w_ent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x(e2, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_pair_rel_tgt_from_src_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x($y, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, RelA, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_constrain_pair_rel_tgt_from_src_w_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x), $x($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e3, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e3, e1, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(2, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, it.entities[0]);
-        test_uint(e3, it.entities[1]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_set_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-    ecs_add(world, ent, RelA);
-    ecs_add(world, ent, RelB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(ent)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, RelA);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_set_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelB, TgtA);
-    ecs_add_pair(world, ent, RelC, TgtB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x(ent, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, RelA);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, RelB);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, RelC);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_ent_src_set_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_entity_t ent = ecs_new_entity(world, "ent");
-    ecs_add_pair(world, ent, RelA, TgtA);
-    ecs_add_pair(world, ent, RelA, TgtB);
-    ecs_add_pair(world, ent, RelB, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA(ent, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, TgtA);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, TgtB);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(ent, ecs_field_src(&it, 1));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, TgtC);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelB);
-    ecs_entity_t e3 = ecs_new(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e2);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_var_w_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelC, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e2);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_var_w_pair_set_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, e1, TgtA);
-    ecs_add_pair(world, e2, e2, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($x, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e2);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_var_w_pair_set_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, RelA, e1);
-    ecs_add_pair(world, e2, RelA, e2);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($x, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e2);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_var_w_pair_set_rel_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, e1, e1);
-    ecs_add_pair(world, e2, e2, e2);
-    ecs_add_pair(world, e3, RelA, e3);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($x, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e2);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, x_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_entity_t e2 = ecs_new(world, RelB);
-    ecs_entity_t e3 = ecs_new(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var == 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e2);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this_w_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelC, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e2);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this_w_pair_set_rel(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, e1, TgtA);
-    ecs_add_pair(world, e2, e2, TgtA);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this($this, TgtA)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e2);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this_w_pair_set_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, RelA, e1);
-    ecs_add_pair(world, e2, RelA, e2);
-    ecs_add_pair(world, e3, RelA, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e2);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this_w_pair_set_rel_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, e1, e1);
-    ecs_add_pair(world, e2, e2, e2);
-    ecs_add_pair(world, e3, RelA, e3);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this($this, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e1);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e2);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        ecs_iter_set_var(&it, this_var, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this_to_empty_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_add(world, e1, TagB);
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    ecs_remove(world, e1, TagB);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ TagA }}
-    });
-
-    int this_var_id = ecs_rule_find_var(f, "this");
-    test_assert(this_var_id != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    ecs_iter_set_var_as_table(&it, this_var_id, t1);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 0);
-    test_assert(it.table == t1);
-    test_uint(ecs_field_id(&it, 1), TagA);
-    test_uint(ecs_field_size(&it, 1), 0);
-    ecs_table_t* this_var = ecs_iter_get_var_as_table(&it, this_var_id);
-    test_assert(this_var != NULL);
-    test_assert(this_var == t1);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this_to_empty_table_w_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_add(world, e1, TagA);
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    ecs_remove(world, e1, TagA);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    int this_var_id = ecs_rule_find_var(f, "this");
-    test_assert(this_var_id != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    ecs_iter_set_var_as_table(&it, this_var_id, t1);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 0);
-    test_assert(it.table == t1);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-    test_assert(ecs_field(&it, Position, 1) == NULL);
-    ecs_table_t* this_var = ecs_iter_get_var_as_table(&it, this_var_id);
-    test_assert(this_var != NULL);
-    test_assert(this_var == t1);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this_to_empty_table_w_component_self(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_add(world, e1, TagA);
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    ecs_remove(world, e1, TagA);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ ecs_id(Position), .src.flags = EcsSelf }}
-    });
-
-    int this_var_id = ecs_rule_find_var(f, "this");
-    test_assert(this_var_id != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    ecs_iter_set_var_as_table(&it, this_var_id, t1);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 0);
-    test_assert(it.table == t1);
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-    test_assert(ecs_field(&it, Position, 1) == NULL);
-    ecs_table_t* this_var = ecs_iter_get_var_as_table(&it, this_var_id);
-    test_assert(this_var != NULL);
-    test_assert(this_var == t1);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this_to_entiy_in_table(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0].id = ecs_id(Position)
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_set_src_this_to_entiy_in_table_self(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = ecs_id(Position), .src.flags = EcsSelf }
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = Foo },
-        .terms[1] = { .id = Bar },
-    });
-
-    ecs_entity_t prefab = ecs_new(world, Bar);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_add(world, e1, Bar);
-
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_add_pair(world, e3, EcsIsA, prefab);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e3);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(prefab, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this_self(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = Foo, .src.flags = EcsSelf },
-        .terms[1] = { .id = Bar, .src.flags = EcsSelf },
-    });
-
-    ecs_entity_t prefab = ecs_new(world, Bar);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_add(world, e1, Bar);
-
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_add(world, e2, Bar);
-
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_add_pair(world, e3, EcsIsA, prefab);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = ecs_id(Position) },
-        .terms[1] = { .id = ecs_id(Velocity) },
-    });
-
-    ecs_entity_t prefab = ecs_set(world, 0, Velocity, {3, 4});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_set(world, e1, Velocity, {1, 2});
-
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_set(world, e2, Velocity, {2, 3});
-
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_add_pair(world, e3, EcsIsA, prefab);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 2);
-        test_int(v->y, 3);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e3);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 30);
-        test_int(p->y, 40);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 3);
-        test_int(v->y, 4);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(prefab, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this_self_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = ecs_id(Position), .src.flags = EcsSelf },
-        .terms[1] = { .id = ecs_id(Velocity), .src.flags = EcsSelf },
-    });
-
-    ecs_entity_t prefab = ecs_set(world, 0, Velocity, {4, 5});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_set(world, e1, Velocity, {1, 2});
-
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_set(world, e2, Velocity, {2, 3});
-
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {40, 50});
-    ecs_add_pair(world, e3, EcsIsA, prefab);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 2);
-        test_int(v->y, 3);
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this_w_up(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Hello);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = Foo },
-        .terms[1] = { .id = Bar },
-        .terms[2] = { .id = Hello, .src.flags = EcsUp, .src.trav = EcsChildOf },
-    });
-
-    ecs_entity_t prefab = ecs_new(world, Bar);
-    ecs_entity_t parent = ecs_new(world, Hello);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_add(world, e1, Bar);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_add(world, e2, Bar);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_add_pair(world, e3, EcsIsA, prefab);
-    ecs_add_pair(world, e3, EcsChildOf, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(Hello, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(Hello, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e3);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(Hello, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(prefab, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this_self_w_up(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Hello);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = Foo, .src.flags = EcsSelf },
-        .terms[1] = { .id = Bar, .src.flags = EcsSelf },
-        .terms[2] = { .id = Hello, .src.flags = EcsUp, .src.trav = EcsChildOf },
-    });
-
-    ecs_entity_t prefab = ecs_new(world, Bar);
-    ecs_entity_t parent = ecs_new(world, Hello);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_add(world, e1, Bar);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_add(world, e2, Bar);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_add_pair(world, e3, EcsIsA, prefab);
-    ecs_add_pair(world, e3, EcsChildOf, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(Hello, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(Hello, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this_component_w_up(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = ecs_id(Position) },
-        .terms[1] = { .id = ecs_id(Velocity) },
-        .terms[2] = { .id = ecs_id(Mass), .src.flags = EcsUp, .src.trav = EcsChildOf },
-    });
-
-    ecs_entity_t prefab = ecs_set(world, 0, Velocity, {3, 4});
-    ecs_entity_t parent = ecs_set(world, 0, Mass, {60});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_set(world, e1, Velocity, {1, 2});
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_set(world, e2, Velocity, {2, 3});
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_add_pair(world, e3, EcsIsA, prefab);
-    ecs_add_pair(world, e3, EcsChildOf, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        Mass *m = ecs_field(&it, Mass, 3);
-        test_assert(m != NULL);
-        test_int(m[0], 60);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 2);
-        test_int(v->y, 3);
-        Mass *m = ecs_field(&it, Mass, 3);
-        test_assert(m != NULL);
-        test_int(m[0], 60);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e3);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 30);
-        test_int(p->y, 40);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 3);
-        test_int(v->y, 4);
-        Mass *m = ecs_field(&it, Mass, 3);
-        test_assert(m != NULL);
-        test_int(m[0], 60);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(prefab, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this_self_component_w_up(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = ecs_id(Position), .src.flags = EcsSelf },
-        .terms[1] = { .id = ecs_id(Velocity), .src.flags = EcsSelf },
-        .terms[2] = { .id = ecs_id(Mass), .src.flags = EcsUp, .src.trav = EcsChildOf },
-    });
-
-    ecs_entity_t prefab = ecs_set(world, 0, Velocity, {3, 4});
-    ecs_entity_t parent = ecs_set(world, 0, Mass, {60});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_set(world, e1, Velocity, {1, 2});
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_set(world, e2, Velocity, {2, 3});
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_add_pair(world, e3, EcsIsA, prefab);
-    ecs_add_pair(world, e3, EcsChildOf, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-        Mass *m = ecs_field(&it, Mass, 3);
-        test_assert(m != NULL);
-        test_int(m[0], 60);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 2);
-        test_int(v->y, 3);
-        Mass *m = ecs_field(&it, Mass, 3);
-        test_assert(m != NULL);
-        test_int(m[0], 60);
-        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-        test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(parent, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this_w_exclusive_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Hello);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = Foo },
-        .terms[1] = { .id = Bar },
-        .terms[2] = { .id = ecs_pair(EcsChildOf, EcsWildcard) },
-    });
-
-    ecs_entity_t prefab = ecs_new(world, Bar);
-    ecs_entity_t parent = ecs_new(world, Hello);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_add(world, e1, Bar);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_add(world, e2, Bar);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_add_pair(world, e3, EcsIsA, prefab);
-    ecs_add_pair(world, e3, EcsChildOf, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e3);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(Bar, ecs_field_id(&it, 2));
-        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(prefab, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_set_src_this_self_w_exclusive_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Hello);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms[0] = { .id = Foo, .src.flags = EcsSelf },
-        .terms[1] = { .id = ecs_pair(EcsChildOf, EcsWildcard), .src.flags = EcsSelf },
-        .terms[2] = { .id = Bar, .src.flags = EcsUp },
-    });
-
-    ecs_entity_t prefab = ecs_new(world, Bar);
-    ecs_entity_t parent = ecs_new(world, Hello);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_add_pair(world, e1, EcsIsA, prefab);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_add_pair(world, e2, EcsIsA, prefab);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_add(world, e3, Bar);
-    ecs_add_pair(world, e3, EcsChildOf, parent);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e1);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e1);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 2));
-        test_uint(Bar, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(prefab, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e2);
-        test_bool(true, ecs_rule_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        test_uint(Foo, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 2));
-        test_uint(Bar, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(prefab, ecs_field_src(&it, 3));
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, f);
-        ecs_iter_set_var(&it, 0, e3);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_this_var_as_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_entity_t e4 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e3, TagC);
-    ecs_add(world, e4, TagC);
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ TagA }}
-    });
-
-    int this_var_id = ecs_rule_find_var(f, "this");
-    test_assert(this_var_id != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    ecs_entity_t this_var = ecs_iter_get_var(&it, this_var_id);
-    test_assert(this_var != 0);
-    test_assert(this_var == e1);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    this_var = ecs_iter_get_var(&it, this_var_id);
-    test_assert(this_var != 0);
-    test_assert(this_var == e2);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 2);
-    test_uint(it.entities[0], e3);
-    test_uint(it.entities[1], e4);
-    this_var = ecs_iter_get_var(&it, this_var_id);
-    test_assert(this_var == 0); /* more than one entity matches */
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_this_var_as_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_entity_t e4 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e3, TagC);
-    ecs_add(world, e4, TagC);
-
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    test_assert(t1 != NULL);
-
-    ecs_table_t *t2 = ecs_get_table(world, e2);
-    test_assert(t2 != NULL);
-    test_assert(t2 != t1);
-
-    ecs_table_t *t3 = ecs_get_table(world, e3);
-    test_assert(t3 != NULL);
-    test_assert(t3 != t1);
-    test_assert(t3 != t2);
-    test_assert(t3 == ecs_get_table(world, e4));
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ TagA }}
-    });
-
-    int this_var_id = ecs_rule_find_var(f, "this");
-    test_assert(this_var_id != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    ecs_table_t *this_var = ecs_iter_get_var_as_table(&it, this_var_id);
-    test_assert(this_var != NULL);
-    test_assert(this_var == t1);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    this_var = ecs_iter_get_var_as_table(&it, this_var_id);
-    test_assert(this_var != NULL);
-    test_assert(this_var == t2);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 2);
-    test_uint(it.entities[0], e3);
-    test_uint(it.entities[1], e4);
-    this_var = ecs_iter_get_var_as_table(&it, this_var_id);
-    test_assert(this_var != NULL);
-    test_assert(this_var == t3);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_src_this_var_as_table_range(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_entity_t e4 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e3, TagC);
-    ecs_add(world, e4, TagC);
-
-    ecs_table_t *t1 = ecs_get_table(world, e1);
-    test_assert(t1 != NULL);
-
-    ecs_table_t *t2 = ecs_get_table(world, e2);
-    test_assert(t2 != NULL);
-    test_assert(t2 != t1);
-
-    ecs_table_t *t3 = ecs_get_table(world, e3);
-    test_assert(t3 != NULL);
-    test_assert(t3 != t1);
-    test_assert(t3 != t2);
-    test_assert(t3 == ecs_get_table(world, e4));
-
-    ecs_rule_t *f = ecs_rule(world, {
-        .terms = {{ TagA }}
-    });
-
-    int this_var_id = ecs_rule_find_var(f, "this");
-    test_assert(this_var_id != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, f);
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    ecs_table_range_t this_var = ecs_iter_get_var_as_range(&it, this_var_id);
-    test_assert(this_var.table != NULL);
-    test_assert(this_var.table == t1);
-    test_assert(this_var.offset == 0);
-    test_assert(this_var.count == 1);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    this_var = ecs_iter_get_var_as_range(&it, this_var_id);
-    test_assert(this_var.table != NULL);
-    test_assert(this_var.table == t2);
-    test_assert(this_var.offset == 0);
-    test_assert(this_var.count == 1);
-
-    test_assert(ecs_rule_next(&it));
-    test_int(it.count, 2);
-    test_uint(it.entities[0], e3);
-    test_uint(it.entities[1], e4);
-    this_var = ecs_iter_get_var_as_range(&it, this_var_id);
-    test_assert(this_var.table != NULL);
-    test_assert(this_var.table == t3);
-    test_assert(this_var.offset == 0);
-    test_assert(this_var.count == 2);
-
-    test_assert(!ecs_rule_next(&it));
-
-    ecs_rule_fini(f);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_join_by_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-
-    ecs_entity_t e1 = ecs_new(world, RelA);
-    ecs_add(world, e1, RelB);
-    ecs_add_pair(world, e1, TagA, TagB);
-
-    ecs_entity_t e2 = ecs_new(world, RelA);
-    ecs_entity_t e3 = ecs_new(world, RelB);
-    ecs_new(world, RelC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this), $x($y), TagA($this, TagB)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TagA, TagB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelA, ecs_field_id(&it, 1));
-        test_uint(RelA, ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TagA, TagB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TagA, TagB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(RelB, ecs_field_id(&it, 1));
-        test_uint(RelB, ecs_field_id(&it, 2));
-        test_uint(ecs_pair(TagA, TagB), ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_join_by_pair_rel_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, RelC);
-    ECS_TAG(world, TgtA);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_add_pair(world, e1, RelB, TgtA);
-    ecs_add(world, e1, TagA);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelB, TgtA);
-    ecs_new_w_pair(world, RelC, TgtA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, TgtA), $x($y, TgtA), TagA"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(RelA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(RelB, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_join_by_pair_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_add_pair(world, e1, RelA, TgtB);
-    ecs_add(world, e1, TagA);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtA);
-    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtB);
-    ecs_new_w_pair(world, RelA, TgtC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "RelA($this, $x), RelA($y, $x), TagA"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($y), $y($x), TagA($x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e2);
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(e2, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 3));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(e1, ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_w_this_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this($y), $y($this), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e2);
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e2, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_w_var_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this), $this($x), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_id(world, e1, e2);
-    ecs_add_id(world, e2, e1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e2, ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(e1, ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_pair_w_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($y, $z), $x($z, $y), TagA($y)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    int z_var = ecs_rule_find_var(r, "z");
-    test_assert(z_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, e3);
-    ecs_add_pair(world, e3, e1, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, ecs_iter_get_var(&it, z_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, ecs_iter_get_var(&it, z_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_pair_w_this_var_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$this($y, $z), $this($z, $y), TagA($y)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    int z_var = ecs_rule_find_var(r, "z");
-    test_assert(z_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, e3);
-    ecs_add_pair(world, e3, e1, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, ecs_iter_get_var(&it, z_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, ecs_iter_get_var(&it, z_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_pair_w_var_this_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $z), $x($z, $this), TagA($this)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    int z_var = ecs_rule_find_var(r, "z");
-    test_assert(z_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, e3);
-    ecs_add_pair(world, e3, e1, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e3, ecs_iter_get_var(&it, z_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(0, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, ecs_iter_get_var(&it, z_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_pair_w_var_var_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($y, $this), $x($this, $y), TagA($y)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e2, e1, e3);
-    ecs_add_pair(world, e3, e1, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, ecs_iter_get_var(&it, this_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 2));
-        test_uint(TagA, ecs_field_id(&it, 3));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_pair_ent_var_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Likes);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Likes($x, $y), Likes($y, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, Likes, e2);
-    ecs_add_pair(world, e1, Likes, e1);
-    ecs_add_pair(world, e2, Likes, e1);
-    ecs_add_pair(world, e2, Likes, e3);
-    ecs_add_pair(world, e3, Likes, e1);
-    ecs_add_pair(world, e3, Likes, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_pair_ent_this_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Likes);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Likes($this, $y), Likes($y, $this)"
-    });
-
-    test_assert(r != NULL);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, Likes, e2);
-    ecs_add_pair(world, e1, Likes, e1);
-    ecs_add_pair(world, e2, Likes, e1);
-    ecs_add_pair(world, e2, Likes, e3);
-    ecs_add_pair(world, e3, Likes, e1);
-    ecs_add_pair(world, e3, Likes, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, ecs_iter_get_var(&it, y_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e3, ecs_iter_get_var(&it, y_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_cycle_pair_ent_var_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Likes);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Likes($x, $this), Likes($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    int this_var = ecs_rule_find_var(r, "This");
-    test_assert(this_var != -1);
-    test_assert(this_var != 0);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_add_pair(world, e1, Likes, e2);
-    ecs_add_pair(world, e1, Likes, e1);
-    ecs_add_pair(world, e2, Likes, e1);
-    ecs_add_pair(world, e2, Likes, e3);
-    ecs_add_pair(world, e3, Likes, e1);
-    ecs_add_pair(world, e3, Likes, e2);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 2));
-        test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e3, ecs_iter_get_var(&it, x_var));
-        test_uint(e2, ecs_iter_get_var(&it, this_var));
-        test_uint(e2, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-        test_uint(e1, ecs_iter_get_var(&it, this_var));
-        test_uint(e1, it.entities[0]);
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_iter_get_var(&it, x_var));
-        test_uint(e3, ecs_iter_get_var(&it, this_var));
-        test_uint(e3, it.entities[0]);
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_0_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, ""));
-    test_uint(it.variables[x_var].entity, EcsWildcard);
-    test_uint(it.variables[y_var].entity, EcsWildcard);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_1_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, "x:e1"));
-    test_uint(it.variables[x_var].entity, e1);
-    test_uint(it.variables[y_var].entity, EcsWildcard);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_2_vars(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, "x:e1,y:e2"));
-    test_uint(it.variables[x_var].entity, e1);
-    test_uint(it.variables[y_var].entity, e2);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_0_var_paren(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, "()"));
-    test_uint(it.variables[x_var].entity, EcsWildcard);
-    test_uint(it.variables[y_var].entity, EcsWildcard);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_1_var_paren(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, "(x:e1)"));
-    test_uint(it.variables[x_var].entity, e1);
-    test_uint(it.variables[y_var].entity, EcsWildcard);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_2_vars_paren(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, "(x:e1,y:e2)"));
-    test_uint(it.variables[x_var].entity, e1);
-    test_uint(it.variables[y_var].entity, e2);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_1_vars_w_path(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t e1 = ecs_new_entity(world, "parent.e1");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, "x:parent.e1"));
-    test_uint(it.variables[x_var].entity, e1);
-    test_uint(it.variables[y_var].entity, EcsWildcard);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_missing_close_paren(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    ecs_log_set_level(-4);
-    test_str(NULL, ecs_rule_parse_vars(r, &it, "(x:e1"));
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_missing_open_paren(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    ecs_log_set_level(-4);
-    test_str(NULL, ecs_rule_parse_vars(r, &it, "x:e1)"));
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_missing_value(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    ecs_log_set_level(-4);
-    test_str(NULL, ecs_rule_parse_vars(r, &it, "x:"));
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_0_var_w_spaces(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, "  "));
-    test_uint(it.variables[x_var].entity, EcsWildcard);
-    test_uint(it.variables[y_var].entity, EcsWildcard);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_1_var_w_spaces(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, "  x  :  e1  "));
-    test_uint(it.variables[x_var].entity, e1);
-    test_uint(it.variables[y_var].entity, EcsWildcard);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_2_vars_w_spaces(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("", ecs_rule_parse_vars(r, &it, "  x  :  e1  ,  y  :  e2  "));
-    test_uint(it.variables[x_var].entity, e1);
-    test_uint(it.variables[y_var].entity, e2);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_0_var_paren_w_spaces(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("  ", ecs_rule_parse_vars(r, &it, "  (  )  "));
-    test_uint(it.variables[x_var].entity, EcsWildcard);
-    test_uint(it.variables[y_var].entity, EcsWildcard);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_1_var_paren_w_spaces(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("  ", ecs_rule_parse_vars(r, &it, "  (  x  :  e1  )  "));
-    test_uint(it.variables[x_var].entity, e1);
-    test_uint(it.variables[y_var].entity, EcsWildcard);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_parse_2_vars_paren_w_spaces(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y)"
-    });
-
-    test_assert(r != NULL);
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_str("  ", ecs_rule_parse_vars(r, &it, "  (  x  :  e1  ,  y  :  e2  )  "));
-    test_uint(it.variables[x_var].entity, e1);
-    test_uint(it.variables[y_var].entity, e2);
-    ecs_iter_fini(&it);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_var_count(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y), $x($this), $y($this)"
-    });
-    test_assert(r != NULL);
-
-    test_int(ecs_rule_var_count(r), 3);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_var_name(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y), $x($this), $y($this)"
-    });
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    test_str(ecs_rule_var_name(r, x_var), "x");
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-    test_str(ecs_rule_var_name(r, y_var), "y");
-
-    int this_var = ecs_rule_find_var(r, "this");
-    test_assert(this_var != -1);
-    test_str(ecs_rule_var_name(r, this_var), "this");
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_var_is_entity(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "$x($this, $y), $x($this), $y($this)"
-    });
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    test_bool(ecs_rule_var_is_entity(r, x_var), true);
-
-    int y_var = ecs_rule_find_var(r, "y");
-    test_assert(y_var != -1);
-    test_bool(ecs_rule_var_is_entity(r, y_var), true);
-
-    int this_var = ecs_rule_find_var(r, "this");
-    test_assert(this_var != -1);
-    test_bool(ecs_rule_var_is_entity(r, this_var), false);
-    
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_no_this_anonymous_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e = ecs_new_w_id(world, TagA);
-    test_assert(e != 0);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($_x)"
-    });
-    test_assert(r != NULL);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(ecs_rule_next(&it), true);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_bool(ecs_rule_next(&it), false);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_no_this_anonymous_src_w_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_id(world, TagA);
-    test_assert(e != 0);
-    ecs_add_pair(world, e, EcsChildOf, parent);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($_x), ChildOf($_x, $Parent)"
-    });
-    test_assert(r != NULL);
-
-    int parent_var = ecs_rule_find_var(r, "Parent");
-    test_assert(parent_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(ecs_rule_next(&it), true);
-    test_uint(0, it.count);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 2));
-    test_uint(parent, ecs_iter_get_var(&it, parent_var));
-    test_bool(ecs_rule_next(&it), false);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_no_this_anonymous_component_src(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new(world, Position);
-    test_assert(e != 0);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($x)"
-    });
-    test_assert(r != NULL);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(ecs_rule_next(&it), true);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_bool(ecs_rule_next(&it), false);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_no_this_anonymous_component_src_w_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e = ecs_new(world, Position);
-    test_assert(e != 0);
-    ecs_add_pair(world, e, EcsChildOf, parent);
-
-    ecs_log_set_level(-4);
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position($_x), ChildOf($_x, $Parent)"
-    });
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_table_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t p1 = ecs_new(world, TagA);
-    ecs_new(world, TagA);
-    ecs_entity_t p3 = ecs_new(world, TagA);
-    ecs_entity_t p4 = ecs_new(world, TagA);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, p1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, p3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, p4);
-    ecs_add(world, child_1, TagB);
-    ecs_add(world, child_4, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA, TagB($this.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t child_var = ecs_rule_find_var(r, "this.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p1, it.entities[0]);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p4, it.entities[0]);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(child_4, ecs_field_src(&it, 2));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_entity_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new_id(world);
-    ecs_entity_t t3 = ecs_new_id(world);
-    ecs_entity_t t4 = ecs_new_id(world);
-
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
-    ecs_new_w_pair(world, Rel, t2);
-    ecs_new_w_pair(world, Rel, t3);
-    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, t1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, t3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, t4);
-    ecs_add(world, child_1, TagB);
-    ecs_add(world, child_4, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel($x, $this), TagB($this.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "this.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(t1, it.entities[0]);
-        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 1));
-        test_uint(p1, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(p1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(t4, it.entities[0]);
-        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 1));
-        test_uint(p4, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(child_4, ecs_field_src(&it, 2));
-        test_uint(p4, ecs_iter_get_var(&it, x_var));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_table(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t p1 = ecs_new(world, TagA);
-    ecs_new(world, TagA);
-    ecs_entity_t p3 = ecs_new(world, TagA);
-    ecs_entity_t p4 = ecs_new(world, TagA);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, p1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, p3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, p4);
-    ecs_add(world, child_1, TagB);
-    ecs_add(world, child_4, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($x), TagB($x.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "x.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(p1, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(p1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(p4, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(p4, ecs_iter_get_var(&it, x_var));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_entity(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new_id(world);
-    ecs_entity_t t3 = ecs_new_id(world);
-    ecs_entity_t t4 = ecs_new_id(world);
-
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
-    ecs_new_w_pair(world, Rel, t2);
-    ecs_new_w_pair(world, Rel, t3);
-    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, t1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, t3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, t4);
-    ecs_add(world, child_1, TagB);
-    ecs_add(world, child_4, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Rel, $x), TagB($x.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "x.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p1, it.entities[0]);
-        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(t1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p4, it.entities[0]);
-        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(child_4, ecs_field_src(&it, 2));
-        test_uint(t4, ecs_iter_get_var(&it, x_var));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_not_written(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-
-    ecs_log_set_level(-4);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($this.foo)"
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_table_this_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p1 = ecs_new(world, TagA);
-    ecs_new(world, TagA);
-    ecs_entity_t p3 = ecs_new(world, TagA);
-    ecs_entity_t p4 = ecs_new(world, TagA);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, p1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, p3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, p4);
-    ecs_set(world, child_1, Position, {10, 20});
-    ecs_set(world, child_4, Position, {11, 22});
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA, Position($this.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t child_var = ecs_rule_find_var(r, "this.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p1, it.entities[0]);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-        {
-            Position *ptr = ecs_field(&it, Position, 2);
-            test_assert(ptr != NULL);
-            test_int(ptr->x, 10);
-            test_int(ptr->y, 20);
-        }
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p4, it.entities[0]);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-        test_uint(child_4, ecs_field_src(&it, 2));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-        {
-            Position *ptr = ecs_field(&it, Position, 2);
-            test_assert(ptr != NULL);
-            test_int(ptr->x, 11);
-            test_int(ptr->y, 22);
-        }
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_entity_this_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new_id(world);
-    ecs_entity_t t3 = ecs_new_id(world);
-    ecs_entity_t t4 = ecs_new_id(world);
-
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
-    ecs_new_w_pair(world, Rel, t2);
-    ecs_new_w_pair(world, Rel, t3);
-    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, t1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, t3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, t4);
-    ecs_set(world, child_1, Position, {10, 20});
-    ecs_set(world, child_4, Position, {11, 22});
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Rel($x, $this), Position($this.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "this.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(t1, it.entities[0]);
-        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 1));
-        test_uint(p1, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(p1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-        {
-            Position *ptr = ecs_field(&it, Position, 2);
-            test_assert(ptr != NULL);
-            test_int(ptr->x, 10);
-            test_int(ptr->y, 20);
-        }
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(t4, it.entities[0]);
-        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 1));
-        test_uint(p4, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-        test_uint(child_4, ecs_field_src(&it, 2));
-        test_uint(p4, ecs_iter_get_var(&it, x_var));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-        {
-            Position *ptr = ecs_field(&it, Position, 2);
-            test_assert(ptr != NULL);
-            test_int(ptr->x, 11);
-            test_int(ptr->y, 22);
-        }
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_table_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p1 = ecs_new(world, TagA);
-    ecs_new(world, TagA);
-    ecs_entity_t p3 = ecs_new(world, TagA);
-    ecs_entity_t p4 = ecs_new(world, TagA);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, p1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, p3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, p4);
-    ecs_set(world, child_1, Position, {10, 20});
-    ecs_set(world, child_4, Position, {11, 22});
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($x), Position($x.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "x.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(p1, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(p1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-        {
-            Position *ptr = ecs_field(&it, Position, 2);
-            test_assert(ptr != NULL);
-            test_int(ptr->x, 10);
-            test_int(ptr->y, 20);
-        }
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(p4, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-        test_uint(p4, ecs_iter_get_var(&it, x_var));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-        {
-            Position *ptr = ecs_field(&it, Position, 2);
-            test_assert(ptr != NULL);
-            test_int(ptr->x, 11);
-            test_int(ptr->y, 22);
-        }
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_entity_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new_id(world);
-    ecs_entity_t t3 = ecs_new_id(world);
-    ecs_entity_t t4 = ecs_new_id(world);
-
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
-    ecs_new_w_pair(world, Rel, t2);
-    ecs_new_w_pair(world, Rel, t3);
-    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, t1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, t3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, t4);
-    ecs_set(world, child_1, Position, {10, 20});
-    ecs_set(world, child_4, Position, {11, 22});
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Rel, $x), Position($x.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "x.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p1, it.entities[0]);
-        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(t1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-        {
-            Position *ptr = ecs_field(&it, Position, 2);
-            test_assert(ptr != NULL);
-            test_int(ptr->x, 10);
-            test_int(ptr->y, 20);
-        }
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p4, it.entities[0]);
-        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-        test_uint(child_4, ecs_field_src(&it, 2));
-        test_uint(t4, ecs_iter_get_var(&it, x_var));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-        {
-            Position *ptr = ecs_field(&it, Position, 2);
-            test_assert(ptr != NULL);
-            test_int(ptr->x, 11);
-            test_int(ptr->y, 22);
-        }
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_table_two_children(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t p1 = ecs_new_entity(world, "p1"); ecs_add(world, p1, TagA);
-    ecs_new(world, TagA);
-    ecs_entity_t p3 = ecs_new_entity(world, "p3"); ecs_add(world, p3, TagA);
-    ecs_entity_t p4 = ecs_new_entity(world, "p4"); ecs_add(world, p4, TagA);
-
-    ecs_entity_t child_a_1 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_1, EcsChildOf, p1);
-    ecs_entity_t child_a_3 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_3, EcsChildOf, p3);
-    ecs_entity_t child_a_4 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_4, EcsChildOf, p4);
-    ecs_add(world, child_a_1, TagB);
-    ecs_add(world, child_a_4, TagB);
-
-    ecs_entity_t child_b_1 = ecs_new_entity(world, "child_b");
-    ecs_add_pair(world, child_b_1, EcsChildOf, p1);
-    ecs_entity_t child_b_3 = ecs_new_entity(world, "child_b");
-    ecs_add_pair(world, child_b_3, EcsChildOf, p3);
-    ecs_entity_t child_b_4 = ecs_new_entity(world, "child_b");
-    ecs_add_pair(world, child_b_4, EcsChildOf, p4);
-    ecs_add(world, child_b_1, TagC);
-    ecs_add(world, child_b_3, TagC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA, TagB($this.child_a), TagC($this.child_b)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t child_a_var = ecs_rule_find_var(r, "this.child_a");
-    test_assert(child_a_var != -1);
-    int32_t child_b_var = ecs_rule_find_var(r, "this.child_b");
-    test_assert(child_b_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p1, it.entities[0]);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(TagC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(child_a_1, ecs_field_src(&it, 2));
-        test_uint(child_b_1, ecs_field_src(&it, 3));
-        test_uint(child_a_1, ecs_iter_get_var(&it, child_a_var));
-        test_uint(child_b_1, ecs_iter_get_var(&it, child_b_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_entity_two_children(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new_id(world);
-    ecs_entity_t t3 = ecs_new_id(world);
-    ecs_entity_t t4 = ecs_new_id(world);
-
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
-    ecs_new_w_pair(world, Rel, t2);
-    ecs_new_w_pair(world, Rel, t3);
-    ecs_new_w_pair(world, Rel, t4);
-
-    ecs_entity_t child_a_1 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_1, EcsChildOf, t1);
-    ecs_entity_t child_a_3 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_3, EcsChildOf, t3);
-    ecs_entity_t child_a_4 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_4, EcsChildOf, t4);
-    ecs_add(world, child_a_1, TagB);
-    ecs_add(world, child_a_4, TagB);
-
-    ecs_entity_t child_b_1 = ecs_new_entity(world, "child_b");
-    ecs_add_pair(world, child_b_1, EcsChildOf, t1);
-    ecs_entity_t child_b_3 = ecs_new_entity(world, "child_b");
-    ecs_add_pair(world, child_b_3, EcsChildOf, t3);
-    ecs_entity_t child_b_4 = ecs_new_entity(world, "child_b");
-    ecs_add_pair(world, child_b_4, EcsChildOf, t4);
-    ecs_add(world, child_b_1, TagC);
-    ecs_add(world, child_b_3, TagC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Rel, $x), TagB($x.child_a), TagC($x.child_b)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_a_var = ecs_rule_find_var(r, "x.child_a");
-    test_assert(child_a_var != -1);
-    int32_t child_b_var = ecs_rule_find_var(r, "x.child_b");
-    test_assert(child_b_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p1, it.entities[0]);
-        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(TagC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(child_a_1, ecs_field_src(&it, 2));
-        test_uint(child_b_1, ecs_field_src(&it, 3));
-        test_uint(t1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_a_1, ecs_iter_get_var(&it, child_a_var));
-        test_uint(child_b_1, ecs_iter_get_var(&it, child_b_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_table_same_child_twice(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t p1 = ecs_new_entity(world, "p1"); ecs_add(world, p1, TagA);
-    ecs_new(world, TagA);
-    ecs_entity_t p3 = ecs_new_entity(world, "p3"); ecs_add(world, p3, TagA);
-    ecs_entity_t p4 = ecs_new_entity(world, "p4"); ecs_add(world, p4, TagA);
-
-    ecs_entity_t child_a_1 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_1, EcsChildOf, p1);
-    ecs_entity_t child_a_3 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_3, EcsChildOf, p3);
-    ecs_entity_t child_a_4 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_4, EcsChildOf, p4);
-    ecs_add(world, child_a_1, TagB);
-    ecs_add(world, child_a_4, TagB);
-    ecs_add(world, child_a_1, TagC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA, TagB($this.child_a), TagC($this.child_a)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t child_a_var = ecs_rule_find_var(r, "this.child_a");
-    test_assert(child_a_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p1, it.entities[0]);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(TagC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(child_a_1, ecs_field_src(&it, 2));
-        test_uint(child_a_1, ecs_field_src(&it, 3));
-        test_uint(child_a_1, ecs_iter_get_var(&it, child_a_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_entity_same_child_twice(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new_id(world);
-    ecs_entity_t t3 = ecs_new_id(world);
-    ecs_entity_t t4 = ecs_new_id(world);
-
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
-    ecs_new_w_pair(world, Rel, t2);
-    ecs_new_w_pair(world, Rel, t3);
-    ecs_new_w_pair(world, Rel, t4);
-
-    ecs_entity_t child_a_1 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_1, EcsChildOf, t1);
-    ecs_entity_t child_a_3 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_3, EcsChildOf, t3);
-    ecs_entity_t child_a_4 = ecs_new_entity(world, "child_a");
-    ecs_add_pair(world, child_a_4, EcsChildOf, t4);
-    ecs_add(world, child_a_1, TagB);
-    ecs_add(world, child_a_4, TagB);
-    ecs_add(world, child_a_1, TagC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Rel, $x), TagB($x.child_a), TagC($x.child_a)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_a_var = ecs_rule_find_var(r, "x.child_a");
-    test_assert(child_a_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p1, it.entities[0]);
-        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(TagC, ecs_field_id(&it, 3));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(child_a_1, ecs_field_src(&it, 2));
-        test_uint(child_a_1, ecs_field_src(&it, 3));
-        test_uint(t1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_a_1, ecs_iter_get_var(&it, child_a_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_table_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t p1 = ecs_new(world, TagA); ecs_set_name(world, p1, "p1");
-    ecs_entity_t p2 = ecs_new(world, TagA); ecs_set_name(world, p2, "p2");
-    ecs_entity_t p3 = ecs_new(world, TagA); ecs_set_name(world, p3, "p3");
-    ecs_entity_t p4 = ecs_new(world, TagA); ecs_set_name(world, p4, "p4");
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, p1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, p3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, p4);
-    ecs_add(world, child_1, TagB);
-    ecs_add(world, child_4, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($x), !TagB($x.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "x.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(p2, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(p2, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, child_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_uint(p3, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(p3, ecs_iter_get_var(&it, x_var));
-        test_uint(child_3, ecs_iter_get_var(&it, child_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_entity_not(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new_id(world);
-    ecs_entity_t t3 = ecs_new_id(world);
-    ecs_entity_t t4 = ecs_new_id(world);
-
-    ecs_new_w_pair(world, Rel, t1);
-    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, t2);
-    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, t3);
-    ecs_new_w_pair(world, Rel, t4);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, t1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, t3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, t4);
-    ecs_add(world, child_1, TagB);
-    ecs_add(world, child_4, TagB);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Rel, $x), !TagB($x.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "x.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p2, it.entities[0]);
-        test_uint(ecs_pair(Rel, t2), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(t2, ecs_iter_get_var(&it, x_var));
-        test_uint(EcsWildcard, ecs_iter_get_var(&it, child_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p3, it.entities[0]);
-        test_uint(ecs_pair(Rel, t3), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(TagB, ecs_field_id(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 2));
-        test_uint(t3, ecs_iter_get_var(&it, x_var));
-        test_uint(child_3, ecs_iter_get_var(&it, child_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_table_w_any_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t p1 = ecs_new(world, TagA);
-    ecs_new(world, TagA);
-    ecs_entity_t p3 = ecs_new(world, TagA);
-    ecs_entity_t p4 = ecs_new(world, TagA);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, p1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, p3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, p4);
-    ecs_add(world, child_1, TagB);
-    ecs_add(world, child_4, TagB);
-    ecs_add(world, child_4, TagC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "TagA($x), _($x.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "x.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(p1, ecs_field_src(&it, 1));
-        test_uint(EcsWildcard, ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(p1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(0, it.count);
-        test_uint(TagA, ecs_field_id(&it, 1));
-        test_uint(p4, ecs_field_src(&it, 1));
-        test_uint(EcsWildcard, ecs_field_id(&it, 2));
-        test_uint(p4, ecs_iter_get_var(&it, x_var));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_from_entity_w_any_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t t1 = ecs_new_id(world);
-    ecs_entity_t t2 = ecs_new_id(world);
-    ecs_entity_t t3 = ecs_new_id(world);
-    ecs_entity_t t4 = ecs_new_id(world);
-
-    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
-    ecs_new_w_pair(world, Rel, t2);
-    ecs_new_w_pair(world, Rel, t3);
-    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
-
-    ecs_entity_t child_1 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_1, EcsChildOf, t1);
-    ecs_entity_t child_3 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_3, EcsChildOf, t3);
-    ecs_entity_t child_4 = ecs_new_entity(world, "child");
-    ecs_add_pair(world, child_4, EcsChildOf, t4);
-    ecs_add(world, child_1, TagB);
-    ecs_add(world, child_4, TagB);
-    ecs_add(world, child_4, TagC);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(Rel, $x), _($x.child)"
-    });
-
-    test_assert(r != NULL);
-
-    int32_t x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int32_t child_var = ecs_rule_find_var(r, "x.child");
-    test_assert(child_var != -1);
-
-    {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p1, it.entities[0]);
-        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(EcsWildcard, ecs_field_id(&it, 2));
-        test_uint(child_1, ecs_field_src(&it, 2));
-        test_uint(t1, ecs_iter_get_var(&it, x_var));
-        test_uint(child_1, ecs_iter_get_var(&it, child_var));
-
-        test_bool(true, ecs_rule_next(&it));
-        test_uint(1, it.count);
-        test_uint(p4, it.entities[0]);
-        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(EcsWildcard, ecs_field_id(&it, 2));
-        test_uint(child_4, ecs_field_src(&it, 2));
-        test_uint(t4, ecs_iter_get_var(&it, x_var));
-        test_uint(child_4, ecs_iter_get_var(&it, child_var));
-
-        test_bool(false, ecs_rule_next(&it));
-    }
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_as_tag(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent_a = ecs_new(world, Foo);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_entity_t parent_c = ecs_new(world, Foo);
-    ecs_new(world, Foo);
-
-    ecs_entity_t tag_a = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_a, EcsChildOf, parent_a);
-
-    ecs_entity_t tag_b = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_b, EcsChildOf, parent_b);
-
-    ecs_entity_t tag_c = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_c, EcsChildOf, parent_c);
-
-    ecs_entity_t a = ecs_new_w_id(world, tag_a);
-    ecs_entity_t c = ecs_new_w_id(world, tag_c);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, $this.Tag($x)"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int tag_var = ecs_rule_find_var(r, "this.Tag");
-    test_assert(tag_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(tag_a, ecs_field_id(&it, 2));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(a, ecs_field_src(&it, 2));
-    test_uint(a, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_a, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_c, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(tag_c, ecs_field_id(&it, 2));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(c, ecs_field_src(&it, 2));
-    test_uint(c, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_c, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_as_relationship(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Tgt);
-
-    ecs_entity_t parent_a = ecs_new(world, Foo);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_entity_t parent_c = ecs_new(world, Foo);
-    ecs_new(world, Foo);
-
-    ecs_entity_t tag_a = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_a, EcsChildOf, parent_a);
-
-    ecs_entity_t tag_b = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_b, EcsChildOf, parent_b);
-
-    ecs_entity_t tag_c = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_c, EcsChildOf, parent_c);
-
-    ecs_entity_t a = ecs_new_w_pair(world, tag_a, Tgt);
-    ecs_entity_t c = ecs_new_w_pair(world, tag_c, Tgt);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, $this.Tag($x, Tgt)"
-    });
-
-    test_assert(r != NULL);
-    
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int tag_var = ecs_rule_find_var(r, "this.Tag");
-    test_assert(tag_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(tag_a, Tgt), ecs_field_id(&it, 2));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(a, ecs_field_src(&it, 2));
-    test_uint(a, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_a, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_c, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(tag_c, Tgt), ecs_field_id(&it, 2));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(c, ecs_field_src(&it, 2));
-    test_uint(c, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_c, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_as_target(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent_a = ecs_new(world, Foo);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_entity_t parent_c = ecs_new(world, Foo);
-    ecs_new(world, Foo);
-
-    ecs_entity_t tag_a = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_a, EcsChildOf, parent_a);
-
-    ecs_entity_t tag_b = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_b, EcsChildOf, parent_b);
-
-    ecs_entity_t tag_c = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_c, EcsChildOf, parent_c);
-
-    ecs_entity_t a = ecs_new_w_pair(world, Rel, tag_a);
-    ecs_entity_t c = ecs_new_w_pair(world, Rel, tag_c);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, Rel($x, $this.Tag)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int tag_var = ecs_rule_find_var(r, "this.Tag");
-    test_assert(tag_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, tag_a), ecs_field_id(&it, 2));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(a, ecs_field_src(&it, 2));
-    test_uint(a, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_a, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_c, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Rel, tag_c), ecs_field_id(&it, 2));
-    test_uint(0, ecs_field_src(&it, 1));
-    test_uint(c, ecs_field_src(&it, 2));
-    test_uint(c, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_c, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_assign_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent_a = ecs_new(world, Foo);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_new(world, Foo);
-
-    ecs_entity_t tag_a = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_a, EcsChildOf, parent_a);
-
-    ecs_entity_t tag_b = ecs_new_entity(world, "Tag");
-    ecs_add_pair(world, tag_b, EcsChildOf, parent_b);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, $x == $this.Tag"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int tag_var = ecs_rule_find_var(r, "this.Tag");
-    test_assert(tag_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(tag_a, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_a, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_b, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(tag_b, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_b, ecs_iter_get_var(&it, tag_var));
-    
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_eq_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent_a = ecs_new(world, Foo);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_new(world, Foo);
-
-    ecs_entity_t tag_ax = ecs_new_entity(world, "TagX");
-    ecs_add_pair(world, tag_ax, EcsChildOf, parent_a);
-    ecs_entity_t tag_ay = ecs_new_entity(world, "TagY");
-    ecs_add_pair(world, tag_ay, EcsChildOf, parent_a);
-    ecs_entity_t tag_az = ecs_new_entity(world, "TagZ");
-    ecs_add_pair(world, tag_az, EcsChildOf, parent_a);
-
-    ecs_entity_t tag_bx = ecs_new_entity(world, "TagX");
-    ecs_add_pair(world, tag_bx, EcsChildOf, parent_b);
-    ecs_entity_t tag_by = ecs_new_entity(world, "TagY");
-    ecs_add_pair(world, tag_by, EcsChildOf, parent_b);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, ChildOf($x, $this), $x == $this.TagY"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int tag_var = ecs_rule_find_var(r, "this.TagY");
-    test_assert(tag_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_childof(parent_a), ecs_field_id(&it, 2));
-    test_uint(tag_ay, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_ay, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_b, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_childof(parent_b), ecs_field_id(&it, 2));
-    test_uint(tag_by, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_by, ecs_iter_get_var(&it, tag_var));
-    
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_neq_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Foo);
-
-    ecs_entity_t parent_a = ecs_new(world, Foo);
-    ecs_entity_t parent_b = ecs_new(world, Foo);
-    ecs_new(world, Foo);
-
-    ecs_entity_t tag_ax = ecs_new_entity(world, "TagX");
-    ecs_add_pair(world, tag_ax, EcsChildOf, parent_a);
-    ecs_entity_t tag_ay = ecs_new_entity(world, "TagY");
-    ecs_add_pair(world, tag_ay, EcsChildOf, parent_a);
-    ecs_entity_t tag_az = ecs_new_entity(world, "TagZ");
-    ecs_add_pair(world, tag_az, EcsChildOf, parent_a);
-
-    ecs_entity_t tag_bx = ecs_new_entity(world, "TagX");
-    ecs_add_pair(world, tag_bx, EcsChildOf, parent_b);
-    ecs_entity_t tag_by = ecs_new_entity(world, "TagY");
-    ecs_add_pair(world, tag_by, EcsChildOf, parent_b);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo, ChildOf($x, $this), $x != $this.TagY"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-    int tag_var = ecs_rule_find_var(r, "this.TagY");
-    test_assert(tag_var != -1);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_childof(parent_a), ecs_field_id(&it, 2));
-    test_uint(tag_ax, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_ay, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_a, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_childof(parent_a), ecs_field_id(&it, 2));
-    test_uint(tag_az, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_ay, ecs_iter_get_var(&it, tag_var));
-
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(parent_b, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_childof(parent_b), ecs_field_id(&it, 2));
-    test_uint(tag_bx, ecs_iter_get_var(&it, x_var));
-    test_uint(tag_by, ecs_iter_get_var(&it, tag_var));
-    
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_lookup_unresolved_dependent(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_log_set_level(-4);
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "(ChildOf, $_tgt), ChildOf(flecs, $tgt.child)"
-    });
-
-    test_assert(r == NULL);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_this(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo"
-    });
-
-    test_assert(r != NULL);
-    test_int(1, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($x)"
-    });
-
-    test_assert(r != NULL);
-    test_int(2, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-    test_str("x", ecs_rule_var_name(r, 1));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "*"
-    });
-
-    test_assert(r != NULL);
-    test_int(1, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "_"
-    });
-
-    test_assert(r != NULL);
-    test_int(1, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_var_as_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($this), ChildOf($this, $x)"
-    });
-
-    test_assert(r != NULL);
-    test_int(2, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-    test_str("x", ecs_rule_var_name(r, 1));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_this_as_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($this), ChildOf($x, $this)"
-    });
-
-    test_assert(r != NULL);
-    test_int(3, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0)); // table
-    test_str("x", ecs_rule_var_name(r, 1));
-    test_str("this", ecs_rule_var_name(r, 2)); // entity
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_this_w_lookup_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($this), ChildOf($x, $this.var)"
-    });
-
-    test_assert(r != NULL);
-    test_int(4, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-    test_str("x", ecs_rule_var_name(r, 1));
-    test_str("this.var", ecs_rule_var_name(r, 2));
-    test_str("this", ecs_rule_var_name(r, 3));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_var_w_lookup_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($y), ChildOf($x, $y.var)"
-    });
-
-    test_assert(r != NULL);
-    test_int(4, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-    test_str("y", ecs_rule_var_name(r, 1));
-    test_str("x", ecs_rule_var_name(r, 2));
-    test_str("y.var", ecs_rule_var_name(r, 3));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_anonymous_var_as_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($this), ChildOf($this, $_x)"
-    });
-
-    test_assert(r != NULL);
-    test_int(2, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-    test_str("_x", ecs_rule_var_name(r, 1));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_wildcard_as_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($this), ChildOf($this, *)"
-    });
-
-    test_assert(r != NULL);
-    test_int(1, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_check_vars_any_as_tgt(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo($this), ChildOf($this, _)"
-    });
-
-    test_assert(r != NULL);
-    test_int(1, ecs_rule_var_count(r));
-    test_str("this", ecs_rule_var_name(r, 0));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_trivial_1_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), ChildOf($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_add(world, e, Foo);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 2));
-    test_uint(p, ecs_iter_get_var(&it, x_var));
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_trivial_1_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), Bar(self), ChildOf($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_add(world, e, Foo);
-    ecs_add(world, e, Bar);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(Bar, ecs_field_id(&it, 2));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
-    test_uint(p, ecs_iter_get_var(&it, x_var));
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_trivial_1_var_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), ChildOf($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set(world, e, Position, {10, 20});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-    test_uint(p, ecs_iter_get_var(&it, x_var));
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_trivial_1_var_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), Velocity(self), ChildOf($this, $x)"
-    });
-
-    test_assert(r != NULL);
-
-    int x_var = ecs_rule_find_var(r, "x");
-    test_assert(x_var != -1);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set(world, e, Position, {10, 20});
-    ecs_set(world, e, Velocity, {1, 2});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-    test_assert(ecs_field(&it, Velocity, 2) != NULL);
-    {
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-    test_uint(p, ecs_iter_get_var(&it, x_var));
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_trivial_1_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), ChildOf($this, *)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_add(world, e, Foo);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 2));
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_trivial_1_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), Bar(self), ChildOf($this, *)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_add(world, e, Foo);
-    ecs_add(world, e, Bar);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(Bar, ecs_field_id(&it, 2));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_trivial_1_wildcard_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), ChildOf($this, *)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set(world, e, Position, {10, 20});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_trivial_1_wildcard_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), Velocity(self), ChildOf($this, *)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set(world, e, Position, {10, 20});
-    ecs_set(world, e, Velocity, {1, 2});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-    test_assert(ecs_field(&it, Velocity, 2) != NULL);
-    {
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_trivial_1_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), ChildOf($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_add(world, e, Foo);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 2));
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_trivial_1_any(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Foo(self), Bar(self), ChildOf($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_add(world, e, Foo);
-    ecs_add(world, e, Bar);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(Foo, ecs_field_id(&it, 1));
-    test_uint(Bar, ecs_field_id(&it, 2));
-    test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 3));
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_1_trivial_1_any_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), ChildOf($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set(world, e, Position, {10, 20});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 2));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void RulesVariables_2_trivial_1_any_component(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "Position(self), Velocity(self), ChildOf($this, _)"
-    });
-
-    test_assert(r != NULL);
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set(world, e, Position, {10, 20});
-    ecs_set(world, e, Velocity, {1, 2});
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(true, ecs_rule_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 3));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-    test_assert(ecs_field(&it, Velocity, 2) != NULL);
-    {
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_assert(v != NULL);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-    test_bool(false, ecs_rule_next(&it));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/Run.c b/test/addons/src/Run.c
index 78afb8b25..600dfe1f4 100644
--- a/test/addons/src/Run.c
+++ b/test/addons/src/Run.c
@@ -6,16 +6,16 @@ void Run_setup(void) {
 
 static
 void Iter(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     Velocity *v = NULL;
     Mass *m = NULL;
 
     if (it->field_count >= 2) {
-        v = ecs_field(it, Velocity, 2);
+        v = ecs_field(it, Velocity, 1);
     }
 
     if (it->field_count >= 3) {
-        m = ecs_field(it, Mass, 3);
+        m = ecs_field(it, Mass, 2);
     }
 
     int *param = it->param;
@@ -139,899 +139,6 @@ void Run_run_w_param(void) {
     ecs_fini(world);
 }
 
-void Run_run_w_offset(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 2, 0, NULL), 0);
-
-    test_int(ctx.count, 4);
-    test_int(ctx.invoked, 3);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e3);
-    test_int(ctx.e[1], e4);
-    test_int(ctx.e[2], e5);
-    test_int(ctx.e[3], e6);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_offset_skip_1_archetype(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 3, 0, NULL), 0);
-
-    test_int(ctx.count, 3);
-    test_int(ctx.invoked, 2);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e4);
-    test_int(ctx.e[1], e5);
-    test_int(ctx.e[2], e6);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_offset_skip_1_archetype_plus_one(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 4, 0, NULL), 0);
-
-    test_int(ctx.count, 2);
-    test_int(ctx.invoked, 2);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e5);
-    test_int(ctx.e[1], e6);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_offset_skip_2_archetypes(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 5, 0, NULL), 0);
-
-    test_int(ctx.count, 1);
-    test_int(ctx.invoked, 1);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e6);
-
-    test_int(ctx.c[0][0], ecs_id(Position));
-    test_int(ctx.s[0][0], 0);
-    test_int(ctx.c[0][1], ecs_id(Velocity));
-    test_int(ctx.s[0][1], 0);
-
-    const Position *p = ecs_get(world, e6, Position);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    const Velocity *v = ecs_get(world, e6, Velocity);
-    test_int(v->x, 30);
-    test_int(v->y, 40);        
-
-    ecs_fini(world);
-}
-
-void Run_run_w_limit_skip_1_archetype(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 0, 5, NULL), 0);
-
-    test_int(ctx.count, 5);
-    test_int(ctx.invoked, 2);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e1);
-    test_int(ctx.e[1], e2);
-    test_int(ctx.e[2], e3);
-    test_int(ctx.e[3], e4);
-    test_int(ctx.e[4], e5);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_limit_skip_1_archetype_minus_one(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 0, 4, NULL), 0);
-
-    test_int(ctx.count, 4);
-    test_int(ctx.invoked, 2);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e1);
-    test_int(ctx.e[1], e2);
-    test_int(ctx.e[2], e3);
-    test_int(ctx.e[3], e4);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_limit_skip_2_archetypes(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 0, 3, NULL), 0);
-
-    test_int(ctx.count, 3);
-    test_int(ctx.invoked, 1);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e1);
-    test_int(ctx.e[1], e2);
-    test_int(ctx.e[2], e3);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_offset_1_limit_max(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 1, 5, NULL), 0);
-
-    test_int(ctx.count, 5);
-    test_int(ctx.invoked, 3);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e2);
-    test_int(ctx.e[1], e3);
-    test_int(ctx.e[2], e4);
-    test_int(ctx.e[3], e5);
-    test_int(ctx.e[4], e6);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_offset_1_limit_minus_1(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 1, 4, NULL), 0);
-
-    test_int(ctx.count, 4);
-    test_int(ctx.invoked, 2);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e2);
-    test_int(ctx.e[1], e3);
-    test_int(ctx.e[2], e4);
-    test_int(ctx.e[3], e5);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_offset_2_type_limit_max(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 3, 3, NULL), 0);
-
-    test_int(ctx.count, 3);
-    test_int(ctx.invoked, 2);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e4);
-    test_int(ctx.e[1], e5);
-    test_int(ctx.e[2], e6);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_offset_2_type_limit_minus_1(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 3, 2, NULL), 0);
-
-    test_int(ctx.count, 2);
-    test_int(ctx.invoked, 1);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e4);
-    test_int(ctx.e[1], e5);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_limit_1_all_offsets(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    /* Process entities out of order so we can validate whether it is correct */
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 0, 1, NULL), 0);
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 2, 1, NULL), 0);
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 1, 1, NULL), 0);
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 3, 1, NULL), 0);
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 5, 1, NULL), 0);
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 4, 1, NULL), 0);
-
-    test_int(ctx.count, 6);
-    test_int(ctx.invoked, 6);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e1);
-    test_int(ctx.e[1], e3);
-    test_int(ctx.e[2], e2);
-    test_int(ctx.e[3], e4);
-    test_int(ctx.e[4], e6);
-    test_int(ctx.e[5], e5);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_w_offset_out_of_bounds(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 6, 1, NULL), 0);
-
-    test_int(ctx.count, 0);
-    test_int(ctx.invoked, 0);
-
-    ecs_fini(world);
-}
-
-void Run_run_w_limit_out_of_bounds(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    ECS_ENTITY(world, e1, Position, Velocity);
-    ECS_ENTITY(world, e2, Position, Velocity);
-    ECS_ENTITY(world, e3, Position, Velocity);
-    ECS_ENTITY(world, e4, Position, Velocity, Mass);
-    ECS_ENTITY(world, e5, Position, Velocity, Mass);
-    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
-    ECS_ENTITY(world, e7, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run_w_filter(world, Iter, 1.0, 5, 2, NULL), 0);
-
-    test_int(ctx.count, 1);
-    test_int(ctx.invoked, 1);
-    test_int(ctx.system, Iter);
-    test_int(ctx.term_count, 2);
-    test_null(ctx.param);
-
-    test_int(ctx.e[0], e6);
-
-    int i;
-    for (i = 0; i < ctx.invoked; i ++) {
-        test_int(ctx.c[i][0], ecs_id(Position));
-        test_int(ctx.s[i][0], 0);
-        test_int(ctx.c[i][1], ecs_id(Velocity));
-        test_int(ctx.s[i][1], 0);
-    }
-
-    for (i = 0; i < ctx.count; i ++) {
-        const Position *p = ecs_get(world, ctx.e[i], Position);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
-        test_int(v->x, 30);
-        test_int(v->y, 40);        
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_no_match(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ECS_ENTITY(world, e1, Position);
-
-    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
-
-    Probe ctx = {0};
-    ecs_set_ctx(world, &ctx, NULL);
-
-    /* Ensure system is not run by ecs_progress */
-    ecs_progress(world, 1);
-    test_int(ctx.invoked, 0);
-
-    test_int( ecs_run(world, Iter, 1.0, NULL), 0);
-
-    test_int(ctx.count, 0);
-    test_int(ctx.invoked, 0);
-
-    ecs_fini(world);
-}
-
-typedef struct Param {
-    ecs_entity_t entity;
-    int count;
-} Param;
-
-static
-void TestSubset(ecs_iter_t *it) {
-    Param *param = it->param;
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        test_assert(param->entity != it->entities[i]);
-        param->count ++;
-    }    
-}
-
-static
-void TestAll(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-
-    ecs_entity_t TestSubset = ecs_field_id(it, 2);
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        Param param = {.entity = it->entities[i], 0};
-        ecs_run_w_filter(it->world, TestSubset, 1, it->frame_offset + i + 1, 0, &param);
-        p[i].x += param.count;
-    }
-}
-
-void Run_run_comb_10_entities_1_type(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_SYSTEM(world, TestSubset, 0, Position);
-    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position, TestSubset());
-
-    int i, ENTITIES = 10;
-
-    const ecs_entity_t *ids = ecs_bulk_new(world, Position, ENTITIES);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        ecs_set(world, ids[i], Position, {1, 2});
-    }
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < ENTITIES; i ++) {
-        const Position *p = ecs_get(world, ids[i], Position);
-        test_int(p->x, ENTITIES - i);
-    }
-
-    ecs_fini(world);
-}
-
-void Run_run_comb_10_entities_2_types(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ECS_SYSTEM(world, TestSubset, 0, Position);
-    ECS_SYSTEM(world, TestAll, EcsOnUpdate, Position, TestSubset());
-
-    int i, ENTITIES = 10;
-    ecs_entity_t ids_1[5], ids_2[5];
-
-    for (int i = 0; i < ENTITIES / 2; i ++) {
-        ids_1[i] = ecs_set(world, 0, Position, {1, 2});
-    }
-    for (int i = 0; i < ENTITIES / 2; i ++) {
-        ids_2[i] = ecs_set(world, 0, Position, {1, 2});
-        ecs_add(world, ids_2[i], Velocity);
-    } 
-
-    ecs_progress(world, 0);
-
-    for (i = 0; i < 5; i ++) {
-        const Position *p = ecs_get(world, ids_1[i], Position);
-        test_int(p->x, ENTITIES - i);
-
-        p = ecs_get(world, ids_2[i], Position);
-        test_int(p->x, ENTITIES - (i + 5));
-    }
-
-    ecs_fini(world);
-}
-
 static
 void Interrupt(ecs_iter_t *it) {
     int i;
@@ -1071,9 +178,9 @@ static
 void AddVelocity(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
 
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -1103,8 +210,8 @@ void Run_run_staging(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {30, 40});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {30, 40}));
 
     ECS_SYSTEM(world, AddVelocity, 0, Position, Velocity());
 
@@ -1131,3 +238,28 @@ void Run_run_staging(void) {
  
     ecs_fini(world);
 }
+
+void Run_run_no_match(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ECS_ENTITY(world, e1, Position);
+
+    ECS_SYSTEM(world, Iter, 0, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    /* Ensure system is not run by ecs_progress */
+    ecs_progress(world, 1);
+    test_int(ctx.invoked, 0);
+
+    test_int( ecs_run(world, Iter, 1.0, NULL), 0);
+
+    test_int(ctx.count, 0);
+    test_int(ctx.invoked, 0);
+
+    ecs_fini(world);
+}
diff --git a/test/addons/src/Snapshot.c b/test/addons/src/Snapshot.c
deleted file mode 100644
index 9ee5031ef..000000000
--- a/test/addons/src/Snapshot.c
+++ /dev/null
@@ -1,879 +0,0 @@
-#include <addons.h>
-
-void Snapshot_simple_snapshot(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    Position *p = ecs_ensure(world, e, Position);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    p->x ++;
-    p->y ++;
-
-    ecs_snapshot_restore(world, s);
-
-    test_assert(ecs_has(world, e, Position));
-    p = ecs_ensure(world, e, Position);
-    test_int(p->x, 10);
-    test_int(p->y, 20);    
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_after_new(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e = ecs_new(world, Position);
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    test_assert(e2 != 0);
-    test_assert(ecs_has(world, e2, Position));
-
-    ecs_snapshot_restore(world, s);
-
-    test_assert(ecs_is_alive(world, e));
-    test_assert(!ecs_is_alive(world, e2));
-
-    test_assert(ecs_has(world, e, Position));
-    test_assert(ecs_new(world, 0) == e2);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_after_delete(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_delete(world, e);
-    test_assert(!ecs_is_alive(world, e));
-
-    ecs_snapshot_restore(world, s);    
-
-    test_assert(ecs_is_alive(world, e));
-    test_assert(ecs_has(world, e, Position));
-
-    const Position *p = ecs_get(world, e, Position);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_after_new_type(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add(world, e2, Velocity);
-
-    ecs_snapshot_restore(world, s);    
-
-    test_assert(ecs_is_alive(world, e));
-    test_assert(!ecs_is_alive(world, e2));
-
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_after_add(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_add(world, e, Velocity);
-    test_assert(ecs_has(world, e, Velocity));
-
-    ecs_snapshot_restore(world, s);
-
-    test_assert(ecs_has(world, e, Position));
-    test_assert(!ecs_has(world, e, Velocity));
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_after_remove(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e = ecs_new(world, Position);
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_add(world, e, Velocity);
-    test_assert(ecs_has(world, e, Velocity));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_remove(world, e, Velocity);
-    test_assert(!ecs_has(world, e, Velocity));
-
-    ecs_snapshot_restore(world, s);
-
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_w_include_filter(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e1 != 0);
-    test_assert(ecs_has(world, e1, Position));
-
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {15, 25});
-    test_assert(e2 != 0);
-    ecs_add(world, e2, Velocity);
-    test_assert(ecs_has(world, e2, Position));
-    test_assert(ecs_has(world, e2, Velocity));
-
-    ecs_entity_t e3 = ecs_set(world, 0, Velocity, {25, 35});
-    test_assert(e3 != 0);
-    test_assert(ecs_has(world, e3, Velocity));
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_snapshot_t *s = ecs_snapshot_take_w_iter(&it);
-
-    Position *p = ecs_ensure(world, e1, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    p->x ++;
-    p->y ++;
-
-    p = ecs_ensure(world, e2, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 15);
-    test_int(p->y, 25);
-
-    p->x ++;
-    p->y ++;
-
-    Velocity *v = ecs_ensure(world, e3, Velocity);
-    test_assert(v != NULL);
-    test_int(v->x, 25); 
-    test_int(v->y, 35);
-
-    v->x ++;
-    v->y ++;
-
-    ecs_snapshot_restore(world, s);
-
-    /* Restored */
-    p = ecs_ensure(world, e1, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    /* Restored */
-    p = ecs_ensure(world, e2, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 15);
-    test_int(p->y, 25);
-
-    /* Not restored */
-    v = ecs_ensure(world, e3, Velocity);
-    test_assert(v != NULL);
-    test_int(v->x, 26); 
-    test_int(v->y, 36);
-
-    test_assert(ecs_new(world, 0) > e3);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_w_exclude_filter(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e1 != 0);
-    test_assert(ecs_has(world, e1, Position));
-
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {15, 25});
-    test_assert(e2 != 0);
-    ecs_add(world, e2, Velocity);
-    test_assert(ecs_has(world, e2, Position));
-    test_assert(ecs_has(world, e2, Velocity));
-
-    ecs_entity_t e3 = ecs_set(world, 0, Velocity, {25, 35});
-    test_assert(e3 != 0);
-    test_assert(ecs_has(world, e3, Velocity));
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Position), .oper = EcsNot }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_snapshot_t *s = ecs_snapshot_take_w_iter(&it);
-
-    Position *p = ecs_ensure(world, e1, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    p->x ++;
-    p->y ++;
-
-    p = ecs_ensure(world, e2, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 15);
-    test_int(p->y, 25);
-
-    p->x ++;
-    p->y ++;
-
-    Velocity *v = ecs_ensure(world, e3, Velocity);
-    test_assert(v != NULL);
-    test_int(v->x, 25); 
-    test_int(v->y, 35);
-
-    v->x ++;
-    v->y ++;
-
-    ecs_snapshot_restore(world, s);
-
-    /* Not restored */
-    p = ecs_ensure(world, e1, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 11);
-    test_int(p->y, 21);
-
-    /* Not restored */
-    p = ecs_ensure(world, e2, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 16);
-    test_int(p->y, 26);
-
-    /* Restored */
-    v = ecs_ensure(world, e3, Velocity);
-    test_assert(v != NULL);
-    test_int(v->x, 25); 
-    test_int(v->y, 35);
-
-    test_assert(ecs_new(world, 0) > e3);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_w_filter_after_new(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {1, 2});
-    test_assert(e1 != 0);
-    test_assert(ecs_has(world, e1, Position));
-
-    ecs_entity_t e2 = ecs_set(world, 0, Velocity, {3, 4});
-    test_assert(e2 != 0);
-    test_assert(ecs_has(world, e2, Velocity));
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_snapshot_t *s = ecs_snapshot_take_w_iter(&it);
-
-    ecs_set(world, e1, Position, {5, 6});
-    ecs_set(world, e2, Velocity, {7, 8});
-
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {33, 44});
-    test_assert(e3 != 0);
-    test_assert(ecs_has(world, e3, Position));
-
-    ecs_entity_t e4 = ecs_set(world, 0, Velocity, {34, 45});
-    test_assert(e4 != 0);
-    test_assert(ecs_has(world, e4, Velocity));
-
-    ecs_snapshot_restore(world, s);
-
-    test_assert(ecs_has(world, e1, Position));
-    const Position *p = ecs_get(world, e1, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 1);
-    test_int(p->y, 2);
-
-    test_assert(ecs_has(world, e2, Velocity));
-    const Velocity *v = ecs_get(world, e2, Velocity);
-    test_assert(v != NULL);
-    test_int(v->x, 7);
-    test_int(v->y, 8);
-
-    test_assert(ecs_has(world, e3, Position));
-    p = ecs_get(world, e3, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 33);
-    test_int(p->y, 44);
-
-    test_assert(ecs_has(world, e4, Velocity));
-    v = ecs_get(world, e4, Velocity);
-    test_assert(p != NULL);
-    test_int(v->x, 34);
-    test_int(v->y, 45);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_w_filter_after_delete(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {1, 2});
-    test_assert(e1 != 0);
-    test_assert(ecs_has(world, e1, Position));
-
-    ecs_entity_t e2 = ecs_set(world, 0, Velocity, {3, 4});
-    test_assert(e2 != 0);
-    test_assert(ecs_has(world, e2, Velocity));
-
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {1, 2});
-    test_assert(e3 != 0);
-    test_assert(ecs_has(world, e3, Position));
-
-    ecs_entity_t e4 = ecs_set(world, 0, Velocity, {3, 4});
-    test_assert(e4 != 0);
-    test_assert(ecs_has(world, e4, Velocity));
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_snapshot_t *s = ecs_snapshot_take_w_iter(&it);
-
-    ecs_delete(world, e3);
-    ecs_delete(world, e4);
-
-    test_assert(!ecs_is_alive(world, e3));
-    test_assert(!ecs_is_alive(world, e4));
-
-    ecs_snapshot_restore(world, s);
-
-    test_assert(ecs_is_alive(world, e1));
-    test_assert(ecs_is_alive(world, e2));
-    test_assert(ecs_is_alive(world, e3));
-    test_assert(!ecs_is_alive(world, e4));
-
-    test_assert(ecs_has(world, e1, Position));
-    test_assert(ecs_has(world, e2, Velocity));
-    test_assert(ecs_has(world, e3, Position));
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_free_empty(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-    test_assert(s != NULL);
-
-    ecs_snapshot_free(s);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_free(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    test_assert( ecs_new(world, Position) != 0);
-    test_assert( ecs_new(world, Velocity) != 0);
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-    test_assert(s != NULL);
-
-    ecs_snapshot_free(s);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_free_filtered(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    test_assert( ecs_new(world, Position) != 0);
-    test_assert( ecs_new(world, Velocity) != 0);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_snapshot_t *s = ecs_snapshot_take_w_iter(&it);
-    test_assert(s != NULL);
-
-    ecs_snapshot_free(s);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_free_filtered_w_dtor(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .name = "e1"
-    });
-
-    ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .name = "e2"
-    });
-
-    ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .name = "e3"
-    });
-
-    ecs_add(world, e1, Position);
-    ecs_add(world, e2, Position);
-    ecs_add(world, e3, Position);
-
-    ecs_add(world, e1, Velocity);
-    ecs_add(world, e2, Velocity);
-    ecs_add(world, e3, Velocity);
-
-    ecs_add(world, e3, Mass);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Position) }, { ecs_id(Velocity) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_snapshot_t *s = ecs_snapshot_take_w_iter(&it);
-    test_assert(s != NULL);
-
-    ecs_snapshot_free(s);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-static bool invoked = false;
-
-static
-void Dummy(ecs_iter_t *it) {
-    invoked = true;
-}
-
-void Snapshot_snapshot_activate_table_w_filter(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position);
-
-    ecs_entity_t e = ecs_set(world, 0, Position, {0, 0});
-    test_assert(e != 0);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_snapshot_t *s = ecs_snapshot_take_w_iter(&it);
-
-    ecs_snapshot_restore(world, s);
-
-    test_assert(ecs_has(world, e, Position));
-    
-    ecs_progress(world, 0);
-    test_bool(invoked, true);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_copy(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-    ecs_iter_t it = ecs_snapshot_iter(s);
-    ecs_snapshot_t *s_copy = ecs_snapshot_take_w_iter(&it);
-    ecs_snapshot_free(s);
-
-    Position *p = ecs_ensure(world, e, Position);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    p->x ++;
-    p->y ++;
-
-    ecs_snapshot_restore(world, s_copy);
-
-    test_assert(ecs_has(world, e, Position));
-    p = ecs_ensure(world, e, Position);
-    test_int(p->x, 10);
-    test_int(p->y, 20);    
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_get_ref_after_restore(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_ref_t ref = ecs_ref_init(world, e, Position);
-    const Position *p = ecs_ref_get(world, &ref, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    Position *p_mut = ecs_ensure(world, e, Position);
-    test_int(p_mut->x, 10);
-    test_int(p_mut->y, 20);
-
-    p_mut->x ++;
-    p_mut->y ++;
-
-    ecs_snapshot_restore(world, s);
-
-    test_assert(ecs_has(world, e, Position));
-    p = ecs_ref_get(world, &ref, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    ecs_fini(world);
-}
-
-void Snapshot_new_after_snapshot(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_snapshot_restore(world, s);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    test_assert(e2 != 0);
-    test_assert(ecs_has(world, e2, Position));
-
-    ecs_add(world, e2, Velocity);
-    test_assert(ecs_has(world, e2, Velocity));
-
-    ecs_fini(world);
-}
-
-void Snapshot_add_after_snapshot(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_snapshot_restore(world, s);
-
-    ecs_add(world, e, Velocity);
-    test_assert(ecs_has(world, e, Velocity));
-
-    ecs_fini(world);
-}
-
-void Snapshot_delete_after_snapshot(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_snapshot_restore(world, s);
-
-    ecs_delete(world, e);
-
-    test_assert(!ecs_is_alive(world, e));
-
-    ecs_fini(world);
-}
-
-void Snapshot_new_empty_after_snapshot(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_snapshot_restore(world, s);
-
-    ecs_entity_t e2 = ecs_new(world, 0);
-    test_assert(e2 != 0);
-
-    ecs_fini(world);
-}
-
-void Snapshot_set_after_snapshot(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_snapshot_restore(world, s);
-
-    ecs_entity_t e2 = ecs_new(world, 0);
-    test_assert(e2 != 0);
-
-    ecs_set_name(world, e2, "e2");
-    test_assert(ecs_has_pair(world, e2, ecs_id(EcsIdentifier), EcsName));
-    test_str(ecs_get_name(world, e2), "e2");
-
-    ecs_fini(world);
-}
-
-void Snapshot_restore_recycled(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_delete(world, e);
-
-    ecs_snapshot_restore(world, s);
-
-    ecs_entity_t e2 = ecs_new(world, 0);
-    test_assert(e2 != 0);
-    test_assert(e != e2);
-
-    ecs_fini(world);
-}
-
-static
-void SetP(ecs_iter_t *it) {
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        ecs_set_name(it->world, 0, "e2");
-    }
-}
-
-void Snapshot_snapshot_w_new_in_onset(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Position));
-
-    ECS_OBSERVER(world, SetP, EcsOnSet, Position);
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_snapshot_restore(world, s);
-
-    ecs_entity_t e2 = ecs_lookup(world, "e2");
-    test_assert(e2 != 0);
-
-    ecs_entity_t e3 = ecs_set_name(world, 0, "e3");
-    test_assert(e3 != 0);
-    test_assert(e3 > e2);
-    test_str(ecs_get_name(world, e3), "e3");
-
-    ecs_fini(world);
-}
-
-static ecs_entity_t v_entity = 0;
-
-static
-void CreateV(ecs_iter_t *it) {
-    ecs_entity_t ecs_id(Velocity) = ecs_field_id(it, 2);
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        v_entity = ecs_set(it->world, 0, Velocity, {3, 4});
-    }    
-}
-
-void Snapshot_snapshot_w_new_in_onset_in_snapshot_table(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Velocity, {1, 2});
-
-    ECS_OBSERVER(world, CreateV, EcsOnSet, Position, Velocity());
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    ecs_snapshot_restore(world, s);
-
-    const Velocity *v = ecs_get(world, e2, Velocity);
-    test_assert(v != NULL);
-    test_int(v->x, 1);
-    test_int(v->y, 2);
-
-    v = ecs_get(world, v_entity, Velocity);
-    test_assert(v != NULL);
-    test_int(v->x, 3);
-    test_int(v->y, 4);
-
-    ecs_fini(world);
-}
-
-void Snapshot_snapshot_from_stage(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {3, 4});
-
-    ecs_readonly_begin(world, false);
-
-    ecs_world_t *stage = ecs_get_stage(world, 0);
-
-    ecs_snapshot_t *s = ecs_snapshot_take(stage);
-
-    ecs_delete(stage, e1);
-    ecs_delete(stage, e2);
-
-    ecs_readonly_end(world);
-
-    test_assert(!ecs_is_alive(world, e1));
-    test_assert(!ecs_is_alive(world, e2));
-
-    ecs_snapshot_restore(world, s);
-
-    const Position *p = ecs_get(world, e1, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 1);
-    test_int(p->y, 2);
-
-    p = ecs_get(world, e2, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 3);
-    test_int(p->y, 4);
-
-    ecs_fini(world);
-}
diff --git a/test/addons/src/Stats.c b/test/addons/src/Stats.c
index ad45a9970..4aee806e0 100644
--- a/test/addons/src/Stats.c
+++ b/test/addons/src/Stats.c
@@ -196,7 +196,7 @@ void Stats_get_pipeline_stats_after_progress_2_systems_one_merge(void) {
 
     ECS_COMPONENT(world, Position);
     
-    ecs_new(world, Position); // Make sure systems are active
+    ecs_new_w(world, Position); // Make sure systems are active
 
     ECS_SYSTEM(world, FooSys, EcsOnUpdate, [out] Position());
     ECS_SYSTEM(world, BarSys, EcsOnUpdate, Position);
@@ -270,7 +270,7 @@ void Stats_get_entity_count(void) {
     float prev = count = stats.entities.count.gauge.avg[stats.t];
     test_assert(count != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_world_stats_get(world, &stats);
     count = stats.entities.count.gauge.avg[stats.t];
@@ -296,7 +296,7 @@ void Stats_get_not_alive_entity_count(void) {
     float prev = count = stats.entities.not_alive_count.gauge.avg[stats.t];
     test_int(count, 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     prev = count;
     ecs_world_stats_get(world, &stats);
diff --git a/test/addons/src/SystemCascade.c b/test/addons/src/SystemCascade.c
index ef59b9eae..8bc47a7c3 100644
--- a/test/addons/src/SystemCascade.c
+++ b/test/addons/src/SystemCascade.c
@@ -2,10 +2,10 @@
 
 static
 void Iter(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Position *p_parent = ecs_field(it, Position, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Position *p_parent = ecs_field(it, Position, 1);
 
-    test_assert(!p_parent || !ecs_field_is_self(it, 2));
+    test_assert(!p_parent || !ecs_field_is_self(it, 1));
 
     probe_iter(it);
 
@@ -31,10 +31,10 @@ void SystemCascade_cascade_depth_1(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(parent|cascade));
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(cascade));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
     ecs_set(world, e1, Position, {1, 2});
@@ -99,10 +99,10 @@ void SystemCascade_cascade_depth_2(void) {
     ECS_ENTITY(world, e5, Position);
     ECS_ENTITY(world, e6, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(parent|cascade));
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(cascade));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
     ecs_set(world, e1, Position, {1, 2});
@@ -180,10 +180,10 @@ void SystemCascade_cascade_depth_2_new_syntax(void) {
     ECS_ENTITY(world, e5, Position);
     ECS_ENTITY(world, e6, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(cascade(ChildOf)));
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(cascade ChildOf));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
     ecs_set(world, e1, Position, {1, 2});
@@ -251,10 +251,10 @@ void SystemCascade_cascade_depth_2_new_syntax(void) {
 
 static
 void AddParent(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Position *p_parent = ecs_field(it, Position, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Position *p_parent = ecs_field(it, Position, 1);
 
-    test_assert(!p_parent || !ecs_field_is_self(it, 2));
+    test_assert(!p_parent || !ecs_field_is_self(it, 1));
 
     probe_iter(it);
 
@@ -277,13 +277,13 @@ void SystemCascade_add_after_match(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, AddParent, EcsOnUpdate, Position, ?Position(parent|cascade));
+    ECS_SYSTEM(world, AddParent, EcsOnUpdate, Position, ?Position(cascade));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = AddParent,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_set(world, e1, Position, {1, 2});
     ecs_set(world, e2, Position, {1, 2});
     ecs_set(world, e3, Position, {1, 2});
@@ -298,7 +298,7 @@ void SystemCascade_add_after_match(void) {
     ecs_progress(world, 1);
 
     /* Before adding Position to parent, it wasn't being considered for the
-     * column(parent|cascade), so tables could have been ordered randomly. Make sure
+     * column(cascade), so tables could have been ordered randomly. Make sure
      * that queries can handle changes to depth after all tables are matched */
     ecs_set(world, parent, Position, {1, 2});
 
@@ -354,13 +354,13 @@ void SystemCascade_adopt_after_match(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, AddParent, EcsOnUpdate, Position, ?Position(parent|cascade));
+    ECS_SYSTEM(world, AddParent, EcsOnUpdate, Position, ?Position(cascade));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = AddParent,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_set(world, 0, Position, {1, 2});
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {1, 2}));
     ecs_set(world, e1, Position, {1, 2});
     ecs_set(world, e2, Position, {1, 2});
     ecs_set(world, e3, Position, {1, 2});
@@ -426,10 +426,10 @@ void SystemCascade_custom_relation_cascade_depth_1(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(cascade(Rel)));
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(cascade Rel));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
     ecs_set(world, e1, Position, {1, 2});
@@ -495,10 +495,10 @@ void SystemCascade_custom_relation_cascade_depth_2(void) {
     ECS_ENTITY(world, e5, Position);
     ECS_ENTITY(world, e6, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(cascade(Rel)));
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Position(cascade Rel));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
     ecs_set(world, e1, Position, {1, 2});
@@ -575,13 +575,13 @@ void SystemCascade_custom_relation_add_after_match(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, AddParent, EcsOnUpdate, Position, ?Position(cascade(Rel)));
+    ECS_SYSTEM(world, AddParent, EcsOnUpdate, Position, ?Position(cascade Rel));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = AddParent,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_set(world, e1, Position, {1, 2});
     ecs_set(world, e2, Position, {1, 2});
     ecs_set(world, e3, Position, {1, 2});
@@ -596,7 +596,7 @@ void SystemCascade_custom_relation_add_after_match(void) {
     ecs_progress(world, 1);
 
     /* Before adding Position to parent, it wasn't being considered for the
-     * column(parent|cascade), so tables could have been ordered randomly. Make sure
+     * column(cascade), so tables could have been ordered randomly. Make sure
      * that queries can handle changes to depth after all tables are matched */
     ecs_set(world, parent, Position, {1, 2});
 
@@ -653,13 +653,13 @@ void SystemCascade_custom_relation_adopt_after_match(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, AddParent, EcsOnUpdate, Position, ?Position(cascade(Rel)));
+    ECS_SYSTEM(world, AddParent, EcsOnUpdate, Position, ?Position(cascade Rel));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = AddParent,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_set(world, 0, Position, {1, 2});
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {1, 2}));
     ecs_set(world, e1, Position, {1, 2});
     ecs_set(world, e2, Position, {1, 2});
     ecs_set(world, e3, Position, {1, 2});
diff --git a/test/addons/src/SystemManual.c b/test/addons/src/SystemManual.c
index 96a8de258..00c6af1f1 100644
--- a/test/addons/src/SystemManual.c
+++ b/test/addons/src/SystemManual.c
@@ -6,16 +6,16 @@ void SystemManual_setup(void) {
 
 static
 void Iter(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     Velocity *v = NULL;
     Mass *m = NULL;
         
     if (it->field_count >= 2) {
-        v = ecs_field(it, Velocity, 2);
+        v = ecs_field(it, Velocity, 1);
     }
 
     if (it->field_count >= 3) {
-        m = ecs_field(it, Mass, 3);
+        m = ecs_field(it, Mass, 2);
     }
 
     probe_iter(it);
@@ -82,57 +82,10 @@ void SystemManual_1_type_1_component(void) {
     ecs_fini(world);
 }
 
-static int normal_count;
-
-static
-void NormalSystem(ecs_iter_t *it) {
-    normal_count ++;
-}
-
-static
-void AddVelocity(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        ecs_add(it->world, it->entities[i], Velocity);
-    }
-}
-
-void SystemManual_no_automerge(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ECS_SYSTEM(world, AddVelocity, 0, Position, Velocity());
-
-    ECS_ENTITY(world, e1, Position);
-
-    ecs_set_automerge(world, false);
-
-    ecs_readonly_begin(world, false);
-    ecs_world_t *stage = ecs_get_stage(world, 0);
-
-    ecs_run(stage, AddVelocity, 1, NULL);
-
-    test_assert(!ecs_has(stage, e1, Velocity));
-
-    ecs_readonly_end(world);
-
-    test_assert(!ecs_has(world, e1, Velocity));
-
-    ecs_merge(world);
-
-    test_assert(ecs_has(world, e1, Velocity));
-
-    ecs_fini(world);
-}
-
 static int dummy_ran = 0;
 
 void DummySystem(ecs_iter_t *it) {
-    ecs_entity_t Tag = ecs_field_id(it, 1);
+    ecs_entity_t Tag = ecs_field_id(it, 0);
     ecs_add_id(it->world, Tag, Tag);
     dummy_ran ++;
 }
diff --git a/test/addons/src/SystemMisc.c b/test/addons/src/SystemMisc.c
index 5fa50ade8..714e2c843 100644
--- a/test/addons/src/SystemMisc.c
+++ b/test/addons/src/SystemMisc.c
@@ -47,20 +47,6 @@ void SystemMisc_invalid_entity_without_id(void) {
     ecs_fini(world);
 }
 
-void SystemMisc_invalid_empty_without_id(void) {
-    install_test_abort();
-
-    ecs_world_t *world = ecs_init();
-
-    test_expect_abort();
-
-    ECS_SYSTEM(world, Dummy, EcsOnUpdate, $This);
-
-    test_assert(true);
-
-    ecs_fini(world);
-}
-
 void SystemMisc_invalid_empty_element(void) {
     install_test_abort();
 
@@ -205,7 +191,7 @@ void SystemMisc_invalid_null_string(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "Dummy", .add = {ecs_dependson(EcsOnUpdate)}}),
+        .entity = ecs_entity(world, { .name = "Dummy", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
         .callback = Dummy
     });
 
@@ -220,8 +206,8 @@ void SystemMisc_invalid_empty_string(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "Dummy", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "",
+        .entity = ecs_entity(world, { .name = "Dummy", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "",
         .callback = Dummy
     });
 
@@ -236,8 +222,8 @@ void SystemMisc_invalid_empty_string_w_space(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "Dummy", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "  ",
+        .entity = ecs_entity(world, { .name = "Dummy", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "  ",
         .callback = Dummy
     });
 
@@ -329,11 +315,11 @@ void SystemMisc_system_w_or_disabled_and_prefab(void) {
 
 static
 void TableColumns(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     const ecs_type_t *type = ecs_table_get_type(it->table);
     test_int(2, type->count);
@@ -357,7 +343,7 @@ void SystemMisc_table_columns_access(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Position);
     ecs_add(world, e, Velocity);
 
@@ -379,7 +365,7 @@ void SystemMisc_dont_enable_after_rematch(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position(self|up), Velocity(self|up));
+    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position(self|up IsA), Velocity(self|up IsA));
 
     /* Create an entity that is watched. Whenever components are added/removed
      * to and/or from watched entities, a rematch is triggered. */
@@ -419,7 +405,7 @@ void SystemMisc_dont_enable_after_rematch(void) {
 
 static void SysA(ecs_iter_t *it)
 {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
     ecs_add(it->world, it->entities[0], Velocity);
 }
 
@@ -450,41 +436,6 @@ void SystemMisc_ensure_single_merge(void) {
     ecs_fini(world);
 }
 
-static int test_table_count_invoked;
-
-static void TestTableCount(ecs_iter_t *it) {
-    test_int(it->table_count, 2);
-
-    test_table_count_invoked ++;
-}
-
-void SystemMisc_table_count(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ECS_SYSTEM(world, TestTableCount, EcsOnUpdate, Position);
-
-    // Create two active tables
-    ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add(world, e2, Velocity);
-
-    // Create one inactive table
-    ecs_entity_t e3 = ecs_new(world, Position);
-    ecs_add(world, e3, Velocity);
-    ecs_add(world, e3, Mass);
-    ecs_delete(world, e3);
-
-    ecs_progress(world, 0);
-
-    test_int(test_table_count_invoked, 2);
-
-    ecs_fini(world);
-}
-
 void SystemMisc_match_system(void) {
     ecs_world_t *world = ecs_init();
 
@@ -527,7 +478,7 @@ void SystemMisc_add_own_component(void) {
     ECS_SYSTEM(world, FooSystem, 0, Position);
     ECS_SYSTEM(world, BarSystem, 0, Position);
 
-    ecs_set_ptr(world, BarSystem, Position, NULL);
+    ecs_set(world, BarSystem, Position, {0, 0});
 
     /* Make sure code didn't assert */
     test_assert(true);
@@ -554,12 +505,12 @@ void SystemMisc_change_system_action(void) {
     ECS_COMPONENT(world, Position);
     
     ecs_entity_t sys = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "Sys", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "Position",
+        .entity = ecs_entity(world, { .name = "Sys", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "Position",
         .callback = ActionA
     });
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     test_bool(action_a_invoked, false);
     test_bool(action_b_invoked, false);
@@ -594,7 +545,7 @@ void SystemMisc_system_readeactivate(void) {
     /* No entities, system should be deactivated */
     test_assert( ecs_has_id(world, Dummy, EcsEmpty));
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_run_aperiodic(world, 0);
 
     /* System should be active, one entity is matched */
@@ -634,8 +585,8 @@ void SystemMisc_system_readeactivate_w_2_systems(void) {
     test_assert( ecs_has_id(world, Dummy1, EcsEmpty));
     test_assert( ecs_has_id(world, Dummy2, EcsEmpty));
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_new(world, Mass);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_new_w(world, Mass);
     ecs_run_aperiodic(world, 0);
 
     /* Systems should be active, one entity is matched */
@@ -667,7 +618,7 @@ void SystemMisc_add_to_system_in_progress(void) {
 
     ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_defer_begin(world);
 
@@ -688,14 +639,14 @@ void SystemMisc_redefine_null_signature(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t s_1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "System", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = NULL,
+        .entity = ecs_entity(world, { .name = "System", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = NULL,
         .callback = Action
     });
 
     ecs_entity_t s_2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "System", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = NULL,
+        .entity = ecs_entity(world, { .name = "System", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = NULL,
         .callback = Action
     });      
 
@@ -708,14 +659,14 @@ void SystemMisc_redefine_0_signature(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t s_1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "System", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "0",
+        .entity = ecs_entity(world, { .name = "System", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "0",
         .callback = Action
     });
 
     ecs_entity_t s_2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .name = "System", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "0",
+        .entity = ecs_entity(world, { .name = "System", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "0",
         .callback = Action
     }); 
 
@@ -724,82 +675,6 @@ void SystemMisc_redefine_0_signature(void) {
     ecs_fini(world);
 }
 
-void SystemMisc_one_named_column_of_two(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f, .terms = {
-        { ecs_id(Position), .name = "pos" },
-        { ecs_id(Velocity) }
-    }}));
-
-    test_int(f.term_count, 2);
-    test_int(f.field_count, 2);
-
-    ecs_term_t *
-    term = &f.terms[0];
-    test_assert(term->oper == EcsAnd);
-    test_assert(term->src.flags == (EcsSelf|EcsUp|EcsIsVariable));
-    test_assert(term->src.id == EcsThis);
-    test_assert(term->inout == EcsInOutDefault);
-    test_assert(term->id == ecs_id(Position));
-    test_str(term->name, "pos");
-
-    term = &f.terms[1];
-    test_assert(term->oper == EcsAnd);
-    test_assert(term->src.flags == (EcsSelf|EcsUp|EcsIsVariable));
-    test_assert(term->src.id == EcsThis);
-    test_assert(term->inout == EcsInOutDefault);
-    test_assert(term->id == ecs_id(Velocity));
-    test_str(term->name, NULL);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void SystemMisc_two_named_columns_of_two(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f, .terms = {
-        { ecs_id(Position), .name = "pos" },
-        { ecs_id(Velocity), .name = "vel" }
-    }}));    
-
-    test_int(f.term_count, 2);
-    test_int(f.field_count, 2);
-
-    ecs_term_t *
-    term = &f.terms[0];
-    test_assert(term->oper == EcsAnd);
-    test_assert(term->src.flags == (EcsSelf|EcsUp|EcsIsVariable));
-    test_assert(term->src.id == EcsThis);
-    test_assert(term->inout == EcsInOutDefault);
-    test_assert(term->id == ecs_id(Position));
-    test_str(term->name, "pos");
-
-    term = &f.terms[1];
-    test_assert(term->oper == EcsAnd);
-    test_assert(term->src.flags == (EcsSelf|EcsUp|EcsIsVariable));
-    test_assert(term->src.id == EcsThis);
-    test_assert(term->inout == EcsInOutDefault);
-    test_assert(term->id == ecs_id(Velocity));
-    test_str(term->name, "vel");
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
 void SystemMisc_redeclare_system_explicit_id(void) {
     ecs_world_t *world = ecs_init();
 
@@ -807,14 +682,14 @@ void SystemMisc_redeclare_system_explicit_id(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}), 
-        .query.filter.expr = "Position, Velocity", 
+        .entity = ecs_entity(world, {.name = "Move", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}), 
+        .query.expr = "Position, Velocity", 
         .callback = Dummy
     });
 
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = s1, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "Position, Velocity", 
+        .entity = ecs_entity(world, {.id = s1, .name = "Move", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "Position, Velocity", 
         .callback = Dummy
     });
 
@@ -830,14 +705,14 @@ void SystemMisc_redeclare_system_explicit_id_null_expr(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}), 
-        .query.filter.expr = NULL, 
+        .entity = ecs_entity(world, {.name = "Move", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}), 
+        .query.expr = NULL, 
         .callback = Dummy
     });
 
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = s1, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = NULL, 
+        .entity = ecs_entity(world, {.id = s1, .name = "Move", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = NULL, 
         .callback = Dummy
     });
 
@@ -853,14 +728,14 @@ void SystemMisc_redeclare_system_explicit_id_no_name(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}), 
-        .query.filter.expr = "Position, Velocity", 
+        .entity = ecs_entity(world, {.name = "Move", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}), 
+        .query.expr = "Position, Velocity", 
         .callback = Dummy
     });
 
     ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = s1, .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "Position, Velocity", 
+        .entity = ecs_entity(world, {.id = s1, .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "Position, Velocity", 
         .callback = Dummy
     });
 
@@ -875,12 +750,12 @@ void SystemMisc_declare_different_id_same_name(void) {
 
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_entity_t s_1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = e1, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "0", 
+        .entity = ecs_entity(world, {.id = e1, .name = "Move", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "0", 
         .callback = Dummy
     });
     test_assert(e1 == s_1);
@@ -888,8 +763,8 @@ void SystemMisc_declare_different_id_same_name(void) {
     test_expect_abort();
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = e2, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "0", 
+        .entity = ecs_entity(world, {.id = e2, .name = "Move", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "0", 
         .callback = Dummy
     });
 }
@@ -899,15 +774,15 @@ void SystemMisc_declare_different_id_same_name_w_scope(void) {
     
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t scope = ecs_new(world, 0);
+    ecs_entity_t scope = ecs_new(world);
     ecs_set_scope(world, scope);
 
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_entity_t s_1 = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = e1, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "0", 
+        .entity = ecs_entity(world, {.id = e1, .name = "Move", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "0", 
         .callback = Dummy
     });
     test_assert(e1 == s_1);
@@ -915,8 +790,8 @@ void SystemMisc_declare_different_id_same_name_w_scope(void) {
     test_expect_abort();
 
     ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.id = e2, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.expr = "0", 
+        .entity = ecs_entity(world, {.id = e2, .name = "Move", .add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.expr = "0", 
         .callback = Dummy
     });
 }
@@ -927,17 +802,19 @@ void SystemMisc_rw_in_implicit_any(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity(self|up)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Velocity(self|up)" });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_query_next(&it) == true);
+    test_assert(ecs_field_is_readonly(&it, 0) == false);
     test_assert(ecs_field_is_readonly(&it, 1) == false);
-    test_assert(ecs_field_is_readonly(&it, 2) == false);
     test_assert(ecs_query_next(&it) == false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -947,18 +824,20 @@ void SystemMisc_rw_in_implicit_shared(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity(up)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Velocity(up IsA)" });
 
-    ecs_entity_t base = ecs_new(world, Velocity);
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t base = ecs_new_w(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add_pair(world, e, EcsIsA, base);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_query_next(&it) == true);
-    test_assert(ecs_field_is_readonly(&it, 1) == false);
-    test_assert(ecs_field_is_readonly(&it, 2) == true);
+    test_assert(ecs_field_is_readonly(&it, 0) == false);
+    test_assert(ecs_field_is_readonly(&it, 1) == true);
     test_assert(ecs_query_next(&it) == false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -968,17 +847,19 @@ void SystemMisc_rw_in_implicit_from_empty(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity()");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Velocity()" });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_query_next(&it) == true);
-    test_assert(ecs_field_is_readonly(&it, 1) == false);
-    test_assert(ecs_field_is_readonly(&it, 2) == true);
+    test_assert(ecs_field_is_readonly(&it, 0) == false);
+    test_assert(ecs_field_is_readonly(&it, 1) == true);
     test_assert(ecs_query_next(&it) == false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -989,17 +870,19 @@ void SystemMisc_rw_in_implicit_from_entity(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_ENTITY(world, f, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity(f)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Velocity(f)" });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_query_next(&it) == true);
-    test_assert(ecs_field_is_readonly(&it, 1) == false);
-    test_assert(ecs_field_is_readonly(&it, 2) == true);
+    test_assert(ecs_field_is_readonly(&it, 0) == false);
+    test_assert(ecs_field_is_readonly(&it, 1) == true);
     test_assert(ecs_query_next(&it) == false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1009,17 +892,19 @@ void SystemMisc_rw_out_explicit_any(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, [out] Velocity(self|up)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, [out] Velocity(self|up IsA)" });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_query_next(&it) == true);
+    test_assert(ecs_field_is_readonly(&it, 0) == false);
     test_assert(ecs_field_is_readonly(&it, 1) == false);
-    test_assert(ecs_field_is_readonly(&it, 2) == false);
     test_assert(ecs_query_next(&it) == false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1029,18 +914,20 @@ void SystemMisc_rw_out_explicit_shared(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, [out] Velocity(up)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, [out] Velocity(up IsA)" });
 
-    ecs_entity_t base = ecs_new(world, Velocity);
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t base = ecs_new_w(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add_pair(world, e, EcsIsA, base);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_query_next(&it) == true);
+    test_assert(ecs_field_is_readonly(&it, 0) == false);
     test_assert(ecs_field_is_readonly(&it, 1) == false);
-    test_assert(ecs_field_is_readonly(&it, 2) == false);
     test_assert(ecs_query_next(&it) == false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1050,17 +937,19 @@ void SystemMisc_rw_out_explicit_from_empty(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, [out] Velocity()");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, [out] Velocity()" });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_query_next(&it) == true);
+    test_assert(ecs_field_is_readonly(&it, 0) == false);
     test_assert(ecs_field_is_readonly(&it, 1) == false);
-    test_assert(ecs_field_is_readonly(&it, 2) == false);
     test_assert(ecs_query_next(&it) == false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1071,17 +960,19 @@ void SystemMisc_rw_out_explicit_from_entity(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_ENTITY(world, f, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, [out] Velocity(f)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, [out] Velocity(f)" });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_query_next(&it) == true);
+    test_assert(ecs_field_is_readonly(&it, 0) == false);
     test_assert(ecs_field_is_readonly(&it, 1) == false);
-    test_assert(ecs_field_is_readonly(&it, 2) == false);
     test_assert(ecs_query_next(&it) == false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1123,9 +1014,9 @@ void SystemMisc_get_query(void) {
 
     ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position);
 
-    ecs_set(world, 0, Position, {0, 0});
-    ecs_set(world, 0, Position, {1, 0});
-    ecs_set(world, 0, Position, {2, 0});
+    ecs_insert(world, ecs_value(Position, {0, 0}));
+    ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_insert(world, ecs_value(Position, {2, 0}));
 
     ecs_query_t *q = ecs_system_get_query(world, Dummy);
     test_assert(q != NULL);
@@ -1134,7 +1025,7 @@ void SystemMisc_get_query(void) {
 
     ecs_iter_t it = ecs_query_iter(world, q);
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
         test_assert(p != NULL);
 
         int i;
@@ -1146,6 +1037,8 @@ void SystemMisc_get_query(void) {
 
     test_int(count, 3);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1158,7 +1051,7 @@ void SystemMisc_set_get_context(void) {
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
         .entity = ecs_entity(world, {.name = "MySystem"}),
-        .query.filter.terms = {{Tag}},
+        .query.terms = {{Tag}},
         .callback = Dummy,
         .ctx = &ctx_a
     });
@@ -1185,7 +1078,7 @@ void SystemMisc_set_get_binding_context(void) {
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
         .entity = ecs_entity(world, {.name = "MySystem"}),
-        .query.filter.terms = {{Tag}},
+        .query.terms = {{Tag}},
         .callback = Dummy,
         .binding_ctx = &ctx_a
     });
@@ -1236,14 +1129,14 @@ void SystemMisc_delete_system(void) {
     Probe ctx = {0};
     ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
         .entity = ecs_entity(world, {.name = "Foo"}),
-        .query.filter.terms = {{.id = Tag}},
+        .query.terms = {{.id = Tag}},
         .callback = Dummy
     });
     test_assert(system != 0);
 
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, Tag);
 
     ecs_run(world, system, 0, NULL);
@@ -1265,28 +1158,28 @@ void SystemMisc_delete_pipeline_system(void) {
 
     // Create system before
     test_assert(ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.terms = {{.id = Tag}},
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.terms = {{.id = Tag}},
         .callback = Dummy
     }) != 0);
 
     ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.terms = {{.id = Tag}},
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.terms = {{.id = Tag}},
         .callback = Dummy
     });
     test_assert(system != 0);
 
     // Create system after
     test_assert(ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.terms = {{.id = Tag}},
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.terms = {{.id = Tag}},
         .callback = Dummy
     }) != 0);
 
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, Tag);
 
     ecs_progress(world, 0);
@@ -1337,7 +1230,7 @@ void SystemMisc_delete_system_w_ctx(void) {
 
     Probe ctx = {0};
     ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
-        .query.filter.terms = {{.id = Tag}},
+        .query.terms = {{.id = Tag}},
         .callback = Dummy,
         .ctx = &ctx_value,
         .ctx_free = ctx_free,
@@ -1352,7 +1245,7 @@ void SystemMisc_delete_system_w_ctx(void) {
 
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, Tag);
 
     ecs_run(world, system, 0, NULL);
@@ -1371,7 +1264,7 @@ void SystemMisc_update_ctx(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
-        .query.filter.terms = {{.id = Tag}},
+        .query.terms = {{.id = Tag}},
         .callback = Dummy,
         .ctx = &ctx_value,
         .ctx_free = ctx_free,
@@ -1457,16 +1350,16 @@ void SystemMisc_run_custom_run_action(void) {
 
     Probe ctx = {0};
     ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
-        .query.filter.terms = {{ .id = TagA }},
+        .query.terms = {{ .id = TagA }},
         .run = Run,
         .callback = Dummy,
         .ctx = &ctx,
     });
     test_assert(system != 0);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
     ecs_add(world, e3, TagB); // 2 tables
 
     ecs_run(world, system, 0, NULL);
@@ -1483,38 +1376,6 @@ void SystemMisc_run_custom_run_action(void) {
     ecs_fini(world);
 }
 
-void SystemMisc_run_w_offset_limit_custom_run_action(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    Probe ctx = {0};
-    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
-        .query.filter.terms = {{ .id = TagA }},
-        .run = Run,
-        .callback = Dummy,
-        .ctx = &ctx,
-    });
-    test_assert(system != 0);
-
-    ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add(world, e3, TagB); // 2 tables
-
-    ecs_run_w_filter(world, system, 0, 1, 1, NULL);
-
-    test_bool(dummy_invoked, false);
-    test_int(run_invoked, 1);
-
-    test_int(ctx.invoked, 1);
-    test_int(ctx.count, 1);
-    test_int(ctx.e[0], e2);
-
-    ecs_fini(world);
-}
-
 void SystemMisc_pipeline_custom_run_action(void) {
     ecs_world_t *world = ecs_init();
 
@@ -1523,17 +1384,17 @@ void SystemMisc_pipeline_custom_run_action(void) {
 
     Probe ctx = {0};
     ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
-        .query.filter.terms = {{ .id = TagA }},
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
+        .query.terms = {{ .id = TagA }},
         .run = Run,
         .callback = Dummy,
         .ctx = &ctx
     });
     test_assert(system != 0);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
     ecs_add(world, e3, TagB); // 2 tables
 
     ecs_progress(world, 0);
@@ -1558,14 +1419,14 @@ void SystemMisc_change_custom_run_action(void) {
 
     Probe ctx = {0};
     ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
-        .query.filter.terms = {{ .id = TagA }},
+        .query.terms = {{ .id = TagA }},
         .run = Run,
         .callback = Dummy,
         .ctx = &ctx,
     });
     test_assert(system != 0);
 
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
 
     ecs_run(world, system, 0, NULL);
     test_bool(dummy_invoked, false);
@@ -1593,17 +1454,17 @@ void SystemMisc_custom_run_action_call_next(void) {
 
     Probe ctx = {0};
     ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
-        .query.filter.terms = {{ .id = TagA }},
+        .query.terms = {{ .id = TagA }},
         .run = Run_call_callback,
         .callback = Dummy,
         .ctx = &ctx,
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}})
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))})
     });
     test_assert(system != 0);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
     ecs_add(world, e3, TagB); // 2 tables
 
     ecs_progress(world, 0);
@@ -1627,14 +1488,14 @@ void SystemMisc_system_w_short_notation(void) {
 
     Probe ctx = {0};
     ecs_entity_t system = ecs_system(world, {
-        .query.filter.terms = {{ .id = Tag }},
+        .query.terms = {{ .id = Tag }},
         .callback = Dummy,
         .ctx = &ctx,
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}})
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))})
     });
     test_assert(system != 0);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     ecs_progress(world, 0);
 
@@ -1690,7 +1551,7 @@ void SystemMisc_system_w_interval_rate_stop_timer(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t system = ecs_system(world, {
-        .entity = ecs_entity(world, { .add = {ecs_dependson(EcsOnUpdate)} }),
+        .entity = ecs_entity(world, { .add = ecs_ids(ecs_dependson(EcsOnUpdate)) }),
         .interval = 1.0,
         .rate = 3.0,
         .callback = Dummy
@@ -1748,19 +1609,19 @@ void SystemMisc_system_same_interval_same_tick(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = {ecs_dependson(EcsOnUpdate)} }),
+        .entity = ecs_entity(world, { .add = ecs_ids(ecs_dependson(EcsOnUpdate)) }),
         .interval = 1.0,
         .callback = SA
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = {ecs_dependson(EcsOnUpdate)} }),
+        .entity = ecs_entity(world, { .add = ecs_ids(ecs_dependson(EcsOnUpdate)) }),
         .interval = 1.0,
         .callback = SB
     });
 
     ecs_system(world, {
-        .entity = ecs_entity(world, { .add = {ecs_dependson(EcsOnUpdate)} }),
+        .entity = ecs_entity(world, { .add = ecs_ids(ecs_dependson(EcsOnUpdate)) }),
         .interval = 1.0,
         .callback = SC
     });
@@ -1776,3 +1637,26 @@ void SystemMisc_system_same_interval_same_tick(void) {
 
     ecs_fini(world);
 }
+
+void SystemMisc_system_no_id_in_scope(void) {
+    ecs_world_t* world = ecs_mini();
+    
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t parent = ecs_new(world);
+
+    ecs_set_scope(world, parent);
+
+    ecs_entity_t s = ecs_system(world, {
+        .query.terms = {
+            { .id = TagA },
+        },
+        .callback = SA
+    });
+
+    ecs_set_scope(world, 0);
+
+    test_assert(ecs_has_pair(world, s, EcsChildOf, parent));
+
+    ecs_fini(world);
+}
diff --git a/test/addons/src/SystemPeriodic.c b/test/addons/src/SystemPeriodic.c
index 949c74f75..167597a6d 100644
--- a/test/addons/src/SystemPeriodic.c
+++ b/test/addons/src/SystemPeriodic.c
@@ -2,19 +2,19 @@
 
 static
 void Iter(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     Velocity *v = NULL;
     Mass *m = NULL;
 
     if (it->field_count >= 2) {
-        if (ecs_field_size(it, 2) == sizeof(Velocity)) {
-            v = ecs_field(it, Velocity, 2);
+        if (ecs_field_size(it, 1) == sizeof(Velocity)) {
+            v = ecs_field(it, Velocity, 1);
         }
     }
 
     if (it->field_count >= 3) {
-        if (ecs_field_size(it, 3) == sizeof(Mass)) {
-            m = ecs_field(it, Mass, 3);
+        if (ecs_field_size(it, 2) == sizeof(Mass)) {
+            m = ecs_field(it, Mass, 2);
         }
     }
 
@@ -560,11 +560,11 @@ void SystemPeriodic_4_type_1_and_1_or(void) {
     ECS_ENTITY(world, e3, Position, Position_1, Velocity);
     ECS_ENTITY(world, e4, Velocity);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position || Position_1, Velocity);
-
     ecs_set(world, e3, Position_1, {0, 0});
     ecs_set(world, e4, Velocity, {0, 0});
 
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position || Position_1, Velocity);
+
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
@@ -577,18 +577,18 @@ void SystemPeriodic_4_type_1_and_1_or(void) {
     test_null(ctx.param);
 
     test_int(ctx.e[0], e1);
-    test_int(ctx.e[1], e2);
-    test_int(ctx.e[2], e3);
+    test_int(ctx.e[1], e3);
+    test_int(ctx.e[2], e2);
 
     test_int(ctx.c[0][0], ecs_id(Position));
     test_int(ctx.s[0][0], 0);
     test_int(ctx.c[0][1], ecs_id(Velocity));
     test_int(ctx.s[0][1], 0);
-    test_int(ctx.c[1][0], ecs_id(Position_1));
+    test_int(ctx.c[1][0], ecs_id(Position));
     test_int(ctx.s[1][0], 0);
     test_int(ctx.c[1][1], ecs_id(Velocity));
     test_int(ctx.s[1][1], 0);
-    test_int(ctx.c[2][0], ecs_id(Position));
+    test_int(ctx.c[2][0], ecs_id(Position_1));
     test_int(ctx.s[2][0], 0);
     test_int(ctx.c[2][1], ecs_id(Velocity));
     test_int(ctx.s[2][1], 0);
@@ -626,18 +626,18 @@ void SystemPeriodic_4_type_1_and_1_or_of_3(void) {
     test_null(ctx.param);
 
     test_int(ctx.e[0], e1);
-    test_int(ctx.e[1], e2);
-    test_int(ctx.e[2], e3);
+    test_int(ctx.e[1], e3);
+    test_int(ctx.e[2], e2);
 
     test_int(ctx.c[0][0], ecs_id(Position));
     test_int(ctx.s[0][0], 0);
     test_int(ctx.c[0][1], ecs_id(Velocity));
     test_int(ctx.s[0][1], 0);
-    test_int(ctx.c[1][0], ecs_id(Position_2));
+    test_int(ctx.c[1][0], ecs_id(Position_1));
     test_int(ctx.s[1][0], 0);
     test_int(ctx.c[1][1], ecs_id(Velocity));
     test_int(ctx.s[1][1], 0);
-    test_int(ctx.c[2][0], ecs_id(Position_1));
+    test_int(ctx.c[2][0], ecs_id(Position_2));
     test_int(ctx.s[2][0], 0);
     test_int(ctx.c[2][1], ecs_id(Velocity));
     test_int(ctx.s[2][1], 0);
@@ -972,8 +972,8 @@ void SystemPeriodic_match_2_systems_w_populated_table(void) {
 }
 
 void TestOptional_w_column(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     test_assert(p != NULL);
     test_assert(v == NULL);
@@ -982,8 +982,8 @@ void TestOptional_w_column(ecs_iter_t *it) {
 }
 
 void TestOptional_w_shared(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     test_assert(p != NULL);
     test_assert(v == NULL);
@@ -1027,7 +1027,7 @@ void SystemPeriodic_ensure_optional_is_null_shared(void) {
 
     ECS_ENTITY(world, e, Position);
 
-    ECS_SYSTEM(world, TestOptional_w_shared, EcsOnUpdate, Position, ?Velocity(parent));
+    ECS_SYSTEM(world, TestOptional_w_shared, EcsOnUpdate, Position, ?Velocity(up));
     
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
@@ -1236,11 +1236,11 @@ void SystemPeriodic_disabled_nested_feature(void) {
 }
 
 void TwoRefs(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
+    test_assert(!ecs_field_is_self(it, 0));
     test_assert(!ecs_field_is_self(it, 1));
-    test_assert(!ecs_field_is_self(it, 2));
 
     (void)p;
     (void)v;
@@ -1419,7 +1419,7 @@ void SystemPeriodic_match_prefab_and_normal(void) {
 
 static
 void TestIsSharedOnNotSet(ecs_iter_t *it) {
-    test_assert(ecs_field_is_self(it, 2) != false);
+    test_assert(ecs_field_is_self(it, 1) != false);
 }
 
 void SystemPeriodic_is_shared_on_column_not_set(void) {
@@ -1548,7 +1548,7 @@ void SystemPeriodic_shared_column(void) {
     ECS_ENTITY(world, e2, Position, (IsA, base));
     ECS_ENTITY(world, e3, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, Velocity(up));
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, Velocity(up IsA));
 
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
@@ -1577,7 +1577,7 @@ void SystemPeriodic_shared_not_column(void) {
     ECS_ENTITY(world, e1, Position, Velocity);
     ECS_ENTITY(world, e2, Position, (IsA, base));
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, !Velocity(up));
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, !Velocity(up IsA));
 
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
@@ -1614,7 +1614,7 @@ void SystemPeriodic_shared_or_column(void) {
     ECS_ENTITY(world, e3, Position, (IsA, base1));
     ECS_ENTITY(world, e4, Position, (IsA, base2));
 
-    ECS_SYSTEM(world, SharedOr, EcsOnUpdate, Position, Velocity(up) || Mass(up));
+    ECS_SYSTEM(world, SharedOr, EcsOnUpdate, Position, Velocity(up IsA) || Mass(up IsA));
 
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
@@ -1648,7 +1648,7 @@ void SystemPeriodic_container_dont_match_inheritance(void) {
     ECS_ENTITY(world, e1, Position, (IsA, base));
     ECS_ENTITY(world, e2, Position, (ChildOf, base));
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, Velocity(parent));
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, Velocity(up));
 
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
@@ -1677,7 +1677,7 @@ void SystemPeriodic_cascade_dont_match_inheritance(void) {
     ECS_ENTITY(world, e1, Position, (IsA, base));
     ECS_ENTITY(world, e2, Position, (ChildOf, base));
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Velocity(parent|cascade));
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Position, ?Velocity(cascade));
 
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
@@ -1792,7 +1792,7 @@ void SystemPeriodic_owned_only(void) {
 
     ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position(self));
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_progress(world, 0);
 
@@ -1805,7 +1805,7 @@ static void AssertReadonly(ecs_iter_t *it) {
     test_assert(dummy_invoked == 0);
     dummy_invoked = it->entities[0];
 
-    test_assert( ecs_field_is_readonly(it, 1) == true);
+    test_assert( ecs_field_is_readonly(it, 0) == true);
 }
 
 void SystemPeriodic_shared_only(void) {
@@ -1813,9 +1813,9 @@ void SystemPeriodic_shared_only(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ECS_SYSTEM(world, AssertReadonly, EcsOnUpdate, Position(up));
+    ECS_SYSTEM(world, AssertReadonly, EcsOnUpdate, Position(up IsA));
 
-    ecs_entity_t base = ecs_new(world, Position);
+    ecs_entity_t base = ecs_new_w(world, Position);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
 
     ecs_progress(world, 0);
@@ -1832,7 +1832,7 @@ void SystemPeriodic_is_in_readonly(void) {
 
     ECS_SYSTEM(world, AssertReadonly, EcsOnUpdate, [in] Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_progress(world, 0);
 
@@ -1868,8 +1868,8 @@ void SystemPeriodic_and_type(void) {
 
     ECS_SYSTEM(world, TypeSystem, EcsOnUpdate, AND | MyType);
 
-    ecs_new(world, Position);
-    ecs_new(world, Velocity);
+    ecs_new_w(world, Position);
+    ecs_new_w(world, Velocity);
     ECS_ENTITY(world, e, Position, Velocity);
 
     Probe ctx = {0};
@@ -1899,9 +1899,9 @@ void SystemPeriodic_or_type(void) {
 
     ECS_SYSTEM(world, TypeSystem, EcsOnUpdate, OR | MyType);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Velocity);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Velocity);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     ecs_add(world, e3, Velocity);
 
     Probe ctx = {0};
@@ -1918,9 +1918,9 @@ void SystemPeriodic_or_type(void) {
     test_int(ctx.e[0], e1);
     test_int(ctx.e[1], e2);
     test_int(ctx.e[2], e3);
-    test_int(ctx.c[0][0], ecs_id(Position));
-    test_int(ctx.c[1][0], ecs_id(Velocity));
-    test_int(ctx.c[2][0], ecs_id(Position));
+    test_int(ctx.c[0][0], MyType);
+    test_int(ctx.c[1][0], MyType);
+    test_int(ctx.c[2][0], MyType);
     test_int(ctx.s[0][0], 0);
 
     ecs_fini(world);
diff --git a/test/addons/src/System_w_Empty.c b/test/addons/src/System_w_Empty.c
index 75d0e80c1..14ff943a9 100644
--- a/test/addons/src/System_w_Empty.c
+++ b/test/addons/src/System_w_Empty.c
@@ -2,7 +2,7 @@
 
 static
 void Iter(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     probe_iter(it);
 
@@ -24,7 +24,7 @@ void System_w_Empty_2_column_1_from_id(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_progress(world, 1);
     
@@ -55,7 +55,7 @@ void System_w_Empty_3_column_2_from_id(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_progress(world, 1);
     
@@ -78,9 +78,9 @@ void System_w_Empty_3_column_2_from_id(void) {
 
 static
 void CheckColumnType(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
 
-    test_assert(ecs_id(Position) == ecs_field_id(it, 1));
+    test_assert(ecs_id(Position) == ecs_field_id(it, 0));
 
     probe_iter(it);
 }
@@ -97,7 +97,7 @@ void System_w_Empty_column_type(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_progress(world, 1);
 
diff --git a/test/addons/src/System_w_FromEntity.c b/test/addons/src/System_w_FromEntity.c
index 8e300612c..66bd048d3 100644
--- a/test/addons/src/System_w_FromEntity.c
+++ b/test/addons/src/System_w_FromEntity.c
@@ -2,20 +2,20 @@
 
 static
 void Iter(ecs_iter_t *it) {
-    Mass *m_ptr = ecs_field(it, Mass, 1);
+    Mass *m_ptr = ecs_field(it, Mass, 0);
 
     Position *p = NULL;
     Velocity *v = NULL;
 
     if (it->field_count >= 2) {
-        p = ecs_field(it, Position, 2);
+        p = ecs_field(it, Position, 1);
     }
 
     if (it->field_count >= 3) {
-        v = ecs_field(it, Velocity, 3);
+        v = ecs_field(it, Velocity, 2);
     }
 
-    test_assert(!m_ptr || !ecs_field_is_self(it, 1));
+    test_assert(!m_ptr || !ecs_field_is_self(it, 0));
 
     probe_iter(it);
 
@@ -88,8 +88,8 @@ void dummy_reset(void) {
 static
 void Dummy(ecs_iter_t *it) {
     dummy_invoked = 1;
-    dummy_component = ecs_field_id(it, 1);
-    dummy_source = ecs_field_src(it, 1);
+    dummy_component = ecs_field_id(it, 0);
+    dummy_source = ecs_field_src(it, 0);
 }
 
 void System_w_FromEntity_task_from_entity(void) {
diff --git a/test/addons/src/System_w_FromParent.c b/test/addons/src/System_w_FromParent.c
index 02b80e0d6..41de4f4d4 100644
--- a/test/addons/src/System_w_FromParent.c
+++ b/test/addons/src/System_w_FromParent.c
@@ -6,22 +6,22 @@ void System_w_FromParent_setup(void) {
 
 static
 void Iter(ecs_iter_t *it) {
-    Mass *m_ptr = ecs_field(it, Mass, 1);
+    Mass *m_ptr = ecs_field(it, Mass, 0);
     bool shared = false;
     
     if (m_ptr) {
-        shared = !ecs_field_is_self(it, 1);
+        shared = !ecs_field_is_self(it, 0);
     }
 
     Position *p = NULL;
     Velocity *v = NULL;
 
     if (it->field_count >= 2) {
-        p = ecs_field(it, Position, 2);
+        p = ecs_field(it, Position, 1);
     }
 
     if (it->field_count >= 3) {
-        v = ecs_field(it, Velocity, 3);
+        v = ecs_field(it, Velocity, 2);
     }
 
     probe_iter(it);
@@ -58,13 +58,13 @@ void System_w_FromParent_1_column_from_container(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_set(world, 0, Mass, {2});
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Mass, {2}));
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
     ecs_add_pair(world, e3, EcsChildOf, parent);
@@ -118,13 +118,13 @@ void System_w_FromParent_2_column_1_from_container(void) {
     ECS_ENTITY(world, e3, Position, Velocity);
     ECS_ENTITY(world, e4, Position, Velocity);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position, Velocity);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position, Velocity);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_set(world, 0, Mass, {2});
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Mass, {2}));
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
     ecs_add_pair(world, e3, EcsChildOf, parent);
@@ -185,22 +185,22 @@ void System_w_FromParent_2_column_1_from_container(void) {
 
 static
 void Iter_2_shared(ecs_iter_t *it) {
-    Mass *m_ptr = ecs_field(it, Mass, 1);
+    Mass *m_ptr = ecs_field(it, Mass, 0);
 
     Rotation *r_ptr = NULL;
     Position *p = NULL;
     Velocity *v = NULL;
 
     if (it->field_count >= 2) {
-        r_ptr = ecs_field(it, Rotation, 2);
+        r_ptr = ecs_field(it, Rotation, 1);
     }
 
     if (it->field_count >= 3) {
-        p = ecs_field(it, Position, 3);
+        p = ecs_field(it, Position, 2);
     }
 
     if (it->field_count >= 4) {
-        v = ecs_field(it, Velocity, 4);
+        v = ecs_field(it, Velocity, 3);
     }    
 
     probe_iter(it);
@@ -241,13 +241,13 @@ void System_w_FromParent_3_column_2_from_container(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, Iter_2_shared, EcsOnUpdate, Mass(parent), Rotation(parent), Position);
+    ECS_SYSTEM(world, Iter_2_shared, EcsOnUpdate, Mass(up), Rotation(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter_2_shared,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_set(world, 0, Mass, {2});
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Mass, {2}));
     ecs_set(world, parent, Rotation, {3});
 
     ecs_add_pair(world, e1, EcsChildOf, parent);
@@ -306,14 +306,14 @@ void System_w_FromParent_2_column_1_from_container_w_not(void) {
     ECS_ENTITY(world, e4, Position);
     ECS_ENTITY(world, e5, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, !Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, !Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent_1 = ecs_set(world, 0, Mass, {2});
-    ecs_entity_t parent_2 = ecs_set(world, 0, Rotation, {3});
+    ecs_entity_t parent_1 = ecs_insert(world, ecs_value(Mass, {2}));
+    ecs_entity_t parent_2 = ecs_insert(world, ecs_value(Rotation, {3}));
 
     ecs_add_pair(world, e1, EcsChildOf, parent_2);
     ecs_add_pair(world, e2, EcsChildOf, parent_2);
@@ -381,15 +381,15 @@ void System_w_FromParent_3_column_1_from_comtainer_1_from_container_w_not(void)
     ECS_ENTITY(world, e5, Position);
     ECS_ENTITY(world, e6, Position);
 
-    ECS_SYSTEM(world, Iter_2_shared, EcsOnUpdate, !Mass(parent), Rotation(parent), Position);
+    ECS_SYSTEM(world, Iter_2_shared, EcsOnUpdate, !Mass(up), Rotation(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter_2_shared,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent_1 = ecs_set(world, 0, Mass, {2});
-    ecs_entity_t parent_2 = ecs_set(world, 0, Rotation, {3});
-    ecs_entity_t parent_3 = ecs_set(world, 0, Mass, {4});
+    ecs_entity_t parent_1 = ecs_insert(world, ecs_value(Mass, {2}));
+    ecs_entity_t parent_2 = ecs_insert(world, ecs_value(Rotation, {3}));
+    ecs_entity_t parent_3 = ecs_insert(world, ecs_value(Mass, {4}));
     ecs_set(world, parent_3, Rotation, {5});
 
     ecs_add_pair(world, e1, EcsChildOf, parent_2);
@@ -449,13 +449,13 @@ void System_w_FromParent_2_column_1_from_container_w_not_prefab(void) {
     ECS_ENTITY(world, e1, Position);
     ECS_ENTITY(world, e2, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, !Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, !Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent_1 = ecs_set(world, 0, Mass, {2});
+    ecs_entity_t parent_1 = ecs_insert(world, ecs_value(Mass, {2}));
     ecs_add_pair(world, e1, EcsIsA, Prefab);
 
     ecs_add_pair(world, e1, EcsChildOf, parent_1);
@@ -506,17 +506,17 @@ void System_w_FromParent_2_column_1_from_container_w_or(void) {
     ECS_ENTITY(world, e5, Position);
     ECS_ENTITY(world, e6, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent) || Rotation(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up) || Rotation(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent_1 = ecs_set(world, 0, Mass, {2});
-    ecs_entity_t parent_2 = ecs_set(world, 0, Rotation, {3});
-    ecs_entity_t parent_3 = ecs_set(world, 0, Rotation, {4});
+    ecs_entity_t parent_1 = ecs_insert(world, ecs_value(Mass, {2}));
+    ecs_entity_t parent_2 = ecs_insert(world, ecs_value(Rotation, {3}));
+    ecs_entity_t parent_3 = ecs_insert(world, ecs_value(Rotation, {4}));
                             ecs_set(world, parent_3, Mass, {5});
-    ecs_entity_t parent_4 = ecs_set(world, 0, Velocity, {10, 20});
+    ecs_entity_t parent_4 = ecs_insert(world, ecs_value(Velocity, {10, 20}));
 
     ecs_add_pair(world, e1, EcsChildOf, parent_1);
     ecs_add_pair(world, e2, EcsChildOf, parent_2);
@@ -555,10 +555,10 @@ void System_w_FromParent_2_column_1_from_container_w_or(void) {
 
 static
 void Dummy(ecs_iter_t *it) {
-    Mass *m_ptr = ecs_field(it, Mass, 1);
-    Position *p = ecs_field(it, Position, 2);
+    Mass *m_ptr = ecs_field(it, Mass, 0);
+    Position *p = ecs_field(it, Position, 1);
 
-    test_assert(!m_ptr || !ecs_field_is_self(it, 1));
+    test_assert(!m_ptr || !ecs_field_is_self(it, 0));
 
     probe_iter(it);
 
@@ -585,13 +585,13 @@ void System_w_FromParent_add_component_after_match(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
 
@@ -639,13 +639,13 @@ void System_w_FromParent_add_component_after_match_and_rematch(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
 
@@ -698,10 +698,10 @@ void System_w_FromParent_add_component_after_match_and_rematch_w_entity_type_exp
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
     ECS_ENTITY(world, Parent, 0);
@@ -750,7 +750,7 @@ void System_w_FromParent_add_component_after_match_and_rematch_w_entity_type_exp
 
 static
 void SetMass(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Mass) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Mass) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -769,10 +769,10 @@ void System_w_FromParent_add_component_after_match_and_rematch_w_entity_type_exp
     ECS_ENTITY(world, e4, Position);     
 
     ECS_SYSTEM(world, SetMass, EcsOnUpdate, Velocity, Mass());
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
     ECS_ENTITY(world, Parent, Velocity);
@@ -821,9 +821,9 @@ void System_w_FromParent_add_component_after_match_unmatch(void) {
     ECS_ENTITY(world, e2, Position);
     ECS_ENTITY(world, e3, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, !Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, !Mass(up), Position);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
 
@@ -863,15 +863,15 @@ void System_w_FromParent_add_component_after_match_unmatch_match(void) {
     ECS_ENTITY(world, e1, Position);
     ECS_ENTITY(world, e2, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ECS_SYSTEM(world, Dummy, EcsOnUpdate, !Mass(parent), Position);
+    ECS_SYSTEM(world, Dummy, EcsOnUpdate, !Mass(up), Position);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
 
@@ -918,19 +918,19 @@ void System_w_FromParent_add_component_after_match_2_systems(void) {
     ECS_ENTITY(world, e2, Position);
     ECS_ENTITY(world, e3, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Dummy,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
 
@@ -992,10 +992,10 @@ void System_w_FromParent_add_component_in_progress_after_match(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
     ECS_OBSERVER(world, AddMass, EcsOnAdd, Tag);
@@ -1005,7 +1005,7 @@ void System_w_FromParent_add_component_in_progress_after_match(void) {
         .ctx = &ecs_id(Mass)
     });
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
 
@@ -1052,13 +1052,13 @@ void System_w_FromParent_adopt_after_match(void) {
     ECS_ENTITY(world, e2, Position);
     ECS_ENTITY(world, e3, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_new(world, Mass);
+    ecs_entity_t parent = ecs_new_w(world, Mass);
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
 
@@ -1103,10 +1103,10 @@ void System_w_FromParent_new_child_after_match(void) {
 
     ECS_ENTITY(world, e3, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Iter,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
     
     ECS_ENTITY(world, parent, Mass);
@@ -1147,10 +1147,10 @@ void System_w_FromParent_new_child_after_match(void) {
 }
 
 void IterSame(ecs_iter_t *it) {
-    Position *p_parent = ecs_field(it, Position, 1);
-    Position *p = ecs_field(it, Position, 2);
+    Position *p_parent = ecs_field(it, Position, 0);
+    Position *p = ecs_field(it, Position, 1);
 
-    test_assert(!ecs_field_is_self(it, 1));
+    test_assert(!ecs_field_is_self(it, 0));
 
     probe_iter(it);
 
@@ -1172,13 +1172,13 @@ void System_w_FromParent_select_same_from_container(void) {
     ECS_ENTITY(world, e3, Position);
     ECS_ENTITY(world, e4, Position);
 
-    ECS_SYSTEM(world, IterSame, EcsOnUpdate, Position(parent), Position);
+    ECS_SYSTEM(world, IterSame, EcsOnUpdate, Position(up), Position);
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = IterSame,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
-    ecs_entity_t parent = ecs_set(world, 0, Position, {1, 2});
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {1, 2}));
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
     ecs_add_pair(world, e3, EcsChildOf, parent);
@@ -1232,9 +1232,9 @@ void System_w_FromParent_realloc_after_match(void) {
 
     ECS_ENTITY(world, e1, Position);
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(parent), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(up), Position);
 
-    ecs_entity_t parent = ecs_set(world, 0, Mass, {2});
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Mass, {2}));
     ecs_add_pair(world, e1, EcsChildOf, parent);
 
     Probe ctx = {0};
diff --git a/test/addons/src/System_w_FromSystem.c b/test/addons/src/System_w_FromSystem.c
index 673dcabd2..4c3c365cb 100644
--- a/test/addons/src/System_w_FromSystem.c
+++ b/test/addons/src/System_w_FromSystem.c
@@ -1,7 +1,7 @@
 #include <addons.h>
 
 void InitVelocity(ecs_iter_t *it) {
-    Velocity *v = ecs_field(it, Velocity, 1);
+    Velocity *v = ecs_field(it, Velocity, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -11,7 +11,7 @@ void InitVelocity(ecs_iter_t *it) {
 }
 
 void InitMass(ecs_iter_t *it) {
-    Mass *m = ecs_field(it, Mass, 1);    
+    Mass *m = ecs_field(it, Mass, 0);    
     int i;
     for (i = 0; i < it->count; i ++) {
         m[i] = 3;
@@ -19,19 +19,19 @@ void InitMass(ecs_iter_t *it) {
 }
 
 void Iter(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     Velocity *v = NULL;
     Mass *m = NULL;
 
     if (it->field_count >= 2) {
-        v = ecs_field(it, Velocity, 2);
-        test_assert(!ecs_field_is_self(it, 2));
+        v = ecs_field(it, Velocity, 1);
+        test_assert(!ecs_field_is_self(it, 1));
     }
 
     if (it->field_count >= 3) {
-        m = ecs_field(it, Mass, 3);
-        test_assert(!m || !ecs_field_is_self(it, 3));
+        m = ecs_field(it, Mass, 2);
+        test_assert(!m || !ecs_field_is_self(it, 2));
     }
 
     probe_iter(it);
@@ -66,7 +66,7 @@ void System_w_FromSystem_2_column_1_from_system(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {0, 0});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {0, 0}));
 
     ecs_progress(world, 1);
     
@@ -120,7 +120,7 @@ void System_w_FromSystem_3_column_2_from_system(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {0, 0});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {0, 0}));
 
     ecs_progress(world, 1);
     
@@ -152,14 +152,14 @@ void System_w_FromSystem_3_column_2_from_system(void) {
 }
 
 void Iter_reactive(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     Velocity *v = it->param;
     Mass *m = NULL;
 
     if (it->field_count >= 2) {
-        v = ecs_field(it, Velocity, 2);
-        test_assert(!ecs_field_is_self(it, 2));
+        v = ecs_field(it, Velocity, 1);
+        test_assert(!ecs_field_is_self(it, 1));
     }
 
     probe_iter(it);
diff --git a/test/addons/src/Timer.c b/test/addons/src/Timer.c
index 0decef3af..fc4699236 100644
--- a/test/addons/src/Timer.c
+++ b/test/addons/src/Timer.c
@@ -25,7 +25,7 @@ void Timer_timeout(void) {
 
     ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_entity_t timer = ecs_set_timeout(world, SystemA, 3.0);
     test_assert(timer != 0);
@@ -60,7 +60,7 @@ void Timer_interval(void) {
 
     ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_entity_t timer = ecs_set_interval(world, SystemA, 3.0);
     test_assert(timer != 0);
@@ -95,7 +95,7 @@ void Timer_shared_timeout(void) {
     ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
     ECS_SYSTEM(world, SystemB, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_entity_t timer = ecs_set_timeout(world, 0, 3.0);
     test_assert(timer != 0);
@@ -140,7 +140,7 @@ void Timer_shared_interval(void) {
     ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
     ECS_SYSTEM(world, SystemB, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_entity_t timer = ecs_set_interval(world, 0, 3.0);
     test_assert(timer != 0);
@@ -184,7 +184,7 @@ void Timer_start_stop_one_shot(void) {
 
     ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_entity_t timer = ecs_set_timeout(world, SystemA, 3.0);
     test_assert(timer != 0);
@@ -226,7 +226,7 @@ void Timer_start_stop_interval(void) {
 
     ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_entity_t timer = ecs_set_interval(world, SystemA, 3.0);
     test_assert(timer != 0);
@@ -279,7 +279,7 @@ void Timer_rate_filter(void) {
 
     ECS_SYSTEM(world, SystemA, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_entity_t filter = ecs_set_rate(world, SystemA, 3, 0);
     test_assert(filter != 0);
@@ -321,7 +321,7 @@ void Timer_rate_filter_w_rate_filter_src(void) {
 
     ECS_SYSTEM(world, SystemC, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_entity_t filter_a = ecs_set_rate(world, 0, 2, 0);
     test_assert(filter_a != 0);
@@ -401,10 +401,10 @@ void Timer_rate_filter_with_empty_src(void) {
 
     ECS_SYSTEM(world, SystemC, EcsOnUpdate, Position);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     // Not actually a tick source
-    ecs_entity_t filter_a = ecs_new_id(world);
+    ecs_entity_t filter_a = ecs_new(world);
     test_assert(filter_a != 0);
 
     ecs_entity_t filter_b = ecs_set_rate(world, SystemC, 6, filter_a);
@@ -519,7 +519,7 @@ void Timer_rate_entity(void) {
         test_bool(src->tick, false);
     }
 
-    /* Filter should tick again */
+    /* Query should tick again */
     ecs_progress(world, 0);
     test_bool(src->tick, true);
 
@@ -553,7 +553,7 @@ void Timer_nested_rate_entity(void) {
         test_bool(src->tick, false);
     }
 
-    /* Filter should tick again */
+    /* Query should tick again */
     ecs_progress(world, 0);
     test_bool(src->tick, true);
 
@@ -564,7 +564,7 @@ void Timer_nested_rate_entity_empty_src(void) {
     ecs_world_t *world = ecs_init();
 
     /* Rate filter with source that is not a tick source */
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t rate = ecs_set_rate(world, 0, 4, parent);
 
     int i;
@@ -587,7 +587,7 @@ void Timer_nested_rate_entity_empty_src(void) {
         test_bool(src->tick, false);
     }
 
-    /* Filter should tick again */
+    /* Query should tick again */
     ecs_progress(world, 0);
     test_bool(src->tick, true);
 
@@ -597,7 +597,7 @@ void Timer_nested_rate_entity_empty_src(void) {
 void Timer_naked_tick_entity(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t tick = ecs_set(world, 0, EcsTickSource, {0});
+    ecs_entity_t tick = ecs_insert(world, ecs_value(EcsTickSource, {0}));
 
     int i;
     for (i = 0; i < 10; i ++) {
diff --git a/test/addons/src/main.c b/test/addons/src/main.c
index cd23e9ef5..cf9981835 100644
--- a/test/addons/src/main.c
+++ b/test/addons/src/main.c
@@ -8,508 +8,6 @@
 
 #include <addons.h>
 
-// Testsuite 'Parser'
-void Parser_resolve_this(void);
-void Parser_resolve_wildcard(void);
-void Parser_resolve_any(void);
-void Parser_resolve_is_a(void);
-void Parser_0(void);
-void Parser_component_implicit_subject(void);
-void Parser_component_explicit_subject(void);
-void Parser_component_explicit_subject_this(void);
-void Parser_component_explicit_subject_this_by_name(void);
-void Parser_component_explicit_subject_this_by_var_name(void);
-void Parser_component_explicit_subject_wildcard(void);
-void Parser_component_explicit_subject_any(void);
-void Parser_component_explicit_subject_0(void);
-void Parser_this_as_predicate(void);
-void Parser_this_var_as_predicate(void);
-void Parser_this_lowercase_var_as_predicate(void);
-void Parser_this_as_object(void);
-void Parser_this_var_as_object(void);
-void Parser_pair_implicit_subject(void);
-void Parser_pair_implicit_subject_wildcard_pred(void);
-void Parser_pair_implicit_subject_wildcard_obj(void);
-void Parser_pair_implicit_subject_any_pred(void);
-void Parser_pair_implicit_subject_any_obj(void);
-void Parser_pair_implicit_subject_this_pred(void);
-void Parser_pair_implicit_subject_this_obj(void);
-void Parser_pair_implicit_subject_pred_w_self(void);
-void Parser_pair_implicit_subject_obj_w_self(void);
-void Parser_pair_implicit_subject_pred_w_up(void);
-void Parser_pair_implicit_subject_obj_w_up(void);
-void Parser_pair_implicit_subject_pred_w_self_up(void);
-void Parser_pair_implicit_subject_obj_w_self_up(void);
-void Parser_pair_implicit_subject_pred_w_up_trav(void);
-void Parser_pair_implicit_subject_obj_w_up_trav(void);
-void Parser_pair_implicit_subject_pred_w_invalid_flags(void);
-void Parser_pair_implicit_subject_obj_w_invalid_flags(void);
-void Parser_pair_explicit_subject(void);
-void Parser_pair_explicit_subject_this(void);
-void Parser_pair_explicit_subject_this_by_name(void);
-void Parser_pair_explicit_subject_this_by_var_name(void);
-void Parser_pair_explicit_subject_wildcard_pred(void);
-void Parser_pair_explicit_subject_wildcard_subj(void);
-void Parser_pair_explicit_subject_wildcard_obj(void);
-void Parser_pair_implicit_subject_0_object(void);
-void Parser_pair_explicit_subject_0_object(void);
-void Parser_pair_explicit_subject_0(void);
-void Parser_in_component_implicit_subject(void);
-void Parser_in_component_explicit_subject(void);
-void Parser_in_pair_implicit_subject(void);
-void Parser_in_pair_explicit_subject(void);
-void Parser_inout_component_implicit_subject(void);
-void Parser_inout_component_explicit_subject(void);
-void Parser_inout_pair_implicit_subject(void);
-void Parser_inout_pair_explicit_subject(void);
-void Parser_out_component_implicit_subject(void);
-void Parser_out_component_explicit_subject(void);
-void Parser_out_pair_implicit_subject(void);
-void Parser_out_pair_explicit_subject(void);
-void Parser_inout_filter_component(void);
-void Parser_component_singleton(void);
-void Parser_this_singleton(void);
-void Parser_component_implicit_no_subject(void);
-void Parser_component_explicit_no_subject(void);
-void Parser_pair_no_subject(void);
-void Parser_variable_single_char(void);
-void Parser_variable_multi_char(void);
-void Parser_variable_multi_char_w_underscore(void);
-void Parser_variable_multi_char_w_number(void);
-void Parser_variable_multi_char_not_allcaps(void);
-void Parser_pred_var(void);
-void Parser_obj_var(void);
-void Parser_component_not(void);
-void Parser_pair_implicit_subject_not(void);
-void Parser_pair_explicit_subject_not(void);
-void Parser_2_component_not(void);
-void Parser_2_component_not_no_space(void);
-void Parser_component_optional(void);
-void Parser_2_component_optional(void);
-void Parser_2_component_optional_no_space(void);
-void Parser_from_and(void);
-void Parser_from_or(void);
-void Parser_from_not(void);
-void Parser_pair_implicit_subject_optional(void);
-void Parser_pair_explicit_subject_optional(void);
-void Parser_pred_implicit_subject_w_role(void);
-void Parser_pred_explicit_subject_w_role(void);
-void Parser_pred_no_subject_w_role(void);
-void Parser_pair_implicit_subject_w_role(void);
-void Parser_pair_explicit_subject_w_role(void);
-void Parser_inout_role_pred_implicit_subject(void);
-void Parser_inout_role_pred_no_subject(void);
-void Parser_inout_role_pred_explicit_subject(void);
-void Parser_inout_role_pair_implicit_subject(void);
-void Parser_inout_role_pair_explicit_subject(void);
-void Parser_2_pred_implicit_subject(void);
-void Parser_2_pred_no_subject(void);
-void Parser_2_pred_explicit_subject(void);
-void Parser_2_pair_implicit_subject(void);
-void Parser_2_pair_explicit_subject(void);
-void Parser_2_pred_role(void);
-void Parser_2_pair_implicit_subj_role(void);
-void Parser_2_pair_explicit_subj_role(void);
-void Parser_2_or_pred_implicit_subj(void);
-void Parser_2_or_pred_explicit_subj(void);
-void Parser_2_or_pair_implicit_subj(void);
-void Parser_2_or_pair_explicit_subj(void);
-void Parser_2_or_pred_inout(void);
-void Parser_1_digit_pred_implicit_subj(void);
-void Parser_1_digit_pred_no_subj(void);
-void Parser_1_digit_pred_explicit_subj(void);
-void Parser_1_digit_pair_implicit_subj(void);
-void Parser_1_digit_pair_explicit_subj(void);
-void Parser_pred_implicit_subject_self(void);
-void Parser_pred_implicit_subject_superset(void);
-void Parser_pred_implicit_subject_subset(void);
-void Parser_pred_implicit_subject_superset_inclusive(void);
-void Parser_pred_implicit_subject_subset_inclusive(void);
-void Parser_pred_implicit_subject_superset_cascade(void);
-void Parser_pred_implicit_subject_subset_cascade(void);
-void Parser_pred_implicit_subject_superset_inclusive_cascade(void);
-void Parser_pred_implicit_subject_subset_inclusive_cascade(void);
-void Parser_pred_implicit_subject_implicit_superset_cascade(void);
-void Parser_pred_implicit_subject_implicit_superset_inclusive_cascade(void);
-void Parser_pred_implicit_subject_implicit_superset_cascade_w_rel(void);
-void Parser_pred_implicit_subject_implicit_superset_inclusive_cascade_w_rel(void);
-void Parser_pred_implicit_subject_superset_childof(void);
-void Parser_pred_implicit_subject_cascade_superset_childof(void);
-void Parser_pred_implicit_subject_superset_cascade_childof(void);
-void Parser_pred_implicit_subject_superset_cascade_childof_optional(void);
-void Parser_expr_w_symbol(void);
-void Parser_expr_w_newline(void);
-void Parser_subj_entity_w_explicit_self(void);
-void Parser_subj_entity_w_explicit_self_superset(void);
-void Parser_subj_entity_w_explicit_superset_relation(void);
-void Parser_subj_entity_w_explicit_self_superset_relation(void);
-void Parser_obj_entity_w_explicit_self(void);
-void Parser_obj_entity_w_explicit_self_superset(void);
-void Parser_obj_entity_w_explicit_superset_relation(void);
-void Parser_obj_entity_w_explicit_self_superset_relation(void);
-void Parser_pred_entity_w_explicit_self(void);
-void Parser_pred_entity_w_explicit_self_superset(void);
-void Parser_pred_entity_w_explicit_superset_relation(void);
-void Parser_pred_entity_w_explicit_self_superset_relation(void);
-void Parser_pred_entity_no_args_w_explicit_self(void);
-void Parser_pred_entity_no_args_w_explicit_self_superset(void);
-void Parser_pred_entity_no_args_w_explicit_superset_relation(void);
-void Parser_pred_entity_no_args_w_explicit_self_superset_relation(void);
-void Parser_pred_entity_no_args_2_terms_w_explicit_self(void);
-void Parser_pred_entity_no_args_2_terms_w_explicit_self_superset(void);
-void Parser_pred_entity_no_args_2_terms_w_explicit_superset_relation(void);
-void Parser_pred_entity_no_args_2_terms_w_explicit_self_superset_relation(void);
-void Parser_newline(void);
-void Parser_2_newlines(void);
-void Parser_3_newlines(void);
-void Parser_space(void);
-void Parser_2_spaces(void);
-void Parser_trailing_newline(void);
-void Parser_2_trailing_newlines(void);
-void Parser_trailing_space(void);
-void Parser_2_trailing_spaces(void);
-void Parser_template_type(void);
-void Parser_predicate_w_parens(void);
-void Parser_not_alive_pred(void);
-void Parser_not_alive_subj(void);
-void Parser_not_alive_obj(void);
-void Parser_this_subj_var_kind(void);
-void Parser_this_obj_var_kind(void);
-void Parser_this_subj_obj_var_kind(void);
-void Parser_var_w_name(void);
-void Parser_entity_pred_no_name(void);
-void Parser_entity_subj_no_name(void);
-void Parser_entity_obj_no_name(void);
-void Parser_this_pred_no_name(void);
-void Parser_this_subj_no_name(void);
-void Parser_this_obj_no_name(void);
-void Parser_auto_object_variable(void);
-void Parser_auto_object_variable_w_subj(void);
-void Parser_auto_scoped_variable(void);
-void Parser_invalid_variable_only(void);
-void Parser_oneof_self_pred_w_relative_obj(void);
-void Parser_oneof_other_pred_w_relative_obj(void);
-void Parser_oneof_self_pred_w_invalid_obj(void);
-void Parser_oneof_other_pred_w_invalid_obj(void);
-void Parser_oneof_w_other_entity_w_same_name(void);
-void Parser_oneof_w_other_entity_w_same_name_w_set_scope(void);
-void Parser_oneof_w_wildcard(void);
-void Parser_oneof_w_any(void);
-void Parser_oneof_w_fullpath(void);
-void Parser_pair_implicit_src_missing_rel(void);
-void Parser_pair_implicit_src_missing_obj(void);
-void Parser_pair_explicit_src_missing_src(void);
-void Parser_pair_explicit_src_missing_obj(void);
-void Parser_eq_id(void);
-void Parser_eq_id_var(void);
-void Parser_eq_var_id(void);
-void Parser_eq_var(void);
-void Parser_neq_id(void);
-void Parser_neq_id_var(void);
-void Parser_neq_var_id(void);
-void Parser_neq_var(void);
-void Parser_eq_name(void);
-void Parser_eq_name_var(void);
-void Parser_eq_var_name(void);
-void Parser_eq_var(void);
-void Parser_neq_name(void);
-void Parser_neq_name_var(void);
-void Parser_neq_var_name(void);
-void Parser_neq_var(void);
-void Parser_match_name(void);
-void Parser_match_name_var(void);
-void Parser_match_var_name(void);
-void Parser_match_var(void);
-void Parser_nmatch_name(void);
-void Parser_nmatch_name_var(void);
-void Parser_nmatch_var_name(void);
-void Parser_eq_same_var(void);
-void Parser_neq_same_var(void);
-void Parser_eq_same_var_this(void);
-void Parser_neq_same_var_this(void);
-void Parser_eq_w_optional(void);
-void Parser_neq_w_optional(void);
-void Parser_match_w_optional(void);
-void Parser_query_scope_1_term(void);
-void Parser_query_scope_1_term_spaces(void);
-void Parser_query_scope_2_terms(void);
-void Parser_query_nested_scope(void);
-void Parser_query_nested_scope_spaces(void);
-void Parser_query_scope_unbalanced(void);
-void Parser_query_not_scope(void);
-void Parser_query_empty_scope(void);
-void Parser_query_scope_newline_after_open(void);
-void Parser_query_scope_newline_after_close(void);
-void Parser_override_tag(void);
-void Parser_override_pair(void);
-void Parser_pair_3_args(void);
-void Parser_pair_3_args_implicit_this(void);
-void Parser_pair_4_args(void);
-void Parser_pair_4_args_implicit_this(void);
-void Parser_pair_3_args_2_terms(void);
-void Parser_pair_3_args_this_tgt(void);
-void Parser_pair_3_args_2_terms_this_tgt(void);
-void Parser_pair_3_args_2_terms_this_tgt_implicit_this(void);
-void Parser_pair_3_or_args(void);
-void Parser_pair_3_or_args_implicit_this(void);
-void Parser_pair_4_or_args(void);
-void Parser_pair_4_or_args_implicit_this(void);
-void Parser_pair_or_before_and_oper(void);
-void Parser_pair_and_before_or_oper(void);
-void Parser_cascade_desc(void);
-void Parser_newline_after_inout(void);
-void Parser_newline_after_term_open(void);
-void Parser_newline_after_term_src(void);
-void Parser_newline_after_term_src_pair(void);
-void Parser_newline_after_term_pair_comma(void);
-void Parser_newline_after_term_pair_second(void);
-void Parser_tag_w_space_implicit_this(void);
-void Parser_tag_w_space(void);
-void Parser_pair_first_w_space_implicit_this(void);
-void Parser_pair_first_w_space(void);
-void Parser_pair_second_w_space_implicit_this(void);
-void Parser_pair_second_w_space(void);
-void Parser_pair_src_w_space(void);
-
-// Testsuite 'Plecs'
-void Plecs_null(void);
-void Plecs_empty(void);
-void Plecs_space(void);
-void Plecs_space_newline(void);
-void Plecs_two_empty_newlines(void);
-void Plecs_three_empty_newlines(void);
-void Plecs_newline_trailing_space(void);
-void Plecs_newline_trailing_spaces(void);
-void Plecs_multiple_trailing_newlines(void);
-void Plecs_entity(void);
-void Plecs_entity_w_entity(void);
-void Plecs_entity_w_pair(void);
-void Plecs_2_entities(void);
-void Plecs_2_entities_w_entities(void);
-void Plecs_3_entities_w_pairs(void);
-void Plecs_line_comment(void);
-void Plecs_line_comment_before_stmt(void);
-void Plecs_line_comment_after_stmt(void);
-void Plecs_line_comment_between_stmt(void);
-void Plecs_multiple_line_comment(void);
-void Plecs_line_comment_after_stmt_same_line(void);
-void Plecs_comma_separated_pred(void);
-void Plecs_comma_separated_pred_w_subj(void);
-void Plecs_comma_separated_pred_w_subj_obj(void);
-void Plecs_comma_separated_pred_trailing_comma(void);
-void Plecs_comma_separated_pred_trailing_comma_newline(void);
-void Plecs_comma_separated_pred_trailing_comma_newline_multiline(void);
-void Plecs_hierarchy_1_child(void);
-void Plecs_hierarchy_2_children(void);
-void Plecs_hierarchy_1_child_same_line(void);
-void Plecs_hierarchy_2_children_same_line(void);
-void Plecs_entity_after_hierarchy(void);
-void Plecs_newline_before_scope_open(void);
-void Plecs_comment_before_scope_open(void);
-void Plecs_comment_after_newline_before_scope_open(void);
-void Plecs_hierarchy_2_levels(void);
-void Plecs_hierarchy_2_levels_2_subtrees(void);
-void Plecs_missing_end_of_scope(void);
-void Plecs_missing_end_of_predicate_scope(void);
-void Plecs_create_in_scope(void);
-void Plecs_hierarchy_w_pred_subj(void);
-void Plecs_hierarchy_custom_relation(void);
-void Plecs_hierarchy_custom_relation_2_levels(void);
-void Plecs_hierarchy_custom_relation_apply_to_object(void);
-void Plecs_hierarchy_custom_relation_apply_to_object_2_levels(void);
-void Plecs_entity_after_hierarchy_custom_relation(void);
-void Plecs_entity_after_hierarchy_custom_relation_2_levels(void);
-void Plecs_pred_scope(void);
-void Plecs_pred_scope_2_levels(void);
-void Plecs_pred_scope_inside_with(void);
-void Plecs_pred_scope_nested_w_subj_scope(void);
-void Plecs_with_tag(void);
-void Plecs_with_tag_2_entities(void);
-void Plecs_with_tag_same_line(void);
-void Plecs_with_tag_2_entities_same_line(void);
-void Plecs_with_tag_2_levels(void);
-void Plecs_with_tag_2_levels_2_subtrees(void);
-void Plecs_with_n_tags(void);
-void Plecs_with_n_tags_2_levels(void);
-void Plecs_with_after_scope(void);
-void Plecs_with_after_with(void);
-void Plecs_scope_inside_with_inside_scope(void);
-void Plecs_with_inside_scope(void);
-void Plecs_assignment_w_1(void);
-void Plecs_assignment_w_2(void);
-void Plecs_assignment_w_pair(void);
-void Plecs_assignment_w_invalid_subject(void);
-void Plecs_assignment_w_invalid_with(void);
-void Plecs_inherit_w_colon(void);
-void Plecs_inherit_w_colon_w_scope(void);
-void Plecs_inherit_w_colon_w_assign(void);
-void Plecs_assign_component_value(void);
-void Plecs_assign_2_component_values(void);
-void Plecs_assign_component_value_in_assign_scope(void);
-void Plecs_assign_2_component_values_in_assign_scope(void);
-void Plecs_type_and_assign_in_plecs(void);
-void Plecs_type_and_assign_in_plecs_w_2_members(void);
-void Plecs_type_and_assign_in_plecs_w_3_members(void);
-void Plecs_type_and_assign_in_plecs_w_enum(void);
-void Plecs_type_and_assign_in_plecs_w_enum_using_meta(void);
-void Plecs_type_and_assign_in_plecs_w_enum_primitive_using_meta(void);
-void Plecs_type_and_assign_in_plecs_w_enum_primitive_and_struct(void);
-void Plecs_type_and_assign_in_plecs_nested_member(void);
-void Plecs_dot_assign_nested_member(void);
-void Plecs_dot_assign_binary_expr(void);
-void Plecs_open_scope_no_parent(void);
-void Plecs_create_subject_in_root_scope_w_resolvable_id(void);
-void Plecs_create_subject_in_scope_w_resolvable_id(void);
-void Plecs_create_subject_in_scope_w_resolvable_id_using(void);
-void Plecs_using_scope(void);
-void Plecs_using_nested_scope(void);
-void Plecs_using_nested_in_scope(void);
-void Plecs_using_with_scope(void);
-void Plecs_using_w_entity_ref_in_value_2_members(void);
-void Plecs_using_w_entity_ref_in_value_3_members(void);
-void Plecs_2_using_scope(void);
-void Plecs_2_using_in_different_scope(void);
-void Plecs_empty_scope_after_using(void);
-void Plecs_assignment_to_non_component(void);
-void Plecs_struct_w_member_w_assignment_to_nothing(void);
-void Plecs_struct_w_member_w_assignment_to_empty_scope(void);
-void Plecs_scope_after_assign(void);
-void Plecs_assign_after_inherit(void);
-void Plecs_multiple_assignments_single_line(void);
-void Plecs_2_stmts_in_scope_w_no_parent(void);
-void Plecs_scope_after_assign_1_tag(void);
-void Plecs_scope_after_assign_2_tags(void);
-void Plecs_invalid_nested_assignment(void);
-void Plecs_invalid_partial_pair_assignment(void);
-void Plecs_empty_assignment(void);
-void Plecs_assign_tag_to_parent(void);
-void Plecs_assign_component_to_parent(void);
-void Plecs_empty_assignment_before_end_of_scope(void);
-void Plecs_assign_to_parent_pair_w_new_entities_in_scope(void);
-void Plecs_assign_to_parent_pair_w_existing_entities_in_scope(void);
-void Plecs_default_child_component(void);
-void Plecs_default_child_component_w_assign(void);
-void Plecs_struct_type_w_default_child_component(void);
-void Plecs_struct_type_w_default_child_component_nested_member(void);
-void Plecs_enum_type_w_default_child_component(void);
-void Plecs_default_type_from_with(void);
-void Plecs_scope_w_1_subj_and_2_pairs(void);
-void Plecs_inherit_from_multiple(void);
-void Plecs_assign_pair_component(void);
-void Plecs_assign_pair_component_in_scope(void);
-void Plecs_assign_pair_component_in_script(void);
-void Plecs_assign_pair_component_in_script_update(void);
-void Plecs_set_entity_names(void);
-void Plecs_oneof(void);
-void Plecs_invalid_oneof(void);
-void Plecs_brief_annotation(void);
-void Plecs_name_annotation(void);
-void Plecs_link_annotation(void);
-void Plecs_color_annotation(void);
-void Plecs_multiple_annotations(void);
-void Plecs_annotation_w_trailing_space(void);
-void Plecs_multiline_string(void);
-void Plecs_unterminated_multiline_string(void);
-void Plecs_declaration_w_underscore_name(void);
-void Plecs_annotate_declaration(void);
-void Plecs_anonymous_entity(void);
-void Plecs_anonymous_entity_in_scope(void);
-void Plecs_anonymous_declaration(void);
-void Plecs_const_var_int(void);
-void Plecs_const_var_float(void);
-void Plecs_const_var_bool(void);
-void Plecs_const_var_string(void);
-void Plecs_const_var_struct(void);
-void Plecs_const_var_redeclare(void);
-void Plecs_const_var_scoped(void);
-void Plecs_assign_component_from_var(void);
-void Plecs_assign_component_from_var_in_scope(void);
-void Plecs_scope_w_component_after_const_var(void);
-void Plecs_component_after_const_paren_expr(void);
-void Plecs_component_after_const_add_expr(void);
-void Plecs_component_after_const_sub_expr(void);
-void Plecs_component_after_const_mul_expr(void);
-void Plecs_component_after_const_div_expr(void);
-void Plecs_parse_with(void);
-void Plecs_parse_with_w_with(void);
-void Plecs_parse_with_w_tag(void);
-void Plecs_parse_with_value(void);
-void Plecs_parse_with_2_values(void);
-void Plecs_parse_with_2_nested_values(void);
-void Plecs_parse_with_var(void);
-void Plecs_parse_with_2_vars(void);
-void Plecs_parse_with_2_nested_vars(void);
-void Plecs_parse_with_var_in_scope(void);
-void Plecs_assign_const_w_expr(void);
-void Plecs_const_w_type(void);
-void Plecs_assembly_no_scope(void);
-void Plecs_assembly_empty(void);
-void Plecs_assembly_no_props(void);
-void Plecs_assembly_prop_no_type(void);
-void Plecs_assembly_prop_no_default(void);
-void Plecs_assembly_prop(void);
-void Plecs_assembly_prop_space_colon(void);
-void Plecs_assembly_2_props(void);
-void Plecs_assembly_instance_w_default_values(void);
-void Plecs_assembly_instance_w_assign_default_values(void);
-void Plecs_assembly_instance_w_overridden_values(void);
-void Plecs_assembly_w_child(void);
-void Plecs_assembly_w_child_parse_script(void);
-void Plecs_assembly_w_child_parse_script_twice(void);
-void Plecs_assembly_w_child_update_after_parse(void);
-void Plecs_assembly_w_nested_child(void);
-void Plecs_assembly_w_prefab(void);
-void Plecs_assembly_w_prefab_tree(void);
-void Plecs_assembly_w_nested_assembly(void);
-void Plecs_instantiate_prefab_w_assembly(void);
-void Plecs_assembly_w_prefab_w_assembly(void);
-void Plecs_3_assemblies(void);
-void Plecs_assembly_nested_w_default_var(void);
-void Plecs_assembly_w_anonymous(void);
-void Plecs_assembly_w_anonymous_parse_again(void);
-void Plecs_typed_const_w_composite_type_invalid_assignment(void);
-void Plecs_typed_const_w_composite_type(void);
-void Plecs_assign_var_to_typed_const_w_composite_type(void);
-void Plecs_typed_const_w_composite_type_invalid_assignment(void);
-void Plecs_assembly_w_composite_prop_invalid_assignment(void);
-void Plecs_assembly_w_composite_prop(void);
-void Plecs_assembly_with_with(void);
-void Plecs_using_wildcard(void);
-void Plecs_single_line_comment_in_value(void);
-void Plecs_single_line_comment_in_value_after_scope(void);
-void Plecs_multi_line_comment_in_value(void);
-void Plecs_multi_line_comment_in_value_after_scope(void);
-void Plecs_unterminated_multi_line_comment_in_value(void);
-void Plecs_module_stmt(void);
-void Plecs_nested_module_stmt(void);
-void Plecs_module_stmt_w_scope(void);
-void Plecs_module_stmt_w_nested_scope(void);
-void Plecs_module_w_assembly(void);
-void Plecs_module_w_nested_assembly(void);
-void Plecs_assign_singleton_tag(void);
-void Plecs_assign_singleton_component(void);
-void Plecs_assign_singleton_tag_w_scope(void);
-void Plecs_assign_singleton_2_tags_w_scope(void);
-void Plecs_assign_singleton_component_w_scope(void);
-void Plecs_assign_singleton_2_components_w_scope(void);
-void Plecs_with_pair_in_scope(void);
-void Plecs_assembly_redeclare_prop_as_const(void);
-void Plecs_assembly_redeclare_prop_as_prop(void);
-void Plecs_assembly_redeclare_const_as_const(void);
-void Plecs_add_auto_override(void);
-void Plecs_add_auto_override_pair(void);
-void Plecs_scope_w_auto_override(void);
-void Plecs_scope_w_auto_override_pair(void);
-void Plecs_pair_w_rel_var(void);
-void Plecs_pair_w_tgt_var(void);
-void Plecs_assembly_w_pair_w_this_var(void);
-void Plecs_with_value_not_a_component(void);
-void Plecs_component_in_with_scope(void);
-void Plecs_component_in_with_scope_nested(void);
-void Plecs_component_in_with_scope_in_scope(void);
-void Plecs_assign_after_with_in_scope(void);
-void Plecs_array_component(void);
-
 // Testsuite 'Doc'
 void Doc_get_set_name(void);
 void Doc_get_entity_name(void);
@@ -610,7 +108,6 @@ void Pipeline_pipeline_init_no_system_term(void);
 void SystemMisc_invalid_not_without_id(void);
 void SystemMisc_invalid_optional_without_id(void);
 void SystemMisc_invalid_entity_without_id(void);
-void SystemMisc_invalid_empty_without_id(void);
 void SystemMisc_invalid_empty_element(void);
 void SystemMisc_invalid_empty_element_w_space(void);
 void SystemMisc_invalid_empty_or(void);
@@ -631,7 +128,6 @@ void SystemMisc_system_w_or_disabled_and_prefab(void);
 void SystemMisc_table_columns_access(void);
 void SystemMisc_dont_enable_after_rematch(void);
 void SystemMisc_ensure_single_merge(void);
-void SystemMisc_table_count(void);
 void SystemMisc_match_system(void);
 void SystemMisc_system_initial_state(void);
 void SystemMisc_add_own_component(void);
@@ -641,8 +137,6 @@ void SystemMisc_system_readeactivate_w_2_systems(void);
 void SystemMisc_add_to_system_in_progress(void);
 void SystemMisc_redefine_null_signature(void);
 void SystemMisc_redefine_0_signature(void);
-void SystemMisc_one_named_column_of_two(void);
-void SystemMisc_two_named_columns_of_two(void);
 void SystemMisc_redeclare_system_explicit_id(void);
 void SystemMisc_redeclare_system_explicit_id_null_expr(void);
 void SystemMisc_redeclare_system_explicit_id_no_name(void);
@@ -666,7 +160,6 @@ void SystemMisc_delete_pipeline_system(void);
 void SystemMisc_delete_system_w_ctx(void);
 void SystemMisc_update_ctx(void);
 void SystemMisc_run_custom_run_action(void);
-void SystemMisc_run_w_offset_limit_custom_run_action(void);
 void SystemMisc_pipeline_custom_run_action(void);
 void SystemMisc_change_custom_run_action(void);
 void SystemMisc_custom_run_action_call_next(void);
@@ -675,739 +168,7 @@ void SystemMisc_update_interval_w_system_init(void);
 void SystemMisc_update_rate_w_system_init(void);
 void SystemMisc_system_w_interval_rate_stop_timer(void);
 void SystemMisc_system_same_interval_same_tick(void);
-
-// Testsuite 'RulesBasic'
-void RulesBasic_1_fact_w_tag(void);
-void RulesBasic_1_fact_w_component(void);
-void RulesBasic_1_fact_w_tag_pair(void);
-void RulesBasic_1_fact_w_component_pair(void);
-void RulesBasic_2_facts_same_src_w_tag(void);
-void RulesBasic_2_facts_same_src_w_component(void);
-void RulesBasic_2_facts_same_src_w_tag_pair(void);
-void RulesBasic_2_facts_same_src_w_component_pair(void);
-void RulesBasic_2_facts_other_src_w_tag(void);
-void RulesBasic_2_facts_other_src_w_component(void);
-void RulesBasic_2_facts_other_src_w_tag_pair(void);
-void RulesBasic_2_facts_other_src_w_component_pair(void);
-void RulesBasic_1_fact_w_any(void);
-void RulesBasic_1_fact_w_pair_any_tgt(void);
-void RulesBasic_1_fact_w_pair_any_rel(void);
-void RulesBasic_1_fact_w_pair_any_rel_tgt(void);
-void RulesBasic_2_facts_same_src_w_any(void);
-void RulesBasic_2_facts_same_src_w_pair_any_tgt(void);
-void RulesBasic_2_facts_same_src_w_pair_any_rel(void);
-void RulesBasic_2_facts_same_src_w_pair_any_rel_tgt(void);
-void RulesBasic_2_facts_other_src_w_any(void);
-void RulesBasic_2_facts_other_src_w_pair_any_tgt(void);
-void RulesBasic_2_facts_other_src_w_pair_any_rel(void);
-void RulesBasic_2_facts_other_src_w_pair_any_rel_tgt(void);
-void RulesBasic_1_this_src_w_tag(void);
-void RulesBasic_1_this_src_w_component(void);
-void RulesBasic_1_this_src_w_tag_pair(void);
-void RulesBasic_1_this_src_w_component_pair(void);
-void RulesBasic_1_this_src_w_tag_2_tables(void);
-void RulesBasic_1_this_src_w_component_2_tables(void);
-void RulesBasic_1_this_src_w_tag_pair_2_tables(void);
-void RulesBasic_1_this_src_w_component_pair_2_tables(void);
-void RulesBasic_2_this_src_w_tag(void);
-void RulesBasic_2_this_src_w_component(void);
-void RulesBasic_2_this_src_ent_src_w_tag(void);
-void RulesBasic_2_this_src_ent_src_w_component(void);
-void RulesBasic_2_ent_src_this_src_w_tag(void);
-void RulesBasic_2_ent_src_this_src_w_component(void);
-void RulesBasic_recycled_tag(void);
-void RulesBasic_recycled_src(void);
-void RulesBasic_recycled_pair_rel(void);
-void RulesBasic_recycled_pair_tgt(void);
-void RulesBasic_this_src_w_wildcard(void);
-void RulesBasic_this_src_w_pair_rel_wildcard(void);
-void RulesBasic_this_src_w_pair_tgt_wildcard(void);
-void RulesBasic_this_src_w_pair_rel_tgt_wildcard(void);
-void RulesBasic_this_src_w_any(void);
-void RulesBasic_this_src_w_any_written(void);
-void RulesBasic_this_src_w_pair_rel_any(void);
-void RulesBasic_this_src_w_pair_tgt_any(void);
-void RulesBasic_this_src_w_pair_rel_tgt_any(void);
-void RulesBasic_ent_src_w_wildcard(void);
-void RulesBasic_ent_src_w_pair_rel_wildcard(void);
-void RulesBasic_ent_src_w_pair_tgt_wildcard(void);
-void RulesBasic_ent_src_w_pair_rel_tgt_wildcard(void);
-void RulesBasic_1_wildcard_src(void);
-void RulesBasic_1_wildcard_src_w_pair(void);
-void RulesBasic_2_wildcard_src(void);
-void RulesBasic_2_wildcard_src_w_pair(void);
-void RulesBasic_1_wildcard_src_w_pair_tgt_var(void);
-void RulesBasic_1_wildcard_src_w_pair_rel_var(void);
-void RulesBasic_1_wildcard_src_w_pair_tgt_this(void);
-void RulesBasic_1_wildcard_src_w_pair_rel_this(void);
-void RulesBasic_1_any_src(void);
-void RulesBasic_1_any_src_component(void);
-void RulesBasic_1_any_src_component_w_this_component(void);
-void RulesBasic_1_any_src_w_pair(void);
-void RulesBasic_2_any_src(void);
-void RulesBasic_2_any_src_w_pair(void);
-void RulesBasic_1_any_src_w_pair_tgt_var(void);
-void RulesBasic_1_any_src_w_pair_rel_var(void);
-void RulesBasic_1_any_src_w_pair_tgt_this(void);
-void RulesBasic_1_any_src_w_pair_rel_this(void);
-void RulesBasic_1_any_src_any_tgt_w_rel_fixed(void);
-void RulesBasic_1_any_src_any_rel_w_tgt_fixed(void);
-void RulesBasic_1_any_src_w_childof_pair_any_tgt(void);
-void RulesBasic_1_any_src_empty(void);
-void RulesBasic_1_any_src_pair_tgt_wildcard_empty(void);
-void RulesBasic_1_any_src_pair_rel_wildcard_empty(void);
-void RulesBasic_1_any_src_any_tgt_w_rel_fixed_empty(void);
-void RulesBasic_1_any_src_any_rel_w_tgt_fixed_empty(void);
-void RulesBasic_1_any_src_pair_w_tag_query_empty(void);
-void RulesBasic_1_any_src_tag_w_pair_query_empty(void);
-void RulesBasic_not_any(void);
-void RulesBasic_rule_w_iter_next(void);
-void RulesBasic_empty_rule(void);
-void RulesBasic_invalid_rule(void);
-void RulesBasic_not_instanced_table_src(void);
-void RulesBasic_not_instanced_entity_src(void);
-void RulesBasic_not_instanced_mixed_src(void);
-void RulesBasic_instanced_table_src(void);
-void RulesBasic_instanced_entity_src(void);
-void RulesBasic_instanced_mixed_src(void);
-void RulesBasic_in_term(void);
-void RulesBasic_out_term(void);
-void RulesBasic_inout_term(void);
-void RulesBasic_nodata_term(void);
-void RulesBasic_find_this_lowercase(void);
-void RulesBasic_find_this_uppercase(void);
-void RulesBasic_find_this_tgt_lowercase(void);
-void RulesBasic_find_this_tgt_uppercase(void);
-void RulesBasic_get_filter(void);
-void RulesBasic_iter_empty_source(void);
-void RulesBasic_iter_empty_source_2_terms(void);
-void RulesBasic_iter_empty_source_wildcard(void);
-void RulesBasic_iter_empty_source_pair(void);
-void RulesBasic_iter_empty_source_pair_wildcard(void);
-void RulesBasic_iter_empty_source_2_terms_pair(void);
-void RulesBasic_iter_empty_source_2_terms_mixed(void);
-void RulesBasic_iter_empty_source_2_terms_mixed_pair(void);
-void RulesBasic_iter_empty_source_2_terms_mixed_pair_wildcard(void);
-void RulesBasic_this_var_w_empty_entity(void);
-void RulesBasic_match_disabled(void);
-void RulesBasic_match_prefab(void);
-void RulesBasic_match_disabled_prefab(void);
-void RulesBasic_match_disabled_this_tgt(void);
-void RulesBasic_match_prefab_this_tgt(void);
-void RulesBasic_match_disabled_prefab_this_tgt(void);
-void RulesBasic_match_self_disabled(void);
-void RulesBasic_match_self_prefab(void);
-void RulesBasic_match_self_disabled_prefab(void);
-void RulesBasic_inout_none_first_term(void);
-void RulesBasic_inout_none_second_term(void);
-void RulesBasic_no_data_rule(void);
-void RulesBasic_frame_offset(void);
-void RulesBasic_frame_offset_no_data(void);
-void RulesBasic_match_empty_tables(void);
-void RulesBasic_match_empty_tables_no_data(void);
-void RulesBasic_match_empty_tables_w_not(void);
-void RulesBasic_match_empty_tables_w_wildcard(void);
-void RulesBasic_match_empty_tables_w_no_empty_tables(void);
-void RulesBasic_match_empty_tables_trivial(void);
-void RulesBasic_oneof_wildcard(void);
-void RulesBasic_oneof_any(void);
-void RulesBasic_instanced_w_singleton(void);
-void RulesBasic_instanced_w_base(void);
-void RulesBasic_not_instanced_w_singleton(void);
-void RulesBasic_not_instanced_w_base(void);
-void RulesBasic_unknown_before_known(void);
-void RulesBasic_unknown_before_known_after_or(void);
-void RulesBasic_unknown_before_known_after_not(void);
-void RulesBasic_unknown_before_known_after_optional(void);
-void RulesBasic_unknown_before_known_after_scope(void);
-void RulesBasic_reordered_plan_1(void);
-void RulesBasic_reordered_plan_2(void);
-void RulesBasic_1_trivial_plan(void);
-void RulesBasic_2_trivial_plan(void);
-void RulesBasic_1_trivial_plan_component(void);
-void RulesBasic_2_trivial_plan_component(void);
-void RulesBasic_2_trivial_plan_w_wildcard(void);
-void RulesBasic_3_trivial_plan_w_pair(void);
-void RulesBasic_3_trivial_plan_w_wildcard(void);
-void RulesBasic_3_trivial_plan_w_any(void);
-void RulesBasic_3_trivial_plan_w_pair_component(void);
-void RulesBasic_3_trivial_plan_w_wildcard_component(void);
-void RulesBasic_3_trivial_plan_w_any_component(void);
-void RulesBasic_1_trivial_component_w_none(void);
-void RulesBasic_2_trivial_component_w_none(void);
-void RulesBasic_2_trivial_mixed_2_tables(void);
-void RulesBasic_2_trivial_mixed_2_tables_component(void);
-void RulesBasic_2_trivial_mixed_2_tables_wildcard(void);
-void RulesBasic_1_plan_any_src(void);
-void RulesBasic_1_plan_not_any_src(void);
-void RulesBasic_1_plan_optional_any_src(void);
-
-// Testsuite 'RulesVariables'
-void RulesVariables_1_ent_src_w_var(void);
-void RulesVariables_1_ent_src_w_pair_rel_var(void);
-void RulesVariables_1_ent_src_w_pair_tgt_var(void);
-void RulesVariables_1_ent_src_w_pair_rel_tgt_var(void);
-void RulesVariables_1_ent_src_w_pair_rel_tgt_same_var(void);
-void RulesVariables_1_ent_src_w_pair_rel_tgt_same_var_after_write(void);
-void RulesVariables_1_this_src_w_var(void);
-void RulesVariables_1_this_src_w_pair_rel_var(void);
-void RulesVariables_1_this_src_w_pair_tgt_var(void);
-void RulesVariables_1_this_src_w_pair_rel_tgt_var(void);
-void RulesVariables_1_this_src_w_pair_rel_tgt_same_var(void);
-void RulesVariables_1_this_src_w_pair_rel_tgt_same_var_after_write(void);
-void RulesVariables_1_src_id_same_var(void);
-void RulesVariables_1_src_pair_first_same_var(void);
-void RulesVariables_1_src_pair_second_same_var(void);
-void RulesVariables_1_src_pair_first_and_second_same_var(void);
-void RulesVariables_1_src_id_same_var_after_write(void);
-void RulesVariables_1_src_pair_first_same_var_after_write(void);
-void RulesVariables_1_src_pair_second_same_var_after_write(void);
-void RulesVariables_1_src_pair_first_and_second_same_var_after_write(void);
-void RulesVariables_1_src_pair_first_same_var_this(void);
-void RulesVariables_1_src_pair_second_same_var_this(void);
-void RulesVariables_1_src_pair_first_and_second_same_var_this(void);
-void RulesVariables_1_src_id_same_var_this_after_write(void);
-void RulesVariables_1_src_pair_first_same_var_this_after_write(void);
-void RulesVariables_1_src_pair_second_same_var_this_after_write(void);
-void RulesVariables_1_src_pair_first_and_second_same_var_this_after_write(void);
-void RulesVariables_1_ent_src_w_this_var(void);
-void RulesVariables_1_ent_src_w_pair_this_rel(void);
-void RulesVariables_1_ent_src_w_pair_this_tgt(void);
-void RulesVariables_1_ent_src_w_pair_this_rel_tgt(void);
-void RulesVariables_1_this_src_w_this(void);
-void RulesVariables_1_this_src_w_pair_this_rel_tgt(void);
-void RulesVariables_1_this_src_w_this_after_write(void);
-void RulesVariables_1_this_src_w_pair_this_rel_tgt_after_write(void);
-void RulesVariables_2_constrain_src_from_src(void);
-void RulesVariables_2_constrain_rel_from_src_w_ent(void);
-void RulesVariables_2_constrain_rel_from_src_w_var(void);
-void RulesVariables_2_constrain_rel_from_src_w_this(void);
-void RulesVariables_2_constrain_pair_rel_from_src_w_ent(void);
-void RulesVariables_2_constrain_pair_rel_from_src_w_var(void);
-void RulesVariables_2_constrain_pair_rel_from_src_w_this(void);
-void RulesVariables_2_constrain_pair_tgt_from_src_w_ent(void);
-void RulesVariables_2_constrain_pair_tgt_from_src_w_var(void);
-void RulesVariables_2_constrain_pair_tgt_from_src_w_this(void);
-void RulesVariables_2_constrain_pair_rel_tgt_from_src_w_ent(void);
-void RulesVariables_2_constrain_pair_rel_tgt_from_src_w_var(void);
-void RulesVariables_2_constrain_pair_rel_tgt_from_src_w_this(void);
-void RulesVariables_1_ent_src_set_rel_var(void);
-void RulesVariables_1_ent_src_set_pair_rel_var(void);
-void RulesVariables_1_ent_src_set_pair_tgt_var(void);
-void RulesVariables_1_set_src_var(void);
-void RulesVariables_1_set_src_var_w_pair(void);
-void RulesVariables_1_set_src_var_w_pair_set_rel(void);
-void RulesVariables_1_set_src_var_w_pair_set_tgt(void);
-void RulesVariables_1_set_src_var_w_pair_set_rel_tgt(void);
-void RulesVariables_1_set_src_this(void);
-void RulesVariables_1_set_src_this_w_pair(void);
-void RulesVariables_1_set_src_this_w_pair_set_rel(void);
-void RulesVariables_1_set_src_this_w_pair_set_tgt(void);
-void RulesVariables_1_set_src_this_w_pair_set_rel_tgt(void);
-void RulesVariables_1_set_src_this_to_empty_table(void);
-void RulesVariables_1_set_src_this_to_empty_table_w_component(void);
-void RulesVariables_1_set_src_this_to_empty_table_w_component_self(void);
-void RulesVariables_1_set_src_this_to_entiy_in_table(void);
-void RulesVariables_1_set_src_this_to_entiy_in_table_self(void);
-void RulesVariables_2_set_src_this(void);
-void RulesVariables_2_set_src_this_self(void);
-void RulesVariables_2_set_src_this_component(void);
-void RulesVariables_2_set_src_this_self_component(void);
-void RulesVariables_2_set_src_this_w_up(void);
-void RulesVariables_2_set_src_this_self_w_up(void);
-void RulesVariables_2_set_src_this_component_w_up(void);
-void RulesVariables_2_set_src_this_self_component_w_up(void);
-void RulesVariables_2_set_src_this_w_exclusive_wildcard(void);
-void RulesVariables_2_set_src_this_self_w_exclusive_wildcard(void);
-void RulesVariables_1_src_this_var_as_entity(void);
-void RulesVariables_1_src_this_var_as_table(void);
-void RulesVariables_1_src_this_var_as_table_range(void);
-void RulesVariables_2_join_by_rel_var(void);
-void RulesVariables_2_join_by_pair_rel_var(void);
-void RulesVariables_2_join_by_pair_tgt_var(void);
-void RulesVariables_2_cycle_w_var(void);
-void RulesVariables_2_cycle_w_this_var(void);
-void RulesVariables_2_cycle_w_var_this(void);
-void RulesVariables_2_cycle_pair_w_var(void);
-void RulesVariables_2_cycle_pair_w_this_var_var(void);
-void RulesVariables_2_cycle_pair_w_var_this_var(void);
-void RulesVariables_2_cycle_pair_w_var_var_this(void);
-void RulesVariables_2_cycle_pair_ent_var_var(void);
-void RulesVariables_2_cycle_pair_ent_this_var(void);
-void RulesVariables_2_cycle_pair_ent_var_this(void);
-void RulesVariables_parse_0_var(void);
-void RulesVariables_parse_1_var(void);
-void RulesVariables_parse_2_vars(void);
-void RulesVariables_parse_0_var_paren(void);
-void RulesVariables_parse_1_var_paren(void);
-void RulesVariables_parse_2_vars_paren(void);
-void RulesVariables_parse_1_vars_w_path(void);
-void RulesVariables_parse_missing_close_paren(void);
-void RulesVariables_parse_missing_open_paren(void);
-void RulesVariables_parse_missing_value(void);
-void RulesVariables_parse_0_var_w_spaces(void);
-void RulesVariables_parse_1_var_w_spaces(void);
-void RulesVariables_parse_2_vars_w_spaces(void);
-void RulesVariables_parse_0_var_paren_w_spaces(void);
-void RulesVariables_parse_1_var_paren_w_spaces(void);
-void RulesVariables_parse_2_vars_paren_w_spaces(void);
-void RulesVariables_var_count(void);
-void RulesVariables_var_name(void);
-void RulesVariables_var_is_entity(void);
-void RulesVariables_no_this_anonymous_src(void);
-void RulesVariables_no_this_anonymous_src_w_pair(void);
-void RulesVariables_no_this_anonymous_component_src(void);
-void RulesVariables_no_this_anonymous_component_src_w_pair(void);
-void RulesVariables_lookup_from_table_this(void);
-void RulesVariables_lookup_from_entity_this(void);
-void RulesVariables_lookup_from_table(void);
-void RulesVariables_lookup_from_entity(void);
-void RulesVariables_lookup_from_not_written(void);
-void RulesVariables_lookup_from_table_this_component(void);
-void RulesVariables_lookup_from_entity_this_component(void);
-void RulesVariables_lookup_from_table_component(void);
-void RulesVariables_lookup_from_entity_component(void);
-void RulesVariables_lookup_from_table_two_children(void);
-void RulesVariables_lookup_from_entity_two_children(void);
-void RulesVariables_lookup_from_table_same_child_twice(void);
-void RulesVariables_lookup_from_entity_same_child_twice(void);
-void RulesVariables_lookup_from_table_not(void);
-void RulesVariables_lookup_from_entity_not(void);
-void RulesVariables_lookup_from_table_w_any_component(void);
-void RulesVariables_lookup_from_entity_w_any_component(void);
-void RulesVariables_lookup_as_tag(void);
-void RulesVariables_lookup_as_relationship(void);
-void RulesVariables_lookup_as_target(void);
-void RulesVariables_lookup_assign_var(void);
-void RulesVariables_lookup_eq_var(void);
-void RulesVariables_lookup_neq_var(void);
-void RulesVariables_lookup_unresolved_dependent(void);
-void RulesVariables_check_vars_this(void);
-void RulesVariables_check_vars_var(void);
-void RulesVariables_check_vars_wildcard(void);
-void RulesVariables_check_vars_any(void);
-void RulesVariables_check_vars_var_as_tgt(void);
-void RulesVariables_check_vars_this_as_tgt(void);
-void RulesVariables_check_vars_anonymous_var_as_tgt(void);
-void RulesVariables_check_vars_wildcard_as_tgt(void);
-void RulesVariables_check_vars_any_as_tgt(void);
-void RulesVariables_check_vars_this_w_lookup_var(void);
-void RulesVariables_check_vars_var_w_lookup_var(void);
-void RulesVariables_1_trivial_1_var(void);
-void RulesVariables_2_trivial_1_var(void);
-void RulesVariables_1_trivial_1_var_component(void);
-void RulesVariables_2_trivial_1_var_component(void);
-void RulesVariables_1_trivial_1_wildcard(void);
-void RulesVariables_2_trivial_1_wildcard(void);
-void RulesVariables_1_trivial_1_wildcard_component(void);
-void RulesVariables_2_trivial_1_wildcard_component(void);
-void RulesVariables_1_trivial_1_any(void);
-void RulesVariables_2_trivial_1_any(void);
-void RulesVariables_1_trivial_1_any_component(void);
-void RulesVariables_2_trivial_1_any_component(void);
-
-// Testsuite 'RulesOperators'
-void RulesOperators_2_and_not(void);
-void RulesOperators_3_and_not_not(void);
-void RulesOperators_2_and_not_pair_rel_wildcard(void);
-void RulesOperators_2_and_not_pair_tgt_wildcard(void);
-void RulesOperators_2_and_not_pair_rel_tgt_wildcard(void);
-void RulesOperators_2_and_not_pair_rel_var(void);
-void RulesOperators_2_and_not_pair_tgt_var(void);
-void RulesOperators_2_and_not_pair_rel_tgt_var(void);
-void RulesOperators_2_and_not_pair_rel_tgt_same_var(void);
-void RulesOperators_2_and_not_pair_rel_var_written(void);
-void RulesOperators_2_and_not_pair_tgt_var_written(void);
-void RulesOperators_2_and_not_pair_rel_tgt_var_written(void);
-void RulesOperators_2_and_not_pair_rel_tgt_same_var_written(void);
-void RulesOperators_2_and_not_pair_rel_src_tgt_same_var_written(void);
-void RulesOperators_2_and_not_pair_any_rel(void);
-void RulesOperators_2_and_not_pair_any_tgt(void);
-void RulesOperators_2_and_not_pair_any_src(void);
-void RulesOperators_1_not_any_src_fixed_first(void);
-void RulesOperators_1_not_any_src_any_tgt_fixed_first(void);
-void RulesOperators_1_not_any_src_any_first_fixed_tgt(void);
-void RulesOperators_1_not_any_src_any_childof_pair_any_tgt(void);
-void RulesOperators_1_not_any_src_any_isa_pair_any_tgt(void);
-void RulesOperators_2_and_optional(void);
-void RulesOperators_3_and_optional_optional(void);
-void RulesOperators_2_and_optional_pair_rel_wildcard(void);
-void RulesOperators_2_and_optional_pair_tgt_wildcard(void);
-void RulesOperators_2_and_optional_pair_rel_var(void);
-void RulesOperators_2_and_optional_pair_tgt_var(void);
-void RulesOperators_2_and_optional_pair_rel_tgt_var(void);
-void RulesOperators_2_and_optional_pair_rel_tgt_same_var(void);
-void RulesOperators_2_and_optional_pair_rel_var_written(void);
-void RulesOperators_2_and_optional_pair_tgt_var_written(void);
-void RulesOperators_2_and_optional_pair_rel_tgt_var_written(void);
-void RulesOperators_2_and_optional_pair_rel_tgt_same_var_written(void);
-void RulesOperators_2_and_optional_pair_rel_src_tgt_same_var_written(void);
-void RulesOperators_3_and_optional_optional_pair_w_var(void);
-void RulesOperators_2_and_optional_pair_any_rel(void);
-void RulesOperators_2_and_optional_pair_any_tgt(void);
-void RulesOperators_2_and_optional_pair_any_src(void);
-void RulesOperators_3_and_optional_dependent_and_pair_rel(void);
-void RulesOperators_3_and_optional_dependent_and_pair_tgt(void);
-void RulesOperators_3_and_optional_dependent_and_pair_rel_tgt(void);
-void RulesOperators_3_and_optional_dependent_and_pair_rel_tgt_same_var(void);
-void RulesOperators_3_and_optional_dependent_and_pair_rel_tgt_same_other_var(void);
-void RulesOperators_3_and_optional_dependent_and_pair_src(void);
-void RulesOperators_3_and_optional_dependent_optional_pair_rel(void);
-void RulesOperators_3_and_optional_dependent_optional_pair_tgt(void);
-void RulesOperators_3_and_optional_dependent_optional_pair_src(void);
-void RulesOperators_3_and_optional_dependent_not_pair_rel(void);
-void RulesOperators_3_and_optional_dependent_not_pair_tgt(void);
-void RulesOperators_3_and_optional_dependent_not_pair_src(void);
-void RulesOperators_1_optional_any_src_fixed_first(void);
-void RulesOperators_1_optional_any_src_any_tgt_fixed_first(void);
-void RulesOperators_1_optional_any_src_any_first_fixed_tgt(void);
-void RulesOperators_1_optional_any_src_any_childof_pair_any_tgt(void);
-void RulesOperators_1_optional_any_src_any_isa_pair_any_tgt(void);
-void RulesOperators_2_or(void);
-void RulesOperators_3_or(void);
-void RulesOperators_2_or_written(void);
-void RulesOperators_3_or_written(void);
-void RulesOperators_2_or_written_w_rel_var(void);
-void RulesOperators_3_or_written_w_rel_var(void);
-void RulesOperators_2_or_written_w_tgt_var(void);
-void RulesOperators_2_or_written_w_rel_tgt_var(void);
-void RulesOperators_2_or_written_w_rel_tgt_same_var(void);
-void RulesOperators_3_or_written_w_tgt_var(void);
-void RulesOperators_2_or_chains(void);
-void RulesOperators_2_or_chains_written(void);
-void RulesOperators_2_or_dependent(void);
-void RulesOperators_2_or_dependent_reverse(void);
-void RulesOperators_2_or_dependent_2_vars(void);
-void RulesOperators_2_or_written_dependent(void);
-void RulesOperators_2_or_written_dependent_2_vars(void);
-void RulesOperators_2_or_w_dependent(void);
-void RulesOperators_2_or_w_both(void);
-void RulesOperators_3_or_w_both(void);
-void RulesOperators_2_not_first(void);
-void RulesOperators_2_optional_first(void);
-void RulesOperators_root_entities_empty(void);
-void RulesOperators_root_entities(void);
-void RulesOperators_root_entities_w_children(void);
-void RulesOperators_root_entities_w_optional_children(void);
-void RulesOperators_core_entities_w_optional_children(void);
-void RulesOperators_root_entities_w_not_children(void);
-void RulesOperators_core_entities_w_not_children(void);
-void RulesOperators_1_ent_src_not(void);
-void RulesOperators_1_ent_src_not_pair(void);
-void RulesOperators_1_ent_src_not_pair_rel_wildcard(void);
-void RulesOperators_1_ent_src_not_pair_tgt_wildcard(void);
-void RulesOperators_1_ent_src_not_pair_rel_tgt_wildcard(void);
-void RulesOperators_1_ent_src_not_pair_rel_any(void);
-void RulesOperators_1_ent_src_not_pair_tgt_any(void);
-void RulesOperators_1_ent_src_not_pair_rel_tgt_any(void);
-void RulesOperators_1_ent_src_not_pair_rel_var(void);
-void RulesOperators_1_ent_src_not_pair_tgt_var(void);
-void RulesOperators_1_ent_src_not_pair_rel_tgt_var(void);
-void RulesOperators_1_ent_src_not_pair_rel_tgt_same_var(void);
-void RulesOperators_1_this_src_not_pair_rel_var(void);
-void RulesOperators_1_this_src_not_pair_tgt_var(void);
-void RulesOperators_1_this_src_not_pair_rel_tgt_var(void);
-void RulesOperators_1_this_src_not_pair_rel_tgt_same_var(void);
-void RulesOperators_1_ent_src_not_pair_rel_var_written(void);
-void RulesOperators_1_ent_src_not_pair_tgt_var_written(void);
-void RulesOperators_1_ent_src_not_pair_rel_tgt_var_written(void);
-void RulesOperators_1_ent_src_not_pair_rel_tgt_same_var_written(void);
-
-// Testsuite 'RulesTransitive'
-void RulesTransitive_1_fact_0_lvl_true(void);
-void RulesTransitive_1_fact_1_lvl_true(void);
-void RulesTransitive_1_fact_2_lvl_true(void);
-void RulesTransitive_1_fact_0_lvl_false(void);
-void RulesTransitive_1_fact_1_lvl_false(void);
-void RulesTransitive_1_fact_2_lvl_false(void);
-void RulesTransitive_1_fact_reflexive(void);
-void RulesTransitive_1_this_src_written_0_lvl(void);
-void RulesTransitive_1_this_src_written_1_lvl(void);
-void RulesTransitive_1_this_src_written_2_lvl(void);
-void RulesTransitive_1_this_src_written_reflexive(void);
-void RulesTransitive_1_this_src_0_lvl(void);
-void RulesTransitive_1_this_src_1_lvl(void);
-void RulesTransitive_1_this_src_2_lvl(void);
-void RulesTransitive_1_this_src_reflexive(void);
-void RulesTransitive_1_ent_src_tgt_var_0_lvl(void);
-void RulesTransitive_1_ent_src_tgt_var_1_lvl(void);
-void RulesTransitive_1_ent_src_tgt_var_2_lvl(void);
-void RulesTransitive_1_ent_src_tgt_var_reflexive(void);
-void RulesTransitive_1_this_src_tgt_var(void);
-void RulesTransitive_1_this_src_tgt_var_reflexive(void);
-void RulesTransitive_1_var_src_written_0_lvl(void);
-void RulesTransitive_1_var_src_written_1_lvl(void);
-void RulesTransitive_1_var_src_written_2_lvl(void);
-void RulesTransitive_1_var_src_written_reflexive(void);
-void RulesTransitive_1_var_src_0_lvl(void);
-void RulesTransitive_1_var_src_1_lvl(void);
-void RulesTransitive_1_var_src_2_lvl(void);
-void RulesTransitive_1_var_src_reflexive(void);
-void RulesTransitive_1_var_src_tgt_var(void);
-void RulesTransitive_1_var_src_tgt_var_reflexive(void);
-void RulesTransitive_1_ent_src_tgt_this_0_lvl(void);
-void RulesTransitive_1_ent_src_tgt_this_1_lvl(void);
-void RulesTransitive_1_ent_src_tgt_this_2_lvl(void);
-void RulesTransitive_1_ent_src_tgt_this_reflexive(void);
-void RulesTransitive_1_var_src_tgt_this(void);
-void RulesTransitive_1_var_src_tgt_this_reflexive(void);
-void RulesTransitive_2_ent_src_constrain_tgt_var_before_0_lvl(void);
-void RulesTransitive_2_ent_src_constrain_tgt_var_before_1_lvl(void);
-void RulesTransitive_2_ent_src_constrain_tgt_var_before_2_lvl(void);
-void RulesTransitive_2_ent_src_constrain_tgt_var_after_0_lvl(void);
-void RulesTransitive_2_ent_src_constrain_tgt_var_after_1_lvl(void);
-void RulesTransitive_2_ent_src_constrain_tgt_var_after_2_lvl(void);
-void RulesTransitive_2_this_src_constrain_tgt_var_before_0_lvl(void);
-void RulesTransitive_2_this_src_constrain_tgt_var_before_1_lvl(void);
-void RulesTransitive_2_this_src_constrain_tgt_var_before_2_lvl(void);
-void RulesTransitive_2_this_src_constrain_tgt_var_after_0_lvl(void);
-void RulesTransitive_2_this_src_constrain_tgt_var_after_1_lvl(void);
-void RulesTransitive_2_this_src_constrain_tgt_var_after_2_lvl(void);
-void RulesTransitive_1_src_tgt_same_var(void);
-void RulesTransitive_1_src_tgt_same_var_reflexive(void);
-void RulesTransitive_1_src_tgt_same_this_var_reflexive(void);
-void RulesTransitive_1_any_src_tgt_var(void);
-void RulesTransitive_not_transitive_ent_tgt(void);
-void RulesTransitive_not_transitive_var_tgt(void);
-void RulesTransitive_not_transitive_ent_tgt_written(void);
-void RulesTransitive_not_transitive_var_tgt_written(void);
-void RulesTransitive_optional_transitive_ent_tgt(void);
-void RulesTransitive_optional_transitive_var_tgt(void);
-void RulesTransitive_optional_transitive_ent_tgt_written(void);
-void RulesTransitive_optional_transitive_var_tgt_written(void);
-void RulesTransitive_2_var_src_w_same_tgt_ent(void);
-void RulesTransitive_self_target(void);
-void RulesTransitive_any_target(void);
-
-// Testsuite 'RulesComponentInheritance'
-void RulesComponentInheritance_1_ent_0_lvl(void);
-void RulesComponentInheritance_1_ent_1_lvl(void);
-void RulesComponentInheritance_1_ent_2_lvl(void);
-void RulesComponentInheritance_1_ent_3_lvl(void);
-void RulesComponentInheritance_1_this_0_lvl(void);
-void RulesComponentInheritance_1_this_1_lvl(void);
-void RulesComponentInheritance_1_this_2_lvl(void);
-void RulesComponentInheritance_1_this_3_lvl(void);
-void RulesComponentInheritance_1_this_0_lvl_written(void);
-void RulesComponentInheritance_1_this_1_lvl_written(void);
-void RulesComponentInheritance_1_this_2_lvl_written(void);
-void RulesComponentInheritance_1_this_3_lvl_written(void);
-void RulesComponentInheritance_1_var_0_lvl(void);
-void RulesComponentInheritance_1_var_1_lvl(void);
-void RulesComponentInheritance_1_var_2_lvl(void);
-void RulesComponentInheritance_1_var_3_lvl(void);
-void RulesComponentInheritance_1_var_0_lvl_written(void);
-void RulesComponentInheritance_1_var_1_lvl_written(void);
-void RulesComponentInheritance_1_var_2_lvl_written(void);
-void RulesComponentInheritance_1_var_3_lvl_written(void);
-void RulesComponentInheritance_1_ent_1_lvl_self(void);
-void RulesComponentInheritance_1_this_1_lvl_self(void);
-void RulesComponentInheritance_1_this_1_lvl_written_self(void);
-void RulesComponentInheritance_1_var_1_lvl_self(void);
-void RulesComponentInheritance_1_var_1_lvl_written_self(void);
-void RulesComponentInheritance_1_ent_src_not(void);
-void RulesComponentInheritance_1_this_src_not(void);
-void RulesComponentInheritance_1_var_src_not(void);
-void RulesComponentInheritance_1_this_src_not_written(void);
-void RulesComponentInheritance_1_var_src_not_written(void);
-void RulesComponentInheritance_first_self(void);
-void RulesComponentInheritance_first_down(void);
-void RulesComponentInheritance_first_self_down(void);
-void RulesComponentInheritance_first_rel_self(void);
-void RulesComponentInheritance_first_rel_down(void);
-void RulesComponentInheritance_first_rel_self_down(void);
-
-// Testsuite 'RulesRecycled'
-void RulesRecycled_recycled_vars(void);
-void RulesRecycled_recycled_pair_vars(void);
-void RulesRecycled_recycled_this_ent_var(void);
-void RulesRecycled_has_recycled_id_from_pair(void);
-
-// Testsuite 'RulesBuiltinPredicates'
-void RulesBuiltinPredicates_this_eq_id(void);
-void RulesBuiltinPredicates_this_eq_name(void);
-void RulesBuiltinPredicates_this_eq_var(void);
-void RulesBuiltinPredicates_this_eq_id_written(void);
-void RulesBuiltinPredicates_this_eq_id_written_no_match(void);
-void RulesBuiltinPredicates_this_eq_name_written(void);
-void RulesBuiltinPredicates_this_eq_name_written_no_match(void);
-void RulesBuiltinPredicates_this_eq_var_written(void);
-void RulesBuiltinPredicates_var_eq_id(void);
-void RulesBuiltinPredicates_var_eq_name(void);
-void RulesBuiltinPredicates_var_eq_var(void);
-void RulesBuiltinPredicates_var_eq_id_written(void);
-void RulesBuiltinPredicates_var_eq_id_written_no_match(void);
-void RulesBuiltinPredicates_var_eq_name_written(void);
-void RulesBuiltinPredicates_var_eq_name_written_no_match(void);
-void RulesBuiltinPredicates_var_eq_var_written(void);
-void RulesBuiltinPredicates_var_eq_this(void);
-void RulesBuiltinPredicates_this_neq_id(void);
-void RulesBuiltinPredicates_this_neq_name(void);
-void RulesBuiltinPredicates_this_neq_var(void);
-void RulesBuiltinPredicates_this_neq_id_written(void);
-void RulesBuiltinPredicates_this_neq_id_written_no_match(void);
-void RulesBuiltinPredicates_this_neq_name_written(void);
-void RulesBuiltinPredicates_this_neq_name_written_no_match(void);
-void RulesBuiltinPredicates_this_neq_var_written(void);
-void RulesBuiltinPredicates_var_neq_id(void);
-void RulesBuiltinPredicates_var_neq_name(void);
-void RulesBuiltinPredicates_var_neq_var(void);
-void RulesBuiltinPredicates_var_neq_id_written(void);
-void RulesBuiltinPredicates_var_neq_id_written_no_match(void);
-void RulesBuiltinPredicates_var_neq_name_written(void);
-void RulesBuiltinPredicates_var_neq_name_written_no_match(void);
-void RulesBuiltinPredicates_var_neq_var_written(void);
-void RulesBuiltinPredicates_var_neq_this(void);
-void RulesBuiltinPredicates_this_2_neq_id(void);
-void RulesBuiltinPredicates_this_2_neq_name(void);
-void RulesBuiltinPredicates_var_2_neq_id(void);
-void RulesBuiltinPredicates_var_2_neq_name(void);
-void RulesBuiltinPredicates_this_2_neq_id_written(void);
-void RulesBuiltinPredicates_this_2_neq_name_written(void);
-void RulesBuiltinPredicates_var_2_neq_id_written(void);
-void RulesBuiltinPredicates_var_2_neq_name_written(void);
-void RulesBuiltinPredicates_this_2_or_id(void);
-void RulesBuiltinPredicates_this_2_or_name(void);
-void RulesBuiltinPredicates_var_2_or_id(void);
-void RulesBuiltinPredicates_var_2_or_name(void);
-void RulesBuiltinPredicates_this_2_or_id_written(void);
-void RulesBuiltinPredicates_this_2_or_name_written(void);
-void RulesBuiltinPredicates_var_2_or_id_written(void);
-void RulesBuiltinPredicates_var_2_or_name_written(void);
-void RulesBuiltinPredicates_this_match_eq(void);
-void RulesBuiltinPredicates_var_match_eq(void);
-void RulesBuiltinPredicates_this_match_eq_written(void);
-void RulesBuiltinPredicates_this_match_eq_written_self(void);
-void RulesBuiltinPredicates_var_match_eq_written(void);
-void RulesBuiltinPredicates_this_match_neq(void);
-void RulesBuiltinPredicates_var_match_neq(void);
-void RulesBuiltinPredicates_this_match_neq_written(void);
-void RulesBuiltinPredicates_var_match_neq_written(void);
-void RulesBuiltinPredicates_this_match_2_neq(void);
-void RulesBuiltinPredicates_var_match_2_neq(void);
-void RulesBuiltinPredicates_this_match_2_neq_written(void);
-void RulesBuiltinPredicates_var_match_2_neq_written(void);
-void RulesBuiltinPredicates_this_match_2_or(void);
-void RulesBuiltinPredicates_this_match_2_or_written(void);
-void RulesBuiltinPredicates_this_match_3_or(void);
-void RulesBuiltinPredicates_this_match_3_or_written(void);
-void RulesBuiltinPredicates_unresolved_by_name(void);
-void RulesBuiltinPredicates_var_eq_wildcard(void);
-void RulesBuiltinPredicates_var_eq_any(void);
-void RulesBuiltinPredicates_var_eq_wildcard_after_write(void);
-void RulesBuiltinPredicates_var_eq_any_after_write(void);
-void RulesBuiltinPredicates_var_eq_after_var_0_src(void);
-void RulesBuiltinPredicates_2_or_w_eq_this(void);
-void RulesBuiltinPredicates_2_or_w_eq_lookup_var(void);
-void RulesBuiltinPredicates_3_or_w_eq_lookup_var(void);
-void RulesBuiltinPredicates_unwritten_var_error_neq(void);
-void RulesBuiltinPredicates_unwritten_var_error_match(void);
-
-// Testsuite 'RulesScopes'
-void RulesScopes_term_w_not_scope_1_term(void);
-void RulesScopes_term_w_not_scope_2_terms(void);
-void RulesScopes_term_w_not_scope_1_term_w_not(void);
-void RulesScopes_term_w_not_scope_2_terms_w_not(void);
-void RulesScopes_term_w_not_scope_1_term_w_var(void);
-void RulesScopes_term_w_not_scope_2_terms_w_var(void);
-void RulesScopes_term_w_not_scope_1_term_w_not_w_var(void);
-void RulesScopes_term_w_not_scope_2_terms_w_not_w_var(void);
-void RulesScopes_term_w_not_scope_2_terms_w_or(void);
-void RulesScopes_term_w_not_scope_3_terms_w_or(void);
-
-// Testsuite 'RulesTraversal'
-void RulesTraversal_this_self_up_childof(void);
-void RulesTraversal_this_up_childof(void);
-void RulesTraversal_this_written_self_up_childof(void);
-void RulesTraversal_this_written_up_childof(void);
-void RulesTraversal_var_self_up_childof(void);
-void RulesTraversal_var_up_childof(void);
-void RulesTraversal_var_written_self_up_childof(void);
-void RulesTraversal_var_written_up_childof(void);
-void RulesTraversal_set_var_self_up_childof(void);
-void RulesTraversal_set_var_up_childof(void);
-void RulesTraversal_set_var_written_self_up_childof(void);
-void RulesTraversal_set_var_written_up_childof(void);
-void RulesTraversal_ent_self_up_childof(void);
-void RulesTraversal_ent_up_childof(void);
-void RulesTraversal_implicit_this_self_up_isa(void);
-void RulesTraversal_implicit_this_up_isa(void);
-void RulesTraversal_implicit_var_self_up_isa(void);
-void RulesTraversal_implicit_var_up_isa(void);
-void RulesTraversal_implicit_ent_self_up_isa(void);
-void RulesTraversal_implicit_ent_up_isa(void);
-void RulesTraversal_self_up_2_targets(void);
-void RulesTraversal_up_2_targets(void);
-void RulesTraversal_self_up_2_targets_diamond(void);
-void RulesTraversal_up_2_targets_diamond(void);
-void RulesTraversal_written_self_up_2_targets(void);
-void RulesTraversal_written_up_2_targets(void);
-void RulesTraversal_written_self_up_2_targets_diamond(void);
-void RulesTraversal_written_up_2_targets_diamond(void);
-void RulesTraversal_2_self_up_terms(void);
-void RulesTraversal_2_self_up_terms_2_targets(void);
-void RulesTraversal_self_up_empty_table(void);
-void RulesTraversal_up_empty_table(void);
-void RulesTraversal_self_up_all_owned(void);
-void RulesTraversal_up_all_owned(void);
-void RulesTraversal_this_self_up_childof_inherited(void);
-void RulesTraversal_this_up_childof_inherited(void);
-void RulesTraversal_this_written_self_up_childof_inherited(void);
-void RulesTraversal_this_written_up_childof_inherited(void);
-void RulesTraversal_var_self_up_childof_inherited(void);
-void RulesTraversal_var_up_childof_inherited(void);
-void RulesTraversal_var_written_self_up_childof_inherited(void);
-void RulesTraversal_var_written_up_childof_inherited(void);
-void RulesTraversal_ent_self_up_childof_inherited(void);
-void RulesTraversal_ent_up_childof_inherited(void);
-void RulesTraversal_ent_written_self_up_childof_inherited(void);
-void RulesTraversal_ent_written_up_childof_inherited(void);
-void RulesTraversal_this_self_up_childof_component(void);
-void RulesTraversal_this_up_childof_component(void);
-void RulesTraversal_this_written_self_up_childof_component(void);
-void RulesTraversal_this_written_up_childof_component(void);
-void RulesTraversal_var_self_up_childof_component(void);
-void RulesTraversal_var_up_childof_component(void);
-void RulesTraversal_var_written_self_up_childof_component(void);
-void RulesTraversal_var_written_up_childof_component(void);
-void RulesTraversal_this_self_up_childof_recycled_parent(void);
-void RulesTraversal_this_up_childof_recycled_parent(void);
-void RulesTraversal_this_written_self_up_childof_recycled_parent(void);
-void RulesTraversal_this_written_up_childof_recycled_parent(void);
-void RulesTraversal_this_self_up_childof_recycled_parent_component(void);
-void RulesTraversal_this_up_childof_recycled_parent_component(void);
-void RulesTraversal_this_written_self_up_childof_recycled_parent_component(void);
-void RulesTraversal_this_written_up_childof_recycled_parent_component(void);
-void RulesTraversal_this_self_up_childof_pair(void);
-void RulesTraversal_this_up_childof_pair(void);
-void RulesTraversal_this_written_self_up_childof_pair(void);
-void RulesTraversal_this_written_up_childof_pair(void);
-void RulesTraversal_this_self_up_childof_pair_wildcard(void);
-void RulesTraversal_this_up_childof_pair_wildcard(void);
-void RulesTraversal_this_written_self_up_childof_pair_wildcard(void);
-void RulesTraversal_this_written_up_childof_pair_wildcard(void);
-void RulesTraversal_this_self_up_childof_pair_tgt_var(void);
-void RulesTraversal_this_written_self_up_childof_pair_tgt_var(void);
-void RulesTraversal_this_self_up_childof_pair_rel_var(void);
-void RulesTraversal_this_written_self_up_childof_pair_rel_var(void);
-void RulesTraversal_this_self_up_childof_pair_for_var_written(void);
-void RulesTraversal_this_up_childof_pair_for_var_written(void);
-void RulesTraversal_this_written_self_up_childof_pair_for_var_written(void);
-void RulesTraversal_this_self_up_childof_pair_for_var_written_n_targets(void);
-void RulesTraversal_this_written_self_up_childof_pair_for_var_written_n_targets(void);
-void RulesTraversal_self_up_2_levels(void);
-void RulesTraversal_not_up_disabled(void);
-void RulesTraversal_up_2_rel_instances(void);
-void RulesTraversal_up_2_rel_instances_match_2nd(void);
-void RulesTraversal_up_only_w_owned(void);
-void RulesTraversal_this_self_cascade_childof(void);
-void RulesTraversal_this_cascade_childof(void);
-void RulesTraversal_this_written_self_cascade_childof(void);
-void RulesTraversal_this_written_cascade_childof(void);
-void RulesTraversal_this_self_cascade_childof_w_parent_flag(void);
-void RulesTraversal_this_cascade_childof_w_parent_flag(void);
-void RulesTraversal_this_written_self_cascade_childof_w_parent_flag(void);
-void RulesTraversal_this_written_cascade_childof_w_parent_flag(void);
+void SystemMisc_system_no_id_in_scope(void);
 
 // Testsuite 'SystemPeriodic'
 void SystemPeriodic_1_type_1_component(void);
@@ -1493,7 +254,6 @@ void SystemCascade_custom_relation_adopt_after_match(void);
 // Testsuite 'SystemManual'
 void SystemManual_setup(void);
 void SystemManual_1_type_1_component(void);
-void SystemManual_no_automerge(void);
 void SystemManual_dont_run_w_unmatching_entity_query(void);
 
 // Testsuite 'Tasks'
@@ -1557,22 +317,6 @@ void Run_setup(void);
 void Run_run(void);
 void Run_run_w_param(void);
 void Run_run_no_match(void);
-void Run_run_w_offset(void);
-void Run_run_w_offset_skip_1_archetype(void);
-void Run_run_w_offset_skip_1_archetype_plus_one(void);
-void Run_run_w_offset_skip_2_archetypes(void);
-void Run_run_w_limit_skip_1_archetype(void);
-void Run_run_w_limit_skip_1_archetype_minus_one(void);
-void Run_run_w_limit_skip_2_archetypes(void);
-void Run_run_w_offset_1_limit_max(void);
-void Run_run_w_offset_1_limit_minus_1(void);
-void Run_run_w_offset_2_type_limit_max(void);
-void Run_run_w_offset_2_type_limit_minus_1(void);
-void Run_run_w_limit_1_all_offsets(void);
-void Run_run_w_offset_out_of_bounds(void);
-void Run_run_w_limit_out_of_bounds(void);
-void Run_run_comb_10_entities_1_type(void);
-void Run_run_comb_10_entities_2_types(void);
 void Run_run_w_interrupt(void);
 void Run_run_staging(void);
 
@@ -1639,111 +383,11 @@ void MultiThreadStaging_6_threads_add_to_current(void);
 void MultiThreadStaging_2_threads_on_add(void);
 void MultiThreadStaging_new_w_count(void);
 void MultiThreadStaging_custom_thread_auto_merge(void);
-void MultiThreadStaging_custom_thread_manual_merge(void);
-void MultiThreadStaging_custom_thread_partial_manual_merge(void);
 void MultiThreadStaging_set_pair_w_new_target_readonly(void);
 void MultiThreadStaging_set_pair_w_new_target_tgt_component_readonly(void);
 void MultiThreadStaging_set_pair_w_new_target_defer(void);
 void MultiThreadStaging_set_pair_w_new_target_tgt_component_defer(void);
 
-// Testsuite 'MultiTaskThread'
-void MultiTaskThread_setup(void);
-void MultiTaskThread_2_thread_1_entity(void);
-void MultiTaskThread_2_thread_2_entity(void);
-void MultiTaskThread_2_thread_5_entity(void);
-void MultiTaskThread_2_thread_10_entity(void);
-void MultiTaskThread_3_thread_1_entity(void);
-void MultiTaskThread_3_thread_2_entity(void);
-void MultiTaskThread_3_thread_5_entity(void);
-void MultiTaskThread_3_thread_10_entity(void);
-void MultiTaskThread_4_thread_1_entity(void);
-void MultiTaskThread_4_thread_2_entity(void);
-void MultiTaskThread_4_thread_5_entity(void);
-void MultiTaskThread_4_thread_10_entity(void);
-void MultiTaskThread_5_thread_1_entity(void);
-void MultiTaskThread_5_thread_2_entity(void);
-void MultiTaskThread_5_thread_5_entity(void);
-void MultiTaskThread_5_thread_10_entity(void);
-void MultiTaskThread_6_thread_1_entity(void);
-void MultiTaskThread_6_thread_2_entity(void);
-void MultiTaskThread_6_thread_5_entity(void);
-void MultiTaskThread_6_thread_10_entity(void);
-void MultiTaskThread_2_thread_1_entity_instanced(void);
-void MultiTaskThread_2_thread_5_entity_instanced(void);
-void MultiTaskThread_2_thread_10_entity_instanced(void);
-void MultiTaskThread_2_thread_test_combs_100_entity_w_next_worker(void);
-void MultiTaskThread_2_thread_test_combs_100_entity(void);
-void MultiTaskThread_3_thread_test_combs_100_entity(void);
-void MultiTaskThread_4_thread_test_combs_100_entity(void);
-void MultiTaskThread_5_thread_test_combs_100_entity(void);
-void MultiTaskThread_6_thread_test_combs_100_entity(void);
-void MultiTaskThread_2_thread_test_combs_100_entity_2_types(void);
-void MultiTaskThread_3_thread_test_combs_100_entity_2_types(void);
-void MultiTaskThread_4_thread_test_combs_100_entity_2_types(void);
-void MultiTaskThread_5_thread_test_combs_100_entity_2_types(void);
-void MultiTaskThread_6_thread_test_combs_100_entity_2_types(void);
-void MultiTaskThread_change_thread_count(void);
-void MultiTaskThread_multithread_quit(void);
-void MultiTaskThread_schedule_w_tasks(void);
-void MultiTaskThread_reactive_system(void);
-void MultiTaskThread_fini_after_set_threads(void);
-void MultiTaskThread_2_threads_single_threaded_system(void);
-void MultiTaskThread_no_staging_w_multithread(void);
-void MultiTaskThread_multithread_w_monitor_addon(void);
-void MultiTaskThread_get_ctx(void);
-void MultiTaskThread_get_binding_ctx(void);
-void MultiTaskThread_get_ctx_w_run(void);
-void MultiTaskThread_get_binding_ctx_w_run(void);
-void MultiTaskThread_bulk_new_in_no_readonly_w_multithread(void);
-void MultiTaskThread_bulk_new_in_no_readonly_w_multithread_2(void);
-void MultiTaskThread_run_first_worker_on_main(void);
-void MultiTaskThread_run_single_thread_on_main(void);
-
-// Testsuite 'MultiTaskThreadStaging'
-void MultiTaskThreadStaging_setup(void);
-void MultiTaskThreadStaging_2_threads_add_to_current(void);
-void MultiTaskThreadStaging_3_threads_add_to_current(void);
-void MultiTaskThreadStaging_4_threads_add_to_current(void);
-void MultiTaskThreadStaging_5_threads_add_to_current(void);
-void MultiTaskThreadStaging_6_threads_add_to_current(void);
-void MultiTaskThreadStaging_2_threads_on_add(void);
-void MultiTaskThreadStaging_new_w_count(void);
-void MultiTaskThreadStaging_custom_thread_auto_merge(void);
-void MultiTaskThreadStaging_custom_thread_manual_merge(void);
-void MultiTaskThreadStaging_custom_thread_partial_manual_merge(void);
-void MultiTaskThreadStaging_set_pair_w_new_target_readonly(void);
-void MultiTaskThreadStaging_set_pair_w_new_target_tgt_component_readonly(void);
-void MultiTaskThreadStaging_set_pair_w_new_target_defer(void);
-void MultiTaskThreadStaging_set_pair_w_new_target_tgt_component_defer(void);
-
-// Testsuite 'Snapshot'
-void Snapshot_simple_snapshot(void);
-void Snapshot_snapshot_after_new(void);
-void Snapshot_snapshot_after_delete(void);
-void Snapshot_snapshot_after_new_type(void);
-void Snapshot_snapshot_after_add(void);
-void Snapshot_snapshot_after_remove(void);
-void Snapshot_snapshot_w_include_filter(void);
-void Snapshot_snapshot_w_exclude_filter(void);
-void Snapshot_snapshot_w_filter_after_new(void);
-void Snapshot_snapshot_w_filter_after_delete(void);
-void Snapshot_snapshot_free_empty(void);
-void Snapshot_snapshot_free(void);
-void Snapshot_snapshot_free_filtered(void);
-void Snapshot_snapshot_free_filtered_w_dtor(void);
-void Snapshot_snapshot_activate_table_w_filter(void);
-void Snapshot_snapshot_copy(void);
-void Snapshot_snapshot_get_ref_after_restore(void);
-void Snapshot_new_after_snapshot(void);
-void Snapshot_new_empty_after_snapshot(void);
-void Snapshot_add_after_snapshot(void);
-void Snapshot_delete_after_snapshot(void);
-void Snapshot_set_after_snapshot(void);
-void Snapshot_restore_recycled(void);
-void Snapshot_snapshot_w_new_in_onset(void);
-void Snapshot_snapshot_w_new_in_onset_in_snapshot_table(void);
-void Snapshot_snapshot_from_stage(void);
-
 // Testsuite 'Modules'
 void Modules_setup(void);
 void Modules_simple_module(void);
@@ -1799,6 +443,7 @@ void Rest_request_commands_2_syncs(void);
 void Rest_request_commands_no_frames(void);
 void Rest_request_commands_no_commands(void);
 void Rest_request_commands_garbage_collect(void);
+void Rest_script_error(void);
 
 // Testsuite 'Metrics'
 void Metrics_member_gauge_1_entity(void);
@@ -1877,6769 +522,1423 @@ void Alerts_member_range_from_var_after_remove(void);
 void Alerts_retained_alert_w_dead_source(void);
 void Alerts_alert_counts(void);
 
-bake_test_case Parser_testcases[] = {
+bake_test_case Doc_testcases[] = {
     {
-        "resolve_this",
-        Parser_resolve_this
+        "get_set_name",
+        Doc_get_set_name
     },
     {
-        "resolve_wildcard",
-        Parser_resolve_wildcard
+        "get_entity_name",
+        Doc_get_entity_name
     },
     {
-        "resolve_any",
-        Parser_resolve_any
+        "get_set_brief",
+        Doc_get_set_brief
     },
     {
-        "resolve_is_a",
-        Parser_resolve_is_a
+        "get_set_detail",
+        Doc_get_set_detail
     },
     {
-        "0",
-        Parser_0
+        "get_set_link",
+        Doc_get_set_link
     },
     {
-        "component_implicit_subject",
-        Parser_component_implicit_subject
+        "set_name_nullptr",
+        Doc_set_name_nullptr
     },
     {
-        "component_explicit_subject",
-        Parser_component_explicit_subject
+        "set_brief_nullptr",
+        Doc_set_brief_nullptr
     },
     {
-        "component_explicit_subject_this",
-        Parser_component_explicit_subject_this
+        "set_detail_nullptr",
+        Doc_set_detail_nullptr
     },
     {
-        "component_explicit_subject_this_by_name",
-        Parser_component_explicit_subject_this_by_name
+        "set_link_nullptr",
+        Doc_set_link_nullptr
     },
     {
-        "component_explicit_subject_this_by_var_name",
-        Parser_component_explicit_subject_this_by_var_name
-    },
+        "set_color_nullptr",
+        Doc_set_color_nullptr
+    }
+};
+
+bake_test_case Pipeline_testcases[] = {
     {
-        "component_explicit_subject_wildcard",
-        Parser_component_explicit_subject_wildcard
+        "system_order_same_phase",
+        Pipeline_system_order_same_phase
     },
     {
-        "component_explicit_subject_any",
-        Parser_component_explicit_subject_any
+        "system_order_same_phase_after_disable",
+        Pipeline_system_order_same_phase_after_disable
     },
     {
-        "component_explicit_subject_0",
-        Parser_component_explicit_subject_0
+        "system_order_same_phase_after_activate",
+        Pipeline_system_order_same_phase_after_activate
     },
     {
-        "this_as_predicate",
-        Parser_this_as_predicate
+        "system_order_different_phase",
+        Pipeline_system_order_different_phase
     },
     {
-        "this_var_as_predicate",
-        Parser_this_var_as_predicate
+        "system_order_different_phase_after_disable",
+        Pipeline_system_order_different_phase_after_disable
     },
     {
-        "this_lowercase_var_as_predicate",
-        Parser_this_lowercase_var_as_predicate
+        "system_order_different_phase_after_activate",
+        Pipeline_system_order_different_phase_after_activate
     },
     {
-        "this_as_object",
-        Parser_this_as_object
+        "system_order_after_new_system_lower_id",
+        Pipeline_system_order_after_new_system_lower_id
     },
     {
-        "this_var_as_object",
-        Parser_this_var_as_object
+        "system_order_after_new_system_inbetween_id",
+        Pipeline_system_order_after_new_system_inbetween_id
     },
     {
-        "pair_implicit_subject",
-        Parser_pair_implicit_subject
+        "system_order_after_new_system_higher_id",
+        Pipeline_system_order_after_new_system_higher_id
     },
     {
-        "pair_implicit_subject_wildcard_pred",
-        Parser_pair_implicit_subject_wildcard_pred
+        "system_reverse_order_by_phase_custom_pipeline",
+        Pipeline_system_reverse_order_by_phase_custom_pipeline
     },
     {
-        "pair_implicit_subject_wildcard_obj",
-        Parser_pair_implicit_subject_wildcard_obj
+        "merge_after_staged_out",
+        Pipeline_merge_after_staged_out
     },
     {
-        "pair_implicit_subject_any_pred",
-        Parser_pair_implicit_subject_any_pred
+        "merge_after_not_out",
+        Pipeline_merge_after_not_out
     },
     {
-        "pair_implicit_subject_any_obj",
-        Parser_pair_implicit_subject_any_obj
+        "no_merge_after_main_out",
+        Pipeline_no_merge_after_main_out
     },
     {
-        "pair_implicit_subject_this_pred",
-        Parser_pair_implicit_subject_this_pred
+        "merge_after_staged_in_out",
+        Pipeline_merge_after_staged_in_out
     },
     {
-        "pair_implicit_subject_this_obj",
-        Parser_pair_implicit_subject_this_obj
+        "merge_after_staged_inout_main_implicit_inout",
+        Pipeline_merge_after_staged_inout_main_implicit_inout
     },
     {
-        "pair_implicit_subject_pred_w_self",
-        Parser_pair_implicit_subject_pred_w_self
+        "merge_after_staged_inout_main_inout",
+        Pipeline_merge_after_staged_inout_main_inout
     },
     {
-        "pair_implicit_subject_obj_w_self",
-        Parser_pair_implicit_subject_obj_w_self
+        "merge_after_staged_out_before_owned",
+        Pipeline_merge_after_staged_out_before_owned
     },
     {
-        "pair_implicit_subject_pred_w_up",
-        Parser_pair_implicit_subject_pred_w_up
+        "switch_pipeline",
+        Pipeline_switch_pipeline
     },
     {
-        "pair_implicit_subject_obj_w_up",
-        Parser_pair_implicit_subject_obj_w_up
+        "run_pipeline",
+        Pipeline_run_pipeline
     },
     {
-        "pair_implicit_subject_pred_w_self_up",
-        Parser_pair_implicit_subject_pred_w_self_up
+        "get_pipeline_from_stage",
+        Pipeline_get_pipeline_from_stage
     },
     {
-        "pair_implicit_subject_obj_w_self_up",
-        Parser_pair_implicit_subject_obj_w_self_up
+        "3_systems_3_types",
+        Pipeline_3_systems_3_types
     },
     {
-        "pair_implicit_subject_pred_w_up_trav",
-        Parser_pair_implicit_subject_pred_w_up_trav
+        "random_read_after_random_write_out_in",
+        Pipeline_random_read_after_random_write_out_in
     },
     {
-        "pair_implicit_subject_obj_w_up_trav",
-        Parser_pair_implicit_subject_obj_w_up_trav
+        "random_read_after_random_write_inout_in",
+        Pipeline_random_read_after_random_write_inout_in
     },
     {
-        "pair_implicit_subject_pred_w_invalid_flags",
-        Parser_pair_implicit_subject_pred_w_invalid_flags
+        "random_read_after_random_write_out_inout",
+        Pipeline_random_read_after_random_write_out_inout
     },
     {
-        "pair_implicit_subject_obj_w_invalid_flags",
-        Parser_pair_implicit_subject_obj_w_invalid_flags
+        "random_read_after_random_write_inout_inout",
+        Pipeline_random_read_after_random_write_inout_inout
     },
     {
-        "pair_explicit_subject",
-        Parser_pair_explicit_subject
+        "random_read_after_random_write_w_not_write",
+        Pipeline_random_read_after_random_write_w_not_write
     },
     {
-        "pair_explicit_subject_this",
-        Parser_pair_explicit_subject_this
+        "random_read_after_random_write_w_not_read",
+        Pipeline_random_read_after_random_write_w_not_read
     },
     {
-        "pair_explicit_subject_this_by_name",
-        Parser_pair_explicit_subject_this_by_name
+        "random_read_after_random_write_w_wildcard",
+        Pipeline_random_read_after_random_write_w_wildcard
     },
     {
-        "pair_explicit_subject_this_by_var_name",
-        Parser_pair_explicit_subject_this_by_var_name
+        "random_in_after_random_inout_after_random_out",
+        Pipeline_random_in_after_random_inout_after_random_out
     },
     {
-        "pair_explicit_subject_wildcard_pred",
-        Parser_pair_explicit_subject_wildcard_pred
+        "stage_write_before_read",
+        Pipeline_stage_write_before_read
     },
     {
-        "pair_explicit_subject_wildcard_subj",
-        Parser_pair_explicit_subject_wildcard_subj
+        "mixed_multithreaded",
+        Pipeline_mixed_multithreaded
     },
     {
-        "pair_explicit_subject_wildcard_obj",
-        Parser_pair_explicit_subject_wildcard_obj
+        "mixed_multithreaded_tasks",
+        Pipeline_mixed_multithreaded_tasks
     },
     {
-        "pair_implicit_subject_0_object",
-        Parser_pair_implicit_subject_0_object
+        "mixed_staging",
+        Pipeline_mixed_staging
     },
     {
-        "pair_explicit_subject_0_object",
-        Parser_pair_explicit_subject_0_object
+        "no_staging_system_create_query",
+        Pipeline_no_staging_system_create_query
     },
     {
-        "pair_explicit_subject_0",
-        Parser_pair_explicit_subject_0
+        "single_threaded_pipeline_change",
+        Pipeline_single_threaded_pipeline_change
     },
     {
-        "in_component_implicit_subject",
-        Parser_in_component_implicit_subject
+        "multi_threaded_pipeline_change",
+        Pipeline_multi_threaded_pipeline_change
     },
     {
-        "in_component_explicit_subject",
-        Parser_in_component_explicit_subject
+        "multi_threaded_pipeline_change_tasks",
+        Pipeline_multi_threaded_pipeline_change_tasks
     },
     {
-        "in_pair_implicit_subject",
-        Parser_in_pair_implicit_subject
+        "activate_after_add",
+        Pipeline_activate_after_add
     },
     {
-        "in_pair_explicit_subject",
-        Parser_in_pair_explicit_subject
+        "match_all_after_pipeline_rebuild",
+        Pipeline_match_all_after_pipeline_rebuild
     },
     {
-        "inout_component_implicit_subject",
-        Parser_inout_component_implicit_subject
+        "empty_pipeline",
+        Pipeline_empty_pipeline
     },
     {
-        "inout_component_explicit_subject",
-        Parser_inout_component_explicit_subject
+        "custom_pipeline_w_system_macro",
+        Pipeline_custom_pipeline_w_system_macro
     },
     {
-        "inout_pair_implicit_subject",
-        Parser_inout_pair_implicit_subject
+        "pipeline_w_short_notation",
+        Pipeline_pipeline_w_short_notation
     },
     {
-        "inout_pair_explicit_subject",
-        Parser_inout_pair_explicit_subject
+        "stack_allocator_after_progress",
+        Pipeline_stack_allocator_after_progress
     },
     {
-        "out_component_implicit_subject",
-        Parser_out_component_implicit_subject
+        "stack_allocator_after_progress_w_pipeline_change",
+        Pipeline_stack_allocator_after_progress_w_pipeline_change
     },
     {
-        "out_component_explicit_subject",
-        Parser_out_component_explicit_subject
+        "iter_from_world_in_singlethread_system_multitead_app",
+        Pipeline_iter_from_world_in_singlethread_system_multitead_app
     },
     {
-        "out_pair_implicit_subject",
-        Parser_out_pair_implicit_subject
+        "iter_from_world_in_singlethread_system_multitead_app_tasks",
+        Pipeline_iter_from_world_in_singlethread_system_multitead_app_tasks
     },
     {
-        "out_pair_explicit_subject",
-        Parser_out_pair_explicit_subject
+        "no_staging_after_inactive_system",
+        Pipeline_no_staging_after_inactive_system
     },
     {
-        "inout_filter_component",
-        Parser_inout_filter_component
+        "inactive_system_after_no_staging_system_no_defer_w_filter",
+        Pipeline_inactive_system_after_no_staging_system_no_defer_w_filter
     },
     {
-        "component_singleton",
-        Parser_component_singleton
+        "inactive_system_after_2_no_staging_system_no_defer_w_filter",
+        Pipeline_inactive_system_after_2_no_staging_system_no_defer_w_filter
     },
     {
-        "this_singleton",
-        Parser_this_singleton
+        "inactive_system_after_no_staging_system_no_defer_w_filter_w_no_staging_at_end",
+        Pipeline_inactive_system_after_no_staging_system_no_defer_w_filter_w_no_staging_at_end
     },
     {
-        "component_implicit_no_subject",
-        Parser_component_implicit_no_subject
+        "inactive_multithread_system_after_no_staging_system_no_defer",
+        Pipeline_inactive_multithread_system_after_no_staging_system_no_defer
     },
     {
-        "component_explicit_no_subject",
-        Parser_component_explicit_no_subject
+        "inactive_multithread_tasks_system_after_no_staging_system_no_defer",
+        Pipeline_inactive_multithread_tasks_system_after_no_staging_system_no_defer
     },
     {
-        "pair_no_subject",
-        Parser_pair_no_subject
+        "inactive_multithread_system_after_no_staging_system_no_defer_w_no_staging_at_end",
+        Pipeline_inactive_multithread_system_after_no_staging_system_no_defer_w_no_staging_at_end
     },
     {
-        "variable_single_char",
-        Parser_variable_single_char
+        "inactive_multithread_tasks_system_after_no_staging_system_no_defer_w_no_staging_at_end",
+        Pipeline_inactive_multithread_tasks_system_after_no_staging_system_no_defer_w_no_staging_at_end
     },
     {
-        "variable_multi_char",
-        Parser_variable_multi_char
+        "multi_threaded_pipeline_change_w_only_singlethreaded",
+        Pipeline_multi_threaded_pipeline_change_w_only_singlethreaded
     },
     {
-        "variable_multi_char_w_underscore",
-        Parser_variable_multi_char_w_underscore
+        "multi_threaded_tasks_pipeline_change_w_only_singlethreaded",
+        Pipeline_multi_threaded_tasks_pipeline_change_w_only_singlethreaded
     },
     {
-        "variable_multi_char_w_number",
-        Parser_variable_multi_char_w_number
+        "sync_after_not_out_for_out",
+        Pipeline_sync_after_not_out_for_out
     },
     {
-        "variable_multi_char_not_allcaps",
-        Parser_variable_multi_char_not_allcaps
+        "pair_wildcard_read_after_staged_write",
+        Pipeline_pair_wildcard_read_after_staged_write
     },
     {
-        "pred_var",
-        Parser_pred_var
+        "pair_read_after_staged_wildcard_write",
+        Pipeline_pair_read_after_staged_wildcard_write
     },
     {
-        "obj_var",
-        Parser_obj_var
+        "no_sync_after_pair_wildcard_read_after_unmatching_staged_write",
+        Pipeline_no_sync_after_pair_wildcard_read_after_unmatching_staged_write
     },
     {
-        "component_not",
-        Parser_component_not
+        "no_merge_after_from_nothing_w_default_inout",
+        Pipeline_no_merge_after_from_nothing_w_default_inout
     },
     {
-        "pair_implicit_subject_not",
-        Parser_pair_implicit_subject_not
+        "on_merge_activate_system_before_merge",
+        Pipeline_on_merge_activate_system_before_merge
     },
     {
-        "pair_explicit_subject_not",
-        Parser_pair_explicit_subject_not
+        "disable_phase",
+        Pipeline_disable_phase
     },
     {
-        "2_component_not",
-        Parser_2_component_not
+        "disable_parent",
+        Pipeline_disable_parent
     },
     {
-        "2_component_not_no_space",
-        Parser_2_component_not_no_space
+        "multi_threaded_no_staging_w_add_after_read",
+        Pipeline_multi_threaded_no_staging_w_add_after_read
     },
     {
-        "component_optional",
-        Parser_component_optional
+        "multi_threaded_tasks_no_staging_w_add_after_read",
+        Pipeline_multi_threaded_tasks_no_staging_w_add_after_read
     },
     {
-        "2_component_optional",
-        Parser_2_component_optional
+        "1_startup_system",
+        Pipeline_1_startup_system
     },
     {
-        "2_component_optional_no_space",
-        Parser_2_component_optional_no_space
+        "2_startup_systems",
+        Pipeline_2_startup_systems
     },
     {
-        "from_and",
-        Parser_from_and
+        "2_startup_phases",
+        Pipeline_2_startup_phases
     },
     {
-        "from_or",
-        Parser_from_or
+        "2_startup_systems_w_merge",
+        Pipeline_2_startup_systems_w_merge
     },
     {
-        "from_not",
-        Parser_from_not
+        "inactive_last_system_merge_count",
+        Pipeline_inactive_last_system_merge_count
     },
     {
-        "pair_implicit_subject_optional",
-        Parser_pair_implicit_subject_optional
+        "inactive_middle_system_merge_count",
+        Pipeline_inactive_middle_system_merge_count
     },
     {
-        "pair_explicit_subject_optional",
-        Parser_pair_explicit_subject_optional
+        "last_no_readonly_system_merge_count",
+        Pipeline_last_no_readonly_system_merge_count
     },
     {
-        "pred_implicit_subject_w_role",
-        Parser_pred_implicit_subject_w_role
+        "2_pipelines_1_system",
+        Pipeline_2_pipelines_1_system
     },
     {
-        "pred_explicit_subject_w_role",
-        Parser_pred_explicit_subject_w_role
+        "builtin_pipeline_w_self_system_term",
+        Pipeline_builtin_pipeline_w_self_system_term
     },
     {
-        "pred_no_subject_w_role",
-        Parser_pred_no_subject_w_role
+        "custom_pipeline_w_self_system_term",
+        Pipeline_custom_pipeline_w_self_system_term
     },
     {
-        "pair_implicit_subject_w_role",
-        Parser_pair_implicit_subject_w_role
+        "switch_from_threads_to_tasks",
+        Pipeline_switch_from_threads_to_tasks
     },
     {
-        "pair_explicit_subject_w_role",
-        Parser_pair_explicit_subject_w_role
+        "switch_from_tasks_to_threads",
+        Pipeline_switch_from_tasks_to_threads
     },
     {
-        "inout_role_pred_implicit_subject",
-        Parser_inout_role_pred_implicit_subject
+        "run_pipeline_multithreaded",
+        Pipeline_run_pipeline_multithreaded
     },
     {
-        "inout_role_pred_no_subject",
-        Parser_inout_role_pred_no_subject
+        "run_pipeline_multithreaded_tasks",
+        Pipeline_run_pipeline_multithreaded_tasks
     },
     {
-        "inout_role_pred_explicit_subject",
-        Parser_inout_role_pred_explicit_subject
+        "pipeline_init_no_terms",
+        Pipeline_pipeline_init_no_terms
     },
     {
-        "inout_role_pair_implicit_subject",
-        Parser_inout_role_pair_implicit_subject
-    },
+        "pipeline_init_no_system_term",
+        Pipeline_pipeline_init_no_system_term
+    }
+};
+
+bake_test_case SystemMisc_testcases[] = {
     {
-        "inout_role_pair_explicit_subject",
-        Parser_inout_role_pair_explicit_subject
+        "invalid_not_without_id",
+        SystemMisc_invalid_not_without_id
     },
     {
-        "2_pred_implicit_subject",
-        Parser_2_pred_implicit_subject
+        "invalid_optional_without_id",
+        SystemMisc_invalid_optional_without_id
     },
     {
-        "2_pred_no_subject",
-        Parser_2_pred_no_subject
+        "invalid_entity_without_id",
+        SystemMisc_invalid_entity_without_id
     },
     {
-        "2_pred_explicit_subject",
-        Parser_2_pred_explicit_subject
+        "invalid_empty_element",
+        SystemMisc_invalid_empty_element
     },
     {
-        "2_pair_implicit_subject",
-        Parser_2_pair_implicit_subject
+        "invalid_empty_element_w_space",
+        SystemMisc_invalid_empty_element_w_space
     },
     {
-        "2_pair_explicit_subject",
-        Parser_2_pair_explicit_subject
+        "invalid_empty_or",
+        SystemMisc_invalid_empty_or
     },
     {
-        "2_pred_role",
-        Parser_2_pred_role
+        "invalid_empty_or_w_space",
+        SystemMisc_invalid_empty_or_w_space
     },
     {
-        "2_pair_implicit_subj_role",
-        Parser_2_pair_implicit_subj_role
+        "invalid_or_w_not",
+        SystemMisc_invalid_or_w_not
     },
     {
-        "2_pair_explicit_subj_role",
-        Parser_2_pair_explicit_subj_role
+        "invalid_not_w_or",
+        SystemMisc_invalid_not_w_or
     },
     {
-        "2_or_pred_implicit_subj",
-        Parser_2_or_pred_implicit_subj
+        "invalid_0_w_and",
+        SystemMisc_invalid_0_w_and
     },
     {
-        "2_or_pred_explicit_subj",
-        Parser_2_or_pred_explicit_subj
+        "invalid_0_w_from_entity",
+        SystemMisc_invalid_0_w_from_entity
     },
     {
-        "2_or_pair_implicit_subj",
-        Parser_2_or_pair_implicit_subj
+        "invalid_component_id",
+        SystemMisc_invalid_component_id
     },
     {
-        "2_or_pair_explicit_subj",
-        Parser_2_or_pair_explicit_subj
+        "invalid_entity_id",
+        SystemMisc_invalid_entity_id
     },
     {
-        "2_or_pred_inout",
-        Parser_2_or_pred_inout
+        "invalid_null_string",
+        SystemMisc_invalid_null_string
     },
     {
-        "1_digit_pred_implicit_subj",
-        Parser_1_digit_pred_implicit_subj
+        "invalid_empty_string",
+        SystemMisc_invalid_empty_string
     },
     {
-        "1_digit_pred_no_subj",
-        Parser_1_digit_pred_no_subj
+        "invalid_empty_string_w_space",
+        SystemMisc_invalid_empty_string_w_space
     },
     {
-        "1_digit_pred_explicit_subj",
-        Parser_1_digit_pred_explicit_subj
+        "redefine_row_system",
+        SystemMisc_redefine_row_system
     },
     {
-        "1_digit_pair_implicit_subj",
-        Parser_1_digit_pair_implicit_subj
+        "system_w_or_prefab",
+        SystemMisc_system_w_or_prefab
     },
     {
-        "1_digit_pair_explicit_subj",
-        Parser_1_digit_pair_explicit_subj
+        "system_w_or_disabled",
+        SystemMisc_system_w_or_disabled
     },
     {
-        "pred_implicit_subject_self",
-        Parser_pred_implicit_subject_self
+        "system_w_or_disabled_and_prefab",
+        SystemMisc_system_w_or_disabled_and_prefab
     },
     {
-        "pred_implicit_subject_superset",
-        Parser_pred_implicit_subject_superset
+        "table_columns_access",
+        SystemMisc_table_columns_access
     },
     {
-        "pred_implicit_subject_subset",
-        Parser_pred_implicit_subject_subset
+        "dont_enable_after_rematch",
+        SystemMisc_dont_enable_after_rematch
     },
     {
-        "pred_implicit_subject_superset_inclusive",
-        Parser_pred_implicit_subject_superset_inclusive
+        "ensure_single_merge",
+        SystemMisc_ensure_single_merge
     },
     {
-        "pred_implicit_subject_subset_inclusive",
-        Parser_pred_implicit_subject_subset_inclusive
-    },
-    {
-        "pred_implicit_subject_superset_cascade",
-        Parser_pred_implicit_subject_superset_cascade
-    },
-    {
-        "pred_implicit_subject_subset_cascade",
-        Parser_pred_implicit_subject_subset_cascade
+        "match_system",
+        SystemMisc_match_system
     },
     {
-        "pred_implicit_subject_superset_inclusive_cascade",
-        Parser_pred_implicit_subject_superset_inclusive_cascade
+        "system_initial_state",
+        SystemMisc_system_initial_state
     },
     {
-        "pred_implicit_subject_subset_inclusive_cascade",
-        Parser_pred_implicit_subject_subset_inclusive_cascade
+        "add_own_component",
+        SystemMisc_add_own_component
     },
     {
-        "pred_implicit_subject_implicit_superset_cascade",
-        Parser_pred_implicit_subject_implicit_superset_cascade
+        "change_system_action",
+        SystemMisc_change_system_action
     },
     {
-        "pred_implicit_subject_implicit_superset_inclusive_cascade",
-        Parser_pred_implicit_subject_implicit_superset_inclusive_cascade
+        "system_readeactivate",
+        SystemMisc_system_readeactivate
     },
     {
-        "pred_implicit_subject_implicit_superset_cascade_w_rel",
-        Parser_pred_implicit_subject_implicit_superset_cascade_w_rel
+        "system_readeactivate_w_2_systems",
+        SystemMisc_system_readeactivate_w_2_systems
     },
     {
-        "pred_implicit_subject_implicit_superset_inclusive_cascade_w_rel",
-        Parser_pred_implicit_subject_implicit_superset_inclusive_cascade_w_rel
+        "add_to_system_in_progress",
+        SystemMisc_add_to_system_in_progress
     },
     {
-        "pred_implicit_subject_superset_childof",
-        Parser_pred_implicit_subject_superset_childof
+        "redefine_null_signature",
+        SystemMisc_redefine_null_signature
     },
     {
-        "pred_implicit_subject_cascade_superset_childof",
-        Parser_pred_implicit_subject_cascade_superset_childof
+        "redefine_0_signature",
+        SystemMisc_redefine_0_signature
     },
     {
-        "pred_implicit_subject_superset_cascade_childof",
-        Parser_pred_implicit_subject_superset_cascade_childof
+        "redeclare_system_explicit_id",
+        SystemMisc_redeclare_system_explicit_id
     },
     {
-        "pred_implicit_subject_superset_cascade_childof_optional",
-        Parser_pred_implicit_subject_superset_cascade_childof_optional
+        "redeclare_system_explicit_id_null_expr",
+        SystemMisc_redeclare_system_explicit_id_null_expr
     },
     {
-        "expr_w_symbol",
-        Parser_expr_w_symbol
+        "redeclare_system_explicit_id_no_name",
+        SystemMisc_redeclare_system_explicit_id_no_name
     },
     {
-        "expr_w_newline",
-        Parser_expr_w_newline
+        "declare_different_id_same_name",
+        SystemMisc_declare_different_id_same_name
     },
     {
-        "subj_entity_w_explicit_self",
-        Parser_subj_entity_w_explicit_self
+        "declare_different_id_same_name_w_scope",
+        SystemMisc_declare_different_id_same_name_w_scope
     },
     {
-        "subj_entity_w_explicit_self_superset",
-        Parser_subj_entity_w_explicit_self_superset
+        "rw_in_implicit_any",
+        SystemMisc_rw_in_implicit_any
     },
     {
-        "subj_entity_w_explicit_superset_relation",
-        Parser_subj_entity_w_explicit_superset_relation
+        "rw_in_implicit_shared",
+        SystemMisc_rw_in_implicit_shared
     },
     {
-        "subj_entity_w_explicit_self_superset_relation",
-        Parser_subj_entity_w_explicit_self_superset_relation
+        "rw_in_implicit_from_empty",
+        SystemMisc_rw_in_implicit_from_empty
     },
     {
-        "obj_entity_w_explicit_self",
-        Parser_obj_entity_w_explicit_self
+        "rw_in_implicit_from_entity",
+        SystemMisc_rw_in_implicit_from_entity
     },
     {
-        "obj_entity_w_explicit_self_superset",
-        Parser_obj_entity_w_explicit_self_superset
+        "rw_out_explicit_any",
+        SystemMisc_rw_out_explicit_any
     },
     {
-        "obj_entity_w_explicit_superset_relation",
-        Parser_obj_entity_w_explicit_superset_relation
+        "rw_out_explicit_shared",
+        SystemMisc_rw_out_explicit_shared
     },
     {
-        "obj_entity_w_explicit_self_superset_relation",
-        Parser_obj_entity_w_explicit_self_superset_relation
+        "rw_out_explicit_from_empty",
+        SystemMisc_rw_out_explicit_from_empty
     },
     {
-        "pred_entity_w_explicit_self",
-        Parser_pred_entity_w_explicit_self
+        "rw_out_explicit_from_entity",
+        SystemMisc_rw_out_explicit_from_entity
     },
     {
-        "pred_entity_w_explicit_self_superset",
-        Parser_pred_entity_w_explicit_self_superset
+        "activate_system_for_table_w_n_pairs",
+        SystemMisc_activate_system_for_table_w_n_pairs
     },
     {
-        "pred_entity_w_explicit_superset_relation",
-        Parser_pred_entity_w_explicit_superset_relation
+        "get_query",
+        SystemMisc_get_query
     },
     {
-        "pred_entity_w_explicit_self_superset_relation",
-        Parser_pred_entity_w_explicit_self_superset_relation
+        "set_get_context",
+        SystemMisc_set_get_context
     },
     {
-        "pred_entity_no_args_w_explicit_self",
-        Parser_pred_entity_no_args_w_explicit_self
+        "set_get_binding_context",
+        SystemMisc_set_get_binding_context
     },
     {
-        "pred_entity_no_args_w_explicit_self_superset",
-        Parser_pred_entity_no_args_w_explicit_self_superset
+        "deactivate_after_disable",
+        SystemMisc_deactivate_after_disable
     },
     {
-        "pred_entity_no_args_w_explicit_superset_relation",
-        Parser_pred_entity_no_args_w_explicit_superset_relation
+        "delete_system",
+        SystemMisc_delete_system
     },
     {
-        "pred_entity_no_args_w_explicit_self_superset_relation",
-        Parser_pred_entity_no_args_w_explicit_self_superset_relation
+        "delete_pipeline_system",
+        SystemMisc_delete_pipeline_system
     },
     {
-        "pred_entity_no_args_2_terms_w_explicit_self",
-        Parser_pred_entity_no_args_2_terms_w_explicit_self
+        "delete_system_w_ctx",
+        SystemMisc_delete_system_w_ctx
     },
     {
-        "pred_entity_no_args_2_terms_w_explicit_self_superset",
-        Parser_pred_entity_no_args_2_terms_w_explicit_self_superset
+        "update_ctx",
+        SystemMisc_update_ctx
     },
     {
-        "pred_entity_no_args_2_terms_w_explicit_superset_relation",
-        Parser_pred_entity_no_args_2_terms_w_explicit_superset_relation
+        "run_custom_run_action",
+        SystemMisc_run_custom_run_action
     },
     {
-        "pred_entity_no_args_2_terms_w_explicit_self_superset_relation",
-        Parser_pred_entity_no_args_2_terms_w_explicit_self_superset_relation
+        "pipeline_custom_run_action",
+        SystemMisc_pipeline_custom_run_action
     },
     {
-        "newline",
-        Parser_newline
+        "change_custom_run_action",
+        SystemMisc_change_custom_run_action
     },
     {
-        "2_newlines",
-        Parser_2_newlines
+        "custom_run_action_call_next",
+        SystemMisc_custom_run_action_call_next
     },
     {
-        "3_newlines",
-        Parser_3_newlines
+        "system_w_short_notation",
+        SystemMisc_system_w_short_notation
     },
     {
-        "space",
-        Parser_space
+        "update_interval_w_system_init",
+        SystemMisc_update_interval_w_system_init
     },
     {
-        "2_spaces",
-        Parser_2_spaces
+        "update_rate_w_system_init",
+        SystemMisc_update_rate_w_system_init
     },
     {
-        "trailing_newline",
-        Parser_trailing_newline
+        "system_w_interval_rate_stop_timer",
+        SystemMisc_system_w_interval_rate_stop_timer
     },
     {
-        "2_trailing_newlines",
-        Parser_2_trailing_newlines
+        "system_same_interval_same_tick",
+        SystemMisc_system_same_interval_same_tick
     },
     {
-        "trailing_space",
-        Parser_trailing_space
-    },
+        "system_no_id_in_scope",
+        SystemMisc_system_no_id_in_scope
+    }
+};
+
+bake_test_case SystemPeriodic_testcases[] = {
     {
-        "2_trailing_spaces",
-        Parser_2_trailing_spaces
+        "1_type_1_component",
+        SystemPeriodic_1_type_1_component
     },
     {
-        "template_type",
-        Parser_template_type
+        "1_type_3_component",
+        SystemPeriodic_1_type_3_component
     },
     {
-        "predicate_w_parens",
-        Parser_predicate_w_parens
+        "3_type_1_component",
+        SystemPeriodic_3_type_1_component
     },
     {
-        "not_alive_pred",
-        Parser_not_alive_pred
+        "2_type_3_component",
+        SystemPeriodic_2_type_3_component
     },
     {
-        "not_alive_subj",
-        Parser_not_alive_subj
+        "1_type_1_component_1_tag",
+        SystemPeriodic_1_type_1_component_1_tag
     },
     {
-        "not_alive_obj",
-        Parser_not_alive_obj
+        "2_type_1_component_1_tag",
+        SystemPeriodic_2_type_1_component_1_tag
     },
     {
-        "this_subj_var_kind",
-        Parser_this_subj_var_kind
+        "2_type_1_and_1_not",
+        SystemPeriodic_2_type_1_and_1_not
     },
     {
-        "this_obj_var_kind",
-        Parser_this_obj_var_kind
+        "2_type_2_and_1_not",
+        SystemPeriodic_2_type_2_and_1_not
     },
     {
-        "this_subj_obj_var_kind",
-        Parser_this_subj_obj_var_kind
+        "2_type_2_and_2_not",
+        SystemPeriodic_2_type_2_and_2_not
     },
     {
-        "var_w_name",
-        Parser_var_w_name
+        "4_type_1_and_1_or",
+        SystemPeriodic_4_type_1_and_1_or
     },
     {
-        "entity_pred_no_name",
-        Parser_entity_pred_no_name
+        "4_type_1_and_1_or_of_3",
+        SystemPeriodic_4_type_1_and_1_or_of_3
     },
     {
-        "entity_subj_no_name",
-        Parser_entity_subj_no_name
+        "1_type_1_and_1_or",
+        SystemPeriodic_1_type_1_and_1_or
     },
     {
-        "entity_obj_no_name",
-        Parser_entity_obj_no_name
+        "2_type_1_and_1_optional",
+        SystemPeriodic_2_type_1_and_1_optional
     },
     {
-        "this_pred_no_name",
-        Parser_this_pred_no_name
+        "2_type_2_and_1_optional",
+        SystemPeriodic_2_type_2_and_1_optional
     },
     {
-        "this_subj_no_name",
-        Parser_this_subj_no_name
+        "6_type_1_and_2_optional",
+        SystemPeriodic_6_type_1_and_2_optional
     },
     {
-        "this_obj_no_name",
-        Parser_this_obj_no_name
+        "ensure_optional_is_unset_column",
+        SystemPeriodic_ensure_optional_is_unset_column
     },
     {
-        "auto_object_variable",
-        Parser_auto_object_variable
+        "ensure_optional_is_null_shared",
+        SystemPeriodic_ensure_optional_is_null_shared
     },
     {
-        "auto_object_variable_w_subj",
-        Parser_auto_object_variable_w_subj
+        "match_2_systems_w_populated_table",
+        SystemPeriodic_match_2_systems_w_populated_table
     },
     {
-        "auto_scoped_variable",
-        Parser_auto_scoped_variable
+        "on_period",
+        SystemPeriodic_on_period
     },
     {
-        "invalid_variable_only",
-        Parser_invalid_variable_only
+        "on_period_long_delta",
+        SystemPeriodic_on_period_long_delta
     },
     {
-        "oneof_self_pred_w_relative_obj",
-        Parser_oneof_self_pred_w_relative_obj
+        "disabled",
+        SystemPeriodic_disabled
     },
     {
-        "oneof_other_pred_w_relative_obj",
-        Parser_oneof_other_pred_w_relative_obj
+        "disabled_feature",
+        SystemPeriodic_disabled_feature
     },
     {
-        "oneof_self_pred_w_invalid_obj",
-        Parser_oneof_self_pred_w_invalid_obj
+        "disabled_nested_feature",
+        SystemPeriodic_disabled_nested_feature
     },
     {
-        "oneof_other_pred_w_invalid_obj",
-        Parser_oneof_other_pred_w_invalid_obj
+        "two_refs",
+        SystemPeriodic_two_refs
     },
     {
-        "oneof_w_other_entity_w_same_name",
-        Parser_oneof_w_other_entity_w_same_name
+        "filter_disabled",
+        SystemPeriodic_filter_disabled
     },
     {
-        "oneof_w_other_entity_w_same_name_w_set_scope",
-        Parser_oneof_w_other_entity_w_same_name_w_set_scope
+        "match_disabled",
+        SystemPeriodic_match_disabled
     },
     {
-        "oneof_w_wildcard",
-        Parser_oneof_w_wildcard
+        "match_disabled_and_enabled",
+        SystemPeriodic_match_disabled_and_enabled
     },
     {
-        "oneof_w_any",
-        Parser_oneof_w_any
+        "match_prefab",
+        SystemPeriodic_match_prefab
     },
     {
-        "oneof_w_fullpath",
-        Parser_oneof_w_fullpath
+        "match_prefab_and_normal",
+        SystemPeriodic_match_prefab_and_normal
     },
     {
-        "pair_implicit_src_missing_rel",
-        Parser_pair_implicit_src_missing_rel
+        "is_shared_on_column_not_set",
+        SystemPeriodic_is_shared_on_column_not_set
     },
     {
-        "pair_implicit_src_missing_obj",
-        Parser_pair_implicit_src_missing_obj
+        "owned_column",
+        SystemPeriodic_owned_column
     },
     {
-        "pair_explicit_src_missing_src",
-        Parser_pair_explicit_src_missing_src
+        "owned_not_column",
+        SystemPeriodic_owned_not_column
     },
     {
-        "pair_explicit_src_missing_obj",
-        Parser_pair_explicit_src_missing_obj
+        "owned_or_column",
+        SystemPeriodic_owned_or_column
     },
     {
-        "eq_id",
-        Parser_eq_id
+        "shared_column",
+        SystemPeriodic_shared_column
     },
     {
-        "eq_id_var",
-        Parser_eq_id_var
+        "shared_not_column",
+        SystemPeriodic_shared_not_column
     },
     {
-        "eq_var_id",
-        Parser_eq_var_id
+        "shared_or_column",
+        SystemPeriodic_shared_or_column
     },
     {
-        "eq_var",
-        Parser_eq_var
+        "container_dont_match_inheritance",
+        SystemPeriodic_container_dont_match_inheritance
     },
     {
-        "neq_id",
-        Parser_neq_id
+        "cascade_dont_match_inheritance",
+        SystemPeriodic_cascade_dont_match_inheritance
     },
     {
-        "neq_id_var",
-        Parser_neq_id_var
+        "not_from_entity",
+        SystemPeriodic_not_from_entity
     },
     {
-        "neq_var_id",
-        Parser_neq_var_id
+        "sys_context",
+        SystemPeriodic_sys_context
     },
     {
-        "neq_var",
-        Parser_neq_var
+        "get_sys_context_from_param",
+        SystemPeriodic_get_sys_context_from_param
     },
     {
-        "eq_name",
-        Parser_eq_name
+        "owned_only",
+        SystemPeriodic_owned_only
     },
     {
-        "eq_name_var",
-        Parser_eq_name_var
+        "shared_only",
+        SystemPeriodic_shared_only
     },
     {
-        "eq_var_name",
-        Parser_eq_var_name
+        "is_in_readonly",
+        SystemPeriodic_is_in_readonly
     },
     {
-        "eq_var",
-        Parser_eq_var
+        "get_period",
+        SystemPeriodic_get_period
     },
     {
-        "neq_name",
-        Parser_neq_name
+        "and_type",
+        SystemPeriodic_and_type
     },
     {
-        "neq_name_var",
-        Parser_neq_name_var
-    },
+        "or_type",
+        SystemPeriodic_or_type
+    }
+};
+
+bake_test_case Timer_testcases[] = {
     {
-        "neq_var_name",
-        Parser_neq_var_name
+        "timeout",
+        Timer_timeout
     },
     {
-        "neq_var",
-        Parser_neq_var
+        "interval",
+        Timer_interval
     },
     {
-        "match_name",
-        Parser_match_name
+        "shared_timeout",
+        Timer_shared_timeout
     },
     {
-        "match_name_var",
-        Parser_match_name_var
+        "shared_interval",
+        Timer_shared_interval
     },
     {
-        "match_var_name",
-        Parser_match_var_name
+        "start_stop_one_shot",
+        Timer_start_stop_one_shot
     },
     {
-        "match_var",
-        Parser_match_var
+        "start_stop_interval",
+        Timer_start_stop_interval
     },
     {
-        "nmatch_name",
-        Parser_nmatch_name
+        "rate_filter",
+        Timer_rate_filter
     },
     {
-        "nmatch_name_var",
-        Parser_nmatch_name_var
+        "rate_filter_w_rate_filter_src",
+        Timer_rate_filter_w_rate_filter_src
     },
     {
-        "nmatch_var_name",
-        Parser_nmatch_var_name
+        "rate_filter_w_timer_src",
+        Timer_rate_filter_w_timer_src
     },
     {
-        "eq_same_var",
-        Parser_eq_same_var
+        "rate_filter_with_empty_src",
+        Timer_rate_filter_with_empty_src
     },
     {
-        "neq_same_var",
-        Parser_neq_same_var
+        "one_shot_timer_entity",
+        Timer_one_shot_timer_entity
     },
     {
-        "eq_same_var_this",
-        Parser_eq_same_var_this
+        "interval_timer_entity",
+        Timer_interval_timer_entity
     },
     {
-        "neq_same_var_this",
-        Parser_neq_same_var_this
+        "rate_entity",
+        Timer_rate_entity
     },
     {
-        "eq_w_optional",
-        Parser_eq_w_optional
+        "nested_rate_entity",
+        Timer_nested_rate_entity
     },
     {
-        "neq_w_optional",
-        Parser_neq_w_optional
+        "nested_rate_entity_empty_src",
+        Timer_nested_rate_entity_empty_src
     },
     {
-        "match_w_optional",
-        Parser_match_w_optional
+        "naked_tick_entity",
+        Timer_naked_tick_entity
     },
     {
-        "query_scope_1_term",
-        Parser_query_scope_1_term
+        "stop_timer_w_rate",
+        Timer_stop_timer_w_rate
     },
     {
-        "query_scope_1_term_spaces",
-        Parser_query_scope_1_term_spaces
+        "stop_timer_w_rate_same_src",
+        Timer_stop_timer_w_rate_same_src
     },
     {
-        "query_scope_2_terms",
-        Parser_query_scope_2_terms
-    },
+        "randomize_timers",
+        Timer_randomize_timers
+    }
+};
+
+bake_test_case SystemCascade_testcases[] = {
     {
-        "query_nested_scope",
-        Parser_query_nested_scope
+        "cascade_depth_1",
+        SystemCascade_cascade_depth_1
     },
     {
-        "query_nested_scope_spaces",
-        Parser_query_nested_scope_spaces
+        "cascade_depth_2",
+        SystemCascade_cascade_depth_2
     },
     {
-        "query_scope_unbalanced",
-        Parser_query_scope_unbalanced
+        "cascade_depth_2_new_syntax",
+        SystemCascade_cascade_depth_2_new_syntax
     },
     {
-        "query_not_scope",
-        Parser_query_not_scope
+        "add_after_match",
+        SystemCascade_add_after_match
     },
     {
-        "query_empty_scope",
-        Parser_query_empty_scope
+        "adopt_after_match",
+        SystemCascade_adopt_after_match
     },
     {
-        "query_scope_newline_after_open",
-        Parser_query_scope_newline_after_open
+        "custom_relation_cascade_depth_1",
+        SystemCascade_custom_relation_cascade_depth_1
     },
     {
-        "query_scope_newline_after_close",
-        Parser_query_scope_newline_after_close
+        "custom_relation_cascade_depth_2",
+        SystemCascade_custom_relation_cascade_depth_2
     },
     {
-        "override_tag",
-        Parser_override_tag
+        "custom_relation_add_after_match",
+        SystemCascade_custom_relation_add_after_match
     },
     {
-        "override_pair",
-        Parser_override_pair
-    },
+        "custom_relation_adopt_after_match",
+        SystemCascade_custom_relation_adopt_after_match
+    }
+};
+
+bake_test_case SystemManual_testcases[] = {
     {
-        "pair_3_args",
-        Parser_pair_3_args
+        "1_type_1_component",
+        SystemManual_1_type_1_component
     },
     {
-        "pair_3_args_implicit_this",
-        Parser_pair_3_args_implicit_this
-    },
-    {
-        "pair_4_args",
-        Parser_pair_4_args
-    },
-    {
-        "pair_4_args_implicit_this",
-        Parser_pair_4_args_implicit_this
-    },
-    {
-        "pair_3_args_2_terms",
-        Parser_pair_3_args_2_terms
-    },
-    {
-        "pair_3_args_this_tgt",
-        Parser_pair_3_args_this_tgt
-    },
-    {
-        "pair_3_args_2_terms_this_tgt",
-        Parser_pair_3_args_2_terms_this_tgt
-    },
-    {
-        "pair_3_args_2_terms_this_tgt_implicit_this",
-        Parser_pair_3_args_2_terms_this_tgt_implicit_this
-    },
-    {
-        "pair_3_or_args",
-        Parser_pair_3_or_args
-    },
-    {
-        "pair_3_or_args_implicit_this",
-        Parser_pair_3_or_args_implicit_this
-    },
-    {
-        "pair_4_or_args",
-        Parser_pair_4_or_args
-    },
-    {
-        "pair_4_or_args_implicit_this",
-        Parser_pair_4_or_args_implicit_this
-    },
-    {
-        "pair_or_before_and_oper",
-        Parser_pair_or_before_and_oper
-    },
-    {
-        "pair_and_before_or_oper",
-        Parser_pair_and_before_or_oper
-    },
-    {
-        "cascade_desc",
-        Parser_cascade_desc
-    },
-    {
-        "newline_after_inout",
-        Parser_newline_after_inout
-    },
-    {
-        "newline_after_term_open",
-        Parser_newline_after_term_open
-    },
-    {
-        "newline_after_term_src",
-        Parser_newline_after_term_src
-    },
-    {
-        "newline_after_term_src_pair",
-        Parser_newline_after_term_src_pair
-    },
-    {
-        "newline_after_term_pair_comma",
-        Parser_newline_after_term_pair_comma
-    },
-    {
-        "newline_after_term_pair_second",
-        Parser_newline_after_term_pair_second
-    },
-    {
-        "tag_w_space_implicit_this",
-        Parser_tag_w_space_implicit_this
-    },
-    {
-        "tag_w_space",
-        Parser_tag_w_space
-    },
-    {
-        "pair_first_w_space_implicit_this",
-        Parser_pair_first_w_space_implicit_this
-    },
-    {
-        "pair_first_w_space",
-        Parser_pair_first_w_space
-    },
-    {
-        "pair_second_w_space_implicit_this",
-        Parser_pair_second_w_space_implicit_this
-    },
-    {
-        "pair_second_w_space",
-        Parser_pair_second_w_space
-    },
-    {
-        "pair_src_w_space",
-        Parser_pair_src_w_space
-    }
-};
-
-bake_test_case Plecs_testcases[] = {
-    {
-        "null",
-        Plecs_null
-    },
-    {
-        "empty",
-        Plecs_empty
-    },
-    {
-        "space",
-        Plecs_space
-    },
-    {
-        "space_newline",
-        Plecs_space_newline
-    },
-    {
-        "two_empty_newlines",
-        Plecs_two_empty_newlines
-    },
-    {
-        "three_empty_newlines",
-        Plecs_three_empty_newlines
-    },
-    {
-        "newline_trailing_space",
-        Plecs_newline_trailing_space
-    },
-    {
-        "newline_trailing_spaces",
-        Plecs_newline_trailing_spaces
-    },
-    {
-        "multiple_trailing_newlines",
-        Plecs_multiple_trailing_newlines
-    },
-    {
-        "entity",
-        Plecs_entity
-    },
-    {
-        "entity_w_entity",
-        Plecs_entity_w_entity
-    },
-    {
-        "entity_w_pair",
-        Plecs_entity_w_pair
-    },
-    {
-        "2_entities",
-        Plecs_2_entities
-    },
-    {
-        "2_entities_w_entities",
-        Plecs_2_entities_w_entities
-    },
-    {
-        "3_entities_w_pairs",
-        Plecs_3_entities_w_pairs
-    },
-    {
-        "line_comment",
-        Plecs_line_comment
-    },
-    {
-        "line_comment_before_stmt",
-        Plecs_line_comment_before_stmt
-    },
-    {
-        "line_comment_after_stmt",
-        Plecs_line_comment_after_stmt
-    },
-    {
-        "line_comment_between_stmt",
-        Plecs_line_comment_between_stmt
-    },
-    {
-        "multiple_line_comment",
-        Plecs_multiple_line_comment
-    },
-    {
-        "line_comment_after_stmt_same_line",
-        Plecs_line_comment_after_stmt_same_line
-    },
-    {
-        "comma_separated_pred",
-        Plecs_comma_separated_pred
-    },
-    {
-        "comma_separated_pred_w_subj",
-        Plecs_comma_separated_pred_w_subj
-    },
-    {
-        "comma_separated_pred_w_subj_obj",
-        Plecs_comma_separated_pred_w_subj_obj
-    },
-    {
-        "comma_separated_pred_trailing_comma",
-        Plecs_comma_separated_pred_trailing_comma
-    },
-    {
-        "comma_separated_pred_trailing_comma_newline",
-        Plecs_comma_separated_pred_trailing_comma_newline
-    },
-    {
-        "comma_separated_pred_trailing_comma_newline_multiline",
-        Plecs_comma_separated_pred_trailing_comma_newline_multiline
-    },
-    {
-        "hierarchy_1_child",
-        Plecs_hierarchy_1_child
-    },
-    {
-        "hierarchy_2_children",
-        Plecs_hierarchy_2_children
-    },
-    {
-        "hierarchy_1_child_same_line",
-        Plecs_hierarchy_1_child_same_line
-    },
-    {
-        "hierarchy_2_children_same_line",
-        Plecs_hierarchy_2_children_same_line
-    },
-    {
-        "entity_after_hierarchy",
-        Plecs_entity_after_hierarchy
-    },
-    {
-        "newline_before_scope_open",
-        Plecs_newline_before_scope_open
-    },
-    {
-        "comment_before_scope_open",
-        Plecs_comment_before_scope_open
-    },
-    {
-        "comment_after_newline_before_scope_open",
-        Plecs_comment_after_newline_before_scope_open
-    },
-    {
-        "hierarchy_2_levels",
-        Plecs_hierarchy_2_levels
-    },
-    {
-        "hierarchy_2_levels_2_subtrees",
-        Plecs_hierarchy_2_levels_2_subtrees
-    },
-    {
-        "missing_end_of_scope",
-        Plecs_missing_end_of_scope
-    },
-    {
-        "missing_end_of_predicate_scope",
-        Plecs_missing_end_of_predicate_scope
-    },
-    {
-        "create_in_scope",
-        Plecs_create_in_scope
-    },
-    {
-        "hierarchy_w_pred_subj",
-        Plecs_hierarchy_w_pred_subj
-    },
-    {
-        "hierarchy_custom_relation",
-        Plecs_hierarchy_custom_relation
-    },
-    {
-        "hierarchy_custom_relation_2_levels",
-        Plecs_hierarchy_custom_relation_2_levels
-    },
-    {
-        "hierarchy_custom_relation_apply_to_object",
-        Plecs_hierarchy_custom_relation_apply_to_object
-    },
-    {
-        "hierarchy_custom_relation_apply_to_object_2_levels",
-        Plecs_hierarchy_custom_relation_apply_to_object_2_levels
-    },
-    {
-        "entity_after_hierarchy_custom_relation",
-        Plecs_entity_after_hierarchy_custom_relation
-    },
-    {
-        "entity_after_hierarchy_custom_relation_2_levels",
-        Plecs_entity_after_hierarchy_custom_relation_2_levels
-    },
-    {
-        "pred_scope",
-        Plecs_pred_scope
-    },
-    {
-        "pred_scope_2_levels",
-        Plecs_pred_scope_2_levels
-    },
-    {
-        "pred_scope_inside_with",
-        Plecs_pred_scope_inside_with
-    },
-    {
-        "pred_scope_nested_w_subj_scope",
-        Plecs_pred_scope_nested_w_subj_scope
-    },
-    {
-        "with_tag",
-        Plecs_with_tag
-    },
-    {
-        "with_tag_2_entities",
-        Plecs_with_tag_2_entities
-    },
-    {
-        "with_tag_same_line",
-        Plecs_with_tag_same_line
-    },
-    {
-        "with_tag_2_entities_same_line",
-        Plecs_with_tag_2_entities_same_line
-    },
-    {
-        "with_tag_2_levels",
-        Plecs_with_tag_2_levels
-    },
-    {
-        "with_tag_2_levels_2_subtrees",
-        Plecs_with_tag_2_levels_2_subtrees
-    },
-    {
-        "with_n_tags",
-        Plecs_with_n_tags
-    },
-    {
-        "with_n_tags_2_levels",
-        Plecs_with_n_tags_2_levels
-    },
-    {
-        "with_after_scope",
-        Plecs_with_after_scope
-    },
-    {
-        "with_after_with",
-        Plecs_with_after_with
-    },
-    {
-        "scope_inside_with_inside_scope",
-        Plecs_scope_inside_with_inside_scope
-    },
-    {
-        "with_inside_scope",
-        Plecs_with_inside_scope
-    },
-    {
-        "assignment_w_1",
-        Plecs_assignment_w_1
-    },
-    {
-        "assignment_w_2",
-        Plecs_assignment_w_2
-    },
-    {
-        "assignment_w_pair",
-        Plecs_assignment_w_pair
-    },
-    {
-        "assignment_w_invalid_subject",
-        Plecs_assignment_w_invalid_subject
-    },
-    {
-        "assignment_w_invalid_with",
-        Plecs_assignment_w_invalid_with
-    },
-    {
-        "inherit_w_colon",
-        Plecs_inherit_w_colon
-    },
-    {
-        "inherit_w_colon_w_scope",
-        Plecs_inherit_w_colon_w_scope
-    },
-    {
-        "inherit_w_colon_w_assign",
-        Plecs_inherit_w_colon_w_assign
-    },
-    {
-        "assign_component_value",
-        Plecs_assign_component_value
-    },
-    {
-        "assign_2_component_values",
-        Plecs_assign_2_component_values
-    },
-    {
-        "assign_component_value_in_assign_scope",
-        Plecs_assign_component_value_in_assign_scope
-    },
-    {
-        "assign_2_component_values_in_assign_scope",
-        Plecs_assign_2_component_values_in_assign_scope
-    },
-    {
-        "type_and_assign_in_plecs",
-        Plecs_type_and_assign_in_plecs
-    },
-    {
-        "type_and_assign_in_plecs_w_2_members",
-        Plecs_type_and_assign_in_plecs_w_2_members
-    },
-    {
-        "type_and_assign_in_plecs_w_3_members",
-        Plecs_type_and_assign_in_plecs_w_3_members
-    },
-    {
-        "type_and_assign_in_plecs_w_enum",
-        Plecs_type_and_assign_in_plecs_w_enum
-    },
-    {
-        "type_and_assign_in_plecs_w_enum_using_meta",
-        Plecs_type_and_assign_in_plecs_w_enum_using_meta
-    },
-    {
-        "type_and_assign_in_plecs_w_enum_primitive_using_meta",
-        Plecs_type_and_assign_in_plecs_w_enum_primitive_using_meta
-    },
-    {
-        "type_and_assign_in_plecs_w_enum_primitive_and_struct",
-        Plecs_type_and_assign_in_plecs_w_enum_primitive_and_struct
-    },
-    {
-        "type_and_assign_in_plecs_nested_member",
-        Plecs_type_and_assign_in_plecs_nested_member
-    },
-    {
-        "dot_assign_nested_member",
-        Plecs_dot_assign_nested_member
-    },
-    {
-        "dot_assign_binary_expr",
-        Plecs_dot_assign_binary_expr
-    },
-    {
-        "open_scope_no_parent",
-        Plecs_open_scope_no_parent
-    },
-    {
-        "create_subject_in_root_scope_w_resolvable_id",
-        Plecs_create_subject_in_root_scope_w_resolvable_id
-    },
-    {
-        "create_subject_in_scope_w_resolvable_id",
-        Plecs_create_subject_in_scope_w_resolvable_id
-    },
-    {
-        "create_subject_in_scope_w_resolvable_id_using",
-        Plecs_create_subject_in_scope_w_resolvable_id_using
-    },
-    {
-        "using_scope",
-        Plecs_using_scope
-    },
-    {
-        "using_nested_scope",
-        Plecs_using_nested_scope
-    },
-    {
-        "using_nested_in_scope",
-        Plecs_using_nested_in_scope
-    },
-    {
-        "using_with_scope",
-        Plecs_using_with_scope
-    },
-    {
-        "using_w_entity_ref_in_value_2_members",
-        Plecs_using_w_entity_ref_in_value_2_members
-    },
-    {
-        "using_w_entity_ref_in_value_3_members",
-        Plecs_using_w_entity_ref_in_value_3_members
-    },
-    {
-        "2_using_scope",
-        Plecs_2_using_scope
-    },
-    {
-        "2_using_in_different_scope",
-        Plecs_2_using_in_different_scope
-    },
-    {
-        "empty_scope_after_using",
-        Plecs_empty_scope_after_using
-    },
-    {
-        "assignment_to_non_component",
-        Plecs_assignment_to_non_component
-    },
-    {
-        "struct_w_member_w_assignment_to_nothing",
-        Plecs_struct_w_member_w_assignment_to_nothing
-    },
-    {
-        "struct_w_member_w_assignment_to_empty_scope",
-        Plecs_struct_w_member_w_assignment_to_empty_scope
-    },
-    {
-        "scope_after_assign",
-        Plecs_scope_after_assign
-    },
-    {
-        "assign_after_inherit",
-        Plecs_assign_after_inherit
-    },
-    {
-        "multiple_assignments_single_line",
-        Plecs_multiple_assignments_single_line
-    },
-    {
-        "2_stmts_in_scope_w_no_parent",
-        Plecs_2_stmts_in_scope_w_no_parent
-    },
-    {
-        "scope_after_assign_1_tag",
-        Plecs_scope_after_assign_1_tag
-    },
-    {
-        "scope_after_assign_2_tags",
-        Plecs_scope_after_assign_2_tags
-    },
-    {
-        "invalid_nested_assignment",
-        Plecs_invalid_nested_assignment
-    },
-    {
-        "invalid_partial_pair_assignment",
-        Plecs_invalid_partial_pair_assignment
-    },
-    {
-        "empty_assignment",
-        Plecs_empty_assignment
-    },
-    {
-        "assign_tag_to_parent",
-        Plecs_assign_tag_to_parent
-    },
-    {
-        "assign_component_to_parent",
-        Plecs_assign_component_to_parent
-    },
-    {
-        "empty_assignment_before_end_of_scope",
-        Plecs_empty_assignment_before_end_of_scope
-    },
-    {
-        "assign_to_parent_pair_w_new_entities_in_scope",
-        Plecs_assign_to_parent_pair_w_new_entities_in_scope
-    },
-    {
-        "assign_to_parent_pair_w_existing_entities_in_scope",
-        Plecs_assign_to_parent_pair_w_existing_entities_in_scope
-    },
-    {
-        "default_child_component",
-        Plecs_default_child_component
-    },
-    {
-        "default_child_component_w_assign",
-        Plecs_default_child_component_w_assign
-    },
-    {
-        "struct_type_w_default_child_component",
-        Plecs_struct_type_w_default_child_component
-    },
-    {
-        "struct_type_w_default_child_component_nested_member",
-        Plecs_struct_type_w_default_child_component_nested_member
-    },
-    {
-        "enum_type_w_default_child_component",
-        Plecs_enum_type_w_default_child_component
-    },
-    {
-        "default_type_from_with",
-        Plecs_default_type_from_with
-    },
-    {
-        "scope_w_1_subj_and_2_pairs",
-        Plecs_scope_w_1_subj_and_2_pairs
-    },
-    {
-        "inherit_from_multiple",
-        Plecs_inherit_from_multiple
-    },
-    {
-        "assign_pair_component",
-        Plecs_assign_pair_component
-    },
-    {
-        "assign_pair_component_in_scope",
-        Plecs_assign_pair_component_in_scope
-    },
-    {
-        "assign_pair_component_in_script",
-        Plecs_assign_pair_component_in_script
-    },
-    {
-        "assign_pair_component_in_script_update",
-        Plecs_assign_pair_component_in_script_update
-    },
-    {
-        "set_entity_names",
-        Plecs_set_entity_names
-    },
-    {
-        "oneof",
-        Plecs_oneof
-    },
-    {
-        "invalid_oneof",
-        Plecs_invalid_oneof
-    },
-    {
-        "brief_annotation",
-        Plecs_brief_annotation
-    },
-    {
-        "name_annotation",
-        Plecs_name_annotation
-    },
-    {
-        "link_annotation",
-        Plecs_link_annotation
-    },
-    {
-        "color_annotation",
-        Plecs_color_annotation
-    },
-    {
-        "multiple_annotations",
-        Plecs_multiple_annotations
-    },
-    {
-        "annotation_w_trailing_space",
-        Plecs_annotation_w_trailing_space
-    },
-    {
-        "multiline_string",
-        Plecs_multiline_string
-    },
-    {
-        "unterminated_multiline_string",
-        Plecs_unterminated_multiline_string
-    },
-    {
-        "declaration_w_underscore_name",
-        Plecs_declaration_w_underscore_name
-    },
-    {
-        "annotate_declaration",
-        Plecs_annotate_declaration
-    },
-    {
-        "anonymous_entity",
-        Plecs_anonymous_entity
-    },
-    {
-        "anonymous_entity_in_scope",
-        Plecs_anonymous_entity_in_scope
-    },
-    {
-        "anonymous_declaration",
-        Plecs_anonymous_declaration
-    },
-    {
-        "const_var_int",
-        Plecs_const_var_int
-    },
-    {
-        "const_var_float",
-        Plecs_const_var_float
-    },
-    {
-        "const_var_bool",
-        Plecs_const_var_bool
-    },
-    {
-        "const_var_string",
-        Plecs_const_var_string
-    },
-    {
-        "const_var_struct",
-        Plecs_const_var_struct
-    },
-    {
-        "const_var_redeclare",
-        Plecs_const_var_redeclare
-    },
-    {
-        "const_var_scoped",
-        Plecs_const_var_scoped
-    },
-    {
-        "assign_component_from_var",
-        Plecs_assign_component_from_var
-    },
-    {
-        "assign_component_from_var_in_scope",
-        Plecs_assign_component_from_var_in_scope
-    },
-    {
-        "scope_w_component_after_const_var",
-        Plecs_scope_w_component_after_const_var
-    },
-    {
-        "component_after_const_paren_expr",
-        Plecs_component_after_const_paren_expr
-    },
-    {
-        "component_after_const_add_expr",
-        Plecs_component_after_const_add_expr
-    },
-    {
-        "component_after_const_sub_expr",
-        Plecs_component_after_const_sub_expr
-    },
-    {
-        "component_after_const_mul_expr",
-        Plecs_component_after_const_mul_expr
-    },
-    {
-        "component_after_const_div_expr",
-        Plecs_component_after_const_div_expr
-    },
-    {
-        "parse_with",
-        Plecs_parse_with
-    },
-    {
-        "parse_with_w_with",
-        Plecs_parse_with_w_with
-    },
-    {
-        "parse_with_w_tag",
-        Plecs_parse_with_w_tag
-    },
-    {
-        "parse_with_value",
-        Plecs_parse_with_value
-    },
-    {
-        "parse_with_2_values",
-        Plecs_parse_with_2_values
-    },
-    {
-        "parse_with_2_nested_values",
-        Plecs_parse_with_2_nested_values
-    },
-    {
-        "parse_with_var",
-        Plecs_parse_with_var
-    },
-    {
-        "parse_with_2_vars",
-        Plecs_parse_with_2_vars
-    },
-    {
-        "parse_with_2_nested_vars",
-        Plecs_parse_with_2_nested_vars
-    },
-    {
-        "parse_with_var_in_scope",
-        Plecs_parse_with_var_in_scope
-    },
-    {
-        "assign_const_w_expr",
-        Plecs_assign_const_w_expr
-    },
-    {
-        "const_w_type",
-        Plecs_const_w_type
-    },
-    {
-        "assembly_no_scope",
-        Plecs_assembly_no_scope
-    },
-    {
-        "assembly_empty",
-        Plecs_assembly_empty
-    },
-    {
-        "assembly_no_props",
-        Plecs_assembly_no_props
-    },
-    {
-        "assembly_prop_no_type",
-        Plecs_assembly_prop_no_type
-    },
-    {
-        "assembly_prop_no_default",
-        Plecs_assembly_prop_no_default
-    },
-    {
-        "assembly_prop",
-        Plecs_assembly_prop
-    },
-    {
-        "assembly_prop_space_colon",
-        Plecs_assembly_prop_space_colon
-    },
-    {
-        "assembly_2_props",
-        Plecs_assembly_2_props
-    },
-    {
-        "assembly_instance_w_default_values",
-        Plecs_assembly_instance_w_default_values
-    },
-    {
-        "assembly_instance_w_assign_default_values",
-        Plecs_assembly_instance_w_assign_default_values
-    },
-    {
-        "assembly_instance_w_overridden_values",
-        Plecs_assembly_instance_w_overridden_values
-    },
-    {
-        "assembly_w_child",
-        Plecs_assembly_w_child
-    },
-    {
-        "assembly_w_child_parse_script",
-        Plecs_assembly_w_child_parse_script
-    },
-    {
-        "assembly_w_child_parse_script_twice",
-        Plecs_assembly_w_child_parse_script_twice
-    },
-    {
-        "assembly_w_child_update_after_parse",
-        Plecs_assembly_w_child_update_after_parse
-    },
-    {
-        "assembly_w_nested_child",
-        Plecs_assembly_w_nested_child
-    },
-    {
-        "assembly_w_prefab",
-        Plecs_assembly_w_prefab
-    },
-    {
-        "assembly_w_prefab_tree",
-        Plecs_assembly_w_prefab_tree
-    },
-    {
-        "assembly_w_nested_assembly",
-        Plecs_assembly_w_nested_assembly
-    },
-    {
-        "instantiate_prefab_w_assembly",
-        Plecs_instantiate_prefab_w_assembly
-    },
-    {
-        "assembly_w_prefab_w_assembly",
-        Plecs_assembly_w_prefab_w_assembly
-    },
-    {
-        "3_assemblies",
-        Plecs_3_assemblies
-    },
-    {
-        "assembly_nested_w_default_var",
-        Plecs_assembly_nested_w_default_var
-    },
-    {
-        "assembly_w_anonymous",
-        Plecs_assembly_w_anonymous
-    },
-    {
-        "assembly_w_anonymous_parse_again",
-        Plecs_assembly_w_anonymous_parse_again
-    },
-    {
-        "typed_const_w_composite_type_invalid_assignment",
-        Plecs_typed_const_w_composite_type_invalid_assignment
-    },
-    {
-        "typed_const_w_composite_type",
-        Plecs_typed_const_w_composite_type
-    },
-    {
-        "assign_var_to_typed_const_w_composite_type",
-        Plecs_assign_var_to_typed_const_w_composite_type
-    },
-    {
-        "typed_const_w_composite_type_invalid_assignment",
-        Plecs_typed_const_w_composite_type_invalid_assignment
-    },
-    {
-        "assembly_w_composite_prop_invalid_assignment",
-        Plecs_assembly_w_composite_prop_invalid_assignment
-    },
-    {
-        "assembly_w_composite_prop",
-        Plecs_assembly_w_composite_prop
-    },
-    {
-        "assembly_with_with",
-        Plecs_assembly_with_with
-    },
-    {
-        "using_wildcard",
-        Plecs_using_wildcard
-    },
-    {
-        "single_line_comment_in_value",
-        Plecs_single_line_comment_in_value
-    },
-    {
-        "single_line_comment_in_value_after_scope",
-        Plecs_single_line_comment_in_value_after_scope
-    },
-    {
-        "multi_line_comment_in_value",
-        Plecs_multi_line_comment_in_value
-    },
-    {
-        "multi_line_comment_in_value_after_scope",
-        Plecs_multi_line_comment_in_value_after_scope
-    },
-    {
-        "unterminated_multi_line_comment_in_value",
-        Plecs_unterminated_multi_line_comment_in_value
-    },
-    {
-        "module_stmt",
-        Plecs_module_stmt
-    },
-    {
-        "nested_module_stmt",
-        Plecs_nested_module_stmt
-    },
-    {
-        "module_stmt_w_scope",
-        Plecs_module_stmt_w_scope
-    },
-    {
-        "module_stmt_w_nested_scope",
-        Plecs_module_stmt_w_nested_scope
-    },
-    {
-        "module_w_assembly",
-        Plecs_module_w_assembly
-    },
-    {
-        "module_w_nested_assembly",
-        Plecs_module_w_nested_assembly
-    },
-    {
-        "assign_singleton_tag",
-        Plecs_assign_singleton_tag
-    },
-    {
-        "assign_singleton_component",
-        Plecs_assign_singleton_component
-    },
-    {
-        "assign_singleton_tag_w_scope",
-        Plecs_assign_singleton_tag_w_scope
-    },
-    {
-        "assign_singleton_2_tags_w_scope",
-        Plecs_assign_singleton_2_tags_w_scope
-    },
-    {
-        "assign_singleton_component_w_scope",
-        Plecs_assign_singleton_component_w_scope
-    },
-    {
-        "assign_singleton_2_components_w_scope",
-        Plecs_assign_singleton_2_components_w_scope
-    },
-    {
-        "with_pair_in_scope",
-        Plecs_with_pair_in_scope
-    },
-    {
-        "assembly_redeclare_prop_as_const",
-        Plecs_assembly_redeclare_prop_as_const
-    },
-    {
-        "assembly_redeclare_prop_as_prop",
-        Plecs_assembly_redeclare_prop_as_prop
-    },
-    {
-        "assembly_redeclare_const_as_const",
-        Plecs_assembly_redeclare_const_as_const
-    },
-    {
-        "add_auto_override",
-        Plecs_add_auto_override
-    },
-    {
-        "add_auto_override_pair",
-        Plecs_add_auto_override_pair
-    },
-    {
-        "scope_w_auto_override",
-        Plecs_scope_w_auto_override
-    },
-    {
-        "scope_w_auto_override_pair",
-        Plecs_scope_w_auto_override_pair
-    },
-    {
-        "pair_w_rel_var",
-        Plecs_pair_w_rel_var
-    },
-    {
-        "pair_w_tgt_var",
-        Plecs_pair_w_tgt_var
-    },
-    {
-        "assembly_w_pair_w_this_var",
-        Plecs_assembly_w_pair_w_this_var
-    },
-    {
-        "with_value_not_a_component",
-        Plecs_with_value_not_a_component
-    },
-    {
-        "component_in_with_scope",
-        Plecs_component_in_with_scope
-    },
-    {
-        "component_in_with_scope_nested",
-        Plecs_component_in_with_scope_nested
-    },
-    {
-        "component_in_with_scope_in_scope",
-        Plecs_component_in_with_scope_in_scope
-    },
-    {
-        "assign_after_with_in_scope",
-        Plecs_assign_after_with_in_scope
-    },
-    {
-        "array_component",
-        Plecs_array_component
-    }
-};
-
-bake_test_case Doc_testcases[] = {
-    {
-        "get_set_name",
-        Doc_get_set_name
-    },
-    {
-        "get_entity_name",
-        Doc_get_entity_name
-    },
-    {
-        "get_set_brief",
-        Doc_get_set_brief
-    },
-    {
-        "get_set_detail",
-        Doc_get_set_detail
-    },
-    {
-        "get_set_link",
-        Doc_get_set_link
-    },
-    {
-        "set_name_nullptr",
-        Doc_set_name_nullptr
-    },
-    {
-        "set_brief_nullptr",
-        Doc_set_brief_nullptr
-    },
-    {
-        "set_detail_nullptr",
-        Doc_set_detail_nullptr
-    },
-    {
-        "set_link_nullptr",
-        Doc_set_link_nullptr
-    },
-    {
-        "set_color_nullptr",
-        Doc_set_color_nullptr
-    }
-};
-
-bake_test_case Pipeline_testcases[] = {
-    {
-        "system_order_same_phase",
-        Pipeline_system_order_same_phase
-    },
-    {
-        "system_order_same_phase_after_disable",
-        Pipeline_system_order_same_phase_after_disable
-    },
-    {
-        "system_order_same_phase_after_activate",
-        Pipeline_system_order_same_phase_after_activate
-    },
-    {
-        "system_order_different_phase",
-        Pipeline_system_order_different_phase
-    },
-    {
-        "system_order_different_phase_after_disable",
-        Pipeline_system_order_different_phase_after_disable
-    },
-    {
-        "system_order_different_phase_after_activate",
-        Pipeline_system_order_different_phase_after_activate
-    },
-    {
-        "system_order_after_new_system_lower_id",
-        Pipeline_system_order_after_new_system_lower_id
-    },
-    {
-        "system_order_after_new_system_inbetween_id",
-        Pipeline_system_order_after_new_system_inbetween_id
-    },
-    {
-        "system_order_after_new_system_higher_id",
-        Pipeline_system_order_after_new_system_higher_id
-    },
-    {
-        "system_reverse_order_by_phase_custom_pipeline",
-        Pipeline_system_reverse_order_by_phase_custom_pipeline
-    },
-    {
-        "merge_after_staged_out",
-        Pipeline_merge_after_staged_out
-    },
-    {
-        "merge_after_not_out",
-        Pipeline_merge_after_not_out
-    },
-    {
-        "no_merge_after_main_out",
-        Pipeline_no_merge_after_main_out
-    },
-    {
-        "merge_after_staged_in_out",
-        Pipeline_merge_after_staged_in_out
-    },
-    {
-        "merge_after_staged_inout_main_implicit_inout",
-        Pipeline_merge_after_staged_inout_main_implicit_inout
-    },
-    {
-        "merge_after_staged_inout_main_inout",
-        Pipeline_merge_after_staged_inout_main_inout
-    },
-    {
-        "merge_after_staged_out_before_owned",
-        Pipeline_merge_after_staged_out_before_owned
-    },
-    {
-        "switch_pipeline",
-        Pipeline_switch_pipeline
-    },
-    {
-        "run_pipeline",
-        Pipeline_run_pipeline
-    },
-    {
-        "get_pipeline_from_stage",
-        Pipeline_get_pipeline_from_stage
-    },
-    {
-        "3_systems_3_types",
-        Pipeline_3_systems_3_types
-    },
-    {
-        "random_read_after_random_write_out_in",
-        Pipeline_random_read_after_random_write_out_in
-    },
-    {
-        "random_read_after_random_write_inout_in",
-        Pipeline_random_read_after_random_write_inout_in
-    },
-    {
-        "random_read_after_random_write_out_inout",
-        Pipeline_random_read_after_random_write_out_inout
-    },
-    {
-        "random_read_after_random_write_inout_inout",
-        Pipeline_random_read_after_random_write_inout_inout
-    },
-    {
-        "random_read_after_random_write_w_not_write",
-        Pipeline_random_read_after_random_write_w_not_write
-    },
-    {
-        "random_read_after_random_write_w_not_read",
-        Pipeline_random_read_after_random_write_w_not_read
-    },
-    {
-        "random_read_after_random_write_w_wildcard",
-        Pipeline_random_read_after_random_write_w_wildcard
-    },
-    {
-        "random_in_after_random_inout_after_random_out",
-        Pipeline_random_in_after_random_inout_after_random_out
-    },
-    {
-        "stage_write_before_read",
-        Pipeline_stage_write_before_read
-    },
-    {
-        "mixed_multithreaded",
-        Pipeline_mixed_multithreaded
-    },
-    {
-        "mixed_multithreaded_tasks",
-        Pipeline_mixed_multithreaded_tasks
-    },
-    {
-        "mixed_staging",
-        Pipeline_mixed_staging
-    },
-    {
-        "no_staging_system_create_query",
-        Pipeline_no_staging_system_create_query
-    },
-    {
-        "single_threaded_pipeline_change",
-        Pipeline_single_threaded_pipeline_change
-    },
-    {
-        "multi_threaded_pipeline_change",
-        Pipeline_multi_threaded_pipeline_change
-    },
-    {
-        "multi_threaded_pipeline_change_tasks",
-        Pipeline_multi_threaded_pipeline_change_tasks
-    },
-    {
-        "activate_after_add",
-        Pipeline_activate_after_add
-    },
-    {
-        "match_all_after_pipeline_rebuild",
-        Pipeline_match_all_after_pipeline_rebuild
-    },
-    {
-        "empty_pipeline",
-        Pipeline_empty_pipeline
-    },
-    {
-        "custom_pipeline_w_system_macro",
-        Pipeline_custom_pipeline_w_system_macro
-    },
-    {
-        "pipeline_w_short_notation",
-        Pipeline_pipeline_w_short_notation
-    },
-    {
-        "stack_allocator_after_progress",
-        Pipeline_stack_allocator_after_progress
-    },
-    {
-        "stack_allocator_after_progress_w_pipeline_change",
-        Pipeline_stack_allocator_after_progress_w_pipeline_change
-    },
-    {
-        "iter_from_world_in_singlethread_system_multitead_app",
-        Pipeline_iter_from_world_in_singlethread_system_multitead_app
-    },
-    {
-        "iter_from_world_in_singlethread_system_multitead_app_tasks",
-        Pipeline_iter_from_world_in_singlethread_system_multitead_app_tasks
-    },
-    {
-        "no_staging_after_inactive_system",
-        Pipeline_no_staging_after_inactive_system
-    },
-    {
-        "inactive_system_after_no_staging_system_no_defer_w_filter",
-        Pipeline_inactive_system_after_no_staging_system_no_defer_w_filter
-    },
-    {
-        "inactive_system_after_2_no_staging_system_no_defer_w_filter",
-        Pipeline_inactive_system_after_2_no_staging_system_no_defer_w_filter
-    },
-    {
-        "inactive_system_after_no_staging_system_no_defer_w_filter_w_no_staging_at_end",
-        Pipeline_inactive_system_after_no_staging_system_no_defer_w_filter_w_no_staging_at_end
-    },
-    {
-        "inactive_multithread_system_after_no_staging_system_no_defer",
-        Pipeline_inactive_multithread_system_after_no_staging_system_no_defer
-    },
-    {
-        "inactive_multithread_tasks_system_after_no_staging_system_no_defer",
-        Pipeline_inactive_multithread_tasks_system_after_no_staging_system_no_defer
-    },
-    {
-        "inactive_multithread_system_after_no_staging_system_no_defer_w_no_staging_at_end",
-        Pipeline_inactive_multithread_system_after_no_staging_system_no_defer_w_no_staging_at_end
-    },
-    {
-        "inactive_multithread_tasks_system_after_no_staging_system_no_defer_w_no_staging_at_end",
-        Pipeline_inactive_multithread_tasks_system_after_no_staging_system_no_defer_w_no_staging_at_end
-    },
-    {
-        "multi_threaded_pipeline_change_w_only_singlethreaded",
-        Pipeline_multi_threaded_pipeline_change_w_only_singlethreaded
-    },
-    {
-        "multi_threaded_tasks_pipeline_change_w_only_singlethreaded",
-        Pipeline_multi_threaded_tasks_pipeline_change_w_only_singlethreaded
-    },
-    {
-        "sync_after_not_out_for_out",
-        Pipeline_sync_after_not_out_for_out
-    },
-    {
-        "pair_wildcard_read_after_staged_write",
-        Pipeline_pair_wildcard_read_after_staged_write
-    },
-    {
-        "pair_read_after_staged_wildcard_write",
-        Pipeline_pair_read_after_staged_wildcard_write
-    },
-    {
-        "no_sync_after_pair_wildcard_read_after_unmatching_staged_write",
-        Pipeline_no_sync_after_pair_wildcard_read_after_unmatching_staged_write
-    },
-    {
-        "no_merge_after_from_nothing_w_default_inout",
-        Pipeline_no_merge_after_from_nothing_w_default_inout
-    },
-    {
-        "on_merge_activate_system_before_merge",
-        Pipeline_on_merge_activate_system_before_merge
-    },
-    {
-        "disable_phase",
-        Pipeline_disable_phase
-    },
-    {
-        "disable_parent",
-        Pipeline_disable_parent
-    },
-    {
-        "multi_threaded_no_staging_w_add_after_read",
-        Pipeline_multi_threaded_no_staging_w_add_after_read
-    },
-    {
-        "multi_threaded_tasks_no_staging_w_add_after_read",
-        Pipeline_multi_threaded_tasks_no_staging_w_add_after_read
-    },
-    {
-        "1_startup_system",
-        Pipeline_1_startup_system
-    },
-    {
-        "2_startup_systems",
-        Pipeline_2_startup_systems
-    },
-    {
-        "2_startup_phases",
-        Pipeline_2_startup_phases
-    },
-    {
-        "2_startup_systems_w_merge",
-        Pipeline_2_startup_systems_w_merge
-    },
-    {
-        "inactive_last_system_merge_count",
-        Pipeline_inactive_last_system_merge_count
-    },
-    {
-        "inactive_middle_system_merge_count",
-        Pipeline_inactive_middle_system_merge_count
-    },
-    {
-        "last_no_readonly_system_merge_count",
-        Pipeline_last_no_readonly_system_merge_count
-    },
-    {
-        "2_pipelines_1_system",
-        Pipeline_2_pipelines_1_system
-    },
-    {
-        "builtin_pipeline_w_self_system_term",
-        Pipeline_builtin_pipeline_w_self_system_term
-    },
-    {
-        "custom_pipeline_w_self_system_term",
-        Pipeline_custom_pipeline_w_self_system_term
-    },
-    {
-        "switch_from_threads_to_tasks",
-        Pipeline_switch_from_threads_to_tasks
-    },
-    {
-        "switch_from_tasks_to_threads",
-        Pipeline_switch_from_tasks_to_threads
-    },
-    {
-        "run_pipeline_multithreaded",
-        Pipeline_run_pipeline_multithreaded
-    },
-    {
-        "run_pipeline_multithreaded_tasks",
-        Pipeline_run_pipeline_multithreaded_tasks
-    },
-    {
-        "pipeline_init_no_terms",
-        Pipeline_pipeline_init_no_terms
-    },
-    {
-        "pipeline_init_no_system_term",
-        Pipeline_pipeline_init_no_system_term
-    }
-};
-
-bake_test_case SystemMisc_testcases[] = {
-    {
-        "invalid_not_without_id",
-        SystemMisc_invalid_not_without_id
-    },
-    {
-        "invalid_optional_without_id",
-        SystemMisc_invalid_optional_without_id
-    },
-    {
-        "invalid_entity_without_id",
-        SystemMisc_invalid_entity_without_id
-    },
-    {
-        "invalid_empty_without_id",
-        SystemMisc_invalid_empty_without_id
-    },
-    {
-        "invalid_empty_element",
-        SystemMisc_invalid_empty_element
-    },
-    {
-        "invalid_empty_element_w_space",
-        SystemMisc_invalid_empty_element_w_space
-    },
-    {
-        "invalid_empty_or",
-        SystemMisc_invalid_empty_or
-    },
-    {
-        "invalid_empty_or_w_space",
-        SystemMisc_invalid_empty_or_w_space
-    },
-    {
-        "invalid_or_w_not",
-        SystemMisc_invalid_or_w_not
-    },
-    {
-        "invalid_not_w_or",
-        SystemMisc_invalid_not_w_or
-    },
-    {
-        "invalid_0_w_and",
-        SystemMisc_invalid_0_w_and
-    },
-    {
-        "invalid_0_w_from_entity",
-        SystemMisc_invalid_0_w_from_entity
-    },
-    {
-        "invalid_component_id",
-        SystemMisc_invalid_component_id
-    },
-    {
-        "invalid_entity_id",
-        SystemMisc_invalid_entity_id
-    },
-    {
-        "invalid_null_string",
-        SystemMisc_invalid_null_string
-    },
-    {
-        "invalid_empty_string",
-        SystemMisc_invalid_empty_string
-    },
-    {
-        "invalid_empty_string_w_space",
-        SystemMisc_invalid_empty_string_w_space
-    },
-    {
-        "redefine_row_system",
-        SystemMisc_redefine_row_system
-    },
-    {
-        "system_w_or_prefab",
-        SystemMisc_system_w_or_prefab
-    },
-    {
-        "system_w_or_disabled",
-        SystemMisc_system_w_or_disabled
-    },
-    {
-        "system_w_or_disabled_and_prefab",
-        SystemMisc_system_w_or_disabled_and_prefab
-    },
-    {
-        "table_columns_access",
-        SystemMisc_table_columns_access
-    },
-    {
-        "dont_enable_after_rematch",
-        SystemMisc_dont_enable_after_rematch
-    },
-    {
-        "ensure_single_merge",
-        SystemMisc_ensure_single_merge
-    },
-    {
-        "table_count",
-        SystemMisc_table_count
-    },
-    {
-        "match_system",
-        SystemMisc_match_system
-    },
-    {
-        "system_initial_state",
-        SystemMisc_system_initial_state
-    },
-    {
-        "add_own_component",
-        SystemMisc_add_own_component
-    },
-    {
-        "change_system_action",
-        SystemMisc_change_system_action
-    },
-    {
-        "system_readeactivate",
-        SystemMisc_system_readeactivate
-    },
-    {
-        "system_readeactivate_w_2_systems",
-        SystemMisc_system_readeactivate_w_2_systems
-    },
-    {
-        "add_to_system_in_progress",
-        SystemMisc_add_to_system_in_progress
-    },
-    {
-        "redefine_null_signature",
-        SystemMisc_redefine_null_signature
-    },
-    {
-        "redefine_0_signature",
-        SystemMisc_redefine_0_signature
-    },
-    {
-        "one_named_column_of_two",
-        SystemMisc_one_named_column_of_two
-    },
-    {
-        "two_named_columns_of_two",
-        SystemMisc_two_named_columns_of_two
-    },
-    {
-        "redeclare_system_explicit_id",
-        SystemMisc_redeclare_system_explicit_id
-    },
-    {
-        "redeclare_system_explicit_id_null_expr",
-        SystemMisc_redeclare_system_explicit_id_null_expr
-    },
-    {
-        "redeclare_system_explicit_id_no_name",
-        SystemMisc_redeclare_system_explicit_id_no_name
-    },
-    {
-        "declare_different_id_same_name",
-        SystemMisc_declare_different_id_same_name
-    },
-    {
-        "declare_different_id_same_name_w_scope",
-        SystemMisc_declare_different_id_same_name_w_scope
-    },
-    {
-        "rw_in_implicit_any",
-        SystemMisc_rw_in_implicit_any
-    },
-    {
-        "rw_in_implicit_shared",
-        SystemMisc_rw_in_implicit_shared
-    },
-    {
-        "rw_in_implicit_from_empty",
-        SystemMisc_rw_in_implicit_from_empty
-    },
-    {
-        "rw_in_implicit_from_entity",
-        SystemMisc_rw_in_implicit_from_entity
-    },
-    {
-        "rw_out_explicit_any",
-        SystemMisc_rw_out_explicit_any
-    },
-    {
-        "rw_out_explicit_shared",
-        SystemMisc_rw_out_explicit_shared
-    },
-    {
-        "rw_out_explicit_from_empty",
-        SystemMisc_rw_out_explicit_from_empty
-    },
-    {
-        "rw_out_explicit_from_entity",
-        SystemMisc_rw_out_explicit_from_entity
-    },
-    {
-        "activate_system_for_table_w_n_pairs",
-        SystemMisc_activate_system_for_table_w_n_pairs
-    },
-    {
-        "get_query",
-        SystemMisc_get_query
-    },
-    {
-        "set_get_context",
-        SystemMisc_set_get_context
-    },
-    {
-        "set_get_binding_context",
-        SystemMisc_set_get_binding_context
-    },
-    {
-        "deactivate_after_disable",
-        SystemMisc_deactivate_after_disable
-    },
-    {
-        "delete_system",
-        SystemMisc_delete_system
-    },
-    {
-        "delete_pipeline_system",
-        SystemMisc_delete_pipeline_system
-    },
-    {
-        "delete_system_w_ctx",
-        SystemMisc_delete_system_w_ctx
-    },
-    {
-        "update_ctx",
-        SystemMisc_update_ctx
-    },
-    {
-        "run_custom_run_action",
-        SystemMisc_run_custom_run_action
-    },
-    {
-        "run_w_offset_limit_custom_run_action",
-        SystemMisc_run_w_offset_limit_custom_run_action
-    },
-    {
-        "pipeline_custom_run_action",
-        SystemMisc_pipeline_custom_run_action
-    },
-    {
-        "change_custom_run_action",
-        SystemMisc_change_custom_run_action
-    },
-    {
-        "custom_run_action_call_next",
-        SystemMisc_custom_run_action_call_next
-    },
-    {
-        "system_w_short_notation",
-        SystemMisc_system_w_short_notation
-    },
-    {
-        "update_interval_w_system_init",
-        SystemMisc_update_interval_w_system_init
-    },
-    {
-        "update_rate_w_system_init",
-        SystemMisc_update_rate_w_system_init
-    },
-    {
-        "system_w_interval_rate_stop_timer",
-        SystemMisc_system_w_interval_rate_stop_timer
-    },
-    {
-        "system_same_interval_same_tick",
-        SystemMisc_system_same_interval_same_tick
-    }
-};
-
-bake_test_case RulesBasic_testcases[] = {
-    {
-        "1_fact_w_tag",
-        RulesBasic_1_fact_w_tag
-    },
-    {
-        "1_fact_w_component",
-        RulesBasic_1_fact_w_component
-    },
-    {
-        "1_fact_w_tag_pair",
-        RulesBasic_1_fact_w_tag_pair
-    },
-    {
-        "1_fact_w_component_pair",
-        RulesBasic_1_fact_w_component_pair
-    },
-    {
-        "2_facts_same_src_w_tag",
-        RulesBasic_2_facts_same_src_w_tag
-    },
-    {
-        "2_facts_same_src_w_component",
-        RulesBasic_2_facts_same_src_w_component
-    },
-    {
-        "2_facts_same_src_w_tag_pair",
-        RulesBasic_2_facts_same_src_w_tag_pair
-    },
-    {
-        "2_facts_same_src_w_component_pair",
-        RulesBasic_2_facts_same_src_w_component_pair
-    },
-    {
-        "2_facts_other_src_w_tag",
-        RulesBasic_2_facts_other_src_w_tag
-    },
-    {
-        "2_facts_other_src_w_component",
-        RulesBasic_2_facts_other_src_w_component
-    },
-    {
-        "2_facts_other_src_w_tag_pair",
-        RulesBasic_2_facts_other_src_w_tag_pair
-    },
-    {
-        "2_facts_other_src_w_component_pair",
-        RulesBasic_2_facts_other_src_w_component_pair
-    },
-    {
-        "1_fact_w_any",
-        RulesBasic_1_fact_w_any
-    },
-    {
-        "1_fact_w_pair_any_tgt",
-        RulesBasic_1_fact_w_pair_any_tgt
-    },
-    {
-        "1_fact_w_pair_any_rel",
-        RulesBasic_1_fact_w_pair_any_rel
-    },
-    {
-        "1_fact_w_pair_any_rel_tgt",
-        RulesBasic_1_fact_w_pair_any_rel_tgt
-    },
-    {
-        "2_facts_same_src_w_any",
-        RulesBasic_2_facts_same_src_w_any
-    },
-    {
-        "2_facts_same_src_w_pair_any_tgt",
-        RulesBasic_2_facts_same_src_w_pair_any_tgt
-    },
-    {
-        "2_facts_same_src_w_pair_any_rel",
-        RulesBasic_2_facts_same_src_w_pair_any_rel
-    },
-    {
-        "2_facts_same_src_w_pair_any_rel_tgt",
-        RulesBasic_2_facts_same_src_w_pair_any_rel_tgt
-    },
-    {
-        "2_facts_other_src_w_any",
-        RulesBasic_2_facts_other_src_w_any
-    },
-    {
-        "2_facts_other_src_w_pair_any_tgt",
-        RulesBasic_2_facts_other_src_w_pair_any_tgt
-    },
-    {
-        "2_facts_other_src_w_pair_any_rel",
-        RulesBasic_2_facts_other_src_w_pair_any_rel
-    },
-    {
-        "2_facts_other_src_w_pair_any_rel_tgt",
-        RulesBasic_2_facts_other_src_w_pair_any_rel_tgt
-    },
-    {
-        "1_this_src_w_tag",
-        RulesBasic_1_this_src_w_tag
-    },
-    {
-        "1_this_src_w_component",
-        RulesBasic_1_this_src_w_component
-    },
-    {
-        "1_this_src_w_tag_pair",
-        RulesBasic_1_this_src_w_tag_pair
-    },
-    {
-        "1_this_src_w_component_pair",
-        RulesBasic_1_this_src_w_component_pair
-    },
-    {
-        "1_this_src_w_tag_2_tables",
-        RulesBasic_1_this_src_w_tag_2_tables
-    },
-    {
-        "1_this_src_w_component_2_tables",
-        RulesBasic_1_this_src_w_component_2_tables
-    },
-    {
-        "1_this_src_w_tag_pair_2_tables",
-        RulesBasic_1_this_src_w_tag_pair_2_tables
-    },
-    {
-        "1_this_src_w_component_pair_2_tables",
-        RulesBasic_1_this_src_w_component_pair_2_tables
-    },
-    {
-        "2_this_src_w_tag",
-        RulesBasic_2_this_src_w_tag
-    },
-    {
-        "2_this_src_w_component",
-        RulesBasic_2_this_src_w_component
-    },
-    {
-        "2_this_src_ent_src_w_tag",
-        RulesBasic_2_this_src_ent_src_w_tag
-    },
-    {
-        "2_this_src_ent_src_w_component",
-        RulesBasic_2_this_src_ent_src_w_component
-    },
-    {
-        "2_ent_src_this_src_w_tag",
-        RulesBasic_2_ent_src_this_src_w_tag
-    },
-    {
-        "2_ent_src_this_src_w_component",
-        RulesBasic_2_ent_src_this_src_w_component
-    },
-    {
-        "recycled_tag",
-        RulesBasic_recycled_tag
-    },
-    {
-        "recycled_src",
-        RulesBasic_recycled_src
-    },
-    {
-        "recycled_pair_rel",
-        RulesBasic_recycled_pair_rel
-    },
-    {
-        "recycled_pair_tgt",
-        RulesBasic_recycled_pair_tgt
-    },
-    {
-        "this_src_w_wildcard",
-        RulesBasic_this_src_w_wildcard
-    },
-    {
-        "this_src_w_pair_rel_wildcard",
-        RulesBasic_this_src_w_pair_rel_wildcard
-    },
-    {
-        "this_src_w_pair_tgt_wildcard",
-        RulesBasic_this_src_w_pair_tgt_wildcard
-    },
-    {
-        "this_src_w_pair_rel_tgt_wildcard",
-        RulesBasic_this_src_w_pair_rel_tgt_wildcard
-    },
-    {
-        "this_src_w_any",
-        RulesBasic_this_src_w_any
-    },
-    {
-        "this_src_w_any_written",
-        RulesBasic_this_src_w_any_written
-    },
-    {
-        "this_src_w_pair_rel_any",
-        RulesBasic_this_src_w_pair_rel_any
-    },
-    {
-        "this_src_w_pair_tgt_any",
-        RulesBasic_this_src_w_pair_tgt_any
-    },
-    {
-        "this_src_w_pair_rel_tgt_any",
-        RulesBasic_this_src_w_pair_rel_tgt_any
-    },
-    {
-        "ent_src_w_wildcard",
-        RulesBasic_ent_src_w_wildcard
-    },
-    {
-        "ent_src_w_pair_rel_wildcard",
-        RulesBasic_ent_src_w_pair_rel_wildcard
-    },
-    {
-        "ent_src_w_pair_tgt_wildcard",
-        RulesBasic_ent_src_w_pair_tgt_wildcard
-    },
-    {
-        "ent_src_w_pair_rel_tgt_wildcard",
-        RulesBasic_ent_src_w_pair_rel_tgt_wildcard
-    },
-    {
-        "1_wildcard_src",
-        RulesBasic_1_wildcard_src
-    },
-    {
-        "1_wildcard_src_w_pair",
-        RulesBasic_1_wildcard_src_w_pair
-    },
-    {
-        "2_wildcard_src",
-        RulesBasic_2_wildcard_src
-    },
-    {
-        "2_wildcard_src_w_pair",
-        RulesBasic_2_wildcard_src_w_pair
-    },
-    {
-        "1_wildcard_src_w_pair_tgt_var",
-        RulesBasic_1_wildcard_src_w_pair_tgt_var
-    },
-    {
-        "1_wildcard_src_w_pair_rel_var",
-        RulesBasic_1_wildcard_src_w_pair_rel_var
-    },
-    {
-        "1_wildcard_src_w_pair_tgt_this",
-        RulesBasic_1_wildcard_src_w_pair_tgt_this
-    },
-    {
-        "1_wildcard_src_w_pair_rel_this",
-        RulesBasic_1_wildcard_src_w_pair_rel_this
-    },
-    {
-        "1_any_src",
-        RulesBasic_1_any_src
-    },
-    {
-        "1_any_src_component",
-        RulesBasic_1_any_src_component
-    },
-    {
-        "1_any_src_component_w_this_component",
-        RulesBasic_1_any_src_component_w_this_component
-    },
-    {
-        "1_any_src_w_pair",
-        RulesBasic_1_any_src_w_pair
-    },
-    {
-        "2_any_src",
-        RulesBasic_2_any_src
-    },
-    {
-        "2_any_src_w_pair",
-        RulesBasic_2_any_src_w_pair
-    },
-    {
-        "1_any_src_w_pair_tgt_var",
-        RulesBasic_1_any_src_w_pair_tgt_var
-    },
-    {
-        "1_any_src_w_pair_rel_var",
-        RulesBasic_1_any_src_w_pair_rel_var
-    },
-    {
-        "1_any_src_w_pair_tgt_this",
-        RulesBasic_1_any_src_w_pair_tgt_this
-    },
-    {
-        "1_any_src_w_pair_rel_this",
-        RulesBasic_1_any_src_w_pair_rel_this
-    },
-    {
-        "1_any_src_any_tgt_w_rel_fixed",
-        RulesBasic_1_any_src_any_tgt_w_rel_fixed
-    },
-    {
-        "1_any_src_any_rel_w_tgt_fixed",
-        RulesBasic_1_any_src_any_rel_w_tgt_fixed
-    },
-    {
-        "1_any_src_w_childof_pair_any_tgt",
-        RulesBasic_1_any_src_w_childof_pair_any_tgt
-    },
-    {
-        "1_any_src_empty",
-        RulesBasic_1_any_src_empty
-    },
-    {
-        "1_any_src_pair_tgt_wildcard_empty",
-        RulesBasic_1_any_src_pair_tgt_wildcard_empty
-    },
-    {
-        "1_any_src_pair_rel_wildcard_empty",
-        RulesBasic_1_any_src_pair_rel_wildcard_empty
-    },
-    {
-        "1_any_src_any_tgt_w_rel_fixed_empty",
-        RulesBasic_1_any_src_any_tgt_w_rel_fixed_empty
-    },
-    {
-        "1_any_src_any_rel_w_tgt_fixed_empty",
-        RulesBasic_1_any_src_any_rel_w_tgt_fixed_empty
-    },
-    {
-        "1_any_src_pair_w_tag_query_empty",
-        RulesBasic_1_any_src_pair_w_tag_query_empty
-    },
-    {
-        "1_any_src_tag_w_pair_query_empty",
-        RulesBasic_1_any_src_tag_w_pair_query_empty
-    },
-    {
-        "not_any",
-        RulesBasic_not_any
-    },
-    {
-        "rule_w_iter_next",
-        RulesBasic_rule_w_iter_next
-    },
-    {
-        "empty_rule",
-        RulesBasic_empty_rule
-    },
-    {
-        "invalid_rule",
-        RulesBasic_invalid_rule
-    },
-    {
-        "not_instanced_table_src",
-        RulesBasic_not_instanced_table_src
-    },
-    {
-        "not_instanced_entity_src",
-        RulesBasic_not_instanced_entity_src
-    },
-    {
-        "not_instanced_mixed_src",
-        RulesBasic_not_instanced_mixed_src
-    },
-    {
-        "instanced_table_src",
-        RulesBasic_instanced_table_src
-    },
-    {
-        "instanced_entity_src",
-        RulesBasic_instanced_entity_src
-    },
-    {
-        "instanced_mixed_src",
-        RulesBasic_instanced_mixed_src
-    },
-    {
-        "in_term",
-        RulesBasic_in_term
-    },
-    {
-        "out_term",
-        RulesBasic_out_term
-    },
-    {
-        "inout_term",
-        RulesBasic_inout_term
-    },
-    {
-        "nodata_term",
-        RulesBasic_nodata_term
-    },
-    {
-        "find_this_lowercase",
-        RulesBasic_find_this_lowercase
-    },
-    {
-        "find_this_uppercase",
-        RulesBasic_find_this_uppercase
-    },
-    {
-        "find_this_tgt_lowercase",
-        RulesBasic_find_this_tgt_lowercase
-    },
-    {
-        "find_this_tgt_uppercase",
-        RulesBasic_find_this_tgt_uppercase
-    },
-    {
-        "get_filter",
-        RulesBasic_get_filter
-    },
-    {
-        "iter_empty_source",
-        RulesBasic_iter_empty_source
-    },
-    {
-        "iter_empty_source_2_terms",
-        RulesBasic_iter_empty_source_2_terms
-    },
-    {
-        "iter_empty_source_wildcard",
-        RulesBasic_iter_empty_source_wildcard
-    },
-    {
-        "iter_empty_source_pair",
-        RulesBasic_iter_empty_source_pair
-    },
-    {
-        "iter_empty_source_pair_wildcard",
-        RulesBasic_iter_empty_source_pair_wildcard
-    },
-    {
-        "iter_empty_source_2_terms_pair",
-        RulesBasic_iter_empty_source_2_terms_pair
-    },
-    {
-        "iter_empty_source_2_terms_mixed",
-        RulesBasic_iter_empty_source_2_terms_mixed
-    },
-    {
-        "iter_empty_source_2_terms_mixed_pair",
-        RulesBasic_iter_empty_source_2_terms_mixed_pair
-    },
-    {
-        "iter_empty_source_2_terms_mixed_pair_wildcard",
-        RulesBasic_iter_empty_source_2_terms_mixed_pair_wildcard
-    },
-    {
-        "this_var_w_empty_entity",
-        RulesBasic_this_var_w_empty_entity
-    },
-    {
-        "match_disabled",
-        RulesBasic_match_disabled
-    },
-    {
-        "match_prefab",
-        RulesBasic_match_prefab
-    },
-    {
-        "match_disabled_prefab",
-        RulesBasic_match_disabled_prefab
-    },
-    {
-        "match_disabled_this_tgt",
-        RulesBasic_match_disabled_this_tgt
-    },
-    {
-        "match_prefab_this_tgt",
-        RulesBasic_match_prefab_this_tgt
-    },
-    {
-        "match_disabled_prefab_this_tgt",
-        RulesBasic_match_disabled_prefab_this_tgt
-    },
-    {
-        "match_self_disabled",
-        RulesBasic_match_self_disabled
-    },
-    {
-        "match_self_prefab",
-        RulesBasic_match_self_prefab
-    },
-    {
-        "match_self_disabled_prefab",
-        RulesBasic_match_self_disabled_prefab
-    },
-    {
-        "inout_none_first_term",
-        RulesBasic_inout_none_first_term
-    },
-    {
-        "inout_none_second_term",
-        RulesBasic_inout_none_second_term
-    },
-    {
-        "no_data_rule",
-        RulesBasic_no_data_rule
-    },
-    {
-        "frame_offset",
-        RulesBasic_frame_offset
-    },
-    {
-        "frame_offset_no_data",
-        RulesBasic_frame_offset_no_data
-    },
-    {
-        "match_empty_tables",
-        RulesBasic_match_empty_tables
-    },
-    {
-        "match_empty_tables_no_data",
-        RulesBasic_match_empty_tables_no_data
-    },
-    {
-        "match_empty_tables_w_not",
-        RulesBasic_match_empty_tables_w_not
-    },
-    {
-        "match_empty_tables_w_wildcard",
-        RulesBasic_match_empty_tables_w_wildcard
-    },
-    {
-        "match_empty_tables_w_no_empty_tables",
-        RulesBasic_match_empty_tables_w_no_empty_tables
-    },
-    {
-        "match_empty_tables_trivial",
-        RulesBasic_match_empty_tables_trivial
-    },
-    {
-        "oneof_wildcard",
-        RulesBasic_oneof_wildcard
-    },
-    {
-        "oneof_any",
-        RulesBasic_oneof_any
-    },
-    {
-        "instanced_w_singleton",
-        RulesBasic_instanced_w_singleton
-    },
-    {
-        "instanced_w_base",
-        RulesBasic_instanced_w_base
-    },
-    {
-        "not_instanced_w_singleton",
-        RulesBasic_not_instanced_w_singleton
-    },
-    {
-        "not_instanced_w_base",
-        RulesBasic_not_instanced_w_base
-    },
-    {
-        "unknown_before_known",
-        RulesBasic_unknown_before_known
-    },
-    {
-        "unknown_before_known_after_or",
-        RulesBasic_unknown_before_known_after_or
-    },
-    {
-        "unknown_before_known_after_not",
-        RulesBasic_unknown_before_known_after_not
-    },
-    {
-        "unknown_before_known_after_optional",
-        RulesBasic_unknown_before_known_after_optional
-    },
-    {
-        "unknown_before_known_after_scope",
-        RulesBasic_unknown_before_known_after_scope
-    },
-    {
-        "reordered_plan_1",
-        RulesBasic_reordered_plan_1
-    },
-    {
-        "reordered_plan_2",
-        RulesBasic_reordered_plan_2
-    },
-    {
-        "1_trivial_plan",
-        RulesBasic_1_trivial_plan
-    },
-    {
-        "2_trivial_plan",
-        RulesBasic_2_trivial_plan
-    },
-    {
-        "1_trivial_plan_component",
-        RulesBasic_1_trivial_plan_component
-    },
-    {
-        "2_trivial_plan_component",
-        RulesBasic_2_trivial_plan_component
-    },
-    {
-        "2_trivial_plan_w_wildcard",
-        RulesBasic_2_trivial_plan_w_wildcard
-    },
-    {
-        "3_trivial_plan_w_pair",
-        RulesBasic_3_trivial_plan_w_pair
-    },
-    {
-        "3_trivial_plan_w_wildcard",
-        RulesBasic_3_trivial_plan_w_wildcard
-    },
-    {
-        "3_trivial_plan_w_any",
-        RulesBasic_3_trivial_plan_w_any
-    },
-    {
-        "3_trivial_plan_w_pair_component",
-        RulesBasic_3_trivial_plan_w_pair_component
-    },
-    {
-        "3_trivial_plan_w_wildcard_component",
-        RulesBasic_3_trivial_plan_w_wildcard_component
-    },
-    {
-        "3_trivial_plan_w_any_component",
-        RulesBasic_3_trivial_plan_w_any_component
-    },
-    {
-        "1_trivial_component_w_none",
-        RulesBasic_1_trivial_component_w_none
-    },
-    {
-        "2_trivial_component_w_none",
-        RulesBasic_2_trivial_component_w_none
-    },
-    {
-        "2_trivial_mixed_2_tables",
-        RulesBasic_2_trivial_mixed_2_tables
-    },
-    {
-        "2_trivial_mixed_2_tables_component",
-        RulesBasic_2_trivial_mixed_2_tables_component
-    },
-    {
-        "2_trivial_mixed_2_tables_wildcard",
-        RulesBasic_2_trivial_mixed_2_tables_wildcard
-    },
-    {
-        "1_plan_any_src",
-        RulesBasic_1_plan_any_src
-    },
-    {
-        "1_plan_not_any_src",
-        RulesBasic_1_plan_not_any_src
-    },
-    {
-        "1_plan_optional_any_src",
-        RulesBasic_1_plan_optional_any_src
-    }
-};
-
-bake_test_case RulesVariables_testcases[] = {
-    {
-        "1_ent_src_w_var",
-        RulesVariables_1_ent_src_w_var
-    },
-    {
-        "1_ent_src_w_pair_rel_var",
-        RulesVariables_1_ent_src_w_pair_rel_var
-    },
-    {
-        "1_ent_src_w_pair_tgt_var",
-        RulesVariables_1_ent_src_w_pair_tgt_var
-    },
-    {
-        "1_ent_src_w_pair_rel_tgt_var",
-        RulesVariables_1_ent_src_w_pair_rel_tgt_var
-    },
-    {
-        "1_ent_src_w_pair_rel_tgt_same_var",
-        RulesVariables_1_ent_src_w_pair_rel_tgt_same_var
-    },
-    {
-        "1_ent_src_w_pair_rel_tgt_same_var_after_write",
-        RulesVariables_1_ent_src_w_pair_rel_tgt_same_var_after_write
-    },
-    {
-        "1_this_src_w_var",
-        RulesVariables_1_this_src_w_var
-    },
-    {
-        "1_this_src_w_pair_rel_var",
-        RulesVariables_1_this_src_w_pair_rel_var
-    },
-    {
-        "1_this_src_w_pair_tgt_var",
-        RulesVariables_1_this_src_w_pair_tgt_var
-    },
-    {
-        "1_this_src_w_pair_rel_tgt_var",
-        RulesVariables_1_this_src_w_pair_rel_tgt_var
-    },
-    {
-        "1_this_src_w_pair_rel_tgt_same_var",
-        RulesVariables_1_this_src_w_pair_rel_tgt_same_var
-    },
-    {
-        "1_this_src_w_pair_rel_tgt_same_var_after_write",
-        RulesVariables_1_this_src_w_pair_rel_tgt_same_var_after_write
-    },
-    {
-        "1_src_id_same_var",
-        RulesVariables_1_src_id_same_var
-    },
-    {
-        "1_src_pair_first_same_var",
-        RulesVariables_1_src_pair_first_same_var
-    },
-    {
-        "1_src_pair_second_same_var",
-        RulesVariables_1_src_pair_second_same_var
-    },
-    {
-        "1_src_pair_first_and_second_same_var",
-        RulesVariables_1_src_pair_first_and_second_same_var
-    },
-    {
-        "1_src_id_same_var_after_write",
-        RulesVariables_1_src_id_same_var_after_write
-    },
-    {
-        "1_src_pair_first_same_var_after_write",
-        RulesVariables_1_src_pair_first_same_var_after_write
-    },
-    {
-        "1_src_pair_second_same_var_after_write",
-        RulesVariables_1_src_pair_second_same_var_after_write
-    },
-    {
-        "1_src_pair_first_and_second_same_var_after_write",
-        RulesVariables_1_src_pair_first_and_second_same_var_after_write
-    },
-    {
-        "1_src_pair_first_same_var_this",
-        RulesVariables_1_src_pair_first_same_var_this
-    },
-    {
-        "1_src_pair_second_same_var_this",
-        RulesVariables_1_src_pair_second_same_var_this
-    },
-    {
-        "1_src_pair_first_and_second_same_var_this",
-        RulesVariables_1_src_pair_first_and_second_same_var_this
-    },
-    {
-        "1_src_id_same_var_this_after_write",
-        RulesVariables_1_src_id_same_var_this_after_write
-    },
-    {
-        "1_src_pair_first_same_var_this_after_write",
-        RulesVariables_1_src_pair_first_same_var_this_after_write
-    },
-    {
-        "1_src_pair_second_same_var_this_after_write",
-        RulesVariables_1_src_pair_second_same_var_this_after_write
-    },
-    {
-        "1_src_pair_first_and_second_same_var_this_after_write",
-        RulesVariables_1_src_pair_first_and_second_same_var_this_after_write
-    },
-    {
-        "1_ent_src_w_this_var",
-        RulesVariables_1_ent_src_w_this_var
-    },
-    {
-        "1_ent_src_w_pair_this_rel",
-        RulesVariables_1_ent_src_w_pair_this_rel
-    },
-    {
-        "1_ent_src_w_pair_this_tgt",
-        RulesVariables_1_ent_src_w_pair_this_tgt
-    },
-    {
-        "1_ent_src_w_pair_this_rel_tgt",
-        RulesVariables_1_ent_src_w_pair_this_rel_tgt
-    },
-    {
-        "1_this_src_w_this",
-        RulesVariables_1_this_src_w_this
-    },
-    {
-        "1_this_src_w_pair_this_rel_tgt",
-        RulesVariables_1_this_src_w_pair_this_rel_tgt
-    },
-    {
-        "1_this_src_w_this_after_write",
-        RulesVariables_1_this_src_w_this_after_write
-    },
-    {
-        "1_this_src_w_pair_this_rel_tgt_after_write",
-        RulesVariables_1_this_src_w_pair_this_rel_tgt_after_write
-    },
-    {
-        "2_constrain_src_from_src",
-        RulesVariables_2_constrain_src_from_src
-    },
-    {
-        "2_constrain_rel_from_src_w_ent",
-        RulesVariables_2_constrain_rel_from_src_w_ent
-    },
-    {
-        "2_constrain_rel_from_src_w_var",
-        RulesVariables_2_constrain_rel_from_src_w_var
-    },
-    {
-        "2_constrain_rel_from_src_w_this",
-        RulesVariables_2_constrain_rel_from_src_w_this
-    },
-    {
-        "2_constrain_pair_rel_from_src_w_ent",
-        RulesVariables_2_constrain_pair_rel_from_src_w_ent
-    },
-    {
-        "2_constrain_pair_rel_from_src_w_var",
-        RulesVariables_2_constrain_pair_rel_from_src_w_var
-    },
-    {
-        "2_constrain_pair_rel_from_src_w_this",
-        RulesVariables_2_constrain_pair_rel_from_src_w_this
-    },
-    {
-        "2_constrain_pair_tgt_from_src_w_ent",
-        RulesVariables_2_constrain_pair_tgt_from_src_w_ent
-    },
-    {
-        "2_constrain_pair_tgt_from_src_w_var",
-        RulesVariables_2_constrain_pair_tgt_from_src_w_var
-    },
-    {
-        "2_constrain_pair_tgt_from_src_w_this",
-        RulesVariables_2_constrain_pair_tgt_from_src_w_this
-    },
-    {
-        "2_constrain_pair_rel_tgt_from_src_w_ent",
-        RulesVariables_2_constrain_pair_rel_tgt_from_src_w_ent
-    },
-    {
-        "2_constrain_pair_rel_tgt_from_src_w_var",
-        RulesVariables_2_constrain_pair_rel_tgt_from_src_w_var
-    },
-    {
-        "2_constrain_pair_rel_tgt_from_src_w_this",
-        RulesVariables_2_constrain_pair_rel_tgt_from_src_w_this
-    },
-    {
-        "1_ent_src_set_rel_var",
-        RulesVariables_1_ent_src_set_rel_var
-    },
-    {
-        "1_ent_src_set_pair_rel_var",
-        RulesVariables_1_ent_src_set_pair_rel_var
-    },
-    {
-        "1_ent_src_set_pair_tgt_var",
-        RulesVariables_1_ent_src_set_pair_tgt_var
-    },
-    {
-        "1_set_src_var",
-        RulesVariables_1_set_src_var
-    },
-    {
-        "1_set_src_var_w_pair",
-        RulesVariables_1_set_src_var_w_pair
-    },
-    {
-        "1_set_src_var_w_pair_set_rel",
-        RulesVariables_1_set_src_var_w_pair_set_rel
-    },
-    {
-        "1_set_src_var_w_pair_set_tgt",
-        RulesVariables_1_set_src_var_w_pair_set_tgt
-    },
-    {
-        "1_set_src_var_w_pair_set_rel_tgt",
-        RulesVariables_1_set_src_var_w_pair_set_rel_tgt
-    },
-    {
-        "1_set_src_this",
-        RulesVariables_1_set_src_this
-    },
-    {
-        "1_set_src_this_w_pair",
-        RulesVariables_1_set_src_this_w_pair
-    },
-    {
-        "1_set_src_this_w_pair_set_rel",
-        RulesVariables_1_set_src_this_w_pair_set_rel
-    },
-    {
-        "1_set_src_this_w_pair_set_tgt",
-        RulesVariables_1_set_src_this_w_pair_set_tgt
-    },
-    {
-        "1_set_src_this_w_pair_set_rel_tgt",
-        RulesVariables_1_set_src_this_w_pair_set_rel_tgt
-    },
-    {
-        "1_set_src_this_to_empty_table",
-        RulesVariables_1_set_src_this_to_empty_table
-    },
-    {
-        "1_set_src_this_to_empty_table_w_component",
-        RulesVariables_1_set_src_this_to_empty_table_w_component
-    },
-    {
-        "1_set_src_this_to_empty_table_w_component_self",
-        RulesVariables_1_set_src_this_to_empty_table_w_component_self
-    },
-    {
-        "1_set_src_this_to_entiy_in_table",
-        RulesVariables_1_set_src_this_to_entiy_in_table
-    },
-    {
-        "1_set_src_this_to_entiy_in_table_self",
-        RulesVariables_1_set_src_this_to_entiy_in_table_self
-    },
-    {
-        "2_set_src_this",
-        RulesVariables_2_set_src_this
-    },
-    {
-        "2_set_src_this_self",
-        RulesVariables_2_set_src_this_self
-    },
-    {
-        "2_set_src_this_component",
-        RulesVariables_2_set_src_this_component
-    },
-    {
-        "2_set_src_this_self_component",
-        RulesVariables_2_set_src_this_self_component
-    },
-    {
-        "2_set_src_this_w_up",
-        RulesVariables_2_set_src_this_w_up
-    },
-    {
-        "2_set_src_this_self_w_up",
-        RulesVariables_2_set_src_this_self_w_up
-    },
-    {
-        "2_set_src_this_component_w_up",
-        RulesVariables_2_set_src_this_component_w_up
-    },
-    {
-        "2_set_src_this_self_component_w_up",
-        RulesVariables_2_set_src_this_self_component_w_up
-    },
-    {
-        "2_set_src_this_w_exclusive_wildcard",
-        RulesVariables_2_set_src_this_w_exclusive_wildcard
-    },
-    {
-        "2_set_src_this_self_w_exclusive_wildcard",
-        RulesVariables_2_set_src_this_self_w_exclusive_wildcard
-    },
-    {
-        "1_src_this_var_as_entity",
-        RulesVariables_1_src_this_var_as_entity
-    },
-    {
-        "1_src_this_var_as_table",
-        RulesVariables_1_src_this_var_as_table
-    },
-    {
-        "1_src_this_var_as_table_range",
-        RulesVariables_1_src_this_var_as_table_range
-    },
-    {
-        "2_join_by_rel_var",
-        RulesVariables_2_join_by_rel_var
-    },
-    {
-        "2_join_by_pair_rel_var",
-        RulesVariables_2_join_by_pair_rel_var
-    },
-    {
-        "2_join_by_pair_tgt_var",
-        RulesVariables_2_join_by_pair_tgt_var
-    },
-    {
-        "2_cycle_w_var",
-        RulesVariables_2_cycle_w_var
-    },
-    {
-        "2_cycle_w_this_var",
-        RulesVariables_2_cycle_w_this_var
-    },
-    {
-        "2_cycle_w_var_this",
-        RulesVariables_2_cycle_w_var_this
-    },
-    {
-        "2_cycle_pair_w_var",
-        RulesVariables_2_cycle_pair_w_var
-    },
-    {
-        "2_cycle_pair_w_this_var_var",
-        RulesVariables_2_cycle_pair_w_this_var_var
-    },
-    {
-        "2_cycle_pair_w_var_this_var",
-        RulesVariables_2_cycle_pair_w_var_this_var
-    },
-    {
-        "2_cycle_pair_w_var_var_this",
-        RulesVariables_2_cycle_pair_w_var_var_this
-    },
-    {
-        "2_cycle_pair_ent_var_var",
-        RulesVariables_2_cycle_pair_ent_var_var
-    },
-    {
-        "2_cycle_pair_ent_this_var",
-        RulesVariables_2_cycle_pair_ent_this_var
-    },
-    {
-        "2_cycle_pair_ent_var_this",
-        RulesVariables_2_cycle_pair_ent_var_this
-    },
-    {
-        "parse_0_var",
-        RulesVariables_parse_0_var
-    },
-    {
-        "parse_1_var",
-        RulesVariables_parse_1_var
-    },
-    {
-        "parse_2_vars",
-        RulesVariables_parse_2_vars
-    },
-    {
-        "parse_0_var_paren",
-        RulesVariables_parse_0_var_paren
-    },
-    {
-        "parse_1_var_paren",
-        RulesVariables_parse_1_var_paren
-    },
-    {
-        "parse_2_vars_paren",
-        RulesVariables_parse_2_vars_paren
-    },
-    {
-        "parse_1_vars_w_path",
-        RulesVariables_parse_1_vars_w_path
-    },
-    {
-        "parse_missing_close_paren",
-        RulesVariables_parse_missing_close_paren
-    },
-    {
-        "parse_missing_open_paren",
-        RulesVariables_parse_missing_open_paren
-    },
-    {
-        "parse_missing_value",
-        RulesVariables_parse_missing_value
-    },
-    {
-        "parse_0_var_w_spaces",
-        RulesVariables_parse_0_var_w_spaces
-    },
-    {
-        "parse_1_var_w_spaces",
-        RulesVariables_parse_1_var_w_spaces
-    },
-    {
-        "parse_2_vars_w_spaces",
-        RulesVariables_parse_2_vars_w_spaces
-    },
-    {
-        "parse_0_var_paren_w_spaces",
-        RulesVariables_parse_0_var_paren_w_spaces
-    },
-    {
-        "parse_1_var_paren_w_spaces",
-        RulesVariables_parse_1_var_paren_w_spaces
-    },
-    {
-        "parse_2_vars_paren_w_spaces",
-        RulesVariables_parse_2_vars_paren_w_spaces
-    },
-    {
-        "var_count",
-        RulesVariables_var_count
-    },
-    {
-        "var_name",
-        RulesVariables_var_name
-    },
-    {
-        "var_is_entity",
-        RulesVariables_var_is_entity
-    },
-    {
-        "no_this_anonymous_src",
-        RulesVariables_no_this_anonymous_src
-    },
-    {
-        "no_this_anonymous_src_w_pair",
-        RulesVariables_no_this_anonymous_src_w_pair
-    },
-    {
-        "no_this_anonymous_component_src",
-        RulesVariables_no_this_anonymous_component_src
-    },
-    {
-        "no_this_anonymous_component_src_w_pair",
-        RulesVariables_no_this_anonymous_component_src_w_pair
-    },
-    {
-        "lookup_from_table_this",
-        RulesVariables_lookup_from_table_this
-    },
-    {
-        "lookup_from_entity_this",
-        RulesVariables_lookup_from_entity_this
-    },
-    {
-        "lookup_from_table",
-        RulesVariables_lookup_from_table
-    },
-    {
-        "lookup_from_entity",
-        RulesVariables_lookup_from_entity
-    },
-    {
-        "lookup_from_not_written",
-        RulesVariables_lookup_from_not_written
-    },
-    {
-        "lookup_from_table_this_component",
-        RulesVariables_lookup_from_table_this_component
-    },
-    {
-        "lookup_from_entity_this_component",
-        RulesVariables_lookup_from_entity_this_component
-    },
-    {
-        "lookup_from_table_component",
-        RulesVariables_lookup_from_table_component
-    },
-    {
-        "lookup_from_entity_component",
-        RulesVariables_lookup_from_entity_component
-    },
-    {
-        "lookup_from_table_two_children",
-        RulesVariables_lookup_from_table_two_children
-    },
-    {
-        "lookup_from_entity_two_children",
-        RulesVariables_lookup_from_entity_two_children
-    },
-    {
-        "lookup_from_table_same_child_twice",
-        RulesVariables_lookup_from_table_same_child_twice
-    },
-    {
-        "lookup_from_entity_same_child_twice",
-        RulesVariables_lookup_from_entity_same_child_twice
-    },
-    {
-        "lookup_from_table_not",
-        RulesVariables_lookup_from_table_not
-    },
-    {
-        "lookup_from_entity_not",
-        RulesVariables_lookup_from_entity_not
-    },
-    {
-        "lookup_from_table_w_any_component",
-        RulesVariables_lookup_from_table_w_any_component
-    },
-    {
-        "lookup_from_entity_w_any_component",
-        RulesVariables_lookup_from_entity_w_any_component
-    },
-    {
-        "lookup_as_tag",
-        RulesVariables_lookup_as_tag
-    },
-    {
-        "lookup_as_relationship",
-        RulesVariables_lookup_as_relationship
-    },
-    {
-        "lookup_as_target",
-        RulesVariables_lookup_as_target
-    },
-    {
-        "lookup_assign_var",
-        RulesVariables_lookup_assign_var
-    },
-    {
-        "lookup_eq_var",
-        RulesVariables_lookup_eq_var
-    },
-    {
-        "lookup_neq_var",
-        RulesVariables_lookup_neq_var
-    },
-    {
-        "lookup_unresolved_dependent",
-        RulesVariables_lookup_unresolved_dependent
-    },
-    {
-        "check_vars_this",
-        RulesVariables_check_vars_this
-    },
-    {
-        "check_vars_var",
-        RulesVariables_check_vars_var
-    },
-    {
-        "check_vars_wildcard",
-        RulesVariables_check_vars_wildcard
-    },
-    {
-        "check_vars_any",
-        RulesVariables_check_vars_any
-    },
-    {
-        "check_vars_var_as_tgt",
-        RulesVariables_check_vars_var_as_tgt
-    },
-    {
-        "check_vars_this_as_tgt",
-        RulesVariables_check_vars_this_as_tgt
-    },
-    {
-        "check_vars_anonymous_var_as_tgt",
-        RulesVariables_check_vars_anonymous_var_as_tgt
-    },
-    {
-        "check_vars_wildcard_as_tgt",
-        RulesVariables_check_vars_wildcard_as_tgt
-    },
-    {
-        "check_vars_any_as_tgt",
-        RulesVariables_check_vars_any_as_tgt
-    },
-    {
-        "check_vars_this_w_lookup_var",
-        RulesVariables_check_vars_this_w_lookup_var
-    },
-    {
-        "check_vars_var_w_lookup_var",
-        RulesVariables_check_vars_var_w_lookup_var
-    },
-    {
-        "1_trivial_1_var",
-        RulesVariables_1_trivial_1_var
-    },
-    {
-        "2_trivial_1_var",
-        RulesVariables_2_trivial_1_var
-    },
-    {
-        "1_trivial_1_var_component",
-        RulesVariables_1_trivial_1_var_component
-    },
-    {
-        "2_trivial_1_var_component",
-        RulesVariables_2_trivial_1_var_component
-    },
-    {
-        "1_trivial_1_wildcard",
-        RulesVariables_1_trivial_1_wildcard
-    },
-    {
-        "2_trivial_1_wildcard",
-        RulesVariables_2_trivial_1_wildcard
-    },
-    {
-        "1_trivial_1_wildcard_component",
-        RulesVariables_1_trivial_1_wildcard_component
-    },
-    {
-        "2_trivial_1_wildcard_component",
-        RulesVariables_2_trivial_1_wildcard_component
-    },
-    {
-        "1_trivial_1_any",
-        RulesVariables_1_trivial_1_any
-    },
-    {
-        "2_trivial_1_any",
-        RulesVariables_2_trivial_1_any
-    },
-    {
-        "1_trivial_1_any_component",
-        RulesVariables_1_trivial_1_any_component
-    },
-    {
-        "2_trivial_1_any_component",
-        RulesVariables_2_trivial_1_any_component
-    }
-};
-
-bake_test_case RulesOperators_testcases[] = {
-    {
-        "2_and_not",
-        RulesOperators_2_and_not
-    },
-    {
-        "3_and_not_not",
-        RulesOperators_3_and_not_not
-    },
-    {
-        "2_and_not_pair_rel_wildcard",
-        RulesOperators_2_and_not_pair_rel_wildcard
-    },
-    {
-        "2_and_not_pair_tgt_wildcard",
-        RulesOperators_2_and_not_pair_tgt_wildcard
-    },
-    {
-        "2_and_not_pair_rel_tgt_wildcard",
-        RulesOperators_2_and_not_pair_rel_tgt_wildcard
-    },
-    {
-        "2_and_not_pair_rel_var",
-        RulesOperators_2_and_not_pair_rel_var
-    },
-    {
-        "2_and_not_pair_tgt_var",
-        RulesOperators_2_and_not_pair_tgt_var
-    },
-    {
-        "2_and_not_pair_rel_tgt_var",
-        RulesOperators_2_and_not_pair_rel_tgt_var
-    },
-    {
-        "2_and_not_pair_rel_tgt_same_var",
-        RulesOperators_2_and_not_pair_rel_tgt_same_var
-    },
-    {
-        "2_and_not_pair_rel_var_written",
-        RulesOperators_2_and_not_pair_rel_var_written
-    },
-    {
-        "2_and_not_pair_tgt_var_written",
-        RulesOperators_2_and_not_pair_tgt_var_written
-    },
-    {
-        "2_and_not_pair_rel_tgt_var_written",
-        RulesOperators_2_and_not_pair_rel_tgt_var_written
-    },
-    {
-        "2_and_not_pair_rel_tgt_same_var_written",
-        RulesOperators_2_and_not_pair_rel_tgt_same_var_written
-    },
-    {
-        "2_and_not_pair_rel_src_tgt_same_var_written",
-        RulesOperators_2_and_not_pair_rel_src_tgt_same_var_written
-    },
-    {
-        "2_and_not_pair_any_rel",
-        RulesOperators_2_and_not_pair_any_rel
-    },
-    {
-        "2_and_not_pair_any_tgt",
-        RulesOperators_2_and_not_pair_any_tgt
-    },
-    {
-        "2_and_not_pair_any_src",
-        RulesOperators_2_and_not_pair_any_src
-    },
-    {
-        "1_not_any_src_fixed_first",
-        RulesOperators_1_not_any_src_fixed_first
-    },
-    {
-        "1_not_any_src_any_tgt_fixed_first",
-        RulesOperators_1_not_any_src_any_tgt_fixed_first
-    },
-    {
-        "1_not_any_src_any_first_fixed_tgt",
-        RulesOperators_1_not_any_src_any_first_fixed_tgt
-    },
-    {
-        "1_not_any_src_any_childof_pair_any_tgt",
-        RulesOperators_1_not_any_src_any_childof_pair_any_tgt
-    },
-    {
-        "1_not_any_src_any_isa_pair_any_tgt",
-        RulesOperators_1_not_any_src_any_isa_pair_any_tgt
-    },
-    {
-        "2_and_optional",
-        RulesOperators_2_and_optional
-    },
-    {
-        "3_and_optional_optional",
-        RulesOperators_3_and_optional_optional
-    },
-    {
-        "2_and_optional_pair_rel_wildcard",
-        RulesOperators_2_and_optional_pair_rel_wildcard
-    },
-    {
-        "2_and_optional_pair_tgt_wildcard",
-        RulesOperators_2_and_optional_pair_tgt_wildcard
-    },
-    {
-        "2_and_optional_pair_rel_var",
-        RulesOperators_2_and_optional_pair_rel_var
-    },
-    {
-        "2_and_optional_pair_tgt_var",
-        RulesOperators_2_and_optional_pair_tgt_var
-    },
-    {
-        "2_and_optional_pair_rel_tgt_var",
-        RulesOperators_2_and_optional_pair_rel_tgt_var
-    },
-    {
-        "2_and_optional_pair_rel_tgt_same_var",
-        RulesOperators_2_and_optional_pair_rel_tgt_same_var
-    },
-    {
-        "2_and_optional_pair_rel_var_written",
-        RulesOperators_2_and_optional_pair_rel_var_written
-    },
-    {
-        "2_and_optional_pair_tgt_var_written",
-        RulesOperators_2_and_optional_pair_tgt_var_written
-    },
-    {
-        "2_and_optional_pair_rel_tgt_var_written",
-        RulesOperators_2_and_optional_pair_rel_tgt_var_written
-    },
-    {
-        "2_and_optional_pair_rel_tgt_same_var_written",
-        RulesOperators_2_and_optional_pair_rel_tgt_same_var_written
-    },
-    {
-        "2_and_optional_pair_rel_src_tgt_same_var_written",
-        RulesOperators_2_and_optional_pair_rel_src_tgt_same_var_written
-    },
-    {
-        "3_and_optional_optional_pair_w_var",
-        RulesOperators_3_and_optional_optional_pair_w_var
-    },
-    {
-        "2_and_optional_pair_any_rel",
-        RulesOperators_2_and_optional_pair_any_rel
-    },
-    {
-        "2_and_optional_pair_any_tgt",
-        RulesOperators_2_and_optional_pair_any_tgt
-    },
-    {
-        "2_and_optional_pair_any_src",
-        RulesOperators_2_and_optional_pair_any_src
-    },
-    {
-        "3_and_optional_dependent_and_pair_rel",
-        RulesOperators_3_and_optional_dependent_and_pair_rel
-    },
-    {
-        "3_and_optional_dependent_and_pair_tgt",
-        RulesOperators_3_and_optional_dependent_and_pair_tgt
-    },
-    {
-        "3_and_optional_dependent_and_pair_rel_tgt",
-        RulesOperators_3_and_optional_dependent_and_pair_rel_tgt
-    },
-    {
-        "3_and_optional_dependent_and_pair_rel_tgt_same_var",
-        RulesOperators_3_and_optional_dependent_and_pair_rel_tgt_same_var
-    },
-    {
-        "3_and_optional_dependent_and_pair_rel_tgt_same_other_var",
-        RulesOperators_3_and_optional_dependent_and_pair_rel_tgt_same_other_var
-    },
-    {
-        "3_and_optional_dependent_and_pair_src",
-        RulesOperators_3_and_optional_dependent_and_pair_src
-    },
-    {
-        "3_and_optional_dependent_optional_pair_rel",
-        RulesOperators_3_and_optional_dependent_optional_pair_rel
-    },
-    {
-        "3_and_optional_dependent_optional_pair_tgt",
-        RulesOperators_3_and_optional_dependent_optional_pair_tgt
-    },
-    {
-        "3_and_optional_dependent_optional_pair_src",
-        RulesOperators_3_and_optional_dependent_optional_pair_src
-    },
-    {
-        "3_and_optional_dependent_not_pair_rel",
-        RulesOperators_3_and_optional_dependent_not_pair_rel
-    },
-    {
-        "3_and_optional_dependent_not_pair_tgt",
-        RulesOperators_3_and_optional_dependent_not_pair_tgt
-    },
-    {
-        "3_and_optional_dependent_not_pair_src",
-        RulesOperators_3_and_optional_dependent_not_pair_src
-    },
-    {
-        "1_optional_any_src_fixed_first",
-        RulesOperators_1_optional_any_src_fixed_first
-    },
-    {
-        "1_optional_any_src_any_tgt_fixed_first",
-        RulesOperators_1_optional_any_src_any_tgt_fixed_first
-    },
-    {
-        "1_optional_any_src_any_first_fixed_tgt",
-        RulesOperators_1_optional_any_src_any_first_fixed_tgt
-    },
-    {
-        "1_optional_any_src_any_childof_pair_any_tgt",
-        RulesOperators_1_optional_any_src_any_childof_pair_any_tgt
-    },
-    {
-        "1_optional_any_src_any_isa_pair_any_tgt",
-        RulesOperators_1_optional_any_src_any_isa_pair_any_tgt
-    },
-    {
-        "2_or",
-        RulesOperators_2_or
-    },
-    {
-        "3_or",
-        RulesOperators_3_or
-    },
-    {
-        "2_or_written",
-        RulesOperators_2_or_written
-    },
-    {
-        "3_or_written",
-        RulesOperators_3_or_written
-    },
-    {
-        "2_or_written_w_rel_var",
-        RulesOperators_2_or_written_w_rel_var
-    },
-    {
-        "3_or_written_w_rel_var",
-        RulesOperators_3_or_written_w_rel_var
-    },
-    {
-        "2_or_written_w_tgt_var",
-        RulesOperators_2_or_written_w_tgt_var
-    },
-    {
-        "2_or_written_w_rel_tgt_var",
-        RulesOperators_2_or_written_w_rel_tgt_var
-    },
-    {
-        "2_or_written_w_rel_tgt_same_var",
-        RulesOperators_2_or_written_w_rel_tgt_same_var
-    },
-    {
-        "3_or_written_w_tgt_var",
-        RulesOperators_3_or_written_w_tgt_var
-    },
-    {
-        "2_or_chains",
-        RulesOperators_2_or_chains
-    },
-    {
-        "2_or_chains_written",
-        RulesOperators_2_or_chains_written
-    },
-    {
-        "2_or_dependent",
-        RulesOperators_2_or_dependent
-    },
-    {
-        "2_or_dependent_reverse",
-        RulesOperators_2_or_dependent_reverse
-    },
-    {
-        "2_or_dependent_2_vars",
-        RulesOperators_2_or_dependent_2_vars
-    },
-    {
-        "2_or_written_dependent",
-        RulesOperators_2_or_written_dependent
-    },
-    {
-        "2_or_written_dependent_2_vars",
-        RulesOperators_2_or_written_dependent_2_vars
-    },
-    {
-        "2_or_w_dependent",
-        RulesOperators_2_or_w_dependent
-    },
-    {
-        "2_or_w_both",
-        RulesOperators_2_or_w_both
-    },
-    {
-        "3_or_w_both",
-        RulesOperators_3_or_w_both
-    },
-    {
-        "2_not_first",
-        RulesOperators_2_not_first
-    },
-    {
-        "2_optional_first",
-        RulesOperators_2_optional_first
-    },
-    {
-        "root_entities_empty",
-        RulesOperators_root_entities_empty
-    },
-    {
-        "root_entities",
-        RulesOperators_root_entities
-    },
-    {
-        "root_entities_w_children",
-        RulesOperators_root_entities_w_children
-    },
-    {
-        "root_entities_w_optional_children",
-        RulesOperators_root_entities_w_optional_children
-    },
-    {
-        "core_entities_w_optional_children",
-        RulesOperators_core_entities_w_optional_children
-    },
-    {
-        "root_entities_w_not_children",
-        RulesOperators_root_entities_w_not_children
-    },
-    {
-        "core_entities_w_not_children",
-        RulesOperators_core_entities_w_not_children
-    },
-    {
-        "1_ent_src_not",
-        RulesOperators_1_ent_src_not
-    },
-    {
-        "1_ent_src_not_pair",
-        RulesOperators_1_ent_src_not_pair
-    },
-    {
-        "1_ent_src_not_pair_rel_wildcard",
-        RulesOperators_1_ent_src_not_pair_rel_wildcard
-    },
-    {
-        "1_ent_src_not_pair_tgt_wildcard",
-        RulesOperators_1_ent_src_not_pair_tgt_wildcard
-    },
-    {
-        "1_ent_src_not_pair_rel_tgt_wildcard",
-        RulesOperators_1_ent_src_not_pair_rel_tgt_wildcard
-    },
-    {
-        "1_ent_src_not_pair_rel_any",
-        RulesOperators_1_ent_src_not_pair_rel_any
-    },
-    {
-        "1_ent_src_not_pair_tgt_any",
-        RulesOperators_1_ent_src_not_pair_tgt_any
-    },
-    {
-        "1_ent_src_not_pair_rel_tgt_any",
-        RulesOperators_1_ent_src_not_pair_rel_tgt_any
-    },
-    {
-        "1_ent_src_not_pair_rel_var",
-        RulesOperators_1_ent_src_not_pair_rel_var
-    },
-    {
-        "1_ent_src_not_pair_tgt_var",
-        RulesOperators_1_ent_src_not_pair_tgt_var
-    },
-    {
-        "1_ent_src_not_pair_rel_tgt_var",
-        RulesOperators_1_ent_src_not_pair_rel_tgt_var
-    },
-    {
-        "1_ent_src_not_pair_rel_tgt_same_var",
-        RulesOperators_1_ent_src_not_pair_rel_tgt_same_var
-    },
-    {
-        "1_this_src_not_pair_rel_var",
-        RulesOperators_1_this_src_not_pair_rel_var
-    },
-    {
-        "1_this_src_not_pair_tgt_var",
-        RulesOperators_1_this_src_not_pair_tgt_var
-    },
-    {
-        "1_this_src_not_pair_rel_tgt_var",
-        RulesOperators_1_this_src_not_pair_rel_tgt_var
-    },
-    {
-        "1_this_src_not_pair_rel_tgt_same_var",
-        RulesOperators_1_this_src_not_pair_rel_tgt_same_var
-    },
-    {
-        "1_ent_src_not_pair_rel_var_written",
-        RulesOperators_1_ent_src_not_pair_rel_var_written
-    },
-    {
-        "1_ent_src_not_pair_tgt_var_written",
-        RulesOperators_1_ent_src_not_pair_tgt_var_written
-    },
-    {
-        "1_ent_src_not_pair_rel_tgt_var_written",
-        RulesOperators_1_ent_src_not_pair_rel_tgt_var_written
-    },
-    {
-        "1_ent_src_not_pair_rel_tgt_same_var_written",
-        RulesOperators_1_ent_src_not_pair_rel_tgt_same_var_written
-    }
-};
-
-bake_test_case RulesTransitive_testcases[] = {
-    {
-        "1_fact_0_lvl_true",
-        RulesTransitive_1_fact_0_lvl_true
-    },
-    {
-        "1_fact_1_lvl_true",
-        RulesTransitive_1_fact_1_lvl_true
-    },
-    {
-        "1_fact_2_lvl_true",
-        RulesTransitive_1_fact_2_lvl_true
-    },
-    {
-        "1_fact_0_lvl_false",
-        RulesTransitive_1_fact_0_lvl_false
-    },
-    {
-        "1_fact_1_lvl_false",
-        RulesTransitive_1_fact_1_lvl_false
-    },
-    {
-        "1_fact_2_lvl_false",
-        RulesTransitive_1_fact_2_lvl_false
-    },
-    {
-        "1_fact_reflexive",
-        RulesTransitive_1_fact_reflexive
-    },
-    {
-        "1_this_src_written_0_lvl",
-        RulesTransitive_1_this_src_written_0_lvl
-    },
-    {
-        "1_this_src_written_1_lvl",
-        RulesTransitive_1_this_src_written_1_lvl
-    },
-    {
-        "1_this_src_written_2_lvl",
-        RulesTransitive_1_this_src_written_2_lvl
-    },
-    {
-        "1_this_src_written_reflexive",
-        RulesTransitive_1_this_src_written_reflexive
-    },
-    {
-        "1_this_src_0_lvl",
-        RulesTransitive_1_this_src_0_lvl
-    },
-    {
-        "1_this_src_1_lvl",
-        RulesTransitive_1_this_src_1_lvl
-    },
-    {
-        "1_this_src_2_lvl",
-        RulesTransitive_1_this_src_2_lvl
-    },
-    {
-        "1_this_src_reflexive",
-        RulesTransitive_1_this_src_reflexive
-    },
-    {
-        "1_ent_src_tgt_var_0_lvl",
-        RulesTransitive_1_ent_src_tgt_var_0_lvl
-    },
-    {
-        "1_ent_src_tgt_var_1_lvl",
-        RulesTransitive_1_ent_src_tgt_var_1_lvl
-    },
-    {
-        "1_ent_src_tgt_var_2_lvl",
-        RulesTransitive_1_ent_src_tgt_var_2_lvl
-    },
-    {
-        "1_ent_src_tgt_var_reflexive",
-        RulesTransitive_1_ent_src_tgt_var_reflexive
-    },
-    {
-        "1_this_src_tgt_var",
-        RulesTransitive_1_this_src_tgt_var
-    },
-    {
-        "1_this_src_tgt_var_reflexive",
-        RulesTransitive_1_this_src_tgt_var_reflexive
-    },
-    {
-        "1_var_src_written_0_lvl",
-        RulesTransitive_1_var_src_written_0_lvl
-    },
-    {
-        "1_var_src_written_1_lvl",
-        RulesTransitive_1_var_src_written_1_lvl
-    },
-    {
-        "1_var_src_written_2_lvl",
-        RulesTransitive_1_var_src_written_2_lvl
-    },
-    {
-        "1_var_src_written_reflexive",
-        RulesTransitive_1_var_src_written_reflexive
-    },
-    {
-        "1_var_src_0_lvl",
-        RulesTransitive_1_var_src_0_lvl
-    },
-    {
-        "1_var_src_1_lvl",
-        RulesTransitive_1_var_src_1_lvl
-    },
-    {
-        "1_var_src_2_lvl",
-        RulesTransitive_1_var_src_2_lvl
-    },
-    {
-        "1_var_src_reflexive",
-        RulesTransitive_1_var_src_reflexive
-    },
-    {
-        "1_var_src_tgt_var",
-        RulesTransitive_1_var_src_tgt_var
-    },
-    {
-        "1_var_src_tgt_var_reflexive",
-        RulesTransitive_1_var_src_tgt_var_reflexive
-    },
-    {
-        "1_ent_src_tgt_this_0_lvl",
-        RulesTransitive_1_ent_src_tgt_this_0_lvl
-    },
-    {
-        "1_ent_src_tgt_this_1_lvl",
-        RulesTransitive_1_ent_src_tgt_this_1_lvl
-    },
-    {
-        "1_ent_src_tgt_this_2_lvl",
-        RulesTransitive_1_ent_src_tgt_this_2_lvl
-    },
-    {
-        "1_ent_src_tgt_this_reflexive",
-        RulesTransitive_1_ent_src_tgt_this_reflexive
-    },
-    {
-        "1_var_src_tgt_this",
-        RulesTransitive_1_var_src_tgt_this
-    },
-    {
-        "1_var_src_tgt_this_reflexive",
-        RulesTransitive_1_var_src_tgt_this_reflexive
-    },
-    {
-        "2_ent_src_constrain_tgt_var_before_0_lvl",
-        RulesTransitive_2_ent_src_constrain_tgt_var_before_0_lvl
-    },
-    {
-        "2_ent_src_constrain_tgt_var_before_1_lvl",
-        RulesTransitive_2_ent_src_constrain_tgt_var_before_1_lvl
-    },
-    {
-        "2_ent_src_constrain_tgt_var_before_2_lvl",
-        RulesTransitive_2_ent_src_constrain_tgt_var_before_2_lvl
-    },
-    {
-        "2_ent_src_constrain_tgt_var_after_0_lvl",
-        RulesTransitive_2_ent_src_constrain_tgt_var_after_0_lvl
-    },
-    {
-        "2_ent_src_constrain_tgt_var_after_1_lvl",
-        RulesTransitive_2_ent_src_constrain_tgt_var_after_1_lvl
-    },
-    {
-        "2_ent_src_constrain_tgt_var_after_2_lvl",
-        RulesTransitive_2_ent_src_constrain_tgt_var_after_2_lvl
-    },
-    {
-        "2_this_src_constrain_tgt_var_before_0_lvl",
-        RulesTransitive_2_this_src_constrain_tgt_var_before_0_lvl
-    },
-    {
-        "2_this_src_constrain_tgt_var_before_1_lvl",
-        RulesTransitive_2_this_src_constrain_tgt_var_before_1_lvl
-    },
-    {
-        "2_this_src_constrain_tgt_var_before_2_lvl",
-        RulesTransitive_2_this_src_constrain_tgt_var_before_2_lvl
-    },
-    {
-        "2_this_src_constrain_tgt_var_after_0_lvl",
-        RulesTransitive_2_this_src_constrain_tgt_var_after_0_lvl
-    },
-    {
-        "2_this_src_constrain_tgt_var_after_1_lvl",
-        RulesTransitive_2_this_src_constrain_tgt_var_after_1_lvl
-    },
-    {
-        "2_this_src_constrain_tgt_var_after_2_lvl",
-        RulesTransitive_2_this_src_constrain_tgt_var_after_2_lvl
-    },
-    {
-        "1_src_tgt_same_var",
-        RulesTransitive_1_src_tgt_same_var
-    },
-    {
-        "1_src_tgt_same_var_reflexive",
-        RulesTransitive_1_src_tgt_same_var_reflexive
-    },
-    {
-        "1_src_tgt_same_this_var_reflexive",
-        RulesTransitive_1_src_tgt_same_this_var_reflexive
-    },
-    {
-        "1_any_src_tgt_var",
-        RulesTransitive_1_any_src_tgt_var
-    },
-    {
-        "not_transitive_ent_tgt",
-        RulesTransitive_not_transitive_ent_tgt
-    },
-    {
-        "not_transitive_var_tgt",
-        RulesTransitive_not_transitive_var_tgt
-    },
-    {
-        "not_transitive_ent_tgt_written",
-        RulesTransitive_not_transitive_ent_tgt_written
-    },
-    {
-        "not_transitive_var_tgt_written",
-        RulesTransitive_not_transitive_var_tgt_written
-    },
-    {
-        "optional_transitive_ent_tgt",
-        RulesTransitive_optional_transitive_ent_tgt
-    },
-    {
-        "optional_transitive_var_tgt",
-        RulesTransitive_optional_transitive_var_tgt
-    },
-    {
-        "optional_transitive_ent_tgt_written",
-        RulesTransitive_optional_transitive_ent_tgt_written
-    },
-    {
-        "optional_transitive_var_tgt_written",
-        RulesTransitive_optional_transitive_var_tgt_written
-    },
-    {
-        "2_var_src_w_same_tgt_ent",
-        RulesTransitive_2_var_src_w_same_tgt_ent
-    },
-    {
-        "self_target",
-        RulesTransitive_self_target
-    },
-    {
-        "any_target",
-        RulesTransitive_any_target
-    }
-};
-
-bake_test_case RulesComponentInheritance_testcases[] = {
-    {
-        "1_ent_0_lvl",
-        RulesComponentInheritance_1_ent_0_lvl
-    },
-    {
-        "1_ent_1_lvl",
-        RulesComponentInheritance_1_ent_1_lvl
-    },
-    {
-        "1_ent_2_lvl",
-        RulesComponentInheritance_1_ent_2_lvl
-    },
-    {
-        "1_ent_3_lvl",
-        RulesComponentInheritance_1_ent_3_lvl
-    },
-    {
-        "1_this_0_lvl",
-        RulesComponentInheritance_1_this_0_lvl
-    },
-    {
-        "1_this_1_lvl",
-        RulesComponentInheritance_1_this_1_lvl
-    },
-    {
-        "1_this_2_lvl",
-        RulesComponentInheritance_1_this_2_lvl
-    },
-    {
-        "1_this_3_lvl",
-        RulesComponentInheritance_1_this_3_lvl
-    },
-    {
-        "1_this_0_lvl_written",
-        RulesComponentInheritance_1_this_0_lvl_written
-    },
-    {
-        "1_this_1_lvl_written",
-        RulesComponentInheritance_1_this_1_lvl_written
-    },
-    {
-        "1_this_2_lvl_written",
-        RulesComponentInheritance_1_this_2_lvl_written
-    },
-    {
-        "1_this_3_lvl_written",
-        RulesComponentInheritance_1_this_3_lvl_written
-    },
-    {
-        "1_var_0_lvl",
-        RulesComponentInheritance_1_var_0_lvl
-    },
-    {
-        "1_var_1_lvl",
-        RulesComponentInheritance_1_var_1_lvl
-    },
-    {
-        "1_var_2_lvl",
-        RulesComponentInheritance_1_var_2_lvl
-    },
-    {
-        "1_var_3_lvl",
-        RulesComponentInheritance_1_var_3_lvl
-    },
-    {
-        "1_var_0_lvl_written",
-        RulesComponentInheritance_1_var_0_lvl_written
-    },
-    {
-        "1_var_1_lvl_written",
-        RulesComponentInheritance_1_var_1_lvl_written
-    },
-    {
-        "1_var_2_lvl_written",
-        RulesComponentInheritance_1_var_2_lvl_written
-    },
-    {
-        "1_var_3_lvl_written",
-        RulesComponentInheritance_1_var_3_lvl_written
-    },
-    {
-        "1_ent_1_lvl_self",
-        RulesComponentInheritance_1_ent_1_lvl_self
-    },
-    {
-        "1_this_1_lvl_self",
-        RulesComponentInheritance_1_this_1_lvl_self
-    },
-    {
-        "1_this_1_lvl_written_self",
-        RulesComponentInheritance_1_this_1_lvl_written_self
-    },
-    {
-        "1_var_1_lvl_self",
-        RulesComponentInheritance_1_var_1_lvl_self
-    },
-    {
-        "1_var_1_lvl_written_self",
-        RulesComponentInheritance_1_var_1_lvl_written_self
-    },
-    {
-        "1_ent_src_not",
-        RulesComponentInheritance_1_ent_src_not
-    },
-    {
-        "1_this_src_not",
-        RulesComponentInheritance_1_this_src_not
-    },
-    {
-        "1_var_src_not",
-        RulesComponentInheritance_1_var_src_not
-    },
-    {
-        "1_this_src_not_written",
-        RulesComponentInheritance_1_this_src_not_written
-    },
-    {
-        "1_var_src_not_written",
-        RulesComponentInheritance_1_var_src_not_written
-    },
-    {
-        "first_self",
-        RulesComponentInheritance_first_self
-    },
-    {
-        "first_down",
-        RulesComponentInheritance_first_down
-    },
-    {
-        "first_self_down",
-        RulesComponentInheritance_first_self_down
-    },
-    {
-        "first_rel_self",
-        RulesComponentInheritance_first_rel_self
-    },
-    {
-        "first_rel_down",
-        RulesComponentInheritance_first_rel_down
-    },
-    {
-        "first_rel_self_down",
-        RulesComponentInheritance_first_rel_self_down
-    }
-};
-
-bake_test_case RulesRecycled_testcases[] = {
-    {
-        "recycled_vars",
-        RulesRecycled_recycled_vars
-    },
-    {
-        "recycled_pair_vars",
-        RulesRecycled_recycled_pair_vars
-    },
-    {
-        "recycled_this_ent_var",
-        RulesRecycled_recycled_this_ent_var
-    },
-    {
-        "has_recycled_id_from_pair",
-        RulesRecycled_has_recycled_id_from_pair
-    }
-};
-
-bake_test_case RulesBuiltinPredicates_testcases[] = {
-    {
-        "this_eq_id",
-        RulesBuiltinPredicates_this_eq_id
-    },
-    {
-        "this_eq_name",
-        RulesBuiltinPredicates_this_eq_name
-    },
-    {
-        "this_eq_var",
-        RulesBuiltinPredicates_this_eq_var
-    },
-    {
-        "this_eq_id_written",
-        RulesBuiltinPredicates_this_eq_id_written
-    },
-    {
-        "this_eq_id_written_no_match",
-        RulesBuiltinPredicates_this_eq_id_written_no_match
-    },
-    {
-        "this_eq_name_written",
-        RulesBuiltinPredicates_this_eq_name_written
-    },
-    {
-        "this_eq_name_written_no_match",
-        RulesBuiltinPredicates_this_eq_name_written_no_match
-    },
-    {
-        "this_eq_var_written",
-        RulesBuiltinPredicates_this_eq_var_written
-    },
-    {
-        "var_eq_id",
-        RulesBuiltinPredicates_var_eq_id
-    },
-    {
-        "var_eq_name",
-        RulesBuiltinPredicates_var_eq_name
-    },
-    {
-        "var_eq_var",
-        RulesBuiltinPredicates_var_eq_var
-    },
-    {
-        "var_eq_id_written",
-        RulesBuiltinPredicates_var_eq_id_written
-    },
-    {
-        "var_eq_id_written_no_match",
-        RulesBuiltinPredicates_var_eq_id_written_no_match
-    },
-    {
-        "var_eq_name_written",
-        RulesBuiltinPredicates_var_eq_name_written
-    },
-    {
-        "var_eq_name_written_no_match",
-        RulesBuiltinPredicates_var_eq_name_written_no_match
-    },
-    {
-        "var_eq_var_written",
-        RulesBuiltinPredicates_var_eq_var_written
-    },
-    {
-        "var_eq_this",
-        RulesBuiltinPredicates_var_eq_this
-    },
-    {
-        "this_neq_id",
-        RulesBuiltinPredicates_this_neq_id
-    },
-    {
-        "this_neq_name",
-        RulesBuiltinPredicates_this_neq_name
-    },
-    {
-        "this_neq_var",
-        RulesBuiltinPredicates_this_neq_var
-    },
-    {
-        "this_neq_id_written",
-        RulesBuiltinPredicates_this_neq_id_written
-    },
-    {
-        "this_neq_id_written_no_match",
-        RulesBuiltinPredicates_this_neq_id_written_no_match
-    },
-    {
-        "this_neq_name_written",
-        RulesBuiltinPredicates_this_neq_name_written
-    },
-    {
-        "this_neq_name_written_no_match",
-        RulesBuiltinPredicates_this_neq_name_written_no_match
-    },
-    {
-        "this_neq_var_written",
-        RulesBuiltinPredicates_this_neq_var_written
-    },
-    {
-        "var_neq_id",
-        RulesBuiltinPredicates_var_neq_id
-    },
-    {
-        "var_neq_name",
-        RulesBuiltinPredicates_var_neq_name
-    },
-    {
-        "var_neq_var",
-        RulesBuiltinPredicates_var_neq_var
-    },
-    {
-        "var_neq_id_written",
-        RulesBuiltinPredicates_var_neq_id_written
-    },
-    {
-        "var_neq_id_written_no_match",
-        RulesBuiltinPredicates_var_neq_id_written_no_match
-    },
-    {
-        "var_neq_name_written",
-        RulesBuiltinPredicates_var_neq_name_written
-    },
-    {
-        "var_neq_name_written_no_match",
-        RulesBuiltinPredicates_var_neq_name_written_no_match
-    },
-    {
-        "var_neq_var_written",
-        RulesBuiltinPredicates_var_neq_var_written
-    },
-    {
-        "var_neq_this",
-        RulesBuiltinPredicates_var_neq_this
-    },
-    {
-        "this_2_neq_id",
-        RulesBuiltinPredicates_this_2_neq_id
-    },
-    {
-        "this_2_neq_name",
-        RulesBuiltinPredicates_this_2_neq_name
-    },
-    {
-        "var_2_neq_id",
-        RulesBuiltinPredicates_var_2_neq_id
-    },
-    {
-        "var_2_neq_name",
-        RulesBuiltinPredicates_var_2_neq_name
-    },
-    {
-        "this_2_neq_id_written",
-        RulesBuiltinPredicates_this_2_neq_id_written
-    },
-    {
-        "this_2_neq_name_written",
-        RulesBuiltinPredicates_this_2_neq_name_written
-    },
-    {
-        "var_2_neq_id_written",
-        RulesBuiltinPredicates_var_2_neq_id_written
-    },
-    {
-        "var_2_neq_name_written",
-        RulesBuiltinPredicates_var_2_neq_name_written
-    },
-    {
-        "this_2_or_id",
-        RulesBuiltinPredicates_this_2_or_id
-    },
-    {
-        "this_2_or_name",
-        RulesBuiltinPredicates_this_2_or_name
-    },
-    {
-        "var_2_or_id",
-        RulesBuiltinPredicates_var_2_or_id
-    },
-    {
-        "var_2_or_name",
-        RulesBuiltinPredicates_var_2_or_name
-    },
-    {
-        "this_2_or_id_written",
-        RulesBuiltinPredicates_this_2_or_id_written
-    },
-    {
-        "this_2_or_name_written",
-        RulesBuiltinPredicates_this_2_or_name_written
-    },
-    {
-        "var_2_or_id_written",
-        RulesBuiltinPredicates_var_2_or_id_written
-    },
-    {
-        "var_2_or_name_written",
-        RulesBuiltinPredicates_var_2_or_name_written
-    },
-    {
-        "this_match_eq",
-        RulesBuiltinPredicates_this_match_eq
-    },
-    {
-        "var_match_eq",
-        RulesBuiltinPredicates_var_match_eq
-    },
-    {
-        "this_match_eq_written",
-        RulesBuiltinPredicates_this_match_eq_written
-    },
-    {
-        "this_match_eq_written_self",
-        RulesBuiltinPredicates_this_match_eq_written_self
-    },
-    {
-        "var_match_eq_written",
-        RulesBuiltinPredicates_var_match_eq_written
-    },
-    {
-        "this_match_neq",
-        RulesBuiltinPredicates_this_match_neq
-    },
-    {
-        "var_match_neq",
-        RulesBuiltinPredicates_var_match_neq
-    },
-    {
-        "this_match_neq_written",
-        RulesBuiltinPredicates_this_match_neq_written
-    },
-    {
-        "var_match_neq_written",
-        RulesBuiltinPredicates_var_match_neq_written
-    },
-    {
-        "this_match_2_neq",
-        RulesBuiltinPredicates_this_match_2_neq
-    },
-    {
-        "var_match_2_neq",
-        RulesBuiltinPredicates_var_match_2_neq
-    },
-    {
-        "this_match_2_neq_written",
-        RulesBuiltinPredicates_this_match_2_neq_written
-    },
-    {
-        "var_match_2_neq_written",
-        RulesBuiltinPredicates_var_match_2_neq_written
-    },
-    {
-        "this_match_2_or",
-        RulesBuiltinPredicates_this_match_2_or
-    },
-    {
-        "this_match_2_or_written",
-        RulesBuiltinPredicates_this_match_2_or_written
-    },
-    {
-        "this_match_3_or",
-        RulesBuiltinPredicates_this_match_3_or
-    },
-    {
-        "this_match_3_or_written",
-        RulesBuiltinPredicates_this_match_3_or_written
-    },
-    {
-        "unresolved_by_name",
-        RulesBuiltinPredicates_unresolved_by_name
-    },
-    {
-        "var_eq_wildcard",
-        RulesBuiltinPredicates_var_eq_wildcard
-    },
-    {
-        "var_eq_any",
-        RulesBuiltinPredicates_var_eq_any
-    },
-    {
-        "var_eq_wildcard_after_write",
-        RulesBuiltinPredicates_var_eq_wildcard_after_write
-    },
-    {
-        "var_eq_any_after_write",
-        RulesBuiltinPredicates_var_eq_any_after_write
-    },
-    {
-        "var_eq_after_var_0_src",
-        RulesBuiltinPredicates_var_eq_after_var_0_src
-    },
-    {
-        "2_or_w_eq_this",
-        RulesBuiltinPredicates_2_or_w_eq_this
-    },
-    {
-        "2_or_w_eq_lookup_var",
-        RulesBuiltinPredicates_2_or_w_eq_lookup_var
-    },
-    {
-        "3_or_w_eq_lookup_var",
-        RulesBuiltinPredicates_3_or_w_eq_lookup_var
-    },
-    {
-        "unwritten_var_error_neq",
-        RulesBuiltinPredicates_unwritten_var_error_neq
-    },
-    {
-        "unwritten_var_error_match",
-        RulesBuiltinPredicates_unwritten_var_error_match
-    }
-};
-
-bake_test_case RulesScopes_testcases[] = {
-    {
-        "term_w_not_scope_1_term",
-        RulesScopes_term_w_not_scope_1_term
-    },
-    {
-        "term_w_not_scope_2_terms",
-        RulesScopes_term_w_not_scope_2_terms
-    },
-    {
-        "term_w_not_scope_1_term_w_not",
-        RulesScopes_term_w_not_scope_1_term_w_not
-    },
-    {
-        "term_w_not_scope_2_terms_w_not",
-        RulesScopes_term_w_not_scope_2_terms_w_not
-    },
-    {
-        "term_w_not_scope_1_term_w_var",
-        RulesScopes_term_w_not_scope_1_term_w_var
-    },
-    {
-        "term_w_not_scope_2_terms_w_var",
-        RulesScopes_term_w_not_scope_2_terms_w_var
-    },
-    {
-        "term_w_not_scope_1_term_w_not_w_var",
-        RulesScopes_term_w_not_scope_1_term_w_not_w_var
-    },
-    {
-        "term_w_not_scope_2_terms_w_not_w_var",
-        RulesScopes_term_w_not_scope_2_terms_w_not_w_var
-    },
-    {
-        "term_w_not_scope_2_terms_w_or",
-        RulesScopes_term_w_not_scope_2_terms_w_or
-    },
-    {
-        "term_w_not_scope_3_terms_w_or",
-        RulesScopes_term_w_not_scope_3_terms_w_or
-    }
-};
-
-bake_test_case RulesTraversal_testcases[] = {
-    {
-        "this_self_up_childof",
-        RulesTraversal_this_self_up_childof
-    },
-    {
-        "this_up_childof",
-        RulesTraversal_this_up_childof
-    },
-    {
-        "this_written_self_up_childof",
-        RulesTraversal_this_written_self_up_childof
-    },
-    {
-        "this_written_up_childof",
-        RulesTraversal_this_written_up_childof
-    },
-    {
-        "var_self_up_childof",
-        RulesTraversal_var_self_up_childof
-    },
-    {
-        "var_up_childof",
-        RulesTraversal_var_up_childof
-    },
-    {
-        "var_written_self_up_childof",
-        RulesTraversal_var_written_self_up_childof
-    },
-    {
-        "var_written_up_childof",
-        RulesTraversal_var_written_up_childof
-    },
-    {
-        "set_var_self_up_childof",
-        RulesTraversal_set_var_self_up_childof
-    },
-    {
-        "set_var_up_childof",
-        RulesTraversal_set_var_up_childof
-    },
-    {
-        "set_var_written_self_up_childof",
-        RulesTraversal_set_var_written_self_up_childof
-    },
-    {
-        "set_var_written_up_childof",
-        RulesTraversal_set_var_written_up_childof
-    },
-    {
-        "ent_self_up_childof",
-        RulesTraversal_ent_self_up_childof
-    },
-    {
-        "ent_up_childof",
-        RulesTraversal_ent_up_childof
-    },
-    {
-        "implicit_this_self_up_isa",
-        RulesTraversal_implicit_this_self_up_isa
-    },
-    {
-        "implicit_this_up_isa",
-        RulesTraversal_implicit_this_up_isa
-    },
-    {
-        "implicit_var_self_up_isa",
-        RulesTraversal_implicit_var_self_up_isa
-    },
-    {
-        "implicit_var_up_isa",
-        RulesTraversal_implicit_var_up_isa
-    },
-    {
-        "implicit_ent_self_up_isa",
-        RulesTraversal_implicit_ent_self_up_isa
-    },
-    {
-        "implicit_ent_up_isa",
-        RulesTraversal_implicit_ent_up_isa
-    },
-    {
-        "self_up_2_targets",
-        RulesTraversal_self_up_2_targets
-    },
-    {
-        "up_2_targets",
-        RulesTraversal_up_2_targets
-    },
-    {
-        "self_up_2_targets_diamond",
-        RulesTraversal_self_up_2_targets_diamond
-    },
-    {
-        "up_2_targets_diamond",
-        RulesTraversal_up_2_targets_diamond
-    },
-    {
-        "written_self_up_2_targets",
-        RulesTraversal_written_self_up_2_targets
-    },
-    {
-        "written_up_2_targets",
-        RulesTraversal_written_up_2_targets
-    },
-    {
-        "written_self_up_2_targets_diamond",
-        RulesTraversal_written_self_up_2_targets_diamond
-    },
-    {
-        "written_up_2_targets_diamond",
-        RulesTraversal_written_up_2_targets_diamond
-    },
-    {
-        "2_self_up_terms",
-        RulesTraversal_2_self_up_terms
-    },
-    {
-        "2_self_up_terms_2_targets",
-        RulesTraversal_2_self_up_terms_2_targets
-    },
-    {
-        "self_up_empty_table",
-        RulesTraversal_self_up_empty_table
-    },
-    {
-        "up_empty_table",
-        RulesTraversal_up_empty_table
-    },
-    {
-        "self_up_all_owned",
-        RulesTraversal_self_up_all_owned
-    },
-    {
-        "up_all_owned",
-        RulesTraversal_up_all_owned
-    },
-    {
-        "this_self_up_childof_inherited",
-        RulesTraversal_this_self_up_childof_inherited
-    },
-    {
-        "this_up_childof_inherited",
-        RulesTraversal_this_up_childof_inherited
-    },
-    {
-        "this_written_self_up_childof_inherited",
-        RulesTraversal_this_written_self_up_childof_inherited
-    },
-    {
-        "this_written_up_childof_inherited",
-        RulesTraversal_this_written_up_childof_inherited
-    },
-    {
-        "var_self_up_childof_inherited",
-        RulesTraversal_var_self_up_childof_inherited
-    },
-    {
-        "var_up_childof_inherited",
-        RulesTraversal_var_up_childof_inherited
-    },
-    {
-        "var_written_self_up_childof_inherited",
-        RulesTraversal_var_written_self_up_childof_inherited
-    },
-    {
-        "var_written_up_childof_inherited",
-        RulesTraversal_var_written_up_childof_inherited
-    },
-    {
-        "ent_self_up_childof_inherited",
-        RulesTraversal_ent_self_up_childof_inherited
-    },
-    {
-        "ent_up_childof_inherited",
-        RulesTraversal_ent_up_childof_inherited
-    },
-    {
-        "ent_written_self_up_childof_inherited",
-        RulesTraversal_ent_written_self_up_childof_inherited
-    },
-    {
-        "ent_written_up_childof_inherited",
-        RulesTraversal_ent_written_up_childof_inherited
-    },
-    {
-        "this_self_up_childof_component",
-        RulesTraversal_this_self_up_childof_component
-    },
-    {
-        "this_up_childof_component",
-        RulesTraversal_this_up_childof_component
-    },
-    {
-        "this_written_self_up_childof_component",
-        RulesTraversal_this_written_self_up_childof_component
-    },
-    {
-        "this_written_up_childof_component",
-        RulesTraversal_this_written_up_childof_component
-    },
-    {
-        "var_self_up_childof_component",
-        RulesTraversal_var_self_up_childof_component
-    },
-    {
-        "var_up_childof_component",
-        RulesTraversal_var_up_childof_component
-    },
-    {
-        "var_written_self_up_childof_component",
-        RulesTraversal_var_written_self_up_childof_component
-    },
-    {
-        "var_written_up_childof_component",
-        RulesTraversal_var_written_up_childof_component
-    },
-    {
-        "this_self_up_childof_recycled_parent",
-        RulesTraversal_this_self_up_childof_recycled_parent
-    },
-    {
-        "this_up_childof_recycled_parent",
-        RulesTraversal_this_up_childof_recycled_parent
-    },
-    {
-        "this_written_self_up_childof_recycled_parent",
-        RulesTraversal_this_written_self_up_childof_recycled_parent
-    },
-    {
-        "this_written_up_childof_recycled_parent",
-        RulesTraversal_this_written_up_childof_recycled_parent
-    },
-    {
-        "this_self_up_childof_recycled_parent_component",
-        RulesTraversal_this_self_up_childof_recycled_parent_component
-    },
-    {
-        "this_up_childof_recycled_parent_component",
-        RulesTraversal_this_up_childof_recycled_parent_component
-    },
-    {
-        "this_written_self_up_childof_recycled_parent_component",
-        RulesTraversal_this_written_self_up_childof_recycled_parent_component
-    },
-    {
-        "this_written_up_childof_recycled_parent_component",
-        RulesTraversal_this_written_up_childof_recycled_parent_component
-    },
-    {
-        "this_self_up_childof_pair",
-        RulesTraversal_this_self_up_childof_pair
-    },
-    {
-        "this_up_childof_pair",
-        RulesTraversal_this_up_childof_pair
-    },
-    {
-        "this_written_self_up_childof_pair",
-        RulesTraversal_this_written_self_up_childof_pair
-    },
-    {
-        "this_written_up_childof_pair",
-        RulesTraversal_this_written_up_childof_pair
-    },
-    {
-        "this_self_up_childof_pair_wildcard",
-        RulesTraversal_this_self_up_childof_pair_wildcard
-    },
-    {
-        "this_up_childof_pair_wildcard",
-        RulesTraversal_this_up_childof_pair_wildcard
-    },
-    {
-        "this_written_self_up_childof_pair_wildcard",
-        RulesTraversal_this_written_self_up_childof_pair_wildcard
-    },
-    {
-        "this_written_up_childof_pair_wildcard",
-        RulesTraversal_this_written_up_childof_pair_wildcard
-    },
-    {
-        "this_self_up_childof_pair_tgt_var",
-        RulesTraversal_this_self_up_childof_pair_tgt_var
-    },
-    {
-        "this_written_self_up_childof_pair_tgt_var",
-        RulesTraversal_this_written_self_up_childof_pair_tgt_var
-    },
-    {
-        "this_self_up_childof_pair_rel_var",
-        RulesTraversal_this_self_up_childof_pair_rel_var
-    },
-    {
-        "this_written_self_up_childof_pair_rel_var",
-        RulesTraversal_this_written_self_up_childof_pair_rel_var
-    },
-    {
-        "this_self_up_childof_pair_for_var_written",
-        RulesTraversal_this_self_up_childof_pair_for_var_written
-    },
-    {
-        "this_up_childof_pair_for_var_written",
-        RulesTraversal_this_up_childof_pair_for_var_written
-    },
-    {
-        "this_written_self_up_childof_pair_for_var_written",
-        RulesTraversal_this_written_self_up_childof_pair_for_var_written
-    },
-    {
-        "this_self_up_childof_pair_for_var_written_n_targets",
-        RulesTraversal_this_self_up_childof_pair_for_var_written_n_targets
-    },
-    {
-        "this_written_self_up_childof_pair_for_var_written_n_targets",
-        RulesTraversal_this_written_self_up_childof_pair_for_var_written_n_targets
-    },
-    {
-        "self_up_2_levels",
-        RulesTraversal_self_up_2_levels
-    },
-    {
-        "not_up_disabled",
-        RulesTraversal_not_up_disabled
-    },
-    {
-        "up_2_rel_instances",
-        RulesTraversal_up_2_rel_instances
-    },
-    {
-        "up_2_rel_instances_match_2nd",
-        RulesTraversal_up_2_rel_instances_match_2nd
-    },
-    {
-        "up_only_w_owned",
-        RulesTraversal_up_only_w_owned
-    },
-    {
-        "this_self_cascade_childof",
-        RulesTraversal_this_self_cascade_childof
-    },
-    {
-        "this_cascade_childof",
-        RulesTraversal_this_cascade_childof
-    },
-    {
-        "this_written_self_cascade_childof",
-        RulesTraversal_this_written_self_cascade_childof
-    },
-    {
-        "this_written_cascade_childof",
-        RulesTraversal_this_written_cascade_childof
-    },
-    {
-        "this_self_cascade_childof_w_parent_flag",
-        RulesTraversal_this_self_cascade_childof_w_parent_flag
-    },
-    {
-        "this_cascade_childof_w_parent_flag",
-        RulesTraversal_this_cascade_childof_w_parent_flag
-    },
-    {
-        "this_written_self_cascade_childof_w_parent_flag",
-        RulesTraversal_this_written_self_cascade_childof_w_parent_flag
-    },
-    {
-        "this_written_cascade_childof_w_parent_flag",
-        RulesTraversal_this_written_cascade_childof_w_parent_flag
-    }
-};
-
-bake_test_case SystemPeriodic_testcases[] = {
-    {
-        "1_type_1_component",
-        SystemPeriodic_1_type_1_component
-    },
-    {
-        "1_type_3_component",
-        SystemPeriodic_1_type_3_component
-    },
-    {
-        "3_type_1_component",
-        SystemPeriodic_3_type_1_component
-    },
-    {
-        "2_type_3_component",
-        SystemPeriodic_2_type_3_component
-    },
-    {
-        "1_type_1_component_1_tag",
-        SystemPeriodic_1_type_1_component_1_tag
-    },
-    {
-        "2_type_1_component_1_tag",
-        SystemPeriodic_2_type_1_component_1_tag
-    },
-    {
-        "2_type_1_and_1_not",
-        SystemPeriodic_2_type_1_and_1_not
-    },
-    {
-        "2_type_2_and_1_not",
-        SystemPeriodic_2_type_2_and_1_not
-    },
-    {
-        "2_type_2_and_2_not",
-        SystemPeriodic_2_type_2_and_2_not
-    },
-    {
-        "4_type_1_and_1_or",
-        SystemPeriodic_4_type_1_and_1_or
-    },
-    {
-        "4_type_1_and_1_or_of_3",
-        SystemPeriodic_4_type_1_and_1_or_of_3
-    },
-    {
-        "1_type_1_and_1_or",
-        SystemPeriodic_1_type_1_and_1_or
-    },
-    {
-        "2_type_1_and_1_optional",
-        SystemPeriodic_2_type_1_and_1_optional
-    },
-    {
-        "2_type_2_and_1_optional",
-        SystemPeriodic_2_type_2_and_1_optional
-    },
-    {
-        "6_type_1_and_2_optional",
-        SystemPeriodic_6_type_1_and_2_optional
-    },
-    {
-        "ensure_optional_is_unset_column",
-        SystemPeriodic_ensure_optional_is_unset_column
-    },
-    {
-        "ensure_optional_is_null_shared",
-        SystemPeriodic_ensure_optional_is_null_shared
-    },
-    {
-        "match_2_systems_w_populated_table",
-        SystemPeriodic_match_2_systems_w_populated_table
-    },
-    {
-        "on_period",
-        SystemPeriodic_on_period
-    },
-    {
-        "on_period_long_delta",
-        SystemPeriodic_on_period_long_delta
-    },
-    {
-        "disabled",
-        SystemPeriodic_disabled
-    },
-    {
-        "disabled_feature",
-        SystemPeriodic_disabled_feature
-    },
-    {
-        "disabled_nested_feature",
-        SystemPeriodic_disabled_nested_feature
-    },
-    {
-        "two_refs",
-        SystemPeriodic_two_refs
-    },
-    {
-        "filter_disabled",
-        SystemPeriodic_filter_disabled
-    },
-    {
-        "match_disabled",
-        SystemPeriodic_match_disabled
-    },
-    {
-        "match_disabled_and_enabled",
-        SystemPeriodic_match_disabled_and_enabled
-    },
-    {
-        "match_prefab",
-        SystemPeriodic_match_prefab
-    },
-    {
-        "match_prefab_and_normal",
-        SystemPeriodic_match_prefab_and_normal
-    },
-    {
-        "is_shared_on_column_not_set",
-        SystemPeriodic_is_shared_on_column_not_set
-    },
-    {
-        "owned_column",
-        SystemPeriodic_owned_column
-    },
-    {
-        "owned_not_column",
-        SystemPeriodic_owned_not_column
-    },
-    {
-        "owned_or_column",
-        SystemPeriodic_owned_or_column
-    },
-    {
-        "shared_column",
-        SystemPeriodic_shared_column
-    },
-    {
-        "shared_not_column",
-        SystemPeriodic_shared_not_column
-    },
-    {
-        "shared_or_column",
-        SystemPeriodic_shared_or_column
-    },
-    {
-        "container_dont_match_inheritance",
-        SystemPeriodic_container_dont_match_inheritance
-    },
-    {
-        "cascade_dont_match_inheritance",
-        SystemPeriodic_cascade_dont_match_inheritance
-    },
-    {
-        "not_from_entity",
-        SystemPeriodic_not_from_entity
-    },
-    {
-        "sys_context",
-        SystemPeriodic_sys_context
-    },
-    {
-        "get_sys_context_from_param",
-        SystemPeriodic_get_sys_context_from_param
-    },
-    {
-        "owned_only",
-        SystemPeriodic_owned_only
-    },
-    {
-        "shared_only",
-        SystemPeriodic_shared_only
-    },
-    {
-        "is_in_readonly",
-        SystemPeriodic_is_in_readonly
-    },
-    {
-        "get_period",
-        SystemPeriodic_get_period
-    },
-    {
-        "and_type",
-        SystemPeriodic_and_type
-    },
-    {
-        "or_type",
-        SystemPeriodic_or_type
-    }
-};
-
-bake_test_case Timer_testcases[] = {
-    {
-        "timeout",
-        Timer_timeout
-    },
-    {
-        "interval",
-        Timer_interval
-    },
-    {
-        "shared_timeout",
-        Timer_shared_timeout
-    },
-    {
-        "shared_interval",
-        Timer_shared_interval
-    },
-    {
-        "start_stop_one_shot",
-        Timer_start_stop_one_shot
-    },
-    {
-        "start_stop_interval",
-        Timer_start_stop_interval
-    },
-    {
-        "rate_filter",
-        Timer_rate_filter
-    },
-    {
-        "rate_filter_w_rate_filter_src",
-        Timer_rate_filter_w_rate_filter_src
-    },
-    {
-        "rate_filter_w_timer_src",
-        Timer_rate_filter_w_timer_src
-    },
-    {
-        "rate_filter_with_empty_src",
-        Timer_rate_filter_with_empty_src
-    },
-    {
-        "one_shot_timer_entity",
-        Timer_one_shot_timer_entity
-    },
-    {
-        "interval_timer_entity",
-        Timer_interval_timer_entity
-    },
-    {
-        "rate_entity",
-        Timer_rate_entity
-    },
-    {
-        "nested_rate_entity",
-        Timer_nested_rate_entity
-    },
-    {
-        "nested_rate_entity_empty_src",
-        Timer_nested_rate_entity_empty_src
-    },
-    {
-        "naked_tick_entity",
-        Timer_naked_tick_entity
-    },
-    {
-        "stop_timer_w_rate",
-        Timer_stop_timer_w_rate
-    },
-    {
-        "stop_timer_w_rate_same_src",
-        Timer_stop_timer_w_rate_same_src
-    },
-    {
-        "randomize_timers",
-        Timer_randomize_timers
-    }
-};
-
-bake_test_case SystemCascade_testcases[] = {
-    {
-        "cascade_depth_1",
-        SystemCascade_cascade_depth_1
-    },
-    {
-        "cascade_depth_2",
-        SystemCascade_cascade_depth_2
-    },
-    {
-        "cascade_depth_2_new_syntax",
-        SystemCascade_cascade_depth_2_new_syntax
-    },
-    {
-        "add_after_match",
-        SystemCascade_add_after_match
-    },
-    {
-        "adopt_after_match",
-        SystemCascade_adopt_after_match
-    },
-    {
-        "custom_relation_cascade_depth_1",
-        SystemCascade_custom_relation_cascade_depth_1
-    },
-    {
-        "custom_relation_cascade_depth_2",
-        SystemCascade_custom_relation_cascade_depth_2
-    },
-    {
-        "custom_relation_add_after_match",
-        SystemCascade_custom_relation_add_after_match
-    },
-    {
-        "custom_relation_adopt_after_match",
-        SystemCascade_custom_relation_adopt_after_match
-    }
-};
-
-bake_test_case SystemManual_testcases[] = {
-    {
-        "1_type_1_component",
-        SystemManual_1_type_1_component
-    },
-    {
-        "no_automerge",
-        SystemManual_no_automerge
-    },
-    {
-        "dont_run_w_unmatching_entity_query",
-        SystemManual_dont_run_w_unmatching_entity_query
-    }
-};
-
-bake_test_case Tasks_testcases[] = {
-    {
-        "no_components",
-        Tasks_no_components
-    },
-    {
-        "one_tag",
-        Tasks_one_tag
-    },
-    {
-        "from_system",
-        Tasks_from_system
-    },
-    {
-        "tasks_in_phases",
-        Tasks_tasks_in_phases
-    }
-};
-
-bake_test_case System_w_FromParent_testcases[] = {
-    {
-        "1_column_from_container",
-        System_w_FromParent_1_column_from_container
-    },
-    {
-        "2_column_1_from_container",
-        System_w_FromParent_2_column_1_from_container
-    },
-    {
-        "3_column_2_from_container",
-        System_w_FromParent_3_column_2_from_container
-    },
-    {
-        "2_column_1_from_container_w_not",
-        System_w_FromParent_2_column_1_from_container_w_not
-    },
-    {
-        "2_column_1_from_container_w_not_prefab",
-        System_w_FromParent_2_column_1_from_container_w_not_prefab
-    },
-    {
-        "3_column_1_from_comtainer_1_from_container_w_not",
-        System_w_FromParent_3_column_1_from_comtainer_1_from_container_w_not
-    },
-    {
-        "2_column_1_from_container_w_or",
-        System_w_FromParent_2_column_1_from_container_w_or
-    },
-    {
-        "select_same_from_container",
-        System_w_FromParent_select_same_from_container
-    },
-    {
-        "add_component_after_match",
-        System_w_FromParent_add_component_after_match
-    },
-    {
-        "add_component_after_match_and_rematch",
-        System_w_FromParent_add_component_after_match_and_rematch
-    },
-    {
-        "add_component_after_match_unmatch",
-        System_w_FromParent_add_component_after_match_unmatch
-    },
-    {
-        "add_component_after_match_unmatch_match",
-        System_w_FromParent_add_component_after_match_unmatch_match
-    },
-    {
-        "add_component_after_match_2_systems",
-        System_w_FromParent_add_component_after_match_2_systems
-    },
-    {
-        "add_component_in_progress_after_match",
-        System_w_FromParent_add_component_in_progress_after_match
-    },
-    {
-        "add_component_after_match_and_rematch_w_entity_type_expr",
-        System_w_FromParent_add_component_after_match_and_rematch_w_entity_type_expr
-    },
-    {
-        "add_component_after_match_and_rematch_w_entity_type_expr_in_progress",
-        System_w_FromParent_add_component_after_match_and_rematch_w_entity_type_expr_in_progress
-    },
-    {
-        "adopt_after_match",
-        System_w_FromParent_adopt_after_match
-    },
-    {
-        "new_child_after_match",
-        System_w_FromParent_new_child_after_match
-    },
-    {
-        "realloc_after_match",
-        System_w_FromParent_realloc_after_match
-    }
-};
-
-bake_test_case System_w_Empty_testcases[] = {
-    {
-        "2_column_1_from_id",
-        System_w_Empty_2_column_1_from_id
-    },
-    {
-        "3_column_2_from_id",
-        System_w_Empty_3_column_2_from_id
-    },
-    {
-        "column_type",
-        System_w_Empty_column_type
-    }
-};
-
-bake_test_case System_w_FromSystem_testcases[] = {
-    {
-        "2_column_1_from_system",
-        System_w_FromSystem_2_column_1_from_system
-    },
-    {
-        "3_column_2_from_system",
-        System_w_FromSystem_3_column_2_from_system
-    },
-    {
-        "auto_add_tag",
-        System_w_FromSystem_auto_add_tag
-    }
-};
-
-bake_test_case System_w_FromEntity_testcases[] = {
-    {
-        "2_column_1_from_entity",
-        System_w_FromEntity_2_column_1_from_entity
-    },
-    {
-        "task_from_entity",
-        System_w_FromEntity_task_from_entity
-    },
-    {
-        "task_not_from_entity",
-        System_w_FromEntity_task_not_from_entity
-    }
-};
-
-bake_test_case Stats_testcases[] = {
-    {
-        "get_world_stats",
-        Stats_get_world_stats
-    },
-    {
-        "get_pipeline_stats_before_progress_mini_world",
-        Stats_get_pipeline_stats_before_progress_mini_world
-    },
-    {
-        "get_pipeline_stats_before_progress",
-        Stats_get_pipeline_stats_before_progress
-    },
-    {
-        "get_pipeline_stats_after_progress_no_systems",
-        Stats_get_pipeline_stats_after_progress_no_systems
-    },
-    {
-        "get_pipeline_stats_after_progress_1_system",
-        Stats_get_pipeline_stats_after_progress_1_system
-    },
-    {
-        "get_pipeline_stats_after_progress_1_inactive_system",
-        Stats_get_pipeline_stats_after_progress_1_inactive_system
-    },
-    {
-        "get_pipeline_stats_after_progress_2_systems",
-        Stats_get_pipeline_stats_after_progress_2_systems
-    },
-    {
-        "get_pipeline_stats_after_progress_2_systems_one_merge",
-        Stats_get_pipeline_stats_after_progress_2_systems_one_merge
-    },
-    {
-        "get_entity_count",
-        Stats_get_entity_count
-    },
-    {
-        "get_pipeline_stats_w_task_system",
-        Stats_get_pipeline_stats_w_task_system
-    },
-    {
-        "get_not_alive_entity_count",
-        Stats_get_not_alive_entity_count
-    }
-};
-
-bake_test_case Run_testcases[] = {
-    {
-        "run",
-        Run_run
-    },
-    {
-        "run_w_param",
-        Run_run_w_param
-    },
-    {
-        "run_no_match",
-        Run_run_no_match
-    },
-    {
-        "run_w_offset",
-        Run_run_w_offset
-    },
-    {
-        "run_w_offset_skip_1_archetype",
-        Run_run_w_offset_skip_1_archetype
-    },
-    {
-        "run_w_offset_skip_1_archetype_plus_one",
-        Run_run_w_offset_skip_1_archetype_plus_one
-    },
-    {
-        "run_w_offset_skip_2_archetypes",
-        Run_run_w_offset_skip_2_archetypes
-    },
-    {
-        "run_w_limit_skip_1_archetype",
-        Run_run_w_limit_skip_1_archetype
-    },
-    {
-        "run_w_limit_skip_1_archetype_minus_one",
-        Run_run_w_limit_skip_1_archetype_minus_one
-    },
-    {
-        "run_w_limit_skip_2_archetypes",
-        Run_run_w_limit_skip_2_archetypes
-    },
-    {
-        "run_w_offset_1_limit_max",
-        Run_run_w_offset_1_limit_max
-    },
-    {
-        "run_w_offset_1_limit_minus_1",
-        Run_run_w_offset_1_limit_minus_1
-    },
-    {
-        "run_w_offset_2_type_limit_max",
-        Run_run_w_offset_2_type_limit_max
-    },
-    {
-        "run_w_offset_2_type_limit_minus_1",
-        Run_run_w_offset_2_type_limit_minus_1
-    },
-    {
-        "run_w_limit_1_all_offsets",
-        Run_run_w_limit_1_all_offsets
-    },
-    {
-        "run_w_offset_out_of_bounds",
-        Run_run_w_offset_out_of_bounds
-    },
-    {
-        "run_w_limit_out_of_bounds",
-        Run_run_w_limit_out_of_bounds
-    },
-    {
-        "run_comb_10_entities_1_type",
-        Run_run_comb_10_entities_1_type
-    },
-    {
-        "run_comb_10_entities_2_types",
-        Run_run_comb_10_entities_2_types
-    },
-    {
-        "run_w_interrupt",
-        Run_run_w_interrupt
-    },
-    {
-        "run_staging",
-        Run_run_staging
+        "dont_run_w_unmatching_entity_query",
+        SystemManual_dont_run_w_unmatching_entity_query
     }
 };
 
-bake_test_case MultiThread_testcases[] = {
-    {
-        "2_thread_1_entity",
-        MultiThread_2_thread_1_entity
-    },
-    {
-        "2_thread_2_entity",
-        MultiThread_2_thread_2_entity
-    },
-    {
-        "2_thread_5_entity",
-        MultiThread_2_thread_5_entity
-    },
-    {
-        "2_thread_10_entity",
-        MultiThread_2_thread_10_entity
-    },
-    {
-        "3_thread_1_entity",
-        MultiThread_3_thread_1_entity
-    },
-    {
-        "3_thread_2_entity",
-        MultiThread_3_thread_2_entity
-    },
-    {
-        "3_thread_5_entity",
-        MultiThread_3_thread_5_entity
-    },
-    {
-        "3_thread_10_entity",
-        MultiThread_3_thread_10_entity
-    },
-    {
-        "4_thread_1_entity",
-        MultiThread_4_thread_1_entity
-    },
-    {
-        "4_thread_2_entity",
-        MultiThread_4_thread_2_entity
-    },
-    {
-        "4_thread_5_entity",
-        MultiThread_4_thread_5_entity
-    },
-    {
-        "4_thread_10_entity",
-        MultiThread_4_thread_10_entity
-    },
-    {
-        "5_thread_1_entity",
-        MultiThread_5_thread_1_entity
-    },
-    {
-        "5_thread_2_entity",
-        MultiThread_5_thread_2_entity
-    },
-    {
-        "5_thread_5_entity",
-        MultiThread_5_thread_5_entity
-    },
-    {
-        "5_thread_10_entity",
-        MultiThread_5_thread_10_entity
-    },
-    {
-        "6_thread_1_entity",
-        MultiThread_6_thread_1_entity
-    },
-    {
-        "6_thread_2_entity",
-        MultiThread_6_thread_2_entity
-    },
+bake_test_case Tasks_testcases[] = {
     {
-        "6_thread_5_entity",
-        MultiThread_6_thread_5_entity
+        "no_components",
+        Tasks_no_components
     },
     {
-        "6_thread_10_entity",
-        MultiThread_6_thread_10_entity
+        "one_tag",
+        Tasks_one_tag
     },
     {
-        "2_thread_1_entity_instanced",
-        MultiThread_2_thread_1_entity_instanced
+        "from_system",
+        Tasks_from_system
     },
     {
-        "2_thread_5_entity_instanced",
-        MultiThread_2_thread_5_entity_instanced
-    },
+        "tasks_in_phases",
+        Tasks_tasks_in_phases
+    }
+};
+
+bake_test_case System_w_FromParent_testcases[] = {
     {
-        "2_thread_10_entity_instanced",
-        MultiThread_2_thread_10_entity_instanced
+        "1_column_from_container",
+        System_w_FromParent_1_column_from_container
     },
     {
-        "2_thread_test_combs_100_entity_w_next_worker",
-        MultiThread_2_thread_test_combs_100_entity_w_next_worker
+        "2_column_1_from_container",
+        System_w_FromParent_2_column_1_from_container
     },
     {
-        "2_thread_test_combs_100_entity",
-        MultiThread_2_thread_test_combs_100_entity
+        "3_column_2_from_container",
+        System_w_FromParent_3_column_2_from_container
     },
     {
-        "3_thread_test_combs_100_entity",
-        MultiThread_3_thread_test_combs_100_entity
+        "2_column_1_from_container_w_not",
+        System_w_FromParent_2_column_1_from_container_w_not
     },
     {
-        "4_thread_test_combs_100_entity",
-        MultiThread_4_thread_test_combs_100_entity
+        "2_column_1_from_container_w_not_prefab",
+        System_w_FromParent_2_column_1_from_container_w_not_prefab
     },
     {
-        "5_thread_test_combs_100_entity",
-        MultiThread_5_thread_test_combs_100_entity
+        "3_column_1_from_comtainer_1_from_container_w_not",
+        System_w_FromParent_3_column_1_from_comtainer_1_from_container_w_not
     },
     {
-        "6_thread_test_combs_100_entity",
-        MultiThread_6_thread_test_combs_100_entity
+        "2_column_1_from_container_w_or",
+        System_w_FromParent_2_column_1_from_container_w_or
     },
     {
-        "2_thread_test_combs_100_entity_2_types",
-        MultiThread_2_thread_test_combs_100_entity_2_types
+        "select_same_from_container",
+        System_w_FromParent_select_same_from_container
     },
     {
-        "3_thread_test_combs_100_entity_2_types",
-        MultiThread_3_thread_test_combs_100_entity_2_types
+        "add_component_after_match",
+        System_w_FromParent_add_component_after_match
     },
     {
-        "4_thread_test_combs_100_entity_2_types",
-        MultiThread_4_thread_test_combs_100_entity_2_types
+        "add_component_after_match_and_rematch",
+        System_w_FromParent_add_component_after_match_and_rematch
     },
     {
-        "5_thread_test_combs_100_entity_2_types",
-        MultiThread_5_thread_test_combs_100_entity_2_types
+        "add_component_after_match_unmatch",
+        System_w_FromParent_add_component_after_match_unmatch
     },
     {
-        "6_thread_test_combs_100_entity_2_types",
-        MultiThread_6_thread_test_combs_100_entity_2_types
+        "add_component_after_match_unmatch_match",
+        System_w_FromParent_add_component_after_match_unmatch_match
     },
     {
-        "change_thread_count",
-        MultiThread_change_thread_count
+        "add_component_after_match_2_systems",
+        System_w_FromParent_add_component_after_match_2_systems
     },
     {
-        "multithread_quit",
-        MultiThread_multithread_quit
+        "add_component_in_progress_after_match",
+        System_w_FromParent_add_component_in_progress_after_match
     },
     {
-        "schedule_w_tasks",
-        MultiThread_schedule_w_tasks
+        "add_component_after_match_and_rematch_w_entity_type_expr",
+        System_w_FromParent_add_component_after_match_and_rematch_w_entity_type_expr
     },
     {
-        "reactive_system",
-        MultiThread_reactive_system
+        "add_component_after_match_and_rematch_w_entity_type_expr_in_progress",
+        System_w_FromParent_add_component_after_match_and_rematch_w_entity_type_expr_in_progress
     },
     {
-        "fini_after_set_threads",
-        MultiThread_fini_after_set_threads
+        "adopt_after_match",
+        System_w_FromParent_adopt_after_match
     },
     {
-        "2_threads_single_threaded_system",
-        MultiThread_2_threads_single_threaded_system
+        "new_child_after_match",
+        System_w_FromParent_new_child_after_match
     },
     {
-        "no_staging_w_multithread",
-        MultiThread_no_staging_w_multithread
-    },
+        "realloc_after_match",
+        System_w_FromParent_realloc_after_match
+    }
+};
+
+bake_test_case System_w_Empty_testcases[] = {
     {
-        "multithread_w_monitor_addon",
-        MultiThread_multithread_w_monitor_addon
+        "2_column_1_from_id",
+        System_w_Empty_2_column_1_from_id
     },
     {
-        "get_ctx",
-        MultiThread_get_ctx
+        "3_column_2_from_id",
+        System_w_Empty_3_column_2_from_id
     },
     {
-        "get_binding_ctx",
-        MultiThread_get_binding_ctx
-    },
+        "column_type",
+        System_w_Empty_column_type
+    }
+};
+
+bake_test_case System_w_FromSystem_testcases[] = {
     {
-        "get_ctx_w_run",
-        MultiThread_get_ctx_w_run
+        "2_column_1_from_system",
+        System_w_FromSystem_2_column_1_from_system
     },
     {
-        "get_binding_ctx_w_run",
-        MultiThread_get_binding_ctx_w_run
+        "3_column_2_from_system",
+        System_w_FromSystem_3_column_2_from_system
     },
     {
-        "bulk_new_in_no_readonly_w_multithread",
-        MultiThread_bulk_new_in_no_readonly_w_multithread
-    },
+        "auto_add_tag",
+        System_w_FromSystem_auto_add_tag
+    }
+};
+
+bake_test_case System_w_FromEntity_testcases[] = {
     {
-        "bulk_new_in_no_readonly_w_multithread_2",
-        MultiThread_bulk_new_in_no_readonly_w_multithread_2
+        "2_column_1_from_entity",
+        System_w_FromEntity_2_column_1_from_entity
     },
     {
-        "run_first_worker_on_main",
-        MultiThread_run_first_worker_on_main
+        "task_from_entity",
+        System_w_FromEntity_task_from_entity
     },
     {
-        "run_single_thread_on_main",
-        MultiThread_run_single_thread_on_main
+        "task_not_from_entity",
+        System_w_FromEntity_task_not_from_entity
     }
 };
 
-bake_test_case MultiThreadStaging_testcases[] = {
+bake_test_case Stats_testcases[] = {
     {
-        "2_threads_add_to_current",
-        MultiThreadStaging_2_threads_add_to_current
+        "get_world_stats",
+        Stats_get_world_stats
     },
     {
-        "3_threads_add_to_current",
-        MultiThreadStaging_3_threads_add_to_current
+        "get_pipeline_stats_before_progress_mini_world",
+        Stats_get_pipeline_stats_before_progress_mini_world
     },
     {
-        "4_threads_add_to_current",
-        MultiThreadStaging_4_threads_add_to_current
+        "get_pipeline_stats_before_progress",
+        Stats_get_pipeline_stats_before_progress
     },
     {
-        "5_threads_add_to_current",
-        MultiThreadStaging_5_threads_add_to_current
+        "get_pipeline_stats_after_progress_no_systems",
+        Stats_get_pipeline_stats_after_progress_no_systems
     },
     {
-        "6_threads_add_to_current",
-        MultiThreadStaging_6_threads_add_to_current
+        "get_pipeline_stats_after_progress_1_system",
+        Stats_get_pipeline_stats_after_progress_1_system
     },
     {
-        "2_threads_on_add",
-        MultiThreadStaging_2_threads_on_add
+        "get_pipeline_stats_after_progress_1_inactive_system",
+        Stats_get_pipeline_stats_after_progress_1_inactive_system
     },
     {
-        "new_w_count",
-        MultiThreadStaging_new_w_count
+        "get_pipeline_stats_after_progress_2_systems",
+        Stats_get_pipeline_stats_after_progress_2_systems
     },
     {
-        "custom_thread_auto_merge",
-        MultiThreadStaging_custom_thread_auto_merge
+        "get_pipeline_stats_after_progress_2_systems_one_merge",
+        Stats_get_pipeline_stats_after_progress_2_systems_one_merge
     },
     {
-        "custom_thread_manual_merge",
-        MultiThreadStaging_custom_thread_manual_merge
+        "get_entity_count",
+        Stats_get_entity_count
     },
     {
-        "custom_thread_partial_manual_merge",
-        MultiThreadStaging_custom_thread_partial_manual_merge
+        "get_pipeline_stats_w_task_system",
+        Stats_get_pipeline_stats_w_task_system
     },
     {
-        "set_pair_w_new_target_readonly",
-        MultiThreadStaging_set_pair_w_new_target_readonly
+        "get_not_alive_entity_count",
+        Stats_get_not_alive_entity_count
+    }
+};
+
+bake_test_case Run_testcases[] = {
+    {
+        "run",
+        Run_run
     },
     {
-        "set_pair_w_new_target_tgt_component_readonly",
-        MultiThreadStaging_set_pair_w_new_target_tgt_component_readonly
+        "run_w_param",
+        Run_run_w_param
     },
     {
-        "set_pair_w_new_target_defer",
-        MultiThreadStaging_set_pair_w_new_target_defer
+        "run_no_match",
+        Run_run_no_match
     },
     {
-        "set_pair_w_new_target_tgt_component_defer",
-        MultiThreadStaging_set_pair_w_new_target_tgt_component_defer
+        "run_w_interrupt",
+        Run_run_w_interrupt
+    },
+    {
+        "run_staging",
+        Run_run_staging
     }
 };
 
-bake_test_case MultiTaskThread_testcases[] = {
+bake_test_case MultiThread_testcases[] = {
     {
         "2_thread_1_entity",
-        MultiTaskThread_2_thread_1_entity
+        MultiThread_2_thread_1_entity
     },
     {
         "2_thread_2_entity",
-        MultiTaskThread_2_thread_2_entity
+        MultiThread_2_thread_2_entity
     },
     {
         "2_thread_5_entity",
-        MultiTaskThread_2_thread_5_entity
+        MultiThread_2_thread_5_entity
     },
     {
         "2_thread_10_entity",
-        MultiTaskThread_2_thread_10_entity
+        MultiThread_2_thread_10_entity
     },
     {
         "3_thread_1_entity",
-        MultiTaskThread_3_thread_1_entity
+        MultiThread_3_thread_1_entity
     },
     {
         "3_thread_2_entity",
-        MultiTaskThread_3_thread_2_entity
+        MultiThread_3_thread_2_entity
     },
     {
         "3_thread_5_entity",
-        MultiTaskThread_3_thread_5_entity
+        MultiThread_3_thread_5_entity
     },
     {
         "3_thread_10_entity",
-        MultiTaskThread_3_thread_10_entity
+        MultiThread_3_thread_10_entity
     },
     {
         "4_thread_1_entity",
-        MultiTaskThread_4_thread_1_entity
+        MultiThread_4_thread_1_entity
     },
     {
         "4_thread_2_entity",
-        MultiTaskThread_4_thread_2_entity
+        MultiThread_4_thread_2_entity
     },
     {
         "4_thread_5_entity",
-        MultiTaskThread_4_thread_5_entity
+        MultiThread_4_thread_5_entity
     },
     {
         "4_thread_10_entity",
-        MultiTaskThread_4_thread_10_entity
+        MultiThread_4_thread_10_entity
     },
     {
         "5_thread_1_entity",
-        MultiTaskThread_5_thread_1_entity
+        MultiThread_5_thread_1_entity
     },
     {
         "5_thread_2_entity",
-        MultiTaskThread_5_thread_2_entity
+        MultiThread_5_thread_2_entity
     },
     {
         "5_thread_5_entity",
-        MultiTaskThread_5_thread_5_entity
+        MultiThread_5_thread_5_entity
     },
     {
         "5_thread_10_entity",
-        MultiTaskThread_5_thread_10_entity
+        MultiThread_5_thread_10_entity
     },
     {
         "6_thread_1_entity",
-        MultiTaskThread_6_thread_1_entity
+        MultiThread_6_thread_1_entity
     },
     {
         "6_thread_2_entity",
-        MultiTaskThread_6_thread_2_entity
+        MultiThread_6_thread_2_entity
     },
     {
         "6_thread_5_entity",
-        MultiTaskThread_6_thread_5_entity
+        MultiThread_6_thread_5_entity
     },
     {
         "6_thread_10_entity",
-        MultiTaskThread_6_thread_10_entity
+        MultiThread_6_thread_10_entity
     },
     {
         "2_thread_1_entity_instanced",
-        MultiTaskThread_2_thread_1_entity_instanced
+        MultiThread_2_thread_1_entity_instanced
     },
     {
         "2_thread_5_entity_instanced",
-        MultiTaskThread_2_thread_5_entity_instanced
+        MultiThread_2_thread_5_entity_instanced
     },
     {
         "2_thread_10_entity_instanced",
-        MultiTaskThread_2_thread_10_entity_instanced
+        MultiThread_2_thread_10_entity_instanced
     },
     {
         "2_thread_test_combs_100_entity_w_next_worker",
-        MultiTaskThread_2_thread_test_combs_100_entity_w_next_worker
+        MultiThread_2_thread_test_combs_100_entity_w_next_worker
     },
     {
         "2_thread_test_combs_100_entity",
-        MultiTaskThread_2_thread_test_combs_100_entity
+        MultiThread_2_thread_test_combs_100_entity
     },
     {
         "3_thread_test_combs_100_entity",
-        MultiTaskThread_3_thread_test_combs_100_entity
+        MultiThread_3_thread_test_combs_100_entity
     },
     {
         "4_thread_test_combs_100_entity",
-        MultiTaskThread_4_thread_test_combs_100_entity
+        MultiThread_4_thread_test_combs_100_entity
     },
     {
         "5_thread_test_combs_100_entity",
-        MultiTaskThread_5_thread_test_combs_100_entity
+        MultiThread_5_thread_test_combs_100_entity
     },
     {
         "6_thread_test_combs_100_entity",
-        MultiTaskThread_6_thread_test_combs_100_entity
+        MultiThread_6_thread_test_combs_100_entity
     },
     {
         "2_thread_test_combs_100_entity_2_types",
-        MultiTaskThread_2_thread_test_combs_100_entity_2_types
+        MultiThread_2_thread_test_combs_100_entity_2_types
     },
     {
         "3_thread_test_combs_100_entity_2_types",
-        MultiTaskThread_3_thread_test_combs_100_entity_2_types
+        MultiThread_3_thread_test_combs_100_entity_2_types
     },
     {
         "4_thread_test_combs_100_entity_2_types",
-        MultiTaskThread_4_thread_test_combs_100_entity_2_types
+        MultiThread_4_thread_test_combs_100_entity_2_types
     },
     {
         "5_thread_test_combs_100_entity_2_types",
-        MultiTaskThread_5_thread_test_combs_100_entity_2_types
+        MultiThread_5_thread_test_combs_100_entity_2_types
     },
     {
         "6_thread_test_combs_100_entity_2_types",
-        MultiTaskThread_6_thread_test_combs_100_entity_2_types
+        MultiThread_6_thread_test_combs_100_entity_2_types
     },
     {
         "change_thread_count",
-        MultiTaskThread_change_thread_count
+        MultiThread_change_thread_count
     },
     {
         "multithread_quit",
-        MultiTaskThread_multithread_quit
+        MultiThread_multithread_quit
     },
     {
         "schedule_w_tasks",
-        MultiTaskThread_schedule_w_tasks
+        MultiThread_schedule_w_tasks
     },
     {
         "reactive_system",
-        MultiTaskThread_reactive_system
+        MultiThread_reactive_system
     },
     {
         "fini_after_set_threads",
-        MultiTaskThread_fini_after_set_threads
+        MultiThread_fini_after_set_threads
     },
     {
         "2_threads_single_threaded_system",
-        MultiTaskThread_2_threads_single_threaded_system
+        MultiThread_2_threads_single_threaded_system
     },
     {
         "no_staging_w_multithread",
-        MultiTaskThread_no_staging_w_multithread
+        MultiThread_no_staging_w_multithread
     },
     {
         "multithread_w_monitor_addon",
-        MultiTaskThread_multithread_w_monitor_addon
+        MultiThread_multithread_w_monitor_addon
     },
     {
         "get_ctx",
-        MultiTaskThread_get_ctx
+        MultiThread_get_ctx
     },
     {
         "get_binding_ctx",
-        MultiTaskThread_get_binding_ctx
+        MultiThread_get_binding_ctx
     },
     {
         "get_ctx_w_run",
-        MultiTaskThread_get_ctx_w_run
+        MultiThread_get_ctx_w_run
     },
     {
         "get_binding_ctx_w_run",
-        MultiTaskThread_get_binding_ctx_w_run
+        MultiThread_get_binding_ctx_w_run
     },
     {
         "bulk_new_in_no_readonly_w_multithread",
-        MultiTaskThread_bulk_new_in_no_readonly_w_multithread
+        MultiThread_bulk_new_in_no_readonly_w_multithread
     },
     {
         "bulk_new_in_no_readonly_w_multithread_2",
-        MultiTaskThread_bulk_new_in_no_readonly_w_multithread_2
+        MultiThread_bulk_new_in_no_readonly_w_multithread_2
     },
     {
         "run_first_worker_on_main",
-        MultiTaskThread_run_first_worker_on_main
+        MultiThread_run_first_worker_on_main
     },
     {
         "run_single_thread_on_main",
-        MultiTaskThread_run_single_thread_on_main
+        MultiThread_run_single_thread_on_main
     }
 };
 
-bake_test_case MultiTaskThreadStaging_testcases[] = {
+bake_test_case MultiThreadStaging_testcases[] = {
     {
         "2_threads_add_to_current",
-        MultiTaskThreadStaging_2_threads_add_to_current
+        MultiThreadStaging_2_threads_add_to_current
     },
     {
         "3_threads_add_to_current",
-        MultiTaskThreadStaging_3_threads_add_to_current
+        MultiThreadStaging_3_threads_add_to_current
     },
     {
         "4_threads_add_to_current",
-        MultiTaskThreadStaging_4_threads_add_to_current
+        MultiThreadStaging_4_threads_add_to_current
     },
     {
         "5_threads_add_to_current",
-        MultiTaskThreadStaging_5_threads_add_to_current
+        MultiThreadStaging_5_threads_add_to_current
     },
     {
         "6_threads_add_to_current",
-        MultiTaskThreadStaging_6_threads_add_to_current
+        MultiThreadStaging_6_threads_add_to_current
     },
     {
         "2_threads_on_add",
-        MultiTaskThreadStaging_2_threads_on_add
+        MultiThreadStaging_2_threads_on_add
     },
     {
         "new_w_count",
-        MultiTaskThreadStaging_new_w_count
+        MultiThreadStaging_new_w_count
     },
     {
         "custom_thread_auto_merge",
-        MultiTaskThreadStaging_custom_thread_auto_merge
-    },
-    {
-        "custom_thread_manual_merge",
-        MultiTaskThreadStaging_custom_thread_manual_merge
-    },
-    {
-        "custom_thread_partial_manual_merge",
-        MultiTaskThreadStaging_custom_thread_partial_manual_merge
+        MultiThreadStaging_custom_thread_auto_merge
     },
     {
         "set_pair_w_new_target_readonly",
-        MultiTaskThreadStaging_set_pair_w_new_target_readonly
+        MultiThreadStaging_set_pair_w_new_target_readonly
     },
     {
         "set_pair_w_new_target_tgt_component_readonly",
-        MultiTaskThreadStaging_set_pair_w_new_target_tgt_component_readonly
+        MultiThreadStaging_set_pair_w_new_target_tgt_component_readonly
     },
     {
         "set_pair_w_new_target_defer",
-        MultiTaskThreadStaging_set_pair_w_new_target_defer
+        MultiThreadStaging_set_pair_w_new_target_defer
     },
     {
         "set_pair_w_new_target_tgt_component_defer",
-        MultiTaskThreadStaging_set_pair_w_new_target_tgt_component_defer
-    }
-};
-
-bake_test_case Snapshot_testcases[] = {
-    {
-        "simple_snapshot",
-        Snapshot_simple_snapshot
-    },
-    {
-        "snapshot_after_new",
-        Snapshot_snapshot_after_new
-    },
-    {
-        "snapshot_after_delete",
-        Snapshot_snapshot_after_delete
-    },
-    {
-        "snapshot_after_new_type",
-        Snapshot_snapshot_after_new_type
-    },
-    {
-        "snapshot_after_add",
-        Snapshot_snapshot_after_add
-    },
-    {
-        "snapshot_after_remove",
-        Snapshot_snapshot_after_remove
-    },
-    {
-        "snapshot_w_include_filter",
-        Snapshot_snapshot_w_include_filter
-    },
-    {
-        "snapshot_w_exclude_filter",
-        Snapshot_snapshot_w_exclude_filter
-    },
-    {
-        "snapshot_w_filter_after_new",
-        Snapshot_snapshot_w_filter_after_new
-    },
-    {
-        "snapshot_w_filter_after_delete",
-        Snapshot_snapshot_w_filter_after_delete
-    },
-    {
-        "snapshot_free_empty",
-        Snapshot_snapshot_free_empty
-    },
-    {
-        "snapshot_free",
-        Snapshot_snapshot_free
-    },
-    {
-        "snapshot_free_filtered",
-        Snapshot_snapshot_free_filtered
-    },
-    {
-        "snapshot_free_filtered_w_dtor",
-        Snapshot_snapshot_free_filtered_w_dtor
-    },
-    {
-        "snapshot_activate_table_w_filter",
-        Snapshot_snapshot_activate_table_w_filter
-    },
-    {
-        "snapshot_copy",
-        Snapshot_snapshot_copy
-    },
-    {
-        "snapshot_get_ref_after_restore",
-        Snapshot_snapshot_get_ref_after_restore
-    },
-    {
-        "new_after_snapshot",
-        Snapshot_new_after_snapshot
-    },
-    {
-        "new_empty_after_snapshot",
-        Snapshot_new_empty_after_snapshot
-    },
-    {
-        "add_after_snapshot",
-        Snapshot_add_after_snapshot
-    },
-    {
-        "delete_after_snapshot",
-        Snapshot_delete_after_snapshot
-    },
-    {
-        "set_after_snapshot",
-        Snapshot_set_after_snapshot
-    },
-    {
-        "restore_recycled",
-        Snapshot_restore_recycled
-    },
-    {
-        "snapshot_w_new_in_onset",
-        Snapshot_snapshot_w_new_in_onset
-    },
-    {
-        "snapshot_w_new_in_onset_in_snapshot_table",
-        Snapshot_snapshot_w_new_in_onset_in_snapshot_table
-    },
-    {
-        "snapshot_from_stage",
-        Snapshot_snapshot_from_stage
+        MultiThreadStaging_set_pair_w_new_target_tgt_component_defer
     }
 };
 
@@ -8840,6 +2139,10 @@ bake_test_case Rest_testcases[] = {
     {
         "request_commands_garbage_collect",
         Rest_request_commands_garbage_collect
+    },
+    {
+        "script_error",
+        Rest_script_error
     }
 };
 
@@ -9141,22 +2444,16 @@ bake_test_case Alerts_testcases[] = {
     }
 };
 
+const char* MultiThread_worker_kind_param[] = {"thread", "task"};
+bake_test_param MultiThread_params[] = {
+    {"worker_kind", (char**)MultiThread_worker_kind_param, 2}
+};
+const char* MultiThreadStaging_worker_kind_param[] = {"thread", "task"};
+bake_test_param MultiThreadStaging_params[] = {
+    {"worker_kind", (char**)MultiThreadStaging_worker_kind_param, 2}
+};
 
 static bake_test_suite suites[] = {
-    {
-        "Parser",
-        NULL,
-        NULL,
-        261,
-        Parser_testcases
-    },
-    {
-        "Plecs",
-        NULL,
-        NULL,
-        237,
-        Plecs_testcases
-    },
     {
         "Doc",
         NULL,
@@ -9175,71 +2472,8 @@ static bake_test_suite suites[] = {
         "SystemMisc",
         NULL,
         NULL,
-        68,
-        SystemMisc_testcases
-    },
-    {
-        "RulesBasic",
-        NULL,
-        NULL,
-        164,
-        RulesBasic_testcases
-    },
-    {
-        "RulesVariables",
-        NULL,
-        NULL,
-        162,
-        RulesVariables_testcases
-    },
-    {
-        "RulesOperators",
-        NULL,
-        NULL,
-        105,
-        RulesOperators_testcases
-    },
-    {
-        "RulesTransitive",
-        NULL,
-        NULL,
         64,
-        RulesTransitive_testcases
-    },
-    {
-        "RulesComponentInheritance",
-        NULL,
-        NULL,
-        36,
-        RulesComponentInheritance_testcases
-    },
-    {
-        "RulesRecycled",
-        NULL,
-        NULL,
-        4,
-        RulesRecycled_testcases
-    },
-    {
-        "RulesBuiltinPredicates",
-        NULL,
-        NULL,
-        78,
-        RulesBuiltinPredicates_testcases
-    },
-    {
-        "RulesScopes",
-        NULL,
-        NULL,
-        10,
-        RulesScopes_testcases
-    },
-    {
-        "RulesTraversal",
-        NULL,
-        NULL,
-        92,
-        RulesTraversal_testcases
+        SystemMisc_testcases
     },
     {
         "SystemPeriodic",
@@ -9266,7 +2500,7 @@ static bake_test_suite suites[] = {
         "SystemManual",
         SystemManual_setup,
         NULL,
-        3,
+        2,
         SystemManual_testcases
     },
     {
@@ -9315,7 +2549,7 @@ static bake_test_suite suites[] = {
         "Run",
         Run_setup,
         NULL,
-        21,
+        5,
         Run_testcases
     },
     {
@@ -9323,35 +2557,18 @@ static bake_test_suite suites[] = {
         MultiThread_setup,
         NULL,
         50,
-        MultiThread_testcases
+        MultiThread_testcases,
+        1,
+        MultiThread_params
     },
     {
         "MultiThreadStaging",
         MultiThreadStaging_setup,
         NULL,
-        14,
-        MultiThreadStaging_testcases
-    },
-    {
-        "MultiTaskThread",
-        MultiTaskThread_setup,
-        NULL,
-        50,
-        MultiTaskThread_testcases
-    },
-    {
-        "MultiTaskThreadStaging",
-        MultiTaskThreadStaging_setup,
-        NULL,
-        14,
-        MultiTaskThreadStaging_testcases
-    },
-    {
-        "Snapshot",
-        NULL,
-        NULL,
-        26,
-        Snapshot_testcases
+        12,
+        MultiThreadStaging_testcases,
+        1,
+        MultiThreadStaging_params
     },
     {
         "Modules",
@@ -9378,7 +2595,7 @@ static bake_test_suite suites[] = {
         "Rest",
         NULL,
         NULL,
-        13,
+        14,
         Rest_testcases
     },
     {
@@ -9398,5 +2615,5 @@ static bake_test_suite suites[] = {
 };
 
 int main(int argc, char *argv[]) {
-    return bake_test_run("addons", argc, argv, suites, 36);
+    return bake_test_run("addons", argc, argv, suites, 22);
 }
diff --git a/test/addons/src/util.c b/test/addons/src/util.c
index bb9edd211..0a6782446 100644
--- a/test/addons/src/util.c
+++ b/test/addons/src/util.c
@@ -20,9 +20,9 @@ void probe_system_w_ctx(
     int i;
     for (i = 0; i < ctx->term_count; i ++) {
         ctx->c[ctx->invoked][i] = it->ids[i];
-        ctx->s[ctx->invoked][i] = ecs_field_src(it, i + 1);
+        ctx->s[ctx->invoked][i] = ecs_field_src(it, i);
 
-        ecs_id_t e = ecs_field_id(it, i + 1);
+        ecs_id_t e = ecs_field_id(it, i);
         test_assert(e != 0);
     }
 
@@ -91,229 +91,3 @@ const ecs_entity_t* bulk_new_w_type(
     
     return result;
 }
-
-int32_t find_entity(
-    ecs_world_t *world,
-    test_iter_result_t *expect, 
-    ecs_entity_t e)
-{
-    int i;
-    for (i = 0; i < ITER_MAX_ENTITIES; i ++) {
-        if (expect->entities[i] == e) {
-            while (expect->matched[i]) {
-                i ++;
-                if (!if_test_assert(e == expect->entities[i])) {
-                    return -1;
-                }
-            }
-
-            if (expect->entity_names[i]) {
-                if (!if_test_str(ecs_get_name(world, e), expect->entity_names[i])) {
-                    return -1;
-                }
-            }
-            return i;
-        }
-    }
-
-    for (i = 0; i < ITER_MAX_ENTITIES; i ++) {
-        if (!expect->entity_names[i]) {
-            break;
-        }
-
-        if (!strcmp(ecs_get_name(world, e), expect->entity_names[i])) {
-            while (expect->matched[i]) {
-                i ++;
-
-                // If this fails, the entity is encountered more times than
-                // expected.
-                if (!if_test_str(ecs_get_name(world, e), 
-                    expect->entity_names[i])) 
-                {
-                    return -1;
-                }
-            }
-
-            return i;
-        }
-    }
-
-    return -1;
-}
-
-bool test_iter(
-    ecs_iter_t *it, 
-    ecs_iter_next_action_t next, 
-    test_iter_result_t *expect) 
-{
-    int32_t entity_index = -1;
-
-    while (next(it)) {
-        int i;
-
-        for (i = 0; (i < it->count) || (i < 1); i ++) {
-            ecs_entity_t e = 0;
-            int t;
-
-            if (it->count) {
-                e = it->entities[i];
-
-                entity_index = find_entity(it->world, expect, e);
-
-                // Matched unexpected entity
-                test_assert(entity_index != -1);
-
-                expect->matched[entity_index] = true;
-
-                // Test data
-                for (t = 0; t < it->field_count; t++) {
-                    size_t size = ecs_field_size(it, t + 1);
-                    if (!size) {
-                        continue;
-                    }
-
-                    void *expect_ptr = expect->term_columns[t];
-                    if (!expect_ptr) {
-                        continue;
-                    }
-
-                    expect_ptr = ECS_OFFSET(expect_ptr, size * entity_index);
-
-                    void *component_ptr = ecs_field_w_size(it, size, t + 1);
-                    if (!if_test_assert(component_ptr != NULL)) {
-                        return false;
-                    }
-
-                    component_ptr = ECS_OFFSET(component_ptr, size * i);
-                    if (!if_test_assert(memcpy(component_ptr, expect_ptr, size))) {
-                        return false;
-                    }
-                }                
-            } else {
-                entity_index ++;
-            }
-
-
-            // Test ids
-            ecs_id_t *ids = expect->term_ids[entity_index];
-            if (!ids[0]) {
-                ids = expect->term_ids[0];
-            }
-
-            for (t = 0; t < it->field_count; t++) {
-                if (!ids[t]) {
-                    break;
-                }
-
-                if (!if_test_assert(ecs_field_id(it, t + 1) == ids[t])) {
-                    return false;
-                }
-            }
-
-            if (!if_test_assert(ids[t] == 0)) {
-                return false;
-            }
-
-
-            // Test ids by expr
-            char **ids_expect = expect->term_ids_expr[entity_index];
-            if (!ids_expect) {
-                ids_expect = expect->term_ids_expr[0];
-            }
-
-            for (t = 0; t < it->field_count; t++) {
-                if (!ids_expect[t]) {
-                    break;
-                }
-
-                char *id_found = ecs_id_str(it->world, ecs_field_id(it, t + 1));
-                if (!if_test_str(id_found, ids_expect[t])) {
-                    printf(" - term %d\n", t);
-                    if (e) {
-                        printf(" - matched entity %u (%s, [%s])\n", 
-                            (uint32_t)e,
-                            ecs_get_name(it->world, e),
-                            ecs_type_str(it->world, ecs_get_type(it->world, e)));
-
-                        if (expect->entities[i]) {
-                            printf(" - expected entity %u (%s)\n", 
-                                (uint32_t)expect->entities[i], 
-                                ecs_get_name(it->world, expect->entities[i]));
-                        } else if (expect->entity_names[i]) {
-                            printf(" - expected entity %s\n", 
-                                expect->entity_names[i]);
-                        }
-                    }
-
-                    printf(" - @ result index %d\n", entity_index);
-                    return false;
-                }
-                ecs_os_free(id_found);
-            }
-
-            if (!if_test_assert(ids_expect[t] == NULL)) {
-                return false;
-            }
-
-
-            // Test variables
-            int v;
-            for (v = 0; v < ITER_MAX_VARIABLES; v++) {
-                int32_t id = expect->variables[v].id;
-                if (!id) {
-                    break;
-                }
-                
-                ecs_entity_t e = expect->variables[v].entities[entity_index];
-                if (!e) {
-                    e = expect->variables[v].entities[0];
-                }
-                if (e) {
-                    ecs_entity_t var = ecs_iter_get_var(it, id);
-                    if (!if_test_assert(e == var)) {
-                        return false;
-                    }
-                }
-
-                const char *name = expect->variables[v].entity_names[entity_index];
-                if (!name) {
-                    name = expect->variables[v].entity_names[0];
-                }
-                if (name) {
-                    ecs_entity_t var = ecs_iter_get_var(it, id);
-                    if (!if_test_str(name, ecs_get_name(it->world, var))) {
-                        printf(" - variable id %d\n", id);
-                        printf(" - index %d\n", entity_index);
-                        return false;
-                    }                    
-                }
-
-                /* If a variable id is set, either an entity or entity name must
-                 * be set. */
-                if (!if_test_assert(e || name)) {
-                    return false;
-                }
-            }
-        }
-
-        expect->table_count_actual ++;
-    }
-
-    for (int i = 0; i < ITER_MAX_ENTITIES; i ++) {
-        if (expect->entities[i] || expect->entity_names[i]) {
-            if (!if_test_assert(expect->matched[i])) {
-                printf(" - entity %u (%s) at index %d not matched\n",
-                    (uint32_t)expect->entities[i], expect->entity_names[i], i);
-                return false;
-            }
-        }
-    }
-
-    if (expect->table_count_expect) {
-        if (!if_test_assert(expect->table_count_actual == expect->table_count_expect)) {
-            return false;
-        }
-    }
-
-    return true;
-}
diff --git a/test/api/.gitignore b/test/api/.gitignore
deleted file mode 100644
index 335606867..000000000
--- a/test/api/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-.bake_cache
-.DS_Store
-.vscode
-bin
diff --git a/test/api/src/EnabledComponents.c b/test/api/src/EnabledComponents.c
deleted file mode 100644
index 05400fbae..000000000
--- a/test/api/src/EnabledComponents.c
+++ /dev/null
@@ -1,1438 +0,0 @@
-#include <api.h>
-#include <stdlib.h>
-
-void EnabledComponents_is_component_enabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new(world, Position);
-
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_empty_entity_disabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new(world, 0);
-
-    test_bool(ecs_is_enabled_component(world, e, Position), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_0_entity_disabled(void) {
-    install_test_abort();
-
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    test_expect_abort();
-
-    test_bool(ecs_is_enabled_component(world, 0, Position), false);
-}
-
-void EnabledComponents_is_0_component_disabled(void) {
-    install_test_abort();
-    
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new(world, 0);
-
-    test_expect_abort();
-
-    test_bool(ecs_is_enabled_id(world, e, 0), false);
-}
-
-void EnabledComponents_is_nonexist_component_disabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e = ecs_new(world, Velocity);
-
-    test_bool(ecs_is_enabled_component(world, e, Position), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_component_enabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_disabled_component_enabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_enable_component(world, e, Position, false);
-    test_bool(ecs_is_enabled_component(world, e, Position), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_has_enabled_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_enable_component(world, e, Position, true);
-    
-    test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_id(Position)), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_after_add(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_add(world, e, Position);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_id(Position)), true);
-    test_bool(ecs_has(world, e, Position), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_after_remove(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new(world, Position);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_remove(world, e, Position);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_id(Position)), true);
-    test_bool(ecs_has(world, e, Position), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_after_disable(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_enable_component(world, e, Position, false);
-    test_bool(ecs_is_enabled_component(world, e, Position), false);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_disabled_after_enable(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-
-    ecs_enable_component(world, e, Position, false);
-    test_bool(ecs_is_enabled_component(world, e, Position), false);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_enable_component(world, e, Position, false);
-    test_bool(ecs_is_enabled_component(world, e, Position), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_randomized(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t entities[100000];
-    bool enabled[100000];
-
-    int32_t i;
-    for (i = 0; i < 100000; i ++) {
-        enabled[i] = rand() % 2;
-        entities[i] = ecs_new_id(world);
-        ecs_enable_component(world, entities[i], Position, enabled[i]);
-    }
-
-    for (i = 0; i < 100000; i ++) {
-        test_bool(
-            ecs_is_enabled_component(world, entities[i], Position), enabled[i]);
-    }
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_after_add_randomized(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t entities[100000];
-    bool enabled[100000];
-
-    int32_t i;
-    for (i = 0; i < 100000; i ++) {
-        enabled[i] = rand() % 2;
-        entities[i] = ecs_new_id(world);
-        ecs_enable_component(world, entities[i], Position, enabled[i]);
-    }
-
-    for (i = 0; i < 100000; i ++) {
-        ecs_add(world, entities[i], Position);
-    }
-
-    for (i = 0; i < 100000; i ++) {
-        test_bool(
-            ecs_is_enabled_component(world, entities[i], Position), enabled[i]);
-    }
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_after_randomized_add_randomized(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t entities[100000];
-    bool enabled[100000];
-
-    int32_t i;
-    for (i = 0; i < 100000; i ++) {
-        enabled[i] = rand() % 2;
-        entities[i] = ecs_new_id(world);
-        ecs_enable_component(world, entities[i], Position, enabled[i]);
-    }
-
-    for (i = 0; i < 100000; i ++) {
-        if (!(rand() % 5)) {
-            ecs_add(world, entities[i], Position);
-        }
-    }
-
-    for (i = 0; i < 100000; i ++) {
-        test_bool(
-            ecs_is_enabled_component(world, entities[i], Position), enabled[i]);
-    }
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_2(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e = ecs_new(world, 0);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_enable_component(world, e, Velocity, false);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_is_enabled_component(world, e, Velocity), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_3(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_entity_t e = ecs_new(world, 0);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_enable_component(world, e, Velocity, false);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_is_enabled_component(world, e, Velocity), false);
-
-    ecs_enable_component(world, e, Mass, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_is_enabled_component(world, e, Velocity), false);
-    test_bool(ecs_is_enabled_component(world, e, Mass), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_2_after_add(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e = ecs_new(world, 0);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_enable_component(world, e, Velocity, false);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_is_enabled_component(world, e, Velocity), false);
-
-    ecs_add(world, e, Position);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_is_enabled_component(world, e, Velocity), false);    
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_3_after_add(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_entity_t e = ecs_new(world, 0);
-
-    ecs_enable_component(world, e, Position, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_enable_component(world, e, Velocity, false);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_is_enabled_component(world, e, Velocity), false);
-
-    ecs_enable_component(world, e, Mass, true);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_is_enabled_component(world, e, Velocity), false);
-    test_bool(ecs_is_enabled_component(world, e, Mass), true);
-
-    ecs_add(world, e, Position);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    test_bool(ecs_is_enabled_component(world, e, Velocity), false);
-    test_bool(ecs_is_enabled_component(world, e, Mass), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_pair_enabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t obj = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, ecs_id(Position), obj);
-
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_enabled_pair_enabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_disabled_pair_enabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, false);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_has_enabled_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_pair(ecs_id(Position), obj)), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_pair_enabled_after_add(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_add_pair(world, e, ecs_id(Position), obj);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_has_id(world, e, ECS_TOGGLE |  ecs_pair(ecs_id(Position), obj)), true);
-    test_bool(ecs_has_pair(world, e, ecs_id(Position), obj), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_pair_enabled_after_remove(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new(world, Position);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_remove_pair(world, e, ecs_id(Position), obj);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_has_id(world, e, ECS_TOGGLE | ecs_pair(ecs_id(Position), obj)), true);
-    test_bool(ecs_has_pair(world, e, ecs_id(Position), obj), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_pair_enabled_after_disable(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_enable_pair(world, e, Position, obj, false);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), false);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_pair_disabled_after_enable(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, false);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), false);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_enable_pair(world, e, Position, obj, false);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_pair_enabled_2(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e = ecs_new(world, 0);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_enable_pair(world, e, Velocity, obj, false);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_pair_enabled_3(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_entity_t e = ecs_new(world, 0);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_enable_pair(world, e, Velocity, obj, false);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
-
-    ecs_enable_pair(world, e, Mass, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
-    test_bool(ecs_is_enabled_pair(world, e, Mass, obj), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_pair_enabled_2_after_add(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e = ecs_new(world, 0);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_enable_pair(world, e, Velocity, obj, false);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
-
-    ecs_add_pair(world, e, ecs_id(Position), obj);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);    
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_is_pair_enabled_3_after_add(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_entity_t e = ecs_new(world, 0);
-    ecs_entity_t obj = ecs_new_id(world);
-
-    ecs_enable_pair(world, e, Position, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-
-    ecs_enable_pair(world, e, Velocity, obj, false);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
-
-    ecs_enable_pair(world, e, Mass, obj, true);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
-    test_bool(ecs_is_enabled_pair(world, e, Mass, obj), true);
-
-    ecs_add_pair(world, e, ecs_id(Position), obj);
-    test_bool(ecs_is_enabled_pair(world, e, Position, obj), true);
-    test_bool(ecs_is_enabled_pair(world, e, Velocity, obj), false);
-    test_bool(ecs_is_enabled_pair(world, e, Mass, obj), true);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_disabled(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
-
-    ecs_enable_component(world, e1, Position, true);
-    ecs_enable_component(world, e2, Position, false);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t table_count = 0, count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != e2);
-            test_assert(it.entities[i] == e1 || it.entities[i] == e3);
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-        }
-        count += it.count;
-        table_count ++;
-    }
-
-    test_int(count, 2);
-    test_int(table_count, 2);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_disabled_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tgt);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
-    ecs_entity_t e2 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
-    ecs_entity_t e3 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
-
-    ecs_enable_pair(world, e1, Position, Tgt, true);
-    ecs_enable_pair(world, e2, Position, Tgt, false);
-
-    ecs_query_t *q = ecs_query_new(world, "(Position, Tgt)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t table_count = 0, count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != e2);
-            test_assert(it.entities[i] == e1 || it.entities[i] == e3);
-            test_assert(ecs_is_enabled_pair(world, it.entities[i], Position, Tgt));
-        }
-        count += it.count;
-        table_count ++;
-    }
-
-    test_int(count, 2);
-    test_int(table_count, 2);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_disabled_skip_initial(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
-
-    ecs_enable_component(world, e1, Position, false);
-    ecs_enable_component(world, e2, Position, true);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != e1);
-            test_assert(it.entities[i] == e2 || it.entities[i] == e3);
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-        }
-        count += it.count;
-    }
-
-    test_int(count, 2);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_disabled_pair_skip_initial(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tgt);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
-    ecs_entity_t e2 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
-    ecs_entity_t e3 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
-
-    ecs_enable_pair(world, e1, Position, Tgt, false);
-    ecs_enable_pair(world, e2, Position, Tgt, true);
-
-    ecs_query_t *q = ecs_query_new(world, "(Position, Tgt)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] != e1);
-            test_assert(it.entities[i] == e2 || it.entities[i] == e3);
-            test_assert(ecs_is_enabled_pair(world, it.entities[i], Position, Tgt));
-        }
-        count += it.count;
-    }
-
-    test_int(count, 2);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_2(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 64; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        if (!(e % 2)) {
-            ecs_enable_component(world, e, Position, false);
-        } else {
-            ecs_enable_component(world, e, Position, true);
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] % 2);
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_8(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        if (!(e % 8)) {
-            ecs_enable_component(world, e, Position, false);
-        } else {
-            ecs_enable_component(world, e, Position, true);
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] % 8);
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_64(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        if (!(e % 64)) {
-            ecs_enable_component(world, e, Position, false);
-        } else {
-            ecs_enable_component(world, e, Position, true);
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] % 64);
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_256(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        if (!(e % 256)) {
-            ecs_enable_component(world, e, Position, false);
-        } else {
-            ecs_enable_component(world, e, Position, true);
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] % 256);
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_1024(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 100000; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        if (!(e % 1024)) {
-            ecs_enable_component(world, e, Position, false);
-        } else {
-            ecs_enable_component(world, e, Position, true);
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] % 1024);
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_enable_mod_10(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        if (!(e % 10)) {
-            ecs_enable_component(world, e, Position, true);
-            total_count ++;
-        } else {
-            ecs_enable_component(world, e, Position, false);
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(!(it.entities[i] % 10));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_2_2_bitsets(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        ecs_add(world, e, Velocity);
-        if (!(e % 2)) {
-            ecs_enable_component(world, e, Position, true);
-        } else {
-            ecs_enable_component(world, e, Position, false);
-        }
-        
-        if (!(e % 3)) {
-            ecs_enable_component(world, e, Velocity, true);
-        } else {
-            ecs_enable_component(world, e, Velocity, false);
-        }        
-
-        if (!(e % 2) && !(e % 3)) {
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
-            test_assert(!(it.entities[i] % 2) && !(it.entities[i] % 3));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_8_2_bitsets(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        ecs_add(world, e, Velocity);
-        if (!(e % 8)) {
-            ecs_enable_component(world, e, Position, true);
-        } else {
-            ecs_enable_component(world, e, Position, false);
-        }
-        
-        if (!(e % 4)) {
-            ecs_enable_component(world, e, Velocity, true);
-        } else {
-            ecs_enable_component(world, e, Velocity, false);
-        }        
-
-        if (!(e % 8) && !(e % 4)) {
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
-            test_assert(!(it.entities[i] % 8) && !(it.entities[i] % 4));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_64_2_bitsets(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        ecs_add(world, e, Velocity);
-        if (!(e % 64)) {
-            ecs_enable_component(world, e, Position, true);
-        } else {
-            ecs_enable_component(world, e, Position, false);
-        }
-        
-        if (!(e % 16)) {
-            ecs_enable_component(world, e, Velocity, true);
-        } else {
-            ecs_enable_component(world, e, Velocity, false);
-        }        
-
-        if (!(e % 64) && !(e % 16)) {
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
-            test_assert(!(it.entities[i] % 64) && !(it.entities[i] % 16));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_256_2_bitsets(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        ecs_add(world, e, Velocity);
-        if (!(e % 256)) {
-            ecs_enable_component(world, e, Position, true);
-        } else {
-            ecs_enable_component(world, e, Position, false);
-        }
-        
-        if (!(e % 64)) {
-            ecs_enable_component(world, e, Velocity, true);
-        } else {
-            ecs_enable_component(world, e, Velocity, false);
-        }        
-
-        if (!(e % 256) && !(e % 64)) {
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
-            test_assert(!(it.entities[i] % 256) && !(it.entities[i] % 64));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_mod_1024_2_bitsets(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        ecs_add(world, e, Velocity);
-        if (!(e % 1024)) {
-            ecs_enable_component(world, e, Position, true);
-        } else {
-            ecs_enable_component(world, e, Position, false);
-        }
-        
-        if (!(e % 128)) {
-            ecs_enable_component(world, e, Velocity, true);
-        } else {
-            ecs_enable_component(world, e, Velocity, false);
-        }        
-
-        if (!(e % 1024) && !(e % 128)) {
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
-            test_assert(!(it.entities[i] % 1024) && !(it.entities[i] % 128));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_randomized_2_bitsets(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        ecs_add(world, e, Velocity);
-
-        bool enable_1 = rand() % 2;
-        ecs_enable_component(world, e, Position, enable_1);
-        bool enable_2 = rand() % 2;
-        ecs_enable_component(world, e, Velocity, enable_2);
-        
-        if (enable_1 && enable_2) {
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_randomized_3_bitsets(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        ecs_add(world, e, Velocity);
-        ecs_add(world, e, Mass);
-
-        bool enable_1 = rand() % 2;
-        ecs_enable_component(world, e, Position, enable_1);
-        bool enable_2 = rand() % 2;
-        ecs_enable_component(world, e, Velocity, enable_2);
-        bool enable_3 = rand() % 2;
-        ecs_enable_component(world, e, Mass, enable_3);        
-
-        if (enable_1 && enable_2 && enable_3) {
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity, Mass");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Mass));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_query_randomized_4_bitsets(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-    ECS_COMPONENT(world, Rotation);
-
-    int32_t i, total_count = 0;
-    for (i = 0; i < 65536; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
-        ecs_add(world, e, Velocity);
-        ecs_add(world, e, Mass);
-        ecs_add(world, e, Rotation);
-
-        bool enable_1 = rand() % 2;
-        ecs_enable_component(world, e, Position, enable_1);
-        bool enable_2 = rand() % 2;
-        ecs_enable_component(world, e, Velocity, enable_2);
-        bool enable_3 = rand() % 2;
-        ecs_enable_component(world, e, Mass, enable_3);        
-        bool enable_4 = rand() % 2;
-        ecs_enable_component(world, e, Rotation, enable_4); 
-
-        if (enable_1 && enable_2 && enable_3 && enable_4) {
-            total_count ++;
-        }
-    }
-
-    test_assert(total_count != 0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity, Mass, Rotation");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Position));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Velocity));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Mass));
-            test_assert(ecs_is_enabled_component(world, it.entities[i], Rotation));
-        }
-        count += it.count;
-    }
-
-    test_int(count, total_count);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_defer_enable(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new(world, Position);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-
-    ecs_defer_begin(world);
-    ecs_enable_component(world, e, Position, false);
-    test_bool(ecs_is_enabled_component(world, e, Position), true);
-    ecs_defer_end(world);
-
-    test_bool(ecs_is_enabled_component(world, e, Position), false);
-
-    ecs_fini(world);
-}
-
-static
-int compare_position(ecs_entity_t e1, const void *ptr1, ecs_entity_t e2, const void *ptr2) {
-    const Position *p1 = ptr1;
-    const Position *p2 = ptr2;
-    return (p1->x > p2->x) - (p1->x < p2->x);
-}
-
-void EnabledComponents_sort(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 2});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {2, 2});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {0, 2});
-
-    ecs_enable_component(world, e1, Position, true);
-    ecs_enable_component(world, e2, Position, true);
-    ecs_enable_component(world, e3, Position, false);
-    ecs_enable_component(world, e4, Position, false);
-
-    test_bool(ecs_is_enabled_component(world, e1, Position), true);
-    test_bool(ecs_is_enabled_component(world, e2, Position), true);
-    test_bool(ecs_is_enabled_component(world, e3, Position), false);
-    test_bool(ecs_is_enabled_component(world, e4, Position), false);
-    
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 2);
-    test_assert(it.entities[0] == e2);
-    test_assert(it.entities[1] == e1);
-    test_assert(!ecs_query_next(&it));
-
-    /* Entities will have shuffled around, ensure bits got shuffled too */
-    test_bool(ecs_is_enabled_component(world, e1, Position), true);
-    test_bool(ecs_is_enabled_component(world, e2, Position), true);
-    test_bool(ecs_is_enabled_component(world, e3, Position), false);
-    test_bool(ecs_is_enabled_component(world, e4, Position), false);
-
-    ecs_fini(world);
-}
-
-void EnabledComponents_table_move_2_from_3(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query(world, { .filter.expr = "Position" });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_enable_component(world, e1, Position, true);
-    ecs_enable_component(world, e2, Position, false);
-    ecs_enable_component(world, e3, Position, true);
-
-    test_bool(ecs_is_enabled_component(world, e1, Position), true);
-    test_bool(ecs_is_enabled_component(world, e2, Position), false);
-    test_bool(ecs_is_enabled_component(world, e3, Position), true);
-
-    ecs_add(world, e3, Tag);
-    ecs_add(world, e2, Tag);
-    
-    test_bool(ecs_is_enabled_component(world, e1, Position), true);
-    test_bool(ecs_is_enabled_component(world, e2, Position), false);
-    test_bool(ecs_is_enabled_component(world, e3, Position), true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(true, ecs_query_next(&it));
-        test_int(1, it.count);
-        test_uint(e1, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 10); test_int(p->y, 20);
-    }
-    {
-        test_bool(true, ecs_query_next(&it));
-        test_int(1, it.count);
-        test_uint(e3, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 30); test_int(p->y, 40);
-    }
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
diff --git a/test/api/src/FilterStr.c b/test/api/src/FilterStr.c
deleted file mode 100644
index 3c3ade80f..000000000
--- a/test/api/src/FilterStr.c
+++ /dev/null
@@ -1,632 +0,0 @@
-#include <api.h>
-
-void FilterStr_one_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ TagA }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "TagA");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_inout(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {
-            { TagA, .inout = EcsIn }
-        }
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "[in] TagA");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_two_terms(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {
-            { TagA },
-            { TagB }
-        }
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "TagA, TagB");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_two_terms_w_inout(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {
-            { TagA },
-            { TagB, .inout = EcsIn }
-        }
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "TagA, [in] TagB");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_three_terms_w_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {
-            { TagA },
-            { TagB, .oper = EcsOr },
-            { TagC }
-        }
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "TagA, TagB || TagC");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_three_terms_w_or_inout(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {
-            { TagA },
-            { TagB, .oper = EcsOr, .inout = EcsIn },
-            { TagC, .inout = EcsIn }
-        }
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "TagA, [in] TagB || TagC");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_four_terms_three_w_or_inout(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, TagD);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {
-            { TagA },
-            { TagB, .oper = EcsOr, .inout = EcsIn },
-            { TagC, .inout = EcsIn },
-            { TagD, .inout = EcsIn }
-        }
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "TagA, [in] TagB || TagC, [in] TagD");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .id = ecs_pair(Rel, Tgt) }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "(Rel,Tgt)");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_pair_entity_src(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Src);
-    ECS_TAG(world, Tgt);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .id = ecs_pair(Rel, Tgt), .src.id = Src }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "Rel(Src,Tgt)");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_self(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .id = Foo, .src.flags = EcsSelf }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "Foo(self)");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_up(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .id = Foo, .src.flags = EcsUp }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "Foo(up)");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_0(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .id = Foo, .src.flags = EcsIsEntity }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "Foo()");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .id = Foo, .src.id = Foo }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "Foo($)");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_final_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Foo, Final);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .first.id = Foo }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "Foo");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_final_dont_inherit_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Foo, Final, DontInherit);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .first.id = Foo }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "Foo");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_src_var(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ Tag, .src.flags = EcsIsVariable, .src.name = "Var" }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "Tag($Var)");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_first_var(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .first.flags = EcsIsVariable, .first.name = "Var" }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "[none] $Var");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_second_var(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .first.id = Rel, .second.flags = EcsIsVariable, .second.name = "Var" }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "(Rel,$Var)");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_first_var_entity_src(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Src);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ .first.flags = EcsIsVariable, .first.name = "Var", .src.id = Src }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "[none] $Var(Src)");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_one_term_w_pair_w_0_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {
-            { .first.id = Rel, .second.id = Tgt, .src = {
-                .id = 0, .flags = EcsIsEntity
-            } }
-        }
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "Rel(0,Tgt)");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_not_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ TagA, .oper = EcsNot }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "!TagA");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_wildcard_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ EcsWildcard }}
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "[none] *");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_scopes(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "TagA, {TagB, {TagC}}"
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "TagA, {TagB, {TagC}}");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_pred_eq(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$this == TagA"
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "$this == TagA");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_pred_neq(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$this != TagA"
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "$this != TagA");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_pred_eq_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$this == \"TagA\""
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "$this == \"TagA\"");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_pred_neq_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$this != \"TagA\""
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "$this != \"TagA\"");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_pred_eq_m(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$this ~= \"TagA\""
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "$this ~= \"TagA\"");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void FilterStr_pred_neq_m(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$this ~= \"!TagA\""
-    }));
-
-    char *str = ecs_filter_str(world, &f);
-    test_str(str, "$this ~= \"!TagA\"");
-    ecs_os_free(str);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
diff --git a/test/api/src/FixedHierarchies.c b/test/api/src/FixedHierarchies.c
deleted file mode 100644
index fbc7a9dcc..000000000
--- a/test/api/src/FixedHierarchies.c
+++ /dev/null
@@ -1,3961 +0,0 @@
-#include <api.h>
-
-void FixedHierarchies_make_fixed_1_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_1_lvl_w_init(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_1_lvl_w_init_comp(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor
-    });
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1_1, Position, {10, 20});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2_1, Position, {30, 40});
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-
-    {
-        const Position *p = ecs_get(world, p_1_1, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-    {
-        const Position *p = ecs_get(world, p_2_1, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 30);
-        test_int(p->y, 40);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_1_lvl_w_init_comp_after_tree_fixed(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor
-    });
-
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1_1, Position, {10, 20});
-    ecs_set_pair_second(world, p_1_1, rel, Position, {100, 200});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2_1, Position, {30, 40});
-    ecs_set_pair_second(world, p_2_1, rel, Position, {300, 400});
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-
-    {
-        const Position *p = ecs_get(world, p_1_1, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-    {
-        const Position *p = ecs_get(world, p_2_1, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 30);
-        test_int(p->y, 40);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_1_lvl_2_entities(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_2 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_2 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_1_2));
-    test_assert(ecs_get_table(world, p_2_1) == ecs_get_table(world, p_2_2));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_2, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_2, EcsChildOf, 0) == p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_1_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_2));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_2, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_2, EcsChildOf, 0) == p_2);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_1_lvl_2_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_2 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_add(world, p_1_2, Tag);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_2 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_add(world, p_2_2, Tag);
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_2) != ecs_get_table(world, p_2_2));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_2, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_2, EcsChildOf, 0) == p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_2) == ecs_get_table(world, p_2_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_1_2));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_2, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_2, EcsChildOf, 0) == p_2);
-
-    test_assert(ecs_has(world, p_1_2, Tag));
-    test_assert(ecs_has(world, p_2_2, Tag));
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_2_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_2_lvl_2_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_entity_t p_1_1_2 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_add(world, p_1_1_2, Tag);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_entity_t p_2_1_2 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_add(world, p_2_1_2, Tag);
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_1_1_2));
-    test_assert(ecs_get_table(world, p_2_1_1) != ecs_get_table(world, p_2_1_2));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_2) == ecs_get_table(world, p_2_1_2));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_1_1_2));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-
-    test_assert(ecs_has(world, p_1_1_2, Tag));
-    test_assert(ecs_has(world, p_2_1_2, Tag));
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_3_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_entity_t p_1_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_entity_t p_2_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1_1);
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_3_lvl_w_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_1_1_1 = ecs_new_entity(world, "p._1._1._1");
-    ecs_entity_t p_1_1_1_1 = ecs_new_entity(world, "p._1._1._1._1");
-
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-    ecs_entity_t p_2_1_1 = ecs_new_entity(world, "p._2._1._1");
-    ecs_entity_t p_2_1_1_1 = ecs_new_entity(world, "p._2._1._1._1");
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_3_2_lvl_w_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_1_1_1 = ecs_new_entity(world, "p._1._1._1");
-    ecs_entity_t p_1_1_1_1 = ecs_new_entity(world, "p._1._1._1._1");
-    ecs_entity_t p_1_1_2 = ecs_new_entity(world, "p._1._1._2");
-    ecs_entity_t p_1_1_2_1 = ecs_new_entity(world, "p._1._1._2._1");
-
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-    ecs_entity_t p_2_1_1 = ecs_new_entity(world, "p._2._1._1");
-    ecs_entity_t p_2_1_1_1 = ecs_new_entity(world, "p._2._1._1._1");
-    ecs_entity_t p_2_1_2 = ecs_new_entity(world, "p._2._1._2");
-    ecs_entity_t p_2_1_2_1 = ecs_new_entity(world, "p._2._1._2._1");
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1_1) != ecs_get_table(world, p_1_1_2_1));
-    test_assert(ecs_get_table(world, p_2_1_1_1) != ecs_get_table(world, p_2_1_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2_1, EcsChildOf, 0) == p_1_1_2);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_2, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-    test_assert(ecs_get_target(world, p_2_1_2_1, EcsChildOf, 0) == p_2_1_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1_1) == ecs_get_table(world, p_1_1_2_1));
-    test_assert(ecs_get_table(world, p_2_1_1_1) == ecs_get_table(world, p_2_1_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2_1, EcsChildOf, 0) == p_1_1_2);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_2, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-    test_assert(ecs_get_target(world, p_2_1_2_1, EcsChildOf, 0) == p_2_1_2);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_2_lvl_nested(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_1_1_1 = ecs_new_entity(world, "p._1._1._1");
-    ecs_entity_t p_1_1_2 = ecs_new_entity(world, "p._1._1._2");
-    ecs_entity_t p_1_2 = ecs_new_entity(world, "p._1._2");
-    ecs_entity_t p_1_2_1 = ecs_new_entity(world, "p._1._2._1");
-    ecs_entity_t p_1_2_2 = ecs_new_entity(world, "p._1._2._2");
-
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-    ecs_entity_t p_2_1_1 = ecs_new_entity(world, "p._2._1._1");
-    ecs_entity_t p_2_1_2 = ecs_new_entity(world, "p._2._1._2");
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_1_2));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_table(world, p_1_2_2) == ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_2, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_2_1, EcsChildOf, 0) == p_1_2);
-    test_assert(ecs_get_target(world, p_1_2_2, EcsChildOf, 0) == p_1_2);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_2, EcsChildOf, 0) == p_2_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p_1), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_1_2));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_table(world, p_1_2_2) == ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_2, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_2_1, EcsChildOf, 0) == p_1_2);
-    test_assert(ecs_get_target(world, p_1_2_2, EcsChildOf, 0) == p_1_2);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_2, EcsChildOf, 0) == p_2_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_1_2));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_table(world, p_1_2_2) == ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_2, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_2_1, EcsChildOf, 0) == p_1_2);
-    test_assert(ecs_get_target(world, p_1_2_2, EcsChildOf, 0) == p_1_2);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_2, EcsChildOf, 0) == p_2_1);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_3_lvl_nested(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_1_1_1 = ecs_new_entity(world, "p._1._1._1");
-    ecs_entity_t p_1_1_1_1 = ecs_new_entity(world, "p._1._1._1._1");
-    ecs_entity_t p_1_1_2 = ecs_new_entity(world, "p._1._1._2");
-    ecs_entity_t p_1_1_2_1 = ecs_new_entity(world, "p._1._1._2._1");
-
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-    ecs_entity_t p_2_1_1 = ecs_new_entity(world, "p._2._1._1");
-    ecs_entity_t p_2_1_1_1 = ecs_new_entity(world, "p._2._1._1._1");
-    ecs_entity_t p_2_1_2 = ecs_new_entity(world, "p._2._1._2");
-    ecs_entity_t p_2_1_2_1 = ecs_new_entity(world, "p._2._1._2._1");
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1_1) != ecs_get_table(world, p_1_1_2_1));
-    test_assert(ecs_get_table(world, p_2_1_1_1) != ecs_get_table(world, p_2_1_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2_1, EcsChildOf, 0) == p_1_1_2);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_2, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-    test_assert(ecs_get_target(world, p_2_1_2_1, EcsChildOf, 0) == p_2_1_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p_1_1), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1_1) == ecs_get_table(world, p_1_1_2_1));
-    test_assert(ecs_get_table(world, p_2_1_1_1) != ecs_get_table(world, p_2_1_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2_1, EcsChildOf, 0) == p_1_1_2);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_2, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-    test_assert(ecs_get_target(world, p_2_1_2_1, EcsChildOf, 0) == p_2_1_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1_1) == ecs_get_table(world, p_1_1_2_1));
-    test_assert(ecs_get_table(world, p_2_1_1_1) == ecs_get_table(world, p_2_1_2_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_1_1_2_1, EcsChildOf, 0) == p_1_1_2);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_2, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-    test_assert(ecs_get_target(world, p_2_1_2_1, EcsChildOf, 0) == p_2_1_2);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_1_lvl_after_delete(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_2 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_3 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_4 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_delete(world, p_1_3);
-    ecs_delete(world, p_1_4);
-
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_2, EcsChildOf, 0) == p_1);
-    test_assert(!ecs_is_alive(world, p_1_3));
-    test_assert(!ecs_is_alive(world, p_1_4));
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_2, EcsChildOf, 0) == p_1);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_get_target_1_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_uint(ecs_get_target(world, p, EcsChildOf, 0), 0);
-    test_uint(ecs_get_target(world, p_1, EcsChildOf, 0), p);
-    test_uint(ecs_get_target(world, p_2, EcsChildOf, 0), p);
-
-    test_uint(ecs_get_target(world, p_1_1, EcsChildOf, 0), p_1);
-    test_uint(ecs_get_target(world, p_2_1, EcsChildOf, 0), p_2);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_get_target_2_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_uint(ecs_get_target(world, p, EcsChildOf, 0), 0);
-    test_uint(ecs_get_target(world, p_1, EcsChildOf, 0), p);
-    test_uint(ecs_get_target(world, p_2, EcsChildOf, 0), p);
-
-    test_uint(ecs_get_target(world, p_1_1, EcsChildOf, 0), p_1);
-    test_uint(ecs_get_target(world, p_2_1, EcsChildOf, 0), p_2);
-
-    test_uint(ecs_get_target(world, p_1_1_1, EcsChildOf, 0), p_1_1);
-    test_uint(ecs_get_target(world, p_2_1_1, EcsChildOf, 0), p_2_1);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_get_depth_1_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_int(ecs_get_depth(world, p, EcsChildOf), 0);
-
-    test_int(ecs_get_depth(world, p_1, EcsChildOf), 1);
-    test_int(ecs_get_depth(world, p_2, EcsChildOf), 1);
-
-    test_int(ecs_get_depth(world, p_1_1, EcsChildOf), 2);
-    test_int(ecs_get_depth(world, p_2_1, EcsChildOf), 2);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_get_depth_2_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_int(ecs_get_depth(world, p, EcsChildOf), 0);
-
-    test_int(ecs_get_depth(world, p_1, EcsChildOf), 1);
-    test_int(ecs_get_depth(world, p_2, EcsChildOf), 1);
-
-    test_int(ecs_get_depth(world, p_1_1, EcsChildOf), 2);
-    test_int(ecs_get_depth(world, p_2_1, EcsChildOf), 2);
-
-    test_int(ecs_get_depth(world, p_1_1_1, EcsChildOf), 3);
-    test_int(ecs_get_depth(world, p_2_1_1, EcsChildOf), 3);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_get_depth_after_reparent_root(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_int(ecs_get_depth(world, p, EcsChildOf), 0);
-
-    test_int(ecs_get_depth(world, p_1, EcsChildOf), 1);
-    test_int(ecs_get_depth(world, p_2, EcsChildOf), 1);
-
-    test_int(ecs_get_depth(world, p_1_1, EcsChildOf), 2);
-    test_int(ecs_get_depth(world, p_2_1, EcsChildOf), 2);
-
-    ecs_entity_t gp = ecs_new_id(world);
-    ecs_add_pair(world, p, EcsChildOf, gp);
-
-    test_int(ecs_get_depth(world, p, EcsChildOf), 1);
-
-    test_int(ecs_get_depth(world, p_1, EcsChildOf), 2);
-    test_int(ecs_get_depth(world, p_2, EcsChildOf), 2);
-
-    test_int(ecs_get_depth(world, p_1_1, EcsChildOf), 3);
-    test_int(ecs_get_depth(world, p_2_1, EcsChildOf), 3);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_delete_fixed_1_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_delete(world, p);
-
-    test_assert(!ecs_is_alive(world, p_1));
-    test_assert(!ecs_is_alive(world, p_1_1));
-    test_assert(!ecs_is_alive(world, p_2));
-    test_assert(!ecs_is_alive(world, p_2_1));
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_delete_fixed_2_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_delete(world, p);
-
-    test_assert(!ecs_is_alive(world, p_1));
-    test_assert(!ecs_is_alive(world, p_1_1));
-    test_assert(!ecs_is_alive(world, p_1_1_1));
-    test_assert(!ecs_is_alive(world, p_2));
-    test_assert(!ecs_is_alive(world, p_2_1));
-    test_assert(!ecs_is_alive(world, p_2_1_1));
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_delete_with_fixed_1_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_delete_with(world, ecs_pair(EcsChildOf, p));
-
-    test_assert(!ecs_is_alive(world, p_1));
-    test_assert(!ecs_is_alive(world, p_1_1));
-    test_assert(!ecs_is_alive(world, p_2));
-    test_assert(!ecs_is_alive(world, p_2_1));
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_delete_with_fixed_2_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_delete_with(world, ecs_pair(EcsChildOf, p));
-
-    test_assert(!ecs_is_alive(world, p_1));
-    test_assert(!ecs_is_alive(world, p_1_1));
-    test_assert(!ecs_is_alive(world, p_1_1_1));
-    test_assert(!ecs_is_alive(world, p_2));
-    test_assert(!ecs_is_alive(world, p_2_1));
-    test_assert(!ecs_is_alive(world, p_2_1_1));
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_1_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_1_lvl_w_init(void) {
-    ecs_world_t *world = ecs_init(); /* Registers metadata/ctor for TreeFixed */
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_1_lvl_w_init_comp_after_tree_fixed(void) {
-    ecs_world_t *world = ecs_init(); /* Registers metadata/ctor for TreeFixed */
-
-    ECS_COMPONENT(world, Position);
-    ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor
-    });
-
-    ecs_entity_t rel = ecs_new_id(world);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set_pair_second(world, p_1_1, rel, Position, {1115, 2115});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    ecs_set_pair_second(world, p_2_1, rel, Position, {1215, 2215});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_pair(rel, ecs_id(Position)) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(0, it.sources[1]);
-        test_uint(p_1, it.sources[2]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *rp = ecs_field(&it, Position, 2);
-        test_int(rp[0].x, 1115); test_int(rp[0].y, 2115);
-
-        Position *pp = ecs_field(&it, Position, 3);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(0, it.sources[1]);
-        test_uint(p_2, it.sources[2]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *rp = ecs_field(&it, Position, 2);
-        test_int(rp[0].x, 1215); test_int(rp[0].y, 2215);
-
-        Position *pp = ecs_field(&it, Position, 3);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_2_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_1_1, Position, {1111, 2111});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    ecs_set(world, p_2_1_1, Position, {1211, 2211});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1111); test_int(p[0].y, 2111);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 111); test_int(pp[0].y, 211);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1211); test_int(p[0].y, 2211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 121); test_int(pp[0].y, 221);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_cascade_field_2_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_1_1, Position, {1111, 2111});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    ecs_set(world, p_2_1_1, Position, {1211, 2211});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent|EcsCascade },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1111); test_int(p[0].y, 2111);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 111); test_int(pp[0].y, 211);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1211); test_int(p[0].y, 2211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 121); test_int(pp[0].y, 221);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_1_fixed_1_regular(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-    ecs_set(world, p, Velocity, {3, 4});
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-            { .id = ecs_id(Velocity), .src.flags = EcsParent }
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_only_fixed_1_lvls(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_assert(pp != NULL);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_assert(pp != NULL);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_fixed_1_lvls_no_match(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), false);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_fixed_1_lvls_2_no_match(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_fixed_1_lvls_no_match_match(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_assert(pp != NULL);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_fixed_1_lvls_match_no_match(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_assert(p != NULL);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_assert(pp != NULL);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_field_2_fixed_2_lvls(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-    ecs_set(world, p, Velocity, {3, 4});
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1, Mass, {5});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_1_1, Position, {1111, 2111});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2, Mass, {6});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    ecs_set(world, p_2_1_1, Position, {1211, 2211});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-            { .id = ecs_id(Velocity), .src.flags = EcsParent },
-            { .id = ecs_id(Mass), .src.flags = EcsSelf|EcsParent }
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        test_uint(0, it.sources[3]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-        Mass *mp = ecs_field(&it, Mass, 4);
-        test_int(mp[0], 5);
-        test_int(mp[1], 6);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_1, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        test_uint(p_1, it.sources[3]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1111); test_int(p[0].y, 2111);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 111); test_int(pp[0].y, 211);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-        Mass *mp = ecs_field(&it, Mass, 4);
-        test_int(mp[0], 5);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2_1, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        test_uint(p_2, it.sources[3]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1211); test_int(p[0].y, 2211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 121); test_int(pp[0].y, 221);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-        Mass *mp = ecs_field(&it, Mass, 4);
-        test_int(mp[0], 6);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        test_uint(p_1, it.sources[3]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-        Mass *mp = ecs_field(&it, Mass, 4);
-        test_int(mp[0], 5);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        test_uint(p_2, it.sources[3]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-        Mass *mp = ecs_field(&it, Mass, 4);
-        test_int(mp[0], 6);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_next_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next_table(&it), true);
-        test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next_table(&it), true);
-        test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    test_bool(ecs_query_next_table(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_next_table_1_elem(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next_table(&it), true);
-        test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-        test_uint(1, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next_table(&it), true);
-        test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    test_bool(ecs_query_next_table(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_next_table_1_elem_no_match(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next_table(&it), true);
-        test_assert(ecs_query_populate(&it, false) == EcsIterNext);
-        test_uint(0, it.count);
-    }
-    test_bool(ecs_query_next_table(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_nested_make_fixed(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent|EcsCascade },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_1_2 = ecs_new_entity(world, "p._1._2");
-
-    ecs_set(world, p, Position, {1, 2});
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_2, Position, {112, 212});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p_1), NULL);
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next_table(&it), true);
-        test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-        test_uint(1, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next_table(&it), true);
-        test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-        test_uint(2, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(p_1_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-        test_int(p[1].x, 112); test_int(p[1].y, 212);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    test_bool(ecs_query_next_table(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_nested_make_fixed_w_optional(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .oper = EcsOptional, .src.flags = EcsParent|EcsCascade },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_1_2 = ecs_new_entity(world, "p._1._2");
-
-    ecs_set(world, p, Position, {1, 2});
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_2, Position, {112, 212});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p_1), NULL);
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(0, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1); test_int(p[0].y, 2);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_assert(pp == NULL);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(p_1_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-        test_int(p[1].x, 112); test_int(p[1].y, 212);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_nested_make_fixed_w_optional_match_children_only(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .oper = EcsOptional, .src.flags = EcsParent|EcsCascade },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_1_2 = ecs_new_entity(world, "p._1._2");
-
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_2, Position, {112, 212});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p_1), NULL);
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(p_1_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(0, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-        test_int(p[1].x, 112); test_int(p[1].y, 212);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_assert(pp == NULL);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_nested_w_2_parents_make_fixed(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .oper = EcsOptional, .src.flags = EcsParent|EcsCascade },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_1_1_1 = ecs_new_entity(world, "p._1._1._1");
-    ecs_entity_t p_1_2 = ecs_new_entity(world, "p._1._2");
-    ecs_entity_t p_1_2_1 = ecs_new_entity(world, "p._1._2._1");
-    ecs_entity_t p_1_2_2 = ecs_new_entity(world, "p._1._2._2");
-
-    ecs_set(world, p, Position, {1, 2});
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_1_1, Position, {1111, 2111});
-    ecs_set(world, p_1_2, Position, {112, 212});
-    ecs_set(world, p_1_2_1, Position, {1121, 2121});
-    ecs_set(world, p_1_2_2, Position, {1122, 2122});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p_1), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_2));
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_2));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(0, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1); test_int(p[0].y, 2);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_assert(pp == NULL);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(p_1_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-        test_int(p[1].x, 112); test_int(p[1].y, 212);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1111); test_int(p[0].y, 2111);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 111); test_int(pp[0].y, 211);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1_2_1, it.entities[0]);
-        test_uint(p_1_2_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1121); test_int(p[0].y, 2121);
-        test_int(p[1].x, 1122); test_int(p[1].y, 2122);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 112); test_int(pp[0].y, 212);
-    }
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_table_w_3_parents(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .oper = EcsOptional, .src.flags = EcsParent|EcsCascade },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_1_1_1 = ecs_new_entity(world, "p._1._1._1");
-    ecs_entity_t p_1_1_2 = ecs_new_entity(world, "p._1._1._2");
-    ecs_entity_t p_1_1_3 = ecs_new_entity(world, "p._1._1._3");
-    ecs_entity_t p_1_2 = ecs_new_entity(world, "p._1._2");
-    ecs_entity_t p_1_2_1 = ecs_new_entity(world, "p._1._2._1");
-    ecs_entity_t p_1_2_2 = ecs_new_entity(world, "p._1._2._2");
-    ecs_entity_t p_1_3 = ecs_new_entity(world, "p._1._3");
-    ecs_entity_t p_1_3_1 = ecs_new_entity(world, "p._1._3._1");
-
-    ecs_set(world, p, Position, {1, 2});
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_1_1, Position, {1111, 2111});
-    ecs_set(world, p_1_1_2, Position, {1112, 2112});
-    ecs_set(world, p_1_1_3, Position, {1113, 2113});
-    ecs_set(world, p_1_2, Position, {112, 212});
-    ecs_set(world, p_1_2_1, Position, {1121, 2121});
-    ecs_set(world, p_1_2_2, Position, {1122, 2122});
-    ecs_set(world, p_1_3, Position, {113, 213});
-    ecs_set(world, p_1_3_1, Position, {1131, 2131});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p_1), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_2));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_3_1));
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_2_2));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_3_1));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(0, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1); test_int(p[0].y, 2);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_assert(pp == NULL);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(3, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(p_1_2, it.entities[1]);
-        test_uint(p_1_3, it.entities[2]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-        test_int(p[1].x, 112); test_int(p[1].y, 212);
-        test_int(p[2].x, 113); test_int(p[2].y, 213);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(3, it.count);
-        test_uint(p_1_1_1, it.entities[0]);
-        test_uint(p_1_1_2, it.entities[1]);
-        test_uint(p_1_1_3, it.entities[2]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1111); test_int(p[0].y, 2111);
-        test_int(p[1].x, 1112); test_int(p[1].y, 2112);
-        test_int(p[2].x, 1113); test_int(p[2].y, 2113);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 111); test_int(pp[0].y, 211);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1_2_1, it.entities[0]);
-        test_uint(p_1_2_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1121); test_int(p[0].y, 2121);
-        test_int(p[1].x, 1122); test_int(p[1].y, 2122);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 112); test_int(pp[0].y, 212);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_3_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_3, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1131); test_int(p[0].y, 2131);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 113); test_int(pp[0].y, 213);
-    }
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_change_detection_1st(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ 
-                .id = ecs_id(Position), 
-                .inout = EcsIn
-            },
-            { 
-                .id = ecs_id(Position), 
-                .src.flags = EcsParent|EcsCascade,
-                .inout = EcsIn
-            },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    
-    // offset the column of Position to verify change detection is testing
-    // againt the right one.
-    ecs_add(world, p_2, Velocity); 
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 11); test_int(pp->y, 21);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_1, Position, {22, 42});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 22); test_int(pp->y, 42);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), false);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_change_detection_2nd(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ 
-                .id = ecs_id(Position), 
-                .inout = EcsIn
-            },
-            { 
-                .id = ecs_id(Position), 
-                .src.flags = EcsParent|EcsCascade,
-                .inout = EcsIn
-            },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    
-    // offset the column of Position to verify change detection is testing
-    // againt the right one.
-    ecs_add(world, p_2, Velocity); 
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 11); test_int(pp->y, 21);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_2, Position, {24, 44});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), false);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 11); test_int(pp->y, 21);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 24); test_int(pp->y, 44);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_change_detection_iter_twice(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ 
-                .id = ecs_id(Position), 
-                .inout = EcsIn
-            },
-            { 
-                .id = ecs_id(Position), 
-                .src.flags = EcsParent|EcsCascade,
-                .inout = EcsIn
-            },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    
-    // offset the column of Position to verify change detection is testing
-    // againt the right one.
-    ecs_add(world, p_2, Velocity); 
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 11); test_int(pp->y, 21);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_1, Position, {22, 42});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 22); test_int(pp->y, 42);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), false);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), false);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 22); test_int(pp->y, 42);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), false);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_change_detection_iter_twice_each_parent(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ 
-                .id = ecs_id(Position), 
-                .inout = EcsIn
-            },
-            { 
-                .id = ecs_id(Position), 
-                .src.flags = EcsParent|EcsCascade,
-                .inout = EcsIn
-            },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    
-    // offset the column of Position to verify change detection is testing
-    // againt the right one.
-    ecs_add(world, p_2, Velocity); 
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 11); test_int(pp->y, 21);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_1, Position, {22, 42});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 22); test_int(pp->y, 42);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), false);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_2, Position, {24, 44});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, false) == EcsIterYield);
-            test_bool(ecs_query_changed(NULL, &it), false);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 22); test_int(pp->y, 42);
-        }
-        {
-            test_assert(ecs_query_populate(&it, false) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 24); test_int(pp->y, 44);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_change_detection_1st_populate_when_changed(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ 
-                .id = ecs_id(Position), 
-                .inout = EcsIn
-            },
-            { 
-                .id = ecs_id(Position), 
-                .src.flags = EcsParent|EcsCascade,
-                .inout = EcsIn
-            },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    
-    // offset the column of Position to verify change detection is testing
-    // againt the right one.
-    ecs_add(world, p_2, Velocity); 
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterYield);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 11); test_int(pp->y, 21);
-        }
-        {
-            test_assert(ecs_query_populate(&it, true) == EcsIterNextYield);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_1, Position, {22, 42});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterYield);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 22); test_int(pp->y, 42);
-        }
-        {
-            test_assert(ecs_query_populate(&it, true) == EcsIterNext);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_change_detection_2nd_populate_when_changed(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ 
-                .id = ecs_id(Position), 
-                .inout = EcsIn
-            },
-            { 
-                .id = ecs_id(Position), 
-                .src.flags = EcsParent|EcsCascade,
-                .inout = EcsIn
-            },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    
-    // offset the column of Position to verify change detection is testing
-    // againt the right one.
-    ecs_add(world, p_2, Velocity); 
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterYield);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 11); test_int(pp->y, 21);
-        }
-        {
-            test_assert(ecs_query_populate(&it, true) == EcsIterNextYield);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_2, Position, {24, 44});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterNextYield);
-            test_bool(ecs_query_changed(NULL, &it), true);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 24); test_int(pp->y, 44);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_change_detection_iter_twice_populate_when_changed(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ 
-                .id = ecs_id(Position), 
-                .inout = EcsIn
-            },
-            { 
-                .id = ecs_id(Position), 
-                .src.flags = EcsParent|EcsCascade,
-                .inout = EcsIn
-            },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    
-    // offset the column of Position to verify change detection is testing
-    // againt the right one.
-    ecs_add(world, p_2, Velocity); 
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterYield);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 11); test_int(pp->y, 21);
-        }
-        {
-            test_assert(ecs_query_populate(&it, true) == EcsIterNextYield);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_1, Position, {22, 42});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterYield);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 22); test_int(pp->y, 42);
-        }
-        {
-            test_assert(ecs_query_populate(&it, true) == EcsIterNext);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterNext);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_query_w_parent_change_detection_iter_twice_each_parent_populate_when_changed(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ 
-                .id = ecs_id(Position), 
-                .inout = EcsIn
-            },
-            { 
-                .id = ecs_id(Position), 
-                .src.flags = EcsParent|EcsCascade,
-                .inout = EcsIn
-            },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t p_1 = ecs_new_entity(world, "p._1");
-    ecs_entity_t p_1_1 = ecs_new_entity(world, "p._1._1");
-    ecs_entity_t p_2 = ecs_new_entity(world, "p._2");
-    ecs_entity_t p_2_1 = ecs_new_entity(world, "p._2._1");
-
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    
-    // offset the column of Position to verify change detection is testing
-    // againt the right one.
-    ecs_add(world, p_2, Velocity); 
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterYield);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 11); test_int(pp->y, 21);
-        }
-        {
-            test_assert(ecs_query_populate(&it, true) == EcsIterNextYield);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 12); test_int(pp->y, 22);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_1, Position, {22, 42});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterYield);
-            test_uint(1, it.count);
-            test_uint(p_1_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_1, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 22); test_int(pp->y, 42);
-        }
-        {
-            test_assert(ecs_query_populate(&it, true) == EcsIterNext);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_set(world, p_2, Position, {24, 44});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        {
-            test_bool(ecs_query_next_table(&it), true);
-            test_assert(ecs_query_populate(&it, true) == EcsIterNextYield);
-            test_uint(1, it.count);
-            test_uint(p_2_1, it.entities[0]);
-            test_uint(0, it.sources[0]);
-            test_uint(p_2, it.sources[1]);
-            Position *p = ecs_field(&it, Position, 1);
-            test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-            Position *pp = ecs_field(&it, Position, 2);
-            test_assert(pp != NULL);
-            test_int(pp->x, 24); test_int(pp->y, 44);
-        }
-        test_bool(ecs_query_next_table(&it), false);
-    }
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_staged_query_w_parent_field_1_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_world_t *stage = ecs_get_stage(world, 0);
-    ecs_readonly_begin(world, false);
-
-    ecs_iter_t it = ecs_query_iter(stage, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_readonly_end(world);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_staged_query_w_parent_field_2_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_1_1, Position, {1111, 2111});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    ecs_set(world, p_2_1_1, Position, {1211, 2211});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_world_t *stage = ecs_get_stage(world, 0);
-    ecs_readonly_begin(world, false);
-
-    ecs_iter_t it = ecs_query_iter(stage, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1111); test_int(p[0].y, 2111);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 111); test_int(pp[0].y, 211);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1211); test_int(p[0].y, 2211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 121); test_int(pp[0].y, 221);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_readonly_end(world);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_staged_query_w_parent_field_1_fixed_1_regular(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-    ecs_set(world, p, Velocity, {3, 4});
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent },
-            { .id = ecs_id(Velocity), .src.flags = EcsParent }
-        },
-        .filter.instanced = true
-    });
-
-    ecs_world_t *stage = ecs_get_stage(world, 0);
-    ecs_readonly_begin(world, false);
-
-    ecs_iter_t it = ecs_query_iter(stage, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        test_uint(p, it.sources[2]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-        Velocity *vp = ecs_field(&it, Velocity, 3);
-        test_int(vp[0].x, 3); test_int(vp[0].y, 4);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_readonly_end(world);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_staged_query_w_cascade_field_2_lvl(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t p = ecs_set(world, 0, Position, {1, 2});
-
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_set(world, p_1, Position, {11, 21});
-    ecs_set(world, p_1_1, Position, {111, 211});
-    ecs_set(world, p_1_1_1, Position, {1111, 2111});
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_set(world, p_2, Position, {12, 22});
-    ecs_set(world, p_2_1, Position, {121, 221});
-    ecs_set(world, p_2_1_1, Position, {1211, 2211});
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Position), .src.flags = EcsParent|EcsCascade },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_world_t *stage = ecs_get_stage(world, 0);
-    ecs_readonly_begin(world, false);
-
-    ecs_iter_t it = ecs_query_iter(stage, q);
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(2, it.count);
-        test_uint(p_1, it.entities[0]);
-        test_uint(p_2, it.entities[1]);
-        test_uint(0, it.sources[0]);
-        test_uint(p, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 11); test_int(p[0].y, 21);
-        test_int(p[1].x, 12); test_int(p[1].y, 22);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 1); test_int(pp[0].y, 2);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 111); test_int(p[0].y, 211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 11); test_int(pp[0].y, 21);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 121); test_int(p[0].y, 221);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 12); test_int(pp[0].y, 22);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_1_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_1_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1111); test_int(p[0].y, 2111);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 111); test_int(pp[0].y, 211);
-    }
-    {
-        test_bool(ecs_query_next(&it), true);
-        test_uint(1, it.count);
-        test_uint(p_2_1_1, it.entities[0]);
-        test_uint(0, it.sources[0]);
-        test_uint(p_2_1, it.sources[1]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 1211); test_int(p[0].y, 2211);
-
-        Position *pp = ecs_field(&it, Position, 2);
-        test_int(pp[0].x, 121); test_int(pp[0].y, 221);
-    }
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_readonly_end(world);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_add_to_fixed(void) {
-    install_test_abort();
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_expect_abort();
-    ecs_add(world, p_1_1, Tag);
-}
-
-void FixedHierarchies_remove_from_fixed(void) {
-    install_test_abort();
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_add(world, p_1_1, Tag);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_expect_abort();
-    ecs_remove(world, p_1_1, Tag);
-}
-
-void FixedHierarchies_delete_fixed(void) {
-    install_test_abort();
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_expect_abort();
-    ecs_delete(world, p_1_1);
-}
-
-void FixedHierarchies_clear_fixed(void) {
-    install_test_abort();
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_expect_abort();
-    ecs_clear(world, p_1_1);
-}
-
-void FixedHierarchies_make_fixed_1_lvl_w_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_set_name(world, p, "p");
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set_name(world, p_1, "name_1");
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set_name(world, p_1_1, "child_1");
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set_name(world, p_2, "name_2");
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set_name(world, p_2_1, "child_1");
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_lookup(world, "p.name_1") == p_1);
-    test_assert(ecs_lookup(world, "p.name_2") == p_2);
-    test_assert(ecs_lookup(world, "p.name_1.child_1") == 0);
-    test_assert(ecs_lookup(world, "p.name_2.child_1") == 0);
-
-    test_str(ecs_get_name(world, p_1), "name_1");
-    test_str(ecs_get_name(world, p_2), "name_2");
-    test_str(ecs_get_name(world, p_1_1), NULL);
-    test_str(ecs_get_name(world, p_2_1), NULL);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_2_lvl_w_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_set_name(world, p, "p");
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set_name(world, p_1, "name_1");
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set_name(world, p_1_1, "child_1");
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_set_name(world, p_1_1_1, "child_1_1");
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set_name(world, p_2, "name_2");
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set_name(world, p_2_1, "child_1");
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_set_name(world, p_2_1_1, "child_1_1");
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_lookup(world, "p.name_1") == p_1);
-    test_assert(ecs_lookup(world, "p.name_2") == p_2);
-    test_assert(ecs_lookup(world, "p.name_1.child_1") == 0);
-    test_assert(ecs_lookup(world, "p.name_2.child_1") == 0);
-    test_assert(ecs_lookup(world, "p.name_1.child_1.child_1_1") == 0);
-    test_assert(ecs_lookup(world, "p.name_2.child_1.child_1_1") == 0);
-
-    test_str(ecs_get_name(world, p_1), "name_1");
-    test_str(ecs_get_name(world, p_2), "name_2");
-    test_str(ecs_get_name(world, p_1_1), NULL);
-    test_str(ecs_get_name(world, p_2_1), NULL);
-    test_str(ecs_get_name(world, p_1_1_1), NULL);
-    test_str(ecs_get_name(world, p_2_1_1), NULL);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_1_lvl_w_name_keep_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_set_name(world, p, "p");
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set_name(world, p_1, "name_1");
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set_name(world, p_1_1, "child_1_1");
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set_name(world, p_2, "name_2");
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set_name(world, p_2_1, "child_2_1");
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), &(ecs_flatten_desc_t){
-        .keep_names = true
-    });
-
-    test_assert(ecs_lookup(world, "p.name_1") == p_1);
-    test_assert(ecs_lookup(world, "p.name_2") == p_2);
-    test_assert(ecs_lookup(world, "p.name_1.child_1") == 0);
-    test_assert(ecs_lookup(world, "p.name_2.child_1") == 0);
-
-    test_str(ecs_get_name(world, p_1), "name_1");
-    test_str(ecs_get_name(world, p_2), "name_2");
-    test_str(ecs_get_name(world, p_1_1), "child_1_1");
-    test_str(ecs_get_name(world, p_2_1), "child_2_1");
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_2_lvl_w_name_keep_name(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    ecs_set_name(world, p, "p");
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set_name(world, p_1, "name_1");
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_set_name(world, p_1_1, "child_1_1");
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_set_name(world, p_1_1_1, "child_1_1_1");
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_set_name(world, p_2, "name_2");
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_set_name(world, p_2_1, "child_2_1");
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_set_name(world, p_2_1_1, "child_2_1_1");
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), &(ecs_flatten_desc_t){
-        .keep_names = true
-    });
-
-    test_assert(ecs_lookup(world, "p.name_1") == p_1);
-    test_assert(ecs_lookup(world, "p.name_2") == p_2);
-    test_assert(ecs_lookup(world, "p.name_1.child_1") == 0);
-    test_assert(ecs_lookup(world, "p.name_2.child_1") == 0);
-    test_assert(ecs_lookup(world, "p.name_1.child_1.child_1_1") == 0);
-    test_assert(ecs_lookup(world, "p.name_2.child_1.child_1_1") == 0);
-
-    test_str(ecs_get_name(world, p_1), "name_1");
-    test_str(ecs_get_name(world, p_2), "name_2");
-    test_str(ecs_get_name(world, p_1_1), "child_1_1");
-    test_str(ecs_get_name(world, p_2_1), "child_2_1");
-    test_str(ecs_get_name(world, p_1_1_1), "child_1_1_1");
-    test_str(ecs_get_name(world, p_2_1_1), "child_2_1_1");
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_2_lvl_lose_depth(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), &(ecs_flatten_desc_t){
-        .lose_depth = true
-    });
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-
-    ecs_fini(world);
-}
-
-void FixedHierarchies_make_fixed_3_lvl_lose_depth(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t p = ecs_new_id(world);
-    
-    ecs_entity_t p_1 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1);
-    ecs_entity_t p_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1);
-    ecs_entity_t p_1_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_1_1_1);
-
-    ecs_entity_t p_2 = ecs_new_w_pair(world, EcsChildOf, p);
-    ecs_entity_t p_2_1 = ecs_new_w_pair(world, EcsChildOf, p_2);
-    ecs_entity_t p_2_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1);
-    ecs_entity_t p_2_1_1_1 = ecs_new_w_pair(world, EcsChildOf, p_2_1_1);
-    
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) != ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-
-    ecs_flatten(world, ecs_pair(EcsChildOf, p), NULL);
-
-    test_assert(ecs_get_table(world, p_1) == ecs_get_table(world, p_2));
-    test_assert(ecs_get_table(world, p_1_1) == ecs_get_table(world, p_2_1));
-    test_assert(ecs_get_table(world, p_1_1_1) == ecs_get_table(world, p_2_1_1));
-    test_assert(ecs_get_table(world, p_1_1_1) != ecs_get_table(world, p_1_1));
-    test_assert(ecs_get_target(world, p_1, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_1_1, EcsChildOf, 0) == p_1);
-    test_assert(ecs_get_target(world, p_1_1_1, EcsChildOf, 0) == p_1_1);
-    test_assert(ecs_get_target(world, p_1_1_1_1, EcsChildOf, 0) == p_1_1_1);
-    test_assert(ecs_get_target(world, p_2, EcsChildOf, 0) == p);
-    test_assert(ecs_get_target(world, p_2_1, EcsChildOf, 0) == p_2);
-    test_assert(ecs_get_target(world, p_2_1_1, EcsChildOf, 0) == p_2_1);
-    test_assert(ecs_get_target(world, p_2_1_1_1, EcsChildOf, 0) == p_2_1_1);
-
-    ecs_fini(world);
-}
diff --git a/test/api/src/Iter.c b/test/api/src/Iter.c
deleted file mode 100644
index 14ce0dc8f..000000000
--- a/test/api/src/Iter.c
+++ /dev/null
@@ -1,2299 +0,0 @@
-#include <api.h>
-
-void Iter_page_iter_0_0(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 0, 0);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.frame_offset, 0);
-        test_int(pit.entities[0], e1);
-        test_int(pit.entities[1], e2);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e1);
-        test_int(ptr[1].value, e2);
-    }
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.frame_offset, 2);
-        test_int(pit.entities[0], e3);
-        test_int(pit.entities[1], e4);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-        test_int(ptr[1].value, e4);
-    }
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.frame_offset, 4);
-        test_int(pit.entities[0], e5);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_1_0(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 1, 0);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e2);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e2);
-    }
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.entities[0], e3);
-        test_int(pit.entities[1], e4);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-        test_int(ptr[1].value, e4);
-    }
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e5);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_0_1(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 0, 1);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e1);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e1);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_n_0(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 2, 0);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e3);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-    }
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e4);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e4);
-    }
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e5);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_0_n(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 0, 2);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.entities[0], e1);
-        test_int(pit.entities[1], e2);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e1);
-        test_int(ptr[1].value, e2);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_m_n(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-    ecs_entity_t e6 = ecs_new_id(world); ecs_set(world, e6, Self, {e6});
-
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagA);
-    ecs_add(world, e6, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 2, 3);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e3);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-    }
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.entities[0], e4);
-        test_int(pit.entities[1], e5);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e4);
-        test_int(ptr[1].value, e5);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_skip_1_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 2, 0);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.entities[0], e3);
-        test_int(pit.entities[1], e4);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-        test_int(ptr[1].value, e4);
-    }
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e5);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_skip_2_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e4, TagB);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 3, 0);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.entities[0], e4);
-        test_int(pit.entities[1], e5);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e4);
-        test_int(ptr[1].value, e5);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_1(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_worker_iter(&it, 0, 1);
-
-    {
-        test_bool(ecs_worker_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.entities[0], e1);
-        test_int(pit.entities[1], e2);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e1);
-        test_int(ptr[1].value, e2);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.entities[0], e3);
-        test_int(pit.entities[1], e4);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-        test_int(ptr[1].value, e4);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e5);
-        test_int(pit.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-    }
-
-    test_bool(ecs_worker_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_2(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it_1 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 2);
-    ecs_iter_t it_2 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 2);
-
-    /* Iter 1 */
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e1);
-        test_int(pit_1.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e1);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e3);
-        test_int(pit_1.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e5);
-        test_int(pit_1.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-    }
-
-    test_bool(ecs_worker_next(&pit_1), false);
-
-    /* Iter 2 */
-    {
-        test_bool(ecs_worker_next(&pit_2), true);
-        test_int(pit_2.count, 1);
-        test_int(pit_2.entities[0], e2);
-        test_int(pit_2.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_2, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e2);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_2), true);
-        test_int(pit_2.count, 1);
-        test_int(pit_2.entities[0], e4);
-        test_int(pit_2.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_2, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e4);
-    }
-
-    test_bool(ecs_worker_next(&pit_2), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_3(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-    ecs_entity_t e6 = ecs_new_id(world); ecs_set(world, e6, Self, {e6});
-
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagA);
-    ecs_add(world, e6, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it_1 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 3);
-    ecs_iter_t it_2 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 3);
-    ecs_iter_t it_3 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_3 = ecs_worker_iter(&it_3, 2, 3);
-
-    /* Iter 1 */
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e1);
-        test_int(pit_1.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e1);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e4);
-        test_int(pit_1.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e4);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e6);
-        test_int(pit_1.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e6);
-    }
-
-    test_bool(ecs_worker_next(&pit_1), false);
-
-    /* Iter 2 */
-    {
-        test_bool(ecs_worker_next(&pit_2), true);
-        test_int(pit_2.count, 1);
-        test_int(pit_2.entities[0], e2);
-        test_int(pit_2.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_2, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e2);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_2), true);
-        test_int(pit_2.count, 1);
-        test_int(pit_2.entities[0], e5);
-        test_int(pit_2.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_2, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-    }
-
-    test_bool(ecs_worker_next(&pit_2), false);
-
-    /* Iter 3 */
-    {
-        test_bool(ecs_worker_next(&pit_3), true);
-        test_int(pit_3.count, 1);
-        test_int(pit_3.entities[0], e3);
-        test_int(pit_3.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_3, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-    }
-
-    test_bool(ecs_worker_next(&pit_3), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_4(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-    ecs_entity_t e6 = ecs_new_id(world); ecs_set(world, e6, Self, {e6});
-    ecs_entity_t e7 = ecs_new_id(world); ecs_set(world, e7, Self, {e7});
-    ecs_entity_t e8 = ecs_new_id(world); ecs_set(world, e8, Self, {e8});
-    ecs_entity_t e9 = ecs_new_id(world); ecs_set(world, e9, Self, {e9});
-
-    ecs_add(world, e5, TagA);
-    ecs_add(world, e6, TagA);
-    ecs_add(world, e7, TagA);
-    ecs_add(world, e8, TagB);
-    ecs_add(world, e9, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }}
-    });
-
-    ecs_iter_t it_1 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 4);
-    ecs_iter_t it_2 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 4);
-    ecs_iter_t it_3 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_3 = ecs_worker_iter(&it_3, 2, 4);
-    ecs_iter_t it_4 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_4 = ecs_worker_iter(&it_4, 3, 4);
-
-    /* Iter 1 */
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e1);
-        test_int(pit_1.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e1);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e5);
-        test_int(pit_1.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e8);
-        test_int(pit_1.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e8);
-    }
-
-    test_bool(ecs_worker_next(&pit_1), false);
-
-    /* Iter 2 */
-    {
-        test_bool(ecs_worker_next(&pit_2), true);
-        test_int(pit_2.count, 1);
-        test_int(pit_2.entities[0], e2);
-        test_int(pit_2.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_2, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e2);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_2), true);
-        test_int(pit_2.count, 1);
-        test_int(pit_2.entities[0], e6);
-        test_int(pit_2.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_2, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e6);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_2), true);
-        test_int(pit_2.count, 1);
-        test_int(pit_2.entities[0], e9);
-        test_int(pit_2.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_2, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e9);
-    }
-
-    test_bool(ecs_worker_next(&pit_2), false);
-
-    /* Iter 3 */
-    {
-        test_bool(ecs_worker_next(&pit_3), true);
-        test_int(pit_3.count, 1);
-        test_int(pit_3.entities[0], e3);
-        test_int(pit_3.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_3, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_3), true);
-        test_int(pit_3.count, 1);
-        test_int(pit_3.entities[0], e7);
-        test_int(pit_3.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_3, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e7);
-    }
-
-    test_bool(ecs_worker_next(&pit_3), false);
-
-    /* Iter 4 */
-    {
-        test_bool(ecs_worker_next(&pit_4), true);
-        test_int(pit_4.count, 1);
-        test_int(pit_4.entities[0], e4);
-        test_int(pit_4.ids[0], ecs_id(Self));
-
-        Self *ptr = ecs_field(&pit_4, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e4);
-    }
-
-    test_bool(ecs_worker_next(&pit_4), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_paged_iter_w_shared_comp(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Self);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t foo = ecs_set(world, 0, Position, {10, 20});
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }, { ecs_id(Position), .src.id = foo} },
-        .instanced = true
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 0, 0);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.entities[0], e1);
-        test_int(pit.entities[1], e2);
-        test_int(pit.ids[0], ecs_id(Self));
-        test_int(pit.ids[1], ecs_id(Position));
-        test_int(pit.sources[0], 0);
-        test_int(pit.sources[1], foo);
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e1);
-        test_int(ptr[1].value, e2);
-
-        Position *pptr = ecs_field(&pit, Position, 2);
-        test_int(pptr->x, 10);
-        test_int(pptr->y, 20);
-    }
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 2);
-        test_int(pit.entities[0], e3);
-        test_int(pit.entities[1], e4);
-        test_int(pit.ids[0], ecs_id(Self));
-        test_int(pit.ids[1], ecs_id(Position));
-        test_int(pit.sources[0], 0);
-        test_int(pit.sources[1], foo);
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-        test_int(ptr[1].value, e4);
-
-        Position *pptr = ecs_field(&pit, Position, 2);
-        test_int(pptr->x, 10);
-        test_int(pptr->y, 20);
-    }
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 1);
-        test_int(pit.entities[0], e5);
-        test_int(pit.ids[0], ecs_id(Self));
-        test_int(pit.ids[1], ecs_id(Position));
-        test_int(pit.sources[0], 0);
-        test_int(pit.sources[1], foo);
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-
-        Position *pptr = ecs_field(&pit, Position, 2);
-        test_int(pptr->x, 10);
-        test_int(pptr->y, 20);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_shared_comp(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t foo = ecs_set(world, 0, Position, {10, 20});
-
-    ecs_entity_t e1 = ecs_new_id(world); ecs_set(world, e1, Self, {e1});
-    ecs_entity_t e2 = ecs_new_id(world); ecs_set(world, e2, Self, {e2});
-    ecs_entity_t e3 = ecs_new_id(world); ecs_set(world, e3, Self, {e3});
-    ecs_entity_t e4 = ecs_new_id(world); ecs_set(world, e4, Self, {e4});
-    ecs_entity_t e5 = ecs_new_id(world); ecs_set(world, e5, Self, {e5});
-
-    ecs_add(world, e3, TagA);
-    ecs_add(world, e4, TagA);
-    ecs_add(world, e5, TagB);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self) }, { ecs_id(Position), .src.id = foo} },
-        .instanced = true
-    });
-
-    ecs_iter_t it_1 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 2);
-    ecs_iter_t it_2 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 2);
-
-    /* Iter 1 */
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e1);
-        test_int(pit_1.ids[0], ecs_id(Self));
-        test_int(pit_1.ids[1], ecs_id(Position));
-        test_int(pit_1.sources[0], 0);
-        test_int(pit_1.sources[1], foo);
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e1);
-
-        Position *pptr = ecs_field(&pit_1, Position, 2);
-        test_int(pptr->x, 10);
-        test_int(pptr->y, 20);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e3);
-        test_int(pit_1.ids[0], ecs_id(Self));
-        test_int(pit_1.ids[1], ecs_id(Position));
-        test_int(pit_1.sources[0], 0);
-        test_int(pit_1.sources[1], foo);
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e3);
-
-        Position *pptr = ecs_field(&pit_1, Position, 2);
-        test_int(pptr->x, 10);
-        test_int(pptr->y, 20);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 1);
-        test_int(pit_1.entities[0], e5);
-        test_int(pit_1.ids[0], ecs_id(Self));
-        test_int(pit_1.ids[1], ecs_id(Position));
-        test_int(pit_1.sources[0], 0);
-        test_int(pit_1.sources[1], foo);
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e5);
-
-        Position *pptr = ecs_field(&pit_1, Position, 2);
-        test_int(pptr->x, 10);
-        test_int(pptr->y, 20);
-    }
-
-    test_bool(ecs_worker_next(&pit_1), false);
-
-    /* Iter 2 */
-    {
-        test_bool(ecs_worker_next(&pit_2), true);
-        test_int(pit_2.count, 1);
-        test_int(pit_2.entities[0], e2);
-        test_int(pit_2.ids[0], ecs_id(Self));
-        test_int(pit_2.ids[1], ecs_id(Position));
-        test_int(pit_2.sources[0], 0);
-        test_int(pit_2.sources[1], foo);
-
-        Self *ptr = ecs_field(&pit_2, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e2);
-
-        Position *pptr = ecs_field(&pit_2, Position, 2);
-        test_int(pptr->x, 10);
-        test_int(pptr->y, 20);
-    }
-
-    {
-        test_bool(ecs_worker_next(&pit_2), true);
-        test_int(pit_2.count, 1);
-        test_int(pit_2.entities[0], e4);
-        test_int(pit_2.ids[0], ecs_id(Self));
-        test_int(pit_2.ids[1], ecs_id(Position));
-        test_int(pit_2.sources[0], 0);
-        test_int(pit_2.sources[1], foo);
-
-        Self *ptr = ecs_field(&pit_2, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, e4);
-
-        Position *pptr = ecs_field(&pit_2, Position, 2);
-        test_int(pptr->x, 10);
-        test_int(pptr->y, 20);
-    }
-
-    test_bool(ecs_worker_next(&pit_2), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_paged_iter_w_task_query(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-
-    ecs_entity_t foo = ecs_new_id(world); ecs_set(world, foo, Self, {foo});
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self), .src.id = foo }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, &f);
-    ecs_iter_t pit = ecs_page_iter(&it, 0, 0);
-
-    {
-        test_bool(ecs_page_next(&pit), true);
-        test_int(pit.count, 0);
-        test_int(pit.ids[0], ecs_id(Self));
-        test_int(pit.sources[0], foo);
-
-        Self *ptr = ecs_field(&pit, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, foo);
-    }
-
-    test_bool(ecs_page_next(&pit), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_task_query(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Self);
-
-    ecs_entity_t foo = ecs_new_id(world); ecs_set(world, foo, Self, {foo});
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .terms = {{ ecs_id(Self), .src.id = foo }}
-    });
-
-    ecs_iter_t it_1 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 2);
-    ecs_iter_t it_2 = ecs_filter_iter(world, &f);
-    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 2);
-
-    /* Iter 1 */
-    {
-        test_bool(ecs_worker_next(&pit_1), true);
-        test_int(pit_1.count, 0);
-        test_int(pit_1.ids[0], ecs_id(Self));
-        test_int(pit_1.sources[0], foo);
-
-        Self *ptr = ecs_field(&pit_1, Self, 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].value, foo);
-    }
-
-    test_bool(ecs_worker_next(&pit_1), false);
-
-    /* Iter 2 */
-
-    test_bool(ecs_worker_next(&pit_2), false);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Singleton);
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_add(world, Singleton);
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Singleton($)");
-
-    Position *p;
-
-    ecs_iter_t it_1 = ecs_query_iter(world, q);
-    ecs_iter_t wit_1 = ecs_worker_iter(&it_1, 0, 2);
-    test_bool(ecs_worker_next(&wit_1), true);
-    test_int(wit_1.count, 2);
-    test_int(wit_1.entities[0], e1);
-    test_int(wit_1.entities[1], e2);
-    p = ecs_field(&wit_1, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-
-    ecs_iter_t it_2 = ecs_query_iter(world, q);
-    ecs_iter_t wit_2 = ecs_worker_iter(&it_2, 1, 2);
-    test_bool(ecs_worker_next(&wit_2), true);
-    test_int(wit_2.count, 2);
-    test_int(wit_2.entities[0], e3);
-    test_int(wit_2.entities[1], e4);
-    p = ecs_field(&wit_2, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_int(p[1].x, 40);
-    test_int(p[1].y, 50);
-
-    test_bool(ecs_worker_next(&wit_2), false);
-    test_bool(ecs_worker_next(&wit_1), false);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_singleton_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity($)");
-
-    Position *p;
-    Velocity *v;
-
-    ecs_iter_t it_1 = ecs_query_iter(world, q);
-    ecs_iter_t wit_1 = ecs_worker_iter(&it_1, 0, 2);
-    test_bool(ecs_worker_next(&wit_1), true);
-    test_int(wit_1.count, 1);
-    test_int(wit_1.entities[0], e1);
-    p = ecs_field(&wit_1, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    v = ecs_field(&wit_1, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-
-    test_bool(ecs_worker_next(&wit_1), true);
-    test_int(wit_1.count, 1);
-    test_int(wit_1.entities[0], e2);
-    p = ecs_field(&wit_1, Position, 1);
-    test_int(p[0].x, 20);
-    test_int(p[0].y, 30);
-    v = ecs_field(&wit_1, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-
-    test_bool(ecs_worker_next(&wit_1), false);
-
-    ecs_iter_t it_2 = ecs_query_iter(world, q);
-    ecs_iter_t wit_2 = ecs_worker_iter(&it_2, 1, 2);
-    test_bool(ecs_worker_next(&wit_2), true);
-    test_int(wit_2.count, 1);
-    test_int(wit_2.entities[0], e3);
-    p = ecs_field(&wit_2, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    v = ecs_field(&wit_2, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-
-    test_bool(ecs_worker_next(&wit_2), true);
-    test_int(wit_2.count, 1);
-    test_int(wit_2.entities[0], e4);
-    p = ecs_field(&wit_2, Position, 1);
-    test_int(p[0].x, 40);
-    test_int(p[0].y, 50);
-    v = ecs_field(&wit_2, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-
-    test_bool(ecs_worker_next(&wit_2), false);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_singleton_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Singleton);
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_add(world, Singleton);
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter = {
-            .expr = "Position, Singleton($)",
-            .instanced = true
-        }
-    });
-
-    Position *p;
-
-    ecs_iter_t it_1 = ecs_query_iter(world, q);
-    ecs_iter_t wit_1 = ecs_worker_iter(&it_1, 0, 2);
-    test_bool(ecs_worker_next(&wit_1), true);
-    test_int(wit_1.count, 2);
-    test_int(wit_1.entities[0], e1);
-    test_int(wit_1.entities[1], e2);
-    p = ecs_field(&wit_1, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-    test_bool(ecs_worker_next(&wit_1), false);
-
-    ecs_iter_t it_2 = ecs_query_iter(world, q);
-    ecs_iter_t wit_2 = ecs_worker_iter(&it_2, 1, 2);
-    test_bool(ecs_worker_next(&wit_2), true);
-    test_int(wit_2.count, 2);
-    test_int(wit_2.entities[0], e3);
-    test_int(wit_2.entities[1], e4);
-    p = ecs_field(&wit_2, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_int(p[1].x, 40);
-    test_int(p[1].y, 50);
-    test_bool(ecs_worker_next(&wit_2), false);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_singleton_component_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter = {
-            .expr = "Position, Velocity($)",
-            .instanced = true
-        }
-    });
-
-    Position *p;
-    Velocity *v;
-
-    ecs_iter_t it_1 = ecs_query_iter(world, q);
-    ecs_iter_t wit_1 = ecs_worker_iter(&it_1, 0, 2);
-    test_bool(ecs_worker_next(&wit_1), true);
-    test_int(wit_1.count, 2);
-    test_int(wit_1.entities[0], e1);
-    test_int(wit_1.entities[1], e2);
-    p = ecs_field(&wit_1, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-    v = ecs_field(&wit_1, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(ecs_worker_next(&wit_1), false);
-
-    ecs_iter_t it_2 = ecs_query_iter(world, q);
-    ecs_iter_t wit_2 = ecs_worker_iter(&it_2, 1, 2);
-    test_bool(ecs_worker_next(&wit_2), true);
-    test_int(wit_2.count, 2);
-    test_int(wit_2.entities[0], e3);
-    test_int(wit_2.entities[1], e4);
-    p = ecs_field(&wit_2, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_int(p[1].x, 40);
-    test_int(p[1].y, 50);
-    v = ecs_field(&wit_2, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(ecs_worker_next(&wit_2), false);
-
-    ecs_fini(world);
-}
-
-void Iter_paged_iter_w_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Singleton);
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_add(world, Singleton);
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Singleton($)");
-
-    Position *p;
-
-    ecs_iter_t it_1 = ecs_query_iter(world, q);
-    ecs_iter_t pit_1 = ecs_page_iter(&it_1, 0, 2);
-    test_bool(ecs_page_next(&pit_1), true);
-    test_int(pit_1.count, 2);
-    test_int(pit_1.entities[0], e1);
-    test_int(pit_1.entities[1], e2);
-    p = ecs_field(&pit_1, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-    test_bool(ecs_page_next(&pit_1), false);
-
-    ecs_iter_t it_2 = ecs_query_iter(world, q);
-    ecs_iter_t pit_2 = ecs_page_iter(&it_2, 2, 2);
-    test_bool(ecs_page_next(&pit_2), true);
-    test_int(pit_2.count, 2);
-    test_int(pit_2.entities[0], e3);
-    test_int(pit_2.entities[1], e4);
-    p = ecs_field(&pit_2, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_int(p[1].x, 40);
-    test_int(p[1].y, 50);
-    test_bool(ecs_page_next(&pit_2), false);
-
-    ecs_fini(world);
-}
-
-void Iter_paged_iter_w_singleton_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity($)");
-
-    Position *p;
-    Velocity *v;
-
-    ecs_iter_t it_1 = ecs_query_iter(world, q);
-    ecs_iter_t pit_1 = ecs_page_iter(&it_1, 0, 2);
-    test_bool(ecs_page_next(&pit_1), true);
-    test_int(pit_1.count, 1);
-    test_int(pit_1.entities[0], e1);
-    p = ecs_field(&pit_1, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    v = ecs_field(&pit_1, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(ecs_page_next(&pit_1), true);
-    test_int(pit_1.count, 1);
-    test_int(pit_1.entities[0], e2);
-    p = ecs_field(&pit_1, Position, 1);
-    test_int(p[0].x, 20);
-    test_int(p[0].y, 30);
-    v = ecs_field(&pit_1, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(ecs_page_next(&pit_1), false);
-
-    ecs_iter_t it_2 = ecs_query_iter(world, q);
-    ecs_iter_t pit_2 = ecs_page_iter(&it_2, 2, 2);
-    test_bool(ecs_page_next(&pit_2), true);
-    test_int(pit_2.count, 1);
-    test_int(pit_2.entities[0], e3);
-    p = ecs_field(&pit_2, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    v = ecs_field(&pit_2, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(ecs_page_next(&pit_2), true);
-    test_int(pit_2.count, 1);
-    test_int(pit_2.entities[0], e4);
-    p = ecs_field(&pit_2, Position, 1);
-    test_int(p[0].x, 40);
-    test_int(p[0].y, 50);
-    v = ecs_field(&pit_2, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(ecs_page_next(&pit_2), false);
-
-    ecs_fini(world);
-}
-
-void Iter_paged_iter_w_singleton_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Singleton);
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_add(world, Singleton);
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter = {
-            .expr = "Position, Singleton($)",
-            .instanced = true
-        }
-    });
-
-    Position *p;
-
-    ecs_iter_t it_1 = ecs_query_iter(world, q);
-    ecs_iter_t pit_1 = ecs_page_iter(&it_1, 0, 2);
-    test_bool(ecs_page_next(&pit_1), true);
-    test_int(pit_1.count, 2);
-    test_int(pit_1.entities[0], e1);
-    test_int(pit_1.entities[1], e2);
-    p = ecs_field(&pit_1, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-    test_bool(ecs_page_next(&pit_1), false);
-
-    ecs_iter_t it_2 = ecs_query_iter(world, q);
-    ecs_iter_t pit_2 = ecs_page_iter(&it_2, 2, 2);
-    test_bool(ecs_page_next(&pit_2), true);
-    test_int(pit_2.count, 2);
-    test_int(pit_2.entities[0], e3);
-    test_int(pit_2.entities[1], e4);
-    p = ecs_field(&pit_2, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_int(p[1].x, 40);
-    test_int(p[1].y, 50);
-    test_bool(ecs_page_next(&pit_2), false);
-
-    ecs_fini(world);
-}
-
-void Iter_paged_iter_w_singleton_component_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter = {
-            .expr = "Position, Velocity($)",
-            .instanced = true
-        }
-    });
-
-    Position *p;
-    Velocity *v;
-
-    ecs_iter_t it_1 = ecs_query_iter(world, q);
-    ecs_iter_t pit_1 = ecs_page_iter(&it_1, 0, 2);
-    test_bool(ecs_page_next(&pit_1), true);
-    test_int(pit_1.count, 2);
-    test_int(pit_1.entities[0], e1);
-    test_int(pit_1.entities[1], e2);
-    p = ecs_field(&pit_1, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-    v = ecs_field(&pit_1, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(ecs_page_next(&pit_1), false);
-
-    ecs_iter_t it_2 = ecs_query_iter(world, q);
-    ecs_iter_t pit_2 = ecs_page_iter(&it_2, 2, 2);
-    test_bool(ecs_page_next(&pit_2), true);
-    test_int(pit_2.count, 2);
-    test_int(pit_2.entities[0], e3);
-    test_int(pit_2.entities[1], e4);
-    p = ecs_field(&pit_2, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_int(p[1].x, 40);
-    test_int(p[1].y, 50);
-    v = ecs_field(&pit_2, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(ecs_page_next(&pit_2), false);
-
-    ecs_fini(world);
-}
-
-void Iter_count(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    for (int i = 0; i < 500; i ++) {
-        ecs_entity_t e = ecs_new(world, TagA);
-        if (!(i % 2)) {
-            ecs_add(world, e, TagB);
-        }
-        if (!(i % 3)) {
-            ecs_add(world, e, TagC);
-        }
-    }
-
-    ecs_query_t *q = ecs_query_new(world, "TagA");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_int(500, ecs_iter_count(&it));
-
-    ecs_fini(world);
-}
-
-void Iter_interleaved_iter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ TagA }}
-    });
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-
-    /* Bit of whitebox testing, check whether the stack cursor is restored to
-     * its original position after the 2nd iterator is done */
-    ecs_iter_t it_1 = ecs_filter_iter(world, f);
-    ecs_stack_cursor_t cursor = *it_1.priv.cache.stack_cursor;
-    ecs_iter_t it_2 = ecs_filter_iter(world, f);
-
-    test_bool(true, ecs_filter_next(&it_1));
-    test_bool(true, ecs_filter_next(&it_2));
-    test_int(e1, it_1.entities[0]);
-    test_int(e1, it_2.entities[0]);
-
-    test_bool(true, ecs_filter_next(&it_1));
-    test_bool(true, ecs_filter_next(&it_2));
-    test_int(e2, it_1.entities[0]);
-    test_int(e2, it_2.entities[0]);
-
-    test_bool(false, ecs_filter_next(&it_1));
-    test_bool(false, ecs_filter_next(&it_2));
-
-    it_1 = ecs_filter_iter(world, f);
-    test_assert(it_1.priv.cache.stack_cursor->page == cursor.page);
-    test_assert(it_1.priv.cache.stack_cursor->sp == cursor.sp);
-    ecs_iter_fini(&it_1);
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_iter_restore_stack_iter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_stack_cursor_t cursor = *it.priv.cache.stack_cursor;
-    ecs_iter_fini(&it);
-
-    it = ecs_filter_iter(world, f);
-    test_assert(it.priv.cache.stack_cursor->page == cursor.page);
-    test_assert(it.priv.cache.stack_cursor->sp == cursor.sp);
-    ecs_iter_fini(&it);
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_get_first(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new(world, Tag);
-    ecs_new(world, Tag);
-    ecs_new(world, Tag);
-
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
-        .terms = {{ Tag }}
-    });
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_entity_t first = ecs_iter_first(&it);
-    test_assert(first == e);
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_w_only_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ Tag }}
-    });
-    
-    ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_iter_t pit = ecs_page_iter(&it, 1, 0);
-
-    test_assert(ecs_page_next(&pit));
-    test_int(pit.count, 1);
-    test_uint(pit.entities[0], e2);
-    test_assert(!ecs_page_next(&pit));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_only_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ Tag }}
-    });
-    
-    ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_iter_t pit = ecs_worker_iter(&it, 1, 2);
-
-    test_assert(ecs_worker_next(&pit));
-    test_int(pit.count, 1);
-    test_uint(pit.entities[0], e2);
-    test_assert(!ecs_worker_next(&pit));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_w_inout_none(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ ecs_id(Position), .inout = EcsInOutNone }}
-    });
-    
-    ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_iter_t pit = ecs_page_iter(&it, 1, 0);
-
-    test_assert(ecs_page_next(&pit));
-    test_int(pit.count, 1);
-    test_uint(pit.entities[0], e2);
-    test_assert(!ecs_page_next(&pit));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_inout_none(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ ecs_id(Position), .inout = EcsInOutNone }}
-    });
-    
-    ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_iter_t pit = ecs_worker_iter(&it, 1, 2);
-
-    test_assert(ecs_worker_next(&pit));
-    test_int(pit.count, 1);
-    test_uint(pit.entities[0], e2);
-    test_assert(!ecs_worker_next(&pit));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_w_ctx(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ TagA  }}
-    });
-    
-    ecs_new(world, TagA);
-
-    int ctx;
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    it.ctx = &ctx;
-
-    ecs_iter_t pit = ecs_page_iter(&it, 0, 1);
-    test_assert(pit.ctx == &ctx);
-
-    test_assert(ecs_page_next(&pit));
-    test_assert(!ecs_page_next(&pit));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_w_binding_ctx(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ TagA  }}
-    });
-    
-    ecs_new(world, TagA);
-
-    int ctx;
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    it.binding_ctx = &ctx;
-
-    ecs_iter_t pit = ecs_page_iter(&it, 0, 1);
-    test_assert(pit.binding_ctx == &ctx);
-
-    test_assert(ecs_page_next(&pit));
-    test_assert(!ecs_page_next(&pit));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_ctx(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ TagA  }}
-    });
-    
-    ecs_new(world, TagA);
-
-    int ctx;
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    it.ctx = &ctx;
-
-    ecs_iter_t pit = ecs_worker_iter(&it, 0, 2);
-    test_assert(pit.ctx == &ctx);
-
-    test_assert(ecs_worker_next(&pit));
-    test_assert(!ecs_worker_next(&pit));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_binding_ctx(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ TagA  }}
-    });
-    
-    ecs_new(world, TagA);
-
-    int ctx;
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    it.binding_ctx = &ctx;
-
-    ecs_iter_t pit = ecs_worker_iter(&it, 0, 2);
-    test_assert(pit.binding_ctx == &ctx);
-
-    test_assert(ecs_worker_next(&pit));
-    test_assert(!ecs_worker_next(&pit));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_column_index_owned(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ TagB }, { TagC }, { TagA }}
-    });
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add(world, e1, TagA);
-    ecs_add(world, e1, TagB);
-    ecs_add(world, e1, TagC);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add(world, e2, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e2, TagC);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    test_bool(true, ecs_filter_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_int(1, ecs_field_column_index(&it, 1));
-    test_int(2, ecs_field_column_index(&it, 2));
-    test_int(0, ecs_field_column_index(&it, 3));
-
-    test_bool(true, ecs_filter_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_int(2, ecs_field_column_index(&it, 1));
-    test_int(3, ecs_field_column_index(&it, 2));
-    test_int(1, ecs_field_column_index(&it, 3));
-    
-    test_bool(false, ecs_filter_next(&it));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_column_index_shared(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ TagB }, { TagC }, { TagA }}
-    });
-
-    ecs_entity_t base = ecs_new(world, TagA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, EcsIsA, base);
-    ecs_add(world, e1, TagB);
-    ecs_add(world, e1, TagC);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add_pair(world, e2, EcsIsA, base);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e2, TagC);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    test_bool(true, ecs_filter_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_int(0, ecs_field_column_index(&it, 1));
-    test_int(1, ecs_field_column_index(&it, 2));
-    test_int(-1, ecs_field_column_index(&it, 3));
-
-    test_bool(true, ecs_filter_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_int(1, ecs_field_column_index(&it, 1));
-    test_int(2, ecs_field_column_index(&it, 2));
-    test_int(-1, ecs_field_column_index(&it, 3));
-    
-    test_bool(false, ecs_filter_next(&it));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_column_index_not(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ TagB }, { TagC }, { TagA, .oper = EcsNot }}
-    });
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add(world, e1, TagB);
-    ecs_add(world, e1, TagC);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e2, TagC);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    test_bool(true, ecs_filter_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_int(0, ecs_field_column_index(&it, 1));
-    test_int(1, ecs_field_column_index(&it, 2));
-    test_int(-1, ecs_field_column_index(&it, 3));
-
-    test_bool(true, ecs_filter_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_int(1, ecs_field_column_index(&it, 1));
-    test_int(2, ecs_field_column_index(&it, 2));
-    test_int(-1, ecs_field_column_index(&it, 3));
-    
-    test_bool(false, ecs_filter_next(&it));
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_page_iter_w_fini(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Foo);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Foo);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_iter_t pit = ecs_page_iter(&it, 0, 2);
-    test_bool(true, ecs_page_next(&pit));
-    test_int(pit.count, 1);
-    test_int(pit.entities[0], e1);
-    
-    ecs_iter_fini(&pit);
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_worker_iter_w_fini(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Foo);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Foo);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    ecs_iter_t pit = ecs_worker_iter(&it, 0, 2);
-    test_bool(true, ecs_worker_next(&pit));
-    test_int(pit.count, 1);
-    test_int(pit.entities[0], e1);
-    ecs_iter_fini(&pit);
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_rule_page_iter_w_fini(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Foo);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    ecs_iter_t pit = ecs_page_iter(&it, 0, 2);
-    test_bool(true, ecs_page_next(&pit));
-    test_int(pit.count, 1);
-    test_int(pit.entities[0], e1);
-    ecs_iter_fini(&pit);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void Iter_rule_worker_iter_w_fini(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .terms = {{ ecs_id(Position) }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Foo);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    ecs_iter_t pit = ecs_worker_iter(&it, 0, 2);
-    test_bool(true, ecs_worker_next(&pit));
-    test_int(pit.count, 1);
-    test_int(pit.entities[0], e1);
-    ecs_iter_fini(&pit);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
-
-void Iter_to_str_before_next(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    char *str = ecs_iter_str(&it);
-    test_assert(str == NULL);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Iter_to_str(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    
-    ecs_entity_t e = ecs_new_entity(world, "foo");
-    ecs_add(world, e, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    char *str = ecs_iter_str(&it);
-    test_assert(str != NULL);
-    test_str(str, 
-        "id:  Tag\n"
-        "src: 0\n"
-        "set: true\n"
-        "this:\n"
-        "    - foo\n"
-    );
-    ecs_os_free(str);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Iter_filter_eval_count(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ Foo }}
-    });
-
-    test_assert(f != NULL);
-
-    test_int(f->eval_count, 0);
-
-    ecs_iter_t it = ecs_filter_iter(world, f);
-    test_bool(false, ecs_filter_next(&it));
-    
-    test_int(f->eval_count, 1);
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Iter_query_eval_count(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ Foo }}
-    });
-
-    test_assert(q != NULL);
-
-    const ecs_filter_t *f = ecs_query_get_filter(q);
-    test_int(f->eval_count, 0);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    test_int(f->eval_count, 1);
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Iter_rule_eval_count(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_rule_t *r = ecs_rule(world, {
-        .terms = {{ Foo }}
-    });
-
-    test_assert(r != NULL);
-
-    const ecs_filter_t *f = ecs_rule_get_filter(r);
-    test_int(f->eval_count, 0);
-
-    ecs_iter_t it = ecs_rule_iter(world, r);
-    test_bool(false, ecs_rule_next(&it));
-
-    test_int(f->eval_count, 1);
-
-    ecs_rule_fini(r);
-
-    ecs_fini(world);
-}
diff --git a/test/api/src/Poly.c b/test/api/src/Poly.c
deleted file mode 100644
index 9c7b3c3e1..000000000
--- a/test/api/src/Poly.c
+++ /dev/null
@@ -1,503 +0,0 @@
-#include <api.h>
-
-static ECS_COMPONENT_DECLARE(Position);
-static ECS_DECLARE(Tag);
-
-static
-void test_no_chain(
-    ecs_world_t *world,
-    ecs_poly_t *poly,
-    ecs_id_t filter)
-{
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {50, 60});
-
-    ecs_add(world, e3, Tag);
-
-    ecs_iter_t it;
-    if (filter) {
-        ecs_term_t term = { .id = filter };
-        ecs_iter_poly(world, poly, &it, &term);
-    } else {
-        ecs_iter_poly(world, poly, &it, NULL);
-    }
-
-    test_assert(ecs_iter_next(&it));
-    test_int(it.count, 2);
-    test_int(it.entities[0], e1);
-    test_int(it.entities[1], e2);
-    test_int(ecs_field_id(&it, 1), ecs_id(Position));
-    test_int(ecs_field_src(&it, 1), 0);
-    test_assert(it.table != NULL);
-
-    Position *ptr = ecs_field(&it, Position, 1);
-    test_assert(ptr != NULL);
-    test_int(ptr[0].x, 10);
-    test_int(ptr[0].y, 20);
-    test_int(ptr[1].x, 30);
-    test_int(ptr[1].y, 40);
-
-    test_assert(ecs_iter_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    test_int(ecs_field_id(&it, 1), ecs_id(Position));
-    test_int(ecs_field_src(&it, 1), 0);
-    test_assert(it.table != NULL);
-
-    ptr = ecs_field(&it, Position, 1);
-    test_assert(ptr != NULL);
-    test_int(ptr[0].x, 50);
-    test_int(ptr[0].y, 60);
-
-    test_assert(!ecs_iter_next(&it));
-}
-
-static
-void test_w_chain(
-    ecs_world_t *world,
-    ecs_poly_t *poly)
-{
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_set(world, 0, Position, {50, 60}); // Not matched
-
-    ecs_add(world, e1, Tag);
-    ecs_add(world, e2, Tag);
-
-    ecs_iter_t it_arr[2];
-    ecs_iter_t *it = it_arr;
-    ecs_iter_poly(world, poly, it_arr, &(ecs_term_t){ .id = Tag});
-
-    test_assert(ecs_iter_next(it));
-    test_int(it->count, 2);
-    test_int(it->entities[0], e1);
-    test_int(it->entities[1], e2);
-    test_int(ecs_field_id(it, 1), Tag);
-    test_int(ecs_field_src(it, 1), 0);
-    test_assert(it->table != NULL);
-
-    ecs_iter_t *chain_it = it->chain_it;
-    test_assert(chain_it != NULL);
-    
-    test_int(chain_it->count, 2);
-    test_int(chain_it->entities[0], e1);
-    test_int(chain_it->entities[1], e2);
-    test_int(ecs_field_id(chain_it, 1), ecs_id(Position));
-    test_int(ecs_field_src(chain_it, 1), 0);
-
-    Position *ptr = ecs_field(chain_it, Position, 1);
-    test_assert(ptr != NULL);
-    test_int(ptr[0].x, 10);
-    test_int(ptr[0].y, 20);
-    test_int(ptr[1].x, 30);
-    test_int(ptr[1].y, 40);
-
-    test_assert(!ecs_iter_next(it));
-}
-
-void Poly_iter_query(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_TAG_DEFINE(world, Tag);
-    
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    test_no_chain(world, q, 0);
-
-    ecs_fini(world);
-}
-
-void Poly_iter_query_w_filter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_TAG_DEFINE(world, Tag);
-    
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    test_w_chain(world, q);
-
-    ecs_fini(world);
-}
-
-void Poly_iter_world(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_TAG_DEFINE(world, Tag);
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {50, 60});
-    ecs_add(world, e3, Tag);
-
-    bool e1_found = false;
-    bool e2_found = false;
-    bool e3_found = false;
-    bool position_found = false;
-    bool tag_found = false;
-
-    ecs_iter_t it;
-    ecs_iter_poly(world, world, &it, 0);
-
-    test_assert(ecs_iter_next(&it));
-    test_assert(it.count != 0); 
-
-    int i;
-    for (i = 0; i < it.count; i ++) {
-        test_assert( ecs_is_alive(world, it.entities[i]));
-        if (it.entities[i] == e1) e1_found = true;
-        if (it.entities[i] == e2) e2_found = true;
-        if (it.entities[i] == e3) e3_found = true;
-        if (it.entities[i] == ecs_id(Position)) position_found = true;
-        if (it.entities[i] == Tag) tag_found = true;
-    }
-
-    test_assert(!ecs_iter_next(&it));
-
-    test_assert(e1_found);
-    test_assert(e2_found);
-    test_assert(e3_found);
-    test_assert(position_found);
-    test_assert(tag_found);
-
-    ecs_fini(world);
-}
-
-void Poly_iter_world_w_filter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_TAG_DEFINE(world, Tag);
-
-    test_no_chain(world, world, ecs_id(Position));
-
-    ecs_fini(world);
-}
-
-void Poly_iter_rule(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_TAG_DEFINE(world, Tag);
-    
-    ecs_rule_t *q = ecs_rule_new(world, "Position");
-    test_assert(q != NULL);
-
-    test_no_chain(world, q, 0);
-
-    ecs_rule_fini(q);
-
-    ecs_fini(world);
-}
-
-void Poly_iter_rule_w_filter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_TAG_DEFINE(world, Tag);
-    
-    ecs_rule_t *q = ecs_rule_new(world, "Position");
-    test_assert(q != NULL);
-
-    test_w_chain(world, q);
-
-    ecs_rule_fini(q);
-
-    ecs_fini(world);
-}
-
-void Poly_iter_filter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_TAG_DEFINE(world, Tag);
-
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
-        .expr = "Position"});
-    test_assert(f != NULL);
-
-    test_no_chain(world, f, 0);
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-void Poly_iter_filter_w_filter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT_DEFINE(world, Position);
-    ECS_TAG_DEFINE(world, Tag);
-    
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
-        .expr = "Position"});
-    test_assert(f != NULL);
-
-    test_w_chain(world, f);
-
-    ecs_filter_fini(f);
-
-    ecs_fini(world);
-}
-
-static
-void FooTrigger(ecs_iter_t *it) {}
-
-static
-void PolyTrigger(ecs_iter_t *it) {
-    probe_system_w_ctx(it, it->ctx);
-
-    EcsPoly *poly = ecs_field(it, EcsPoly, 1);
-
-    test_int(1, it->count);
-    test_assert(poly->poly != NULL);
-}
-
-void Poly_on_set_poly_observer(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t tag = ecs_new_id(world);
-
-    Probe ctx = {0};
-    ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { ecs_pair(ecs_id(EcsPoly), EcsObserver) },
-        .events = { EcsOnSet },
-        .callback = PolyTrigger,
-        .ctx = &ctx
-    });
-
-    test_int(1, ctx.invoked);
-
-    ecs_os_zeromem(&ctx);
-
-    ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ tag }},
-        .events = { EcsOnAdd },
-        .callback = FooTrigger
-    });
-
-    test_int(1, ctx.invoked);
-    test_int(1, ctx.count);
-    test_uint(t, ctx.e[0]);
-
-    ecs_fini(world);
-}
-
-void Poly_on_set_poly_query(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t tag = ecs_new_id(world);
-
-    Probe ctx = {0};
-    ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { ecs_pair(ecs_id(EcsPoly), EcsQuery) },
-        .events = { EcsOnSet },
-        .callback = PolyTrigger,
-        .ctx = &ctx
-    });
-
-    test_int(0, ctx.invoked);
-
-    ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ tag }},
-    });
-
-    test_int(1, ctx.invoked);
-    test_int(1, ctx.count);
-
-    ecs_fini(world);
-}
-
-void Poly_on_set_poly_system(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t tag = ecs_new_id(world);
-
-    Probe ctx = {0};
-    ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { ecs_pair(ecs_id(EcsPoly), EcsSystem) },
-        .events = { EcsOnSet },
-        .callback = PolyTrigger,
-        .ctx = &ctx
-    });
-
-    test_int(0, ctx.invoked);
-
-    ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .query.filter.terms = {{ tag }},
-        .callback = FooTrigger
-    });
-
-    test_int(1, ctx.invoked);
-    test_int(1, ctx.count);
-    test_uint(s, ctx.e[0]);
-
-    ecs_fini(world);
-}
-
-void Poly_iter_filter_from_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new(world, Tag);
-
-    ecs_entity_t qe = ecs_new_id(world);
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ Tag }},
-        .entity = qe
-    });
-
-    test_assert(f->entity == qe);
-
-    const EcsPoly *poly = ecs_get_pair(world, qe, EcsPoly, EcsQuery);
-    test_assert(poly != NULL);
-    test_assert(poly->poly == f);
-
-    ecs_iter_t it;
-    ecs_iter_poly(world, poly->poly, &it, NULL);
-
-    test_bool(true, ecs_iter_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e);
-    test_bool(false, ecs_iter_next(&it));
-
-    ecs_filter_fini(f);
-
-    test_assert(!ecs_is_alive(world, qe));
-
-    ecs_fini(world);
-}
-
-void Poly_iter_query_from_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new(world, Tag);
-
-    ecs_entity_t qe = ecs_new_id(world);
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ Tag }},
-        .filter.entity = qe
-    });
-
-    const EcsPoly *poly = ecs_get_pair(world, qe, EcsPoly, EcsQuery);
-    test_assert(poly != NULL);
-    test_assert(poly->poly == q);
-
-    ecs_iter_t it;
-    ecs_iter_poly(world, poly->poly, &it, NULL);
-
-    test_bool(true, ecs_iter_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e);
-    test_bool(false, ecs_iter_next(&it));
-
-    ecs_query_fini(q);
-
-    test_assert(!ecs_is_alive(world, qe));
-
-    ecs_fini(world);
-}
-
-void Poly_iter_rule_from_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new(world, Tag);
-
-    ecs_entity_t qe = ecs_new_id(world);
-    ecs_rule_t *q = ecs_rule(world, {
-        .terms = {{ Tag }},
-        .entity = qe
-    });
-
-    const EcsPoly *poly = ecs_get_pair(world, qe, EcsPoly, EcsQuery);
-    test_assert(poly != NULL);
-    test_assert(poly->poly == q);
-
-    ecs_iter_t it;
-    ecs_iter_poly(world, poly->poly, &it, NULL);
-
-    test_bool(true, ecs_iter_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e);
-    test_bool(false, ecs_iter_next(&it));
-
-    ecs_rule_fini(q);
-
-    test_assert(!ecs_is_alive(world, qe));
-
-    ecs_fini(world);
-}
-
-void Poly_free_filter_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t qe = ecs_new_id(world);
-    ecs_filter_t *f = ecs_filter(world, {
-        .terms = {{ Tag }},
-        .entity = qe
-    });
-
-    test_assert(f->entity == qe);
-
-    const EcsPoly *poly = ecs_get_pair(world, qe, EcsPoly, EcsQuery);
-    test_assert(poly != NULL);
-    test_assert(poly->poly == f);
-
-    ecs_delete(world, qe);
-
-    ecs_fini(world);
-}
-
-void Poly_free_query_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t qe = ecs_new_id(world);
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{ Tag }},
-        .filter.entity = qe
-    });
-
-    const EcsPoly *poly = ecs_get_pair(world, qe, EcsPoly, EcsQuery);
-    test_assert(poly != NULL);
-    test_assert(poly->poly == q);
-
-    ecs_delete(world, qe);
-
-    test_assert(!ecs_is_alive(world, qe));
-
-    ecs_fini(world);
-}
-
-void Poly_free_rule_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t qe = ecs_new_id(world);
-    ecs_rule_t *q = ecs_rule(world, {
-        .terms = {{ Tag }},
-        .entity = qe
-    });
-
-    const EcsPoly *poly = ecs_get_pair(world, qe, EcsPoly, EcsQuery);
-    test_assert(poly != NULL);
-    test_assert(poly->poly == q);
-
-    ecs_delete(world, qe);
-
-    ecs_fini(world);
-}
diff --git a/test/api/src/Query.c b/test/api/src/Query.c
deleted file mode 100644
index bb36f09ea..000000000
--- a/test/api/src/Query.c
+++ /dev/null
@@ -1,9945 +0,0 @@
-#include <api.h>
-#include <stdlib.h>
-
-static
-int order_by_entity(
-    ecs_entity_t e1,
-    const void *ptr1,
-    ecs_entity_t e2,
-    const void *ptr2)
-{
-    return (e1 > e2) - (e1 < e2);
-}
-
-static
-uint64_t group_by_first_id(
-    ecs_world_t *world,
-    ecs_table_t *table,
-    ecs_id_t id,
-    void *ctx)
-{
-    const ecs_type_t *type = ecs_table_get_type(table);
-    ecs_id_t *first = type->array;
-    if (!first) {
-        return 0;
-    }
-
-    return first[0];
-}
-
-static
-uint64_t group_by_rel(ecs_world_t *world, ecs_table_t *table, ecs_id_t id, void *ctx) {
-    ecs_id_t match;
-    if (ecs_search(world, table, ecs_pair(id, EcsWildcard), &match) != -1) {
-        return ecs_pair_second(world, match);
-    }
-    return 0;
-}
-
-void Query_simple_query_existing_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_simple_query_2_existing_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_simple_query_new_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA");
-    test_assert(q != NULL);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_simple_query_2_new_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_simple_query_existing_and_new_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA");
-    test_assert(q != NULL);
-
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_wildcard_query_existing_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, ObjA);
-    ECS_TAG(world, ObjB);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
-
-    ecs_query_t *q = ecs_query_new(world, "(Rel, *)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_wildcard_query_new_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, ObjA);
-    ECS_TAG(world, ObjB);
-
-    ecs_query_t *q = ecs_query_new(world, "(Rel, *)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_wildcard_query_existing_table_2_results_p_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, ObjA);
-    ECS_TAG(world, ObjB);
-    ECS_TAG(world, ObjC);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
-    ecs_add_pair(world, e1, Rel, ObjC);
-    ecs_add_pair(world, e2, Rel, ObjC);
-
-    ecs_query_t *q = ecs_query_new(world, "(Rel, *)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjC), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjC), ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_wildcard_query_new_table_2_results_p_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, ObjA);
-    ECS_TAG(world, ObjB);
-    ECS_TAG(world, ObjC);
-
-    ecs_query_t *q = ecs_query_new(world, "(Rel, *)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
-    ecs_add_pair(world, e1, Rel, ObjC);
-    ecs_add_pair(world, e2, Rel, ObjC);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjC), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, ObjC), ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_wildcard_query_2nd_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_add_pair(world, e1, Rel, TgtA);
-    ecs_add_pair(world, e1, Rel, TgtB);
-
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_add_pair(world, e2, Rel, TgtA);
-
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_add_pair(world, e3, Rel, TgtA);
-    ecs_add_pair(world, e3, Rel, TgtC);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ Tag }, { ecs_pair(Rel, EcsWildcard) }}
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtB), it.ids[1]);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtC), it.ids[1]);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_wildcard_query_2nd_term_self(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_add_pair(world, e1, Rel, TgtA);
-    ecs_add_pair(world, e1, Rel, TgtB);
-
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_add_pair(world, e2, Rel, TgtA);
-
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_add_pair(world, e3, Rel, TgtA);
-    ecs_add_pair(world, e3, Rel, TgtC);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ Tag }, { ecs_pair(Rel, EcsWildcard), .src.flags = EcsSelf }}
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtB), it.ids[1]);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(Tag, it.ids[0]);
-    test_uint(ecs_pair(Rel, TgtC), it.ids[1]);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_simple_query_existing_empty_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_add(world, e1, TagB);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA");
-    test_assert(q != NULL);
-
-    ecs_remove(world, e1, TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_simple_query_existing_empty_type(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_PREFAB(world, TypeX, TagA, TagB);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_add(world, e1, TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_simple_query_new_empty_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_add(world, e1, TagB);
-    ecs_remove(world, e1, TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_component_query_existing_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_assert(ecs_field_size(&it, 1) == sizeof(Position));
-    test_assert(ecs_field(&it, Position, 1) != NULL);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_component_query_new_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_entity_t e = ecs_new(world, Position);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-    test_assert(ecs_field(&it, Position, 1) != NULL);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_component_query_existing_empty_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e = ecs_new(world, Position);
-    ecs_add(world, e, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_remove(world, e, TagA);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-    test_assert(ecs_field(&it, Position, 1) != NULL);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_2_component_query_existing_empty_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_TAG(world, Tag);
-    ECS_PREFAB(world, MyType, Position, Velocity);
-
-    ecs_entity_t e = ecs_new(world, Position);
-    ecs_add(world, e, Velocity);
-    ecs_add(world, e, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    test_assert(q != NULL);
-
-    ecs_remove(world, e, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-    test_assert(ecs_field(&it, Position, 1) != NULL);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_2_component_query_existing_empty_type(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_PREFAB(world, MyType, Position, Velocity);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    test_assert(q != NULL);
-
-    ecs_entity_t e = ecs_new(world, Position);
-    ecs_add(world, e, Velocity);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    test_uint(ecs_field_size(&it, 1), sizeof(Position));
-    test_assert(ecs_field(&it, Position, 1) != NULL);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_only_optional(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "?TagA");
-    test_assert(q != NULL);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-    int32_t count = 0;
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        if (ecs_field_is_set(&it, 1)) {
-            test_assert(count == 0);
-            test_int(it.count, 1);
-            test_uint(it.entities[0], e);
-            count ++;
-        }
-    }
-
-    test_int(count, 1);
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_only_optional_new_empty_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "?TagA");
-    test_assert(q != NULL);
-
-    int32_t count = 0, total_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        if (ecs_field_is_set(&it, 1)) {
-            test_assert(count == 0);
-            test_int(it.count, 1);
-            test_uint(it.entities[0], e);
-            count ++;
-        }
-        total_count ++;
-    }
-
-    test_int(count, 1);
-    test_assert(total_count >= count);
-
-    int32_t prev_total_count = total_count;
-    total_count = 0;
-
-    ecs_remove(world, e, TagA);
-
-    it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(!ecs_field_is_set(&it, 1));
-        test_assert(it.count > 0);
-        total_count ++;
-    }
-
-    test_assert(total_count == (prev_total_count - 1));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_only_optional_new_empty_non_empty_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-    ecs_add(world, e, TagB);
-
-    ecs_query_t *q = ecs_query_new(world, "?TagA");
-    test_assert(q != NULL);
-
-    int32_t count = 0, total_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        if (ecs_field_is_set(&it, 1)) {
-            test_assert(count == 0);
-            test_int(it.count, 1);
-            test_uint(it.entities[0], e);
-            count ++;
-        }
-        total_count ++;
-    }
-
-    test_int(count, 1);
-    test_assert(total_count >= count);
-
-    int32_t prev_total_count = total_count;
-    count = 0; total_count = 0;
-
-    ecs_remove(world, e, TagA);
-    ecs_table_t *table = ecs_get_table(world, e);
-
-    it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(!ecs_field_is_set(&it, 1));
-        test_assert(it.count > 0);
-        total_count ++;
-        if (it.entities[0] == e) {
-            test_assert(table == it.table);
-            count ++;
-        }
-    }
-
-    test_int(count, 1);
-    test_assert(total_count == prev_total_count);
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_only_optional_new_unset_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-    ecs_add(world, e, TagB);
-    ecs_table_t *table = ecs_get_table(world, e);
-
-    ecs_query_t *q = ecs_query_new(world, "?TagC");
-    test_assert(q != NULL);
-
-    int32_t count = 0, total_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(!ecs_field_is_set(&it, 1));
-        test_assert(it.count > 0);
-        if (it.entities[0] == e) {
-            test_assert(table == it.table);
-            count ++;
-        }
-        total_count ++;
-    }
-
-    test_int(count, 1);
-    test_assert(total_count >= count);
-
-    int32_t prev_total_count = total_count;
-    count = 0; total_count = 0;
-
-    ecs_remove(world, e, TagA);
-    table = ecs_get_table(world, e);
-
-    it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(!ecs_field_is_set(&it, 1));
-        test_assert(it.count > 0);
-        total_count ++;
-        if (it.entities[0] == e) {
-            test_assert(table == it.table);
-            count ++;
-        }
-    }
-
-    test_int(count, 1);
-    test_assert(total_count == prev_total_count);
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_singleton_w_optional_new_empty_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Singleton);
-    ECS_TAG(world, TagA);
-
-    ecs_singleton_add(world, Singleton);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-    ecs_set_name(world, e, "e");
-
-    ecs_query_t *q = ecs_query_new(world, "Singleton($), ?TagA");
-    test_assert(q != NULL);
-
-    int32_t count = 0, total_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        if (ecs_field_is_set(&it, 2)) {
-            test_assert(count == 0);
-            test_int(it.count, 1);
-            test_uint(it.entities[0], e);
-            count ++;
-        }
-        total_count ++;
-    }
-
-    test_int(count, 1);
-    test_assert(total_count >= count);
-
-    int32_t prev_total_count = total_count;
-    total_count = 0;
-
-    ecs_remove(world, e, TagA);
-
-    it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(!ecs_field_is_set(&it, 2));
-        test_assert(it.count > 0);
-        total_count ++;
-    }
-
-    test_assert(total_count == (prev_total_count - 1));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_singleton_w_optional_new_empty_non_empty_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Singleton);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_singleton_add(world, Singleton);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-    ecs_add(world, e, TagB);
-
-    ecs_query_t *q = ecs_query_new(world, "Singleton($), ?TagA");
-    test_assert(q != NULL);
-
-    int32_t count = 0, total_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        if (ecs_field_is_set(&it, 2)) {
-            test_assert(count == 0);
-            test_int(it.count, 1);
-            test_uint(it.entities[0], e);
-            count ++;
-        }
-        total_count ++;
-    }
-
-    test_int(count, 1);
-    test_assert(total_count >= count);
-
-    int32_t prev_total_count = total_count;
-    count = 0; total_count = 0;
-
-    ecs_remove(world, e, TagA);
-    ecs_table_t *table = ecs_get_table(world, e);
-
-    it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(!ecs_field_is_set(&it, 2));
-        test_assert(it.count > 0);
-        total_count ++;
-        if (it.entities[0] == e) {
-            test_assert(table == it.table);
-            count ++;
-        }
-    }
-
-    test_int(count, 1);
-    test_assert(total_count == prev_total_count);
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_singleton_w_optional_new_unset_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Singleton);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_singleton_add(world, Singleton);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-    ecs_add(world, e, TagB);
-    ecs_table_t *table = ecs_get_table(world, e);
-
-    ecs_query_t *q = ecs_query_new(world, "Singleton($), ?TagC");
-    test_assert(q != NULL);
-
-    int32_t count = 0, total_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(!ecs_field_is_set(&it, 2));
-        test_assert(it.count > 0);
-        if (it.entities[0] == e) {
-            test_assert(table == it.table);
-            count ++;
-        }
-        total_count ++;
-    }
-
-    test_int(count, 1);
-    test_assert(total_count >= count);
-
-    int32_t prev_total_count = total_count;
-    count = 0; total_count = 0;
-
-    ecs_remove(world, e, TagA);
-    table = ecs_get_table(world, e);
-
-    it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(!ecs_field_is_set(&it, 2));
-        test_assert(it.count > 0);
-        total_count ++;
-        if (it.entities[0] == e) {
-            test_assert(table == it.table);
-            count ++;
-        }
-    }
-
-    test_int(count, 1);
-    test_assert(total_count == prev_total_count);
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new_entity(world, "e");
-    ecs_add(world, e, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(e)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 0);
-    test_uint(ecs_field_src(&it, 1), e);
-    test_uint(ecs_field_id(&it, 1), Tag);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_entity_no_match(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new_entity(world, "e");
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(e)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_add(world, e, Tag);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 0);
-    test_uint(ecs_field_src(&it, 1), e);
-    test_uint(ecs_field_id(&it, 1), Tag);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_entity_no_match_iter_alloc(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, A);
-    ECS_TAG(world, B);
-    ECS_TAG(world, C);
-    ECS_TAG(world, D);
-    ECS_TAG(world, E);
-
-    ecs_new_entity(world, "e");
-
-    ecs_query_t *q = ecs_query_new(world, "A(e), B(e), C(e), D(e), E(e)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_singleton_add(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag($)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 0);
-    test_uint(ecs_field_src(&it, 1), Tag);
-    test_uint(ecs_field_id(&it, 1), Tag);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_entity_match_after(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new_entity(world, "e");
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(e)");
-    test_assert(q != NULL);
-    
-    ecs_add(world, e, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 0);
-    test_uint(ecs_field_src(&it, 1), e);
-    test_uint(ecs_field_id(&it, 1), Tag);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_singleton_match_after(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag($)");
-    test_assert(q != NULL);
-    
-    ecs_singleton_add(world, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 0);
-    test_uint(ecs_field_src(&it, 1), Tag);
-    test_uint(ecs_field_id(&it, 1), Tag);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_singleton_component_match_after(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position($)");
-    test_assert(q != NULL);
-    
-    ecs_singleton_add(world, Position);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 0);
-    test_uint(ecs_field_src(&it, 1), ecs_id(Position));
-    test_uint(ecs_field_id(&it, 1), ecs_id(Position));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_nothing(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag()");
-    test_assert(q != NULL);
-    
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 0);
-    test_uint(ecs_field_id(&it, 1), Tag);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_entity_optional(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_ENTITY(world, Ent, Position);
-
-    ecs_set(world, Ent, Position, {10, 20});
-
-    ecs_query_t *q = ecs_query_new(world, "?Position(Ent)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 0);
-
-    test_bool(ecs_field_is_set(&it, 1), true);
-    
-    Position *ptr = ecs_field(&it, Position, 1);
-    test_assert(ptr != NULL);
-    test_int(ptr->x, 10);
-    test_int(ptr->y, 20);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_entity_no_match_optional(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_new_entity(world, "Ent");
-
-    ecs_query_t *q = ecs_query_new(world, "?Position(Ent)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 0);
-    test_bool(ecs_field_is_set(&it, 1), false);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_entity_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t Ent = ecs_new_entity(world, "Ent");
-    ecs_set(world, Ent, Position, {10, 20});
-
-    ecs_query_t *q = ecs_query_new(world, "Position(Ent) || Velocity(Ent)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 0);
-
-    test_bool(ecs_field_is_set(&it, 1), true);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_entity_no_match_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ECS_ENTITY(world, Ent, Mass);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(Ent) || Velocity(Ent)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_from_entity_or_change(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t Ent = ecs_new_entity(world, "Ent");
-    ecs_set(world, Ent, Position, {10, 20});
-
-    ecs_query_t *q = ecs_query_new(world, "Position(Ent) || Velocity(Ent)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 0);
-
-    test_bool(ecs_field_is_set(&it, 1), true);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(Ent, it.sources[0]);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_remove(world, Ent, Position);
-    ecs_set(world, Ent, Velocity, {1, 2});
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 0);
-
-    test_bool(ecs_field_is_set(&it, 1), true);
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
-    test_uint(Ent, it.sources[0]);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_from_entity_or_change(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t Ent = ecs_new_entity(world, "Ent");
-    ecs_set(world, Ent, Position, {10, 20});
-
-    ecs_entity_t e = ecs_new(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(Ent) || Velocity(Ent), Tag");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-
-    test_bool(ecs_field_is_set(&it, 1), true);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 2));
-    test_uint(e, it.entities[0]);
-    test_uint(Ent, it.sources[0]);
-    test_uint(0, it.sources[1]);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_remove(world, Ent, Position);
-    ecs_set(world, Ent, Velocity, {1, 2});
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-
-    test_bool(ecs_field_is_set(&it, 1), true);
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
-    test_uint(Tag, ecs_field_id(&it, 2));
-    test_uint(e, it.entities[0]);
-    test_uint(Ent, it.sources[0]);
-    test_uint(0, it.sources[1]);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_from_entity_w_superset(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_entity_t g = ecs_new_entity(world, "Game");
-    ecs_set(world, g, Position, {10, 20});
-    ecs_set(world, g, Velocity, {1, 2});
-
-    ecs_entity_t p = ecs_new_w_id(world, EcsPrefab);
-    ecs_set(world, p, Mass, {30});
-    ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, p);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            { .id = ecs_id(Velocity), .src.name = "Game" },
-            { .id = ecs_id(Mass), .src.flags = EcsUp }
-        }
-    });
-
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_singleton_tag_non_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Singleton);
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_add(world, Singleton);
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Singleton($)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(4, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(e2, it.entities[1]);
-    test_uint(e3, it.entities[2]);
-    test_uint(e4, it.entities[3]);
-    test_uint(0, it.sources[0]);
-    test_uint(Singleton, it.sources[1]);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-    test_int(p[2].x, 30);
-    test_int(p[2].y, 40);
-    test_int(p[3].x, 40);
-    test_int(p[3].y, 50);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_singleton_tag_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Singleton);
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_add(world, Singleton);
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .expr = "Position, Singleton($)",
-        .instanced = true
-    }});
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(4, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(e2, it.entities[1]);
-    test_uint(e3, it.entities[2]);
-    test_uint(e4, it.entities[3]);
-    test_uint(0, it.sources[0]);
-    test_uint(Singleton, it.sources[1]);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-    test_int(p[2].x, 30);
-    test_int(p[2].y, 40);
-    test_int(p[3].x, 40);
-    test_int(p[3].y, 50);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_singleton_component_non_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity($)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    Position *p;
-    Velocity *v;
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(0, it.sources[0]);
-    test_uint(ecs_id(Velocity), it.sources[1]);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    v = ecs_field(&it, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(true, ecs_query_next(&it));
-
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(0, it.sources[0]);
-    test_uint(ecs_id(Velocity), it.sources[1]);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 20);
-    test_int(p[0].y, 30);
-    v = ecs_field(&it, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(true, ecs_query_next(&it));
-
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(0, it.sources[0]);
-    test_uint(ecs_id(Velocity), it.sources[1]);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    v = ecs_field(&it, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_bool(true, ecs_query_next(&it));
-
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(0, it.sources[0]);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 40);
-    test_int(p[0].y, 50);
-    v = ecs_field(&it, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-    test_uint(ecs_id(Velocity), it.sources[1]);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_singleton_component_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .expr = "Position, Velocity($)",
-        .instanced = true
-    }});
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(4, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(e2, it.entities[1]);
-    test_uint(e3, it.entities[2]);
-    test_uint(e4, it.entities[3]);
-    test_uint(0, it.sources[0]);
-    test_uint(ecs_id(Velocity), it.sources[1]);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-    test_int(p[2].x, 30);
-    test_int(p[2].y, 40);
-    test_int(p[3].x, 40);
-    test_int(p[3].y, 50);
-
-    Velocity *v = ecs_field(&it, Velocity, 2);
-    test_int(v[0].x, 1);
-    test_int(v[0].y, 2);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_from_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e");
-    ecs_add(world, e1, TagB);
-
-    ecs_entity_t e2 = ecs_new(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA, TagB(e)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(ecs_field_src(&it, 1), 0);
-    test_uint(ecs_field_id(&it, 1), TagA);
-    test_uint(ecs_field_src(&it, 2), e1);
-    test_uint(ecs_field_id(&it, 2), TagB);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_from_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_singleton_add(world, TagB);
-
-    ecs_entity_t e2 = ecs_new(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA, TagB($)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(ecs_field_src(&it, 1), 0);
-    test_uint(ecs_field_id(&it, 1), TagA);
-    test_uint(ecs_field_src(&it, 2), TagB);
-    test_uint(ecs_field_id(&it, 2), TagB);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_from_entity_match_after(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_entity(world, "e");
-    ecs_entity_t e2 = ecs_new(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA, TagB(e)");
-    test_assert(q != NULL);
-
-    ecs_add(world, e1, TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(ecs_field_src(&it, 1), 0);
-    test_uint(ecs_field_id(&it, 1), TagA);
-    test_uint(ecs_field_src(&it, 2), e1);
-    test_uint(ecs_field_id(&it, 2), TagB);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_from_singleton_match_after(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e2 = ecs_new(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA, TagB($)");
-    test_assert(q != NULL);
-
-    ecs_singleton_add(world, TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(ecs_field_src(&it, 1), 0);
-    test_uint(ecs_field_id(&it, 1), TagA);
-    test_uint(ecs_field_src(&it, 2), TagB);
-    test_uint(ecs_field_id(&it, 2), TagB);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_from_nothing(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e2 = ecs_new(world, TagA);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA, TagB()");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(ecs_field_src(&it, 1), 0);
-    test_uint(ecs_field_id(&it, 1), TagA);
-    test_uint(ecs_field_src(&it, 2), 0);
-    test_uint(ecs_field_id(&it, 2), TagB);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_existing_switch_and_case(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, *)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Movement, EcsWildcard));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_new_switch_and_case(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, *)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Running);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 3);
-    test_uint(it.entities[0], e1);
-    test_uint(it.entities[1], e2);
-    test_uint(it.entities[2], e3);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Movement, EcsWildcard));
-    test_assert(it.sizes != NULL);
-    test_int(it.sizes[0], ECS_SIZEOF(ecs_entity_t));
-    test_assert(it.ptrs != NULL);
-    ecs_entity_t *cases = ecs_field(&it, ecs_entity_t, 1);
-    test_uint(cases[0], Walking);
-    test_uint(cases[1], Running);
-    test_uint(cases[2], Walking);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_for_case_existing(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_new_w_pair(world, Movement, Running);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Movement, Walking));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Movement, Walking));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_for_case_new(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_new_w_pair(world, Movement, Running);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Movement, Walking));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Movement, Walking));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_case_w_generation(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Rel, Union);
-
-    ecs_entity_t tgt_1 = ecs_new_id(world);
-    ecs_delete(world, tgt_1);
-    tgt_1 = ecs_new_id(world);
-    test_assert(tgt_1 != (uint32_t)tgt_1);
-
-    ecs_entity_t tgt_2 = ecs_new_id(world);
-    ecs_delete(world, tgt_2);
-    tgt_2 = ecs_new_id(world);
-    test_assert(tgt_2 != (uint32_t)tgt_2);
-
-    ecs_query_t *q = ecs_query_new(world, "(Rel, *)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, tgt_1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, tgt_2);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(true, ecs_query_next(&it));
-        test_int(it.count, 2);
-        test_uint(it.entities[0], e1);
-        test_uint(it.entities[1], e2);
-        test_uint(ecs_field_id(&it, 1), ecs_pair(Rel, EcsWildcard));
-        ecs_entity_t *cases = ecs_field(&it, ecs_entity_t, 1);
-        test_assert(cases != NULL);
-        test_uint(cases[0], tgt_1);
-        test_uint(cases[1], tgt_2);
-    }
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_case_w_not_alive(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Rel, Union);
-
-    ecs_entity_t tgt_1 = ecs_new_id(world);
-    ecs_delete(world, tgt_1);
-    tgt_1 = ecs_new_id(world);
-    test_assert(tgt_1 != (uint32_t)tgt_1);
-
-    ecs_entity_t tgt_2 = ecs_new_id(world);
-    ecs_delete(world, tgt_2);
-    tgt_2 = ecs_new_id(world);
-    test_assert(tgt_2 != (uint32_t)tgt_2);
-
-    ecs_query_t *q = ecs_query_new(world, "(Rel, *)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, tgt_1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, tgt_2);
-
-    ecs_delete(world, tgt_1);
-    ecs_delete(world, tgt_2);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(true, ecs_query_next(&it));
-        test_int(it.count, 2);
-        test_uint(it.entities[0], e1);
-        test_uint(it.entities[1], e2);
-        test_uint(ecs_field_id(&it, 1), ecs_pair(Rel, EcsWildcard));
-        ecs_entity_t *cases = ecs_field(&it, ecs_entity_t, 1);
-        test_assert(cases != NULL);
-        test_uint(cases[0], tgt_1);
-        test_uint(cases[1], tgt_2);
-    }
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_for_switch_filter_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_query_t *q = ecs_query_new(world, "[none] (Movement, *)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Movement, EcsWildcard));
-    test_int(it.sizes[0], ECS_SIZEOF(ecs_entity_t));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_switch_from_nothing(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .terms = {
-            {Tag},
-            { ecs_pair(Movement, EcsWildcard), .src.flags = EcsIsEntity }
-        }
-    }});
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_id(world, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(ecs_field_id(&it, 1), Tag);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(Movement, EcsWildcard));
-    test_bool(true, ecs_field_is_set(&it, 1));
-    test_bool(false, ecs_field_is_set(&it, 2));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_case_from_nothing(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .terms = {
-            {Tag},
-            {ecs_pair(Movement, Walking), .src.flags = EcsIsEntity }
-        }
-    }});
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_id(world, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(ecs_field_id(&it, 1), Tag);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(Movement, Walking));
-    test_bool(true, ecs_field_is_set(&it, 1));
-    test_bool(false, ecs_field_is_set(&it, 2));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_case_inherited(void) {
-    test_quarantine("Aug 1st 2022");
-
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_entity_t base_1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_entity_t inst_1 = ecs_new_w_pair(world, EcsIsA, base_1);
-
-    ecs_entity_t base_2 = ecs_new_w_pair(world, Movement, Running);
-    ecs_new_w_pair(world, EcsIsA, base_2);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .terms = {
-            { ecs_pair(Movement, Walking) }
-        }
-    }});
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], base_1);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Movement, Walking));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst_1);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(Movement, Walking));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_disabled_from_nothing(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .terms = {
-            {TagA},
-            {TagB, .src.flags = EcsIsEntity}
-        }
-    }});
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_id(world, TagA);
-    ecs_add(world, e1, TagB);
-    ecs_add_id(world, e1, ECS_TOGGLE | TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(ecs_field_id(&it, 1), TagA);
-    test_uint(ecs_field_id(&it, 2), TagB);
-    test_bool(true, ecs_field_is_set(&it, 1));
-    test_bool(false, ecs_field_is_set(&it, 2));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_2_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA || TagB");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_entity_t e3 = ecs_new(world, TagB);
-    ecs_new(world, TagC);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(TagB, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_only_3_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, TagD);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .expr = "TagA || TagB || TagC"
-    }});
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_entity_t e3 = ecs_new(world, TagB);
-    ecs_entity_t e4 = ecs_new(world, TagC);
-    ecs_new(world, TagD);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(TagB, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(TagC, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_query_2_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, Foo);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .expr = "TagA || TagB, Foo"
-    }});
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_entity_t e3 = ecs_new(world, TagB);
-
-    ecs_add(world, e1, Foo);
-    ecs_add(world, e2, Foo);
-    ecs_add(world, e3, Foo);
-
-    ecs_new(world, TagB);
-    ecs_new(world, TagC);
-    ecs_new(world, Foo);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(TagB, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_query_3_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, Foo);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .expr =  "TagA || TagB || TagC, Foo"
-    }});
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_entity_t e3 = ecs_new(world, TagB);
-    ecs_add(world, e3, TagC);
-    ecs_entity_t e4 = ecs_new(world, TagC);
-
-    ecs_add(world, e1, Foo);
-    ecs_add(world, e2, Foo);
-    ecs_add(world, e3, Foo);
-    ecs_add(world, e4, Foo);
-
-    ecs_new(world, TagB);
-    ecs_new(world, TagC);
-    ecs_new(world, Foo);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(TagB, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(TagC, ecs_field_id(&it, 1));
-    test_uint(Foo, ecs_field_id(&it, 2));
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_query_and_type(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_PREFAB(world, TypeX, TagA, TagB);
-
-    ecs_entity_t e1 = ecs_new_w_id(world, TagA);
-    ecs_add(world, e1, TagB);
-    ecs_table_t *table1 = ecs_get_table(world, e1);
-
-    ecs_entity_t e2 = ecs_new_w_id(world, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e2, Foo);
-    ecs_table_t *table2 = ecs_get_table(world, e2);
-
-    /* Not matched */
-    ecs_new(world, TagA);
-    ecs_new(world, TagB);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .expr =  "AND | TypeX"
-    }});
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.ids[0], TypeX);
-    test_assert(it.table == table1);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.ids[0], TypeX);
-    test_assert(it.table == table2);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_query_or_type(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_PREFAB(world, TypeX, TagA, TagB);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_table_t *table1 = ecs_get_table(world, e1);
-
-    ecs_entity_t e2 = ecs_new(world, TagB);
-    ecs_table_t *table2 = ecs_get_table(world, e2);
-
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add(world, e3, TagB);
-    ecs_table_t *table3 = ecs_get_table(world, e3);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .expr =  "OR | TypeX"
-    }});
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.ids[0], TagA);
-    test_assert(it.table == table1);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.ids[0], TagB);
-    test_assert(it.table == table2);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.ids[0], TagA);
-    test_assert(it.table == table3);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_query_and_type_match_after(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_PREFAB(world, TypeX, TagA, TagB);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .expr =  "AND | TypeX"
-    }});
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_id(world, TagA);
-    ecs_add(world, e1, TagB);
-    ecs_table_t *table1 = ecs_get_table(world, e1);
-
-    ecs_entity_t e2 = ecs_new_w_id(world, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e2, Foo);
-    ecs_table_t *table2 = ecs_get_table(world, e2);
-
-    /* Not matched */
-    ecs_new(world, TagA);
-    ecs_new(world, TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.ids[0], TypeX);
-    test_assert(it.table == table1);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.ids[0], TypeX);
-    test_assert(it.table == table2);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_query_or_type_match_after(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_PREFAB(world, TypeX, TagA, TagB);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){ .filter = {
-        .expr =  "OR | TypeX"
-    }});
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_table_t *table1 = ecs_get_table(world, e1);
-
-    ecs_entity_t e2 = ecs_new(world, TagB);
-    ecs_table_t *table2 = ecs_get_table(world, e2);
-
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add(world, e3, TagB);
-    ecs_table_t *table3 = ecs_get_table(world, e3);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.ids[0], TagA);
-    test_assert(it.table == table1);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.ids[0], TagB);
-    test_assert(it.table == table2);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.ids[0], TagA);
-    test_assert(it.table == table3);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_after_new(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_new(world, Position);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_after_delete(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_delete(world, e1);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_after_add(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e1 = ecs_new(world, 0);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_add(world, e1, Position);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_after_remove(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_remove(world, e1, Position);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_after_set(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_set(world, e1, Position, {10, 20});
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_after_modified(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_modified(world, e1, Position);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Sys(ecs_iter_t *it) { }
-
-void Query_query_change_after_out_system(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_SYSTEM(world, Sys, EcsOnUpdate, [out] Position);
-    
-    ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_progress(world, 0);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_after_in_system(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_SYSTEM(world, Sys, EcsOnUpdate, [in] Position);
-    
-    ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_progress(world, 0);
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == false);
-    ecs_iter_fini(&it);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_after_modified_out_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    
-    ecs_entity_t e = ecs_new(world, Position);
-    ecs_add(world, e, Velocity);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position, [out] Velocity");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_set(world, e, Position, {10, 20});
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_set(world, e, Velocity, {1, 2});
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_check_iter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
-
-    ecs_add(world, e1, TagA);
-    ecs_add(world, e2, TagB);
-    ecs_add(world, e3, TagC);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { 
-        test_bool(ecs_query_changed(q, &it), true);
-    }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_modified(world, e1, Position);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);
-    test_bool(ecs_query_changed(q, &it), true);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-    test_bool(ecs_query_changed(q, &it), false);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    test_bool(ecs_query_changed(q, &it), false);
-    test_bool(ecs_query_changed(q, NULL), false);
-    test_bool(ecs_query_next(&it), false);
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == false);
-    while (ecs_query_next(&it)) { 
-        test_bool(ecs_query_changed(q, &it), false);
-    }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_modified(world, e2, Position);
-
-
-    it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);
-    test_bool(ecs_query_changed(q, &it), false);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-    test_bool(ecs_query_changed(q, &it), true);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    test_bool(ecs_query_changed(q, &it), false);
-    test_bool(ecs_query_changed(q, NULL), false);
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_check_iter_after_skip_read(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_set(world, e, Position, {10, 20});
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_assert(ecs_query_changed(q, &it) == true);
-    ecs_query_skip(&it);
-    test_bool(ecs_query_next(&it), false);
-
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_assert(ecs_query_changed(q, &it) == true);
-    test_bool(ecs_query_next(&it), false);
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_check_iter_after_skip_write(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_new(world, Position);
-
-    ecs_query_t *qw = ecs_query_new(world, "[out] Position");
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    it = ecs_query_iter(world, qw);
-    test_assert(ecs_query_changed(q, 0) == false);
-    test_bool(ecs_query_next(&it), true);
-    test_assert(ecs_query_changed(q, 0) == false);
-    ecs_query_skip(&it);
-    test_bool(ecs_query_next(&it), false);
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    it = ecs_query_iter(world, qw);
-    test_assert(ecs_query_changed(q, 0) == false);
-    test_bool(ecs_query_next(&it), true);
-    test_assert(ecs_query_changed(q, 0) == false);
-    test_bool(ecs_query_next(&it), false);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_assert(ecs_query_changed(q, &it) == true);
-    test_bool(ecs_query_next(&it), false);
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_parent_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t parent = ecs_new(world, Position);
-    ecs_new_w_pair(world, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position(parent)");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_set(world, parent, Position, {10, 20});
-
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_assert(ecs_query_changed(q, &it) == true);
-    test_bool(ecs_query_next(&it), false);
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_prefab_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t base = ecs_new(world, Position);
-    ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position(up)");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_set(world, base, Position, {10, 20});
-
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_assert(ecs_query_changed(q, &it) == true);
-    test_bool(ecs_query_next(&it), false);
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_parent_term_w_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t parent = ecs_new(world, Position);
-    ecs_add_id(world, parent, EcsPrefab);
-    ecs_new_w_pair(world, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position(parent), ?Prefab");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_set(world, parent, Position, {10, 20});
-
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_assert(ecs_query_changed(q, &it) == true);
-    test_bool(ecs_query_next(&it), false);
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_prefab_term_w_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t base = ecs_new(world, Position);
-    ecs_add_id(world, base, EcsPrefab);
-    ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_query_t *q = ecs_query_new(world, "[in] Position(up)");
-    test_assert(q != NULL);
-    test_assert(ecs_query_changed(q, 0) == true);
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_changed(q, 0) == true);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_set(world, base, Position, {10, 20});
-
-    test_assert(ecs_query_changed(q, 0) == true);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_assert(ecs_query_changed(q, &it) == true);
-    test_bool(ecs_query_next(&it), false);
-    test_assert(ecs_query_changed(q, 0) == false);
-
-    ecs_fini(world);
-}
-
-void Query_query_change_skip_non_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_TAG(world, Tag);
-    
-    ecs_entity_t base = ecs_new(world, Position);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_add(world, e1, Velocity);
-    ecs_add(world, e2, Velocity);
-    ecs_add(world, e3, Velocity);
-    ecs_add(world, e4, Velocity);
-
-    ecs_add(world, e3, Tag);
-    ecs_add(world, e4, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(up), [out] Velocity");
-    test_assert(q != NULL);
-
-    ecs_query_t *q_r = ecs_query_new(world, "Position(up), [in] Velocity");
-    test_assert(q_r != NULL);
-
-    test_assert(ecs_query_changed(q_r, 0) == true);
-    ecs_iter_t it = ecs_query_iter(world, q_r);
-    while (ecs_query_next(&it)) { }
-    test_assert(ecs_query_changed(q_r, 0) == false);
-
-    it = ecs_query_iter(world, q);
-    int32_t count = 0;
-
-    while (ecs_query_next(&it)) {
-        test_int(it.count, 1);
-
-        if (it.entities[0] == e1) {
-            ecs_query_skip(&it); /* Skip one entity in table 1 */
-        }
-        if (it.entities[0] == e3 || it.entities[0] == e4) {
-            ecs_query_skip(&it); /* Skip both entities in table 1 */
-        }
-
-        count ++;
-    }
-
-    test_int(count, 4);
-
-    test_bool(ecs_query_changed(q_r, NULL), true);
-    
-    it = ecs_query_iter(world, q_r);
-    count = 0;
-
-    while (ecs_query_next(&it)) {
-        test_int(it.count, 1);
-
-        if (it.entities[0] == e1 || it.entities[0] == e2) {
-            /* Table changed, not all entities were skipped */
-            test_bool( ecs_query_changed(0, &it), true );
-        }
-        if (it.entities[0] == e3 || it.entities[0] == e4) {
-            /* Table did not change, all entities were skipped */
-            test_bool( ecs_query_changed(0, &it), false );
-        }
-
-        count ++;
-    }
-
-    test_int(count, 4);
-
-    test_bool(ecs_query_changed(q_r, NULL), false);
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add(world, e, Position);
-    ecs_add(world, e, Velocity);
-    ecs_add(world, e, TagA);
-    ecs_add(world, e, TagB);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_id(Position), .inout = EcsIn },
-            { TagA, .oper = EcsOr },
-            { TagB },
-            { ecs_id(Velocity), .inout = EcsIn }
-        }
-    });
-    test_assert(q != NULL);
-    
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_set(world, e, Position, {10, 20});
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_set(world, e, Velocity, {10, 20});
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_or(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add(world, e1, Position);
-    ecs_add(world, e1, TagA);
-    ecs_add(world, e1, TagB);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add(world, e2, Velocity);
-    ecs_add(world, e2, TagA);
-    ecs_add(world, e2, TagB);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { TagA },
-            { ecs_id(Position), .inout = EcsIn, .oper = EcsOr },
-            { ecs_id(Velocity), .inout = EcsIn },
-            { TagB }
-        }
-    });
-    test_assert(q != NULL);
-
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_set(world, e1, Position, {10, 20});
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_set(world, e2, Velocity, {10, 20});
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add(world, e1, TagA);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { TagA }
-        }
-    });
-    test_assert(q != NULL);
-    
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_no_source(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add(world, e1, TagA);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { TagA },
-            { TagB, .src.flags = EcsIsEntity, .inout = EcsOut }
-        }
-    });
-    test_assert(q != NULL);
-    
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_no_source_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add(world, e1, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_id(Position), .inout = EcsIn },
-            { ecs_id(Velocity), .src.flags = EcsIsEntity, .inout = EcsOut }
-        }
-    });
-    test_assert(q != NULL);
-    
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_not_out(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add(world, e1, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_id(Position), .inout = EcsIn },
-            { ecs_id(Velocity), .inout = EcsOut, .oper = EcsNot }
-        }
-    });
-    test_assert(q != NULL);
-    
-    test_bool(true, ecs_query_changed(q, NULL));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(q, NULL));
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position)
-        }, {
-            .id = ecs_id(Velocity),
-            .src.id = ecs_id(Velocity)
-        }}
-    });
-
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(true, ecs_query_changed(NULL, &it));
-    test_uint(e, it.entities[0]);
-    Position *p = ecs_field(&it, Position, 1);
-    Velocity *v = ecs_field(&it, Velocity, 2);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    test_int(v->x, 1);
-    test_int(v->y, 2);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_only_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_set(world, Position, {1, 2});
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .src.id = ecs_id(Position)
-        }}
-    });
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(false, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_only_singleton_after_set(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_set(world, Position, {1, 2});
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position), .src.id = ecs_id(Position)
-        }}
-    });
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(false, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_singleton_set(world, Position, {3, 4});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 3);
-        test_int(p->y, 4);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_only_singleton_after_out_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_set(world, Position, {1, 2});
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position), .src.id = ecs_id(Position)
-        }}
-    });
-
-    ecs_query_t *q_write = ecs_query(world, {
-        .filter.terms = {
-            { ecs_id(Position), .inout = EcsOut }
-        }
-    });
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(false, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q_write);
-        test_bool(true, ecs_query_next(&it));
-        test_int(1, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        p->x = 3;
-        p->y = 4;
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 3);
-        test_int(p->y, 4);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_only_singleton_after_singleton_out_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_singleton_set(world, Position, {1, 2});
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position), .src.id = ecs_id(Position)
-        }}
-    });
-
-    ecs_query_t *q_write = ecs_query(world, {
-        .filter.terms = {
-            { ecs_id(Position), .src.id = ecs_id(Position), .inout = EcsOut }
-        }
-    });
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(false, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q_write);
-        test_bool(true, ecs_query_next(&it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        p->x = 3;
-        p->y = 4;
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(0, it.count);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 3);
-        test_int(p->y, 4);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_only_parent(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t parent = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .src.flags = EcsParent
-        }}
-    });
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(false, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_only_parent_after_set(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t parent = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .src.flags = EcsParent
-        }}
-    });
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(false, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_set(world, parent, Position, {3, 4});
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 3);
-        test_int(p->y, 4);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_only_parent_after_out_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t parent = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .src.flags = EcsParent
-        }}
-    });
-
-    ecs_query_t *q_write = ecs_query(world, {
-        .filter.terms = {
-            { ecs_id(Position), .inout = EcsOut }
-        }
-    });
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(false, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q_write);
-        test_bool(true, ecs_query_next(&it));
-        test_int(1, it.count);
-        test_uint(parent, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        p->x = 3;
-        p->y = 4;
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 3);
-        test_int(p->y, 4);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_fini(world);
-}
-
-void Query_query_changed_w_only_parent_after_parent_out_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t parent = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .src.flags = EcsParent
-        }}
-    });
-
-    ecs_query_t *q_write = ecs_query(world, {
-        .filter.terms = {
-            { ecs_id(Position), .src.flags = EcsParent, .inout = EcsOut }
-        }
-    });
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(false, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q_write);
-        test_bool(true, ecs_query_next(&it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        p->x = 3;
-        p->y = 4;
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    {
-        ecs_iter_t it = ecs_query_iter(world, q);
-        test_bool(true, ecs_query_next(&it));
-        test_bool(true, ecs_query_changed(NULL, &it));
-        test_int(1, it.count);
-        test_uint(child, it.entities[0]);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p->x, 3);
-        test_int(p->y, 4);
-        test_bool(false, ecs_query_next(&it));
-    }
-
-    ecs_fini(world);
-}
-
-void Query_subquery_match_existing(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_PREFAB(world, Type, Position, Velocity);
-
-    ecs_bulk_new(world, Position, 3);
-    ecs_bulk_new(world, Velocity, 3);
-    const ecs_id_t *ids = ecs_bulk_new(world, Position, 3);
-    ecs_add(world, ids[0], Velocity);
-    ecs_add(world, ids[1], Velocity);
-    ecs_add(world, ids[2], Velocity);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Velocity",
-        .parent = q
-    });
-    
-    test_assert(sq != NULL);
-
-    int32_t table_count = 0, entity_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-        entity_count += it.count;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_has(world, it.entities[i], Position));
-        }
-    }
-
-    test_int(table_count, 2);
-    test_int(entity_count, 6);
-
-    table_count = 0, entity_count = 0;
-    it = ecs_query_iter(world, sq);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-        entity_count += it.count;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_has(world, it.entities[i], Position));
-            test_assert(ecs_has(world, it.entities[i], Velocity));
-        }
-    } 
-
-    test_int(table_count, 1);
-    test_int(entity_count, 3); 
-
-     ecs_query_fini(sq); 
-
-    ecs_fini(world);
-}
-
-void Query_subquery_match_new(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Velocity",
-        .parent = q
-    });
-    test_assert(sq != NULL);
-
-    ecs_bulk_new(world, Position, 3);
-    ecs_bulk_new(world, Velocity, 3);
-    const ecs_id_t *ids = ecs_bulk_new(world, Position, 3);
-    ecs_add(world, ids[0], Velocity);
-    ecs_add(world, ids[1], Velocity);
-    ecs_add(world, ids[2], Velocity);
-
-    int32_t table_count = 0, entity_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-        entity_count += it.count;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_has(world, it.entities[i], Position));
-        }
-    }
-
-    test_int(table_count, 2);
-    test_int(entity_count, 6);
-
-    table_count = 0, entity_count = 0;
-    it = ecs_query_iter(world, sq);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-        entity_count += it.count;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_has(world, it.entities[i], Position));
-            test_assert(ecs_has(world, it.entities[i], Velocity));
-        }
-    } 
-
-    test_int(table_count, 1);
-    test_int(entity_count, 3);  
-
-     ecs_query_fini(sq);
-
-    ecs_fini(world);
-}
-
-void Query_subquery_inactive(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_bulk_new(world, Position, 3);
-    ecs_bulk_new(world, Velocity, 3);
-    ECS_ENTITY(world, e, Position, Velocity);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Velocity",
-        .parent = q
-    });
-    test_assert(sq != NULL);
-    
-    /* Create an empty table which should deactivate it for both queries */
-    ecs_delete(world, e);
-
-    int32_t table_count = 0, entity_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-        entity_count += it.count;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_has(world, it.entities[i], Position));
-        }
-    }
-
-    test_int(table_count, 1);
-    test_int(entity_count, 3);
-
-    table_count = 0, entity_count = 0;
-    it = ecs_query_iter(world, sq);
-    test_int(it.table_count, 0);
-    ecs_iter_fini(&it);
-
-    table_count = 0, entity_count = 0;
-    it = ecs_query_iter(world, sq);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-    }
-
-    test_int(table_count, 0);
-
-    ecs_query_fini(sq);
-
-    ecs_fini(world);
-}
-
-void Query_subquery_unmatch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t parent = ecs_new(world, 0);
-    ecs_add(world, parent, Position);
-
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_add(world, e1, Position);
-    ecs_add(world, e1, Velocity);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_add(world, e2, Position);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Velocity",
-        .parent = q
-    });
-    test_assert(sq != NULL);
-
-    int32_t table_count = 0, entity_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-        entity_count += it.count;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_has(world, it.entities[i], Position));
-        }
-    }
-
-    test_int(table_count, 2);  
-    test_int(entity_count, 2);
-
-    table_count = 0, entity_count = 0;
-    it = ecs_query_iter(world, sq);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-        entity_count += it.count;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_has(world, it.entities[i], Position));
-            test_assert(ecs_has(world, it.entities[i], Velocity));
-        }
-    }
-
-    test_int(table_count, 1);
-    test_int(entity_count, 1);
-
-    /* Query now no longer match */
-    ecs_remove(world, parent, Position);
-
-    /* Force rematching */
-    ecs_run_aperiodic(world, 0);
-
-    /* Test if tables have been unmatched */
-    it = ecs_query_iter(world, q);
-    test_int(it.table_count, 0);
-    ecs_iter_fini(&it);
-
-    it = ecs_query_iter(world, sq);
-    test_int(it.table_count, 0);
-    ecs_iter_fini(&it);
-
-    ecs_query_fini(sq);
-
-    ecs_fini(world);
-}
-
-void Query_subquery_rematch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t parent = ecs_new(world, 0);
-    ecs_add(world, parent, Position);
-
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_add(world, e1, Position);
-    ecs_add(world, e1, Velocity);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_add(world, e2, Position);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Velocity",
-        .parent = q
-    });
-    test_assert(sq != NULL);
-
-    int32_t table_count = 0, entity_count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-        entity_count += it.count;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_has(world, it.entities[i], Position));
-        }
-    }
-
-    test_int(table_count, 2);  
-    test_int(entity_count, 2);
-
-    table_count = 0, entity_count = 0;
-    it = ecs_query_iter(world, sq);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-        entity_count += it.count;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(ecs_has(world, it.entities[i], Position));
-            test_assert(ecs_has(world, it.entities[i], Velocity));
-        }
-    }
-
-    test_int(table_count, 1);
-    test_int(entity_count, 1);
-
-    /* Query now no longer match */
-    ecs_remove(world, parent, Position);
-
-    /* Force unmatching */
-    ecs_run_aperiodic(world, 0);
-
-    /* Test if tables have been unmatched */
-    it = ecs_query_iter(world, q);
-    test_int(it.table_count, 0);
-    ecs_iter_fini(&it);
-
-    it = ecs_query_iter(world, sq);
-    test_int(it.table_count, 0);
-    ecs_iter_fini(&it);
-
-    /* Rematch queries */
-    ecs_add(world, parent, Position);    
-
-    /* Force rematching */
-    ecs_run_aperiodic(world, 0);
-
-    /* Test if tables have been rematched */
-    it = ecs_query_iter(world, q);
-    test_int(it.table_count, 2);
-    ecs_iter_fini(&it);
-
-    it = ecs_query_iter(world, sq);
-    test_int(it.table_count, 1);
-    ecs_iter_fini(&it);
-
-    ecs_query_fini(sq);
-
-    ecs_fini(world);
-}
-
-void Query_subquery_rematch_w_parent_optional(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_entity_t parent = ecs_new(world, 0);
-
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_add(world, e1, Position);
-    ecs_add(world, e1, Velocity);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_add(world, e2, Position);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, ?Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Velocity",
-        .parent = q
-    });
-    test_assert(sq != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_int(it.table_count, 2);
-    ecs_iter_fini(&it);
-
-    it = ecs_query_iter(world, sq);
-    test_int(it.table_count, 1);
-    ecs_iter_fini(&it);
-
-    /* Trigger rematch */
-    ecs_add(world, parent, Position);
-    ecs_run_aperiodic(world, 0);
-
-    /* Tables should be matched */
-    it = ecs_query_iter(world, q);
-    test_int(it.table_count, 3);
-    ecs_iter_fini(&it);
-
-    it = ecs_query_iter(world, sq);
-    test_int(it.table_count, 1);
-    ecs_iter_fini(&it);
-
-    ecs_query_fini(sq);
-
-    ecs_fini(world);
-}
-
-void Query_subquery_rematch_w_sub_optional(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_entity_t parent = ecs_new(world, 0);
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_add(world, e1, Position);
-    ecs_add(world, e1, Velocity);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_add(world, e2, Position);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, ?Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Velocity",
-        .parent = q
-    });
-    test_assert(sq != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_int(it.table_count, 2);
-    ecs_iter_fini(&it);
-
-    it = ecs_query_iter(world, sq);
-    test_int(it.table_count, 1);
-    ecs_iter_fini(&it);
-
-    /* Trigger rematch */
-    ecs_add(world, parent, Position);
-    ecs_run_aperiodic(world, 0);
-
-    /* Tables should be matched */
-    it = ecs_query_iter(world, q);
-    test_int(it.table_count, 3);
-    ecs_iter_fini(&it);
-
-    it = ecs_query_iter(world, sq);
-    test_int(it.table_count, 1);
-    ecs_iter_fini(&it);
-
-    ecs_query_fini(sq);
-
-    ecs_fini(world);
-}
-
-void Query_query_single_pairs(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_TAG(world, Rel);
-
-    ECS_ENTITY(world, e1, (Rel, Position));
-    ECS_ENTITY(world, e2, (Rel, Velocity));
-    ECS_ENTITY(world, e3, Position);
-    ECS_ENTITY(world, e4, Velocity);
-
-    int32_t table_count = 0, entity_count = 0;
-
-    ecs_query_t *q = ecs_query_new(world, "(Rel, Velocity)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] == e2);
-            entity_count ++;
-        }
-    }
-
-    test_int(table_count, 1);
-    test_int(entity_count, 1);
-
-    ecs_fini(world);
-}
-
-void Query_query_single_instanceof(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, BaseA, 0);
-    ECS_ENTITY(world, BaseB, 0);
-    ECS_ENTITY(world, e1, (IsA, BaseB));
-    ECS_ENTITY(world, e2, (IsA, BaseA));
-
-    int32_t table_count = 0, entity_count = 0;
-
-    ecs_query_t *q = ecs_query_new(world, "(IsA, BaseA)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] == e2);
-            entity_count ++;
-        }
-    }
-
-    test_int(table_count, 1);
-    test_int(entity_count, 1);
-
-    ecs_fini(world);
-}
-
-void Query_query_single_childof(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, BaseA, 0);
-    ECS_ENTITY(world, BaseB, 0);
-    ECS_ENTITY(world, e1, (ChildOf, BaseB));
-    ECS_ENTITY(world, e2, (ChildOf, BaseA));
-
-    int32_t table_count = 0, entity_count = 0;
-
-    ecs_query_t *q = ecs_query_new(world, "(ChildOf, BaseA)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        table_count ++;
-
-        int32_t i;
-        for (i = 0; i < it.count; i ++) {
-            test_assert(it.entities[i] == e2);
-            entity_count ++;
-        }
-    }
-
-    test_int(table_count, 1);
-    test_int(entity_count, 1);
-
-    ecs_fini(world);
-}
-
-void Query_query_optional_owned(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t base = ecs_new(world, Velocity);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_add_pair(world, e1, EcsIsA, base);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add(world, e2, Velocity);
-
-    ecs_entity_t e3 = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, ?Velocity(self)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    int32_t count = 0;
-    
-    while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        
-        test_int(it.count, 1);
-        test_assert(p != NULL);
-
-        if (it.entities[0] == e1) {
-            test_assert(v == NULL);
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), false); 
-        } else if (it.entities[0] == e2) {
-            test_assert(v != NULL);
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), true); 
-        } else if (it.entities[0] == e3) {
-            test_assert(v == NULL);
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), false);
-        }
-
-        count ++;
-    }
-
-    test_int(count, 3);
-
-    ecs_fini(world);
-}
-
-void Query_query_optional_shared(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t base = ecs_new(world, Velocity);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_add_pair(world, e1, EcsIsA, base);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add(world, e2, Velocity);
-
-    ecs_entity_t e3 = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, ?Velocity(up)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    int32_t count = 0;
-    
-    while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        
-        test_int(it.count, 1);
-        test_assert(p != NULL);
-        
-        if (it.entities[0] == e1) {
-            test_assert(v != NULL);
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), true);
-        } else if (it.entities[0] == e2) {
-            test_assert(v == NULL);
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), false);            
-        } else if (it.entities[0] == e3) {
-            test_assert(v == NULL);
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), false); 
-        }
-
-        count ++;
-    }
-
-    test_int(count, 3);
-
-    ecs_fini(world);
-}
-
-void Query_query_optional_shared_nested(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t base_base = ecs_new(world, Velocity);
-    ecs_entity_t base = ecs_new(world, 0);
-    ecs_add_pair(world, base, EcsIsA, base_base);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_add_pair(world, e1, EcsIsA, base);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add(world, e2, Velocity);
-
-    ecs_entity_t e3 = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, ?Velocity(up)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    int32_t count = 0;
-    
-    while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        
-        test_int(it.count, 1);
-        test_assert(p != NULL);
-        
-        if (it.entities[0] == e1) {
-            test_assert(v != NULL);
-        } else if (it.entities[0] == e2) {
-            test_assert(v == NULL);
-        } else if (it.entities[0] == e3) {
-            test_assert(v == NULL);
-        }
-
-        count ++;
-    }
-
-    test_int(count, 3);
-
-    ecs_fini(world);
-}
-
-void Query_query_optional_any(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t base = ecs_new(world, Velocity);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_add_pair(world, e1, EcsIsA, base);
-
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add(world, e2, Velocity);
-
-    ecs_entity_t e3 = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, ?Velocity(self|up)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    int32_t count = 0;
-    
-    while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        
-        test_int(it.count, 1);
-        test_assert(p != NULL);
-        
-        if (it.entities[0] == e1) {
-            test_assert(v != NULL);
-            test_assert(!ecs_field_is_self(&it, 2));
-        } else if (it.entities[0] == e2) {
-            test_assert(v != NULL);
-            test_assert(ecs_field_is_self(&it, 2));
-        } else if (it.entities[0] == e3) {
-            test_assert(v == NULL);
-        }
-
-        count ++;
-    }
-
-    test_int(count, 3);
-
-    ecs_fini(world);
-}
-
-void Query_query_rematch_optional_after_add(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t base = ecs_new(world, 0);
-    
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_add_pair(world, e1, EcsIsA, base);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_add(world, e2, Velocity);
-    ecs_entity_t e3 = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, ?Velocity(up)");
-    test_assert(q != NULL);
-
-    /* First iteration, base doesn't have Velocity but query should match with
-     * entity anyway since the component is optional */
-    ecs_iter_t it = ecs_query_iter(world, q);
-    int32_t count = 0;
-    
-    while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        
-        test_int(it.count, 1);
-        test_assert(p != NULL);
-        
-        if (it.entities[0] == e1) {
-            test_assert(v == NULL);
-        } else if (it.entities[0] == e2) {
-            test_assert(v == NULL);
-        } else if (it.entities[0] == e3) {
-            test_assert(v == NULL);
-        }
-
-        count ++;
-    }
-    test_int(count, 3);
-
-    /* Add Velocity to base, should trigger rematch */
-    ecs_add(world, base, Velocity);
-
-    /* Trigger a merge, which triggers the rematch */
-    ecs_readonly_begin(world, false);
-    ecs_readonly_end(world);
-
-    /* Second iteration, base has Velocity and entity should be able to access
-     * the shared component. */
-    it = ecs_query_iter(world, q);
-    count = 0;
-    
-    while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        
-        test_int(it.count, 1);
-        test_assert(p != NULL);
-        
-        if (it.entities[0] == e1) {
-            test_assert(v != NULL);
-        } else if (it.entities[0] == e2) {
-            test_assert(v == NULL);
-        } else if (it.entities[0] == e3) {
-            test_assert(v == NULL);
-        }
-
-        count ++;
-    }
-    test_int(count, 3);    
-
-    ecs_fini(world);    
-}
-
-void Query_get_owned_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag");
-
-    int count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(ecs_field_w_size(&it, 0, 1) == NULL);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e);
-        count += it.count;
-    }
-
-    test_int(count, 1);
-
-    ecs_fini(world);
-}
-
-void Query_get_shared_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t instance = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(up)");
-
-    int count = 0;
-    ecs_iter_t it = ecs_query_iter(world, q);
-    while (ecs_query_next(&it)) {
-        test_assert(ecs_field_w_size(&it, 0, 1) == NULL);
-        test_int(it.count, 1);
-        test_int(it.entities[0], instance);
-        count += it.count;
-    }
-
-    test_int(count, 1);
-
-    ecs_fini(world);
-}
-
-void Query_explicit_delete(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    /* Ensure query isn't deleted twice when deleting world */
-     ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_get_column_size(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(ecs_field_size(&it, 1), sizeof(Position));
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);    
-}
-
-void Query_orphaned_query(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    /* Nonsense subquery, doesn't matter, this is just for orphan testing */
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .parent = q
-    });
-    test_assert(sq != NULL);
-
-    test_assert(!ecs_query_orphaned(sq));
-
-     ecs_query_fini(q);
-
-    test_assert(ecs_query_orphaned(sq));
-    
-     ecs_query_fini(sq);
-
-    ecs_fini(world);
-}
-
-void Query_nested_orphaned_query(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    /* Nonsense subquery, doesn't matter, this is just for orphan testing */
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .parent = q
-    });
-    test_assert(sq != NULL);
-
-    ecs_query_t *nsq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .parent = sq
-    });
-    test_assert(nsq != NULL);    
-
-    test_assert(!ecs_query_orphaned(sq));
-    test_assert(!ecs_query_orphaned(nsq));
-
-     ecs_query_fini(q);
-
-    test_assert(ecs_query_orphaned(sq));
-    test_assert(ecs_query_orphaned(nsq));
-    
-     ecs_query_fini(sq);
-     ecs_query_fini(nsq);
-
-    ecs_fini(world);
-}
-
-void Query_invalid_access_orphaned_query(void) {
-    install_test_abort();
-
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    /* Nonsense subquery, doesn't matter, this is just for orphan testing */
-    ecs_query_t *sq = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .parent = q
-    });
-    test_assert(sq != NULL);
-
-    test_assert(!ecs_query_orphaned(sq));
-
-     ecs_query_fini(q);
-
-    test_expect_abort();
-
-    ecs_query_iter(world, sq);  
-}
-
-void Query_stresstest_query_free(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-    ECS_TAG(world, Hello);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add(world, e, Foo);
-    ecs_add(world, e, Bar);
-    ecs_add(world, e, Hello);
-
-    /* Create & delete query to test if query is properly unregistered with
-     * the table */
-
-    for (int i = 0; i < 10000; i ++) {
-        ecs_query_t *q = ecs_query_new(world, "Foo");
-         ecs_query_fini(q);
-    }
-
-    /* If code did not crash, test passes */
-    test_assert(true);
-
-    ecs_fini(world);
-}
-
-void Query_only_from_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_set_name(world, 0, "e");
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(e)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_add(world, e, Tag);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_assert(ecs_field_src(&it, 1) == e);
-    test_assert(ecs_field_id(&it, 1) == Tag);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_only_from_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_set_name(world, 0, "e");
-
-    ecs_query_t *q = ecs_query_new(world, "e($)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_add_id(world, e, e);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_assert(ecs_field_src(&it, 1) == e);
-    test_assert(ecs_field_id(&it, 1) == e);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_only_not_from_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_set_name(world, 0, "e");
-
-    ecs_query_t *q = ecs_query_new(world, "!Tag(e)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_assert(ecs_field_src(&it, 1) == e);
-    test_assert(ecs_field_id(&it, 1) == Tag);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_add(world, e, Tag);
-
-    it = ecs_query_iter(world, q);
-    test_assert(!ecs_query_next(&it));
-
-    test_assert(ECS_BIT_IS_SET(it.flags, EcsIterIsValid) == false);
-    ecs_fini(world);
-}
-
-void Query_only_not_from_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_set_name(world, 0, "e");
-
-    ecs_query_t *q = ecs_query_new(world, "!e($)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_assert(ecs_field_src(&it, 1) == e);
-    test_assert(ecs_field_id(&it, 1) == e);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_add_id(world, e, e);
-
-    it = ecs_query_iter(world, q);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_get_filter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    test_assert(q != NULL);
-
-    const ecs_filter_t *f = ecs_query_get_filter(q);
-    test_assert(f != NULL);
-
-    test_int(f->term_count, 2);
-    test_int(f->terms[0].id, ecs_id(Position));
-    test_int(f->terms[1].id, ecs_id(Velocity));
-
-    ecs_fini(world);
-}
-
-void Query_group_by(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, TagX);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{TagX}},
-        .group_by = group_by_first_id
-    });
-
-    ecs_entity_t e1 = ecs_new(world, TagX);
-    ecs_entity_t e2 = ecs_new(world, TagX);
-    ecs_entity_t e3 = ecs_new(world, TagX);
-
-    ecs_add_id(world, e1, TagC);
-    ecs_add_id(world, e2, TagB);
-    ecs_add_id(world, e3, TagA);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);    
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-static int ctx_value;
-static int ctx_value_free_invoked = 0;
-static
-void ctx_value_free(void *ctx) {
-    test_assert(ctx == &ctx_value);
-    ctx_value_free_invoked ++;
-}
-
-void Query_group_by_w_ctx(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, TagX);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{TagX}},
-        .group_by = group_by_first_id,
-        .group_by_ctx = &ctx_value,
-        .group_by_ctx_free = ctx_value_free
-    });
-
-    ecs_entity_t e1 = ecs_new(world, TagX);
-    ecs_entity_t e2 = ecs_new(world, TagX);
-    ecs_entity_t e3 = ecs_new(world, TagX);
-
-    ecs_add_id(world, e1, TagC);
-    ecs_add_id(world, e2, TagB);
-    ecs_add_id(world, e3, TagA);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);    
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_query_fini(q);
-
-    test_int(ctx_value_free_invoked, 1);
-
-    ecs_fini(world);
-}
-
-void Query_group_by_w_sort_reverse_group_creation(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t TagA = ecs_new_id(world);
-    ecs_entity_t TagB = ecs_new_id(world);
-    ecs_entity_t TagC = ecs_new_id(world);
-
-    ecs_entity_t TagX = ecs_new_id(world);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{TagX}},
-        .order_by = order_by_entity,
-        .group_by = group_by_first_id
-    });
-
-    ecs_entity_t e1 = ecs_new_w_id(world, TagX);
-    ecs_entity_t e2 = ecs_new_w_id(world, TagX);
-    ecs_entity_t e3 = ecs_new_w_id(world, TagX);
-
-    ecs_add_id(world, e1, TagC);
-    ecs_add_id(world, e2, TagB);
-    ecs_add_id(world, e3, TagA);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);    
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_group_by_iter_one(void) {
-    ecs_world_t* world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, Tag);
-
-    ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_new_w_pair(world, Rel, TgtC);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t e5 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t e6 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-    ecs_add(world, e6, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_pair(Rel, EcsWildcard) }
-        },
-        .group_by = group_by_rel,
-        .group_by_id = Rel
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    ecs_query_set_group(&it, TgtB);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-    test_uint(TgtB, it.group_id);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-    test_uint(TgtB, it.group_id);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_group_by_iter_one_all_groups(void) {
-    ecs_world_t* world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtC);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t e5 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t e6 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-    ecs_add(world, e6, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_pair(Rel, EcsWildcard) }
-        },
-        .group_by = group_by_rel,
-        .group_by_id = Rel
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    ecs_query_set_group(&it, TgtB);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-    test_uint(TgtB, it.group_id);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e5, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-    test_uint(TgtB, it.group_id);
-    test_bool(false, ecs_query_next(&it));
-
-    it = ecs_query_iter(world, q);
-    ecs_query_set_group(&it, TgtA);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-    test_uint(TgtA, it.group_id);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e4, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-    test_uint(TgtA, it.group_id);
-    test_bool(false, ecs_query_next(&it));
-
-    it = ecs_query_iter(world, q);
-    ecs_query_set_group(&it, TgtC);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-    test_uint(TgtC, it.group_id);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e6, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-    test_uint(TgtC, it.group_id);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_group_by_iter_one_empty(void) {
-    ecs_world_t* world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, TgtD);
-    ECS_TAG(world, Tag);
-
-    ecs_new_w_pair(world, Rel, TgtA);
-    ecs_new_w_pair(world, Rel, TgtB);
-    ecs_new_w_pair(world, Rel, TgtC);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t e5 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t e6 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-    ecs_add(world, e6, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_pair(Rel, EcsWildcard) }
-        },
-        .group_by = group_by_rel,
-        .group_by_id = Rel
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    ecs_query_set_group(&it, TgtD);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_group_by_iter_one_empty_query(void) {
-    ecs_world_t* world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_pair(Rel, EcsWildcard) }
-        },
-        .group_by = group_by_rel,
-        .group_by_id = Rel
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    ecs_query_set_group(&it, TgtA);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_group_by_iter_one_empty_table(void) {
-    ecs_world_t* world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-    ECS_TAG(world, Tag);
-
-    ecs_new_w_pair(world, Rel, TgtA);
-    ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtC);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_entity_t e5 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t e6 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-    ecs_add(world, e6, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_pair(Rel, EcsWildcard) }
-        },
-        .group_by = group_by_rel,
-        .group_by_id = Rel
-    });
-
-    ecs_delete(world, e3);
-    ecs_delete(world, e6);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    ecs_query_set_group(&it, TgtC);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_group_by_w_deleted_group_id(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_pair(Rel, EcsWildcard) }
-        },
-        .group_by = group_by_rel,
-        .group_by_id = Rel
-    });
-
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    ecs_query_set_group(&it, tgt);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_delete(world, tgt);
-    ecs_delete(world, e);
-
-    it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    tgt = ecs_new_id(world);
-    e = ecs_new_w_pair(world, Rel, tgt);
-
-    it = ecs_query_iter(world, q);
-    ecs_query_set_group(&it, tgt);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-static int group_by_ctx;
-static int on_group_create_invoked;
-static int on_group_delete_invoked;
-
-static
-void* on_group_create(ecs_world_t *world, uint64_t group_id, void *group_by_arg) {
-    test_assert(world != NULL);
-    test_assert(group_id != 0);
-    test_assert(group_by_arg != NULL);
-    test_assert(group_by_arg == &group_by_ctx);
-    uint64_t *group_ctx = ecs_os_malloc_t(uint64_t);
-    *group_ctx = group_id;
-    on_group_create_invoked ++;
-    return group_ctx;
-}
-
-static
-void on_group_delete(ecs_world_t *world, uint64_t group_id, void *group_ctx, void *group_by_arg) {
-    test_assert(world != NULL);
-    test_assert(group_id != 0);
-    test_assert(group_ctx != NULL);
-    test_assert(group_by_arg != NULL);
-    test_assert(group_by_arg == &group_by_ctx);
-    test_assert(*(uint64_t*)group_ctx == group_id);
-    ecs_os_free(group_ctx);
-    on_group_delete_invoked ++;
-}
-
-void Query_group_by_callbacks(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_pair(Rel, EcsWildcard) }
-        },
-        .group_by = group_by_rel,
-        .group_by_id = Rel,
-        .on_group_create = on_group_create,
-        .on_group_delete = on_group_delete,
-        .group_by_ctx = &group_by_ctx
-    });
-
-    ecs_entity_t tgt_a = ecs_new_id(world);
-    ecs_entity_t tgt_b = ecs_new_id(world);
-
-    test_int(on_group_create_invoked, 0);
-    test_int(on_group_delete_invoked, 0);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, tgt_a);
-    ecs_run_aperiodic(world, 0);
-    test_int(on_group_create_invoked, 1);
-    test_int(on_group_delete_invoked, 0);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, tgt_a);
-    ecs_run_aperiodic(world, 0);
-    test_int(on_group_create_invoked, 1);
-    test_int(on_group_delete_invoked, 0);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, tgt_b);
-    ecs_run_aperiodic(world, 0);
-    test_int(on_group_create_invoked, 2);
-    test_int(on_group_delete_invoked, 0);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(2, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(e2, it.entities[1]);
-    test_uint(tgt_a, it.group_id);
-    const ecs_query_group_info_t *gi = ecs_query_get_group_info(q, it.group_id);
-    test_assert(gi != NULL);
-    test_assert(gi->ctx != NULL);
-    test_uint(tgt_a, *(uint64_t*)gi->ctx);
-
-    test_assert(ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(tgt_b, it.group_id);
-    gi = ecs_query_get_group_info(q, it.group_id);
-    test_assert(gi != NULL);
-    test_assert(gi->ctx != NULL);
-    test_uint(tgt_b, *(uint64_t*)gi->ctx);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_delete_with(world, ecs_pair(Rel, tgt_a));
-    ecs_run_aperiodic(world, 0);
-    test_int(on_group_create_invoked, 2);
-    test_int(on_group_delete_invoked, 1);
-
-    ecs_query_fini(q);
-
-    test_int(on_group_create_invoked, 2);
-    test_int(on_group_delete_invoked, 2);
-
-    ecs_fini(world);
-}
-
-void Query_group_by_default_action(void) {
-    ecs_world_t* world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, TgtC);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtB);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtA);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_pair(Rel, EcsWildcard) }
-        },
-        // .group_by = group_by_rel, default action groups by relationship
-        .group_by_id = Rel
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e3, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
-    test_uint(TgtA, it.group_id);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e2, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
-    test_uint(TgtB, it.group_id);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
-    test_uint(TgtC, it.group_id);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_group_table_count(void) {
-    ecs_world_t* world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, Foo);
-
-    ecs_new_w_pair(world, Rel, TgtA);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { ecs_pair(Rel, EcsWildcard) }
-        },
-        .group_by_id = Rel
-    });
-
-    ecs_run_aperiodic(world, 0);
-
-    const ecs_query_group_info_t *gi_a;
-    const ecs_query_group_info_t *gi_b;
-    gi_a = ecs_query_get_group_info(q, TgtA);
-    gi_b = ecs_query_get_group_info(q, TgtB);
-    test_assert(gi_a != NULL);
-    test_assert(gi_b == NULL);
-    test_int(gi_a->table_count, 1);
-    test_int(gi_a->match_count, 1);
-
-    ecs_new_w_pair(world, Rel, TgtB);
-    ecs_run_aperiodic(world, 0);
-
-    gi_a = ecs_query_get_group_info(q, TgtA);
-    gi_b = ecs_query_get_group_info(q, TgtB);
-    test_assert(gi_a != NULL);
-    test_assert(gi_b != NULL);
-    test_int(gi_a->table_count, 1);
-    test_int(gi_a->match_count, 1);
-    test_int(gi_b->table_count, 1);
-    test_int(gi_b->match_count, 1);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtA);
-    ecs_run_aperiodic(world, 0);
-
-    gi_a = ecs_query_get_group_info(q, TgtA);
-    gi_b = ecs_query_get_group_info(q, TgtB);
-    test_assert(gi_a != NULL);
-    test_assert(gi_b != NULL);
-    test_int(gi_a->table_count, 1);
-    test_int(gi_a->match_count, 1);
-    test_int(gi_b->table_count, 1);
-    test_int(gi_b->match_count, 1);
-
-    ecs_add(world, e3, Foo);
-    ecs_run_aperiodic(world, 0);
-
-    gi_a = ecs_query_get_group_info(q, TgtA);
-    gi_b = ecs_query_get_group_info(q, TgtB);
-    test_assert(gi_a != NULL);
-    test_assert(gi_b != NULL);
-    test_int(gi_a->table_count, 2);
-    test_int(gi_a->match_count, 2);
-    test_int(gi_b->table_count, 1);
-    test_int(gi_b->match_count, 1);
-
-    ecs_delete_with(world, Foo);
-    ecs_run_aperiodic(world, 0);
-
-    gi_a = ecs_query_get_group_info(q, TgtA);
-    gi_b = ecs_query_get_group_info(q, TgtB);
-    test_assert(gi_a != NULL);
-    test_assert(gi_b != NULL);
-    test_int(gi_a->table_count, 1);
-    test_int(gi_a->match_count, 3);
-    test_int(gi_b->table_count, 1);
-    test_int(gi_b->match_count, 1);
-
-    ecs_delete_with(world, ecs_pair(Rel, TgtA));
-    ecs_run_aperiodic(world, 0);
-
-    gi_a = ecs_query_get_group_info(q, TgtA);
-    gi_b = ecs_query_get_group_info(q, TgtB);
-    test_assert(gi_a == NULL);
-    test_assert(gi_b != NULL);
-    test_int(gi_b->table_count, 1);
-    test_int(gi_b->match_count, 1);
-
-    ecs_delete_with(world, ecs_pair(Rel, TgtB));
-    ecs_run_aperiodic(world, 0);
-
-    gi_a = ecs_query_get_group_info(q, TgtA);
-    gi_b = ecs_query_get_group_info(q, TgtB);
-    test_assert(gi_a == NULL);
-    test_assert(gi_b == NULL);
-
-    ecs_fini(world);
-}
-
-void Query_iter_valid(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(it.flags & EcsIterIsValid, false);
-
-    test_bool(ecs_query_next(&it), true);
-    test_bool(it.flags & EcsIterIsValid, true);
-
-    test_bool(ecs_query_next(&it), false);
-    test_bool(it.flags & EcsIterIsValid, false);
-
-    ecs_fini(world);
-}
-
-void Query_query_optional_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add_id(world, e2, TagB);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA, ?TagB");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    int32_t count = 0;
-    
-    while (ecs_query_next(&it)) {    
-        test_uint(ecs_field_id(&it, 1), TagA);
-        test_assert(ecs_field_id(&it, 2) == TagB);
-        test_int(it.count, 1);
-
-        if (it.entities[0] == e1) {
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), false); 
-        } else if (it.entities[0] == e2) {
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), true); 
-        }
-
-        count ++;
-    }
-
-    test_int(count, 2);
-
-    ecs_fini(world);
-}
-
-void Query_query_optional_shared_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_add_id(world, e2, TagB);
-    
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_add_pair(world, e3, EcsIsA, e2);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA, ?TagB(self|up)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    int32_t count = 0;
-    
-    while (ecs_query_next(&it)) {    
-        test_uint(ecs_field_id(&it, 1), TagA);
-        test_assert(ecs_field_id(&it, 2) == TagB);
-        test_int(it.count, 1);
-
-        if (it.entities[0] == e1) {
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), false); 
-        } else if (it.entities[0] == e2) {
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), true); 
-        } else if (it.entities[0] == e3) {
-            test_bool(ecs_field_is_set(&it, 1), true);
-            test_bool(ecs_field_is_set(&it, 2), true);
-        }
-
-        count ++;
-    }
-
-    test_int(count, 3);
-
-    ecs_fini(world);
-}
-
-void Query_query_iter_10_tags(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, TagD);
-    ECS_TAG(world, TagE);
-    ECS_TAG(world, TagF);
-    ECS_TAG(world, TagG);
-    ECS_TAG(world, TagH);
-    ECS_TAG(world, TagI);
-    ECS_TAG(world, TagJ);
-    ECS_TAG(world, TagK);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_add_id(world, e_1, TagB);
-    ecs_add_id(world, e_1, TagC);
-    ecs_add_id(world, e_1, TagD);
-    ecs_add_id(world, e_1, TagE);
-    ecs_add_id(world, e_1, TagF);
-    ecs_add_id(world, e_1, TagG);
-    ecs_add_id(world, e_1, TagH);
-    ecs_add_id(world, e_1, TagI);
-    ecs_add_id(world, e_1, TagJ);
-    
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, TagB);
-    ecs_add_id(world, e_2, TagC);
-    ecs_add_id(world, e_2, TagD);
-    ecs_add_id(world, e_2, TagE);
-    ecs_add_id(world, e_2, TagF);
-    ecs_add_id(world, e_2, TagG);
-    ecs_add_id(world, e_2, TagH);
-    ecs_add_id(world, e_2, TagI);
-    ecs_add_id(world, e_2, TagJ);
-    ecs_add_id(world, e_2, TagK); /* 2nd match in different table */
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            {TagA}, {TagB}, {TagC}, {TagD}, {TagE}, {TagF}, {TagG}, {TagH}, 
-            {TagI}, {TagJ}
-        }
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_int(ecs_field_id(&it, 2), TagB);
-    test_int(ecs_field_id(&it, 3), TagC);
-    test_int(ecs_field_id(&it, 4), TagD);
-    test_int(ecs_field_id(&it, 5), TagE);
-    test_int(ecs_field_id(&it, 6), TagF);
-    test_int(ecs_field_id(&it, 7), TagG);
-    test_int(ecs_field_id(&it, 8), TagH);
-    test_int(ecs_field_id(&it, 9), TagI);
-    test_int(ecs_field_id(&it, 10), TagJ);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_2);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_int(ecs_field_id(&it, 2), TagB);
-    test_int(ecs_field_id(&it, 3), TagC);
-    test_int(ecs_field_id(&it, 4), TagD);
-    test_int(ecs_field_id(&it, 5), TagE);
-    test_int(ecs_field_id(&it, 6), TagF);
-    test_int(ecs_field_id(&it, 7), TagG);
-    test_int(ecs_field_id(&it, 8), TagH);
-    test_int(ecs_field_id(&it, 9), TagI);
-    test_int(ecs_field_id(&it, 10), TagJ);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_query_iter_20_tags(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-    ECS_TAG(world, TagD);
-    ECS_TAG(world, TagE);
-    ECS_TAG(world, TagF);
-    ECS_TAG(world, TagG);
-    ECS_TAG(world, TagH);
-    ECS_TAG(world, TagI);
-    ECS_TAG(world, TagJ);
-    ECS_TAG(world, TagK);
-    ECS_TAG(world, TagL);
-    ECS_TAG(world, TagM);
-    ECS_TAG(world, TagN);
-    ECS_TAG(world, TagO);
-    ECS_TAG(world, TagP);
-    ECS_TAG(world, TagQ);
-    ECS_TAG(world, TagR);
-    ECS_TAG(world, TagS);
-    ECS_TAG(world, TagT);
-    ECS_TAG(world, TagU);
-
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_add_id(world, e_1, TagB);
-    ecs_add_id(world, e_1, TagC);
-    ecs_add_id(world, e_1, TagD);
-    ecs_add_id(world, e_1, TagE);
-    ecs_add_id(world, e_1, TagF);
-    ecs_add_id(world, e_1, TagG);
-    ecs_add_id(world, e_1, TagH);
-    ecs_add_id(world, e_1, TagI);
-    ecs_add_id(world, e_1, TagJ);
-    ecs_add_id(world, e_1, TagK);
-    ecs_add_id(world, e_1, TagL);
-    ecs_add_id(world, e_1, TagM);
-    ecs_add_id(world, e_1, TagN);
-    ecs_add_id(world, e_1, TagO);
-    ecs_add_id(world, e_1, TagP);
-    ecs_add_id(world, e_1, TagQ);
-    ecs_add_id(world, e_1, TagR);
-    ecs_add_id(world, e_1, TagS);
-    ecs_add_id(world, e_1, TagT);
-    
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_add_id(world, e_2, TagB);
-    ecs_add_id(world, e_2, TagC);
-    ecs_add_id(world, e_2, TagD);
-    ecs_add_id(world, e_2, TagE);
-    ecs_add_id(world, e_2, TagF);
-    ecs_add_id(world, e_2, TagG);
-    ecs_add_id(world, e_2, TagH);
-    ecs_add_id(world, e_2, TagI);
-    ecs_add_id(world, e_2, TagJ);
-    ecs_add_id(world, e_2, TagK);
-    ecs_add_id(world, e_2, TagL);
-    ecs_add_id(world, e_2, TagM);
-    ecs_add_id(world, e_2, TagN);
-    ecs_add_id(world, e_2, TagO);
-    ecs_add_id(world, e_2, TagP);
-    ecs_add_id(world, e_2, TagQ);
-    ecs_add_id(world, e_2, TagR);
-    ecs_add_id(world, e_2, TagS);
-    ecs_add_id(world, e_2, TagT);
-    ecs_add_id(world, e_2, TagU); /* 2nd match in different table */
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter = {
-            .terms_buffer = (ecs_term_t[]){
-                {TagA}, {TagB}, {TagC}, {TagD}, {TagE}, {TagF}, {TagG}, {TagH}, 
-                {TagI}, {TagJ}, {TagK}, {TagL}, {TagM}, {TagN}, {TagO}, {TagP},
-                {TagQ}, {TagR}, {TagS}, {TagT}
-            },
-            .terms_buffer_count = 20
-        },
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_int(ecs_field_id(&it, 2), TagB);
-    test_int(ecs_field_id(&it, 3), TagC);
-    test_int(ecs_field_id(&it, 4), TagD);
-    test_int(ecs_field_id(&it, 5), TagE);
-    test_int(ecs_field_id(&it, 6), TagF);
-    test_int(ecs_field_id(&it, 7), TagG);
-    test_int(ecs_field_id(&it, 8), TagH);
-    test_int(ecs_field_id(&it, 9), TagI);
-    test_int(ecs_field_id(&it, 10), TagJ);
-    test_int(ecs_field_id(&it, 11), TagK);
-    test_int(ecs_field_id(&it, 12), TagL);
-    test_int(ecs_field_id(&it, 13), TagM);
-    test_int(ecs_field_id(&it, 14), TagN);
-    test_int(ecs_field_id(&it, 15), TagO);
-    test_int(ecs_field_id(&it, 16), TagP);
-    test_int(ecs_field_id(&it, 17), TagQ);
-    test_int(ecs_field_id(&it, 18), TagR);
-    test_int(ecs_field_id(&it, 19), TagS);
-    test_int(ecs_field_id(&it, 20), TagT);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_2);
-    test_int(ecs_field_id(&it, 1), TagA);
-    test_int(ecs_field_id(&it, 2), TagB);
-    test_int(ecs_field_id(&it, 3), TagC);
-    test_int(ecs_field_id(&it, 4), TagD);
-    test_int(ecs_field_id(&it, 5), TagE);
-    test_int(ecs_field_id(&it, 6), TagF);
-    test_int(ecs_field_id(&it, 7), TagG);
-    test_int(ecs_field_id(&it, 8), TagH);
-    test_int(ecs_field_id(&it, 9), TagI);
-    test_int(ecs_field_id(&it, 10), TagJ);
-    test_int(ecs_field_id(&it, 11), TagK);
-    test_int(ecs_field_id(&it, 12), TagL);
-    test_int(ecs_field_id(&it, 13), TagM);
-    test_int(ecs_field_id(&it, 14), TagN);
-    test_int(ecs_field_id(&it, 15), TagO);
-    test_int(ecs_field_id(&it, 16), TagP);
-    test_int(ecs_field_id(&it, 17), TagQ);
-    test_int(ecs_field_id(&it, 18), TagR);
-    test_int(ecs_field_id(&it, 19), TagS);
-    test_int(ecs_field_id(&it, 20), TagT);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-typedef struct {
-    float v;
-} CompA, CompB, CompC, CompD, CompE, CompF, CompG, CompH, CompI, CompJ, CompK,
-  CompL, CompM, CompN, CompO, CompP, CompQ, CompR, CompS, CompT, CompU;
-
-void Query_query_iter_10_components(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, CompA);
-    ECS_COMPONENT(world, CompB);
-    ECS_COMPONENT(world, CompC);
-    ECS_COMPONENT(world, CompD);
-    ECS_COMPONENT(world, CompE);
-    ECS_COMPONENT(world, CompF);
-    ECS_COMPONENT(world, CompG);
-    ECS_COMPONENT(world, CompH);
-    ECS_COMPONENT(world, CompI);
-    ECS_COMPONENT(world, CompJ);
-    ECS_COMPONENT(world, CompK);
-
-    ecs_entity_t e_1 = ecs_set(world, 0, CompA, {10});
-    ecs_set(world, e_1, CompB, {10});
-    ecs_set(world, e_1, CompC, {10});
-    ecs_set(world, e_1, CompD, {10});
-    ecs_set(world, e_1, CompE, {10});
-    ecs_set(world, e_1, CompF, {10});
-    ecs_set(world, e_1, CompG, {10});
-    ecs_set(world, e_1, CompH, {10});
-    ecs_set(world, e_1, CompI, {10});
-    ecs_set(world, e_1, CompJ, {10});
-    
-    ecs_entity_t e_2 = ecs_set(world, 0, CompA, {10});
-    ecs_set(world, e_2, CompB, {10});
-    ecs_set(world, e_2, CompC, {10});
-    ecs_set(world, e_2, CompD, {10});
-    ecs_set(world, e_2, CompE, {10});
-    ecs_set(world, e_2, CompF, {10});
-    ecs_set(world, e_2, CompG, {10});
-    ecs_set(world, e_2, CompH, {10});
-    ecs_set(world, e_2, CompI, {10});
-    ecs_set(world, e_2, CompJ, {10});
-    ecs_set(world, e_2, CompK, {10});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            {ecs_id(CompA)}, {ecs_id(CompB)}, {ecs_id(CompC)}, {ecs_id(CompD)}, 
-            {ecs_id(CompE)}, {ecs_id(CompF)}, {ecs_id(CompG)}, {ecs_id(CompH)}, 
-            {ecs_id(CompI)}, {ecs_id(CompJ)}
-        }
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), ecs_id(CompA));
-    test_int(ecs_field_id(&it, 2), ecs_id(CompB));
-    test_int(ecs_field_id(&it, 3), ecs_id(CompC));
-    test_int(ecs_field_id(&it, 4), ecs_id(CompD));
-    test_int(ecs_field_id(&it, 5), ecs_id(CompE));
-    test_int(ecs_field_id(&it, 6), ecs_id(CompF));
-    test_int(ecs_field_id(&it, 7), ecs_id(CompG));
-    test_int(ecs_field_id(&it, 8), ecs_id(CompH));
-    test_int(ecs_field_id(&it, 9), ecs_id(CompI));
-    test_int(ecs_field_id(&it, 10), ecs_id(CompJ));
-
-    int i;
-    for (i = 0; i < 10; i ++) {
-        CompA *ptr = ecs_field_w_size(&it, 0, i + 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].v, 10);
-    }
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_2);
-    test_int(ecs_field_id(&it, 1), ecs_id(CompA));
-    test_int(ecs_field_id(&it, 2), ecs_id(CompB));
-    test_int(ecs_field_id(&it, 3), ecs_id(CompC));
-    test_int(ecs_field_id(&it, 4), ecs_id(CompD));
-    test_int(ecs_field_id(&it, 5), ecs_id(CompE));
-    test_int(ecs_field_id(&it, 6), ecs_id(CompF));
-    test_int(ecs_field_id(&it, 7), ecs_id(CompG));
-    test_int(ecs_field_id(&it, 8), ecs_id(CompH));
-    test_int(ecs_field_id(&it, 9), ecs_id(CompI));
-    test_int(ecs_field_id(&it, 10), ecs_id(CompJ));
-
-    for (i = 0; i < 10; i ++) {
-        CompA *ptr = ecs_field_w_size(&it, 0, i + 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].v, 10);
-    }
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_iter_20_components(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, CompA);
-    ECS_COMPONENT(world, CompB);
-    ECS_COMPONENT(world, CompC);
-    ECS_COMPONENT(world, CompD);
-    ECS_COMPONENT(world, CompE);
-    ECS_COMPONENT(world, CompF);
-    ECS_COMPONENT(world, CompG);
-    ECS_COMPONENT(world, CompH);
-    ECS_COMPONENT(world, CompI);
-    ECS_COMPONENT(world, CompJ);
-    ECS_COMPONENT(world, CompK);
-    ECS_COMPONENT(world, CompL);
-    ECS_COMPONENT(world, CompM);
-    ECS_COMPONENT(world, CompN);
-    ECS_COMPONENT(world, CompO);
-    ECS_COMPONENT(world, CompP);
-    ECS_COMPONENT(world, CompQ);
-    ECS_COMPONENT(world, CompR);
-    ECS_COMPONENT(world, CompS);
-    ECS_COMPONENT(world, CompT);
-    ECS_COMPONENT(world, CompU);
-
-    ecs_entity_t e_1 = ecs_set(world, 0, CompA, {10});
-    ecs_set(world, e_1, CompB, {10});
-    ecs_set(world, e_1, CompC, {10});
-    ecs_set(world, e_1, CompD, {10});
-    ecs_set(world, e_1, CompE, {10});
-    ecs_set(world, e_1, CompF, {10});
-    ecs_set(world, e_1, CompG, {10});
-    ecs_set(world, e_1, CompH, {10});
-    ecs_set(world, e_1, CompI, {10});
-    ecs_set(world, e_1, CompJ, {10});
-    ecs_set(world, e_1, CompK, {10});
-    ecs_set(world, e_1, CompL, {10});
-    ecs_set(world, e_1, CompM, {10});
-    ecs_set(world, e_1, CompN, {10});
-    ecs_set(world, e_1, CompO, {10});
-    ecs_set(world, e_1, CompP, {10});
-    ecs_set(world, e_1, CompQ, {10});
-    ecs_set(world, e_1, CompR, {10});
-    ecs_set(world, e_1, CompS, {10});
-    ecs_set(world, e_1, CompT, {10});
-
-    ecs_entity_t e_2 = ecs_set(world, 0, CompA, {10});
-    ecs_set(world, e_2, CompB, {10});
-    ecs_set(world, e_2, CompC, {10});
-    ecs_set(world, e_2, CompD, {10});
-    ecs_set(world, e_2, CompE, {10});
-    ecs_set(world, e_2, CompF, {10});
-    ecs_set(world, e_2, CompG, {10});
-    ecs_set(world, e_2, CompH, {10});
-    ecs_set(world, e_2, CompI, {10});
-    ecs_set(world, e_2, CompJ, {10});
-    ecs_set(world, e_2, CompK, {10});
-    ecs_set(world, e_2, CompL, {10});
-    ecs_set(world, e_2, CompM, {10});
-    ecs_set(world, e_2, CompN, {10});
-    ecs_set(world, e_2, CompO, {10});
-    ecs_set(world, e_2, CompP, {10});
-    ecs_set(world, e_2, CompQ, {10});
-    ecs_set(world, e_2, CompR, {10});
-    ecs_set(world, e_2, CompS, {10});
-    ecs_set(world, e_2, CompT, {10});
-    ecs_set(world, e_2, CompU, {10});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter = {
-            .terms_buffer = (ecs_term_t[]){
-                {ecs_id(CompA)}, {ecs_id(CompB)}, {ecs_id(CompC)}, {ecs_id(CompD)}, 
-                {ecs_id(CompE)}, {ecs_id(CompF)}, {ecs_id(CompG)}, {ecs_id(CompH)}, 
-                {ecs_id(CompI)}, {ecs_id(CompJ)}, {ecs_id(CompK)}, {ecs_id(CompL)},
-                {ecs_id(CompM)}, {ecs_id(CompN)}, {ecs_id(CompO)}, {ecs_id(CompP)},
-                {ecs_id(CompQ)}, {ecs_id(CompR)}, {ecs_id(CompS)}, {ecs_id(CompT)}
-            },
-            .terms_buffer_count = 20
-        }
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_1);
-    test_int(ecs_field_id(&it, 1), ecs_id(CompA));
-    test_int(ecs_field_id(&it, 2), ecs_id(CompB));
-    test_int(ecs_field_id(&it, 3), ecs_id(CompC));
-    test_int(ecs_field_id(&it, 4), ecs_id(CompD));
-    test_int(ecs_field_id(&it, 5), ecs_id(CompE));
-    test_int(ecs_field_id(&it, 6), ecs_id(CompF));
-    test_int(ecs_field_id(&it, 7), ecs_id(CompG));
-    test_int(ecs_field_id(&it, 8), ecs_id(CompH));
-    test_int(ecs_field_id(&it, 9), ecs_id(CompI));
-    test_int(ecs_field_id(&it, 10), ecs_id(CompJ));
-    test_int(ecs_field_id(&it, 11), ecs_id(CompK));
-    test_int(ecs_field_id(&it, 12), ecs_id(CompL));
-    test_int(ecs_field_id(&it, 13), ecs_id(CompM));
-    test_int(ecs_field_id(&it, 14), ecs_id(CompN));
-    test_int(ecs_field_id(&it, 15), ecs_id(CompO));
-    test_int(ecs_field_id(&it, 16), ecs_id(CompP));
-    test_int(ecs_field_id(&it, 17), ecs_id(CompQ));
-    test_int(ecs_field_id(&it, 18), ecs_id(CompR));
-    test_int(ecs_field_id(&it, 19), ecs_id(CompS));
-    test_int(ecs_field_id(&it, 20), ecs_id(CompT));
-
-    int i;
-    for (i = 0; i < 20; i ++) {
-        CompA *ptr = ecs_field_w_size(&it, 0, i + 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].v, 10);
-    }
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e_2);
-    test_int(ecs_field_id(&it, 1), ecs_id(CompA));
-    test_int(ecs_field_id(&it, 2), ecs_id(CompB));
-    test_int(ecs_field_id(&it, 3), ecs_id(CompC));
-    test_int(ecs_field_id(&it, 4), ecs_id(CompD));
-    test_int(ecs_field_id(&it, 5), ecs_id(CompE));
-    test_int(ecs_field_id(&it, 6), ecs_id(CompF));
-    test_int(ecs_field_id(&it, 7), ecs_id(CompG));
-    test_int(ecs_field_id(&it, 8), ecs_id(CompH));
-    test_int(ecs_field_id(&it, 9), ecs_id(CompI));
-    test_int(ecs_field_id(&it, 10), ecs_id(CompJ));
-    test_int(ecs_field_id(&it, 11), ecs_id(CompK));
-    test_int(ecs_field_id(&it, 12), ecs_id(CompL));
-    test_int(ecs_field_id(&it, 13), ecs_id(CompM));
-    test_int(ecs_field_id(&it, 14), ecs_id(CompN));
-    test_int(ecs_field_id(&it, 15), ecs_id(CompO));
-    test_int(ecs_field_id(&it, 16), ecs_id(CompP));
-    test_int(ecs_field_id(&it, 17), ecs_id(CompQ));
-    test_int(ecs_field_id(&it, 18), ecs_id(CompR));
-    test_int(ecs_field_id(&it, 19), ecs_id(CompS));
-    test_int(ecs_field_id(&it, 20), ecs_id(CompT));
-
-    for (i = 0; i < 20; i ++) {
-        CompA *ptr = ecs_field_w_size(&it, 0, i + 1);
-        test_assert(ptr != NULL);
-        test_int(ptr[0].v, 10);
-    }
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_iter_type_set(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    
-    ecs_entity_t e = ecs_new(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e);
-    test_assert(it.table != NULL);
-    const ecs_type_t *type = ecs_table_get_type(it.table);
-    test_int(type->count, 1);
-    test_int(type->array[0], ecs_id(Position));
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_filter_term(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ .id = ecs_id(Position), .inout = EcsInOutNone }}
-    });
-
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(ecs_query_next(&it), true);
-    test_assert(it.ids != NULL);
-    test_assert(it.ids[0] == ecs_id(Position));
-
-    test_int(it.count, 1);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e);
-
-    test_assert(it.ptrs != NULL);
-    test_assert(it.columns != NULL);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_2_terms_1_filter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            { .id = ecs_id(Position), .inout = EcsInOutNone },
-            { .id = ecs_id(Velocity) }
-        }
-    });
-
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    ecs_set(world, e, Velocity, {1, 1});
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(ecs_query_next(&it), true);
-    test_assert(it.ids != NULL);
-    test_assert(it.ids[0] == ecs_id(Position));
-    test_assert(it.ids[1] == ecs_id(Velocity));
-
-    test_int(it.count, 1);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e);
-
-    test_assert(it.ptrs != NULL);
-    test_assert(it.sizes != NULL);
-    test_assert(it.columns != NULL);
-
-    test_assert(it.ptrs[0] == NULL);
-    test_assert(it.ptrs[1] != NULL);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_3_terms_2_filter(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-    ECS_COMPONENT(world, Mass);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            { .id = ecs_id(Position), .inout = EcsInOutNone },
-            { .id = ecs_id(Velocity), .inout = EcsInOutNone },
-            { .id = ecs_id(Mass) }
-        }
-    });
-
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
-    ecs_set(world, e, Velocity, {1, 1});
-    ecs_set(world, e, Mass, {1});
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(ecs_query_next(&it), true);
-    test_assert(it.ids != NULL);
-    test_assert(it.ids[0] == ecs_id(Position));
-    test_assert(it.ids[1] == ecs_id(Velocity));
-    test_assert(it.ids[2] == ecs_id(Mass));
-
-    test_int(it.count, 1);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e);
-
-    test_assert(it.ptrs != NULL);
-    test_assert(it.sizes != NULL);
-    test_assert(it.columns != NULL);
-
-    test_assert(it.ptrs[0] == NULL);
-    test_assert(it.ptrs[1] == NULL);
-    test_assert(it.ptrs[2] != NULL);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_no_instancing_w_singleton(void) {
-    ecs_world_t *world = ecs_mini();
-    
-    ECS_TAG(world, Tag);
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_singleton_set(world, Velocity, {1, 2});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {50, 60});
-
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity($)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e1);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e2);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e3);
-        test_int(p->x, 30);
-        test_int(p->y, 40);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e4);
-        test_int(p->x, 40);
-        test_int(p->y, 50);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e5);
-        test_int(p->x, 50);
-        test_int(p->y, 60);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_no_instancing_w_shared(void) {
-    ecs_world_t *world = ecs_mini();
-    
-    ECS_TAG(world, Tag);
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_entity_t base = ecs_set(world, 0, Velocity, {1, 2});
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {40, 50});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {50, 60});
-    ecs_add(world, e4, Tag);
-    ecs_add(world, e5, Tag);
-
-    ecs_add_pair(world, e1, EcsIsA, base);
-    ecs_add_pair(world, e2, EcsIsA, base);
-    ecs_add_pair(world, e3, EcsIsA, base);
-    ecs_add_pair(world, e4, EcsIsA, base);
-    ecs_add_pair(world, e5, EcsIsA, base);
-
-    ecs_entity_t e6 = ecs_set(world, 0, Position, {60, 70});
-    ecs_entity_t e7 = ecs_set(world, 0, Position, {70, 80});
-    ecs_set(world, e6, Velocity, {2, 3});
-    ecs_set(world, e7, Velocity, {4, 5});
-
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 2);
-        test_int(it.entities[0], e6);
-        test_int(p[0].x, 60);
-        test_int(p[0].y, 70);
-        test_int(v[0].x, 2);
-        test_int(v[0].y, 3);
-
-        test_int(it.entities[1], e7);
-        test_int(p[1].x, 70);
-        test_int(p[1].y, 80);
-        test_int(v[1].x, 4);
-        test_int(v[1].y, 5);
-    }
-
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e1);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e2);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e3);
-        test_int(p->x, 30);
-        test_int(p->y, 40);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e4);
-        test_int(p->x, 40);
-        test_int(p->y, 50);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(ecs_query_next(&it));
-    {
-        Position *p = ecs_field(&it, Position, 1);
-        Velocity *v = ecs_field(&it, Velocity, 2);
-        test_int(it.count, 1);
-        test_int(it.entities[0], e5);
-        test_int(p->x, 50);
-        test_int(p->y, 60);
-        test_int(v->x, 1);
-        test_int(v->y, 2);
-    }
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_iter_frame_offset(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, TagC);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            { .id = TagA, }
-        },
-    });
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_entity_t e4 = ecs_new(world, TagA);
-    ecs_entity_t e5 = ecs_new(world, TagA);
-
-    ecs_add(world, e3, TagB);
-    ecs_add(world, e4, TagB);
-    ecs_add(world, e5, TagC);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 2);
-    test_int(it.frame_offset, 0);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e1);
-    test_assert(it.entities[1] == e2);
-    test_assert(it.ids[0] == TagA);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 2);
-    test_int(it.frame_offset, 2);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e3);
-    test_assert(it.entities[1] == e4);
-    test_assert(it.ids[0] == TagA);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.frame_offset, 4);
-    test_assert(it.entities != NULL);
-    test_assert(it.entities[0] == e5);
-    test_assert(it.ids[0] == TagA);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_add_singleton_after_query(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            { TagA },
-            { TagB, .src.id = TagB }
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add(world, e, TagA);
-    
-    ecs_singleton_add(world, TagB);
-    test_assert(ecs_has(world, TagB, TagB));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool (ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e);
-    test_bool (ecs_query_next(&it), false);
-
-    ecs_singleton_remove(world, TagB);
-    test_assert(!ecs_has(world, TagB, TagB));
-
-    it = ecs_query_iter(world, q);
-    test_bool (ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_query_w_component_from_parent_from_non_this(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t parent = ecs_new(world, TagB);
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            { TagA },
-            { TagB, .src.id = child, .src.trav = EcsChildOf, .src.flags = EcsUp }
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add(world, e, TagA);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool (ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e);
-    test_int(it.sources[0], 0);
-    test_int(it.sources[1], parent);
-    test_bool (ecs_query_next(&it), false);
-
-    ecs_remove_pair(world, child, EcsChildOf, parent);
-    it = ecs_query_iter(world, q);
-    test_bool (ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Query_create_query_while_pending(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_entity_t e = ecs_new(world, TagA);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ TagA }}
-    });
-    test_assert(q != NULL);
-
-    ecs_add(world, e, TagB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert( ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e);
-
-    test_assert( !ecs_query_next(&it));
-    
-    ecs_fini(world);
-}
-
-void Query_empty_query(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ 0 }}
-    });
-    test_assert(q != NULL);
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_implicit_existing_isa_superset(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], base);
-    test_uint(it.sources[0], 0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_implicit_new_isa_superset(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], base);
-    test_uint(it.sources[0], 0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_superset(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(up)");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_superset_2_lvls(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(up)");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], base);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], base);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_superset_3_lvls(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(up)");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], base);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], base);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], base);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_superset_2_lvls_owned(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(up)");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
-
-    ecs_add(world, e1, Tag);
-    ecs_add(world, e2, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], base);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e1);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_superset_3_lvls_owned(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(up)");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
-
-    ecs_add(world, e1, Tag);
-    ecs_add(world, e2, Tag);
-    ecs_add(world, e3, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], base);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e1);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e2);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_superset_owned_empty_table_after_match(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(up)");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
-
-    ecs_add(world, e1, Tag);
-    ecs_add(world, e2, Tag);
-    ecs_add(world, e3, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], base);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e1);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e2);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove_pair(world, e3, EcsIsA, e2);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], base);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e1);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_self_superset(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(self|up)");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], base);
-    test_uint(it.sources[0], 0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_childof_superset(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(up(ChildOf))");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_superset_2_targets(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, R, EcsTraversable);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e_0 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e_1 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e_2 = ecs_set(world, 0, Position, {50, 60});
-    ecs_entity_t e_3 = ecs_set(world, 0, Position, {70, 80});
-
-    ecs_add_pair(world, e_3, R, e_2);
-    ecs_add_pair(world, e_2, R, e_1);
-    ecs_add_pair(world, e_1, R, e_0);
-
-    ecs_entity_t t = ecs_new_id(world);
-    ecs_add(world, t, Position);
-    ecs_add_pair(world, t, R, e_2);
-    ecs_add_pair(world, t, R, e_1);
-    ecs_delete(world, t);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(up(R))");
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_3);
-    test_uint(it.sources[0], e_2);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 50);
-    test_int(p[0].y, 60);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_2);
-    test_uint(it.sources[0], e_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_1);
-    test_uint(it.sources[0], e_0);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_superset_2_relations(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = TagA, .src.trav = EcsChildOf, .src.flags = EcsUp },
-            { .id = TagA, .src.trav = EcsIsA, .src.flags = EcsUp },
-        }
-    });
-
-    ecs_entity_t base = ecs_new(world, TagA);
-    ecs_entity_t parent = ecs_new(world, TagA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, EcsIsA, base);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add_pair(world, e2, EcsIsA, base);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(2, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(e2, it.entities[1]);
-    test_uint(parent, it.sources[0]);
-    test_uint(base, it.sources[1]);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_superset_2_relations_instanced(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = TagA, .src.trav = EcsChildOf, .src.flags = EcsUp },
-            { .id = TagA, .src.trav = EcsIsA, .src.flags = EcsUp },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t base = ecs_new(world, TagA);
-    ecs_entity_t parent = ecs_new(world, TagA);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, EcsIsA, base);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add_pair(world, e2, EcsIsA, base);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(2, it.count);
-    test_uint(e1, it.entities[0]);
-    test_uint(e2, it.entities[1]);
-    test_uint(parent, it.sources[0]);
-    test_uint(base, it.sources[1]);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_superset_2_relations_w_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position), .src.trav = EcsChildOf, .src.flags = EcsUp },
-            { .id = ecs_id(Position), .src.trav = EcsIsA, .src.flags = EcsUp },
-        }
-    });
-
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t parent = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, EcsIsA, base);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add_pair(world, e2, EcsIsA, base);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(true, ecs_query_next(&it));
-        test_int(1, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(parent, it.sources[0]);
-        test_uint(base, it.sources[1]);
-        Position *p1 = ecs_field(&it, Position, 1);
-        Position *p2 = ecs_field(&it, Position, 2);
-        test_assert(p1 != NULL);
-        test_assert(p2 != NULL);
-        test_int(p1->x, 30);
-        test_int(p1->y, 40);
-        test_int(p2->x, 10);
-        test_int(p2->y, 20);
-    }
-    {
-        test_bool(true, ecs_query_next(&it));
-        test_int(1, it.count);
-        test_uint(e2, it.entities[0]);
-        test_uint(parent, it.sources[0]);
-        test_uint(base, it.sources[1]);
-        Position *p1 = ecs_field(&it, Position, 1);
-        Position *p2 = ecs_field(&it, Position, 2);
-        test_assert(p1 != NULL);
-        test_assert(p2 != NULL);
-        test_int(p1->x, 30);
-        test_int(p1->y, 40);
-        test_int(p2->x, 10);
-        test_int(p2->y, 20);
-    }
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_superset_2_relations_instanced_w_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position), .src.trav = EcsChildOf, .src.flags = EcsUp },
-            { .id = ecs_id(Position), .src.trav = EcsIsA, .src.flags = EcsUp },
-        },
-        .filter.instanced = true
-    });
-
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t parent = ecs_set(world, 0, Position, {30, 40});
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, EcsIsA, base);
-    ecs_add_pair(world, e1, EcsChildOf, parent);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add_pair(world, e2, EcsIsA, base);
-    ecs_add_pair(world, e2, EcsChildOf, parent);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    {
-        test_bool(true, ecs_query_next(&it));
-        test_int(2, it.count);
-        test_uint(e1, it.entities[0]);
-        test_uint(e2, it.entities[1]);
-        test_uint(parent, it.sources[0]);
-        test_uint(base, it.sources[1]);
-        Position *p1 = ecs_field(&it, Position, 1);
-        Position *p2 = ecs_field(&it, Position, 2);
-        test_assert(p1 != NULL);
-        test_assert(p2 != NULL);
-        test_int(p1->x, 30);
-        test_int(p1->y, 40);
-        test_int(p2->x, 10);
-        test_int(p2->y, 20);
-    }
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_parent(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(parent)");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new(world, Tag);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_existing_isa_cascade(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, e0);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(cascade)");
-    test_assert(q != NULL);
-
-    ecs_add_id(world, e1, Bar); /* mix up order */
-    ecs_add_id(world, e2, Foo);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e0);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_new_isa_cascade(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(cascade)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, e0);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
-
-    ecs_add_id(world, e2, Foo); /* mix up order */
-    ecs_add_id(world, e1, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e0);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_childof_cascade(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(cascade(ChildOf))");
-    test_assert(q != NULL);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, e0);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, e1);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, e2);
-
-    ecs_add_id(world, e2, Foo); /* mix up order */
-    ecs_add_id(world, e1, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e0);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_parent_cascade(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(parent|cascade)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, e0);
-    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, e1);
-    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, e2);
-
-    ecs_add_id(world, e2, Foo); /* mix up order */
-    ecs_add_id(world, e1, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e0);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_existing_custom_rel_cascade(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_ENTITY(world, Rel, EcsTraversable);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, e0);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, e1);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, e2);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(cascade(Rel))");
-    test_assert(q != NULL);
-
-    ecs_add_id(world, e2, Foo); /* mix up order */
-    ecs_add_id(world, e1, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e0);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_new_custom_rel_cascade(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_ENTITY(world, Rel, EcsTraversable);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(cascade(Rel))");
-    test_assert(q != NULL);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, e0);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, e1);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, e2);
-
-    ecs_add_id(world, e2, Foo); /* mix up order */
-    ecs_add_id(world, e1, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e0);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_w_2_depths(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_ENTITY(world, Rel, EcsTraversable);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(cascade(Rel))");
-    test_assert(q != NULL);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, Rel, e0);
-    ecs_add_pair(world, e2, Rel, e1);
-    ecs_add_pair(world, e3, Rel, e2);
-
-    ecs_add_id(world, e2, Foo); /* mix up order */
-    ecs_add_id(world, e1, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e1);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e1);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_w_3_depths(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_ENTITY(world, Rel, EcsTraversable);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(cascade(Rel))");
-    test_assert(q != NULL);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, Rel, e0);
-    ecs_add_pair(world, e2, Rel, e1);
-    ecs_add_pair(world, e3, Rel, e2);
-
-    ecs_add_id(world, e2, Foo); /* mix up order */
-    ecs_add_id(world, e1, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e1);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e2);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_w_2_depths_desc(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_ENTITY(world, Rel, EcsTraversable);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(cascade|desc(Rel))");
-    test_assert(q != NULL);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, Rel, e0);
-    ecs_add_pair(world, e2, Rel, e1);
-    ecs_add_pair(world, e3, Rel, e2);
-
-    ecs_add_id(world, e2, Foo); /* mix up order */
-    ecs_add_id(world, e1, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e1);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e1);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_w_3_depths_desc(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_ENTITY(world, Rel, EcsTraversable);
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag(cascade|desc(Rel))");
-    test_assert(q != NULL);
-
-    ecs_entity_t e0 = ecs_new(world, Tag);
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_add_pair(world, e1, Rel, e0);
-    ecs_add_pair(world, e2, Rel, e1);
-    ecs_add_pair(world, e3, Rel, e2);
-
-    ecs_add_id(world, e2, Foo); /* mix up order */
-    ecs_add_id(world, e1, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.sources[0], e2);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(it.sources[0], e1);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.sources[0], e0);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_not_pair_relation_wildcard(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, ObjA);
-    ECS_TAG(world, ObjB);
-    
-    ecs_query_t *q = ecs_query_new(world, "Foo, !(*, ObjA)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_entity_t e4 = ecs_new(world, Foo);
-
-    ecs_add_pair(world, e1, RelA, ObjA);
-    ecs_add_pair(world, e2, RelA, ObjB);
-    ecs_add_pair(world, e3, RelB, ObjA);
-    ecs_add_pair(world, e4, RelB, ObjB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(EcsWildcard, ObjA));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e4);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(EcsWildcard, ObjA));
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_not_pair_object_wildcard(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, ObjA);
-    ECS_TAG(world, ObjB);
-    
-    ecs_query_t *q = ecs_query_new(world, "Foo, !(RelA, *)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_entity_t e4 = ecs_new(world, Foo);
-
-    ecs_add_pair(world, e1, RelA, ObjA);
-    ecs_add_pair(world, e2, RelA, ObjB);
-    ecs_add_pair(world, e3, RelB, ObjA);
-    ecs_add_pair(world, e4, RelB, ObjB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(RelA, EcsWildcard));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e4);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(RelA, EcsWildcard));
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_two_pair_wildcards_one_not(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, ObjA);
-    ECS_TAG(world, ObjB);
-    
-    ecs_query_t *q = ecs_query_new(world, "Foo, (RelA, *), !(RelB, *)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_entity_t e4 = ecs_new(world, Foo);
-
-    ecs_add_pair(world, e1, RelA, ObjA);
-    ecs_add_pair(world, e1, RelB, ObjA);
-
-    ecs_add_pair(world, e2, RelA, ObjA);
-
-    ecs_add_pair(world, e3, RelA, ObjB);
-    ecs_add_pair(world, e3, RelB, ObjB);
-
-    ecs_add_pair(world, e4, RelA, ObjB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(ecs_field_id(&it, 1), Foo);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(RelA, ObjA));
-    test_uint(ecs_field_id(&it, 3), ecs_pair(RelB, EcsWildcard));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e4);
-    test_uint(ecs_field_id(&it, 1), Foo);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(RelA, ObjB));
-    test_uint(ecs_field_id(&it, 3), ecs_pair(RelB, EcsWildcard));
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_two_pair_wildcards_one_not_any(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, RelA);
-    ECS_TAG(world, RelB);
-    ECS_TAG(world, ObjA);
-    ECS_TAG(world, ObjB);
-    
-    ecs_query_t *q = ecs_query_new(world, "Foo, (RelA, *), !(RelB, _)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
-    ecs_entity_t e3 = ecs_new(world, Foo);
-    ecs_entity_t e4 = ecs_new(world, Foo);
-
-    ecs_add_pair(world, e1, RelA, ObjA);
-    ecs_add_pair(world, e1, RelB, ObjA);
-
-    ecs_add_pair(world, e2, RelA, ObjA);
-
-    ecs_add_pair(world, e3, RelA, ObjB);
-    ecs_add_pair(world, e3, RelB, ObjB);
-
-    ecs_add_pair(world, e4, RelA, ObjB);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    test_uint(ecs_field_id(&it, 1), Foo);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(RelA, ObjA));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e4);
-    test_uint(ecs_field_id(&it, 1), Foo);
-    test_uint(ecs_field_id(&it, 2), ecs_pair(RelA, ObjB));
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_rematch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base_1);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 2);
-    test_uint(it.entities[0], base_1);
-    test_uint(it.entities[1], base_2);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 30);
-    test_int(p[1].y, 40);
-    test_uint(it.sources[0], 0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_uint(it.sources[0], base_1);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove_pair(world, inst, EcsIsA, base_1);
-    ecs_add_pair(world, inst, EcsIsA, base_2);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 2);
-    test_uint(it.entities[0], base_1);
-    test_uint(it.entities[1], base_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 30);
-    test_int(p[1].y, 40);
-    test_uint(it.sources[0], 0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_uint(it.sources[0], base_2);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_childof_rematch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base_1);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_uint(it.sources[0], base_1);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_add_pair(world, inst, EcsChildOf, base_2);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_uint(it.sources[0], base_2);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_unmatch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base_1);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 2);
-    test_uint(it.entities[0], base_1);
-    test_uint(it.entities[1], base_2);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 30);
-    test_int(p[1].y, 40);
-    test_uint(it.sources[0], 0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_uint(it.sources[0], base_1);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove(world, base_1, Position);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], base_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_uint(it.sources[0], 0);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_childof_unmatch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base_1);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_uint(it.sources[0], base_1);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove(world, base_1, Position);
-
-    it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_isa_rematch_2_lvls(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t base = ecs_new_w_pair(world, EcsIsA, base_1);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 2);
-    test_uint(it.entities[0], base_1);
-    test_uint(it.entities[1], base_2);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 30);
-    test_int(p[1].y, 40);
-    test_uint(it.sources[0], 0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], base);
-    test_uint(it.sources[0], base_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove_pair(world, base, EcsIsA, base_1);
-    ecs_add_pair(world, base, EcsIsA, base_2);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 2);
-    test_uint(it.entities[0], base_1);
-    test_uint(it.entities[1], base_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 30);
-    test_int(p[1].y, 40);
-    test_uint(it.sources[0], 0);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], base);
-    test_uint(it.sources[0], base_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_childof_rematch_2_lvls(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t base = ecs_new_w_pair(world, EcsChildOf, base_1);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], base);
-    test_uint(it.sources[0], base_1);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_add_pair(world, base, EcsChildOf, base_2);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], base);
-    test_uint(it.sources[0], base_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_rematch_2_lvls(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e_0 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e_1 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e_2 = ecs_set(world, 0, Position, {50, 60});
-    ecs_entity_t e_3 = ecs_set(world, 0, Position, {70, 80});
-    ecs_add_pair(world, e_3, EcsChildOf, e_2);
-
-    ecs_add_pair(world, e_2, EcsChildOf, e_1);
-    ecs_add_pair(world, e_1, EcsChildOf, e_0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(cascade(ChildOf))");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_1);
-    test_uint(it.sources[0], e_0);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_2);
-    test_uint(it.sources[0], e_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_3);
-    test_uint(it.sources[0], e_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 50);
-    test_int(p[0].y, 60);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove_pair(world, e_1, EcsChildOf, EcsWildcard);
-    ecs_remove_pair(world, e_2, EcsChildOf, EcsWildcard);
-    ecs_remove_pair(world, e_3, EcsChildOf, EcsWildcard);
-
-    ecs_add_pair(world, e_0, EcsChildOf, e_1);
-    ecs_add_pair(world, e_1, EcsChildOf, e_2);
-    ecs_add_pair(world, e_2, EcsChildOf, e_3);
-
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_2);
-    test_uint(it.sources[0], e_3);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 70);
-    test_int(p[0].y, 80);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_1);
-    test_uint(it.sources[0], e_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 50);
-    test_int(p[0].y, 60);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_0);
-    test_uint(it.sources[0], e_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_rematch_2_lvls_2_relations(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, R, EcsTraversable);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e_0 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e_1 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e_2 = ecs_set(world, 0, Position, {50, 60});
-    ecs_entity_t e_3 = ecs_set(world, 0, Position, {70, 80});
-
-    ecs_add_pair(world, e_3, R, e_2);
-    ecs_add_pair(world, e_2, R, e_1);
-    ecs_add_pair(world, e_1, R, e_0);
-
-    ecs_entity_t t = ecs_new_id(world);
-    ecs_add(world, t, Position);
-    ecs_add_pair(world, t, R, e_2);
-    ecs_add_pair(world, t, R, e_1);
-    ecs_delete(world, t);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(cascade(R))");
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_1);
-    test_uint(it.sources[0], e_0);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_2);
-    test_uint(it.sources[0], e_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_3);
-    test_uint(it.sources[0], e_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 50);
-    test_int(p[0].y, 60);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_topological(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, R, Traversable);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-
-    ecs_add_pair(world, e3, R, e1);
-    ecs_add_pair(world, e3, R, e2);
-    ecs_add_pair(world, e3, R, e4);
-    ecs_add_pair(world, e1, R, e5);
-    ecs_add_pair(world, e2, R, e6);
-    ecs_add_pair(world, e4, R, e1);
-    ecs_add_pair(world, e4, R, e2);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag, ?Tag(cascade(R))");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(2, it.count);
-    test_uint(it.entities[0], e5);
-    test_uint(it.entities[1], e6);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(it.entities[0], e1);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(it.entities[0], e2);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(it.entities[0], e4);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(it.entities[0], e3);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_desc_rematch_2_lvls(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e_0 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e_1 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e_2 = ecs_set(world, 0, Position, {50, 60});
-    ecs_entity_t e_3 = ecs_set(world, 0, Position, {70, 80});
-    
-    ecs_add_pair(world, e_3, EcsChildOf, e_2);
-    ecs_add_pair(world, e_2, EcsChildOf, e_1);
-    ecs_add_pair(world, e_1, EcsChildOf, e_0);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(cascade|desc(ChildOf))");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_3);
-    test_uint(it.sources[0], e_2);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 50);
-    test_int(p[0].y, 60);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_2);
-    test_uint(it.sources[0], e_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_1);
-    test_uint(it.sources[0], e_0);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove_pair(world, e_1, EcsChildOf, EcsWildcard);
-    ecs_remove_pair(world, e_2, EcsChildOf, EcsWildcard);
-    ecs_remove_pair(world, e_3, EcsChildOf, EcsWildcard);
-
-    ecs_add_pair(world, e_0, EcsChildOf, e_1);
-    ecs_add_pair(world, e_1, EcsChildOf, e_2);
-    ecs_add_pair(world, e_2, EcsChildOf, e_3);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_0);
-    test_uint(it.sources[0], e_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_1);
-    test_uint(it.sources[0], e_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 50);
-    test_int(p[0].y, 60);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_2);
-    test_uint(it.sources[0], e_3);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 70);
-    test_int(p[0].y, 80);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_desc_rematch_2_lvls_2_relations(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, R, EcsTraversable);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e_0 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e_1 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e_2 = ecs_set(world, 0, Position, {50, 60});
-    ecs_entity_t e_3 = ecs_set(world, 0, Position, {70, 80});
-
-    ecs_add_pair(world, e_3, R, e_2);
-    ecs_add_pair(world, e_2, R, e_1);
-    ecs_add_pair(world, e_1, R, e_0);
-
-    ecs_entity_t t = ecs_new_id(world);
-    ecs_add(world, t, Position);
-    ecs_add_pair(world, t, R, e_2);
-    ecs_add_pair(world, t, R, e_1);
-    ecs_delete(world, t);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(cascade|desc(R))");
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_3);
-    test_uint(it.sources[0], e_2);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 50);
-    test_int(p[0].y, 60);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_2);
-    test_uint(it.sources[0], e_1);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e_1);
-    test_uint(it.sources[0], e_0);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_cascade_desc_topological(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, R, Traversable);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-
-    ecs_add_pair(world, e3, R, e1);
-    ecs_add_pair(world, e3, R, e2);
-    ecs_add_pair(world, e3, R, e4);
-    ecs_add_pair(world, e1, R, e5);
-    ecs_add_pair(world, e2, R, e6);
-    ecs_add_pair(world, e4, R, e1);
-    ecs_add_pair(world, e4, R, e2);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag, ?Tag(cascade|desc(R))");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(it.entities[0], e3);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(it.entities[0], e4);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(it.entities[0], e1);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(it.entities[0], e2);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(2, it.count);
-    test_uint(it.entities[0], e5);
-    test_uint(it.entities[1], e6);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_childof_rematch_from_isa(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t base = ecs_new_w_pair(world, EcsIsA, base_1);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base);
-
-    ecs_query_t *q = ecs_query_new(world, "Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base_1);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove_pair(world, base, EcsIsA, base_1);
-    ecs_add_pair(world, base, EcsIsA, base_2);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_uint(it.sources[0], base_2);
-    p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 30);
-    test_int(p[0].y, 40);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_rematch_optional_ref(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag, ?Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_entity_t parent = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t child = ecs_new(world, Tag);
-    ecs_add_pair(world, child, EcsChildOf, parent);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    test_bool(true, ecs_field_is_set(&it, 1));
-    test_bool(true, ecs_field_is_set(&it, 2));
-    test_uint(0, it.sources[0]);
-    test_uint(parent, it.sources[1]);
-    Position *p = ecs_field(&it, Position, 2);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove(world, parent, Position);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    test_bool(true, ecs_field_is_set(&it, 1));
-    test_bool(false, ecs_field_is_set(&it, 2));
-    test_uint(0, it.sources[0]);
-    test_uint(0, it.sources[1]);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_rematch_optional_ref_w_2_refs(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag, Velocity(parent), ?Position(parent)");
-    test_assert(q != NULL);
-
-    ecs_entity_t parent = ecs_set(world, 0, Position, {10, 20});
-    ecs_set(world, parent, Velocity, {1, 2});
-    ecs_entity_t child = ecs_new(world, Tag);
-    ecs_add_pair(world, child, EcsChildOf, parent);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 3));
-    test_bool(true, ecs_field_is_set(&it, 1));
-    test_bool(true, ecs_field_is_set(&it, 2));
-    test_bool(true, ecs_field_is_set(&it, 3));
-    test_uint(0, it.sources[0]);
-    test_uint(parent, it.sources[1]);
-    Velocity *v = ecs_field(&it, Velocity, 2);
-    test_assert(v != NULL);
-    test_int(v->x, 1);
-    test_int(v->y, 2);
-    Position *p = ecs_field(&it, Position, 3);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove(world, parent, Position);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(Tag, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 3));
-    test_bool(true, ecs_field_is_set(&it, 1));
-    test_bool(true, ecs_field_is_set(&it, 2));
-    test_bool(false, ecs_field_is_set(&it, 3));
-    test_uint(0, it.sources[0]);
-    test_uint(parent, it.sources[1]);
-    test_uint(0, it.sources[2]);
-    v = ecs_field(&it, Velocity, 2);
-    test_assert(v != NULL);
-    test_int(v->x, 1);
-    test_int(v->y, 2);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_rematch_optional_ref_tag_w_ref_component(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_query_t *q = ecs_query_new(world, "TagA, ?Position(parent), TagB(parent)");
-    test_assert(q != NULL);
-
-    ecs_entity_t parent = ecs_set(world, 0, Position, {10, 20});
-    ecs_add(world, parent, TagB);
-
-    ecs_entity_t child = ecs_new(world, TagA);
-    ecs_add_pair(world, child, EcsChildOf, parent);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    test_bool(true, ecs_field_is_set(&it, 1));
-    test_bool(true, ecs_field_is_set(&it, 2));
-    test_bool(true, ecs_field_is_set(&it, 3));
-    test_uint(0, it.sources[0]);
-    test_uint(parent, it.sources[1]);
-    test_uint(parent, it.sources[2]);
-    Position *p = ecs_field(&it, Position, 2);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_remove(world, parent, Position);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(child, it.entities[0]);
-    test_uint(TagA, ecs_field_id(&it, 1));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
-    test_bool(true, ecs_field_is_set(&it, 1));
-    test_bool(false, ecs_field_is_set(&it, 2));
-    test_bool(true, ecs_field_is_set(&it, 3));
-    test_uint(0, it.sources[0]);
-    test_uint(0, it.sources[1]);
-    test_uint(parent, it.sources[2]);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_match_query_expr_from_scope(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t foo = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .name = "Foo"
-    });
-
-    ecs_entity_t bar = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .name = "Foo.Bar"
-    });
-
-    ecs_set_scope(world, foo);
-
-    ecs_query_t *q = ecs_query_new(world, "Bar");
-    test_assert(q != NULL);
-
-    ecs_set_scope(world, 0);
-
-    ecs_entity_t e = ecs_new_w_id(world, bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(bar, ecs_field_id(&it, 1));
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_long_or_w_ref(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_TAG(world, A);
-    ECS_TAG(world, B);
-    ECS_TAG(world, C);
-    ECS_TAG(world, D);
-    ECS_TAG(world, E);
-    ECS_TAG(world, F);
-    ECS_TAG(world, G);
-    ECS_TAG(world, H);
-    ECS_TAG(world, I);
-    ECS_TAG(world, J);
-    ECS_TAG(world, K);
-    ECS_TAG(world, L);
-    ECS_TAG(world, M);
-    ECS_TAG(world, N);
-    ECS_TAG(world, O);
-    ECS_TAG(world, P);
-    ECS_TAG(world, Q);
-    ECS_TAG(world, R);
-
-    ecs_entity_t e = ecs_new_entity(world, "e");
-    ecs_set(world, e, Position, {10, 20});
-
-    ecs_entity_t e2 = ecs_new(world, A);
-
-    ecs_query_t *q = ecs_query_new(world, 
-        "Position(e), A || B || C || D || E || F || G || H || I || J || K || L ||"
-        "M || N || O || P || Q || R");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(A, ecs_field_id(&it, 2));
-    test_uint(e2, it.entities[0]);
-    test_uint(e, it.sources[0]);
-    test_uint(0, it.sources[1]);
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_0_query(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_query_t *q = ecs_query_new(world, "0");
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_pair_id_and_subj(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Obj);
-    ECS_TAG(world, Subj);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{
-            .id = ecs_pair(Rel, Obj), .src.id = Subj
-        }}
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_add_pair(world, Subj, Rel, Obj);
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 0);
-    test_uint(it.sources[0], Subj);
-    test_uint(it.ids[0], ecs_pair(Rel, Obj));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_table_count(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{
-            .id = TagA
-        }}
-    });
-    test_assert(q != NULL);
-
-    test_int(0, ecs_query_table_count(q));
-
-    ecs_new(world, TagA);
-
-    test_int(1, ecs_query_table_count(q));
-
-    ecs_entity_t e = ecs_new(world, TagA);
-
-    test_int(1, ecs_query_table_count(q));
-
-    ecs_add(world, e, TagB);
-
-    test_int(2, ecs_query_table_count(q));
-
-    ecs_delete_with(world, TagB);
-
-    test_int(1, ecs_query_table_count(q));
-
-    ecs_delete_with(world, TagA);
-
-    test_int(0, ecs_query_table_count(q));
-
-    ecs_fini(world);
-}
-
-void Query_empty_table_count(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{
-            .id = TagA
-        }}
-    });
-    test_assert(q != NULL);
-
-    test_int(0, ecs_query_empty_table_count(q));
-
-    ecs_entity_t e = ecs_new(world, TagA);
-
-    test_int(0, ecs_query_empty_table_count(q));
-
-    ecs_delete(world, e);
-
-    test_int(1, ecs_query_empty_table_count(q));
-
-    ecs_fini(world);
-}
-
-void Query_entity_count(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{
-            .id = TagA
-        }}
-    });
-    test_assert(q != NULL);
-
-    test_int(0, ecs_query_entity_count(q));
-
-    ecs_entity_t e1 = ecs_new(world, TagA);
-
-    test_int(1, ecs_query_entity_count(q));
-
-    ecs_entity_t e2 = ecs_new(world, TagA);
-
-    test_int(2, ecs_query_entity_count(q));
-
-    ecs_add(world, e2, TagB);
-
-    test_int(2, ecs_query_entity_count(q));
-
-    ecs_delete(world, e1);
-
-    test_int(1, ecs_query_entity_count(q));
-
-    ecs_delete(world, e2);
-
-    test_int(0, ecs_query_entity_count(q));
-
-    ecs_fini(world);
-}
-
-void Query_rematch_after_delete_inherited_tag(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t tag = ecs_new_id(world);
-    ecs_entity_t base = ecs_new_w_id(world, tag);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            { .id = tag }
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(base, it.entities[0]);
-    test_uint(tag, ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(inst, it.entities[0]);
-    test_uint(tag, ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_delete_with(world, tag);
-
-    it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_rematch_after_delete_rel_of_inherited_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
-    ecs_entity_t base = ecs_new_w_pair(world, rel, obj);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            { .id = ecs_pair(rel, obj) }
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(base, it.entities[0]);
-    test_uint(ecs_pair(rel, obj), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(inst, it.entities[0]);
-    test_uint(ecs_pair(rel, obj), ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_delete_with(world, ecs_pair(rel, EcsWildcard));
-
-    it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_rematch_after_delete_obj_of_inherited_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
-    ecs_entity_t base = ecs_new_w_pair(world, rel, obj);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
-            { .id = ecs_pair(rel, obj) }
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(base, it.entities[0]);
-    test_uint(ecs_pair(rel, obj), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(inst, it.entities[0]);
-    test_uint(ecs_pair(rel, obj), ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_delete_with(world, ecs_pair(EcsWildcard, obj));
-
-    it = ecs_query_iter(world, q);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_rematch_empty_table_w_superset(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ Foo }, { Bar, .oper = EcsNot }}
-    });
-
-    ecs_entity_t base = ecs_new_w_id(world, EcsPrefab);
-    ecs_add(world, base, Foo);
-    test_assert( ecs_is_alive(world, base));
-
-    ecs_delete_with(world, Foo);
-    test_assert( !ecs_is_alive(world, base));
-
-    base = ecs_new_w_id(world, EcsPrefab);
-    ecs_add(world, base, Foo);
-
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_add(world, inst, Bar);
-
-    ecs_run_aperiodic(world, 0); // force table (IsA, base) to empty list
-
-    ecs_remove(world, inst, Bar);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], inst);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_short_notation(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = Foo
-        }}
-    });
-
-    test_assert(q != NULL);
-
-    ecs_entity_t e = ecs_new(world, Foo);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e);
-    test_uint(it.ids[0], ecs_field_id(&it, 1));
-    test_assert(!ecs_query_next(&it));
-
-    ecs_query_fini(q);
-
-    ecs_fini(world);
-}
-
-void Query_query_w_invalid_filter_flag(void) {
-    install_test_abort();
-
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    test_expect_abort();
-    ecs_query(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position), .src.flags = EcsFilter }
-        }
-    });
-}
-
-
-void Query_query_next_table(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position)
-        }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e1));
-
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e2));
-    test_bool(false, ecs_query_next_table(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_next_table_w_populate(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position)
-        }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e1));
-    ecs_query_populate(&it, false);
-    test_int(1, it.count);
-    test_assert(it.table == ecs_get_table(world, e1));
-    test_uint(it.entities[0], e1);
-
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e2));
-    ecs_query_populate(&it, false);
-    test_int(1, it.count);
-    test_assert(it.table == ecs_get_table(world, e2));
-    test_uint(it.entities[0], e2);
-    test_bool(false, ecs_query_next_table(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_next_table_w_changed(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position)
-        }}
-    });
-
-    ecs_query_t *qr = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .inout = EcsIn
-        }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Tag);
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-    ecs_iter_t it = ecs_query_iter(world, qr);
-    while (ecs_query_next_table(&it)) { }
-    test_bool(false, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e1));
-
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e2));
-    test_bool(false, ecs_query_next_table(&it));
-
-    test_bool(false, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, qr);
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(false, ecs_query_changed(NULL, &it));
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(false, ecs_query_changed(NULL, &it));
-    test_bool(false, ecs_query_next_table(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_next_table_w_skip(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position)
-        }}
-    });
-
-    ecs_query_t *qr = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .inout = EcsIn
-        }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Tag);
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-    ecs_iter_t it = ecs_query_iter(world, qr);
-    while (ecs_query_next(&it)) { }
-    test_bool(false, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e1));
-
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e2));
-    ecs_query_skip(&it);
-    test_bool(false, ecs_query_next_table(&it));
-
-    test_bool(false, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, qr);
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(NULL, &it));
-    test_bool(true, ecs_query_next(&it));
-    test_bool(false, ecs_query_changed(NULL, &it));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_next_table_w_populate_first_changed(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position)
-        }}
-    });
-
-    ecs_query_t *qr = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .inout = EcsIn
-        }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Tag);
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-    ecs_iter_t it = ecs_query_iter(world, qr);
-    while (ecs_query_next(&it)) { }
-    test_bool(false, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e1));
-    ecs_query_populate(&it, false);
-    test_int(1, it.count);
-
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e2));
-    test_bool(false, ecs_query_next_table(&it));
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, qr);
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(true, ecs_query_changed(NULL, &it));
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(false, ecs_query_changed(NULL, &it));
-    test_bool(false, ecs_query_next_table(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_next_table_w_populate_last_changed(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position)
-        }}
-    });
-
-    ecs_query_t *qr = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .inout = EcsIn
-        }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Tag);
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-    ecs_iter_t it = ecs_query_iter(world, qr);
-    while (ecs_query_next(&it)) { }
-    test_bool(false, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e1));
-
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e2));
-    ecs_query_populate(&it, false);
-    test_int(1, it.count);
-    test_bool(false, ecs_query_next_table(&it));
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, qr);
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(false, ecs_query_changed(NULL, &it));
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(true, ecs_query_changed(NULL, &it));
-    test_bool(false, ecs_query_next_table(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_next_table_w_populate_skip_first(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position)
-        }}
-    });
-
-    ecs_query_t *qr = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .inout = EcsIn
-        }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Tag);
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-    ecs_iter_t it = ecs_query_iter(world, qr);
-    while (ecs_query_next(&it)) { }
-    test_bool(false, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e1));
-    ecs_query_populate(&it, false);
-    ecs_query_skip(&it);
-    test_int(1, it.count);
-
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e2));
-    ecs_query_populate(&it, false);
-    test_int(1, it.count);
-    test_bool(false, ecs_query_next_table(&it));
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, qr);
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(false, ecs_query_changed(NULL, &it));
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(true, ecs_query_changed(NULL, &it));
-    test_bool(false, ecs_query_next_table(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_next_table_w_populate_skip_last(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position)
-        }}
-    });
-
-    ecs_query_t *qr = ecs_query(world, {
-        .filter.terms = {{
-            .id = ecs_id(Position),
-            .inout = EcsIn
-        }}
-    });
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {20, 30});
-    ecs_add(world, e2, Tag);
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-    ecs_iter_t it = ecs_query_iter(world, qr);
-    while (ecs_query_next(&it)) { }
-    test_bool(false, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e1));
-    ecs_query_populate(&it, false);
-    test_int(1, it.count);
-
-    test_bool(true, ecs_query_next_table(&it));
-    test_int(0, it.count);
-    test_assert(it.table == ecs_get_table(world, e2));
-    ecs_query_populate(&it, false);
-    test_int(1, it.count);
-    ecs_query_skip(&it);
-    test_bool(false, ecs_query_next_table(&it));
-
-    test_bool(true, ecs_query_changed(qr, NULL));
-
-    it = ecs_query_iter(world, qr);
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(true, ecs_query_changed(NULL, &it));
-    test_bool(true, ecs_query_next_table(&it));
-    test_bool(false, ecs_query_changed(NULL, &it));
-    test_bool(false, ecs_query_next_table(&it));
-
-    ecs_fini(world);
-}
-
-void Query_create_query_existing_query_entity(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Foo);
-    ECS_TAG(world, Bar);
-
-    ecs_query_t *q_1 = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.entity = ecs_entity(world, { .name = "q" }),
-        .filter.terms = {
-            { .id = Foo },
-            { .id = Bar }
-        },
-    });
-
-    test_assert(q_1 != NULL);
-
-    ecs_query_t *q_2 = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.entity = ecs_entity(world, { .name = "q" }),
-        .filter.terms = {
-            { .id = Foo },
-            { .id = Bar }
-        },
-    });
-
-    test_assert(q_2 != NULL);
-
-    ecs_fini(world);
-}
-
-void Query_query_for_recycled_pair(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t rel = ecs_new_entity(world, "Rel");
-    ecs_entity_t tgt = ecs_new_entity(world, "Tgt");
-    ecs_delete(world, rel);
-    ecs_delete(world, tgt);
-    rel = ecs_new_entity(world, "Rel");
-    tgt = ecs_new_entity(world, "Tgt");
-
-    ecs_entity_t e = ecs_new_w_pair(world, rel, tgt);
-
-    ecs_query_t *q = ecs_query(world, {
-        .filter.terms[0] = {
-            .first.id = rel,
-            .second.id = tgt
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e);
-    test_uint(ecs_field_id(&it, 1), ecs_pair(rel, tgt));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Query_query_w_singleton_w_rule_iter(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_TAG(ecs, Tag);
-    ECS_TAG(ecs, Singleton);
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            {Singleton, .src.id = Singleton}, {Tag}
-        }
-    });
-
-    ecs_rule_t *r = ecs_rule(ecs, {
-        .terms = {{Tag}}
-    });
-
-    ecs_singleton_add(ecs, Singleton);
-    ecs_entity_t e = ecs_new(ecs, Tag);
-
-    ecs_iter_t qit = ecs_query_iter(ecs, q);
-    test_bool(true, ecs_query_next(&qit));
-    test_int(1, qit.count);
-    test_uint(e, qit.entities[0]);
-
-    ecs_id_t id = qit.ids[0];
-    ecs_iter_t rit = ecs_rule_iter(ecs, r);
-    test_bool(true, ecs_rule_next(&rit));
-    test_int(1, rit.count);
-    test_uint(e, rit.entities[0]);
-    test_bool(false, ecs_rule_next(&rit));
-    test_assert(id == qit.ids[0]);
-    test_bool(false, ecs_query_next(&qit));
-
-    ecs_rule_fini(r);
-
-    ecs_fini(ecs);
-}
-
-void Query_query_w_singleton_nested_iter(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_TAG(ecs, TagA);
-    ECS_TAG(ecs, TagB);
-    ECS_TAG(ecs, Singleton);
-
-    ecs_query_t *qa = ecs_query(ecs, {
-        .filter.terms = {
-            {TagA}, {Singleton, .src.id = Singleton}
-        }
-    });
-
-    ecs_query_t *qb = ecs_query(ecs, {
-        .filter.terms = {
-            {TagB}, {Singleton, .src.id = Singleton}
-        }
-    });
-
-    ecs_singleton_add(ecs, Singleton);
-
-    ecs_entity_t ea = ecs_new(ecs, TagA);
-    ecs_entity_t eb = ecs_new(ecs, TagB);
-
-    ecs_iter_t qita = ecs_query_iter(ecs, qa);
-    ecs_iter_t qitb = ecs_query_iter(ecs, qb);
-
-    test_bool(ecs_query_next(&qita), true);
-    test_int(1, qita.count);
-    test_uint(ea, qita.entities[0]);
-
-    test_bool(ecs_query_next(&qitb), true);
-    test_int(1, qitb.count);
-    test_uint(eb, qitb.entities[0]);
-
-    test_uint(TagA, qita.ids[0]);
-    test_uint(TagB, qitb.ids[0]);
-
-    test_bool(ecs_query_next(&qita), false);
-    test_bool(ecs_query_next(&qitb), false);
-
-    ecs_fini(ecs);
-}
-
-void Query_query_w_singleton_interleaved_iter(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_TAG(ecs, TagA);
-    ECS_TAG(ecs, TagB);
-    ECS_TAG(ecs, TagC);
-    ECS_TAG(ecs, Singleton);
-
-    ecs_query_t *qa = ecs_query(ecs, {
-        .filter.terms = {
-            {TagA}, {Singleton, .src.id = Singleton}
-        }
-    });
-
-    ecs_query_t *qb = ecs_query(ecs, {
-        .filter.terms = {
-            {TagB}, {Singleton, .src.id = Singleton}
-        }
-    });
-
-    ecs_query_t *qc = ecs_query(ecs, {
-        .filter.terms = {
-            {TagC}, {Singleton, .src.id = Singleton}
-        }
-    });
-
-    ecs_singleton_add(ecs, Singleton);
-
-    ecs_entity_t ea = ecs_new(ecs, TagA);
-    ecs_entity_t eb = ecs_new(ecs, TagB);
-    ecs_entity_t ec = ecs_new(ecs, TagC);
-
-    ecs_iter_t qita = ecs_query_iter(ecs, qa);
-    ecs_iter_t qitb = ecs_query_iter(ecs, qb);
-
-    test_bool(ecs_query_next(&qita), true);
-    test_int(1, qita.count);
-    test_uint(ea, qita.entities[0]);
-
-    test_bool(ecs_query_next(&qitb), true);
-    test_int(1, qitb.count);
-    test_uint(eb, qitb.entities[0]);
-
-    test_uint(TagA, qita.ids[0]);
-    test_uint(TagB, qitb.ids[0]);
-
-    test_bool(ecs_query_next(&qita), false);
-
-    ecs_iter_t qitc = ecs_query_iter(ecs, qc);
-    test_bool(ecs_query_next(&qitc), true);
-    test_int(1, qitc.count);
-    test_uint(ec, qitc.entities[0]);
-
-    test_uint(TagB, qitb.ids[0]);
-    test_uint(TagC, qitc.ids[0]);
-
-    test_bool(ecs_query_next(&qitb), false);
-    test_bool(ecs_query_next(&qitc), false);
-
-    ecs_fini(ecs);
-}
-
-void Query_recycled_component_id(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    for (int i = 0; i < FLECS_HI_COMPONENT_ID; i ++) {
-        ecs_new_low_id(ecs);
-    }
-
-    ecs_entity_t e = ecs_new_id(ecs);
-    ecs_delete(ecs, e);
-
-    ECS_COMPONENT(ecs, Position);
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) }
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_set(ecs, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(ecs, 0, Position, {20, 30});
-
-    ecs_iter_t it = ecs_query_iter(ecs, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 2);
-    test_uint(it.entities[0], e1);
-    test_uint(it.entities[1], e2);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 10);
-    test_int(p[0].y, 20);
-    test_int(p[1].x, 20);
-    test_int(p[1].y, 30);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(ecs);
-}
-
-void Query_set_get_context(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_COMPONENT(ecs, Position);
-
-    int ctx = 0;
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) }
-        },
-        .ctx = &ctx
-    });
-    test_assert(q != NULL);
-
-    test_assert(ecs_query_get_ctx(q) == &ctx);
-    test_assert(ecs_query_get_binding_ctx(q) == NULL);
-
-    ecs_fini(ecs);
-}
-
-void Query_set_get_binding_context(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_COMPONENT(ecs, Position);
-
-    int ctx = 0;
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) }
-        },
-        .binding_ctx = &ctx
-    });
-    test_assert(q != NULL);
-
-    test_assert(ecs_query_get_binding_ctx(q) == &ctx);
-    test_assert(ecs_query_get_ctx(q) == NULL);
-
-    ecs_fini(ecs);
-}
-
-static void ctx_free(void *ptr) {
-    *(int*)ptr = 10;
-}
-
-void Query_set_get_context_w_free(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_COMPONENT(ecs, Position);
-
-    int ctx = 0;
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) }
-        },
-        .ctx = &ctx,
-        .ctx_free = ctx_free
-    });
-    test_assert(q != NULL);
-
-    test_assert(ecs_query_get_ctx(q) == &ctx);
-    test_assert(ecs_query_get_binding_ctx(q) == NULL);
-    test_int(ctx, 0);
-
-    ecs_query_fini(q);
-
-    test_int(ctx, 10);
-
-    ecs_fini(ecs);
-}
-
-void Query_set_get_binding_context_w_free(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_COMPONENT(ecs, Position);
-
-    int ctx = 0;
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) }
-        },
-        .binding_ctx = &ctx,
-        .binding_ctx_free = ctx_free
-    });
-    test_assert(q != NULL);
-
-    test_assert(ecs_query_get_binding_ctx(q) == &ctx);
-    test_assert(ecs_query_get_ctx(q) == NULL);
-    test_int(ctx, 0);
-
-    ecs_query_fini(q);
-
-    test_int(ctx, 10);
-
-    ecs_fini(ecs);
-}
-
-void Query_set_this(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_COMPONENT(ecs, Position);
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) }
-        }
-    });
-    test_assert(q != NULL);
-
-    /* ecs_entity_t e1 = */ ecs_set(ecs, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(ecs, 0, Position, {20, 30});
-    /* ecs_entity_t e3 = */ ecs_set(ecs, 0, Position, {30, 40});
-
-    ecs_iter_t it = ecs_query_iter(ecs, q);
-    ecs_iter_set_var(&it, 0, e2);
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e2);
-    Position *p = ecs_field(&it, Position, 1);
-    test_int(p[0].x, 20);
-    test_int(p[0].y, 30);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(ecs);
-}
-
-void Query_set_this_no_match(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_COMPONENT(ecs, Position);
-    ECS_COMPONENT(ecs, Velocity);
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) }
-        }
-    });
-    test_assert(q != NULL);
-
-    /* ecs_entity_t e1 = */ ecs_set(ecs, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(ecs, 0, Velocity, {20, 30});
-    /* ecs_entity_t e3 = */ ecs_set(ecs, 0, Position, {30, 40});
-
-    ecs_iter_t it = ecs_query_iter(ecs, q);
-    ecs_iter_set_var(&it, 0, e2);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(ecs);
-}
-
-void Query_set_this_is_true(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_COMPONENT(ecs, Position);
-    ECS_COMPONENT(ecs, Velocity);
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) }
-        }
-    });
-    test_assert(q != NULL);
-
-    /* ecs_entity_t e1 = */ ecs_set(ecs, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(ecs, 0, Position, {20, 30});
-    /* ecs_entity_t e3 = */ ecs_set(ecs, 0, Position, {30, 40});
-    ecs_entity_t e4 = ecs_set(ecs, 0, Velocity, {20, 30});
-
-    ecs_iter_t it = ecs_query_iter(ecs, q);
-    ecs_iter_set_var(&it, 0, e2);
-    test_bool(true, ecs_iter_is_true(&it));
-
-    it = ecs_query_iter(ecs, q);
-    ecs_iter_set_var(&it, 0, e4);
-    test_bool(false, ecs_iter_is_true(&it));
-
-    ecs_fini(ecs);
-}
-
-void Query_set_this_w_wildcard(void) {
-    ecs_world_t* ecs = ecs_init();
-
-    ECS_COMPONENT(ecs, Position);
-    ECS_TAG(ecs, Likes);
-    ECS_TAG(ecs, Apples);
-    ECS_TAG(ecs, Pears);
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_pair(Likes, EcsWildcard) }
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_set(ecs, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(ecs, 0, Position, {20, 30});
-    ecs_entity_t e3 = ecs_set(ecs, 0, Position, {30, 40});
-
-    ecs_add_pair(ecs, e1, Likes, Apples);
-    ecs_add_pair(ecs, e2, Likes, Apples);
-    ecs_add_pair(ecs, e3, Likes, Apples);
-
-    ecs_add_pair(ecs, e1, Likes, Pears);
-    ecs_add_pair(ecs, e2, Likes, Pears);
-    ecs_add_pair(ecs, e3, Likes, Pears);
-
-    ecs_iter_t it = ecs_query_iter(ecs, q);
-    ecs_iter_set_var(&it, 0, e2);
-
-    {
-        test_bool(true, ecs_query_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-        test_uint(ecs_pair(Likes, Apples), ecs_field_id(&it, 2));
-    }
-    {
-        test_bool(true, ecs_query_next(&it));
-        test_int(it.count, 1);
-        test_uint(it.entities[0], e2);
-        Position *p = ecs_field(&it, Position, 1);
-        test_int(p[0].x, 20);
-        test_int(p[0].y, 30);
-        test_uint(ecs_pair(Likes, Pears), ecs_field_id(&it, 2));
-    }
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(ecs);
-}
-
-void Query_singleton_w_inout_none(void) {
-    ecs_world_t *ecs = ecs_mini();
-
-    ECS_COMPONENT(ecs, Position);
-    ECS_COMPONENT(ecs, Velocity);
-    
-    ecs_singleton_set(ecs, Position, {10, 20});
-
-    ecs_entity_t e = ecs_set(ecs, 0, Velocity, {20, 30});
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position), .src.id = EcsVariable },
-            { .id = ecs_id(Velocity), .inout = EcsInOutNone },
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(ecs, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    Position *p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    test_assert(ecs_field(&it, Velocity, 2) == NULL);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(ecs);
-}
-
-void Query_singleton_w_inout_none_or(void) {
-    ecs_world_t *ecs = ecs_mini();
-
-    ECS_COMPONENT(ecs, Position);
-    ECS_COMPONENT(ecs, Velocity);
-    ECS_COMPONENT(ecs, Mass);
-
-    ecs_singleton_set(ecs, Position, {10, 20});
-
-    ecs_entity_t e = ecs_set(ecs, 0, Velocity, {20, 30});
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position), .src.id = EcsVariable },
-            { .id = ecs_id(Velocity), .inout = EcsInOutNone, .oper = EcsOr },
-            { .id = ecs_id(Mass), .inout = EcsInOutNone },
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(ecs, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    Position *p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    test_assert(ecs_field(&it, Velocity, 2) == NULL);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(ecs);
-}
-
-void Query_component_w_inout_none_or(void) {
-    ecs_world_t *ecs = ecs_mini();
-
-    ECS_COMPONENT(ecs, Position);
-    ECS_COMPONENT(ecs, Velocity);
-    ECS_COMPONENT(ecs, Mass);
-
-    ecs_entity_t e = ecs_set(ecs, 0, Velocity, {20, 30});
-    ecs_set(ecs, e, Position, {10, 20});
-
-    ecs_query_t *q = ecs_query(ecs, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
-            { .id = ecs_id(Velocity), .inout = EcsInOutNone, .oper = EcsOr },
-            { .id = ecs_id(Mass), .inout = EcsInOutNone },
-        }
-    });
-    test_assert(q != NULL);
-
-    ecs_iter_t it = ecs_query_iter(ecs, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(1, it.count);
-    test_uint(e, it.entities[0]);
-    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
-    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
-    Position *p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    test_assert(ecs_field(&it, Velocity, 2) == NULL);
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(ecs);
-}
diff --git a/test/api/src/Switch.c b/test/api/src/Switch.c
deleted file mode 100644
index 2015435d0..000000000
--- a/test/api/src/Switch.c
+++ /dev/null
@@ -1,1789 +0,0 @@
-#include <api.h>
-
-void Switch_get_case_no_switch(void) {
-    ecs_world_t *world = ecs_mini();
-    
-    ECS_COMPONENT(world, Position);
-    ECS_ENTITY(world, Rel, Union);
-
-    ecs_entity_t e = ecs_new(world, Position);
-    test_assert(e != 0);
-
-    test_uint(ecs_get_target(world, e, Rel, 0), 0);
-
-    ecs_fini(world);
-}
-
-void Switch_get_case_set(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_entity_t e = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e != 0);
-
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_assert( !ecs_has_pair(world, e, Movement, Running));
-    test_assert( !ecs_has_pair(world, e, Movement, Jumping));
-    test_uint(ecs_get_target(world, e, Movement, 0), Walking);
-
-    ecs_fini(world);
-}
-
-void Switch_get_case_change(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_entity_t e = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e != 0);
-
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_assert( !ecs_has_pair(world, e, Movement, Running));
-    test_assert( !ecs_has_pair(world, e, Movement, Jumping));
-    test_uint(ecs_get_target(world, e, Movement, 0), Walking);
-
-    ecs_add_pair(world, e, Movement, Running);
-
-    test_assert( !ecs_has_pair(world, e, Movement, Walking));
-    test_assert( ecs_has_pair(world, e, Movement, Running));
-    test_assert( !ecs_has_pair(world, e, Movement, Jumping));
-    test_uint(ecs_get_target(world, e, Movement, 0), Running);
-
-    ecs_add_pair(world, e, Movement, Jumping);
-
-    test_assert( !ecs_has_pair(world, e, Movement, Walking));
-    test_assert( !ecs_has_pair(world, e, Movement, Running));
-    test_assert( ecs_has_pair(world, e, Movement, Jumping));
-    test_uint(ecs_get_target(world, e, Movement, 0), Jumping);
-
-    ecs_fini(world);
-}
-
-void Switch_remove_case(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_entity_t e = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e != 0);
-
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_assert( !ecs_has_pair(world, e, Movement, Running));
-    test_assert( !ecs_has_pair(world, e, Movement, Jumping));
-    test_uint(ecs_get_target(world, e, Movement, 0), Walking);
-
-    ecs_remove_pair(world, e, Movement, Walking);
-
-    test_assert( !ecs_has_pair(world, e, Movement, Walking));
-    test_assert( !ecs_has_pair(world, e, Movement, Running));
-    test_assert( !ecs_has_pair(world, e, Movement, Jumping));
-    test_uint(ecs_get_target(world, e, Movement, 0), 0);
-
-    test_assert(ecs_get_type(world, e) == NULL);
-
-    ecs_fini(world);
-}
-
-void Switch_remove_last(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e1 != 0);
-    ecs_add(world, e1, Tag);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e2 != 0);
-    ecs_add(world, e2, Tag);
-
-    ecs_remove(world, e2, Tag);
-
-    test_assert(!ecs_has(world, e2, Tag));
-    test_assert(ecs_has_pair(world, e2, Movement, Walking));
-
-    test_assert(ecs_has(world, e1, Tag));
-    test_assert(ecs_has_pair(world, e1, Movement, Walking));
-
-    ecs_fini(world);
-}
-
-void Switch_delete_first(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e1 != 0);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e2 != 0);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e3 != 0);
-
-    ecs_delete(world, e1);
-
-    test_assert(ecs_has_pair(world, e2, Movement, Walking));
-    test_assert(ecs_has_pair(world, e3, Movement, Walking));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_delete_last(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e1 != 0);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e2 != 0);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e3 != 0);
-
-    ecs_delete(world, e3);
-
-    test_assert(ecs_has_pair(world, e1, Movement, Walking));
-    test_assert(ecs_has_pair(world, e2, Movement, Walking));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_delete_first_last(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e1 != 0);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e2 != 0);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e3 != 0);
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e3);
-
-    test_assert(ecs_has_pair(world, e2, Movement, Walking));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_3_entities_same_case(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_ENTITY(world, e1, (Movement, Running));
-    ECS_ENTITY(world, e2, (Movement, Running));
-    ECS_ENTITY(world, e3, (Movement, Running));
-
-    test_assert( ecs_has_pair(world, e1, Movement, Running));
-    test_assert( ecs_has_pair(world, e2, Movement, Running));
-    test_assert( ecs_has_pair(world, e3, Movement, Running));
-
-    test_int(ecs_get_target(world, e1, Movement, 0), Running);
-    test_int(ecs_get_target(world, e2, Movement, 0), Running);
-    test_int(ecs_get_target(world, e3, Movement, 0), Running);
-
-    ecs_fini(world);
-}
-
-void Switch_2_entities_1_change_case(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_ENTITY(world, e1, (Movement, Running));
-    ECS_ENTITY(world, e2, (Movement, Running));
-
-    ecs_add_pair(world, e2, Movement, Jumping);
-    test_assert( ecs_has_pair(world, e1, Movement, Running));
-    test_assert( ecs_has_pair(world, e2, Movement, Jumping));
-
-    test_int(ecs_get_target(world, e1, Movement, 0), Running);
-    test_int(ecs_get_target(world, e2, Movement, 0), Jumping);
-
-    ecs_fini(world);
-}
-
-void Switch_3_entities_change_case(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_ENTITY(world, e1, (Movement, Running));
-    ECS_ENTITY(world, e2, (Movement, Running));
-    ECS_ENTITY(world, e3, (Movement, Running));
-
-    ecs_add_pair(world, e1, Movement, Walking);
-    test_assert( ecs_has_pair(world, e1, Movement, Walking));
-    test_assert( ecs_has_pair(world, e2, Movement, Running));
-    test_assert( ecs_has_pair(world, e3, Movement, Running));
-
-    test_int(ecs_get_target(world, e1, Movement, 0), Walking);
-    test_int(ecs_get_target(world, e2, Movement, 0), Running);
-    test_int(ecs_get_target(world, e3, Movement, 0), Running);
-
-    ecs_add_pair(world, e2, Movement, Jumping);
-    test_assert( ecs_has_pair(world, e1, Movement, Walking));
-    test_assert( ecs_has_pair(world, e2, Movement, Jumping));
-    test_assert( ecs_has_pair(world, e3, Movement, Running));
-
-    test_int(ecs_get_target(world, e1, Movement, 0), Walking);
-    test_int(ecs_get_target(world, e2, Movement, 0), Jumping);
-    test_int(ecs_get_target(world, e3, Movement, 0), Running); 
-
-    ecs_add_pair(world, e3, Movement, Walking);
-    test_assert( ecs_has_pair(world, e1, Movement, Walking));
-    test_assert( ecs_has_pair(world, e2, Movement, Jumping));
-    test_assert( ecs_has_pair(world, e3, Movement, Walking));
-
-    test_int(ecs_get_target(world, e1, Movement, 0), Walking);
-    test_int(ecs_get_target(world, e2, Movement, 0), Jumping);
-    test_int(ecs_get_target(world, e3, Movement, 0), Walking);
-
-    ecs_fini(world);
-}
-
-static
-void MatchSwitch(ecs_iter_t *it) {
-    ecs_entity_t *movement = ecs_field(it, ecs_entity_t, 1);
-    test_assert(movement != NULL);
-    probe_iter(it);
-}
-
-void Switch_query_switch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, *)");
-    test_assert(q != NULL);
-
-    ECS_ENTITY(world, e1, (Movement, Running));
-    ECS_ENTITY(world, e2, (Movement, Walking));
-    ECS_ENTITY(world, e3, (Movement, Running));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 3);
-    test_uint(it.entities[0], e1);
-    test_uint(it.entities[1], e2);
-    test_uint(it.entities[2], e3);
-    test_uint(ecs_pair(Movement, EcsWildcard), ecs_field_id(&it, 1));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_query_1_case_1_type(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Running)");
-    test_assert(q != NULL);
-
-    ECS_ENTITY(world, e1, (Movement, Running));
-    ECS_ENTITY(world, e2, (Movement, Walking));
-    ECS_ENTITY(world, e3, (Movement, Running));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(it.ids[0], ecs_pair(Movement, Running));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.ids[0], ecs_pair(Movement, Running));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_query_1_case_2_types(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Running)");
-    test_assert(q != NULL);
-
-    ECS_ENTITY(world, e1, (Movement, Running));
-    ECS_ENTITY(world, e2, (Movement, Walking));
-    ECS_ENTITY(world, e3, (Movement, Running));
-    ECS_ENTITY(world, e4, (Movement, Walking), Position);
-    ECS_ENTITY(world, e5, (Movement, Running), Position);
-    ECS_ENTITY(world, e6, (Movement, Walking), Position);
-    ECS_ENTITY(world, e7, (Movement, Running), Position);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e3);
-    test_uint(ecs_pair(Movement, Running), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(ecs_pair(Movement, Running), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e7);
-    test_uint(ecs_pair(Movement, Running), ecs_field_id(&it, 1));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e5);
-    test_uint(ecs_pair(Movement, Running), ecs_field_id(&it, 1));    
-
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_query_2_cases_1_type(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_ENTITY(world, Direction, Union);
-    ECS_TAG(world, Front);
-    ECS_TAG(world, Back);
-    ECS_TAG(world, Left);
-    ECS_TAG(world, Right);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Running), (Direction, Front)");
-    test_assert(q != NULL);
-
-    ECS_ENTITY(world, e1, (Movement, Running), (Direction, Front));
-    ECS_ENTITY(world, e2, (Movement, Walking), (Direction, Front));
-    ECS_ENTITY(world, e3, (Movement, Running), (Direction, Back));
-    ECS_ENTITY(world, e4, (Movement, Running), (Direction, Front));
-    ECS_ENTITY(world, e5, (Movement, Walking), (Direction, Front));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e4);
-    test_uint(ecs_pair(Movement, Running), ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Direction, Front), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(ecs_pair(Movement, Running), ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Direction, Front), ecs_field_id(&it, 2));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_query_2_cases_2_types(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_ENTITY(world, Direction, Union);
-    ECS_TAG(world, Front);
-    ECS_TAG(world, Back);
-    ECS_TAG(world, Left);
-    ECS_TAG(world, Right);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Running), (Direction, Front)");
-    test_assert(q != NULL);
-
-    ECS_ENTITY(world, e1, (Movement, Running), (Direction, Front));
-    ECS_ENTITY(world, e2, (Movement, Walking), (Direction, Front));
-    ECS_ENTITY(world, e3, (Movement, Running), (Direction, Back));
-    ECS_ENTITY(world, e4, (Movement, Running), (Direction, Front));
-    ECS_ENTITY(world, e5, (Movement, Walking), (Direction, Front));
-    ECS_ENTITY(world, e6, Position, (Movement, Walking), (Direction, Front));
-    ECS_ENTITY(world, e7, Position, (Movement, Running), (Direction, Front));
-    ECS_ENTITY(world, e8, Position, (Movement, Walking), (Direction, Front));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e4);
-    test_uint(ecs_pair(Movement, Running), ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Direction, Front), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(ecs_pair(Movement, Running), ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Direction, Front), ecs_field_id(&it, 2));
-
-    test_bool(true, ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e7);
-    test_uint(ecs_pair(Movement, Running), ecs_field_id(&it, 1));
-    test_uint(ecs_pair(Direction, Front), ecs_field_id(&it, 2));
-    test_bool(false, ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_query_after_remove(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_ENTITY(world, e1, (Movement, Walking));
-    ECS_ENTITY(world, e2, (Movement, Walking));
-    ECS_ENTITY(world, e3, (Movement, Running));
-    ECS_ENTITY(world, e4, (Movement, Running));
-    ECS_ENTITY(world, e5, (Movement, Running));
-    ECS_ENTITY(world, e6, (Movement, Jumping));
-    ECS_ENTITY(world, e7, (Movement, Jumping));
-
-    ecs_query_t *q_walking = ecs_query_new(world, "(Movement, Walking)");
-    ecs_query_t *q_running = ecs_query_new(world, "(Movement, Running)");
-    ecs_query_t *q_jumping = ecs_query_new(world, "(Movement, Jumping)");
-
-    /* Verify all queries are correctly matched */
-    ecs_iter_t it = ecs_query_iter(world, q_walking);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e2);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e1);
-    test_assert(!ecs_query_next(&it));
-
-    it = ecs_query_iter(world, q_running);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e5);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e4);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e3);    
-    test_assert(!ecs_query_next(&it));
-
-    it = ecs_query_iter(world, q_jumping);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e7);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e6);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_remove_pair(world, e4, Movement, Running);
-    test_assert(!ecs_has_pair(world, e4, Movement, Running));
-    ecs_entity_t c = ecs_get_target(world, e4, Movement, 0);
-    test_int(c, 0);
-
-    /* Verify queries are still correctly matched, now excluding e4 */
-    it = ecs_query_iter(world, q_walking);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e2);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e1);
-    test_assert(!ecs_query_next(&it));
-
-    it = ecs_query_iter(world, q_running);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e5);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e3);    
-    test_assert(!ecs_query_next(&it));
-
-    it = ecs_query_iter(world, q_jumping);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e7);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e6);
-    test_assert(!ecs_query_next(&it));    
-
-    ecs_add_pair(world, e4, Movement, Running);
-    test_assert(ecs_has_pair(world, e4, Movement, Running));
-    c = ecs_get_target(world, e4, Movement, 0);
-    test_int(c, Running);
-
-    /* Verify e4 is now matched again */
-    it = ecs_query_iter(world, q_walking);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e2);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e1);
-    test_assert(!ecs_query_next(&it));
-
-    it = ecs_query_iter(world, q_running);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e4);      
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e5);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e3);      
-    test_assert(!ecs_query_next(&it));
-
-    it = ecs_query_iter(world, q_jumping);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e7);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1); test_int(it.entities[0], e6);
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-static
-void SetCase(ecs_iter_t *it) {
-    ecs_world_t *world = it->world;
-    ecs_entity_t id = ecs_field_id(it, 2);
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        ecs_add_id(world, it->entities[i], id);
-    }
-}
-
-void Switch_add_case_in_stage(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_SYSTEM(world, SetCase, EcsOnUpdate, Position, Movement(0, Walking));
-
-    ECS_ENTITY(world, e1, Position);
-    ECS_ENTITY(world, e2, Position);
-    ECS_ENTITY(world, e3, Position);
-
-    ecs_progress(world, 0);
-
-    test_assert(ecs_has_pair(world, e1, Movement, Walking));
-    test_assert(ecs_has_pair(world, e2, Movement, Walking));
-    test_assert(ecs_has_pair(world, e3, Movement, Walking));
-
-    ecs_fini(world);
-}
-
-void Switch_change_case_in_stage(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_SYSTEM(world, SetCase, EcsOnUpdate, Position, Movement(0, Walking));
-
-    ECS_ENTITY(world, e1, Position, (Movement, Running));
-    ECS_ENTITY(world, e2, Position, (Movement, Running));
-    ECS_ENTITY(world, e3, Position, (Movement, Running));
-
-    ecs_progress(world, 0);
-
-    test_assert(!ecs_has_pair(world, e1, Movement, Running));
-    test_assert(!ecs_has_pair(world, e2, Movement, Running));
-    test_assert(!ecs_has_pair(world, e3, Movement, Running));
-
-    test_assert(ecs_has_pair(world, e1, Movement, Walking));
-    test_assert(ecs_has_pair(world, e2, Movement, Walking));
-    test_assert(ecs_has_pair(world, e3, Movement, Walking));
-
-    ecs_fini(world);
-}
-
-void Switch_change_one_case_in_stage(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_SYSTEM(world, SetCase, EcsOnUpdate, Position, Movement(0, Jumping), (Movement, Walking));
-
-    ECS_ENTITY(world, e0, Position, (Movement, Jumping));
-    ECS_ENTITY(world, e1, Position, (Movement, Walking));
-    ECS_ENTITY(world, e2, Position, (Movement, Running));
-    ECS_ENTITY(world, e3, Position, (Movement, Walking));
-    ECS_ENTITY(world, e4, Position, (Movement, Running));
-    ECS_ENTITY(world, e5, Position, (Movement, Jumping));
-
-    ecs_progress(world, 0);
-
-    test_assert(ecs_has_pair(world, e0, Movement, Jumping));
-    test_assert(ecs_has_pair(world, e1, Movement, Jumping));
-    test_assert(ecs_has_pair(world, e2, Movement, Running));
-    test_assert(ecs_has_pair(world, e3, Movement, Jumping));
-    test_assert(ecs_has_pair(world, e4, Movement, Running));
-    test_assert(ecs_has_pair(world, e5, Movement, Jumping));
-
-    ecs_fini(world);
-}
-
-static
-void RemoveSwitch(ecs_iter_t *it) {
-    ecs_world_t *world = it->world;
-    ecs_entity_t id = ecs_field_id(it, 1);
-
-    int i;
-    for (i = 0; i < it->count; i ++) {
-        ecs_remove_id(world, it->entities[i], id);
-    }
-}
-
-void Switch_remove_switch_in_stage(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_SYSTEM(world, RemoveSwitch, EcsOnUpdate, (Movement, *));
-
-    ECS_ENTITY(world, e1, Position, (Movement, Walking));
-    ECS_ENTITY(world, e2, Position, (Movement, Walking));
-    ECS_ENTITY(world, e3, Position, (Movement, Walking));
-
-    ecs_progress(world, 0);
-
-    test_assert(!ecs_has_pair(world, e1, Movement, Walking));
-    test_assert(!ecs_has_pair(world, e2, Movement, Walking));
-    test_assert(!ecs_has_pair(world, e3, Movement, Walking));
-
-    test_assert(!ecs_has_pair(world, e1, Movement, EcsWildcard));
-    test_assert(!ecs_has_pair(world, e2, Movement, EcsWildcard));
-    test_assert(!ecs_has_pair(world, e3, Movement, EcsWildcard));
-
-    ecs_fini(world);
-}
-
-void Switch_switch_no_match_for_case(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_new_w_pair(world, Movement, Walking);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Running)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    int count = 0;
-    while (ecs_query_next(&it)) {
-        count ++;
-    }
-
-    test_assert(count == 0);
-
-    ecs_fini(world);
-}
-
-void Switch_empty_entity_has_case(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-
-    ecs_entity_t e = ecs_new(world, 0);
-    test_assert(!ecs_has_pair(world, e, Movement, Walking));
-
-    ecs_fini(world);
-}
-
-void Switch_zero_entity_has_case(void) {
-    install_test_abort();
-
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-
-    test_expect_abort();
-
-    test_assert(!ecs_has_pair(world, 0, Movement, Walking));
-}
-
-void Switch_add_to_entity_w_switch(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e != 0);
-
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_int(ecs_get_target(world, e, Movement, 0), Walking);
-
-    ecs_add(world, e, Position);
-    test_assert( ecs_has(world, e, Position));
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_int(ecs_get_target(world, e, Movement, 0), Walking);
-
-    ecs_fini(world);
-}
-
-void Switch_add_pair_to_entity_w_switch(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-    
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Pair);
-
-    ecs_entity_t e = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e != 0);
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_int(ecs_get_target(world, e, Movement, 0), Walking);
-
-    ecs_entity_t pair_id = ecs_pair(ecs_id(Position), Pair);
-    ecs_add_id(world, e, pair_id);
-    test_assert(ecs_has_id(world, e, pair_id));
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_int(ecs_get_target(world, e, Movement, 0), Walking);
-
-    ecs_fini(world);
-}
-
-static
-int compare_position(ecs_entity_t e1, const void *ptr1, ecs_entity_t e2, const void *ptr2) {
-    const Position *p1 = ptr1;
-    const Position *p2 = ptr2;
-    return (p1->x > p2->x) - (p1->x < p2->x);
-}
-
-void Switch_sort(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-    ECS_TAG(world, Sitting);
-
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 2});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {2, 2});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {0, 2});
-
-    ecs_add_pair(world, e1, Movement, Walking);
-    ecs_add_pair(world, e2, Movement, Running);
-    ecs_add_pair(world, e3, Movement, Jumping);
-    ecs_add_pair(world, e4, Movement, Sitting);
-    
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ ecs_id(Position) }},
-        .order_by_component = ecs_id(Position), 
-        .order_by = compare_position
-    });
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 4);
-    test_assert(it.entities[0] == e4);
-    test_assert(it.entities[1] == e3);
-    test_assert(it.entities[2] == e2);
-    test_assert(it.entities[3] == e1);
-    test_assert(!ecs_query_next(&it));
-
-    /* Entities will have shuffled around, ensure cases got shuffled too */
-    test_uint(ecs_get_target(world, e1, Movement, 0), Walking);
-    test_uint(ecs_get_target(world, e2, Movement, 0), Running);
-    test_uint(ecs_get_target(world, e3, Movement, 0), Jumping);
-    test_uint(ecs_get_target(world, e4, Movement, 0), Sitting);
-
-    ecs_fini(world);
-}
-
-void Switch_recycled_tags(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-    ecs_delete(world, e3);
-
-    ECS_TAG(world, Standing);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    test_assert(Standing > UINT32_MAX);
-    test_assert(Walking > UINT32_MAX);
-    test_assert(Running > UINT32_MAX);
-
-    ecs_entity_t e = ecs_new_w_pair(world, Movement, Standing);
-    test_assert(ecs_has_pair(world, e, Movement, Standing));
-    test_assert(!ecs_has_pair(world, e, Movement, Walking));
-    test_assert(!ecs_has_pair(world, e, Movement, Running));
-
-    ecs_add_pair(world, e, Movement, Walking);
-    test_assert(!ecs_has_pair(world, e, Movement, Standing));
-    test_assert(ecs_has_pair(world, e, Movement, Walking));
-    test_assert(!ecs_has_pair(world, e, Movement, Running));
-
-    ecs_fini(world);
-}
-
-void Switch_query_recycled_tags(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-
-    ecs_delete(world, e1);
-    ecs_delete(world, e2);
-    ecs_delete(world, e3);
-
-    ECS_TAG(world, Standing);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    test_assert(Standing > UINT32_MAX);
-    test_assert(Walking > UINT32_MAX);
-    test_assert(Running > UINT32_MAX);
-
-    ecs_entity_t e = ecs_new(world, 0);
-    ecs_add_pair(world, e, Movement, Standing);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Standing)");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e);
-
-    ecs_entity_t *cases = ecs_field(&it, ecs_entity_t, 1);
-    test_assert(cases != NULL);
-    test_assert(ecs_get_alive(world, cases[0]) == Standing);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_single_case(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e1 != 0);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e2 != 0);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e3 != 0);
-
-    test_assert(ecs_has_pair(world, e1, Movement, Walking));
-    test_assert(ecs_has_pair(world, e2, Movement, Walking));
-    test_assert(ecs_has_pair(world, e3, Movement, Walking));
-
-    ecs_delete(world, e1);
-
-    test_assert(ecs_has_pair(world, e2, Movement, Walking));
-    test_assert(ecs_has_pair(world, e3, Movement, Walking));
-
-    ecs_delete(world, e3);
-
-    test_assert(ecs_has_pair(world, e2, Movement, Walking));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_match_switch_on_base_instance(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t base = ecs_new_id(world);
-    test_assert(base != 0);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e1 != 0);
-    ecs_add_pair(world, e1, EcsIsA, base);
-
-    test_uint(ecs_get_target(world, e1, Movement, 0), Walking);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Switch_switch_w_bitset_query(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, (Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_enable_component(world, e1, Position, true);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e2, Position, {11, 22});
-    ecs_enable_component(world, e2, Position, false);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e3, Position, {13, 23});
-
-    test_bool(ecs_is_enabled_component(world, e1, Position), true);
-    test_bool(ecs_is_enabled_component(world, e2, Position), false);
-
-    Position *p;
-    ecs_entity_t *c;
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_switch_w_bitset_query_inv(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, (Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_enable_component(world, e1, Position, true);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e2, Position, {11, 22});
-    ecs_enable_component(world, e2, Position, true);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e3, Position, {13, 23});
-
-    Position *p;
-    ecs_entity_t *c;
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_switch_w_bitset_query_2_elems(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, (Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_enable_component(world, e1, Position, true);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e2, Position, {11, 22});
-    ecs_enable_component(world, e2, Position, true);
-
-    ecs_entity_t e0 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e0, Position, {11, 22});
-    ecs_enable_component(world, e0, Position, false);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e3, Position, {13, 23});
-
-    Position *p;
-    ecs_entity_t *c;
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 11);
-    test_int(p->y, 22);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_switch_w_bitset_query_2_elems_skip(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, (Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_enable_component(world, e1, Position, true);
-
-    ecs_entity_t e0 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e0, Position, {11, 22});
-    ecs_enable_component(world, e0, Position, false);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e2, Position, {11, 22});
-    ecs_enable_component(world, e2, Position, true);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e3, Position, {13, 23});
-
-    Position *p;
-    ecs_entity_t *c;
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e3);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e1);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e2);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 11);
-    test_int(p->y, 22);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_switch_w_bitset_query_elems_interleaved(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-    ECS_COMPONENT(world, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, (Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_enable_component(world, e1, Position, false);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e2, Position, {11, 22});
-    ecs_enable_component(world, e2, Position, true);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e3, Position, {13, 23});
-    ecs_enable_component(world, e3, Position, false);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e4, Position, {13, 23});
-    ecs_enable_component(world, e4, Position, true);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e5, Position, {13, 23});
-    ecs_enable_component(world, e5, Position, true);
-
-    ecs_entity_t e6 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e6, Position, {13, 23});
-    ecs_enable_component(world, e6, Position, true);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e7, Position, {13, 23});
-    ecs_enable_component(world, e7, Position, false);
-
-    ecs_entity_t e8 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e8, Position, {13, 23});
-    ecs_enable_component(world, e8, Position, true);
-
-    Position *p;
-    ecs_entity_t *c;
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e5);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e8);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_switch_w_bitset_query_elems_interleaved_2_types(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Position, (Movement, Walking)");
-    test_assert(q != NULL);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e1, Position, {10, 20});
-    ecs_enable_component(world, e1, Position, false);
-
-    ecs_entity_t e2 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e2, Position, {11, 22});
-    ecs_enable_component(world, e2, Position, true);
-
-    ecs_entity_t e3 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e3, Position, {13, 23});
-    ecs_enable_component(world, e3, Position, false);
-
-    ecs_entity_t e4 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e4, Position, {13, 23});
-    ecs_enable_component(world, e4, Position, true);
-
-    ecs_entity_t e5 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e5, Position, {13, 23});
-    ecs_enable_component(world, e5, Position, true);
-
-    ecs_entity_t e6 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e6, Position, {13, 23});
-    ecs_enable_component(world, e6, Position, true);
-
-    ecs_entity_t e7 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e7, Position, {13, 23});
-    ecs_enable_component(world, e7, Position, false);
-
-    ecs_entity_t e8 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e8, Position, {13, 23});
-    ecs_enable_component(world, e8, Position, true);
-
-
-    ecs_entity_t e1_2 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e1_2, Position, {10, 20});
-    ecs_enable_component(world, e1_2, Position, false);
-    ecs_add_id(world, e1_2, Tag);
-
-    ecs_entity_t e2_2 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e2_2, Position, {11, 22});
-    ecs_enable_component(world, e2_2, Position, true);
-    ecs_add_id(world, e2_2, Tag);
-
-    ecs_entity_t e3_2 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e3_2, Position, {13, 23});
-    ecs_enable_component(world, e3_2, Position, false);
-    ecs_add_id(world, e3_2, Tag);
-
-    ecs_entity_t e4_2 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e4_2, Position, {13, 23});
-    ecs_enable_component(world, e4_2, Position, true);
-    ecs_add_id(world, e4_2, Tag);
-
-    ecs_entity_t e5_2 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e5_2, Position, {13, 23});
-    ecs_enable_component(world, e5_2, Position, true);
-    ecs_add_id(world, e5_2, Tag);
-
-    ecs_entity_t e6_2 = ecs_new_w_pair(world, Movement, Running);
-    ecs_set(world, e6_2, Position, {13, 23});
-    ecs_enable_component(world, e6_2, Position, true);
-    ecs_add_id(world, e6_2, Tag);
-
-    ecs_entity_t e7_2 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e7_2, Position, {13, 23});
-    ecs_enable_component(world, e7_2, Position, false);
-    ecs_add_id(world, e7_2, Tag);
-
-    ecs_entity_t e8_2 = ecs_new_w_pair(world, Movement, Walking);
-    ecs_set(world, e8_2, Position, {13, 23});
-    ecs_enable_component(world, e8_2, Position, true);
-    ecs_add_id(world, e8_2, Tag);
-
-    Position *p;
-    ecs_entity_t *c;
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e5);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e8);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e5_2);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_int(it.entities[0], e8_2);
-    p = ecs_field(&it, Position, 1);
-    test_assert(p != NULL);
-    test_int(p->x, 13);
-    test_int(p->y, 23);
-    c = ecs_field(&it, ecs_entity_t, 2);
-    test_assert(c != NULL);
-    test_assert(c[0] == Walking);
-
-    test_assert(!ecs_query_next(&it));
-
-    ecs_fini(world);
-}
-
-void Switch_has_wildcard(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_entity_t e = ecs_new_id(world);
-    test_assert( !ecs_has_pair(world, e, Movement, EcsWildcard));
-
-    ecs_add_pair(world, e, Movement, Walking);
-    test_assert( ecs_has_pair(world, e, Movement, EcsWildcard));
-
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_assert( !ecs_has_pair(world, e, Movement, Running));
-    test_assert( !ecs_has_pair(world, e, Movement, Jumping));
-    test_assert( ecs_has_pair(world, e, Movement, EcsWildcard));
-
-    ecs_fini(world);
-}
-
-void Switch_remove_wildcard(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_entity_t e = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e != 0);
-
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_assert( !ecs_has_pair(world, e, Movement, Running));
-    test_assert( !ecs_has_pair(world, e, Movement, Jumping));
-    test_uint(ecs_get_target(world, e, Movement, 0), Walking);
-
-    ecs_remove_pair(world, e, Movement, EcsWildcard);
-
-    test_assert( !ecs_has_pair(world, e, Movement, Walking));
-    test_assert( !ecs_has_pair(world, e, Movement, Running));
-    test_assert( !ecs_has_pair(world, e, Movement, Jumping));
-    test_uint(ecs_get_target(world, e, Movement, 0), 0);
-    test_assert( !ecs_has_pair(world, e, Movement, EcsWildcard));
-
-    ecs_fini(world);
-}
-
-void Switch_same_table_after_change(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_entity_t e = ecs_new_w_pair(world, Movement, Walking);
-    test_assert(e != 0);
-
-    ecs_table_t *table = ecs_get_table(world, e);
-    test_assert(table != NULL);
-
-    ecs_add_pair(world, e, Movement, Running);
-    test_assert(ecs_get_table(world, e) == table);
-
-    ecs_add_pair(world, e, Movement, Jumping);
-    test_assert(ecs_get_table(world, e) == table);
-    
-    ecs_remove_pair(world, e, Movement, EcsWildcard);
-    test_assert(ecs_get_table(world, e) != table);
-    test_assert(ecs_get_table(world, e) == NULL);
-
-    ecs_fini(world);
-}
-
-void Switch_component_relation(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_ENTITY(world, Direction, Union);
-    ECS_TAG(world, Front);
-    ECS_TAG(world, Back);
-    ECS_TAG(world, Left);
-    ECS_TAG(world, Right);
-    
-    ecs_set(world, Movement, EcsComponent, { .size = 1, .alignment = 1 });
-    ecs_set(world, Direction, EcsComponent, { .size = 1, .alignment = 1 });
-
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_add_pair(world, e1, Movement, Walking);
-    ecs_add_pair(world, e1, Direction, Front);
-
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_add_pair(world, e2, Movement, Running);
-    ecs_add_pair(world, e2, Direction, Left);
-
-    ecs_query_t *q = ecs_query_new(world, "(Movement, Walking), (Direction, *)");
-    test_assert(q != NULL);
-
-    ecs_entity_t *m;
-    ecs_entity_t *d;
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_uint(it.entities[0], e1);
-    test_uint(it.ids[0], ecs_pair(Movement, Walking));
-    test_uint(it.ids[1], ecs_pair(Direction, EcsWildcard));
-    m = ecs_field(&it, ecs_entity_t, 1);
-    d = ecs_field(&it, ecs_entity_t, 2);
-    test_uint(m[0], Walking);
-    test_uint(d[0], Front);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-static
-void Trigger(ecs_iter_t *it) {
-    probe_system_w_ctx(it, it->ctx);
-}
-
-void Switch_delete_case_trigger_after_delete_switch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    Probe ctx = {0};
-
-    ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { .id = ecs_pair(Movement, Walking), .src.flags = EcsSelf },
-        .events = {EcsOnAdd},
-        .callback = Trigger,
-        .ctx = &ctx
-    });
-
-    ecs_entity_t e = ecs_new_w_pair(world, Movement, Walking);
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-
-    ecs_delete(world, Movement);
-
-    ecs_fini(world);
-}
-
-void Switch_add_2(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_ENTITY(world, Direction, Union);
-    ECS_TAG(world, Up);
-    ECS_TAG(world, Down);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Movement, Walking);
-    ecs_add_pair(world, e, Direction, Up);
-
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_assert( ecs_has_pair(world, e, Direction, Up));
-
-    test_assert(ecs_get_target(world, e, Movement, 0) == Walking);
-    test_assert(ecs_get_target(world, e, Direction, 0) == Up);
-
-    ecs_fini(world);
-}
-
-void Switch_add_2_reverse(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ECS_ENTITY(world, Direction, Union);
-    ECS_TAG(world, Up);
-    ECS_TAG(world, Down);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Direction, Up);
-    ecs_add_pair(world, e, Movement, Walking);
-
-    test_assert( ecs_has_pair(world, e, Movement, Walking));
-    test_assert( ecs_has_pair(world, e, Direction, Up));
-
-    test_assert(ecs_get_target(world, e, Movement, 0) == Walking);
-    test_assert(ecs_get_target(world, e, Direction, 0) == Up);
-
-    ecs_fini(world);
-}
-
-void Switch_add_switch_to_prefab_instance(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Jumping);
-
-    ecs_entity_t base = ecs_new_id(world);
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-    ecs_add_pair(world, inst, Movement, Walking);
-
-    test_assert(ecs_has_pair(world, inst, Movement, Walking));
-    test_assert(ecs_get_target(world, inst, Movement, 0) == Walking);
-
-    ecs_fini(world);
-}
-
-void Switch_get_case_w_generation(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Rel, Union);
-
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_delete(world, tgt);
-    tgt = ecs_new_id(world);
-    test_assert(tgt != (uint32_t)tgt);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Rel, tgt);
-
-    ecs_entity_t t = ecs_get_target(world, e, Rel, 0);
-    test_assert(t == tgt);
-
-    ecs_fini(world);
-}
-
-void Switch_get_case_w_generation_not_alive(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Rel, Union);
-
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_delete(world, tgt);
-    tgt = ecs_new_id(world);
-    test_assert(tgt != (uint32_t)tgt);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Rel, tgt);
-
-    ecs_entity_t t = ecs_get_target(world, e, Rel, 0);
-    test_assert(t == tgt);
-
-    ecs_delete(world, tgt);
-
-    t = ecs_get_target(world, e, Rel, 0);
-    test_assert(t == tgt);
-
-    ecs_fini(world);
-}
diff --git a/test/api/src/util.c b/test/api/src/util.c
deleted file mode 100644
index 3d0ac9f9c..000000000
--- a/test/api/src/util.c
+++ /dev/null
@@ -1,319 +0,0 @@
-#include <api.h>
-#include <stdio.h>
-
-void probe_system_w_ctx(
-    ecs_iter_t *it,
-    Probe *ctx) 
-{
-    if (!ctx) {
-        return;
-    }
-
-    ctx->param = it->param;
-    ctx->system = it->system;
-    ctx->event = it->event;
-    ctx->event_id = it->event_id;
-    ctx->offset = 0;
-    ctx->term_count = it->field_count;
-    ctx->term_index = it->term_index;
-
-    int i;
-    for (i = 0; i < ctx->term_count; i ++) {
-        ctx->c[ctx->invoked][i] = it->ids[i];
-        ctx->s[ctx->invoked][i] = ecs_field_src(it, i + 1);
-
-        ecs_id_t e = ecs_field_id(it, i + 1);
-        test_assert(e != 0);
-    }
-
-    for (i = 0; i < it->count; i ++) {
-        if (i + ctx->count < 256) {
-            ctx->e[i + ctx->count] = it->entities[i];
-        } else {
-            /* can't store more than that, tests shouldn't rely on
-                * getting back more than 256 results */
-        }
-    }
-    ctx->count += it->count;
-
-    ctx->invoked ++;
-}
-
-void probe_iter(
-    ecs_iter_t *it) 
-{
-    Probe *ctx = ecs_get_ctx(it->world);
-    if (!ctx) {
-        ctx = it->ctx;
-    }
-    probe_system_w_ctx(it, ctx);
-}
-
-void probe_has_entity(Probe *probe, ecs_entity_t e) {
-    int i;
-    for (i = 0; i < probe->count; i ++) {
-        if (probe->e[i] == e) {
-            break;
-        }
-    }
-
-    test_assert(i != probe->count);
-}
-
-void install_test_abort(void) {
-    ecs_os_set_api_defaults();
-    ecs_os_api_t os_api = ecs_os_get_api();
-    os_api.abort_ = test_abort;
-    ecs_os_set_api(&os_api);
-    ecs_log_set_level(-5);
-}
-
-const ecs_entity_t* bulk_new_w_type(
-    ecs_world_t *world, ecs_entity_t type_ent, int32_t count) 
-{
-    const ecs_type_t *type = ecs_get_type(world, type_ent);
-    test_assert(type != NULL);
-
-    ecs_id_t *ids = type->array;
-    int i = 0;
-    while ((ecs_id_get_flags(world, ids[i]) & EcsIdDontInherit)) {
-        i ++;
-    }
-    const ecs_entity_t *result = ecs_bulk_new_w_id(world, ids[i], count);
-    for (; i < type->count; i ++) {
-        for (int e = 0; e < count; e ++) {
-            if (ecs_id_get_flags(world, ids[i]) & EcsIdDontInherit) {
-                continue;
-            }
-            ecs_add_id(world, result[e], ids[i]);
-        }
-    }
-    
-    return result;
-}
-
-int32_t find_entity(
-    ecs_world_t *world,
-    test_iter_result_t *expect, 
-    ecs_entity_t e)
-{
-    int i;
-    for (i = 0; i < ITER_MAX_ENTITIES; i ++) {
-        if (expect->entities[i] == e) {
-            while (expect->matched[i]) {
-                i ++;
-                if (!if_test_assert(e == expect->entities[i])) {
-                    return -1;
-                }
-            }
-
-            if (expect->entity_names[i]) {
-                if (!if_test_str(ecs_get_name(world, e), expect->entity_names[i])) {
-                    return -1;
-                }
-            }
-            return i;
-        }
-    }
-
-    for (i = 0; i < ITER_MAX_ENTITIES; i ++) {
-        if (!expect->entity_names[i]) {
-            break;
-        }
-
-        if (!strcmp(ecs_get_name(world, e), expect->entity_names[i])) {
-            while (expect->matched[i]) {
-                i ++;
-
-                // If this fails, the entity is encountered more times than
-                // expected.
-                if (!if_test_str(ecs_get_name(world, e), 
-                    expect->entity_names[i])) 
-                {
-                    return -1;
-                }
-            }
-
-            return i;
-        }
-    }
-
-    return -1;
-}
-
-bool test_iter(
-    ecs_iter_t *it, 
-    ecs_iter_next_action_t next, 
-    test_iter_result_t *expect) 
-{
-    int32_t entity_index = -1;
-
-    while (next(it)) {
-        int i;
-
-        for (i = 0; (i < it->count) || (i < 1); i ++) {
-            ecs_entity_t e = 0;
-            int t;
-
-            if (it->count) {
-                e = it->entities[i];
-
-                entity_index = find_entity(it->world, expect, e);
-
-                // Matched unexpected entity
-                test_assert(entity_index != -1);
-
-                expect->matched[entity_index] = true;
-
-                // Test data
-                for (t = 0; t < it->field_count; t++) {
-                    size_t size = ecs_field_size(it, t + 1);
-                    if (!size) {
-                        continue;
-                    }
-
-                    void *expect_ptr = expect->term_columns[t];
-                    if (!expect_ptr) {
-                        continue;
-                    }
-
-                    expect_ptr = ECS_OFFSET(expect_ptr, size * entity_index);
-
-                    void *component_ptr = ecs_field_w_size(it, size, t + 1);
-                    if (!if_test_assert(component_ptr != NULL)) {
-                        return false;
-                    }
-
-                    component_ptr = ECS_OFFSET(component_ptr, size * i);
-                    if (!if_test_assert(memcpy(component_ptr, expect_ptr, size))) {
-                        return false;
-                    }
-                }                
-            } else {
-                entity_index ++;
-            }
-
-
-            // Test ids
-            ecs_id_t *ids = expect->term_ids[entity_index];
-            if (!ids[0]) {
-                ids = expect->term_ids[0];
-            }
-
-            for (t = 0; t < it->field_count; t++) {
-                if (!ids[t]) {
-                    break;
-                }
-
-                if (!if_test_assert(ecs_field_id(it, t + 1) == ids[t])) {
-                    return false;
-                }
-            }
-
-            if (!if_test_assert(ids[t] == 0)) {
-                return false;
-            }
-
-
-            // Test ids by expr
-            char **ids_expect = expect->term_ids_expr[entity_index];
-            if (!ids_expect) {
-                ids_expect = expect->term_ids_expr[0];
-            }
-
-            for (t = 0; t < it->field_count; t++) {
-                if (!ids_expect[t]) {
-                    break;
-                }
-
-                char *id_found = ecs_id_str(it->world, ecs_field_id(it, t + 1));
-                if (!if_test_str(id_found, ids_expect[t])) {
-                    printf(" - term %d\n", t);
-                    if (e) {
-                        printf(" - matched entity %u (%s, [%s])\n", 
-                            (uint32_t)e,
-                            ecs_get_name(it->world, e),
-                            ecs_type_str(it->world, ecs_get_type(it->world, e)));
-
-                        if (expect->entities[i]) {
-                            printf(" - expected entity %u (%s)\n", 
-                                (uint32_t)expect->entities[i], 
-                                ecs_get_name(it->world, expect->entities[i]));
-                        } else if (expect->entity_names[i]) {
-                            printf(" - expected entity %s\n", 
-                                expect->entity_names[i]);
-                        }
-                    }
-
-                    printf(" - @ result index %d\n", entity_index);
-                    return false;
-                }
-                ecs_os_free(id_found);
-            }
-
-            if (!if_test_assert(ids_expect[t] == NULL)) {
-                return false;
-            }
-
-
-            // Test variables
-            int v;
-            for (v = 0; v < ITER_MAX_VARIABLES; v++) {
-                int32_t id = expect->variables[v].id;
-                if (!id) {
-                    break;
-                }
-                
-                ecs_entity_t e = expect->variables[v].entities[entity_index];
-                if (!e) {
-                    e = expect->variables[v].entities[0];
-                }
-                if (e) {
-                    ecs_entity_t var = ecs_iter_get_var(it, id);
-                    if (!if_test_assert(e == var)) {
-                        return false;
-                    }
-                }
-
-                const char *name = expect->variables[v].entity_names[entity_index];
-                if (!name) {
-                    name = expect->variables[v].entity_names[0];
-                }
-                if (name) {
-                    ecs_entity_t var = ecs_iter_get_var(it, id);
-                    if (!if_test_str(name, ecs_get_name(it->world, var))) {
-                        printf(" - variable id %d\n", id);
-                        printf(" - index %d\n", entity_index);
-                        return false;
-                    }                    
-                }
-
-                /* If a variable id is set, either an entity or entity name must
-                 * be set. */
-                if (!if_test_assert(e || name)) {
-                    return false;
-                }
-            }
-        }
-
-        expect->table_count_actual ++;
-    }
-
-    for (int i = 0; i < ITER_MAX_ENTITIES; i ++) {
-        if (expect->entities[i] || expect->entity_names[i]) {
-            if (!if_test_assert(expect->matched[i])) {
-                printf(" - entity %u (%s) at index %d not matched\n",
-                    (uint32_t)expect->entities[i], expect->entity_names[i], i);
-                return false;
-            }
-        }
-    }
-
-    if (expect->table_count_expect) {
-        if (!if_test_assert(expect->table_count_actual == expect->table_count_expect)) {
-            return false;
-        }
-    }
-
-    return true;
-}
diff --git a/test/collections/project.json b/test/collections/project.json
index eace53def..45dfc9d31 100644
--- a/test/collections/project.json
+++ b/test/collections/project.json
@@ -69,7 +69,8 @@
                 "count_of_null",
                 "try_low_after_ensure_high",
                 "is_alive_low_after_ensure_high",
-                "remove_low_after_ensure_high"
+                "remove_low_after_ensure_high",
+                "ensure_skip_generation"
             ]
         }, {
             "id": "Strbuf",
diff --git a/test/collections/src/Sparse.c b/test/collections/src/Sparse.c
index 03fe4d728..2c0a41c59 100644
--- a/test/collections/src/Sparse.c
+++ b/test/collections/src/Sparse.c
@@ -1,5 +1,5 @@
 #include <collections.h>
-#include <flecs/private/sparse.h>
+#include <flecs/datastructures/sparse.h>
 
 void Sparse_setup(void) {
     ecs_os_set_api_defaults();
@@ -392,3 +392,50 @@ void Sparse_remove_low_after_ensure_high(void) {
 
     flecs_sparse_free(sp);
 }
+
+void Sparse_ensure_skip_generation(void) {
+    ecs_sparse_t *sp1 = flecs_sparse_new(NULL, NULL, int);
+    ecs_sparse_t *sp2 = flecs_sparse_new(NULL, NULL, int);
+
+    uint64_t id = flecs_sparse_new_id(sp1);
+    flecs_sparse_ensure(sp2, 0, id);
+
+    test_assert(flecs_sparse_is_alive(sp1, id));
+    test_assert(flecs_sparse_is_alive(sp2, id));
+
+    flecs_sparse_remove(sp1, 0, id);
+    flecs_sparse_remove(sp2, 0, id);
+
+    test_assert(!flecs_sparse_is_alive(sp1, id));
+    test_assert(!flecs_sparse_is_alive(sp2, id));
+
+    uint64_t id_2 = flecs_sparse_new_id(sp1);
+    test_assert((uint32_t)id_2 == id);
+
+    test_assert(flecs_sparse_is_alive(sp1, id_2));
+    test_assert(!flecs_sparse_is_alive(sp2, id_2));
+    test_assert(!flecs_sparse_is_alive(sp1, id));
+    test_assert(!flecs_sparse_is_alive(sp2, id));
+
+    flecs_sparse_remove(sp1, 0, id_2);
+
+    test_assert(!flecs_sparse_is_alive(sp1, id_2));
+    test_assert(!flecs_sparse_is_alive(sp2, id_2));
+    test_assert(!flecs_sparse_is_alive(sp1, id));
+    test_assert(!flecs_sparse_is_alive(sp2, id));
+
+    uint64_t id_3 = flecs_sparse_new_id(sp1);
+    test_assert((uint32_t)id_3 == id);
+    flecs_sparse_ensure(sp2, 0, id_3);
+
+    test_assert(flecs_sparse_is_alive(sp1, id_3));
+    test_assert(flecs_sparse_is_alive(sp2, id_3));
+
+    test_assert(!flecs_sparse_is_alive(sp1, id_2));
+    test_assert(!flecs_sparse_is_alive(sp2, id_2));
+    test_assert(!flecs_sparse_is_alive(sp1, id));
+    test_assert(!flecs_sparse_is_alive(sp2, id));
+
+    flecs_sparse_free(sp1);
+    flecs_sparse_free(sp2);
+}
diff --git a/test/collections/src/main.c b/test/collections/src/main.c
index e228b5552..69be5ac6b 100644
--- a/test/collections/src/main.c
+++ b/test/collections/src/main.c
@@ -63,6 +63,7 @@ void Sparse_count_of_null(void);
 void Sparse_try_low_after_ensure_high(void);
 void Sparse_is_alive_low_after_ensure_high(void);
 void Sparse_remove_low_after_ensure_high(void);
+void Sparse_ensure_skip_generation(void);
 
 // Testsuite 'Strbuf'
 void Strbuf_setup(void);
@@ -305,6 +306,10 @@ bake_test_case Sparse_testcases[] = {
     {
         "remove_low_after_ensure_high",
         Sparse_remove_low_after_ensure_high
+    },
+    {
+        "ensure_skip_generation",
+        Sparse_ensure_skip_generation
     }
 };
 
@@ -463,7 +468,7 @@ static bake_test_suite suites[] = {
         "Sparse",
         Sparse_setup,
         NULL,
-        21,
+        22,
         Sparse_testcases
     },
     {
diff --git a/test/cpp_api/include/cpp_api/bake_config.h b/test/core/include/api/bake_config.h
similarity index 92%
rename from test/cpp_api/include/cpp_api/bake_config.h
rename to test/core/include/api/bake_config.h
index 85e23e0b3..71a0175fe 100644
--- a/test/cpp_api/include/cpp_api/bake_config.h
+++ b/test/core/include/api/bake_config.h
@@ -14,8 +14,8 @@
  * dependencies will automatically show up in this file. Include bake_config.h
  * in your main project file. Do not edit! */
 
-#ifndef CPP_API_BAKE_CONFIG_H
-#define CPP_API_BAKE_CONFIG_H
+#ifndef CORE_BAKE_CONFIG_H
+#define CORE_BAKE_CONFIG_H
 
 /* Headers of public dependencies */
 #include <flecs.h>
diff --git a/test/api/include/api.h b/test/core/include/core.h
similarity index 62%
rename from test/api/include/api.h
rename to test/core/include/core.h
index 97d70f2cc..ae2a9453b 100644
--- a/test/api/include/api.h
+++ b/test/core/include/core.h
@@ -1,8 +1,8 @@
-#ifndef API_H
-#define API_H
+#ifndef CORE_H
+#define CORE_H
 
 /* This generated file contains includes for project dependencies */
-#include <api/bake_config.h>
+#include <core/bake_config.h>
 #include <stdio.h>
 
 #ifdef __cplusplus
@@ -75,35 +75,6 @@ void probe_has_entity(Probe *probe, ecs_entity_t e);
 
 void install_test_abort(void);
 
-#define ITER_MAX_ENTITIES (64)
-#define ITER_MAX_TERMS (16)
-#define ITER_MAX_VARIABLES (16)
-
-typedef struct test_iter_result_t {
-    ecs_entity_t entities[ITER_MAX_ENTITIES];
-    ecs_id_t term_ids[ITER_MAX_ENTITIES][ITER_MAX_TERMS];
-    void *term_columns[ITER_MAX_TERMS];
-    
-    int32_t table_count_expect;
-    int32_t table_count_actual;
-
-    char *entity_names[ITER_MAX_ENTITIES];
-    char *term_ids_expr[ITER_MAX_ENTITIES][ITER_MAX_TERMS];
-    int32_t matched[ITER_MAX_ENTITIES];
-
-    struct {
-        int32_t id;
-        ecs_entity_t entities[ITER_MAX_ENTITIES];
-        char *entity_names[ITER_MAX_ENTITIES];
-    } variables[ITER_MAX_VARIABLES];
-} test_iter_result_t;
-
-// Utility for doing order-independent validation of iterator output
-bool test_iter(
-    ecs_iter_t *it, 
-    ecs_iter_next_action_t next, 
-    test_iter_result_t *expect);
-
 const ecs_entity_t* bulk_new_w_type(
     ecs_world_t *world, ecs_entity_t type_ent, int32_t count);
 
diff --git a/test/core/include/core/bake_config.h b/test/core/include/core/bake_config.h
new file mode 100644
index 000000000..71a0175fe
--- /dev/null
+++ b/test/core/include/core/bake_config.h
@@ -0,0 +1,25 @@
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef CORE_BAKE_CONFIG_H
+#define CORE_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+#include <bake_test.h>
+
+#endif
+
diff --git a/test/api/project.json b/test/core/project.json
similarity index 66%
rename from test/api/project.json
rename to test/core/project.json
index b650903cb..58f34e1f5 100644
--- a/test/api/project.json
+++ b/test/core/project.json
@@ -1,9 +1,9 @@
 {
-    "id": "api",
+    "id": "core",
     "type": "application",
     "value": {
         "author": "Sander Mertens",
-        "description": "Test project for flecs",
+        "description": "Flecs core tests",
         "public": false,
         "coverage": false,
         "use": [
@@ -160,7 +160,107 @@
                 "commit_w_on_add",
                 "commit_w_on_remove",
                 "commit_w_cmd_in_observer",
-                "entity_init_existing_no_sep"
+                "entity_init_existing_no_sep",
+                "entity_init_w_set_1_comp",
+                "entity_init_w_set_2_comp",
+                "entity_init_w_set_1_comp_1_tag",
+                "entity_init_w_set_2_comp_2_tag",
+                "entity_init_w_set_1_comp_w_name",
+                "entity_init_w_set_1_comp_existing",
+                "entity_init_w_set_1_comp_existing_empty",
+                "entity_init_w_set_1_comp_1_tag_w_set",
+                "entity_init_w_set_w_hook",
+                "entity_init_w_set_w_observer",
+                "entity_init_w_set_1_comp_defer",
+                "entity_init_w_set_2_comp_defer",
+                "entity_init_w_set_1_comp_1_tag_defer",
+                "entity_init_w_set_2_comp_2_tag_defer",
+                "entity_init_w_set_1_comp_w_name_defer",
+                "entity_init_w_set_1_comp_existing_defer",
+                "entity_init_w_set_1_comp_existing_empty_defer",
+                "entity_init_w_set_1_comp_1_tag_w_set_defer",
+                "insert_1_comp",
+                "insert_2_comp",
+                "insert_1_comp_1_tag",
+                "entity_w_parent",
+                "entity_w_parent_w_name",
+                "entity_w_parent_w_add",
+                "entity_w_parent_w_add_w_parent",
+                "entity_w_parent_w_set",
+                "entity_w_parent_w_set_w_parent"
+            ]
+        }, {
+            "id": "Each",
+            "testcases": [
+                "each_tag",
+                "each_component",
+                "each_pair",
+                "each_pair_rel_wildcard",
+                "each_pair_tgt_wildcard"
+            ]
+        }, {
+            "id": "Iter",
+            "testcases": [
+                "page_iter_0_0",
+                "page_iter_1_0",
+                "page_iter_0_1",
+                "page_iter_n_0",
+                "page_iter_0_n",
+                "page_iter_m_n",
+                "page_iter_skip_1_table",
+                "page_iter_skip_2_tables",
+                "worker_iter_1",
+                "worker_iter_2",
+                "worker_iter_3",
+                "worker_iter_4",
+                "paged_iter_w_shared_comp",
+                "worker_iter_w_shared_comp",
+                "paged_iter_w_task_query",
+                "worker_iter_w_task_query",
+                "worker_iter_w_singleton",
+                "worker_iter_w_singleton_component",
+                "worker_iter_w_singleton_instanced",
+                "worker_iter_w_singleton_component_instanced",
+                "paged_iter_w_singleton",
+                "paged_iter_w_singleton_component",
+                "paged_iter_w_singleton_instanced",
+                "paged_iter_w_singleton_component_instanced",
+                "page_iter_w_offset_skip_1_archetype",
+                "page_iter_w_offset_skip_1_archetype_plus_one",
+                "page_iter_w_offset_skip_2_archetypes",
+                "page_iter_w_limit_skip_1_archetype",
+                "page_iter_w_limit_skip_1_archetype_minus_one",
+                "page_iter_w_limit_skip_2_archetypes",
+                "page_iter_w_offset_1_limit_max",
+                "page_iter_w_offset_1_limit_minus_1",
+                "page_iter_w_offset_2_type_limit_max",
+                "page_iter_w_offset_2_type_limit_minus_1",
+                "page_iter_w_limit_1_all_offsets",
+                "page_iter_w_offset_out_of_bounds",
+                "page_iter_w_limit_out_of_bounds",
+                "page_iter_comb_10_entities_1_type",
+                "page_iter_comb_10_entities_2_types",
+                "count",
+                "iter_restore_stack_iter",
+                "interleaved_iter",
+                "get_first",
+                "page_iter_w_only_tag",
+                "worker_iter_w_only_tag",
+                "page_iter_w_inout_none",
+                "worker_iter_w_inout_none",
+                "page_iter_w_ctx",
+                "page_iter_w_binding_ctx",
+                "worker_iter_w_ctx",
+                "worker_iter_w_binding_ctx",
+                "column_index_owned",
+                "column_index_shared",
+                "column_index_not",
+                "page_iter_w_fini",
+                "worker_iter_w_fini",
+                "rule_page_iter_w_fini",
+                "rule_worker_iter_w_fini",
+                "to_str_before_next",
+                "to_str"
             ]
         }, {
             "id": "Search",
@@ -184,10 +284,7 @@
                 "search_relation_inherit_from_parent",
                 "search_relation_dont_inherit",
                 "search_relation_dont_inherit_from_parent",
-                "search_relation_exclusive",
-                "search_relation_union",
-                "search_relation_union_wildcard",
-                "search_relation_union_pair"
+                "search_relation_exclusive"
             ]
         }, {
             "id": "Event",
@@ -207,6 +304,7 @@
                 "emit_custom_implicit_any",
                 "emit_custom_empty_type",
                 "emit_w_param",
+                "emit_w_param_multi_observer",
                 "emit_w_const_param",
                 "emit_nested",
                 "enqueue_event_1_id",
@@ -248,7 +346,6 @@
                 "create_w_explicit_id_2_worlds",
                 "new_w_id_0_w_with",
                 "new_w_id_w_with",
-                "new_w_type_0_w_with",
                 "new_w_type_w_with",
                 "new_w_id_w_with_w_scope",
                 "new_w_type_w_with_w_scope",
@@ -311,113 +408,6 @@
                 "invalid_pair_w_0_obj",
                 "add_random_id"
             ]
-        }, {
-            "id": "Switch",
-            "testcases": [
-                "get_case_no_switch",
-                "get_case_set",
-                "get_case_change",
-                "remove_case",
-                "remove_last",
-                "delete_first",
-                "delete_last",
-                "delete_first_last",
-                "3_entities_same_case",
-                "2_entities_1_change_case",
-                "3_entities_change_case",
-                "query_switch",
-                "query_1_case_1_type",
-                "query_1_case_2_types",
-                "query_2_cases_1_type",
-                "query_2_cases_2_types",
-                "query_after_remove",
-                "add_case_in_stage",
-                "change_case_in_stage",
-                "change_one_case_in_stage",
-                "remove_switch_in_stage",
-                "switch_no_match_for_case",
-                "empty_entity_has_case",
-                "zero_entity_has_case",
-                "add_to_entity_w_switch",
-                "add_pair_to_entity_w_switch",
-                "sort",
-                "recycled_tags",
-                "query_recycled_tags",
-                "single_case",
-                "match_switch_on_base_instance",
-                "switch_w_bitset_query",
-                "switch_w_bitset_query_inv",
-                "switch_w_bitset_query_2_elems",
-                "switch_w_bitset_query_2_elems_skip",
-                "switch_w_bitset_query_elems_interleaved",
-                "switch_w_bitset_query_elems_interleaved_2_types",
-                "has_wildcard",
-                "remove_wildcard",
-                "same_table_after_change",
-                "component_relation",
-                "delete_case_trigger_after_delete_switch",
-                "add_2",
-                "add_2_reverse",
-                "add_switch_to_prefab_instance",
-                "get_case_w_generation",
-                "get_case_w_generation_not_alive"
-            ]
-        }, {
-            "id": "EnabledComponents",
-            "testcases": [
-                "is_component_enabled",
-                "is_empty_entity_disabled",
-                "is_0_entity_disabled",
-                "is_0_component_disabled",
-                "is_nonexist_component_disabled",
-                "is_enabled_component_enabled",
-                "is_disabled_component_enabled",
-                "has_enabled_component",
-                "is_enabled_after_add",
-                "is_enabled_after_remove",
-                "is_enabled_after_disable",
-                "is_disabled_after_enable",
-                "is_enabled_randomized",
-                "is_enabled_after_add_randomized",
-                "is_enabled_after_randomized_add_randomized",
-                "is_enabled_2",
-                "is_enabled_3",
-                "is_enabled_2_after_add",
-                "is_enabled_3_after_add",
-                "is_pair_enabled",
-                "is_enabled_pair_enabled",
-                "is_disabled_pair_enabled",
-                "has_enabled_pair",
-                "is_pair_enabled_after_add",
-                "is_pair_enabled_after_remove",
-                "is_pair_enabled_after_disable",
-                "is_pair_disabled_after_enable",
-                "is_pair_enabled_2",
-                "is_pair_enabled_3",
-                "is_pair_enabled_2_after_add",
-                "is_pair_enabled_3_after_add",
-                "query_disabled",
-                "query_disabled_skip_initial",
-                "query_disabled_pair",
-                "query_disabled_pair_skip_initial",
-                "query_mod_2",
-                "query_mod_8",
-                "query_mod_64",
-                "query_mod_256",
-                "query_mod_1024",
-                "query_enable_mod_10",
-                "query_mod_2_2_bitsets",
-                "query_mod_8_2_bitsets",
-                "query_mod_64_2_bitsets",
-                "query_mod_256_2_bitsets",
-                "query_mod_1024_2_bitsets",
-                "query_randomized_2_bitsets",
-                "query_randomized_3_bitsets",
-                "query_randomized_4_bitsets",
-                "defer_enable",
-                "sort",
-                "table_move_2_from_3"
-            ]
         }, {
             "id": "Remove",
             "testcases": [
@@ -491,8 +481,6 @@
                 "delete_children",
                 "scope_set",
                 "scope_set_again",
-                "scope_set_w_new",
-                "scope_set_w_new_staged",
                 "scope_set_w_lookup",
                 "scope_component",
                 "scope_component_no_macro",
@@ -512,14 +500,11 @@
                 "add_path_from_scope_new_entity",
                 "add_root_path_to_child",
                 "add_parent_path_from_root_to_child",
-                "new_w_child_in_root",
                 "delete_child",
                 "delete_2_children",
                 "delete_2_children_different_type",
                 "delete_tree_2_levels",
                 "delete_tree_3_levels",
-                "delete_tree_count_tables",
-                "delete_tree_staged",
                 "delete_tree_empty_table",
                 "delete_tree_recreate",
                 "delete_tree_w_onremove",
@@ -531,8 +516,6 @@
                 "add_child_after_delete_tree",
                 "add_child_to_recycled_parent",
                 "get_type_after_recycled_parent_add",
-                "rematch_after_add_to_recycled_parent",
-                "cascade_after_recycled_parent_change",
                 "long_name_depth_0",
                 "long_name_depth_1",
                 "long_name_depth_2",
@@ -548,75 +531,6 @@
                 "defer_batch_remove_name_w_add_childof",
                 "defer_batch_remove_childof_w_add_name"
             ]
-        }, {
-            "id": "FixedHierarchies",
-            "testcases": [
-                "make_fixed_1_lvl",
-                "make_fixed_1_lvl_w_init",
-                "make_fixed_1_lvl_w_init_comp",
-                "make_fixed_1_lvl_w_init_comp_after_tree_fixed",
-                "make_fixed_1_lvl_2_entities",
-                "make_fixed_1_lvl_2_tables",
-                "make_fixed_2_lvl",
-                "make_fixed_2_lvl_2_tables",
-                "make_fixed_3_lvl",
-                "make_fixed_3_lvl_w_name",
-                "make_fixed_3_2_lvl_w_name",
-                "make_fixed_2_lvl_nested",
-                "make_fixed_3_lvl_nested",
-                "make_fixed_1_lvl_after_delete",
-                "get_target_1_lvl",
-                "get_target_2_lvl",
-                "get_depth_1_lvl",
-                "get_depth_2_lvl",
-                "get_depth_after_reparent_root",
-                "delete_fixed_1_lvl",
-                "delete_fixed_2_lvl",
-                "delete_with_fixed_1_lvl",
-                "delete_with_fixed_2_lvl",
-                "query_w_parent_field_1_lvl",
-                "query_w_parent_field_1_lvl_w_init",
-                "query_w_parent_field_1_lvl_w_init_comp_after_tree_fixed",
-                "query_w_parent_field_2_lvl",
-                "query_w_parent_field_1_fixed_1_regular",
-                "query_w_parent_field_only_fixed_1_lvls",
-                "query_w_parent_field_fixed_1_lvls_no_match",
-                "query_w_parent_field_fixed_1_lvls_2_no_match",
-                "query_w_parent_field_fixed_1_lvls_match_no_match",
-                "query_w_parent_field_fixed_1_lvls_no_match_match",
-                "query_w_parent_field_2_fixed_2_lvls",
-                "query_w_cascade_field_2_lvl",
-                "query_next_table",
-                "query_next_table_1_elem",
-                "query_next_table_1_elem_no_match",
-                "query_nested_make_fixed",
-                "query_nested_make_fixed_w_optional",
-                "query_nested_make_fixed_w_optional_match_children_only",
-                "query_nested_w_2_parents_make_fixed",
-                "query_table_w_3_parents",
-                "query_w_parent_change_detection_1st",
-                "query_w_parent_change_detection_2nd",
-                "query_w_parent_change_detection_iter_twice",
-                "query_w_parent_change_detection_iter_twice_each_parent",
-                "query_w_parent_change_detection_1st_populate_when_changed",
-                "query_w_parent_change_detection_2nd_populate_when_changed",
-                "query_w_parent_change_detection_iter_twice_populate_when_changed",
-                "query_w_parent_change_detection_iter_twice_each_parent_populate_when_changed",
-                "staged_query_w_parent_field_1_lvl",
-                "staged_query_w_parent_field_2_lvl",
-                "staged_query_w_parent_field_1_fixed_1_regular",
-                "staged_query_w_cascade_field_2_lvl",
-                "add_to_fixed",
-                "remove_from_fixed",
-                "delete_fixed",
-                "clear_fixed",
-                "make_fixed_1_lvl_w_name",
-                "make_fixed_2_lvl_w_name",
-                "make_fixed_1_lvl_w_name_keep_name",
-                "make_fixed_2_lvl_w_name_keep_name",
-                "make_fixed_2_lvl_lose_depth",
-                "make_fixed_3_lvl_lose_depth"
-            ]
         }, {
             "id": "Has",
             "testcases": [
@@ -810,9 +724,7 @@
                 "delete_child_of_delete_with",
                 "deep_clean_64",
                 "deep_clean_256",
-                "id_w_switch",
                 "id_w_disabled",
-                "id_to_no_switch",
                 "id_to_no_disabled",
                 "remove_on_delete_action",
                 "delete_with_w_relation",
@@ -880,7 +792,8 @@
                 "emplace_2",
                 "emplace_existing",
                 "emplace_w_move",
-                "emplace_w_observer_w_add"
+                "emplace_w_observer_w_add",
+                "emplace_existing_w_check"
             ]
         }, {
             "id": "ReadWrite",
@@ -988,9 +901,6 @@
                 "copy_on_override",
                 "copy_on_clone",
                 "no_copy_on_move",
-                "ctor_copy_on_snapshot",
-                "copy_on_snapshot",
-                "dtor_on_restore",
                 "ctor_on_tag",
                 "dtor_on_tag",
                 "copy_on_tag",
@@ -1016,6 +926,8 @@
                 "ctor_w_emplace",
                 "ctor_w_emplace_defer",
                 "ctor_w_emplace_defer_use_move_ctor",
+                "ctor_w_emplace_defer_twice",
+                "ctor_w_emplace_defer_existing",
                 "on_add_w_emplace",
                 "on_add_w_emplace_existing",
                 "on_add_w_emplace_defer",
@@ -1055,6 +967,8 @@
                 "component_init_set_hooks",
                 "component_init_name_from_type_info",
                 "component_init_scoped_name_from_type_info",
+                "component_init_w_recycled_id",
+                "component_init_w_recycled_non_component_id",
                 "on_add_after_ctor_w_add",
                 "on_add_after_ctor_w_add_to",
                 "with_before_hooks",
@@ -1072,729 +986,6 @@
                 "on_nested_prefab_copy_test_invokes_copy_count",
                 "no_move_no_move_ctor_with_move_dtor_with_ctor_move_dtor"
             ]
-        }, {
-            "id": "Sorting",
-            "testcases": [
-                "sort_by_component",
-                "sort_by_component_2_tables",
-                "sort_by_component_3_tables",
-                "sort_by_entity",
-                "sort_after_add",
-                "sort_after_remove",
-                "sort_after_delete",
-                "sort_after_set",
-                "sort_after_system",
-                "sort_after_query",
-                "sort_by_component_same_value_1",
-                "sort_by_component_same_value_2",
-                "sort_by_component_move_pivot",
-                "sort_1000_entities",
-                "sort_1000_entities_w_duplicates",
-                "sort_1000_entities_again",
-                "sort_1000_entities_2_types",
-                "sort_1500_entities_3_types",
-                "sort_2000_entities_4_types",
-                "sort_2_entities_2_types",
-                "sort_3_entities_3_types",
-                "sort_3_entities_3_types_2",
-                "sort_4_entities_4_types",
-                "sort_1000_entities_2_types_again",
-                "sort_1000_entities_add_type_after_sort",
-                "sort_shared_component",
-                "sort_shared_component_childof",
-                "sort_w_tags_only",
-                "sort_childof_marked",
-                "sort_isa_marked",
-                "sort_relation_marked",
-                "dont_resort_after_set_unsorted_component",
-                "dont_resort_after_set_unsorted_component_w_tag",
-                "dont_resort_after_set_unsorted_component_w_tag_w_out_term",
-                "sort_component_not_queried_for",
-                "sort_by_wildcard",
-                "sort_shared_w_delete",
-                "sort_w_nontrivial_component"
-            ]
-        }, {
-            "id": "SortingEntireTable",
-            "testcases": [
-                "sort_by_component",
-                "sort_by_component_2_tables",
-                "sort_by_component_3_tables",
-                "sort_by_entity",
-                "sort_after_add",
-                "sort_after_remove",
-                "sort_after_delete",
-                "sort_after_set",
-                "sort_after_system",
-                "sort_after_query",
-                "sort_by_component_same_value_1",
-                "sort_by_component_same_value_2",
-                "sort_by_component_move_pivot",
-                "sort_1000_entities",
-                "sort_1000_entities_w_duplicates",
-                "sort_1000_entities_again",
-                "sort_1000_entities_2_types",
-                "sort_1500_entities_3_types",
-                "sort_2000_entities_4_types",
-                "sort_2_entities_2_types",
-                "sort_3_entities_3_types",
-                "sort_3_entities_3_types_2",
-                "sort_4_entities_4_types",
-                "sort_1000_entities_2_types_again",
-                "sort_1000_entities_add_type_after_sort",
-                "sort_shared_component",
-                "sort_w_tags_only",
-                "sort_childof_marked",
-                "sort_isa_marked",
-                "sort_relation_marked",
-                "dont_resort_after_set_unsorted_component",
-                "dont_resort_after_set_unsorted_component_w_tag",
-                "dont_resort_after_set_unsorted_component_w_tag_w_out_term",
-                "sort_shared_w_delete"
-            ]
-        }, {
-            "id": "Filter",
-            "testcases": [
-                "filter_1_term",
-                "filter_1_term_component",
-                "filter_2_terms",
-                "filter_3_terms",
-                "filter_3_terms_w_or",
-                "filter_4_terms_w_or_at_1",
-                "filter_1_term_wildcard",
-                "filter_1_term_any",
-                "filter_1_term_same_subj_obj",
-                "filter_1_term_acyclic_same_subj_obj",
-                "filter_1_term_acyclic_reflexive_same_subj_obj",
-                "filter_1_term_same_subj_obj_var",
-                "filter_1_term_acyclic_same_subj_obj_var",
-                "filter_1_term_acyclic_reflexive_same_subj_obj_var",
-                "filter_1_term_non_acyclic_superset",
-                "filter_1_term_dont_inherit_default_set",
-                "filter_1_term_dont_inherit_pair_default_set",
-                "filter_1_term_cascade_implicit_isa",
-                "filter_1_term_cascade_isa",
-                "filter_1_term_cascade_childof",
-                "filter_1_term_cascade_down",
-                "filter_1_term_optional_only",
-                "filter_1_term_transitive_pair",
-                "filter_1_term_transitive_pair_explicit_self_tgt",
-                "filter_1_variable_as_pred_only",
-                "filter_1_variable_as_pred_w_subj",
-                "filter_1_variable_as_pred_w_pair",
-                "filter_1_variable_as_subj",
-                "filter_1_variable_as_obj",
-                "filter_2_terms_or_w_dontinherit",
-                "filter_2_terms_or_w_both_dontinherit",
-                "filter_w_pair_id",
-                "filter_w_pred_obj",
-                "filter_w_pair_id_and_subj",
-                "filter_1_w_pred_name",
-                "filter_1_w_final_pred_name",
-                "filter_1_w_subj_name",
-                "filter_1_w_obj_name",
-                "filter_w_this_implicit_variable",
-                "filter_w_this_explicit_entity",
-                "filter_w_first_this_implicit_variable",
-                "filter_w_first_this_explicit_entity",
-                "filter_w_second_this_implicit_variable",
-                "filter_w_second_this_explicit_entity",
-                "filter_w_this_variable_name",
-                "filter_w_src_var",
-                "filter_w_first_var",
-                "filter_w_second_var",
-                "filter_w_src_var_from_name",
-                "filter_w_first_first_var",
-                "filter_w_second_second_var",
-                "filter_w_0_source",
-                "filter_w_0_target",
-                "filter_2_terms_w_or",
-                "filter_2_terms_w_or_mixed_src_flags",
-                "filter_2_terms_w_or_mixed_src_id",
-                "filter_2_terms_w_or_mixed_src_name",
-                "filter_2_terms_w_or_same_src_w_id_and_name",
-                "filter_move",
-                "filter_copy",
-                "filter_w_resources_copy",
-                "filter_w_and_flag",
-                "filter_w_or_flag",
-                "filter_w_not_flag",
-                "filter_filter",
-                "filter_double_init",
-                "filter_double_init_w_expr",
-                "filter_double_init_w_expr_optional",
-                "filter_w_tag_term_is_no_data",
-                "filter_w_inout_none_term_is_no_data",
-                "filter_w_tag_and_inout_none_term_is_no_data",
-                "filter_w_not_term_is_no_data",
-                "filter_w_no_transitive_pair",
-                "filter_w_transitive_pair_any_src",
-                "filter_w_transitive_pair",
-                "filter_w_transitive_tag_no_pair",
-                "filter_w_transitive_tag_self_tgt",
-                "filter_w_transitive_tag_any_tgt",
-                "filter_w_pair_same_vars",
-                "filter_w_pair_not_same_vars",
-                "filter_w_pair_no_vars_not_same_vars",
-                "filter_w_pair_wildcard_not_same_vars",
-                "filter_w_pair_any_not_same_vars",
-                "filter_w_no_pair_not_same_vars",
-                "filter_not_childof_any",
-                "filter_w_inherited_id",
-                "filter_w_inherited_pair",
-                "filter_w_non_inherited_id",
-                "filter_w_non_inherited_pair",
-                "filter_w_first_rel",
-                "filter_w_first_rel_self",
-                "filter_w_first_rel_down",
-                "filter_w_first_rel_self_down",
-                "filter_w_first_rel_reflexive",
-                "filter_w_first_rel_reflexive_self",
-                "filter_w_first_rel_reflexive_down",
-                "filter_w_first_rel_reflexive_self_down",
-                "filter_w_first_rel_non_traversable",
-                "filter_w_first_wildcard_inout_none",
-                "filter_w_first_var_inout_none",
-                "filter_w_pair_wildcard_inout_none",
-                "filter_w_pair_var_inout_none",
-                "filter_w_unresolved_by_name",
-                "filter_w_unresolved_by_name_eq",
-                "filter_childof_this",
-                "filter_childof_this_entity",
-                "filter_childof_this_by_id",
-                "term_w_id",
-                "term_w_pair_id",
-                "term_w_pred_obj",
-                "term_w_pair_finalize_twice",
-                "term_w_role",
-                "term_w_pred_role",
-                "term_w_self",
-                "term_w_superset",
-                "term_w_subset",
-                "term_w_self_superset",
-                "term_w_superset_custom_relation",
-                "term_w_self_superset_custom_relation",
-                "term_iter_component",
-                "term_iter_w_pred",
-                "term_iter_tag",
-                "term_iter_pair",
-                "term_iter_pair_w_rel_wildcard",
-                "term_iter_pair_w_obj_wildcard",
-                "term_iter_pair_w_rel_wildcard_n_matches",
-                "term_iter_pair_w_rel_wildcard_n_matches_w_data",
-                "term_iter_pair_w_obj_wildcard_n_matches",
-                "term_iter_pair_w_obj_wildcard_n_matches_w_data",
-                "term_iter_w_superset",
-                "term_iter_w_superset_base_w_2_components",
-                "term_iter_w_superset_childof",
-                "term_iter_w_superset_self",
-                "term_iter_w_superset_self_childof",
-                "term_iter_w_superset_tag",
-                "term_iter_w_superset_pair",
-                "term_iter_w_superset_pair_obj_wildcard",
-                "term_iter_in_stage",
-                "term_iter_w_readonly_term",
-                "term_iter_type_set",
-                "term_iter_any_match_wildcard",
-                "term_iter_any_match_tag_and_wildcard",
-                "term_iter_any_obj",
-                "children_iter",
-                "filter_iter_1_tag",
-                "filter_iter_2_tags",
-                "filter_iter_2_tags_1_not",
-                "filter_iter_3_tags_2_or",
-                "filter_iter_only_optional",
-                "filter_iter_only_2_or",
-                "filter_iter_only_3_or",
-                "filter_iter_2_or",
-                "filter_iter_3_or",
-                "filter_iter_2_or_other_type",
-                "filter_iter_2_or_same_type",
-                "filter_iter_or_w_wildcard",
-                "filer_iter_or_w_component_and_tag",
-                "filer_iter_or_w_tag_and_component",
-                "filter_iter_1_component",
-                "filter_iter_2_components",
-                "filter_iter_pair_id",
-                "filter_iter_2_pair_ids",
-                "filter_iter_childof_pair_0_parent",
-                "filter_iter_pair_pred_obj",
-                "filter_iter_pair_2_pred_obj",
-                "filter_iter_null",
-                "filter_iter_1_not_tag",
-                "filter_iter_2_tags_1_optional",
-                "filter_iter_2_components_1_optional",
-                "filter_iter_in_stage",
-                "filter_iter_10_tags",
-                "filter_iter_20_tags",
-                "filter_iter_10_components",
-                "filter_iter_20_components",
-                "filter_iter_superset",
-                "filter_iter_superset_childof",
-                "filter_iter_type_set",
-                "filter_iter_w_readonly_term",
-                "filter_iter_w_from_nothing_term",
-                "filter_iter_pair_w_rel_wildcard_n_matches",
-                "filter_iter_pair_w_obj_wildcard_n_matches",
-                "filter_iter_pair_w_2_wildcards_1_match",
-                "filter_iter_pair_w_2_wildcards_2x1_matches",
-                "filter_iter_pair_w_2_wildcards_2x2_matches",
-                "filter_iter_pair_w_3_wildcards_2x2x2_matches",
-                "filter_iter_pair_w_wildcard_and_nothing",
-                "filter_iter_any",
-                "filter_iter_any_match_wildcard",
-                "filter_iter_any_match_tag_and_wildcard",
-                "filter_iter_wildcard_in_2nd_term",
-                "filter_iter_wildcard_in_2nd_term_self",
-                "filter_iter_2nd_term_self_create_id_after_filter",
-                "filter_iter_any_obj",
-                "filter_iter_not_any",
-                "filter_iter_not_any_obj",
-                "filter_iter_cascade_isa",
-                "filter_iter_cascade_childof",
-                "filter_iter_superset_2_rel_instances",
-                "filter_iter_superset_2_rel_instances_match_2nd",
-                "filter_iter_superset_2_levels",
-                "filter_iter_superset_only_w_owned",
-                "filter_iter_superset_after_add",
-                "filter_iter_superset_after_remove",
-                "filter_iter_superset_after_clear",
-                "filter_iter_superset_after_delete",
-                "filter_iter_2_terms_superset_2_rel_instances",
-                "filter_iter_2_terms_superset_2_rel_instances_match_2nd",
-                "filter_iter_superset_parent_w_isa",
-                "filter_iter_superset_isa_after_remove_parent",
-                "filter_iter_superset_isa_create_table_after_iter",
-                "filter_iter_superset_2_relations",
-                "filter_iter_superset_2_relations_instanced",
-                "filter_iter_superset_2_relations_w_component",
-                "filter_iter_superset_2_relations_instanced_w_component",
-                "filter_iter_not_up_disabled",
-                "filter_iter_pair_wildcard_component",
-                "filter_w_10_terms",
-                "filter_w_10_terms_move",
-                "filter_w_10_terms_copy",
-                "match_disabled",
-                "match_prefab",
-                "chain_term_iter",
-                "chain_filter_iter",
-                "chain_query_iter",
-                "chain_rule_iter",
-                "chain_iter_2_levels",
-                "filter_from_expr_2_terms_err",
-                "chain_term_iter_w_term_iter",
-                "chain_filter_iter_w_term_iter",
-                "chain_w_term_iter_component",
-                "chain_iter_w_or",
-                "filter_w_recycled_first",
-                "filter_w_recycled_second",
-                "filter_w_recycled_first_and_id",
-                "filter_w_recycled_second_and_id",
-                "filter_w_recycled_first_by_name_and_id",
-                "filter_w_recycled_second_by_name_and_id",
-                "filter_w_recycled_first_by_expr",
-                "filter_w_recycled_second_by_expr",
-                "filter_w_recycled_first_only_by_expr",
-                "term_iter_w_filter_term",
-                "filter_iter_w_filter_term",
-                "filter_iter_w_2_terms_1_filter",
-                "filter_iter_w_3_terms_2_filter",
-                "filter_iter_2_terms_filter_all",
-                "filter_iter_2_terms_filter_all_w_out",
-                "filter_iter_switch_term_filter",
-                "filter_iter_2_terms_switch_term_filter",
-                "filter_iter_switch_superset",
-                "filter_instanced_w_singleton",
-                "filter_instanced_w_base",
-                "filter_no_instancing_w_singleton",
-                "filter_no_instancing_w_base",
-                "filter_no_this_tag",
-                "filter_no_this_component",
-                "filter_no_this_tag_2_ents",
-                "filter_no_this_component_2_ents",
-                "filter_no_this_tag_2_ents_1_not",
-                "filter_no_this_component_2_ents_1_not",
-                "filter_no_this_component_1_not",
-                "filter_iter_entities_optional_flag",
-                "filter_iter_frame_offset",
-                "filter_1_term_no_alloc",
-                "filter_cache_size_terms_no_alloc",
-                "filter_lt_cache_size_terms_no_alloc",
-                "move_self",
-                "match_empty_tables",
-                "match_empty_tables_w_no_empty_tables",
-                "match_switch_w_switch",
-                "match_switch_w_case",
-                "match_switch_w_case_2_terms",
-                "match_case_no_case",
-                "and_term",
-                "or_term",
-                "iter_while_creating_components",
-                "iter_w_this_var_as_entity",
-                "iter_w_this_var_as_table",
-                "iter_w_this_var_as_table_range",
-                "filter_wo_this_var",
-                "set_this_to_table_1_term",
-                "set_this_to_table_2_terms",
-                "set_this_to_table_1_wildcard",
-                "set_this_to_table_no_match_no_data",
-                "set_this_to_table_no_match",
-                "set_this_to_table_2_terms_no_match",
-                "set_this_to_empty_table",
-                "set_this_to_empty_table_w_component",
-                "set_this_to_implicit_isa_superset_match",
-                "set_this_to_self_isa_superset_match",
-                "set_this_to_isa_superset_match",
-                "set_this_to_childof_superset_match",
-                "set_this_to_superset_w_self_filter_no_match",
-                "set_this_to_isa_cascade",
-                "set_this_to_childof_cascade",
-                "set_this_w_wildcard_2_matches",
-                "set_this_to_entity_superset_self_has_component",
-                "set_this_to_1_entity_in_table",
-                "oneof",
-                "oneof_expr",
-                "oneof_w_mismatching_obj",
-                "oneof_w_mismatching_obj_expr",
-                "oneof_wildcard",
-                "oneof_any",
-                "flag_match_only_this",
-                "flag_match_only_this_w_ref",
-                "filter_w_alloc",
-                "filter_w_short_notation"
-            ]
-        }, {
-            "id": "FilterStr",
-            "testcases": [
-                "one_term",
-                "one_term_w_inout",
-                "two_terms",
-                "two_terms_w_inout",
-                "three_terms_w_or",
-                "three_terms_w_or_inout",
-                "four_terms_three_w_or_inout",
-                "one_term_w_pair",
-                "one_term_w_pair_entity_src",
-                "one_term_w_self",
-                "one_term_w_up",
-                "one_term_w_0",
-                "one_term_w_singleton",
-                "one_term_w_final_pair",
-                "one_term_w_final_dont_inherit_pair",
-                "one_term_w_src_var",
-                "one_term_w_first_var",
-                "one_term_w_second_var",
-                "one_term_w_first_var_entity_src",
-                "one_term_w_pair_w_0_entity",
-                "not_term",
-                "wildcard_term",
-                "scopes",
-                "pred_eq",
-                "pred_neq",
-                "pred_eq_name",
-                "pred_neq_name",
-                "pred_eq_m",
-                "pred_neq_m"
-            ]
-        }, {
-            "id": "Query",
-            "testcases": [
-                "simple_query_existing_table",
-                "simple_query_2_existing_tables",
-                "simple_query_new_table",
-                "simple_query_2_new_tables",
-                "simple_query_existing_and_new_table",
-                "wildcard_query_existing_table",
-                "wildcard_query_new_table",
-                "wildcard_query_existing_table_2_results_p_table",
-                "wildcard_query_new_table_2_results_p_table",
-                "wildcard_query_2nd_term",
-                "wildcard_query_2nd_term_self",
-                "simple_query_existing_empty_table",
-                "simple_query_existing_empty_type",
-                "simple_query_new_empty_table",
-                "component_query_existing_table",
-                "component_query_new_table",
-                "component_query_existing_empty_table",
-                "2_component_query_existing_empty_table",
-                "2_component_query_existing_empty_type",
-                "only_optional",
-                "only_optional_new_empty_table",
-                "only_optional_new_empty_non_empty_table",
-                "only_optional_new_unset_tables",
-                "singleton_w_optional_new_empty_table",
-                "singleton_w_optional_new_empty_non_empty_table",
-                "singleton_w_optional_new_unset_tables",
-                "query_only_from_entity",
-                "query_only_from_entity_no_match",
-                "query_only_from_entity_no_match_iter_alloc",
-                "query_only_from_singleton",
-                "query_only_from_entity_match_after",
-                "query_only_from_singleton_match_after",
-                "query_only_from_singleton_component_match_after",
-                "query_only_from_nothing",
-                "query_only_from_entity_optional",
-                "query_only_from_entity_no_match_optional",
-                "query_only_from_entity_or",
-                "query_only_from_entity_no_match_or",
-                "query_only_from_entity_or_change",
-                "query_from_entity_or_change",
-                "query_from_entity_w_superset",
-                "query_w_singleton_tag_non_instanced",
-                "query_w_singleton_tag_instanced",
-                "query_w_singleton_component_non_instanced",
-                "query_w_singleton_component_instanced",
-                "query_w_from_entity",
-                "query_w_from_singleton",
-                "query_w_from_entity_match_after",
-                "query_w_from_singleton_match_after",
-                "query_w_from_nothing",
-                "query_w_existing_switch_and_case",
-                "query_w_new_switch_and_case",
-                "query_for_case_existing",
-                "query_for_case_new",
-                "query_for_switch_filter_term",
-                "query_switch_from_nothing",
-                "query_case_from_nothing",
-                "query_case_inherited",
-                "query_case_w_generation",
-                "query_case_w_not_alive",
-                "query_disabled_from_nothing",
-                "query_only_2_or",
-                "query_only_3_or",
-                "query_2_or",
-                "query_3_or",
-                "query_and_type",
-                "query_or_type",
-                "query_and_type_match_after",
-                "query_or_type_match_after",
-                "query_changed_after_new",
-                "query_changed_after_delete",
-                "query_changed_after_add",
-                "query_changed_after_remove",
-                "query_changed_after_set",
-                "query_change_after_modified",
-                "query_change_after_out_system",
-                "query_change_after_in_system",
-                "query_change_after_modified_out_term",
-                "query_change_check_iter",
-                "query_change_check_iter_after_skip_read",
-                "query_change_check_iter_after_skip_write",
-                "query_change_parent_term",
-                "query_change_prefab_term",
-                "query_change_parent_term_w_tag",
-                "query_change_prefab_term_w_tag",
-                "query_change_skip_non_instanced",
-                "query_changed_w_or",
-                "query_changed_or",
-                "query_changed_w_singleton",
-                "query_changed_w_only_singleton",
-                "query_changed_w_only_singleton_after_set",
-                "query_changed_w_only_singleton_after_out_term",
-                "query_changed_w_only_singleton_after_singleton_out_term",
-                "query_changed_w_only_parent",
-                "query_changed_w_only_parent_after_set",
-                "query_changed_w_only_parent_after_out_term",
-                "query_changed_w_only_parent_after_parent_out_term",
-                "query_changed_tag",
-                "query_changed_no_source",
-                "query_changed_no_source_component",
-                "query_changed_w_not_out",
-                "subquery_match_existing",
-                "subquery_match_new",
-                "subquery_inactive",
-                "subquery_unmatch",
-                "subquery_rematch",
-                "subquery_rematch_w_parent_optional",
-                "subquery_rematch_w_sub_optional",
-                "query_single_pairs",
-                "query_single_instanceof",
-                "query_single_childof",
-                "query_optional_owned",
-                "query_optional_shared",
-                "query_optional_shared_nested",
-                "query_optional_any",
-                "query_rematch_optional_after_add",
-                "get_owned_tag",
-                "get_shared_tag",
-                "explicit_delete",
-                "get_column_size",
-                "orphaned_query",
-                "nested_orphaned_query",
-                "invalid_access_orphaned_query",
-                "stresstest_query_free",
-                "only_from_entity",
-                "only_not_from_entity",
-                "only_from_singleton",
-                "only_not_from_singleton",
-                "get_filter",
-                "group_by",
-                "group_by_w_ctx",
-                "group_by_w_sort_reverse_group_creation",
-                "group_by_iter_one",
-                "group_by_iter_one_all_groups",
-                "group_by_iter_one_empty",
-                "group_by_iter_one_empty_query",
-                "group_by_iter_one_empty_table",
-                "group_by_w_deleted_group_id",
-                "group_by_callbacks",
-                "group_by_default_action",
-                "group_table_count",
-                "iter_valid",
-                "query_optional_tag",
-                "query_optional_shared_tag",
-                "query_iter_10_tags",
-                "query_iter_20_tags",
-                "query_iter_10_components",
-                "query_iter_20_components",
-                "iter_type_set",
-                "filter_term",
-                "2_terms_1_filter",
-                "3_terms_2_filter",
-                "no_instancing_w_singleton",
-                "no_instancing_w_shared",
-                "query_iter_frame_offset",
-                "add_singleton_after_query",
-                "query_w_component_from_parent_from_non_this",
-                "create_query_while_pending",
-                "empty_query",
-                "parent_cascade",
-                "existing_custom_rel_cascade",
-                "new_custom_rel_cascade",
-                "cascade_w_2_depths",
-                "cascade_w_3_depths",
-                "cascade_w_2_depths_desc",
-                "cascade_w_3_depths_desc",
-                "not_pair_relation_wildcard",
-                "not_pair_object_wildcard",
-                "two_pair_wildcards_one_not",
-                "two_pair_wildcards_one_not_any",
-                "implicit_existing_isa_superset",
-                "implicit_new_isa_superset",
-                "isa_superset",
-                "isa_superset_2_lvls",
-                "isa_superset_3_lvls",
-                "isa_superset_2_lvls_owned",
-                "isa_superset_3_lvls_owned",
-                "isa_superset_owned_empty_table_after_match",
-                "isa_self_superset",
-                "childof_superset",
-                "superset_2_targets",
-                "superset_2_relations",
-                "superset_2_relations_instanced",
-                "superset_2_relations_w_component",
-                "superset_2_relations_instanced_w_component",
-                "parent",
-                "existing_isa_cascade",
-                "new_isa_cascade",
-                "childof_cascade",
-                "isa_rematch",
-                "childof_rematch",
-                "isa_unmatch",
-                "childof_unmatch",
-                "isa_rematch_2_lvls",
-                "childof_rematch_2_lvls",
-                "cascade_rematch_2_lvls",
-                "cascade_rematch_2_lvls_2_relations",
-                "cascade_topological",
-                "cascade_desc_rematch_2_lvls",
-                "cascade_desc_rematch_2_lvls_2_relations",
-                "cascade_desc_topological",
-                "childof_rematch_from_isa",
-                "rematch_optional_ref",
-                "rematch_optional_ref_w_2_refs",
-                "rematch_optional_ref_tag_w_ref_component",
-                "match_query_expr_from_scope",
-                "query_long_or_w_ref",
-                "0_query",
-                "query_w_pair_id_and_subj",
-                "table_count",
-                "empty_table_count",
-                "entity_count",
-                "rematch_after_delete_inherited_tag",
-                "rematch_after_delete_rel_of_inherited_pair",
-                "rematch_after_delete_obj_of_inherited_pair",
-                "rematch_empty_table_w_superset",
-                "query_w_short_notation",
-                "query_w_invalid_filter_flag",
-                "query_next_table",
-                "query_next_table_w_changed",
-                "query_next_table_w_populate",
-                "query_next_table_w_skip",
-                "query_next_table_w_populate_first_changed",
-                "query_next_table_w_populate_last_changed",
-                "query_next_table_w_populate_skip_first",
-                "query_next_table_w_populate_skip_last",
-                "create_query_existing_query_entity",
-                "query_for_recycled_pair",
-                "query_w_singleton_w_rule_iter",
-                "query_w_singleton_nested_iter",
-                "query_w_singleton_interleaved_iter",
-                "recycled_component_id",
-                "set_get_context",
-                "set_get_binding_context",
-                "set_get_context_w_free",
-                "set_get_binding_context_w_free",
-                "set_this",
-                "set_this_no_match",
-                "set_this_is_true",
-                "set_this_w_wildcard",
-                "singleton_w_inout_none",
-                "singleton_w_inout_none_or",
-                "component_w_inout_none_or"
-            ]
-        }, {
-            "id": "Iter",
-            "testcases": [
-                "page_iter_0_0",
-                "page_iter_1_0",
-                "page_iter_0_1",
-                "page_iter_n_0",
-                "page_iter_0_n",
-                "page_iter_m_n",
-                "page_iter_skip_1_table",
-                "page_iter_skip_2_tables",
-                "worker_iter_1",
-                "worker_iter_2",
-                "worker_iter_3",
-                "worker_iter_4",
-                "paged_iter_w_shared_comp",
-                "worker_iter_w_shared_comp",
-                "paged_iter_w_task_query",
-                "worker_iter_w_task_query",
-                "worker_iter_w_singleton",
-                "worker_iter_w_singleton_component",
-                "worker_iter_w_singleton_instanced",
-                "worker_iter_w_singleton_component_instanced",
-                "paged_iter_w_singleton",
-                "paged_iter_w_singleton_component",
-                "paged_iter_w_singleton_instanced",
-                "paged_iter_w_singleton_component_instanced",
-                "count",
-                "iter_restore_stack_iter",
-                "interleaved_iter",
-                "get_first",
-                "page_iter_w_only_tag",
-                "worker_iter_w_only_tag",
-                "page_iter_w_inout_none",
-                "worker_iter_w_inout_none",
-                "page_iter_w_ctx",
-                "page_iter_w_binding_ctx",
-                "worker_iter_w_ctx",
-                "worker_iter_w_binding_ctx",
-                "column_index_owned",
-                "column_index_shared",
-                "column_index_not",
-                "page_iter_w_fini",
-                "worker_iter_w_fini",
-                "rule_page_iter_w_fini",
-                "rule_worker_iter_w_fini",
-                "to_str_before_next",
-                "to_str",
-                "filter_eval_count",
-                "query_eval_count",
-                "rule_eval_count"
-            ]
         }, {
             "id": "Pairs",
             "testcases": [
@@ -2042,8 +1233,7 @@
                "on_set_superset_after_filter_observer",
                "on_set_superset_after_filter_observer_w_on_add",
                "on_set_superset_after_filter_observer_w_on_add_isa_after_set",
-               "on_set_superset_after_filter_observer_w_on_add_2",
-               "propagate_w_union_pair"
+               "on_set_superset_after_filter_observer_w_on_add_2"
            ]
         }, {
             "id": "Observer",
@@ -2099,6 +1289,10 @@
                 "3_terms_2_filter",
                 "and_from",
                 "or_from",
+                "and_from_empty",
+                "or_from_empty",
+                "and_from_empty_w_tag",
+                "or_from_empty_w_tag",
                 "notify_propagated_twice",
                 "on_add_yield_existing",
                 "on_add_yield_existing_2_tables",
@@ -2185,6 +1379,7 @@
                 "multi_observer_eval_count",
                 "yield_existing_uni_no_this",
                 "yield_existing_multi_no_this",
+                "observer_no_id_in_scope",
                 "cache_test_1",
                 "cache_test_2",
                 "cache_test_3",
@@ -2291,7 +1486,6 @@
                 "on_set_after_override_w_new",
                 "on_set_after_override_w_new_w_count",
                 "on_set_after_override_1_of_2_overridden",
-                "on_set_after_snapshot_restore",
                 "on_set_after_remove_override",
                 "emplace",
                 "un_set_tag_w_remove",
@@ -2424,7 +1618,6 @@
                 "get_component_pair_from_base",
                 "get_component_pair_from_prefab_base",
                 "override_dont_inherit",
-                "prefab_w_switch",
                 "prefab_child_w_dont_inherit_component",
                 "prefab_child_override",
                 "prefab_child_override_w_exclusive_pair",
@@ -2440,7 +1633,6 @@
                 "slot_has_union",
                 "slot_override",
                 "base_slot_override",
-                "prefab_child_w_union",
                 "override_twice_w_add",
                 "override_twice_w_set",
                 "auto_override_copy_once",
@@ -2545,10 +1737,8 @@
                 "entity_instanceof_str",
                 "entity_childof_str",
                 "entity_pair_str",
-                "entity_and_str",
                 "entity_str_small_buffer",
                 "role_pair_str",
-                "role_and_str",
                 "role_owned_str",
                 "role_disabled_str",
                 "large_type_expr",
@@ -2609,9 +1799,7 @@
                 "async_stage_clear",
                 "async_stage_delete",
                 "async_stage_new",
-                "async_stage_no_get",
                 "async_stage_readonly",
-                "async_stage_is_async",
                 "register_component_while_in_progress",
                 "register_component_while_staged",
                 "register_component_while_deferred",
@@ -2629,10 +1817,6 @@
                 "defer_set_large_component",
                 "defer_while_suspend_readonly",
                 "defer_while_suspend_readonly_w_existing_commands",
-                "defer_add_union_relationship",
-                "defer_add_existing_union_relationship",
-                "defer_add_union_relationship_2_ops",
-                "defer_add_existing_union_relationship_2_ops",
                 "defer_remove_after_set",
                 "defer_remove_after_set_w_observer",
                 "defer_override_after_remove",
@@ -2689,7 +1873,9 @@
                 "add_path_to_deleted_parent_w_stage",
                 "add_path_nested_w_stage",
                 "add_path_nested_to_deleted_parent_w_stage",
-                "add_path_nested_to_created_deleted_parent_w_stage"
+                "add_path_nested_to_created_deleted_parent_w_stage",
+                "defer_emplace_w_arg",
+                "defer_emplace_existing_w_arg"
             ]
         }, {
             "id": "SingleThreadStaging",
@@ -2756,7 +1942,6 @@
                 "lock_table",
                 "recursive_lock_table",
                 "modify_after_lock",
-                "get_case_from_stage",
                 "get_object_from_stage",
                 "add_to_world_while_readonly",
                 "add_to_world_and_stage_while_readonly",
@@ -2804,23 +1989,9 @@
         }, {
             "id": "Poly",
             "testcases": [
-                "iter_query",
-                "iter_query_w_filter",
-                "iter_world",
-                "iter_world_w_filter",
-                "iter_rule",
-                "iter_rule_w_filter",
-                "iter_filter",
-                "iter_filter_w_filter",
                 "on_set_poly_observer",
                 "on_set_poly_query",
-                "on_set_poly_system",
-                "iter_filter_from_entity",
-                "iter_query_from_entity",
-                "iter_rule_from_entity",
-                "free_filter_entity",
-                "free_query_entity",
-                "free_rule_entity"
+                "on_set_poly_system"
             ]
         }, {
             "id": "Internals",
diff --git a/test/api/src/Add.c b/test/core/src/Add.c
similarity index 87%
rename from test/api/src/Add.c
rename to test/core/src/Add.c
index e4663d3f6..408710e91 100644
--- a/test/api/src/Add.c
+++ b/test/core/src/Add.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 #include <stdlib.h>
 
 void Add_zero(void) {
@@ -6,11 +6,11 @@ void Add_zero(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
-    ecs_add(world, e, 0);
+    ecs_add_id(world, e, 0);
 }
 
 void Add_component(void) {
@@ -18,7 +18,7 @@ void Add_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, Position);
@@ -32,7 +32,7 @@ void Add_component_again(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, Position);
@@ -50,7 +50,7 @@ void Add_2_components(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, Position);
@@ -70,7 +70,7 @@ void Add_2_components_again(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, Position);
@@ -93,7 +93,7 @@ void Add_2_components_overlap(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, Position);
@@ -117,7 +117,7 @@ void Add_component_to_nonempty(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_has(world, e, Position));
 
@@ -133,7 +133,7 @@ void Add_component_to_nonempty_again(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_has(world, e, Position));
 
@@ -167,7 +167,7 @@ void Add_tag(void) {
 
     ECS_ENTITY(world, Tag, 0);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add_id(world, e, Tag);
@@ -179,10 +179,10 @@ void Add_tag(void) {
 void Add_add_entity(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
-    ecs_entity_t f = ecs_new(world, 0);
+    ecs_entity_t f = ecs_new(world);
     test_assert(f != 0);
 
     ecs_add_id(world, e, f);
@@ -194,10 +194,10 @@ void Add_add_entity(void) {
 void Add_remove_entity(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
-    ecs_entity_t f = ecs_new(world, 0);
+    ecs_entity_t f = ecs_new(world);
     test_assert(f != 0);
 
     ecs_add_id(world, e, f);
@@ -214,7 +214,7 @@ void Add_add_0_entity(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -229,7 +229,7 @@ void Add_remove_0_entity(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -242,7 +242,7 @@ void Add_invalid_add_wildcard(void) {
     
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -255,7 +255,7 @@ void Add_invalid_add_pair_w_wildcard(void) {
     
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -270,7 +270,7 @@ void Add_invalid_add_pair_w_wildcard_rel(void) {
     
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -285,7 +285,7 @@ void Add_invalid_add_pair_w_wildcard_obj(void) {
     
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -300,7 +300,7 @@ void Add_invalid_add_any(void) {
     
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -315,7 +315,7 @@ void Add_invalid_add_pair_w_any(void) {
     
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -330,7 +330,7 @@ void Add_invalid_add_pair_w_any_rel(void) {
     
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -345,7 +345,7 @@ void Add_invalid_add_pair_w_any_obj(void) {
     
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -360,7 +360,7 @@ void Add_invalid_pair_w_0(void) {
     
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -375,7 +375,7 @@ void Add_invalid_pair_w_0_rel(void) {
     
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -390,7 +390,7 @@ void Add_invalid_pair_w_0_obj(void) {
     
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
diff --git a/test/api/src/Clone.c b/test/core/src/Clone.c
similarity index 96%
rename from test/api/src/Clone.c
rename to test/core/src/Clone.c
index 5c2156fe0..755d974f9 100644
--- a/test/api/src/Clone.c
+++ b/test/core/src/Clone.c
@@ -1,9 +1,9 @@
-#include <api.h>
+#include <core.h>
 
 void Clone_empty(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_clone(world, 0, e1, false);
@@ -19,7 +19,7 @@ void Clone_empty(void) {
 void Clone_empty_w_value(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_clone(world, 0, e1, true);
@@ -54,7 +54,7 @@ void Clone_1_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_clone(world, 0, e1, false);
@@ -132,7 +132,7 @@ void Clone_1_component_w_value(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
     ecs_set(world, e1, Position, {10, 20});
@@ -164,7 +164,7 @@ void Clone_2_component_w_value(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
     ecs_set(world, e1, Position, {10, 20});
@@ -211,7 +211,7 @@ void Clone_3_component_w_value(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
     ecs_set(world, e1, Position, {10, 20});
@@ -327,7 +327,7 @@ void Clone_1_tag_1_component_w_value(void) {
     ECS_ENTITY(world, Tag, 0);
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add(world, e1, Tag);
     ecs_set(world, e1, Position, {10, 20});
 
@@ -355,7 +355,7 @@ void Clone_clone_w_name(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t t = ecs_new_entity(world, "template");
+    ecs_entity_t t = ecs_entity(world, { .name = "template" });
     ecs_set(world, t, Position, {10, 20});
     ecs_set(world, t, Velocity, {1, 2});
 
diff --git a/test/api/src/Commands.c b/test/core/src/Commands.c
similarity index 87%
rename from test/api/src/Commands.c
rename to test/core/src/Commands.c
index 46d960f42..4acdd6428 100644
--- a/test/api/src/Commands.c
+++ b/test/core/src/Commands.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Commands_defer_new(void) {
     ecs_world_t *world = ecs_mini();
@@ -11,7 +11,7 @@ void Commands_defer_new(void) {
 
     ecs_defer_begin(world);
     
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_assert(!ecs_has(world, e, Position));
@@ -76,7 +76,7 @@ void Commands_defer_add(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_frame_begin(world, 1);
 
@@ -109,7 +109,7 @@ void Commands_defer_add_two(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_frame_begin(world, 1);
 
@@ -146,7 +146,7 @@ void Commands_defer_remove(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_frame_begin(world, 1);
 
@@ -179,7 +179,7 @@ void Commands_defer_remove_two(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Position);
     ecs_add(world, e, Velocity);
 
@@ -218,7 +218,7 @@ void Commands_defer_set(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_set(world, e, Position, {1, 2});
 
     const Position *p = ecs_get(world, e, Position);
@@ -273,7 +273,7 @@ void Commands_defer_delete(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_frame_begin(world, 1);
 
@@ -306,7 +306,7 @@ void Commands_defer_twice(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_defer_begin(world);
     ecs_defer_begin(world);
@@ -332,7 +332,7 @@ void Commands_defer_twice_in_progress(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_frame_begin(world, 0);
     ecs_readonly_begin(world, false);
@@ -363,7 +363,7 @@ void Commands_defer_twice_in_progress(void) {
 
 static
 void AddVelocity(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     ecs_defer_begin(it->world);
 
@@ -383,7 +383,7 @@ void Commands_run_w_defer(void) {
 
     ECS_SYSTEM(world, AddVelocity, 0, Position, [in] Velocity());
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_run(world, AddVelocity, 0, NULL);
 
@@ -400,7 +400,7 @@ void Commands_system_in_progress_w_defer(void) {
 
     ECS_SYSTEM(world, AddVelocity, EcsOnUpdate, Position, [in] Velocity());
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_progress(world, 0);
 
@@ -424,7 +424,7 @@ void Commands_defer_ensure_no_modify(void) {
 
     ECS_OBSERVER(world, OnSetTestInvoked, EcsOnSet, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_defer_begin(world);
 
@@ -454,7 +454,7 @@ void Commands_defer_ensure_w_modify(void) {
 
     ECS_OBSERVER(world, OnSetTestInvoked, EcsOnSet, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_defer_begin(world);
 
@@ -486,7 +486,7 @@ void Commands_defer_modify(void) {
 
     ECS_OBSERVER(world, OnSetTestInvoked, EcsOnSet, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Velocity);
 
     ecs_defer_begin(world);
 
@@ -507,7 +507,7 @@ void Commands_defer_set_pair(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
 
@@ -525,7 +525,7 @@ void Commands_defer_clear(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_frame_begin(world, 1);
 
@@ -558,7 +558,7 @@ void Commands_defer_add_after_delete(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_frame_begin(world, 1);
 
@@ -591,7 +591,7 @@ void Commands_defer_set_after_delete(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_frame_begin(world, 1);
 
@@ -624,7 +624,7 @@ void Commands_defer_ensure_after_delete(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_frame_begin(world, 1);
 
@@ -659,11 +659,11 @@ void Commands_defer_ensure_after_delete_2nd_to_last(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     /* Create 2nd position. This will cause deletion of the entity in the sparse
      * set to take a different path since it's not the last. */
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_frame_begin(world, 1);
 
@@ -698,7 +698,7 @@ void Commands_defer_add_child_to_deleted_parent(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
 
     ecs_frame_begin(world, 1);
 
@@ -723,7 +723,7 @@ void Commands_recreate_deleted_entity_while_deferred(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e_old = ecs_new(world, 0);
+    ecs_entity_t e_old = ecs_new(world);
     test_assert(e_old != 0);
 
     ecs_delete(world, e_old);
@@ -735,7 +735,7 @@ void Commands_recreate_deleted_entity_while_deferred(void) {
 
     ecs_defer_begin(world);
     
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(e != e_old);
     test_assert((e & ECS_ENTITY_MASK) == (e_old & ECS_ENTITY_MASK));
@@ -763,12 +763,12 @@ void Commands_defer_add_to_recycled_id(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
 
     ecs_delete(world, id);
 
-    ecs_entity_t id_2 = ecs_new_id(world);
+    ecs_entity_t id_2 = ecs_new(world);
     test_assert(id != id_2);
     test_assert((int32_t)id == (int32_t)id_2);
     
@@ -797,12 +797,12 @@ void Commands_defer_add_to_recycled_id_w_role(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
 
     ecs_delete(world, id);
 
-    ecs_entity_t id_2 = ecs_new_id(world);
+    ecs_entity_t id_2 = ecs_new(world);
     test_assert(id != id_2);
     test_assert((int32_t)id == (int32_t)id_2);
     
@@ -831,15 +831,15 @@ void Commands_defer_add_to_recycled_relation(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t target = ecs_new_id(world);
+    ecs_entity_t target = ecs_new(world);
     test_assert(target != 0);
 
-    ecs_entity_t rel = ecs_new_id(world);
+    ecs_entity_t rel = ecs_new(world);
     test_assert(rel != 0);
 
     ecs_delete(world, rel);
 
-    ecs_entity_t rel_2 = ecs_new_id(world);
+    ecs_entity_t rel_2 = ecs_new(world);
     test_assert(rel != rel_2);
     test_assert((int32_t)rel == (int32_t)rel_2);
     
@@ -870,12 +870,12 @@ void Commands_defer_add_to_recycled_object(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t target = ecs_new(world, 0);
+    ecs_entity_t target = ecs_new(world);
     test_assert(target != 0);
 
     ecs_delete(world, target);
 
-    ecs_entity_t object_2 = ecs_new_id(world);
+    ecs_entity_t object_2 = ecs_new(world);
     test_assert(target != object_2);
     test_assert((int32_t)target == (int32_t)object_2);
     
@@ -904,12 +904,12 @@ void Commands_defer_add_to_recycled_object_childof(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
 
     ecs_delete(world, parent);
 
-    ecs_entity_t parent_2 = ecs_new_id(world);
+    ecs_entity_t parent_2 = ecs_new(world);
     test_assert(parent != parent_2);
     test_assert((int32_t)parent == (int32_t)parent_2);
     
@@ -938,7 +938,7 @@ void Commands_defer_add_to_deleted_id(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
     
     ecs_frame_begin(world, 1);
@@ -964,7 +964,7 @@ void Commands_defer_add_to_deleted_id_w_role(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
     
     ecs_frame_begin(world, 1);
@@ -992,10 +992,10 @@ void Commands_defer_add_to_deleted_relation(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t target = ecs_new_id(world);
+    ecs_entity_t target = ecs_new(world);
     test_assert(target != 0);
 
-    ecs_entity_t rel = ecs_new_id(world);
+    ecs_entity_t rel = ecs_new(world);
     test_assert(rel != 0);
 
     ecs_frame_begin(world, 1);
@@ -1026,7 +1026,7 @@ void Commands_defer_add_to_deleted_object(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_entity_t target = ecs_new(world, 0);
+    ecs_entity_t target = ecs_new(world);
 
     ecs_frame_begin(world, 1);
 
@@ -1053,7 +1053,7 @@ void Commands_defer_add_to_deleted_object_childof(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
 
     ecs_frame_begin(world, 1);
 
@@ -1079,7 +1079,7 @@ void Commands_defer_delete_added_id(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
     
     ecs_frame_begin(world, 1);
@@ -1107,7 +1107,7 @@ void Commands_defer_delete_added_id_w_role(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
     
     ecs_frame_begin(world, 1);
@@ -1135,10 +1135,10 @@ void Commands_defer_delete_added_relation(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t target = ecs_new_id(world);
+    ecs_entity_t target = ecs_new(world);
     test_assert(target != 0);
 
-    ecs_entity_t rel = ecs_new_id(world);
+    ecs_entity_t rel = ecs_new(world);
     test_assert(rel != 0);
 
     ecs_frame_begin(world, 1);
@@ -1149,7 +1149,7 @@ void Commands_defer_delete_added_relation(void) {
     ecs_add(world, child, Velocity);
     ecs_delete(world, rel);
 
-    ecs_defer_end(world);  
+    ecs_defer_end(world);
 
     ecs_frame_end(world);    
 
@@ -1169,7 +1169,7 @@ void Commands_defer_delete_added_object(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_entity_t target = ecs_new(world, 0);
+    ecs_entity_t target = ecs_new(world);
 
     ecs_frame_begin(world, 1);
 
@@ -1196,7 +1196,7 @@ void Commands_defer_delete_added_object_childof(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
 
     ecs_frame_begin(world, 1);
 
@@ -1221,7 +1221,7 @@ void Commands_discard_add(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_frame_begin(world, 1);
 
@@ -1258,7 +1258,7 @@ void Commands_discard_remove(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_frame_begin(world, 1);
 
@@ -1296,7 +1296,7 @@ void Commands_discard_add_two(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_frame_begin(world, 1);
 
@@ -1337,7 +1337,7 @@ void Commands_discard_remove_two(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Position);
     ecs_add(world, e, Velocity);
 
@@ -1385,7 +1385,7 @@ void Commands_discard_child(void) {
 
     ecs_defer_begin(world);
     
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_assert(!ecs_has(world, e, Position));
     ecs_delete(world, e);
@@ -1426,13 +1426,13 @@ void Commands_discard_child_w_add(void) {
 
     ecs_defer_begin(world);
     
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_assert(!ecs_has(world, e, Position));
     ecs_delete(world, e);
     test_assert(ecs_is_alive(world, e));    
 
-    ecs_entity_t child = ecs_new(world, 0);
+    ecs_entity_t child = ecs_new(world);
     test_assert(child != 0);
 
     ecs_add_pair(world, child, EcsChildOf, e);
@@ -1476,7 +1476,7 @@ void Commands_defer_ensure_pair(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Pair);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
 
@@ -1500,15 +1500,15 @@ void Commands_async_stage_add(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
     ecs_add(async, e, Position);
     test_assert(!ecs_has(world, e, Position));
     ecs_merge(async);
     test_assert(ecs_has(world, e, Position));
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
@@ -1519,9 +1519,9 @@ void Commands_async_stage_add_twice(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
     ecs_add(async, e, Position);
     test_assert(!ecs_has(world, e, Position));
     ecs_merge(async);
@@ -1532,7 +1532,7 @@ void Commands_async_stage_add_twice(void) {
     ecs_merge(async);
     test_assert(ecs_has(world, e, Velocity));
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
@@ -1543,15 +1543,15 @@ void Commands_async_stage_remove(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
     ecs_remove(async, e, Position);
     test_assert(ecs_has(world, e, Position));
     ecs_merge(async);
     test_assert(!ecs_has(world, e, Position));
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
@@ -1562,10 +1562,10 @@ void Commands_async_stage_clear(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
     ecs_clear(async, e);
     test_assert(ecs_has(world, e, Position));
     test_assert(ecs_has(world, e, Velocity));
@@ -1573,7 +1573,7 @@ void Commands_async_stage_clear(void) {
     test_assert(!ecs_has(world, e, Position));
     test_assert(!ecs_has(world, e, Velocity));
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
@@ -1584,10 +1584,10 @@ void Commands_async_stage_delete(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
     ecs_delete(async, e);
     test_assert(ecs_has(world, e, Position));
     test_assert(ecs_has(world, e, Velocity));
@@ -1595,7 +1595,7 @@ void Commands_async_stage_delete(void) {
     ecs_merge(async);
     test_assert(!ecs_is_alive(world, e));
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
@@ -1606,8 +1606,8 @@ void Commands_async_stage_new(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
-    ecs_entity_t e = ecs_new(async, 0);
+    ecs_world_t *async = ecs_stage_new(world);
+    ecs_entity_t e = ecs_new(async);
     ecs_add(async, e, Position);
     ecs_add(async, e, Velocity);
     test_assert(!ecs_has(world, e, Position));
@@ -1617,43 +1617,18 @@ void Commands_async_stage_new(void) {
     test_assert(ecs_has(world, e, Velocity)); 
     test_assert(ecs_is_alive(world, e));
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
 
-void Commands_async_stage_no_get(void) {
-    install_test_abort();
-
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t e = ecs_new(world, Position);
-
-    ecs_world_t *async = ecs_async_stage_new(world);
-    
-    test_expect_abort();
-    ecs_get(async, e, Position);
-}
-
 void Commands_async_stage_readonly(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
     test_assert(!ecs_stage_is_readonly(async));
 
-    ecs_async_stage_free(async);
-    ecs_fini(world);
-}
-
-void Commands_async_stage_is_async(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_world_t *async = ecs_async_stage_new(world);
-    test_assert(ecs_stage_is_async(async));
-
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
     ecs_fini(world);
 }
 
@@ -1680,7 +1655,7 @@ void Commands_register_component_while_in_progress(void) {
     test_assert(ecs_id(Position) != 0);
     test_assert(ecs_has(world, ecs_id(Position), EcsComponent));
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {10, 20});
     test_assert(ecs_has_id(world, e, ecs_id(Position)));
 
@@ -1697,8 +1672,8 @@ void Commands_register_component_while_staged(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t canary = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t canary = ecs_new(world);
 
     ecs_readonly_begin(world, false);
 
@@ -1736,8 +1711,8 @@ void Commands_register_component_while_deferred(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t canary = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t canary = ecs_new(world);
 
     ecs_defer_begin(world);
 
@@ -1764,7 +1739,7 @@ void Commands_register_component_while_deferred(void) {
 void Commands_defer_enable(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_enable(world, e, false);
@@ -1797,9 +1772,9 @@ void Commands_defer_delete_with(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
     ecs_add(world, e_1, TagB);
 
     ecs_defer_begin(world);
@@ -1822,9 +1797,9 @@ void Commands_defer_remove_all(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e_1 = ecs_new(world, TagA);
-    ecs_entity_t e_2 = ecs_new(world, TagA);
-    ecs_entity_t e_3 = ecs_new(world, TagA);
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
     ecs_add(world, e_1, TagB);
 
     ecs_defer_begin(world);
@@ -1852,12 +1827,12 @@ void Commands_deferred_modified_after_remove(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = { EcsOnSet },
         .callback = OnSetTestInvoked
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_modified(world, e, Position);
 
@@ -1908,7 +1883,7 @@ static void update_counter(ecs_iter_t *it) {
 }
 
 static void remove_counter(ecs_iter_t *it) {
-    Counter *ptr = ecs_field(it, Counter, 1);
+    Counter *ptr = ecs_field(it, Counter, 0);
 
     for (int i = 0; i < it->count; i ++) {
         test_int(ptr[i].value, 0);
@@ -1923,21 +1898,21 @@ void Commands_merge_cleanup_ops_before_delete(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = update_counter
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = ecs_id(Counter),
-            .src.flags = EcsSelf
+            .src.id = EcsSelf
         },
         .events = {EcsOnRemove},
         .callback = remove_counter
     });
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_set(world, parent, Counter, {0});
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -1964,24 +1939,24 @@ void Commands_merge_nested_cleanup_ops_before_delete(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = Tag,
-            .src.flags = EcsSelf
+            .src.id = EcsSelf
         },
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = update_counter
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = ecs_id(Counter),
-            .src.flags = EcsSelf
+            .src.id = EcsSelf
         },
         .events = {EcsOnRemove},
         .callback = remove_counter
     });
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_set(world, parent, Counter, {0});
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -2015,7 +1990,7 @@ void Commands_defer_suspend_resume(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     
     ecs_defer_begin(world);
     ecs_add(world, e, TagA);
@@ -2059,7 +2034,7 @@ void Commands_create_observer_while_deferred(void) {
     ecs_defer_begin(world);
     Probe ctx = {0};
     ecs_entity_t observer = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ .id = TagA }},
+        .query.terms = {{ .id = TagA }},
         .events = {EcsOnAdd},
         .callback = System,
         .ctx = &ctx
@@ -2068,7 +2043,7 @@ void Commands_create_observer_while_deferred(void) {
     test_assert(observer != 0);
     test_int(ctx.invoked, 0);
 
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
     test_int(ctx.invoked, 1);
 
     ecs_fini(world);
@@ -2080,13 +2055,13 @@ void Commands_create_query_while_deferred(void) {
     ECS_TAG(world, TagA);
 
     ecs_defer_begin(world);
-    ecs_query_t *query = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ .id = TagA }}
+    ecs_query_t *query = ecs_query(world, {
+        .terms = {{ .id = TagA }}
     });
     ecs_defer_end(world);
     test_assert(query != 0);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
 
     ecs_iter_t it = ecs_query_iter(world, query);
     test_bool(true, ecs_query_next(&it));
@@ -2094,6 +2069,8 @@ void Commands_create_query_while_deferred(void) {
     test_uint(e, it.entities[0]);
     test_bool(false, ecs_query_next(&it));
 
+    ecs_query_fini(query);
+
     ecs_fini(world);
 }
 
@@ -2105,7 +2082,7 @@ void Commands_update_observer_while_deferred(void) {
     ecs_defer_begin(world);
     Probe ctx = {0};
     ecs_entity_t observer = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ .id = TagA }},
+        .query.terms = {{ .id = TagA }},
         .events = {EcsOnAdd},
         .callback = System,
         .ctx = &ctx
@@ -2114,7 +2091,7 @@ void Commands_update_observer_while_deferred(void) {
     test_assert(observer != 0);
     test_int(ctx.invoked, 0);
 
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
     test_int(ctx.invoked, 1);
 
     test_int(system_2_invoked, 0);
@@ -2126,7 +2103,7 @@ void Commands_update_observer_while_deferred(void) {
     });
     ecs_defer_end(world);
 
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
     test_int(ctx.invoked, 2);
     test_int(system_2_invoked, 1);
 
@@ -2142,7 +2119,7 @@ void Commands_defer_set_large_component(void) {
 
     ECS_COMPONENT(world, LargeComponent);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     LargeComponent *ptr = ecs_ensure(world, e, LargeComponent);
@@ -2165,7 +2142,7 @@ void Commands_defer_set_large_component(void) {
 static ECS_COMPONENT_DECLARE(Position);
 
 static void CreatePosition(ecs_iter_t *it) {
-    ecs_entity_t e = ecs_new_id(it->world);
+    ecs_entity_t e = ecs_new(it->world);
     ecs_set(it->world, e, Position, {999, 1000});
 }
 
@@ -2177,7 +2154,7 @@ void Commands_defer_while_suspend_readonly(void) {
     /* Create observer on EcsComponent which will defer a command while readonly
      * mode is suspended */
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(EcsComponent),
+        .query.terms[0].id = ecs_id(EcsComponent),
         .events = { EcsOnAdd },
         .callback = CreatePosition
     });
@@ -2190,9 +2167,9 @@ void Commands_defer_while_suspend_readonly(void) {
      * after they have been registered */
     ECS_COMPONENT(s, Velocity);
 
-    ecs_entity_t e = 
-    ecs_set(s, 0, Position, {10, 20});
-    ecs_set(s, e, Velocity, {1, 2});
+    ecs_entity_t e = ecs_insert(world, 
+        ecs_value(Position, {10, 20}),
+        ecs_value(Velocity, {1, 2}));
     test_assert(!ecs_has(s, e, Position));
     test_assert(!ecs_has(s, e, Velocity));
 
@@ -2224,7 +2201,7 @@ void Commands_defer_while_suspend_readonly_w_existing_commands(void) {
     /* Create observer on EcsComponent which will defer a command while readonly
      * mode is suspended */
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(EcsComponent),
+        .query.terms[0].id = ecs_id(EcsComponent),
         .events = { EcsOnAdd },
         .callback = CreatePosition
     });
@@ -2233,16 +2210,16 @@ void Commands_defer_while_suspend_readonly_w_existing_commands(void) {
 
     ecs_readonly_begin(world, false);
 
-    ecs_entity_t e1 = ecs_set(s, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(s, ecs_value(Position, {10, 20}));
     test_assert(!ecs_has(s, e1, Position));
 
     /* Component creation suspends readonly mode so that they can be used right
      * after they have been registered */
     ECS_COMPONENT(s, Velocity);
 
-    ecs_entity_t e2 = 
-    ecs_set(s, 0, Position, {20, 30});
-    ecs_set(s, e2, Velocity, {1, 2});
+    ecs_entity_t e2 = ecs_insert(world,
+        ecs_value(Position, {20, 30}),
+        ecs_value(Velocity, {1, 2}));
     test_assert(!ecs_has(s, e2, Position));
     test_assert(!ecs_has(s, e2, Velocity));
 
@@ -2272,96 +2249,12 @@ void Commands_defer_while_suspend_readonly_w_existing_commands(void) {
     ecs_fini(world);
 }
 
-void Commands_defer_add_union_relationship(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Rel, Union);
-    ECS_TAG(world, Tgt);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_defer_begin(world);
-    ecs_add_pair(world, e, Rel, Tgt);
-    test_assert(!ecs_has_pair(world, e, Rel, Tgt));
-    ecs_defer_end(world);
-    test_assert(ecs_has_pair(world, e, Rel, Tgt));
-
-    ecs_fini(world);
-}
-
-void Commands_defer_add_existing_union_relationship(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Rel, Union);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Rel, TgtA);
-    test_assert(ecs_has_pair(world, e, Rel, TgtA));
-
-    ecs_defer_begin(world);
-    ecs_add_pair(world, e, Rel, TgtB);
-    test_assert(ecs_has_pair(world, e, Rel, TgtA));
-    test_assert(!ecs_has_pair(world, e, Rel, TgtB));
-    ecs_defer_end(world);
-    test_assert(!ecs_has_pair(world, e, Rel, TgtA));
-    test_assert(ecs_has_pair(world, e, Rel, TgtB));
-
-    ecs_fini(world);
-}
-
-void Commands_defer_add_union_relationship_2_ops(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Rel, Union);
-    ECS_TAG(world, Tgt);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_defer_begin(world);
-    ecs_add_pair(world, e, Rel, Tgt);
-    ecs_add(world, e, Tag);
-    test_assert(!ecs_has_pair(world, e, Rel, Tgt));
-    test_assert(!ecs_has(world, e, Tag));
-    ecs_defer_end(world);
-    test_assert(ecs_has_pair(world, e, Rel, Tgt));
-    test_assert(ecs_has(world, e, Tag));
-
-    ecs_fini(world);
-}
-
-void Commands_defer_add_existing_union_relationship_2_ops(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Rel, Union);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, Rel, TgtA);
-    test_assert(ecs_has_pair(world, e, Rel, TgtA));
-
-    ecs_defer_begin(world);
-    ecs_add_pair(world, e, Rel, TgtB);
-    ecs_add(world, e, Tag);
-    test_assert(ecs_has_pair(world, e, Rel, TgtA));
-    test_assert(!ecs_has_pair(world, e, Rel, TgtB));
-    test_assert(!ecs_has(world, e, Tag));
-    ecs_defer_end(world);
-    test_assert(!ecs_has_pair(world, e, Rel, TgtA));
-    test_assert(ecs_has_pair(world, e, Rel, TgtB));
-    test_assert(ecs_has(world, e, Tag));
-
-    ecs_fini(world);
-}
-
 void Commands_defer_remove_after_set(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_set(world, e, Position, {10, 20});
@@ -2388,7 +2281,7 @@ void Commands_defer_remove_after_set_w_observer(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, PositionObserver, EcsOnSet, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_set(world, e, Position, {10, 20});
@@ -2408,7 +2301,7 @@ void Commands_defer_override_after_remove(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
     ecs_set(world, inst, Position, {20, 30});
 
@@ -2433,7 +2326,7 @@ void Commands_defer_override_after_remove_3_ops(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
     ecs_set(world, inst, Position, {20, 30});
 
@@ -2457,9 +2350,9 @@ void Commands_flush_stage_to_deferred_world(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
     ecs_add(async, e, Tag);
     test_assert(!ecs_has(world, e, Tag));
 
@@ -2469,7 +2362,7 @@ void Commands_flush_stage_to_deferred_world(void) {
     ecs_defer_end(world);
     test_assert(ecs_has(world, e, Tag));
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
@@ -2488,7 +2381,7 @@ void Commands_add_in_observer_during_merge(void) {
 
     ECS_OBSERVER(world, AddPosition, EcsOnAdd, TagA);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_add(world, e, TagA);
@@ -2516,7 +2409,7 @@ void Commands_add_in_observer_during_merge_2_commands(void) {
 
     ECS_OBSERVER(world, AddPosition, EcsOnAdd, TagB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_log_set_level(0);
 
@@ -2561,7 +2454,7 @@ void Commands_add_2_in_observer_while_on_remove_for_delete(void) {
 
     ECS_OBSERVER(world, AddTwoTags, EcsOnRemove, TagA);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     ecs_delete(world, e);
 
     test_assert(!ecs_is_alive(world, e));
@@ -2578,8 +2471,8 @@ void Commands_add_2_in_observer_while_on_remove_for_delete_child(void) {
 
     ECS_OBSERVER(world, AddTwoTags, EcsOnRemove, TagA);
 
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     ecs_add_pair(world, e, EcsChildOf, parent);
     ecs_delete(world, e);
 
@@ -2597,9 +2490,9 @@ void Commands_add_2_in_observer_while_on_remove_for_delete_recycled_id(void) {
 
     ECS_OBSERVER(world, AddTwoTags, EcsOnRemove, TagA);
 
-    ecs_delete(world, ecs_new_id(world));
+    ecs_delete(world, ecs_new(world));
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     ecs_delete(world, e);
 
     test_assert(!ecs_is_alive(world, e));
@@ -2616,9 +2509,9 @@ void Commands_add_2_in_observer_while_on_remove_for_deferred_delete_recycled_id(
 
     ECS_OBSERVER(world, AddTwoTags, EcsOnRemove, TagA);
 
-    ecs_delete(world, ecs_new_id(world));
+    ecs_delete(world, ecs_new(world));
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     ecs_defer_begin(world);
     ecs_delete(world, e);
     ecs_defer_end(world);
@@ -2634,7 +2527,7 @@ void Commands_defer_add_after_clear(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_clear(world, e);
@@ -2651,8 +2544,8 @@ void Commands_defer_cmd_after_modified(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
     
     ecs_defer_begin(world);
     ecs_set(world, e1, Position, {10, 20});
@@ -2684,11 +2577,11 @@ void Commands_defer_remove_after_emplace_different_id(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Tag);
 
     ecs_defer_begin(world);
-    Position *p = ecs_emplace(world, e, Position);
+    Position *p = ecs_emplace(world, e, Position, NULL);
     p->x = 10;
     p->y = 20;
     ecs_remove(world, e, Tag);
@@ -2714,11 +2607,11 @@ void Commands_defer_remove_after_set_and_emplace_different_id(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Tag);
 
     ecs_defer_begin(world);
-    Position *p = ecs_emplace(world, e, Position);
+    Position *p = ecs_emplace(world, e, Position, NULL);
     p->x = 10;
     p->y = 20;
     ecs_set(world, e, Velocity, {1, 2});
@@ -2751,7 +2644,7 @@ void Commands_clear_after_add_to_nonempty(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
 
     ecs_defer_begin(world);
     ecs_add(world, e, TagB);
@@ -2773,7 +2666,7 @@ void Commands_remove_after_add_to_nonempty(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
 
     ecs_defer_begin(world);
     ecs_add(world, e, TagB);
@@ -2811,8 +2704,8 @@ void PositionVelocityObserver(ecs_iter_t *it) {
     position_velocity_observer_invoked ++;
     test_int(it->count, 1);
     
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     test_assert(p != NULL);
     test_assert(v != NULL);
@@ -2831,12 +2724,12 @@ void Commands_defer_2_sets_w_multi_observer(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_id(Position) }, { ecs_id(Velocity) }},
+        .query.terms = {{ ecs_id(Position) }, { ecs_id(Velocity) }},
         .callback = PositionVelocityObserver,
         .events = { EcsOnSet }
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_set(world, e, Position, {10, 20});
@@ -2862,12 +2755,12 @@ void Commands_defer_2_ensures_w_multi_observer(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_id(Position) }, { ecs_id(Velocity) }},
+        .query.terms = {{ ecs_id(Position) }, { ecs_id(Velocity) }},
         .callback = PositionVelocityObserver,
         .events = { EcsOnSet }
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     {
@@ -2901,12 +2794,12 @@ void Commands_defer_2_ensures_no_modified_w_multi_observer(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_id(Position) }, { ecs_id(Velocity) }},
+        .query.terms = {{ ecs_id(Position) }, { ecs_id(Velocity) }},
         .callback = PositionVelocityObserver,
         .events = { EcsOnSet }
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     {
@@ -2936,7 +2829,7 @@ void Commands_exists_remove_set(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {1, 2});
 
     ecs_defer_begin(world);
@@ -2957,7 +2850,7 @@ void Commands_absent_remove_set(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_remove(world, e, Position);
@@ -2977,7 +2870,7 @@ void Commands_exists_set_remove(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {1, 2});
 
     ecs_defer_begin(world);
@@ -2996,7 +2889,7 @@ void Commands_absent_set_remove(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_set(world, e, Position, {5, 6});
@@ -3014,7 +2907,7 @@ void Commands_exists_set_w_ensure(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {1, 2});
 
     ecs_defer_begin(world);
@@ -3038,7 +2931,7 @@ void Commands_exists_remove_ensure(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {1, 2});
 
     ecs_defer_begin(world);
@@ -3064,7 +2957,7 @@ void Commands_absent_remove_ensure(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_remove(world, e, Position);
@@ -3090,7 +2983,7 @@ void Commands_exists_ensure_remove(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {1, 2});
 
     ecs_defer_begin(world);
@@ -3114,7 +3007,7 @@ void Commands_absent_ensure_remove(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     {
@@ -3140,7 +3033,7 @@ void Commands_absent_set_invoke_on_set(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, OnSetTestInvoked, EcsOnSet, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     /* create the component */
     ecs_defer_begin(world);
@@ -3164,7 +3057,7 @@ void Commands_exists_set_invoke_on_set(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, OnSetTestInvoked, EcsOnSet, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {1, 2});
     on_set_invoked = 0;
 
@@ -3191,7 +3084,7 @@ void Commands_defer_ensure_no_on_set(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, OnSetTestInvoked, EcsOnSet, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     /* create the component */
     ecs_defer_begin(world);
@@ -3219,7 +3112,7 @@ void Commands_defer_existing_ensure_no_on_set(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, OnSetTestInvoked, EcsOnSet, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     /* create the component */
     ecs_defer_begin(world);
@@ -3245,7 +3138,7 @@ void Commands_ensure_override(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {1, 2});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {1, 2}));
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
 
     ecs_defer_begin(world);
@@ -3281,7 +3174,7 @@ void Commands_set_override(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {1, 2});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {1, 2}));
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
 
     ecs_defer_begin(world);
@@ -3313,7 +3206,7 @@ void Commands_absent_ensure_for_entity_w_tag(void) {
     ECS_TAG(world, Tag);
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
     test_assert(e != 0);
     
     ecs_defer_begin(world);
@@ -3364,12 +3257,12 @@ void Commands_on_set_hook_before_on_add_for_existing_component(void) {
     });
 
     ecs_observer(world, {
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = { EcsOnAdd },
         .callback = add_tag
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_defer_begin(world);
     ecs_add(world, e, TagB); /* 2 add commands, to trigger batching */
@@ -3392,12 +3285,12 @@ void Commands_defer_2_sets_w_observer_same_component(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_observer(world, {
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = { EcsOnSet },
         .callback = set_position_hook
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_defer_begin(world);
     ecs_set(world, e, Position, {10, 20});
@@ -3421,18 +3314,18 @@ void Commands_defer_2_sets_w_observer_other_component(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_observer(world, {
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = { EcsOnSet },
         .callback = set_position_hook
     });
 
     ecs_observer(world, {
-        .filter.terms[0].id = ecs_id(Velocity),
+        .query.terms[0].id = ecs_id(Velocity),
         .events = { EcsOnSet },
         .callback = set_velocity_hook
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_defer_begin(world);
     ecs_set(world, e, Position, {10, 20});
@@ -3468,12 +3361,12 @@ void Commands_on_remove_after_deferred_clear_and_add(void) {
     ECS_TAG(world, TagC);
 
     ecs_observer(world, {
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = { EcsOnRemove },
         .callback = remove_tag
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
 
@@ -3492,8 +3385,8 @@ void Commands_on_remove_after_deferred_clear_and_add(void) {
 }
 
 static void Recycle(ecs_iter_t *it) {
-    ecs_new_id(it->world);
-    *(ecs_entity_t*)it->ctx = ecs_new_id(it->world);
+    ecs_new(it->world);
+    *(ecs_entity_t*)it->ctx = ecs_new(it->world);
 }
 
 void Commands_defer_delete_recycle_same_id(void) {
@@ -3502,12 +3395,12 @@ void Commands_defer_delete_recycle_same_id(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, parent);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Foo) }
         },
         .events = { EcsOnAdd },
@@ -3546,7 +3439,7 @@ void Commands_observer_while_defer_suspended(void) {
     ECS_COMPONENT_DEFINE(world, Velocity);
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) }
         },
         .events = { EcsOnAdd },
@@ -3556,7 +3449,7 @@ void Commands_observer_while_defer_suspended(void) {
     ecs_defer_begin(world);
     ecs_defer_suspend(world);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_has(world, e, Position));
     test_assert(!ecs_has(world, e, Velocity));
@@ -3583,7 +3476,7 @@ void Commands_on_add_hook_while_defer_suspended(void) {
     ecs_defer_begin(world);
     ecs_defer_suspend(world);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_has(world, e, Position));
     test_assert(!ecs_has(world, e, Velocity));
@@ -3610,7 +3503,7 @@ void Commands_on_set_hook_while_defer_suspended(void) {
     ecs_defer_begin(world);
     ecs_defer_suspend(world);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(e != 0);
     test_assert(ecs_has(world, e, Position));
     test_assert(!ecs_has(world, e, Velocity));
@@ -3634,7 +3527,7 @@ void Commands_on_remove_hook_while_defer_suspended(void) {
         .on_remove = AddWhileSuspended
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_has(world, e, Position));
     test_assert(!ecs_has(world, e, Velocity));
@@ -3690,7 +3583,7 @@ void Commands_on_set_hook_batched_is_deferred(void) {
 
     ECS_OBSERVER(world, DummyObserver, EcsOnSet, Position);
 
-    ecs_entity_t e = ecs_new(world, Bar);
+    ecs_entity_t e = ecs_new_w(world, Bar);
     ecs_add(world, e, Position);
 
     test_int(on_set_is_deferred_invoked, 0);
@@ -3717,8 +3610,8 @@ void Commands_on_set_hook_batched_is_deferred(void) {
 void Commands_add_path(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_defer_begin(world);
     ecs_add_path(world, e, p, "foo");
@@ -3738,8 +3631,8 @@ void Commands_add_path(void) {
 void Commands_add_path_to_deleted_parent(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_defer_begin(world);
     ecs_delete(world, p);
@@ -3758,8 +3651,8 @@ void Commands_add_path_to_deleted_parent(void) {
 void Commands_add_path_nested(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_defer_begin(world);
     ecs_add_path(world, e, p, "foo.bar");
@@ -3779,8 +3672,8 @@ void Commands_add_path_nested(void) {
 void Commands_add_path_nested_to_deleted_parent(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_defer_begin(world);
     ecs_delete(world, p);
@@ -3799,11 +3692,11 @@ void Commands_add_path_nested_to_deleted_parent(void) {
 void Commands_add_path_nested_to_created_deleted_parent(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_defer_begin(world);
-    ecs_entity_t foo = ecs_new_entity(world, "p.foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "p.foo" });
     ecs_delete(world, foo);
     ecs_add_path(world, e, p, "foo.bar");
     ecs_defer_end(world);
@@ -3818,8 +3711,8 @@ void Commands_add_path_nested_to_created_deleted_parent(void) {
 void Commands_add_path_w_stage(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_world_t *s = ecs_get_stage(world, 0);
 
@@ -3841,8 +3734,8 @@ void Commands_add_path_w_stage(void) {
 void Commands_add_path_to_deleted_parent_w_stage(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_world_t *s = ecs_get_stage(world, 0);
 
@@ -3863,8 +3756,8 @@ void Commands_add_path_to_deleted_parent_w_stage(void) {
 void Commands_add_path_nested_w_stage(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_world_t *s = ecs_get_stage(world, 0);
 
@@ -3886,8 +3779,8 @@ void Commands_add_path_nested_w_stage(void) {
 void Commands_add_path_nested_to_deleted_parent_w_stage(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_world_t *s = ecs_get_stage(world, 0);
 
@@ -3908,13 +3801,13 @@ void Commands_add_path_nested_to_deleted_parent_w_stage(void) {
 void Commands_add_path_nested_to_created_deleted_parent_w_stage(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "p");
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t p = ecs_entity(world, { .name = "p" });
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
     ecs_world_t *s = ecs_get_stage(world, 0);
 
     ecs_defer_begin(world);
-    ecs_entity_t foo = ecs_new_entity(s, "p.foo");
+    ecs_entity_t foo = ecs_entity(s, { .name = "p.foo" });
     ecs_delete(s, foo);
     ecs_add_path(s, e, p, "foo.bar");
     ecs_defer_end(world);
@@ -3925,3 +3818,67 @@ void Commands_add_path_nested_to_created_deleted_parent_w_stage(void) {
 
     ecs_fini(world);
 }
+
+void Commands_defer_emplace_w_arg(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e = ecs_new(world);
+
+    ecs_defer_begin(world);
+    {
+        bool is_new = false;
+        Position *p = ecs_emplace(world, e, Position, &is_new);
+        p->x = 1; p->y = 2;
+        test_bool(is_new, true);
+    }
+    {
+        bool is_new = false;
+        Position *p = ecs_emplace(world, e, Position, &is_new);
+        p->x = 10; p->y = 20;
+        test_bool(is_new, true); /* Might change after cmd queue temp storage refactor */
+    }
+    test_assert(!ecs_has(world, e, Position));
+    ecs_defer_end(world);
+    test_assert(ecs_has(world, e, Position));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Commands_defer_emplace_existing_w_arg(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e = ecs_new_w(world, Position);
+
+    ecs_defer_begin(world);
+    {
+        bool is_new = false;
+        Position *p = ecs_emplace(world, e, Position, &is_new);
+        p->x = 1; p->y = 2;
+        test_bool(is_new, false);
+    }
+    {
+        bool is_new = false;
+        Position *p = ecs_emplace(world, e, Position, &is_new);
+        p->x = 10; p->y = 20;
+        test_bool(is_new, false); /* Might change after cmd queue temp storage refactor */
+    }
+    test_assert(ecs_has(world, e, Position));
+    ecs_defer_end(world);
+    test_assert(ecs_has(world, e, Position));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
diff --git a/test/api/src/ComponentLifecycle.c b/test/core/src/ComponentLifecycle.c
similarity index 85%
rename from test/api/src/ComponentLifecycle.c
rename to test/core/src/ComponentLifecycle.c
index bea66287e..18236203f 100644
--- a/test/api/src/ComponentLifecycle.c
+++ b/test/core/src/ComponentLifecycle.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static ECS_COMPONENT_DECLARE(Position);
 static ECS_COMPONENT_DECLARE(String);
@@ -167,7 +167,7 @@ static void ecs_on_add(Position)(ecs_iter_t *it) {
     test_assert(it->count >= 1);
     test_assert(it->event == EcsOnAdd);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     for (int i = 0; i < it->count; i ++) {
         on_add_position ++;
         test_int(p[i].x, 0);
@@ -269,7 +269,7 @@ void ComponentLifecycle_ctor_on_add(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.ctor.invoked, 0);
 
     ecs_add(world, e, Position);
@@ -293,7 +293,7 @@ void ComponentLifecycle_ctor_on_new(void) {
         .ctx = &ctx
     });
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
     test_assert(ctx.ctor.invoked != 0);
     test_int(ctx.ctor.component, ecs_id(Position));
     test_int(ctx.ctor.size, sizeof(Position));
@@ -314,7 +314,7 @@ void ComponentLifecycle_dtor_on_remove(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.dtor.invoked, 0);
 
     ecs_remove(world, e, Position);
@@ -338,7 +338,7 @@ void ComponentLifecycle_dtor_on_delete(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.dtor.invoked, 0);
 
     ecs_delete(world, e);
@@ -362,7 +362,7 @@ void ComponentLifecycle_copy_on_set(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.copy.invoked, 0);
 
     ecs_set(world, e, Position, {0, 0});
@@ -386,7 +386,7 @@ void ComponentLifecycle_copy_on_override(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new(world, Position);
+    ecs_entity_t base = ecs_new_w(world, Position);
     test_int(ctx.copy.invoked, 0);
 
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
@@ -413,7 +413,7 @@ void ComponentLifecycle_copy_on_clone(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(ctx.copy.invoked != 0);
     memset(&ctx, 0, sizeof(ctx));
 
@@ -439,7 +439,7 @@ void ComponentLifecycle_no_copy_on_move(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(ctx.copy.invoked != 0);
     memset(&ctx, 0, sizeof(ctx));
 
@@ -449,164 +449,6 @@ void ComponentLifecycle_no_copy_on_move(void) {
     ecs_fini(world);
 }
 
-void ComponentLifecycle_copy_on_snapshot(void) {
-    test_quarantine("13 March 2022");
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    cl_ctx ctx = { { 0 } };
-    ecs_set_hooks(world, Position, {
-        .copy = comp_copy,
-        .ctx = &ctx
-    });
-
-    const ecs_entity_t *ids = ecs_bulk_new(world, Position, 10);
-    test_assert(ids != NULL);
-
-    int32_t i;
-    for (i = 0; i < 10; i ++) {
-        test_assert(ecs_has(world, ids[i], Position));
-        ecs_set(world, ids[i], Position, {i, i * 2});
-    }
-
-    test_assert(ctx.copy.invoked != 0);
-    test_int(ctx.copy.component, ecs_id(Position));
-    test_int(ctx.copy.size, sizeof(Position));
-    test_int(ctx.copy.count, 10);
-
-    ctx = (cl_ctx){ { 0 } };
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    test_assert(ctx.copy.invoked != 0);
-    test_int(ctx.copy.component, ecs_id(Position));
-    test_int(ctx.copy.size, sizeof(Position));
-    test_int(ctx.copy.count, 10);
-
-    ecs_snapshot_restore(world, s);
-    ecs_snapshot_free(s);
-
-    for (i = 0; i < 10; i ++) {
-        test_assert(ecs_has(world, ids[i], Position));
-        const Position *p = ecs_get(world, ids[i], Position);
-        test_assert(p != NULL);
-        test_int(p->x, i);
-        test_int(p->y, i * 2);
-    }
-
-    ecs_fini(world);
-}
-
-void ComponentLifecycle_ctor_copy_on_snapshot(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    cl_ctx ctx = { { 0 } };
-    ecs_set_hooks(world, Position, {
-        .ctor = comp_ctor,
-        .copy = comp_copy,
-        .ctx = &ctx
-    });
-
-    const ecs_entity_t *ids = ecs_bulk_new(world, Position, 10);
-    test_assert(ids != NULL);
-
-    int32_t i;
-    for (i = 0; i < 10; i ++) {
-        test_assert(ecs_has(world, ids[i], Position));
-        ecs_set(world, ids[i], Position, {i, i * 2});
-    }
-
-    test_assert(ctx.copy.invoked != 0);
-    test_int(ctx.copy.component, ecs_id(Position));
-    test_int(ctx.copy.size, sizeof(Position));
-    test_int(ctx.copy.count, 10);
-
-    ctx = (cl_ctx){ { 0 } };
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    test_assert(ctx.ctor.invoked != 0);
-    test_int(ctx.ctor.component, ecs_id(Position));
-    test_int(ctx.ctor.size, sizeof(Position));
-    test_int(ctx.ctor.count, 10);
-
-    test_assert(ctx.copy.invoked != 0);
-    test_int(ctx.copy.component, ecs_id(Position));
-    test_int(ctx.copy.size, sizeof(Position));
-    test_int(ctx.copy.count, 10);
-
-    ecs_snapshot_restore(world, s);
-
-    for (i = 0; i < 10; i ++) {
-        test_assert(ecs_has(world, ids[i], Position));
-        const Position *p = ecs_get(world, ids[i], Position);
-        test_assert(p != NULL);
-        test_int(p->x, i);
-        test_int(p->y, i * 2);
-    }
-
-    ecs_fini(world);
-}
-
-void ComponentLifecycle_dtor_on_restore(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    cl_ctx ctx = { { 0 } };
-    ecs_set_hooks(world, Position, {
-        .dtor = comp_dtor,
-        .ctx = &ctx
-    });
-
-    const ecs_entity_t *temp_ids = ecs_bulk_new(world, Position, 10);
-    test_assert(temp_ids != NULL);
-    ecs_entity_t ids[10];
-    memcpy(ids, temp_ids, sizeof(ecs_entity_t) * 10);
-
-    int32_t i;
-    for (i = 0; i < 10; i ++) {
-        test_assert(ecs_has(world, ids[i], Position));
-        ecs_set(world, ids[i], Position, {i, i * 2});
-    }
-
-    test_int(ctx.dtor.invoked, 0);
-
-    ctx = (cl_ctx){ { 0 } };
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    test_int(ctx.dtor.invoked, 0);
-
-    /* Delete one entity, so we have more confidence we're destructing the right
-     * entities */
-    ecs_delete(world, ids[0]);
-
-    test_assert(ctx.dtor.invoked != 0);
-    ctx = (cl_ctx){ { 0 } };
-
-    ecs_snapshot_restore(world, s);
-
-    test_assert(ctx.dtor.invoked != 0);
-    test_int(ctx.dtor.component, ecs_id(Position));
-    test_int(ctx.dtor.size, sizeof(Position));
-    test_int(ctx.dtor.count, 9);
-
-    for (i = 0; i < 10; i ++) {
-        test_assert(ecs_has(world, ids[i], Position));
-        const Position *p = ecs_get(world, ids[i], Position);
-        test_assert(p != NULL);
-
-        test_int(p->x, i);
-        test_int(p->y, i * 2);
-    }
-
-    ecs_fini(world);
-}
-
 void ComponentLifecycle_ctor_on_tag(void) {
     install_test_abort();
 
@@ -801,7 +643,7 @@ void ComponentLifecycle_merge_to_new_table(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_set_hooks(world, Position, {
         .ctor = ecs_ctor(Position),
@@ -920,7 +762,7 @@ void ComponentLifecycle_ctor_on_add_pair(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.ctor.invoked, 0);
 
     ecs_add_pair(world, e, ecs_id(Pair), ecs_id(Position));
@@ -945,7 +787,7 @@ void ComponentLifecycle_ctor_on_add_pair_tag(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.ctor.invoked, 0);
 
     ecs_add_pair(world, e, Pair, ecs_id(Position));
@@ -972,7 +814,7 @@ void ComponentLifecycle_ctor_on_move_pair(void) {
     });
 
     /* Create entity in existing table */
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.ctor.invoked, 0);
 
     /* Add pair to existing table */
@@ -999,7 +841,7 @@ void ComponentLifecycle_move_on_realloc(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.ctor.invoked, 0);
 
     ecs_add(world, e, Position);
@@ -1012,8 +854,8 @@ void ComponentLifecycle_move_on_realloc(void) {
     ctx = (cl_ctx){ { 0 } };
 
     /* Trigger realloc & move */
-    ecs_new(world, Position);
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
     test_assert(ctx.ctor.invoked != 0);
     test_assert(ctx.move.invoked != 0);
 
@@ -1033,7 +875,7 @@ void ComponentLifecycle_move_on_bulk_new(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.ctor.invoked, 0);
 
     ecs_add(world, e, Position);
@@ -1082,8 +924,8 @@ void ComponentLifecycle_move_on_delete(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
     test_assert(ctx.ctor.invoked != 0);
 
     ctx = (cl_ctx){ { 0 } };
@@ -1112,8 +954,8 @@ void ComponentLifecycle_move_dtor_on_delete(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
 
     ctx = (cl_ctx){ { 0 } };
 
@@ -1147,7 +989,7 @@ void ComponentLifecycle_copy_on_override_pair(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     ecs_add_pair(world, base, ecs_id(Pair), ecs_id(Position));
     test_assert(ctx.ctor.invoked != 0);
     test_int(ctx.copy.invoked, 0);
@@ -1184,7 +1026,7 @@ void ComponentLifecycle_copy_on_override_pair_tag(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     ecs_add_pair(world, base, Pair, ecs_id(Position));
     test_assert(ctx.ctor.invoked != 0);
     test_int(ctx.copy.invoked, 0);
@@ -1220,7 +1062,7 @@ void ComponentLifecycle_copy_on_set_pair(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.copy.invoked, 0);
 
     ecs_set_pair(world, e, Pair, ecs_id(Position), {0, 0});
@@ -1245,10 +1087,10 @@ void ComponentLifecycle_copy_on_set_pair_tag(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.copy.invoked, 0);
-
-    ecs_set_pair_object(world, e, Pair, Position, {0, 0});
+    
+    ecs_set_pair_second(world, e, Pair, Position, {0, 0});
     test_assert(ctx.copy.invoked != 0);
     test_int(ctx.copy.component, ecs_id(Position));
     test_int(ctx.copy.size, sizeof(Position));
@@ -1271,7 +1113,7 @@ void ComponentLifecycle_allow_lifecycle_overwrite_equal_callbacks(void) {
         .ctor = ecs_ctor(Position)
     });
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     test_int(ctor_position, 1);
 
@@ -1291,7 +1133,7 @@ void ComponentLifecycle_set_lifecycle_after_trigger(void) {
         .ctor = ecs_ctor(Position)
     });
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     test_int(ctor_position, 1);
 
@@ -1331,7 +1173,7 @@ void ComponentLifecycle_valid_entity_in_dtor_after_delete(void) {
         .dtor = dummy_dtor
     });
 
-    ecs_entity_t e = ecs_new(world, Dummy);
+    ecs_entity_t e = ecs_new_w(world, Dummy);
     test_assert(e != 0);
     ecs_set(world, e, Dummy, {world, e, 0});
 
@@ -1356,10 +1198,10 @@ void ComponentLifecycle_ctor_w_emplace(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
-    const Position *ptr = ecs_emplace(world, e, Position);
+    const Position *ptr = ecs_emplace(world, e, Position, NULL);
     test_assert(ptr != NULL);
     test_int(ctx.ctor.invoked, 0);
 
@@ -1377,11 +1219,11 @@ void ComponentLifecycle_ctor_w_emplace_defer(void) {
 
     test_int(ctor_position, 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_defer_begin(world);
-    Position *ptr = ecs_emplace(world, e, Position);
+    Position *ptr = ecs_emplace(world, e, Position, NULL);
     test_assert(ptr != NULL);
     test_int(ctor_position, 0);
     ptr->x = 10;
@@ -1409,11 +1251,11 @@ void ComponentLifecycle_on_add_w_emplace(void) {
         .on_add = on_add_position_emplace
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_int(on_add_position, 0);
-    const Position *ptr = ecs_emplace(world, e, Position);
+    const Position *ptr = ecs_emplace(world, e, Position, NULL);
     test_assert(ptr != NULL);
     test_int(on_add_position, 1);
 
@@ -1431,12 +1273,12 @@ void ComponentLifecycle_on_add_w_emplace_existing(void) {
         .on_add = on_add_position_emplace
     });
 
-    ecs_entity_t e = ecs_new(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Velocity);
     test_assert(e != 0);
 
     test_int(ctor_position, 0);
     test_int(on_add_position, 0);
-    const Position *ptr = ecs_emplace(world, e, Position);
+    const Position *ptr = ecs_emplace(world, e, Position, NULL);
     test_assert(ptr != NULL);
     test_int(ctor_position, 0);
     test_int(on_add_position, 1);
@@ -1453,12 +1295,12 @@ void ComponentLifecycle_on_add_w_emplace_defer(void) {
         .on_add = on_add_position_emplace
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_defer_begin(world);
     test_int(on_add_position, 0);
-    const Position *ptr = ecs_emplace(world, e, Position);
+    const Position *ptr = ecs_emplace(world, e, Position, NULL);
     test_assert(ptr != NULL);
     test_int(on_add_position, 0);
     ecs_defer_end(world);
@@ -1480,6 +1322,18 @@ void position_move_ctor(
     move_ctor_position ++;
 }
 
+static int move_dtor_position = 0;
+static
+void position_move_dtor(
+    void *dst,
+    void *src,
+    int32_t count,
+    const ecs_type_info_t *info)
+{
+    *((Position*)dst) = *((Position*)src);
+    move_dtor_position ++;
+}
+
 void ComponentLifecycle_ctor_w_emplace_defer_use_move_ctor(void) {
     ecs_world_t *world = ecs_mini();
 
@@ -1491,12 +1345,12 @@ void ComponentLifecycle_ctor_w_emplace_defer_use_move_ctor(void) {
         .move_ctor = position_move_ctor
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_defer_begin(world);
     test_int(on_add_position, 0);
-    Position *ptr = ecs_emplace(world, e, Position);
+    Position *ptr = ecs_emplace(world, e, Position, NULL);
     ptr->x = 10;
     ptr->y = 20;
     test_assert(ptr != NULL);
@@ -1516,6 +1370,113 @@ void ComponentLifecycle_ctor_w_emplace_defer_use_move_ctor(void) {
     ecs_fini(world);
 }
 
+void ComponentLifecycle_ctor_w_emplace_defer_twice(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_set_hooks(world, Position, {
+        .ctor = ecs_ctor(Position),
+        .move = ecs_move(Position),
+        .move_ctor = position_move_ctor,
+        .move_dtor = position_move_dtor
+    });
+
+    ecs_entity_t e = ecs_new(world);
+    test_assert(e != 0);
+
+    ecs_defer_begin(world);
+
+    {
+        bool is_new = false;
+        Position *ptr = ecs_emplace(world, e, Position, &is_new);
+        test_bool(is_new, true);
+        test_assert(ptr != NULL);
+        ptr->x = 10;
+        ptr->y = 20;
+    }
+    {
+        bool is_new = false;
+        Position *ptr = ecs_emplace(world, e, Position, &is_new);
+        test_bool(is_new, true);
+        test_assert(ptr != NULL);
+        ptr->x = 20;
+        ptr->y = 30;
+    }
+
+    test_int(ctor_position, 0);
+    test_int(move_position, 0);
+    test_int(move_ctor_position, 0);
+    test_int(move_dtor_position, 0);
+    ecs_defer_end(world);
+
+    test_int(ctor_position, 0);
+    test_int(move_position, 0);
+    test_int(move_ctor_position, 1);
+    test_int(move_dtor_position, 1);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 20);
+    test_int(p->y, 30);
+
+    ecs_fini(world); 
+}
+
+void ComponentLifecycle_ctor_w_emplace_defer_existing(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_set_hooks(world, Position, {
+        .ctor = ecs_ctor(Position),
+        .move = ecs_move(Position),
+        .move_ctor = position_move_ctor,
+        .move_dtor = position_move_dtor
+    });
+
+    ecs_entity_t e = ecs_new_w(world, Position);
+    test_assert(e != 0);
+
+    test_int(ctor_position, 1);
+    ctor_position = 0;
+
+    ecs_defer_begin(world);
+
+    {
+        bool is_new = false;
+        Position *ptr = ecs_emplace(world, e, Position, &is_new);
+        test_bool(is_new, false);
+        test_assert(ptr != NULL);
+        ptr->x = 10;
+        ptr->y = 20;
+    }
+    {
+        bool is_new = false;
+        Position *ptr = ecs_emplace(world, e, Position, &is_new);
+        test_bool(is_new, false);
+        test_assert(ptr != NULL);
+        ptr->x = 20;
+        ptr->y = 30;
+    }
+
+    test_int(ctor_position, 0);
+    test_int(move_position, 0);
+    test_int(move_ctor_position, 0);
+    test_int(move_dtor_position, 0);
+    ecs_defer_end(world);
+
+    test_int(ctor_position, 0);
+    test_int(move_position, 0);
+    test_int(move_ctor_position, 0);
+    test_int(move_dtor_position, 0);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 20);
+    test_int(p->y, 30);
+
+    ecs_fini(world);
+}
+
 void ComponentLifecycle_merge_async_stage_w_emplace(void) {
     ecs_world_t *world = ecs_mini();
 
@@ -1528,11 +1489,11 @@ void ComponentLifecycle_merge_async_stage_w_emplace(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
 
-    Position *p = ecs_emplace(async, e, Position);
+    Position *p = ecs_emplace(async, e, Position, NULL);
     test_assert(!ecs_has(world, e, Position));
     test_int(ctor_position, 0);
     test_int(copy_position, 0);
@@ -1554,7 +1515,7 @@ void ComponentLifecycle_merge_async_stage_w_emplace(void) {
     test_int(ptr->x, 10);
     test_int(ptr->y, 20);
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
@@ -1569,11 +1530,11 @@ void ComponentLifecycle_merge_async_stage_w_emplace_to_deferred_world(void) {
         .copy = ecs_copy(Position)
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
 
-    Position *p = ecs_emplace(async, e, Position);
+    Position *p = ecs_emplace(async, e, Position, NULL);
     test_assert(!ecs_has(world, e, Position));
     test_int(ctor_position, 0);
     p->x = 10;
@@ -1592,7 +1553,7 @@ void ComponentLifecycle_merge_async_stage_w_emplace_to_deferred_world(void) {
     test_int(ptr->x, 10);
     test_int(ptr->y, 20);
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
@@ -1616,22 +1577,22 @@ void ComponentLifecycle_emplace_grow_w_existing_component(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t e1 = ecs_new(world, Velocity);
-    ecs_entity_t e2 = ecs_new(world, Velocity);
-    ecs_entity_t e3 = ecs_new(world, Velocity);
+    ecs_entity_t e1 = ecs_new_w(world, Velocity);
+    ecs_entity_t e2 = ecs_new_w(world, Velocity);
+    ecs_entity_t e3 = ecs_new_w(world, Velocity);
 
     {
-        Position *p = ecs_emplace(world, e1, Position);
+        Position *p = ecs_emplace(world, e1, Position, NULL);
         p->x = 10;
         p->y = 20;
     }
     {
-        Position *p = ecs_emplace(world, e2, Position);
+        Position *p = ecs_emplace(world, e2, Position, NULL);
         p->x = 30;
         p->y = 40;
     }
     {
-        Position *p = ecs_emplace(world, e3, Position);
+        Position *p = ecs_emplace(world, e3, Position, NULL);
         p->x = 50;
         p->y = 60;
     }
@@ -1671,7 +1632,7 @@ void ComponentLifecycle_dtor_on_fini(void) {
         .dtor = dummy_dtor
     });
 
-    ecs_entity_t e = ecs_new(world, Dummy);
+    ecs_entity_t e = ecs_new_w(world, Dummy);
     test_assert(e != 0);
 
     ecs_set(world, e, Dummy, {world, e});
@@ -1749,39 +1710,6 @@ void other_type_dtor(
     other_dtor_invoked ++;
 }
 
-static
-void other_comp_dtor(
-    void *ptr,
-    int32_t count,
-    const ecs_type_info_t *info)
-{
-    test_int(count, 1);
-    test_assert(ptr != NULL);
-
-    Entity *comp = ptr;
-
-    ecs_world_t *world = comp->world;
-    ecs_entity_t e = comp->e;
-    test_assert(e != 0);
-    test_assert(ecs_is_valid(world, e));
-
-    test_assert(comp->other != 0);
-
-    if (ecs_is_valid(world, comp->other)) {
-        if (ecs_has(world, comp->other, String)) {
-            const String *str_ptr = ecs_get(world, comp->other, String);
-            test_assert(str_ptr != NULL);
-            test_assert(str_ptr->str != NULL);
-            test_str(str_ptr->str, "Foo");
-            other_dtor_valid_entity ++;
-        } else {
-            test_assert(ecs_get(world, comp->other, String) == NULL);
-        }
-    }
-
-    other_dtor_invoked ++;
-}
-
 ECS_MOVE(Entity, dst, src, {
     dst->world = src->world;
     dst->e = src->e;
@@ -1877,7 +1805,7 @@ void ComponentLifecycle_valid_type_in_dtor_on_fini(void) {
         .dtor = type_dtor
     });
 
-    ecs_entity_t e = ecs_new(world, Dummy);
+    ecs_entity_t e = ecs_new_w(world, Dummy);
     test_assert(e != 0);
     ecs_set(world, e, Dummy, {world, e});
     ecs_add(world, e, Position);
@@ -1901,8 +1829,8 @@ void ComponentLifecycle_valid_other_type_of_entity_in_dtor_on_fini(void) {
         .dtor = other_type_dtor
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     ecs_set(world, e2, Entity, {world, e2, e1});
 
     ecs_add(world, e1, Velocity);
@@ -1932,8 +1860,8 @@ void ComponentLifecycle_delete_in_dtor_other_type_on_fini(void) {
         .dtor = other_delete_dtor
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Velocity);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Velocity);
 
     ecs_set(world, e2, Entity, {world, e2, e1});
     ecs_set(world, e1, Entity, {world, e1, e2});
@@ -1965,10 +1893,10 @@ void ComponentLifecycle_delete_in_dtor_other_type_on_delete_parent(void) {
         .dtor = other_delete_dtor
     });
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Velocity);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Velocity);
 
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
@@ -2008,8 +1936,8 @@ void ComponentLifecycle_delete_in_dtor_other_type_on_delete(void) {
         .dtor = other_delete_dtor
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Velocity);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Velocity);
 
     ecs_set(world, e2, Entity, {world, e2, e1});
     ecs_set(world, e1, Entity, {world, e1, e2});
@@ -2037,9 +1965,9 @@ void ComponentLifecycle_delete_self_in_dtor_on_delete(void) {
         .dtor = self_delete_dtor
     });
 
-    ecs_entity_t e1 = ecs_new(world, Dummy);
-    ecs_entity_t e2 = ecs_new(world, Dummy);
-    ecs_entity_t e3 = ecs_new(world, Dummy);
+    ecs_entity_t e1 = ecs_new_w(world, Dummy);
+    ecs_entity_t e2 = ecs_new_w(world, Dummy);
+    ecs_entity_t e3 = ecs_new_w(world, Dummy);
 
     ecs_set(world, e1, Dummy, {world, e1});
     ecs_set(world, e2, Dummy, {world, e2});
@@ -2081,7 +2009,7 @@ void ComponentLifecycle_on_set_after_set(void) {
         .on_set = ecs_on_set(Position)
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctor_position, 1);
     test_int(position_on_set_invoked, 0);
 
@@ -2107,15 +2035,15 @@ void ComponentLifecycle_on_add_after_new(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .on_add = ecs_on_add(Position)
     });
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
     test_int(on_add_position, 1);
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
     test_int(on_add_position, 2);
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
     test_int(on_add_position, 3);
 
     ecs_fini(world);
@@ -2127,13 +2055,13 @@ void ComponentLifecycle_on_add_after_add(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .on_add = ecs_on_add(Position)
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     test_int(on_add_position, 1);
@@ -2151,15 +2079,15 @@ void ComponentLifecycle_on_add_after_set(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .on_add = ecs_on_add(Position)
     });
 
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
     test_int(on_add_position, 1);
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
     test_int(on_add_position, 2);
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
     test_int(on_add_position, 3);
 
     ecs_fini(world);
@@ -2171,7 +2099,7 @@ static void ecs_on_remove(Position)(ecs_iter_t *it) {
     test_assert(it->count >= 1);
     test_assert(it->event == EcsOnRemove);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     for (int i = 0; i < it->count; i ++) {
         on_remove_position ++;
         test_int(p[i].x, 10);
@@ -2188,9 +2116,9 @@ void ComponentLifecycle_on_remove_after_remove(void) {
         .on_remove = ecs_on_remove(Position)
     });
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_remove(world, e1, Position);
     test_int(on_remove_position, 1);
@@ -2211,9 +2139,9 @@ void ComponentLifecycle_on_remove_after_clear(void) {
         .on_remove = ecs_on_remove(Position)
     });
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_clear(world, e1);
     test_int(on_remove_position, 1);
@@ -2234,9 +2162,9 @@ void ComponentLifecycle_on_remove_after_delete(void) {
         .on_remove = ecs_on_remove(Position)
     });
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_delete(world, e1);
     test_int(on_remove_position, 1);
@@ -2261,8 +2189,8 @@ void on_remove_tag_set_position(ecs_iter_t *it) {
 static
 void on_remove_tag_set_position_pair(ecs_iter_t *it) {
     for (int i = 0; i < it->count; i ++) {
-        ecs_set_pair(it->world, it->entities[i],
-            Position, ecs_new_id(it->world), {10, 20});
+        ecs_set_pair(it->world, it->entities[i], 
+            Position, ecs_new(it->world), {10, 20});
         on_remove_tag_set_position_invoked ++;
     }
 }
@@ -2270,8 +2198,8 @@ void on_remove_tag_set_position_pair(ecs_iter_t *it) {
 static
 void on_remove_tag_set_position_obj_pair(ecs_iter_t *it) {
     for (int i = 0; i < it->count; i ++) {
-        ecs_set_pair_object(it->world, it->entities[i],
-            ecs_new_id(it->world), Position, {10, 20});
+        ecs_set_pair_second(it->world, it->entities[i], 
+            ecs_new(it->world), Position, {10, 20});
         on_remove_tag_set_position_invoked ++;
     }
 }
@@ -2283,12 +2211,12 @@ void ComponentLifecycle_free_component_new_id_while_fini(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnRemove},
         .callback = on_remove_tag_set_position
     });
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     ecs_fini(world);
 
@@ -2302,17 +2230,17 @@ void ComponentLifecycle_dtor_component_new_id_while_fini(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnRemove},
         .callback = on_remove_tag_set_position
     });
 
     ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     test_int(dtor_position, 0);
 
@@ -2329,12 +2257,12 @@ void ComponentLifecycle_free_component_new_pair_id_while_fini(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnRemove},
         .callback = on_remove_tag_set_position_pair
     });
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     ecs_fini(world);
 
@@ -2348,17 +2276,17 @@ void ComponentLifecycle_dtor_component_new_pair_id_while_fini(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnRemove},
         .callback = on_remove_tag_set_position_pair
     });
 
     ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     test_int(dtor_position, 0);
 
@@ -2375,12 +2303,12 @@ void ComponentLifecycle_free_component_new_obj_pair_id_while_fini(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnRemove},
         .callback = on_remove_tag_set_position_obj_pair
     });
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     ecs_fini(world);
 
@@ -2394,17 +2322,17 @@ void ComponentLifecycle_dtor_component_new_obj_pair_id_while_fini(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnRemove},
         .callback = on_remove_tag_set_position_obj_pair
     });
 
     ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     test_int(dtor_position, 0);
 
@@ -2429,9 +2357,9 @@ void ComponentLifecycle_ctor_move_dtor_after_resize(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     test_int(ctx.ctor.count, 1);
@@ -2550,7 +2478,7 @@ void ComponentLifecycle_on_add_ctx(void) {
         .binding_ctx = &component_lifecycle_binding_ctx
     });
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
     test_int(1, component_lifecycle_ctx);
     test_int(1, component_lifecycle_binding_ctx);
 
@@ -2571,7 +2499,7 @@ void ComponentLifecycle_on_remove_ctx(void) {
         .binding_ctx = &component_lifecycle_binding_ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(0, component_lifecycle_ctx);
     test_int(0, component_lifecycle_binding_ctx);
 
@@ -2596,7 +2524,7 @@ void ComponentLifecycle_on_set_ctx(void) {
         .binding_ctx = &component_lifecycle_binding_ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(0, component_lifecycle_ctx);
     test_int(0, component_lifecycle_binding_ctx);
 
@@ -2630,7 +2558,7 @@ void ComponentLifecycle_on_add_w_existing_component(void) {
         .ctx = (void*)&EcsOnAdd
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Position);
 
     test_int(1, test_on_event_invoked);
@@ -2650,7 +2578,7 @@ void ComponentLifecycle_on_remove_w_existing_component(void) {
         .ctx = (void*)&EcsOnRemove
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Position);
 
     test_int(0, test_on_event_invoked);
@@ -2698,7 +2626,7 @@ void ComponentLifecycle_component_init_set_hooks(void) {
     test_int(0, on_add_count);
     test_int(0, on_remove_count);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, c);
 
     test_int(1, on_add_count);
@@ -2759,6 +2687,77 @@ void ComponentLifecycle_component_init_scoped_name_from_type_info(void) {
     ecs_fini(world);
 }
 
+void ComponentLifecycle_component_init_w_recycled_id(void) {
+    ecs_world_t *world = ecs_init();
+
+    {
+        ecs_entity_t c = ecs_component(world, {
+            .entity = ecs_new(world),
+            .type.size = 4,
+            .type.alignment = 4
+        });
+
+        test_assert(c != 0);
+        test_assert(ecs_has(world, c, EcsComponent));
+
+        ecs_delete(world, c);
+    }
+
+    {
+        ecs_entity_t c = ecs_component(world, {
+            .entity = ecs_new(world),
+            .type.size = 4,
+            .type.alignment = 4
+        });
+
+        test_assert(c != 0);
+        test_assert(ecs_has(world, c, EcsComponent));
+
+        ecs_delete(world, c);
+    }
+
+    ecs_fini(world);
+}
+
+void ComponentLifecycle_component_init_w_recycled_non_component_id(void) {
+    ecs_world_t *world = ecs_init();
+
+    {
+        ecs_entity_t c = ecs_component(world, {
+            .entity = ecs_new(world),
+            .type.size = 4,
+            .type.alignment = 4
+        });
+
+        test_assert(c != 0);
+        test_assert(ecs_has(world, c, EcsComponent));
+
+        ecs_delete(world, c);
+    }
+
+    {
+        ecs_entity_t c = ecs_new(world);
+        test_assert(c != 0);
+        test_assert(!ecs_has(world, c, EcsComponent));
+        ecs_delete(world, c);
+    }
+
+    {
+        ecs_entity_t c = ecs_component(world, {
+            .entity = ecs_new(world),
+            .type.size = 4,
+            .type.alignment = 4
+        });
+
+        test_assert(c != 0);
+        test_assert(ecs_has(world, c, EcsComponent));
+
+        ecs_delete(world, c);
+    }
+
+    ecs_fini(world);
+}
+
 static int ctor_before_on_add_count = 0;
 static int on_add_after_ctor_count = 0;
 
@@ -2788,7 +2787,7 @@ void ComponentLifecycle_on_add_after_ctor_w_add(void) {
     test_int(0, ctor_before_on_add_count);
     test_int(0, on_add_after_ctor_count);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     test_int(1, ctor_before_on_add_count);
     test_int(1, on_add_after_ctor_count);
@@ -2810,7 +2809,7 @@ void ComponentLifecycle_on_add_after_ctor_w_add_to(void) {
     test_int(0, ctor_before_on_add_count);
     test_int(0, on_add_after_ctor_count);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     test_int(0, ctor_before_on_add_count);
     test_int(0, on_add_after_ctor_count);
@@ -2826,7 +2825,7 @@ void ComponentLifecycle_on_add_after_ctor_w_add_to(void) {
 void ComponentLifecycle_with_before_hooks(void) {
     ecs_world_t* world = ecs_mini();
 
-    ecs_entity_t pos_id = ecs_new_id(world);
+    ecs_entity_t pos_id = ecs_new(world);
     ecs_entity_t tag = ecs_new_w_pair(world, EcsWith, pos_id);
 
     ecs_entity_t ecs_id(Position) =
@@ -2865,7 +2864,7 @@ void ComponentLifecycle_with_component_on_add(void) {
                 .size = ECS_SIZEOF(Position),
                 .alignment = ECS_ALIGNOF(Position),
                 .hooks = {
-                    .ctor = ecs_default_ctor,
+                    .ctor = flecs_default_ctor,
                     .on_add = ecs_on_add(Position)
                 }
             }
@@ -2877,7 +2876,7 @@ void ComponentLifecycle_with_component_on_add(void) {
 
     test_int(on_add_position, 0);
 
-    ecs_entity_t e = ecs_new(world, Foo);
+    ecs_entity_t e = ecs_new_w(world, Foo);
     test_assert(ecs_has(world, e, Foo));
     test_assert(ecs_has(world, e, Position));
     test_int(on_add_position, 1);
@@ -2897,13 +2896,13 @@ void ComponentLifecycle_move_ctor_on_move(void) {
         .move_ctor = position_move_ctor,
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t p = ecs_new(world);
 
-    Position *p1 = ecs_emplace(world, e1, Position);
+    Position *p1 = ecs_emplace(world, e1, Position, NULL);
     test_assert(p1 != NULL);
-    Position *p2 = ecs_emplace(world, e2, Position);
+    Position *p2 = ecs_emplace(world, e2, Position, NULL);
     test_assert(p2 != NULL);
 
     test_int(ctor_position, 0);
@@ -2952,18 +2951,18 @@ void ComponentLifecycle_ptr_to_self(void) {
         .dtor = ecs_dtor(TestSelf)
     });
 
-    ecs_entity_t role = ecs_new_entity(world, "MyRole");
+    ecs_entity_t role = ecs_entity(world, { .name = "MyRole" });
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, TestSelf, {"a"});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, TestSelf, {"a"});
 
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e3 = ecs_new(world);
     ecs_add_pair(world, e2, e3, role);
 
-    ecs_entity_t e4 = ecs_new_id(world);
+    ecs_entity_t e4 = ecs_new(world);
     ecs_set(world, e4, TestSelf, {"a"});
 
     ecs_delete(world, role);
@@ -2984,11 +2983,11 @@ void ComponentLifecycle_ctor_move_dtor_from_move_ctor(void) {
         .move_ctor = position_move_ctor
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
-    ecs_world_t *async = ecs_async_stage_new(world);
+    ecs_world_t *async = ecs_stage_new(world);
 
-    Position *p = ecs_emplace(async, e, Position);
+    Position *p = ecs_emplace(async, e, Position, NULL);
     test_assert(!ecs_has(world, e, Position));
     test_int(ctor_position, 0);
     test_int(copy_position, 0);
@@ -3006,7 +3005,7 @@ void ComponentLifecycle_ctor_move_dtor_from_move_ctor(void) {
     test_int(ptr->x, 10);
     test_int(ptr->y, 20);
 
-    ecs_async_stage_free(async);
+    ecs_stage_free(async);
 
     ecs_fini(world);
 }
@@ -3017,7 +3016,7 @@ static Position hook_w_offset_position;
 
 static
 void hook_w_offset(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_int(it->count, 1);
     hook_w_offset_offset = it->offset;
     hook_w_offset_invoked ++;
@@ -3033,15 +3032,15 @@ void ComponentLifecycle_on_add_hook_check_offset(void) {
         .on_add = hook_w_offset
     });
 
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
     test_int(hook_w_offset_invoked, 1);
     test_int(hook_w_offset_offset, 0);
 
-    ecs_set(world, 0, Position, {30, 40});
+    ecs_insert(world, ecs_value(Position, {30, 40}));
     test_int(hook_w_offset_invoked, 2);
     test_int(hook_w_offset_offset, 1);
 
-    ecs_set(world, 0, Position, {50, 60});
+    ecs_insert(world, ecs_value(Position, {50, 60}));
     test_int(hook_w_offset_invoked, 3);
     test_int(hook_w_offset_offset, 2);
 
@@ -3057,9 +3056,9 @@ void ComponentLifecycle_on_remove_hook_check_offset(void) {
         .on_remove = hook_w_offset
     });
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {50, 60});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {50, 60}));
     test_int(hook_w_offset_invoked, 0);
 
     ecs_remove(world, e3, Position);
@@ -3092,19 +3091,19 @@ void ComponentLifecycle_on_set_hook_check_offset(void) {
         .on_set = hook_w_offset
     });
 
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
     test_int(hook_w_offset_invoked, 1);
     test_int(hook_w_offset_offset, 0);
     test_int(hook_w_offset_position.x, 10);
     test_int(hook_w_offset_position.y, 20);
 
-    ecs_set(world, 0, Position, {30, 40});
+    ecs_insert(world, ecs_value(Position, {30, 40}));
     test_int(hook_w_offset_invoked, 2);
     test_int(hook_w_offset_offset, 1);
     test_int(hook_w_offset_position.x, 30);
     test_int(hook_w_offset_position.y, 40);
 
-    ecs_set(world, 0, Position, {50, 60});
+    ecs_insert(world, ecs_value(Position, {50, 60}));
     test_int(hook_w_offset_invoked, 3);
     test_int(hook_w_offset_offset, 2);
     test_int(hook_w_offset_position.x, 50);
@@ -3117,7 +3116,7 @@ static int on_set_position_invoked = 0;
 
 static
 void on_set_position(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_int(it->count, 1);
 
     test_int(p->x, 10);
@@ -3135,7 +3134,7 @@ void ComponentLifecycle_on_set_hook_on_override(void) {
         .on_set = on_set_position
     });
 
-    ecs_entity_t p = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t p = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_add_id(world, p, EcsPrefab);
     test_int(on_set_position_invoked, 1);
 
@@ -3164,7 +3163,7 @@ void ComponentLifecycle_on_set_hook_on_auto_override(void) {
         .on_set = on_set_position
     });
 
-    ecs_entity_t p = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t p = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_add_id(world, p, ECS_OVERRIDE | ecs_id(Position));
     ecs_add_id(world, p, EcsPrefab);
     test_int(on_set_position_invoked, 1);
@@ -3197,7 +3196,7 @@ void ComponentLifecycle_batched_set_new_component_w_lifecycle(void) {
 
     ecs_defer_begin(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {10, 20});
     ecs_add(world, e, Tag); // to hit command batching
 
@@ -3238,7 +3237,7 @@ void ComponentLifecycle_batched_ensure_new_component_w_lifecycle(void) {
 
     ecs_defer_begin(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_ensure(world, e, Position);
     ecs_add(world, e, Tag); // to hit command batching
 
@@ -3276,29 +3275,29 @@ void ComponentLifecycle_on_nested_prefab_copy_test_invokes_copy_count(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t child = ecs_new(world, Position);
+    ecs_entity_t child = ecs_new_w(world, Position);
     ecs_add_id(world, child, ECS_OVERRIDE | ecs_id(Position));
     ecs_add_id(world, child, EcsPrefab);
     test_int(ctx.copy.invoked, 0);
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent"});
     ecs_add_id(world, parent, EcsPrefab);
 
-    ecs_entity_t child_e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t child_e1 = ecs_entity(world, { .name = "e1"});
     ecs_add_id(world, child_e1, EcsPrefab);
     ecs_add_pair(world, child_e1, EcsIsA, child);
     ecs_add_pair(world, child_e1, EcsChildOf, parent);
 
     test_int(ctx.copy.invoked, 1);
 
-    ecs_entity_t child_e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t child_e2 = ecs_entity(world, { .name = "e2"});
     ecs_add_id(world, child_e2, EcsPrefab);
     ecs_add_pair(world, child_e2, EcsIsA, child);
     ecs_add_pair(world, child_e2, EcsChildOf, parent);
 
     test_int(ctx.copy.invoked, 2);
 
-    ecs_entity_t child_e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t child_e3 = ecs_entity(world, { .name = "e3"});
     ecs_add_id(world, child_e3, EcsPrefab);
     ecs_add_pair(world, child_e3, EcsIsA, child);
     ecs_add_pair(world, child_e3, EcsChildOf, parent);
@@ -3337,13 +3336,13 @@ void ComponentLifecycle_no_move_no_move_ctor_with_move_dtor_with_ctor_move_dtor(
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Position); 
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add(world, e2, Position);
 
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e3 = ecs_new(world);
     ecs_add(world, e3, Position);
 
     ctx.ctor_move_dtor.invoked = 0;
diff --git a/test/api/src/Count.c b/test/core/src/Count.c
similarity index 81%
rename from test/api/src/Count.c
rename to test/core/src/Count.c
index a5ce7f116..b0b1bc8c4 100644
--- a/test/api/src/Count.c
+++ b/test/core/src/Count.c
@@ -1,9 +1,9 @@
-#include <api.h>
+#include <core.h>
 
 void Count_count_empty(void) {
     ecs_world_t *world = ecs_mini();
 
-    test_int(ecs_count(world, 0), 0);
+    test_int(ecs_count_id(world, 0), 0);
 
     ecs_fini(world);
 }
@@ -34,8 +34,8 @@ void Count_count_disabled(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
 
     test_int(ecs_count(world, Position), 2);
 
@@ -51,8 +51,8 @@ void Count_count_prefab(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
 
     test_int(ecs_count(world, Position), 2);
 
diff --git a/test/api/src/Delete.c b/test/core/src/Delete.c
similarity index 86%
rename from test/api/src/Delete.c
rename to test/core/src/Delete.c
index ef1794534..f534b982e 100644
--- a/test/api/src/Delete.c
+++ b/test/core/src/Delete.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Delete_setup(void) {
     ecs_log_set_level(-3);
@@ -9,7 +9,7 @@ void Delete_delete_1(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_delete(world, e);
@@ -25,7 +25,7 @@ void Delete_delete_1_again(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_delete(world, e);
@@ -42,14 +42,14 @@ void Delete_delete_1_again(void) {
 void Delete_delete_recycled_tag_again(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_delete(world, e);
     test_assert(ecs_exists(world, e));
     test_assert(!ecs_is_alive(world, e));
 
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t t = ecs_new(world);
     test_assert(t != 0);
     test_assert((uint32_t)t == (uint32_t)e);
     test_assert(ecs_exists(world, e));
@@ -57,7 +57,7 @@ void Delete_delete_recycled_tag_again(void) {
     test_assert(ecs_exists(world, t));
     test_assert(ecs_is_alive(world, t));
 
-    ecs_entity_t f = ecs_new_id(world);
+    ecs_entity_t f = ecs_new(world);
     ecs_add_id(world, f, t);
 
     ecs_delete(world, e);
@@ -76,7 +76,7 @@ void Delete_delete_empty(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_delete(world, e);
@@ -101,9 +101,9 @@ void Delete_delete_1st_of_3(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(e2 != 0);
     test_assert(e3 != 0);
@@ -126,9 +126,9 @@ void Delete_delete_2nd_of_3(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(e2 != 0);
     test_assert(e3 != 0);
@@ -152,9 +152,9 @@ void Delete_delete_3rd_of_3(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(e2 != 0);
     test_assert(e3 != 0);
@@ -178,9 +178,9 @@ void Delete_delete_2_of_3(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(e2 != 0);
     test_assert(e3 != 0);
@@ -205,9 +205,9 @@ void Delete_delete_3_of_3(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(e2 != 0);
     test_assert(e3 != 0);
@@ -230,7 +230,7 @@ void Delete_delete_3_of_3(void) {
 
 static
 void CreateEntity(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
     const ecs_entity_t *ids = ecs_bulk_new(it->world, Position, 10);
     test_assert(ids != NULL);
 }
@@ -275,13 +275,13 @@ void Delete_clear_1_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_clear(world, e);
     test_assert(!ecs_get_type(world, e));
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e2 > e);
     
     ecs_fini(world);
@@ -293,14 +293,14 @@ void Delete_clear_2_components(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
     test_assert(e != 0);
 
     ecs_clear(world, e);
     test_assert(!ecs_get_type(world, e));
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e2 > e);
     
     ecs_fini(world);
@@ -311,7 +311,7 @@ void Delete_alive_after_delete(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_is_alive(world, e));
 
@@ -328,7 +328,7 @@ void Delete_alive_after_clear(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_is_alive(world, e));
 
@@ -346,7 +346,7 @@ void Delete_alive_after_staged_delete(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_is_alive(world, e));
 
@@ -365,7 +365,7 @@ void Delete_alive_while_staged(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_is_alive(world, e));
 
@@ -381,7 +381,7 @@ void Delete_alive_while_staged_w_delete(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_is_alive(world, e));
 
@@ -402,12 +402,12 @@ void Delete_alive_while_staged_w_delete_recycled_id(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_is_alive(world, e));
 
     ecs_delete(world, e);
-    e = ecs_new(world, 0);
+    e = ecs_new(world);
     test_assert(ecs_is_alive(world, e));
 
     ecs_defer_begin(world);
@@ -427,7 +427,7 @@ void Delete_alive_after_recycle(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_is_alive(world, e));
 
@@ -435,7 +435,7 @@ void Delete_alive_after_recycle(void) {
     test_assert(!ecs_is_alive(world, e));
     test_assert(ecs_exists(world, e));
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e2 != 0);
     test_assert(ecs_is_alive(world, e2));
     test_assert(e != e2);
@@ -447,12 +447,12 @@ void Delete_alive_after_recycle(void) {
 void Delete_delete_recycled(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_delete(world, e);
     test_assert(!ecs_is_alive(world, e));
     test_assert(ecs_exists(world, e));
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e != e2);
     test_assert((e2 & ECS_ENTITY_MASK) == (e & ECS_ENTITY_MASK));
     test_assert(!ecs_is_alive(world, e));
@@ -468,7 +468,7 @@ void Delete_delete_recycled(void) {
 void Delete_get_alive_for_alive(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_assert(ecs_is_alive(world, e));
     test_assert(ecs_exists(world, e));
@@ -483,14 +483,14 @@ void Delete_get_alive_for_alive(void) {
 void Delete_get_alive_for_recycled(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     
     ecs_delete(world, e);
     test_assert(!ecs_is_alive(world, e));
     test_assert(ecs_exists(world, e));
 
-    e = ecs_new(world, 0);
+    e = ecs_new(world);
     test_assert(ecs_entity_t_lo(e) != e); // Ensure id is recycled
 
     ecs_entity_t a = ecs_get_alive(world, ecs_entity_t_lo(e));
@@ -503,7 +503,7 @@ void Delete_get_alive_for_recycled(void) {
 void Delete_get_alive_for_not_alive(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     
     ecs_delete(world, e);
@@ -522,14 +522,14 @@ void Delete_get_alive_for_not_alive(void) {
 void Delete_get_alive_w_generation_for_recycled_alive(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     
     ecs_delete(world, e);
     test_assert(!ecs_is_alive(world, e));
     test_assert(ecs_exists(world, e));
 
-    e = ecs_new(world, 0);
+    e = ecs_new(world);
     test_assert(ecs_entity_t_lo(e) != e);
 
     ecs_entity_t a = ecs_get_alive(world, e);
@@ -542,14 +542,14 @@ void Delete_get_alive_w_generation_for_recycled_alive(void) {
 void Delete_get_alive_w_generation_for_recycled_not_alive(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     
     ecs_delete(world, e);
     test_assert(!ecs_is_alive(world, e));
     test_assert(ecs_exists(world, e));
 
-    e = ecs_new(world, 0);
+    e = ecs_new(world);
     test_assert(ecs_entity_t_lo(e) != e);
 
     ecs_delete(world, e);
@@ -613,10 +613,10 @@ void Delete_move_w_dtor_move(void) {
         .move = ecs_move(Position),
     });
 
-    ecs_entity_t e_1 = ecs_new_id(world);
+    ecs_entity_t e_1 = ecs_new(world);
     test_assert(e_1 != 0);
 
-    ecs_entity_t e_2 = ecs_new_id(world);
+    ecs_entity_t e_2 = ecs_new(world);
     test_assert(e_2 != 0);
 
 
@@ -659,10 +659,10 @@ void Delete_move_w_dtor_no_move(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t e_1 = ecs_new_id(world);
+    ecs_entity_t e_1 = ecs_new(world);
     test_assert(e_1 != 0);
 
-    ecs_entity_t e_2 = ecs_new_id(world);
+    ecs_entity_t e_2 = ecs_new(world);
     test_assert(e_2 != 0);
 
     ecs_set(world, e_1, Position, {10, 20});
@@ -694,10 +694,10 @@ void Delete_move_w_no_dtor_move(void) {
         .move = ecs_move(Position)
     });
 
-    ecs_entity_t e_1 = ecs_new_id(world);
+    ecs_entity_t e_1 = ecs_new(world);
     test_assert(e_1 != 0);
 
-    ecs_entity_t e_2 = ecs_new_id(world);
+    ecs_entity_t e_2 = ecs_new(world);
     test_assert(e_2 != 0);
 
     ecs_set(world, e_1, Position, {10, 20});
@@ -725,29 +725,29 @@ void Delete_move_w_no_dtor_move(void) {
 void Delete_wrap_generation_count(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t start = ecs_new_id(world);
+    ecs_entity_t start = ecs_new(world);
     ecs_entity_t e = start;
 
     for (int i = 0; i < 65535; i ++) {
         ecs_delete(world, e);
-        e = ecs_new_id(world);
+        e = ecs_new(world);
         test_assert(e != start);
         test_assert((uint32_t)e == start);
     }
 
     ecs_delete(world, e);
-    e = ecs_new_id(world);
+    e = ecs_new(world);
     test_assert(e == start);
 
     for (int i = 0; i < 65535; i ++) {
         ecs_delete(world, e);
-        e = ecs_new_id(world);
+        e = ecs_new(world);
         test_assert(e != start);
         test_assert((uint32_t)e == start);
     }
 
     ecs_delete(world, e);
-    e = ecs_new_id(world);
+    e = ecs_new(world);
     test_assert(e == start);
 
     ecs_fini(world);
diff --git a/test/core/src/Each.c b/test/core/src/Each.c
new file mode 100644
index 000000000..53a3fbea6
--- /dev/null
+++ b/test/core/src/Each.c
@@ -0,0 +1,178 @@
+#include <core.h>
+
+void Each_each_tag(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_add(world, e3, Bar);
+
+    ecs_iter_t it = ecs_each(world, Foo);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(2, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(e2, it.entities[1]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_fini(world);
+}
+
+void Each_each_component(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add(world, e3, Bar);
+
+    ecs_iter_t it = ecs_each(world, Position);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(2, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(e2, it.entities[1]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10); test_int(p[0].y, 20);
+        test_int(p[1].x, 20); test_int(p[1].y, 30);
+    }
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_iter_next(&it));
+    {    
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30); test_int(p[0].y, 40);
+    }
+
+    ecs_fini(world);
+}
+
+void Each_each_pair(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_add(world, e3, Foo);
+    ecs_new_w_pair(world, Rel, TgtB);
+
+    ecs_iter_t it = ecs_each_pair(world, Rel, TgtA);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(2, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(e2, it.entities[1]);
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_fini(world);
+}
+
+void Each_each_pair_rel_wildcard(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_add(world, e3, Foo);
+    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtB);
+
+    ecs_iter_t it = ecs_each_pair(world, Rel, EcsWildcard);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(2, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(e2, it.entities[1]);
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_fini(world);
+}
+
+void Each_each_pair_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, Tgt);
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, Tgt);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, Tgt);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, Tgt);
+    ecs_add(world, e3, Foo);
+    ecs_entity_t e4 = ecs_new_w_pair(world, RelB, Tgt);
+
+    ecs_iter_t it = ecs_each_pair(world, EcsWildcard, Tgt);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(2, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(e2, it.entities[1]);
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_fini(world);
+}
diff --git a/test/api/src/Entity.c b/test/core/src/Entity.c
similarity index 73%
rename from test/api/src/Entity.c
rename to test/core/src/Entity.c
index 300b8d7d6..a878b7833 100644
--- a/test/api/src/Entity.c
+++ b/test/core/src/Entity.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Entity_init_id(void) {
     ecs_world_t *world = ecs_mini();
@@ -50,7 +50,7 @@ void Entity_init_id_add_1_comp(void) {
     ECS_TAG(world, TagA);
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {TagA}
+        .add = ecs_ids(TagA)
     });
     test_assert(e != 0);
     test_assert(ecs_has(world, e, TagA));
@@ -65,7 +65,7 @@ void Entity_init_id_add_2_comp(void) {
     ECS_TAG(world, TagB);
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {TagA, TagB}
+        .add = ecs_ids(TagA, TagB)
     });
     test_assert(e != 0);
     test_assert(ecs_has(world, e, TagA));
@@ -77,7 +77,7 @@ void Entity_init_id_add_2_comp(void) {
 void Entity_init_id_w_scope(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t scope = ecs_new_id(world);
+    ecs_entity_t scope = ecs_new(world);
     test_assert(scope != 0);
 
     ecs_set_scope(world, scope);
@@ -217,7 +217,7 @@ void Entity_init_id_name_1_comp(void) {
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "foo",
-        .add = {TagA}
+        .add = ecs_ids(TagA)
     });
     test_assert(e != 0);
     test_assert(ecs_has_id(world, e, TagA));
@@ -239,7 +239,7 @@ void Entity_init_id_name_2_comp(void) {
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "foo",
-        .add = {TagA, TagB}
+        .add = ecs_ids(TagA, TagB)
     });
     test_assert(e != 0);
     test_assert(ecs_has_id(world, e, TagA));
@@ -270,7 +270,7 @@ void Entity_init_id_name_2_comp_w_scope(void) {
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "child",
-        .add = {TagA, TagB}
+        .add = ecs_ids(TagA, TagB)
     });
     test_assert(e != 0);
     test_assert(ecs_has_id(world, e, TagA));
@@ -289,12 +289,12 @@ void Entity_id_add_1_comp(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_entity_t r = ecs_entity_init(world, &(ecs_entity_desc_t){
         .id = e,
-        .add = {TagA}
+        .add = ecs_ids(TagA)
     });
     test_assert(r != 0);
     test_assert(e == r);
@@ -309,12 +309,12 @@ void Entity_id_add_2_comp(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_entity_t r = ecs_entity_init(world, &(ecs_entity_desc_t){
         .id = e,
-        .add = {TagA, TagB}
+        .add = ecs_ids(TagA, TagB)
     });
     test_assert(r != 0);
     test_assert(e == r);
@@ -363,7 +363,7 @@ void Entity_find_id_name(void) {
 void Entity_find_w_existing_id_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
         .id = id,
@@ -705,7 +705,7 @@ void Entity_find_id_add_1_comp(void) {
 
     ecs_entity_t r = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "foo",
-        .add = {TagA}
+        .add = ecs_ids(TagA)
     });
     test_assert(r == e);
     test_assert(ecs_has_id(world, e, TagA));
@@ -727,7 +727,7 @@ void Entity_find_id_add_2_comp(void) {
 
     ecs_entity_t r = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "foo",
-        .add = {TagA, TagB}
+        .add = ecs_ids(TagA, TagB)
     });
     test_assert(r == e);
     test_assert(ecs_has_id(world, e, TagA));
@@ -817,7 +817,7 @@ void Entity_init_w_with_w_scope(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
 
     ecs_set_with(world, Tag);
     ecs_set_scope(world, parent);
@@ -838,7 +838,7 @@ void Entity_init_w_with_w_name_scope(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
 
     ecs_set_with(world, Tag);
     ecs_set_scope(world, parent);
@@ -861,7 +861,7 @@ void Entity_init_w_with_w_name_scope(void) {
 void Entity_is_valid(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_bool(ecs_is_valid(world, e), true);
 
@@ -871,14 +871,14 @@ void Entity_is_valid(void) {
 void Entity_is_recycled_valid(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_bool(ecs_is_valid(world, e), true);
 
     ecs_delete(world, e);
     test_bool(ecs_is_valid(world, e), false);
 
-    e = ecs_new_id(world);
+    e = ecs_new(world);
     test_assert(e != 0);
     test_assert((uint32_t)e != e);
     test_bool(ecs_is_valid(world, e), true);
@@ -915,7 +915,7 @@ void Entity_is_junk_valid(void) {
 void Entity_is_not_alive_valid(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_bool(ecs_is_valid(world, e), true);
     test_bool(ecs_is_alive(world, e), true);
@@ -1042,13 +1042,13 @@ void Entity_init_w_childof_name_twice_deferred(void) {
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Bar",
-        .add = {ecs_pair(EcsChildOf, parent)}
+        .parent = parent
     });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Bar",
-        .add = {ecs_pair(EcsChildOf, parent)}
+        .parent = parent
     });
     test_assert(e2 != 0);
 
@@ -1076,13 +1076,13 @@ void Entity_init_w_childof_nested_name_twice_deferred(void) {
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Bar.Hello",
-        .add = {ecs_pair(EcsChildOf, parent)}
+        .parent = parent
     });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Bar.Hello",
-        .add = {ecs_pair(EcsChildOf, parent)}
+        .parent = parent
     });
     test_assert(e2 != 0);
 
@@ -1126,7 +1126,7 @@ void Entity_init_w_name_staged(void) {
 void Entity_record_find_for_empty(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_record_t *r = ecs_record_find(world, e);
@@ -1141,7 +1141,7 @@ void Entity_record_find(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     ecs_record_t *r = ecs_record_find(world, e);
@@ -1156,7 +1156,7 @@ void Entity_record_find_from_stage(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     ecs_readonly_begin(world, false);
@@ -1208,7 +1208,7 @@ void Entity_make_alive_nonzero_gen(void) {
 void Entity_make_alive_zero_gen_exists(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_delete(world, e);
     test_assert(ecs_exists(world, e));
     test_assert(!ecs_is_valid(world, e));
@@ -1225,7 +1225,7 @@ void Entity_make_alive_zero_gen_exists(void) {
 void Entity_make_alive_nonzero_gen_exists(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_delete(world, e);
     test_assert(ecs_exists(world, e));
     test_assert(!ecs_is_valid(world, e));
@@ -1250,14 +1250,14 @@ void Entity_make_alive_zero_gen_exists_alive(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_delete(world, e);
     test_assert(ecs_exists(world, e));
     test_assert(!ecs_is_valid(world, e));
     test_assert(!ecs_is_alive(world, e));
     ecs_delete(world, e);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != e);
     test_assert(ecs_strip_generation(e1) == e);
 
@@ -1270,14 +1270,14 @@ void Entity_make_alive_nonzero_gen_exists_alive(void) {
     
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_delete(world, e);
     test_assert(ecs_exists(world, e));
     test_assert(!ecs_is_valid(world, e));
     test_assert(!ecs_is_alive(world, e));
     ecs_delete(world, e);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != e);
     test_assert(ecs_strip_generation(e1) == e);
 
@@ -1346,11 +1346,11 @@ void Entity_entity_init_w_childof_twice(void) {
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Child",
-        .add = { ecs_childof(parent) }
+        .parent = parent
     });
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Child",
-        .add = { ecs_childof(parent) }
+        .parent = parent
     });
 
     test_assert( ecs_has_pair(world, e1, EcsChildOf, parent) );
@@ -1372,11 +1372,11 @@ void Entity_entity_init_w_childof_nested_name_twice(void) {
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Foo.Child",
-        .add = { ecs_childof(parent) }
+        .parent = parent
     });
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Foo.Child",
-        .add = { ecs_childof(parent) }
+        .parent = parent
     });
 
     ecs_entity_t foo = ecs_lookup_child(world, parent, "Foo");
@@ -1403,7 +1403,7 @@ void Entity_entity_init_w_childof_and_scope(void) {
     ecs_set_scope(world, parent_a);
     ecs_entity_t child = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Child",
-        .add = { ecs_childof(parent_b) }
+        .parent = parent_b
     });
     ecs_set_scope(world, 0);
 
@@ -1427,7 +1427,7 @@ void Entity_entity_init_w_childof_and_scope_and_scoped_name(void) {
     ecs_set_scope(world, parent_a);
     ecs_entity_t grand_child = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Child.GrandChild",
-        .add = { ecs_childof(parent_b) }
+        .parent = parent_b
     });
     ecs_set_scope(world, 0);
 
@@ -1449,10 +1449,10 @@ void Entity_entity_init_w_childof_and_scope_and_scoped_name(void) {
 void Entity_entity_init_w_childof_and_no_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
 
     ecs_entity_t child = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = { ecs_pair(EcsChildOf, parent) }
+        .parent = parent
     });
 
     test_assert(child != 0);
@@ -1472,7 +1472,7 @@ void Entity_deferred_entity_init_w_childof_and_scope(void) {
     ecs_set_scope(world, parent_a);
     ecs_entity_t child = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Child",
-        .add = { ecs_childof(parent_b) }
+        .parent = parent_b
     });
     ecs_set_scope(world, 0);
 
@@ -1500,7 +1500,7 @@ void Entity_deferred_entity_init_w_childof_and_scope_and_scoped_name(void) {
     ecs_set_scope(world, parent_a);
     ecs_entity_t grand_child = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Child.GrandChild",
-        .add = { ecs_childof(parent_b) }
+        .parent = parent_b
     });
     ecs_set_scope(world, 0);
 
@@ -1524,11 +1524,11 @@ void Entity_deferred_entity_init_w_childof_and_scope_and_scoped_name(void) {
 void Entity_deferred_entity_init_w_childof_and_no_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_entity_t child = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = { ecs_pair(EcsChildOf, parent) }
+        .parent = parent
     });
     test_assert(child != 0);
     test_assert(!ecs_has_pair(world, child, EcsChildOf, parent));
@@ -1580,8 +1580,8 @@ void Entity_set_name_w_0_twice(void) {
 void Entity_new_entity_twice(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Foo");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Foo" });
 
     test_str(ecs_get_name(world, e1), "Foo");
     test_assert(e1 == e2);
@@ -1592,8 +1592,8 @@ void Entity_new_entity_twice(void) {
 void Entity_new_entity_scoped_twice(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo.Bar");
-    ecs_entity_t e2 = ecs_new_entity(world, "Foo.Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo.Bar" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Foo.Bar" });
 
     test_str(ecs_get_name(world, e1), "Bar");
     test_assert(e1 == e2);
@@ -1722,10 +1722,10 @@ void Entity_staged_set_symbol_n_stages(void) {
 void Entity_entity_init_w_add_childof_no_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = { ecs_childof(parent) }
+        .parent = parent
     });
 
     test_assert( ecs_has_pair(world, e, EcsChildOf, parent));
@@ -1743,7 +1743,6 @@ void Entity_entity_w_short_notation(void) {
     ecs_fini(world);
 }
 
-
 void Entity_override_inherited_symbol(void) {
     ecs_world_t *world = ecs_mini();
     
@@ -1756,7 +1755,7 @@ void Entity_override_inherited_symbol(void) {
     ecs_entity_t Bar = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "Bar",
         .symbol = "BarSymbol",
-        .add = { ecs_pair(EcsIsA, Foo) }
+        .parent = EcsIsA
     });
     test_assert(Bar != 0);
 
@@ -1781,7 +1780,7 @@ void Entity_use_low_id_for_component(void) {
 void Entity_get_depth(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, e2);
     ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, e3);
@@ -1800,7 +1799,7 @@ void Entity_get_depth_non_acyclic(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     test_expect_abort();
     ecs_get_depth(world, e1, Rel);
@@ -1809,7 +1808,7 @@ void Entity_get_depth_non_acyclic(void) {
 void Entity_get_depth_empty(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     test_int(0, ecs_get_depth(world, e1, EcsChildOf));
 
     ecs_fini(world);
@@ -1818,7 +1817,7 @@ void Entity_get_depth_empty(void) {
 void Entity_get_depth_2_paths(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
     ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, e2);
@@ -1853,7 +1852,7 @@ void Entity_entity_init_w_empty_sep(void) {
 void Entity_entity_init_w_empty_sep_from_scope(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     ecs_set_scope(world, parent);
     ecs_entity_t child = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "foo.bar",
@@ -1875,7 +1874,7 @@ void Entity_entity_init_w_empty_sep_from_scope(void) {
 void Entity_entity_init_w_empty_sep_w_prefix(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     ecs_entity_t child = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = "foo.bar",
         .sep = ""
@@ -1895,7 +1894,7 @@ void Entity_entity_init_w_empty_sep_w_prefix(void) {
 void Entity_set_name_w_same_ptr(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     const char *name = ecs_get_name(world, e);
     test_assert(name != NULL);
     test_str(name, "foo");
@@ -1911,7 +1910,7 @@ void Entity_set_name_w_same_ptr(void) {
 void Entity_set_name_w_overlapping_ptr(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     const char *name = ecs_get_name(world, e);
     test_assert(name != NULL);
     test_str(name, "foo");
@@ -1927,7 +1926,7 @@ void Entity_set_name_w_overlapping_ptr(void) {
 void Entity_defer_set_name_w_overlapping_ptr(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     const char *name = ecs_get_name(world, e);
     test_assert(name != NULL);
     test_str(name, "foo");
@@ -1957,9 +1956,9 @@ void Entity_make_alive_from_stage(void) {
 void Entity_make_alive_after_deleted_1_entity(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_delete(world, e1);
-    e1 = ecs_new_id(world);
+    e1 = ecs_new(world);
     ecs_delete(world, e1);
 
     test_assert(!ecs_is_alive(world, e1));
@@ -1972,10 +1971,10 @@ void Entity_make_alive_after_deleted_1_entity(void) {
 void Entity_make_alive_after_deleted_2_entities(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_delete(world, e1);
-    e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_delete(world, e1);
     ecs_delete(world, e2);
 
@@ -1993,8 +1992,8 @@ void Entity_make_alive_after_deleted_2_entities(void) {
 void Entity_defer_entity_init_w_set_name_w_add_childof(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
 
     ecs_defer_begin(world);
     ecs_entity(world, { .id = e, .name = "Foo" });
@@ -2063,9 +2062,9 @@ void Entity_set_generation_on_nonempty_entity(void) {
     ecs_add(world, e1, Tag);
 
     e1 |= 0x200000000ul;
-    ecs_set_entity_generation(world, e1);
+    ecs_set_generation(world, e1);
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ .id = Tag });
+    ecs_iter_t it = ecs_each(world, Tag);
     ecs_entity_t first = ecs_iter_first(&it);
     test_uint(first, e1);
 
@@ -2076,11 +2075,11 @@ void Entity_set_generation_while_deferred(void) {
     install_test_abort();
 
     ecs_world_t* world = ecs_mini();
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     ecs_defer_begin(world);    
     test_expect_abort();
-    ecs_set_entity_generation(world, e1 |= 0x200000000ul);
+    ecs_set_generation(world, e1 |= 0x200000000ul);
 }
 
 static
@@ -2097,7 +2096,7 @@ void Entity_commit_w_on_add(void) {
     int invoked = 0;
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = Tag }
         },
         .events = { EcsOnAdd },
@@ -2113,7 +2112,7 @@ void Entity_commit_w_on_add(void) {
         .count = 1
     };
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_commit(world, e, NULL, dst, &added, NULL);
 
     test_assert(ecs_has(world, e, Tag));
@@ -2131,7 +2130,7 @@ void Entity_commit_w_on_remove(void) {
     int invoked = 0;
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = Tag }
         },
         .events = { EcsOnRemove },
@@ -2147,7 +2146,7 @@ void Entity_commit_w_on_remove(void) {
     ecs_table_t *dst = ecs_table_add_id(world, NULL, Foo);
     test_assert(dst != NULL);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
     ecs_add_id(world, e, Foo);
     ecs_commit(world, e, NULL, dst, NULL, &removed);
 
@@ -2183,7 +2182,7 @@ void Entity_commit_w_cmd_in_observer(void) {
     int invoked = 0;
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = Tag }
         },
         .events = { EcsOnAdd },
@@ -2199,7 +2198,7 @@ void Entity_commit_w_cmd_in_observer(void) {
         .count = 1
     };
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_commit(world, e, NULL, dst, &added, NULL);
 
     test_assert(ecs_has(world, e, Tag));
@@ -2228,3 +2227,708 @@ void Entity_entity_init_existing_no_sep(void) {
 
     ecs_fini(world);
 }
+
+void Entity_entity_init_w_set_1_comp(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    test_assert(e != 0);
+    test_assert(ecs_has(world, e, Position));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_2_comp(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .set = ecs_values( 
+            ecs_value(Position, {10, 20}),
+            ecs_value(Velocity, {1, 2})
+        )
+    });
+
+    test_assert(e != 0);
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, Velocity));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    const Velocity *v = ecs_get(world, e, Velocity);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_1_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .add = ecs_ids(TagA),
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    test_assert(e != 0);
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, TagA));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_2_comp_2_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .add = ecs_ids(TagA, TagB),
+        .set = ecs_values(
+            ecs_value(Position, {10, 20}),
+            ecs_value(Velocity, {1, 2})
+        )
+    });
+
+    test_assert(e != 0);
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, Velocity));
+    test_assert(ecs_has(world, e, TagA));
+    test_assert(ecs_has(world, e, TagB));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    const Velocity *v = ecs_get(world, e, Velocity);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_w_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .name = "Foo",
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    test_assert(e != 0);
+    test_assert(ecs_has(world, e, Position));
+    test_str(ecs_get_name(world, e), "Foo");
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_existing(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e1 = ecs_entity(world, {
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    ecs_entity_t e2 = ecs_entity(world, {
+        .id = e1,
+        .set = ecs_values( ecs_value(Velocity, {1, 2}) )
+    });
+
+    test_assert(e1 == e2);
+    test_assert(ecs_has(world, e1, Position));
+    test_assert(ecs_has(world, e1, Velocity));
+
+    const Position *p = ecs_get(world, e1, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    const Velocity *v = ecs_get(world, e1, Velocity);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_existing_empty(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_entity(world, {
+        .id = e1,
+        .set = ecs_values( ecs_value(Velocity, {1, 2}) )
+    });
+
+    test_assert(e1 == e2);
+    test_assert(ecs_has(world, e1, Velocity));
+
+    const Velocity *v = ecs_get(world, e1, Velocity);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+static int add_position_invoked = 0;
+static int set_position_invoked = 0;
+
+static void add_position_hook(ecs_iter_t *it) {
+    add_position_invoked ++;
+}
+
+static void set_position_hook(ecs_iter_t *it) {
+    set_position_invoked ++;
+}
+
+void Entity_entity_init_w_set_w_hook(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_set_hooks(world, Position, {
+        .on_add = add_position_hook,
+        .on_set = set_position_hook
+    });
+
+    ecs_entity_t e = ecs_entity(world, {
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    test_assert(e != 0);
+    test_assert(ecs_has(world, e, Position));
+    test_int(add_position_invoked, 1);
+    test_int(set_position_invoked, 1);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_w_observer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_observer(world, {
+        .query.terms = {{ ecs_id(Position) }},
+        .events = { EcsOnAdd },
+        .callback = add_position_hook
+    });
+
+    ecs_observer(world, {
+        .query.terms = {{ ecs_id(Position) }},
+        .events = { EcsOnSet },
+        .callback = set_position_hook
+    });
+
+    ecs_entity_t e = ecs_entity(world, {
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    test_assert(e != 0);
+    test_assert(ecs_has(world, e, Position));
+    test_int(add_position_invoked, 1);
+    test_int(set_position_invoked, 1);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_1_tag_w_set(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .set = ecs_values( ecs_value(Position, {10, 20}), {TagA} )
+    });
+
+    test_assert(e != 0);
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, TagA));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_defer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_defer_begin(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    test_assert(e != 0);
+    test_assert(!ecs_has(world, e, Position));
+    
+    ecs_defer_end(world);
+
+    test_assert(ecs_has(world, e, Position));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_2_comp_defer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_defer_begin(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .set = ecs_values( 
+            ecs_value(Position, {10, 20}),
+            ecs_value(Velocity, {1, 2})
+        )
+    });
+
+    test_assert(e != 0);
+    test_assert(!ecs_has(world, e, Position));
+    test_assert(!ecs_has(world, e, Velocity));
+
+    ecs_defer_end(world);
+
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, Velocity));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    const Velocity *v = ecs_get(world, e, Velocity);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_1_tag_defer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_defer_begin(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .add = ecs_ids(TagA),
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    test_assert(e != 0);
+    test_assert(!ecs_has(world, e, Position));
+    test_assert(!ecs_has(world, e, TagA));
+
+    ecs_defer_end(world);
+
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, TagA));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_2_comp_2_tag_defer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_defer_begin(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .add = ecs_ids(TagA, TagB),
+        .set = ecs_values(
+            ecs_value(Position, {10, 20}),
+            ecs_value(Velocity, {1, 2})
+        )
+    });
+
+    test_assert(e != 0);
+    
+    test_assert(!ecs_has(world, e, Position));
+    test_assert(!ecs_has(world, e, Velocity));
+    test_assert(!ecs_has(world, e, TagA));
+    test_assert(!ecs_has(world, e, TagB));
+
+    ecs_defer_end(world);
+
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, Velocity));
+    test_assert(ecs_has(world, e, TagA));
+    test_assert(ecs_has(world, e, TagB));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    const Velocity *v = ecs_get(world, e, Velocity);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_w_name_defer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_defer_begin(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .name = "Foo",
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    test_assert(e != 0);
+
+    test_assert(!ecs_has(world, e, Position));
+    test_str(ecs_get_name(world, e), "Foo");
+
+    ecs_defer_end(world);
+
+    test_assert(ecs_has(world, e, Position));
+    test_str(ecs_get_name(world, e), "Foo");
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_existing_defer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_defer_begin(world);
+
+    ecs_entity_t e1 = ecs_entity(world, {
+        .set = ecs_values( ecs_value(Position, {10, 20}) )
+    });
+
+    ecs_entity_t e2 = ecs_entity(world, {
+        .id = e1,
+        .set = ecs_values( ecs_value(Velocity, {1, 2}) )
+    });
+
+    test_assert(e1 == e2);
+    test_assert(!ecs_has(world, e1, Position));
+    test_assert(!ecs_has(world, e1, Velocity));
+
+    ecs_defer_end(world);
+
+    test_assert(ecs_has(world, e1, Position));
+    test_assert(ecs_has(world, e1, Velocity));
+
+    const Position *p = ecs_get(world, e1, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    const Velocity *v = ecs_get(world, e1, Velocity);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_existing_empty_defer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_defer_begin(world);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_entity(world, {
+        .id = e1,
+        .set = ecs_values( ecs_value(Velocity, {1, 2}) )
+    });
+
+    test_assert(e1 == e2);
+    test_assert(!ecs_has(world, e1, Velocity));
+
+    ecs_defer_end(world);
+
+    test_assert(ecs_has(world, e1, Velocity));
+
+    const Velocity *v = ecs_get(world, e1, Velocity);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_init_w_set_1_comp_1_tag_w_set_defer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_defer_begin(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .set = ecs_values( ecs_value(Position, {10, 20}), {TagA} )
+    });
+
+    test_assert(e != 0);
+
+    test_assert(!ecs_has(world, e, Position));
+    test_assert(!ecs_has(world, e, TagA));
+
+    ecs_defer_end(world);
+
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, TagA));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_insert_1_comp(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
+    test_assert(e != 0);
+    test_assert(ecs_has(world, e, Position));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_insert_2_comp(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e = ecs_insert(world, 
+        ecs_value(Position, {10, 20}),
+        ecs_value(Velocity, {1, 2})
+    );
+    
+    test_assert(e != 0);
+
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, Velocity));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    const Velocity *v = ecs_get(world, e, Velocity);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+void Entity_insert_1_comp_1_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e = ecs_insert(world, 
+        ecs_value(Position, {10, 20}),
+        {TagA}
+    );
+    
+    test_assert(e != 0);
+
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, TagA));
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    ecs_fini(world);
+}
+
+void Entity_entity_w_parent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t parent = ecs_new(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .parent = parent
+    });
+    
+    test_assert(e != 0);
+
+    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+
+    ecs_fini(world);
+}
+
+void Entity_entity_w_parent_w_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t parent = ecs_new(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .parent = parent,
+        .name = "Foo"
+    });
+    
+    test_assert(e != 0);
+
+    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+    test_str(ecs_get_name(world, e), "Foo");
+
+    ecs_fini(world);
+}
+
+void Entity_entity_w_parent_w_add(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t parent = ecs_new(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .parent = parent,
+        .add = (ecs_id_t[]){TagA, 0}
+    });
+    
+    test_assert(e != 0);
+
+    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+    test_assert(ecs_has(world, e, TagA));
+
+    ecs_fini(world);
+}
+
+void Entity_entity_w_parent_w_add_w_parent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t parent = ecs_new(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .parent = parent,
+        .name = "Foo",
+        .add = (ecs_id_t[]){TagA, 0}
+    });
+    
+    test_assert(e != 0);
+
+    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+    test_assert(ecs_has(world, e, TagA));
+    test_str(ecs_get_name(world, e), "Foo");
+
+    ecs_fini(world);
+}
+
+void Entity_entity_w_parent_w_set(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t parent = ecs_new(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .parent = parent,
+        .set = (ecs_value_t[]){{ .type = TagA}, {0}}
+    });
+    
+    test_assert(e != 0);
+
+    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+    test_assert(ecs_has(world, e, TagA));
+
+    ecs_fini(world);
+}
+
+void Entity_entity_w_parent_w_set_w_parent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t parent = ecs_new(world);
+
+    ecs_entity_t e = ecs_entity(world, {
+        .parent = parent,
+        .name = "Foo",
+        .set = (ecs_value_t[]){{ .type = TagA}, {0}}
+    });
+    
+    test_assert(e != 0);
+
+    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+    test_assert(ecs_has(world, e, TagA));
+    test_str(ecs_get_name(world, e), "Foo");
+
+    ecs_fini(world);
+}
diff --git a/test/api/src/Error.c b/test/core/src/Error.c
similarity index 99%
rename from test/api/src/Error.c
rename to test/core/src/Error.c
index 68ffc4e26..0f83ff024 100644
--- a/test/api/src/Error.c
+++ b/test/core/src/Error.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 #include <stdlib.h>
 
 void Error_setup(void) {
diff --git a/test/api/src/Event.c b/test/core/src/Event.c
similarity index 85%
rename from test/api/src/Event.c
rename to test/core/src/Event.c
index e9d0029fa..79c9dcb81 100644
--- a/test/api/src/Event.c
+++ b/test/core/src/Event.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static
 void system_callback(ecs_iter_t *it) {
@@ -20,15 +20,15 @@ void system_w_param_callback(ecs_iter_t *it) {
 void Event_table_1_id_w_trigger(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
     ecs_table_t *table = ecs_get_table(world, e);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -54,9 +54,9 @@ void Event_table_1_id_w_trigger(void) {
 void Event_table_2_ids_w_trigger(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id_a = ecs_new_id(world);
-    ecs_entity_t id_b = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id_a = ecs_new(world);
+    ecs_entity_t id_b = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id_a);
     ecs_add_id(world, e, id_b);
     ecs_table_t *table = ecs_get_table(world, e);
@@ -64,7 +64,7 @@ void Event_table_2_ids_w_trigger(void) {
     Probe ctx = {0};
 
     ecs_entity_t s_a = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id_a,
+        .query.terms[0].id = id_a,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx,
@@ -87,7 +87,7 @@ void Event_table_2_ids_w_trigger(void) {
     ecs_delete(world, s_a);
 
     ecs_entity_t s_b = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id_b,
+        .query.terms[0].id = id_b,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -115,15 +115,15 @@ void Event_table_2_ids_w_trigger(void) {
 void Event_table_1_id_w_observer(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
     ecs_table_t *table = ecs_get_table(world, e);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ id }},
+        .query.terms = {{ id }},
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -149,9 +149,9 @@ void Event_table_1_id_w_observer(void) {
 void Event_table_2_ids_w_observer(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id_a = ecs_new_id(world);
-    ecs_entity_t id_b = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id_a = ecs_new(world);
+    ecs_entity_t id_b = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id_a);
     ecs_add_id(world, e, id_b);
     ecs_table_t *table = ecs_get_table(world, e);
@@ -159,7 +159,7 @@ void Event_table_2_ids_w_observer(void) {
     Probe ctx = {0};
 
     ecs_entity_t s_a = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ id_a }},
+        .query.terms = {{ id_a }},
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -196,14 +196,14 @@ void Event_emit_event_for_empty_table(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t evt = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     ecs_table_t *table = ecs_get_table(world, e);
     ecs_delete(world, e);
 
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }},
+        .query.terms = {{ TagA }},
         .events = {evt},
         .callback = empty_table_callback,
         .ctx = table
@@ -231,25 +231,26 @@ void Event_emit_table_event(void) {
     ecs_entity_t base = ecs_new_w_id(world, TagA);
     ecs_table_t *base_table = ecs_get_table(world, base);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base);
 
     Probe ctx_a = {0};
     Probe ctx_b = {0};
 
-    ecs_entity_t evt = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].src.flags = EcsSelf,
+        .query.terms[0].id = TagA,
+        .query.terms[0].src.id = EcsSelf,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx_a
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].src.flags = EcsUp,
+        .query.terms[0].id = TagA,
+        .query.terms[0].src.id = EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx_b
@@ -282,15 +283,15 @@ void Event_emit_table_event(void) {
 void Event_emit_staged_from_world(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
     ecs_table_t *table = ecs_get_table(world, e);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -317,15 +318,15 @@ void Event_emit_staged_from_world(void) {
 void Event_emit_staged_from_stage(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
     ecs_table_t *table = ecs_get_table(world, e);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -353,15 +354,15 @@ void Event_emit_staged_from_stage(void) {
 void Event_emit_staged_from_world_observer(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
     ecs_table_t *table = ecs_get_table(world, e);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ id }},
+        .query.terms = {{ id }},
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -388,15 +389,15 @@ void Event_emit_staged_from_world_observer(void) {
 void Event_emit_staged_from_stage_observer(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
     ecs_table_t *table = ecs_get_table(world, e);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ id }},
+        .query.terms = {{ id }},
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -426,14 +427,14 @@ void Event_emit_staged_from_stage_observer(void) {
 void Event_emit_for_entity(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -470,19 +471,19 @@ void Event_emit_custom_for_any(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t MyEvent = ecs_new_id(world);
+    ecs_entity_t MyEvent = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAny, .src.id = e1 }},
+        .query.terms = {{ .id = EcsAny, .src.id = e1 }},
         .events = {MyEvent},
         .callback = ObserverA
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAny, .src.id = e2 }},
+        .query.terms = {{ .id = EcsAny, .src.id = e2 }},
         .events = {MyEvent},
         .callback = ObserverB
     });
@@ -513,19 +514,19 @@ void Event_emit_custom_implicit_any(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t MyEvent = ecs_new_id(world);
+    ecs_entity_t MyEvent = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAny, .src.id = e1 }},
+        .query.terms = {{ .id = EcsAny, .src.id = e1 }},
         .events = {MyEvent},
         .callback = ObserverA
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAny, .src.id = e2 }},
+        .query.terms = {{ .id = EcsAny, .src.id = e2 }},
         .events = {MyEvent},
         .callback = ObserverB
     });
@@ -554,19 +555,19 @@ void Event_emit_custom_empty_type(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t MyEvent = ecs_new_id(world);
+    ecs_entity_t MyEvent = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAny, .src.id = e1 }},
+        .query.terms = {{ .id = EcsAny, .src.id = e1 }},
         .events = {MyEvent},
         .callback = ObserverA
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAny, .src.id = e2 }},
+        .query.terms = {{ .id = EcsAny, .src.id = e2 }},
         .events = {MyEvent},
         .callback = ObserverB
     });
@@ -595,16 +596,54 @@ void Event_emit_custom_empty_type(void) {
 void Event_emit_w_param(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Position); /* Used as event type */
     
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
+        .events = {ecs_id(Position)},
+        .callback = system_w_param_callback,
+        .ctx = &ctx
+    });
+
+    ecs_emit(world, &(ecs_event_desc_t){
+        .event = ecs_id(Position),
+        .ids = &(ecs_type_t){.count = 1, .array = (ecs_id_t[]){ id }},
+        .entity = e,
+        .param = &p
+    });
+
+    test_int(ctx.invoked, 1);
+    test_assert(ctx.system == s);
+    test_assert(ctx.event == ecs_id(Position));
+    test_assert(ctx.event_id == id);
+    test_int(ctx.count, 1);
+    test_assert(ctx.e[0] == e);
+    test_assert(system_param == &p);
+
+    ecs_fini(world);
+}
+
+void Event_emit_w_param_multi_observer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position); /* Used as event type */
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t id = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_id(world, id);
+    ecs_add(world, e, Foo);
+
+    Probe ctx = {0};
+    Position p = {10, 20};
+
+    ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
+        .query.terms = {{ id }, { Foo }},
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
@@ -633,14 +672,14 @@ void Event_emit_w_const_param(void) {
 
     ECS_COMPONENT(world, Position);
     
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
@@ -697,8 +736,8 @@ void Event_emit_nested(void) {
     int ctx_1 = 0;
     int ctx_2 = 0;
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    other = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    other = ecs_new(world);
 
     ecs_add(world, e1, Foo);
     ecs_add(world, e1, Bar);
@@ -707,7 +746,7 @@ void Event_emit_nested(void) {
 
     ecs_observer(world, {
         .entity = ecs_entity(world, { .name = "o1" }),
-        .filter.terms = {{ Foo }, { Bar }},
+        .query.terms = {{ Foo }, { Bar }},
         .events = { Event },
         .ctx = &ctx_1,
         .callback = Nested1
@@ -715,7 +754,7 @@ void Event_emit_nested(void) {
 
     ecs_observer(world, {
         .entity = ecs_entity(world, { .name = "o2" }),
-        .filter.terms = {{ Foo }, { Bar }},
+        .query.terms = {{ Foo }, { Bar }},
         .events = { Event },
         .ctx = &ctx_2,
         .callback = Nested2
@@ -737,14 +776,14 @@ void Event_emit_nested(void) {
 void Event_enqueue_event_1_id(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -775,9 +814,9 @@ void Event_enqueue_event_1_id(void) {
 void Event_enqueue_event_2_ids(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id_a = ecs_new_id(world);
-    ecs_entity_t id_b = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id_a = ecs_new(world);
+    ecs_entity_t id_b = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id_a);
     ecs_add_id(world, e, id_b);
 
@@ -785,14 +824,14 @@ void Event_enqueue_event_2_ids(void) {
     Probe *ctx_b = ecs_os_calloc_t(Probe);
 
     ecs_entity_t s_a = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id_a,
+        .query.terms[0].id = id_a,
         .events = {evt},
         .callback = system_callback,
         .ctx = ctx_a
     });
 
     ecs_entity_t s_b = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id_b,
+        .query.terms[0].id = id_b,
         .events = {evt},
         .callback = system_callback,
         .ctx = ctx_b
@@ -836,14 +875,14 @@ void Event_enqueue_event_w_data(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
@@ -905,14 +944,14 @@ void Event_enqueue_event_w_data_move(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
@@ -958,14 +997,14 @@ void Event_enqueue_event_w_data_copy(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
@@ -1006,14 +1045,14 @@ void Event_enqueue_event_w_const_data_no_copy(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
@@ -1050,14 +1089,14 @@ void Event_enqueue_event_w_const_data_no_copy(void) {
 void Event_enqueue_event_not_alive(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -1093,14 +1132,14 @@ void Event_enqueue_event_not_alive_w_data_move(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
@@ -1137,14 +1176,14 @@ void Event_enqueue_event_not_alive_w_data_copy(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
@@ -1182,22 +1221,22 @@ void system_delete_callback(ecs_iter_t *it) {
 void Event_enqueue_event_not_alive_after_delete_during_merge(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t delete_evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t delete_evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {delete_evt},
         .callback = system_delete_callback,
     });
@@ -1236,22 +1275,22 @@ void Event_enqueue_event_not_alive_w_data_move_after_delete_during_merge(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t delete_evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t delete_evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {delete_evt},
         .callback = system_delete_callback,
     });
@@ -1294,22 +1333,22 @@ void Event_enqueue_event_not_alive_w_data_copy_after_delete_during_merge(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t delete_evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t delete_evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
     Position p = {10, 20};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {ecs_id(Position)},
         .callback = system_w_param_callback,
         .ctx = &ctx
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {delete_evt},
         .callback = system_delete_callback,
     });
@@ -1348,8 +1387,8 @@ void Event_enqueue_event_not_deferred(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     test_expect_abort();
@@ -1364,20 +1403,20 @@ void Event_enqueue_event_not_deferred(void) {
 void Event_enqueue_event_not_deferred_to_async(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
     });
 
-    ecs_world_t *my_stage = ecs_async_stage_new(world);
+    ecs_world_t *my_stage = ecs_stage_new(world);
 
     ecs_enqueue(my_stage, &(ecs_event_desc_t){
         .event = evt,
@@ -1396,7 +1435,7 @@ void Event_enqueue_event_not_deferred_to_async(void) {
     test_int(ctx.count, 1);
     test_assert(ctx.e[0] == e);
 
-    ecs_async_stage_free(my_stage);
+    ecs_stage_free(my_stage);
 
     ecs_fini(world);
 }
@@ -1406,19 +1445,19 @@ void Event_enqueue_custom_implicit_any(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t MyEvent = ecs_new_id(world);
+    ecs_entity_t MyEvent = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAny, .src.id = e1 }},
+        .query.terms = {{ .id = EcsAny, .src.id = e1 }},
         .events = {MyEvent},
         .callback = ObserverA
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ .id = EcsAny, .src.id = e2 }},
+        .query.terms = {{ .id = EcsAny, .src.id = e2 }},
         .events = {MyEvent},
         .callback = ObserverB
     });
@@ -1479,7 +1518,7 @@ void Event_enqueue_custom_after_large_cmd(void) {
     ECS_OBSERVER(world, OnPosition, ecs_id(Position), LargeType);
 
     ecs_defer_begin(world);
-    ecs_entity_t e = ecs_set(world, 0, LargeType, {{0}});
+    ecs_entity_t e = ecs_insert(world, ecs_value(LargeType, {{0}}));
     ecs_defer_end(world);
     test_assert(ecs_has(world, e, LargeType));
 
@@ -1502,14 +1541,14 @@ void Event_enqueue_custom_after_large_cmd(void) {
 void Event_enqueue_on_readonly_world(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t evt = ecs_new_id(world);
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t evt = ecs_new(world);
+    ecs_entity_t id = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, id);
 
     Probe ctx = {0};
 
     ecs_entity_t s = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = id,
+        .query.terms[0].id = id,
         .events = {evt},
         .callback = system_callback,
         .ctx = &ctx
@@ -1536,4 +1575,3 @@ void Event_enqueue_on_readonly_world(void) {
 
     ecs_fini(world);
 }
-
diff --git a/test/api/src/Get_component.c b/test/core/src/Get_component.c
similarity index 88%
rename from test/api/src/Get_component.c
rename to test/core/src/Get_component.c
index f8ca01533..4827d7de7 100644
--- a/test/api/src/Get_component.c
+++ b/test/core/src/Get_component.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Get_component_setup(void) {
     ecs_log_set_level(-3);
@@ -7,7 +7,7 @@ void Get_component_setup(void) {
 void Get_component_get_empty(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_assert(ecs_get_type(world, e) == NULL);
@@ -20,7 +20,7 @@ void Get_component_get_1_from_1(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_assert(ecs_get_type(world, e)->array[0] == ecs_id(Position));
@@ -73,7 +73,7 @@ void Get_component_get_2_from_3(void) {
 
 static
 void Test_main_stage(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     for (int i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
@@ -86,7 +86,7 @@ void Get_component_get_1_from_2_in_progress_from_main_stage(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ECS_SYSTEM(world, Test_main_stage, EcsOnUpdate, Position);
@@ -101,7 +101,7 @@ void Add_in_progress(ecs_iter_t *it) {
     ecs_id_t ecs_id(Velocity) = 0;
 
     if (it->field_count >= 2) {
-        ecs_id(Velocity) = ecs_field_id(it, 2);
+        ecs_id(Velocity) = ecs_field_id(it, 1);
     }
 
     for (int i = 0; i < it->count; i ++) {
@@ -117,7 +117,7 @@ void Get_component_get_1_from_2_add_in_progress(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ECS_SYSTEM(world, Add_in_progress, EcsOnUpdate, Position, Velocity());
@@ -131,8 +131,8 @@ void Get_component_get_1_from_2_add_in_progress(void) {
 
 static
 void Add_in_progress_test_main(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     for (int i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
@@ -147,7 +147,7 @@ void Get_component_get_both_from_2_add_in_progress(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ECS_SYSTEM(world, Add_in_progress_test_main, EcsOnUpdate, Position, Velocity());
@@ -163,8 +163,8 @@ void Get_component_get_both_from_2_add_in_progress(void) {
 
 static
 void Add_remove_in_progress_test_main(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     for (int i = 0; i < it->count; i ++) {
         ecs_entity_t e = it->entities[i];
@@ -180,7 +180,7 @@ void Get_component_get_both_from_2_add_remove_in_progress(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ECS_SYSTEM(world, Add_remove_in_progress_test_main, EcsOnUpdate, Position, Velocity());
@@ -231,7 +231,7 @@ void Get_component_get_tag(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -244,7 +244,7 @@ void Get_component_get_pair_tag(void) {
     install_test_abort();
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, parent);
     test_assert(e != 0);
 
@@ -260,7 +260,7 @@ void Get_component_get_wildcard(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e = ecs_set_pair(world, 0, Position, Tgt, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value_pair(Position, Tgt, {10, 20}));
     test_assert(e != 0);
     test_assert(ecs_has_pair(world, e, ecs_id(Position), Tgt));
 
diff --git a/test/api/src/GlobalComponentIds.c b/test/core/src/GlobalComponentIds.c
similarity index 95%
rename from test/api/src/GlobalComponentIds.c
rename to test/core/src/GlobalComponentIds.c
index f21321920..cba003f18 100644
--- a/test/api/src/GlobalComponentIds.c
+++ b/test/core/src/GlobalComponentIds.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static ECS_DECLARE(MyTag);
 static ECS_DECLARE(MyEntity);
@@ -7,7 +7,7 @@ static ECS_COMPONENT_DECLARE(Velocity);
 
 static
 ecs_entity_t create_entity(ecs_world_t *world) {
-    return ecs_new(world, Position);
+    return ecs_new_w(world, Position);
 }
 
 static
@@ -17,7 +17,7 @@ ecs_entity_t create_entity_w_entity(ecs_world_t *world) {
 
 static
 ecs_entity_t create_tag_entity(ecs_world_t *world) {
-    return ecs_new(world, MyTag);
+    return ecs_new_w(world, MyTag);
 }
 
 static
@@ -128,7 +128,7 @@ void GlobalComponentIds_reuse_300_component_ids(void) {
     const ecs_world_info_t *info = ecs_get_world_info(world);
     ecs_entity_t info_last_component_id = info->last_component_id;
     ecs_entity_t info_last_id = ecs_get_max_id(world);
-    ecs_entity_t next_id = ecs_new_id(world);
+    ecs_entity_t next_id = ecs_new(world);
 
     ecs_fini(world);
 
@@ -145,7 +145,7 @@ void GlobalComponentIds_reuse_300_component_ids(void) {
     info = ecs_get_world_info(world);
     test_int(info->last_component_id, info_last_component_id);
     test_int(ecs_get_max_id(world), info_last_id);
-    test_int(next_id, ecs_new_id(world));
+    test_int(next_id, ecs_new(world));
 
     ecs_os_free(ids);
 
diff --git a/test/api/src/Has.c b/test/core/src/Has.c
similarity index 85%
rename from test/api/src/Has.c
rename to test/core/src/Has.c
index c90eeb8a2..01310a7ec 100644
--- a/test/api/src/Has.c
+++ b/test/core/src/Has.c
@@ -1,15 +1,15 @@
-#include <api.h>
+#include <core.h>
 
 void Has_zero(void) {
     install_test_abort();
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
-    ecs_has(world, e, 0);
+    ecs_has_id(world, e, 0);
 }
 
 void Has_1_of_0(void) {
@@ -17,7 +17,7 @@ void Has_1_of_0(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_assert(!ecs_has(world, e, Position));
@@ -30,7 +30,7 @@ void Has_1_of_1(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_assert(ecs_has(world, e, Position));
@@ -58,7 +58,7 @@ void Has_1_of_empty(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_assert(!ecs_has(world, e, Position));
@@ -67,7 +67,7 @@ void Has_1_of_empty(void) {
 }
 
 void TestHas(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -81,7 +81,7 @@ void Has_has_in_progress(void) {
     ECS_COMPONENT(world, Position);
     ECS_SYSTEM(world, TestHas, EcsOnUpdate, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert( ecs_has(world, e, Position));
 
@@ -97,7 +97,7 @@ void Has_has_of_zero(void) {
 
     test_expect_abort();
 
-    ecs_has(world, 0, 0);
+    ecs_has_id(world, 0, 0);
 }
 
 void Has_owns(void) {
@@ -106,12 +106,12 @@ void Has_owns(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);    
+    ecs_entity_t e = ecs_new_w(world, Position);    
     test_assert(e != 0);
     test_assert( ecs_has(world, e, Position));
     test_assert( ecs_owns(world, e, Position));
 
-    ecs_entity_t base = ecs_new(world, Velocity);
+    ecs_entity_t base = ecs_new_w(world, Velocity);
     test_assert( ecs_has(world, base, Velocity));
     test_assert( ecs_owns(world, base, Velocity));
 
@@ -128,10 +128,10 @@ void Has_owns_wildcard(void) {
     ECS_TAG(world, Tag_1);
     ECS_TAG(world, Tag_2);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e2 != 0);    
 
     ecs_add_id(world, e1, Tag_1);
@@ -154,7 +154,7 @@ void Has_owns_wildcard_pair(void) {
     ECS_TAG(world, Obj_1);
     ECS_TAG(world, Obj_2);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add_pair(world, e, Rel, Obj_1);
@@ -172,10 +172,10 @@ void Has_owns_wildcard_pair(void) {
 void Has_has_entity(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_add_pair(world, e, EcsIsA, base);
@@ -190,7 +190,7 @@ void Has_has_entity_0(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     test_expect_abort();
@@ -203,7 +203,7 @@ void Has_has_entity_0_component(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -213,16 +213,16 @@ void Has_has_entity_0_component(void) {
 void Has_has_entity_owned(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     
-    ecs_entity_t f = ecs_new(world, 0);
+    ecs_entity_t f = ecs_new(world);
     test_assert(f != 0);
 
-    ecs_entity_t g = ecs_new(world, 0);
+    ecs_entity_t g = ecs_new(world);
     test_assert(g != 0);
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_add_id(world, e, f);
@@ -247,7 +247,7 @@ void Has_has_entity_owned_0(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -258,7 +258,7 @@ void Has_has_entity_owned_0(void) {
 void Has_has_entity_owned_0_component(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_assert( ecs_owns_id(world, e, 0) == false);
@@ -272,10 +272,10 @@ void Has_has_wildcard(void) {
     ECS_TAG(world, Tag_1);
     ECS_TAG(world, Tag_2);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e2 != 0);    
 
     ecs_add_id(world, e1, Tag_1);
@@ -298,7 +298,7 @@ void Has_has_wildcard_pair(void) {
     ECS_TAG(world, Obj_1);
     ECS_TAG(world, Obj_2);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add_pair(world, e, Rel, Obj_1);
diff --git a/test/api/src/Hierarchies.c b/test/core/src/Hierarchies.c
similarity index 79%
rename from test/api/src/Hierarchies.c
rename to test/core/src/Hierarchies.c
index 5739b068c..48e4df0e7 100644
--- a/test/api/src/Hierarchies.c
+++ b/test/core/src/Hierarchies.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Hierarchies_setup(void) {
     ecs_log_set_level(-2);
@@ -59,7 +59,7 @@ void Hierarchies_get_object_from_0(void) {
 void Hierarchies_delete_children(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -78,8 +78,8 @@ void Hierarchies_tree_iter_empty(void) {
 
     ECS_ENTITY(world, Parent, 0);
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ ecs_childof(Parent) });
-    test_assert( !ecs_term_next(&it));
+    ecs_iter_t it = ecs_children(world, Parent);
+    test_assert( !ecs_children_next(&it));
 
     ecs_fini(world);
 }
@@ -93,15 +93,15 @@ void Hierarchies_tree_iter_1_table(void) {
     ECS_ENTITY(world, Child2, (ChildOf, Parent));
     ECS_ENTITY(world, Child3, (ChildOf, Parent));
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ ecs_childof(Parent) });
-    test_assert( ecs_term_next(&it) == true);
+    ecs_iter_t it = ecs_children(world, Parent);
+    test_assert( ecs_children_next(&it) == true);
     test_int( it.count, 3);
 
     test_assert(it.entities[0] == Child1);
     test_assert(it.entities[1] == Child2);
     test_assert(it.entities[2] == Child3);
 
-    test_assert( !ecs_term_next(&it));
+    test_assert( !ecs_children_next(&it));
 
     ecs_fini(world);
 }
@@ -118,19 +118,19 @@ void Hierarchies_tree_iter_2_tables(void) {
     ECS_ENTITY(world, Child3, (ChildOf, Parent), Position);
     ECS_ENTITY(world, Child4, (ChildOf, Parent), Position);
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ ecs_childof(Parent) });
+    ecs_iter_t it = ecs_children(world, Parent);
 
-    test_assert( ecs_term_next(&it) == true);
+    test_assert( ecs_children_next(&it) == true);
     test_int( it.count, 2);
     test_int(it.entities[0], Child1);
     test_int(it.entities[1], Child2);
 
-    test_assert( ecs_term_next(&it) == true);
+    test_assert( ecs_children_next(&it) == true);
     test_int( it.count, 2);
     test_int(it.entities[0], Child3);
     test_int(it.entities[1], Child4);
 
-    test_assert( !ecs_term_next(&it));
+    test_assert( !ecs_children_next(&it));
 
     ecs_fini(world);
 }
@@ -521,55 +521,6 @@ void Hierarchies_scope_set(void) {
     ecs_fini(world);
 }
 
-void Hierarchies_scope_set_w_new(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Scope, 0);
-
-    ecs_entity_t old_scope = ecs_set_scope(world, Scope);
-    test_assert(old_scope == 0);
-
-    ecs_entity_t e = ecs_new(world, 0);
-    test_assert(e != 0);
-    test_assert(ecs_has_pair(world, e, EcsChildOf, Scope));
-
-    old_scope = ecs_set_scope(world, 0);
-    test_assert(old_scope == Scope);
-
-    e = ecs_new(world, 0);
-    test_assert(e != 0);
-    test_assert(ecs_get_type(world, e) == NULL);
-
-    ecs_fini(world);
-}
-
-void Hierarchies_scope_set_w_new_staged(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Scope, 0);
-
-    ecs_defer_begin(world);
-
-    ecs_entity_t old_scope = ecs_set_scope(world, Scope);
-    test_assert(old_scope == 0);
-
-    ecs_entity_t e1 = ecs_new(world, 0);
-    test_assert(e1 != 0);
-
-    old_scope = ecs_set_scope(world, 0);
-    test_assert(old_scope == Scope);
-
-    ecs_entity_t e2 = ecs_new(world, 0);
-    test_assert(e2 != 0);
-
-    ecs_defer_end(world);
-
-    test_assert(ecs_has_pair(world, e1, EcsChildOf, Scope));
-    test_assert(ecs_get_type(world, e2) == NULL);
-
-    ecs_fini(world);
-}
-
 void Hierarchies_scope_set_again(void) {
     ecs_world_t *world = ecs_mini();
 
@@ -681,7 +632,7 @@ void Hierarchies_scope_component(void) {
 void Hierarchies_scope_component_no_macro(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t Scope = ecs_new_id(world);
+    ecs_entity_t Scope = ecs_new(world);
 
     ecs_entity_t old_scope = ecs_set_scope(world, Scope);
     test_assert(old_scope == 0);
@@ -816,7 +767,7 @@ void Hierarchies_new_from_path_existing_depth_2(void) {
 void Hierarchies_add_path_depth_0(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t id = ecs_new(world, 0);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
 
     ecs_entity_t e = ecs_add_path(world, id, 0, "foo");
@@ -838,7 +789,7 @@ void Hierarchies_add_path_depth_0(void) {
 void Hierarchies_add_path_depth_1(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t id = ecs_new(world, 0);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
 
     ecs_entity_t e = ecs_add_path(world, id, 0, "foo.bar");
@@ -860,7 +811,7 @@ void Hierarchies_add_path_depth_1(void) {
 void Hierarchies_add_path_depth_2(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t id = ecs_new(world, 0);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
 
     ecs_entity_t e = ecs_add_path(world, id, 0, "foo.bar.hello");
@@ -888,7 +839,7 @@ void Hierarchies_add_path_existing_depth_0(void) {
     test_assert(e != 0);
     test_str(ecs_get_name(world, e), "foo");    
 
-    ecs_entity_t id = ecs_new(world, 0);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
 
     test_expect_abort();
@@ -903,7 +854,7 @@ void Hierarchies_add_path_existing_depth_1(void) {
     test_assert(e != 0);
     test_str(ecs_get_name(world, e), "bar");    
 
-    ecs_entity_t id = ecs_new(world, 0);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
 
     test_expect_abort();
@@ -918,7 +869,7 @@ void Hierarchies_add_path_existing_depth_2(void) {
     test_assert(e != 0);
     test_str(ecs_get_name(world, e), "hello");    
 
-    ecs_entity_t id = ecs_new(world, 0);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
 
     test_expect_abort();
@@ -934,7 +885,7 @@ void Hierarchies_add_path_from_scope(void) {
 
     ecs_set_scope(world, e);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     test_assert(id != 0);
 
     ecs_entity_t f = ecs_add_path(world, id, 0, "hello.world");
@@ -975,8 +926,8 @@ void Hierarchies_add_path_from_scope_new_entity(void) {
 void Hierarchies_add_root_path_to_child(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
-    ecs_entity_t child = ecs_new_entity(world, "parent.child");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
+    ecs_entity_t child = ecs_entity(world, { .name = "parent.child" });
     test_assert(ecs_get_target(world, child, EcsChildOf, 0) == parent);
     test_str(ecs_get_name(world, child), "child");
 
@@ -990,10 +941,10 @@ void Hierarchies_add_root_path_to_child(void) {
 void Hierarchies_add_parent_path_from_root_to_child(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t gparent = ecs_new_entity(world, "gparent");
-    ecs_entity_t parent = ecs_new_entity(world, "gparent.parent");
+    ecs_entity_t gparent = ecs_entity(world, { .name = "gparent" });
+    ecs_entity_t parent = ecs_entity(world, { .name = "gparent.parent" });
     test_assert(ecs_get_target(world, parent, EcsChildOf, 0) == gparent);
-    ecs_entity_t child = ecs_new_entity(world, "gparent.parent.child");
+    ecs_entity_t child = ecs_entity(world, { .name = "gparent.parent.child" });
     test_assert(ecs_get_target(world, child, EcsChildOf, 0) == parent);
     test_str(ecs_get_name(world, child), "child");
 
@@ -1004,29 +955,10 @@ void Hierarchies_add_parent_path_from_root_to_child(void) {
     ecs_fini(world);
 }
 
-void Hierarchies_new_w_child_in_root(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t scope = ecs_new(world, 0);
-    ecs_entity_t parent = ecs_new(world, 0);
-    
-    ecs_set_scope(world, scope);
-
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    test_assert( ecs_has_pair(world, child, EcsChildOf, parent));
-    test_assert( !ecs_has_pair(world, child, EcsChildOf, scope));
-
-    ecs_entity_t child_2 = ecs_new(world, 0);
-    test_assert( !ecs_has_pair(world, child_2, EcsChildOf, parent));
-    test_assert( ecs_has_pair(world, child_2, EcsChildOf, scope));
-
-    ecs_fini(world);
-}
-
 void Hierarchies_delete_child(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -1045,7 +977,7 @@ void Hierarchies_delete_child(void) {
 void Hierarchies_delete_2_children(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
 
     ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -1071,7 +1003,7 @@ void Hierarchies_delete_2_children_different_type(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
 
     ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -1096,7 +1028,7 @@ void Hierarchies_delete_2_children_different_type(void) {
 void Hierarchies_delete_tree_2_levels(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -1117,7 +1049,7 @@ void Hierarchies_delete_tree_2_levels(void) {
 void Hierarchies_delete_tree_3_levels(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -1139,76 +1071,6 @@ void Hierarchies_delete_tree_3_levels(void) {
     ecs_fini(world);
 }
 
-void Hierarchies_delete_tree_count_tables(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t parent = ecs_new(world, Position);
-    test_assert(parent != 0);
-
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    test_assert(ecs_get_type(world, child) != NULL);
-    ecs_add(world, child, Position);
-
-    ecs_entity_t grand_child = ecs_new_w_pair(world, EcsChildOf, child);
-    test_assert(ecs_get_type(world, grand_child) != NULL);
-    ecs_add(world, grand_child, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_int(it.table_count, 3);
-    ecs_iter_fini(&it);
-
-    ecs_delete(world, parent);
-    
-    test_bool(ecs_is_alive(world, parent), false);
-    test_bool(ecs_is_alive(world, child), false);
-    test_bool(ecs_is_alive(world, grand_child), false);
-
-    it = ecs_query_iter(world, q);
-    test_int(it.table_count, 0);
-    ecs_iter_fini(&it);
-
-    ecs_fini(world);
-}
-
-void Hierarchies_delete_tree_staged(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_entity_t parent = ecs_new(world, Position);
-    test_assert(parent != 0);
-
-    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
-    test_assert(ecs_get_type(world, child) != NULL);
-    ecs_add(world, child, Position);
-
-    ecs_entity_t grand_child = ecs_new_w_pair(world, EcsChildOf, child);
-    test_assert(ecs_get_type(world, grand_child) != NULL);
-    ecs_add(world, grand_child, Position);
-
-    ecs_query_t *q = ecs_query_new(world, "Position");
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_int(it.table_count, 3);
-    ecs_iter_fini(&it);
-
-    ecs_defer_begin(world);
-    ecs_delete(world, parent);
-    ecs_defer_end(world);
-    
-    test_bool(ecs_is_alive(world, parent), false);
-    test_bool(ecs_is_alive(world, child), false);
-    test_bool(ecs_is_alive(world, grand_child), false);
-
-    it = ecs_query_iter(world, q);
-    test_int(it.table_count, 0);
-    ecs_iter_fini(&it);
-
-    ecs_fini(world);
-}
-
 void Hierarchies_delete_tree_empty_table(void) {
     ecs_world_t *world = ecs_mini();
 
@@ -1230,15 +1092,18 @@ void Hierarchies_delete_tree_recreate(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
     test_assert(parent != 0);
     test_assert(child != 0);
     test_assert(ecs_has_pair(world, child, EcsChildOf, parent));
 
-    ecs_delete_children(world, parent);
+    ecs_delete_with(world, ecs_childof(parent));
+
+    ecs_iter_t it = ecs_children(world, parent);
+    test_assert(!ecs_children_next(&it));
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_entity_t child_2  = ecs_new_w_pair(world, EcsChildOf, parent);
     test_assert(child_2 != 0);
@@ -1294,16 +1159,16 @@ void Hierarchies_scope_iter_after_delete_tree(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
     test_assert(parent != 0);
     test_assert(child != 0);
     test_assert(ecs_has_pair(world, child, EcsChildOf, parent));
 
-    ecs_delete_children(world, parent);
+    ecs_delete_with(world, ecs_childof(parent));
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ ecs_childof(parent) });
-    test_assert(!ecs_term_next(&it));
+    ecs_iter_t it = ecs_children(world, parent);
+    test_assert(!ecs_children_next(&it));
 
     ecs_fini(world);
 }
@@ -1313,13 +1178,16 @@ void Hierarchies_add_child_after_delete_tree(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
     test_assert(parent != 0);
     test_assert(child != 0);
     test_assert(ecs_has_pair(world, child, EcsChildOf, parent));
 
-    ecs_delete_children(world, parent);
+    ecs_delete_with(world, ecs_childof(parent));
+
+    ecs_iter_t it = ecs_children(world, parent);
+    test_assert(!ecs_children_next(&it));
 
     child = ecs_new_w_pair(world, EcsChildOf, parent);
 
@@ -1343,7 +1211,7 @@ void Hierarchies_delete_tree_w_onremove(void) {
 
     ECS_OBSERVER(world, RemovePosition, EcsOnRemove, Position);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
     ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent);
     ecs_entity_t child_2 = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -1382,7 +1250,7 @@ void Hierarchies_delete_tree_w_dtor(void) {
         .dtor = ecs_dtor(Position)
     });
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
     ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent);
     ecs_entity_t child_2 = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -1411,7 +1279,7 @@ void Hierarchies_add_child_to_recycled_parent(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -1422,7 +1290,7 @@ void Hierarchies_add_child_to_recycled_parent(void) {
     test_assert( !ecs_is_alive(world, parent));
     test_assert( !ecs_is_alive(world, child));
 
-    ecs_entity_t new_parent = ecs_new(world, 0);
+    ecs_entity_t new_parent = ecs_new(world);
     test_assert(new_parent != 0);
     /* Make sure we have a recycled identifier */
     test_assert(ecs_entity_t_lo(new_parent) != new_parent);
@@ -1441,14 +1309,14 @@ void Hierarchies_get_type_after_recycled_parent_add(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t parent = ecs_new(world);
     test_assert(parent != 0);
     test_assert( ecs_get_type(world, parent) == NULL);
 
     ecs_delete(world, parent);
     test_assert( !ecs_is_alive(world, parent));
 
-    parent = ecs_new(world, Position);
+    parent = ecs_new_w(world, Position);
     test_assert(parent != 0);
     test_assert(ecs_entity_t_lo(parent) != parent); // Ensure recycled
     test_assert( ecs_get_type(world, parent) != NULL);
@@ -1460,140 +1328,6 @@ void Hierarchies_get_type_after_recycled_parent_add(void) {
     ecs_fini(world);
 }
 
-void Hierarchies_rematch_after_add_to_recycled_parent(void) {
-    ecs_world_t *world = ecs_mini();
-    
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag, Position(parent)");
-
-    ecs_entity_t parent = ecs_new(world, 0);
-    test_assert(parent != 0);
-
-    ecs_delete(world, parent);
-    test_assert( !ecs_is_alive(world, parent));
-
-    parent = ecs_new(world, 0);
-    test_assert(parent != 0);
-
-    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, parent);
-    test_assert(e != 0);
-    test_assert( ecs_has_pair(world, e, EcsChildOf, parent));
-    ecs_add(world, e, Tag);
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_set(world, parent, Position, {10, 20});
-
-    ecs_run_aperiodic(world, 0);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-
-    const Position *p = ecs_field(&it, Position, 2);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    test_assert(ecs_field_src(&it, 2) == parent);
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
-void Hierarchies_cascade_after_recycled_parent_change(void) {
-    ecs_world_t *world = ecs_mini();
-    
-    ECS_COMPONENT(world, Position);
-    ECS_TAG(world, Tag);
-
-    ecs_query_t *q = ecs_query_new(world, "Tag, ?Position(parent|cascade)");
-
-    ecs_entity_t parent = ecs_new(world, 0);
-    test_assert(parent != 0);
-    ecs_entity_t child = ecs_new(world, 0);
-    test_assert(child != 0);
-
-    ecs_delete(world, parent);
-    test_assert( !ecs_is_alive(world, parent));
-    ecs_delete(world, child);
-    test_assert( !ecs_is_alive(world, child));
-
-    parent = ecs_new_w_id(world, Tag);
-    test_assert(parent != 0);
-    child = ecs_new_w_id(world, Tag);
-    test_assert(child != 0);
-    ecs_add_pair(world, child, EcsChildOf, parent);
-
-    ecs_entity_t e = ecs_new_w_id(world, Tag);
-    test_assert(e != 0);
-
-    ecs_add_pair(world, e, EcsChildOf, child);
-    test_assert( ecs_has_pair(world, e, EcsChildOf, child));
-
-    ecs_iter_t it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_assert(it.entities[0] == parent);
-    test_assert(ecs_field_src(&it, 2) == 0);
-    const Position *p = ecs_field(&it, Position, 2);
-    test_assert(p == NULL);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_assert(it.entities[0] == child);
-    test_assert(ecs_field_src(&it, 2) == 0);
-    p = ecs_field(&it, Position, 2);
-    test_assert(p == NULL);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_assert(it.entities[0] == e);
-    test_assert(ecs_field_src(&it, 2) == 0);
-    p = ecs_field(&it, Position, 2);
-    test_assert(p == NULL);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_set(world, parent, Position, {10, 20});
-    ecs_set(world, child, Position, {20, 30});
-
-    ecs_run_aperiodic(world, 0);
-
-    it = ecs_query_iter(world, q);
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_assert(it.entities[0] == parent);
-    test_assert(ecs_field_src(&it, 2) == 0);
-    p = ecs_field(&it, Position, 2);
-    test_assert(p == NULL);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_assert(it.entities[0] == child);
-    test_assert(ecs_field_src(&it, 2) == parent);
-    p = ecs_field(&it, Position, 2);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    test_bool(ecs_query_next(&it), true);
-    test_int(it.count, 1);
-    test_assert(it.entities[0] == e);
-    test_assert(ecs_field_src(&it, 2) == child);
-    p = ecs_field(&it, Position, 2);
-    test_assert(p != NULL);
-    test_int(p->x, 20);
-    test_int(p->y, 30);
-
-    test_bool(ecs_query_next(&it), false);
-
-    ecs_fini(world);
-}
-
 void Hierarchies_long_name_depth_0(void) {
     ecs_world_t *world = ecs_mini();
 
@@ -1632,7 +1366,7 @@ void Hierarchies_long_name_depth_1(void) {
     test_assert(strlen(child_name) >= 64);
     ecs_entity_t child = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = child_name,
-        .add = { ecs_pair(EcsChildOf, parent) }
+        .parent = parent
     });    
     test_str(ecs_get_name(world, child), child_name);
 
@@ -1666,7 +1400,7 @@ void Hierarchies_long_name_depth_2(void) {
     test_assert(strlen(child_name) >= 64);
     ecs_entity_t child = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = child_name,
-        .add = { ecs_pair(EcsChildOf, parent) }
+        .parent = parent
     });    
     test_str(ecs_get_name(world, child), child_name);
 
@@ -1675,7 +1409,7 @@ void Hierarchies_long_name_depth_2(void) {
     test_assert(strlen(grand_child_name) >= 64);
     ecs_entity_t grand_child = ecs_entity_init(world, &(ecs_entity_desc_t){
         .name = grand_child_name,
-        .add = { ecs_pair(EcsChildOf, child) }
+        .parent = child
     });    
     test_str(ecs_get_name(world, grand_child), grand_child_name);
 
@@ -1697,10 +1431,10 @@ void Hierarchies_long_name_depth_2(void) {
 void Hierarchies_ensure_1_parent_after_adding_2(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent_1 = ecs_new(world, 0);
+    ecs_entity_t parent_1 = ecs_new(world);
     test_assert(parent_1 != 0);
 
-    ecs_entity_t parent_2 = ecs_new(world, 0);
+    ecs_entity_t parent_2 = ecs_new(world);
     test_assert(parent_2 != 0);
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent_1);
@@ -1717,10 +1451,10 @@ void Hierarchies_ensure_1_parent_after_adding_2(void) {
 void Hierarchies_ensure_child_alive_after_deleting_prev_parent(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent_1 = ecs_new(world, 0);
+    ecs_entity_t parent_1 = ecs_new(world);
     test_assert(parent_1 != 0);
 
-    ecs_entity_t parent_2 = ecs_new(world, 0);
+    ecs_entity_t parent_2 = ecs_new(world);
     test_assert(parent_2 != 0);
 
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent_1);
@@ -1741,8 +1475,8 @@ void Hierarchies_ensure_child_alive_after_deleting_prev_parent(void) {
 void Hierarchies_lookup_after_root_to_parent_move(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "Parent");
-    ecs_entity_t c = ecs_new_entity(world, "Child");
+    ecs_entity_t p = ecs_entity(world, { .name = "Parent" });
+    ecs_entity_t c = ecs_entity(world, { .name = "Child" });
 
     test_str("Parent", ecs_get_name(world, p));
     test_str("Child", ecs_get_name(world, c));
@@ -1774,8 +1508,8 @@ void Hierarchies_lookup_after_root_to_parent_move(void) {
 void Hierarchies_lookup_after_parent_to_root_move(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "Parent");
-    ecs_entity_t c = ecs_new_entity(world, "Parent.Child");
+    ecs_entity_t p = ecs_entity(world, { .name = "Parent" });
+    ecs_entity_t c = ecs_entity(world, { .name = "Parent.Child" });
 
     test_str("Parent", ecs_get_name(world, p));
     test_str("Child", ecs_get_name(world, c));
@@ -1808,9 +1542,9 @@ void Hierarchies_lookup_after_parent_to_root_move(void) {
 void Hierarchies_lookup_after_parent_to_parent_move(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "Parent");
-    ecs_entity_t p2 = ecs_new_entity(world, "Parent2");
-    ecs_entity_t c = ecs_new_entity(world, "Parent.Child");
+    ecs_entity_t p = ecs_entity(world, { .name = "Parent" });
+    ecs_entity_t p2 = ecs_entity(world, { .name = "Parent2" });
+    ecs_entity_t c = ecs_entity(world, { .name = "Parent.Child" });
 
     test_str("Parent", ecs_get_name(world, p));
     test_str("Parent2", ecs_get_name(world, p2));
@@ -1846,7 +1580,7 @@ void Hierarchies_lookup_after_parent_to_parent_move(void) {
 void Hierarchies_lookup_after_clear_from_root(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_entity(world, "Child");
+    ecs_entity_t c = ecs_entity(world, { .name = "Child" });
 
     test_str("Child", ecs_get_name(world, c));
 
@@ -1867,8 +1601,8 @@ void Hierarchies_lookup_after_clear_from_root(void) {
 void Hierarchies_lookup_after_clear_from_parent(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "Parent");
-    ecs_entity_t c = ecs_new_entity(world, "Parent.Child");
+    ecs_entity_t p = ecs_entity(world, { .name = "Parent" });
+    ecs_entity_t c = ecs_entity(world, { .name = "Parent.Child" });
 
     test_str("Parent", ecs_get_name(world, p));
     test_str("Child", ecs_get_name(world, c));
@@ -1897,7 +1631,7 @@ void Hierarchies_lookup_after_clear_from_parent(void) {
 void Hierarchies_lookup_after_delete_from_root(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_entity(world, "Child");
+    ecs_entity_t c = ecs_entity(world, { .name = "Child" });
 
     test_str("Child", ecs_get_name(world, c));
 
@@ -1917,8 +1651,8 @@ void Hierarchies_lookup_after_delete_from_root(void) {
 void Hierarchies_lookup_after_delete_from_parent(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t p = ecs_new_entity(world, "Parent");
-    ecs_entity_t c = ecs_new_entity(world, "Parent.Child");
+    ecs_entity_t p = ecs_entity(world, { .name = "Parent" });
+    ecs_entity_t c = ecs_entity(world, { .name = "Parent.Child" });
 
     test_str("Parent", ecs_get_name(world, p));
     test_str("Child", ecs_get_name(world, c));
@@ -1946,12 +1680,12 @@ void Hierarchies_lookup_after_delete_from_parent(void) {
 void Hierarchies_defer_batch_remove_name_w_add_childof(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
     test_assert(e != 0);
     test_str("e", ecs_get_name(world, e));
     test_assert(ecs_lookup(world, "e") == e);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_defer_begin(world);
     ecs_clear(world, e);
     ecs_add_pair(world, e, EcsChildOf, parent);
@@ -1967,7 +1701,7 @@ void Hierarchies_defer_batch_remove_name_w_add_childof(void) {
 void Hierarchies_defer_batch_remove_childof_w_add_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, parent);
     test_assert(e != 0);
     
diff --git a/test/api/src/Id.c b/test/core/src/Id.c
similarity index 82%
rename from test/api/src/Id.c
rename to test/core/src/Id.c
index 1236d70d0..18ab8cebd 100644
--- a/test/api/src/Id.c
+++ b/test/core/src/Id.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Id_0_is_wildcard(void) {
     test_assert( !ecs_id_is_wildcard(0) );
@@ -14,29 +14,29 @@ void Id_any_is_wildcard(void) {
 
 void Id_entity_is_wildcard(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert( !ecs_id_is_wildcard(e) );
     ecs_fini(world);
 }
 
 void Id_pair_is_wildcard(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert( !ecs_id_is_wildcard(ecs_pair(r, o)) );
     ecs_fini(world);
 }
 
 void Id_pair_w_rel_wildcard_is_wildcard(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert( ecs_id_is_wildcard(ecs_pair(EcsWildcard, o)) );
     ecs_fini(world);
 }
 
 void Id_pair_w_obj_wildcard_is_wildcard(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert( ecs_id_is_wildcard(ecs_pair(r, EcsWildcard)) );
     ecs_fini(world);
 }
@@ -47,14 +47,14 @@ void Id_pair_w_wildcard_wildcard_is_wildcard(void) {
 
 void Id_pair_w_rel_any_is_wildcard(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert( ecs_id_is_wildcard(ecs_pair(EcsAny, o)) );
     ecs_fini(world);
 }
 
 void Id_pair_w_obj_any_is_wildcard(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert( ecs_id_is_wildcard(ecs_pair(r, EcsAny)) );
     ecs_fini(world);
 }
@@ -65,21 +65,21 @@ void Id_pair_w_any_any_is_wildcard(void) {
 
 void Id_pair_w_override_is_wildcard(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert( !ecs_id_is_wildcard(ECS_OVERRIDE | ecs_pair(r, EcsWildcard)));
     ecs_fini(world);
 }
 
 void Id_pair_w_toggle_is_wildcard(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert( !ecs_id_is_wildcard(ECS_TOGGLE | ecs_pair(r, EcsWildcard)));
     ecs_fini(world);
 }
 
 void Id_tag_id_is_tag(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t t = ecs_new(world);
     test_assert( ecs_id_is_tag(world, t));
     ecs_fini(world);
 }
@@ -93,8 +93,8 @@ void Id_component_id_is_tag(void) {
 
 void Id_pair_id_is_tag(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert( ecs_id_is_tag(world, ecs_pair(r, o)));
     ecs_fini(world);
 }
@@ -102,7 +102,7 @@ void Id_pair_id_is_tag(void) {
 void Id_pair_id_w_rel_component_is_tag(void) {
     ecs_world_t *world = ecs_mini();
     ECS_COMPONENT(world, Position);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert( !ecs_id_is_tag(world, ecs_pair(ecs_id(Position), o)));
     ecs_fini(world);
 }
@@ -110,7 +110,7 @@ void Id_pair_id_w_rel_component_is_tag(void) {
 void Id_pair_id_w_obj_component_is_tag(void) {
     ecs_world_t *world = ecs_mini();
     ECS_COMPONENT(world, Position);
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert( !ecs_id_is_tag(world, ecs_pair(r, ecs_id(Position))));
     ecs_fini(world);
 }
@@ -124,7 +124,7 @@ void Id_pair_id_w_rel_component_obj_wildcard_is_tag(void) {
 
 void Id_pair_id_w_obj_wildcard_is_tag(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert( !ecs_id_is_tag(world, ecs_pair(r, EcsWildcard)));
     ecs_fini(world);
 }
@@ -132,7 +132,7 @@ void Id_pair_id_w_obj_wildcard_is_tag(void) {
 void Id_pair_id_w_tag_property_w_obj_component_is_tag(void) {
     ecs_world_t *world = ecs_mini();
     ECS_COMPONENT(world, Position);
-    ecs_entity_t r = ecs_new_w_id(world, EcsTag);
+    ecs_entity_t r = ecs_new_w_id(world, EcsPairIsTag);
     test_assert( ecs_id_is_tag(world, ecs_pair(r, ecs_id(Position))));
     ecs_fini(world);
 }
@@ -140,29 +140,29 @@ void Id_pair_id_w_tag_property_w_obj_component_is_tag(void) {
 void Id_pair_id_w_tag_property_w_obj_wildcard_is_tag(void) {
     ecs_world_t *world = ecs_mini();
     ECS_COMPONENT(world, Position);
-    ecs_entity_t r = ecs_new_w_id(world, EcsTag);
+    ecs_entity_t r = ecs_new_w_id(world, EcsPairIsTag);
     test_assert( ecs_id_is_tag(world, ecs_pair(r, EcsWildcard)));
     ecs_fini(world);
 }
 
 void Id_pair_w_rel_wildcard_is_tag(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert( !ecs_id_is_tag(world, ecs_pair(EcsWildcard, o)));
     ecs_fini(world);
 }
 
 void Id_pair_w_obj_wildcard_is_tag(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert( !ecs_id_is_tag(world, ecs_pair(r, EcsWildcard)));
     ecs_fini(world);
 }
 
 void Id_pair_w_rel_tag_obj_wildcard_is_tag(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_add_id(world, r, EcsTag);
+    ecs_entity_t r = ecs_new(world);
+    ecs_add_id(world, r, EcsPairIsTag);
     test_assert( ecs_id_is_tag(world, ecs_pair(r, EcsWildcard)));
     ecs_fini(world);
 }
@@ -175,22 +175,22 @@ void Id_pair_w_wildcard_wildcard_is_tag(void) {
 
 void Id_pair_w_rel_any_is_tag(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert( !ecs_id_is_tag(world, ecs_pair(EcsAny, o)));
     ecs_fini(world);
 }
 
 void Id_pair_w_obj_any_is_tag(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert( !ecs_id_is_tag(world, ecs_pair(r, EcsAny)));
     ecs_fini(world);
 }
 
 void Id_pair_w_rel_tag_obj_any_is_tag(void) {
     ecs_world_t *world = ecs_mini();
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_add_id(world, r, EcsTag);
+    ecs_entity_t r = ecs_new(world);
+    ecs_add_id(world, r, EcsPairIsTag);
     test_assert( ecs_id_is_tag(world, ecs_pair(r, EcsAny)));
     ecs_fini(world);
 }
@@ -218,7 +218,7 @@ void Id_id_w_toggle_is_tag(void) {
 void Id_pair_id_override_is_tag(void) {
     ecs_world_t *world = ecs_mini();
     ECS_COMPONENT(world, Position);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert( ecs_id_is_tag(world, ECS_OVERRIDE | ecs_pair(ecs_id(Position), o)));
     ecs_fini(world);
 }
@@ -226,7 +226,7 @@ void Id_pair_id_override_is_tag(void) {
 void Id_pair_id_toggle_is_tag(void) {
     ecs_world_t *world = ecs_mini();
     ECS_COMPONENT(world, Position);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert( ecs_id_is_tag(world, ECS_TOGGLE | ecs_pair(ecs_id(Position), o)));
     ecs_fini(world);
 }
@@ -234,8 +234,8 @@ void Id_pair_id_toggle_is_tag(void) {
 void Id_make_pair(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t t = ecs_new(world);
     ecs_id_t id = ecs_make_pair(r, t);
 
     test_assert( ecs_pair_first(world, id) == r);
@@ -248,8 +248,8 @@ void Id_make_pair_of_pair(void) {
     install_test_abort();
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t t = ecs_new(world);
     ecs_id_t id = ecs_make_pair(r, t);
 
     test_expect_abort();
@@ -260,8 +260,8 @@ void Id_make_pair_of_pair_tgt(void) {
     install_test_abort();
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t t = ecs_new(world);
     ecs_id_t id = ecs_make_pair(r, t);
 
     test_expect_abort();
diff --git a/test/api/src/Internals.c b/test/core/src/Internals.c
similarity index 89%
rename from test/api/src/Internals.c
rename to test/core/src/Internals.c
index b6f546fe3..0c830a273 100644
--- a/test/api/src/Internals.c
+++ b/test/core/src/Internals.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Internals_setup(void) {
     ecs_log_set_level(-3);
@@ -6,9 +6,9 @@ void Internals_setup(void) {
 
 static
 void Iter(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
-    Mass *m = ecs_field(it, Mass, 3);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
+    Mass *m = ecs_field(it, Mass, 2);
 
     probe_iter(it);
 
@@ -140,7 +140,7 @@ static int invoked = 0;
 
 static
 void CreateNewTable(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     int32_t i;
     for (i = 0; i < it->count; i ++) {
@@ -191,7 +191,7 @@ void Internals_recreate_deleted_table(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t parent_A = ecs_new(world, 0);
+    ecs_entity_t parent_A = ecs_new(world);
     ecs_entity_t child_A = ecs_new_w_pair(world, EcsChildOf, parent_A);
     test_assert(parent_A != 0);
     test_assert(child_A != 0);
@@ -200,7 +200,7 @@ void Internals_recreate_deleted_table(void) {
     test_assert( !ecs_is_alive(world, parent_A));
     test_assert( !ecs_is_alive(world, child_A));
 
-    ecs_entity_t parent_B = ecs_new(world, 0);
+    ecs_entity_t parent_B = ecs_new(world);
     ecs_entity_t child_B = ecs_new_w_pair(world, EcsChildOf, parent_B);
     test_assert(parent_B != 0);
     test_assert(child_B != 0);
@@ -213,7 +213,7 @@ void Internals_create_65k_tables(void) {
 
     int32_t i;
     for (i = 0; i <= 65536; i ++) {
-        ecs_entity_t e = ecs_new_id(world);
+        ecs_entity_t e = ecs_new(world);
         ecs_add_id(world, e, e);
         test_assert(ecs_has_id(world, e, e));
         test_int(ecs_get_type(world, e)->count, 1);
@@ -231,7 +231,7 @@ void Internals_no_duplicate_root_table_id(void) {
 
     int32_t i;
     for (i = 0; i <= 50; i ++) {
-        ecs_entity_t e = ecs_new_id(world);
+        ecs_entity_t e = ecs_new(world);
         ecs_add_id(world, e, i + 1000);
         test_assert(e != 0);
         test_assert(ecs_has_id(world, e, i + 1000));
@@ -265,26 +265,26 @@ void Internals_override_os_api_w_addon(void) {
 void Internals_records_resize_on_override(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t TagA = ecs_new_id(world);
-    ecs_entity_t TagB = ecs_new_id(world);
-    ecs_entity_t TagC = ecs_new_id(world);
-    ecs_entity_t TagD = ecs_new_id(world);
-    ecs_entity_t TagE = ecs_new_id(world);
-    ecs_entity_t TagF = ecs_new_id(world);
-    ecs_entity_t TagG = ecs_new_id(world);
-    ecs_entity_t TagH = ecs_new_id(world);
-
-    ecs_entity_t RelA = ecs_new_id(world);
-    ecs_entity_t RelB = ecs_new_id(world);
-    ecs_entity_t RelC = ecs_new_id(world);
-    ecs_entity_t RelD = ecs_new_id(world);
-    ecs_entity_t RelE = ecs_new_id(world);
-    ecs_entity_t RelF = ecs_new_id(world);
-    ecs_entity_t RelG = ecs_new_id(world);
-    ecs_entity_t TgtA = ecs_new_id(world);
-    ecs_entity_t TgtB = ecs_new_id(world);
-
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t TagA = ecs_new(world);
+    ecs_entity_t TagB = ecs_new(world);
+    ecs_entity_t TagC = ecs_new(world);
+    ecs_entity_t TagD = ecs_new(world);
+    ecs_entity_t TagE = ecs_new(world);
+    ecs_entity_t TagF = ecs_new(world);
+    ecs_entity_t TagG = ecs_new(world);
+    ecs_entity_t TagH = ecs_new(world);
+
+    ecs_entity_t RelA = ecs_new(world);
+    ecs_entity_t RelB = ecs_new(world);
+    ecs_entity_t RelC = ecs_new(world);
+    ecs_entity_t RelD = ecs_new(world);
+    ecs_entity_t RelE = ecs_new(world);
+    ecs_entity_t RelF = ecs_new(world);
+    ecs_entity_t RelG = ecs_new(world);
+    ecs_entity_t TgtA = ecs_new(world);
+    ecs_entity_t TgtB = ecs_new(world);
+
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, TagA);
     ecs_add_id(world, e, TagB);
     ecs_add_id(world, e, TagC);
@@ -325,7 +325,7 @@ void Internals_table_observed_after_add(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
     ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
     ecs_table_t *pt = ecs_get_table(world, p);
     ecs_table_t *ct = ecs_get_table(world, c);
@@ -353,7 +353,7 @@ void Internals_table_observed_after_remove(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
     ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
     ecs_table_t *pt = ecs_get_table(world, p);
     ecs_table_t *ct = ecs_get_table(world, c);
@@ -388,7 +388,7 @@ void Internals_table_observed_after_clear(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
     ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
     ecs_table_t *pt = ecs_get_table(world, p);
     ecs_table_t *ct = ecs_get_table(world, c);
@@ -415,7 +415,7 @@ void Internals_table_observed_after_delete(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
     ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
     ecs_table_t *pt = ecs_get_table(world, p);
     ecs_table_t *ct = ecs_get_table(world, c);
@@ -439,7 +439,7 @@ void Internals_table_observed_after_on_remove(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
     ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
     ecs_table_t *pt = ecs_get_table(world, p);
     ecs_table_t *ct = ecs_get_table(world, c);
@@ -447,7 +447,7 @@ void Internals_table_observed_after_on_remove(void) {
     test_assert(ct != NULL);
     test_int(flecs_table_observed_count(ct), 0);
 
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t t = ecs_new(world);
     ecs_add_id(world, p, t);
     ecs_table_t *pt_t = ecs_get_table(world, p);
     test_assert(pt_t != NULL);
@@ -476,7 +476,7 @@ void Internals_table_observed_after_entity_flag(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
 
     ecs_add(world, p, TagA);
     ecs_table_t *p_a = ecs_get_table(world, p);
@@ -498,7 +498,7 @@ void Internals_table_create_leak_check(void) {
 
     int64_t max_block_count;
 
-    ecs_entity_t tag = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
     ecs_entity_t e = ecs_new_w_id(world, tag);
     ecs_delete(world, tag);
 
@@ -506,7 +506,7 @@ void Internals_table_create_leak_check(void) {
         ecs_block_allocator_free_count;
 
     for (int i = 0; i < 25000; i ++) {
-        tag = ecs_new_id(world);
+        tag = ecs_new(world);
         ecs_add_id(world, e, tag);
         ecs_delete(world, tag);
     }
diff --git a/test/core/src/Iter.c b/test/core/src/Iter.c
new file mode 100644
index 000000000..e236cf476
--- /dev/null
+++ b/test/core/src/Iter.c
@@ -0,0 +1,3012 @@
+#include <core.h>
+
+void Iter_page_iter_0_0(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 0, 0);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.frame_offset, 0);
+        test_int(pit.entities[0], e1);
+        test_int(pit.entities[1], e2);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e1);
+        test_int(ptr[1].value, e2);
+    }
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.frame_offset, 2);
+        test_int(pit.entities[0], e3);
+        test_int(pit.entities[1], e4);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+        test_int(ptr[1].value, e4);
+    }
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.frame_offset, 4);
+        test_int(pit.entities[0], e5);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_1_0(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 1, 0);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e2);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e2);
+    }
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.entities[0], e3);
+        test_int(pit.entities[1], e4);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+        test_int(ptr[1].value, e4);
+    }
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e5);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_0_1(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 0, 1);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e1);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e1);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_n_0(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 2, 0);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e3);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+    }
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e4);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e4);
+    }
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e5);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_0_n(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 0, 2);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.entities[0], e1);
+        test_int(pit.entities[1], e2);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e1);
+        test_int(ptr[1].value, e2);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_m_n(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+    ecs_entity_t e6 = ecs_new(world); ecs_set(world, e6, Self, {e6});
+
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagA);
+    ecs_add(world, e6, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 2, 3);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e3);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+    }
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.entities[0], e4);
+        test_int(pit.entities[1], e5);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e4);
+        test_int(ptr[1].value, e5);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_skip_1_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 2, 0);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.entities[0], e3);
+        test_int(pit.entities[1], e4);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+        test_int(ptr[1].value, e4);
+    }
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e5);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_skip_2_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e4, TagB);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 3, 0);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.entities[0], e4);
+        test_int(pit.entities[1], e5);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e4);
+        test_int(ptr[1].value, e5);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_1(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_worker_iter(&it, 0, 1);
+
+    {
+        test_bool(ecs_worker_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.entities[0], e1);
+        test_int(pit.entities[1], e2);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e1);
+        test_int(ptr[1].value, e2);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.entities[0], e3);
+        test_int(pit.entities[1], e4);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+        test_int(ptr[1].value, e4);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e5);
+        test_int(pit.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+    }
+
+    test_bool(ecs_worker_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_2(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 2);
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 2);
+
+    /* Iter 1 */
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e1);
+        test_int(pit_1.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e1);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e3);
+        test_int(pit_1.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e5);
+        test_int(pit_1.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+    }
+
+    test_bool(ecs_worker_next(&pit_1), false);
+
+    /* Iter 2 */
+    {
+        test_bool(ecs_worker_next(&pit_2), true);
+        test_int(pit_2.count, 1);
+        test_int(pit_2.entities[0], e2);
+        test_int(pit_2.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_2, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e2);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_2), true);
+        test_int(pit_2.count, 1);
+        test_int(pit_2.entities[0], e4);
+        test_int(pit_2.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_2, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e4);
+    }
+
+    test_bool(ecs_worker_next(&pit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_3(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+    ecs_entity_t e6 = ecs_new(world); ecs_set(world, e6, Self, {e6});
+
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagA);
+    ecs_add(world, e6, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 3);
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 3);
+    ecs_iter_t it_3 = ecs_query_iter(world, q);
+    ecs_iter_t pit_3 = ecs_worker_iter(&it_3, 2, 3);
+
+    /* Iter 1 */
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e1);
+        test_int(pit_1.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e1);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e4);
+        test_int(pit_1.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e4);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e6);
+        test_int(pit_1.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e6);
+    }
+
+    test_bool(ecs_worker_next(&pit_1), false);
+
+    /* Iter 2 */
+    {
+        test_bool(ecs_worker_next(&pit_2), true);
+        test_int(pit_2.count, 1);
+        test_int(pit_2.entities[0], e2);
+        test_int(pit_2.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_2, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e2);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_2), true);
+        test_int(pit_2.count, 1);
+        test_int(pit_2.entities[0], e5);
+        test_int(pit_2.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_2, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+    }
+
+    test_bool(ecs_worker_next(&pit_2), false);
+
+    /* Iter 3 */
+    {
+        test_bool(ecs_worker_next(&pit_3), true);
+        test_int(pit_3.count, 1);
+        test_int(pit_3.entities[0], e3);
+        test_int(pit_3.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_3, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+    }
+
+    test_bool(ecs_worker_next(&pit_3), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_4(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+    ecs_entity_t e6 = ecs_new(world); ecs_set(world, e6, Self, {e6});
+    ecs_entity_t e7 = ecs_new(world); ecs_set(world, e7, Self, {e7});
+    ecs_entity_t e8 = ecs_new(world); ecs_set(world, e8, Self, {e8});
+    ecs_entity_t e9 = ecs_new(world); ecs_set(world, e9, Self, {e9});
+
+    ecs_add(world, e5, TagA);
+    ecs_add(world, e6, TagA);
+    ecs_add(world, e7, TagA);
+    ecs_add(world, e8, TagB);
+    ecs_add(world, e9, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }}
+    });
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 4);
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 4);
+    ecs_iter_t it_3 = ecs_query_iter(world, q);
+    ecs_iter_t pit_3 = ecs_worker_iter(&it_3, 2, 4);
+    ecs_iter_t it_4 = ecs_query_iter(world, q);
+    ecs_iter_t pit_4 = ecs_worker_iter(&it_4, 3, 4);
+
+    /* Iter 1 */
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e1);
+        test_int(pit_1.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e1);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e5);
+        test_int(pit_1.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e8);
+        test_int(pit_1.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e8);
+    }
+
+    test_bool(ecs_worker_next(&pit_1), false);
+
+    /* Iter 2 */
+    {
+        test_bool(ecs_worker_next(&pit_2), true);
+        test_int(pit_2.count, 1);
+        test_int(pit_2.entities[0], e2);
+        test_int(pit_2.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_2, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e2);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_2), true);
+        test_int(pit_2.count, 1);
+        test_int(pit_2.entities[0], e6);
+        test_int(pit_2.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_2, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e6);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_2), true);
+        test_int(pit_2.count, 1);
+        test_int(pit_2.entities[0], e9);
+        test_int(pit_2.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_2, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e9);
+    }
+
+    test_bool(ecs_worker_next(&pit_2), false);
+
+    /* Iter 3 */
+    {
+        test_bool(ecs_worker_next(&pit_3), true);
+        test_int(pit_3.count, 1);
+        test_int(pit_3.entities[0], e3);
+        test_int(pit_3.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_3, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_3), true);
+        test_int(pit_3.count, 1);
+        test_int(pit_3.entities[0], e7);
+        test_int(pit_3.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_3, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e7);
+    }
+
+    test_bool(ecs_worker_next(&pit_3), false);
+
+    /* Iter 4 */
+    {
+        test_bool(ecs_worker_next(&pit_4), true);
+        test_int(pit_4.count, 1);
+        test_int(pit_4.entities[0], e4);
+        test_int(pit_4.ids[0], ecs_id(Self));
+
+        Self *ptr = ecs_field(&pit_4, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e4);
+    }
+
+    test_bool(ecs_worker_next(&pit_4), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_paged_iter_w_shared_comp(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Self);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t foo = ecs_insert(world, ecs_value(Position, {10, 20}));
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }, { ecs_id(Position), .src.id = foo} },
+        .flags = EcsQueryIsInstanced
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 0, 0);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.entities[0], e1);
+        test_int(pit.entities[1], e2);
+        test_int(pit.ids[0], ecs_id(Self));
+        test_int(pit.ids[1], ecs_id(Position));
+        test_int(pit.sources[0], 0);
+        test_int(pit.sources[1], foo);
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e1);
+        test_int(ptr[1].value, e2);
+
+        Position *pptr = ecs_field(&pit, Position, 1);
+        test_int(pptr->x, 10);
+        test_int(pptr->y, 20);
+    }
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 2);
+        test_int(pit.entities[0], e3);
+        test_int(pit.entities[1], e4);
+        test_int(pit.ids[0], ecs_id(Self));
+        test_int(pit.ids[1], ecs_id(Position));
+        test_int(pit.sources[0], 0);
+        test_int(pit.sources[1], foo);
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+        test_int(ptr[1].value, e4);
+
+        Position *pptr = ecs_field(&pit, Position, 1);
+        test_int(pptr->x, 10);
+        test_int(pptr->y, 20);
+    }
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 1);
+        test_int(pit.entities[0], e5);
+        test_int(pit.ids[0], ecs_id(Self));
+        test_int(pit.ids[1], ecs_id(Position));
+        test_int(pit.sources[0], 0);
+        test_int(pit.sources[1], foo);
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+
+        Position *pptr = ecs_field(&pit, Position, 1);
+        test_int(pptr->x, 10);
+        test_int(pptr->y, 20);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_shared_comp(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t foo = ecs_insert(world, ecs_value(Position, {10, 20}));
+
+    ecs_entity_t e1 = ecs_new(world); ecs_set(world, e1, Self, {e1});
+    ecs_entity_t e2 = ecs_new(world); ecs_set(world, e2, Self, {e2});
+    ecs_entity_t e3 = ecs_new(world); ecs_set(world, e3, Self, {e3});
+    ecs_entity_t e4 = ecs_new(world); ecs_set(world, e4, Self, {e4});
+    ecs_entity_t e5 = ecs_new(world); ecs_set(world, e5, Self, {e5});
+
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e4, TagA);
+    ecs_add(world, e5, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self) }, { ecs_id(Position), .src.id = foo} },
+        .flags = EcsQueryIsInstanced
+    });
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 2);
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 2);
+
+    /* Iter 1 */
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e1);
+        test_int(pit_1.ids[0], ecs_id(Self));
+        test_int(pit_1.ids[1], ecs_id(Position));
+        test_int(pit_1.sources[0], 0);
+        test_int(pit_1.sources[1], foo);
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e1);
+
+        Position *pptr = ecs_field(&pit_1, Position, 1);
+        test_int(pptr->x, 10);
+        test_int(pptr->y, 20);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e3);
+        test_int(pit_1.ids[0], ecs_id(Self));
+        test_int(pit_1.ids[1], ecs_id(Position));
+        test_int(pit_1.sources[0], 0);
+        test_int(pit_1.sources[1], foo);
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e3);
+
+        Position *pptr = ecs_field(&pit_1, Position, 1);
+        test_int(pptr->x, 10);
+        test_int(pptr->y, 20);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 1);
+        test_int(pit_1.entities[0], e5);
+        test_int(pit_1.ids[0], ecs_id(Self));
+        test_int(pit_1.ids[1], ecs_id(Position));
+        test_int(pit_1.sources[0], 0);
+        test_int(pit_1.sources[1], foo);
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e5);
+
+        Position *pptr = ecs_field(&pit_1, Position, 1);
+        test_int(pptr->x, 10);
+        test_int(pptr->y, 20);
+    }
+
+    test_bool(ecs_worker_next(&pit_1), false);
+
+    /* Iter 2 */
+    {
+        test_bool(ecs_worker_next(&pit_2), true);
+        test_int(pit_2.count, 1);
+        test_int(pit_2.entities[0], e2);
+        test_int(pit_2.ids[0], ecs_id(Self));
+        test_int(pit_2.ids[1], ecs_id(Position));
+        test_int(pit_2.sources[0], 0);
+        test_int(pit_2.sources[1], foo);
+
+        Self *ptr = ecs_field(&pit_2, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e2);
+
+        Position *pptr = ecs_field(&pit_2, Position, 1);
+        test_int(pptr->x, 10);
+        test_int(pptr->y, 20);
+    }
+
+    {
+        test_bool(ecs_worker_next(&pit_2), true);
+        test_int(pit_2.count, 1);
+        test_int(pit_2.entities[0], e4);
+        test_int(pit_2.ids[0], ecs_id(Self));
+        test_int(pit_2.ids[1], ecs_id(Position));
+        test_int(pit_2.sources[0], 0);
+        test_int(pit_2.sources[1], foo);
+
+        Self *ptr = ecs_field(&pit_2, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, e4);
+
+        Position *pptr = ecs_field(&pit_2, Position, 1);
+        test_int(pptr->x, 10);
+        test_int(pptr->y, 20);
+    }
+
+    test_bool(ecs_worker_next(&pit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_paged_iter_w_task_query(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+
+    ecs_entity_t foo = ecs_new(world); ecs_set(world, foo, Self, {foo});
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self), .src.id = foo }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, 0, 0);
+
+    {
+        test_bool(ecs_page_next(&pit), true);
+        test_int(pit.count, 0);
+        test_int(pit.ids[0], ecs_id(Self));
+        test_int(pit.sources[0], foo);
+
+        Self *ptr = ecs_field(&pit, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, foo);
+    }
+
+    test_bool(ecs_page_next(&pit), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_task_query(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Self);
+
+    ecs_entity_t foo = ecs_new(world); ecs_set(world, foo, Self, {foo});
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Self), .src.id = foo }}
+    });
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t pit_1 = ecs_worker_iter(&it_1, 0, 2);
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t pit_2 = ecs_worker_iter(&it_2, 1, 2);
+
+    /* Iter 1 */
+    {
+        test_bool(ecs_worker_next(&pit_1), true);
+        test_int(pit_1.count, 0);
+        test_int(pit_1.ids[0], ecs_id(Self));
+        test_int(pit_1.sources[0], foo);
+
+        Self *ptr = ecs_field(&pit_1, Self, 0);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].value, foo);
+    }
+
+    test_bool(ecs_worker_next(&pit_1), false);
+
+    /* Iter 2 */
+
+    test_bool(ecs_worker_next(&pit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_singleton(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Singleton);
+    ECS_COMPONENT(world, Position);
+
+    ecs_singleton_add(world, Singleton);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Singleton($)" });
+
+    Position *p;
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t wit_1 = ecs_worker_iter(&it_1, 0, 2);
+    test_bool(ecs_worker_next(&wit_1), true);
+    test_int(wit_1.count, 2);
+    test_int(wit_1.entities[0], e1);
+    test_int(wit_1.entities[1], e2);
+    p = ecs_field(&wit_1, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 20);
+    test_int(p[1].y, 30);
+
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t wit_2 = ecs_worker_iter(&it_2, 1, 2);
+    test_bool(ecs_worker_next(&wit_2), true);
+    test_int(wit_2.count, 2);
+    test_int(wit_2.entities[0], e3);
+    test_int(wit_2.entities[1], e4);
+    p = ecs_field(&wit_2, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_int(p[1].x, 40);
+    test_int(p[1].y, 50);
+
+    test_bool(ecs_worker_next(&wit_2), false);
+    test_bool(ecs_worker_next(&wit_1), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_singleton_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_singleton_set(world, Velocity, {1, 2});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Velocity($)" });
+
+    Position *p;
+    Velocity *v;
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t wit_1 = ecs_worker_iter(&it_1, 0, 2);
+    test_bool(ecs_worker_next(&wit_1), true);
+    test_int(wit_1.count, 1);
+    test_int(wit_1.entities[0], e1);
+    p = ecs_field(&wit_1, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    v = ecs_field(&wit_1, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+
+    test_bool(ecs_worker_next(&wit_1), true);
+    test_int(wit_1.count, 1);
+    test_int(wit_1.entities[0], e2);
+    p = ecs_field(&wit_1, Position, 0);
+    test_int(p[0].x, 20);
+    test_int(p[0].y, 30);
+    v = ecs_field(&wit_1, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+
+    test_bool(ecs_worker_next(&wit_1), false);
+
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t wit_2 = ecs_worker_iter(&it_2, 1, 2);
+    test_bool(ecs_worker_next(&wit_2), true);
+    test_int(wit_2.count, 1);
+    test_int(wit_2.entities[0], e3);
+    p = ecs_field(&wit_2, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    v = ecs_field(&wit_2, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+
+    test_bool(ecs_worker_next(&wit_2), true);
+    test_int(wit_2.count, 1);
+    test_int(wit_2.entities[0], e4);
+    p = ecs_field(&wit_2, Position, 0);
+    test_int(p[0].x, 40);
+    test_int(p[0].y, 50);
+    v = ecs_field(&wit_2, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+
+    test_bool(ecs_worker_next(&wit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_singleton_instanced(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Singleton);
+    ECS_COMPONENT(world, Position);
+
+    ecs_singleton_add(world, Singleton);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Singleton($)",
+        .flags = EcsQueryIsInstanced
+    });
+
+    Position *p;
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t wit_1 = ecs_worker_iter(&it_1, 0, 2);
+    test_bool(ecs_worker_next(&wit_1), true);
+    test_int(wit_1.count, 2);
+    test_int(wit_1.entities[0], e1);
+    test_int(wit_1.entities[1], e2);
+    p = ecs_field(&wit_1, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 20);
+    test_int(p[1].y, 30);
+    test_bool(ecs_worker_next(&wit_1), false);
+
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t wit_2 = ecs_worker_iter(&it_2, 1, 2);
+    test_bool(ecs_worker_next(&wit_2), true);
+    test_int(wit_2.count, 2);
+    test_int(wit_2.entities[0], e3);
+    test_int(wit_2.entities[1], e4);
+    p = ecs_field(&wit_2, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_int(p[1].x, 40);
+    test_int(p[1].y, 50);
+    test_bool(ecs_worker_next(&wit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_singleton_component_instanced(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_singleton_set(world, Velocity, {1, 2});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity($)",
+        .flags = EcsQueryIsInstanced
+    });
+
+    Position *p;
+    Velocity *v;
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t wit_1 = ecs_worker_iter(&it_1, 0, 2);
+    test_bool(ecs_worker_next(&wit_1), true);
+    test_int(wit_1.count, 2);
+    test_int(wit_1.entities[0], e1);
+    test_int(wit_1.entities[1], e2);
+    p = ecs_field(&wit_1, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 20);
+    test_int(p[1].y, 30);
+    v = ecs_field(&wit_1, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+    test_bool(ecs_worker_next(&wit_1), false);
+
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t wit_2 = ecs_worker_iter(&it_2, 1, 2);
+    test_bool(ecs_worker_next(&wit_2), true);
+    test_int(wit_2.count, 2);
+    test_int(wit_2.entities[0], e3);
+    test_int(wit_2.entities[1], e4);
+    p = ecs_field(&wit_2, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_int(p[1].x, 40);
+    test_int(p[1].y, 50);
+    v = ecs_field(&wit_2, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+    test_bool(ecs_worker_next(&wit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_paged_iter_w_singleton(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Singleton);
+    ECS_COMPONENT(world, Position);
+
+    ecs_singleton_add(world, Singleton);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Singleton($)" });
+
+    Position *p;
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t pit_1 = ecs_page_iter(&it_1, 0, 2);
+    test_bool(ecs_page_next(&pit_1), true);
+    test_int(pit_1.count, 2);
+    test_int(pit_1.entities[0], e1);
+    test_int(pit_1.entities[1], e2);
+    p = ecs_field(&pit_1, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 20);
+    test_int(p[1].y, 30);
+    test_bool(ecs_page_next(&pit_1), false);
+
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t pit_2 = ecs_page_iter(&it_2, 2, 2);
+    test_bool(ecs_page_next(&pit_2), true);
+    test_int(pit_2.count, 2);
+    test_int(pit_2.entities[0], e3);
+    test_int(pit_2.entities[1], e4);
+    p = ecs_field(&pit_2, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_int(p[1].x, 40);
+    test_int(p[1].y, 50);
+    test_bool(ecs_page_next(&pit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_paged_iter_w_singleton_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_singleton_set(world, Velocity, {1, 2});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Velocity($)" });
+
+    Position *p;
+    Velocity *v;
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t pit_1 = ecs_page_iter(&it_1, 0, 2);
+    test_bool(ecs_page_next(&pit_1), true);
+    test_int(pit_1.count, 1);
+    test_int(pit_1.entities[0], e1);
+    p = ecs_field(&pit_1, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    v = ecs_field(&pit_1, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+    test_bool(ecs_page_next(&pit_1), true);
+    test_int(pit_1.count, 1);
+    test_int(pit_1.entities[0], e2);
+    p = ecs_field(&pit_1, Position, 0);
+    test_int(p[0].x, 20);
+    test_int(p[0].y, 30);
+    v = ecs_field(&pit_1, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+    test_bool(ecs_page_next(&pit_1), false);
+
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t pit_2 = ecs_page_iter(&it_2, 2, 2);
+    test_bool(ecs_page_next(&pit_2), true);
+    test_int(pit_2.count, 1);
+    test_int(pit_2.entities[0], e3);
+    p = ecs_field(&pit_2, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    v = ecs_field(&pit_2, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+    test_bool(ecs_page_next(&pit_2), true);
+    test_int(pit_2.count, 1);
+    test_int(pit_2.entities[0], e4);
+    p = ecs_field(&pit_2, Position, 0);
+    test_int(p[0].x, 40);
+    test_int(p[0].y, 50);
+    v = ecs_field(&pit_2, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+    test_bool(ecs_page_next(&pit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_paged_iter_w_singleton_instanced(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Singleton);
+    ECS_COMPONENT(world, Position);
+
+    ecs_singleton_add(world, Singleton);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Singleton($)",
+        .flags = EcsQueryIsInstanced
+    });
+
+    Position *p;
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t pit_1 = ecs_page_iter(&it_1, 0, 2);
+    test_bool(ecs_page_next(&pit_1), true);
+    test_int(pit_1.count, 2);
+    test_int(pit_1.entities[0], e1);
+    test_int(pit_1.entities[1], e2);
+    p = ecs_field(&pit_1, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 20);
+    test_int(p[1].y, 30);
+    test_bool(ecs_page_next(&pit_1), false);
+
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t pit_2 = ecs_page_iter(&it_2, 2, 2);
+    test_bool(ecs_page_next(&pit_2), true);
+    test_int(pit_2.count, 2);
+    test_int(pit_2.entities[0], e3);
+    test_int(pit_2.entities[1], e4);
+    p = ecs_field(&pit_2, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_int(p[1].x, 40);
+    test_int(p[1].y, 50);
+    test_bool(ecs_page_next(&pit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_paged_iter_w_singleton_component_instanced(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_singleton_set(world, Velocity, {1, 2});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity($)",
+        .flags = EcsQueryIsInstanced
+    });
+
+    Position *p;
+    Velocity *v;
+
+    ecs_iter_t it_1 = ecs_query_iter(world, q);
+    ecs_iter_t pit_1 = ecs_page_iter(&it_1, 0, 2);
+    test_bool(ecs_page_next(&pit_1), true);
+    test_int(pit_1.count, 2);
+    test_int(pit_1.entities[0], e1);
+    test_int(pit_1.entities[1], e2);
+    p = ecs_field(&pit_1, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 20);
+    test_int(p[1].y, 30);
+    v = ecs_field(&pit_1, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+    test_bool(ecs_page_next(&pit_1), false);
+
+    ecs_iter_t it_2 = ecs_query_iter(world, q);
+    ecs_iter_t pit_2 = ecs_page_iter(&it_2, 2, 2);
+    test_bool(ecs_page_next(&pit_2), true);
+    test_int(pit_2.count, 2);
+    test_int(pit_2.entities[0], e3);
+    test_int(pit_2.entities[1], e4);
+    p = ecs_field(&pit_2, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_int(p[1].x, 40);
+    test_int(p[1].y, 50);
+    v = ecs_field(&pit_2, Velocity, 1);
+    test_int(v[0].x, 1);
+    test_int(v[0].y, 2);
+    test_bool(ecs_page_next(&pit_2), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+static
+void Iter(ecs_world_t *world, ecs_query_t *q, int32_t offset, int32_t limit) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_t pit = ecs_page_iter(&it, offset, limit);
+    while (ecs_page_next(&pit)) {
+        Position *p = ecs_field(&pit, Position, 0);
+        Velocity *v = NULL;
+        Mass *m = NULL;
+
+        if (pit.field_count >= 2) {
+            v = ecs_field(&pit, Velocity, 1);
+        }
+
+        if (pit.field_count >= 3) {
+            m = ecs_field(&pit, Mass, 2);
+        }
+
+        int *param = pit.param;
+
+        probe_iter(&pit);
+
+        int i;
+        for (i = 0; i < pit.count; i ++) {
+            p[i].x = 10;
+            p[i].y = 20;
+
+            if (param) {
+                p[i].x += *param;
+                p[i].y += *param;
+            }
+
+            if (v) {
+                v[i].x = 30;
+                v[i].y = 40;
+            }
+
+            if (m) {
+                m[i] = 50;
+            }
+        }
+    }
+}
+
+void Iter_page_iter_w_offset_skip_1_archetype(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 3, 0);
+
+    test_int(ctx.count, 3);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e4);
+    test_int(ctx.e[1], e5);
+    test_int(ctx.e[2], e6);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_offset_skip_1_archetype_plus_one(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 4, 0);
+
+    test_int(ctx.count, 2);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e5);
+    test_int(ctx.e[1], e6);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_offset_skip_2_archetypes(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 5, 0);
+
+    test_int(ctx.count, 1);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e6);
+
+    test_int(ctx.c[0][0], ecs_id(Position));
+    test_int(ctx.s[0][0], 0);
+    test_int(ctx.c[0][1], ecs_id(Velocity));
+    test_int(ctx.s[0][1], 0);
+
+    const Position *p = ecs_get(world, e6, Position);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+    const Velocity *v = ecs_get(world, e6, Velocity);
+    test_int(v->x, 30);
+    test_int(v->y, 40);        
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_limit_skip_1_archetype(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 0, 5);
+
+    test_int(ctx.count, 5);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e1);
+    test_int(ctx.e[1], e2);
+    test_int(ctx.e[2], e3);
+    test_int(ctx.e[3], e4);
+    test_int(ctx.e[4], e5);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_limit_skip_1_archetype_minus_one(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 0, 4);
+
+    test_int(ctx.count, 4);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e1);
+    test_int(ctx.e[1], e2);
+    test_int(ctx.e[2], e3);
+    test_int(ctx.e[3], e4);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_limit_skip_2_archetypes(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 0, 3);
+
+    test_int(ctx.count, 3);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e1);
+    test_int(ctx.e[1], e2);
+    test_int(ctx.e[2], e3);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_offset_1_limit_max(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 1, 5);
+
+    test_int(ctx.count, 5);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e2);
+    test_int(ctx.e[1], e3);
+    test_int(ctx.e[2], e4);
+    test_int(ctx.e[3], e5);
+    test_int(ctx.e[4], e6);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_offset_1_limit_minus_1(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 1, 4);
+
+    test_int(ctx.count, 4);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e2);
+    test_int(ctx.e[1], e3);
+    test_int(ctx.e[2], e4);
+    test_int(ctx.e[3], e5);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_offset_2_type_limit_max(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 3, 3);
+
+    test_int(ctx.count, 3);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e4);
+    test_int(ctx.e[1], e5);
+    test_int(ctx.e[2], e6);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_offset_2_type_limit_minus_1(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 3, 2);
+
+    test_int(ctx.count, 2);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e4);
+    test_int(ctx.e[1], e5);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_limit_1_all_offsets(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 0, 1);
+    Iter(world, q, 2, 1);
+    Iter(world, q, 1, 1);
+    Iter(world, q, 3, 1);
+    Iter(world, q, 5, 1);
+    Iter(world, q, 4, 1);
+
+    test_int(ctx.count, 6);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e1);
+    test_int(ctx.e[1], e3);
+    test_int(ctx.e[2], e2);
+    test_int(ctx.e[3], e4);
+    test_int(ctx.e[4], e6);
+    test_int(ctx.e[5], e5);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_offset_out_of_bounds(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 6, 1);
+
+    test_int(ctx.count, 0);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_limit_out_of_bounds(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ECS_ENTITY(world, e1, Position, Velocity);
+    ECS_ENTITY(world, e2, Position, Velocity);
+    ECS_ENTITY(world, e3, Position, Velocity);
+    ECS_ENTITY(world, e4, Position, Velocity, Mass);
+    ECS_ENTITY(world, e5, Position, Velocity, Mass);
+    ECS_ENTITY(world, e6, Position, Velocity, Rotation);
+    ECS_ENTITY(world, e7, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 5, 2);
+
+    test_int(ctx.count, 1);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e6);
+
+    int i;
+    for (i = 0; i < ctx.invoked; i ++) {
+        test_int(ctx.c[i][0], ecs_id(Position));
+        test_int(ctx.s[i][0], 0);
+        test_int(ctx.c[i][1], ecs_id(Velocity));
+        test_int(ctx.s[i][1], 0);
+    }
+
+    for (i = 0; i < ctx.count; i ++) {
+        const Position *p = ecs_get(world, ctx.e[i], Position);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_get(world, ctx.e[i], Velocity);
+        test_int(v->x, 30);
+        test_int(v->y, 40);        
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_no_match(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ECS_ENTITY(world, e1, Position);
+
+    ECS_QUERY(world, q, Position, Velocity);
+
+    Probe ctx = {0};
+    ecs_set_ctx(world, &ctx, NULL);
+
+    Iter(world, q, 0, 0);
+
+    test_int(ctx.count, 0);
+
+    ecs_fini(world);
+}
+
+typedef struct Param {
+    ecs_entity_t entity;
+    int count;
+} Param;
+
+static ECS_QUERY_DECLARE(qTestSubset);
+
+static
+void TestSubset(ecs_world_t *world, ecs_query_t *query, int32_t offset, 
+    int32_t limit, Param *param) 
+{
+    ecs_iter_t it = ecs_query_iter(world, query);
+    ecs_iter_t pit = ecs_page_iter(&it, offset, limit);
+    while (ecs_page_next(&pit)) {
+        int i;
+        for (i = 0; i < pit.count; i ++) {
+            test_assert(param->entity != pit.entities[i]);
+            param->count ++;
+        }
+    }
+}
+
+static
+void TestAll(ecs_world_t *world, ecs_query_t *query) {
+    ecs_iter_t it = ecs_query_iter(world, query);
+    while (ecs_query_next(&it)) {
+        Position *p = ecs_field(&it, Position, 0);
+
+        int i;
+        for (i = 0; i < it.count; i ++) {
+            Param param = {.entity = it.entities[i], 0};
+            TestSubset(world, qTestSubset, it.frame_offset + i + 1, 0, &param);
+            p[i].x += param.count;
+        }
+    }
+}
+
+void Iter_page_iter_comb_10_entities_1_type(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ECS_QUERY_DEFINE(world, qTestSubset, Position);
+    ECS_QUERY(world, qTestAll, Position);
+
+    int i, ENTITIES = 10;
+
+    const ecs_entity_t *ids = ecs_bulk_new(world, Position, ENTITIES);
+
+    for (i = 0; i < ENTITIES; i ++) {
+        ecs_set(world, ids[i], Position, {1, 2});
+    }
+
+    TestAll(world, qTestAll);
+
+    for (i = 0; i < ENTITIES; i ++) {
+        const Position *p = ecs_get(world, ids[i], Position);
+        test_int(p->x, ENTITIES - i);
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_comb_10_entities_2_types(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ECS_QUERY_DEFINE(world, qTestSubset, Position);
+    ECS_QUERY(world, qTestAll, Position);
+
+    int i, ENTITIES = 10;
+    ecs_entity_t ids_1[5], ids_2[5];
+
+    for (int i = 0; i < ENTITIES / 2; i ++) {
+        ids_1[i] = ecs_insert(world, ecs_value(Position, {1, 2}));
+    }
+    for (int i = 0; i < ENTITIES / 2; i ++) {
+        ids_2[i] = ecs_insert(world, ecs_value(Position, {1, 2}));
+        ecs_add(world, ids_2[i], Velocity);
+    } 
+
+    TestAll(world, qTestAll);
+
+    for (i = 0; i < 5; i ++) {
+        const Position *p = ecs_get(world, ids_1[i], Position);
+        test_int(p->x, ENTITIES - i);
+
+        p = ecs_get(world, ids_2[i], Position);
+        test_int(p->x, ENTITIES - (i + 5));
+    }
+
+    ecs_fini(world);
+}
+
+void Iter_count(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    for (int i = 0; i < 500; i ++) {
+        ecs_entity_t e = ecs_new_w(world, TagA);
+        if (!(i % 2)) {
+            ecs_add(world, e, TagB);
+        }
+        if (!(i % 3)) {
+            ecs_add(world, e, TagC);
+        }
+    }
+
+    ecs_query_t *q = ecs_query(world, { .expr = "TagA" });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_int(500, ecs_iter_count(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_interleaved_iter(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ TagA }}
+    });
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+
+    /* Bit of whitebox testing, check whether the stack cursor is restored to
+     * its original position after the 2nd iterator is done */
+    ecs_iter_t it_1 = ecs_query_iter(world, f);
+    ecs_stack_cursor_t cursor = *it_1.priv_.cache.stack_cursor;
+    ecs_iter_t it_2 = ecs_query_iter(world, f);
+
+    test_bool(true, ecs_query_next(&it_1));
+    test_bool(true, ecs_query_next(&it_2));
+    test_int(e1, it_1.entities[0]);
+    test_int(e1, it_2.entities[0]);
+
+    test_bool(true, ecs_query_next(&it_1));
+    test_bool(true, ecs_query_next(&it_2));
+    test_int(e2, it_1.entities[0]);
+    test_int(e2, it_2.entities[0]);
+
+    test_bool(false, ecs_query_next(&it_1));
+    test_bool(false, ecs_query_next(&it_2));
+
+    it_1 = ecs_query_iter(world, f);
+    test_assert(it_1.priv_.cache.stack_cursor->page == cursor.page);
+    test_assert(it_1.priv_.cache.stack_cursor->sp == cursor.sp);
+    ecs_iter_fini(&it_1);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_iter_restore_stack_iter(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ ecs_id(Position) }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_stack_cursor_t cursor = *it.priv_.cache.stack_cursor;
+    ecs_iter_fini(&it);
+
+    it = ecs_query_iter(world, f);
+    test_assert(it.priv_.cache.stack_cursor->page == cursor.page);
+    test_assert(it.priv_.cache.stack_cursor->sp == cursor.sp);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_get_first(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e = ecs_new_w(world, Tag);
+    ecs_new_w(world, Tag);
+    ecs_new_w(world, Tag);
+
+    ecs_query_t *f = ecs_query_init(world, &(ecs_query_desc_t){
+        .terms = {{ Tag }}
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_entity_t first = ecs_iter_first(&it);
+    test_assert(first == e);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_only_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ Tag }}
+    });
+    
+    ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_iter_t pit = ecs_page_iter(&it, 1, 0);
+
+    test_assert(ecs_page_next(&pit));
+    test_int(pit.count, 1);
+    test_uint(pit.entities[0], e2);
+    test_assert(!ecs_page_next(&pit));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_only_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ Tag }}
+    });
+    
+    ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_iter_t pit = ecs_worker_iter(&it, 1, 2);
+
+    test_assert(ecs_worker_next(&pit));
+    test_int(pit.count, 1);
+    test_uint(pit.entities[0], e2);
+    test_assert(!ecs_worker_next(&pit));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_inout_none(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ ecs_id(Position), .inout = EcsInOutNone }}
+    });
+    
+    ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_iter_t pit = ecs_page_iter(&it, 1, 0);
+
+    test_assert(ecs_page_next(&pit));
+    test_int(pit.count, 1);
+    test_uint(pit.entities[0], e2);
+    test_assert(!ecs_page_next(&pit));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_inout_none(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ ecs_id(Position), .inout = EcsInOutNone }}
+    });
+    
+    ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_iter_t pit = ecs_worker_iter(&it, 1, 2);
+
+    test_assert(ecs_worker_next(&pit));
+    test_int(pit.count, 1);
+    test_uint(pit.entities[0], e2);
+    test_assert(!ecs_worker_next(&pit));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_ctx(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ TagA  }}
+    });
+    
+    ecs_new_w(world, TagA);
+
+    int ctx;
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    it.ctx = &ctx;
+
+    ecs_iter_t pit = ecs_page_iter(&it, 0, 1);
+    test_assert(pit.ctx == &ctx);
+
+    test_assert(ecs_page_next(&pit));
+    test_assert(!ecs_page_next(&pit));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_binding_ctx(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ TagA  }}
+    });
+    
+    ecs_new_w(world, TagA);
+
+    int ctx;
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    it.binding_ctx = &ctx;
+
+    ecs_iter_t pit = ecs_page_iter(&it, 0, 1);
+    test_assert(pit.binding_ctx == &ctx);
+
+    test_assert(ecs_page_next(&pit));
+    test_assert(!ecs_page_next(&pit));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_ctx(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ TagA  }}
+    });
+    
+    ecs_new_w(world, TagA);
+
+    int ctx;
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    it.ctx = &ctx;
+
+    ecs_iter_t pit = ecs_worker_iter(&it, 0, 2);
+    test_assert(pit.ctx == &ctx);
+
+    test_assert(ecs_worker_next(&pit));
+    test_assert(!ecs_worker_next(&pit));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_binding_ctx(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ TagA  }}
+    });
+    
+    ecs_new_w(world, TagA);
+
+    int ctx;
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    it.binding_ctx = &ctx;
+
+    ecs_iter_t pit = ecs_worker_iter(&it, 0, 2);
+    test_assert(pit.binding_ctx == &ctx);
+
+    test_assert(ecs_worker_next(&pit));
+    test_assert(!ecs_worker_next(&pit));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_column_index_owned(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ TagB }, { TagC }, { TagA }}
+    });
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e1, TagC);
+
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e2, TagC);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_int(1, ecs_field_column(&it, 0));
+    test_int(2, ecs_field_column(&it, 1));
+    test_int(0, ecs_field_column(&it, 2));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_int(2, ecs_field_column(&it, 0));
+    test_int(3, ecs_field_column(&it, 1));
+    test_int(1, ecs_field_column(&it, 2));
+    
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_column_index_shared(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ TagB }, { TagC }, { TagA }}
+    });
+
+    ecs_entity_t base = ecs_new_w(world, TagA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, EcsIsA, base);
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e1, TagC);
+
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add_pair(world, e2, EcsIsA, base);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e2, TagC);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_int(0, ecs_field_column(&it, 0));
+    test_int(1, ecs_field_column(&it, 1));
+    test_int(0, ecs_field_column(&it, 2));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_int(1, ecs_field_column(&it, 0));
+    test_int(2, ecs_field_column(&it, 1));
+    test_int(0, ecs_field_column(&it, 2));
+    
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_column_index_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ TagB }, { TagC }, { TagA, .oper = EcsNot }}
+    });
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e1, TagC);
+
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e2, TagC);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_int(0, ecs_field_column(&it, 0));
+    test_int(1, ecs_field_column(&it, 1));
+    test_int(0, ecs_field_column(&it, 2));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_int(1, ecs_field_column(&it, 0));
+    test_int(2, ecs_field_column(&it, 1));
+    test_int(0, ecs_field_column(&it, 2));
+    
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_page_iter_w_fini(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ ecs_id(Position) }}
+    });
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_add(world, e2, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_iter_t pit = ecs_page_iter(&it, 0, 2);
+    test_bool(true, ecs_page_next(&pit));
+    test_int(pit.count, 1);
+    test_int(pit.entities[0], e1);
+    
+    ecs_iter_fini(&pit);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_worker_iter_w_fini(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ ecs_id(Position) }}
+    });
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_add(world, e2, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    ecs_iter_t pit = ecs_worker_iter(&it, 0, 2);
+    test_bool(true, ecs_worker_next(&pit));
+    test_int(pit.count, 1);
+    test_int(pit.entities[0], e1);
+    ecs_iter_fini(&pit);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Iter_rule_page_iter_w_fini(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .terms = {{ ecs_id(Position) }}
+    });
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_add(world, e2, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    ecs_iter_t pit = ecs_page_iter(&it, 0, 2);
+    test_bool(true, ecs_page_next(&pit));
+    test_int(pit.count, 1);
+    test_int(pit.entities[0], e1);
+    ecs_iter_fini(&pit);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Iter_rule_worker_iter_w_fini(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .terms = {{ ecs_id(Position) }}
+    });
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_add(world, e2, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    ecs_iter_t pit = ecs_worker_iter(&it, 0, 2);
+    test_bool(true, ecs_worker_next(&pit));
+    test_int(pit.count, 1);
+    test_int(pit.entities[0], e1);
+    ecs_iter_fini(&pit);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Iter_to_str_before_next(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag" });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *str = ecs_iter_str(&it);
+    test_assert(str == NULL);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Iter_to_str(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
+    ecs_add(world, e, Tag);
+
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag" });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    char *str = ecs_iter_str(&it);
+    test_assert(str != NULL);
+    test_str(str, 
+        "id:  Tag\n"
+        "src: 0\n"
+        "set: true\n"
+        "this:\n"
+        "    - foo\n"
+    );
+    ecs_os_free(str);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
diff --git a/test/api/src/Lookup.c b/test/core/src/Lookup.c
similarity index 94%
rename from test/api/src/Lookup.c
rename to test/core/src/Lookup.c
index 93630702a..48e43f98f 100644
--- a/test/api/src/Lookup.c
+++ b/test/core/src/Lookup.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 #include <stdio.h>
 
 void Lookup_setup(void) {
@@ -35,7 +35,7 @@ void Lookup_lookup_w_null_name(void) {
 void Lookup_lookup_after_name_reset(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     ecs_entity_t lookup = ecs_lookup(world, "foo");
     test_assert(e == lookup);
 
@@ -113,7 +113,7 @@ void Lookup_get_name_no_name(void) {
     ECS_COMPONENT(world, Position);
 
     /* Ensure this doesn't crash the lookup function */
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     const char *id = ecs_get_name(world, e);
     test_assert(id == NULL);
 
@@ -124,7 +124,7 @@ void Lookup_get_name_from_empty(void) {
     ecs_world_t *world = ecs_mini();
 
     /* Ensure this doesn't crash the lookup function */
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     const char *id = ecs_get_name(world, e);
     test_assert(id == NULL);
 
@@ -148,7 +148,7 @@ void Lookup_lookup_by_id(void) {
 void Lookup_lookup_recycled_by_id(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     char buf[20];
@@ -159,7 +159,7 @@ void Lookup_lookup_recycled_by_id(void) {
     test_assert(l == e);
 
     ecs_delete(world, e);
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert((uint32_t)r == e);
     test_assert(r != e);
 
@@ -242,7 +242,7 @@ void Lookup_lookup_path_w_spaces(void) {
 void Lookup_set_name_of_existing(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_assert(ecs_get_name(world, e) == NULL);
 
@@ -397,7 +397,7 @@ void Lookup_lookup_path_wildcard(void) {
 void Lookup_lookup_path_this_from_scope(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t scope = ecs_new_id(world);
+    ecs_entity_t scope = ecs_new(world);
 
     ecs_entity_t lookup = ecs_lookup_path_w_sep(world, scope, ".", NULL, NULL, false);
     test_assert(lookup != 0);
@@ -409,7 +409,7 @@ void Lookup_lookup_path_this_from_scope(void) {
 void Lookup_lookup_path_wildcard_from_scope(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t scope = ecs_new_id(world);
+    ecs_entity_t scope = ecs_new(world);
 
     ecs_entity_t lookup = ecs_lookup_path_w_sep(world, scope, ".", NULL, NULL, false);
     test_assert(lookup != 0);
@@ -574,7 +574,7 @@ void Lookup_lookup_custom_search_path_n_elems(void) {
 void Lookup_set_same_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_entity(world, "MyName");
+    ecs_entity_t e = ecs_entity(world, { .name = "MyName" });
     test_assert(e != 0);
     test_str("MyName", ecs_get_name(world, e));
     test_uint(e, ecs_lookup(world, "MyName"));
@@ -589,8 +589,8 @@ void Lookup_set_same_name(void) {
 void Lookup_set_same_name_after_reparenting(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
-    ecs_entity_t e = ecs_new_entity(world, "MyName");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
+    ecs_entity_t e = ecs_entity(world, { .name = "MyName" });
     test_assert(e != 0);
     test_str("MyName", ecs_get_name(world, e));
     test_uint(e, ecs_lookup(world, "MyName"));
@@ -609,7 +609,7 @@ void Lookup_set_same_name_after_reparenting(void) {
 void Lookup_defer_set_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     test_assert(e != 0);
     test_str("Foo", ecs_get_name(world, e));
     test_uint(e, ecs_lookup(world, "Foo"));
@@ -627,7 +627,7 @@ void Lookup_defer_set_name(void) {
 void Lookup_defer_set_same_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_entity(world, "MyName");
+    ecs_entity_t e = ecs_entity(world, { .name = "MyName" });
     test_assert(e != 0);
     test_str("MyName", ecs_get_name(world, e));
     test_uint(e, ecs_lookup(world, "MyName"));
@@ -654,7 +654,7 @@ void Lookup_lookup_invalid_digit(void) {
 void Lookup_lookup_child_invalid_digit(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_entity(world, "p");
+    ecs_entity_t parent = ecs_entity(world, { .name = "p" });
     test_assert(parent != 0);
     ecs_entity_t child = ecs_lookup_child(world, parent, "111111111111");
     test_assert(child == 0);
@@ -665,7 +665,7 @@ void Lookup_lookup_child_invalid_digit(void) {
 void Lookup_lookup_digit_from_wrong_scope(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_entity(world, "p");
+    ecs_entity_t parent = ecs_entity(world, { .name = "p" });
     test_assert(parent != 0);
     ecs_entity_t child = ecs_lookup(world, "p.1");
     test_assert(child == 0);
@@ -676,7 +676,7 @@ void Lookup_lookup_digit_from_wrong_scope(void) {
 void Lookup_lookup_core_entity_from_wrong_scope(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_entity(world, "p");
+    ecs_entity_t parent = ecs_entity(world, { .name = "p" });
     test_assert(parent != 0);
     ecs_entity_t child = ecs_lookup(world, "p.10.Component");
     test_assert(child == 0);
@@ -687,7 +687,7 @@ void Lookup_lookup_core_entity_from_wrong_scope(void) {
 void Lookup_lookup_alias_w_number(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_entity(world, "p");
+    ecs_entity_t parent = ecs_entity(world, { .name = "p" });
     test_assert(parent != 0);
     ecs_set_alias(world, parent, "10p");
 
@@ -700,8 +700,8 @@ void Lookup_lookup_alias_w_number(void) {
 void Lookup_lookup_symbol_path(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t foo = ecs_new_entity(world, "foo");
-    ecs_entity_t bar = ecs_new_entity(world, "bar");
+    ecs_entity_t foo = ecs_entity(world, { .name = "foo" });
+    ecs_entity_t bar = ecs_entity(world, { .name = "bar" });
     ecs_add_pair(world, bar, EcsChildOf, foo);
 
     ecs_entity_t e = ecs_set_symbol(world, 0, "foo.bar");
diff --git a/test/api/src/Monitor.c b/test/core/src/Monitor.c
similarity index 92%
rename from test/api/src/Monitor.c
rename to test/core/src/Monitor.c
index a3a72b85d..92b74d9a6 100644
--- a/test/api/src/Monitor.c
+++ b/test/core/src/Monitor.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static
 void OnPosition(ecs_iter_t *it) {
@@ -15,7 +15,7 @@ void Monitor_1_comp(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
     test_int(ctx.system, OnPosition);
@@ -47,7 +47,7 @@ void Monitor_2_comps(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_add(world, e, Velocity);
@@ -94,7 +94,7 @@ void Monitor_1_comp_1_not(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
     test_int(ctx.system, OnPosition);
@@ -133,15 +133,15 @@ void Monitor_1_parent(void) {
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
-    ECS_OBSERVER(world, OnPosition, EcsOnAdd, Position(parent));
+    ECS_OBSERVER(world, OnPosition, EcsOnAdd, Position(up));
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t parent = ecs_new(world, Position);
+    ecs_entity_t parent = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsChildOf, parent);
@@ -164,15 +164,15 @@ void Monitor_1_comp_1_parent(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_OBSERVER(world, OnPosition, EcsMonitor, 
-        Position, Position(up(ChildOf)));
+        Position, Position(up ChildOf));
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t parent = ecs_new(world, Position);
+    ecs_entity_t parent = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsChildOf, parent);
@@ -278,7 +278,7 @@ void Monitor_monitor_w_and(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -318,7 +318,7 @@ void Monitor_monitor_w_or(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_int(ctx.invoked, 0); // No match, filter doesn't match yet
 
@@ -355,7 +355,7 @@ void Monitor_monitor_w_not(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -389,7 +389,7 @@ void Monitor_monitor_w_optional(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1); // First match, trigger OnAdd
@@ -424,20 +424,20 @@ void Monitor_monitor_w_superset(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
-    ECS_OBSERVER(world, OnPosition, EcsMonitor, Position, Velocity(up));
+    ECS_OBSERVER(world, OnPosition, EcsMonitor, Position, Velocity(up IsA));
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t base_1 = ecs_new(world, Velocity);
+    ecs_entity_t base_1 = ecs_new_w(world, Velocity);
     test_assert(base_1 != 0);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base_2 = ecs_new(world, Velocity);
+    ecs_entity_t base_2 = ecs_new_w(world, Velocity);
     test_assert(base_2 != 0);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -471,20 +471,20 @@ void Monitor_monitor_w_self_superset(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
-    ECS_OBSERVER(world, OnPosition, EcsMonitor, Position, Velocity(self|up));
+    ECS_OBSERVER(world, OnPosition, EcsMonitor, Position, Velocity(self|up IsA));
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t base_1 = ecs_new(world, Velocity);
+    ecs_entity_t base_1 = ecs_new_w(world, Velocity);
     test_assert(base_1 != 0);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base_2 = ecs_new(world, Velocity);
+    ecs_entity_t base_2 = ecs_new_w(world, Velocity);
     test_assert(base_2 != 0);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -537,7 +537,7 @@ void Monitor_monitor_w_wildcard(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -585,7 +585,7 @@ void Monitor_monitor_at_fini(void) {
     Probe ctx = {0};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }},
+        .query.terms = {{ TagA }},
         .events = {EcsMonitor},
         .callback = Monitor,
         .ctx = &ctx
@@ -593,7 +593,7 @@ void Monitor_monitor_at_fini(void) {
 
     test_int(ctx.invoked, 0);
 
-	ecs_entity_t e = ecs_new_id(world);
+	ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagA);
 
     test_int(ctx.invoked, 1);
@@ -630,13 +630,13 @@ void Monitor_monitor_other_table(void) {
     ECS_TAG(world, X);
     ECS_TAG(world, Y);
 
-    ecs_entity_t x = ecs_new(world, X);
-    ecs_entity_t xy = ecs_new(world, X);
+    ecs_entity_t x = ecs_new_w(world, X);
+    ecs_entity_t xy = ecs_new_w(world, X);
     ecs_add(world, xy, Y);
 
     check_table_t ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {
+        .query.terms = {
             { X },
             { Y, .oper = EcsNot }
         },
@@ -648,7 +648,7 @@ void Monitor_monitor_other_table(void) {
     ctx.table = ecs_get_table(world, x);
     ctx.other_table = NULL;
     ctx.event = EcsOnAdd;
-    ecs_entity_t e = ecs_new(world, X);
+    ecs_entity_t e = ecs_new_w(world, X);
     test_int(ctx.invoked, 1);
 
     ctx.table = ecs_get_table(world, xy);
@@ -681,7 +681,7 @@ static void CheckComponent(ecs_iter_t *it) {
 
     test_assert(it->event == ctx->event);
 
-    ctx->result = ecs_field(it, Position, 1);
+    ctx->result = ecs_field(it, Position, 0);
     ctx->invoked ++;
 }
 
@@ -693,7 +693,7 @@ void Monitor_monitor_component(void) {
 
     check_component_t ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {
+        .query.terms = {
             { ecs_id(Position) },
             { Tag, .oper = EcsNot }
         },
@@ -703,7 +703,7 @@ void Monitor_monitor_component(void) {
     });
 
     ctx.event = EcsOnAdd;
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     const Position *expect = ecs_get(world, e, Position);
     test_int(ctx.invoked, 1);
     test_assert(ctx.result == expect);
diff --git a/test/api/src/New.c b/test/core/src/New.c
similarity index 81%
rename from test/api/src/New.c
rename to test/core/src/New.c
index afc2350b0..2194a3ac8 100644
--- a/test/api/src/New.c
+++ b/test/core/src/New.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void New_setup(void) {
     ecs_log_set_level(-2);
@@ -7,7 +7,7 @@ void New_setup(void) {
 void New_empty(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_assert(!ecs_get_type(world, e));
 
@@ -19,7 +19,7 @@ void New_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(ecs_has(world, e, Position));
 
@@ -59,11 +59,11 @@ void New_redefine_component(void) {
 void New_recycle_id_empty(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
     ecs_delete(world, e1);
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e2 != 0);
     test_assert(e1 != e2);
     test_assert((e1 & ECS_ENTITY_MASK) == (e2 & ECS_ENTITY_MASK));
@@ -74,7 +74,7 @@ void New_recycle_id_empty(void) {
 void New_recycle_id_w_entity(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t tag = ecs_new(world, 0);
+    ecs_entity_t tag = ecs_new(world);
 
     ecs_entity_t e1 = ecs_new_w_id(world, tag);
     test_assert(e1 != 0);
@@ -91,14 +91,14 @@ void New_recycle_id_w_entity(void) {
 void New_recycle_empty_staged_delete(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
     ecs_defer_begin(world);
     ecs_delete(world, e1);
     ecs_defer_end(world);
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e2 != 0);
     test_assert(e1 != e2);
     test_assert((e1 & ECS_ENTITY_MASK) == (e2 & ECS_ENTITY_MASK));
@@ -111,14 +111,14 @@ void New_recycle_staged_delete(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
 
     ecs_defer_begin(world);
     ecs_delete(world, e1);
     ecs_defer_end(world);
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e2 != 0);
     test_assert(e1 != e2);
     test_assert((e1 & ECS_ENTITY_MASK) == (e2 & ECS_ENTITY_MASK));
@@ -129,7 +129,7 @@ void New_recycle_staged_delete(void) {
 void New_new_id(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_assert(!ecs_get_type(world, e));
 
@@ -190,7 +190,7 @@ void New_new_component_id_skip_to_hi_id(void) {
     test_assert(e2 > FLECS_HI_COMPONENT_ID);
     test_assert(!ecs_get_type(world, e2));
 
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e3 = ecs_new(world);
     test_assert(e3 != e2);
     test_assert(e3 > e2);
     test_assert(!ecs_get_type(world, e3));
@@ -201,7 +201,7 @@ void New_new_component_id_skip_to_hi_id(void) {
 void New_new_hi_component_id(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_entity_t c;
@@ -216,11 +216,12 @@ void New_new_hi_component_id(void) {
 }
 
 void New_new_w_entity_0(void) {
+    install_test_abort();
+
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_w_id(world, 0);
-    test_assert(e != 0);
-    test_assert(ecs_get_type(world, e) == NULL);
+    test_expect_abort();
+    ecs_new_w_id(world, 0);
 
     ecs_fini(world);
 }
@@ -253,19 +254,16 @@ void New_create_w_explicit_id_2_worlds(void) {
 }
 
 void New_new_w_id_0_w_with(void) {
+    install_test_abort();
+
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     ecs_set_with(world, Tag);
 
-    ecs_entity_t e = ecs_new_w_id(world, 0);
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Tag));
-
-    test_int(ecs_set_with(world, 0), Tag);
-
-    ecs_fini(world);
+    test_expect_abort();
+    ecs_new_w_id(world, 0);
 }
 
 void New_new_w_id_w_with(void) {
@@ -278,7 +276,7 @@ void New_new_w_id_w_with(void) {
 
     ecs_entity_t e = ecs_new_w_id(world, Tag2);
     test_assert(e != 0);
-    test_assert(ecs_has(world, e, Tag));
+    test_assert(!ecs_has(world, e, Tag));
     test_assert(ecs_has(world, e, Tag2));
 
     test_int(ecs_set_with(world, 0), Tag);
@@ -294,14 +292,14 @@ void New_new_w_id_w_with_w_scope(void) {
 
     ecs_set_with(world, Tag);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_set_scope(world, parent);
 
     ecs_entity_t e = ecs_new_w_id(world, Tag2);
     test_assert(e != 0);
-    test_assert(ecs_has(world, e, Tag));
+    test_assert(!ecs_has(world, e, Tag));
     test_assert(ecs_has(world, e, Tag2));
-    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+    test_assert(!ecs_has_pair(world, e, EcsChildOf, parent));
 
     test_int(ecs_set_with(world, 0), Tag);
     test_int(ecs_set_scope(world, 0), parent);
@@ -327,7 +325,7 @@ void New_new_w_id_w_with_defer(void) {
 
     ecs_defer_end(world);
 
-    test_assert(ecs_has(world, e, Tag));
+    test_assert(!ecs_has(world, e, Tag));
     test_assert(ecs_has(world, e, Tag2));
 
     test_int(ecs_set_with(world, 0), Tag);
@@ -343,7 +341,7 @@ void New_new_w_id_w_with_defer_w_scope(void) {
 
     ecs_set_with(world, Tag);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_set_scope(world, parent);
 
     ecs_defer_begin(world);
@@ -357,9 +355,9 @@ void New_new_w_id_w_with_defer_w_scope(void) {
 
     ecs_defer_end(world);
 
-    test_assert(ecs_has(world, e, Tag));
+    test_assert(!ecs_has(world, e, Tag));
     test_assert(ecs_has(world, e, Tag2));
-    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+    test_assert(!ecs_has_pair(world, e, EcsChildOf, parent));
 
     test_int(ecs_set_with(world, 0), Tag);
     test_int(ecs_set_scope(world, 0), parent);
@@ -367,22 +365,6 @@ void New_new_w_id_w_with_defer_w_scope(void) {
     ecs_fini(world);
 }
 
-void New_new_w_type_0_w_with(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-
-    ecs_set_with(world, Tag);
-
-    ecs_entity_t e = ecs_new(world, 0);
-    test_assert(e != 0);
-    test_assert(ecs_has(world, e, Tag));
-
-    test_int(ecs_set_with(world, 0), Tag);
-
-    ecs_fini(world);
-}
-
 void New_new_w_type_w_with(void) {
     ecs_world_t *world = ecs_mini();
 
@@ -391,9 +373,9 @@ void New_new_w_type_w_with(void) {
 
     ecs_set_with(world, Tag);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
-    test_assert(ecs_has(world, e, Tag));
+    test_assert(!ecs_has(world, e, Tag));
     test_assert(ecs_has(world, e, Position));
 
     test_int(ecs_set_with(world, 0), Tag);
@@ -409,14 +391,14 @@ void New_new_w_type_w_with_w_scope(void) {
 
     ecs_set_with(world, Tag);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_set_scope(world, parent);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
-    test_assert(ecs_has(world, e, Tag));
+    test_assert(!ecs_has(world, e, Tag));
     test_assert(ecs_has(world, e, Position));
-    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+    test_assert(!ecs_has_pair(world, e, EcsChildOf, parent));
 
     test_int(ecs_set_with(world, 0), Tag);
     test_int(ecs_set_scope(world, 0), parent);
@@ -434,7 +416,7 @@ void New_new_w_type_w_with_defer(void) {
 
     ecs_defer_begin(world);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     
     test_assert(!ecs_has(world, e, Tag));
@@ -442,7 +424,7 @@ void New_new_w_type_w_with_defer(void) {
 
     ecs_defer_end(world);
 
-    test_assert(ecs_has(world, e, Tag));
+    test_assert(!ecs_has(world, e, Tag));
     test_assert(ecs_has(world, e, Position));
 
     test_int(ecs_set_with(world, 0), Tag);
@@ -458,12 +440,12 @@ void New_new_w_type_w_with_defer_w_scope(void) {
 
     ecs_set_with(world, Tag);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_set_scope(world, parent);
 
     ecs_defer_begin(world);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_assert(!ecs_has(world, e, Tag));
@@ -472,9 +454,9 @@ void New_new_w_type_w_with_defer_w_scope(void) {
 
     ecs_defer_end(world);
 
-    test_assert(ecs_has(world, e, Tag));
+    test_assert(!ecs_has(world, e, Tag));
     test_assert(ecs_has(world, e, Position));
-    test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
+    test_assert(!ecs_has_pair(world, e, EcsChildOf, parent));
 
     test_int(ecs_set_with(world, 0), Tag);
     test_int(ecs_set_scope(world, 0), parent);
diff --git a/test/api/src/New_w_Count.c b/test/core/src/New_w_Count.c
similarity index 96%
rename from test/api/src/New_w_Count.c
rename to test/core/src/New_w_Count.c
index 412eb13c1..3abcc9b2b 100644
--- a/test/api/src/New_w_Count.c
+++ b/test/core/src/New_w_Count.c
@@ -1,9 +1,9 @@
-#include <api.h>
+#include <core.h>
 
 void New_w_Count_empty(void) {
     ecs_world_t *world = ecs_mini();
 
-    const ecs_entity_t *ids = ecs_bulk_new(world, 0, 1000);
+    const ecs_entity_t *ids = ecs_bulk_new_w_id(world, 0, 1000);
     test_assert(ids != NULL);
 
     int i;
@@ -545,7 +545,7 @@ void New_w_Count_add_after_bulk(void) {
         test_assert(ecs_has_id(world, e, Tag));
     }
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Tag);
     test_assert(ecs_has(world, e, Tag));
 
@@ -568,7 +568,7 @@ void New_w_Count_add_after_bulk_w_component(void) {
         test_assert(ecs_has(world, e, Position));
     }
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Position);
     test_assert(ecs_has(world, e, Position));
 
@@ -581,7 +581,7 @@ void New_w_Count_add_after_bulk_w_ctor(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor
+        .ctor = flecs_default_ctor
     });
 
     const ecs_entity_t *ids = ecs_bulk_new(world, Position, 10);
@@ -595,7 +595,7 @@ void New_w_Count_add_after_bulk_w_ctor(void) {
         test_assert(ecs_has(world, e, Position));
     }
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add(world, e, Position);
     test_assert(ecs_has(world, e, Position));
@@ -606,10 +606,10 @@ void New_w_Count_add_after_bulk_w_ctor(void) {
 void New_w_Count_recycle_1_of_2(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t tag = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
 
-    /* ecs_entity_t e0 = */ ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
+    /* ecs_entity_t e0 = */ ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_delete(world, e1);
 
     const ecs_entity_t *ids = ecs_bulk_new_w_id(world, tag, 2);
@@ -624,10 +624,10 @@ void New_w_Count_recycle_1_of_2(void) {
 void New_w_Count_recycle_1_of_3(void) {
   ecs_world_t *world = ecs_init();
 
-  ecs_entity_t tag = ecs_new_id(world);
+  ecs_entity_t tag = ecs_new(world);
 
-  /* ecs_entity_t e0 = */ ecs_new_id(world);
-  ecs_entity_t e1 = ecs_new_id(world);
+  /* ecs_entity_t e0 = */ ecs_new(world);
+  ecs_entity_t e1 = ecs_new(world);
   ecs_delete(world, e1);
 
   const ecs_entity_t *ids = ecs_bulk_new_w_id(world, tag, 3);
@@ -643,10 +643,10 @@ void New_w_Count_recycle_1_of_3(void) {
 void New_w_Count_recycle_2_of_3(void) {
   ecs_world_t *world = ecs_init();
 
-  ecs_entity_t tag = ecs_new_id(world);
+  ecs_entity_t tag = ecs_new(world);
 
-  ecs_entity_t e0 = ecs_new_id(world);
-  ecs_entity_t e1 = ecs_new_id(world);
+  ecs_entity_t e0 = ecs_new(world);
+  ecs_entity_t e1 = ecs_new(world);
   ecs_delete(world, e1);
   ecs_delete(world, e0);
 
diff --git a/test/api/src/Observer.c b/test/core/src/Observer.c
similarity index 84%
rename from test/api/src/Observer.c
rename to test/core/src/Observer.c
index e3a468cbf..bc7f1a5c0 100644
--- a/test/api/src/Observer.c
+++ b/test/core/src/Observer.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static
 void Observer(ecs_iter_t *it) {
@@ -13,12 +13,12 @@ void Observer_w_value(ecs_iter_t *it) {
     test_assert(it->entities != NULL);
     test_assert(it->entities[0] != 0);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_int(p->x, 10);
     test_int(p->y, 20);
 
     if (it->field_count > 1) {
-        Velocity *v = ecs_field(it, Velocity, 2);
+        Velocity *v = ecs_field(it, Velocity, 1);
         test_int(v->x, 1);
         test_int(v->y, 2);
     }
@@ -32,7 +32,7 @@ void Observer_w_1_value(ecs_iter_t *it) {
     test_assert(it->entities != NULL);
     test_assert(it->entities[0] != 0);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_int(p->x, 10);
     test_int(p->y, 20);
 }
@@ -62,7 +62,7 @@ void Observer_w_1_filter_term(ecs_iter_t *it) {
     // test_assert(it->ptrs[0] == NULL);
     test_assert(it->ptrs[1] != NULL);
 
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Velocity *v = ecs_field(it, Velocity, 1);
     test_int(v->x, 1);
     test_int(v->y, 2);
 }
@@ -83,7 +83,7 @@ void Observer_w_2_filter_terms(ecs_iter_t *it) {
     // test_assert(it->ptrs[1] == NULL);
     test_assert(it->ptrs[2] != NULL);
 
-    Mass *m = ecs_field(it, Mass, 3);
+    Mass *m = ecs_field(it, Mass, 2);
     test_int(m[0], 100);
 }
 
@@ -102,14 +102,14 @@ void Observer_2_terms_w_on_add(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB}},
+        .query.terms = {{TagA}, {TagB}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagB);
     test_int(ctx.invoked, 0);
@@ -137,14 +137,14 @@ void Observer_2_terms_w_on_remove(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB}},
+        .query.terms = {{TagA}, {TagB}},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagA);
     test_int(ctx.invoked, 0);
@@ -175,14 +175,14 @@ void Observer_2_terms_w_on_set_value(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_id(Position)}, {ecs_id(Velocity)}},
+        .query.terms = {{ecs_id(Position)}, {ecs_id(Velocity)}},
         .events = {EcsOnSet},
         .callback = Observer_w_value,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_set(world, e, Velocity, {1, 2});
     test_int(ctx.invoked, 0);
@@ -210,14 +210,14 @@ void Observer_2_terms_w_on_remove_value(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_id(Position)}, {ecs_id(Velocity)}},
+        .query.terms = {{ecs_id(Position)}, {ecs_id(Velocity)}},
         .events = {EcsOnRemove},
         .callback = Observer_w_value,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_set(world, e, Velocity, {1, 2});
     test_int(ctx.invoked, 0);
@@ -249,14 +249,14 @@ void Observer_2_terms_w_on_add_2nd(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB}},
+        .query.terms = {{TagA}, {TagB}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagA);
     test_int(ctx.invoked, 0);
@@ -284,14 +284,14 @@ void Observer_2_terms_w_on_remove_2nd(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB}},
+        .query.terms = {{TagA}, {TagB}},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagA);
     test_int(ctx.invoked, 0);
@@ -327,14 +327,14 @@ void Observer_2_pair_terms_w_on_add(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{pair_a}, {pair_b}},
+        .query.terms = {{pair_a}, {pair_b}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, RelA, ObjA);
     test_int(ctx.invoked, 0);
@@ -367,14 +367,14 @@ void Observer_2_pair_terms_w_on_remove(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{pair_a}, {pair_b}},
+        .query.terms = {{pair_a}, {pair_b}},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, RelA, ObjA);
     test_int(ctx.invoked, 0);
@@ -407,14 +407,14 @@ void Observer_2_wildcard_pair_terms_w_on_add(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_pair(RelA, ObjA)}, {ecs_pair(RelB, EcsWildcard)}},
+        .query.terms = {{ecs_pair(RelA, ObjA)}, {ecs_pair(RelB, EcsWildcard)}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, RelA, ObjA);
     test_int(ctx.invoked, 0);
@@ -444,14 +444,14 @@ void Observer_2_wildcard_pair_terms_w_on_add_2_matching(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_pair(RelA, ObjA)}, {ecs_pair(RelB, EcsWildcard)}},
+        .query.terms = {{ecs_pair(RelA, ObjA)}, {ecs_pair(RelB, EcsWildcard)}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, RelA, ObjA);
     test_int(ctx.invoked, 0);
@@ -495,14 +495,14 @@ void Observer_2_wildcard_pair_terms_w_on_add_3_matching(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_pair(RelA, ObjA)}, {ecs_pair(RelB, EcsWildcard)}},
+        .query.terms = {{ecs_pair(RelA, ObjA)}, {ecs_pair(RelB, EcsWildcard)}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, RelA, ObjA);
     test_int(ctx.invoked, 0);
@@ -548,7 +548,6 @@ void Observer_2_wildcard_pair_terms_w_on_add_3_matching(void) {
     ecs_fini(world);
 }
 
-
 void Observer_2_wildcard_pair_terms_w_on_remove(void) {
     ecs_world_t *world = ecs_mini();
 
@@ -559,14 +558,14 @@ void Observer_2_wildcard_pair_terms_w_on_remove(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_pair(RelA, ObjA)}, {ecs_pair(RelB, EcsWildcard)}},
+        .query.terms = {{ecs_pair(RelA, ObjA)}, {ecs_pair(RelB, EcsWildcard)}},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, RelA, ObjA);
     test_int(ctx.invoked, 0);
@@ -596,14 +595,14 @@ void Observer_on_set_n_entities(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_id(Self)}},
+        .query.terms = {{ecs_id(Self)}},
         .events = {EcsOnSet},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e_1 = ecs_new_id(world);
+    ecs_entity_t e_1 = ecs_new(world);
     test_int(ctx.invoked, 0);
     ecs_set(world, e_1, Self, {e_1});
 
@@ -618,7 +617,7 @@ void Observer_on_set_n_entities(void) {
 
     ecs_os_zeromem(&ctx);
 
-    ecs_entity_t e_2 = ecs_new_id(world);
+    ecs_entity_t e_2 = ecs_new(world);
     test_int(ctx.invoked, 0);
     ecs_set(world, e_2, Self, {e_2});
 
@@ -633,7 +632,7 @@ void Observer_on_set_n_entities(void) {
 
     ecs_os_zeromem(&ctx);
 
-    ecs_entity_t e_3 = ecs_new_id(world);
+    ecs_entity_t e_3 = ecs_new(world);
     test_int(ctx.invoked, 0);
     ecs_set(world, e_3, Self, {e_3});
 
@@ -657,14 +656,14 @@ void Observer_on_set_n_entities_2_comp(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_id(Self)}, {ecs_pair(ecs_id(Self), EcsWildcard)}},
+        .query.terms = {{ecs_id(Self)}, {ecs_pair(ecs_id(Self), EcsWildcard)}},
         .events = {EcsOnSet},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e_1 = ecs_new_id(world);
+    ecs_entity_t e_1 = ecs_new(world);
     ecs_set(world, e_1, Self, {e_1});
     test_int(ctx.invoked, 0);
     ecs_set_pair(world, e_1, Self, Obj, {e_1});
@@ -681,7 +680,7 @@ void Observer_on_set_n_entities_2_comp(void) {
 
     ecs_os_zeromem(&ctx);
 
-    ecs_entity_t e_2 = ecs_new_id(world);
+    ecs_entity_t e_2 = ecs_new(world);
     ecs_set(world, e_2, Self, {e_2});
     test_int(ctx.invoked, 0);
     ecs_set_pair(world, e_2, Self, Obj, {e_2});
@@ -708,14 +707,14 @@ void Observer_wildcard_pair_w_pred_component(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_pair(ecs_id(Position), EcsWildcard)}},
+        .query.terms = {{ecs_pair(ecs_id(Position), EcsWildcard)}},
         .events = {EcsOnSet},
         .callback = Observer_w_value,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.invoked, 0);
 
     ecs_set_pair(world, e, Position, ObjA, {10, 20});
@@ -763,17 +762,17 @@ void Observer_wildcard_pair_w_obj_component(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ ecs_pair(EcsWildcard, ecs_id(Position)) }},
+        .query.terms = {{ ecs_pair(EcsWildcard, ecs_id(Position)) }},
         .events = {EcsOnSet},
         .callback = Observer_w_value,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.invoked, 0);
 
-    ecs_set_pair_object(world, e, RelA, Position, {10, 20});
+    ecs_set_pair_second(world, e, RelA, Position, {10, 20});
 
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
@@ -795,7 +794,7 @@ void Observer_wildcard_pair_w_obj_component(void) {
 
     ecs_os_zeromem(&ctx);
 
-    ecs_set_pair_object(world, e, RelB, Position, {10, 20});
+    ecs_set_pair_second(world, e, RelB, Position, {10, 20});
 
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
@@ -817,14 +816,14 @@ void Observer_2_terms_1_not_w_on_add(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB, .oper = EcsNot}},
+        .query.terms = {{TagA}, {TagB, .oper = EcsNot}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagB);
     test_int(ctx.invoked, 0);
@@ -859,14 +858,14 @@ void Observer_2_terms_1_not_w_on_remove(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB, .oper = EcsNot}},
+        .query.terms = {{TagA}, {TagB, .oper = EcsNot}},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagB);
     test_int(ctx.invoked, 0);
@@ -906,14 +905,14 @@ void Observer_2_terms_w_on_set(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_id(Position)}, {TagB}},
+        .query.terms = {{ecs_id(Position)}, {TagB}},
         .events = {EcsOnSet},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagB);
     test_int(ctx.invoked, 0);
@@ -944,14 +943,14 @@ void Observer_2_terms_w_un_set(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ecs_id(Position)}, {TagB}},
+        .query.terms = {{ecs_id(Position)}, {TagB}},
         .events = {EcsUnSet},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagB);
     test_int(ctx.invoked, 0);
@@ -986,14 +985,14 @@ void Observer_3_terms_2_or_on_add(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB, .oper = EcsOr}, {TagC }},
+        .query.terms = {{TagA}, {TagB, .oper = EcsOr}, {TagC }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagA);
     test_int(ctx.invoked, 0);
@@ -1036,14 +1035,14 @@ void Observer_3_terms_2_or_on_remove(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB, .oper = EcsOr}, {TagC }},
+        .query.terms = {{TagA}, {TagB, .oper = EcsOr}, {TagC }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagA);
     test_int(ctx.invoked, 0);
@@ -1072,18 +1071,18 @@ void Observer_2_terms_w_from_entity_on_add(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
     
-    ecs_entity_t x = ecs_new_id(world);
+    ecs_entity_t x = ecs_new(world);
     
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB, .src.id = x}},
+        .query.terms = {{TagA}, {TagB, .src.id = x}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagA);
     test_int(ctx.invoked, 0);
@@ -1111,14 +1110,14 @@ void Observer_2_terms_on_remove_on_clear(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB}},
+        .query.terms = {{TagA}, {TagB}},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagA);
     test_int(ctx.invoked, 0);
@@ -1140,14 +1139,14 @@ void Observer_2_terms_on_remove_on_delete(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{TagA}, {TagB}},
+        .query.terms = {{TagA}, {TagB}},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagA);
     test_int(ctx.invoked, 0);
@@ -1167,12 +1166,12 @@ void Observer_add_after_delete_observer(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t observer = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{.id = ecs_id(Position) }},
+        .query.terms = {{.id = ecs_id(Position) }},
         .events = {EcsOnAdd},
         .callback = Dummy
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(ecs_has(world, e1, Position));
     test_int(dummy_called, 1);
@@ -1182,7 +1181,7 @@ void Observer_add_after_delete_observer(void) {
     ecs_delete(world, observer);
     test_int(dummy_called, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     test_assert(e2 != 0);
     test_assert(ecs_has(world, e2, Position));
     test_int(dummy_called, 0);
@@ -1196,12 +1195,12 @@ void Observer_remove_after_delete_observer(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t observer = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{.id = ecs_id(Position) }},
+        .query.terms = {{.id = ecs_id(Position) }},
         .events = {EcsOnRemove},
         .callback = Dummy
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(ecs_has(world, e1, Position));
     test_int(dummy_called, 0);
@@ -1214,7 +1213,7 @@ void Observer_remove_after_delete_observer(void) {
     ecs_delete(world, observer);
     test_int(dummy_called, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     test_assert(e2 != 0);
     test_assert(ecs_has(world, e2, Position));
     test_int(dummy_called, 0);
@@ -1259,7 +1258,7 @@ void Observer_delete_observer_w_ctx(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms =  {{ Tag }},
+        .query.terms =  {{ Tag }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx_value,
@@ -1286,7 +1285,7 @@ void Observer_update_ctx(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t system = ecs_observer(world, {
-        .filter.terms = {{.id = Tag}},
+        .query.terms = {{.id = Tag}},
         .callback = Dummy,
         .events = {EcsOnAdd},
         .ctx = &ctx_value,
@@ -1344,14 +1343,14 @@ void Observer_filter_w_strings(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{.first.name = "TagA"}, {.first.name = "TagB"}},
+        .query.terms = {{.first.name = "TagA"}, {.first.name = "TagB"}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, TagB);
     test_int(ctx.invoked, 0);
@@ -1384,14 +1383,14 @@ void Observer_iter_type_set(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ Tag }},
+        .query.terms = {{ Tag }},
         .events = {EcsOnAdd},
         .callback = TypeObserver,
         .ctx = &ctx
     });
     test_assert(t != 0);
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     test_assert(trigger_table != NULL);
     test_assert(trigger_table != NULL);
@@ -1404,7 +1403,7 @@ void Observer_iter_type_set(void) {
 
 void ObserverReadonly(ecs_iter_t *it) {
     probe_system_w_ctx(it, it->ctx);
-    test_bool(ecs_field_is_readonly(it, 1), true);
+    test_bool(ecs_field_is_readonly(it, 0), true);
 }
 
 void Observer_readonly_term(void) {
@@ -1414,13 +1413,13 @@ void Observer_readonly_term(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA, .inout = EcsIn }},
+        .query.terms = {{ TagA, .inout = EcsIn }},
         .events = {EcsOnAdd},
         .callback = ObserverReadonly,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     ecs_add(world, e, TagA);
 
@@ -1447,20 +1446,20 @@ void Observer_trigger_on_prefab(void) {
     Probe ctx_2 = {0};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }},
+        .query.terms = {{ TagA }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx_1
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }, { EcsPrefab, .oper = EcsOptional}},
+        .query.terms = {{ TagA }, { EcsPrefab, .oper = EcsOptional}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx_2
     });
 
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
     test_int(ctx_1.invoked, 1);
     test_int(ctx_2.invoked, 1);
     ecs_os_zeromem(&ctx_1);
@@ -1493,20 +1492,20 @@ void Observer_trigger_on_disabled(void) {
     Probe ctx_2 = {0};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }},
+        .query.terms = {{ TagA }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx_1
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }, { EcsDisabled, .oper = EcsOptional}},
+        .query.terms = {{ TagA }, { EcsDisabled, .oper = EcsOptional}},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx_2
     });
 
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
     test_int(ctx_1.invoked, 1);
     test_int(ctx_2.invoked, 1);
     ecs_os_zeromem(&ctx_1);
@@ -1552,7 +1551,7 @@ void Observer_unset_1_of_1(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -1595,7 +1594,7 @@ void Observer_unset_1_of_2(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -1645,7 +1644,7 @@ void Observer_unset_1_of_3(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -1703,13 +1702,13 @@ void Observer_unset_on_delete_1(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);    
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_delete(world, e);
@@ -1738,15 +1737,15 @@ void Observer_unset_on_delete_2(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);    
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     ecs_add(world, e1, Velocity);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     ecs_add(world, e2, Velocity);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     ecs_add(world, e3, Velocity);
     test_int(ctx.invoked, 0);
 
@@ -1779,17 +1778,17 @@ void Observer_unset_on_delete_3(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);    
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     ecs_add(world, e1, Velocity);
     ecs_add(world, e1, Mass);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     ecs_add(world, e2, Velocity);
     ecs_add(world, e2, Mass);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     ecs_add(world, e3, Velocity);
     ecs_add(world, e3, Mass);
     test_int(ctx.invoked, 0);
@@ -1824,16 +1823,16 @@ void Observer_unset_on_fini_1(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);    
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_new(world, Velocity);
+    ecs_new_w(world, Velocity);
     test_int(ctx.invoked, 0);
 
     ecs_fini(world);
@@ -1861,22 +1860,22 @@ void Observer_unset_on_fini_2(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);    
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     ecs_add(world, e1, Velocity);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     ecs_add(world, e2, Velocity);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     ecs_add(world, e3, Velocity);
     test_int(ctx.invoked, 0);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_new(world, Velocity);
+    ecs_new_w(world, Velocity);
     test_int(ctx.invoked, 0);    
 
     ecs_fini(world);
@@ -1907,28 +1906,28 @@ void Observer_unset_on_fini_3(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);    
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     ecs_add(world, e1, Velocity);
     ecs_add(world, e1, Mass);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     ecs_add(world, e2, Velocity);
     ecs_add(world, e2, Mass);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     ecs_add(world, e3, Velocity);
     ecs_add(world, e3, Mass);
     test_int(ctx.invoked, 0);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_new(world, Velocity);
+    ecs_new_w(world, Velocity);
     test_int(ctx.invoked, 0); 
 
-    ecs_new(world, Mass);
+    ecs_new_w(world, Mass);
     test_int(ctx.invoked, 0);        
 
     ecs_fini(world);
@@ -1964,7 +1963,7 @@ void Observer_overlapping_unset_systems(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);  
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
     test_int(ctx.invoked, 0);
 
@@ -1996,7 +1995,7 @@ void UnSet_TestComp(ecs_iter_t *it) {
 
     test_int(it->count, 1);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_assert(p != NULL);
     test_int(p->x, 10);
     test_int(p->y, 20);
@@ -2024,7 +2023,7 @@ void Observer_unset_move_to_nonempty_table(void) {
     ecs_set(world, e, Velocity, {20, 10});
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Velocity);
+    ecs_entity_t e2 = ecs_new_w(world, Velocity);
     ecs_set(world, e2, Velocity, {30, 40});
     test_int(ctx.invoked, 0);
 
@@ -2057,10 +2056,10 @@ void UnSet_WriteComp(ecs_iter_t *it) {
 
     test_int(it->count, 1);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_assert(p != NULL);
 
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     test_int(p->x, 10);
     test_int(p->y, 20);
@@ -2080,7 +2079,7 @@ void Observer_write_in_unset(void) {
 
     ECS_OBSERVER(world, UnSet_WriteComp, EcsUnSet, Position, Velocity);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_set(world, e, Velocity, {1, 2});
 
     Probe ctx = { 0 };
@@ -2119,14 +2118,14 @@ void Observer_filter_term(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ .id = ecs_id(Position), .inout = EcsInOutNone }},
+        .query.terms = {{ .id = ecs_id(Position), .inout = EcsInOutNone }},
         .events = {EcsOnSet},
         .callback = Observer_w_filter_term,
         .ctx = &ctx
     });
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(e1 != 0);
 
     test_int(ctx.invoked, 1);
@@ -2151,7 +2150,7 @@ void Observer_2_terms_1_filter(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position), .inout = EcsInOutNone },
             { .id = ecs_id(Velocity) }
         },
@@ -2161,7 +2160,7 @@ void Observer_2_terms_1_filter(void) {
     });
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_set(world, 0, Velocity, {1, 2});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Velocity, {1, 2}));
     test_assert(e1 != 0);
     test_int(ctx.invoked, 0);
 
@@ -2191,7 +2190,7 @@ void Observer_3_terms_2_filter(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position), .inout = EcsInOutNone },
             { .id = ecs_id(Velocity), .inout = EcsInOutNone },
             { .id = ecs_id(Mass) }
@@ -2202,7 +2201,7 @@ void Observer_3_terms_2_filter(void) {
     });
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_set(world, 0, Velocity, {1, 2});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Velocity, {1, 2}));
     test_assert(e1 != 0);
     test_int(ctx.invoked, 0);
 
@@ -2234,15 +2233,15 @@ void Observer_and_from(void) {
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {
-            { ECS_AND | Type}
+        .query.terms = {
+            { Type, .oper = EcsAndFrom }
         },
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.invoked, 0);
 
     ecs_add(world, e, TagA);
@@ -2269,7 +2268,7 @@ void Observer_or_from(void) {
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {
+        .query.terms = {
             { Type, .oper = EcsOrFrom }
         },
         .events = {EcsOnAdd},
@@ -2277,7 +2276,7 @@ void Observer_or_from(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.invoked, 0);
 
     ecs_add(world, e, TagA);
@@ -2295,6 +2294,120 @@ void Observer_or_from(void) {
     ecs_fini(world);
 }
 
+void Observer_and_from_empty(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t Type = ecs_new(world);
+
+    Probe ctx = {0};
+    ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
+        .query.terms = {
+            { Type, .oper = EcsAndFrom }
+        },
+        .events = {EcsOnAdd, EcsOnRemove, EcsOnSet},
+        .callback = Observer,
+        .ctx = &ctx
+    });
+
+    test_assert(o != 0);
+
+    ecs_fini(world);
+
+    test_int(ctx.invoked, 0);
+}
+
+void Observer_or_from_empty(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t Type = ecs_new(world);
+
+    Probe ctx = {0};
+    ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
+        .query.terms = {
+            { Type, .oper = EcsOrFrom }
+        },
+        .events = {EcsOnAdd, EcsOnRemove, EcsOnSet},
+        .callback = Observer,
+        .ctx = &ctx
+    });
+
+    test_assert(o != 0);
+
+    ecs_fini(world);
+
+    test_int(ctx.invoked, 0);
+}
+
+void Observer_and_from_empty_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ecs_entity_t Type = ecs_new(world);
+
+    Probe ctx = {0};
+    ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
+        .query.terms = {
+            { Type, .oper = EcsAndFrom },
+            { TagA }
+        },
+        .events = {EcsOnAdd, EcsOnRemove, EcsOnSet},
+        .callback = Observer,
+        .ctx = &ctx
+    });
+
+    test_assert(o != 0);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    test_int(ctx.invoked, 1);
+    test_int(ctx.count, 1);
+    test_int(ctx.system, o);
+    test_int(ctx.event, EcsOnAdd);
+    test_int(ctx.event_id, TagA);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e);
+    test_int(ctx.c[0][1], TagA);
+
+    ecs_fini(world);
+}
+
+void Observer_or_from_empty_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ecs_entity_t Type = ecs_new(world);
+
+    Probe ctx = {0};
+    ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
+        .query.terms = {
+            { Type, .oper = EcsOrFrom },
+            { TagA }
+        },
+        .events = {EcsOnAdd, EcsOnRemove, EcsOnSet},
+        .callback = Observer,
+        .ctx = &ctx
+    });
+
+    test_assert(o != 0);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    test_int(ctx.invoked, 1);
+    test_int(ctx.count, 1);
+    test_int(ctx.system, o);
+    test_int(ctx.event, EcsOnAdd);
+    test_int(ctx.event_id, TagA);
+    test_int(ctx.term_count, 2);
+    test_null(ctx.param);
+
+    test_int(ctx.e[0], e);
+    test_int(ctx.c[0][1], TagA);
+
+    ecs_fini(world);
+}
+
 static int invoke_count = 0;
 static ecs_entity_t base_ent = 0;
 static ecs_entity_t inst_ent_a = 0;
@@ -2329,14 +2442,14 @@ void Observer_notify_propagated_twice(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }},
+        .query.terms = {{ TagA }},
         .events = {EcsOnAdd},
         .callback = TriggerTwice,
         .ctx = &ctx
     });
     test_assert(t1 != 0);
 
-    base_ent = ecs_new_id(world);
+    base_ent = ecs_new(world);
     inst_ent_a = ecs_new_w_pair(world, EcsIsA, base_ent);
     ecs_add(world, inst_ent_a, TagB);
     inst_ent_b = ecs_new_w_pair(world, EcsIsA, base_ent);
@@ -2357,9 +2470,9 @@ void Observer_on_add_yield_existing(void) {
     ECS_TAG(world, Tag);
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
 
     test_assert(e1 != 0);
     test_assert(e2 != 0);
@@ -2367,7 +2480,7 @@ void Observer_on_add_yield_existing(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ Tag }},
+        .query.terms = {{ Tag }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx,
@@ -2389,7 +2502,7 @@ void Observer_on_add_yield_existing(void) {
 
     // Ensure normal triggering also still works
     ecs_os_zeromem(&ctx);
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
     test_int(ctx.invoked, 1);
 
     ecs_fini(world);
@@ -2402,9 +2515,9 @@ void Observer_on_add_yield_existing_2_tables(void) {
     ECS_TAG(world, TagB);
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
 
     test_assert(e1 != 0);
     test_assert(e2 != 0);
@@ -2414,7 +2527,7 @@ void Observer_on_add_yield_existing_2_tables(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }},
+        .query.terms = {{ TagA }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx,
@@ -2436,7 +2549,7 @@ void Observer_on_add_yield_existing_2_tables(void) {
 
     // Ensure normal triggering also still works
     ecs_os_zeromem(&ctx);
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
     test_int(ctx.invoked, 1);
 
     ecs_fini(world);
@@ -2450,11 +2563,11 @@ void Observer_on_add_yield_existing_2_terms(void) {
     ECS_TAG(world, TagC);
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_entity_t e4 = ecs_new(world, TagA); /* no match */
-    ecs_entity_t e5 = ecs_new(world, TagB); /* no match */
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_entity_t e4 = ecs_new_w(world, TagA); /* no match */
+    ecs_entity_t e5 = ecs_new_w(world, TagB); /* no match */
 
     test_assert(e1 != 0);
     test_assert(e2 != 0);
@@ -2470,7 +2583,7 @@ void Observer_on_add_yield_existing_2_terms(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }, { TagB }},
+        .query.terms = {{ TagA }, { TagB }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx,
@@ -2494,7 +2607,7 @@ void Observer_on_add_yield_existing_2_terms(void) {
 
     // Ensure normal triggering also still works
     ecs_os_zeromem(&ctx);
-    ecs_entity_t e6 = ecs_new(world, TagA);
+    ecs_entity_t e6 = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
     ecs_add(world, e6, TagB);
     test_int(ctx.invoked, 1);
@@ -2514,7 +2627,7 @@ void Observer_on_add_yield_existing_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ ecs_pair(Rel, EcsWildcard ) }},
+        .query.terms = {{ ecs_pair(Rel, EcsWildcard ) }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx,
@@ -2553,7 +2666,7 @@ void Observer_on_add_yield_existing_wildcard_multi(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ ecs_pair(Rel, EcsWildcard ) }, { Tag }},
+        .query.terms = {{ ecs_pair(Rel, EcsWildcard ) }, { Tag }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx,
@@ -2589,11 +2702,11 @@ void Observer_on_add_yield_existing_wildcard_multi_w_wildcard_pivot(void) {
     ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtB);
     ecs_add(world, e1, Tag);
     ecs_add(world, e2, Tag);
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ ecs_pair(Rel, EcsWildcard ) }, { Tag }},
+        .query.terms = {{ ecs_pair(Rel, EcsWildcard ) }, { Tag }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx,
@@ -2624,13 +2737,17 @@ void Observer_observer_superset_wildcard(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t base = ecs_new_id(world);
-    ecs_entity_t inst = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
+    ecs_entity_t inst = ecs_new(world);
     ecs_add_pair(world, inst, EcsIsA, base);
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ .id = ecs_pair(Rel, EcsWildcard), .src.flags = EcsUp }},
+        .query.terms = {{ 
+            .id = ecs_pair(Rel, EcsWildcard), 
+            .src.id = EcsUp, 
+            .trav = EcsIsA
+        }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
@@ -2673,15 +2790,19 @@ void Observer_observer_superset_wildcard_add_isa(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add_pair(world, base, Rel, ObjA);
     ecs_add_pair(world, base, Rel, ObjB);
 
-    ecs_entity_t inst = ecs_new_id(world);
+    ecs_entity_t inst = ecs_new(world);
     
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ .id = ecs_pair(Rel, EcsWildcard), .src.flags = EcsUp }},
+        .query.terms = {{ 
+            .id = ecs_pair(Rel, EcsWildcard), 
+            .src.id = EcsUp,
+            .trav = EcsIsA
+        }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
@@ -2713,16 +2834,20 @@ void Observer_observer_superset_wildcard_add_isa_at_offset(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add(world, base, Tag);
     ecs_add_pair(world, base, Rel, ObjA);
     ecs_add_pair(world, base, Rel, ObjB);
 
-    ecs_entity_t inst = ecs_new_id(world);
+    ecs_entity_t inst = ecs_new(world);
     
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ .id = ecs_pair(Rel, EcsWildcard), .src.flags = EcsUp }},
+        .query.terms = {{ 
+            .id = ecs_pair(Rel, EcsWildcard), 
+            .src.id = EcsUp,
+            .trav = EcsIsA 
+        }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
@@ -2752,14 +2877,14 @@ void Observer_on_set_w_tag(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }},
+        .query.terms = {{ TagA }},
         .events = {EcsOnSet},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(t1 != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, TagA);
@@ -2780,14 +2905,14 @@ void Observer_mixed_on_set_w_tag(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }, { ecs_id(Position) }},
+        .query.terms = {{ TagA }, { ecs_id(Position) }},
         .events = {EcsOnSet},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(t1 != 0);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
     ecs_add(world, e1, TagA);
@@ -2805,7 +2930,7 @@ void Observer_mixed_on_set_w_tag(void) {
 
     ctx = (Probe){0};
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     test_assert(e2 != 0);
 
     ecs_set(world, e2, Position, {10, 20});
@@ -2829,14 +2954,14 @@ void Observer_mixed_un_set_w_tag(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }, { ecs_id(Position) }},
+        .query.terms = {{ TagA }, { ecs_id(Position) }},
         .events = {EcsUnSet},
         .callback = Observer,
         .ctx = &ctx
     });
     test_assert(t1 != 0);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add(world, e1, TagA);
     ecs_set(world, e1, Position, {10, 20});
     test_int(ctx.invoked, 0);
@@ -2851,7 +2976,7 @@ void Observer_mixed_un_set_w_tag(void) {
 
     ctx = (Probe){0};
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {10, 20});
     ecs_add(world, e2, TagA);
     test_int(ctx.invoked, 0);
@@ -2875,7 +3000,7 @@ void Observer_match_base_w_id_at_offset(void) {
 
     Probe ctx_1 = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ ecs_id(Position) }},
+        .query.terms = {{ ecs_id(Position) }},
         .events = {EcsOnSet},
         .callback = Observer,
         .ctx = &ctx_1
@@ -2884,7 +3009,7 @@ void Observer_match_base_w_id_at_offset(void) {
 
     Probe ctx_2 = {0};
     ecs_entity_t t2 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ ecs_id(Velocity) }},
+        .query.terms = {{ ecs_id(Velocity) }},
         .events = {EcsOnSet},
         .callback = Observer,
         .ctx = &ctx_2
@@ -2942,7 +3067,7 @@ void Observer_custom_run_action(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }},
+        .query.terms = {{ TagA }},
         .events = {EcsOnAdd},
         .run = Run,
         .callback = Observer,
@@ -2950,7 +3075,7 @@ void Observer_custom_run_action(void) {
     });
     test_assert(t1 != 0);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
 
     test_int(run_invoked, 1);
     test_int(run_invoked_matched, 1);
@@ -2969,7 +3094,7 @@ void Observer_custom_run_action_w_iter_next(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }},
+        .query.terms = {{ TagA }},
         .events = {EcsOnAdd},
         .run = Run_w_iter_next,
         .callback = Observer,
@@ -2977,7 +3102,7 @@ void Observer_custom_run_action_w_iter_next(void) {
     });
     test_assert(t1 != 0);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
 
     test_int(run_invoked, 1);
     test_int(ctx.invoked, 1);
@@ -2996,7 +3121,7 @@ void Observer_custom_run_action_2_terms(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }, { TagB }},
+        .query.terms = {{ TagA }, { TagB }},
         .events = {EcsOnAdd},
         .run = Run,
         .callback = Observer,
@@ -3004,7 +3129,7 @@ void Observer_custom_run_action_2_terms(void) {
     });
     test_assert(t1 != 0);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_int(run_invoked, 1);
     run_invoked = 0;
 
@@ -3027,7 +3152,7 @@ void Observer_custom_run_action_w_iter_next_2_terms(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }, { TagB }},
+        .query.terms = {{ TagA }, { TagB }},
         .events = {EcsOnAdd},
         .run = Run_w_iter_next,
         .callback = Observer,
@@ -3035,7 +3160,7 @@ void Observer_custom_run_action_w_iter_next_2_terms(void) {
     });
     test_assert(t1 != 0);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_int(run_invoked, 1);
     run_invoked = 0;
 
@@ -3054,12 +3179,12 @@ void Observer_read_in_on_remove_after_add_other_w_not(void) {
 
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
-    ECS_TAG(world, O);
+    ECS_TAG(world, Tgt);
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {
-            { .id = ecs_pair(ecs_id(Position), O)},
+        .query.terms = {
+            { .id = ecs_pair_t(Position, Tgt)},
             { .id = Tag, .oper = EcsNot }
         },
         .events = {EcsOnRemove},
@@ -3067,7 +3192,7 @@ void Observer_read_in_on_remove_after_add_other_w_not(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_set_pair(world, 0, Position, O, { 10, 20 });
+    ecs_entity_t e = ecs_insert(world, ecs_value_pair(Position, Tgt, { 10, 20 }));
     test_int(ctx.invoked, 0);
 
     ecs_add(world, e, Tag);
@@ -3086,7 +3211,7 @@ void Observer_observer_w_short_notation(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {{
+        .query.terms = {{
             .id = Foo
         }},
         .events = { EcsOnAdd },
@@ -3096,7 +3221,7 @@ void Observer_observer_w_short_notation(void) {
 
     test_assert(o != 0);
 
-    ecs_entity_t e = ecs_new(world, Foo);
+    ecs_entity_t e = ecs_new_w(world, Foo);
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
     test_int(ctx.e[0], e);
@@ -3113,13 +3238,13 @@ void Observer_observer_w_filter_term(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ .id = TagA }, { .id = TagB, .src.flags = EcsFilter }},
+        .query.terms = {{ .id = TagA }, { .id = TagB, .inout = EcsInOutFilter }},
         .events = { EcsOnAdd },
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.invoked, 0);
 
     ecs_add(world, e, TagB);
@@ -3167,7 +3292,7 @@ void Observer_multi_observer_w_ctx_free(void) {
     *ctx = 10;
 
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {{ .id = TagA }, { .id = TagB }},
+        .query.terms = {{ .id = TagA }, { .id = TagB }},
         .events = { EcsOnAdd },
         .callback = Observer_w_ctx,
         .ctx = ctx,
@@ -3177,7 +3302,7 @@ void Observer_multi_observer_w_ctx_free(void) {
     test_int(observer_w_ctx_invoked, 0);
     test_int(free_ctx_invoked, 0);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_int(observer_w_ctx_invoked, 0);
     test_int(free_ctx_invoked, 0);
     ecs_add(world, e, TagB);
@@ -3198,17 +3323,17 @@ void Observer_propagate_after_on_delete_clear_action(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t tgt = ecs_new(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add_pair(world, parent, Rel, tgt);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ 
+        .query.terms = {{ 
             .id = ecs_pair(Rel, EcsWildcard), 
-            .src.flags = EcsUp, 
-            .src.trav = EcsChildOf 
+            .src.id = EcsUp, 
+            .trav = EcsChildOf 
         }},
         .events = { EcsOnRemove },
         .callback = Observer,
@@ -3238,9 +3363,9 @@ void Observer_on_add_after_batch_w_exclusive_adds(void) {
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ 
+        .query.terms = {{ 
             ecs_pair(Rel, EcsWildcard), 
-            .src.flags = EcsSelf
+            .src.id = EcsSelf
         }},
         .events = {EcsOnAdd},
         .callback = Observer,
@@ -3248,7 +3373,7 @@ void Observer_on_add_after_batch_w_exclusive_adds(void) {
     });
      
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_add_pair(world, e, Rel, TgtA);
@@ -3276,13 +3401,13 @@ void Observer_propagate_match_relationship_w_self_up(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagB, .src.flags = EcsSelf|EcsUp }},
+        .query.terms = {{ TagB, .src.id = EcsSelf|EcsUp, .trav = EcsIsA }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add(world, parent, TagA);
     ecs_new_w_pair(world, EcsChildOf, parent);
     test_int(ctx.invoked, 0);
@@ -3306,13 +3431,13 @@ void Observer_propagate_match_relationship_w_up(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagB, .src.flags = EcsUp }},
+        .query.terms = {{ TagB, .src.id = EcsUp, .trav = EcsIsA }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add(world, parent, TagA);
     ecs_new_w_pair(world, EcsChildOf, parent);
     test_int(ctx.invoked, 0);
@@ -3330,13 +3455,13 @@ void Observer_propagate_isa_of_parent_add(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
 
@@ -3361,13 +3486,13 @@ void Observer_propagate_isa_of_parent_remove(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add(world, base, TagA);
     ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -3393,13 +3518,13 @@ void Observer_propagate_isa_of_parent_set(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ ecs_id(Position), .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ ecs_id(Position), .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnSet},
         .callback = Observer_w_1_value,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {0, 0});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {0, 0}));
     ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
 
@@ -3424,15 +3549,15 @@ void Observer_propagate_add_childof_of_parent(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t grandparent = ecs_new_id(world);
+    ecs_entity_t grandparent = ecs_new(world);
     ecs_add(world, grandparent, TagA);
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_new_w_pair(world, EcsChildOf, parent);
 
     test_int(ctx.invoked, 0);
@@ -3455,13 +3580,13 @@ void Observer_propagate_add_childof_of_parent_w_siblings(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t grandparent = ecs_new_id(world);
+    ecs_entity_t grandparent = ecs_new(world);
     ecs_add(world, grandparent, TagA);
 
     {
@@ -3514,13 +3639,13 @@ void Observer_propagate_add_childof_w_parent_w_base(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new(world, TagA);
+    ecs_entity_t base = ecs_new_w(world, TagA);
     ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
     
     test_int(ctx.invoked, 0);
@@ -3544,13 +3669,13 @@ void Observer_propagate_remove_childof_w_parent_w_base(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new(world, TagA);
+    ecs_entity_t base = ecs_new_w(world, TagA);
     ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
 
@@ -3575,13 +3700,13 @@ void Observer_propagate_remove_childof_of_parent(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t grandparent = ecs_new_id(world);
+    ecs_entity_t grandparent = ecs_new(world);
     ecs_add(world, grandparent, TagA);
     ecs_entity_t parent = ecs_new_w_pair(world, EcsChildOf, grandparent);
     ecs_new_w_pair(world, EcsChildOf, parent);
@@ -3606,15 +3731,15 @@ void Observer_propagate_add_isa_of_parent(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add(world, base, TagA);
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
 
     test_int(ctx.invoked, 0);
@@ -3638,13 +3763,13 @@ void Observer_propagate_remove_isa_of_parent(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add(world, base, TagA);
     ecs_entity_t parent = ecs_new_w_pair(world, EcsIsA, base);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
@@ -3670,15 +3795,15 @@ void Observer_propagate_add_childof_of_base(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add(world, base, TagA);
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_new_w_pair(world, EcsIsA, parent);
 
     test_int(ctx.invoked, 0);
@@ -3702,13 +3827,13 @@ void Observer_propagate_remove_childof_of_base(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagA, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ TagA, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add(world, base, TagA);
     ecs_entity_t parent = ecs_new_w_pair(world, EcsChildOf, base);
     ecs_new_w_pair(world, EcsIsA, parent);
@@ -3734,7 +3859,7 @@ void Observer_emit_for_parent_w_prefab_child_and_instance(void) {
 
     Probe ctx = {0};
     ecs_observer(ecs, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) }
         },
         .events = { EcsOnSet },
@@ -3742,7 +3867,7 @@ void Observer_emit_for_parent_w_prefab_child_and_instance(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new_id(ecs);
+    ecs_entity_t e = ecs_new(ecs);
     ecs_entity_t p = ecs_new_w_pair(ecs, EcsChildOf, e);
     ecs_entity_t child_1 = ecs_new_w_pair(ecs, EcsChildOf, e);
     ecs_add_pair(ecs, child_1, EcsIsA, p);
@@ -3763,17 +3888,16 @@ void Observer_emit_for_parent_w_prefab_child_and_instance(void) {
 void Observer_observer_w_2_fixed_src(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t Foo  = ecs_new_id(world);
-    ecs_entity_t Bar = ecs_new_id(world);
+    ecs_entity_t Foo  = ecs_new(world);
+    ecs_entity_t Bar = ecs_new(world);
 
-    ecs_entity_t e1  = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1  = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {
-            // Comment out either of these and the callback succeeds.
-            { Foo , .src.id = e1 },
+        .query.terms = {
+            { Foo, .src.id = e1 },
             { Bar, .src.id = e2 },
         },
         .events = { EcsOnAdd },
@@ -3797,12 +3921,12 @@ void Observer_emit_for_recreated_id_after_remove_all(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e1, Rel, Tgt);
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA },
             { ecs_pair(Rel, Tgt) }
         },
@@ -3817,7 +3941,7 @@ void Observer_emit_for_recreated_id_after_remove_all(void) {
 
     test_int(0, ctx.invoked);
 
-    ecs_entity_t e2 = ecs_new(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e2, Rel, Tgt);
 
     test_int(ctx.invoked, 1);
@@ -3838,12 +3962,12 @@ void Observer_emit_for_recreated_id_after_remove_all_wildcard(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e1, Rel, Tgt);
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA },
             { ecs_pair(Rel, Tgt) }
         },
@@ -3858,7 +3982,7 @@ void Observer_emit_for_recreated_id_after_remove_all_wildcard(void) {
 
     test_int(0, ctx.invoked);
 
-    ecs_entity_t e2 = ecs_new(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e2, Rel, Tgt);
 
     test_int(ctx.invoked, 1);
@@ -3879,12 +4003,12 @@ void Observer_emit_for_recreated_id_after_delete_with(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e1, Rel, Tgt);
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA },
             { ecs_pair(Rel, Tgt) }
         },
@@ -3899,7 +4023,7 @@ void Observer_emit_for_recreated_id_after_delete_with(void) {
 
     test_int(0, ctx.invoked);
 
-    ecs_entity_t e2 = ecs_new(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e2, Rel, Tgt);
 
     test_int(ctx.invoked, 1);
@@ -3920,12 +4044,12 @@ void Observer_emit_for_recreated_id_after_delete_with_wildcard(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e1, Rel, Tgt);
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA },
             { ecs_pair(Rel, Tgt) }
         },
@@ -3940,7 +4064,7 @@ void Observer_emit_for_recreated_id_after_delete_with_wildcard(void) {
 
     test_int(0, ctx.invoked);
 
-    ecs_entity_t e2 = ecs_new(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e2, Rel, Tgt);
 
     test_int(ctx.invoked, 1);
@@ -3963,12 +4087,12 @@ void Observer_delete_observed_id(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e1, Rel, Tgt);
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA },
             { ecs_pair(Rel, Tgt) }
         },
@@ -3990,12 +4114,12 @@ void Observer_delete_observed_rel(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e1, Rel, Tgt);
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA },
             { ecs_pair(Rel, Tgt) }
         },
@@ -4017,12 +4141,12 @@ void Observer_delete_observed_tgt(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
     ecs_add_pair(world, e1, Rel, Tgt);
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA },
             { ecs_pair(Rel, Tgt) }
         },
@@ -4048,7 +4172,7 @@ void OnTagPair(ecs_iter_t *it) {
 static
 void OnPair(ecs_iter_t *it) {
     test_int(it->count, 1);
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     pair_x = p->x;
     pair_column = it->columns[0];
     probe_iter(it);
@@ -4067,7 +4191,7 @@ void Observer_on_add_2_pairs_w_uni_observer(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Tag);
     ecs_add_pair(world, e, Rel, TgtA);
     test_int(ctx.invoked, 1);
@@ -4111,7 +4235,7 @@ void Observer_on_add_2_pairs_w_multi_observer(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Tag);
     ecs_add_pair(world, e, Rel, TgtA);
     test_int(ctx.invoked, 1);
@@ -4155,7 +4279,7 @@ void Observer_on_set_2_pairs_w_uni_observer(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Tag);
     ecs_set_pair(world, e, Position, TgtA, {1});
     test_int(ctx.invoked, 1);
@@ -4202,7 +4326,7 @@ void Observer_on_set_2_pairs_w_multi_observer(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Tag);
     ecs_set_pair(world, e, Position, TgtA, {1});
     test_int(ctx.invoked, 1);
@@ -4239,15 +4363,15 @@ void Observer_on_set_2_pairs_w_multi_observer(void) {
 void Observer_on_remove_target_from_base_at_offset(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t R = ecs_new_id(world);
-    ecs_entity_t T1 = ecs_new_id(world);
-    ecs_entity_t T2 = ecs_new_id(world);
-    ecs_entity_t C = ecs_new_id(world);
+    ecs_entity_t R = ecs_new(world);
+    ecs_entity_t T1 = ecs_new(world);
+    ecs_entity_t T2 = ecs_new(world);
+    ecs_entity_t C = ecs_new(world);
 
     Probe ctx = { 0 };
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(R, EcsWildcard), .src.flags = EcsUp },
+        .query.terms = {
+            { .id = ecs_pair(R, EcsWildcard), .src.id = EcsUp, .trav = EcsIsA },
             { .id = C },
         },
         .events = { EcsOnRemove },
@@ -4255,11 +4379,11 @@ void Observer_on_remove_target_from_base_at_offset(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add_pair(world, base, R, T1);
     ecs_add_pair(world, base, R, T2);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base);
     ecs_add_id(world, e, C);
 
@@ -4278,7 +4402,7 @@ void Observer_on_remove_target_from_base_at_offset(void) {
 static void Observer_base_component(ecs_iter_t *it) {
     probe_system_w_ctx(it, it->ctx);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_assert(p != NULL);
     test_int(p->x, 30);
     test_int(p->y, 40);
@@ -4288,14 +4412,14 @@ void Observer_on_remove_target_component_from_base_at_offset(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
-    ecs_entity_t T1 = ecs_new_id(world);
-    ecs_entity_t T2 = ecs_new_id(world);
-    ecs_entity_t C = ecs_new_id(world);
+    ecs_entity_t T1 = ecs_new(world);
+    ecs_entity_t T2 = ecs_new(world);
+    ecs_entity_t C = ecs_new(world);
 
     Probe ctx = { 0 };
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_pair(ecs_id(Position), EcsWildcard), .src.flags = EcsUp },
+        .query.terms = {
+            { .id = ecs_pair(ecs_id(Position), EcsWildcard), .src.id = EcsUp, .trav = EcsIsA },
             { .id = C },
         },
         .events = { EcsOnRemove },
@@ -4303,11 +4427,11 @@ void Observer_on_remove_target_component_from_base_at_offset(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_set_pair(world, base, Position, T1, {10, 20});
     ecs_set_pair(world, base, Position, T2, {30, 40});
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base);
     ecs_add_id(world, e, C);
 
@@ -4339,9 +4463,9 @@ static void Observer_dummy(ecs_iter_t *it) {}
 void Observer_wildcard_propagate_w_other_table(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t tag = ecs_new_id(world);
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t tgt_1 = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t tgt_1 = ecs_new(world);
     
     ecs_entity_t parent = ecs_new_w_id(world, tag);
     ecs_new_w_pair(world, EcsChildOf, parent);
@@ -4349,20 +4473,20 @@ void Observer_wildcard_propagate_w_other_table(void) {
     Probe ctx_parent = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_pair(rel, EcsWildcard) }},
+        .query.terms = {{ ecs_pair(rel, EcsWildcard) }},
         .events = {EcsOnAdd},
         .callback = Observer_dummy
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_pair(rel, EcsWildcard) }},
+        .query.terms = {{ ecs_pair(rel, EcsWildcard) }},
         .events = {EcsWildcard},
         .callback = Observer_w_other_table,
         .ctx = &ctx_parent
     });
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_pair(rel, EcsWildcard), .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ ecs_pair(rel, EcsWildcard), .src.id = EcsUp }},
         .events = {EcsWildcard},
         .callback = Observer_dummy
     });
@@ -4381,7 +4505,7 @@ void Observer_disable_observer(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer(ecs, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) }
         },
         .events = { EcsOnAdd },
@@ -4389,19 +4513,19 @@ void Observer_disable_observer(void) {
         .ctx = &ctx
     });
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 1);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, o, false);
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 0);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, o, true);
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 1);
     ecs_os_zeromem(&ctx);
 
@@ -4417,8 +4541,8 @@ void Observer_disable_observer_module(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer(ecs, {
-        .entity = ecs_entity(ecs, { .add = { ecs_childof(module) }}),
-        .filter.terms = {
+        .entity = ecs_entity(ecs, { .parent = module }),
+        .query.terms = {
             { .id = ecs_id(Position) }
         },
         .events = { EcsOnAdd },
@@ -4426,21 +4550,21 @@ void Observer_disable_observer_module(void) {
         .ctx = &ctx
     });
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 1);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, module, false);
     test_assert(!ecs_has_id(ecs, o, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 0);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, module, true);
     test_assert(!ecs_has_id(ecs, o, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 1);
     ecs_os_zeromem(&ctx);
 
@@ -4458,8 +4582,8 @@ void Observer_disable_observer_module_nested(void) {
 
     Probe ctx = {0};
     ecs_observer(ecs, {
-        .entity = ecs_entity(ecs, { .add = { ecs_childof(module_child) }}),
-        .filter.terms = {
+        .entity = ecs_entity(ecs, { .parent = module_child }),
+        .query.terms = {
             { .id = ecs_id(Position) }
         },
         .events = { EcsOnAdd },
@@ -4467,35 +4591,35 @@ void Observer_disable_observer_module_nested(void) {
         .ctx = &ctx
     });
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 1);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, module, false);
     test_assert(!ecs_has_id(ecs, module_child, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 0);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, module_child, false);
     test_assert(ecs_has_id(ecs, module_child, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 0);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, module, true);
     test_assert(ecs_has_id(ecs, module_child, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 0);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, module_child, true);
     test_assert(!ecs_has_id(ecs, module_child, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 1);
     ecs_os_zeromem(&ctx);
 
@@ -4511,8 +4635,8 @@ void Observer_disable_observer_and_module(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer(ecs, {
-        .entity = ecs_entity(ecs, { .add = { ecs_childof(module) }}),
-        .filter.terms = {
+        .entity = ecs_entity(ecs, { .parent = module }),
+        .query.terms = {
             { .id = ecs_id(Position) }
         },
         .events = { EcsOnAdd },
@@ -4520,35 +4644,35 @@ void Observer_disable_observer_and_module(void) {
         .ctx = &ctx
     });
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 1);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, module, false);
     test_assert(!ecs_has_id(ecs, o, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 0);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, o, false);
     test_assert(ecs_has_id(ecs, o, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 0);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, module, true);
     test_assert(ecs_has_id(ecs, o, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 0);
     ecs_os_zeromem(&ctx);
 
     ecs_enable(ecs, o, true);
     test_assert(!ecs_has_id(ecs, o, EcsDisabled));
 
-    ecs_new(ecs, Position);
+    ecs_new_w(ecs, Position);
     test_int(ctx.invoked, 1);
     ecs_os_zeromem(&ctx);
 
@@ -4563,7 +4687,7 @@ void Observer_disable_multi_observer(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer(ecs, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity) },
         },
@@ -4573,7 +4697,7 @@ void Observer_disable_multi_observer(void) {
     });
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 1);
@@ -4582,7 +4706,7 @@ void Observer_disable_multi_observer(void) {
     ecs_enable(ecs, o, false);
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 0);
@@ -4591,7 +4715,7 @@ void Observer_disable_multi_observer(void) {
     ecs_enable(ecs, o, true);
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 1);
@@ -4610,8 +4734,8 @@ void Observer_disable_multi_observer_module(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer(ecs, {
-        .entity = ecs_entity(ecs, { .add = { ecs_childof(module) }}),
-        .filter.terms = {
+        .entity = ecs_entity(ecs, { .parent = module }),
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity) },
         },
@@ -4621,7 +4745,7 @@ void Observer_disable_multi_observer_module(void) {
     });
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 1);
@@ -4631,7 +4755,7 @@ void Observer_disable_multi_observer_module(void) {
     test_assert(!ecs_has_id(ecs, o, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 0);
@@ -4641,7 +4765,7 @@ void Observer_disable_multi_observer_module(void) {
     test_assert(!ecs_has_id(ecs, o, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 1);
@@ -4662,8 +4786,8 @@ void Observer_disable_multi_observer_module_nested(void) {
 
     Probe ctx = {0};
     ecs_observer(ecs, {
-        .entity = ecs_entity(ecs, { .add = { ecs_childof(module_child) }}),
-        .filter.terms = {
+        .entity = ecs_entity(ecs, { .parent = module_child }),
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity) }
         },
@@ -4673,7 +4797,7 @@ void Observer_disable_multi_observer_module_nested(void) {
     });
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 1);
@@ -4683,7 +4807,7 @@ void Observer_disable_multi_observer_module_nested(void) {
     test_assert(!ecs_has_id(ecs, module_child, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 0);
@@ -4693,7 +4817,7 @@ void Observer_disable_multi_observer_module_nested(void) {
     test_assert(ecs_has_id(ecs, module_child, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 0);
@@ -4703,7 +4827,7 @@ void Observer_disable_multi_observer_module_nested(void) {
     test_assert(ecs_has_id(ecs, module_child, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 0);
@@ -4713,7 +4837,7 @@ void Observer_disable_multi_observer_module_nested(void) {
     test_assert(!ecs_has_id(ecs, module_child, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 1);
@@ -4732,8 +4856,8 @@ void Observer_disable_multi_observer_and_module(void) {
 
     Probe ctx = {0};
     ecs_entity_t o = ecs_observer(ecs, {
-        .entity = ecs_entity(ecs, { .add = { ecs_childof(module) }}),
-        .filter.terms = {
+        .entity = ecs_entity(ecs, { .parent = module }),
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity) }
         },
@@ -4743,7 +4867,7 @@ void Observer_disable_multi_observer_and_module(void) {
     });
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 1);
@@ -4753,7 +4877,7 @@ void Observer_disable_multi_observer_and_module(void) {
     test_assert(!ecs_has_id(ecs, o, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 0);
@@ -4763,7 +4887,7 @@ void Observer_disable_multi_observer_and_module(void) {
     test_assert(ecs_has_id(ecs, o, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 0);
@@ -4773,7 +4897,7 @@ void Observer_disable_multi_observer_and_module(void) {
     test_assert(ecs_has_id(ecs, o, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 0);
@@ -4783,7 +4907,7 @@ void Observer_disable_multi_observer_and_module(void) {
     test_assert(!ecs_has_id(ecs, o, EcsDisabled));
 
     {
-        ecs_entity_t e = ecs_new(ecs, Position);
+        ecs_entity_t e = ecs_new_w(ecs, Position);
         ecs_add(ecs, e, Velocity);
     }
     test_int(ctx.invoked, 1);
@@ -4795,13 +4919,13 @@ void Observer_disable_multi_observer_and_module(void) {
 void Observer_tag_w_on_set_and_on_add(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {{ tag }},
+        .query.terms = {{ tag }},
         .events = {EcsOnAdd, EcsOnSet},
         .callback = Observer,
         .ctx = &ctx
@@ -4819,7 +4943,7 @@ void Observer_tag_w_on_set_and_on_add(void) {
     ecs_delete(world, o);
     ecs_os_zeromem(&ctx);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_id(world, e2, tag);
     test_int(ctx.invoked, 0);
 
@@ -4829,13 +4953,13 @@ void Observer_tag_w_on_set_and_on_add(void) {
 void Observer_tag_w_on_set_and_on_add_reverse(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {{ tag }},
+        .query.terms = {{ tag }},
         .events = {EcsOnSet, EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
@@ -4853,7 +4977,7 @@ void Observer_tag_w_on_set_and_on_add_reverse(void) {
     ecs_delete(world, o);
     ecs_os_zeromem(&ctx);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_id(world, e2, tag);
     test_int(ctx.invoked, 0);
 
@@ -4863,13 +4987,13 @@ void Observer_tag_w_on_set_and_on_add_reverse(void) {
 void Observer_tag_w_un_set_and_on_remove(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {{ tag }},
+        .query.terms = {{ tag }},
         .events = {EcsOnRemove, EcsUnSet},
         .callback = Observer,
         .ctx = &ctx
@@ -4890,7 +5014,7 @@ void Observer_tag_w_un_set_and_on_remove(void) {
     ecs_delete(world, o);
     ecs_os_zeromem(&ctx);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_id(world, e2, tag);
     ecs_remove_id(world, e1, tag);
     test_int(ctx.invoked, 0);
@@ -4901,13 +5025,13 @@ void Observer_tag_w_un_set_and_on_remove(void) {
 void Observer_tag_w_un_set_and_on_remove_reverse(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {{ tag }},
+        .query.terms = {{ tag }},
         .events = {EcsUnSet, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
@@ -4928,7 +5052,7 @@ void Observer_tag_w_un_set_and_on_remove_reverse(void) {
     ecs_delete(world, o);
     ecs_os_zeromem(&ctx);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_id(world, e2, tag);
     ecs_remove_id(world, e1, tag);
     test_int(ctx.invoked, 0);
@@ -4942,12 +5066,12 @@ void Observer_on_add_pair_w_rel_any(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_pair(EcsAny, Tgt) }},
+        .query.terms = {{ ecs_pair(EcsAny, Tgt) }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
@@ -4973,12 +5097,12 @@ void Observer_on_remove_pair_w_rel_any(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_pair(EcsAny, Tgt) }},
+        .query.terms = {{ ecs_pair(EcsAny, Tgt) }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
@@ -5008,12 +5132,12 @@ void Observer_on_add_pair_w_tgt_any(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_pair(Rel, EcsAny) }},
+        .query.terms = {{ ecs_pair(Rel, EcsAny) }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
@@ -5039,12 +5163,12 @@ void Observer_on_remove_pair_w_tgt_any(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_pair(Rel, EcsAny) }},
+        .query.terms = {{ ecs_pair(Rel, EcsAny) }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
@@ -5074,12 +5198,12 @@ void Observer_on_add_pair_w_any_any(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_pair(EcsAny, EcsAny) }},
+        .query.terms = {{ ecs_pair(EcsAny, EcsAny) }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
@@ -5105,12 +5229,12 @@ void Observer_on_remove_pair_w_any_any(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ ecs_pair(EcsAny, EcsAny) }},
+        .query.terms = {{ ecs_pair(EcsAny, EcsAny) }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
@@ -5139,12 +5263,12 @@ void Observer_on_add_any(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ EcsAny }},
+        .query.terms = {{ EcsAny }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
@@ -5169,12 +5293,12 @@ void Observer_on_remove_any(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ EcsAny }},
+        .query.terms = {{ EcsAny }},
         .events = {EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
@@ -5199,12 +5323,12 @@ void Observer_yield_existing_uni_no_this(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA, .src.id = e1 },
         },
         .events = {EcsOnAdd},
@@ -5228,13 +5352,13 @@ void Observer_yield_existing_multi_no_this(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
     ecs_add(world, e1, TagB);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA, .src.id = e1 },
             { TagB, .src.id = e1 },
         },
@@ -5253,17 +5377,41 @@ void Observer_yield_existing_multi_no_this(void) {
     ecs_fini(world);
 }
 
+void Observer_observer_no_id_in_scope(void) {
+    ecs_world_t* world = ecs_mini();
+    
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t parent = ecs_new(world);
+
+    ecs_set_scope(world, parent);
+
+    ecs_entity_t o = ecs_observer(world, {
+        .query.terms = {
+            { .id = TagA },
+        },
+        .callback = Observer,
+        .events = { EcsOnAdd },
+    });
+
+    ecs_set_scope(world, 0);
+
+    test_assert(ecs_has_pair(world, o, EcsChildOf, parent));
+
+    ecs_fini(world);
+}
+
 void Observer_cache_test_1(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ tag, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx
@@ -5280,7 +5428,7 @@ void Observer_cache_test_1(void) {
     test_int(ctx.event, EcsOnAdd);
     ecs_os_zeromem(&ctx);
 
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e3 = ecs_new(world);
     ecs_add_id(world, e3, ecs_pair(EcsChildOf, e2));
 
     test_int(ctx.invoked, 1);
@@ -5309,7 +5457,7 @@ void Observer_cache_test_1(void) {
     test_int(ctx.event, EcsOnRemove);
     ecs_os_zeromem(&ctx);
 
-    e3 = ecs_new_id(world);
+    e3 = ecs_new(world);
     ecs_add_id(world, e3, ecs_pair(EcsChildOf, e2));
 
     test_int(ctx.invoked, 0);
@@ -5320,23 +5468,23 @@ void Observer_cache_test_1(void) {
 void Observer_cache_test_2(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag_1 = ecs_new_id(world);
-    ecs_entity_t tag_2 = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t tag_1 = ecs_new(world);
+    ecs_entity_t tag_2 = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     Probe ctx_1 = {0};
     Probe ctx_2 = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ tag_1, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_1, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx_1
     });
     ecs_observer(world, {
-        .filter.terms = {{ tag_2, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_2, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx_2
@@ -5382,23 +5530,23 @@ void Observer_cache_test_2(void) {
 void Observer_cache_test_3(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag_1 = ecs_new_id(world);
-    ecs_entity_t tag_2 = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t tag_1 = ecs_new(world);
+    ecs_entity_t tag_2 = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     Probe ctx_1 = {0};
     Probe ctx_2 = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ tag_1, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_1, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx_1
     });
     ecs_observer(world, {
-        .filter.terms = {{ tag_2, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_2, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx_2
@@ -5445,32 +5593,32 @@ void Observer_cache_test_3(void) {
 void Observer_cache_test_4(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag_0 = ecs_new_id(world);
-    ecs_entity_t tag_1 = ecs_new_id(world);
-    ecs_entity_t tag_2 = ecs_new_id(world);
-    ecs_entity_t e0 = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t tag_0 = ecs_new(world);
+    ecs_entity_t tag_1 = ecs_new(world);
+    ecs_entity_t tag_2 = ecs_new(world);
+    ecs_entity_t e0 = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     Probe *ctx_0 = ecs_os_calloc_t(Probe);
     Probe *ctx_1 = ecs_os_calloc_t(Probe);
     Probe *ctx_2 = ecs_os_calloc_t(Probe);
 
     ecs_observer(world, {
-        .filter.terms = {{ tag_0, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_0, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = ctx_0
     });
     ecs_observer(world, {
-        .filter.terms = {{ tag_1, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_1, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = ctx_1
     });
     ecs_observer(world, {
-        .filter.terms = {{ tag_2, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_2, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = ctx_2
@@ -5553,26 +5701,26 @@ void Observer_cache_test_4(void) {
 void Observer_cache_test_5(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag_0 = ecs_new_id(world);
-    ecs_entity_t tag_1 = ecs_new_id(world);
-    ecs_entity_t tag_2 = ecs_new_id(world);
-    ecs_entity_t e0 = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
+    ecs_entity_t tag_0 = ecs_new(world);
+    ecs_entity_t tag_1 = ecs_new(world);
+    ecs_entity_t tag_2 = ecs_new(world);
+    ecs_entity_t e0 = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
 
     Probe ctx_1 = {0};
     Probe ctx_2 = {0};
 
     ecs_observer(world, {
-        .filter.terms = {{ tag_1, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_1, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx_1
     });
     ecs_observer(world, {
-        .filter.terms = {{ tag_2, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_2, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx_2
@@ -5641,14 +5789,14 @@ void Observer_cache_test_5(void) {
 void Observer_cache_test_6(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag_1 = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t tag_1 = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     Probe ctx_1 = {0};
     ecs_observer(world, {
-        .filter.terms = {{ tag_1, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_1, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx_1
@@ -5684,15 +5832,15 @@ void Observer_cache_test_6(void) {
 void Observer_cache_test_7(void) {
     ecs_world_t *world = ecs_mini();
     
-    ecs_entity_t tag_1 = ecs_new_id(world);
-    ecs_entity_t tag_2 = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t tag_1 = ecs_new(world);
+    ecs_entity_t tag_2 = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     Probe ctx_1 = {0};
     ecs_observer(world, {
-        .filter.terms = {{ tag_1, .src.flags = EcsUp, .src.trav = EcsChildOf }},
+        .query.terms = {{ tag_1, .src.id = EcsUp, .trav = EcsChildOf }},
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Observer,
         .ctx = &ctx_1
@@ -5734,13 +5882,13 @@ void Observer_cache_test_8(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ TagB }},
+        .query.terms = {{ TagB }},
         .events = {EcsOnAdd},
         .callback = Observer,
         .ctx = &ctx
     });
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_add(world, parent, TagA);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
     ecs_new_w_pair(world, EcsChildOf, child);
@@ -5757,11 +5905,6 @@ void Observer_cache_test_8(void) {
     ecs_fini(world);
 }
 
-static
-void testobserver(ecs_iter_t *it) {
-    printf("%s\n", ecs_iter_str(it));
-}
-
 void Observer_cache_test_9(void) {
     ecs_world_t *world = ecs_mini();
 
@@ -5769,7 +5912,7 @@ void Observer_cache_test_9(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {{ ecs_id(Position), .src.flags = EcsUp }},
+        .query.terms = {{ ecs_id(Position), .src.id = EcsUp, .trav = EcsIsA }},
         .events = { EcsOnRemove },
         .callback = Observer,
         .ctx = &ctx
@@ -5819,31 +5962,31 @@ void Observer_cache_test_9(void) {
 void Observer_cache_test_10(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t tag = ecs_new_id(world);
-    ecs_entity_t ns = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
+    ecs_entity_t ns = ecs_new(world);
     ecs_add_id(world, ns, tag);
 
     ecs_entity_t foo_parent = ecs_new_w_pair(world, EcsChildOf, ns);
     ecs_entity_t foo = ecs_new_w_pair(world, EcsChildOf, foo_parent);
-    ecs_entity_t bar = ecs_new_id(world);
+    ecs_entity_t bar = ecs_new(world);
 
     ecs_entity_t parent = ecs_new_w_id(world, foo);
     
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_id(world, e1, foo);
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_id(world, e1, bar);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_id(world, e2, foo);
     ecs_add_pair(world, e2, EcsChildOf, parent);
     ecs_add_id(world, e2, bar);
 
-    ecs_entity_t c1 = ecs_new_id(world);
+    ecs_entity_t c1 = ecs_new(world);
     ecs_add_id(world, c1, foo);
     ecs_add_pair(world, c1, EcsChildOf, e1);
 
-    ecs_entity_t c2 = ecs_new_id(world);
+    ecs_entity_t c2 = ecs_new(world);
     ecs_add_id(world, c2, foo);
     ecs_add_pair(world, c2, EcsChildOf, e2);
 
@@ -5870,7 +6013,7 @@ void Observer_cache_test_10(void) {
 void Observer_cache_test_11(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t ns = ecs_new_id(world);
+    ecs_entity_t ns = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, ns);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsDependsOn, e1);
     ecs_add_pair(world, e2, EcsChildOf, e1);
@@ -5880,7 +6023,7 @@ void Observer_cache_test_11(void) {
     ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, e3);
     ecs_add_pair(world, e4, EcsDependsOn, e2);
 
-    ecs_add_id(world, e1, ecs_new_id(world));
+    ecs_add_id(world, e1, ecs_new(world));
 
     ecs_run_aperiodic(world, 0);
 
@@ -5892,16 +6035,16 @@ void Observer_cache_test_11(void) {
 void Observer_cache_test_12(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t t0 = ecs_new_id(world); 
-    ecs_entity_t t1 = ecs_new_id(world); 
-    ecs_entity_t t2 = ecs_new_id(world); 
+    ecs_entity_t t0 = ecs_new(world); 
+    ecs_entity_t t1 = ecs_new(world); 
+    ecs_entity_t t2 = ecs_new(world); 
 
-    ecs_entity_t e0 = ecs_new_id(world); 
+    ecs_entity_t e0 = ecs_new(world); 
     ecs_add_id(world, e0, t0); 
     ecs_add_id(world, e0, t1); 
     ecs_add_id(world, e0, t2); 
 
-    ecs_entity_t e1 = ecs_new_id(world); 
+    ecs_entity_t e1 = ecs_new(world); 
     ecs_add_id(world, e1, t0); 
     ecs_add_id(world, e1, t1); 
     ecs_add_id(world, e1, t2); 
@@ -5910,7 +6053,7 @@ void Observer_cache_test_12(void) {
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, e0); 
     ecs_add_id(world, e3, t0); 
 
-    ecs_entity_t e4 = ecs_new_id(world); 
+    ecs_entity_t e4 = ecs_new(world); 
     ecs_new_w_pair(world, EcsChildOf, e4); 
     ecs_remove_all(world, t1); 
 
@@ -5929,17 +6072,17 @@ void Observer_cache_test_13(void) {
     install_test_abort();
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t t0 = ecs_new_id(world);
-    ecs_entity_t e0 = ecs_new_id(world);
+    ecs_entity_t t0 = ecs_new(world);
+    ecs_entity_t e0 = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_id(world, e1, t0);
     ecs_add_id(world, e1, ecs_pair(EcsChildOf, e0));
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_id(world, e2, t0);
 
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e3 = ecs_new(world);
     ecs_add_id(world, e3, ecs_pair(EcsChildOf, e2));
 
     ecs_delete_with(world, t0);
@@ -5947,7 +6090,7 @@ void Observer_cache_test_13(void) {
     test_assert(!ecs_is_alive(world, e2));
     test_assert(!ecs_is_alive(world, e3));
 
-    ecs_entity_t e4 = ecs_new_id(world);
+    ecs_entity_t e4 = ecs_new(world);
     test_expect_abort();
     ecs_add_id(world, e4, ecs_pair(EcsChildOf, e2));
 }
@@ -5958,13 +6101,13 @@ void Observer_cache_test_14(void) {
     ECS_TAG(world, Tag);
 
     {
-        ecs_entity_t e0 = ecs_new_id(world);
+        ecs_entity_t e0 = ecs_new(world);
         ecs_add(world, e0, Tag);
 
-        ecs_entity_t e1 = ecs_new_id(world);
+        ecs_entity_t e1 = ecs_new(world);
         ecs_add_pair(world, e1, EcsChildOf, e0);
 
-        ecs_entity_t e2 = ecs_new_id(world);
+        ecs_entity_t e2 = ecs_new(world);
         ecs_add_pair(world, e2, EcsChildOf, e1);
 
         ecs_delete_with(world, Tag);
@@ -5975,14 +6118,14 @@ void Observer_cache_test_14(void) {
     }
 
     {
-        ecs_entity_t e0 = ecs_new_id(world);
+        ecs_entity_t e0 = ecs_new(world);
         ecs_add(world, e0, Tag);
 
-        ecs_entity_t e1 = ecs_new_id(world);
+        ecs_entity_t e1 = ecs_new(world);
         ecs_add_pair(world, e1, EcsChildOf, e0);
         ecs_add(world, e1, Tag);
 
-        ecs_entity_t e2 = ecs_new_id(world);
+        ecs_entity_t e2 = ecs_new(world);
         ecs_add_pair(world, e2, EcsChildOf, e1);
 
         ecs_remove_all(world, Tag);
@@ -6000,9 +6143,9 @@ void Observer_cache_test_14(void) {
 void Observer_cache_test_15(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t e0 = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t e0 = ecs_new(world);
+    ecs_entity_t e1 = ecs_new(world);
 
     ecs_add_pair(world, e1, r, e0);
     ecs_add_pair(world, e0, EcsChildOf, e1);
@@ -6031,12 +6174,12 @@ void Observer_cache_test_16(void) {
 
     ECS_OBSERVER(ecs, Observer_w_run_aperiodic, EcsOnAdd, Foo);
 
-    ecs_entity_t p1 = ecs_new_id(ecs);
+    ecs_entity_t p1 = ecs_new(ecs);
     ecs_entity_t e1 = ecs_new_w_pair(ecs, EcsIsA, p1);
 
     ecs_run_aperiodic(ecs, 0);
     
-    ecs_entity_t e2 = ecs_new_id(ecs);
+    ecs_entity_t e2 = ecs_new(ecs);
     ecs_add_pair(ecs, e2, EcsIsA, p1);
     ecs_add_pair(ecs, e2, EcsChildOf, e1);
     ecs_add(ecs, e1, Foo);
@@ -6062,7 +6205,7 @@ void Observer_filter_observer_after_observer(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = Tag }
         },
@@ -6071,7 +6214,7 @@ void Observer_filter_observer_after_observer(void) {
     });
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position), .inout = EcsInOutNone },
             { .id = Tag, .inout = EcsInOutNone}
         },
@@ -6079,7 +6222,7 @@ void Observer_filter_observer_after_observer(void) {
         .events = { EcsOnAdd }
     });
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
     ecs_add(world, e, Position);
 
     test_int(Observer_a_invoked, 1);
@@ -6097,7 +6240,7 @@ void Observer_notify_after_defer_batched(void) {
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity) }
         },
@@ -6107,7 +6250,7 @@ void Observer_notify_after_defer_batched(void) {
     });
 
     ecs_defer_begin(world);
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     test_int(ctx.invoked, 0);
     ecs_set(world, e1, Velocity, {1, 2});
@@ -6128,7 +6271,7 @@ void Observer_notify_after_defer_batched_2_entities_in_table(void) {
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity) }
         },
@@ -6137,7 +6280,7 @@ void Observer_notify_after_defer_batched_2_entities_in_table(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     test_int(ctx.invoked, 0);
     ecs_set(world, e1, Velocity, {1, 2});
@@ -6147,7 +6290,7 @@ void Observer_notify_after_defer_batched_2_entities_in_table(void) {
 
     ecs_os_zeromem(&ctx);
     
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_set(world, e2, Position, {30, 40});
@@ -6169,7 +6312,7 @@ void Observer_notify_after_defer_batched_2_entities_in_table_w_tgt(void) {
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity) }
         },
@@ -6178,7 +6321,7 @@ void Observer_notify_after_defer_batched_2_entities_in_table_w_tgt(void) {
         .ctx = &ctx
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     test_int(ctx.invoked, 0);
     ecs_set(world, e1, Velocity, {1, 2});
@@ -6188,8 +6331,8 @@ void Observer_notify_after_defer_batched_2_entities_in_table_w_tgt(void) {
 
     ecs_os_zeromem(&ctx);
     
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
     ecs_add_pair(world, e3, EcsChildOf, e2);
 
     ecs_defer_begin(world);
@@ -6212,11 +6355,11 @@ void Observer_multi_observer_table_fill_w_singleton(void) {
     Probe ctx = {0};
 
     ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position), .src.flags = EcsIsEntity, .src.id = ecs_id(Position) },
+        .query.terms = {
+            { .id = ecs_id(Position), .src.id = ecs_id(Position)|EcsIsEntity },
             { .id = ecs_id(Velocity) },
         },
-        .filter.flags = EcsFilterNoData,
+        .query.flags = EcsQueryNoData,
         .callback = Observer,
         .events = { EcsOnTableFill },
         .ctx = &ctx
@@ -6225,7 +6368,7 @@ void Observer_multi_observer_table_fill_w_singleton(void) {
     ecs_singleton_add(world, Position);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Velocity);
     test_int(ctx.invoked, 0);
 
@@ -6251,12 +6394,12 @@ void Observer_add_in_yield_existing(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT_DEFINE(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
         },
         .callback = AddVelocity,
@@ -6283,16 +6426,16 @@ void Observer_add_in_yield_existing_multi(void) {
     ECS_COMPONENT(world, Mass);
     ECS_COMPONENT_DEFINE(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
 
     ecs_add(world, e1, Mass);
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Mass) },
         },
@@ -6322,14 +6465,14 @@ void Observer_get_filter(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {
-            { .id = ecs_id(Position) },
+        .query.terms = {
+            { .id = ecs_id(Position) }
         },
         .callback = Observer,
         .events = { EcsOnAdd },
     });
 
-    const ecs_filter_t *f = ecs_observer_get_filter(world, o);
+    const ecs_query_t *f = ecs_observer_get_query(world, o);
     test_assert(f != NULL);
     test_int(f->term_count, 1);
     test_uint(ecs_id(Position), f->terms[0].id);
@@ -6343,20 +6486,20 @@ void Observer_uni_observer_eval_count(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
         },
         .callback = Observer,
         .events = { EcsOnAdd },
     });
 
-    const ecs_filter_t *f = ecs_observer_get_filter(world, o);
-    test_assert(f != NULL);
-    test_int(f->eval_count, 0);
+    const ecs_query_t *q = ecs_observer_get_query(world, o);
+    test_assert(q != NULL);
+    test_int(q->eval_count, 0);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
-    test_int(f->eval_count, 1);
+    test_int(q->eval_count, 1);
 
     ecs_fini(world);
 }
@@ -6368,7 +6511,7 @@ void Observer_multi_observer_eval_count(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t o = ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity) },
         },
@@ -6376,15 +6519,15 @@ void Observer_multi_observer_eval_count(void) {
         .events = { EcsOnAdd },
     });
 
-    const ecs_filter_t *f = ecs_observer_get_filter(world, o);
-    test_assert(f != NULL);
-    test_int(f->eval_count, 0);
+    const ecs_query_t *q = ecs_observer_get_query(world, o);
+    test_assert(q != NULL);
+    test_int(q->eval_count, 0);
 
-    ecs_entity_t e = ecs_new(world, Position);
-    test_int(f->eval_count, 0);
+    ecs_entity_t e = ecs_new_w(world, Position);
+    test_int(q->eval_count, 0);
 
     ecs_add(world, e, Velocity);
-    test_int(f->eval_count, 1);
+    test_int(q->eval_count, 1);
 
     ecs_fini(world);
 }
diff --git a/test/api/src/ObserverOnSet.c b/test/core/src/ObserverOnSet.c
similarity index 89%
rename from test/api/src/ObserverOnSet.c
rename to test/core/src/ObserverOnSet.c
index 923e66165..d2611e522 100644
--- a/test/api/src/ObserverOnSet.c
+++ b/test/core/src/ObserverOnSet.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static
 void OnPosition(ecs_iter_t *it) {
@@ -49,8 +49,8 @@ static Probe pv_probe;
 
 static
 void On_PV(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     probe_system_w_ctx(it, &pv_probe);
 
@@ -71,7 +71,7 @@ void ObserverOnSet_set_1_of_1(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -117,7 +117,7 @@ void ObserverOnSet_set_1_of_2(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -168,7 +168,7 @@ void ObserverOnSet_set_1_of_3(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -238,7 +238,7 @@ void ObserverOnSet_set_1_of_2_1_from_base(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_ENTITY(world, Base, Position);
-    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up), Velocity);
+    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up IsA), Velocity);
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
@@ -272,7 +272,7 @@ void ObserverOnSet_set_1_of_3_1_from_base(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
     ECS_ENTITY(world, Base, Position);
-    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up), Velocity, Mass);
+    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up IsA), Velocity, Mass);
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
@@ -327,12 +327,12 @@ void ObserverOnSet_add_base(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_ENTITY(world, Base, Position);
-    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up), Velocity);
+    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up IsA), Velocity);
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Velocity);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsIsA, Base);
@@ -356,12 +356,12 @@ void ObserverOnSet_add_base_to_1_overridden(void) {
 
     ECS_COMPONENT(world, Position);
     ECS_ENTITY(world, Base, Position);
-    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up));
+    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up IsA));
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsIsA, Base);
@@ -376,12 +376,12 @@ void ObserverOnSet_add_base_to_2_overridden(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_ENTITY(world, Base, Position, Velocity);
-    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up), Velocity(self|up));
+    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up IsA), Velocity(self|up IsA));
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_add(world, e, Velocity);
     test_int(ctx.invoked, 0);
 
@@ -397,12 +397,12 @@ void ObserverOnSet_add_base_to_1_of_2_overridden(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_ENTITY(world, Base, Position, Velocity);
-    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up));
+    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up IsA));
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Velocity);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsIsA, Base);
@@ -418,7 +418,7 @@ void ObserverOnSet_add_base_to_1_of_2_overridden(void) {
 
     ecs_os_zeromem(&ctx);
 
-    e = ecs_new(world, Position);
+    e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsIsA, Base);
@@ -438,7 +438,7 @@ void ObserverOnSet_on_set_after_remove_override(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsIsA, Base);
@@ -464,12 +464,12 @@ void ObserverOnSet_no_set_after_remove_base(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_ENTITY(world, Base, Position);
-    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up));
+    ECS_OBSERVER(world, OnPosition, EcsOnSet, Position(self|up IsA));
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsIsA, Base);
@@ -490,7 +490,7 @@ void ObserverOnSet_un_set_after_remove(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_remove(world, e, Position);
@@ -504,12 +504,12 @@ void ObserverOnSet_un_set_after_remove_base(void) {
 
     ECS_COMPONENT(world, Position);
     ECS_ENTITY(world, Base, Position);
-    ECS_OBSERVER(world, OnPosition, EcsUnSet, Position(self|up));
+    ECS_OBSERVER(world, OnPosition, EcsUnSet, Position(self|up IsA));
 
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsIsA, Base);
@@ -532,9 +532,9 @@ void ObserverOnSet_add_to_current_in_on_set(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {11, 21});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {12, 22});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {11, 21}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {12, 22}));
 
     test_assert( ecs_has(world, e1, Position));
     test_assert( ecs_has(world, e2, Position));
@@ -574,9 +574,9 @@ void ObserverOnSet_remove_from_current_in_on_set(void) {
     ECS_ENTITY(world, e2, Position, Velocity);
     ECS_ENTITY(world, e3, Position, Velocity);
 
-    e1 = ecs_set(world, e1, Position, {10, 20});
-    e2 = ecs_set(world, e2, Position, {11, 21});
-    e3 = ecs_set(world, e3, Position, {12, 22});
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e2, Position, {11, 21});
+    ecs_set(world, e3, Position, {12, 22});
 
     test_assert( ecs_has(world, e1, Position));
     test_assert( ecs_has(world, e2, Position));
@@ -616,9 +616,9 @@ void ObserverOnSet_remove_set_component_in_on_set(void) {
     ECS_ENTITY(world, e2, Position, Velocity);
     ECS_ENTITY(world, e3, Position, Velocity);
 
-    e1 = ecs_set(world, e1, Position, {10, 20});
-    e2 = ecs_set(world, e2, Position, {11, 21});
-    e3 = ecs_set(world, e3, Position, {12, 22});
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e2, Position, {11, 21});
+    ecs_set(world, e3, Position, {12, 22});
 
     test_assert( !ecs_has(world, e1, Position));
     test_assert( !ecs_has(world, e2, Position));
@@ -644,9 +644,9 @@ void ObserverOnSet_match_table_created_w_add_in_on_set(void) {
     IterData add_ctx = {.component = ecs_id(Velocity)};
     ecs_set_ctx(world, &add_ctx, NULL);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_progress(world, 1);
 
@@ -677,7 +677,7 @@ void ObserverOnSet_set_optional(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -709,7 +709,7 @@ void ObserverOnSet_set_from_nothing(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
     test_int(ctx.system, OnPosition);
@@ -752,7 +752,7 @@ void ObserverOnSet_add_0_entity_in_on_set(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     test_expect_abort();
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
 }
 
 static int dummy_invoked = 0;
@@ -769,6 +769,7 @@ void ObserverOnSet_on_set_prefab(void) {
     ECS_OBSERVER(world, Dummy, EcsOnSet, Position);
 
     ECS_PREFAB(world, Prefab, 0);
+    test_assert(ecs_has_id(world, Prefab, EcsPrefab));
     ecs_set(world, Prefab, Position, {10, 20});
 
     test_int(dummy_invoked, 0);
diff --git a/test/api/src/OnDelete.c b/test/core/src/OnDelete.c
similarity index 81%
rename from test/api/src/OnDelete.c
rename to test/core/src/OnDelete.c
index 851511b38..ee7cb5c51 100644
--- a/test/api/src/OnDelete.c
+++ b/test/core/src/OnDelete.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void OnDelete_flags(void) {
     ecs_flags32_t f_remove = EcsIdOnDeleteRemove;
@@ -37,8 +37,8 @@ void OnDelete_flags(void) {
 void OnDelete_id_default(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, c);
     test_assert(ecs_has_id(world, e, c));
 
@@ -56,10 +56,10 @@ void OnDelete_id_default(void) {
 void OnDelete_id_remove(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
     ecs_add_pair(world, c, EcsOnDelete, EcsRemove);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, c);
     test_assert(ecs_has_id(world, e, c));
 
@@ -75,10 +75,10 @@ void OnDelete_id_remove(void) {
 void OnDelete_id_delete(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
     ecs_add_pair(world, c, EcsOnDelete, EcsDelete);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, c);
     test_assert(ecs_has_id(world, e, c));
 
@@ -93,10 +93,10 @@ void OnDelete_id_delete(void) {
 void OnDelete_relation_default(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, o);
     test_assert(ecs_has_pair(world, e, r, o));
 
@@ -113,11 +113,11 @@ void OnDelete_relation_default(void) {
 void OnDelete_relation_remove(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
     ecs_add_pair(world, r, EcsOnDelete, EcsRemove);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, o);
     test_assert(ecs_has_pair(world, e, r, o));
 
@@ -134,11 +134,11 @@ void OnDelete_relation_remove(void) {
 void OnDelete_relation_delete(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
     ecs_add_pair(world, r, EcsOnDelete, EcsDelete);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, o);
     test_assert(ecs_has_pair(world, e, r, o));
 
@@ -154,10 +154,10 @@ void OnDelete_relation_delete(void) {
 void OnDelete_object_default(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, o);
     test_assert(ecs_has_pair(world, e, r, o));
 
@@ -174,11 +174,11 @@ void OnDelete_object_default(void) {
 void OnDelete_object_remove(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
     ecs_add_pair(world, r, EcsOnDeleteTarget, EcsRemove);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, o);
     test_assert(ecs_has_pair(world, e, r, o));
 
@@ -195,11 +195,11 @@ void OnDelete_object_remove(void) {
 void OnDelete_object_delete(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
     ecs_add_pair(world, r, EcsOnDeleteTarget, EcsDelete);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, o);
     test_assert(ecs_has_pair(world, e, r, o));
 
@@ -215,13 +215,13 @@ void OnDelete_object_delete(void) {
 void OnDelete_object_mixed(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t t_1 = ecs_new_id(world);
-    ecs_entity_t t_2 = ecs_new_id(world);
+    ecs_entity_t t_1 = ecs_new(world);
+    ecs_entity_t t_2 = ecs_new(world);
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
 
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     ecs_add_pair(world, r_1, EcsOnDeleteTarget, EcsDelete);
 
     ecs_entity_t e_1 = ecs_new_w_pair(world, r_1, o);
@@ -255,10 +255,10 @@ void OnDelete_id_throw(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
     ecs_add_pair(world, c, EcsOnDelete, EcsPanic);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, c);
     test_assert(ecs_has_id(world, e, c));
 
@@ -271,11 +271,11 @@ void OnDelete_relation_throw(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
     ecs_add_pair(world, r, EcsOnDelete, EcsPanic);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, o);
     test_assert(ecs_has_pair(world, e, r, o));
 
@@ -288,11 +288,11 @@ void OnDelete_object_throw(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
     ecs_add_pair(world, r, EcsOnDeleteTarget, EcsPanic);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, o);
     test_assert(ecs_has_pair(world, e, r, o));
 
@@ -303,7 +303,7 @@ void OnDelete_object_throw(void) {
 void OnDelete_id_remove_no_instances(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
     ecs_add_pair(world, c, EcsOnDelete, EcsRemove);
 
     ecs_delete(world, c);
@@ -316,7 +316,7 @@ void OnDelete_id_remove_no_instances(void) {
 void OnDelete_id_delete_no_instances(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
     ecs_add_pair(world, c, EcsOnDelete, EcsDelete);
 
     ecs_delete(world, c);
@@ -330,7 +330,7 @@ void OnDelete_id_throw_no_instances(void) {
     install_test_abort();
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
     ecs_add_pair(world, c, EcsOnDelete, EcsPanic);
 
     test_expect_abort();
@@ -340,8 +340,8 @@ void OnDelete_id_throw_no_instances(void) {
 void OnDelete_cyclic_self(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t r = ecs_new(world);
 
     ecs_add_pair(world, e, r, e);
     test_assert(ecs_has_pair(world, e, r, e));
@@ -357,8 +357,8 @@ void OnDelete_nonempty_cyclic_self(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new(world, Tag);
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t e = ecs_new_w(world, Tag);
+    ecs_entity_t r = ecs_new(world);
 
     ecs_add_pair(world, e, r, e);
     test_assert(ecs_has_pair(world, e, r, e));
@@ -372,8 +372,8 @@ void OnDelete_nonempty_cyclic_self(void) {
 void OnDelete_cyclic_id_default(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
 
     ecs_add_id(world, a, b);
     ecs_add_id(world, b, a);
@@ -393,8 +393,8 @@ void OnDelete_cyclic_id_default(void) {
 void OnDelete_cyclic_id_remove(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
 
     ecs_add_pair(world, a, EcsOnDelete, EcsRemove);
 
@@ -428,8 +428,8 @@ void OnDelete_cyclic_id_remove(void) {
 void OnDelete_cyclic_id_remove_both(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
     ecs_add_pair(world, a, EcsOnDelete, EcsRemove);
     ecs_add_pair(world, b, EcsOnDelete, EcsRemove);
 
@@ -451,8 +451,8 @@ void OnDelete_cyclic_id_remove_both(void) {
 void OnDelete_cyclic_id_delete(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
     ecs_add_pair(world, a, EcsOnDelete, EcsDelete);
 
     ecs_add_id(world, a, b);
@@ -468,8 +468,8 @@ void OnDelete_cyclic_id_delete(void) {
 void OnDelete_cyclic_id_delete_both(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
     ecs_add_pair(world, a, EcsOnDelete, EcsDelete);
     ecs_add_pair(world, b, EcsOnDelete, EcsDelete);
 
@@ -486,8 +486,8 @@ void OnDelete_cyclic_id_delete_both(void) {
 void OnDelete_cyclic_relation_default(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
 
     ecs_add_id(world, a, b);
     ecs_add_id(world, b, a);
@@ -507,10 +507,10 @@ void OnDelete_cyclic_relation_default(void) {
 void OnDelete_cyclic_relation_remove(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_entity_t o_a = ecs_new_id(world);
-    ecs_entity_t o_b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
+    ecs_entity_t o_a = ecs_new(world);
+    ecs_entity_t o_b = ecs_new(world);
     ecs_add_pair(world, a, EcsOnDelete, EcsRemove);
 
     ecs_add_pair(world, a, b, o_b);
@@ -531,10 +531,10 @@ void OnDelete_cyclic_relation_remove(void) {
 void OnDelete_cyclic_relation_remove_both(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_entity_t o_a = ecs_new_id(world);
-    ecs_entity_t o_b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
+    ecs_entity_t o_a = ecs_new(world);
+    ecs_entity_t o_b = ecs_new(world);
     ecs_add_pair(world, a, EcsOnDelete, EcsRemove);
     ecs_add_pair(world, b, EcsOnDelete, EcsRemove);
 
@@ -557,10 +557,10 @@ void OnDelete_cyclic_relation_remove_both(void) {
 void OnDelete_cyclic_relation_delete(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_entity_t o_a = ecs_new_id(world);
-    ecs_entity_t o_b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
+    ecs_entity_t o_a = ecs_new(world);
+    ecs_entity_t o_b = ecs_new(world);
     ecs_add_pair(world, a, EcsOnDelete, EcsDelete);
 
     ecs_add_pair(world, a, b, o_b);
@@ -576,10 +576,10 @@ void OnDelete_cyclic_relation_delete(void) {
 void OnDelete_cyclic_relation_delete_both(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_entity_t o_a = ecs_new_id(world);
-    ecs_entity_t o_b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
+    ecs_entity_t o_a = ecs_new(world);
+    ecs_entity_t o_b = ecs_new(world);
     ecs_add_pair(world, a, EcsOnDelete, EcsDelete);
     ecs_add_pair(world, b, EcsOnDelete, EcsDelete);
 
@@ -596,9 +596,9 @@ void OnDelete_cyclic_relation_delete_both(void) {
 void OnDelete_cyclic_object_default(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
+    ecs_entity_t r = ecs_new(world);
 
     ecs_add_pair(world, a, r, b);
     ecs_add_pair(world, b, r, a);
@@ -618,9 +618,9 @@ void OnDelete_cyclic_object_default(void) {
 void OnDelete_cyclic_object_remove(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
+    ecs_entity_t r = ecs_new(world);
     ecs_add_pair(world, r, EcsOnDeleteTarget, EcsRemove);
 
     ecs_add_pair(world, a, r, b);
@@ -641,9 +641,9 @@ void OnDelete_cyclic_object_remove(void) {
 void OnDelete_cyclic_object_delete(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
+    ecs_entity_t r = ecs_new(world);
     ecs_add_pair(world, r, EcsOnDeleteTarget, EcsDelete);
 
     ecs_add_pair(world, a, r, b);
@@ -660,9 +660,9 @@ void OnDelete_cyclic_overlapping_table(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_entity_t rel = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
-    ecs_entity_t obj_a = ecs_new_id(world);
-    ecs_entity_t obj_b = ecs_new_id(world);
-    ecs_entity_t obj_c = ecs_new_id(world);
+    ecs_entity_t obj_a = ecs_new(world);
+    ecs_entity_t obj_b = ecs_new(world);
+    ecs_entity_t obj_c = ecs_new(world);
 
     ecs_add_pair(world, obj_a, rel, obj_b);
     ecs_add_pair(world, obj_b, rel, obj_a);
@@ -681,17 +681,17 @@ void OnDelete_cyclic_overlapping_table(void) {
 void OnDelete_cyclic_overlapping_new_tables(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t tag = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
 
     ecs_entity_t rel_1 = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
-    ecs_entity_t rel_2 = ecs_new_id(world);
-    ecs_entity_t obj_a = ecs_new_id(world);
-    ecs_entity_t obj_b = ecs_new_id(world);
+    ecs_entity_t rel_2 = ecs_new(world);
+    ecs_entity_t obj_a = ecs_new(world);
+    ecs_entity_t obj_b = ecs_new(world);
 
     ecs_add_pair(world, obj_a, rel_1, obj_b);
     ecs_add_pair(world, obj_b, rel_1, obj_a);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, rel_2, obj_a);
     ecs_add_pair(world, e, rel_2, obj_b);
     ecs_add_id(world, e, tag);
@@ -709,14 +709,14 @@ void OnDelete_cyclic_object_mixed(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_entity_t rel_1 = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
-    ecs_entity_t rel_2 = ecs_new_id(world);
-    ecs_entity_t obj_a = ecs_new_id(world);
-    ecs_entity_t obj_b = ecs_new_id(world);
+    ecs_entity_t rel_2 = ecs_new(world);
+    ecs_entity_t obj_a = ecs_new(world);
+    ecs_entity_t obj_b = ecs_new(world);
 
     ecs_add_pair(world, obj_a, rel_1, obj_b);
     ecs_add_pair(world, obj_b, rel_1, obj_a);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, rel_2, obj_a);
     ecs_add_pair(world, e, rel_2, obj_b);
 
@@ -737,8 +737,8 @@ void OnDelete_cyclic_storage_table(void) {
     ecs_entity_t rel_1 = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
     ecs_set(world, rel_1, EcsComponent, {1, 1});
 
-    ecs_entity_t obj_a = ecs_new_id(world);
-    ecs_entity_t obj_b = ecs_new_id(world);
+    ecs_entity_t obj_a = ecs_new(world);
+    ecs_entity_t obj_b = ecs_new(world);
 
     ecs_add_pair(world, obj_a, rel_1, obj_b);
 
@@ -746,7 +746,7 @@ void OnDelete_cyclic_storage_table(void) {
     ecs_add_pair(world, obj_b, rel_1, obj_a);
     ecs_add_pair(world, obj_b, rel_1, obj_b);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, rel_1, obj_a);
     ecs_add_pair(world, e, rel_1, obj_b);
 
@@ -767,8 +767,8 @@ void OnDelete_cyclic_storage_table_2(void) {
     ecs_entity_t rel_1 = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
     ecs_set(world, rel_1, EcsComponent, {1, 1});
 
-    ecs_entity_t obj_a = ecs_new_id(world);
-    ecs_entity_t obj_b = ecs_new_id(world);
+    ecs_entity_t obj_a = ecs_new(world);
+    ecs_entity_t obj_b = ecs_new(world);
 
     ecs_add_pair(world, obj_a, rel_1, obj_b);
 
@@ -776,7 +776,7 @@ void OnDelete_cyclic_storage_table_2(void) {
     ecs_add_pair(world, obj_b, rel_1, obj_a);
     ecs_add_pair(world, obj_b, rel_1, obj_b);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, rel_1, obj_a);
     ecs_add_pair(world, e, rel_1, obj_b);
 
@@ -799,8 +799,8 @@ void OnDelete_cyclic_storage_table_3(void) {
     ecs_entity_t rel_1 = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
     ecs_set(world, rel_1, EcsComponent, {1, 1});
 
-    ecs_entity_t obj_a = ecs_new_id(world);
-    ecs_entity_t obj_b = ecs_new_id(world);
+    ecs_entity_t obj_a = ecs_new(world);
+    ecs_entity_t obj_b = ecs_new(world);
 
     ecs_add_pair(world, obj_a, rel_1, obj_b);
 
@@ -808,7 +808,7 @@ void OnDelete_cyclic_storage_table_3(void) {
     ecs_add_pair(world, obj_b, rel_1, obj_a);
     ecs_add_pair(world, obj_b, rel_1, obj_b);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, rel_1, obj_a);
     ecs_add_pair(world, e, rel_1, obj_b);
 
@@ -827,15 +827,15 @@ void OnDelete_cyclic_set_empty(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t rel_1 = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
-    ecs_entity_t rel_2 = ecs_new_id(world);
-    ecs_entity_t obj_a = ecs_new_id(world);
-    ecs_entity_t obj_b = ecs_new_id(world);
+    ecs_entity_t rel_2 = ecs_new(world);
+    ecs_entity_t obj_a = ecs_new(world);
+    ecs_entity_t obj_b = ecs_new(world);
 
     ecs_add_pair(world, obj_a, rel_1, obj_b);
     ecs_add_pair(world, obj_b, rel_1, obj_a);
     ecs_add_pair(world, obj_b, rel_2, obj_b);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
     ecs_add_pair(world, e, rel_2, obj_a);
 
     ecs_delete(world, obj_a);
@@ -855,8 +855,8 @@ void OnDelete_2_acyclic_relations_w_cycle(void) {
     ecs_entity_t r1 = ecs_new_w_id(world, EcsTraversable);
     ecs_entity_t r2 = ecs_new_w_id(world, EcsTraversable);
 
-    ecs_entity_t a = ecs_new_id(world);
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
+    ecs_entity_t b = ecs_new(world);
 
     ecs_add_pair(world, a, r1, b);
     ecs_add_pair(world, b, r2, a);
@@ -869,8 +869,8 @@ void OnDelete_remove_2_comps(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t c = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
     
     ecs_add_id(world, e, c);
     ecs_set(world, e, Position, {10, 20});
@@ -893,15 +893,15 @@ void OnDelete_remove_2_comps_to_existing_table(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t c = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
     
     ecs_add_id(world, e, c);
     ecs_set(world, e, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {20, 30});
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e3 = ecs_new(world);
     ecs_set(world, e3, Position, {40, 50});
 
     ecs_delete(world, c);
@@ -928,15 +928,15 @@ void OnDelete_remove_2_comps_to_existing_table(void) {
 void OnDelete_delete_recursive(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     ecs_add_pair(world, r, EcsOnDeleteTarget, EcsDelete);
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
 
-    ecs_entity_t c = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
     ecs_add_pair(world, c, r, p);
 
-    ecs_entity_t gc = ecs_new_id(world);
+    ecs_entity_t gc = ecs_new(world);
     ecs_add_pair(world, gc, r, c);
 
     ecs_delete(world, p);
@@ -954,7 +954,9 @@ void OnDelete_component_throw(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_add_pair(world, ecs_id(Position), EcsOnDelete, EcsPanic);
+
+    ecs_insert(world, ecs_value(Position, {10, 20}));
 
     test_expect_abort();
     ecs_delete(world, ecs_id(Position));
@@ -963,11 +965,11 @@ void OnDelete_component_throw(void) {
 void OnDelete_remove_2_relations(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o_1 = ecs_new_id(world);
-    ecs_entity_t o_2 = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o_1 = ecs_new(world);
+    ecs_entity_t o_2 = ecs_new(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, o_1);
     ecs_add_pair(world, e, r, o_2);
 
@@ -985,11 +987,11 @@ void OnDelete_remove_2_relations(void) {
 void OnDelete_remove_object_w_2_relations(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r_1, o);
     ecs_add_pair(world, e, r_2, o);
 
@@ -1007,14 +1009,14 @@ void OnDelete_remove_object_w_2_relations(void) {
 void OnDelete_remove_object_w_5_relations(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
-    ecs_entity_t r_3 = ecs_new_id(world);
-    ecs_entity_t r_4 = ecs_new_id(world);
-    ecs_entity_t r_5 = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
+    ecs_entity_t r_3 = ecs_new(world);
+    ecs_entity_t r_4 = ecs_new(world);
+    ecs_entity_t r_5 = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r_1, o);
     ecs_add_pair(world, e, r_2, o);
     ecs_add_pair(world, e, r_3, o);
@@ -1043,11 +1045,11 @@ void OnDelete_remove_object_w_50_relations(void) {
     ecs_entity_t r[NUM];
     int i;
     for (i = 0; i < NUM; i ++) {
-        r[i] = ecs_new_id(world);
+        r[i] = ecs_new(world);
     }
 
-    ecs_entity_t o = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     for (i = 0; i < NUM; i ++) {
         ecs_add_pair(world, e, r[i], o);
@@ -1076,10 +1078,10 @@ void OnDelete_remove_object_w_50_relations_3_tables(void) {
     ecs_entity_t r[NUM];
     int i;
     for (i = 0; i < NUM; i ++) {
-        r[i] = ecs_new_id(world);
+        r[i] = ecs_new(world);
     }
 
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     ecs_entity_t e_1 = ecs_new_w_id(world, TagA);
     ecs_entity_t e_2 = ecs_new_w_id(world, TagB);
     ecs_entity_t e_3 = ecs_new_w_id(world, TagC);
@@ -1110,12 +1112,12 @@ void OnDelete_remove_object_w_50_relations_3_tables(void) {
 void OnDelete_remove_object_w_3_relations_interleaved(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
-    ecs_entity_t r_3 = ecs_new_id(world);
-    ecs_entity_t t_1 = ecs_new_id(world);
-    ecs_entity_t t_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
+    ecs_entity_t r_3 = ecs_new(world);
+    ecs_entity_t t_1 = ecs_new(world);
+    ecs_entity_t t_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, r_1, t_1);
     ecs_add_pair(world, e, r_2, t_1);
@@ -1158,12 +1160,12 @@ void OnDelete_remove_id_from_2_tables(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t c = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_id(world, e1, c);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_id(world, e2, c);
     ecs_add_id(world, e2, Tag);
 
@@ -1184,13 +1186,13 @@ void OnDelete_remove_relation_from_2_tables(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_pair(world, e1, r, o);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_pair(world, e1, r, o);
     ecs_add_id(world, e2, Tag);
 
@@ -1211,13 +1213,13 @@ void OnDelete_remove_object_from_2_tables(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_pair(world, e1, r, o);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_pair(world, e1, r, o);
     ecs_add_id(world, e2, Tag);
 
@@ -1236,10 +1238,10 @@ void OnDelete_remove_object_from_2_tables(void) {
 void OnDelete_remove_id_and_relation(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, r);
     ecs_add_pair(world, e, r, o);
 
@@ -1257,14 +1259,14 @@ void OnDelete_remove_id_and_relation_from_2_tables(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t o = ecs_new(world);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_pair(world, e1, r, o);
     ecs_add_id(world, e1, r);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_pair(world, e1, r, o);
     ecs_add_id(world, e2, r);
     ecs_add_id(world, e2, Tag);
@@ -1296,13 +1298,13 @@ void OnDelete_stresstest_many_objects(void) {
     /* Precreate relationships so we get different relationship ids */
     ecs_entity_t relationships[100];
     for (i = 0; i < 100; i ++) {
-        relationships[i] = ecs_new_id(world);
+        relationships[i] = ecs_new(world);
     }
 
     for (ri = 0; ri < 100; ri ++) {    
         for (i = 0; i < 100; i ++) {
-            ecs_entity_t o = ecs_new_id(world);
-            ecs_entity_t e = ecs_new_id(world);
+            ecs_entity_t o = ecs_new(world);
+            ecs_entity_t e = ecs_new(world);
             ecs_add_id(world, e, Tag);
             ecs_add_pair(world, e, relationships[ri], o);
         }
@@ -1332,13 +1334,13 @@ void OnDelete_stresstest_many_relations(void) {
     /* Precreate objects so we get different relationship ids */
     ecs_entity_t objects[100];
     for (i = 0; i < 100; i ++) {
-        objects[i] = ecs_new_id(world);
+        objects[i] = ecs_new(world);
     }
 
     for (oi = 0; oi < 100; oi ++) {    
         for (i = 0; i < 100; i ++) {
-            ecs_entity_t r = ecs_new_id(world);
-            ecs_entity_t e = ecs_new_id(world);
+            ecs_entity_t r = ecs_new(world);
+            ecs_entity_t e = ecs_new(world);
             ecs_add_id(world, e, Tag);
             ecs_add_pair(world, e, r, objects[oi]);
         }
@@ -1363,7 +1365,7 @@ void OnDelete_stresstest_many_objects_on_delete(void) {
     /* Precreate relationships so we get different relationship ids */
     ecs_entity_t relationships[100];
     for (i = 0; i < 100; i ++) {
-        relationships[i] = ecs_new_id(world);
+        relationships[i] = ecs_new(world);
         ecs_add_pair(world, relationships[i], EcsOnDelete, EcsDelete);
     }
 
@@ -1373,8 +1375,8 @@ void OnDelete_stresstest_many_objects_on_delete(void) {
 
     for (ri = 0; ri < 100; ri ++) {    
         for (i = 0; i < 100; i ++) {
-            ecs_entity_t o = ecs_new_id(world);
-            ecs_entity_t e = ecs_new_id(world);
+            ecs_entity_t o = ecs_new(world);
+            ecs_entity_t e = ecs_new(world);
             ecs_add_pair(world, e, relationships[ri], o);
             ecs_add_id(world, e, Tag);
         }
@@ -1400,7 +1402,7 @@ void OnDelete_stresstest_many_relations_on_delete(void) {
     /* Precreate objects so we get different relationship ids */
     ecs_entity_t objects[COUNT];
     for (i = 0; i < COUNT; i ++) {
-        objects[i] = ecs_new_id(world);
+        objects[i] = ecs_new(world);
     }
 
     /* Add (OnDeleteTarget, Delete) to a dummy object so that it won't mess up
@@ -1413,10 +1415,10 @@ void OnDelete_stresstest_many_relations_on_delete(void) {
 
     for (oi = 0; oi < COUNT; oi ++) {    
         for (i = 0; i < COUNT; i ++) {
-            ecs_entity_t r = ecs_new_id(world);
+            ecs_entity_t r = ecs_new(world);
             ecs_add_pair(world, r, EcsOnDeleteTarget, EcsDelete);
 
-            ecs_entity_t e = ecs_new_id(world);
+            ecs_entity_t e = ecs_new(world);
             ecs_add_pair(world, e, r, objects[oi]);
             ecs_add_id(world, e, Tag);
         }
@@ -1450,14 +1452,14 @@ void OnDelete_empty_table_w_on_remove(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_add_id(world, e1, e2);
     ecs_add_id(world, e1, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = e2,
+        .query.terms[0].id = e2,
         .events = {EcsOnRemove},
         .callback = dummy_on_remove
     });
@@ -1484,7 +1486,7 @@ typedef struct {
 static 
 void delete_on_remove(ecs_iter_t *it) {
     test_int(it->count, 1);
-    Entity *comp = ecs_field(it, Entity, 1);
+    Entity *comp = ecs_field(it, Entity, 0);
     test_assert(comp != NULL);
     test_assert(comp->other != 0);
     ecs_delete(it->world, comp->other);
@@ -1506,8 +1508,8 @@ void OnDelete_delete_table_in_on_remove_during_fini(void) {
 
     /* Setup scenario so that the order in which tables are deleted doesn't
      * matter for reproducing the issue */
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     /* Add entities to each other so that deleting one will delete the table of
      * the other. */
@@ -1519,14 +1521,14 @@ void OnDelete_delete_table_in_on_remove_during_fini(void) {
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
         .events = {EcsOnRemove},
-        .filter.terms[0].id = e1,
+        .query.terms[0].id = e1,
         .callback = delete_self_on_remove,
         .ctx = &e2
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
         .events = {EcsOnRemove},
-        .filter.terms[0].id = e2,
+        .query.terms[0].id = e2,
         .callback = delete_self_on_remove,
         .ctx = &e1
     });    
@@ -1546,8 +1548,8 @@ void OnDelete_delete_other_in_on_remove_during_fini(void) {
     /* Setup scenario so that the order in which tables are deleted doesn't
      * matter for reproducing the issue */
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     /* Removing Entity from one will delete the other */
     ecs_set(world, e1, Entity, {e2});
@@ -1558,7 +1560,7 @@ void OnDelete_delete_other_in_on_remove_during_fini(void) {
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
         .events = {EcsOnRemove},
-        .filter.terms[0].id = ecs_id(Entity),
+        .query.terms[0].id = ecs_id(Entity),
         .callback = delete_on_remove
     });
 
@@ -1571,9 +1573,9 @@ void OnDelete_delete_other_in_on_remove_during_fini(void) {
 void OnDelete_remove_id_w_role(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t c = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     
     ecs_add_id(world, e, ECS_TOGGLE | c);
     test_assert(ecs_has_id(world, e, ECS_TOGGLE | c));
@@ -1591,10 +1593,10 @@ void OnDelete_remove_id_w_role(void) {
 void OnDelete_remove_rel_w_override_pair(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
-    ecs_entity_t t = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
+    ecs_entity_t t = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_1, t));
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_2, t));
@@ -1618,10 +1620,10 @@ void OnDelete_remove_rel_w_override_pair(void) {
 void OnDelete_remove_obj_w_override_pair(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
-    ecs_entity_t t_1 = ecs_new_id(world);
-    ecs_entity_t t_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
+    ecs_entity_t t_1 = ecs_new(world);
+    ecs_entity_t t_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r, t_1));
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r, t_2));
@@ -1645,10 +1647,10 @@ void OnDelete_remove_obj_w_override_pair(void) {
 void OnDelete_remove_rel_w_override_pair_after_on_delete_target(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
-    ecs_entity_t t = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
+    ecs_entity_t t = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_1, t));
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_2, t));
@@ -1656,7 +1658,7 @@ void OnDelete_remove_rel_w_override_pair_after_on_delete_target(void) {
     test_assert(ecs_has_id(world, e, ECS_OVERRIDE | ecs_pair(r_1, t)));
     test_assert(ecs_has_id(world, e, ECS_OVERRIDE | ecs_pair(r_2, t)));
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
     ecs_add_pair(world, r_1, EcsChildOf, p);
 
     ecs_delete(world, p);
@@ -1676,11 +1678,11 @@ void OnDelete_remove_rel_w_override_pair_after_on_delete_target(void) {
 void OnDelete_remove_rel_w_override_pair_2_ids(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
-    ecs_entity_t t_1 = ecs_new_id(world);
-    ecs_entity_t t_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
+    ecs_entity_t t_1 = ecs_new(world);
+    ecs_entity_t t_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_1, t_1));
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_1, t_2));
@@ -1708,11 +1710,11 @@ void OnDelete_remove_rel_w_override_pair_2_ids(void) {
 void OnDelete_remove_obj_w_override_pair_2_ids(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
-    ecs_entity_t t_1 = ecs_new_id(world);
-    ecs_entity_t t_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
+    ecs_entity_t t_1 = ecs_new(world);
+    ecs_entity_t t_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_1, t_1));
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_2, t_1));
@@ -1740,12 +1742,12 @@ void OnDelete_remove_obj_w_override_pair_2_ids(void) {
 void OnDelete_remove_obj_w_override_pair_3_ids(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
-    ecs_entity_t r_3 = ecs_new_id(world);
-    ecs_entity_t t_1 = ecs_new_id(world);
-    ecs_entity_t t_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
+    ecs_entity_t r_3 = ecs_new(world);
+    ecs_entity_t t_1 = ecs_new(world);
+    ecs_entity_t t_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_1, t_1));
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_2, t_1));
@@ -1786,13 +1788,13 @@ void OnDelete_remove_obj_w_override_pair_3_ids(void) {
 void OnDelete_remove_mixed_w_override_pair_3_ids(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r_1 = ecs_new_id(world);
-    ecs_entity_t r_2 = ecs_new_id(world);
-    ecs_entity_t r_3 = ecs_new_id(world);
+    ecs_entity_t r_1 = ecs_new(world);
+    ecs_entity_t r_2 = ecs_new(world);
+    ecs_entity_t r_3 = ecs_new(world);
 
-    ecs_entity_t t_1 = ecs_new_id(world);
-    ecs_entity_t t_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t t_1 = ecs_new(world);
+    ecs_entity_t t_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_1, t_1));
     ecs_add_id(world, e, ECS_OVERRIDE | ecs_pair(r_2, t_1));
@@ -1844,9 +1846,9 @@ void OnDelete_merge_pair_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e_1 = ecs_new_id(world);
-    ecs_entity_t e_2 = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
+    ecs_entity_t e_1 = ecs_new(world);
+    ecs_entity_t e_2 = ecs_new(world);
+    ecs_entity_t obj = ecs_new(world);
 
     ecs_add_id(world, e_1, e_2);
     ecs_set_pair(world, e_1, Position, obj, {10, 20});
@@ -1895,9 +1897,9 @@ void OnDelete_delete_with_component(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e_1 = ecs_new(world, Position);
-    ecs_entity_t e_2 = ecs_new(world, Position);
-    ecs_entity_t e_3 = ecs_new(world, Position);
+    ecs_entity_t e_1 = ecs_new_w(world, Position);
+    ecs_entity_t e_2 = ecs_new_w(world, Position);
+    ecs_entity_t e_3 = ecs_new_w(world, Position);
 
     ecs_add(world, e_3, Velocity);
 
@@ -2073,8 +2075,8 @@ void OnDelete_remove_childof_entity(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t parent_1 = ecs_new_id(world);
-    ecs_entity_t parent_2 = ecs_new_id(world);
+    ecs_entity_t parent_1 = ecs_new(world);
+    ecs_entity_t parent_2 = ecs_new(world);
 
     ecs_entity_t e_1 = ecs_new_w_pair(world, EcsChildOf, parent_1);
     ecs_entity_t e_2 = ecs_new_w_pair(world, EcsChildOf, parent_1);
@@ -2121,13 +2123,13 @@ void OnDelete_remove_childof_wildcard(void) {
 
     /* Create custom childof relationship so we won't try to remove ChildOf from
      * builtin entities */
-    ecs_entity_t child_of = ecs_new_id(world);
+    ecs_entity_t child_of = ecs_new(world);
 
     /* Simulate same behavior as ChildOf */
     ecs_add_pair(world, child_of, EcsOnDeleteTarget, EcsDelete);
 
-    ecs_entity_t parent_1 = ecs_new_id(world);
-    ecs_entity_t parent_2 = ecs_new_id(world);
+    ecs_entity_t parent_1 = ecs_new(world);
+    ecs_entity_t parent_2 = ecs_new(world);
 
     ecs_entity_t e_1 = ecs_new_w_pair(world, child_of, parent_1);
     ecs_entity_t e_2 = ecs_new_w_pair(world, child_of, parent_1);
@@ -2171,7 +2173,7 @@ void OnDelete_delete_child_of_delete_with(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_entity_t obj = ecs_new_id(world);
+    ecs_entity_t obj = ecs_new(world);
 
     ecs_entity_t e_1 = ecs_new_w_pair(world, Rel, obj);
     ecs_entity_t e_2 = ecs_new_w_pair(world, Rel, obj);
@@ -2216,8 +2218,8 @@ void OnDelete_delete_with_component_after_delete_cyclic_self(void) {
     ECS_TAG(world, Rel);
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     ecs_add_pair(world, e2, Rel, e2);
 
     test_assert(ecs_is_alive(world, e1));
@@ -2237,9 +2239,9 @@ void OnDelete_delete_with_component_after_delete_cyclic(void) {
     ECS_TAG(world, Rel);
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
     ecs_add_pair(world, e2, Rel, e3);
     ecs_add_pair(world, e3, Rel, e2);
 
@@ -2263,18 +2265,18 @@ void OnDelete_delete_with_component_after_delete_cyclic_w_alive_moved(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
 
-    ecs_entity_t e4 = ecs_new_id(world);
+    ecs_entity_t e4 = ecs_new(world);
     ecs_add_pair(world, e4, Rel, e2);
     ecs_add(world, e4, Velocity);
 
     ecs_add_pair(world, e2, Rel, e3);
     ecs_add_pair(world, e3, Rel, e2);
 
-    ecs_entity_t e5 = ecs_new_id(world);
+    ecs_entity_t e5 = ecs_new(world);
     ecs_add_pair(world, e5, Rel, e2);
     ecs_add_pair(world, e5, Rel, e3);
     ecs_add(world, e5, Velocity);
@@ -2305,12 +2307,12 @@ void OnDelete_deep_clean_64(void) {
     ecs_entity_t r = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
     test_assert(r != 0);
 
-    ecs_entity_t first = ecs_new_id(world);
+    ecs_entity_t first = ecs_new(world);
     ecs_entity_t prev = first;
     ecs_entity_t entities[64];
 
     for (int i = 0; i < 64; i ++) {
-        entities[i] = ecs_new_id(world);
+        entities[i] = ecs_new(world);
         ecs_add_pair(world, entities[i], r, prev);
         prev = entities[i];
     }
@@ -2336,12 +2338,12 @@ void OnDelete_deep_clean_256(void) {
     ecs_entity_t r = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
     test_assert(r != 0);
 
-    ecs_entity_t first = ecs_new_id(world);
+    ecs_entity_t first = ecs_new(world);
     ecs_entity_t prev = first;
     ecs_entity_t entities[256];
 
     for (int i = 0; i < 256; i ++) {
-        entities[i] = ecs_new_id(world);
+        entities[i] = ecs_new(world);
         ecs_add_pair(world, entities[i], r, prev);
         prev = entities[i];
     }
@@ -2361,118 +2363,51 @@ void OnDelete_deep_clean_256(void) {
     ecs_fini(world);
 }
 
-void OnDelete_id_w_switch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Sw, Union);
-    ECS_TAG(world, C1);
-    ECS_TAG(world, C2);
-    ECS_TAG(world, C3);
-    ECS_TAG(world, C4);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Sw, C1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Sw, C2);
-    ecs_entity_t e3 = ecs_new_w_pair(world, Sw, C3);
-    ecs_entity_t e4 = ecs_new_w_pair(world, Sw, C4);
-
-    ecs_entity_t t = ecs_new_id(world);
-
-    ecs_add_id(world, e3, t);
-    ecs_add_id(world, e4, t);
-
-    test_assert( ecs_has_pair(world, e1, Sw, C1));
-    test_assert( ecs_has_pair(world, e2, Sw, C2));
-    test_assert( ecs_has_pair(world, e3, Sw, C3));
-    test_assert( ecs_has_pair(world, e4, Sw, C4));
-    
-    ecs_delete(world, t);
-
-    test_assert( ecs_has_pair(world, e1, Sw, C1));
-    test_assert( ecs_has_pair(world, e2, Sw, C2));
-    test_assert( ecs_has_pair(world, e3, Sw, C3));
-    test_assert( ecs_has_pair(world, e4, Sw, C4));
-
-    ecs_fini(world);
-}
-
 void OnDelete_id_w_disabled(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_TAG(world, Tag);
+    ECS_ENTITY(world, Tag, CanToggle);
+
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
 
     ecs_add_id(world, e1, ECS_TOGGLE | Tag);
     ecs_add_id(world, e2, ECS_TOGGLE | Tag);
     ecs_add_id(world, e3, ECS_TOGGLE | Tag);
     ecs_add_id(world, e4, ECS_TOGGLE | Tag);
 
-    test_bool(false, ecs_is_enabled_component(world, e1, Tag));
-    test_bool(false, ecs_is_enabled_component(world, e2, Tag));
-    test_bool(false, ecs_is_enabled_component(world, e3, Tag));
-    test_bool(false, ecs_is_enabled_component(world, e4, Tag));
+    test_bool(false, ecs_is_enabled(world, e1, Tag));
+    test_bool(false, ecs_is_enabled(world, e2, Tag));
+    test_bool(false, ecs_is_enabled(world, e3, Tag));
+    test_bool(false, ecs_is_enabled(world, e4, Tag));
 
     ecs_enable_component(world, e1, Tag, true);
     ecs_enable_component(world, e3, Tag, true);
 
-    test_bool(true, ecs_is_enabled_component(world, e1, Tag));
-    test_bool(false, ecs_is_enabled_component(world, e2, Tag));
-    test_bool(true, ecs_is_enabled_component(world, e3, Tag));
-    test_bool(false, ecs_is_enabled_component(world, e4, Tag));
+    test_bool(true, ecs_is_enabled(world, e1, Tag));
+    test_bool(false, ecs_is_enabled(world, e2, Tag));
+    test_bool(true, ecs_is_enabled(world, e3, Tag));
+    test_bool(false, ecs_is_enabled(world, e4, Tag));
 
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t t = ecs_new(world);
 
     ecs_add_id(world, e3, t);
     ecs_add_id(world, e4, t);
 
-    test_bool(true, ecs_is_enabled_component(world, e1, Tag));
-    test_bool(false, ecs_is_enabled_component(world, e2, Tag));
-    test_bool(true, ecs_is_enabled_component(world, e3, Tag));
-    test_bool(false, ecs_is_enabled_component(world, e4, Tag));
+    test_bool(true, ecs_is_enabled(world, e1, Tag));
+    test_bool(false, ecs_is_enabled(world, e2, Tag));
+    test_bool(true, ecs_is_enabled(world, e3, Tag));
+    test_bool(false, ecs_is_enabled(world, e4, Tag));
     
     ecs_delete(world, t);
 
-    test_bool(true, ecs_is_enabled_component(world, e1, Tag));
-    test_bool(false, ecs_is_enabled_component(world, e2, Tag));
-    test_bool(true, ecs_is_enabled_component(world, e3, Tag));
-    test_bool(false, ecs_is_enabled_component(world, e4, Tag));
-
-    ecs_fini(world);
-}
-
-void OnDelete_id_to_no_switch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Sw, Union);
-    ECS_TAG(world, C1);
-    ECS_TAG(world, C2);
-    ECS_TAG(world, C3);
-    ECS_TAG(world, C4);
-    ECS_TAG(world, Tag);
-
-    ecs_entity_t e1 = ecs_new_w_pair(world, Sw, C1);
-    ecs_entity_t e2 = ecs_new_w_pair(world, Sw, C2);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-
-    ecs_add(world, e1, Tag);
-    ecs_add(world, e2, Tag);
-
-    test_assert( ecs_has_pair(world, e1, Sw, C1));
-    test_assert( ecs_has_pair(world, e2, Sw, C2));
-
-    ecs_delete(world, Sw);
-
-    test_assert( !ecs_has_pair(world, e1, Sw, C1));
-    test_assert( !ecs_has_pair(world, e2, Sw, C2));
-
-    test_assert( ecs_has_id(world, e1, Tag));
-    test_assert( ecs_has_id(world, e2, Tag));
-    test_assert( ecs_has_id(world, e3, Tag));
-    test_assert( ecs_has_id(world, e4, Tag));
+    test_bool(true, ecs_is_enabled(world, e1, Tag));
+    test_bool(false, ecs_is_enabled(world, e2, Tag));
+    test_bool(true, ecs_is_enabled(world, e3, Tag));
+    test_bool(false, ecs_is_enabled(world, e4, Tag));
 
     ecs_fini(world);
 }
@@ -2483,10 +2418,10 @@ void OnDelete_id_to_no_disabled(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
-    ecs_entity_t e4 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_entity_t e4 = ecs_new_w(world, TagA);
 
     ecs_add(world, e1, TagB);
     ecs_add(world, e2, TagB);
@@ -2494,8 +2429,8 @@ void OnDelete_id_to_no_disabled(void) {
     ecs_add_id(world, e1, ECS_TOGGLE | TagB);
     ecs_add_id(world, e2, ECS_TOGGLE | TagB);
 
-    test_bool(false, ecs_is_enabled_component(world, e1, TagB));
-    test_bool(false, ecs_is_enabled_component(world, e2, TagB));
+    test_bool(false, ecs_is_enabled(world, e1, TagB));
+    test_bool(false, ecs_is_enabled(world, e2, TagB));
 
     ecs_delete(world, TagB);
 
@@ -2517,13 +2452,9 @@ void OnDelete_remove_on_delete_action(void) {
 
     ECS_COMPONENT(world, Position);
 
-    test_assert( ecs_has_pair(world, ecs_id(Position), EcsOnDelete, EcsPanic));
-
-    ecs_remove_pair(world, ecs_id(Position), EcsOnDelete, EcsWildcard);
-
     test_assert( !ecs_has_pair(world, ecs_id(Position), EcsOnDelete, EcsPanic));
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert( ecs_has(world, e, Position));
 
     ecs_delete(world, ecs_id(Position));
@@ -2539,8 +2470,8 @@ void OnDelete_delete_with_w_relation(void) {
     ECS_TAG(world, Tag);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
     ecs_add_pair(world, e2, Rel, e1);
 
     ecs_delete_with(world, Tag);
@@ -2555,7 +2486,7 @@ static int delete_target_invoked = 0;
 
 static
 void DeleteTarget(ecs_iter_t *it) {
-    ecs_id_t pair = ecs_field_id(it, 1);
+    ecs_id_t pair = ecs_field_id(it, 0);
     test_assert(ecs_id_is_pair(pair));
     ecs_delete(it->world, ECS_PAIR_SECOND(pair));
     delete_target_invoked ++;
@@ -2567,12 +2498,12 @@ void OnDelete_delete_self_in_on_remove(void) {
     ecs_entity_t Rel = ecs_new_w_pair(world, EcsOnDeleteTarget, EcsDelete);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard),
         .events = { EcsOnRemove },
         .callback = DeleteTarget
     });
 
-    ecs_entity_t a = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
     ecs_entity_t b = ecs_new_w_pair(world, Rel, a);
 
     test_int(0, delete_target_invoked);
@@ -2607,15 +2538,15 @@ void OnDelete_delete_nested_in_on_remove(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard),
         .events = { EcsOnRemove },
         .callback = DeleteOther,
         .ctx = &Tag
     });
 
-    ecs_entity_t a = ecs_new_id(world);
+    ecs_entity_t a = ecs_new(world);
     ecs_entity_t b = ecs_new_w_pair(world, Rel, a);
-    ecs_entity_t c = ecs_new(world, Tag);
+    ecs_entity_t c = ecs_new_w(world, Tag);
 
     test_int(0, delete_target_invoked);
 
@@ -2636,7 +2567,7 @@ void OnDelete_delete_nested_in_on_remove(void) {
 
 static
 void AddRemoved(ecs_iter_t *it) {
-    ecs_id_t id = ecs_field_id(it, 1);
+    ecs_id_t id = ecs_field_id(it, 0);
     for (int i = 0; i < it->count; i ++) {
         ecs_new_w_id(it->world, id); /* create entity with removed id */
     }
@@ -2647,11 +2578,11 @@ void OnDelete_add_deleted_in_on_remove(void) {
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t t = ecs_new(world);
     ecs_new_w_id(world, t);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = t,
+        .query.terms[0].id = t,
         .events = { EcsOnRemove },
         .callback = AddRemoved
     });
@@ -2664,18 +2595,20 @@ void OnDelete_delete_tree_w_query(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
-    ECS_ENTITY(world, Rel, EcsTraversable);
+    ECS_ENTITY(world, Rel, Traversable);
     ECS_TAG(world, Foo);
 
-    ecs_query_t *q = ecs_query_new(world, "Tag(up(Rel))");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag(up Rel)" });
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
 
     ecs_add_pair(world, e2, Rel, e1);
     ecs_add_id(world, e1, Foo);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 
     // Make sure query can handle matching with tables while entities are 
@@ -2707,7 +2640,7 @@ void OnDelete_fini_cleanup_order(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
         ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, e1);
             ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, e2);
                 ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, e3);
@@ -2717,7 +2650,7 @@ void OnDelete_fini_cleanup_order(void) {
     ecs_add(world, e2, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnRemove},
         .callback = TestAlive
     });
@@ -2730,11 +2663,11 @@ void OnDelete_fini_cleanup_order(void) {
 void OnDelete_fini_cleanup_order_root_id_w_trait(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     ecs_add_id(world, r, EcsExclusive);
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t t = ecs_new(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, r, t);
 
     ecs_fini(world);
@@ -2762,7 +2695,7 @@ void OnDelete_fini_cleanup_order_entity_after_singleton(void) {
 
     ecs_singleton_set(world, Position, {10, 20});
     
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Velocity);
 
     ecs_fini(world);
@@ -2780,7 +2713,7 @@ void OnDelete_fini_cleanup_order_entity_after_component(void) {
         .on_remove = ecs_on_remove(Velocity)
     });
     
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Velocity);
 
     ecs_fini(world);
@@ -2793,7 +2726,7 @@ void OnDelete_on_delete_parent_w_in_use_id_w_remove(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t p = ecs_new(world, Tag);
+    ecs_entity_t p = ecs_new_w(world, Tag);
     ecs_entity_t r = ecs_new_w_pair(world, EcsChildOf, p);
     ecs_entity_t o = ecs_new_w_pair(world, EcsChildOf, p);
 
@@ -2817,7 +2750,7 @@ void OnDelete_on_delete_parent_w_in_use_id_w_delete(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t p = ecs_new(world, Tag);
+    ecs_entity_t p = ecs_new_w(world, Tag);
     ecs_entity_t r = ecs_new_w_pair(world, EcsChildOf, p);
     ecs_entity_t o = ecs_new_w_pair(world, EcsChildOf, p);
 
@@ -2843,7 +2776,7 @@ void OnDelete_create_after_delete_with(void) {
     const ecs_type_info_t *ti = ecs_get_type_info(world, ecs_id(Position));
     test_assert(ti != NULL);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(ecs_is_alive(world, e));
     test_assert(ecs_has(world, e, Position));
 
@@ -2854,9 +2787,9 @@ void OnDelete_create_after_delete_with(void) {
     ti = ecs_get_type_info(world, ecs_id(Position));
     test_assert(ti != NULL);
 
-    ecs_entity_t id = ecs_new_id(world);
+    ecs_entity_t id = ecs_new(world);
     test_assert(ecs_get_table(world, id) == NULL);
-    e = ecs_set(world, 0, Position, {10, 20});
+    e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(ecs_is_alive(world, e));
     test_assert(ecs_has(world, e, Position));
 
@@ -2868,7 +2801,7 @@ void OnDelete_delete_with_inherited_tag(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
 
     test_assert(ecs_is_alive(world, base));
@@ -2888,11 +2821,11 @@ void OnDelete_delete_with_inherited_tag_w_query(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
     
-    ecs_query_t *query = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ Tag }}
+    ecs_query_t *query = ecs_query(world, {
+        .terms = {{ Tag }}
     });
     test_assert(query != NULL);
 
@@ -2918,6 +2851,8 @@ void OnDelete_delete_with_inherited_tag_w_query(void) {
     it = ecs_query_iter(world, query);
     test_bool(false, ecs_query_next(&it));
 
+    ecs_query_fini(query);
+
     ecs_fini(world);
 }
 
@@ -2930,12 +2865,12 @@ void OnDelete_delete_with_inherited_tag_w_observer(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
     
     Probe ctx;
     ecs_entity_t o = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ Tag }},
+        .query.terms = {{ Tag }},
         .events = { EcsOnRemove },
         .callback = Observer,
         .ctx = &ctx
@@ -2962,7 +2897,7 @@ void OnDelete_delete_with_inherited_tag_w_observer(void) {
 void OnDelete_delete_symmetric_relation(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, EcsSymmetric);
     ecs_delete(world, e);
     test_assert(!ecs_is_alive(world, e));
@@ -2975,8 +2910,8 @@ void OnDelete_delete_symmetric_relation(void) {
 void OnDelete_delete_observed_symmetric_relation(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_id(world, e, EcsTag);
+    ecs_entity_t e = ecs_new(world);
+    ecs_add_id(world, e, EcsPairIsTag);
 
     ecs_add_id(world, e, EcsSymmetric);
     ecs_delete(world, e);
@@ -3001,7 +2936,7 @@ void OnDelete_nested_delete_with(void) {
         .on_remove = on_remove_delete_with
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, e);
     ecs_delete_with(world, ecs_id(Position));
 
@@ -3017,12 +2952,12 @@ void OnDelete_deferred_delete_with_after_create_named(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Tag);
 
     ecs_defer_begin(world);
     ecs_delete_with(world, Tag);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add(world, e2, Tag);
     ecs_defer_end(world);
 
@@ -3039,15 +2974,15 @@ void OnDelete_deferred_delete_with_childof_after_create_named(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     ecs_add(world, parent, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "parent.e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "parent.e1" });
     ecs_add(world, e1, Tag);
 
     ecs_defer_begin(world);
     ecs_delete_with(world, ecs_childof(parent));
-    ecs_entity_t e2 = ecs_new_entity(world, "parent.e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "parent.e2" });
     ecs_add(world, e2, Tag);
     ecs_defer_end(world);
 
@@ -3062,18 +2997,18 @@ void OnDelete_deferred_delete_with_childof_after_create_named(void) {
 void OnDelete_match_marked_for_deletion(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t ns = ecs_new_entity(world, "ns");
+    ecs_entity_t ns = ecs_entity(world, { .name = "ns" });
     ecs_set_scope(world, ns);
     ECS_COMPONENT(world, Position);
-    ecs_entity_t Foo = ecs_component(world, { .entity = ecs_new(world, 0) });
-    ecs_entity_t Bar = ecs_component(world, { .entity = ecs_new(world, 0) });
+    ecs_entity_t Foo = ecs_component(world, { .entity = ecs_new(world) });
+    ecs_entity_t Bar = ecs_component(world, { .entity = ecs_new(world) });
     ecs_set_scope(world, 0);
 
     /* During cleanup a new table will be created that matches the query */
-    ecs_query_t *q = ecs_query_new(world, "ns.Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "ns.Position" });
     test_assert(q != NULL);
 
-    ecs_entity_t prefab = ecs_new_id(world);
+    ecs_entity_t prefab = ecs_new(world);
     ecs_add_id(world, prefab, EcsPrefab);
     ecs_add(world, prefab, Position);
     ecs_override_id(world, prefab, Foo);
@@ -3081,6 +3016,8 @@ void OnDelete_match_marked_for_deletion(void) {
     ecs_entity_t newEnemy = ecs_new_w_pair(world, EcsIsA, prefab);
     ecs_add_id(world, newEnemy, Bar);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 
     test_assert(true); /* Ensure cleanup was successful */
@@ -3090,8 +3027,8 @@ void OnDelete_delete_w_low_rel_mixed_cleanup(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_entity_t rel = ecs_new_low_id(world);
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t child = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t child = ecs_new(world);
     ecs_add_pair(world, child, EcsChildOf, parent);
     ecs_add_pair(world, child, rel, parent);
 
@@ -3107,9 +3044,9 @@ void OnDelete_delete_w_low_rel_mixed_cleanup_interleaved_ids(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_entity_t rel = ecs_new_low_id(world);
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t other = ecs_new_id(world);
-    ecs_entity_t child = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t other = ecs_new(world);
+    ecs_entity_t child = ecs_new(world);
     ecs_add_pair(world, child, EcsChildOf, parent);
     ecs_add_pair(world, child, rel, other);
     ecs_add_pair(world, child, rel, parent);
@@ -3127,19 +3064,21 @@ void OnDelete_fini_query_w_singleton_in_scope_no_module(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t t = ecs_new_entity(world, "ns.foo");
-    ecs_entity_t s = ecs_new_entity(world, "ns.singleton");
+    ecs_entity_t t = ecs_entity(world, { .name = "ns.foo" });
+    ecs_entity_t s = ecs_entity(world, { .name = "ns.singleton" });
     ecs_add_id(world, s, s);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, ns.singleton($)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, ns.singleton($)" });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, t);
     ecs_add(world, e, Position);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_iter_is_true(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -3148,31 +3087,33 @@ void OnDelete_fini_query_w_singleton_in_module(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t n = ecs_new_entity(world, "ns");
+    ecs_entity_t n = ecs_entity(world, { .name = "ns" });
     ecs_add_id(world, n, EcsModule);
 
-    ecs_entity_t t = ecs_new_entity(world, "ns.foo");
-    ecs_entity_t s = ecs_new_entity(world, "ns.singleton");
+    ecs_entity_t t = ecs_entity(world, { .name = "ns.foo" });
+    ecs_entity_t s = ecs_entity(world, { .name = "ns.singleton" });
     ecs_add_id(world, s, s);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, ns.singleton($)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, ns.singleton($)" });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, t);
     ecs_add(world, e, Position);
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_iter_is_true(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
 void OnDelete_fini_observer_w_relationship_in_scope(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t Tag = ecs_new_id(world);
+    ecs_entity_t Tag = ecs_new(world);
 
-    ecs_entity_t ns = ecs_new_entity(world, "ns");
+    ecs_entity_t ns = ecs_entity(world, { .name = "ns" });
     ecs_entity_t Rel = ecs_component(world, {
         .entity = ecs_entity(world, { .name = "Rel" }),
     });
@@ -3180,7 +3121,7 @@ void OnDelete_fini_observer_w_relationship_in_scope(void) {
     ecs_add_pair(world, Rel, EcsChildOf, ns);
 
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { ecs_pair(Rel, EcsWildcard) },
             { Tag }
         },
diff --git a/test/api/src/Pairs.c b/test/core/src/Pairs.c
similarity index 84%
rename from test/api/src/Pairs.c
rename to test/core/src/Pairs.c
index 2008a1d75..8cd5df035 100644
--- a/test/api/src/Pairs.c
+++ b/test/core/src/Pairs.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 typedef struct Rel {
     float value;
@@ -17,7 +17,7 @@ typedef struct Obj {
 } Obj;
 
 void ProcessPairs(ecs_iter_t *it) {
-    Rel *tr = ecs_field(it, Rel, 1);
+    Rel *tr = ecs_field(it, Rel, 0);
 
     probe_iter(it);
 
@@ -39,16 +39,16 @@ void Pairs_type_w_one_pair(void) {
     ECS_SYSTEM(world, ProcessPairs, EcsOnUpdate, (Rel, *));
 
     /* Ensure that pair is matched against different components */
-    ecs_entity_t e1 = ecs_set_pair(world, 0, Rel, ecs_id(Position), {
+    ecs_entity_t e1 = ecs_insert(world, ecs_value_pair(Rel, ecs_id(Position), {
         .value = 10
-    });
+    }));
 
     test_assert(e1 != 0);
     test_assert( ecs_has_pair(world, e1, ecs_id(Rel), ecs_id(Position)));
 
-    ecs_entity_t e2 = ecs_set_pair(world, 0, Rel, ecs_id(Velocity), {
+    ecs_entity_t e2 = ecs_insert(world, ecs_value_pair(Rel, ecs_id(Velocity), {
         .value = 20
-    });
+    }));
     test_assert(e2 != 0);
     test_assert( ecs_has_pair(world, e2, ecs_id(Rel), ecs_id(Velocity)));
 
@@ -102,7 +102,7 @@ void Pairs_type_w_two_pairs(void) {
     ECS_SYSTEM(world, ProcessPairs, EcsOnUpdate, (Rel, *));
 
     /* Ensure that pair is matched against different components on same entity */
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set_pair(world, e1, Rel, ecs_id(Position), {
         .value = 10
     });  
@@ -113,7 +113,7 @@ void Pairs_type_w_two_pairs(void) {
     });      
     test_assert( ecs_has_pair(world, e1, ecs_id(Rel), ecs_id(Velocity)));
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set_pair(world, e2, Rel, ecs_id(Position), {
         .value = 30
     });
@@ -183,7 +183,7 @@ void Pairs_add_pair(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Rel);
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
     ecs_add_pair(world, e1, ecs_id(Rel), ecs_id(Position));
@@ -199,9 +199,9 @@ void Pairs_remove_pair(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Rel);
 
-    ecs_entity_t e1 = ecs_set_pair(world, 0, Rel, ecs_id(Position), {
+    ecs_entity_t e1 = ecs_insert(world, ecs_value_pair(Rel, ecs_id(Position), {
         .value = 10
-    });  
+    }));
     test_assert(e1 != 0);
     test_assert( ecs_has_pair(world, e1, ecs_id(Rel), ecs_id(Position)));
 
@@ -225,12 +225,12 @@ void Pairs_add_tag_pair_for_tag(void) {
     ECS_SYSTEM(world, ProcessPairTags, EcsOnUpdate, (Rel, *));
 
     /* Ensure that pair is matched against different components */
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_pair(world, e1, Rel, Tag1);
     test_assert(e1 != 0);
     test_assert( ecs_has_pair(world, e1, Rel, Tag1));
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_pair(world, e2, Rel, Tag2);
     test_assert(e2 != 0);
     test_assert( ecs_has_pair(world, e2, Rel, Tag2));
@@ -271,7 +271,7 @@ void Pairs_add_tag_pair_for_tag(void) {
 void ProcessValuePairs(ecs_iter_t *it) {
     /* Strictly speaking this can be either Position or Velocity, but they have
      * the same layout. */
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     probe_iter(it);
 
@@ -293,16 +293,16 @@ void Pairs_add_tag_pair_for_component(void) {
 
     ECS_SYSTEM(world, ProcessValuePairs, EcsOnUpdate, (Rel, *));
 
-    ecs_entity_t e1 = ecs_set_pair_object(world, 0, Rel, Position, {
+    ecs_entity_t e1 = ecs_insert(world, ecs_value_pair_2nd(Rel, Position, {
         .x = 1,
         .y = 2
-    });
+    }));
     test_assert( ecs_has_pair(world, e1, Rel, ecs_id(Position)));
 
-    ecs_entity_t e2 = ecs_set_pair_object(world, 0, Rel, Velocity, {
+    ecs_entity_t e2 = ecs_insert(world, ecs_value_pair_2nd(Rel, Velocity, {
         .x = 3,
         .y = 4
-    });
+    }));
     test_assert( ecs_has_pair(world, e2, Rel, ecs_id(Velocity)));
 
     Probe ctx = {0};
@@ -338,8 +338,8 @@ void Pairs_add_tag_pair_for_component(void) {
 }
 
 void ProcessTwoPairs(ecs_iter_t *it) {
-    RelA *tr_a = ecs_field(it, RelA, 1);
-    RelB *tr_b = ecs_field(it, RelB, 2);
+    RelA *tr_a = ecs_field(it, RelA, 0);
+    RelB *tr_b = ecs_field(it, RelB, 1);
 
     probe_iter(it);
 
@@ -360,9 +360,9 @@ void Pairs_query_2_pairs(void) {
     ECS_SYSTEM(world, ProcessTwoPairs, EcsOnUpdate, (RelA, *), (RelB, *));
 
     /* Create entity with both RelA and RelB */
-    ecs_entity_t e1 = ecs_set_pair(world, 0, RelA, ecs_id(Position), {
+    ecs_entity_t e1 = ecs_insert(world, ecs_value_pair(RelA, ecs_id(Position), {
         .value = 1
-    });
+    }));
 
     ecs_set_pair(world, e1, RelB, ecs_id(Position), {
         .value = 2
@@ -372,9 +372,9 @@ void Pairs_query_2_pairs(void) {
     test_assert( ecs_has_pair(world, e1, ecs_id(RelB), ecs_id(Position)));
 
     /* Create entity with only RelA. Should not be matched with system */
-    ecs_entity_t e2 = ecs_set_pair(world, 0, RelA, ecs_id(Position), {
+    ecs_entity_t e2 = ecs_insert(world, ecs_value_pair(RelA, ecs_id(Position), {
         .value = 3
-    });
+    }));
     test_assert( ecs_has_pair(world, e2, ecs_id(RelA), ecs_id(Position)));
 
     /* Run system */
@@ -425,9 +425,9 @@ void Pairs_query_2_pairs_2_instances_per_type(void) {
     ECS_SYSTEM(world, ProcessTwoPairs, EcsOnUpdate, (RelA, *), (RelB, *));
 
     /* Create entity with both RelA and RelB, applied to two components*/
-    ecs_entity_t e1 = ecs_set_pair(world, 0, RelA, ecs_id(Position), {
+    ecs_entity_t e1 = ecs_insert(world, ecs_value_pair(RelA, ecs_id(Position), {
         .value = 1
-    });
+    }));
 
     ecs_set_pair(world, e1, RelB, ecs_id(Position), {
         .value = 2
@@ -483,7 +483,7 @@ void Pairs_override_pair(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Rel);
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     ecs_set_pair(world, base, Rel, ecs_id(Position), {.value = 10});
 
     ecs_entity_t instance = ecs_new_w_pair(world, EcsIsA, base);
@@ -512,23 +512,23 @@ void Pairs_override_tag_pair(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t base = ecs_new(world, 0);
-    ecs_set_pair_object(world, base, Rel, Position, {.x = 10, .y = 20});
+    ecs_entity_t base = ecs_new(world);
+    ecs_set_pair_second(world, base, Rel, Position, {.x = 10, .y = 20});
 
     ecs_entity_t instance = ecs_new_w_pair(world, EcsIsA, base);
     test_assert(ecs_has_pair(world, instance, Rel, ecs_id(Position)));
 
-    const Position *t = ecs_get_pair_object(world, instance, Rel, Position);
+    const Position *t = ecs_get_pair_second(world, instance, Rel, Position);
     test_assert(t != NULL);
     test_int(t->x, 10);
     test_int(t->y, 20);
 
-    const Position *t_2 = ecs_get_pair_object(world, base, Rel, Position);
+    const Position *t_2 = ecs_get_pair_second(world, base, Rel, Position);
     test_assert(t_2 != NULL);
     test_assert(t == t_2);
 
     ecs_add_pair(world, instance, Rel, ecs_id(Position));
-    t = ecs_get_pair_object(world, instance, Rel, Position);
+    t = ecs_get_pair_second(world, instance, Rel, Position);
     test_assert(t != NULL);
     test_int(t->x, 10);
     test_int(t->y, 20);
@@ -554,7 +554,7 @@ void Pairs_on_add_pair(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Position));
 
     test_int(ctx.count, 1);
@@ -600,7 +600,7 @@ void Pairs_on_add_pair_tag(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, Rel, ecs_id(Position));
 
     test_int(ctx.count, 1);
@@ -631,7 +631,7 @@ void Pairs_on_remove_pair(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Position));
     ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Velocity));
     test_int(ctx.count, 0);
@@ -679,7 +679,7 @@ void Pairs_on_remove_pair_tag(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, Rel, ecs_id(Position));
     test_int(ctx.count, 0);
 
@@ -712,7 +712,7 @@ void Pairs_on_remove_pair_on_delete(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Position));
     ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Velocity));
     test_int(ctx.count, 0);
@@ -765,7 +765,7 @@ void Pairs_on_remove_pair_tag_on_delete(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, Rel, ecs_id(Position));
     ecs_add_pair(world, e, Rel, ecs_id(Velocity));
     test_int(ctx.count, 0);
@@ -801,15 +801,15 @@ void Pairs_pair_w_component_query(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Rel);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, ecs_id(Rel), ecs_id(Position));
 
-    ecs_query_t *q = ecs_query_new(world, "(Rel, Position)");
+    ecs_query_t *q = ecs_query(world, { .expr = "(Rel, Position)" });
     
     int32_t count = 0;
     ecs_iter_t it = ecs_query_iter(world, q);
     while (ecs_query_next(&it)) {
-        Rel *t = ecs_field(&it, Rel, 1);
+        Rel *t = ecs_field(&it, Rel, 0);
         test_assert(t != NULL);
 
         int i;
@@ -821,6 +821,8 @@ void Pairs_pair_w_component_query(void) {
 
     test_assert(count == 1);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -830,11 +832,11 @@ void Pairs_query_pair_or_component(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_pair(world, e1, Rel, ecs_id(Position));
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
 
-    ecs_query_t *q = ecs_query_new(world, "(Rel, Position) || Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "(Rel, Position) || Position" });
     
     int32_t count = 0;
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -848,6 +850,8 @@ void Pairs_query_pair_or_component(void) {
 
     test_assert(count == 2);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -858,12 +862,12 @@ void Pairs_query_pair_or_pair(void) {
     ECS_TAG(world, RelA);
     ECS_TAG(world, RelB);
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_pair(world, e1, RelA, ecs_id(Position));
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     ecs_add_pair(world, e2, RelB, ecs_id(Position));
 
-    ecs_query_t *q = ecs_query_new(world, "(RelA, Position) || (RelB, Position)");
+    ecs_query_t *q = ecs_query(world, { .expr = "(RelA, Position) || (RelB, Position)" });
     
     int32_t count = 0;
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -877,6 +881,8 @@ void Pairs_query_pair_or_pair(void) {
 
     test_int(count, 2);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -886,18 +892,18 @@ void Pairs_query_not_pair(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     ecs_add_pair(world, e2, Rel, ecs_id(Position));
 
-    ecs_query_t *q = ecs_query_new(world, "!(Rel, Position), Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "!(Rel, Position), Position" });
     
     int32_t count = 0;
     ecs_iter_t it = ecs_query_iter(world, q);
     while (ecs_query_next(&it)) {
-        Position *t = ecs_field(&it, Position, 1);
+        Position *t = ecs_field(&it, Position, 0);
         test_assert(t == NULL);
-        Position *p = ecs_field(&it, Position, 2);
+        Position *p = ecs_field(&it, Position, 1);
         test_assert(p != NULL);
 
         int i;
@@ -909,20 +915,22 @@ void Pairs_query_not_pair(void) {
 
     test_assert(count == 1);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
 void Pairs_get_typeid_w_recycled_rel(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert(o != 0);
 
-    ecs_entity_t dummy = ecs_new_id(world);
+    ecs_entity_t dummy = ecs_new(world);
     ecs_delete(world, dummy); // force recycle
 
     // don't use ECS_COMPONENT, because it will try to get low ids first
-    ecs_entity_t pos = ecs_set(world, 0, EcsComponent, {1, 1});
+    ecs_entity_t pos = ecs_insert(world, ecs_value(EcsComponent, {1, 1}));
     test_assert(pos != 0);
     test_assert((uint32_t)pos != pos); // ensure recycled
 
@@ -937,14 +945,14 @@ void Pairs_get_typeid_w_recycled_rel(void) {
 void Pairs_get_typeid_w_recycled_obj(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_new_id(world);
+    ecs_entity_t r = ecs_new(world);
     test_assert(r != 0);
 
-    ecs_entity_t dummy = ecs_new_id(world);
+    ecs_entity_t dummy = ecs_new(world);
     ecs_delete(world, dummy); // force recycle
 
     // don't use ECS_COMPONENT, because it will try to get low ids first
-    ecs_entity_t pos = ecs_set(world, 0, EcsComponent, {1, 1});
+    ecs_entity_t pos = ecs_insert(world, ecs_value(EcsComponent, {1, 1}));
     test_assert(pos != 0);
     test_assert((uint32_t)pos != pos); // ensure recycled
 
@@ -962,7 +970,7 @@ void Pairs_id_str_w_recycled_rel(void) {
     ecs_entity_t o = ecs_set_name(world, 0, "o");
     test_assert(o != 0);
 
-    ecs_entity_t dummy = ecs_new_id(world);
+    ecs_entity_t dummy = ecs_new(world);
     ecs_delete(world, dummy); // force recycle
 
     ecs_entity_t r = ecs_set_name(world, 0, "r");
@@ -982,7 +990,7 @@ void Pairs_id_str_w_recycled_obj(void) {
     ecs_entity_t r = ecs_set_name(world, 0, "r");
     test_assert(r != 0);
 
-    ecs_entity_t dummy = ecs_new_id(world);
+    ecs_entity_t dummy = ecs_new(world);
     ecs_delete(world, dummy); // force recycle
 
     ecs_entity_t o = ecs_set_name(world, 0, "o");
@@ -999,13 +1007,13 @@ void Pairs_id_str_w_recycled_obj(void) {
 void Pairs_set_object_w_zero_sized_rel_comp(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t r = ecs_set(world, 0, EcsComponent, {0});
+    ecs_entity_t r = ecs_insert(world, ecs_value(EcsComponent, {0}));
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_set_pair_object(world, 0, r, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value_pair_2nd(r, Position, {10, 20}));
     
-    const Position *p = ecs_get_pair_object(world, e, r, Position);
+    const Position *p = ecs_get_pair_second(world, e, r, Position);
     test_assert(p != NULL);
     test_int(p->x, 10);
     test_int(p->y, 20);
@@ -1021,26 +1029,26 @@ void Pairs_dsl_pair(void) {
     ECS_TAG(world, Obj);
     ECS_TAG(world, Obj_2);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "(Rel, Obj)"
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, Obj)"
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2)) });
     test_assert(e4 != 0);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1048,10 +1056,12 @@ void Pairs_dsl_pair(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e1);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
 
     test_bool(ecs_query_next(&it), false); 
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1063,26 +1073,26 @@ void Pairs_dsl_pair_w_pred_wildcard(void) {
     ECS_TAG(world, Obj);
     ECS_TAG(world, Obj_2);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "(*, Obj)"
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(*, Obj)"
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2)) });
     test_assert(e4 != 0);    
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1090,15 +1100,17 @@ void Pairs_dsl_pair_w_pred_wildcard(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e1);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e3);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj));
 
     test_bool(ecs_query_next(&it), false); 
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1110,26 +1122,26 @@ void Pairs_dsl_pair_w_obj_wildcard(void) {
     ECS_TAG(world, Obj);
     ECS_TAG(world, Obj_2);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "(Rel_2, *)"
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel_2, *)"
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2)) });
     test_assert(e4 != 0);    
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1137,14 +1149,16 @@ void Pairs_dsl_pair_w_obj_wildcard(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e3);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e4);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj_2));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj_2));
 
     test_bool(ecs_query_next(&it), false); 
+    
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1159,26 +1173,26 @@ void Pairs_dsl_pair_w_both_wildcard(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "(*, *), Tag" // add Tag or we'd match builtin entities
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(*, *), Tag" // add Tag or we'd match builtin entities
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj), Tag} });
+        .add = ecs_ids(ecs_pair(Rel, Obj), Tag) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2), Tag} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2), Tag) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj), Tag} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj), Tag) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2), Tag} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2), Tag) });
     test_assert(e4 != 0);    
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1187,25 +1201,27 @@ void Pairs_dsl_pair_w_both_wildcard(void) {
     test_int(it.count, 1);
     test_int(it.entities[0], e1);
 
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e2);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj_2));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj_2));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e3);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e4);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj_2));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj_2));
 
     test_bool(ecs_query_next(&it), false); 
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1217,26 +1233,26 @@ void Pairs_dsl_pair_w_explicit_subj_this(void) {
     ECS_TAG(world, Obj);
     ECS_TAG(world, Obj_2);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Rel($This, Obj)"
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Rel($this, Obj)"
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2)) });
     test_assert(e4 != 0);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1244,9 +1260,11 @@ void Pairs_dsl_pair_w_explicit_subj_this(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e1);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
 
-    test_bool(ecs_query_next(&it), false); 
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(q); 
 
     ecs_fini(world);
 }
@@ -1262,29 +1280,29 @@ void Pairs_dsl_pair_w_explicit_subj(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t Subj = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .name = "Subj", .add = {ecs_pair(Rel, Obj)} });
+        .name = "Subj", .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(Subj != 0);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Rel(Subj, Obj), Tag"
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Rel(Subj, Obj), Tag"
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2), Tag} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2), Tag) });
     test_assert(e4 != 0);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1292,11 +1310,13 @@ void Pairs_dsl_pair_w_explicit_subj(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e4);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
-    test_int(ecs_field_src(&it, 1), Subj);
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
+    test_int(ecs_field_src(&it, 0), Subj);
 
     test_bool(ecs_query_next(&it), false); 
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1308,26 +1328,26 @@ void Pairs_api_pair(void) {
     ECS_TAG(world, Obj);
     ECS_TAG(world, Obj_2);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ecs_pair(Rel, Obj)}}
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ecs_pair(Rel, Obj)}}
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2)) });
     test_assert(e4 != 0);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1335,10 +1355,12 @@ void Pairs_api_pair(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e1);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
 
     test_bool(ecs_query_next(&it), false); 
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1350,26 +1372,26 @@ void Pairs_api_pair_w_pred_wildcard(void) {
     ECS_TAG(world, Obj);
     ECS_TAG(world, Obj_2);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ecs_pair(EcsWildcard, Obj)}}
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ecs_pair(EcsWildcard, Obj)}}
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2)) });
     test_assert(e4 != 0);    
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1377,15 +1399,17 @@ void Pairs_api_pair_w_pred_wildcard(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e1);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e3);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj));
 
     test_bool(ecs_query_next(&it), false); 
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1397,26 +1421,26 @@ void Pairs_api_pair_w_obj_wildcard(void) {
     ECS_TAG(world, Obj);
     ECS_TAG(world, Obj_2);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ecs_pair(Rel_2, EcsWildcard)}}
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ecs_pair(Rel_2, EcsWildcard)}}
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2)) });
     test_assert(e4 != 0);    
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1424,14 +1448,16 @@ void Pairs_api_pair_w_obj_wildcard(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e3);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e4);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj_2));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj_2));
 
-    test_bool(ecs_query_next(&it), false); 
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(q); 
 
     ecs_fini(world);
 }
@@ -1446,27 +1472,27 @@ void Pairs_api_pair_w_both_wildcard(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         // add Tag or we'd match builtin entities
-        .filter.terms = {{ecs_pair(EcsWildcard, EcsWildcard)}, {Tag}} 
+        .terms = {{ecs_pair(EcsWildcard, EcsWildcard)}, {Tag}} 
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj), Tag} });
+        .add = ecs_ids(ecs_pair(Rel, Obj), Tag) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2), Tag} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2), Tag) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj), Tag} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj), Tag) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2), Tag} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2), Tag) });
     test_assert(e4 != 0);    
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1474,25 +1500,27 @@ void Pairs_api_pair_w_both_wildcard(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e1);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e2);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj_2));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj_2));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e3);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj));
 
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e4);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel_2, Obj_2));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel_2, Obj_2));
 
     test_bool(ecs_query_next(&it), false); 
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1504,8 +1532,8 @@ void Pairs_api_pair_w_explicit_subj_this(void) {
     ECS_TAG(world, Obj);
     ECS_TAG(world, Obj_2);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
             { ecs_pair(Rel, Obj), .src.id = EcsThis }
         }
     });
@@ -1513,19 +1541,19 @@ void Pairs_api_pair_w_explicit_subj_this(void) {
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2)) });
     test_assert(e4 != 0);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1533,10 +1561,12 @@ void Pairs_api_pair_w_explicit_subj_this(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e1);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
 
     test_bool(ecs_query_next(&it), false); 
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1551,29 +1581,29 @@ void Pairs_api_pair_w_explicit_subj(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t Subj = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .name = "Subj", .add = {ecs_pair(Rel, Obj)} });
+        .name = "Subj", .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(Subj != 0);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ecs_pair(Rel, Obj), .src.id = Subj}, {Tag}}
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ecs_pair(Rel, Obj), .src.id = Subj}, {Tag}}
     });
 
     test_assert(q != NULL);
 
     ecs_entity_t e1 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj)) });
     test_assert(e1 != 0);
 
     ecs_entity_t e2 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj_2)} });
+        .add = ecs_ids(ecs_pair(Rel, Obj_2)) });
     test_assert(e2 != 0);
 
     ecs_entity_t e3 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj)} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj)) });
     test_assert(e3 != 0);
 
     ecs_entity_t e4 = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel_2, Obj_2), Tag} });
+        .add = ecs_ids(ecs_pair(Rel_2, Obj_2), Tag) });
     test_assert(e4 != 0);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1581,18 +1611,20 @@ void Pairs_api_pair_w_explicit_subj(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
     test_int(it.entities[0], e4);
-    test_int(ecs_field_id(&it, 1), ecs_pair(Rel, Obj));
-    test_int(ecs_field_src(&it, 1), Subj);
+    test_int(ecs_field_id(&it, 0), ecs_pair(Rel, Obj));
+    test_int(ecs_field_src(&it, 0), Subj);
 
     test_bool(ecs_query_next(&it), false); 
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
 void Pairs_typeid_from_tag(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t tag = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
     test_assert(tag != 0);
 
     ecs_entity_t id = ecs_get_typeid(world, tag);
@@ -1618,10 +1650,10 @@ void Pairs_typeid_from_component(void) {
 void Pairs_typeid_from_pair(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t rel_id = ecs_new_id(world);
+    ecs_entity_t rel_id = ecs_new(world);
     test_assert(rel_id != 0);
 
-    ecs_entity_t obj_id = ecs_new_id(world);
+    ecs_entity_t obj_id = ecs_new(world);
     test_assert(obj_id != 0);
 
     ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
@@ -1639,7 +1671,7 @@ void Pairs_typeid_from_pair_w_rel_type(void) {
     ecs_id_t rel_id = ecs_id(Rel);
     test_assert(rel_id != 0);
 
-    ecs_entity_t obj_id = ecs_new_id(world);
+    ecs_entity_t obj_id = ecs_new(world);
     test_assert(obj_id != 0);
 
     ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
@@ -1658,7 +1690,7 @@ void Pairs_typeid_from_pair_w_obj_type(void) {
     ecs_id_t obj_id = ecs_id(Obj);
     test_assert(obj_id != 0);
 
-    ecs_entity_t rel_id = ecs_new_id(world);
+    ecs_entity_t rel_id = ecs_new(world);
     test_assert(rel_id != 0);
 
     ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
@@ -1693,7 +1725,7 @@ void Pairs_typeid_from_pair_w_rel_obj_type(void) {
 void Pairs_typeid_from_pair_w_rel_0_obj_type(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_id_t rel_id = ecs_set(world, 0, EcsComponent, {0});
+    ecs_id_t rel_id = ecs_insert(world, ecs_value(EcsComponent, {0}));
     test_assert(rel_id != 0);
 
     ECS_COMPONENT(world, Obj);
@@ -1716,7 +1748,7 @@ void Pairs_typeid_from_pair_w_rel_obj_0_type(void) {
     ecs_id_t rel_id = ecs_id(Rel);
     test_assert(rel_id != 0);
 
-    ecs_id_t obj_id = ecs_set(world, 0, EcsComponent, {0});
+    ecs_id_t obj_id = ecs_insert(world, ecs_value(EcsComponent, {0}));
     test_assert(obj_id != 0);
 
     ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
@@ -1731,10 +1763,10 @@ void Pairs_typeid_from_pair_w_rel_obj_0_type(void) {
 void Pairs_typeid_from_pair_w_rel_0_obj_0_type(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_id_t rel_id = ecs_set(world, 0, EcsComponent, {0});
+    ecs_id_t rel_id = ecs_insert(world, ecs_value(EcsComponent, {0}));
     test_assert(rel_id != 0);
 
-    ecs_id_t obj_id = ecs_set(world, 0, EcsComponent, {0});
+    ecs_id_t obj_id = ecs_insert(world, ecs_value(EcsComponent, {0}));
     test_assert(obj_id != 0);
 
     ecs_id_t pair_id = ecs_pair(rel_id, obj_id);
@@ -1763,7 +1795,7 @@ void Pairs_typeid_from_pair_w_override(void) {
     ecs_id_t rel_id = ecs_id(Rel);
     test_assert(rel_id != 0);
 
-    ecs_entity_t obj_id = ecs_new_id(world);
+    ecs_entity_t obj_id = ecs_new(world);
     test_assert(obj_id != 0);
 
     ecs_id_t pair_id = ECS_OVERRIDE | ecs_pair(rel_id, obj_id);
@@ -1781,7 +1813,7 @@ void Pairs_typeid_from_pair_w_toggle(void) {
     ecs_id_t rel_id = ecs_id(Rel);
     test_assert(rel_id != 0);
 
-    ecs_entity_t obj_id = ecs_new_id(world);
+    ecs_entity_t obj_id = ecs_new(world);
     test_assert(obj_id != 0);
 
     ecs_id_t pair_id = ECS_TOGGLE | ecs_pair(rel_id, obj_id);
@@ -1798,9 +1830,9 @@ void Pairs_tag_pair_w_rel_comp(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Obj);
 
-    ecs_add_id(world, ecs_id(Position), EcsTag);
+    ecs_add_id(world, ecs_id(Position), EcsPairIsTag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_id_t pair_id = ecs_pair(ecs_id(Position), Obj);
 
     ecs_add_id(world, e, pair_id);
@@ -1817,9 +1849,9 @@ void Pairs_tag_pair_w_obj_comp(void) {
     ECS_TAG(world, Rel);
     ECS_COMPONENT(world, Position);
 
-    ecs_add_id(world, Rel, EcsTag);
+    ecs_add_id(world, Rel, EcsPairIsTag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_id_t pair_id = ecs_pair(Rel, ecs_id(Position));
 
     ecs_add_id(world, e, pair_id);
@@ -1836,9 +1868,9 @@ void Pairs_tag_pair_w_rel_obj_comp(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_add_id(world, ecs_id(Position), EcsTag);
+    ecs_add_id(world, ecs_id(Position), EcsPairIsTag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_id_t pair_id = ecs_pair(ecs_id(Position), ecs_id(Velocity));
 
     ecs_add_id(world, e, pair_id);
@@ -1857,9 +1889,9 @@ void Pairs_get_tag_pair_w_rel_comp(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Obj);
 
-    ecs_add_id(world, ecs_id(Position), EcsTag);
+    ecs_add_id(world, ecs_id(Position), EcsPairIsTag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_id_t pair_id = ecs_pair(ecs_id(Position), Obj);
 
     ecs_add_id(world, e, pair_id);
@@ -1876,9 +1908,9 @@ void Pairs_get_tag_pair_w_obj_comp(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_add_id(world, ecs_id(Position), EcsTag);
+    ecs_add_id(world, ecs_id(Position), EcsPairIsTag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_id_t pair_id = ecs_pair(ecs_id(Position), ecs_id(Velocity));
 
     ecs_add_id(world, e, pair_id);
@@ -1895,9 +1927,9 @@ void Pairs_get_tag_pair_w_rel_obj_comp(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_add_id(world, ecs_id(Position), EcsTag);
+    ecs_add_id(world, ecs_id(Position), EcsPairIsTag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_id_t pair_id = ecs_pair(ecs_id(Position), ecs_id(Velocity));
 
     ecs_add_id(world, e, pair_id);
@@ -1911,7 +1943,7 @@ void Pairs_tag_pair_w_childof_w_comp(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_id_t pair_id = ecs_pair(EcsChildOf, ecs_id(Position));
 
     ecs_add_id(world, e, pair_id);
@@ -1927,7 +1959,7 @@ void Pairs_tag_pair_w_isa_w_comp(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_id_t pair_id = ecs_pair(EcsIsA, ecs_id(Position));
 
     ecs_add_id(world, e, pair_id);
@@ -1941,9 +1973,9 @@ void Pairs_tag_pair_w_isa_w_comp(void) {
 void Pairs_get_1_target(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t obj = ecs_new(world);
 
     ecs_add_pair(world, e, rel, obj);
     test_assert(ecs_has_pair(world, e, rel, obj));
@@ -1955,8 +1987,8 @@ void Pairs_get_1_target(void) {
 void Pairs_get_1_target_not_found(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t rel = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t rel = ecs_new(world);
 
     test_assert(ecs_get_target(world, e, rel, 0) == 0);
 
@@ -1966,11 +1998,11 @@ void Pairs_get_1_target_not_found(void) {
 void Pairs_get_n_targets(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t obj_1 = ecs_new_id(world);
-    ecs_entity_t obj_2 = ecs_new_id(world);
-    ecs_entity_t obj_3 = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t obj_1 = ecs_new(world);
+    ecs_entity_t obj_2 = ecs_new(world);
+    ecs_entity_t obj_3 = ecs_new(world);
 
     ecs_add_pair(world, e, rel, obj_1);
     ecs_add_pair(world, e, rel, obj_2);
@@ -1989,8 +2021,8 @@ void Pairs_get_n_targets(void) {
 void Pairs_get_target_from_base(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t tgt = ecs_new_id(world);
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t tgt = ecs_new(world);
     ecs_entity_t base = ecs_new_w_pair(world, rel, tgt);
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
 
@@ -2003,9 +2035,9 @@ void Pairs_get_target_from_base(void) {
 void Pairs_get_target_from_2nd_base(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_entity_t base_1 = ecs_new_id(world);
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t tgt = ecs_new(world);
+    ecs_entity_t base_1 = ecs_new(world);
     ecs_entity_t base_2 = ecs_new_w_pair(world, rel, tgt);
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base_1);
     ecs_add_pair(world, inst, EcsIsA, base_2);
@@ -2020,9 +2052,9 @@ void Pairs_get_target_from_2nd_base(void) {
 void Pairs_get_target_from_base_w_pair_on_instance(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t tgt_a = ecs_new_id(world);
-    ecs_entity_t tgt_b = ecs_new_id(world);
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t tgt_a = ecs_new(world);
+    ecs_entity_t tgt_b = ecs_new(world);
     ecs_entity_t base = ecs_new_w_pair(world, rel, tgt_b);
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
     ecs_add_pair(world, inst, rel, tgt_a);
@@ -2037,7 +2069,7 @@ void Pairs_get_target_from_base_w_pair_on_instance(void) {
 void Pairs_get_childof_target_from_base(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t base = ecs_new_w_pair(world, EcsChildOf, parent);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
 
@@ -2054,7 +2086,7 @@ void Pairs_get_dontinherit_target_from_base(void) {
 
     ECS_ENTITY(world, Rel, DontInherit);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t base = ecs_new_w_pair(world, Rel, parent);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
 
@@ -2069,7 +2101,7 @@ void Pairs_get_dontinherit_target_from_base(void) {
 void Pairs_get_parent(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, parent);
 
     test_assert(ecs_get_target(world, e, EcsChildOf, 0) == parent);
@@ -2081,7 +2113,7 @@ void Pairs_get_parent(void) {
 void Pairs_get_parent_from_root(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     test_assert(ecs_get_parent(world, e) == 0);
 
@@ -2093,7 +2125,7 @@ void Pairs_get_target_for_id_from_self(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
     ecs_add_id(world, e, Tag);
 
@@ -2109,7 +2141,7 @@ void Pairs_get_target_for_id_from_base(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
 
     ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA, Tag);
@@ -2124,7 +2156,7 @@ void Pairs_get_target_for_id_from_nested_base(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_entity_t base_2 = ecs_new_w_pair(world, EcsIsA, base);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base_2);
 
@@ -2140,7 +2172,7 @@ void Pairs_get_target_for_id_not_found(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_entity_t base_2 = ecs_new_w_pair(world, EcsIsA, base);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base_2);
 
@@ -2213,7 +2245,7 @@ void Pairs_ignore_childof_from_base(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Obj);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t base = ecs_new_w_pair(world, EcsChildOf, parent);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
 
@@ -2229,7 +2261,7 @@ void Pairs_get_target_for_id_from_empty(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_entity_t result = ecs_get_target_for_id(world, e, EcsIsA, Tag);
     test_assert(result == 0);
 
@@ -2241,7 +2273,7 @@ void Pairs_get_target_for_id_from_empty_no_rel(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_entity_t result = ecs_get_target_for_id(world, e, 0, Tag);
     test_assert(result == 0);
 
@@ -2254,7 +2286,7 @@ void Pairs_get_target_for_id_not_empty_not_found(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     ecs_entity_t result = ecs_get_target_for_id(world, e, 0, TagB);
     test_assert(result == 0);
 
@@ -2266,7 +2298,7 @@ void Pairs_get_target_for_id_from_stage(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
 
     ecs_world_t *stage = ecs_get_stage(world, 0);
@@ -2284,7 +2316,7 @@ void Pairs_get_target_for_id_no_id(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
     ecs_add_id(world, e, Tag);
 
@@ -2302,7 +2334,7 @@ void Pairs_add_exclusive_relation_twice(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, Rel, ObjA);
     test_assert( ecs_has_pair(world, e, Rel, ObjA));
@@ -2320,7 +2352,7 @@ void Pairs_add_same_exclusive_relation_twice(void) {
     ECS_ENTITY(world, Rel, Exclusive);
     ECS_TAG(world, ObjA);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, Rel, ObjA);
     test_assert( ecs_has_pair(world, e, Rel, ObjA));
@@ -2340,7 +2372,7 @@ void Pairs_set_exclusive_relation_twice(void) {
 
     ecs_add_id(world, ecs_id(Position), EcsExclusive);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_set_pair(world, e, Position, Start, {10, 20});
     test_assert( ecs_has_pair(world, e, ecs_id(Position), Start));
@@ -2372,7 +2404,7 @@ void Pairs_add_exclusive_non_empty_table(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
     ecs_add(world, e, TagC);
@@ -2399,7 +2431,7 @@ void Pairs_add_exclusive_non_empty_table_w_pairs(void) {
 
     ECS_TAG(world, RelB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, RelA, ObjA);
     ecs_add_pair(world, e, RelB, ObjA);
 
@@ -2421,7 +2453,7 @@ void Pairs_add_pair_to_entity_w_exclusive_pair(void) {
     ECS_TAG(world, RelA);
     ECS_TAG(world, RelB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsChildOf, ObjA);
     test_assert( ecs_has_pair(world, e, EcsChildOf, ObjA));
 
@@ -2444,7 +2476,7 @@ void Pairs_add_pair_to_entity_w_scope(void) {
 
     ecs_set_scope(world, ObjA);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, RelA, ObjA);
     test_assert( ecs_has_pair(world, e, RelA, ObjA));
@@ -2464,7 +2496,7 @@ void Pairs_add_existing_exclusive_pair_after_pair(void) {
     ECS_TAG(world, RelB);
     ECS_TAG(world, ObjA);
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
 
     ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, parent);
     ecs_add_pair(world, e, EcsChildOf, ObjA);
@@ -2493,10 +2525,10 @@ void Pairs_add_remove_exclusive_property(void) {
     ecs_entity_t rel = ecs_new_w_id(world, EcsExclusive);
     ecs_remove_id(world, rel, EcsExclusive);
 
-    ecs_entity_t tgt_1 = ecs_new_id(world);
-    ecs_entity_t tgt_2 = ecs_new_id(world);
+    ecs_entity_t tgt_1 = ecs_new(world);
+    ecs_entity_t tgt_2 = ecs_new(world);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, rel, tgt_1);
     test_assert( ecs_has_pair(world, e, rel, tgt_1));
 
@@ -2589,15 +2621,15 @@ void Pairs_add_symmetric_exclusive_relation(void) {
 void Pairs_add_symmetric_recycled_relation(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t obj_a = ecs_new_id(world);
-    ecs_entity_t obj_b = ecs_new_id(world);
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t obj_a = ecs_new(world);
+    ecs_entity_t obj_b = ecs_new(world);
     ecs_delete(world, rel);
-    rel = ecs_new_id(world);
+    rel = ecs_new(world);
     ecs_delete(world, obj_a);
-    obj_a = ecs_new_id(world);
+    obj_a = ecs_new(world);
     ecs_delete(world, obj_b);
-    obj_b = ecs_new_id(world);
+    obj_b = ecs_new(world);
 
     test_assert(rel != (uint32_t)rel);
     test_assert(obj_a != (uint32_t)obj_a);
@@ -2619,7 +2651,7 @@ void Pairs_with(void) {
     ECS_TAG(world, TagA);
     ECS_ENTITY(world, TagB, (With, TagA));
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagB);
     test_assert( ecs_has(world, e, TagA));
     test_assert( ecs_has(world, e, TagB));
@@ -2634,7 +2666,7 @@ void Pairs_2_with(void) {
     ECS_TAG(world, TagB);
     ECS_ENTITY(world, TagC, (With, TagA), (With, TagB));
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagC);
     test_assert( ecs_has(world, e, TagA));
     test_assert( ecs_has(world, e, TagB));
@@ -2650,7 +2682,7 @@ void Pairs_nested_with(void) {
     ECS_ENTITY(world, TagB, (With, TagA));
     ECS_ENTITY(world, TagC, (With, TagB));
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagC);
     test_assert( ecs_has(world, e, TagA));
     test_assert( ecs_has(world, e, TagB));
@@ -2711,7 +2743,7 @@ void Pairs_with_for_existing(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagB);
     test_assert( !ecs_has(world, e, TagA));
     test_assert( ecs_has(world, e, TagB));
@@ -2725,8 +2757,8 @@ void Pairs_65k_relations(void) {
 
     ecs_set_entity_range(world, 65536, 0);
 
-    ecs_entity_t rel = ecs_new_id(world);
-    ecs_entity_t obj = ecs_new_id(world);
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t obj = ecs_new(world);
     ecs_entity_t e = ecs_new_w_pair(world, rel, obj);
     test_assert(ecs_has_pair(world, e, rel, obj));
 
@@ -2741,7 +2773,7 @@ void Pairs_remove_wildcard(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, RelA, ObjA);
     ecs_add_pair(world, e, RelA, ObjB);
     ecs_add_pair(world, e, RelB, ObjA);
@@ -2770,7 +2802,7 @@ void Pairs_remove_relation_wildcard(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, RelA, ObjA);
     ecs_add_pair(world, e, RelA, ObjB);
     ecs_add_pair(world, e, RelB, ObjA);
@@ -2794,7 +2826,7 @@ void Pairs_remove_relation_wildcard(void) {
 void Pairs_add_not_alive_relation(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t obj = ecs_new_id(world);
+    ecs_entity_t obj = ecs_new(world);
     ecs_entity_t e = ecs_new_w_pair(world, 2000, obj);
     test_assert(ecs_has_pair(world, e, 2000, obj));
 
@@ -2809,7 +2841,7 @@ void Pairs_remove_wildcard_all(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, RelA, ObjA);
     ecs_add_pair(world, e, RelA, ObjB);
     ecs_add_pair(world, e, RelB, ObjA);
@@ -2892,7 +2924,7 @@ void Pairs_has_pair_wildcard_w_tag(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
 
     test_bool(ecs_has_pair(world, e, EcsWildcard, EcsWildcard), false);
     test_bool(ecs_has_id(world, e, Tag), true);
@@ -2908,7 +2940,7 @@ void Pairs_oneof_self(void) {
     ECS_ENTITY(world, ObjA, (ChildOf, Rel));
     ECS_ENTITY(world, ObjB, (ChildOf, Rel));
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, Rel, ObjA);
     test_assert(ecs_has_pair(world, e, Rel, ObjA));
 
@@ -2926,7 +2958,7 @@ void Pairs_oneof_other(void) {
     ECS_ENTITY(world, ObjA, (ChildOf, Parent));
     ECS_ENTITY(world, ObjB, (ChildOf, Parent));
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, Rel, ObjA);
     test_assert(ecs_has_pair(world, e, Rel, ObjA));
 
@@ -2946,7 +2978,7 @@ void Pairs_oneof_self_constraint_violated(void) {
     ECS_ENTITY(world, ObjB, (ChildOf, Rel));
     ECS_TAG(world, ObjC);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     test_expect_abort();
     ecs_add_pair(world, e, Rel, ObjC);
@@ -2963,7 +2995,7 @@ void Pairs_oneof_other_constraint_violated(void) {
     ECS_ENTITY(world, ObjB, (ChildOf, Parent));
     ECS_TAG(world, ObjC);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     test_expect_abort();
     ecs_add_pair(world, e, Rel, ObjC);
@@ -2980,7 +3012,7 @@ void Pairs_oneof_other_rel_parent_constraint_violated(void) {
     ECS_ENTITY(world, ObjB, (ChildOf, Parent));
     ECS_ENTITY(world, ObjC, (ChildOf, Rel));
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     test_expect_abort();
     ecs_add_pair(world, e, Rel, ObjC);
@@ -2989,19 +3021,19 @@ void Pairs_oneof_other_rel_parent_constraint_violated(void) {
 void Pairs_set_w_recycled_rel(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t dummy = ecs_new_id(world);
+    ecs_entity_t dummy = ecs_new(world);
     ecs_delete(world, dummy);
 
     ecs_entity_t ecs_id(Position) = ecs_component(world, {
-        .entity = ecs_new_id(world),
+        .entity = ecs_new(world),
         .type.size = ECS_SIZEOF(Position),
         .type.alignment = ECS_ALIGNOF(Position)
     });
 
     test_assert(ecs_id(Position) != (uint32_t)ecs_id(Position));
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t tgt = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t tgt = ecs_new(world);
     ecs_set_pair(world, e, Position, tgt, {10, 20});
     test_assert(ecs_has_pair(world, e, ecs_id(Position), tgt));
 
@@ -3016,19 +3048,19 @@ void Pairs_set_w_recycled_rel(void) {
 void Pairs_set_w_recycled_tgt(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t dummy = ecs_new_id(world);
+    ecs_entity_t dummy = ecs_new(world);
     ecs_delete(world, dummy);
 
     ecs_entity_t ecs_id(Position) = ecs_component(world, {
-        .entity = ecs_new_id(world),
+        .entity = ecs_new(world),
         .type.size = ECS_SIZEOF(Position),
         .type.alignment = ECS_ALIGNOF(Position)
     });
 
     test_assert(ecs_id(Position) != (uint32_t)ecs_id(Position));
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t rel = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t rel = ecs_new(world);
     ecs_set_pair_second(world, e, rel, Position, {10, 20});
     test_assert(ecs_has_pair(world, e, rel, ecs_id(Position)));
 
@@ -3048,7 +3080,7 @@ void Pairs_force_relationship_on_component(void) {
     ECS_ENTITY(world, Rel, Relationship);
 
     test_expect_abort();
-    ecs_new(world, Rel);
+    ecs_new_w(world, Rel);
 }
 
 void Pairs_force_relationship_on_target(void) {
@@ -3095,7 +3127,7 @@ void Pairs_force_target_on_component(void) {
     ECS_ENTITY(world, Tgt, Target);
 
     test_expect_abort();
-    ecs_new(world, Tgt);
+    ecs_new_w(world, Tgt);
 }
 
 void Pairs_force_target_on_relationship(void) {
diff --git a/test/core/src/Poly.c b/test/core/src/Poly.c
new file mode 100644
index 000000000..316dc8e74
--- /dev/null
+++ b/test/core/src/Poly.c
@@ -0,0 +1,119 @@
+#include <core.h>
+
+static
+void FooTrigger(ecs_iter_t *it) {}
+
+static
+void PolyTrigger(ecs_iter_t *it) {
+    probe_system_w_ctx(it, it->ctx);
+
+    EcsPoly *poly = ecs_field(it, EcsPoly, 0);
+
+    test_int(1, it->count);
+    test_assert(poly->poly != NULL);
+}
+
+void Poly_on_set_poly_observer(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t tag = ecs_new(world);
+
+    Probe ctx = {0};
+    ecs_observer(world, {
+        .query.terms[0] = { ecs_pair(ecs_id(EcsPoly), EcsObserver) },
+        .events = { EcsOnSet },
+        .callback = PolyTrigger,
+        .ctx = &ctx
+    });
+
+    test_int(1, ctx.invoked);
+
+    ecs_os_zeromem(&ctx);
+
+    ecs_entity_t t = ecs_observer(world, {
+        .query.terms = {{ tag }},
+        .events = { EcsOnAdd },
+        .callback = FooTrigger
+    });
+
+    test_int(1, ctx.invoked);
+    test_int(1, ctx.count);
+    test_uint(t, ctx.e[0]);
+
+    ecs_fini(world);
+}
+
+void Poly_on_set_poly_query(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t tag = ecs_new(world);
+
+    Probe ctx = {0};
+    ecs_observer(world, {
+        .query.terms[0] = { ecs_pair(ecs_id(EcsPoly), EcsQuery) },
+        .events = { EcsOnSet },
+        .callback = PolyTrigger,
+        .ctx = &ctx
+    });
+
+    test_int(0, ctx.invoked);
+
+    ecs_query(world, {
+        .terms = {{ tag }},
+        .entity = ecs_new(world)
+    });
+
+    test_int(1, ctx.invoked);
+    test_int(1, ctx.count);
+
+    ecs_fini(world);
+}
+
+void Poly_on_set_poly_system(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t tag = ecs_new(world);
+
+    Probe ctx = {0};
+    ecs_observer(world, {
+        .query.terms[0] = { ecs_pair(ecs_id(EcsPoly), EcsSystem) },
+        .events = { EcsOnSet },
+        .callback = PolyTrigger,
+        .ctx = &ctx
+    });
+
+    test_int(0, ctx.invoked);
+
+    ecs_entity_t s = ecs_system(world, {
+        .query.terms = {{ tag }},
+        .callback = FooTrigger
+    });
+
+    test_int(1, ctx.invoked);
+    test_int(1, ctx.count);
+    test_uint(s, ctx.e[0]);
+
+    ecs_fini(world);
+}
+
+void Poly_free_query_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t qe = ecs_new(world);
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ Tag }},
+        .entity = qe
+    });
+
+    const EcsPoly *poly = ecs_get_pair(world, qe, EcsPoly, EcsQuery);
+    test_assert(poly != NULL);
+    test_assert(poly->poly == q);
+
+    ecs_delete(world, qe);
+
+    test_assert(!ecs_is_alive(world, qe));
+
+    ecs_fini(world);
+}
diff --git a/test/api/src/Prefab.c b/test/core/src/Prefab.c
similarity index 91%
rename from test/api/src/Prefab.c
rename to test/core/src/Prefab.c
index 93e837be6..9e44c602c 100644
--- a/test/api/src/Prefab.c
+++ b/test/core/src/Prefab.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static ecs_id_t NamePair;
 
@@ -8,14 +8,14 @@ void Prefab_setup(void) {
 
 static
 void Iter(ecs_iter_t *it) {
-    Mass *m_ptr = ecs_field(it, Mass, 1);
-    bool shared = !ecs_field_is_self(it, 1);
+    Mass *m_ptr = ecs_field(it, Mass, 0);
+    bool shared = !ecs_field_is_self(it, 0);
 
-    Position *p = ecs_field(it, Position, 2);
+    Position *p = ecs_field(it, Position, 1);
 
     Velocity *v = NULL;
     if (it->field_count >= 3) {
-        v = ecs_field(it, Velocity, 3);
+        v = ecs_field(it, Velocity, 2);
     }
 
     probe_iter(it);
@@ -187,7 +187,7 @@ void Prefab_add_prefab(void) {
 
     ecs_set(world, Prefab, Position, {10, 20});
 
-    ecs_entity_t e1 = ecs_new(world, Velocity);
+    ecs_entity_t e1 = ecs_new_w(world, Velocity);
     test_assert(e1 != 0);
 
     ecs_add_pair(world, e1, EcsIsA, Prefab);
@@ -197,7 +197,7 @@ void Prefab_add_prefab(void) {
     test_assert( !ecs_has_id(world, e1, EcsPrefab));
     test_assert( !ecs_has_id(world, e1, NamePair));
 
-    ecs_entity_t e2 = ecs_new(world, Velocity);
+    ecs_entity_t e2 = ecs_new_w(world, Velocity);
     test_assert(e2 != 0);
 
     ecs_add_pair(world, e2, EcsIsA, Prefab);
@@ -264,7 +264,7 @@ void Prefab_remove_prefab_after_add(void) {
 
     ecs_set(world, Prefab, Position, {10, 20});
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != 0);
 
     ecs_add_pair(world, e1, EcsIsA, Prefab);
@@ -549,20 +549,20 @@ static
 void Prefab_w_shared(ecs_iter_t *it) {
     Velocity *v = NULL;
     if (it->field_count >= 2) {
-        v = ecs_field(it, Velocity, 2);
+        v = ecs_field(it, Velocity, 1);
         if (v) {
-            test_assert(!ecs_field_is_self(it, 2));
+            test_assert(!ecs_field_is_self(it, 1));
         }
     }
     
     Mass *m = NULL;
     if (it->field_count >= 3) {
-        m = ecs_field(it, Mass, 3);
+        m = ecs_field(it, Mass, 2);
     }
 
     probe_iter(it);
 
-    Position *pos = ecs_field(it, Position, 1);
+    Position *pos = ecs_field(it, Position, 0);
 
     for (int i = 0; i < it->count; i ++) {
         Position *p = &pos[i];
@@ -582,7 +582,9 @@ void Prefab_iterate_w_prefab_shared(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_PREFAB(world, Prefab, Velocity);
-    ECS_SYSTEM(world, Prefab_w_shared, EcsOnUpdate, Position, Velocity(up|self));
+    ECS_SYSTEM(world, Prefab_w_shared, EcsOnUpdate, 
+        Position, 
+        Velocity(self|up IsA));
 
     ecs_set(world, Prefab, Velocity, {1, 2});
 
@@ -625,8 +627,8 @@ void Prefab_match_entity_prefab_w_system_optional(void) {
     ECS_PREFAB(world, Prefab, Velocity, Mass);
     ECS_SYSTEM(world, Prefab_w_shared, EcsOnUpdate, 
         Position, 
-        Velocity(self|up), 
-        ?Mass(self|up));
+        Velocity(self|up IsA), 
+        ?Mass(self|up IsA));
 
     ecs_set(world, Prefab, Velocity, {1, 2});
     ecs_set(world, Prefab, Mass, {3});
@@ -671,10 +673,10 @@ void Prefab_prefab_in_system_expr(void) {
 
     ECS_PREFAB(world, Prefab1, Velocity);
     ECS_PREFAB(world, Prefab2, Velocity);
-    ECS_SYSTEM(world, Prefab_w_shared, EcsOnUpdate, Position, Velocity(self|up), Mass, (IsA, Prefab1));
+    ECS_SYSTEM(world, Prefab_w_shared, EcsOnUpdate, Position, Velocity(self|up IsA), Mass, (IsA, Prefab1));
     ecs_system_init(world, &(ecs_system_desc_t){
         .entity = Prefab_w_shared,
-        .query.filter.instanced = true
+        .query.flags = EcsQueryIsInstanced
     });
 
     ecs_set(world, Prefab1, Velocity, {1, 2});
@@ -867,8 +869,8 @@ void Prefab_ignore_prefab_parent_component(void) {
 
 static
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -879,7 +881,7 @@ void Move(ecs_iter_t *it) {
 
 static
 void AddVelocity(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -900,7 +902,7 @@ void Prefab_match_table_created_in_progress(void) {
     ECS_ENTITY(world, e, (IsA, Prefab), Position);
 
     ECS_SYSTEM(world, AddVelocity, EcsOnUpdate, Position, [out] !Velocity);
-    ECS_SYSTEM(world, Move, EcsOnUpdate, Position, Velocity, Mass(self|up));
+    ECS_SYSTEM(world, Move, EcsOnUpdate, Position, Velocity, Mass(self|up IsA));
 
     ecs_set(world, e, Position, {0, 0});
     
@@ -1448,7 +1450,7 @@ void Prefab_on_set_on_instance(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ECS_OBSERVER(world, PrefabReactiveTest, EcsOnSet, Position(self|up));
+    ECS_OBSERVER(world, PrefabReactiveTest, EcsOnSet, Position(self|up IsA));
 
     ECS_PREFAB(world, Prefab, Position);
 
@@ -1472,7 +1474,7 @@ void Prefab_on_set_on_instance(void) {
 }
 
 void InstantiateInProgress(ecs_iter_t *it) {
-    ecs_id_t Prefab = ecs_field_id(it, 2);
+    ecs_id_t Prefab = ecs_field_id(it, 1);
     ecs_entity_t *ids = ecs_get_ctx(it->world);
 
     int i;
@@ -1514,7 +1516,7 @@ void Prefab_instantiate_in_progress(void) {
 }
 
 void NewInProgress(ecs_iter_t *it) {
-    ecs_id_t Prefab = ecs_field_id(it, 2);
+    ecs_id_t Prefab = ecs_field_id(it, 1);
 
     ecs_entity_t *ids = ecs_get_ctx(it->world);
 
@@ -1606,7 +1608,7 @@ void Prefab_ref_after_realloc(void) {
 
     ECS_ENTITY(world, e2, Position, (IsA, Prefab));
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(self|up), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(self|up IsA), Position);
 
     /* Trigger a realloc of the table in which the prefab is stored. This should
      * cause systems with refs to re-resolve their cached ref ptrs  */
@@ -1643,7 +1645,7 @@ void Prefab_revalidate_ref_w_mixed_table_refs(void) {
     ECS_ENTITY(world, e2, Position, Mass);
     ecs_set(world, e2, Mass, {3});
 
-    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(self|up), Position);
+    ECS_SYSTEM(world, Iter, EcsOnUpdate, Mass(self|up IsA), Position);
 
     /* Trigger a realloc of the table in which the prefab is stored. This should
      * cause systems with refs to re-resolve their cached ref ptrs  */
@@ -1692,7 +1694,7 @@ void Prefab_no_overwrite_on_2nd_add(void) {
 }
 
 void AddPrefab(ecs_iter_t *it) {
-    ecs_id_t Prefab = ecs_field_id(it, 2);
+    ecs_id_t Prefab = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -1822,7 +1824,7 @@ void Prefab_no_instantiate_on_2nd_add_in_progress(void) {
 
 void NewPrefab_w_count(ecs_iter_t *it) {
     ecs_entity_t *ids = ecs_get_ctx(it->world);
-    ecs_id_t Prefab = ecs_field_id(it, 1);
+    ecs_id_t Prefab = ecs_field_id(it, 0);
 
     const ecs_entity_t *new_ids = ecs_bulk_new_w_id(it->world, ecs_pair(EcsIsA, Prefab), 3);
     test_assert(new_ids != NULL);
@@ -1874,8 +1876,8 @@ static int on_set_velocity_invoked;
 
 static
 void OnSetVelocity(ecs_iter_t *it) {
-    Velocity *v = ecs_field(it, Velocity, 1);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
+    Velocity *v = ecs_field(it, Velocity, 0);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 0);
 
     on_set_velocity_invoked ++;
 
@@ -1883,7 +1885,7 @@ void OnSetVelocity(ecs_iter_t *it) {
     for (i = 0; i < it->count; i ++) {
         ecs_add(it->world, it->entities[i], Velocity);
 
-        if (ecs_field_is_self(it, 1)) {
+        if (ecs_field_is_self(it, 0)) {
             v[i].x ++;
             v[i].y ++;
         }
@@ -1938,8 +1940,8 @@ void Prefab_nested_prefab_in_progress_w_count_set_after_override(void) {
 }
 
 void AddPrefabInProgress(ecs_iter_t *it) {
-    ecs_id_t Prefab = ecs_field_id(it, 2);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 3);
+    ecs_id_t Prefab = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -1984,10 +1986,10 @@ void Prefab_get_ptr_from_prefab_from_new_table_in_progress(void) {
 }
 
 void TestBase(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
-    test_assert(!ecs_field_is_self(it, 2));
+    test_assert(!ecs_field_is_self(it, 1));
 
     test_assert(p != NULL);
     test_assert(v != NULL);
@@ -2007,7 +2009,7 @@ void Prefab_match_base(void) {
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, Child);
     ecs_add(world, e, Position);
 
-    ECS_SYSTEM(world, TestBase, EcsOnUpdate, Position, Velocity(self|up));
+    ECS_SYSTEM(world, TestBase, EcsOnUpdate, Position, Velocity(self|up IsA));
 
     ecs_progress(world, 1);
 
@@ -2016,7 +2018,7 @@ void Prefab_match_base(void) {
 
 static
 void AddMass(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Mass) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Mass) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2039,7 +2041,7 @@ void Prefab_match_base_after_add_in_prev_phase(void) {
     ecs_add(world, e, Position);
 
     ECS_SYSTEM(world, AddMass, EcsPreUpdate, Position, !Mass);
-    ECS_SYSTEM(world, TestBase, EcsOnUpdate, Position, Velocity(self|up));
+    ECS_SYSTEM(world, TestBase, EcsOnUpdate, Position, Velocity(self|up IsA));
 
     ecs_progress(world, 1);
 
@@ -2083,7 +2085,10 @@ void Prefab_rematch_twice(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position(self|up), Velocity(self|up), Mass(self|up));
+    ECS_SYSTEM(world, Dummy, EcsOnUpdate, 
+        Position(self|up IsA), 
+        Velocity(self|up IsA), 
+        Mass(self|up IsA));
 
     ECS_PREFAB(world, Prefab, Position);
     ECS_ENTITY(world, Entity, (IsA, Prefab));
@@ -2111,7 +2116,7 @@ void Prefab_rematch_twice(void) {
 
 static
 void AddPosition(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
     
     ecs_entity_t *base = ecs_get_ctx(it->world);
 
@@ -2123,8 +2128,8 @@ void Prefab_add_to_empty_base_in_system(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new(world, 0);
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t base = ecs_new(world);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     ecs_add_pair(world, e1, EcsIsA, base);
 
     ECS_SYSTEM(world, AddPosition, EcsOnUpdate, Position());
@@ -2144,8 +2149,8 @@ void Prefab_inherit_disabled(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Velocity);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Velocity);
     
     ecs_add_id(world, e2, EcsDisabled);
     ecs_add_pair(world, e1, EcsIsA, e2);
@@ -2166,7 +2171,7 @@ static bool has_cloned = false;
 static
 void CloneInOnAdd(ecs_iter_t *it)
 {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2192,7 +2197,7 @@ void Prefab_clone_after_inherit_in_on_add(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, CloneInOnAdd, EcsOnAdd, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     const Position *p = ecs_get(world, e, Position);
@@ -2240,7 +2245,7 @@ void Prefab_override_from_nested(void) {
 
 static
 void OnAddEntity(ecs_iter_t *it) {
-    ecs_entity_t *e = ecs_field(it, ecs_entity_t, 1);
+    ecs_entity_t *e = ecs_field(it, ecs_entity_t, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2315,7 +2320,7 @@ static ecs_entity_t new_instance_1, new_instance_2;
 
 static
 void CreateInstances(ecs_iter_t *it) {
-    ecs_id_t Prefab = ecs_field_id(it, 1);
+    ecs_id_t Prefab = ecs_field_id(it, 0);
 
     new_instance_1 = ecs_new_w_pair(it->world, EcsIsA, Prefab);
     new_instance_2 = ecs_new_w_pair(it->world, EcsIsA, Prefab);
@@ -2339,7 +2344,7 @@ void Prefab_create_multiple_nested_w_on_set_in_progress(void) {
 
     ECS_SYSTEM(world, CreateInstances, EcsOnUpdate, Prefab());
     ECS_OBSERVER(world, OnAddEntity, EcsOnSet, ecs_entity_t);
-    ECS_OBSERVER(world, OnSetVelocity, EcsOnSet, Velocity(self|up));
+    ECS_OBSERVER(world, OnSetVelocity, EcsOnSet, Velocity(self|up IsA));
 
     ecs_progress(world, 1);
 
@@ -2489,7 +2494,7 @@ void Prefab_auto_override_pair(void) {
     ECS_TAG(world, TgtB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_pair(Rel, TgtA));
     test_assert(!ecs_has_pair(world, base, Rel, TgtA));
     test_assert(!ecs_has_pair(world, base, Rel, TgtB));
@@ -2520,7 +2525,7 @@ void Prefab_auto_override_pair_w_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_pair(ecs_id(Position), TgtA));
     test_assert(ecs_get_pair(world, base, Position, TgtA) == NULL);
 
@@ -2558,7 +2563,7 @@ void Prefab_auto_override_2_pairs(void) {
     ECS_TAG(world, TgtB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_pair(Rel, TgtA));
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_pair(Rel, TgtB));
     test_assert(!ecs_has_pair(world, base, Rel, TgtA));
@@ -2592,7 +2597,7 @@ void Prefab_auto_override_2_pairs_w_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_pair(ecs_id(Position), TgtA));
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_pair(ecs_id(Position), TgtB));
     test_assert(ecs_get_pair(world, base, Position, TgtA) == NULL);
@@ -2634,7 +2639,7 @@ void Prefab_auto_override_2_pairs_same_obj(void) {
     ECS_TAG(world, RelA);
     ECS_TAG(world, RelB);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_pair(RelA, Tgt));
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_pair(RelB, Tgt));
     test_assert(!ecs_has_pair(world, base, RelA, Tgt));
@@ -2673,7 +2678,7 @@ void Prefab_prefab_instanceof_hierarchy(void) {
 
     /* Ensure that child has not been instantiated by making
      * sure there are no matching entities for Position up to this point */
-    ecs_query_t *q = ecs_query_new(world, "Position(self|up)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position(self|up IsA)" });
 
     ecs_iter_t qit = ecs_query_iter(world, q);
     test_assert(!ecs_query_next(&qit));
@@ -2692,6 +2697,8 @@ void Prefab_prefab_instanceof_hierarchy(void) {
     test_int(qit.count, 1);
     test_assert(ecs_query_next(&qit) == false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -2701,7 +2708,7 @@ void Prefab_override_tag(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_set(world, base, Position, {10, 20});
     
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
@@ -2720,7 +2727,7 @@ void Prefab_empty_prefab(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
     ecs_add(world, e, Position);
@@ -2801,7 +2808,7 @@ void Prefab_override_2_prefabs(void) {
     ecs_set(world, PrefabA, Position, {10, 20});
     ecs_set(world, PrefabB, Velocity, {1, 2});
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, PrefabA);
     ecs_add_pair(world, e, EcsIsA, PrefabB);
 
@@ -2827,11 +2834,11 @@ void Prefab_rematch_after_add_instanceof_to_parent(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_query_t *q = ecs_query_new(world, "Position(parent)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position(up)" });
     test_assert(q != NULL);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t parent = ecs_new(world, 0);
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
     test_assert(base != 0);
     test_assert(parent != 0);
@@ -2844,12 +2851,14 @@ void Prefab_rematch_after_add_instanceof_to_parent(void) {
     test_int(it.count, 1);
     test_int(it.entities[0], child);
 
-    Position *p = ecs_field(&it, Position, 1);
+    Position *p = ecs_field(&it, Position, 0);
     test_assert(p != NULL);
     test_int(p->x, 10);
     test_int(p->y, 20);
     test_bool(ecs_query_next(&it), false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -2859,7 +2868,7 @@ void Prefab_child_of_instance(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t base = ecs_new_w_id(world, EcsPrefab);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, EcsChildOf, base);
 
@@ -2876,16 +2885,16 @@ void Prefab_rematch_after_prefab_delete(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
 
-    ecs_query_t *q = ecs_query_new(world, "Position(up)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position(up IsA)" });
 
     ecs_iter_t it = ecs_query_iter(world, q);
     test_assert(ecs_query_next(&it));
     test_int(it.count, 1);
     test_int(it.entities[0], e);
-    Position *p = ecs_field(&it, Position, 1);
+    Position *p = ecs_field(&it, Position, 0);
     test_assert(p != NULL);
     test_int(p->x, 10);
     test_int(p->y, 20);
@@ -2896,6 +2905,8 @@ void Prefab_rematch_after_prefab_delete(void) {
     it = ecs_query_iter(world, q);
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -2905,7 +2916,7 @@ void Prefab_add_tag_w_low_id_to_instance(void) {
     ecs_entity_t Tag = ecs_new_low_id(world);
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_add_id(world, base, Tag);
 
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
@@ -2922,7 +2933,7 @@ void Prefab_get_type_after_base_add(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new(world, Position);
+    ecs_entity_t base = ecs_new_w(world, Position);
     test_assert(base != 0);
     test_assert( ecs_get_type(world, base) != NULL);
 
@@ -2938,14 +2949,14 @@ void Prefab_get_type_after_recycled_base_add(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
     test_assert( ecs_get_type(world, base) == NULL);
 
     ecs_delete(world, base);
     test_assert( !ecs_is_alive(world, base));
 
-    base = ecs_new(world, Position);
+    base = ecs_new_w(world, Position);
     test_assert(base != 0);
     test_assert(ecs_entity_t_lo(base) != base); // Ensure recycled
     test_assert( ecs_get_type(world, base) != NULL);
@@ -2960,13 +2971,13 @@ void Prefab_get_type_after_recycled_base_add(void) {
 void Prefab_new_w_recycled_base(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_delete(world, base);
     test_assert( !ecs_is_alive(world, base));
 
-    base = ecs_new(world, 0);
+    base = ecs_new(world);
     test_assert(base != 0);
     test_assert(ecs_entity_t_lo(base) != base); // Ensure recycled
 
@@ -2980,17 +2991,17 @@ void Prefab_new_w_recycled_base(void) {
 void Prefab_add_recycled_base(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_delete(world, base);
     test_assert( !ecs_is_alive(world, base));
 
-    base = ecs_new(world, 0);
+    base = ecs_new(world);
     test_assert(base != 0);
     test_assert(ecs_entity_t_lo(base) != base); // Ensure recycled
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     ecs_add_pair(world, e, EcsIsA, base);
     test_assert( ecs_has_pair(world, e, EcsIsA, base));
@@ -3001,17 +3012,17 @@ void Prefab_add_recycled_base(void) {
 void Prefab_remove_recycled_base(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_delete(world, base);
     test_assert( !ecs_is_alive(world, base));
 
-    base = ecs_new(world, 0);
+    base = ecs_new(world);
     test_assert(base != 0);
     test_assert(ecs_entity_t_lo(base) != base); // Ensure recycled
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     ecs_add_pair(world, e, EcsIsA, base);
     test_assert( ecs_has_pair(world, e, EcsIsA, base));
@@ -3027,13 +3038,13 @@ void Prefab_get_from_recycled_base(void) {
     
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_delete(world, base);
     test_assert( !ecs_is_alive(world, base));
 
-    base = ecs_set(world, 0, Position, {10, 20});
+    base = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(base != 0);
     test_assert(ecs_entity_t_lo(base) != base); // Ensure recycled
     test_assert( ecs_get_type(world, base) != NULL);
@@ -3059,13 +3070,13 @@ void Prefab_override_from_recycled_base(void) {
     
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_delete(world, base);
     test_assert( !ecs_is_alive(world, base));
 
-    base = ecs_set(world, 0, Position, {10, 20});
+    base = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(base != 0);
     test_assert(ecs_entity_t_lo(base) != base); // Ensure recycled
 
@@ -3092,13 +3103,13 @@ void Prefab_remove_override_from_recycled_base(void) {
     
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_delete(world, base);
     test_assert( !ecs_is_alive(world, base));
 
-    base = ecs_set(world, 0, Position, {10, 20});
+    base = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(base != 0);
     test_assert(ecs_entity_t_lo(base) != base); // Ensure recycled
 
@@ -3130,7 +3141,7 @@ void Prefab_instantiate_tree_from_recycled_base(void) {
     ecs_delete(world, base);
     test_assert( !ecs_is_alive(world, base));
 
-    base = ecs_set(world, 0, Position, {10, 20});
+    base = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(base != 0);
     ecs_add_id(world, base, EcsPrefab);
 
@@ -3165,15 +3176,15 @@ void Prefab_rematch_after_add_to_recycled_base(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_new(world, "Tag, Position(up)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag, Position(up IsA)" });
 
-    ecs_entity_t base = ecs_new(world, 0);
+    ecs_entity_t base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_delete(world, base);
     test_assert( !ecs_is_alive(world, base));
 
-    base = ecs_new(world, 0);
+    base = ecs_new(world);
     test_assert(base != 0);
 
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base);
@@ -3192,13 +3203,15 @@ void Prefab_rematch_after_add_to_recycled_base(void) {
     test_bool(ecs_query_next(&it), true);
     test_int(it.count, 1);
 
-    const Position *p = ecs_field(&it, Position, 2);
+    const Position *p = ecs_field(&it, Position, 1);
     test_assert(p != NULL);
     test_int(p->x, 10);
     test_int(p->y, 20);
-    test_assert(ecs_field_src(&it, 2) == base);
+    test_assert(ecs_field_src(&it, 1) == base);
     test_bool(ecs_query_next(&it), false);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -3207,10 +3220,10 @@ void Prefab_get_tag_from_2nd_base(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t base_1 = ecs_new_id(world);
+    ecs_entity_t base_1 = ecs_new(world);
     ecs_entity_t base_2 = ecs_new_w_id(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base_1);
     ecs_add_pair(world, e, EcsIsA, base_2);
 
@@ -3227,10 +3240,10 @@ void Prefab_get_component_from_2nd_base(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base_1 = ecs_new_id(world);
-    ecs_entity_t base_2 = ecs_new(world, Position);
+    ecs_entity_t base_1 = ecs_new(world);
+    ecs_entity_t base_2 = ecs_new_w(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base_1);
     ecs_add_pair(world, e, EcsIsA, base_2);
 
@@ -3250,10 +3263,10 @@ void Prefab_get_component_from_1st_base(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base_1 = ecs_new(world, Position);
-    ecs_entity_t base_2 = ecs_new(world, Position);
+    ecs_entity_t base_1 = ecs_new_w(world, Position);
+    ecs_entity_t base_2 = ecs_new_w(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base_1);
     ecs_add_pair(world, e, EcsIsA, base_2);
 
@@ -3274,10 +3287,10 @@ void Prefab_get_component_from_2nd_base_of_base(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base_1 = ecs_new_id(world);
-    ecs_entity_t base_2 = ecs_new(world, Position);
+    ecs_entity_t base_1 = ecs_new(world);
+    ecs_entity_t base_2 = ecs_new_w(world, Position);
 
-    ecs_entity_t base_3 = ecs_new_id(world);
+    ecs_entity_t base_3 = ecs_new(world);
     ecs_add_pair(world, base_3, EcsIsA, base_1);
     ecs_add_pair(world, base_3, EcsIsA, base_2);
 
@@ -3300,10 +3313,10 @@ void Prefab_get_component_from_1st_base_of_base(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base_1 = ecs_new(world, Position);
-    ecs_entity_t base_2 = ecs_new(world, Position);
+    ecs_entity_t base_1 = ecs_new_w(world, Position);
+    ecs_entity_t base_2 = ecs_new_w(world, Position);
 
-    ecs_entity_t base_3 = ecs_new_id(world);
+    ecs_entity_t base_3 = ecs_new(world);
     ecs_add_pair(world, base_3, EcsIsA, base_1);
     ecs_add_pair(world, base_3, EcsIsA, base_2);
 
@@ -3329,7 +3342,7 @@ void Prefab_get_component_from_2nd_base_prefab_base(void) {
     ECS_PREFAB(world, base_1, 0);
     ECS_PREFAB(world, base_2, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base_1);
     ecs_add_pair(world, e, EcsIsA, base_2);
 
@@ -3353,7 +3366,7 @@ void Prefab_get_component_from_1st_base_prefab_base(void) {
     ECS_PREFAB(world, base_1, Position);
     ECS_PREFAB(world, base_2, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base_1);
     ecs_add_pair(world, e, EcsIsA, base_2);
 
@@ -3429,13 +3442,12 @@ void Prefab_fail_on_override_final(void) {
 static
 int child_count(ecs_world_t *world, ecs_entity_t e) {
     int32_t count = 0;
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ 
-        ecs_pair(EcsChildOf, e 
-    )});
+    ecs_iter_t it = ecs_each_pair(world, EcsChildOf, e);
 
-    while (ecs_term_next(&it)) {
+    while (ecs_each_next(&it)) {
         count += it.count;
     }
+
     return count;
 }
 
@@ -3510,7 +3522,7 @@ void Prefab_get_component_pair_from_base(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Obj);
 
-    ecs_entity_t base = ecs_set_pair(world, 0, Position, Obj, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value_pair(Position, Obj, {10, 20}));
     test_assert(ecs_has_pair(world, base, ecs_id(Position), Obj));
 
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
@@ -3557,10 +3569,10 @@ void Prefab_override_dont_inherit(void) {
     ecs_add_id(world, ecs_id(Position), EcsDontInherit);
 
     ecs_set_hooks(world, Position, {
-        .ctor = ecs_default_ctor
+        .ctor = flecs_default_ctor
     });
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
     test_assert( !ecs_has(world, inst, Position));
 
@@ -3573,31 +3585,14 @@ void Prefab_override_dont_inherit(void) {
     ecs_fini(world);
 }
 
-void Prefab_prefab_w_switch(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Walking);
-    ECS_TAG(world, Running);
-
-    ecs_entity_t p = ecs_new_w_pair(world, Movement, Running);
-    test_assert( ecs_has_pair(world, p, Movement, Running));
-
-    ecs_entity_t i = ecs_new_w_pair(world, EcsIsA, p);
-    test_assert( ecs_has_pair(world, i, Movement, Running));
-    test_assert( !ecs_has_pair(world, i, Movement, Walking));
-
-    ecs_fini(world);
-}
-
 void Prefab_prefab_child_w_dont_inherit_component(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_ENTITY(world, TagA, DontInherit);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_child = ecs_new_prefab(world, "Base.Child");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_child = ecs_entity(world, { .name = "Base.Child", .add = ecs_ids( EcsPrefab ) });
     ecs_add(world, base_child, TagA);
     ecs_add(world, base_child, TagB);
     test_assert(base != 0);
@@ -3620,16 +3615,16 @@ void Prefab_prefab_child_override(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_entity_t turret = ecs_new_prefab(world, "Turret");
-    ecs_entity_t turret_head = ecs_new_prefab(world, "Turret.Head");
+    ecs_entity_t turret = ecs_entity(world, { .name = "Turret", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t turret_head = ecs_entity(world, { .name = "Turret.Head", .add = ecs_ids( EcsPrefab ) });
     ecs_add(world, turret_head, Foo);
 
-    ecs_entity_t railgun = ecs_new_prefab(world, "Railgun");
+    ecs_entity_t railgun = ecs_entity(world, { .name = "Railgun", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, railgun, EcsIsA, turret);
-    ecs_entity_t railgun_head = ecs_new_prefab(world, "Railgun.Head");
+    ecs_entity_t railgun_head = ecs_entity(world, { .name = "Railgun.Head", .add = ecs_ids( EcsPrefab ) });
     ecs_add(world, railgun_head, Bar);
 
-    ecs_entity_t inst = ecs_new_entity(world, "inst");
+    ecs_entity_t inst = ecs_entity(world, { .name = "inst" });
     ecs_add_pair(world, inst, EcsIsA, railgun);
 
     ecs_entity_t head = ecs_lookup_child(world, inst, "Head");
@@ -3647,19 +3642,19 @@ void Prefab_prefab_child_override_w_exclusive_pair(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t turret = ecs_new_prefab(world, "Turret");
-    ecs_entity_t turret_head = ecs_new_prefab(world, "Turret.Head");
+    ecs_entity_t turret = ecs_entity(world, { .name = "Turret", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t turret_head = ecs_entity(world, { .name = "Turret.Head", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, turret_head, Rel, ObjA);
     test_assert(ecs_has_pair(world, turret_head, Rel, ObjA));
 
-    ecs_entity_t railgun = ecs_new_prefab(world, "Railgun");
+    ecs_entity_t railgun = ecs_entity(world, { .name = "Railgun", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, railgun, EcsIsA, turret);
-    ecs_entity_t railgun_head = ecs_new_prefab(world, "Railgun.Head");
+    ecs_entity_t railgun_head = ecs_entity(world, { .name = "Railgun.Head", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, railgun_head, Rel, ObjB);
     test_assert(!ecs_has_pair(world, railgun_head, Rel, ObjA));
     test_assert(ecs_has_pair(world, railgun_head, Rel, ObjB));
 
-    ecs_entity_t inst = ecs_new_entity(world, "inst");
+    ecs_entity_t inst = ecs_entity(world, { .name = "inst" });
     ecs_add_pair(world, inst, EcsIsA, railgun);
 
     ecs_entity_t head = ecs_lookup_child(world, inst, "Head");
@@ -3673,8 +3668,8 @@ void Prefab_prefab_child_override_w_exclusive_pair(void) {
 void Prefab_prefab_1_slot(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_slot = ecs_new_prefab(world, "Base.Slot");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot = ecs_entity(world, { .name = "Base.Slot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, base_slot, EcsSlotOf, base);
     test_assert(ecs_has_pair(world, base_slot, EcsChildOf, base));
     test_assert(ecs_has_pair(world, base_slot, EcsSlotOf, base));
@@ -3694,9 +3689,9 @@ void Prefab_prefab_1_slot(void) {
 void Prefab_prefab_2_slots(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_slot_a = ecs_new_prefab(world, "Base.SlotA");
-    ecs_entity_t base_slot_b = ecs_new_prefab(world, "Base.SlotB");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot_a = ecs_entity(world, { .name = "Base.SlotA", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot_b = ecs_entity(world, { .name = "Base.SlotB", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, base_slot_a, EcsSlotOf, base);
     ecs_add_pair(world, base_slot_b, EcsSlotOf, base);
     test_assert(ecs_has_pair(world, base_slot_a, EcsChildOf, base));
@@ -3725,9 +3720,9 @@ void Prefab_prefab_2_slots(void) {
 void Prefab_prefab_w_nested_slot(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_slot = ecs_new_prefab(world, "Base.Slot");
-    ecs_entity_t base_slot_slot = ecs_new_prefab(world, "Base.Slot.Slot");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot = ecs_entity(world, { .name = "Base.Slot", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot_slot = ecs_entity(world, { .name = "Base.Slot.Slot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, base_slot, EcsSlotOf, base);
     ecs_add_pair(world, base_slot_slot, EcsSlotOf, base);
     test_assert(ecs_has_pair(world, base_slot, EcsChildOf, base));
@@ -3757,9 +3752,9 @@ void Prefab_prefab_w_nested_slot(void) {
 void Prefab_prefab_w_mixed_slots(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_slot = ecs_new_prefab(world, "Base.Slot");
-    ecs_entity_t base_slot_slot = ecs_new_prefab(world, "Base.Slot.Slot");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot = ecs_entity(world, { .name = "Base.Slot", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot_slot = ecs_entity(world, { .name = "Base.Slot.Slot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, base_slot, EcsSlotOf, base);
     ecs_add_pair(world, base_slot_slot, EcsSlotOf, base_slot);
     test_assert(ecs_has_pair(world, base_slot, EcsChildOf, base));
@@ -3792,9 +3787,9 @@ void Prefab_prefab_w_mixed_slots(void) {
 void Prefab_prefab_variant_w_slot(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t variant = ecs_new_prefab(world, "Variant");
-    ecs_entity_t variant_slot = ecs_new_prefab(world, "Variant.Slot");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t variant = ecs_entity(world, { .name = "Variant", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t variant_slot = ecs_entity(world, { .name = "Variant.Slot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, variant, EcsIsA, base);
     ecs_add_pair(world, variant_slot, EcsSlotOf, variant);
     test_assert(ecs_has_pair(world, variant_slot, EcsChildOf, variant));
@@ -3815,13 +3810,13 @@ void Prefab_prefab_variant_w_slot(void) {
 void Prefab_prefab_variant_w_base_slot(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_slot = ecs_new_prefab(world, "Base.Slot");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot = ecs_entity(world, { .name = "Base.Slot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, base_slot, EcsSlotOf, base);
     test_assert(ecs_has_pair(world, base_slot, EcsChildOf, base));
     test_assert(ecs_has_pair(world, base_slot, EcsSlotOf, base));
 
-    ecs_entity_t variant = ecs_new_prefab(world, "Variant");
+    ecs_entity_t variant = ecs_entity(world, { .name = "Variant", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, variant, EcsIsA, base);
 
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, variant);
@@ -3839,15 +3834,15 @@ void Prefab_prefab_variant_w_base_slot(void) {
 void Prefab_prefab_variant_w_mixed_slots(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_slot = ecs_new_prefab(world, "Base.BaseSlot");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot = ecs_entity(world, { .name = "Base.BaseSlot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, base_slot, EcsSlotOf, base);
     test_assert(ecs_has_pair(world, base_slot, EcsChildOf, base));
     test_assert(ecs_has_pair(world, base_slot, EcsSlotOf, base));
 
-    ecs_entity_t variant = ecs_new_prefab(world, "Variant");
+    ecs_entity_t variant = ecs_entity(world, { .name = "Variant", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, variant, EcsIsA, base);
-    ecs_entity_t variant_slot = ecs_new_prefab(world, "Variant.VariantSlot");
+    ecs_entity_t variant_slot = ecs_entity(world, { .name = "Variant.VariantSlot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, variant, EcsIsA, base);
     ecs_add_pair(world, variant_slot, EcsSlotOf, variant);
     test_assert(ecs_has_pair(world, variant_slot, EcsChildOf, variant));
@@ -3873,10 +3868,13 @@ void Prefab_prefab_variant_w_mixed_slots(void) {
 }
 
 void Prefab_override_slot(void) {
+    // Quarantined until Union trait is reintroduced
+    test_quarantine("1 Apr 2024");
+
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_slot = ecs_new_prefab(world, "Base.Slot");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot = ecs_entity(world, { .name = "Base.Slot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, base_slot, EcsSlotOf, base);
     test_assert(ecs_has_pair(world, base_slot, EcsChildOf, base));
     test_assert(ecs_has_pair(world, base_slot, EcsSlotOf, base));
@@ -3890,7 +3888,7 @@ void Prefab_override_slot(void) {
     test_assert(!ecs_has_pair(world, inst_slot, EcsSlotOf, EcsWildcard));
     test_assert(ecs_has_pair(world, inst_slot, EcsChildOf, inst));
 
-    ecs_entity_t slot_override = ecs_new_id(world);
+    ecs_entity_t slot_override = ecs_new(world);
     ecs_add_pair(world, inst, base_slot, slot_override);
 
     test_assert(ecs_has_pair(world, inst, base_slot, slot_override));
@@ -3900,10 +3898,13 @@ void Prefab_override_slot(void) {
 }
 
 void Prefab_2_instances_w_slots_same_table(void) {
+    // Quarantined until Union trait is reintroduced
+    test_quarantine("1 Apr 2024");
+
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_slot = ecs_new_prefab(world, "Base.Slot");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot = ecs_entity(world, { .name = "Base.Slot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, base_slot, EcsSlotOf, base);
     test_assert(ecs_has_pair(world, base_slot, EcsChildOf, base));
     test_assert(ecs_has_pair(world, base_slot, EcsSlotOf, base));
@@ -3928,8 +3929,8 @@ void Prefab_2_instances_w_slots_same_table(void) {
 void Prefab_slot_has_union(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_slot = ecs_new_prefab(world, "Base.Slot");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t base_slot = ecs_entity(world, { .name = "Base.Slot", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, base_slot, EcsSlotOf, base);
     test_assert(ecs_has_pair(world, base_slot, EcsChildOf, base));
     test_assert(ecs_has_pair(world, base_slot, EcsSlotOf, base));
@@ -3941,8 +3942,8 @@ void Prefab_slot_has_union(void) {
     test_assert(inst_slot != 0);
     test_assert(base_slot != 0);
 
-    test_assert( ecs_has_id(world, base_slot, EcsUnion));
-    test_assert( !ecs_has_id(world, inst_slot, EcsUnion));
+    // test_assert( ecs_has_id(world, base_slot, EcsUnion));
+    // test_assert( !ecs_has_id(world, inst_slot, EcsUnion));
 
     ecs_fini(world);
 }
@@ -3950,25 +3951,25 @@ void Prefab_slot_has_union(void) {
 void Prefab_slot_override(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t turret = ecs_new_prefab(world, "Turret");
-    ecs_entity_t turret_base = ecs_new_prefab(world, "Turret.Base");
+    ecs_entity_t turret = ecs_entity(world, { .name = "Turret", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t turret_base = ecs_entity(world, { .name = "Turret.Base", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, turret_base, EcsSlotOf, turret);
-    ecs_entity_t turret_head = ecs_new_prefab(world, "Turret.Head");
+    ecs_entity_t turret_head = ecs_entity(world, { .name = "Turret.Head", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, turret_head, EcsSlotOf, turret);
 
-    ecs_entity_t railgun = ecs_new_prefab(world, "Railgun");
+    ecs_entity_t railgun = ecs_entity(world, { .name = "Railgun", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, railgun, EcsIsA, turret);
-    ecs_entity_t railgun_head = ecs_new_prefab(world, "Railgun.Head");
+    ecs_entity_t railgun_head = ecs_entity(world, { .name = "Railgun.Head", .add = ecs_ids( EcsPrefab ) });
 
     test_assert(ecs_has_pair(world, railgun_head, EcsSlotOf, turret));
     ecs_add_pair(world, railgun_head, EcsSlotOf, railgun);
     test_assert(ecs_has_pair(world, railgun_head, EcsSlotOf, railgun));
     test_assert(!ecs_has_pair(world, railgun_head, EcsSlotOf, turret));
 
-    ecs_entity_t railgun_beam = ecs_new_prefab(world, "Railgun.Beam");
+    ecs_entity_t railgun_beam = ecs_entity(world, { .name = "Railgun.Beam", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, railgun_beam, EcsSlotOf, railgun);
 
-    ecs_entity_t inst = ecs_new_entity(world, "inst");
+    ecs_entity_t inst = ecs_entity(world, { .name = "inst" });
     ecs_add_pair(world, inst, EcsIsA, railgun);
 
     ecs_entity_t head = ecs_get_target(world, inst, turret_head, 0);
@@ -3999,21 +4000,21 @@ void Prefab_slot_override(void) {
 void Prefab_base_slot_override(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t turret = ecs_new_prefab(world, "Turret");
-    ecs_entity_t turret_base = ecs_new_prefab(world, "Turret.Base");
+    ecs_entity_t turret = ecs_entity(world, { .name = "Turret", .add = ecs_ids( EcsPrefab ) });
+    ecs_entity_t turret_base = ecs_entity(world, { .name = "Turret.Base", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, turret_base, EcsSlotOf, turret);
-    ecs_entity_t turret_head = ecs_new_prefab(world, "Turret.Head");
+    ecs_entity_t turret_head = ecs_entity(world, { .name = "Turret.Head", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, turret_head, EcsSlotOf, turret);
 
-    ecs_entity_t railgun = ecs_new_prefab(world, "Railgun");
+    ecs_entity_t railgun = ecs_entity(world, { .name = "Railgun", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, railgun, EcsIsA, turret);
-    ecs_entity_t railgun_head = ecs_new_prefab(world, "Railgun.Head");
+    ecs_entity_t railgun_head = ecs_entity(world, { .name = "Railgun.Head", .add = ecs_ids( EcsPrefab ) });
     test_assert(ecs_has_pair(world, railgun_head, EcsSlotOf, turret));
 
-    ecs_entity_t railgun_beam = ecs_new_prefab(world, "Railgun.Beam");
+    ecs_entity_t railgun_beam = ecs_entity(world, { .name = "Railgun.Beam", .add = ecs_ids( EcsPrefab ) });
     ecs_add_pair(world, railgun_beam, EcsSlotOf, railgun);
 
-    ecs_entity_t inst = ecs_new_entity(world, "inst");
+    ecs_entity_t inst = ecs_entity(world, { .name = "inst" });
     ecs_add_pair(world, inst, EcsIsA, railgun);
 
     ecs_entity_t head = ecs_get_target(world, inst, turret_head, 0);
@@ -4041,45 +4042,12 @@ void Prefab_base_slot_override(void) {
     ecs_fini(world);
 }
 
-void Prefab_prefab_child_w_union(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Rel, Union);
-    ECS_TAG(world, TgtA);
-    ECS_TAG(world, TgtB);
-    ECS_TAG(world, TgtC);
-
-    ecs_entity_t base = ecs_new_prefab(world, "Base");
-    ecs_entity_t base_child_a = ecs_new_prefab(world, "Base.ChildA");
-    ecs_entity_t base_child_b = ecs_new_prefab(world, "Base.ChildB");
-    ecs_entity_t base_child_c = ecs_new_prefab(world, "Base.ChildC");
-    ecs_add_pair(world, base_child_a, Rel, TgtA);
-    ecs_add_pair(world, base_child_b, Rel, TgtB);
-    ecs_add_pair(world, base_child_c, Rel, TgtC);
-
-    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
-    test_assert(inst != 0);
-
-    ecs_entity_t child_a = ecs_lookup_child(world, inst, "ChildA");
-    ecs_entity_t child_b = ecs_lookup_child(world, inst, "ChildB");
-    ecs_entity_t child_c = ecs_lookup_child(world, inst, "ChildC");
-    test_assert(child_a != 0);
-    test_assert(child_b != 0);
-    test_assert(child_c != 0);
-
-    test_assert(ecs_has_pair(world, child_a, Rel, TgtA));
-    test_assert(ecs_has_pair(world, child_b, Rel, TgtB));
-    test_assert(ecs_has_pair(world, child_c, Rel, TgtC));
-
-    ecs_fini(world);
-}
-
 void Prefab_override_twice_w_add(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_set(world, base, Position, {10});
     ecs_override(world, base, Position);
 
@@ -4105,7 +4073,7 @@ void Prefab_override_twice_w_set(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_set(world, base, Position, {10});
     ecs_override(world, base, Position);
 
@@ -4143,7 +4111,7 @@ void Prefab_auto_override_copy_once(void) {
         .copy = ecs_copy(Position)
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_set(world, base, Position, {10, 20});
     ecs_override(world, base, Position);
 
@@ -4169,7 +4137,7 @@ void Prefab_always_override(void) {
 
     ecs_add_id(world, ecs_id(Position), EcsAlwaysOverride);
 
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t b = ecs_new(world);
     ecs_set(world, b, Position, {10, 20});
     ecs_set(world, b, Velocity, {1, 2});
 
@@ -4206,7 +4174,7 @@ void Prefab_always_override_pair(void) {
 
     ecs_add_id(world, RelA, EcsAlwaysOverride);
 
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t b = ecs_new(world);
     ecs_set_pair_second(world, b, RelA, Position, {10, 20});
     ecs_set_pair_second(world, b, RelB, Velocity, {1, 2});
 
@@ -4282,13 +4250,13 @@ void Prefab_override_exclusive(void) {
 
     ECS_ENTITY(ecs, Rel, Exclusive);
 
-    ecs_entity_t t1 = ecs_new_id(ecs);
-    ecs_entity_t t2 = ecs_new_id(ecs);
+    ecs_entity_t t1 = ecs_new(ecs);
+    ecs_entity_t t2 = ecs_new(ecs);
 
-    ecs_entity_t e = ecs_new_id(ecs);
+    ecs_entity_t e = ecs_new(ecs);
     ecs_add_pair(ecs, e, Rel, t1);
 
-    ecs_entity_t p = ecs_new_id(ecs);
+    ecs_entity_t p = ecs_new(ecs);
     ecs_override_pair(ecs, p, Rel, t2);
 
     ecs_add_pair(ecs, e, EcsIsA, p);
@@ -4304,17 +4272,17 @@ void Prefab_override_exclusive_2_lvls(void) {
 
     ECS_ENTITY(ecs, Rel, Exclusive);
 
-    ecs_entity_t t1 = ecs_new_id(ecs);
-    ecs_entity_t t2 = ecs_new_id(ecs);
-    ecs_entity_t t3 = ecs_new_id(ecs);
+    ecs_entity_t t1 = ecs_new(ecs);
+    ecs_entity_t t2 = ecs_new(ecs);
+    ecs_entity_t t3 = ecs_new(ecs);
 
-    ecs_entity_t e = ecs_new_id(ecs);
+    ecs_entity_t e = ecs_new(ecs);
     ecs_add_pair(ecs, e, Rel, t1);
 
-    ecs_entity_t p = ecs_new_id(ecs);
+    ecs_entity_t p = ecs_new(ecs);
     ecs_override_pair(ecs, p, Rel, t2);
 
-    ecs_entity_t p2 = ecs_new_id(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
     ecs_override_pair(ecs, p2, Rel, t3);
     ecs_add_pair(ecs, p2, EcsIsA, p);
 
diff --git a/test/api/src/ReadWrite.c b/test/core/src/ReadWrite.c
similarity index 86%
rename from test/api/src/ReadWrite.c
rename to test/core/src/ReadWrite.c
index 86f642d58..e37e425b7 100644
--- a/test/api/src/ReadWrite.c
+++ b/test/core/src/ReadWrite.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void ReadWrite_read(void) {
     ecs_world_t *world = ecs_mini();
@@ -6,7 +6,7 @@ void ReadWrite_read(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     const ecs_record_t *r = ecs_read_begin(world, e);
     test_assert(r != NULL);
@@ -28,7 +28,7 @@ void ReadWrite_nested_read(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     const ecs_record_t *r = ecs_read_begin(world, e);
     const ecs_record_t *r_2 = ecs_read_begin(world, e);
@@ -54,7 +54,7 @@ void ReadWrite_write(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_record_t *r = ecs_write_begin(world, e);
     test_assert(r != NULL);
@@ -78,7 +78,7 @@ void ReadWrite_nested_write(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_record_t *r = ecs_write_begin(world, e);
     test_assert(r != NULL);
@@ -94,7 +94,7 @@ void ReadWrite_add_while_read(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     const ecs_record_t *r = ecs_read_begin(world, e);
     test_assert(r != NULL);
@@ -110,7 +110,7 @@ void ReadWrite_add_while_write(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_record_t *r = ecs_write_begin(world, e);
     test_assert(r != NULL);
@@ -125,7 +125,7 @@ void ReadWrite_read_from_stage(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_world_t *s = ecs_get_stage(world, 0);
     ecs_readonly_begin(world, false);
@@ -152,7 +152,7 @@ void ReadWrite_write_from_stage(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
 
     ecs_world_t *s = ecs_get_stage(world, 0);
     ecs_readonly_begin(world, false);
diff --git a/test/api/src/Reference.c b/test/core/src/Reference.c
similarity index 88%
rename from test/api/src/Reference.c
rename to test/core/src/Reference.c
index 0e8d07df9..941210f77 100644
--- a/test/api/src/Reference.c
+++ b/test/core/src/Reference.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Reference_setup(void) {
     ecs_log_set_level(-3);
@@ -9,7 +9,7 @@ void Reference_get_ref(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     
     ecs_ref_t ref = ecs_ref_init(world, e, Position);
     const Position *p = ecs_ref_get(world, &ref, Position);
@@ -26,7 +26,7 @@ void Reference_get_ref_after_add(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     
     ecs_ref_t ref = ecs_ref_init(world, e, Position);
     const Position *p = ecs_ref_get(world, &ref, Position);
@@ -50,7 +50,7 @@ void Reference_get_ref_after_remove(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_add(world, e, Velocity);
     
     ecs_ref_t ref = ecs_ref_init(world, e, Position);
@@ -74,8 +74,8 @@ void Reference_get_ref_after_delete(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t dummy = ecs_new(world, Position);
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t dummy = ecs_new_w(world, Position);
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     
     ecs_ref_t ref = ecs_ref_init(world, e, Position);
     const Position *p = ecs_ref_get(world, &ref, Position);
@@ -98,7 +98,7 @@ void Reference_get_ref_after_realloc(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     
     ecs_ref_t ref = ecs_ref_init(world, e, Position);
     const Position *p = ecs_ref_get(world, &ref, Position);
@@ -109,7 +109,7 @@ void Reference_get_ref_after_realloc(void) {
     int i;
     for (i = 0; i < 1000; i ++) {
         // Creating lots of entities which will trigger allocations
-        ecs_new(world, Position);
+        ecs_new_w(world, Position);
     }
 
     p = ecs_ref_get(world, &ref, Position);
@@ -125,7 +125,7 @@ void Reference_get_ref_staged(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     
     ecs_ref_t ref = ecs_ref_init(world, e, Position);
     const Position *p = ecs_ref_get(world, &ref, Position);
@@ -158,7 +158,7 @@ void Reference_get_ref_after_new_in_stage(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     
     ecs_ref_t ref = ecs_ref_init(world, e, Position);
     const Position *p = ecs_ref_get(world, &ref, Position);
@@ -168,7 +168,7 @@ void Reference_get_ref_after_new_in_stage(void) {
 
     ecs_defer_begin(world);
 
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     /* ecs_set() makes immediate changes */
     ecs_set(world, e, Position, {30, 40});
@@ -194,7 +194,7 @@ void Reference_get_ref_monitored(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_new_w_pair(world, EcsChildOf, e);
     
     ecs_ref_t ref = ecs_ref_init(world, e, Position);
@@ -212,7 +212,7 @@ void Reference_get_nonexisting(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     
     ecs_ref_t ref = ecs_ref_init(world, e, Velocity);
     const Velocity *p = ecs_ref_get(world, &ref, Velocity);
@@ -269,7 +269,7 @@ void Reference_get_ref_w_low_id_tag(void) {
         .type.alignment = 4
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, tag);
     ecs_add_id(world, e, comp);
 
@@ -297,7 +297,7 @@ void Reference_get_ref_w_low_id_tag_after_add(void) {
         .type.alignment = 4
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, tag);
     ecs_add_id(world, e, comp);
 
@@ -318,10 +318,10 @@ void Reference_aba_table(void) {
 
   ECS_COMPONENT(world, Position);
 
-  ecs_entity_t t1 = ecs_new_id(world);
-  ecs_entity_t t2 = ecs_new_id(world);
-  ecs_entity_t t3 = ecs_new_id(world);
-  ecs_entity_t e = ecs_new_id(world);
+  ecs_entity_t t1 = ecs_new(world);
+  ecs_entity_t t2 = ecs_new(world);
+  ecs_entity_t t3 = ecs_new(world);
+  ecs_entity_t e = ecs_new(world);
 
   ecs_set_pair(world, e, Position, t1, {10, 20});
   ecs_set_pair(world, e, Position, t2, {20, 30});
diff --git a/test/api/src/Remove.c b/test/core/src/Remove.c
similarity index 93%
rename from test/api/src/Remove.c
rename to test/core/src/Remove.c
index 7f092ffb4..50c99b010 100644
--- a/test/api/src/Remove.c
+++ b/test/core/src/Remove.c
@@ -1,15 +1,15 @@
-#include <api.h>
+#include <core.h>
 
 void Remove_zero(void) {
     install_test_abort();
 
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
-    ecs_remove(world, e, 0);
+    ecs_remove_id(world, e, 0);
 }
 
 void Remove_1_of_1(void) {
@@ -17,7 +17,7 @@ void Remove_1_of_1(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_remove(world, e, Position);
@@ -31,7 +31,7 @@ void Remove_1_of_1_again(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_remove(world, e, Position);
@@ -147,7 +147,7 @@ void Remove_1_from_empty(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_remove(world, e, Position);
@@ -162,7 +162,7 @@ void Remove_not_added(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_remove(world, e, Velocity);
diff --git a/test/api/src/Search.c b/test/core/src/Search.c
similarity index 78%
rename from test/api/src/Search.c
rename to test/core/src/Search.c
index 51faac46d..c9d189258 100644
--- a/test/api/src/Search.c
+++ b/test/core/src/Search.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Search_search(void) {
     ecs_world_t *world = ecs_mini();
@@ -164,7 +164,7 @@ void Search_search_follow_relation_lvl_0(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e_0 = ecs_new(world, TagA);
+    ecs_entity_t e_0 = ecs_new_w(world, TagA);
     ecs_add(world, e_0, TagB);
 
     ecs_table_t *t = ecs_get_table(world, e_0);
@@ -186,7 +186,7 @@ void Search_search_follow_relation_lvl_1(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e_0 = ecs_new(world, TagA);
+    ecs_entity_t e_0 = ecs_new_w(world, TagA);
     ecs_add(world, e_0, TagB);
     ecs_entity_t e_1 = ecs_new_w_pair(world, Rel, e_0);
 
@@ -209,7 +209,7 @@ void Search_search_follow_relation_lvl_2(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e_0 = ecs_new(world, TagA);
+    ecs_entity_t e_0 = ecs_new_w(world, TagA);
     ecs_add(world, e_0, TagB);
     ecs_entity_t e_1 = ecs_new_w_pair(world, Rel, e_0);
     ecs_entity_t e_2 = ecs_new_w_pair(world, Rel, e_1);
@@ -233,7 +233,7 @@ void Search_search_follow_relation_lvl_3(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e_0 = ecs_new(world, TagA);
+    ecs_entity_t e_0 = ecs_new_w(world, TagA);
     ecs_add(world, e_0, TagB);
     ecs_entity_t e_1 = ecs_new_w_pair(world, Rel, e_0);
     ecs_entity_t e_2 = ecs_new_w_pair(world, Rel, e_1);
@@ -258,7 +258,7 @@ void Search_search_first_lvl_0(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e_0 = ecs_new(world, TagA);
+    ecs_entity_t e_0 = ecs_new_w(world, TagA);
     ecs_add(world, e_0, TagB);
 
     ecs_table_t *t = ecs_get_table(world, e_0);
@@ -280,7 +280,7 @@ void Search_search_first_lvl_1(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e_0 = ecs_new(world, TagA);
+    ecs_entity_t e_0 = ecs_new_w(world, TagA);
     ecs_entity_t e_1 = ecs_new_w_pair(world, Rel, e_0);
     ecs_add(world, e_0, TagB);
 
@@ -303,7 +303,7 @@ void Search_search_first_lvl_2(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e_0 = ecs_new(world, TagA);
+    ecs_entity_t e_0 = ecs_new_w(world, TagA);
     ecs_entity_t e_1 = ecs_new_w_pair(world, Rel, e_0);
     ecs_entity_t e_2 = ecs_new_w_pair(world, Rel, e_1);
     ecs_add(world, e_0, TagB);
@@ -328,7 +328,7 @@ void Search_search_first_lvl_3(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e_0 = ecs_new(world, TagA);
+    ecs_entity_t e_0 = ecs_new_w(world, TagA);
     ecs_entity_t e_1 = ecs_new_w_pair(world, Rel, e_0);
     ecs_entity_t e_2 = ecs_new_w_pair(world, Rel, e_1);
     ecs_entity_t e_3 = ecs_new_w_pair(world, Rel, e_2);
@@ -356,12 +356,12 @@ void Search_search_relation_wildcard(void) {
     ECS_TAG(world, TgtB);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t b = ecs_new(world, Tag);
+    ecs_entity_t b = ecs_new_w(world, Tag);
     ecs_add(world, b, Tag);
     ecs_add_pair(world, b, Rel, TgtA);
     ecs_add_pair(world, b, Rel, TgtB);
     
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsChildOf, b);
 
     ecs_table_t *table = ecs_get_table(world, e);
@@ -384,10 +384,10 @@ void Search_search_relation_at_offset(void) {
     ECS_TAG(world, Tag);
     ECS_TAG(world, Rel);
 
-    ecs_entity_t b1 = ecs_new(world, Tag);
-    ecs_entity_t b2 = ecs_new(world, Tag);
+    ecs_entity_t b1 = ecs_new_w(world, Tag);
+    ecs_entity_t b2 = ecs_new_w(world, Tag);
     
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, Rel, b1);
     ecs_add_pair(world, e, Rel, b2);
 
@@ -418,15 +418,15 @@ void Search_search_relation_inherit_from_parent(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, TagC);
 
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t b = ecs_new(world);
     ecs_add(world, b, TagA);
     ecs_add(world, b, TagB);
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
     ecs_add_pair(world, p, EcsIsA, b);
     ecs_add(world, p, TagC);
     
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
     ecs_add(world, e, TagC);
@@ -462,12 +462,12 @@ void Search_search_relation_dont_inherit(void) {
     
     ecs_add_id(world, TagB, EcsDontInherit);
 
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t b = ecs_new(world);
     ecs_add(world, b, TagA);
     ecs_add(world, b, TagB);
     ecs_add(world, b, TagC);
     
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
     ecs_add(world, e, TagC);
@@ -512,15 +512,15 @@ void Search_search_relation_dont_inherit_from_parent(void) {
     
     ecs_add_id(world, TagB, EcsDontInherit);
 
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t b = ecs_new(world);
     ecs_add(world, b, TagA);
     ecs_add(world, b, TagB);
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
     ecs_add_pair(world, p, EcsIsA, b);
     ecs_add(world, p, TagC);
     
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
     ecs_add(world, e, TagC);
@@ -564,10 +564,10 @@ void Search_search_relation_exclusive(void) {
     
     ecs_add_id(world, Rel, EcsExclusive);
 
-    ecs_entity_t b = ecs_new_id(world);
+    ecs_entity_t b = ecs_new(world);
     ecs_add_pair(world, b, Rel, TagA);
     
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, Rel, TagB);
     ecs_add_pair(world, e, EcsIsA, b);
 
@@ -592,111 +592,3 @@ void Search_search_relation_exclusive(void) {
 
     ecs_fini(world);
 }
-
-void Search_search_relation_union(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, Rel);
-    
-    ecs_add_id(world, Rel, EcsUnion);
-
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_add_pair(world, b, Rel, TagA);
-    
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, EcsIsA, b);
-
-    ecs_table_t *table = ecs_get_table(world, e);
-    ecs_entity_t subj = 0;
-    ecs_id_t id = 0;
-    int32_t column = 0;
-
-    column = ecs_search_relation(world, table, 0, ecs_pair(Rel, TagA), EcsIsA, EcsSelf|EcsUp, &subj, &id, 0);
-    test_int(column, 0);
-    test_int(subj, b);
-    test_int(id, ecs_pair(Rel, EcsWildcard));
-
-    column = ecs_search_relation(world, table, 0, ecs_pair(Rel, TagA), EcsIsA, EcsUp, &subj, &id, 0);
-    test_int(column, 0);
-    test_int(subj, b);
-    test_int(id, ecs_pair(Rel, EcsWildcard));
-
-    column = ecs_search_relation(world, table, 0, ecs_pair(Rel, TagA), EcsIsA, EcsSelf, &subj, &id, 0);
-    test_int(column, -1);
-
-    ecs_fini(world);
-}
-
-void Search_search_relation_union_wildcard(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, Rel);
-    
-    ecs_add_id(world, Rel, EcsUnion);
-
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_add_pair(world, b, Rel, TagA);
-    
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, EcsIsA, b);
-
-    ecs_table_t *table = ecs_get_table(world, e);
-    ecs_entity_t subj = 0;
-    ecs_id_t id = 0;
-    int32_t column = 0;
-
-    column = ecs_search_relation(world, table, 0, ecs_pair(Rel, EcsWildcard), EcsIsA, EcsSelf|EcsUp, &subj, &id, 0);
-    test_int(column, 0);
-    test_int(subj, b);
-    test_int(id, ecs_pair(Rel, EcsWildcard));
-
-    column = ecs_search_relation(world, table, 0, ecs_pair(Rel, EcsWildcard), EcsIsA, EcsUp, &subj, &id, 0);
-    test_int(column, 0);
-    test_int(subj, b);
-    test_int(id, ecs_pair(Rel, EcsWildcard));
-
-    column = ecs_search_relation(world, table, 0, ecs_pair(Rel, EcsWildcard), EcsIsA, EcsSelf, &subj, &id, 0);
-    test_int(column, -1);
-
-    ecs_fini(world);
-}
-
-void Search_search_relation_union_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, TagA);
-    ECS_TAG(world, TagB);
-    ECS_TAG(world, Rel);
-    
-    ecs_add_id(world, Rel, EcsUnion);
-
-    ecs_entity_t b = ecs_new_id(world);
-    ecs_add_pair(world, b, Rel, TagA);
-    
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_add_pair(world, e, EcsIsA, b);
-
-    ecs_table_t *table = ecs_get_table(world, e);
-    ecs_entity_t subj = 0;
-    ecs_id_t id = 0;
-    int32_t column = 0;
-
-    column = ecs_search_relation(world, table, 0, ecs_pair(EcsUnion, Rel), EcsIsA, EcsSelf|EcsUp, &subj, &id, 0);
-    test_int(column, 0);
-    test_int(subj, b);
-    test_int(id, ecs_pair(EcsUnion, Rel));
-
-    column = ecs_search_relation(world, table, 0, ecs_pair(EcsUnion, Rel), EcsIsA, EcsUp, &subj, &id, 0);
-    test_int(column, 0);
-    test_int(subj, b);
-    test_int(id, ecs_pair(EcsUnion, Rel));
-
-    column = ecs_search_relation(world, table, 0, ecs_pair(EcsUnion, Rel), EcsIsA, EcsSelf, &subj, &id, 0);
-    test_int(column, -1);
-
-    ecs_fini(world);
-}
diff --git a/test/api/src/Set.c b/test/core/src/Set.c
similarity index 87%
rename from test/api/src/Set.c
rename to test/core/src/Set.c
index 041fd6c58..87e6ee9bf 100644
--- a/test/api/src/Set.c
+++ b/test/core/src/Set.c
@@ -1,11 +1,11 @@
-#include <api.h>
+#include <core.h>
 
 void Set_set_empty(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -25,7 +25,7 @@ void Set_set_nonempty(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_set(world, e, Velocity, {10, 20});
@@ -45,7 +45,7 @@ void Set_set_non_empty_override(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -64,7 +64,7 @@ void Set_set_again(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -92,7 +92,7 @@ void Set_set_2(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -125,7 +125,7 @@ void Set_add_set(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, Position);
@@ -147,7 +147,7 @@ void Set_set_add(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -175,7 +175,7 @@ void Set_set_add_other(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -203,7 +203,7 @@ void Set_set_remove(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -229,7 +229,7 @@ void Set_set_remove_other(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Velocity);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -258,7 +258,7 @@ void Set_set_remove_twice(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -291,7 +291,7 @@ void Set_set_and_new(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(e != 0);
 
     test_assert(ecs_has(world, e, Position));
@@ -304,21 +304,16 @@ void Set_set_and_new(void) {
 }
 
 void Set_set_null(void) {
+    install_test_abort();
+
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
-    ecs_set_ptr(world, e, Position, NULL);
-    test_assert(e != 0);
+    ecs_entity_t e = ecs_new(world);
 
-    test_assert(ecs_has(world, e, Position));
-    const Position *p = ecs_get(world, e, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 0);
-    test_int(p->y, 0);
-
-    ecs_fini(world);
+    test_expect_abort();
+    ecs_set_ptr(world, e, Position, NULL);
 }
 
 void Set_ensure_new(void) {
@@ -326,7 +321,7 @@ void Set_ensure_new(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     Position *p = ecs_ensure(world, e, Position);
@@ -342,7 +337,7 @@ void Set_ensure_existing(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert( ecs_has(world, e, Position));
     const Position *p_prev = ecs_get(world, e, Position);
@@ -362,7 +357,7 @@ void Set_ensure_tag_new(void) {
 
     ECS_TAG(world, MyTag);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -377,7 +372,7 @@ void Set_ensure_tag_existing(void) {
 
     ECS_TAG(world, MyTag);
 
-    ecs_entity_t e = ecs_new(world, MyTag);
+    ecs_entity_t e = ecs_new_w(world, MyTag);
     test_assert(e != 0);
     test_assert( ecs_has(world, e, MyTag));
 
@@ -394,7 +389,7 @@ void Set_ensure_tag_new_w_comp(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, MyTag);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -410,7 +405,7 @@ void Set_ensure_tag_existing_w_comp(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, MyTag);
 
-    ecs_entity_t e = ecs_new(world, MyTag);
+    ecs_entity_t e = ecs_new_w(world, MyTag);
     test_assert(e != 0);
     test_assert( ecs_has(world, e, MyTag));
     ecs_add(world, e, Position);
@@ -446,7 +441,7 @@ void Set_ensure_tag_existing_w_pair(void) {
     ECS_TAG(world, Pair);
     ECS_TAG(world, MyTag);
 
-    ecs_entity_t e = ecs_new(world, MyTag);
+    ecs_entity_t e = ecs_new_w(world, MyTag);
     test_assert(e != 0);
     test_assert( ecs_has(world, e, MyTag));
     ecs_add_pair(world, e, Pair, ecs_id(Position));
@@ -461,7 +456,7 @@ void Set_get_mut_not_existing(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     Position *p = ecs_get_mut(world, e, Position);
     test_assert(p == NULL);
     
@@ -473,7 +468,7 @@ void Set_get_mut_existing(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     Position *p = ecs_get_mut(world, e, Position);
     test_assert(p != NULL);
     test_int(p->x, 10);
@@ -487,7 +482,7 @@ void Set_get_mut_tag(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_entity_t e = ecs_new(world, Foo);
+    ecs_entity_t e = ecs_new_w(world, Foo);
     test_assert(NULL == ecs_get_mut_id(world, e, Foo));
     
     ecs_fini(world);
@@ -499,12 +494,12 @@ void Set_get_mut_pair(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e = ecs_set_pair(world, 0, Position, Tgt, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value_pair(Position, Tgt, {10, 20}));
     Position *p = ecs_get_mut_pair(world, e, Position, Tgt);
     test_assert(p != NULL);
     test_int(p->x, 10);
     test_int(p->y, 20);
-    
+
     ecs_fini(world);
 }
 
@@ -514,7 +509,7 @@ void Set_get_mut_pair_second(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e = ecs_set_pair_second(world, 0, Tgt, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value_pair_2nd(Tgt, Position, {10, 20}));
     Position *p = ecs_get_mut_pair_second(world, e, Tgt, Position);
     test_assert(p != NULL);
     test_int(p->x, 10);
@@ -535,7 +530,7 @@ void Set_modified_w_on_set(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, OnSetPosition, EcsOnSet, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     Position *p = ecs_ensure(world, e, Position);
@@ -558,7 +553,7 @@ void Set_modified_no_component(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, OnSetPosition, EcsOnSet, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_expect_abort();
@@ -596,7 +591,7 @@ void Set_ensure_w_add_in_on_add(void) {
 
     ECS_OBSERVER(world, OnAdd, EcsOnAdd, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     Position *p = ecs_ensure(world, e, Position);
     test_assert(p != NULL);
@@ -618,7 +613,7 @@ void Set_ensure_w_remove_in_on_add(void) {
     ECS_COMPONENT_DEFINE(world, Position);
     ECS_OBSERVER(world, OnAddRemove, EcsOnAdd, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     test_expect_abort();
 
@@ -645,17 +640,17 @@ void Set_ensure_w_realloc_in_on_add(void) {
 
     ecs_entity_t *entities = ecs_os_malloc_n(ecs_entity_t, 1000);
     for (int i = 0; i < 1000; i ++) {
-        entities[i] = ecs_new(world, Position);
+        entities[i] = ecs_new_w(world, Position);
     }
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
         .callback = OnAddRealloc,
         .events = {EcsOnAdd},
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .ctx = entities
     });
 
-    ecs_entity_t e = ecs_new(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Velocity);
     const Position *ptr = ecs_ensure(world, e, Position);
     test_assert(ptr == ecs_get(world, e, Position));
 
@@ -680,10 +675,10 @@ void Set_emplace(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
-    Position *p = ecs_emplace(world, e, Position);
+    Position *p = ecs_emplace(world, e, Position, NULL);
     test_assert(p != NULL);
     test_assert(ecs_has(world, e, Position));
     test_assert(p == ecs_get(world, e, Position));
@@ -697,15 +692,15 @@ void Set_emplace_2(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
-    Position *p = ecs_emplace(world, e, Position);
+    Position *p = ecs_emplace(world, e, Position, NULL);
     test_assert(p != NULL);
     test_assert(ecs_has(world, e, Position));
     test_assert(p == ecs_get(world, e, Position));
 
-    Velocity *v = ecs_emplace(world, e, Velocity);
+    Velocity *v = ecs_emplace(world, e, Velocity, NULL);
     test_assert(v != NULL);
     test_assert(ecs_has(world, e, Velocity));
     test_assert(v == ecs_get(world, e, Velocity));  
@@ -720,12 +715,12 @@ void Set_emplace_existing(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(ecs_has(world, e, Position));
     test_assert(e != 0);
 
     test_expect_abort();
-    ecs_emplace(world, e, Position);
+    ecs_emplace(world, e, Position, NULL);
 }
 
 void Set_emplace_w_move(void) {
@@ -738,7 +733,7 @@ void Set_emplace_w_move(void) {
     test_assert(e != 0);
     test_str("Foo", ecs_get_name(world, e));
 
-    Position *p = ecs_emplace(world, e, Position);
+    Position *p = ecs_emplace(world, e, Position, NULL);
     test_assert(p != NULL);
     test_assert(ecs_has(world, e, Position));
     test_assert(p == ecs_get(world, e, Position));
@@ -765,13 +760,13 @@ void Set_emplace_w_observer_w_add(void) {
     ecs_observer_init(world, &(ecs_observer_desc_t){
         .callback = OnAddMove,
         .events = {EcsOnAdd},
-        .filter.terms[0].id = ecs_id(Position)
+        .query.terms[0].id = ecs_id(Position)
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
-    Position *p = ecs_emplace(world, e, Position);
+    Position *p = ecs_emplace(world, e, Position, NULL);
     test_assert(p != NULL);
     p->x = 10;
     p->y = 20;
@@ -792,3 +787,22 @@ void Set_emplace_w_observer_w_add(void) {
 
     ecs_fini(world);
 }
+
+void Set_emplace_existing_w_check(void) {
+    install_test_abort();
+
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e = ecs_new(world);
+    test_assert(e != 0);
+
+    bool is_new;
+    ecs_emplace(world, e, Position, &is_new);
+    test_bool(is_new, true);
+    ecs_emplace(world, e, Position, &is_new);
+    test_bool(is_new, false);
+
+    ecs_fini(world);
+}
diff --git a/test/api/src/SingleThreadStaging.c b/test/core/src/SingleThreadStaging.c
similarity index 91%
rename from test/api/src/SingleThreadStaging.c
rename to test/core/src/SingleThreadStaging.c
index 98d1597f1..9e4cb6672 100644
--- a/test/api/src/SingleThreadStaging.c
+++ b/test/core/src/SingleThreadStaging.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static ECS_COMPONENT_DECLARE(Velocity);
 
@@ -12,7 +12,7 @@ void NewEmpty(ecs_iter_t *it) {
 
     int i;
     for (i = 0; i < it->count; i ++) {
-        ctx->new_entities[ctx->entity_count] = ecs_new(it->world, 0);
+        ctx->new_entities[ctx->entity_count] = ecs_new(it->world);
         ctx->entity_count ++;
     }
 }
@@ -90,7 +90,7 @@ static
 void NewEmpty_w_count(ecs_iter_t *it) {
     IterData *ctx = ecs_get_ctx(it->world);
 
-    ctx->new_entities[ctx->entity_count] = ecs_bulk_new(it->world, 0, 1000)[0];
+    ctx->new_entities[ctx->entity_count] = ecs_bulk_new_w_id(it->world, 0, 1000)[0];
     ctx->entity_count ++;
 }
 
@@ -157,7 +157,7 @@ void Add_to_new_empty(ecs_iter_t *it) {
     IterData *ctx = ecs_get_ctx(it->world);
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_entity_t e = ecs_new(it->world, 0);
+        ecs_entity_t e = ecs_new(it->world);
         if (ctx->component) {
             ecs_add_id(it->world, e, ctx->component);
         }
@@ -232,7 +232,7 @@ void Add_remove_same_from_new(ecs_iter_t *it) {
     IterData *ctx = ecs_get_ctx(it->world);
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_entity_t e = ecs_new(it->world, 0);
+        ecs_entity_t e = ecs_new(it->world);
 
         test_assert( !ecs_get_type(it->world, e));
 
@@ -356,7 +356,7 @@ void Add_remove_different_from_new_empty(ecs_iter_t *it) {
     IterData *ctx = ecs_get_ctx(it->world);
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_entity_t e = ecs_new(it->world, 0);
+        ecs_entity_t e = ecs_new(it->world);
 
         if (ctx->component_3) {
             ecs_add_id(it->world, e, ctx->component_3);
@@ -500,9 +500,9 @@ void SingleThreadStaging_clone_w_value(void) {
     ECS_COMPONENT(world, Rotation);
     ECS_SYSTEM(world, Clone_current_w_value, EcsOnUpdate, Position);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_set(world, e1, Position, {10, 20});
 
@@ -662,9 +662,9 @@ void SingleThreadStaging_remove_from_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -701,9 +701,9 @@ void SingleThreadStaging_remove_2_from_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Velocity);
@@ -764,9 +764,9 @@ void SingleThreadStaging_add_remove_same_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -805,9 +805,9 @@ void SingleThreadStaging_add_remove_same_existing_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -863,9 +863,9 @@ void SingleThreadStaging_remove_add_same_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -904,9 +904,9 @@ void SingleThreadStaging_remove_add_same_existing_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -942,9 +942,9 @@ void SingleThreadStaging_add_remove_2_same_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -985,9 +985,9 @@ void SingleThreadStaging_add_remove_2_same_existing_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e1, Velocity);
@@ -1029,9 +1029,9 @@ void SingleThreadStaging_remove_add_2_same_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1061,7 +1061,7 @@ void SingleThreadStaging_remove_add_2_same_to_current(void) {
 
 static
 void AddRemoveAdd(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -1080,9 +1080,9 @@ void SingleThreadStaging_add_remove_add_same_to_current(void) {
     ECS_SYSTEM(world, AddRemoveAdd, EcsOnUpdate, Position, Velocity());
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
 
     ecs_progress(world, 1);
 
@@ -1106,9 +1106,9 @@ void SingleThreadStaging_remove_add_2_same_existing_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1168,9 +1168,9 @@ void SingleThreadStaging_add_remove_different_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1211,9 +1211,9 @@ void SingleThreadStaging_2_add_1_remove_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1277,9 +1277,9 @@ void SingleThreadStaging_1_add_2_remove_to_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1426,7 +1426,7 @@ void Delete_new_empty(ecs_iter_t *it) {
     IterData *ctx = ecs_get_ctx(it->world);
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_entity_t e = ecs_new(it->world, 0);
+        ecs_entity_t e = ecs_new(it->world);
         ecs_delete(it->world, e);
         ctx->new_entities[ctx->entity_count] = e;
         ctx->entity_count ++;
@@ -1524,9 +1524,9 @@ void SingleThreadStaging_set_current(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1564,7 +1564,7 @@ void Set_new_empty(ecs_iter_t *it) {
 
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_entity_t e = ecs_new(it->world, 0);
+        ecs_entity_t e = ecs_new(it->world);
         ecs_set(it->world, e, Rotation, {10 + e});
         ctx->new_entities[ctx->entity_count] = e;
         ctx->entity_count ++;
@@ -1584,9 +1584,9 @@ void SingleThreadStaging_set_new_empty(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1638,9 +1638,9 @@ void SingleThreadStaging_set_new_w_component(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1693,9 +1693,9 @@ void SingleThreadStaging_set_existing_new_w_component(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1728,7 +1728,7 @@ void Set_new_after_add(ecs_iter_t *it) {
 
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_entity_t e = ecs_new(it->world, 0);
+        ecs_entity_t e = ecs_new(it->world);
         ecs_add_id(it->world, e, ctx->component);
         ecs_set(it->world, e, Position, {10 + e, 20 + e});
         ctx->new_entities[ctx->entity_count] = e;
@@ -1749,9 +1749,9 @@ void SingleThreadStaging_set_new_after_add(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1784,7 +1784,7 @@ void Remove_after_set(ecs_iter_t *it) {
 
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_entity_t e = ecs_new(it->world, 0);
+        ecs_entity_t e = ecs_new(it->world);
         ecs_set(it->world, e, Position, {10 + e, 20 + e});
         ecs_remove_id(it->world, e, ctx->component);
 
@@ -1806,9 +1806,9 @@ void SingleThreadStaging_remove_after_set(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1839,7 +1839,7 @@ void Delete_after_set(ecs_iter_t *it) {
 
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_entity_t e = ecs_new(it->world, 0);
+        ecs_entity_t e = ecs_new(it->world);
         test_assert( !ecs_get_type(it->world, e));
 
         ecs_set(it->world, e, Position, {10 + e, 20 + e});
@@ -1863,9 +1863,9 @@ void SingleThreadStaging_delete_after_set(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, 0);
-    ecs_entity_t e2 = ecs_new(world, 0);
-    ecs_entity_t e3 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -1898,9 +1898,9 @@ void SingleThreadStaging_add_to_current_in_on_add(void) {
     ecs_set_ctx(world, &ctx, NULL);
 
     /* Create entities from scratch so they don't have the EcsName component */
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
 
     test_assert( ecs_has(world, e1, Position));
     test_assert( ecs_has(world, e2, Position));
@@ -1969,8 +1969,8 @@ static Probe pv_probe;
 
 static
 void On_PV(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     probe_system_w_ctx(it, &pv_probe);
 
@@ -1994,9 +1994,9 @@ void SingleThreadStaging_match_table_created_in_progress(void) {
     IterData add_ctx = {.component = ecs_id(Velocity)};
     ecs_set_ctx(world, &add_ctx, NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
 
     ecs_progress(world, 1);
 
@@ -2021,13 +2021,13 @@ static
 void Set_velocity_on_new(ecs_iter_t *it) {
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_set(it->world, 0, Velocity, {10, 20});
+        ecs_insert(it->world, ecs_value(Velocity, {10, 20}));
     }
 }
 
 static
 void On_V(ecs_iter_t *it) {
-    Velocity *v = ecs_field(it, Velocity, 1);
+    Velocity *v = ecs_field(it, Velocity, 0);
 
     probe_iter(it);
 
@@ -2046,7 +2046,7 @@ void SingleThreadStaging_match_table_created_w_new_in_progress(void) {
     ECS_SYSTEM(world, Set_velocity_on_new, EcsOnUpdate, Position);
     ECS_SYSTEM(world, On_V, EcsOnUpdate, Velocity);
 
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
 
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
@@ -2076,7 +2076,7 @@ void SingleThreadStaging_match_table_created_w_new_in_on_set(void) {
     IterData add_ctx = {.component = ecs_id(Velocity)};
     ecs_set_ctx(world, &add_ctx, NULL);
 
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
 
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
@@ -2173,8 +2173,8 @@ void Create_container_reverse(ecs_iter_t *it) {
 
     int i;
     for (i = 0; i < it->count; i ++) {
-        ecs_entity_t child = ecs_new(world, 0);
-        ecs_entity_t parent = ecs_new(world, 0);
+        ecs_entity_t child = ecs_new(world);
+        ecs_entity_t parent = ecs_new(world);
         test_assert(child != 0);
         test_assert(parent != 0);
 
@@ -2220,7 +2220,7 @@ void SingleThreadStaging_merge_table_w_container_added_on_set_reverse(void) {
 
 static
 void Task(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     ecs_entity_t *e = ecs_get_ctx(it->world);
 
@@ -2232,7 +2232,7 @@ void SingleThreadStaging_merge_after_tasks(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ECS_SYSTEM(world, Task, EcsOnUpdate, Position());
 
@@ -2247,8 +2247,8 @@ void SingleThreadStaging_merge_after_tasks(void) {
 
 static
 void OverrideAfterRemove(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2288,12 +2288,12 @@ void SingleThreadStaging_override_after_remove_in_progress(void) {
 
 static
 void GetParentInProgress(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
     
     ecs_world_t *world = it->world;
 
     /* Create parent */
-    ecs_entity_t parent = ecs_new(world, Velocity);
+    ecs_entity_t parent = ecs_new_w(world, Velocity);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2310,7 +2310,7 @@ void SingleThreadStaging_get_parent_in_progress(void) {
 
     ECS_SYSTEM(world, GetParentInProgress, EcsOnUpdate, Position, Velocity());
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_progress(world, 1);
 
@@ -2324,8 +2324,8 @@ static
 void AddInProgress(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
 
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
     
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2336,8 +2336,8 @@ void AddInProgress(ecs_iter_t *it) {
 
 static
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2355,7 +2355,7 @@ void SingleThreadStaging_merge_once(void) {
     ECS_SYSTEM(world, AddInProgress, EcsOnUpdate, Position, [out] !Velocity);
     ECS_SYSTEM(world, Move, EcsOnUpdate, Position, Velocity);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {0, 0});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {0, 0}));
     ecs_progress(world, 1);
 
     const Position *p = ecs_get(world, e, Position);
@@ -2397,7 +2397,7 @@ void SingleThreadStaging_clear_stage_after_merge(void) {
         .move = ecs_move(Position)
     });
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_defer_begin(world);
     ecs_set(world, e, Position, {10, 20});
@@ -2425,8 +2425,8 @@ void SingleThreadStaging_clear_stage_after_merge(void) {
 void MutableTest(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
 
-    Velocity *v = ecs_field(it, Velocity, 2);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    Velocity *v = ecs_field(it, Velocity, 1);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     int32_t i;
     for (i = 0; i < it->count; i ++) {
@@ -2462,7 +2462,7 @@ void SingleThreadStaging_ensureable(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_SYSTEM(world, MutableTest, EcsOnUpdate, Position, ?Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_progress(world, 0);
@@ -2491,7 +2491,7 @@ void SingleThreadStaging_ensureable_from_main(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_SYSTEM(world, MutableTest, EcsOnUpdate, Position, ?Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     // Add velocity on main stage
@@ -2519,9 +2519,9 @@ void SingleThreadStaging_ensureable_from_main(void) {
 void MutableTest_w_Add(ecs_iter_t *it) {
     ecs_world_t *world = it->world;
 
-    Velocity *v = ecs_field(it, Velocity, 2);
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
-    ecs_id_t ecs_id(MyTag) = ecs_field_id(it, 3);
+    Velocity *v = ecs_field(it, Velocity, 1);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(MyTag) = ecs_field_id(it, 2);
 
     int32_t i;
     for (i = 0; i < it->count; i ++) {
@@ -2562,7 +2562,7 @@ void SingleThreadStaging_ensureable_w_add(void) {
     ECS_COMPONENT(world, MyBool);
     ECS_SYSTEM(world, MutableTest_w_Add, EcsOnUpdate, Position, ?Velocity, MyBool());
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_progress(world, 0);
@@ -2594,7 +2594,7 @@ void SingleThreadStaging_ensureable_w_add(void) {
 
 static
 void OnAdd(ecs_iter_t *it) {
-    Velocity *v = ecs_field(it, Velocity, 1);
+    Velocity *v = ecs_field(it, Velocity, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2605,7 +2605,7 @@ void OnAdd(ecs_iter_t *it) {
 
 static
 void AddInProgress2(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2621,7 +2621,7 @@ void SingleThreadStaging_on_add_after_new_type_in_progress(void) {
     ECS_SYSTEM(world, AddInProgress2, EcsOnUpdate, Position, Velocity());
     ECS_OBSERVER(world, OnAdd, EcsOnAdd, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     ecs_progress(world, 1);
 
@@ -2641,10 +2641,10 @@ void SingleThreadStaging_lock_table(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ecs_id(Position)}}
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ecs_id(Position)}}
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -2668,10 +2668,10 @@ void SingleThreadStaging_recursive_lock_table(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ecs_id(Position)}}
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ecs_id(Position)}}
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -2695,10 +2695,10 @@ void SingleThreadStaging_modify_after_lock(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{ecs_id(Position)}}
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ecs_id(Position)}}
     });
 
     int32_t count = 0;
@@ -2718,33 +2718,7 @@ void SingleThreadStaging_modify_after_lock(void) {
     ecs_remove(world, e, Position);
     test_assert(!ecs_has(world, e, Position));
 
-    ecs_fini(world);
-}
-
-void SingleThreadStaging_get_case_from_stage(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Switch, Union);
-    ECS_TAG(world, CaseOne);
-    ECS_TAG(world, CaseTwo);
-
-    ecs_entity_t e = ecs_new_w_pair(world, Switch, CaseOne);
-
-    ecs_frame_begin(world, 1);
-
-    ecs_readonly_begin(world, false);
-
-    ecs_world_t *stage = ecs_get_stage(world, 0);
-
-    ecs_entity_t c = ecs_get_target(world, e, Switch, 0);
-    test_assert(c == CaseOne);
-
-    c = ecs_get_target(stage, e, Switch, 0);
-    test_assert(c == CaseOne);
-
-    ecs_readonly_end(world);
-
-    ecs_frame_end(world);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2752,7 +2726,7 @@ void SingleThreadStaging_get_case_from_stage(void) {
 void SingleThreadStaging_get_object_from_stage(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_id(world);
+    ecs_entity_t parent = ecs_new(world);
     ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, parent);
 
     ecs_readonly_begin(world, false);
@@ -2771,7 +2745,7 @@ void SingleThreadStaging_add_to_world_while_readonly(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_readonly_begin(world, false);
     ecs_add(world, e, Tag);
@@ -2789,7 +2763,7 @@ void SingleThreadStaging_add_to_world_and_stage_while_readonly(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_world_t *stage = ecs_get_stage(world, 0);
 
     ecs_readonly_begin(world, false);
@@ -2819,8 +2793,8 @@ void SingleThreadStaging_lookup_after_stage_count_change(void) {
 void SingleThreadStaging_lookup_w_scope_after_stage_count_change(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
-    ecs_entity_t child = ecs_new_entity(world, "child");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
+    ecs_entity_t child = ecs_entity(world, { .name = "child" });
     ecs_add_pair(world, child, EcsChildOf, parent);
 
     test_assert(ecs_lookup(world, "parent.child") != 0);
@@ -2839,15 +2813,15 @@ void SingleThreadStaging_lookup_w_scope_after_stage_count_change(void) {
 void SingleThreadStaging_with_after_stage_count_change(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t tag = ecs_new_id(world);
+    ecs_entity_t tag = ecs_new(world);
     ecs_set_with(world, tag);
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_entity(world, { 0 });
     test_assert(ecs_has_id(world, e1, tag));
 
     ecs_set_stage_count(world, 2);
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_entity(world, { 0 });
     test_assert(ecs_has_id(world, e2, tag));
 
     ecs_fini(world);
diff --git a/test/api/src/Singleton.c b/test/core/src/Singleton.c
similarity index 96%
rename from test/api/src/Singleton.c
rename to test/core/src/Singleton.c
index 5dd8394e9..fb9edd0ef 100644
--- a/test/api/src/Singleton.c
+++ b/test/core/src/Singleton.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Singleton_add_singleton(void) {
     ecs_world_t *world = ecs_mini();
@@ -66,7 +66,7 @@ void Singleton_ensure_singleton(void) {
 
 static
 void IncSingleton(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     p->x ++;
     p->y ++;
 }
diff --git a/test/api/src/StackAlloc.c b/test/core/src/StackAlloc.c
similarity index 99%
rename from test/api/src/StackAlloc.c
rename to test/core/src/StackAlloc.c
index 6852b32af..a7e342c43 100644
--- a/test/api/src/StackAlloc.c
+++ b/test/core/src/StackAlloc.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 #include "../../../src/private_api.h"
 
 void StackAlloc_init_fini(void) {
diff --git a/test/api/src/Stresstests.c b/test/core/src/Stresstests.c
similarity index 96%
rename from test/api/src/Stresstests.c
rename to test/core/src/Stresstests.c
index de0d0d0fa..4640dcc8c 100644
--- a/test/api/src/Stresstests.c
+++ b/test/core/src/Stresstests.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 #include <stdlib.h>
 
 void Stresstests_setup(void) {
@@ -59,7 +59,7 @@ void Add_random(ecs_iter_t *it) {
 
 static
 void Set_velocity_callback(ecs_iter_t *it) {
-    Velocity *v = ecs_field(it, Velocity, 1);
+    Velocity *v = ecs_field(it, Velocity, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -191,7 +191,7 @@ void Stresstests_create_delete_entity_random_components(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Rotation);
 
-    const ecs_entity_t *ids = ecs_bulk_new(world, 0, 1000);
+    const ecs_entity_t *ids = ecs_bulk_new_w_id(world, 0, 1000);
     test_assert(ids != NULL);
 
     int i;
@@ -213,7 +213,7 @@ void Stresstests_set_entity_random_components(void) {
 
     ECS_SYSTEM(world, Set_velocity_callback, EcsOnSet, Velocity);
 
-    const ecs_entity_t *ids = ecs_bulk_new(world, 0, 1000);
+    const ecs_entity_t *ids = ecs_bulk_new_w_id(world, 0, 1000);
     test_assert(ids != NULL);
 
     int i;
@@ -271,7 +271,7 @@ void Stresstests_create_2m_entities_1_comp(void) {
 
     int32_t i;
     for (i = 0; i < 2000 * 1000; i ++) {
-        ecs_entity_t e = ecs_new(world, Position);
+        ecs_entity_t e = ecs_new_w(world, Position);
         test_assert(e != 0);
         test_assert(ecs_has(world, e, Position));
     }
@@ -298,7 +298,7 @@ void Stresstests_create_2m_entities_bulk_1_comp(void) {
 void Stresstests_add_1k_tags(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     int i;
     for (i = 0; i < 1000; i ++) {
@@ -319,7 +319,7 @@ void Stresstests_create_1m_set_two_components(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     ecs_entity_t i, j;
     for (i = e; i < 1000000 + e; i ++) {
         ecs_make_alive(world, i);
diff --git a/test/api/src/Table.c b/test/core/src/Table.c
similarity index 91%
rename from test/api/src/Table.c
rename to test/core/src/Table.c
index c9adbc984..9debdda87 100644
--- a/test/api/src/Table.c
+++ b/test/core/src/Table.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 void Table_get_index(void) {
     ecs_world_t *world = ecs_mini();
@@ -6,7 +6,7 @@ void Table_get_index(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {10, 20});
     ecs_set(world, e, Velocity, {10, 20});
 
@@ -25,7 +25,7 @@ void Table_get_index_not_in_table(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {10, 20});
     ecs_set(world, e, Velocity, {10, 20});
 
@@ -44,11 +44,11 @@ void Table_get_column(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e2, Velocity, {2, 3});
 
@@ -82,7 +82,7 @@ void Table_get_column_for_tag(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     ecs_add(world, e1, Tag);
 
@@ -107,12 +107,12 @@ void Table_get_column_for_component_after_tag(void) {
 
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
     ecs_add_id(world, e1, tag_w_low_id);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e2, Velocity, {2, 3});
     ecs_add_id(world, e2, tag_w_low_id);
@@ -148,11 +148,11 @@ void Table_get_column_w_offset(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e2, Velocity, {2, 3});
 
@@ -180,11 +180,11 @@ void Table_get_id(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e2, Velocity, {2, 3});
 
@@ -212,11 +212,11 @@ void Table_get_component(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e2, Velocity, {2, 3});
 
@@ -245,11 +245,11 @@ void Table_get_pair(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_TAG(world, Tgt);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set_pair(world, e1, Position, Tgt, {10, 20});
     ecs_set_pair(world, e1, Velocity, Tgt, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set_pair(world, e2, Position, Tgt, {20, 30});
     ecs_set_pair(world, e2, Velocity, Tgt, {2, 3});
 
@@ -277,11 +277,11 @@ void Table_get_from_stage(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e2, Velocity, {2, 3});
 
@@ -310,7 +310,7 @@ void Table_get_from_stage(void) {
 void Table_get_depth(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, e2);
     ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, e3);
@@ -339,7 +339,7 @@ void Table_get_depth_non_acyclic(void) {
 void Table_get_depth_2_paths(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
     ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, e2);
@@ -359,12 +359,12 @@ void Table_get_column_size(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t ecs_id(Mass) = ecs_component(world, {
-        .entity = ecs_new_id(world),
+        .entity = ecs_new(world),
         .type.size = 4,
         .type.alignment = 4
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     ecs_add(world, e1, Tag);
     ecs_set(world, e1, Mass, {1});
diff --git a/test/api/src/Trigger.c b/test/core/src/Trigger.c
similarity index 88%
rename from test/api/src/Trigger.c
rename to test/core/src/Trigger.c
index c06f4d41b..c1a0e9184 100644
--- a/test/api/src/Trigger.c
+++ b/test/core/src/Trigger.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static int on_remove_count = 0;
 
@@ -15,7 +15,7 @@ void Trigger_w_value(ecs_iter_t *it) {
     test_assert(it->entities != NULL);
     test_assert(it->entities[0] != 0);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_int(p->x, 10);
     test_int(p->y, 20);
 }
@@ -29,7 +29,7 @@ void Trigger_w_value_from_entity(ecs_iter_t *it) {
     test_assert(it->entities[0] == 0);
     test_assert(it->sources[0] != 0);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_int(p->x, 10);
     test_int(p->y, 20);
 }
@@ -40,7 +40,7 @@ void Trigger_w_value_instanced(ecs_iter_t *it) {
 
     test_assert(it->count > 1);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_int(p->x, 10);
     test_int(p->y, 20);
 }
@@ -59,7 +59,7 @@ static
 void Trigger_n_w_values(ecs_iter_t *it) {
     probe_system_w_ctx(it, it->ctx);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     test_assert(it->entities != NULL);
 
@@ -115,14 +115,14 @@ void Trigger_on_add_trigger_before_table(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     /* Create entity/table after trigger, should invoke trigger */
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1);
@@ -146,19 +146,19 @@ void Trigger_on_add_trigger_after_table(void) {
 
     /* Create entity/before trigger */
     ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {TagA}
+        .add = ecs_ids(TagA)
     });
 
     /* Create trigger after table, should send notification to table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1);
@@ -183,14 +183,14 @@ void Trigger_on_remove_trigger_before_table(void) {
     /* Create trigger after table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     /* Create entity/table after trigger, should invoke trigger */
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 0);
@@ -217,13 +217,13 @@ void Trigger_on_remove_trigger_after_table(void) {
     ECS_TAG(world, TagA);
 
     /* Create entity/before trigger */
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     /* Create trigger after table, should send notification to table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
@@ -252,13 +252,13 @@ void Trigger_on_add_tag(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1);
@@ -282,13 +282,13 @@ void Trigger_on_add_component(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1);
@@ -313,13 +313,13 @@ void Trigger_on_add_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = EcsWildcard,
+        .query.terms[0].id = EcsWildcard,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1);
@@ -359,14 +359,14 @@ void Trigger_on_add_pair(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Pred, Obj),
+        .query.terms[0].id = ecs_pair(Pred, Obj),
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Pred, Obj)}
+        .add = ecs_ids(ecs_pair(Pred, Obj))
     });
     test_assert(e != 0);
 
@@ -393,14 +393,14 @@ void Trigger_on_add_pair_obj_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Pred, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Pred, EcsWildcard),
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Pred, ObjA)}
+        .add = ecs_ids(ecs_pair(Pred, ObjA))
     });
     test_assert(e != 0);
 
@@ -442,14 +442,14 @@ void Trigger_on_add_pair_pred_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, Obj),
+        .query.terms[0].id = ecs_pair(EcsWildcard, Obj),
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(PredA, Obj)}
+        .add = ecs_ids(ecs_pair(PredA, Obj))
     });
     test_assert(e != 0);
 
@@ -490,14 +490,14 @@ void Trigger_on_add_pair_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
+        .query.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Pred, Obj)}
+        .add = ecs_ids(ecs_pair(Pred, Obj))
     });
     test_assert(e != 0);
 
@@ -524,7 +524,7 @@ void Trigger_on_add_any(void) {
 
     Probe *ctx_any = ecs_os_calloc_t(Probe);
     ecs_entity_t t_any = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = EcsAny,
+        .query.terms[0].id = EcsAny,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = ctx_any
@@ -532,7 +532,7 @@ void Trigger_on_add_any(void) {
 
     Probe *ctx_wc = ecs_os_calloc_t(Probe);
     ecs_entity_t t_wc = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = EcsWildcard,
+        .query.terms[0].id = EcsWildcard,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = ctx_wc
@@ -540,7 +540,7 @@ void Trigger_on_add_any(void) {
 
     Probe *ctx_wc_pair = ecs_os_calloc_t(Probe);
     ecs_entity_t t_wc_pair = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
+        .query.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = ctx_wc_pair
@@ -550,7 +550,7 @@ void Trigger_on_add_any(void) {
     ecs_os_zeromem(ctx_wc);
     ecs_os_zeromem(ctx_wc_pair);
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
     test_int(ctx_any->invoked, 1);
     test_int(ctx_any->count, 1);
     test_int(ctx_any->system, t_any);
@@ -593,13 +593,13 @@ void Trigger_on_remove_tag(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -626,13 +626,13 @@ void Trigger_on_remove_component(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -660,14 +660,14 @@ void Trigger_on_remove_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = EcsWildcard,
+        .query.terms[0].id = EcsWildcard,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {TagA, TagB}
+        .add = ecs_ids(TagA, TagB)
     });
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
@@ -711,14 +711,14 @@ void Trigger_on_remove_pair(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Pred, Obj),
+        .query.terms[0].id = ecs_pair(Pred, Obj),
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Pred, Obj)}
+        .add = ecs_ids(ecs_pair(Pred, Obj))
     });
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
@@ -748,14 +748,14 @@ void Trigger_on_remove_pair_obj_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Pred, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Pred, EcsWildcard),
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Pred, ObjA), ecs_pair(Pred, ObjB)}
+        .add = ecs_ids(ecs_pair(Pred, ObjA), ecs_pair(Pred, ObjB))
     });
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
@@ -802,14 +802,14 @@ void Trigger_on_remove_pair_pred_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, Obj),
+        .query.terms[0].id = ecs_pair(EcsWildcard, Obj),
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(PredA, Obj), ecs_pair(PredB, Obj)}
+        .add = ecs_ids(ecs_pair(PredA, Obj), ecs_pair(PredB, Obj))
     });
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
@@ -853,14 +853,14 @@ void Trigger_on_remove_pair_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
+        .query.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Pred, Obj)}
+        .add = ecs_ids(ecs_pair(Pred, Obj))
     });
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
@@ -893,14 +893,14 @@ void Trigger_wildcard_pair_w_pred_component(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(ecs_id(Position), EcsWildcard),
+        .query.terms[0].id = ecs_pair(ecs_id(Position), EcsWildcard),
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
         .ctx = &ctx
     });
     test_assert(t != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.invoked, 0);
 
     ecs_set_pair(world, e, Position, ObjA, {10, 20});
@@ -948,17 +948,17 @@ void Trigger_wildcard_pair_w_obj_component(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, ecs_id(Position)),
+        .query.terms[0].id = ecs_pair(EcsWildcard, ecs_id(Position)),
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
         .ctx = &ctx
     });
     test_assert(t != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.invoked, 0);
 
-    ecs_set_pair_object(world, e, RelA, Position, {10, 20});
+    ecs_set_pair_second(world, e, RelA, Position, {10, 20});
 
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
@@ -980,7 +980,7 @@ void Trigger_wildcard_pair_w_obj_component(void) {
 
     ecs_os_zeromem(&ctx);
 
-    ecs_set_pair_object(world, e, RelB, Position, {10, 20});
+    ecs_set_pair_second(world, e, RelB, Position, {10, 20});
 
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
@@ -1002,13 +1002,13 @@ void Trigger_on_set_component(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 0);
@@ -1035,13 +1035,13 @@ void Trigger_on_set_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = EcsWildcard,
+        .query.terms[0].id = EcsWildcard,
         .events = {EcsOnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 0);
@@ -1070,14 +1070,14 @@ void Trigger_on_set_pair(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(ecs_id(Position), Obj),
+        .query.terms[0].id = ecs_pair(ecs_id(Position), Obj),
         .events = {EcsOnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(ecs_id(Position), Obj)}
+        .add = ecs_ids(ecs_pair(ecs_id(Position), Obj))
     });
     test_assert(e != 0);
 
@@ -1107,14 +1107,14 @@ void Trigger_on_set_pair_w_obj_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(ecs_id(Position), EcsWildcard),
+        .query.terms[0].id = ecs_pair(ecs_id(Position), EcsWildcard),
         .events = {EcsOnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(ecs_id(Position), Obj)}
+        .add = ecs_ids(ecs_pair(ecs_id(Position), Obj))
     });
     test_assert(e != 0);
 
@@ -1144,14 +1144,14 @@ void Trigger_on_set_pair_pred_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, Obj),
+        .query.terms[0].id = ecs_pair(EcsWildcard, Obj),
         .events = {EcsOnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(ecs_id(Position), Obj)}
+        .add = ecs_ids(ecs_pair(ecs_id(Position), Obj))
     });
     test_assert(e != 0);
 
@@ -1181,7 +1181,7 @@ void Trigger_on_set_pair_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
+        .query.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
         .events = {EcsOnSet},
         .callback = Trigger,
         .ctx = &ctx
@@ -1191,7 +1191,7 @@ void Trigger_on_set_pair_wildcard(void) {
     ecs_os_zeromem(&ctx);
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(ecs_id(Position), Obj)}
+        .add = ecs_ids(ecs_pair(ecs_id(Position), Obj))
     });
     test_assert(e != 0);
 
@@ -1220,13 +1220,13 @@ void Trigger_on_add_remove(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd, EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1);
@@ -1265,13 +1265,13 @@ void Trigger_on_set_component_after_modified(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 0);
@@ -1299,13 +1299,13 @@ void Trigger_un_set_component(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsUnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 0);
@@ -1333,13 +1333,13 @@ void Trigger_un_set_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = EcsWildcard,
+        .query.terms[0].id = EcsWildcard,
         .events = {EcsUnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 0);
@@ -1371,14 +1371,14 @@ void Trigger_un_set_pair(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, Obj),
+        .query.terms[0].id = ecs_pair(Rel, Obj),
         .events = {EcsUnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)}
+        .add = ecs_ids(ecs_pair(Rel, Obj))
     });
     test_assert(e != 0);
 
@@ -1411,14 +1411,14 @@ void Trigger_un_set_pair_w_obj_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard),
         .events = {EcsUnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)}
+        .add = ecs_ids(ecs_pair(Rel, Obj))
     });
     test_assert(e != 0);
 
@@ -1451,14 +1451,14 @@ void Trigger_un_set_pair_pred_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, Obj),
+        .query.terms[0].id = ecs_pair(EcsWildcard, Obj),
         .events = {EcsUnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)}
+        .add = ecs_ids(ecs_pair(Rel, Obj))
     });
     test_assert(e != 0);
 
@@ -1491,14 +1491,14 @@ void Trigger_un_set_pair_wildcard(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
+        .query.terms[0].id = ecs_pair(EcsWildcard, EcsWildcard),
         .events = {EcsUnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {ecs_pair(Rel, Obj)}
+        .add = ecs_ids(ecs_pair(Rel, Obj))
     });
     test_assert(e != 0);
 
@@ -1530,14 +1530,14 @@ void Trigger_on_add_not_tag(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].oper = EcsNot,
+        .query.terms[0].id = TagA,
+        .query.terms[0].oper = EcsNot,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -1570,14 +1570,14 @@ void Trigger_on_remove_not_tag(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].oper = EcsNot,
+        .query.terms[0].id = TagA,
+        .query.terms[0].oper = EcsNot,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
@@ -1606,17 +1606,18 @@ void Trigger_on_add_superset(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].src.flags = EcsUp,
+        .query.terms[0].id = TagA,
+        .query.terms[0].src.id = EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t base_no_comp = ecs_new_id(world);
+    ecs_entity_t base_no_comp = ecs_new(world);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base = ecs_new(world, TagA);
+    ecs_entity_t base = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
 
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base_no_comp);
@@ -1653,17 +1654,18 @@ void Trigger_on_add_superset_2_levels(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].src.flags = EcsUp,
+        .query.terms[0].id = TagA,
+        .query.terms[0].src.id = EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t base_no_comp = ecs_new_id(world);
+    ecs_entity_t base_no_comp = ecs_new(world);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base_of_base = ecs_new(world, TagA);
+    ecs_entity_t base_of_base = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
 
     ecs_entity_t base = ecs_new_w_pair(world, EcsIsA, base_of_base);
@@ -1704,17 +1706,18 @@ void Trigger_on_remove_superset(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].src.flags = EcsUp,
+        .query.terms[0].id = TagA,
+        .query.terms[0].src.id = EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t base_no_comp = ecs_new_id(world);
+    ecs_entity_t base_no_comp = ecs_new(world);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base = ecs_new(world, TagA);
+    ecs_entity_t base = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
 
     ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, base_no_comp);
@@ -1753,20 +1756,20 @@ void Trigger_on_add_superset_childof(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = TagA,
-            .src.trav = EcsChildOf,
-            .src.flags = EcsUp
+            .trav = EcsChildOf,
+            .src.id = EcsUp
         },
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t base_no_comp = ecs_new_id(world);
+    ecs_entity_t base_no_comp = ecs_new(world);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base = ecs_new(world, TagA);
+    ecs_entity_t base = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
 
     ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, base_no_comp);
@@ -1802,20 +1805,20 @@ void Trigger_on_remove_superset_childof(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = TagA,
-            .src.trav = EcsChildOf,
-            .src.flags = EcsUp
+            .trav = EcsChildOf,
+            .src.id = EcsUp
         },
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t base_no_comp = ecs_new_id(world);
+    ecs_entity_t base_no_comp = ecs_new(world);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base = ecs_new(world, TagA);
+    ecs_entity_t base = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
 
     ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, base_no_comp);
@@ -1854,17 +1857,18 @@ void Trigger_on_add_self_superset(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].src.flags = EcsSelf | EcsUp,
+        .query.terms[0].id = TagA,
+        .query.terms[0].src.id = EcsSelf | EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t base_no_comp = ecs_new_id(world);
+    ecs_entity_t base_no_comp = ecs_new(world);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base = ecs_new(world, TagA);
+    ecs_entity_t base = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
     test_int(ctx.system, t);
@@ -1927,17 +1931,18 @@ void Trigger_on_remove_self_superset(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].src.flags = EcsSelf | EcsUp,
+        .query.terms[0].id = TagA,
+        .query.terms[0].src.id = EcsSelf | EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t base_no_comp = ecs_new_id(world);
+    ecs_entity_t base_no_comp = ecs_new(world);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base = ecs_new(world, TagA);
+    ecs_entity_t base = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
 
     ecs_os_zeromem(&ctx);
@@ -2002,13 +2007,13 @@ void Trigger_add_twice(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1);
@@ -2038,13 +2043,13 @@ void Trigger_remove_twice(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -2076,13 +2081,13 @@ void Trigger_on_remove_w_clear(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -2109,13 +2114,13 @@ void Trigger_on_remove_w_delete(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -2142,13 +2147,13 @@ void Trigger_on_remove_w_world_fini(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
     test_int(ctx.invoked, 0);
 
@@ -2173,13 +2178,13 @@ void Trigger_on_add_w_clone(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1);
@@ -2218,13 +2223,13 @@ void Trigger_add_in_trigger(void) {
     ECS_TAG(world, TagB);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = TriggerAdd,
         .ctx = &TagB
     });
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_assert(ecs_has_id(world, e, TagB));
@@ -2239,14 +2244,14 @@ void Trigger_remove_in_trigger(void) {
     ECS_TAG(world, TagB);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = TriggerRemove,
         .ctx = &TagB
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {TagA, TagB}
+        .add = ecs_ids(TagA, TagB)
     });
     test_assert(e != 0);
 
@@ -2262,13 +2267,13 @@ void Trigger_clear_in_trigger(void) {
     ECS_TAG(world, TagB);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = TriggerClear,
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {TagA, TagB}
+        .add = ecs_ids(TagA, TagB)
     });
     test_assert(e != 0);
 
@@ -2285,13 +2290,13 @@ void Trigger_delete_in_trigger(void) {
     ECS_TAG(world, TagB);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = TriggerDelete,
     });
 
     ecs_entity_t e = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = {TagA, TagB}
+        .add = ecs_ids(TagA, TagB)
     });
     test_assert(e != 0);
 
@@ -2309,14 +2314,14 @@ void Trigger_trigger_w_named_entity(void) {
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
         .entity = ecs_entity(world, {.name = "MyTrigger"}),
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
     /* Create entity/table after trigger, should invoke trigger */
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
 
     test_int(ctx.invoked, 1);
@@ -2325,10 +2330,10 @@ void Trigger_trigger_w_named_entity(void) {
 }
 
 void RemoveSelf(ecs_iter_t *it) {
-    Self *s = ecs_field(it, Self, 1);
+    Self *s = ecs_field(it, Self, 0);
     test_assert(s != NULL);
 
-    ecs_id_t ecs_id(Self) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Self) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -2352,7 +2357,7 @@ void Trigger_on_remove_tree(void) {
 
     ECS_OBSERVER(world, RemoveSelf, EcsOnRemove, Self);
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, root);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, e1);
@@ -2402,7 +2407,7 @@ void Trigger_set_get_context(void) {
     int32_t ctx_a, ctx_b;
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
         .entity = ecs_entity(world, {.name = "MyTrigger"}),
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx_a
@@ -2429,7 +2434,7 @@ void Trigger_set_get_binding_context(void) {
     int32_t ctx_a, ctx_b;
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
         .entity = ecs_entity(world, {.name = "MyTrigger"}),
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .binding_ctx = &ctx_a
@@ -2468,7 +2473,7 @@ void Trigger_delete_trigger_w_delete_ctx(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx_value,
@@ -2496,7 +2501,7 @@ void Trigger_trigger_w_index(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .term_index = 50,
         .events = {EcsOnAdd},
         .callback = Trigger,
@@ -2504,7 +2509,7 @@ void Trigger_trigger_w_index(void) {
     });
     test_assert(t != 0);
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     test_int(ctx.invoked, 1);
     test_int(ctx.term_index, 50);
@@ -2525,14 +2530,14 @@ void Trigger_iter_type_set(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnAdd},
         .callback = TypeTrigger,
         .ctx = &ctx
     });
     test_assert(t != 0);
 
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
 
     test_assert(trigger_table != NULL);
     const ecs_type_t *type = ecs_table_get_type(trigger_table);
@@ -2544,7 +2549,7 @@ void Trigger_iter_type_set(void) {
 
 void TriggerReadonly(ecs_iter_t *it) {
     probe_system_w_ctx(it, it->ctx);
-    test_bool(ecs_field_is_readonly(it, 1), true);
+    test_bool(ecs_field_is_readonly(it, 0), true);
 }
 
 void Trigger_readonly_term(void) {
@@ -2554,13 +2559,13 @@ void Trigger_readonly_term(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { TagA, .inout = EcsIn },
+        .query.terms[0] = { TagA, .inout = EcsIn },
         .events = {EcsOnAdd},
         .callback = TriggerReadonly,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     ecs_add(world, e, TagA);
 
@@ -2587,20 +2592,20 @@ void Trigger_trigger_on_prefab(void) {
     Probe ctx_2 = {0};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { TagA },
+        .query.terms[0] = { TagA },
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx_1
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }, { EcsPrefab, .oper = EcsOptional }},
+        .query.terms = {{ TagA }, { EcsPrefab, .oper = EcsOptional }},
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx_2
     });
 
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
     test_int(ctx_1.invoked, 1);
     test_int(ctx_2.invoked, 1);
     ecs_os_zeromem(&ctx_1);
@@ -2633,20 +2638,20 @@ void Trigger_trigger_on_disabled(void) {
     Probe ctx_2 = {0};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { TagA },
+        .query.terms[0] = { TagA },
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx_1
     });
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms = {{ TagA }, { EcsDisabled, .oper = EcsOptional }},
+        .query.terms = {{ TagA }, { EcsDisabled, .oper = EcsOptional }},
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx_2
     });
 
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
     test_int(ctx_1.invoked, 1);
     test_int(ctx_2.invoked, 1);
     ecs_os_zeromem(&ctx_1);
@@ -2676,7 +2681,7 @@ void Trigger_trigger_on_prefab_tag(void) {
     Probe ctx_1 = {0};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { EcsPrefab },
+        .query.terms[0] = { EcsPrefab },
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx_1
@@ -2694,7 +2699,7 @@ void Trigger_trigger_on_disabled_tag(void) {
     Probe ctx_1 = {0};
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { EcsDisabled },
+        .query.terms[0] = { EcsDisabled },
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx_1
@@ -2712,13 +2717,13 @@ void Trigger_trigger_cleanup_2_w_self_super_id(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { .id = Tag, .src.flags = EcsUp },
+        .query.terms[0] = { .id = Tag, .src.id = EcsUp },
         .events = { EcsOnAdd },
         .callback = Trigger
     });
 
     ecs_entity_t t2 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { Tag },
+        .query.terms[0] = { Tag },
         .events = { EcsOnAdd },
         .callback = Trigger
     });
@@ -2737,9 +2742,9 @@ void Trigger_on_add_yield_existing(void) {
     ECS_TAG(world, Tag);
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
 
     test_assert(e1 != 0);
     test_assert(e2 != 0);
@@ -2747,7 +2752,7 @@ void Trigger_on_add_yield_existing(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx,
@@ -2769,7 +2774,7 @@ void Trigger_on_add_yield_existing(void) {
 
     // Ensure normal triggering also still works
     ecs_os_zeromem(&ctx);
-    ecs_new(world, Tag);
+    ecs_new_w(world, Tag);
     test_int(ctx.invoked, 1);
 
     ecs_fini(world);
@@ -2782,9 +2787,9 @@ void Trigger_on_add_yield_existing_2_tables(void) {
     ECS_TAG(world, TagB);
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_new(world, TagA);
-    ecs_entity_t e2 = ecs_new(world, TagA);
-    ecs_entity_t e3 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
 
     test_assert(e1 != 0);
     test_assert(e2 != 0);
@@ -2794,7 +2799,7 @@ void Trigger_on_add_yield_existing_2_tables(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx,
@@ -2817,7 +2822,7 @@ void Trigger_on_add_yield_existing_2_tables(void) {
 
     // Ensure normal triggering also still works
     ecs_os_zeromem(&ctx);
-    ecs_new(world, TagA);
+    ecs_new_w(world, TagA);
     test_int(ctx.invoked, 1);
 
     ecs_fini(world);
@@ -2841,7 +2846,7 @@ void Trigger_on_add_yield_existing_wildcard_pair(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard),
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx,
@@ -2876,9 +2881,9 @@ void Trigger_on_set_yield_existing(void) {
     ECS_COMPONENT(world, Position);
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {50, 60});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {50, 60}));
 
     test_assert(e1 != 0);
     test_assert(e2 != 0);
@@ -2886,7 +2891,7 @@ void Trigger_on_set_yield_existing(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnSet},
         .callback = Trigger_n_w_values,
         .ctx = &ctx,
@@ -2908,7 +2913,7 @@ void Trigger_on_set_yield_existing(void) {
 
     // Ensure normal triggering also still works
     ecs_os_zeromem(&ctx);
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -2925,14 +2930,14 @@ void Trigger_filter_term(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = { .id = ecs_id(Position), .inout = EcsInOutNone },
+        .query.terms[0] = { .id = ecs_id(Position), .inout = EcsInOutNone },
         .events = {EcsOnSet},
         .callback = Trigger_w_filter_term,
         .ctx = &ctx
     });
 
     /* Create entities before trigger */
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(e1 != 0);
 
     test_int(ctx.invoked, 1);
@@ -2958,7 +2963,7 @@ void Trigger_on_add_remove_after_exclusive_add(void) {
 
     Probe ctx_add = {0};
     ecs_entity_t t_add = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard),
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx_add
@@ -2966,13 +2971,13 @@ void Trigger_on_add_remove_after_exclusive_add(void) {
 
     Probe ctx_remove = {0};
     ecs_entity_t t_remove = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard),
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx_remove
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_pair(world, e, Rel, ObjA);
     test_assert( ecs_has_pair(world, e, Rel, ObjA));
@@ -3021,7 +3026,7 @@ void Trigger_on_add_base(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA, /* Implicitly also listens to IsA */
+        .query.terms[0].id = TagA, /* Implicitly also listens to IsA */
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
@@ -3061,7 +3066,7 @@ void Trigger_on_remove_base(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA, /* Implicitly also listens to IsA */
+        .query.terms[0].id = TagA, /* Implicitly also listens to IsA */
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx
@@ -3105,7 +3110,7 @@ void Trigger_on_set_base(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
+        .query.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
         .ctx = &ctx
@@ -3156,7 +3161,7 @@ void Trigger_on_unset_base(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
+        .query.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
         .events = {EcsUnSet},
         .callback = Trigger_w_value,
         .ctx = &ctx
@@ -3199,8 +3204,9 @@ void Trigger_on_add_base_superset_trigger(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].src.flags = EcsUp,
+        .query.terms[0].id = TagA,
+        .query.terms[0].src.id = EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
@@ -3238,8 +3244,9 @@ void Trigger_on_add_base_superset_trigger_2_lvls(void) {
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
-        .filter.terms[0].src.flags = EcsUp,
+        .query.terms[0].id = TagA,
+        .query.terms[0].src.id = EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
@@ -3282,7 +3289,7 @@ void Trigger_on_add_base_2_entities(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA, /* Implicitly also listens to IsA */
+        .query.terms[0].id = TagA, /* Implicitly also listens to IsA */
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
@@ -3324,8 +3331,8 @@ void Trigger_on_add_base_2_entities_filter(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA, /* Implicitly also listens to IsA */
-        .filter.terms[0].inout = EcsInOutNone,
+        .query.terms[0].id = TagA, /* Implicitly also listens to IsA */
+        .query.terms[0].inout = EcsInOutNone,
         .events = {EcsOnAdd},
         .callback = Trigger_w_filter_term,
         .ctx = &ctx
@@ -3367,7 +3374,7 @@ void Trigger_on_set_base_w_value_2_entities(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
+        .query.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
         .ctx = &ctx
@@ -3419,8 +3426,8 @@ void Trigger_on_set_base_w_value_2_entities_instanced(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
-        .filter.instanced = true,
+        .query.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
+        .query.flags = EcsQueryIsInstanced,
         .events = {EcsOnSet},
         .callback = Trigger_w_value_instanced,
         .ctx = &ctx
@@ -3472,7 +3479,7 @@ void Trigger_on_add_base_w_override(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA, /* Implicitly also listens to IsA */
+        .query.terms[0].id = TagA, /* Implicitly also listens to IsA */
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
@@ -3527,7 +3534,7 @@ void Trigger_on_set_base_w_override(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
+        .query.terms[0].id = ecs_id(Position), /* Implicitly also listens to IsA */
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
         .ctx = &ctx
@@ -3579,14 +3586,14 @@ void Trigger_entity_source_1_trigger(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t subj = ecs_new_id(world);
-    ecs_entity_t dummy = ecs_new_id(world);
+    ecs_entity_t subj = ecs_new(world);
+    ecs_entity_t dummy = ecs_new(world);
 
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
-        .filter.terms[0].src.id = subj,
+        .query.terms[0].id = ecs_id(Position),
+        .query.terms[0].src.id = subj,
         .events = {EcsOnSet},
         .callback = Trigger_w_value_from_entity,
         .ctx = &ctx
@@ -3614,23 +3621,23 @@ void Trigger_entity_source_2_triggers(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t subj_a = ecs_new_id(world);
-    ecs_entity_t subj_b = ecs_new_id(world);
-    ecs_entity_t dummy = ecs_new_id(world);
+    ecs_entity_t subj_a = ecs_new(world);
+    ecs_entity_t subj_b = ecs_new(world);
+    ecs_entity_t dummy = ecs_new(world);
 
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
-        .filter.terms[0].src.id = subj_a,
+        .query.terms[0].id = ecs_id(Position),
+        .query.terms[0].src.id = subj_a,
         .events = {EcsOnSet},
         .callback = Trigger_w_value_from_entity,
         .ctx = &ctx
     });
 
     ecs_entity_t t2 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
-        .filter.terms[0].src.id = subj_b,
+        .query.terms[0].id = ecs_id(Position),
+        .query.terms[0].src.id = subj_b,
         .events = {EcsOnSet},
         .callback = Trigger_w_value_from_entity,
         .ctx = &ctx
@@ -3679,8 +3686,8 @@ void Trigger_entity_source_base_set(void) {
     /* Create trigger before table */
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
-        .filter.terms[0].src.id = subj,
+        .query.terms[0].id = ecs_id(Position),
+        .query.terms[0].src.id = subj,
         .events = {EcsOnSet},
         .callback = Trigger_w_value_from_entity,
         .ctx = &ctx
@@ -3713,15 +3720,16 @@ void Trigger_not_from_superset(void) {
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
-        .filter.terms[0].oper = EcsNot,
-        .filter.terms[0].src.flags = EcsUp,
+        .query.terms[0].id = Tag,
+        .query.terms[0].oper = EcsNot,
+        .query.terms[0].src.id = EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
     });
 
-    ecs_entity_t base = ecs_new(world, Tag);
+    ecs_entity_t base = ecs_new_w(world, Tag);
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
     test_int(ctx.invoked, 0);
 
@@ -3741,8 +3749,8 @@ void Trigger_create_stresstest(void) {
      * builds don't detect leaks that are cleaned up @ ecs_fini). */
     for (int i = 0; i < 100 * 1000; i ++) {
         ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-            .filter.terms[0].id = Tag,
-            .filter.terms[0].src.flags = EcsSelf | EcsUp,
+            .query.terms[0].id = Tag,
+            .query.terms[0].src.id = EcsSelf | EcsUp,
             .events = {EcsOnAdd},
             .callback = Trigger
         });
@@ -3767,13 +3775,13 @@ void Trigger_add_non_existing_entity(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard),
         .events = {EcsOnAdd},
         .callback = Trigger_w_new_entity_value,
         .ctx = &ctx
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, Rel, 1000);
 
     test_assert( ecs_has_pair(world, e, Rel, 1000));
@@ -3797,8 +3805,8 @@ void Trigger_on_add_self_trigger_with_add_isa(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
-        .filter.terms[0].src.flags = EcsSelf,
+        .query.terms[0].id = Tag,
+        .query.terms[0].src.id = EcsSelf,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
@@ -3807,13 +3815,13 @@ void Trigger_on_add_self_trigger_with_add_isa(void) {
     test_assert(t1 != 0);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_add(world, base, Tag);
     test_int(ctx.invoked, 1);
 
     ctx = (Probe){0};
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base);
     test_int(ctx.invoked, 0);
 
@@ -3827,8 +3835,8 @@ void Trigger_on_set_self_trigger_with_add_isa(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
-        .filter.terms[0].src.flags = EcsSelf,
+        .query.terms[0].id = ecs_id(Position),
+        .query.terms[0].src.id = EcsSelf,
         .events = {EcsOnSet},
         .callback = Trigger,
         .ctx = &ctx
@@ -3837,12 +3845,12 @@ void Trigger_on_set_self_trigger_with_add_isa(void) {
     test_assert(t1 != 0);
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_int(ctx.invoked, 1);
 
     ctx = (Probe){0};
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_pair(world, e, EcsIsA, base);
     test_int(ctx.invoked, 0);
 
@@ -3883,14 +3891,14 @@ void Trigger_notify_propagated_twice(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = TriggerTwice,
         .ctx = &ctx
     });
     test_assert(t1 != 0);
 
-    base_ent = ecs_new_id(world);
+    base_ent = ecs_new(world);
     inst_ent_a = ecs_new_w_pair(world, EcsIsA, base_ent);
     ecs_add(world, inst_ent_a, TagB);
     inst_ent_b = ecs_new_w_pair(world, EcsIsA, base_ent);
@@ -3912,14 +3920,15 @@ void Trigger_trigger_superset_wildcard(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t base = ecs_new_id(world);
-    ecs_entity_t inst = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
+    ecs_entity_t inst = ecs_new(world);
     ecs_add_pair(world, inst, EcsIsA, base);
 
     Probe ctx = {0};
     ecs_entity_t t = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard), 
-        .filter.terms[0].src.flags = EcsUp,
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard), 
+        .query.terms[0].src.id = EcsUp,
+        .query.terms[0].trav = EcsIsA,
         .events = {EcsOnAdd},
         .callback = Trigger,
         .ctx = &ctx
@@ -3967,7 +3976,7 @@ void Trigger_remove_wildcard_1_id(void) {
 
     Probe ctx_a = {0};
     ecs_entity_t t_a = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, ObjA), 
+        .query.terms[0].id = ecs_pair(Rel, ObjA), 
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx_a
@@ -3976,7 +3985,7 @@ void Trigger_remove_wildcard_1_id(void) {
 
     Probe ctx_b = {0};
     ecs_entity_t t_b = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard),
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard),
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = &ctx_b
@@ -4026,7 +4035,7 @@ void Trigger_remove_wildcard_2_ids(void) {
 
     Probe *ctx_a = &ctx_array[0];
     ecs_entity_t t_a = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, EcsWildcard), 
+        .query.terms[0].id = ecs_pair(Rel, EcsWildcard), 
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = ctx_a
@@ -4035,7 +4044,7 @@ void Trigger_remove_wildcard_2_ids(void) {
 
     Probe *ctx_b = &ctx_array[1];
     ecs_entity_t t_b = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, ObjA),
+        .query.terms[0].id = ecs_pair(Rel, ObjA),
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = ctx_b
@@ -4044,7 +4053,7 @@ void Trigger_remove_wildcard_2_ids(void) {
 
     Probe *ctx_c = &ctx_array[2];
     ecs_entity_t t_c = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_pair(Rel, ObjB),
+        .query.terms[0].id = ecs_pair(Rel, ObjB),
         .events = {EcsOnRemove},
         .callback = Trigger,
         .ctx = ctx_c
@@ -4096,14 +4105,14 @@ void Trigger_on_set_w_tag(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnSet},
         .callback = Trigger,
         .ctx = &ctx
     });
     test_assert(t1 != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, TagA);
@@ -4134,16 +4143,16 @@ static void CreateTriggers(ecs_iter_t *it) {
 
     create_trigger_invoked ++;
 
-    ctx->first = ecs_new_id(it->world);
+    ctx->first = ecs_new(it->world);
 
     int i;
     for (i = 0; i < ctx->count - 1; i ++) {
-        ecs_new_id(it->world);
+        ecs_new(it->world);
     }
 
     for (i = 0; i < ctx->count; i ++) {
         ecs_observer_init(it->world, &(ecs_observer_desc_t){
-            .filter.terms[0].id = ctx->first + i,
+            .query.terms[0].id = ctx->first + i,
             .events = {EcsOnAdd},
             .callback = NestedTrigger
         });
@@ -4160,14 +4169,14 @@ void Trigger_create_triggers_in_trigger(void) {
 
     CreateTriggers_ctx ctx = { .count = CreateCount };
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnAdd},
         .callback = CreateTriggers,
         .ctx = &ctx
     });
     test_assert(t1 != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, TagA);
@@ -4176,7 +4185,7 @@ void Trigger_create_triggers_in_trigger(void) {
 
     int i;
     for (i = 0; i < CreateCount; i ++) {
-        ecs_entity_t t = ecs_new_id(world);
+        ecs_entity_t t = ecs_new(world);
         ecs_add_id(world, t, ctx.first + i);
         test_int(nested_trigger_invoked, i + 1);
     }
@@ -4195,7 +4204,7 @@ void Trigger_w_nonzero_value(ecs_iter_t *it) {
     test_assert(it->entities != NULL);
     test_assert(it->entities[0] != 0);
 
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     test_assert(p != NULL);
 }
 
@@ -4206,13 +4215,13 @@ void Trigger_on_add_superset_w_component(void) {
 
     Probe ctx = {0};
 	ecs_observer_init(world, &(ecs_observer_desc_t){
-		.filter.terms[0].id = ecs_id(Position),
+		.query.terms[0].id = ecs_id(Position),
 		.events = {EcsOnAdd},
 		.callback = Trigger_w_nonzero_value,
         .ctx = &ctx
 	});
 
-	ecs_entity_t b = ecs_new(world, 0);
+	ecs_entity_t b = ecs_new(world);
 	ecs_set(world, b, Position, {10, 20});
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
@@ -4237,13 +4246,13 @@ void Trigger_on_set_superset_w_component(void) {
 
     Probe ctx = {0};
 	ecs_observer_init(world, &(ecs_observer_desc_t){
-		.filter.terms[0].id = ecs_id(Position),
+		.query.terms[0].id = ecs_id(Position),
 		.events = {EcsOnSet},
 		.callback = Trigger_w_value,
         .ctx = &ctx
 	});
 
-	ecs_entity_t b = ecs_new(world, 0);
+	ecs_entity_t b = ecs_new(world);
 	ecs_set(world, b, Position, {10, 20});
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
@@ -4268,20 +4277,21 @@ void Trigger_on_add_base_superset_w_owned(void) {
 
     Probe ctx = {0};
 	ecs_observer_init(world, &(ecs_observer_desc_t){
-		.filter.terms[0] = {
+		.query.terms[0] = {
             .id = ecs_id(Tag),
-            .src.flags = EcsUp,
+            .src.id = EcsUp,
+            .trav = EcsIsA,
         },
 		.events = {EcsOnAdd},
 		.callback = Trigger,
         .ctx = &ctx
 	});
 
-	ecs_entity_t b = ecs_new(world, 0);
+	ecs_entity_t b = ecs_new(world);
 	ecs_add(world, b, Tag);
     test_int(ctx.invoked, 0);
 	
-	ecs_entity_t i = ecs_new(world, Tag);
+	ecs_entity_t i = ecs_new_w(world, Tag);
     test_int(ctx.invoked, 0);
     
     ecs_add_pair(world, i, EcsIsA, b);
@@ -4300,16 +4310,17 @@ void Trigger_on_add_base_self_superset_w_owned(void) {
 
     Probe ctx = {0};
 	ecs_observer_init(world, &(ecs_observer_desc_t){
-		.filter.terms[0] = {
+		.query.terms[0] = {
             .id = ecs_id(Tag),
-            .src.flags = EcsSelf|EcsUp,
+            .src.id = EcsSelf|EcsUp,
+            .trav = EcsIsA,
         },
 		.events = {EcsOnAdd},
 		.callback = Trigger,
         .ctx = &ctx
 	});
 
-	ecs_entity_t b = ecs_new(world, 0);
+	ecs_entity_t b = ecs_new(world);
 	ecs_add(world, b, Tag);
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
@@ -4318,7 +4329,7 @@ void Trigger_on_add_base_self_superset_w_owned(void) {
 
     ecs_os_zeromem(&ctx);
 	
-	ecs_entity_t i1 = ecs_new(world, Tag);
+	ecs_entity_t i1 = ecs_new_w(world, Tag);
     test_int(ctx.invoked, 1);
     test_int(ctx.count, 1);
     test_int(ctx.e[0], i1);
@@ -4344,16 +4355,17 @@ void Trigger_on_set_self_from_child_of_prefab(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t base = ecs_new_w_id(world, EcsPrefab);
-    ecs_entity_t base_child = ecs_new_entity(world, "Child");
+    ecs_entity_t base_child = ecs_entity(world, { .name = "Child" });
     ecs_add_id(world, base_child, EcsPrefab);
     ecs_add_pair(world, base_child, EcsChildOf, base);
     ecs_set(world, base_child, Position, {10, 20});
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = ecs_id(Position),
-            .src.flags = EcsSelf
+            .src.id = EcsSelf,
+            .trav = EcsIsA,
         },
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
@@ -4381,16 +4393,17 @@ void Trigger_on_set_self_superset_from_child_of_prefab(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t base = ecs_new_w_id(world, EcsPrefab);
-    ecs_entity_t base_child = ecs_new_entity(world, "Child");
+    ecs_entity_t base_child = ecs_entity(world, { .name = "Child" });
     ecs_add_id(world, base_child, EcsPrefab);
     ecs_add_pair(world, base_child, EcsChildOf, base);
     ecs_set(world, base_child, Position, {10, 20});
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = ecs_id(Position),
-            .src.flags = EcsSelf | EcsUp
+            .src.id = EcsSelf|EcsUp,
+            .trav = EcsIsA,
         },
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
@@ -4421,15 +4434,15 @@ void Trigger_on_set_self_from_child_base_of_prefab(void) {
     ecs_add_id(world, base_child_base, EcsPrefab);
     ecs_set(world, base_child_base, Position, {10, 20});
 
-    ecs_entity_t base_child = ecs_new_entity(world, "Child");
+    ecs_entity_t base_child = ecs_entity(world, { .name = "Child" });
     ecs_add_pair(world, base_child, EcsChildOf, base);
     ecs_add_pair(world, base_child, EcsIsA, base_child_base);
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = ecs_id(Position),
-            .src.flags = EcsSelf
+            .src.id = EcsSelf
         },
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
@@ -4457,15 +4470,16 @@ void Trigger_on_set_self_superset_from_child_base_of_prefab(void) {
     ecs_add_id(world, base_child_base, EcsPrefab);
     ecs_set(world, base_child_base, Position, {10, 20});
 
-    ecs_entity_t base_child = ecs_new_entity(world, "Child");
+    ecs_entity_t base_child = ecs_entity(world, { .name = "Child" });
     ecs_add_pair(world, base_child, EcsChildOf, base);
     ecs_add_pair(world, base_child, EcsIsA, base_child_base);
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = ecs_id(Position),
-            .src.flags = EcsSelf | EcsUp
+            .src.id = EcsSelf|EcsUp,
+            .trav = EcsIsA
         },
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
@@ -4491,14 +4505,14 @@ void Trigger_on_set_self_auto_override(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_id(Position));
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = ecs_id(Position),
-            .src.flags = EcsSelf
+            .src.id = EcsSelf
         },
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
@@ -4522,14 +4536,15 @@ void Trigger_on_set_self_superset_auto_override(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_id(Position));
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = ecs_id(Position),
-            .src.flags = EcsSelf | EcsUp
+            .src.id = EcsSelf|EcsUp,
+            .trav = EcsIsA,
         },
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
@@ -4553,14 +4568,15 @@ void Trigger_on_set_superset_auto_override(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_add_id(world, base, ECS_OVERRIDE | ecs_id(Position));
 
     Probe ctx = {0};
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
+        .query.terms[0] = {
             .id = ecs_id(Position),
-            .src.flags = EcsUp
+            .src.id = EcsUp,
+            .trav = EcsIsA,
         },
         .events = {EcsOnSet},
         .callback = Trigger_w_value,
@@ -4587,7 +4603,7 @@ void Trigger_not_only(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA, .oper = EcsNot }
         },
         .events = { EcsOnAdd },
@@ -4597,7 +4613,7 @@ void Trigger_not_only(void) {
 
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t i = ecs_new(world, TagA);
+    ecs_entity_t i = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
 
     ecs_delete(world, i);
@@ -4613,7 +4629,7 @@ void Trigger_not_only_w_base(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagA, .oper = EcsNot }
         },
         .events = { EcsOnAdd },
@@ -4623,7 +4639,7 @@ void Trigger_not_only_w_base(void) {
 
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t p = ecs_new(world, TagA);
+    ecs_entity_t p = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
 
     ecs_entity_t i = ecs_new_w_pair(world, EcsIsA, p);
@@ -4643,7 +4659,7 @@ void Trigger_not_only_w_base_no_match(void) {
 
     Probe ctx = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { TagB, .oper = EcsNot }
         },
         .events = { EcsOnAdd },
@@ -4653,7 +4669,7 @@ void Trigger_not_only_w_base_no_match(void) {
 
     test_int(ctx.invoked, 0);
 
-    ecs_entity_t p = ecs_new(world, TagA);
+    ecs_entity_t p = ecs_new_w(world, TagA);
     test_int(ctx.invoked, 0);
 
     ecs_entity_t i = ecs_new_w_pair(world, EcsIsA, p);
@@ -4672,10 +4688,10 @@ void Trigger_on_set_superset_after_filter_observer(void) {
 
     Probe ctx_1 = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { ecs_id(Position) }
         },
-        .filter.flags = EcsFilterNoData,
+        .query.flags = EcsQueryNoData,
         .events = { EcsOnSet },
         .callback = Trigger,
         .ctx = &ctx_1
@@ -4683,15 +4699,15 @@ void Trigger_on_set_superset_after_filter_observer(void) {
 
     Probe ctx_2 = {0};
     ecs_observer(world, {
-        .filter.terms = {
-            { ecs_id(Position), .src.flags = EcsUp }
+        .query.terms = {
+            { ecs_id(Position), .src.id = EcsUp, .trav = EcsIsA }
         },
         .events = { EcsOnSet },
         .callback = Trigger_w_value,
         .ctx = &ctx_2
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
 
     test_int(ctx_1.invoked, 0);
@@ -4717,10 +4733,10 @@ void Trigger_on_set_superset_after_filter_observer_w_on_add(void) {
 
     Probe ctx_1 = {0};
     ecs_observer(world, {
-        .filter.terms = {
+        .query.terms = {
             { ecs_id(Position) }
         },
-        .filter.flags = EcsFilterNoData,
+        .query.flags = EcsQueryNoData,
         .events = { EcsOnAdd },
         .callback = Trigger,
         .ctx = &ctx_1
@@ -4728,15 +4744,15 @@ void Trigger_on_set_superset_after_filter_observer_w_on_add(void) {
 
     Probe ctx_2 = {0};
     ecs_observer(world, {
-        .filter.terms = {
-            { ecs_id(Position), .src.flags = EcsUp }
+        .query.terms = {
+            { ecs_id(Position), .src.id = EcsUp, .trav = EcsIsA }
         },
         .events = { EcsOnAdd },
         .callback = Trigger,
         .ctx = &ctx_2
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
 
     test_int(ctx_1.invoked, 0);
@@ -4762,10 +4778,10 @@ void Trigger_on_set_superset_after_filter_observer_w_on_add_isa_after_set(void)
 
     Probe ctx_1 = {0};
     ecs_observer(world, {
-        .filter.terms = {
-            { ecs_id(Position), .src.flags = EcsUp }
+        .query.terms = {
+            { ecs_id(Position), .src.id = EcsUp, .trav = EcsIsA, }
         },
-        .filter.flags = EcsFilterNoData,
+        .query.flags = EcsQueryNoData,
         .events = { EcsOnAdd },
         .callback = Trigger,
         .ctx = &ctx_1
@@ -4773,15 +4789,15 @@ void Trigger_on_set_superset_after_filter_observer_w_on_add_isa_after_set(void)
 
     Probe ctx_2 = {0};
     ecs_observer(world, {
-        .filter.terms = {
-            { ecs_id(Position), .src.flags = EcsUp }
+        .query.terms = {
+            { ecs_id(Position), .src.id = EcsUp, .trav = EcsIsA, }
         },
         .events = { EcsOnAdd },
         .callback = Trigger,
         .ctx = &ctx_2
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_set(world, base, Position, {10, 20});
     test_int(ctx_1.invoked, 0);
     test_int(ctx_2.invoked, 0);
@@ -4812,10 +4828,10 @@ void Trigger_on_set_superset_after_filter_observer_w_on_add_2(void) {
     // first observer causes observer to be initialized with filter flag
     Probe ctx_1 = {0};
     ecs_observer(world, { 
-        .filter.terms = {
+        .query.terms = {
             { ecs_id(Position) }
         },
-        .filter.flags = EcsFilterNoData,
+        .query.flags = EcsQueryNoData,
         .events = { EcsOnAdd },
         .callback = Trigger,
         .ctx = &ctx_1
@@ -4824,15 +4840,15 @@ void Trigger_on_set_superset_after_filter_observer_w_on_add_2(void) {
     // second observer is not a filter, so value should be avaulable
     Probe ctx_2 = {0};
     ecs_observer(world, {
-        .filter.terms = {
-            { ecs_id(Position), .src.flags = EcsUp }
+        .query.terms = {
+            { ecs_id(Position), .src.id = EcsUp, .trav = EcsIsA }
         },
         .events = { EcsOnAdd },
         .callback = Trigger,
         .ctx = &ctx_2
     });
 
-    ecs_entity_t base = ecs_new_id(world);
+    ecs_entity_t base = ecs_new(world);
     ecs_set(world, base, Position, {10, 20});
     ecs_override(world, base, Position); // override causes emit with 2 ids
     
@@ -4857,39 +4873,3 @@ void Trigger_on_set_superset_after_filter_observer_w_on_add_2(void) {
 
     ecs_fini(world);
 }
-
-void Trigger_propagate_w_union_pair(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Tag);
-    ECS_TAG(world, RelX);
-    ECS_ENTITY(world, RelY, Union);
-
-    ecs_entity_t base = ecs_new_id(world);
-    ecs_entity_t tgt = ecs_new_id(world);
-    ecs_new_w_pair(world, EcsIsA, base);
-
-    Probe ctx = {0};
-    ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0] = {
-            .id = Tag,
-            .src.flags = EcsUp
-        },
-        .events = {EcsOnAdd},
-        .callback = Trigger,
-        .ctx = &ctx
-    });
-    test_int(ctx.invoked, 0);
-    
-    ecs_add_id(world, base, Tag);
-    test_int(ctx.invoked, 1);
-
-    ecs_os_zeromem(&ctx);
-    ecs_add_pair(world, base, RelX, tgt);
-    test_int(ctx.invoked, 0);
-
-    ecs_add_pair(world, base, RelY, tgt);
-    test_int(ctx.invoked, 0);
-
-    ecs_fini(world);
-}
diff --git a/test/api/src/TriggerOnAdd.c b/test/core/src/TriggerOnAdd.c
similarity index 89%
rename from test/api/src/TriggerOnAdd.c
rename to test/core/src/TriggerOnAdd.c
index cdbe466fd..88ccab68f 100644
--- a/test/api/src/TriggerOnAdd.c
+++ b/test/core/src/TriggerOnAdd.c
@@ -1,15 +1,15 @@
-#include <api.h>
+#include <core.h>
 
 void TriggerOnAdd_setup(void) {
     ecs_log_set_level(-3);
 }
 
 void Init(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     
     Velocity *v = NULL;
     if (it->field_count >= 2) {
-        v = ecs_field(it, Velocity, 2);
+        v = ecs_field(it, Velocity, 1);
     }
 
     probe_iter(it);
@@ -95,7 +95,7 @@ void TriggerOnAdd_new_match_1_of_1(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.count, 1);
@@ -155,7 +155,7 @@ void TriggerOnAdd_new_no_match_1(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Velocity);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -172,7 +172,7 @@ void TriggerOnAdd_add_match_1_of_1(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -206,7 +206,7 @@ void TriggerOnAdd_add_match_1_of_2(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -241,7 +241,7 @@ void TriggerOnAdd_add_no_match_1(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -262,7 +262,7 @@ void TriggerOnAdd_set_match_1_of_1(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -296,7 +296,7 @@ void TriggerOnAdd_set_no_match_1(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -314,7 +314,7 @@ void TriggerOnAdd_clone_match_1_of_1(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, Init, EcsOnAdd, Position);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
 
     Probe ctx = {0};
@@ -377,7 +377,7 @@ void TriggerOnAdd_add_again_1(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, Init, EcsOnAdd, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, Position);
@@ -398,7 +398,7 @@ void TriggerOnAdd_set_again_1(void) {
     ECS_COMPONENT(world, Position);
     ECS_OBSERVER(world, Init, EcsOnAdd, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -420,7 +420,7 @@ void TriggerOnAdd_add_again_2(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_OBSERVER(world, Init, EcsOnAdd, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, Position);
@@ -473,7 +473,7 @@ void TriggerOnAdd_new_w_count_match_1_of_1(void) {
 
 static
 void AddVelocity(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     ecs_id_t v = 0;
     if (it->ctx) {
@@ -481,7 +481,7 @@ void AddVelocity(ecs_iter_t *it) {
     }
     
     if (!v) {
-        v = ecs_field_id(it, 2);
+        v = ecs_field_id(it, 1);
     }
 
     probe_iter(it);
@@ -505,7 +505,7 @@ void TriggerOnAdd_override_after_add_in_on_add(void) {
 
     ECS_OBSERVER(world, AddVelocity, EcsOnAdd, Position(self));
 
-    ecs_observer_init(world, &(ecs_observer_desc_t){
+    ecs_observer(world, {
         .entity = ecs_entity(world, {.id = AddVelocity}),
         .ctx = &ecs_id(Velocity)
     });
@@ -540,7 +540,7 @@ void TriggerOnAdd_override_after_add_in_on_add(void) {
 
 static
 void OnSetPosition(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -558,7 +558,7 @@ void TriggerOnAdd_set_after_add_in_on_add(void) {
     ECS_OBSERVER(world, AddVelocity, EcsOnAdd, Position);
     ECS_OBSERVER(world, OnSetPosition, EcsOnSet, Position);
 
-    ecs_observer_init(world, &(ecs_observer_desc_t){
+    ecs_observer(world, {
         .entity = ecs_entity(world, {.id = AddVelocity}),
         .ctx = &ecs_id(Velocity)
     });
@@ -566,7 +566,7 @@ void TriggerOnAdd_set_after_add_in_on_add(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -593,7 +593,7 @@ void TriggerOnAdd_set_after_add_in_on_add(void) {
 
 static
 void AddAgain(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -608,7 +608,7 @@ void TriggerOnAdd_add_again_in_progress(void) {
     ECS_OBSERVER(world, Init, EcsOnAdd, Position);
     ECS_SYSTEM(world, AddAgain, EcsOnUpdate, Position);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
 
     ecs_add(world, e, Position);
@@ -625,7 +625,7 @@ void TriggerOnAdd_add_again_in_progress(void) {
 
 static
 void AddMass(ecs_iter_t *it) {
-    Mass *m = ecs_field(it, Mass, 1);
+    Mass *m = ecs_field(it, Mass, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -640,7 +640,7 @@ void TriggerOnAdd_add_in_progress_before_system_def(void) {
     ECS_COMPONENT(world, Velocity);
     ECS_SYSTEM(world, AddVelocity, EcsOnUpdate, Position, Velocity());
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert( ecs_has(world, e, Position));
     test_assert( !ecs_has(world, e, Velocity));
@@ -673,7 +673,7 @@ void SystemA(ecs_iter_t *it) {
 }
 
 void SystemB(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -688,16 +688,16 @@ void TriggerOnAdd_2_systems_w_table_creation(void) {
     ECS_OBSERVER(world, SystemA, EcsOnAdd, Position);
     ECS_OBSERVER(world, SystemB, EcsOnAdd, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);    
 
     ecs_fini(world);
 }
 
 void NewWithPosition(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
-    ecs_entity_t e = ecs_new(it->world, Position);
+    ecs_entity_t e = ecs_new_w(it->world, Position);
     test_assert(e != 0); 
 }
 
@@ -730,7 +730,7 @@ void TriggerOnAdd_sys_context(void) {
 
     ECS_OBSERVER(world, TestContext, EcsOnAdd, Position);
 
-    ecs_observer_init(world, &(ecs_observer_desc_t){
+    ecs_observer(world, {
         .entity = ecs_entity(world, {.id = TestContext}), .ctx = &param
     });
 
@@ -747,7 +747,7 @@ void TriggerOnAdd_get_sys_context_from_param(void) {
 
     ECS_OBSERVER(world, TestContext, EcsOnAdd, Position);
 
-    ecs_observer_init(world, &(ecs_observer_desc_t){
+    ecs_observer(world, {
         .entity = ecs_entity(world, {.id = TestContext}), .ctx = &param
     });
 
@@ -755,7 +755,7 @@ void TriggerOnAdd_get_sys_context_from_param(void) {
     ecs_set_ctx(world, &param, NULL);
 
     /* Trigger system */
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     test_int(param, 1);
 
@@ -775,7 +775,7 @@ void TriggerOnAdd_remove_added_component_in_on_add_w_set(void) {
 
     test_expect_abort();
 
-    ecs_set(world, 0, Position, {0, 0});
+    ecs_insert(world, ecs_value(Position, {0, 0}));
 }
 
 void Add_3_to_current(ecs_iter_t *it) {
@@ -802,9 +802,9 @@ void TriggerOnAdd_on_add_in_on_add(void) {
     IterData ctx = {.component = ecs_id(Velocity), .component_3 = ecs_id(Mass)};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
 
     test_assert( ecs_has(world, e1, Position));
     test_assert( ecs_has(world, e2, Position));
@@ -863,9 +863,9 @@ void TriggerOnAdd_on_set_in_on_add(void) {
     IterData ctx = {.component = ecs_id(Rotation), .component_3 = ecs_id(Mass)};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
 
     test_assert( ecs_has(world, e1, Position));
     test_assert( ecs_has(world, e2, Position));
@@ -907,9 +907,9 @@ void TriggerOnAdd_on_add_in_on_update(void) {
     IterData ctx = {.component = ecs_id(Velocity), .component_3 = ecs_id(Mass)};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
-    ecs_entity_t e3 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
 
     ecs_progress(world, 1);
 
@@ -933,17 +933,17 @@ void TriggerOnAdd_emplace(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+    ecs_observer(world, {
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnAdd},
         .callback = Dummy
     });    
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_int(dummy_called, 0);
 
-    Position *p = ecs_emplace(world, e, Position);
+    Position *p = ecs_emplace(world, e, Position, NULL);
     test_assert(p != NULL);
     test_bool(dummy_called, true);
 
@@ -955,13 +955,13 @@ void TriggerOnAdd_add_after_delete_trigger(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t trigger = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+    ecs_entity_t trigger = ecs_observer(world, {
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnAdd},
         .callback = Dummy
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(ecs_has(world, e1, Position));
     test_int(dummy_called, 1);
@@ -971,7 +971,7 @@ void TriggerOnAdd_add_after_delete_trigger(void) {
     ecs_delete(world, trigger);
     test_int(dummy_called, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     test_assert(e2 != 0);
     test_assert(ecs_has(world, e2, Position));
     test_int(dummy_called, 0);
@@ -984,13 +984,13 @@ void TriggerOnAdd_add_after_delete_wildcard_id_trigger(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t trigger = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = EcsWildcard,
+    ecs_entity_t trigger = ecs_observer(world, {
+        .query.terms[0].id = EcsWildcard,
         .events = {EcsOnAdd},
         .callback = Dummy
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(ecs_has(world, e1, Position));
     test_int(dummy_called, 1);
@@ -1000,7 +1000,7 @@ void TriggerOnAdd_add_after_delete_wildcard_id_trigger(void) {
     ecs_delete(world, trigger);
     test_int(dummy_called, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     test_assert(e2 != 0);
     test_assert(ecs_has(world, e2, Position));
     test_int(dummy_called, 0);
diff --git a/test/api/src/TriggerOnRemove.c b/test/core/src/TriggerOnRemove.c
similarity index 89%
rename from test/api/src/TriggerOnRemove.c
rename to test/core/src/TriggerOnRemove.c
index 13ef50873..ea3f31287 100644
--- a/test/api/src/TriggerOnRemove.c
+++ b/test/core/src/TriggerOnRemove.c
@@ -1,11 +1,11 @@
-#include <api.h>
+#include <core.h>
 
 void Deinit(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     Velocity *v = NULL;
     if (it->field_count >= 2) {
-        v = ecs_field(it, Velocity, 2);
+        v = ecs_field(it, Velocity, 1);
     }
 
     probe_iter(it);
@@ -52,7 +52,7 @@ void TriggerOnRemove_remove(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -80,7 +80,7 @@ void TriggerOnRemove_remove_no_match(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -101,7 +101,7 @@ void TriggerOnRemove_delete(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -129,7 +129,7 @@ void TriggerOnRemove_delete_no_match(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Velocity);
+    ecs_entity_t e = ecs_new_w(world, Velocity);
     test_assert(e != 0);
 
     test_int(ctx.count, 0);
@@ -145,7 +145,7 @@ static Position old_position = {0};
 
 static
 void RemovePosition(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     test_assert(it->count == 1);
 
@@ -159,7 +159,7 @@ void TriggerOnRemove_remove_watched(void) {
 
     ECS_OBSERVER(world, RemovePosition, EcsOnRemove, Position);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(e != 0);
 
     /* Make parent entity watched */
@@ -181,7 +181,7 @@ void TriggerOnRemove_delete_watched(void) {
 
     ECS_OBSERVER(world, RemovePosition, EcsOnRemove, Position);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(e != 0);
 
     /* Make parent entity watched */
@@ -256,7 +256,7 @@ void TriggerOnRemove_valid_entity_after_delete(void) {
     ECS_COMPONENT(world, DummyComp);
     ECS_OBSERVER(world, RemoveDummyComp, EcsOnRemove, DummyComp);
 
-    ecs_entity_t e = ecs_new(world, DummyComp);
+    ecs_entity_t e = ecs_new_w(world, DummyComp);
     test_assert(e != 0);
 
     ecs_delete(world, e);
@@ -274,12 +274,12 @@ void TriggerOnRemove_remove_after_delete_trigger(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t trigger = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnRemove},
         .callback = Dummy
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(ecs_has(world, e1, Position));
     test_int(dummy_called, 0);
@@ -292,7 +292,7 @@ void TriggerOnRemove_remove_after_delete_trigger(void) {
     ecs_delete(world, trigger);
     test_int(dummy_called, 0);
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     test_assert(e2 != 0);
     test_assert(ecs_has(world, e2, Position));
     test_int(dummy_called, 0);
@@ -309,12 +309,12 @@ void TriggerOnRemove_remove_after_delete_wildcard_id_trigger(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_entity_t trigger = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = EcsWildcard,
+        .query.terms[0].id = EcsWildcard,
         .events = {EcsOnRemove},
         .callback = Dummy
     });
 
-    ecs_entity_t e1 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, Position);
     test_assert(e1 != 0);
     test_assert(ecs_has(world, e1, Position));
     test_int(dummy_called, 0);
@@ -330,7 +330,7 @@ void TriggerOnRemove_remove_after_delete_wildcard_id_trigger(void) {
 
     dummy_called = 0;
 
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
     test_assert(e2 != 0);
     test_assert(ecs_has(world, e2, Position));
     test_int(dummy_called, 0);
@@ -353,7 +353,7 @@ void OnRemoveHasTag(ecs_iter_t *it) {
 
     test_int(it->count, 1);
     test_assert(it->entities[0] == ctx->ent);
-    test_assert(ecs_field_id(it, 1) == ctx->tag);
+    test_assert(ecs_field_id(it, 0) == ctx->tag);
     test_bool(ecs_has_id(it->world, ctx->ent, ctx->tag), true);
 
     dummy_called = true;
@@ -364,7 +364,7 @@ void TriggerOnRemove_has_removed_tag_trigger_1_tag(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
     test_assert(e != 0);
     test_assert(ecs_has(world, e, Tag));
 
@@ -374,7 +374,7 @@ void TriggerOnRemove_has_removed_tag_trigger_1_tag(void) {
     };
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsOnRemove},
         .callback = OnRemoveHasTag,
         .ctx = &ctx
@@ -393,7 +393,7 @@ void TriggerOnRemove_has_removed_tag_trigger_2_tags(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new(world, TagA);
+    ecs_entity_t e = ecs_new_w(world, TagA);
     test_assert(e != 0);
     test_assert(ecs_has(world, e, TagA));
 
@@ -406,7 +406,7 @@ void TriggerOnRemove_has_removed_tag_trigger_2_tags(void) {
     };
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = TagA,
+        .query.terms[0].id = TagA,
         .events = {EcsOnRemove},
         .callback = OnRemoveHasTag,
         .ctx = &ctx
diff --git a/test/api/src/TriggerOnSet.c b/test/core/src/TriggerOnSet.c
similarity index 85%
rename from test/api/src/TriggerOnSet.c
rename to test/core/src/TriggerOnSet.c
index 07d1aa1d4..f3b6e7d1d 100644
--- a/test/api/src/TriggerOnSet.c
+++ b/test/core/src/TriggerOnSet.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 static
 void Trigger(ecs_iter_t *it) {
@@ -7,11 +7,11 @@ void Trigger(ecs_iter_t *it) {
 
 static
 void OnSet(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     Velocity *v = NULL;
     if (it->field_count >= 2) {
-        v = ecs_field(it, Velocity, 2);
+        v = ecs_field(it, Velocity, 1);
     }
 
     probe_iter(it);
@@ -43,7 +43,7 @@ void TriggerOnSet_set(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.count, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -76,7 +76,7 @@ void TriggerOnSet_set_new(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     
     test_int(ctx.count, 1);
     test_int(ctx.invoked, 1);
@@ -106,7 +106,7 @@ void TriggerOnSet_set_again(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.count, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -146,7 +146,7 @@ void TriggerOnSet_clone(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
     
     test_int(ctx.count, 1);
     test_int(ctx.invoked, 1);
@@ -184,7 +184,7 @@ void TriggerOnSet_clone_w_value(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
     
     test_int(ctx.count, 1);
     test_int(ctx.invoked, 1);
@@ -228,7 +228,7 @@ static bool set_called;
 
 static
 void OnAdd_check_order(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     test_assert(!add_called);
     test_assert(!set_called);
@@ -246,7 +246,7 @@ void OnAdd_check_order(ecs_iter_t *it) {
 
 static
 void OnSet_check_order(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     probe_iter(it);
 
@@ -272,7 +272,7 @@ void TriggerOnSet_set_and_add_system(void) {
     Probe ctx = {0};
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(ctx.count, 0);
 
     ecs_set(world, e, Position, {10, 20});
@@ -302,11 +302,11 @@ void TriggerOnSet_set_and_add_system(void) {
 
 static
 void OnSetShared(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     Velocity *v = NULL;
     if (it->field_count >= 2) {
-        v = ecs_field(it, Velocity, 2);
+        v = ecs_field(it, Velocity, 1);
     }
 
     probe_iter(it);
@@ -403,7 +403,7 @@ void TriggerOnSet_on_set_after_override_w_new(void) {
 
     Probe ctx = {0};
     ecs_entity_t t1 = ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnSet},
         .callback = OnSet,
         .ctx = &ctx
@@ -498,74 +498,22 @@ void TriggerOnSet_on_set_after_override_1_of_2_overridden(void) {
     ecs_fini(world);
 }
 
-static
-void SetPosition(ecs_iter_t *it) {
-    probe_iter(it);
-}
-
-void TriggerOnSet_on_set_after_snapshot_restore(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_COMPONENT(world, Position);
-    ECS_OBSERVER(world, SetPosition, EcsOnSet, Position);
-
-    const ecs_entity_t *ids = ecs_bulk_new(world, Position, 10);
-    test_assert(ids != NULL);
-
-    ecs_entity_t id_arr[10];
-    memcpy(id_arr, ids, sizeof(ecs_entity_t) * 10);
-
-    int32_t i;
-    for (i = 0; i < 10; i ++) {
-        test_assert(ecs_has(world, ids[i], Position));
-        ecs_set(world, ids[i], Position, {i, i * 2});
-    }
-
-    Probe ctx = { 0 };
-    ecs_set_ctx(world, &ctx, NULL);
-
-    ecs_snapshot_t *s = ecs_snapshot_take(world);
-
-    test_int(ctx.invoked, 0);
-
-    /* Delete one entity, so we have more confidence we're triggering on the 
-     * right entities */
-    ecs_delete(world, id_arr[0]);
-    
-    test_int(ctx.invoked, 0);
-
-    ecs_snapshot_restore(world, s);
-
-    test_int(ctx.count, 10);
-    test_int(ctx.invoked, 1);
-    test_int(ctx.system, SetPosition);
-    test_int(ctx.term_count, 1);
-    test_int(ctx.c[0][0], ecs_id(Position));
-    test_null(ctx.param);
-    
-    for (i = 0; i < 10; i ++) {
-        test_int(ctx.e[i], id_arr[i]);
-    }
-
-    ecs_fini(world);
-}
-
 void TriggerOnSet_emplace(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = {EcsOnSet},
         .callback = Dummy
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_int(dummy_called, 0);
 
-    Position *p = ecs_emplace(world, e, Position);
+    Position *p = ecs_emplace(world, e, Position, NULL);
     test_assert(p != NULL);
     test_int(dummy_called, 0);
 
@@ -581,12 +529,12 @@ void TriggerOnSet_un_set_tag_w_remove(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsUnSet},
         .callback = Dummy
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_int(dummy_called, 0);
 
@@ -605,12 +553,12 @@ void TriggerOnSet_un_set_tag_w_clear(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsUnSet},
         .callback = Dummy
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_int(dummy_called, 0);
 
@@ -629,12 +577,12 @@ void TriggerOnSet_un_set_tag_w_delete(void) {
     ECS_TAG(world, Tag);
 
     ecs_observer_init(world, &(ecs_observer_desc_t){
-        .filter.terms[0].id = Tag,
+        .query.terms[0].id = Tag,
         .events = {EcsUnSet},
         .callback = Dummy
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_int(dummy_called, 0);
 
@@ -658,7 +606,7 @@ void TriggerOnSet_on_set_after_remove_override(void) {
     Probe ctx = { 0 };
     ecs_set_ctx(world, &ctx, NULL);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_int(ctx.invoked, 0);
 
     ecs_add_pair(world, e, EcsIsA, Base);
diff --git a/test/api/src/Type.c b/test/core/src/Type.c
similarity index 92%
rename from test/api/src/Type.c
rename to test/core/src/Type.c
index b52a1775e..8192ef42d 100644
--- a/test/api/src/Type.c
+++ b/test/core/src/Type.c
@@ -1,13 +1,6 @@
-#include <api.h>
+#include <core.h>
 #include <stdio.h>
 
-static
-char* type_str(ecs_world_t *world, ecs_entity_t type_ent) {
-    const ecs_type_t *t = ecs_get_type(world, type_ent);
-    test_assert(t != NULL);
-    return ecs_type_str(world, t);
-}
-
 void Type_setup(void) {
     ecs_log_set_level(-2);
 }
@@ -100,7 +93,7 @@ void Type_get_type(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
 
     const ecs_type_t *t = ecs_get_type(world, e);
     test_assert(t != NULL);
@@ -116,7 +109,7 @@ void Type_get_type(void) {
 void Type_get_type_from_empty(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     const ecs_type_t *t = ecs_get_type(world, e);
     test_assert(t == NULL);
@@ -279,20 +272,6 @@ void Type_entity_pair_str(void) {
     ecs_fini(world);
 }
 
-void Type_entity_and_str(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_ENTITY(world, Foo, 0);
-
-    ecs_entity_t e = ECS_AND | Foo;
-
-    char *str = ecs_id_str(world, e);
-    test_str(str, "AND|Foo");
-    ecs_os_free(str);
-
-    ecs_fini(world);
-}
-
 void Type_entity_str_small_buffer(void) {
     ecs_world_t *world = ecs_mini();
 
@@ -312,11 +291,6 @@ void Type_role_pair_str(void) {
     test_str(ecs_id_flag_str(e), "PAIR");
 }
 
-void Type_role_and_str(void) {
-    ecs_entity_t e = ECS_AND;
-    test_str(ecs_id_flag_str(e), "AND");
-}
-
 void Type_role_owned_str(void) {
     ecs_entity_t e = ECS_OVERRIDE;
     test_str(ecs_id_flag_str(e), "OVERRIDE");
diff --git a/test/api/src/World.c b/test/core/src/World.c
similarity index 91%
rename from test/api/src/World.c
rename to test/core/src/World.c
index 5339ec739..a4822dfd7 100644
--- a/test/api/src/World.c
+++ b/test/core/src/World.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 #include <stdlib.h>
 
 void World_setup(void) {
@@ -7,8 +7,8 @@ void World_setup(void) {
 
 static
 void Move(ecs_iter_t *it) {
-    Position *pos = ecs_field(it, Position, 1);
-    Velocity *vel = ecs_field(it, Velocity, 2);
+    Position *pos = ecs_field(it, Position, 0);
+    Velocity *vel = ecs_field(it, Velocity, 1);
     probe_iter(it);
 
     int row;
@@ -101,7 +101,7 @@ void World_entity_range_offset(void) {
 
     ecs_set_entity_range(world, 5000, 0);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(e, 5000);
 
     ecs_fini(world);
@@ -152,12 +152,12 @@ void World_entity_range_out_of_range_check_disabled(void) {
     ecs_set_entity_range(world, 5000, 10000);
 
     /* Validate that range is being used when issuing new ids */
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_int(e, 5000);
 
     /* Validate that application does not abort when changing out of range */
-    ecs_entity_t e2 = ecs_set(world, 4999, Position, {10, 20});
-    test_int(e2, 4999);
+    ecs_entity_t e2 = 4999;
+    ecs_set(world, e2, Position, {10, 20});
     test_assert( ecs_has(world, e2, Position));
     
     const Position *p = ecs_get(world, e2, Position);
@@ -176,13 +176,13 @@ void World_entity_range_check_after_delete(void) {
     ecs_enable_range_check(world, true);
     ecs_set_entity_range(world, 5000, 10000);
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
     test_assert(e != 0);
     test_assert(e == 5000);
 
     ecs_delete(world, e);
 
-    e = ecs_new(world, 0);
+    e = ecs_new(world);
     test_assert(e != 0);
     test_assert((uint32_t)e == 5000);
 
@@ -195,7 +195,7 @@ void World_entity_range_add_existing_staged(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert(e < 1000);
 
@@ -217,7 +217,7 @@ void World_entity_range_add_in_range_staged(void) {
 
     ecs_set_entity_range(world, 500, 1000);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e == 500);
 
     ecs_readonly_begin(world, false);
@@ -229,7 +229,7 @@ void World_entity_range_add_in_range_staged(void) {
 }
 
 void AddOutOfRange(ecs_iter_t *it) {
-    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
+    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 1);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -250,7 +250,7 @@ void World_entity_range_add_out_of_range_staged(void) {
     ecs_set_entity_range(world, 500, 1000);
 
     /* Dummy entity to invoke the system */
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e == 500);
 
     ecs_readonly_begin(world, false);
@@ -312,7 +312,7 @@ void World_dim(void) {
 
     /* Create single entity so that the table exists. This makes the allocation
      * counts more predictable, as new_w_count won't trigger table creation */
-    ecs_new(world, Position);
+    ecs_new_w(world, Position);
 
     ecs_dim(world, 1100);
 
@@ -333,7 +333,7 @@ void World_dim(void) {
 
 static
 void TOnLoad(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     int i;
     for (i = 0; i < it->count; i ++) {
         test_int(p[i].x, 0);
@@ -343,7 +343,7 @@ void TOnLoad(ecs_iter_t *it) {
 
 static
 void TPostLoad(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     int i;
     for (i = 0; i < it->count; i ++) {
         test_int(p[i].x, 1);
@@ -353,7 +353,7 @@ void TPostLoad(ecs_iter_t *it) {
 
 static
 void TPreUpdate(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     int i;
     for (i = 0; i < it->count; i ++) {
         test_int(p[i].x, 2);
@@ -363,7 +363,7 @@ void TPreUpdate(ecs_iter_t *it) {
 
 static
 void TOnUpdate(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     int i;
     for (i = 0; i < it->count; i ++) {
         test_int(p[i].x, 3);
@@ -373,7 +373,7 @@ void TOnUpdate(ecs_iter_t *it) {
 
 static
 void TOnValidate(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     int i;
     for (i = 0; i < it->count; i ++) {
         test_int(p[i].x, 4);
@@ -383,7 +383,7 @@ void TOnValidate(ecs_iter_t *it) {
 
 static
 void TPostUpdate(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     int i;
     for (i = 0; i < it->count; i ++) {
         test_int(p[i].x, 5);
@@ -393,7 +393,7 @@ void TPostUpdate(ecs_iter_t *it) {
 
 static
 void TPreStore(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     int i;
     for (i = 0; i < it->count; i ++) {
         test_int(p[i].x, 6);
@@ -403,7 +403,7 @@ void TPreStore(ecs_iter_t *it) {
 
 static
 void TOnStore(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     int i;
     for (i = 0; i < it->count; i ++) {
         test_int(p[i].x, 7);
@@ -413,7 +413,7 @@ void TOnStore(ecs_iter_t *it) {
 
 static
 void TManual(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
     int i;
     for (i = 0; i < it->count; i ++) {
         test_int(p[i].x, 8);
@@ -436,7 +436,7 @@ void World_phases(void) {
     ECS_SYSTEM(world, TOnStore, EcsOnStore, Position);
     ECS_SYSTEM(world, TManual, 0, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {0, 0});
@@ -458,7 +458,7 @@ void World_phases_match_in_create(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {0, 0});
@@ -487,8 +487,8 @@ void World_phases_match_in_create(void) {
 
 static
 void TMergeOnLoad(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -499,8 +499,8 @@ void TMergeOnLoad(ecs_iter_t *it) {
 
 static
 void TMergePostLoad(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -511,8 +511,8 @@ void TMergePostLoad(ecs_iter_t *it) {
 
 static
 void TMergePreUpdate(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -523,8 +523,8 @@ void TMergePreUpdate(ecs_iter_t *it) {
 
 static
 void TMergeOnUpdate(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -535,8 +535,8 @@ void TMergeOnUpdate(ecs_iter_t *it) {
 
 static
 void TMergeOnValidate(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -547,8 +547,8 @@ void TMergeOnValidate(ecs_iter_t *it) {
 
 static
 void TMergePostUpdate(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -559,8 +559,8 @@ void TMergePostUpdate(ecs_iter_t *it) {
 
 static
 void TMergePreStore(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -571,8 +571,8 @@ void TMergePreStore(ecs_iter_t *it) {
 
 static
 void TMergeOnStore(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -583,8 +583,8 @@ void TMergeOnStore(ecs_iter_t *it) {
 
 static
 void TMergeManual(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
+    Position *p = ecs_field(it, Position, 0);
+    ecs_id_t ecs_id(Position) = ecs_field_id(it, 0);
 
     int i;
     for (i = 0; i < it->count; i ++) {
@@ -608,7 +608,7 @@ void World_phases_w_merging(void) {
     ECS_SYSTEM(world, TMergeOnStore, EcsOnStore, Position, [out] Position());
     ECS_SYSTEM(world, TMergeManual, 0, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_set(world, e, Position, {0, 0});
@@ -638,7 +638,7 @@ void World_measure_time(void) {
 
     ECS_SYSTEM(world, TimeCheck, EcsOnLoad, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     int i = 0;
@@ -658,7 +658,7 @@ void World_control_fps(void) {
 
     ECS_SYSTEM(world, TimeCheck, EcsOnLoad, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     double start, now = 0;
@@ -991,7 +991,7 @@ void World_no_time(void) {
 void World_is_entity_enabled(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new(world, 0);
+    ecs_entity_t e = ecs_new(world);
 
     test_assert( ecs_has_id(world, e, EcsDisabled) == false);
 
@@ -1030,7 +1030,7 @@ void World_system_time_scale(void) {
 void World_ensure_empty_root(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_query_t *q = ecs_query_new(world, "!(ChildOf, *)");
+    ecs_query_t *q = ecs_query(world, { .expr = "!(ChildOf, *)" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     /* Make sure that the only entity in the root is the flecs module */
@@ -1038,20 +1038,17 @@ void World_ensure_empty_root(void) {
     test_int(it.count, 1);
     test_assert(it.entities[0] == EcsFlecs);
 
-    /* Entity for the query */
-    test_assert(ecs_query_next(&it));
-    test_int(it.count, 1);
-    test_assert(ecs_has_id(world, it.entities[0], EcsQuery));
-
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
 void World_register_alias_twice_same_entity(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_set_alias(world, e, "Foo");
     ecs_set_alias(world, e, "Foo");
@@ -1067,8 +1064,8 @@ void World_register_alias_twice_different_entity(void) {
 
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
-    ecs_entity_t f = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
+    ecs_entity_t f = ecs_new(world);
 
     ecs_set_alias(world, e, "Foo");
     
@@ -1132,9 +1129,9 @@ void World_delete_1000_empty_tables(void) {
     const ecs_world_info_t *info = ecs_get_world_info(world);
     int32_t old_empty_table_count = info->empty_table_count;
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
     for (int i = 0; i < 1000; i ++) {
-        ecs_add_id(world, e, ecs_new_id(world));
+        ecs_add_id(world, e, ecs_new(world));
     }
 
     ecs_run_aperiodic(world, 0);
@@ -1163,14 +1160,14 @@ void World_delete_empty_tables_for_id(void) {
     const ecs_world_info_t *info = ecs_get_world_info(world);
     int32_t old_empty_table_count = info->empty_table_count;
 
-    ecs_entity_t e1 = ecs_new(world, TagA);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
     for (int i = 0; i < 500; i ++) {
-        ecs_add_id(world, e1, ecs_new_id(world));
+        ecs_add_id(world, e1, ecs_new(world));
     }
 
-    ecs_entity_t e2 = ecs_new(world, TagB);
+    ecs_entity_t e2 = ecs_new_w(world, TagB);
     for (int i = 0; i < 500; i ++) {
-        ecs_add_id(world, e2, ecs_new_id(world));
+        ecs_add_id(world, e2, ecs_new(world));
     }
 
     ecs_run_aperiodic(world, 0);
@@ -1196,7 +1193,7 @@ void World_use_after_delete_empty(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
 
@@ -1220,7 +1217,7 @@ void World_use_after_clear_empty(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
 
@@ -1244,7 +1241,7 @@ void World_use_after_delete_empty_w_component(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Position);
     ecs_add(world, e, Velocity);
 
@@ -1281,7 +1278,7 @@ void World_use_after_clear_empty_w_component(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Position);
     ecs_add(world, e, Velocity);
 
@@ -1319,13 +1316,13 @@ void World_use_after_clear_empty_w_component_w_lifecycle(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_set_hooks(world, Position, { 
-        .ctor = ecs_default_ctor 
+        .ctor = flecs_default_ctor 
     });
     ecs_set_hooks(world, Velocity, { 
-        .ctor = ecs_default_ctor 
+        .ctor = flecs_default_ctor 
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Position);
     ecs_add(world, e, Velocity);
 
@@ -1368,7 +1365,7 @@ void World_use_after_clear_unused(void) {
     deleted = ecs_delete_empty_tables(world, 0, 1, 0, 0, 0);
     test_assert(deleted == 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
 
@@ -1445,7 +1442,7 @@ void World_get_type_info_after_reuse(void) {
 
     ecs_delete_with(world, ecs_id(Position));
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
     test_assert( ecs_has(world, e, Position));
 
diff --git a/test/api/src/WorldInfo.c b/test/core/src/WorldInfo.c
similarity index 86%
rename from test/api/src/WorldInfo.c
rename to test/core/src/WorldInfo.c
index d2fd11c64..a5eb5726d 100644
--- a/test/api/src/WorldInfo.c
+++ b/test/core/src/WorldInfo.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <core.h>
 
 #define test_delta(prev, cur, field, value)\
     test_int(value, (cur)->field - (prev)->field);\
@@ -27,8 +27,8 @@ void WorldInfo_table_count(void) {
 
     ecs_world_info_t prev = *cur;
 
-    ecs_entity_t c = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
     test_delta(&prev, cur, table_count, 0);
 
     ecs_add_id(world, e, c);
@@ -48,8 +48,8 @@ void WorldInfo_empty_table_count(void) {
 
     ecs_world_info_t prev = *cur;
 
-    ecs_entity_t c = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t c = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_add_id(world, e, c);
     ecs_run_aperiodic(world, 0);
@@ -74,9 +74,9 @@ void WorldInfo_table_create_count(void) {
 
     ecs_world_info_t prev = *cur;
 
-    ecs_entity_t c_1 = ecs_new_id(world);
-    ecs_entity_t c_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t c_1 = ecs_new(world);
+    ecs_entity_t c_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
     test_delta(&prev, cur, table_create_total, 0);
 
     ecs_add_id(world, e, c_1);
@@ -100,16 +100,16 @@ void WorldInfo_table_delete_count(void) {
 
     ecs_world_info_t prev = *cur;
 
-    ecs_entity_t c_1 = ecs_new_id(world);
-    ecs_entity_t c_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t c_1 = ecs_new(world);
+    ecs_entity_t c_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add_id(world, e, c_1);
     test_delta(&prev, cur, table_delete_total, 0);
 
     ecs_add_id(world, e, c_2);
     test_delta(&prev, cur, table_delete_total, 0);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add_id(world, e2, c_2);
     test_delta(&prev, cur, table_delete_total, 0);
 
@@ -135,9 +135,9 @@ void WorldInfo_id_tag_component_count(void) {
     ecs_world_info_t prev_1 = *cur;
     ecs_world_info_t prev_2 = *cur;
 
-    ecs_entity_t c_1 = ecs_new_id(world);
-    ecs_entity_t c_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t c_1 = ecs_new(world);
+    ecs_entity_t c_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
     test_delta(&prev_1, cur, tag_id_count, 0);
     test_delta(&prev_2, cur, component_id_count, 0);
 
@@ -176,9 +176,9 @@ void WorldInfo_id_pair_count(void) {
 
     ecs_world_info_t prev = *cur;
 
-    ecs_entity_t c_1 = ecs_new_id(world);
-    ecs_entity_t c_2 = ecs_new_id(world);
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t c_1 = ecs_new(world);
+    ecs_entity_t c_2 = ecs_new(world);
+    ecs_entity_t e = ecs_new(world);
     test_delta(&prev, cur, pair_id_count, 0);
 
     ecs_add_id(world, e, c_1);
diff --git a/test/api/src/main.c b/test/core/src/main.c
similarity index 66%
rename from test/api/src/main.c
rename to test/core/src/main.c
index c71707488..5ced734ec 100644
--- a/test/api/src/main.c
+++ b/test/core/src/main.c
@@ -6,7 +6,7 @@
  * ----------------------------------------------------------------------------
  */
 
-#include <api.h>
+#include <core.h>
 
 // Testsuite 'Id'
 void Id_0_is_wildcard(void);
@@ -154,6 +154,102 @@ void Entity_commit_w_on_add(void);
 void Entity_commit_w_on_remove(void);
 void Entity_commit_w_cmd_in_observer(void);
 void Entity_entity_init_existing_no_sep(void);
+void Entity_entity_init_w_set_1_comp(void);
+void Entity_entity_init_w_set_2_comp(void);
+void Entity_entity_init_w_set_1_comp_1_tag(void);
+void Entity_entity_init_w_set_2_comp_2_tag(void);
+void Entity_entity_init_w_set_1_comp_w_name(void);
+void Entity_entity_init_w_set_1_comp_existing(void);
+void Entity_entity_init_w_set_1_comp_existing_empty(void);
+void Entity_entity_init_w_set_1_comp_1_tag_w_set(void);
+void Entity_entity_init_w_set_w_hook(void);
+void Entity_entity_init_w_set_w_observer(void);
+void Entity_entity_init_w_set_1_comp_defer(void);
+void Entity_entity_init_w_set_2_comp_defer(void);
+void Entity_entity_init_w_set_1_comp_1_tag_defer(void);
+void Entity_entity_init_w_set_2_comp_2_tag_defer(void);
+void Entity_entity_init_w_set_1_comp_w_name_defer(void);
+void Entity_entity_init_w_set_1_comp_existing_defer(void);
+void Entity_entity_init_w_set_1_comp_existing_empty_defer(void);
+void Entity_entity_init_w_set_1_comp_1_tag_w_set_defer(void);
+void Entity_insert_1_comp(void);
+void Entity_insert_2_comp(void);
+void Entity_insert_1_comp_1_tag(void);
+void Entity_entity_w_parent(void);
+void Entity_entity_w_parent_w_name(void);
+void Entity_entity_w_parent_w_add(void);
+void Entity_entity_w_parent_w_add_w_parent(void);
+void Entity_entity_w_parent_w_set(void);
+void Entity_entity_w_parent_w_set_w_parent(void);
+
+// Testsuite 'Each'
+void Each_each_tag(void);
+void Each_each_component(void);
+void Each_each_pair(void);
+void Each_each_pair_rel_wildcard(void);
+void Each_each_pair_tgt_wildcard(void);
+
+// Testsuite 'Iter'
+void Iter_page_iter_0_0(void);
+void Iter_page_iter_1_0(void);
+void Iter_page_iter_0_1(void);
+void Iter_page_iter_n_0(void);
+void Iter_page_iter_0_n(void);
+void Iter_page_iter_m_n(void);
+void Iter_page_iter_skip_1_table(void);
+void Iter_page_iter_skip_2_tables(void);
+void Iter_worker_iter_1(void);
+void Iter_worker_iter_2(void);
+void Iter_worker_iter_3(void);
+void Iter_worker_iter_4(void);
+void Iter_paged_iter_w_shared_comp(void);
+void Iter_worker_iter_w_shared_comp(void);
+void Iter_paged_iter_w_task_query(void);
+void Iter_worker_iter_w_task_query(void);
+void Iter_worker_iter_w_singleton(void);
+void Iter_worker_iter_w_singleton_component(void);
+void Iter_worker_iter_w_singleton_instanced(void);
+void Iter_worker_iter_w_singleton_component_instanced(void);
+void Iter_paged_iter_w_singleton(void);
+void Iter_paged_iter_w_singleton_component(void);
+void Iter_paged_iter_w_singleton_instanced(void);
+void Iter_paged_iter_w_singleton_component_instanced(void);
+void Iter_page_iter_w_offset_skip_1_archetype(void);
+void Iter_page_iter_w_offset_skip_1_archetype_plus_one(void);
+void Iter_page_iter_w_offset_skip_2_archetypes(void);
+void Iter_page_iter_w_limit_skip_1_archetype(void);
+void Iter_page_iter_w_limit_skip_1_archetype_minus_one(void);
+void Iter_page_iter_w_limit_skip_2_archetypes(void);
+void Iter_page_iter_w_offset_1_limit_max(void);
+void Iter_page_iter_w_offset_1_limit_minus_1(void);
+void Iter_page_iter_w_offset_2_type_limit_max(void);
+void Iter_page_iter_w_offset_2_type_limit_minus_1(void);
+void Iter_page_iter_w_limit_1_all_offsets(void);
+void Iter_page_iter_w_offset_out_of_bounds(void);
+void Iter_page_iter_w_limit_out_of_bounds(void);
+void Iter_page_iter_comb_10_entities_1_type(void);
+void Iter_page_iter_comb_10_entities_2_types(void);
+void Iter_count(void);
+void Iter_iter_restore_stack_iter(void);
+void Iter_interleaved_iter(void);
+void Iter_get_first(void);
+void Iter_page_iter_w_only_tag(void);
+void Iter_worker_iter_w_only_tag(void);
+void Iter_page_iter_w_inout_none(void);
+void Iter_worker_iter_w_inout_none(void);
+void Iter_page_iter_w_ctx(void);
+void Iter_page_iter_w_binding_ctx(void);
+void Iter_worker_iter_w_ctx(void);
+void Iter_worker_iter_w_binding_ctx(void);
+void Iter_column_index_owned(void);
+void Iter_column_index_shared(void);
+void Iter_column_index_not(void);
+void Iter_page_iter_w_fini(void);
+void Iter_worker_iter_w_fini(void);
+void Iter_rule_page_iter_w_fini(void);
+void Iter_rule_worker_iter_w_fini(void);
+void Iter_to_str_before_next(void);
+void Iter_to_str(void);
 
 // Testsuite 'Search'
 void Search_search(void);
@@ -176,9 +272,6 @@ void Search_search_relation_inherit_from_parent(void);
 void Search_search_relation_dont_inherit(void);
 void Search_search_relation_dont_inherit_from_parent(void);
 void Search_search_relation_exclusive(void);
-void Search_search_relation_union(void);
-void Search_search_relation_union_wildcard(void);
-void Search_search_relation_union_pair(void);
 
 // Testsuite 'Event'
 void Event_table_1_id_w_trigger(void);
@@ -196,6 +289,7 @@ void Event_emit_custom_for_any(void);
 void Event_emit_custom_implicit_any(void);
 void Event_emit_custom_empty_type(void);
 void Event_emit_w_param(void);
+void Event_emit_w_param_multi_observer(void);
 void Event_emit_w_const_param(void);
 void Event_emit_nested(void);
 void Event_enqueue_event_1_id(void);
@@ -235,7 +329,6 @@ void New_new_w_entity_0(void);
 void New_create_w_explicit_id_2_worlds(void);
 void New_new_w_id_0_w_with(void);
 void New_new_w_id_w_with(void);
-void New_new_w_type_0_w_with(void);
 void New_new_w_type_w_with(void);
 void New_new_w_id_w_with_w_scope(void);
 void New_new_w_type_w_with_w_scope(void);
@@ -294,109 +387,6 @@ void Add_invalid_pair_w_0_rel(void);
 void Add_invalid_pair_w_0_obj(void);
 void Add_add_random_id(void);
 
-// Testsuite 'Switch'
-void Switch_get_case_no_switch(void);
-void Switch_get_case_set(void);
-void Switch_get_case_change(void);
-void Switch_remove_case(void);
-void Switch_remove_last(void);
-void Switch_delete_first(void);
-void Switch_delete_last(void);
-void Switch_delete_first_last(void);
-void Switch_3_entities_same_case(void);
-void Switch_2_entities_1_change_case(void);
-void Switch_3_entities_change_case(void);
-void Switch_query_switch(void);
-void Switch_query_1_case_1_type(void);
-void Switch_query_1_case_2_types(void);
-void Switch_query_2_cases_1_type(void);
-void Switch_query_2_cases_2_types(void);
-void Switch_query_after_remove(void);
-void Switch_add_case_in_stage(void);
-void Switch_change_case_in_stage(void);
-void Switch_change_one_case_in_stage(void);
-void Switch_remove_switch_in_stage(void);
-void Switch_switch_no_match_for_case(void);
-void Switch_empty_entity_has_case(void);
-void Switch_zero_entity_has_case(void);
-void Switch_add_to_entity_w_switch(void);
-void Switch_add_pair_to_entity_w_switch(void);
-void Switch_sort(void);
-void Switch_recycled_tags(void);
-void Switch_query_recycled_tags(void);
-void Switch_single_case(void);
-void Switch_match_switch_on_base_instance(void);
-void Switch_switch_w_bitset_query(void);
-void Switch_switch_w_bitset_query_inv(void);
-void Switch_switch_w_bitset_query_2_elems(void);
-void Switch_switch_w_bitset_query_2_elems_skip(void);
-void Switch_switch_w_bitset_query_elems_interleaved(void);
-void Switch_switch_w_bitset_query_elems_interleaved_2_types(void);
-void Switch_has_wildcard(void);
-void Switch_remove_wildcard(void);
-void Switch_same_table_after_change(void);
-void Switch_component_relation(void);
-void Switch_delete_case_trigger_after_delete_switch(void);
-void Switch_add_2(void);
-void Switch_add_2_reverse(void);
-void Switch_add_switch_to_prefab_instance(void);
-void Switch_get_case_w_generation(void);
-void Switch_get_case_w_generation_not_alive(void);
-
-// Testsuite 'EnabledComponents'
-void EnabledComponents_is_component_enabled(void);
-void EnabledComponents_is_empty_entity_disabled(void);
-void EnabledComponents_is_0_entity_disabled(void);
-void EnabledComponents_is_0_component_disabled(void);
-void EnabledComponents_is_nonexist_component_disabled(void);
-void EnabledComponents_is_enabled_component_enabled(void);
-void EnabledComponents_is_disabled_component_enabled(void);
-void EnabledComponents_has_enabled_component(void);
-void EnabledComponents_is_enabled_after_add(void);
-void EnabledComponents_is_enabled_after_remove(void);
-void EnabledComponents_is_enabled_after_disable(void);
-void EnabledComponents_is_disabled_after_enable(void);
-void EnabledComponents_is_enabled_randomized(void);
-void EnabledComponents_is_enabled_after_add_randomized(void);
-void EnabledComponents_is_enabled_after_randomized_add_randomized(void);
-void EnabledComponents_is_enabled_2(void);
-void EnabledComponents_is_enabled_3(void);
-void EnabledComponents_is_enabled_2_after_add(void);
-void EnabledComponents_is_enabled_3_after_add(void);
-void EnabledComponents_is_pair_enabled(void);
-void EnabledComponents_is_enabled_pair_enabled(void);
-void EnabledComponents_is_disabled_pair_enabled(void);
-void EnabledComponents_has_enabled_pair(void);
-void EnabledComponents_is_pair_enabled_after_add(void);
-void EnabledComponents_is_pair_enabled_after_remove(void);
-void EnabledComponents_is_pair_enabled_after_disable(void);
-void EnabledComponents_is_pair_disabled_after_enable(void);
-void EnabledComponents_is_pair_enabled_2(void);
-void EnabledComponents_is_pair_enabled_3(void);
-void EnabledComponents_is_pair_enabled_2_after_add(void);
-void EnabledComponents_is_pair_enabled_3_after_add(void);
-void EnabledComponents_query_disabled(void);
-void EnabledComponents_query_disabled_skip_initial(void);
-void EnabledComponents_query_disabled_pair(void);
-void EnabledComponents_query_disabled_pair_skip_initial(void);
-void EnabledComponents_query_mod_2(void);
-void EnabledComponents_query_mod_8(void);
-void EnabledComponents_query_mod_64(void);
-void EnabledComponents_query_mod_256(void);
-void EnabledComponents_query_mod_1024(void);
-void EnabledComponents_query_enable_mod_10(void);
-void EnabledComponents_query_mod_2_2_bitsets(void);
-void EnabledComponents_query_mod_8_2_bitsets(void);
-void EnabledComponents_query_mod_64_2_bitsets(void);
-void EnabledComponents_query_mod_256_2_bitsets(void);
-void EnabledComponents_query_mod_1024_2_bitsets(void);
-void EnabledComponents_query_randomized_2_bitsets(void);
-void EnabledComponents_query_randomized_3_bitsets(void);
-void EnabledComponents_query_randomized_4_bitsets(void);
-void EnabledComponents_defer_enable(void);
-void EnabledComponents_sort(void);
-void EnabledComponents_table_move_2_from_3(void);
-
 // Testsuite 'Remove'
 void Remove_zero(void);
 void Remove_1_of_1(void);
@@ -464,8 +454,6 @@ void Hierarchies_lookup_number(void);
 void Hierarchies_delete_children(void);
 void Hierarchies_scope_set(void);
 void Hierarchies_scope_set_again(void);
-void Hierarchies_scope_set_w_new(void);
-void Hierarchies_scope_set_w_new_staged(void);
 void Hierarchies_scope_set_w_lookup(void);
 void Hierarchies_scope_component(void);
 void Hierarchies_scope_component_no_macro(void);
@@ -485,14 +473,11 @@ void Hierarchies_add_path_from_scope(void);
 void Hierarchies_add_path_from_scope_new_entity(void);
 void Hierarchies_add_root_path_to_child(void);
 void Hierarchies_add_parent_path_from_root_to_child(void);
-void Hierarchies_new_w_child_in_root(void);
 void Hierarchies_delete_child(void);
 void Hierarchies_delete_2_children(void);
 void Hierarchies_delete_2_children_different_type(void);
 void Hierarchies_delete_tree_2_levels(void);
 void Hierarchies_delete_tree_3_levels(void);
-void Hierarchies_delete_tree_count_tables(void);
-void Hierarchies_delete_tree_staged(void);
 void Hierarchies_delete_tree_empty_table(void);
 void Hierarchies_delete_tree_recreate(void);
 void Hierarchies_delete_tree_w_onremove(void);
@@ -504,8 +489,6 @@ void Hierarchies_scope_iter_after_delete_tree(void);
 void Hierarchies_add_child_after_delete_tree(void);
 void Hierarchies_add_child_to_recycled_parent(void);
 void Hierarchies_get_type_after_recycled_parent_add(void);
-void Hierarchies_rematch_after_add_to_recycled_parent(void);
-void Hierarchies_cascade_after_recycled_parent_change(void);
 void Hierarchies_long_name_depth_0(void);
 void Hierarchies_long_name_depth_1(void);
 void Hierarchies_long_name_depth_2(void);
@@ -521,73 +504,6 @@ void Hierarchies_lookup_after_delete_from_parent(void);
 void Hierarchies_defer_batch_remove_name_w_add_childof(void);
 void Hierarchies_defer_batch_remove_childof_w_add_name(void);
 
-// Testsuite 'FixedHierarchies'
-void FixedHierarchies_make_fixed_1_lvl(void);
-void FixedHierarchies_make_fixed_1_lvl_w_init(void);
-void FixedHierarchies_make_fixed_1_lvl_w_init_comp(void);
-void FixedHierarchies_make_fixed_1_lvl_w_init_comp_after_tree_fixed(void);
-void FixedHierarchies_make_fixed_1_lvl_2_entities(void);
-void FixedHierarchies_make_fixed_1_lvl_2_tables(void);
-void FixedHierarchies_make_fixed_2_lvl(void);
-void FixedHierarchies_make_fixed_2_lvl_2_tables(void);
-void FixedHierarchies_make_fixed_3_lvl(void);
-void FixedHierarchies_make_fixed_3_lvl_w_name(void);
-void FixedHierarchies_make_fixed_3_2_lvl_w_name(void);
-void FixedHierarchies_make_fixed_2_lvl_nested(void);
-void FixedHierarchies_make_fixed_3_lvl_nested(void);
-void FixedHierarchies_make_fixed_1_lvl_after_delete(void);
-void FixedHierarchies_get_target_1_lvl(void);
-void FixedHierarchies_get_target_2_lvl(void);
-void FixedHierarchies_get_depth_1_lvl(void);
-void FixedHierarchies_get_depth_2_lvl(void);
-void FixedHierarchies_get_depth_after_reparent_root(void);
-void FixedHierarchies_delete_fixed_1_lvl(void);
-void FixedHierarchies_delete_fixed_2_lvl(void);
-void FixedHierarchies_delete_with_fixed_1_lvl(void);
-void FixedHierarchies_delete_with_fixed_2_lvl(void);
-void FixedHierarchies_query_w_parent_field_1_lvl(void);
-void FixedHierarchies_query_w_parent_field_1_lvl_w_init(void);
-void FixedHierarchies_query_w_parent_field_1_lvl_w_init_comp_after_tree_fixed(void);
-void FixedHierarchies_query_w_parent_field_2_lvl(void);
-void FixedHierarchies_query_w_parent_field_1_fixed_1_regular(void);
-void FixedHierarchies_query_w_parent_field_only_fixed_1_lvls(void);
-void FixedHierarchies_query_w_parent_field_fixed_1_lvls_no_match(void);
-void FixedHierarchies_query_w_parent_field_fixed_1_lvls_2_no_match(void);
-void FixedHierarchies_query_w_parent_field_fixed_1_lvls_match_no_match(void);
-void FixedHierarchies_query_w_parent_field_fixed_1_lvls_no_match_match(void);
-void FixedHierarchies_query_w_parent_field_2_fixed_2_lvls(void);
-void FixedHierarchies_query_w_cascade_field_2_lvl(void);
-void FixedHierarchies_query_next_table(void);
-void FixedHierarchies_query_next_table_1_elem(void);
-void FixedHierarchies_query_next_table_1_elem_no_match(void);
-void FixedHierarchies_query_nested_make_fixed(void);
-void FixedHierarchies_query_nested_make_fixed_w_optional(void);
-void FixedHierarchies_query_nested_make_fixed_w_optional_match_children_only(void);
-void FixedHierarchies_query_nested_w_2_parents_make_fixed(void);
-void FixedHierarchies_query_table_w_3_parents(void);
-void FixedHierarchies_query_w_parent_change_detection_1st(void);
-void FixedHierarchies_query_w_parent_change_detection_2nd(void);
-void FixedHierarchies_query_w_parent_change_detection_iter_twice(void);
-void FixedHierarchies_query_w_parent_change_detection_iter_twice_each_parent(void);
-void FixedHierarchies_query_w_parent_change_detection_1st_populate_when_changed(void);
-void FixedHierarchies_query_w_parent_change_detection_2nd_populate_when_changed(void);
-void FixedHierarchies_query_w_parent_change_detection_iter_twice_populate_when_changed(void);
-void FixedHierarchies_query_w_parent_change_detection_iter_twice_each_parent_populate_when_changed(void);
-void FixedHierarchies_staged_query_w_parent_field_1_lvl(void);
-void FixedHierarchies_staged_query_w_parent_field_2_lvl(void);
-void FixedHierarchies_staged_query_w_parent_field_1_fixed_1_regular(void);
-void FixedHierarchies_staged_query_w_cascade_field_2_lvl(void);
-void FixedHierarchies_add_to_fixed(void);
-void FixedHierarchies_remove_from_fixed(void);
-void FixedHierarchies_delete_fixed(void);
-void FixedHierarchies_clear_fixed(void);
-void FixedHierarchies_make_fixed_1_lvl_w_name(void);
-void FixedHierarchies_make_fixed_2_lvl_w_name(void);
-void FixedHierarchies_make_fixed_1_lvl_w_name_keep_name(void);
-void FixedHierarchies_make_fixed_2_lvl_w_name_keep_name(void);
-void FixedHierarchies_make_fixed_2_lvl_lose_depth(void);
-void FixedHierarchies_make_fixed_3_lvl_lose_depth(void);
-
 // Testsuite 'Has'
 void Has_zero(void);
 void Has_1_of_0(void);
@@ -769,9 +685,7 @@ void OnDelete_remove_childof_wildcard(void);
 void OnDelete_delete_child_of_delete_with(void);
 void OnDelete_deep_clean_64(void);
 void OnDelete_deep_clean_256(void);
-void OnDelete_id_w_switch(void);
 void OnDelete_id_w_disabled(void);
-void OnDelete_id_to_no_switch(void);
 void OnDelete_id_to_no_disabled(void);
 void OnDelete_remove_on_delete_action(void);
 void OnDelete_delete_with_w_relation(void);
@@ -838,6 +752,7 @@ void Set_emplace_2(void);
 void Set_emplace_existing(void);
 void Set_emplace_w_move(void);
 void Set_emplace_w_observer_w_add(void);
+void Set_emplace_existing_w_check(void);
 
 // Testsuite 'ReadWrite'
 void ReadWrite_read(void);
@@ -935,9 +850,6 @@ void ComponentLifecycle_copy_on_set(void);
 void ComponentLifecycle_copy_on_override(void);
 void ComponentLifecycle_copy_on_clone(void);
 void ComponentLifecycle_no_copy_on_move(void);
-void ComponentLifecycle_ctor_copy_on_snapshot(void);
-void ComponentLifecycle_copy_on_snapshot(void);
-void ComponentLifecycle_dtor_on_restore(void);
 void ComponentLifecycle_ctor_on_tag(void);
 void ComponentLifecycle_dtor_on_tag(void);
 void ComponentLifecycle_copy_on_tag(void);
@@ -963,6 +875,8 @@ void ComponentLifecycle_valid_entity_in_dtor_after_delete(void);
 void ComponentLifecycle_ctor_w_emplace(void);
 void ComponentLifecycle_ctor_w_emplace_defer(void);
 void ComponentLifecycle_ctor_w_emplace_defer_use_move_ctor(void);
+void ComponentLifecycle_ctor_w_emplace_defer_twice(void);
+void ComponentLifecycle_ctor_w_emplace_defer_existing(void);
 void ComponentLifecycle_on_add_w_emplace(void);
 void ComponentLifecycle_on_add_w_emplace_existing(void);
 void ComponentLifecycle_on_add_w_emplace_defer(void);
@@ -1002,6 +916,8 @@ void ComponentLifecycle_on_remove_w_existing_component(void);
 void ComponentLifecycle_component_init_set_hooks(void);
 void ComponentLifecycle_component_init_name_from_type_info(void);
 void ComponentLifecycle_component_init_scoped_name_from_type_info(void);
+void ComponentLifecycle_component_init_w_recycled_id(void);
+void ComponentLifecycle_component_init_w_recycled_non_component_id(void);
 void ComponentLifecycle_on_add_after_ctor_w_add(void);
 void ComponentLifecycle_on_add_after_ctor_w_add_to(void);
 void ComponentLifecycle_with_before_hooks(void);
@@ -1019,717 +935,6 @@ void ComponentLifecycle_batched_ensure_new_component_w_lifecycle(void);
 void ComponentLifecycle_on_nested_prefab_copy_test_invokes_copy_count(void);
 void ComponentLifecycle_no_move_no_move_ctor_with_move_dtor_with_ctor_move_dtor(void);
 
-// Testsuite 'Sorting'
-void Sorting_sort_by_component(void);
-void Sorting_sort_by_component_2_tables(void);
-void Sorting_sort_by_component_3_tables(void);
-void Sorting_sort_by_entity(void);
-void Sorting_sort_after_add(void);
-void Sorting_sort_after_remove(void);
-void Sorting_sort_after_delete(void);
-void Sorting_sort_after_set(void);
-void Sorting_sort_after_system(void);
-void Sorting_sort_after_query(void);
-void Sorting_sort_by_component_same_value_1(void);
-void Sorting_sort_by_component_same_value_2(void);
-void Sorting_sort_by_component_move_pivot(void);
-void Sorting_sort_1000_entities(void);
-void Sorting_sort_1000_entities_w_duplicates(void);
-void Sorting_sort_1000_entities_again(void);
-void Sorting_sort_1000_entities_2_types(void);
-void Sorting_sort_1500_entities_3_types(void);
-void Sorting_sort_2000_entities_4_types(void);
-void Sorting_sort_2_entities_2_types(void);
-void Sorting_sort_3_entities_3_types(void);
-void Sorting_sort_3_entities_3_types_2(void);
-void Sorting_sort_4_entities_4_types(void);
-void Sorting_sort_1000_entities_2_types_again(void);
-void Sorting_sort_1000_entities_add_type_after_sort(void);
-void Sorting_sort_shared_component(void);
-void Sorting_sort_shared_component_childof(void);
-void Sorting_sort_w_tags_only(void);
-void Sorting_sort_childof_marked(void);
-void Sorting_sort_isa_marked(void);
-void Sorting_sort_relation_marked(void);
-void Sorting_dont_resort_after_set_unsorted_component(void);
-void Sorting_dont_resort_after_set_unsorted_component_w_tag(void);
-void Sorting_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void);
-void Sorting_sort_component_not_queried_for(void);
-void Sorting_sort_by_wildcard(void);
-void Sorting_sort_shared_w_delete(void);
-void Sorting_sort_w_nontrivial_component(void);
-
-// Testsuite 'SortingEntireTable'
-void SortingEntireTable_sort_by_component(void);
-void SortingEntireTable_sort_by_component_2_tables(void);
-void SortingEntireTable_sort_by_component_3_tables(void);
-void SortingEntireTable_sort_by_entity(void);
-void SortingEntireTable_sort_after_add(void);
-void SortingEntireTable_sort_after_remove(void);
-void SortingEntireTable_sort_after_delete(void);
-void SortingEntireTable_sort_after_set(void);
-void SortingEntireTable_sort_after_system(void);
-void SortingEntireTable_sort_after_query(void);
-void SortingEntireTable_sort_by_component_same_value_1(void);
-void SortingEntireTable_sort_by_component_same_value_2(void);
-void SortingEntireTable_sort_by_component_move_pivot(void);
-void SortingEntireTable_sort_1000_entities(void);
-void SortingEntireTable_sort_1000_entities_w_duplicates(void);
-void SortingEntireTable_sort_1000_entities_again(void);
-void SortingEntireTable_sort_1000_entities_2_types(void);
-void SortingEntireTable_sort_1500_entities_3_types(void);
-void SortingEntireTable_sort_2000_entities_4_types(void);
-void SortingEntireTable_sort_2_entities_2_types(void);
-void SortingEntireTable_sort_3_entities_3_types(void);
-void SortingEntireTable_sort_3_entities_3_types_2(void);
-void SortingEntireTable_sort_4_entities_4_types(void);
-void SortingEntireTable_sort_1000_entities_2_types_again(void);
-void SortingEntireTable_sort_1000_entities_add_type_after_sort(void);
-void SortingEntireTable_sort_shared_component(void);
-void SortingEntireTable_sort_w_tags_only(void);
-void SortingEntireTable_sort_childof_marked(void);
-void SortingEntireTable_sort_isa_marked(void);
-void SortingEntireTable_sort_relation_marked(void);
-void SortingEntireTable_dont_resort_after_set_unsorted_component(void);
-void SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag(void);
-void SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void);
-void SortingEntireTable_sort_shared_w_delete(void);
-
-// Testsuite 'Filter'
-void Filter_filter_1_term(void);
-void Filter_filter_1_term_component(void);
-void Filter_filter_2_terms(void);
-void Filter_filter_3_terms(void);
-void Filter_filter_3_terms_w_or(void);
-void Filter_filter_4_terms_w_or_at_1(void);
-void Filter_filter_1_term_wildcard(void);
-void Filter_filter_1_term_any(void);
-void Filter_filter_1_term_same_subj_obj(void);
-void Filter_filter_1_term_acyclic_same_subj_obj(void);
-void Filter_filter_1_term_acyclic_reflexive_same_subj_obj(void);
-void Filter_filter_1_term_same_subj_obj_var(void);
-void Filter_filter_1_term_acyclic_same_subj_obj_var(void);
-void Filter_filter_1_term_acyclic_reflexive_same_subj_obj_var(void);
-void Filter_filter_1_term_non_acyclic_superset(void);
-void Filter_filter_1_term_dont_inherit_default_set(void);
-void Filter_filter_1_term_dont_inherit_pair_default_set(void);
-void Filter_filter_1_term_cascade_implicit_isa(void);
-void Filter_filter_1_term_cascade_isa(void);
-void Filter_filter_1_term_cascade_childof(void);
-void Filter_filter_1_term_cascade_down(void);
-void Filter_filter_1_term_optional_only(void);
-void Filter_filter_1_term_transitive_pair(void);
-void Filter_filter_1_term_transitive_pair_explicit_self_tgt(void);
-void Filter_filter_1_variable_as_pred_only(void);
-void Filter_filter_1_variable_as_pred_w_subj(void);
-void Filter_filter_1_variable_as_pred_w_pair(void);
-void Filter_filter_1_variable_as_subj(void);
-void Filter_filter_1_variable_as_obj(void);
-void Filter_filter_2_terms_or_w_dontinherit(void);
-void Filter_filter_2_terms_or_w_both_dontinherit(void);
-void Filter_filter_w_pair_id(void);
-void Filter_filter_w_pred_obj(void);
-void Filter_filter_w_pair_id_and_subj(void);
-void Filter_filter_1_w_pred_name(void);
-void Filter_filter_1_w_final_pred_name(void);
-void Filter_filter_1_w_subj_name(void);
-void Filter_filter_1_w_obj_name(void);
-void Filter_filter_w_this_implicit_variable(void);
-void Filter_filter_w_this_explicit_entity(void);
-void Filter_filter_w_first_this_implicit_variable(void);
-void Filter_filter_w_first_this_explicit_entity(void);
-void Filter_filter_w_second_this_implicit_variable(void);
-void Filter_filter_w_second_this_explicit_entity(void);
-void Filter_filter_w_this_variable_name(void);
-void Filter_filter_w_src_var(void);
-void Filter_filter_w_first_var(void);
-void Filter_filter_w_second_var(void);
-void Filter_filter_w_src_var_from_name(void);
-void Filter_filter_w_first_first_var(void);
-void Filter_filter_w_second_second_var(void);
-void Filter_filter_w_0_source(void);
-void Filter_filter_w_0_target(void);
-void Filter_filter_2_terms_w_or(void);
-void Filter_filter_2_terms_w_or_mixed_src_flags(void);
-void Filter_filter_2_terms_w_or_mixed_src_id(void);
-void Filter_filter_2_terms_w_or_mixed_src_name(void);
-void Filter_filter_2_terms_w_or_same_src_w_id_and_name(void);
-void Filter_filter_move(void);
-void Filter_filter_copy(void);
-void Filter_filter_w_resources_copy(void);
-void Filter_filter_w_and_flag(void);
-void Filter_filter_w_or_flag(void);
-void Filter_filter_w_not_flag(void);
-void Filter_filter_filter(void);
-void Filter_filter_double_init(void);
-void Filter_filter_double_init_w_expr(void);
-void Filter_filter_double_init_w_expr_optional(void);
-void Filter_filter_w_tag_term_is_no_data(void);
-void Filter_filter_w_inout_none_term_is_no_data(void);
-void Filter_filter_w_tag_and_inout_none_term_is_no_data(void);
-void Filter_filter_w_not_term_is_no_data(void);
-void Filter_filter_w_no_transitive_pair(void);
-void Filter_filter_w_transitive_pair_any_src(void);
-void Filter_filter_w_transitive_pair(void);
-void Filter_filter_w_transitive_tag_no_pair(void);
-void Filter_filter_w_transitive_tag_self_tgt(void);
-void Filter_filter_w_transitive_tag_any_tgt(void);
-void Filter_filter_w_pair_same_vars(void);
-void Filter_filter_w_pair_not_same_vars(void);
-void Filter_filter_w_pair_no_vars_not_same_vars(void);
-void Filter_filter_w_pair_wildcard_not_same_vars(void);
-void Filter_filter_w_pair_any_not_same_vars(void);
-void Filter_filter_w_no_pair_not_same_vars(void);
-void Filter_filter_not_childof_any(void);
-void Filter_filter_w_inherited_id(void);
-void Filter_filter_w_inherited_pair(void);
-void Filter_filter_w_non_inherited_id(void);
-void Filter_filter_w_non_inherited_pair(void);
-void Filter_filter_w_first_rel(void);
-void Filter_filter_w_first_rel_self(void);
-void Filter_filter_w_first_rel_down(void);
-void Filter_filter_w_first_rel_self_down(void);
-void Filter_filter_w_first_rel_reflexive(void);
-void Filter_filter_w_first_rel_reflexive_self(void);
-void Filter_filter_w_first_rel_reflexive_down(void);
-void Filter_filter_w_first_rel_reflexive_self_down(void);
-void Filter_filter_w_first_rel_non_traversable(void);
-void Filter_filter_w_first_wildcard_inout_none(void);
-void Filter_filter_w_first_var_inout_none(void);
-void Filter_filter_w_pair_wildcard_inout_none(void);
-void Filter_filter_w_pair_var_inout_none(void);
-void Filter_filter_w_unresolved_by_name(void);
-void Filter_filter_w_unresolved_by_name_eq(void);
-void Filter_filter_childof_this(void);
-void Filter_filter_childof_this_entity(void);
-void Filter_filter_childof_this_by_id(void);
-void Filter_term_w_id(void);
-void Filter_term_w_pair_id(void);
-void Filter_term_w_pred_obj(void);
-void Filter_term_w_pair_finalize_twice(void);
-void Filter_term_w_role(void);
-void Filter_term_w_pred_role(void);
-void Filter_term_w_self(void);
-void Filter_term_w_superset(void);
-void Filter_term_w_subset(void);
-void Filter_term_w_self_superset(void);
-void Filter_term_w_superset_custom_relation(void);
-void Filter_term_w_self_superset_custom_relation(void);
-void Filter_term_iter_component(void);
-void Filter_term_iter_w_pred(void);
-void Filter_term_iter_tag(void);
-void Filter_term_iter_pair(void);
-void Filter_term_iter_pair_w_rel_wildcard(void);
-void Filter_term_iter_pair_w_obj_wildcard(void);
-void Filter_term_iter_pair_w_rel_wildcard_n_matches(void);
-void Filter_term_iter_pair_w_rel_wildcard_n_matches_w_data(void);
-void Filter_term_iter_pair_w_obj_wildcard_n_matches(void);
-void Filter_term_iter_pair_w_obj_wildcard_n_matches_w_data(void);
-void Filter_term_iter_w_superset(void);
-void Filter_term_iter_w_superset_base_w_2_components(void);
-void Filter_term_iter_w_superset_childof(void);
-void Filter_term_iter_w_superset_self(void);
-void Filter_term_iter_w_superset_self_childof(void);
-void Filter_term_iter_w_superset_tag(void);
-void Filter_term_iter_w_superset_pair(void);
-void Filter_term_iter_w_superset_pair_obj_wildcard(void);
-void Filter_term_iter_in_stage(void);
-void Filter_term_iter_w_readonly_term(void);
-void Filter_term_iter_type_set(void);
-void Filter_term_iter_any_match_wildcard(void);
-void Filter_term_iter_any_match_tag_and_wildcard(void);
-void Filter_term_iter_any_obj(void);
-void Filter_children_iter(void);
-void Filter_filter_iter_1_tag(void);
-void Filter_filter_iter_2_tags(void);
-void Filter_filter_iter_2_tags_1_not(void);
-void Filter_filter_iter_3_tags_2_or(void);
-void Filter_filter_iter_only_optional(void);
-void Filter_filter_iter_only_2_or(void);
-void Filter_filter_iter_only_3_or(void);
-void Filter_filter_iter_2_or(void);
-void Filter_filter_iter_3_or(void);
-void Filter_filter_iter_2_or_other_type(void);
-void Filter_filter_iter_2_or_same_type(void);
-void Filter_filter_iter_or_w_wildcard(void);
-void Filter_filer_iter_or_w_component_and_tag(void);
-void Filter_filer_iter_or_w_tag_and_component(void);
-void Filter_filter_iter_1_component(void);
-void Filter_filter_iter_2_components(void);
-void Filter_filter_iter_pair_id(void);
-void Filter_filter_iter_2_pair_ids(void);
-void Filter_filter_iter_childof_pair_0_parent(void);
-void Filter_filter_iter_pair_pred_obj(void);
-void Filter_filter_iter_pair_2_pred_obj(void);
-void Filter_filter_iter_null(void);
-void Filter_filter_iter_1_not_tag(void);
-void Filter_filter_iter_2_tags_1_optional(void);
-void Filter_filter_iter_2_components_1_optional(void);
-void Filter_filter_iter_in_stage(void);
-void Filter_filter_iter_10_tags(void);
-void Filter_filter_iter_20_tags(void);
-void Filter_filter_iter_10_components(void);
-void Filter_filter_iter_20_components(void);
-void Filter_filter_iter_superset(void);
-void Filter_filter_iter_superset_childof(void);
-void Filter_filter_iter_type_set(void);
-void Filter_filter_iter_w_readonly_term(void);
-void Filter_filter_iter_w_from_nothing_term(void);
-void Filter_filter_iter_pair_w_rel_wildcard_n_matches(void);
-void Filter_filter_iter_pair_w_obj_wildcard_n_matches(void);
-void Filter_filter_iter_pair_w_2_wildcards_1_match(void);
-void Filter_filter_iter_pair_w_2_wildcards_2x1_matches(void);
-void Filter_filter_iter_pair_w_2_wildcards_2x2_matches(void);
-void Filter_filter_iter_pair_w_3_wildcards_2x2x2_matches(void);
-void Filter_filter_iter_pair_w_wildcard_and_nothing(void);
-void Filter_filter_iter_any(void);
-void Filter_filter_iter_any_match_wildcard(void);
-void Filter_filter_iter_any_match_tag_and_wildcard(void);
-void Filter_filter_iter_wildcard_in_2nd_term(void);
-void Filter_filter_iter_wildcard_in_2nd_term_self(void);
-void Filter_filter_iter_2nd_term_self_create_id_after_filter(void);
-void Filter_filter_iter_any_obj(void);
-void Filter_filter_iter_not_any(void);
-void Filter_filter_iter_not_any_obj(void);
-void Filter_filter_iter_cascade_isa(void);
-void Filter_filter_iter_cascade_childof(void);
-void Filter_filter_iter_superset_2_rel_instances(void);
-void Filter_filter_iter_superset_2_rel_instances_match_2nd(void);
-void Filter_filter_iter_superset_2_levels(void);
-void Filter_filter_iter_superset_only_w_owned(void);
-void Filter_filter_iter_superset_after_add(void);
-void Filter_filter_iter_superset_after_remove(void);
-void Filter_filter_iter_superset_after_clear(void);
-void Filter_filter_iter_superset_after_delete(void);
-void Filter_filter_iter_2_terms_superset_2_rel_instances(void);
-void Filter_filter_iter_2_terms_superset_2_rel_instances_match_2nd(void);
-void Filter_filter_iter_superset_parent_w_isa(void);
-void Filter_filter_iter_superset_isa_after_remove_parent(void);
-void Filter_filter_iter_superset_isa_create_table_after_iter(void);
-void Filter_filter_iter_superset_2_relations(void);
-void Filter_filter_iter_superset_2_relations_instanced(void);
-void Filter_filter_iter_superset_2_relations_w_component(void);
-void Filter_filter_iter_superset_2_relations_instanced_w_component(void);
-void Filter_filter_iter_not_up_disabled(void);
-void Filter_filter_iter_pair_wildcard_component(void);
-void Filter_filter_w_10_terms(void);
-void Filter_filter_w_10_terms_move(void);
-void Filter_filter_w_10_terms_copy(void);
-void Filter_match_disabled(void);
-void Filter_match_prefab(void);
-void Filter_chain_term_iter(void);
-void Filter_chain_filter_iter(void);
-void Filter_chain_query_iter(void);
-void Filter_chain_rule_iter(void);
-void Filter_chain_iter_2_levels(void);
-void Filter_filter_from_expr_2_terms_err(void);
-void Filter_chain_term_iter_w_term_iter(void);
-void Filter_chain_filter_iter_w_term_iter(void);
-void Filter_chain_w_term_iter_component(void);
-void Filter_chain_iter_w_or(void);
-void Filter_filter_w_recycled_first(void);
-void Filter_filter_w_recycled_second(void);
-void Filter_filter_w_recycled_first_and_id(void);
-void Filter_filter_w_recycled_second_and_id(void);
-void Filter_filter_w_recycled_first_by_name_and_id(void);
-void Filter_filter_w_recycled_second_by_name_and_id(void);
-void Filter_filter_w_recycled_first_by_expr(void);
-void Filter_filter_w_recycled_second_by_expr(void);
-void Filter_filter_w_recycled_first_only_by_expr(void);
-void Filter_term_iter_w_filter_term(void);
-void Filter_filter_iter_w_filter_term(void);
-void Filter_filter_iter_w_2_terms_1_filter(void);
-void Filter_filter_iter_w_3_terms_2_filter(void);
-void Filter_filter_iter_2_terms_filter_all(void);
-void Filter_filter_iter_2_terms_filter_all_w_out(void);
-void Filter_filter_iter_switch_term_filter(void);
-void Filter_filter_iter_2_terms_switch_term_filter(void);
-void Filter_filter_iter_switch_superset(void);
-void Filter_filter_instanced_w_singleton(void);
-void Filter_filter_instanced_w_base(void);
-void Filter_filter_no_instancing_w_singleton(void);
-void Filter_filter_no_instancing_w_base(void);
-void Filter_filter_no_this_tag(void);
-void Filter_filter_no_this_component(void);
-void Filter_filter_no_this_tag_2_ents(void);
-void Filter_filter_no_this_component_2_ents(void);
-void Filter_filter_no_this_tag_2_ents_1_not(void);
-void Filter_filter_no_this_component_2_ents_1_not(void);
-void Filter_filter_no_this_component_1_not(void);
-void Filter_filter_iter_entities_optional_flag(void);
-void Filter_filter_iter_frame_offset(void);
-void Filter_filter_1_term_no_alloc(void);
-void Filter_filter_cache_size_terms_no_alloc(void);
-void Filter_filter_lt_cache_size_terms_no_alloc(void);
-void Filter_move_self(void);
-void Filter_match_empty_tables(void);
-void Filter_match_empty_tables_w_no_empty_tables(void);
-void Filter_match_switch_w_switch(void);
-void Filter_match_switch_w_case(void);
-void Filter_match_switch_w_case_2_terms(void);
-void Filter_match_case_no_case(void);
-void Filter_and_term(void);
-void Filter_or_term(void);
-void Filter_iter_while_creating_components(void);
-void Filter_iter_w_this_var_as_entity(void);
-void Filter_iter_w_this_var_as_table(void);
-void Filter_iter_w_this_var_as_table_range(void);
-void Filter_filter_wo_this_var(void);
-void Filter_set_this_to_table_1_term(void);
-void Filter_set_this_to_table_2_terms(void);
-void Filter_set_this_to_table_1_wildcard(void);
-void Filter_set_this_to_table_no_match_no_data(void);
-void Filter_set_this_to_table_no_match(void);
-void Filter_set_this_to_table_2_terms_no_match(void);
-void Filter_set_this_to_empty_table(void);
-void Filter_set_this_to_empty_table_w_component(void);
-void Filter_set_this_to_implicit_isa_superset_match(void);
-void Filter_set_this_to_self_isa_superset_match(void);
-void Filter_set_this_to_isa_superset_match(void);
-void Filter_set_this_to_childof_superset_match(void);
-void Filter_set_this_to_superset_w_self_filter_no_match(void);
-void Filter_set_this_to_isa_cascade(void);
-void Filter_set_this_to_childof_cascade(void);
-void Filter_set_this_w_wildcard_2_matches(void);
-void Filter_set_this_to_entity_superset_self_has_component(void);
-void Filter_set_this_to_1_entity_in_table(void);
-void Filter_oneof(void);
-void Filter_oneof_expr(void);
-void Filter_oneof_w_mismatching_obj(void);
-void Filter_oneof_w_mismatching_obj_expr(void);
-void Filter_oneof_wildcard(void);
-void Filter_oneof_any(void);
-void Filter_flag_match_only_this(void);
-void Filter_flag_match_only_this_w_ref(void);
-void Filter_filter_w_alloc(void);
-void Filter_filter_w_short_notation(void);
-
-// Testsuite 'FilterStr'
-void FilterStr_one_term(void);
-void FilterStr_one_term_w_inout(void);
-void FilterStr_two_terms(void);
-void FilterStr_two_terms_w_inout(void);
-void FilterStr_three_terms_w_or(void);
-void FilterStr_three_terms_w_or_inout(void);
-void FilterStr_four_terms_three_w_or_inout(void);
-void FilterStr_one_term_w_pair(void);
-void FilterStr_one_term_w_pair_entity_src(void);
-void FilterStr_one_term_w_self(void);
-void FilterStr_one_term_w_up(void);
-void FilterStr_one_term_w_0(void);
-void FilterStr_one_term_w_singleton(void);
-void FilterStr_one_term_w_final_pair(void);
-void FilterStr_one_term_w_final_dont_inherit_pair(void);
-void FilterStr_one_term_w_src_var(void);
-void FilterStr_one_term_w_first_var(void);
-void FilterStr_one_term_w_second_var(void);
-void FilterStr_one_term_w_first_var_entity_src(void);
-void FilterStr_one_term_w_pair_w_0_entity(void);
-void FilterStr_not_term(void);
-void FilterStr_wildcard_term(void);
-void FilterStr_scopes(void);
-void FilterStr_pred_eq(void);
-void FilterStr_pred_neq(void);
-void FilterStr_pred_eq_name(void);
-void FilterStr_pred_neq_name(void);
-void FilterStr_pred_eq_m(void);
-void FilterStr_pred_neq_m(void);
-
-// Testsuite 'Query'
-void Query_simple_query_existing_table(void);
-void Query_simple_query_2_existing_tables(void);
-void Query_simple_query_new_table(void);
-void Query_simple_query_2_new_tables(void);
-void Query_simple_query_existing_and_new_table(void);
-void Query_wildcard_query_existing_table(void);
-void Query_wildcard_query_new_table(void);
-void Query_wildcard_query_existing_table_2_results_p_table(void);
-void Query_wildcard_query_new_table_2_results_p_table(void);
-void Query_wildcard_query_2nd_term(void);
-void Query_wildcard_query_2nd_term_self(void);
-void Query_simple_query_existing_empty_table(void);
-void Query_simple_query_existing_empty_type(void);
-void Query_simple_query_new_empty_table(void);
-void Query_component_query_existing_table(void);
-void Query_component_query_new_table(void);
-void Query_component_query_existing_empty_table(void);
-void Query_2_component_query_existing_empty_table(void);
-void Query_2_component_query_existing_empty_type(void);
-void Query_only_optional(void);
-void Query_only_optional_new_empty_table(void);
-void Query_only_optional_new_empty_non_empty_table(void);
-void Query_only_optional_new_unset_tables(void);
-void Query_singleton_w_optional_new_empty_table(void);
-void Query_singleton_w_optional_new_empty_non_empty_table(void);
-void Query_singleton_w_optional_new_unset_tables(void);
-void Query_query_only_from_entity(void);
-void Query_query_only_from_entity_no_match(void);
-void Query_query_only_from_entity_no_match_iter_alloc(void);
-void Query_query_only_from_singleton(void);
-void Query_query_only_from_entity_match_after(void);
-void Query_query_only_from_singleton_match_after(void);
-void Query_query_only_from_singleton_component_match_after(void);
-void Query_query_only_from_nothing(void);
-void Query_query_only_from_entity_optional(void);
-void Query_query_only_from_entity_no_match_optional(void);
-void Query_query_only_from_entity_or(void);
-void Query_query_only_from_entity_no_match_or(void);
-void Query_query_only_from_entity_or_change(void);
-void Query_query_from_entity_or_change(void);
-void Query_query_from_entity_w_superset(void);
-void Query_query_w_singleton_tag_non_instanced(void);
-void Query_query_w_singleton_tag_instanced(void);
-void Query_query_w_singleton_component_non_instanced(void);
-void Query_query_w_singleton_component_instanced(void);
-void Query_query_w_from_entity(void);
-void Query_query_w_from_singleton(void);
-void Query_query_w_from_entity_match_after(void);
-void Query_query_w_from_singleton_match_after(void);
-void Query_query_w_from_nothing(void);
-void Query_query_w_existing_switch_and_case(void);
-void Query_query_w_new_switch_and_case(void);
-void Query_query_for_case_existing(void);
-void Query_query_for_case_new(void);
-void Query_query_for_switch_filter_term(void);
-void Query_query_switch_from_nothing(void);
-void Query_query_case_from_nothing(void);
-void Query_query_case_inherited(void);
-void Query_query_case_w_generation(void);
-void Query_query_case_w_not_alive(void);
-void Query_query_disabled_from_nothing(void);
-void Query_query_only_2_or(void);
-void Query_query_only_3_or(void);
-void Query_query_2_or(void);
-void Query_query_3_or(void);
-void Query_query_and_type(void);
-void Query_query_or_type(void);
-void Query_query_and_type_match_after(void);
-void Query_query_or_type_match_after(void);
-void Query_query_changed_after_new(void);
-void Query_query_changed_after_delete(void);
-void Query_query_changed_after_add(void);
-void Query_query_changed_after_remove(void);
-void Query_query_changed_after_set(void);
-void Query_query_change_after_modified(void);
-void Query_query_change_after_out_system(void);
-void Query_query_change_after_in_system(void);
-void Query_query_change_after_modified_out_term(void);
-void Query_query_change_check_iter(void);
-void Query_query_change_check_iter_after_skip_read(void);
-void Query_query_change_check_iter_after_skip_write(void);
-void Query_query_change_parent_term(void);
-void Query_query_change_prefab_term(void);
-void Query_query_change_parent_term_w_tag(void);
-void Query_query_change_prefab_term_w_tag(void);
-void Query_query_change_skip_non_instanced(void);
-void Query_query_changed_w_or(void);
-void Query_query_changed_or(void);
-void Query_query_changed_w_singleton(void);
-void Query_query_changed_w_only_singleton(void);
-void Query_query_changed_w_only_singleton_after_set(void);
-void Query_query_changed_w_only_singleton_after_out_term(void);
-void Query_query_changed_w_only_singleton_after_singleton_out_term(void);
-void Query_query_changed_w_only_parent(void);
-void Query_query_changed_w_only_parent_after_set(void);
-void Query_query_changed_w_only_parent_after_out_term(void);
-void Query_query_changed_w_only_parent_after_parent_out_term(void);
-void Query_query_changed_tag(void);
-void Query_query_changed_no_source(void);
-void Query_query_changed_no_source_component(void);
-void Query_query_changed_w_not_out(void);
-void Query_subquery_match_existing(void);
-void Query_subquery_match_new(void);
-void Query_subquery_inactive(void);
-void Query_subquery_unmatch(void);
-void Query_subquery_rematch(void);
-void Query_subquery_rematch_w_parent_optional(void);
-void Query_subquery_rematch_w_sub_optional(void);
-void Query_query_single_pairs(void);
-void Query_query_single_instanceof(void);
-void Query_query_single_childof(void);
-void Query_query_optional_owned(void);
-void Query_query_optional_shared(void);
-void Query_query_optional_shared_nested(void);
-void Query_query_optional_any(void);
-void Query_query_rematch_optional_after_add(void);
-void Query_get_owned_tag(void);
-void Query_get_shared_tag(void);
-void Query_explicit_delete(void);
-void Query_get_column_size(void);
-void Query_orphaned_query(void);
-void Query_nested_orphaned_query(void);
-void Query_invalid_access_orphaned_query(void);
-void Query_stresstest_query_free(void);
-void Query_only_from_entity(void);
-void Query_only_not_from_entity(void);
-void Query_only_from_singleton(void);
-void Query_only_not_from_singleton(void);
-void Query_get_filter(void);
-void Query_group_by(void);
-void Query_group_by_w_ctx(void);
-void Query_group_by_w_sort_reverse_group_creation(void);
-void Query_group_by_iter_one(void);
-void Query_group_by_iter_one_all_groups(void);
-void Query_group_by_iter_one_empty(void);
-void Query_group_by_iter_one_empty_query(void);
-void Query_group_by_iter_one_empty_table(void);
-void Query_group_by_w_deleted_group_id(void);
-void Query_group_by_callbacks(void);
-void Query_group_by_default_action(void);
-void Query_group_table_count(void);
-void Query_iter_valid(void);
-void Query_query_optional_tag(void);
-void Query_query_optional_shared_tag(void);
-void Query_query_iter_10_tags(void);
-void Query_query_iter_20_tags(void);
-void Query_query_iter_10_components(void);
-void Query_query_iter_20_components(void);
-void Query_iter_type_set(void);
-void Query_filter_term(void);
-void Query_2_terms_1_filter(void);
-void Query_3_terms_2_filter(void);
-void Query_no_instancing_w_singleton(void);
-void Query_no_instancing_w_shared(void);
-void Query_query_iter_frame_offset(void);
-void Query_add_singleton_after_query(void);
-void Query_query_w_component_from_parent_from_non_this(void);
-void Query_create_query_while_pending(void);
-void Query_empty_query(void);
-void Query_parent_cascade(void);
-void Query_existing_custom_rel_cascade(void);
-void Query_new_custom_rel_cascade(void);
-void Query_cascade_w_2_depths(void);
-void Query_cascade_w_3_depths(void);
-void Query_cascade_w_2_depths_desc(void);
-void Query_cascade_w_3_depths_desc(void);
-void Query_not_pair_relation_wildcard(void);
-void Query_not_pair_object_wildcard(void);
-void Query_two_pair_wildcards_one_not(void);
-void Query_two_pair_wildcards_one_not_any(void);
-void Query_implicit_existing_isa_superset(void);
-void Query_implicit_new_isa_superset(void);
-void Query_isa_superset(void);
-void Query_isa_superset_2_lvls(void);
-void Query_isa_superset_3_lvls(void);
-void Query_isa_superset_2_lvls_owned(void);
-void Query_isa_superset_3_lvls_owned(void);
-void Query_isa_superset_owned_empty_table_after_match(void);
-void Query_isa_self_superset(void);
-void Query_childof_superset(void);
-void Query_superset_2_targets(void);
-void Query_superset_2_relations(void);
-void Query_superset_2_relations_instanced(void);
-void Query_superset_2_relations_w_component(void);
-void Query_superset_2_relations_instanced_w_component(void);
-void Query_parent(void);
-void Query_existing_isa_cascade(void);
-void Query_new_isa_cascade(void);
-void Query_childof_cascade(void);
-void Query_isa_rematch(void);
-void Query_childof_rematch(void);
-void Query_isa_unmatch(void);
-void Query_childof_unmatch(void);
-void Query_isa_rematch_2_lvls(void);
-void Query_childof_rematch_2_lvls(void);
-void Query_cascade_rematch_2_lvls(void);
-void Query_cascade_rematch_2_lvls_2_relations(void);
-void Query_cascade_topological(void);
-void Query_cascade_desc_rematch_2_lvls(void);
-void Query_cascade_desc_rematch_2_lvls_2_relations(void);
-void Query_cascade_desc_topological(void);
-void Query_childof_rematch_from_isa(void);
-void Query_rematch_optional_ref(void);
-void Query_rematch_optional_ref_w_2_refs(void);
-void Query_rematch_optional_ref_tag_w_ref_component(void);
-void Query_match_query_expr_from_scope(void);
-void Query_query_long_or_w_ref(void);
-void Query_0_query(void);
-void Query_query_w_pair_id_and_subj(void);
-void Query_table_count(void);
-void Query_empty_table_count(void);
-void Query_entity_count(void);
-void Query_rematch_after_delete_inherited_tag(void);
-void Query_rematch_after_delete_rel_of_inherited_pair(void);
-void Query_rematch_after_delete_obj_of_inherited_pair(void);
-void Query_rematch_empty_table_w_superset(void);
-void Query_query_w_short_notation(void);
-void Query_query_w_invalid_filter_flag(void);
-void Query_query_next_table(void);
-void Query_query_next_table_w_changed(void);
-void Query_query_next_table_w_populate(void);
-void Query_query_next_table_w_skip(void);
-void Query_query_next_table_w_populate_first_changed(void);
-void Query_query_next_table_w_populate_last_changed(void);
-void Query_query_next_table_w_populate_skip_first(void);
-void Query_query_next_table_w_populate_skip_last(void);
-void Query_create_query_existing_query_entity(void);
-void Query_query_for_recycled_pair(void);
-void Query_query_w_singleton_w_rule_iter(void);
-void Query_query_w_singleton_nested_iter(void);
-void Query_query_w_singleton_interleaved_iter(void);
-void Query_recycled_component_id(void);
-void Query_set_get_context(void);
-void Query_set_get_binding_context(void);
-void Query_set_get_context_w_free(void);
-void Query_set_get_binding_context_w_free(void);
-void Query_set_this(void);
-void Query_set_this_no_match(void);
-void Query_set_this_is_true(void);
-void Query_set_this_w_wildcard(void);
-void Query_singleton_w_inout_none(void);
-void Query_singleton_w_inout_none_or(void);
-void Query_component_w_inout_none_or(void);
-
-// Testsuite 'Iter'
-void Iter_page_iter_0_0(void);
-void Iter_page_iter_1_0(void);
-void Iter_page_iter_0_1(void);
-void Iter_page_iter_n_0(void);
-void Iter_page_iter_0_n(void);
-void Iter_page_iter_m_n(void);
-void Iter_page_iter_skip_1_table(void);
-void Iter_page_iter_skip_2_tables(void);
-void Iter_worker_iter_1(void);
-void Iter_worker_iter_2(void);
-void Iter_worker_iter_3(void);
-void Iter_worker_iter_4(void);
-void Iter_paged_iter_w_shared_comp(void);
-void Iter_worker_iter_w_shared_comp(void);
-void Iter_paged_iter_w_task_query(void);
-void Iter_worker_iter_w_task_query(void);
-void Iter_worker_iter_w_singleton(void);
-void Iter_worker_iter_w_singleton_component(void);
-void Iter_worker_iter_w_singleton_instanced(void);
-void Iter_worker_iter_w_singleton_component_instanced(void);
-void Iter_paged_iter_w_singleton(void);
-void Iter_paged_iter_w_singleton_component(void);
-void Iter_paged_iter_w_singleton_instanced(void);
-void Iter_paged_iter_w_singleton_component_instanced(void);
-void Iter_count(void);
-void Iter_iter_restore_stack_iter(void);
-void Iter_interleaved_iter(void);
-void Iter_get_first(void);
-void Iter_page_iter_w_only_tag(void);
-void Iter_worker_iter_w_only_tag(void);
-void Iter_page_iter_w_inout_none(void);
-void Iter_worker_iter_w_inout_none(void);
-void Iter_page_iter_w_ctx(void);
-void Iter_page_iter_w_binding_ctx(void);
-void Iter_worker_iter_w_ctx(void);
-void Iter_worker_iter_w_binding_ctx(void);
-void Iter_column_index_owned(void);
-void Iter_column_index_shared(void);
-void Iter_column_index_not(void);
-void Iter_page_iter_w_fini(void);
-void Iter_worker_iter_w_fini(void);
-void Iter_rule_page_iter_w_fini(void);
-void Iter_rule_worker_iter_w_fini(void);
-void Iter_to_str_before_next(void);
-void Iter_to_str(void);
-void Iter_filter_eval_count(void);
-void Iter_query_eval_count(void);
-void Iter_rule_eval_count(void);
-
 // Testsuite 'Pairs'
 void Pairs_type_w_one_pair(void);
 void Pairs_type_w_two_pairs(void);
@@ -1974,7 +1179,6 @@ void Trigger_on_set_superset_after_filter_observer(void);
 void Trigger_on_set_superset_after_filter_observer_w_on_add(void);
 void Trigger_on_set_superset_after_filter_observer_w_on_add_isa_after_set(void);
 void Trigger_on_set_superset_after_filter_observer_w_on_add_2(void);
-void Trigger_propagate_w_union_pair(void);
 
 // Testsuite 'Observer'
 void Observer_2_terms_w_on_add(void);
@@ -2028,6 +1232,10 @@ void Observer_2_terms_1_filter(void);
 void Observer_3_terms_2_filter(void);
 void Observer_and_from(void);
 void Observer_or_from(void);
+void Observer_and_from_empty(void);
+void Observer_or_from_empty(void);
+void Observer_and_from_empty_w_tag(void);
+void Observer_or_from_empty_w_tag(void);
 void Observer_notify_propagated_twice(void);
 void Observer_on_add_yield_existing(void);
 void Observer_on_add_yield_existing_2_tables(void);
@@ -2114,6 +1322,7 @@ void Observer_uni_observer_eval_count(void);
 void Observer_multi_observer_eval_count(void);
 void Observer_yield_existing_uni_no_this(void);
 void Observer_yield_existing_multi_no_this(void);
+void Observer_observer_no_id_in_scope(void);
 void Observer_cache_test_1(void);
 void Observer_cache_test_2(void);
 void Observer_cache_test_3(void);
@@ -2212,7 +1421,6 @@ void TriggerOnSet_on_set_after_override(void);
 void TriggerOnSet_on_set_after_override_w_new(void);
 void TriggerOnSet_on_set_after_override_w_new_w_count(void);
 void TriggerOnSet_on_set_after_override_1_of_2_overridden(void);
-void TriggerOnSet_on_set_after_snapshot_restore(void);
 void TriggerOnSet_on_set_after_remove_override(void);
 void TriggerOnSet_emplace(void);
 void TriggerOnSet_un_set_tag_w_remove(void);
@@ -2341,7 +1549,6 @@ void Prefab_dont_copy_children_for_non_prefab_base(void);
 void Prefab_get_component_pair_from_base(void);
 void Prefab_get_component_pair_from_prefab_base(void);
 void Prefab_override_dont_inherit(void);
-void Prefab_prefab_w_switch(void);
 void Prefab_prefab_child_w_dont_inherit_component(void);
 void Prefab_prefab_child_override(void);
 void Prefab_prefab_child_override_w_exclusive_pair(void);
@@ -2357,7 +1564,6 @@ void Prefab_2_instances_w_slots_same_table(void);
 void Prefab_slot_has_union(void);
 void Prefab_slot_override(void);
 void Prefab_base_slot_override(void);
-void Prefab_prefab_child_w_union(void);
 void Prefab_override_twice_w_add(void);
 void Prefab_override_twice_w_set(void);
 void Prefab_auto_override_copy_once(void);
@@ -2456,10 +1662,8 @@ void Type_entity_path_str(void);
 void Type_entity_instanceof_str(void);
 void Type_entity_childof_str(void);
 void Type_entity_pair_str(void);
-void Type_entity_and_str(void);
 void Type_entity_str_small_buffer(void);
 void Type_role_pair_str(void);
-void Type_role_and_str(void);
 void Type_role_owned_str(void);
 void Type_role_disabled_str(void);
 void Type_large_type_expr(void);
@@ -2518,9 +1722,7 @@ void Commands_async_stage_remove(void);
 void Commands_async_stage_clear(void);
 void Commands_async_stage_delete(void);
 void Commands_async_stage_new(void);
-void Commands_async_stage_no_get(void);
 void Commands_async_stage_readonly(void);
-void Commands_async_stage_is_async(void);
 void Commands_register_component_while_in_progress(void);
 void Commands_register_component_while_staged(void);
 void Commands_register_component_while_deferred(void);
@@ -2538,10 +1740,6 @@ void Commands_update_observer_while_deferred(void);
 void Commands_defer_set_large_component(void);
 void Commands_defer_while_suspend_readonly(void);
 void Commands_defer_while_suspend_readonly_w_existing_commands(void);
-void Commands_defer_add_union_relationship(void);
-void Commands_defer_add_existing_union_relationship(void);
-void Commands_defer_add_union_relationship_2_ops(void);
-void Commands_defer_add_existing_union_relationship_2_ops(void);
 void Commands_defer_remove_after_set(void);
 void Commands_defer_remove_after_set_w_observer(void);
 void Commands_defer_override_after_remove(void);
@@ -2599,6 +1797,8 @@ void Commands_add_path_to_deleted_parent_w_stage(void);
 void Commands_add_path_nested_w_stage(void);
 void Commands_add_path_nested_to_deleted_parent_w_stage(void);
 void Commands_add_path_nested_to_created_deleted_parent_w_stage(void);
+void Commands_defer_emplace_w_arg(void);
+void Commands_defer_emplace_existing_w_arg(void);
 
 // Testsuite 'SingleThreadStaging'
 void SingleThreadStaging_setup(void);
@@ -2663,7 +1863,6 @@ void SingleThreadStaging_on_add_after_new_type_in_progress(void);
 void SingleThreadStaging_lock_table(void);
 void SingleThreadStaging_recursive_lock_table(void);
 void SingleThreadStaging_modify_after_lock(void);
-void SingleThreadStaging_get_case_from_stage(void);
 void SingleThreadStaging_get_object_from_stage(void);
 void SingleThreadStaging_add_to_world_while_readonly(void);
 void SingleThreadStaging_add_to_world_and_stage_while_readonly(void);
@@ -2705,23 +1904,9 @@ void Table_get_depth_2_paths(void);
 void Table_get_column_size(void);
 
 // Testsuite 'Poly'
-void Poly_iter_query(void);
-void Poly_iter_query_w_filter(void);
-void Poly_iter_world(void);
-void Poly_iter_world_w_filter(void);
-void Poly_iter_rule(void);
-void Poly_iter_rule_w_filter(void);
-void Poly_iter_filter(void);
-void Poly_iter_filter_w_filter(void);
 void Poly_on_set_poly_observer(void);
 void Poly_on_set_poly_query(void);
 void Poly_on_set_poly_system(void);
-void Poly_iter_filter_from_entity(void);
-void Poly_iter_query_from_entity(void);
-void Poly_iter_rule_from_entity(void);
-void Poly_free_filter_entity(void);
-void Poly_free_query_entity(void);
-void Poly_free_rule_entity(void);
 
 // Testsuite 'Internals'
 void Internals_setup(void);
@@ -3338,6133 +2523,2988 @@ bake_test_case Entity_testcases[] = {
     {
         "entity_init_existing_no_sep",
         Entity_entity_init_existing_no_sep
-    }
-};
-
-bake_test_case Search_testcases[] = {
-    {
-        "search",
-        Search_search
     },
     {
-        "search_wildcard",
-        Search_search_wildcard
+        "entity_init_w_set_1_comp",
+        Entity_entity_init_w_set_1_comp
     },
     {
-        "search_wildcard_w_offset",
-        Search_search_wildcard_w_offset
+        "entity_init_w_set_2_comp",
+        Entity_entity_init_w_set_2_comp
     },
     {
-        "search_relation_wildcard_w_offset",
-        Search_search_relation_wildcard_w_offset
+        "entity_init_w_set_1_comp_1_tag",
+        Entity_entity_init_w_set_1_comp_1_tag
     },
     {
-        "search_pair_w_any_rel",
-        Search_search_pair_w_any_rel
+        "entity_init_w_set_2_comp_2_tag",
+        Entity_entity_init_w_set_2_comp_2_tag
     },
     {
-        "search_pair_w_any_obj",
-        Search_search_pair_w_any_obj
+        "entity_init_w_set_1_comp_w_name",
+        Entity_entity_init_w_set_1_comp_w_name
     },
     {
-        "search_follow_relation_lvl_0",
-        Search_search_follow_relation_lvl_0
+        "entity_init_w_set_1_comp_existing",
+        Entity_entity_init_w_set_1_comp_existing
     },
     {
-        "search_follow_relation_lvl_1",
-        Search_search_follow_relation_lvl_1
+        "entity_init_w_set_1_comp_existing_empty",
+        Entity_entity_init_w_set_1_comp_existing_empty
     },
     {
-        "search_follow_relation_lvl_2",
-        Search_search_follow_relation_lvl_2
+        "entity_init_w_set_1_comp_1_tag_w_set",
+        Entity_entity_init_w_set_1_comp_1_tag_w_set
     },
     {
-        "search_follow_relation_lvl_3",
-        Search_search_follow_relation_lvl_3
+        "entity_init_w_set_w_hook",
+        Entity_entity_init_w_set_w_hook
     },
     {
-        "search_first_lvl_0",
-        Search_search_first_lvl_0
+        "entity_init_w_set_w_observer",
+        Entity_entity_init_w_set_w_observer
     },
     {
-        "search_first_lvl_1",
-        Search_search_first_lvl_1
+        "entity_init_w_set_1_comp_defer",
+        Entity_entity_init_w_set_1_comp_defer
     },
     {
-        "search_first_lvl_2",
-        Search_search_first_lvl_2
+        "entity_init_w_set_2_comp_defer",
+        Entity_entity_init_w_set_2_comp_defer
     },
     {
-        "search_first_lvl_3",
-        Search_search_first_lvl_3
+        "entity_init_w_set_1_comp_1_tag_defer",
+        Entity_entity_init_w_set_1_comp_1_tag_defer
     },
     {
-        "search_relation_wildcard",
-        Search_search_relation_wildcard
+        "entity_init_w_set_2_comp_2_tag_defer",
+        Entity_entity_init_w_set_2_comp_2_tag_defer
     },
     {
-        "search_relation_at_offset",
-        Search_search_relation_at_offset
+        "entity_init_w_set_1_comp_w_name_defer",
+        Entity_entity_init_w_set_1_comp_w_name_defer
     },
     {
-        "search_relation_inherit_from_parent",
-        Search_search_relation_inherit_from_parent
+        "entity_init_w_set_1_comp_existing_defer",
+        Entity_entity_init_w_set_1_comp_existing_defer
     },
     {
-        "search_relation_dont_inherit",
-        Search_search_relation_dont_inherit
+        "entity_init_w_set_1_comp_existing_empty_defer",
+        Entity_entity_init_w_set_1_comp_existing_empty_defer
     },
     {
-        "search_relation_dont_inherit_from_parent",
-        Search_search_relation_dont_inherit_from_parent
+        "entity_init_w_set_1_comp_1_tag_w_set_defer",
+        Entity_entity_init_w_set_1_comp_1_tag_w_set_defer
     },
     {
-        "search_relation_exclusive",
-        Search_search_relation_exclusive
+        "insert_1_comp",
+        Entity_insert_1_comp
     },
     {
-        "search_relation_union",
-        Search_search_relation_union
+        "insert_2_comp",
+        Entity_insert_2_comp
     },
     {
-        "search_relation_union_wildcard",
-        Search_search_relation_union_wildcard
+        "insert_1_comp_1_tag",
+        Entity_insert_1_comp_1_tag
     },
     {
-        "search_relation_union_pair",
-        Search_search_relation_union_pair
-    }
-};
-
-bake_test_case Event_testcases[] = {
-    {
-        "table_1_id_w_trigger",
-        Event_table_1_id_w_trigger
+        "entity_w_parent",
+        Entity_entity_w_parent
     },
     {
-        "table_2_ids_w_trigger",
-        Event_table_2_ids_w_trigger
+        "entity_w_parent_w_name",
+        Entity_entity_w_parent_w_name
     },
     {
-        "table_1_id_w_observer",
-        Event_table_1_id_w_observer
+        "entity_w_parent_w_add",
+        Entity_entity_w_parent_w_add
     },
     {
-        "table_2_ids_w_observer",
-        Event_table_2_ids_w_observer
+        "entity_w_parent_w_add_w_parent",
+        Entity_entity_w_parent_w_add_w_parent
     },
     {
-        "emit_event_for_empty_table",
-        Event_emit_event_for_empty_table
+        "entity_w_parent_w_set",
+        Entity_entity_w_parent_w_set
     },
     {
-        "emit_table_event",
-        Event_emit_table_event
-    },
+        "entity_w_parent_w_set_w_parent",
+        Entity_entity_w_parent_w_set_w_parent
+    }
+};
+
+bake_test_case Each_testcases[] = {
     {
-        "emit_staged_from_world",
-        Event_emit_staged_from_world
+        "each_tag",
+        Each_each_tag
     },
     {
-        "emit_staged_from_stage",
-        Event_emit_staged_from_stage
+        "each_component",
+        Each_each_component
     },
     {
-        "emit_staged_from_world_observer",
-        Event_emit_staged_from_world_observer
+        "each_pair",
+        Each_each_pair
     },
     {
-        "emit_staged_from_stage_observer",
-        Event_emit_staged_from_stage_observer
+        "each_pair_rel_wildcard",
+        Each_each_pair_rel_wildcard
     },
     {
-        "emit_for_entity",
-        Event_emit_for_entity
-    },
+        "each_pair_tgt_wildcard",
+        Each_each_pair_tgt_wildcard
+    }
+};
+
+bake_test_case Iter_testcases[] = {
     {
-        "emit_custom_for_any",
-        Event_emit_custom_for_any
+        "page_iter_0_0",
+        Iter_page_iter_0_0
     },
     {
-        "emit_custom_implicit_any",
-        Event_emit_custom_implicit_any
+        "page_iter_1_0",
+        Iter_page_iter_1_0
     },
     {
-        "emit_custom_empty_type",
-        Event_emit_custom_empty_type
+        "page_iter_0_1",
+        Iter_page_iter_0_1
     },
     {
-        "emit_w_param",
-        Event_emit_w_param
+        "page_iter_n_0",
+        Iter_page_iter_n_0
     },
     {
-        "emit_w_const_param",
-        Event_emit_w_const_param
+        "page_iter_0_n",
+        Iter_page_iter_0_n
     },
     {
-        "emit_nested",
-        Event_emit_nested
+        "page_iter_m_n",
+        Iter_page_iter_m_n
     },
     {
-        "enqueue_event_1_id",
-        Event_enqueue_event_1_id
+        "page_iter_skip_1_table",
+        Iter_page_iter_skip_1_table
     },
     {
-        "enqueue_event_2_ids",
-        Event_enqueue_event_2_ids
+        "page_iter_skip_2_tables",
+        Iter_page_iter_skip_2_tables
     },
     {
-        "enqueue_event_w_data",
-        Event_enqueue_event_w_data
+        "worker_iter_1",
+        Iter_worker_iter_1
     },
     {
-        "enqueue_event_w_data_move",
-        Event_enqueue_event_w_data_move
+        "worker_iter_2",
+        Iter_worker_iter_2
     },
     {
-        "enqueue_event_w_data_copy",
-        Event_enqueue_event_w_data_copy
+        "worker_iter_3",
+        Iter_worker_iter_3
     },
     {
-        "enqueue_event_w_const_data_no_copy",
-        Event_enqueue_event_w_const_data_no_copy
+        "worker_iter_4",
+        Iter_worker_iter_4
     },
     {
-        "enqueue_event_not_alive",
-        Event_enqueue_event_not_alive
+        "paged_iter_w_shared_comp",
+        Iter_paged_iter_w_shared_comp
     },
     {
-        "enqueue_event_not_alive_w_data_move",
-        Event_enqueue_event_not_alive_w_data_move
+        "worker_iter_w_shared_comp",
+        Iter_worker_iter_w_shared_comp
     },
     {
-        "enqueue_event_not_alive_w_data_copy",
-        Event_enqueue_event_not_alive_w_data_copy
+        "paged_iter_w_task_query",
+        Iter_paged_iter_w_task_query
     },
     {
-        "enqueue_event_not_alive_after_delete_during_merge",
-        Event_enqueue_event_not_alive_after_delete_during_merge
+        "worker_iter_w_task_query",
+        Iter_worker_iter_w_task_query
     },
     {
-        "enqueue_event_not_alive_w_data_move_after_delete_during_merge",
-        Event_enqueue_event_not_alive_w_data_move_after_delete_during_merge
+        "worker_iter_w_singleton",
+        Iter_worker_iter_w_singleton
     },
     {
-        "enqueue_event_not_alive_w_data_copy_after_delete_during_merge",
-        Event_enqueue_event_not_alive_w_data_copy_after_delete_during_merge
+        "worker_iter_w_singleton_component",
+        Iter_worker_iter_w_singleton_component
     },
     {
-        "enqueue_event_not_deferred",
-        Event_enqueue_event_not_deferred
-    },
-    {
-        "enqueue_event_not_deferred_to_async",
-        Event_enqueue_event_not_deferred_to_async
-    },
-    {
-        "enqueue_custom_implicit_any",
-        Event_enqueue_custom_implicit_any
-    },
-    {
-        "enqueue_custom_after_large_cmd",
-        Event_enqueue_custom_after_large_cmd
-    },
-    {
-        "enqueue_on_readonly_world",
-        Event_enqueue_on_readonly_world
-    }
-};
-
-bake_test_case New_testcases[] = {
-    {
-        "empty",
-        New_empty
-    },
-    {
-        "component",
-        New_component
-    },
-    {
-        "tag",
-        New_tag
-    },
-    {
-        "redefine_component",
-        New_redefine_component
-    },
-    {
-        "recycle_id_empty",
-        New_recycle_id_empty
-    },
-    {
-        "recycle_id_w_entity",
-        New_recycle_id_w_entity
-    },
-    {
-        "recycle_empty_staged_delete",
-        New_recycle_empty_staged_delete
-    },
-    {
-        "recycle_staged_delete",
-        New_recycle_staged_delete
-    },
-    {
-        "new_id",
-        New_new_id
-    },
-    {
-        "new_component_id",
-        New_new_component_id
-    },
-    {
-        "new_hi_component_id",
-        New_new_hi_component_id
-    },
-    {
-        "new_component_id_skip_used",
-        New_new_component_id_skip_used
-    },
-    {
-        "new_component_id_skip_to_hi_id",
-        New_new_component_id_skip_to_hi_id
-    },
-    {
-        "new_w_entity_0",
-        New_new_w_entity_0
-    },
-    {
-        "create_w_explicit_id_2_worlds",
-        New_create_w_explicit_id_2_worlds
-    },
-    {
-        "new_w_id_0_w_with",
-        New_new_w_id_0_w_with
-    },
-    {
-        "new_w_id_w_with",
-        New_new_w_id_w_with
-    },
-    {
-        "new_w_type_0_w_with",
-        New_new_w_type_0_w_with
-    },
-    {
-        "new_w_type_w_with",
-        New_new_w_type_w_with
-    },
-    {
-        "new_w_id_w_with_w_scope",
-        New_new_w_id_w_with_w_scope
-    },
-    {
-        "new_w_type_w_with_w_scope",
-        New_new_w_type_w_with_w_scope
-    },
-    {
-        "new_w_id_w_with_defer",
-        New_new_w_id_w_with_defer
-    },
-    {
-        "new_w_id_w_with_defer_w_scope",
-        New_new_w_id_w_with_defer_w_scope
-    },
-    {
-        "new_w_type_w_with_defer",
-        New_new_w_type_w_with_defer
-    },
-    {
-        "new_w_type_w_with_defer_w_scope",
-        New_new_w_type_w_with_defer_w_scope
-    }
-};
-
-bake_test_case New_w_Count_testcases[] = {
-    {
-        "empty",
-        New_w_Count_empty
-    },
-    {
-        "component",
-        New_w_Count_component
-    },
-    {
-        "tag",
-        New_w_Count_tag
-    },
-    {
-        "bulk_init_empty",
-        New_w_Count_bulk_init_empty
-    },
-    {
-        "bulk_init_empty_w_entities",
-        New_w_Count_bulk_init_empty_w_entities
-    },
-    {
-        "bulk_init_1_tag",
-        New_w_Count_bulk_init_1_tag
-    },
-    {
-        "bulk_init_1_tag_w_entities",
-        New_w_Count_bulk_init_1_tag_w_entities
-    },
-    {
-        "bulk_init_2_tags",
-        New_w_Count_bulk_init_2_tags
-    },
-    {
-        "bulk_init_1_component",
-        New_w_Count_bulk_init_1_component
-    },
-    {
-        "bulk_init_2_components",
-        New_w_Count_bulk_init_2_components
-    },
-    {
-        "bulk_init_1_component_w_value",
-        New_w_Count_bulk_init_1_component_w_value
-    },
-    {
-        "bulk_init_2_components_w_value",
-        New_w_Count_bulk_init_2_components_w_value
-    },
-    {
-        "bulk_init_2_components_tag_w_value",
-        New_w_Count_bulk_init_2_components_tag_w_value
-    },
-    {
-        "add_after_bulk",
-        New_w_Count_add_after_bulk
-    },
-    {
-        "add_after_bulk_w_component",
-        New_w_Count_add_after_bulk_w_component
-    },
-    {
-        "add_after_bulk_w_ctor",
-        New_w_Count_add_after_bulk_w_ctor
-    },
-    {
-        "recycle_1_of_2",
-        New_w_Count_recycle_1_of_2
-    },
-    {
-        "recycle_1_of_3",
-        New_w_Count_recycle_1_of_3
-    },
-    {
-        "recycle_2_of_3",
-        New_w_Count_recycle_2_of_3
-    },
-    {
-        "bulk_init_w_table",
-        New_w_Count_bulk_init_w_table
-    }
-};
-
-bake_test_case Add_testcases[] = {
-    {
-        "zero",
-        Add_zero
-    },
-    {
-        "component",
-        Add_component
-    },
-    {
-        "component_again",
-        Add_component_again
-    },
-    {
-        "2_components",
-        Add_2_components
-    },
-    {
-        "2_components_again",
-        Add_2_components_again
-    },
-    {
-        "2_components_overlap",
-        Add_2_components_overlap
-    },
-    {
-        "component_to_nonempty",
-        Add_component_to_nonempty
-    },
-    {
-        "component_to_nonempty_again",
-        Add_component_to_nonempty_again
-    },
-    {
-        "component_to_nonempty_overlap",
-        Add_component_to_nonempty_overlap
-    },
-    {
-        "tag",
-        Add_tag
-    },
-    {
-        "add_entity",
-        Add_add_entity
-    },
-    {
-        "remove_entity",
-        Add_remove_entity
-    },
-    {
-        "add_0_entity",
-        Add_add_0_entity
-    },
-    {
-        "remove_0_entity",
-        Add_remove_0_entity
-    },
-    {
-        "invalid_add_wildcard",
-        Add_invalid_add_wildcard
-    },
-    {
-        "invalid_add_pair_w_wildcard",
-        Add_invalid_add_pair_w_wildcard
-    },
-    {
-        "invalid_add_pair_w_wildcard_rel",
-        Add_invalid_add_pair_w_wildcard_rel
-    },
-    {
-        "invalid_add_pair_w_wildcard_obj",
-        Add_invalid_add_pair_w_wildcard_obj
-    },
-    {
-        "invalid_add_any",
-        Add_invalid_add_any
-    },
-    {
-        "invalid_add_pair_w_any",
-        Add_invalid_add_pair_w_any
-    },
-    {
-        "invalid_add_pair_w_any_rel",
-        Add_invalid_add_pair_w_any_rel
-    },
-    {
-        "invalid_add_pair_w_any_obj",
-        Add_invalid_add_pair_w_any_obj
-    },
-    {
-        "invalid_pair_w_0",
-        Add_invalid_pair_w_0
-    },
-    {
-        "invalid_pair_w_0_rel",
-        Add_invalid_pair_w_0_rel
-    },
-    {
-        "invalid_pair_w_0_obj",
-        Add_invalid_pair_w_0_obj
-    },
-    {
-        "add_random_id",
-        Add_add_random_id
-    }
-};
-
-bake_test_case Switch_testcases[] = {
-    {
-        "get_case_no_switch",
-        Switch_get_case_no_switch
-    },
-    {
-        "get_case_set",
-        Switch_get_case_set
-    },
-    {
-        "get_case_change",
-        Switch_get_case_change
-    },
-    {
-        "remove_case",
-        Switch_remove_case
-    },
-    {
-        "remove_last",
-        Switch_remove_last
-    },
-    {
-        "delete_first",
-        Switch_delete_first
-    },
-    {
-        "delete_last",
-        Switch_delete_last
-    },
-    {
-        "delete_first_last",
-        Switch_delete_first_last
-    },
-    {
-        "3_entities_same_case",
-        Switch_3_entities_same_case
-    },
-    {
-        "2_entities_1_change_case",
-        Switch_2_entities_1_change_case
-    },
-    {
-        "3_entities_change_case",
-        Switch_3_entities_change_case
-    },
-    {
-        "query_switch",
-        Switch_query_switch
-    },
-    {
-        "query_1_case_1_type",
-        Switch_query_1_case_1_type
-    },
-    {
-        "query_1_case_2_types",
-        Switch_query_1_case_2_types
-    },
-    {
-        "query_2_cases_1_type",
-        Switch_query_2_cases_1_type
-    },
-    {
-        "query_2_cases_2_types",
-        Switch_query_2_cases_2_types
-    },
-    {
-        "query_after_remove",
-        Switch_query_after_remove
-    },
-    {
-        "add_case_in_stage",
-        Switch_add_case_in_stage
-    },
-    {
-        "change_case_in_stage",
-        Switch_change_case_in_stage
-    },
-    {
-        "change_one_case_in_stage",
-        Switch_change_one_case_in_stage
-    },
-    {
-        "remove_switch_in_stage",
-        Switch_remove_switch_in_stage
-    },
-    {
-        "switch_no_match_for_case",
-        Switch_switch_no_match_for_case
-    },
-    {
-        "empty_entity_has_case",
-        Switch_empty_entity_has_case
-    },
-    {
-        "zero_entity_has_case",
-        Switch_zero_entity_has_case
-    },
-    {
-        "add_to_entity_w_switch",
-        Switch_add_to_entity_w_switch
-    },
-    {
-        "add_pair_to_entity_w_switch",
-        Switch_add_pair_to_entity_w_switch
-    },
-    {
-        "sort",
-        Switch_sort
-    },
-    {
-        "recycled_tags",
-        Switch_recycled_tags
-    },
-    {
-        "query_recycled_tags",
-        Switch_query_recycled_tags
-    },
-    {
-        "single_case",
-        Switch_single_case
-    },
-    {
-        "match_switch_on_base_instance",
-        Switch_match_switch_on_base_instance
-    },
-    {
-        "switch_w_bitset_query",
-        Switch_switch_w_bitset_query
-    },
-    {
-        "switch_w_bitset_query_inv",
-        Switch_switch_w_bitset_query_inv
-    },
-    {
-        "switch_w_bitset_query_2_elems",
-        Switch_switch_w_bitset_query_2_elems
-    },
-    {
-        "switch_w_bitset_query_2_elems_skip",
-        Switch_switch_w_bitset_query_2_elems_skip
-    },
-    {
-        "switch_w_bitset_query_elems_interleaved",
-        Switch_switch_w_bitset_query_elems_interleaved
-    },
-    {
-        "switch_w_bitset_query_elems_interleaved_2_types",
-        Switch_switch_w_bitset_query_elems_interleaved_2_types
-    },
-    {
-        "has_wildcard",
-        Switch_has_wildcard
-    },
-    {
-        "remove_wildcard",
-        Switch_remove_wildcard
-    },
-    {
-        "same_table_after_change",
-        Switch_same_table_after_change
-    },
-    {
-        "component_relation",
-        Switch_component_relation
-    },
-    {
-        "delete_case_trigger_after_delete_switch",
-        Switch_delete_case_trigger_after_delete_switch
-    },
-    {
-        "add_2",
-        Switch_add_2
-    },
-    {
-        "add_2_reverse",
-        Switch_add_2_reverse
-    },
-    {
-        "add_switch_to_prefab_instance",
-        Switch_add_switch_to_prefab_instance
-    },
-    {
-        "get_case_w_generation",
-        Switch_get_case_w_generation
-    },
-    {
-        "get_case_w_generation_not_alive",
-        Switch_get_case_w_generation_not_alive
-    }
-};
-
-bake_test_case EnabledComponents_testcases[] = {
-    {
-        "is_component_enabled",
-        EnabledComponents_is_component_enabled
-    },
-    {
-        "is_empty_entity_disabled",
-        EnabledComponents_is_empty_entity_disabled
-    },
-    {
-        "is_0_entity_disabled",
-        EnabledComponents_is_0_entity_disabled
-    },
-    {
-        "is_0_component_disabled",
-        EnabledComponents_is_0_component_disabled
-    },
-    {
-        "is_nonexist_component_disabled",
-        EnabledComponents_is_nonexist_component_disabled
-    },
-    {
-        "is_enabled_component_enabled",
-        EnabledComponents_is_enabled_component_enabled
-    },
-    {
-        "is_disabled_component_enabled",
-        EnabledComponents_is_disabled_component_enabled
-    },
-    {
-        "has_enabled_component",
-        EnabledComponents_has_enabled_component
-    },
-    {
-        "is_enabled_after_add",
-        EnabledComponents_is_enabled_after_add
-    },
-    {
-        "is_enabled_after_remove",
-        EnabledComponents_is_enabled_after_remove
-    },
-    {
-        "is_enabled_after_disable",
-        EnabledComponents_is_enabled_after_disable
-    },
-    {
-        "is_disabled_after_enable",
-        EnabledComponents_is_disabled_after_enable
-    },
-    {
-        "is_enabled_randomized",
-        EnabledComponents_is_enabled_randomized
-    },
-    {
-        "is_enabled_after_add_randomized",
-        EnabledComponents_is_enabled_after_add_randomized
-    },
-    {
-        "is_enabled_after_randomized_add_randomized",
-        EnabledComponents_is_enabled_after_randomized_add_randomized
-    },
-    {
-        "is_enabled_2",
-        EnabledComponents_is_enabled_2
-    },
-    {
-        "is_enabled_3",
-        EnabledComponents_is_enabled_3
-    },
-    {
-        "is_enabled_2_after_add",
-        EnabledComponents_is_enabled_2_after_add
-    },
-    {
-        "is_enabled_3_after_add",
-        EnabledComponents_is_enabled_3_after_add
-    },
-    {
-        "is_pair_enabled",
-        EnabledComponents_is_pair_enabled
-    },
-    {
-        "is_enabled_pair_enabled",
-        EnabledComponents_is_enabled_pair_enabled
-    },
-    {
-        "is_disabled_pair_enabled",
-        EnabledComponents_is_disabled_pair_enabled
-    },
-    {
-        "has_enabled_pair",
-        EnabledComponents_has_enabled_pair
-    },
-    {
-        "is_pair_enabled_after_add",
-        EnabledComponents_is_pair_enabled_after_add
-    },
-    {
-        "is_pair_enabled_after_remove",
-        EnabledComponents_is_pair_enabled_after_remove
-    },
-    {
-        "is_pair_enabled_after_disable",
-        EnabledComponents_is_pair_enabled_after_disable
-    },
-    {
-        "is_pair_disabled_after_enable",
-        EnabledComponents_is_pair_disabled_after_enable
-    },
-    {
-        "is_pair_enabled_2",
-        EnabledComponents_is_pair_enabled_2
-    },
-    {
-        "is_pair_enabled_3",
-        EnabledComponents_is_pair_enabled_3
-    },
-    {
-        "is_pair_enabled_2_after_add",
-        EnabledComponents_is_pair_enabled_2_after_add
-    },
-    {
-        "is_pair_enabled_3_after_add",
-        EnabledComponents_is_pair_enabled_3_after_add
-    },
-    {
-        "query_disabled",
-        EnabledComponents_query_disabled
-    },
-    {
-        "query_disabled_skip_initial",
-        EnabledComponents_query_disabled_skip_initial
-    },
-    {
-        "query_disabled_pair",
-        EnabledComponents_query_disabled_pair
-    },
-    {
-        "query_disabled_pair_skip_initial",
-        EnabledComponents_query_disabled_pair_skip_initial
-    },
-    {
-        "query_mod_2",
-        EnabledComponents_query_mod_2
-    },
-    {
-        "query_mod_8",
-        EnabledComponents_query_mod_8
-    },
-    {
-        "query_mod_64",
-        EnabledComponents_query_mod_64
-    },
-    {
-        "query_mod_256",
-        EnabledComponents_query_mod_256
-    },
-    {
-        "query_mod_1024",
-        EnabledComponents_query_mod_1024
-    },
-    {
-        "query_enable_mod_10",
-        EnabledComponents_query_enable_mod_10
-    },
-    {
-        "query_mod_2_2_bitsets",
-        EnabledComponents_query_mod_2_2_bitsets
-    },
-    {
-        "query_mod_8_2_bitsets",
-        EnabledComponents_query_mod_8_2_bitsets
-    },
-    {
-        "query_mod_64_2_bitsets",
-        EnabledComponents_query_mod_64_2_bitsets
-    },
-    {
-        "query_mod_256_2_bitsets",
-        EnabledComponents_query_mod_256_2_bitsets
-    },
-    {
-        "query_mod_1024_2_bitsets",
-        EnabledComponents_query_mod_1024_2_bitsets
-    },
-    {
-        "query_randomized_2_bitsets",
-        EnabledComponents_query_randomized_2_bitsets
-    },
-    {
-        "query_randomized_3_bitsets",
-        EnabledComponents_query_randomized_3_bitsets
-    },
-    {
-        "query_randomized_4_bitsets",
-        EnabledComponents_query_randomized_4_bitsets
-    },
-    {
-        "defer_enable",
-        EnabledComponents_defer_enable
-    },
-    {
-        "sort",
-        EnabledComponents_sort
-    },
-    {
-        "table_move_2_from_3",
-        EnabledComponents_table_move_2_from_3
-    }
-};
-
-bake_test_case Remove_testcases[] = {
-    {
-        "zero",
-        Remove_zero
-    },
-    {
-        "1_of_1",
-        Remove_1_of_1
-    },
-    {
-        "1_of_2",
-        Remove_1_of_2
-    },
-    {
-        "2_of_2",
-        Remove_2_of_2
-    },
-    {
-        "2_of_3",
-        Remove_2_of_3
-    },
-    {
-        "1_of_1_again",
-        Remove_1_of_1_again
-    },
-    {
-        "2_again",
-        Remove_2_again
-    },
-    {
-        "2_overlap",
-        Remove_2_overlap
-    },
-    {
-        "1_from_empty",
-        Remove_1_from_empty
-    },
-    {
-        "not_added",
-        Remove_not_added
-    }
-};
-
-bake_test_case GlobalComponentIds_testcases[] = {
-    {
-        "declare",
-        GlobalComponentIds_declare
-    },
-    {
-        "declare_w_entity",
-        GlobalComponentIds_declare_w_entity
-    },
-    {
-        "declare_2_world",
-        GlobalComponentIds_declare_2_world
-    },
-    {
-        "declare_tag",
-        GlobalComponentIds_declare_tag
-    },
-    {
-        "declare_tag_w_entity",
-        GlobalComponentIds_declare_tag_w_entity
-    },
-    {
-        "declare_entity",
-        GlobalComponentIds_declare_entity
-    },
-    {
-        "reuse_300_component_ids",
-        GlobalComponentIds_reuse_300_component_ids
-    }
-};
-
-bake_test_case Hierarchies_testcases[] = {
-    {
-        "empty_scope",
-        Hierarchies_empty_scope
-    },
-    {
-        "get_parent",
-        Hierarchies_get_parent
-    },
-    {
-        "get_parent_from_nested",
-        Hierarchies_get_parent_from_nested
-    },
-    {
-        "get_parent_from_nested_2",
-        Hierarchies_get_parent_from_nested_2
-    },
-    {
-        "get_object_from_0",
-        Hierarchies_get_object_from_0
-    },
-    {
-        "tree_iter_empty",
-        Hierarchies_tree_iter_empty
-    },
-    {
-        "tree_iter_1_table",
-        Hierarchies_tree_iter_1_table
-    },
-    {
-        "tree_iter_2_tables",
-        Hierarchies_tree_iter_2_tables
-    },
-    {
-        "path_depth_0",
-        Hierarchies_path_depth_0
-    },
-    {
-        "path_depth_1",
-        Hierarchies_path_depth_1
-    },
-    {
-        "path_depth_2",
-        Hierarchies_path_depth_2
-    },
-    {
-        "path_core",
-        Hierarchies_path_core
-    },
-    {
-        "path_core_w_prefix",
-        Hierarchies_path_core_w_prefix
-    },
-    {
-        "path_core_w_empty_prefix",
-        Hierarchies_path_core_w_empty_prefix
-    },
-    {
-        "path_this_w_empty_prefix",
-        Hierarchies_path_this_w_empty_prefix
-    },
-    {
-        "path_wildcard_w_empty_prefix",
-        Hierarchies_path_wildcard_w_empty_prefix
-    },
-    {
-        "path_any_w_empty_prefix",
-        Hierarchies_path_any_w_empty_prefix
-    },
-    {
-        "rel_path_from_root",
-        Hierarchies_rel_path_from_root
-    },
-    {
-        "rel_path_from_self",
-        Hierarchies_rel_path_from_self
-    },
-    {
-        "rel_path_depth_1",
-        Hierarchies_rel_path_depth_1
-    },
-    {
-        "rel_path_depth_2",
-        Hierarchies_rel_path_depth_2
-    },
-    {
-        "rel_path_no_match",
-        Hierarchies_rel_path_no_match
-    },
-    {
-        "path_custom_sep",
-        Hierarchies_path_custom_sep
-    },
-    {
-        "path_custom_prefix",
-        Hierarchies_path_custom_prefix
-    },
-    {
-        "path_prefix_rel_match",
-        Hierarchies_path_prefix_rel_match
-    },
-    {
-        "path_prefix_rel_no_match",
-        Hierarchies_path_prefix_rel_no_match
-    },
-    {
-        "fullpath_for_core",
-        Hierarchies_fullpath_for_core
-    },
-    {
-        "path_w_number",
-        Hierarchies_path_w_number
-    },
-    {
-        "lookup_depth_0",
-        Hierarchies_lookup_depth_0
-    },
-    {
-        "lookup_depth_1",
-        Hierarchies_lookup_depth_1
-    },
-    {
-        "lookup_depth_2",
-        Hierarchies_lookup_depth_2
-    },
-    {
-        "lookup_rel_0",
-        Hierarchies_lookup_rel_0
-    },
-    {
-        "lookup_rel_1",
-        Hierarchies_lookup_rel_1
-    },
-    {
-        "lookup_rel_2",
-        Hierarchies_lookup_rel_2
-    },
-    {
-        "lookup_custom_sep",
-        Hierarchies_lookup_custom_sep
-    },
-    {
-        "lookup_custom_prefix",
-        Hierarchies_lookup_custom_prefix
-    },
-    {
-        "lookup_custom_prefix_from_root",
-        Hierarchies_lookup_custom_prefix_from_root
-    },
-    {
-        "lookup_self",
-        Hierarchies_lookup_self
-    },
-    {
-        "lookup_in_parent_from_scope",
-        Hierarchies_lookup_in_parent_from_scope
-    },
-    {
-        "lookup_in_root_from_scope",
-        Hierarchies_lookup_in_root_from_scope
-    },
-    {
-        "lookup_number",
-        Hierarchies_lookup_number
-    },
-    {
-        "delete_children",
-        Hierarchies_delete_children
-    },
-    {
-        "scope_set",
-        Hierarchies_scope_set
-    },
-    {
-        "scope_set_again",
-        Hierarchies_scope_set_again
-    },
-    {
-        "scope_set_w_new",
-        Hierarchies_scope_set_w_new
-    },
-    {
-        "scope_set_w_new_staged",
-        Hierarchies_scope_set_w_new_staged
-    },
-    {
-        "scope_set_w_lookup",
-        Hierarchies_scope_set_w_lookup
-    },
-    {
-        "scope_component",
-        Hierarchies_scope_component
-    },
-    {
-        "scope_component_no_macro",
-        Hierarchies_scope_component_no_macro
-    },
-    {
-        "new_from_path_depth_0",
-        Hierarchies_new_from_path_depth_0
-    },
-    {
-        "new_from_path_depth_1",
-        Hierarchies_new_from_path_depth_1
-    },
-    {
-        "new_from_path_depth_2",
-        Hierarchies_new_from_path_depth_2
-    },
-    {
-        "new_from_path_existing_depth_0",
-        Hierarchies_new_from_path_existing_depth_0
-    },
-    {
-        "new_from_path_existing_depth_1",
-        Hierarchies_new_from_path_existing_depth_1
-    },
-    {
-        "new_from_path_existing_depth_2",
-        Hierarchies_new_from_path_existing_depth_2
-    },
-    {
-        "add_path_depth_0",
-        Hierarchies_add_path_depth_0
-    },
-    {
-        "add_path_depth_1",
-        Hierarchies_add_path_depth_1
-    },
-    {
-        "add_path_depth_2",
-        Hierarchies_add_path_depth_2
-    },
-    {
-        "add_path_existing_depth_0",
-        Hierarchies_add_path_existing_depth_0
-    },
-    {
-        "add_path_existing_depth_1",
-        Hierarchies_add_path_existing_depth_1
-    },
-    {
-        "add_path_existing_depth_2",
-        Hierarchies_add_path_existing_depth_2
-    },
-    {
-        "add_path_from_scope",
-        Hierarchies_add_path_from_scope
-    },
-    {
-        "add_path_from_scope_new_entity",
-        Hierarchies_add_path_from_scope_new_entity
-    },
-    {
-        "add_root_path_to_child",
-        Hierarchies_add_root_path_to_child
-    },
-    {
-        "add_parent_path_from_root_to_child",
-        Hierarchies_add_parent_path_from_root_to_child
-    },
-    {
-        "new_w_child_in_root",
-        Hierarchies_new_w_child_in_root
-    },
-    {
-        "delete_child",
-        Hierarchies_delete_child
-    },
-    {
-        "delete_2_children",
-        Hierarchies_delete_2_children
-    },
-    {
-        "delete_2_children_different_type",
-        Hierarchies_delete_2_children_different_type
-    },
-    {
-        "delete_tree_2_levels",
-        Hierarchies_delete_tree_2_levels
-    },
-    {
-        "delete_tree_3_levels",
-        Hierarchies_delete_tree_3_levels
-    },
-    {
-        "delete_tree_count_tables",
-        Hierarchies_delete_tree_count_tables
-    },
-    {
-        "delete_tree_staged",
-        Hierarchies_delete_tree_staged
-    },
-    {
-        "delete_tree_empty_table",
-        Hierarchies_delete_tree_empty_table
-    },
-    {
-        "delete_tree_recreate",
-        Hierarchies_delete_tree_recreate
-    },
-    {
-        "delete_tree_w_onremove",
-        Hierarchies_delete_tree_w_onremove
-    },
-    {
-        "delete_tree_w_dtor",
-        Hierarchies_delete_tree_w_dtor
-    },
-    {
-        "get_child_count",
-        Hierarchies_get_child_count
-    },
-    {
-        "get_child_count_2_tables",
-        Hierarchies_get_child_count_2_tables
-    },
-    {
-        "get_child_count_no_children",
-        Hierarchies_get_child_count_no_children
-    },
-    {
-        "scope_iter_after_delete_tree",
-        Hierarchies_scope_iter_after_delete_tree
-    },
-    {
-        "add_child_after_delete_tree",
-        Hierarchies_add_child_after_delete_tree
-    },
-    {
-        "add_child_to_recycled_parent",
-        Hierarchies_add_child_to_recycled_parent
-    },
-    {
-        "get_type_after_recycled_parent_add",
-        Hierarchies_get_type_after_recycled_parent_add
-    },
-    {
-        "rematch_after_add_to_recycled_parent",
-        Hierarchies_rematch_after_add_to_recycled_parent
-    },
-    {
-        "cascade_after_recycled_parent_change",
-        Hierarchies_cascade_after_recycled_parent_change
-    },
-    {
-        "long_name_depth_0",
-        Hierarchies_long_name_depth_0
-    },
-    {
-        "long_name_depth_1",
-        Hierarchies_long_name_depth_1
-    },
-    {
-        "long_name_depth_2",
-        Hierarchies_long_name_depth_2
-    },
-    {
-        "ensure_1_parent_after_adding_2",
-        Hierarchies_ensure_1_parent_after_adding_2
-    },
-    {
-        "ensure_child_alive_after_deleting_prev_parent",
-        Hierarchies_ensure_child_alive_after_deleting_prev_parent
-    },
-    {
-        "lookup_after_root_to_parent_move",
-        Hierarchies_lookup_after_root_to_parent_move
-    },
-    {
-        "lookup_after_parent_to_root_move",
-        Hierarchies_lookup_after_parent_to_root_move
-    },
-    {
-        "lookup_after_parent_to_parent_move",
-        Hierarchies_lookup_after_parent_to_parent_move
-    },
-    {
-        "lookup_after_clear_from_root",
-        Hierarchies_lookup_after_clear_from_root
-    },
-    {
-        "lookup_after_clear_from_parent",
-        Hierarchies_lookup_after_clear_from_parent
-    },
-    {
-        "lookup_after_delete_from_root",
-        Hierarchies_lookup_after_delete_from_root
-    },
-    {
-        "lookup_after_delete_from_parent",
-        Hierarchies_lookup_after_delete_from_parent
-    },
-    {
-        "defer_batch_remove_name_w_add_childof",
-        Hierarchies_defer_batch_remove_name_w_add_childof
-    },
-    {
-        "defer_batch_remove_childof_w_add_name",
-        Hierarchies_defer_batch_remove_childof_w_add_name
-    }
-};
-
-bake_test_case FixedHierarchies_testcases[] = {
-    {
-        "make_fixed_1_lvl",
-        FixedHierarchies_make_fixed_1_lvl
-    },
-    {
-        "make_fixed_1_lvl_w_init",
-        FixedHierarchies_make_fixed_1_lvl_w_init
-    },
-    {
-        "make_fixed_1_lvl_w_init_comp",
-        FixedHierarchies_make_fixed_1_lvl_w_init_comp
-    },
-    {
-        "make_fixed_1_lvl_w_init_comp_after_tree_fixed",
-        FixedHierarchies_make_fixed_1_lvl_w_init_comp_after_tree_fixed
-    },
-    {
-        "make_fixed_1_lvl_2_entities",
-        FixedHierarchies_make_fixed_1_lvl_2_entities
-    },
-    {
-        "make_fixed_1_lvl_2_tables",
-        FixedHierarchies_make_fixed_1_lvl_2_tables
-    },
-    {
-        "make_fixed_2_lvl",
-        FixedHierarchies_make_fixed_2_lvl
-    },
-    {
-        "make_fixed_2_lvl_2_tables",
-        FixedHierarchies_make_fixed_2_lvl_2_tables
-    },
-    {
-        "make_fixed_3_lvl",
-        FixedHierarchies_make_fixed_3_lvl
-    },
-    {
-        "make_fixed_3_lvl_w_name",
-        FixedHierarchies_make_fixed_3_lvl_w_name
-    },
-    {
-        "make_fixed_3_2_lvl_w_name",
-        FixedHierarchies_make_fixed_3_2_lvl_w_name
-    },
-    {
-        "make_fixed_2_lvl_nested",
-        FixedHierarchies_make_fixed_2_lvl_nested
-    },
-    {
-        "make_fixed_3_lvl_nested",
-        FixedHierarchies_make_fixed_3_lvl_nested
-    },
-    {
-        "make_fixed_1_lvl_after_delete",
-        FixedHierarchies_make_fixed_1_lvl_after_delete
-    },
-    {
-        "get_target_1_lvl",
-        FixedHierarchies_get_target_1_lvl
-    },
-    {
-        "get_target_2_lvl",
-        FixedHierarchies_get_target_2_lvl
-    },
-    {
-        "get_depth_1_lvl",
-        FixedHierarchies_get_depth_1_lvl
-    },
-    {
-        "get_depth_2_lvl",
-        FixedHierarchies_get_depth_2_lvl
-    },
-    {
-        "get_depth_after_reparent_root",
-        FixedHierarchies_get_depth_after_reparent_root
-    },
-    {
-        "delete_fixed_1_lvl",
-        FixedHierarchies_delete_fixed_1_lvl
-    },
-    {
-        "delete_fixed_2_lvl",
-        FixedHierarchies_delete_fixed_2_lvl
-    },
-    {
-        "delete_with_fixed_1_lvl",
-        FixedHierarchies_delete_with_fixed_1_lvl
-    },
-    {
-        "delete_with_fixed_2_lvl",
-        FixedHierarchies_delete_with_fixed_2_lvl
-    },
-    {
-        "query_w_parent_field_1_lvl",
-        FixedHierarchies_query_w_parent_field_1_lvl
-    },
-    {
-        "query_w_parent_field_1_lvl_w_init",
-        FixedHierarchies_query_w_parent_field_1_lvl_w_init
-    },
-    {
-        "query_w_parent_field_1_lvl_w_init_comp_after_tree_fixed",
-        FixedHierarchies_query_w_parent_field_1_lvl_w_init_comp_after_tree_fixed
-    },
-    {
-        "query_w_parent_field_2_lvl",
-        FixedHierarchies_query_w_parent_field_2_lvl
-    },
-    {
-        "query_w_parent_field_1_fixed_1_regular",
-        FixedHierarchies_query_w_parent_field_1_fixed_1_regular
-    },
-    {
-        "query_w_parent_field_only_fixed_1_lvls",
-        FixedHierarchies_query_w_parent_field_only_fixed_1_lvls
-    },
-    {
-        "query_w_parent_field_fixed_1_lvls_no_match",
-        FixedHierarchies_query_w_parent_field_fixed_1_lvls_no_match
-    },
-    {
-        "query_w_parent_field_fixed_1_lvls_2_no_match",
-        FixedHierarchies_query_w_parent_field_fixed_1_lvls_2_no_match
-    },
-    {
-        "query_w_parent_field_fixed_1_lvls_match_no_match",
-        FixedHierarchies_query_w_parent_field_fixed_1_lvls_match_no_match
-    },
-    {
-        "query_w_parent_field_fixed_1_lvls_no_match_match",
-        FixedHierarchies_query_w_parent_field_fixed_1_lvls_no_match_match
-    },
-    {
-        "query_w_parent_field_2_fixed_2_lvls",
-        FixedHierarchies_query_w_parent_field_2_fixed_2_lvls
-    },
-    {
-        "query_w_cascade_field_2_lvl",
-        FixedHierarchies_query_w_cascade_field_2_lvl
-    },
-    {
-        "query_next_table",
-        FixedHierarchies_query_next_table
-    },
-    {
-        "query_next_table_1_elem",
-        FixedHierarchies_query_next_table_1_elem
-    },
-    {
-        "query_next_table_1_elem_no_match",
-        FixedHierarchies_query_next_table_1_elem_no_match
-    },
-    {
-        "query_nested_make_fixed",
-        FixedHierarchies_query_nested_make_fixed
-    },
-    {
-        "query_nested_make_fixed_w_optional",
-        FixedHierarchies_query_nested_make_fixed_w_optional
-    },
-    {
-        "query_nested_make_fixed_w_optional_match_children_only",
-        FixedHierarchies_query_nested_make_fixed_w_optional_match_children_only
-    },
-    {
-        "query_nested_w_2_parents_make_fixed",
-        FixedHierarchies_query_nested_w_2_parents_make_fixed
-    },
-    {
-        "query_table_w_3_parents",
-        FixedHierarchies_query_table_w_3_parents
-    },
-    {
-        "query_w_parent_change_detection_1st",
-        FixedHierarchies_query_w_parent_change_detection_1st
-    },
-    {
-        "query_w_parent_change_detection_2nd",
-        FixedHierarchies_query_w_parent_change_detection_2nd
-    },
-    {
-        "query_w_parent_change_detection_iter_twice",
-        FixedHierarchies_query_w_parent_change_detection_iter_twice
-    },
-    {
-        "query_w_parent_change_detection_iter_twice_each_parent",
-        FixedHierarchies_query_w_parent_change_detection_iter_twice_each_parent
-    },
-    {
-        "query_w_parent_change_detection_1st_populate_when_changed",
-        FixedHierarchies_query_w_parent_change_detection_1st_populate_when_changed
-    },
-    {
-        "query_w_parent_change_detection_2nd_populate_when_changed",
-        FixedHierarchies_query_w_parent_change_detection_2nd_populate_when_changed
-    },
-    {
-        "query_w_parent_change_detection_iter_twice_populate_when_changed",
-        FixedHierarchies_query_w_parent_change_detection_iter_twice_populate_when_changed
-    },
-    {
-        "query_w_parent_change_detection_iter_twice_each_parent_populate_when_changed",
-        FixedHierarchies_query_w_parent_change_detection_iter_twice_each_parent_populate_when_changed
-    },
-    {
-        "staged_query_w_parent_field_1_lvl",
-        FixedHierarchies_staged_query_w_parent_field_1_lvl
-    },
-    {
-        "staged_query_w_parent_field_2_lvl",
-        FixedHierarchies_staged_query_w_parent_field_2_lvl
-    },
-    {
-        "staged_query_w_parent_field_1_fixed_1_regular",
-        FixedHierarchies_staged_query_w_parent_field_1_fixed_1_regular
-    },
-    {
-        "staged_query_w_cascade_field_2_lvl",
-        FixedHierarchies_staged_query_w_cascade_field_2_lvl
-    },
-    {
-        "add_to_fixed",
-        FixedHierarchies_add_to_fixed
-    },
-    {
-        "remove_from_fixed",
-        FixedHierarchies_remove_from_fixed
-    },
-    {
-        "delete_fixed",
-        FixedHierarchies_delete_fixed
-    },
-    {
-        "clear_fixed",
-        FixedHierarchies_clear_fixed
-    },
-    {
-        "make_fixed_1_lvl_w_name",
-        FixedHierarchies_make_fixed_1_lvl_w_name
-    },
-    {
-        "make_fixed_2_lvl_w_name",
-        FixedHierarchies_make_fixed_2_lvl_w_name
-    },
-    {
-        "make_fixed_1_lvl_w_name_keep_name",
-        FixedHierarchies_make_fixed_1_lvl_w_name_keep_name
-    },
-    {
-        "make_fixed_2_lvl_w_name_keep_name",
-        FixedHierarchies_make_fixed_2_lvl_w_name_keep_name
-    },
-    {
-        "make_fixed_2_lvl_lose_depth",
-        FixedHierarchies_make_fixed_2_lvl_lose_depth
-    },
-    {
-        "make_fixed_3_lvl_lose_depth",
-        FixedHierarchies_make_fixed_3_lvl_lose_depth
-    }
-};
-
-bake_test_case Has_testcases[] = {
-    {
-        "zero",
-        Has_zero
-    },
-    {
-        "1_of_0",
-        Has_1_of_0
-    },
-    {
-        "1_of_1",
-        Has_1_of_1
-    },
-    {
-        "1_of_2",
-        Has_1_of_2
-    },
-    {
-        "1_of_empty",
-        Has_1_of_empty
-    },
-    {
-        "has_in_progress",
-        Has_has_in_progress
-    },
-    {
-        "has_of_zero",
-        Has_has_of_zero
-    },
-    {
-        "owns",
-        Has_owns
-    },
-    {
-        "owns_wildcard",
-        Has_owns_wildcard
-    },
-    {
-        "owns_wildcard_pair",
-        Has_owns_wildcard_pair
-    },
-    {
-        "has_entity",
-        Has_has_entity
-    },
-    {
-        "has_entity_0",
-        Has_has_entity_0
-    },
-    {
-        "has_entity_0_component",
-        Has_has_entity_0_component
-    },
-    {
-        "has_entity_owned",
-        Has_has_entity_owned
-    },
-    {
-        "has_entity_owned_0",
-        Has_has_entity_owned_0
-    },
-    {
-        "has_entity_owned_0_component",
-        Has_has_entity_owned_0_component
-    },
-    {
-        "has_wildcard",
-        Has_has_wildcard
-    },
-    {
-        "has_wildcard_pair",
-        Has_has_wildcard_pair
-    }
-};
-
-bake_test_case Count_testcases[] = {
-    {
-        "count_empty",
-        Count_count_empty
-    },
-    {
-        "count_w_entity_0",
-        Count_count_w_entity_0
-    },
-    {
-        "count_1_component",
-        Count_count_1_component
-    },
-    {
-        "count_disabled",
-        Count_count_disabled
-    },
-    {
-        "count_prefab",
-        Count_count_prefab
-    }
-};
-
-bake_test_case Get_component_testcases[] = {
-    {
-        "get_empty",
-        Get_component_get_empty
-    },
-    {
-        "get_1_from_1",
-        Get_component_get_1_from_1
-    },
-    {
-        "get_1_from_2",
-        Get_component_get_1_from_2
-    },
-    {
-        "get_2_from_2",
-        Get_component_get_2_from_2
-    },
-    {
-        "get_2_from_3",
-        Get_component_get_2_from_3
-    },
-    {
-        "get_1_from_2_in_progress_from_main_stage",
-        Get_component_get_1_from_2_in_progress_from_main_stage
-    },
-    {
-        "get_1_from_2_add_in_progress",
-        Get_component_get_1_from_2_add_in_progress
-    },
-    {
-        "get_both_from_2_add_in_progress",
-        Get_component_get_both_from_2_add_in_progress
-    },
-    {
-        "get_both_from_2_add_remove_in_progress",
-        Get_component_get_both_from_2_add_remove_in_progress
-    },
-    {
-        "get_childof_component",
-        Get_component_get_childof_component
-    },
-    {
-        "ensure_equal_get",
-        Get_component_ensure_equal_get
-    },
-    {
-        "get_tag",
-        Get_component_get_tag
-    },
-    {
-        "get_pair_tag",
-        Get_component_get_pair_tag
-    },
-    {
-        "get_wildcard",
-        Get_component_get_wildcard
-    }
-};
-
-bake_test_case Reference_testcases[] = {
-    {
-        "get_ref",
-        Reference_get_ref
-    },
-    {
-        "get_ref_after_add",
-        Reference_get_ref_after_add
-    },
-    {
-        "get_ref_after_remove",
-        Reference_get_ref_after_remove
-    },
-    {
-        "get_ref_after_delete",
-        Reference_get_ref_after_delete
-    },
-    {
-        "get_ref_after_realloc",
-        Reference_get_ref_after_realloc
-    },
-    {
-        "get_ref_after_realloc_w_lifecycle",
-        Reference_get_ref_after_realloc_w_lifecycle
-    },
-    {
-        "get_ref_staged",
-        Reference_get_ref_staged
-    },
-    {
-        "get_ref_after_new_in_stage",
-        Reference_get_ref_after_new_in_stage
-    },
-    {
-        "get_ref_monitored",
-        Reference_get_ref_monitored
-    },
-    {
-        "get_ref_w_low_id_tag",
-        Reference_get_ref_w_low_id_tag
-    },
-    {
-        "get_ref_w_low_id_tag_after_add",
-        Reference_get_ref_w_low_id_tag_after_add
-    },
-    {
-        "get_nonexisting",
-        Reference_get_nonexisting
-    },
-    {
-        "aba_table",
-        Reference_aba_table
-    }
-};
-
-bake_test_case Delete_testcases[] = {
-    {
-        "delete_1",
-        Delete_delete_1
-    },
-    {
-        "delete_1_again",
-        Delete_delete_1_again
-    },
-    {
-        "delete_recycled_tag_again",
-        Delete_delete_recycled_tag_again
-    },
-    {
-        "delete_empty",
-        Delete_delete_empty
-    },
-    {
-        "delete_nonexist",
-        Delete_delete_nonexist
-    },
-    {
-        "delete_1st_of_3",
-        Delete_delete_1st_of_3
-    },
-    {
-        "delete_2nd_of_3",
-        Delete_delete_2nd_of_3
-    },
-    {
-        "delete_3rd_of_3",
-        Delete_delete_3rd_of_3
-    },
-    {
-        "delete_2_of_3",
-        Delete_delete_2_of_3
-    },
-    {
-        "delete_3_of_3",
-        Delete_delete_3_of_3
-    },
-    {
-        "delete_w_on_remove",
-        Delete_delete_w_on_remove
-    },
-    {
-        "clear_1_component",
-        Delete_clear_1_component
-    },
-    {
-        "clear_2_components",
-        Delete_clear_2_components
-    },
-    {
-        "alive_after_delete",
-        Delete_alive_after_delete
-    },
-    {
-        "alive_after_clear",
-        Delete_alive_after_clear
-    },
-    {
-        "alive_after_staged_delete",
-        Delete_alive_after_staged_delete
-    },
-    {
-        "alive_while_staged",
-        Delete_alive_while_staged
-    },
-    {
-        "alive_while_staged_w_delete",
-        Delete_alive_while_staged_w_delete
-    },
-    {
-        "alive_while_staged_w_delete_recycled_id",
-        Delete_alive_while_staged_w_delete_recycled_id
-    },
-    {
-        "alive_after_recycle",
-        Delete_alive_after_recycle
-    },
-    {
-        "delete_recycled",
-        Delete_delete_recycled
-    },
-    {
-        "get_alive_for_alive",
-        Delete_get_alive_for_alive
-    },
-    {
-        "get_alive_for_recycled",
-        Delete_get_alive_for_recycled
-    },
-    {
-        "get_alive_for_not_alive",
-        Delete_get_alive_for_not_alive
-    },
-    {
-        "get_alive_w_generation_for_recycled_alive",
-        Delete_get_alive_w_generation_for_recycled_alive
-    },
-    {
-        "get_alive_w_generation_for_recycled_not_alive",
-        Delete_get_alive_w_generation_for_recycled_not_alive
-    },
-    {
-        "get_alive_for_0",
-        Delete_get_alive_for_0
-    },
-    {
-        "get_alive_for_nonexistent",
-        Delete_get_alive_for_nonexistent
-    },
-    {
-        "move_w_dtor_move",
-        Delete_move_w_dtor_move
-    },
-    {
-        "move_w_dtor_no_move",
-        Delete_move_w_dtor_no_move
-    },
-    {
-        "move_w_no_dtor_move",
-        Delete_move_w_no_dtor_move
-    },
-    {
-        "wrap_generation_count",
-        Delete_wrap_generation_count
-    }
-};
-
-bake_test_case OnDelete_testcases[] = {
-    {
-        "flags",
-        OnDelete_flags
-    },
-    {
-        "id_default",
-        OnDelete_id_default
-    },
-    {
-        "id_remove",
-        OnDelete_id_remove
-    },
-    {
-        "id_delete",
-        OnDelete_id_delete
-    },
-    {
-        "relation_default",
-        OnDelete_relation_default
-    },
-    {
-        "relation_remove",
-        OnDelete_relation_remove
-    },
-    {
-        "relation_delete",
-        OnDelete_relation_delete
-    },
-    {
-        "object_default",
-        OnDelete_object_default
-    },
-    {
-        "object_remove",
-        OnDelete_object_remove
-    },
-    {
-        "object_delete",
-        OnDelete_object_delete
-    },
-    {
-        "id_throw",
-        OnDelete_id_throw
-    },
-    {
-        "relation_throw",
-        OnDelete_relation_throw
-    },
-    {
-        "object_throw",
-        OnDelete_object_throw
-    },
-    {
-        "object_mixed",
-        OnDelete_object_mixed
-    },
-    {
-        "id_remove_no_instances",
-        OnDelete_id_remove_no_instances
-    },
-    {
-        "id_delete_no_instances",
-        OnDelete_id_delete_no_instances
-    },
-    {
-        "id_throw_no_instances",
-        OnDelete_id_throw_no_instances
-    },
-    {
-        "cyclic_self",
-        OnDelete_cyclic_self
-    },
-    {
-        "nonempty_cyclic_self",
-        OnDelete_nonempty_cyclic_self
-    },
-    {
-        "cyclic_id_default",
-        OnDelete_cyclic_id_default
-    },
-    {
-        "cyclic_id_remove",
-        OnDelete_cyclic_id_remove
-    },
-    {
-        "cyclic_id_remove_both",
-        OnDelete_cyclic_id_remove_both
-    },
-    {
-        "cyclic_id_delete",
-        OnDelete_cyclic_id_delete
-    },
-    {
-        "cyclic_id_delete_both",
-        OnDelete_cyclic_id_delete_both
-    },
-    {
-        "cyclic_relation_default",
-        OnDelete_cyclic_relation_default
-    },
-    {
-        "cyclic_relation_remove",
-        OnDelete_cyclic_relation_remove
-    },
-    {
-        "cyclic_relation_remove_both",
-        OnDelete_cyclic_relation_remove_both
-    },
-    {
-        "cyclic_relation_delete",
-        OnDelete_cyclic_relation_delete
-    },
-    {
-        "cyclic_relation_delete_both",
-        OnDelete_cyclic_relation_delete_both
-    },
-    {
-        "cyclic_object_default",
-        OnDelete_cyclic_object_default
-    },
-    {
-        "cyclic_object_remove",
-        OnDelete_cyclic_object_remove
-    },
-    {
-        "cyclic_object_delete",
-        OnDelete_cyclic_object_delete
-    },
-    {
-        "cyclic_overlapping_table",
-        OnDelete_cyclic_overlapping_table
-    },
-    {
-        "cyclic_overlapping_new_tables",
-        OnDelete_cyclic_overlapping_new_tables
-    },
-    {
-        "cyclic_object_mixed",
-        OnDelete_cyclic_object_mixed
-    },
-    {
-        "cyclic_storage_table",
-        OnDelete_cyclic_storage_table
-    },
-    {
-        "cyclic_storage_table_2",
-        OnDelete_cyclic_storage_table_2
-    },
-    {
-        "cyclic_storage_table_3",
-        OnDelete_cyclic_storage_table_3
-    },
-    {
-        "cyclic_set_empty",
-        OnDelete_cyclic_set_empty
-    },
-    {
-        "2_acyclic_relations_w_cycle",
-        OnDelete_2_acyclic_relations_w_cycle
-    },
-    {
-        "remove_2_comps",
-        OnDelete_remove_2_comps
-    },
-    {
-        "remove_2_comps_to_existing_table",
-        OnDelete_remove_2_comps_to_existing_table
-    },
-    {
-        "delete_recursive",
-        OnDelete_delete_recursive
-    },
-    {
-        "component_throw",
-        OnDelete_component_throw
-    },
-    {
-        "remove_2_relations",
-        OnDelete_remove_2_relations
-    },
-    {
-        "remove_object_w_2_relations",
-        OnDelete_remove_object_w_2_relations
-    },
-    {
-        "remove_object_w_5_relations",
-        OnDelete_remove_object_w_5_relations
-    },
-    {
-        "remove_object_w_50_relations",
-        OnDelete_remove_object_w_50_relations
-    },
-    {
-        "remove_object_w_50_relations_3_tables",
-        OnDelete_remove_object_w_50_relations_3_tables
-    },
-    {
-        "remove_object_w_3_relations_interleaved",
-        OnDelete_remove_object_w_3_relations_interleaved
-    },
-    {
-        "remove_id_from_2_tables",
-        OnDelete_remove_id_from_2_tables
-    },
-    {
-        "remove_relation_from_2_tables",
-        OnDelete_remove_relation_from_2_tables
-    },
-    {
-        "remove_object_from_2_tables",
-        OnDelete_remove_object_from_2_tables
-    },
-    {
-        "remove_id_and_relation",
-        OnDelete_remove_id_and_relation
-    },
-    {
-        "remove_id_and_relation_from_2_tables",
-        OnDelete_remove_id_and_relation_from_2_tables
-    },
-    {
-        "stresstest_many_objects",
-        OnDelete_stresstest_many_objects
-    },
-    {
-        "stresstest_many_relations",
-        OnDelete_stresstest_many_relations
-    },
-    {
-        "stresstest_many_objects_on_delete",
-        OnDelete_stresstest_many_objects_on_delete
-    },
-    {
-        "stresstest_many_relations_on_delete",
-        OnDelete_stresstest_many_relations_on_delete
-    },
-    {
-        "empty_table_w_on_remove",
-        OnDelete_empty_table_w_on_remove
-    },
-    {
-        "delete_table_in_on_remove_during_fini",
-        OnDelete_delete_table_in_on_remove_during_fini
-    },
-    {
-        "delete_other_in_on_remove_during_fini",
-        OnDelete_delete_other_in_on_remove_during_fini
-    },
-    {
-        "remove_id_w_role",
-        OnDelete_remove_id_w_role
-    },
-    {
-        "remove_rel_w_override_pair",
-        OnDelete_remove_rel_w_override_pair
-    },
-    {
-        "remove_obj_w_override_pair",
-        OnDelete_remove_obj_w_override_pair
-    },
-    {
-        "remove_rel_w_override_pair_after_on_delete_target",
-        OnDelete_remove_rel_w_override_pair_after_on_delete_target
-    },
-    {
-        "remove_rel_w_override_pair_2_ids",
-        OnDelete_remove_rel_w_override_pair_2_ids
-    },
-    {
-        "remove_obj_w_override_pair_2_ids",
-        OnDelete_remove_obj_w_override_pair_2_ids
-    },
-    {
-        "remove_obj_w_override_pair_3_ids",
-        OnDelete_remove_obj_w_override_pair_3_ids
-    },
-    {
-        "remove_mixed_w_override_pair_3_ids",
-        OnDelete_remove_mixed_w_override_pair_3_ids
-    },
-    {
-        "merge_pair_component",
-        OnDelete_merge_pair_component
-    },
-    {
-        "delete_with_tag",
-        OnDelete_delete_with_tag
-    },
-    {
-        "delete_with_component",
-        OnDelete_delete_with_component
-    },
-    {
-        "delete_with_pair",
-        OnDelete_delete_with_pair
-    },
-    {
-        "delete_with_object_wildcard",
-        OnDelete_delete_with_object_wildcard
-    },
-    {
-        "delete_with_relation_wildcard",
-        OnDelete_delete_with_relation_wildcard
-    },
-    {
-        "delete_with_component_after_delete_cyclic_self",
-        OnDelete_delete_with_component_after_delete_cyclic_self
-    },
-    {
-        "delete_with_component_after_delete_cyclic",
-        OnDelete_delete_with_component_after_delete_cyclic
-    },
-    {
-        "delete_with_component_after_delete_cyclic_w_alive_moved",
-        OnDelete_delete_with_component_after_delete_cyclic_w_alive_moved
-    },
-    {
-        "delete_all_with_entity",
-        OnDelete_delete_all_with_entity
-    },
-    {
-        "remove_childof_entity",
-        OnDelete_remove_childof_entity
-    },
-    {
-        "remove_childof_wildcard",
-        OnDelete_remove_childof_wildcard
-    },
-    {
-        "delete_child_of_delete_with",
-        OnDelete_delete_child_of_delete_with
-    },
-    {
-        "deep_clean_64",
-        OnDelete_deep_clean_64
-    },
-    {
-        "deep_clean_256",
-        OnDelete_deep_clean_256
-    },
-    {
-        "id_w_switch",
-        OnDelete_id_w_switch
-    },
-    {
-        "id_w_disabled",
-        OnDelete_id_w_disabled
-    },
-    {
-        "id_to_no_switch",
-        OnDelete_id_to_no_switch
-    },
-    {
-        "id_to_no_disabled",
-        OnDelete_id_to_no_disabled
-    },
-    {
-        "remove_on_delete_action",
-        OnDelete_remove_on_delete_action
-    },
-    {
-        "delete_with_w_relation",
-        OnDelete_delete_with_w_relation
-    },
-    {
-        "delete_self_in_on_remove",
-        OnDelete_delete_self_in_on_remove
-    },
-    {
-        "delete_nested_in_on_remove",
-        OnDelete_delete_nested_in_on_remove
-    },
-    {
-        "add_deleted_in_on_remove",
-        OnDelete_add_deleted_in_on_remove
-    },
-    {
-        "delete_tree_w_query",
-        OnDelete_delete_tree_w_query
-    },
-    {
-        "fini_cleanup_order",
-        OnDelete_fini_cleanup_order
-    },
-    {
-        "fini_cleanup_order_root_id_w_trait",
-        OnDelete_fini_cleanup_order_root_id_w_trait
-    },
-    {
-        "fini_cleanup_order_entity_after_singleton",
-        OnDelete_fini_cleanup_order_entity_after_singleton
-    },
-    {
-        "fini_cleanup_order_entity_after_component",
-        OnDelete_fini_cleanup_order_entity_after_component
-    },
-    {
-        "on_delete_parent_w_in_use_id_w_remove",
-        OnDelete_on_delete_parent_w_in_use_id_w_remove
-    },
-    {
-        "on_delete_parent_w_in_use_id_w_delete",
-        OnDelete_on_delete_parent_w_in_use_id_w_delete
-    },
-    {
-        "create_after_delete_with",
-        OnDelete_create_after_delete_with
-    },
-    {
-        "delete_with_inherited_tag",
-        OnDelete_delete_with_inherited_tag
-    },
-    {
-        "delete_with_inherited_tag_w_query",
-        OnDelete_delete_with_inherited_tag_w_query
-    },
-    {
-        "delete_with_inherited_tag_w_observer",
-        OnDelete_delete_with_inherited_tag_w_observer
-    },
-    {
-        "delete_symmetric_relation",
-        OnDelete_delete_symmetric_relation
-    },
-    {
-        "delete_observed_symmetric_relation",
-        OnDelete_delete_observed_symmetric_relation
-    },
-    {
-        "nested_delete_with",
-        OnDelete_nested_delete_with
-    },
-    {
-        "deferred_delete_with_after_create_named",
-        OnDelete_deferred_delete_with_after_create_named
-    },
-    {
-        "deferred_delete_with_childof_after_create_named",
-        OnDelete_deferred_delete_with_childof_after_create_named
-    },
-    {
-        "match_marked_for_deletion",
-        OnDelete_match_marked_for_deletion
-    },
-    {
-        "delete_w_low_rel_mixed_cleanup",
-        OnDelete_delete_w_low_rel_mixed_cleanup
-    },
-    {
-        "delete_w_low_rel_mixed_cleanup_interleaved_ids",
-        OnDelete_delete_w_low_rel_mixed_cleanup_interleaved_ids
-    },
-    {
-        "fini_query_w_singleton_in_scope_no_module",
-        OnDelete_fini_query_w_singleton_in_scope_no_module
-    },
-    {
-        "fini_query_w_singleton_in_module",
-        OnDelete_fini_query_w_singleton_in_module
-    },
-    {
-        "fini_observer_w_relationship_in_scope",
-        OnDelete_fini_observer_w_relationship_in_scope
-    }
-};
-
-bake_test_case Set_testcases[] = {
-    {
-        "set_empty",
-        Set_set_empty
-    },
-    {
-        "set_nonempty",
-        Set_set_nonempty
-    },
-    {
-        "set_non_empty_override",
-        Set_set_non_empty_override
-    },
-    {
-        "set_again",
-        Set_set_again
-    },
-    {
-        "set_2",
-        Set_set_2
-    },
-    {
-        "add_set",
-        Set_add_set
-    },
-    {
-        "set_add",
-        Set_set_add
-    },
-    {
-        "set_add_other",
-        Set_set_add_other
-    },
-    {
-        "set_remove",
-        Set_set_remove
-    },
-    {
-        "set_remove_other",
-        Set_set_remove_other
-    },
-    {
-        "set_remove_twice",
-        Set_set_remove_twice
-    },
-    {
-        "set_and_new",
-        Set_set_and_new
-    },
-    {
-        "set_null",
-        Set_set_null
-    },
-    {
-        "ensure_new",
-        Set_ensure_new
-    },
-    {
-        "ensure_existing",
-        Set_ensure_existing
-    },
-    {
-        "ensure_tag_new",
-        Set_ensure_tag_new
-    },
-    {
-        "ensure_tag_existing",
-        Set_ensure_tag_existing
-    },
-    {
-        "ensure_tag_new_w_comp",
-        Set_ensure_tag_new_w_comp
-    },
-    {
-        "ensure_tag_existing_w_comp",
-        Set_ensure_tag_existing_w_comp
-    },
-    {
-        "ensure_tag_new_w_pair",
-        Set_ensure_tag_new_w_pair
-    },
-    {
-        "ensure_tag_existing_w_pair",
-        Set_ensure_tag_existing_w_pair
-    },
-    {
-        "get_mut_not_existing",
-        Set_get_mut_not_existing
-    },
-    {
-        "get_mut_existing",
-        Set_get_mut_existing
-    },
-    {
-        "get_mut_tag",
-        Set_get_mut_tag
-    },
-    {
-        "get_mut_pair",
-        Set_get_mut_pair
-    },
-    {
-        "get_mut_pair_second",
-        Set_get_mut_pair_second
-    },
-    {
-        "modified_w_on_set",
-        Set_modified_w_on_set
-    },
-    {
-        "modified_no_component",
-        Set_modified_no_component
-    },
-    {
-        "ensure_w_add_in_on_add",
-        Set_ensure_w_add_in_on_add
-    },
-    {
-        "ensure_w_remove_in_on_add",
-        Set_ensure_w_remove_in_on_add
-    },
-    {
-        "ensure_w_realloc_in_on_add",
-        Set_ensure_w_realloc_in_on_add
-    },
-    {
-        "emplace",
-        Set_emplace
-    },
-    {
-        "emplace_2",
-        Set_emplace_2
-    },
-    {
-        "emplace_existing",
-        Set_emplace_existing
-    },
-    {
-        "emplace_w_move",
-        Set_emplace_w_move
-    },
-    {
-        "emplace_w_observer_w_add",
-        Set_emplace_w_observer_w_add
-    }
-};
-
-bake_test_case ReadWrite_testcases[] = {
-    {
-        "read",
-        ReadWrite_read
-    },
-    {
-        "nested_read",
-        ReadWrite_nested_read
-    },
-    {
-        "write",
-        ReadWrite_write
-    },
-    {
-        "nested_write",
-        ReadWrite_nested_write
-    },
-    {
-        "add_while_read",
-        ReadWrite_add_while_read
-    },
-    {
-        "add_while_write",
-        ReadWrite_add_while_write
-    },
-    {
-        "read_from_stage",
-        ReadWrite_read_from_stage
-    },
-    {
-        "write_from_stage",
-        ReadWrite_write_from_stage
-    }
-};
-
-bake_test_case Lookup_testcases[] = {
-    {
-        "lookup",
-        Lookup_lookup
-    },
-    {
-        "lookup_component",
-        Lookup_lookup_component
-    },
-    {
-        "lookup_not_found",
-        Lookup_lookup_not_found
-    },
-    {
-        "lookup_child",
-        Lookup_lookup_child
-    },
-    {
-        "lookup_w_null_name",
-        Lookup_lookup_w_null_name
-    },
-    {
-        "lookup_after_name_reset",
-        Lookup_lookup_after_name_reset
-    },
-    {
-        "get_name",
-        Lookup_get_name
-    },
-    {
-        "get_name_no_name",
-        Lookup_get_name_no_name
-    },
-    {
-        "get_name_from_empty",
-        Lookup_get_name_from_empty
-    },
-    {
-        "lookup_by_id",
-        Lookup_lookup_by_id
-    },
-    {
-        "lookup_recycled_by_id",
-        Lookup_lookup_recycled_by_id
-    },
-    {
-        "lookup_symbol_by_id",
-        Lookup_lookup_symbol_by_id
-    },
-    {
-        "lookup_name_w_digit",
-        Lookup_lookup_name_w_digit
-    },
-    {
-        "lookup_symbol_w_digit",
-        Lookup_lookup_symbol_w_digit
-    },
-    {
-        "lookup_path_w_digit",
-        Lookup_lookup_path_w_digit
-    },
-    {
-        "lookup_name_w_spaces",
-        Lookup_lookup_name_w_spaces
-    },
-    {
-        "lookup_path_w_spaces",
-        Lookup_lookup_path_w_spaces
-    },
-    {
-        "set_name_of_existing",
-        Lookup_set_name_of_existing
-    },
-    {
-        "change_name_of_existing",
-        Lookup_change_name_of_existing
-    },
-    {
-        "lookup_alias",
-        Lookup_lookup_alias
-    },
-    {
-        "lookup_scoped_alias",
-        Lookup_lookup_scoped_alias
-    },
-    {
-        "define_duplicate_alias",
-        Lookup_define_duplicate_alias
-    },
-    {
-        "lookup_null",
-        Lookup_lookup_null
-    },
-    {
-        "lookup_symbol_null",
-        Lookup_lookup_symbol_null
-    },
-    {
-        "lookup_this",
-        Lookup_lookup_this
-    },
-    {
-        "lookup_wildcard",
-        Lookup_lookup_wildcard
-    },
-    {
-        "lookup_any",
-        Lookup_lookup_any
-    },
-    {
-        "lookup_variable",
-        Lookup_lookup_variable
-    },
-    {
-        "lookup_path_this",
-        Lookup_lookup_path_this
-    },
-    {
-        "lookup_path_wildcard",
-        Lookup_lookup_path_wildcard
-    },
-    {
-        "lookup_path_this_from_scope",
-        Lookup_lookup_path_this_from_scope
-    },
-    {
-        "lookup_path_wildcard_from_scope",
-        Lookup_lookup_path_wildcard_from_scope
-    },
-    {
-        "resolve_builtin_symbols",
-        Lookup_resolve_builtin_symbols
-    },
-    {
-        "lookup_from_scope_staged",
-        Lookup_lookup_from_scope_staged
-    },
-    {
-        "lookup_core",
-        Lookup_lookup_core
-    },
-    {
-        "lookup_core_from_stage",
-        Lookup_lookup_core_from_stage
-    },
-    {
-        "lookup_custom_search_path",
-        Lookup_lookup_custom_search_path
-    },
-    {
-        "lookup_custom_search_path_from_stage",
-        Lookup_lookup_custom_search_path_from_stage
-    },
-    {
-        "lookup_custom_search_path_n_elems",
-        Lookup_lookup_custom_search_path_n_elems
-    },
-    {
-        "set_same_name",
-        Lookup_set_same_name
-    },
-    {
-        "set_same_name_after_reparenting",
-        Lookup_set_same_name_after_reparenting
-    },
-    {
-        "defer_set_name",
-        Lookup_defer_set_name
-    },
-    {
-        "defer_set_same_name",
-        Lookup_defer_set_same_name
-    },
-    {
-        "lookup_invalid_digit",
-        Lookup_lookup_invalid_digit
-    },
-    {
-        "lookup_child_invalid_digit",
-        Lookup_lookup_child_invalid_digit
-    },
-    {
-        "lookup_digit_from_wrong_scope",
-        Lookup_lookup_digit_from_wrong_scope
-    },
-    {
-        "lookup_core_entity_from_wrong_scope",
-        Lookup_lookup_core_entity_from_wrong_scope
-    },
-    {
-        "lookup_alias_w_number",
-        Lookup_lookup_alias_w_number
-    },
-    {
-        "lookup_symbol_path",
-        Lookup_lookup_symbol_path
-    }
-};
-
-bake_test_case Singleton_testcases[] = {
-    {
-        "add_singleton",
-        Singleton_add_singleton
-    },
-    {
-        "remove_singleton",
-        Singleton_remove_singleton
-    },
-    {
-        "set_get_singleton",
-        Singleton_set_get_singleton
-    },
-    {
-        "ensure_singleton",
-        Singleton_ensure_singleton
-    },
-    {
-        "singleton_system",
-        Singleton_singleton_system
-    }
-};
-
-bake_test_case Clone_testcases[] = {
-    {
-        "empty",
-        Clone_empty
-    },
-    {
-        "empty_w_value",
-        Clone_empty_w_value
-    },
-    {
-        "null",
-        Clone_null
-    },
-    {
-        "null_w_value",
-        Clone_null_w_value
-    },
-    {
-        "1_component",
-        Clone_1_component
-    },
-    {
-        "2_component",
-        Clone_2_component
-    },
-    {
-        "1_component_w_value",
-        Clone_1_component_w_value
-    },
-    {
-        "2_component_w_value",
-        Clone_2_component_w_value
-    },
-    {
-        "3_component",
-        Clone_3_component
-    },
-    {
-        "3_component_w_value",
-        Clone_3_component_w_value
-    },
-    {
-        "tag",
-        Clone_tag
-    },
-    {
-        "tag_w_value",
-        Clone_tag_w_value
-    },
-    {
-        "1_tag_1_component",
-        Clone_1_tag_1_component
-    },
-    {
-        "1_tag_1_component_w_value",
-        Clone_1_tag_1_component_w_value
-    },
-    {
-        "clone_w_name",
-        Clone_clone_w_name
-    }
-};
-
-bake_test_case ComponentLifecycle_testcases[] = {
-    {
-        "ctor_on_add",
-        ComponentLifecycle_ctor_on_add
-    },
-    {
-        "ctor_on_new",
-        ComponentLifecycle_ctor_on_new
-    },
-    {
-        "dtor_on_remove",
-        ComponentLifecycle_dtor_on_remove
-    },
-    {
-        "dtor_on_delete",
-        ComponentLifecycle_dtor_on_delete
-    },
-    {
-        "copy_on_set",
-        ComponentLifecycle_copy_on_set
-    },
-    {
-        "copy_on_override",
-        ComponentLifecycle_copy_on_override
-    },
-    {
-        "copy_on_clone",
-        ComponentLifecycle_copy_on_clone
-    },
-    {
-        "no_copy_on_move",
-        ComponentLifecycle_no_copy_on_move
-    },
-    {
-        "ctor_copy_on_snapshot",
-        ComponentLifecycle_ctor_copy_on_snapshot
-    },
-    {
-        "copy_on_snapshot",
-        ComponentLifecycle_copy_on_snapshot
-    },
-    {
-        "dtor_on_restore",
-        ComponentLifecycle_dtor_on_restore
-    },
-    {
-        "ctor_on_tag",
-        ComponentLifecycle_ctor_on_tag
-    },
-    {
-        "dtor_on_tag",
-        ComponentLifecycle_dtor_on_tag
-    },
-    {
-        "copy_on_tag",
-        ComponentLifecycle_copy_on_tag
-    },
-    {
-        "move_on_tag",
-        ComponentLifecycle_move_on_tag
-    },
-    {
-        "merge_to_different_table",
-        ComponentLifecycle_merge_to_different_table
-    },
-    {
-        "merge_to_new_table",
-        ComponentLifecycle_merge_to_new_table
-    },
-    {
-        "delete_in_stage",
-        ComponentLifecycle_delete_in_stage
-    },
-    {
-        "ctor_on_add_pair",
-        ComponentLifecycle_ctor_on_add_pair
-    },
-    {
-        "ctor_on_add_pair_tag",
-        ComponentLifecycle_ctor_on_add_pair_tag
-    },
-    {
-        "ctor_on_move_pair",
-        ComponentLifecycle_ctor_on_move_pair
-    },
-    {
-        "move_on_realloc",
-        ComponentLifecycle_move_on_realloc
-    },
-    {
-        "move_on_bulk_new",
-        ComponentLifecycle_move_on_bulk_new
-    },
-    {
-        "on_add_on_bulk_new",
-        ComponentLifecycle_on_add_on_bulk_new
-    },
-    {
-        "move_on_delete",
-        ComponentLifecycle_move_on_delete
-    },
-    {
-        "move_dtor_on_delete",
-        ComponentLifecycle_move_dtor_on_delete
-    },
-    {
-        "copy_on_override_pair",
-        ComponentLifecycle_copy_on_override_pair
-    },
-    {
-        "copy_on_override_pair_tag",
-        ComponentLifecycle_copy_on_override_pair_tag
-    },
-    {
-        "copy_on_set_pair",
-        ComponentLifecycle_copy_on_set_pair
-    },
-    {
-        "copy_on_set_pair_tag",
-        ComponentLifecycle_copy_on_set_pair_tag
-    },
-    {
-        "allow_lifecycle_overwrite_equal_callbacks",
-        ComponentLifecycle_allow_lifecycle_overwrite_equal_callbacks
-    },
-    {
-        "set_lifecycle_after_trigger",
-        ComponentLifecycle_set_lifecycle_after_trigger
-    },
-    {
-        "valid_entity_in_dtor_after_delete",
-        ComponentLifecycle_valid_entity_in_dtor_after_delete
-    },
-    {
-        "ctor_w_emplace",
-        ComponentLifecycle_ctor_w_emplace
-    },
-    {
-        "ctor_w_emplace_defer",
-        ComponentLifecycle_ctor_w_emplace_defer
-    },
-    {
-        "ctor_w_emplace_defer_use_move_ctor",
-        ComponentLifecycle_ctor_w_emplace_defer_use_move_ctor
-    },
-    {
-        "on_add_w_emplace",
-        ComponentLifecycle_on_add_w_emplace
-    },
-    {
-        "on_add_w_emplace_existing",
-        ComponentLifecycle_on_add_w_emplace_existing
-    },
-    {
-        "on_add_w_emplace_defer",
-        ComponentLifecycle_on_add_w_emplace_defer
-    },
-    {
-        "merge_async_stage_w_emplace",
-        ComponentLifecycle_merge_async_stage_w_emplace
-    },
-    {
-        "merge_async_stage_w_emplace_to_deferred_world",
-        ComponentLifecycle_merge_async_stage_w_emplace_to_deferred_world
-    },
-    {
-        "emplace_grow_w_existing_component",
-        ComponentLifecycle_emplace_grow_w_existing_component
-    },
-    {
-        "dtor_on_fini",
-        ComponentLifecycle_dtor_on_fini
-    },
-    {
-        "valid_type_in_dtor_on_fini",
-        ComponentLifecycle_valid_type_in_dtor_on_fini
-    },
-    {
-        "valid_other_type_of_entity_in_dtor_on_fini",
-        ComponentLifecycle_valid_other_type_of_entity_in_dtor_on_fini
-    },
-    {
-        "delete_in_dtor_other_type_on_fini",
-        ComponentLifecycle_delete_in_dtor_other_type_on_fini
-    },
-    {
-        "delete_in_dtor_other_type_on_delete_parent",
-        ComponentLifecycle_delete_in_dtor_other_type_on_delete_parent
-    },
-    {
-        "delete_in_dtor_other_type_on_delete",
-        ComponentLifecycle_delete_in_dtor_other_type_on_delete
-    },
-    {
-        "delete_self_in_dtor_on_delete",
-        ComponentLifecycle_delete_self_in_dtor_on_delete
-    },
-    {
-        "on_set_after_set",
-        ComponentLifecycle_on_set_after_set
-    },
-    {
-        "on_add_after_new",
-        ComponentLifecycle_on_add_after_new
-    },
-    {
-        "on_add_after_add",
-        ComponentLifecycle_on_add_after_add
-    },
-    {
-        "on_add_after_set",
-        ComponentLifecycle_on_add_after_set
-    },
-    {
-        "on_remove_after_remove",
-        ComponentLifecycle_on_remove_after_remove
-    },
-    {
-        "on_remove_after_clear",
-        ComponentLifecycle_on_remove_after_clear
-    },
-    {
-        "on_remove_after_delete",
-        ComponentLifecycle_on_remove_after_delete
-    },
-    {
-        "free_component_new_id_while_fini",
-        ComponentLifecycle_free_component_new_id_while_fini
-    },
-    {
-        "dtor_component_new_id_while_fini",
-        ComponentLifecycle_dtor_component_new_id_while_fini
-    },
-    {
-        "free_component_new_pair_id_while_fini",
-        ComponentLifecycle_free_component_new_pair_id_while_fini
-    },
-    {
-        "dtor_component_new_pair_id_while_fini",
-        ComponentLifecycle_dtor_component_new_pair_id_while_fini
-    },
-    {
-        "free_component_new_obj_pair_id_while_fini",
-        ComponentLifecycle_free_component_new_obj_pair_id_while_fini
-    },
-    {
-        "dtor_component_new_obj_pair_id_while_fini",
-        ComponentLifecycle_dtor_component_new_obj_pair_id_while_fini
-    },
-    {
-        "ctor_move_dtor_after_resize",
-        ComponentLifecycle_ctor_move_dtor_after_resize
-    },
-    {
-        "ctx_free",
-        ComponentLifecycle_ctx_free
-    },
-    {
-        "binding_ctx_free",
-        ComponentLifecycle_binding_ctx_free
-    },
-    {
-        "ctx_free_after_delete_component",
-        ComponentLifecycle_ctx_free_after_delete_component
-    },
-    {
-        "binding_ctx_free_after_delete_component",
-        ComponentLifecycle_binding_ctx_free_after_delete_component
-    },
-    {
-        "on_add_ctx",
-        ComponentLifecycle_on_add_ctx
-    },
-    {
-        "on_remove_ctx",
-        ComponentLifecycle_on_remove_ctx
-    },
-    {
-        "on_set_ctx",
-        ComponentLifecycle_on_set_ctx
-    },
-    {
-        "on_add_w_existing_component",
-        ComponentLifecycle_on_add_w_existing_component
-    },
-    {
-        "on_remove_w_existing_component",
-        ComponentLifecycle_on_remove_w_existing_component
-    },
-    {
-        "component_init_set_hooks",
-        ComponentLifecycle_component_init_set_hooks
-    },
-    {
-        "component_init_name_from_type_info",
-        ComponentLifecycle_component_init_name_from_type_info
-    },
-    {
-        "component_init_scoped_name_from_type_info",
-        ComponentLifecycle_component_init_scoped_name_from_type_info
-    },
-    {
-        "on_add_after_ctor_w_add",
-        ComponentLifecycle_on_add_after_ctor_w_add
-    },
-    {
-        "on_add_after_ctor_w_add_to",
-        ComponentLifecycle_on_add_after_ctor_w_add_to
-    },
-    {
-        "with_before_hooks",
-        ComponentLifecycle_with_before_hooks
-    },
-    {
-        "with_component_on_add",
-        ComponentLifecycle_with_component_on_add
-    },
-    {
-        "move_ctor_on_move",
-        ComponentLifecycle_move_ctor_on_move
-    },
-    {
-        "ptr_to_self",
-        ComponentLifecycle_ptr_to_self
-    },
-    {
-        "ctor_move_dtor_from_move_ctor",
-        ComponentLifecycle_ctor_move_dtor_from_move_ctor
-    },
-    {
-        "on_add_hook_check_offset",
-        ComponentLifecycle_on_add_hook_check_offset
-    },
-    {
-        "on_remove_hook_check_offset",
-        ComponentLifecycle_on_remove_hook_check_offset
-    },
-    {
-        "on_set_hook_check_offset",
-        ComponentLifecycle_on_set_hook_check_offset
-    },
-    {
-        "on_set_hook_on_override",
-        ComponentLifecycle_on_set_hook_on_override
-    },
-    {
-        "on_set_hook_on_auto_override",
-        ComponentLifecycle_on_set_hook_on_auto_override
+        "worker_iter_w_singleton_instanced",
+        Iter_worker_iter_w_singleton_instanced
     },
     {
-        "batched_set_new_component_w_lifecycle",
-        ComponentLifecycle_batched_set_new_component_w_lifecycle
+        "worker_iter_w_singleton_component_instanced",
+        Iter_worker_iter_w_singleton_component_instanced
     },
     {
-        "batched_ensure_new_component_w_lifecycle",
-        ComponentLifecycle_batched_ensure_new_component_w_lifecycle
+        "paged_iter_w_singleton",
+        Iter_paged_iter_w_singleton
     },
     {
-        "on_nested_prefab_copy_test_invokes_copy_count",
-        ComponentLifecycle_on_nested_prefab_copy_test_invokes_copy_count
+        "paged_iter_w_singleton_component",
+        Iter_paged_iter_w_singleton_component
     },
     {
-        "no_move_no_move_ctor_with_move_dtor_with_ctor_move_dtor",
-        ComponentLifecycle_no_move_no_move_ctor_with_move_dtor_with_ctor_move_dtor
-    }
-};
-
-bake_test_case Sorting_testcases[] = {
-    {
-        "sort_by_component",
-        Sorting_sort_by_component
+        "paged_iter_w_singleton_instanced",
+        Iter_paged_iter_w_singleton_instanced
     },
     {
-        "sort_by_component_2_tables",
-        Sorting_sort_by_component_2_tables
+        "paged_iter_w_singleton_component_instanced",
+        Iter_paged_iter_w_singleton_component_instanced
     },
     {
-        "sort_by_component_3_tables",
-        Sorting_sort_by_component_3_tables
+        "page_iter_w_offset_skip_1_archetype",
+        Iter_page_iter_w_offset_skip_1_archetype
     },
     {
-        "sort_by_entity",
-        Sorting_sort_by_entity
+        "page_iter_w_offset_skip_1_archetype_plus_one",
+        Iter_page_iter_w_offset_skip_1_archetype_plus_one
     },
     {
-        "sort_after_add",
-        Sorting_sort_after_add
+        "page_iter_w_offset_skip_2_archetypes",
+        Iter_page_iter_w_offset_skip_2_archetypes
     },
     {
-        "sort_after_remove",
-        Sorting_sort_after_remove
+        "page_iter_w_limit_skip_1_archetype",
+        Iter_page_iter_w_limit_skip_1_archetype
     },
     {
-        "sort_after_delete",
-        Sorting_sort_after_delete
+        "page_iter_w_limit_skip_1_archetype_minus_one",
+        Iter_page_iter_w_limit_skip_1_archetype_minus_one
     },
     {
-        "sort_after_set",
-        Sorting_sort_after_set
+        "page_iter_w_limit_skip_2_archetypes",
+        Iter_page_iter_w_limit_skip_2_archetypes
     },
     {
-        "sort_after_system",
-        Sorting_sort_after_system
+        "page_iter_w_offset_1_limit_max",
+        Iter_page_iter_w_offset_1_limit_max
     },
     {
-        "sort_after_query",
-        Sorting_sort_after_query
+        "page_iter_w_offset_1_limit_minus_1",
+        Iter_page_iter_w_offset_1_limit_minus_1
     },
     {
-        "sort_by_component_same_value_1",
-        Sorting_sort_by_component_same_value_1
+        "page_iter_w_offset_2_type_limit_max",
+        Iter_page_iter_w_offset_2_type_limit_max
     },
     {
-        "sort_by_component_same_value_2",
-        Sorting_sort_by_component_same_value_2
+        "page_iter_w_offset_2_type_limit_minus_1",
+        Iter_page_iter_w_offset_2_type_limit_minus_1
     },
     {
-        "sort_by_component_move_pivot",
-        Sorting_sort_by_component_move_pivot
+        "page_iter_w_limit_1_all_offsets",
+        Iter_page_iter_w_limit_1_all_offsets
     },
     {
-        "sort_1000_entities",
-        Sorting_sort_1000_entities
+        "page_iter_w_offset_out_of_bounds",
+        Iter_page_iter_w_offset_out_of_bounds
     },
     {
-        "sort_1000_entities_w_duplicates",
-        Sorting_sort_1000_entities_w_duplicates
+        "page_iter_w_limit_out_of_bounds",
+        Iter_page_iter_w_limit_out_of_bounds
     },
     {
-        "sort_1000_entities_again",
-        Sorting_sort_1000_entities_again
+        "page_iter_comb_10_entities_1_type",
+        Iter_page_iter_comb_10_entities_1_type
     },
     {
-        "sort_1000_entities_2_types",
-        Sorting_sort_1000_entities_2_types
+        "page_iter_comb_10_entities_2_types",
+        Iter_page_iter_comb_10_entities_2_types
     },
     {
-        "sort_1500_entities_3_types",
-        Sorting_sort_1500_entities_3_types
+        "count",
+        Iter_count
     },
     {
-        "sort_2000_entities_4_types",
-        Sorting_sort_2000_entities_4_types
+        "iter_restore_stack_iter",
+        Iter_iter_restore_stack_iter
     },
     {
-        "sort_2_entities_2_types",
-        Sorting_sort_2_entities_2_types
+        "interleaved_iter",
+        Iter_interleaved_iter
     },
     {
-        "sort_3_entities_3_types",
-        Sorting_sort_3_entities_3_types
+        "get_first",
+        Iter_get_first
     },
     {
-        "sort_3_entities_3_types_2",
-        Sorting_sort_3_entities_3_types_2
+        "page_iter_w_only_tag",
+        Iter_page_iter_w_only_tag
     },
     {
-        "sort_4_entities_4_types",
-        Sorting_sort_4_entities_4_types
+        "worker_iter_w_only_tag",
+        Iter_worker_iter_w_only_tag
     },
     {
-        "sort_1000_entities_2_types_again",
-        Sorting_sort_1000_entities_2_types_again
+        "page_iter_w_inout_none",
+        Iter_page_iter_w_inout_none
     },
     {
-        "sort_1000_entities_add_type_after_sort",
-        Sorting_sort_1000_entities_add_type_after_sort
+        "worker_iter_w_inout_none",
+        Iter_worker_iter_w_inout_none
     },
     {
-        "sort_shared_component",
-        Sorting_sort_shared_component
+        "page_iter_w_ctx",
+        Iter_page_iter_w_ctx
     },
     {
-        "sort_shared_component_childof",
-        Sorting_sort_shared_component_childof
+        "page_iter_w_binding_ctx",
+        Iter_page_iter_w_binding_ctx
     },
     {
-        "sort_w_tags_only",
-        Sorting_sort_w_tags_only
+        "worker_iter_w_ctx",
+        Iter_worker_iter_w_ctx
     },
     {
-        "sort_childof_marked",
-        Sorting_sort_childof_marked
+        "worker_iter_w_binding_ctx",
+        Iter_worker_iter_w_binding_ctx
     },
     {
-        "sort_isa_marked",
-        Sorting_sort_isa_marked
+        "column_index_owned",
+        Iter_column_index_owned
     },
     {
-        "sort_relation_marked",
-        Sorting_sort_relation_marked
+        "column_index_shared",
+        Iter_column_index_shared
     },
     {
-        "dont_resort_after_set_unsorted_component",
-        Sorting_dont_resort_after_set_unsorted_component
+        "column_index_not",
+        Iter_column_index_not
     },
     {
-        "dont_resort_after_set_unsorted_component_w_tag",
-        Sorting_dont_resort_after_set_unsorted_component_w_tag
+        "page_iter_w_fini",
+        Iter_page_iter_w_fini
     },
     {
-        "dont_resort_after_set_unsorted_component_w_tag_w_out_term",
-        Sorting_dont_resort_after_set_unsorted_component_w_tag_w_out_term
+        "worker_iter_w_fini",
+        Iter_worker_iter_w_fini
     },
     {
-        "sort_component_not_queried_for",
-        Sorting_sort_component_not_queried_for
+        "rule_page_iter_w_fini",
+        Iter_rule_page_iter_w_fini
     },
     {
-        "sort_by_wildcard",
-        Sorting_sort_by_wildcard
+        "rule_worker_iter_w_fini",
+        Iter_rule_worker_iter_w_fini
     },
     {
-        "sort_shared_w_delete",
-        Sorting_sort_shared_w_delete
+        "to_str_before_next",
+        Iter_to_str_before_next
     },
     {
-        "sort_w_nontrivial_component",
-        Sorting_sort_w_nontrivial_component
+        "to_str",
+        Iter_to_str
     }
 };
 
-bake_test_case SortingEntireTable_testcases[] = {
-    {
-        "sort_by_component",
-        SortingEntireTable_sort_by_component
-    },
-    {
-        "sort_by_component_2_tables",
-        SortingEntireTable_sort_by_component_2_tables
-    },
-    {
-        "sort_by_component_3_tables",
-        SortingEntireTable_sort_by_component_3_tables
-    },
-    {
-        "sort_by_entity",
-        SortingEntireTable_sort_by_entity
-    },
-    {
-        "sort_after_add",
-        SortingEntireTable_sort_after_add
-    },
-    {
-        "sort_after_remove",
-        SortingEntireTable_sort_after_remove
-    },
-    {
-        "sort_after_delete",
-        SortingEntireTable_sort_after_delete
-    },
-    {
-        "sort_after_set",
-        SortingEntireTable_sort_after_set
-    },
-    {
-        "sort_after_system",
-        SortingEntireTable_sort_after_system
-    },
-    {
-        "sort_after_query",
-        SortingEntireTable_sort_after_query
-    },
-    {
-        "sort_by_component_same_value_1",
-        SortingEntireTable_sort_by_component_same_value_1
-    },
-    {
-        "sort_by_component_same_value_2",
-        SortingEntireTable_sort_by_component_same_value_2
-    },
-    {
-        "sort_by_component_move_pivot",
-        SortingEntireTable_sort_by_component_move_pivot
-    },
-    {
-        "sort_1000_entities",
-        SortingEntireTable_sort_1000_entities
-    },
+bake_test_case Search_testcases[] = {
     {
-        "sort_1000_entities_w_duplicates",
-        SortingEntireTable_sort_1000_entities_w_duplicates
+        "search",
+        Search_search
     },
     {
-        "sort_1000_entities_again",
-        SortingEntireTable_sort_1000_entities_again
+        "search_wildcard",
+        Search_search_wildcard
     },
     {
-        "sort_1000_entities_2_types",
-        SortingEntireTable_sort_1000_entities_2_types
+        "search_wildcard_w_offset",
+        Search_search_wildcard_w_offset
     },
     {
-        "sort_1500_entities_3_types",
-        SortingEntireTable_sort_1500_entities_3_types
+        "search_relation_wildcard_w_offset",
+        Search_search_relation_wildcard_w_offset
     },
     {
-        "sort_2000_entities_4_types",
-        SortingEntireTable_sort_2000_entities_4_types
+        "search_pair_w_any_rel",
+        Search_search_pair_w_any_rel
     },
     {
-        "sort_2_entities_2_types",
-        SortingEntireTable_sort_2_entities_2_types
+        "search_pair_w_any_obj",
+        Search_search_pair_w_any_obj
     },
     {
-        "sort_3_entities_3_types",
-        SortingEntireTable_sort_3_entities_3_types
+        "search_follow_relation_lvl_0",
+        Search_search_follow_relation_lvl_0
     },
     {
-        "sort_3_entities_3_types_2",
-        SortingEntireTable_sort_3_entities_3_types_2
+        "search_follow_relation_lvl_1",
+        Search_search_follow_relation_lvl_1
     },
     {
-        "sort_4_entities_4_types",
-        SortingEntireTable_sort_4_entities_4_types
+        "search_follow_relation_lvl_2",
+        Search_search_follow_relation_lvl_2
     },
     {
-        "sort_1000_entities_2_types_again",
-        SortingEntireTable_sort_1000_entities_2_types_again
+        "search_follow_relation_lvl_3",
+        Search_search_follow_relation_lvl_3
     },
     {
-        "sort_1000_entities_add_type_after_sort",
-        SortingEntireTable_sort_1000_entities_add_type_after_sort
+        "search_first_lvl_0",
+        Search_search_first_lvl_0
     },
     {
-        "sort_shared_component",
-        SortingEntireTable_sort_shared_component
+        "search_first_lvl_1",
+        Search_search_first_lvl_1
     },
     {
-        "sort_w_tags_only",
-        SortingEntireTable_sort_w_tags_only
+        "search_first_lvl_2",
+        Search_search_first_lvl_2
     },
     {
-        "sort_childof_marked",
-        SortingEntireTable_sort_childof_marked
+        "search_first_lvl_3",
+        Search_search_first_lvl_3
     },
     {
-        "sort_isa_marked",
-        SortingEntireTable_sort_isa_marked
+        "search_relation_wildcard",
+        Search_search_relation_wildcard
     },
     {
-        "sort_relation_marked",
-        SortingEntireTable_sort_relation_marked
+        "search_relation_at_offset",
+        Search_search_relation_at_offset
     },
     {
-        "dont_resort_after_set_unsorted_component",
-        SortingEntireTable_dont_resort_after_set_unsorted_component
+        "search_relation_inherit_from_parent",
+        Search_search_relation_inherit_from_parent
     },
     {
-        "dont_resort_after_set_unsorted_component_w_tag",
-        SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag
+        "search_relation_dont_inherit",
+        Search_search_relation_dont_inherit
     },
     {
-        "dont_resort_after_set_unsorted_component_w_tag_w_out_term",
-        SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag_w_out_term
+        "search_relation_dont_inherit_from_parent",
+        Search_search_relation_dont_inherit_from_parent
     },
     {
-        "sort_shared_w_delete",
-        SortingEntireTable_sort_shared_w_delete
+        "search_relation_exclusive",
+        Search_search_relation_exclusive
     }
 };
 
-bake_test_case Filter_testcases[] = {
-    {
-        "filter_1_term",
-        Filter_filter_1_term
-    },
-    {
-        "filter_1_term_component",
-        Filter_filter_1_term_component
-    },
-    {
-        "filter_2_terms",
-        Filter_filter_2_terms
-    },
-    {
-        "filter_3_terms",
-        Filter_filter_3_terms
-    },
-    {
-        "filter_3_terms_w_or",
-        Filter_filter_3_terms_w_or
-    },
-    {
-        "filter_4_terms_w_or_at_1",
-        Filter_filter_4_terms_w_or_at_1
-    },
-    {
-        "filter_1_term_wildcard",
-        Filter_filter_1_term_wildcard
-    },
-    {
-        "filter_1_term_any",
-        Filter_filter_1_term_any
-    },
-    {
-        "filter_1_term_same_subj_obj",
-        Filter_filter_1_term_same_subj_obj
-    },
-    {
-        "filter_1_term_acyclic_same_subj_obj",
-        Filter_filter_1_term_acyclic_same_subj_obj
-    },
+bake_test_case Event_testcases[] = {
     {
-        "filter_1_term_acyclic_reflexive_same_subj_obj",
-        Filter_filter_1_term_acyclic_reflexive_same_subj_obj
+        "table_1_id_w_trigger",
+        Event_table_1_id_w_trigger
     },
     {
-        "filter_1_term_same_subj_obj_var",
-        Filter_filter_1_term_same_subj_obj_var
+        "table_2_ids_w_trigger",
+        Event_table_2_ids_w_trigger
     },
     {
-        "filter_1_term_acyclic_same_subj_obj_var",
-        Filter_filter_1_term_acyclic_same_subj_obj_var
+        "table_1_id_w_observer",
+        Event_table_1_id_w_observer
     },
     {
-        "filter_1_term_acyclic_reflexive_same_subj_obj_var",
-        Filter_filter_1_term_acyclic_reflexive_same_subj_obj_var
+        "table_2_ids_w_observer",
+        Event_table_2_ids_w_observer
     },
     {
-        "filter_1_term_non_acyclic_superset",
-        Filter_filter_1_term_non_acyclic_superset
+        "emit_event_for_empty_table",
+        Event_emit_event_for_empty_table
     },
     {
-        "filter_1_term_dont_inherit_default_set",
-        Filter_filter_1_term_dont_inherit_default_set
+        "emit_table_event",
+        Event_emit_table_event
     },
     {
-        "filter_1_term_dont_inherit_pair_default_set",
-        Filter_filter_1_term_dont_inherit_pair_default_set
+        "emit_staged_from_world",
+        Event_emit_staged_from_world
     },
     {
-        "filter_1_term_cascade_implicit_isa",
-        Filter_filter_1_term_cascade_implicit_isa
+        "emit_staged_from_stage",
+        Event_emit_staged_from_stage
     },
     {
-        "filter_1_term_cascade_isa",
-        Filter_filter_1_term_cascade_isa
+        "emit_staged_from_world_observer",
+        Event_emit_staged_from_world_observer
     },
     {
-        "filter_1_term_cascade_childof",
-        Filter_filter_1_term_cascade_childof
+        "emit_staged_from_stage_observer",
+        Event_emit_staged_from_stage_observer
     },
     {
-        "filter_1_term_cascade_down",
-        Filter_filter_1_term_cascade_down
+        "emit_for_entity",
+        Event_emit_for_entity
     },
     {
-        "filter_1_term_optional_only",
-        Filter_filter_1_term_optional_only
+        "emit_custom_for_any",
+        Event_emit_custom_for_any
     },
     {
-        "filter_1_term_transitive_pair",
-        Filter_filter_1_term_transitive_pair
+        "emit_custom_implicit_any",
+        Event_emit_custom_implicit_any
     },
     {
-        "filter_1_term_transitive_pair_explicit_self_tgt",
-        Filter_filter_1_term_transitive_pair_explicit_self_tgt
+        "emit_custom_empty_type",
+        Event_emit_custom_empty_type
     },
     {
-        "filter_1_variable_as_pred_only",
-        Filter_filter_1_variable_as_pred_only
+        "emit_w_param",
+        Event_emit_w_param
     },
     {
-        "filter_1_variable_as_pred_w_subj",
-        Filter_filter_1_variable_as_pred_w_subj
+        "emit_w_param_multi_observer",
+        Event_emit_w_param_multi_observer
     },
     {
-        "filter_1_variable_as_pred_w_pair",
-        Filter_filter_1_variable_as_pred_w_pair
+        "emit_w_const_param",
+        Event_emit_w_const_param
     },
     {
-        "filter_1_variable_as_subj",
-        Filter_filter_1_variable_as_subj
+        "emit_nested",
+        Event_emit_nested
     },
     {
-        "filter_1_variable_as_obj",
-        Filter_filter_1_variable_as_obj
+        "enqueue_event_1_id",
+        Event_enqueue_event_1_id
     },
     {
-        "filter_2_terms_or_w_dontinherit",
-        Filter_filter_2_terms_or_w_dontinherit
+        "enqueue_event_2_ids",
+        Event_enqueue_event_2_ids
     },
     {
-        "filter_2_terms_or_w_both_dontinherit",
-        Filter_filter_2_terms_or_w_both_dontinherit
+        "enqueue_event_w_data",
+        Event_enqueue_event_w_data
     },
     {
-        "filter_w_pair_id",
-        Filter_filter_w_pair_id
+        "enqueue_event_w_data_move",
+        Event_enqueue_event_w_data_move
     },
     {
-        "filter_w_pred_obj",
-        Filter_filter_w_pred_obj
+        "enqueue_event_w_data_copy",
+        Event_enqueue_event_w_data_copy
     },
     {
-        "filter_w_pair_id_and_subj",
-        Filter_filter_w_pair_id_and_subj
+        "enqueue_event_w_const_data_no_copy",
+        Event_enqueue_event_w_const_data_no_copy
     },
     {
-        "filter_1_w_pred_name",
-        Filter_filter_1_w_pred_name
+        "enqueue_event_not_alive",
+        Event_enqueue_event_not_alive
     },
     {
-        "filter_1_w_final_pred_name",
-        Filter_filter_1_w_final_pred_name
+        "enqueue_event_not_alive_w_data_move",
+        Event_enqueue_event_not_alive_w_data_move
     },
     {
-        "filter_1_w_subj_name",
-        Filter_filter_1_w_subj_name
+        "enqueue_event_not_alive_w_data_copy",
+        Event_enqueue_event_not_alive_w_data_copy
     },
     {
-        "filter_1_w_obj_name",
-        Filter_filter_1_w_obj_name
+        "enqueue_event_not_alive_after_delete_during_merge",
+        Event_enqueue_event_not_alive_after_delete_during_merge
     },
     {
-        "filter_w_this_implicit_variable",
-        Filter_filter_w_this_implicit_variable
+        "enqueue_event_not_alive_w_data_move_after_delete_during_merge",
+        Event_enqueue_event_not_alive_w_data_move_after_delete_during_merge
     },
     {
-        "filter_w_this_explicit_entity",
-        Filter_filter_w_this_explicit_entity
+        "enqueue_event_not_alive_w_data_copy_after_delete_during_merge",
+        Event_enqueue_event_not_alive_w_data_copy_after_delete_during_merge
     },
     {
-        "filter_w_first_this_implicit_variable",
-        Filter_filter_w_first_this_implicit_variable
+        "enqueue_event_not_deferred",
+        Event_enqueue_event_not_deferred
     },
     {
-        "filter_w_first_this_explicit_entity",
-        Filter_filter_w_first_this_explicit_entity
+        "enqueue_event_not_deferred_to_async",
+        Event_enqueue_event_not_deferred_to_async
     },
     {
-        "filter_w_second_this_implicit_variable",
-        Filter_filter_w_second_this_implicit_variable
+        "enqueue_custom_implicit_any",
+        Event_enqueue_custom_implicit_any
     },
     {
-        "filter_w_second_this_explicit_entity",
-        Filter_filter_w_second_this_explicit_entity
+        "enqueue_custom_after_large_cmd",
+        Event_enqueue_custom_after_large_cmd
     },
     {
-        "filter_w_this_variable_name",
-        Filter_filter_w_this_variable_name
-    },
+        "enqueue_on_readonly_world",
+        Event_enqueue_on_readonly_world
+    }
+};
+
+bake_test_case New_testcases[] = {
     {
-        "filter_w_src_var",
-        Filter_filter_w_src_var
+        "empty",
+        New_empty
     },
     {
-        "filter_w_first_var",
-        Filter_filter_w_first_var
+        "component",
+        New_component
     },
     {
-        "filter_w_second_var",
-        Filter_filter_w_second_var
+        "tag",
+        New_tag
     },
     {
-        "filter_w_src_var_from_name",
-        Filter_filter_w_src_var_from_name
+        "redefine_component",
+        New_redefine_component
     },
     {
-        "filter_w_first_first_var",
-        Filter_filter_w_first_first_var
+        "recycle_id_empty",
+        New_recycle_id_empty
     },
     {
-        "filter_w_second_second_var",
-        Filter_filter_w_second_second_var
+        "recycle_id_w_entity",
+        New_recycle_id_w_entity
     },
     {
-        "filter_w_0_source",
-        Filter_filter_w_0_source
+        "recycle_empty_staged_delete",
+        New_recycle_empty_staged_delete
     },
     {
-        "filter_w_0_target",
-        Filter_filter_w_0_target
+        "recycle_staged_delete",
+        New_recycle_staged_delete
     },
     {
-        "filter_2_terms_w_or",
-        Filter_filter_2_terms_w_or
+        "new_id",
+        New_new_id
     },
     {
-        "filter_2_terms_w_or_mixed_src_flags",
-        Filter_filter_2_terms_w_or_mixed_src_flags
+        "new_component_id",
+        New_new_component_id
     },
     {
-        "filter_2_terms_w_or_mixed_src_id",
-        Filter_filter_2_terms_w_or_mixed_src_id
+        "new_hi_component_id",
+        New_new_hi_component_id
     },
     {
-        "filter_2_terms_w_or_mixed_src_name",
-        Filter_filter_2_terms_w_or_mixed_src_name
+        "new_component_id_skip_used",
+        New_new_component_id_skip_used
     },
     {
-        "filter_2_terms_w_or_same_src_w_id_and_name",
-        Filter_filter_2_terms_w_or_same_src_w_id_and_name
+        "new_component_id_skip_to_hi_id",
+        New_new_component_id_skip_to_hi_id
     },
     {
-        "filter_move",
-        Filter_filter_move
+        "new_w_entity_0",
+        New_new_w_entity_0
     },
     {
-        "filter_copy",
-        Filter_filter_copy
+        "create_w_explicit_id_2_worlds",
+        New_create_w_explicit_id_2_worlds
     },
     {
-        "filter_w_resources_copy",
-        Filter_filter_w_resources_copy
+        "new_w_id_0_w_with",
+        New_new_w_id_0_w_with
     },
     {
-        "filter_w_and_flag",
-        Filter_filter_w_and_flag
+        "new_w_id_w_with",
+        New_new_w_id_w_with
     },
     {
-        "filter_w_or_flag",
-        Filter_filter_w_or_flag
+        "new_w_type_w_with",
+        New_new_w_type_w_with
     },
     {
-        "filter_w_not_flag",
-        Filter_filter_w_not_flag
+        "new_w_id_w_with_w_scope",
+        New_new_w_id_w_with_w_scope
     },
     {
-        "filter_filter",
-        Filter_filter_filter
+        "new_w_type_w_with_w_scope",
+        New_new_w_type_w_with_w_scope
     },
     {
-        "filter_double_init",
-        Filter_filter_double_init
+        "new_w_id_w_with_defer",
+        New_new_w_id_w_with_defer
     },
     {
-        "filter_double_init_w_expr",
-        Filter_filter_double_init_w_expr
+        "new_w_id_w_with_defer_w_scope",
+        New_new_w_id_w_with_defer_w_scope
     },
     {
-        "filter_double_init_w_expr_optional",
-        Filter_filter_double_init_w_expr_optional
+        "new_w_type_w_with_defer",
+        New_new_w_type_w_with_defer
     },
     {
-        "filter_w_tag_term_is_no_data",
-        Filter_filter_w_tag_term_is_no_data
-    },
+        "new_w_type_w_with_defer_w_scope",
+        New_new_w_type_w_with_defer_w_scope
+    }
+};
+
+bake_test_case New_w_Count_testcases[] = {
     {
-        "filter_w_inout_none_term_is_no_data",
-        Filter_filter_w_inout_none_term_is_no_data
+        "empty",
+        New_w_Count_empty
     },
     {
-        "filter_w_tag_and_inout_none_term_is_no_data",
-        Filter_filter_w_tag_and_inout_none_term_is_no_data
+        "component",
+        New_w_Count_component
     },
     {
-        "filter_w_not_term_is_no_data",
-        Filter_filter_w_not_term_is_no_data
+        "tag",
+        New_w_Count_tag
     },
     {
-        "filter_w_no_transitive_pair",
-        Filter_filter_w_no_transitive_pair
+        "bulk_init_empty",
+        New_w_Count_bulk_init_empty
     },
     {
-        "filter_w_transitive_pair_any_src",
-        Filter_filter_w_transitive_pair_any_src
+        "bulk_init_empty_w_entities",
+        New_w_Count_bulk_init_empty_w_entities
     },
     {
-        "filter_w_transitive_pair",
-        Filter_filter_w_transitive_pair
+        "bulk_init_1_tag",
+        New_w_Count_bulk_init_1_tag
     },
     {
-        "filter_w_transitive_tag_no_pair",
-        Filter_filter_w_transitive_tag_no_pair
+        "bulk_init_1_tag_w_entities",
+        New_w_Count_bulk_init_1_tag_w_entities
     },
     {
-        "filter_w_transitive_tag_self_tgt",
-        Filter_filter_w_transitive_tag_self_tgt
+        "bulk_init_2_tags",
+        New_w_Count_bulk_init_2_tags
     },
     {
-        "filter_w_transitive_tag_any_tgt",
-        Filter_filter_w_transitive_tag_any_tgt
+        "bulk_init_1_component",
+        New_w_Count_bulk_init_1_component
     },
     {
-        "filter_w_pair_same_vars",
-        Filter_filter_w_pair_same_vars
+        "bulk_init_2_components",
+        New_w_Count_bulk_init_2_components
     },
     {
-        "filter_w_pair_not_same_vars",
-        Filter_filter_w_pair_not_same_vars
+        "bulk_init_1_component_w_value",
+        New_w_Count_bulk_init_1_component_w_value
     },
     {
-        "filter_w_pair_no_vars_not_same_vars",
-        Filter_filter_w_pair_no_vars_not_same_vars
+        "bulk_init_2_components_w_value",
+        New_w_Count_bulk_init_2_components_w_value
     },
     {
-        "filter_w_pair_wildcard_not_same_vars",
-        Filter_filter_w_pair_wildcard_not_same_vars
+        "bulk_init_2_components_tag_w_value",
+        New_w_Count_bulk_init_2_components_tag_w_value
     },
     {
-        "filter_w_pair_any_not_same_vars",
-        Filter_filter_w_pair_any_not_same_vars
+        "add_after_bulk",
+        New_w_Count_add_after_bulk
     },
     {
-        "filter_w_no_pair_not_same_vars",
-        Filter_filter_w_no_pair_not_same_vars
+        "add_after_bulk_w_component",
+        New_w_Count_add_after_bulk_w_component
     },
     {
-        "filter_not_childof_any",
-        Filter_filter_not_childof_any
+        "add_after_bulk_w_ctor",
+        New_w_Count_add_after_bulk_w_ctor
     },
     {
-        "filter_w_inherited_id",
-        Filter_filter_w_inherited_id
+        "recycle_1_of_2",
+        New_w_Count_recycle_1_of_2
     },
     {
-        "filter_w_inherited_pair",
-        Filter_filter_w_inherited_pair
+        "recycle_1_of_3",
+        New_w_Count_recycle_1_of_3
     },
     {
-        "filter_w_non_inherited_id",
-        Filter_filter_w_non_inherited_id
+        "recycle_2_of_3",
+        New_w_Count_recycle_2_of_3
     },
     {
-        "filter_w_non_inherited_pair",
-        Filter_filter_w_non_inherited_pair
-    },
+        "bulk_init_w_table",
+        New_w_Count_bulk_init_w_table
+    }
+};
+
+bake_test_case Add_testcases[] = {
     {
-        "filter_w_first_rel",
-        Filter_filter_w_first_rel
+        "zero",
+        Add_zero
     },
     {
-        "filter_w_first_rel_self",
-        Filter_filter_w_first_rel_self
+        "component",
+        Add_component
     },
     {
-        "filter_w_first_rel_down",
-        Filter_filter_w_first_rel_down
+        "component_again",
+        Add_component_again
     },
     {
-        "filter_w_first_rel_self_down",
-        Filter_filter_w_first_rel_self_down
+        "2_components",
+        Add_2_components
     },
     {
-        "filter_w_first_rel_reflexive",
-        Filter_filter_w_first_rel_reflexive
+        "2_components_again",
+        Add_2_components_again
     },
     {
-        "filter_w_first_rel_reflexive_self",
-        Filter_filter_w_first_rel_reflexive_self
+        "2_components_overlap",
+        Add_2_components_overlap
     },
     {
-        "filter_w_first_rel_reflexive_down",
-        Filter_filter_w_first_rel_reflexive_down
+        "component_to_nonempty",
+        Add_component_to_nonempty
     },
     {
-        "filter_w_first_rel_reflexive_self_down",
-        Filter_filter_w_first_rel_reflexive_self_down
+        "component_to_nonempty_again",
+        Add_component_to_nonempty_again
     },
     {
-        "filter_w_first_rel_non_traversable",
-        Filter_filter_w_first_rel_non_traversable
+        "component_to_nonempty_overlap",
+        Add_component_to_nonempty_overlap
     },
     {
-        "filter_w_first_wildcard_inout_none",
-        Filter_filter_w_first_wildcard_inout_none
+        "tag",
+        Add_tag
     },
     {
-        "filter_w_first_var_inout_none",
-        Filter_filter_w_first_var_inout_none
+        "add_entity",
+        Add_add_entity
     },
     {
-        "filter_w_pair_wildcard_inout_none",
-        Filter_filter_w_pair_wildcard_inout_none
+        "remove_entity",
+        Add_remove_entity
     },
     {
-        "filter_w_pair_var_inout_none",
-        Filter_filter_w_pair_var_inout_none
+        "add_0_entity",
+        Add_add_0_entity
     },
     {
-        "filter_w_unresolved_by_name",
-        Filter_filter_w_unresolved_by_name
+        "remove_0_entity",
+        Add_remove_0_entity
     },
     {
-        "filter_w_unresolved_by_name_eq",
-        Filter_filter_w_unresolved_by_name_eq
+        "invalid_add_wildcard",
+        Add_invalid_add_wildcard
     },
     {
-        "filter_childof_this",
-        Filter_filter_childof_this
+        "invalid_add_pair_w_wildcard",
+        Add_invalid_add_pair_w_wildcard
     },
     {
-        "filter_childof_this_entity",
-        Filter_filter_childof_this_entity
+        "invalid_add_pair_w_wildcard_rel",
+        Add_invalid_add_pair_w_wildcard_rel
     },
     {
-        "filter_childof_this_by_id",
-        Filter_filter_childof_this_by_id
+        "invalid_add_pair_w_wildcard_obj",
+        Add_invalid_add_pair_w_wildcard_obj
     },
     {
-        "term_w_id",
-        Filter_term_w_id
+        "invalid_add_any",
+        Add_invalid_add_any
     },
     {
-        "term_w_pair_id",
-        Filter_term_w_pair_id
+        "invalid_add_pair_w_any",
+        Add_invalid_add_pair_w_any
     },
     {
-        "term_w_pred_obj",
-        Filter_term_w_pred_obj
+        "invalid_add_pair_w_any_rel",
+        Add_invalid_add_pair_w_any_rel
     },
     {
-        "term_w_pair_finalize_twice",
-        Filter_term_w_pair_finalize_twice
+        "invalid_add_pair_w_any_obj",
+        Add_invalid_add_pair_w_any_obj
     },
     {
-        "term_w_role",
-        Filter_term_w_role
+        "invalid_pair_w_0",
+        Add_invalid_pair_w_0
     },
     {
-        "term_w_pred_role",
-        Filter_term_w_pred_role
+        "invalid_pair_w_0_rel",
+        Add_invalid_pair_w_0_rel
     },
     {
-        "term_w_self",
-        Filter_term_w_self
+        "invalid_pair_w_0_obj",
+        Add_invalid_pair_w_0_obj
     },
     {
-        "term_w_superset",
-        Filter_term_w_superset
-    },
+        "add_random_id",
+        Add_add_random_id
+    }
+};
+
+bake_test_case Remove_testcases[] = {
     {
-        "term_w_subset",
-        Filter_term_w_subset
+        "zero",
+        Remove_zero
     },
     {
-        "term_w_self_superset",
-        Filter_term_w_self_superset
+        "1_of_1",
+        Remove_1_of_1
     },
     {
-        "term_w_superset_custom_relation",
-        Filter_term_w_superset_custom_relation
+        "1_of_2",
+        Remove_1_of_2
     },
     {
-        "term_w_self_superset_custom_relation",
-        Filter_term_w_self_superset_custom_relation
+        "2_of_2",
+        Remove_2_of_2
     },
     {
-        "term_iter_component",
-        Filter_term_iter_component
+        "2_of_3",
+        Remove_2_of_3
     },
     {
-        "term_iter_w_pred",
-        Filter_term_iter_w_pred
+        "1_of_1_again",
+        Remove_1_of_1_again
     },
     {
-        "term_iter_tag",
-        Filter_term_iter_tag
+        "2_again",
+        Remove_2_again
     },
     {
-        "term_iter_pair",
-        Filter_term_iter_pair
+        "2_overlap",
+        Remove_2_overlap
     },
     {
-        "term_iter_pair_w_rel_wildcard",
-        Filter_term_iter_pair_w_rel_wildcard
+        "1_from_empty",
+        Remove_1_from_empty
     },
     {
-        "term_iter_pair_w_obj_wildcard",
-        Filter_term_iter_pair_w_obj_wildcard
-    },
+        "not_added",
+        Remove_not_added
+    }
+};
+
+bake_test_case GlobalComponentIds_testcases[] = {
     {
-        "term_iter_pair_w_rel_wildcard_n_matches",
-        Filter_term_iter_pair_w_rel_wildcard_n_matches
+        "declare",
+        GlobalComponentIds_declare
     },
     {
-        "term_iter_pair_w_rel_wildcard_n_matches_w_data",
-        Filter_term_iter_pair_w_rel_wildcard_n_matches_w_data
+        "declare_w_entity",
+        GlobalComponentIds_declare_w_entity
     },
     {
-        "term_iter_pair_w_obj_wildcard_n_matches",
-        Filter_term_iter_pair_w_obj_wildcard_n_matches
+        "declare_2_world",
+        GlobalComponentIds_declare_2_world
     },
     {
-        "term_iter_pair_w_obj_wildcard_n_matches_w_data",
-        Filter_term_iter_pair_w_obj_wildcard_n_matches_w_data
+        "declare_tag",
+        GlobalComponentIds_declare_tag
     },
     {
-        "term_iter_w_superset",
-        Filter_term_iter_w_superset
+        "declare_tag_w_entity",
+        GlobalComponentIds_declare_tag_w_entity
     },
     {
-        "term_iter_w_superset_base_w_2_components",
-        Filter_term_iter_w_superset_base_w_2_components
+        "declare_entity",
+        GlobalComponentIds_declare_entity
     },
     {
-        "term_iter_w_superset_childof",
-        Filter_term_iter_w_superset_childof
-    },
+        "reuse_300_component_ids",
+        GlobalComponentIds_reuse_300_component_ids
+    }
+};
+
+bake_test_case Hierarchies_testcases[] = {
     {
-        "term_iter_w_superset_self",
-        Filter_term_iter_w_superset_self
+        "empty_scope",
+        Hierarchies_empty_scope
     },
     {
-        "term_iter_w_superset_self_childof",
-        Filter_term_iter_w_superset_self_childof
+        "get_parent",
+        Hierarchies_get_parent
     },
     {
-        "term_iter_w_superset_tag",
-        Filter_term_iter_w_superset_tag
+        "get_parent_from_nested",
+        Hierarchies_get_parent_from_nested
     },
     {
-        "term_iter_w_superset_pair",
-        Filter_term_iter_w_superset_pair
+        "get_parent_from_nested_2",
+        Hierarchies_get_parent_from_nested_2
     },
     {
-        "term_iter_w_superset_pair_obj_wildcard",
-        Filter_term_iter_w_superset_pair_obj_wildcard
+        "get_object_from_0",
+        Hierarchies_get_object_from_0
     },
     {
-        "term_iter_in_stage",
-        Filter_term_iter_in_stage
+        "tree_iter_empty",
+        Hierarchies_tree_iter_empty
     },
     {
-        "term_iter_w_readonly_term",
-        Filter_term_iter_w_readonly_term
+        "tree_iter_1_table",
+        Hierarchies_tree_iter_1_table
     },
     {
-        "term_iter_type_set",
-        Filter_term_iter_type_set
+        "tree_iter_2_tables",
+        Hierarchies_tree_iter_2_tables
     },
     {
-        "term_iter_any_match_wildcard",
-        Filter_term_iter_any_match_wildcard
+        "path_depth_0",
+        Hierarchies_path_depth_0
     },
     {
-        "term_iter_any_match_tag_and_wildcard",
-        Filter_term_iter_any_match_tag_and_wildcard
+        "path_depth_1",
+        Hierarchies_path_depth_1
     },
     {
-        "term_iter_any_obj",
-        Filter_term_iter_any_obj
+        "path_depth_2",
+        Hierarchies_path_depth_2
     },
     {
-        "children_iter",
-        Filter_children_iter
+        "path_core",
+        Hierarchies_path_core
     },
     {
-        "filter_iter_1_tag",
-        Filter_filter_iter_1_tag
+        "path_core_w_prefix",
+        Hierarchies_path_core_w_prefix
     },
     {
-        "filter_iter_2_tags",
-        Filter_filter_iter_2_tags
+        "path_core_w_empty_prefix",
+        Hierarchies_path_core_w_empty_prefix
     },
     {
-        "filter_iter_2_tags_1_not",
-        Filter_filter_iter_2_tags_1_not
+        "path_this_w_empty_prefix",
+        Hierarchies_path_this_w_empty_prefix
     },
     {
-        "filter_iter_3_tags_2_or",
-        Filter_filter_iter_3_tags_2_or
+        "path_wildcard_w_empty_prefix",
+        Hierarchies_path_wildcard_w_empty_prefix
     },
     {
-        "filter_iter_only_optional",
-        Filter_filter_iter_only_optional
+        "path_any_w_empty_prefix",
+        Hierarchies_path_any_w_empty_prefix
     },
     {
-        "filter_iter_only_2_or",
-        Filter_filter_iter_only_2_or
+        "rel_path_from_root",
+        Hierarchies_rel_path_from_root
     },
     {
-        "filter_iter_only_3_or",
-        Filter_filter_iter_only_3_or
+        "rel_path_from_self",
+        Hierarchies_rel_path_from_self
     },
     {
-        "filter_iter_2_or",
-        Filter_filter_iter_2_or
+        "rel_path_depth_1",
+        Hierarchies_rel_path_depth_1
     },
     {
-        "filter_iter_3_or",
-        Filter_filter_iter_3_or
+        "rel_path_depth_2",
+        Hierarchies_rel_path_depth_2
     },
     {
-        "filter_iter_2_or_other_type",
-        Filter_filter_iter_2_or_other_type
+        "rel_path_no_match",
+        Hierarchies_rel_path_no_match
     },
     {
-        "filter_iter_2_or_same_type",
-        Filter_filter_iter_2_or_same_type
+        "path_custom_sep",
+        Hierarchies_path_custom_sep
     },
     {
-        "filter_iter_or_w_wildcard",
-        Filter_filter_iter_or_w_wildcard
+        "path_custom_prefix",
+        Hierarchies_path_custom_prefix
     },
     {
-        "filer_iter_or_w_component_and_tag",
-        Filter_filer_iter_or_w_component_and_tag
+        "path_prefix_rel_match",
+        Hierarchies_path_prefix_rel_match
     },
     {
-        "filer_iter_or_w_tag_and_component",
-        Filter_filer_iter_or_w_tag_and_component
+        "path_prefix_rel_no_match",
+        Hierarchies_path_prefix_rel_no_match
     },
     {
-        "filter_iter_1_component",
-        Filter_filter_iter_1_component
+        "fullpath_for_core",
+        Hierarchies_fullpath_for_core
     },
     {
-        "filter_iter_2_components",
-        Filter_filter_iter_2_components
+        "path_w_number",
+        Hierarchies_path_w_number
     },
     {
-        "filter_iter_pair_id",
-        Filter_filter_iter_pair_id
+        "lookup_depth_0",
+        Hierarchies_lookup_depth_0
     },
     {
-        "filter_iter_2_pair_ids",
-        Filter_filter_iter_2_pair_ids
+        "lookup_depth_1",
+        Hierarchies_lookup_depth_1
     },
     {
-        "filter_iter_childof_pair_0_parent",
-        Filter_filter_iter_childof_pair_0_parent
+        "lookup_depth_2",
+        Hierarchies_lookup_depth_2
     },
     {
-        "filter_iter_pair_pred_obj",
-        Filter_filter_iter_pair_pred_obj
+        "lookup_rel_0",
+        Hierarchies_lookup_rel_0
     },
     {
-        "filter_iter_pair_2_pred_obj",
-        Filter_filter_iter_pair_2_pred_obj
+        "lookup_rel_1",
+        Hierarchies_lookup_rel_1
     },
     {
-        "filter_iter_null",
-        Filter_filter_iter_null
+        "lookup_rel_2",
+        Hierarchies_lookup_rel_2
     },
     {
-        "filter_iter_1_not_tag",
-        Filter_filter_iter_1_not_tag
+        "lookup_custom_sep",
+        Hierarchies_lookup_custom_sep
     },
     {
-        "filter_iter_2_tags_1_optional",
-        Filter_filter_iter_2_tags_1_optional
+        "lookup_custom_prefix",
+        Hierarchies_lookup_custom_prefix
     },
     {
-        "filter_iter_2_components_1_optional",
-        Filter_filter_iter_2_components_1_optional
+        "lookup_custom_prefix_from_root",
+        Hierarchies_lookup_custom_prefix_from_root
     },
     {
-        "filter_iter_in_stage",
-        Filter_filter_iter_in_stage
+        "lookup_self",
+        Hierarchies_lookup_self
     },
     {
-        "filter_iter_10_tags",
-        Filter_filter_iter_10_tags
+        "lookup_in_parent_from_scope",
+        Hierarchies_lookup_in_parent_from_scope
     },
     {
-        "filter_iter_20_tags",
-        Filter_filter_iter_20_tags
+        "lookup_in_root_from_scope",
+        Hierarchies_lookup_in_root_from_scope
     },
     {
-        "filter_iter_10_components",
-        Filter_filter_iter_10_components
+        "lookup_number",
+        Hierarchies_lookup_number
     },
     {
-        "filter_iter_20_components",
-        Filter_filter_iter_20_components
+        "delete_children",
+        Hierarchies_delete_children
     },
     {
-        "filter_iter_superset",
-        Filter_filter_iter_superset
+        "scope_set",
+        Hierarchies_scope_set
     },
     {
-        "filter_iter_superset_childof",
-        Filter_filter_iter_superset_childof
+        "scope_set_again",
+        Hierarchies_scope_set_again
     },
     {
-        "filter_iter_type_set",
-        Filter_filter_iter_type_set
+        "scope_set_w_lookup",
+        Hierarchies_scope_set_w_lookup
     },
     {
-        "filter_iter_w_readonly_term",
-        Filter_filter_iter_w_readonly_term
+        "scope_component",
+        Hierarchies_scope_component
     },
     {
-        "filter_iter_w_from_nothing_term",
-        Filter_filter_iter_w_from_nothing_term
+        "scope_component_no_macro",
+        Hierarchies_scope_component_no_macro
     },
     {
-        "filter_iter_pair_w_rel_wildcard_n_matches",
-        Filter_filter_iter_pair_w_rel_wildcard_n_matches
+        "new_from_path_depth_0",
+        Hierarchies_new_from_path_depth_0
     },
     {
-        "filter_iter_pair_w_obj_wildcard_n_matches",
-        Filter_filter_iter_pair_w_obj_wildcard_n_matches
+        "new_from_path_depth_1",
+        Hierarchies_new_from_path_depth_1
     },
     {
-        "filter_iter_pair_w_2_wildcards_1_match",
-        Filter_filter_iter_pair_w_2_wildcards_1_match
+        "new_from_path_depth_2",
+        Hierarchies_new_from_path_depth_2
     },
     {
-        "filter_iter_pair_w_2_wildcards_2x1_matches",
-        Filter_filter_iter_pair_w_2_wildcards_2x1_matches
+        "new_from_path_existing_depth_0",
+        Hierarchies_new_from_path_existing_depth_0
     },
     {
-        "filter_iter_pair_w_2_wildcards_2x2_matches",
-        Filter_filter_iter_pair_w_2_wildcards_2x2_matches
+        "new_from_path_existing_depth_1",
+        Hierarchies_new_from_path_existing_depth_1
     },
     {
-        "filter_iter_pair_w_3_wildcards_2x2x2_matches",
-        Filter_filter_iter_pair_w_3_wildcards_2x2x2_matches
+        "new_from_path_existing_depth_2",
+        Hierarchies_new_from_path_existing_depth_2
     },
     {
-        "filter_iter_pair_w_wildcard_and_nothing",
-        Filter_filter_iter_pair_w_wildcard_and_nothing
+        "add_path_depth_0",
+        Hierarchies_add_path_depth_0
     },
     {
-        "filter_iter_any",
-        Filter_filter_iter_any
+        "add_path_depth_1",
+        Hierarchies_add_path_depth_1
     },
     {
-        "filter_iter_any_match_wildcard",
-        Filter_filter_iter_any_match_wildcard
+        "add_path_depth_2",
+        Hierarchies_add_path_depth_2
     },
     {
-        "filter_iter_any_match_tag_and_wildcard",
-        Filter_filter_iter_any_match_tag_and_wildcard
+        "add_path_existing_depth_0",
+        Hierarchies_add_path_existing_depth_0
     },
     {
-        "filter_iter_wildcard_in_2nd_term",
-        Filter_filter_iter_wildcard_in_2nd_term
+        "add_path_existing_depth_1",
+        Hierarchies_add_path_existing_depth_1
     },
     {
-        "filter_iter_wildcard_in_2nd_term_self",
-        Filter_filter_iter_wildcard_in_2nd_term_self
+        "add_path_existing_depth_2",
+        Hierarchies_add_path_existing_depth_2
     },
     {
-        "filter_iter_2nd_term_self_create_id_after_filter",
-        Filter_filter_iter_2nd_term_self_create_id_after_filter
+        "add_path_from_scope",
+        Hierarchies_add_path_from_scope
     },
     {
-        "filter_iter_any_obj",
-        Filter_filter_iter_any_obj
+        "add_path_from_scope_new_entity",
+        Hierarchies_add_path_from_scope_new_entity
     },
     {
-        "filter_iter_not_any",
-        Filter_filter_iter_not_any
+        "add_root_path_to_child",
+        Hierarchies_add_root_path_to_child
     },
     {
-        "filter_iter_not_any_obj",
-        Filter_filter_iter_not_any_obj
+        "add_parent_path_from_root_to_child",
+        Hierarchies_add_parent_path_from_root_to_child
     },
     {
-        "filter_iter_cascade_isa",
-        Filter_filter_iter_cascade_isa
+        "delete_child",
+        Hierarchies_delete_child
     },
     {
-        "filter_iter_cascade_childof",
-        Filter_filter_iter_cascade_childof
+        "delete_2_children",
+        Hierarchies_delete_2_children
     },
     {
-        "filter_iter_superset_2_rel_instances",
-        Filter_filter_iter_superset_2_rel_instances
+        "delete_2_children_different_type",
+        Hierarchies_delete_2_children_different_type
     },
     {
-        "filter_iter_superset_2_rel_instances_match_2nd",
-        Filter_filter_iter_superset_2_rel_instances_match_2nd
+        "delete_tree_2_levels",
+        Hierarchies_delete_tree_2_levels
     },
     {
-        "filter_iter_superset_2_levels",
-        Filter_filter_iter_superset_2_levels
+        "delete_tree_3_levels",
+        Hierarchies_delete_tree_3_levels
     },
     {
-        "filter_iter_superset_only_w_owned",
-        Filter_filter_iter_superset_only_w_owned
+        "delete_tree_empty_table",
+        Hierarchies_delete_tree_empty_table
     },
     {
-        "filter_iter_superset_after_add",
-        Filter_filter_iter_superset_after_add
+        "delete_tree_recreate",
+        Hierarchies_delete_tree_recreate
     },
     {
-        "filter_iter_superset_after_remove",
-        Filter_filter_iter_superset_after_remove
+        "delete_tree_w_onremove",
+        Hierarchies_delete_tree_w_onremove
     },
     {
-        "filter_iter_superset_after_clear",
-        Filter_filter_iter_superset_after_clear
+        "delete_tree_w_dtor",
+        Hierarchies_delete_tree_w_dtor
     },
     {
-        "filter_iter_superset_after_delete",
-        Filter_filter_iter_superset_after_delete
+        "get_child_count",
+        Hierarchies_get_child_count
     },
     {
-        "filter_iter_2_terms_superset_2_rel_instances",
-        Filter_filter_iter_2_terms_superset_2_rel_instances
+        "get_child_count_2_tables",
+        Hierarchies_get_child_count_2_tables
     },
     {
-        "filter_iter_2_terms_superset_2_rel_instances_match_2nd",
-        Filter_filter_iter_2_terms_superset_2_rel_instances_match_2nd
+        "get_child_count_no_children",
+        Hierarchies_get_child_count_no_children
     },
     {
-        "filter_iter_superset_parent_w_isa",
-        Filter_filter_iter_superset_parent_w_isa
+        "scope_iter_after_delete_tree",
+        Hierarchies_scope_iter_after_delete_tree
     },
     {
-        "filter_iter_superset_isa_after_remove_parent",
-        Filter_filter_iter_superset_isa_after_remove_parent
+        "add_child_after_delete_tree",
+        Hierarchies_add_child_after_delete_tree
     },
     {
-        "filter_iter_superset_isa_create_table_after_iter",
-        Filter_filter_iter_superset_isa_create_table_after_iter
+        "add_child_to_recycled_parent",
+        Hierarchies_add_child_to_recycled_parent
     },
     {
-        "filter_iter_superset_2_relations",
-        Filter_filter_iter_superset_2_relations
+        "get_type_after_recycled_parent_add",
+        Hierarchies_get_type_after_recycled_parent_add
     },
     {
-        "filter_iter_superset_2_relations_instanced",
-        Filter_filter_iter_superset_2_relations_instanced
+        "long_name_depth_0",
+        Hierarchies_long_name_depth_0
     },
     {
-        "filter_iter_superset_2_relations_w_component",
-        Filter_filter_iter_superset_2_relations_w_component
+        "long_name_depth_1",
+        Hierarchies_long_name_depth_1
     },
     {
-        "filter_iter_superset_2_relations_instanced_w_component",
-        Filter_filter_iter_superset_2_relations_instanced_w_component
+        "long_name_depth_2",
+        Hierarchies_long_name_depth_2
     },
     {
-        "filter_iter_not_up_disabled",
-        Filter_filter_iter_not_up_disabled
+        "ensure_1_parent_after_adding_2",
+        Hierarchies_ensure_1_parent_after_adding_2
     },
     {
-        "filter_iter_pair_wildcard_component",
-        Filter_filter_iter_pair_wildcard_component
+        "ensure_child_alive_after_deleting_prev_parent",
+        Hierarchies_ensure_child_alive_after_deleting_prev_parent
     },
     {
-        "filter_w_10_terms",
-        Filter_filter_w_10_terms
+        "lookup_after_root_to_parent_move",
+        Hierarchies_lookup_after_root_to_parent_move
     },
     {
-        "filter_w_10_terms_move",
-        Filter_filter_w_10_terms_move
+        "lookup_after_parent_to_root_move",
+        Hierarchies_lookup_after_parent_to_root_move
     },
     {
-        "filter_w_10_terms_copy",
-        Filter_filter_w_10_terms_copy
+        "lookup_after_parent_to_parent_move",
+        Hierarchies_lookup_after_parent_to_parent_move
     },
     {
-        "match_disabled",
-        Filter_match_disabled
+        "lookup_after_clear_from_root",
+        Hierarchies_lookup_after_clear_from_root
     },
     {
-        "match_prefab",
-        Filter_match_prefab
+        "lookup_after_clear_from_parent",
+        Hierarchies_lookup_after_clear_from_parent
     },
     {
-        "chain_term_iter",
-        Filter_chain_term_iter
+        "lookup_after_delete_from_root",
+        Hierarchies_lookup_after_delete_from_root
     },
     {
-        "chain_filter_iter",
-        Filter_chain_filter_iter
+        "lookup_after_delete_from_parent",
+        Hierarchies_lookup_after_delete_from_parent
     },
     {
-        "chain_query_iter",
-        Filter_chain_query_iter
+        "defer_batch_remove_name_w_add_childof",
+        Hierarchies_defer_batch_remove_name_w_add_childof
     },
     {
-        "chain_rule_iter",
-        Filter_chain_rule_iter
-    },
+        "defer_batch_remove_childof_w_add_name",
+        Hierarchies_defer_batch_remove_childof_w_add_name
+    }
+};
+
+bake_test_case Has_testcases[] = {
     {
-        "chain_iter_2_levels",
-        Filter_chain_iter_2_levels
+        "zero",
+        Has_zero
     },
     {
-        "filter_from_expr_2_terms_err",
-        Filter_filter_from_expr_2_terms_err
+        "1_of_0",
+        Has_1_of_0
     },
     {
-        "chain_term_iter_w_term_iter",
-        Filter_chain_term_iter_w_term_iter
+        "1_of_1",
+        Has_1_of_1
     },
     {
-        "chain_filter_iter_w_term_iter",
-        Filter_chain_filter_iter_w_term_iter
+        "1_of_2",
+        Has_1_of_2
     },
     {
-        "chain_w_term_iter_component",
-        Filter_chain_w_term_iter_component
+        "1_of_empty",
+        Has_1_of_empty
     },
     {
-        "chain_iter_w_or",
-        Filter_chain_iter_w_or
+        "has_in_progress",
+        Has_has_in_progress
     },
     {
-        "filter_w_recycled_first",
-        Filter_filter_w_recycled_first
+        "has_of_zero",
+        Has_has_of_zero
     },
     {
-        "filter_w_recycled_second",
-        Filter_filter_w_recycled_second
+        "owns",
+        Has_owns
     },
     {
-        "filter_w_recycled_first_and_id",
-        Filter_filter_w_recycled_first_and_id
+        "owns_wildcard",
+        Has_owns_wildcard
     },
     {
-        "filter_w_recycled_second_and_id",
-        Filter_filter_w_recycled_second_and_id
+        "owns_wildcard_pair",
+        Has_owns_wildcard_pair
     },
     {
-        "filter_w_recycled_first_by_name_and_id",
-        Filter_filter_w_recycled_first_by_name_and_id
+        "has_entity",
+        Has_has_entity
     },
     {
-        "filter_w_recycled_second_by_name_and_id",
-        Filter_filter_w_recycled_second_by_name_and_id
+        "has_entity_0",
+        Has_has_entity_0
     },
     {
-        "filter_w_recycled_first_by_expr",
-        Filter_filter_w_recycled_first_by_expr
+        "has_entity_0_component",
+        Has_has_entity_0_component
     },
     {
-        "filter_w_recycled_second_by_expr",
-        Filter_filter_w_recycled_second_by_expr
+        "has_entity_owned",
+        Has_has_entity_owned
     },
     {
-        "filter_w_recycled_first_only_by_expr",
-        Filter_filter_w_recycled_first_only_by_expr
+        "has_entity_owned_0",
+        Has_has_entity_owned_0
     },
     {
-        "term_iter_w_filter_term",
-        Filter_term_iter_w_filter_term
+        "has_entity_owned_0_component",
+        Has_has_entity_owned_0_component
     },
     {
-        "filter_iter_w_filter_term",
-        Filter_filter_iter_w_filter_term
+        "has_wildcard",
+        Has_has_wildcard
     },
     {
-        "filter_iter_w_2_terms_1_filter",
-        Filter_filter_iter_w_2_terms_1_filter
-    },
+        "has_wildcard_pair",
+        Has_has_wildcard_pair
+    }
+};
+
+bake_test_case Count_testcases[] = {
     {
-        "filter_iter_w_3_terms_2_filter",
-        Filter_filter_iter_w_3_terms_2_filter
+        "count_empty",
+        Count_count_empty
     },
     {
-        "filter_iter_2_terms_filter_all",
-        Filter_filter_iter_2_terms_filter_all
+        "count_w_entity_0",
+        Count_count_w_entity_0
     },
     {
-        "filter_iter_2_terms_filter_all_w_out",
-        Filter_filter_iter_2_terms_filter_all_w_out
+        "count_1_component",
+        Count_count_1_component
     },
     {
-        "filter_iter_switch_term_filter",
-        Filter_filter_iter_switch_term_filter
+        "count_disabled",
+        Count_count_disabled
     },
     {
-        "filter_iter_2_terms_switch_term_filter",
-        Filter_filter_iter_2_terms_switch_term_filter
-    },
+        "count_prefab",
+        Count_count_prefab
+    }
+};
+
+bake_test_case Get_component_testcases[] = {
     {
-        "filter_iter_switch_superset",
-        Filter_filter_iter_switch_superset
+        "get_empty",
+        Get_component_get_empty
     },
     {
-        "filter_instanced_w_singleton",
-        Filter_filter_instanced_w_singleton
+        "get_1_from_1",
+        Get_component_get_1_from_1
     },
     {
-        "filter_instanced_w_base",
-        Filter_filter_instanced_w_base
+        "get_1_from_2",
+        Get_component_get_1_from_2
     },
     {
-        "filter_no_instancing_w_singleton",
-        Filter_filter_no_instancing_w_singleton
+        "get_2_from_2",
+        Get_component_get_2_from_2
     },
     {
-        "filter_no_instancing_w_base",
-        Filter_filter_no_instancing_w_base
+        "get_2_from_3",
+        Get_component_get_2_from_3
     },
     {
-        "filter_no_this_tag",
-        Filter_filter_no_this_tag
+        "get_1_from_2_in_progress_from_main_stage",
+        Get_component_get_1_from_2_in_progress_from_main_stage
     },
     {
-        "filter_no_this_component",
-        Filter_filter_no_this_component
+        "get_1_from_2_add_in_progress",
+        Get_component_get_1_from_2_add_in_progress
     },
     {
-        "filter_no_this_tag_2_ents",
-        Filter_filter_no_this_tag_2_ents
+        "get_both_from_2_add_in_progress",
+        Get_component_get_both_from_2_add_in_progress
     },
     {
-        "filter_no_this_component_2_ents",
-        Filter_filter_no_this_component_2_ents
+        "get_both_from_2_add_remove_in_progress",
+        Get_component_get_both_from_2_add_remove_in_progress
     },
     {
-        "filter_no_this_tag_2_ents_1_not",
-        Filter_filter_no_this_tag_2_ents_1_not
+        "get_childof_component",
+        Get_component_get_childof_component
     },
     {
-        "filter_no_this_component_2_ents_1_not",
-        Filter_filter_no_this_component_2_ents_1_not
+        "ensure_equal_get",
+        Get_component_ensure_equal_get
     },
     {
-        "filter_no_this_component_1_not",
-        Filter_filter_no_this_component_1_not
+        "get_tag",
+        Get_component_get_tag
     },
     {
-        "filter_iter_entities_optional_flag",
-        Filter_filter_iter_entities_optional_flag
+        "get_pair_tag",
+        Get_component_get_pair_tag
     },
     {
-        "filter_iter_frame_offset",
-        Filter_filter_iter_frame_offset
-    },
+        "get_wildcard",
+        Get_component_get_wildcard
+    }
+};
+
+bake_test_case Reference_testcases[] = {
     {
-        "filter_1_term_no_alloc",
-        Filter_filter_1_term_no_alloc
+        "get_ref",
+        Reference_get_ref
     },
     {
-        "filter_cache_size_terms_no_alloc",
-        Filter_filter_cache_size_terms_no_alloc
+        "get_ref_after_add",
+        Reference_get_ref_after_add
     },
     {
-        "filter_lt_cache_size_terms_no_alloc",
-        Filter_filter_lt_cache_size_terms_no_alloc
+        "get_ref_after_remove",
+        Reference_get_ref_after_remove
     },
     {
-        "move_self",
-        Filter_move_self
+        "get_ref_after_delete",
+        Reference_get_ref_after_delete
     },
     {
-        "match_empty_tables",
-        Filter_match_empty_tables
+        "get_ref_after_realloc",
+        Reference_get_ref_after_realloc
     },
     {
-        "match_empty_tables_w_no_empty_tables",
-        Filter_match_empty_tables_w_no_empty_tables
+        "get_ref_after_realloc_w_lifecycle",
+        Reference_get_ref_after_realloc_w_lifecycle
     },
     {
-        "match_switch_w_switch",
-        Filter_match_switch_w_switch
+        "get_ref_staged",
+        Reference_get_ref_staged
     },
     {
-        "match_switch_w_case",
-        Filter_match_switch_w_case
+        "get_ref_after_new_in_stage",
+        Reference_get_ref_after_new_in_stage
     },
     {
-        "match_switch_w_case_2_terms",
-        Filter_match_switch_w_case_2_terms
+        "get_ref_monitored",
+        Reference_get_ref_monitored
     },
     {
-        "match_case_no_case",
-        Filter_match_case_no_case
+        "get_ref_w_low_id_tag",
+        Reference_get_ref_w_low_id_tag
     },
     {
-        "and_term",
-        Filter_and_term
+        "get_ref_w_low_id_tag_after_add",
+        Reference_get_ref_w_low_id_tag_after_add
     },
     {
-        "or_term",
-        Filter_or_term
+        "get_nonexisting",
+        Reference_get_nonexisting
     },
     {
-        "iter_while_creating_components",
-        Filter_iter_while_creating_components
-    },
+        "aba_table",
+        Reference_aba_table
+    }
+};
+
+bake_test_case Delete_testcases[] = {
     {
-        "iter_w_this_var_as_entity",
-        Filter_iter_w_this_var_as_entity
+        "delete_1",
+        Delete_delete_1
     },
     {
-        "iter_w_this_var_as_table",
-        Filter_iter_w_this_var_as_table
+        "delete_1_again",
+        Delete_delete_1_again
     },
     {
-        "iter_w_this_var_as_table_range",
-        Filter_iter_w_this_var_as_table_range
+        "delete_recycled_tag_again",
+        Delete_delete_recycled_tag_again
     },
     {
-        "filter_wo_this_var",
-        Filter_filter_wo_this_var
+        "delete_empty",
+        Delete_delete_empty
     },
     {
-        "set_this_to_table_1_term",
-        Filter_set_this_to_table_1_term
+        "delete_nonexist",
+        Delete_delete_nonexist
     },
     {
-        "set_this_to_table_2_terms",
-        Filter_set_this_to_table_2_terms
+        "delete_1st_of_3",
+        Delete_delete_1st_of_3
     },
     {
-        "set_this_to_table_1_wildcard",
-        Filter_set_this_to_table_1_wildcard
+        "delete_2nd_of_3",
+        Delete_delete_2nd_of_3
     },
     {
-        "set_this_to_table_no_match_no_data",
-        Filter_set_this_to_table_no_match_no_data
+        "delete_3rd_of_3",
+        Delete_delete_3rd_of_3
     },
     {
-        "set_this_to_table_no_match",
-        Filter_set_this_to_table_no_match
+        "delete_2_of_3",
+        Delete_delete_2_of_3
     },
     {
-        "set_this_to_table_2_terms_no_match",
-        Filter_set_this_to_table_2_terms_no_match
+        "delete_3_of_3",
+        Delete_delete_3_of_3
     },
     {
-        "set_this_to_empty_table",
-        Filter_set_this_to_empty_table
+        "delete_w_on_remove",
+        Delete_delete_w_on_remove
     },
     {
-        "set_this_to_empty_table_w_component",
-        Filter_set_this_to_empty_table_w_component
+        "clear_1_component",
+        Delete_clear_1_component
     },
     {
-        "set_this_to_implicit_isa_superset_match",
-        Filter_set_this_to_implicit_isa_superset_match
+        "clear_2_components",
+        Delete_clear_2_components
     },
     {
-        "set_this_to_self_isa_superset_match",
-        Filter_set_this_to_self_isa_superset_match
+        "alive_after_delete",
+        Delete_alive_after_delete
     },
     {
-        "set_this_to_isa_superset_match",
-        Filter_set_this_to_isa_superset_match
+        "alive_after_clear",
+        Delete_alive_after_clear
     },
     {
-        "set_this_to_childof_superset_match",
-        Filter_set_this_to_childof_superset_match
+        "alive_after_staged_delete",
+        Delete_alive_after_staged_delete
     },
     {
-        "set_this_to_superset_w_self_filter_no_match",
-        Filter_set_this_to_superset_w_self_filter_no_match
+        "alive_while_staged",
+        Delete_alive_while_staged
     },
     {
-        "set_this_to_isa_cascade",
-        Filter_set_this_to_isa_cascade
+        "alive_while_staged_w_delete",
+        Delete_alive_while_staged_w_delete
     },
     {
-        "set_this_to_childof_cascade",
-        Filter_set_this_to_childof_cascade
+        "alive_while_staged_w_delete_recycled_id",
+        Delete_alive_while_staged_w_delete_recycled_id
     },
     {
-        "set_this_w_wildcard_2_matches",
-        Filter_set_this_w_wildcard_2_matches
+        "alive_after_recycle",
+        Delete_alive_after_recycle
     },
     {
-        "set_this_to_entity_superset_self_has_component",
-        Filter_set_this_to_entity_superset_self_has_component
+        "delete_recycled",
+        Delete_delete_recycled
     },
     {
-        "set_this_to_1_entity_in_table",
-        Filter_set_this_to_1_entity_in_table
+        "get_alive_for_alive",
+        Delete_get_alive_for_alive
     },
     {
-        "oneof",
-        Filter_oneof
+        "get_alive_for_recycled",
+        Delete_get_alive_for_recycled
     },
     {
-        "oneof_expr",
-        Filter_oneof_expr
+        "get_alive_for_not_alive",
+        Delete_get_alive_for_not_alive
     },
     {
-        "oneof_w_mismatching_obj",
-        Filter_oneof_w_mismatching_obj
+        "get_alive_w_generation_for_recycled_alive",
+        Delete_get_alive_w_generation_for_recycled_alive
     },
     {
-        "oneof_w_mismatching_obj_expr",
-        Filter_oneof_w_mismatching_obj_expr
+        "get_alive_w_generation_for_recycled_not_alive",
+        Delete_get_alive_w_generation_for_recycled_not_alive
     },
     {
-        "oneof_wildcard",
-        Filter_oneof_wildcard
+        "get_alive_for_0",
+        Delete_get_alive_for_0
     },
     {
-        "oneof_any",
-        Filter_oneof_any
+        "get_alive_for_nonexistent",
+        Delete_get_alive_for_nonexistent
     },
     {
-        "flag_match_only_this",
-        Filter_flag_match_only_this
+        "move_w_dtor_move",
+        Delete_move_w_dtor_move
     },
     {
-        "flag_match_only_this_w_ref",
-        Filter_flag_match_only_this_w_ref
+        "move_w_dtor_no_move",
+        Delete_move_w_dtor_no_move
     },
     {
-        "filter_w_alloc",
-        Filter_filter_w_alloc
+        "move_w_no_dtor_move",
+        Delete_move_w_no_dtor_move
     },
     {
-        "filter_w_short_notation",
-        Filter_filter_w_short_notation
+        "wrap_generation_count",
+        Delete_wrap_generation_count
     }
 };
 
-bake_test_case FilterStr_testcases[] = {
+bake_test_case OnDelete_testcases[] = {
+    {
+        "flags",
+        OnDelete_flags
+    },
     {
-        "one_term",
-        FilterStr_one_term
+        "id_default",
+        OnDelete_id_default
     },
     {
-        "one_term_w_inout",
-        FilterStr_one_term_w_inout
+        "id_remove",
+        OnDelete_id_remove
     },
     {
-        "two_terms",
-        FilterStr_two_terms
+        "id_delete",
+        OnDelete_id_delete
     },
     {
-        "two_terms_w_inout",
-        FilterStr_two_terms_w_inout
+        "relation_default",
+        OnDelete_relation_default
     },
     {
-        "three_terms_w_or",
-        FilterStr_three_terms_w_or
+        "relation_remove",
+        OnDelete_relation_remove
     },
     {
-        "three_terms_w_or_inout",
-        FilterStr_three_terms_w_or_inout
+        "relation_delete",
+        OnDelete_relation_delete
     },
     {
-        "four_terms_three_w_or_inout",
-        FilterStr_four_terms_three_w_or_inout
+        "object_default",
+        OnDelete_object_default
     },
     {
-        "one_term_w_pair",
-        FilterStr_one_term_w_pair
+        "object_remove",
+        OnDelete_object_remove
     },
     {
-        "one_term_w_pair_entity_src",
-        FilterStr_one_term_w_pair_entity_src
+        "object_delete",
+        OnDelete_object_delete
     },
     {
-        "one_term_w_self",
-        FilterStr_one_term_w_self
+        "id_throw",
+        OnDelete_id_throw
     },
     {
-        "one_term_w_up",
-        FilterStr_one_term_w_up
+        "relation_throw",
+        OnDelete_relation_throw
     },
     {
-        "one_term_w_0",
-        FilterStr_one_term_w_0
+        "object_throw",
+        OnDelete_object_throw
     },
     {
-        "one_term_w_singleton",
-        FilterStr_one_term_w_singleton
+        "object_mixed",
+        OnDelete_object_mixed
     },
     {
-        "one_term_w_final_pair",
-        FilterStr_one_term_w_final_pair
+        "id_remove_no_instances",
+        OnDelete_id_remove_no_instances
     },
     {
-        "one_term_w_final_dont_inherit_pair",
-        FilterStr_one_term_w_final_dont_inherit_pair
+        "id_delete_no_instances",
+        OnDelete_id_delete_no_instances
     },
     {
-        "one_term_w_src_var",
-        FilterStr_one_term_w_src_var
+        "id_throw_no_instances",
+        OnDelete_id_throw_no_instances
     },
     {
-        "one_term_w_first_var",
-        FilterStr_one_term_w_first_var
+        "cyclic_self",
+        OnDelete_cyclic_self
     },
     {
-        "one_term_w_second_var",
-        FilterStr_one_term_w_second_var
+        "nonempty_cyclic_self",
+        OnDelete_nonempty_cyclic_self
     },
     {
-        "one_term_w_first_var_entity_src",
-        FilterStr_one_term_w_first_var_entity_src
+        "cyclic_id_default",
+        OnDelete_cyclic_id_default
     },
     {
-        "one_term_w_pair_w_0_entity",
-        FilterStr_one_term_w_pair_w_0_entity
+        "cyclic_id_remove",
+        OnDelete_cyclic_id_remove
     },
     {
-        "not_term",
-        FilterStr_not_term
+        "cyclic_id_remove_both",
+        OnDelete_cyclic_id_remove_both
     },
     {
-        "wildcard_term",
-        FilterStr_wildcard_term
+        "cyclic_id_delete",
+        OnDelete_cyclic_id_delete
     },
     {
-        "scopes",
-        FilterStr_scopes
+        "cyclic_id_delete_both",
+        OnDelete_cyclic_id_delete_both
     },
     {
-        "pred_eq",
-        FilterStr_pred_eq
+        "cyclic_relation_default",
+        OnDelete_cyclic_relation_default
     },
     {
-        "pred_neq",
-        FilterStr_pred_neq
+        "cyclic_relation_remove",
+        OnDelete_cyclic_relation_remove
     },
     {
-        "pred_eq_name",
-        FilterStr_pred_eq_name
+        "cyclic_relation_remove_both",
+        OnDelete_cyclic_relation_remove_both
     },
     {
-        "pred_neq_name",
-        FilterStr_pred_neq_name
+        "cyclic_relation_delete",
+        OnDelete_cyclic_relation_delete
     },
     {
-        "pred_eq_m",
-        FilterStr_pred_eq_m
+        "cyclic_relation_delete_both",
+        OnDelete_cyclic_relation_delete_both
     },
     {
-        "pred_neq_m",
-        FilterStr_pred_neq_m
-    }
-};
-
-bake_test_case Query_testcases[] = {
+        "cyclic_object_default",
+        OnDelete_cyclic_object_default
+    },
     {
-        "simple_query_existing_table",
-        Query_simple_query_existing_table
+        "cyclic_object_remove",
+        OnDelete_cyclic_object_remove
     },
     {
-        "simple_query_2_existing_tables",
-        Query_simple_query_2_existing_tables
+        "cyclic_object_delete",
+        OnDelete_cyclic_object_delete
     },
     {
-        "simple_query_new_table",
-        Query_simple_query_new_table
+        "cyclic_overlapping_table",
+        OnDelete_cyclic_overlapping_table
     },
     {
-        "simple_query_2_new_tables",
-        Query_simple_query_2_new_tables
+        "cyclic_overlapping_new_tables",
+        OnDelete_cyclic_overlapping_new_tables
     },
     {
-        "simple_query_existing_and_new_table",
-        Query_simple_query_existing_and_new_table
+        "cyclic_object_mixed",
+        OnDelete_cyclic_object_mixed
     },
     {
-        "wildcard_query_existing_table",
-        Query_wildcard_query_existing_table
+        "cyclic_storage_table",
+        OnDelete_cyclic_storage_table
     },
     {
-        "wildcard_query_new_table",
-        Query_wildcard_query_new_table
+        "cyclic_storage_table_2",
+        OnDelete_cyclic_storage_table_2
     },
     {
-        "wildcard_query_existing_table_2_results_p_table",
-        Query_wildcard_query_existing_table_2_results_p_table
+        "cyclic_storage_table_3",
+        OnDelete_cyclic_storage_table_3
     },
     {
-        "wildcard_query_new_table_2_results_p_table",
-        Query_wildcard_query_new_table_2_results_p_table
+        "cyclic_set_empty",
+        OnDelete_cyclic_set_empty
     },
     {
-        "wildcard_query_2nd_term",
-        Query_wildcard_query_2nd_term
+        "2_acyclic_relations_w_cycle",
+        OnDelete_2_acyclic_relations_w_cycle
     },
     {
-        "wildcard_query_2nd_term_self",
-        Query_wildcard_query_2nd_term_self
+        "remove_2_comps",
+        OnDelete_remove_2_comps
     },
     {
-        "simple_query_existing_empty_table",
-        Query_simple_query_existing_empty_table
+        "remove_2_comps_to_existing_table",
+        OnDelete_remove_2_comps_to_existing_table
     },
     {
-        "simple_query_existing_empty_type",
-        Query_simple_query_existing_empty_type
+        "delete_recursive",
+        OnDelete_delete_recursive
     },
     {
-        "simple_query_new_empty_table",
-        Query_simple_query_new_empty_table
+        "component_throw",
+        OnDelete_component_throw
     },
     {
-        "component_query_existing_table",
-        Query_component_query_existing_table
+        "remove_2_relations",
+        OnDelete_remove_2_relations
     },
     {
-        "component_query_new_table",
-        Query_component_query_new_table
+        "remove_object_w_2_relations",
+        OnDelete_remove_object_w_2_relations
     },
     {
-        "component_query_existing_empty_table",
-        Query_component_query_existing_empty_table
+        "remove_object_w_5_relations",
+        OnDelete_remove_object_w_5_relations
     },
     {
-        "2_component_query_existing_empty_table",
-        Query_2_component_query_existing_empty_table
+        "remove_object_w_50_relations",
+        OnDelete_remove_object_w_50_relations
     },
     {
-        "2_component_query_existing_empty_type",
-        Query_2_component_query_existing_empty_type
+        "remove_object_w_50_relations_3_tables",
+        OnDelete_remove_object_w_50_relations_3_tables
     },
     {
-        "only_optional",
-        Query_only_optional
+        "remove_object_w_3_relations_interleaved",
+        OnDelete_remove_object_w_3_relations_interleaved
     },
     {
-        "only_optional_new_empty_table",
-        Query_only_optional_new_empty_table
+        "remove_id_from_2_tables",
+        OnDelete_remove_id_from_2_tables
     },
     {
-        "only_optional_new_empty_non_empty_table",
-        Query_only_optional_new_empty_non_empty_table
+        "remove_relation_from_2_tables",
+        OnDelete_remove_relation_from_2_tables
     },
     {
-        "only_optional_new_unset_tables",
-        Query_only_optional_new_unset_tables
+        "remove_object_from_2_tables",
+        OnDelete_remove_object_from_2_tables
     },
     {
-        "singleton_w_optional_new_empty_table",
-        Query_singleton_w_optional_new_empty_table
+        "remove_id_and_relation",
+        OnDelete_remove_id_and_relation
     },
     {
-        "singleton_w_optional_new_empty_non_empty_table",
-        Query_singleton_w_optional_new_empty_non_empty_table
+        "remove_id_and_relation_from_2_tables",
+        OnDelete_remove_id_and_relation_from_2_tables
     },
     {
-        "singleton_w_optional_new_unset_tables",
-        Query_singleton_w_optional_new_unset_tables
+        "stresstest_many_objects",
+        OnDelete_stresstest_many_objects
     },
     {
-        "query_only_from_entity",
-        Query_query_only_from_entity
+        "stresstest_many_relations",
+        OnDelete_stresstest_many_relations
     },
     {
-        "query_only_from_entity_no_match",
-        Query_query_only_from_entity_no_match
+        "stresstest_many_objects_on_delete",
+        OnDelete_stresstest_many_objects_on_delete
     },
     {
-        "query_only_from_entity_no_match_iter_alloc",
-        Query_query_only_from_entity_no_match_iter_alloc
+        "stresstest_many_relations_on_delete",
+        OnDelete_stresstest_many_relations_on_delete
     },
     {
-        "query_only_from_singleton",
-        Query_query_only_from_singleton
+        "empty_table_w_on_remove",
+        OnDelete_empty_table_w_on_remove
     },
     {
-        "query_only_from_entity_match_after",
-        Query_query_only_from_entity_match_after
+        "delete_table_in_on_remove_during_fini",
+        OnDelete_delete_table_in_on_remove_during_fini
     },
     {
-        "query_only_from_singleton_match_after",
-        Query_query_only_from_singleton_match_after
+        "delete_other_in_on_remove_during_fini",
+        OnDelete_delete_other_in_on_remove_during_fini
     },
     {
-        "query_only_from_singleton_component_match_after",
-        Query_query_only_from_singleton_component_match_after
+        "remove_id_w_role",
+        OnDelete_remove_id_w_role
     },
     {
-        "query_only_from_nothing",
-        Query_query_only_from_nothing
+        "remove_rel_w_override_pair",
+        OnDelete_remove_rel_w_override_pair
     },
     {
-        "query_only_from_entity_optional",
-        Query_query_only_from_entity_optional
+        "remove_obj_w_override_pair",
+        OnDelete_remove_obj_w_override_pair
     },
     {
-        "query_only_from_entity_no_match_optional",
-        Query_query_only_from_entity_no_match_optional
+        "remove_rel_w_override_pair_after_on_delete_target",
+        OnDelete_remove_rel_w_override_pair_after_on_delete_target
     },
     {
-        "query_only_from_entity_or",
-        Query_query_only_from_entity_or
+        "remove_rel_w_override_pair_2_ids",
+        OnDelete_remove_rel_w_override_pair_2_ids
     },
     {
-        "query_only_from_entity_no_match_or",
-        Query_query_only_from_entity_no_match_or
+        "remove_obj_w_override_pair_2_ids",
+        OnDelete_remove_obj_w_override_pair_2_ids
     },
     {
-        "query_only_from_entity_or_change",
-        Query_query_only_from_entity_or_change
+        "remove_obj_w_override_pair_3_ids",
+        OnDelete_remove_obj_w_override_pair_3_ids
     },
     {
-        "query_from_entity_or_change",
-        Query_query_from_entity_or_change
+        "remove_mixed_w_override_pair_3_ids",
+        OnDelete_remove_mixed_w_override_pair_3_ids
     },
     {
-        "query_from_entity_w_superset",
-        Query_query_from_entity_w_superset
+        "merge_pair_component",
+        OnDelete_merge_pair_component
     },
     {
-        "query_w_singleton_tag_non_instanced",
-        Query_query_w_singleton_tag_non_instanced
+        "delete_with_tag",
+        OnDelete_delete_with_tag
     },
     {
-        "query_w_singleton_tag_instanced",
-        Query_query_w_singleton_tag_instanced
+        "delete_with_component",
+        OnDelete_delete_with_component
     },
     {
-        "query_w_singleton_component_non_instanced",
-        Query_query_w_singleton_component_non_instanced
+        "delete_with_pair",
+        OnDelete_delete_with_pair
     },
     {
-        "query_w_singleton_component_instanced",
-        Query_query_w_singleton_component_instanced
+        "delete_with_object_wildcard",
+        OnDelete_delete_with_object_wildcard
     },
     {
-        "query_w_from_entity",
-        Query_query_w_from_entity
+        "delete_with_relation_wildcard",
+        OnDelete_delete_with_relation_wildcard
     },
     {
-        "query_w_from_singleton",
-        Query_query_w_from_singleton
+        "delete_with_component_after_delete_cyclic_self",
+        OnDelete_delete_with_component_after_delete_cyclic_self
     },
     {
-        "query_w_from_entity_match_after",
-        Query_query_w_from_entity_match_after
+        "delete_with_component_after_delete_cyclic",
+        OnDelete_delete_with_component_after_delete_cyclic
     },
     {
-        "query_w_from_singleton_match_after",
-        Query_query_w_from_singleton_match_after
+        "delete_with_component_after_delete_cyclic_w_alive_moved",
+        OnDelete_delete_with_component_after_delete_cyclic_w_alive_moved
     },
     {
-        "query_w_from_nothing",
-        Query_query_w_from_nothing
+        "delete_all_with_entity",
+        OnDelete_delete_all_with_entity
     },
     {
-        "query_w_existing_switch_and_case",
-        Query_query_w_existing_switch_and_case
+        "remove_childof_entity",
+        OnDelete_remove_childof_entity
     },
     {
-        "query_w_new_switch_and_case",
-        Query_query_w_new_switch_and_case
+        "remove_childof_wildcard",
+        OnDelete_remove_childof_wildcard
     },
     {
-        "query_for_case_existing",
-        Query_query_for_case_existing
+        "delete_child_of_delete_with",
+        OnDelete_delete_child_of_delete_with
     },
     {
-        "query_for_case_new",
-        Query_query_for_case_new
+        "deep_clean_64",
+        OnDelete_deep_clean_64
     },
     {
-        "query_for_switch_filter_term",
-        Query_query_for_switch_filter_term
+        "deep_clean_256",
+        OnDelete_deep_clean_256
     },
     {
-        "query_switch_from_nothing",
-        Query_query_switch_from_nothing
+        "id_w_disabled",
+        OnDelete_id_w_disabled
     },
     {
-        "query_case_from_nothing",
-        Query_query_case_from_nothing
+        "id_to_no_disabled",
+        OnDelete_id_to_no_disabled
     },
     {
-        "query_case_inherited",
-        Query_query_case_inherited
+        "remove_on_delete_action",
+        OnDelete_remove_on_delete_action
     },
     {
-        "query_case_w_generation",
-        Query_query_case_w_generation
+        "delete_with_w_relation",
+        OnDelete_delete_with_w_relation
     },
     {
-        "query_case_w_not_alive",
-        Query_query_case_w_not_alive
+        "delete_self_in_on_remove",
+        OnDelete_delete_self_in_on_remove
     },
     {
-        "query_disabled_from_nothing",
-        Query_query_disabled_from_nothing
+        "delete_nested_in_on_remove",
+        OnDelete_delete_nested_in_on_remove
     },
     {
-        "query_only_2_or",
-        Query_query_only_2_or
+        "add_deleted_in_on_remove",
+        OnDelete_add_deleted_in_on_remove
     },
     {
-        "query_only_3_or",
-        Query_query_only_3_or
+        "delete_tree_w_query",
+        OnDelete_delete_tree_w_query
     },
     {
-        "query_2_or",
-        Query_query_2_or
+        "fini_cleanup_order",
+        OnDelete_fini_cleanup_order
     },
     {
-        "query_3_or",
-        Query_query_3_or
+        "fini_cleanup_order_root_id_w_trait",
+        OnDelete_fini_cleanup_order_root_id_w_trait
     },
     {
-        "query_and_type",
-        Query_query_and_type
+        "fini_cleanup_order_entity_after_singleton",
+        OnDelete_fini_cleanup_order_entity_after_singleton
     },
     {
-        "query_or_type",
-        Query_query_or_type
+        "fini_cleanup_order_entity_after_component",
+        OnDelete_fini_cleanup_order_entity_after_component
     },
     {
-        "query_and_type_match_after",
-        Query_query_and_type_match_after
+        "on_delete_parent_w_in_use_id_w_remove",
+        OnDelete_on_delete_parent_w_in_use_id_w_remove
     },
     {
-        "query_or_type_match_after",
-        Query_query_or_type_match_after
+        "on_delete_parent_w_in_use_id_w_delete",
+        OnDelete_on_delete_parent_w_in_use_id_w_delete
     },
     {
-        "query_changed_after_new",
-        Query_query_changed_after_new
+        "create_after_delete_with",
+        OnDelete_create_after_delete_with
     },
     {
-        "query_changed_after_delete",
-        Query_query_changed_after_delete
+        "delete_with_inherited_tag",
+        OnDelete_delete_with_inherited_tag
     },
     {
-        "query_changed_after_add",
-        Query_query_changed_after_add
+        "delete_with_inherited_tag_w_query",
+        OnDelete_delete_with_inherited_tag_w_query
     },
     {
-        "query_changed_after_remove",
-        Query_query_changed_after_remove
+        "delete_with_inherited_tag_w_observer",
+        OnDelete_delete_with_inherited_tag_w_observer
     },
     {
-        "query_changed_after_set",
-        Query_query_changed_after_set
+        "delete_symmetric_relation",
+        OnDelete_delete_symmetric_relation
     },
     {
-        "query_change_after_modified",
-        Query_query_change_after_modified
+        "delete_observed_symmetric_relation",
+        OnDelete_delete_observed_symmetric_relation
     },
     {
-        "query_change_after_out_system",
-        Query_query_change_after_out_system
+        "nested_delete_with",
+        OnDelete_nested_delete_with
     },
     {
-        "query_change_after_in_system",
-        Query_query_change_after_in_system
+        "deferred_delete_with_after_create_named",
+        OnDelete_deferred_delete_with_after_create_named
     },
     {
-        "query_change_after_modified_out_term",
-        Query_query_change_after_modified_out_term
+        "deferred_delete_with_childof_after_create_named",
+        OnDelete_deferred_delete_with_childof_after_create_named
     },
     {
-        "query_change_check_iter",
-        Query_query_change_check_iter
+        "match_marked_for_deletion",
+        OnDelete_match_marked_for_deletion
     },
     {
-        "query_change_check_iter_after_skip_read",
-        Query_query_change_check_iter_after_skip_read
+        "delete_w_low_rel_mixed_cleanup",
+        OnDelete_delete_w_low_rel_mixed_cleanup
     },
     {
-        "query_change_check_iter_after_skip_write",
-        Query_query_change_check_iter_after_skip_write
+        "delete_w_low_rel_mixed_cleanup_interleaved_ids",
+        OnDelete_delete_w_low_rel_mixed_cleanup_interleaved_ids
     },
     {
-        "query_change_parent_term",
-        Query_query_change_parent_term
+        "fini_query_w_singleton_in_scope_no_module",
+        OnDelete_fini_query_w_singleton_in_scope_no_module
     },
     {
-        "query_change_prefab_term",
-        Query_query_change_prefab_term
+        "fini_query_w_singleton_in_module",
+        OnDelete_fini_query_w_singleton_in_module
     },
     {
-        "query_change_parent_term_w_tag",
-        Query_query_change_parent_term_w_tag
-    },
+        "fini_observer_w_relationship_in_scope",
+        OnDelete_fini_observer_w_relationship_in_scope
+    }
+};
+
+bake_test_case Set_testcases[] = {
     {
-        "query_change_prefab_term_w_tag",
-        Query_query_change_prefab_term_w_tag
+        "set_empty",
+        Set_set_empty
     },
     {
-        "query_change_skip_non_instanced",
-        Query_query_change_skip_non_instanced
+        "set_nonempty",
+        Set_set_nonempty
     },
     {
-        "query_changed_w_or",
-        Query_query_changed_w_or
+        "set_non_empty_override",
+        Set_set_non_empty_override
     },
     {
-        "query_changed_or",
-        Query_query_changed_or
+        "set_again",
+        Set_set_again
     },
     {
-        "query_changed_w_singleton",
-        Query_query_changed_w_singleton
+        "set_2",
+        Set_set_2
     },
     {
-        "query_changed_w_only_singleton",
-        Query_query_changed_w_only_singleton
+        "add_set",
+        Set_add_set
     },
     {
-        "query_changed_w_only_singleton_after_set",
-        Query_query_changed_w_only_singleton_after_set
+        "set_add",
+        Set_set_add
     },
     {
-        "query_changed_w_only_singleton_after_out_term",
-        Query_query_changed_w_only_singleton_after_out_term
+        "set_add_other",
+        Set_set_add_other
     },
     {
-        "query_changed_w_only_singleton_after_singleton_out_term",
-        Query_query_changed_w_only_singleton_after_singleton_out_term
+        "set_remove",
+        Set_set_remove
     },
     {
-        "query_changed_w_only_parent",
-        Query_query_changed_w_only_parent
+        "set_remove_other",
+        Set_set_remove_other
     },
     {
-        "query_changed_w_only_parent_after_set",
-        Query_query_changed_w_only_parent_after_set
+        "set_remove_twice",
+        Set_set_remove_twice
     },
     {
-        "query_changed_w_only_parent_after_out_term",
-        Query_query_changed_w_only_parent_after_out_term
+        "set_and_new",
+        Set_set_and_new
     },
     {
-        "query_changed_w_only_parent_after_parent_out_term",
-        Query_query_changed_w_only_parent_after_parent_out_term
+        "set_null",
+        Set_set_null
     },
     {
-        "query_changed_tag",
-        Query_query_changed_tag
+        "ensure_new",
+        Set_ensure_new
     },
     {
-        "query_changed_no_source",
-        Query_query_changed_no_source
+        "ensure_existing",
+        Set_ensure_existing
     },
     {
-        "query_changed_no_source_component",
-        Query_query_changed_no_source_component
+        "ensure_tag_new",
+        Set_ensure_tag_new
     },
     {
-        "query_changed_w_not_out",
-        Query_query_changed_w_not_out
+        "ensure_tag_existing",
+        Set_ensure_tag_existing
     },
     {
-        "subquery_match_existing",
-        Query_subquery_match_existing
+        "ensure_tag_new_w_comp",
+        Set_ensure_tag_new_w_comp
     },
     {
-        "subquery_match_new",
-        Query_subquery_match_new
+        "ensure_tag_existing_w_comp",
+        Set_ensure_tag_existing_w_comp
     },
     {
-        "subquery_inactive",
-        Query_subquery_inactive
+        "ensure_tag_new_w_pair",
+        Set_ensure_tag_new_w_pair
     },
     {
-        "subquery_unmatch",
-        Query_subquery_unmatch
+        "ensure_tag_existing_w_pair",
+        Set_ensure_tag_existing_w_pair
     },
     {
-        "subquery_rematch",
-        Query_subquery_rematch
+        "get_mut_not_existing",
+        Set_get_mut_not_existing
     },
     {
-        "subquery_rematch_w_parent_optional",
-        Query_subquery_rematch_w_parent_optional
+        "get_mut_existing",
+        Set_get_mut_existing
     },
     {
-        "subquery_rematch_w_sub_optional",
-        Query_subquery_rematch_w_sub_optional
+        "get_mut_tag",
+        Set_get_mut_tag
     },
     {
-        "query_single_pairs",
-        Query_query_single_pairs
+        "get_mut_pair",
+        Set_get_mut_pair
     },
     {
-        "query_single_instanceof",
-        Query_query_single_instanceof
+        "get_mut_pair_second",
+        Set_get_mut_pair_second
     },
     {
-        "query_single_childof",
-        Query_query_single_childof
+        "modified_w_on_set",
+        Set_modified_w_on_set
     },
     {
-        "query_optional_owned",
-        Query_query_optional_owned
+        "modified_no_component",
+        Set_modified_no_component
     },
     {
-        "query_optional_shared",
-        Query_query_optional_shared
+        "ensure_w_add_in_on_add",
+        Set_ensure_w_add_in_on_add
     },
     {
-        "query_optional_shared_nested",
-        Query_query_optional_shared_nested
+        "ensure_w_remove_in_on_add",
+        Set_ensure_w_remove_in_on_add
     },
     {
-        "query_optional_any",
-        Query_query_optional_any
+        "ensure_w_realloc_in_on_add",
+        Set_ensure_w_realloc_in_on_add
     },
     {
-        "query_rematch_optional_after_add",
-        Query_query_rematch_optional_after_add
+        "emplace",
+        Set_emplace
     },
     {
-        "get_owned_tag",
-        Query_get_owned_tag
+        "emplace_2",
+        Set_emplace_2
     },
     {
-        "get_shared_tag",
-        Query_get_shared_tag
+        "emplace_existing",
+        Set_emplace_existing
     },
     {
-        "explicit_delete",
-        Query_explicit_delete
+        "emplace_w_move",
+        Set_emplace_w_move
     },
     {
-        "get_column_size",
-        Query_get_column_size
+        "emplace_w_observer_w_add",
+        Set_emplace_w_observer_w_add
     },
     {
-        "orphaned_query",
-        Query_orphaned_query
-    },
+        "emplace_existing_w_check",
+        Set_emplace_existing_w_check
+    }
+};
+
+bake_test_case ReadWrite_testcases[] = {
     {
-        "nested_orphaned_query",
-        Query_nested_orphaned_query
+        "read",
+        ReadWrite_read
     },
     {
-        "invalid_access_orphaned_query",
-        Query_invalid_access_orphaned_query
+        "nested_read",
+        ReadWrite_nested_read
     },
     {
-        "stresstest_query_free",
-        Query_stresstest_query_free
+        "write",
+        ReadWrite_write
     },
     {
-        "only_from_entity",
-        Query_only_from_entity
+        "nested_write",
+        ReadWrite_nested_write
     },
     {
-        "only_not_from_entity",
-        Query_only_not_from_entity
+        "add_while_read",
+        ReadWrite_add_while_read
     },
     {
-        "only_from_singleton",
-        Query_only_from_singleton
+        "add_while_write",
+        ReadWrite_add_while_write
     },
     {
-        "only_not_from_singleton",
-        Query_only_not_from_singleton
+        "read_from_stage",
+        ReadWrite_read_from_stage
     },
     {
-        "get_filter",
-        Query_get_filter
-    },
+        "write_from_stage",
+        ReadWrite_write_from_stage
+    }
+};
+
+bake_test_case Lookup_testcases[] = {
     {
-        "group_by",
-        Query_group_by
+        "lookup",
+        Lookup_lookup
     },
     {
-        "group_by_w_ctx",
-        Query_group_by_w_ctx
+        "lookup_component",
+        Lookup_lookup_component
     },
     {
-        "group_by_w_sort_reverse_group_creation",
-        Query_group_by_w_sort_reverse_group_creation
+        "lookup_not_found",
+        Lookup_lookup_not_found
     },
     {
-        "group_by_iter_one",
-        Query_group_by_iter_one
+        "lookup_child",
+        Lookup_lookup_child
     },
     {
-        "group_by_iter_one_all_groups",
-        Query_group_by_iter_one_all_groups
+        "lookup_w_null_name",
+        Lookup_lookup_w_null_name
     },
     {
-        "group_by_iter_one_empty",
-        Query_group_by_iter_one_empty
+        "lookup_after_name_reset",
+        Lookup_lookup_after_name_reset
     },
     {
-        "group_by_iter_one_empty_query",
-        Query_group_by_iter_one_empty_query
+        "get_name",
+        Lookup_get_name
     },
     {
-        "group_by_iter_one_empty_table",
-        Query_group_by_iter_one_empty_table
+        "get_name_no_name",
+        Lookup_get_name_no_name
     },
     {
-        "group_by_w_deleted_group_id",
-        Query_group_by_w_deleted_group_id
+        "get_name_from_empty",
+        Lookup_get_name_from_empty
     },
     {
-        "group_by_callbacks",
-        Query_group_by_callbacks
+        "lookup_by_id",
+        Lookup_lookup_by_id
     },
     {
-        "group_by_default_action",
-        Query_group_by_default_action
+        "lookup_recycled_by_id",
+        Lookup_lookup_recycled_by_id
     },
     {
-        "group_table_count",
-        Query_group_table_count
+        "lookup_symbol_by_id",
+        Lookup_lookup_symbol_by_id
     },
     {
-        "iter_valid",
-        Query_iter_valid
+        "lookup_name_w_digit",
+        Lookup_lookup_name_w_digit
     },
     {
-        "query_optional_tag",
-        Query_query_optional_tag
+        "lookup_symbol_w_digit",
+        Lookup_lookup_symbol_w_digit
     },
     {
-        "query_optional_shared_tag",
-        Query_query_optional_shared_tag
+        "lookup_path_w_digit",
+        Lookup_lookup_path_w_digit
     },
     {
-        "query_iter_10_tags",
-        Query_query_iter_10_tags
+        "lookup_name_w_spaces",
+        Lookup_lookup_name_w_spaces
     },
     {
-        "query_iter_20_tags",
-        Query_query_iter_20_tags
+        "lookup_path_w_spaces",
+        Lookup_lookup_path_w_spaces
     },
     {
-        "query_iter_10_components",
-        Query_query_iter_10_components
+        "set_name_of_existing",
+        Lookup_set_name_of_existing
     },
     {
-        "query_iter_20_components",
-        Query_query_iter_20_components
+        "change_name_of_existing",
+        Lookup_change_name_of_existing
     },
     {
-        "iter_type_set",
-        Query_iter_type_set
+        "lookup_alias",
+        Lookup_lookup_alias
     },
     {
-        "filter_term",
-        Query_filter_term
+        "lookup_scoped_alias",
+        Lookup_lookup_scoped_alias
     },
     {
-        "2_terms_1_filter",
-        Query_2_terms_1_filter
+        "define_duplicate_alias",
+        Lookup_define_duplicate_alias
     },
     {
-        "3_terms_2_filter",
-        Query_3_terms_2_filter
+        "lookup_null",
+        Lookup_lookup_null
     },
     {
-        "no_instancing_w_singleton",
-        Query_no_instancing_w_singleton
+        "lookup_symbol_null",
+        Lookup_lookup_symbol_null
     },
     {
-        "no_instancing_w_shared",
-        Query_no_instancing_w_shared
+        "lookup_this",
+        Lookup_lookup_this
     },
     {
-        "query_iter_frame_offset",
-        Query_query_iter_frame_offset
+        "lookup_wildcard",
+        Lookup_lookup_wildcard
     },
     {
-        "add_singleton_after_query",
-        Query_add_singleton_after_query
+        "lookup_any",
+        Lookup_lookup_any
     },
     {
-        "query_w_component_from_parent_from_non_this",
-        Query_query_w_component_from_parent_from_non_this
+        "lookup_variable",
+        Lookup_lookup_variable
     },
     {
-        "create_query_while_pending",
-        Query_create_query_while_pending
+        "lookup_path_this",
+        Lookup_lookup_path_this
     },
     {
-        "empty_query",
-        Query_empty_query
+        "lookup_path_wildcard",
+        Lookup_lookup_path_wildcard
     },
     {
-        "parent_cascade",
-        Query_parent_cascade
+        "lookup_path_this_from_scope",
+        Lookup_lookup_path_this_from_scope
     },
     {
-        "existing_custom_rel_cascade",
-        Query_existing_custom_rel_cascade
+        "lookup_path_wildcard_from_scope",
+        Lookup_lookup_path_wildcard_from_scope
     },
     {
-        "new_custom_rel_cascade",
-        Query_new_custom_rel_cascade
+        "resolve_builtin_symbols",
+        Lookup_resolve_builtin_symbols
     },
     {
-        "cascade_w_2_depths",
-        Query_cascade_w_2_depths
+        "lookup_from_scope_staged",
+        Lookup_lookup_from_scope_staged
     },
     {
-        "cascade_w_3_depths",
-        Query_cascade_w_3_depths
+        "lookup_core",
+        Lookup_lookup_core
     },
     {
-        "cascade_w_2_depths_desc",
-        Query_cascade_w_2_depths_desc
+        "lookup_core_from_stage",
+        Lookup_lookup_core_from_stage
     },
     {
-        "cascade_w_3_depths_desc",
-        Query_cascade_w_3_depths_desc
+        "lookup_custom_search_path",
+        Lookup_lookup_custom_search_path
     },
     {
-        "not_pair_relation_wildcard",
-        Query_not_pair_relation_wildcard
+        "lookup_custom_search_path_from_stage",
+        Lookup_lookup_custom_search_path_from_stage
     },
     {
-        "not_pair_object_wildcard",
-        Query_not_pair_object_wildcard
+        "lookup_custom_search_path_n_elems",
+        Lookup_lookup_custom_search_path_n_elems
     },
     {
-        "two_pair_wildcards_one_not",
-        Query_two_pair_wildcards_one_not
+        "set_same_name",
+        Lookup_set_same_name
     },
     {
-        "two_pair_wildcards_one_not_any",
-        Query_two_pair_wildcards_one_not_any
+        "set_same_name_after_reparenting",
+        Lookup_set_same_name_after_reparenting
     },
     {
-        "implicit_existing_isa_superset",
-        Query_implicit_existing_isa_superset
+        "defer_set_name",
+        Lookup_defer_set_name
     },
     {
-        "implicit_new_isa_superset",
-        Query_implicit_new_isa_superset
+        "defer_set_same_name",
+        Lookup_defer_set_same_name
     },
     {
-        "isa_superset",
-        Query_isa_superset
+        "lookup_invalid_digit",
+        Lookup_lookup_invalid_digit
     },
     {
-        "isa_superset_2_lvls",
-        Query_isa_superset_2_lvls
+        "lookup_child_invalid_digit",
+        Lookup_lookup_child_invalid_digit
     },
     {
-        "isa_superset_3_lvls",
-        Query_isa_superset_3_lvls
+        "lookup_digit_from_wrong_scope",
+        Lookup_lookup_digit_from_wrong_scope
     },
     {
-        "isa_superset_2_lvls_owned",
-        Query_isa_superset_2_lvls_owned
+        "lookup_core_entity_from_wrong_scope",
+        Lookup_lookup_core_entity_from_wrong_scope
     },
     {
-        "isa_superset_3_lvls_owned",
-        Query_isa_superset_3_lvls_owned
+        "lookup_alias_w_number",
+        Lookup_lookup_alias_w_number
     },
     {
-        "isa_superset_owned_empty_table_after_match",
-        Query_isa_superset_owned_empty_table_after_match
-    },
+        "lookup_symbol_path",
+        Lookup_lookup_symbol_path
+    }
+};
+
+bake_test_case Singleton_testcases[] = {
     {
-        "isa_self_superset",
-        Query_isa_self_superset
+        "add_singleton",
+        Singleton_add_singleton
     },
     {
-        "childof_superset",
-        Query_childof_superset
+        "remove_singleton",
+        Singleton_remove_singleton
     },
     {
-        "superset_2_targets",
-        Query_superset_2_targets
+        "set_get_singleton",
+        Singleton_set_get_singleton
     },
     {
-        "superset_2_relations",
-        Query_superset_2_relations
+        "ensure_singleton",
+        Singleton_ensure_singleton
     },
     {
-        "superset_2_relations_instanced",
-        Query_superset_2_relations_instanced
-    },
+        "singleton_system",
+        Singleton_singleton_system
+    }
+};
+
+bake_test_case Clone_testcases[] = {
     {
-        "superset_2_relations_w_component",
-        Query_superset_2_relations_w_component
+        "empty",
+        Clone_empty
     },
     {
-        "superset_2_relations_instanced_w_component",
-        Query_superset_2_relations_instanced_w_component
+        "empty_w_value",
+        Clone_empty_w_value
     },
     {
-        "parent",
-        Query_parent
+        "null",
+        Clone_null
     },
     {
-        "existing_isa_cascade",
-        Query_existing_isa_cascade
+        "null_w_value",
+        Clone_null_w_value
     },
     {
-        "new_isa_cascade",
-        Query_new_isa_cascade
+        "1_component",
+        Clone_1_component
     },
     {
-        "childof_cascade",
-        Query_childof_cascade
+        "2_component",
+        Clone_2_component
     },
     {
-        "isa_rematch",
-        Query_isa_rematch
+        "1_component_w_value",
+        Clone_1_component_w_value
     },
     {
-        "childof_rematch",
-        Query_childof_rematch
+        "2_component_w_value",
+        Clone_2_component_w_value
     },
     {
-        "isa_unmatch",
-        Query_isa_unmatch
+        "3_component",
+        Clone_3_component
     },
     {
-        "childof_unmatch",
-        Query_childof_unmatch
+        "3_component_w_value",
+        Clone_3_component_w_value
     },
     {
-        "isa_rematch_2_lvls",
-        Query_isa_rematch_2_lvls
+        "tag",
+        Clone_tag
     },
     {
-        "childof_rematch_2_lvls",
-        Query_childof_rematch_2_lvls
+        "tag_w_value",
+        Clone_tag_w_value
     },
     {
-        "cascade_rematch_2_lvls",
-        Query_cascade_rematch_2_lvls
+        "1_tag_1_component",
+        Clone_1_tag_1_component
     },
     {
-        "cascade_rematch_2_lvls_2_relations",
-        Query_cascade_rematch_2_lvls_2_relations
+        "1_tag_1_component_w_value",
+        Clone_1_tag_1_component_w_value
     },
     {
-        "cascade_topological",
-        Query_cascade_topological
-    },
+        "clone_w_name",
+        Clone_clone_w_name
+    }
+};
+
+bake_test_case ComponentLifecycle_testcases[] = {
     {
-        "cascade_desc_rematch_2_lvls",
-        Query_cascade_desc_rematch_2_lvls
+        "ctor_on_add",
+        ComponentLifecycle_ctor_on_add
     },
     {
-        "cascade_desc_rematch_2_lvls_2_relations",
-        Query_cascade_desc_rematch_2_lvls_2_relations
+        "ctor_on_new",
+        ComponentLifecycle_ctor_on_new
     },
     {
-        "cascade_desc_topological",
-        Query_cascade_desc_topological
+        "dtor_on_remove",
+        ComponentLifecycle_dtor_on_remove
     },
     {
-        "childof_rematch_from_isa",
-        Query_childof_rematch_from_isa
+        "dtor_on_delete",
+        ComponentLifecycle_dtor_on_delete
     },
     {
-        "rematch_optional_ref",
-        Query_rematch_optional_ref
+        "copy_on_set",
+        ComponentLifecycle_copy_on_set
     },
     {
-        "rematch_optional_ref_w_2_refs",
-        Query_rematch_optional_ref_w_2_refs
+        "copy_on_override",
+        ComponentLifecycle_copy_on_override
     },
     {
-        "rematch_optional_ref_tag_w_ref_component",
-        Query_rematch_optional_ref_tag_w_ref_component
+        "copy_on_clone",
+        ComponentLifecycle_copy_on_clone
     },
     {
-        "match_query_expr_from_scope",
-        Query_match_query_expr_from_scope
+        "no_copy_on_move",
+        ComponentLifecycle_no_copy_on_move
     },
     {
-        "query_long_or_w_ref",
-        Query_query_long_or_w_ref
+        "ctor_on_tag",
+        ComponentLifecycle_ctor_on_tag
     },
     {
-        "0_query",
-        Query_0_query
+        "dtor_on_tag",
+        ComponentLifecycle_dtor_on_tag
     },
     {
-        "query_w_pair_id_and_subj",
-        Query_query_w_pair_id_and_subj
+        "copy_on_tag",
+        ComponentLifecycle_copy_on_tag
     },
     {
-        "table_count",
-        Query_table_count
+        "move_on_tag",
+        ComponentLifecycle_move_on_tag
     },
     {
-        "empty_table_count",
-        Query_empty_table_count
+        "merge_to_different_table",
+        ComponentLifecycle_merge_to_different_table
     },
     {
-        "entity_count",
-        Query_entity_count
+        "merge_to_new_table",
+        ComponentLifecycle_merge_to_new_table
     },
     {
-        "rematch_after_delete_inherited_tag",
-        Query_rematch_after_delete_inherited_tag
+        "delete_in_stage",
+        ComponentLifecycle_delete_in_stage
     },
     {
-        "rematch_after_delete_rel_of_inherited_pair",
-        Query_rematch_after_delete_rel_of_inherited_pair
+        "ctor_on_add_pair",
+        ComponentLifecycle_ctor_on_add_pair
     },
     {
-        "rematch_after_delete_obj_of_inherited_pair",
-        Query_rematch_after_delete_obj_of_inherited_pair
+        "ctor_on_add_pair_tag",
+        ComponentLifecycle_ctor_on_add_pair_tag
     },
     {
-        "rematch_empty_table_w_superset",
-        Query_rematch_empty_table_w_superset
+        "ctor_on_move_pair",
+        ComponentLifecycle_ctor_on_move_pair
     },
     {
-        "query_w_short_notation",
-        Query_query_w_short_notation
+        "move_on_realloc",
+        ComponentLifecycle_move_on_realloc
     },
     {
-        "query_w_invalid_filter_flag",
-        Query_query_w_invalid_filter_flag
+        "move_on_bulk_new",
+        ComponentLifecycle_move_on_bulk_new
     },
     {
-        "query_next_table",
-        Query_query_next_table
+        "on_add_on_bulk_new",
+        ComponentLifecycle_on_add_on_bulk_new
     },
     {
-        "query_next_table_w_changed",
-        Query_query_next_table_w_changed
+        "move_on_delete",
+        ComponentLifecycle_move_on_delete
     },
     {
-        "query_next_table_w_populate",
-        Query_query_next_table_w_populate
+        "move_dtor_on_delete",
+        ComponentLifecycle_move_dtor_on_delete
     },
     {
-        "query_next_table_w_skip",
-        Query_query_next_table_w_skip
+        "copy_on_override_pair",
+        ComponentLifecycle_copy_on_override_pair
     },
     {
-        "query_next_table_w_populate_first_changed",
-        Query_query_next_table_w_populate_first_changed
+        "copy_on_override_pair_tag",
+        ComponentLifecycle_copy_on_override_pair_tag
     },
     {
-        "query_next_table_w_populate_last_changed",
-        Query_query_next_table_w_populate_last_changed
+        "copy_on_set_pair",
+        ComponentLifecycle_copy_on_set_pair
     },
     {
-        "query_next_table_w_populate_skip_first",
-        Query_query_next_table_w_populate_skip_first
+        "copy_on_set_pair_tag",
+        ComponentLifecycle_copy_on_set_pair_tag
     },
     {
-        "query_next_table_w_populate_skip_last",
-        Query_query_next_table_w_populate_skip_last
+        "allow_lifecycle_overwrite_equal_callbacks",
+        ComponentLifecycle_allow_lifecycle_overwrite_equal_callbacks
     },
     {
-        "create_query_existing_query_entity",
-        Query_create_query_existing_query_entity
+        "set_lifecycle_after_trigger",
+        ComponentLifecycle_set_lifecycle_after_trigger
     },
     {
-        "query_for_recycled_pair",
-        Query_query_for_recycled_pair
+        "valid_entity_in_dtor_after_delete",
+        ComponentLifecycle_valid_entity_in_dtor_after_delete
     },
     {
-        "query_w_singleton_w_rule_iter",
-        Query_query_w_singleton_w_rule_iter
+        "ctor_w_emplace",
+        ComponentLifecycle_ctor_w_emplace
     },
     {
-        "query_w_singleton_nested_iter",
-        Query_query_w_singleton_nested_iter
+        "ctor_w_emplace_defer",
+        ComponentLifecycle_ctor_w_emplace_defer
     },
     {
-        "query_w_singleton_interleaved_iter",
-        Query_query_w_singleton_interleaved_iter
+        "ctor_w_emplace_defer_use_move_ctor",
+        ComponentLifecycle_ctor_w_emplace_defer_use_move_ctor
     },
     {
-        "recycled_component_id",
-        Query_recycled_component_id
+        "ctor_w_emplace_defer_twice",
+        ComponentLifecycle_ctor_w_emplace_defer_twice
     },
     {
-        "set_get_context",
-        Query_set_get_context
+        "ctor_w_emplace_defer_existing",
+        ComponentLifecycle_ctor_w_emplace_defer_existing
     },
     {
-        "set_get_binding_context",
-        Query_set_get_binding_context
+        "on_add_w_emplace",
+        ComponentLifecycle_on_add_w_emplace
     },
     {
-        "set_get_context_w_free",
-        Query_set_get_context_w_free
+        "on_add_w_emplace_existing",
+        ComponentLifecycle_on_add_w_emplace_existing
     },
     {
-        "set_get_binding_context_w_free",
-        Query_set_get_binding_context_w_free
+        "on_add_w_emplace_defer",
+        ComponentLifecycle_on_add_w_emplace_defer
     },
     {
-        "set_this",
-        Query_set_this
+        "merge_async_stage_w_emplace",
+        ComponentLifecycle_merge_async_stage_w_emplace
     },
     {
-        "set_this_no_match",
-        Query_set_this_no_match
+        "merge_async_stage_w_emplace_to_deferred_world",
+        ComponentLifecycle_merge_async_stage_w_emplace_to_deferred_world
     },
     {
-        "set_this_is_true",
-        Query_set_this_is_true
+        "emplace_grow_w_existing_component",
+        ComponentLifecycle_emplace_grow_w_existing_component
     },
     {
-        "set_this_w_wildcard",
-        Query_set_this_w_wildcard
+        "dtor_on_fini",
+        ComponentLifecycle_dtor_on_fini
     },
     {
-        "singleton_w_inout_none",
-        Query_singleton_w_inout_none
+        "valid_type_in_dtor_on_fini",
+        ComponentLifecycle_valid_type_in_dtor_on_fini
     },
     {
-        "singleton_w_inout_none_or",
-        Query_singleton_w_inout_none_or
+        "valid_other_type_of_entity_in_dtor_on_fini",
+        ComponentLifecycle_valid_other_type_of_entity_in_dtor_on_fini
     },
     {
-        "component_w_inout_none_or",
-        Query_component_w_inout_none_or
-    }
-};
-
-bake_test_case Iter_testcases[] = {
-    {
-        "page_iter_0_0",
-        Iter_page_iter_0_0
+        "delete_in_dtor_other_type_on_fini",
+        ComponentLifecycle_delete_in_dtor_other_type_on_fini
     },
     {
-        "page_iter_1_0",
-        Iter_page_iter_1_0
+        "delete_in_dtor_other_type_on_delete_parent",
+        ComponentLifecycle_delete_in_dtor_other_type_on_delete_parent
     },
     {
-        "page_iter_0_1",
-        Iter_page_iter_0_1
+        "delete_in_dtor_other_type_on_delete",
+        ComponentLifecycle_delete_in_dtor_other_type_on_delete
     },
     {
-        "page_iter_n_0",
-        Iter_page_iter_n_0
+        "delete_self_in_dtor_on_delete",
+        ComponentLifecycle_delete_self_in_dtor_on_delete
     },
     {
-        "page_iter_0_n",
-        Iter_page_iter_0_n
+        "on_set_after_set",
+        ComponentLifecycle_on_set_after_set
     },
     {
-        "page_iter_m_n",
-        Iter_page_iter_m_n
+        "on_add_after_new",
+        ComponentLifecycle_on_add_after_new
     },
     {
-        "page_iter_skip_1_table",
-        Iter_page_iter_skip_1_table
+        "on_add_after_add",
+        ComponentLifecycle_on_add_after_add
     },
     {
-        "page_iter_skip_2_tables",
-        Iter_page_iter_skip_2_tables
+        "on_add_after_set",
+        ComponentLifecycle_on_add_after_set
     },
     {
-        "worker_iter_1",
-        Iter_worker_iter_1
+        "on_remove_after_remove",
+        ComponentLifecycle_on_remove_after_remove
     },
     {
-        "worker_iter_2",
-        Iter_worker_iter_2
+        "on_remove_after_clear",
+        ComponentLifecycle_on_remove_after_clear
     },
     {
-        "worker_iter_3",
-        Iter_worker_iter_3
+        "on_remove_after_delete",
+        ComponentLifecycle_on_remove_after_delete
     },
     {
-        "worker_iter_4",
-        Iter_worker_iter_4
+        "free_component_new_id_while_fini",
+        ComponentLifecycle_free_component_new_id_while_fini
     },
     {
-        "paged_iter_w_shared_comp",
-        Iter_paged_iter_w_shared_comp
+        "dtor_component_new_id_while_fini",
+        ComponentLifecycle_dtor_component_new_id_while_fini
     },
-    {
-        "worker_iter_w_shared_comp",
-        Iter_worker_iter_w_shared_comp
+    {
+        "free_component_new_pair_id_while_fini",
+        ComponentLifecycle_free_component_new_pair_id_while_fini
     },
     {
-        "paged_iter_w_task_query",
-        Iter_paged_iter_w_task_query
+        "dtor_component_new_pair_id_while_fini",
+        ComponentLifecycle_dtor_component_new_pair_id_while_fini
     },
     {
-        "worker_iter_w_task_query",
-        Iter_worker_iter_w_task_query
+        "free_component_new_obj_pair_id_while_fini",
+        ComponentLifecycle_free_component_new_obj_pair_id_while_fini
     },
     {
-        "worker_iter_w_singleton",
-        Iter_worker_iter_w_singleton
+        "dtor_component_new_obj_pair_id_while_fini",
+        ComponentLifecycle_dtor_component_new_obj_pair_id_while_fini
     },
     {
-        "worker_iter_w_singleton_component",
-        Iter_worker_iter_w_singleton_component
+        "ctor_move_dtor_after_resize",
+        ComponentLifecycle_ctor_move_dtor_after_resize
     },
     {
-        "worker_iter_w_singleton_instanced",
-        Iter_worker_iter_w_singleton_instanced
+        "ctx_free",
+        ComponentLifecycle_ctx_free
     },
     {
-        "worker_iter_w_singleton_component_instanced",
-        Iter_worker_iter_w_singleton_component_instanced
+        "binding_ctx_free",
+        ComponentLifecycle_binding_ctx_free
     },
     {
-        "paged_iter_w_singleton",
-        Iter_paged_iter_w_singleton
+        "ctx_free_after_delete_component",
+        ComponentLifecycle_ctx_free_after_delete_component
     },
     {
-        "paged_iter_w_singleton_component",
-        Iter_paged_iter_w_singleton_component
+        "binding_ctx_free_after_delete_component",
+        ComponentLifecycle_binding_ctx_free_after_delete_component
     },
     {
-        "paged_iter_w_singleton_instanced",
-        Iter_paged_iter_w_singleton_instanced
+        "on_add_ctx",
+        ComponentLifecycle_on_add_ctx
     },
     {
-        "paged_iter_w_singleton_component_instanced",
-        Iter_paged_iter_w_singleton_component_instanced
+        "on_remove_ctx",
+        ComponentLifecycle_on_remove_ctx
     },
     {
-        "count",
-        Iter_count
+        "on_set_ctx",
+        ComponentLifecycle_on_set_ctx
     },
     {
-        "iter_restore_stack_iter",
-        Iter_iter_restore_stack_iter
+        "on_add_w_existing_component",
+        ComponentLifecycle_on_add_w_existing_component
     },
     {
-        "interleaved_iter",
-        Iter_interleaved_iter
+        "on_remove_w_existing_component",
+        ComponentLifecycle_on_remove_w_existing_component
     },
     {
-        "get_first",
-        Iter_get_first
+        "component_init_set_hooks",
+        ComponentLifecycle_component_init_set_hooks
     },
     {
-        "page_iter_w_only_tag",
-        Iter_page_iter_w_only_tag
+        "component_init_name_from_type_info",
+        ComponentLifecycle_component_init_name_from_type_info
     },
     {
-        "worker_iter_w_only_tag",
-        Iter_worker_iter_w_only_tag
+        "component_init_scoped_name_from_type_info",
+        ComponentLifecycle_component_init_scoped_name_from_type_info
     },
     {
-        "page_iter_w_inout_none",
-        Iter_page_iter_w_inout_none
+        "component_init_w_recycled_id",
+        ComponentLifecycle_component_init_w_recycled_id
     },
     {
-        "worker_iter_w_inout_none",
-        Iter_worker_iter_w_inout_none
+        "component_init_w_recycled_non_component_id",
+        ComponentLifecycle_component_init_w_recycled_non_component_id
     },
     {
-        "page_iter_w_ctx",
-        Iter_page_iter_w_ctx
+        "on_add_after_ctor_w_add",
+        ComponentLifecycle_on_add_after_ctor_w_add
     },
     {
-        "page_iter_w_binding_ctx",
-        Iter_page_iter_w_binding_ctx
+        "on_add_after_ctor_w_add_to",
+        ComponentLifecycle_on_add_after_ctor_w_add_to
     },
     {
-        "worker_iter_w_ctx",
-        Iter_worker_iter_w_ctx
+        "with_before_hooks",
+        ComponentLifecycle_with_before_hooks
     },
     {
-        "worker_iter_w_binding_ctx",
-        Iter_worker_iter_w_binding_ctx
+        "with_component_on_add",
+        ComponentLifecycle_with_component_on_add
     },
     {
-        "column_index_owned",
-        Iter_column_index_owned
+        "move_ctor_on_move",
+        ComponentLifecycle_move_ctor_on_move
     },
     {
-        "column_index_shared",
-        Iter_column_index_shared
+        "ptr_to_self",
+        ComponentLifecycle_ptr_to_self
     },
     {
-        "column_index_not",
-        Iter_column_index_not
+        "ctor_move_dtor_from_move_ctor",
+        ComponentLifecycle_ctor_move_dtor_from_move_ctor
     },
     {
-        "page_iter_w_fini",
-        Iter_page_iter_w_fini
+        "on_add_hook_check_offset",
+        ComponentLifecycle_on_add_hook_check_offset
     },
     {
-        "worker_iter_w_fini",
-        Iter_worker_iter_w_fini
+        "on_remove_hook_check_offset",
+        ComponentLifecycle_on_remove_hook_check_offset
     },
     {
-        "rule_page_iter_w_fini",
-        Iter_rule_page_iter_w_fini
+        "on_set_hook_check_offset",
+        ComponentLifecycle_on_set_hook_check_offset
     },
     {
-        "rule_worker_iter_w_fini",
-        Iter_rule_worker_iter_w_fini
+        "on_set_hook_on_override",
+        ComponentLifecycle_on_set_hook_on_override
     },
     {
-        "to_str_before_next",
-        Iter_to_str_before_next
+        "on_set_hook_on_auto_override",
+        ComponentLifecycle_on_set_hook_on_auto_override
     },
     {
-        "to_str",
-        Iter_to_str
+        "batched_set_new_component_w_lifecycle",
+        ComponentLifecycle_batched_set_new_component_w_lifecycle
     },
     {
-        "filter_eval_count",
-        Iter_filter_eval_count
+        "batched_ensure_new_component_w_lifecycle",
+        ComponentLifecycle_batched_ensure_new_component_w_lifecycle
     },
     {
-        "query_eval_count",
-        Iter_query_eval_count
+        "on_nested_prefab_copy_test_invokes_copy_count",
+        ComponentLifecycle_on_nested_prefab_copy_test_invokes_copy_count
     },
     {
-        "rule_eval_count",
-        Iter_rule_eval_count
+        "no_move_no_move_ctor_with_move_dtor_with_ctor_move_dtor",
+        ComponentLifecycle_no_move_no_move_ctor_with_move_dtor_with_ctor_move_dtor
     }
 };
 
@@ -10435,10 +6475,6 @@ bake_test_case Trigger_testcases[] = {
     {
         "on_set_superset_after_filter_observer_w_on_add_2",
         Trigger_on_set_superset_after_filter_observer_w_on_add_2
-    },
-    {
-        "propagate_w_union_pair",
-        Trigger_propagate_w_union_pair
     }
 };
 
@@ -10647,6 +6683,22 @@ bake_test_case Observer_testcases[] = {
         "or_from",
         Observer_or_from
     },
+    {
+        "and_from_empty",
+        Observer_and_from_empty
+    },
+    {
+        "or_from_empty",
+        Observer_or_from_empty
+    },
+    {
+        "and_from_empty_w_tag",
+        Observer_and_from_empty_w_tag
+    },
+    {
+        "or_from_empty_w_tag",
+        Observer_or_from_empty_w_tag
+    },
     {
         "notify_propagated_twice",
         Observer_notify_propagated_twice
@@ -10991,6 +7043,10 @@ bake_test_case Observer_testcases[] = {
         "yield_existing_multi_no_this",
         Observer_yield_existing_multi_no_this
     },
+    {
+        "observer_no_id_in_scope",
+        Observer_observer_no_id_in_scope
+    },
     {
         "cache_test_1",
         Observer_cache_test_1
@@ -11359,10 +7415,6 @@ bake_test_case TriggerOnSet_testcases[] = {
         "on_set_after_override_1_of_2_overridden",
         TriggerOnSet_on_set_after_override_1_of_2_overridden
     },
-    {
-        "on_set_after_snapshot_restore",
-        TriggerOnSet_on_set_after_snapshot_restore
-    },
     {
         "on_set_after_remove_override",
         TriggerOnSet_on_set_after_remove_override
@@ -11861,10 +7913,6 @@ bake_test_case Prefab_testcases[] = {
         "override_dont_inherit",
         Prefab_override_dont_inherit
     },
-    {
-        "prefab_w_switch",
-        Prefab_prefab_w_switch
-    },
     {
         "prefab_child_w_dont_inherit_component",
         Prefab_prefab_child_w_dont_inherit_component
@@ -11925,10 +7973,6 @@ bake_test_case Prefab_testcases[] = {
         "base_slot_override",
         Prefab_base_slot_override
     },
-    {
-        "prefab_child_w_union",
-        Prefab_prefab_child_w_union
-    },
     {
         "override_twice_w_add",
         Prefab_override_twice_w_add
@@ -12298,10 +8342,6 @@ bake_test_case Type_testcases[] = {
         "entity_pair_str",
         Type_entity_pair_str
     },
-    {
-        "entity_and_str",
-        Type_entity_and_str
-    },
     {
         "entity_str_small_buffer",
         Type_entity_str_small_buffer
@@ -12310,10 +8350,6 @@ bake_test_case Type_testcases[] = {
         "role_pair_str",
         Type_role_pair_str
     },
-    {
-        "role_and_str",
-        Type_role_and_str
-    },
     {
         "role_owned_str",
         Type_role_owned_str
@@ -12541,18 +8577,10 @@ bake_test_case Commands_testcases[] = {
         "async_stage_new",
         Commands_async_stage_new
     },
-    {
-        "async_stage_no_get",
-        Commands_async_stage_no_get
-    },
     {
         "async_stage_readonly",
         Commands_async_stage_readonly
     },
-    {
-        "async_stage_is_async",
-        Commands_async_stage_is_async
-    },
     {
         "register_component_while_in_progress",
         Commands_register_component_while_in_progress
@@ -12621,22 +8649,6 @@ bake_test_case Commands_testcases[] = {
         "defer_while_suspend_readonly_w_existing_commands",
         Commands_defer_while_suspend_readonly_w_existing_commands
     },
-    {
-        "defer_add_union_relationship",
-        Commands_defer_add_union_relationship
-    },
-    {
-        "defer_add_existing_union_relationship",
-        Commands_defer_add_existing_union_relationship
-    },
-    {
-        "defer_add_union_relationship_2_ops",
-        Commands_defer_add_union_relationship_2_ops
-    },
-    {
-        "defer_add_existing_union_relationship_2_ops",
-        Commands_defer_add_existing_union_relationship_2_ops
-    },
     {
         "defer_remove_after_set",
         Commands_defer_remove_after_set
@@ -12864,6 +8876,14 @@ bake_test_case Commands_testcases[] = {
     {
         "add_path_nested_to_created_deleted_parent_w_stage",
         Commands_add_path_nested_to_created_deleted_parent_w_stage
+    },
+    {
+        "defer_emplace_w_arg",
+        Commands_defer_emplace_w_arg
+    },
+    {
+        "defer_emplace_existing_w_arg",
+        Commands_defer_emplace_existing_w_arg
     }
 };
 
@@ -13112,10 +9132,6 @@ bake_test_case SingleThreadStaging_testcases[] = {
         "modify_after_lock",
         SingleThreadStaging_modify_after_lock
     },
-    {
-        "get_case_from_stage",
-        SingleThreadStaging_get_case_from_stage
-    },
     {
         "get_object_from_stage",
         SingleThreadStaging_get_object_from_stage
@@ -13261,38 +9277,6 @@ bake_test_case Table_testcases[] = {
 };
 
 bake_test_case Poly_testcases[] = {
-    {
-        "iter_query",
-        Poly_iter_query
-    },
-    {
-        "iter_query_w_filter",
-        Poly_iter_query_w_filter
-    },
-    {
-        "iter_world",
-        Poly_iter_world
-    },
-    {
-        "iter_world_w_filter",
-        Poly_iter_world_w_filter
-    },
-    {
-        "iter_rule",
-        Poly_iter_rule
-    },
-    {
-        "iter_rule_w_filter",
-        Poly_iter_rule_w_filter
-    },
-    {
-        "iter_filter",
-        Poly_iter_filter
-    },
-    {
-        "iter_filter_w_filter",
-        Poly_iter_filter_w_filter
-    },
     {
         "on_set_poly_observer",
         Poly_on_set_poly_observer
@@ -13304,30 +9288,6 @@ bake_test_case Poly_testcases[] = {
     {
         "on_set_poly_system",
         Poly_on_set_poly_system
-    },
-    {
-        "iter_filter_from_entity",
-        Poly_iter_filter_from_entity
-    },
-    {
-        "iter_query_from_entity",
-        Poly_iter_query_from_entity
-    },
-    {
-        "iter_rule_from_entity",
-        Poly_iter_rule_from_entity
-    },
-    {
-        "free_filter_entity",
-        Poly_free_filter_entity
-    },
-    {
-        "free_query_entity",
-        Poly_free_query_entity
-    },
-    {
-        "free_rule_entity",
-        Poly_free_rule_entity
     }
 };
 
@@ -13481,28 +9441,42 @@ static bake_test_suite suites[] = {
         "Entity",
         NULL,
         NULL,
-        106,
+        133,
         Entity_testcases
     },
+    {
+        "Each",
+        NULL,
+        NULL,
+        5,
+        Each_testcases
+    },
+    {
+        "Iter",
+        NULL,
+        NULL,
+        60,
+        Iter_testcases
+    },
     {
         "Search",
         NULL,
         NULL,
-        23,
+        20,
         Search_testcases
     },
     {
         "Event",
         NULL,
         NULL,
-        34,
+        35,
         Event_testcases
     },
     {
         "New",
         New_setup,
         NULL,
-        25,
+        24,
         New_testcases
     },
     {
@@ -13519,20 +9493,6 @@ static bake_test_suite suites[] = {
         26,
         Add_testcases
     },
-    {
-        "Switch",
-        NULL,
-        NULL,
-        47,
-        Switch_testcases
-    },
-    {
-        "EnabledComponents",
-        NULL,
-        NULL,
-        52,
-        EnabledComponents_testcases
-    },
     {
         "Remove",
         NULL,
@@ -13551,16 +9511,9 @@ static bake_test_suite suites[] = {
         "Hierarchies",
         Hierarchies_setup,
         NULL,
-        100,
+        93,
         Hierarchies_testcases
     },
-    {
-        "FixedHierarchies",
-        NULL,
-        NULL,
-        65,
-        FixedHierarchies_testcases
-    },
     {
         "Has",
         NULL,
@@ -13600,14 +9553,14 @@ static bake_test_suite suites[] = {
         "OnDelete",
         NULL,
         NULL,
-        116,
+        114,
         OnDelete_testcases
     },
     {
         "Set",
         NULL,
         NULL,
-        36,
+        37,
         Set_testcases
     },
     {
@@ -13642,51 +9595,9 @@ static bake_test_suite suites[] = {
         "ComponentLifecycle",
         ComponentLifecycle_setup,
         NULL,
-        91,
+        92,
         ComponentLifecycle_testcases
     },
-    {
-        "Sorting",
-        NULL,
-        NULL,
-        38,
-        Sorting_testcases
-    },
-    {
-        "SortingEntireTable",
-        NULL,
-        NULL,
-        34,
-        SortingEntireTable_testcases
-    },
-    {
-        "Filter",
-        NULL,
-        NULL,
-        307,
-        Filter_testcases
-    },
-    {
-        "FilterStr",
-        NULL,
-        NULL,
-        29,
-        FilterStr_testcases
-    },
-    {
-        "Query",
-        NULL,
-        NULL,
-        243,
-        Query_testcases
-    },
-    {
-        "Iter",
-        NULL,
-        NULL,
-        48,
-        Iter_testcases
-    },
     {
         "Pairs",
         NULL,
@@ -13698,14 +9609,14 @@ static bake_test_suite suites[] = {
         "Trigger",
         NULL,
         NULL,
-        118,
+        117,
         Trigger_testcases
     },
     {
         "Observer",
         NULL,
         NULL,
-        153,
+        158,
         Observer_testcases
     },
     {
@@ -13733,7 +9644,7 @@ static bake_test_suite suites[] = {
         "TriggerOnSet",
         NULL,
         NULL,
-        16,
+        15,
         TriggerOnSet_testcases
     },
     {
@@ -13747,7 +9658,7 @@ static bake_test_suite suites[] = {
         "Prefab",
         Prefab_setup,
         NULL,
-        129,
+        127,
         Prefab_testcases
     },
     {
@@ -13768,21 +9679,21 @@ static bake_test_suite suites[] = {
         "Type",
         Type_setup,
         NULL,
-        25,
+        23,
         Type_testcases
     },
     {
         "Commands",
         NULL,
         NULL,
-        133,
+        129,
         Commands_testcases
     },
     {
         "SingleThreadStaging",
         SingleThreadStaging_setup,
         NULL,
-        68,
+        67,
         SingleThreadStaging_testcases
     },
     {
@@ -13803,7 +9714,7 @@ static bake_test_suite suites[] = {
         "Poly",
         NULL,
         NULL,
-        17,
+        3,
         Poly_testcases
     },
     {
@@ -13830,5 +9741,5 @@ static bake_test_suite suites[] = {
 };
 
 int main(int argc, char *argv[]) {
-    return bake_test_run("api", argc, argv, suites, 51);
+    return bake_test_run("core", argc, argv, suites, 44);
 }
diff --git a/test/core/src/util.c b/test/core/src/util.c
new file mode 100644
index 000000000..499e7e067
--- /dev/null
+++ b/test/core/src/util.c
@@ -0,0 +1,93 @@
+#include <core.h>
+#include <stdio.h>
+
+void probe_system_w_ctx(
+    ecs_iter_t *it,
+    Probe *ctx) 
+{
+    if (!ctx) {
+        return;
+    }
+
+    ctx->param = it->param;
+    ctx->system = it->system;
+    ctx->event = it->event;
+    ctx->event_id = it->event_id;
+    ctx->offset = 0;
+    ctx->term_count = it->field_count;
+    ctx->term_index = it->term_index;
+
+    int i;
+    for (i = 0; i < ctx->term_count; i ++) {
+        ctx->c[ctx->invoked][i] = it->ids[i];
+        ctx->s[ctx->invoked][i] = ecs_field_src(it, i);
+
+        ecs_id_t field_id = ecs_field_id(it, i);
+        test_assert(field_id != 0);
+    }
+
+    for (i = 0; i < it->count; i ++) {
+        if (i + ctx->count < 256) {
+            ctx->e[i + ctx->count] = it->entities[i];
+        } else {
+            /* can't store more than that, tests shouldn't rely on
+                * getting back more than 256 results */
+        }
+    }
+    ctx->count += it->count;
+
+    ctx->invoked ++;
+}
+
+void probe_iter(
+    ecs_iter_t *it) 
+{
+    Probe *ctx = ecs_get_ctx(it->world);
+    if (!ctx) {
+        ctx = it->ctx;
+    }
+    probe_system_w_ctx(it, ctx);
+}
+
+void probe_has_entity(Probe *probe, ecs_entity_t e) {
+    int i;
+    for (i = 0; i < probe->count; i ++) {
+        if (probe->e[i] == e) {
+            break;
+        }
+    }
+
+    test_assert(i != probe->count);
+}
+
+void install_test_abort(void) {
+    ecs_os_set_api_defaults();
+    ecs_os_api_t os_api = ecs_os_get_api();
+    os_api.abort_ = test_abort;
+    ecs_os_set_api(&os_api);
+    ecs_log_set_level(-5);
+}
+
+const ecs_entity_t* bulk_new_w_type(
+    ecs_world_t *world, ecs_entity_t type_ent, int32_t count) 
+{
+    const ecs_type_t *type = ecs_get_type(world, type_ent);
+    test_assert(type != NULL);
+
+    ecs_id_t *ids = type->array;
+    int i = 0;
+    while ((ecs_id_get_flags(world, ids[i]) & EcsIdDontInherit)) {
+        i ++;
+    }
+    const ecs_entity_t *result = ecs_bulk_new_w_id(world, ids[i], count);
+    for (; i < type->count; i ++) {
+        for (int e = 0; e < count; e ++) {
+            if (ecs_id_get_flags(world, ids[i]) & EcsIdDontInherit) {
+                continue;
+            }
+            ecs_add_id(world, result[e], ids[i]);
+        }
+    }
+    
+    return result;
+}
diff --git a/test/cpp_api/include/cpp_api.h b/test/cpp/include/cpp.h
similarity index 99%
rename from test/cpp_api/include/cpp_api.h
rename to test/cpp/include/cpp.h
index 097b15795..a97807583 100644
--- a/test/cpp_api/include/cpp_api.h
+++ b/test/cpp/include/cpp.h
@@ -1,8 +1,8 @@
-#ifndef CPP_API_H
-#define CPP_API_H
+#ifndef CPP_H
+#define CPP_H
 
 /* This generated file contains includes for project dependencies */
-#include <cpp_api/bake_config.h>
+#include <cpp/bake_config.h>
 #include <string>
 #include <vector>
 
diff --git a/test/api/include/api/bake_config.h b/test/cpp/include/cpp/bake_config.h
similarity index 93%
rename from test/api/include/api/bake_config.h
rename to test/cpp/include/cpp/bake_config.h
index 45462eccd..7d5292dc1 100644
--- a/test/api/include/api/bake_config.h
+++ b/test/cpp/include/cpp/bake_config.h
@@ -14,8 +14,8 @@
  * dependencies will automatically show up in this file. Include bake_config.h
  * in your main project file. Do not edit! */
 
-#ifndef API_BAKE_CONFIG_H
-#define API_BAKE_CONFIG_H
+#ifndef CPP_BAKE_CONFIG_H
+#define CPP_BAKE_CONFIG_H
 
 /* Headers of public dependencies */
 #include <flecs.h>
diff --git a/test/cpp_api/project.json b/test/cpp/project.json
similarity index 92%
rename from test/cpp_api/project.json
rename to test/cpp/project.json
index faca81f50..a9d4df475 100644
--- a/test/cpp_api/project.json
+++ b/test/cpp/project.json
@@ -1,5 +1,5 @@
 {
-    "id": "cpp_api",
+    "id": "cpp",
     "type": "application",
     "value": {
         "author": "Sander Mertens",
@@ -273,7 +273,11 @@
                 "emplace_w_observer",
                 "scoped_world",
                 "entity_lookup_not_recursive",
-                "world_lookup_not_recursive"
+                "world_lookup_not_recursive",
+                "world_lookup_custom_sep",
+                "world_lookup_custom_root_sep",
+                "depends_on",
+                "depends_on_type"
             ]
         }, {
             "id": "Pairs",
@@ -389,20 +393,6 @@
                 "enum_class_mixed_auto_manual_constants",
                 "enum_child_count"
             ]
-        }, {
-            "id": "Switch",
-            "testcases": [
-                "add_case",
-                "get_case",
-                "system_w_case",
-                "system_w_case_builder",
-                "system_w_sw_type_builder",
-                "system_w_switch",
-                "add_case_w_type",
-                "add_switch_w_type",
-                "add_remove_switch_w_type",
-                "switch_enum_type"
-            ]
         }, {
             "id": "Paths",
             "testcases": [
@@ -542,6 +532,18 @@
         }, {
             "id": "Query",
             "testcases": [
+                "term_each_component",
+                "term_each_tag",
+                "term_each_id",
+                "term_each_pair_type",
+                "term_each_pair_id",
+                "term_each_pair_relation_wildcard",
+                "term_each_pair_object_wildcard",
+                "term_get_id",
+                "term_get_subj",
+                "term_get_pred",
+                "term_get_obj",
+                "set_this_var",
                 "action",
                 "action_const",
                 "action_shared",
@@ -554,14 +556,11 @@
                 "signature_const",
                 "signature_shared",
                 "signature_optional",
-                "subquery",
-                "subquery_w_expr",
                 "query_single_pair",
                 "tag_w_each",
                 "shared_tag_w_each",
                 "sort_by",
                 "changed",
-                "orphaned",
                 "default_ctor",
                 "default_ctor_no_assign",
                 "expr_w_template",
@@ -633,83 +632,16 @@
                 "find",
                 "find_not_found",
                 "find_w_entity",
-                "optional_pair_term"
+                "optional_pair_term",
+                "query_from_entity",
+                "query_from_entity_name"
             ]
         }, {
             "id": "QueryBuilder",
-            "testcases": [
-                "builder_assign_same_type",
-                "builder_assign_from_empty",
-                "builder_assign_to_empty",
-                "builder_build",
-                "builder_build_to_auto",
-                "builder_build_n_statements",
-                "1_type",
-                "add_1_type",
-                "add_2_types",
-                "add_1_type_w_1_type",
-                "add_2_types_w_1_type",
-                "add_pair",
-                "add_not",
-                "add_or",
-                "add_optional",
-                "ptr_type",
-                "const_type",
-                "string_term",
-                "singleton_term",
-                "isa_superset_term",
-                "isa_self_superset_term",
-                "childof_superset_term",
-                "childof_self_superset_term",
-                "isa_superset_term_w_each",
-                "isa_self_superset_term_w_each",
-                "childof_superset_term_w_each",
-                "childof_self_superset_term_w_each",
-                "isa_superset_shortcut",
-                "isa_superset_shortcut_w_self",
-                "childof_superset_shortcut",
-                "childof_superset_shortcut_w_self",
-                "relation",
-                "relation_w_object_wildcard",
-                "relation_w_predicate_wildcard",
-                "add_pair_w_rel_type",
-                "template_term",
-                "explicit_subject_w_id",
-                "explicit_subject_w_type",
-                "explicit_object_w_id",
-                "explicit_object_w_type",
-                "explicit_term",
-                "explicit_term_w_type",
-                "explicit_term_w_pair_type",
-                "explicit_term_w_id",
-                "explicit_term_w_pair_id",
-                "1_term_to_empty",
-                "2_subsequent_args",
-                "optional_tag_is_set",
-                "10_terms",
-                "20_terms",
-                "group_by_raw",
-                "group_by_template",
-                "group_by_iter_one",
-                "group_by_iter_one_template",
-                "group_by_iter_one_all_groups",
-                "group_by_default_func_w_id",
-                "group_by_default_func_w_type",
-                "group_by_callbacks",
-                "create_w_no_template_args",
-                "any_wildcard",
-                "cascade",
-                "cascade_w_relationship",
-                "up_w_type",
-                "cascade_w_type",
-                "cascade_desc",
-                "named_query",
-                "term_w_write",
-                "term_w_read",
-                "iter_w_stage"
-            ]
-        }, {
-            "id": "FilterBuilder",
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "setup": true,
             "testcases": [
                 "builder_assign_same_type",
                 "builder_assign_from_empty",
@@ -719,6 +651,25 @@
                 "builder_build_n_statements",
                 "builder_force_assign_operator",
                 "1_type",
+                "2_types",
+                "id_term",
+                "type_term",
+                "id_pair_term",
+                "id_pair_wildcard_term",
+                "type_pair_term",
+                "pair_term_w_var",
+                "2_pair_terms_w_var",
+                "set_var",
+                "set_2_vars",
+                "set_var_by_name",
+                "set_2_vars_by_name",
+                "expr_w_var",
+                "set_var_on_query",
+                "set_var_by_name_on_query",
+                "set_table_var",
+                "set_range_var",
+                "set_table_var_chained",
+                "set_range_var_chained",
                 "add_1_type",
                 "add_2_types",
                 "add_1_type_w_1_type",
@@ -759,7 +710,6 @@
                 "explicit_term_w_pair_id",
                 "1_term_to_empty",
                 "2_subsequent_args",
-                "filter_as_arg",
                 "filter_as_move_arg",
                 "filter_as_return",
                 "filter_copy",
@@ -768,7 +718,7 @@
                 "world_each_filter_1_component_no_entity",
                 "world_each_filter_2_components_no_entity",
                 "10_terms",
-                "20_terms",
+                "16_terms",
                 "term_after_arg",
                 "name_arg",
                 "const_in_term",
@@ -823,29 +773,28 @@
                 "with_T_inout",
                 "with_R_T_inout",
                 "with_R_t_inout",
-                "with_r_t_inout"
-            ]
-        }, {
-            "id": "RuleBuilder",
-            "testcases": [
-                "1_type",
-                "2_types",
-                "id_term",
-                "type_term",
-                "id_pair_term",
-                "id_pair_wildcard_term",
-                "type_pair_term",
-                "pair_term_w_var",
-                "2_pair_terms_w_var",
-                "set_var",
-                "set_2_vars",
-                "set_var_by_name",
-                "set_2_vars_by_name",
-                "expr_w_var",
-                "get_first",
-                "get_count_direct",
-                "get_is_true_direct",
-                "get_first_direct",
+                "with_r_t_inout",
+                "optional_tag_is_set",
+                "group_by_raw",
+                "group_by_template",
+                "group_by_iter_one",
+                "group_by_iter_one_template",
+                "group_by_iter_one_all_groups",
+                "group_by_default_func_w_id",
+                "group_by_default_func_w_type",
+                "group_by_callbacks",
+                "set_group_on_query",
+                "set_group_type_on_query",
+                "create_w_no_template_args",
+                "any_wildcard",
+                "cascade",
+                "cascade_w_relationship",
+                "up_w_type",
+                "cascade_w_type",
+                "cascade_desc",
+                "named_query",
+                "term_w_write",
+                "term_w_read",
                 "var_src_w_prefixed_name",
                 "var_first_w_prefixed_name",
                 "var_second_w_prefixed_name",
@@ -855,12 +804,7 @@
                 "named_scoped_rule",
                 "is_valid",
                 "unresolved_by_name",
-                "scope",
-                "iter_w_stage",
-                "inspect_terms_w_expr",
-                "find",
-                "find_not_found",
-                "find_w_entity"
+                "scope"
             ]
         }, {
             "id": "SystemBuilder",
@@ -882,7 +826,7 @@
                 "string_term",
                 "singleton_term",
                 "10_terms",
-                "20_terms",
+                "16_terms",
                 "name_arg",
                 "create_w_no_template_args",
                 "write_annotation",
@@ -896,7 +840,7 @@
                 "2_terms_on_set",
                 "2_terms_un_set",
                 "10_terms",
-                "20_terms",
+                "16_terms",
                 "2_entities_iter",
                 "2_entities_table_column",
                 "2_entities_each",
@@ -924,37 +868,6 @@
                 "add_in_yield_existing_multi",
                 "name_from_root"
             ]
-        }, {
-            "id": "Filter",
-            "testcases": [
-                "term_each_component",
-                "term_each_tag",
-                "term_each_id",
-                "term_each_pair_type",
-                "term_each_pair_id",
-                "term_each_pair_relation_wildcard",
-                "term_each_pair_object_wildcard",
-                "default_ctor_no_assign",
-                "term_get_id",
-                "term_get_subj",
-                "term_get_pred",
-                "term_get_obj",
-                "get_first",
-                "get_count_direct",
-                "get_is_true_direct",
-                "get_first_direct",
-                "each_w_no_this",
-                "each_w_iter_no_this",
-                "invalid_each_w_no_this",
-                "named_filter",
-                "named_scoped_filter",
-                "set_this_var",
-                "inspect_terms_w_expr",
-                "find",
-                "find_not_found",
-                "find_w_entity",
-                "optional_pair_term"
-            ]
         }, {
             "id": "ComponentLifecycle",
             "testcases": [
@@ -1104,11 +1017,6 @@
                 "implicit_const_ref",
                 "vector_elem_type"
             ]
-        }, {
-            "id": "Snapshot",
-            "testcases": [
-                "simple_snapshot"
-            ]
         }, {
             "id": "WorldFactory",
             "testcases": [
@@ -1122,7 +1030,6 @@
                 "system_w_expr",
                 "query",
                 "query_w_expr",
-                "snapshot",
                 "module"
             ]
         }, {
@@ -1239,7 +1146,8 @@
                 "atfini",
                 "atfini_w_ctx",
                 "get_mut_T",
-                "get_mut_R_T"
+                "get_mut_R_T",
+                "copy_world"
             ]
         }, {
             "id": "Singleton",
diff --git a/test/cpp_api/src/ComponentLifecycle.cpp b/test/cpp/src/ComponentLifecycle.cpp
similarity index 99%
rename from test/cpp_api/src/ComponentLifecycle.cpp
rename to test/cpp/src/ComponentLifecycle.cpp
index 4087db435..9cc5f91a8 100644
--- a/test/cpp_api/src/ComponentLifecycle.cpp
+++ b/test/cpp/src/ComponentLifecycle.cpp
@@ -2,7 +2,7 @@
 #define flecs_static_assert(cond, str)\
     ecs_assert(cond, ECS_INVALID_OPERATION, str)
 
-#include <cpp_api.h>
+#include <cpp.h>
 
 int Pod::ctor_invoked = 0;
 int Pod::dtor_invoked = 0;
diff --git a/test/cpp_api/src/Doc.cpp b/test/cpp/src/Doc.cpp
similarity index 98%
rename from test/cpp_api/src/Doc.cpp
rename to test/cpp/src/Doc.cpp
index 9f2939630..1366f5f44 100644
--- a/test/cpp_api/src/Doc.cpp
+++ b/test/cpp/src/Doc.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void Doc_set_brief(void) {
     flecs::world ecs;
diff --git a/test/cpp_api/src/Entity.cpp b/test/cpp/src/Entity.cpp
similarity index 97%
rename from test/cpp_api/src/Entity.cpp
rename to test/cpp/src/Entity.cpp
index 4793f5bfa..2cfca2c92 100644
--- a/test/cpp_api/src/Entity.cpp
+++ b/test/cpp/src/Entity.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 struct Parent {
     struct EntityType { };
@@ -1301,6 +1301,8 @@ void Entity_get_parent(void) {
 void Entity_is_component_enabled(void) {
     flecs::world world;
 
+    world.component<Position>().add(flecs::CanToggle);
+
     auto e = world.entity()
         .add<Position>();
 
@@ -1310,6 +1312,8 @@ void Entity_is_component_enabled(void) {
 
 void Entity_is_enabled_component_enabled(void) {
     flecs::world world;
+    
+    world.component<Position>().add(flecs::CanToggle);
 
     auto e = world.entity()
         .add<Position>()
@@ -1321,6 +1325,8 @@ void Entity_is_enabled_component_enabled(void) {
 void Entity_is_disabled_component_enabled(void) {
     flecs::world world;
 
+    world.component<Position>().add(flecs::CanToggle);
+
     auto e = world.entity()
         .add<Position>()
         .disable<Position>();
@@ -1331,6 +1337,8 @@ void Entity_is_disabled_component_enabled(void) {
 void Entity_is_pair_enabled(void) {
     flecs::world world;
 
+    world.component<Position>().add(flecs::CanToggle);
+
     struct TgtA { };
     struct TgtB { };
 
@@ -1344,8 +1352,12 @@ void Entity_is_pair_enabled(void) {
 void Entity_is_enabled_pair_enabled(void) {
     flecs::world world;
 
+    world.component<Position>().add(flecs::CanToggle);
+
     struct Tgt { };
 
+    world.component<Position>().add(flecs::CanToggle);
+
     auto e = world.entity()
         .add<Position, Tgt>()
         .enable<Position, Tgt>();
@@ -1356,6 +1368,8 @@ void Entity_is_enabled_pair_enabled(void) {
 void Entity_is_disabled_pair_enabled(void) {
     flecs::world world;
 
+    world.component<Position>().add(flecs::CanToggle);
+
     struct Tgt { };
 
     auto e = world.entity()
@@ -1368,6 +1382,8 @@ void Entity_is_disabled_pair_enabled(void) {
 void Entity_is_pair_enabled_w_ids(void) {
     flecs::world world;
 
+    world.component<Position>().add(flecs::CanToggle);
+
     auto rel = world.entity();
     auto tgt_a = world.entity();
     auto tgt_b = world.entity();
@@ -1382,7 +1398,7 @@ void Entity_is_pair_enabled_w_ids(void) {
 void Entity_is_enabled_pair_enabled_w_ids(void) {
     flecs::world world;
 
-    auto rel = world.entity();
+    auto rel = world.entity().add(flecs::CanToggle);
     auto tgt = world.entity();
 
     auto e = world.entity()
@@ -1395,7 +1411,7 @@ void Entity_is_enabled_pair_enabled_w_ids(void) {
 void Entity_is_disabled_pair_enabled_w_ids(void) {
     flecs::world world;
 
-    auto rel = world.entity();
+    auto rel = world.entity().add(flecs::CanToggle);
     auto tgt = world.entity();
 
     auto e = world.entity()
@@ -1408,6 +1424,8 @@ void Entity_is_disabled_pair_enabled_w_ids(void) {
 void Entity_is_pair_enabled_w_tgt_id(void) {
     flecs::world world;
 
+    world.component<Position>().add(flecs::CanToggle);
+
     auto tgt_a = world.entity();
     auto tgt_b = world.entity();
 
@@ -1421,6 +1439,8 @@ void Entity_is_pair_enabled_w_tgt_id(void) {
 void Entity_is_enabled_pair_enabled_w_tgt_id(void) {
     flecs::world world;
 
+    world.component<Position>().add(flecs::CanToggle);
+
     auto tgt = world.entity();
 
     auto e = world.entity()
@@ -1433,6 +1453,8 @@ void Entity_is_enabled_pair_enabled_w_tgt_id(void) {
 void Entity_is_disabled_pair_enabled_w_tgt_id(void) {
     flecs::world world;
 
+    world.component<Position>().add(flecs::CanToggle);
+
     auto tgt = world.entity();
 
     auto e = world.entity()
@@ -2099,7 +2121,7 @@ void Entity_set_1_component_w_callback(void) {
     flecs::world ecs;
 
     auto e = ecs.entity()
-        .set([](Position& p){
+        .insert([](Position& p){
             p.x = 10;
             p.y = 20;
         });
@@ -2116,7 +2138,7 @@ void Entity_set_2_components_w_callback(void) {
     flecs::world ecs;
 
     auto e = ecs.entity()
-        .set([](Position& p, Velocity& v){
+        .insert([](Position& p, Velocity& v){
             p = {10, 20};
             v = {1, 2};
         });
@@ -2138,7 +2160,7 @@ void Entity_set_3_components_w_callback(void) {
     flecs::world ecs;
 
     auto e = ecs.entity()
-        .set([](Position& p, Velocity& v, Mass& m){
+        .insert([](Position& p, Velocity& v, Mass& m){
             p = {10, 20};
             v = {1, 2};
             m = {50};
@@ -2167,7 +2189,7 @@ void Entity_defer_set_1_component(void) {
     ecs.defer_begin();
 
     auto e = ecs.entity()
-        .set([](Position& p){
+        .insert([](Position& p){
             p.x = 10;
             p.y = 20;
         });
@@ -2190,7 +2212,7 @@ void Entity_defer_set_2_components(void) {
     ecs.defer_begin();
 
     auto e = ecs.entity()
-        .set([](Position& p, Velocity& v){
+        .insert([](Position& p, Velocity& v){
             p = {10, 20};
             v = {1, 2};
         });
@@ -2218,7 +2240,7 @@ void Entity_defer_set_3_components(void) {
     ecs.defer_begin();
 
     auto e = ecs.entity()
-        .set([](Position& p, Velocity& v, Mass& m){
+        .insert([](Position& p, Velocity& v, Mass& m){
             p = {10, 20};
             v = {1, 2};
             m = {50};
@@ -2268,7 +2290,7 @@ void Entity_set_2_w_on_set(void) {
         });
 
     auto e = ecs.entity()
-        .set([](Position& p, Velocity& v){
+        .insert([](Position& p, Velocity& v){
             p = {10, 20};
             v = {1, 2};
         });
@@ -2310,7 +2332,7 @@ void Entity_defer_set_2_w_on_set(void) {
     ecs.defer_begin();   
 
     auto e = ecs.entity()
-        .set([](Position& p, Velocity& v){
+        .insert([](Position& p, Velocity& v){
             p = {10, 20};
             v = {1, 2};
         });
@@ -2337,7 +2359,7 @@ void Entity_set_2_after_fluent(void) {
 
     auto e = ecs.entity()
         .set<Mass>({50})
-        .set([](Position& p, Velocity& v){
+        .insert([](Position& p, Velocity& v){
             p = {10, 20};
             v = {1, 2};
         });
@@ -2361,7 +2383,7 @@ void Entity_set_2_before_fluent(void) {
     flecs::world ecs;
 
     auto e = ecs.entity()
-        .set([](Position& p, Velocity& v){
+        .insert([](Position& p, Velocity& v){
             p = {10, 20};
             v = {1, 2};
         })
@@ -2396,7 +2418,7 @@ void Entity_set_2_after_set_1(void) {
     }), true);
 
     // Set both Position and Velocity
-    e.set([](Position& p, Velocity& v) {
+    e.insert([](Position& p, Velocity& v) {
         p = {10, 20};
         v = {1, 2};
     });
@@ -2438,7 +2460,7 @@ void Entity_set_2_after_set_2(void) {
     test_int(called, 1);
 
     // Set both Position and Velocity (doesn't add any components)
-    e.set([](Position& p, Velocity& v) {
+    e.insert([](Position& p, Velocity& v) {
         p = {10, 20};
         v = {3, 4};
     });
@@ -2471,7 +2493,9 @@ void Entity_with_self(void) {
     test_assert(!self.has(Tag));
 
     int count = 0;
-    auto q = ecs.query_builder<>().term(Tag).build();
+    auto q = ecs.query_builder<>()
+        .with(Tag)
+        .build();
 
     q.each([&](flecs::entity e) {
         test_assert(e.has(Tag));
@@ -2503,7 +2527,9 @@ void Entity_with_relation_type_self(void) {
     test_assert(!self.has<Likes>(Bob));
 
     int count = 0;
-    auto q = ecs.query_builder<>().term<Likes>(Bob).build();
+    auto q = ecs.query_builder<>()
+        .with<Likes>(Bob)
+        .build();
 
     q.each([&](flecs::entity e) {
         test_assert(e.has<Likes>(Bob));
@@ -2535,7 +2561,9 @@ void Entity_with_relation_self(void) {
     test_assert(!self.has(Likes, Bob));
 
     int count = 0;
-    auto q = ecs.query_builder<>().term(Likes, Bob).build();
+    auto q = ecs.query_builder<>()
+        .with(Likes, Bob)
+        .build();
 
     q.each([&](flecs::entity e) {
         test_assert(e.has(Likes, Bob));
@@ -2620,7 +2648,9 @@ void Entity_with_scope(void) {
     test_assert(!self.has(flecs::ChildOf, parent));
 
     int count = 0;
-    auto q = ecs.query_builder<>().term(flecs::ChildOf, parent).build();
+    auto q = ecs.query_builder<>()
+        .with(flecs::ChildOf, parent)
+        .build();
 
     q.each([&](flecs::entity e) {
         test_assert(e.has(flecs::ChildOf, parent));
@@ -4492,5 +4522,42 @@ void Entity_world_lookup_not_recursive(void) {
     flecs::entity foo = world.scope(parent).entity("foo");
 
     test_assert(world.scope(child).lookup("foo") == foo);
-    test_assert(world.scope(child).lookup("foo", false) == 0);
+    test_assert(world.scope(child).lookup("foo", "::", "::", false) == 0);
+}
+
+void Entity_world_lookup_custom_sep(void) {
+    flecs::world world;
+
+    flecs::entity parent = world.entity("parent");
+    flecs::entity child = world.scope(parent).entity("child");
+    flecs::entity foo = world.scope(parent).entity("foo");
+
+    test_assert(world.lookup("parent.child", ".") == child);
+    test_assert(world.lookup("parent.foo", ".") == foo);
+}
+
+void Entity_world_lookup_custom_root_sep(void) {
+    flecs::world world;
+
+    flecs::entity parent = world.entity("parent");
+    flecs::entity child = world.scope(parent).entity("child");
+    flecs::entity foo = world.scope(parent).entity("foo");
+
+    test_assert(world.lookup(".parent.child", ".", ".") == child);
+    test_assert(world.lookup(".parent.foo", ".", ".") == foo);
+}
+
+void Entity_depends_on(void) {
+    flecs::world world;
+
+    flecs::entity a = world.entity();
+    flecs::entity b = world.entity().depends_on(a);
+    test_assert(b.has(flecs::DependsOn, a));
+}
+
+void Entity_depends_on_type(void) {
+    flecs::world world;
+
+    flecs::entity b = world.entity().depends_on<Position>();
+    test_assert(b.has(flecs::DependsOn, world.id<Position>()));
 }
diff --git a/test/cpp_api/src/Enum.cpp b/test/cpp/src/Enum.cpp
similarity index 88%
rename from test/cpp_api/src/Enum.cpp
rename to test/cpp/src/Enum.cpp
index a1d87f987..27f45e645 100644
--- a/test/cpp_api/src/Enum.cpp
+++ b/test/cpp/src/Enum.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 enum StandardEnum {
     Red, Green, Blue
@@ -615,21 +615,21 @@ void Enum_query_enum_wildcard(void) {
     auto e3 = ecs.entity().add(StandardEnum::Blue);
 
     auto q = ecs.query_builder()
-        .term<StandardEnum>(flecs::Wildcard)
+        .with<StandardEnum>(flecs::Wildcard)
         .build();
 
     int32_t count = 0;
     q.each([&](flecs::iter& it, size_t index) {
         if (it.entity(index) == e1) {
-            test_assert(it.pair(1).second() == ecs.id(StandardEnum::Red));
+            test_assert(it.pair(0).second() == ecs.id(StandardEnum::Red));
             count ++;
         }
         if (it.entity(index) == e2) {
-            test_assert(it.pair(1).second() == ecs.id(StandardEnum::Green));
+            test_assert(it.pair(0).second() == ecs.id(StandardEnum::Green));
             count ++;
         }
         if (it.entity(index) == e3) {
-            test_assert(it.pair(1).second() == ecs.id(StandardEnum::Blue));
+            test_assert(it.pair(0).second() == ecs.id(StandardEnum::Blue));
             count ++;
         }
     });
@@ -645,13 +645,13 @@ void Enum_query_enum_constant(void) {
     auto e1 = ecs.entity().add(StandardEnum::Blue);
 
     auto q = ecs.query_builder()
-        .term<StandardEnum>(StandardEnum::Blue)
+        .with<StandardEnum>(StandardEnum::Blue)
         .build();
 
     int32_t count = 0;
     q.each([&](flecs::iter& it, size_t index) {
         test_assert(it.entity(index) == e1);
-        test_assert(it.pair(1).second() == ecs.id(StandardEnum::Blue));
+        test_assert(it.pair(0).second() == ecs.id(StandardEnum::Blue));
         count ++;
     });
 
@@ -865,70 +865,79 @@ void Enum_enum_w_incorrect_size(void) {
 }
 
 void Enum_add_union_enum(void) {
-    flecs::world ecs;
+    // Quarantined until the Union trait is reintroduced
+    test_quarantine("1 Apr 2024");
+
+    // flecs::world ecs;
 
-    ecs.component<StandardEnum>().add(flecs::Union);
+    // ecs.component<StandardEnum>().add(flecs::Union);
 
-    auto t_color = flecs::enum_type<StandardEnum>(ecs);
-    auto red = t_color.entity(StandardEnum::Red);
-    auto blue = t_color.entity(StandardEnum::Blue);
+    // auto t_color = flecs::enum_type<StandardEnum>(ecs);
+    // auto red = t_color.entity(StandardEnum::Red);
+    // auto blue = t_color.entity(StandardEnum::Blue);
 
-    auto e1 = ecs.entity().add(StandardEnum::Red);
-    auto e2 = ecs.entity().add(StandardEnum::Blue);
+    // auto e1 = ecs.entity().add(StandardEnum::Red);
+    // auto e2 = ecs.entity().add(StandardEnum::Blue);
 
-    test_assert(e1.type() == e2.type());
-    test_assert(e1.target<StandardEnum>() == red);
-    test_assert(e2.target<StandardEnum>() == blue);
-    test_assert(e1.has(StandardEnum::Red));
-    test_assert(e2.has(StandardEnum::Blue));
+    // test_assert(e1.type() == e2.type());
+    // test_assert(e1.target<StandardEnum>() == red);
+    // test_assert(e2.target<StandardEnum>() == blue);
+    // test_assert(e1.has(StandardEnum::Red));
+    // test_assert(e2.has(StandardEnum::Blue));
 }
 
 void Enum_add_2_union_enums(void) {
-    flecs::world ecs;
+    // Quarantined until the Union trait is reintroduced
+    test_quarantine("1 Apr 2024");
 
-    ecs.component<StandardEnum>().add(flecs::Union);
-    ecs.component<AnotherEnum>().add(flecs::Union);
+    // flecs::world ecs;
 
-    auto e = ecs.entity();
-    e.add(StandardEnum::Red);
-    e.add(AnotherEnum::Running);
+    // ecs.component<StandardEnum>().add(flecs::Union);
+    // ecs.component<AnotherEnum>().add(flecs::Union);
 
-    test_assert(e.has(StandardEnum::Red));
-    test_assert(e.has(AnotherEnum::Running));
-    test_assert(e.target<StandardEnum>() != 0);
-    test_assert(e.target<AnotherEnum>() != 0);
+    // auto e = ecs.entity();
+    // e.add(StandardEnum::Red);
+    // e.add(AnotherEnum::Running);
+
+    // test_assert(e.has(StandardEnum::Red));
+    // test_assert(e.has(AnotherEnum::Running));
+    // test_assert(e.target<StandardEnum>() != 0);
+    // test_assert(e.target<AnotherEnum>() != 0);
 
-    auto t_color = flecs::enum_type<StandardEnum>(ecs);
-    auto t_AnotherEnum = flecs::enum_type<AnotherEnum>(ecs);
-    auto red = t_color.entity(StandardEnum::Red);
-    auto running = t_AnotherEnum.entity(AnotherEnum::Running);
+    // auto t_color = flecs::enum_type<StandardEnum>(ecs);
+    // auto t_AnotherEnum = flecs::enum_type<AnotherEnum>(ecs);
+    // auto red = t_color.entity(StandardEnum::Red);
+    // auto running = t_AnotherEnum.entity(AnotherEnum::Running);
 
-    test_assert(e.target<StandardEnum>() == red);
-    test_assert(e.target<AnotherEnum>() == running);
+    // test_assert(e.target<StandardEnum>() == red);
+    // test_assert(e.target<AnotherEnum>() == running);
 }
 
 void Enum_add_2_union_enums_reverse(void) {
-    flecs::world ecs;
+    // Quarantined until the Union trait is reintroduced
+    test_quarantine("1 Apr 2024");
+
+    // flecs::world ecs;
 
-    ecs.component<StandardEnum>().add(flecs::Union);
-    ecs.component<AnotherEnum>().add(flecs::Union);
+    // ecs.component<StandardEnum>().add(flecs::Union);
+    // ecs.component<AnotherEnum>().add(flecs::Union);
 
-    auto e = ecs.entity();
-    e.add(AnotherEnum::Running);
-    e.add(StandardEnum::Red);
+    // auto e = ecs.entity();
+    // e.add(AnotherEnum::Running);
+    // e.add(StandardEnum::Red);
 
-    test_assert(e.has(StandardEnum::Red));
-    test_assert(e.has(AnotherEnum::Running));
-    test_assert(e.target<StandardEnum>() != 0);
-    test_assert(e.target<AnotherEnum>() != 0);
+    // test_assert(e.has(StandardEnum::Red));
+    // test_assert(e.has(AnotherEnum::Running));
+    // test_assert(e.target<StandardEnum>() != 0);
+    // test_assert(e.target<AnotherEnum>() != 0);
 
-    auto t_color = flecs::enum_type<StandardEnum>(ecs);
-    auto t_AnotherEnum = flecs::enum_type<AnotherEnum>(ecs);
-    auto red = t_color.entity(StandardEnum::Red);
-    auto running = t_AnotherEnum.entity(AnotherEnum::Running);
+    // auto t_color = flecs::enum_type<StandardEnum>(ecs);
+    // auto t_AnotherEnum = flecs::enum_type<AnotherEnum>(ecs);
+    // auto red = t_color.entity(StandardEnum::Red);
+    // auto running = t_AnotherEnum.entity(AnotherEnum::Running);
 
-    test_assert(e.target<StandardEnum>() == red);
-    test_assert(e.target<AnotherEnum>() == running);
+    // test_assert(e.target<StandardEnum>() == red);
+    // test_assert(e.target<AnotherEnum>() == running);
 }
 
 void Enum_constant_from_entity(void) {
@@ -978,49 +987,55 @@ void Enum_add_if_other(void) {
 }
 
 void Enum_query_union_enum(void) {
-    flecs::world ecs;
-
-    enum Color {
-        Red,
-        Green,
-        Blue
-    };
-
-    ecs.component<StandardEnum>().add(flecs::Union);
-
-    flecs::entity e1 = ecs.entity().add(StandardEnum::Red);
-    flecs::entity e2 = ecs.entity().add(StandardEnum::Green);
-    flecs::entity e3 = ecs.entity().add(StandardEnum::Blue);
+    // Quarantined until the Union trait is reintroduced
+    test_quarantine("1 Apr 2024");
 
-    auto q = ecs.query_builder()
-        .term<StandardEnum>().second(flecs::Wildcard)
-        .build();
-
-    q.iter([&](flecs::iter& it) {
-        flecs::field<flecs::entity_t> colors = it.field<flecs::entity_t>(1);
-        test_int(it.count(), 3);
-        test_uint(it.entity(0), e1);
-        test_uint(it.entity(1), e2);
-        test_uint(it.entity(2), e3);
+    // flecs::world ecs;
 
-        test_uint(colors[0], ecs.to_entity(StandardEnum::Red));
-        test_uint(colors[1], ecs.to_entity(StandardEnum::Green));
-        test_uint(colors[2], ecs.to_entity(StandardEnum::Blue));
-    });
+    // enum Color {
+    //     Red,
+    //     Green,
+    //     Blue
+    // };
+
+    // ecs.component<StandardEnum>().add(flecs::Union);
+
+    // flecs::entity e1 = ecs.entity().add(StandardEnum::Red);
+    // flecs::entity e2 = ecs.entity().add(StandardEnum::Green);
+    // flecs::entity e3 = ecs.entity().add(StandardEnum::Blue);
+
+    // auto q = ecs.query_builder()
+    //     .with<StandardEnum>().second(flecs::Wildcard)
+    //     .build();
+
+    // q.iter([&](flecs::iter& it) {
+    //     flecs::field<flecs::entity_t> colors = it.field<flecs::entity_t>(0);
+    //     test_int(it.count(), 3);
+    //     test_uint(it.entity(0), e1);
+    //     test_uint(it.entity(1), e2);
+    //     test_uint(it.entity(2), e3);
+
+    //     test_uint(colors[0], ecs.to_entity(StandardEnum::Red));
+    //     test_uint(colors[1], ecs.to_entity(StandardEnum::Green));
+    //     test_uint(colors[2], ecs.to_entity(StandardEnum::Blue));
+    // });
 }
 
 void Enum_query_union_enum_invalid_query_type(void) {
-    install_test_abort();
+    // Quarantined until the Union trait is reintroduced
+    test_quarantine("1 Apr 2024");
 
-    flecs::world ecs;
+    // install_test_abort();
 
-    ecs.component<StandardEnum>().add(flecs::Union);
+    // flecs::world ecs;
 
-    test_expect_abort();
+    // ecs.component<StandardEnum>().add(flecs::Union);
 
-    ecs.query_builder<StandardEnum>()
-        .term_at(1).second(flecs::Wildcard)
-        .build();
+    // test_expect_abort();
+
+    // ecs.query_builder<StandardEnum>()
+    //     .term_at(0).second(flecs::Wildcard)
+    //     .build();
 }
 
 void Enum_component_registered_as_enum(void) {
@@ -1030,7 +1045,7 @@ void Enum_component_registered_as_enum(void) {
 
     test_assert(e.has<flecs::Enum>());
 
-    const flecs::MetaType *mt = e.get<flecs::MetaType>();
+    const flecs::Type *mt = e.get<flecs::Type>();
 
     test_assert(mt != nullptr);
     test_assert(mt->kind == flecs::meta::EnumType);
@@ -1083,7 +1098,7 @@ void Enum_mixed_auto_manual_constants(void) {
 
     test_assert(e.has<flecs::Enum>());
 
-    const flecs::MetaType *mt = e.get<flecs::MetaType>();
+    const flecs::Type *mt = e.get<flecs::Type>();
     test_assert(mt != nullptr);
     test_assert(mt->kind == flecs::meta::EnumType);
 
@@ -1135,7 +1150,7 @@ void Enum_enum_class_mixed_auto_manual_constants(void) {
 
     test_assert(e.has<flecs::Enum>());
 
-    const flecs::MetaType *mt = e.get<flecs::MetaType>();
+    const flecs::Type *mt = e.get<flecs::Type>();
     test_assert(mt != nullptr);
     test_assert(mt->kind == flecs::meta::EnumType);
 
@@ -1160,7 +1175,7 @@ void Enum_enum_child_count(void) {
 
     flecs::entity e = ecs.component<StandardEnum>();
 
-    flecs::filter<> f = ecs.filter_builder()
+    flecs::query<> f = ecs.query_builder()
         .with(flecs::ChildOf, e)
         .build();
 
diff --git a/test/cpp_api/src/Event.cpp b/test/cpp/src/Event.cpp
similarity index 97%
rename from test/cpp_api/src/Event.cpp
rename to test/cpp/src/Event.cpp
index 8a52d7cb7..8d9459c95 100644
--- a/test/cpp_api/src/Event.cpp
+++ b/test/cpp/src/Event.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 struct Evt { };
 
@@ -16,7 +16,7 @@ void Event_evt_1_id_entity(void) {
 
     ecs.observer()
         .event(evt)
-        .term(id)
+        .with(id)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -42,7 +42,7 @@ void Event_evt_2_ids_entity(void) {
 
     ecs.observer()
         .event(evt)
-        .term(id_a)
+        .with(id_a)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -50,7 +50,7 @@ void Event_evt_2_ids_entity(void) {
 
     ecs.observer()
         .event(evt)
-        .term(id_b)
+        .with(id_b)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -78,7 +78,7 @@ void Event_evt_1_id_table(void) {
 
     ecs.observer()
         .event(evt)
-        .term(id)
+        .with(id)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -105,7 +105,7 @@ void Event_evt_2_ids_table(void) {
 
     ecs.observer()
         .event(evt)
-        .term(id_a)
+        .with(id_a)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -113,7 +113,7 @@ void Event_evt_2_ids_table(void) {
 
     ecs.observer()
         .event(evt)
-        .term(id_b)
+        .with(id_b)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -138,7 +138,7 @@ void Event_evt_type(void) {
 
     ecs.observer()
         .event<Evt>()
-        .term(id)
+        .with(id)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -161,7 +161,7 @@ void Event_evt_1_component(void) {
 
     ecs.observer()
         .event<Evt>()
-        .term<IdA>()
+        .with<IdA>()
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -184,7 +184,7 @@ void Event_evt_2_components(void) {
 
     ecs.observer()
         .event<Evt>()
-        .term<IdA>()
+        .with<IdA>()
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -192,7 +192,7 @@ void Event_evt_2_components(void) {
 
     ecs.observer()
         .event<Evt>()
-        .term<IdB>()
+        .with<IdB>()
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -222,7 +222,7 @@ void Event_evt_void_ctx(void) {
 
     ecs.observer()
         .event(evt)
-        .term(id)
+        .with(id)
         .iter([&](flecs::iter& it) {
             test_assert(it.entity(0) == e1);
             test_int(it.param<EvtData>()->value, 10);
@@ -250,7 +250,7 @@ void Event_evt_typed_ctx(void) {
 
     ecs.observer()
         .event<EvtData>()
-        .term(id)
+        .with(id)
         .iter([&](flecs::iter& it) {
             test_assert(it.entity(0) == e1);
             test_int(it.param<EvtData>()->value, 10);
@@ -276,7 +276,7 @@ void Event_evt_implicit_typed_ctx(void) {
 
     ecs.observer()
         .event<EvtData>()
-        .term(id)
+        .with(id)
         .iter([&](flecs::iter& it) {
             test_assert(it.entity(0) == e1);
             test_int(it.param<EvtData>()->value, 10);
@@ -304,7 +304,7 @@ void Event_evt_1_id_pair_rel_id_obj_id_entity(void) {
 
     ecs.observer()
         .event(evt)
-        .term(rel, obj)
+        .with(rel, obj)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -329,7 +329,7 @@ void Event_evt_1_id_pair_rel_obj_id_entity(void) {
 
     ecs.observer()
         .event(evt)
-        .term<IdA>(obj)
+        .with<IdA>(obj)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -353,7 +353,7 @@ void Event_evt_1_id_pair_rel_obj_entity(void) {
 
     ecs.observer()
         .event(evt)
-        .term<IdA, IdB>()
+        .with<IdA, IdB>()
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -377,7 +377,7 @@ void Event_emit_staged_from_world(void) {
 
     ecs.observer()
         .event(evt)
-        .term<Tag>()
+        .with<Tag>()
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -405,7 +405,7 @@ void Event_emit_staged_from_stage(void) {
 
     ecs.observer()
         .event(evt)
-        .term<Tag>()
+        .with<Tag>()
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -636,7 +636,7 @@ void Event_enqueue_event(void) {
 
     ecs.observer()
         .event(evt)
-        .term(id_a)
+        .with(id_a)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
             count ++;
@@ -690,7 +690,7 @@ void Event_enqueue_event_w_payload(void) {
 
     ecs.observer()
         .event<Position>()
-        .term(id_a)
+        .with(id_a)
         .each([&](flecs::iter& it, size_t i) {
             test_assert(it.entity(i) == e1);
             test_int(it.param<Position>()->x, 10);
diff --git a/test/cpp_api/src/ImplicitComponents.cpp b/test/cpp/src/ImplicitComponents.cpp
similarity index 98%
rename from test/cpp_api/src/ImplicitComponents.cpp
rename to test/cpp/src/ImplicitComponents.cpp
index 8d8e7c2a9..2abd95f3a 100644
--- a/test/cpp_api/src/ImplicitComponents.cpp
+++ b/test/cpp/src/ImplicitComponents.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 struct Pair {
     int value;
@@ -227,7 +227,7 @@ void ImplicitComponents_reinit(void) {
 
     // Reset component id using internals (currently the only way to simulate
     // registration across translation units)
-    flecs::_::cpp_type<Position>::reset();
+    flecs::_::type<Position>::reset();
 
     world.entity()
         .add<Position>();
@@ -251,7 +251,7 @@ void ImplicitComponents_reinit_scoped(void) {
 
     // Reset component id using internals (currently the only way to simulate
     // registration across translation units)
-    flecs::_::cpp_type<Foo::Position>::reset();
+    flecs::_::type<Foo::Position>::reset();
 
     world.entity()
         .add<Foo::Position>();
@@ -284,7 +284,7 @@ void ImplicitComponents_reinit_w_lifecycle(void) {
 
     // Reset component id using internals (currently the only way to simulate
     // registration across translation units)
-    flecs::_::cpp_type<Position>::reset();
+    flecs::_::type<Position>::reset();
 
     e = world.entity()
         .add<Position>();
diff --git a/test/cpp_api/src/Iterable.cpp b/test/cpp/src/Iterable.cpp
similarity index 99%
rename from test/cpp_api/src/Iterable.cpp
rename to test/cpp/src/Iterable.cpp
index b1d98c0f1..2c68ce2c5 100644
--- a/test/cpp_api/src/Iterable.cpp
+++ b/test/cpp/src/Iterable.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void Iterable_page_each(void) {
     flecs::world ecs;
diff --git a/test/cpp_api/src/Meta.cpp b/test/cpp/src/Meta.cpp
similarity index 99%
rename from test/cpp_api/src/Meta.cpp
rename to test/cpp/src/Meta.cpp
index 7d9547375..3962bade3 100644
--- a/test/cpp_api/src/Meta.cpp
+++ b/test/cpp/src/Meta.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 flecs::opaque<std::string> std_string_support(flecs::world&) {
     flecs::opaque<std::string> ts;
@@ -604,7 +604,7 @@ void Meta_primitive_type(void) {
     test_assert(t != 0);
 
     test_assert(t.has<flecs::Component>());
-    test_assert(t.has<flecs::MetaType>());
+    test_assert(t.has<flecs::Type>());
     test_assert(t.has<flecs::Primitive>());
 
     const flecs::Component *c = t.get<flecs::Component>();
@@ -612,7 +612,7 @@ void Meta_primitive_type(void) {
     test_int(c->size, 4);
     test_int(c->alignment, 4);
 
-    const flecs::MetaType *mt = t.get<flecs::MetaType>();
+    const flecs::Type *mt = t.get<flecs::Type>();
     test_assert(mt != nullptr);
     test_assert(mt->kind == flecs::meta::PrimitiveType);
 
@@ -628,7 +628,7 @@ void Meta_array_type(void) {
     test_assert(t != 0);
 
     test_assert(t.has<flecs::Component>());
-    test_assert(t.has<flecs::MetaType>());
+    test_assert(t.has<flecs::Type>());
     test_assert(t.has<flecs::Array>());
 
     const flecs::Component *c = t.get<flecs::Component>();
@@ -636,7 +636,7 @@ void Meta_array_type(void) {
     test_int(c->size, 3 * 4);
     test_int(c->alignment, 4);
 
-    const flecs::MetaType *mt = t.get<flecs::MetaType>();
+    const flecs::Type *mt = t.get<flecs::Type>();
     test_assert(mt != nullptr);
     test_assert(mt->kind == flecs::meta::ArrayType);
 
@@ -653,7 +653,7 @@ void Meta_vector_type(void) {
     test_assert(t != 0);
 
     test_assert(t.has<flecs::Component>());
-    test_assert(t.has<flecs::MetaType>());
+    test_assert(t.has<flecs::Type>());
     test_assert(t.has<flecs::Vector>());
 
     const flecs::Component *c = t.get<flecs::Component>();
@@ -661,7 +661,7 @@ void Meta_vector_type(void) {
     test_int(c->size, ECS_SIZEOF(ecs_vec_t));
     test_int(c->alignment, ECS_SIZEOF(void*));
 
-    const flecs::MetaType *mt = t.get<flecs::MetaType>();
+    const flecs::Type *mt = t.get<flecs::Type>();
     test_assert(mt != nullptr);
     test_assert(mt->kind == flecs::meta::VectorType);
 
diff --git a/test/cpp_api/src/Misc.cpp b/test/cpp/src/Misc.cpp
similarity index 94%
rename from test/cpp_api/src/Misc.cpp
rename to test/cpp/src/Misc.cpp
index 81719acf5..c8b8221a8 100644
--- a/test/cpp_api/src/Misc.cpp
+++ b/test/cpp/src/Misc.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 enum Color {
     Red, Green, Blue
@@ -122,8 +122,8 @@ static int obs_invoked_count = 0;
 static int trig_invoked_count = 0;
 
 void Sys(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     test_assert(p != NULL);
     test_assert(v != NULL);
@@ -132,8 +132,8 @@ void Sys(ecs_iter_t *it) {
 }
 
 void Obs(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     test_assert(p != NULL);
     test_assert(v != NULL);
@@ -142,7 +142,7 @@ void Obs(ecs_iter_t *it) {
 }
 
 void Trig(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     test_assert(p != NULL);
 
@@ -286,7 +286,7 @@ void Misc_member_gauge_metric(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -319,7 +319,7 @@ void Misc_id_gauge_metric(void) {
     ecs.progress(1.0);
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
             test_int(count, 2);
@@ -337,7 +337,7 @@ void Misc_id_gauge_metric(void) {
     test_int(count, 2);
     count = 0;
 
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
             test_int(count, 2);
@@ -375,7 +375,7 @@ void Misc_oneof_gauge_metric(void) {
     ecs.progress(1.0);
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source>()
+    ecs.query<flecs::metrics::Source>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s) {
             ColorMetric *i = static_cast<ColorMetric*>(it.range().get(m, ecs.id<flecs::metrics::Value>()));
             test_assert(i != nullptr);
@@ -398,7 +398,7 @@ void Misc_oneof_gauge_metric(void) {
     test_int(count, 3);
     count = 0;
 
-    ecs.filter<flecs::metrics::Source>()
+    ecs.query<flecs::metrics::Source>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s) {
             ColorMetric *i = static_cast<ColorMetric*>(it.range().get(m, ecs.id<flecs::metrics::Value>()));
             test_assert(i != nullptr);
@@ -436,7 +436,7 @@ void Misc_id_counter_metric(void) {
     ecs.progress(1.0);
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
             test_int(count, 2);
@@ -454,7 +454,7 @@ void Misc_id_counter_metric(void) {
     test_int(count, 2);
     count = 0;
 
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
             test_int(count, 2);
@@ -492,7 +492,7 @@ void Misc_oneof_counter_metric(void) {
     ecs.progress(1.0);
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source>()
+    ecs.query<flecs::metrics::Source>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s) {
             ColorMetric *i = static_cast<ColorMetric*>(it.range().get(m, ecs.id<flecs::metrics::Value>()));
             test_assert(i != nullptr);
@@ -516,7 +516,7 @@ void Misc_oneof_counter_metric(void) {
     ecs.progress(1.0);
     count = 0;
 
-    ecs.filter<flecs::metrics::Source>()
+    ecs.query<flecs::metrics::Source>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s) {
             ColorMetric *i = static_cast<ColorMetric*>(it.range().get(m, ecs.id<flecs::metrics::Value>()));
             test_assert(i != nullptr);
@@ -554,7 +554,7 @@ void Misc_component_mixin_member_metric(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -591,7 +591,7 @@ void Misc_component_mixin_member_metric_custom_parent_entity(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -634,7 +634,7 @@ void Misc_metric_description(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -670,7 +670,7 @@ void Misc_component_mixin_member_metric_description(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -707,7 +707,7 @@ void Misc_member_metric_w_value_name(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -751,7 +751,7 @@ void Misc_member_metric_w_value_name_camel_case_type(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -791,7 +791,7 @@ void Misc_member_metric_w_custom_name(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -844,7 +844,7 @@ void Misc_dotmember_metric(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -957,7 +957,7 @@ void Misc_alert(void) {
     test_int(e2.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -973,7 +973,7 @@ void Misc_alert(void) {
     ecs.progress(1.0);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1006,7 +1006,7 @@ void Misc_alert_w_message(void) {
     test_int(e2.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1024,7 +1024,7 @@ void Misc_alert_w_message(void) {
     ecs.progress(1.0);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1147,7 +1147,7 @@ void Misc_alert_w_retain_period(void) {
 
     flecs::entity ai;
     {
-        ai = ecs.filter_builder()
+        ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1198,7 +1198,7 @@ void Misc_alert_w_severity_filter(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1219,7 +1219,7 @@ void Misc_alert_w_severity_filter(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1240,7 +1240,7 @@ void Misc_alert_w_severity_filter(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1275,7 +1275,7 @@ void Misc_alert_w_severity_filter_severity_type(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1296,7 +1296,7 @@ void Misc_alert_w_severity_filter_severity_type(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1317,7 +1317,7 @@ void Misc_alert_w_severity_filter_severity_type(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1352,7 +1352,7 @@ void Misc_alert_w_severity_filter_severity_type_id_type(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1373,7 +1373,7 @@ void Misc_alert_w_severity_filter_severity_type_id_type(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1394,7 +1394,7 @@ void Misc_alert_w_severity_filter_severity_type_id_type(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1429,7 +1429,7 @@ void Misc_alert_w_severity_filter_severity_type_enum_constant(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1450,7 +1450,7 @@ void Misc_alert_w_severity_filter_severity_type_enum_constant(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1471,7 +1471,7 @@ void Misc_alert_w_severity_filter_severity_type_enum_constant(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1492,7 +1492,7 @@ void Misc_alert_w_severity_filter_severity_type_enum_constant(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1529,7 +1529,7 @@ void Misc_alert_w_severity_filter_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1550,7 +1550,7 @@ void Misc_alert_w_severity_filter_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1571,7 +1571,7 @@ void Misc_alert_w_severity_filter_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1608,7 +1608,7 @@ void Misc_alert_w_severity_filter_severity_type_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1629,7 +1629,7 @@ void Misc_alert_w_severity_filter_severity_type_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1650,7 +1650,7 @@ void Misc_alert_w_severity_filter_severity_type_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1687,7 +1687,7 @@ void Misc_alert_w_severity_filter_severity_type_id_type_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1708,7 +1708,7 @@ void Misc_alert_w_severity_filter_severity_type_id_type_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1729,7 +1729,7 @@ void Misc_alert_w_severity_filter_severity_type_id_type_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1766,7 +1766,7 @@ void Misc_alert_w_severity_filter_severity_type_enum_constant_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1787,7 +1787,7 @@ void Misc_alert_w_severity_filter_severity_type_enum_constant_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1808,7 +1808,7 @@ void Misc_alert_w_severity_filter_severity_type_enum_constant_w_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1853,7 +1853,7 @@ void Misc_alert_for_member_range(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1871,7 +1871,7 @@ void Misc_alert_for_member_range(void) {
     ecs.progress(1.0);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1913,7 +1913,7 @@ void Misc_alert_w_member_range_from_var(void) {
     test_int(e1.alert_count(a), 1);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1929,7 +1929,7 @@ void Misc_alert_w_member_range_from_var(void) {
     ecs.progress(1.0);
 
     {
-        flecs::entity ai = ecs.filter_builder()
+        flecs::entity ai = ecs.query_builder()
             .with<flecs::alerts::Instance>()
             .build()
             .first();
@@ -1994,7 +1994,7 @@ void Misc_member_metric_w_pair_R_T(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -2034,7 +2034,7 @@ void Misc_member_metric_w_pair_R_t(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -2074,7 +2074,7 @@ void Misc_member_metric_w_pair_r_t(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
@@ -2114,7 +2114,7 @@ void Misc_member_metric_w_pair_r_T(void) {
     ecs.progress();
 
     int32_t count = 0;
-    ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
+    ecs.query<flecs::metrics::Source, flecs::metrics::Value>()
         .iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
             count += it.count();
 
diff --git a/test/cpp_api/src/Module.cpp b/test/cpp/src/Module.cpp
similarity index 99%
rename from test/cpp_api/src/Module.cpp
rename to test/cpp/src/Module.cpp
index 2b36f40e9..95e0cca27 100644
--- a/test/cpp_api/src/Module.cpp
+++ b/test/cpp/src/Module.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 namespace ns {
 struct NestedNameSpaceType { };
@@ -324,9 +324,9 @@ void Module_lookup_module_after_reparent(void) {
 
     // Tests if symbol resolving (used by query DSL) interferes with getting the
     // correct object
-    test_int(world.filter_builder()
+    test_int(world.query_builder()
         .expr("(ChildOf, p.NestedModule)").build().count(), 1);
-    test_int(world.filter_builder()
+    test_int(world.query_builder()
         .expr("(ChildOf, ns.NestedModule)").build().count(), 0);
 }
 
diff --git a/test/cpp_api/src/Observer.cpp b/test/cpp/src/Observer.cpp
similarity index 94%
rename from test/cpp_api/src/Observer.cpp
rename to test/cpp/src/Observer.cpp
index 438dd99e1..5d6d7915c 100644
--- a/test/cpp_api/src/Observer.cpp
+++ b/test/cpp/src/Observer.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void Observer_2_terms_on_add(void) {
     flecs::world ecs;
@@ -117,16 +117,16 @@ void Observer_10_terms(void) {
 
     ecs.observer<>()
         .event(flecs::OnAdd)
-        .term<TagA>()
-        .term<TagB>()
-        .term<TagC>()
-        .term<TagD>()
-        .term<TagE>()
-        .term<TagF>()
-        .term<TagG>()
-        .term<TagH>()
-        .term<TagI>()
-        .term<TagJ>()
+        .with<TagA>()
+        .with<TagB>()
+        .with<TagC>()
+        .with<TagD>()
+        .with<TagE>()
+        .with<TagF>()
+        .with<TagG>()
+        .with<TagH>()
+        .with<TagI>()
+        .with<TagJ>()
         .iter([&](flecs::iter& it) {
             test_int(it.count(), 1);
             test_assert(it.entity(0) == e);
@@ -148,7 +148,7 @@ void Observer_10_terms(void) {
     test_int(count, 1);
 }
 
-void Observer_20_terms(void) {
+void Observer_16_terms(void) {
     flecs::world ecs;
 
     int count = 0;
@@ -157,30 +157,26 @@ void Observer_20_terms(void) {
 
     ecs.observer<>()
         .event(flecs::OnAdd)
-        .term<TagA>()
-        .term<TagB>()
-        .term<TagC>()
-        .term<TagD>()
-        .term<TagE>()
-        .term<TagF>()
-        .term<TagG>()
-        .term<TagH>()
-        .term<TagI>()
-        .term<TagJ>()
-        .term<TagK>()
-        .term<TagL>()
-        .term<TagM>()
-        .term<TagN>()
-        .term<TagO>()
-        .term<TagP>()
-        .term<TagQ>()
-        .term<TagR>()
-        .term<TagS>()
-        .term<TagT>()
+        .with<TagA>()
+        .with<TagB>()
+        .with<TagC>()
+        .with<TagD>()
+        .with<TagE>()
+        .with<TagF>()
+        .with<TagG>()
+        .with<TagH>()
+        .with<TagI>()
+        .with<TagJ>()
+        .with<TagK>()
+        .with<TagL>()
+        .with<TagM>()
+        .with<TagN>()
+        .with<TagO>()
+        .with<TagP>()
         .iter([&](flecs::iter& it) {
             test_int(it.count(), 1);
             test_assert(it.entity(0) == e);
-            test_int(it.field_count(), 20);
+            test_int(it.field_count(), 16);
             count ++;
         });
 
@@ -327,7 +323,7 @@ void Observer_create_w_no_template_args(void) {
     int32_t count = 0;
 
     ecs.observer()
-        .term<Position>()
+        .with<Position>()
         .event(flecs::OnAdd)
         .each([&](flecs::entity e) {
             test_assert(e == e1);
@@ -545,8 +541,8 @@ void Observer_observer_w_filter_term(void) {
     int invoked = 0;
 
     world.observer()
-        .term(TagA)
-        .term(TagB).filter()
+        .with(TagA)
+        .with(TagB).filter()
         .event(flecs::OnAdd)
         .each([&](flecs::entity e) {
             invoked ++;
@@ -615,7 +611,7 @@ void Observer_get_query(void) {
     auto q = sys.query();
 
     q.iter([&](flecs::iter &it) {
-        auto pos = it.field<const Position>(1);
+        auto pos = it.field<const Position>(0);
         for (auto i : it) {
             test_int(i, pos[i].x);
             count ++;
@@ -674,7 +670,7 @@ void Observer_on_add_singleton(void) {
     int32_t count = 0;
 
     world.observer<Position>()
-        .term_at(1).singleton()
+        .term_at(0).singleton()
         .event(flecs::OnSet)
         .each([&](Position& p) {
             test_int(p.x, 10);
@@ -695,7 +691,7 @@ void Observer_on_add_pair_singleton(void) {
     flecs::entity tgt = world.entity();
 
     world.observer<Position>()
-        .term_at(1).second(tgt).singleton()
+        .term_at(0).second(tgt).singleton()
         .event(flecs::OnSet)
         .each([&](Position& p) {
             test_int(p.x, 10);
@@ -717,7 +713,7 @@ void Observer_on_add_pair_wildcard_singleton(void) {
     flecs::entity tgt_2 = world.entity();
 
     world.observer<Position>()
-        .term_at(1).second(flecs::Wildcard).singleton()
+        .term_at(0).second(flecs::Wildcard).singleton()
         .event(flecs::OnSet)
         .each([&](Position& p) {
             test_int(p.x, 10);
diff --git a/test/cpp_api/src/Pairs.cpp b/test/cpp/src/Pairs.cpp
similarity index 98%
rename from test/cpp_api/src/Pairs.cpp
rename to test/cpp/src/Pairs.cpp
index c709124c6..bb2b7d108 100644
--- a/test/cpp_api/src/Pairs.cpp
+++ b/test/cpp/src/Pairs.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 typedef struct Pair {
     float value;
@@ -147,7 +147,7 @@ void Pairs_system_1_pair_instance(void) {
     ecs.system<>()
         .expr("(Pair, *)")
         .iter([&](flecs::iter it) {
-            flecs::field<Pair> tr(it, 1);
+            flecs::field<Pair> tr(it, 0);
             invoke_count ++;            
             for (auto i : it) {
                 entity_count ++;
@@ -176,7 +176,7 @@ void Pairs_system_2_pair_instances(void) {
     ecs.system<>()
         .expr("(Pair, *)")
         .iter([&](flecs::iter it) {
-            flecs::field<Pair> tr(it, 1);
+            flecs::field<Pair> tr(it, 0);
             invoke_count ++;            
             for (auto i : it) {
                 entity_count ++;
@@ -991,7 +991,7 @@ void Pairs_set_1_pair_arg(void) {
     flecs::world ecs;
 
     auto e = ecs.entity()
-        .set([](EatsApples&& a) {
+        .insert([](EatsApples&& a) {
             a->amount = 10;
         });
 
@@ -1003,7 +1003,7 @@ void Pairs_set_2_pair_arg(void) {
     flecs::world ecs;
 
     auto e = ecs.entity()
-        .set([](EatsApples&& a, EatsPears&& p) {
+        .insert([](EatsApples&& a, EatsPears&& p) {
             a->amount = 10;
             p->amount = 20;
         });
@@ -1031,7 +1031,7 @@ void Pairs_set_inline_pair_type(void) {
     flecs::world ecs;
 
     auto e = ecs.entity()
-        .set([](flecs::pair<Eats, Apples>&& a) {
+        .insert([](flecs::pair<Eats, Apples>&& a) {
             a->amount = 10;
         });
 
@@ -1054,7 +1054,7 @@ void Pairs_set_pair_type_object(void) {
     flecs::world ecs;
 
     auto e = ecs.entity()
-        .set([](flecs::pair_object<Apples, Eats>&& a) {
+        .insert([](flecs::pair_object<Apples, Eats>&& a) {
             a->amount = 10;
         });
 
diff --git a/test/cpp_api/src/Paths.cpp b/test/cpp/src/Paths.cpp
similarity index 99%
rename from test/cpp_api/src/Paths.cpp
rename to test/cpp/src/Paths.cpp
index 7e01916a5..e0991beac 100644
--- a/test/cpp_api/src/Paths.cpp
+++ b/test/cpp/src/Paths.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void Paths_name(void) {
     flecs::world world;
diff --git a/test/cpp_api/src/PrettyFunction.cpp b/test/cpp/src/PrettyFunction.cpp
similarity index 96%
rename from test/cpp_api/src/PrettyFunction.cpp
rename to test/cpp/src/PrettyFunction.cpp
index 65939581f..b4cee714b 100644
--- a/test/cpp_api/src/PrettyFunction.cpp
+++ b/test/cpp/src/PrettyFunction.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 #include <iostream>
 
 // Helper to debug differences in function name strings across compilers
diff --git a/test/cpp_api/src/Query.cpp b/test/cpp/src/Query.cpp
similarity index 83%
rename from test/cpp_api/src/Query.cpp
rename to test/cpp/src/Query.cpp
index 81f42d726..e1933d727 100644
--- a/test/cpp_api/src/Query.cpp
+++ b/test/cpp/src/Query.cpp
@@ -1,9 +1,559 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 struct Pair {
     float value;
 };
 
+void Query_term_each_component(void) {
+    flecs::world ecs;
+
+    auto e_1 = ecs.entity().set<Position>({1, 2});
+    auto e_2 = ecs.entity().set<Position>({3, 4});
+    auto e_3 = ecs.entity().set<Position>({5, 6});
+
+    e_3.add<Tag>();
+
+    int32_t count = 0;
+    ecs.each<Position>([&](flecs::entity e, Position& p) {
+        if (e == e_1) {
+            test_int(p.x, 1);
+            test_int(p.y, 2);
+            count ++;
+        }
+        if (e == e_2) {
+            test_int(p.x, 3);
+            test_int(p.y, 4);
+            count ++;
+        }
+        if (e == e_3) {
+            test_int(p.x, 5);
+            test_int(p.y, 6);
+            count ++;
+        }                
+    });
+
+    test_int(count, 3);
+}
+
+void Query_term_each_tag(void) {
+    flecs::world ecs;
+
+    struct Foo { };
+
+    auto e_1 = ecs.entity().add<Foo>();
+    auto e_2 = ecs.entity().add<Foo>();
+    auto e_3 = ecs.entity().add<Foo>();
+
+    e_3.add<Tag>();
+
+    int32_t count = 0;
+    ecs.each<Foo>([&](flecs::entity e, Foo) {
+        if (e == e_1 || e == e_2 || e == e_3) {
+            count ++;
+        }            
+    });
+
+    test_int(count, 3);
+}
+
+void Query_term_each_id(void) {
+    flecs::world ecs;
+
+    auto foo = ecs.entity();
+
+    auto e_1 = ecs.entity().add(foo);
+    auto e_2 = ecs.entity().add(foo);
+    auto e_3 = ecs.entity().add(foo);
+
+    e_3.add<Tag>();
+
+    int32_t count = 0;
+    ecs.each(foo, [&](flecs::entity e) {
+        if (e == e_1 || e == e_2 || e == e_3) {
+            count ++;
+        }            
+    });
+
+    test_int(count, 3);
+}
+
+void Query_term_each_pair_type(void) {
+    flecs::world ecs;
+
+    struct Rel { };
+    struct Obj { };
+
+    auto e_1 = ecs.entity().add<Rel, Obj>();
+    auto e_2 = ecs.entity().add<Rel, Obj>();
+    auto e_3 = ecs.entity().add<Rel, Obj>();
+
+    e_3.add<Tag>();
+
+    int32_t count = 0;
+    ecs.each<flecs::pair<Rel, Obj>>([&](flecs::entity e, flecs::pair<Rel,Obj>) {
+        if (e == e_1 || e == e_2 || e == e_3) {
+            count ++;
+        }
+    });
+
+    test_int(count, 3);
+}
+
+void Query_term_each_pair_id(void) {
+    flecs::world ecs;
+
+    auto rel = ecs.entity();
+    auto obj = ecs.entity();
+
+    auto e_1 = ecs.entity().add(rel, obj);
+    auto e_2 = ecs.entity().add(rel, obj);
+    auto e_3 = ecs.entity().add(rel, obj);
+
+    e_3.add<Tag>();
+
+    int32_t count = 0;
+    ecs.each(ecs.pair(rel, obj), [&](flecs::entity e) {
+        if (e == e_1 || e == e_2 || e == e_3) {
+            count ++;
+        }
+    });
+
+    test_int(count, 3);
+}
+
+void Query_term_each_pair_relation_wildcard(void) {
+    flecs::world ecs;
+
+    auto rel_1 = ecs.entity();
+    auto rel_2 = ecs.entity();
+    auto obj = ecs.entity();
+
+    auto e_1 = ecs.entity().add(rel_1, obj);
+    auto e_2 = ecs.entity().add(rel_1, obj);
+    auto e_3 = ecs.entity().add(rel_2, obj);
+
+    e_3.add<Tag>();
+
+    int32_t count = 0;
+    ecs.each(ecs.pair(flecs::Wildcard, obj), [&](flecs::entity e) {
+        if (e == e_1 || e == e_2 || e == e_3) {
+            count ++;
+        }
+    });
+
+    test_int(count, 3);
+}
+
+void Query_term_each_pair_object_wildcard(void) {
+    flecs::world ecs;
+
+    auto rel = ecs.entity();
+    auto obj_1 = ecs.entity();
+    auto obj_2 = ecs.entity();
+
+    auto e_1 = ecs.entity().add(rel, obj_1);
+    auto e_2 = ecs.entity().add(rel, obj_1);
+    auto e_3 = ecs.entity().add(rel, obj_2);
+
+    e_3.add<Tag>();
+
+    int32_t count = 0;
+    ecs.each(ecs.pair(rel, flecs::Wildcard), [&](flecs::entity e) {
+        if (e == e_1 || e == e_2 || e == e_3) {
+            count ++;
+        }
+    });
+
+    test_int(count, 3);
+}
+
+void Query_default_ctor_no_assign(void) {
+    flecs::query<> f;
+    
+    // Make sure code compiles & works
+    test_assert(true);
+}
+
+void Query_term_get_id(void) {
+    flecs::world ecs;
+
+    auto Foo = ecs.entity();
+    auto Bar = ecs.entity();
+
+    auto q = ecs.query_builder()
+        .with<Position>()
+        .with<Velocity>()
+        .with(Foo, Bar)
+        .build();
+
+    test_int(q.field_count(), 3);
+    
+    flecs::term 
+    t = q.term(0);
+    test_assert(t.id() == ecs.id<Position>());
+    t = q.term(1);
+    test_assert(t.id() == ecs.id<Velocity>());
+    t = q.term(2);
+    test_assert(t.id() == ecs.pair(Foo, Bar));
+}
+
+void Query_term_get_subj(void) {
+    flecs::world ecs;
+
+    auto Foo = ecs.entity();
+    auto Bar = ecs.entity();
+    auto Src = ecs.entity();
+
+    auto q = ecs.query_builder()
+        .with<Position>()
+        .with<Velocity>().src(Src)
+        .with(Foo, Bar)
+        .build();
+
+    test_int(q.field_count(), 3);
+    
+    flecs::term 
+    t = q.term(0);
+    test_assert(t.get_src() == flecs::This);
+    t = q.term(1);
+    test_assert(t.get_src() == Src);
+    t = q.term(2);
+    test_assert(t.get_src() == flecs::This);
+}
+
+void Query_term_get_pred(void) {
+    flecs::world ecs;
+
+    auto Foo = ecs.entity();
+    auto Bar = ecs.entity();
+    auto Src = ecs.entity();
+
+    auto q = ecs.query_builder()
+        .with<Position>()
+        .with<Velocity>().src(Src)
+        .with(Foo, Bar)
+        .build();
+
+    test_int(q.field_count(), 3);
+    
+    flecs::term 
+    t = q.term(0);
+    test_assert(t.get_first() == ecs.id<Position>());
+    t = q.term(1);
+    test_assert(t.get_first() == ecs.id<Velocity>());
+    t = q.term(2);
+    test_assert(t.get_first() == Foo);
+}
+
+void Query_term_get_obj(void) {
+    flecs::world ecs;
+
+    auto Foo = ecs.entity();
+    auto Bar = ecs.entity();
+    auto Src = ecs.entity();
+
+    auto q = ecs.query_builder()
+        .with<Position>()
+        .with<Velocity>().src(Src)
+        .with(Foo, Bar)
+        .build();
+
+    test_int(q.field_count(), 3);
+    
+    flecs::term 
+    t = q.term(0);
+    test_assert(t.get_second() == 0);
+    t = q.term(1);
+    test_assert(t.get_second() == 0);
+    t = q.term(2);
+    test_assert(t.get_second() == Bar);
+}
+
+void Query_get_first(void) {
+    flecs::world ecs;
+
+    struct A {};
+
+    auto e1 = ecs.entity().add<A>();
+    ecs.entity().add<A>();
+    ecs.entity().add<A>();
+
+    auto q = ecs.query<A>();
+
+    auto first = q.iter().first();
+    test_assert(first != 0);
+    test_assert(first == e1);
+}
+
+void Query_get_count_direct(void) {
+    flecs::world ecs;
+
+    struct A {};
+
+    ecs.entity().add<A>();
+    ecs.entity().add<A>();
+    ecs.entity().add<A>();
+
+    auto q = ecs.query<A>();
+
+    test_int(3, q.count());
+}
+
+void Query_get_is_true_direct(void) {
+    flecs::world ecs;
+
+    struct A {};
+    struct B {};
+
+    ecs.entity().add<A>();
+    ecs.entity().add<A>();
+    ecs.entity().add<A>();
+
+    auto q_1 = ecs.query<A>();
+    auto q_2 = ecs.query<B>();
+
+    test_bool(true, q_1.is_true());
+    test_bool(false, q_2.is_true());
+}
+
+void Query_get_first_direct(void) {
+    flecs::world ecs;
+
+    struct A {};
+
+    auto e1 = ecs.entity().add<A>();
+    ecs.entity().add<A>();
+    ecs.entity().add<A>();
+
+    auto q = ecs.query<A>();
+
+    auto first = q.first();
+    test_assert(first != 0);
+    test_assert(first == e1);
+}
+
+void Query_each_w_no_this(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    auto f = ecs.query_builder<Position, Velocity>()
+        .term_at(0).src(e)
+        .term_at(1).src(e)
+        .build();
+
+    int32_t count = 0;
+
+    f.each([&](Position& p, Velocity& v) {
+        count ++;
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+        test_int(v.x, 1);
+        test_int(v.y, 2);
+    });
+
+    test_int(count, 1);
+}
+
+void Query_each_w_iter_no_this(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    auto f = ecs.query_builder<Position, Velocity>()
+        .term_at(0).src(e)
+        .term_at(1).src(e)
+        .build();
+
+    int32_t count = 0;
+
+    f.each([&](flecs::iter& it, size_t index, Position& p, Velocity& v) {
+        count ++;
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+        test_int(v.x, 1);
+        test_int(v.y, 2);
+        test_int(index, 0);
+        test_int(it.count(), 0);
+    });
+
+    test_int(count, 1);
+}
+
+void Query_invalid_each_w_no_this(void) {
+    install_test_abort();
+
+    flecs::world ecs;
+
+    auto e = ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    auto f = ecs.query_builder<Position, Velocity>()
+        .term_at(0).src(e)
+        .term_at(1).src(e)
+        .build();
+
+    test_expect_abort();
+
+    f.each([&](flecs::entity e, Position& p, Velocity& v) { });
+}
+
+void Query_named_query(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Position>();
+
+    auto q = ecs.query<Position>("my_query");
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position&) {
+        test_assert(e == e1 || e == e2);
+        count ++;
+    });
+    test_int(count, 2);
+
+    flecs::entity qe = q.entity();
+    test_assert(qe != 0);
+    test_str(qe.name(), "my_query");
+}
+
+void Query_named_scoped_query(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Position>();
+
+    auto q = ecs.query<Position>("my::query");
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position&) {
+        test_assert(e == e1 || e == e2);
+        count ++;
+    });
+    test_int(count, 2);
+
+    flecs::entity qe = q.entity();
+    test_assert(qe != 0);
+    test_str(qe.name(), "query");
+    test_str(qe.path(), "::my::query");
+}
+
+void Query_set_this_var(void) {
+    flecs::world ecs;
+
+    /* auto e_1 = */ ecs.entity().set<Position>({1, 2});
+    auto e_2 = ecs.entity().set<Position>({3, 4});
+    /* auto e_3 = */ ecs.entity().set<Position>({5, 6});
+
+    auto q = ecs.query<Position>("my::query");
+
+    int32_t count = 0;
+    q.iter().set_var(0, e_2).each([&](flecs::entity e, Position&) {
+        test_assert(e == e_2);
+        count ++;
+    });
+    test_int(count, 1);
+}
+
+void Query_inspect_terms_w_expr(void) {
+    flecs::world ecs;
+
+    flecs::query<> f = ecs.query_builder()
+        .expr("(ChildOf,0)")
+        .build();
+
+    int32_t count = 0;
+    f.each_term([&](flecs::term &term) {
+        test_assert(term.id().is_pair());
+        count ++;
+    });
+
+    test_int(count, 1);
+}
+
+void Query_find(void) {
+    flecs::world ecs;
+
+    /* auto e1 = */ ecs.entity().set<Position>({10, 20});
+    auto e2 = ecs.entity().set<Position>({20, 30});
+
+    auto q = ecs.query<Position>();
+
+    auto r = q.find([](Position& p) {
+        return p.x == 20;
+    });
+
+    test_assert(r == e2);
+}
+
+void Query_find_not_found(void) {
+    flecs::world ecs;
+
+    /* auto e1 = */ ecs.entity().set<Position>({10, 20});
+    /* auto e2 = */ ecs.entity().set<Position>({20, 30});
+
+    auto q = ecs.query<Position>();
+
+    auto r = q.find([](Position& p) {
+        return p.x == 30;
+    });
+
+    test_assert(!r);
+}
+
+void Query_find_w_entity(void) {
+    flecs::world ecs;
+
+    /* auto e1 = */ ecs.entity().set<Position>({10, 20}).set<Velocity>({20, 30});
+    auto e2 = ecs.entity().set<Position>({20, 30}).set<Velocity>({20, 30});
+
+    auto q = ecs.query<Position>();
+
+    auto r = q.find([](flecs::entity e, Position& p) {
+        return p.x == e.get<Velocity>()->x &&
+               p.y == e.get<Velocity>()->y;
+    });
+
+    test_assert(r == e2);
+}
+
+void Query_optional_pair_term(void) {
+    flecs::world ecs;
+
+    ecs.entity()
+        .add<TagA>()
+        .emplace<Position, Tag>(1.0f, 2.0f);
+    ecs.entity()
+        .add<TagA>();
+
+    int32_t with_pair = 0, without_pair = 0;
+
+    auto f = ecs.query_builder<flecs::pair<Position, Tag>*>()
+        .with<TagA>()
+        .build();
+        
+    f.each([&](flecs::entity e, Position* p) {
+        if (p) {
+            with_pair++;
+            test_flt(1.0f, p->x);
+            test_flt(2.0f, p->y);
+        } else {
+            without_pair++;
+        }
+    });
+
+    ecs.progress(1.0);
+
+    test_int(1, with_pair);
+    test_int(1, without_pair);
+}
+
 void Query_action(void) {
     flecs::world world;
 
@@ -70,13 +620,13 @@ void Query_action_shared(void) {
         .set<Velocity>({3, 4});
 
     auto q = world.query_builder<Position>()
-        .expr("Velocity(self|up)")
+        .expr("Velocity(self|up IsA)")
         .build();
 
     q.iter([](flecs::iter&it, Position *p) {
-            auto v = it.field<const Velocity>(2);
+            auto v = it.field<const Velocity>(1);
 
-            if (!it.is_self(2)) {
+            if (!it.is_self(1)) {
                 for (auto i : it) {
                     p[i].x += v->x;
                     p[i].y += v->y;
@@ -124,7 +674,7 @@ void Query_action_optional(void) {
     auto q = world.query<Position, Velocity*, Mass*>();
 
     q.iter([](flecs::iter& it, Position *p, Velocity *v, Mass *m) {
-        if (it.is_set(2) && it.is_set(3)) {
+        if (it.is_set(1) && it.is_set(2)) {
             for (auto i : it) {
                 p[i].x += v[i].x * m[i].value;
                 p[i].y += v[i].y * m[i].value;
@@ -304,8 +854,8 @@ void Query_signature(void) {
     auto q = world.query_builder<>().expr("Position, Velocity").build();
 
     q.iter([](flecs::iter& it) {
-        auto p = it.field<Position>(1);
-        auto v = it.field<Velocity>(2);
+        auto p = it.field<Position>(0);
+        auto v = it.field<Velocity>(1);
 
         for (auto i : it) {
             p[i].x += v[i].x;
@@ -331,8 +881,8 @@ void Query_signature_const(void) {
     auto q = world.query_builder<>().expr("Position, [in] Velocity").build();
 
     q.iter([](flecs::iter& it) {
-        auto p = it.field<Position>(1);
-        auto v = it.field<const Velocity>(2);
+        auto p = it.field<Position>(0);
+        auto v = it.field<const Velocity>(1);
         
         for (auto i : it) {
             p[i].x += v[i].x;
@@ -363,14 +913,14 @@ void Query_signature_shared(void) {
         .set<Velocity>({3, 4});
 
     auto q = world.query_builder<>()
-        .expr("Position, [in] Velocity(self|up)")
+        .expr("Position, [in] Velocity(self|up IsA)")
         .build();
     
     q.iter([](flecs::iter&it) {
-        auto p = it.field<Position>(1);
-        auto v = it.field<const Velocity>(2);
+        auto p = it.field<Position>(0);
+        auto v = it.field<const Velocity>(1);
 
-        if (!it.is_self(2)) {
+        if (!it.is_self(1)) {
             for (auto i : it) {
                 p[i].x += v->x;
                 p[i].y += v->y;
@@ -418,11 +968,11 @@ void Query_signature_optional(void) {
     auto q = world.query_builder<>().expr("Position, ?Velocity, ?Mass").build();
 
     q.iter([](flecs::iter& it) {
-        auto p = it.field<Position>(1);
-        auto v = it.field<const Velocity>(2);
-        auto m = it.field<const Mass>(3);
+        auto p = it.field<Position>(0);
+        auto v = it.field<const Velocity>(1);
+        auto m = it.field<const Mass>(2);
 
-        if (it.is_set(2) && it.is_set(3)) {
+        if (it.is_set(1) && it.is_set(2)) {
             for (auto i : it) {
                 p[i].x += v[i].x * m[i].value;
                 p[i].y += v[i].y * m[i].value;
@@ -452,64 +1002,6 @@ void Query_signature_optional(void) {
     test_int(p->y, 81); 
 }
 
-void Query_subquery(void) {
-    flecs::world world;
-
-    auto e1 = flecs::entity(world)
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    auto e2 = flecs::entity(world)
-        .set<Velocity>({1, 2});        
-
-    auto q = world.query<Position>();
-    auto sq = world.query_builder<Velocity>().observable(q).build();
-
-    sq.each([](flecs::entity e, Velocity& v) {
-        v.x ++;
-        v.y ++;
-    });
-
-    const Velocity *v = e1.get<Velocity>();
-    test_int(v->x, 2);
-    test_int(v->y, 3);
-
-    v = e2.get<Velocity>();
-    test_int(v->x, 1);
-    test_int(v->y, 2);
-}
-
-void Query_subquery_w_expr(void) {
-    flecs::world world;
-
-    auto e1 = flecs::entity(world)
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    auto e2 = flecs::entity(world)
-        .set<Velocity>({1, 2});        
-
-    auto q = world.query<Position>();
-    auto sq = world.query_builder<>().observable(q).expr("Velocity").build();
-
-    sq.iter([](flecs::iter it) {
-        auto v = it.field<Velocity>(1);
-
-        for (auto i : it) {
-            v[i].x ++;
-            v[i].y ++;
-        }
-    });
-
-    const Velocity *v = e1.get<Velocity>();
-    test_int(v->x, 2);
-    test_int(v->y, 3);
-
-    v = e2.get<Velocity>();
-    test_int(v->x, 1);
-    test_int(v->y, 2);
-}
-
 void Query_query_single_pair(void) {
     flecs::world world;
 
@@ -602,7 +1094,10 @@ void Query_changed(void) {
 
     auto e = world.entity().set<Position>({1, 0});
 
-    auto q = world.query<const Position>();
+    auto q = world.query_builder<const Position>()
+        .cached()
+        .build();
+
     auto q_w = world.query<Position>();
 
     test_bool(q.changed(), true);
@@ -620,20 +1115,6 @@ void Query_changed(void) {
     test_bool(q.changed(), true);
 }
 
-void Query_orphaned(void) {
-    flecs::world world;
-
-    auto q = world.query<Position>();
-    auto sq = world.query_builder<Position>().observable(q).build();
-    
-    test_assert(!q.orphaned());
-    test_assert(!sq.orphaned());
-
-    q.destruct();
-
-    test_assert(sq.orphaned());
-}
-
 void Query_default_ctor(void) {
     flecs::world world;
 
@@ -715,11 +1196,11 @@ void Query_compare_term_id(void) {
     auto e = world.entity().add<Tag>();
 
     auto q = world.query_builder<>()
-        .term<Tag>()
+        .with<Tag>()
         .build();
     
     q.iter([&](flecs::iter& it) {
-        test_assert(it.id(1) == it.world().id<Tag>());
+        test_assert(it.id(0) == it.world().id<Tag>());
         test_assert(it.entity(0) == e);
         count ++;
     });
@@ -736,7 +1217,9 @@ void Query_test_no_defer_each(void) {
 
     world.entity().add<Tag>().set<Value>({10});
 
-    auto q = world.query_builder<Value>().term<Tag>().build();
+    auto q = world.query_builder<Value>()
+        .with<Tag>()
+        .build();
 
     q.each([](flecs::entity e, Value& v) {
         test_expect_abort();
@@ -755,7 +1238,9 @@ void Query_test_no_defer_iter(void) {
 
     world.entity().add<Tag>().set<Value>({10});
 
-    auto q = world.query_builder<Value>().term<Tag>().build();
+    auto q = world.query_builder<Value>()
+        .with<Tag>()
+        .build();
 
     q.iter([](flecs::iter& it, Value *v) {
         for (auto i : it) {
@@ -773,8 +1258,8 @@ void Query_inspect_terms(void) {
     auto p = world.entity();
 
     auto q = world.query_builder<Position>()
-        .term<Velocity>()
-        .term(flecs::ChildOf, p)
+        .with<Velocity>()
+        .with(flecs::ChildOf, p)
         .build();
 
     test_int(3, q.field_count());
@@ -787,12 +1272,12 @@ void Query_inspect_terms(void) {
     t = q.term(1);
     test_int(t.id(), world.id<Velocity>());
     test_int(t.oper(), flecs::And);
-    test_int(t.inout(), flecs::InOutDefault);
+    test_int(t.inout(), flecs::InOutNone);
 
     t = q.term(2);
     test_int(t.id(), world.pair(flecs::ChildOf, p));
     test_int(t.oper(), flecs::And);
-    test_int(t.inout(), flecs::InOutDefault);
+    test_int(t.inout(), flecs::InOutNone);
     test_assert(t.id().second() == p);
 }
 
@@ -802,55 +1287,41 @@ void Query_inspect_terms_w_each(void) {
     auto p = world.entity();
 
     auto q = world.query_builder<Position>()
-        .term<Velocity>()
-        .term(flecs::ChildOf, p)
+        .with<Velocity>()
+        .with(flecs::ChildOf, p)
         .build();
 
     int32_t count =  0;
     q.each_term([&](flecs::term& t) {
         if (count == 0) {
             test_int(t.id(), world.id<Position>());
+            test_int(t.inout(), flecs::InOutDefault);
         } else if (count == 1) {
             test_int(t.id(), world.id<Velocity>());
+            test_int(t.inout(), flecs::InOutNone);
         } else if (count == 2) {
-            test_int(t.id(), world.pair(flecs::ChildOf, p));
-            test_assert(t.id().second() == p);
-        } else {
-            test_assert(false);
-        }
-
-        test_int(t.oper(), flecs::And);
-        test_int(t.inout(), flecs::InOutDefault);
-
-        count ++;
-    });
-
-    test_int(count, 3);
-}
-
-void Query_inspect_terms_w_expr(void) {
-    flecs::world ecs;
+            test_int(t.id(), world.pair(flecs::ChildOf, p));
+            test_assert(t.id().second() == p);
+            test_int(t.inout(), flecs::InOutNone);
+        } else {
+            test_assert(false);
+        }
 
-    flecs::query<> f = ecs.query_builder()
-        .expr("(ChildOf,0)")
-        .build();
+        test_int(t.oper(), flecs::And);
 
-    int32_t count = 0;
-    f.each_term([&](flecs::term &term) {
-        test_assert(term.id().is_pair());
         count ++;
     });
 
-    test_int(count, 1);
+    test_int(count, 3);
 }
 
 void Query_comp_to_str(void) {
     flecs::world ecs;
 
     auto q = ecs.query_builder<Position>()
-        .term<Velocity>()
+        .with<Velocity>()
         .build();
-    test_str(q.str(), "Position, Velocity");
+    test_str(q.str(), "Position, [none] Velocity");
 }
 
 struct Eats { int amount; };
@@ -861,17 +1332,17 @@ void Query_pair_to_str(void) {
     flecs::world ecs;
 
     auto q = ecs.query_builder<Position>()
-        .term<Velocity>()
-        .term<Eats, Apples>()
+        .with<Velocity>()
+        .with<Eats, Apples>()
         .build();
-    test_str(q.str(), "Position, Velocity, (Eats,Apples)");
+    test_str(q.str(), "Position, [none] Velocity, [none] (Eats,Apples)");
 }
 
 void Query_oper_not_to_str(void) {
     flecs::world ecs;
 
     auto q = ecs.query_builder<Position>()
-        .term<Velocity>().oper(flecs::Not)
+        .with<Velocity>().oper(flecs::Not)
         .build();
     test_str(q.str(), "Position, !Velocity");
 }
@@ -880,19 +1351,19 @@ void Query_oper_optional_to_str(void) {
     flecs::world ecs;
 
     auto q = ecs.query_builder<Position>()
-        .term<Velocity>().oper(flecs::Optional)
+        .with<Velocity>().oper(flecs::Optional)
         .build();
-    test_str(q.str(), "Position, ?Velocity");
+    test_str(q.str(), "Position, [none] ?Velocity");
 }
 
 void Query_oper_or_to_str(void) {
     flecs::world ecs;
 
     auto q = ecs.query_builder<>()
-        .term<Position>().oper(flecs::Or)
-        .term<Velocity>()
+        .with<Position>().oper(flecs::Or)
+        .with<Velocity>()
         .build();
-    test_str(q.str(), "Position || Velocity");
+    test_str(q.str(), "[none] Position || Velocity");
 }
 
 using EatsApples = flecs::pair<Eats, Apples>;
@@ -963,14 +1434,14 @@ void Query_term_pair_type(void) {
         .set<EatsPears>({20});
 
     auto q = ecs.query_builder<>()
-        .term<EatsApples>()
+        .with<EatsApples>().inout()
         .build();
 
     int count = 0;
     q.iter([&](flecs::iter& it) {
         test_int(it.count(), 1);
 
-        auto a = it.field<EatsApples>(1);
+        auto a = it.field<EatsApples>(0);
 
         test_int(a->amount, 10);
         test_assert(it.entity(0) == e1);
@@ -1092,7 +1563,7 @@ void Query_iter_no_comps_no_comps(void) {
     ecs.entity().add<Position>().add<Velocity>();
 
     auto q = ecs.query_builder<>()
-        .term<Position>()
+        .with<Position>()
         .build();
 
     int32_t count = 0;
@@ -1206,7 +1677,7 @@ void Query_instanced_query_w_singleton_each(void) {
     e5.add<Tag>();
 
     auto q = ecs.query_builder<Self, Position, const Velocity>()
-        .arg(3).singleton()
+        .term_at(2).singleton()
         .instanced()
         .build();
 
@@ -1324,7 +1795,7 @@ void Query_un_instanced_query_w_singleton_each(void) {
     e5.add<Tag>();
 
     auto q = ecs.query_builder<Self, Position, const Velocity>()
-        .arg(3).singleton()
+        .term_at(2).singleton()
         .build();
 
     int32_t count = 0;
@@ -1440,7 +1911,7 @@ void Query_instanced_query_w_singleton_iter(void) {
     e5.add<Tag>();
 
     auto q = ecs.query_builder<Self, Position, const Velocity>()
-        .arg(3).singleton()
+        .term_at(2).singleton()
         .instanced()
         .build();
 
@@ -1506,7 +1977,7 @@ void Query_instanced_query_w_base_iter(void) {
         test_assert(it.count() > 1);
 
         for (auto i : it) {
-            if (it.is_self(3)) {
+            if (it.is_self(2)) {
                 p[i].x += v[i].x;
                 p[i].y += v[i].y;
             } else {
@@ -1572,7 +2043,7 @@ void Query_un_instanced_query_w_singleton_iter(void) {
     e5.add<Tag>();
 
     auto q = ecs.query_builder<Self, Position, const Velocity>()
-        .arg(3).singleton()
+        .term_at(2).singleton()
         .build();
 
     int32_t count = 0;
@@ -1679,13 +2150,6 @@ void Query_un_instanced_query_w_base_iter(void) {
     }));
 }
 
-void Query_default_ctor_no_assign(void) {
-    flecs::query<> q;
-
-    // Make sure code compiles & works
-    test_assert(true);
-}
-
 void Query_query_each_from_component(void) {
     flecs::world w;
 
@@ -1841,33 +2305,6 @@ void Query_query_each_w_iter(void) {
     test_int(ptr->y, 31);
 }
 
-void Query_each_w_iter_no_this(void) {
-    flecs::world ecs;
-
-    auto e = ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    auto q = ecs.query_builder<Position, Velocity>()
-        .arg(1).src(e)
-        .arg(2).src(e)
-        .build();
-
-    int32_t count = 0;
-
-    q.each([&](flecs::iter& it, size_t index, Position& p, Velocity& v) {
-        count ++;
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-        test_int(v.x, 1);
-        test_int(v.y, 2);
-        test_int(index, 0);
-        test_int(it.count(), 0);
-    });
-
-    test_int(count, 1);
-}
-
 void Query_invalid_field_from_each_w_iter(void) {
     install_test_abort();
 
@@ -1884,7 +2321,7 @@ void Query_invalid_field_from_each_w_iter(void) {
     test_expect_abort();
 
     q.each([&](flecs::iter& it, size_t index, Position& p) {
-        it.field(2); // not allowed from each
+        it.field(1); // not allowed from each
     });
 }
 
@@ -1904,7 +2341,7 @@ void Query_invalid_field_T_from_each_w_iter(void) {
     test_expect_abort();
 
     q.each([&](flecs::iter& it, size_t index, Position& p) {
-        it.field<Velocity>(2); // not allowed from each
+        it.field<Velocity>(1); // not allowed from each
     });
 }
 
@@ -1924,7 +2361,7 @@ void Query_invalid_field_const_T_from_each_w_iter(void) {
     test_expect_abort();
 
     q.each([&](flecs::iter& it, size_t index, Position& p) {
-        it.field<const Velocity>(2); // not allowed from each
+        it.field<const Velocity>(1); // not allowed from each
     });
 }
 
@@ -1946,7 +2383,7 @@ void Query_field_at_from_each_w_iter(void) {
     int32_t count = 0;
 
     q.each([&](flecs::iter& it, size_t row, Position& p) {
-        Velocity* v = static_cast<Velocity*>(it.field_at(2, row));
+        Velocity* v = static_cast<Velocity*>(it.field_at(1, row));
         if (it.entity(row) == e1) {
             test_int(v->x, 1);
             test_int(v->y, 2);
@@ -1979,7 +2416,7 @@ void Query_field_at_T_from_each_w_iter(void) {
     int32_t count = 0;
 
     q.each([&](flecs::iter& it, size_t row, Position& p) {
-        Velocity& v = it.field_at<Velocity>(2, row);
+        Velocity& v = it.field_at<Velocity>(1, row);
         if (it.entity(row) == e1) {
             test_int(v.x, 1);
             test_int(v.y, 2);
@@ -2012,7 +2449,7 @@ void Query_field_at_const_T_from_each_w_iter(void) {
     int32_t count = 0;
 
     q.each([&](flecs::iter& it, size_t row, Position& p) {
-        const Velocity& v = it.field_at<const Velocity>(2, row);
+        const Velocity& v = it.field_at<const Velocity>(1, row);
         if (it.entity(row) == e1) {
             test_int(v.x, 1);
             test_int(v.y, 2);
@@ -2057,7 +2494,7 @@ void Query_field_at_from_each_w_iter_w_base_type(void) {
     int32_t count = 0;
 
     q.each([&](flecs::iter& it, size_t row, Position& p) {
-        Velocity* v = static_cast<Velocity*>(it.field_at(2, row));
+        Velocity* v = static_cast<Velocity*>(it.field_at(1, row));
         if (it.entity(row) == e1) {
             test_int(v->x, 1);
             test_int(v->y, 2);
@@ -2076,7 +2513,9 @@ void Query_change_tracking(void) {
     flecs::world w;
 
     auto qw = w.query<Position>();
-    auto qr = w.query<const Position>();
+    auto qr = w.query_builder<const Position>()
+        .cached()
+        .build();
 
     auto e1 = w.entity().add<Tag>().set<Position>({10, 20});
     w.entity().set<Position>({20, 30});
@@ -2132,8 +2571,8 @@ void Query_not_w_write(void) {
     struct B {};
 
     auto q = ecs.query_builder()
-        .term<A>()
-        .term<B>().oper(flecs::Not).write()
+        .with<A>()
+        .with<B>().oper(flecs::Not).write()
         .build();
 
     auto e = ecs.entity().add<A>();
@@ -2156,164 +2595,16 @@ void Query_not_w_write(void) {
     test_int(1, count);
 }
 
-void Query_get_first(void) {
-    flecs::world ecs;
-
-    struct A {};
-
-    auto e1 = ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q = ecs.query<A>();
-
-    auto first = q.iter().first();
-    test_assert(first != 0);
-    test_assert(first == e1);
-}
-
-void Query_get_first_direct(void) {
-    flecs::world ecs;
-
-    struct A {};
-
-    auto e1 = ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q = ecs.query<A>();
-
-    auto first = q.first();
-    test_assert(first != 0);
-    test_assert(first == e1);
-}
-
-void Query_get_count_direct(void) {
-    flecs::world ecs;
-
-    struct A {};
-
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q = ecs.query<A>();
-
-    test_int(3, q.count());
-}
-
-void Query_get_is_true_direct(void) {
-    flecs::world ecs;
-
-    struct A {};
-    struct B {};
-
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q_1 = ecs.query<A>();
-    auto q_2 = ecs.query<B>();
-
-    test_bool(true, q_1.is_true());
-    test_bool(false, q_2.is_true());
-}
-
-void Query_each_w_no_this(void) {
-    flecs::world ecs;
-
-    auto e = ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    auto q = ecs.query_builder<Position, Velocity>()
-        .arg(1).src(e)
-        .arg(2).src(e)
-        .build();
-
-    int32_t count = 0;
-
-    q.each([&](Position& p, Velocity& v) {
-        count ++;
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-        test_int(v.x, 1);
-        test_int(v.y, 2);
-    });
-
-    test_int(count, 1);
-}
-
-void Query_invalid_each_w_no_this(void) {
-    install_test_abort();
-
-    flecs::world ecs;
-
-    auto e = ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    auto q = ecs.query_builder<Position, Velocity>()
-        .arg(1).src(e)
-        .arg(2).src(e)
-        .build();
-
-    test_expect_abort();
-
-    q.each([&](flecs::entity e, Position& p, Velocity& v) { });
-}
-
-void Query_named_query(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>();
-
-    auto q = ecs.query<Position>("my_query");
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position&) {
-        test_assert(e == e1 || e == e2);
-        count ++;
-    });
-    test_int(count, 2);
-
-    flecs::entity qe = q.entity();
-    test_assert(qe != 0);
-    test_str(qe.name(), "my_query");
-}
-
-void Query_named_scoped_query(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>();
-
-    auto q = ecs.query<Position>("my::query");
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position&) {
-        test_assert(e == e1 || e == e2);
-        count ++;
-    });
-    test_int(count, 2);
-
-    flecs::entity qe = q.entity();
-    test_assert(qe != 0);
-    test_str(qe.name(), "query");
-    test_str(qe.path(), "::my::query");
-}
-
 void Query_instanced_nested_query_w_iter(void) {
     flecs::world ecs;
 
     flecs::query<> q1 = ecs.query_builder()
-        .term<Position>()
-        .term<Mass>().singleton()
+        .with<Position>()
+        .with<Mass>().singleton().inout()
         .build();
 
     flecs::query<> q2 = ecs.query_builder()
-        .term<Velocity>()
+        .with<Velocity>()
         .build();
 
     ecs.add<Mass>();
@@ -2337,12 +2628,12 @@ void Query_instanced_nested_query_w_entity(void) {
     flecs::world ecs;
 
     flecs::query<> q1 = ecs.query_builder()
-        .term<Position>()
-        .term<Mass>().singleton()
+        .with<Position>()
+        .with<Mass>().singleton().inout()
         .build();
 
     flecs::query<> q2 = ecs.query_builder()
-        .term<Velocity>()
+        .with<Velocity>()
         .build();
 
     ecs.add<Mass>();
@@ -2366,12 +2657,12 @@ void Query_instanced_nested_query_w_world(void) {
     flecs::world ecs;
 
     flecs::query<> q1 = ecs.query_builder()
-        .term<Position>()
-        .term<Mass>().singleton()
+        .with<Position>()
+        .with<Mass>().singleton().inout()
         .build();
 
     flecs::query<> q2 = ecs.query_builder()
-        .term<Velocity>()
+        .with<Velocity>()
         .build();
 
     ecs.add<Mass>();
@@ -2481,9 +2772,9 @@ void Query_iter_get_pair_w_id(void) {
     int32_t count = 0;
 
     q.each([&](flecs::iter& it, size_t i) {
-        test_bool(true, it.id(1).is_pair());
-        test_assert(it.id(1).first() == Rel);
-        test_assert(it.id(1).second() == Tgt);
+        test_bool(true, it.id(0).is_pair());
+        test_assert(it.id(0).first() == Rel);
+        test_assert(it.id(0).second() == Tgt);
         test_assert(e == it.entity(i));
         count ++;
     });
@@ -2491,79 +2782,51 @@ void Query_iter_get_pair_w_id(void) {
     test_int(count, 1);
 }
 
-void Query_find(void) {
+void Query_query_from_entity(void) {
     flecs::world ecs;
 
-    /* auto e1 = */ ecs.entity().set<Position>({10, 20});
-    auto e2 = ecs.entity().set<Position>({20, 30});
+    flecs::entity qe = ecs.entity();
+    flecs::query<Position, Velocity> q1 = ecs.query_builder<Position, Velocity>(qe)
+        .build();
 
-    auto q = ecs.query<Position>();
+    /* flecs::entity e1 = */ ecs.entity().add<Position>();
+    flecs::entity e2 = ecs.entity().add<Position>().add<Velocity>();
 
-    auto r = q.find([](Position& p) {
-        return p.x == 20;
+    int32_t count = 0;
+    q1.each([&](flecs::entity e, Position&, Velocity&) {
+        count ++;
+        test_assert(e == e2);
     });
+    test_int(count, 1);
 
-    test_assert(r == e2);
-}
-
-void Query_find_not_found(void) {
-    flecs::world ecs;
-
-    /* auto e1 = */ ecs.entity().set<Position>({10, 20});
-    /* auto e2 = */ ecs.entity().set<Position>({20, 30});
-
-    auto q = ecs.query<Position>();
-
-    auto r = q.find([](Position& p) {
-        return p.x == 30;
+    flecs::query<> q2 = ecs.query(qe);
+    q2.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
     });
-
-    test_assert(!r);
+    test_int(count, 2);
 }
 
-void Query_find_w_entity(void) {
+void Query_query_from_entity_name(void) {
     flecs::world ecs;
 
-    /* auto e1 = */ ecs.entity().set<Position>({10, 20}).set<Velocity>({20, 30});
-    auto e2 = ecs.entity().set<Position>({20, 30}).set<Velocity>({20, 30});
+    flecs::query<Position, Velocity> q1 = ecs.query_builder<Position, Velocity>("qe")
+        .build();
 
-    auto q = ecs.query<Position>();
+    /* flecs::entity e1 = */ ecs.entity().add<Position>();
+    flecs::entity e2 = ecs.entity().add<Position>().add<Velocity>();
 
-    auto r = q.find([](flecs::entity e, Position& p) {
-        return p.x == e.get<Velocity>()->x &&
-               p.y == e.get<Velocity>()->y;
+    int32_t count = 0;
+    q1.each([&](flecs::entity e, Position&, Velocity&) {
+        count ++;
+        test_assert(e == e2);
     });
+    test_int(count, 1);
 
-    test_assert(r == e2);
-}
-
-void Query_optional_pair_term(void) {
-    flecs::world ecs;
-
-    ecs.entity()
-        .add<TagA>()
-        .emplace<Position, Tag>(1.0f, 2.0f);
-    ecs.entity()
-        .add<TagA>();
-
-    int32_t with_pair = 0, without_pair = 0;
-
-    auto f = ecs.query_builder<flecs::pair<Position, Tag>*>()
-        .with<TagA>()
-        .build();
-        
-    f.each([&](flecs::entity e, Position* p) {
-        if (p) {
-            with_pair++;
-            test_flt(1.0f, p->x);
-            test_flt(2.0f, p->y);
-        } else {
-            without_pair++;
-        }
+    flecs::query<> q2 = ecs.query("qe");
+    q2.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
     });
-
-    ecs.progress(1.0);
-
-    test_int(1, with_pair);
-    test_int(1, without_pair);
+    test_int(count, 2);
 }
diff --git a/test/cpp/src/QueryBuilder.cpp b/test/cpp/src/QueryBuilder.cpp
new file mode 100644
index 000000000..517695894
--- /dev/null
+++ b/test/cpp/src/QueryBuilder.cpp
@@ -0,0 +1,4724 @@
+#include <cpp.h>
+
+static flecs::query_cache_kind_t cache_kind = flecs::QueryCacheDefault;
+
+void QueryBuilder_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = flecs::QueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+struct Other {
+    int32_t value;
+};
+
+enum Color {
+    Red, Green, Blue
+};
+
+void QueryBuilder_builder_assign_same_type(void) {
+    flecs::world ecs;
+
+    flecs::query<Position, Velocity> q = 
+        ecs.query_builder<Position, Velocity>()
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p, Velocity& v) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_builder_assign_to_empty(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = ecs.query_builder<Position, Velocity>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_builder_assign_from_empty(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = ecs.query_builder<>()
+        .cache_kind(cache_kind)
+        .with<Position>()
+        .with<Velocity>()
+        .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_builder_build(void) {
+    flecs::world ecs;
+
+    flecs::query<Position, Velocity> q = 
+        ecs.query_builder<Position, Velocity>()
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p, Velocity& v) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_builder_build_to_auto(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Position, Velocity>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p, Velocity& v) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_builder_build_n_statements(void) {
+    flecs::world ecs;
+
+    auto qb = ecs.query_builder<>();
+    qb.with<Position>();
+    qb.with<Velocity>();
+    qb.cache_kind(cache_kind);
+    auto q = qb.build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_1_type(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_2_types(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    ecs.entity().set<Velocity>({10, 20});
+
+    auto r = ecs.query_builder<Position, const Velocity>()
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+    r.each([&](flecs::entity e, Position& p, const Velocity& v) {
+        count ++;
+        test_assert(e == e1);
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+
+        test_int(v.x, 1);
+        test_int(v.y, 2);
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_id_term(void) {
+    flecs::world ecs;
+
+    auto Tag = ecs.entity();
+
+    auto e1 = ecs.entity()
+        .add(Tag);
+
+    ecs.entity().set<Velocity>({10, 20});
+
+    auto r = ecs.query_builder()
+        .with(Tag)
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+    r.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_type_term(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity()
+        .set<Position>({10, 20});
+
+    ecs.entity().set<Velocity>({10, 20});
+
+    auto r = ecs.query_builder()
+        .with<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+    r.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_id_pair_term(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    auto e1 = ecs.entity()
+        .add(Likes, Apples);
+
+    ecs.entity()
+        .add(Likes, Pears);
+
+    auto r = ecs.query_builder()
+        .with(Likes, Apples)
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+    r.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_id_pair_wildcard_term(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    auto e1 = ecs.entity()
+        .add(Likes, Apples);
+
+    auto e2 = ecs.entity()
+        .add(Likes, Pears);
+
+    auto r = ecs.query_builder()
+        .with(Likes, flecs::Wildcard)
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+    r.each([&](flecs::iter& it, size_t index) {
+        if (it.entity(index) == e1) {
+            test_assert(it.id(0) == ecs.pair(Likes, Apples));
+            count ++;
+        }
+        if (it.entity(index) == e2) {
+            test_assert(it.id(0) == ecs.pair(Likes, Pears));
+            count ++;
+        }
+    });
+    test_int(count, 2);
+
+}
+
+void QueryBuilder_type_pair_term(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Apples { };
+    struct Pears { };
+
+    auto e1 = ecs.entity()
+        .add<Likes, Apples>();
+
+    auto e2 = ecs.entity()
+        .add<Likes, Pears>();
+
+    auto r = ecs.query_builder()
+        .with<Likes>(flecs::Wildcard)
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+    r.each([&](flecs::iter& it, size_t index) {
+        if (it.entity(index) == e1) {
+            test_assert((it.id(0) == ecs.pair<Likes, Apples>()));
+            count ++;
+        }
+        if (it.entity(index) == e2) {
+            test_assert((it.id(0) == ecs.pair<Likes, Pears>()));
+            count ++;
+        }
+    });
+    test_int(count, 2);
+
+}
+
+void QueryBuilder_pair_term_w_var(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Apples { };
+    struct Pears { };
+
+    auto e1 = ecs.entity()
+        .add<Likes, Apples>();
+
+    auto e2 = ecs.entity()
+        .add<Likes, Pears>();
+
+    auto r = ecs.query_builder()
+        .with<Likes>().second().var("Food")
+        .cache_kind(cache_kind)
+        .build();
+
+    int food_var = r.find_var("Food");
+
+    int count = 0;
+    r.each([&](flecs::iter& it, size_t index) {
+        if (it.entity(index) == e1) {
+            test_assert((it.id(0) == ecs.pair<Likes, Apples>()));
+            test_assert(it.get_var("Food") == ecs.id<Apples>());
+            test_assert(it.get_var(food_var) == ecs.id<Apples>());
+            count ++;
+        }
+        if (it.entity(index) == e2) {
+            test_assert((it.id(0) == ecs.pair<Likes, Pears>()));
+            test_assert(it.get_var("Food") == ecs.id<Pears>());
+            test_assert(it.get_var(food_var) == ecs.id<Pears>());
+            count ++;
+        }
+    });
+    test_int(count, 2);
+
+}
+
+void QueryBuilder_2_pair_terms_w_var(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Eats { };
+    struct Apples { };
+    struct Pears { };
+
+    auto Bob = ecs.entity()
+        .add<Eats, Apples>();
+
+    auto Alice = ecs.entity()
+        .add<Eats, Pears>()
+        .add<Likes>(Bob);
+
+    Bob.add<Likes>(Alice);
+
+    auto r = ecs.query_builder()
+        .with<Eats>().second().var("Food")
+        .with<Likes>().second().var("Person")
+        .cache_kind(cache_kind)
+        .build();
+
+    int food_var = r.find_var("Food");
+    int person_var = r.find_var("Person");
+
+    int count = 0;
+    r.each([&](flecs::iter& it, size_t index) {
+        if (it.entity(index) == Bob) {
+            test_assert((it.id(0) == ecs.pair<Eats, Apples>()));
+            test_assert(it.get_var("Food") == ecs.id<Apples>());
+            test_assert(it.get_var(food_var) == ecs.id<Apples>());
+
+            test_assert((it.id(1) == ecs.pair<Likes>(Alice)));
+            test_assert(it.get_var("Person") == Alice);
+            test_assert(it.get_var(person_var) == Alice);
+            count ++;
+        }
+        if (it.entity(index) == Alice) {
+            test_assert((it.id(0) == ecs.pair<Eats, Pears>()));
+            test_assert(it.get_var("Food") == ecs.id<Pears>());
+            test_assert(it.get_var(food_var) == ecs.id<Pears>());
+
+            test_assert((it.id(1) == ecs.pair<Likes>(Bob)));
+            test_assert(it.get_var("Person") == Bob);
+            test_assert(it.get_var(person_var) == Bob);
+            count ++;
+        }
+    });
+    test_int(count, 2);
+
+}
+
+void QueryBuilder_set_var(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    ecs.entity()
+        .add<Likes>(Apples);
+
+    auto e2 = ecs.entity()
+        .add<Likes>(Pears);
+
+    auto r = ecs.query_builder()
+        .with<Likes>().second().var("Food")
+        .cache_kind(cache_kind)
+        .build();
+
+    int food_var = r.find_var("Food");
+
+    int count = 0;
+    r.iter()
+        .set_var(food_var, Pears)
+        .each([&](flecs::iter& it, size_t index) {
+            test_assert(it.entity(index) == e2);
+            test_assert((it.id(0) == ecs.pair<Likes>(Pears)));
+            test_assert(it.get_var("Food") == Pears);
+            test_assert(it.get_var(food_var) == Pears);
+            count ++;
+        });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_set_2_vars(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Eats { };
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    auto Bob = ecs.entity()
+        .add<Eats>(Apples);
+
+    auto Alice = ecs.entity()
+        .add<Eats>(Pears)
+        .add<Likes>(Bob);
+
+    Bob.add<Likes>(Alice);
+
+    auto r = ecs.query_builder()
+        .with<Eats>().second().var("Food")
+        .with<Likes>().second().var("Person")
+        .cache_kind(cache_kind)
+        .build();
+
+    int food_var = r.find_var("Food");
+    int person_var = r.find_var("Person");
+
+    int count = 0;
+    r.iter()
+        .set_var(food_var, Pears)
+        .set_var(person_var, Bob)
+        .each([&](flecs::iter& it, size_t index) {
+            test_assert(it.entity(index) == Alice);
+            test_assert((it.id(0) == ecs.pair<Eats>(Pears)));
+            test_assert((it.id(1) == ecs.pair<Likes>(Bob)));
+            test_assert(it.get_var("Food") == Pears);
+            test_assert(it.get_var(food_var) == Pears);
+            test_assert(it.get_var("Person") == Bob);
+            test_assert(it.get_var(person_var) == Bob);
+            count ++;
+        });
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_set_var_by_name(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    ecs.entity()
+        .add<Likes>(Apples);
+
+    auto e2 = ecs.entity()
+        .add<Likes>(Pears);
+
+    auto r = ecs.query_builder()
+        .with<Likes>().second().var("Food")
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+    r.iter()
+        .set_var("Food", Pears)
+        .each([&](flecs::iter& it, size_t index) {
+            test_assert(it.entity(index) == e2);
+            test_assert((it.id(0) == ecs.pair<Likes>(Pears)));
+            count ++;
+        });
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_set_2_vars_by_name(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Eats { };
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    auto Bob = ecs.entity()
+        .add<Eats>(Apples);
+
+    auto Alice = ecs.entity()
+        .add<Eats>(Pears)
+        .add<Likes>(Bob);
+
+    Bob.add<Likes>(Alice);
+
+    auto r = ecs.query_builder()
+        .with<Eats>().second().var("Food")
+        .with<Likes>().second().var("Person")
+        .cache_kind(cache_kind)
+        .build();
+
+    int food_var = r.find_var("Food");
+    int person_var = r.find_var("Person");
+
+    int count = 0;
+    r.iter()
+        .set_var("Food", Pears)
+        .set_var("Person", Bob)
+        .each([&](flecs::iter& it, size_t index) {
+            test_assert(it.entity(index) == Alice);
+            test_assert((it.id(0) == ecs.pair<Eats>(Pears)));
+            test_assert((it.id(1) == ecs.pair<Likes>(Bob)));
+            test_assert(it.get_var("Food") == Pears);
+            test_assert(it.get_var(food_var) == Pears);
+            test_assert(it.get_var("Person") == Bob);
+            test_assert(it.get_var(person_var) == Bob);
+            count ++;
+        });
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_set_var_on_query(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    ecs.entity()
+        .add<Likes>(Apples);
+
+    auto e2 = ecs.entity()
+        .add<Likes>(Pears);
+
+    auto r = ecs.query_builder()
+        .with<Likes>().second().var("Food")
+        .cache_kind(cache_kind)
+        .build();
+
+    int food_var = r.find_var("Food");
+
+    int count = 0;
+    r.set_var(food_var, Pears)
+     .each([&](flecs::iter& it, size_t index) {
+         test_assert(it.entity(index) == e2);
+         test_assert((it.id(0) == ecs.pair<Likes>(Pears)));
+         test_assert(it.get_var("Food") == Pears);
+         test_assert(it.get_var(food_var) == Pears);
+         count ++;
+     });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_set_var_by_name_on_query(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    ecs.entity()
+        .add<Likes>(Apples);
+
+    auto e2 = ecs.entity()
+        .add<Likes>(Pears);
+
+    auto r = ecs.query_builder()
+        .with<Likes>().second().var("Food")
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+    r.set_var("Food", Pears)
+     .each([&](flecs::iter& it, size_t index) {
+         test_assert(it.entity(index) == e2);
+         test_assert((it.id(0) == ecs.pair<Likes>(Pears)));
+         test_assert(it.get_var("Food") == Pears);
+         count ++;
+     });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_set_table_var(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Position>();
+    auto e3 = ecs.entity().add<Position>().add<Velocity>();
+
+    auto r = ecs.query_builder<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+    r.set_var("this", e1.table())
+     .each([&](flecs::iter& it, size_t index, Position&) {
+        if (index == 0) {
+            test_assert(it.entity(index) == e1);
+        } else if (index == 1) {
+            test_assert(it.entity(index) == e2);
+        }
+        count ++;
+     });
+
+    test_int(count, 2);
+
+    r.set_var("this", e3.table())
+     .each([&](flecs::iter& it, size_t index, Position&) {
+        test_assert(it.entity(index) == e3);
+        count ++;
+     });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_set_range_var(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Position>();
+    auto e3 = ecs.entity().add<Position>().add<Velocity>();
+
+    auto r = ecs.query_builder<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+
+    r.set_var("this", e1.range())
+     .each([&](flecs::iter& it, size_t index, Position&) {
+        test_assert(it.entity(index) == e1);
+        count ++;
+     });
+
+    test_int(count, 1);
+
+    r.set_var("this", e2.range())
+     .each([&](flecs::iter& it, size_t index, Position&) {
+        test_assert(it.entity(index) == e2);
+        count ++;
+     });
+
+    test_int(count, 2);
+
+    r.set_var("this", e3.range())
+     .each([&](flecs::iter& it, size_t index, Position&) {
+        test_assert(it.entity(index) == e3);
+        count ++;
+     });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_set_table_var_chained(void) {
+    flecs::world ecs;
+
+    /* auto e1 = */ ecs.entity().add<Position>();
+    /* auto e2 = */ ecs.entity().add<Position>();
+    auto e3 = ecs.entity().add<Position>().add<Velocity>();
+    /* auto e4 = */ ecs.entity().add<Velocity>();
+
+    auto q1 = ecs.query_builder<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto q2 = ecs.query_builder<Velocity>()
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+
+    q1.iter([&](flecs::iter& it, Position*) {
+        q2.set_var("this", it.table()).each([&](flecs::entity e, Velocity&) {
+            test_assert(e == e3);
+            count ++;
+        });
+    });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_set_range_var_chained(void) {
+    flecs::world ecs;
+
+    /* auto e1 = */ ecs.entity().add<Position>();
+    /* auto e2 = */ ecs.entity().add<Position>();
+    auto e3 = ecs.entity().add<Position>().add<Velocity>();
+    /* auto e4 = */ ecs.entity().add<Velocity>();
+
+    auto q1 = ecs.query_builder<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto q2 = ecs.query_builder<Velocity>()
+        .cache_kind(cache_kind)
+        .build();
+
+    int count = 0;
+
+    q1.iter([&](flecs::iter& it, Position*) {
+        q2.set_var("this", it.range()).each([&](flecs::entity e, Velocity&) {
+            test_assert(e == e3);
+            count ++;
+        });
+    });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_expr_w_var(void) {
+    flecs::world ecs;
+
+    auto rel = ecs.entity("Rel");
+    auto obj = ecs.entity();
+    auto e = ecs.entity().add(rel, obj);
+
+    auto r = ecs.query_builder()
+        .expr("(Rel, $X)")
+        .cache_kind(cache_kind)
+        .build();
+
+    int x_var = r.find_var("X");
+    test_assert(x_var != -1);
+
+    int32_t count = 0;
+    r.each([&](flecs::iter& it, size_t index) {
+        test_assert(it.entity(index) == e);
+        test_assert(it.pair(0).second() == obj);
+        count ++;
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_add_1_type(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<>()
+        .with<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_add_2_types(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<>()
+        .with<Position>()
+        .with<Velocity>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_add_1_type_w_1_type(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Position>()
+        .with<Velocity>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_add_2_types_w_1_type(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Position>()
+        .with<Velocity>()
+        .with<Mass>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>().add<Mass>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_add_pair(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Bob = ecs.entity();
+    auto Alice = ecs.entity();
+
+    auto q = ecs.query_builder<>()
+        .with(Likes, Bob)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add(Likes, Bob);
+    ecs.entity().add(Likes, Alice);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_add_not(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Position>()
+        .with<Velocity>().oper(flecs::Not)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    ecs.entity().add<Position>().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_add_or(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<>()
+        .with<Position>().oper(flecs::Or)
+        .with<Velocity>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Velocity>();
+    ecs.entity().add<Mass>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1 || e == e2);
+    });
+    
+    test_int(count, 2);
+}
+
+void QueryBuilder_add_optional(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<>()
+        .with<Position>()
+        .with<Velocity>().oper(flecs::Optional)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Velocity>().add<Mass>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1 || e == e2);
+    });
+    
+    test_int(count, 2);
+}
+
+void QueryBuilder_ptr_type(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Position, Velocity*>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Velocity>().add<Mass>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p, Velocity* v) {
+        count ++;
+        test_assert(e == e1 || e == e2);
+    });
+    
+    test_int(count, 2);
+}
+
+void QueryBuilder_const_type(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<const Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, const Position& p) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_string_term(void) {
+    flecs::world ecs;
+
+    ecs.component<Position>();
+
+    auto q = ecs.query_builder<>()
+        .expr("Position")
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_singleton_term(void) {
+    flecs::world ecs;
+
+    ecs.set<Other>({10});
+
+    auto q = ecs.query_builder<Self>()
+        .with<Other>().singleton().inout()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto 
+    e = ecs.entity(); e.set<Self>({e});
+    e = ecs.entity(); e.set<Self>({e});
+    e = ecs.entity(); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.iter([&](flecs::iter& it, Self *s) {
+        auto o = it.field<const Other>(1);
+        test_assert(!it.is_self(1));
+        test_int(o->value, 10);
+        
+        const Other& o_ref = *o;
+        test_int(o_ref.value, 10);
+
+        for (auto i : it) {
+            test_assert(it.entity(i) == s[i].value);
+            count ++;
+        }
+    });
+    
+    test_int(count, 3);
+}
+
+void QueryBuilder_isa_superset_term(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self>()
+        .with<Other>().src().up(flecs::IsA).in()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.iter([&](flecs::iter& it, Self *s) {
+        auto o = it.field<const Other>(1);
+        test_assert(!it.is_self(1));
+        test_int(o->value, 10);
+
+        for (auto i : it) {
+            test_assert(it.entity(i) == s[i].value);
+            count ++;
+        }
+    });
+    
+    test_int(count, 3);
+}
+
+void QueryBuilder_isa_self_superset_term(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self>()
+        .with<Other>().src().self().up(flecs::IsA).in()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
+    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
+
+    int32_t count = 0;
+    int32_t owned_count = 0;
+
+    q.iter([&](flecs::iter& it, Self *s) {
+        auto o = it.field<const Other>(1);
+
+        if (!it.is_self(1)) {
+            test_int(o->value, 10);
+        } else {
+            for (auto i : it) {
+                test_int(o[i].value, 20);
+                owned_count ++;
+            }
+        }
+
+        for (auto i : it) {
+            test_assert(it.entity(i) == s[i].value);
+            count ++;
+        }
+    });
+    
+    test_int(count, 5);
+    test_int(owned_count, 2);
+}
+
+void QueryBuilder_childof_superset_term(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self>()
+        .with<Other>().src().up().in()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.iter([&](flecs::iter& it, Self *s) {
+        auto o = it.field<const Other>(1);
+        test_assert(!it.is_self(1));
+        test_int(o->value, 10);
+
+        for (auto i : it) {
+            test_assert(it.entity(i) == s[i].value);
+            count ++;
+        }
+    });
+    
+    test_int(count, 3);
+}
+
+void QueryBuilder_childof_self_superset_term(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self>()
+        .with<Other>().src().self().up().in()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
+    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
+
+    int32_t count = 0;
+    int32_t owned_count = 0;
+
+    q.iter([&](flecs::iter& it, Self *s) {
+        auto o = it.field<const Other>(1);
+
+        if (!it.is_self(1)) {
+            test_int(o->value, 10);
+        } else {
+            for (auto i : it) {
+                test_int(o[i].value, 20);
+                owned_count ++;
+            }
+        }
+
+        for (auto i : it) {
+            test_assert(it.entity(i) == s[i].value);
+            count ++;
+        }
+    });
+    
+    test_int(count, 5);
+    test_int(owned_count, 2);
+}
+
+void QueryBuilder_isa_superset_term_w_each(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self, Other>()
+        .term_at(1).src().up(flecs::IsA)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s, Other& o) {
+        test_assert(e == s.value);
+        test_int(o.value, 10);
+        count ++;
+    });
+    
+    test_int(count, 3);
+}
+
+void QueryBuilder_isa_self_superset_term_w_each(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self, Other>()
+        .term_at(1).src().self().up(flecs::IsA)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
+    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
+    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s, Other& o) {
+        test_assert(e == s.value);
+        test_int(o.value, 10);
+        count ++;
+    });
+    
+    test_int(count, 5);
+}
+
+void QueryBuilder_childof_superset_term_w_each(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self, Other>()
+        .term_at(1).src().up()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s, Other& o) {
+        test_assert(e == s.value);
+        test_int(o.value, 10);
+        count ++;
+    });
+    
+    test_int(count, 3);
+}
+
+void QueryBuilder_childof_self_superset_term_w_each(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self, Other>()
+        .term_at(1).src().self().up()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
+    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s, Other& o) {
+        test_assert(e == s.value);
+        test_int(o.value, 10);
+        count ++;
+    });
+    
+    test_int(count, 5);
+}
+
+void QueryBuilder_isa_superset_shortcut(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self, Other>()
+        .term_at(1).up(flecs::IsA)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().is_a(base); e.set<Self>({e});
+    e = ecs.entity().is_a(base); e.set<Self>({e});
+    e = ecs.entity().is_a(base); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s, Other& o) {
+        test_assert(e == s.value);
+        test_int(o.value, 10);
+        count ++;
+    });
+    
+    test_int(count, 3);
+}
+
+void QueryBuilder_isa_superset_shortcut_w_self(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self, Other>()
+        .term_at(1).self().up(flecs::IsA)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().is_a(base); e.set<Self>({e});
+    e = ecs.entity().is_a(base); e.set<Self>({e});
+    e = ecs.entity().is_a(base); e.set<Self>({e});
+    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
+    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s, Other& o) {
+        test_assert(e == s.value);
+        test_int(o.value, 10);
+        count ++;
+    });
+    
+    test_int(count, 5);
+}
+
+void QueryBuilder_childof_superset_shortcut(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self, Other>()
+        .term_at(1).up()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s, Other& o) {
+        test_assert(e == s.value);
+        test_int(o.value, 10);
+        count ++;
+    });
+    
+    test_int(count, 3);
+}
+
+void QueryBuilder_childof_superset_shortcut_w_self(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Self, Other>()
+        .term_at(1).self().up()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().child_of(base); e.set<Self>({e});
+    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
+    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s, Other& o) {
+        test_assert(e == s.value);
+        test_int(o.value, 10);
+        count ++;
+    });
+    
+    test_int(count, 5);
+}
+
+void QueryBuilder_relation(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Bob = ecs.entity();
+    auto Alice = ecs.entity();
+
+    auto q = ecs.query_builder<Self>()
+        .with(Likes, Bob)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto 
+    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
+    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
+
+    e = ecs.entity().add(Likes, Alice); e.set<Self>({0});
+    e = ecs.entity().add(Likes, Alice); e.set<Self>({0});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+    
+    test_int(count, 2);
+}
+
+void QueryBuilder_relation_w_object_wildcard(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Bob = ecs.entity();
+    auto Alice = ecs.entity();
+
+    auto q = ecs.query_builder<Self>()
+        .with(Likes, flecs::Wildcard)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto 
+    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
+    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
+
+    e = ecs.entity().add(Likes, Alice); e.set<Self>({e});
+    e = ecs.entity().add(Likes, Alice); e.set<Self>({e});
+
+    e = ecs.entity(); e.set<Self>({0});
+    e = ecs.entity(); e.set<Self>({0});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+    
+    test_int(count, 4);
+}
+
+void QueryBuilder_relation_w_predicate_wildcard(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Dislikes = ecs.entity();
+    auto Bob = ecs.entity();
+    auto Alice = ecs.entity();
+
+    auto q = ecs.query_builder<Self>()
+        .with(flecs::Wildcard, Alice)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto 
+    e = ecs.entity().add(Likes, Alice); e.set<Self>({e});
+    e = ecs.entity().add(Dislikes, Alice); e.set<Self>({e});
+
+    e = ecs.entity().add(Likes, Bob); e.set<Self>({0});
+    e = ecs.entity().add(Dislikes, Bob); e.set<Self>({0});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+    
+    test_int(count, 2);
+}
+
+void QueryBuilder_add_pair_w_rel_type(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    
+    auto Dislikes = ecs.entity();
+    auto Bob = ecs.entity();
+    auto Alice = ecs.entity();
+
+    auto q = ecs.query_builder<Self>()
+        .with<Likes>(flecs::Wildcard)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto 
+    e = ecs.entity().add<Likes>(Alice); e.set<Self>({e});
+    e = ecs.entity().add(Dislikes, Alice); e.set<Self>({0});
+
+    e = ecs.entity().add<Likes>(Bob); e.set<Self>({e});
+    e = ecs.entity().add(Dislikes, Bob); e.set<Self>({0});
+
+    int32_t count = 0;
+
+    q.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+    
+    test_int(count, 2);
+}
+
+void QueryBuilder_template_term(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Position>()
+        .with<Template<int>>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Template<int>>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_explicit_subject_w_id(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<Position>()
+        .with<Position>().id(flecs::This)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_explicit_subject_w_type(void) {
+    flecs::world ecs;
+
+    ecs.set<Position>({10, 20});
+
+    auto q = ecs.query_builder<Position>()
+        .with<Position>().src<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position& p) {
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+        count ++;
+        test_assert(e == ecs.singleton<Position>());
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_explicit_object_w_id(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Alice = ecs.entity();
+    auto Bob = ecs.entity();
+
+    auto q = ecs.query_builder<>()
+        .with(Likes).second(Alice)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add(Likes, Alice);
+    ecs.entity().add(Likes, Bob);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_explicit_object_w_type(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    struct Alice { };
+    auto Bob = ecs.entity();
+
+    auto q = ecs.query_builder<>()
+        .with(Likes).second<Alice>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add(Likes, ecs.id<Alice>());
+    ecs.entity().add(Likes, Bob);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_explicit_term(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<>()
+        .with(ecs.term(ecs.id<Position>()))
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_explicit_term_w_type(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder<>()
+        .with(ecs.term<Position>())
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+    ecs.entity().add<Velocity>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_explicit_term_w_pair_type(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Alice { };
+    struct Bob { };
+
+    auto q = ecs.query_builder<>()
+        .with(ecs.term<Likes, Alice>())
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Likes, Alice>();
+    ecs.entity().add<Likes, Bob>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_explicit_term_w_id(void) {
+    flecs::world ecs;
+
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    auto q = ecs.query_builder<>()
+        .with(ecs.term(Apples))
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add(Apples);
+    ecs.entity().add(Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_explicit_term_w_pair_id(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Apples = ecs.entity();
+    auto Pears = ecs.entity();
+
+    auto q = ecs.query_builder<>()
+        .with(ecs.term(Likes, Apples))
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add(Likes, Apples);
+    ecs.entity().add(Likes, Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_1_term_to_empty(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Apples = ecs.entity();
+
+    auto qb = ecs.query_builder<>()
+        .with<Position>()
+        .cache_kind(cache_kind);
+
+    qb.with(Likes, Apples);
+
+    auto q = qb.build();
+
+    test_int(q.field_count(), 2);
+    test_int(q.term(0).id(), ecs.id<Position>());
+    test_int(q.term(1).id(), ecs.pair(Likes, Apples));
+}
+
+void QueryBuilder_2_subsequent_args(void) {
+    flecs::world ecs;
+
+    struct Rel { int foo; };
+
+    int32_t count = 0;
+
+    auto s = ecs.system<Rel, const Velocity>()
+        .term_at(0).second(flecs::Wildcard)
+        .term_at(1).singleton()
+        .iter([&](flecs::iter it){
+            count += it.count();
+        });
+    
+    ecs.entity().add<Rel, Tag>();
+    ecs.set<Velocity>({});
+
+    s.run();
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_optional_tag_is_set(void) {
+    flecs::world ecs;
+
+    struct TagA { };
+    struct TagB { };
+
+    auto q = ecs.query_builder()
+        .with<TagA>()
+        .with<TagB>().oper(flecs::Optional)
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e_1 = ecs.entity().add<TagA>().add<TagB>();
+    auto e_2 = ecs.entity().add<TagA>();
+
+    int count = 0;
+
+    q.iter([&](flecs::iter& it) {
+        test_int(it.count(), 1);
+
+        count += it.count();
+        
+        if (it.entity(0) == e_1) {
+            test_bool(it.is_set(0), true);
+            test_bool(it.is_set(1), true);
+        } else {
+            test_assert(it.entity(0) == e_2);
+            test_bool(it.is_set(0), true);
+            test_bool(it.is_set(1), false);
+        }
+    });
+
+    test_int(count, 2);
+}
+
+void QueryBuilder_10_terms(void) {
+    flecs::world ecs;
+
+    auto f = ecs.query_builder<>()
+        .with<TagA>()
+        .with<TagB>()
+        .with<TagC>()
+        .with<TagD>()
+        .with<TagE>()
+        .with<TagF>()
+        .with<TagG>()
+        .with<TagH>()
+        .with<TagI>()
+        .with<TagJ>()
+        .cache_kind(cache_kind)
+        .build();
+
+    test_int(f.field_count(), 10);
+
+    auto e = ecs.entity()
+        .add<TagA>()
+        .add<TagB>()
+        .add<TagC>()
+        .add<TagD>()
+        .add<TagE>()
+        .add<TagF>()
+        .add<TagG>()
+        .add<TagH>()
+        .add<TagI>()
+        .add<TagJ>();
+
+    int count = 0;
+    f.iter([&](flecs::iter& it) {
+        test_int(it.count(), 1);
+        test_assert(it.entity(0) == e);
+        test_int(it.field_count(), 10);
+        count ++;
+    });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_16_terms(void) {
+    flecs::world ecs;
+
+    auto f = ecs.query_builder<>()
+        .with<TagA>()
+        .with<TagB>()
+        .with<TagC>()
+        .with<TagD>()
+        .with<TagE>()
+        .with<TagF>()
+        .with<TagG>()
+        .with<TagH>()
+        .with<TagI>()
+        .with<TagJ>()
+        .with<TagK>()
+        .with<TagL>()
+        .with<TagM>()
+        .with<TagN>()
+        .with<TagO>()
+        .with<TagP>()
+        .cache_kind(cache_kind)
+        .build();
+
+    test_int(f.field_count(), 16);
+
+    auto e = ecs.entity()
+        .add<TagA>()
+        .add<TagB>()
+        .add<TagC>()
+        .add<TagD>()
+        .add<TagE>()
+        .add<TagF>()
+        .add<TagG>()
+        .add<TagH>()
+        .add<TagI>()
+        .add<TagJ>()
+        .add<TagK>()
+        .add<TagL>()
+        .add<TagM>()
+        .add<TagN>()
+        .add<TagO>()
+        .add<TagP>()
+        .add<TagQ>()
+        .add<TagR>()
+        .add<TagS>()
+        .add<TagT>();
+
+    int count = 0;
+    f.iter([&](flecs::iter& it) {
+        test_int(it.count(), 1);
+        test_assert(it.entity(0) == e);
+        test_int(it.field_count(), 16);
+        count ++;
+    });
+
+    test_int(count, 1);
+}
+
+uint64_t group_by_first_id(
+    flecs::world_t *m_world,
+    flecs::table_t *m_table,
+    flecs::entity_t id,
+    void *ctx)
+{
+    const flecs::type_t *type = ecs_table_get_type(m_table);
+    return type->array[0];
+}
+
+uint64_t group_by_first_id_negated(
+    flecs::world_t *m_world,
+    flecs::table_t *m_table,
+    flecs::entity_t id,
+    void *ctx)
+{
+    return ~group_by_first_id(m_world, m_table, id, ctx);
+}
+
+void QueryBuilder_group_by_raw(void) {
+    flecs::world ecs;
+
+    struct TagA { };
+    struct TagB { };
+    struct TagC { };
+    struct TagX { };
+
+    ecs.component<TagA>();
+    ecs.component<TagB>();
+    ecs.component<TagC>();
+    ecs.component<TagX>();
+
+    auto q = ecs.query_builder()
+        .with<TagX>()
+        .group_by(flecs::type_id<TagX>(), group_by_first_id)
+        .build();
+
+    auto q_reverse = ecs.query_builder()
+        .with<TagX>()
+        .group_by(flecs::type_id<TagX>(), group_by_first_id_negated)
+        .build();
+
+    auto e3 = ecs.entity().add<TagX>().add<TagC>();
+    auto e2 = ecs.entity().add<TagX>().add<TagB>();
+    auto e1 = ecs.entity().add<TagX>().add<TagA>();
+
+    int count = 0;
+
+    q.iter([&](flecs::iter& it){
+        test_int(it.count(), 1);
+        if(count == 0){
+            test_bool(it.entity(0) == e1, true);
+        }else if(count == 1){
+            test_bool(it.entity(0) == e2, true);
+        }else if(count == 2){
+            test_bool(it.entity(0) == e3, true);
+        }else{
+            test_assert(false);
+        }
+        count++;
+    });
+    test_int(count, 3);
+    
+    count = 0;
+    q_reverse.iter([&](flecs::iter& it){
+        test_int(it.count(), 1);
+        if(count == 0){
+            test_bool(it.entity(0) == e3, true);
+        }else if(count == 1){
+            test_bool(it.entity(0) == e2, true);
+        }else if(count == 2){
+            test_bool(it.entity(0) == e1, true);
+        }else{
+            test_assert(false);
+        }
+        count++;
+    });
+    test_int(count, 3);
+}
+
+void QueryBuilder_group_by_template(void) {
+    flecs::world ecs;
+
+    struct TagA { };
+    struct TagB { };
+    struct TagC { };
+    struct TagX { };
+
+    ecs.component<TagA>();
+    ecs.component<TagB>();
+    ecs.component<TagC>();
+    ecs.component<TagX>();
+
+    auto q = ecs.query_builder()
+        .with<TagX>()
+        .group_by<TagX>(group_by_first_id)
+        .build();
+
+    auto q_reverse = ecs.query_builder()
+        .with<TagX>()
+        .group_by<TagX>( group_by_first_id_negated)
+        .build();
+
+    auto e3 = ecs.entity().add<TagX>().add<TagC>();
+    auto e2 = ecs.entity().add<TagX>().add<TagB>();
+    auto e1 = ecs.entity().add<TagX>().add<TagA>();
+
+    int count = 0;
+
+    q.iter([&](flecs::iter& it){
+        test_int(it.count(), 1);
+        if(count == 0){
+            test_bool(it.entity(0) == e1, true);
+        }else if(count == 1){
+            test_bool(it.entity(0) == e2, true);
+        }else if(count == 2){
+            test_bool(it.entity(0) == e3, true);
+        }else{
+            test_assert(false);
+        }
+        count++;
+    });
+    test_int(count, 3);
+    
+    count = 0;
+    q_reverse.iter([&](flecs::iter& it){
+        test_int(it.count(), 1);
+        if(count == 0){
+            test_bool(it.entity(0) == e3, true);
+        }else if(count == 1){
+            test_bool(it.entity(0) == e2, true);
+        }else if(count == 2){
+            test_bool(it.entity(0) == e1, true);
+        }else{
+            test_assert(false);
+        }
+        count++;
+    });
+    test_int(count, 3);
+}
+
+static
+uint64_t group_by_rel(flecs::world_t *world, flecs::table_t *table, flecs::entity_t id, void *ctx) {
+    ecs_id_t match;
+    if (ecs_search(world, table, ecs_pair(id, EcsWildcard), &match) != -1) {
+        return ECS_PAIR_SECOND(match);
+    }
+    return 0;
+}
+
+void QueryBuilder_group_by_iter_one(void) {
+    flecs::world ecs;
+
+    auto Rel = ecs.entity();
+    auto TgtA = ecs.entity();
+    auto TgtB = ecs.entity();
+    auto TgtC = ecs.entity();
+    auto Tag = ecs.entity();
+
+    ecs.entity().add(Rel, TgtA);
+    auto e2 = ecs.entity().add(Rel, TgtB);
+    ecs.entity().add(Rel, TgtC);
+
+    ecs.entity().add(Rel, TgtA).add(Tag);
+    auto e5 = ecs.entity().add(Rel, TgtB).add(Tag);
+    ecs.entity().add(Rel, TgtC).add(Tag);
+
+    auto q = ecs.query_builder()
+        .with(Rel, flecs::Wildcard)
+        .group_by(Rel, group_by_rel)
+        .build();
+
+    bool e2_found = false;
+    bool e5_found = false;
+    int32_t count = 0;
+
+    q.iter().set_group(TgtB).each([&](flecs::iter& it, size_t i) {
+        flecs::entity e = it.entity(i);
+        test_assert(it.group_id() == TgtB);
+
+        if (e == e2) e2_found = true;
+        if (e == e5) e5_found = true;
+        count ++;
+    });
+
+    test_int(2, count);
+    test_bool(true, e2_found);
+    test_bool(true, e5_found);
+}
+
+void QueryBuilder_group_by_iter_one_template(void) {
+    flecs::world ecs;
+
+    struct Rel { };
+    struct TgtA { };
+    struct TgtB { };
+    struct TgtC { };
+    struct Tag { };
+
+    ecs.entity().add<Rel, TgtA>();
+    auto e2 = ecs.entity().add<Rel, TgtB>();
+    ecs.entity().add<Rel, TgtC>();
+
+    ecs.entity().add<Rel, TgtA>().add<Tag>();
+    auto e5 = ecs.entity().add<Rel, TgtB>().add<Tag>();
+    ecs.entity().add<Rel, TgtC>().add<Tag>();
+
+    auto q = ecs.query_builder()
+        .with<Rel>(flecs::Wildcard)
+        .group_by<Rel>(group_by_rel)
+        .build();
+
+    bool e2_found = false;
+    bool e5_found = false;
+    int32_t count = 0;
+
+    q.iter().set_group<TgtB>().each([&](flecs::iter& it, size_t i) {
+        flecs::entity e = it.entity(i);
+        test_assert(it.group_id() == ecs.id<TgtB>());
+
+        if (e == e2) e2_found = true;
+        if (e == e5) e5_found = true;
+        count ++;
+    });
+
+    test_int(2, count);
+    test_bool(true, e2_found);
+    test_bool(true, e5_found);
+}
+
+void QueryBuilder_group_by_iter_one_all_groups(void) {
+    flecs::world ecs;
+
+    auto Rel = ecs.entity();
+    auto TgtA = ecs.entity();
+    auto TgtB = ecs.entity();
+    auto TgtC = ecs.entity();
+    auto Tag = ecs.entity();
+
+    auto e1 = ecs.entity().add(Rel, TgtA);
+    auto e2 = ecs.entity().add(Rel, TgtB);
+    auto e3 = ecs.entity().add(Rel, TgtC);
+
+    auto e4 = ecs.entity().add(Rel, TgtA).add(Tag);
+    auto e5 = ecs.entity().add(Rel, TgtB).add(Tag);
+    auto e6 = ecs.entity().add(Rel, TgtC).add(Tag);
+
+    auto q = ecs.query_builder()
+        .with(Rel, flecs::Wildcard)
+        .group_by(Rel, group_by_rel)
+        .build();
+
+    int e1_found = 0;
+    int e2_found = 0;
+    int e3_found = 0;
+    int e4_found = 0;
+    int e5_found = 0;
+    int e6_found = 0;
+    int32_t count = 0;
+    uint64_t group_id = 0;
+
+    const auto func = [&](flecs::iter& it, size_t i) {
+        flecs::entity e = it.entity(i);
+        test_assert(it.group_id() == group_id);
+        if (e == e1) e1_found ++;
+        if (e == e2) e2_found ++;
+        if (e == e3) e3_found ++;
+        if (e == e4) e4_found ++;
+        if (e == e5) e5_found ++;
+        if (e == e6) e6_found ++;
+        count ++;
+    };
+
+    group_id = TgtB;
+    q.iter().set_group(TgtB).each(func);
+    test_int(2, count);
+    test_int(1, e2_found);
+    test_int(1, e5_found);
+
+    group_id = TgtA;
+    q.iter().set_group(TgtA).each(func);
+    test_int(4, count);
+    test_int(1, e1_found);
+    test_int(1, e4_found);
+
+    group_id = TgtC;
+    q.iter().set_group(TgtC).each(func);
+    test_int(6, count);
+    test_int(1, e3_found);
+    test_int(1, e6_found);
+
+    test_int(1, e1_found);
+    test_int(1, e2_found);
+    test_int(1, e3_found);
+    test_int(1, e4_found);
+    test_int(1, e5_found);
+    test_int(1, e6_found);
+}
+
+void QueryBuilder_group_by_default_func_w_id(void) {
+    flecs::world ecs;
+
+    auto Rel = ecs.entity();
+    auto TgtA = ecs.entity();
+    auto TgtB = ecs.entity();
+    auto TgtC = ecs.entity();
+
+    auto e1 = ecs.entity().add(Rel, TgtC);
+    auto e2 = ecs.entity().add(Rel, TgtB);
+    auto e3 = ecs.entity().add(Rel, TgtA);
+
+    auto q = ecs.query_builder()
+        .with(Rel, flecs::Wildcard)
+        .group_by(Rel)
+        .build();
+
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    int32_t count = 0;
+
+    q.each([&](flecs::iter& it, size_t i) {
+        flecs::entity e = it.entity(i);
+        if (e == e1) {
+            test_assert(it.group_id() == TgtC);
+            test_assert(!e1_found);
+            test_assert(e2_found);
+            test_assert(e3_found);
+            e1_found = true;
+        }
+        if (e == e2) {
+            test_assert(it.group_id() == TgtB);
+            test_assert(!e1_found);
+            test_assert(!e2_found);
+            test_assert(e3_found);
+            e2_found = true;
+        }
+        if (e == e3) {
+            test_assert(it.group_id() == TgtA);
+            test_assert(!e1_found);
+            test_assert(!e2_found);
+            test_assert(!e3_found);
+            e3_found = true;
+        }
+        count ++;
+    });
+
+    test_int(3, count);
+    test_bool(true, e1_found);
+    test_bool(true, e2_found);
+    test_bool(true, e3_found);
+}
+
+void QueryBuilder_group_by_default_func_w_type(void) {
+    flecs::world ecs;
+
+    struct Rel { };
+    auto TgtA = ecs.entity();
+    auto TgtB = ecs.entity();
+    auto TgtC = ecs.entity();
+
+    auto e1 = ecs.entity().add<Rel>(TgtC);
+    auto e2 = ecs.entity().add<Rel>(TgtB);
+    auto e3 = ecs.entity().add<Rel>(TgtA);
+
+    auto q = ecs.query_builder()
+        .with<Rel>(flecs::Wildcard)
+        .group_by<Rel>()
+        .build();
+
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    int32_t count = 0;
+
+    q.each([&](flecs::iter& it, size_t i) {
+        flecs::entity e = it.entity(i);
+        if (e == e1) {
+            test_assert(it.group_id() == TgtC);
+            test_assert(!e1_found);
+            test_assert(e2_found);
+            test_assert(e3_found);
+            e1_found = true;
+        }
+        if (e == e2) {
+            test_assert(it.group_id() == TgtB);
+            test_assert(!e1_found);
+            test_assert(!e2_found);
+            test_assert(e3_found);
+            e2_found = true;
+        }
+        if (e == e3) {
+            test_assert(it.group_id() == TgtA);
+            test_assert(!e1_found);
+            test_assert(!e2_found);
+            test_assert(!e3_found);
+            e3_found = true;
+        }
+        count ++;
+    });
+
+    test_int(3, count);
+    test_bool(true, e1_found);
+    test_bool(true, e2_found);
+    test_bool(true, e3_found);
+}
+
+static int group_by_ctx = 0;
+
+void QueryBuilder_group_by_callbacks(void) {
+    flecs::world ecs;
+
+    struct Rel { };
+    auto TgtA = ecs.entity();
+    auto TgtB = ecs.entity();
+    auto TgtC = ecs.entity();
+
+    auto e1 = ecs.entity().add<Rel>(TgtC);
+    auto e2 = ecs.entity().add<Rel>(TgtB);
+    auto e3 = ecs.entity().add<Rel>(TgtA);
+
+    auto q = ecs.query_builder()
+        .with<Rel>(flecs::Wildcard)
+        .group_by<Rel>()
+        .group_by_ctx(&group_by_ctx)
+        .on_group_create(
+            [](flecs::world_t *world, uint64_t id, void *group_by_arg) {
+                test_assert(world != nullptr);
+                test_assert(id != 0);
+                test_assert(group_by_arg != nullptr);
+                test_assert(group_by_arg == &group_by_ctx);
+                uint64_t *ctx = ecs_os_malloc_t(uint64_t);
+                *ctx = id;
+                return (void*)ctx;
+            })
+        .on_group_delete(
+            [](flecs::world_t *world, uint64_t id, void *ctx, void *group_by_arg) {
+                test_assert(world != nullptr);
+                test_assert(id != 0);
+                test_assert(group_by_arg != nullptr);
+                test_assert(group_by_arg == &group_by_ctx);
+                test_assert(ctx != NULL);
+                test_uint(*(uint64_t*)ctx, id);
+                ecs_os_free(ctx);
+            })
+        .build();
+
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    int32_t count = 0;
+
+    q.each([&](flecs::iter& it, size_t i) {
+        flecs::entity e = it.entity(i);
+        if (e == e1) {
+            test_assert(it.group_id() == TgtC);
+            test_assert(!e1_found);
+            test_assert(e2_found);
+            test_assert(e3_found);
+            e1_found = true;
+            uint64_t *ctx = (uint64_t*)q.group_ctx(it.group_id());
+            test_uint(*ctx, it.group_id());
+        }
+        if (e == e2) {
+            test_assert(it.group_id() == TgtB);
+            test_assert(!e1_found);
+            test_assert(!e2_found);
+            test_assert(e3_found);
+            e2_found = true;
+            uint64_t *ctx = (uint64_t*)q.group_ctx(it.group_id());
+            test_uint(*ctx, it.group_id());
+        }
+        if (e == e3) {
+            test_assert(it.group_id() == TgtA);
+            test_assert(!e1_found);
+            test_assert(!e2_found);
+            test_assert(!e3_found);
+            e3_found = true;
+            uint64_t *ctx = (uint64_t*)q.group_ctx(it.group_id());
+            test_uint(*ctx, it.group_id());
+        }
+        count ++;
+    });
+
+    test_int(3, count);
+    test_bool(true, e1_found);
+    test_bool(true, e2_found);
+    test_bool(true, e3_found);
+}
+
+void QueryBuilder_set_group_on_query(void) {
+    flecs::world ecs;
+
+    auto Rel = ecs.entity();
+    auto TgtA = ecs.entity();
+    auto TgtB = ecs.entity();
+    auto TgtC = ecs.entity();
+    auto Tag = ecs.entity();
+
+    ecs.entity().add(Rel, TgtA);
+    auto e2 = ecs.entity().add(Rel, TgtB);
+    ecs.entity().add(Rel, TgtC);
+
+    ecs.entity().add(Rel, TgtA).add(Tag);
+    auto e5 = ecs.entity().add(Rel, TgtB).add(Tag);
+    ecs.entity().add(Rel, TgtC).add(Tag);
+
+    auto q = ecs.query_builder()
+        .with(Rel, flecs::Wildcard)
+        .group_by(Rel, group_by_rel)
+        .build();
+
+    bool e2_found = false;
+    bool e5_found = false;
+    int32_t count = 0;
+
+    q.set_group(TgtB).each([&](flecs::iter& it, size_t i) {
+        flecs::entity e = it.entity(i);
+        test_assert(it.group_id() == TgtB);
+
+        if (e == e2) e2_found = true;
+        if (e == e5) e5_found = true;
+        count ++;
+    });
+
+    test_int(2, count);
+    test_bool(true, e2_found);
+    test_bool(true, e5_found);
+}
+
+void QueryBuilder_set_group_type_on_query(void) {
+    flecs::world ecs;
+
+    struct Rel { };
+    struct TgtA { };
+    struct TgtB { };
+    struct TgtC { };
+
+    auto Tag = ecs.entity();
+
+    ecs.entity().add<Rel, TgtA>();
+    auto e2 = ecs.entity().add<Rel, TgtB>();
+    ecs.entity().add<Rel, TgtC>();
+
+    ecs.entity().add<Rel, TgtA>().add(Tag);
+    auto e5 = ecs.entity().add<Rel, TgtB>().add(Tag);
+    ecs.entity().add<Rel, TgtC>().add(Tag);
+
+    auto q = ecs.query_builder()
+        .with<Rel>(flecs::Wildcard)
+        .group_by<Rel>(group_by_rel)
+        .build();
+
+    bool e2_found = false;
+    bool e5_found = false;
+    int32_t count = 0;
+
+    q.set_group<TgtB>().each([&](flecs::iter& it, size_t i) {
+        flecs::entity e = it.entity(i);
+        test_assert(it.group_id() == ecs.id<TgtB>());
+
+        if (e == e2) e2_found = true;
+        if (e == e5) e5_found = true;
+        count ++;
+    });
+
+    test_int(2, count);
+    test_bool(true, e2_found);
+    test_bool(true, e5_found);
+}
+
+void QueryBuilder_create_w_no_template_args(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder()
+        .with<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_any_wildcard(void) {
+    flecs::world ecs;
+
+    auto Likes = ecs.entity();
+    auto Apple = ecs.entity();
+    auto Mango = ecs.entity();
+
+    auto e1 = ecs.entity()
+        .add(Likes, Apple)
+        .add(Likes, Mango);
+
+    auto q = ecs.query_builder()
+        .with(Likes, flecs::Any)
+        .cache_kind(cache_kind)
+        .build();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_cascade(void) {
+    flecs::world ecs;
+
+    auto Tag = ecs.entity();
+    auto Foo = ecs.entity();
+    auto Bar = ecs.entity();
+
+    auto e0 = ecs.entity().add(Tag);
+    auto e1 = ecs.entity().is_a(e0);
+    auto e2 = ecs.entity().is_a(e1);
+    auto e3 = ecs.entity().is_a(e2);
+
+    auto q = ecs.query_builder()
+        .with(Tag).cascade(flecs::IsA)
+        .cached()
+        .build();
+
+    e1.add(Bar);
+    e2.add(Foo);
+
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+
+        if (e == e1) {
+            test_bool(e1_found, false);
+            test_bool(e2_found, false);
+            test_bool(e3_found, false);
+            e1_found = true;
+        }
+        if (e == e2) {
+            test_bool(e1_found, true);
+            test_bool(e2_found, false);
+            test_bool(e3_found, false);
+            e2_found = true;
+        }
+        if (e == e3) {
+            test_bool(e1_found, true);
+            test_bool(e2_found, true);
+            test_bool(e3_found, false);
+            e3_found = true;
+        }
+    });
+
+    test_bool(e1_found, true);
+    test_bool(e2_found, true);
+    test_bool(e3_found, true);
+    test_int(count, 3);
+}
+
+void QueryBuilder_cascade_desc(void) {
+    flecs::world ecs;
+
+    auto Tag = ecs.entity();
+    auto Foo = ecs.entity();
+    auto Bar = ecs.entity();
+
+    auto e0 = ecs.entity().add(Tag);
+    auto e1 = ecs.entity().is_a(e0);
+    auto e2 = ecs.entity().is_a(e1);
+    auto e3 = ecs.entity().is_a(e2);
+
+    auto q = ecs.query_builder()
+        .with(Tag).cascade(flecs::IsA).desc()
+        .cached()
+        .build();
+
+    e1.add(Bar);
+    e2.add(Foo);
+
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+
+        if (e == e1) {
+            test_bool(e1_found, false);
+            test_bool(e2_found, true);
+            test_bool(e3_found, true);
+            e1_found = true;
+        }
+        if (e == e2) {
+            test_bool(e1_found, false);
+            test_bool(e2_found, false);
+            test_bool(e3_found, true);
+            e2_found = true;
+        }
+        if (e == e3) {
+            test_bool(e1_found, false);
+            test_bool(e2_found, false);
+            test_bool(e3_found, false);
+            e3_found = true;
+        }
+    });
+
+    test_bool(e1_found, true);
+    test_bool(e2_found, true);
+    test_bool(e3_found, true);
+    test_int(count, 3);
+}
+
+void QueryBuilder_cascade_w_relationship(void) {
+    flecs::world ecs;
+
+    auto Tag = ecs.entity();
+    auto Foo = ecs.entity();
+    auto Bar = ecs.entity();
+
+    auto e0 = ecs.entity().add(Tag);
+    auto e1 = ecs.entity().child_of(e0);
+    auto e2 = ecs.entity().child_of(e1);
+    auto e3 = ecs.entity().child_of(e2);
+
+    auto q = ecs.query_builder()
+        .with(Tag).cascade(flecs::ChildOf)
+        .cached()
+        .build();
+
+    e1.add(Bar);
+    e2.add(Foo);
+
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+
+        if (e == e1) {
+            test_bool(e1_found, false);
+            test_bool(e2_found, false);
+            test_bool(e3_found, false);
+            e1_found = true;
+        }
+        if (e == e2) {
+            test_bool(e1_found, true);
+            test_bool(e2_found, false);
+            test_bool(e3_found, false);
+            e2_found = true;
+        }
+        if (e == e3) {
+            test_bool(e1_found, true);
+            test_bool(e2_found, true);
+            test_bool(e3_found, false);
+            e3_found = true;
+        }
+    });
+
+    test_bool(e1_found, true);
+    test_bool(e2_found, true);
+    test_bool(e3_found, true);
+    test_int(count, 3);
+}
+
+void QueryBuilder_up_w_type(void) {
+    flecs::world ecs;
+
+    struct Rel { };
+
+    ecs.component<Rel>().add(flecs::Traversable);
+
+    auto q = ecs.query_builder<Self>()
+        .with<Other>().src().up<Rel>().in()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto base = ecs.entity().set<Other>({10});
+
+    auto 
+    e = ecs.entity().add<Rel>(base); e.set<Self>({e});
+    e = ecs.entity().add<Rel>(base); e.set<Self>({e});
+    e = ecs.entity().add<Rel>(base); e.set<Self>({e});
+
+    int32_t count = 0;
+
+    q.iter([&](flecs::iter& it, Self *s) {
+        auto o = it.field<const Other>(1);
+        test_assert(!it.is_self(1));
+        test_int(o->value, 10);
+
+        for (auto i : it) {
+            test_assert(it.entity(i) == s[i].value);
+            count ++;
+        }
+    });
+    
+    test_int(count, 3);
+}
+
+void QueryBuilder_cascade_w_type(void) {
+    flecs::world ecs;
+
+    struct Rel { };
+
+    ecs.component<Rel>().add(flecs::Traversable);
+
+    auto Tag = ecs.entity();
+    auto Foo = ecs.entity();
+    auto Bar = ecs.entity();
+
+    auto e0 = ecs.entity().add(Tag);
+    auto e1 = ecs.entity().add<Rel>(e0);
+    auto e2 = ecs.entity().add<Rel>(e1);
+    auto e3 = ecs.entity().add<Rel>(e2);
+
+    auto q = ecs.query_builder()
+        .with(Tag).cascade<Rel>()
+        .cached()
+        .build();
+
+    e1.add(Bar);
+    e2.add(Foo);
+
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+
+        if (e == e1) {
+            test_bool(e1_found, false);
+            test_bool(e2_found, false);
+            test_bool(e3_found, false);
+            e1_found = true;
+        }
+        if (e == e2) {
+            test_bool(e1_found, true);
+            test_bool(e2_found, false);
+            test_bool(e3_found, false);
+            e2_found = true;
+        }
+        if (e == e3) {
+            test_bool(e1_found, true);
+            test_bool(e2_found, true);
+            test_bool(e3_found, false);
+            e3_found = true;
+        }
+    });
+
+    test_bool(e1_found, true);
+    test_bool(e2_found, true);
+    test_bool(e3_found, true);
+    test_int(count, 3);
+}
+
+void QueryBuilder_named_query(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Position>();
+
+    auto q = ecs.query_builder("my_query")
+        .with<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        test_assert(e == e1 || e == e2);
+        count ++;
+    });
+    test_int(count, 2);
+
+    flecs::entity qe = q.entity();
+    test_assert(qe != 0);
+    test_str(qe.name(), "my_query");
+}
+
+void QueryBuilder_term_w_write(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder()
+        .with<Position>()
+        .with<Position>().write()
+        .cache_kind(cache_kind)
+        .build();
+
+    test_assert(q.term(0).inout() == flecs::InOutNone);
+    test_assert(q.term(0).get_src() == flecs::This);
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_term_w_read(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder()
+        .with<Position>()
+        .with<Position>().read()
+        .cache_kind(cache_kind)
+        .build();
+
+    test_assert(q.term(0).inout() == flecs::InOutNone);
+    test_assert(q.term(0).get_src() == flecs::This);
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_iter_w_stage(void) {
+    flecs::world ecs;
+
+    ecs.set_stage_count(2);
+    flecs::world stage = ecs.get_stage(1);
+
+    auto e1 = ecs.entity().add<Position>();
+
+    auto q = ecs.query<Position>();
+
+    int32_t count = 0;
+    q.each(stage, [&](flecs::iter& it, size_t i, Position&) {
+        test_assert(it.world() == stage);
+        test_assert(it.entity(i) == e1);
+        count ++;
+    });
+
+    test_int(count, 1);
+}
+
+template<typename ... Components>
+struct QueryWrapper
+{
+    QueryWrapper(flecs::query<Components...> f) : f_(f) {}
+    flecs::query<Components...> f_;
+};
+
+void QueryBuilder_builder_force_assign_operator(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity().set<Position>({10, 20});
+
+    auto f = ecs.entity().emplace<QueryWrapper<>>(
+        ecs.query_builder()
+            .with<Position>()
+            .cache_kind(cache_kind)
+            .build()
+    );
+
+    int32_t count = 0;
+    f.get<QueryWrapper<>>()->f_.each([&](flecs::entity e) {
+        test_assert(e == e1);
+        count ++;
+    });
+}
+
+static
+int query_arg(flecs::query<Self> f) {
+    int32_t count = 0;
+
+    f.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+
+    return count;
+}
+
+void QueryBuilder_query_as_arg(void) {
+    flecs::world ecs;
+
+    auto f = ecs.query_builder<Self>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    test_int(query_arg(f), 3);
+}
+
+static
+int query_move_arg(flecs::query<Self>&& f) {
+    int32_t count = 0;
+
+    f.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+
+    return count;
+}
+
+void QueryBuilder_query_as_move_arg(void) {
+    flecs::world ecs;
+
+    auto f = ecs.query<Self>();
+
+    auto e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    test_int(query_move_arg(ecs.query<Self>()), 3);
+}
+
+static
+flecs::query<Self> query_return(flecs::world& ecs) {
+    return ecs.query<Self>();
+}
+
+void QueryBuilder_query_as_return(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    auto f = query_return(ecs);
+
+    int32_t count = 0;
+
+    f.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_query_copy(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    auto f = ecs.query_builder<Self>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto f_2 = f;
+
+    int32_t count = 0;
+
+    f_2.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_world_each_query_1_component(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    int32_t count = 0;
+
+    ecs.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_world_each_query_2_components(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity();
+    e.set<Self>({e})
+     .set<Position>({10, 20});
+
+    e = ecs.entity();
+    e.set<Self>({e})
+        .set<Position>({10, 20});
+
+    e = ecs.entity();
+    e.set<Self>({e})
+     .set<Position>({10, 20});
+
+    int32_t count = 0;
+
+    ecs.each([&](flecs::entity e, Self& s, Position& p) {
+        test_assert(e == s.value);
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_world_each_query_1_component_no_entity(void) {
+    flecs::world ecs;
+
+    ecs.entity()
+        .set<Position>({10, 20});
+
+    ecs.entity()
+        .set<Position>({10, 20});
+
+    ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    int32_t count = 0;
+
+    ecs.each([&](Position& p) {
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_world_each_query_2_components_no_entity(void) {
+    flecs::world ecs;
+
+    ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    ecs.entity()
+        .set<Position>({3, 5});
+
+    ecs.entity()
+        .set<Velocity>({20, 40});
+
+    int32_t count = 0;
+
+    ecs.each([&](Position& p, Velocity& v) {
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+        test_int(v.x, 1);
+        test_int(v.y, 2);        
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_term_after_arg(void) {
+    flecs::world ecs;
+
+    auto e_1 = ecs.entity()
+        .add<TagA>()
+        .add<TagB>()
+        .add<TagC>();
+
+    ecs.entity()
+        .add<TagA>()
+        .add<TagB>();
+
+    auto f = ecs.query_builder<TagA, TagB>()
+        .term_at(0).src(flecs::This) // dummy
+        .with<TagC>()
+        .cache_kind(cache_kind)
+        .build();
+
+    test_int(f.field_count(), 3);
+
+    int count = 0;
+    f.each([&](flecs::entity e, TagA, TagB) {
+        test_assert(e == e_1);
+        count ++;
+    });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_name_arg(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity("Foo").set<Position>({10, 20});
+
+    auto f = ecs.query_builder<Position>()
+        .term_at(0).src().name("Foo")
+        .cache_kind(cache_kind)
+        .build();
+
+    int32_t count = 0;
+    f.iter([&](flecs::iter& it, Position* p) {
+        count ++;
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_assert(it.src(0) == e);
+    });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_const_in_term(void) {
+    flecs::world ecs;
+
+    ecs.entity().set<Position>({10, 20});
+
+    auto f = ecs.query_builder<>()
+        .with<const Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    int32_t count = 0;
+    f.iter([&](flecs::iter& it) {
+        auto p = it.field<const Position>(0);
+        test_assert(it.is_readonly(0));
+        for (auto i : it) {
+            count ++;
+            test_int(p[i].x, 10);
+            test_int(p[i].y, 20);
+        }
+    });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_const_optional(void) {
+    flecs::world ecs;
+	
+	ecs.entity().set<Position>({10, 20}).add<TagA>();
+    ecs.entity().add<TagA>();
+
+    auto f = ecs.query_builder<TagA, const Position*>()
+        .cache_kind(cache_kind)
+        .build();
+	
+    int32_t count = 0, set_count = 0;
+    f.iter([&](flecs::iter& it) {
+        test_int(it.count(), 1);
+        if (it.is_set(1)) {
+            auto p = it.field<const Position>(1);
+            test_assert(it.is_readonly(1));
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+            set_count ++;
+        }
+        count++;
+	});
+	
+    test_int(count, 2);
+    test_int(set_count, 1);
+}
+
+void QueryBuilder_2_terms_w_expr(void) {
+    flecs::world ecs;
+
+    auto a = ecs.entity("A");
+    auto b = ecs.entity("B");
+
+    auto e1 = ecs.entity().add(a).add(b);
+
+    auto f = ecs.query_builder()
+        .expr("A, B")
+        .cache_kind(cache_kind)
+        .build();
+    
+    test_int(f.field_count(), 2);
+
+    int32_t count = 0;
+    f.each([&](flecs::iter& it, size_t index) {
+        if (it.entity(index) == e1) {
+            test_assert(it.id(0) == a);
+            test_assert(it.id(1) == b);
+            count ++;
+        }
+    });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_assert_on_uninitialized_term(void) {
+    install_test_abort();
+
+    flecs::world ecs;
+
+    ecs.entity("A");
+    ecs.entity("B");
+
+    test_expect_abort();
+
+    auto f = ecs.query_builder()
+        .term()
+        .term()
+        .cache_kind(cache_kind)
+        .build();
+}
+
+void QueryBuilder_operator_shortcuts(void) {
+    flecs::world ecs;
+
+    flecs::entity a = ecs.entity();
+    flecs::entity b = ecs.entity();
+    flecs::entity c = ecs.entity();
+    flecs::entity d = ecs.entity();
+    flecs::entity e = ecs.entity();
+    flecs::entity f = ecs.entity();
+    flecs::entity g = ecs.entity();
+    flecs::entity h = ecs.entity();
+
+    auto query = ecs.query_builder()
+        .with(a).and_()
+        .with(b).or_()
+        .with(c)
+        .with(d).not_()
+        .with(e).optional()
+        .with(f).and_from()
+        .with(g).or_from()
+        .with(h).not_from()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto t = query.term(0);
+    test_int(t.id(), a);
+    test_int(t.oper(), flecs::And);
+
+    t = query.term(1);
+    test_int(t.id(), b);
+    test_int(t.oper(), flecs::Or);
+
+    t = query.term(2);
+    test_int(t.id(), c);
+    test_int(t.oper(), flecs::And);
+
+    t = query.term(3);
+    test_int(t.id(), d);
+    test_int(t.oper(), flecs::Not);
+
+    t = query.term(4);
+    test_int(t.id(), e);
+    test_int(t.oper(), flecs::Optional);
+
+    t = query.term(5);
+    test_int(t.id(), f);
+    test_int(t.oper(), flecs::AndFrom);
+
+    t = query.term(6);
+    test_int(t.id(), g);
+    test_int(t.oper(), flecs::OrFrom);
+
+    t = query.term(7);
+    test_int(t.id(), h);
+    test_int(t.oper(), flecs::NotFrom);
+}
+
+void QueryBuilder_inout_shortcuts(void) {
+    flecs::world ecs;
+
+    flecs::entity a = ecs.entity();
+    flecs::entity b = ecs.entity();
+    flecs::entity c = ecs.entity();
+    flecs::entity d = ecs.entity();
+
+    auto query = ecs.query_builder()
+        .with(a).in()
+        .with(b).out()
+        .with(c).inout()
+        .with(d).inout_none()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto t = query.term(0);
+    test_int(t.id(), a);
+    test_int(t.inout(), flecs::In);
+
+    t = query.term(1);
+    test_int(t.id(), b);
+    test_int(t.inout(), flecs::Out);
+
+    t = query.term(2);
+    test_int(t.id(), c);
+    test_int(t.inout(), flecs::InOut);
+
+    t = query.term(3);
+    test_int(t.id(), d);
+    test_int(t.inout(), flecs::InOutNone);
+}
+
+void QueryBuilder_iter_column_w_const_as_array(void) {
+    flecs::world world;
+
+    auto f = world.query_builder<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e1 = world.entity().set<Position>({10, 20});
+    auto e2 = world.entity().set<Position>({20, 30});
+
+    int32_t count = 0;
+    f.iter([&](flecs::iter& it) {
+        const auto p = it.field<Position>(0);
+        for (auto i : it) {
+            p[i].x += 1;
+            p[i].y += 2;
+
+            count ++;
+        }
+    });
+
+    test_int(count, 2);
+
+    const Position *p = e1.get<Position>();
+    test_int(p->x, 11);
+    test_int(p->y, 22);
+
+    p = e2.get<Position>();
+    test_int(p->x, 21);
+    test_int(p->y, 32);
+}
+
+void QueryBuilder_iter_column_w_const_as_ptr(void) {
+    flecs::world world;
+
+    auto f = world.query_builder<Position>()
+        .cache_kind(cache_kind)
+        .build();
+    
+    auto base = world.prefab().set<Position>({10, 20});
+    world.entity().is_a(base);
+    world.entity().is_a(base);
+
+    int32_t count = 0;
+    f.iter([&](flecs::iter& it) {
+        const auto p = it.field<Position>(0);
+        for (size_t i = 0; i < it.count(); i ++) {
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+            count ++;
+        }
+    });
+
+    test_int(count, 2);
+}
+
+void QueryBuilder_iter_column_w_const_deref(void) {
+    flecs::world world;
+
+    auto f = world.query_builder<Position>()
+        .cache_kind(cache_kind)
+        .build();
+    
+    auto base = world.prefab().set<Position>({10, 20});
+    world.entity().is_a(base);
+    world.entity().is_a(base);
+
+    int32_t count = 0;
+    f.iter([&](flecs::iter& it) {
+        const auto p = it.field<Position>(0);
+        Position pv = *p;
+        for (size_t i = 0; i < it.count(); i ++) {
+            test_int(pv.x, 10);
+            test_int(pv.y, 20);
+            count ++;
+        }
+    });
+
+    test_int(count, 2);
+}
+
+void QueryBuilder_with_id(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with(ecs.id<Position>())
+            .with(ecs.id<Velocity>())
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_with_name(void) {
+    flecs::world ecs;
+
+    ecs.component<Velocity>();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .with("Velocity")
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_with_component(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .with<Velocity>()
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Velocity>();
+    ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_with_pair_id(void) {
+    flecs::world ecs;
+
+    flecs::entity Likes = ecs.entity();
+    flecs::entity Apples = ecs.entity();
+    flecs::entity Pears = ecs.entity();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .with(Likes, Apples)
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add(Likes, Apples);
+    ecs.entity().add<Position>().add(Likes, Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_with_pair_name(void) {
+    flecs::world ecs;
+
+    flecs::entity Likes = ecs.entity("Likes");
+    flecs::entity Apples = ecs.entity("Apples");
+    flecs::entity Pears = ecs.entity("Pears");
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .with("Likes", "Apples")
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add(Likes, Apples);
+    ecs.entity().add<Position>().add(Likes, Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_with_pair_components(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Apples { };
+    struct Pears { };
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .with<Likes, Apples>()
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Likes, Apples>();
+    ecs.entity().add<Position>().add<Likes, Pears>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_with_pair_component_id(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    flecs::entity Apples = ecs.entity();
+    flecs::entity Pears = ecs.entity();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .with<Likes>(Apples)
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Likes>(Apples);
+    ecs.entity().add<Position>().add<Likes>(Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_with_pair_component_name(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    flecs::entity Apples = ecs.entity("Apples");
+    flecs::entity Pears = ecs.entity("Pears");
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .with<Likes>("Apples")
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add<Likes>(Apples);
+    ecs.entity().add<Position>().add<Likes>(Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_with_enum(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .with(Green)
+            .cache_kind(cache_kind)
+            .build();
+
+    auto e1 = ecs.entity().add<Position>().add(Green);
+    ecs.entity().add<Position>().add(Red);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e1);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_without_id(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with(ecs.id<Position>())
+            .without(ecs.id<Velocity>())
+            .cache_kind(cache_kind)
+            .build();
+
+    ecs.entity().add<Position>().add<Velocity>();
+    auto e2 = ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_without_name(void) {
+    flecs::world ecs;
+
+    ecs.component<Velocity>();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with(ecs.id<Position>())
+            .without("Velocity")
+            .cache_kind(cache_kind)
+            .build();
+
+    ecs.entity().add<Position>().add<Velocity>();
+    auto e2 = ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_without_component(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .without<Velocity>()
+            .cache_kind(cache_kind)
+            .build();
+
+    ecs.entity().add<Position>().add<Velocity>();
+    auto e2 = ecs.entity().add<Position>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_without_pair_id(void) {
+    flecs::world ecs;
+
+    flecs::entity Likes = ecs.entity();
+    flecs::entity Apples = ecs.entity();
+    flecs::entity Pears = ecs.entity();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .without(Likes, Apples)
+            .cache_kind(cache_kind)
+            .build();
+
+    ecs.entity().add<Position>().add(Likes, Apples);
+    auto e2 = ecs.entity().add<Position>().add(Likes, Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_without_pair_name(void) {
+    flecs::world ecs;
+
+    flecs::entity Likes = ecs.entity("Likes");
+    flecs::entity Apples = ecs.entity("Apples");
+    flecs::entity Pears = ecs.entity("Pears");
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .without("Likes", "Apples")
+            .cache_kind(cache_kind)
+            .build();
+
+    ecs.entity().add<Position>().add(Likes, Apples);
+    auto e2 = ecs.entity().add<Position>().add(Likes, Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_without_pair_components(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Apples { };
+    struct Pears { };
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .without<Likes, Apples>()
+            .cache_kind(cache_kind)
+            .build();
+
+    ecs.entity().add<Position>().add<Likes, Apples>();
+    auto e2 = ecs.entity().add<Position>().add<Likes, Pears>();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_without_pair_component_id(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    flecs::entity Apples = ecs.entity();
+    flecs::entity Pears = ecs.entity();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .without<Likes>(Apples)
+            .cache_kind(cache_kind)
+            .build();
+
+    ecs.entity().add<Position>().add<Likes>(Apples);
+    auto e2 = ecs.entity().add<Position>().add<Likes>(Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_without_pair_component_name(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    flecs::entity Apples = ecs.entity("Apples");
+    flecs::entity Pears = ecs.entity("Pears");
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .without<Likes>("Apples")
+            .cache_kind(cache_kind)
+            .build();
+
+    ecs.entity().add<Position>().add<Likes>(Apples);
+    auto e2 = ecs.entity().add<Position>().add<Likes>(Pears);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_without_enum(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .without(Green)
+            .cache_kind(cache_kind)
+            .build();
+
+    ecs.entity().add<Position>().add(Green);
+    auto e2 = ecs.entity().add<Position>().add(Red);
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e) {
+        count ++;
+        test_assert(e == e2);
+    });
+    
+    test_int(count, 1);
+}
+
+void QueryBuilder_write_id(void) {
+    flecs::world ecs;
+
+    auto q = 
+        ecs.query_builder()
+            .with<Position>()
+            .write(ecs.id<Position>())
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_first() == ecs.id<Position>());
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_write_name(void) {
+    flecs::world ecs;
+
+    ecs.component<Position>();
+
+    auto q = 
+        ecs.query_builder()
+            .with<Position>()
+            .write("Position")
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_first() == ecs.id<Position>());
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_write_component(void) {
+    flecs::world ecs;
+
+    ecs.component<Position>();
+
+    auto q = 
+        ecs.query_builder()
+            .with<Position>()
+            .write<Position>()
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_first() == ecs.id<Position>());
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_write_pair_id(void) {
+    flecs::world ecs;
+
+    flecs::entity Likes = ecs.entity();
+    flecs::entity Apples = ecs.entity();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .write(Likes, Apples)
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_first() == Likes);
+    test_assert(q.term(1).get_second() == Apples);
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_write_pair_name(void) {
+    flecs::world ecs;
+
+    flecs::entity Likes = ecs.entity("Likes");
+    flecs::entity Apples = ecs.entity("Apples");
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .write("Likes", "Apples")
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_first() == Likes);
+    test_assert(q.term(1).get_second() == Apples);
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_write_pair_components(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Apples { };
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .write<Likes, Apples>()
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_first() == ecs.id<Likes>());
+    test_assert(q.term(1).get_second() == ecs.id<Apples>());
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_write_pair_component_id(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    flecs::entity Apples = ecs.entity();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .write<Likes>(Apples)
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_first() == ecs.id<Likes>());
+    test_assert(q.term(1).get_second() == Apples);
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_write_pair_component_name(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    flecs::entity Apples = ecs.entity("Apples");
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .write<Likes>("Apples")
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_first() == ecs.id<Likes>());
+    test_assert(q.term(1).get_second() == Apples);
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_write_enum(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .write(Green)
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::Out);
+    test_assert(q.term(1).get_first() == ecs.id<Color>());
+    test_assert(q.term(1).get_second() == ecs.to_entity<Color>(Green));
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_read_id(void) {
+    flecs::world ecs;
+
+    auto q = 
+        ecs.query_builder()
+            .with<Position>()
+            .read(ecs.id<Position>())
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_first() == ecs.id<Position>());
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_read_name(void) {
+    flecs::world ecs;
+
+    ecs.component<Position>();
+
+    auto q = 
+        ecs.query_builder()
+            .with<Position>()
+            .read("Position")
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_first() == ecs.id<Position>());
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_read_component(void) {
+    flecs::world ecs;
+
+    ecs.component<Position>();
+
+    auto q = 
+        ecs.query_builder()
+            .with<Position>()
+            .read<Position>()
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_first() == ecs.id<Position>());
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_read_pair_id(void) {
+    flecs::world ecs;
+
+    flecs::entity Likes = ecs.entity();
+    flecs::entity Apples = ecs.entity();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .read(Likes, Apples)
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_first() == Likes);
+    test_assert(q.term(1).get_second() == Apples);
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_read_pair_name(void) {
+    flecs::world ecs;
+
+    flecs::entity Likes = ecs.entity("Likes");
+    flecs::entity Apples = ecs.entity("Apples");
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .read("Likes", "Apples")
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_first() == Likes);
+    test_assert(q.term(1).get_second() == Apples);
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_read_pair_components(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    struct Apples { };
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .read<Likes, Apples>()
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_first() == ecs.id<Likes>());
+    test_assert(q.term(1).get_second() == ecs.id<Apples>());
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_read_pair_component_id(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    flecs::entity Apples = ecs.entity();
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .read<Likes>(Apples)
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_first() == ecs.id<Likes>());
+    test_assert(q.term(1).get_second() == Apples);
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_read_pair_component_name(void) {
+    flecs::world ecs;
+
+    struct Likes { };
+    flecs::entity Apples = ecs.entity("Apples");
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .read<Likes>("Apples")
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_first() == ecs.id<Likes>());
+    test_assert(q.term(1).get_second() == Apples);
+
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_read_enum(void) {
+    flecs::world ecs;
+
+    flecs::query<> q = 
+        ecs.query_builder()
+            .with<Position>()
+            .read(Green)
+            .cache_kind(cache_kind)
+            .build();
+
+    test_assert(q.term(1).inout() == flecs::In);
+    test_assert(q.term(1).get_first() == ecs.id<Color>());
+    test_assert(q.term(1).get_second() == ecs.to_entity<Color>(Green));
+    test_assert(q.term(1).get_src() == 0);
+}
+
+void QueryBuilder_assign_after_init(void) {
+    flecs::world ecs;
+
+    flecs::query<> f;
+    flecs::query_builder<> fb = ecs.query_builder();
+    fb.with<Position>();
+    fb.cache_kind(cache_kind);
+    f = fb.build();
+
+    flecs::entity e1 = ecs.entity().set<Position>({10, 20});
+
+    int32_t count = 0;
+    f.each([&](flecs::entity e) {
+        test_assert(e == e1);
+        count ++;
+    });
+
+    test_int(count, 1);
+}
+
+void QueryBuilder_with_t_inout(void) {
+    flecs::world ecs;
+
+    flecs::query<> f = ecs.query_builder()
+        .with(ecs.id<Position>())
+        .cache_kind(cache_kind)
+        .build();
+
+    test_assert(f.term(0).inout() == flecs::InOutNone);
+}
+
+void QueryBuilder_with_T_inout(void) {
+    flecs::world ecs;
+
+    flecs::query<> f = ecs.query_builder()
+        .with<Position>()
+        .cache_kind(cache_kind)
+        .build();
+
+    test_assert(f.term(0).inout() == flecs::InOutNone);
+}
+
+void QueryBuilder_with_R_T_inout(void) {
+    flecs::world ecs;
+
+    flecs::query<> f = ecs.query_builder()
+        .with<Position, Velocity>()
+        .cache_kind(cache_kind)
+        .build();
+
+    test_assert(f.term(0).inout() == flecs::InOutNone);
+}
+
+void QueryBuilder_with_R_t_inout(void) {
+    flecs::world ecs;
+
+    flecs::query<> f = ecs.query_builder()
+        .with<Position>(ecs.id<Velocity>())
+        .cache_kind(cache_kind)
+        .build();
+
+    test_assert(f.term(0).inout() == flecs::InOutNone);
+}
+
+void QueryBuilder_with_r_t_inout(void) {
+    flecs::world ecs;
+
+    flecs::query<> f = ecs.query_builder()
+        .with(ecs.id<Position>(), ecs.id<Velocity>())
+        .cache_kind(cache_kind)
+        .build();
+
+    test_assert(f.term(0).inout() == flecs::InOutNone);
+}
+
+static
+int filter_move_arg(flecs::query<Self>&& f) {
+    int32_t count = 0;
+
+    f.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+
+    return count;
+}
+
+void QueryBuilder_filter_as_move_arg(void) {
+    flecs::world ecs;
+
+    auto f = ecs.query_builder<Self>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    test_int(filter_move_arg(ecs.query<Self>()), 3);
+}
+
+static
+flecs::query<Self> filter_return(flecs::world& ecs) {
+    return ecs.query_builder<Self>()
+        .cache_kind(cache_kind)
+        .build();
+}
+
+void QueryBuilder_filter_as_return(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    auto f = filter_return(ecs);
+
+    int32_t count = 0;
+
+    f.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_filter_copy(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    auto f = ecs.query_builder<Self>()
+        .cache_kind(cache_kind)
+        .build();
+
+    auto f_2 = f;
+
+    int32_t count = 0;
+
+    f_2.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_world_each_filter_1_component(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    e = ecs.entity();
+    e.set<Self>({e});
+
+    int32_t count = 0;
+
+    ecs.each([&](flecs::entity e, Self& s) {
+        test_assert(e == s.value);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_world_each_filter_2_components(void) {
+    flecs::world ecs;
+
+    auto e = ecs.entity();
+    e.set<Self>({e})
+     .set<Position>({10, 20});
+
+    e = ecs.entity();
+    e.set<Self>({e})
+        .set<Position>({10, 20});
+
+    e = ecs.entity();
+    e.set<Self>({e})
+     .set<Position>({10, 20});
+
+    int32_t count = 0;
+
+    ecs.each([&](flecs::entity e, Self& s, Position& p) {
+        test_assert(e == s.value);
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_world_each_filter_1_component_no_entity(void) {
+    flecs::world ecs;
+
+    ecs.entity()
+        .set<Position>({10, 20});
+
+    ecs.entity()
+        .set<Position>({10, 20});
+
+    ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    int32_t count = 0;
+
+    ecs.each([&](Position& p) {
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_world_each_filter_2_components_no_entity(void) {
+    flecs::world ecs;
+
+    ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    ecs.entity()
+        .set<Position>({10, 20})
+        .set<Velocity>({1, 2});
+
+    ecs.entity()
+        .set<Position>({3, 5});
+
+    ecs.entity()
+        .set<Velocity>({20, 40});
+
+    int32_t count = 0;
+
+    ecs.each([&](Position& p, Velocity& v) {
+        test_int(p.x, 10);
+        test_int(p.y, 20);
+        test_int(v.x, 1);
+        test_int(v.y, 2);        
+        count ++;
+    });
+
+    test_int(count, 3);
+}
+
+void QueryBuilder_var_src_w_prefixed_name(void) {
+    flecs::world ecs;
+
+    struct Foo { };
+
+    auto r = ecs.query_builder()
+        .with<Foo>().src("$Var")
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e = ecs.entity().add<Foo>();
+
+    int32_t count = 0;
+    r.iter([&](flecs::iter& it) {
+        test_assert(it.get_var("Var") == e);
+        count ++;
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_var_first_w_prefixed_name(void) {
+    flecs::world ecs;
+
+    struct Foo { };
+
+    auto r = ecs.query_builder()
+        .with<Foo>()
+        .term().first("$Var")
+        .cache_kind(cache_kind)
+        .build();
+
+    auto e = ecs.entity().add<Foo>();
+
+    int32_t count = 0;
+    r.iter([&](flecs::iter& it) {
+        test_int(it.count(), 1);
+        test_uint(it.entity(0), e);
+        test_assert(it.get_var("Var") == ecs.id<Foo>());
+        count ++;
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_var_second_w_prefixed_name(void) {
+    flecs::world ecs;
+
+    struct Foo { };
+
+    auto r = ecs.query_builder()
+        .with<Foo>().second("$Var")
+        .cache_kind(cache_kind)
+        .build();
+
+    auto t = ecs.entity();
+    auto e = ecs.entity().add<Foo>(t);
+
+    int32_t count = 0;
+    r.iter([&](flecs::iter& it) {
+        test_int(it.count(), 1);
+        test_uint(it.entity(0), e);
+        test_assert(it.get_var("Var") == t);
+        count ++;
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_term_w_second_var_string(void) {
+    flecs::world ecs;
+
+    flecs::entity Foo = ecs.entity();
+
+    auto r = ecs.query_builder()
+        .with(Foo, "$Var")
+        .cache_kind(cache_kind)
+        .build();
+
+    auto t = ecs.entity();
+    auto e = ecs.entity().add(Foo, t);
+
+    int32_t count = 0;
+    r.iter([&](flecs::iter& it) {
+        test_int(it.count(), 1);
+        test_uint(it.entity(0), e);
+        test_assert(it.get_var("Var") == t);
+        count ++;
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_term_type_w_second_var_string(void) {
+    flecs::world ecs;
+
+    struct Foo { };
+
+    auto r = ecs.query_builder()
+        .with<Foo>("$Var")
+        .cache_kind(cache_kind)
+        .build();
+
+    auto t = ecs.entity();
+    auto e = ecs.entity().add<Foo>(t);
+
+    int32_t count = 0;
+    r.iter([&](flecs::iter& it) {
+        test_int(it.count(), 1);
+        test_uint(it.entity(0), e);
+        test_assert(it.get_var("Var") == t);
+        count ++;
+    });
+
+    test_int(count, 1);
+
+}
+
+void QueryBuilder_named_rule(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Position>();
+
+    auto q = ecs.query_builder<Position>("my_query")
+        .cache_kind(cache_kind)
+        .build();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position&) {
+        test_assert(e == e1 || e == e2);
+        count ++;
+    });
+    test_int(count, 2);
+
+    flecs::entity qe = q.entity();
+    test_assert(qe != 0);
+    test_str(qe.name(), "my_query");
+
+}
+
+void QueryBuilder_named_scoped_rule(void) {
+    flecs::world ecs;
+
+    auto e1 = ecs.entity().add<Position>();
+    auto e2 = ecs.entity().add<Position>();
+
+    auto q = ecs.query_builder<Position>("my::query")
+        .cache_kind(cache_kind)
+        .build();
+
+    int32_t count = 0;
+    q.each([&](flecs::entity e, Position&) {
+        test_assert(e == e1 || e == e2);
+        count ++;
+    });
+    test_int(count, 2);
+
+    flecs::entity qe = q.entity();
+    test_assert(qe != 0);
+    test_str(qe.name(), "query");
+    test_str(qe.path(), "::my::query");
+
+}
+
+void QueryBuilder_is_valid(void) {
+    flecs::world ecs;
+
+    auto q_1 = ecs.query<Position>();
+    test_assert(q_1);
+
+    flecs::log::set_level(-4);
+    auto q_2 = ecs.query_builder()
+        .expr("foo")
+        .cache_kind(cache_kind)
+        .build();
+    test_assert(!q_2);
+}
+
+void QueryBuilder_unresolved_by_name(void) {
+    flecs::world ecs;
+
+    auto q = ecs.query_builder()
+        .flags(EcsQueryAllowUnresolvedByName)
+        .expr("$this == Foo")
+        .cache_kind(cache_kind)
+        .build();
+
+    test_assert(q);
+
+    test_false(q.iter().is_true());
+
+    ecs.entity("Foo");
+
+    test_true(q.iter().is_true());
+
+}
+
+void QueryBuilder_scope(void) {
+    flecs::world ecs;
+
+    flecs::entity Root = ecs.entity();
+    flecs::entity TagA = ecs.entity();
+    flecs::entity TagB = ecs.entity();
+
+    ecs.entity()
+        .add(Root)
+        .add(TagA)
+        .add(TagB);
+
+    auto e2 = ecs.entity()
+        .add(Root)
+        .add(TagA);
+
+    ecs.entity()
+        .add(Root)
+        .add(TagB);
+
+    ecs.entity()
+        .add(Root);
+
+    auto r = ecs.query_builder()
+        .with(Root)
+        .scope_open().not_()
+            .with(TagA)
+            .without(TagB)
+        .scope_close()
+        .cache_kind(cache_kind)
+        .build();
+
+    int32_t count = 0;
+    r.each([&](flecs::entity e) {
+        test_assert(e != e2);
+        count ++;
+    });
+
+    test_int(count, 3);
+
+}
diff --git a/test/cpp_api/src/Refs.cpp b/test/cpp/src/Refs.cpp
similarity index 99%
rename from test/cpp_api/src/Refs.cpp
rename to test/cpp/src/Refs.cpp
index ca300761a..1e98d6775 100644
--- a/test/cpp_api/src/Refs.cpp
+++ b/test/cpp/src/Refs.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void Refs_get_ref_by_ptr(void) {
     flecs::world world;
diff --git a/test/cpp_api/src/Singleton.cpp b/test/cpp/src/Singleton.cpp
similarity index 99%
rename from test/cpp_api/src/Singleton.cpp
rename to test/cpp/src/Singleton.cpp
index ace1c3b7c..b322ed9a3 100644
--- a/test/cpp_api/src/Singleton.cpp
+++ b/test/cpp/src/Singleton.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void Singleton_set_get_singleton(void) {
     flecs::world world;
@@ -107,7 +107,7 @@ void Singleton_singleton_system(void) {
     world.system<>()
         .expr("[inout] Position($)")
         .iter([](flecs::iter it) {
-            auto p = it.field<Position>(1);
+            auto p = it.field<Position>(0);
             test_int(p->x, 10);
             test_int(p->y, 20);
 
diff --git a/test/cpp_api/src/System.cpp b/test/cpp/src/System.cpp
similarity index 97%
rename from test/cpp_api/src/System.cpp
rename to test/cpp/src/System.cpp
index d27099eb0..30ed88c9c 100644
--- a/test/cpp_api/src/System.cpp
+++ b/test/cpp/src/System.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void System_iter(void) {
     flecs::world world;
@@ -66,11 +66,11 @@ void System_iter_shared(void) {
         .set<Position>({10, 20})
         .set<Velocity>({3, 4});
 
-    world.system<Position>().expr("Velocity(self|up)")
+    world.system<Position>().expr("Velocity(self|up IsA)")
         .iter([](flecs::iter&it, Position *p) {
-            auto v = it.field<const Velocity>(2);
+            auto v = it.field<const Velocity>(1);
 
-            if (!it.is_self(2)) {
+            if (!it.is_self(1)) {
                 for (auto i : it) {
                     p[i].x += v->x;
                     p[i].y += v->y;
@@ -116,7 +116,7 @@ void System_iter_optional(void) {
 
     world.system<Position, Velocity*, Mass*>()
         .iter([](flecs::iter& it, Position *p, Velocity *v, Mass *m) {
-        if (it.is_set(2) && it.is_set(3)) {
+        if (it.is_set(1) && it.is_set(2)) {
             for (auto i : it) {
                 p[i].x += v[i].x * m[i].value;
                 p[i].y += v[i].y * m[i].value;
@@ -279,8 +279,8 @@ void System_signature(void) {
 
     world.system<>().expr("Position, Velocity")
         .iter([](flecs::iter&it) {
-            flecs::field<Position> p(it, 1);
-            flecs::field<Velocity> v(it, 2);
+            flecs::field<Position> p(it, 0);
+            flecs::field<Velocity> v(it, 1);
 
             for (auto i : it) {
                 p[i].x += v[i].x;
@@ -308,8 +308,8 @@ void System_signature_const(void) {
 
     world.system<>().expr("Position, [in] Velocity")
         .iter([](flecs::iter&it) {
-            flecs::field<Position> p(it, 1);
-            flecs::field<const Velocity> v(it, 2);
+            flecs::field<Position> p(it, 0);
+            flecs::field<const Velocity> v(it, 1);
 
             for (auto i : it) {
                 p[i].x += v[i].x;
@@ -342,12 +342,12 @@ void System_signature_shared(void) {
         .set<Position>({10, 20})
         .set<Velocity>({3, 4});
 
-    world.system<>().expr("Position, [in] Velocity(self|up)")
+    world.system<>().expr("Position, [in] Velocity(self|up IsA)")
         .iter([](flecs::iter&it) {
-            flecs::field<Position> p(it, 1);
-            flecs::field<const Velocity> v(it, 2);
+            flecs::field<Position> p(it, 0);
+            flecs::field<const Velocity> v(it, 1);
 
-            if (!it.is_self(2)) {
+            if (!it.is_self(1)) {
                 for (auto i : it) {
                     p[i].x += v->x;
                     p[i].y += v->y;
@@ -393,11 +393,11 @@ void System_signature_optional(void) {
 
     world.system<>().expr("Position, ?Velocity, ?Mass")
         .iter([](flecs::iter& it) {
-            flecs::field<Position> p(it, 1);
-            flecs::field<Velocity> v(it, 2);
-            flecs::field<Mass> m(it, 3);
+            flecs::field<Position> p(it, 0);
+            flecs::field<Velocity> v(it, 1);
+            flecs::field<Mass> m(it, 2);
 
-            if (it.is_set(2) && it.is_set(3)) {
+            if (it.is_set(1) && it.is_set(2)) {
                 for (auto i : it) {
                     p[i].x += v[i].x * m[i].value;
                     p[i].y += v[i].y * m[i].value;
@@ -671,7 +671,7 @@ void System_get_query(void) {
     auto q = sys.query();
 
     q.iter([&](flecs::iter &it) {
-        auto pos = it.field<const Position>(1);
+        auto pos = it.field<const Position>(0);
         for (auto i : it) {
             test_int(i, pos[i].x);
             count ++;
@@ -1041,7 +1041,7 @@ void System_test_auto_defer_each(void) {
     auto e3 = world.entity().add<Tag>().set<Value>({30});
 
     auto s = world.system<Value>()
-        .term<Tag>()
+        .with<Tag>()
         .each([](flecs::entity e, Value& v) {
             v.value ++;
             e.remove<Tag>();
@@ -1072,7 +1072,7 @@ void System_test_auto_defer_iter(void) {
     auto e3 = world.entity().add<Tag>().set<Value>({30});
 
     auto s = world.system<Value>()
-        .term<Tag>()
+        .with<Tag>()
         .iter([](flecs::iter& it, Value *v) {
             for (auto i : it) {
                 v[i].value ++;
@@ -1104,9 +1104,9 @@ void System_custom_pipeline(void) {
     auto Tag = world.entity();
 
     flecs::entity pip = world.pipeline()
-        .term(flecs::System)
-        .term(flecs::Phase).cascade(flecs::DependsOn)
-        .term(Tag)
+        .with(flecs::System)
+        .with(flecs::Phase).cascade(flecs::DependsOn)
+        .with(Tag)
         .build();
 
     int count = 0;
@@ -1150,8 +1150,8 @@ void System_custom_pipeline_w_kind(void) {
     auto Tag = world.entity();
 
     flecs::entity pip = world.pipeline()
-        .term(flecs::System)
-        .term(Tag)
+        .with(flecs::System)
+        .with(Tag)
         .build();
 
     int count = 0;
@@ -1203,7 +1203,7 @@ void System_instanced_query_w_singleton_each(void) {
     int32_t count = 0;
 
     auto s = ecs.system<Self, Position, const Velocity>()
-        .arg(3).singleton()
+        .term_at(2).singleton()
         .instanced()
         .each([&](flecs::entity e, Self& s, Position&p, const Velocity& v) {
             test_assert(e == s.value);
@@ -1322,7 +1322,7 @@ void System_un_instanced_query_w_singleton_each(void) {
     int32_t count = 0;
 
     auto s = ecs.system<Self, Position, const Velocity>()
-        .arg(3).singleton()
+        .term_at(2).singleton()
         .each([&](flecs::entity e, Self& s, Position&p, const Velocity& v) {
             test_assert(e == s.value);
             p.x += v.x;
@@ -1440,7 +1440,7 @@ void System_instanced_query_w_singleton_iter(void) {
     int32_t count = 0;
 
     auto s = ecs.system<Self, Position, const Velocity>()
-        .arg(3).singleton()
+        .term_at(2).singleton()
         .instanced()
         .iter([&](flecs::iter it, Self* s, Position* p, const Velocity* v) {
             test_assert(it.count() > 1);
@@ -1504,7 +1504,7 @@ void System_instanced_query_w_base_iter(void) {
             test_assert(it.count() > 1);
 
             for (auto i : it) {
-                if (it.is_self(3)) {
+                if (it.is_self(2)) {
                     p[i].x += v[i].x;
                     p[i].y += v[i].y;
                 } else {
@@ -1574,7 +1574,7 @@ void System_un_instanced_query_w_singleton_iter(void) {
     int32_t count = 0;
 
     auto s = ecs.system<Self, Position, const Velocity>()
-        .arg(3).singleton()
+        .term_at(2).singleton()
         .iter([&](flecs::iter it, Self* s, Position* p, const Velocity* v) {
             test_assert(it.count() == 1);
 
@@ -1690,7 +1690,7 @@ void System_create_w_no_template_args(void) {
     int32_t count = 0;
 
     auto s = world.system()
-        .term<Position>()
+        .with<Position>()
         .each([&](flecs::entity e) {
             test_assert(e == entity);
             count ++;
@@ -1716,8 +1716,8 @@ void System_system_w_type_kind_type_pipeline(void) {
         );
 
     world.pipeline<PipelineType>()
-        .term(flecs::System)
-        .term(flecs::Phase).cascade(flecs::DependsOn)
+        .with(flecs::System)
+        .with(flecs::Phase).cascade(flecs::DependsOn)
         .build();
 
     world.set_pipeline<PipelineType>();
@@ -1802,9 +1802,8 @@ void System_ensure_instanced_w_each(void) {
         });
 
     auto q = sys.query();
-    auto f = q.filter();
-    const ecs_filter_t *c_f = f;
-    test_assert(c_f->flags & EcsIterIsInstanced);
+    const ecs_query_t *c_f = q;
+    test_assert(c_f->flags & EcsQueryIsInstanced);
 
     test_int(count, 0);
     sys.run();
diff --git a/test/cpp_api/src/SystemBuilder.cpp b/test/cpp/src/SystemBuilder.cpp
similarity index 86%
rename from test/cpp_api/src/SystemBuilder.cpp
rename to test/cpp/src/SystemBuilder.cpp
index 6356f5a62..cdfbb6357 100644
--- a/test/cpp_api/src/SystemBuilder.cpp
+++ b/test/cpp/src/SystemBuilder.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void SystemBuilder_builder_assign_same_type(void) {
     flecs::world ecs;
@@ -48,8 +48,8 @@ void SystemBuilder_builder_build_n_statements(void) {
     int32_t count = 0;
 
     auto qb = ecs.system<>();
-    qb.term<Position>();
-    qb.term<Velocity>();
+    qb.with<Position>();
+    qb.with<Velocity>();
     auto s = qb.each([&](flecs::entity e) {
         count ++;
         test_assert(e == e1);
@@ -88,7 +88,7 @@ void SystemBuilder_add_1_type(void) {
     int32_t count = 0;
 
     auto s = ecs.system<>()
-        .term<Position>()
+        .with<Position>()
         .each([&](flecs::entity e) {
             count ++;
             test_assert(e == e1);
@@ -108,8 +108,8 @@ void SystemBuilder_add_2_types(void) {
     int32_t count = 0;
 
     auto s = ecs.system<>()
-        .term<Position>()
-        .term<Velocity>()
+        .with<Position>()
+        .with<Velocity>()
         .each([&](flecs::entity e) {
             count ++;
             test_assert(e == e1);
@@ -129,7 +129,7 @@ void SystemBuilder_add_1_type_w_1_type(void) {
     int32_t count = 0;
 
     auto s = ecs.system<Position>()
-        .term<Velocity>()
+        .with<Velocity>()
         .each([&](flecs::entity e, Position& p) {
             count ++;
             test_assert(e == e1);
@@ -149,8 +149,8 @@ void SystemBuilder_add_2_types_w_1_type(void) {
     int32_t count = 0;
 
     auto s = ecs.system<Position>()
-        .term<Velocity>()
-        .term<Mass>()
+        .with<Velocity>()
+        .with<Mass>()
         .each([&](flecs::entity e, Position& p) {
             count ++;
             test_assert(e == e1);
@@ -174,7 +174,7 @@ void SystemBuilder_add_pair(void) {
     int32_t count = 0;
 
     auto s = ecs.system<>()
-        .term(Likes, Bob)
+        .with(Likes, Bob)
         .each([&](flecs::entity e) {
             count ++;
             test_assert(e == e1);
@@ -194,7 +194,7 @@ void SystemBuilder_add_not(void) {
     int32_t count = 0;
 
     auto s = ecs.system<Position>()
-        .term<Velocity>().oper(flecs::Not)
+        .with<Velocity>().oper(flecs::Not)
         .each([&](flecs::entity e, Position& p) {
             count ++;
             test_assert(e == e1);
@@ -215,8 +215,8 @@ void SystemBuilder_add_or(void) {
     int32_t count = 0;
 
     auto s = ecs.system<>()
-        .term<Position>().oper(flecs::Or)
-        .term<Velocity>()
+        .with<Position>().oper(flecs::Or)
+        .with<Velocity>()
         .each([&](flecs::entity e) {
             count ++;
             test_assert(e == e1 || e == e2);
@@ -237,8 +237,8 @@ void SystemBuilder_add_optional(void) {
     int32_t count = 0;
 
     auto s = ecs.system<>()
-        .term<Position>()
-        .term<Velocity>().oper(flecs::Optional)
+        .with<Position>()
+        .with<Velocity>().oper(flecs::Optional)
         .each([&](flecs::entity e) {
             count ++;
             test_assert(e == e1 || e == e2);
@@ -324,10 +324,10 @@ void SystemBuilder_singleton_term(void) {
     int32_t count = 0;
 
     auto s = ecs.system<Entity>()
-        .term<Singleton>().singleton()
+        .with<Singleton>().singleton().in()
         .iter([&](flecs::iter& it, Entity *e) {
-            auto s = it.field<const Singleton>(2);
-            test_assert(!it.is_self(2));
+            auto s = it.field<const Singleton>(1);
+            test_assert(!it.is_self(1));
             test_int(s->value, 10);
             
             const Singleton& s_ref = *s;
@@ -367,16 +367,16 @@ void SystemBuilder_10_terms(void) {
         .add<TagJ>();
 
     auto s = ecs.system<>()
-        .term<TagA>()
-        .term<TagB>()
-        .term<TagC>()
-        .term<TagD>()
-        .term<TagE>()
-        .term<TagF>()
-        .term<TagG>()
-        .term<TagH>()
-        .term<TagI>()
-        .term<TagJ>()
+        .with<TagA>()
+        .with<TagB>()
+        .with<TagC>()
+        .with<TagD>()
+        .with<TagE>()
+        .with<TagF>()
+        .with<TagG>()
+        .with<TagH>()
+        .with<TagI>()
+        .with<TagJ>()
         .iter([&](flecs::iter& it) {
             test_int(it.count(), 1);
             test_assert(it.entity(0) == e);
@@ -389,7 +389,7 @@ void SystemBuilder_10_terms(void) {
     test_int(count, 1);
 }
 
-void SystemBuilder_20_terms(void) {
+void SystemBuilder_16_terms(void) {
     flecs::world ecs;
 
     int count = 0;
@@ -410,37 +410,29 @@ void SystemBuilder_20_terms(void) {
         .add<TagM>()
         .add<TagN>()
         .add<TagO>()
-        .add<TagP>()
-        .add<TagQ>()
-        .add<TagR>()
-        .add<TagS>()
-        .add<TagT>();
+        .add<TagP>();
 
     auto s = ecs.system<>()
-        .term<TagA>()
-        .term<TagB>()
-        .term<TagC>()
-        .term<TagD>()
-        .term<TagE>()
-        .term<TagF>()
-        .term<TagG>()
-        .term<TagH>()
-        .term<TagI>()
-        .term<TagJ>()
-        .term<TagK>()
-        .term<TagL>()
-        .term<TagM>()
-        .term<TagN>()
-        .term<TagO>()
-        .term<TagP>()
-        .term<TagQ>()
-        .term<TagR>()
-        .term<TagS>()
-        .term<TagT>()
+        .with<TagA>()
+        .with<TagB>()
+        .with<TagC>()
+        .with<TagD>()
+        .with<TagE>()
+        .with<TagF>()
+        .with<TagG>()
+        .with<TagH>()
+        .with<TagI>()
+        .with<TagJ>()
+        .with<TagK>()
+        .with<TagL>()
+        .with<TagM>()
+        .with<TagN>()
+        .with<TagO>()
+        .with<TagP>()
         .iter([&](flecs::iter& it) {
             test_int(it.count(), 1);
             test_assert(it.entity(0) == e);
-            test_int(it.field_count(), 20);
+            test_int(it.field_count(), 16);
             count ++;
         });
 
@@ -453,7 +445,7 @@ void SystemBuilder_name_arg(void) {
     flecs::world ecs;
 
     auto s = ecs.system<const Position>("MySystem")
-        .arg(1).src().name("MySystem")
+        .term_at(0).src().name("MySystem")
         .iter([](flecs::iter& Iter, const Position* Config)
         { });
 
@@ -468,7 +460,7 @@ void SystemBuilder_create_w_no_template_args(void) {
     int32_t count = 0;
 
     auto s = ecs.system()
-        .term<Position>()
+        .with<Position>()
         .each([&](flecs::entity e) {
             count ++;
             test_assert(e == e1);
@@ -490,7 +482,7 @@ void SystemBuilder_write_annotation(void) {
     int32_t a_count = 0, b_count = 0;
 
     ecs.system<TagA>()
-        .term<TagB>().write()
+        .with<TagB>().write()
         .each([&](flecs::entity e, TagA) {
             a_count ++;
             test_assert(e == e1);
diff --git a/test/cpp_api/src/Table.cpp b/test/cpp/src/Table.cpp
similarity index 97%
rename from test/cpp_api/src/Table.cpp
rename to test/cpp/src/Table.cpp
index c3b2baf19..004b94b42 100644
--- a/test/cpp_api/src/Table.cpp
+++ b/test/cpp/src/Table.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void Table_each(void) {
     flecs::world ecs;
@@ -6,7 +6,7 @@ void Table_each(void) {
     ecs.entity().add<Position>();
     auto e2 = ecs.entity().add<Velocity>();
 
-    ecs.filter<Position>()
+    ecs.query<Position>()
         .each([&](flecs::entity e, Position& p) {
             e2.add<Mass>();
         });
@@ -21,7 +21,7 @@ void Table_each_locked(void) {
 
     auto e1 = ecs.entity().add<Position>();
 
-    ecs.filter<Position>()
+    ecs.query<Position>()
         .each([&](flecs::entity e, Position& p) {
             test_expect_abort();
             e1.add<Mass>();
@@ -36,7 +36,7 @@ void Table_each_without_entity(void) {
     ecs.entity().add<Position>();
     auto e2 = ecs.entity().add<Velocity>();
 
-    ecs.filter<Position>()
+    ecs.query<Position>()
         .each([&](Position& p) {
             e2.add<Mass>();
         });
@@ -51,7 +51,7 @@ void Table_each_without_entity_locked(void) {
 
     auto e1 = ecs.entity().add<Position>();
 
-    ecs.filter<Position>()
+    ecs.query<Position>()
         .each([&](Position& p) {
             test_expect_abort();
             e1.add<Mass>();
@@ -66,7 +66,7 @@ void Table_iter(void) {
     ecs.entity().add<Position>();
     auto e2 = ecs.entity().add<Velocity>();
 
-    ecs.filter<Position>()
+    ecs.query<Position>()
         .iter([&](flecs::iter& it, Position* p) {
             e2.add<Mass>();
         });
@@ -81,7 +81,7 @@ void Table_iter_locked(void) {
 
     auto e1 = ecs.entity().add<Position>();
 
-    ecs.filter<Position>()
+    ecs.query<Position>()
         .iter([&](flecs::iter& it, Position* p) {
             test_expect_abort();
             e1.add<Mass>();
@@ -96,7 +96,7 @@ void Table_iter_without_components(void) {
     ecs.entity().add<Position>();
     auto e2 = ecs.entity().add<Velocity>();
 
-    ecs.filter<Position>()
+    ecs.query<Position>()
         .iter([&](flecs::iter& it) {
             e2.add<Mass>();
         });
@@ -111,7 +111,7 @@ void Table_iter_without_components_locked(void) {
 
     auto e1 = ecs.entity().add<Position>();
 
-    ecs.filter<Position>()
+    ecs.query<Position>()
         .iter([&](flecs::iter& it) {
             test_expect_abort();
             e1.add<Mass>();
@@ -155,7 +155,7 @@ void Table_multi_set(void) {
     auto e1 = ecs.entity().add<Position>().add<Velocity>();
     auto e2 = ecs.entity().add<Position>();
 
-    e1.set([&](Position& p, Velocity& v) {
+    e1.insert([&](Position& p, Velocity& v) {
         e2.add<Mass>();
     });
 
@@ -170,7 +170,7 @@ void Table_multi_set_locked(void) {
     auto e1 = ecs.entity().add<Position>().add<Velocity>();
     auto e2 = ecs.entity().add<Position>();
 
-    e1.set([&](Position& p, Velocity& v) {
+    e1.insert([&](Position& p, Velocity& v) {
         test_expect_abort();
         e2.add<Velocity>();
     });
diff --git a/test/cpp_api/src/Trigger.cpp b/test/cpp/src/Trigger.cpp
similarity index 100%
rename from test/cpp_api/src/Trigger.cpp
rename to test/cpp/src/Trigger.cpp
diff --git a/test/cpp_api/src/World.cpp b/test/cpp/src/World.cpp
similarity index 98%
rename from test/cpp_api/src/World.cpp
rename to test/cpp/src/World.cpp
index b76919d46..771ad59df 100644
--- a/test/cpp_api/src/World.cpp
+++ b/test/cpp/src/World.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void World_multi_world_empty(void) {
     flecs::world *w1 = new flecs::world();
@@ -92,7 +92,6 @@ void World_builtin_components(void) {
     test_assert(ecs.component<flecs::Component>() == ecs_id(EcsComponent));
     test_assert(ecs.component<flecs::Identifier>() == ecs_id(EcsIdentifier));
     test_assert(ecs.component<flecs::Poly>() == ecs_id(EcsPoly));
-    test_assert(ecs.component<flecs::FlattenTarget>() == ecs_id(EcsFlattenTarget));
     test_assert(ecs.component<flecs::RateFilter>() == ecs_id(EcsRateFilter));
     test_assert(ecs.component<flecs::TickSource>() == ecs_id(EcsTickSource));
     test_assert(flecs::Name == EcsName);
@@ -222,7 +221,7 @@ void World_reregister_after_reset(void) {
     auto p1 = ecs.component<Position>("Position");
 
     // Simulate different binary
-    flecs::_::cpp_type<Position>::reset();
+    flecs::_::type<Position>::reset();
 
     auto p2 = ecs.component<Position>("Position");
 
@@ -237,7 +236,7 @@ void World_implicit_reregister_after_reset(void) {
     flecs::entity_t p_id_1 = flecs::type_id<Position>();
 
     // Simulate different binary
-    flecs::_::cpp_type<Position>::reset();
+    flecs::_::type<Position>::reset();
 
     ecs.entity().add<Position>();
 
@@ -254,7 +253,7 @@ void World_reregister_after_reset_w_namespace(void) {
     flecs::entity_t p_id_1 = flecs::type_id<ns::FooComp>();
 
     // Simulate different binary
-    flecs::_::cpp_type<ns::FooComp>::reset();
+    flecs::_::type<ns::FooComp>::reset();
 
     ecs.component<ns::FooComp>();
 
@@ -287,7 +286,7 @@ void World_reregister_after_reset_different_name(void) {
     ecs.component<Position>("Position");
 
     // Simulate different binary
-    flecs::_::cpp_type<Position>::reset();
+    flecs::_::type<Position>::reset();
 
     ecs.component<Position>("Velocity");
 }
@@ -300,7 +299,7 @@ void World_register_component_w_reset_in_multithreaded(void) {
     flecs::entity pos = ecs.component<Position>();
     flecs::entity e = ecs.entity();
 
-    flecs::_::cpp_type<Position>::reset();
+    flecs::_::type<Position>::reset();
 
     ecs.readonly_begin();
     e.set<Position>({10, 20});
@@ -357,7 +356,7 @@ void World_reimport_module_after_reset(void) {
     auto m1 = ecs.import<FooModule>();
 
     // Simulate different binary
-    flecs::_::cpp_type<FooModule>::reset();
+    flecs::_::type<FooModule>::reset();
 
     auto m2 = ecs.import<FooModule>();
     
@@ -415,7 +414,7 @@ void World_c_interop_after_reset(void) {
     auto e_pos = ecs.lookup("test::interop::module::Position");
     test_assert(e_pos.id() != 0);
 
-    flecs::_::cpp_type<test::interop::module>::reset();
+    flecs::_::type<test::interop::module>::reset();
 
     ecs.import<test::interop::module>();
 }
@@ -642,7 +641,7 @@ void World_with_tag(void) {
     auto self = ecs.component<Self>();
     test_assert(!self.has(Tag));    
 
-    auto q = ecs.query_builder<>().term(Tag).build();
+    auto q = ecs.query_builder<>().with(Tag).build();
 
     int32_t count = 0;
 
@@ -675,7 +674,7 @@ void World_with_tag_type(void) {
     auto self = ecs.component<Self>();
     test_assert(!self.has<Tag>());
 
-    auto q = ecs.query_builder<>().term<Tag>().build();
+    auto q = ecs.query_builder<>().with<Tag>().build();
 
     int32_t count = 0;
 
@@ -709,7 +708,7 @@ void World_with_relation(void) {
     auto self = ecs.component<Self>();
     test_assert(!self.has(Likes, Bob));
 
-    auto q = ecs.query_builder<>().term(Likes, Bob).build();
+    auto q = ecs.query_builder<>().with(Likes, Bob).build();
 
     int32_t count = 0;
 
@@ -743,7 +742,7 @@ void World_with_relation_type(void) {
     auto self = ecs.component<Self>();
     test_assert(!self.has<Likes>(Bob));
 
-    auto q = ecs.query_builder<>().term<Likes>(Bob).build();
+    auto q = ecs.query_builder<>().with<Likes>(Bob).build();
 
     int32_t count = 0;
 
@@ -777,7 +776,7 @@ void World_with_relation_object_type(void) {
     auto self = ecs.component<Self>();
     test_assert(!(self.has<Likes, Bob>()));
 
-    auto q = ecs.query_builder<>().term<Likes, Bob>().build();
+    auto q = ecs.query_builder<>().with<Likes, Bob>().build();
 
     int32_t count = 0;
 
@@ -832,7 +831,7 @@ void World_with_scope(void) {
     test_assert(!self.has(flecs::ChildOf, parent));
 
     int count = 0;
-    auto q = ecs.query_builder<>().term(flecs::ChildOf, parent).build();
+    auto q = ecs.query_builder<>().with(flecs::ChildOf, parent).build();
 
     q.each([&](flecs::entity e) {
         test_assert(e.has(flecs::ChildOf, parent));
@@ -984,7 +983,7 @@ void World_type_w_tag_name(void) {
     auto c = ecs.component<Tag>();
     test_assert(c != flecs::entity());
     test_str(c.path().c_str(), "::Tag");
-    test_assert(c != flecs::Tag);
+    test_assert(c != flecs::PairIsTag);
 }
 
 void World_entity_w_tag_name(void) {
@@ -993,7 +992,7 @@ void World_entity_w_tag_name(void) {
     auto c = ecs.entity("Tag");
     test_assert(c != flecs::entity());
     test_str(c.path().c_str(), "::Tag");
-    test_assert(c != flecs::Tag);
+    test_assert(c != flecs::PairIsTag);
 }
 
 template <typename T>
@@ -1927,3 +1926,9 @@ void World_get_mut_R_T(void) {
     test_int(p->y, 20);
 }
 
+void World_copy_world(void) {
+    flecs::world world_1;
+    flecs::world world_2 = world_1;
+
+    test_assert(world_1.c_ptr() == world_2.c_ptr());
+}
diff --git a/test/cpp_api/src/WorldFactory.cpp b/test/cpp/src/WorldFactory.cpp
similarity index 86%
rename from test/cpp_api/src/WorldFactory.cpp
rename to test/cpp/src/WorldFactory.cpp
index 6d77d8a48..05a6f00be 100644
--- a/test/cpp_api/src/WorldFactory.cpp
+++ b/test/cpp/src/WorldFactory.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void WorldFactory_entity(void) {
     flecs::world ecs;
@@ -93,8 +93,8 @@ void WorldFactory_system_w_expr(void) {
     auto s = ecs.system<>("MySystem")
         .expr("Position, [in] Velocity")
         .iter([](flecs::iter it) {
-            flecs::field<Position> p(it, 1);
-            flecs::field<const Velocity> v(it, 2);
+            flecs::field<Position> p(it, 0);
+            flecs::field<const Velocity> v(it, 1);
 
             for (auto i : it) {
                 p[i].x += v[i].x;
@@ -148,8 +148,8 @@ void WorldFactory_query_w_expr(void) {
         .set<Velocity>({1, 2});
 
     q.iter([](flecs::iter it) {
-        flecs::field<Position> p(it, 1);
-        flecs::field<const Velocity> v(it, 2);
+        flecs::field<Position> p(it, 0);
+        flecs::field<const Velocity> v(it, 1);
 
         for (auto i : it) {
             p[i].x += v[i].x;
@@ -162,27 +162,6 @@ void WorldFactory_query_w_expr(void) {
     test_int(p->y, 22);
 }
 
-void WorldFactory_snapshot(void) {
-    flecs::world ecs;
-
-    ecs.component<Position>();
-    ecs.component<Velocity>();
-
-    auto e = ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    auto s = ecs.snapshot();
-
-    e.set<Position>({11, 22});
-
-    s.restore();
-
-    const Position *p = e.get<Position>();
-    test_int(p->x, 11);
-    test_int(p->y, 22);
-}
-
 class MyModule {
 public:
     MyModule(flecs::world& ecs) {
diff --git a/test/cpp_api/src/main.cpp b/test/cpp/src/main.cpp
similarity index 87%
rename from test/cpp_api/src/main.cpp
rename to test/cpp/src/main.cpp
index dca53c011..5c9c3a74e 100644
--- a/test/cpp_api/src/main.cpp
+++ b/test/cpp/src/main.cpp
@@ -6,7 +6,7 @@
  * ----------------------------------------------------------------------------
  */
 
-#include <cpp_api.h>
+#include <cpp.h>
 
 // Testsuite 'PrettyFunction'
 void PrettyFunction_component(void);
@@ -266,6 +266,10 @@ void Entity_emplace_w_observer(void);
 void Entity_scoped_world(void);
 void Entity_entity_lookup_not_recursive(void);
 void Entity_world_lookup_not_recursive(void);
+void Entity_world_lookup_custom_sep(void);
+void Entity_world_lookup_custom_root_sep(void);
+void Entity_depends_on(void);
+void Entity_depends_on_type(void);
 
 // Testsuite 'Pairs'
 void Pairs_add_component_pair(void);
@@ -377,18 +381,6 @@ void Enum_mixed_auto_manual_constants(void);
 void Enum_enum_class_mixed_auto_manual_constants(void);
 void Enum_enum_child_count(void);
 
-// Testsuite 'Switch'
-void Switch_add_case(void);
-void Switch_get_case(void);
-void Switch_system_w_case(void);
-void Switch_system_w_case_builder(void);
-void Switch_system_w_sw_type_builder(void);
-void Switch_system_w_switch(void);
-void Switch_add_case_w_type(void);
-void Switch_add_switch_w_type(void);
-void Switch_add_remove_switch_w_type(void);
-void Switch_switch_enum_type(void);
-
 // Testsuite 'Paths'
 void Paths_name(void);
 void Paths_path_depth_1(void);
@@ -518,6 +510,18 @@ void Iterable_worker_each(void);
 void Iterable_worker_iter(void);
 
 // Testsuite 'Query'
+void Query_term_each_component(void);
+void Query_term_each_tag(void);
+void Query_term_each_id(void);
+void Query_term_each_pair_type(void);
+void Query_term_each_pair_id(void);
+void Query_term_each_pair_relation_wildcard(void);
+void Query_term_each_pair_object_wildcard(void);
+void Query_term_get_id(void);
+void Query_term_get_subj(void);
+void Query_term_get_pred(void);
+void Query_term_get_obj(void);
+void Query_set_this_var(void);
 void Query_action(void);
 void Query_action_const(void);
 void Query_action_shared(void);
@@ -530,14 +534,11 @@ void Query_signature(void);
 void Query_signature_const(void);
 void Query_signature_shared(void);
 void Query_signature_optional(void);
-void Query_subquery(void);
-void Query_subquery_w_expr(void);
 void Query_query_single_pair(void);
 void Query_tag_w_each(void);
 void Query_shared_tag_w_each(void);
 void Query_sort_by(void);
 void Query_changed(void);
-void Query_orphaned(void);
 void Query_default_ctor(void);
 void Query_default_ctor_no_assign(void);
 void Query_expr_w_template(void);
@@ -610,15 +611,38 @@ void Query_find(void);
 void Query_find_not_found(void);
 void Query_find_w_entity(void);
 void Query_optional_pair_term(void);
+void Query_query_from_entity(void);
+void Query_query_from_entity_name(void);
 
 // Testsuite 'QueryBuilder'
+void QueryBuilder_setup(void);
 void QueryBuilder_builder_assign_same_type(void);
 void QueryBuilder_builder_assign_from_empty(void);
 void QueryBuilder_builder_assign_to_empty(void);
 void QueryBuilder_builder_build(void);
 void QueryBuilder_builder_build_to_auto(void);
 void QueryBuilder_builder_build_n_statements(void);
+void QueryBuilder_builder_force_assign_operator(void);
 void QueryBuilder_1_type(void);
+void QueryBuilder_2_types(void);
+void QueryBuilder_id_term(void);
+void QueryBuilder_type_term(void);
+void QueryBuilder_id_pair_term(void);
+void QueryBuilder_id_pair_wildcard_term(void);
+void QueryBuilder_type_pair_term(void);
+void QueryBuilder_pair_term_w_var(void);
+void QueryBuilder_2_pair_terms_w_var(void);
+void QueryBuilder_set_var(void);
+void QueryBuilder_set_2_vars(void);
+void QueryBuilder_set_var_by_name(void);
+void QueryBuilder_set_2_vars_by_name(void);
+void QueryBuilder_expr_w_var(void);
+void QueryBuilder_set_var_on_query(void);
+void QueryBuilder_set_var_by_name_on_query(void);
+void QueryBuilder_set_table_var(void);
+void QueryBuilder_set_range_var(void);
+void QueryBuilder_set_table_var_chained(void);
+void QueryBuilder_set_range_var_chained(void);
 void QueryBuilder_add_1_type(void);
 void QueryBuilder_add_2_types(void);
 void QueryBuilder_add_1_type_w_1_type(void);
@@ -659,9 +683,71 @@ void QueryBuilder_explicit_term_w_id(void);
 void QueryBuilder_explicit_term_w_pair_id(void);
 void QueryBuilder_1_term_to_empty(void);
 void QueryBuilder_2_subsequent_args(void);
-void QueryBuilder_optional_tag_is_set(void);
+void QueryBuilder_filter_as_move_arg(void);
+void QueryBuilder_filter_as_return(void);
+void QueryBuilder_filter_copy(void);
+void QueryBuilder_world_each_filter_1_component(void);
+void QueryBuilder_world_each_filter_2_components(void);
+void QueryBuilder_world_each_filter_1_component_no_entity(void);
+void QueryBuilder_world_each_filter_2_components_no_entity(void);
 void QueryBuilder_10_terms(void);
-void QueryBuilder_20_terms(void);
+void QueryBuilder_16_terms(void);
+void QueryBuilder_term_after_arg(void);
+void QueryBuilder_name_arg(void);
+void QueryBuilder_const_in_term(void);
+void QueryBuilder_const_optional(void);
+void QueryBuilder_create_w_no_template_args(void);
+void QueryBuilder_2_terms_w_expr(void);
+void QueryBuilder_assert_on_uninitialized_term(void);
+void QueryBuilder_operator_shortcuts(void);
+void QueryBuilder_inout_shortcuts(void);
+void QueryBuilder_iter_column_w_const_as_array(void);
+void QueryBuilder_iter_column_w_const_as_ptr(void);
+void QueryBuilder_iter_column_w_const_deref(void);
+void QueryBuilder_with_id(void);
+void QueryBuilder_with_name(void);
+void QueryBuilder_with_component(void);
+void QueryBuilder_with_pair_id(void);
+void QueryBuilder_with_pair_name(void);
+void QueryBuilder_with_pair_components(void);
+void QueryBuilder_with_pair_component_id(void);
+void QueryBuilder_with_pair_component_name(void);
+void QueryBuilder_with_enum(void);
+void QueryBuilder_without_id(void);
+void QueryBuilder_without_name(void);
+void QueryBuilder_without_component(void);
+void QueryBuilder_without_pair_id(void);
+void QueryBuilder_without_pair_name(void);
+void QueryBuilder_without_pair_components(void);
+void QueryBuilder_without_pair_component_id(void);
+void QueryBuilder_without_pair_component_name(void);
+void QueryBuilder_without_enum(void);
+void QueryBuilder_write_id(void);
+void QueryBuilder_write_name(void);
+void QueryBuilder_write_component(void);
+void QueryBuilder_write_pair_id(void);
+void QueryBuilder_write_pair_name(void);
+void QueryBuilder_write_pair_components(void);
+void QueryBuilder_write_pair_component_id(void);
+void QueryBuilder_write_pair_component_name(void);
+void QueryBuilder_write_enum(void);
+void QueryBuilder_read_id(void);
+void QueryBuilder_read_name(void);
+void QueryBuilder_read_component(void);
+void QueryBuilder_read_pair_id(void);
+void QueryBuilder_read_pair_name(void);
+void QueryBuilder_read_pair_components(void);
+void QueryBuilder_read_pair_component_id(void);
+void QueryBuilder_read_pair_component_name(void);
+void QueryBuilder_read_enum(void);
+void QueryBuilder_assign_after_init(void);
+void QueryBuilder_iter_w_stage(void);
+void QueryBuilder_with_t_inout(void);
+void QueryBuilder_with_T_inout(void);
+void QueryBuilder_with_R_T_inout(void);
+void QueryBuilder_with_R_t_inout(void);
+void QueryBuilder_with_r_t_inout(void);
+void QueryBuilder_optional_tag_is_set(void);
 void QueryBuilder_group_by_raw(void);
 void QueryBuilder_group_by_template(void);
 void QueryBuilder_group_by_iter_one(void);
@@ -670,6 +756,8 @@ void QueryBuilder_group_by_iter_one_all_groups(void);
 void QueryBuilder_group_by_default_func_w_id(void);
 void QueryBuilder_group_by_default_func_w_type(void);
 void QueryBuilder_group_by_callbacks(void);
+void QueryBuilder_set_group_on_query(void);
+void QueryBuilder_set_group_type_on_query(void);
 void QueryBuilder_create_w_no_template_args(void);
 void QueryBuilder_any_wildcard(void);
 void QueryBuilder_cascade(void);
@@ -680,157 +768,16 @@ void QueryBuilder_cascade_desc(void);
 void QueryBuilder_named_query(void);
 void QueryBuilder_term_w_write(void);
 void QueryBuilder_term_w_read(void);
-void QueryBuilder_iter_w_stage(void);
-
-// Testsuite 'FilterBuilder'
-void FilterBuilder_builder_assign_same_type(void);
-void FilterBuilder_builder_assign_from_empty(void);
-void FilterBuilder_builder_assign_to_empty(void);
-void FilterBuilder_builder_build(void);
-void FilterBuilder_builder_build_to_auto(void);
-void FilterBuilder_builder_build_n_statements(void);
-void FilterBuilder_builder_force_assign_operator(void);
-void FilterBuilder_1_type(void);
-void FilterBuilder_add_1_type(void);
-void FilterBuilder_add_2_types(void);
-void FilterBuilder_add_1_type_w_1_type(void);
-void FilterBuilder_add_2_types_w_1_type(void);
-void FilterBuilder_add_pair(void);
-void FilterBuilder_add_not(void);
-void FilterBuilder_add_or(void);
-void FilterBuilder_add_optional(void);
-void FilterBuilder_ptr_type(void);
-void FilterBuilder_const_type(void);
-void FilterBuilder_string_term(void);
-void FilterBuilder_singleton_term(void);
-void FilterBuilder_isa_superset_term(void);
-void FilterBuilder_isa_self_superset_term(void);
-void FilterBuilder_childof_superset_term(void);
-void FilterBuilder_childof_self_superset_term(void);
-void FilterBuilder_isa_superset_term_w_each(void);
-void FilterBuilder_isa_self_superset_term_w_each(void);
-void FilterBuilder_childof_superset_term_w_each(void);
-void FilterBuilder_childof_self_superset_term_w_each(void);
-void FilterBuilder_isa_superset_shortcut(void);
-void FilterBuilder_isa_superset_shortcut_w_self(void);
-void FilterBuilder_childof_superset_shortcut(void);
-void FilterBuilder_childof_superset_shortcut_w_self(void);
-void FilterBuilder_relation(void);
-void FilterBuilder_relation_w_object_wildcard(void);
-void FilterBuilder_relation_w_predicate_wildcard(void);
-void FilterBuilder_add_pair_w_rel_type(void);
-void FilterBuilder_template_term(void);
-void FilterBuilder_explicit_subject_w_id(void);
-void FilterBuilder_explicit_subject_w_type(void);
-void FilterBuilder_explicit_object_w_id(void);
-void FilterBuilder_explicit_object_w_type(void);
-void FilterBuilder_explicit_term(void);
-void FilterBuilder_explicit_term_w_type(void);
-void FilterBuilder_explicit_term_w_pair_type(void);
-void FilterBuilder_explicit_term_w_id(void);
-void FilterBuilder_explicit_term_w_pair_id(void);
-void FilterBuilder_1_term_to_empty(void);
-void FilterBuilder_2_subsequent_args(void);
-void FilterBuilder_filter_as_arg(void);
-void FilterBuilder_filter_as_move_arg(void);
-void FilterBuilder_filter_as_return(void);
-void FilterBuilder_filter_copy(void);
-void FilterBuilder_world_each_filter_1_component(void);
-void FilterBuilder_world_each_filter_2_components(void);
-void FilterBuilder_world_each_filter_1_component_no_entity(void);
-void FilterBuilder_world_each_filter_2_components_no_entity(void);
-void FilterBuilder_10_terms(void);
-void FilterBuilder_20_terms(void);
-void FilterBuilder_term_after_arg(void);
-void FilterBuilder_name_arg(void);
-void FilterBuilder_const_in_term(void);
-void FilterBuilder_const_optional(void);
-void FilterBuilder_create_w_no_template_args(void);
-void FilterBuilder_2_terms_w_expr(void);
-void FilterBuilder_assert_on_uninitialized_term(void);
-void FilterBuilder_operator_shortcuts(void);
-void FilterBuilder_inout_shortcuts(void);
-void FilterBuilder_iter_column_w_const_as_array(void);
-void FilterBuilder_iter_column_w_const_as_ptr(void);
-void FilterBuilder_iter_column_w_const_deref(void);
-void FilterBuilder_with_id(void);
-void FilterBuilder_with_name(void);
-void FilterBuilder_with_component(void);
-void FilterBuilder_with_pair_id(void);
-void FilterBuilder_with_pair_name(void);
-void FilterBuilder_with_pair_components(void);
-void FilterBuilder_with_pair_component_id(void);
-void FilterBuilder_with_pair_component_name(void);
-void FilterBuilder_with_enum(void);
-void FilterBuilder_without_id(void);
-void FilterBuilder_without_name(void);
-void FilterBuilder_without_component(void);
-void FilterBuilder_without_pair_id(void);
-void FilterBuilder_without_pair_name(void);
-void FilterBuilder_without_pair_components(void);
-void FilterBuilder_without_pair_component_id(void);
-void FilterBuilder_without_pair_component_name(void);
-void FilterBuilder_without_enum(void);
-void FilterBuilder_write_id(void);
-void FilterBuilder_write_name(void);
-void FilterBuilder_write_component(void);
-void FilterBuilder_write_pair_id(void);
-void FilterBuilder_write_pair_name(void);
-void FilterBuilder_write_pair_components(void);
-void FilterBuilder_write_pair_component_id(void);
-void FilterBuilder_write_pair_component_name(void);
-void FilterBuilder_write_enum(void);
-void FilterBuilder_read_id(void);
-void FilterBuilder_read_name(void);
-void FilterBuilder_read_component(void);
-void FilterBuilder_read_pair_id(void);
-void FilterBuilder_read_pair_name(void);
-void FilterBuilder_read_pair_components(void);
-void FilterBuilder_read_pair_component_id(void);
-void FilterBuilder_read_pair_component_name(void);
-void FilterBuilder_read_enum(void);
-void FilterBuilder_assign_after_init(void);
-void FilterBuilder_iter_w_stage(void);
-void FilterBuilder_with_t_inout(void);
-void FilterBuilder_with_T_inout(void);
-void FilterBuilder_with_R_T_inout(void);
-void FilterBuilder_with_R_t_inout(void);
-void FilterBuilder_with_r_t_inout(void);
-
-// Testsuite 'RuleBuilder'
-void RuleBuilder_1_type(void);
-void RuleBuilder_2_types(void);
-void RuleBuilder_id_term(void);
-void RuleBuilder_type_term(void);
-void RuleBuilder_id_pair_term(void);
-void RuleBuilder_id_pair_wildcard_term(void);
-void RuleBuilder_type_pair_term(void);
-void RuleBuilder_pair_term_w_var(void);
-void RuleBuilder_2_pair_terms_w_var(void);
-void RuleBuilder_set_var(void);
-void RuleBuilder_set_2_vars(void);
-void RuleBuilder_set_var_by_name(void);
-void RuleBuilder_set_2_vars_by_name(void);
-void RuleBuilder_expr_w_var(void);
-void RuleBuilder_get_first(void);
-void RuleBuilder_get_count_direct(void);
-void RuleBuilder_get_is_true_direct(void);
-void RuleBuilder_get_first_direct(void);
-void RuleBuilder_var_src_w_prefixed_name(void);
-void RuleBuilder_var_first_w_prefixed_name(void);
-void RuleBuilder_var_second_w_prefixed_name(void);
-void RuleBuilder_term_w_second_var_string(void);
-void RuleBuilder_term_type_w_second_var_string(void);
-void RuleBuilder_named_rule(void);
-void RuleBuilder_named_scoped_rule(void);
-void RuleBuilder_is_valid(void);
-void RuleBuilder_unresolved_by_name(void);
-void RuleBuilder_scope(void);
-void RuleBuilder_iter_w_stage(void);
-void RuleBuilder_inspect_terms_w_expr(void);
-void RuleBuilder_find(void);
-void RuleBuilder_find_not_found(void);
-void RuleBuilder_find_w_entity(void);
+void QueryBuilder_var_src_w_prefixed_name(void);
+void QueryBuilder_var_first_w_prefixed_name(void);
+void QueryBuilder_var_second_w_prefixed_name(void);
+void QueryBuilder_term_w_second_var_string(void);
+void QueryBuilder_term_type_w_second_var_string(void);
+void QueryBuilder_named_rule(void);
+void QueryBuilder_named_scoped_rule(void);
+void QueryBuilder_is_valid(void);
+void QueryBuilder_unresolved_by_name(void);
+void QueryBuilder_scope(void);
 
 // Testsuite 'SystemBuilder'
 void SystemBuilder_builder_assign_same_type(void);
@@ -850,7 +797,7 @@ void SystemBuilder_const_type(void);
 void SystemBuilder_string_term(void);
 void SystemBuilder_singleton_term(void);
 void SystemBuilder_10_terms(void);
-void SystemBuilder_20_terms(void);
+void SystemBuilder_16_terms(void);
 void SystemBuilder_name_arg(void);
 void SystemBuilder_create_w_no_template_args(void);
 void SystemBuilder_write_annotation(void);
@@ -862,7 +809,7 @@ void Observer_2_terms_on_remove(void);
 void Observer_2_terms_on_set(void);
 void Observer_2_terms_un_set(void);
 void Observer_10_terms(void);
-void Observer_20_terms(void);
+void Observer_16_terms(void);
 void Observer_2_entities_iter(void);
 void Observer_2_entities_table_column(void);
 void Observer_2_entities_each(void);
@@ -890,35 +837,6 @@ void Observer_add_in_yield_existing(void);
 void Observer_add_in_yield_existing_multi(void);
 void Observer_name_from_root(void);
 
-// Testsuite 'Filter'
-void Filter_term_each_component(void);
-void Filter_term_each_tag(void);
-void Filter_term_each_id(void);
-void Filter_term_each_pair_type(void);
-void Filter_term_each_pair_id(void);
-void Filter_term_each_pair_relation_wildcard(void);
-void Filter_term_each_pair_object_wildcard(void);
-void Filter_default_ctor_no_assign(void);
-void Filter_term_get_id(void);
-void Filter_term_get_subj(void);
-void Filter_term_get_pred(void);
-void Filter_term_get_obj(void);
-void Filter_get_first(void);
-void Filter_get_count_direct(void);
-void Filter_get_is_true_direct(void);
-void Filter_get_first_direct(void);
-void Filter_each_w_no_this(void);
-void Filter_each_w_iter_no_this(void);
-void Filter_invalid_each_w_no_this(void);
-void Filter_named_filter(void);
-void Filter_named_scoped_filter(void);
-void Filter_set_this_var(void);
-void Filter_inspect_terms_w_expr(void);
-void Filter_find(void);
-void Filter_find_not_found(void);
-void Filter_find_w_entity(void);
-void Filter_optional_pair_term(void);
-
 // Testsuite 'ComponentLifecycle'
 void ComponentLifecycle_ctor_on_add(void);
 void ComponentLifecycle_dtor_on_remove(void);
@@ -1060,9 +978,6 @@ void ImplicitComponents_implicit_ref(void);
 void ImplicitComponents_implicit_const_ref(void);
 void ImplicitComponents_vector_elem_type(void);
 
-// Testsuite 'Snapshot'
-void Snapshot_simple_snapshot(void);
-
 // Testsuite 'WorldFactory'
 void WorldFactory_entity(void);
 void WorldFactory_entity_w_name(void);
@@ -1074,7 +989,6 @@ void WorldFactory_system_w_name(void);
 void WorldFactory_system_w_expr(void);
 void WorldFactory_query(void);
 void WorldFactory_query_w_expr(void);
-void WorldFactory_snapshot(void);
 void WorldFactory_module(void);
 
 // Testsuite 'World'
@@ -1190,6 +1104,7 @@ void World_atfini(void);
 void World_atfini_w_ctx(void);
 void World_get_mut_T(void);
 void World_get_mut_R_T(void);
+void World_copy_world(void);
 
 // Testsuite 'Singleton'
 void Singleton_set_get_singleton(void);
@@ -2388,6 +2303,22 @@ bake_test_case Entity_testcases[] = {
     {
         "world_lookup_not_recursive",
         Entity_world_lookup_not_recursive
+    },
+    {
+        "world_lookup_custom_sep",
+        Entity_world_lookup_custom_sep
+    },
+    {
+        "world_lookup_custom_root_sep",
+        Entity_world_lookup_custom_root_sep
+    },
+    {
+        "depends_on",
+        Entity_depends_on
+    },
+    {
+        "depends_on_type",
+        Entity_depends_on_type
     }
 };
 
@@ -2821,49 +2752,6 @@ bake_test_case Enum_testcases[] = {
     }
 };
 
-bake_test_case Switch_testcases[] = {
-    {
-        "add_case",
-        Switch_add_case
-    },
-    {
-        "get_case",
-        Switch_get_case
-    },
-    {
-        "system_w_case",
-        Switch_system_w_case
-    },
-    {
-        "system_w_case_builder",
-        Switch_system_w_case_builder
-    },
-    {
-        "system_w_sw_type_builder",
-        Switch_system_w_sw_type_builder
-    },
-    {
-        "system_w_switch",
-        Switch_system_w_switch
-    },
-    {
-        "add_case_w_type",
-        Switch_add_case_w_type
-    },
-    {
-        "add_switch_w_type",
-        Switch_add_switch_w_type
-    },
-    {
-        "add_remove_switch_w_type",
-        Switch_add_remove_switch_w_type
-    },
-    {
-        "switch_enum_type",
-        Switch_switch_enum_type
-    }
-};
-
 bake_test_case Paths_testcases[] = {
     {
         "name",
@@ -3357,6 +3245,54 @@ bake_test_case Iterable_testcases[] = {
 };
 
 bake_test_case Query_testcases[] = {
+    {
+        "term_each_component",
+        Query_term_each_component
+    },
+    {
+        "term_each_tag",
+        Query_term_each_tag
+    },
+    {
+        "term_each_id",
+        Query_term_each_id
+    },
+    {
+        "term_each_pair_type",
+        Query_term_each_pair_type
+    },
+    {
+        "term_each_pair_id",
+        Query_term_each_pair_id
+    },
+    {
+        "term_each_pair_relation_wildcard",
+        Query_term_each_pair_relation_wildcard
+    },
+    {
+        "term_each_pair_object_wildcard",
+        Query_term_each_pair_object_wildcard
+    },
+    {
+        "term_get_id",
+        Query_term_get_id
+    },
+    {
+        "term_get_subj",
+        Query_term_get_subj
+    },
+    {
+        "term_get_pred",
+        Query_term_get_pred
+    },
+    {
+        "term_get_obj",
+        Query_term_get_obj
+    },
+    {
+        "set_this_var",
+        Query_set_this_var
+    },
     {
         "action",
         Query_action
@@ -3405,14 +3341,6 @@ bake_test_case Query_testcases[] = {
         "signature_optional",
         Query_signature_optional
     },
-    {
-        "subquery",
-        Query_subquery
-    },
-    {
-        "subquery_w_expr",
-        Query_subquery_w_expr
-    },
     {
         "query_single_pair",
         Query_query_single_pair
@@ -3433,10 +3361,6 @@ bake_test_case Query_testcases[] = {
         "changed",
         Query_changed
     },
-    {
-        "orphaned",
-        Query_orphaned
-    },
     {
         "default_ctor",
         Query_default_ctor
@@ -3724,6 +3648,14 @@ bake_test_case Query_testcases[] = {
     {
         "optional_pair_term",
         Query_optional_pair_term
+    },
+    {
+        "query_from_entity",
+        Query_query_from_entity
+    },
+    {
+        "query_from_entity_name",
+        Query_query_from_entity_name
     }
 };
 
@@ -3752,10 +3684,90 @@ bake_test_case QueryBuilder_testcases[] = {
         "builder_build_n_statements",
         QueryBuilder_builder_build_n_statements
     },
+    {
+        "builder_force_assign_operator",
+        QueryBuilder_builder_force_assign_operator
+    },
     {
         "1_type",
         QueryBuilder_1_type
     },
+    {
+        "2_types",
+        QueryBuilder_2_types
+    },
+    {
+        "id_term",
+        QueryBuilder_id_term
+    },
+    {
+        "type_term",
+        QueryBuilder_type_term
+    },
+    {
+        "id_pair_term",
+        QueryBuilder_id_pair_term
+    },
+    {
+        "id_pair_wildcard_term",
+        QueryBuilder_id_pair_wildcard_term
+    },
+    {
+        "type_pair_term",
+        QueryBuilder_type_pair_term
+    },
+    {
+        "pair_term_w_var",
+        QueryBuilder_pair_term_w_var
+    },
+    {
+        "2_pair_terms_w_var",
+        QueryBuilder_2_pair_terms_w_var
+    },
+    {
+        "set_var",
+        QueryBuilder_set_var
+    },
+    {
+        "set_2_vars",
+        QueryBuilder_set_2_vars
+    },
+    {
+        "set_var_by_name",
+        QueryBuilder_set_var_by_name
+    },
+    {
+        "set_2_vars_by_name",
+        QueryBuilder_set_2_vars_by_name
+    },
+    {
+        "expr_w_var",
+        QueryBuilder_expr_w_var
+    },
+    {
+        "set_var_on_query",
+        QueryBuilder_set_var_on_query
+    },
+    {
+        "set_var_by_name_on_query",
+        QueryBuilder_set_var_by_name_on_query
+    },
+    {
+        "set_table_var",
+        QueryBuilder_set_table_var
+    },
+    {
+        "set_range_var",
+        QueryBuilder_set_range_var
+    },
+    {
+        "set_table_var_chained",
+        QueryBuilder_set_table_var_chained
+    },
+    {
+        "set_range_var_chained",
+        QueryBuilder_set_range_var_chained
+    },
     {
         "add_1_type",
         QueryBuilder_add_1_type
@@ -3917,682 +3929,384 @@ bake_test_case QueryBuilder_testcases[] = {
         QueryBuilder_2_subsequent_args
     },
     {
-        "optional_tag_is_set",
-        QueryBuilder_optional_tag_is_set
+        "filter_as_move_arg",
+        QueryBuilder_filter_as_move_arg
     },
     {
-        "10_terms",
-        QueryBuilder_10_terms
+        "filter_as_return",
+        QueryBuilder_filter_as_return
     },
     {
-        "20_terms",
-        QueryBuilder_20_terms
+        "filter_copy",
+        QueryBuilder_filter_copy
     },
     {
-        "group_by_raw",
-        QueryBuilder_group_by_raw
+        "world_each_filter_1_component",
+        QueryBuilder_world_each_filter_1_component
     },
     {
-        "group_by_template",
-        QueryBuilder_group_by_template
+        "world_each_filter_2_components",
+        QueryBuilder_world_each_filter_2_components
     },
     {
-        "group_by_iter_one",
-        QueryBuilder_group_by_iter_one
+        "world_each_filter_1_component_no_entity",
+        QueryBuilder_world_each_filter_1_component_no_entity
     },
     {
-        "group_by_iter_one_template",
-        QueryBuilder_group_by_iter_one_template
+        "world_each_filter_2_components_no_entity",
+        QueryBuilder_world_each_filter_2_components_no_entity
     },
     {
-        "group_by_iter_one_all_groups",
-        QueryBuilder_group_by_iter_one_all_groups
+        "10_terms",
+        QueryBuilder_10_terms
     },
     {
-        "group_by_default_func_w_id",
-        QueryBuilder_group_by_default_func_w_id
+        "16_terms",
+        QueryBuilder_16_terms
     },
     {
-        "group_by_default_func_w_type",
-        QueryBuilder_group_by_default_func_w_type
+        "term_after_arg",
+        QueryBuilder_term_after_arg
     },
     {
-        "group_by_callbacks",
-        QueryBuilder_group_by_callbacks
+        "name_arg",
+        QueryBuilder_name_arg
     },
     {
-        "create_w_no_template_args",
-        QueryBuilder_create_w_no_template_args
+        "const_in_term",
+        QueryBuilder_const_in_term
     },
     {
-        "any_wildcard",
-        QueryBuilder_any_wildcard
+        "const_optional",
+        QueryBuilder_const_optional
     },
     {
-        "cascade",
-        QueryBuilder_cascade
+        "create_w_no_template_args",
+        QueryBuilder_create_w_no_template_args
     },
     {
-        "cascade_w_relationship",
-        QueryBuilder_cascade_w_relationship
+        "2_terms_w_expr",
+        QueryBuilder_2_terms_w_expr
     },
     {
-        "up_w_type",
-        QueryBuilder_up_w_type
+        "assert_on_uninitialized_term",
+        QueryBuilder_assert_on_uninitialized_term
     },
     {
-        "cascade_w_type",
-        QueryBuilder_cascade_w_type
+        "operator_shortcuts",
+        QueryBuilder_operator_shortcuts
     },
     {
-        "cascade_desc",
-        QueryBuilder_cascade_desc
+        "inout_shortcuts",
+        QueryBuilder_inout_shortcuts
     },
     {
-        "named_query",
-        QueryBuilder_named_query
+        "iter_column_w_const_as_array",
+        QueryBuilder_iter_column_w_const_as_array
     },
     {
-        "term_w_write",
-        QueryBuilder_term_w_write
+        "iter_column_w_const_as_ptr",
+        QueryBuilder_iter_column_w_const_as_ptr
     },
     {
-        "term_w_read",
-        QueryBuilder_term_w_read
+        "iter_column_w_const_deref",
+        QueryBuilder_iter_column_w_const_deref
     },
     {
-        "iter_w_stage",
-        QueryBuilder_iter_w_stage
-    }
-};
-
-bake_test_case FilterBuilder_testcases[] = {
-    {
-        "builder_assign_same_type",
-        FilterBuilder_builder_assign_same_type
+        "with_id",
+        QueryBuilder_with_id
     },
     {
-        "builder_assign_from_empty",
-        FilterBuilder_builder_assign_from_empty
+        "with_name",
+        QueryBuilder_with_name
     },
     {
-        "builder_assign_to_empty",
-        FilterBuilder_builder_assign_to_empty
+        "with_component",
+        QueryBuilder_with_component
     },
     {
-        "builder_build",
-        FilterBuilder_builder_build
+        "with_pair_id",
+        QueryBuilder_with_pair_id
     },
     {
-        "builder_build_to_auto",
-        FilterBuilder_builder_build_to_auto
+        "with_pair_name",
+        QueryBuilder_with_pair_name
     },
     {
-        "builder_build_n_statements",
-        FilterBuilder_builder_build_n_statements
+        "with_pair_components",
+        QueryBuilder_with_pair_components
     },
     {
-        "builder_force_assign_operator",
-        FilterBuilder_builder_force_assign_operator
+        "with_pair_component_id",
+        QueryBuilder_with_pair_component_id
     },
     {
-        "1_type",
-        FilterBuilder_1_type
+        "with_pair_component_name",
+        QueryBuilder_with_pair_component_name
     },
     {
-        "add_1_type",
-        FilterBuilder_add_1_type
+        "with_enum",
+        QueryBuilder_with_enum
     },
     {
-        "add_2_types",
-        FilterBuilder_add_2_types
+        "without_id",
+        QueryBuilder_without_id
     },
     {
-        "add_1_type_w_1_type",
-        FilterBuilder_add_1_type_w_1_type
+        "without_name",
+        QueryBuilder_without_name
     },
     {
-        "add_2_types_w_1_type",
-        FilterBuilder_add_2_types_w_1_type
+        "without_component",
+        QueryBuilder_without_component
     },
     {
-        "add_pair",
-        FilterBuilder_add_pair
+        "without_pair_id",
+        QueryBuilder_without_pair_id
     },
     {
-        "add_not",
-        FilterBuilder_add_not
+        "without_pair_name",
+        QueryBuilder_without_pair_name
     },
     {
-        "add_or",
-        FilterBuilder_add_or
+        "without_pair_components",
+        QueryBuilder_without_pair_components
     },
     {
-        "add_optional",
-        FilterBuilder_add_optional
+        "without_pair_component_id",
+        QueryBuilder_without_pair_component_id
     },
     {
-        "ptr_type",
-        FilterBuilder_ptr_type
+        "without_pair_component_name",
+        QueryBuilder_without_pair_component_name
     },
     {
-        "const_type",
-        FilterBuilder_const_type
+        "without_enum",
+        QueryBuilder_without_enum
     },
     {
-        "string_term",
-        FilterBuilder_string_term
+        "write_id",
+        QueryBuilder_write_id
     },
     {
-        "singleton_term",
-        FilterBuilder_singleton_term
+        "write_name",
+        QueryBuilder_write_name
     },
     {
-        "isa_superset_term",
-        FilterBuilder_isa_superset_term
+        "write_component",
+        QueryBuilder_write_component
     },
     {
-        "isa_self_superset_term",
-        FilterBuilder_isa_self_superset_term
+        "write_pair_id",
+        QueryBuilder_write_pair_id
     },
     {
-        "childof_superset_term",
-        FilterBuilder_childof_superset_term
+        "write_pair_name",
+        QueryBuilder_write_pair_name
     },
     {
-        "childof_self_superset_term",
-        FilterBuilder_childof_self_superset_term
-    },
-    {
-        "isa_superset_term_w_each",
-        FilterBuilder_isa_superset_term_w_each
-    },
-    {
-        "isa_self_superset_term_w_each",
-        FilterBuilder_isa_self_superset_term_w_each
-    },
-    {
-        "childof_superset_term_w_each",
-        FilterBuilder_childof_superset_term_w_each
-    },
-    {
-        "childof_self_superset_term_w_each",
-        FilterBuilder_childof_self_superset_term_w_each
-    },
-    {
-        "isa_superset_shortcut",
-        FilterBuilder_isa_superset_shortcut
-    },
-    {
-        "isa_superset_shortcut_w_self",
-        FilterBuilder_isa_superset_shortcut_w_self
-    },
-    {
-        "childof_superset_shortcut",
-        FilterBuilder_childof_superset_shortcut
-    },
-    {
-        "childof_superset_shortcut_w_self",
-        FilterBuilder_childof_superset_shortcut_w_self
-    },
-    {
-        "relation",
-        FilterBuilder_relation
-    },
-    {
-        "relation_w_object_wildcard",
-        FilterBuilder_relation_w_object_wildcard
-    },
-    {
-        "relation_w_predicate_wildcard",
-        FilterBuilder_relation_w_predicate_wildcard
-    },
-    {
-        "add_pair_w_rel_type",
-        FilterBuilder_add_pair_w_rel_type
-    },
-    {
-        "template_term",
-        FilterBuilder_template_term
-    },
-    {
-        "explicit_subject_w_id",
-        FilterBuilder_explicit_subject_w_id
-    },
-    {
-        "explicit_subject_w_type",
-        FilterBuilder_explicit_subject_w_type
-    },
-    {
-        "explicit_object_w_id",
-        FilterBuilder_explicit_object_w_id
-    },
-    {
-        "explicit_object_w_type",
-        FilterBuilder_explicit_object_w_type
-    },
-    {
-        "explicit_term",
-        FilterBuilder_explicit_term
-    },
-    {
-        "explicit_term_w_type",
-        FilterBuilder_explicit_term_w_type
-    },
-    {
-        "explicit_term_w_pair_type",
-        FilterBuilder_explicit_term_w_pair_type
-    },
-    {
-        "explicit_term_w_id",
-        FilterBuilder_explicit_term_w_id
-    },
-    {
-        "explicit_term_w_pair_id",
-        FilterBuilder_explicit_term_w_pair_id
-    },
-    {
-        "1_term_to_empty",
-        FilterBuilder_1_term_to_empty
-    },
-    {
-        "2_subsequent_args",
-        FilterBuilder_2_subsequent_args
-    },
-    {
-        "filter_as_arg",
-        FilterBuilder_filter_as_arg
-    },
-    {
-        "filter_as_move_arg",
-        FilterBuilder_filter_as_move_arg
-    },
-    {
-        "filter_as_return",
-        FilterBuilder_filter_as_return
-    },
-    {
-        "filter_copy",
-        FilterBuilder_filter_copy
-    },
-    {
-        "world_each_filter_1_component",
-        FilterBuilder_world_each_filter_1_component
-    },
-    {
-        "world_each_filter_2_components",
-        FilterBuilder_world_each_filter_2_components
-    },
-    {
-        "world_each_filter_1_component_no_entity",
-        FilterBuilder_world_each_filter_1_component_no_entity
-    },
-    {
-        "world_each_filter_2_components_no_entity",
-        FilterBuilder_world_each_filter_2_components_no_entity
-    },
-    {
-        "10_terms",
-        FilterBuilder_10_terms
-    },
-    {
-        "20_terms",
-        FilterBuilder_20_terms
-    },
-    {
-        "term_after_arg",
-        FilterBuilder_term_after_arg
-    },
-    {
-        "name_arg",
-        FilterBuilder_name_arg
-    },
-    {
-        "const_in_term",
-        FilterBuilder_const_in_term
-    },
-    {
-        "const_optional",
-        FilterBuilder_const_optional
-    },
-    {
-        "create_w_no_template_args",
-        FilterBuilder_create_w_no_template_args
-    },
-    {
-        "2_terms_w_expr",
-        FilterBuilder_2_terms_w_expr
-    },
-    {
-        "assert_on_uninitialized_term",
-        FilterBuilder_assert_on_uninitialized_term
-    },
-    {
-        "operator_shortcuts",
-        FilterBuilder_operator_shortcuts
-    },
-    {
-        "inout_shortcuts",
-        FilterBuilder_inout_shortcuts
-    },
-    {
-        "iter_column_w_const_as_array",
-        FilterBuilder_iter_column_w_const_as_array
-    },
-    {
-        "iter_column_w_const_as_ptr",
-        FilterBuilder_iter_column_w_const_as_ptr
-    },
-    {
-        "iter_column_w_const_deref",
-        FilterBuilder_iter_column_w_const_deref
-    },
-    {
-        "with_id",
-        FilterBuilder_with_id
-    },
-    {
-        "with_name",
-        FilterBuilder_with_name
-    },
-    {
-        "with_component",
-        FilterBuilder_with_component
-    },
-    {
-        "with_pair_id",
-        FilterBuilder_with_pair_id
-    },
-    {
-        "with_pair_name",
-        FilterBuilder_with_pair_name
-    },
-    {
-        "with_pair_components",
-        FilterBuilder_with_pair_components
-    },
-    {
-        "with_pair_component_id",
-        FilterBuilder_with_pair_component_id
-    },
-    {
-        "with_pair_component_name",
-        FilterBuilder_with_pair_component_name
-    },
-    {
-        "with_enum",
-        FilterBuilder_with_enum
-    },
-    {
-        "without_id",
-        FilterBuilder_without_id
-    },
-    {
-        "without_name",
-        FilterBuilder_without_name
-    },
-    {
-        "without_component",
-        FilterBuilder_without_component
-    },
-    {
-        "without_pair_id",
-        FilterBuilder_without_pair_id
-    },
-    {
-        "without_pair_name",
-        FilterBuilder_without_pair_name
-    },
-    {
-        "without_pair_components",
-        FilterBuilder_without_pair_components
-    },
-    {
-        "without_pair_component_id",
-        FilterBuilder_without_pair_component_id
-    },
-    {
-        "without_pair_component_name",
-        FilterBuilder_without_pair_component_name
-    },
-    {
-        "without_enum",
-        FilterBuilder_without_enum
-    },
-    {
-        "write_id",
-        FilterBuilder_write_id
-    },
-    {
-        "write_name",
-        FilterBuilder_write_name
-    },
-    {
-        "write_component",
-        FilterBuilder_write_component
-    },
-    {
-        "write_pair_id",
-        FilterBuilder_write_pair_id
-    },
-    {
-        "write_pair_name",
-        FilterBuilder_write_pair_name
-    },
-    {
-        "write_pair_components",
-        FilterBuilder_write_pair_components
+        "write_pair_components",
+        QueryBuilder_write_pair_components
     },
     {
         "write_pair_component_id",
-        FilterBuilder_write_pair_component_id
+        QueryBuilder_write_pair_component_id
     },
     {
         "write_pair_component_name",
-        FilterBuilder_write_pair_component_name
+        QueryBuilder_write_pair_component_name
     },
     {
         "write_enum",
-        FilterBuilder_write_enum
+        QueryBuilder_write_enum
     },
     {
         "read_id",
-        FilterBuilder_read_id
+        QueryBuilder_read_id
     },
     {
         "read_name",
-        FilterBuilder_read_name
+        QueryBuilder_read_name
     },
     {
         "read_component",
-        FilterBuilder_read_component
+        QueryBuilder_read_component
     },
     {
         "read_pair_id",
-        FilterBuilder_read_pair_id
+        QueryBuilder_read_pair_id
     },
     {
         "read_pair_name",
-        FilterBuilder_read_pair_name
+        QueryBuilder_read_pair_name
     },
     {
         "read_pair_components",
-        FilterBuilder_read_pair_components
+        QueryBuilder_read_pair_components
     },
     {
         "read_pair_component_id",
-        FilterBuilder_read_pair_component_id
+        QueryBuilder_read_pair_component_id
     },
     {
         "read_pair_component_name",
-        FilterBuilder_read_pair_component_name
+        QueryBuilder_read_pair_component_name
     },
     {
         "read_enum",
-        FilterBuilder_read_enum
+        QueryBuilder_read_enum
     },
     {
         "assign_after_init",
-        FilterBuilder_assign_after_init
+        QueryBuilder_assign_after_init
     },
     {
         "iter_w_stage",
-        FilterBuilder_iter_w_stage
+        QueryBuilder_iter_w_stage
     },
     {
         "with_t_inout",
-        FilterBuilder_with_t_inout
+        QueryBuilder_with_t_inout
     },
     {
         "with_T_inout",
-        FilterBuilder_with_T_inout
+        QueryBuilder_with_T_inout
     },
     {
         "with_R_T_inout",
-        FilterBuilder_with_R_T_inout
+        QueryBuilder_with_R_T_inout
     },
     {
         "with_R_t_inout",
-        FilterBuilder_with_R_t_inout
+        QueryBuilder_with_R_t_inout
     },
     {
         "with_r_t_inout",
-        FilterBuilder_with_r_t_inout
-    }
-};
-
-bake_test_case RuleBuilder_testcases[] = {
+        QueryBuilder_with_r_t_inout
+    },
     {
-        "1_type",
-        RuleBuilder_1_type
+        "optional_tag_is_set",
+        QueryBuilder_optional_tag_is_set
     },
     {
-        "2_types",
-        RuleBuilder_2_types
+        "group_by_raw",
+        QueryBuilder_group_by_raw
     },
     {
-        "id_term",
-        RuleBuilder_id_term
+        "group_by_template",
+        QueryBuilder_group_by_template
     },
     {
-        "type_term",
-        RuleBuilder_type_term
+        "group_by_iter_one",
+        QueryBuilder_group_by_iter_one
     },
     {
-        "id_pair_term",
-        RuleBuilder_id_pair_term
+        "group_by_iter_one_template",
+        QueryBuilder_group_by_iter_one_template
     },
     {
-        "id_pair_wildcard_term",
-        RuleBuilder_id_pair_wildcard_term
+        "group_by_iter_one_all_groups",
+        QueryBuilder_group_by_iter_one_all_groups
     },
     {
-        "type_pair_term",
-        RuleBuilder_type_pair_term
+        "group_by_default_func_w_id",
+        QueryBuilder_group_by_default_func_w_id
     },
     {
-        "pair_term_w_var",
-        RuleBuilder_pair_term_w_var
+        "group_by_default_func_w_type",
+        QueryBuilder_group_by_default_func_w_type
     },
     {
-        "2_pair_terms_w_var",
-        RuleBuilder_2_pair_terms_w_var
+        "group_by_callbacks",
+        QueryBuilder_group_by_callbacks
     },
     {
-        "set_var",
-        RuleBuilder_set_var
+        "set_group_on_query",
+        QueryBuilder_set_group_on_query
     },
     {
-        "set_2_vars",
-        RuleBuilder_set_2_vars
+        "set_group_type_on_query",
+        QueryBuilder_set_group_type_on_query
     },
     {
-        "set_var_by_name",
-        RuleBuilder_set_var_by_name
+        "create_w_no_template_args",
+        QueryBuilder_create_w_no_template_args
     },
     {
-        "set_2_vars_by_name",
-        RuleBuilder_set_2_vars_by_name
+        "any_wildcard",
+        QueryBuilder_any_wildcard
     },
     {
-        "expr_w_var",
-        RuleBuilder_expr_w_var
+        "cascade",
+        QueryBuilder_cascade
     },
     {
-        "get_first",
-        RuleBuilder_get_first
+        "cascade_w_relationship",
+        QueryBuilder_cascade_w_relationship
     },
     {
-        "get_count_direct",
-        RuleBuilder_get_count_direct
+        "up_w_type",
+        QueryBuilder_up_w_type
     },
     {
-        "get_is_true_direct",
-        RuleBuilder_get_is_true_direct
+        "cascade_w_type",
+        QueryBuilder_cascade_w_type
     },
     {
-        "get_first_direct",
-        RuleBuilder_get_first_direct
+        "cascade_desc",
+        QueryBuilder_cascade_desc
+    },
+    {
+        "named_query",
+        QueryBuilder_named_query
+    },
+    {
+        "term_w_write",
+        QueryBuilder_term_w_write
+    },
+    {
+        "term_w_read",
+        QueryBuilder_term_w_read
     },
     {
         "var_src_w_prefixed_name",
-        RuleBuilder_var_src_w_prefixed_name
+        QueryBuilder_var_src_w_prefixed_name
     },
     {
         "var_first_w_prefixed_name",
-        RuleBuilder_var_first_w_prefixed_name
+        QueryBuilder_var_first_w_prefixed_name
     },
     {
         "var_second_w_prefixed_name",
-        RuleBuilder_var_second_w_prefixed_name
+        QueryBuilder_var_second_w_prefixed_name
     },
     {
         "term_w_second_var_string",
-        RuleBuilder_term_w_second_var_string
+        QueryBuilder_term_w_second_var_string
     },
     {
         "term_type_w_second_var_string",
-        RuleBuilder_term_type_w_second_var_string
+        QueryBuilder_term_type_w_second_var_string
     },
     {
         "named_rule",
-        RuleBuilder_named_rule
+        QueryBuilder_named_rule
     },
     {
         "named_scoped_rule",
-        RuleBuilder_named_scoped_rule
+        QueryBuilder_named_scoped_rule
     },
     {
         "is_valid",
-        RuleBuilder_is_valid
+        QueryBuilder_is_valid
     },
     {
         "unresolved_by_name",
-        RuleBuilder_unresolved_by_name
+        QueryBuilder_unresolved_by_name
     },
     {
         "scope",
-        RuleBuilder_scope
-    },
-    {
-        "iter_w_stage",
-        RuleBuilder_iter_w_stage
-    },
-    {
-        "inspect_terms_w_expr",
-        RuleBuilder_inspect_terms_w_expr
-    },
-    {
-        "find",
-        RuleBuilder_find
-    },
-    {
-        "find_not_found",
-        RuleBuilder_find_not_found
-    },
-    {
-        "find_w_entity",
-        RuleBuilder_find_w_entity
+        QueryBuilder_scope
     }
 };
 
@@ -4666,8 +4380,8 @@ bake_test_case SystemBuilder_testcases[] = {
         SystemBuilder_10_terms
     },
     {
-        "20_terms",
-        SystemBuilder_20_terms
+        "16_terms",
+        SystemBuilder_16_terms
     },
     {
         "name_arg",
@@ -4709,8 +4423,8 @@ bake_test_case Observer_testcases[] = {
         Observer_10_terms
     },
     {
-        "20_terms",
-        Observer_20_terms
+        "16_terms",
+        Observer_16_terms
     },
     {
         "2_entities_iter",
@@ -4818,117 +4532,6 @@ bake_test_case Observer_testcases[] = {
     }
 };
 
-bake_test_case Filter_testcases[] = {
-    {
-        "term_each_component",
-        Filter_term_each_component
-    },
-    {
-        "term_each_tag",
-        Filter_term_each_tag
-    },
-    {
-        "term_each_id",
-        Filter_term_each_id
-    },
-    {
-        "term_each_pair_type",
-        Filter_term_each_pair_type
-    },
-    {
-        "term_each_pair_id",
-        Filter_term_each_pair_id
-    },
-    {
-        "term_each_pair_relation_wildcard",
-        Filter_term_each_pair_relation_wildcard
-    },
-    {
-        "term_each_pair_object_wildcard",
-        Filter_term_each_pair_object_wildcard
-    },
-    {
-        "default_ctor_no_assign",
-        Filter_default_ctor_no_assign
-    },
-    {
-        "term_get_id",
-        Filter_term_get_id
-    },
-    {
-        "term_get_subj",
-        Filter_term_get_subj
-    },
-    {
-        "term_get_pred",
-        Filter_term_get_pred
-    },
-    {
-        "term_get_obj",
-        Filter_term_get_obj
-    },
-    {
-        "get_first",
-        Filter_get_first
-    },
-    {
-        "get_count_direct",
-        Filter_get_count_direct
-    },
-    {
-        "get_is_true_direct",
-        Filter_get_is_true_direct
-    },
-    {
-        "get_first_direct",
-        Filter_get_first_direct
-    },
-    {
-        "each_w_no_this",
-        Filter_each_w_no_this
-    },
-    {
-        "each_w_iter_no_this",
-        Filter_each_w_iter_no_this
-    },
-    {
-        "invalid_each_w_no_this",
-        Filter_invalid_each_w_no_this
-    },
-    {
-        "named_filter",
-        Filter_named_filter
-    },
-    {
-        "named_scoped_filter",
-        Filter_named_scoped_filter
-    },
-    {
-        "set_this_var",
-        Filter_set_this_var
-    },
-    {
-        "inspect_terms_w_expr",
-        Filter_inspect_terms_w_expr
-    },
-    {
-        "find",
-        Filter_find
-    },
-    {
-        "find_not_found",
-        Filter_find_not_found
-    },
-    {
-        "find_w_entity",
-        Filter_find_w_entity
-    },
-    {
-        "optional_pair_term",
-        Filter_optional_pair_term
-    }
-};
-
 bake_test_case ComponentLifecycle_testcases[] = {
     {
         "ctor_on_add",
@@ -5473,13 +5076,6 @@ bake_test_case ImplicitComponents_testcases[] = {
     }
 };
 
-bake_test_case Snapshot_testcases[] = {
-    {
-        "simple_snapshot",
-        Snapshot_simple_snapshot
-    }
-};
-
 bake_test_case WorldFactory_testcases[] = {
     {
         "entity",
@@ -5521,10 +5117,6 @@ bake_test_case WorldFactory_testcases[] = {
         "query_w_expr",
         WorldFactory_query_w_expr
     },
-    {
-        "snapshot",
-        WorldFactory_snapshot
-    },
     {
         "module",
         WorldFactory_module
@@ -5979,6 +5571,10 @@ bake_test_case World_testcases[] = {
     {
         "get_mut_R_T",
         World_get_mut_R_T
+    },
+    {
+        "copy_world",
+        World_copy_world
     }
 };
 
@@ -6649,6 +6245,10 @@ bake_test_case Doc_testcases[] = {
     }
 };
 
+const char* QueryBuilder_cache_kind_param[] = {"default", "auto"};
+bake_test_param QueryBuilder_params[] = {
+    {"cache_kind", (char**)QueryBuilder_cache_kind_param, 2}
+};
 
 static bake_test_suite suites[] = {
     {
@@ -6662,7 +6262,7 @@ static bake_test_suite suites[] = {
         "Entity",
         NULL,
         NULL,
-        253,
+        257,
         Entity_testcases
     },
     {
@@ -6679,13 +6279,6 @@ static bake_test_suite suites[] = {
         39,
         Enum_testcases
     },
-    {
-        "Switch",
-        NULL,
-        NULL,
-        10,
-        Switch_testcases
-    },
     {
         "Paths",
         NULL,
@@ -6718,29 +6311,17 @@ static bake_test_suite suites[] = {
         "Query",
         NULL,
         NULL,
-        92,
+        103,
         Query_testcases
     },
     {
         "QueryBuilder",
+        QueryBuilder_setup,
         NULL,
-        NULL,
-        69,
-        QueryBuilder_testcases
-    },
-    {
-        "FilterBuilder",
-        NULL,
-        NULL,
-        113,
-        FilterBuilder_testcases
-    },
-    {
-        "RuleBuilder",
-        NULL,
-        NULL,
-        33,
-        RuleBuilder_testcases
+        162,
+        QueryBuilder_testcases,
+        1,
+        QueryBuilder_params
     },
     {
         "SystemBuilder",
@@ -6756,13 +6337,6 @@ static bake_test_suite suites[] = {
         32,
         Observer_testcases
     },
-    {
-        "Filter",
-        NULL,
-        NULL,
-        27,
-        Filter_testcases
-    },
     {
         "ComponentLifecycle",
         NULL,
@@ -6791,25 +6365,18 @@ static bake_test_suite suites[] = {
         27,
         ImplicitComponents_testcases
     },
-    {
-        "Snapshot",
-        NULL,
-        NULL,
-        1,
-        Snapshot_testcases
-    },
     {
         "WorldFactory",
         NULL,
         NULL,
-        12,
+        11,
         WorldFactory_testcases
     },
     {
         "World",
         NULL,
         NULL,
-        112,
+        113,
         World_testcases
     },
     {
@@ -6850,5 +6417,5 @@ static bake_test_suite suites[] = {
 };
 
 int main(int argc, char *argv[]) {
-    return bake_test_run("cpp_api", argc, argv, suites, 28);
+    return bake_test_run("cpp", argc, argv, suites, 23);
 }
diff --git a/test/cpp_api/src/util.cpp b/test/cpp/src/util.cpp
similarity index 90%
rename from test/cpp_api/src/util.cpp
rename to test/cpp/src/util.cpp
index 4c2f2a3ab..7a212ca90 100644
--- a/test/cpp_api/src/util.cpp
+++ b/test/cpp/src/util.cpp
@@ -1,4 +1,4 @@
-#include <cpp_api.h>
+#include <cpp.h>
 
 void install_test_abort(void) {
     ecs_os_set_api_defaults();
diff --git a/test/cpp_api/src/Filter.cpp b/test/cpp_api/src/Filter.cpp
deleted file mode 100644
index 4054b556e..000000000
--- a/test/cpp_api/src/Filter.cpp
+++ /dev/null
@@ -1,551 +0,0 @@
-#include <cpp_api.h>
-
-void Filter_term_each_component(void) {
-    flecs::world ecs;
-
-    auto e_1 = ecs.entity().set<Position>({1, 2});
-    auto e_2 = ecs.entity().set<Position>({3, 4});
-    auto e_3 = ecs.entity().set<Position>({5, 6});
-
-    e_3.add<Tag>();
-
-    int32_t count = 0;
-    ecs.each<Position>([&](flecs::entity e, Position& p) {
-        if (e == e_1) {
-            test_int(p.x, 1);
-            test_int(p.y, 2);
-            count ++;
-        }
-        if (e == e_2) {
-            test_int(p.x, 3);
-            test_int(p.y, 4);
-            count ++;
-        }
-        if (e == e_3) {
-            test_int(p.x, 5);
-            test_int(p.y, 6);
-            count ++;
-        }                
-    });
-
-    test_int(count, 3);
-}
-
-void Filter_term_each_tag(void) {
-    flecs::world ecs;
-
-    struct Foo { };
-
-    auto e_1 = ecs.entity().add<Foo>();
-    auto e_2 = ecs.entity().add<Foo>();
-    auto e_3 = ecs.entity().add<Foo>();
-
-    e_3.add<Tag>();
-
-    int32_t count = 0;
-    ecs.each<Foo>([&](flecs::entity e, Foo) {
-        if (e == e_1 || e == e_2 || e == e_3) {
-            count ++;
-        }            
-    });
-
-    test_int(count, 3);
-}
-
-void Filter_term_each_id(void) {
-    flecs::world ecs;
-
-    auto foo = ecs.entity();
-
-    auto e_1 = ecs.entity().add(foo);
-    auto e_2 = ecs.entity().add(foo);
-    auto e_3 = ecs.entity().add(foo);
-
-    e_3.add<Tag>();
-
-    int32_t count = 0;
-    ecs.each(foo, [&](flecs::entity e) {
-        if (e == e_1 || e == e_2 || e == e_3) {
-            count ++;
-        }            
-    });
-
-    test_int(count, 3);
-}
-
-void Filter_term_each_pair_type(void) {
-    flecs::world ecs;
-
-    struct Rel { };
-    struct Obj { };
-
-    auto e_1 = ecs.entity().add<Rel, Obj>();
-    auto e_2 = ecs.entity().add<Rel, Obj>();
-    auto e_3 = ecs.entity().add<Rel, Obj>();
-
-    e_3.add<Tag>();
-
-    int32_t count = 0;
-    ecs.each<flecs::pair<Rel, Obj>>([&](flecs::entity e, flecs::pair<Rel,Obj>) {
-        if (e == e_1 || e == e_2 || e == e_3) {
-            count ++;
-        }
-    });
-
-    test_int(count, 3);
-}
-
-void Filter_term_each_pair_id(void) {
-    flecs::world ecs;
-
-    auto rel = ecs.entity();
-    auto obj = ecs.entity();
-
-    auto e_1 = ecs.entity().add(rel, obj);
-    auto e_2 = ecs.entity().add(rel, obj);
-    auto e_3 = ecs.entity().add(rel, obj);
-
-    e_3.add<Tag>();
-
-    int32_t count = 0;
-    ecs.each(ecs.pair(rel, obj), [&](flecs::entity e) {
-        if (e == e_1 || e == e_2 || e == e_3) {
-            count ++;
-        }
-    });
-
-    test_int(count, 3);
-}
-
-void Filter_term_each_pair_relation_wildcard(void) {
-    flecs::world ecs;
-
-    auto rel_1 = ecs.entity();
-    auto rel_2 = ecs.entity();
-    auto obj = ecs.entity();
-
-    auto e_1 = ecs.entity().add(rel_1, obj);
-    auto e_2 = ecs.entity().add(rel_1, obj);
-    auto e_3 = ecs.entity().add(rel_2, obj);
-
-    e_3.add<Tag>();
-
-    int32_t count = 0;
-    ecs.each(ecs.pair(flecs::Wildcard, obj), [&](flecs::entity e) {
-        if (e == e_1 || e == e_2 || e == e_3) {
-            count ++;
-        }
-    });
-
-    test_int(count, 3);
-}
-
-void Filter_term_each_pair_object_wildcard(void) {
-    flecs::world ecs;
-
-    auto rel = ecs.entity();
-    auto obj_1 = ecs.entity();
-    auto obj_2 = ecs.entity();
-
-    auto e_1 = ecs.entity().add(rel, obj_1);
-    auto e_2 = ecs.entity().add(rel, obj_1);
-    auto e_3 = ecs.entity().add(rel, obj_2);
-
-    e_3.add<Tag>();
-
-    int32_t count = 0;
-    ecs.each(ecs.pair(rel, flecs::Wildcard), [&](flecs::entity e) {
-        if (e == e_1 || e == e_2 || e == e_3) {
-            count ++;
-        }
-    });
-
-    test_int(count, 3);
-}
-
-void Filter_default_ctor_no_assign(void) {
-    flecs::filter<> f;
-    
-    // Make sure code compiles & works
-    test_assert(true);
-}
-
-void Filter_term_get_id(void) {
-    flecs::world ecs;
-
-    auto Foo = ecs.entity();
-    auto Bar = ecs.entity();
-
-    auto q = ecs.query_builder()
-        .term<Position>()
-        .term<Velocity>()
-        .term(Foo, Bar)
-        .build();
-
-    test_int(q.field_count(), 3);
-    
-    flecs::term 
-    t = q.term(0);
-    test_assert(t.id() == ecs.id<Position>());
-    t = q.term(1);
-    test_assert(t.id() == ecs.id<Velocity>());
-    t = q.term(2);
-    test_assert(t.id() == ecs.pair(Foo, Bar));
-}
-
-void Filter_term_get_subj(void) {
-    flecs::world ecs;
-
-    auto Foo = ecs.entity();
-    auto Bar = ecs.entity();
-    auto Src = ecs.entity();
-
-    auto q = ecs.query_builder()
-        .term<Position>()
-        .term<Velocity>().src(Src)
-        .term(Foo, Bar)
-        .build();
-
-    test_int(q.field_count(), 3);
-    
-    flecs::term 
-    t = q.term(0);
-    test_assert(t.get_src() == flecs::This);
-    t = q.term(1);
-    test_assert(t.get_src() == Src);
-    t = q.term(2);
-    test_assert(t.get_src() == flecs::This);
-}
-
-void Filter_term_get_pred(void) {
-    flecs::world ecs;
-
-    auto Foo = ecs.entity();
-    auto Bar = ecs.entity();
-    auto Src = ecs.entity();
-
-    auto q = ecs.query_builder()
-        .term<Position>()
-        .term<Velocity>().src(Src)
-        .term(Foo, Bar)
-        .build();
-
-    test_int(q.field_count(), 3);
-    
-    flecs::term 
-    t = q.term(0);
-    test_assert(t.get_first() == ecs.id<Position>());
-    t = q.term(1);
-    test_assert(t.get_first() == ecs.id<Velocity>());
-    t = q.term(2);
-    test_assert(t.get_first() == Foo);
-}
-
-void Filter_term_get_obj(void) {
-    flecs::world ecs;
-
-    auto Foo = ecs.entity();
-    auto Bar = ecs.entity();
-    auto Src = ecs.entity();
-
-    auto q = ecs.query_builder()
-        .term<Position>()
-        .term<Velocity>().src(Src)
-        .term(Foo, Bar)
-        .build();
-
-    test_int(q.field_count(), 3);
-    
-    flecs::term 
-    t = q.term(0);
-    test_assert(t.get_second() == 0);
-    t = q.term(1);
-    test_assert(t.get_second() == 0);
-    t = q.term(2);
-    test_assert(t.get_second() == Bar);
-}
-
-void Filter_get_first(void) {
-    flecs::world ecs;
-
-    struct A {};
-
-    auto e1 = ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q = ecs.filter<A>();
-
-    auto first = q.iter().first();
-    test_assert(first != 0);
-    test_assert(first == e1);
-}
-
-void Filter_get_count_direct(void) {
-    flecs::world ecs;
-
-    struct A {};
-
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q = ecs.filter<A>();
-
-    test_int(3, q.count());
-}
-
-void Filter_get_is_true_direct(void) {
-    flecs::world ecs;
-
-    struct A {};
-    struct B {};
-
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q_1 = ecs.filter<A>();
-    auto q_2 = ecs.filter<B>();
-
-    test_bool(true, q_1.is_true());
-    test_bool(false, q_2.is_true());
-}
-
-void Filter_get_first_direct(void) {
-    flecs::world ecs;
-
-    struct A {};
-
-    auto e1 = ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q = ecs.filter<A>();
-
-    auto first = q.first();
-    test_assert(first != 0);
-    test_assert(first == e1);
-}
-
-void Filter_each_w_no_this(void) {
-    flecs::world ecs;
-
-    auto e = ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    auto f = ecs.filter_builder<Position, Velocity>()
-        .arg(1).src(e)
-        .arg(2).src(e)
-        .build();
-
-    int32_t count = 0;
-
-    f.each([&](Position& p, Velocity& v) {
-        count ++;
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-        test_int(v.x, 1);
-        test_int(v.y, 2);
-    });
-
-    test_int(count, 1);
-}
-
-void Filter_each_w_iter_no_this(void) {
-    flecs::world ecs;
-
-    auto e = ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    auto f = ecs.filter_builder<Position, Velocity>()
-        .arg(1).src(e)
-        .arg(2).src(e)
-        .build();
-
-    int32_t count = 0;
-
-    f.each([&](flecs::iter& it, size_t index, Position& p, Velocity& v) {
-        count ++;
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-        test_int(v.x, 1);
-        test_int(v.y, 2);
-        test_int(index, 0);
-        test_int(it.count(), 0);
-    });
-
-    test_int(count, 1);
-}
-
-void Filter_invalid_each_w_no_this(void) {
-    install_test_abort();
-
-    flecs::world ecs;
-
-    auto e = ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    auto f = ecs.filter_builder<Position, Velocity>()
-        .arg(1).src(e)
-        .arg(2).src(e)
-        .build();
-
-    test_expect_abort();
-
-    f.each([&](flecs::entity e, Position& p, Velocity& v) { });
-}
-
-void Filter_named_filter(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>();
-
-    auto q = ecs.filter<Position>("my_query");
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position&) {
-        test_assert(e == e1 || e == e2);
-        count ++;
-    });
-    test_int(count, 2);
-
-    flecs::entity qe = q.entity();
-    test_assert(qe != 0);
-    test_str(qe.name(), "my_query");
-}
-
-void Filter_named_scoped_filter(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>();
-
-    auto q = ecs.filter<Position>("my::query");
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position&) {
-        test_assert(e == e1 || e == e2);
-        count ++;
-    });
-    test_int(count, 2);
-
-    flecs::entity qe = q.entity();
-    test_assert(qe != 0);
-    test_str(qe.name(), "query");
-    test_str(qe.path(), "::my::query");
-}
-
-void Filter_set_this_var(void) {
-    flecs::world ecs;
-
-    /* auto e_1 = */ ecs.entity().set<Position>({1, 2});
-    auto e_2 = ecs.entity().set<Position>({3, 4});
-    /* auto e_3 = */ ecs.entity().set<Position>({5, 6});
-
-    auto q = ecs.filter<Position>("my::query");
-
-    int32_t count = 0;
-    q.iter().set_var(0, e_2).each([&](flecs::entity e, Position&) {
-        test_assert(e == e_2);
-        count ++;
-    });
-    test_int(count, 1);
-}
-
-void Filter_inspect_terms_w_expr(void) {
-    flecs::world ecs;
-
-    flecs::filter<> f = ecs.filter_builder()
-        .expr("(ChildOf,0)")
-        .build();
-
-    int32_t count = 0;
-    f.each_term([&](flecs::term &term) {
-        test_assert(term.id().is_pair());
-        count ++;
-    });
-
-    test_int(count, 1);
-}
-
-void Filter_find(void) {
-    flecs::world ecs;
-
-    /* auto e1 = */ ecs.entity().set<Position>({10, 20});
-    auto e2 = ecs.entity().set<Position>({20, 30});
-
-    auto q = ecs.filter<Position>();
-
-    auto r = q.find([](Position& p) {
-        return p.x == 20;
-    });
-
-    test_assert(r == e2);
-}
-
-void Filter_find_not_found(void) {
-    flecs::world ecs;
-
-    /* auto e1 = */ ecs.entity().set<Position>({10, 20});
-    /* auto e2 = */ ecs.entity().set<Position>({20, 30});
-
-    auto q = ecs.filter<Position>();
-
-    auto r = q.find([](Position& p) {
-        return p.x == 30;
-    });
-
-    test_assert(!r);
-}
-
-void Filter_find_w_entity(void) {
-    flecs::world ecs;
-
-    /* auto e1 = */ ecs.entity().set<Position>({10, 20}).set<Velocity>({20, 30});
-    auto e2 = ecs.entity().set<Position>({20, 30}).set<Velocity>({20, 30});
-
-    auto q = ecs.filter<Position>();
-
-    auto r = q.find([](flecs::entity e, Position& p) {
-        return p.x == e.get<Velocity>()->x &&
-               p.y == e.get<Velocity>()->y;
-    });
-
-    test_assert(r == e2);
-}
-
-void Filter_optional_pair_term(void) {
-    flecs::world ecs;
-
-    ecs.entity()
-        .add<TagA>()
-        .emplace<Position, Tag>(1.0f, 2.0f);
-    ecs.entity()
-        .add<TagA>();
-
-    int32_t with_pair = 0, without_pair = 0;
-
-    auto f = ecs.filter_builder<flecs::pair<Position, Tag>*>()
-        .with<TagA>()
-        .build();
-        
-    f.each([&](flecs::entity e, Position* p) {
-        if (p) {
-            with_pair++;
-            test_flt(1.0f, p->x);
-            test_flt(2.0f, p->y);
-        } else {
-            without_pair++;
-        }
-    });
-
-    ecs.progress(1.0);
-
-    test_int(1, with_pair);
-    test_int(1, without_pair);
-}
diff --git a/test/cpp_api/src/FilterBuilder.cpp b/test/cpp_api/src/FilterBuilder.cpp
deleted file mode 100644
index 0eb09fb12..000000000
--- a/test/cpp_api/src/FilterBuilder.cpp
+++ /dev/null
@@ -1,2581 +0,0 @@
-#include <cpp_api.h>
-
-struct Other {
-    int32_t value;
-};
-
-enum Color {
-    Red, Green, Blue
-};
-
-void FilterBuilder_builder_assign_same_type(void) {
-    flecs::world ecs;
-
-    flecs::filter<Position, Velocity> q = 
-        ecs.filter_builder<Position, Velocity>().build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p, Velocity& v) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_builder_assign_to_empty(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = ecs.filter_builder<Position, Velocity>().build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_builder_assign_from_empty(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = ecs.filter_builder<>()
-        .term<Position>()
-        .term<Velocity>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-template<typename ... Components>
-struct FilterWrapper
-{
-    FilterWrapper(flecs::filter<Components...> f) : f_(f) {}
-    flecs::filter<Components...> f_;
-};
-
-void FilterBuilder_builder_force_assign_operator(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity().set<Position>({10, 20});
-
-    auto f = ecs.entity().emplace<FilterWrapper<>>(
-        ecs.filter_builder().term<Position>().build()
-    );
-
-    int32_t count = 0;
-    f.get<FilterWrapper<>>()->f_.each([&](flecs::entity e) {
-        test_assert(e == e1);
-        count ++;
-    });
-}
-
-void FilterBuilder_builder_build(void) {
-    flecs::world ecs;
-
-    flecs::filter<Position, Velocity> q = 
-        ecs.filter_builder<Position, Velocity>().build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p, Velocity& v) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_builder_build_to_auto(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Position, Velocity>().build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p, Velocity& v) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_builder_build_n_statements(void) {
-    flecs::world ecs;
-
-    auto qb = ecs.filter_builder<>();
-    qb.term<Position>();
-    qb.term<Velocity>();
-    auto q = qb.build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_1_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Position>().build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_add_1_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<>()
-        .term<Position>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_add_2_types(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<>()
-        .term<Position>()
-        .term<Velocity>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_add_1_type_w_1_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Position>()
-        .term<Velocity>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_add_2_types_w_1_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Position>()
-        .term<Velocity>()
-        .term<Mass>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>().add<Mass>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_add_pair(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.filter_builder<>()
-        .term(Likes, Bob)
-        .build();
-
-    auto e1 = ecs.entity().add(Likes, Bob);
-    ecs.entity().add(Likes, Alice);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_add_not(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Position>()
-        .term<Velocity>().oper(flecs::Not)
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Position>().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_add_or(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<>()
-        .term<Position>().oper(flecs::Or)
-        .term<Velocity>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Velocity>();
-    ecs.entity().add<Mass>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1 || e == e2);
-    });
-    
-    test_int(count, 2);
-}
-
-void FilterBuilder_add_optional(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<>()
-        .term<Position>()
-        .term<Velocity>().oper(flecs::Optional)
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>().add<Mass>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1 || e == e2);
-    });
-    
-    test_int(count, 2);
-}
-
-void FilterBuilder_ptr_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Position, Velocity*>().build();
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>().add<Mass>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p, Velocity* v) {
-        count ++;
-        test_assert(e == e1 || e == e2);
-    });
-    
-    test_int(count, 2);
-}
-
-void FilterBuilder_const_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<const Position>().build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, const Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_string_term(void) {
-    flecs::world ecs;
-
-    ecs.component<Position>();
-
-    auto q = ecs.filter_builder<>()
-        .expr("Position")
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_singleton_term(void) {
-    flecs::world ecs;
-
-    ecs.set<Other>({10});
-
-    auto q = ecs.filter_builder<Self>()
-        .term<Other>().singleton()
-        .build();
-
-    auto 
-    e = ecs.entity(); e.set<Self>({e});
-    e = ecs.entity(); e.set<Self>({e});
-    e = ecs.entity(); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-        test_assert(!it.is_self(2));
-        test_int(o->value, 10);
-        
-        const Other& o_ref = *o;
-        test_int(o_ref.value, 10);
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 3);
-}
-
-void FilterBuilder_isa_superset_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self>()
-        .term<Other>().src().up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-        test_assert(!it.is_self(2));
-        test_int(o->value, 10);
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 3);
-}
-
-void FilterBuilder_isa_self_superset_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self>()
-        .term<Other>().src().self().up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
-
-    int32_t count = 0;
-    int32_t owned_count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-
-        if (!it.is_self(2)) {
-            test_int(o->value, 10);
-        } else {
-            for (auto i : it) {
-                test_int(o[i].value, 20);
-                owned_count ++;
-            }
-        }
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 5);
-    test_int(owned_count, 2);
-}
-
-void FilterBuilder_childof_superset_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self>()
-        .term<Other>().src().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-        test_assert(!it.is_self(2));
-        test_int(o->value, 10);
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 3);
-}
-
-void FilterBuilder_childof_self_superset_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self>()
-        .term<Other>().src().self().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
-
-    int32_t count = 0;
-    int32_t owned_count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-
-        if (!it.is_self(2)) {
-            test_int(o->value, 10);
-        } else {
-            for (auto i : it) {
-                test_int(o[i].value, 20);
-                owned_count ++;
-            }
-        }
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 5);
-    test_int(owned_count, 2);
-}
-
-void FilterBuilder_isa_superset_term_w_each(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self, Other>()
-        .arg(2).src().up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 3);
-}
-
-void FilterBuilder_isa_self_superset_term_w_each(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self, Other>()
-        .arg(2).src().self().up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 5);
-}
-
-void FilterBuilder_childof_superset_term_w_each(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self, Other>()
-        .arg(2).src().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 3);
-}
-
-void FilterBuilder_childof_self_superset_term_w_each(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self, Other>()
-        .arg(2).src().self().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 5);
-}
-
-void FilterBuilder_isa_superset_shortcut(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self, Other>()
-        .arg(2).up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 3);
-}
-
-void FilterBuilder_isa_superset_shortcut_w_self(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self, Other>()
-        .arg(2).self().up(flecs::IsA)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 5);
-}
-
-void FilterBuilder_childof_superset_shortcut(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self, Other>()
-        .arg(2).up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 3);
-}
-
-void FilterBuilder_childof_superset_shortcut_w_self(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Self, Other>()
-        .arg(2).self().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 5);
-}
-
-void FilterBuilder_relation(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.filter_builder<Self>()
-        .term(Likes, Bob)
-        .build();
-
-    auto 
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
-
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({0});
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({0});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-    
-    test_int(count, 2);
-}
-
-void FilterBuilder_relation_w_object_wildcard(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.filter_builder<Self>()
-        .term(Likes, flecs::Wildcard)
-        .build();
-
-    auto 
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
-
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({e});
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({e});
-
-    e = ecs.entity(); e.set<Self>({0});
-    e = ecs.entity(); e.set<Self>({0});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-    
-    test_int(count, 4);
-}
-
-void FilterBuilder_relation_w_predicate_wildcard(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Dislikes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.filter_builder<Self>()
-        .term(flecs::Wildcard, Alice)
-        .build();
-
-    auto 
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({e});
-    e = ecs.entity().add(Dislikes, Alice); e.set<Self>({e});
-
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({0});
-    e = ecs.entity().add(Dislikes, Bob); e.set<Self>({0});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-    
-    test_int(count, 2);
-}
-
-void FilterBuilder_add_pair_w_rel_type(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    
-    auto Dislikes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.filter_builder<Self>()
-        .term<Likes>(flecs::Wildcard)
-        .build();
-
-    auto 
-    e = ecs.entity().add<Likes>(Alice); e.set<Self>({e});
-    e = ecs.entity().add(Dislikes, Alice); e.set<Self>({0});
-
-    e = ecs.entity().add<Likes>(Bob); e.set<Self>({e});
-    e = ecs.entity().add(Dislikes, Bob); e.set<Self>({0});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-    
-    test_int(count, 2);
-}
-
-void FilterBuilder_template_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Position>()
-        .term<Template<int>>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Template<int>>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_explicit_subject_w_id(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<Position>()
-        .term<Position>().id(flecs::This)
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_explicit_subject_w_type(void) {
-    flecs::world ecs;
-
-    ecs.set<Position>({10, 20});
-
-    auto q = ecs.filter_builder<Position>()
-        .term<Position>().src<Position>()
-        .build();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-        count ++;
-        test_assert(e == ecs.singleton<Position>());
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_explicit_object_w_id(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity("Likes");
-    auto Alice = ecs.entity("Alice");
-    auto Bob = ecs.entity("Bob");
-
-    auto q = ecs.filter_builder<>()
-        .term(Likes).second(Alice)
-        .build();
-
-    auto e1 = ecs.entity().add(Likes, Alice);
-    ecs.entity().add(Likes, Bob);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_explicit_object_w_type(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    struct Alice { };
-    auto Bob = ecs.entity();
-
-    auto q = ecs.filter_builder<>()
-        .term(Likes).second<Alice>()
-        .build();
-
-    auto e1 = ecs.entity().add(Likes, ecs.id<Alice>());
-    ecs.entity().add(Likes, Bob);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_explicit_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<>()
-        .term(ecs.term<Position>())
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_explicit_term_w_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder<>()
-        .term(ecs.term<Position>())
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_explicit_term_w_pair_type(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Alice { };
-    struct Bob { };
-
-    auto q = ecs.filter_builder<>()
-        .term(ecs.term<Likes, Alice>())
-        .build();
-
-    auto e1 = ecs.entity().add<Likes, Alice>();
-    ecs.entity().add<Likes, Bob>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_explicit_term_w_id(void) {
-    flecs::world ecs;
-
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    auto q = ecs.filter_builder<>()
-        .term(ecs.term(Apples))
-        .build();
-
-    auto e1 = ecs.entity().add(Apples);
-    ecs.entity().add(Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_explicit_term_w_pair_id(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    auto q = ecs.filter_builder<>()
-        .term(ecs.term(Likes, Apples))
-        .build();
-
-    auto e1 = ecs.entity().add(Likes, Apples);
-    ecs.entity().add(Likes, Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_1_term_to_empty(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Apples = ecs.entity();
-
-    auto qb = ecs.filter_builder<>()
-        .term<Position>();
-
-    qb.term(Likes, Apples);
-
-    auto q = qb.build();
-
-    test_int(q.field_count(), 2);
-    test_int(q.term(0).id(), ecs.id<Position>());
-    test_int(q.term(1).id(), ecs.pair(Likes, Apples));
-}
-
-void FilterBuilder_2_subsequent_args(void) {
-    flecs::world ecs;
-
-    struct Rel { int foo; };
-
-    int32_t count = 0;
-
-    auto s = ecs.system<Rel, const Velocity>()
-        .arg(1).second(flecs::Wildcard)
-        .arg(2).singleton()
-        .iter([&](flecs::iter it){
-            count += it.count();
-        });
-    
-    ecs.entity().add<Rel, Tag>();
-    ecs.set<Velocity>({});
-
-    s.run();
-
-    test_int(count, 1);
-}
-
-static
-int filter_arg(flecs::filter<Self> f) {
-    int32_t count = 0;
-
-    f.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-
-    return count;
-}
-
-void FilterBuilder_filter_as_arg(void) {
-    flecs::world ecs;
-
-    auto f = ecs.filter<Self>();
-
-    auto e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    test_int(filter_arg(f), 3);
-}
-
-static
-int filter_move_arg(flecs::filter<Self>&& f) {
-    int32_t count = 0;
-
-    f.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-
-    return count;
-}
-
-void FilterBuilder_filter_as_move_arg(void) {
-    flecs::world ecs;
-
-    auto f = ecs.filter<Self>();
-
-    auto e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    test_int(filter_move_arg(ecs.filter<Self>()), 3);
-}
-
-static
-flecs::filter<Self> filter_return(flecs::world& ecs) {
-    return ecs.filter<Self>();
-}
-
-void FilterBuilder_filter_as_return(void) {
-    flecs::world ecs;
-
-    auto e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    auto f = filter_return(ecs);
-
-    int32_t count = 0;
-
-    f.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-
-    test_int(count, 3);
-}
-
-void FilterBuilder_filter_copy(void) {
-    flecs::world ecs;
-
-    auto e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    auto f = ecs.filter<Self>();
-
-    auto f_2 = f;
-
-    int32_t count = 0;
-
-    f_2.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-
-    test_int(count, 3);
-}
-
-void FilterBuilder_world_each_filter_1_component(void) {
-    flecs::world ecs;
-
-    auto e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    e = ecs.entity();
-    e.set<Self>({e});
-
-    int32_t count = 0;
-
-    ecs.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-
-    test_int(count, 3);
-}
-
-void FilterBuilder_world_each_filter_2_components(void) {
-    flecs::world ecs;
-
-    auto e = ecs.entity();
-    e.set<Self>({e})
-     .set<Position>({10, 20});
-
-    e = ecs.entity();
-    e.set<Self>({e})
-        .set<Position>({10, 20});
-
-    e = ecs.entity();
-    e.set<Self>({e})
-     .set<Position>({10, 20});
-
-    int32_t count = 0;
-
-    ecs.each([&](flecs::entity e, Self& s, Position& p) {
-        test_assert(e == s.value);
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-        count ++;
-    });
-
-    test_int(count, 3);
-}
-
-void FilterBuilder_world_each_filter_1_component_no_entity(void) {
-    flecs::world ecs;
-
-    ecs.entity()
-        .set<Position>({10, 20});
-
-    ecs.entity()
-        .set<Position>({10, 20});
-
-    ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    int32_t count = 0;
-
-    ecs.each([&](Position& p) {
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-        count ++;
-    });
-
-    test_int(count, 3);
-}
-
-void FilterBuilder_world_each_filter_2_components_no_entity(void) {
-    flecs::world ecs;
-
-    ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    ecs.entity()
-        .set<Position>({3, 5});
-
-    ecs.entity()
-        .set<Velocity>({20, 40});
-
-    int32_t count = 0;
-
-    ecs.each([&](Position& p, Velocity& v) {
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-        test_int(v.x, 1);
-        test_int(v.y, 2);        
-        count ++;
-    });
-
-    test_int(count, 3);
-}
-
-void FilterBuilder_10_terms(void) {
-    flecs::world ecs;
-
-    auto f = ecs.filter_builder<>()
-        .term<TagA>()
-        .term<TagB>()
-        .term<TagC>()
-        .term<TagD>()
-        .term<TagE>()
-        .term<TagF>()
-        .term<TagG>()
-        .term<TagH>()
-        .term<TagI>()
-        .term<TagJ>()
-        .build();
-
-    test_int(f.field_count(), 10);
-
-    auto e = ecs.entity()
-        .add<TagA>()
-        .add<TagB>()
-        .add<TagC>()
-        .add<TagD>()
-        .add<TagE>()
-        .add<TagF>()
-        .add<TagG>()
-        .add<TagH>()
-        .add<TagI>()
-        .add<TagJ>();
-
-    int count = 0;
-    f.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-        test_assert(it.entity(0) == e);
-        test_int(it.field_count(), 10);
-        count ++;
-    });
-
-    test_int(count, 1);
-}
-
-void FilterBuilder_20_terms(void) {
-    flecs::world ecs;
-
-    auto f = ecs.filter_builder<>()
-        .term<TagA>()
-        .term<TagB>()
-        .term<TagC>()
-        .term<TagD>()
-        .term<TagE>()
-        .term<TagF>()
-        .term<TagG>()
-        .term<TagH>()
-        .term<TagI>()
-        .term<TagJ>()
-        .term<TagK>()
-        .term<TagL>()
-        .term<TagM>()
-        .term<TagN>()
-        .term<TagO>()
-        .term<TagP>()
-        .term<TagQ>()
-        .term<TagR>()
-        .term<TagS>()
-        .term<TagT>()
-        .build();
-
-    test_int(f.field_count(), 20);
-
-    auto e = ecs.entity()
-        .add<TagA>()
-        .add<TagB>()
-        .add<TagC>()
-        .add<TagD>()
-        .add<TagE>()
-        .add<TagF>()
-        .add<TagG>()
-        .add<TagH>()
-        .add<TagI>()
-        .add<TagJ>()
-        .add<TagK>()
-        .add<TagL>()
-        .add<TagM>()
-        .add<TagN>()
-        .add<TagO>()
-        .add<TagP>()
-        .add<TagQ>()
-        .add<TagR>()
-        .add<TagS>()
-        .add<TagT>();
-
-    int count = 0;
-    f.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-        test_assert(it.entity(0) == e);
-        test_int(it.field_count(), 20);
-        count ++;
-    });
-
-    test_int(count, 1);
-}
-
-void FilterBuilder_term_after_arg(void) {
-    flecs::world ecs;
-
-    auto e_1 = ecs.entity()
-        .add<TagA>()
-        .add<TagB>()
-        .add<TagC>();
-
-    ecs.entity()
-        .add<TagA>()
-        .add<TagB>();
-
-    auto f = ecs.filter_builder<TagA, TagB>()
-        .arg(1).src(flecs::This) // dummy
-        .term<TagC>()
-        .build();
-
-    test_int(f.field_count(), 3);
-
-    int count = 0;
-    f.each([&](flecs::entity e, TagA, TagB) {
-        test_assert(e == e_1);
-        count ++;
-    });
-
-    test_int(count, 1);
-}
-
-void FilterBuilder_name_arg(void) {
-    flecs::world ecs;
-
-    auto e = ecs.entity("Foo").set<Position>({10, 20});
-
-    auto f = ecs.filter_builder<Position>()
-        .arg(1).src().name("Foo")
-        .build();
-
-    int32_t count = 0;
-    f.iter([&](flecs::iter& it, Position* p) {
-        count ++;
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-        test_assert(it.src(1) == e);
-    });
-
-    test_int(count, 1);
-}
-
-void FilterBuilder_const_in_term(void) {
-    flecs::world ecs;
-
-    ecs.entity().set<Position>({10, 20});
-
-    auto f = ecs.filter_builder<>()
-        .term<const Position>()
-        .build();
-
-    int32_t count = 0;
-    f.iter([&](flecs::iter& it) {
-        auto p = it.field<const Position>(1);
-        test_assert(it.is_readonly(1));
-        for (auto i : it) {
-            count ++;
-            test_int(p[i].x, 10);
-            test_int(p[i].y, 20);
-        }
-    });
-
-    test_int(count, 1);
-}
-
-void FilterBuilder_const_optional(void) {
-    flecs::world ecs;
-	
-	ecs.entity().set<Position>({10, 20}).add<TagA>();
-    ecs.entity().add<TagA>();
-
-    auto f = ecs.filter_builder<TagA, const Position*>().build();
-	
-    int32_t count = 0, set_count = 0;
-    f.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-        if (it.is_set(2)) {
-            auto p = it.field<const Position>(2);
-            test_assert(it.is_readonly(2));
-            test_int(p->x, 10);
-            test_int(p->y, 20);
-            set_count ++;
-        }
-        count++;
-	});
-	
-    test_int(count, 2);
-    test_int(set_count, 1);
-}
-
-void FilterBuilder_create_w_no_template_args(void) {
-    flecs::world ecs;
-
-    auto q = ecs.filter_builder().term<Position>().build();
-
-    auto e1 = ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_2_terms_w_expr(void) {
-    flecs::world ecs;
-
-    auto a = ecs.entity("A");
-    auto b = ecs.entity("B");
-
-    auto e1 = ecs.entity().add(a).add(b);
-
-    auto f = ecs.filter_builder()
-        .expr("A, B")
-        .build();
-    
-    test_int(f.field_count(), 2);
-
-    int32_t count = 0;
-    f.each([&](flecs::iter& it, size_t index) {
-        if (it.entity(index) == e1) {
-            test_assert(it.id(1) == a);
-            test_assert(it.id(2) == b);
-            count ++;
-        }
-    });
-
-    test_int(count, 1);
-}
-
-void FilterBuilder_assert_on_uninitialized_term(void) {
-    install_test_abort();
-
-    flecs::world ecs;
-
-    ecs.entity("A");
-    ecs.entity("B");
-
-    test_expect_abort();
-
-    auto f = ecs.filter_builder()
-        .term()
-        .term()
-        .build();
-}
-
-void FilterBuilder_operator_shortcuts(void) {
-    flecs::world ecs;
-
-    flecs::entity a = ecs.entity();
-    flecs::entity b = ecs.entity();
-    flecs::entity c = ecs.entity();
-    flecs::entity d = ecs.entity();
-    flecs::entity e = ecs.entity();
-    flecs::entity f = ecs.entity();
-    flecs::entity g = ecs.entity();
-    flecs::entity h = ecs.entity();
-
-    auto filter = ecs.filter_builder()
-        .term(a).and_()
-        .term(b).or_()
-        .term(c)
-        .term(d).not_()
-        .term(e).optional()
-        .term(f).and_from()
-        .term(g).or_from()
-        .term(h).not_from()
-        .build();
-
-    auto t = filter.term(0);
-    test_int(t.id(), a);
-    test_int(t.oper(), flecs::And);
-
-    t = filter.term(1);
-    test_int(t.id(), b);
-    test_int(t.oper(), flecs::Or);
-
-    t = filter.term(2);
-    test_int(t.id(), c);
-    test_int(t.oper(), flecs::And);
-
-    t = filter.term(3);
-    test_int(t.id(), d);
-    test_int(t.oper(), flecs::Not);
-
-    t = filter.term(4);
-    test_int(t.id(), e);
-    test_int(t.oper(), flecs::Optional);
-
-    t = filter.term(5);
-    test_int(t.id(), f);
-    test_int(t.oper(), flecs::AndFrom);
-
-    t = filter.term(6);
-    test_int(t.id(), g);
-    test_int(t.oper(), flecs::OrFrom);
-
-    t = filter.term(7);
-    test_int(t.id(), h);
-    test_int(t.oper(), flecs::NotFrom);
-}
-
-void FilterBuilder_inout_shortcuts(void) {
-    flecs::world ecs;
-
-    flecs::entity a = ecs.entity();
-    flecs::entity b = ecs.entity();
-    flecs::entity c = ecs.entity();
-    flecs::entity d = ecs.entity();
-
-    auto filter = ecs.filter_builder()
-        .term(a).in()
-        .term(b).out()
-        .term(c).inout()
-        .term(d).inout_none()
-        .build();
-
-    auto t = filter.term(0);
-    test_int(t.id(), a);
-    test_int(t.inout(), flecs::In);
-
-    t = filter.term(1);
-    test_int(t.id(), b);
-    test_int(t.inout(), flecs::Out);
-
-    t = filter.term(2);
-    test_int(t.id(), c);
-    test_int(t.inout(), flecs::InOut);
-
-    t = filter.term(3);
-    test_int(t.id(), d);
-    test_int(t.inout(), flecs::InOutNone);
-}
-
-void FilterBuilder_iter_column_w_const_as_array(void) {
-    flecs::world world;
-
-    auto f = world.filter<Position>();
-
-    auto e1 = world.entity().set<Position>({10, 20});
-    auto e2 = world.entity().set<Position>({20, 30});
-
-    int32_t count = 0;
-    f.iter([&](flecs::iter& it) {
-        const auto p = it.field<Position>(1);
-        for (auto i : it) {
-            p[i].x += 1;
-            p[i].y += 2;
-
-            count ++;
-        }
-    });
-
-    test_int(count, 2);
-
-    const Position *p = e1.get<Position>();
-    test_int(p->x, 11);
-    test_int(p->y, 22);
-
-    p = e2.get<Position>();
-    test_int(p->x, 21);
-    test_int(p->y, 32);
-}
-
-void FilterBuilder_iter_column_w_const_as_ptr(void) {
-    flecs::world world;
-
-    auto f = world.filter<Position>();
-    
-    auto base = world.prefab().set<Position>({10, 20});
-    world.entity().is_a(base);
-    world.entity().is_a(base);
-
-    int32_t count = 0;
-    f.iter([&](flecs::iter& it) {
-        const auto p = it.field<Position>(1);
-        for (size_t i = 0; i < it.count(); i ++) {
-            test_int(p->x, 10);
-            test_int(p->y, 20);
-            count ++;
-        }
-    });
-
-    test_int(count, 2);
-}
-
-void FilterBuilder_iter_column_w_const_deref(void) {
-    flecs::world world;
-
-    auto f = world.filter<Position>();
-    
-    auto base = world.prefab().set<Position>({10, 20});
-    world.entity().is_a(base);
-    world.entity().is_a(base);
-
-    int32_t count = 0;
-    f.iter([&](flecs::iter& it) {
-        const auto p = it.field<Position>(1);
-        Position pv = *p;
-        for (size_t i = 0; i < it.count(); i ++) {
-            test_int(pv.x, 10);
-            test_int(pv.y, 20);
-            count ++;
-        }
-    });
-
-    test_int(count, 2);
-}
-
-void FilterBuilder_with_id(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with(ecs.id<Position>())
-            .with(ecs.id<Velocity>())
-            .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_with_name(void) {
-    flecs::world ecs;
-
-    ecs.component<Velocity>();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .with("Velocity")
-            .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_with_component(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .with<Velocity>()
-            .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_with_pair_id(void) {
-    flecs::world ecs;
-
-    flecs::entity Likes = ecs.entity();
-    flecs::entity Apples = ecs.entity();
-    flecs::entity Pears = ecs.entity();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .with(Likes, Apples)
-            .build();
-
-    auto e1 = ecs.entity().add<Position>().add(Likes, Apples);
-    ecs.entity().add<Position>().add(Likes, Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_with_pair_name(void) {
-    flecs::world ecs;
-
-    flecs::entity Likes = ecs.entity("Likes");
-    flecs::entity Apples = ecs.entity("Apples");
-    flecs::entity Pears = ecs.entity("Pears");
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .with("Likes", "Apples")
-            .build();
-
-    auto e1 = ecs.entity().add<Position>().add(Likes, Apples);
-    ecs.entity().add<Position>().add(Likes, Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_with_pair_components(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Apples { };
-    struct Pears { };
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .with<Likes, Apples>()
-            .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Likes, Apples>();
-    ecs.entity().add<Position>().add<Likes, Pears>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_with_pair_component_id(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    flecs::entity Apples = ecs.entity();
-    flecs::entity Pears = ecs.entity();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .with<Likes>(Apples)
-            .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Likes>(Apples);
-    ecs.entity().add<Position>().add<Likes>(Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_with_pair_component_name(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    flecs::entity Apples = ecs.entity("Apples");
-    flecs::entity Pears = ecs.entity("Pears");
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .with<Likes>("Apples")
-            .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Likes>(Apples);
-    ecs.entity().add<Position>().add<Likes>(Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_with_enum(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .with(Green)
-            .build();
-
-    auto e1 = ecs.entity().add<Position>().add(Green);
-    ecs.entity().add<Position>().add(Red);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_without_id(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with(ecs.id<Position>())
-            .without(ecs.id<Velocity>())
-            .build();
-
-    ecs.entity().add<Position>().add<Velocity>();
-    auto e2 = ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e2);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_without_name(void) {
-    flecs::world ecs;
-
-    ecs.component<Velocity>();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with(ecs.id<Position>())
-            .without("Velocity")
-            .build();
-
-    ecs.entity().add<Position>().add<Velocity>();
-    auto e2 = ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e2);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_without_component(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .without<Velocity>()
-            .build();
-
-    ecs.entity().add<Position>().add<Velocity>();
-    auto e2 = ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e2);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_without_pair_id(void) {
-    flecs::world ecs;
-
-    flecs::entity Likes = ecs.entity();
-    flecs::entity Apples = ecs.entity();
-    flecs::entity Pears = ecs.entity();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .without(Likes, Apples)
-            .build();
-
-    ecs.entity().add<Position>().add(Likes, Apples);
-    auto e2 = ecs.entity().add<Position>().add(Likes, Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e2);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_without_pair_name(void) {
-    flecs::world ecs;
-
-    flecs::entity Likes = ecs.entity("Likes");
-    flecs::entity Apples = ecs.entity("Apples");
-    flecs::entity Pears = ecs.entity("Pears");
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .without("Likes", "Apples")
-            .build();
-
-    ecs.entity().add<Position>().add(Likes, Apples);
-    auto e2 = ecs.entity().add<Position>().add(Likes, Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e2);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_without_pair_components(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Apples { };
-    struct Pears { };
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .without<Likes, Apples>()
-            .build();
-
-    ecs.entity().add<Position>().add<Likes, Apples>();
-    auto e2 = ecs.entity().add<Position>().add<Likes, Pears>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e2);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_without_pair_component_id(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    flecs::entity Apples = ecs.entity();
-    flecs::entity Pears = ecs.entity();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .without<Likes>(Apples)
-            .build();
-
-    ecs.entity().add<Position>().add<Likes>(Apples);
-    auto e2 = ecs.entity().add<Position>().add<Likes>(Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e2);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_without_pair_component_name(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    flecs::entity Apples = ecs.entity("Apples");
-    flecs::entity Pears = ecs.entity("Pears");
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .without<Likes>("Apples")
-            .build();
-
-    ecs.entity().add<Position>().add<Likes>(Apples);
-    auto e2 = ecs.entity().add<Position>().add<Likes>(Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e2);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_without_enum(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .without(Green)
-            .build();
-
-    ecs.entity().add<Position>().add(Green);
-    auto e2 = ecs.entity().add<Position>().add(Red);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e2);
-    });
-    
-    test_int(count, 1);
-}
-
-void FilterBuilder_write_id(void) {
-    flecs::world ecs;
-
-    auto q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .write(ecs.id<Position>())
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::Out);
-    test_assert(q.term(1).get_first() == ecs.id<Position>());
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_write_name(void) {
-    flecs::world ecs;
-
-    ecs.component<Position>();
-
-    auto q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .write("Position")
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::Out);
-    test_assert(q.term(1).get_first() == ecs.id<Position>());
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_write_component(void) {
-    flecs::world ecs;
-
-    ecs.component<Position>();
-
-    auto q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .write<Position>()
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::Out);
-    test_assert(q.term(1).get_first() == ecs.id<Position>());
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_write_pair_id(void) {
-    flecs::world ecs;
-
-    flecs::entity Likes = ecs.entity();
-    flecs::entity Apples = ecs.entity();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .write(Likes, Apples)
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::Out);
-    test_assert(q.term(1).get_first() == Likes);
-    test_assert(q.term(1).get_second() == Apples);
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_write_pair_name(void) {
-    flecs::world ecs;
-
-    flecs::entity Likes = ecs.entity("Likes");
-    flecs::entity Apples = ecs.entity("Apples");
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .write("Likes", "Apples")
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::Out);
-    test_assert(q.term(1).get_first() == Likes);
-    test_assert(q.term(1).get_second() == Apples);
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_write_pair_components(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Apples { };
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .write<Likes, Apples>()
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::Out);
-    test_assert(q.term(1).get_first() == ecs.id<Likes>());
-    test_assert(q.term(1).get_second() == ecs.id<Apples>());
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_write_pair_component_id(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    flecs::entity Apples = ecs.entity();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .write<Likes>(Apples)
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::Out);
-    test_assert(q.term(1).get_first() == ecs.id<Likes>());
-    test_assert(q.term(1).get_second() == Apples);
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_write_pair_component_name(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    flecs::entity Apples = ecs.entity("Apples");
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .write<Likes>("Apples")
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::Out);
-    test_assert(q.term(1).get_first() == ecs.id<Likes>());
-    test_assert(q.term(1).get_second() == Apples);
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_write_enum(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .write(Green)
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::Out);
-    test_assert(q.term(1).get_first() == ecs.id<Color>());
-    test_assert(q.term(1).get_second() == ecs.to_entity<Color>(Green));
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_read_id(void) {
-    flecs::world ecs;
-
-    auto q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .read(ecs.id<Position>())
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::In);
-    test_assert(q.term(1).get_first() == ecs.id<Position>());
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_read_name(void) {
-    flecs::world ecs;
-
-    ecs.component<Position>();
-
-    auto q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .read("Position")
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::In);
-    test_assert(q.term(1).get_first() == ecs.id<Position>());
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_read_component(void) {
-    flecs::world ecs;
-
-    ecs.component<Position>();
-
-    auto q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .read<Position>()
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::In);
-    test_assert(q.term(1).get_first() == ecs.id<Position>());
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_read_pair_id(void) {
-    flecs::world ecs;
-
-    flecs::entity Likes = ecs.entity();
-    flecs::entity Apples = ecs.entity();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .read(Likes, Apples)
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::In);
-    test_assert(q.term(1).get_first() == Likes);
-    test_assert(q.term(1).get_second() == Apples);
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_read_pair_name(void) {
-    flecs::world ecs;
-
-    flecs::entity Likes = ecs.entity("Likes");
-    flecs::entity Apples = ecs.entity("Apples");
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .read("Likes", "Apples")
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::In);
-    test_assert(q.term(1).get_first() == Likes);
-    test_assert(q.term(1).get_second() == Apples);
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_read_pair_components(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Apples { };
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .read<Likes, Apples>()
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::In);
-    test_assert(q.term(1).get_first() == ecs.id<Likes>());
-    test_assert(q.term(1).get_second() == ecs.id<Apples>());
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_read_pair_component_id(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    flecs::entity Apples = ecs.entity();
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .read<Likes>(Apples)
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::In);
-    test_assert(q.term(1).get_first() == ecs.id<Likes>());
-    test_assert(q.term(1).get_second() == Apples);
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_read_pair_component_name(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    flecs::entity Apples = ecs.entity("Apples");
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .read<Likes>("Apples")
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::In);
-    test_assert(q.term(1).get_first() == ecs.id<Likes>());
-    test_assert(q.term(1).get_second() == Apples);
-
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_read_enum(void) {
-    flecs::world ecs;
-
-    flecs::filter<> q = 
-        ecs.filter_builder()
-            .with<Position>()
-            .read(Green)
-            .build();
-
-    test_assert(q.term(1).inout() == flecs::In);
-    test_assert(q.term(1).get_first() == ecs.id<Color>());
-    test_assert(q.term(1).get_second() == ecs.to_entity<Color>(Green));
-    test_assert(q.term(1).get_src() == 0);
-}
-
-void FilterBuilder_assign_after_init(void) {
-    flecs::world ecs;
-
-    flecs::filter<> f;
-    flecs::filter_builder<> fb = ecs.filter_builder();
-    fb.with<Position>();
-    f = fb.build();
-
-    flecs::entity e1 = ecs.entity().set<Position>({10, 20});
-
-    int32_t count = 0;
-    f.each([&](flecs::entity e) {
-        test_assert(e == e1);
-        count ++;
-    });
-
-    test_int(count, 1);
-}
-
-void FilterBuilder_iter_w_stage(void) {
-    flecs::world ecs;
-
-    ecs.set_stage_count(2);
-    flecs::world stage = ecs.get_stage(1);
-
-    auto e1 = ecs.entity().add<Position>();
-
-    auto q = ecs.filter<Position>();
-
-    int32_t count = 0;
-    q.each(stage, [&](flecs::iter& it, size_t i, Position&) {
-        test_assert(it.world() == stage);
-        test_assert(it.entity(i) == e1);
-        count ++;
-    });
-
-    test_int(count, 1);
-}
-
-void FilterBuilder_with_t_inout(void) {
-    flecs::world ecs;
-
-    flecs::filter<> f = ecs.filter_builder()
-        .with(ecs.id<Position>())
-        .build();
-
-    test_assert(f.term(0).inout() == flecs::InOutNone);
-}
-
-void FilterBuilder_with_T_inout(void) {
-    flecs::world ecs;
-
-    flecs::filter<> f = ecs.filter_builder()
-        .with<Position>()
-        .build();
-
-    test_assert(f.term(0).inout() == flecs::InOutNone);
-}
-
-void FilterBuilder_with_R_T_inout(void) {
-    flecs::world ecs;
-
-    flecs::filter<> f = ecs.filter_builder()
-        .with<Position, Velocity>()
-        .build();
-
-    test_assert(f.term(0).inout() == flecs::InOutNone);
-}
-
-void FilterBuilder_with_R_t_inout(void) {
-    flecs::world ecs;
-
-    flecs::filter<> f = ecs.filter_builder()
-        .with<Position>(ecs.id<Velocity>())
-        .build();
-
-    test_assert(f.term(0).inout() == flecs::InOutNone);
-}
-
-void FilterBuilder_with_r_t_inout(void) {
-    flecs::world ecs;
-
-    flecs::filter<> f = ecs.filter_builder()
-        .with(ecs.id<Position>(), ecs.id<Velocity>())
-        .build();
-
-    test_assert(f.term(0).inout() == flecs::InOutNone);
-}
diff --git a/test/cpp_api/src/QueryBuilder.cpp b/test/cpp_api/src/QueryBuilder.cpp
deleted file mode 100644
index b7b54bb3e..000000000
--- a/test/cpp_api/src/QueryBuilder.cpp
+++ /dev/null
@@ -1,2089 +0,0 @@
-#include <cpp_api.h>
-
-struct Other {
-    int32_t value;
-};
-
-void QueryBuilder_builder_assign_same_type(void) {
-    flecs::world ecs;
-
-    flecs::query<Position, Velocity> q = 
-        ecs.query_builder<Position, Velocity>().build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p, Velocity& v) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_builder_assign_to_empty(void) {
-    flecs::world ecs;
-
-    flecs::query<> q = ecs.query_builder<Position, Velocity>().build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_builder_assign_from_empty(void) {
-    flecs::world ecs;
-
-    flecs::query<> q = ecs.query_builder<>()
-        .term<Position>()
-        .term<Velocity>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_builder_build(void) {
-    flecs::world ecs;
-
-    flecs::query<Position, Velocity> q = 
-        ecs.query_builder<Position, Velocity>().build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p, Velocity& v) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_builder_build_to_auto(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Position, Velocity>().build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p, Velocity& v) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_builder_build_n_statements(void) {
-    flecs::world ecs;
-
-    auto qb = ecs.query_builder<>();
-    qb.term<Position>();
-    qb.term<Velocity>();
-    auto q = qb.build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_1_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Position>().build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_add_1_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<>()
-        .term<Position>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_add_2_types(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<>()
-        .term<Position>()
-        .term<Velocity>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_add_1_type_w_1_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Position>()
-        .term<Velocity>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_add_2_types_w_1_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Position>()
-        .term<Velocity>()
-        .term<Mass>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>().add<Mass>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_add_pair(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.query_builder<>()
-        .term(Likes, Bob)
-        .build();
-
-    auto e1 = ecs.entity().add(Likes, Bob);
-    ecs.entity().add(Likes, Alice);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_add_not(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Position>()
-        .term<Velocity>().oper(flecs::Not)
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Position>().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_add_or(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<>()
-        .term<Position>().oper(flecs::Or)
-        .term<Velocity>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Velocity>();
-    ecs.entity().add<Mass>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1 || e == e2);
-    });
-    
-    test_int(count, 2);
-}
-
-void QueryBuilder_add_optional(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<>()
-        .term<Position>()
-        .term<Velocity>().oper(flecs::Optional)
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>().add<Mass>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1 || e == e2);
-    });
-    
-    test_int(count, 2);
-}
-
-void QueryBuilder_ptr_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Position, Velocity*>().build();
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>().add<Mass>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p, Velocity* v) {
-        count ++;
-        test_assert(e == e1 || e == e2);
-    });
-    
-    test_int(count, 2);
-}
-
-void QueryBuilder_const_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<const Position>().build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, const Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_string_term(void) {
-    flecs::world ecs;
-
-    ecs.component<Position>();
-
-    auto q = ecs.query_builder<>()
-        .expr("Position")
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_singleton_term(void) {
-    flecs::world ecs;
-
-    ecs.set<Other>({10});
-
-    auto q = ecs.query_builder<Self>()
-        .term<Other>().singleton()
-        .build();
-
-    auto 
-    e = ecs.entity(); e.set<Self>({e});
-    e = ecs.entity(); e.set<Self>({e});
-    e = ecs.entity(); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-        test_assert(!it.is_self(2));
-        test_int(o->value, 10);
-        
-        const Other& o_ref = *o;
-        test_int(o_ref.value, 10);
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 3);
-}
-
-void QueryBuilder_isa_superset_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self>()
-        .term<Other>().src().up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-        test_assert(!it.is_self(2));
-        test_int(o->value, 10);
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 3);
-}
-
-void QueryBuilder_isa_self_superset_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self>()
-        .term<Other>().src().self().up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
-
-    int32_t count = 0;
-    int32_t owned_count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-
-        if (!it.is_self(2)) {
-            test_int(o->value, 10);
-        } else {
-            for (auto i : it) {
-                test_int(o[i].value, 20);
-                owned_count ++;
-            }
-        }
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 5);
-    test_int(owned_count, 2);
-}
-
-void QueryBuilder_childof_superset_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self>()
-        .term<Other>().src().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-        test_assert(!it.is_self(2));
-        test_int(o->value, 10);
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 3);
-}
-
-void QueryBuilder_childof_self_superset_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self>()
-        .term<Other>().src().self().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({20}); e.set<Self>({e});
-
-    int32_t count = 0;
-    int32_t owned_count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-
-        if (!it.is_self(2)) {
-            test_int(o->value, 10);
-        } else {
-            for (auto i : it) {
-                test_int(o[i].value, 20);
-                owned_count ++;
-            }
-        }
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 5);
-    test_int(owned_count, 2);
-}
-
-void QueryBuilder_isa_superset_term_w_each(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self, Other>()
-        .arg(2).src().up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 3);
-}
-
-void QueryBuilder_isa_self_superset_term_w_each(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self, Other>()
-        .arg(2).src().self().up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().add(flecs::IsA, base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 5);
-}
-
-void QueryBuilder_childof_superset_term_w_each(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self, Other>()
-        .arg(2).src().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 3);
-}
-
-void QueryBuilder_childof_self_superset_term_w_each(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self, Other>()
-        .arg(2).src().self().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 5);
-}
-
-void QueryBuilder_isa_superset_shortcut(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self, Other>()
-        .arg(2).up()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 3);
-}
-
-void QueryBuilder_isa_superset_shortcut_w_self(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self, Other>()
-        .arg(2).self().up(flecs::IsA)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().is_a(base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 5);
-}
-
-void QueryBuilder_childof_superset_shortcut(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self, Other>()
-        .arg(2).up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 3);
-}
-
-void QueryBuilder_childof_superset_shortcut_w_self(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Self, Other>()
-        .arg(2).self().up(flecs::ChildOf)
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().child_of(base); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-    e = ecs.entity().set<Other>({10}); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s, Other& o) {
-        test_assert(e == s.value);
-        test_int(o.value, 10);
-        count ++;
-    });
-    
-    test_int(count, 5);
-}
-
-void QueryBuilder_relation(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.query_builder<Self>()
-        .term(Likes, Bob)
-        .build();
-
-    auto 
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
-
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({0});
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({0});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-    
-    test_int(count, 2);
-}
-
-void QueryBuilder_relation_w_object_wildcard(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.query_builder<Self>()
-        .term(Likes, flecs::Wildcard)
-        .build();
-
-    auto 
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({e});
-
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({e});
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({e});
-
-    e = ecs.entity(); e.set<Self>({0});
-    e = ecs.entity(); e.set<Self>({0});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-    
-    test_int(count, 4);
-}
-
-void QueryBuilder_relation_w_predicate_wildcard(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Dislikes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.query_builder<Self>()
-        .term(flecs::Wildcard, Alice)
-        .build();
-
-    auto 
-    e = ecs.entity().add(Likes, Alice); e.set<Self>({e});
-    e = ecs.entity().add(Dislikes, Alice); e.set<Self>({e});
-
-    e = ecs.entity().add(Likes, Bob); e.set<Self>({0});
-    e = ecs.entity().add(Dislikes, Bob); e.set<Self>({0});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-    
-    test_int(count, 2);
-}
-
-void QueryBuilder_add_pair_w_rel_type(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    
-    auto Dislikes = ecs.entity();
-    auto Bob = ecs.entity();
-    auto Alice = ecs.entity();
-
-    auto q = ecs.query_builder<Self>()
-        .term<Likes>(flecs::Wildcard)
-        .build();
-
-    auto 
-    e = ecs.entity().add<Likes>(Alice); e.set<Self>({e});
-    e = ecs.entity().add(Dislikes, Alice); e.set<Self>({0});
-
-    e = ecs.entity().add<Likes>(Bob); e.set<Self>({e});
-    e = ecs.entity().add(Dislikes, Bob); e.set<Self>({0});
-
-    int32_t count = 0;
-
-    q.each([&](flecs::entity e, Self& s) {
-        test_assert(e == s.value);
-        count ++;
-    });
-    
-    test_int(count, 2);
-}
-
-void QueryBuilder_template_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Position>()
-        .term<Template<int>>()
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Template<int>>();
-    ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_explicit_subject_w_id(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<Position>()
-        .term<Position>().id(flecs::This)
-        .build();
-
-    auto e1 = ecs.entity().add<Position>().add<Velocity>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_explicit_subject_w_type(void) {
-    flecs::world ecs;
-
-    ecs.set<Position>({10, 20});
-
-    auto q = ecs.query_builder<Position>()
-        .term<Position>().src<Position>()
-        .build();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position& p) {
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-        count ++;
-        test_assert(e == ecs.singleton<Position>());
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_explicit_object_w_id(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Alice = ecs.entity();
-    auto Bob = ecs.entity();
-
-    auto q = ecs.query_builder<>()
-        .term(Likes).second(Alice)
-        .build();
-
-    auto e1 = ecs.entity().add(Likes, Alice);
-    ecs.entity().add(Likes, Bob);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_explicit_object_w_type(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    struct Alice { };
-    auto Bob = ecs.entity();
-
-    auto q = ecs.query_builder<>()
-        .term(Likes).second<Alice>()
-        .build();
-
-    auto e1 = ecs.entity().add(Likes, ecs.id<Alice>());
-    ecs.entity().add(Likes, Bob);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_explicit_term(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<>()
-        .term(ecs.term(ecs.id<Position>()))
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_explicit_term_w_type(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder<>()
-        .term(ecs.term<Position>())
-        .build();
-
-    auto e1 = ecs.entity().add<Position>();
-    ecs.entity().add<Velocity>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_explicit_term_w_pair_type(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Alice { };
-    struct Bob { };
-
-    auto q = ecs.query_builder<>()
-        .term(ecs.term<Likes, Alice>())
-        .build();
-
-    auto e1 = ecs.entity().add<Likes, Alice>();
-    ecs.entity().add<Likes, Bob>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_explicit_term_w_id(void) {
-    flecs::world ecs;
-
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    auto q = ecs.query_builder<>()
-        .term(ecs.term(Apples))
-        .build();
-
-    auto e1 = ecs.entity().add(Apples);
-    ecs.entity().add(Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_explicit_term_w_pair_id(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    auto q = ecs.query_builder<>()
-        .term(ecs.term(Likes, Apples))
-        .build();
-
-    auto e1 = ecs.entity().add(Likes, Apples);
-    ecs.entity().add(Likes, Pears);
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_1_term_to_empty(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Apples = ecs.entity();
-
-    auto qb = ecs.query_builder<>()
-        .term<Position>();
-
-    qb.term(Likes, Apples);
-
-    auto q = qb.build();
-
-    test_int(q.field_count(), 2);
-    test_int(q.term(0).id(), ecs.id<Position>());
-    test_int(q.term(1).id(), ecs.pair(Likes, Apples));
-}
-
-void QueryBuilder_2_subsequent_args(void) {
-    flecs::world ecs;
-
-    struct Rel { int foo; };
-
-    int32_t count = 0;
-
-    auto s = ecs.system<Rel, const Velocity>()
-        .arg(1).second(flecs::Wildcard)
-        .arg(2).singleton()
-        .iter([&](flecs::iter it){
-            count += it.count();
-        });
-    
-    ecs.entity().add<Rel, Tag>();
-    ecs.set<Velocity>({});
-
-    s.run();
-
-    test_int(count, 1);
-}
-
-void QueryBuilder_optional_tag_is_set(void) {
-    flecs::world ecs;
-
-    struct TagA { };
-    struct TagB { };
-
-    auto q = ecs.query_builder()
-        .term<TagA>()
-        .term<TagB>().oper(flecs::Optional)
-        .build();
-
-    auto e_1 = ecs.entity().add<TagA>().add<TagB>();
-    auto e_2 = ecs.entity().add<TagA>();
-
-    int count = 0;
-
-    q.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-
-        count += it.count();
-        
-        if (it.entity(0) == e_1) {
-            test_bool(it.is_set(1), true);
-            test_bool(it.is_set(2), true);
-        } else {
-            test_assert(it.entity(0) == e_2);
-            test_bool(it.is_set(1), true);
-            test_bool(it.is_set(2), false);
-        }
-    });
-
-    test_int(count, 2);
-}
-
-void QueryBuilder_10_terms(void) {
-    flecs::world ecs;
-
-    auto f = ecs.query_builder<>()
-        .term<TagA>()
-        .term<TagB>()
-        .term<TagC>()
-        .term<TagD>()
-        .term<TagE>()
-        .term<TagF>()
-        .term<TagG>()
-        .term<TagH>()
-        .term<TagI>()
-        .term<TagJ>()
-        .build();
-
-    test_int(f.field_count(), 10);
-
-    auto e = ecs.entity()
-        .add<TagA>()
-        .add<TagB>()
-        .add<TagC>()
-        .add<TagD>()
-        .add<TagE>()
-        .add<TagF>()
-        .add<TagG>()
-        .add<TagH>()
-        .add<TagI>()
-        .add<TagJ>();
-
-    int count = 0;
-    f.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-        test_assert(it.entity(0) == e);
-        test_int(it.field_count(), 10);
-        count ++;
-    });
-
-    test_int(count, 1);
-}
-
-void QueryBuilder_20_terms(void) {
-    flecs::world ecs;
-
-    auto f = ecs.query_builder<>()
-        .term<TagA>()
-        .term<TagB>()
-        .term<TagC>()
-        .term<TagD>()
-        .term<TagE>()
-        .term<TagF>()
-        .term<TagG>()
-        .term<TagH>()
-        .term<TagI>()
-        .term<TagJ>()
-        .term<TagK>()
-        .term<TagL>()
-        .term<TagM>()
-        .term<TagN>()
-        .term<TagO>()
-        .term<TagP>()
-        .term<TagQ>()
-        .term<TagR>()
-        .term<TagS>()
-        .term<TagT>()
-        .build();
-
-    test_int(f.field_count(), 20);
-
-    auto e = ecs.entity()
-        .add<TagA>()
-        .add<TagB>()
-        .add<TagC>()
-        .add<TagD>()
-        .add<TagE>()
-        .add<TagF>()
-        .add<TagG>()
-        .add<TagH>()
-        .add<TagI>()
-        .add<TagJ>()
-        .add<TagK>()
-        .add<TagL>()
-        .add<TagM>()
-        .add<TagN>()
-        .add<TagO>()
-        .add<TagP>()
-        .add<TagQ>()
-        .add<TagR>()
-        .add<TagS>()
-        .add<TagT>();
-
-    int count = 0;
-    f.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-        test_assert(it.entity(0) == e);
-        test_int(it.field_count(), 20);
-        count ++;
-    });
-
-    test_int(count, 1);
-}
-
-uint64_t group_by_first_id(
-    flecs::world_t *m_world,
-    flecs::table_t *m_table,
-    flecs::entity_t id,
-    void *ctx)
-{
-    const flecs::type_t *type = ecs_table_get_type(m_table);
-    return type->array[0];
-}
-
-uint64_t group_by_first_id_negated(
-    flecs::world_t *m_world,
-    flecs::table_t *m_table,
-    flecs::entity_t id,
-    void *ctx)
-{
-    return ~group_by_first_id(m_world, m_table, id, ctx);
-}
-
-void QueryBuilder_group_by_raw(void) {
-    flecs::world ecs;
-
-    struct TagA { };
-    struct TagB { };
-    struct TagC { };
-    struct TagX { };
-
-    ecs.component<TagA>();
-    ecs.component<TagB>();
-    ecs.component<TagC>();
-    ecs.component<TagX>();
-
-    auto q = ecs.query_builder()
-        .term<TagX>()
-        .group_by(flecs::type_id<TagX>(), group_by_first_id)
-        .build();
-
-    auto q_reverse = ecs.query_builder()
-        .term<TagX>()
-        .group_by(flecs::type_id<TagX>(), group_by_first_id_negated)
-        .build();
-
-    auto e3 = ecs.entity().add<TagX>().add<TagC>();
-    auto e2 = ecs.entity().add<TagX>().add<TagB>();
-    auto e1 = ecs.entity().add<TagX>().add<TagA>();
-
-    int count = 0;
-
-    q.iter([&](flecs::iter& it){
-        test_int(it.count(), 1);
-        if(count == 0){
-            test_bool(it.entity(0) == e1, true);
-        }else if(count == 1){
-            test_bool(it.entity(0) == e2, true);
-        }else if(count == 2){
-            test_bool(it.entity(0) == e3, true);
-        }else{
-            test_assert(false);
-        }
-        count++;
-    });
-    test_int(count, 3);
-    
-    count = 0;
-    q_reverse.iter([&](flecs::iter& it){
-        test_int(it.count(), 1);
-        if(count == 0){
-            test_bool(it.entity(0) == e3, true);
-        }else if(count == 1){
-            test_bool(it.entity(0) == e2, true);
-        }else if(count == 2){
-            test_bool(it.entity(0) == e1, true);
-        }else{
-            test_assert(false);
-        }
-        count++;
-    });
-    test_int(count, 3);
-}
-
-void QueryBuilder_group_by_template(void) {
-    flecs::world ecs;
-
-    struct TagA { };
-    struct TagB { };
-    struct TagC { };
-    struct TagX { };
-
-    ecs.component<TagA>();
-    ecs.component<TagB>();
-    ecs.component<TagC>();
-    ecs.component<TagX>();
-
-    auto q = ecs.query_builder()
-        .term<TagX>()
-        .group_by<TagX>(group_by_first_id)
-        .build();
-
-    auto q_reverse = ecs.query_builder()
-        .term<TagX>()
-        .group_by<TagX>( group_by_first_id_negated)
-        .build();
-
-    auto e3 = ecs.entity().add<TagX>().add<TagC>();
-    auto e2 = ecs.entity().add<TagX>().add<TagB>();
-    auto e1 = ecs.entity().add<TagX>().add<TagA>();
-
-    int count = 0;
-
-    q.iter([&](flecs::iter& it){
-        test_int(it.count(), 1);
-        if(count == 0){
-            test_bool(it.entity(0) == e1, true);
-        }else if(count == 1){
-            test_bool(it.entity(0) == e2, true);
-        }else if(count == 2){
-            test_bool(it.entity(0) == e3, true);
-        }else{
-            test_assert(false);
-        }
-        count++;
-    });
-    test_int(count, 3);
-    
-    count = 0;
-    q_reverse.iter([&](flecs::iter& it){
-        test_int(it.count(), 1);
-        if(count == 0){
-            test_bool(it.entity(0) == e3, true);
-        }else if(count == 1){
-            test_bool(it.entity(0) == e2, true);
-        }else if(count == 2){
-            test_bool(it.entity(0) == e1, true);
-        }else{
-            test_assert(false);
-        }
-        count++;
-    });
-    test_int(count, 3);
-}
-
-static
-uint64_t group_by_rel(flecs::world_t *world, flecs::table_t *table, flecs::entity_t id, void *ctx) {
-    ecs_id_t match;
-    if (ecs_search(world, table, ecs_pair(id, EcsWildcard), &match) != -1) {
-        return ECS_PAIR_SECOND(match);
-    }
-    return 0;
-}
-
-void QueryBuilder_group_by_iter_one(void) {
-    flecs::world ecs;
-
-    auto Rel = ecs.entity();
-    auto TgtA = ecs.entity();
-    auto TgtB = ecs.entity();
-    auto TgtC = ecs.entity();
-    auto Tag = ecs.entity();
-
-    ecs.entity().add(Rel, TgtA);
-    auto e2 = ecs.entity().add(Rel, TgtB);
-    ecs.entity().add(Rel, TgtC);
-
-    ecs.entity().add(Rel, TgtA).add(Tag);
-    auto e5 = ecs.entity().add(Rel, TgtB).add(Tag);
-    ecs.entity().add(Rel, TgtC).add(Tag);
-
-    auto q = ecs.query_builder()
-        .term(Rel, flecs::Wildcard)
-        .group_by(Rel, group_by_rel)
-        .build();
-
-    bool e2_found = false;
-    bool e5_found = false;
-    int32_t count = 0;
-
-    q.iter().set_group(TgtB).each([&](flecs::iter& it, size_t i) {
-        flecs::entity e = it.entity(i);
-        test_assert(it.group_id() == TgtB);
-
-        if (e == e2) e2_found = true;
-        if (e == e5) e5_found = true;
-        count ++;
-    });
-
-    test_int(2, count);
-    test_bool(true, e2_found);
-    test_bool(true, e5_found);
-}
-
-void QueryBuilder_group_by_iter_one_template(void) {
-    flecs::world ecs;
-
-    struct Rel { };
-    struct TgtA { };
-    struct TgtB { };
-    struct TgtC { };
-    struct Tag { };
-
-    ecs.entity().add<Rel, TgtA>();
-    auto e2 = ecs.entity().add<Rel, TgtB>();
-    ecs.entity().add<Rel, TgtC>();
-
-    ecs.entity().add<Rel, TgtA>().add<Tag>();
-    auto e5 = ecs.entity().add<Rel, TgtB>().add<Tag>();
-    ecs.entity().add<Rel, TgtC>().add<Tag>();
-
-    auto q = ecs.query_builder()
-        .term<Rel>(flecs::Wildcard)
-        .group_by<Rel>(group_by_rel)
-        .build();
-
-    bool e2_found = false;
-    bool e5_found = false;
-    int32_t count = 0;
-
-    q.iter().set_group<TgtB>().each([&](flecs::iter& it, size_t i) {
-        flecs::entity e = it.entity(i);
-        test_assert(it.group_id() == ecs.id<TgtB>());
-
-        if (e == e2) e2_found = true;
-        if (e == e5) e5_found = true;
-        count ++;
-    });
-
-    test_int(2, count);
-    test_bool(true, e2_found);
-    test_bool(true, e5_found);
-}
-
-void QueryBuilder_group_by_iter_one_all_groups(void) {
-    flecs::world ecs;
-
-    auto Rel = ecs.entity();
-    auto TgtA = ecs.entity();
-    auto TgtB = ecs.entity();
-    auto TgtC = ecs.entity();
-    auto Tag = ecs.entity();
-
-    auto e1 = ecs.entity().add(Rel, TgtA);
-    auto e2 = ecs.entity().add(Rel, TgtB);
-    auto e3 = ecs.entity().add(Rel, TgtC);
-
-    auto e4 = ecs.entity().add(Rel, TgtA).add(Tag);
-    auto e5 = ecs.entity().add(Rel, TgtB).add(Tag);
-    auto e6 = ecs.entity().add(Rel, TgtC).add(Tag);
-
-    auto q = ecs.query_builder()
-        .term(Rel, flecs::Wildcard)
-        .group_by(Rel, group_by_rel)
-        .build();
-
-    int e1_found = 0;
-    int e2_found = 0;
-    int e3_found = 0;
-    int e4_found = 0;
-    int e5_found = 0;
-    int e6_found = 0;
-    int32_t count = 0;
-    uint64_t group_id = 0;
-
-    const auto func = [&](flecs::iter& it, size_t i) {
-        flecs::entity e = it.entity(i);
-        test_assert(it.group_id() == group_id);
-        if (e == e1) e1_found ++;
-        if (e == e2) e2_found ++;
-        if (e == e3) e3_found ++;
-        if (e == e4) e4_found ++;
-        if (e == e5) e5_found ++;
-        if (e == e6) e6_found ++;
-        count ++;
-    };
-
-    group_id = TgtB;
-    q.iter().set_group(TgtB).each(func);
-    test_int(2, count);
-    test_int(1, e2_found);
-    test_int(1, e5_found);
-
-    group_id = TgtA;
-    q.iter().set_group(TgtA).each(func);
-    test_int(4, count);
-    test_int(1, e1_found);
-    test_int(1, e4_found);
-
-    group_id = TgtC;
-    q.iter().set_group(TgtC).each(func);
-    test_int(6, count);
-    test_int(1, e3_found);
-    test_int(1, e6_found);
-
-    test_int(1, e1_found);
-    test_int(1, e2_found);
-    test_int(1, e3_found);
-    test_int(1, e4_found);
-    test_int(1, e5_found);
-    test_int(1, e6_found);
-}
-
-void QueryBuilder_group_by_default_func_w_id(void) {
-    flecs::world ecs;
-
-    auto Rel = ecs.entity();
-    auto TgtA = ecs.entity();
-    auto TgtB = ecs.entity();
-    auto TgtC = ecs.entity();
-
-    auto e1 = ecs.entity().add(Rel, TgtC);
-    auto e2 = ecs.entity().add(Rel, TgtB);
-    auto e3 = ecs.entity().add(Rel, TgtA);
-
-    auto q = ecs.query_builder()
-        .term(Rel, flecs::Wildcard)
-        .group_by(Rel)
-        .build();
-
-    bool e1_found = false;
-    bool e2_found = false;
-    bool e3_found = false;
-    int32_t count = 0;
-
-    q.each([&](flecs::iter& it, size_t i) {
-        flecs::entity e = it.entity(i);
-        if (e == e1) {
-            test_assert(it.group_id() == TgtC);
-            test_assert(!e1_found);
-            test_assert(e2_found);
-            test_assert(e3_found);
-            e1_found = true;
-        }
-        if (e == e2) {
-            test_assert(it.group_id() == TgtB);
-            test_assert(!e1_found);
-            test_assert(!e2_found);
-            test_assert(e3_found);
-            e2_found = true;
-        }
-        if (e == e3) {
-            test_assert(it.group_id() == TgtA);
-            test_assert(!e1_found);
-            test_assert(!e2_found);
-            test_assert(!e3_found);
-            e3_found = true;
-        }
-        count ++;
-    });
-
-    test_int(3, count);
-    test_bool(true, e1_found);
-    test_bool(true, e2_found);
-    test_bool(true, e3_found);
-}
-
-void QueryBuilder_group_by_default_func_w_type(void) {
-    flecs::world ecs;
-
-    struct Rel { };
-    auto TgtA = ecs.entity();
-    auto TgtB = ecs.entity();
-    auto TgtC = ecs.entity();
-
-    auto e1 = ecs.entity().add<Rel>(TgtC);
-    auto e2 = ecs.entity().add<Rel>(TgtB);
-    auto e3 = ecs.entity().add<Rel>(TgtA);
-
-    auto q = ecs.query_builder()
-        .term<Rel>(flecs::Wildcard)
-        .group_by<Rel>()
-        .build();
-
-    bool e1_found = false;
-    bool e2_found = false;
-    bool e3_found = false;
-    int32_t count = 0;
-
-    q.each([&](flecs::iter& it, size_t i) {
-        flecs::entity e = it.entity(i);
-        if (e == e1) {
-            test_assert(it.group_id() == TgtC);
-            test_assert(!e1_found);
-            test_assert(e2_found);
-            test_assert(e3_found);
-            e1_found = true;
-        }
-        if (e == e2) {
-            test_assert(it.group_id() == TgtB);
-            test_assert(!e1_found);
-            test_assert(!e2_found);
-            test_assert(e3_found);
-            e2_found = true;
-        }
-        if (e == e3) {
-            test_assert(it.group_id() == TgtA);
-            test_assert(!e1_found);
-            test_assert(!e2_found);
-            test_assert(!e3_found);
-            e3_found = true;
-        }
-        count ++;
-    });
-
-    test_int(3, count);
-    test_bool(true, e1_found);
-    test_bool(true, e2_found);
-    test_bool(true, e3_found);
-}
-
-static int group_by_ctx = 0;
-
-void QueryBuilder_group_by_callbacks(void) {
-    flecs::world ecs;
-
-    struct Rel { };
-    auto TgtA = ecs.entity();
-    auto TgtB = ecs.entity();
-    auto TgtC = ecs.entity();
-
-    auto e1 = ecs.entity().add<Rel>(TgtC);
-    auto e2 = ecs.entity().add<Rel>(TgtB);
-    auto e3 = ecs.entity().add<Rel>(TgtA);
-
-    auto q = ecs.query_builder()
-        .term<Rel>(flecs::Wildcard)
-        .group_by<Rel>()
-        .group_by_ctx(&group_by_ctx)
-        .on_group_create(
-            [](flecs::world_t *world, uint64_t id, void *group_by_arg) {
-                test_assert(world != nullptr);
-                test_assert(id != 0);
-                test_assert(group_by_arg != nullptr);
-                test_assert(group_by_arg == &group_by_ctx);
-                uint64_t *ctx = ecs_os_malloc_t(uint64_t);
-                *ctx = id;
-                return (void*)ctx;
-            })
-        .on_group_delete(
-            [](flecs::world_t *world, uint64_t id, void *ctx, void *group_by_arg) {
-                test_assert(world != nullptr);
-                test_assert(id != 0);
-                test_assert(group_by_arg != nullptr);
-                test_assert(group_by_arg == &group_by_ctx);
-                test_assert(ctx != NULL);
-                test_uint(*(uint64_t*)ctx, id);
-                ecs_os_free(ctx);
-            })
-        .build();
-
-    bool e1_found = false;
-    bool e2_found = false;
-    bool e3_found = false;
-    int32_t count = 0;
-
-    q.each([&](flecs::iter& it, size_t i) {
-        flecs::entity e = it.entity(i);
-        if (e == e1) {
-            test_assert(it.group_id() == TgtC);
-            test_assert(!e1_found);
-            test_assert(e2_found);
-            test_assert(e3_found);
-            e1_found = true;
-            uint64_t *ctx = (uint64_t*)q.group_ctx(it.group_id());
-            test_uint(*ctx, it.group_id());
-        }
-        if (e == e2) {
-            test_assert(it.group_id() == TgtB);
-            test_assert(!e1_found);
-            test_assert(!e2_found);
-            test_assert(e3_found);
-            e2_found = true;
-            uint64_t *ctx = (uint64_t*)q.group_ctx(it.group_id());
-            test_uint(*ctx, it.group_id());
-        }
-        if (e == e3) {
-            test_assert(it.group_id() == TgtA);
-            test_assert(!e1_found);
-            test_assert(!e2_found);
-            test_assert(!e3_found);
-            e3_found = true;
-            uint64_t *ctx = (uint64_t*)q.group_ctx(it.group_id());
-            test_uint(*ctx, it.group_id());
-        }
-        count ++;
-    });
-
-    test_int(3, count);
-    test_bool(true, e1_found);
-    test_bool(true, e2_found);
-    test_bool(true, e3_found);
-}
-
-void QueryBuilder_create_w_no_template_args(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder().term<Position>().build();
-
-    auto e1 = ecs.entity().add<Position>();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_any_wildcard(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Apple = ecs.entity();
-    auto Mango = ecs.entity();
-
-    auto e1 = ecs.entity()
-        .add(Likes, Apple)
-        .add(Likes, Mango);
-
-    auto q = ecs.query_builder()
-        .term(Likes, flecs::Any)
-        .build();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-    
-    test_int(count, 1);
-}
-
-void QueryBuilder_cascade(void) {
-    flecs::world ecs;
-
-    auto Tag = ecs.entity();
-    auto Foo = ecs.entity();
-    auto Bar = ecs.entity();
-
-    auto e0 = ecs.entity().add(Tag);
-    auto e1 = ecs.entity().is_a(e0);
-    auto e2 = ecs.entity().is_a(e1);
-    auto e3 = ecs.entity().is_a(e2);
-
-    auto q = ecs.query_builder()
-        .term(Tag).cascade()
-        .build();
-
-    e1.add(Bar);
-    e2.add(Foo);
-
-    bool e1_found = false;
-    bool e2_found = false;
-    bool e3_found = false;
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-
-        if (e == e1) {
-            test_bool(e1_found, false);
-            test_bool(e2_found, false);
-            test_bool(e3_found, false);
-            e1_found = true;
-        }
-        if (e == e2) {
-            test_bool(e1_found, true);
-            test_bool(e2_found, false);
-            test_bool(e3_found, false);
-            e2_found = true;
-        }
-        if (e == e3) {
-            test_bool(e1_found, true);
-            test_bool(e2_found, true);
-            test_bool(e3_found, false);
-            e3_found = true;
-        }
-    });
-
-    test_bool(e1_found, true);
-    test_bool(e2_found, true);
-    test_bool(e3_found, true);
-    test_int(count, 3);
-}
-
-void QueryBuilder_cascade_desc(void) {
-    flecs::world ecs;
-
-    auto Tag = ecs.entity();
-    auto Foo = ecs.entity();
-    auto Bar = ecs.entity();
-
-    auto e0 = ecs.entity().add(Tag);
-    auto e1 = ecs.entity().is_a(e0);
-    auto e2 = ecs.entity().is_a(e1);
-    auto e3 = ecs.entity().is_a(e2);
-
-    auto q = ecs.query_builder()
-        .term(Tag).cascade().desc()
-        .build();
-
-    e1.add(Bar);
-    e2.add(Foo);
-
-    bool e1_found = false;
-    bool e2_found = false;
-    bool e3_found = false;
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-
-        if (e == e1) {
-            test_bool(e1_found, false);
-            test_bool(e2_found, true);
-            test_bool(e3_found, true);
-            e1_found = true;
-        }
-        if (e == e2) {
-            test_bool(e1_found, false);
-            test_bool(e2_found, false);
-            test_bool(e3_found, true);
-            e2_found = true;
-        }
-        if (e == e3) {
-            test_bool(e1_found, false);
-            test_bool(e2_found, false);
-            test_bool(e3_found, false);
-            e3_found = true;
-        }
-    });
-
-    test_bool(e1_found, true);
-    test_bool(e2_found, true);
-    test_bool(e3_found, true);
-    test_int(count, 3);
-}
-
-void QueryBuilder_cascade_w_relationship(void) {
-    flecs::world ecs;
-
-    auto Tag = ecs.entity();
-    auto Foo = ecs.entity();
-    auto Bar = ecs.entity();
-
-    auto e0 = ecs.entity().add(Tag);
-    auto e1 = ecs.entity().child_of(e0);
-    auto e2 = ecs.entity().child_of(e1);
-    auto e3 = ecs.entity().child_of(e2);
-
-    auto q = ecs.query_builder()
-        .term(Tag).cascade(flecs::ChildOf)
-        .build();
-
-    e1.add(Bar);
-    e2.add(Foo);
-
-    bool e1_found = false;
-    bool e2_found = false;
-    bool e3_found = false;
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-
-        if (e == e1) {
-            test_bool(e1_found, false);
-            test_bool(e2_found, false);
-            test_bool(e3_found, false);
-            e1_found = true;
-        }
-        if (e == e2) {
-            test_bool(e1_found, true);
-            test_bool(e2_found, false);
-            test_bool(e3_found, false);
-            e2_found = true;
-        }
-        if (e == e3) {
-            test_bool(e1_found, true);
-            test_bool(e2_found, true);
-            test_bool(e3_found, false);
-            e3_found = true;
-        }
-    });
-
-    test_bool(e1_found, true);
-    test_bool(e2_found, true);
-    test_bool(e3_found, true);
-    test_int(count, 3);
-}
-
-void QueryBuilder_up_w_type(void) {
-    flecs::world ecs;
-
-    struct Rel { };
-
-    ecs.component<Rel>().add(flecs::Traversable);
-
-    auto q = ecs.query_builder<Self>()
-        .term<Other>().src().up<Rel>()
-        .build();
-
-    auto base = ecs.entity().set<Other>({10});
-
-    auto 
-    e = ecs.entity().add<Rel>(base); e.set<Self>({e});
-    e = ecs.entity().add<Rel>(base); e.set<Self>({e});
-    e = ecs.entity().add<Rel>(base); e.set<Self>({e});
-
-    int32_t count = 0;
-
-    q.iter([&](flecs::iter& it, Self *s) {
-        auto o = it.field<const Other>(2);
-        test_assert(!it.is_self(2));
-        test_int(o->value, 10);
-
-        for (auto i : it) {
-            test_assert(it.entity(i) == s[i].value);
-            count ++;
-        }
-    });
-    
-    test_int(count, 3);
-}
-
-void QueryBuilder_cascade_w_type(void) {
-    flecs::world ecs;
-
-    struct Rel { };
-
-    ecs.component<Rel>().add(flecs::Traversable);
-
-    auto Tag = ecs.entity();
-    auto Foo = ecs.entity();
-    auto Bar = ecs.entity();
-
-    auto e0 = ecs.entity().add(Tag);
-    auto e1 = ecs.entity().add<Rel>(e0);
-    auto e2 = ecs.entity().add<Rel>(e1);
-    auto e3 = ecs.entity().add<Rel>(e2);
-
-    auto q = ecs.query_builder()
-        .term(Tag).cascade<Rel>()
-        .build();
-
-    e1.add(Bar);
-    e2.add(Foo);
-
-    bool e1_found = false;
-    bool e2_found = false;
-    bool e3_found = false;
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        count ++;
-
-        if (e == e1) {
-            test_bool(e1_found, false);
-            test_bool(e2_found, false);
-            test_bool(e3_found, false);
-            e1_found = true;
-        }
-        if (e == e2) {
-            test_bool(e1_found, true);
-            test_bool(e2_found, false);
-            test_bool(e3_found, false);
-            e2_found = true;
-        }
-        if (e == e3) {
-            test_bool(e1_found, true);
-            test_bool(e2_found, true);
-            test_bool(e3_found, false);
-            e3_found = true;
-        }
-    });
-
-    test_bool(e1_found, true);
-    test_bool(e2_found, true);
-    test_bool(e3_found, true);
-    test_int(count, 3);
-}
-
-void QueryBuilder_named_query(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>();
-
-    auto q = ecs.query_builder("my_query")
-        .term<Position>()
-        .build();
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e) {
-        test_assert(e == e1 || e == e2);
-        count ++;
-    });
-    test_int(count, 2);
-
-    flecs::entity qe = q.entity();
-    test_assert(qe != 0);
-    test_str(qe.name(), "my_query");
-}
-
-void QueryBuilder_term_w_write(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder()
-        .term<Position>()
-        .term<Position>().write()
-        .build();
-
-    auto f = q.filter();
-    test_assert(f.term(0).inout() == flecs::InOutDefault);
-    test_assert(f.term(0).get_src() == flecs::This);
-    test_assert(f.term(1).inout() == flecs::Out);
-    test_assert(f.term(1).get_src() == 0);
-}
-
-void QueryBuilder_term_w_read(void) {
-    flecs::world ecs;
-
-    auto q = ecs.query_builder()
-        .term<Position>()
-        .term<Position>().read()
-        .build();
-
-    auto f = q.filter();
-    test_assert(f.term(0).inout() == flecs::InOutDefault);
-    test_assert(f.term(0).get_src() == flecs::This);
-    test_assert(f.term(1).inout() == flecs::In);
-    test_assert(f.term(1).get_src() == 0);
-}
-
-void QueryBuilder_iter_w_stage(void) {
-    flecs::world ecs;
-
-    ecs.set_stage_count(2);
-    flecs::world stage = ecs.get_stage(1);
-
-    auto e1 = ecs.entity().add<Position>();
-
-    auto q = ecs.query<Position>();
-
-    int32_t count = 0;
-    q.each(stage, [&](flecs::iter& it, size_t i, Position&) {
-        test_assert(it.world() == stage);
-        test_assert(it.entity(i) == e1);
-        count ++;
-    });
-
-    test_int(count, 1);
-}
diff --git a/test/cpp_api/src/RuleBuilder.cpp b/test/cpp_api/src/RuleBuilder.cpp
deleted file mode 100644
index 4b7da4302..000000000
--- a/test/cpp_api/src/RuleBuilder.cpp
+++ /dev/null
@@ -1,869 +0,0 @@
-#include <cpp_api.h>
-
-void RuleBuilder_1_type(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity()
-        .set<Position>({10, 20});
-
-    ecs.entity().set<Velocity>({10, 20});
-
-    auto r = ecs.rule<Position>();
-
-    int count = 0;
-    r.each([&](flecs::entity e, Position& p) {
-        count ++;
-        test_assert(e == e1);
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_2_types(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity()
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 2});
-
-    ecs.entity().set<Velocity>({10, 20});
-
-    auto r = ecs.rule<Position, const Velocity>();
-
-    int count = 0;
-    r.each([&](flecs::entity e, Position& p, const Velocity& v) {
-        count ++;
-        test_assert(e == e1);
-        test_int(p.x, 10);
-        test_int(p.y, 20);
-
-        test_int(v.x, 1);
-        test_int(v.y, 2);
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_id_term(void) {
-    flecs::world ecs;
-
-    auto Tag = ecs.entity();
-
-    auto e1 = ecs.entity()
-        .add(Tag);
-
-    ecs.entity().set<Velocity>({10, 20});
-
-    auto r = ecs.rule_builder()
-        .term(Tag)
-        .build();
-
-    int count = 0;
-    r.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_type_term(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity()
-        .set<Position>({10, 20});
-
-    ecs.entity().set<Velocity>({10, 20});
-
-    auto r = ecs.rule_builder()
-        .term<Position>()
-        .build();
-
-    int count = 0;
-    r.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_id_pair_term(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    auto e1 = ecs.entity()
-        .add(Likes, Apples);
-
-    ecs.entity()
-        .add(Likes, Pears);
-
-    auto r = ecs.rule_builder()
-        .term(Likes, Apples)
-        .build();
-
-    int count = 0;
-    r.each([&](flecs::entity e) {
-        count ++;
-        test_assert(e == e1);
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_id_pair_wildcard_term(void) {
-    flecs::world ecs;
-
-    auto Likes = ecs.entity();
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    auto e1 = ecs.entity()
-        .add(Likes, Apples);
-
-    auto e2 = ecs.entity()
-        .add(Likes, Pears);
-
-    auto r = ecs.rule_builder()
-        .term(Likes, flecs::Wildcard)
-        .build();
-
-    int count = 0;
-    r.each([&](flecs::iter& it, size_t index) {
-        if (it.entity(index) == e1) {
-            test_assert(it.id(1) == ecs.pair(Likes, Apples));
-            count ++;
-        }
-        if (it.entity(index) == e2) {
-            test_assert(it.id(1) == ecs.pair(Likes, Pears));
-            count ++;
-        }
-    });
-    test_int(count, 2);
-
-    r.destruct();
-}
-
-void RuleBuilder_type_pair_term(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Apples { };
-    struct Pears { };
-
-    auto e1 = ecs.entity()
-        .add<Likes, Apples>();
-
-    auto e2 = ecs.entity()
-        .add<Likes, Pears>();
-
-    auto r = ecs.rule_builder()
-        .term<Likes>(flecs::Wildcard)
-        .build();
-
-    int count = 0;
-    r.each([&](flecs::iter& it, size_t index) {
-        if (it.entity(index) == e1) {
-            test_assert((it.id(1) == ecs.pair<Likes, Apples>()));
-            count ++;
-        }
-        if (it.entity(index) == e2) {
-            test_assert((it.id(1) == ecs.pair<Likes, Pears>()));
-            count ++;
-        }
-    });
-    test_int(count, 2);
-
-    r.destruct();
-}
-
-void RuleBuilder_pair_term_w_var(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Apples { };
-    struct Pears { };
-
-    auto e1 = ecs.entity()
-        .add<Likes, Apples>();
-
-    auto e2 = ecs.entity()
-        .add<Likes, Pears>();
-
-    auto r = ecs.rule_builder()
-        .term<Likes>().second().var("Food")
-        .build();
-
-    int food_var = r.find_var("Food");
-
-    int count = 0;
-    r.each([&](flecs::iter& it, size_t index) {
-        if (it.entity(index) == e1) {
-            test_assert((it.id(1) == ecs.pair<Likes, Apples>()));
-            test_assert(it.get_var("Food") == ecs.id<Apples>());
-            test_assert(it.get_var(food_var) == ecs.id<Apples>());
-            count ++;
-        }
-        if (it.entity(index) == e2) {
-            test_assert((it.id(1) == ecs.pair<Likes, Pears>()));
-            test_assert(it.get_var("Food") == ecs.id<Pears>());
-            test_assert(it.get_var(food_var) == ecs.id<Pears>());
-            count ++;
-        }
-    });
-    test_int(count, 2);
-
-    r.destruct();
-}
-
-void RuleBuilder_2_pair_terms_w_var(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Eats { };
-    struct Apples { };
-    struct Pears { };
-
-    auto Bob = ecs.entity()
-        .add<Eats, Apples>();
-
-    auto Alice = ecs.entity()
-        .add<Eats, Pears>()
-        .add<Likes>(Bob);
-
-    Bob.add<Likes>(Alice);
-
-    auto r = ecs.rule_builder()
-        .term<Eats>().second().var("Food")
-        .term<Likes>().second().var("Person")
-        .build();
-
-    int food_var = r.find_var("Food");
-    int person_var = r.find_var("Person");
-
-    int count = 0;
-    r.each([&](flecs::iter& it, size_t index) {
-        if (it.entity(index) == Bob) {
-            test_assert((it.id(1) == ecs.pair<Eats, Apples>()));
-            test_assert(it.get_var("Food") == ecs.id<Apples>());
-            test_assert(it.get_var(food_var) == ecs.id<Apples>());
-
-            test_assert((it.id(2) == ecs.pair<Likes>(Alice)));
-            test_assert(it.get_var("Person") == Alice);
-            test_assert(it.get_var(person_var) == Alice);
-            count ++;
-        }
-        if (it.entity(index) == Alice) {
-            test_assert((it.id(1) == ecs.pair<Eats, Pears>()));
-            test_assert(it.get_var("Food") == ecs.id<Pears>());
-            test_assert(it.get_var(food_var) == ecs.id<Pears>());
-
-            test_assert((it.id(2) == ecs.pair<Likes>(Bob)));
-            test_assert(it.get_var("Person") == Bob);
-            test_assert(it.get_var(person_var) == Bob);
-            count ++;
-        }
-    });
-    test_int(count, 2);
-
-    r.destruct();
-}
-
-void RuleBuilder_set_var(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    ecs.entity()
-        .add<Likes>(Apples);
-
-    auto e2 = ecs.entity()
-        .add<Likes>(Pears);
-
-    auto r = ecs.rule_builder()
-        .term<Likes>().second().var("Food")
-        .build();
-
-    int food_var = r.find_var("Food");
-
-    int count = 0;
-    r.iter()
-        .set_var(food_var, Pears)
-        .each([&](flecs::iter& it, size_t index) {
-            test_assert(it.entity(index) == e2);
-            test_assert((it.id(1) == ecs.pair<Likes>(Pears)));
-            test_assert(it.get_var("Food") == Pears);
-            test_assert(it.get_var(food_var) == Pears);
-            count ++;
-        });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_set_2_vars(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Eats { };
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    auto Bob = ecs.entity()
-        .add<Eats>(Apples);
-
-    auto Alice = ecs.entity()
-        .add<Eats>(Pears)
-        .add<Likes>(Bob);
-
-    Bob.add<Likes>(Alice);
-
-    auto r = ecs.rule_builder()
-        .term<Eats>().second().var("Food")
-        .term<Likes>().second().var("Person")
-        .build();
-
-    int food_var = r.find_var("Food");
-    int person_var = r.find_var("Person");
-
-    int count = 0;
-    r.iter()
-        .set_var(food_var, Pears)
-        .set_var(person_var, Bob)
-        .each([&](flecs::iter& it, size_t index) {
-            test_assert(it.entity(index) == Alice);
-            test_assert((it.id(1) == ecs.pair<Eats>(Pears)));
-            test_assert((it.id(2) == ecs.pair<Likes>(Bob)));
-            test_assert(it.get_var("Food") == Pears);
-            test_assert(it.get_var(food_var) == Pears);
-            test_assert(it.get_var("Person") == Bob);
-            test_assert(it.get_var(person_var) == Bob);
-            count ++;
-        });
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_set_var_by_name(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    ecs.entity()
-        .add<Likes>(Apples);
-
-    auto e2 = ecs.entity()
-        .add<Likes>(Pears);
-
-    auto r = ecs.rule_builder()
-        .term<Likes>().second().var("Food")
-        .build();
-
-    int count = 0;
-    r.iter()
-        .set_var("Food", Pears)
-        .each([&](flecs::iter& it, size_t index) {
-            test_assert(it.entity(index) == e2);
-            test_assert((it.id(1) == ecs.pair<Likes>(Pears)));
-            count ++;
-        });
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_set_2_vars_by_name(void) {
-    flecs::world ecs;
-
-    struct Likes { };
-    struct Eats { };
-    auto Apples = ecs.entity();
-    auto Pears = ecs.entity();
-
-    auto Bob = ecs.entity()
-        .add<Eats>(Apples);
-
-    auto Alice = ecs.entity()
-        .add<Eats>(Pears)
-        .add<Likes>(Bob);
-
-    Bob.add<Likes>(Alice);
-
-    auto r = ecs.rule_builder()
-        .term<Eats>().second().var("Food")
-        .term<Likes>().second().var("Person")
-        .build();
-
-    int food_var = r.find_var("Food");
-    int person_var = r.find_var("Person");
-
-    int count = 0;
-    r.iter()
-        .set_var("Food", Pears)
-        .set_var("Person", Bob)
-        .each([&](flecs::iter& it, size_t index) {
-            test_assert(it.entity(index) == Alice);
-            test_assert((it.id(1) == ecs.pair<Eats>(Pears)));
-            test_assert((it.id(2) == ecs.pair<Likes>(Bob)));
-            test_assert(it.get_var("Food") == Pears);
-            test_assert(it.get_var(food_var) == Pears);
-            test_assert(it.get_var("Person") == Bob);
-            test_assert(it.get_var(person_var) == Bob);
-            count ++;
-        });
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_expr_w_var(void) {
-    flecs::world ecs;
-
-    auto rel = ecs.entity("Rel");
-    auto obj = ecs.entity();
-    auto e = ecs.entity().add(rel, obj);
-
-    auto r = ecs.rule_builder()
-        .expr("(Rel, $X)")
-        .build();
-
-    int x_var = r.find_var("X");
-    test_assert(x_var != -1);
-
-    int32_t count = 0;
-    r.each([&](flecs::iter& it, size_t index) {
-        test_assert(it.entity(index) == e);
-        test_assert(it.pair(1).second() == obj);
-        count ++;
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_get_first(void) {
-    flecs::world ecs;
-
-    struct A {};
-
-    auto e1 = ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q = ecs.rule<A>();
-
-    auto first = q.iter().first();
-    test_assert(first != 0);
-    test_assert(first == e1);
-
-    q.destruct();
-}
-
-void RuleBuilder_get_count_direct(void) {
-    flecs::world ecs;
-
-    struct A {};
-
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q = ecs.rule<A>();
-
-    test_int(3, q.count());
-
-    q.destruct();
-}
-
-void RuleBuilder_get_is_true_direct(void) {
-    flecs::world ecs;
-
-    struct A {};
-    struct B {};
-
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q_1 = ecs.rule<A>();
-    auto q_2 = ecs.rule<B>();
-
-    test_bool(true, q_1.is_true());
-    test_bool(false, q_2.is_true());
-
-    q_1.destruct();
-    q_2.destruct();
-}
-
-void RuleBuilder_get_first_direct(void) {
-    flecs::world ecs;
-
-    struct A {};
-
-    auto e1 = ecs.entity().add<A>();
-    ecs.entity().add<A>();
-    ecs.entity().add<A>();
-
-    auto q = ecs.rule<A>();
-
-    auto first = q.first();
-    test_assert(first != 0);
-    test_assert(first == e1);
-
-    q.destruct();
-}
-
-void RuleBuilder_var_src_w_prefixed_name(void) {
-    flecs::world ecs;
-
-    struct Foo { };
-
-    auto r = ecs.rule_builder()
-        .term<Foo>().src("$Var")
-        .build();
-
-    auto e = ecs.entity().add<Foo>();
-
-    int32_t count = 0;
-    r.iter([&](flecs::iter& it) {
-        test_assert(it.get_var("Var") == e);
-        count ++;
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_var_first_w_prefixed_name(void) {
-    flecs::world ecs;
-
-    struct Foo { };
-
-    auto r = ecs.rule_builder()
-        .term<Foo>()
-        .term().first("$Var")
-        .build();
-
-    auto e = ecs.entity().add<Foo>();
-
-    int32_t count = 0;
-    r.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-        test_uint(it.entity(0), e);
-        test_assert(it.get_var("Var") == ecs.id<Foo>());
-        count ++;
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_var_second_w_prefixed_name(void) {
-    flecs::world ecs;
-
-    struct Foo { };
-
-    auto r = ecs.rule_builder()
-        .term<Foo>().second("$Var")
-        .build();
-
-    auto t = ecs.entity();
-    auto e = ecs.entity().add<Foo>(t);
-
-    int32_t count = 0;
-    r.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-        test_uint(it.entity(0), e);
-        test_assert(it.get_var("Var") == t);
-        count ++;
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_term_w_second_var_string(void) {
-    flecs::world ecs;
-
-    flecs::entity Foo = ecs.entity();
-
-    auto r = ecs.rule_builder()
-        .term(Foo, "$Var")
-        .build();
-
-    auto t = ecs.entity();
-    auto e = ecs.entity().add(Foo, t);
-
-    int32_t count = 0;
-    r.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-        test_uint(it.entity(0), e);
-        test_assert(it.get_var("Var") == t);
-        count ++;
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_term_type_w_second_var_string(void) {
-    flecs::world ecs;
-
-    struct Foo { };
-
-    auto r = ecs.rule_builder()
-        .term<Foo>("$Var")
-        .build();
-
-    auto t = ecs.entity();
-    auto e = ecs.entity().add<Foo>(t);
-
-    int32_t count = 0;
-    r.iter([&](flecs::iter& it) {
-        test_int(it.count(), 1);
-        test_uint(it.entity(0), e);
-        test_assert(it.get_var("Var") == t);
-        count ++;
-    });
-
-    test_int(count, 1);
-
-    r.destruct();
-}
-
-void RuleBuilder_named_rule(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>();
-
-    auto q = ecs.rule<Position>("my_query");
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position&) {
-        test_assert(e == e1 || e == e2);
-        count ++;
-    });
-    test_int(count, 2);
-
-    flecs::entity qe = q.entity();
-    test_assert(qe != 0);
-    test_str(qe.name(), "my_query");
-
-    q.destruct();
-}
-
-void RuleBuilder_named_scoped_rule(void) {
-    flecs::world ecs;
-
-    auto e1 = ecs.entity().add<Position>();
-    auto e2 = ecs.entity().add<Position>();
-
-    auto q = ecs.rule<Position>("my::query");
-
-    int32_t count = 0;
-    q.each([&](flecs::entity e, Position&) {
-        test_assert(e == e1 || e == e2);
-        count ++;
-    });
-    test_int(count, 2);
-
-    flecs::entity qe = q.entity();
-    test_assert(qe != 0);
-    test_str(qe.name(), "query");
-    test_str(qe.path(), "::my::query");
-
-    q.destruct();
-}
-
-void RuleBuilder_is_valid(void) {
-    flecs::world ecs;
-
-    auto q_1 = ecs.rule<Position>();
-    test_assert(q_1.is_valid());
-
-    flecs::log::set_level(-4);
-    auto q_2 = ecs.rule_builder().expr("foo").build();
-    test_assert(!q_2.is_valid());
-
-    q_1.destruct();
-}
-
-void RuleBuilder_unresolved_by_name(void) {
-    flecs::world ecs;
-
-    auto q = ecs.rule_builder()
-        .filter_flags(EcsFilterUnresolvedByName)
-        .expr("$this == Foo")
-        .build();
-
-    test_assert(q.is_valid());
-
-    test_false(q.iter().is_true());
-
-    ecs.entity("Foo");
-
-    test_true(q.iter().is_true());
-
-    q.destruct();
-}
-
-void RuleBuilder_scope(void) {
-    flecs::world ecs;
-
-    flecs::entity Root = ecs.entity();
-    flecs::entity TagA = ecs.entity();
-    flecs::entity TagB = ecs.entity();
-
-    ecs.entity()
-        .add(Root)
-        .add(TagA)
-        .add(TagB);
-
-    auto e2 = ecs.entity()
-        .add(Root)
-        .add(TagA);
-
-    ecs.entity()
-        .add(Root)
-        .add(TagB);
-
-    ecs.entity()
-        .add(Root);
-
-    auto r = ecs.rule_builder()
-        .with(Root)
-        .scope_open().not_()
-            .with(TagA)
-            .without(TagB)
-        .scope_close()
-        .build();
-
-    int32_t count = 0;
-    r.each([&](flecs::entity e) {
-        test_assert(e != e2);
-        count ++;
-    });
-
-    test_int(count, 3);
-
-    r.destruct();
-}
-
-void RuleBuilder_iter_w_stage(void) {
-    flecs::world ecs;
-
-    ecs.set_stage_count(2);
-    flecs::world stage = ecs.get_stage(1);
-
-    auto e1 = ecs.entity().add<Position>();
-
-    auto q = ecs.rule<Position>();
-
-    int32_t count = 0;
-    q.each(stage, [&](flecs::iter& it, size_t i, Position&) {
-        test_assert(it.world() == stage);
-        test_assert(it.entity(i) == e1);
-        count ++;
-    });
-
-    test_int(count, 1);
-
-    q.destruct();
-}
-
-void RuleBuilder_inspect_terms_w_expr(void) {
-    flecs::world ecs;
-
-    flecs::rule<> f = ecs.rule_builder()
-        .expr("(ChildOf,0)")
-        .build();
-
-    int32_t count = 0;
-    f.each_term([&](flecs::term &term) {
-        test_assert(term.id().is_pair());
-        count ++;
-    });
-
-    test_int(count, 1);
-
-    f.destruct();
-}
-
-void RuleBuilder_find(void) {
-    flecs::world ecs;
-
-    /* auto e1 = */ ecs.entity().set<Position>({10, 20});
-    auto e2 = ecs.entity().set<Position>({20, 30});
-
-    auto q = ecs.rule<Position>();
-
-    auto r = q.find([](Position& p) {
-        return p.x == 20;
-    });
-
-    test_assert(r == e2);
-
-    q.destruct();
-}
-
-void RuleBuilder_find_not_found(void) {
-    flecs::world ecs;
-
-    /* auto e1 = */ ecs.entity().set<Position>({10, 20});
-    /* auto e2 = */ ecs.entity().set<Position>({20, 30});
-
-    auto q = ecs.rule<Position>();
-
-    auto r = q.find([](Position& p) {
-        return p.x == 30;
-    });
-
-    test_assert(!r);
-
-    q.destruct();
-}
-
-void RuleBuilder_find_w_entity(void) {
-    flecs::world ecs;
-
-    /* auto e1 = */ ecs.entity().set<Position>({10, 20}).set<Velocity>({20, 30});
-    auto e2 = ecs.entity().set<Position>({20, 30}).set<Velocity>({20, 30});
-
-    auto q = ecs.rule<Position>();
-
-    auto r = q.find([](flecs::entity e, Position& p) {
-        return p.x == e.get<Velocity>()->x &&
-               p.y == e.get<Velocity>()->y;
-    });
-
-    test_assert(r == e2);
-
-    q.destruct();
-}
diff --git a/test/cpp_api/src/Snapshot.cpp b/test/cpp_api/src/Snapshot.cpp
deleted file mode 100644
index 189221094..000000000
--- a/test/cpp_api/src/Snapshot.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include <cpp_api.h>
-
-void Snapshot_simple_snapshot(void) {
-    flecs::world world;
-
-    auto e = flecs::entity(world)
-        .set<Position>({10, 20})
-        .set<Velocity>({1, 1});
-
-    flecs::snapshot s(world);
-    s.take();
-
-    e.set<Position>({30, 40});
-    e.set<Velocity>({2, 2});
-    
-    s.restore();
-
-    const Position *p = e.get<Position>();
-    const Velocity *v = e.get<Velocity>();
-
-    test_assert(p != NULL);
-    test_assert(v != NULL);
-
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    test_int(v->x, 1);
-    test_int(v->y, 1);
-}
diff --git a/test/cpp_api/src/Switch.cpp b/test/cpp_api/src/Switch.cpp
deleted file mode 100644
index aa7cf33b4..000000000
--- a/test/cpp_api/src/Switch.cpp
+++ /dev/null
@@ -1,257 +0,0 @@
-#include <cpp_api.h>
-
-void Switch_add_case(void) {
-    flecs::world world;
-
-    auto Standing = world.entity("Standing");
-    auto Walking = world.entity("Walking");
-    auto Movement = world.entity().add(flecs::Union);
-
-    auto e = world.entity()
-        .add(Movement, Standing);
-    test_assert(e.has(Movement, Standing));
-
-    auto table = e.table();
-
-    e.add(Movement, Walking);
-    test_assert(e.table() == table);
-
-    test_assert(e.has(Movement, Walking));
-    test_assert(!e.has(Movement, Standing));
-}
-
-void Switch_get_case(void) {
-    flecs::world world;
-
-    auto Standing = world.entity("Standing");
-    world.entity("Walking");
-    auto Movement = world.entity().add(flecs::Union);
-
-    auto e = world.entity()
-        .add(Movement, Standing);
-    test_assert(e.has(Movement, Standing));
-
-    test_assert(e.target(Movement) == Standing);
-}
-
-void Switch_system_w_case(void) {
-    flecs::world world;
-
-    auto Standing = world.entity("Standing");
-    auto Walking = world.entity("Walking");
-    auto Movement = world.entity("Movement").add(flecs::Union);
-
-    world.entity().add(Movement, Walking);
-    world.entity().add(Movement, Walking);
-    world.entity().add(Movement, Standing);
-
-    int count = 0, invoke_count = 0;  
-    world.system()
-        .expr("(Movement, Walking)")
-        .iter([&](flecs::iter it) {
-            auto movement = it.field<flecs::entity_t>(1);
-
-            invoke_count ++;
-            for (auto i : it) {
-                test_assert(movement[i] == Walking.id());
-                count ++;
-            }
-        });
-
-    world.progress();
-
-    test_int(invoke_count, 2);
-    test_int(count, 2);
-}
-
-void Switch_system_w_case_builder(void) {
-    flecs::world world;
-
-    auto Standing = world.entity("Standing");
-    auto Walking = world.entity("Walking");
-    auto Movement = world.entity().add(flecs::Union);
-
-    world.entity().add(Movement, Walking);
-    world.entity().add(Movement, Walking);
-    world.entity().add(Movement, Standing);
-
-    int count = 0, invoke_count = 0;  
-    world.system()
-        .term(Movement, Walking)
-        .iter([&](flecs::iter it) {
-            auto movement = it.field<flecs::entity_t>(1);
-
-            invoke_count ++;
-            for (auto i : it) {
-                test_assert(movement[i] == Walking.id());
-                count ++;
-            }
-        });
-
-    world.progress();
-
-    test_int(invoke_count, 2);
-    test_int(count, 2);
-}
-
-void Switch_system_w_switch(void) {
-    flecs::world world;
-
-    auto Standing = world.entity("Standing");
-    auto Walking = world.entity("Walking");
-    auto Movement = world.entity("Movement").add(flecs::Union);
-
-    auto e1 = world.entity().add(Movement, Walking);
-    auto e2 = world.entity().add(Movement, Walking);
-    auto e3 = world.entity().add(Movement, Standing);
-
-    int count = 0, invoke_count = 0;  
-    world.system()
-        .expr("(Movement, *)")
-        .iter([&](flecs::iter it) {
-            flecs::field<flecs::entity_t> movement(it, 1);
-
-            invoke_count ++;
-            for (auto i : it) {
-                if (it.entity(i) == e1 || it.entity(i) == e2) {
-                    test_int(movement[i], Walking.id());
-                } else if (it.entity(i) == e3) {
-                    test_int(movement[i], Standing.id());   
-                }
-                count ++;
-            }
-        });
-
-    world.progress();
-
-    test_int(invoke_count, 1);
-    test_int(count, 3);
-}
-
-struct Movement { };
-struct Standing { };
-struct Walking { };
-
-void Switch_system_w_sw_type_builder(void) {
-    flecs::world world;
-
-    world.component<Movement>().add(flecs::Union);
-
-    world.entity().add<Movement, Walking>();
-    world.entity().add<Movement, Walking>();
-    world.entity().add<Movement, Standing>();
-
-    int count = 0, invoke_count = 0;  
-    world.system<>()
-        .term<Movement, Walking>()
-        .iter([&](flecs::iter it) {
-            auto movement = it.field<flecs::entity_t>(1);
-
-            invoke_count ++;
-            for (auto i : it) {
-                test_assert(movement[i] == world.id<Walking>());
-                count ++;
-            }
-        });
-
-    world.progress();
-
-    test_int(invoke_count, 2);
-    test_int(count, 2);
-}
-
-void Switch_add_case_w_type(void) {
-    flecs::world world;
-
-    world.component<Movement>().add(flecs::Union);
-
-    auto e = world.entity().add<Movement, Standing>();
-    test_assert((e.has<Movement, Standing>()));
-
-    e.add<Movement, Walking>();
-
-    test_assert((e.has<Movement, Walking>()));
-    test_assert((!e.has<Movement, Standing>()));
-}
-
-void Switch_add_switch_w_type(void) {
-    flecs::world world;
-
-    world.component<Movement>().add(flecs::Union);
-
-    auto e = world.entity().add<Movement, Standing>();
-    test_assert((e.has<Movement, Standing>()));
-
-    e.add<Movement, Walking>();
-
-    test_assert((e.has<Movement, Walking>()));
-    test_assert((!e.has<Movement, Standing>()));
-}
-
-void Switch_add_remove_switch_w_type(void) {
-    flecs::world world;
-
-    world.component<Movement>().add(flecs::Union);
-
-    auto e = world.entity().add<Movement, Standing>();
-    test_assert(e.has<Movement>(flecs::Wildcard));
-    test_assert((e.has<Movement, Standing>()));
-
-    auto table = e.table();
-
-    e.add<Movement, Walking>();
-
-    test_assert((e.has<Movement, Walking>()));
-    test_assert((!e.has<Movement, Standing>()));
-    test_assert(e.table() == table);
-
-    auto c = e.target<Movement>();
-    test_assert(c != 0);
-    test_assert(c == world.id<Walking>());
-
-    e.remove<Movement>(flecs::Wildcard);
-    test_assert(!e.has<Movement>(flecs::Wildcard));
-    test_assert((!e.has<Movement, Walking>()));
-    test_assert(e.table() != table);
-}
-
-enum Color {
-    Red,
-    Green,
-    Blue
-};
-
-void Switch_switch_enum_type(void) {
-    flecs::world world;
-
-    world.component<Color>().add(flecs::Union);
-
-    auto e = world.entity().add(Red);
-    test_assert(e.has(Red));
-    test_assert(!e.has(Green));
-    test_assert(!e.has(Blue));
-    test_assert(e.has<Color>(flecs::Wildcard));
-
-    auto table = e.table();
-
-    e.add(Green);
-    test_assert(!e.has(Red));
-    test_assert(e.has(Green));
-    test_assert(!e.has(Blue));
-    test_assert(e.has<Color>(flecs::Wildcard));
-    test_assert(e.table() == table);
-
-    e.add(Blue);
-    test_assert(!e.has(Red));
-    test_assert(!e.has(Green));
-    test_assert(e.has(Blue));
-    test_assert(e.has<Color>(flecs::Wildcard));
-    test_assert(e.table() == table);
-
-    e.remove<Color>();
-    test_assert(!e.has(Red));
-    test_assert(!e.has(Green));
-    test_assert(!e.has(Blue));
-    test_assert(!e.has<Color>(flecs::Wildcard));
-    test_assert(e.table() != table);
-}
diff --git a/test/custom_builds/c/meta_c/include/meta_c/bake_config.h b/test/custom_builds/c/meta_c/include/meta_c/bake_config.h
deleted file mode 100644
index 87840d4c7..000000000
--- a/test/custom_builds/c/meta_c/include/meta_c/bake_config.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef META_C_BAKE_CONFIG_H
-#define META_C_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include "../../deps/flecs.h"
-
-#endif
-
diff --git a/test/custom_builds/c/meta_c/project.json b/test/custom_builds/c/meta_c/project.json
deleted file mode 100644
index f860cf273..000000000
--- a/test/custom_builds/c/meta_c/project.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-    "id": "meta_c",
-    "type": "application",
-    "value": {
-        "public": false,
-        "use": [
-            "flecs"
-        ],
-        "standalone": true
-    },
-    "lang.c": {
-        "defines": ["FLECS_CUSTOM_BUILD", "FLECS_META_C"]
-    }
-}
\ No newline at end of file
diff --git a/test/custom_builds/c/meta_c/src/main.c b/test/custom_builds/c/meta_c/src/main.c
deleted file mode 100644
index 6595fe530..000000000
--- a/test/custom_builds/c/meta_c/src/main.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <meta_c.h>
-
-ECS_STRUCT(Position, {
-    float x;
-    float y;
-});
-
-int main(int argc, char *argv[]) {
-    ecs_world_t *world = ecs_init_w_args(argc, argv);
-
-    ECS_META_COMPONENT(world, Position);
-
-    return ecs_fini(world);
-}
diff --git a/test/custom_builds/c/pipeline/src/main.c b/test/custom_builds/c/pipeline/src/main.c
index efd22b4d3..47dab3dbd 100644
--- a/test/custom_builds/c/pipeline/src/main.c
+++ b/test/custom_builds/c/pipeline/src/main.c
@@ -5,8 +5,8 @@ typedef struct {
 } Position, Velocity;
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i ++) {
         p[i].x += v[i].x;
@@ -21,13 +21,13 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, {.add = { ecs_dependson(EcsOnUpdate) }}),
-        .query.filter.terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }},
+        .entity = ecs_entity(world, {.add = ecs_ids( ecs_dependson(EcsOnUpdate) )}),
+        .query.terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }},
         .callback = Move
     });
     assert(s != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {10, 20});
     ecs_set(world, e, Velocity, {1, 2});
 
diff --git a/test/custom_builds/c/pipeline_w_system/src/main.c b/test/custom_builds/c/pipeline_w_system/src/main.c
index 10c351ac6..fa0320cfb 100644
--- a/test/custom_builds/c/pipeline_w_system/src/main.c
+++ b/test/custom_builds/c/pipeline_w_system/src/main.c
@@ -5,8 +5,8 @@ typedef struct {
 } Position, Velocity;
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i ++) {
         p[i].x += v[i].x;
@@ -21,13 +21,13 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .entity = ecs_entity(world, { .add = {ecs_dependson(EcsOnUpdate)} }),
-        .query.filter.terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }},
+        .entity = ecs_entity(world, { .add = ecs_ids(ecs_dependson(EcsOnUpdate)) }),
+        .query.terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }},
         .callback = Move
     });
     assert(s != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {10, 20});
     ecs_set(world, e, Velocity, {1, 2});
 
diff --git a/test/custom_builds/c/plecs/project.json b/test/custom_builds/c/plecs/project.json
index 5148e5019..7da9c8965 100644
--- a/test/custom_builds/c/plecs/project.json
+++ b/test/custom_builds/c/plecs/project.json
@@ -9,6 +9,6 @@
         "standalone": true
     },
     "lang.c": {
-        "defines": ["FLECS_CUSTOM_BUILD", "FLECS_PLECS"]
+        "defines": ["FLECS_CUSTOM_BUILD", "FLECS_SCRIPT"]
     }
 }
\ No newline at end of file
diff --git a/test/custom_builds/c/plecs/src/main.c b/test/custom_builds/c/plecs/src/main.c
index 35823ff1f..0b8fdc66d 100644
--- a/test/custom_builds/c/plecs/src/main.c
+++ b/test/custom_builds/c/plecs/src/main.c
@@ -3,7 +3,7 @@
 int main(int argc, char *argv[]) {
     ecs_world_t *world = ecs_init_w_args(argc, argv);
 
-    int ret = ecs_plecs_from_str(world, NULL, "Foo");
+    int ret = ecs_script_run(world, NULL, "Foo {}");
     assert(ret == 0);
     (void)ret;
 
diff --git a/test/custom_builds/c/plecs_w_parser/include/plecs_w_parser.h b/test/custom_builds/c/plecs_w_parser/include/plecs_w_parser.h
deleted file mode 100644
index 3176d99bd..000000000
--- a/test/custom_builds/c/plecs_w_parser/include/plecs_w_parser.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef PLECS_W_PARSER_H
-#define PLECS_W_PARSER_H
-
-/* This generated file contains includes for project dependencies */
-#include "plecs_w_parser/bake_config.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
diff --git a/test/custom_builds/c/plecs_w_parser/include/plecs_w_parser/bake_config.h b/test/custom_builds/c/plecs_w_parser/include/plecs_w_parser/bake_config.h
deleted file mode 100644
index 92e93f177..000000000
--- a/test/custom_builds/c/plecs_w_parser/include/plecs_w_parser/bake_config.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef PLECS_W_PARSER_BAKE_CONFIG_H
-#define PLECS_W_PARSER_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include "../../deps/flecs.h"
-
-#endif
-
diff --git a/test/custom_builds/c/plecs_w_parser/project.json b/test/custom_builds/c/plecs_w_parser/project.json
deleted file mode 100644
index 963427d09..000000000
--- a/test/custom_builds/c/plecs_w_parser/project.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-    "id": "plecs_w_parser",
-    "type": "application",
-    "value": {
-        "public": false,
-        "use": [
-            "flecs"
-        ],
-        "standalone": true
-    },
-    "lang.c": {
-        "defines": ["FLECS_CUSTOM_BUILD", "FLECS_PLECS", "FLECS_PARSER"]
-    }
-}
diff --git a/test/custom_builds/c/plecs_w_parser/src/main.c b/test/custom_builds/c/plecs_w_parser/src/main.c
deleted file mode 100644
index 382b8af02..000000000
--- a/test/custom_builds/c/plecs_w_parser/src/main.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <plecs_w_parser.h>
-
-int main(int argc, char *argv[]) {
-    ecs_world_t *world = ecs_init_w_args(argc, argv);
-
-    int ret = ecs_plecs_from_str(world, NULL, "Foo");
-    assert(ret == 0);
-    (void)ret;
-
-    ecs_fini(world);
-}
diff --git a/test/custom_builds/c/rest/src/main.c b/test/custom_builds/c/rest/src/main.c
index de33f0182..9d4d09c57 100644
--- a/test/custom_builds/c/rest/src/main.c
+++ b/test/custom_builds/c/rest/src/main.c
@@ -3,7 +3,7 @@
 int main(int argc, char *argv[]) {
     ecs_world_t *world = ecs_init_w_args(argc, argv);
 
-    ecs_set(world, 0, EcsRest, {0});
+    ecs_insert(world, ecs_value(EcsRest, {0}));
 
     return ecs_fini(world);
 }
diff --git a/test/custom_builds/c/system/src/main.c b/test/custom_builds/c/system/src/main.c
index a9c8585cb..173b0e93b 100644
--- a/test/custom_builds/c/system/src/main.c
+++ b/test/custom_builds/c/system/src/main.c
@@ -5,8 +5,8 @@ typedef struct {
 } Position, Velocity;
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i ++) {
         p[i].x += v[i].x;
@@ -21,12 +21,12 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .query.filter.terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }},
+        .query.terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }},
         .callback = Move,
     });
     assert(s != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {10, 20});
     ecs_set(world, e, Velocity, {1, 2});
 
diff --git a/test/custom_builds/c/timer/src/main.c b/test/custom_builds/c/timer/src/main.c
index 7a202626e..93804df1b 100644
--- a/test/custom_builds/c/timer/src/main.c
+++ b/test/custom_builds/c/timer/src/main.c
@@ -5,8 +5,8 @@ typedef struct {
 } Position, Velocity;
 
 void Move(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
-    Velocity *v = ecs_field(it, Velocity, 2);
+    Position *p = ecs_field(it, Position, 0);
+    Velocity *v = ecs_field(it, Velocity, 1);
 
     for (int i = 0; i < it->count; i ++) {
         p[i].x += v[i].x;
@@ -21,9 +21,9 @@ int main(int argc, char *argv[]) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
-        .query.filter.terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }},
+        .query.terms = {{ .id = ecs_id(Position) }, { .id = ecs_id(Velocity) }},
         .callback = Move,
-        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
+        .entity = ecs_entity(world, {.add = ecs_ids(ecs_dependson(EcsOnUpdate))}),
         .interval = 2.9f
     });
     assert(s != 0);
@@ -31,7 +31,7 @@ int main(int argc, char *argv[]) {
     EcsTimer *timer = ecs_ensure(world, s, EcsTimer);
     timer->time = 0;
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_set(world, e, Position, {10, 20});
     ecs_set(world, e, Velocity, {1, 2});
 
diff --git a/test/custom_builds/cpp/no_auto_registration/project.json b/test/custom_builds/cpp/no_auto_registration/project.json
index ec48ad341..c9920a526 100644
--- a/test/custom_builds/cpp/no_auto_registration/project.json
+++ b/test/custom_builds/cpp/no_auto_registration/project.json
@@ -12,4 +12,4 @@
     "lang.cpp": {
         "defines": ["FLECS_CPP_NO_AUTO_REGISTRATION"]
     }
-}
\ No newline at end of file
+}
diff --git a/test/custom_builds/cpp/no_auto_registration/src/main.cpp b/test/custom_builds/cpp/no_auto_registration/src/main.cpp
index 00095a152..3cf810a4b 100644
--- a/test/custom_builds/cpp/no_auto_registration/src/main.cpp
+++ b/test/custom_builds/cpp/no_auto_registration/src/main.cpp
@@ -13,9 +13,7 @@ int main(int, char *[]) {
     // core
     world.id<flecs::Component>();
     world.id<flecs::Identifier>();
-    world.id<flecs::Iterable>();
     world.id<flecs::Poly>();
-    world.id<flecs::FlattenTarget>();
 
     // alerts
     world.id<flecs::alerts::AlertsActive>();
@@ -63,8 +61,8 @@ int main(int, char *[]) {
     world.id<flecs::enum_constant_t>();
     world.id<flecs::bitmask_constant_t>();
 
-    world.id<flecs::MetaType>();
-    world.id<flecs::MetaTypeSerialized>();
+    world.id<flecs::Type>();
+    world.id<flecs::TypeSerializer>();
     world.id<flecs::Primitive>();
     world.id<flecs::Enum>();
     world.id<flecs::Bitmask>();
diff --git a/test/custom_builds/cpp/pipeline_no_timer/project.json b/test/custom_builds/cpp/pipeline_no_timer/project.json
index 0b3dda086..3a456c938 100644
--- a/test/custom_builds/cpp/pipeline_no_timer/project.json
+++ b/test/custom_builds/cpp/pipeline_no_timer/project.json
@@ -17,8 +17,6 @@
             "FLECS_MODULE", 
             "FLECS_SYSTEM",
             "FLECS_PIPELINE", 
-            "FLECS_EXPR", 
-            "FLECS_PARSER", 
             "FLECS_LOG"
         ]
     }
diff --git a/test/custom_builds/cpp/snapshot/include/snapshot/bake_config.h b/test/custom_builds/cpp/snapshot/include/snapshot/bake_config.h
deleted file mode 100644
index 9e10624d8..000000000
--- a/test/custom_builds/cpp/snapshot/include/snapshot/bake_config.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-                                   )
-                                  (.)
-                                  .|.
-                                  | |
-                              _.--| |--._
-                           .-';  ;`-'& ; `&.
-                          \   &  ;    &   &_/
-                           |"""---...---"""|
-                           \ | | | | | | | /
-                            `---.|.|.|.---'
-
- * This file is generated by bake.lang.c for your convenience. Headers of
- * dependencies will automatically show up in this file. Include bake_config.h
- * in your main project file. Do not edit! */
-
-#ifndef SNAPSHOT_BAKE_CONFIG_H
-#define SNAPSHOT_BAKE_CONFIG_H
-
-/* Headers of public dependencies */
-#include "../../deps/flecs.h"
-
-#endif
-
diff --git a/test/custom_builds/cpp/snapshot/project.json b/test/custom_builds/cpp/snapshot/project.json
deleted file mode 100644
index b4929f232..000000000
--- a/test/custom_builds/cpp/snapshot/project.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-    "id": "snapshot",
-    "type": "application",
-    "value": {
-        "use": [
-            "flecs"
-        ],
-        "public": false,
-        "standalone": true,
-        "language": "c++"
-    },
-    "lang.cpp": {
-        "defines": ["FLECS_CUSTOM_BUILD", "FLECS_CPP", "FLECS_SNAPSHOT"]
-    }
-}
diff --git a/test/custom_builds/cpp/snapshot/src/main.cpp b/test/custom_builds/cpp/snapshot/src/main.cpp
deleted file mode 100644
index 5a0332969..000000000
--- a/test/custom_builds/cpp/snapshot/src/main.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <snapshot.h>
-#include <iostream>
-
-int main(int, char *[]) {
-    flecs::world world;
-
-    auto s = world.snapshot();
-
-    s.restore();
-}
diff --git a/test/meta/project.json b/test/meta/project.json
index 8b4ee0935..166c34ebb 100644
--- a/test/meta/project.json
+++ b/test/meta/project.json
@@ -423,126 +423,6 @@
                 "set_out_of_bounds",
                 "get_member_id"
             ]
-        }, {
-            "id": "DeserializeFromExpr",
-            "testcases": [
-                "bool",
-                "byte",
-                "char",
-                "char_literal",
-                "i8",
-                "i16",
-                "i32",
-                "i64",
-                "iptr",
-                "u8",
-                "u16",
-                "u32",
-                "u64",
-                "uptr",
-                "float",
-                "double",
-                "negative_int",
-                "negative_float",
-                "string",
-                "entity",
-                "id",
-                "enum",
-                "bitmask",
-                "struct_enum",
-                "struct_bitmask",
-                "struct_i32",
-                "struct_i32_neg",
-                "struct_i32_i32",
-                "struct_entity",
-                "struct_id",
-                "struct_nested_i32",
-                "struct_nested_i32_i32",
-                "struct_2_nested_i32_i32",
-                "struct_member_i32",
-                "struct_member_i32_neg",
-                "struct_member_i32_i32",
-                "struct_member_nested_i32",
-                "struct_member_nested_i32_i32",
-                "struct_member_2_nested_i32_i32",
-                "struct_member_2_nested_i32_i32_reverse",
-                "struct_i32_array_3",
-                "struct_struct_i32_array_3",
-                "struct_struct_i32_i32_array_3",
-                "struct_w_array_type_i32_i32",
-                "struct_w_array_type_struct",
-                "struct_w_2_array_type_i32_i32",
-                "struct_w_2_array_type_struct",
-                "discover_type_int",
-                "discover_type_negative_int",
-                "discover_type_float",
-                "discover_type_negative_float",
-                "discover_type_string",
-                "discover_type_multiline_string",
-                "discover_type_entity",
-                "discover_type_bool",
-                "discover_type_unknown",
-                "discover_type_invalid"
-            ]
-        }, {
-            "id": "SerializeToExpr",
-            "testcases": [
-                "bool",
-                "byte",
-                "char",
-                "i8",
-                "i16",
-                "i32",
-                "i64",
-                "iptr",
-                "u8",
-                "u16",
-                "u32",
-                "u64",
-                "uptr",
-                "float",
-                "double",
-                "string",
-                "entity",
-                "entity_10k",
-                "id",
-                "enum",
-                "bitmask",
-                "float_nan",
-                "float_inf",
-                "double_nan",
-                "double_inf",
-                "struct_enum",
-                "struct_bitmask",
-                "struct_i32",
-                "struct_i32_i32",
-                "struct_entity",
-                "struct_id",
-                "array_i32_3",
-                "array_struct_i32_i32",
-                "array_array_i32_3",
-                "vector_i32_3",
-                "vector_struct_i32_i32",
-                "vector_array_i32_3",
-                "entity_entity_after_float",
-                "struct_nested_i32",
-                "struct_nested_i32_i32",
-                "struct_2_nested_i32_i32",
-                "struct_i32_array_3",
-                "struct_struct_i32_array_3",
-                "struct_struct_i32_i32_array_3",
-                "struct_w_array_type_i32_i32",
-                "struct_w_array_type_struct",
-                "struct_w_2_array_type_i32_i32",
-                "struct_w_2_array_type_struct",
-                "struct_partial",
-                "escape_simple_string",
-                "escape_newline",
-                "escape_2_newlines",
-                "escape_string_w_trailing_newline",
-                "escape_string_w_2_trailing_newlines",
-                "escape_string_w_delim"
-            ]
         }, {
             "id": "DeserializeFromJson",
             "testcases": [
@@ -757,12 +637,6 @@
                 "serialize_w_link_no_link",
                 "serialize_color",
                 "serialize_w_doc_w_quotes",
-                "serialize_union_relationship",
-                "serialize_union_relationship_w_labels",
-                "serialize_union_relationship_invalid_entity",
-                "serialize_union_relationship_invalid_entity_w_labels",
-                "serialize_w_union_property",
-                "serialize_w_union_property",
                 "serialize_from_core",
                 "serialize_w_1_alert",
                 "serialize_w_2_alerts",
@@ -1015,155 +889,6 @@
                 "enum_constant_w_type_prefix",
                 "enum_constant_w_name_type_prefix"
             ]
-        }, {
-            "id": "Vars",
-            "testcases": [
-                "declare_1_var",
-                "declare_2_vars",
-                "declare_vars_nested_scope",
-                "declare_vars_2_scopes",
-                "redeclare_var",
-                "i32_expr_w_i32_var",
-                "i32_expr_w_f32_var",
-                "i32_expr_w_string_var",
-                "string_expr_w_string_var",
-                "struct_expr_w_i32_vars",
-                "struct_expr_w_struct_var",
-                "nested_struct_expr_w_struct_var",
-                "declare_w_value",
-                "redeclare_in_scope",
-                "init_fini_vars"
-            ]
-        }, {
-            "id": "DeserExprOperators",
-            "testcases": [
-                "add_2_int_literals",
-                "add_2_int_literals_twice",
-                "sub_2_int_literals",
-                "mul_2_int_literals",
-                "div_2_int_literals",
-                "add_3_int_literals",
-                "add_3_int_literals_twice",
-                "sub_3_int_literals",
-                "mul_3_int_literals",
-                "div_3_int_literals",
-                "int_to_bool",
-                "bool_to_int",
-                "bool_to_uint",
-                "add_mul_3_int_literals",
-                "sub_mul_3_int_literals",
-                "div_mul_3_int_literals",
-                "add_div_3_int_literals",
-                "sub_div_3_int_literals",
-                "mul_div_3_int_literals",
-                "mul_add_mul_add_int_literals",
-                "mul_sub_mul_sub_int_literals",
-                "mul_div_mul_div_int_literals",
-                "div_add_div_add_int_literals",
-                "div_sub_div_sub_int_literals",
-                "div_sub_div_mul_int_literals",
-                "div_mul_div_mul_int_literals",
-                "add_2_flt_literals",
-                "sub_2_flt_literals",
-                "mul_2_flt_literals",
-                "div_2_flt_literals",
-                "add_2_int_neg_literals",
-                "sub_2_int_neg_literals",
-                "mul_2_int_neg_literals",
-                "div_2_int_neg_literals",
-                "mul_lparen_add_add_rparen_int_literals",
-                "mul_lparen_add_add_add_rparen_int_literals",
-                "mul_lparen_add_add_rparen_add_int_literals",
-                "lparen_add_add_rparen_mul_int_literals",
-                "lparen_add_add_add_rparen_mul_int_literals",
-                "double_paren_add_add",
-                "double_paren_literal",
-                "lparen_add_add_rparen_mul_lparen_add_add_rparen",
-                "float_result_add_2_int_literals",
-                "struct_result_add_2_int_literals",
-                "struct_result_add_2_2_fields_int_literals",
-                "struct_result_add_3_int_literals",
-                "struct_result_lparen_int_rparen",
-                "add_to_var",
-                "add_var_to",
-                "var_member",
-                "bool_cond_and_bool",
-                "bool_cond_or_bool",
-                "int_cond_and_int",
-                "int_cond_or_int",
-                "bool_cond_and_int",
-                "int_cond_and_bool",
-                "bool_cond_or_int",
-                "int_cond_or_bool",
-                "cond_eq_bool",
-                "cond_eq_int",
-                "cond_neq_bool",
-                "cond_neq_int",
-                "cond_eq_bool_int",
-                "cond_eq_int_flt",
-                "cond_eq_cond_and",
-                "cond_eq_cond_or",
-                "cond_gt_bool",
-                "cond_gt_int",
-                "cond_gt_flt",
-                "cond_gteq_bool",
-                "cond_gteq_int",
-                "cond_gteq_flt",
-                "cond_lt_bool",
-                "cond_lt_int",
-                "cond_lt_flt",
-                "cond_lteq_bool",
-                "cond_lteq_int",
-                "cond_lteq_flt",
-                "min_lparen_int_rparen",
-                "min_lparen_int_add_int_rparen",
-                "min_var",
-                "min_lparen_int_rparen_to_i64",
-                "min_lparen_int_rparen_to_i32",
-                "struct_w_min_var",
-                "struct_w_min_lparen_int_rparen",
-                "struct_w_min_lparen_var_rparen",
-                "shift_left_int",
-                "shift_right_int",
-                "shift_left_int_add_int",
-                "shift_left_int_mul_int",
-                "add_int_shift_left_int",
-                "mul_int_shift_left_int",
-                "add_int_shift_left_int_add_int",
-                "mul_int_shift_left_int_mul_int",
-                "entity_expr",
-                "entity_path_expr",
-                "entity_parent_func",
-                "entity_name_func",
-                "entity_doc_name_func",
-                "entity_chain_func",
-                "var_parent_func",
-                "var_name_func",
-                "var_doc_name_func",
-                "var_chain_func",
-                "interpolate_string_w_i32_var",
-                "interpolate_string_w_string_var",
-                "interpolate_string_w_entity_var",
-                "interpolate_string_w_id_var",
-                "interpolate_string_w_var_not_found",
-                "interpolate_string_w_entity_var_0",
-                "interpolate_string_w_var_special_chars",
-                "interpolate_string_w_var_before_after_text",
-                "interpolate_string_w_curly_brackets_var",
-                "interpolate_string_w_curly_brackets_expr",
-                "interpolate_string_w_curly_brackets_expr_w_var",
-                "interpolate_string_w_curly_brackets_expr_w_composite_var",
-                "interpolate_string_w_escape_var_operator",
-                "interpolate_string_w_escape_curly_brackets",
-                "interpolate_string_w_func",
-                "interpolate_string_w_func_chain",
-                "iter_to_vars_no_data",
-                "iter_to_vars_1_comp",
-                "iter_to_vars_2_comps",
-                "iter_to_vars_1_comp_1_tag",
-                "iter_to_vars_w_1_query_var",
-                "iter_to_vars_w_2_query_vars"
-            ]
         }, {
             "id": "OpaqueTypes",
             "testcases": [
diff --git a/test/meta/src/BitmaskTypes.c b/test/meta/src/BitmaskTypes.c
index 76759cc42..50889652e 100644
--- a/test/meta/src/BitmaskTypes.c
+++ b/test/meta/src/BitmaskTypes.c
@@ -11,7 +11,7 @@ void meta_test_bitmask(
     test_int(ct->size, ECS_SIZEOF(ecs_i32_t));
     test_int(ct->alignment, ECS_ALIGNOF(ecs_i32_t));
 
-    const EcsMetaType *mt = ecs_get(world, t, EcsMetaType);
+    const EcsType *mt = ecs_get(world, t, EcsType);
     test_assert(mt != NULL);
     test_assert(mt->kind == EcsBitmaskType);
 
@@ -48,7 +48,7 @@ void meta_test_constant(
         if (!ecs_os_strcmp(c->name, name)) {
             test_int(c->value, value);
 
-            const ecs_u32_t *vptr = ecs_get_pair_object(world, c->constant, 
+            const ecs_u32_t *vptr = ecs_get_pair_second(world, c->constant, 
                 EcsConstant, ecs_u32_t);
             if (vptr) {
                 test_int(*vptr, value);
diff --git a/test/meta/src/Cursor.c b/test/meta/src/Cursor.c
index 42e289720..ac7f44c76 100644
--- a/test/meta/src/Cursor.c
+++ b/test/meta/src/Cursor.c
@@ -454,7 +454,7 @@ void Cursor_set_entity_as_signed(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t value = 0;
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(world, ecs_id(ecs_entity_t), &value);
     test_ok( ecs_meta_set_int(&cur, (int64_t)e) );
@@ -468,7 +468,7 @@ void Cursor_set_entity_as_unsigned(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t value = 0;
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(world, ecs_id(ecs_entity_t), &value);
     test_ok( ecs_meta_set_uint(&cur, e) );
@@ -496,7 +496,7 @@ void Cursor_set_id_as_signed(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_id_t value = 0;
-    ecs_id_t e = ecs_new_id(world);
+    ecs_id_t e = ecs_new(world);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(world, ecs_id(ecs_id_t), &value);
     test_ok( ecs_meta_set_int(&cur, (int64_t)e) );
@@ -510,7 +510,7 @@ void Cursor_set_id_as_unsigned(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_id_t value = 0;
-    ecs_id_t e = ecs_new_id(world);
+    ecs_id_t e = ecs_new(world);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(world, ecs_id(ecs_id_t), &value);
     test_ok( ecs_meta_set_uint(&cur, e) );
@@ -2973,8 +2973,8 @@ void Cursor_opaque_set_entity(void) {
     });
 
     Opaque_entity v = { 0 };
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(world, ecs_id(Opaque_entity), &v);
     test_int(0, ecs_meta_set_entity(&cur, e1));
@@ -2997,8 +2997,8 @@ void Cursor_opaque_set_id(void) {
     });
 
     Opaque_id v = { 0 };
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
 
     ecs_meta_cursor_t cur = ecs_meta_cursor(world, ecs_id(Opaque_id), &v);
     test_int(0, ecs_meta_set_id(&cur, e1));
diff --git a/test/meta/src/DeserializeFromJson.c b/test/meta/src/DeserializeFromJson.c
index 76f7975fd..06be05bec 100644
--- a/test/meta/src/DeserializeFromJson.c
+++ b/test/meta/src/DeserializeFromJson.c
@@ -1259,7 +1259,7 @@ void DeserializeFromJson_deser_entity_1_component_1_member(void) {
 
     test_assert(ecs_id(Position) != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *ptr = ecs_entity_from_json(world, e, 
         "{\"ids\":[[\"Position\"]],\"values\":[{\"x\":10}]}", NULL);
     test_assert(ptr != NULL);
@@ -1285,7 +1285,7 @@ void DeserializeFromJson_deser_entity_1_component_1_member_w_spaces(void) {
 
     test_assert(ecs_id(Position) != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *ptr = ecs_entity_from_json(world, e, 
         " { \"ids\" : [ [ \"Position\" ] ] , \"values\" : [ { \"x\" : 10 } ] }", NULL);
     test_assert(ptr != NULL);
@@ -1311,7 +1311,7 @@ void DeserializeFromJson_deser_entity_1_component_2_members(void) {
 
     test_assert(ecs_id(Position) != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *ptr = ecs_entity_from_json(world, e, 
         "{\"ids\":[[\"Position\"]],\"values\":[{\"x\":10, \"y\":20}]}", NULL);
     test_assert(ptr != NULL);
@@ -1348,7 +1348,7 @@ void DeserializeFromJson_deser_entity_2_components(void) {
 
     test_assert(ecs_id(Velocity) != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *ptr = ecs_entity_from_json(world, e, 
         "{"
             "\"ids\":[[\"Position\"], [\"Velocity\"]],"
@@ -1395,7 +1395,7 @@ void DeserializeFromJson_deser_entity_1_component_composite_member(void) {
 
     test_assert(ecs_id(Line) != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *ptr = ecs_entity_from_json(world, e, 
         "{\"ids\":[[\"Line\"]],\"values\":[{\"start\": {\"x\":10, \"y\":20}, \"stop\": {\"x\":30, \"y\":40}}]}", NULL);
     test_assert(ptr != NULL);
@@ -1434,7 +1434,7 @@ void DeserializeFromJson_deser_entity_1_component_nested_member(void) {
 
     test_assert(ecs_id(Line) != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *ptr = ecs_entity_from_json(world, e, 
         "{\"ids\":[[\"Line\"]],\"values\":[{\"start.x\": 10, \"start.y\": 20, \"stop.x\": 30, \"stop.y\": 40}]}", NULL);
     test_assert(ptr != NULL);
@@ -1465,7 +1465,7 @@ void DeserializeFromJson_deser_entity_1_pair(void) {
 
     test_assert(ecs_id(Position) != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *ptr = ecs_entity_from_json(world, e, 
         "{\"ids\":[[\"Position\", \"Tgt\"]],\"values\":[{\"x\":10, \"y\":20}]}", NULL);
     test_assert(ptr != NULL);
@@ -1504,7 +1504,7 @@ void DeserializeFromJson_deser_entity_2_pairs(void) {
 
     test_assert(ecs_id(Velocity) != 0);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *ptr = ecs_entity_from_json(world, e, 
         "{"
             "\"ids\":[[\"Position\", \"Tgt\"], [\"Velocity\", \"Tgt\"]],"
@@ -1531,7 +1531,7 @@ void DeserializeFromJson_deser_entity_2_pairs(void) {
 void DeserializeFromJson_deser_entity_empty(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *r = ecs_entity_from_json(world, e, "{}", NULL);
     test_str(r, "");
 
@@ -1541,7 +1541,7 @@ void DeserializeFromJson_deser_entity_empty(void) {
 void DeserializeFromJson_deser_entity_w_path(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *r = ecs_entity_from_json(world, e, "{\"path\":\"ent\"}", NULL);
     test_str(r, "");
     test_str(ecs_get_name(world, e), "ent");
@@ -1554,7 +1554,7 @@ void DeserializeFromJson_deser_entity_w_path_and_ids(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *r = ecs_entity_from_json(world, e, 
         "{\"path\":\"ent\", \"ids\":[[\"Position\"]]}", NULL);
     test_str(r, "");
@@ -1577,7 +1577,7 @@ void DeserializeFromJson_deser_entity_w_path_and_ids_and_values(void) {
         }
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *r = ecs_entity_from_json(world, e, 
         "{\"path\":\"ent\", \"ids\":[[\"Position\"]], \"values\":[{\"x\":10, \"y\":20}]}", NULL);
     test_str(r, "");
@@ -1596,7 +1596,7 @@ void DeserializeFromJson_deser_entity_w_ids(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     const char *r = ecs_entity_from_json(world, e, 
         "{\"ids\":[[\"Position\"]]}", NULL);
     test_str(r, "");
@@ -1748,7 +1748,7 @@ void DeserializeFromJson_ser_deser_new_world_1_entity_w_tag(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
     test_assert(e != 0);
 
     char *json = ecs_world_to_json(world, NULL);
@@ -1775,7 +1775,7 @@ void DeserializeFromJson_ser_deser_new_world_1_entity_w_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     char *json = ecs_world_to_json(world, NULL);
@@ -1812,7 +1812,7 @@ void DeserializeFromJson_ser_deser_new_world_1_entity_w_component_meta(void) {
         }
     });
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(e != 0);
 
     char *json = ecs_world_to_json(world, NULL);
@@ -1852,7 +1852,7 @@ void DeserializeFromJson_ser_deser_new_world_1_named_entity_w_tag(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     ecs_add(world, e, Tag);
     test_assert(e != 0);
 
@@ -1881,7 +1881,7 @@ void DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     ecs_add(world, e, Position);
     test_assert(e != 0);
 
@@ -1921,7 +1921,7 @@ void DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component_meta(voi
         }
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     ecs_set(world, e, Position, {10, 20});
     test_assert(e != 0);
 
@@ -1964,7 +1964,7 @@ void DeserializeFromJson_ser_deser_new_world_1_entity_w_tag_serialize_all(void)
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new(world, Tag);
+    ecs_entity_t e = ecs_new_w(world, Tag);
     test_assert(e != 0);
 
     ecs_world_to_json_desc_t desc = {0};
@@ -1994,7 +1994,7 @@ void DeserializeFromJson_ser_deser_new_world_1_entity_w_component_serialize_all(
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new(world, Position);
+    ecs_entity_t e = ecs_new_w(world, Position);
     test_assert(e != 0);
 
     ecs_world_to_json_desc_t desc = {0};
@@ -2034,7 +2034,7 @@ void DeserializeFromJson_ser_deser_new_world_1_entity_w_component_meta_serialize
         }
     });
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
     test_assert(e != 0);
 
     ecs_world_to_json_desc_t desc = {0};
@@ -2077,7 +2077,7 @@ void DeserializeFromJson_ser_deser_new_world_1_named_entity_w_tag_serialize_all(
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     ecs_add(world, e, Tag);
     test_assert(e != 0);
 
@@ -2109,7 +2109,7 @@ void DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component_serializ
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     ecs_add(world, e, Position);
     test_assert(e != 0);
 
@@ -2152,7 +2152,7 @@ void DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component_meta_ser
         }
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     ecs_set(world, e, Position, {10, 20});
     test_assert(e != 0);
 
@@ -2205,9 +2205,9 @@ void DeserializeFromJson_ser_deser_new_world_3_entities_w_component_meta(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
@@ -2286,9 +2286,9 @@ void DeserializeFromJson_ser_deser_new_world_3_entities_w_2_components_meta(void
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
@@ -2393,10 +2393,10 @@ void DeserializeFromJson_ser_deser_new_world_4_entities_2_tables_w_component_met
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-    ecs_entity_t e4 = ecs_new_entity(world, "e4");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+    ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
@@ -2492,15 +2492,15 @@ void DeserializeFromJson_ser_deser_new_world_component_w_anon_entity_member(void
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t a1 = ecs_new_id(world);
-    ecs_entity_t a2 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t a1 = ecs_new(world);
+    ecs_entity_t a2 = ecs_new(world);
     ecs_set(world, e1, EntityType, {a1, a2});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_id(world, e2, a1);
 
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_id(world, e3, a2);
 
     char *json = ecs_world_to_json(world, NULL);
@@ -2560,15 +2560,15 @@ void DeserializeFromJson_ser_deser_new_world_component_w_named_entity_member(voi
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t n1 = ecs_new_entity(world, "n1");
-    ecs_entity_t n2 = ecs_new_entity(world, "n2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t n1 = ecs_entity(world, { .name = "n1" });
+    ecs_entity_t n2 = ecs_entity(world, { .name = "n2" });
     ecs_set(world, e1, EntityType, {n1, n2});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_id(world, e2, n1);
 
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_id(world, e3, n2);
 
     char *json = ecs_world_to_json(world, NULL);
@@ -2628,15 +2628,15 @@ void DeserializeFromJson_ser_deser_new_world_component_w_anon_and_named_entity_m
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t n1 = ecs_new_entity(world, "n1");
-    ecs_entity_t a1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t n1 = ecs_entity(world, { .name = "n1" });
+    ecs_entity_t a1 = ecs_new(world);
     ecs_set(world, e1, EntityType, {n1, a1});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_id(world, e2, n1);
 
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_id(world, e3, a1);
 
     char *json = ecs_world_to_json(world, NULL);
@@ -2687,10 +2687,10 @@ void DeserializeFromJson_ser_deser_new_world_component_w_anon_and_named_entity_m
 void DeserializeFromJson_ser_deser_new_world_component_w_anon_entity_with_self(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add_id(world, e1, e1);
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_id(world, e2, e1);
 
     char *json = ecs_world_to_json(world, NULL);
@@ -2721,10 +2721,10 @@ void DeserializeFromJson_ser_deser_new_world_component_w_anon_entity_with_self(v
 void DeserializeFromJson_ser_deser_new_world_component_w_named_entity_with_self(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add_id(world, e1, e1);
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_id(world, e2, e1);
 
     char *json = ecs_world_to_json(world, NULL);
@@ -2755,15 +2755,15 @@ void DeserializeFromJson_ser_deser_new_world_2_entities_w_anon_parent(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagB);
 
-    ecs_entity_t foo = ecs_new_entity(world, "foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "foo" });
     ecs_add_pair(world, foo, TagA, e1);
     ecs_add_pair(world, foo, TagB, e2);
 
@@ -2804,9 +2804,9 @@ void DeserializeFromJson_ser_deser_new_world_2_entities_w_named_parent(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
     ecs_add(world, e1, TagA);
@@ -2846,15 +2846,15 @@ void DeserializeFromJson_ser_deser_new_world_2_entities_w_anon_parent_w_cycle(vo
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagB);
 
-    ecs_entity_t foo = ecs_new_entity(world, "foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "foo" });
     ecs_add_pair(world, foo, TagA, e1);
     ecs_add_pair(world, foo, TagB, e2);
 
@@ -2902,9 +2902,9 @@ void DeserializeFromJson_ser_deser_new_world_2_entities_w_named_parent_w_cycle(v
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
     ecs_add(world, e1, TagA);
@@ -2950,10 +2950,10 @@ void DeserializeFromJson_ser_deser_new_world_w_prefab(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_entity_t b = ecs_new(world, Foo);
+    ecs_entity_t b = ecs_new_w(world, Foo);
     test_assert(b != 0);
     ecs_add_id(world, b, EcsPrefab);
-    ecs_entity_t e = ecs_new(world, Bar);
+    ecs_entity_t e = ecs_new_w(world, Bar);
     test_assert(e != 0);
     ecs_add_pair(world, e, EcsIsA, b);
 
@@ -2991,7 +2991,7 @@ void DeserializeFromJson_ser_deser_new_world_w_disabled(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_entity_t b = ecs_new(world, Foo);
+    ecs_entity_t b = ecs_new_w(world, Foo);
     test_assert(b != 0);
     ecs_enable(world, b, false);
     test_assert(ecs_has_id(world, b, EcsDisabled));
@@ -3033,13 +3033,13 @@ void DeserializeFromJson_ser_deser_restore_1_entity_to_empty_table(void) {
 
     ECS_COMPONENT(world, Velocity);
     
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
     char *json = ecs_world_to_json(world, NULL);
     test_assert(json != NULL);
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Position, {30, 40});
     ecs_set(world, e2, Velocity, {3, 4});
     ecs_set(world, e1, Velocity, {1, 2});
@@ -3099,11 +3099,11 @@ void DeserializeFromJson_ser_deser_restore_1_entity_to_non_empty_table(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Position, {30, 40});
     ecs_set(world, e2, Velocity, {3, 4});
 
@@ -3166,13 +3166,13 @@ void DeserializeFromJson_ser_deser_restore_1_anon_entity_to_empty_table(void) {
 
     ECS_COMPONENT(world, Velocity);
     
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
 
     char *json = ecs_world_to_json(world, NULL);
     test_assert(json != NULL);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {30, 40});
     ecs_set(world, e2, Velocity, {3, 4});
     ecs_set(world, e1, Velocity, {1, 2});
@@ -3232,11 +3232,11 @@ void DeserializeFromJson_ser_deser_restore_1_anon_entity_to_non_empty_table(void
         }
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {30, 40});
     ecs_set(world, e2, Velocity, {3, 4});
 
@@ -3297,7 +3297,7 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_entity_to_empty_table(void)
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
     char *json = ecs_world_to_json(world, NULL);
@@ -3333,10 +3333,10 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_entity_to_non_empty_table(v
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Position, {30, 40});
 
     char *json = ecs_world_to_json(world, NULL);
@@ -3384,7 +3384,7 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_anon_entity_to_empty_table(
         }
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
 
     char *json = ecs_world_to_json(world, NULL);
@@ -3397,7 +3397,7 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_anon_entity_to_empty_table(
     test_str(r, "");
     ecs_os_free(json);
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ .id = ecs_id(Position) });
+    ecs_iter_t it = ecs_each(world, Position);
     e1 = ecs_iter_first(&it);
     test_assert(e1 != 0);
 
@@ -3424,10 +3424,10 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_anon_entity_to_non_empty_ta
         }
     });
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {30, 40});
 
     char *json = ecs_world_to_json(world, NULL);
@@ -3440,15 +3440,15 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_anon_entity_to_non_empty_ta
     test_str(r, "");
     ecs_os_free(json);
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ .id = ecs_id(Position) });
-    test_assert(ecs_term_next(&it) == true);
+    ecs_iter_t it = ecs_each(world, Position);
+    test_assert(ecs_each_next(&it) == true);
     test_int(it.count, 2);
     if (it.entities[0] == e2) {
         e1 = it.entities[1];
     } else {
         e1 = it.entities[0];
     }
-    test_assert(ecs_term_next(&it) == false);
+    test_assert(ecs_each_next(&it) == false);
 
     test_assert(ecs_has(world, e1, Position));
     test_assert(ecs_is_alive(world, e2));
@@ -3484,10 +3484,10 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_w_ref(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Position, {30, 40});
     ecs_add_pair(world, e2, TagA, e1);
 
@@ -3543,10 +3543,10 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_ref(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {30, 40});
     ecs_add_pair(world, e2, TagA, e1);
 
@@ -3597,10 +3597,10 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_w_cycle_ref(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Position, {30, 40});
     
     ecs_add_pair(world, e1, TagA, e2);
@@ -3659,10 +3659,10 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_cycle_ref(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {30, 40});
     
     ecs_add_pair(world, e1, TagA, e2);
@@ -3717,10 +3717,10 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_w_recycled(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Position, {30, 40});
     
     ecs_add_pair(world, e1, TagA, e2);
@@ -3733,7 +3733,7 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_w_recycled(void) {
     test_assert(!ecs_is_alive(world, e1));
     test_assert(ecs_get_target(world, e2, TagA, 0) == 0);
 
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_set(world, e3, Position, {50, 60});
 
     const char *r = ecs_world_from_json(world, json, NULL);
@@ -3793,10 +3793,10 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_recycled(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {30, 40});
     
     ecs_add_pair(world, e1, TagA, e2);
@@ -3809,7 +3809,7 @@ void DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_recycled(void) {
     test_assert(!ecs_is_alive(world, e1));
     test_assert(ecs_get_target(world, e2, TagA, 0) == 0);
 
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e3 = ecs_new(world);
     ecs_set(world, e3, Position, {50, 60});
 
     const char *r = ecs_world_from_json(world, json, NULL);
@@ -3871,15 +3871,15 @@ void DeserializeFromJson_ser_deser_on_set_3_entities(void) {
     int32_t count = 0;
 
     ecs_observer(world, {
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = { EcsOnSet },
         .callback = OnSet_count,
         .ctx = &count
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
     ecs_set(world, e3, Position, {50, 60});
@@ -3914,14 +3914,14 @@ void DeserializeFromJson_ser_deser_on_set_3_entities_2_restored(void) {
     int32_t count = 0;
 
     ecs_observer(world, {
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = { EcsOnSet },
         .callback = OnSet_count,
         .ctx = &count
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
 
@@ -3931,7 +3931,7 @@ void DeserializeFromJson_ser_deser_on_set_3_entities_2_restored(void) {
     char *json = ecs_world_to_json(world, NULL);
     test_assert(json != NULL);
 
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_set(world, e3, Position, {50, 60});
 
     test_int(count, 1);
@@ -3961,13 +3961,13 @@ void DeserializeFromJson_ser_deser_on_set_3_entities_1_restored(void) {
     int32_t count = 0;
 
     ecs_observer(world, {
-        .filter.terms[0].id = ecs_id(Position),
+        .query.terms[0].id = ecs_id(Position),
         .events = { EcsOnSet },
         .callback = OnSet_count,
         .ctx = &count
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
     test_int(count, 1);
@@ -3976,8 +3976,8 @@ void DeserializeFromJson_ser_deser_on_set_3_entities_1_restored(void) {
     char *json = ecs_world_to_json(world, NULL);
     test_assert(json != NULL);
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_set(world, e2, Position, {30, 40});
     ecs_set(world, e3, Position, {50, 60});
 
@@ -4005,9 +4005,9 @@ void DeserializeFromJson_ser_deser_3_entities_after_remove_all(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
     ecs_set(world, e3, Position, {50, 60});
@@ -4072,9 +4072,9 @@ void DeserializeFromJson_ser_deser_3_entities_after_delete_with(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
     ecs_set(world, e3, Position, {50, 60});
@@ -4166,16 +4166,16 @@ void DeserializeFromJson_ser_deser_w_hooks(void) {
     });
 
     ecs_set_hooks(world, StringType, {
-        .ctor = ecs_default_ctor,
+        .ctor = flecs_default_ctor,
         .dtor = ecs_dtor(StringType),
         .move = ecs_move(StringType),
         .copy = ecs_copy(StringType)
     });
 
-    ecs_entity_t e1 = ecs_set(world, 0, StringType, {"foo"});
-    ecs_entity_t e2 = ecs_set(world, 0, StringType, {"bar"});
-    ecs_entity_t e3 = ecs_set(world, 0, StringType, {"hello"});
-    ecs_entity_t e4 = ecs_set(world, 0, StringType, {"world"});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(StringType, {"foo"}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(StringType, {"bar"}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(StringType, {"hello"}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(StringType, {"world"}));
 
     ecs_set_name(world, e1, "e1");
     ecs_set_name(world, e2, "e2");
@@ -4257,7 +4257,7 @@ void DeserializeFromJson_ser_deser_large_data(void) {
         .v = long_str
     };
 
-    char *long_str_ser = ecs_asprintf("{\"v\":\"%s\"}", long_str);
+    char *long_str_ser = flecs_asprintf("{\"v\":\"%s\"}", long_str);
     char *json = ecs_ptr_to_json(world, t, &value);
     test_assert(json != NULL);
     test_str(json, long_str_ser);
@@ -4282,7 +4282,7 @@ void DeserializeFromJson_ser_deser_different_component_order(void) {
     {
         ECS_TAG(world, Foo);
 
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -4314,34 +4314,34 @@ void DeserializeFromJson_ser_deser_different_component_order(void) {
 
         ecs_set_scope(world, 0);
 
-        ecs_entity_t e1 = ecs_new_entity(world, "e1");
+        ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
         ecs_set(world, e1, Position, {11, 20});
         ecs_set(world, e1, Velocity, {1, 2});
         ecs_set(world, e1, Mass, {100});
         ecs_add(world, e1, Foo);
 
-        ecs_entity_t e2 = ecs_new_entity(world, "e2");
+        ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
         ecs_set(world, e2, Position, {12, 20});
         ecs_set(world, e2, Velocity, {2, 2});
         ecs_set(world, e2, Mass, {200});
         ecs_add(world, e2, Foo);
 
-        ecs_entity_t e3 = ecs_new_entity(world, "e3");
+        ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
         ecs_set(world, e3, Position, {13, 20});
         ecs_set(world, e3, Mass, {300});
         ecs_add(world, e3, Foo);
 
-        ecs_entity_t e4 = ecs_new_entity(world, "e4");
+        ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
         ecs_set(world, e4, Position, {14, 20});
         ecs_set(world, e4, Mass, {400});
         ecs_add(world, e4, Foo);
 
-        ecs_entity_t e5 = ecs_new_entity(world, "e5");
+        ecs_entity_t e5 = ecs_entity(world, { .name = "e5" });
         ecs_set(world, e5, Velocity, {5, 2});
         ecs_set(world, e5, Mass, {500});
         ecs_add(world, e5, Foo);
 
-        ecs_entity_t e6 = ecs_new_entity(world, "e6");
+        ecs_entity_t e6 = ecs_entity(world, { .name = "e6" });
         ecs_set(world, e6, Velocity, {6, 2});
         ecs_set(world, e6, Mass, {600});
         ecs_add(world, e6, Foo);
@@ -4354,7 +4354,7 @@ void DeserializeFromJson_ser_deser_different_component_order(void) {
     world = ecs_init();
 
     {
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -4527,7 +4527,7 @@ void DeserializeFromJson_ser_deser_no_reflection_data(void) {
     {
         ECS_TAG(world, Foo);
 
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -4559,34 +4559,34 @@ void DeserializeFromJson_ser_deser_no_reflection_data(void) {
 
         ecs_set_scope(world, 0);
 
-        ecs_entity_t e1 = ecs_new_entity(world, "e1");
+        ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
         ecs_set(world, e1, Position, {11, 20});
         ecs_set(world, e1, Velocity, {1, 2});
         ecs_set(world, e1, Mass, {100});
         ecs_add(world, e1, Foo);
 
-        ecs_entity_t e2 = ecs_new_entity(world, "e2");
+        ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
         ecs_set(world, e2, Position, {12, 20});
         ecs_set(world, e2, Velocity, {2, 2});
         ecs_set(world, e2, Mass, {200});
         ecs_add(world, e2, Foo);
 
-        ecs_entity_t e3 = ecs_new_entity(world, "e3");
+        ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
         ecs_set(world, e3, Position, {13, 20});
         ecs_set(world, e3, Mass, {300});
         ecs_add(world, e3, Foo);
 
-        ecs_entity_t e4 = ecs_new_entity(world, "e4");
+        ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
         ecs_set(world, e4, Position, {14, 20});
         ecs_set(world, e4, Mass, {400});
         ecs_add(world, e4, Foo);
 
-        ecs_entity_t e5 = ecs_new_entity(world, "e5");
+        ecs_entity_t e5 = ecs_entity(world, { .name = "e5" });
         ecs_set(world, e5, Velocity, {5, 2});
         ecs_set(world, e5, Mass, {500});
         ecs_add(world, e5, Foo);
 
-        ecs_entity_t e6 = ecs_new_entity(world, "e6");
+        ecs_entity_t e6 = ecs_entity(world, { .name = "e6" });
         ecs_set(world, e6, Velocity, {6, 2});
         ecs_set(world, e6, Mass, {600});
         ecs_add(world, e6, Foo);
@@ -4599,7 +4599,7 @@ void DeserializeFromJson_ser_deser_no_reflection_data(void) {
     world = ecs_init();
 
     {
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -4741,7 +4741,7 @@ void DeserializeFromJson_ser_deser_no_reflection_data_strict(void) {
     {
         ECS_TAG(world, Foo);
 
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -4773,34 +4773,34 @@ void DeserializeFromJson_ser_deser_no_reflection_data_strict(void) {
 
         ecs_set_scope(world, 0);
 
-        ecs_entity_t e1 = ecs_new_entity(world, "e1");
+        ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
         ecs_set(world, e1, Position, {11, 20});
         ecs_set(world, e1, Velocity, {1, 2});
         ecs_set(world, e1, Mass, {100});
         ecs_add(world, e1, Foo);
 
-        ecs_entity_t e2 = ecs_new_entity(world, "e2");
+        ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
         ecs_set(world, e2, Position, {12, 20});
         ecs_set(world, e2, Velocity, {2, 2});
         ecs_set(world, e2, Mass, {200});
         ecs_add(world, e2, Foo);
 
-        ecs_entity_t e3 = ecs_new_entity(world, "e3");
+        ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
         ecs_set(world, e3, Position, {13, 20});
         ecs_set(world, e3, Mass, {300});
         ecs_add(world, e3, Foo);
 
-        ecs_entity_t e4 = ecs_new_entity(world, "e4");
+        ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
         ecs_set(world, e4, Position, {14, 20});
         ecs_set(world, e4, Mass, {400});
         ecs_add(world, e4, Foo);
 
-        ecs_entity_t e5 = ecs_new_entity(world, "e5");
+        ecs_entity_t e5 = ecs_entity(world, { .name = "e5" });
         ecs_set(world, e5, Velocity, {5, 2});
         ecs_set(world, e5, Mass, {500});
         ecs_add(world, e5, Foo);
 
-        ecs_entity_t e6 = ecs_new_entity(world, "e6");
+        ecs_entity_t e6 = ecs_entity(world, { .name = "e6" });
         ecs_set(world, e6, Velocity, {6, 2});
         ecs_set(world, e6, Mass, {600});
         ecs_add(world, e6, Foo);
@@ -4813,7 +4813,7 @@ void DeserializeFromJson_ser_deser_no_reflection_data_strict(void) {
     world = ecs_init();
 
     {
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -4856,7 +4856,7 @@ void DeserializeFromJson_ser_deser_value_for_tag(void) {
     {
         ECS_TAG(world, Foo);
 
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -4888,34 +4888,34 @@ void DeserializeFromJson_ser_deser_value_for_tag(void) {
 
         ecs_set_scope(world, 0);
 
-        ecs_entity_t e1 = ecs_new_entity(world, "e1");
+        ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
         ecs_set(world, e1, Position, {11, 20});
         ecs_set(world, e1, Velocity, {1, 2});
         ecs_set(world, e1, Mass, {100});
         ecs_add(world, e1, Foo);
 
-        ecs_entity_t e2 = ecs_new_entity(world, "e2");
+        ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
         ecs_set(world, e2, Position, {12, 20});
         ecs_set(world, e2, Velocity, {2, 2});
         ecs_set(world, e2, Mass, {200});
         ecs_add(world, e2, Foo);
 
-        ecs_entity_t e3 = ecs_new_entity(world, "e3");
+        ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
         ecs_set(world, e3, Position, {13, 20});
         ecs_set(world, e3, Mass, {300});
         ecs_add(world, e3, Foo);
 
-        ecs_entity_t e4 = ecs_new_entity(world, "e4");
+        ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
         ecs_set(world, e4, Position, {14, 20});
         ecs_set(world, e4, Mass, {400});
         ecs_add(world, e4, Foo);
 
-        ecs_entity_t e5 = ecs_new_entity(world, "e5");
+        ecs_entity_t e5 = ecs_entity(world, { .name = "e5" });
         ecs_set(world, e5, Velocity, {5, 2});
         ecs_set(world, e5, Mass, {500});
         ecs_add(world, e5, Foo);
 
-        ecs_entity_t e6 = ecs_new_entity(world, "e6");
+        ecs_entity_t e6 = ecs_entity(world, { .name = "e6" });
         ecs_set(world, e6, Velocity, {6, 2});
         ecs_set(world, e6, Mass, {600});
         ecs_add(world, e6, Foo);
@@ -4928,7 +4928,7 @@ void DeserializeFromJson_ser_deser_value_for_tag(void) {
     world = ecs_init();
 
     {
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -5070,7 +5070,7 @@ void DeserializeFromJson_ser_deser_value_for_tag_strict(void) {
     {
         ECS_TAG(world, Foo);
 
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -5102,34 +5102,34 @@ void DeserializeFromJson_ser_deser_value_for_tag_strict(void) {
 
         ecs_set_scope(world, 0);
 
-        ecs_entity_t e1 = ecs_new_entity(world, "e1");
+        ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
         ecs_set(world, e1, Position, {11, 20});
         ecs_set(world, e1, Velocity, {1, 2});
         ecs_set(world, e1, Mass, {100});
         ecs_add(world, e1, Foo);
 
-        ecs_entity_t e2 = ecs_new_entity(world, "e2");
+        ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
         ecs_set(world, e2, Position, {12, 20});
         ecs_set(world, e2, Velocity, {2, 2});
         ecs_set(world, e2, Mass, {200});
         ecs_add(world, e2, Foo);
 
-        ecs_entity_t e3 = ecs_new_entity(world, "e3");
+        ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
         ecs_set(world, e3, Position, {13, 20});
         ecs_set(world, e3, Mass, {300});
         ecs_add(world, e3, Foo);
 
-        ecs_entity_t e4 = ecs_new_entity(world, "e4");
+        ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
         ecs_set(world, e4, Position, {14, 20});
         ecs_set(world, e4, Mass, {400});
         ecs_add(world, e4, Foo);
 
-        ecs_entity_t e5 = ecs_new_entity(world, "e5");
+        ecs_entity_t e5 = ecs_entity(world, { .name = "e5" });
         ecs_set(world, e5, Velocity, {5, 2});
         ecs_set(world, e5, Mass, {500});
         ecs_add(world, e5, Foo);
 
-        ecs_entity_t e6 = ecs_new_entity(world, "e6");
+        ecs_entity_t e6 = ecs_entity(world, { .name = "e6" });
         ecs_set(world, e6, Velocity, {6, 2});
         ecs_set(world, e6, Mass, {600});
         ecs_add(world, e6, Foo);
@@ -5142,7 +5142,7 @@ void DeserializeFromJson_ser_deser_value_for_tag_strict(void) {
     world = ecs_init();
 
     {
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -5185,7 +5185,7 @@ void DeserializeFromJson_ser_deser_value_for_non_existing(void) {
     {
         ECS_TAG(world, Foo);
 
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -5217,34 +5217,34 @@ void DeserializeFromJson_ser_deser_value_for_non_existing(void) {
 
         ecs_set_scope(world, 0);
 
-        ecs_entity_t e1 = ecs_new_entity(world, "e1");
+        ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
         ecs_set(world, e1, Position, {11, 20});
         ecs_set(world, e1, Velocity, {1, 2});
         ecs_set(world, e1, Mass, {100});
         ecs_add(world, e1, Foo);
 
-        ecs_entity_t e2 = ecs_new_entity(world, "e2");
+        ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
         ecs_set(world, e2, Position, {12, 20});
         ecs_set(world, e2, Velocity, {2, 2});
         ecs_set(world, e2, Mass, {200});
         ecs_add(world, e2, Foo);
 
-        ecs_entity_t e3 = ecs_new_entity(world, "e3");
+        ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
         ecs_set(world, e3, Position, {13, 20});
         ecs_set(world, e3, Mass, {300});
         ecs_add(world, e3, Foo);
 
-        ecs_entity_t e4 = ecs_new_entity(world, "e4");
+        ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
         ecs_set(world, e4, Position, {14, 20});
         ecs_set(world, e4, Mass, {400});
         ecs_add(world, e4, Foo);
 
-        ecs_entity_t e5 = ecs_new_entity(world, "e5");
+        ecs_entity_t e5 = ecs_entity(world, { .name = "e5" });
         ecs_set(world, e5, Velocity, {5, 2});
         ecs_set(world, e5, Mass, {500});
         ecs_add(world, e5, Foo);
 
-        ecs_entity_t e6 = ecs_new_entity(world, "e6");
+        ecs_entity_t e6 = ecs_entity(world, { .name = "e6" });
         ecs_set(world, e6, Velocity, {6, 2});
         ecs_set(world, e6, Mass, {600});
         ecs_add(world, e6, Foo);
@@ -5257,7 +5257,7 @@ void DeserializeFromJson_ser_deser_value_for_non_existing(void) {
     world = ecs_init();
 
     {
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -5401,7 +5401,7 @@ void DeserializeFromJson_ser_deser_value_for_non_existing_strict(void) {
     {
         ECS_TAG(world, Foo);
 
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -5433,34 +5433,34 @@ void DeserializeFromJson_ser_deser_value_for_non_existing_strict(void) {
 
         ecs_set_scope(world, 0);
 
-        ecs_entity_t e1 = ecs_new_entity(world, "e1");
+        ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
         ecs_set(world, e1, Position, {11, 20});
         ecs_set(world, e1, Velocity, {1, 2});
         ecs_set(world, e1, Mass, {100});
         ecs_add(world, e1, Foo);
 
-        ecs_entity_t e2 = ecs_new_entity(world, "e2");
+        ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
         ecs_set(world, e2, Position, {12, 20});
         ecs_set(world, e2, Velocity, {2, 2});
         ecs_set(world, e2, Mass, {200});
         ecs_add(world, e2, Foo);
 
-        ecs_entity_t e3 = ecs_new_entity(world, "e3");
+        ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
         ecs_set(world, e3, Position, {13, 20});
         ecs_set(world, e3, Mass, {300});
         ecs_add(world, e3, Foo);
 
-        ecs_entity_t e4 = ecs_new_entity(world, "e4");
+        ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
         ecs_set(world, e4, Position, {14, 20});
         ecs_set(world, e4, Mass, {400});
         ecs_add(world, e4, Foo);
 
-        ecs_entity_t e5 = ecs_new_entity(world, "e5");
+        ecs_entity_t e5 = ecs_entity(world, { .name = "e5" });
         ecs_set(world, e5, Velocity, {5, 2});
         ecs_set(world, e5, Mass, {500});
         ecs_add(world, e5, Foo);
 
-        ecs_entity_t e6 = ecs_new_entity(world, "e6");
+        ecs_entity_t e6 = ecs_entity(world, { .name = "e6" });
         ecs_set(world, e6, Velocity, {6, 2});
         ecs_set(world, e6, Mass, {600});
         ecs_add(world, e6, Foo);
@@ -5473,7 +5473,7 @@ void DeserializeFromJson_ser_deser_value_for_non_existing_strict(void) {
     world = ecs_init();
 
     {
-        ecs_entity_t module = ecs_new_entity(world, "module");
+        ecs_entity_t module = ecs_entity(world, { .name = "module" });
         ecs_add_id(world, module, EcsModule);
         ecs_set_scope(world, module);
 
@@ -5529,7 +5529,7 @@ void ser_deser_cpp_name_test(
         test_assert(t != 0);
         test_str(ecs_get_name(world, t), typename);
 
-        ecs_entity_t child = ecs_new_entity(world, "c");
+        ecs_entity_t child = ecs_entity(world, { .name = "c" });
         ecs_add_pair(world, child, EcsChildOf, t);
 
         ECS_COMPONENT(world, Mass);
@@ -5540,7 +5540,7 @@ void ser_deser_cpp_name_test(
             }
         });
 
-        ecs_entity_t e = ecs_new_entity(world, "e");
+        ecs_entity_t e = ecs_entity(world, { .name = "e" });
         ecs_set(world, e, Position, {10, 20});
         ecs_set(world, e, Mass, {100});
         ecs_add_id(world, e, t);
@@ -5653,12 +5653,12 @@ void DeserializeFromJson_ser_deser_w_alerts(void) {
         ECS_TAG(world, Bar);
 
         ecs_entity_t alert = ecs_alert(world, {
-            .entity = ecs_new_entity(world, "module.my_alert"),
-            .filter.expr = "Foo, !Bar"
+            .entity = ecs_entity(world, { .name = "module.my_alert" }),
+            .query.expr = "Foo, !Bar"
         });
         test_assert(alert != 0);
 
-        ecs_entity_t e = ecs_new_entity(world, "e");
+        ecs_entity_t e = ecs_entity(world, { .name = "e" });
         ecs_add(world, e, Foo);
 
         ecs_progress(world, 2.0);
@@ -5757,12 +5757,12 @@ void DeserializeFromJson_ser_deser_w_alerts_w_progress(void) {
         ECS_TAG(world, Bar);
 
         ecs_entity_t alert = ecs_alert(world, {
-            .entity = ecs_new_entity(world, "module.my_alert"),
-            .filter.expr = "Foo, !Bar"
+            .entity = ecs_entity(world, { .name = "module.my_alert" }),
+            .query.expr = "Foo, !Bar"
         });
         test_assert(alert != 0);
 
-        ecs_entity_t e = ecs_new_entity(world, "e");
+        ecs_entity_t e = ecs_entity(world, { .name = "e" });
         ecs_add(world, e, Foo);
 
         ecs_progress(world, 2.0);
@@ -5859,7 +5859,7 @@ void DeserializeFromJson_ser_deser_named_to_different_table(void) {
 
     {
         ECS_TAG(world, Foo);
-        ecs_entity_t e = ecs_new_entity(world, "e");
+        ecs_entity_t e = ecs_entity(world, { .name = "e" });
         ecs_add(world, e, Foo);
     }
 
@@ -5871,7 +5871,7 @@ void DeserializeFromJson_ser_deser_named_to_different_table(void) {
 
     {
         ECS_TAG(world, Foo);
-        ecs_entity_t e = ecs_new_entity(world, "e");
+        ecs_entity_t e = ecs_entity(world, { .name = "e" });
 
         const char *r = ecs_world_from_json(world, json, NULL);
         test_str(r, "");
@@ -5888,8 +5888,8 @@ void DeserializeFromJson_ser_deser_named_child_to_different_table(void) {
 
     {
         ECS_TAG(world, Foo);
-        ecs_entity_t p = ecs_new_entity(world, "p");
-        ecs_entity_t e = ecs_new_entity(world, "e");
+        ecs_entity_t p = ecs_entity(world, { .name = "p" });
+        ecs_entity_t e = ecs_entity(world, { .name = "e" });
         ecs_add_pair(world, e, EcsChildOf, p);
         ecs_add(world, e, Foo);
     }
@@ -5902,8 +5902,8 @@ void DeserializeFromJson_ser_deser_named_child_to_different_table(void) {
 
     {
         ECS_TAG(world, Foo);
-        ecs_entity_t p = ecs_new_entity(world, "p");
-        ecs_entity_t e = ecs_new_entity(world, "e");
+        ecs_entity_t p = ecs_entity(world, { .name = "p" });
+        ecs_entity_t e = ecs_entity(world, { .name = "e" });
         ecs_add_pair(world, e, EcsChildOf, p);
 
         const char *r = ecs_world_from_json(world, json, NULL);
@@ -5923,13 +5923,13 @@ void DeserializeFromJson_ser_deser_with_child_tgt(void) {
     {
         ECS_TAG(world, Rel);
         ECS_TAG(world, Foo);
-        ecs_entity_t p = ecs_new_entity(world, "p");
+        ecs_entity_t p = ecs_entity(world, { .name = "p" });
 
-        ecs_entity_t e = ecs_new_entity(world, "e");
+        ecs_entity_t e = ecs_entity(world, { .name = "e" });
         ecs_add_pair(world, e, EcsChildOf, p);
         ecs_add(world, e, Foo);
 
-        ecs_entity_t c = ecs_new_entity(world, "c");
+        ecs_entity_t c = ecs_entity(world, { .name = "c" });
         ecs_add_pair(world, c, EcsChildOf, e);
         ecs_add_pair(world, e, Rel, c);
     }
diff --git a/test/meta/src/EnumTypes.c b/test/meta/src/EnumTypes.c
index 7128fb42a..f040c45a5 100644
--- a/test/meta/src/EnumTypes.c
+++ b/test/meta/src/EnumTypes.c
@@ -11,7 +11,7 @@ void meta_test_enum(
     test_int(ct->size, ECS_SIZEOF(ecs_i32_t));
     test_int(ct->alignment, ECS_ALIGNOF(ecs_i32_t));
 
-    const EcsMetaType *mt = ecs_get(world, t, EcsMetaType);
+    const EcsType *mt = ecs_get(world, t, EcsType);
     test_assert(mt != NULL);
     test_assert(mt->kind == EcsEnumType);
 
@@ -48,7 +48,7 @@ void meta_test_constant(
         if (!ecs_os_strcmp(c->name, name)) {
             test_int(c->value, value);
 
-            const ecs_i32_t *vptr = ecs_get_pair_object(world, c->constant, 
+            const ecs_i32_t *vptr = ecs_get_pair_second(world, c->constant, 
                 EcsConstant, ecs_i32_t);
             if (vptr) {
                 test_int(*vptr, value);
@@ -183,7 +183,7 @@ void EnumTypes_zero_initialized(void) {
     test_assert(e != 0);
     test_assert(ecs_has(world, e, EcsComponent));
 
-    ecs_entity_t ent = ecs_new_id(world);
+    ecs_entity_t ent = ecs_new(world);
     ecs_add_id(world, ent, e);
 
     const int32_t *ptr = ecs_get_id(world, ent, e);
@@ -209,7 +209,7 @@ void EnumTypes_enum_relation(void) {
     test_assert(e != 0);
     test_assert(ecs_has(world, e, EcsComponent));
     test_assert(ecs_has_id(world, e, EcsExclusive));
-    test_assert(ecs_has_id(world, e, EcsTag));
+    test_assert(ecs_has_id(world, e, EcsPairIsTag));
 
     ecs_entity_t red = ecs_lookup_child(world, e, "Red");
     ecs_entity_t green = ecs_lookup_child(world, e, "Green");
@@ -221,7 +221,7 @@ void EnumTypes_enum_relation(void) {
 
     test_assert(ecs_get_typeid(world, ecs_pair(e, red)) == 0);
 
-    ecs_entity_t ent = ecs_new_id(world);
+    ecs_entity_t ent = ecs_new(world);
     ecs_add_pair(world, ent, e, red);
     test_assert( ecs_has_pair(world, ent, e, red));
 
diff --git a/test/meta/src/OpaqueTypes.c b/test/meta/src/OpaqueTypes.c
index 9e39c924e..bbdb98261 100644
--- a/test/meta/src/OpaqueTypes.c
+++ b/test/meta/src/OpaqueTypes.c
@@ -523,8 +523,8 @@ void OpaqueTypes_deser_entity_from_json(void) {
         .type.assign_entity = Opaque_entity_set
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     Opaque_entity v = { 0 };
     {
@@ -597,8 +597,8 @@ void OpaqueTypes_ser_deser_entity(void) {
         .type.assign_entity = Entity_assign
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "ent1");
-    ecs_entity_t e2 = ecs_new_entity(world, "ent2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "ent1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "ent2" });
 
     Entity v = { e1 };
     char *json = ecs_ptr_to_json(world, ecs_id(Entity), &v);
diff --git a/test/meta/src/PrimitiveTypes.c b/test/meta/src/PrimitiveTypes.c
index c4462caa8..747260db9 100644
--- a/test/meta/src/PrimitiveTypes.c
+++ b/test/meta/src/PrimitiveTypes.c
@@ -12,7 +12,7 @@ static void meta_test_primitive(
     test_assert(ct->size == size);
     test_assert(ct->alignment == alignment);
 
-    const EcsMetaType *mt = ecs_get(world, t, EcsMetaType);
+    const EcsType *mt = ecs_get(world, t, EcsType);
     test_assert(mt != NULL);
     test_assert(mt->kind == EcsPrimitiveType);
 
@@ -51,7 +51,7 @@ meta_test_type(EcsId, id)
 void PrimitiveTypes_bool(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsBool});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsBool}));
     test_assert(t != 0);
 
     meta_test_bool(world, t);
@@ -62,7 +62,7 @@ void PrimitiveTypes_bool(void) {
 void PrimitiveTypes_byte(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsByte});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsByte}));
     test_assert(t != 0);
 
     meta_test_byte(world, t);
@@ -73,7 +73,7 @@ void PrimitiveTypes_byte(void) {
 void PrimitiveTypes_char(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsChar});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsChar}));
     test_assert(t != 0);
 
     meta_test_char(world, t);
@@ -84,7 +84,7 @@ void PrimitiveTypes_char(void) {
 void PrimitiveTypes_i8(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsI8});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsI8}));
     test_assert(t != 0);
 
     meta_test_i8(world, t);
@@ -95,7 +95,7 @@ void PrimitiveTypes_i8(void) {
 void PrimitiveTypes_i16(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsI16});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsI16}));
     test_assert(t != 0);
 
     meta_test_i16(world, t);
@@ -106,7 +106,7 @@ void PrimitiveTypes_i16(void) {
 void PrimitiveTypes_i32(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsI32});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsI32}));
     test_assert(t != 0);
 
     meta_test_i32(world, t);
@@ -117,7 +117,7 @@ void PrimitiveTypes_i32(void) {
 void PrimitiveTypes_i64(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsI64});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsI64}));
     test_assert(t != 0);
 
     meta_test_i64(world, t);
@@ -128,7 +128,7 @@ void PrimitiveTypes_i64(void) {
 void PrimitiveTypes_iptr(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsIPtr});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsIPtr}));
     test_assert(t != 0);
 
     meta_test_iptr(world, t);
@@ -139,7 +139,7 @@ void PrimitiveTypes_iptr(void) {
 void PrimitiveTypes_u8(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsU8});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsU8}));
     test_assert(t != 0);
 
     meta_test_u8(world, t);
@@ -150,7 +150,7 @@ void PrimitiveTypes_u8(void) {
 void PrimitiveTypes_u16(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsU16});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsU16}));
     test_assert(t != 0);
 
     meta_test_u16(world, t);
@@ -161,7 +161,7 @@ void PrimitiveTypes_u16(void) {
 void PrimitiveTypes_u32(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsU32});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsU32}));
     test_assert(t != 0);
 
     meta_test_u32(world, t);
@@ -172,7 +172,7 @@ void PrimitiveTypes_u32(void) {
 void PrimitiveTypes_u64(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsU64});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsU64}));
     test_assert(t != 0);
 
     meta_test_u64(world, t);
@@ -183,7 +183,7 @@ void PrimitiveTypes_u64(void) {
 void PrimitiveTypes_uptr(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsUPtr});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsUPtr}));
     test_assert(t != 0);
 
     meta_test_uptr(world, t);
@@ -194,7 +194,7 @@ void PrimitiveTypes_uptr(void) {
 void PrimitiveTypes_float(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsF32});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsF32}));
     test_assert(t != 0);
 
     meta_test_f32(world, t);
@@ -205,7 +205,7 @@ void PrimitiveTypes_float(void) {
 void PrimitiveTypes_double(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsF64});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsF64}));
     test_assert(t != 0);
 
     meta_test_f64(world, t);
@@ -216,7 +216,7 @@ void PrimitiveTypes_double(void) {
 void PrimitiveTypes_string(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsString});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsString}));
     test_assert(t != 0);
 
     meta_test_string(world, t);
@@ -227,7 +227,7 @@ void PrimitiveTypes_string(void) {
 void PrimitiveTypes_entity(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsEntity});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsEntity}));
     test_assert(t != 0);
 
     meta_test_entity(world, t);
@@ -238,7 +238,7 @@ void PrimitiveTypes_entity(void) {
 void PrimitiveTypes_id(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_set(world, 0, EcsPrimitive, {.kind = EcsId});
+    ecs_entity_t t = ecs_insert(world, ecs_value(EcsPrimitive, {.kind = EcsId}));
     test_assert(t != 0);
 
     meta_test_id(world, t);
@@ -505,7 +505,7 @@ void PrimitiveTypes_primitive_init(void) {
     test_assert(prim_ptr != NULL);
     test_int(prim_ptr->kind, EcsU16);
 
-    const EcsMetaType *type_ptr = ecs_get(world, t, EcsMetaType);
+    const EcsType *type_ptr = ecs_get(world, t, EcsType);
     test_assert(type_ptr != NULL);
     test_int(type_ptr->kind, EcsPrimitiveType);
 
@@ -527,7 +527,7 @@ void PrimitiveTypes_primitive_w_short_notation(void) {
     test_assert(prim_ptr != NULL);
     test_int(prim_ptr->kind, EcsU16);
 
-    const EcsMetaType *type_ptr = ecs_get(world, t, EcsMetaType);
+    const EcsType *type_ptr = ecs_get(world, t, EcsType);
     test_assert(type_ptr != NULL);
     test_int(type_ptr->kind, EcsPrimitiveType);
 
diff --git a/test/meta/src/SerializeEntityToJson.c b/test/meta/src/SerializeEntityToJson.c
index c94085967..f4ffc93e1 100644
--- a/test/meta/src/SerializeEntityToJson.c
+++ b/test/meta/src/SerializeEntityToJson.c
@@ -6,7 +6,7 @@
 void SerializeEntityToJson_serialize_empty(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
 
     char *str = ecs_os_strdup("{\"path\":\"446\", \"ids\":[]}");
     ecs_os_sprintf(
@@ -24,7 +24,7 @@ void SerializeEntityToJson_serialize_empty(void) {
 void SerializeEntityToJson_serialize_w_name(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
 
     char *json = ecs_entity_to_json(world, e, NULL);
     test_assert(json != NULL);
@@ -39,7 +39,7 @@ void SerializeEntityToJson_serialize_w_name_1_tag(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
 
     char *json = ecs_entity_to_json(world, e, NULL);
@@ -56,7 +56,7 @@ void SerializeEntityToJson_serialize_w_name_2_tags(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
 
@@ -75,7 +75,7 @@ void SerializeEntityToJson_serialize_w_name_1_pair(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Obj);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add_pair(world, e, Rel, Obj);
 
     char *json = ecs_entity_to_json(world, e, NULL);
@@ -93,10 +93,10 @@ void SerializeEntityToJson_serialize_w_base(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t base = ecs_new_entity(world, "Base");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base" });
     ecs_add(world, base, TagA);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add_pair(world, e, EcsIsA, base);
     ecs_add(world, e, TagB);
 
@@ -119,10 +119,10 @@ void SerializeEntityToJson_serialize_w_base_override(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t base = ecs_new_entity(world, "Base");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base" });
     ecs_add(world, base, TagA);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add_pair(world, e, EcsIsA, base);
     ecs_add(world, e, TagA);
     ecs_add(world, e, TagB);
@@ -150,10 +150,10 @@ void SerializeEntityToJson_serialize_w_2_base(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t base_a = ecs_new_entity(world, "BaseA");
-    ecs_entity_t base_b = ecs_new_entity(world, "BaseB");
+    ecs_entity_t base_a = ecs_entity(world, { .name = "BaseA" });
+    ecs_entity_t base_b = ecs_entity(world, { .name = "BaseB" });
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add_pair(world, e, EcsIsA, base_a);
     ecs_add_pair(world, e, EcsIsA, base_b);
 
@@ -177,11 +177,11 @@ void SerializeEntityToJson_serialize_w_nested_base(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t base_of_base = ecs_new_entity(world, "BaseOfBase");
-    ecs_entity_t base = ecs_new_entity(world, "Base");
+    ecs_entity_t base_of_base = ecs_entity(world, { .name = "BaseOfBase" });
+    ecs_entity_t base = ecs_entity(world, { .name = "Base" });
     ecs_add_pair(world, base, EcsIsA, base_of_base);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add_pair(world, e, EcsIsA, base);
 
     char *json = ecs_entity_to_json(world, e, NULL);
@@ -209,7 +209,7 @@ void SerializeEntityToJson_serialize_w_1_component(void) {
         }
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, Position, {10, 20});
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -246,7 +246,7 @@ void SerializeEntityToJson_serialize_w_2_components(void) {
         }
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, Position, {10, 20});
     ecs_set(world, e, Mass, {1234});
 
@@ -269,7 +269,7 @@ void SerializeEntityToJson_serialize_w_2_components(void) {
 void SerializeEntityToJson_serialize_w_primitive_component(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, ecs_i32_t, {10});
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -304,7 +304,7 @@ void SerializeEntityToJson_serialize_w_enum_component(void) {
 
     test_assert(ecs_id(Color) != 0);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, Color, {1});
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -349,7 +349,7 @@ void SerializeEntityToJson_serialize_w_struct_and_enum_component(void) {
 
     test_assert(ecs_id(Color) != 0);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, Color, {1});
     ecs_set(world, e, Position, {10, 20});
 
@@ -385,7 +385,7 @@ void SerializeEntityToJson_serialize_w_invalid_enum_component(void) {
 
     test_assert(ecs_id(Color) != 0);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, Color, {100});
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -409,7 +409,7 @@ void SerializeEntityToJson_serialize_w_type_info(void) {
         }
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, Position, {10, 20});
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -451,7 +451,7 @@ void SerializeEntityToJson_serialize_w_type_info_unit(void) {
     });
     test_assert(ecs_id(T) != 0);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, T, {24});
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -501,7 +501,7 @@ void SerializeEntityToJson_serialize_w_type_info_unit_quantity(void) {
     });
     test_assert(ecs_id(T) != 0);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, T, {24});
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -559,7 +559,7 @@ void SerializeEntityToJson_serialize_w_type_info_unit_over(void) {
     });
     test_assert(ecs_id(T) != 0);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e, T, {24});
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -590,7 +590,7 @@ void SerializeEntityToJson_serialize_wo_private(void) {
 
     ecs_add_id(world, Tag, EcsPrivate);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
 
     char *json = ecs_entity_to_json(world, e, NULL);
@@ -611,7 +611,7 @@ void SerializeEntityToJson_serialize_w_private(void) {
 
     ecs_add_id(world, Tag, EcsPrivate);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -634,7 +634,7 @@ void SerializeEntityToJson_serialize_w_label(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
     ecs_doc_set_name(world, e, "My name");
 
@@ -660,7 +660,7 @@ void SerializeEntityToJson_serialize_w_label_no_name(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     ecs_add(world, e, Tag);
 
     char *str = ecs_os_malloc(
@@ -699,7 +699,7 @@ void SerializeEntityToJson_serialize_w_id_labels(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
     ecs_doc_set_name(world, Tag, "My tag");
 
@@ -727,7 +727,7 @@ void SerializeEntityToJson_serialize_w_brief(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
     ecs_doc_set_brief(world, e, "Brief description");
 
@@ -753,7 +753,7 @@ void SerializeEntityToJson_serialize_w_brief_no_brief(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -777,7 +777,7 @@ void SerializeEntityToJson_serialize_w_link(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
     ecs_doc_set_link(world, e, "Link");
 
@@ -803,7 +803,7 @@ void SerializeEntityToJson_serialize_w_link_no_link(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -827,7 +827,7 @@ void SerializeEntityToJson_serialize_color(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
     ecs_doc_set_color(world, e, "#47B576");
 
@@ -848,135 +848,13 @@ void SerializeEntityToJson_serialize_color(void) {
     ecs_fini(world);
 }
 
-void SerializeEntityToJson_serialize_union_relationship(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Walking);
-
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
-    ecs_add_pair(world, e, Movement, Running);
-
-    ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
-    char *json = ecs_entity_to_json(world, e, &desc);
-    test_assert(json != NULL);
-
-    test_str(json, "{"
-        "\"path\":\"Foo\", "
-        "\"ids\":["
-            "[\"Movement\", \"Running\"]"
-        "]}");
-
-    ecs_os_free(json);
-
-    ecs_fini(world);
-}
-
-void SerializeEntityToJson_serialize_union_relationship_invalid_entity(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ecs_entity_t Running = ecs_new_entity(world, "Running");
-
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
-    ecs_add_pair(world, e, Movement, Running);
-    ecs_delete(world, Running);
-
-    ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
-    char *json = ecs_entity_to_json(world, e, &desc);
-    test_assert(json != NULL);
-
-    test_str(json, "{"
-        "\"path\":\"Foo\", "
-        "\"ids\":[]}");
-
-    ecs_os_free(json);
-
-    ecs_fini(world);
-}
-
-void SerializeEntityToJson_serialize_union_relationship_invalid_entity_w_labels(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ecs_entity_t Running = ecs_new_entity(world, "Running");
-
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
-    ecs_add_pair(world, e, Movement, Running);
-    ecs_delete(world, Running);
-
-    ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
-    desc.serialize_id_labels = true;
-    char *json = ecs_entity_to_json(world, e, &desc);
-    test_assert(json != NULL);
-
-    test_str(json, "{"
-        "\"path\":\"Foo\", "
-        "\"ids\":[], "
-        "\"id_labels\":[]}");
-
-    ecs_os_free(json);
-
-    ecs_fini(world);
-}
-
-void SerializeEntityToJson_serialize_w_union_property(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-
-    ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
-    char *json = ecs_entity_to_json(world, Movement, &desc);
-    test_assert(json != NULL);
-
-    test_str(json, "{"
-        "\"path\":\"Movement\", "
-        "\"ids\":["
-            "[\"flecs.core.Union\"]"
-        "]}");
-
-    ecs_os_free(json);
-
-    ecs_fini(world);
-}
-
-void SerializeEntityToJson_serialize_union_relationship_w_labels(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_ENTITY(world, Movement, Union);
-    ECS_TAG(world, Running);
-    ECS_TAG(world, Walking);
-
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
-    ecs_add_pair(world, e, Movement, Running);
-
-    ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
-    desc.serialize_id_labels = true;
-    char *json = ecs_entity_to_json(world, e, &desc);
-    test_assert(json != NULL);
-
-    test_str(json, "{"
-        "\"path\":\"Foo\", "
-        "\"ids\":["
-            "[\"Movement\", \"Running\"]"
-        "], "
-        "\"id_labels\":["
-            "[\"Movement\", \"Running\"]"
-        "]}");
-
-    ecs_os_free(json);
-
-    ecs_fini(world);
-}
-
 void SerializeEntityToJson_serialize_w_doc_w_quotes(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t p = ecs_new_entity(world, "Parent");
-    ecs_entity_t e = ecs_new_entity(world, "Child");
+    ecs_entity_t p = ecs_entity(world, { .name = "Parent" });
+    ecs_entity_t e = ecs_entity(world, { .name = "Child" });
     ecs_add(world, e, Tag);
     ecs_add_pair(world, e, EcsChildOf, p);
     ecs_doc_set_name(world, e, "Doc \"name\"");
@@ -1026,12 +904,12 @@ void SerializeEntityToJson_serialize_w_1_alert(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .message = "$this has Position but not Velocity"
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
     ecs_progress(world, 1.0); /* Evaluate alert logic */
@@ -1070,18 +948,18 @@ void SerializeEntityToJson_serialize_w_2_alerts(void) {
     ECS_COMPONENT(world, Mass);
 
     ecs_entity_t alert_1 = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .message = "$this has Position but not Velocity"
     });
 
     ecs_entity_t alert_2 = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_mass"),
-        .filter.expr = "Position, !Mass",
+        .entity = ecs_entity(world, { .name = "position_without_mass" }),
+        .query.expr = "Position, !Mass",
         .message = "$this has Position but not Mass"
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
     ecs_progress(world, 1.0); /* Evaluate alert logic */
@@ -1100,19 +978,34 @@ void SerializeEntityToJson_serialize_w_2_alerts(void) {
     char *json = ecs_entity_to_json(world, e1, &desc);
     test_assert(json != NULL);
 
+    // test_str(json, "{"
+    //     "\"path\":\"e1\", "
+    //     "\"ids\":[[\"Position\"]], "
+    //     "\"alerts\":[{"
+    //         "\"alert\":\"position_without_mass.e1_alert_2\", "
+    //         "\"message\":\"e1 has Position but not Mass\", "
+    //         "\"severity\":\"Error\""
+    //     "}, {"
+    //         "\"alert\":\"position_without_velocity.e1_alert_1\", "
+    //         "\"message\":\"e1 has Position but not Velocity\", "
+    //         "\"severity\":\"Error\""
+    //     "}]"
+    // "}");
+
     test_str(json, "{"
         "\"path\":\"e1\", "
         "\"ids\":[[\"Position\"]], "
         "\"alerts\":[{"
-            "\"alert\":\"position_without_mass.e1_alert_2\", "
-            "\"message\":\"e1 has Position but not Mass\", "
-            "\"severity\":\"Error\""
-        "}, {"
             "\"alert\":\"position_without_velocity.e1_alert_1\", "
             "\"message\":\"e1 has Position but not Velocity\", "
             "\"severity\":\"Error\""
+        "}, {"
+            "\"alert\":\"position_without_mass.e1_alert_2\", "
+            "\"message\":\"e1 has Position but not Mass\", "
+            "\"severity\":\"Error\""
         "}]"
     "}");
+
     ecs_os_free(json);
 
     ecs_fini(world);
@@ -1127,23 +1020,23 @@ void SerializeEntityToJson_serialize_w_child_alerts(void) {
     ECS_COMPONENT(world, Velocity);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .message = "$this has Position but not Velocity"
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_entity_t child_1 = ecs_new_entity(world, "child1");
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child1" });
     ecs_set(world, child_1, Position, {10, 20});
     ecs_add_pair(world, child_1, EcsChildOf, e1);
 
-    ecs_entity_t child_2 = ecs_new_entity(world, "child2");
+    ecs_entity_t child_2 = ecs_entity(world, { .name = "child2" });
     ecs_set(world, child_2, Position, {10, 20});
     ecs_add_pair(world, child_2, EcsChildOf, e1);
 
-    ecs_entity_t grandchild_1 = ecs_new_entity(world, "grandchild1");
+    ecs_entity_t grandchild_1 = ecs_entity(world, { .name = "grandchild1" });
     ecs_set(world, grandchild_1, Position, {10, 20});
     ecs_add_pair(world, grandchild_1, EcsChildOf, child_1);
 
@@ -1210,8 +1103,8 @@ void SerializeEntityToJson_serialize_w_severity_filter_alert(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
         .message = "$this has Position but not Velocity",
         .severity_filters[0] = {
             .severity = EcsAlertWarning,
@@ -1219,7 +1112,7 @@ void SerializeEntityToJson_serialize_w_severity_filter_alert(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
     ecs_add(world, e1, Tag);
 
@@ -1254,7 +1147,7 @@ void SerializeEntityToJson_serialize_w_alerts_not_imported(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
     ecs_new_w_pair(world, EcsChildOf, e1);
 
@@ -1282,11 +1175,11 @@ void SerializeEntityToJson_serialize_w_alerts_no_message(void) {
     ECS_TAG(world, Tag);
 
     ecs_entity_t alert = ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity"
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity"
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {10, 20});
     ecs_add(world, e1, Tag);
 
@@ -1320,15 +1213,15 @@ void SerializeEntityToJson_serialize_refs_childof(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_entity_t child_1 = ecs_new_entity(world, "child1");
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child1" });
     ecs_add_pair(world, child_1, EcsChildOf, e1);
 
-    ecs_entity_t child_2 = ecs_new_entity(world, "child2");
+    ecs_entity_t child_2 = ecs_entity(world, { .name = "child2" });
     ecs_add_pair(world, child_2, EcsChildOf, e1);
 
-    ecs_entity_t child_3 = ecs_new_entity(world, "child3");
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child3" });
     ecs_add_pair(world, child_3, Rel, e1);
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -1356,15 +1249,15 @@ void SerializeEntityToJson_serialize_refs_custom(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_entity_t child_1 = ecs_new_entity(world, "child1");
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child1" });
     ecs_add_pair(world, child_1, Rel, e1);
 
-    ecs_entity_t child_2 = ecs_new_entity(world, "child2");
+    ecs_entity_t child_2 = ecs_entity(world, { .name = "child2" });
     ecs_add_pair(world, child_2, Rel, e1);
 
-    ecs_entity_t child_3 = ecs_new_entity(world, "child3");
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child3" });
     ecs_add_pair(world, child_3, EcsChildOf, e1);
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -1392,15 +1285,15 @@ void SerializeEntityToJson_serialize_refs_wildcard(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_entity_t child_1 = ecs_new_entity(world, "child1");
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child1" });
     ecs_add_pair(world, child_1, Rel, e1);
 
-    ecs_entity_t child_2 = ecs_new_entity(world, "child2");
+    ecs_entity_t child_2 = ecs_entity(world, { .name = "child2" });
     ecs_add_pair(world, child_2, Rel, e1);
 
-    ecs_entity_t child_3 = ecs_new_entity(world, "child3");
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child3" });
     ecs_add_pair(world, child_3, EcsChildOf, e1);
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -1431,7 +1324,7 @@ void SerializeEntityToJson_serialize_no_ids(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add(world, e, Tag);
 
     ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
@@ -1451,24 +1344,24 @@ void SerializeEntityToJson_serialize_matches_filter(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, TagC);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, TagA);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add(world, e2, TagB);
 
-    ecs_filter_t *f_a = ecs_filter(world, {
+    ecs_query_t *f_a = ecs_query(world, {
         .entity = ecs_entity(world, { .name = "f_a"} ),
         .terms = {{ TagA }}
     });
     test_assert(f_a != NULL);
 
-    ecs_filter_t *f_b = ecs_filter(world, {
+    ecs_query_t *f_b = ecs_query(world, {
         .entity = ecs_entity(world, { .name = "f_b"} ),
         .terms = {{ TagB }}
     });
     test_assert(f_b != NULL);
 
-    ecs_filter_t *f_c = ecs_filter(world, {
+    ecs_query_t *f_c = ecs_query(world, {
         .entity = ecs_entity(world, { .name = "f_c"} ),
         .terms = {{ TagC }}
     });
@@ -1487,9 +1380,9 @@ void SerializeEntityToJson_serialize_matches_filter(void) {
         "}");
     ecs_os_free(json);
 
-    ecs_filter_fini(f_a);
-    ecs_filter_fini(f_b);
-    ecs_filter_fini(f_c);
+    ecs_query_fini(f_a);
+    ecs_query_fini(f_b);
+    ecs_query_fini(f_c);
 
     ecs_fini(world);
 }
@@ -1501,26 +1394,26 @@ void SerializeEntityToJson_serialize_matches_query(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, TagC);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, TagA);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add(world, e2, TagB);
 
     ecs_query_t *f_a = ecs_query(world, {
-        .filter.entity = ecs_entity(world, { .name = "f_a"} ),
-        .filter.terms = {{ TagA }}
+        .entity = ecs_entity(world, { .name = "f_a"} ),
+        .terms = {{ TagA }}
     });
     test_assert(f_a != NULL);
 
     ecs_query_t *f_b = ecs_query(world, {
-        .filter.entity = ecs_entity(world, { .name = "f_b"} ),
-        .filter.terms = {{ TagB }}
+        .entity = ecs_entity(world, { .name = "f_b"} ),
+        .terms = {{ TagB }}
     });
     test_assert(f_b != NULL);
 
     ecs_query_t *f_c = ecs_query(world, {
-        .filter.entity = ecs_entity(world, { .name = "f_c"} ),
-        .filter.terms = {{ TagC }}
+        .entity = ecs_entity(world, { .name = "f_c"} ),
+        .terms = {{ TagC }}
     });
     test_assert(f_c != NULL);
 
@@ -1551,24 +1444,24 @@ void SerializeEntityToJson_serialize_matches_rule(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, TagC);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, TagA);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add(world, e2, TagB);
 
-    ecs_rule_t *f_a = ecs_rule(world, {
+    ecs_query_t *f_a = ecs_query(world, {
         .entity = ecs_entity(world, { .name = "f_a"} ),
         .terms = {{ TagA }}
     });
     test_assert(f_a != NULL);
 
-    ecs_rule_t *f_b = ecs_rule(world, {
+    ecs_query_t *f_b = ecs_query(world, {
         .entity = ecs_entity(world, { .name = "f_b"} ),
         .terms = {{ TagB }}
     });
     test_assert(f_b != NULL);
 
-    ecs_rule_t *f_c = ecs_rule(world, {
+    ecs_query_t *f_c = ecs_query(world, {
         .entity = ecs_entity(world, { .name = "f_c"} ),
         .terms = {{ TagC }}
     });
@@ -1587,9 +1480,9 @@ void SerializeEntityToJson_serialize_matches_rule(void) {
         "}");
     ecs_os_free(json);
 
-    ecs_rule_fini(f_a);
-    ecs_rule_fini(f_b);
-    ecs_rule_fini(f_c);
+    ecs_query_fini(f_a);
+    ecs_query_fini(f_b);
+    ecs_query_fini(f_c);
 
     ecs_fini(world);
 }
@@ -1601,18 +1494,18 @@ void SerializeEntityToJson_serialize_no_matches(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, TagC);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, TagA);
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add(world, e2, TagB);
 
-    ecs_filter_t *f_b = ecs_filter(world, {
+    ecs_query_t *f_b = ecs_query(world, {
         .entity = ecs_entity(world, { .name = "f_b"} ),
         .terms = {{ TagB }}
     });
     test_assert(f_b != NULL);
 
-    ecs_filter_t *f_c = ecs_filter(world, {
+    ecs_query_t *f_c = ecs_query(world, {
         .entity = ecs_entity(world, { .name = "f_c"} ),
         .terms = {{ TagC }}
     });
@@ -1630,8 +1523,8 @@ void SerializeEntityToJson_serialize_no_matches(void) {
         "}");
     ecs_os_free(json);
 
-    ecs_filter_fini(f_b);
-    ecs_filter_fini(f_c);
+    ecs_query_fini(f_b);
+    ecs_query_fini(f_c);
 
     ecs_fini(world);
 }
diff --git a/test/meta/src/SerializeIterToJson.c b/test/meta/src/SerializeIterToJson.c
index 3fd7018e7..372fa8a86 100644
--- a/test/meta/src/SerializeIterToJson.c
+++ b/test/meta/src/SerializeIterToJson.c
@@ -16,15 +16,17 @@ void SerializeIterToJson_serialize_1_comps_empty(void) {
         }
     });
 
-    ecs_query_t *q = ecs_query_new(world, "Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_assert(json != NULL);
     test_str(json, "{\"ids\":[[\"Position\"]], \"results\":[]}");
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -41,16 +43,16 @@ void SerializeIterToJson_serialize_1_comps_2_ents_same_table(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
 
-    ecs_query_t *q = ecs_query_new(world, "Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Position\"]], "
@@ -69,6 +71,8 @@ void SerializeIterToJson_serialize_1_comps_2_ents_same_table(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -93,8 +97,8 @@ void SerializeIterToJson_serialize_2_comps_2_ents_same_table(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
@@ -102,10 +106,10 @@ void SerializeIterToJson_serialize_2_comps_2_ents_same_table(void) {
     ecs_set(world, e1, Mass, {1});
     ecs_set(world, e2, Mass, {2});
 
-    ecs_query_t *q = ecs_query_new(world, "Position, Mass");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Mass" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Position\"], [\"Mass\"]], "
@@ -127,6 +131,8 @@ void SerializeIterToJson_serialize_2_comps_2_ents_same_table(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -135,16 +141,16 @@ void SerializeIterToJson_serialize_1_tag_2_ents_same_table(void) {
 
     ECS_TAG(world, MyTag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add(world, e1, MyTag);
     ecs_add(world, e2, MyTag);
 
-    ecs_query_t *q = ecs_query_new(world, "MyTag");
+    ecs_query_t *q = ecs_query(world, { .expr = "MyTag" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"MyTag\"]], "
@@ -159,6 +165,8 @@ void SerializeIterToJson_serialize_1_tag_2_ents_same_table(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -176,8 +184,8 @@ void SerializeIterToJson_serialize_1_tag_1_comp_2_ents_same_table(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
@@ -185,10 +193,10 @@ void SerializeIterToJson_serialize_1_tag_1_comp_2_ents_same_table(void) {
     ecs_add(world, e1, MyTag);
     ecs_add(world, e2, MyTag);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, MyTag");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, MyTag" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Position\"], [\"MyTag\"]], "
@@ -207,6 +215,8 @@ void SerializeIterToJson_serialize_1_tag_1_comp_2_ents_same_table(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -225,10 +235,10 @@ void SerializeIterToJson_serialize_1_tag_1_comp_4_ents_two_tables(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
-    ecs_entity_t e3 = ecs_new_entity(world, "Hello");
-    ecs_entity_t e4 = ecs_new_entity(world, "World");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "Hello" });
+    ecs_entity_t e4 = ecs_entity(world, { .name = "World" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {30, 40});
@@ -244,10 +254,10 @@ void SerializeIterToJson_serialize_1_tag_1_comp_4_ents_two_tables(void) {
     ecs_add(world, e3, TagB);
     ecs_add(world, e4, TagB);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, TagA");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, TagA" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Position\"], [\"TagA\"]], "
@@ -276,6 +286,8 @@ void SerializeIterToJson_serialize_1_tag_1_comp_4_ents_two_tables(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -300,9 +312,9 @@ void SerializeIterToJson_serialize_2_comps_1_owned_2_ents(void) {
         }
     });
 
-    ecs_entity_t base = ecs_new_entity(world, "Base");
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t base = ecs_entity(world, { .name = "Base" });
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_set(world, base, Mass, {100});
     ecs_set(world, e1, Position, {10, 20});
@@ -311,10 +323,10 @@ void SerializeIterToJson_serialize_2_comps_1_owned_2_ents(void) {
     ecs_add_pair(world, e1, EcsIsA, base);
     ecs_add_pair(world, e2, EcsIsA, base);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, Mass(up)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Mass(up IsA)" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Position\"], [\"Mass\"]], "
@@ -335,6 +347,8 @@ void SerializeIterToJson_serialize_2_comps_1_owned_2_ents(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -345,16 +359,16 @@ void SerializeIterToJson_serialize_w_pair_wildcard(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add_pair(world, e1, Rel, ObjA);
     ecs_add_pair(world, e2, Rel, ObjB);
 
-    ecs_query_t *q = ecs_query_new(world, "(Rel, *)");
+    ecs_query_t *q = ecs_query(world, { .expr = "(Rel, *)" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Rel\",\"*\"]], "
@@ -375,6 +389,8 @@ void SerializeIterToJson_serialize_w_pair_wildcard(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -385,19 +401,19 @@ void SerializeIterToJson_serialize_w_var(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add_pair(world, e1, Rel, ObjA);
     ecs_add_pair(world, e2, Rel, ObjB);
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Rel, $X)"
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Rel\",\"*\"]], "
@@ -421,7 +437,7 @@ void SerializeIterToJson_serialize_w_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -437,8 +453,8 @@ void SerializeIterToJson_serialize_w_2_vars(void) {
     ECS_TAG(world, ObjC);
     ECS_TAG(world, ObjD);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add_pair(world, e1, RelX, ObjA);
     ecs_add_pair(world, e2, RelX, ObjB);
@@ -446,13 +462,13 @@ void SerializeIterToJson_serialize_w_2_vars(void) {
     ecs_add_pair(world, e1, RelY, ObjC);
     ecs_add_pair(world, e2, RelY, ObjD);
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(RelX, $X), (RelY, $Y)"
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"RelX\",\"*\"], [\"RelY\",\"*\"]], "
@@ -476,7 +492,7 @@ void SerializeIterToJson_serialize_w_2_vars(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -486,18 +502,18 @@ void SerializeIterToJson_serialize_type_info_1_tags(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
 
-    ecs_query_t *q = ecs_query_new(world, "TagA");
+    ecs_query_t *q = ecs_query(world, { .expr = "TagA" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -513,6 +529,8 @@ void SerializeIterToJson_serialize_type_info_1_tags(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -522,20 +540,20 @@ void SerializeIterToJson_serialize_type_info_2_tags(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e1, TagB);
     ecs_add(world, e2, TagA);
     ecs_add(world, e2, TagB);
 
-    ecs_query_t *q = ecs_query_new(world, "TagA, TagB");
+    ecs_query_t *q = ecs_query(world, { .expr = "TagA, TagB" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -551,6 +569,8 @@ void SerializeIterToJson_serialize_type_info_2_tags(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -559,18 +579,18 @@ void SerializeIterToJson_serialize_type_info_1_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
 
-    ecs_query_t *q = ecs_query_new(world, "Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -588,6 +608,8 @@ void SerializeIterToJson_serialize_type_info_1_component(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -597,8 +619,8 @@ void SerializeIterToJson_serialize_type_info_2_components(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -606,12 +628,12 @@ void SerializeIterToJson_serialize_type_info_2_components(void) {
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Velocity" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -629,6 +651,8 @@ void SerializeIterToJson_serialize_type_info_2_components(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -647,18 +671,18 @@ void SerializeIterToJson_serialize_type_info_1_struct(void) {
 
     test_assert(t == ecs_id(Position));
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
 
-    ecs_query_t *q = ecs_query_new(world, "Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -679,6 +703,8 @@ void SerializeIterToJson_serialize_type_info_1_struct(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -698,8 +724,8 @@ void SerializeIterToJson_serialize_type_info_1_component_1_struct(void) {
 
     test_assert(t == ecs_id(Position));
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -707,12 +733,12 @@ void SerializeIterToJson_serialize_type_info_1_component_1_struct(void) {
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Velocity" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -736,6 +762,8 @@ void SerializeIterToJson_serialize_type_info_1_component_1_struct(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -763,8 +791,8 @@ void SerializeIterToJson_serialize_type_info_2_structs(void) {
     });
     test_assert(t == ecs_id(Velocity));
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
@@ -772,12 +800,12 @@ void SerializeIterToJson_serialize_type_info_2_structs(void) {
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, Velocity");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, Velocity" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -804,6 +832,8 @@ void SerializeIterToJson_serialize_type_info_2_structs(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -828,18 +858,18 @@ void SerializeIterToJson_serialize_type_info_w_unit(void) {
     });
     test_assert(ecs_id(T) != 0);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_set(world, e1, T, {24});
     ecs_set(world, e2, T, {16});
 
-    ecs_query_t *q = ecs_query_new(world, "T");
+    ecs_query_t *q = ecs_query(world, { .expr = "T" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -864,6 +894,8 @@ void SerializeIterToJson_serialize_type_info_w_unit(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -894,18 +926,18 @@ void SerializeIterToJson_serialize_type_info_w_unit_quantity(void) {
     });
     test_assert(ecs_id(T) != 0);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_set(world, e1, T, {24});
     ecs_set(world, e2, T, {16});
 
-    ecs_query_t *q = ecs_query_new(world, "T");
+    ecs_query_t *q = ecs_query(world, { .expr = "T" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -930,6 +962,8 @@ void SerializeIterToJson_serialize_type_info_w_unit_quantity(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -967,18 +1001,18 @@ void SerializeIterToJson_serialize_type_info_w_unit_over(void) {
     });
     test_assert(ecs_id(T) != 0);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_set(world, e1, T, {24});
     ecs_set(world, e2, T, {16});
 
-    ecs_query_t *q = ecs_query_new(world, "T");
+    ecs_query_t *q = ecs_query(world, { .expr = "T" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -1003,6 +1037,8 @@ void SerializeIterToJson_serialize_type_info_w_unit_over(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1011,19 +1047,19 @@ void SerializeIterToJson_serialize_w_entity_label(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "foo_bar");
-    ecs_entity_t e2 = ecs_new_entity(world, "hello_world");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "foo_bar" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "hello_world" });
     ecs_doc_set_name(world, e2, "Hello World");
 
     ecs_add(world, e1, Tag);
     ecs_add(world, e2, Tag);
 
-    ecs_query_t *q = ecs_query_new(world, "Tag");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_entity_labels = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -1048,6 +1084,8 @@ void SerializeIterToJson_serialize_w_entity_label(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1056,19 +1094,19 @@ void SerializeIterToJson_serialize_w_entity_label_w_str(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "foo_bar");
-    ecs_entity_t e2 = ecs_new_entity(world, "hello_world");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "foo_bar" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "hello_world" });
     ecs_doc_set_name(world, e2, "Hello \"World\"");
 
     ecs_add(world, e1, Tag);
     ecs_add(world, e2, Tag);
 
-    ecs_query_t *q = ecs_query_new(world, "Tag");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_entity_labels = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -1093,6 +1131,8 @@ void SerializeIterToJson_serialize_w_entity_label_w_str(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1103,23 +1143,23 @@ void SerializeIterToJson_serialize_w_var_labels(void) {
     ECS_TAG(world, ObjA);
     ECS_TAG(world, ObjB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
-    ecs_entity_t e2 = ecs_new_entity(world, "Bar");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "Bar" });
 
     ecs_add_pair(world, e1, Rel, ObjA);
     ecs_add_pair(world, e2, Rel, ObjB);
 
     ecs_doc_set_name(world, ObjA, "Object A");
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Rel, $X)"
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_variable_labels = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -1146,7 +1186,7 @@ void SerializeIterToJson_serialize_w_var_labels(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -1156,19 +1196,19 @@ void SerializeIterToJson_serialize_color(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "foo_bar");
-    ecs_entity_t e2 = ecs_new_entity(world, "hello_world");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "foo_bar" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "hello_world" });
     ecs_doc_set_color(world, e2, "#47B576");
 
     ecs_add(world, e1, Tag);
     ecs_add(world, e2, Tag);
 
-    ecs_query_t *q = ecs_query_new(world, "Tag");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_colors = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
     "{"
@@ -1193,6 +1233,8 @@ void SerializeIterToJson_serialize_color(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1213,17 +1255,17 @@ void SerializeIterToJson_serialize_w_var_component(void) {
         }
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "Foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "Foo" });
     ecs_add_pair(world, e, Rel, Obj);
     ecs_set(world, Obj, T, {10});
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Rel, $X), T($X)"
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1242,7 +1284,7 @@ void SerializeIterToJson_serialize_w_var_component(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -1253,17 +1295,17 @@ void SerializeIterToJson_serialize_w_optional_tag(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_add(world, e1, TagB);
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
 
-    ecs_query_t *q = ecs_query_new(world, "TagA, ?TagB");
+    ecs_query_t *q = ecs_query(world, { .expr = "TagA, ?TagB" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1287,6 +1329,8 @@ void SerializeIterToJson_serialize_w_optional_tag(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1296,17 +1340,17 @@ void SerializeIterToJson_serialize_w_optional_component(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e1, Position);
     ecs_add(world, e2, Position);
 
-    ecs_query_t *q = ecs_query_new(world, "Position, ?Velocity");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, ?Velocity" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1332,6 +1376,8 @@ void SerializeIterToJson_serialize_w_optional_component(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1354,17 +1400,17 @@ void SerializeIterToJson_serialize_w_optional_reflected_component(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_set(world, e1, Velocity, {1, 2});
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {10, 20});
 
-    ecs_query_t *q = ecs_query_new(world, "Position, ?Velocity");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position, ?Velocity" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1390,6 +1436,8 @@ void SerializeIterToJson_serialize_w_optional_reflected_component(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1398,14 +1446,14 @@ void SerializeIterToJson_serialize_w_inout_filter_tag(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
     ecs_add(world, e1, TagA);
 
-    ecs_query_t *q = ecs_query_new(world, "[none] TagA");
+    ecs_query_t *q = ecs_query(world, { .expr = "[none] TagA" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1421,6 +1469,8 @@ void SerializeIterToJson_serialize_w_inout_filter_tag(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1438,15 +1488,15 @@ void SerializeIterToJson_serialize_w_inout_filter_component(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_query_t *q = ecs_query_new(world, "[none] Position, Velocity");
+    ecs_query_t *q = ecs_query(world, { .expr = "[none] Position, Velocity" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1463,6 +1513,8 @@ void SerializeIterToJson_serialize_w_inout_filter_component(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1488,15 +1540,15 @@ void SerializeIterToJson_serialize_w_inout_filter_reflected_component(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_query_t *q = ecs_query_new(world, "[none] Position, Velocity");
+    ecs_query_t *q = ecs_query(world, { .expr = "[none] Position, Velocity" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1513,6 +1565,8 @@ void SerializeIterToJson_serialize_w_inout_filter_reflected_component(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1521,14 +1575,14 @@ void SerializeIterToJson_serialize_w_inout_out_tag(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
     ecs_add(world, e1, TagA);
 
-    ecs_query_t *q = ecs_query_new(world, "[out] TagA");
+    ecs_query_t *q = ecs_query(world, { .expr = "[out] TagA" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1544,6 +1598,8 @@ void SerializeIterToJson_serialize_w_inout_out_tag(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1561,15 +1617,15 @@ void SerializeIterToJson_serialize_w_inout_out_component(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_query_t *q = ecs_query_new(world, "[out] Position, Velocity");
+    ecs_query_t *q = ecs_query(world, { .expr = "[out] Position, Velocity" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1586,6 +1642,8 @@ void SerializeIterToJson_serialize_w_inout_out_component(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1611,15 +1669,15 @@ void SerializeIterToJson_serialize_w_inout_out_reflected_component(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Velocity, {1, 2});
 
-    ecs_query_t *q = ecs_query_new(world, "[out] Position, Velocity");
+    ecs_query_t *q = ecs_query(world, { .expr = "[out] Position, Velocity" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1636,6 +1694,8 @@ void SerializeIterToJson_serialize_w_inout_out_reflected_component(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1653,14 +1713,14 @@ void SerializeIterToJson_serialize_component_from_var(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_rule_t *r = ecs_rule_new(world, "Position($E)");
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_query_t *r = ecs_query(world, { .expr = "Position($E)" });
+    ecs_iter_t it = ecs_query_iter(world, r);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
 
     test_str(json, 
     "{"
@@ -1676,7 +1736,7 @@ void SerializeIterToJson_serialize_component_from_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -1686,9 +1746,9 @@ void SerializeIterToJson_serialize_ids(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_new(world, "Tag");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag" });
 
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
     ecs_add(world, e, Tag);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1698,10 +1758,10 @@ void SerializeIterToJson_serialize_ids(void) {
     desc.serialize_values = false;
     desc.serialize_is_set = false;
     desc.serialize_sources = false;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"ids\":[[\"Tag\"]], \"results\":[{\"entities\":[\"e\"], \"entity_ids\":[%u]}]}",
         (uint32_t)e);
     test_str(json, expect);
@@ -1709,6 +1769,8 @@ void SerializeIterToJson_serialize_ids(void) {
     ecs_os_free(json);
     ecs_os_free(expect);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1717,12 +1779,12 @@ void SerializeIterToJson_serialize_ids_2_entities(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_new(world, "Tag");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag" });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Tag);
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add(world, e2, Tag);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1732,10 +1794,10 @@ void SerializeIterToJson_serialize_ids_2_entities(void) {
     desc.serialize_values = false;
     desc.serialize_is_set = false;
     desc.serialize_sources = false;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"ids\":[[\"Tag\"]], \"results\":[{\"entities\":[\"e1\", \"e2\"], \"entity_ids\":[%u, %u]}]}",
         (uint32_t)e1, (uint32_t)e2);
     test_str(json, expect);
@@ -1743,6 +1805,8 @@ void SerializeIterToJson_serialize_ids_2_entities(void) {
     ecs_os_free(json);
     ecs_os_free(expect);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1751,7 +1815,7 @@ void SerializeIterToJson_serialize_anonymous(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_new(world, "Tag");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag" });
 
     ecs_entity_t e1 = 5000;
     ecs_entity_t e2 = 10000;
@@ -1769,16 +1833,18 @@ void SerializeIterToJson_serialize_anonymous(void) {
     ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_entities = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"results\":[{\"entities\":[5000, 10000, 100000, 1000000]}]}");
     test_str(json, expect);
 
     ecs_os_free(json);
     ecs_os_free(expect);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1787,7 +1853,7 @@ void SerializeIterToJson_serialize_anonymous_ids(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_new(world, "Tag");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag" });
 
     ecs_entity_t e1 = 5000;
     ecs_entity_t e2 = 10000;
@@ -1805,16 +1871,18 @@ void SerializeIterToJson_serialize_anonymous_ids(void) {
     ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_entity_ids = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"results\":[{\"entity_ids\":[5000, 10000, 100000, 1000000]}]}");
     test_str(json, expect);
 
     ecs_os_free(json);
     ecs_os_free(expect);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1823,22 +1891,22 @@ void SerializeIterToJson_serialize_variable_ids(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *q = ecs_rule_new(world, "Tag($Entity)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag($Entity)" });
 
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
     ecs_add(world, e, Tag);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_ids = false;
     desc.serialize_variable_ids = true;
     desc.serialize_values = false;
     desc.serialize_is_set = false;
     desc.serialize_sources = false;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"ids\":[[\"Tag\"]], \"vars\":[\"Entity\"], \"results\":[{\"vars\":[\"e\"], \"var_ids\":[%u]}]}",
         (uint32_t)e);
     test_str(json, expect);
@@ -1846,7 +1914,7 @@ void SerializeIterToJson_serialize_variable_ids(void) {
     ecs_os_free(json);
     ecs_os_free(expect);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1856,25 +1924,25 @@ void SerializeIterToJson_serialize_variable_ids_2_entities(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *q = ecs_rule_new(world, "Tag($Entity)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag($Entity)" });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Tag);
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add(world, e2, Tag);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_ids = false;
     desc.serialize_variable_ids = true;
     desc.serialize_values = false;
     desc.serialize_is_set = false;
     desc.serialize_sources = false;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"ids\":[[\"Tag\"]], \"vars\":[\"Entity\"], \"results\":[{\"vars\":[\"e1\"], \"var_ids\":[%u]}, {\"vars\":[\"e2\"], \"var_ids\":[%u]}]}",
         (uint32_t)e1, (uint32_t)e2);
     test_str(json, expect);
@@ -1882,7 +1950,7 @@ void SerializeIterToJson_serialize_variable_ids_2_entities(void) {
     ecs_os_free(json);
     ecs_os_free(expect);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1892,22 +1960,22 @@ void SerializeIterToJson_serialize_variable_anonymous(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *q = ecs_rule_new(world, "Tag($Entity)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag($Entity)" });
 
     ecs_entity_t e = 10000;
     ecs_make_alive(world, 10000);
     ecs_add(world, e, Tag);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_ids = false;
     desc.serialize_values = false;
     desc.serialize_is_set = false;
     desc.serialize_sources = false;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"ids\":[[\"Tag\"]], \"vars\":[\"Entity\"], \"results\":[{\"vars\":[\"10000\"]}]}",
         (uint32_t)e);
     test_str(json, expect);
@@ -1915,7 +1983,7 @@ void SerializeIterToJson_serialize_variable_anonymous(void) {
     ecs_os_free(json);
     ecs_os_free(expect);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1925,13 +1993,13 @@ void SerializeIterToJson_serialize_variable_anonymous_ids(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *q = ecs_rule_new(world, "Tag($Entity)");
+    ecs_query_t *q = ecs_query(world, { .expr = "Tag($Entity)" });
 
     ecs_entity_t e = 10000;
     ecs_make_alive(world, 10000);
     ecs_add(world, e, Tag);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT;
     desc.serialize_ids = false;
     desc.serialize_variables = false;
@@ -1939,10 +2007,10 @@ void SerializeIterToJson_serialize_variable_anonymous_ids(void) {
     desc.serialize_values = false;
     desc.serialize_is_set = false;
     desc.serialize_sources = false;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"ids\":[[\"Tag\"]], \"vars\":[\"Entity\"], \"results\":[{\"var_ids\":[10000]}]}",
         (uint32_t)e);
     test_str(json, expect);
@@ -1950,7 +2018,7 @@ void SerializeIterToJson_serialize_variable_anonymous_ids(void) {
     ecs_os_free(json);
     ecs_os_free(expect);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1960,9 +2028,9 @@ void SerializeIterToJson_serialize_anonymous_tag(void) {
 
     ecs_entity_t tag = 10000;
     ecs_make_alive(world, tag);
-    ecs_query_t *q = ecs_query_new(world, "10000");
+    ecs_query_t *q = ecs_query(world, { .expr = "10000" });
 
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
     ecs_add_id(world, e, tag);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1970,16 +2038,18 @@ void SerializeIterToJson_serialize_anonymous_tag(void) {
     desc.serialize_term_ids = true;
     desc.serialize_ids = true;
     desc.serialize_entities = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"ids\":[[\"10000\"]], \"results\":[{\"ids\":[[\"10000\"]], \"entities\":[\"e\"]}]}");
     test_str(json, expect);
 
     ecs_os_free(json);
     ecs_os_free(expect);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1995,9 +2065,9 @@ void SerializeIterToJson_serialize_anonymous_component(void) {
         }
     });
 
-    ecs_query_t *q = ecs_query_new(world, "10000");
+    ecs_query_t *q = ecs_query(world, { .expr = "10000" });
 
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
     int32_t *ptr = ecs_ensure_id(world, e, tag);
     *ptr = 10;
 
@@ -2008,10 +2078,10 @@ void SerializeIterToJson_serialize_anonymous_component(void) {
     desc.serialize_entities = true;
     desc.serialize_values = true;
     desc.serialize_type_info = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"ids\":[[\"10000\"]], \"type_info\":{\"10000\":{\"value\":[\"int\"]}}, "
         "\"results\":[{\"ids\":[[\"10000\"]], \"entities\":[\"e\"], \"values\":[[{\"value\":10}]]}]}");
     test_str(json, expect);
@@ -2019,6 +2089,8 @@ void SerializeIterToJson_serialize_anonymous_component(void) {
     ecs_os_free(json);
     ecs_os_free(expect);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -2029,9 +2101,9 @@ void SerializeIterToJson_serialize_anonymous_pair(void) {
     ecs_make_alive(world, rel);
     ecs_entity_t tgt = 20000;
     ecs_make_alive(world, tgt);
-    ecs_query_t *q = ecs_query_new(world, "(10000, 20000)");
+    ecs_query_t *q = ecs_query(world, { .expr = "(10000, 20000)" });
 
-    ecs_entity_t e = ecs_new_entity(world, "e");
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
     ecs_add_id(world, e, ecs_pair(rel, tgt));
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -2039,16 +2111,18 @@ void SerializeIterToJson_serialize_anonymous_pair(void) {
     desc.serialize_term_ids = true;
     desc.serialize_ids = true;
     desc.serialize_entities = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"ids\":[[\"10000\",\"20000\"]], \"results\":[{\"ids\":[[\"10000\",\"20000\"]], \"entities\":[\"e\"]}]}");
     test_str(json, expect);
 
     ecs_os_free(json);
     ecs_os_free(expect);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -2077,41 +2151,43 @@ void SerializeIterToJson_serialize_invalid_value(void) {
     });
 
     for (int i = 0; i < 10; i ++) {
-        ecs_entity_t p = ecs_new_id(world);
+        ecs_entity_t p = ecs_new(world);
         ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
         ecs_set(world, e, T, {4});
     }
 
-    ecs_query_t *q = ecs_query_new(world, "T");
+    ecs_query_t *q = ecs_query(world, { .expr = "T" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_log_set_level(-4);
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_assert(json == NULL);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
 void SerializeIterToJson_serialize_recycled_pair_id(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t rel = ecs_new_entity(world, "Rel");
-    ecs_entity_t tgt = ecs_new_entity(world, "Tgt");
+    ecs_entity_t rel = ecs_entity(world, { .name = "Rel" });
+    ecs_entity_t tgt = ecs_entity(world, { .name = "Tgt" });
     ecs_delete(world, tgt);
-    tgt = ecs_new_entity(world, "Tgt");
+    tgt = ecs_entity(world, { .name = "Tgt" });
 
     ecs_entity_t e = ecs_new_w_pair(world, rel, tgt);
     ecs_set_name(world, e, "ent");
 
     ecs_query_t *q = ecs_query(world, {
-        .filter.terms[0] = {
+        .terms[0] = {
             .first.id = rel,
             .second.id = tgt
         }
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_assert(json != NULL);
     test_str(json, "{\"ids\":[[\"Rel\",\"Tgt\"]], \"results\":["
         "{\"ids\":[[\"Rel\",\"Tgt\"]], \"sources\":[0], \"entities\":[\"ent\"]}"
@@ -2119,6 +2195,8 @@ void SerializeIterToJson_serialize_recycled_pair_id(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -2130,12 +2208,12 @@ void SerializeIterToJson_serialize_w_alert(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
 
     ecs_alert(world, {
-        .entity = ecs_new_entity(world, "position_without_velocity"),
-        .filter.expr = "Position, !Velocity",
+        .entity = ecs_entity(world, { .name = "position_without_velocity" }),
+        .query.expr = "Position, !Velocity",
     });
 
     ecs_set(world, e1, Position, {10, 20});
@@ -2144,7 +2222,7 @@ void SerializeIterToJson_serialize_w_alert(void) {
 
     ecs_progress(world, 1.0); /* Evaluate alert logic */
 
-    ecs_query_t *q = ecs_query_new(world, "Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position" });
     test_assert(q != NULL);
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -2154,7 +2232,7 @@ void SerializeIterToJson_serialize_w_alert(void) {
     desc.serialize_values = false;
     desc.serialize_is_set = false;
     desc.serialize_sources = false;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
     test_str(json, "{\"ids\":[[\"Position\"]], \"results\":["
         "{\"entities\":[\"e1\"]}, "
@@ -2162,6 +2240,8 @@ void SerializeIterToJson_serialize_w_alert(void) {
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -2180,15 +2260,15 @@ void SerializeIterToJson_serialize_no_this_alert_imported(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "Foo");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "Foo" });
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position($x)"
     });
-    ecs_iter_t it = ecs_rule_iter(world, q);
+    ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Position\"]], "
@@ -2204,7 +2284,7 @@ void SerializeIterToJson_serialize_no_this_alert_imported(void) {
     "}");
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2214,17 +2294,17 @@ void SerializeIterToJson_serialize_paged_iterator(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {30, 40});
-    ecs_set(world, 0, Position, {10, 20});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_insert(world, ecs_value(Position, {10, 20}));
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .terms = {{ .id = ecs_id(Position) }}
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
     ecs_iter_t pit = ecs_page_iter(&it, 1, 3);
 
     test_bool(true, ecs_page_next(&pit));
@@ -2233,7 +2313,7 @@ void SerializeIterToJson_serialize_paged_iterator(void) {
     test_uint(e3, pit.entities[1]);
     test_uint(e4, pit.entities[2]);
 
-    Position *p = ecs_field(&pit, Position, 1);
+    Position *p = ecs_field(&pit, Position, 0);
     test_int(p[0].x, 10);
     test_int(p[0].y, 20);
     test_int(p[1].x, 20);
@@ -2243,7 +2323,7 @@ void SerializeIterToJson_serialize_paged_iterator(void) {
 
     test_bool(false, ecs_page_next(&pit));
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -2254,33 +2334,33 @@ void SerializeIterToJson_serialize_paged_iterator_w_optional_component(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {40, 50});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {40, 50}));
 
     ecs_set(world, e4, Velocity, {1, 2});
     ecs_set(world, e5, Velocity, {2, 3});
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .terms = {
             { .id = ecs_id(Position) },
             { .id = ecs_id(Velocity), .oper = EcsOptional }
         }
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
     ecs_iter_t pit = ecs_page_iter(&it, 1, 3);
 
     test_bool(true, ecs_page_next(&pit));
     test_int(2, pit.count);
-    test_bool(true, ecs_field_is_set(&pit, 1));
-    test_bool(false, ecs_field_is_set(&pit, 2));
+    test_bool(true, ecs_field_is_set(&pit, 0));
+    test_bool(false, ecs_field_is_set(&pit, 1));
     test_uint(e2, pit.entities[0]);
     test_uint(e3, pit.entities[1]);
 
-    Position *p = ecs_field(&pit, Position, 1);
+    Position *p = ecs_field(&pit, Position, 0);
     test_int(p[0].x, 10);
     test_int(p[0].y, 20);
     test_int(p[1].x, 20);
@@ -2288,21 +2368,21 @@ void SerializeIterToJson_serialize_paged_iterator_w_optional_component(void) {
 
     test_bool(true, ecs_page_next(&pit));
     test_int(1, pit.count);
+    test_bool(true, ecs_field_is_set(&pit, 0));
     test_bool(true, ecs_field_is_set(&pit, 1));
-    test_bool(true, ecs_field_is_set(&pit, 2));
 
     test_uint(e4, pit.entities[0]);
-    p = ecs_field(&pit, Position, 1);
+    p = ecs_field(&pit, Position, 0);
     test_int(p[0].x, 30);
     test_int(p[0].y, 40);
 
-    Velocity *v = ecs_field(&pit, Velocity, 2);
+    Velocity *v = ecs_field(&pit, Velocity, 1);
     test_int(v[0].x, 1);
     test_int(v[0].y, 2);
 
     test_bool(false, ecs_page_next(&pit));
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -2313,33 +2393,33 @@ void SerializeIterToJson_serialize_paged_iterator_w_optional_tag(void) {
     ECS_COMPONENT(world, Position);
     ECS_TAG(world, Tag);
 
-    ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 20});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {20, 30});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {30, 40});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {40, 50});
+    ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {40, 50}));
 
     ecs_add(world, e4, Tag);
     ecs_add(world, e5, Tag);
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .terms = {
             { .id = ecs_id(Position) },
             { .id = Tag, .oper = EcsOptional }
         }
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
     ecs_iter_t pit = ecs_page_iter(&it, 1, 3);
 
     test_bool(true, ecs_page_next(&pit));
     test_int(2, pit.count);
-    test_bool(true, ecs_field_is_set(&pit, 1));
-    test_bool(false, ecs_field_is_set(&pit, 2));
+    test_bool(true, ecs_field_is_set(&pit, 0));
+    test_bool(false, ecs_field_is_set(&pit, 1));
     test_uint(e2, pit.entities[0]);
     test_uint(e3, pit.entities[1]);
 
-    Position *p = ecs_field(&pit, Position, 1);
+    Position *p = ecs_field(&pit, Position, 0);
     test_int(p[0].x, 10);
     test_int(p[0].y, 20);
     test_int(p[1].x, 20);
@@ -2347,17 +2427,17 @@ void SerializeIterToJson_serialize_paged_iterator_w_optional_tag(void) {
 
     test_bool(true, ecs_page_next(&pit));
     test_int(1, pit.count);
+    test_bool(true, ecs_field_is_set(&pit, 0));
     test_bool(true, ecs_field_is_set(&pit, 1));
-    test_bool(true, ecs_field_is_set(&pit, 2));
 
     test_uint(e4, pit.entities[0]);
-    p = ecs_field(&pit, Position, 1);
+    p = ecs_field(&pit, Position, 0);
     test_int(p[0].x, 30);
     test_int(p[0].y, 40);
 
     test_bool(false, ecs_page_next(&pit));
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -2375,13 +2455,13 @@ void SerializeIterToJson_serialize_paged_iterator_w_vars(void) {
     ecs_entity_t e4 = ecs_new_w_pair(world, Rel, ObjB);
     ecs_new_w_pair(world, Rel, ObjB);
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Rel, $Var)"
     });
 
-    int32_t var = ecs_rule_find_var(r, "Var");
+    int32_t var = ecs_query_find_var(r, "Var");
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
     ecs_iter_t pit = ecs_page_iter(&it, 1, 3);
 
     test_assert(var < pit.variable_count);
@@ -2400,7 +2480,7 @@ void SerializeIterToJson_serialize_paged_iterator_w_vars(void) {
 
     test_bool(false, ecs_page_next(&pit));
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -2437,9 +2517,9 @@ void SerializeIterToJson_serialize_table(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -2452,19 +2532,19 @@ void SerializeIterToJson_serialize_table(void) {
     ecs_set(world, e2, Velocity, {1, 1});
     ecs_set(world, e3, Mass, {100});
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_id(Position) }
         }
     });
 
-    ecs_iter_t it = ecs_filter_iter(world, f);
+    ecs_iter_t it = ecs_query_iter(world, f);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_table = true;
     desc.serialize_ids = true;
     desc.serialize_entities = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
     test_str(json, "{\"results\":["
@@ -2484,7 +2564,7 @@ void SerializeIterToJson_serialize_table(void) {
     
     ecs_os_free(json);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -2525,9 +2605,9 @@ void SerializeIterToJson_serialize_table_w_id_labels(void) {
     ecs_doc_set_name(world, ecs_id(Velocity), "velocity");
     ecs_doc_set_name(world, ecs_id(Mass), "mass");
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -2540,19 +2620,19 @@ void SerializeIterToJson_serialize_table_w_id_labels(void) {
     ecs_set(world, e2, Velocity, {1, 1});
     ecs_set(world, e3, Mass, {100});
 
-    ecs_filter_t *f = ecs_filter(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_id(Position) }
         }
     });
 
-    ecs_iter_t it = ecs_filter_iter(world, f);
+    ecs_iter_t it = ecs_query_iter(world, f);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_table = true;
     desc.serialize_entities = true;
     desc.serialize_id_labels = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
     test_str(json, "{\"results\":["
@@ -2572,7 +2652,7 @@ void SerializeIterToJson_serialize_table_w_id_labels(void) {
     
     ecs_os_free(json);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -2609,12 +2689,12 @@ void SerializeIterToJson_serialize_table_w_var_labels(void) {
         }
     });
 
-    ecs_entity_t parent = ecs_new_entity(world, "Parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "Parent" });
     ecs_doc_set_name(world, parent, "parent");
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
@@ -2631,21 +2711,21 @@ void SerializeIterToJson_serialize_table_w_var_labels(void) {
     ecs_set(world, e2, Velocity, {1, 1});
     ecs_set(world, e3, Mass, {100});
 
-    ecs_rule_t *f = ecs_rule(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_id(Position) },
-            { .first.id = EcsChildOf, .second.name = "p", .second.flags = EcsIsVariable }
+            { .first.id = EcsChildOf, .second.name = "p", .second.id = EcsIsVariable }
         }
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, f);
+    ecs_iter_t it = ecs_query_iter(world, f);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_table = true;
     desc.serialize_entities = true;
     desc.serialize_variable_labels = true;
     desc.serialize_ids = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
     test_str(json, "{\"vars\":[\"p\"], \"results\":["
@@ -2671,7 +2751,7 @@ void SerializeIterToJson_serialize_table_w_var_labels(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -2708,12 +2788,12 @@ void SerializeIterToJson_serialize_table_w_private(void) {
         }
     });
 
-    ecs_entity_t parent = ecs_new_entity(world, "Parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "Parent" });
     ecs_doc_set_name(world, parent, "parent");
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
@@ -2730,14 +2810,14 @@ void SerializeIterToJson_serialize_table_w_private(void) {
     ecs_set(world, e2, Velocity, {1, 1});
     ecs_set(world, e3, Mass, {100});
 
-    ecs_rule_t *f = ecs_rule(world, {
+    ecs_query_t *f = ecs_query(world, {
         .terms = {
             { .id = ecs_id(Position) },
-            { .first.id = EcsChildOf, .second.name = "p", .second.flags = EcsIsVariable }
+            { .first.id = EcsChildOf, .second.name = "p", .second.id = EcsIsVariable }
         }
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, f);
+    ecs_iter_t it = ecs_query_iter(world, f);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_table = true;
@@ -2745,7 +2825,7 @@ void SerializeIterToJson_serialize_table_w_private(void) {
     desc.serialize_variable_labels = true;
     desc.serialize_ids = true;
     desc.serialize_private = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
 
     test_str(json, "{\"vars\":[\"p\"], \"results\":["
@@ -2771,7 +2851,7 @@ void SerializeIterToJson_serialize_table_w_private(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(f);
+    ecs_query_fini(f);
 
     ecs_fini(world);
 }
@@ -2802,25 +2882,25 @@ void SerializeIterToJson_serialize_w_offset(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_add(world, e1, Tag);
 
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_add(world, e2, Tag);
 
-    ecs_rule_t *r = ecs_rule_new(world, "Tag($this), ?$this(_)");
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), ?$this(_)" });
+    ecs_iter_t it = ecs_query_iter(world, r);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_entities = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
         "{\"results\":[{\"entities\":[\"e1\"]}, {\"entities\":[\"e2\"]}]}");
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -2830,27 +2910,27 @@ void SerializeIterToJson_serialize_labels_w_offset(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add(world, e1, Tag);
     ecs_doc_set_name(world, e1, "e1");
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add(world, e2, Tag);
     ecs_doc_set_name(world, e2, "e2");
 
-    ecs_rule_t *r = ecs_rule_new(world, "Tag($this), ?$this(_)");
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), ?$this(_)" });
+    ecs_iter_t it = ecs_query_iter(world, r);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_entity_labels = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
         "{\"results\":[{\"entity_labels\":[\"e1\"]}, {\"entity_labels\":[\"e2\"]}]}");
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -2860,27 +2940,27 @@ void SerializeIterToJson_serialize_colors_w_offset(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add(world, e1, Tag);
     ecs_doc_set_color(world, e1, "e1");
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add(world, e2, Tag);
     ecs_doc_set_color(world, e2, "e2");
 
-    ecs_rule_t *r = ecs_rule_new(world, "Tag($this), ?$this(_)");
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), ?$this(_)" });
+    ecs_iter_t it = ecs_query_iter(world, r);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_colors = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
     test_str(json, 
         "{\"results\":[{\"colors\":[\"e1\"]}, {\"colors\":[\"e2\"]}]}");
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -2890,20 +2970,20 @@ void SerializeIterToJson_serialize_anonymous_entities_w_offset(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_add(world, e1, Tag);
 
-    ecs_entity_t e2 = ecs_new_id(world);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_add(world, e2, Tag);
 
-    ecs_rule_t *r = ecs_rule_new(world, "Tag($this), ?$this(_)");
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), ?$this(_)" });
+    ecs_iter_t it = ecs_query_iter(world, r);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_entities = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
 
-    char *expect = ecs_asprintf(
+    char *expect = flecs_asprintf(
         "{\"results\":[{\"entities\":[%u]}, {\"entities\":[%u]}]}",
             (uint32_t)e1, (uint32_t)e2);
 
@@ -2912,7 +2992,7 @@ void SerializeIterToJson_serialize_anonymous_entities_w_offset(void) {
     ecs_os_free(json);
     ecs_os_free(expect);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -2932,17 +3012,19 @@ void SerializeIterToJson_serialize_term_labels(void) {
         }
     });
 
-    ecs_query_t *q = ecs_query_new(world, "Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_term_labels = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
     test_str(json, "{\"id_labels\":[[\"position\"]], \"results\":[]}");
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -2961,20 +3043,22 @@ void SerializeIterToJson_serialize_id_labels(void) {
         }
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "ent");
+    ecs_entity_t e = ecs_entity(world, { .name = "ent" });
     ecs_set(world, e, Position, {1, 2});
 
-    ecs_query_t *q = ecs_query_new(world, "Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_id_labels = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
     test_str(json, "{\"results\":[{\"id_labels\":[[\"position\"]]}]}");
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -2993,20 +3077,22 @@ void SerializeIterToJson_serialize_id_labels_w_str(void) {
         }
     });
 
-    ecs_entity_t e = ecs_new_entity(world, "ent");
+    ecs_entity_t e = ecs_entity(world, { .name = "ent" });
     ecs_set(world, e, Position, {1, 2});
 
-    ecs_query_t *q = ecs_query_new(world, "Position");
+    ecs_query_t *q = ecs_query(world, { .expr = "Position" });
     ecs_iter_t it = ecs_query_iter(world, q);
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_id_labels = true;
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
     test_str(json, "{\"results\":[{\"id_labels\":[[\"\\\"position\\\"\"]]}]}");
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -3016,26 +3102,28 @@ void SerializeIterToJson_serialize_vars_for_query(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_query_t *q = ecs_query(world, {
-        .filter.terms[0] = {
+        .terms[0] = {
             .id = ecs_id(Position)
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {1, 2});
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Position, {3, 4});
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_entities = true;
     desc.serialize_variables = true;
     ecs_iter_t it = ecs_query_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
     test_str(json, "{\"results\":[{\"entities\":[\"e1\", \"e2\"]}]}");
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -3045,26 +3133,28 @@ void SerializeIterToJson_serialize_var_labels_for_query(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_query_t *q = ecs_query(world, {
-        .filter.terms[0] = {
+        .terms[0] = {
             .id = ecs_id(Position)
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {1, 2});
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Position, {3, 4});
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_entities = true;
     desc.serialize_variable_labels = true;
     ecs_iter_t it = ecs_query_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
     test_str(json, "{\"results\":[{\"entities\":[\"e1\", \"e2\"]}]}");
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -3074,26 +3164,28 @@ void SerializeIterToJson_serialize_var_ids_for_query(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_query_t *q = ecs_query(world, {
-        .filter.terms[0] = {
+        .terms[0] = {
             .id = ecs_id(Position)
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
     ecs_set(world, e1, Position, {1, 2});
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
     ecs_set(world, e2, Position, {3, 4});
 
     ecs_iter_to_json_desc_t desc = {0};
     desc.serialize_entities = true;
     desc.serialize_variable_ids = true;
     ecs_iter_t it = ecs_query_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
     test_str(json, "{\"results\":[{\"entities\":[\"e1\", \"e2\"]}]}");
 
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -3102,13 +3194,13 @@ void SerializeIterToJson_serialize_null_doc_name(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e = ecs_new_entity(world, "foo");
+    ecs_entity_t e = ecs_entity(world, { .name = "foo" });
     ecs_doc_set_name(world, e, "bar");
     ecs_doc_set_name(world, e, NULL);
     ecs_add(world, e, Tag);
 
     ecs_query_t *q = ecs_query(world, {
-        .filter.terms[0] = {
+        .terms[0] = {
             .id = Tag
         }
     });
@@ -3119,11 +3211,13 @@ void SerializeIterToJson_serialize_null_doc_name(void) {
     desc.serialize_entity_labels = true;
 
     ecs_iter_t it = ecs_query_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_assert(json != NULL);
     test_str(json, "{\"results\":[{\"entities\":[\"foo\"]}]}");
     ecs_os_free(json);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -3133,19 +3227,19 @@ void SerializeIterToJson_serialize_rule_w_optional(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
     ecs_set_name(world, e1, "e1");
-    ecs_entity_t e2 = ecs_new(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
     ecs_set_name(world, e2, "e2");
     ecs_add(world, e2, Bar);
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Foo, ?Bar"
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Foo\"], [\"Bar\"]], "
@@ -3168,7 +3262,7 @@ void SerializeIterToJson_serialize_rule_w_optional(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -3196,24 +3290,24 @@ void SerializeIterToJson_serialize_rule_w_optional_component(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {10, 20});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
     ecs_set_name(world, e1, "e1");
 
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {30, 40});
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {30, 40}));
     ecs_set_name(world, e2, "e2");
     ecs_set(world, e2, Velocity, {1, 2});
 
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {50, 60});
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {50, 60}));
     ecs_set_name(world, e3, "e3");
     ecs_add(world, e3, Foo);
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *r = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Position, ?Velocity"
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, r);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Position\"], [\"Velocity\"]], "
@@ -3246,7 +3340,7 @@ void SerializeIterToJson_serialize_rule_w_optional_component(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
@@ -3256,20 +3350,22 @@ void SerializeIterToJson_serialize_entity_w_flecs_core_parent(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
     ecs_set_name(world, e1, "e1");
 
     ecs_entity_t flecs_core_parent = 
-        ecs_new_from_fullpath(world, "flecs.core.bob");
+        ecs_entity(world, { .name = "flecs.core.bob" });
     ecs_add_pair(world, e1, EcsChildOf, flecs_core_parent);
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo"
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, NULL);
+    char *json = ecs_iter_to_json(&it, NULL);
     test_str(json, 
     "{"
         "\"ids\":[[\"Foo\"]], "
@@ -3285,7 +3381,7 @@ void SerializeIterToJson_serialize_entity_w_flecs_core_parent(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
diff --git a/test/meta/src/SerializeIterToRowJson.c b/test/meta/src/SerializeIterToRowJson.c
index ff7df9632..a33028c21 100644
--- a/test/meta/src/SerializeIterToRowJson.c
+++ b/test/meta/src/SerializeIterToRowJson.c
@@ -6,23 +6,23 @@ void SerializeIterToRowJson_serialize_this_w_1_tag(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
     ecs_add(world, e3, TagA);
     ecs_add(world, e3, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -35,7 +35,7 @@ void SerializeIterToRowJson_serialize_this_w_1_tag(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -46,18 +46,18 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_w_parent(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t p1 = ecs_new_entity(world, "p1");
-    ecs_entity_t p2 = ecs_new_entity(world, "p2");
+    ecs_entity_t p1 = ecs_entity(world, { .name = "p1" });
+    ecs_entity_t p2 = ecs_entity(world, { .name = "p2" });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     
     ecs_add_pair(world, e1, EcsChildOf, p1);
     ecs_add_pair(world, e2, EcsChildOf, p1);
@@ -68,8 +68,8 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_w_parent(void) {
     ecs_add(world, e3, TagA);
     ecs_add(world, e3, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -82,7 +82,7 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_w_parent(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -93,18 +93,18 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_no_name(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t p1 = ecs_new_entity(world, "p1");
-    ecs_entity_t p2 = ecs_new_entity(world, "p1");
+    ecs_entity_t p1 = ecs_entity(world, { .name = "p1" });
+    ecs_entity_t p2 = ecs_entity(world, { .name = "p1" });
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
     
     ecs_add_pair(world, e1, EcsChildOf, p1);
     ecs_add_pair(world, e2, EcsChildOf, p1);
@@ -115,8 +115,8 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_no_name(void) {
     ecs_add(world, e3, TagA);
     ecs_add(world, e3, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -126,7 +126,7 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_no_name(void) {
         "{\"parent\":\"p1\", \"name\":\"%u\", \"tags\":[\"TagA\"]}, "
         "{\"parent\":\"p1\", \"name\":\"%u\", \"tags\":[\"TagA\"]}]}";
 
-    char *expect = ecs_asprintf(expect_fmt, 
+    char *expect = flecs_asprintf(expect_fmt, 
         (uint32_t)e1, 
         (uint32_t)e2, 
         (uint32_t)e3);
@@ -135,7 +135,7 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_no_name(void) {
     ecs_os_free(json);
     ecs_os_free(expect);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -149,18 +149,18 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_doc_name(void) {
     ecs_doc_set_name(world, TagA, "The Tag A");
     ecs_doc_set_name(world, TagB, "The Tag B");
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t p1 = ecs_new_entity(world, "p1");
-    ecs_entity_t p2 = ecs_new_entity(world, "p1");
+    ecs_entity_t p1 = ecs_entity(world, { .name = "p1" });
+    ecs_entity_t p2 = ecs_entity(world, { .name = "p1" });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     
     ecs_add_pair(world, e1, EcsChildOf, p1);
     ecs_add_pair(world, e2, EcsChildOf, p1);
@@ -171,8 +171,8 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_doc_name(void) {
     ecs_add(world, e3, TagA);
     ecs_add(world, e3, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -185,7 +185,7 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_doc_name(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -196,15 +196,15 @@ void SerializeIterToRowJson_serialize_this_w_2_tag(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, TagB"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -214,8 +214,8 @@ void SerializeIterToRowJson_serialize_this_w_2_tag(void) {
     ecs_add(world, e2, TagB);
     ecs_add(world, e3, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -228,7 +228,7 @@ void SerializeIterToRowJson_serialize_this_w_2_tag(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -246,22 +246,22 @@ void SerializeIterToRowJson_serialize_this_w_1_component(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e3, Position, {30, 40});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -275,7 +275,7 @@ void SerializeIterToRowJson_serialize_this_w_1_component(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -302,15 +302,15 @@ void SerializeIterToRowJson_serialize_this_w_2_component(void) {
     });
 
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position, Mass"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -320,8 +320,8 @@ void SerializeIterToRowJson_serialize_this_w_2_component(void) {
     ecs_set(world, e2, Mass, {2});
     ecs_set(world, e3, Mass, {3});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -334,7 +334,7 @@ void SerializeIterToRowJson_serialize_this_w_2_component(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -361,17 +361,17 @@ void SerializeIterToRowJson_serialize_this_w_2_component_1_shared(void) {
     });
 
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position, Mass"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t base_1 = ecs_new_entity(world, "base_1");
-    ecs_entity_t base_2 = ecs_new_entity(world, "base_2");
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t base_1 = ecs_entity(world, { .name = "base_1" });
+    ecs_entity_t base_2 = ecs_entity(world, { .name = "base_2" });
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -384,8 +384,8 @@ void SerializeIterToRowJson_serialize_this_w_2_component_1_shared(void) {
     ecs_set(world, base_1, Mass, {1});
     ecs_set(world, base_2, Mass, {2});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -398,7 +398,7 @@ void SerializeIterToRowJson_serialize_this_w_2_component_1_shared(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -410,22 +410,22 @@ void SerializeIterToRowJson_serialize_this_w_1_pair(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, *)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
     ecs_add_pair(world, e3, RelA, TgtB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -438,7 +438,7 @@ void SerializeIterToRowJson_serialize_this_w_1_pair(void) {
 
     ecs_os_free(json);
     
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -460,22 +460,22 @@ void SerializeIterToRowJson_serialize_this_w_1_pair_component(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Position, *)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set_pair(world, e1, Position, TgtA, {10, 20});
     ecs_set_pair(world, e2, Position, TgtA, {20, 30});
     ecs_set_pair(world, e3, Position, TgtB, {30, 40});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -488,7 +488,7 @@ void SerializeIterToRowJson_serialize_this_w_1_pair_component(void) {
 
     ecs_os_free(json);
     
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -501,15 +501,15 @@ void SerializeIterToRowJson_serialize_this_w_2_pair(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, *), (RelB, *)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
@@ -519,8 +519,8 @@ void SerializeIterToRowJson_serialize_this_w_2_pair(void) {
     ecs_add_pair(world, e2, RelB, TgtA);
     ecs_add_pair(world, e3, RelB, TgtB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -533,7 +533,7 @@ void SerializeIterToRowJson_serialize_this_w_2_pair(void) {
 
     ecs_os_free(json);
     
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -546,22 +546,22 @@ void SerializeIterToRowJson_serialize_this_w_1_var(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, $a)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
     ecs_add_pair(world, e3, RelA, TgtB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -574,7 +574,7 @@ void SerializeIterToRowJson_serialize_this_w_1_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -587,15 +587,15 @@ void SerializeIterToRowJson_serialize_this_w_2_var(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, $a), (RelB, $b)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
@@ -605,8 +605,8 @@ void SerializeIterToRowJson_serialize_this_w_2_var(void) {
     ecs_add_pair(world, e2, RelB, TgtA);
     ecs_add_pair(world, e3, RelB, TgtB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -619,7 +619,7 @@ void SerializeIterToRowJson_serialize_this_w_2_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -635,15 +635,15 @@ void SerializeIterToRowJson_serialize_this_w_2_var_doc_name(void) {
     ecs_doc_set_name(world, TgtA, "Target A");
     ecs_doc_set_name(world, TgtB, "Target B");
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, $a), (RelB, $b)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
@@ -653,8 +653,8 @@ void SerializeIterToRowJson_serialize_this_w_2_var_doc_name(void) {
     ecs_add_pair(world, e2, RelB, TgtA);
     ecs_add_pair(world, e3, RelB, TgtB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -667,7 +667,7 @@ void SerializeIterToRowJson_serialize_this_w_2_var_doc_name(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -690,15 +690,15 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_component_pair_var(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, (RelA, $a), Position"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -712,8 +712,8 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_component_pair_var(void) {
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e3, Position, {30, 40});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -727,7 +727,7 @@ void SerializeIterToRowJson_serialize_this_w_1_tag_component_pair_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -761,15 +761,15 @@ void SerializeIterToRowJson_serialize_this_w_2_tag_component_pair_var(void) {
     });
 
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, TagB, (RelA, $a), (RelB, $b), Position, Mass"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -795,8 +795,8 @@ void SerializeIterToRowJson_serialize_this_w_2_tag_component_pair_var(void) {
     ecs_set(world, e2, Mass, {2});
     ecs_set(world, e3, Mass, {3});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -809,7 +809,7 @@ void SerializeIterToRowJson_serialize_this_w_2_tag_component_pair_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -820,23 +820,23 @@ void SerializeIterToRowJson_serialize_var_w_1_tag(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA($x)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
     ecs_add(world, e3, TagA);
     ecs_add(world, e3, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -849,7 +849,7 @@ void SerializeIterToRowJson_serialize_var_w_1_tag(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -867,22 +867,22 @@ void SerializeIterToRowJson_serialize_var_w_1_component(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position($x)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e3, Position, {30, 40});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -896,7 +896,7 @@ void SerializeIterToRowJson_serialize_var_w_1_component(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -908,22 +908,22 @@ void SerializeIterToRowJson_serialize_var_w_1_pair(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "RelA($x, *)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
     ecs_add_pair(world, e3, RelA, TgtB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -936,7 +936,7 @@ void SerializeIterToRowJson_serialize_var_w_1_pair(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -949,22 +949,22 @@ void SerializeIterToRowJson_serialize_var_w_1_var(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "RelA($x, $a)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
     ecs_add_pair(world, e3, RelA, TgtB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -977,7 +977,7 @@ void SerializeIterToRowJson_serialize_var_w_1_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1003,17 +1003,17 @@ void SerializeIterToRowJson_serialize_var_w_2_component_1_shared(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position($x), Mass($x)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t base_1 = ecs_new_entity(world, "base_1");
-    ecs_entity_t base_2 = ecs_new_entity(world, "base_2");
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t base_1 = ecs_entity(world, { .name = "base_1" });
+    ecs_entity_t base_2 = ecs_entity(world, { .name = "base_2" });
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -1026,8 +1026,8 @@ void SerializeIterToRowJson_serialize_var_w_2_component_1_shared(void) {
     ecs_set(world, base_1, Mass, {1});
     ecs_set(world, base_2, Mass, {2});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1040,7 +1040,7 @@ void SerializeIterToRowJson_serialize_var_w_2_component_1_shared(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1063,15 +1063,15 @@ void SerializeIterToRowJson_serialize_var_w_1_tag_component_pair_var(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA($x), RelA($x, $a), Position($x)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -1085,8 +1085,8 @@ void SerializeIterToRowJson_serialize_var_w_1_tag_component_pair_var(void) {
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e3, Position, {30, 40});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1099,7 +1099,7 @@ void SerializeIterToRowJson_serialize_var_w_1_tag_component_pair_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1133,15 +1133,15 @@ void SerializeIterToRowJson_serialize_var_w_2_tag_component_pair_var(void) {
     });
 
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA($x), TagB($x), RelA($x, $a), RelB($x, $b), Position($x), Mass($x)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -1167,8 +1167,8 @@ void SerializeIterToRowJson_serialize_var_w_2_tag_component_pair_var(void) {
     ecs_set(world, e2, Mass, {2});
     ecs_set(world, e3, Mass, {3});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1181,7 +1181,7 @@ void SerializeIterToRowJson_serialize_var_w_2_tag_component_pair_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1192,9 +1192,9 @@ void SerializeIterToRowJson_serialize_fixed_w_1_tag(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA(e1)"
     });
 
@@ -1202,8 +1202,8 @@ void SerializeIterToRowJson_serialize_fixed_w_1_tag(void) {
 
     ecs_add(world, e1, TagA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1213,7 +1213,7 @@ void SerializeIterToRowJson_serialize_fixed_w_1_tag(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1231,9 +1231,9 @@ void SerializeIterToRowJson_serialize_fixed_w_1_component(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position(e1)"
     });
 
@@ -1241,8 +1241,8 @@ void SerializeIterToRowJson_serialize_fixed_w_1_component(void) {
 
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1253,7 +1253,7 @@ void SerializeIterToRowJson_serialize_fixed_w_1_component(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1265,9 +1265,9 @@ void SerializeIterToRowJson_serialize_fixed_w_1_pair(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "RelA(e1, *)"
     });
 
@@ -1275,8 +1275,8 @@ void SerializeIterToRowJson_serialize_fixed_w_1_pair(void) {
 
     ecs_add_pair(world, e1, RelA, TgtA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1286,7 +1286,7 @@ void SerializeIterToRowJson_serialize_fixed_w_1_pair(void) {
 
     ecs_os_free(json);
     
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1299,9 +1299,9 @@ void SerializeIterToRowJson_serialize_fixed_w_1_var(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "RelA(e1, $a)"
     });
 
@@ -1309,8 +1309,8 @@ void SerializeIterToRowJson_serialize_fixed_w_1_var(void) {
 
     ecs_add_pair(world, e1, RelA, TgtA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1320,7 +1320,7 @@ void SerializeIterToRowJson_serialize_fixed_w_1_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1346,22 +1346,22 @@ void SerializeIterToRowJson_serialize_fixed_w_2_component_1_shared(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position(e1), Mass(e1)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t base_1 = ecs_new_entity(world, "base_1");
+    ecs_entity_t base_1 = ecs_entity(world, { .name = "base_1" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_add_pair(world, e1, EcsIsA, base_1);
     ecs_set(world, base_1, Mass, {1});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1371,7 +1371,7 @@ void SerializeIterToRowJson_serialize_fixed_w_2_component_1_shared(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1394,9 +1394,9 @@ void SerializeIterToRowJson_serialize_fixed_w_1_tag_component_pair_var(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA(e1), RelA(e1, $a), Position(e1)"
     });
 
@@ -1406,8 +1406,8 @@ void SerializeIterToRowJson_serialize_fixed_w_1_tag_component_pair_var(void) {
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_set(world, e1, Position, {10, 20});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1417,7 +1417,7 @@ void SerializeIterToRowJson_serialize_fixed_w_1_tag_component_pair_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1450,9 +1450,9 @@ void SerializeIterToRowJson_serialize_fixed_w_2_tag_component_pair_var(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA(e1), TagB(e1), RelA(e1, $a), RelB(e1, $b), Position(e1), Mass(e1)"
     });
 
@@ -1465,8 +1465,8 @@ void SerializeIterToRowJson_serialize_fixed_w_2_tag_component_pair_var(void) {
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e1, Mass, {1});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1479,7 +1479,7 @@ void SerializeIterToRowJson_serialize_fixed_w_2_tag_component_pair_var(void) {
 
     ecs_os_free(json);
     
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1506,15 +1506,15 @@ void SerializeIterToRowJson_serialize_not(void) {
     });
 
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position, !Mass"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -1523,8 +1523,8 @@ void SerializeIterToRowJson_serialize_not(void) {
     ecs_set(world, e1, Mass, {1});
     ecs_set(world, e2, Mass, {2});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1534,7 +1534,7 @@ void SerializeIterToRowJson_serialize_not(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1547,23 +1547,23 @@ void SerializeIterToRowJson_serialize_not_pair_wildcard(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, *), !(RelB, *)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
     ecs_add_pair(world, e3, RelA, TgtA);
     ecs_add_pair(world, e3, RelB, TgtA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1575,7 +1575,7 @@ void SerializeIterToRowJson_serialize_not_pair_wildcard(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1588,15 +1588,15 @@ void SerializeIterToRowJson_serialize_not_pair_var(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, *), !(RelB, $var)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
@@ -1605,8 +1605,8 @@ void SerializeIterToRowJson_serialize_not_pair_var(void) {
     ecs_add_pair(world, e1, RelB, TgtA);
     ecs_add_pair(world, e2, RelB, TgtA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1617,7 +1617,7 @@ void SerializeIterToRowJson_serialize_not_pair_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1630,15 +1630,15 @@ void SerializeIterToRowJson_serialize_not_pair_var_constrained(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, $var), !(RelB, $var)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
@@ -1648,8 +1648,8 @@ void SerializeIterToRowJson_serialize_not_pair_var_constrained(void) {
     ecs_add_pair(world, e2, RelB, TgtB);
     ecs_add_pair(world, e3, RelB, TgtA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1661,7 +1661,7 @@ void SerializeIterToRowJson_serialize_not_pair_var_constrained(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1688,15 +1688,15 @@ void SerializeIterToRowJson_serialize_optional(void) {
     });
 
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position, ?Mass"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -1705,8 +1705,8 @@ void SerializeIterToRowJson_serialize_optional(void) {
     ecs_set(world, e1, Mass, {1});
     ecs_set(world, e2, Mass, {2});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1719,7 +1719,7 @@ void SerializeIterToRowJson_serialize_optional(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1732,15 +1732,15 @@ void SerializeIterToRowJson_serialize_optional_pair_wildcard(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, *), ?(RelB, *)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
@@ -1749,8 +1749,8 @@ void SerializeIterToRowJson_serialize_optional_pair_wildcard(void) {
     ecs_add_pair(world, e1, RelB, TgtA);
     ecs_add_pair(world, e2, RelB, TgtA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1763,7 +1763,7 @@ void SerializeIterToRowJson_serialize_optional_pair_wildcard(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1776,15 +1776,15 @@ void SerializeIterToRowJson_serialize_optional_pair_var(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, *), ?(RelB, $var)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
@@ -1793,8 +1793,8 @@ void SerializeIterToRowJson_serialize_optional_pair_var(void) {
     ecs_add_pair(world, e1, RelB, TgtA);
     ecs_add_pair(world, e2, RelB, TgtA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1807,7 +1807,7 @@ void SerializeIterToRowJson_serialize_optional_pair_var(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1820,15 +1820,15 @@ void SerializeIterToRowJson_serialize_optional_pair_var_constrained(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(RelA, $var), ?(RelB, $var)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add_pair(world, e1, RelA, TgtA);
     ecs_add_pair(world, e2, RelA, TgtA);
@@ -1838,8 +1838,8 @@ void SerializeIterToRowJson_serialize_optional_pair_var_constrained(void) {
     ecs_add_pair(world, e2, RelB, TgtB);
     ecs_add_pair(world, e3, RelB, TgtA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1852,7 +1852,7 @@ void SerializeIterToRowJson_serialize_optional_pair_var_constrained(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1874,22 +1874,22 @@ void SerializeIterToRowJson_serialize_or(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Position, TgtA) || (Position, TgtB)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set_pair(world, e1, Position, TgtA, {10, 20});
     ecs_set_pair(world, e2, Position, TgtA, {20, 30});
     ecs_set_pair(world, e3, Position, TgtB, {30, 40});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1902,7 +1902,7 @@ void SerializeIterToRowJson_serialize_or(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1913,15 +1913,15 @@ void SerializeIterToRowJson_serialize_scope(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, !{ChildOf($child, $this), TagB($child)}, TagB"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -1931,18 +1931,18 @@ void SerializeIterToRowJson_serialize_scope(void) {
     ecs_add(world, e2, TagB);
     ecs_add(world, e3, TagB);
 
-    ecs_entity_t child_e1_1 = ecs_new_entity(world, "child_1");
+    ecs_entity_t child_e1_1 = ecs_entity(world, { .name = "child_1" });
     ecs_add_pair(world, child_e1_1, EcsChildOf, e1);
 
-    ecs_entity_t child_e2_1 = ecs_new_entity(world, "child_1");
+    ecs_entity_t child_e2_1 = ecs_entity(world, { .name = "child_1" });
     ecs_add_pair(world, child_e2_1, EcsChildOf, e2);
 
-    ecs_entity_t child_e2_2 = ecs_new_entity(world, "child_2");
+    ecs_entity_t child_e2_2 = ecs_entity(world, { .name = "child_2" });
     ecs_add_pair(world, child_e2_2, EcsChildOf, e2);
     ecs_add(world, child_e2_2, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1952,13 +1952,14 @@ void SerializeIterToRowJson_serialize_scope(void) {
      *       the serializer doesn't crash, and will be updated after the query
      *       refactor. */
     char* expect = "{\"results\":["
-        "{\"name\":\"e1\", \"tags\":[\"TagA\", \"TagB\"],\"pairs\":{\"ChildOf\":\"e1\"},\"vars\":{\"child\":\"*\"},\"is_set\":[true, false, true, false, false, true]}, "
+        "{\"name\":\"e1\", \"tags\":[\"TagA\", \"TagB\", \"TagB\"],\"pairs\":{\"ChildOf\":\"e1\"},\"vars\":{\"child\":\"*\"},\"is_set\":[true, false, true, true, false, true]}, "
         "{\"name\":\"e3\", \"tags\":[\"TagA\", \"TagB\", \"TagB\"],\"pairs\":{\"ChildOf\":\"e2\"},\"vars\":{\"child\":\"*\"},\"is_set\":[true, false, true, true, false, true]}]}";
+    
     test_str(json, expect);
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1969,11 +1970,11 @@ void SerializeIterToRowJson_serialize_eq(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, $this == e2"
     });
 
@@ -1984,8 +1985,8 @@ void SerializeIterToRowJson_serialize_eq(void) {
     ecs_add(world, e3, TagA);
     ecs_add(world, e3, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -1995,7 +1996,7 @@ void SerializeIterToRowJson_serialize_eq(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2006,11 +2007,11 @@ void SerializeIterToRowJson_serialize_neq(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, $this != e2"
     });
 
@@ -2021,8 +2022,8 @@ void SerializeIterToRowJson_serialize_neq(void) {
     ecs_add(world, e3, TagA);
     ecs_add(world, e3, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -2034,7 +2035,7 @@ void SerializeIterToRowJson_serialize_neq(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2045,11 +2046,11 @@ void SerializeIterToRowJson_serialize_eq_m(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, $this ~= \"e2\""
     });
 
@@ -2060,8 +2061,8 @@ void SerializeIterToRowJson_serialize_eq_m(void) {
     ecs_add(world, e3, TagA);
     ecs_add(world, e3, TagB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -2071,7 +2072,7 @@ void SerializeIterToRowJson_serialize_eq_m(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2104,15 +2105,15 @@ void SerializeIterToRowJson_serialize_table(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -2138,8 +2139,8 @@ void SerializeIterToRowJson_serialize_table(void) {
     ecs_set(world, e2, Mass, {2});
     ecs_set(world, e3, Mass, {3});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_table = true,
         .serialize_rows = true
     });
@@ -2153,7 +2154,7 @@ void SerializeIterToRowJson_serialize_table(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2186,11 +2187,11 @@ void SerializeIterToRowJson_serialize_table_w_eq(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, $this == e2"
     });
 
@@ -2220,8 +2221,8 @@ void SerializeIterToRowJson_serialize_table_w_eq(void) {
     ecs_set(world, e2, Mass, {2});
     ecs_set(world, e3, Mass, {3});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_table = true,
         .serialize_rows = true
     });
@@ -2237,7 +2238,7 @@ void SerializeIterToRowJson_serialize_table_w_eq(void) {
     test_str(json, expect);
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2270,11 +2271,11 @@ void SerializeIterToRowJson_serialize_table_w_neq(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, $this != e2"
     });
 
@@ -2304,8 +2305,8 @@ void SerializeIterToRowJson_serialize_table_w_neq(void) {
     ecs_set(world, e2, Mass, {2});
     ecs_set(world, e3, Mass, {3});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_table = true,
         .serialize_rows = true
     });
@@ -2318,7 +2319,7 @@ void SerializeIterToRowJson_serialize_table_w_neq(void) {
 
     ecs_os_free(json);
     
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2332,15 +2333,15 @@ void SerializeIterToRowJson_serialize_table_w_2_pair_targets(void) {
     ECS_TAG(world, TgtA);
     ECS_TAG(world, TgtB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -2351,8 +2352,8 @@ void SerializeIterToRowJson_serialize_table_w_2_pair_targets(void) {
     ecs_add_pair(world, e3, RelA, TgtA);
     ecs_add_pair(world, e3, RelA, TgtB);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_table = true,
         .serialize_rows = true
     });
@@ -2366,7 +2367,7 @@ void SerializeIterToRowJson_serialize_table_w_2_pair_targets(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2381,15 +2382,15 @@ void SerializeIterToRowJson_serialize_table_w_2_pair_targets_2_rel(void) {
     ECS_TAG(world, TgtB);
     ECS_TAG(world, TgtC);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -2403,8 +2404,8 @@ void SerializeIterToRowJson_serialize_table_w_2_pair_targets_2_rel(void) {
     ecs_add_pair(world, e3, RelB, TgtB);
     ecs_add_pair(world, e3, RelB, TgtC);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_table = true,
         .serialize_rows = true
     });
@@ -2418,7 +2419,7 @@ void SerializeIterToRowJson_serialize_table_w_2_pair_targets_2_rel(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2434,15 +2435,15 @@ void SerializeIterToRowJson_serialize_table_w_3_pair_targets(void) {
     ECS_TAG(world, TgtC);
     ECS_TAG(world, TgtD);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -2457,8 +2458,8 @@ void SerializeIterToRowJson_serialize_table_w_3_pair_targets(void) {
     ecs_add_pair(world, e3, RelA, TgtC);
     ecs_add_pair(world, e3, RelA, TgtD);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_table = true,
         .serialize_rows = true
     });
@@ -2472,7 +2473,7 @@ void SerializeIterToRowJson_serialize_table_w_3_pair_targets(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2488,15 +2489,15 @@ void SerializeIterToRowJson_serialize_table_w_3_pair_targets_2_rel(void) {
     ECS_TAG(world, TgtC);
     ECS_TAG(world, TgtD);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_add(world, e1, TagA);
     ecs_add(world, e2, TagA);
@@ -2515,8 +2516,8 @@ void SerializeIterToRowJson_serialize_table_w_3_pair_targets_2_rel(void) {
     ecs_add_pair(world, e3, RelB, TgtC);
     ecs_add_pair(world, e3, RelB, TgtD);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_table = true,
         .serialize_rows = true
     });
@@ -2530,7 +2531,7 @@ void SerializeIterToRowJson_serialize_table_w_3_pair_targets_2_rel(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2563,11 +2564,11 @@ void SerializeIterToRowJson_serialize_everything(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "_"
     });
 
@@ -2597,8 +2598,8 @@ void SerializeIterToRowJson_serialize_everything(void) {
     ecs_set(world, e2, Mass, {2});
     ecs_set(world, e3, Mass, {3});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
@@ -2606,7 +2607,7 @@ void SerializeIterToRowJson_serialize_everything(void) {
      * intended as a catch all, to make sure the serializer doesn't crash. */
     ecs_os_free(json);
     
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2641,11 +2642,11 @@ void SerializeIterToRowJson_serialize_everything_table(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "_"
     });
 
@@ -2675,8 +2676,8 @@ void SerializeIterToRowJson_serialize_everything_table(void) {
     ecs_set(world, e2, Mass, {2});
     ecs_set(world, e3, Mass, {3});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true,
         .serialize_table = true
     });
@@ -2689,7 +2690,7 @@ void SerializeIterToRowJson_serialize_everything_table(void) {
     test_assert(!strstr(json, "[\"TagA\""));
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2724,11 +2725,11 @@ void SerializeIterToRowJson_serialize_everything_table_w_private(void) {
         }
     });
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "_"
     });
 
@@ -2758,8 +2759,8 @@ void SerializeIterToRowJson_serialize_everything_table_w_private(void) {
     ecs_set(world, e2, Mass, {2});
     ecs_set(world, e3, Mass, {3});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true,
         .serialize_table = true,
         .serialize_private = true
@@ -2774,7 +2775,7 @@ void SerializeIterToRowJson_serialize_everything_table_w_private(void) {
     test_assert(strstr(json, "[\"TagA\"") != NULL);
     ecs_os_free(json);
     
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2792,22 +2793,22 @@ void SerializeIterToRowJson_serialize_w_type_info(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e3, Position, {30, 40});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true,
         .serialize_type_info = true
     });
@@ -2823,7 +2824,7 @@ void SerializeIterToRowJson_serialize_w_type_info(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2849,15 +2850,15 @@ void SerializeIterToRowJson_serialize_w_field_info(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position, ?Mass"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -2865,8 +2866,8 @@ void SerializeIterToRowJson_serialize_w_field_info(void) {
 
     ecs_set(world, e3, Mass, {100});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true,
         .serialize_field_info = true
     });
@@ -2884,7 +2885,7 @@ void SerializeIterToRowJson_serialize_w_field_info(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2910,15 +2911,15 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_0_target(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position, ?Mass, (ChildOf, 0)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -2926,8 +2927,8 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_0_target(void) {
 
     ecs_set(world, e3, Mass, {100});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true,
         .serialize_field_info = true
     });
@@ -2945,7 +2946,7 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_0_target(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2964,15 +2965,15 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_not_tag(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position, !Foo"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -2980,8 +2981,8 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_not_tag(void) {
 
     ecs_add(world, e3, Foo);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true,
         .serialize_field_info = true
     });
@@ -2998,7 +2999,7 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_not_tag(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3017,15 +3018,15 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_not_pair(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position, !(ChildOf, flecs)"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -3033,8 +3034,8 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_not_pair(void) {
 
     ecs_add(world, e3, Foo);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true,
         .serialize_field_info = true
     });
@@ -3052,7 +3053,7 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_not_pair(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3078,15 +3079,15 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_not_component(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position, !Mass"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
@@ -3094,8 +3095,8 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_not_component(void) {
 
     ecs_set(world, e3, Mass, {100});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true,
         .serialize_field_info = true
     });
@@ -3111,7 +3112,7 @@ void SerializeIterToRowJson_serialize_w_field_info_pair_w_not_component(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3137,22 +3138,22 @@ void SerializeIterToRowJson_serialize_w_field_info_w_or(void) {
         }
     });
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position || Mass"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
 
     ecs_set(world, e1, Position, {10, 20});
     ecs_set(world, e2, Position, {20, 30});
     ecs_set(world, e3, Mass, {100});
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true,
         .serialize_field_info = true
     });
@@ -3167,7 +3168,7 @@ void SerializeIterToRowJson_serialize_w_field_info_w_or(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3178,34 +3179,34 @@ void SerializeIterToRowJson_serialize_recycled_id(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_rule_t *q = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA"
     });
 
     test_assert(q != NULL);
 
-    ecs_entity_t _e1 = ecs_new_id(world);
+    ecs_entity_t _e1 = ecs_new(world);
     ecs_delete(world, _e1);
-    ecs_entity_t e1 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
     test_assert(e1 != _e1);
     test_assert((uint32_t)e1 == _e1);
 
     ecs_add(world, e1, TagA);
 
-    ecs_iter_t it = ecs_rule_iter(world, q);
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    ecs_iter_t it = ecs_query_iter(world, q);
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
     test_assert(json != NULL);
 
-    char* expect = ecs_asprintf("{\"results\":["
+    char* expect = flecs_asprintf("{\"results\":["
         "{\"name\":\"%u\", \"tags\":[\"TagA\"]}]}", (uint32_t)e1);
     test_str(json, expect);
 
     ecs_os_free(json);
     ecs_os_free(expect);
 
-    ecs_rule_fini(q);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3215,20 +3216,22 @@ void SerializeIterToRowJson_serialize_entity_w_flecs_core_parent(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
     ecs_set_name(world, e1, "e1");
 
     ecs_entity_t flecs_core_parent = 
-        ecs_new_from_fullpath(world, "flecs.core.bob");
+        ecs_entity(world, { .name = "flecs.core.bob" });
     ecs_add_pair(world, e1, EcsChildOf, flecs_core_parent);
 
-    ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo"
     });
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
 
-    char *json = ecs_iter_to_json(world, &it, &(ecs_iter_to_json_desc_t) {
+    char *json = ecs_iter_to_json(&it, &(ecs_iter_to_json_desc_t) {
         .serialize_rows = true
     });
 
@@ -3237,7 +3240,7 @@ void SerializeIterToRowJson_serialize_entity_w_flecs_core_parent(void) {
 
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
diff --git a/test/meta/src/SerializeQueryInfoToJson.c b/test/meta/src/SerializeQueryInfoToJson.c
index e8f5b6a5f..a8f5b99fe 100644
--- a/test/meta/src/SerializeQueryInfoToJson.c
+++ b/test/meta/src/SerializeQueryInfoToJson.c
@@ -5,19 +5,19 @@ void SerializeQueryInfoToJson_1_tag(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -26,7 +26,7 @@ void SerializeQueryInfoToJson_1_tag(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -36,19 +36,19 @@ void SerializeQueryInfoToJson_1_component(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Position"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":true, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -57,7 +57,7 @@ void SerializeQueryInfoToJson_1_component(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -68,19 +68,19 @@ void SerializeQueryInfoToJson_1_pair(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Rel, Tgt)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -90,7 +90,7 @@ void SerializeQueryInfoToJson_1_pair(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -100,19 +100,19 @@ void SerializeQueryInfoToJson_1_pair_w_wildcard(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Rel, *)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -122,7 +122,7 @@ void SerializeQueryInfoToJson_1_pair_w_wildcard(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -132,19 +132,19 @@ void SerializeQueryInfoToJson_1_pair_w_any(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Rel, _)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -154,7 +154,7 @@ void SerializeQueryInfoToJson_1_pair_w_any(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
     
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -165,19 +165,19 @@ void SerializeQueryInfoToJson_1_tag_fixed_src(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, e);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo(e)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"entity\":\"e\"}, "
@@ -186,7 +186,7 @@ void SerializeQueryInfoToJson_1_tag_fixed_src(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -196,19 +196,19 @@ void SerializeQueryInfoToJson_1_tag_var_src(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo($v)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"vars\":[\"v\"], \"query_info\":{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"var\":\"v\"}, "
@@ -217,7 +217,7 @@ void SerializeQueryInfoToJson_1_tag_var_src(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -227,19 +227,19 @@ void SerializeQueryInfoToJson_1_component_in(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[in] Position"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"in\", \"has_data\":true, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -248,7 +248,7 @@ void SerializeQueryInfoToJson_1_component_in(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -258,19 +258,19 @@ void SerializeQueryInfoToJson_1_component_inout(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[inout] Position"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"inout\", \"has_data\":true, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -279,7 +279,7 @@ void SerializeQueryInfoToJson_1_component_inout(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -289,19 +289,19 @@ void SerializeQueryInfoToJson_1_component_out(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[out] Position"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"out\", \"has_data\":true, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -310,7 +310,7 @@ void SerializeQueryInfoToJson_1_component_out(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -320,19 +320,19 @@ void SerializeQueryInfoToJson_1_component_none(void) {
 
     ECS_COMPONENT(world, Position);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[none] Position"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"none\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -341,7 +341,7 @@ void SerializeQueryInfoToJson_1_component_none(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -351,19 +351,19 @@ void SerializeQueryInfoToJson_1_tag_not(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "!Foo"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"none\", \"has_data\":false, \"oper\":\"not\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -372,7 +372,7 @@ void SerializeQueryInfoToJson_1_tag_not(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -383,19 +383,19 @@ void SerializeQueryInfoToJson_2_tags_or(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo || Bar"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"or\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -409,7 +409,7 @@ void SerializeQueryInfoToJson_2_tags_or(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -419,19 +419,19 @@ void SerializeQueryInfoToJson_1_tag_optional(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "?Foo"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"optional\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -440,7 +440,7 @@ void SerializeQueryInfoToJson_1_tag_optional(void) {
             "\"flags\":[\"self\", \"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -450,19 +450,19 @@ void SerializeQueryInfoToJson_1_tag_self(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo(self)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -470,7 +470,7 @@ void SerializeQueryInfoToJson_1_tag_self(void) {
             "\"flags\":[\"self\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -480,19 +480,19 @@ void SerializeQueryInfoToJson_1_tag_self_dont_inherit(void) {
 
     ECS_ENTITY(world, Foo, DontInherit);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo(self)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"dont_inherit\":true, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
@@ -500,7 +500,7 @@ void SerializeQueryInfoToJson_1_tag_self_dont_inherit(void) {
             "\"flags\":[\"self\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -510,28 +510,28 @@ void SerializeQueryInfoToJson_1_tag_up(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo(up)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
             "\"first\":{\"entity\":\"Foo\"}, "
-            "\"trav\":{\"entity\":\"flecs.core.IsA\", \"symbol\":\"EcsIsA\"}, "
+            "\"trav\":{\"entity\":\"flecs.core.ChildOf\", \"symbol\":\"EcsChildOf\"}, "
             "\"flags\":[\"up\"]}]}}");
     ecs_os_free(json);
 
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -541,28 +541,28 @@ void SerializeQueryInfoToJson_1_tag_cascade(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo(cascade)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":""{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"var\":\"this\"}, "
             "\"first\":{\"entity\":\"Foo\"}, "
-            "\"trav\":{\"entity\":\"flecs.core.IsA\", \"symbol\":\"EcsIsA\"}, "
+            "\"trav\":{\"entity\":\"flecs.core.ChildOf\", \"symbol\":\"EcsChildOf\"}, "
             "\"flags\":[\"cascade\"]}]}}");
     ecs_os_free(json);
     
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -572,19 +572,19 @@ void SerializeQueryInfoToJson_0_term(void) {
 
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Foo(0)"
     });
 
-    test_assert(r != NULL);
+    test_assert(q != NULL);
 
-    ecs_iter_t it = ecs_rule_iter(world, r);
+    ecs_iter_t it = ecs_query_iter(world, q);
     ecs_iter_to_json_desc_t desc = {
         .serialize_query_info = true,
         .dont_serialize_results = true
     };
 
-    char *json = ecs_iter_to_json(world, &it, &desc);
+    char *json = ecs_iter_to_json(&it, &desc);
     test_str(json, "{\"query_info\":{\"terms\":["
         "{\"inout\":\"default\", \"has_data\":false, \"oper\":\"and\", "
             "\"src\":{\"entity\":\"0\"}, "
@@ -592,7 +592,7 @@ void SerializeQueryInfoToJson_0_term(void) {
             "\"flags\":[]}]}}");
     ecs_os_free(json);
     
-    ecs_rule_fini(r);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
diff --git a/test/meta/src/Serialized.c b/test/meta/src/Serialized.c
index 1c8118ae0..a2837e952 100644
--- a/test/meta/src/Serialized.c
+++ b/test/meta/src/Serialized.c
@@ -77,8 +77,8 @@ static void _test_member_op(
 void Serialized_ops_bool(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_bool_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_bool_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -90,8 +90,8 @@ void Serialized_ops_bool(void) {
 void Serialized_ops_byte(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_byte_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_byte_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -103,8 +103,8 @@ void Serialized_ops_byte(void) {
 void Serialized_ops_char(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_char_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_char_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -116,8 +116,8 @@ void Serialized_ops_char(void) {
 void Serialized_ops_i8(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_i8_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_i8_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -129,8 +129,8 @@ void Serialized_ops_i8(void) {
 void Serialized_ops_i16(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_i16_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_i16_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -142,8 +142,8 @@ void Serialized_ops_i16(void) {
 void Serialized_ops_i32(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_i32_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_i32_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -155,8 +155,8 @@ void Serialized_ops_i32(void) {
 void Serialized_ops_i64(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_i64_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_i64_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -168,8 +168,8 @@ void Serialized_ops_i64(void) {
 void Serialized_ops_iptr(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_iptr_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_iptr_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -181,8 +181,8 @@ void Serialized_ops_iptr(void) {
 void Serialized_ops_u8(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_u8_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_u8_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -194,8 +194,8 @@ void Serialized_ops_u8(void) {
 void Serialized_ops_u16(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_u16_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_u16_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -207,8 +207,8 @@ void Serialized_ops_u16(void) {
 void Serialized_ops_u32(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_u32_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_u32_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -220,8 +220,8 @@ void Serialized_ops_u32(void) {
 void Serialized_ops_u64(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_u64_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_u64_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -233,8 +233,8 @@ void Serialized_ops_u64(void) {
 void Serialized_ops_uptr(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_uptr_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_uptr_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -246,8 +246,8 @@ void Serialized_ops_uptr(void) {
 void Serialized_ops_float(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_f32_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_f32_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -259,8 +259,8 @@ void Serialized_ops_float(void) {
 void Serialized_ops_double(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_f64_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_f64_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -272,8 +272,8 @@ void Serialized_ops_double(void) {
 void Serialized_ops_string(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_string_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_string_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -285,8 +285,8 @@ void Serialized_ops_string(void) {
 void Serialized_ops_entity(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_entity_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_entity_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -298,8 +298,8 @@ void Serialized_ops_entity(void) {
 void Serialized_ops_id(void) {
     ecs_world_t *world = ecs_init();
 
-    const EcsMetaTypeSerialized *s = ecs_get(
-        world, ecs_id(ecs_id_t), EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(
+        world, ecs_id(ecs_id_t), EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -323,7 +323,7 @@ void Serialized_ops_struct_bool(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 3);
 
@@ -351,7 +351,7 @@ void Serialized_ops_struct_bool_bool(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -378,7 +378,7 @@ void Serialized_ops_struct_i32(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 3);
 
@@ -406,7 +406,7 @@ void Serialized_ops_struct_i32_i32(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -435,7 +435,7 @@ void Serialized_ops_struct_i32_bool(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -464,7 +464,7 @@ void Serialized_ops_struct_bool_i32(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -503,7 +503,7 @@ void Serialized_ops_nested_struct_1_bool(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 5);
 
@@ -543,7 +543,7 @@ void Serialized_ops_nested_struct_1_i32(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 5);
 
@@ -585,7 +585,7 @@ void Serialized_ops_nested_struct_1_bool_w_bool_member(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 6);
 
@@ -628,7 +628,7 @@ void Serialized_ops_nested_struct_1_bool_w_i32_member(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 6);
 
@@ -678,7 +678,7 @@ void Serialized_ops_nested_struct_1_bool_2_bool(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 8);
 
@@ -733,7 +733,7 @@ void Serialized_ops_nested_struct_1_i32_2_bool(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 8);
 
@@ -792,7 +792,7 @@ void Serialized_ops_nested_struct_1_i32_i32_2_bool_bool(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 10);
 
@@ -853,7 +853,7 @@ void Serialized_ops_nested_struct_1_bool_bool_2_i32_i32(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 10);
 
@@ -914,7 +914,7 @@ void Serialized_ops_nested_struct_1_i32_bool_2_bool_i32(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 10);
 
@@ -975,7 +975,7 @@ void Serialized_ops_nested_struct_1_bool_i32_2_i32_bool(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 10);
 
@@ -1055,7 +1055,7 @@ void Serialized_ops_nested_2_lvls_bool(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 12);
 
@@ -1144,7 +1144,7 @@ void Serialized_ops_nested_2_lvls_bool_bool(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 14);
 
@@ -1243,7 +1243,7 @@ void Serialized_ops_nested_2_lvls_i32_i32_w_member_before(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 18);
 
@@ -1346,7 +1346,7 @@ void Serialized_ops_nested_2_lvls_1_bool_i32_2_i32_bool_w_member_before(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 18);
 
@@ -1449,7 +1449,7 @@ void Serialized_ops_nested_2_lvls_1_i32_bool_2_bool_i32_w_member_before(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 18);
 
@@ -1493,7 +1493,7 @@ void Serialized_ops_struct_array_bool_1(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 3);
 
@@ -1519,7 +1519,7 @@ void Serialized_ops_struct_array_bool_2(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 3);
 
@@ -1545,7 +1545,7 @@ void Serialized_ops_struct_array_bool_3(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 3);
 
@@ -1573,7 +1573,7 @@ void Serialized_ops_struct_array_bool_1_w_i32_after(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -1602,7 +1602,7 @@ void Serialized_ops_struct_array_bool_2_w_i32_after(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -1631,7 +1631,7 @@ void Serialized_ops_struct_array_bool_3_w_i32_after(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -1672,7 +1672,7 @@ void Serialized_ops_struct_array_struct_bool_3_w_i32_after(void) {
 
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 6);
 
@@ -1709,7 +1709,7 @@ void Serialized_ops_standalone_array_bool_1(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 3);
 
@@ -1743,7 +1743,7 @@ void Serialized_ops_standalone_array_bool_2(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 3);
 
@@ -1777,7 +1777,7 @@ void Serialized_ops_standalone_array_bool_3(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 3);
 
@@ -1813,7 +1813,7 @@ void Serialized_ops_standalone_array_bool_1_w_bool_after(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -1850,7 +1850,7 @@ void Serialized_ops_standalone_array_bool_2_w_bool_after(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -1886,7 +1886,7 @@ void Serialized_ops_standalone_array_bool_3_w_bool_after(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -1907,7 +1907,7 @@ void Serialized_ops_vector(void) {
 
     test_assert(v != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, v, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, v, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -1938,7 +1938,7 @@ void Serialized_ops_struct_w_vector(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 3);
 
@@ -1973,7 +1973,7 @@ void Serialized_ops_struct_w_vector_w_bool_before(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -2009,7 +2009,7 @@ void Serialized_ops_struct_w_vector_w_bool_after(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 4);
 
@@ -2032,7 +2032,7 @@ void Serialized_ops_bitmask(void) {
 
     test_assert(b != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, b, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, b, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -2068,7 +2068,7 @@ void Serialized_ops_struct_w_bitmask(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 5);
 
@@ -2092,7 +2092,7 @@ void Serialized_ops_enum(void) {
 
     test_assert(e != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, e, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, e, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 1);
 
@@ -2128,7 +2128,7 @@ void Serialized_ops_struct_w_enum(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 5);
 
@@ -2159,7 +2159,7 @@ void Serialized_ops_missing_metatype(void) {
     });
     test_assert(t != 0);
 
-    const EcsMetaTypeSerialized *s = ecs_get(world, t, EcsMetaTypeSerialized);
+    const EcsTypeSerializer *s = ecs_get(world, t, EcsTypeSerializer);
     test_assert(s != NULL);
     test_int(ecs_vec_count(&s->ops), 2);
     
diff --git a/test/meta/src/StructTypes.c b/test/meta/src/StructTypes.c
index 49450669b..d3770d8ca 100644
--- a/test/meta/src/StructTypes.c
+++ b/test/meta/src/StructTypes.c
@@ -11,7 +11,7 @@ void _meta_test_struct(
     test_int(ct->size, size);
     test_int(ct->alignment, alignment);
 
-    const EcsMetaType *mt = ecs_get(world, t, EcsMetaType);
+    const EcsType *mt = ecs_get(world, t, EcsType);
     test_assert(mt != NULL);
     test_assert(mt->kind == EcsStructType);
 }
@@ -368,7 +368,7 @@ void StructTypes_incomplete_member(void) {
 
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t t = ecs_new_id(world);
+    ecs_entity_t t = ecs_new(world);
 
     ecs_entity_t m_x = ecs_new_w_pair(world, EcsChildOf, t);
     ecs_set_name(world, m_x, "x");
@@ -412,7 +412,7 @@ void StructTypes_partial_type(void) {
     test_int(cptr->size, sizeof(Position));
     test_int(cptr->alignment, ECS_ALIGNOF(Position));
 
-    const EcsMetaType *mptr = ecs_get(world, s, EcsMetaType);
+    const EcsType *mptr = ecs_get(world, s, EcsType);
     test_assert(mptr != NULL);
     test_bool(mptr->partial, true);
     test_bool(mptr->existing, true);
@@ -444,7 +444,7 @@ void StructTypes_partial_type_custom_offset(void) {
     test_int(cptr->size, sizeof(Vec3));
     test_int(cptr->alignment, ECS_ALIGNOF(Vec3));
 
-    const EcsMetaType *mptr = ecs_get(world, s, EcsMetaType);
+    const EcsType *mptr = ecs_get(world, s, EcsType);
     test_assert(mptr != NULL);
     test_bool(mptr->partial, true);
     test_bool(mptr->existing, true);
@@ -813,7 +813,7 @@ void StructTypes_struct_w_16_alignment(void) {
     test_int(cptr->size, sizeof(T));
     test_int(cptr->alignment, 16);
 
-    const EcsMetaType *mptr = ecs_get(world, t, EcsMetaType);
+    const EcsType *mptr = ecs_get(world, t, EcsType);
     test_assert(mptr != NULL);
     test_bool(mptr->partial, false);
     test_bool(mptr->existing, true);
diff --git a/test/meta/src/Units.c b/test/meta/src/Units.c
index 2424ebe0a..e1ed8ad9f 100644
--- a/test/meta/src/Units.c
+++ b/test/meta/src/Units.c
@@ -51,7 +51,7 @@ void Units_member_w_unit_type(void) {
     });
     test_assert(u != 0);
     test_str("percentage", ecs_get_name(world, u));
-    test_assert(ecs_has(world, u, EcsMetaType));
+    test_assert(ecs_has(world, u, EcsType));
 
     ecs_unit_init(world, &(ecs_unit_desc_t){
         .entity = u,
@@ -106,7 +106,7 @@ void Units_cursor_get_unit(void) {
         }
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     void *ptr = ecs_ensure_id(world, e, s);
     test_assert(ptr != NULL);
 
@@ -139,7 +139,7 @@ void Units_cursor_get_unit_type(void) {
         }
     });
 
-    ecs_entity_t e = ecs_new_id(world);
+    ecs_entity_t e = ecs_new(world);
     void *ptr = ecs_ensure_id(world, e, s);
     test_assert(ptr != NULL);
 
@@ -351,7 +351,7 @@ void Units_unit_w_over(void) {
 void Units_member_w_invalid_unit(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t u = ecs_new_id(world); /* not a unit */
+    ecs_entity_t u = ecs_new(world); /* not a unit */
     test_assert(u != 0);
 
     ecs_log_set_level(-4);
@@ -369,7 +369,7 @@ void Units_member_w_invalid_unit(void) {
 void Units_unit_w_invalid_quantity(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t q = ecs_new_id(world); /* not a quantity */
+    ecs_entity_t q = ecs_new(world); /* not a quantity */
     test_assert(q != 0);
 
     ecs_log_set_level(-4);
@@ -387,7 +387,7 @@ void Units_unit_w_invalid_quantity(void) {
 void Units_unit_w_invalid_derived(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t u_1 = ecs_new_id(world); /* not a unit */
+    ecs_entity_t u_1 = ecs_new(world); /* not a unit */
     test_assert(u_1 != 0);
 
     ecs_log_set_level(-4);
@@ -405,7 +405,7 @@ void Units_unit_w_invalid_derived(void) {
 void Units_unit_w_invalid_over(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t u_1 = ecs_new_id(world); /* not a unit */
+    ecs_entity_t u_1 = ecs_new(world); /* not a unit */
     test_assert(u_1 != 0);
 
     ecs_entity_t u_2 = ecs_unit_init(world, &(ecs_unit_desc_t){
@@ -631,11 +631,11 @@ void Units_set_unit(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t q = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = { EcsQuantity }
+        .add = ecs_ids( EcsQuantity )
     });
     test_assert(q != 0);
 
-    ecs_entity_t u = ecs_new_id(world);
+    ecs_entity_t u = ecs_new(world);
     test_assert(u != 0);
 
     ecs_set(world, u, EcsUnit, {
@@ -679,18 +679,18 @@ void Units_set_unit_w_derived(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t q = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = { EcsQuantity }
+        .add = ecs_ids( EcsQuantity )
     });
     test_assert(q != 0);
 
-    ecs_entity_t d = ecs_new_id(world);
+    ecs_entity_t d = ecs_new(world);
     test_assert(d != 0);
 
     ecs_set(world, d, EcsUnit, {
         .symbol = "d"
     });
 
-    ecs_entity_t u = ecs_new_id(world);
+    ecs_entity_t u = ecs_new(world);
     test_assert(u != 0);
 
     ecs_set(world, u, EcsUnit, {
@@ -736,25 +736,25 @@ void Units_set_unit_w_over(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t q = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = { EcsQuantity }
+        .add = ecs_ids( EcsQuantity )
     });
     test_assert(q != 0);
 
-    ecs_entity_t d = ecs_new_id(world);
+    ecs_entity_t d = ecs_new(world);
     test_assert(d != 0);
 
     ecs_set(world, d, EcsUnit, {
         .symbol = "d"
     });
 
-    ecs_entity_t o = ecs_new_id(world);
+    ecs_entity_t o = ecs_new(world);
     test_assert(o != 0);
 
     ecs_set(world, o, EcsUnit, {
         .symbol = "o"
     });
 
-    ecs_entity_t u = ecs_new_id(world);
+    ecs_entity_t u = ecs_new(world);
     test_assert(u != 0);
 
     ecs_set(world, u, EcsUnit, {
@@ -801,18 +801,18 @@ void Units_set_unit_w_prefix(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t q = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .add = { EcsQuantity }
+        .add = ecs_ids( EcsQuantity )
     });
     test_assert(q != 0);
 
-    ecs_entity_t d = ecs_new_id(world);
+    ecs_entity_t d = ecs_new(world);
     test_assert(d != 0);
 
     ecs_set(world, d, EcsUnit, {
         .symbol = "d"
     });
 
-    ecs_entity_t p = ecs_new_id(world);
+    ecs_entity_t p = ecs_new(world);
     test_assert(p != 0);
 
     ecs_set(world, p, EcsUnitPrefix, {
@@ -821,7 +821,7 @@ void Units_set_unit_w_prefix(void) {
         .translation.power = 2
     });
 
-    ecs_entity_t u = ecs_new_id(world);
+    ecs_entity_t u = ecs_new(world);
     test_assert(u != 0);
 
     ecs_set(world, u, EcsUnit, {
diff --git a/test/meta/src/Vars.c b/test/meta/src/Vars.c
deleted file mode 100644
index ca8112d06..000000000
--- a/test/meta/src/Vars.c
+++ /dev/null
@@ -1,406 +0,0 @@
-#include <meta.h>
-
-void Vars_declare_1_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
-    test_assert(v != NULL);
-    test_assert(v->value.ptr != NULL);
-    test_assert(v->value.type != 0);
-    test_uint(v->value.type, ecs_id(ecs_i32_t));
-    test_int(*(int32_t*)v->value.ptr, 0);
-
-    const ecs_expr_var_t *v2 = ecs_vars_lookup(&vars, "foo");
-    test_assert(v2 != NULL);
-    test_assert(v == v2);
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_declare_2_vars(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
-    test_assert(foo != NULL);
-    test_assert(foo->value.ptr != NULL);
-    test_assert(foo->value.type != 0);
-    test_uint(foo->value.type, ecs_id(ecs_i32_t));
-    test_int(*(int32_t*)foo->value.ptr, 0);
-
-    ecs_expr_var_t *bar = ecs_vars_declare(
-        &vars, "bar", ecs_id(ecs_u32_t));
-    test_assert(bar != NULL);
-    test_assert(bar->value.ptr != NULL);
-    test_assert(bar->value.type != 0);
-    test_uint(bar->value.type, ecs_id(ecs_u32_t));
-    test_uint(*(ecs_u32_t*)bar->value.ptr, 0);
-
-    test_assert(foo == ecs_vars_lookup(&vars, "foo"));
-    test_assert(bar == ecs_vars_lookup(&vars, "bar"));
-    test_assert(foo != bar);
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_declare_vars_nested_scope(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_vars_push(&vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
-    test_assert(foo != NULL);
-    test_assert(foo->value.ptr != NULL);
-    test_assert(foo->value.type != 0);
-    test_uint(foo->value.type, ecs_id(ecs_i32_t));
-    test_int(*(int32_t*)foo->value.ptr, 0);
-    test_assert(foo == ecs_vars_lookup(&vars, "foo"));
-
-    test_int(0, ecs_vars_pop(&vars));
-
-    test_assert(NULL == ecs_vars_lookup(&vars, "foo"));
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_declare_vars_2_scopes(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
-    test_assert(foo != NULL);
-    test_assert(foo->value.ptr != NULL);
-    test_assert(foo->value.type != 0);
-    test_uint(foo->value.type, ecs_id(ecs_i32_t));
-    test_int(*(int32_t*)foo->value.ptr, 0);
-    test_assert(foo == ecs_vars_lookup(&vars, "foo"));
-
-    ecs_vars_push(&vars);
-
-    ecs_expr_var_t *bar = ecs_vars_declare(
-        &vars, "bar", ecs_id(ecs_u32_t));
-    test_assert(bar != NULL);
-    test_assert(bar->value.ptr != NULL);
-    test_assert(bar->value.type != 0);
-    test_uint(bar->value.type, ecs_id(ecs_u32_t));
-    test_uint(*(ecs_u32_t*)bar->value.ptr, 0);
-
-    test_assert(foo == ecs_vars_lookup(&vars, "foo"));
-    test_assert(bar == ecs_vars_lookup(&vars, "bar"));
-    test_assert(foo != bar);
-
-    ecs_vars_pop(&vars);
-
-    test_assert(foo == ecs_vars_lookup(&vars, "foo"));
-    test_assert(NULL == ecs_vars_lookup(&vars, "bar"));
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_redeclare_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
-    test_assert(foo != NULL);
-    test_assert(foo->value.ptr != NULL);
-    test_assert(foo->value.type != 0);
-    test_uint(foo->value.type, ecs_id(ecs_i32_t));
-    test_int(*(int32_t*)foo->value.ptr, 0);
-    test_assert(foo == ecs_vars_lookup(&vars, "foo"));
-
-    ecs_log_set_level(-4);
-    ecs_expr_var_t *foo_2 = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
-    test_assert(foo_2 == NULL);
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_i32_expr_w_i32_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
-    *(int32_t*)foo->value.ptr = 10;
-
-    int32_t v = 0;
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(
-        world, "$foo", &ecs_value(ecs_i32_t, &v), &desc);
-    test_assert(ptr != NULL);
-    test_assert(ptr[0] == 0);
-    test_int(v, 10);
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_i32_expr_w_f32_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_f32_t));
-    *(float*)foo->value.ptr = 10.5;
-
-    int32_t v = 0;
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(
-        world, "$foo", &ecs_value(ecs_i32_t, &v), &desc);
-    test_assert(ptr != NULL);
-    test_assert(ptr[0] == 0);
-    test_int(v, 10);
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_i32_expr_w_string_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(&vars, "foo", ecs_id(ecs_string_t));
-    *(char**)foo->value.ptr = "10";
-
-    int32_t v = 0;
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(
-        world, "$foo", &ecs_value(ecs_i32_t, &v), &desc);
-    test_assert(ptr != NULL);
-    test_assert(ptr[0] == 0);
-    test_int(v, 10);
-
-    *(char**)foo->value.ptr = NULL;
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_string_expr_w_string_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(&vars, "foo", ecs_id(ecs_string_t));
-    *(char**)foo->value.ptr = "Hello World";
-
-    char* v = NULL;
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(
-        world, "$foo", &ecs_value(ecs_string_t, &v), &desc);
-    test_assert(ptr != NULL);
-    test_assert(ptr[0] == 0);
-    test_str(v, "Hello World");
-    
-    ecs_os_free(v);
-
-    *(char**)foo->value.ptr = NULL;
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_struct_expr_w_i32_vars(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t point = ecs_struct_init(world, &(ecs_struct_desc_t){
-        .members = {
-            {"x", ecs_id(ecs_i32_t)},
-            {"y", ecs_id(ecs_i32_t)}
-        }
-    });
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(&vars, "foo", ecs_id(ecs_i32_t));
-    *(int32_t*)foo->value.ptr = 10;
-    ecs_expr_var_t *bar = ecs_vars_declare(&vars, "bar", ecs_id(ecs_i32_t));
-    *(int32_t*)bar->value.ptr = 20;
-
-    Position v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(world, "{$foo, $bar}", &(ecs_value_t){point, &v}, &desc);
-    test_assert(ptr != NULL);
-    test_assert(ptr[0] == 0);
-
-    test_int(v.x, 10);
-    test_int(v.y, 20);
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_struct_expr_w_struct_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t point = ecs_struct_init(world, &(ecs_struct_desc_t){
-        .members = {
-            {"x", ecs_id(ecs_i32_t)},
-            {"y", ecs_id(ecs_i32_t)}
-        }
-    });
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(&vars, "foo", point);
-    *(Position*)foo->value.ptr = (Position){10, 20};
-
-    Position v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(world, "$foo", &(ecs_value_t){point, &v}, &desc);
-    test_assert(ptr != NULL);
-    test_assert(ptr[0] == 0);
-
-    test_int(v.x, 10);
-    test_int(v.y, 20);
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_nested_struct_expr_w_struct_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t point = ecs_struct_init(world, &(ecs_struct_desc_t){
-        .members = {
-            {"x", ecs_id(ecs_i32_t)},
-            {"y", ecs_id(ecs_i32_t)}
-        }
-    });
-
-    ecs_entity_t line = ecs_struct_init(world, &(ecs_struct_desc_t){
-        .members = {
-            {"start", point},
-            {"stop", point}
-        }
-    });
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *foo = ecs_vars_declare(&vars, "foo", point);
-    *(Position*)foo->value.ptr = (Position){10, 20};
-    ecs_expr_var_t *bar = ecs_vars_declare(&vars, "bar", point);
-    *(Position*)bar->value.ptr = (Position){30, 40};
-
-    Line v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(world, 
-        "{start: $foo, stop: $bar}", &(ecs_value_t){line, &v}, &desc);
-    test_assert(ptr != NULL);
-    test_assert(ptr[0] == 0);
-
-    test_int(v.start.x, 10);
-    test_int(v.start.y, 20);
-    test_int(v.stop.x, 30);
-    test_int(v.stop.y, 40);
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_declare_w_value(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_value_t src;
-    src.type = ecs_id(ecs_i32_t);
-    src.ptr = ecs_value_new_t(world, ecs_i32_t);
-    *(int32_t*)src.ptr = 10;
-    void *src_ptr = src.ptr;
-
-    ecs_expr_var_t *v = ecs_vars_declare_w_value(
-        &vars, "foo", &src);
-    test_assert(v != NULL);
-    test_assert(v->value.ptr != NULL);
-    test_assert(v->value.type != 0);
-    test_uint(v->value.type, ecs_id(ecs_i32_t));
-    test_int(*(int32_t*)v->value.ptr, 10);
-    test_assert(v->value.ptr == src_ptr);
-    test_assert(src.ptr == NULL);
-
-    const ecs_expr_var_t *v2 = ecs_vars_lookup(&vars, "foo");
-    test_assert(v2 != NULL);
-    test_assert(v == v2);
-
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_redeclare_in_scope(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_expr_var_t *v1 = ecs_vars_declare(&vars, "foo", ecs_id(ecs_i32_t));
-    test_assert(v1 != NULL);
-    ecs_vars_push(&vars);
-    ecs_expr_var_t *v2 = ecs_vars_declare(&vars, "foo", ecs_id(ecs_i32_t));
-    test_assert(v2 != NULL);
-    test_assert(v1 != v2);
-    test_assert(ecs_vars_lookup(&vars, "foo") == v2);
-    ecs_vars_pop(&vars);
-    test_assert(ecs_vars_lookup(&vars, "foo") == v1);
-    ecs_vars_fini(&vars);
-
-    ecs_fini(world);
-}
-
-void Vars_init_fini_vars(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
-
-    ecs_vars_fini(&vars);
-    ecs_fini(world);
-
-    test_assert(true);
-}
diff --git a/test/meta/src/VectorTypes.c b/test/meta/src/VectorTypes.c
index 32bc81b17..19949106a 100644
--- a/test/meta/src/VectorTypes.c
+++ b/test/meta/src/VectorTypes.c
@@ -10,7 +10,7 @@ void meta_test_vector(
     test_int(ct->size, ECS_SIZEOF(ecs_vec_t));
     test_int(ct->alignment, ECS_ALIGNOF(ecs_vec_t));
 
-    const EcsMetaType *mt = ecs_get(world, t, EcsMetaType);
+    const EcsType *mt = ecs_get(world, t, EcsType);
     test_assert(mt != NULL);
     test_assert(mt->kind == EcsVectorType);
 
diff --git a/test/meta/src/main.c b/test/meta/src/main.c
index 2a7000980..934bab126 100644
--- a/test/meta/src/main.c
+++ b/test/meta/src/main.c
@@ -400,122 +400,6 @@ void Cursor_next_out_of_bounds(void);
 void Cursor_set_out_of_bounds(void);
 void Cursor_get_member_id(void);
 
-// Testsuite 'DeserializeFromExpr'
-void DeserializeFromExpr_bool(void);
-void DeserializeFromExpr_byte(void);
-void DeserializeFromExpr_char(void);
-void DeserializeFromExpr_char_literal(void);
-void DeserializeFromExpr_i8(void);
-void DeserializeFromExpr_i16(void);
-void DeserializeFromExpr_i32(void);
-void DeserializeFromExpr_i64(void);
-void DeserializeFromExpr_iptr(void);
-void DeserializeFromExpr_u8(void);
-void DeserializeFromExpr_u16(void);
-void DeserializeFromExpr_u32(void);
-void DeserializeFromExpr_u64(void);
-void DeserializeFromExpr_uptr(void);
-void DeserializeFromExpr_float(void);
-void DeserializeFromExpr_double(void);
-void DeserializeFromExpr_negative_int(void);
-void DeserializeFromExpr_negative_float(void);
-void DeserializeFromExpr_string(void);
-void DeserializeFromExpr_entity(void);
-void DeserializeFromExpr_id(void);
-void DeserializeFromExpr_enum(void);
-void DeserializeFromExpr_bitmask(void);
-void DeserializeFromExpr_struct_enum(void);
-void DeserializeFromExpr_struct_bitmask(void);
-void DeserializeFromExpr_struct_i32(void);
-void DeserializeFromExpr_struct_i32_neg(void);
-void DeserializeFromExpr_struct_i32_i32(void);
-void DeserializeFromExpr_struct_entity(void);
-void DeserializeFromExpr_struct_id(void);
-void DeserializeFromExpr_struct_nested_i32(void);
-void DeserializeFromExpr_struct_nested_i32_i32(void);
-void DeserializeFromExpr_struct_2_nested_i32_i32(void);
-void DeserializeFromExpr_struct_member_i32(void);
-void DeserializeFromExpr_struct_member_i32_neg(void);
-void DeserializeFromExpr_struct_member_i32_i32(void);
-void DeserializeFromExpr_struct_member_nested_i32(void);
-void DeserializeFromExpr_struct_member_nested_i32_i32(void);
-void DeserializeFromExpr_struct_member_2_nested_i32_i32(void);
-void DeserializeFromExpr_struct_member_2_nested_i32_i32_reverse(void);
-void DeserializeFromExpr_struct_i32_array_3(void);
-void DeserializeFromExpr_struct_struct_i32_array_3(void);
-void DeserializeFromExpr_struct_struct_i32_i32_array_3(void);
-void DeserializeFromExpr_struct_w_array_type_i32_i32(void);
-void DeserializeFromExpr_struct_w_array_type_struct(void);
-void DeserializeFromExpr_struct_w_2_array_type_i32_i32(void);
-void DeserializeFromExpr_struct_w_2_array_type_struct(void);
-void DeserializeFromExpr_discover_type_int(void);
-void DeserializeFromExpr_discover_type_negative_int(void);
-void DeserializeFromExpr_discover_type_float(void);
-void DeserializeFromExpr_discover_type_negative_float(void);
-void DeserializeFromExpr_discover_type_string(void);
-void DeserializeFromExpr_discover_type_multiline_string(void);
-void DeserializeFromExpr_discover_type_entity(void);
-void DeserializeFromExpr_discover_type_bool(void);
-void DeserializeFromExpr_discover_type_unknown(void);
-void DeserializeFromExpr_discover_type_invalid(void);
-
-// Testsuite 'SerializeToExpr'
-void SerializeToExpr_bool(void);
-void SerializeToExpr_byte(void);
-void SerializeToExpr_char(void);
-void SerializeToExpr_i8(void);
-void SerializeToExpr_i16(void);
-void SerializeToExpr_i32(void);
-void SerializeToExpr_i64(void);
-void SerializeToExpr_iptr(void);
-void SerializeToExpr_u8(void);
-void SerializeToExpr_u16(void);
-void SerializeToExpr_u32(void);
-void SerializeToExpr_u64(void);
-void SerializeToExpr_uptr(void);
-void SerializeToExpr_float(void);
-void SerializeToExpr_double(void);
-void SerializeToExpr_string(void);
-void SerializeToExpr_entity(void);
-void SerializeToExpr_entity_10k(void);
-void SerializeToExpr_id(void);
-void SerializeToExpr_enum(void);
-void SerializeToExpr_bitmask(void);
-void SerializeToExpr_float_nan(void);
-void SerializeToExpr_float_inf(void);
-void SerializeToExpr_double_nan(void);
-void SerializeToExpr_double_inf(void);
-void SerializeToExpr_struct_enum(void);
-void SerializeToExpr_struct_bitmask(void);
-void SerializeToExpr_struct_i32(void);
-void SerializeToExpr_struct_i32_i32(void);
-void SerializeToExpr_struct_entity(void);
-void SerializeToExpr_struct_id(void);
-void SerializeToExpr_array_i32_3(void);
-void SerializeToExpr_array_struct_i32_i32(void);
-void SerializeToExpr_array_array_i32_3(void);
-void SerializeToExpr_vector_i32_3(void);
-void SerializeToExpr_vector_struct_i32_i32(void);
-void SerializeToExpr_vector_array_i32_3(void);
-void SerializeToExpr_entity_entity_after_float(void);
-void SerializeToExpr_struct_nested_i32(void);
-void SerializeToExpr_struct_nested_i32_i32(void);
-void SerializeToExpr_struct_2_nested_i32_i32(void);
-void SerializeToExpr_struct_i32_array_3(void);
-void SerializeToExpr_struct_struct_i32_array_3(void);
-void SerializeToExpr_struct_struct_i32_i32_array_3(void);
-void SerializeToExpr_struct_w_array_type_i32_i32(void);
-void SerializeToExpr_struct_w_array_type_struct(void);
-void SerializeToExpr_struct_w_2_array_type_i32_i32(void);
-void SerializeToExpr_struct_w_2_array_type_struct(void);
-void SerializeToExpr_struct_partial(void);
-void SerializeToExpr_escape_simple_string(void);
-void SerializeToExpr_escape_newline(void);
-void SerializeToExpr_escape_2_newlines(void);
-void SerializeToExpr_escape_string_w_trailing_newline(void);
-void SerializeToExpr_escape_string_w_2_trailing_newlines(void);
-void SerializeToExpr_escape_string_w_delim(void);
-
 // Testsuite 'DeserializeFromJson'
 void DeserializeFromJson_struct_bool(void);
 void DeserializeFromJson_struct_byte(void);
@@ -724,12 +608,6 @@ void SerializeEntityToJson_serialize_w_link(void);
 void SerializeEntityToJson_serialize_w_link_no_link(void);
 void SerializeEntityToJson_serialize_color(void);
 void SerializeEntityToJson_serialize_w_doc_w_quotes(void);
-void SerializeEntityToJson_serialize_union_relationship(void);
-void SerializeEntityToJson_serialize_union_relationship_w_labels(void);
-void SerializeEntityToJson_serialize_union_relationship_invalid_entity(void);
-void SerializeEntityToJson_serialize_union_relationship_invalid_entity_w_labels(void);
-void SerializeEntityToJson_serialize_w_union_property(void);
-void SerializeEntityToJson_serialize_w_union_property(void);
 void SerializeEntityToJson_serialize_from_core(void);
 void SerializeEntityToJson_serialize_w_1_alert(void);
 void SerializeEntityToJson_serialize_w_2_alerts(void);
@@ -972,151 +850,6 @@ void MetaUtils_enum_constant_w_name_prefix(void);
 void MetaUtils_enum_constant_w_type_prefix(void);
 void MetaUtils_enum_constant_w_name_type_prefix(void);
 
-// Testsuite 'Vars'
-void Vars_declare_1_var(void);
-void Vars_declare_2_vars(void);
-void Vars_declare_vars_nested_scope(void);
-void Vars_declare_vars_2_scopes(void);
-void Vars_redeclare_var(void);
-void Vars_i32_expr_w_i32_var(void);
-void Vars_i32_expr_w_f32_var(void);
-void Vars_i32_expr_w_string_var(void);
-void Vars_string_expr_w_string_var(void);
-void Vars_struct_expr_w_i32_vars(void);
-void Vars_struct_expr_w_struct_var(void);
-void Vars_nested_struct_expr_w_struct_var(void);
-void Vars_declare_w_value(void);
-void Vars_redeclare_in_scope(void);
-void Vars_init_fini_vars(void);
-
-// Testsuite 'DeserExprOperators'
-void DeserExprOperators_add_2_int_literals(void);
-void DeserExprOperators_add_2_int_literals_twice(void);
-void DeserExprOperators_sub_2_int_literals(void);
-void DeserExprOperators_mul_2_int_literals(void);
-void DeserExprOperators_div_2_int_literals(void);
-void DeserExprOperators_add_3_int_literals(void);
-void DeserExprOperators_add_3_int_literals_twice(void);
-void DeserExprOperators_sub_3_int_literals(void);
-void DeserExprOperators_mul_3_int_literals(void);
-void DeserExprOperators_div_3_int_literals(void);
-void DeserExprOperators_int_to_bool(void);
-void DeserExprOperators_bool_to_int(void);
-void DeserExprOperators_bool_to_uint(void);
-void DeserExprOperators_add_mul_3_int_literals(void);
-void DeserExprOperators_sub_mul_3_int_literals(void);
-void DeserExprOperators_div_mul_3_int_literals(void);
-void DeserExprOperators_add_div_3_int_literals(void);
-void DeserExprOperators_sub_div_3_int_literals(void);
-void DeserExprOperators_mul_div_3_int_literals(void);
-void DeserExprOperators_mul_add_mul_add_int_literals(void);
-void DeserExprOperators_mul_sub_mul_sub_int_literals(void);
-void DeserExprOperators_mul_div_mul_div_int_literals(void);
-void DeserExprOperators_div_add_div_add_int_literals(void);
-void DeserExprOperators_div_sub_div_sub_int_literals(void);
-void DeserExprOperators_div_sub_div_mul_int_literals(void);
-void DeserExprOperators_div_mul_div_mul_int_literals(void);
-void DeserExprOperators_add_2_flt_literals(void);
-void DeserExprOperators_sub_2_flt_literals(void);
-void DeserExprOperators_mul_2_flt_literals(void);
-void DeserExprOperators_div_2_flt_literals(void);
-void DeserExprOperators_add_2_int_neg_literals(void);
-void DeserExprOperators_sub_2_int_neg_literals(void);
-void DeserExprOperators_mul_2_int_neg_literals(void);
-void DeserExprOperators_div_2_int_neg_literals(void);
-void DeserExprOperators_mul_lparen_add_add_rparen_int_literals(void);
-void DeserExprOperators_mul_lparen_add_add_add_rparen_int_literals(void);
-void DeserExprOperators_mul_lparen_add_add_rparen_add_int_literals(void);
-void DeserExprOperators_lparen_add_add_rparen_mul_int_literals(void);
-void DeserExprOperators_lparen_add_add_add_rparen_mul_int_literals(void);
-void DeserExprOperators_double_paren_add_add(void);
-void DeserExprOperators_double_paren_literal(void);
-void DeserExprOperators_lparen_add_add_rparen_mul_lparen_add_add_rparen(void);
-void DeserExprOperators_float_result_add_2_int_literals(void);
-void DeserExprOperators_struct_result_add_2_int_literals(void);
-void DeserExprOperators_struct_result_add_2_2_fields_int_literals(void);
-void DeserExprOperators_struct_result_add_3_int_literals(void);
-void DeserExprOperators_struct_result_lparen_int_rparen(void);
-void DeserExprOperators_add_to_var(void);
-void DeserExprOperators_add_var_to(void);
-void DeserExprOperators_var_member(void);
-void DeserExprOperators_bool_cond_and_bool(void);
-void DeserExprOperators_bool_cond_or_bool(void);
-void DeserExprOperators_int_cond_and_int(void);
-void DeserExprOperators_int_cond_or_int(void);
-void DeserExprOperators_bool_cond_and_int(void);
-void DeserExprOperators_int_cond_and_bool(void);
-void DeserExprOperators_bool_cond_or_int(void);
-void DeserExprOperators_int_cond_or_bool(void);
-void DeserExprOperators_cond_eq_bool(void);
-void DeserExprOperators_cond_eq_int(void);
-void DeserExprOperators_cond_neq_bool(void);
-void DeserExprOperators_cond_neq_int(void);
-void DeserExprOperators_cond_eq_bool_int(void);
-void DeserExprOperators_cond_eq_int_flt(void);
-void DeserExprOperators_cond_eq_cond_and(void);
-void DeserExprOperators_cond_eq_cond_or(void);
-void DeserExprOperators_cond_gt_bool(void);
-void DeserExprOperators_cond_gt_int(void);
-void DeserExprOperators_cond_gt_flt(void);
-void DeserExprOperators_cond_gteq_bool(void);
-void DeserExprOperators_cond_gteq_int(void);
-void DeserExprOperators_cond_gteq_flt(void);
-void DeserExprOperators_cond_lt_bool(void);
-void DeserExprOperators_cond_lt_int(void);
-void DeserExprOperators_cond_lt_flt(void);
-void DeserExprOperators_cond_lteq_bool(void);
-void DeserExprOperators_cond_lteq_int(void);
-void DeserExprOperators_cond_lteq_flt(void);
-void DeserExprOperators_min_lparen_int_rparen(void);
-void DeserExprOperators_min_lparen_int_add_int_rparen(void);
-void DeserExprOperators_min_var(void);
-void DeserExprOperators_min_lparen_int_rparen_to_i64(void);
-void DeserExprOperators_min_lparen_int_rparen_to_i32(void);
-void DeserExprOperators_struct_w_min_var(void);
-void DeserExprOperators_struct_w_min_lparen_int_rparen(void);
-void DeserExprOperators_struct_w_min_lparen_var_rparen(void);
-void DeserExprOperators_shift_left_int(void);
-void DeserExprOperators_shift_right_int(void);
-void DeserExprOperators_shift_left_int_add_int(void);
-void DeserExprOperators_shift_left_int_mul_int(void);
-void DeserExprOperators_add_int_shift_left_int(void);
-void DeserExprOperators_mul_int_shift_left_int(void);
-void DeserExprOperators_add_int_shift_left_int_add_int(void);
-void DeserExprOperators_mul_int_shift_left_int_mul_int(void);
-void DeserExprOperators_entity_expr(void);
-void DeserExprOperators_entity_path_expr(void);
-void DeserExprOperators_entity_parent_func(void);
-void DeserExprOperators_entity_name_func(void);
-void DeserExprOperators_entity_doc_name_func(void);
-void DeserExprOperators_entity_chain_func(void);
-void DeserExprOperators_var_parent_func(void);
-void DeserExprOperators_var_name_func(void);
-void DeserExprOperators_var_doc_name_func(void);
-void DeserExprOperators_var_chain_func(void);
-void DeserExprOperators_interpolate_string_w_i32_var(void);
-void DeserExprOperators_interpolate_string_w_string_var(void);
-void DeserExprOperators_interpolate_string_w_entity_var(void);
-void DeserExprOperators_interpolate_string_w_id_var(void);
-void DeserExprOperators_interpolate_string_w_var_not_found(void);
-void DeserExprOperators_interpolate_string_w_entity_var_0(void);
-void DeserExprOperators_interpolate_string_w_var_special_chars(void);
-void DeserExprOperators_interpolate_string_w_var_before_after_text(void);
-void DeserExprOperators_interpolate_string_w_curly_brackets_var(void);
-void DeserExprOperators_interpolate_string_w_curly_brackets_expr(void);
-void DeserExprOperators_interpolate_string_w_curly_brackets_expr_w_var(void);
-void DeserExprOperators_interpolate_string_w_curly_brackets_expr_w_composite_var(void);
-void DeserExprOperators_interpolate_string_w_escape_var_operator(void);
-void DeserExprOperators_interpolate_string_w_escape_curly_brackets(void);
-void DeserExprOperators_interpolate_string_w_func(void);
-void DeserExprOperators_interpolate_string_w_func_chain(void);
-void DeserExprOperators_iter_to_vars_no_data(void);
-void DeserExprOperators_iter_to_vars_1_comp(void);
-void DeserExprOperators_iter_to_vars_2_comps(void);
-void DeserExprOperators_iter_to_vars_1_comp_1_tag(void);
-void DeserExprOperators_iter_to_vars_w_1_query_var(void);
-void DeserExprOperators_iter_to_vars_w_2_query_vars(void);
-
 // Testsuite 'OpaqueTypes'
 void OpaqueTypes_ser_i32_type_to_json(void);
 void OpaqueTypes_ser_string_type_to_json(void);
@@ -2696,2811 +2429,1763 @@ bake_test_case Cursor_testcases[] = {
     }
 };
 
-bake_test_case DeserializeFromExpr_testcases[] = {
-    {
-        "bool",
-        DeserializeFromExpr_bool
-    },
-    {
-        "byte",
-        DeserializeFromExpr_byte
-    },
+bake_test_case DeserializeFromJson_testcases[] = {
     {
-        "char",
-        DeserializeFromExpr_char
+        "struct_bool",
+        DeserializeFromJson_struct_bool
     },
     {
-        "char_literal",
-        DeserializeFromExpr_char_literal
+        "struct_byte",
+        DeserializeFromJson_struct_byte
     },
     {
-        "i8",
-        DeserializeFromExpr_i8
+        "struct_char",
+        DeserializeFromJson_struct_char
     },
     {
-        "i16",
-        DeserializeFromExpr_i16
+        "struct_char_literal",
+        DeserializeFromJson_struct_char_literal
     },
     {
-        "i32",
-        DeserializeFromExpr_i32
+        "struct_i8",
+        DeserializeFromJson_struct_i8
     },
     {
-        "i64",
-        DeserializeFromExpr_i64
+        "struct_i16",
+        DeserializeFromJson_struct_i16
     },
     {
-        "iptr",
-        DeserializeFromExpr_iptr
+        "struct_i32",
+        DeserializeFromJson_struct_i32
     },
     {
-        "u8",
-        DeserializeFromExpr_u8
+        "struct_i64",
+        DeserializeFromJson_struct_i64
     },
     {
-        "u16",
-        DeserializeFromExpr_u16
+        "struct_iptr",
+        DeserializeFromJson_struct_iptr
     },
     {
-        "u32",
-        DeserializeFromExpr_u32
+        "struct_u8",
+        DeserializeFromJson_struct_u8
     },
     {
-        "u64",
-        DeserializeFromExpr_u64
+        "struct_u16",
+        DeserializeFromJson_struct_u16
     },
     {
-        "uptr",
-        DeserializeFromExpr_uptr
+        "struct_u32",
+        DeserializeFromJson_struct_u32
     },
     {
-        "float",
-        DeserializeFromExpr_float
+        "struct_u64",
+        DeserializeFromJson_struct_u64
     },
     {
-        "double",
-        DeserializeFromExpr_double
+        "struct_uptr",
+        DeserializeFromJson_struct_uptr
     },
     {
-        "negative_int",
-        DeserializeFromExpr_negative_int
+        "struct_float",
+        DeserializeFromJson_struct_float
     },
     {
-        "negative_float",
-        DeserializeFromExpr_negative_float
+        "struct_double",
+        DeserializeFromJson_struct_double
     },
     {
-        "string",
-        DeserializeFromExpr_string
+        "struct_negative_int",
+        DeserializeFromJson_struct_negative_int
     },
     {
-        "entity",
-        DeserializeFromExpr_entity
+        "struct_negative_float",
+        DeserializeFromJson_struct_negative_float
     },
     {
-        "id",
-        DeserializeFromExpr_id
+        "struct_string",
+        DeserializeFromJson_struct_string
     },
     {
-        "enum",
-        DeserializeFromExpr_enum
+        "struct_entity",
+        DeserializeFromJson_struct_entity
     },
     {
-        "bitmask",
-        DeserializeFromExpr_bitmask
+        "struct_id",
+        DeserializeFromJson_struct_id
     },
     {
         "struct_enum",
-        DeserializeFromExpr_struct_enum
+        DeserializeFromJson_struct_enum
     },
     {
         "struct_bitmask",
-        DeserializeFromExpr_struct_bitmask
-    },
-    {
-        "struct_i32",
-        DeserializeFromExpr_struct_i32
-    },
-    {
-        "struct_i32_neg",
-        DeserializeFromExpr_struct_i32_neg
+        DeserializeFromJson_struct_bitmask
     },
     {
         "struct_i32_i32",
-        DeserializeFromExpr_struct_i32_i32
-    },
-    {
-        "struct_entity",
-        DeserializeFromExpr_struct_entity
-    },
-    {
-        "struct_id",
-        DeserializeFromExpr_struct_id
+        DeserializeFromJson_struct_i32_i32
     },
     {
         "struct_nested_i32",
-        DeserializeFromExpr_struct_nested_i32
+        DeserializeFromJson_struct_nested_i32
     },
     {
         "struct_nested_i32_i32",
-        DeserializeFromExpr_struct_nested_i32_i32
+        DeserializeFromJson_struct_nested_i32_i32
     },
     {
         "struct_2_nested_i32_i32",
-        DeserializeFromExpr_struct_2_nested_i32_i32
+        DeserializeFromJson_struct_2_nested_i32_i32
     },
     {
-        "struct_member_i32",
-        DeserializeFromExpr_struct_member_i32
+        "struct_i32_array_3",
+        DeserializeFromJson_struct_i32_array_3
     },
     {
-        "struct_member_i32_neg",
-        DeserializeFromExpr_struct_member_i32_neg
+        "struct_struct_i32_array_3",
+        DeserializeFromJson_struct_struct_i32_array_3
     },
     {
-        "struct_member_i32_i32",
-        DeserializeFromExpr_struct_member_i32_i32
+        "struct_struct_i32_i32_array_3",
+        DeserializeFromJson_struct_struct_i32_i32_array_3
     },
     {
-        "struct_member_nested_i32",
-        DeserializeFromExpr_struct_member_nested_i32
+        "struct_w_array_type_i32_i32",
+        DeserializeFromJson_struct_w_array_type_i32_i32
     },
     {
-        "struct_member_nested_i32_i32",
-        DeserializeFromExpr_struct_member_nested_i32_i32
+        "struct_w_2_array_type_i32_i32",
+        DeserializeFromJson_struct_w_2_array_type_i32_i32
     },
     {
-        "struct_member_2_nested_i32_i32",
-        DeserializeFromExpr_struct_member_2_nested_i32_i32
+        "struct_w_nested_member_i32",
+        DeserializeFromJson_struct_w_nested_member_i32
     },
     {
-        "struct_member_2_nested_i32_i32_reverse",
-        DeserializeFromExpr_struct_member_2_nested_i32_i32_reverse
+        "struct_w_2_nested_members_i32",
+        DeserializeFromJson_struct_w_2_nested_members_i32
     },
     {
-        "struct_i32_array_3",
-        DeserializeFromExpr_struct_i32_array_3
+        "struct_w_nested_members_struct",
+        DeserializeFromJson_struct_w_nested_members_struct
     },
     {
-        "struct_struct_i32_array_3",
-        DeserializeFromExpr_struct_struct_i32_array_3
+        "struct_w_2_nested_members_struct",
+        DeserializeFromJson_struct_w_2_nested_members_struct
     },
     {
-        "struct_struct_i32_i32_array_3",
-        DeserializeFromExpr_struct_struct_i32_i32_array_3
+        "deser_entity_1_component_1_member",
+        DeserializeFromJson_deser_entity_1_component_1_member
     },
     {
-        "struct_w_array_type_i32_i32",
-        DeserializeFromExpr_struct_w_array_type_i32_i32
+        "deser_entity_1_component_1_member_w_spaces",
+        DeserializeFromJson_deser_entity_1_component_1_member_w_spaces
     },
     {
-        "struct_w_array_type_struct",
-        DeserializeFromExpr_struct_w_array_type_struct
+        "deser_entity_1_component_2_members",
+        DeserializeFromJson_deser_entity_1_component_2_members
     },
     {
-        "struct_w_2_array_type_i32_i32",
-        DeserializeFromExpr_struct_w_2_array_type_i32_i32
+        "deser_entity_2_components",
+        DeserializeFromJson_deser_entity_2_components
     },
     {
-        "struct_w_2_array_type_struct",
-        DeserializeFromExpr_struct_w_2_array_type_struct
+        "deser_entity_1_component_composite_member",
+        DeserializeFromJson_deser_entity_1_component_composite_member
     },
     {
-        "discover_type_int",
-        DeserializeFromExpr_discover_type_int
+        "deser_entity_1_component_nested_member",
+        DeserializeFromJson_deser_entity_1_component_nested_member
     },
     {
-        "discover_type_negative_int",
-        DeserializeFromExpr_discover_type_negative_int
+        "deser_entity_1_pair",
+        DeserializeFromJson_deser_entity_1_pair
     },
     {
-        "discover_type_float",
-        DeserializeFromExpr_discover_type_float
+        "deser_entity_2_pairs",
+        DeserializeFromJson_deser_entity_2_pairs
     },
     {
-        "discover_type_negative_float",
-        DeserializeFromExpr_discover_type_negative_float
+        "deser_entity_empty",
+        DeserializeFromJson_deser_entity_empty
     },
     {
-        "discover_type_string",
-        DeserializeFromExpr_discover_type_string
+        "deser_entity_w_path",
+        DeserializeFromJson_deser_entity_w_path
     },
     {
-        "discover_type_multiline_string",
-        DeserializeFromExpr_discover_type_multiline_string
+        "deser_entity_w_path_and_ids",
+        DeserializeFromJson_deser_entity_w_path_and_ids
     },
     {
-        "discover_type_entity",
-        DeserializeFromExpr_discover_type_entity
+        "deser_entity_w_path_and_ids_and_values",
+        DeserializeFromJson_deser_entity_w_path_and_ids_and_values
     },
     {
-        "discover_type_bool",
-        DeserializeFromExpr_discover_type_bool
+        "deser_entity_w_ids",
+        DeserializeFromJson_deser_entity_w_ids
     },
     {
-        "discover_type_unknown",
-        DeserializeFromExpr_discover_type_unknown
+        "ser_deser_mini",
+        DeserializeFromJson_ser_deser_mini
     },
     {
-        "discover_type_invalid",
-        DeserializeFromExpr_discover_type_invalid
-    }
-};
-
-bake_test_case SerializeToExpr_testcases[] = {
-    {
-        "bool",
-        SerializeToExpr_bool
+        "ser_deser_init",
+        DeserializeFromJson_ser_deser_init
     },
     {
-        "byte",
-        SerializeToExpr_byte
+        "ser_deser_mini_serialize_builtin",
+        DeserializeFromJson_ser_deser_mini_serialize_builtin
     },
     {
-        "char",
-        SerializeToExpr_char
+        "ser_deser_mini_serialize_modules",
+        DeserializeFromJson_ser_deser_mini_serialize_modules
     },
     {
-        "i8",
-        SerializeToExpr_i8
+        "ser_deser_mini_serialize_builtin_modules",
+        DeserializeFromJson_ser_deser_mini_serialize_builtin_modules
     },
     {
-        "i16",
-        SerializeToExpr_i16
+        "ser_deser_init_serialize_builtin",
+        DeserializeFromJson_ser_deser_init_serialize_builtin
     },
     {
-        "i32",
-        SerializeToExpr_i32
+        "ser_deser_init_serialize_modules",
+        DeserializeFromJson_ser_deser_init_serialize_modules
     },
     {
-        "i64",
-        SerializeToExpr_i64
+        "ser_deser_init_serialize_builtin_modules",
+        DeserializeFromJson_ser_deser_init_serialize_builtin_modules
     },
     {
-        "iptr",
-        SerializeToExpr_iptr
+        "ser_deser_new_world",
+        DeserializeFromJson_ser_deser_new_world
     },
     {
-        "u8",
-        SerializeToExpr_u8
+        "ser_deser_new_world_1_entity_w_tag",
+        DeserializeFromJson_ser_deser_new_world_1_entity_w_tag
     },
     {
-        "u16",
-        SerializeToExpr_u16
+        "ser_deser_new_world_1_entity_w_component",
+        DeserializeFromJson_ser_deser_new_world_1_entity_w_component
     },
     {
-        "u32",
-        SerializeToExpr_u32
+        "ser_deser_new_world_1_entity_w_component_meta",
+        DeserializeFromJson_ser_deser_new_world_1_entity_w_component_meta
     },
     {
-        "u64",
-        SerializeToExpr_u64
+        "ser_deser_new_world_1_named_entity_w_tag",
+        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_tag
     },
     {
-        "uptr",
-        SerializeToExpr_uptr
+        "ser_deser_new_world_1_named_entity_w_component",
+        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component
     },
     {
-        "float",
-        SerializeToExpr_float
+        "ser_deser_new_world_1_named_entity_w_component_meta",
+        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component_meta
     },
     {
-        "double",
-        SerializeToExpr_double
+        "ser_deser_new_world_1_entity_w_tag_serialize_all",
+        DeserializeFromJson_ser_deser_new_world_1_entity_w_tag_serialize_all
     },
     {
-        "string",
-        SerializeToExpr_string
+        "ser_deser_new_world_1_entity_w_component_serialize_all",
+        DeserializeFromJson_ser_deser_new_world_1_entity_w_component_serialize_all
     },
     {
-        "entity",
-        SerializeToExpr_entity
+        "ser_deser_new_world_1_entity_w_component_meta_serialize_all",
+        DeserializeFromJson_ser_deser_new_world_1_entity_w_component_meta_serialize_all
     },
     {
-        "entity_10k",
-        SerializeToExpr_entity_10k
+        "ser_deser_new_world_1_named_entity_w_tag_serialize_all",
+        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_tag_serialize_all
     },
     {
-        "id",
-        SerializeToExpr_id
+        "ser_deser_new_world_1_named_entity_w_component_serialize_all",
+        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component_serialize_all
     },
     {
-        "enum",
-        SerializeToExpr_enum
+        "ser_deser_new_world_1_named_entity_w_component_meta_serialize_all",
+        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component_meta_serialize_all
     },
     {
-        "bitmask",
-        SerializeToExpr_bitmask
+        "ser_deser_new_world_3_entities_w_component_meta",
+        DeserializeFromJson_ser_deser_new_world_3_entities_w_component_meta
     },
     {
-        "float_nan",
-        SerializeToExpr_float_nan
+        "ser_deser_new_world_3_entities_w_2_components_meta",
+        DeserializeFromJson_ser_deser_new_world_3_entities_w_2_components_meta
     },
     {
-        "float_inf",
-        SerializeToExpr_float_inf
+        "ser_deser_new_world_4_entities_2_tables_w_component_meta",
+        DeserializeFromJson_ser_deser_new_world_4_entities_2_tables_w_component_meta
     },
     {
-        "double_nan",
-        SerializeToExpr_double_nan
+        "ser_deser_new_world_component_w_anon_entity_member",
+        DeserializeFromJson_ser_deser_new_world_component_w_anon_entity_member
     },
     {
-        "double_inf",
-        SerializeToExpr_double_inf
+        "ser_deser_new_world_component_w_named_entity_member",
+        DeserializeFromJson_ser_deser_new_world_component_w_named_entity_member
     },
     {
-        "struct_enum",
-        SerializeToExpr_struct_enum
+        "ser_deser_new_world_component_w_anon_and_named_entity_member",
+        DeserializeFromJson_ser_deser_new_world_component_w_anon_and_named_entity_member
     },
     {
-        "struct_bitmask",
-        SerializeToExpr_struct_bitmask
+        "ser_deser_new_world_component_w_anon_entity_with_self",
+        DeserializeFromJson_ser_deser_new_world_component_w_anon_entity_with_self
     },
     {
-        "struct_i32",
-        SerializeToExpr_struct_i32
+        "ser_deser_new_world_component_w_named_entity_with_self",
+        DeserializeFromJson_ser_deser_new_world_component_w_named_entity_with_self
     },
     {
-        "struct_i32_i32",
-        SerializeToExpr_struct_i32_i32
+        "ser_deser_new_world_2_entities_w_anon_parent",
+        DeserializeFromJson_ser_deser_new_world_2_entities_w_anon_parent
     },
     {
-        "struct_entity",
-        SerializeToExpr_struct_entity
+        "ser_deser_new_world_2_entities_w_named_parent",
+        DeserializeFromJson_ser_deser_new_world_2_entities_w_named_parent
     },
     {
-        "struct_id",
-        SerializeToExpr_struct_id
+        "ser_deser_new_world_2_entities_w_anon_parent_w_cycle",
+        DeserializeFromJson_ser_deser_new_world_2_entities_w_anon_parent_w_cycle
     },
     {
-        "array_i32_3",
-        SerializeToExpr_array_i32_3
+        "ser_deser_new_world_2_entities_w_named_parent_w_cycle",
+        DeserializeFromJson_ser_deser_new_world_2_entities_w_named_parent_w_cycle
     },
     {
-        "array_struct_i32_i32",
-        SerializeToExpr_array_struct_i32_i32
+        "ser_deser_new_world_w_prefab",
+        DeserializeFromJson_ser_deser_new_world_w_prefab
     },
     {
-        "array_array_i32_3",
-        SerializeToExpr_array_array_i32_3
+        "ser_deser_new_world_w_disabled",
+        DeserializeFromJson_ser_deser_new_world_w_disabled
     },
     {
-        "vector_i32_3",
-        SerializeToExpr_vector_i32_3
+        "ser_deser_restore_1_entity_to_empty_table",
+        DeserializeFromJson_ser_deser_restore_1_entity_to_empty_table
     },
     {
-        "vector_struct_i32_i32",
-        SerializeToExpr_vector_struct_i32_i32
+        "ser_deser_restore_1_entity_to_non_empty_table",
+        DeserializeFromJson_ser_deser_restore_1_entity_to_non_empty_table
     },
     {
-        "vector_array_i32_3",
-        SerializeToExpr_vector_array_i32_3
+        "ser_deser_restore_1_anon_entity_to_empty_table",
+        DeserializeFromJson_ser_deser_restore_1_anon_entity_to_empty_table
     },
     {
-        "entity_entity_after_float",
-        SerializeToExpr_entity_entity_after_float
+        "ser_deser_restore_1_anon_entity_to_non_empty_table",
+        DeserializeFromJson_ser_deser_restore_1_anon_entity_to_non_empty_table
     },
     {
-        "struct_nested_i32",
-        SerializeToExpr_struct_nested_i32
+        "ser_deser_restore_1_deleted_entity_to_empty_table",
+        DeserializeFromJson_ser_deser_restore_1_deleted_entity_to_empty_table
     },
     {
-        "struct_nested_i32_i32",
-        SerializeToExpr_struct_nested_i32_i32
+        "ser_deser_restore_1_deleted_entity_to_non_empty_table",
+        DeserializeFromJson_ser_deser_restore_1_deleted_entity_to_non_empty_table
     },
     {
-        "struct_2_nested_i32_i32",
-        SerializeToExpr_struct_2_nested_i32_i32
+        "ser_deser_restore_1_deleted_anon_entity_to_empty_table",
+        DeserializeFromJson_ser_deser_restore_1_deleted_anon_entity_to_empty_table
     },
     {
-        "struct_i32_array_3",
-        SerializeToExpr_struct_i32_array_3
+        "ser_deser_restore_1_deleted_anon_entity_to_non_empty_table",
+        DeserializeFromJson_ser_deser_restore_1_deleted_anon_entity_to_non_empty_table
     },
     {
-        "struct_struct_i32_array_3",
-        SerializeToExpr_struct_struct_i32_array_3
+        "ser_deser_restore_1_deleted_w_ref",
+        DeserializeFromJson_ser_deser_restore_1_deleted_w_ref
     },
     {
-        "struct_struct_i32_i32_array_3",
-        SerializeToExpr_struct_struct_i32_i32_array_3
+        "ser_deser_restore_1_deleted_anon_w_ref",
+        DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_ref
     },
     {
-        "struct_w_array_type_i32_i32",
-        SerializeToExpr_struct_w_array_type_i32_i32
+        "ser_deser_restore_1_deleted_w_cycle_ref",
+        DeserializeFromJson_ser_deser_restore_1_deleted_w_cycle_ref
     },
     {
-        "struct_w_array_type_struct",
-        SerializeToExpr_struct_w_array_type_struct
+        "ser_deser_restore_1_deleted_anon_w_cycle_ref",
+        DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_cycle_ref
     },
     {
-        "struct_w_2_array_type_i32_i32",
-        SerializeToExpr_struct_w_2_array_type_i32_i32
+        "ser_deser_restore_1_deleted_w_recycled",
+        DeserializeFromJson_ser_deser_restore_1_deleted_w_recycled
     },
     {
-        "struct_w_2_array_type_struct",
-        SerializeToExpr_struct_w_2_array_type_struct
+        "ser_deser_restore_1_deleted_anon_w_recycled",
+        DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_recycled
     },
     {
-        "struct_partial",
-        SerializeToExpr_struct_partial
+        "ser_deser_on_set_3_entities",
+        DeserializeFromJson_ser_deser_on_set_3_entities
     },
     {
-        "escape_simple_string",
-        SerializeToExpr_escape_simple_string
+        "ser_deser_on_set_3_entities_2_restored",
+        DeserializeFromJson_ser_deser_on_set_3_entities_2_restored
     },
     {
-        "escape_newline",
-        SerializeToExpr_escape_newline
+        "ser_deser_on_set_3_entities_1_restored",
+        DeserializeFromJson_ser_deser_on_set_3_entities_1_restored
     },
     {
-        "escape_2_newlines",
-        SerializeToExpr_escape_2_newlines
+        "ser_deser_3_entities_after_remove_all",
+        DeserializeFromJson_ser_deser_3_entities_after_remove_all
     },
     {
-        "escape_string_w_trailing_newline",
-        SerializeToExpr_escape_string_w_trailing_newline
+        "ser_deser_3_entities_after_delete_with",
+        DeserializeFromJson_ser_deser_3_entities_after_delete_with
     },
     {
-        "escape_string_w_2_trailing_newlines",
-        SerializeToExpr_escape_string_w_2_trailing_newlines
+        "ser_deser_w_hooks",
+        DeserializeFromJson_ser_deser_w_hooks
     },
     {
-        "escape_string_w_delim",
-        SerializeToExpr_escape_string_w_delim
-    }
-};
-
-bake_test_case DeserializeFromJson_testcases[] = {
-    {
-        "struct_bool",
-        DeserializeFromJson_struct_bool
+        "ser_deser_large_data",
+        DeserializeFromJson_ser_deser_large_data
     },
     {
-        "struct_byte",
-        DeserializeFromJson_struct_byte
+        "ser_deser_different_component_order",
+        DeserializeFromJson_ser_deser_different_component_order
     },
     {
-        "struct_char",
-        DeserializeFromJson_struct_char
+        "ser_deser_no_reflection_data",
+        DeserializeFromJson_ser_deser_no_reflection_data
     },
     {
-        "struct_char_literal",
-        DeserializeFromJson_struct_char_literal
+        "ser_deser_no_reflection_data_strict",
+        DeserializeFromJson_ser_deser_no_reflection_data_strict
     },
     {
-        "struct_i8",
-        DeserializeFromJson_struct_i8
+        "ser_deser_value_for_tag",
+        DeserializeFromJson_ser_deser_value_for_tag
     },
     {
-        "struct_i16",
-        DeserializeFromJson_struct_i16
+        "ser_deser_value_for_tag_strict",
+        DeserializeFromJson_ser_deser_value_for_tag_strict
     },
     {
-        "struct_i32",
-        DeserializeFromJson_struct_i32
+        "ser_deser_value_for_non_existing",
+        DeserializeFromJson_ser_deser_value_for_non_existing
     },
     {
-        "struct_i64",
-        DeserializeFromJson_struct_i64
+        "ser_deser_value_for_non_existing_strict",
+        DeserializeFromJson_ser_deser_value_for_non_existing_strict
     },
     {
-        "struct_iptr",
-        DeserializeFromJson_struct_iptr
+        "ser_deser_cpp_typename",
+        DeserializeFromJson_ser_deser_cpp_typename
     },
     {
-        "struct_u8",
-        DeserializeFromJson_struct_u8
+        "ser_deser_cpp_template",
+        DeserializeFromJson_ser_deser_cpp_template
     },
     {
-        "struct_u16",
-        DeserializeFromJson_struct_u16
+        "ser_deser_cpp_template_1_param",
+        DeserializeFromJson_ser_deser_cpp_template_1_param
     },
     {
-        "struct_u32",
-        DeserializeFromJson_struct_u32
+        "ser_deser_cpp_template_n_params",
+        DeserializeFromJson_ser_deser_cpp_template_n_params
     },
     {
-        "struct_u64",
-        DeserializeFromJson_struct_u64
+        "ser_deser_cpp_template_nested",
+        DeserializeFromJson_ser_deser_cpp_template_nested
     },
     {
-        "struct_uptr",
-        DeserializeFromJson_struct_uptr
+        "ser_deser_cpp_template_n_params_nested",
+        DeserializeFromJson_ser_deser_cpp_template_n_params_nested
     },
     {
-        "struct_float",
-        DeserializeFromJson_struct_float
+        "ser_deser_long_name",
+        DeserializeFromJson_ser_deser_long_name
     },
     {
-        "struct_double",
-        DeserializeFromJson_struct_double
+        "ser_deser_long_name_256_chars",
+        DeserializeFromJson_ser_deser_long_name_256_chars
     },
     {
-        "struct_negative_int",
-        DeserializeFromJson_struct_negative_int
+        "ser_deser_w_alerts",
+        DeserializeFromJson_ser_deser_w_alerts
     },
     {
-        "struct_negative_float",
-        DeserializeFromJson_struct_negative_float
+        "ser_deser_w_alerts_w_progress",
+        DeserializeFromJson_ser_deser_w_alerts_w_progress
     },
     {
-        "struct_string",
-        DeserializeFromJson_struct_string
+        "ser_deser_struct",
+        DeserializeFromJson_ser_deser_struct
     },
     {
-        "struct_entity",
-        DeserializeFromJson_struct_entity
+        "ser_deser_anon_w_same_id_as_existing_named",
+        DeserializeFromJson_ser_deser_anon_w_same_id_as_existing_named
     },
     {
-        "struct_id",
-        DeserializeFromJson_struct_id
+        "ser_deser_named_to_different_table",
+        DeserializeFromJson_ser_deser_named_to_different_table
     },
     {
-        "struct_enum",
-        DeserializeFromJson_struct_enum
+        "ser_deser_named_child_to_different_table",
+        DeserializeFromJson_ser_deser_named_child_to_different_table
     },
     {
-        "struct_bitmask",
-        DeserializeFromJson_struct_bitmask
+        "ser_deser_with_child_tgt",
+        DeserializeFromJson_ser_deser_with_child_tgt
     },
     {
-        "struct_i32_i32",
-        DeserializeFromJson_struct_i32_i32
+        "ser_deser_with_child_tgt_no_child",
+        DeserializeFromJson_ser_deser_with_child_tgt_no_child
     },
     {
-        "struct_nested_i32",
-        DeserializeFromJson_struct_nested_i32
-    },
+        "deser_invalid_entity_name",
+        DeserializeFromJson_deser_invalid_entity_name
+    }
+};
+
+bake_test_case SerializeToJson_testcases[] = {
     {
-        "struct_nested_i32_i32",
-        DeserializeFromJson_struct_nested_i32_i32
+        "struct_bool",
+        SerializeToJson_struct_bool
     },
     {
-        "struct_2_nested_i32_i32",
-        DeserializeFromJson_struct_2_nested_i32_i32
+        "struct_byte",
+        SerializeToJson_struct_byte
     },
     {
-        "struct_i32_array_3",
-        DeserializeFromJson_struct_i32_array_3
+        "struct_char",
+        SerializeToJson_struct_char
     },
     {
-        "struct_struct_i32_array_3",
-        DeserializeFromJson_struct_struct_i32_array_3
+        "struct_i8",
+        SerializeToJson_struct_i8
     },
     {
-        "struct_struct_i32_i32_array_3",
-        DeserializeFromJson_struct_struct_i32_i32_array_3
+        "struct_i16",
+        SerializeToJson_struct_i16
     },
     {
-        "struct_w_array_type_i32_i32",
-        DeserializeFromJson_struct_w_array_type_i32_i32
+        "struct_i32",
+        SerializeToJson_struct_i32
     },
     {
-        "struct_w_2_array_type_i32_i32",
-        DeserializeFromJson_struct_w_2_array_type_i32_i32
+        "struct_i64",
+        SerializeToJson_struct_i64
     },
     {
-        "struct_w_nested_member_i32",
-        DeserializeFromJson_struct_w_nested_member_i32
+        "struct_iptr",
+        SerializeToJson_struct_iptr
     },
     {
-        "struct_w_2_nested_members_i32",
-        DeserializeFromJson_struct_w_2_nested_members_i32
+        "struct_u8",
+        SerializeToJson_struct_u8
     },
     {
-        "struct_w_nested_members_struct",
-        DeserializeFromJson_struct_w_nested_members_struct
+        "struct_u16",
+        SerializeToJson_struct_u16
     },
     {
-        "struct_w_2_nested_members_struct",
-        DeserializeFromJson_struct_w_2_nested_members_struct
+        "struct_u32",
+        SerializeToJson_struct_u32
     },
     {
-        "deser_entity_1_component_1_member",
-        DeserializeFromJson_deser_entity_1_component_1_member
+        "struct_u64",
+        SerializeToJson_struct_u64
     },
     {
-        "deser_entity_1_component_1_member_w_spaces",
-        DeserializeFromJson_deser_entity_1_component_1_member_w_spaces
+        "struct_uptr",
+        SerializeToJson_struct_uptr
     },
     {
-        "deser_entity_1_component_2_members",
-        DeserializeFromJson_deser_entity_1_component_2_members
+        "struct_float",
+        SerializeToJson_struct_float
     },
     {
-        "deser_entity_2_components",
-        DeserializeFromJson_deser_entity_2_components
+        "struct_double",
+        SerializeToJson_struct_double
     },
     {
-        "deser_entity_1_component_composite_member",
-        DeserializeFromJson_deser_entity_1_component_composite_member
+        "struct_string",
+        SerializeToJson_struct_string
     },
     {
-        "deser_entity_1_component_nested_member",
-        DeserializeFromJson_deser_entity_1_component_nested_member
+        "struct_entity",
+        SerializeToJson_struct_entity
     },
     {
-        "deser_entity_1_pair",
-        DeserializeFromJson_deser_entity_1_pair
+        "struct_entity_10k",
+        SerializeToJson_struct_entity_10k
     },
     {
-        "deser_entity_2_pairs",
-        DeserializeFromJson_deser_entity_2_pairs
+        "struct_entity_after_float",
+        SerializeToJson_struct_entity_after_float
     },
     {
-        "deser_entity_empty",
-        DeserializeFromJson_deser_entity_empty
+        "struct_id",
+        SerializeToJson_struct_id
     },
     {
-        "deser_entity_w_path",
-        DeserializeFromJson_deser_entity_w_path
+        "struct_float_nan",
+        SerializeToJson_struct_float_nan
     },
     {
-        "deser_entity_w_path_and_ids",
-        DeserializeFromJson_deser_entity_w_path_and_ids
+        "struct_float_inf",
+        SerializeToJson_struct_float_inf
     },
     {
-        "deser_entity_w_path_and_ids_and_values",
-        DeserializeFromJson_deser_entity_w_path_and_ids_and_values
+        "struct_double_nan",
+        SerializeToJson_struct_double_nan
     },
     {
-        "deser_entity_w_ids",
-        DeserializeFromJson_deser_entity_w_ids
+        "struct_double_inf",
+        SerializeToJson_struct_double_inf
     },
     {
-        "ser_deser_mini",
-        DeserializeFromJson_ser_deser_mini
+        "struct_double_large",
+        SerializeToJson_struct_double_large
     },
     {
-        "ser_deser_init",
-        DeserializeFromJson_ser_deser_init
+        "struct_double_large_e",
+        SerializeToJson_struct_double_large_e
     },
     {
-        "ser_deser_mini_serialize_builtin",
-        DeserializeFromJson_ser_deser_mini_serialize_builtin
+        "struct_enum",
+        SerializeToJson_struct_enum
     },
     {
-        "ser_deser_mini_serialize_modules",
-        DeserializeFromJson_ser_deser_mini_serialize_modules
+        "struct_bitmask",
+        SerializeToJson_struct_bitmask
     },
     {
-        "ser_deser_mini_serialize_builtin_modules",
-        DeserializeFromJson_ser_deser_mini_serialize_builtin_modules
+        "struct_i32_i32",
+        SerializeToJson_struct_i32_i32
     },
     {
-        "ser_deser_init_serialize_builtin",
-        DeserializeFromJson_ser_deser_init_serialize_builtin
+        "struct_nested_i32",
+        SerializeToJson_struct_nested_i32
     },
     {
-        "ser_deser_init_serialize_modules",
-        DeserializeFromJson_ser_deser_init_serialize_modules
+        "struct_nested_i32_i32",
+        SerializeToJson_struct_nested_i32_i32
     },
     {
-        "ser_deser_init_serialize_builtin_modules",
-        DeserializeFromJson_ser_deser_init_serialize_builtin_modules
+        "struct_2_nested_i32_i32",
+        SerializeToJson_struct_2_nested_i32_i32
     },
     {
-        "ser_deser_new_world",
-        DeserializeFromJson_ser_deser_new_world
+        "struct_i32_array_3",
+        SerializeToJson_struct_i32_array_3
     },
     {
-        "ser_deser_new_world_1_entity_w_tag",
-        DeserializeFromJson_ser_deser_new_world_1_entity_w_tag
+        "struct_struct_i32_array_3",
+        SerializeToJson_struct_struct_i32_array_3
     },
     {
-        "ser_deser_new_world_1_entity_w_component",
-        DeserializeFromJson_ser_deser_new_world_1_entity_w_component
+        "struct_struct_i32_i32_array_3",
+        SerializeToJson_struct_struct_i32_i32_array_3
     },
     {
-        "ser_deser_new_world_1_entity_w_component_meta",
-        DeserializeFromJson_ser_deser_new_world_1_entity_w_component_meta
+        "struct_w_array_type_i32_i32",
+        SerializeToJson_struct_w_array_type_i32_i32
     },
     {
-        "ser_deser_new_world_1_named_entity_w_tag",
-        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_tag
+        "struct_w_2_array_type_i32_i32",
+        SerializeToJson_struct_w_2_array_type_i32_i32
     },
     {
-        "ser_deser_new_world_1_named_entity_w_component",
-        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component
+        "struct_partial",
+        SerializeToJson_struct_partial
     },
     {
-        "ser_deser_new_world_1_named_entity_w_component_meta",
-        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component_meta
+        "array_i32_3",
+        SerializeToJson_array_i32_3
     },
     {
-        "ser_deser_new_world_1_entity_w_tag_serialize_all",
-        DeserializeFromJson_ser_deser_new_world_1_entity_w_tag_serialize_all
+        "array_struct_i32_i32",
+        SerializeToJson_array_struct_i32_i32
     },
     {
-        "ser_deser_new_world_1_entity_w_component_serialize_all",
-        DeserializeFromJson_ser_deser_new_world_1_entity_w_component_serialize_all
+        "array_array_i32_3",
+        SerializeToJson_array_array_i32_3
     },
     {
-        "ser_deser_new_world_1_entity_w_component_meta_serialize_all",
-        DeserializeFromJson_ser_deser_new_world_1_entity_w_component_meta_serialize_all
+        "vector_i32_3",
+        SerializeToJson_vector_i32_3
     },
     {
-        "ser_deser_new_world_1_named_entity_w_tag_serialize_all",
-        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_tag_serialize_all
+        "vector_struct_i32_i32",
+        SerializeToJson_vector_struct_i32_i32
     },
     {
-        "ser_deser_new_world_1_named_entity_w_component_serialize_all",
-        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component_serialize_all
-    },
+        "vector_array_i32_3",
+        SerializeToJson_vector_array_i32_3
+    }
+};
+
+bake_test_case SerializeEntityToJson_testcases[] = {
     {
-        "ser_deser_new_world_1_named_entity_w_component_meta_serialize_all",
-        DeserializeFromJson_ser_deser_new_world_1_named_entity_w_component_meta_serialize_all
+        "serialize_empty",
+        SerializeEntityToJson_serialize_empty
     },
     {
-        "ser_deser_new_world_3_entities_w_component_meta",
-        DeserializeFromJson_ser_deser_new_world_3_entities_w_component_meta
+        "serialize_w_name",
+        SerializeEntityToJson_serialize_w_name
     },
     {
-        "ser_deser_new_world_3_entities_w_2_components_meta",
-        DeserializeFromJson_ser_deser_new_world_3_entities_w_2_components_meta
+        "serialize_w_name_1_tag",
+        SerializeEntityToJson_serialize_w_name_1_tag
     },
     {
-        "ser_deser_new_world_4_entities_2_tables_w_component_meta",
-        DeserializeFromJson_ser_deser_new_world_4_entities_2_tables_w_component_meta
+        "serialize_w_name_2_tags",
+        SerializeEntityToJson_serialize_w_name_2_tags
     },
     {
-        "ser_deser_new_world_component_w_anon_entity_member",
-        DeserializeFromJson_ser_deser_new_world_component_w_anon_entity_member
+        "serialize_w_name_1_pair",
+        SerializeEntityToJson_serialize_w_name_1_pair
     },
     {
-        "ser_deser_new_world_component_w_named_entity_member",
-        DeserializeFromJson_ser_deser_new_world_component_w_named_entity_member
+        "serialize_w_base",
+        SerializeEntityToJson_serialize_w_base
     },
     {
-        "ser_deser_new_world_component_w_anon_and_named_entity_member",
-        DeserializeFromJson_ser_deser_new_world_component_w_anon_and_named_entity_member
+        "serialize_w_base_override",
+        SerializeEntityToJson_serialize_w_base_override
     },
     {
-        "ser_deser_new_world_component_w_anon_entity_with_self",
-        DeserializeFromJson_ser_deser_new_world_component_w_anon_entity_with_self
+        "serialize_w_2_base",
+        SerializeEntityToJson_serialize_w_2_base
     },
     {
-        "ser_deser_new_world_component_w_named_entity_with_self",
-        DeserializeFromJson_ser_deser_new_world_component_w_named_entity_with_self
+        "serialize_w_nested_base",
+        SerializeEntityToJson_serialize_w_nested_base
     },
     {
-        "ser_deser_new_world_2_entities_w_anon_parent",
-        DeserializeFromJson_ser_deser_new_world_2_entities_w_anon_parent
+        "serialize_w_1_component",
+        SerializeEntityToJson_serialize_w_1_component
     },
     {
-        "ser_deser_new_world_2_entities_w_named_parent",
-        DeserializeFromJson_ser_deser_new_world_2_entities_w_named_parent
+        "serialize_w_2_components",
+        SerializeEntityToJson_serialize_w_2_components
     },
     {
-        "ser_deser_new_world_2_entities_w_anon_parent_w_cycle",
-        DeserializeFromJson_ser_deser_new_world_2_entities_w_anon_parent_w_cycle
+        "serialize_w_primitive_component",
+        SerializeEntityToJson_serialize_w_primitive_component
     },
     {
-        "ser_deser_new_world_2_entities_w_named_parent_w_cycle",
-        DeserializeFromJson_ser_deser_new_world_2_entities_w_named_parent_w_cycle
+        "serialize_w_enum_component",
+        SerializeEntityToJson_serialize_w_enum_component
     },
     {
-        "ser_deser_new_world_w_prefab",
-        DeserializeFromJson_ser_deser_new_world_w_prefab
+        "serialize_w_struct_and_enum_component",
+        SerializeEntityToJson_serialize_w_struct_and_enum_component
     },
     {
-        "ser_deser_new_world_w_disabled",
-        DeserializeFromJson_ser_deser_new_world_w_disabled
+        "serialize_w_invalid_enum_component",
+        SerializeEntityToJson_serialize_w_invalid_enum_component
     },
     {
-        "ser_deser_restore_1_entity_to_empty_table",
-        DeserializeFromJson_ser_deser_restore_1_entity_to_empty_table
+        "serialize_w_type_info",
+        SerializeEntityToJson_serialize_w_type_info
     },
     {
-        "ser_deser_restore_1_entity_to_non_empty_table",
-        DeserializeFromJson_ser_deser_restore_1_entity_to_non_empty_table
+        "serialize_w_type_info_unit",
+        SerializeEntityToJson_serialize_w_type_info_unit
     },
     {
-        "ser_deser_restore_1_anon_entity_to_empty_table",
-        DeserializeFromJson_ser_deser_restore_1_anon_entity_to_empty_table
+        "serialize_w_type_info_unit_quantity",
+        SerializeEntityToJson_serialize_w_type_info_unit_quantity
     },
     {
-        "ser_deser_restore_1_anon_entity_to_non_empty_table",
-        DeserializeFromJson_ser_deser_restore_1_anon_entity_to_non_empty_table
+        "serialize_w_type_info_unit_over",
+        SerializeEntityToJson_serialize_w_type_info_unit_over
     },
     {
-        "ser_deser_restore_1_deleted_entity_to_empty_table",
-        DeserializeFromJson_ser_deser_restore_1_deleted_entity_to_empty_table
+        "serialize_wo_private",
+        SerializeEntityToJson_serialize_wo_private
     },
     {
-        "ser_deser_restore_1_deleted_entity_to_non_empty_table",
-        DeserializeFromJson_ser_deser_restore_1_deleted_entity_to_non_empty_table
+        "serialize_w_private",
+        SerializeEntityToJson_serialize_w_private
     },
     {
-        "ser_deser_restore_1_deleted_anon_entity_to_empty_table",
-        DeserializeFromJson_ser_deser_restore_1_deleted_anon_entity_to_empty_table
+        "serialize_w_label",
+        SerializeEntityToJson_serialize_w_label
     },
     {
-        "ser_deser_restore_1_deleted_anon_entity_to_non_empty_table",
-        DeserializeFromJson_ser_deser_restore_1_deleted_anon_entity_to_non_empty_table
+        "serialize_w_label_no_name",
+        SerializeEntityToJson_serialize_w_label_no_name
     },
     {
-        "ser_deser_restore_1_deleted_w_ref",
-        DeserializeFromJson_ser_deser_restore_1_deleted_w_ref
+        "serialize_w_id_labels",
+        SerializeEntityToJson_serialize_w_id_labels
     },
     {
-        "ser_deser_restore_1_deleted_anon_w_ref",
-        DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_ref
+        "serialize_w_brief",
+        SerializeEntityToJson_serialize_w_brief
     },
     {
-        "ser_deser_restore_1_deleted_w_cycle_ref",
-        DeserializeFromJson_ser_deser_restore_1_deleted_w_cycle_ref
+        "serialize_w_brief_no_brief",
+        SerializeEntityToJson_serialize_w_brief_no_brief
     },
     {
-        "ser_deser_restore_1_deleted_anon_w_cycle_ref",
-        DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_cycle_ref
+        "serialize_w_link",
+        SerializeEntityToJson_serialize_w_link
     },
     {
-        "ser_deser_restore_1_deleted_w_recycled",
-        DeserializeFromJson_ser_deser_restore_1_deleted_w_recycled
+        "serialize_w_link_no_link",
+        SerializeEntityToJson_serialize_w_link_no_link
     },
     {
-        "ser_deser_restore_1_deleted_anon_w_recycled",
-        DeserializeFromJson_ser_deser_restore_1_deleted_anon_w_recycled
+        "serialize_color",
+        SerializeEntityToJson_serialize_color
     },
     {
-        "ser_deser_on_set_3_entities",
-        DeserializeFromJson_ser_deser_on_set_3_entities
+        "serialize_w_doc_w_quotes",
+        SerializeEntityToJson_serialize_w_doc_w_quotes
     },
     {
-        "ser_deser_on_set_3_entities_2_restored",
-        DeserializeFromJson_ser_deser_on_set_3_entities_2_restored
+        "serialize_from_core",
+        SerializeEntityToJson_serialize_from_core
     },
     {
-        "ser_deser_on_set_3_entities_1_restored",
-        DeserializeFromJson_ser_deser_on_set_3_entities_1_restored
+        "serialize_w_1_alert",
+        SerializeEntityToJson_serialize_w_1_alert
     },
     {
-        "ser_deser_3_entities_after_remove_all",
-        DeserializeFromJson_ser_deser_3_entities_after_remove_all
+        "serialize_w_2_alerts",
+        SerializeEntityToJson_serialize_w_2_alerts
     },
     {
-        "ser_deser_3_entities_after_delete_with",
-        DeserializeFromJson_ser_deser_3_entities_after_delete_with
+        "serialize_w_child_alerts",
+        SerializeEntityToJson_serialize_w_child_alerts
     },
     {
-        "ser_deser_w_hooks",
-        DeserializeFromJson_ser_deser_w_hooks
+        "serialize_w_severity_filter_alert",
+        SerializeEntityToJson_serialize_w_severity_filter_alert
     },
     {
-        "ser_deser_large_data",
-        DeserializeFromJson_ser_deser_large_data
+        "serialize_w_alerts_not_imported",
+        SerializeEntityToJson_serialize_w_alerts_not_imported
     },
     {
-        "ser_deser_different_component_order",
-        DeserializeFromJson_ser_deser_different_component_order
+        "serialize_w_alerts_no_message",
+        SerializeEntityToJson_serialize_w_alerts_no_message
     },
     {
-        "ser_deser_no_reflection_data",
-        DeserializeFromJson_ser_deser_no_reflection_data
+        "serialize_refs_childof",
+        SerializeEntityToJson_serialize_refs_childof
     },
     {
-        "ser_deser_no_reflection_data_strict",
-        DeserializeFromJson_ser_deser_no_reflection_data_strict
+        "serialize_refs_custom",
+        SerializeEntityToJson_serialize_refs_custom
     },
     {
-        "ser_deser_value_for_tag",
-        DeserializeFromJson_ser_deser_value_for_tag
+        "serialize_refs_wildcard",
+        SerializeEntityToJson_serialize_refs_wildcard
     },
     {
-        "ser_deser_value_for_tag_strict",
-        DeserializeFromJson_ser_deser_value_for_tag_strict
+        "serialize_no_ids",
+        SerializeEntityToJson_serialize_no_ids
     },
     {
-        "ser_deser_value_for_non_existing",
-        DeserializeFromJson_ser_deser_value_for_non_existing
+        "serialize_matches_filter",
+        SerializeEntityToJson_serialize_matches_filter
     },
     {
-        "ser_deser_value_for_non_existing_strict",
-        DeserializeFromJson_ser_deser_value_for_non_existing_strict
+        "serialize_matches_query",
+        SerializeEntityToJson_serialize_matches_query
     },
     {
-        "ser_deser_cpp_typename",
-        DeserializeFromJson_ser_deser_cpp_typename
+        "serialize_matches_rule",
+        SerializeEntityToJson_serialize_matches_rule
     },
     {
-        "ser_deser_cpp_template",
-        DeserializeFromJson_ser_deser_cpp_template
-    },
-    {
-        "ser_deser_cpp_template_1_param",
-        DeserializeFromJson_ser_deser_cpp_template_1_param
-    },
-    {
-        "ser_deser_cpp_template_n_params",
-        DeserializeFromJson_ser_deser_cpp_template_n_params
-    },
-    {
-        "ser_deser_cpp_template_nested",
-        DeserializeFromJson_ser_deser_cpp_template_nested
-    },
-    {
-        "ser_deser_cpp_template_n_params_nested",
-        DeserializeFromJson_ser_deser_cpp_template_n_params_nested
-    },
-    {
-        "ser_deser_long_name",
-        DeserializeFromJson_ser_deser_long_name
-    },
-    {
-        "ser_deser_long_name_256_chars",
-        DeserializeFromJson_ser_deser_long_name_256_chars
-    },
-    {
-        "ser_deser_w_alerts",
-        DeserializeFromJson_ser_deser_w_alerts
-    },
-    {
-        "ser_deser_w_alerts_w_progress",
-        DeserializeFromJson_ser_deser_w_alerts_w_progress
-    },
-    {
-        "ser_deser_struct",
-        DeserializeFromJson_ser_deser_struct
-    },
-    {
-        "ser_deser_anon_w_same_id_as_existing_named",
-        DeserializeFromJson_ser_deser_anon_w_same_id_as_existing_named
-    },
-    {
-        "ser_deser_named_to_different_table",
-        DeserializeFromJson_ser_deser_named_to_different_table
-    },
-    {
-        "ser_deser_named_child_to_different_table",
-        DeserializeFromJson_ser_deser_named_child_to_different_table
-    },
-    {
-        "ser_deser_with_child_tgt",
-        DeserializeFromJson_ser_deser_with_child_tgt
-    },
-    {
-        "ser_deser_with_child_tgt_no_child",
-        DeserializeFromJson_ser_deser_with_child_tgt_no_child
-    },
-    {
-        "deser_invalid_entity_name",
-        DeserializeFromJson_deser_invalid_entity_name
-    }
-};
-
-bake_test_case SerializeToJson_testcases[] = {
-    {
-        "struct_bool",
-        SerializeToJson_struct_bool
-    },
-    {
-        "struct_byte",
-        SerializeToJson_struct_byte
-    },
-    {
-        "struct_char",
-        SerializeToJson_struct_char
-    },
-    {
-        "struct_i8",
-        SerializeToJson_struct_i8
-    },
-    {
-        "struct_i16",
-        SerializeToJson_struct_i16
-    },
-    {
-        "struct_i32",
-        SerializeToJson_struct_i32
-    },
-    {
-        "struct_i64",
-        SerializeToJson_struct_i64
-    },
-    {
-        "struct_iptr",
-        SerializeToJson_struct_iptr
-    },
-    {
-        "struct_u8",
-        SerializeToJson_struct_u8
-    },
-    {
-        "struct_u16",
-        SerializeToJson_struct_u16
-    },
-    {
-        "struct_u32",
-        SerializeToJson_struct_u32
-    },
-    {
-        "struct_u64",
-        SerializeToJson_struct_u64
-    },
-    {
-        "struct_uptr",
-        SerializeToJson_struct_uptr
-    },
-    {
-        "struct_float",
-        SerializeToJson_struct_float
-    },
-    {
-        "struct_double",
-        SerializeToJson_struct_double
-    },
-    {
-        "struct_string",
-        SerializeToJson_struct_string
-    },
-    {
-        "struct_entity",
-        SerializeToJson_struct_entity
-    },
-    {
-        "struct_entity_10k",
-        SerializeToJson_struct_entity_10k
-    },
-    {
-        "struct_entity_after_float",
-        SerializeToJson_struct_entity_after_float
-    },
-    {
-        "struct_id",
-        SerializeToJson_struct_id
-    },
-    {
-        "struct_float_nan",
-        SerializeToJson_struct_float_nan
-    },
-    {
-        "struct_float_inf",
-        SerializeToJson_struct_float_inf
-    },
-    {
-        "struct_double_nan",
-        SerializeToJson_struct_double_nan
-    },
-    {
-        "struct_double_inf",
-        SerializeToJson_struct_double_inf
-    },
-    {
-        "struct_double_large",
-        SerializeToJson_struct_double_large
-    },
-    {
-        "struct_double_large_e",
-        SerializeToJson_struct_double_large_e
-    },
-    {
-        "struct_enum",
-        SerializeToJson_struct_enum
-    },
-    {
-        "struct_bitmask",
-        SerializeToJson_struct_bitmask
-    },
-    {
-        "struct_i32_i32",
-        SerializeToJson_struct_i32_i32
-    },
-    {
-        "struct_nested_i32",
-        SerializeToJson_struct_nested_i32
-    },
-    {
-        "struct_nested_i32_i32",
-        SerializeToJson_struct_nested_i32_i32
-    },
-    {
-        "struct_2_nested_i32_i32",
-        SerializeToJson_struct_2_nested_i32_i32
-    },
-    {
-        "struct_i32_array_3",
-        SerializeToJson_struct_i32_array_3
-    },
-    {
-        "struct_struct_i32_array_3",
-        SerializeToJson_struct_struct_i32_array_3
-    },
-    {
-        "struct_struct_i32_i32_array_3",
-        SerializeToJson_struct_struct_i32_i32_array_3
-    },
-    {
-        "struct_w_array_type_i32_i32",
-        SerializeToJson_struct_w_array_type_i32_i32
-    },
-    {
-        "struct_w_2_array_type_i32_i32",
-        SerializeToJson_struct_w_2_array_type_i32_i32
-    },
-    {
-        "struct_partial",
-        SerializeToJson_struct_partial
-    },
-    {
-        "array_i32_3",
-        SerializeToJson_array_i32_3
-    },
-    {
-        "array_struct_i32_i32",
-        SerializeToJson_array_struct_i32_i32
-    },
-    {
-        "array_array_i32_3",
-        SerializeToJson_array_array_i32_3
-    },
-    {
-        "vector_i32_3",
-        SerializeToJson_vector_i32_3
-    },
-    {
-        "vector_struct_i32_i32",
-        SerializeToJson_vector_struct_i32_i32
-    },
-    {
-        "vector_array_i32_3",
-        SerializeToJson_vector_array_i32_3
-    }
-};
-
-bake_test_case SerializeEntityToJson_testcases[] = {
-    {
-        "serialize_empty",
-        SerializeEntityToJson_serialize_empty
-    },
-    {
-        "serialize_w_name",
-        SerializeEntityToJson_serialize_w_name
-    },
-    {
-        "serialize_w_name_1_tag",
-        SerializeEntityToJson_serialize_w_name_1_tag
-    },
-    {
-        "serialize_w_name_2_tags",
-        SerializeEntityToJson_serialize_w_name_2_tags
-    },
-    {
-        "serialize_w_name_1_pair",
-        SerializeEntityToJson_serialize_w_name_1_pair
-    },
-    {
-        "serialize_w_base",
-        SerializeEntityToJson_serialize_w_base
-    },
-    {
-        "serialize_w_base_override",
-        SerializeEntityToJson_serialize_w_base_override
-    },
-    {
-        "serialize_w_2_base",
-        SerializeEntityToJson_serialize_w_2_base
-    },
-    {
-        "serialize_w_nested_base",
-        SerializeEntityToJson_serialize_w_nested_base
-    },
-    {
-        "serialize_w_1_component",
-        SerializeEntityToJson_serialize_w_1_component
-    },
-    {
-        "serialize_w_2_components",
-        SerializeEntityToJson_serialize_w_2_components
-    },
-    {
-        "serialize_w_primitive_component",
-        SerializeEntityToJson_serialize_w_primitive_component
-    },
-    {
-        "serialize_w_enum_component",
-        SerializeEntityToJson_serialize_w_enum_component
-    },
-    {
-        "serialize_w_struct_and_enum_component",
-        SerializeEntityToJson_serialize_w_struct_and_enum_component
-    },
-    {
-        "serialize_w_invalid_enum_component",
-        SerializeEntityToJson_serialize_w_invalid_enum_component
-    },
-    {
-        "serialize_w_type_info",
-        SerializeEntityToJson_serialize_w_type_info
-    },
-    {
-        "serialize_w_type_info_unit",
-        SerializeEntityToJson_serialize_w_type_info_unit
-    },
-    {
-        "serialize_w_type_info_unit_quantity",
-        SerializeEntityToJson_serialize_w_type_info_unit_quantity
-    },
-    {
-        "serialize_w_type_info_unit_over",
-        SerializeEntityToJson_serialize_w_type_info_unit_over
-    },
-    {
-        "serialize_wo_private",
-        SerializeEntityToJson_serialize_wo_private
-    },
-    {
-        "serialize_w_private",
-        SerializeEntityToJson_serialize_w_private
-    },
-    {
-        "serialize_w_label",
-        SerializeEntityToJson_serialize_w_label
-    },
-    {
-        "serialize_w_label_no_name",
-        SerializeEntityToJson_serialize_w_label_no_name
-    },
-    {
-        "serialize_w_id_labels",
-        SerializeEntityToJson_serialize_w_id_labels
-    },
-    {
-        "serialize_w_brief",
-        SerializeEntityToJson_serialize_w_brief
-    },
-    {
-        "serialize_w_brief_no_brief",
-        SerializeEntityToJson_serialize_w_brief_no_brief
-    },
-    {
-        "serialize_w_link",
-        SerializeEntityToJson_serialize_w_link
-    },
-    {
-        "serialize_w_link_no_link",
-        SerializeEntityToJson_serialize_w_link_no_link
-    },
-    {
-        "serialize_color",
-        SerializeEntityToJson_serialize_color
-    },
-    {
-        "serialize_w_doc_w_quotes",
-        SerializeEntityToJson_serialize_w_doc_w_quotes
-    },
-    {
-        "serialize_union_relationship",
-        SerializeEntityToJson_serialize_union_relationship
-    },
-    {
-        "serialize_union_relationship_w_labels",
-        SerializeEntityToJson_serialize_union_relationship_w_labels
-    },
-    {
-        "serialize_union_relationship_invalid_entity",
-        SerializeEntityToJson_serialize_union_relationship_invalid_entity
-    },
-    {
-        "serialize_union_relationship_invalid_entity_w_labels",
-        SerializeEntityToJson_serialize_union_relationship_invalid_entity_w_labels
-    },
-    {
-        "serialize_w_union_property",
-        SerializeEntityToJson_serialize_w_union_property
-    },
-    {
-        "serialize_w_union_property",
-        SerializeEntityToJson_serialize_w_union_property
-    },
-    {
-        "serialize_from_core",
-        SerializeEntityToJson_serialize_from_core
-    },
-    {
-        "serialize_w_1_alert",
-        SerializeEntityToJson_serialize_w_1_alert
-    },
-    {
-        "serialize_w_2_alerts",
-        SerializeEntityToJson_serialize_w_2_alerts
-    },
-    {
-        "serialize_w_child_alerts",
-        SerializeEntityToJson_serialize_w_child_alerts
-    },
-    {
-        "serialize_w_severity_filter_alert",
-        SerializeEntityToJson_serialize_w_severity_filter_alert
-    },
-    {
-        "serialize_w_alerts_not_imported",
-        SerializeEntityToJson_serialize_w_alerts_not_imported
-    },
-    {
-        "serialize_w_alerts_no_message",
-        SerializeEntityToJson_serialize_w_alerts_no_message
-    },
-    {
-        "serialize_refs_childof",
-        SerializeEntityToJson_serialize_refs_childof
-    },
-    {
-        "serialize_refs_custom",
-        SerializeEntityToJson_serialize_refs_custom
-    },
-    {
-        "serialize_refs_wildcard",
-        SerializeEntityToJson_serialize_refs_wildcard
-    },
-    {
-        "serialize_no_ids",
-        SerializeEntityToJson_serialize_no_ids
-    },
-    {
-        "serialize_matches_filter",
-        SerializeEntityToJson_serialize_matches_filter
-    },
-    {
-        "serialize_matches_query",
-        SerializeEntityToJson_serialize_matches_query
-    },
-    {
-        "serialize_matches_rule",
-        SerializeEntityToJson_serialize_matches_rule
-    },
-    {
-        "serialize_no_matches",
-        SerializeEntityToJson_serialize_no_matches
-    }
-};
-
-bake_test_case SerializeIterToJson_testcases[] = {
-    {
-        "serialize_1_comps_empty",
-        SerializeIterToJson_serialize_1_comps_empty
-    },
-    {
-        "serialize_1_comps_2_ents_same_table",
-        SerializeIterToJson_serialize_1_comps_2_ents_same_table
-    },
-    {
-        "serialize_1_tag_2_ents_same_table",
-        SerializeIterToJson_serialize_1_tag_2_ents_same_table
-    },
-    {
-        "serialize_2_comps_2_ents_same_table",
-        SerializeIterToJson_serialize_2_comps_2_ents_same_table
-    },
-    {
-        "serialize_1_tag_1_comp_2_ents_same_table",
-        SerializeIterToJson_serialize_1_tag_1_comp_2_ents_same_table
-    },
-    {
-        "serialize_1_tag_1_comp_4_ents_two_tables",
-        SerializeIterToJson_serialize_1_tag_1_comp_4_ents_two_tables
-    },
-    {
-        "serialize_2_comps_1_owned_2_ents",
-        SerializeIterToJson_serialize_2_comps_1_owned_2_ents
-    },
-    {
-        "serialize_w_pair_wildcard",
-        SerializeIterToJson_serialize_w_pair_wildcard
-    },
-    {
-        "serialize_w_var",
-        SerializeIterToJson_serialize_w_var
-    },
-    {
-        "serialize_w_2_vars",
-        SerializeIterToJson_serialize_w_2_vars
-    },
-    {
-        "serialize_type_info_1_tags",
-        SerializeIterToJson_serialize_type_info_1_tags
-    },
-    {
-        "serialize_type_info_2_tags",
-        SerializeIterToJson_serialize_type_info_2_tags
-    },
-    {
-        "serialize_type_info_1_component",
-        SerializeIterToJson_serialize_type_info_1_component
-    },
-    {
-        "serialize_type_info_2_components",
-        SerializeIterToJson_serialize_type_info_2_components
-    },
-    {
-        "serialize_type_info_1_struct",
-        SerializeIterToJson_serialize_type_info_1_struct
-    },
-    {
-        "serialize_type_info_1_component_1_struct",
-        SerializeIterToJson_serialize_type_info_1_component_1_struct
-    },
-    {
-        "serialize_type_info_2_structs",
-        SerializeIterToJson_serialize_type_info_2_structs
-    },
-    {
-        "serialize_type_info_w_unit",
-        SerializeIterToJson_serialize_type_info_w_unit
-    },
-    {
-        "serialize_type_info_w_unit_quantity",
-        SerializeIterToJson_serialize_type_info_w_unit_quantity
-    },
-    {
-        "serialize_type_info_w_unit_over",
-        SerializeIterToJson_serialize_type_info_w_unit_over
-    },
-    {
-        "serialize_w_entity_label",
-        SerializeIterToJson_serialize_w_entity_label
-    },
-    {
-        "serialize_w_entity_label_w_str",
-        SerializeIterToJson_serialize_w_entity_label_w_str
-    },
-    {
-        "serialize_w_var_labels",
-        SerializeIterToJson_serialize_w_var_labels
-    },
-    {
-        "serialize_w_var_component",
-        SerializeIterToJson_serialize_w_var_component
-    },
-    {
-        "serialize_w_optional_tag",
-        SerializeIterToJson_serialize_w_optional_tag
-    },
-    {
-        "serialize_w_optional_component",
-        SerializeIterToJson_serialize_w_optional_component
-    },
-    {
-        "serialize_w_optional_reflected_component",
-        SerializeIterToJson_serialize_w_optional_reflected_component
-    },
-    {
-        "serialize_w_inout_filter_tag",
-        SerializeIterToJson_serialize_w_inout_filter_tag
-    },
-    {
-        "serialize_w_inout_filter_component",
-        SerializeIterToJson_serialize_w_inout_filter_component
-    },
-    {
-        "serialize_w_inout_filter_reflected_component",
-        SerializeIterToJson_serialize_w_inout_filter_reflected_component
-    },
-    {
-        "serialize_w_inout_out_tag",
-        SerializeIterToJson_serialize_w_inout_out_tag
-    },
-    {
-        "serialize_w_inout_out_component",
-        SerializeIterToJson_serialize_w_inout_out_component
-    },
-    {
-        "serialize_w_inout_out_reflected_component",
-        SerializeIterToJson_serialize_w_inout_out_reflected_component
-    },
-    {
-        "serialize_component_from_var",
-        SerializeIterToJson_serialize_component_from_var
-    },
-    {
-        "serialize_color",
-        SerializeIterToJson_serialize_color
-    },
-    {
-        "serialize_ids",
-        SerializeIterToJson_serialize_ids
-    },
-    {
-        "serialize_ids_2_entities",
-        SerializeIterToJson_serialize_ids_2_entities
-    },
-    {
-        "serialize_anonymous",
-        SerializeIterToJson_serialize_anonymous
-    },
-    {
-        "serialize_anonymous_ids",
-        SerializeIterToJson_serialize_anonymous_ids
-    },
-    {
-        "serialize_variable_ids",
-        SerializeIterToJson_serialize_variable_ids
-    },
-    {
-        "serialize_variable_ids_2_entities",
-        SerializeIterToJson_serialize_variable_ids_2_entities
-    },
-    {
-        "serialize_variable_anonymous",
-        SerializeIterToJson_serialize_variable_anonymous
-    },
-    {
-        "serialize_variable_anonymous_ids",
-        SerializeIterToJson_serialize_variable_anonymous_ids
-    },
-    {
-        "serialize_anonymous_tag",
-        SerializeIterToJson_serialize_anonymous_tag
-    },
-    {
-        "serialize_anonymous_component",
-        SerializeIterToJson_serialize_anonymous_component
-    },
-    {
-        "serialize_anonymous_pair",
-        SerializeIterToJson_serialize_anonymous_pair
-    },
-    {
-        "serialize_invalid_value",
-        SerializeIterToJson_serialize_invalid_value
-    },
-    {
-        "serialize_recycled_pair_id",
-        SerializeIterToJson_serialize_recycled_pair_id
-    },
-    {
-        "serialize_w_alert",
-        SerializeIterToJson_serialize_w_alert
-    },
-    {
-        "serialize_no_this_alert_imported",
-        SerializeIterToJson_serialize_no_this_alert_imported
-    },
-    {
-        "serialize_paged_iterator",
-        SerializeIterToJson_serialize_paged_iterator
-    },
-    {
-        "serialize_paged_iterator_w_optional_component",
-        SerializeIterToJson_serialize_paged_iterator_w_optional_component
-    },
-    {
-        "serialize_paged_iterator_w_optional_tag",
-        SerializeIterToJson_serialize_paged_iterator_w_optional_tag
-    },
-    {
-        "serialize_paged_iterator_w_vars",
-        SerializeIterToJson_serialize_paged_iterator_w_vars
-    },
-    {
-        "serialize_w_offset",
-        SerializeIterToJson_serialize_w_offset
-    },
-    {
-        "serialize_labels_w_offset",
-        SerializeIterToJson_serialize_labels_w_offset
-    },
-    {
-        "serialize_colors_w_offset",
-        SerializeIterToJson_serialize_colors_w_offset
-    },
-    {
-        "serialize_anonymous_entities_w_offset",
-        SerializeIterToJson_serialize_anonymous_entities_w_offset
-    },
-    {
-        "serialize_table",
-        SerializeIterToJson_serialize_table
-    },
-    {
-        "serialize_table_w_id_labels",
-        SerializeIterToJson_serialize_table_w_id_labels
-    },
-    {
-        "serialize_table_w_var_labels",
-        SerializeIterToJson_serialize_table_w_var_labels
-    },
-    {
-        "serialize_table_w_private",
-        SerializeIterToJson_serialize_table_w_private
-    },
-    {
-        "serialize_world",
-        SerializeIterToJson_serialize_world
-    },
-    {
-        "serialize_term_labels",
-        SerializeIterToJson_serialize_term_labels
-    },
-    {
-        "serialize_id_labels",
-        SerializeIterToJson_serialize_id_labels
-    },
-    {
-        "serialize_id_labels_w_str",
-        SerializeIterToJson_serialize_id_labels_w_str
-    },
-    {
-        "serialize_vars_for_query",
-        SerializeIterToJson_serialize_vars_for_query
-    },
-    {
-        "serialize_var_labels_for_query",
-        SerializeIterToJson_serialize_var_labels_for_query
-    },
-    {
-        "serialize_var_ids_for_query",
-        SerializeIterToJson_serialize_var_ids_for_query
-    },
-    {
-        "serialize_null_doc_name",
-        SerializeIterToJson_serialize_null_doc_name
-    },
-    {
-        "serialize_rule_w_optional",
-        SerializeIterToJson_serialize_rule_w_optional
-    },
-    {
-        "serialize_rule_w_optional_component",
-        SerializeIterToJson_serialize_rule_w_optional_component
-    },
-    {
-        "serialize_entity_w_flecs_core_parent",
-        SerializeIterToJson_serialize_entity_w_flecs_core_parent
-    }
-};
-
-bake_test_case SerializeIterToRowJson_testcases[] = {
-    {
-        "serialize_this_w_1_tag",
-        SerializeIterToRowJson_serialize_this_w_1_tag
-    },
-    {
-        "serialize_this_w_1_tag_w_parent",
-        SerializeIterToRowJson_serialize_this_w_1_tag_w_parent
-    },
-    {
-        "serialize_this_w_1_tag_no_name",
-        SerializeIterToRowJson_serialize_this_w_1_tag_no_name
-    },
-    {
-        "serialize_this_w_1_tag_doc_name",
-        SerializeIterToRowJson_serialize_this_w_1_tag_doc_name
-    },
-    {
-        "serialize_this_w_2_tag",
-        SerializeIterToRowJson_serialize_this_w_2_tag
-    },
-    {
-        "serialize_this_w_1_component",
-        SerializeIterToRowJson_serialize_this_w_1_component
-    },
-    {
-        "serialize_this_w_2_component",
-        SerializeIterToRowJson_serialize_this_w_2_component
-    },
-    {
-        "serialize_this_w_2_component_1_shared",
-        SerializeIterToRowJson_serialize_this_w_2_component_1_shared
-    },
-    {
-        "serialize_this_w_1_pair",
-        SerializeIterToRowJson_serialize_this_w_1_pair
-    },
-    {
-        "serialize_this_w_2_pair",
-        SerializeIterToRowJson_serialize_this_w_2_pair
-    },
-    {
-        "serialize_this_w_1_pair_component",
-        SerializeIterToRowJson_serialize_this_w_1_pair_component
-    },
-    {
-        "serialize_this_w_1_var",
-        SerializeIterToRowJson_serialize_this_w_1_var
-    },
-    {
-        "serialize_this_w_2_var",
-        SerializeIterToRowJson_serialize_this_w_2_var
-    },
-    {
-        "serialize_this_w_2_var_doc_name",
-        SerializeIterToRowJson_serialize_this_w_2_var_doc_name
-    },
-    {
-        "serialize_this_w_1_tag_component_pair_var",
-        SerializeIterToRowJson_serialize_this_w_1_tag_component_pair_var
-    },
-    {
-        "serialize_this_w_2_tag_component_pair_var",
-        SerializeIterToRowJson_serialize_this_w_2_tag_component_pair_var
-    },
-    {
-        "serialize_var_w_1_tag",
-        SerializeIterToRowJson_serialize_var_w_1_tag
-    },
-    {
-        "serialize_var_w_1_component",
-        SerializeIterToRowJson_serialize_var_w_1_component
-    },
-    {
-        "serialize_var_w_1_pair",
-        SerializeIterToRowJson_serialize_var_w_1_pair
-    },
-    {
-        "serialize_var_w_1_var",
-        SerializeIterToRowJson_serialize_var_w_1_var
-    },
-    {
-        "serialize_var_w_2_component_1_shared",
-        SerializeIterToRowJson_serialize_var_w_2_component_1_shared
-    },
-    {
-        "serialize_var_w_1_tag_component_pair_var",
-        SerializeIterToRowJson_serialize_var_w_1_tag_component_pair_var
-    },
-    {
-        "serialize_var_w_2_tag_component_pair_var",
-        SerializeIterToRowJson_serialize_var_w_2_tag_component_pair_var
-    },
-    {
-        "serialize_fixed_w_1_tag",
-        SerializeIterToRowJson_serialize_fixed_w_1_tag
-    },
-    {
-        "serialize_fixed_w_1_component",
-        SerializeIterToRowJson_serialize_fixed_w_1_component
-    },
-    {
-        "serialize_fixed_w_1_pair",
-        SerializeIterToRowJson_serialize_fixed_w_1_pair
-    },
-    {
-        "serialize_fixed_w_1_var",
-        SerializeIterToRowJson_serialize_fixed_w_1_var
-    },
-    {
-        "serialize_fixed_w_2_component_1_shared",
-        SerializeIterToRowJson_serialize_fixed_w_2_component_1_shared
-    },
-    {
-        "serialize_fixed_w_1_tag_component_pair_var",
-        SerializeIterToRowJson_serialize_fixed_w_1_tag_component_pair_var
-    },
-    {
-        "serialize_fixed_w_2_tag_component_pair_var",
-        SerializeIterToRowJson_serialize_fixed_w_2_tag_component_pair_var
-    },
-    {
-        "serialize_not",
-        SerializeIterToRowJson_serialize_not
-    },
-    {
-        "serialize_not_pair_wildcard",
-        SerializeIterToRowJson_serialize_not_pair_wildcard
-    },
-    {
-        "serialize_not_pair_var",
-        SerializeIterToRowJson_serialize_not_pair_var
-    },
-    {
-        "serialize_not_pair_var_constrained",
-        SerializeIterToRowJson_serialize_not_pair_var_constrained
-    },
-    {
-        "serialize_optional",
-        SerializeIterToRowJson_serialize_optional
-    },
-    {
-        "serialize_optional_pair_wildcard",
-        SerializeIterToRowJson_serialize_optional_pair_wildcard
-    },
-    {
-        "serialize_optional_pair_var",
-        SerializeIterToRowJson_serialize_optional_pair_var
-    },
-    {
-        "serialize_optional_pair_var_constrained",
-        SerializeIterToRowJson_serialize_optional_pair_var_constrained
-    },
-    {
-        "serialize_or",
-        SerializeIterToRowJson_serialize_or
-    },
-    {
-        "serialize_scope",
-        SerializeIterToRowJson_serialize_scope
-    },
-    {
-        "serialize_eq",
-        SerializeIterToRowJson_serialize_eq
-    },
-    {
-        "serialize_neq",
-        SerializeIterToRowJson_serialize_neq
-    },
-    {
-        "serialize_eq_m",
-        SerializeIterToRowJson_serialize_eq_m
-    },
-    {
-        "serialize_table",
-        SerializeIterToRowJson_serialize_table
-    },
-    {
-        "serialize_table_w_eq",
-        SerializeIterToRowJson_serialize_table_w_eq
-    },
-    {
-        "serialize_table_w_neq",
-        SerializeIterToRowJson_serialize_table_w_neq
-    },
-    {
-        "serialize_table_w_2_pair_targets",
-        SerializeIterToRowJson_serialize_table_w_2_pair_targets
-    },
-    {
-        "serialize_table_w_2_pair_targets_2_rel",
-        SerializeIterToRowJson_serialize_table_w_2_pair_targets_2_rel
-    },
-    {
-        "serialize_table_w_3_pair_targets",
-        SerializeIterToRowJson_serialize_table_w_3_pair_targets
-    },
-    {
-        "serialize_table_w_3_pair_targets_2_rel",
-        SerializeIterToRowJson_serialize_table_w_3_pair_targets_2_rel
-    },
-    {
-        "serialize_everything",
-        SerializeIterToRowJson_serialize_everything
-    },
-    {
-        "serialize_everything_table",
-        SerializeIterToRowJson_serialize_everything_table
-    },
-    {
-        "serialize_everything_table_w_private",
-        SerializeIterToRowJson_serialize_everything_table_w_private
-    },
-    {
-        "serialize_w_type_info",
-        SerializeIterToRowJson_serialize_w_type_info
-    },
-    {
-        "serialize_w_field_info",
-        SerializeIterToRowJson_serialize_w_field_info
-    },
-    {
-        "serialize_w_field_info_pair_w_0_target",
-        SerializeIterToRowJson_serialize_w_field_info_pair_w_0_target
-    },
-    {
-        "serialize_w_field_info_pair_w_not_tag",
-        SerializeIterToRowJson_serialize_w_field_info_pair_w_not_tag
-    },
-    {
-        "serialize_w_field_info_pair_w_not_pair",
-        SerializeIterToRowJson_serialize_w_field_info_pair_w_not_pair
-    },
-    {
-        "serialize_w_field_info_pair_w_not_component",
-        SerializeIterToRowJson_serialize_w_field_info_pair_w_not_component
-    },
-    {
-        "serialize_w_field_info_w_or",
-        SerializeIterToRowJson_serialize_w_field_info_w_or
-    },
-    {
-        "serialize_recycled_id",
-        SerializeIterToRowJson_serialize_recycled_id
-    },
-    {
-        "serialize_entity_w_flecs_core_parent",
-        SerializeIterToRowJson_serialize_entity_w_flecs_core_parent
+        "serialize_no_matches",
+        SerializeEntityToJson_serialize_no_matches
     }
 };
 
-bake_test_case SerializeTypeInfoToJson_testcases[] = {
-    {
-        "bool",
-        SerializeTypeInfoToJson_bool
-    },
-    {
-        "byte",
-        SerializeTypeInfoToJson_byte
-    },
-    {
-        "char",
-        SerializeTypeInfoToJson_char
-    },
-    {
-        "i8",
-        SerializeTypeInfoToJson_i8
-    },
-    {
-        "i16",
-        SerializeTypeInfoToJson_i16
-    },
-    {
-        "i32",
-        SerializeTypeInfoToJson_i32
-    },
-    {
-        "i64",
-        SerializeTypeInfoToJson_i64
-    },
-    {
-        "iptr",
-        SerializeTypeInfoToJson_iptr
-    },
+bake_test_case SerializeIterToJson_testcases[] = {
     {
-        "u8",
-        SerializeTypeInfoToJson_u8
+        "serialize_1_comps_empty",
+        SerializeIterToJson_serialize_1_comps_empty
     },
     {
-        "u16",
-        SerializeTypeInfoToJson_u16
+        "serialize_1_comps_2_ents_same_table",
+        SerializeIterToJson_serialize_1_comps_2_ents_same_table
     },
     {
-        "u32",
-        SerializeTypeInfoToJson_u32
+        "serialize_1_tag_2_ents_same_table",
+        SerializeIterToJson_serialize_1_tag_2_ents_same_table
     },
     {
-        "u64",
-        SerializeTypeInfoToJson_u64
+        "serialize_2_comps_2_ents_same_table",
+        SerializeIterToJson_serialize_2_comps_2_ents_same_table
     },
     {
-        "uptr",
-        SerializeTypeInfoToJson_uptr
+        "serialize_1_tag_1_comp_2_ents_same_table",
+        SerializeIterToJson_serialize_1_tag_1_comp_2_ents_same_table
     },
     {
-        "float",
-        SerializeTypeInfoToJson_float
+        "serialize_1_tag_1_comp_4_ents_two_tables",
+        SerializeIterToJson_serialize_1_tag_1_comp_4_ents_two_tables
     },
     {
-        "double",
-        SerializeTypeInfoToJson_double
+        "serialize_2_comps_1_owned_2_ents",
+        SerializeIterToJson_serialize_2_comps_1_owned_2_ents
     },
     {
-        "string",
-        SerializeTypeInfoToJson_string
+        "serialize_w_pair_wildcard",
+        SerializeIterToJson_serialize_w_pair_wildcard
     },
     {
-        "entity",
-        SerializeTypeInfoToJson_entity
+        "serialize_w_var",
+        SerializeIterToJson_serialize_w_var
     },
     {
-        "id",
-        SerializeTypeInfoToJson_id
+        "serialize_w_2_vars",
+        SerializeIterToJson_serialize_w_2_vars
     },
     {
-        "enum",
-        SerializeTypeInfoToJson_enum
+        "serialize_type_info_1_tags",
+        SerializeIterToJson_serialize_type_info_1_tags
     },
     {
-        "bitmask",
-        SerializeTypeInfoToJson_bitmask
+        "serialize_type_info_2_tags",
+        SerializeIterToJson_serialize_type_info_2_tags
     },
     {
-        "struct",
-        SerializeTypeInfoToJson_struct
+        "serialize_type_info_1_component",
+        SerializeIterToJson_serialize_type_info_1_component
     },
     {
-        "nested_struct",
-        SerializeTypeInfoToJson_nested_struct
+        "serialize_type_info_2_components",
+        SerializeIterToJson_serialize_type_info_2_components
     },
     {
-        "array_type",
-        SerializeTypeInfoToJson_array_type
+        "serialize_type_info_1_struct",
+        SerializeIterToJson_serialize_type_info_1_struct
     },
     {
-        "vector_type",
-        SerializeTypeInfoToJson_vector_type
+        "serialize_type_info_1_component_1_struct",
+        SerializeIterToJson_serialize_type_info_1_component_1_struct
     },
     {
-        "struct_array_i32_2",
-        SerializeTypeInfoToJson_struct_array_i32_2
+        "serialize_type_info_2_structs",
+        SerializeIterToJson_serialize_type_info_2_structs
     },
     {
-        "struct_array_struct_2",
-        SerializeTypeInfoToJson_struct_array_struct_2
+        "serialize_type_info_w_unit",
+        SerializeIterToJson_serialize_type_info_w_unit
     },
     {
-        "struct_array_type",
-        SerializeTypeInfoToJson_struct_array_type
+        "serialize_type_info_w_unit_quantity",
+        SerializeIterToJson_serialize_type_info_w_unit_quantity
     },
     {
-        "struct_vector_type",
-        SerializeTypeInfoToJson_struct_vector_type
+        "serialize_type_info_w_unit_over",
+        SerializeIterToJson_serialize_type_info_w_unit_over
     },
     {
-        "custom_primitive_type",
-        SerializeTypeInfoToJson_custom_primitive_type
+        "serialize_w_entity_label",
+        SerializeIterToJson_serialize_w_entity_label
     },
     {
-        "custom_array_type",
-        SerializeTypeInfoToJson_custom_array_type
+        "serialize_w_entity_label_w_str",
+        SerializeIterToJson_serialize_w_entity_label_w_str
     },
     {
-        "custom_vector_type",
-        SerializeTypeInfoToJson_custom_vector_type
+        "serialize_w_var_labels",
+        SerializeIterToJson_serialize_w_var_labels
     },
     {
-        "custom_struct_type",
-        SerializeTypeInfoToJson_custom_struct_type
+        "serialize_w_var_component",
+        SerializeIterToJson_serialize_w_var_component
     },
     {
-        "struct_w_value_range",
-        SerializeTypeInfoToJson_struct_w_value_range
+        "serialize_w_optional_tag",
+        SerializeIterToJson_serialize_w_optional_tag
     },
     {
-        "struct_w_error_range",
-        SerializeTypeInfoToJson_struct_w_error_range
+        "serialize_w_optional_component",
+        SerializeIterToJson_serialize_w_optional_component
     },
     {
-        "struct_w_warning_range",
-        SerializeTypeInfoToJson_struct_w_warning_range
+        "serialize_w_optional_reflected_component",
+        SerializeIterToJson_serialize_w_optional_reflected_component
     },
     {
-        "struct_w_error_and_warning_range",
-        SerializeTypeInfoToJson_struct_w_error_and_warning_range
+        "serialize_w_inout_filter_tag",
+        SerializeIterToJson_serialize_w_inout_filter_tag
     },
     {
-        "struct_nested",
-        SerializeTypeInfoToJson_struct_nested
+        "serialize_w_inout_filter_component",
+        SerializeIterToJson_serialize_w_inout_filter_component
     },
     {
-        "struct_nested_2_lvls",
-        SerializeTypeInfoToJson_struct_nested_2_lvls
+        "serialize_w_inout_filter_reflected_component",
+        SerializeIterToJson_serialize_w_inout_filter_reflected_component
     },
     {
-        "struct_nested_2_members",
-        SerializeTypeInfoToJson_struct_nested_2_members
+        "serialize_w_inout_out_tag",
+        SerializeIterToJson_serialize_w_inout_out_tag
     },
     {
-        "struct_nested_3_members",
-        SerializeTypeInfoToJson_struct_nested_3_members
-    }
-};
-
-bake_test_case SerializeQueryInfoToJson_testcases[] = {
+        "serialize_w_inout_out_component",
+        SerializeIterToJson_serialize_w_inout_out_component
+    },
     {
-        "1_tag",
-        SerializeQueryInfoToJson_1_tag
+        "serialize_w_inout_out_reflected_component",
+        SerializeIterToJson_serialize_w_inout_out_reflected_component
     },
     {
-        "1_component",
-        SerializeQueryInfoToJson_1_component
+        "serialize_component_from_var",
+        SerializeIterToJson_serialize_component_from_var
     },
     {
-        "1_pair",
-        SerializeQueryInfoToJson_1_pair
+        "serialize_color",
+        SerializeIterToJson_serialize_color
     },
     {
-        "1_pair_w_wildcard",
-        SerializeQueryInfoToJson_1_pair_w_wildcard
+        "serialize_ids",
+        SerializeIterToJson_serialize_ids
     },
     {
-        "1_pair_w_any",
-        SerializeQueryInfoToJson_1_pair_w_any
+        "serialize_ids_2_entities",
+        SerializeIterToJson_serialize_ids_2_entities
     },
     {
-        "1_tag_fixed_src",
-        SerializeQueryInfoToJson_1_tag_fixed_src
+        "serialize_anonymous",
+        SerializeIterToJson_serialize_anonymous
     },
     {
-        "1_tag_var_src",
-        SerializeQueryInfoToJson_1_tag_var_src
+        "serialize_anonymous_ids",
+        SerializeIterToJson_serialize_anonymous_ids
     },
     {
-        "1_component_in",
-        SerializeQueryInfoToJson_1_component_in
+        "serialize_variable_ids",
+        SerializeIterToJson_serialize_variable_ids
     },
     {
-        "1_component_inout",
-        SerializeQueryInfoToJson_1_component_inout
+        "serialize_variable_ids_2_entities",
+        SerializeIterToJson_serialize_variable_ids_2_entities
     },
     {
-        "1_component_out",
-        SerializeQueryInfoToJson_1_component_out
+        "serialize_variable_anonymous",
+        SerializeIterToJson_serialize_variable_anonymous
     },
     {
-        "1_component_none",
-        SerializeQueryInfoToJson_1_component_none
+        "serialize_variable_anonymous_ids",
+        SerializeIterToJson_serialize_variable_anonymous_ids
     },
     {
-        "1_tag_not",
-        SerializeQueryInfoToJson_1_tag_not
+        "serialize_anonymous_tag",
+        SerializeIterToJson_serialize_anonymous_tag
     },
     {
-        "2_tags_or",
-        SerializeQueryInfoToJson_2_tags_or
+        "serialize_anonymous_component",
+        SerializeIterToJson_serialize_anonymous_component
     },
     {
-        "1_tag_optional",
-        SerializeQueryInfoToJson_1_tag_optional
+        "serialize_anonymous_pair",
+        SerializeIterToJson_serialize_anonymous_pair
     },
     {
-        "1_tag_self",
-        SerializeQueryInfoToJson_1_tag_self
+        "serialize_invalid_value",
+        SerializeIterToJson_serialize_invalid_value
     },
     {
-        "1_tag_self_dont_inherit",
-        SerializeQueryInfoToJson_1_tag_self_dont_inherit
+        "serialize_recycled_pair_id",
+        SerializeIterToJson_serialize_recycled_pair_id
     },
     {
-        "1_tag_up",
-        SerializeQueryInfoToJson_1_tag_up
+        "serialize_w_alert",
+        SerializeIterToJson_serialize_w_alert
     },
     {
-        "1_tag_cascade",
-        SerializeQueryInfoToJson_1_tag_cascade
+        "serialize_no_this_alert_imported",
+        SerializeIterToJson_serialize_no_this_alert_imported
     },
     {
-        "0_term",
-        SerializeQueryInfoToJson_0_term
-    }
-};
-
-bake_test_case MetaUtils_testcases[] = {
+        "serialize_paged_iterator",
+        SerializeIterToJson_serialize_paged_iterator
+    },
     {
-        "struct_w_2_i32",
-        MetaUtils_struct_w_2_i32
+        "serialize_paged_iterator_w_optional_component",
+        SerializeIterToJson_serialize_paged_iterator_w_optional_component
     },
     {
-        "struct_w_2_bool",
-        MetaUtils_struct_w_2_bool
+        "serialize_paged_iterator_w_optional_tag",
+        SerializeIterToJson_serialize_paged_iterator_w_optional_tag
     },
     {
-        "struct_w_2_char",
-        MetaUtils_struct_w_2_char
+        "serialize_paged_iterator_w_vars",
+        SerializeIterToJson_serialize_paged_iterator_w_vars
     },
     {
-        "struct_w_2_string",
-        MetaUtils_struct_w_2_string
+        "serialize_w_offset",
+        SerializeIterToJson_serialize_w_offset
     },
     {
-        "struct_w_2_f32",
-        MetaUtils_struct_w_2_f32
+        "serialize_labels_w_offset",
+        SerializeIterToJson_serialize_labels_w_offset
     },
     {
-        "struct_w_2_f64",
-        MetaUtils_struct_w_2_f64
+        "serialize_colors_w_offset",
+        SerializeIterToJson_serialize_colors_w_offset
     },
     {
-        "struct_w_3_enum",
-        MetaUtils_struct_w_3_enum
+        "serialize_anonymous_entities_w_offset",
+        SerializeIterToJson_serialize_anonymous_entities_w_offset
     },
     {
-        "struct_w_3_enum_multiline",
-        MetaUtils_struct_w_3_enum_multiline
+        "serialize_table",
+        SerializeIterToJson_serialize_table
     },
     {
-        "struct_w_3_enum_w_assignment",
-        MetaUtils_struct_w_3_enum_w_assignment
+        "serialize_table_w_id_labels",
+        SerializeIterToJson_serialize_table_w_id_labels
     },
     {
-        "struct_w_4_bitmask",
-        MetaUtils_struct_w_4_bitmask
+        "serialize_table_w_var_labels",
+        SerializeIterToJson_serialize_table_w_var_labels
     },
     {
-        "struct_w_3_entities",
-        MetaUtils_struct_w_3_entities
+        "serialize_table_w_private",
+        SerializeIterToJson_serialize_table_w_private
     },
     {
-        "struct_w_2_array_3_i32",
-        MetaUtils_struct_w_2_array_3_i32
+        "serialize_world",
+        SerializeIterToJson_serialize_world
     },
     {
-        "struct_w_nested",
-        MetaUtils_struct_w_nested
+        "serialize_term_labels",
+        SerializeIterToJson_serialize_term_labels
     },
     {
-        "struct_w_2_nested",
-        MetaUtils_struct_w_2_nested
+        "serialize_id_labels",
+        SerializeIterToJson_serialize_id_labels
     },
     {
-        "enum_nospace",
-        MetaUtils_enum_nospace
+        "serialize_id_labels_w_str",
+        SerializeIterToJson_serialize_id_labels_w_str
     },
     {
-        "struct_nospace",
-        MetaUtils_struct_nospace
+        "serialize_vars_for_query",
+        SerializeIterToJson_serialize_vars_for_query
     },
     {
-        "identifier_w_underscore",
-        MetaUtils_identifier_w_underscore
+        "serialize_var_labels_for_query",
+        SerializeIterToJson_serialize_var_labels_for_query
     },
     {
-        "struct_w_ptr",
-        MetaUtils_struct_w_ptr
+        "serialize_var_ids_for_query",
+        SerializeIterToJson_serialize_var_ids_for_query
     },
     {
-        "private_members",
-        MetaUtils_private_members
+        "serialize_null_doc_name",
+        SerializeIterToJson_serialize_null_doc_name
     },
     {
-        "enum_constant_w_name_prefix",
-        MetaUtils_enum_constant_w_name_prefix
+        "serialize_rule_w_optional",
+        SerializeIterToJson_serialize_rule_w_optional
     },
     {
-        "enum_constant_w_type_prefix",
-        MetaUtils_enum_constant_w_type_prefix
+        "serialize_rule_w_optional_component",
+        SerializeIterToJson_serialize_rule_w_optional_component
     },
     {
-        "enum_constant_w_name_type_prefix",
-        MetaUtils_enum_constant_w_name_type_prefix
+        "serialize_entity_w_flecs_core_parent",
+        SerializeIterToJson_serialize_entity_w_flecs_core_parent
     }
 };
 
-bake_test_case Vars_testcases[] = {
+bake_test_case SerializeIterToRowJson_testcases[] = {
+    {
+        "serialize_this_w_1_tag",
+        SerializeIterToRowJson_serialize_this_w_1_tag
+    },
+    {
+        "serialize_this_w_1_tag_w_parent",
+        SerializeIterToRowJson_serialize_this_w_1_tag_w_parent
+    },
     {
-        "declare_1_var",
-        Vars_declare_1_var
+        "serialize_this_w_1_tag_no_name",
+        SerializeIterToRowJson_serialize_this_w_1_tag_no_name
     },
     {
-        "declare_2_vars",
-        Vars_declare_2_vars
+        "serialize_this_w_1_tag_doc_name",
+        SerializeIterToRowJson_serialize_this_w_1_tag_doc_name
     },
     {
-        "declare_vars_nested_scope",
-        Vars_declare_vars_nested_scope
+        "serialize_this_w_2_tag",
+        SerializeIterToRowJson_serialize_this_w_2_tag
     },
     {
-        "declare_vars_2_scopes",
-        Vars_declare_vars_2_scopes
+        "serialize_this_w_1_component",
+        SerializeIterToRowJson_serialize_this_w_1_component
     },
     {
-        "redeclare_var",
-        Vars_redeclare_var
+        "serialize_this_w_2_component",
+        SerializeIterToRowJson_serialize_this_w_2_component
     },
     {
-        "i32_expr_w_i32_var",
-        Vars_i32_expr_w_i32_var
+        "serialize_this_w_2_component_1_shared",
+        SerializeIterToRowJson_serialize_this_w_2_component_1_shared
     },
     {
-        "i32_expr_w_f32_var",
-        Vars_i32_expr_w_f32_var
+        "serialize_this_w_1_pair",
+        SerializeIterToRowJson_serialize_this_w_1_pair
     },
     {
-        "i32_expr_w_string_var",
-        Vars_i32_expr_w_string_var
+        "serialize_this_w_2_pair",
+        SerializeIterToRowJson_serialize_this_w_2_pair
     },
     {
-        "string_expr_w_string_var",
-        Vars_string_expr_w_string_var
+        "serialize_this_w_1_pair_component",
+        SerializeIterToRowJson_serialize_this_w_1_pair_component
     },
     {
-        "struct_expr_w_i32_vars",
-        Vars_struct_expr_w_i32_vars
+        "serialize_this_w_1_var",
+        SerializeIterToRowJson_serialize_this_w_1_var
     },
     {
-        "struct_expr_w_struct_var",
-        Vars_struct_expr_w_struct_var
+        "serialize_this_w_2_var",
+        SerializeIterToRowJson_serialize_this_w_2_var
     },
     {
-        "nested_struct_expr_w_struct_var",
-        Vars_nested_struct_expr_w_struct_var
+        "serialize_this_w_2_var_doc_name",
+        SerializeIterToRowJson_serialize_this_w_2_var_doc_name
     },
     {
-        "declare_w_value",
-        Vars_declare_w_value
+        "serialize_this_w_1_tag_component_pair_var",
+        SerializeIterToRowJson_serialize_this_w_1_tag_component_pair_var
     },
     {
-        "redeclare_in_scope",
-        Vars_redeclare_in_scope
+        "serialize_this_w_2_tag_component_pair_var",
+        SerializeIterToRowJson_serialize_this_w_2_tag_component_pair_var
     },
     {
-        "init_fini_vars",
-        Vars_init_fini_vars
-    }
-};
-
-bake_test_case DeserExprOperators_testcases[] = {
+        "serialize_var_w_1_tag",
+        SerializeIterToRowJson_serialize_var_w_1_tag
+    },
     {
-        "add_2_int_literals",
-        DeserExprOperators_add_2_int_literals
+        "serialize_var_w_1_component",
+        SerializeIterToRowJson_serialize_var_w_1_component
     },
     {
-        "add_2_int_literals_twice",
-        DeserExprOperators_add_2_int_literals_twice
+        "serialize_var_w_1_pair",
+        SerializeIterToRowJson_serialize_var_w_1_pair
     },
     {
-        "sub_2_int_literals",
-        DeserExprOperators_sub_2_int_literals
+        "serialize_var_w_1_var",
+        SerializeIterToRowJson_serialize_var_w_1_var
     },
     {
-        "mul_2_int_literals",
-        DeserExprOperators_mul_2_int_literals
+        "serialize_var_w_2_component_1_shared",
+        SerializeIterToRowJson_serialize_var_w_2_component_1_shared
     },
     {
-        "div_2_int_literals",
-        DeserExprOperators_div_2_int_literals
+        "serialize_var_w_1_tag_component_pair_var",
+        SerializeIterToRowJson_serialize_var_w_1_tag_component_pair_var
     },
     {
-        "add_3_int_literals",
-        DeserExprOperators_add_3_int_literals
+        "serialize_var_w_2_tag_component_pair_var",
+        SerializeIterToRowJson_serialize_var_w_2_tag_component_pair_var
     },
     {
-        "add_3_int_literals_twice",
-        DeserExprOperators_add_3_int_literals_twice
+        "serialize_fixed_w_1_tag",
+        SerializeIterToRowJson_serialize_fixed_w_1_tag
     },
     {
-        "sub_3_int_literals",
-        DeserExprOperators_sub_3_int_literals
+        "serialize_fixed_w_1_component",
+        SerializeIterToRowJson_serialize_fixed_w_1_component
     },
     {
-        "mul_3_int_literals",
-        DeserExprOperators_mul_3_int_literals
+        "serialize_fixed_w_1_pair",
+        SerializeIterToRowJson_serialize_fixed_w_1_pair
     },
     {
-        "div_3_int_literals",
-        DeserExprOperators_div_3_int_literals
+        "serialize_fixed_w_1_var",
+        SerializeIterToRowJson_serialize_fixed_w_1_var
     },
     {
-        "int_to_bool",
-        DeserExprOperators_int_to_bool
+        "serialize_fixed_w_2_component_1_shared",
+        SerializeIterToRowJson_serialize_fixed_w_2_component_1_shared
     },
     {
-        "bool_to_int",
-        DeserExprOperators_bool_to_int
+        "serialize_fixed_w_1_tag_component_pair_var",
+        SerializeIterToRowJson_serialize_fixed_w_1_tag_component_pair_var
     },
     {
-        "bool_to_uint",
-        DeserExprOperators_bool_to_uint
+        "serialize_fixed_w_2_tag_component_pair_var",
+        SerializeIterToRowJson_serialize_fixed_w_2_tag_component_pair_var
     },
     {
-        "add_mul_3_int_literals",
-        DeserExprOperators_add_mul_3_int_literals
+        "serialize_not",
+        SerializeIterToRowJson_serialize_not
     },
     {
-        "sub_mul_3_int_literals",
-        DeserExprOperators_sub_mul_3_int_literals
+        "serialize_not_pair_wildcard",
+        SerializeIterToRowJson_serialize_not_pair_wildcard
     },
     {
-        "div_mul_3_int_literals",
-        DeserExprOperators_div_mul_3_int_literals
+        "serialize_not_pair_var",
+        SerializeIterToRowJson_serialize_not_pair_var
     },
     {
-        "add_div_3_int_literals",
-        DeserExprOperators_add_div_3_int_literals
+        "serialize_not_pair_var_constrained",
+        SerializeIterToRowJson_serialize_not_pair_var_constrained
     },
     {
-        "sub_div_3_int_literals",
-        DeserExprOperators_sub_div_3_int_literals
+        "serialize_optional",
+        SerializeIterToRowJson_serialize_optional
     },
     {
-        "mul_div_3_int_literals",
-        DeserExprOperators_mul_div_3_int_literals
+        "serialize_optional_pair_wildcard",
+        SerializeIterToRowJson_serialize_optional_pair_wildcard
     },
     {
-        "mul_add_mul_add_int_literals",
-        DeserExprOperators_mul_add_mul_add_int_literals
+        "serialize_optional_pair_var",
+        SerializeIterToRowJson_serialize_optional_pair_var
     },
     {
-        "mul_sub_mul_sub_int_literals",
-        DeserExprOperators_mul_sub_mul_sub_int_literals
+        "serialize_optional_pair_var_constrained",
+        SerializeIterToRowJson_serialize_optional_pair_var_constrained
     },
     {
-        "mul_div_mul_div_int_literals",
-        DeserExprOperators_mul_div_mul_div_int_literals
+        "serialize_or",
+        SerializeIterToRowJson_serialize_or
     },
     {
-        "div_add_div_add_int_literals",
-        DeserExprOperators_div_add_div_add_int_literals
+        "serialize_scope",
+        SerializeIterToRowJson_serialize_scope
     },
     {
-        "div_sub_div_sub_int_literals",
-        DeserExprOperators_div_sub_div_sub_int_literals
+        "serialize_eq",
+        SerializeIterToRowJson_serialize_eq
     },
     {
-        "div_sub_div_mul_int_literals",
-        DeserExprOperators_div_sub_div_mul_int_literals
+        "serialize_neq",
+        SerializeIterToRowJson_serialize_neq
     },
     {
-        "div_mul_div_mul_int_literals",
-        DeserExprOperators_div_mul_div_mul_int_literals
+        "serialize_eq_m",
+        SerializeIterToRowJson_serialize_eq_m
     },
     {
-        "add_2_flt_literals",
-        DeserExprOperators_add_2_flt_literals
+        "serialize_table",
+        SerializeIterToRowJson_serialize_table
     },
     {
-        "sub_2_flt_literals",
-        DeserExprOperators_sub_2_flt_literals
+        "serialize_table_w_eq",
+        SerializeIterToRowJson_serialize_table_w_eq
     },
     {
-        "mul_2_flt_literals",
-        DeserExprOperators_mul_2_flt_literals
+        "serialize_table_w_neq",
+        SerializeIterToRowJson_serialize_table_w_neq
     },
     {
-        "div_2_flt_literals",
-        DeserExprOperators_div_2_flt_literals
+        "serialize_table_w_2_pair_targets",
+        SerializeIterToRowJson_serialize_table_w_2_pair_targets
     },
     {
-        "add_2_int_neg_literals",
-        DeserExprOperators_add_2_int_neg_literals
+        "serialize_table_w_2_pair_targets_2_rel",
+        SerializeIterToRowJson_serialize_table_w_2_pair_targets_2_rel
     },
     {
-        "sub_2_int_neg_literals",
-        DeserExprOperators_sub_2_int_neg_literals
+        "serialize_table_w_3_pair_targets",
+        SerializeIterToRowJson_serialize_table_w_3_pair_targets
     },
     {
-        "mul_2_int_neg_literals",
-        DeserExprOperators_mul_2_int_neg_literals
+        "serialize_table_w_3_pair_targets_2_rel",
+        SerializeIterToRowJson_serialize_table_w_3_pair_targets_2_rel
     },
     {
-        "div_2_int_neg_literals",
-        DeserExprOperators_div_2_int_neg_literals
+        "serialize_everything",
+        SerializeIterToRowJson_serialize_everything
     },
     {
-        "mul_lparen_add_add_rparen_int_literals",
-        DeserExprOperators_mul_lparen_add_add_rparen_int_literals
+        "serialize_everything_table",
+        SerializeIterToRowJson_serialize_everything_table
     },
     {
-        "mul_lparen_add_add_add_rparen_int_literals",
-        DeserExprOperators_mul_lparen_add_add_add_rparen_int_literals
+        "serialize_everything_table_w_private",
+        SerializeIterToRowJson_serialize_everything_table_w_private
     },
     {
-        "mul_lparen_add_add_rparen_add_int_literals",
-        DeserExprOperators_mul_lparen_add_add_rparen_add_int_literals
+        "serialize_w_type_info",
+        SerializeIterToRowJson_serialize_w_type_info
     },
     {
-        "lparen_add_add_rparen_mul_int_literals",
-        DeserExprOperators_lparen_add_add_rparen_mul_int_literals
+        "serialize_w_field_info",
+        SerializeIterToRowJson_serialize_w_field_info
     },
     {
-        "lparen_add_add_add_rparen_mul_int_literals",
-        DeserExprOperators_lparen_add_add_add_rparen_mul_int_literals
+        "serialize_w_field_info_pair_w_0_target",
+        SerializeIterToRowJson_serialize_w_field_info_pair_w_0_target
     },
     {
-        "double_paren_add_add",
-        DeserExprOperators_double_paren_add_add
+        "serialize_w_field_info_pair_w_not_tag",
+        SerializeIterToRowJson_serialize_w_field_info_pair_w_not_tag
     },
     {
-        "double_paren_literal",
-        DeserExprOperators_double_paren_literal
+        "serialize_w_field_info_pair_w_not_pair",
+        SerializeIterToRowJson_serialize_w_field_info_pair_w_not_pair
     },
     {
-        "lparen_add_add_rparen_mul_lparen_add_add_rparen",
-        DeserExprOperators_lparen_add_add_rparen_mul_lparen_add_add_rparen
+        "serialize_w_field_info_pair_w_not_component",
+        SerializeIterToRowJson_serialize_w_field_info_pair_w_not_component
     },
     {
-        "float_result_add_2_int_literals",
-        DeserExprOperators_float_result_add_2_int_literals
+        "serialize_w_field_info_w_or",
+        SerializeIterToRowJson_serialize_w_field_info_w_or
     },
     {
-        "struct_result_add_2_int_literals",
-        DeserExprOperators_struct_result_add_2_int_literals
+        "serialize_recycled_id",
+        SerializeIterToRowJson_serialize_recycled_id
     },
     {
-        "struct_result_add_2_2_fields_int_literals",
-        DeserExprOperators_struct_result_add_2_2_fields_int_literals
-    },
+        "serialize_entity_w_flecs_core_parent",
+        SerializeIterToRowJson_serialize_entity_w_flecs_core_parent
+    }
+};
+
+bake_test_case SerializeTypeInfoToJson_testcases[] = {
     {
-        "struct_result_add_3_int_literals",
-        DeserExprOperators_struct_result_add_3_int_literals
+        "bool",
+        SerializeTypeInfoToJson_bool
     },
     {
-        "struct_result_lparen_int_rparen",
-        DeserExprOperators_struct_result_lparen_int_rparen
+        "byte",
+        SerializeTypeInfoToJson_byte
     },
     {
-        "add_to_var",
-        DeserExprOperators_add_to_var
+        "char",
+        SerializeTypeInfoToJson_char
     },
     {
-        "add_var_to",
-        DeserExprOperators_add_var_to
+        "i8",
+        SerializeTypeInfoToJson_i8
     },
     {
-        "var_member",
-        DeserExprOperators_var_member
+        "i16",
+        SerializeTypeInfoToJson_i16
     },
     {
-        "bool_cond_and_bool",
-        DeserExprOperators_bool_cond_and_bool
+        "i32",
+        SerializeTypeInfoToJson_i32
     },
     {
-        "bool_cond_or_bool",
-        DeserExprOperators_bool_cond_or_bool
+        "i64",
+        SerializeTypeInfoToJson_i64
     },
     {
-        "int_cond_and_int",
-        DeserExprOperators_int_cond_and_int
+        "iptr",
+        SerializeTypeInfoToJson_iptr
     },
     {
-        "int_cond_or_int",
-        DeserExprOperators_int_cond_or_int
+        "u8",
+        SerializeTypeInfoToJson_u8
     },
     {
-        "bool_cond_and_int",
-        DeserExprOperators_bool_cond_and_int
+        "u16",
+        SerializeTypeInfoToJson_u16
     },
     {
-        "int_cond_and_bool",
-        DeserExprOperators_int_cond_and_bool
+        "u32",
+        SerializeTypeInfoToJson_u32
     },
     {
-        "bool_cond_or_int",
-        DeserExprOperators_bool_cond_or_int
+        "u64",
+        SerializeTypeInfoToJson_u64
     },
     {
-        "int_cond_or_bool",
-        DeserExprOperators_int_cond_or_bool
+        "uptr",
+        SerializeTypeInfoToJson_uptr
     },
     {
-        "cond_eq_bool",
-        DeserExprOperators_cond_eq_bool
+        "float",
+        SerializeTypeInfoToJson_float
     },
     {
-        "cond_eq_int",
-        DeserExprOperators_cond_eq_int
+        "double",
+        SerializeTypeInfoToJson_double
     },
     {
-        "cond_neq_bool",
-        DeserExprOperators_cond_neq_bool
+        "string",
+        SerializeTypeInfoToJson_string
     },
     {
-        "cond_neq_int",
-        DeserExprOperators_cond_neq_int
+        "entity",
+        SerializeTypeInfoToJson_entity
     },
     {
-        "cond_eq_bool_int",
-        DeserExprOperators_cond_eq_bool_int
+        "id",
+        SerializeTypeInfoToJson_id
     },
     {
-        "cond_eq_int_flt",
-        DeserExprOperators_cond_eq_int_flt
+        "enum",
+        SerializeTypeInfoToJson_enum
     },
     {
-        "cond_eq_cond_and",
-        DeserExprOperators_cond_eq_cond_and
+        "bitmask",
+        SerializeTypeInfoToJson_bitmask
     },
     {
-        "cond_eq_cond_or",
-        DeserExprOperators_cond_eq_cond_or
+        "struct",
+        SerializeTypeInfoToJson_struct
     },
     {
-        "cond_gt_bool",
-        DeserExprOperators_cond_gt_bool
+        "nested_struct",
+        SerializeTypeInfoToJson_nested_struct
     },
     {
-        "cond_gt_int",
-        DeserExprOperators_cond_gt_int
+        "array_type",
+        SerializeTypeInfoToJson_array_type
     },
     {
-        "cond_gt_flt",
-        DeserExprOperators_cond_gt_flt
+        "vector_type",
+        SerializeTypeInfoToJson_vector_type
     },
     {
-        "cond_gteq_bool",
-        DeserExprOperators_cond_gteq_bool
+        "struct_array_i32_2",
+        SerializeTypeInfoToJson_struct_array_i32_2
     },
     {
-        "cond_gteq_int",
-        DeserExprOperators_cond_gteq_int
+        "struct_array_struct_2",
+        SerializeTypeInfoToJson_struct_array_struct_2
     },
     {
-        "cond_gteq_flt",
-        DeserExprOperators_cond_gteq_flt
+        "struct_array_type",
+        SerializeTypeInfoToJson_struct_array_type
     },
     {
-        "cond_lt_bool",
-        DeserExprOperators_cond_lt_bool
+        "struct_vector_type",
+        SerializeTypeInfoToJson_struct_vector_type
     },
     {
-        "cond_lt_int",
-        DeserExprOperators_cond_lt_int
+        "custom_primitive_type",
+        SerializeTypeInfoToJson_custom_primitive_type
     },
     {
-        "cond_lt_flt",
-        DeserExprOperators_cond_lt_flt
+        "custom_array_type",
+        SerializeTypeInfoToJson_custom_array_type
     },
     {
-        "cond_lteq_bool",
-        DeserExprOperators_cond_lteq_bool
+        "custom_vector_type",
+        SerializeTypeInfoToJson_custom_vector_type
     },
     {
-        "cond_lteq_int",
-        DeserExprOperators_cond_lteq_int
+        "custom_struct_type",
+        SerializeTypeInfoToJson_custom_struct_type
     },
     {
-        "cond_lteq_flt",
-        DeserExprOperators_cond_lteq_flt
+        "struct_w_value_range",
+        SerializeTypeInfoToJson_struct_w_value_range
     },
     {
-        "min_lparen_int_rparen",
-        DeserExprOperators_min_lparen_int_rparen
+        "struct_w_error_range",
+        SerializeTypeInfoToJson_struct_w_error_range
     },
     {
-        "min_lparen_int_add_int_rparen",
-        DeserExprOperators_min_lparen_int_add_int_rparen
+        "struct_w_warning_range",
+        SerializeTypeInfoToJson_struct_w_warning_range
     },
     {
-        "min_var",
-        DeserExprOperators_min_var
+        "struct_w_error_and_warning_range",
+        SerializeTypeInfoToJson_struct_w_error_and_warning_range
     },
     {
-        "min_lparen_int_rparen_to_i64",
-        DeserExprOperators_min_lparen_int_rparen_to_i64
+        "struct_nested",
+        SerializeTypeInfoToJson_struct_nested
     },
     {
-        "min_lparen_int_rparen_to_i32",
-        DeserExprOperators_min_lparen_int_rparen_to_i32
+        "struct_nested_2_lvls",
+        SerializeTypeInfoToJson_struct_nested_2_lvls
     },
     {
-        "struct_w_min_var",
-        DeserExprOperators_struct_w_min_var
+        "struct_nested_2_members",
+        SerializeTypeInfoToJson_struct_nested_2_members
     },
     {
-        "struct_w_min_lparen_int_rparen",
-        DeserExprOperators_struct_w_min_lparen_int_rparen
-    },
+        "struct_nested_3_members",
+        SerializeTypeInfoToJson_struct_nested_3_members
+    }
+};
+
+bake_test_case SerializeQueryInfoToJson_testcases[] = {
     {
-        "struct_w_min_lparen_var_rparen",
-        DeserExprOperators_struct_w_min_lparen_var_rparen
+        "1_tag",
+        SerializeQueryInfoToJson_1_tag
     },
     {
-        "shift_left_int",
-        DeserExprOperators_shift_left_int
+        "1_component",
+        SerializeQueryInfoToJson_1_component
     },
     {
-        "shift_right_int",
-        DeserExprOperators_shift_right_int
+        "1_pair",
+        SerializeQueryInfoToJson_1_pair
     },
     {
-        "shift_left_int_add_int",
-        DeserExprOperators_shift_left_int_add_int
+        "1_pair_w_wildcard",
+        SerializeQueryInfoToJson_1_pair_w_wildcard
     },
     {
-        "shift_left_int_mul_int",
-        DeserExprOperators_shift_left_int_mul_int
+        "1_pair_w_any",
+        SerializeQueryInfoToJson_1_pair_w_any
     },
     {
-        "add_int_shift_left_int",
-        DeserExprOperators_add_int_shift_left_int
+        "1_tag_fixed_src",
+        SerializeQueryInfoToJson_1_tag_fixed_src
     },
     {
-        "mul_int_shift_left_int",
-        DeserExprOperators_mul_int_shift_left_int
+        "1_tag_var_src",
+        SerializeQueryInfoToJson_1_tag_var_src
     },
     {
-        "add_int_shift_left_int_add_int",
-        DeserExprOperators_add_int_shift_left_int_add_int
+        "1_component_in",
+        SerializeQueryInfoToJson_1_component_in
     },
     {
-        "mul_int_shift_left_int_mul_int",
-        DeserExprOperators_mul_int_shift_left_int_mul_int
+        "1_component_inout",
+        SerializeQueryInfoToJson_1_component_inout
     },
     {
-        "entity_expr",
-        DeserExprOperators_entity_expr
+        "1_component_out",
+        SerializeQueryInfoToJson_1_component_out
     },
     {
-        "entity_path_expr",
-        DeserExprOperators_entity_path_expr
+        "1_component_none",
+        SerializeQueryInfoToJson_1_component_none
     },
     {
-        "entity_parent_func",
-        DeserExprOperators_entity_parent_func
+        "1_tag_not",
+        SerializeQueryInfoToJson_1_tag_not
     },
     {
-        "entity_name_func",
-        DeserExprOperators_entity_name_func
+        "2_tags_or",
+        SerializeQueryInfoToJson_2_tags_or
     },
     {
-        "entity_doc_name_func",
-        DeserExprOperators_entity_doc_name_func
+        "1_tag_optional",
+        SerializeQueryInfoToJson_1_tag_optional
     },
     {
-        "entity_chain_func",
-        DeserExprOperators_entity_chain_func
+        "1_tag_self",
+        SerializeQueryInfoToJson_1_tag_self
     },
     {
-        "var_parent_func",
-        DeserExprOperators_var_parent_func
+        "1_tag_self_dont_inherit",
+        SerializeQueryInfoToJson_1_tag_self_dont_inherit
     },
     {
-        "var_name_func",
-        DeserExprOperators_var_name_func
+        "1_tag_up",
+        SerializeQueryInfoToJson_1_tag_up
     },
     {
-        "var_doc_name_func",
-        DeserExprOperators_var_doc_name_func
+        "1_tag_cascade",
+        SerializeQueryInfoToJson_1_tag_cascade
     },
     {
-        "var_chain_func",
-        DeserExprOperators_var_chain_func
-    },
+        "0_term",
+        SerializeQueryInfoToJson_0_term
+    }
+};
+
+bake_test_case MetaUtils_testcases[] = {
     {
-        "interpolate_string_w_i32_var",
-        DeserExprOperators_interpolate_string_w_i32_var
+        "struct_w_2_i32",
+        MetaUtils_struct_w_2_i32
     },
     {
-        "interpolate_string_w_string_var",
-        DeserExprOperators_interpolate_string_w_string_var
+        "struct_w_2_bool",
+        MetaUtils_struct_w_2_bool
     },
     {
-        "interpolate_string_w_entity_var",
-        DeserExprOperators_interpolate_string_w_entity_var
+        "struct_w_2_char",
+        MetaUtils_struct_w_2_char
     },
     {
-        "interpolate_string_w_id_var",
-        DeserExprOperators_interpolate_string_w_id_var
+        "struct_w_2_string",
+        MetaUtils_struct_w_2_string
     },
     {
-        "interpolate_string_w_var_not_found",
-        DeserExprOperators_interpolate_string_w_var_not_found
+        "struct_w_2_f32",
+        MetaUtils_struct_w_2_f32
     },
     {
-        "interpolate_string_w_entity_var_0",
-        DeserExprOperators_interpolate_string_w_entity_var_0
+        "struct_w_2_f64",
+        MetaUtils_struct_w_2_f64
     },
     {
-        "interpolate_string_w_var_special_chars",
-        DeserExprOperators_interpolate_string_w_var_special_chars
+        "struct_w_3_enum",
+        MetaUtils_struct_w_3_enum
     },
     {
-        "interpolate_string_w_var_before_after_text",
-        DeserExprOperators_interpolate_string_w_var_before_after_text
+        "struct_w_3_enum_multiline",
+        MetaUtils_struct_w_3_enum_multiline
     },
     {
-        "interpolate_string_w_curly_brackets_var",
-        DeserExprOperators_interpolate_string_w_curly_brackets_var
+        "struct_w_3_enum_w_assignment",
+        MetaUtils_struct_w_3_enum_w_assignment
     },
     {
-        "interpolate_string_w_curly_brackets_expr",
-        DeserExprOperators_interpolate_string_w_curly_brackets_expr
+        "struct_w_4_bitmask",
+        MetaUtils_struct_w_4_bitmask
     },
     {
-        "interpolate_string_w_curly_brackets_expr_w_var",
-        DeserExprOperators_interpolate_string_w_curly_brackets_expr_w_var
+        "struct_w_3_entities",
+        MetaUtils_struct_w_3_entities
     },
     {
-        "interpolate_string_w_curly_brackets_expr_w_composite_var",
-        DeserExprOperators_interpolate_string_w_curly_brackets_expr_w_composite_var
+        "struct_w_2_array_3_i32",
+        MetaUtils_struct_w_2_array_3_i32
     },
     {
-        "interpolate_string_w_escape_var_operator",
-        DeserExprOperators_interpolate_string_w_escape_var_operator
+        "struct_w_nested",
+        MetaUtils_struct_w_nested
     },
     {
-        "interpolate_string_w_escape_curly_brackets",
-        DeserExprOperators_interpolate_string_w_escape_curly_brackets
+        "struct_w_2_nested",
+        MetaUtils_struct_w_2_nested
     },
     {
-        "interpolate_string_w_func",
-        DeserExprOperators_interpolate_string_w_func
+        "enum_nospace",
+        MetaUtils_enum_nospace
     },
     {
-        "interpolate_string_w_func_chain",
-        DeserExprOperators_interpolate_string_w_func_chain
+        "struct_nospace",
+        MetaUtils_struct_nospace
     },
     {
-        "iter_to_vars_no_data",
-        DeserExprOperators_iter_to_vars_no_data
+        "identifier_w_underscore",
+        MetaUtils_identifier_w_underscore
     },
     {
-        "iter_to_vars_1_comp",
-        DeserExprOperators_iter_to_vars_1_comp
+        "struct_w_ptr",
+        MetaUtils_struct_w_ptr
     },
     {
-        "iter_to_vars_2_comps",
-        DeserExprOperators_iter_to_vars_2_comps
+        "private_members",
+        MetaUtils_private_members
     },
     {
-        "iter_to_vars_1_comp_1_tag",
-        DeserExprOperators_iter_to_vars_1_comp_1_tag
+        "enum_constant_w_name_prefix",
+        MetaUtils_enum_constant_w_name_prefix
     },
     {
-        "iter_to_vars_w_1_query_var",
-        DeserExprOperators_iter_to_vars_w_1_query_var
+        "enum_constant_w_type_prefix",
+        MetaUtils_enum_constant_w_type_prefix
     },
     {
-        "iter_to_vars_w_2_query_vars",
-        DeserExprOperators_iter_to_vars_w_2_query_vars
+        "enum_constant_w_name_type_prefix",
+        MetaUtils_enum_constant_w_name_type_prefix
     }
 };
 
@@ -5810,20 +4495,6 @@ static bake_test_suite suites[] = {
         135,
         Cursor_testcases
     },
-    {
-        "DeserializeFromExpr",
-        NULL,
-        NULL,
-        57,
-        DeserializeFromExpr_testcases
-    },
-    {
-        "SerializeToExpr",
-        NULL,
-        NULL,
-        55,
-        SerializeToExpr_testcases
-    },
     {
         "DeserializeFromJson",
         NULL,
@@ -5842,7 +4513,7 @@ static bake_test_suite suites[] = {
         "SerializeEntityToJson",
         NULL,
         NULL,
-        51,
+        45,
         SerializeEntityToJson_testcases
     },
     {
@@ -5880,20 +4551,6 @@ static bake_test_suite suites[] = {
         22,
         MetaUtils_testcases
     },
-    {
-        "Vars",
-        NULL,
-        NULL,
-        15,
-        Vars_testcases
-    },
-    {
-        "DeserExprOperators",
-        NULL,
-        NULL,
-        126,
-        DeserExprOperators_testcases
-    },
     {
         "OpaqueTypes",
         NULL,
@@ -5911,5 +4568,5 @@ static bake_test_suite suites[] = {
 };
 
 int main(int argc, char *argv[]) {
-    return bake_test_run("meta", argc, argv, suites, 24);
+    return bake_test_run("meta", argc, argv, suites, 20);
 }
diff --git a/test/query/include/query.h b/test/query/include/query.h
new file mode 100644
index 000000000..da9d7a78b
--- /dev/null
+++ b/test/query/include/query.h
@@ -0,0 +1,83 @@
+#ifndef QUERY_H
+#define QUERY_H
+
+/* This generated file contains includes for project dependencies */
+#include "query/bake_config.h"
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Multiline strings */
+#define HEAD
+#define LINE "\n"
+
+#define MAX_SYS_COLUMNS (20)
+#define MAX_ENTITIES (256)
+#define MAX_INVOCATIONS (1024)
+
+typedef struct Probe {
+    ecs_entity_t system;
+    ecs_entity_t event;
+    ecs_id_t event_id;
+    int32_t offset;
+    int32_t count;
+    int32_t invoked;
+    int32_t term_count;
+    int32_t term_index;
+    ecs_entity_t e[MAX_ENTITIES];
+    ecs_entity_t c[MAX_INVOCATIONS][MAX_SYS_COLUMNS];
+    ecs_entity_t s[MAX_INVOCATIONS][MAX_SYS_COLUMNS];
+    void *param;
+} Probe;
+
+typedef struct IterData {
+    ecs_entity_t component;
+    ecs_entity_t component_2;
+    ecs_entity_t component_3;
+    ecs_entity_t new_entities[MAX_ENTITIES];
+    int32_t entity_count;
+} IterData;
+
+typedef struct Position {
+    float x;
+    float y;
+} Position;
+
+typedef struct Velocity {
+    float x;
+    float y;
+} Velocity;
+
+typedef float Mass;
+
+typedef float Rotation;
+
+typedef struct Color {
+    float r;
+    float g;
+    float b;
+    float a;
+} Color;
+
+typedef struct Self {
+    ecs_entity_t value;
+} Self;
+
+void probe_system_w_ctx(
+    ecs_iter_t *it,
+    Probe *ctx);
+
+void probe_iter(ecs_iter_t *it);
+
+void probe_has_entity(Probe *probe, ecs_entity_t e);
+
+void install_test_abort(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/test/query/include/query/bake_config.h b/test/query/include/query/bake_config.h
new file mode 100644
index 000000000..2b2c33ea2
--- /dev/null
+++ b/test/query/include/query/bake_config.h
@@ -0,0 +1,25 @@
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef QUERY_BAKE_CONFIG_H
+#define QUERY_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+#include <bake_test.h>
+
+#endif
+
diff --git a/test/query/project.json b/test/query/project.json
new file mode 100644
index 000000000..892e740b8
--- /dev/null
+++ b/test/query/project.json
@@ -0,0 +1,1877 @@
+{
+    "id": "query",
+    "type": "application",
+    "value": {
+        "author": "Sander Mertens",
+        "description": "Test project for flecs queries",
+        "public": false,
+        "coverage": false,
+        "use": [
+            "flecs"
+        ]
+    },
+    "test": {
+        "testsuites": [{
+            "id": "Validator",
+            "testcases": [
+                "validate_1_term",
+                "validate_1_term_component",
+                "validate_2_terms",
+                "validate_3_terms",
+                "validate_3_terms_w_or",
+                "validate_4_terms_w_or_at_1",
+                "validate_1_term_wildcard",
+                "validate_1_term_any",
+                "validate_1_term_same_subj_obj",
+                "validate_1_term_acyclic_same_subj_obj",
+                "validate_1_term_acyclic_reflexive_same_subj_obj",
+                "validate_1_term_same_subj_obj_var",
+                "validate_1_term_acyclic_same_subj_obj_var",
+                "validate_1_term_acyclic_reflexive_same_subj_obj_var",
+                "validate_1_term_non_acyclic_superset",
+                "validate_1_term_dont_inherit_default_set",
+                "validate_1_term_dont_inherit_pair_default_set",
+                "validate_1_term_cascade_implicit_trav",
+                "validate_1_term_cascade_isa",
+                "validate_1_term_cascade_childof",
+                "validate_1_term_cascade_down",
+                "validate_1_term_optional_only",
+                "validate_1_term_transitive_pair",
+                "validate_1_variable_as_pred_only",
+                "validate_1_variable_as_pred_w_subj",
+                "validate_1_variable_as_pred_w_pair",
+                "validate_1_variable_as_subj",
+                "validate_1_variable_as_obj",
+                "validate_2_terms_or_w_dontinherit",
+                "validate_2_terms_or_w_both_dontinherit",
+                "validate_w_pair_id",
+                "validate_w_pred_obj",
+                "validate_w_pair_id_and_subj",
+                "validate_1_w_pred_name",
+                "validate_1_w_final_pred_name",
+                "validate_1_w_subj_name",
+                "validate_1_w_obj_name",
+                "validate_w_this_implicit_variable",
+                "validate_w_this_explicit_entity",
+                "validate_w_first_this_implicit_variable",
+                "validate_w_first_this_explicit_entity",
+                "validate_w_second_this_implicit_variable",
+                "validate_w_second_this_explicit_entity",
+                "validate_w_this_variable_name",
+                "validate_w_src_var",
+                "validate_w_first_var",
+                "validate_w_second_var",
+                "validate_w_src_var_from_name",
+                "validate_w_first_first_var",
+                "validate_w_second_second_var",
+                "validate_w_0_source",
+                "validate_w_0_target",
+                "validate_2_terms_w_or",
+                "validate_2_terms_w_or_mixed_src_flags",
+                "validate_2_terms_w_or_mixed_src_id",
+                "validate_2_terms_w_or_mixed_src_name",
+                "validate_2_terms_w_or_same_src_w_id_and_name",
+                "validate_w_and_flag",
+                "validate_w_or_flag",
+                "validate_w_not_flag",
+                "validate_filter",
+                "validate_double_init",
+                "validate_double_init_w_expr",
+                "validate_double_init_w_expr_optional",
+                "validate_w_tag_term_is_no_data",
+                "validate_w_inout_none_term_is_no_data",
+                "validate_w_tag_and_inout_none_term_is_no_data",
+                "validate_w_not_term_is_no_data",
+                "validate_w_no_transitive_pair",
+                "validate_w_transitive_pair_any_src",
+                "validate_w_transitive_pair",
+                "validate_w_transitive_tag_no_pair",
+                "validate_w_transitive_tag_self_tgt",
+                "validate_w_transitive_tag_any_tgt",
+                "validate_w_pair_same_vars",
+                "validate_w_pair_not_same_vars",
+                "validate_w_pair_no_vars_not_same_vars",
+                "validate_w_pair_wildcard_not_same_vars",
+                "validate_w_pair_any_not_same_vars",
+                "validate_w_no_pair_not_same_vars",
+                "validate_not_childof_any",
+                "validate_w_inherited_id",
+                "validate_w_inherited_pair",
+                "validate_w_non_inherited_id",
+                "validate_w_non_inherited_pair",
+                "validate_w_first_wildcard_inout_none",
+                "validate_w_first_var_inout_none",
+                "validate_w_pair_wildcard_inout_none",
+                "validate_w_pair_var_inout_none",
+                "validate_w_unresolved_by_name",
+                "validate_w_unresolved_by_name_eq",
+                "validate_childof_this",
+                "validate_childof_this_entity",
+                "validate_childof_this_by_id",
+                "validate_filter_flag",
+                "validate_first_0_name",
+                "validate_src_0_name",
+                "validate_second_0_name",
+                "validate_singleton_src_w_first_name",
+                "validate_singleton_second_w_first_name"
+            ]
+        }, {
+            "id": "Parser",
+            "testcases": [
+                "resolve_this",
+                "resolve_wildcard",
+                "resolve_any",
+                "resolve_is_a",
+                "0",
+                "component_implicit_subject",
+                "component_explicit_subject",
+                "component_explicit_subject_this",
+                "component_explicit_subject_this_by_name",
+                "component_explicit_subject_this_by_var_name",
+                "component_explicit_subject_wildcard",
+                "component_explicit_subject_any",
+                "component_explicit_subject_0",
+                "this_as_predicate",
+                "this_var_as_predicate",
+                "this_lowercase_var_as_predicate",
+                "this_as_object",
+                "this_var_as_object",
+                "pair_implicit_subject",
+                "pair_implicit_subject_wildcard_pred",
+                "pair_implicit_subject_wildcard_obj",
+                "pair_implicit_subject_any_pred",
+                "pair_implicit_subject_any_obj",
+                "pair_implicit_subject_this_pred",
+                "pair_implicit_subject_this_obj",
+                "pair_implicit_subject_pred_w_self",
+                "pair_implicit_subject_obj_w_self",
+                "pair_implicit_subject_pred_w_up",
+                "pair_implicit_subject_obj_w_up",
+                "pair_implicit_subject_pred_w_self_up",
+                "pair_implicit_subject_obj_w_self_up",
+                "pair_implicit_subject_pred_w_invalid_flags",
+                "pair_implicit_subject_obj_w_invalid_flags",
+                "pair_explicit_subject",
+                "pair_explicit_subject_this",
+                "pair_explicit_subject_this_by_name",
+                "pair_explicit_subject_this_by_var_name",
+                "pair_explicit_subject_wildcard_pred",
+                "pair_explicit_subject_wildcard_subj",
+                "pair_explicit_subject_wildcard_obj",
+                "pair_implicit_subject_0_object",
+                "pair_explicit_subject_0_object",
+                "pair_explicit_subject_0",
+                "in_component_implicit_subject",
+                "in_component_explicit_subject",
+                "in_pair_implicit_subject",
+                "in_pair_explicit_subject",
+                "inout_component_implicit_subject",
+                "inout_component_explicit_subject",
+                "inout_pair_implicit_subject",
+                "inout_pair_explicit_subject",   
+                "out_component_implicit_subject",
+                "out_component_explicit_subject",
+                "out_pair_implicit_subject",
+                "out_pair_explicit_subject",
+                "inout_filter_component",
+                "inout_w_not_operator",
+                "inout_w_optional_operator",
+                "component_singleton",
+                "this_singleton",
+                "component_implicit_no_subject",
+                "component_explicit_no_subject",
+                "pair_no_subject",
+                "variable_single_char",
+                "variable_multi_char",
+                "variable_multi_char_w_underscore",
+                "variable_multi_char_w_number",
+                "variable_multi_char_not_allcaps",
+                "pred_var",
+                "obj_var",
+                "component_not",
+                "pair_implicit_subject_not",
+                "pair_explicit_subject_not",
+                "2_component_not",
+                "2_component_not_no_space",
+                "component_optional",
+                "2_component_optional",
+                "2_component_optional_no_space",
+                "from_and",
+                "from_or",
+                "from_not",
+                "pair_implicit_subject_optional",
+                "pair_explicit_subject_optional",                
+                "pred_implicit_subject_w_role",
+                "pred_explicit_subject_w_role",
+                "pred_no_subject_w_role",
+                "pair_implicit_subject_w_role",
+                "pair_explicit_subject_w_role",
+                "inout_role_pred_implicit_subject",
+                "inout_role_pred_no_subject",
+                "inout_role_pred_explicit_subject",
+                "inout_role_pair_implicit_subject",
+                "inout_role_pair_explicit_subject",
+                "2_pred_implicit_subject",
+                "2_pred_no_subject",
+                "2_pred_explicit_subject",
+                "2_pair_implicit_subject",
+                "2_pair_explicit_subject",
+                "2_pred_role",
+                "2_pair_implicit_subj_role",
+                "2_pair_explicit_subj_role",
+                "2_or_pred_implicit_subj",
+                "2_or_pred_explicit_subj",
+                "2_or_pair_implicit_subj",
+                "2_or_pair_explicit_subj",
+                "2_or_pred_inout",
+                "2_or_no_space",
+                "2_or_w_not_1st_arg",
+                "2_or_w_not_2nd_arg",
+                "2_or_w_optional_1st_arg",
+                "2_or_w_optional_2nd_arg",
+                "1_digit_pred_implicit_subj",
+                "1_digit_pred_no_subj",
+                "1_digit_pred_explicit_subj",
+                "1_digit_pair_implicit_subj",
+                "1_digit_pair_explicit_subj",
+                "pred_implicit_subject_self",
+                "pred_implicit_subject_superset",
+                "pred_implicit_subject_superset_inclusive",
+                "pred_implicit_subject_superset_cascade",
+                "pred_implicit_subject_superset_inclusive_cascade",
+                "pred_implicit_subject_implicit_superset_cascade",         
+                "pred_implicit_subject_implicit_superset_inclusive_cascade",
+                "pred_implicit_subject_implicit_superset_cascade_w_rel",         
+                "pred_implicit_subject_implicit_superset_inclusive_cascade_w_rel",
+                "pred_implicit_subject_superset_childof",
+                "pred_implicit_subject_cascade_superset_childof",
+                "pred_implicit_subject_superset_cascade_childof",
+                "pred_implicit_subject_superset_cascade_childof_optional",
+                "expr_w_symbol",
+                "expr_w_newline",
+                "subj_entity_w_explicit_self",
+                "subj_entity_w_explicit_self_superset",
+                "subj_entity_w_explicit_superset_relation",
+                "subj_entity_w_explicit_self_superset_relation",
+                "obj_entity_w_explicit_self",
+                "obj_entity_w_explicit_self_superset",
+                "obj_entity_w_explicit_superset_relation",
+                "obj_entity_w_explicit_self_superset_relation",
+                "pred_entity_w_explicit_self",
+                "pred_entity_w_explicit_self_superset",
+                "pred_entity_no_args_w_explicit_self",
+                "pred_entity_no_args_w_explicit_self_superset",
+                "pred_entity_no_args_2_terms_w_explicit_self",
+                "pred_entity_no_args_2_terms_w_explicit_self_superset",
+                "newline",
+                "2_newlines",
+                "3_newlines",
+                "space",
+                "2_spaces",
+                "trailing_newline",
+                "2_trailing_newlines",
+                "trailing_space",
+                "2_trailing_spaces",
+                "template_type",
+                "template_type_nested",
+                "template_type_multiple_args",
+                "template_type_multiple_args_nested",
+                "template_type_unbalanced_open",
+                "template_type_unbalanced_close",
+                "predicate_w_parens",
+                "not_alive_pred",
+                "not_alive_subj",
+                "not_alive_obj",
+                "this_subj_var_kind",
+                "this_obj_var_kind",
+                "this_subj_obj_var_kind",
+                "var_w_name",
+                "entity_pred_no_name",
+                "entity_subj_no_name",
+                "entity_obj_no_name",
+                "this_pred_no_name",
+                "this_subj_no_name",
+                "this_obj_no_name",
+                "invalid_variable_only",
+                "oneof_self_pred_w_relative_obj",
+                "oneof_other_pred_w_relative_obj",
+                "oneof_self_pred_w_invalid_obj",
+                "oneof_other_pred_w_invalid_obj",
+                "oneof_w_other_entity_w_same_name",
+                "oneof_w_other_entity_w_same_name_w_set_scope",
+                "oneof_w_wildcard",
+                "oneof_w_any",
+                "oneof_w_fullpath",
+                "pair_implicit_src_missing_rel",
+                "pair_implicit_src_missing_obj",
+                "pair_explicit_src_missing_src",
+                "pair_explicit_src_missing_obj",
+                "eq_id",
+                "eq_id_var",
+                "eq_var_id",
+                "eq_var_table",
+                "eq_var",
+                "neq_id",
+                "neq_id_var",
+                "neq_var_id",
+                "neq_var_table",
+                "neq_var",
+                "eq_name",
+                "eq_name_var",
+                "eq_var_name",
+                "neq_name",
+                "neq_name_var",
+                "neq_var_name",
+                "match_name",
+                "match_name_var",
+                "match_var_name",
+                "match_var",
+                "nmatch_name",
+                "nmatch_name_var",
+                "nmatch_var_name",
+                "eq_same_var",
+                "neq_same_var",
+                "eq_same_var_this",
+                "neq_same_var_this",
+                "eq_w_not",
+                "neq_w_not",
+                "match_w_not",
+                "eq_w_optional",
+                "neq_w_optional",
+                "match_w_optional",
+                "eq_0",
+                "neq_0",
+                "eq_wildcard",
+                "neq_wildcard",
+                "eq_any",
+                "neq_any",
+                "query_scope_1_term",
+                "query_scope_1_term_spaces",
+                "query_scope_2_terms",
+                "query_nested_scope",
+                "query_nested_scope_spaces",
+                "query_scope_unbalanced",
+                "query_not_scope",
+                "query_empty_scope",
+                "query_scope_newline_after_open",
+                "query_scope_newline_after_close",
+                "query_term_after_scope",
+                "override_tag",
+                "override_pair",
+                "pair_3_args",
+                "pair_3_args_implicit_this",
+                "pair_4_args",
+                "pair_4_args_implicit_this",
+                "pair_3_args_2_terms",
+                "pair_3_args_this_tgt",
+                "pair_3_args_2_terms_this_tgt",
+                "pair_3_args_2_terms_this_tgt_implicit_this",
+                "pair_3_or_args",
+                "pair_3_or_args_implicit_this",
+                "pair_4_or_args",
+                "pair_4_or_args_implicit_this",
+                "pair_3_args_w_vars",
+                "pair_4_args_w_vars",
+                "pair_3_args_w_vars_w_term_after",
+                "pair_4_args_w_vars_w_term_after",
+                "pair_or_before_and_oper",
+                "pair_and_before_or_oper",
+                "cascade_desc",
+                "newline_after_inout",
+                "newline_after_term_open",
+                "newline_after_term_src",
+                "newline_after_term_src_pair",
+                "newline_after_term_pair_comma",
+                "newline_after_term_pair_second",
+                "tag_w_space_implicit_this",
+                "tag_w_space",
+                "pair_first_w_space_implicit_this",
+                "pair_first_w_space",
+                "pair_second_w_space_implicit_this",
+                "pair_second_w_space",
+                "pair_src_w_space",
+                "empty_term",
+                "empty_term_w_space",
+                "empty_term_w_newline",
+                "mixed_1_desc_and_1_expr",
+                "mixed_2_desc_and_1_expr",
+                "mixed_1_desc_and_2_expr"
+            ]
+        }, {
+            "id": "Basic",
+            "setup": true,
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "testcases": [
+                "0_query",
+                "1_fact_w_tag",
+                "1_fact_w_component",
+                "1_fact_w_tag_pair",
+                "1_fact_w_component_pair",
+                "2_facts_same_src_w_tag",
+                "2_facts_same_src_w_component",
+                "2_facts_same_src_w_tag_pair",
+                "2_facts_same_src_w_component_pair",
+                "2_facts_other_src_w_tag",
+                "2_facts_other_src_w_component",
+                "2_facts_other_src_w_tag_pair",
+                "2_facts_other_src_w_component_pair",
+                "1_fact_w_any",
+                "1_fact_w_pair_any_tgt",
+                "1_fact_w_pair_any_rel",
+                "1_fact_w_pair_any_rel_tgt",
+                "2_facts_same_src_w_any",
+                "2_facts_same_src_w_pair_any_tgt",
+                "2_facts_same_src_w_pair_any_rel",
+                "2_facts_same_src_w_pair_any_rel_tgt",
+                "2_facts_other_src_w_any",
+                "2_facts_other_src_w_pair_any_tgt",
+                "2_facts_other_src_w_pair_any_rel",
+                "2_facts_other_src_w_pair_any_rel_tgt",
+                "1_this_src_w_tag",
+                "1_this_src_w_component",
+                "1_this_src_w_tag_pair",
+                "1_this_src_w_component_pair",
+                "1_this_src_w_tag_2_tables",
+                "1_this_src_w_component_2_tables",
+                "1_this_src_w_tag_pair_2_tables",
+                "1_this_src_w_component_pair_2_tables",
+                "2_this_src_w_tag",
+                "2_this_src_w_component",
+                "2_this_src_ent_src_w_tag",
+                "2_this_src_ent_src_w_component",
+                "2_ent_src_this_src_w_tag",
+                "2_ent_src_this_src_w_component",
+                "recycled_tag",
+                "recycled_src",
+                "recycled_pair_rel",
+                "recycled_pair_tgt",
+                "this_src_w_wildcard",
+                "this_src_w_pair_rel_wildcard",
+                "this_src_w_pair_tgt_wildcard",
+                "this_src_w_pair_rel_tgt_wildcard",
+                "this_src_w_any",
+                "this_src_w_any_written",
+                "this_src_w_pair_rel_any",
+                "this_src_w_pair_tgt_any",
+                "this_src_w_pair_rel_tgt_any",
+                "ent_src_w_wildcard",
+                "ent_src_w_pair_rel_wildcard",
+                "ent_src_w_pair_tgt_wildcard",
+                "ent_src_w_pair_rel_tgt_wildcard",
+                "1_wildcard_src",
+                "1_wildcard_src_w_pair",
+                "2_wildcard_src",
+                "2_wildcard_src_w_pair",
+                "1_wildcard_src_w_pair_tgt_var",
+                "1_wildcard_src_w_pair_rel_var",
+                "1_wildcard_src_w_pair_tgt_this",
+                "1_wildcard_src_w_pair_rel_this",
+                "1_any_src",
+                "1_any_src_w_pair",
+                "2_any_src",
+                "2_any_src_w_pair",
+                "1_any_src_w_pair_tgt_var",
+                "1_any_src_w_pair_rel_var",
+                "1_any_src_w_pair_tgt_this",
+                "1_any_src_w_pair_rel_this",
+                "not_any",
+                "rule_w_iter_next",
+                "empty_rule",
+                "invalid_rule",
+                "not_instanced_table_src",
+                "not_instanced_entity_src",
+                "not_instanced_mixed_src",
+                "not_instanced_inherited",
+                "instanced_table_src",
+                "instanced_entity_src",
+                "instanced_mixed_src",
+                "instanced_inherited",
+                "in_term",
+                "out_term",
+                "inout_term",
+                "nodata_term",
+                "find_this_lowercase",
+                "find_this_uppercase",
+                "find_this_tgt_lowercase",
+                "find_this_tgt_uppercase",
+                "get_filter",
+                "iter_empty_source",
+                "iter_empty_source_2_terms",
+                "iter_empty_source_wildcard",
+                "iter_empty_source_pair",
+                "iter_empty_source_pair_wildcard",
+                "iter_empty_source_2_terms_pair",
+                "iter_empty_source_2_terms_mixed",
+                "iter_empty_source_2_terms_mixed_pair",
+                "iter_empty_source_2_terms_mixed_pair_wildcard",
+                "this_var_w_empty_entity",
+                "match_disabled",
+                "match_prefab",
+                "match_disabled_prefab",
+                "match_disabled_this_tgt",
+                "match_prefab_this_tgt",
+                "match_disabled_prefab_this_tgt",
+                "match_self_disabled",
+                "match_self_prefab",
+                "match_self_disabled_prefab",
+                "match_optional_disabled",
+                "match_optional_prefab",
+                "match_optional_disabled_prefab",
+                "match_optional_disabled_this_tgt",
+                "match_optional_prefab_this_tgt",
+                "match_optional_disabled_prefab_this_tgt",
+                "match_optional_self_disabled",
+                "match_optional_self_prefab",
+                "match_optional_self_disabled_prefab",
+                "inout_none_first_term",
+                "inout_none_second_term",
+                "inout_none_singleton",
+                "inout_none_singleton_w_or",
+                "inout_none_component_w_or",
+                "no_data_rule",
+                "frame_offset",
+                "frame_offset_no_data",
+                "match_empty_tables",
+                "match_empty_tables_no_data",
+                "match_empty_tables_w_not",
+                "match_empty_tables_w_wildcard",
+                "match_empty_tables_w_no_empty_tables",
+                "match_empty_tables_trivial",
+                "oneof_wildcard",
+                "oneof_any",
+                "instanced_w_singleton",
+                "instanced_w_base",
+                "not_instanced_w_singleton",
+                "not_instanced_w_base",
+                "unknown_before_known",
+                "unknown_before_known_after_or",
+                "unknown_before_known_after_not",
+                "unknown_before_known_after_optional",
+                "unknown_before_known_after_scope",
+                "2_trivial_mixed_2_tables",
+                "2_trivial_mixed_2_tables_component",
+                "2_trivial_mixed_2_tables_wildcard",
+                "2_trivial_1_unused_id",
+                "2_trivial_one_regular",
+                "1_trivial_one_regular_one_trivial",
+                "one_regular_2_trivial",
+                "2_trivial_w_prefab",
+                "3_trivial_w_prefab",
+                "2_trivial_w_disabled",
+                "3_trivial_w_disabled",
+                "2_this_w_fixed_src",
+                "2_fixed_src_w_this",
+                "2_this_w_fixed_src_no_match_fixed",
+                "2_fixed_src_w_this_no_match_fixed",
+                "2_this_w_fixed_src_no_match_this",
+                "2_fixed_src_w_this_no_match_this",
+                "query_count_results",
+                "query_count_entities",
+                "query_is_true",
+                "implicit_cleanup_1_term",
+                "implicit_cleanup_2_terms",
+                "implicit_cleanup_1_term_w_up",
+                "implicit_cleanup_2_terms_w_up",
+                "implicit_cleanup_2_queries",
+                "implicit_cleanup_2_queries_1_cleanup",
+                "iter_valid",
+                "iter_frame_offset",
+                "iter_nested_1",
+                "iter_nested_2",
+                "iter_interleaved",
+                "set_get_context",
+                "set_get_binding_context",
+                "set_get_context_w_free",
+                "set_get_binding_context_w_free",
+                "create_query_w_existing_entity",
+                "create_query_w_existing_entity_different_term_count",
+                "create_multi_component_query_w_existing_entity",
+                "delete_query_by_entity",
+                "eval_count",
+                "no_results_after_delete_tree",
+                "no_results_after_delete_tree_deferred",
+                "add_on_self_ref",
+                "add_on_self_ref_by_name",
+                "delete_id_after_delete_query",
+                "pair_sweep_tag",
+                "pair_sweep_wildcard_first",
+                "pair_sweep_wildcard_second"
+            ]
+        }, {
+            "id": "Plan",
+            "testcases": [
+                "reordered_plan_1",
+                "reordered_plan_2",
+                "1_trivial_plan",
+                "2_trivial_plan",
+                "1_trivial_plan_component",
+                "2_trivial_plan_component",
+                "3_trivial_plan_w_pair",
+                "3_trivial_plan_w_wildcard",
+                "3_trivial_plan_w_any",
+                "3_trivial_plan_w_pair_component",
+                "3_trivial_plan_w_wildcard_component",
+                "3_trivial_plan_w_any_component",
+                "1_trivial_component_w_none",
+                "2_trivial_component_w_none",
+                "2_trivial_plan_w_wildcard",
+                "this_before_fixed_src",
+                "fixed_src_before_this",
+                "var_before_fixed_src",
+                "fixed_src_before_var",
+                "this_before_fixed_src_w_not",
+                "this_before_fixed_src_w_first_var",
+                "this_before_fixed_src_w_first_var_w_not",
+                "this_before_fixed_src_w_second_var",
+                "this_before_fixed_src_w_second_var_w_not",
+                "populate_1_fixed",
+                "populate_2_fixed",
+                "populate_1_fixed_1_this_self",
+                "populate_2_fixed_2_this_self",
+                "populate_2_fixed_2_this_self_interleaved",
+                "populate_2_this_self_2_fixed",
+                "populate_1_fixed_1_this_up",
+                "populate_2_fixed_2_this_up",
+                "populate_2_fixed_2_this_up_interleaved",
+                "populate_2_this_up_2_fixed",
+                "populate_1_fixed_1_this_self_cached",
+                "populate_2_fixed_2_this_self_cached",
+                "populate_2_fixed_2_this_self_interleaved_cached",
+                "populate_2_this_self_2_fixed_cached",
+                "populate_1_fixed_1_this_up_cached",
+                "populate_2_fixed_2_this_up_cached",
+                "populate_2_fixed_2_this_up_interleaved_cached",
+                "populate_2_this_up_2_fixed_cached",
+                "populate_1_fixed_1_var_self",
+                "populate_2_fixed_2_var_self",
+                "populate_2_fixed_2_var_self_interleaved",
+                "populate_2_var_self_2_fixed",
+                "populate_1_fixed_1_var_up",
+                "populate_2_fixed_2_var_up",
+                "populate_2_fixed_2_var_up_interleaved",
+                "populate_2_var_up_2_fixed",
+                "cache_2_or",
+                "cache_2_or_w_not",
+                "1_plan_any_src",
+                "1_plan_not_any_src",
+                "1_plan_optional_any_src",
+                "pair_first_wildcard",
+                "pair_first_wildcard_cached",
+                "pair_second_wildcard",
+                "pair_second_wildcard_cached"
+            ]
+        }, {
+            "id": "Variables",
+            "setup": true,
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "testcases": [
+                "1_ent_src_w_var",
+                "1_ent_src_w_pair_rel_var",
+                "1_ent_src_w_pair_tgt_var",
+                "1_ent_src_w_pair_rel_tgt_var",
+                "1_ent_src_w_pair_rel_tgt_same_var",
+                "1_ent_src_w_pair_rel_tgt_same_var_after_write",
+                "1_this_src_w_var",
+                "1_this_src_w_pair_rel_var",
+                "1_this_src_w_pair_tgt_var",
+                "1_this_src_w_pair_rel_tgt_var",
+                "1_this_src_w_pair_rel_tgt_same_var",
+                "1_this_src_w_pair_rel_tgt_same_var_after_write",
+                "1_src_id_same_var",
+                "1_src_pair_first_same_var",
+                "1_src_pair_second_same_var",
+                "1_src_pair_first_and_second_same_var",
+                "1_src_id_same_var_after_write",
+                "1_src_pair_first_same_var_after_write",
+                "1_src_pair_second_same_var_after_write",
+                "1_src_pair_first_and_second_same_var_after_write",
+                "1_src_pair_first_same_var_this",
+                "1_src_pair_second_same_var_this",
+                "1_src_pair_first_and_second_same_var_this",
+                "1_src_id_same_var_this_after_write",
+                "1_src_pair_first_same_var_this_after_write",
+                "1_src_pair_second_same_var_this_after_write",
+                "1_src_pair_first_and_second_same_var_this_after_write",
+                "1_ent_src_w_this_var",
+                "1_ent_src_w_pair_this_rel",
+                "1_ent_src_w_pair_this_tgt",
+                "1_ent_src_w_pair_this_rel_tgt",
+                "1_this_src_w_this",
+                "1_this_src_w_pair_this_rel_tgt",
+                "1_this_src_w_this_after_write",
+                "1_this_src_w_pair_this_rel_tgt_after_write",
+                "2_constrain_src_from_src",
+                "2_constrain_rel_from_src_w_ent",
+                "2_constrain_rel_from_src_w_var",
+                "2_constrain_rel_from_src_w_this",
+                "2_constrain_pair_rel_from_src_w_ent",
+                "2_constrain_pair_rel_from_src_w_var",
+                "2_constrain_pair_rel_from_src_w_this",
+                "2_constrain_pair_tgt_from_src_w_ent",
+                "2_constrain_pair_tgt_from_src_w_var",
+                "2_constrain_pair_tgt_from_src_w_this",
+                "2_constrain_pair_rel_tgt_from_src_w_ent",
+                "2_constrain_pair_rel_tgt_from_src_w_var",
+                "2_constrain_pair_rel_tgt_from_src_w_this",
+                "1_ent_src_set_rel_var",
+                "1_ent_src_set_pair_rel_var",
+                "1_ent_src_set_pair_tgt_var",
+                "1_set_src_var",
+                "1_set_src_var_w_pair",
+                "1_set_src_var_w_pair_set_rel",
+                "1_set_src_var_w_pair_set_tgt",
+                "1_set_src_var_w_pair_set_rel_tgt",
+                "1_set_src_this",
+                "1_set_src_this_w_pair",
+                "1_set_src_this_w_pair_set_rel",
+                "1_set_src_this_w_pair_set_tgt",
+                "1_set_src_this_w_pair_set_rel_tgt",
+                "1_set_src_this_to_empty_table",
+                "1_set_src_this_to_empty_table_w_component",
+                "1_set_src_this_to_empty_table_w_component_self",
+                "1_set_src_this_to_entiy_in_table",
+                "1_set_src_this_to_entiy_in_table_self",
+                "2_set_src_this",
+                "2_set_src_this_self",
+                "2_set_src_this_component",
+                "2_set_src_this_self_component",
+                "2_set_src_this_w_up",
+                "2_set_src_this_self_w_up",
+                "2_set_src_this_component_w_up",
+                "2_set_src_this_self_component_w_up",
+                "2_set_src_this_w_exclusive_wildcard",
+                "2_set_src_this_self_w_exclusive_wildcard",
+                "2_set_src_this_self_w_exclusive_wildcard_w_up",
+                "1_set_src_this_is_true",
+                "3_set_src_this_w_uncacheable_tag_tag_tag",
+                "3_set_src_this_w_uncacheable_tag_component_tag",
+                "3_set_src_this_w_uncacheable_tag_component_component",
+                "3_set_src_this_w_tag_uncacheable_tag_tag",
+                "3_set_src_this_w_component_uncacheable_tag_tag",
+                "3_set_src_this_w_component_uncacheable_tag_component",
+                "3_set_src_this_w_tag_tag_uncacheable_tag",
+                "3_set_src_this_w_component_tag_uncacheable_tag",
+                "3_set_src_this_w_component_component_uncacheable_tag",
+                "3_set_src_this_w_uncacheable_component_tag_tag",
+                "3_set_src_this_w_uncacheable_component_component_tag",
+                "3_set_src_this_w_uncacheable_component_component_component",
+                "3_set_src_this_w_tag_uncacheable_component_tag",
+                "3_set_src_this_w_component_uncacheable_component_tag",
+                "3_set_src_this_w_component_uncacheable_component_component",
+                "3_set_src_this_w_tag_tag_uncacheable_component",
+                "3_set_src_this_w_component_tag_uncacheable_component",
+                "3_set_src_this_w_component_component_uncacheable_component",
+                "2_set_src_this_w_wildcard",
+                "1_src_this_var_as_entity",
+                "1_src_this_var_as_table",
+                "1_src_this_var_as_table_range",
+                "2_join_by_rel_var",
+                "2_join_by_pair_rel_var",
+                "2_join_by_pair_tgt_var",
+                "2_cycle_w_var",
+                "2_cycle_w_this_var",
+                "2_cycle_w_var_this",
+                "2_cycle_pair_w_var",
+                "2_cycle_pair_w_this_var_var",
+                "2_cycle_pair_w_var_this_var",
+                "2_cycle_pair_w_var_var_this",
+                "2_cycle_pair_ent_var_var",
+                "2_cycle_pair_ent_this_var",
+                "2_cycle_pair_ent_var_this",
+                "parse_0_var",
+                "parse_1_var",
+                "parse_2_vars",
+                "parse_0_var_paren",
+                "parse_1_var_paren",
+                "parse_2_vars_paren",
+                "parse_1_vars_w_path",
+                "parse_missing_close_paren",
+                "parse_missing_open_paren",
+                "parse_missing_value",
+                "parse_0_var_w_spaces",
+                "parse_1_var_w_spaces",
+                "parse_2_vars_w_spaces",
+                "parse_0_var_paren_w_spaces",
+                "parse_1_var_paren_w_spaces",
+                "parse_2_vars_paren_w_spaces",
+                "var_count",
+                "var_name",
+                "var_is_entity",
+                "no_this_anonymous_src",
+                "no_this_anonymous_src_w_pair",
+                "no_this_anonymous_component_src",
+                "no_this_anonymous_component_src_w_pair",
+                "lookup_from_table_this",
+                "lookup_from_entity_this",
+                "lookup_from_table",
+                "lookup_from_entity",
+                "lookup_from_not_written",
+                "lookup_from_table_this_component",
+                "lookup_from_entity_this_component",
+                "lookup_from_table_component",
+                "lookup_from_entity_component",
+                "lookup_from_table_two_children",
+                "lookup_from_entity_two_children",
+                "lookup_from_table_same_child_twice",
+                "lookup_from_entity_same_child_twice",
+                "lookup_from_table_not",
+                "lookup_from_entity_not",
+                "lookup_from_table_w_any_component",
+                "lookup_from_entity_w_any_component",
+                "lookup_as_tag",
+                "lookup_as_relationship",
+                "lookup_as_target",
+                "lookup_assign_var",
+                "lookup_eq_var",
+                "lookup_neq_var",
+                "lookup_unresolved_dependent",
+                "check_vars_this",
+                "check_vars_var",
+                "check_vars_wildcard",
+                "check_vars_any",
+                "check_vars_var_as_tgt",
+                "check_vars_this_as_tgt",
+                "check_vars_anonymous_var_as_tgt",
+                "check_vars_wildcard_as_tgt",
+                "check_vars_any_as_tgt",
+                "check_vars_this_w_lookup_var",
+                "check_vars_var_w_lookup_var",
+                "1_trivial_1_var",
+                "2_trivial_1_var",
+                "1_trivial_1_var_component",
+                "2_trivial_1_var_component",
+                "1_trivial_1_wildcard",
+                "2_trivial_1_wildcard",
+                "1_trivial_1_wildcard_component",
+                "2_trivial_1_wildcard_component",
+                "1_trivial_1_any",
+                "2_trivial_1_any",
+                "1_trivial_1_any_component",
+                "2_trivial_1_any_component",
+                "first_invalid_var_name_and_id",
+                "src_invalid_var_name_and_id",
+                "second_invalid_var_name_and_id"
+            ]
+        }, {
+            "id": "Operators",
+            "setup": true,
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "testcases": [
+                "2_and_not",
+                "2_and_not_component",
+                "2_and_out_not",
+                "2_and_out_not_component",
+                "3_and_not_not",
+                "2_and_not_pair_rel_wildcard",
+                "2_and_not_pair_tgt_wildcard",
+                "2_and_not_pair_rel_tgt_wildcard",
+                "2_and_not_pair_rel_var",
+                "2_and_not_pair_tgt_var",
+                "2_and_not_pair_rel_tgt_var",
+                "2_and_not_pair_rel_tgt_same_var",
+                "2_and_not_pair_rel_var_written",
+                "2_and_not_pair_tgt_var_written",
+                "2_and_not_pair_rel_tgt_var_written",
+                "2_and_not_pair_rel_tgt_same_var_written",
+                "2_and_not_pair_rel_src_tgt_same_var_written",
+                "2_and_not_pair_any_rel",
+                "2_and_not_pair_any_tgt",
+                "2_and_not_pair_any_src",
+                "1_not_any_src_fixed_first",
+                "1_not_any_src_any_tgt_fixed_first",
+                "1_not_any_src_any_first_fixed_tgt",
+                "1_not_any_src_any_childof_pair_any_tgt",
+                "1_not_any_src_any_isa_pair_any_tgt",
+                "2_and_optional",
+                "3_and_optional_optional",
+                "2_and_optional_pair_rel_wildcard",
+                "2_and_optional_pair_tgt_wildcard",
+                "2_and_optional_pair_rel_var",
+                "2_and_optional_pair_tgt_var",
+                "2_and_optional_pair_rel_tgt_var",
+                "2_and_optional_pair_rel_tgt_same_var",
+                "2_and_optional_pair_rel_var_written",
+                "2_and_optional_pair_tgt_var_written",
+                "2_and_optional_pair_rel_tgt_var_written",
+                "2_and_optional_pair_rel_tgt_same_var_written",
+                "2_and_optional_pair_rel_src_tgt_same_var_written",
+                "3_and_optional_optional_pair_w_var",
+                "2_and_optional_pair_any_rel",
+                "2_and_optional_pair_any_tgt",
+                "2_and_optional_pair_any_src",
+                "3_and_optional_dependent_and_pair_rel",
+                "3_and_optional_dependent_and_pair_tgt",
+                "3_and_optional_dependent_and_pair_rel_tgt",
+                "3_and_optional_dependent_and_pair_rel_tgt_same_var",
+                "3_and_optional_dependent_and_pair_rel_tgt_same_other_var",
+                "3_and_optional_dependent_and_pair_src",
+                "3_and_optional_dependent_optional_pair_rel",
+                "3_and_optional_dependent_optional_pair_tgt",
+                "3_and_optional_dependent_optional_pair_src",
+                "3_and_optional_dependent_not_pair_rel",
+                "3_and_optional_dependent_not_pair_tgt",
+                "3_and_optional_dependent_not_pair_src",
+                "1_optional_any_src_fixed_first",
+                "1_optional_any_src_any_tgt_fixed_first",
+                "1_optional_any_src_any_first_fixed_tgt",
+                "1_optional_any_src_any_childof_pair_any_tgt",
+                "1_optional_any_src_any_isa_pair_any_tgt",
+                "2_or",
+                "3_or",
+                "2_or_w_and",
+                "3_or_w_and",
+                "2_or_written",
+                "3_or_written",
+                "2_or_written_w_rel_var",
+                "3_or_written_w_rel_var",
+                "2_or_written_w_tgt_var",
+                "2_or_written_w_rel_tgt_var",
+                "2_or_written_w_rel_tgt_same_var",
+                "3_or_written_w_tgt_var",
+                "2_or_chains",
+                "2_or_chains_written",
+                "2_or_dependent",
+                "2_or_dependent_reverse",
+                "2_or_dependent_2_vars",
+                "2_or_written_dependent",
+                "2_or_written_dependent_2_vars",
+                "2_or_w_dependent",
+                "2_or_w_both",
+                "3_or_w_both",
+                "2_or_w_not",
+                "2_or_w_not_component",
+                "2_or_w_not_out_component",
+                "2_or_w_not_out_all_components",
+                "2_not_first",
+                "2_optional_first",
+                "only_not",
+                "only_not_component",
+                "only_not_out_component",
+                "only_optional",
+                "only_optional_component",
+                "not_after_fixed_src",
+                "optional_after_fixed_src",
+                "root_entities_empty",
+                "root_entities",
+                "root_entities_w_children",
+                "root_entities_w_optional_children",
+                "core_entities_w_optional_children",
+                "root_entities_w_not_children",
+                "core_entities_w_not_children",
+                "1_ent_src_not",
+                "1_ent_src_not_pair",
+                "1_ent_src_not_pair_rel_wildcard",
+                "1_ent_src_not_pair_tgt_wildcard",
+                "1_ent_src_not_pair_rel_tgt_wildcard",
+                "1_ent_src_not_pair_rel_any",
+                "1_ent_src_not_pair_tgt_any",
+                "1_ent_src_not_pair_rel_tgt_any",
+                "1_ent_src_not_pair_rel_var",
+                "1_ent_src_not_pair_tgt_var",
+                "1_ent_src_not_pair_rel_tgt_var",
+                "1_ent_src_not_pair_rel_tgt_same_var",
+                "1_this_src_not_pair_rel_var",
+                "1_this_src_not_pair_tgt_var",
+                "1_this_src_not_pair_rel_tgt_var",
+                "1_this_src_not_pair_rel_tgt_same_var",
+                "1_ent_src_not_pair_rel_var_written",
+                "1_ent_src_not_pair_tgt_var_written",
+                "1_ent_src_not_pair_rel_tgt_var_written",
+                "1_ent_src_not_pair_rel_tgt_same_var_written",
+                "and_from_fixed_src",
+                "not_from_fixed_src",
+                "or_from_fixed_src",
+                "and_from_this",
+                "not_from_this",
+                "or_from_this",
+                "and_from_this_written",
+                "not_from_this_written",
+                "or_from_this_written",
+                "and_from_empty",
+                "not_from_empty",
+                "or_from_empty",
+                "and_from_empty_w_tag",
+                "not_from_empty_w_tag",
+                "or_from_empty_w_tag",
+                "or_w_wildcard",
+                "or_w_component_and_tag",
+                "or_w_tag_and_component"
+            ]
+        }, {
+            "id": "Transitive",
+            "testcases": [
+                "1_fact_0_lvl_true",
+                "1_fact_1_lvl_true",
+                "1_fact_2_lvl_true",
+                "1_fact_0_lvl_false",
+                "1_fact_1_lvl_false",
+                "1_fact_2_lvl_false",
+                "1_fact_reflexive",
+                "1_isa",
+                "1_childof",
+                "1_this_src_written_0_lvl",
+                "1_this_src_written_1_lvl",
+                "1_this_src_written_2_lvl",
+                "1_this_src_written_reflexive",
+                "1_this_src_0_lvl",
+                "1_this_src_1_lvl",
+                "1_this_src_2_lvl",
+                "1_this_src_reflexive",
+                "1_ent_src_tgt_var_0_lvl",
+                "1_ent_src_tgt_var_1_lvl",
+                "1_ent_src_tgt_var_2_lvl",
+                "1_ent_src_tgt_var_reflexive",
+                "1_this_src_tgt_var",
+                "1_this_src_tgt_var_reflexive",
+                "1_var_src_written_0_lvl",
+                "1_var_src_written_1_lvl",
+                "1_var_src_written_2_lvl",
+                "1_var_src_written_reflexive",
+                "1_var_src_0_lvl",
+                "1_var_src_1_lvl",
+                "1_var_src_2_lvl",
+                "1_var_src_reflexive",
+                "1_var_src_tgt_var",
+                "1_var_src_tgt_var_reflexive",
+                "1_ent_src_tgt_this_0_lvl",
+                "1_ent_src_tgt_this_1_lvl",
+                "1_ent_src_tgt_this_2_lvl",
+                "1_ent_src_tgt_this_reflexive",
+                "1_var_src_tgt_this",
+                "1_var_src_tgt_this_reflexive",
+                "2_ent_src_constrain_tgt_var_before_0_lvl",
+                "2_ent_src_constrain_tgt_var_before_1_lvl",
+                "2_ent_src_constrain_tgt_var_before_2_lvl",
+                "2_ent_src_constrain_tgt_var_after_0_lvl",
+                "2_ent_src_constrain_tgt_var_after_1_lvl",
+                "2_ent_src_constrain_tgt_var_after_2_lvl",
+                "2_this_src_constrain_tgt_var_before_0_lvl",
+                "2_this_src_constrain_tgt_var_before_1_lvl",
+                "2_this_src_constrain_tgt_var_before_2_lvl",
+                "2_this_src_constrain_tgt_var_after_0_lvl",
+                "2_this_src_constrain_tgt_var_after_1_lvl",
+                "2_this_src_constrain_tgt_var_after_2_lvl",
+                "1_src_tgt_same_var",
+                "1_src_tgt_same_var_reflexive",
+                "1_src_tgt_same_this_var_reflexive",
+                "1_any_src_tgt_var",
+                "not_transitive_ent_tgt",
+                "not_transitive_var_tgt",
+                "not_transitive_ent_tgt_written",
+                "not_transitive_var_tgt_written",
+                "optional_transitive_ent_tgt",
+                "optional_transitive_var_tgt",
+                "optional_transitive_ent_tgt_written",
+                "optional_transitive_var_tgt_written",
+                "2_var_src_w_same_tgt_ent",
+                "self_target",
+                "any_target",
+                "isa_prefab",
+                "isa_disabled",
+                "isa_prefab_match_prefab_flag",
+                "isa_prefab_match_prefab_term",
+                "isa_disabled_match_disabled_flag",
+                "isa_disabled_match_disabled_term"
+            ]
+        }, {
+            "id": "ComponentInheritance",
+            "testcases": [
+                "1_ent_0_lvl",
+                "1_ent_1_lvl",
+                "1_ent_2_lvl",
+                "1_ent_3_lvl",
+                "1_this_0_lvl",
+                "1_this_1_lvl",
+                "1_this_2_lvl",
+                "1_this_3_lvl",
+                "1_this_0_lvl_written",
+                "1_this_1_lvl_written",
+                "1_this_2_lvl_written",
+                "1_this_3_lvl_written",
+                "1_var_0_lvl",
+                "1_var_1_lvl",
+                "1_var_2_lvl",
+                "1_var_3_lvl",
+                "1_var_0_lvl_written",
+                "1_var_1_lvl_written",
+                "1_var_2_lvl_written",
+                "1_var_3_lvl_written",
+                "1_ent_1_lvl_self",
+                "1_this_1_lvl_self",
+                "1_this_1_lvl_written_self",
+                "1_var_1_lvl_self",
+                "1_var_1_lvl_written_self",
+                "1_ent_src_not",
+                "1_this_src_not",
+                "1_var_src_not",
+                "1_this_src_not_written",
+                "1_var_src_not_written",
+                "first_self"
+            ]
+        }, {
+            "id": "Recycled",
+            "setup": true,
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "testcases": [
+                "recycled_vars",
+                "recycled_pair_vars",
+                "recycled_this_ent_var",
+                "has_recycled_id_from_pair",
+                "recycled_pair",
+                "recycled_component_id"
+            ]
+        }, {
+            "id": "BuiltinPredicates",
+            "setup": true,
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "testcases": [
+                "this_eq_id",
+                "this_eq_name",
+                "this_eq_var",
+                "this_eq_id_written",
+                "this_eq_id_written_no_match",
+                "this_eq_name_written",
+                "this_eq_name_written_no_match",
+                "this_eq_var_written",
+                "var_eq_id",
+                "var_eq_name",
+                "var_eq_var",
+                "var_eq_id_written",
+                "var_eq_id_written_no_match",
+                "var_eq_name_written",
+                "var_eq_name_written_no_match",
+                "var_eq_var_written",
+                "var_eq_this",
+                "this_neq_id",
+                "this_neq_name",
+                "this_neq_var",
+                "this_neq_id_written",
+                "this_neq_id_written_no_match",
+                "this_neq_name_written",
+                "this_neq_name_written_no_match",
+                "this_neq_var_written",
+                "var_neq_id",
+                "var_neq_name",
+                "var_neq_var",
+                "var_neq_id_written",
+                "var_neq_id_written_no_match",
+                "var_neq_name_written",
+                "var_neq_name_written_no_match",
+                "var_neq_var_written",
+                "var_neq_this",
+                "this_2_neq_id",
+                "this_2_neq_name",
+                "var_2_neq_id",
+                "var_2_neq_name",
+                "this_2_neq_id_written",
+                "this_2_neq_name_written",
+                "var_2_neq_id_written",
+                "var_2_neq_name_written",
+                "this_2_or_id",
+                "this_3_or_id",
+                "this_2_or_name",
+                "this_3_or_name",
+                "this_2_or_match",
+                "this_3_or_match",
+                "var_2_or_id",
+                "var_2_or_name",
+                "this_2_or_id_written",
+                "this_3_or_id_written",
+                "this_2_or_name_written",
+                "var_2_or_id_written",
+                "var_2_or_name_written",
+                "this_match_eq",
+                "var_match_eq",
+                "this_match_eq_written",
+                "this_match_eq_written_self",
+                "var_match_eq_written",
+                "this_match_neq",
+                "var_match_neq",
+                "this_match_neq_written",
+                "var_match_neq_written",
+                "this_match_2_neq",
+                "var_match_2_neq",
+                "this_match_2_neq_written",
+                "var_match_2_neq_written",
+                "this_match_2_or",
+                "this_match_2_or_written",
+                "this_match_3_or",
+                "this_match_3_or_written",
+                "unresolved_by_name",
+                "var_eq_wildcard",
+                "var_eq_any",
+                "var_eq_wildcard_after_write",
+                "var_eq_any_after_write",
+                "var_eq_after_var_0_src",
+                "2_or_w_eq_this",
+                "2_or_w_eq_lookup_var",
+                "3_or_w_eq_lookup_var"
+            ]
+        }, {
+            "id": "Scopes",
+            "setup": true,
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "testcases": [
+                "term_w_not_scope_1_term",
+                "term_w_not_scope_2_terms",
+                "term_w_not_scope_1_term_w_not",
+                "term_w_not_scope_2_terms_w_not",
+                "term_w_not_scope_1_term_w_var",
+                "term_w_not_scope_2_terms_w_var",
+                "term_w_not_scope_1_term_w_not_w_var",
+                "term_w_not_scope_2_terms_w_not_w_var",
+                "term_w_not_scope_2_terms_w_or",
+                "term_w_not_scope_3_terms_w_or"
+            ]
+        }, {
+            "id": "Traversal",
+            "setup": true,
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "testcases": [
+                "this_self_up_childof",
+                "this_up_childof",
+                "this_written_self_up_childof",
+                "this_written_up_childof",
+                "var_self_up_childof",
+                "var_up_childof",
+                "var_written_self_up_childof",
+                "var_written_up_childof",
+                "set_var_self_up_childof",
+                "set_var_up_childof",
+                "set_var_written_self_up_childof",
+                "set_var_written_up_childof",
+                "ent_self_up_childof",
+                "ent_up_childof",
+                "implicit_this_self_up_isa",
+                "implicit_this_up_isa",
+                "implicit_var_self_up_isa",
+                "implicit_var_up_isa",
+                "implicit_ent_self_up_isa",
+                "implicit_ent_up_isa",
+                "self_up_2_targets",
+                "up_2_targets",
+                "self_up_2_targets_diamond",
+                "up_2_targets_diamond",
+                "written_self_up_2_targets",
+                "written_up_2_targets",
+                "written_self_up_2_targets_diamond",
+                "written_up_2_targets_diamond",
+                "2_self_up_terms",
+                "2_self_up_terms_2_targets",
+                "self_up_empty_table",
+                "up_empty_table",
+                "self_up_all_owned",
+                "up_all_owned",
+                "this_self_up_childof_inherited",
+                "this_up_childof_inherited",
+                "this_written_self_up_childof_inherited",
+                "this_written_up_childof_inherited",
+                "var_self_up_childof_inherited",
+                "var_up_childof_inherited",
+                "var_written_self_up_childof_inherited",
+                "var_written_up_childof_inherited",
+                "ent_self_up_childof_inherited",
+                "ent_up_childof_inherited",
+                "ent_written_self_up_childof_inherited",
+                "ent_written_up_childof_inherited",
+                "this_self_up_childof_component",
+                "this_up_childof_component",
+                "this_written_self_up_childof_component",
+                "this_written_up_childof_component",
+                "var_self_up_childof_component",
+                "var_up_childof_component",
+                "var_written_self_up_childof_component",
+                "var_written_up_childof_component",
+                "this_self_up_childof_recycled_parent",
+                "this_up_childof_recycled_parent",
+                "this_written_self_up_childof_recycled_parent",
+                "this_written_up_childof_recycled_parent",
+                "this_self_up_childof_recycled_parent_component",
+                "this_up_childof_recycled_parent_component",
+                "this_written_self_up_childof_recycled_parent_component",
+                "this_written_up_childof_recycled_parent_component",
+                "this_self_up_childof_pair",
+                "this_up_childof_pair",
+                "this_written_self_up_childof_pair",
+                "this_written_up_childof_pair",
+                "this_self_up_childof_pair_wildcard",
+                "this_up_childof_pair_wildcard",
+                "this_written_self_up_childof_pair_wildcard",
+                "this_written_up_childof_pair_wildcard",
+                "this_self_up_childof_pair_tgt_var",
+                "this_written_self_up_childof_pair_tgt_var",
+                "this_self_up_childof_pair_rel_var",
+                "this_written_self_up_childof_pair_rel_var",
+                "this_self_up_childof_pair_for_var_written",
+                "this_up_childof_pair_for_var_written",
+                "this_written_self_up_childof_pair_for_var_written",
+                "this_self_up_childof_pair_for_var_written_n_targets",
+                "this_written_self_up_childof_pair_for_var_written_n_targets",
+                "self_up_2_levels",
+                "not_up_disabled",
+                "up_2_rel_instances",
+                "up_2_rel_instances_match_2nd",
+                "up_only_w_owned",
+                "this_up_trav_unused_rel",
+                "this_optional_self",
+                "this_optional_up",
+                "this_optional_self_up",
+                "this_written_optional_self",
+                "this_written_optional_up",
+                "this_written_optional_self_up",
+                "fixed_src_w_up",
+                "match_empty_table_up",
+                "match_empty_table_up_written",
+                "match_empty_table_up_implicit_isa",
+                "match_empty_table_up_written_implicit_isa",
+                "match_empty_table_up_isa",
+                "match_empty_table_up_written_isa"
+            ]
+        }, {
+            "id": "Cascade",
+            "testcases": [
+                "this_self_cascade_childof_uncached",
+                "this_cascade_childof_uncached",
+                "this_written_self_cascade_childof_uncached",
+                "this_written_cascade_childof_uncached",
+                "this_self_cascade_childof_w_parent_flag_uncached",
+                "this_cascade_childof_w_parent_flag_uncached",
+                "this_written_self_cascade_childof_w_parent_flag_uncached",
+                "this_written_cascade_childof_w_parent_flag_uncached",
+                "parent_cascade",
+                "existing_custom_rel_cascade",
+                "new_custom_rel_cascade",
+                "cascade_w_2_depths",
+                "cascade_w_3_depths",
+                "cascade_w_2_depths_desc",
+                "cascade_w_3_depths_desc",
+                "existing_isa_cascade",
+                "new_isa_cascade",
+                "childof_cascade",
+                "cascade_rematch_2_lvls",
+                "cascade_rematch_2_lvls_2_relations",
+                "cascade_topological",
+                "cascade_desc_rematch_2_lvls",
+                "cascade_desc_rematch_2_lvls_2_relations",
+                "cascade_desc_topological",
+                "cascade_after_recycled_parent_change"
+            ]
+        }, {
+            "id": "Cached",
+            "testcases": [
+                "simple_query_existing_table",
+                "simple_query_2_existing_tables",
+                "simple_query_new_table",
+                "simple_query_2_new_tables",
+                "simple_query_existing_and_new_table",
+                "wildcard_query_existing_table",
+                "wildcard_query_new_table",
+                "wildcard_query_existing_table_2_results_p_table",
+                "wildcard_query_new_table_2_results_p_table",
+                "wildcard_query_2nd_term",
+                "wildcard_query_2nd_term_self",
+                "simple_query_existing_empty_table",
+                "simple_query_existing_empty_type",
+                "simple_query_new_empty_table",
+                "component_query_existing_table",
+                "component_query_new_table",
+                "component_query_existing_empty_table",
+                "2_component_query_existing_empty_table",
+                "2_component_query_existing_empty_type",
+                "only_optional",
+                "only_optional_new_empty_table",
+                "only_optional_new_empty_non_empty_table",
+                "only_optional_new_unset_tables",
+                "singleton_w_optional_new_empty_table",
+                "singleton_w_optional_new_empty_non_empty_table",
+                "singleton_w_optional_new_unset_tables",
+                "query_w_from_entity_match_after",
+                "query_w_from_singleton_match_after",
+                "query_rematch_optional_after_add",
+                "get_owned_tag",
+                "get_shared_tag",
+                "explicit_delete",
+                "get_column_size",
+                "stresstest_query_free",
+                "query_optional_tag",
+                "query_optional_shared_tag",
+                "query_iter_10_tags",
+                "query_iter_10_components",
+                "iter_type_set",
+                "filter_term",
+                "2_terms_1_filter",
+                "3_terms_2_filter",
+                "no_instancing_w_singleton",
+                "add_singleton_after_query",
+                "query_w_component_from_parent_from_non_this",
+                "create_query_while_pending",
+                "empty_query",
+                "not_pair_relation_wildcard",
+                "not_pair_object_wildcard",
+                "two_pair_wildcards_one_not",
+                "two_pair_wildcards_one_not_any",
+                "implicit_existing_isa_superset",
+                "implicit_new_isa_superset",
+                "isa_superset",
+                "isa_superset_2_lvls",
+                "isa_superset_3_lvls",
+                "isa_superset_2_lvls_owned",
+                "isa_superset_3_lvls_owned",
+                "isa_superset_owned_empty_table_after_match",
+                "isa_self_superset",
+                "childof_superset",
+                "superset_2_targets",
+                "superset_2_relations",
+                "superset_2_relations_instanced",
+                "superset_2_relations_w_component",
+                "superset_2_relations_instanced_w_component",
+                "parent",
+                "isa_rematch",
+                "childof_rematch",
+                "isa_unmatch",
+                "childof_unmatch",
+                "isa_rematch_2_lvls",
+                "childof_rematch_2_lvls",
+                "childof_rematch_from_isa",
+                "rematch_optional_ref",
+                "rematch_optional_ref_w_2_refs",
+                "rematch_optional_ref_tag_w_ref_component",
+                "rematch_after_add_to_recycled_parent",
+                "match_query_expr_from_scope",
+                "query_long_or_w_ref",
+                "query_w_pair_id_and_subj",
+                "rematch_after_delete_inherited_tag",
+                "rematch_after_delete_rel_of_inherited_pair",
+                "rematch_after_delete_obj_of_inherited_pair",
+                "rematch_empty_table_w_superset",
+                "2_self_up_terms_new_tables",
+                "this_self_up_childof_pair_new_tables"
+            ]
+        }, {
+            "id": "ChangeDetection",
+            "testcases": [
+                "query_changed_after_new",
+                "query_changed_after_delete",
+                "query_changed_after_add",
+                "query_changed_after_remove",
+                "query_changed_after_set",
+                "query_change_after_modified",
+                "query_change_after_out_system",
+                "query_change_after_in_system",
+                "query_change_after_modified_out_term",
+                "query_change_check_iter",
+                "query_change_check_iter_after_skip_read",
+                "query_change_check_iter_after_skip_write",
+                "query_change_parent_term",
+                "query_change_prefab_term",
+                "query_change_parent_term_w_tag",
+                "query_change_prefab_term_w_tag",
+                "query_change_skip_non_instanced",
+                "query_changed_w_or",
+                "query_changed_or",
+                "query_changed_w_singleton",
+                "query_changed_w_only_singleton",
+                "query_changed_w_only_singleton_after_set",
+                "query_changed_w_only_singleton_after_out_term",
+                "query_changed_w_only_singleton_after_singleton_out_term",
+                "query_changed_w_only_parent",
+                "query_changed_w_only_parent_after_set",
+                "query_changed_w_only_parent_after_out_term",
+                "query_changed_w_only_parent_after_parent_out_term",
+                "query_changed_tag",
+                "query_changed_no_source",
+                "query_changed_no_source_component",
+                "query_changed_w_not_out"
+            ]
+        }, {
+            "id": "GroupBy",
+            "testcases": [
+                "group_by",
+                "group_by_w_ctx",
+                "group_by_w_sort_reverse_group_creation",
+                "group_by_iter_one",
+                "group_by_iter_one_all_groups",
+                "group_by_iter_one_empty",
+                "group_by_iter_one_empty_query",
+                "group_by_iter_one_empty_table",
+                "group_by_w_deleted_group_id",
+                "group_by_callbacks",
+                "group_by_default_action",
+                "group_table_count"
+            ]
+        }, {
+            "id": "MemberTarget",
+            "setup": true,
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "testcases": [
+                "this_member_eq_1",
+                "this_member_eq_2",
+                "this_member_eq_no_matches",
+                "this_member_eq_all_matches",
+                "this_member_wildcard",
+                "this_member_var",
+                "this_member_var_written",
+                "this_member_var_read",
+                "this_member_eq_1_2nd_member",
+                "this_member_eq_2_2nd_member",
+                "this_member_var_same_1",
+                "this_member_var_same_2",
+                "this_written_member_eq_1",
+                "this_written_member_eq_2",
+                "this_written_member_wildcard",
+                "this_written_member_var",
+                "this_member_neq_1",
+                "this_member_neq_2",
+                "this_member_neq_no_matches",
+                "this_member_neq_all_matches",
+                "this_member_neq_wildcard",
+                "this_written_member_neq_1",
+                "this_written_member_neq_2",
+                "this_written_member_neq_no_matches",
+                "this_written_member_neq_all_matches",
+                "this_written_member_neq_wildcard",
+                "this_member_eq_optional",
+                "this_member_eq_optional_wildcard",
+                "this_written_member_eq_optional",
+                "this_written_member_eq_optional_wildcard",
+                "this_member_eq_w_other_tag",
+                "this_member_eq_w_other_component",
+                "this_written_member_eq_w_other_tag",
+                "this_written_member_eq_w_other_component",
+                "this_2_or",
+                "this_3_or",
+                "this_written_2_or",
+                "this_written_3_or",
+                "var_2_or",
+                "var_3_or",
+                "this_2_or_w_2_members",
+                "this_2_or_w_2_types",
+                "this_written_2_or_w_2_members",
+                "this_written_2_or_w_2_types",
+                "this_2_or_2_types_wildcard",
+                "this_2_or_2_types_dep_var",
+                "var_written_2_or",
+                "var_written_3_or",
+                "var_member_eq",
+                "var_member_eq_no_matches",
+                "var_member_eq_all_matches",
+                "var_member_wildcard",
+                "var_member_neq",
+                "var_member_neq_no_matches",
+                "var_member_neq_all_matches",
+                "var_written_member_eq",
+                "var_written_member_eq_no_matches",
+                "var_written_member_eq_all_matches",
+                "var_written_member_wildcard",
+                "var_written_member_neq",
+                "var_written_member_neq_no_matches",
+                "var_written_member_neq_all_matches"
+            ]
+        }, {
+            "id": "Toggle",
+            "setup": true,
+            "params": {
+                "cache_kind": ["default", "auto"]
+            },
+            "testcases": [
+                "fixed_src_1_tag_toggle",
+                "fixed_src_1_component_toggle",
+                "fixed_src_2_tag_toggle",
+                "fixed_src_2_component_toggle",
+                "fixed_2_src_w_toggle",
+                "this_w_fixed_src_w_toggle",
+                "fixed_src_w_this_w_toggle",
+                "this_from_nothing",
+                "this",
+                "this_skip_initial",
+                "this_pair",
+                "this_pair_skip_initial",
+                "this_tag",
+                "this_tag_pair",
+                "this_tag_pair_wildcard",
+                "this_toggle_shared_self_up",
+                "this_toggle_shared_up",
+                "this_toggle_shared_self_up_w_self",
+                "this_toggle_shared_up_w_self",
+                "this_toggle_shared_self_up_w_self_reverse",
+                "this_toggle_shared_up_w_self_reverse",
+                "this_toggle_shared_self_up_w_self_toggle",
+                "this_toggle_shared_up_w_self_toggle",
+                "this_toggle_shared_self_up_w_self_toggle_reverse",
+                "this_toggle_shared_up_w_self_toggle_reverse",
+                "this_toggle_not_shared_self_up",
+                "this_toggle_not_shared_up",
+                "this_toggle_optional_shared_self_up",
+                "this_toggle_optional_shared_up",
+                "this_64_mod_1",
+                "this_64_mod_2",
+                "this_64_mod_3",
+                "this_64_mod_7",
+                "this_64_mod_8",
+                "this_64_mod_10",
+                "this_64_mod_64",
+                "this_64_mod_256",
+                "this_64_mod_1024",
+                "this_100_mod_1",
+                "this_100_mod_2",
+                "this_100_mod_3",
+                "this_100_mod_7",
+                "this_100_mod_8",
+                "this_100_mod_10",
+                "this_100_mod_64",
+                "this_100_mod_256",
+                "this_100_mod_1024",
+                "this_128_mod_1",
+                "this_128_mod_2",
+                "this_128_mod_3",
+                "this_128_mod_7",
+                "this_128_mod_8",
+                "this_128_mod_10",
+                "this_128_mod_64",
+                "this_128_mod_256",
+                "this_128_mod_1024",
+                "this_200_mod_1",
+                "this_200_mod_2",
+                "this_200_mod_3",
+                "this_200_mod_7",
+                "this_200_mod_8",
+                "this_200_mod_10",
+                "this_200_mod_64",
+                "this_200_mod_256",
+                "this_200_mod_1024",
+                "this_1024_mod_1",
+                "this_1024_mod_2",
+                "this_1024_mod_3",
+                "this_1024_mod_7",
+                "this_1024_mod_8",
+                "this_1024_mod_10",
+                "this_1024_mod_64",
+                "this_1024_mod_256",
+                "this_1024_mod_1024",
+                "this_enabled_64_mod_1",
+                "this_enabled_64_mod_2",
+                "this_enabled_64_mod_3",
+                "this_enabled_64_mod_7",
+                "this_enabled_64_mod_8",
+                "this_enabled_64_mod_10",
+                "this_enabled_64_mod_64",
+                "this_enabled_64_mod_256",
+                "this_enabled_64_mod_1024",
+                "this_enabled_100_mod_1",
+                "this_enabled_100_mod_2",
+                "this_enabled_100_mod_3",
+                "this_enabled_100_mod_7",
+                "this_enabled_100_mod_8",
+                "this_enabled_100_mod_10",
+                "this_enabled_100_mod_64",
+                "this_enabled_100_mod_256",
+                "this_enabled_100_mod_1024",
+                "this_enabled_128_mod_1",
+                "this_enabled_128_mod_2",
+                "this_enabled_128_mod_3",
+                "this_enabled_128_mod_7",
+                "this_enabled_128_mod_8",
+                "this_enabled_128_mod_10",
+                "this_enabled_128_mod_64",
+                "this_enabled_128_mod_256",
+                "this_enabled_128_mod_1024",
+                "this_enabled_200_mod_1",
+                "this_enabled_200_mod_2",
+                "this_enabled_200_mod_3",
+                "this_enabled_200_mod_7",
+                "this_enabled_200_mod_8",
+                "this_enabled_200_mod_10",
+                "this_enabled_200_mod_64",
+                "this_enabled_200_mod_256",
+                "this_enabled_200_mod_1024",
+                "this_enabled_1024_mod_1",
+                "this_enabled_1024_mod_2",
+                "this_enabled_1024_mod_3",
+                "this_enabled_1024_mod_7",
+                "this_enabled_1024_mod_8",
+                "this_enabled_1024_mod_10",
+                "this_enabled_1024_mod_64",
+                "this_enabled_1024_mod_256",
+                "this_enabled_1024_mod_1024",
+                "this_mod_2_2_bitsets",
+                "this_mod_8_2_bitsets",
+                "this_mod_64_2_bitsets",
+                "this_mod_256_2_bitsets",
+                "this_mod_1024_2_bitsets",
+                "this_randomized_2_bitsets",
+                "this_randomized_3_bitsets",
+                "this_randomized_4_bitsets",
+                "this_w_other_tag",
+                "this_w_other_component",
+                "this_not",
+                "this_written_not_1024_mod_2",
+                "this_written_not_1024_mod_3",
+                "this_written_not_1024_mod_7",
+                "this_written_not_1024_mod_8",
+                "this_written_not_1024_mod_10",
+                "this_written_not_1024_mod_64",
+                "this_written_not_1024_mod_256",
+                "this_written_not_1024_mod_1024",
+                "this_optional",
+                "this_written_optional_1024_mod_2",
+                "this_written_optional_1024_mod_3",
+                "this_written_optional_1024_mod_7",
+                "this_written_optional_1024_mod_8",
+                "this_written_optional_1024_mod_10",
+                "this_written_optional_1024_mod_64",
+                "this_written_optional_1024_mod_256",
+                "this_written_optional_1024_mod_1024",
+                "this_written_toggle_w_not_toggle",
+                "this_written_not_toggle_w_toggle",
+                "this_written_toggle_w_optional_toggle",
+                "this_written_optional_toggle_w_toggle",
+                "this_written_not_w_optional_toggle",
+                "this_written_optional_w_not_toggle",
+                "this_written_2_not_toggle",
+                "this_written_2_optional_toggle",
+                "this_written_toggle_w_2_not_toggle",
+                "this_written_toggle_w_2_optional_toggle",
+                "this_written_2_toggle_w_not_toggle",
+                "this_written_2_toggle_w_optional_toggle",
+                "this_sort",
+                "this_table_move_2_from_3"
+            ]
+        }, {
+            "id": "OrderBy",
+            "testcases": [
+                "sort_by_component",
+                "sort_by_component_2_tables",
+                "sort_by_component_3_tables",
+                "sort_by_entity",
+                "sort_after_add",
+                "sort_after_remove",
+                "sort_after_delete",
+                "sort_after_set",
+                "sort_after_system",
+                "sort_after_query",
+                "sort_by_component_same_value_1",
+                "sort_by_component_same_value_2",
+                "sort_by_component_move_pivot",
+                "sort_1000_entities",
+                "sort_1000_entities_w_duplicates",
+                "sort_1000_entities_again",
+                "sort_1000_entities_2_types",
+                "sort_1500_entities_3_types",
+                "sort_2000_entities_4_types",
+                "sort_2_entities_2_types",
+                "sort_3_entities_3_types",
+                "sort_3_entities_3_types_2",
+                "sort_4_entities_4_types",
+                "sort_1000_entities_2_types_again",
+                "sort_1000_entities_add_type_after_sort",
+                "sort_shared_component",
+                "sort_shared_component_childof",
+                "sort_w_tags_only",
+                "sort_childof_marked",
+                "sort_isa_marked",
+                "sort_relation_marked",
+                "dont_resort_after_set_unsorted_component",
+                "dont_resort_after_set_unsorted_component_w_tag",
+                "dont_resort_after_set_unsorted_component_w_tag_w_out_term",
+                "sort_component_not_queried_for",
+                "sort_by_wildcard",
+                "sort_shared_w_delete",
+                "sort_w_nontrivial_component",
+                "sort_by_wildcard",
+                "sort_not_term",
+                "sort_or_term",
+                "sort_optional_term"
+            ]
+        }, {
+            "id": "OrderByEntireTable",
+            "testcases": [
+                "sort_by_component",
+                "sort_by_component_2_tables",
+                "sort_by_component_3_tables",
+                "sort_by_entity",
+                "sort_after_add",
+                "sort_after_remove",
+                "sort_after_delete",
+                "sort_after_set",
+                "sort_after_system",
+                "sort_after_query",
+                "sort_by_component_same_value_1",
+                "sort_by_component_same_value_2",
+                "sort_by_component_move_pivot",
+                "sort_1000_entities",
+                "sort_1000_entities_w_duplicates",
+                "sort_1000_entities_again",
+                "sort_1000_entities_2_types",
+                "sort_1500_entities_3_types",
+                "sort_2000_entities_4_types",
+                "sort_2_entities_2_types",
+                "sort_3_entities_3_types",
+                "sort_3_entities_3_types_2",
+                "sort_4_entities_4_types",
+                "sort_1000_entities_2_types_again",
+                "sort_1000_entities_add_type_after_sort",
+                "sort_shared_component",
+                "sort_w_tags_only",
+                "sort_childof_marked",
+                "sort_isa_marked",
+                "sort_relation_marked",
+                "dont_resort_after_set_unsorted_component",
+                "dont_resort_after_set_unsorted_component_w_tag",
+                "dont_resort_after_set_unsorted_component_w_tag_w_out_term",
+                "sort_shared_w_delete",
+                "sort_not_term",
+                "sort_or_term",
+                "sort_optional_term"
+            ]
+        }, {
+            "id": "QueryStr",
+            "testcases": [
+                "one_term",
+                "one_term_w_inout",
+                "two_terms",
+                "two_terms_w_inout",
+                "three_terms_w_or",
+                "three_terms_w_or_inout",
+                "four_terms_three_w_or_inout",
+                "one_term_w_pair",
+                "one_term_w_pair_entity_src",
+                "one_term_w_self",
+                "one_term_w_up",
+                "one_term_w_0",
+                "one_term_w_singleton",
+                "one_term_w_final_pair",
+                "one_term_w_final_dont_inherit_pair",
+                "one_term_w_src_var",
+                "one_term_w_first_var",
+                "one_term_w_second_var",
+                "one_term_w_first_var_entity_src",
+                "one_term_w_pair_w_0_entity",
+                "not_term",
+                "wildcard_term",
+                "scopes",
+                "pred_eq",
+                "pred_neq",
+                "pred_eq_name",
+                "pred_neq_name",
+                "pred_eq_m",
+                "pred_neq_m"
+            ]
+        }]
+    }
+}
diff --git a/test/query/src/Basic.c b/test/query/src/Basic.c
new file mode 100644
index 000000000..f32505880
--- /dev/null
+++ b/test/query/src/Basic.c
@@ -0,0 +1,10211 @@
+#include <query.h>
+#include <stdio.h>
+
+static ecs_query_cache_kind_t cache_kind = EcsQueryCacheDefault;
+
+void Basic_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = EcsQueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+void Basic_0_query(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "0",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_1_fact_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_fact_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_fact_w_tag_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_fact_w_component_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set_pair(world, ent, Position, TgtA, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_same_src_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent), RelB(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_same_src_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(ent), Velocity(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Velocity, {1, 2});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_same_src_w_tag_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent, TgtA), RelA(ent, TgtB)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_same_src_w_component_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(ent, TgtA), Position(ent, TgtB)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set_pair(world, ent, Position, TgtA, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set_pair(world, ent, Position, TgtB, {30, 40});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_pair(ecs_id(Position), TgtB), ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_other_src_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent1 = ecs_entity(world, { .name = "ent1" });
+    ecs_entity_t ent2 = ecs_entity(world, { .name = "ent2" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent1), RelB(ent2)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent1, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent2, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(ent2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_other_src_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t ent1 = ecs_entity(world, { .name = "ent1" });
+    ecs_entity_t ent2 = ecs_entity(world, { .name = "ent2" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(ent1), Velocity(ent2)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent1, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent2, Velocity, {1, 2});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ent1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ent2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        const Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_other_src_w_tag_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent1 = ecs_entity(world, { .name = "ent1" });
+    ecs_entity_t ent2 = ecs_entity(world, { .name = "ent2" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent1, TgtA), RelA(ent2, TgtB)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent1, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent2, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(ent2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_other_src_w_component_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent1 = ecs_entity(world, { .name = "ent1" });
+    ecs_entity_t ent2 = ecs_entity(world, { .name = "ent2" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(ent1, TgtA), Position(ent2, TgtB)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set_pair(world, ent1, Position, TgtA, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set_pair(world, ent2, Position, TgtB, {30, 40});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 0));
+        test_uint(ent1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_pair(ecs_id(Position), TgtB), ecs_field_id(&it, 1));
+        test_uint(ent2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_fact_w_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelA);
+    ecs_add(world, ent, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(EcsWildcard, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_fact_w_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_fact_w_pair_any_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_fact_w_pair_any_rel_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelB, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(ent, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_same_src_w_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(ent), _(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelA);
+    ecs_add(world, ent, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(EcsWildcard, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_same_src_w_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent, _), RelA(ent, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_same_src_w_pair_any_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(ent, TgtA), _(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_same_src_w_pair_any_rel_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelB, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(ent, _), _(ent, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_other_src_w_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent1 = ecs_entity(world, { .name = "ent1" });
+    ecs_entity_t ent2 = ecs_entity(world, { .name = "ent2" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(ent1), _(ent2)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent1, RelA);
+    ecs_add(world, ent1, RelB);
+    ecs_add(world, ent2, RelA);
+    ecs_add(world, ent2, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(EcsWildcard, ecs_field_id(&it, 0));
+        test_uint(ent1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_id(&it, 1));
+        test_uint(ent2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_other_src_w_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent1 = ecs_entity(world, { .name = "ent1" });
+    ecs_entity_t ent2 = ecs_entity(world, { .name = "ent2" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent1, _), RelA(ent2, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent1, RelA, TgtA);
+    ecs_add_pair(world, ent1, RelA, TgtB);
+    ecs_add_pair(world, ent2, RelA, TgtA);
+    ecs_add_pair(world, ent2, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(ent1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ent2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_other_src_w_pair_any_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent1 = ecs_entity(world, { .name = "ent1" });
+    ecs_entity_t ent2 = ecs_entity(world, { .name = "ent2" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent1, _), RelA(ent2, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent1, RelA, TgtA);
+    ecs_add_pair(world, ent1, RelA, TgtB);
+    ecs_add_pair(world, ent2, RelA, TgtA);
+    ecs_add_pair(world, ent2, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(ent1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ent2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_facts_other_src_w_pair_any_rel_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent1 = ecs_entity(world, { .name = "ent1" });
+    ecs_add_pair(world, ent1, RelA, TgtA);
+    ecs_add_pair(world, ent1, RelB, TgtA);
+    ecs_entity_t ent2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add_pair(world, ent2, RelA, TgtA);
+    ecs_add_pair(world, ent2, RelB, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(ent1, _), _(ent2, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(ent1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ent2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_this_src_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e2, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_this_src_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e2, Position, {30, 40});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10); test_int(p[0].y, 20);
+        test_int(p[1].x, 30); test_int(p[1].y, 40);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_this_src_w_tag_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_this_src_w_component_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set_pair(world, e1, Position, TgtA, {10, 20});
+    ecs_set_pair(world, e2, Position, TgtA, {30, 40});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10); test_int(p[0].y, 20);
+        test_int(p[1].x, 30); test_int(p[1].y, 40);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_this_src_w_tag_2_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, FragmentA);
+    ECS_TAG(world, FragmentB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_add(world, e1, FragmentA);
+    ecs_add(world, e2, FragmentB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e2, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_this_src_w_component_2_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, FragmentA);
+    ECS_TAG(world, FragmentB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_add(world, e1, FragmentA);
+    ecs_add(world, e2, FragmentB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e2, Position, {30, 40});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p[0].x, 10); test_int(p[0].y, 20);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p[0].x, 30); test_int(p[0].y, 40);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_this_src_w_tag_pair_2_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, FragmentA);
+    ECS_TAG(world, FragmentB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_add(world, e1, FragmentA);
+    ecs_add(world, e2, FragmentB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_this_src_w_component_pair_2_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, FragmentA);
+    ECS_TAG(world, FragmentB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_add(world, e1, FragmentA);
+    ecs_add(world, e2, FragmentB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set_pair(world, e1, Position, TgtA, {10, 20});
+    ecs_set_pair(world, e2, Position, TgtA, {30, 40});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p[0].x, 10); test_int(p[0].y, 20);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(ecs_id(Position), TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p[0].x, 30); test_int(p[0].y, 40);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_this_src_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this), RelB($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e2, RelA);
+    ecs_add(world, e1, RelB);
+    ecs_add(world, e2, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_this_src_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this), Velocity($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e2, Position, {30, 40});
+
+    ecs_set(world, e1, Velocity, {1, 2});
+    ecs_set(world, e2, Velocity, {3, 4});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10); test_int(p[0].y, 20);
+        test_int(p[1].x, 30); test_int(p[1].y, 40);
+        const Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v[0].x, 1); test_int(v[0].y, 2);
+        test_int(v[1].x, 3); test_int(v[1].y, 4);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_this_src_ent_src_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this), RelB(e3)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e2, RelA);
+    ecs_add(world, e3, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_this_src_ent_src_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this), Velocity(e3)",
+        .cache_kind = cache_kind,
+        .flags = EcsQueryIsInstanced
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e2, Position, {30, 40});
+    ecs_set(world, e3, Velocity, {1, 2});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10); test_int(p[0].y, 20);
+        test_int(p[1].x, 30); test_int(p[1].y, 40);
+        const Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v[0].x, 1); test_int(v[0].y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_ent_src_this_src_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelB(e3), RelA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e2, RelA);
+    ecs_add(world, e3, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_ent_src_this_src_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Velocity(e3), Position($this)",
+        .cache_kind = cache_kind,
+        .flags = EcsQueryIsInstanced
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e2, Position, {30, 40});
+    ecs_set(world, e3, Velocity, {1, 2});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        const Velocity *v = ecs_field(&it, Velocity, 0);
+        test_assert(v != NULL);
+        test_int(v[0].x, 1); test_int(v[0].y, 2);
+        const Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10); test_int(p[0].y, 20);
+        test_int(p[1].x, 30); test_int(p[1].y, 40);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_recycled_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_delete(world, ecs_new(world));
+    ECS_TAG(world, RelA);
+    test_assert((uint32_t)RelA != RelA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_recycled_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+    test_assert((uint32_t)ent != ent);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_recycled_pair_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_delete(world, ecs_new(world));
+    ECS_TAG(world, RelA);
+    test_assert((uint32_t)RelA != RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_recycled_pair_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ecs_delete(world, ecs_new(world));
+    ECS_TAG(world, TgtA);
+    test_assert((uint32_t)TgtA != TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_src_w_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this), *($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e1, RelB);
+    
+    ecs_add(world, e2, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e2, RelC);
+
+    ecs_add(world, e3, RelA);
+    ecs_add(world, e3, RelB);
+    ecs_add(world, e3, RelC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelC, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_src_w_pair_rel_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this, TgtA), *($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtB);
+    
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+    ecs_add_pair(world, e2, RelC, TgtA);
+    ecs_add_pair(world, e2, RelC, TgtB);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+    ecs_add_pair(world, e3, RelC, TgtA);
+    ecs_add_pair(world, e3, RelC, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_src_w_pair_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this, TgtA), RelA($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtB);
+    ecs_add_pair(world, e2, RelA, TgtC);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+    ecs_add_pair(world, e3, RelA, TgtC);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_src_w_pair_rel_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this, TgtA), *($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtB);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_src_w_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_",
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, Tgt);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    ecs_entity_t prev = 0;
+    int32_t count = 0, e1_matched = 0;
+    while (ecs_query_next(&it)) {
+        test_assert(it.count > 0);
+        test_assert(!prev || prev != it.entities[0]);
+        prev = it.entities[0];
+        if (it.entities[0] == e1) {
+            e1_matched ++;
+        }
+        count ++;
+    }
+
+    test_assert(count > 0);
+    test_int(e1_matched, 1);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_not_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "!_",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_src_w_any_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this), _($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e1, RelB);
+    
+    ecs_add(world, e2, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e2, RelC);
+
+    ecs_add(world, e3, RelA);
+    ecs_add(world, e3, RelB);
+    ecs_add(world, e3, RelC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_src_w_pair_rel_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this, TgtA), _($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtB);
+    
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+    ecs_add_pair(world, e2, RelC, TgtA);
+    ecs_add_pair(world, e2, RelC, TgtB);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+    ecs_add_pair(world, e3, RelC, TgtA);
+    ecs_add_pair(world, e3, RelC, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_src_w_pair_tgt_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this, TgtA), RelA($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtB);
+    ecs_add_pair(world, e2, RelA, TgtC);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+    ecs_add_pair(world, e3, RelA, TgtC);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_src_w_pair_rel_tgt_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this, TgtA), _($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtB);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_ent_src_w_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "*(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e1, RelB);
+    ecs_add(world, e1, RelC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelC, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_ent_src_w_pair_rel_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "*(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e1, RelC, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_ent_src_w_pair_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add_pair(world, e1, RelA, TgtC);
+    ecs_add_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_ent_src_w_pair_rel_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "ent" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add_pair(world, e1, RelB, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "*(ent, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_wildcard_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(*)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_add_id(world, e1, Tag);
+    ecs_new_w(world, RelA);
+    ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_wildcard_src_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(*, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_add(world, e1, Tag);
+    ecs_new_w_pair(world, RelA, TgtA);
+    ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_wildcard_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(*), RelB(*)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_add_id(world, e1, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelB);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e3, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_wildcard_src_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(*, TgtA), RelB(*, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_add(world, e1, Tag);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+    
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_rule_w_iter_next(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_wildcard_src_w_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(*, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, Rel, TgtA);
+    ecs_new_w_pair(world, Rel, TgtB);
+    ecs_new_w_pair(world, Rel, TgtC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_wildcard_src_w_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$x(*, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, Tgt);
+    ecs_new_w_pair(world, RelB, Tgt);
+    ecs_new_w_pair(world, RelC, Tgt);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelC, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_wildcard_src_w_pair_tgt_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(*, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int this_var = ecs_query_find_var(r, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, Rel, TgtA);
+    ecs_new_w_pair(world, Rel, TgtB);
+    ecs_new_w_pair(world, Rel, TgtC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, this_var));
+        test_uint(TgtA, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, this_var));
+        test_uint(TgtB, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtC, ecs_iter_get_var(&it, this_var));
+        test_uint(TgtC, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_wildcard_src_w_pair_rel_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$this(*, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int this_var = ecs_query_find_var(r, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, Tgt);
+    ecs_new_w_pair(world, RelB, Tgt);
+    ecs_new_w_pair(world, RelC, Tgt);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, this_var));
+        test_uint(RelA, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, this_var));
+        test_uint(RelB, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelC, ecs_iter_get_var(&it, this_var));
+        test_uint(RelC, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_add_id(world, e1, Tag);
+    ecs_new_w(world, RelA);
+    ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_component(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(_)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add_id(world, e1, Tag);
+    ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_assert(NULL == ecs_field(&it, Position, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_component_w_this_component(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(_), Velocity",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e = ecs_insert(world, ecs_value(Velocity, {10, 20}));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add_id(world, e1, Tag);
+    ecs_new_w(world, Position);
+    ecs_new_w(world, Position);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_assert(NULL == ecs_field(&it, Position, 0));
+        {
+            Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 10);
+            test_int(v->y, 20);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_add(world, e1, Tag);
+    ecs_new_w_pair(world, RelA, TgtA);
+    ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_any_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_), RelB(_)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_add_id(world, e1, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelB);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e3, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_any_src_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_, TgtA), RelB(_, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_add(world, e1, Tag);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_w_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(_, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, Rel, TgtA);
+    ecs_new_w_pair(world, Rel, TgtB);
+    ecs_new_w_pair(world, Rel, TgtC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_w_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$x(_, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, Tgt);
+    ecs_new_w_pair(world, RelB, Tgt);
+    ecs_new_w_pair(world, RelC, Tgt);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelC, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_w_pair_tgt_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(_, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int this_var = ecs_query_find_var(r, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, Rel, TgtA);
+    ecs_new_w_pair(world, Rel, TgtB);
+    ecs_new_w_pair(world, Rel, TgtC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+        test_uint(TgtC, ecs_iter_get_var(&it, this_var));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_uint(TgtC, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, this_var));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_uint(TgtB, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, this_var));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_uint(TgtA, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_w_pair_rel_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$this(_, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int this_var = ecs_query_find_var(r, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, Tgt);
+    ecs_new_w_pair(world, RelB, Tgt);
+    ecs_new_w_pair(world, RelC, Tgt);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 0));
+        test_uint(RelC, ecs_iter_get_var(&it, this_var));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_uint(RelC, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, this_var));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_uint(RelB, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, this_var));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_uint(RelA, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_any_tgt_w_rel_fixed(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_any_rel_w_tgt_fixed(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(_, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_w_childof_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "ChildOf(_, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_empty(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_pair_tgt_wildcard_empty(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e3);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_pair_rel_wildcard_empty(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "*(_, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelC, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e3);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_any_tgt_w_rel_fixed_empty(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_any_rel_w_tgt_fixed_empty(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "_(_, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_pair_w_tag_query_empty(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_1_any_src_tag_w_pair_query_empty(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_empty_rule(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_invalid_rule(void) {
+    ecs_log_set_level(-4);
+
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r == NULL);
+
+    ecs_fini(world);
+}
+
+void Basic_not_instanced_table_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(3, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10); test_int(p[0].y, 20);
+        test_int(p[1].x, 20); test_int(p[1].y, 30);
+        test_int(p[2].x, 30); test_int(p[2].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_not_instanced_entity_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e1)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set(world, e1, Position, {10, 20});
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_not_instanced_mixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e0 = ecs_entity(world, { .name = "e0" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this), Velocity(e0)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_set(world, e0, Velocity, {1, 2});
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+
+        const Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+
+        const Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, it.entities[0]);
+
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 30);
+        test_int(p->y, 40);
+
+        const Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_not_instanced_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+    
+    ECS_TAG(world, Tag);
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base = ecs_insert(world, ecs_value(Velocity, {1, 2}));
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+
+    ecs_add_pair(world, e1, EcsIsA, base);
+    ecs_add_pair(world, e2, EcsIsA, base);
+    ecs_add_pair(world, e3, EcsIsA, base);
+    ecs_add_pair(world, e4, EcsIsA, base);
+    ecs_add_pair(world, e5, EcsIsA, base);
+
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Position, {60, 70}));
+    ecs_entity_t e7 = ecs_insert(world, ecs_value(Position, {70, 80}));
+    ecs_set(world, e6, Velocity, {2, 3});
+    ecs_set(world, e7, Velocity, {4, 5});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e1);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e2);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e3);
+        test_int(p->x, 30);
+        test_int(p->y, 40);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e4);
+        test_int(p->x, 40);
+        test_int(p->y, 50);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e5);
+        test_int(p->x, 50);
+        test_int(p->y, 60);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 2);
+        test_int(it.entities[0], e6);
+        test_int(p[0].x, 60);
+        test_int(p[0].y, 70);
+        test_int(v[0].x, 2);
+        test_int(v[0].y, 3);
+
+        test_int(it.entities[1], e7);
+        test_int(p[1].x, 70);
+        test_int(p[1].y, 80);
+        test_int(v[1].x, 4);
+        test_int(v[1].y, 5);
+    }
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_instanced_table_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this)",
+        .cache_kind = cache_kind,
+        .flags = EcsQueryIsInstanced
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(3, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10); test_int(p[0].y, 20);
+        test_int(p[1].x, 20); test_int(p[1].y, 30);
+        test_int(p[2].x, 30); test_int(p[2].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_instanced_entity_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e1)",
+        .cache_kind = cache_kind,
+        .flags = EcsQueryIsInstanced
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set(world, e1, Position, {10, 20});
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_instanced_mixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e0 = ecs_entity(world, { .name = "e0" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($this), Velocity(e0)",
+        .cache_kind = cache_kind,
+        .flags = EcsQueryIsInstanced
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_set(world, e0, Velocity, {1, 2});
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(3, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10); test_int(p[0].y, 20);
+        test_int(p[1].x, 20); test_int(p[1].y, 30);
+        test_int(p[2].x, 30); test_int(p[2].y, 40);
+
+        const Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_instanced_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+    
+    ECS_TAG(world, Tag);
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base = ecs_insert(world, ecs_value(Velocity, {1, 2}));
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+
+    ecs_add_pair(world, e1, EcsIsA, base);
+    ecs_add_pair(world, e2, EcsIsA, base);
+    ecs_add_pair(world, e3, EcsIsA, base);
+    ecs_add_pair(world, e4, EcsIsA, base);
+    ecs_add_pair(world, e5, EcsIsA, base);
+
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Position, {60, 70}));
+    ecs_entity_t e7 = ecs_insert(world, ecs_value(Position, {70, 80}));
+    ecs_set(world, e6, Velocity, {2, 3});
+    ecs_set(world, e7, Velocity, {4, 5});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind,
+        .flags = EcsQueryIsInstanced
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 3);
+        test_int(it.entities[0], e1);
+        test_int(it.entities[1], e2);
+        test_int(it.entities[2], e3);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+        test_int(p[1].x, 20);
+        test_int(p[1].y, 30);
+        test_int(p[2].x, 30);
+        test_int(p[2].y, 40);
+        test_int(v[0].x, 1);
+        test_int(v[0].y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 2);
+        test_int(it.entities[0], e4);
+        test_int(it.entities[1], e5);
+        test_int(p[0].x, 40);
+        test_int(p[0].y, 50);
+        test_int(p[1].x, 50);
+        test_int(p[1].y, 60);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 2);
+        test_int(it.entities[0], e6);
+        test_int(p[0].x, 60);
+        test_int(p[0].y, 70);
+        test_int(v[0].x, 2);
+        test_int(v[0].y, 3);
+
+        test_int(it.entities[1], e7);
+        test_int(p[1].x, 70);
+        test_int(p[1].y, 80);
+        test_int(v[1].x, 4);
+        test_int(v[1].y, 5);
+    }
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_in_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "[in] Position(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_readonly(&it, 0));
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_out_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "[out] Position(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_readonly(&it, 0));
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_inout_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "[inout] Position(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_readonly(&it, 0));
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_nodata_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "[none] Position(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_readonly(&it, 0));
+        const Position *p = ecs_field(&it, Position, 0);
+        test_assert(p == NULL);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_find_this_lowercase(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int this_var = ecs_query_find_var(r, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var == 0);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_find_this_uppercase(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int this_var = ecs_query_find_var(r, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var == 0);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_find_this_tgt_lowercase(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(*, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int this_var = ecs_query_find_var(r, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_find_this_tgt_uppercase(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(*, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int this_var = ecs_query_find_var(r, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_get_filter(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    const ecs_query_t *f = r;
+    test_assert(f != NULL);
+    test_int(f->term_count, 1);
+    test_uint(f->terms[0].id, Rel);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_empty_source(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo()",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_id(Foo), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_empty_source_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "*()",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(EcsWildcard, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_empty_source_2_terms(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(), Bar()",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_id(Foo), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Bar), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_empty_source_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(0, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Foo, Tgt), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_empty_source_pair_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "*(0, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, Tgt), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_empty_source_2_terms_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(0, Tgt), Bar(0, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Foo, Tgt), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Bar, Tgt), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_empty_source_2_terms_mixed(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, Bar()",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add(world, e, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_empty_source_2_terms_mixed_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "(Foo, Tgt), Bar(0, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add_pair(world, e, Foo, Tgt);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(ecs_pair(Foo, Tgt), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Bar, Tgt), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_empty_source_2_terms_mixed_pair_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "(Foo, Tgt), *(0, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add_pair(world, e, Foo, Tgt);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(ecs_pair(Foo, Tgt), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, Tgt), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_this_var_w_empty_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_entity_t t = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, Rel, t);
+
+    ecs_query_t *r = ecs_query(world, { 
+        .expr = "Rel($x, $this)",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_uint(1, it.count);
+    test_uint(t, it.entities[0]);
+    test_uint(ecs_pair(Rel, t), ecs_field_id(&it, 0));
+    test_uint(e, ecs_field_src(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_uint(e, ecs_iter_get_var(&it, x_var));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_match_disabled(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_2);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, Prefab",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_3);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_disabled_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+    ecs_entity_t e_4 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_4, EcsPrefab);
+    ecs_add_id(world, e_4, EcsDisabled);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, Disabled",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_3 = ecs_query(world, {
+        .expr = "TagA, Prefab",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_4 = ecs_query(world, {
+        .expr = "TagA, Prefab, Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+    test_assert(r_3 != NULL);
+    test_assert(r_4 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+    test_bool(r_3->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_4->flags & EcsQueryMatchDisabled, true);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_3->flags & EcsQueryMatchPrefab, true);
+    test_bool(r_4->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_assert(!ecs_query_next(&it));
+
+    {
+        it = ecs_query_iter(world, r_2);
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_2);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_3);
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_3);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_4);
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_4);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(!ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+    ecs_query_fini(r_3);
+    ecs_query_fini(r_4);
+
+    ecs_fini(world);
+}
+
+void Basic_match_disabled_this_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_new_w_pair(world, EcsChildOf, e_1);
+    ecs_new_w_pair(world, EcsChildOf, e_2);
+    ecs_new_w_pair(world, EcsChildOf, e_3);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_2);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_prefab_this_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_new_w_pair(world, EcsChildOf, e_1);
+    ecs_new_w_pair(world, EcsChildOf, e_2);
+    ecs_new_w_pair(world, EcsChildOf, e_3);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), Prefab",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_3);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_disabled_prefab_this_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+    ecs_entity_t e_4 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_4, EcsPrefab);
+    ecs_add_id(world, e_4, EcsDisabled);
+
+    ecs_new_w_pair(world, EcsChildOf, e_1);
+    ecs_new_w_pair(world, EcsChildOf, e_2);
+    ecs_new_w_pair(world, EcsChildOf, e_3);
+    ecs_new_w_pair(world, EcsChildOf, e_4);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), Disabled",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_3 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), Prefab",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_4 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), Prefab, Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+    test_assert(r_3 != NULL);
+    test_assert(r_4 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+    test_bool(r_3->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_4->flags & EcsQueryMatchDisabled, true);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_3->flags & EcsQueryMatchPrefab, true);
+    test_bool(r_4->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_assert(!ecs_query_next(&it));
+
+    {
+        it = ecs_query_iter(world, r_2);
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_2);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_3);
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_3);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_4);
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_4);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(!ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+    ecs_query_fini(r_3);
+    ecs_query_fini(r_4);
+
+    ecs_fini(world);
+}
+
+void Basic_match_self_disabled(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA(self), Disabled(self)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_2);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_self_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA(self), Prefab(self)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_3);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_self_disabled_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+    ecs_entity_t e_4 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_4, EcsPrefab);
+    ecs_add_id(world, e_4, EcsDisabled);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA(self), Disabled(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_3 = ecs_query(world, {
+        .expr = "TagA(self), Prefab(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_4 = ecs_query(world, {
+        .expr = "TagA(self), Prefab(self), Disabled(self)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+    test_assert(r_3 != NULL);
+    test_assert(r_4 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+    test_bool(r_3->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_4->flags & EcsQueryMatchDisabled, true);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_3->flags & EcsQueryMatchPrefab, true);
+    test_bool(r_4->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_assert(!ecs_query_next(&it));
+
+    {
+        it = ecs_query_iter(world, r_2);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_2);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_3);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_3);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_4);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_4);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(!ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+    ecs_query_fini(r_3);
+    ecs_query_fini(r_4);
+
+    ecs_fini(world);
+}
+
+void Basic_match_optional_disabled(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, ?Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_2);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_optional_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, ?Prefab",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_3);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_optional_disabled_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+    ecs_entity_t e_4 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_4, EcsPrefab);
+    ecs_add_id(world, e_4, EcsDisabled);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, ?Disabled",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_3 = ecs_query(world, {
+        .expr = "TagA, ?Prefab",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_4 = ecs_query(world, {
+        .expr = "TagA, ?Prefab, ?Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+    test_assert(r_3 != NULL);
+    test_assert(r_4 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+    test_bool(r_3->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_4->flags & EcsQueryMatchDisabled, true);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_3->flags & EcsQueryMatchPrefab, true);
+    test_bool(r_4->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_assert(!ecs_query_next(&it));
+
+    {
+        it = ecs_query_iter(world, r_2);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_1);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_2);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_3);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_1);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_3);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_4);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_1);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_2);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_3);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_4);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(!ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+    ecs_query_fini(r_3);
+    ecs_query_fini(r_4);
+
+    ecs_fini(world);
+}
+
+void Basic_match_optional_disabled_this_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_new_w_pair(world, EcsChildOf, e_1);
+    ecs_new_w_pair(world, EcsChildOf, e_2);
+    ecs_new_w_pair(world, EcsChildOf, e_3);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), ?Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_2);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_optional_prefab_this_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_new_w_pair(world, EcsChildOf, e_1);
+    ecs_new_w_pair(world, EcsChildOf, e_2);
+    ecs_new_w_pair(world, EcsChildOf, e_3);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), ?Prefab",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_3);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_optional_disabled_prefab_this_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+    ecs_entity_t e_4 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_4, EcsPrefab);
+    ecs_add_id(world, e_4, EcsDisabled);
+
+    ecs_new_w_pair(world, EcsChildOf, e_1);
+    ecs_new_w_pair(world, EcsChildOf, e_2);
+    ecs_new_w_pair(world, EcsChildOf, e_3);
+    ecs_new_w_pair(world, EcsChildOf, e_4);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), ?Disabled",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_3 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), ?Prefab",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_4 = ecs_query(world, {
+        .expr = "TagA, ChildOf($child, $this), ?Prefab, ?Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+    test_assert(r_3 != NULL);
+    test_assert(r_4 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+    test_bool(r_3->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_4->flags & EcsQueryMatchDisabled, true);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_3->flags & EcsQueryMatchPrefab, true);
+    test_bool(r_4->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_assert(!ecs_query_next(&it));
+
+    {
+        it = ecs_query_iter(world, r_2);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_1);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_2);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_3);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_1);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_3);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_4);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_1);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_2);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_3);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_4);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(!ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+    ecs_query_fini(r_3);
+    ecs_query_fini(r_4);
+
+    ecs_fini(world);
+}
+
+void Basic_match_optional_self_disabled(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA(self), ?Disabled(self)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_2);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_optional_self_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA(self), ?Prefab(self)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_assert(!ecs_query_next(&it));
+
+    it = ecs_query_iter(world, r_2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_3);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+
+    ecs_fini(world);
+}
+
+void Basic_match_optional_self_disabled_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, EcsDisabled);
+    ecs_entity_t e_3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_3, EcsPrefab);
+    ecs_entity_t e_4 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_4, EcsPrefab);
+    ecs_add_id(world, e_4, EcsDisabled);
+
+    ecs_query_t *r_1 = ecs_query(world, {
+        .expr = "TagA(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_2 = ecs_query(world, {
+        .expr = "TagA(self), ?Disabled(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_3 = ecs_query(world, {
+        .expr = "TagA(self), ?Prefab(self)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *r_4 = ecs_query(world, {
+        .expr = "TagA(self), ?Prefab(self), ?Disabled(self)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r_1 != NULL);
+    test_assert(r_2 != NULL);
+    test_assert(r_3 != NULL);
+    test_assert(r_4 != NULL);
+
+    test_bool(r_1->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_2->flags & EcsQueryMatchDisabled, true);
+    test_bool(r_3->flags & EcsQueryMatchDisabled, false);
+    test_bool(r_4->flags & EcsQueryMatchDisabled, true);
+
+    test_bool(r_1->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_2->flags & EcsQueryMatchPrefab, false);
+    test_bool(r_3->flags & EcsQueryMatchPrefab, true);
+    test_bool(r_4->flags & EcsQueryMatchPrefab, true);
+
+    ecs_iter_t it = ecs_query_iter(world, r_1);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_assert(!ecs_query_next(&it));
+
+    {
+        it = ecs_query_iter(world, r_2);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_1);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_2);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_3);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_1);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_3);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_assert(!ecs_query_next(&it));
+    }
+
+    {
+        it = ecs_query_iter(world, r_4);
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_1);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_2);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_3);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_int(it.entities[0], e_4);
+        test_int(ecs_field_id(&it, 0), TagA);
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_assert(!ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r_1);
+    ecs_query_fini(r_2);
+    ecs_query_fini(r_3);
+    ecs_query_fini(r_4);
+
+    ecs_fini(world);
+}
+
+void Basic_inout_none_first_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *r = ecs_query(world, {
+        .terms = {
+            { .id = ecs_id(Position), .inout = EcsInOutNone },
+            { .id = ecs_id(Velocity) }
+        },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e1, Velocity, {1, 2});
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p == NULL);
+    }
+    {
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_inout_none_second_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *r = ecs_query(world, {
+        .terms = {
+            { .id = ecs_id(Position) },
+            { .id = ecs_id(Velocity), .inout = EcsInOutNone }
+        },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e1, Velocity, {1, 2});
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    {
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v == NULL);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_inout_none_singleton(void) {
+    ecs_world_t *ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+    
+    ecs_singleton_set(ecs, Position, {10, 20});
+
+    ecs_entity_t e = ecs_insert(ecs, ecs_value(Velocity, {20, 30}));
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position), .src.id = EcsVariable },
+            { .id = ecs_id(Velocity), .inout = EcsInOutNone },
+        },
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    Position *p = ecs_field(&it, Position, 0);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+    test_assert(ecs_field(&it, Velocity, 1) == NULL);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Basic_inout_none_singleton_w_or(void) {
+    ecs_world_t *ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+    ECS_COMPONENT(ecs, Mass);
+
+    ecs_singleton_set(ecs, Position, {10, 20});
+
+    ecs_entity_t e = ecs_insert(ecs, ecs_value(Velocity, {20, 30}));
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position), .src.id = EcsVariable },
+            { .id = ecs_id(Velocity), .inout = EcsInOutNone, .oper = EcsOr },
+            { .id = ecs_id(Mass), .inout = EcsInOutNone },
+        },
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    Position *p = ecs_field(&it, Position, 0);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+    test_assert(ecs_field(&it, Velocity, 1) == NULL);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Basic_inout_none_component_w_or(void) {
+    ecs_world_t *ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+    ECS_COMPONENT(ecs, Mass);
+
+    ecs_entity_t e = ecs_insert(ecs, ecs_value(Velocity, {20, 30}));
+    ecs_set(ecs, e, Position, {10, 20});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position) },
+            { .id = ecs_id(Velocity), .inout = EcsInOutNone, .oper = EcsOr },
+            { .id = ecs_id(Mass), .inout = EcsInOutNone },
+        },
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    Position *p = ecs_field(&it, Position, 0);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+    test_assert(ecs_field(&it, Velocity, 1) == NULL);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Basic_no_data_rule(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *r = ecs_query(world, {
+        .terms = {
+            { .id = ecs_id(Position) },
+            { .id = ecs_id(Velocity) }
+        },
+        .flags = EcsQueryNoData,
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e1, Velocity, {1, 2});
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p == NULL);
+    }
+    {
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v == NULL);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_frame_offset(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {
+            { .id = ecs_id(Position), }
+        },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+    ecs_entity_t e4 = ecs_new_w(world, Position);
+    ecs_entity_t e5 = ecs_new_w(world, Position);
+
+    ecs_add(world, e3, TagB);
+    ecs_add(world, e4, TagB);
+    ecs_add(world, e5, TagC);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 2);
+    test_int(it.frame_offset, 0);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e1);
+    test_assert(it.entities[1] == e2);
+    test_assert(it.ids[0] == ecs_id(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 2);
+    test_int(it.frame_offset, 2);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e3);
+    test_assert(it.entities[1] == e4);
+    test_assert(it.ids[0] == ecs_id(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.frame_offset, 4);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e5);
+    test_assert(it.ids[0] == ecs_id(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_frame_offset_no_data(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {
+            { .id = TagA, }
+        },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_entity_t e4 = ecs_new_w(world, TagA);
+    ecs_entity_t e5 = ecs_new_w(world, TagA);
+
+    ecs_add(world, e3, TagB);
+    ecs_add(world, e4, TagB);
+    ecs_add(world, e5, TagC);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 2);
+    test_int(it.frame_offset, 0);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e1);
+    test_assert(it.entities[1] == e2);
+    test_assert(it.ids[0] == TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 2);
+    test_int(it.frame_offset, 2);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e3);
+    test_assert(it.entities[1] == e4);
+    test_assert(it.ids[0] == TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.frame_offset, 4);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e5);
+    test_assert(it.ids[0] == TagA);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_match_empty_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+    ecs_entity_t e4 = ecs_new_w(world, Position);
+
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e3, TagB);
+    ecs_add(world, e4, TagC);
+
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    ecs_table_t *t2 = ecs_get_table(world, e2);
+    ecs_table_t *t3 = ecs_get_table(world, e3);
+    ecs_table_t *t4 = ecs_get_table(world, e4);
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ ecs_id(Position) }},
+        .flags = EcsQueryMatchEmptyTables,
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t1);
+    test_int(it.count, 0);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t2);
+    test_int(it.count, 0);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t3);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t4);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e4);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), false);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_match_empty_tables_no_data(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_entity_t e4 = ecs_new_w(world, Foo);
+
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e3, TagB);
+    ecs_add(world, e4, TagC);
+
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    ecs_table_t *t2 = ecs_get_table(world, e2);
+    ecs_table_t *t3 = ecs_get_table(world, e3);
+    ecs_table_t *t4 = ecs_get_table(world, e4);
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ Foo }},
+        .flags = EcsQueryMatchEmptyTables,
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t1);
+    test_int(it.count, 0);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t2);
+    test_int(it.count, 0);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t3);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t4);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e4);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), false);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_match_empty_tables_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_entity_t e4 = ecs_new_w(world, Foo);
+
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e3, TagB);
+    ecs_add(world, e4, TagC);
+
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    ecs_get_table(world, e2);
+    ecs_table_t *t3 = ecs_get_table(world, e3);
+    ecs_table_t *t4 = ecs_get_table(world, e4);
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ Foo }, { TagA, .oper = EcsNot }},
+        .flags = EcsQueryMatchEmptyTables,
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t1);
+    test_int(it.count, 0);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t3);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t4);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e4);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), false);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_match_empty_tables_w_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, TgtD);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtC);
+    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtD);
+
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    ecs_table_t *t2 = ecs_get_table(world, e2);
+    ecs_table_t *t3 = ecs_get_table(world, e3);
+    ecs_table_t *t4 = ecs_get_table(world, e4);
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ ecs_pair(Rel, EcsWildcard) }},
+        .flags = EcsQueryMatchEmptyTables,
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t1);
+    test_int(it.count, 0);
+    test_uint(ecs_field_id(&it, 0), ecs_pair(Rel, TgtA));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t2);
+    test_int(it.count, 0);
+    test_uint(ecs_field_id(&it, 0), ecs_pair(Rel, TgtB));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t3);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+    test_uint(ecs_field_id(&it, 0), ecs_pair(Rel, TgtC));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t4);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e4);
+    test_uint(ecs_field_id(&it, 0), ecs_pair(Rel, TgtD));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), false);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_match_empty_tables_w_no_empty_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {
+            { Foo }
+        },
+        .flags = EcsQueryMatchEmptyTables,
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_add(world, e2, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_match_empty_tables_trivial(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+    ecs_entity_t e4 = ecs_new_w(world, Position);
+
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e3, TagB);
+    ecs_add(world, e4, TagC);
+
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    ecs_table_t *t2 = ecs_get_table(world, e2);
+    ecs_table_t *t3 = ecs_get_table(world, e3);
+    ecs_table_t *t4 = ecs_get_table(world, e4);
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{ ecs_id(Position), .src.id = EcsSelf }},
+        .flags = EcsQueryMatchEmptyTables,
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t1);
+    test_int(it.count, 0);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t2);
+    test_int(it.count, 0);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t3);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), true);
+    test_assert(it.table == t4);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e4);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool( ecs_query_next(&it), false);
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_oneof_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Parent);
+    ECS_ENTITY(world, Rel, (OneOf, Parent));
+    ECS_ENTITY(world, ObjA, (ChildOf, Parent));
+    ECS_ENTITY(world, ObjB, (ChildOf, Parent));
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
+    test_assert( ecs_has_pair(world, e1, Rel, ObjA));
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
+    test_assert( ecs_has_pair(world, e2, Rel, ObjB));
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{
+            .id = ecs_pair(Rel, EcsWildcard)
+        }},
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_oneof_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Parent);
+    ECS_ENTITY(world, Rel, (OneOf, Parent));
+    ECS_ENTITY(world, ObjA, (ChildOf, Parent));
+    ECS_ENTITY(world, ObjB, (ChildOf, Parent));
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
+    test_assert( ecs_has_pair(world, e1, Rel, ObjA));
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
+    test_assert( ecs_has_pair(world, e2, Rel, ObjB));
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {{
+            .id = ecs_pair(Rel, EcsAny)
+        }},
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, EcsWildcard), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, EcsWildcard), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_instanced_w_singleton(void) {
+    ecs_world_t *world = ecs_mini();
+    
+    ECS_TAG(world, Tag);
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_singleton_set(world, Velocity, {1, 2});
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {50, 60}));
+
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+
+    ecs_query_t *f = ecs_query(world, {
+        .expr = "Position, Velocity($)",
+        .cache_kind = cache_kind,
+        .flags = EcsQueryIsInstanced
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 3);
+        test_int(it.entities[0], e1);
+        test_int(it.entities[1], e2);
+        test_int(it.entities[2], e3);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+        test_int(p[1].x, 20);
+        test_int(p[1].y, 30);
+        test_int(p[2].x, 30);
+        test_int(p[2].y, 40);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 2);
+        test_int(it.entities[0], e4);
+        test_int(it.entities[1], e5);
+        test_int(p[0].x, 40);
+        test_int(p[0].y, 50);
+        test_int(p[1].x, 50);
+        test_int(p[1].y, 60);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_instanced_w_base(void) {
+    ecs_world_t *world = ecs_mini();
+    
+    ECS_TAG(world, Tag);
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Velocity, {1, 2}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {80, 90}));
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+
+    ecs_add_pair(world, e1, EcsIsA, base_1);
+    ecs_add_pair(world, e2, EcsIsA, base_1);
+    ecs_add_pair(world, e3, EcsIsA, base_1);
+    ecs_add_pair(world, e4, EcsIsA, base_1);
+    ecs_add_pair(world, e5, EcsIsA, base_1);
+
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Position, {60, 70}));
+    ecs_entity_t e7 = ecs_insert(world, ecs_value(Position, {70, 80}));
+    ecs_set(world, e6, Velocity, {2, 3});
+    ecs_set(world, e7, Velocity, {4, 5});
+
+    ecs_entity_t e8 = ecs_insert(world, ecs_value(Velocity, {6, 7}));
+    ecs_entity_t e9 = ecs_insert(world, ecs_value(Velocity, {8, 9}));
+    ecs_add_pair(world, e8, EcsIsA, base_2);
+    ecs_add_pair(world, e9, EcsIsA, base_2);
+
+    ecs_query_t *f = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind,
+        .flags = EcsQueryIsInstanced
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), false);
+        test_bool(ecs_field_is_self(&it, 1), true);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 2);
+        test_int(it.entities[0], e8);
+        test_int(it.entities[1], e9);
+        test_int(p->x, 80);
+        test_int(p->y, 90);
+        test_int(v[0].x, 6);
+        test_int(v[0].y, 7);
+        test_int(v[1].x, 8);
+        test_int(v[1].y, 9);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), true);
+        test_bool(ecs_field_is_self(&it, 1), false);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 3);
+        test_int(it.entities[0], e1);
+        test_int(it.entities[1], e2);
+        test_int(it.entities[2], e3);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+        test_int(p[1].x, 20);
+        test_int(p[1].y, 30);
+        test_int(p[2].x, 30);
+        test_int(p[2].y, 40);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), true);
+        test_bool(ecs_field_is_self(&it, 1), false);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 2);
+        test_int(it.entities[0], e4);
+        test_int(it.entities[1], e5);
+        test_int(p[0].x, 40);
+        test_int(p[0].y, 50);
+        test_int(p[1].x, 50);
+        test_int(p[1].y, 60);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), true);
+        test_bool(ecs_field_is_self(&it, 1), true);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 2);
+        test_int(it.entities[0], e6);
+        test_int(p[0].x, 60);
+        test_int(p[0].y, 70);
+        test_int(v[0].x, 2);
+        test_int(v[0].y, 3);
+
+        test_int(it.entities[1], e7);
+        test_int(p[1].x, 70);
+        test_int(p[1].y, 80);
+        test_int(v[1].x, 4);
+        test_int(v[1].y, 5);
+    }
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_not_instanced_w_singleton(void) {
+    ecs_world_t *world = ecs_mini();
+    
+    ECS_TAG(world, Tag);
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_singleton_set(world, Velocity, {1, 2});
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {50, 60}));
+
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+
+    ecs_query_t *f = ecs_query(world, {
+        .expr = "Position, Velocity($)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e1);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e2);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e3);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e4);
+        test_int(p[0].x, 40);
+        test_int(p[0].y, 50);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e5);
+        test_int(p[0].x, 50);
+        test_int(p[0].y, 60);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+    }
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_not_instanced_w_base(void) {
+    ecs_world_t *world = ecs_mini();
+    
+    ECS_TAG(world, Tag);
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Velocity, {1, 2}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {80, 90}));
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+
+    ecs_add_pair(world, e1, EcsIsA, base_1);
+    ecs_add_pair(world, e2, EcsIsA, base_1);
+    ecs_add_pair(world, e3, EcsIsA, base_1);
+    ecs_add_pair(world, e4, EcsIsA, base_1);
+    ecs_add_pair(world, e5, EcsIsA, base_1);
+
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Position, {60, 70}));
+    ecs_entity_t e7 = ecs_insert(world, ecs_value(Position, {70, 80}));
+    ecs_set(world, e6, Velocity, {2, 3});
+    ecs_set(world, e7, Velocity, {4, 5});
+
+    ecs_entity_t e8 = ecs_insert(world, ecs_value(Velocity, {6, 7}));
+    ecs_entity_t e9 = ecs_insert(world, ecs_value(Velocity, {8, 9}));
+    ecs_add_pair(world, e8, EcsIsA, base_2);
+    ecs_add_pair(world, e9, EcsIsA, base_2);
+
+    ecs_query_t *f = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), false);
+        test_bool(ecs_field_is_self(&it, 1), true);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e8);
+        test_int(p->x, 80);
+        test_int(p->y, 90);
+        test_int(v[0].x, 6);
+        test_int(v[0].y, 7);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), false);
+        test_bool(ecs_field_is_self(&it, 1), true);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e9);
+        test_int(p->x, 80);
+        test_int(p->y, 90);
+        test_int(v[0].x, 8);
+        test_int(v[0].y, 9);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), true);
+        test_bool(ecs_field_is_self(&it, 1), false);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e1);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), true);
+        test_bool(ecs_field_is_self(&it, 1), false);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e2);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), true);
+        test_bool(ecs_field_is_self(&it, 1), false);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e3);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), true);
+        test_bool(ecs_field_is_self(&it, 1), false);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e4);
+        test_int(p[0].x, 40);
+        test_int(p[0].y, 50);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), true);
+        test_bool(ecs_field_is_self(&it, 1), false);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e5);
+        test_int(p[0].x, 50);
+        test_int(p[0].y, 60);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        test_bool(ecs_field_is_self(&it, 0), true);
+        test_bool(ecs_field_is_self(&it, 1), true);
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(p != NULL);
+        test_assert(v != NULL);
+        test_int(it.count, 2);
+        test_int(it.entities[0], e6);
+        test_int(p[0].x, 60);
+        test_int(p[0].y, 70);
+        test_int(v[0].x, 2);
+        test_int(v[0].y, 3);
+
+        test_int(it.entities[1], e7);
+        test_int(p[1].x, 70);
+        test_int(p[1].y, 80);
+        test_int(v[1].x, 4);
+        test_int(v[1].y, 5);
+    }
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Basic_unknown_before_known(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, ChildOf($gc, $c), ChildOf($c, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int c_var = ecs_query_find_var(r, "c");
+    test_assert(c_var != -1);
+    int gc_var = ecs_query_find_var(r, "gc");
+    test_assert(gc_var != -1);
+
+    ecs_entity_t p = ecs_new_w(world, Foo);
+    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
+    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_entity_t gc = ecs_new_w_pair(world, EcsChildOf, c);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 1));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_uint(c, ecs_iter_get_var(&it, c_var));
+    test_uint(gc, ecs_iter_get_var(&it, gc_var));
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r);
+    
+    ecs_fini(world);
+}
+
+void Basic_unknown_before_known_after_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, ChildOf($gc, $c), Foo($gc) || Bar($gc), ChildOf($c, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int c_var = ecs_query_find_var(r, "c");
+    test_assert(c_var != -1);
+    int gc_var = ecs_query_find_var(r, "gc");
+    test_assert(gc_var != -1);
+
+    ecs_entity_t p = ecs_new_w(world, Foo);
+    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
+    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_entity_t gc1 = ecs_new_w_pair(world, EcsChildOf, c);
+    ecs_add(world, gc1, Foo);
+    ecs_entity_t gc2 = ecs_new_w_pair(world, EcsChildOf, c);
+    ecs_add(world, gc2, Bar);
+    /* ecs_entity_t gc3 = */ ecs_new_w_pair(world, EcsChildOf, c);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 1));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 3));
+    test_uint(c, ecs_iter_get_var(&it, c_var));
+    test_uint(gc1, ecs_iter_get_var(&it, gc_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 1));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 3));
+    test_uint(c, ecs_iter_get_var(&it, c_var));
+    test_uint(gc2, ecs_iter_get_var(&it, gc_var));
+    test_assert(!ecs_query_next(&it));
+    
+    ecs_query_fini(r);
+    
+    ecs_fini(world);
+}
+
+void Basic_unknown_before_known_after_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, ChildOf($gc, $c), !Foo($gc), ChildOf($c, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int c_var = ecs_query_find_var(r, "c");
+    test_assert(c_var != -1);
+    int gc_var = ecs_query_find_var(r, "gc");
+    test_assert(gc_var != -1);
+
+    ecs_entity_t p = ecs_new_w(world, Foo);
+    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
+    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_entity_t gc1 = ecs_new_w_pair(world, EcsChildOf, c);
+    ecs_entity_t gc2 = ecs_new_w_pair(world, EcsChildOf, c);
+    ecs_add(world, gc2, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 1));
+    test_uint(Foo, ecs_field_id(&it, 2));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+    test_uint(c, ecs_iter_get_var(&it, c_var));
+    test_uint(gc1, ecs_iter_get_var(&it, gc_var));
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r);
+    
+    ecs_fini(world);
+}
+
+void Basic_unknown_before_known_after_optional(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, ChildOf($gc, $c), ?Foo($gc), ChildOf($c, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int c_var = ecs_query_find_var(r, "c");
+    test_assert(c_var != -1);
+    int gc_var = ecs_query_find_var(r, "gc");
+    test_assert(gc_var != -1);
+
+    ecs_entity_t p = ecs_new_w(world, Foo);
+    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
+    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_entity_t gc1 = ecs_new_w_pair(world, EcsChildOf, c);
+    ecs_entity_t gc2 = ecs_new_w_pair(world, EcsChildOf, c);
+    ecs_add(world, gc2, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 1));
+    test_uint(Foo, ecs_field_id(&it, 2));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+    test_uint(c, ecs_iter_get_var(&it, c_var));
+    test_uint(gc1, ecs_iter_get_var(&it, gc_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, c), ecs_field_id(&it, 1));
+    test_uint(Foo, ecs_field_id(&it, 2));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+    test_uint(c, ecs_iter_get_var(&it, c_var));
+    test_uint(gc2, ecs_iter_get_var(&it, gc_var));
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r);
+    
+    ecs_fini(world);
+}
+
+void Basic_unknown_before_known_after_scope(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, ChildOf($gc, $c), !{Foo($gc) || Bar($gc)}, ChildOf($c, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int c_var = ecs_query_find_var(r, "c");
+    test_assert(c_var != -1);
+    int gc_var = ecs_query_find_var(r, "gc");
+    test_assert(gc_var != -1);
+
+    ecs_entity_t p = ecs_new_w(world, Foo);
+    ecs_entity_t c = ecs_new_w_pair(world, EcsChildOf, p);
+    /* ecs_entity_t c2 = */ ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_entity_t gc1 = ecs_new_w_pair(world, EcsChildOf, c);
+    ecs_entity_t gc2 = ecs_new_w_pair(world, EcsChildOf, c);
+    ecs_add(world, gc2, Foo);
+    ecs_entity_t gc3 = ecs_new_w_pair(world, EcsChildOf, c);
+    ecs_add(world, gc3, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(c, ecs_iter_get_var(&it, c_var));
+    test_uint(gc1, ecs_iter_get_var(&it, gc_var));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(r);
+    
+    ecs_fini(world);
+}
+
+void Basic_2_trivial_mixed_2_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Mass);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self), Bar(self), Mass(ent|self)",
+        .flags = EcsQueryIsInstanced,
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e1, Bar);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e3, Bar);
+    ecs_add(world, e3, Tag);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Mass, {100});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 2));
+
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e3, it.entities[0]);
+
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 2));
+
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_trivial_mixed_2_tables_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(self), Velocity(self), Mass(ent|self)",
+        .flags = EcsQueryIsInstanced,
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e1, Velocity, {1, 2});
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_set(world, e2, Position, {20, 30});
+    ecs_set(world, e2, Velocity, {2, 3});
+
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_set(world, e3, Position, {30, 40});
+    ecs_set(world, e3, Velocity, {3, 4});
+    ecs_add(world, e3, Tag);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Mass, {100});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 2));
+
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p[0].x, 10); test_int(p[0].y, 20);
+            test_int(p[1].x, 20); test_int(p[1].y, 30);
+
+            Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v[0].x, 1); test_int(v[0].y, 2);
+            test_int(v[1].x, 2); test_int(v[1].y, 3);
+
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e3, it.entities[0]);
+
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 2));
+
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p[0].x, 30); test_int(p[0].y, 40);
+
+            Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v[0].x, 3); test_int(v[0].y, 4);
+
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_trivial_mixed_2_tables_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Mass);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self), ChildOf(self, *), Mass(ent|self)",
+        .flags = EcsQueryIsInstanced,
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add(world, e1, Foo);
+    ecs_add_pair(world, e1, EcsChildOf, TgtA);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add(world, e2, Foo);
+    ecs_add_pair(world, e2, EcsChildOf, TgtA);
+
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_add(world, e3, Foo);
+    ecs_add_pair(world, e3, EcsChildOf, TgtA);
+    ecs_add(world, e3, Tag);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, ent, Mass, {100});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 2));
+
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e3, it.entities[0]);
+
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 2));
+
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Basic_2_trivial_1_unused_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+    ecs_add(world, e, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, Bar",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_2_trivial_one_regular(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e1, TagC);
+
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_add_pair(world, e2, EcsChildOf, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA(self), TagB(self), TagC(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 2));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_1_trivial_one_regular_one_trivial(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e1, TagC);
+
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e2, EcsChildOf, e1);
+    ecs_add(world, e2, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA(self), TagB(self|up), TagC(self)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_one_regular_2_trivial(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e1, TagC);
+
+    ecs_entity_t e2 = ecs_new_w(world, TagB);
+    ecs_add(world, e2, TagC);
+    ecs_add_pair(world, e2, EcsChildOf, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA(self|up), TagB(self), TagC(self)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_2_trivial_w_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w_id(world, EcsPrefab);
+    ecs_add(world, e1, TagA);
+
+    ecs_entity_t e2 = ecs_new_w_id(world, EcsPrefab);
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e2, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA(self), Prefab",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(EcsPrefab, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(EcsPrefab, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_3_trivial_w_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w_id(world, EcsPrefab);
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e1, TagB);
+
+    ecs_entity_t e2 = ecs_new_w_id(world, EcsPrefab);
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e2, TagC);
+
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e3, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA(self), TagB(self), Prefab",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(EcsPrefab, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(EcsPrefab, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_2_trivial_w_disabled(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w_id(world, EcsDisabled);
+    ecs_add(world, e1, TagA);
+
+    ecs_entity_t e2 = ecs_new_w_id(world, EcsDisabled);
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e2, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA(self), Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(EcsDisabled, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(EcsDisabled, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_3_trivial_w_disabled(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w_id(world, EcsDisabled);
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e1, TagB);
+
+    ecs_entity_t e2 = ecs_new_w_id(world, EcsDisabled);
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e2, TagC);
+
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e3, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA(self), TagB(self), Disabled",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(EcsDisabled, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(EcsDisabled, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_2_this_w_fixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+    ecs_add(world, e, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, Bar(e)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e, ecs_field_src(&it, 1));
+
+        test_bool(false, ecs_query_next(&it)); 
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_2_fixed_src_w_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+    ecs_add(world, e, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Bar(e), Foo",
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+
+        test_uint(Bar, ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(false, ecs_query_next(&it)); 
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_2_this_w_fixed_src_no_match_fixed(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, Bar(e)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_2_fixed_src_w_this_no_match_fixed(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Bar(e), Foo",
+        .cache_kind = cache_kind
+    });
+
+    ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_2_this_w_fixed_src_no_match_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+    ecs_add(world, e, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, Bar(e)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_2_fixed_src_w_this_no_match_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+    ecs_add(world, e, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Bar(e), Foo",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_query_count_results(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    test_int(0, ecs_query_count(q).results);
+
+    ecs_new_w(world, TagA);
+
+    test_int(1, ecs_query_count(q).results);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    test_int(1, ecs_query_count(q).results);
+
+    ecs_add(world, e, TagB);
+
+    test_int(2, ecs_query_count(q).results);
+
+    ecs_delete_with(world, TagB);
+
+    test_int(1, ecs_query_count(q).results);
+
+    ecs_delete_with(world, TagA);
+
+    test_int(0, ecs_query_count(q).results);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_query_count_entities(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    test_int(0, ecs_query_count(q).entities);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+
+    test_int(1, ecs_query_count(q).entities);
+
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+
+    test_int(2, ecs_query_count(q).entities);
+
+    ecs_add(world, e2, TagB);
+
+    test_int(2, ecs_query_count(q).entities);
+
+    ecs_delete(world, e1);
+
+    test_int(1, ecs_query_count(q).entities);
+
+    ecs_delete(world, e2);
+
+    test_int(0, ecs_query_count(q).entities);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_query_is_true(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    test_bool(false, ecs_query_is_true(q));
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    test_bool(true, ecs_query_is_true(q));
+
+    ecs_delete(world, e);
+
+    test_bool(false, ecs_query_is_true(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_implicit_cleanup_1_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .entity = ecs_new(world),
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_fini(world);
+}
+
+void Basic_implicit_cleanup_2_terms(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    
+    ecs_add(world, ecs_new_w(world, TagA), TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .entity = ecs_new(world),
+        .expr = "TagA, TagB",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_fini(world);
+}
+
+void Basic_implicit_cleanup_1_term_w_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_new_w_pair(world, EcsChildOf, ecs_new_w(world, TagA));
+
+    ecs_query_t *q = ecs_query(world, {
+        .entity = ecs_new(world),
+        .expr = "TagA(up)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_fini(world);
+}
+
+void Basic_implicit_cleanup_2_terms_w_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_add(world, 
+        ecs_new_w_pair(world, EcsChildOf, 
+            ecs_new_w(world, TagB)), TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .entity = ecs_new(world),
+        .expr = "TagA, TagB(up)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_fini(world);
+}
+
+void Basic_implicit_cleanup_2_queries(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_new_w_pair(world, EcsIsA, ecs_new_w(world, Position));
+
+    ecs_query_t *q_1 = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+    test_assert(q_1 != NULL);
+
+    ecs_query_t *q_2 = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+    test_assert(q_2 != NULL);
+
+    ecs_query_fini(q_1);
+    ecs_query_fini(q_2);
+
+    ecs_fini(world);
+}
+
+void Basic_implicit_cleanup_2_queries_1_cleanup(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+    
+    ecs_new_w_pair(world, EcsIsA, ecs_new_w(world, Position));
+
+    ecs_query_t *q_1 = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+    test_assert(q_1 != NULL);
+
+    ecs_query_t *q_2 = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+    test_assert(q_2 != NULL);
+
+    ecs_query_fini(q_1);
+    ecs_query_fini(q_2);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_valid(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(it.flags & EcsIterIsValid, false);
+
+    test_bool(ecs_query_next(&it), true);
+    test_bool(it.flags & EcsIterIsValid, true);
+
+    test_bool(ecs_query_next(&it), false);
+    test_bool(it.flags & EcsIterIsValid, false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_frame_offset(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_entity_t e4 = ecs_new_w(world, TagA);
+    ecs_entity_t e5 = ecs_new_w(world, TagA);
+
+    ecs_add(world, e3, TagB);
+    ecs_add(world, e4, TagB);
+    ecs_add(world, e5, TagC);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 2);
+    test_int(it.frame_offset, 0);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e1);
+    test_assert(it.entities[1] == e2);
+    test_assert(it.ids[0] == TagA);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 2);
+    test_int(it.frame_offset, 2);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e3);
+    test_assert(it.entities[1] == e4);
+    test_assert(it.ids[0] == TagA);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.frame_offset, 4);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e5);
+    test_assert(it.ids[0] == TagA);
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_iter_nested_1(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_TAG(ecs, Tag);
+    ECS_TAG(ecs, Singleton);
+
+    ecs_query_t *qa = ecs_query(ecs, {
+        .terms = {
+            {Singleton, .src.id = Singleton}, {Tag}
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_query_t *qb = ecs_query(ecs, {
+        .terms = {{Tag}},
+        .cache_kind = cache_kind
+    });
+
+    ecs_singleton_add(ecs, Singleton);
+    ecs_entity_t e = ecs_new_w(ecs, Tag);
+
+    ecs_iter_t qit = ecs_query_iter(ecs, qa);
+    test_bool(true, ecs_query_next(&qit));
+    test_int(1, qit.count);
+    test_uint(e, qit.entities[0]);
+
+    ecs_id_t id = qit.ids[0];
+    ecs_iter_t rit = ecs_query_iter(ecs, qb);
+    test_bool(true, ecs_query_next(&rit));
+    test_int(1, rit.count);
+    test_uint(e, rit.entities[0]);
+    test_bool(false, ecs_query_next(&rit));
+    test_assert(id == qit.ids[0]);
+    test_bool(false, ecs_query_next(&qit));
+
+    ecs_query_fini(qa);
+    ecs_query_fini(qb);
+
+    ecs_fini(ecs);
+}
+
+void Basic_iter_nested_2(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_TAG(ecs, TagA);
+    ECS_TAG(ecs, TagB);
+    ECS_TAG(ecs, Singleton);
+
+    ecs_query_t *qa = ecs_query(ecs, {
+        .terms = {
+            {TagA}, {Singleton, .src.id = Singleton}
+        },
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *qb = ecs_query(ecs, {
+        .terms = {
+            {TagB}, {Singleton, .src.id = Singleton}
+        },
+        .cache_kind = cache_kind
+    });
+
+    ecs_singleton_add(ecs, Singleton);
+
+    ecs_entity_t ea = ecs_new_w(ecs, TagA);
+    ecs_entity_t eb = ecs_new_w(ecs, TagB);
+
+    ecs_iter_t qita = ecs_query_iter(ecs, qa);
+    ecs_iter_t qitb = ecs_query_iter(ecs, qb);
+
+    test_bool(ecs_query_next(&qita), true);
+    test_int(1, qita.count);
+    test_uint(ea, qita.entities[0]);
+
+    test_bool(ecs_query_next(&qitb), true);
+    test_int(1, qitb.count);
+    test_uint(eb, qitb.entities[0]);
+
+    test_uint(TagA, qita.ids[0]);
+    test_uint(TagB, qitb.ids[0]);
+
+    test_bool(ecs_query_next(&qita), false);
+    test_bool(ecs_query_next(&qitb), false);
+
+    ecs_query_fini(qa);
+    ecs_query_fini(qb);
+
+    ecs_fini(ecs);
+}
+
+void Basic_iter_interleaved(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_TAG(ecs, TagA);
+    ECS_TAG(ecs, TagB);
+    ECS_TAG(ecs, TagC);
+    ECS_TAG(ecs, Singleton);
+
+    ecs_query_t *qa = ecs_query(ecs, {
+        .terms = {
+            {TagA}, {Singleton, .src.id = Singleton}
+        },
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *qb = ecs_query(ecs, {
+        .terms = {
+            {TagB}, {Singleton, .src.id = Singleton}
+        },
+        .cache_kind = cache_kind
+    });
+
+    ecs_query_t *qc = ecs_query(ecs, {
+        .terms = {
+            {TagC}, {Singleton, .src.id = Singleton}
+        },
+        .cache_kind = cache_kind
+    });
+
+    ecs_singleton_add(ecs, Singleton);
+
+    ecs_entity_t ea = ecs_new_w(ecs, TagA);
+    ecs_entity_t eb = ecs_new_w(ecs, TagB);
+    ecs_entity_t ec = ecs_new_w(ecs, TagC);
+
+    ecs_iter_t qita = ecs_query_iter(ecs, qa);
+    ecs_iter_t qitb = ecs_query_iter(ecs, qb);
+
+    test_bool(ecs_query_next(&qita), true);
+    test_int(1, qita.count);
+    test_uint(ea, qita.entities[0]);
+
+    test_bool(ecs_query_next(&qitb), true);
+    test_int(1, qitb.count);
+    test_uint(eb, qitb.entities[0]);
+
+    test_uint(TagA, qita.ids[0]);
+    test_uint(TagB, qitb.ids[0]);
+
+    test_bool(ecs_query_next(&qita), false);
+
+    ecs_iter_t qitc = ecs_query_iter(ecs, qc);
+    test_bool(ecs_query_next(&qitc), true);
+    test_int(1, qitc.count);
+    test_uint(ec, qitc.entities[0]);
+
+    test_uint(TagB, qitb.ids[0]);
+    test_uint(TagC, qitc.ids[0]);
+
+    test_bool(ecs_query_next(&qitb), false);
+    test_bool(ecs_query_next(&qitc), false);
+
+    ecs_query_fini(qa);
+    ecs_query_fini(qb);
+    ecs_query_fini(qc);
+
+    ecs_fini(ecs);
+}
+
+void Basic_set_get_context(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+
+    int ctx = 0;
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position) }
+        },
+        .ctx = &ctx,
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    test_assert(q->ctx == &ctx);
+    test_assert(q->binding_ctx == NULL);
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Basic_set_get_binding_context(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+
+    int ctx = 0;
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position) }
+        },
+        .binding_ctx = &ctx,
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    test_assert(q->binding_ctx == &ctx);
+    test_assert(q->ctx == NULL);
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+static int ctx_free_invoked = 0;
+
+static void ctx_free(void *ptr) {
+    *(int*)ptr = 10;
+    ctx_free_invoked ++;
+}
+
+void Basic_set_get_context_w_free(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+
+    int ctx = 0;
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position) }
+        },
+        .ctx = &ctx,
+        .ctx_free = ctx_free,
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    test_assert(q->ctx == &ctx);
+    test_assert(q->binding_ctx == NULL);
+    test_int(ctx, 0);
+
+    test_int(ctx_free_invoked, 0);
+    ecs_query_fini(q);
+    test_int(ctx_free_invoked, 1);
+
+    test_int(ctx, 10);
+
+    ecs_fini(ecs);
+}
+
+void Basic_set_get_binding_context_w_free(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+
+    int ctx = 0;
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position) }
+        },
+        .binding_ctx = &ctx,
+        .binding_ctx_free = ctx_free,
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    test_assert(q->binding_ctx == &ctx);
+    test_assert(q->ctx == NULL);
+    test_int(ctx, 0);
+
+    test_int(ctx_free_invoked, 0);
+    ecs_query_fini(q);
+    test_int(ctx_free_invoked, 1);
+
+    test_int(ctx, 10);
+
+    ecs_fini(ecs);
+}
+
+void Basic_create_query_w_existing_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    if (cache_kind == EcsQueryCacheDefault) {
+        /* Make sure we also test uncached, as the default will create a cached
+         * query if an entity id is provided. */
+        cache_kind = EcsQueryCacheNone;
+    }
+
+    ecs_entity_t e = ecs_entity(world, { .name = "q" });
+
+    ecs_query_t *q_1 = ecs_query(world, {
+        .entity = e,
+        .terms = {
+            { .id = Foo },
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q_1 != NULL);
+
+    ecs_query_t *q_2 = ecs_query(world, {
+        .entity = e,
+        .terms = {
+            { .id = Foo },
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q_2 != NULL);
+    
+    test_str(ecs_get_name(world, e), "q");
+
+    ecs_query_fini(q_2);
+
+    ecs_fini(world);
+}
+
+void Basic_create_multi_component_query_w_existing_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    if (cache_kind == EcsQueryCacheDefault) {
+        /* Make sure we also test uncached, as the default will create a cached
+         * query if an entity id is provided. */
+        cache_kind = EcsQueryCacheNone;
+    }
+
+    ecs_entity_t e = ecs_entity(world, { .name = "q" });
+
+    ecs_query_t *q_1 = ecs_query(world, {
+        .entity = e,
+        .terms = {
+            { .id = Foo },
+            { .id = Bar }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q_1 != NULL);
+
+    ecs_query_t *q_2 = ecs_query(world, {
+        .entity = e,
+        .terms = {
+            { .id = Foo },
+            { .id = Bar },
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q_2 != NULL);
+    
+    test_str(ecs_get_name(world, e), "q");
+
+    ecs_query_fini(q_2);
+
+    ecs_fini(world);
+}
+
+void Basic_create_query_w_existing_entity_different_term_count(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    if (cache_kind == EcsQueryCacheDefault) {
+        /* Make sure we also test uncached, as the default will create a cached
+         * query if an entity id is provided. */
+        cache_kind = EcsQueryCacheNone;
+    }
+
+    ecs_entity_t e = ecs_entity(world, { .name = "q" });
+
+    ecs_query_t *q_1 = ecs_query(world, {
+        .entity = e,
+        .terms = {
+            { .id = Foo },
+            { .id = Bar }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q_1 != NULL);
+
+    ecs_query_t *q_2 = ecs_query(world, {
+        .entity = e,
+        .terms = {
+            { .id = Foo },
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q_2 != NULL);
+    
+    test_str(ecs_get_name(world, e), "q");
+
+    ecs_query_fini(q_2);
+
+    ecs_fini(world);
+}
+
+void Basic_delete_query_by_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "q" });
+    ecs_query_t *q = ecs_query(world, {
+        .entity = e,
+        .expr = "Foo",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_delete(world, e);
+
+    ecs_fini(world);
+}
+
+void Basic_eval_count(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ Foo }},
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    test_int(q->eval_count, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    test_int(q->eval_count, 1);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_no_results_after_delete_tree(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t parent = ecs_new_w(world, Position);
+    test_assert(parent != 0);
+
+    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
+    test_assert(ecs_get_type(world, child) != NULL);
+    ecs_add(world, child, Position);
+
+    ecs_entity_t grand_child = ecs_new_w_pair(world, EcsChildOf, child);
+    test_assert(ecs_get_type(world, grand_child) != NULL);
+    ecs_add(world, grand_child, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    test_int(3, ecs_query_count(q).results);
+
+    ecs_delete(world, parent);
+    
+    test_bool(ecs_is_alive(world, parent), false);
+    test_bool(ecs_is_alive(world, child), false);
+    test_bool(ecs_is_alive(world, grand_child), false);
+
+    test_int(0, ecs_query_count(q).results);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_no_results_after_delete_tree_deferred(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t parent = ecs_new_w(world, Position);
+    test_assert(parent != 0);
+
+    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
+    test_assert(ecs_get_type(world, child) != NULL);
+    ecs_add(world, child, Position);
+
+    ecs_entity_t grand_child = ecs_new_w_pair(world, EcsChildOf, child);
+    test_assert(ecs_get_type(world, grand_child) != NULL);
+    ecs_add(world, grand_child, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+
+    test_int(3, ecs_query_count(q).results);
+
+    ecs_defer_begin(world);
+    ecs_delete(world, parent);
+    ecs_defer_end(world);
+    
+    test_bool(ecs_is_alive(world, parent), false);
+    test_bool(ecs_is_alive(world, child), false);
+    test_bool(ecs_is_alive(world, grand_child), false);
+
+    test_int(0, ecs_query_count(q).results);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Basic_add_on_self_ref(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t qe = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .entity = qe,
+        .terms = {{ TagA, .src.id = qe }},
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    test_assert(ecs_has(world, qe, TagA));
+    test_bool(true, ecs_query_is_true(q));
+
+    ecs_fini(world);
+}
+
+void Basic_add_on_self_ref_by_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t qe = ecs_entity(world, { .name = "q" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .entity = qe,
+        .expr = "TagA(q)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    test_assert(ecs_has(world, qe, TagA));
+    test_bool(true, ecs_query_is_true(q));
+
+    ecs_fini(world);
+}
+
+void Basic_delete_id_after_delete_query(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t i = ecs_new(world);
+    ecs_make_alive(world, i);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = i }},
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    test_int(ecs_query_count(q).entities, 0);
+    ecs_entity_t e = ecs_new_w_id(world, i);
+    test_int(ecs_query_count(q).entities, 1);
+    ecs_delete(world, e);
+    test_int(ecs_query_count(q).entities, 0);
+
+    ecs_query_fini(q);
+
+    ecs_delete(world, i);
+
+    ecs_fini(world);
+}
+
+void Basic_pair_sweep_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    for (ecs_entity_t i = 1023; i < 4097; i ++) {
+        ecs_entity_t i = 1024;
+        test_assert(!ecs_is_alive(world, i));
+        ecs_make_alive(world, i);
+
+        ecs_query_t *q = ecs_query(world, {
+            .terms = {{ .id = i }},
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        test_int(ecs_query_count(q).entities, 0);
+        ecs_entity_t e = ecs_new_w_id(world, i);
+        test_int(ecs_query_count(q).entities, 1);
+        ecs_delete(world, e);
+        test_int(ecs_query_count(q).entities, 0);
+
+        ecs_query_fini(q);
+
+        ecs_delete(world, i);
+    }
+
+    ecs_fini(world);
+}
+
+void Basic_pair_sweep_wildcard_first(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    for (ecs_entity_t i = 1023; i < 4097; i ++) {
+        test_assert(!ecs_is_alive(world, i));
+        ecs_make_alive(world, i);
+
+        ecs_query_t *q = ecs_query(world, {
+            .terms = {{ .id = ecs_pair(EcsWildcard, i) }},
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        test_int(ecs_query_count(q).entities, 0);
+        ecs_entity_t e = ecs_new_w_pair(world, Rel, i);
+        test_int(ecs_query_count(q).entities, 1);
+        ecs_delete(world, e);
+        test_int(ecs_query_count(q).entities, 0);
+
+        ecs_query_fini(q);
+
+        ecs_delete(world, i);
+    }
+
+    ecs_fini(world);
+}
+
+void Basic_pair_sweep_wildcard_second(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tgt);
+
+    for (ecs_entity_t i = 1023; i < 4097; i ++) {
+        test_assert(!ecs_is_alive(world, i));
+        ecs_make_alive(world, i);
+
+        ecs_query_t *q = ecs_query(world, {
+            .terms = {{ .id = ecs_pair(i, EcsWildcard) }}
+        });
+
+        test_assert(q != NULL);
+
+        test_int(ecs_query_count(q).entities, 0);
+        ecs_entity_t e = ecs_new_w_pair(world, i, Tgt);
+        test_int(ecs_query_count(q).entities, 1);
+        ecs_delete(world, e);
+        test_int(ecs_query_count(q).entities, 0);
+
+        ecs_query_fini(q);
+
+        ecs_delete(world, i);
+    }
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/BuiltinPredicates.c b/test/query/src/BuiltinPredicates.c
new file mode 100644
index 000000000..8c6f6d54b
--- /dev/null
+++ b/test/query/src/BuiltinPredicates.c
@@ -0,0 +1,3546 @@
+#include <query.h>
+
+static ecs_query_cache_kind_t cache_kind = EcsQueryCacheDefault;
+
+void BuiltinPredicates_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = EcsQueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+void BuiltinPredicates_this_eq_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == ent",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_eq_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == \"ent\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_eq_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == $x",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_eq_id_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this == ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_eq_id_written_no_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelB($this), $this == ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_eq_name_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this == \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_eq_name_written_no_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelB($this), $this == \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_eq_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add_pair(world, ent_1, RelA, ent_2);
+    ecs_add_pair(world, ent_2, RelA, ent_2);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add_pair(world, ent_3, RelA, ent_2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $x), $this == $x",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+        test_uint(ent_2, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x == ent",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x == \"ent\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x == $y",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_add(world, e1, Bar);
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), $x == $this, Bar($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_id_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x == ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_id_written_no_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelB($x), $x == ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_name_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x == \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_name_written_no_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelB($x), $x == \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add_pair(world, ent_1, RelA, ent_2);
+    ecs_add_pair(world, ent_2, RelA, ent_2);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add_pair(world, ent_3, RelA, ent_2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x, $y), $x == $y",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+        test_uint(ent_2, ecs_iter_get_var(&it, y_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_neq_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$this != ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    bool ent_1_found = false;
+    bool ent_3_found = false;
+    bool ent_4_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    while (ecs_query_next(&it)) {
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != ent_2);
+            if (it.entities[i] == ent_1) {
+                ent_1_found = true;
+            }
+            if (it.entities[i] == ent_3) {
+                ent_3_found = true;
+            }
+            if (it.entities[i] == ent_4) {
+                ent_4_found = true;
+            }
+        }
+    }
+
+    test_bool(ent_1_found, true);
+    test_bool(ent_3_found, true);
+    test_bool(ent_4_found, true);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_neq_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this != \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    bool ent_1_found = false;
+    bool ent_3_found = false;
+    bool ent_4_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != ent_2);
+            if (it.entities[i] == ent_1) {
+                ent_1_found = true;
+            }
+            if (it.entities[i] == ent_3) {
+                ent_3_found = true;
+            }
+            if (it.entities[i] == ent_4) {
+                ent_4_found = true;
+            }
+        }
+    }
+
+    test_bool(ent_1_found, true);
+    test_bool(ent_3_found, true);
+    test_bool(ent_4_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_neq_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this != $x",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_neq_id_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this != ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_neq_id_written_no_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelB($this), $this != ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_neq_name_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this != \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_neq_name_written_no_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelB($this), $this != \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_neq_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add_pair(world, ent_1, RelA, ent_2);
+    ecs_add_pair(world, ent_2, RelA, ent_2);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add_pair(world, ent_3, RelA, ent_2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $x), $this != $x",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_neq_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x != ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    bool ent_1_found = false;
+    bool ent_3_found = false;
+    bool ent_4_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_uint(it.count, 0);
+        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
+        test_assert(e != ent_2);
+        if (e == ent_1) {
+            ent_1_found = true;
+        }
+        if (e == ent_3) {
+            ent_3_found = true;
+        }
+        if (e == ent_4) {
+            ent_4_found = true;
+        }
+    }
+
+    test_bool(ent_1_found, true);
+    test_bool(ent_3_found, true);
+    test_bool(ent_4_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_neq_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x != \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    bool ent_1_found = false;
+    bool ent_3_found = false;
+    bool ent_4_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_uint(it.count, 0);
+        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
+        test_assert(e != ent_2);
+        if (e == ent_1) {
+            ent_1_found = true;
+        }
+        if (e == ent_3) {
+            ent_3_found = true;
+        }
+        if (e == ent_4) {
+            ent_4_found = true;
+        }
+    }
+
+    test_bool(ent_1_found, true);
+    test_bool(ent_3_found, true);
+    test_bool(ent_4_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_neq_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x != $y",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_neq_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tgt);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, Tgt);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add_pair(world, e2, Rel, e2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Rel($this, $x), $x != $this",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(Tgt, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_neq_id_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x != ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_neq_id_written_no_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelB($x), $x != ent_2",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_neq_name_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x != \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_neq_name_written_no_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelB($x), $x != \"ent_2\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_neq_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add_pair(world, ent_1, RelA, ent_2);
+    ecs_add_pair(world, ent_2, RelA, ent_2);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add_pair(world, ent_3, RelA, ent_2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x, $y), $x != $y",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
+        test_uint(ent_2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
+        test_uint(ent_2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_2_neq_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this != ent_2, $this != ent_3",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    bool ent_1_found = false;
+    bool ent_4_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != ent_2);
+            test_assert(it.entities[i] != ent_3);
+            if (it.entities[i] == ent_1) {
+                ent_1_found = true;
+            }
+            if (it.entities[i] == ent_4) {
+                ent_4_found = true;
+            }
+            if (it.entities[i] == ent_5) {
+                ent_5_found = true;
+            }
+        }
+    }
+
+    test_bool(ent_1_found, true);
+    test_bool(ent_4_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_2_neq_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this != \"ent_2\", $this != \"ent_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    bool ent_1_found = false;
+    bool ent_4_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != ent_2);
+            test_assert(it.entities[i] != ent_3);
+            if (it.entities[i] == ent_1) {
+                ent_1_found = true;
+            }
+            if (it.entities[i] == ent_4) {
+                ent_4_found = true;
+            }
+            if (it.entities[i] == ent_5) {
+                ent_5_found = true;
+            }
+        }
+    }
+
+    test_bool(ent_1_found, true);
+    test_bool(ent_4_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_2_neq_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x != ent_2, $x != ent_3",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    bool ent_1_found = false;
+    bool ent_4_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_uint(it.count, 0);
+        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
+        test_assert(e != ent_2);
+        test_assert(e != ent_3);
+        if (e == ent_1) {
+            ent_1_found = true;
+        }
+        if (e == ent_4) {
+            ent_4_found = true;
+        }
+        if (e == ent_5) {
+            ent_5_found = true;
+        }
+    }
+
+    test_bool(ent_1_found, true);
+    test_bool(ent_4_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_2_neq_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x != \"ent_2\", $x != \"ent_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    bool ent_1_found = false;
+    bool ent_4_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_uint(it.count, 0);
+        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
+        test_assert(e != ent_2);
+        test_assert(e != ent_3);
+        if (e == ent_1) {
+            ent_1_found = true;
+        }
+        if (e == ent_4) {
+            ent_4_found = true;
+        }
+        if (e == ent_5) {
+            ent_5_found = true;
+        }
+    }
+
+    test_bool(ent_1_found, true);
+    test_bool(ent_4_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_2_neq_id_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this != ent_2, $this != ent_3",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, it.entities[0]);
+        test_uint(ent_5, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_2_neq_name_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this != \"ent_2\", $this != \"ent_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, it.entities[0]);
+        test_uint(ent_5, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_2_neq_id_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x != ent_2, $x != ent_3",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_2_neq_name_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x != \"ent_2\", $x != \"ent_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_2_or_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    /* ecs_entity_t ent_1 = */ ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    /* ecs_entity_t ent_4 = */ ecs_entity(world, { .name = "ent_4" });
+    /* ecs_entity_t ent_5 = */ ecs_entity(world, { .name = "ent_5" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == ent_2 || $this == ent_3",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_3_or_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    /* ecs_entity_t ent_1 = */ ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    /* ecs_entity_t ent_5 = */ ecs_entity(world, { .name = "ent_5" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == ent_2 || $this == ent_3 || $this == ent_4",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_2_or_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    /* ecs_entity_t ent_1 = */ ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    /* ecs_entity_t ent_4 = */ ecs_entity(world, { .name = "ent_4" });
+    /* ecs_entity_t ent_5 = */ ecs_entity(world, { .name = "ent_5" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == \"ent_2\" || $this == \"ent_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_3_or_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    /* ecs_entity_t ent_1 = */ ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    /* ecs_entity_t ent_5 = */ ecs_entity(world, { .name = "ent_5" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == \"ent_2\" || $this == \"ent_3\" || $this == \"ent_4\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_2_or_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    /* ecs_entity_t ent_1 = */ ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_2_5 = ecs_entity(world, { .name = "ent_25" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_3_5 = ecs_entity(world, { .name = "ent_35" });
+    /* ecs_entity_t ent_4 = */ ecs_entity(world, { .name = "ent_4" });
+    /* ecs_entity_t ent_5 = */ ecs_entity(world, { .name = "ent_5" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this ~= \"ent_2\" || $this ~= \"ent_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2_5, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3_5, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_3_or_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    /* ecs_entity_t ent_1 = */ ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_2_5 = ecs_entity(world, { .name = "ent_25" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_entity_t ent_3_5 = ecs_entity(world, { .name = "ent_35" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_4_5 = ecs_entity(world, { .name = "ent_45" });
+    /* ecs_entity_t ent_5 = */ ecs_entity(world, { .name = "ent_5" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this ~= \"ent_2\" || $this ~= \"ent_3\" || $this ~= \"ent_4\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2_5, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3_5, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_4, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_4_5, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_2_or_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    /* ecs_entity_t ent_1 = */ ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    /* ecs_entity_t ent_4 = */ ecs_entity(world, { .name = "ent_4" });
+    /* ecs_entity_t ent_5 = */ ecs_entity(world, { .name = "ent_5" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x == ent_2 || $x == ent_3",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_2_or_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    /* ecs_entity_t ent_1 = */ ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    /* ecs_entity_t ent_4 = */ ecs_entity(world, { .name = "ent_4" });
+    /* ecs_entity_t ent_5 = */ ecs_entity(world, { .name = "ent_5" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x == \"ent_2\" || $x == \"ent_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_2_or_id_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this == ent_2 || $this == ent_3",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_3_or_id_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this == ent_2 || $this == ent_3 || $this == ent_4",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_2_or_name_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this == \"ent_2\" || $this == \"ent_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_2_or_id_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x == ent_2 || $x == ent_3",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_2_or_name_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent_2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "ent_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent_5" });
+    ecs_add(world, ent_5, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x == \"ent_2\" || $x == \"ent_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_eq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    /* ecs_entity_t ent_2 = */ ecs_entity(world, { .name = "ent2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, Tag);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this ~= \"nt_\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, it.entities[0]);
+        test_uint(ent_4, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_6, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_match_eq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    /* ecs_entity_t ent_2 = */ ecs_entity(world, { .name = "ent2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, Tag);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x ~= \"nt_\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_6, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_eq_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, RelA);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, RelA);
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this ~= \"nt_\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, it.entities[0]);
+        test_uint(ent_4, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_6, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_eq_written_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, RelA);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, RelA);
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA($this|self), $this ~= \"nt_\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, it.entities[0]);
+        test_uint(ent_4, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_6, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_match_eq_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, RelA);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, RelA);
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x ~= \"nt_\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_4, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_6, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_neq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, Tag);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this ~= \"!nt_\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    bool ent_2_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != ent_1);
+            test_assert(it.entities[i] != ent_3);
+            test_assert(it.entities[i] != ent_4);
+            test_assert(it.entities[i] != ent_6);
+            if (it.entities[i] == ent_2) {
+                ent_2_found = true;
+            }
+            if (it.entities[i] == ent_5) {
+                ent_5_found = true;
+            }
+        }
+    }
+
+    test_bool(ent_2_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_match_neq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, Tag);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x ~= \"!nt_\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    bool ent_2_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_uint(it.count, 0);
+        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
+        test_assert(e != ent_1);
+        test_assert(e != ent_3);
+        test_assert(e != ent_4);
+        test_assert(e != ent_6);
+        if (e == ent_2) {
+            ent_2_found = true;
+        }
+        if (e == ent_5) {
+            ent_5_found = true;
+        }
+    }
+
+    test_bool(ent_2_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_neq_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, RelA);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, RelA);
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this ~= \"!nt_\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    bool ent_2_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != ent_1);
+            test_assert(it.entities[i] != ent_3);
+            test_assert(it.entities[i] != ent_4);
+            test_assert(it.entities[i] != ent_6);
+            if (it.entities[i] == ent_2) {
+                ent_2_found = true;
+            }
+            if (it.entities[i] == ent_5) {
+                ent_5_found = true;
+            }
+        }
+    }
+
+    test_bool(ent_2_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_match_neq_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, RelA);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, RelA);
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x ~= \"!nt_\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    bool ent_2_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_uint(it.count, 0);
+        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
+        test_assert(e != ent_1);
+        test_assert(e != ent_3);
+        test_assert(e != ent_4);
+        test_assert(e != ent_6);
+        if (e == ent_2) {
+            ent_2_found = true;
+        }
+        if (e == ent_5) {
+            ent_5_found = true;
+        }
+    }
+
+    test_bool(ent_2_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_2_neq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, Tag);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this ~= \"!nt_\", $this ~= \"!_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    bool ent_2_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != ent_1);
+            test_assert(it.entities[i] != ent_3);
+            test_assert(it.entities[i] != ent_4);
+            test_assert(it.entities[i] != ent_6);
+            if (it.entities[i] == ent_2) {
+                ent_2_found = true;
+            }
+            if (it.entities[i] == ent_5) {
+                ent_5_found = true;
+            }
+        }
+    }
+
+    test_bool(ent_2_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_match_2_neq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, Tag);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x ~= \"!nt_\", $x ~= \"!_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    bool ent_2_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
+        test_assert(e != ent_1);
+        test_assert(e != ent_3);
+        test_assert(e != ent_4);
+        test_assert(e != ent_6);
+        if (e == ent_2) {
+            ent_2_found = true;
+        }
+        if (e == ent_5) {
+            ent_5_found = true;
+        }
+    }
+
+    test_bool(ent_2_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_2_neq_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, RelA);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, RelA);
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this ~= \"!nt_\", $this ~= \"!_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    bool ent_2_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != ent_1);
+            test_assert(it.entities[i] != ent_3);
+            test_assert(it.entities[i] != ent_4);
+            test_assert(it.entities[i] != ent_6);
+            if (it.entities[i] == ent_2) {
+                ent_2_found = true;
+            }
+            if (it.entities[i] == ent_5) {
+                ent_5_found = true;
+            }
+        }
+    }
+
+    test_bool(ent_2_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_match_2_neq_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, RelA);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, RelA);
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x ~= \"!nt_\", $x ~= \"!_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    bool ent_2_found = false;
+    bool ent_5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        ecs_entity_t e = ecs_iter_get_var(&it, x_var);
+        test_assert(e != ent_1);
+        test_assert(e != ent_3);
+        test_assert(e != ent_4);
+        test_assert(e != ent_6);
+        if (e == ent_2) {
+            ent_2_found = true;
+        }
+        if (e == ent_5) {
+            ent_5_found = true;
+        }
+    }
+
+    test_bool(ent_2_found, true);
+    test_bool(ent_5_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_2_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    /* ecs_entity_t ent_2 = */ ecs_entity(world, { .name = "ent2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    /* ecs_entity_t ent_4 = */ ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, Tag);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this ~= \"1\" || $this ~= \"_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_2_or_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, RelA);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, RelA);
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this ~= \"1\" || $this ~= \"_3\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_3_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    /* ecs_entity_t ent_2 = */ ecs_entity(world, { .name = "ent2" });
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    /* ecs_entity_t ent_4 = */ ecs_entity(world, { .name = "ent_4" });
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, Tag);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this ~= \"1\" || $this ~= \"_3\" || $this ~= \"nt_6\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent_6, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_this_match_3_or_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t ent_1 = ecs_entity(world, { .name = "ent_1" });
+    ecs_add(world, ent_1, RelA);
+    ecs_entity_t ent_2 = ecs_entity(world, { .name = "ent2" });
+    ecs_add(world, ent_2, RelA);
+    ecs_entity_t ent_3 = ecs_entity(world, { .name = "nt_3" });
+    ecs_add(world, ent_3, RelA);
+    ecs_entity_t ent_4 = ecs_entity(world, { .name = "ent_4" });
+    ecs_add(world, ent_4, RelA);
+    ecs_entity_t ent_5 = ecs_entity(world, { .name = "ent5" });
+    ecs_add(world, ent_5, RelA);
+    ecs_entity_t ent_6 = ecs_entity(world, { .name = "ent_6" });
+    ecs_add(world, ent_6, RelA);
+    ecs_add(world, ent_6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $this ~= \"1\" || $this ~= \"_3\" || $this ~= \"nt_6\"",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(false, ecs_field_is_set(&it, 1));
+        test_uint(ent_6, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_unresolved_by_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == ent",
+        .cache_kind = cache_kind,
+        .flags = EcsQueryAllowUnresolvedByName
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(false, ecs_field_is_set(&it, 0));
+        test_uint(ent, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_entity_t tgt = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x == *, (Rel, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(tgt, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_entity_t tgt = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x == _, (Rel, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(tgt, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_wildcard_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_entity_t tgt = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, $x), $x == *",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(tgt, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_any_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_entity_t tgt = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, $x), $x == _",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(tgt, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_var_eq_after_var_0_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x(), $x == flecs",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(EcsFlecs, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_2_or_w_eq_lookup_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Hello);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    ecs_entity_t child1 = ecs_entity(world, { .name = "hello" });
+    ecs_add_pair(world, child1, EcsChildOf, e1);
+    ecs_add(world, child1, Bar);
+
+    ecs_entity_t child2 = ecs_entity(world, { .name = "world" });
+    ecs_add_pair(world, child2, EcsChildOf, e2);
+    ecs_add(world, child2, Bar);
+
+    ecs_entity_t child3_1 = ecs_entity(world, { .name = "hello" });
+    ecs_add_pair(world, child3_1, EcsChildOf, e3);
+    ecs_add(world, child3_1, Bar);
+
+    ecs_entity_t child3_2 = ecs_entity(world, { .name = "world" });
+    ecs_add_pair(world, child3_2, EcsChildOf, e3);
+    ecs_add(world, child3_2, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), $x == $this.hello || $x == $this.world, Bar($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int hello_var = ecs_query_find_var(q, "this.hello");
+    test_assert(hello_var != -1);
+
+    int world_var = ecs_query_find_var(q, "this.world");
+    test_assert(world_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(child1, ecs_iter_get_var(&it, x_var));
+    test_uint(child1, ecs_iter_get_var(&it, hello_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(child2, ecs_iter_get_var(&it, x_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, hello_var));
+    test_uint(child2, ecs_iter_get_var(&it, world_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(child3_1, ecs_iter_get_var(&it, x_var));
+    test_uint(child3_1, ecs_iter_get_var(&it, hello_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_3_or_w_eq_lookup_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Hello);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_entity_t e4 = ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    ecs_entity_t child1 = ecs_entity(world, { .name = "hello" });
+    ecs_add_pair(world, child1, EcsChildOf, e1);
+    ecs_add(world, child1, Bar);
+
+    ecs_entity_t child2 = ecs_entity(world, { .name = "world" });
+    ecs_add_pair(world, child2, EcsChildOf, e2);
+    ecs_add(world, child2, Bar);
+
+    ecs_entity_t child3_1 = ecs_entity(world, { .name = "hello" });
+    ecs_add_pair(world, child3_1, EcsChildOf, e3);
+    ecs_add(world, child3_1, Bar);
+
+    ecs_entity_t child3_2 = ecs_entity(world, { .name = "world" });
+    ecs_add_pair(world, child3_2, EcsChildOf, e3);
+    ecs_add(world, child3_2, Bar);
+
+    ecs_entity_t child4 = ecs_entity(world, { .name = "zoo" });
+    ecs_add_pair(world, child4, EcsChildOf, e4);
+    ecs_add(world, child4, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), $x == $this.hello || $x == $this.world || $x == $this.zoo, Bar($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int hello_var = ecs_query_find_var(q, "this.hello");
+    test_assert(hello_var != -1);
+
+    int world_var = ecs_query_find_var(q, "this.world");
+    test_assert(world_var != -1);
+
+    int zoo_var = ecs_query_find_var(q, "this.zoo");
+    test_assert(zoo_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(child1, ecs_iter_get_var(&it, x_var));
+    test_uint(child1, ecs_iter_get_var(&it, hello_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, zoo_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(child2, ecs_iter_get_var(&it, x_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, hello_var));
+    test_uint(child2, ecs_iter_get_var(&it, world_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, zoo_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(child3_1, ecs_iter_get_var(&it, x_var));
+    test_uint(child3_1, ecs_iter_get_var(&it, hello_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, zoo_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(child4, ecs_iter_get_var(&it, x_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, hello_var));
+    test_uint(EcsWildcard, ecs_iter_get_var(&it, world_var));
+    test_uint(child4, ecs_iter_get_var(&it, zoo_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void BuiltinPredicates_2_or_w_eq_this(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, Rel, e1);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add_pair(world, e2, Rel, e1);
+
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_add_pair(world, e3, Rel, Rel);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel($this, $x), $x == $this || $x == Rel",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+    
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_pair(Rel, e1), ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_pair(Rel, Rel), ecs_field_id(&it, 0));
+        test_uint(true, ecs_field_is_set(&it, 0));
+        test_uint(Rel, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/Cached.c b/test/query/src/Cached.c
new file mode 100644
index 000000000..a45caa782
--- /dev/null
+++ b/test/query/src/Cached.c
@@ -0,0 +1,3667 @@
+#include <query.h>
+#include <stdlib.h>
+
+void Cached_simple_query_existing_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_simple_query_2_existing_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_simple_query_new_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_simple_query_2_new_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_simple_query_existing_and_new_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_wildcard_query_existing_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, ObjA);
+    ECS_TAG(world, ObjB);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, *)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_wildcard_query_new_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, ObjA);
+    ECS_TAG(world, ObjB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, *)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_wildcard_query_existing_table_2_results_p_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, ObjA);
+    ECS_TAG(world, ObjB);
+    ECS_TAG(world, ObjC);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
+    ecs_add_pair(world, e1, Rel, ObjC);
+    ecs_add_pair(world, e2, Rel, ObjC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, *)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjC), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjC), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_wildcard_query_new_table_2_results_p_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, ObjA);
+    ECS_TAG(world, ObjB);
+    ECS_TAG(world, ObjC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, *)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, ObjA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, ObjB);
+    ecs_add_pair(world, e1, Rel, ObjC);
+    ecs_add_pair(world, e2, Rel, ObjC);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjC), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjB), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, ObjC), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_wildcard_query_2nd_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add_pair(world, e1, Rel, TgtA);
+    ecs_add_pair(world, e1, Rel, TgtB);
+
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_add_pair(world, e2, Rel, TgtA);
+
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add_pair(world, e3, Rel, TgtA);
+    ecs_add_pair(world, e3, Rel, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ Tag }, { ecs_pair(Rel, EcsWildcard) }},
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtB), it.ids[1]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtC), it.ids[1]);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_wildcard_query_2nd_term_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add_pair(world, e1, Rel, TgtA);
+    ecs_add_pair(world, e1, Rel, TgtB);
+
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_add_pair(world, e2, Rel, TgtA);
+
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add_pair(world, e3, Rel, TgtA);
+    ecs_add_pair(world, e3, Rel, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ Tag }, { ecs_pair(Rel, EcsWildcard), .src.id = EcsSelf }},
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtB), it.ids[1]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtA), it.ids[1]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Tag, it.ids[0]);
+    test_uint(ecs_pair(Rel, TgtC), it.ids[1]);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_simple_query_existing_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_add(world, e1, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_remove(world, e1, TagB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_simple_query_existing_empty_type(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_PREFAB(world, TypeX, TagA, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_add(world, e1, TagB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_simple_query_new_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_add(world, e1, TagB);
+    ecs_remove(world, e1, TagB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_component_query_existing_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_assert(ecs_field_size(&it, 0) == sizeof(Position));
+    test_assert(ecs_field(&it, Position, 0) != NULL);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_component_query_new_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e = ecs_new_w(world, Position);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_assert(ecs_field(&it, Position, 0) != NULL);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_component_query_existing_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e = ecs_new_w(world, Position);
+    ecs_add(world, e, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_remove(world, e, TagA);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_assert(ecs_field(&it, Position, 0) != NULL);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_2_component_query_existing_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+    ECS_PREFAB(world, MyType, Position, Velocity);
+
+    ecs_entity_t e = ecs_new_w(world, Position);
+    ecs_add(world, e, Velocity);
+    ecs_add(world, e, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_remove(world, e, Tag);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_assert(ecs_field(&it, Position, 0) != NULL);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_2_component_query_existing_empty_type(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_PREFAB(world, MyType, Position, Velocity);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e = ecs_new_w(world, Position);
+    ecs_add(world, e, Velocity);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_assert(ecs_field(&it, Position, 0) != NULL);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_only_optional(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+    int32_t count = 0;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        if (ecs_field_is_set(&it, 0)) {
+            test_assert(count == 0);
+            test_int(it.count, 1);
+            test_uint(it.entities[0], e);
+            count ++;
+        }
+    }
+
+    test_int(count, 1);
+
+
+    ecs_fini(world);
+}
+
+void Cached_only_optional_new_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    int32_t count = 0, total_count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        if (ecs_field_is_set(&it, 0)) {
+            test_assert(count == 0);
+            test_int(it.count, 1);
+            test_uint(it.entities[0], e);
+            count ++;
+        }
+        total_count ++;
+    }
+
+    test_int(count, 1);
+    test_assert(total_count >= count);
+
+    int32_t prev_total_count = total_count;
+    total_count = 0;
+
+    ecs_remove(world, e, TagA);
+
+    it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(!ecs_field_is_set(&it, 0));
+        test_assert(it.count > 0);
+        total_count ++;
+    }
+
+    test_assert(total_count == (prev_total_count - 1));
+
+
+    ecs_fini(world);
+}
+
+void Cached_only_optional_new_empty_non_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+    ecs_add(world, e, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    int32_t count = 0, total_count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        if (ecs_field_is_set(&it, 0)) {
+            test_assert(count == 0);
+            test_int(it.count, 1);
+            test_uint(it.entities[0], e);
+            count ++;
+        }
+        total_count ++;
+    }
+
+    test_int(count, 1);
+    test_assert(total_count >= count);
+
+    int32_t prev_total_count = total_count;
+    count = 0; total_count = 0;
+
+    ecs_remove(world, e, TagA);
+    ecs_table_t *table = ecs_get_table(world, e);
+
+    it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(!ecs_field_is_set(&it, 0));
+        test_assert(it.count > 0);
+        total_count ++;
+        if (it.entities[0] == e) {
+            test_assert(table == it.table);
+            count ++;
+        }
+    }
+
+    test_int(count, 1);
+    test_assert(total_count == prev_total_count);
+
+
+    ecs_fini(world);
+}
+
+void Cached_only_optional_new_unset_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+    ecs_add(world, e, TagB);
+    ecs_table_t *table = ecs_get_table(world, e);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?TagC",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    int32_t count = 0, total_count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(!ecs_field_is_set(&it, 0));
+        test_assert(it.count > 0);
+        if (it.entities[0] == e) {
+            test_assert(table == it.table);
+            count ++;
+        }
+        total_count ++;
+    }
+
+    test_int(count, 1);
+    test_assert(total_count >= count);
+
+    int32_t prev_total_count = total_count;
+    count = 0; total_count = 0;
+
+    ecs_remove(world, e, TagA);
+    table = ecs_get_table(world, e);
+
+    it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(!ecs_field_is_set(&it, 0));
+        test_assert(it.count > 0);
+        total_count ++;
+        if (it.entities[0] == e) {
+            test_assert(table == it.table);
+            count ++;
+        }
+    }
+
+    test_int(count, 1);
+    test_assert(total_count == prev_total_count);
+
+
+    ecs_fini(world);
+}
+
+void Cached_singleton_w_optional_new_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Singleton);
+    ECS_TAG(world, TagA);
+
+    ecs_singleton_add(world, Singleton);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+    ecs_set_name(world, e, "e");
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Singleton($), ?TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    int32_t count = 0, total_count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        if (ecs_field_is_set(&it, 1)) {
+            test_assert(count == 0);
+            test_int(it.count, 1);
+            test_uint(it.entities[0], e);
+            count ++;
+        }
+        total_count ++;
+    }
+
+    test_int(count, 1);
+    test_assert(total_count >= count);
+
+    int32_t prev_total_count = total_count;
+    total_count = 0;
+
+    ecs_remove(world, e, TagA);
+
+    it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(!ecs_field_is_set(&it, 1));
+        test_assert(it.count > 0);
+        total_count ++;
+    }
+
+    test_assert(total_count == (prev_total_count - 1));
+
+
+    ecs_fini(world);
+}
+
+void Cached_singleton_w_optional_new_empty_non_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Singleton);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_singleton_add(world, Singleton);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+    ecs_add(world, e, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Singleton($), ?TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    int32_t count = 0, total_count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        if (ecs_field_is_set(&it, 1)) {
+            test_assert(count == 0);
+            test_int(it.count, 1);
+            test_uint(it.entities[0], e);
+            count ++;
+        }
+        total_count ++;
+    }
+
+    test_int(count, 1);
+    test_assert(total_count >= count);
+
+    int32_t prev_total_count = total_count;
+    count = 0; total_count = 0;
+
+    ecs_remove(world, e, TagA);
+    ecs_table_t *table = ecs_get_table(world, e);
+
+    it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(!ecs_field_is_set(&it, 1));
+        test_assert(it.count > 0);
+        total_count ++;
+        if (it.entities[0] == e) {
+            test_assert(table == it.table);
+            count ++;
+        }
+    }
+
+    test_int(count, 1);
+    test_assert(total_count == prev_total_count);
+
+
+    ecs_fini(world);
+}
+
+void Cached_singleton_w_optional_new_unset_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Singleton);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_singleton_add(world, Singleton);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+    ecs_add(world, e, TagB);
+    ecs_table_t *table = ecs_get_table(world, e);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Singleton($), ?TagC",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    int32_t count = 0, total_count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(!ecs_field_is_set(&it, 1));
+        test_assert(it.count > 0);
+        if (it.entities[0] == e) {
+            test_assert(table == it.table);
+            count ++;
+        }
+        total_count ++;
+    }
+
+    test_int(count, 1);
+    test_assert(total_count >= count);
+
+    int32_t prev_total_count = total_count;
+    count = 0; total_count = 0;
+
+    ecs_remove(world, e, TagA);
+    table = ecs_get_table(world, e);
+
+    it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(!ecs_field_is_set(&it, 1));
+        test_assert(it.count > 0);
+        total_count ++;
+        if (it.entities[0] == e) {
+            test_assert(table == it.table);
+            count ++;
+        }
+    }
+
+    test_int(count, 1);
+    test_assert(total_count == prev_total_count);
+
+
+    ecs_fini(world);
+}
+
+void Cached_query_w_from_entity_match_after(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e" });
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, TagB(e)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_add(world, e1, TagB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(ecs_field_src(&it, 0), 0);
+    test_uint(ecs_field_id(&it, 0), TagA);
+    test_uint(ecs_field_src(&it, 1), e1);
+    test_uint(ecs_field_id(&it, 1), TagB);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_query_w_from_singleton_match_after(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, TagB($)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_singleton_add(world, TagB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(ecs_field_src(&it, 0), 0);
+    test_uint(ecs_field_id(&it, 0), TagA);
+    test_uint(ecs_field_src(&it, 1), TagB);
+    test_uint(ecs_field_id(&it, 1), TagB);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_rematch_after_add_to_recycled_parent(void) {
+    ecs_world_t *world = ecs_mini();
+    
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t parent = ecs_new(world);
+    test_assert(parent != 0);
+
+    ecs_delete(world, parent);
+    test_assert( !ecs_is_alive(world, parent));
+
+    parent = ecs_new(world);
+    test_assert(parent != 0);
+
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, parent);
+    test_assert(e != 0);
+    test_assert( ecs_has_pair(world, e, EcsChildOf, parent));
+    ecs_add(world, e, Tag);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_set(world, parent, Position, {10, 20});
+
+    ecs_run_aperiodic(world, 0);
+
+    it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+
+    const Position *p = ecs_field(&it, Position, 1);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    test_assert(ecs_field_src(&it, 1) == parent);
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_fini(world);
+}
+
+void Cached_query_rematch_optional_after_add(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base = ecs_new(world);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add_pair(world, e1, EcsIsA, base);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, Velocity);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, ?Velocity(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    /* First iteration, base doesn't have Velocity but query should match with
+     * entity anyway since the component is optional */
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    
+    while (ecs_query_next(&it)) {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        
+        test_int(it.count, 1);
+        test_assert(p != NULL);
+        
+        if (it.entities[0] == e1) {
+            test_assert(v == NULL);
+        } else if (it.entities[0] == e2) {
+            test_assert(v == NULL);
+        } else if (it.entities[0] == e3) {
+            test_assert(v == NULL);
+        }
+
+        count ++;
+    }
+
+    test_int(count, 3);
+
+    /* Add Velocity to base, should trigger rematch */
+    ecs_add(world, base, Velocity);
+
+    /* Trigger a merge, which triggers the rematch */
+    ecs_readonly_begin(world, false);
+    ecs_readonly_end(world);
+
+    /* Second iteration, base has Velocity and entity should be able to access
+     * the shared component. */
+    it = ecs_query_iter(world, q);
+    count = 0;
+    
+    while (ecs_query_next(&it)) {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        
+        test_int(it.count, 1);
+        test_assert(p != NULL);
+        
+        if (it.entities[0] == e1) {
+            test_assert(ecs_field_is_set(&it, 1));
+            test_assert(v != NULL);
+        } else if (it.entities[0] == e2) {
+            test_assert(!ecs_field_is_set(&it, 1));
+        } else if (it.entities[0] == e3) {
+            test_assert(!ecs_field_is_set(&it, 1));
+        }
+
+        count ++;
+    }
+    test_int(count, 3);
+
+
+    ecs_fini(world);    
+}
+
+void Cached_get_owned_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e = ecs_new_w(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    int count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(ecs_field_w_size(&it, 0, 0) == NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e);
+        count += it.count;
+    }
+
+    test_int(count, 1);
+
+
+    ecs_fini(world);
+}
+
+void Cached_get_shared_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t instance = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    int count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(ecs_field_w_size(&it, 0, 0) == NULL);
+        test_int(it.count, 1);
+        test_int(it.entities[0], instance);
+        count += it.count;
+    }
+
+    test_int(count, 1);
+
+
+    ecs_fini(world);
+}
+
+void Cached_explicit_delete(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    /* Ensure query isn't deleted twice when deleting world */
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cached_get_column_size(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(ecs_query_next(&it));
+    test_int(ecs_field_size(&it, 0), sizeof(Position));
+    test_assert(!ecs_query_next(&it));
+
+
+    ecs_fini(world);    
+}
+
+void Cached_stresstest_query_free(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Hello);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add(world, e, Foo);
+    ecs_add(world, e, Bar);
+    ecs_add(world, e, Hello);
+
+    /* Create & delete query to test if query is properly unregistered with
+     * the table */
+
+    for (int i = 0; i < 10000; i ++) {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "Foo",
+            .cache_kind = EcsQueryCacheAuto
+        });
+        ecs_query_fini(q);
+    }
+
+    /* If code did not crash, test passes */
+    test_assert(true);
+
+    ecs_fini(world);
+}
+
+void Cached_query_optional_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, ?TagB",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    
+    while (ecs_query_next(&it)) {    
+        test_uint(ecs_field_id(&it, 0), TagA);
+        test_assert(ecs_field_id(&it, 1) == TagB);
+        test_int(it.count, 1);
+
+        if (it.entities[0] == e1) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), false); 
+        } else if (it.entities[0] == e2) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true); 
+        }
+
+        count ++;
+    }
+
+    test_int(count, 2);
+
+
+    ecs_fini(world);
+}
+
+void Cached_query_optional_shared_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e2, TagB);
+    
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, EcsIsA, e2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, ?TagB(self|up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    
+    while (ecs_query_next(&it)) {    
+        test_uint(ecs_field_id(&it, 0), TagA);
+        test_assert(ecs_field_id(&it, 1) == TagB);
+        test_int(it.count, 1);
+
+        if (it.entities[0] == e1) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), false); 
+        } else if (it.entities[0] == e2) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true); 
+        } else if (it.entities[0] == e3) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true);
+        }
+
+        count ++;
+    }
+
+    test_int(count, 3);
+
+
+    ecs_fini(world);
+}
+
+void Cached_query_iter_10_tags(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, TagD);
+    ECS_TAG(world, TagE);
+    ECS_TAG(world, TagF);
+    ECS_TAG(world, TagG);
+    ECS_TAG(world, TagH);
+    ECS_TAG(world, TagI);
+    ECS_TAG(world, TagJ);
+    ECS_TAG(world, TagK);
+
+    ecs_entity_t e_1 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_1, TagB);
+    ecs_add_id(world, e_1, TagC);
+    ecs_add_id(world, e_1, TagD);
+    ecs_add_id(world, e_1, TagE);
+    ecs_add_id(world, e_1, TagF);
+    ecs_add_id(world, e_1, TagG);
+    ecs_add_id(world, e_1, TagH);
+    ecs_add_id(world, e_1, TagI);
+    ecs_add_id(world, e_1, TagJ);
+    
+    ecs_entity_t e_2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e_2, TagB);
+    ecs_add_id(world, e_2, TagC);
+    ecs_add_id(world, e_2, TagD);
+    ecs_add_id(world, e_2, TagE);
+    ecs_add_id(world, e_2, TagF);
+    ecs_add_id(world, e_2, TagG);
+    ecs_add_id(world, e_2, TagH);
+    ecs_add_id(world, e_2, TagI);
+    ecs_add_id(world, e_2, TagJ);
+    ecs_add_id(world, e_2, TagK); /* 2nd match in different table */
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {TagA}, {TagB}, {TagC}, {TagD}, {TagE}, {TagF}, {TagG}, {TagH}, 
+            {TagI}, {TagJ}
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_int(ecs_field_id(&it, 1), TagB);
+    test_int(ecs_field_id(&it, 2), TagC);
+    test_int(ecs_field_id(&it, 3), TagD);
+    test_int(ecs_field_id(&it, 4), TagE);
+    test_int(ecs_field_id(&it, 5), TagF);
+    test_int(ecs_field_id(&it, 6), TagG);
+    test_int(ecs_field_id(&it, 7), TagH);
+    test_int(ecs_field_id(&it, 8), TagI);
+    test_int(ecs_field_id(&it, 9), TagJ);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_2);
+    test_int(ecs_field_id(&it, 0), TagA);
+    test_int(ecs_field_id(&it, 1), TagB);
+    test_int(ecs_field_id(&it, 2), TagC);
+    test_int(ecs_field_id(&it, 3), TagD);
+    test_int(ecs_field_id(&it, 4), TagE);
+    test_int(ecs_field_id(&it, 5), TagF);
+    test_int(ecs_field_id(&it, 6), TagG);
+    test_int(ecs_field_id(&it, 7), TagH);
+    test_int(ecs_field_id(&it, 8), TagI);
+    test_int(ecs_field_id(&it, 9), TagJ);
+
+    test_assert(!ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+typedef struct {
+    float v;
+} CompA, CompB, CompC, CompD, CompE, CompF, CompG, CompH, CompI, CompJ, CompK,
+  CompL, CompM, CompN, CompO, CompP, CompQ, CompR, CompS, CompT, CompU;
+
+void Cached_query_iter_10_components(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, CompA);
+    ECS_COMPONENT(world, CompB);
+    ECS_COMPONENT(world, CompC);
+    ECS_COMPONENT(world, CompD);
+    ECS_COMPONENT(world, CompE);
+    ECS_COMPONENT(world, CompF);
+    ECS_COMPONENT(world, CompG);
+    ECS_COMPONENT(world, CompH);
+    ECS_COMPONENT(world, CompI);
+    ECS_COMPONENT(world, CompJ);
+    ECS_COMPONENT(world, CompK);
+
+    ecs_entity_t e_1 = ecs_insert(world, ecs_value(CompA, {10}));
+    ecs_set(world, e_1, CompB, {10});
+    ecs_set(world, e_1, CompC, {10});
+    ecs_set(world, e_1, CompD, {10});
+    ecs_set(world, e_1, CompE, {10});
+    ecs_set(world, e_1, CompF, {10});
+    ecs_set(world, e_1, CompG, {10});
+    ecs_set(world, e_1, CompH, {10});
+    ecs_set(world, e_1, CompI, {10});
+    ecs_set(world, e_1, CompJ, {10});
+    
+    ecs_entity_t e_2 = ecs_insert(world, ecs_value(CompA, {10}));
+    ecs_set(world, e_2, CompB, {10});
+    ecs_set(world, e_2, CompC, {10});
+    ecs_set(world, e_2, CompD, {10});
+    ecs_set(world, e_2, CompE, {10});
+    ecs_set(world, e_2, CompF, {10});
+    ecs_set(world, e_2, CompG, {10});
+    ecs_set(world, e_2, CompH, {10});
+    ecs_set(world, e_2, CompI, {10});
+    ecs_set(world, e_2, CompJ, {10});
+    ecs_set(world, e_2, CompK, {10});
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {ecs_id(CompA)}, {ecs_id(CompB)}, {ecs_id(CompC)}, {ecs_id(CompD)}, 
+            {ecs_id(CompE)}, {ecs_id(CompF)}, {ecs_id(CompG)}, {ecs_id(CompH)}, 
+            {ecs_id(CompI)}, {ecs_id(CompJ)}
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_1);
+    test_int(ecs_field_id(&it, 0), ecs_id(CompA));
+    test_int(ecs_field_id(&it, 1), ecs_id(CompB));
+    test_int(ecs_field_id(&it, 2), ecs_id(CompC));
+    test_int(ecs_field_id(&it, 3), ecs_id(CompD));
+    test_int(ecs_field_id(&it, 4), ecs_id(CompE));
+    test_int(ecs_field_id(&it, 5), ecs_id(CompF));
+    test_int(ecs_field_id(&it, 6), ecs_id(CompG));
+    test_int(ecs_field_id(&it, 7), ecs_id(CompH));
+    test_int(ecs_field_id(&it, 8), ecs_id(CompI));
+    test_int(ecs_field_id(&it, 9), ecs_id(CompJ));
+
+    int i;
+    for (i = 0; i < 10; i ++) {
+        CompA *ptr = ecs_field_w_size(&it, 0, i);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].v, 10);
+    }
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e_2);
+    test_int(ecs_field_id(&it, 0), ecs_id(CompA));
+    test_int(ecs_field_id(&it, 1), ecs_id(CompB));
+    test_int(ecs_field_id(&it, 2), ecs_id(CompC));
+    test_int(ecs_field_id(&it, 3), ecs_id(CompD));
+    test_int(ecs_field_id(&it, 4), ecs_id(CompE));
+    test_int(ecs_field_id(&it, 5), ecs_id(CompF));
+    test_int(ecs_field_id(&it, 6), ecs_id(CompG));
+    test_int(ecs_field_id(&it, 7), ecs_id(CompH));
+    test_int(ecs_field_id(&it, 8), ecs_id(CompI));
+    test_int(ecs_field_id(&it, 9), ecs_id(CompJ));
+
+    for (i = 0; i < 10; i ++) {
+        CompA *ptr = ecs_field_w_size(&it, 0, i);
+        test_assert(ptr != NULL);
+        test_int(ptr[0].v, 10);
+    }
+
+    test_assert(!ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_iter_type_set(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t e = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e);
+    test_assert(it.table != NULL);
+    const ecs_type_t *type = ecs_table_get_type(it.table);
+    test_int(type->count, 1);
+    test_int(type->array[0], ecs_id(Position));
+
+    test_assert(!ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_filter_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = ecs_id(Position), .inout = EcsInOutNone }},
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_bool(ecs_query_next(&it), true);
+    test_assert(it.ids != NULL);
+    test_assert(it.ids[0] == ecs_id(Position));
+
+    test_int(it.count, 1);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e);
+
+    test_assert(it.ptrs != NULL);
+    test_assert(it.columns != NULL);
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_fini(world);
+}
+
+void Cached_2_terms_1_filter(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .id = ecs_id(Position), .inout = EcsInOutNone },
+            { .id = ecs_id(Velocity) }
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_set(world, e, Velocity, {1, 1});
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_bool(ecs_query_next(&it), true);
+    test_assert(it.ids != NULL);
+    test_assert(it.ids[0] == ecs_id(Position));
+    test_assert(it.ids[1] == ecs_id(Velocity));
+
+    test_int(it.count, 1);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e);
+
+    test_assert(it.ptrs != NULL);
+    test_assert(it.sizes != NULL);
+    test_assert(it.columns != NULL);
+
+    test_assert(it.ptrs[0] == NULL);
+    test_assert(it.ptrs[1] != NULL);
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_fini(world);
+}
+
+void Cached_3_terms_2_filter(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .id = ecs_id(Position), .inout = EcsInOutNone },
+            { .id = ecs_id(Velocity), .inout = EcsInOutNone },
+            { .id = ecs_id(Mass) }
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_set(world, e, Velocity, {1, 1});
+    ecs_set(world, e, Mass, {1});
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_bool(ecs_query_next(&it), true);
+    test_assert(it.ids != NULL);
+    test_assert(it.ids[0] == ecs_id(Position));
+    test_assert(it.ids[1] == ecs_id(Velocity));
+    test_assert(it.ids[2] == ecs_id(Mass));
+
+    test_int(it.count, 1);
+    test_assert(it.entities != NULL);
+    test_assert(it.entities[0] == e);
+
+    test_assert(it.ptrs != NULL);
+    test_assert(it.sizes != NULL);
+    test_assert(it.columns != NULL);
+
+    test_assert(it.ptrs[0] == NULL);
+    test_assert(it.ptrs[1] == NULL);
+    test_assert(it.ptrs[2] != NULL);
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_fini(world);
+}
+
+void Cached_no_instancing_w_singleton(void) {
+    ecs_world_t *world = ecs_mini();
+    
+    ECS_TAG(world, Tag);
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_singleton_set(world, Velocity, {1, 2});
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {40, 50}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {50, 60}));
+
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity($)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e1);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e2);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e3);
+        test_int(p->x, 30);
+        test_int(p->y, 40);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e4);
+        test_int(p->x, 40);
+        test_int(p->y, 50);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(ecs_query_next(&it));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(it.count, 1);
+        test_int(it.entities[0], e5);
+        test_int(p->x, 50);
+        test_int(p->y, 60);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_add_singleton_after_query(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA },
+            { TagB, .src.id = TagB }
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add(world, e, TagA);
+    
+    ecs_singleton_add(world, TagB);
+    test_assert(ecs_has(world, TagB, TagB));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool (ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e);
+    test_bool (ecs_query_next(&it), false);
+
+    ecs_singleton_remove(world, TagB);
+    test_assert(!ecs_has(world, TagB, TagB));
+
+    it = ecs_query_iter(world, q);
+    test_bool (ecs_query_next(&it), false);
+
+    ecs_fini(world);
+}
+
+void Cached_query_w_component_from_parent_from_non_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t parent = ecs_new_w(world, TagB);
+    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA },
+            { TagB, .src.id = child|EcsUp, .trav = EcsChildOf }
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add(world, e, TagA);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool (ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e);
+    test_int(it.sources[0], 0);
+    test_int(it.sources[1], parent);
+    test_bool (ecs_query_next(&it), false);
+
+    ecs_remove_pair(world, child, EcsChildOf, parent);
+    it = ecs_query_iter(world, q);
+    test_bool (ecs_query_next(&it), false);
+
+    ecs_fini(world);
+}
+
+void Cached_create_query_while_pending(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ TagA }},
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_add(world, e, TagB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert( ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_int(it.entities[0], e);
+
+    test_assert( !ecs_query_next(&it));
+    
+    ecs_fini(world);
+}
+
+void Cached_empty_query(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 0 }},
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+
+    ecs_fini(world);
+}
+
+void Cached_implicit_existing_isa_superset(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], base);
+    test_uint(it.sources[0], 0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_implicit_new_isa_superset(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], base);
+    test_uint(it.sources[0], 0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_superset(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_superset_2_lvls(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], base);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], base);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_superset_3_lvls(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
+    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], base);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], base);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], base);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_superset_2_lvls_owned(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
+
+    ecs_add(world, e1, Tag);
+    ecs_add(world, e2, Tag);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], base);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e1);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_superset_3_lvls_owned(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
+    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
+
+    ecs_add(world, e1, Tag);
+    ecs_add(world, e2, Tag);
+    ecs_add(world, e3, Tag);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], base);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e1);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e2);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_superset_owned_empty_table_after_match(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
+    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, e2);
+
+    ecs_add(world, e1, Tag);
+    ecs_add(world, e2, Tag);
+    ecs_add(world, e3, Tag);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], base);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e1);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e2);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove_pair(world, e3, EcsIsA, e2);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], base);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e1);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_self_superset(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(self|up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], base);
+    test_uint(it.sources[0], 0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_childof_superset(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_superset_2_targets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, R, Traversable);
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e_0 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e_1 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e_2 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_entity_t e_3 = ecs_insert(world, ecs_value(Position, {70, 80}));
+
+    ecs_add_pair(world, e_3, R, e_2);
+    ecs_add_pair(world, e_2, R, e_1);
+    ecs_add_pair(world, e_1, R, e_0);
+
+    ecs_entity_t t = ecs_new(world);
+    ecs_add(world, t, Position);
+    ecs_add_pair(world, t, R, e_2);
+    ecs_add_pair(world, t, R, e_1);
+    ecs_delete(world, t);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up R)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e_1);
+        test_uint(it.sources[0], e_0);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e_3);
+        test_uint(it.sources[0], e_2);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p[0].x, 50);
+        test_int(p[0].y, 60);
+    }
+
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e_2);
+        test_uint(it.sources[0], e_1);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_superset_2_relations(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .id = TagA, .trav = EcsChildOf, .src.id = EcsUp },
+            { .id = TagA, .trav = EcsIsA, .src.id = EcsUp },
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_entity_t base = ecs_new_w(world, TagA);
+    ecs_entity_t parent = ecs_new_w(world, TagA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, EcsIsA, base);
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add_pair(world, e2, EcsIsA, base);
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(e2, it.entities[1]);
+    test_uint(parent, it.sources[0]);
+    test_uint(base, it.sources[1]);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_superset_2_relations_instanced(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .id = TagA, .trav = EcsChildOf, .src.id = EcsUp },
+            { .id = TagA, .trav = EcsIsA, .src.id = EcsUp },
+        },
+        .flags = EcsQueryIsInstanced,
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_entity_t base = ecs_new_w(world, TagA);
+    ecs_entity_t parent = ecs_new_w(world, TagA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, EcsIsA, base);
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add_pair(world, e2, EcsIsA, base);
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(e2, it.entities[1]);
+    test_uint(parent, it.sources[0]);
+    test_uint(base, it.sources[1]);
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_superset_2_relations_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .id = ecs_id(Position), .trav = EcsChildOf, .src.id = EcsUp },
+            { .id = ecs_id(Position), .trav = EcsIsA, .src.id = EcsUp },
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, EcsIsA, base);
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add_pair(world, e2, EcsIsA, base);
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(parent, it.sources[0]);
+        test_uint(base, it.sources[1]);
+        Position *p1 = ecs_field(&it, Position, 0);
+        Position *p2 = ecs_field(&it, Position, 1);
+        test_assert(p1 != NULL);
+        test_assert(p2 != NULL);
+        test_int(p1->x, 30);
+        test_int(p1->y, 40);
+        test_int(p2->x, 10);
+        test_int(p2->y, 20);
+    }
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(parent, it.sources[0]);
+        test_uint(base, it.sources[1]);
+        Position *p1 = ecs_field(&it, Position, 0);
+        Position *p2 = ecs_field(&it, Position, 1);
+        test_assert(p1 != NULL);
+        test_assert(p2 != NULL);
+        test_int(p1->x, 30);
+        test_int(p1->y, 40);
+        test_int(p2->x, 10);
+        test_int(p2->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_superset_2_relations_instanced_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .id = ecs_id(Position), .trav = EcsChildOf, .src.id = EcsUp },
+            { .id = ecs_id(Position), .trav = EcsIsA, .src.id = EcsUp },
+        },
+        .flags = EcsQueryIsInstanced,
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, EcsIsA, base);
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add_pair(world, e2, EcsIsA, base);
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(2, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(parent, it.sources[0]);
+        test_uint(base, it.sources[1]);
+        Position *p1 = ecs_field(&it, Position, 0);
+        Position *p2 = ecs_field(&it, Position, 1);
+        test_assert(p1 != NULL);
+        test_assert(p2 != NULL);
+        test_int(p1->x, 30);
+        test_int(p1->y, 40);
+        test_int(p2->x, 10);
+        test_int(p2->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+
+    ecs_fini(world);
+}
+
+void Cached_parent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t base = ecs_new_w(world, Tag);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_not_pair_relation_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, ObjA);
+    ECS_TAG(world, ObjB);
+    
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, !(*, ObjA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_entity_t e4 = ecs_new_w(world, Foo);
+
+    ecs_add_pair(world, e1, RelA, ObjA);
+    ecs_add_pair(world, e2, RelA, ObjB);
+    ecs_add_pair(world, e3, RelB, ObjA);
+    ecs_add_pair(world, e4, RelB, ObjB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(ecs_field_id(&it, 1), ecs_pair(EcsWildcard, ObjA));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e4);
+    test_uint(ecs_field_id(&it, 1), ecs_pair(EcsWildcard, ObjA));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_not_pair_object_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, ObjA);
+    ECS_TAG(world, ObjB);
+    
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, !(RelA, *)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_entity_t e4 = ecs_new_w(world, Foo);
+
+    ecs_add_pair(world, e1, RelA, ObjA);
+    ecs_add_pair(world, e2, RelA, ObjB);
+    ecs_add_pair(world, e3, RelB, ObjA);
+    ecs_add_pair(world, e4, RelB, ObjB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(ecs_field_id(&it, 1), ecs_pair(RelA, EcsWildcard));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e4);
+    test_uint(ecs_field_id(&it, 1), ecs_pair(RelA, EcsWildcard));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_two_pair_wildcards_one_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, ObjA);
+    ECS_TAG(world, ObjB);
+    
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (RelA, *), !(RelB, *)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_entity_t e4 = ecs_new_w(world, Foo);
+
+    ecs_add_pair(world, e1, RelA, ObjA);
+    ecs_add_pair(world, e1, RelB, ObjA);
+
+    ecs_add_pair(world, e2, RelA, ObjA);
+
+    ecs_add_pair(world, e3, RelA, ObjB);
+    ecs_add_pair(world, e3, RelB, ObjB);
+
+    ecs_add_pair(world, e4, RelA, ObjB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_uint(ecs_field_id(&it, 1), ecs_pair(RelA, ObjA));
+    test_uint(ecs_field_id(&it, 2), ecs_pair(RelB, EcsWildcard));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e4);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_uint(ecs_field_id(&it, 1), ecs_pair(RelA, ObjB));
+    test_uint(ecs_field_id(&it, 2), ecs_pair(RelB, EcsWildcard));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_two_pair_wildcards_one_not_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, ObjA);
+    ECS_TAG(world, ObjB);
+    
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (RelA, *), !(RelB, _)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_entity_t e4 = ecs_new_w(world, Foo);
+
+    ecs_add_pair(world, e1, RelA, ObjA);
+    ecs_add_pair(world, e1, RelB, ObjA);
+
+    ecs_add_pair(world, e2, RelA, ObjA);
+
+    ecs_add_pair(world, e3, RelA, ObjB);
+    ecs_add_pair(world, e3, RelB, ObjB);
+
+    ecs_add_pair(world, e4, RelA, ObjB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_uint(ecs_field_id(&it, 1), ecs_pair(RelA, ObjA));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e4);
+    test_uint(ecs_field_id(&it, 0), Foo);
+    test_uint(ecs_field_id(&it, 1), ecs_pair(RelA, ObjB));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_rematch(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base_1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_uint(it.entities[0], base_1);
+    test_uint(it.entities[1], base_2);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 30);
+    test_int(p[1].y, 40);
+    test_uint(it.sources[0], 0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_uint(it.sources[0], base_1);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove_pair(world, inst, EcsIsA, base_1);
+    ecs_add_pair(world, inst, EcsIsA, base_2);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_uint(it.entities[0], base_1);
+    test_uint(it.entities[1], base_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 30);
+    test_int(p[1].y, 40);
+    test_uint(it.sources[0], 0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_uint(it.sources[0], base_2);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_childof_rematch(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base_1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_uint(it.sources[0], base_1);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_add_pair(world, inst, EcsChildOf, base_2);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_uint(it.sources[0], base_2);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_unmatch(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base_1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_uint(it.entities[0], base_1);
+    test_uint(it.entities[1], base_2);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 30);
+    test_int(p[1].y, 40);
+    test_uint(it.sources[0], 0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_uint(it.sources[0], base_1);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove(world, base_1, Position);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], base_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_uint(it.sources[0], 0);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_childof_unmatch(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base_1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_uint(it.sources[0], base_1);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove(world, base_1, Position);
+
+    it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_isa_rematch_2_lvls(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t base = ecs_new_w_pair(world, EcsIsA, base_1);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_uint(it.entities[0], base_1);
+    test_uint(it.entities[1], base_2);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 30);
+    test_int(p[1].y, 40);
+    test_uint(it.sources[0], 0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], base);
+    test_uint(it.sources[0], base_1);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base_1);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove_pair(world, base, EcsIsA, base_1);
+    ecs_add_pair(world, base, EcsIsA, base_2);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_uint(it.entities[0], base_1);
+    test_uint(it.entities[1], base_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 30);
+    test_int(p[1].y, 40);
+    test_uint(it.sources[0], 0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], base);
+    test_uint(it.sources[0], base_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_childof_rematch_2_lvls(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t base = ecs_new_w_pair(world, EcsChildOf, base_1);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], base);
+    test_uint(it.sources[0], base_1);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base_1);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_add_pair(world, base, EcsChildOf, base_2);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], base);
+    test_uint(it.sources[0], base_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_childof_rematch_from_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t base = ecs_new_w_pair(world, EcsIsA, base_1);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsChildOf, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base_1);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove_pair(world, base, EcsIsA, base_1);
+    ecs_add_pair(world, base, EcsIsA, base_2);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_uint(it.sources[0], base_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_rematch_optional_ref(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, ?Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t child = ecs_new_w(world, Tag);
+    ecs_add_pair(world, child, EcsChildOf, parent);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_uint(0, it.sources[0]);
+    test_uint(parent, it.sources[1]);
+    Position *p = ecs_field(&it, Position, 1);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove(world, parent, Position);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_uint(0, it.sources[0]);
+    test_uint(0, it.sources[1]);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_rematch_optional_ref_w_2_refs(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, Velocity(up), ?Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_set(world, parent, Velocity, {1, 2});
+    ecs_entity_t child = ecs_new_w(world, Tag);
+    ecs_add_pair(world, child, EcsChildOf, parent);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_uint(0, it.sources[0]);
+    test_uint(parent, it.sources[1]);
+    Velocity *v = ecs_field(&it, Velocity, 1);
+    test_assert(v != NULL);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+    Position *p = ecs_field(&it, Position, 2);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove(world, parent, Position);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_uint(0, it.sources[0]);
+    test_uint(parent, it.sources[1]);
+    test_uint(0, it.sources[2]);
+    v = ecs_field(&it, Velocity, 1);
+    test_assert(v != NULL);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_rematch_optional_ref_tag_w_ref_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, ?Position(up), TagB(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_add(world, parent, TagB);
+
+    ecs_entity_t child = ecs_new_w(world, TagA);
+    ecs_add_pair(world, child, EcsChildOf, parent);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_uint(0, it.sources[0]);
+    test_uint(parent, it.sources[1]);
+    test_uint(parent, it.sources[2]);
+    Position *p = ecs_field(&it, Position, 1);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove(world, parent, Position);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_uint(0, it.sources[0]);
+    test_uint(0, it.sources[1]);
+    test_uint(parent, it.sources[2]);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_match_query_expr_from_scope(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t foo = ecs_entity_init(world, &(ecs_entity_desc_t){
+        .name = "Foo"
+    });
+
+    ecs_entity_t bar = ecs_entity_init(world, &(ecs_entity_desc_t){
+        .name = "Foo.Bar"
+    });
+
+    ecs_set_scope(world, foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Bar",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_set_scope(world, 0);
+
+    ecs_entity_t e = ecs_new_w_id(world, bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(bar, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_query_long_or_w_ref(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ECS_TAG(world, A);
+    ECS_TAG(world, B);
+    ECS_TAG(world, C);
+    ECS_TAG(world, D);
+    ECS_TAG(world, E);
+    ECS_TAG(world, F);
+    ECS_TAG(world, G);
+    ECS_TAG(world, H);
+    ECS_TAG(world, I);
+    ECS_TAG(world, J);
+    ECS_TAG(world, K);
+    ECS_TAG(world, L);
+    ECS_TAG(world, M);
+    ECS_TAG(world, N);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+    ecs_set(world, e, Position, {10, 20});
+
+    ecs_entity_t e2 = ecs_new_w(world, A);
+
+    ecs_query_t *q = ecs_query(world, {
+       .expr = 
+        "Position(e), A || B || C || D || E || F || G || H || I || J || K || L ||"
+        "M || N",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(A, ecs_field_id(&it, 1));
+    test_uint(e2, it.entities[0]);
+    test_uint(e, it.sources[0]);
+    test_uint(0, it.sources[1]);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_query_w_pair_id_and_subj(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Obj);
+    ECS_TAG(world, Subj);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{
+            .id = ecs_pair(Rel, Obj), .src.id = Subj
+        }},
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_add_pair(world, Subj, Rel, Obj);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 0);
+    test_uint(it.sources[0], Subj);
+    test_uint(it.ids[0], ecs_pair(Rel, Obj));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cached_rematch_after_delete_inherited_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t tag = ecs_new(world);
+    ecs_entity_t base = ecs_new_w_id(world, tag);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .id = tag }
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(base, it.entities[0]);
+    test_uint(tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(tag, ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_delete_with(world, tag);
+
+    it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cached_rematch_after_delete_rel_of_inherited_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t obj = ecs_new(world);
+    ecs_entity_t base = ecs_new_w_pair(world, rel, obj);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .id = ecs_pair(rel, obj) }
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(base, it.entities[0]);
+    test_uint(ecs_pair(rel, obj), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(ecs_pair(rel, obj), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_delete_with(world, ecs_pair(rel, EcsWildcard));
+
+    it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_rematch_after_delete_obj_of_inherited_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t rel = ecs_new(world);
+    ecs_entity_t obj = ecs_new(world);
+    ecs_entity_t base = ecs_new_w_pair(world, rel, obj);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .id = ecs_pair(rel, obj) }
+        },
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(base, it.entities[0]);
+    test_uint(ecs_pair(rel, obj), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(ecs_pair(rel, obj), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_delete_with(world, ecs_pair(EcsWildcard, obj));
+
+    it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_rematch_empty_table_w_superset(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ Foo }, { Bar, .oper = EcsNot }},
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_entity_t base = ecs_new_w_id(world, EcsPrefab);
+    ecs_add(world, base, Foo);
+    test_assert( ecs_is_alive(world, base));
+
+    ecs_delete_with(world, Foo);
+    test_assert( !ecs_is_alive(world, base));
+
+    base = ecs_new_w_id(world, EcsPrefab);
+    ecs_add(world, base, Foo);
+
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_add(world, inst, Bar);
+
+    ecs_run_aperiodic(world, 0); // force table (IsA, base) to empty list
+
+    ecs_remove(world, inst, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], inst);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void Cached_2_self_up_terms_new_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag, Foo(self|up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t parent_a = ecs_entity(world, {0});
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity_t e_3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e_2)) });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_b, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Cached_this_self_up_childof_pair_new_tables(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(self|up, Tgt)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t p0 = ecs_new(world);
+    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, Tgt);
+    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, Tgt);
+    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, Tgt);
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, p1);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, p1);
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, p2);
+    ecs_entity_t e4 = ecs_new_w_pair(world, EcsChildOf, p2);
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_new_w_pair(world, EcsChildOf, e2);
+    ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, e2);
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, p3);
+
+    ecs_new_w_pair(world, EcsChildOf, p0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/Cascade.c b/test/query/src/Cascade.c
new file mode 100644
index 000000000..e04f33e83
--- /dev/null
+++ b/test/query/src/Cascade.c
@@ -0,0 +1,1762 @@
+#include <query.h>
+
+void Cascade_this_self_cascade_childof_uncached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_new(world);
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self|cascade)",
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Cascade_this_cascade_childof_uncached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(cascade)",
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t p0 = ecs_new(world);
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Cascade_this_written_self_cascade_childof_uncached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(self|cascade)",
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_new(world);
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Cascade_this_written_cascade_childof_uncached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(cascade)",
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_new(world);
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Cascade_this_self_cascade_childof_w_parent_flag_uncached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self|cascade)",
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t p0 = ecs_new(world);
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Cascade_this_cascade_childof_w_parent_flag_uncached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(cascade)",
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t p0 = ecs_new(world);
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Cascade_this_written_self_cascade_childof_w_parent_flag_uncached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(self|cascade)",
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Cascade_this_written_cascade_childof_w_parent_flag_uncached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(cascade)",
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_new(world);
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Cascade_existing_isa_cascade(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(EcsIsA, e0)) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(EcsIsA, e1)) });
+    ecs_entity_t e3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(EcsIsA, e2)) });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_add_id(world, e1, Bar); /* mix up order */
+    ecs_add_id(world, e2, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e0);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_new_isa_cascade(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(EcsIsA, e0)) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(EcsIsA, e1)) });
+    ecs_entity_t e3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(EcsIsA, e2)) });
+
+    ecs_add_id(world, e2, Foo); /* mix up order */
+    ecs_add_id(world, e1, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e0);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_childof_cascade(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_entity(world, { .parent = e0 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = e1 });
+    ecs_entity_t e3 = ecs_entity(world, { .parent = e2 });
+
+    ecs_add_id(world, e2, Foo); /* mix up order */
+    ecs_add_id(world, e1, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e0);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_parent_cascade(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_entity(world, { .parent = e0 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = e1 });
+    ecs_entity_t e3 = ecs_entity(world, { .parent = e2 });
+
+    ecs_add_id(world, e2, Foo); /* mix up order */
+    ecs_add_id(world, e1, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e0);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_existing_custom_rel_cascade(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_ENTITY(world, Rel, Traversable);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, e0)) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, e1)) });
+    ecs_entity_t e3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, e2)) });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade Rel)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_add_id(world, e2, Foo); /* mix up order */
+    ecs_add_id(world, e1, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e0);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_new_custom_rel_cascade(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_ENTITY(world, Rel, Traversable);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade Rel)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, e0)) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, e1)) });
+    ecs_entity_t e3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, e2)) });
+
+    ecs_add_id(world, e2, Foo); /* mix up order */
+    ecs_add_id(world, e1, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e0);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_w_2_depths(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_ENTITY(world, Rel, Traversable);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade Rel)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, Rel, e0);
+    ecs_add_pair(world, e2, Rel, e1);
+    ecs_add_pair(world, e3, Rel, e2);
+
+    ecs_add_id(world, e2, Foo); /* mix up order */
+    ecs_add_id(world, e1, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e1);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e1);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_w_3_depths(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_ENTITY(world, Rel, Traversable);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade Rel)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, Rel, e0);
+    ecs_add_pair(world, e2, Rel, e1);
+    ecs_add_pair(world, e3, Rel, e2);
+
+    ecs_add_id(world, e2, Foo); /* mix up order */
+    ecs_add_id(world, e1, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e1);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e2);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_w_2_depths_desc(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_ENTITY(world, Rel, Traversable);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade|desc Rel)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, Rel, e0);
+    ecs_add_pair(world, e2, Rel, e1);
+    ecs_add_pair(world, e3, Rel, e2);
+
+    ecs_add_id(world, e2, Foo); /* mix up order */
+    ecs_add_id(world, e1, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e1);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e1);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_w_3_depths_desc(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_ENTITY(world, Rel, Traversable);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag(cascade|desc Rel)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, Rel, e0);
+    ecs_add_pair(world, e2, Rel, e1);
+    ecs_add_pair(world, e3, Rel, e2);
+
+    ecs_add_id(world, e2, Foo); /* mix up order */
+    ecs_add_id(world, e1, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e3);
+    test_uint(it.sources[0], e2);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    test_uint(it.sources[0], e1);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(it.sources[0], e0);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_rematch_2_lvls(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e_0 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e_1 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e_2 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_entity_t e_3 = ecs_insert(world, ecs_value(Position, {70, 80}));
+    ecs_add_pair(world, e_3, EcsChildOf, e_2);
+
+    ecs_add_pair(world, e_2, EcsChildOf, e_1);
+    ecs_add_pair(world, e_1, EcsChildOf, e_0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(cascade)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e_1);
+        test_uint(it.sources[0], e_0);
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_int(p[0].x, 10);
+            test_int(p[0].y, 20);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e_2);
+        test_uint(it.sources[0], e_1);
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_int(p[0].x, 30);
+            test_int(p[0].y, 40);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e_3);
+        test_uint(it.sources[0], e_2);
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_int(p[0].x, 50);
+            test_int(p[0].y, 60);
+            test_bool(false, ecs_query_next(&it));
+        }
+    }
+
+    ecs_remove_pair(world, e_1, EcsChildOf, EcsWildcard);
+    ecs_remove_pair(world, e_2, EcsChildOf, EcsWildcard);
+    ecs_remove_pair(world, e_3, EcsChildOf, EcsWildcard);
+
+    ecs_add_pair(world, e_0, EcsChildOf, e_1);
+    ecs_add_pair(world, e_1, EcsChildOf, e_2);
+    ecs_add_pair(world, e_2, EcsChildOf, e_3);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e_2);
+        test_uint(it.sources[0], e_3);
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_int(p[0].x, 70);
+            test_int(p[0].y, 80);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e_1);
+        test_uint(it.sources[0], e_2);
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_int(p[0].x, 50);
+            test_int(p[0].y, 60);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e_0);
+        test_uint(it.sources[0], e_1);
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_int(p[0].x, 30);
+            test_int(p[0].y, 40);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_rematch_2_lvls_2_relations(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, R, Traversable);
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e_0 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e_1 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e_2 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_entity_t e_3 = ecs_insert(world, ecs_value(Position, {70, 80}));
+
+    ecs_add_pair(world, e_3, R, e_2);
+    ecs_add_pair(world, e_2, R, e_1);
+    ecs_add_pair(world, e_1, R, e_0);
+
+    ecs_entity_t t = ecs_new(world);
+    ecs_add(world, t, Position);
+    ecs_add_pair(world, t, R, e_2);
+    ecs_add_pair(world, t, R, e_1);
+    ecs_delete(world, t);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(cascade R)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_1);
+    test_uint(it.sources[0], e_0);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_2);
+    test_uint(it.sources[0], e_1);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_3);
+    test_uint(it.sources[0], e_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 50);
+    test_int(p[0].y, 60);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_topological(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, R, Traversable);
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+
+    ecs_add_pair(world, e3, R, e1);
+    ecs_add_pair(world, e3, R, e2);
+    ecs_add_pair(world, e3, R, e4);
+    ecs_add_pair(world, e1, R, e5);
+    ecs_add_pair(world, e2, R, e6);
+    ecs_add_pair(world, e4, R, e1);
+    ecs_add_pair(world, e4, R, e2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, ?Tag(cascade R)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(it.entities[0], e5);
+    test_uint(it.entities[1], e6);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(it.entities[0], e1);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(it.entities[0], e2);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(it.entities[0], e4);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(it.entities[0], e3);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_desc_rematch_2_lvls(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e_0 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e_1 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e_2 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_entity_t e_3 = ecs_insert(world, ecs_value(Position, {70, 80}));
+    
+    ecs_add_pair(world, e_3, EcsChildOf, e_2);
+    ecs_add_pair(world, e_2, EcsChildOf, e_1);
+    ecs_add_pair(world, e_1, EcsChildOf, e_0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(cascade|desc)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_3);
+    test_uint(it.sources[0], e_2);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 50);
+    test_int(p[0].y, 60);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_2);
+    test_uint(it.sources[0], e_1);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_1);
+    test_uint(it.sources[0], e_0);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_remove_pair(world, e_1, EcsChildOf, EcsWildcard);
+    ecs_remove_pair(world, e_2, EcsChildOf, EcsWildcard);
+    ecs_remove_pair(world, e_3, EcsChildOf, EcsWildcard);
+
+    ecs_add_pair(world, e_0, EcsChildOf, e_1);
+    ecs_add_pair(world, e_1, EcsChildOf, e_2);
+    ecs_add_pair(world, e_2, EcsChildOf, e_3);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_0);
+    test_uint(it.sources[0], e_1);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_1);
+    test_uint(it.sources[0], e_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 50);
+    test_int(p[0].y, 60);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_2);
+    test_uint(it.sources[0], e_3);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 70);
+    test_int(p[0].y, 80);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_desc_rematch_2_lvls_2_relations(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, R, Traversable);
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e_0 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e_1 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e_2 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_entity_t e_3 = ecs_insert(world, ecs_value(Position, {70, 80}));
+
+    ecs_add_pair(world, e_3, R, e_2);
+    ecs_add_pair(world, e_2, R, e_1);
+    ecs_add_pair(world, e_1, R, e_0);
+
+    ecs_entity_t t = ecs_new(world);
+    ecs_add(world, t, Position);
+    ecs_add_pair(world, t, R, e_2);
+    ecs_add_pair(world, t, R, e_1);
+    ecs_delete(world, t);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(cascade|desc R)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_3);
+    test_uint(it.sources[0], e_2);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 50);
+    test_int(p[0].y, 60);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_2);
+    test_uint(it.sources[0], e_1);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_1);
+    test_uint(it.sources[0], e_0);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_desc_topological(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, R, Traversable);
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+
+    ecs_add_pair(world, e3, R, e1);
+    ecs_add_pair(world, e3, R, e2);
+    ecs_add_pair(world, e3, R, e4);
+    ecs_add_pair(world, e1, R, e5);
+    ecs_add_pair(world, e2, R, e6);
+    ecs_add_pair(world, e4, R, e1);
+    ecs_add_pair(world, e4, R, e2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, ?Tag(cascade|desc R)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(it.entities[0], e3);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(it.entities[0], e4);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(it.entities[0], e1);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(it.entities[0], e2);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(it.entities[0], e5);
+    test_uint(it.entities[1], e6);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Cascade_cascade_after_recycled_parent_change(void) {
+    ecs_world_t *world = ecs_mini();
+    
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, ?Position(cascade)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t parent = ecs_new(world);
+    test_assert(parent != 0);
+    ecs_entity_t child = ecs_new(world);
+    test_assert(child != 0);
+
+    ecs_delete(world, parent);
+    test_assert( !ecs_is_alive(world, parent));
+    ecs_delete(world, child);
+    test_assert( !ecs_is_alive(world, child));
+
+    parent = ecs_new_w_id(world, Tag);
+    test_assert(parent != 0);
+    child = ecs_new_w_id(world, Tag);
+    test_assert(child != 0);
+    ecs_add_pair(world, child, EcsChildOf, parent);
+
+    ecs_entity_t e = ecs_new_w_id(world, Tag);
+    test_assert(e != 0);
+
+    ecs_add_pair(world, e, EcsChildOf, child);
+    test_assert( ecs_has_pair(world, e, EcsChildOf, child));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_uint(it.entities[0], parent);
+    test_assert(ecs_field_src(&it, 1) == 0);
+    const Position *p = ecs_field(&it, Position, 1);
+    test_assert(p == NULL);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_uint(it.entities[0], child);
+    test_assert(ecs_field_src(&it, 1) == 0);
+    p = ecs_field(&it, Position, 1);
+    test_assert(p == NULL);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e);
+    test_assert(ecs_field_src(&it, 1) == 0);
+    p = ecs_field(&it, Position, 1);
+    test_assert(p == NULL);
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_set(world, parent, Position, {10, 20});
+    ecs_set(world, child, Position, {20, 30});
+
+    ecs_run_aperiodic(world, 0);
+
+    it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_uint(it.entities[0], parent);
+    test_assert(ecs_field_is_set(&it, 1) == false);
+    p = ecs_field(&it, Position, 1);
+    test_assert(p == NULL);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_uint(it.entities[0], child);
+    test_assert(ecs_field_src(&it, 1) == parent);
+    p = ecs_field(&it, Position, 1);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e);
+    test_assert(ecs_field_src(&it, 1) == child);
+    p = ecs_field(&it, Position, 1);
+    test_assert(p != NULL);
+    test_int(p->x, 20);
+    test_int(p->y, 30);
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/ChangeDetection.c b/test/query/src/ChangeDetection.c
new file mode 100644
index 000000000..2765742a6
--- /dev/null
+++ b/test/query/src/ChangeDetection.c
@@ -0,0 +1,1470 @@
+#include <query.h>
+
+void ChangeDetection_query_changed_after_new(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_new_w(world, Position);
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_after_delete(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_delete(world, e1);
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_after_add(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t e1 = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_add(world, e1, Position);
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_after_remove(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_remove(world, e1, Position);
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_after_set(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, e1, Position, {10, 20});
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_after_modified(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_modified(world, e1, Position);
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+static int sys_invoked = 0;
+void Sys(ecs_iter_t *it) { 
+    sys_invoked ++;
+}
+
+void ChangeDetection_query_change_after_out_system(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ECS_SYSTEM(world, Sys, EcsOnUpdate, [out] Position);
+
+    ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_progress(world, 0);
+    test_int(sys_invoked, 1);
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+
+    test_int(sys_invoked, 1);
+}
+
+void ChangeDetection_query_change_after_in_system(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ECS_SYSTEM(world, Sys, EcsOnUpdate, [in] Position);
+    
+    ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_progress(world, 0);
+    test_bool(false, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_changed(q));
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_after_modified_out_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    
+    ecs_entity_t e = ecs_new_w(world, Position);
+    ecs_add(world, e, Velocity);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position, [out] Velocity",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, e, Position, {10, 20});
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, e, Velocity, {1, 2});
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_check_iter(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e3, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { 
+        test_bool(ecs_iter_changed(&it), true);
+    }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_modified(world, e1, Position);
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e1);
+    test_bool(ecs_iter_changed(&it), true);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e2);
+    test_bool(ecs_iter_changed(&it), false);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+    test_bool(ecs_iter_changed(&it), false);
+    test_bool(ecs_query_changed(q), false);
+    test_bool(ecs_query_next(&it), false);
+
+    it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { 
+        test_bool(ecs_iter_changed(&it), false);
+    }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_modified(world, e2, Position);
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e1);
+    test_bool(ecs_iter_changed(&it), false);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e2);
+    test_bool(ecs_iter_changed(&it), true);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+    test_bool(ecs_iter_changed(&it), false);
+    test_bool(ecs_query_changed(q), false);
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_check_iter_after_skip_read(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t e = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, e, Position, {10, 20});
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_assert(ecs_iter_changed(&it) == true);
+    ecs_iter_skip(&it);
+    test_bool(ecs_query_next(&it), false);
+
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_assert(ecs_iter_changed(&it) == true);
+    test_bool(ecs_query_next(&it), false);
+    test_bool(false, ecs_query_changed(q));
+    
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_check_iter_after_skip_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_new_w(world, Position);
+
+    ecs_query_t *qw = ecs_query(world, {
+        .expr = "[out] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, qw);
+    test_bool(false, ecs_query_changed(q));
+    test_bool(ecs_query_next(&it), true);
+    test_bool(false, ecs_query_changed(q));
+    ecs_iter_skip(&it);
+    test_bool(ecs_query_next(&it), false);
+    test_bool(false, ecs_query_changed(q));
+
+    test_bool(false, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, qw);
+    test_bool(false, ecs_query_changed(q));
+    test_bool(ecs_query_next(&it), true);
+    test_bool(false, ecs_query_changed(q));
+    test_bool(ecs_query_next(&it), false);
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_assert(ecs_iter_changed(&it) == true);
+    test_bool(ecs_query_next(&it), false);
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_parent_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t parent = ecs_new_w(world, Position);
+    ecs_new_w_pair(world, EcsChildOf, parent);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(q != NULL);
+
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, parent, Position, {10, 20});
+
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_assert(ecs_iter_changed(&it) == true);
+    test_bool(ecs_query_next(&it), false);
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_prefab_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t base = ecs_new_w(world, Position);
+    ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, base, Position, {10, 20});
+
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_assert(ecs_iter_changed(&it) == true);
+    test_bool(ecs_query_next(&it), false);
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_parent_term_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t parent = ecs_new_w(world, Position);
+    ecs_add_id(world, parent, EcsPrefab);
+    ecs_new_w_pair(world, EcsChildOf, parent);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position(up), ?Prefab",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, parent, Position, {10, 20});
+
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_assert(ecs_iter_changed(&it) == true);
+    test_bool(ecs_query_next(&it), false);
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_prefab_term_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_entity_t base = ecs_new_w(world, Position);
+    ecs_add_id(world, base, EcsPrefab);
+    ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position(up IsA)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    test_bool(true, ecs_query_changed(q));
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_changed(q));
+    while (ecs_query_next(&it)) { }
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, base, Position, {10, 20});
+
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_assert(ecs_iter_changed(&it) == true);
+    test_bool(ecs_query_next(&it), false);
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_change_skip_non_instanced(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+    
+    ecs_entity_t base = ecs_new_w(world, Position);
+    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_add(world, e1, Velocity);
+    ecs_add(world, e2, Velocity);
+    ecs_add(world, e3, Velocity);
+    ecs_add(world, e4, Velocity);
+
+    ecs_add(world, e3, Tag);
+    ecs_add(world, e4, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up IsA), [out] Velocity",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    ecs_query_t *q_r = ecs_query(world, {
+        .expr = "Position(up IsA), [in] Velocity",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q_r != NULL);
+
+    test_assert(ecs_query_changed(q_r) == true);
+    ecs_iter_t it = ecs_query_iter(world, q_r);
+    while (ecs_query_next(&it)) { }
+    test_assert(ecs_query_changed(q_r) == false);
+
+    it = ecs_query_iter(world, q);
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_int(it.count, 1);
+
+        if (it.entities[0] == e1) {
+            ecs_iter_skip(&it); /* Skip one entity in table 1 */
+        }
+        if (it.entities[0] == e3 || it.entities[0] == e4) {
+            ecs_iter_skip(&it); /* Skip both entities in table 1 */
+        }
+
+        count ++;
+    }
+
+    test_int(count, 4);
+
+    test_bool(ecs_query_changed(q_r), true);
+    
+    it = ecs_query_iter(world, q_r);
+    count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_int(it.count, 1);
+
+        if (it.entities[0] == e1 || it.entities[0] == e2) {
+            /* Table changed, not all entities were skipped */
+            test_bool( ecs_iter_changed(&it), true );
+        }
+        if (it.entities[0] == e3 || it.entities[0] == e4) {
+            /* Table did not change, all entities were skipped */
+            test_bool( ecs_iter_changed(&it), false );
+        }
+
+        count ++;
+    }
+
+    test_int(count, 4);
+
+    test_bool(ecs_query_changed(q_r), false);
+
+    ecs_query_fini(q);
+    ecs_query_fini(q_r);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add(world, e, Position);
+    ecs_add(world, e, Velocity);
+    ecs_add(world, e, TagA);
+    ecs_add(world, e, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position, TagA || TagB, [in] Velocity",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, e, Position, {10, 20});
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, e, Velocity, {10, 20});
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add(world, e1, Position);
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e1, TagB);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add(world, e2, Velocity);
+    ecs_add(world, e2, TagA);
+    ecs_add(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, [in] Position || [in] Velocity, TagB",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, e1, Position, {10, 20});
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_set(world, e2, Velocity, {10, 20});
+    test_bool(true, ecs_query_changed(q));
+
+    it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add(world, e1, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_no_source(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add(world, e1, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, [out] TagB()",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_no_source_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add(world, e1, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position, [out] Velocity()",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_not_out(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add(world, e1, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position, [out] !Velocity",
+        .cache_kind = EcsQueryCacheAuto
+    });
+    test_assert(q != NULL);
+    
+    test_bool(true, ecs_query_changed(q));
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_bool(false, ecs_query_next(&it));
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_singleton(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_singleton_set(world, Velocity, {1, 2});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position, Velocity($)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_bool(true, ecs_query_changed(q));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        while (ecs_query_next(&it)) { }
+        test_bool(false, ecs_query_changed(q));
+    }
+
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {10, 20}));
+
+    test_bool(true, ecs_query_changed(q));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_uint(e, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_singleton_set(world, Velocity, {2, 3});
+
+    test_bool(true, ecs_query_changed(q));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_query_changed(q));
+        test_bool(true, ecs_iter_changed(&it));
+        test_uint(e, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_int(v->x, 2);
+        test_int(v->y, 3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    test_bool(false, ecs_query_changed(q));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_only_singleton(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_singleton_set(world, Position, {1, 2});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position($)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(false, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_only_singleton_after_set(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_singleton_set(world, Position, {1, 2});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position($)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(false, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_singleton_set(world, Position, {3, 4});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 3);
+        test_int(p->y, 4);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_only_singleton_after_out_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_singleton_set(world, Position, {1, 2});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position($)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_query_t *q_write = ecs_query(world, {
+        .expr = "[out] Position"
+    });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(false, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q_write);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        p->x = 3;
+        p->y = 4;
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 3);
+        test_int(p->y, 4);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+    ecs_query_fini(q_write);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_only_singleton_after_singleton_out_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_singleton_set(world, Position, {1, 2});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position($)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_query_t *q_write = ecs_query(world, {
+        .expr = "[out] Position($)"
+    });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(false, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q_write);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        p->x = 3;
+        p->y = 4;
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(0, it.count);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 3);
+        test_int(p->y, 4);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+    ecs_query_fini(q_write);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_only_parent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {1, 2}));
+    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(false, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_only_parent_after_set(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {1, 2}));
+    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(false, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, parent, Position, {3, 4});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 3);
+        test_int(p->y, 4);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_only_parent_after_out_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {1, 2}));
+    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_query_t *q_write = ecs_query(world, {
+        .expr = "[out] Position"
+    });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(false, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q_write);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(parent, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        p->x = 3;
+        p->y = 4;
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 3);
+        test_int(p->y, 4);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+    ecs_query_fini(q_write);
+
+    ecs_fini(world);
+}
+
+void ChangeDetection_query_changed_w_only_parent_after_parent_out_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Position, {1, 2}));
+    ecs_entity_t child = ecs_new_w_pair(world, EcsChildOf, parent);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    ecs_query_t *q_write = ecs_query(world, {
+        .expr = "[out] Position(up)"
+    });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(false, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q_write);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        p->x = 3;
+        p->y = 4;
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_bool(true, ecs_iter_changed(&it));
+        test_int(1, it.count);
+        test_uint(child, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 3);
+        test_int(p->y, 4);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+    ecs_query_fini(q_write);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/ComponentInheritance.c b/test/query/src/ComponentInheritance.c
new file mode 100644
index 000000000..e56d7f138
--- /dev/null
+++ b/test/query/src/ComponentInheritance.c
@@ -0,0 +1,3350 @@
+#include <query.h>
+
+ECS_TAG_DECLARE(Unit);
+ECS_TAG_DECLARE(MeleeUnit);
+ECS_TAG_DECLARE(RangedUnit);
+ECS_TAG_DECLARE(Warrior);
+ECS_TAG_DECLARE(Archer);
+ECS_TAG_DECLARE(Wizard);
+ECS_TAG_DECLARE(Warlock);
+
+static
+void populate_facts(ecs_world_t *world) {
+    ECS_TAG_DEFINE(world, Unit);
+    ECS_ENTITY_DEFINE(world, MeleeUnit, (IsA, Unit));
+    ECS_ENTITY_DEFINE(world, RangedUnit, (IsA, Unit));
+    ECS_ENTITY_DEFINE(world, Warrior, (IsA, MeleeUnit));
+    ECS_ENTITY_DEFINE(world, Archer, (IsA, RangedUnit));
+    ECS_ENTITY_DEFINE(world, Wizard, (IsA, RangedUnit));
+    ECS_ENTITY_DEFINE(world, Warlock, (IsA, Wizard), (IsA, Warrior));
+}
+
+void ComponentInheritance_1_ent_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Warlock(e1)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_ent_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Warrior(e1)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_ent_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "MeleeUnit(e1)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_ent_3_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Unit(e1)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it)); /* not ideal, diamond problem */
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0)); 
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+
+void ComponentInheritance_1_this_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    ecs_entity_t e2 = ecs_new_w(world, Wizard);
+    ecs_entity_t e3 = ecs_new_w(world, Warrior);
+    ecs_entity_t e4 = ecs_new_w(world, Archer);
+    ecs_entity_t e5 = ecs_new_w(world, MeleeUnit);
+    ecs_entity_t e6 = ecs_new_w(world, RangedUnit);
+    ecs_entity_t e7 = ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Unit($this)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Unit, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e7, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(MeleeUnit, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e5, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RangedUnit, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e6, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warrior, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Archer, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Wizard, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Wizard);
+    ecs_entity_t e3 = ecs_new_w(world, Warrior);
+    /* ecs_entity_t e4 = */ ecs_new_w(world, Archer);
+    ecs_entity_t e5 = ecs_new_w(world, MeleeUnit);
+    /* ecs_entity_t e6 = */ ecs_new_w(world, RangedUnit);
+    /* ecs_entity_t e7 = */ ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "MeleeUnit($this)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(MeleeUnit, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e5, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warrior, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Wizard);
+    ecs_entity_t e3 = ecs_new_w(world, Warrior);
+    /* ecs_entity_t e4 = */ ecs_new_w(world, Archer);
+    /* ecs_entity_t e5 = */ ecs_new_w(world, MeleeUnit);
+    /* ecs_entity_t e6 = */ ecs_new_w(world, RangedUnit);
+    /* ecs_entity_t e7 = */ ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Warrior($this)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warrior, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_3_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Wizard);
+    /* ecs_entity_t e3 = */ ecs_new_w(world, Warrior);
+    /* ecs_entity_t e4 = */ ecs_new_w(world, Archer);
+    /* ecs_entity_t e5 = */ ecs_new_w(world, MeleeUnit);
+    /* ecs_entity_t e6 = */ ecs_new_w(world, RangedUnit);
+    /* ecs_entity_t e7 = */ ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Warlock($this)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_0_lvl_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($this), Unit($this)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Wizard, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warrior, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Archer, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(MeleeUnit, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e5, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RangedUnit, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e6, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Unit, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e7, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_1_lvl_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($this), MeleeUnit($this)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warrior, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(MeleeUnit, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e5, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_2_lvl_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($this), Warrior($this)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warrior, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_3_lvl_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($this), Warlock($this)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    ecs_entity_t e2 = ecs_new_w(world, Wizard);
+    ecs_entity_t e3 = ecs_new_w(world, Warrior);
+    ecs_entity_t e4 = ecs_new_w(world, Archer);
+    ecs_entity_t e5 = ecs_new_w(world, MeleeUnit);
+    ecs_entity_t e6 = ecs_new_w(world, RangedUnit);
+    ecs_entity_t e7 = ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Unit($x)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Unit, ecs_field_id(&it, 0));
+        test_uint(e7, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e7, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(MeleeUnit, ecs_field_id(&it, 0));
+        test_uint(e5, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RangedUnit, ecs_field_id(&it, 0));
+        test_uint(e6, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warrior, ecs_field_id(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Archer, ecs_field_id(&it, 0));
+        test_uint(e4, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Wizard, ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Wizard);
+    ecs_entity_t e3 = ecs_new_w(world, Warrior);
+    /* ecs_entity_t e4 = */ ecs_new_w(world, Archer);
+    ecs_entity_t e5 = ecs_new_w(world, MeleeUnit);
+    /* ecs_entity_t e6 = */ ecs_new_w(world, RangedUnit);
+    /* ecs_entity_t e7 = */ ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "MeleeUnit($x)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(MeleeUnit, ecs_field_id(&it, 0));
+        test_uint(e5, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warrior, ecs_field_id(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Wizard);
+    ecs_entity_t e3 = ecs_new_w(world, Warrior);
+    /* ecs_entity_t e4 = */ ecs_new_w(world, Archer);
+    /* ecs_entity_t e5 = */ ecs_new_w(world, MeleeUnit);
+    /* ecs_entity_t e6 = */ ecs_new_w(world, RangedUnit);
+    /* ecs_entity_t e7 = */ ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Warrior($x)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warrior, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_3_lvl(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Wizard);
+    /* ecs_entity_t e3 = */ ecs_new_w(world, Warrior);
+    /* ecs_entity_t e4 = */ ecs_new_w(world, Archer);
+    /* ecs_entity_t e5 = */ ecs_new_w(world, MeleeUnit);
+    /* ecs_entity_t e6 = */ ecs_new_w(world, RangedUnit);
+    /* ecs_entity_t e7 = */ ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Warlock($x)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_0_lvl_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x), Unit($x)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Wizard, ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warrior, ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Archer, ecs_field_id(&it, 1));
+        test_uint(e4, ecs_field_src(&it, 0));
+        test_uint(e4, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(MeleeUnit, ecs_field_id(&it, 1));
+        test_uint(e5, ecs_field_src(&it, 0));
+        test_uint(e5, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RangedUnit, ecs_field_id(&it, 1));
+        test_uint(e6, ecs_field_src(&it, 0));
+        test_uint(e6, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Unit, ecs_field_id(&it, 1));
+        test_uint(e7, ecs_field_src(&it, 0));
+        test_uint(e7, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e7, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_1_lvl_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x), MeleeUnit($x)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warrior, ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(MeleeUnit, ecs_field_id(&it, 1));
+        test_uint(e5, ecs_field_src(&it, 0));
+        test_uint(e5, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_2_lvl_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x), Warrior($x)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warrior, ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_3_lvl_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x), Warlock($x)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_ent_1_lvl_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Warrior(e1|self)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_1_lvl_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Wizard);
+    ecs_entity_t e3 = ecs_new_w(world, Warrior);
+    /* ecs_entity_t e4 = */ ecs_new_w(world, Archer);
+    ecs_entity_t e5 = ecs_new_w(world, MeleeUnit);
+    /* ecs_entity_t e6 = */ ecs_new_w(world, RangedUnit);
+    /* ecs_entity_t e7 = */ ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "MeleeUnit(self)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(MeleeUnit, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e5, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warrior, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_1_lvl_written_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), MeleeUnit(self)"
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warrior, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(MeleeUnit, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e5, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_1_lvl_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Warlock);
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Wizard);
+    ecs_entity_t e3 = ecs_new_w(world, Warrior);
+    /* ecs_entity_t e4 = */ ecs_new_w(world, Archer);
+    ecs_entity_t e5 = ecs_new_w(world, MeleeUnit);
+    /* ecs_entity_t e6 = */ ecs_new_w(world, RangedUnit);
+    /* ecs_entity_t e7 = */ ecs_new_w(world, Unit);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "MeleeUnit($x|self)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(MeleeUnit, ecs_field_id(&it, 0));
+        test_uint(e5, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warrior, ecs_field_id(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Warlock, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_1_lvl_written_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Warlock);
+    ecs_add(world, e2, Wizard);
+    ecs_add(world, e3, Warrior);
+    ecs_add(world, e4, Archer);
+    ecs_add(world, e5, MeleeUnit);
+    ecs_add(world, e6, RangedUnit);
+    ecs_add(world, e7, Unit);
+
+    /* entities that don't match query */
+    ecs_new_w(world, Unit);
+    ecs_new_w(world, MeleeUnit);
+    ecs_new_w(world, Warrior);
+    ecs_new_w(world, Warlock);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x), MeleeUnit($x)"
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warlock, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Warrior, ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(MeleeUnit, ecs_field_id(&it, 1));
+        test_uint(e5, ecs_field_src(&it, 0));
+        test_uint(e5, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_ent_src_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, Warrior);
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Unit(e1)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!MeleeUnit(e1)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Warrior(e1)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Warlock(e1)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!RangedUnit(e1)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(RangedUnit, ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Archer(e1)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Wizard(e1)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_src_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Unit);
+    ecs_add(world, e2, MeleeUnit);
+    ecs_add(world, e3, RangedUnit);
+    ecs_add(world, e4, Warrior);
+    ecs_add(world, e5, Archer);
+    ecs_add(world, e6, Wizard);
+    ecs_add(world, e7, Warlock);
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Unit($this), Tag($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!MeleeUnit($this), Tag($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(MeleeUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(MeleeUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(MeleeUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e5, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(MeleeUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e6, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Warrior($this), Tag($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e5, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e6, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Warlock($this), Tag($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e4, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e5, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e6, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!RangedUnit($this), Tag($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(RangedUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(RangedUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(RangedUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e4, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Archer($this), Tag($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e4, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e6, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e7, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Wizard($this), Tag($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e4, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e5, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_src_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Unit);
+    ecs_add(world, e2, MeleeUnit);
+    ecs_add(world, e3, RangedUnit);
+    ecs_add(world, e4, Warrior);
+    ecs_add(world, e5, Archer);
+    ecs_add(world, e6, Wizard);
+    ecs_add(world, e7, Warlock);
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Unit($x), Tag($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!MeleeUnit($x), Tag($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(MeleeUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(MeleeUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(MeleeUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e5, ecs_field_src(&it, 0));
+            test_uint(e5, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(MeleeUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e6, ecs_field_src(&it, 0));
+            test_uint(e6, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Warrior($x), Tag($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e5, ecs_field_src(&it, 0));
+            test_uint(e5, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e6, ecs_field_src(&it, 0));
+            test_uint(e6, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Warlock($x), Tag($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e4, ecs_field_src(&it, 0));
+            test_uint(e4, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e5, ecs_field_src(&it, 0));
+            test_uint(e5, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e6, ecs_field_src(&it, 0));
+            test_uint(e6, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!RangedUnit($x), Tag($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(RangedUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(RangedUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(RangedUnit, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e4, ecs_field_src(&it, 0));
+            test_uint(e4, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Archer($x), Tag($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e4, ecs_field_src(&it, 0));
+            test_uint(e4, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e6, ecs_field_src(&it, 0));
+            test_uint(e6, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Archer, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e7, ecs_field_src(&it, 0));
+            test_uint(e7, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e7, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "!Wizard($x), Tag($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e4, ecs_field_src(&it, 0));
+            test_uint(e4, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Wizard, ecs_field_id(&it, 0));
+            test_uint(Tag, ecs_field_id(&it, 1));
+            test_uint(e5, ecs_field_src(&it, 0));
+            test_uint(e5, ecs_field_src(&it, 1));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 1));
+            test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_this_src_not_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Unit);
+    ecs_add(world, e2, MeleeUnit);
+    ecs_add(world, e3, RangedUnit);
+    ecs_add(world, e4, Warrior);
+    ecs_add(world, e5, Archer);
+    ecs_add(world, e6, Wizard);
+    ecs_add(world, e7, Warlock);
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), !Unit($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), !MeleeUnit($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(e1, it.entities[0]);
+            test_uint(Tag, ecs_field_id(&it, 0));
+
+            test_uint(MeleeUnit, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(e3, it.entities[0]);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(MeleeUnit, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(e5, it.entities[0]);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(MeleeUnit, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(e6, it.entities[0]);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(MeleeUnit, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), !Warrior($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e3, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e5, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e6, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), !Warlock($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e3, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e4, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e5, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e6, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), !RangedUnit($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(RangedUnit, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(RangedUnit, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(RangedUnit, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e4, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), !Archer($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e3, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e4, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e6, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e7, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($this), !Wizard($this)" });
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e3, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e4, it.entities[0]);
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(1, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e5, it.entities[0]);
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_1_var_src_not_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, Unit);
+    ecs_add(world, e2, MeleeUnit);
+    ecs_add(world, e3, RangedUnit);
+    ecs_add(world, e4, Warrior);
+    ecs_add(world, e5, Archer);
+    ecs_add(world, e6, Wizard);
+    ecs_add(world, e7, Warlock);
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($x), !Unit($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($x), !MeleeUnit($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(MeleeUnit, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(MeleeUnit, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(MeleeUnit, ecs_field_id(&it, 1));
+            test_uint(e5, ecs_field_src(&it, 0));
+            test_uint(e5, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(MeleeUnit, ecs_field_id(&it, 1));
+            test_uint(e6, ecs_field_src(&it, 0));
+            test_uint(e6, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($x), !Warrior($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(e5, ecs_field_src(&it, 0));
+            test_uint(e5, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warrior, ecs_field_id(&it, 1));
+            test_uint(e6, ecs_field_src(&it, 0));
+            test_uint(e6, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($x), !Warlock($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(e4, ecs_field_src(&it, 0));
+            test_uint(e4, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(e5, ecs_field_src(&it, 0));
+            test_uint(e5, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Warlock, ecs_field_id(&it, 1));
+            test_uint(e6, ecs_field_src(&it, 0));
+            test_uint(e6, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($x), !RangedUnit($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(RangedUnit, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(RangedUnit, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(RangedUnit, ecs_field_id(&it, 1));
+            test_uint(e4, ecs_field_src(&it, 0));
+            test_uint(e4, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($x), !Archer($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(e4, ecs_field_src(&it, 0));
+            test_uint(e4, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(e6, ecs_field_src(&it, 0));
+            test_uint(e6, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Archer, ecs_field_id(&it, 1));
+            test_uint(e7, ecs_field_src(&it, 0));
+            test_uint(e7, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e7, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, { .expr = "Tag($x), !Wizard($x)" });
+        test_assert(r != NULL);
+
+        int x_var = ecs_query_find_var(r, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(e2, ecs_field_src(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(e3, ecs_field_src(&it, 0));
+            test_uint(e3, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(e4, ecs_field_src(&it, 0));
+            test_uint(e4, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Tag, ecs_field_id(&it, 0));
+            test_uint(Wizard, ecs_field_id(&it, 1));
+            test_uint(e5, ecs_field_src(&it, 0));
+            test_uint(e5, ecs_field_src(&it, 1));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+            test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    ecs_fini(world);
+}
+
+void ComponentInheritance_first_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    populate_facts(world);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, Warlock);
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_add(world, e2, Warrior);
+
+    {
+        ecs_query_t *r = ecs_query(world, {
+            .expr = "Warrior|self(e1)"
+        });
+
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, {
+            .expr = "Warlock|self(e1)"
+        });
+
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warlock, ecs_field_id(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    {
+        ecs_query_t *r = ecs_query(world, {
+            .expr = "Warrior|self(e2)"
+        });
+
+        test_assert(r != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, r);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(Warrior, ecs_field_id(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_uint(e2, ecs_field_src(&it, 0));
+
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(r);
+    }
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/EnabledComponents.c b/test/query/src/EnabledComponents.c
new file mode 100644
index 000000000..e9f664306
--- /dev/null
+++ b/test/query/src/EnabledComponents.c
@@ -0,0 +1,209 @@
+#include <query.h>
+
+void EnabledComponents_is_component_enabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_empty_entity_disabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_0_entity_disabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_0_component_disabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_nonexist_component_disabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_component_enabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_disabled_component_enabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_has_enabled_component(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_after_add(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_after_remove(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_after_disable(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_disabled_after_enable(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_randomized(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_after_add_randomized(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_after_randomized_add_randomized(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_2(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_3(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_2_after_add(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_3_after_add(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_pair_enabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_enabled_pair_enabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_disabled_pair_enabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_has_enabled_pair(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_pair_enabled_after_add(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_pair_enabled_after_remove(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_pair_enabled_after_disable(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_pair_disabled_after_enable(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_pair_enabled_2(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_pair_enabled_3(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_pair_enabled_2_after_add(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_is_pair_enabled_3_after_add(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_disabled(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_disabled_skip_initial(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_disabled_pair(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_disabled_pair_skip_initial(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_2(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_8(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_64(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_256(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_1024(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_enable_mod_10(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_2_2_bitsets(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_8_2_bitsets(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_64_2_bitsets(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_256_2_bitsets(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_mod_1024_2_bitsets(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_randomized_2_bitsets(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_randomized_3_bitsets(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_query_randomized_4_bitsets(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_defer_enable(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_sort(void) {
+    // Implement testcase
+}
+
+void EnabledComponents_table_move_2_from_3(void) {
+    // Implement testcase
+}
diff --git a/test/query/src/GroupBy.c b/test/query/src/GroupBy.c
new file mode 100644
index 000000000..cdf34a776
--- /dev/null
+++ b/test/query/src/GroupBy.c
@@ -0,0 +1,671 @@
+#include <query.h>
+
+static
+int order_by_entity(
+    ecs_entity_t e1,
+    const void *ptr1,
+    ecs_entity_t e2,
+    const void *ptr2)
+{
+    return (e1 > e2) - (e1 < e2);
+}
+
+static
+uint64_t group_by_first_id(
+    ecs_world_t *world,
+    ecs_table_t *table,
+    ecs_id_t id,
+    void *ctx)
+{
+    const ecs_type_t *type = ecs_table_get_type(table);
+    ecs_id_t *first = type->array;
+    if (!first) {
+        return 0;
+    }
+
+    return first[0];
+}
+
+static
+uint64_t group_by_rel(ecs_world_t *world, ecs_table_t *table, ecs_id_t id, void *ctx) {
+    ecs_id_t match;
+    if (ecs_search(world, table, ecs_pair(id, EcsWildcard), &match) != -1) {
+        return ecs_pair_second(world, match);
+    }
+    return 0;
+}
+
+void GroupBy_group_by(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, TagX);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{TagX}},
+        .group_by_callback = group_by_first_id
+    });
+
+    ecs_entity_t e1 = ecs_new_w(world, TagX);
+    ecs_entity_t e2 = ecs_new_w(world, TagX);
+    ecs_entity_t e3 = ecs_new_w(world, TagX);
+
+    ecs_add_id(world, e1, TagC);
+    ecs_add_id(world, e2, TagB);
+    ecs_add_id(world, e3, TagA);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e2);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e1);    
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_fini(world);
+}
+
+static int ctx_value;
+static int ctx_value_free_invoked = 0;
+static
+void ctx_value_free(void *ctx) {
+    test_assert(ctx == &ctx_value);
+    ctx_value_free_invoked ++;
+}
+
+void GroupBy_group_by_w_ctx(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, TagX);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{TagX}},
+        .group_by_callback = group_by_first_id,
+        .group_by_ctx = &ctx_value,
+        .group_by_ctx_free = ctx_value_free
+    });
+
+    ecs_entity_t e1 = ecs_new_w(world, TagX);
+    ecs_entity_t e2 = ecs_new_w(world, TagX);
+    ecs_entity_t e3 = ecs_new_w(world, TagX);
+
+    ecs_add_id(world, e1, TagC);
+    ecs_add_id(world, e2, TagB);
+    ecs_add_id(world, e3, TagA);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e2);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e1);    
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(q);
+
+    test_int(ctx_value_free_invoked, 1);
+
+    ecs_fini(world);
+}
+
+void GroupBy_group_by_w_sort_reverse_group_creation(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t TagA = ecs_new(world);
+    ecs_entity_t TagB = ecs_new(world);
+    ecs_entity_t TagC = ecs_new(world);
+
+    ecs_entity_t TagX = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{TagX}},
+        .order_by_callback = order_by_entity,
+        .group_by_callback = group_by_first_id
+    });
+
+    ecs_entity_t e1 = ecs_new_w_id(world, TagX);
+    ecs_entity_t e2 = ecs_new_w_id(world, TagX);
+    ecs_entity_t e3 = ecs_new_w_id(world, TagX);
+
+    ecs_add_id(world, e1, TagC);
+    ecs_add_id(world, e2, TagB);
+    ecs_add_id(world, e3, TagA);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e3);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e2);
+
+    test_bool(ecs_query_next(&it), true);
+    test_int(it.count, 1);
+    test_int(it.entities[0], e1);    
+
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_fini(world);
+}
+
+void GroupBy_group_by_iter_one(void) {
+    ecs_world_t* world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, Tag);
+
+    ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_new_w_pair(world, Rel, TgtC);
+
+    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e5 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e6 = ecs_new_w_pair(world, Rel, TgtC);
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+    ecs_add(world, e6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_pair(Rel, EcsWildcard) }
+        },
+        .group_by_callback = group_by_rel,
+        .group_by = Rel
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_set_group(&it, TgtB);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_uint(TgtB, it.group_id);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_uint(TgtB, it.group_id);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void GroupBy_group_by_iter_one_all_groups(void) {
+    ecs_world_t* world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtC);
+
+    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e5 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e6 = ecs_new_w_pair(world, Rel, TgtC);
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+    ecs_add(world, e6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_pair(Rel, EcsWildcard) }
+        },
+        .group_by_callback = group_by_rel,
+        .group_by = Rel
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_set_group(&it, TgtB);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_uint(TgtB, it.group_id);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_uint(TgtB, it.group_id);
+    test_bool(false, ecs_query_next(&it));
+
+    it = ecs_query_iter(world, q);
+    ecs_iter_set_group(&it, TgtA);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_uint(TgtA, it.group_id);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_uint(TgtA, it.group_id);
+    test_bool(false, ecs_query_next(&it));
+
+    it = ecs_query_iter(world, q);
+    ecs_iter_set_group(&it, TgtC);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+    test_uint(TgtC, it.group_id);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+    test_uint(TgtC, it.group_id);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void GroupBy_group_by_iter_one_empty(void) {
+    ecs_world_t* world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, TgtD);
+    ECS_TAG(world, Tag);
+
+    ecs_new_w_pair(world, Rel, TgtA);
+    ecs_new_w_pair(world, Rel, TgtB);
+    ecs_new_w_pair(world, Rel, TgtC);
+
+    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e5 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e6 = ecs_new_w_pair(world, Rel, TgtC);
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+    ecs_add(world, e6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_pair(Rel, EcsWildcard) }
+        },
+        .group_by_callback = group_by_rel,
+        .group_by = Rel
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_set_group(&it, TgtD);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void GroupBy_group_by_iter_one_empty_query(void) {
+    ecs_world_t* world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_pair(Rel, EcsWildcard) }
+        },
+        .group_by_callback = group_by_rel,
+        .group_by = Rel
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_set_group(&it, TgtA);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void GroupBy_group_by_iter_one_empty_table(void) {
+    ecs_world_t* world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, Tag);
+
+    ecs_new_w_pair(world, Rel, TgtA);
+    ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtC);
+
+    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e5 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e6 = ecs_new_w_pair(world, Rel, TgtC);
+    ecs_add(world, e4, Tag);
+    ecs_add(world, e5, Tag);
+    ecs_add(world, e6, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_pair(Rel, EcsWildcard) }
+        },
+        .group_by_callback = group_by_rel,
+        .group_by = Rel
+    });
+
+    ecs_delete(world, e3);
+    ecs_delete(world, e6);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_set_group(&it, TgtC);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void GroupBy_group_by_w_deleted_group_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_pair(Rel, EcsWildcard) }
+        },
+        .group_by_callback = group_by_rel,
+        .group_by = Rel
+    });
+
+    ecs_entity_t tgt = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_set_group(&it, tgt);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_delete(world, tgt);
+    ecs_delete(world, e);
+
+    it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    tgt = ecs_new(world);
+    e = ecs_new_w_pair(world, Rel, tgt);
+
+    it = ecs_query_iter(world, q);
+    ecs_iter_set_group(&it, tgt);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+static int group_by_ctx;
+static int on_group_create_invoked;
+static int on_group_delete_invoked;
+
+static
+void* on_group_create(ecs_world_t *world, uint64_t group_id, void *group_by_arg) {
+    test_assert(world != NULL);
+    test_assert(group_id != 0);
+    test_assert(group_by_arg != NULL);
+    test_assert(group_by_arg == &group_by_ctx);
+    uint64_t *group_ctx = ecs_os_malloc_t(uint64_t);
+    *group_ctx = group_id;
+    on_group_create_invoked ++;
+    return group_ctx;
+}
+
+static
+void on_group_delete(ecs_world_t *world, uint64_t group_id, void *group_ctx, void *group_by_arg) {
+    test_assert(world != NULL);
+    test_assert(group_id != 0);
+    test_assert(group_ctx != NULL);
+    test_assert(group_by_arg != NULL);
+    test_assert(group_by_arg == &group_by_ctx);
+    test_assert(*(uint64_t*)group_ctx == group_id);
+    ecs_os_free(group_ctx);
+    on_group_delete_invoked ++;
+}
+
+void GroupBy_group_by_callbacks(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_pair(Rel, EcsWildcard) }
+        },
+        .group_by_callback = group_by_rel,
+        .group_by = Rel,
+        .on_group_create = on_group_create,
+        .on_group_delete = on_group_delete,
+        .group_by_ctx = &group_by_ctx
+    });
+
+    ecs_entity_t tgt_a = ecs_new(world);
+    ecs_entity_t tgt_b = ecs_new(world);
+
+    test_int(on_group_create_invoked, 0);
+    test_int(on_group_delete_invoked, 0);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, tgt_a);
+    ecs_run_aperiodic(world, 0);
+    test_int(on_group_create_invoked, 1);
+    test_int(on_group_delete_invoked, 0);
+
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, tgt_a);
+    ecs_run_aperiodic(world, 0);
+    test_int(on_group_create_invoked, 1);
+    test_int(on_group_delete_invoked, 0);
+
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, tgt_b);
+    ecs_run_aperiodic(world, 0);
+    test_int(on_group_create_invoked, 2);
+    test_int(on_group_delete_invoked, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(e2, it.entities[1]);
+    test_uint(tgt_a, it.group_id);
+    const ecs_query_group_info_t *gi = ecs_query_get_group_info(q, it.group_id);
+    test_assert(gi != NULL);
+    test_assert(gi->ctx != NULL);
+    test_uint(tgt_a, *(uint64_t*)gi->ctx);
+
+    test_assert(ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(tgt_b, it.group_id);
+    gi = ecs_query_get_group_info(q, it.group_id);
+    test_assert(gi != NULL);
+    test_assert(gi->ctx != NULL);
+    test_uint(tgt_b, *(uint64_t*)gi->ctx);
+    test_assert(!ecs_query_next(&it));
+
+    ecs_delete_with(world, ecs_pair(Rel, tgt_a));
+    ecs_run_aperiodic(world, 0);
+    test_int(on_group_create_invoked, 2);
+    test_int(on_group_delete_invoked, 1);
+
+    ecs_query_fini(q);
+
+    test_int(on_group_create_invoked, 2);
+    test_int(on_group_delete_invoked, 2);
+
+    ecs_fini(world);
+}
+
+void GroupBy_group_by_default_action(void) {
+    ecs_world_t* world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, TgtC);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_pair(Rel, EcsWildcard) }
+        },
+        // .group_by_callback = group_by_rel, default action groups by relationship
+        .group_by = Rel
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_uint(TgtA, it.group_id);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_uint(TgtB, it.group_id);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+    test_uint(TgtC, it.group_id);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_fini(world);
+}
+
+void GroupBy_group_table_count(void) {
+    ecs_world_t* world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, Foo);
+
+    ecs_new_w_pair(world, Rel, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_pair(Rel, EcsWildcard) }
+        },
+        .group_by = Rel
+    });
+
+    ecs_run_aperiodic(world, 0);
+
+    const ecs_query_group_info_t *gi_a;
+    const ecs_query_group_info_t *gi_b;
+    gi_a = ecs_query_get_group_info(q, TgtA);
+    gi_b = ecs_query_get_group_info(q, TgtB);
+    test_assert(gi_a != NULL);
+    test_assert(gi_b == NULL);
+    test_int(gi_a->table_count, 1);
+    test_int(gi_a->match_count, 1);
+
+    ecs_new_w_pair(world, Rel, TgtB);
+    ecs_run_aperiodic(world, 0);
+
+    gi_a = ecs_query_get_group_info(q, TgtA);
+    gi_b = ecs_query_get_group_info(q, TgtB);
+    test_assert(gi_a != NULL);
+    test_assert(gi_b != NULL);
+    test_int(gi_a->table_count, 1);
+    test_int(gi_a->match_count, 1);
+    test_int(gi_b->table_count, 1);
+    test_int(gi_b->match_count, 1);
+
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_run_aperiodic(world, 0);
+
+    gi_a = ecs_query_get_group_info(q, TgtA);
+    gi_b = ecs_query_get_group_info(q, TgtB);
+    test_assert(gi_a != NULL);
+    test_assert(gi_b != NULL);
+    test_int(gi_a->table_count, 1);
+    test_int(gi_a->match_count, 1);
+    test_int(gi_b->table_count, 1);
+    test_int(gi_b->match_count, 1);
+
+    ecs_add(world, e3, Foo);
+    ecs_run_aperiodic(world, 0);
+
+    gi_a = ecs_query_get_group_info(q, TgtA);
+    gi_b = ecs_query_get_group_info(q, TgtB);
+    test_assert(gi_a != NULL);
+    test_assert(gi_b != NULL);
+    test_int(gi_a->table_count, 2);
+    test_int(gi_a->match_count, 2);
+    test_int(gi_b->table_count, 1);
+    test_int(gi_b->match_count, 1);
+
+    ecs_delete_with(world, Foo);
+    ecs_run_aperiodic(world, 0);
+
+    gi_a = ecs_query_get_group_info(q, TgtA);
+    gi_b = ecs_query_get_group_info(q, TgtB);
+    test_assert(gi_a != NULL);
+    test_assert(gi_b != NULL);
+    test_int(gi_a->table_count, 1);
+    test_int(gi_a->match_count, 3);
+    test_int(gi_b->table_count, 1);
+    test_int(gi_b->match_count, 1);
+
+    ecs_delete_with(world, ecs_pair(Rel, TgtA));
+    ecs_run_aperiodic(world, 0);
+
+    gi_a = ecs_query_get_group_info(q, TgtA);
+    gi_b = ecs_query_get_group_info(q, TgtB);
+    test_assert(gi_a == NULL);
+    test_assert(gi_b != NULL);
+    test_int(gi_b->table_count, 1);
+    test_int(gi_b->match_count, 1);
+
+    ecs_delete_with(world, ecs_pair(Rel, TgtB));
+    ecs_run_aperiodic(world, 0);
+
+    gi_a = ecs_query_get_group_info(q, TgtA);
+    gi_b = ecs_query_get_group_info(q, TgtB);
+    test_assert(gi_a == NULL);
+    test_assert(gi_b == NULL);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/MemberTarget.c b/test/query/src/MemberTarget.c
new file mode 100644
index 000000000..c43383cc5
--- /dev/null
+++ b/test/query/src/MemberTarget.c
@@ -0,0 +1,4532 @@
+#include <query.h>
+
+static ecs_query_cache_kind_t cache_kind = EcsQueryCacheDefault;
+
+void MemberTarget_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = EcsQueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+typedef struct {
+    ecs_entity_t value;
+} Movement;
+
+typedef struct {
+    ecs_entity_t a;
+    ecs_entity_t b;
+} TwoMembers;
+
+static ecs_entity_t ecs_id(Movement) = 0;
+static ecs_entity_t ecs_id(TwoMembers) = 0;
+static ecs_entity_t Running = 0;
+static ecs_entity_t Walking = 0;
+static ecs_entity_t Sitting = 0;
+
+static void register_types(
+    ecs_world_t *world)
+{
+    ecs_id(Movement) = ecs_struct(world, {
+        .entity = ecs_entity(world, { .name = "Movement" }),
+        .members = {
+            { "value", ecs_id(ecs_entity_t) }
+        }
+    });
+
+    ecs_id(TwoMembers) = ecs_struct(world, {
+        .entity = ecs_entity(world, { .name = "TwoMembers" }),
+        .members = {
+            { "a", ecs_id(ecs_entity_t) },
+            { "b", ecs_id(ecs_entity_t) }
+        }
+    });
+
+    Running = ecs_entity(world, { .name = "Running" });
+    Walking = ecs_entity(world, { .name = "Walking" });
+    Sitting = ecs_entity(world, { .name = "Sitting" });
+}
+
+void MemberTarget_this_member_eq_1(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_eq_2(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    /* ecs_entity_t e1 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    /* ecs_entity_t e5 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_eq_no_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    /* ecs_entity_t e1 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    /* ecs_entity_t e2 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    /* ecs_entity_t e5 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_eq_all_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Walking, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Sitting, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), (Movement.value, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_add(world, Running, Foo);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_var_read(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, $x), Foo($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_add(world, Running, Foo);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_eq_1_2nd_member(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(TwoMembers.b, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(TwoMembers, { Walking, Walking }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(TwoMembers, { Walking, Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_eq_2_2nd_member(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(TwoMembers.b, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    /* ecs_entity_t e1 = */ ecs_insert(world, ecs_value(TwoMembers, { Sitting, Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Running }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(TwoMembers, { Sitting, Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Running }));
+    /* ecs_entity_t e5 = */ ecs_insert(world, ecs_value(TwoMembers, { Sitting, Sitting }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_var_same_1(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(TwoMembers.a, $x), (TwoMembers.b, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(TwoMembers, { Running, Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Walking }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(TwoMembers, { Walking, Sitting }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(TwoMembers, { Sitting, Walking }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Sitting }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Walking, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Sitting, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_var_same_2(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(TwoMembers.a, $x), (TwoMembers.b, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    /* ecs_entity_t e1 = */ ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(TwoMembers, { Running, Running }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(TwoMembers, { Walking, Sitting }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Walking }));
+    /* ecs_entity_t e5 = */ ecs_insert(world, ecs_value(TwoMembers, { Running, Sitting }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Walking, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_eq_1(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_eq_2(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (Movement.value, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (Movement.value, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Walking, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Sitting, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_neq_1(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            e0_found |= it.entities[i] == e0;
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            e3_found |= it.entities[i] == e3;
+            e4_found |= it.entities[i] == e4;
+            e5_found |= it.entities[i] == e5;
+
+            if (it.entities[i] == e0) test_assert(it.table == ecs_get_table(world, e0));
+            if (it.entities[i] == e1) test_assert(it.table == ecs_get_table(world, e1));
+            if (it.entities[i] == e2) test_assert(it.table == ecs_get_table(world, e2));
+            if (it.entities[i] == e3) test_assert(it.table == ecs_get_table(world, e3));
+            if (it.entities[i] == e4) test_assert(it.table == ecs_get_table(world, e4));
+            if (it.entities[i] == e5) test_assert(it.table == ecs_get_table(world, e5));
+        }
+    }
+
+    test_bool(true, e0_found);
+    test_bool(false, e1_found);
+    test_bool(false, e2_found);
+    test_bool(true, e3_found);
+    test_bool(true, e4_found);
+    test_bool(false, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_neq_2(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        for (int i = 0; i < it.count; i ++) {
+            e0_found |= it.entities[i] == e0;
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            e3_found |= it.entities[i] == e3;
+            e4_found |= it.entities[i] == e4;
+            e5_found |= it.entities[i] == e5;
+
+            if (it.entities[i] == e0) test_assert(it.table == ecs_get_table(world, e0));
+            if (it.entities[i] == e1) test_assert(it.table == ecs_get_table(world, e1));
+            if (it.entities[i] == e2) test_assert(it.table == ecs_get_table(world, e2));
+            if (it.entities[i] == e3) test_assert(it.table == ecs_get_table(world, e3));
+            if (it.entities[i] == e4) test_assert(it.table == ecs_get_table(world, e4));
+            if (it.entities[i] == e5) test_assert(it.table == ecs_get_table(world, e5));
+        }
+    }
+
+    test_bool(true, e0_found);
+    test_bool(true, e1_found);
+    test_bool(false, e2_found);
+    test_bool(true, e3_found);
+    test_bool(false, e4_found);
+    test_bool(true, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_neq_no_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            e0_found |= it.entities[i] == e0;
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            e3_found |= it.entities[i] == e3;
+            e4_found |= it.entities[i] == e4;
+            e5_found |= it.entities[i] == e5;
+
+            if (it.entities[i] == e0) test_assert(it.table == ecs_get_table(world, e0));
+        }
+    }
+
+    test_bool(true, e0_found);
+    test_bool(false, e1_found);
+    test_bool(false, e2_found);
+    test_bool(false, e3_found);
+    test_bool(false, e4_found);
+    test_bool(false, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_neq_all_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Walking }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            e0_found |= it.entities[i] == e0;
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            e3_found |= it.entities[i] == e3;
+            e4_found |= it.entities[i] == e4;
+            e5_found |= it.entities[i] == e5;
+
+            if (it.entities[i] == e0) test_assert(it.table == ecs_get_table(world, e0));
+        }
+    }
+
+    test_bool(true, e0_found);
+    test_bool(true, e1_found);
+    test_bool(true, e2_found);
+    test_bool(true, e3_found);
+    test_bool(true, e4_found);
+    test_bool(true, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_neq_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!(Movement.value, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            e0_found |= it.entities[i] == e0;
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            e3_found |= it.entities[i] == e3;
+            e4_found |= it.entities[i] == e4;
+            e5_found |= it.entities[i] == e5;
+
+            if (it.entities[i] == e0) test_assert(it.table == ecs_get_table(world, e0));
+            if (it.entities[i] == e1) test_assert(it.table == ecs_get_table(world, e1));
+            if (it.entities[i] == e2) test_assert(it.table == ecs_get_table(world, e2));
+            if (it.entities[i] == e3) test_assert(it.table == ecs_get_table(world, e3));
+            if (it.entities[i] == e4) test_assert(it.table == ecs_get_table(world, e4));
+            if (it.entities[i] == e5) test_assert(it.table == ecs_get_table(world, e5));
+        }
+    }
+
+    test_bool(true, e0_found);
+    test_bool(false, e1_found);
+    test_bool(false, e2_found);
+    test_bool(false, e3_found);
+    test_bool(false, e4_found);
+    test_bool(false, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_neq_1(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, !(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e0, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_neq_2(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, !(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e0, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_neq_no_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, !(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e0, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_neq_all_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, !(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Walking }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e0, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_neq_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, !(Movement.value, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Walking }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e0, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_eq_optional(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            e0_found |= it.entities[i] == e0;
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            e3_found |= it.entities[i] == e3;
+            e4_found |= it.entities[i] == e4;
+            e5_found |= it.entities[i] == e5;
+
+            if (it.entities[i] == e0) test_assert(it.table == ecs_get_table(world, e0));
+            if (it.entities[i] == e1) test_assert(it.table == ecs_get_table(world, e1));
+            if (it.entities[i] == e2) test_assert(it.table == ecs_get_table(world, e2));
+            if (it.entities[i] == e3) test_assert(it.table == ecs_get_table(world, e3));
+            if (it.entities[i] == e4) test_assert(it.table == ecs_get_table(world, e4));
+            if (it.entities[i] == e5) test_assert(it.table == ecs_get_table(world, e5));
+        }
+    }
+
+    test_bool(true, e0_found);
+    test_bool(true, e1_found);
+    test_bool(true, e2_found);
+    test_bool(true, e3_found);
+    test_bool(true, e4_found);
+    test_bool(true, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_eq_optional_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?(Movement.value, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            e0_found |= it.entities[i] == e0;
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            e3_found |= it.entities[i] == e3;
+            e4_found |= it.entities[i] == e4;
+            e5_found |= it.entities[i] == e5;
+
+            if (it.entities[i] == e0) test_assert(it.table == ecs_get_table(world, e0));
+            if (it.entities[i] == e1) test_assert(it.table == ecs_get_table(world, e1));
+            if (it.entities[i] == e2) test_assert(it.table == ecs_get_table(world, e2));
+            if (it.entities[i] == e3) test_assert(it.table == ecs_get_table(world, e3));
+            if (it.entities[i] == e4) test_assert(it.table == ecs_get_table(world, e4));
+            if (it.entities[i] == e5) test_assert(it.table == ecs_get_table(world, e5));
+        }
+    }
+
+    test_bool(true, e0_found);
+    test_bool(true, e1_found);
+    test_bool(true, e2_found);
+    test_bool(true, e3_found);
+    test_bool(true, e4_found);
+    test_bool(true, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_eq_optional(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, ?(Movement.value, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e0, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_eq_optional_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, ?(Movement.value, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e0, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_eq_w_other_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Tag);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, Running), Tag",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+    /* ecs_entity_t e5 = */ ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Tag);
+    ecs_add(world, e2, Tag);
+    ecs_add(world, e3, Tag);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_member_eq_w_other_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_COMPONENT(world, Position);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, Running), Position",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+    /* ecs_entity_t e5 = */ ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e2, Position, {20, 30});
+    ecs_set(world, e3, Position, {40, 50});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p[0].x, 10);
+            test_int(p[0].y, 20);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p[0].x, 40);
+            test_int(p[0].y, 50);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_eq_w_other_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (Movement.value, Running), Tag",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    ecs_add(world, e1, Tag);
+    ecs_add(world, e2, Tag);
+    ecs_add(world, e3, Tag);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_member_eq_w_other_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (Movement.value, Running), Position",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    ecs_set(world, e1, Position, {10, 20});
+    ecs_set(world, e2, Position, {20, 30});
+    ecs_set(world, e3, Position, {40, 50});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 2);
+            test_assert(p != NULL);
+            test_int(p[0].x, 10);
+            test_int(p[0].y, 20);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 2);
+            test_assert(p != NULL);
+            test_int(p[0].x, 40);
+            test_int(p[0].y, 50);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_2_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, Running) || (Movement.value, Walking)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    /* ecs_entity_t e0 = */ ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_3_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, Running) || (Movement.value, Walking) || (Movement.value, Sitting)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t Idle = ecs_new(world);
+
+    /* ecs_entity_t e0 = */ ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Idle }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Idle }));
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+    ecs_add(world, e6, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e6, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_2_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (Movement.value, Running) || (Movement.value, Walking)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    /* ecs_entity_t e0 = */ ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_3_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (Movement.value, Running) || (Movement.value, Walking) || (Movement.value, Sitting)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t Idle = ecs_new(world);
+
+    /* ecs_entity_t e0 = */ ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Idle }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Idle }));
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+    ecs_add(world, e6, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e6, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_2_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Movement.value($x, Running) || Movement.value($x, Walking)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    /* ecs_entity_t e0 = */ ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_3_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Movement.value($x, Running) || Movement.value($x, Walking) || Movement.value($x, Sitting)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t Idle = ecs_new(world);
+
+    /* ecs_entity_t e0 = */ ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Idle }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Idle }));
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+    ecs_add(world, e6, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e6, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_written_2_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), Movement.value($x, Running) || Movement.value($x, Walking)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    /* ecs_entity_t e0 = */ ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_written_3_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), Movement.value($x, Running) || Movement.value($x, Walking) || Movement.value($x, Sitting)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t Idle = ecs_new(world);
+
+    /* ecs_entity_t e0 = */ ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Idle }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Idle }));
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+    ecs_add(world, e6, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e6, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_2_or_w_2_members(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(TwoMembers.a, Running) || (TwoMembers.b, Walking)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    /* ecs_entity_t e1 = */ ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(TwoMembers, { Running, Sitting }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(TwoMembers, { Running, Walking }));
+    /* ecs_entity_t e5 = */ ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_2_or_w_2_types(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Movement.value, Running) || (TwoMembers.b, Walking)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Sitting }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Walking }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    
+    ecs_set(world, e1, Movement, { Walking });
+    ecs_set(world, e2, Movement, { Running });
+    ecs_set(world, e3, Movement, { Sitting });
+    ecs_set(world, e4, Movement, { Running });
+    ecs_set(world, e5, Movement, { Sitting });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_2_or_w_2_members(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (TwoMembers.a, Running) || (TwoMembers.b, Walking)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(TwoMembers, { Running, Sitting }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(TwoMembers, { Running, Walking }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_written_2_or_w_2_types(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, (Movement.value, Running) || (TwoMembers.b, Walking)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Sitting }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(TwoMembers, { Sitting, Walking }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    
+    ecs_set(world, e1, Movement, { Walking });
+    ecs_set(world, e2, Movement, { Running });
+    ecs_set(world, e3, Movement, { Sitting });
+    ecs_set(world, e4, Movement, { Running });
+    ecs_set(world, e5, Movement, { Sitting });
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_2_or_2_types_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(TwoMembers.b, *) || (Movement.value, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Sitting }));
+    
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_set(world, e4, TwoMembers, { Running, Walking });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_this_2_or_2_types_dep_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(TwoMembers.b, $x) || (Movement.value, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(TwoMembers, { Walking, Sitting }));
+    
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_set(world, e4, TwoMembers, { Running, Walking });
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Running, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Sitting, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(Walking, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(Running, ecs_iter_get_var(&it, y_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(Sitting, ecs_iter_get_var(&it, y_var));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_member_eq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_member_eq_no_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    /* ecs_entity_t e1 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    /* ecs_entity_t e2 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+    /* ecs_entity_t e3 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+    /* ecs_entity_t e4 = */ ecs_insert(world, ecs_value(Movement, { Sitting }));
+    /* ecs_entity_t e5 = */ ecs_insert(world, ecs_value(Movement, { Walking }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_member_eq_all_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_member_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Movement.value($x, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 0));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 0);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_member_neq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count == 0);
+        ecs_entity_t x = ecs_iter_get_var(&it, x_var);
+        e0_found |= x == e0;
+        e1_found |= x == e1;
+        e2_found |= x == e2;
+        e3_found |= x == e3;
+        e4_found |= x == e4;
+        e5_found |= x == e5;
+    }
+
+    test_bool(true, e0_found);
+    test_bool(false, e1_found);
+    test_bool(false, e2_found);
+    test_bool(true, e3_found);
+    test_bool(true, e4_found);
+    test_bool(false, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_member_neq_no_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count == 0);
+        ecs_entity_t x = ecs_iter_get_var(&it, x_var);
+        e0_found |= x == e0;
+        e1_found |= x == e1;
+        e2_found |= x == e2;
+        e3_found |= x == e3;
+        e4_found |= x == e4;
+        e5_found |= x == e5;
+    }
+
+    test_bool(true, e0_found);
+    test_bool(false, e1_found);
+    test_bool(false, e2_found);
+    test_bool(false, e3_found);
+    test_bool(false, e4_found);
+    test_bool(false, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_member_neq_all_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Walking }));
+
+    bool e0_found = false;
+    bool e1_found = false;
+    bool e2_found = false;
+    bool e3_found = false;
+    bool e4_found = false;
+    bool e5_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count == 0);
+        ecs_entity_t x = ecs_iter_get_var(&it, x_var);
+        e0_found |= x == e0;
+        e1_found |= x == e1;
+        e2_found |= x == e2;
+        e3_found |= x == e3;
+        e4_found |= x == e4;
+        e5_found |= x == e5;
+    }
+
+    test_bool(true, e0_found);
+    test_bool(true, e1_found);
+    test_bool(true, e2_found);
+    test_bool(true, e3_found);
+    test_bool(true, e4_found);
+    test_bool(true, e5_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_written_member_eq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_written_member_eq_no_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Walking }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_written_member_eq_all_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_written_member_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), Movement.value($x, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Walking }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Running);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_written_member_neq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), !Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e0, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_written_member_neq_no_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), !Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Running }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Running }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e0, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void MemberTarget_var_written_member_neq_all_matches(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_IMPORT(world, FlecsMeta);
+    ECS_TAG(world, Foo);
+
+    register_types(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x), !Movement.value($x, Running)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e0 = ecs_new_w(world, Foo);
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Movement, { Walking }));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Movement, { Sitting }));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Movement, { Walking }));
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+    ecs_add(world, e5, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e0, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Movement), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e4, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Sitting);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(ecs_entity_t), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        {
+            ecs_entity_t *m = ecs_field(&it, ecs_entity_t, 1);
+            test_assert(m != NULL);
+            test_int(m[0], Walking);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/Operators.c b/test/query/src/Operators.c
new file mode 100644
index 000000000..657cc53d1
--- /dev/null
+++ b/test/query/src/Operators.c
@@ -0,0 +1,8834 @@
+#include <query.h>
+
+static ecs_query_cache_kind_t cache_kind = EcsQueryCacheDefault;
+
+void Operators_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = EcsQueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+void Operators_2_and_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !RelB($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e1, RelB);
+    ecs_add(world, e2, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !Position($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e1, Position);
+    ecs_add(world, e2, Position);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, Position);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_out_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), [out] !RelB($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e1, RelB);
+    ecs_add(world, e2, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_out_not_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), [out] !Position($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e1, Position);
+    ecs_add(world, e2, Position);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, Position);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_not_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !RelB($this), !RelC($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e1, RelB);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e1, RelC);
+    ecs_add(world, e2, RelC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e2, RelC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, RelC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_rel_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !*($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !RelA($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add_pair(world, e2, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_rel_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !*($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add_pair(world, e2, RelA, TgtB);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !$x($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !RelA($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add_pair(world, e2, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_rel_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int32_t y_var = ecs_query_find_var(q, "x");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_rel_tgt_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !$x($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e1, RelA, RelA);
+    ecs_add_pair(world, e2, RelA, RelA);
+    ecs_add_pair(world, e1, RelB, RelB);
+    ecs_add_pair(world, e2, RelB, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelB, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_rel_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), !$x($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelB);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e2, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_tgt_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), !RelA($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e2, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_rel_tgt_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), !$x($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
+    ecs_add_pair(world, e1, TgtA, TgtA);
+    ecs_add_pair(world, e1, TgtB, TgtB);
+    ecs_add_pair(world, e2, TgtA, TgtA);
+    ecs_add_pair(world, e2, TgtB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, TgtA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e2, TgtB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_rel_tgt_same_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), !$x($this, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
+    ecs_add_pair(world, e1, TgtA, e1);
+    ecs_add_pair(world, e1, TgtB, e1);
+    ecs_add_pair(world, e2, TgtA, e2);
+    ecs_add_pair(world, e2, TgtB, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, TgtA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, e1), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e2, TgtB, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, e1), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtB, e2), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+
+void Operators_2_and_not_pair_rel_src_tgt_same_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), !$x($x, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e1, e1, e1);
+    ecs_add_pair(world, e2, e2, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e2, e2, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_any_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !_($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), !RelA($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_not_pair_any_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), !RelA(_, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_new_w_pair(world, Tag, TgtB);
+    ecs_new_w_pair(world, Tag, TgtC);
+
+    ecs_entity_t e4 = ecs_new_w_pair(world, RelA, TgtB);
+    ecs_add_pair(world, e4, RelA, TgtC);
+    ecs_new_w_pair(world, RelA, TgtC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_not_any_src_fixed_first(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!RelA(_)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_not_any_src_any_tgt_fixed_first(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!RelA(_, _)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_not_any_src_any_first_fixed_tgt(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!_(_, TgtA)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_not_any_src_any_childof_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!ChildOf(_, _)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_not_any_src_any_isa_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!IsA(_, _)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsIsA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, EcsIsA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelB($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e2, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);   
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_optional(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelB($this), ?RelC($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e3, RelC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_rel_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?*($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?$x($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_rel_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_rel_tgt_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?$x($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    ecs_add_pair(world, e2, TgtA, TgtA);
+    ecs_add_pair(world, e3, TgtA, TgtA);
+    ecs_add_pair(world, e3, RelA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, RelA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_rel_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), ?$x($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_add_pair(world, e3, Tag, RelB);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_tgt_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), ?RelA($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_add_pair(world, e3, Tag, TgtB);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtB);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_rel_tgt_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), ?$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_add_pair(world, e3, Tag, RelB);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_rel_tgt_same_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), ?$x($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_add_pair(world, e3, Tag, RelA);
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    ecs_add_pair(world, e2, TgtA, TgtA);
+    ecs_add_pair(world, e3, TgtA, TgtA);
+    ecs_add_pair(world, e3, RelA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, RelA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_rel_src_tgt_same_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), ?$x($x, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e2, e2, e2);
+    ecs_add_pair(world, e3, e3, e3);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e3, e3), ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_optional_pair_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelB($this, $x), ?RelC($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int32_t y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+    ecs_add_pair(world, e3, RelC, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelC, EcsWildcard), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelC, EcsWildcard), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelC, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_any_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?_($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_and_optional_pair_any_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), ?RelA(_, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtC);
+
+    ecs_entity_t e4 = ecs_new_w_pair(world, RelA, TgtB);
+    ecs_add_pair(world, e4, RelA, TgtC);
+    ecs_new_w_pair(world, RelA, TgtC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtC), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_and_pair_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?$x($this, TgtA), $x($this, TgtB)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_entity_t e4 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+
+    ecs_add_pair(world, e2, RelA, TgtB);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+    ecs_add_pair(world, e3, RelB, TgtB);
+
+    ecs_add_pair(world, e4, RelA, TgtA);
+    ecs_add_pair(world, e4, RelA, TgtB);
+    ecs_add_pair(world, e4, RelB, TgtA);
+    ecs_add_pair(world, e4, RelB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_and_pair_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, $x), RelB($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_entity_t e4 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtB);
+
+    ecs_add_pair(world, e4, RelA, TgtA);
+    ecs_add_pair(world, e4, RelA, TgtB);
+    ecs_add_pair(world, e4, RelB, TgtA);
+    ecs_add_pair(world, e4, RelB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_and_pair_rel_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?$x($this, $y), $y($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TgtA, RelA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, RelA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(RelA, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_and_pair_rel_tgt_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, $x), $x($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, TgtA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_and_pair_rel_tgt_same_other_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, $x), $y($x, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new_w_pair(world, TgtA, TgtA);
+    ecs_entity_t t3 = ecs_new_w_pair(world, TgtB, TgtB);
+    ecs_add_pair(world, t3, TgtC, TgtC);
+
+    ecs_add_pair(world, e2, RelA, t1);
+    ecs_add_pair(world, e3, RelA, t2);
+    ecs_add_pair(world, e3, RelA, t3);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(EcsWildcard, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t2), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t2, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(t2, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t3), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t3, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(t3, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t3), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TgtC, TgtC), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t3, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(t3, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_and_pair_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, $x), Tag($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new_w(world, Tag);
+    ecs_entity_t t3 = ecs_new_w(world, Tag);
+
+    ecs_add_pair(world, e2, RelA, t1);
+    ecs_add_pair(world, e3, RelA, t2);
+    ecs_add_pair(world, e3, RelA, t3);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(EcsWildcard, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t2), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t2, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(t2, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t3), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t3, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(t3, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_optional_pair_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?$x($this, TgtA), ?$x($this, TgtB)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_entity_t e4 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+
+    ecs_add_pair(world, e2, RelA, TgtB);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+    ecs_add_pair(world, e3, RelB, TgtB);
+
+    ecs_add_pair(world, e4, RelA, TgtA);
+    ecs_add_pair(world, e4, RelA, TgtB);
+    ecs_add_pair(world, e4, RelB, TgtA);
+    ecs_add_pair(world, e4, RelB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_optional_pair_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, $x), ?RelB($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_entity_t e4 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtB);
+
+    ecs_add_pair(world, e4, RelA, TgtA);
+    ecs_add_pair(world, e4, RelA, TgtB);
+    ecs_add_pair(world, e4, RelB, TgtA);
+    ecs_add_pair(world, e4, RelB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_optional_pair_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, $x), ?Tag($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new_w(world, Tag);
+    ecs_entity_t t3 = ecs_new_w(world, Tag);
+
+    ecs_add_pair(world, e2, RelA, t1);
+    ecs_add_pair(world, e3, RelA, t2);
+    ecs_add_pair(world, e3, RelA, t3);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(EcsWildcard, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t1), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t1, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(t1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t2), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t2, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(t2, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t3), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t3, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(t3, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_not_pair_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?$x($this, TgtA), !$x($this, TgtB)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtB);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+    ecs_add_pair(world, e3, RelB, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+    
+    ecs_remove_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e3, RelB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_not_pair_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, $x), !RelB($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    ecs_add_pair(world, e3, RelA, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtB);
+    ecs_add_pair(world, e3, RelB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+    
+    ecs_remove_pair(world, e3, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e3, RelB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_and_optional_dependent_not_pair_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), ?RelA($this, $x), !Tag($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_entity_t t1 = ecs_new_w(world, Tag);
+    ecs_entity_t t2 = ecs_new_w(world, Tag);
+    ecs_entity_t t3 = ecs_new_w(world, Tag);
+
+    ecs_add_pair(world, e2, RelA, t1);
+    ecs_add_pair(world, e3, RelA, t2);
+    ecs_add_pair(world, e3, RelA, t3);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(EcsWildcard, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, t1, Tag);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(EcsWildcard, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t1), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t1, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(t1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e3, RelA, t2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(EcsWildcard, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t1), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t1, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(t1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove_pair(world, e3, RelA, t3);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(EcsWildcard, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, t1), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(t1, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(t1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_optional_any_src_fixed_first(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?RelA(_)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w(world, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_optional_any_src_any_tgt_fixed_first(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?RelA(_, _)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_optional_any_src_any_first_fixed_tgt(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?_(_, TgtA)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, TgtA, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_optional_any_src_any_childof_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?ChildOf(_, _)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_optional_any_src_any_isa_pair_any_tgt(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?IsA(_, _)"
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsIsA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_new_w_pair(world, EcsIsA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(EcsIsA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this) || RelB($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_entity_t e3 = ecs_new_w(world, RelB);
+    ecs_entity_t e4 = ecs_new_w(world, RelB);
+    ecs_add(world, e4, Tag);
+    ecs_new_w(world, RelC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(e1, it.entities[0]);
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(e2, it.entities[0]);
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(e3, it.entities[0]);
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(e4, it.entities[0]);
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, RelD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this) || RelB($this) || RelC($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelB);
+    ecs_entity_t e3 = ecs_new_w(world, RelC);
+    ecs_new_w(world, RelD);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelC, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_w_and(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA || TagB, Foo",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_entity_t e3 = ecs_new_w(world, TagB);
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+
+    ecs_new_w(world, TagB);
+    ecs_new_w(world, TagC);
+    ecs_new_w(world, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(TagB, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_or_w_and(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr =  "TagA || TagB || TagC, Foo",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_entity_t e3 = ecs_new_w(world, TagB);
+    ecs_add(world, e3, TagC);
+    ecs_entity_t e4 = ecs_new_w(world, TagC);
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Foo);
+    ecs_add(world, e3, Foo);
+    ecs_add(world, e4, Foo);
+
+    ecs_new_w(world, TagB);
+    ecs_new_w(world, TagC);
+    ecs_new_w(world, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(TagB, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(TagC, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this), RelA($this) || RelB($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e2, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e3, RelB);
+    ecs_add(world, e4, RelC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_or_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, RelD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this), RelA($this) || RelB($this) || RelC($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e3, RelB);
+    ecs_add(world, e3, RelC);
+    ecs_add(world, e4, RelC);
+    ecs_add(world, e5, RelD);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelC, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_written_w_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), $x($this, TgtA) || $x($this, TgtB)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, RelC);
+    ecs_entity_t e4 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtB);
+    ecs_add_pair(world, e3, RelC, TgtA);
+    ecs_add_pair(world, e3, RelC, TgtB);
+    ecs_add_pair(world, e4, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelC), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelC, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_or_written_w_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, RelD);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), $x($this, TgtA) || $x($this, TgtB) || $x($this, TgtC)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, RelB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, RelC);
+    ecs_entity_t e4 = ecs_new_w_pair(world, Tag, RelD);
+    ecs_entity_t e5 = ecs_new_w_pair(world, Tag, RelA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtB);
+    ecs_add_pair(world, e3, RelC, TgtA);
+    ecs_add_pair(world, e3, RelC, TgtB);
+    ecs_add_pair(world, e4, RelD, TgtC);
+    ecs_add_pair(world, e5, RelD, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelC), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelC, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, RelD), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelD, TgtC), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(RelD, ecs_iter_get_var(&it, x_var));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_written_w_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), RelA($this, $x) || RelB($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtC);
+    ecs_entity_t e4 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtB);
+    ecs_add_pair(world, e3, RelA, TgtC);
+    ecs_add_pair(world, e3, RelB, TgtC);
+    ecs_add_pair(world, e4, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtC), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_written_w_rel_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, TgtD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $x), RelB($this, $y), $x($this, $y) || $y($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtC);
+    ecs_entity_t e4 = ecs_new_w_pair(world, RelA, TgtD);
+
+    ecs_add_pair(world, e1, RelB, TgtD);
+    ecs_add_pair(world, e2, RelB, TgtC);
+    ecs_add_pair(world, e3, RelB, TgtB);
+    ecs_add_pair(world, e4, RelB, TgtA);
+
+    ecs_add_pair(world, e2, TgtB, TgtC);
+    ecs_add_pair(world, e3, TgtB, TgtC);
+    ecs_add_pair(world, e4, TgtD, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtC), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TgtB, TgtC), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtC, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TgtB, TgtC), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtD), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TgtD, TgtA), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtD, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_written_w_rel_tgt_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, TgtD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $x), $x($this, $x) || RelB($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtC);
+    ecs_new_w_pair(world, RelA, TgtC);
+
+    ecs_add_pair(world, e1, TgtA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtB);
+    ecs_add_pair(world, e3, TgtC, TgtC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtC, TgtC), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_or_written_w_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, TgtD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this, $x), RelA($this, $x) || RelB($this, $x) || RelC($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Tag, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Tag, TgtC);
+    ecs_entity_t e4 = ecs_new_w_pair(world, Tag, TgtD);
+    ecs_entity_t e5 = ecs_new_w_pair(world, Tag, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelB, TgtB);
+    ecs_add_pair(world, e3, RelA, TgtC);
+    ecs_add_pair(world, e3, RelB, TgtC);
+    ecs_add_pair(world, e4, RelC, TgtD);
+    ecs_add_pair(world, e5, RelA, TgtD);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtC), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Tag, TgtD), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelC, TgtD), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(TgtD, ecs_iter_get_var(&it, x_var));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_chains_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, RelD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this), RelA($this) || RelB($this), RelC($this) || RelD($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e2, RelC);
+
+    ecs_add(world, e3, RelA);
+    ecs_add(world, e3, RelC);
+
+    ecs_add(world, e4, RelA);
+    ecs_add(world, e4, RelD);
+
+    ecs_add(world, e5, RelB);
+    ecs_add(world, e5, RelC);
+
+    ecs_add(world, e6, RelB);
+    ecs_add(world, e6, RelD);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(RelD, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e4, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e5, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(RelD, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e6, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_chains(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, RelD);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+    ecs_entity_t e5 = ecs_new(world);
+    ecs_entity_t e6 = ecs_new(world);
+
+    ecs_add(world, e1, RelA);
+    ecs_add(world, e2, RelC);
+
+    ecs_add(world, e3, RelA);
+    ecs_add(world, e3, RelC);
+
+    ecs_add(world, e4, RelA);
+    ecs_add(world, e4, RelD);
+
+    ecs_add(world, e5, RelB);
+    ecs_add(world, e5, RelC);
+
+    ecs_add(world, e6, RelB);
+    ecs_add(world, e6, RelD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this) || RelB($this), RelC($this) || RelD($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e3, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelC, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e4, it.entities[0]);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelD, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e5, it.entities[0]);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(RelC, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e6, it.entities[0]);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(RelD, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_dependent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelB($this) || RelA($this, $tgt), RelC($tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    int tgt_var = ecs_query_find_var(q, "tgt");
+    test_assert(tgt_var != -1);
+
+    ecs_entity_t tgt = ecs_new_w(world, RelC);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add(world, e1, RelB);
+    ecs_add_pair(world, e2, RelA, tgt);
+    ecs_add(world, e3, RelB);
+    ecs_add(world, e3, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, tgt), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, it.entities[0]);
+        test_uint(tgt, ecs_iter_get_var(&it, tgt_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_dependent_reverse(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $tgt) || RelB($this), RelC($tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    int tgt_var = ecs_query_find_var(q, "tgt");
+    test_assert(tgt_var != -1);
+
+    ecs_entity_t tgt = ecs_new_w(world, RelC);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add(world, e1, RelB);
+    ecs_add_pair(world, e2, RelA, tgt);
+    ecs_add(world, e3, RelB);
+    ecs_add(world, e3, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, tgt), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, it.entities[0]);
+        test_uint(tgt, ecs_iter_get_var(&it, tgt_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_dependent_2_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, RelD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $x) || RelB($this, $y), RelC($x), RelD($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_entity_t tgt_a = ecs_new_w(world, RelC);
+    ecs_entity_t tgt_b = ecs_new_w(world, RelD);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+
+    ecs_add_pair(world, e1, RelA, tgt_a);
+    ecs_add_pair(world, e2, RelB, tgt_b);
+
+    ecs_add_pair(world, e3, RelA, tgt_b);
+    ecs_add_pair(world, e4, RelB, tgt_a);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, tgt_a), ecs_field_id(&it, 0));
+        test_uint(RelC, ecs_field_id(&it, 1));
+        test_uint(RelD, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(e1, it.entities[0]);
+        test_uint(tgt_a, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelB, tgt_b), ecs_field_id(&it, 0));
+        test_uint(RelC, ecs_field_id(&it, 1));
+        test_uint(RelD, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(e2, it.entities[0]);
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(tgt_b, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_written_dependent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, RelA($this, $tgt) || RelB($this), RelC($tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    int tgt_var = ecs_query_find_var(q, "tgt");
+    test_assert(tgt_var != -1);
+
+    ecs_entity_t tgt = ecs_new_w(world, RelC);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+
+    ecs_add(world, e1, RelB);
+    ecs_add_pair(world, e2, RelA, tgt);
+    ecs_add(world, e3, RelB);
+    ecs_add(world, e3, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(e1, it.entities[0]);
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, tgt), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(e2, it.entities[0]);
+        test_uint(tgt, ecs_iter_get_var(&it, tgt_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(e3, it.entities[0]);
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, tgt_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_written_dependent_2_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, RelD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, RelA($this, $x) || RelB($this, $y), RelC($x), RelD($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_entity_t tgt_a = ecs_new_w(world, RelC);
+    ecs_entity_t tgt_b = ecs_new_w(world, RelD);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+
+    ecs_add_pair(world, e1, RelA, tgt_a);
+    ecs_add_pair(world, e2, RelB, tgt_b);
+
+    ecs_add_pair(world, e3, RelA, tgt_b);
+    ecs_add_pair(world, e4, RelB, tgt_a);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, tgt_a), ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_id(&it, 2));
+        test_uint(RelD, ecs_field_id(&it, 3));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 3));
+        test_uint(e1, it.entities[0]);
+        test_uint(tgt_a, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, tgt_b), ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_id(&it, 2));
+        test_uint(RelD, ecs_field_id(&it, 3));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 3));
+        test_uint(e2, it.entities[0]);
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(tgt_b, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_w_dependent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, RelD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, ?RelA($this, $x), RelB($x) || RelC($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t tgt_a = ecs_new_w(world, RelB);
+    ecs_entity_t tgt_b = ecs_new_w(world, RelC);
+    ecs_entity_t tgt_c = ecs_new_w(world, RelD);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+
+    ecs_add_pair(world, e2, RelA, tgt_a);
+    ecs_add_pair(world, e3, RelA, tgt_b);
+    ecs_add_pair(world, e4, RelA, tgt_c);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 1));
+        // test_uint(RelC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 2));
+        test_uint(e1, it.entities[0]);
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, tgt_a), ecs_field_id(&it, 1));
+        test_uint(RelB, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(e2, it.entities[0]);
+        test_uint(tgt_a, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, tgt_b), ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 2));
+        test_uint(e3, it.entities[0]);
+        test_uint(tgt_b, ecs_iter_get_var(&it, x_var));
+
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_w_both(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA || RelB",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_entity_t e3 = ecs_new_w(world, RelB);
+    ecs_new_w(world, RelC);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(RelA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(RelA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(RelB, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_3_or_w_both(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, RelD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA || RelB || RelC",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+    ecs_add(world, e3, RelD);
+
+    ecs_entity_t e4 = ecs_new_w(world, RelB);
+    ecs_entity_t e5 = ecs_new_w(world, RelB);
+    ecs_add(world, e5, RelC);
+    ecs_entity_t e6 = ecs_new_w(world, RelB);
+    ecs_add(world, e6, RelD);
+
+    ecs_entity_t e7 = ecs_new_w(world, RelC);
+    ecs_entity_t e8 = ecs_new_w(world, RelC);
+    ecs_add(world, e8, RelD);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(RelA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(RelA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(RelA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(RelB, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(RelB, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(RelB, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(RelC, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e8, it.entities[0]);
+    test_uint(RelC, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA || RelB, !RelC",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e2, RelC);
+    ecs_entity_t e3 = ecs_new_w(world, RelB);
+    ecs_new_w(world, RelC);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(RelA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(RelB, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_w_not_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA || RelB, !Position",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e2, Position);
+    ecs_entity_t e3 = ecs_new_w(world, RelB);
+    ecs_new_w(world, Position);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(RelA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(RelB, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_w_not_out_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA || RelB, [out] !Position",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e2, Position);
+    ecs_entity_t e3 = ecs_new_w(world, RelB);
+    ecs_new_w(world, Position);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(RelA, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(RelB, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_or_w_not_out_all_components(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Velocity || Mass, [out] !Position",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w(world, Velocity);
+    ecs_entity_t e2 = ecs_new_w(world, Velocity);
+    ecs_add(world, e2, Mass);
+    ecs_add(world, e2, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Mass);
+    ecs_new_w(world, Position);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_not_first(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e3, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!TagB($this), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagB, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(TagB, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_2_optional_first(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e3, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?TagB($this), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(3, it.count);
+        test_uint(TagB, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e3, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(TagB, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagB, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_only_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    while (ecs_query_next(&it)) {
+        for (int32_t i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e1);
+            test_assert(it.entities[i] != e2);
+            count ++;
+        }
+    }
+
+    test_assert(count != 0);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_only_not_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!Position($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    while (ecs_query_next(&it)) {
+        for (int32_t i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e1);
+            test_assert(it.entities[i] != e2);
+            count ++;
+        }
+    }
+
+    test_assert(count != 0);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_only_not_out_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[out] !Position($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    while (ecs_query_next(&it)) {
+        for (int32_t i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e1);
+            test_assert(it.entities[i] != e2);
+            count ++;
+        }
+    }
+
+    test_assert(count != 0);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_only_optional(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    bool e1_found = false;
+    bool e2_found = false;
+    while (ecs_query_next(&it)) {
+        for (int32_t i = 0; i < it.count; i ++) {
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            count ++;
+        }
+    }
+
+    test_assert(count > 2);
+    test_bool(e1_found, true);
+    test_bool(e2_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_only_optional_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?Position($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    bool e1_found = false;
+    bool e2_found = false;
+    while (ecs_query_next(&it)) {
+        for (int32_t i = 0; i < it.count; i ++) {
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            count ++;
+        }
+    }
+
+    test_assert(count > 2);
+    test_bool(e1_found, true);
+    test_bool(e2_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_not_after_fixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagC(ent), !TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TagC);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        int32_t count = 0;
+        while (ecs_query_next(&it)) {
+            for (int32_t i = 0; i < it.count; i ++) {
+                test_assert(it.entities[i] != e1);
+                test_assert(it.entities[i] != e2);
+                count ++;
+            }
+        }
+        test_assert(count != 0);
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_optional_after_fixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagC(ent), ?TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TagC);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    bool e1_found = false;
+    bool e2_found = false;
+    while (ecs_query_next(&it)) {
+        for (int32_t i = 0; i < it.count; i ++) {
+            e1_found |= it.entities[i] == e1;
+            e2_found |= it.entities[i] == e2;
+            count ++;
+        }
+    }
+
+    test_assert(count > 2);
+    test_bool(e1_found, true);
+    test_bool(e2_found, true);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_root_entities_empty(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!ChildOf($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(EcsFlecs, it.entities[0]);
+
+        if (ecs_query_next(&it)) {
+            test_uint(1, it.count);
+            test_uint(q->entity, it.entities[0]);
+            test_bool(false, ecs_query_next(&it));
+        }
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_root_entities(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity(world, { .name = "e1.e2" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!ChildOf($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(EcsFlecs, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(e1, it.entities[0]);
+
+        if (ecs_query_next(&it)) {
+            test_uint(1, it.count);
+            test_uint(q->entity, it.entities[0]);
+            test_bool(false, ecs_query_next(&it));
+        }
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_root_entities_w_children(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!ChildOf($this, _), ChildOf(_, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add_pair(world, e3, EcsChildOf, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, EcsFlecs), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(EcsFlecs, ecs_iter_get_var(&it, this_var));
+        test_uint(EcsFlecs, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, e2), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_root_entities_w_optional_children(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add_pair(world, e3, EcsChildOf, e2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!ChildOf($this, _), ?ChildOf(_, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, EcsFlecs), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(EcsFlecs, ecs_iter_get_var(&it, this_var));
+        test_uint(EcsFlecs, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, Tag), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(Tag, ecs_iter_get_var(&it, this_var));
+        test_uint(Tag, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, e1), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, e2), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, e4), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e4, ecs_iter_get_var(&it, this_var));
+        test_uint(e4, it.entities[0]);
+
+        if (ecs_query_next(&it)) {
+            test_uint(1, it.count);
+            test_uint(q->entity, it.entities[0]);
+            test_bool(false, ecs_query_next(&it));
+        }
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_core_entities_w_optional_children(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "ChildOf($this, flecs.core), ?ChildOf(_, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        while (ecs_query_next(&it)) {
+            test_assert(ecs_field_is_set(&it, 0));
+            for (int i = 0; i < it.count; i ++) {
+                test_assert(ecs_has_pair(
+                    world, it.entities[i], EcsChildOf, EcsFlecsCore));
+                if (ecs_field_is_set(&it, 1)) {
+                    test_assert(ecs_count_id(
+                        world, ecs_pair(EcsChildOf, it.entities[i])) != 0);
+                } else {
+                    test_assert(ecs_count_id(
+                        world, ecs_pair(EcsChildOf, it.entities[i])) == 0);
+                }
+            }
+        }
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_root_entities_w_not_children(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add_pair(world, e3, EcsChildOf, e2);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!ChildOf($this, _), !ChildOf(_, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, Tag), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(Tag, ecs_iter_get_var(&it, this_var));
+        test_uint(Tag, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, e1), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(EcsChildOf, 0), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, e4), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(e4, ecs_iter_get_var(&it, this_var));
+        test_uint(e4, it.entities[0]);
+
+        if (ecs_query_next(&it)) {
+            test_uint(1, it.count);
+            test_uint(q->entity, it.entities[0]);
+            test_bool(false, ecs_query_next(&it));
+        }
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_core_entities_w_not_children(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "ChildOf($this, flecs.core), !ChildOf(_, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        while (ecs_query_next(&it)) {
+            test_assert(ecs_field_is_set(&it, 0));
+            test_assert(!ecs_field_is_set(&it, 1));
+            for (int i = 0; i < it.count; i ++) {
+                test_assert(ecs_has_pair(
+                    world, it.entities[i], EcsChildOf, EcsFlecsCore));
+                test_assert(ecs_count_id(
+                    world, ecs_pair(EcsChildOf, it.entities[i])) == 0);
+            }
+        }
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, RelA);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelA(e1)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelB(e1)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(RelB, ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, Tgt);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, Tgt);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelA(e1, Tgt)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelB(e1, Tgt)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!*(e1, TgtA)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!*(e1, TgtB)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelA(e1, *)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelB(e1, *)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_tgt_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!*(e1, *)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!_(e1, TgtA)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!_(e1, TgtB)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_tgt_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelA(e1, _)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelB(e1, _)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_tgt_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!_(e1, _)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!$x(e1, TgtA)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        int x_var = ecs_query_find_var(q, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!$x(e1, TgtB)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        int x_var = ecs_query_find_var(q, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(ecs_pair(EcsWildcard, TgtB), ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelA(e1, $x)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        int x_var = ecs_query_find_var(q, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!RelB(e1, $x)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        int x_var = ecs_query_find_var(q, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(ecs_pair(RelB, EcsWildcard), ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!$x(e1, $y)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        int x_var = ecs_query_find_var(q, "x");
+        test_assert(x_var != -1);
+        int y_var = ecs_query_find_var(q, "y");
+        test_assert(y_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_tgt_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    {
+        ecs_query_t *q = ecs_query(world, {
+            .expr = "!$x(e1, $x)",
+            .cache_kind = cache_kind
+        });
+
+        test_assert(q != NULL);
+
+        int x_var = ecs_query_find_var(q, "x");
+        test_assert(x_var != -1);
+
+        {
+            ecs_iter_t it = ecs_query_iter(world, q);
+            test_bool(true, ecs_query_next(&it));
+            test_uint(0, it.count);
+            test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 0));
+            test_uint(e1, ecs_field_src(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 0));
+            test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+            test_bool(false, ecs_query_next(&it));
+        }
+
+        ecs_query_fini(q);
+    }
+
+    ecs_fini(world);
+}
+
+void Operators_1_this_src_not_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!$x($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add_pair(world, e2, RelA, TgtB);
+
+    bool e2_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e1);
+            if (it.entities[i] == e2) {
+                e2_found = true;
+            }
+        }
+
+        test_uint(ecs_pair(EcsWildcard, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+    }
+
+    test_assert(e2_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_this_src_not_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!RelA($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add_pair(world, e2, RelB, TgtA);
+
+    bool e2_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e1);
+            if (it.entities[i] == e2) {
+                e2_found = true;
+            }
+        }
+
+        test_uint(ecs_pair(RelA, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+    }
+
+    test_assert(e2_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_this_src_not_pair_rel_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add(world, e2, TgtA);
+
+    bool e2_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e1);
+            if (it.entities[i] == e2) {
+                e2_found = true;
+            }
+        }
+
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, y_var));
+    }
+
+    test_assert(e2_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_this_src_not_pair_rel_tgt_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, RelA);
+
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_add(world, e3, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!$x($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    bool e1_found = false;
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        test_assert(it.count != 0);
+        for (int i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e2);
+            if (it.entities[i] == e1) {
+                e1_found = true;
+            }
+        }
+
+        test_uint(ecs_pair(EcsWildcard, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
+    }
+
+    test_assert(e1_found);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_ENTITY(world, RelA, Tag);
+    ECS_ENTITY(world, RelB, Tag);
+    ECS_ENTITY(world, RelC, Tag);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtB);
+    ecs_add_pair(world, e1, RelC, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($x), !$x(e1, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelC, TgtA), ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(RelC, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_tgt_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_ENTITY(world, TgtA, Tag);
+    ECS_ENTITY(world, TgtB, Tag);
+    ECS_ENTITY(world, TgtC, Tag);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add_pair(world, e1, RelB, TgtB);
+    ecs_add_pair(world, e1, RelB, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($x), !RelA(e1, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtC), ecs_field_id(&it, 1));
+        test_uint(TgtC, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_tgt_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_ENTITY(world, RelA, (Tag, TgtA));
+    ECS_ENTITY(world, RelB, (Tag, TgtA));
+    ECS_ENTITY(world, RelC, (Tag, TgtB));
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e1, RelC, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($x, $y), !$x(e1, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Tag, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelC, TgtB), ecs_field_id(&it, 1));
+        test_uint(RelC, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(RelC, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_1_ent_src_not_pair_rel_tgt_same_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, RelA);
+    ECS_ENTITY(world, RelB, Tag);
+    ECS_ENTITY(world, TgtA, Tag);
+    ECS_ENTITY(world, TgtB, Tag);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e1, TgtA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtB);
+    ecs_add_pair(world, e1, TgtB, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($x), !$x(e1, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, RelB), ecs_field_id(&it, 1));
+        test_uint(RelB, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_and_from_fixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_PREFAB(world, Type, TagA, TagB);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "AND | Type(e)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_not_from_fixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_PREFAB(world, Type, TagA, TagB);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "NOT | Type(e)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_or_from_fixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_PREFAB(world, Type, TagA, TagB);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "OR | Type(e)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_and_from_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_PREFAB(world, Type, TagA, TagB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_add(world, e2, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "AND | Type",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, TagA);
+    ecs_remove(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_not_from_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_PREFAB(world, Type, TagA, TagB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_add(world, e2, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "NOT | Type",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+        }
+        test_assert(e1_found == true);
+        test_assert(e2_found == true);
+    }
+
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+        }
+        test_assert(e1_found == false);
+        test_assert(e2_found == false);
+    }
+
+
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+        }
+        test_assert(e1_found == false);
+        test_assert(e2_found == false);
+    }
+
+    ecs_remove(world, e1, TagA);
+    ecs_remove(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+        }
+        test_assert(e1_found == false);
+        test_assert(e2_found == false);
+    }
+
+    ecs_remove(world, e1, TagB);
+    ecs_remove(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+        }
+        test_assert(e1_found == true);
+        test_assert(e2_found == true);
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_or_from_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_PREFAB(world, Type, TagA, TagB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_add(world, e2, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "OR | Type",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, TagB);
+    ecs_remove(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_and_from_this_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, TagD);
+    ECS_PREFAB(world, Type, TagA, TagB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, TagD);
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_add(world, e2, TagC);
+    ecs_add(world, e2, TagD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagD, AND | Type",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, TagA);
+    ecs_remove(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_not_from_this_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, TagD);
+    ECS_PREFAB(world, Type, TagA, TagB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, TagD);
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_add(world, e2, TagC);
+    ecs_add(world, e2, TagD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagD, NOT | Type",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+        }
+        test_assert(e1_found == true);
+        test_assert(e2_found == true);
+    }
+
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+        }
+        test_assert(e1_found == false);
+        test_assert(e2_found == false);
+    }
+
+
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+        }
+        test_assert(e1_found == false);
+        test_assert(e2_found == false);
+    }
+
+    ecs_remove(world, e1, TagA);
+    ecs_remove(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+        }
+        test_assert(e1_found == false);
+        test_assert(e2_found == false);
+    }
+
+    ecs_remove(world, e1, TagB);
+    ecs_remove(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        bool e1_found = false;
+        bool e2_found = false;
+        while (ecs_query_next(&it)) {
+            for (int i = 0; i < it.count; i ++) {
+                e1_found |= it.entities[i] == e1;
+                e2_found |= it.entities[i] == e2;
+            }
+            test_uint(0, ecs_field_src(&it, 0));
+            test_uint(0, ecs_field_src(&it, 0));
+            test_bool(true, ecs_field_is_set(&it, 0));
+            test_bool(false, ecs_field_is_set(&it, 1));
+        }
+        test_assert(e1_found == true);
+        test_assert(e2_found == true);
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_or_from_this_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, TagD);
+    ECS_PREFAB(world, Type, TagA, TagB);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_add(world, e1, TagD);
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_add(world, e2, TagC);
+    ecs_add(world, e2, TagD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagD, OR | Type",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, TagA);
+    ecs_add(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, TagB);
+    ecs_add(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e2, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, TagA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e1, TagB);
+    ecs_remove(world, e2, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_and_from_empty(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity(world, { .name = "Type" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "AND | Type",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_not_from_empty(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity(world, { .name = "Type" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "NOT | Type",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_or_from_empty(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity(world, { .name = "Type" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "OR | Type",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_and_from_empty_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity(world, { .name = "Type" });
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "AND | Type, TagA",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_not_from_empty_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity(world, { .name = "Type" });
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "NOT | Type, TagA",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_or_from_empty_w_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity(world, { .name = "Type" });
+
+    ecs_entity_t e = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "OR | Type, TagA",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_or_w_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA, .oper = EcsOr },
+            { TagB },
+            { ecs_pair(Rel, EcsWildcard) }
+        }
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add(world, e, TagA);
+    ecs_add(world, e, TagB);
+    ecs_add_pair(world, e, Rel, TgtA);
+    ecs_add_pair(world, e, Rel, TgtB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_or_w_component_and_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_id(Position), .oper = EcsOr },
+            { TagA }
+        }
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_set(world, e, Position, {10, 20});
+    ecs_add(world, e, TagA);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Operators_or_w_tag_and_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA, .oper = EcsOr },
+            { ecs_id(Position) }
+        }
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_set(world, e, Position, {10, 20});
+    ecs_add(world, e, TagA);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
diff --git a/test/api/src/Sorting.c b/test/query/src/OrderBy.c
similarity index 65%
rename from test/api/src/Sorting.c
rename to test/query/src/OrderBy.c
index 8b05aa40b..5047f7581 100644
--- a/test/api/src/Sorting.c
+++ b/test/query/src/OrderBy.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <query.h>
 #include <stdlib.h>
 
 static
@@ -23,21 +23,21 @@ int compare_entity(
     return (e1 > e2) - (e1 < e2);
 }
 
-void Sorting_sort_by_component(void) {
+void OrderBy_sort_by_component(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -50,27 +50,28 @@ void Sorting_sort_by_component(void) {
     test_assert(it.entities[2] == e1);
     test_assert(it.entities[3] == e5);
     test_assert(it.entities[4] == e3);
-
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_by_component_same_value_1(void) {
+void OrderBy_sort_by_component_same_value_1(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {1, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {1, 0}));
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -87,25 +88,27 @@ void Sorting_sort_by_component_same_value_1(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_by_component_same_value_2(void) {
+void OrderBy_sort_by_component_same_value_2(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e6 = ecs_set(world, 0, Position, {1, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Position, {1, 0}));
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -122,29 +125,31 @@ void Sorting_sort_by_component_same_value_2(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_by_component_2_tables(void) {
+void OrderBy_sort_by_component_2_tables(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
 
     ecs_add(world, e3, Velocity);
     ecs_add(world, e4, Velocity);
     ecs_add(world, e5, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -168,32 +173,34 @@ void Sorting_sort_by_component_2_tables(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_by_component_3_tables(void) {
+void OrderBy_sort_by_component_3_tables(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
-    ecs_entity_t e6 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e7 = ecs_set(world, 0, Position, {7, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e7 = ecs_insert(world, ecs_value(Position, {7, 0}));
 
     ecs_add(world, e5, Velocity);
     ecs_add(world, e6, Mass);
     ecs_add(world, e7, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -222,29 +229,31 @@ void Sorting_sort_by_component_3_tables(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
 
-void Sorting_sort_by_entity(void) {
+void OrderBy_sort_by_entity(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
 
     ecs_add(world, e2, Velocity);
     ecs_add(world, e4, Velocity);
     ecs_add(world, e5, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by = compare_entity
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by_callback = compare_entity
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -268,21 +277,23 @@ void Sorting_sort_by_entity(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_after_add(void) {
+void OrderBy_sort_after_add(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 0}));
 
     ecs_add(world, e3, Velocity);
     ecs_add(world, e4, Velocity);
@@ -290,10 +301,10 @@ void Sorting_sort_after_add(void) {
 
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -344,23 +355,25 @@ void Sorting_sort_after_add(void) {
     test_int(it.count, 1);    
     test_assert(it.entities[0] == e3);
 
-    test_assert(!ecs_query_next(&it));     
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);  
 
     ecs_fini(world);
 }
 
-void Sorting_sort_after_remove(void) {
+void OrderBy_sort_after_remove(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 0}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -372,10 +385,10 @@ void Sorting_sort_after_remove(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -446,21 +459,23 @@ void Sorting_sort_after_remove(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_after_delete(void) {
+void OrderBy_sort_after_delete(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 0}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -472,10 +487,10 @@ void Sorting_sort_after_delete(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -530,21 +545,23 @@ void Sorting_sort_after_delete(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_after_set(void) {
+void OrderBy_sort_after_set(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 0}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -556,10 +573,10 @@ void Sorting_sort_after_set(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -578,7 +595,7 @@ void Sorting_sort_after_set(void) {
     test_int(it.count, 1);    
     test_assert(it.entities[0] == e3);
 
-    test_assert(!ecs_query_next(&it));  
+    test_assert(!ecs_query_next(&it)); 
 
     ecs_set(world, e1, Position, {7, 0});
 
@@ -601,14 +618,16 @@ void Sorting_sort_after_set(void) {
     test_int(it.count, 1);    
     test_assert(it.entities[0] == e1);
 
-    test_assert(!ecs_query_next(&it)); 
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
 static
 void FlipP(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     int32_t i;
     for (i = 0; i < it->count; i ++) {
@@ -618,7 +637,7 @@ void FlipP(ecs_iter_t *it) {
     }
 }
 
-void Sorting_sort_after_system(void) {
+void OrderBy_sort_after_system(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Velocity);
@@ -627,11 +646,11 @@ void Sorting_sort_after_system(void) {
 
     ECS_SYSTEM(world, FlipP, EcsOnUpdate, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 5});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 6});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 1});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 3});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 5}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 2}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 6}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 1}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 3}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -643,10 +662,10 @@ void Sorting_sort_after_system(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, [in] Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, [in] Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -712,21 +731,23 @@ void Sorting_sort_after_system(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_after_query(void) {
+void OrderBy_sort_after_query(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 5});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 6});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 1});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 3});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 5}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 2}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 6}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 1}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 3}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -738,11 +759,12 @@ void Sorting_sort_after_query(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *flip_q = ecs_query_new(world, "Position");
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, [in] Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *flip_q = ecs_query(world, { .expr = "Position" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, [in] Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -816,23 +838,26 @@ void Sorting_sort_after_query(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+    ecs_query_fini(flip_q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_by_component_move_pivot(void) {
+void OrderBy_sort_by_component_move_pivot(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {1, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {10, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {1, 0}));
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -847,29 +872,31 @@ void Sorting_sort_by_component_move_pivot(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_1000_entities(void) {
+void OrderBy_sort_1000_entities(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     for (int i = 0; i < 1000; i ++) {
         int32_t v = rand();
-        ecs_set(world, 0, Position, {v});
+        ecs_insert(world, ecs_value(Position, {v}));
 
         int32_t x = 0;
 
         ecs_iter_t it = ecs_query_iter(world, q);
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             test_assert(it.count == (i + 1));
 
@@ -881,30 +908,32 @@ void Sorting_sort_1000_entities(void) {
         }
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_1000_entities_w_duplicates(void) {
+void OrderBy_sort_1000_entities_w_duplicates(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     for (int i = 0; i < 500; i ++) {
         int32_t v = rand();
-        ecs_set(world, 0, Position, {v});
-        ecs_set(world, 0, Position, {v});
+        ecs_insert(world, ecs_value(Position, {v}));
+        ecs_insert(world, ecs_value(Position, {v}));
 
         int32_t x = 0;
 
         ecs_iter_t it = ecs_query_iter(world, q);
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             test_assert(it.count == (i + 1) * 2);
 
@@ -916,21 +945,23 @@ void Sorting_sort_1000_entities_w_duplicates(void) {
         }
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_1000_entities_again(void) {
+void OrderBy_sort_1000_entities_again(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
-    ecs_entity_t start = ecs_new(world, 0);
+    ecs_entity_t start = ecs_new(world);
 
     for (int i = 0; i < 1000; i ++) {
         int32_t v = rand();
@@ -939,7 +970,7 @@ void Sorting_sort_1000_entities_again(void) {
 
         ecs_iter_t it = ecs_query_iter(world, q);
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             test_assert(it.count == (i + 1));
 
@@ -960,7 +991,7 @@ void Sorting_sort_1000_entities_again(void) {
 
     ecs_iter_t it = ecs_query_iter(world, q);
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         test_assert(it.count == 1000);
 
@@ -969,34 +1000,35 @@ void Sorting_sort_1000_entities_again(void) {
             test_assert(x <= p[j].x);
             x = p[j].x;
         }
-    }    
+    }
 
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Sorting_sort_1000_entities_2_types(void) {
+void OrderBy_sort_1000_entities_2_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     for (int i = 0; i < 500; i ++) {
         int32_t v = rand();
-        ecs_set(world, 0, Position, {v});
-        ecs_entity_t e = ecs_set(world, 0, Position, {v});
+        ecs_insert(world, ecs_value(Position, {v}));
+        ecs_entity_t e = ecs_insert(world, ecs_value(Position, {v}));
         ecs_add(world, e, Velocity);
 
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0, x = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1010,22 +1042,24 @@ void Sorting_sort_1000_entities_2_types(void) {
         test_int(count, (i + 1) * 2);
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_1000_entities_2_types_again(void) {
+void OrderBy_sort_1000_entities_2_types_again(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
-    ecs_entity_t start = ecs_new(world, 0);
+    ecs_entity_t start = ecs_new(world);
 
     for (int i = 0; i < 1000; i ++) {
         int32_t v = rand();
@@ -1038,7 +1072,7 @@ void Sorting_sort_1000_entities_2_types_again(void) {
 
         ecs_iter_t it = ecs_query_iter(world, q);
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             int32_t j, x = 0;
             for (j = 0; j < it.count; j ++) {  
@@ -1056,7 +1090,7 @@ void Sorting_sort_1000_entities_2_types_again(void) {
     ecs_iter_t it = ecs_query_iter(world, q);
     int32_t count = 0, x = 0;
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         count += it.count;
 
@@ -1069,22 +1103,24 @@ void Sorting_sort_1000_entities_2_types_again(void) {
 
     test_int(count, 1000);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_1000_entities_add_type_after_sort(void) {
+void OrderBy_sort_1000_entities_add_type_after_sort(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
-    ecs_entity_t start = ecs_new(world, 0);
+    ecs_entity_t start = ecs_new(world);
 
     for (int i = 0; i < 500; i ++) {
         int32_t v = rand();
@@ -1094,7 +1130,7 @@ void Sorting_sort_1000_entities_add_type_after_sort(void) {
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1122,7 +1158,7 @@ void Sorting_sort_1000_entities_add_type_after_sort(void) {
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0, x = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1134,36 +1170,38 @@ void Sorting_sort_1000_entities_add_type_after_sort(void) {
         }
 
         test_int(count, i + 500 + 1);
-    }    
+    }
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Sorting_sort_1500_entities_3_types(void) {
+void OrderBy_sort_1500_entities_3_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     for (int i = 0; i < 500; i ++) {
-        ecs_set(world, 0, Position, {rand()});
-        ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+        ecs_insert(world, ecs_value(Position, {rand()}));
+        ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Velocity);
 
-        e = ecs_set(world, 0, Position, {rand()});
+        e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Mass);
 
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0, x = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1177,39 +1215,41 @@ void Sorting_sort_1500_entities_3_types(void) {
         test_int(count, (i + 1) * 3);
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_2000_entities_4_types(void) {
+void OrderBy_sort_2000_entities_4_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     for (int i = 0; i < 500; i ++) {
-        ecs_set(world, 0, Position, {rand()});
+        ecs_insert(world, ecs_value(Position, {rand()}));
 
-        ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+        ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Velocity);
 
-        e = ecs_set(world, 0, Position, {rand()});
+        e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Mass);
 
-        e = ecs_set(world, 0, Position, {rand()});
+        e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Velocity);
         ecs_add(world, e, Mass);        
 
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0, x = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1223,33 +1263,35 @@ void Sorting_sort_2000_entities_4_types(void) {
         test_int(count, (i + 1) * 4);
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_shared_component(void) {
+void OrderBy_sort_shared_component(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {0, 0});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t base_3 = ecs_set(world, 0, Position, {7, 0});
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {0, 0}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t base_3 = ecs_insert(world, ecs_value(Position, {7, 0}));
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
     ecs_entity_t e6 = ecs_new_w_pair(world, EcsIsA, base_3);
     ecs_entity_t e7 = ecs_new_w_pair(world, EcsIsA, base_2);
     ecs_entity_t e8 = ecs_new_w_pair(world, EcsIsA, base_1);
     ecs_entity_t e9 = ecs_new_w_pair(world, EcsIsA, base_1);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position(self|up)",
-        .filter.instanced = true,
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position,
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self|up IsA)",
+        .flags = EcsQueryIsInstanced,
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position,
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1285,33 +1327,35 @@ void Sorting_sort_shared_component(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_shared_component_childof(void) {
+void OrderBy_sort_shared_component_childof(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {0, 0});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t base_3 = ecs_set(world, 0, Position, {7, 0});
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {0, 0}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t base_3 = ecs_insert(world, ecs_value(Position, {7, 0}));
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
     ecs_entity_t e6 = ecs_new_w_pair(world, EcsChildOf, base_3);
     ecs_entity_t e7 = ecs_new_w_pair(world, EcsChildOf, base_2);
     ecs_entity_t e8 = ecs_new_w_pair(world, EcsChildOf, base_1);
     ecs_entity_t e9 = ecs_new_w_pair(world, EcsChildOf, base_1);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position(self|up(ChildOf))",
-        .filter.instanced = true,
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position,
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self|up ChildOf)",
+        .flags = EcsQueryIsInstanced,
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position,
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1347,30 +1391,32 @@ void Sorting_sort_shared_component_childof(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_2_entities_2_types(void) {
+void OrderBy_sort_2_entities_2_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
-    ecs_set(world, 0, Position, {rand()});
+    ecs_insert(world, ecs_value(Position, {rand()}));
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Velocity); 
 
     ecs_iter_t it = ecs_query_iter(world, q);
     int32_t count = 0;
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         count += it.count;
 
@@ -1383,34 +1429,36 @@ void Sorting_sort_2_entities_2_types(void) {
 
     test_int(count, 2);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_3_entities_3_types(void) {
+void OrderBy_sort_3_entities_3_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
-    ecs_set(world, 0, Position, {rand()});
+    ecs_insert(world, ecs_value(Position, {rand()}));
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Velocity);
 
-    e = ecs_set(world, 0, Position, {rand()});
+    e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Mass);   
 
     ecs_iter_t it = ecs_query_iter(world, q);
     int32_t count = 0;
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         count += it.count;
 
@@ -1423,24 +1471,26 @@ void Sorting_sort_3_entities_3_types(void) {
 
     test_int(count, 3);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_3_entities_3_types_2(void) {
+void OrderBy_sort_3_entities_3_types_2(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Tag",
-        .order_by = compare_entity
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag",
+        .order_by_callback = compare_entity
     });
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
 
     ecs_add_id(world, e1, Foo);
     ecs_add_id(world, e2, Bar);
@@ -1461,38 +1511,40 @@ void Sorting_sort_3_entities_3_types_2(void) {
 
     test_int(count, 3);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_4_entities_4_types(void) {
+void OrderBy_sort_4_entities_4_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
-    ecs_set(world, 0, Position, {rand()});
+    ecs_insert(world, ecs_value(Position, {rand()}));
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Velocity);
 
-    e = ecs_set(world, 0, Position, {rand()});
+    e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Mass);
 
-    e = ecs_set(world, 0, Position, {rand()});
+    e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Velocity);
     ecs_add(world, e, Mass);     
 
     ecs_iter_t it = ecs_query_iter(world, q);
     int32_t count = 0;
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         count += it.count;
 
@@ -1505,20 +1557,22 @@ void Sorting_sort_4_entities_4_types(void) {
 
     test_int(count, 4);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_w_tags_only(void) {
+void OrderBy_sort_w_tags_only(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{Tag}},
-        .order_by = compare_entity
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{Tag}},
+        .order_by_callback = compare_entity
     });
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, root);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, root);
 
@@ -1532,20 +1586,22 @@ void Sorting_sort_w_tags_only(void) {
     test_int(it.entities[1], e2);
     ecs_iter_fini(&it);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_childof_marked(void) {
+void OrderBy_sort_childof_marked(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{Tag}},
-        .order_by = compare_entity
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{Tag}},
+        .order_by_callback = compare_entity
     });
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, root);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, root);
@@ -1564,20 +1620,22 @@ void Sorting_sort_childof_marked(void) {
     test_assert(!ecs_is_alive(world, e2));
     test_assert(!ecs_is_alive(world, e3));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_isa_marked(void) {
+void OrderBy_sort_isa_marked(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{Tag}},
-        .order_by = compare_entity
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{Tag}},
+        .order_by_callback = compare_entity
     });
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, root);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, root);
@@ -1598,21 +1656,23 @@ void Sorting_sort_isa_marked(void) {
     test_int(1, ecs_get_type(world, e3)->count);
     test_assert(ecs_has(world, e3, Tag));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_relation_marked(void) {
+void OrderBy_sort_relation_marked(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
     ECS_TAG(world, Rel);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{Tag}},
-        .order_by = compare_entity
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{Tag}},
+        .order_by_callback = compare_entity
     });
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, Rel, root);
     ecs_entity_t e2 = ecs_new_w_pair(world, Rel, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, Rel, root);
@@ -1634,6 +1694,8 @@ void Sorting_sort_relation_marked(void) {
     test_int(1, ecs_get_type(world, e3)->count);
     test_assert(ecs_has(world, e3, Tag));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1650,23 +1712,23 @@ int dummy_compare(
     return (e1 > e2) - (e1 < e2);
 }
 
-void Sorting_dont_resort_after_set_unsorted_component(void) {
+void OrderBy_dont_resort_after_set_unsorted_component(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "[in] Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = dummy_compare
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = dummy_compare
     });
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {0, 0});
     ecs_set(world, e1, Velocity, {0, 0});
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {0, 0});
     ecs_set(world, e2, Velocity, {0, 0});
 
@@ -1683,20 +1745,22 @@ void Sorting_dont_resort_after_set_unsorted_component(void) {
 
     // No change in sorted component, shouldn't sort
     ecs_modified(world, e2, Velocity);
-    ecs_query_iter(world, q);
+    it = ecs_query_iter(world, q);
     test_bool(dummy_compare_invoked, false);
     ecs_iter_fini(&it);
 
     // Change in sorted component, should sort
     ecs_modified(world, e2, Position);
-    ecs_query_iter(world, q);
+    it = ecs_query_iter(world, q);
     test_bool(dummy_compare_invoked, true);
     ecs_iter_fini(&it);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_dont_resort_after_set_unsorted_component_w_tag(void) {
+void OrderBy_dont_resort_after_set_unsorted_component_w_tag(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Velocity);
@@ -1711,10 +1775,10 @@ void Sorting_dont_resort_after_set_unsorted_component_w_tag(void) {
 
     test_assert(Tag < ecs_id(Position));
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "[in] Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = dummy_compare
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = dummy_compare
     });
 
     ecs_entity_t e1 = ecs_new_w_id(world, Tag);
@@ -1748,10 +1812,12 @@ void Sorting_dont_resort_after_set_unsorted_component_w_tag(void) {
     test_bool(dummy_compare_invoked, true);
     ecs_iter_fini(&it);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void Sorting_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void) {
+void OrderBy_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Velocity);
@@ -1765,16 +1831,16 @@ void Sorting_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void) {
     test_assert(Tag < ecs_id(Position));
 
     // Sorted query
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "[in] Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = dummy_compare
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = dummy_compare
     });
 
     // Dummy queries that mutate
-    ecs_query_t *q_a = ecs_query_new(world, "Position"); // [inout]
-    ecs_query_t *q_b = ecs_query_new(world, "[out] Position");
-    ecs_query_t *q_c = ecs_query_new(world, "[out] Velocity");
+    ecs_query_t *q_a = ecs_query(world, { .expr = "Position" }); // [inout]
+    ecs_query_t *q_b = ecs_query(world, { .expr = "[out] Position" });
+    ecs_query_t *q_c = ecs_query(world, { .expr = "[out] Velocity" });
 
     ecs_entity_t e1 = ecs_new_w_id(world, Tag);
     ecs_set(world, e1, Position, {0, 0});
@@ -1815,10 +1881,16 @@ void Sorting_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void) {
     dummy_compare_invoked = false;
     ecs_iter_fini(&it);
 
+    ecs_query_fini(q);
+
+    ecs_query_fini(q_a);
+    ecs_query_fini(q_b);
+    ecs_query_fini(q_c);
+
     ecs_fini(world);
 }
 
-void Sorting_sort_component_not_queried_for(void) {
+void OrderBy_sort_component_not_queried_for(void) {
     install_test_abort();
 
     ecs_world_t *world = ecs_mini();
@@ -1826,15 +1898,19 @@ void Sorting_sort_component_not_queried_for(void) {
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    test_expect_abort();
-    ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Velocity),
-        .order_by = compare_position
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Velocity),
+        .order_by_callback = compare_position
     });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
 }
 
-void Sorting_sort_by_wildcard(void) {
+void OrderBy_sort_by_wildcard(void) {
     install_test_abort();
 
     ecs_world_t *world = ecs_mini();
@@ -1842,10 +1918,10 @@ void Sorting_sort_by_wildcard(void) {
     ECS_COMPONENT(world, Position);
 
     test_expect_abort();
-    ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "(Position, *)",
-        .order_by_component = ecs_pair(ecs_id(Position), EcsWildcard),
-        .order_by = compare_position
+    ecs_query(world, {
+        .expr = "(Position, *)",
+        .order_by = ecs_pair(ecs_id(Position), EcsWildcard),
+        .order_by_callback = compare_position
     });
 }
 
@@ -1855,15 +1931,120 @@ void Sorting_sort_shared_w_delete(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
+        .terms = {
+            { .id = ecs_id(Position), .inout = EcsIn }
+        },
+        .flags = EcsQueryIsInstanced,
+        .order_by_callback = compare_position,
+        .order_by = ecs_id(Position)
+    });
+
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {0, 0}));
+    ecs_add_id(world, base, EcsPrefab);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e5 = ecs_new_w_pair(world, EcsIsA, base);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(5, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+        test_uint(e4, it.entities[3]);
+        test_uint(e5, it.entities[4]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+    ecs_delete(world, e3);
+    ecs_delete(world, e4);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[4]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void OrderBy_sort_not_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void OrderBy_sort_or_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position || Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void OrderBy_sort_optional_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void OrderBy_sort_shared_w_delete(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
             { .id = ecs_id(Position), .inout = EcsIn }
         },
-        .filter.instanced = true,
-        .order_by = compare_position,
-        .order_by_component = ecs_id(Position)
+        .flags = EcsQueryIsInstanced,
+        .order_by_callback = compare_position,
+        .order_by = ecs_id(Position)
     });
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {0, 0});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {0, 0}));
     ecs_add_id(world, base, EcsPrefab);
 
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
@@ -1917,7 +2098,7 @@ ECS_DTOR(Velocity, ptr, {
     dtor_invoked ++;
 })
 
-void Sorting_sort_w_nontrivial_component(void) {
+void OrderBy_sort_w_nontrivial_component(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
@@ -1929,11 +2110,11 @@ void Sorting_sort_w_nontrivial_component(void) {
         .dtor = ecs_dtor(Velocity)
     });
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
 
     ecs_set(world, e1, Velocity, {0, 3});
     ecs_set(world, e2, Velocity, {0, 1});
@@ -1946,9 +2127,9 @@ void Sorting_sort_w_nontrivial_component(void) {
     dtor_invoked = 0;
 
     ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = compare_position
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
diff --git a/test/api/src/SortingEntireTable.c b/test/query/src/OrderByEntireTable.c
similarity index 62%
rename from test/api/src/SortingEntireTable.c
rename to test/query/src/OrderByEntireTable.c
index 1c668c502..e1ccebd6d 100644
--- a/test/api/src/SortingEntireTable.c
+++ b/test/query/src/OrderByEntireTable.c
@@ -1,4 +1,4 @@
-#include <api.h>
+#include <query.h>
 #include <stdlib.h>
 
 static
@@ -11,31 +11,32 @@ int compare_entity(
     return (e1 > e2) - (e1 < e2);
 }
 
-ECS_COMPARE(Position, {
+static ECS_COMPARE(Position, {
     const Position *p1 = ptr1;
     const Position *p2 = ptr2;
     return (p1->x > p2->x) - (p1->x < p2->x);
 })
+
 ECS_SORT_TABLE(Position)
 
 ECS_SORT_TABLE_WITH_COMPARE(Position, PositionSortByEntity, compare_entity)
 
-void SortingEntireTable_sort_by_component(void) {
+void OrderByEntireTable_sort_by_component(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -51,25 +52,27 @@ void SortingEntireTable_sort_by_component(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_by_component_same_value_1(void) {
+void OrderByEntireTable_sort_by_component_same_value_1(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {1, 0});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {1, 0}));
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -86,26 +89,28 @@ void SortingEntireTable_sort_by_component_same_value_1(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_by_component_same_value_2(void) {
+void OrderByEntireTable_sort_by_component_same_value_2(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e6 = ecs_set(world, 0, Position, {1, 0});
-
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Position, {1, 0}));
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -122,30 +127,32 @@ void SortingEntireTable_sort_by_component_same_value_2(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_by_component_2_tables(void) {
+void OrderByEntireTable_sort_by_component_2_tables(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
 
     ecs_add(world, e3, Velocity);
     ecs_add(world, e4, Velocity);
     ecs_add(world, e5, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -169,33 +176,35 @@ void SortingEntireTable_sort_by_component_2_tables(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_by_component_3_tables(void) {
+void OrderByEntireTable_sort_by_component_3_tables(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
-    ecs_entity_t e6 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e7 = ecs_set(world, 0, Position, {7, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
+    ecs_entity_t e6 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e7 = ecs_insert(world, ecs_value(Position, {7, 0}));
 
     ecs_add(world, e5, Velocity);
     ecs_add(world, e6, Mass);
     ecs_add(world, e7, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -224,30 +233,32 @@ void SortingEntireTable_sort_by_component_3_tables(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
 
-void SortingEntireTable_sort_by_entity(void) {
+void OrderByEntireTable_sort_by_entity(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
 
     ecs_add(world, e2, Velocity);
     ecs_add(world, e4, Velocity);
     ecs_add(world, e5, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by = compare_entity,
-        .sort_table = PositionSortByEntity
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by_callback = compare_entity,
+        .order_by_table_callback = PositionSortByEntity
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -271,21 +282,23 @@ void SortingEntireTable_sort_by_entity(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_after_add(void) {
+void OrderByEntireTable_sort_after_add(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 0}));
 
     ecs_add(world, e3, Velocity);
     ecs_add(world, e4, Velocity);
@@ -293,11 +306,11 @@ void SortingEntireTable_sort_after_add(void) {
 
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -348,23 +361,25 @@ void SortingEntireTable_sort_after_add(void) {
     test_int(it.count, 1);    
     test_assert(it.entities[0] == e3);
 
-    test_assert(!ecs_query_next(&it));     
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);   
 
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_after_remove(void) {
+void OrderByEntireTable_sort_after_remove(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 0}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -376,11 +391,11 @@ void SortingEntireTable_sort_after_remove(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -451,21 +466,23 @@ void SortingEntireTable_sort_after_remove(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_after_delete(void) {
+void OrderByEntireTable_sort_after_delete(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 0}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -477,11 +494,11 @@ void SortingEntireTable_sort_after_delete(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -536,21 +553,23 @@ void SortingEntireTable_sort_after_delete(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_after_set(void) {
+void OrderByEntireTable_sort_after_set(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 0}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -562,11 +581,11 @@ void SortingEntireTable_sort_after_set(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -608,14 +627,16 @@ void SortingEntireTable_sort_after_set(void) {
     test_int(it.count, 1);    
     test_assert(it.entities[0] == e1);
 
-    test_assert(!ecs_query_next(&it)); 
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
 static
 void FlipP(ecs_iter_t *it) {
-    Position *p = ecs_field(it, Position, 1);
+    Position *p = ecs_field(it, Position, 0);
 
     int32_t i;
     for (i = 0; i < it->count; i ++) {
@@ -625,7 +646,7 @@ void FlipP(ecs_iter_t *it) {
     }
 }
 
-void SortingEntireTable_sort_after_system(void) {
+void OrderByEntireTable_sort_after_system(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Velocity);
@@ -634,11 +655,11 @@ void SortingEntireTable_sort_after_system(void) {
 
     ECS_SYSTEM(world, FlipP, EcsOnUpdate, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 5});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 6});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 1});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 3});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 5}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 2}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 6}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 1}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 3}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -650,11 +671,11 @@ void SortingEntireTable_sort_after_system(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, [in] Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, [in] Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -720,21 +741,23 @@ void SortingEntireTable_sort_after_system(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_after_query(void) {
+void OrderByEntireTable_sort_after_query(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Mass);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {3, 5});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 2});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {6, 6});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 1});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {5, 3});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 5}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 2}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {6, 6}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 1}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {5, 3}));
 
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);   
@@ -746,12 +769,12 @@ void SortingEntireTable_sort_after_query(void) {
     ecs_add(world, e2, Mass);
     ecs_add(world, e3, Mass);
 
-    ecs_query_t *flip_q = ecs_query_new(world, "Position");
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position, [in] Velocity",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *flip_q = ecs_query(world, { .expr = "Position" });
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, [in] Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -825,24 +848,27 @@ void SortingEntireTable_sort_after_query(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+    ecs_query_fini(flip_q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_by_component_move_pivot(void) {
+void OrderByEntireTable_sort_by_component_move_pivot(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {10, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {1, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {10, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {1, 0}));
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -857,29 +883,31 @@ void SortingEntireTable_sort_by_component_move_pivot(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_1000_entities(void) {
+void OrderByEntireTable_sort_1000_entities(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position)
     });
 
     for (int i = 0; i < 1000; i ++) {
         int32_t v = rand();
-        ecs_set(world, 0, Position, {v});
+        ecs_insert(world, ecs_value(Position, {v}));
 
         int32_t x = 0;
 
         ecs_iter_t it = ecs_query_iter(world, q);
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             test_assert(it.count == (i + 1));
 
@@ -891,30 +919,32 @@ void SortingEntireTable_sort_1000_entities(void) {
         }
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_1000_entities_w_duplicates(void) {
+void OrderByEntireTable_sort_1000_entities_w_duplicates(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position)
     });
 
     for (int i = 0; i < 500; i ++) {
         int32_t v = rand();
-        ecs_set(world, 0, Position, {v});
-        ecs_set(world, 0, Position, {v});
+        ecs_insert(world, ecs_value(Position, {v}));
+        ecs_insert(world, ecs_value(Position, {v}));
 
         int32_t x = 0;
 
         ecs_iter_t it = ecs_query_iter(world, q);
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             test_assert(it.count == (i + 1) * 2);
 
@@ -926,22 +956,24 @@ void SortingEntireTable_sort_1000_entities_w_duplicates(void) {
         }
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_1000_entities_again(void) {
+void OrderByEntireTable_sort_1000_entities_again(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
-    ecs_entity_t start = ecs_new(world, 0);
+    ecs_entity_t start = ecs_new(world);
 
     for (int i = 0; i < 1000; i ++) {
         int32_t v = rand();
@@ -950,7 +982,7 @@ void SortingEntireTable_sort_1000_entities_again(void) {
 
         ecs_iter_t it = ecs_query_iter(world, q);
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             test_assert(it.count == (i + 1));
 
@@ -971,7 +1003,7 @@ void SortingEntireTable_sort_1000_entities_again(void) {
 
     ecs_iter_t it = ecs_query_iter(world, q);
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         test_assert(it.count == 1000);
 
@@ -980,35 +1012,36 @@ void SortingEntireTable_sort_1000_entities_again(void) {
             test_assert(x <= p[j].x);
             x = p[j].x;
         }
-    }    
+    }
 
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_1000_entities_2_types(void) {
+void OrderByEntireTable_sort_1000_entities_2_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     for (int i = 0; i < 500; i ++) {
         int32_t v = rand();
-        ecs_set(world, 0, Position, {v});
-        ecs_entity_t e = ecs_set(world, 0, Position, {v});
+        ecs_insert(world, ecs_value(Position, {v}));
+        ecs_entity_t e = ecs_insert(world, ecs_value(Position, {v}));
         ecs_add(world, e, Velocity);
 
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0, x = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1022,23 +1055,25 @@ void SortingEntireTable_sort_1000_entities_2_types(void) {
         test_int(count, (i + 1) * 2);
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_1000_entities_2_types_again(void) {
+void OrderByEntireTable_sort_1000_entities_2_types_again(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
-    ecs_entity_t start = ecs_new(world, 0);
+    ecs_entity_t start = ecs_new(world);
 
     for (int i = 0; i < 1000; i ++) {
         int32_t v = rand();
@@ -1051,7 +1086,7 @@ void SortingEntireTable_sort_1000_entities_2_types_again(void) {
 
         ecs_iter_t it = ecs_query_iter(world, q);
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             int32_t j, x = 0;
             for (j = 0; j < it.count; j ++) {  
@@ -1069,7 +1104,7 @@ void SortingEntireTable_sort_1000_entities_2_types_again(void) {
     ecs_iter_t it = ecs_query_iter(world, q);
     int32_t count = 0, x = 0;
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         count += it.count;
 
@@ -1082,23 +1117,25 @@ void SortingEntireTable_sort_1000_entities_2_types_again(void) {
 
     test_int(count, 1000);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_1000_entities_add_type_after_sort(void) {
+void OrderByEntireTable_sort_1000_entities_add_type_after_sort(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
-    ecs_entity_t start = ecs_new(world, 0);
+    ecs_entity_t start = ecs_new(world);
 
     for (int i = 0; i < 500; i ++) {
         int32_t v = rand();
@@ -1108,7 +1145,7 @@ void SortingEntireTable_sort_1000_entities_add_type_after_sort(void) {
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1136,7 +1173,7 @@ void SortingEntireTable_sort_1000_entities_add_type_after_sort(void) {
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0, x = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1148,37 +1185,39 @@ void SortingEntireTable_sort_1000_entities_add_type_after_sort(void) {
         }
 
         test_int(count, i + 500 + 1);
-    }    
+    }
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_1500_entities_3_types(void) {
+void OrderByEntireTable_sort_1500_entities_3_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     for (int i = 0; i < 500; i ++) {
-        ecs_set(world, 0, Position, {rand()});
-        ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+        ecs_insert(world, ecs_value(Position, {rand()}));
+        ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Velocity);
 
-        e = ecs_set(world, 0, Position, {rand()});
+        e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Mass);
 
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0, x = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1192,40 +1231,42 @@ void SortingEntireTable_sort_1500_entities_3_types(void) {
         test_int(count, (i + 1) * 3);
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_2000_entities_4_types(void) {
+void OrderByEntireTable_sort_2000_entities_4_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
     for (int i = 0; i < 500; i ++) {
-        ecs_set(world, 0, Position, {rand()});
+        ecs_insert(world, ecs_value(Position, {rand()}));
 
-        ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+        ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Velocity);
 
-        e = ecs_set(world, 0, Position, {rand()});
+        e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Mass);
 
-        e = ecs_set(world, 0, Position, {rand()});
+        e = ecs_insert(world, ecs_value(Position, {rand()}));
         ecs_add(world, e, Velocity);
         ecs_add(world, e, Mass);        
 
         ecs_iter_t it = ecs_query_iter(world, q);
         int32_t count = 0, x = 0;
         while (ecs_query_next(&it)) {
-            Position *p = ecs_field(&it, Position, 1);
+            Position *p = ecs_field(&it, Position, 0);
 
             count += it.count;
 
@@ -1239,33 +1280,35 @@ void SortingEntireTable_sort_2000_entities_4_types(void) {
         test_int(count, (i + 1) * 4);
     }
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_shared_component(void) {
+void OrderByEntireTable_sort_shared_component(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
 
-    ecs_entity_t base_1 = ecs_set(world, 0, Position, {0, 0});
-    ecs_entity_t base_2 = ecs_set(world, 0, Position, {3, 0});
-    ecs_entity_t base_3 = ecs_set(world, 0, Position, {7, 0});
+    ecs_entity_t base_1 = ecs_insert(world, ecs_value(Position, {0, 0}));
+    ecs_entity_t base_2 = ecs_insert(world, ecs_value(Position, {3, 0}));
+    ecs_entity_t base_3 = ecs_insert(world, ecs_value(Position, {7, 0}));
 
-    ecs_entity_t e1 = ecs_set(world, 0, Position, {6, 0});
-    ecs_entity_t e2 = ecs_set(world, 0, Position, {1, 0});
-    ecs_entity_t e3 = ecs_set(world, 0, Position, {5, 0});
-    ecs_entity_t e4 = ecs_set(world, 0, Position, {2, 0});
-    ecs_entity_t e5 = ecs_set(world, 0, Position, {4, 0});
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {6, 0}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {1, 0}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {5, 0}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {2, 0}));
+    ecs_entity_t e5 = ecs_insert(world, ecs_value(Position, {4, 0}));
     ecs_entity_t e6 = ecs_new_w_pair(world, EcsIsA, base_3);
     ecs_entity_t e7 = ecs_new_w_pair(world, EcsIsA, base_2);
     ecs_entity_t e8 = ecs_new_w_pair(world, EcsIsA, base_1);
     ecs_entity_t e9 = ecs_new_w_pair(world, EcsIsA, base_1);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position(self|up)",
-        .filter.instanced = true,
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self|up IsA)",
+        .flags = EcsQueryIsInstanced,
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
     });
 
     ecs_iter_t it = ecs_query_iter(world, q);
@@ -1301,31 +1344,33 @@ void SortingEntireTable_sort_shared_component(void) {
 
     test_assert(!ecs_query_next(&it));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_2_entities_2_types(void) {
+void OrderByEntireTable_sort_2_entities_2_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
-    ecs_set(world, 0, Position, {rand()});
+    ecs_insert(world, ecs_value(Position, {rand()}));
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Velocity); 
 
     ecs_iter_t it = ecs_query_iter(world, q);
     int32_t count = 0;
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         count += it.count;
 
@@ -1338,35 +1383,37 @@ void SortingEntireTable_sort_2_entities_2_types(void) {
 
     test_int(count, 2);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_3_entities_3_types(void) {
+void OrderByEntireTable_sort_3_entities_3_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
-    ecs_set(world, 0, Position, {rand()});
+    ecs_insert(world, ecs_value(Position, {rand()}));
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Velocity);
 
-    e = ecs_set(world, 0, Position, {rand()});
+    e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Mass);   
 
     ecs_iter_t it = ecs_query_iter(world, q);
     int32_t count = 0;
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         count += it.count;
 
@@ -1379,25 +1426,27 @@ void SortingEntireTable_sort_3_entities_3_types(void) {
 
     test_int(count, 3);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_3_entities_3_types_2(void) {
+void OrderByEntireTable_sort_3_entities_3_types_2(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Tag",
-        .order_by = compare_entity,
-        .sort_table = PositionSortByEntity
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag",
+        .order_by_callback = compare_entity,
+        .order_by_table_callback = PositionSortByEntity
     });
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
 
     ecs_add_id(world, e1, Foo);
     ecs_add_id(world, e2, Bar);
@@ -1418,39 +1467,41 @@ void SortingEntireTable_sort_3_entities_3_types_2(void) {
 
     test_int(count, 3);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_4_entities_4_types(void) {
+void OrderByEntireTable_sort_4_entities_4_types(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
     ECS_COMPONENT(world, Mass);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
-    ecs_set(world, 0, Position, {rand()});
+    ecs_insert(world, ecs_value(Position, {rand()}));
 
-    ecs_entity_t e = ecs_set(world, 0, Position, {rand()});
+    ecs_entity_t e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Velocity);
 
-    e = ecs_set(world, 0, Position, {rand()});
+    e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Mass);
 
-    e = ecs_set(world, 0, Position, {rand()});
+    e = ecs_insert(world, ecs_value(Position, {rand()}));
     ecs_add(world, e, Velocity);
     ecs_add(world, e, Mass);     
 
     ecs_iter_t it = ecs_query_iter(world, q);
     int32_t count = 0;
     while (ecs_query_next(&it)) {
-        Position *p = ecs_field(&it, Position, 1);
+        Position *p = ecs_field(&it, Position, 0);
 
         count += it.count;
 
@@ -1463,21 +1514,23 @@ void SortingEntireTable_sort_4_entities_4_types(void) {
 
     test_int(count, 4);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_w_tags_only(void) {
+void OrderByEntireTable_sort_w_tags_only(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{Tag}},
-        .order_by = compare_entity,
-        .sort_table = PositionSortByEntity
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{Tag}},
+        .order_by_callback = compare_entity,
+        .order_by_table_callback = PositionSortByEntity
     });
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, root);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, root);
 
@@ -1491,21 +1544,23 @@ void SortingEntireTable_sort_w_tags_only(void) {
     test_int(it.entities[1], e2);
     ecs_iter_fini(&it);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_childof_marked(void) {
+void OrderByEntireTable_sort_childof_marked(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{Tag}},
-        .order_by = compare_entity,
-        .sort_table = PositionSortByEntity
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{Tag}},
+        .order_by_callback = compare_entity,
+        .order_by_table_callback = PositionSortByEntity
     });
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsChildOf, root);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsChildOf, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsChildOf, root);
@@ -1524,21 +1579,23 @@ void SortingEntireTable_sort_childof_marked(void) {
     test_assert(!ecs_is_alive(world, e2));
     test_assert(!ecs_is_alive(world, e3));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_isa_marked(void) {
+void OrderByEntireTable_sort_isa_marked(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{Tag}},
-        .order_by = compare_entity,
-        .sort_table = PositionSortByEntity
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{Tag}},
+        .order_by_callback = compare_entity,
+        .order_by_table_callback = PositionSortByEntity
     });
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, root);
     ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, root);
@@ -1560,22 +1617,24 @@ void SortingEntireTable_sort_isa_marked(void) {
     test_int(1, ecs_get_type(world, e3)->count);
     test_assert(ecs_has(world, e3, Tag));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_sort_relation_marked(void) {
+void OrderByEntireTable_sort_relation_marked(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
     ECS_TAG(world, Rel);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.terms = {{Tag}},
-        .order_by = compare_entity,
-        .sort_table = PositionSortByEntity
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{Tag}},
+        .order_by_callback = compare_entity,
+        .order_by_table_callback = PositionSortByEntity
     });
 
-    ecs_entity_t root = ecs_new_id(world);
+    ecs_entity_t root = ecs_new(world);
     ecs_entity_t e1 = ecs_new_w_pair(world, Rel, root);
     ecs_entity_t e2 = ecs_new_w_pair(world, Rel, e1);
     ecs_entity_t e3 = ecs_new_w_pair(world, Rel, root);
@@ -1597,6 +1656,8 @@ void SortingEntireTable_sort_relation_marked(void) {
     test_int(1, ecs_get_type(world, e3)->count);
     test_assert(ecs_has(world, e3, Tag));
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
@@ -1613,23 +1674,23 @@ int dummy_compare(
     return (e1 > e2) - (e1 < e2);
 }
 
-void SortingEntireTable_dont_resort_after_set_unsorted_component(void) {
+void OrderByEntireTable_dont_resort_after_set_unsorted_component(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Position);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "[in] Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = dummy_compare
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = dummy_compare
     });
 
-    ecs_entity_t e1 = ecs_new(world, 0);
+    ecs_entity_t e1 = ecs_new(world);
     ecs_set(world, e1, Position, {0, 0});
     ecs_set(world, e1, Velocity, {0, 0});
 
-    ecs_entity_t e2 = ecs_new(world, 0);
+    ecs_entity_t e2 = ecs_new(world);
     ecs_set(world, e2, Position, {0, 0});
     ecs_set(world, e2, Velocity, {0, 0});
 
@@ -1656,10 +1717,12 @@ void SortingEntireTable_dont_resort_after_set_unsorted_component(void) {
     test_bool(dummy_compare_invoked, true);
     ecs_iter_fini(&it);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag(void) {
+void OrderByEntireTable_dont_resort_after_set_unsorted_component_w_tag(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Velocity);
@@ -1674,10 +1737,10 @@ void SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag(void) {
 
     test_assert(Tag < ecs_id(Position));
 
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "[in] Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = dummy_compare
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = dummy_compare
     });
 
     ecs_entity_t e1 = ecs_new_w_id(world, Tag);
@@ -1711,10 +1774,12 @@ void SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag(void) {
     test_bool(dummy_compare_invoked, true);
     ecs_iter_fini(&it);
 
+    ecs_query_fini(q);
+
     ecs_fini(world);
 }
 
-void SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void) {
+void OrderByEntireTable_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_COMPONENT(world, Velocity);
@@ -1728,16 +1793,16 @@ void SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag_w_out_ter
     test_assert(Tag < ecs_id(Position));
 
     // Sorted query
-    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
-        .filter.expr = "[in] Position",
-        .order_by_component = ecs_id(Position),
-        .order_by = dummy_compare
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "[in] Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = dummy_compare,
     });
 
     // Dummy queries that mutate
-    ecs_query_t *q_a = ecs_query_new(world, "Position"); // [inout]
-    ecs_query_t *q_b = ecs_query_new(world, "[out] Position");
-    ecs_query_t *q_c = ecs_query_new(world, "[out] Velocity");
+    ecs_query_t *q_a = ecs_query(world, { .expr = "Position" }); // [inou }t]
+    ecs_query_t *q_b = ecs_query(world, { .expr = "[out] Position" });
+    ecs_query_t *q_c = ecs_query(world, { .expr = "[out] Velocity" });
 
     ecs_entity_t e1 = ecs_new_w_id(world, Tag);
     ecs_set(world, e1, Position, {0, 0});
@@ -1778,6 +1843,66 @@ void SortingEntireTable_dont_resort_after_set_unsorted_component_w_tag_w_out_ter
     dummy_compare_invoked = false;
     ecs_iter_fini(&itq);
 
+    ecs_query_fini(q);
+    ecs_query_fini(q_a);
+    ecs_query_fini(q_b);
+    ecs_query_fini(q_c);
+
+    ecs_fini(world);
+}
+
+void OrderByEntireTable_sort_not_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void OrderByEntireTable_sort_or_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position || Velocity",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void OrderByEntireTable_sort_optional_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
+    });
+
+    test_assert(q == NULL);
+
     ecs_fini(world);
 }
 
@@ -1787,16 +1912,68 @@ void SortingEntireTable_sort_shared_w_delete(void) {
     ECS_COMPONENT(world, Position);
 
     ecs_query_t *q = ecs_query(world, {
-        .filter.terms = {
+        .terms = {
+            { .id = ecs_id(Position), .inout = EcsIn }
+        },
+        .flags = EcsQueryIsInstanced,
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
+    });
+
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {0, 0}));
+    ecs_add_id(world, base, EcsPrefab);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e3 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e4 = ecs_new_w_pair(world, EcsIsA, base);
+    ecs_entity_t e5 = ecs_new_w_pair(world, EcsIsA, base);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(5, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+        test_uint(e4, it.entities[3]);
+        test_uint(e5, it.entities[4]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_delete(world, e1);
+    ecs_delete(world, e2);
+    ecs_delete(world, e3);
+    ecs_delete(world, e4);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e5, it.entities[4]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_fini(world);
+}
+
+void OrderByEntireTable_sort_shared_w_delete(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
             { .id = ecs_id(Position), .inout = EcsIn }
         },
-        .filter.instanced = true,
-        .order_by_component = ecs_id(Position),
-        .order_by = ecs_compare(Position),
-        .sort_table = ecs_sort_table(Position)
+        .flags = EcsQueryIsInstanced,
+        .order_by = ecs_id(Position),
+        .order_by_callback = ecs_compare(Position),
+        .order_by_table_callback = ecs_sort_table(Position)
     });
 
-    ecs_entity_t base = ecs_set(world, 0, Position, {0, 0});
+    ecs_entity_t base = ecs_insert(world, ecs_value(Position, {0, 0}));
     ecs_add_id(world, base, EcsPrefab);
 
     ecs_entity_t e1 = ecs_new_w_pair(world, EcsIsA, base);
diff --git a/test/addons/src/Parser.c b/test/query/src/Parser.c
similarity index 62%
rename from test/addons/src/Parser.c
rename to test/query/src/Parser.c
index 5c36f4679..cc0ac3e52 100644
--- a/test/addons/src/Parser.c
+++ b/test/query/src/Parser.c
@@ -1,28 +1,61 @@
-#include <addons.h>
+#include <query.h>
 
 static
-int filter_count(ecs_filter_t *f) {
-    test_assert(f != NULL);
-    return f->term_count;
+int term_count(ecs_query_t *q) {
+    test_assert(q != NULL);
+    return q->term_count;
 }
 
 static
-ecs_term_t* filter_terms(ecs_filter_t *f) {
-    test_assert(f != NULL);
-    return f->terms;
+ecs_term_t* query_terms(ecs_query_t *q) {
+    test_assert(q != NULL);
+    return q->terms;
 }
 
+static
+void print_term_id_flags(ecs_id_t value) {
+    if (value & EcsIsEntity) {
+        printf("|EcsIsEntity");
+    }
+    if (value & EcsIsVariable) {
+        printf("|EcsIsVariable");
+    }
+    if (value & EcsIsName) {
+        printf("|EcsIsName");
+    }
+    if (value & EcsSelf) {
+        printf("|EcsSelf");
+    }
+    if (value & EcsUp) {
+        printf("|EcsUp");
+    }
+    if (value & EcsCascade) {
+        printf("|EcsCascade");
+    }
+    if (value & EcsDesc) {
+        printf("|EcsDesc");
+    }
+}
+
+#define test_id(actual, value)\
+    if ((value) != (actual)) {\
+        printf("actual:   %u", (uint32_t)(actual));\
+        print_term_id_flags(actual);\
+        printf("\n");\
+        printf("expected: %u", (uint32_t)(value));\
+        print_term_id_flags(value);\
+        printf("\n");\
+        test_assert(false);\
+    }
+
 #define test_first(column, e, flgs)\
-    test_int(column.first.id, e);\
-    test_int(column.first.flags, flgs);
+    test_id(column.first.id, e | flgs);
 
 #define test_src(column, e, flgs)\
-    test_int(column.src.id, e);\
-    test_int(column.src.flags, flgs);
+    test_id(column.src.id, e | flgs);
 
 #define test_second(column, e, flgs)\
-    test_int(column.second.id, e);\
-    test_int(column.second.flags, flgs);
+    test_id(column.second.id, e | flgs);
 
 #define test_first_var(column, e, flgs, str)\
     test_first(column, e, flgs|EcsIsVariable);\
@@ -81,15 +114,14 @@ void Parser_0(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "0"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 0);
+    test_int(term_count(q), 0);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -99,21 +131,20 @@ void Parser_component_implicit_subject(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -124,21 +155,20 @@ void Parser_component_explicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(Subj)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -148,20 +178,20 @@ void Parser_component_explicit_subject_this(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred($This)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred($this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
+    test_assert(terms[0].src.name == NULL);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -171,21 +201,20 @@ void Parser_component_explicit_subject_this_by_name(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(this)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -195,21 +224,20 @@ void Parser_component_explicit_subject_this_by_var_name(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred($This)"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred($this)"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -219,20 +247,19 @@ void Parser_component_explicit_subject_wildcard(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(*)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsWildcard, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -242,20 +269,19 @@ void Parser_component_explicit_subject_any(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(_)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsAny, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -265,21 +291,20 @@ void Parser_component_explicit_subject_0(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(0)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -289,20 +314,19 @@ void Parser_this_as_predicate(void) {
 
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "this(Subj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsThis, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -312,20 +336,19 @@ void Parser_this_var_as_predicate(void) {
 
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$This(Subj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "$this(Subj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -335,20 +358,19 @@ void Parser_this_lowercase_var_as_predicate(void) {
 
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$this(Subj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -359,21 +381,20 @@ void Parser_this_as_object(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(Subj, this)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], EcsThis, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -384,21 +405,20 @@ void Parser_this_var_as_object(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(Subj, $This)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(Subj, $this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -409,21 +429,20 @@ void Parser_pair_implicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Pred, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -434,21 +453,20 @@ void Parser_pair_implicit_subject_wildcard_pred(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(*, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsWildcard, EcsSelf|EcsIsVariable);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -459,21 +477,20 @@ void Parser_pair_implicit_subject_wildcard_obj(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Pred, *)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], EcsWildcard, EcsSelf|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -484,21 +501,20 @@ void Parser_pair_implicit_subject_any_pred(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(_, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsAny, EcsSelf|EcsIsVariable);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -509,21 +525,20 @@ void Parser_pair_implicit_subject_any_obj(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Pred, _)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], EcsAny, EcsSelf|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -534,21 +549,20 @@ void Parser_pair_implicit_subject_this_pred(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "($This, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "($this, Obj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -559,21 +573,20 @@ void Parser_pair_implicit_subject_this_obj(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred, $This)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "(Pred, $this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -584,21 +597,20 @@ void Parser_pair_implicit_subject_pred_w_self(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred:self, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "(Pred|self, Obj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -609,21 +621,20 @@ void Parser_pair_implicit_subject_obj_w_self(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred, Obj:self)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "(Pred, Obj|self)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -634,21 +645,20 @@ void Parser_pair_implicit_subject_pred_w_up(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred:up, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "(Pred|up, Obj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsUp|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -659,21 +669,20 @@ void Parser_pair_implicit_subject_obj_w_up(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred, Obj:up)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "(Pred, Obj|up)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -684,21 +693,20 @@ void Parser_pair_implicit_subject_pred_w_self_up(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred:self|up, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "(Pred|self|up, Obj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsUp|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -709,77 +717,20 @@ void Parser_pair_implicit_subject_obj_w_self_up(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred, Obj:self|up)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "(Pred, Obj|self|up)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Parser_pair_implicit_subject_pred_w_up_trav(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Pred);
-    ECS_TAG(world, Obj);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred:up(ChildOf), Obj)"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsUp|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-    
-    test_assert(terms[0].first.trav == EcsChildOf);
-    test_assert(terms[0].second.trav == 0);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Parser_pair_implicit_subject_obj_w_up_trav(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Pred);
-    ECS_TAG(world, Obj);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred, Obj:up(ChildOf))"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_second(terms[0], Obj, EcsUp|EcsIsEntity);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-
-    test_assert(terms[0].first.trav == 0);
-    test_assert(terms[0].second.trav == EcsChildOf);
-
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -790,12 +741,11 @@ void Parser_pair_implicit_subject_pred_w_invalid_flags(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred:, Obj)"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "(Pred|, Obj)"
+    });
+    test_assert(q == NULL);
 
     ecs_fini(world);
 }
@@ -806,12 +756,11 @@ void Parser_pair_implicit_subject_obj_w_invalid_flags(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "(Pred, Obj:)"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "(Pred, Obj|)"
+    });
+    test_assert(q == NULL);
 
     ecs_fini(world);
 }
@@ -823,21 +772,20 @@ void Parser_pair_explicit_subject(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(Subj, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -848,21 +796,20 @@ void Parser_pair_explicit_subject_this(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred($This, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred($this, Obj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -873,21 +820,20 @@ void Parser_pair_explicit_subject_this_by_name(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(this, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -898,21 +844,20 @@ void Parser_pair_explicit_subject_this_by_var_name(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred($This, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred($this, Obj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -923,21 +868,20 @@ void Parser_pair_explicit_subject_wildcard_pred(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "*($This, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "*($this, Obj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsWildcard, EcsSelf|EcsIsVariable);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -948,21 +892,20 @@ void Parser_pair_explicit_subject_wildcard_subj(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(*, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsWildcard, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -973,21 +916,20 @@ void Parser_pair_explicit_subject_wildcard_obj(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred($This, *)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred($this, *)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], EcsWildcard, EcsSelf|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -995,22 +937,21 @@ void Parser_pair_explicit_subject_wildcard_obj(void) {
 void Parser_pair_implicit_subject_0_object(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(ChildOf, 0)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
-    test_second(terms[0], 0, EcsIsEntity);
+    test_second(terms[0], 0, EcsIsEntity|EcsSelf);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
     test_int(terms[0].id, ecs_pair(EcsChildOf, 0));
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1018,22 +959,21 @@ void Parser_pair_implicit_subject_0_object(void) {
 void Parser_pair_explicit_subject_0_object(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "ChildOf($This, 0)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "ChildOf($this, 0)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
-    test_second(terms[0], 0, EcsIsEntity);
+    test_second(terms[0], 0, EcsIsEntity|EcsSelf);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
     test_int(terms[0].id, ecs_pair(EcsChildOf, 0));
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1044,21 +984,20 @@ void Parser_pair_explicit_subject_0(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(0, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1068,20 +1007,19 @@ void Parser_in_component_implicit_subject(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[in] Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1092,20 +1030,19 @@ void Parser_in_component_explicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[in] Pred(Subj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1116,21 +1053,20 @@ void Parser_in_pair_implicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[in] (Pred, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1142,21 +1078,20 @@ void Parser_in_pair_explicit_subject(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[in] Pred(Subj, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1166,20 +1101,19 @@ void Parser_inout_component_implicit_subject(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[inout] Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOut);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1190,20 +1124,19 @@ void Parser_inout_component_explicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[inout] Pred(Subj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOut);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1214,21 +1147,20 @@ void Parser_inout_pair_implicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[inout] (Pred, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOut);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1240,21 +1172,20 @@ void Parser_inout_pair_explicit_subject(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[inout] Pred(Subj, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOut);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1264,20 +1195,19 @@ void Parser_out_component_implicit_subject(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[out] Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsOut);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1288,20 +1218,19 @@ void Parser_out_component_explicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[out] Pred(Subj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsOut);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1312,21 +1241,20 @@ void Parser_out_pair_implicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[out] (Pred, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsOut);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1338,21 +1266,20 @@ void Parser_out_pair_explicit_subject(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[out] Pred(Subj, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsOut);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1362,20 +1289,63 @@ void Parser_inout_filter_component(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[none] Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_inout_w_not_operator(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred);
+
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "[out] !Pred"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[0].oper, EcsNot);
+    test_int(terms[0].inout, EcsOut);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_inout_w_optional_operator(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred);
+
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "[in] ?Pred"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[0].oper, EcsOptional);
+    test_int(terms[0].inout, EcsIn);
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1385,20 +1355,19 @@ void Parser_component_singleton(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred($)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Pred, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1410,20 +1379,19 @@ void Parser_this_singleton(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$This($)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "$this($)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1433,20 +1401,19 @@ void Parser_component_implicit_no_subject(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred()"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1456,20 +1423,19 @@ void Parser_component_explicit_no_subject(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(0)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1480,21 +1446,20 @@ void Parser_pair_no_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(0, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1505,20 +1470,19 @@ void Parser_variable_single_char(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, X);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred($X)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src_var(terms[0], 0, EcsSelf|EcsUp, "X");
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1529,20 +1493,19 @@ void Parser_variable_multi_char(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, XYZ);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred($XYZ)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src_var(terms[0], 0, EcsSelf|EcsUp, "XYZ");
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1553,20 +1516,19 @@ void Parser_variable_multi_char_w_underscore(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, XY_Z);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred($XY_Z)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src_var(terms[0], 0, EcsSelf|EcsUp, "XY_Z");
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1577,20 +1539,19 @@ void Parser_variable_multi_char_w_number(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, XY_1);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred($XY_1)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src_var(terms[0], 0, EcsSelf|EcsUp, "XY_1");
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1601,20 +1562,19 @@ void Parser_variable_multi_char_not_allcaps(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, XYZ);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred($xyZ)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src_var(terms[0], 0, EcsSelf|EcsUp, "xyZ");
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1625,21 +1585,20 @@ void Parser_pred_var(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "($Pred, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first_var(terms[0], 0, EcsSelf, "Pred");
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1649,21 +1608,20 @@ void Parser_obj_var(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Pred, $Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second_var(terms[0], 0, EcsSelf, "Obj");
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1673,20 +1631,19 @@ void Parser_component_not(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "!Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsNot);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1697,21 +1654,20 @@ void Parser_pair_implicit_subject_not(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "!(Pred, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsNot);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1723,21 +1679,20 @@ void Parser_pair_explicit_subject_not(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "!Pred(Subj, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsNot);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1748,14 +1703,13 @@ void Parser_2_component_not(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "!Pred_1, !Pred_2"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsNot);
@@ -1766,7 +1720,7 @@ void Parser_2_component_not(void) {
     test_int(terms[1].oper, EcsNot);
     test_int(terms[1].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1777,14 +1731,13 @@ void Parser_2_component_not_no_space(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "!Pred_1,!Pred_2"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsNot);
@@ -1795,7 +1748,7 @@ void Parser_2_component_not_no_space(void) {
     test_int(terms[1].oper, EcsNot);
     test_int(terms[1].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1805,20 +1758,19 @@ void Parser_component_optional(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "?Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsOptional);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1829,14 +1781,13 @@ void Parser_2_component_optional(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "?Pred_1, ?Pred_2"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsOptional);
@@ -1847,7 +1798,7 @@ void Parser_2_component_optional(void) {
     test_int(terms[1].oper, EcsOptional);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1858,14 +1809,13 @@ void Parser_2_component_optional_no_space(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "?Pred_1,?Pred_2"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsOptional);
@@ -1876,7 +1826,7 @@ void Parser_2_component_optional_no_space(void) {
     test_int(terms[1].oper, EcsOptional);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1886,20 +1836,19 @@ void Parser_from_and(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "AND | Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAndFrom);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1909,20 +1858,19 @@ void Parser_from_or(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "OR | Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsOrFrom);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1932,20 +1880,19 @@ void Parser_from_not(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "NOT | Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsNotFrom);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1956,21 +1903,20 @@ void Parser_pair_implicit_subject_optional(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "?(Pred, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsOptional);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -1982,21 +1928,20 @@ void Parser_pair_explicit_subject_optional(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "?Pred(Subj, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsOptional);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -2006,21 +1951,19 @@ void Parser_pred_implicit_subject_w_role(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TOGGLE | Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_TOGGLE);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);    
 }
@@ -2030,21 +1973,19 @@ void Parser_pred_explicit_subject_w_role(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "TOGGLE | Pred($This)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "TOGGLE | Pred($this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_TOGGLE);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);    
 }
@@ -2054,21 +1995,19 @@ void Parser_pred_no_subject_w_role(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TOGGLE | Pred()"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_TOGGLE);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);  
 }
@@ -2079,22 +2018,20 @@ void Parser_pair_implicit_subject_w_role(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Pred, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_PAIR);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);   
 }
@@ -2105,22 +2042,20 @@ void Parser_pair_explicit_subject_w_role(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred($This, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred($this, Obj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_PAIR);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2130,21 +2065,19 @@ void Parser_inout_role_pred_implicit_subject(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[inout] TOGGLE | Pred"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOut);
-    test_int(terms[0].id_flags, ECS_TOGGLE);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);  
 }
@@ -2154,21 +2087,19 @@ void Parser_inout_role_pred_no_subject(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[inout] TOGGLE | Pred()"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOut);
-    test_int(terms[0].id_flags, ECS_TOGGLE);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);  
 }
@@ -2178,21 +2109,19 @@ void Parser_inout_role_pred_explicit_subject(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "[inout] TOGGLE | Pred($This)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "[inout] TOGGLE | Pred($this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOut);
-    test_int(terms[0].id_flags, ECS_TOGGLE);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);  
 }
@@ -2203,22 +2132,20 @@ void Parser_inout_role_pair_implicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[inout] (Pred, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOut);
-    test_int(terms[0].id_flags, ECS_PAIR);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);  
 }
@@ -2229,22 +2156,20 @@ void Parser_inout_role_pair_explicit_subject(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "[inout] Pred($This, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "[inout] Pred($this, Obj)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOut);
-    test_int(terms[0].id_flags, ECS_PAIR);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);  
 }
@@ -2255,14 +2180,13 @@ void Parser_2_pred_implicit_subject(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred_1, Pred_2"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -2274,7 +2198,7 @@ void Parser_2_pred_implicit_subject(void) {
     test_int(terms[1].inout, EcsInOutDefault);    
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2285,14 +2209,13 @@ void Parser_2_pred_no_subject(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred_1(), Pred_2()"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
@@ -2304,7 +2227,7 @@ void Parser_2_pred_no_subject(void) {
     test_int(terms[1].inout, EcsInOutDefault);    
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2315,14 +2238,13 @@ void Parser_2_pred_explicit_subject(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred_1($This), Pred_2($This)"
-    }));
-    test_int(filter_count(&f), 2);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1($this), Pred_2($this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -2334,7 +2256,7 @@ void Parser_2_pred_explicit_subject(void) {
     test_int(terms[1].inout, EcsInOutDefault);    
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2347,14 +2269,13 @@ void Parser_2_pair_implicit_subject(void) {
     ECS_TAG(world, Obj_1);
     ECS_TAG(world, Obj_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Pred_1, Obj_1), (Pred_2, Obj_2)"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj_1, EcsSelf|EcsIsEntity);
@@ -2368,7 +2289,7 @@ void Parser_2_pair_implicit_subject(void) {
     test_int(terms[1].inout, EcsInOutDefault);    
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2381,14 +2302,13 @@ void Parser_2_pair_explicit_subject(void) {
     ECS_TAG(world, Obj_1);
     ECS_TAG(world, Obj_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred_1($This, Obj_1), Pred_2($This, Obj_2)"
-    }));
-    test_int(filter_count(&f), 2);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1($this, Obj_1), Pred_2($this, Obj_2)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj_1, EcsSelf|EcsIsEntity);
@@ -2402,7 +2322,7 @@ void Parser_2_pair_explicit_subject(void) {
     test_int(terms[1].inout, EcsInOutDefault);    
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2413,28 +2333,25 @@ void Parser_2_pred_role(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TOGGLE | Pred_1, TOGGLE | Pred_2"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_TOGGLE);
 
     test_first(terms[1], Pred_2, EcsSelf|EcsIsEntity);
     test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault); 
-    test_int(terms[1].id_flags, ECS_TOGGLE);   
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2447,30 +2364,27 @@ void Parser_2_pair_implicit_subj_role(void) {
     ECS_TAG(world, Obj_1);
     ECS_TAG(world, Obj_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Pred_1, Obj_1), (Pred_2, Obj_2)"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj_1, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_PAIR);
 
     test_first(terms[1], Pred_2, EcsSelf|EcsIsEntity);
     test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[1], Obj_2, EcsSelf|EcsIsEntity);
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault); 
-    test_int(terms[1].id_flags, ECS_PAIR);   
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2483,30 +2397,27 @@ void Parser_2_pair_explicit_subj_role(void) {
     ECS_TAG(world, Obj_1);
     ECS_TAG(world, Obj_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred_1($This, Obj_1), Pred_2($This, Obj_2)"
-    }));
-    test_int(filter_count(&f), 2);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1($this, Obj_1), Pred_2($this, Obj_2)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj_1, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_PAIR);
 
     test_first(terms[1], Pred_2, EcsSelf|EcsIsEntity);
     test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[1], Obj_2, EcsSelf|EcsIsEntity);
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault); 
-    test_int(terms[1].id_flags, ECS_PAIR);   
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2517,14 +2428,13 @@ void Parser_2_or_pred_implicit_subj(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred_1 || Pred_2"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsOr);
@@ -2535,7 +2445,7 @@ void Parser_2_or_pred_implicit_subj(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2546,14 +2456,13 @@ void Parser_2_or_pred_explicit_subj(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred_1($This) || Pred_2($This)"
-    }));
-    test_int(filter_count(&f), 2);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1($this) || Pred_2($this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsOr);
@@ -2564,7 +2473,7 @@ void Parser_2_or_pred_explicit_subj(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2577,14 +2486,13 @@ void Parser_2_or_pair_implicit_subj(void) {
     ECS_TAG(world, Obj_1);
     ECS_TAG(world, Obj_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Pred_1, Obj_1) || (Pred_2, Obj_2)"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);    
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj_1, EcsSelf|EcsIsEntity);
@@ -2597,7 +2505,7 @@ void Parser_2_or_pair_implicit_subj(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2610,14 +2518,13 @@ void Parser_2_or_pair_explicit_subj(void) {
     ECS_TAG(world, Obj_1);
     ECS_TAG(world, Obj_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred_1($This, Obj_1) || Pred_2($This, Obj_2)"
-    }));
-    test_int(filter_count(&f), 2);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1($this, Obj_1) || Pred_2($this, Obj_2)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);    
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj_1, EcsSelf|EcsIsEntity);
@@ -2630,7 +2537,7 @@ void Parser_2_or_pair_explicit_subj(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2641,14 +2548,13 @@ void Parser_2_or_pred_inout(void) {
     ECS_TAG(world, Pred_1);
     ECS_TAG(world, Pred_2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "[inout] Pred_1 || Pred_2"
-    }));
-    test_int(filter_count(&f), 2);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsOr);
@@ -2659,31 +2565,121 @@ void Parser_2_or_pred_inout(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
+void Parser_2_or_no_space(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1||Pred_2"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[0].oper, EcsOr);
+    test_int(terms[0].inout, EcsInOutDefault);
+
+    test_first(terms[1], Pred_2, EcsSelf|EcsIsEntity);
+    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Parser_2_or_w_not_1st_arg(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "!Pred_1 || Pred_2"
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world); 
+}
+
+void Parser_2_or_w_not_2nd_arg(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1 || !Pred_2"
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world); 
+}
+
+void Parser_2_or_w_optional_1st_arg(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "?Pred_1 || Pred_2"
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world); 
+}
+
+void Parser_2_or_w_optional_2nd_arg(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1 || ?Pred_2"
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world); 
+}
+
 void Parser_1_digit_pred_implicit_subj(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_make_alive(world, 100);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "100"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], 100, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
 
-
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2693,21 +2689,20 @@ void Parser_1_digit_pred_no_subj(void) {
 
     ecs_make_alive(world, 100);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "100()"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], 100, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2718,21 +2713,20 @@ void Parser_1_digit_pred_explicit_subj(void) {
     ecs_make_alive(world, 100);
     ecs_make_alive(world, 200);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "100(200)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], 100, EcsSelf|EcsIsEntity);
     test_src(terms[0], 200, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2746,14 +2740,13 @@ void Parser_1_digit_pair_implicit_subj(void) {
     ecs_make_alive(world, 100);
     ecs_make_alive(world, 300);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(100, 300)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], 100, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], 300, EcsSelf|EcsIsEntity);
@@ -2761,7 +2754,7 @@ void Parser_1_digit_pair_implicit_subj(void) {
     test_int(terms[0].inout, EcsInOutDefault);  
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2776,14 +2769,13 @@ void Parser_1_digit_pair_explicit_subj(void) {
     ecs_make_alive(world, 200);
     ecs_make_alive(world, 300);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "100(200, 300)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], 100, EcsSelf|EcsIsEntity);
     test_src(terms[0], 200, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], 300, EcsSelf|EcsIsEntity);
@@ -2791,7 +2783,7 @@ void Parser_1_digit_pair_explicit_subj(void) {
     test_int(terms[0].inout, EcsInOutDefault);  
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2801,21 +2793,20 @@ void Parser_pred_implicit_subject_self(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(self)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
 
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2825,45 +2816,20 @@ void Parser_pred_implicit_subject_superset(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(up)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world); 
-}
-
-void Parser_pred_implicit_subject_subset(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Pred);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(down)"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsDown|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
+    test_int(terms[0].trav, EcsChildOf);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2873,45 +2839,20 @@ void Parser_pred_implicit_subject_superset_inclusive(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(self|up)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world); 
-}
-
-void Parser_pred_implicit_subject_subset_inclusive(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Pred);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(self|down)"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsDown|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
+    test_int(terms[0].trav, EcsChildOf);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2921,45 +2862,20 @@ void Parser_pred_implicit_subject_superset_cascade(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(up|cascade)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsCascade|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world); 
-}
-
-void Parser_pred_implicit_subject_subset_cascade(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Pred);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(down|cascade)"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsDown|EcsCascade|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
+    test_int(terms[0].trav, EcsChildOf);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -2969,45 +2885,20 @@ void Parser_pred_implicit_subject_superset_inclusive_cascade(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(up|cascade|self)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsCascade|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world); 
-}
-
-void Parser_pred_implicit_subject_subset_inclusive_cascade(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Pred);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(down|cascade|self)"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsDown|EcsCascade|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
+    test_int(terms[0].trav, EcsChildOf);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -3017,21 +2908,20 @@ void Parser_pred_implicit_subject_implicit_superset_cascade(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(cascade)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsCascade|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
+    test_int(terms[0].trav, EcsChildOf);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -3041,21 +2931,20 @@ void Parser_pred_implicit_subject_implicit_superset_inclusive_cascade(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(self|cascade)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsSelf|EcsCascade|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
-    test_int(terms[0].src.trav, EcsIsA);
+    test_int(terms[0].trav, EcsChildOf);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -3066,21 +2955,20 @@ void Parser_pred_implicit_subject_implicit_superset_cascade_w_rel(void) {
     ECS_TAG(world, Pred);
     ECS_ENTITY(world, Rel, Traversable);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(cascade(Rel))"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(cascade Rel)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsCascade|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
-    test_int(terms[0].src.trav, Rel);
+    test_int(terms[0].trav, Rel);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -3091,21 +2979,20 @@ void Parser_pred_implicit_subject_implicit_superset_inclusive_cascade_w_rel(void
     ECS_TAG(world, Pred);
     ECS_ENTITY(world, Rel, Traversable);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(self|cascade(Rel))"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(self|cascade Rel)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsSelf|EcsCascade|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
-    test_int(terms[0].src.trav, Rel);
+    test_int(terms[0].trav, Rel);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -3115,21 +3002,20 @@ void Parser_pred_implicit_subject_superset_childof(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(up(ChildOf))"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(up IsA)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
-    test_int(terms[0].src.trav, EcsChildOf);
+    test_int(terms[0].trav, EcsIsA);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -3139,21 +3025,20 @@ void Parser_pred_implicit_subject_cascade_superset_childof(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(cascade|up(ChildOf))"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(cascade|up IsA)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsCascade|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
-    test_int(terms[0].src.trav, EcsChildOf);
+    test_int(terms[0].trav, EcsIsA);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -3163,21 +3048,20 @@ void Parser_pred_implicit_subject_superset_cascade_childof(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(up|cascade(ChildOf))"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(up|cascade IsA)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsCascade|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);  
-    test_int(terms[0].src.trav, EcsChildOf);
+    test_int(terms[0].trav, EcsIsA);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world); 
 }
@@ -3187,21 +3071,20 @@ void Parser_pred_implicit_subject_superset_cascade_childof_optional(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "?Pred(up|cascade(ChildOf))"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "?Pred(up|cascade IsA)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsCascade|EcsIsVariable);
     test_int(terms[0].oper, EcsOptional);
     test_int(terms[0].inout, EcsInOutDefault);  
-    test_int(terms[0].src.trav, EcsChildOf);
+    test_int(terms[0].trav, EcsIsA);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3211,28 +3094,18 @@ void Parser_expr_w_symbol(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_entity_t comp = ecs_component_init(world, &(ecs_component_desc_t){
+    ecs_component_init(world, &(ecs_component_desc_t){
         .entity = ecs_entity(world, {
             .name = "Foo",
             .symbol = "FooBar"
         })
     });
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "FooBar"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], comp, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);  
-
-
-    ecs_filter_fini(&f);
+    });
+    test_assert(q == NULL);
 
     ecs_fini(world);
 }
@@ -3240,15 +3113,14 @@ void Parser_expr_w_symbol(void) {
 void Parser_expr_w_newline(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_new_entity(world, "Foo");
+    ecs_entity(world, { .name = "Foo" });
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Foo\n"
-    }));
+    });
+    test_assert(q != NULL);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3259,21 +3131,20 @@ void Parser_subj_entity_w_explicit_self(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(Subj:self)"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(Subj|self)"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3284,21 +3155,20 @@ void Parser_subj_entity_w_explicit_self_superset(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(Subj:self|up)"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(Subj|self|up)"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3309,22 +3179,21 @@ void Parser_subj_entity_w_explicit_superset_relation(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(Subj:up(ChildOf))"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(Subj|up IsA)"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsUp|EcsIsEntity);
-    test_int(terms[0].src.trav, EcsChildOf);
+    test_int(terms[0].trav, EcsIsA);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3335,22 +3204,21 @@ void Parser_subj_entity_w_explicit_self_superset_relation(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(Subj:self|up(ChildOf))"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(Subj|self|up IsA)"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
-    test_int(terms[0].src.trav, EcsChildOf);
+    test_int(terms[0].trav, EcsIsA);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3362,21 +3230,20 @@ void Parser_obj_entity_w_explicit_self(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(Subj, Obj:self)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(Subj, Obj|self)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3388,21 +3255,20 @@ void Parser_obj_entity_w_explicit_self_superset(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(Subj, Obj:self|up)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(Subj, Obj|self|up)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3414,21 +3280,20 @@ void Parser_obj_entity_w_explicit_superset_relation(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(Subj, Obj:up(ChildOf))"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(Subj, Obj|up ChildOf)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3440,21 +3305,20 @@ void Parser_obj_entity_w_explicit_self_superset_relation(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred(Subj, Obj:self|up(ChildOf))"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred(Subj, Obj|self|up ChildOf)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3465,21 +3329,20 @@ void Parser_pred_entity_w_explicit_self(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:self:(Subj)"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred|self(Subj)"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -3490,497 +3353,423 @@ void Parser_pred_entity_w_explicit_self_superset(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:self|up:(Subj)"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred|self|up(Subj)"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsUp|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_w_explicit_superset_relation(void) {
+void Parser_pred_entity_no_args_w_explicit_self(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Pred);
-    ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:up(ChildOf):(Subj)"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred|self"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsUp|EcsIsEntity);
-    test_int(terms[0].first.trav, EcsChildOf);
-    test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_w_explicit_self_superset_relation(void) {
+void Parser_pred_entity_no_args_w_explicit_self_superset(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Pred);
-    ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:self|up(ChildOf):(Subj)"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred|self|up"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsUp|EcsIsEntity);
-    test_int(terms[0].first.trav, EcsChildOf);
-    test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_no_args_w_explicit_self(void) {
+void Parser_pred_entity_no_args_2_terms_w_explicit_self(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Pred);
+    ECS_TAG(world, Pred2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:self"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred|self, Pred2"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    test_first(terms[1], Pred2, EcsSelf|EcsIsEntity);
+    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_no_args_w_explicit_self_superset(void) {
+void Parser_pred_entity_no_args_2_terms_w_explicit_self_superset(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Pred);
+    ECS_TAG(world, Pred2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:self|up"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred|self|up, Pred2"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsUp|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    test_first(terms[1], Pred2, EcsSelf|EcsIsEntity);
+    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_no_args_w_explicit_superset_relation(void) {
+void Parser_newline(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_TAG(world, Pred);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:up(ChildOf)"
-    }));
-
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "\n"
+    });
+    test_assert(q != NULL);
 
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsUp|EcsIsEntity);
-    test_int(terms[0].first.trav, EcsChildOf);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
+    test_int(term_count(q), 0);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_no_args_w_explicit_self_superset_relation(void) {
+void Parser_2_newlines(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_TAG(world, Pred);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "\n\n"
+    });
+    test_assert(q != NULL);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:self|up(ChildOf)"
-    }));
+    test_int(term_count(q), 0);
 
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsUp|EcsIsEntity);
-    test_int(terms[0].first.trav, EcsChildOf);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_no_args_2_terms_w_explicit_self(void) {
+void Parser_3_newlines(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_TAG(world, Pred);
-    ECS_TAG(world, Pred2);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:self, Pred2"
-    }));
-
-    test_int(filter_count(&f), 2);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "\n\n"
+    });
+    test_assert(q != NULL);
 
-    test_first(terms[1], Pred2, EcsSelf|EcsIsEntity);
-    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[1].oper, EcsAnd);
-    test_int(terms[1].inout, EcsInOutDefault);
+    test_int(term_count(q), 0);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_no_args_2_terms_w_explicit_self_superset(void) {
+void Parser_space(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_TAG(world, Pred);
-    ECS_TAG(world, Pred2);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = " "
+    });
+    test_assert(q != NULL);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:self|up, Pred2"
-    }));
+    test_int(term_count(q), 0);
 
-    test_int(filter_count(&f), 2);
+    ecs_query_fini(q);
 
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsUp|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
+    ecs_fini(world);
+}
 
-    test_first(terms[1], Pred2, EcsSelf|EcsIsEntity);
-    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[1].oper, EcsAnd);
-    test_int(terms[1].inout, EcsInOutDefault);
+void Parser_2_spaces(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "  "
+    });
+    test_assert(q != NULL);
 
-    ecs_filter_fini(&f);
+    test_int(term_count(q), 0);
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_no_args_2_terms_w_explicit_superset_relation(void) {
+void Parser_trailing_newline(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Pred);
-    ECS_TAG(world, Pred2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:up(ChildOf), Pred2"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred\n"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 2);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsUp|EcsIsEntity);
-    test_int(terms[0].first.trav, EcsChildOf);
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    test_first(terms[1], Pred2, EcsSelf|EcsIsEntity);
-    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[1].oper, EcsAnd);
-    test_int(terms[1].inout, EcsInOutDefault);
-
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_pred_entity_no_args_2_terms_w_explicit_self_superset_relation(void) {
+void Parser_2_trailing_newlines(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Pred);
-    ECS_TAG(world, Pred2);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred:self|up(ChildOf), Pred2"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred\n\n"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 2);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsUp|EcsIsEntity);
-    test_int(terms[0].first.trav, EcsChildOf);
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    test_first(terms[1], Pred2, EcsSelf|EcsIsEntity);
-    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[1].oper, EcsAnd);
-    test_int(terms[1].inout, EcsInOutDefault);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Parser_newline(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "\n"
-    }));
-
-    test_int(filter_count(&f), 0);
-
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_2_newlines(void) {
+void Parser_trailing_space(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "\n\n"
-    }));
-
-    test_int(filter_count(&f), 0);
-
-    ecs_filter_fini(&f);
+    ECS_TAG(world, Pred);
 
-    ecs_fini(world);
-}
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred "
+    });
+    test_assert(q != NULL);
 
-void Parser_3_newlines(void) {
-    ecs_world_t *world = ecs_mini();
+    test_int(term_count(q), 1);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "\n\n"
-    }));
-
-    test_int(filter_count(&f), 0);
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_space(void) {
+void Parser_2_trailing_spaces(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = " "
-    }));
-
-    test_int(filter_count(&f), 0);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
+    ECS_TAG(world, Pred);
 
-void Parser_2_spaces(void) {
-    ecs_world_t *world = ecs_mini();
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred  "
+    });
+    test_assert(q != NULL);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "  "
-    }));
+    test_int(term_count(q), 1);
 
-    test_int(filter_count(&f), 0);
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_trailing_newline(void) {
+void Parser_template_type(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_TAG(world, Pred);
+    ecs_entity_t Pred = ecs_entity_init(world, &(ecs_entity_desc_t){
+        .name = "Template<int>"
+    });
+    test_assert(Pred != 0);
+    test_str(ecs_get_name(world, Pred), "Template<int>");
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred\n"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Template<int>"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_2_trailing_newlines(void) {
+void Parser_template_type_nested(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_TAG(world, Pred);
+    ecs_entity_t Pred = ecs_entity_init(world, &(ecs_entity_desc_t){
+        .name = "Template<Foo<int>>"
+    });
+    test_assert(Pred != 0);
+    test_str(ecs_get_name(world, Pred), "Template<Foo<int>>");
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred\n\n"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Template<Foo<int>>"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_trailing_space(void) {
+void Parser_template_type_multiple_args(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_TAG(world, Pred);
+    ecs_entity_t Pred = ecs_entity_init(world, &(ecs_entity_desc_t){
+        .name = "Template<int, float>"
+    });
+    test_assert(Pred != 0);
+    test_str(ecs_get_name(world, Pred), "Template<int, float>");
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred "
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Template<int, float>"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_2_trailing_spaces(void) {
+void Parser_template_type_multiple_args_nested(void) {
     ecs_world_t *world = ecs_mini();
 
-    ECS_TAG(world, Pred);
+    ecs_entity_t Pred = ecs_entity_init(world, &(ecs_entity_desc_t){
+        .name = "Template<Foo<int>, Foo<float>>"
+    });
+    test_assert(Pred != 0);
+    test_str(ecs_get_name(world, Pred), "Template<Foo<int>, Foo<float>>");
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Pred  "
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Template<Foo<int>, Foo<float>>"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void Parser_template_type(void) {
+void Parser_template_type_unbalanced_open(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_entity_t Pred = ecs_entity_init(world, &(ecs_entity_desc_t){
-        .name = "Template<int>"
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Template<int"
     });
-    test_assert(Pred != 0);
-    test_str(ecs_get_name(world, Pred), "Template<int>");
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "Template<int>"
-    }));
+    test_assert(q == NULL);
 
-    test_int(filter_count(&f), 1);
+    ecs_fini(world);
+}
 
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
+void Parser_template_type_unbalanced_close(void) {
+    ecs_world_t *world = ecs_mini();
 
-    ecs_filter_fini(&f);
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Templateint>"
+    });
+    test_assert(q == NULL);
 
     ecs_fini(world);
 }
@@ -3990,20 +3779,12 @@ void Parser_predicate_w_parens(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Pred)"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
+    });
 
-    ecs_filter_fini(&f);
+    test_assert(q == NULL);
 
     ecs_fini(world);
 }
@@ -4015,9 +3796,7 @@ void Parser_not_alive_pred(void) {
 
     test_assert(!ecs_is_alive(world, 5000));
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "5000"
     }));
 
@@ -4033,9 +3812,7 @@ void Parser_not_alive_subj(void) {
 
     test_assert(!ecs_is_alive(world, 5000));
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(5000)"
     }));
 
@@ -4052,9 +3829,7 @@ void Parser_not_alive_obj(void) {
 
     test_assert(!ecs_is_alive(world, 5000));
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(Subj, 5000)"
     }));
 
@@ -4067,14 +3842,13 @@ void Parser_this_subj_var_kind(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "TagA, TagB($This)"
-    }));
-    test_int(filter_count(&f), 2);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "TagA, TagB($this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -4085,7 +3859,7 @@ void Parser_this_subj_var_kind(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4097,14 +3871,13 @@ void Parser_this_obj_var_kind(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "TagA, TagB(Subj, $This)"
-    }));
-    test_int(filter_count(&f), 2);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "TagA, TagB(Subj, $this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -4116,7 +3889,7 @@ void Parser_this_obj_var_kind(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4127,14 +3900,13 @@ void Parser_this_subj_obj_var_kind(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "TagA, TagB($This, $This)"
-    }));
-    test_int(filter_count(&f), 2);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "TagA, TagB($this, $this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -4146,7 +3918,7 @@ void Parser_this_subj_obj_var_kind(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4156,21 +3928,20 @@ void Parser_var_w_name(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA($Var)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], 0, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);    
     test_str(terms[0].src.name, "Var");
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4180,14 +3951,13 @@ void Parser_entity_pred_no_name(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -4195,7 +3965,7 @@ void Parser_entity_pred_no_name(void) {
 
     test_str(terms[0].first.name, NULL);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4206,14 +3976,13 @@ void Parser_entity_subj_no_name(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA(Subj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
@@ -4221,7 +3990,7 @@ void Parser_entity_subj_no_name(void) {
 
     test_str(terms[0].src.name, NULL);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4233,14 +4002,13 @@ void Parser_entity_obj_no_name(void) {
     ECS_TAG(world, Subj);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA(Subj, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
@@ -4249,7 +4017,7 @@ void Parser_entity_obj_no_name(void) {
 
     test_str(terms[0].second.name, NULL);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4257,14 +4025,13 @@ void Parser_entity_obj_no_name(void) {
 void Parser_this_pred_no_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$This"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "$this"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -4272,7 +4039,7 @@ void Parser_this_pred_no_name(void) {
 
     test_str(terms[0].first.name, NULL);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4283,14 +4050,13 @@ void Parser_this_subj_no_name(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "TagA($This)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "TagA($this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -4298,7 +4064,7 @@ void Parser_this_subj_no_name(void) {
 
     test_str(terms[0].src.name, NULL);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4309,14 +4075,13 @@ void Parser_this_obj_no_name(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "TagA(Subj, $This)"
-    }));
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "TagA(Subj, $this)"
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
     test_second(terms[0], EcsThis, EcsSelf|EcsIsVariable);
@@ -4325,82 +4090,7 @@ void Parser_this_obj_no_name(void) {
 
     test_str(terms[0].second.name, NULL);
 
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Parser_auto_object_variable(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Pred);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$(Pred)"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_second_var(terms[0], 0, EcsSelf, "Pred");
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Parser_auto_object_variable_w_subj(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ECS_TAG(world, Pred);
-    ECS_TAG(world, Subj);
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$(Pred, Subj)"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], Subj, EcsSelf|EcsUp|EcsIsEntity);
-    test_second_var(terms[0], 0, EcsSelf, "Pred");
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-
-    ecs_filter_fini(&f);
-
-    ecs_fini(world);
-}
-
-void Parser_auto_scoped_variable(void) {
-    ecs_world_t *world = ecs_mini();
-
-    ecs_entity_t Pred = ecs_entity(world, {
-        .name = "foo.Pred"
-    });
-
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$(foo.Pred)"
-    }));
-    test_int(filter_count(&f), 1);
-
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
-    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
-    test_second_var(terms[0], 0, EcsSelf, "Pred");
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutDefault);
-
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4413,9 +4103,7 @@ void Parser_invalid_variable_only(void) {
     ECS_TAG(world, Pred);
     ECS_TAG(world, Subj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$"
     }));
 
@@ -4430,21 +4118,20 @@ void Parser_oneof_self_pred_w_relative_obj(void) {
 
     test_assert( ecs_lookup_child(world, 0, "Obj") == 0 ); // sanity check
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Rel, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
  
     ecs_fini(world);
 }
@@ -4458,21 +4145,20 @@ void Parser_oneof_other_pred_w_relative_obj(void) {
 
     test_assert( ecs_lookup_child(world, 0, "Obj") == 0 ); // sanity check
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Rel, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
  
     ecs_fini(world);
 }
@@ -4487,9 +4173,7 @@ void Parser_oneof_self_pred_w_invalid_obj(void) {
 
     test_assert( ecs_lookup_child(world, 0, "Obj") != 0 ); // sanity check
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Rel, Obj)"
     }));
  
@@ -4507,9 +4191,7 @@ void Parser_oneof_other_pred_w_invalid_obj(void) {
 
     test_assert( ecs_lookup_child(world, 0, "Obj") != 0 ); // sanity check
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Rel, Obj)"
     }));
  
@@ -4521,26 +4203,26 @@ void Parser_oneof_w_other_entity_w_same_name(void) {
 
     ECS_ENTITY(world, Rel, OneOf);
     ECS_ENTITY(world, Obj, (ChildOf, Rel));
-    ecs_entity_t obj_2 = ecs_new_entity(world, "Obj");
+    ecs_entity_t obj_2 = ecs_entity(world, { .name = "Obj" });
 
     test_uint( ecs_lookup_child(world, 0, "Obj"), obj_2 );
     test_uint( ecs_lookup(world, "Rel.Obj"), Obj );
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Rel, Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
 
-    ecs_term_t *terms = filter_terms(&f);
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
  
     ecs_fini(world);
 }
@@ -4551,30 +4233,30 @@ void Parser_oneof_w_other_entity_w_same_name_w_set_scope(void) {
     ECS_ENTITY(world, Rel, OneOf);
     ECS_ENTITY(world, Obj, (ChildOf, Rel));
 
-    ecs_entity_t p = ecs_new_entity(world, "parent");
-    ecs_entity_t obj_2 = ecs_new_entity(world, "Obj");
+    ecs_entity_t p = ecs_entity(world, { .name = "parent" });
+    ecs_entity_t obj_2 = ecs_entity(world, { .name = "Obj" });
     ecs_add_pair(world, obj_2, EcsChildOf, p);
 
     ecs_set_scope(world, p);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Rel, Obj)"
-    }));
+    });
+
+    test_assert(q != NULL);
 
     ecs_set_scope(world, 0);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
  
     ecs_fini(world);
 }
@@ -4584,21 +4266,22 @@ void Parser_oneof_w_wildcard(void) {
 
     ECS_ENTITY(world, Rel, OneOf);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Rel, *)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], EcsWildcard, EcsSelf|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
  
     ecs_fini(world);
 }
@@ -4608,21 +4291,22 @@ void Parser_oneof_w_any(void) {
 
     ECS_ENTITY(world, Rel, OneOf);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Rel, _)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
 
-    ecs_term_t *terms = filter_terms(&f);
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], EcsAny, EcsSelf|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
  
     ecs_fini(world);
 }
@@ -4632,26 +4316,27 @@ void Parser_oneof_w_fullpath(void) {
 
     ECS_ENTITY(world, Rel, OneOf);
     ECS_ENTITY(world, Obj, (ChildOf, Rel));
-    ecs_entity_t obj_2 = ecs_new_entity(world, "Obj");
+    ecs_entity_t obj_2 = ecs_entity(world, { .name = "Obj" });
 
     test_uint( ecs_lookup_child(world, 0, "Obj"), obj_2 );
     test_uint( ecs_lookup(world, "Rel.Obj"), Obj );
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Rel, Rel.Obj)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
 
-    ecs_term_t *terms = filter_terms(&f);
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Obj, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
  
     ecs_fini(world);
 }
@@ -4664,9 +4349,7 @@ void Parser_pair_implicit_src_missing_rel(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(, Obj)"
     }));
 
@@ -4681,9 +4364,7 @@ void Parser_pair_implicit_src_missing_obj(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(Rel, )"
     }));
 
@@ -4698,9 +4379,7 @@ void Parser_pair_explicit_src_missing_src(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Rel(, Obj)"
     }));
 
@@ -4715,9 +4394,7 @@ void Parser_pair_explicit_src_missing_obj(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Obj);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Rel($this, )"
     }));
 
@@ -4731,7 +4408,7 @@ void Parser_eq_id(void) {
     ECS_TAG(world, Second);
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "First == Second"
     }));
 
@@ -4743,22 +4420,21 @@ void Parser_eq_id_var(void) {
 
     ECS_TAG(world, Second);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$this == Second"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_second(terms[0], Second, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4769,35 +4445,59 @@ void Parser_eq_var_id(void) {
     ECS_TAG(world, First);
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "First == $this"
     }));
 
     ecs_fini(world);
 }
 
+void Parser_eq_var_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, First);
+    ECS_TAG(world, Second);
+
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "First($y), $x == $y"
+    });
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 2);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[1], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_src_var(terms[1], 0, EcsSelf, "x");
+    test_second_var(terms[1], 0, EcsSelf, "y");
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutNone);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
 void Parser_eq_var(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, First);
     ECS_TAG(world, Second);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$x == $y"
-    }));
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "First($this, $y), $x == $y"
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
-    test_src_var(terms[0], 0, EcsSelf, "x");
-    test_second_var(terms[0], 0, EcsSelf, "y");
-    test_int(terms[0].oper, EcsAnd);
-    test_int(terms[0].inout, EcsInOutNone);
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[1], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_src_var(terms[1], 0, EcsSelf, "x");
+    test_second_var(terms[1], 0, EcsSelf, "y");
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4809,7 +4509,7 @@ void Parser_neq_id(void) {
     ECS_TAG(world, Second);
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "First != Second"
     }));
 
@@ -4821,22 +4521,21 @@ void Parser_neq_id_var(void) {
 
     ECS_TAG(world, Second);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$this != Second"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_second(terms[0], Second, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsNot);
     test_int(terms[0].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4847,32 +4546,57 @@ void Parser_neq_var_id(void) {
     ECS_TAG(world, First);
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "First != $this"
     }));
 
     ecs_fini(world);
 }
 
+void Parser_neq_var_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, First);
+
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "First($y), $x != $y"
+    });
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 2);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[1], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_src_var(terms[1], 0, EcsSelf, "x");
+    test_second_var(terms[1], 0, EcsSelf, "y");
+    test_int(terms[1].oper, EcsNot);
+    test_int(terms[1].inout, EcsInOutNone);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
 void Parser_neq_var(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
-        .expr = "$x != $y"
-    }));
+    ECS_TAG(world, First);
 
-    test_int(filter_count(&f), 1);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "First($this, $y), $x != $y"
+    });
+    test_assert(q != NULL);
 
-    ecs_term_t *terms = filter_terms(&f);
-    test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
-    test_src_var(terms[0], 0, EcsSelf, "x");
-    test_second_var(terms[0], 0, EcsSelf, "y");
-    test_int(terms[0].oper, EcsNot);
-    test_int(terms[0].inout, EcsInOutNone);
+    test_int(term_count(q), 2);
 
-    ecs_filter_fini(&f);
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[1], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_src_var(terms[1], 0, EcsSelf, "x");
+    test_second_var(terms[1], 0, EcsSelf, "y");
+    test_int(terms[1].oper, EcsNot);
+    test_int(terms[1].inout, EcsInOutNone);
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4881,7 +4605,7 @@ void Parser_eq_name(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "\"First\" == \"Second\""
     }));
 
@@ -4892,7 +4616,7 @@ void Parser_eq_name_var(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "\"First\" == $y"
     }));
 
@@ -4902,14 +4626,13 @@ void Parser_eq_name_var(void) {
 void Parser_eq_var_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_log_set_level(-4);
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$x == \"Second\""
-    }));
+    });
 
-    ecs_filter_fini(&f);
+    test_assert(q != NULL);
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4918,7 +4641,7 @@ void Parser_neq_name(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "\"First\" != \"Second\""
     }));
 
@@ -4929,7 +4652,7 @@ void Parser_neq_name_var(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "\"First\" != $y"
     }));
 
@@ -4939,25 +4662,22 @@ void Parser_neq_name_var(void) {
 void Parser_neq_var_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$x != \"Second\""
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
-    test_uint(terms[0].src.flags, (EcsSelf|EcsIsVariable));
+    test_uint(terms[0].src.id, (EcsSelf|EcsIsVariable));
     test_str(terms[0].src.name, "x");
-    test_uint(terms[0].src.id, 0);
-    test_uint(terms[0].second.flags, (EcsSelf|EcsIsName));
+    test_uint(terms[0].second.id, (EcsSelf|EcsIsName));
     test_str(terms[0].second.name, "Second");
-    test_uint(terms[0].second.id, 0);
     test_int(terms[0].oper, EcsNot);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -4966,7 +4686,7 @@ void Parser_match_name(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "\"First\" ~= \"Second\""
     }));
 
@@ -4977,7 +4697,7 @@ void Parser_match_name_var(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "\"First\" ~= $y"
     }));
 
@@ -4987,25 +4707,22 @@ void Parser_match_name_var(void) {
 void Parser_match_var_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$x ~= \"Second\""
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsPredMatch, EcsSelf|EcsIsEntity);
-    test_uint(terms[0].src.flags, (EcsSelf|EcsIsVariable));
+    test_uint(terms[0].src.id, (EcsSelf|EcsIsVariable));
     test_str(terms[0].src.name, "x");
-    test_uint(terms[0].src.id, 0);
-    test_uint(terms[0].second.flags, (EcsSelf|EcsIsName));
+    test_uint(terms[0].second.id, (EcsSelf|EcsIsName));
     test_str(terms[0].second.name, "Second");
-    test_uint(terms[0].second.id, 0);
     test_int(terms[0].oper, EcsAnd);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5014,7 +4731,7 @@ void Parser_match_var(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$x ~= $y"
     }));
 
@@ -5025,7 +4742,7 @@ void Parser_nmatch_name(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "\"First\" ~= \"!Second\""
     }));
 
@@ -5036,7 +4753,7 @@ void Parser_nmatch_name_var(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "\"!First\" ~= $y"
     }));
 
@@ -5046,25 +4763,22 @@ void Parser_nmatch_name_var(void) {
 void Parser_nmatch_var_name(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$x ~= \"!Second\""
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsPredMatch, EcsSelf|EcsIsEntity);
-    test_uint(terms[0].src.flags, (EcsSelf|EcsIsVariable));
+    test_uint(terms[0].src.id, (EcsSelf|EcsIsVariable));
     test_str(terms[0].src.name, "x");
-    test_uint(terms[0].src.id, 0);
-    test_uint(terms[0].second.flags, (EcsSelf|EcsIsName));
+    test_uint(terms[0].second.id, (EcsSelf|EcsIsName));
     test_str(terms[0].second.name, "Second");
-    test_uint(terms[0].second.id, 0);
     test_int(terms[0].oper, EcsNot);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5073,7 +4787,7 @@ void Parser_eq_same_var(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$x == $x"
     }));
 
@@ -5084,7 +4798,7 @@ void Parser_neq_same_var(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$x != $x"
     }));
 
@@ -5095,7 +4809,7 @@ void Parser_eq_same_var_this(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$this == $this"
     }));
 
@@ -5106,20 +4820,57 @@ void Parser_neq_same_var_this(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "$this != $this"
     }));
 
     ecs_fini(world);
 }
 
+void Parser_eq_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_log_set_level(-4);
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "!$this == Foo"
+    }));
+
+    ecs_fini(world);
+}
+
+void Parser_neq_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_log_set_level(-4);
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "!$this != Foo"
+    }));
+
+    ecs_fini(world);
+}
+
+void Parser_match_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_log_set_level(-4);
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "!$this ~= \"Foo\""
+    }));
+
+    ecs_fini(world);
+}
+
 void Parser_eq_w_optional(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Foo);
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "?$this == Foo"
     }));
 
@@ -5132,7 +4883,7 @@ void Parser_neq_w_optional(void) {
     ECS_TAG(world, Foo);
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "?$this != Foo"
     }));
 
@@ -5143,27 +4894,170 @@ void Parser_match_w_optional(void) {
     ecs_world_t *world = ecs_mini();
 
     ecs_log_set_level(-4);
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "?$this ~= \"Foo\""
     }));
 
     ecs_fini(world);
 }
 
+void Parser_eq_0(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == 0"
+    });
+
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_uint(terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_str(terms[0].src.name, NULL);
+    test_uint(terms[0].second.id, EcsSelf|EcsIsEntity);
+    test_str(terms[0].second.name, NULL);
+    test_int(terms[0].oper, EcsAnd);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_neq_0(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this != 0"
+    });
+
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_uint(terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_str(terms[0].src.name, NULL);
+    test_uint(terms[0].second.id, EcsSelf|EcsIsEntity);
+    test_str(terms[0].second.name, NULL);
+    test_int(terms[0].oper, EcsNot);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_eq_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == *"
+    });
+
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_uint(terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_str(terms[0].src.name, NULL);
+    test_uint(terms[0].second.id, EcsWildcard|EcsSelf|EcsIsVariable);
+    test_str(terms[0].second.name, NULL);
+    test_int(terms[0].oper, EcsAnd);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_neq_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this != *"
+    });
+
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_uint(terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_str(terms[0].src.name, NULL);
+    test_uint(terms[0].second.id, EcsWildcard|EcsSelf|EcsIsVariable);
+    test_str(terms[0].second.name, NULL);
+    test_int(terms[0].oper, EcsNot);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_eq_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == _"
+    });
+
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_uint(terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_str(terms[0].src.name, NULL);
+    test_uint(terms[0].second.id, EcsAny|EcsSelf|EcsIsVariable);
+    test_str(terms[0].second.name, NULL);
+    test_int(terms[0].oper, EcsAnd);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_neq_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this != _"
+    });
+
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
+
+    ecs_term_t *terms = query_terms(q);
+    test_first(terms[0], EcsPredEq, EcsSelf|EcsIsEntity);
+    test_uint(terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_str(terms[0].src.name, NULL);
+    test_uint(terms[0].second.id, EcsAny|EcsSelf|EcsIsVariable);
+    test_str(terms[0].second.name, NULL);
+    test_int(terms[0].oper, EcsNot);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
 void Parser_query_scope_1_term(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA, {TagB}"
-    }));
-    test_int(filter_count(&f), 4);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 4);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -5184,7 +5078,7 @@ void Parser_query_scope_1_term(void) {
     test_int(terms[3].oper, EcsAnd);
     test_int(terms[3].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5195,14 +5089,13 @@ void Parser_query_scope_1_term_spaces(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA, { TagB }"
-    }));
-    test_int(filter_count(&f), 4);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 4);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -5223,7 +5116,7 @@ void Parser_query_scope_1_term_spaces(void) {
     test_int(terms[3].oper, EcsAnd);
     test_int(terms[3].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5235,14 +5128,13 @@ void Parser_query_scope_2_terms(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, TagC);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA, { TagB, TagC }"
-    }));
-    test_int(filter_count(&f), 5);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 5);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -5268,7 +5160,7 @@ void Parser_query_scope_2_terms(void) {
     test_int(terms[4].oper, EcsAnd);
     test_int(terms[4].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5280,14 +5172,13 @@ void Parser_query_nested_scope(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, TagC);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA, {TagB, {TagC}}"
-    }));
-    test_int(filter_count(&f), 7);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 7);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -5323,7 +5214,7 @@ void Parser_query_nested_scope(void) {
     test_int(terms[6].oper, EcsAnd);
     test_int(terms[6].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5335,14 +5226,13 @@ void Parser_query_nested_scope_spaces(void) {
     ECS_TAG(world, TagB);
     ECS_TAG(world, TagC);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA, { TagB, { TagC } }"
-    }));
-    test_int(filter_count(&f), 7);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 7);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -5378,7 +5268,7 @@ void Parser_query_nested_scope_spaces(void) {
     test_int(terms[6].oper, EcsAnd);
     test_int(terms[6].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5390,9 +5280,7 @@ void Parser_query_scope_unbalanced(void) {
     ECS_TAG(world, TagB);
 
     ecs_log_set_level(-4);
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA, { TagB"
     }));
 
@@ -5405,14 +5293,13 @@ void Parser_query_not_scope(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA, !{TagB}"
-    }));
-    test_int(filter_count(&f), 4);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 4);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -5433,7 +5320,7 @@ void Parser_query_not_scope(void) {
     test_int(terms[3].oper, EcsAnd);
     test_int(terms[3].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5445,9 +5332,7 @@ void Parser_query_empty_scope(void) {
     ECS_TAG(world, TagB);
 
     ecs_log_set_level(-4);
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "TagA, !{}"
     }));
 
@@ -5460,14 +5345,13 @@ void Parser_query_scope_newline_after_open(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, {\nTagB}"
-    }));
-    test_int(filter_count(&f), 4);
+    });
+    test_assert(q != NULL);
+    test_int(q->term_count, 4);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = q->terms;
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -5488,7 +5372,7 @@ void Parser_query_scope_newline_after_open(void) {
     test_int(terms[3].oper, EcsAnd);
     test_int(terms[3].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5499,14 +5383,13 @@ void Parser_query_scope_newline_after_close(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "TagA, {TagB\n}"
-    }));
-    test_int(filter_count(&f), 4);
+    });
+    test_assert(q != NULL);
+    test_int(q->term_count, 4);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = q->terms;
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
@@ -5527,7 +5410,52 @@ void Parser_query_scope_newline_after_close(void) {
     test_int(terms[3].oper, EcsAnd);
     test_int(terms[3].inout, EcsInOutNone);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_query_term_after_scope(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, {TagB}, TagC"
+    });
+
+    test_assert(q != NULL);
+    test_int(q->term_count, 5);
+
+    ecs_term_t *terms = q->terms;
+    test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
+
+    test_first(terms[1], EcsScopeOpen, EcsSelf|EcsIsEntity);
+    test_src(terms[1], 0, EcsIsEntity);
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutNone);
+
+    test_first(terms[2], TagB, EcsSelf|EcsIsEntity);
+    test_src(terms[2], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[2].oper, EcsAnd);
+    test_int(terms[2].inout, EcsInOutDefault);
+
+    test_first(terms[3], EcsScopeClose, EcsSelf|EcsIsEntity);
+    test_src(terms[3], 0, EcsIsEntity);
+    test_int(terms[3].oper, EcsAnd);
+    test_int(terms[3].inout, EcsInOutNone);
+
+    test_first(terms[4], TagC, EcsSelf|EcsIsEntity);
+    test_src(terms[4], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[4].oper, EcsAnd);
+    test_int(terms[4].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5537,22 +5465,20 @@ void Parser_override_tag(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "OVERRIDE|Tag"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Tag, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_OVERRIDE);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5563,23 +5489,21 @@ void Parser_override_pair(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "OVERRIDE|(Rel, Tgt)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 1);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Tgt, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].id_flags, ECS_PAIR|ECS_OVERRIDE);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5587,15 +5511,14 @@ void Parser_override_pair(void) {
 void Parser_pair_3_args(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "ChildOf($this, $parent, $grandparent)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 2);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "parent");
@@ -5608,7 +5531,7 @@ void Parser_pair_3_args(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5616,15 +5539,14 @@ void Parser_pair_3_args(void) {
 void Parser_pair_3_args_implicit_this(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(ChildOf, $parent, $grandparent)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 2);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "parent");
@@ -5637,7 +5559,7 @@ void Parser_pair_3_args_implicit_this(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5645,15 +5567,14 @@ void Parser_pair_3_args_implicit_this(void) {
 void Parser_pair_4_args(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "ChildOf($this, $parent, $grandparent, $greatgrandparent)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 3);
+    test_int(term_count(q), 3);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "parent");
@@ -5672,7 +5593,7 @@ void Parser_pair_4_args(void) {
     test_int(terms[2].oper, EcsAnd);
     test_int(terms[2].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5680,15 +5601,14 @@ void Parser_pair_4_args(void) {
 void Parser_pair_4_args_implicit_this(void) {
     ecs_world_t *world = ecs_mini();
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "(ChildOf, $parent, $grandparent, $greatgrandparent)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 3);
+    test_int(term_count(q), 3);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "parent");
@@ -5707,7 +5627,7 @@ void Parser_pair_4_args_implicit_this(void) {
     test_int(terms[2].oper, EcsAnd);
     test_int(terms[2].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5718,15 +5638,14 @@ void Parser_pair_3_args_2_terms(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "ChildOf($this, $parent, $grandparent), Rel($this, $parent)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 3);
+    test_int(term_count(q), 3);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsIsVariable);
     test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "parent");
@@ -5745,7 +5664,7 @@ void Parser_pair_3_args_2_terms(void) {
     test_int(terms[2].oper, EcsAnd);
     test_int(terms[2].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5755,21 +5674,20 @@ void Parser_cascade_desc(void) {
 
     ECS_TAG(world, Pred);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "Pred(cascade|desc)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Pred, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsUp|EcsCascade|EcsDesc|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsInOutDefault);
-    test_int(terms[0].src.trav, EcsIsA);
+    test_int(terms[0].trav, EcsChildOf);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5780,15 +5698,14 @@ void Parser_pair_3_args_this_tgt(void) {
     ECS_TAG(world, Rel);
     ECS_TAG(world, Tgt);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "ChildOf($grandchild, $child, $this)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 2);
+    test_int(term_count(q), 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src_var(terms[0], 0, EcsSelf|EcsIsVariable, "grandchild");
     test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "child");
@@ -5801,7 +5718,7 @@ void Parser_pair_3_args_this_tgt(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5811,15 +5728,14 @@ void Parser_pair_3_args_2_terms_this_tgt(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "ChildOf($grandchild, $child, $this), Rel($this)"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 3);
+    test_int(term_count(q), 3);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src_var(terms[0], 0, EcsSelf|EcsIsVariable, "grandchild");
     test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "child");
@@ -5837,7 +5753,7 @@ void Parser_pair_3_args_2_terms_this_tgt(void) {
     test_int(terms[2].oper, EcsAnd);
     test_int(terms[2].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5847,15 +5763,14 @@ void Parser_pair_3_args_2_terms_this_tgt_implicit_this(void) {
 
     ECS_TAG(world, Rel);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
         .expr = "ChildOf($grandchild, $child, $this), Rel"
-    }));
+    });
+    test_assert(q != NULL);
 
-    test_int(filter_count(&f), 3);
+    test_int(term_count(q), 3);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src_var(terms[0], 0, EcsSelf|EcsIsVariable, "grandchild");
     test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "child");
@@ -5873,7 +5788,7 @@ void Parser_pair_3_args_2_terms_this_tgt_implicit_this(void) {
     test_int(terms[2].oper, EcsAnd);
     test_int(terms[2].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5884,15 +5799,13 @@ void Parser_pair_3_or_args(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "ChildOf($this, Foo || Bar)"
-    }));
+    });
 
-    test_int(filter_count(&f), 2);
+    test_int(q->term_count, 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = q->terms;
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Foo, EcsSelf|EcsIsEntity);
@@ -5905,7 +5818,7 @@ void Parser_pair_3_or_args(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5916,15 +5829,13 @@ void Parser_pair_3_or_args_implicit_this(void) {
     ECS_TAG(world, Foo);
     ECS_TAG(world, Bar);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(ChildOf, Foo || Bar)"
-    }));
+    });
 
-    test_int(filter_count(&f), 2);
+    test_int(q->term_count, 2);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = q->terms;
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Foo, EcsSelf|EcsIsEntity);
@@ -5937,7 +5848,7 @@ void Parser_pair_3_or_args_implicit_this(void) {
     test_int(terms[1].oper, EcsAnd);
     test_int(terms[1].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5949,15 +5860,13 @@ void Parser_pair_4_or_args(void) {
     ECS_TAG(world, Bar);
     ECS_TAG(world, Hello);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "ChildOf($this, Foo || Bar || Hello)"
-    }));
+    });
 
-    test_int(filter_count(&f), 3);
+    test_int(q->term_count, 3);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = q->terms;
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Foo, EcsSelf|EcsIsEntity);
@@ -5976,7 +5885,7 @@ void Parser_pair_4_or_args(void) {
     test_int(terms[2].oper, EcsAnd);
     test_int(terms[2].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -5988,15 +5897,13 @@ void Parser_pair_4_or_args_implicit_this(void) {
     ECS_TAG(world, Bar);
     ECS_TAG(world, Hello);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(ChildOf, Foo || Bar || Hello)"
-    }));
+    });
 
-    test_int(filter_count(&f), 3);
+    test_int(q->term_count, 3);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = q->terms;
     test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Foo, EcsSelf|EcsIsEntity);
@@ -6015,7 +5922,7 @@ void Parser_pair_4_or_args_implicit_this(void) {
     test_int(terms[2].oper, EcsAnd);
     test_int(terms[2].inout, EcsInOutDefault);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6028,9 +5935,7 @@ void Parser_pair_or_before_and_oper(void) {
     ECS_TAG(world, Hello);
 
     ecs_log_set_level(-4);
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query(world, {
         .expr = "ChildOf($this, Foo || Bar, Hello)"
     }));
 
@@ -6045,34 +5950,167 @@ void Parser_pair_and_before_or_oper(void) {
     ECS_TAG(world, Hello);
 
     ecs_log_set_level(-4);
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL == ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    test_assert(NULL == ecs_query(world, {
         .expr = "ChildOf($this, Foo, Bar || Hello)"
     }));
 
     ecs_fini(world);
 }
 
+void Parser_pair_3_args_w_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "ChildOf($a, $bb, $ccc)"
+    });
+
+    test_int(q->term_count, 2);
+
+    ecs_term_t *terms = q->terms;
+    test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[0], 0, EcsSelf|EcsIsVariable, "a");
+    test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "bb");
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
+
+    test_first(terms[1], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[1], 0, EcsSelf|EcsIsVariable, "bb");
+    test_second_var(terms[1], 0, EcsSelf|EcsIsVariable, "ccc");
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_pair_4_args_w_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "ChildOf($a, $bb, $ccc, $dddd)"
+    });
+
+    test_int(q->term_count, 3);
+
+    ecs_term_t *terms = q->terms;
+    test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[0], 0, EcsSelf|EcsIsVariable, "a");
+    test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "bb");
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
+
+    test_first(terms[1], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[1], 0, EcsSelf|EcsIsVariable, "bb");
+    test_second_var(terms[1], 0, EcsSelf|EcsIsVariable, "ccc");
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    test_first(terms[2], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[2], 0, EcsSelf|EcsIsVariable, "ccc");
+    test_second_var(terms[2], 0, EcsSelf|EcsIsVariable, "dddd");
+    test_int(terms[2].oper, EcsAnd);
+    test_int(terms[2].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_pair_3_args_w_vars_w_term_after(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "ChildOf($a, $bb, $ccc), Foo($ccc)"
+    });
+
+    test_int(q->term_count, 3);
+
+    ecs_term_t *terms = q->terms;
+    test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[0], 0, EcsSelf|EcsIsVariable, "a");
+    test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "bb");
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
+
+    test_first(terms[1], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[1], 0, EcsSelf|EcsIsVariable, "bb");
+    test_second_var(terms[1], 0, EcsSelf|EcsIsVariable, "ccc");
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    test_first(terms[2], Foo, EcsSelf|EcsIsEntity);
+    test_src_var(terms[2], 0, EcsSelf|EcsUp|EcsIsVariable, "ccc");
+    test_int(terms[2].oper, EcsAnd);
+    test_int(terms[2].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_pair_4_args_w_vars_w_term_after(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "ChildOf($a, $bb, $ccc, $dddd), Foo($dddd)"
+    });
+
+    test_int(q->term_count, 4);
+
+    ecs_term_t *terms = q->terms;
+    test_first(terms[0], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[0], 0, EcsSelf|EcsIsVariable, "a");
+    test_second_var(terms[0], 0, EcsSelf|EcsIsVariable, "bb");
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
+
+    test_first(terms[1], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[1], 0, EcsSelf|EcsIsVariable, "bb");
+    test_second_var(terms[1], 0, EcsSelf|EcsIsVariable, "ccc");
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    test_first(terms[2], EcsChildOf, EcsSelf|EcsIsEntity);
+    test_src_var(terms[2], 0, EcsSelf|EcsIsVariable, "ccc");
+    test_second_var(terms[2], 0, EcsSelf|EcsIsVariable, "dddd");
+    test_int(terms[2].oper, EcsAnd);
+    test_int(terms[2].inout, EcsInOutDefault);
+
+    test_first(terms[3], Foo, EcsSelf|EcsIsEntity);
+    test_src_var(terms[3], 0, EcsSelf|EcsUp|EcsIsVariable, "dddd");
+    test_int(terms[3].oper, EcsAnd);
+    test_int(terms[3].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
 void Parser_newline_after_inout(void) {
     ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, TagA);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[in]\nTagA($this)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = q->terms;
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6082,20 +6120,21 @@ void Parser_newline_after_term_open(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[in] TagA(\n$this)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = q->terms;
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6105,20 +6144,21 @@ void Parser_newline_after_term_src(void) {
 
     ECS_TAG(world, TagA);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[in] TagA($this\n)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6129,21 +6169,22 @@ void Parser_newline_after_term_src_pair(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, Tgt);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[in] TagA($this\n,Tgt)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Tgt, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6154,21 +6195,22 @@ void Parser_newline_after_term_pair_comma(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, Tgt);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[in] TagA($this,\nTgt)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    
+    test_assert(q != NULL);
+
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_second(terms[0], Tgt, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6179,20 +6221,21 @@ void Parser_newline_after_term_pair_second(void) {
     ECS_TAG(world, TagA);
     ECS_TAG(world, Tgt);
 
-    ecs_filter_t f = ECS_FILTER_INIT;
-    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
-        .storage = &f,
+    ecs_query_t *q = ecs_query(world, {
         .expr = "[in] TagA($this,Tgt\n)"
-    }));
-    test_int(filter_count(&f), 1);
+    });
+    
+    test_assert(q != NULL);
+    
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(&f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], TagA, EcsSelf|EcsIsEntity);
     test_second(terms[0], Tgt, EcsSelf|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
     test_int(terms[0].inout, EcsIn);
 
-    ecs_filter_fini(&f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6202,18 +6245,19 @@ void Parser_tag_w_space_implicit_this(void) {
 
     ecs_entity_t tag = ecs_set_name(world, 0, "Tag A");
 
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Tag\\ A"
     });
-    test_assert(f != NULL);
-    test_int(filter_count(f), 1);
+    
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], tag, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6223,18 +6267,19 @@ void Parser_tag_w_space(void) {
 
     ecs_entity_t tag = ecs_set_name(world, 0, "Tag A");
 
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Tag\\ A($this)"
     });
-    test_assert(f != NULL);
-    test_int(filter_count(f), 1);
+    
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], tag, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6246,19 +6291,20 @@ void Parser_pair_first_w_space_implicit_this(void) {
 
     ecs_entity_t tag = ecs_set_name(world, 0, "Tag A");
 
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Tag\\ A, Tgt)"
     });
-    test_assert(f != NULL);
-    test_int(filter_count(f), 1);
+    
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], tag, EcsSelf|EcsIsEntity);
     test_second(terms[0], Tgt, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6270,19 +6316,20 @@ void Parser_pair_first_w_space(void) {
 
     ecs_entity_t tag = ecs_set_name(world, 0, "Tag A");
 
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Tag\\ A($this, Tgt)"
     });
-    test_assert(f != NULL);
-    test_int(filter_count(f), 1);
+    
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], tag, EcsSelf|EcsIsEntity);
     test_second(terms[0], Tgt, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6294,19 +6341,20 @@ void Parser_pair_second_w_space_implicit_this(void) {
 
     ecs_entity_t tgt = ecs_set_name(world, 0, "Tgt A");
 
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         .expr = "(Rel, Tgt\\ A)"
     });
-    test_assert(f != NULL);
-    test_int(filter_count(f), 1);
+    
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_second(terms[0], tgt, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6318,19 +6366,20 @@ void Parser_pair_second_w_space(void) {
 
     ecs_entity_t tgt = ecs_set_name(world, 0, "Tgt A");
 
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Rel($this, Tgt\\ A)"
     });
-    test_assert(f != NULL);
-    test_int(filter_count(f), 1);
+    
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_second(terms[0], tgt, EcsSelf|EcsIsEntity);
     test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
     test_int(terms[0].oper, EcsAnd);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
@@ -6343,19 +6392,173 @@ void Parser_pair_src_w_space(void) {
 
     ecs_entity_t src = ecs_set_name(world, 0, "Src A");
 
-    ecs_filter_t *f = ecs_filter_init(world, &(ecs_filter_desc_t){
+    ecs_query_t *q = ecs_query(world, {
         .expr = "Rel(Src\\ A, Tgt)"
     });
-    test_assert(f != NULL);
-    test_int(filter_count(f), 1);
+    
+    test_assert(q != NULL);
+    test_int(term_count(q), 1);
 
-    ecs_term_t *terms = filter_terms(f);
+    ecs_term_t *terms = query_terms(q);
     test_first(terms[0], Rel, EcsSelf|EcsIsEntity);
     test_second(terms[0], Tgt, EcsSelf|EcsIsEntity);
     test_src(terms[0], src, EcsSelf|EcsUp|EcsIsEntity);
     test_int(terms[0].oper, EcsAnd);
 
-    ecs_filter_fini(f);
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_empty_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1,, Pred_2"
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world); 
+}
+
+void Parser_empty_term_w_space(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1, , Pred_2"
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world); 
+}
+
+void Parser_empty_term_w_newline(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .expr = "Pred_1,\n, Pred_2"
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world); 
+}
+
+void Parser_mixed_1_desc_and_1_expr(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .terms = {{ Pred_1 }},
+        .expr = "Pred_2"
+    });
+
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 2);
+
+    ecs_term_t *terms = q->terms;
+    test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
+
+    test_first(terms[1], Pred_2, EcsSelf|EcsIsEntity);
+    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Parser_mixed_2_desc_and_1_expr(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+    ECS_TAG(world, Pred_3);
+
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .terms = {{ Pred_1 }, { Pred_2 }},
+        .expr = "Pred_3"
+    });
+
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 3);
+
+    ecs_term_t *terms = q->terms;
+    test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
+
+    test_first(terms[1], Pred_2, EcsSelf|EcsIsEntity);
+    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    test_first(terms[2], Pred_3, EcsSelf|EcsIsEntity);
+    test_src(terms[2], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[2].oper, EcsAnd);
+    test_int(terms[2].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Parser_mixed_1_desc_and_2_expr(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Pred_1);
+    ECS_TAG(world, Pred_2);
+    ECS_TAG(world, Pred_3);
+
+    ecs_query_t *q = ecs_query_init(world, &(ecs_query_desc_t){
+        .terms = {{ Pred_1 }},
+        .expr = "Pred_2, Pred_3"
+    });
+
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 3);
+
+    ecs_term_t *terms = q->terms;
+    test_first(terms[0], Pred_1, EcsSelf|EcsIsEntity);
+    test_src(terms[0], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[0].oper, EcsAnd);
+    test_int(terms[0].inout, EcsInOutDefault);
+
+    test_first(terms[1], Pred_2, EcsSelf|EcsIsEntity);
+    test_src(terms[1], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[1].oper, EcsAnd);
+    test_int(terms[1].inout, EcsInOutDefault);
+
+    test_first(terms[2], Pred_3, EcsSelf|EcsIsEntity);
+    test_src(terms[2], EcsThis, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(terms[2].oper, EcsAnd);
+    test_int(terms[2].inout, EcsInOutDefault);
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
diff --git a/test/query/src/Plan.c b/test/query/src/Plan.c
new file mode 100644
index 000000000..25a986168
--- /dev/null
+++ b/test/query/src/Plan.c
@@ -0,0 +1,2041 @@
+#include <query.h>
+
+void Plan_reordered_plan_1(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, ChildOf($this, $p, $gp, $ggp), Bar($ggp)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      "
+    LINE " 1. [ 0,  2]  selfupid    $[this]           (Foo)"
+    LINE " 2. [ 1,  3]  and         $[this]           (ChildOf, $p)"
+    LINE " 3. [ 2,  4]  and         $p                (ChildOf, $gp)"
+    LINE " 4. [ 3,  5]  and         $gp               (ChildOf, $ggp)"
+    LINE " 5. [ 4,  6]  selfupid    $ggp              (Bar)"
+    LINE " 6. [ 5,  7]  setvars     "
+    LINE " 7. [ 6,  8]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_reordered_plan_2(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($ggp), ChildOf($this, $p, $gp, $ggp), Bar($this)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      "
+    LINE " 1. [ 0,  2]  selfupid    $[ggp]            (Foo)"
+    LINE " 2. [ 1,  3]  each        $ggp              ($[ggp])"
+    LINE " 3. [ 2,  4]  and         $[gp]             (ChildOf, $ggp)"
+    LINE " 4. [ 3,  5]  each        $gp               ($[gp])"
+    LINE " 5. [ 4,  6]  and         $[p]              (ChildOf, $gp)"
+    LINE " 6. [ 5,  7]  each        $p                ($[p])"
+    LINE " 7. [ 6,  8]  and         $[this]           (ChildOf, $p)"
+    LINE " 8. [ 7,  9]  selfupid    $[this]           (Bar)"
+    LINE " 9. [ 8, 10]  setvars     "
+    LINE "10. [ 9, 11]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_1_trivial_plan(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  andid       $[this]           (Foo)"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_2_trivial_plan(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self), Bar(self)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  triv        {0,1}"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_1_trivial_plan_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(self)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  andid       $[this]           (Position)"
+    LINE " 2. [ 1,  3]  popself     {0}"
+    LINE " 3. [ 2,  4]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_2_trivial_plan_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(self), Velocity(self)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  trivpop     {0,1}"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_3_trivial_plan_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "p" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self), Bar(self), ChildOf(self, p)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  triv        {0,1,2}"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_3_trivial_plan_w_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "p" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self), Bar(self), ChildOf(self, *)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  trivwc      {0,1,2}"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_3_trivial_plan_w_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "p" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self), Bar(self), ChildOf(self, _)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  triv        {0,1}"
+    LINE " 2. [ 1,  3]  andany      $[this]           (ChildOf, $_'1)"
+    LINE " 3. [ 2,  4]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_3_trivial_plan_w_pair_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity(world, { .name = "p" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(self), Velocity(self), ChildOf(self, p)"
+    });
+    
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  trivpop     {0,1,2}"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_3_trivial_plan_w_wildcard_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity(world, { .name = "p" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(self), Velocity(self), ChildOf(self, *)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  trivwc      {0,1,2}"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_3_trivial_plan_w_any_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity(world, { .name = "p" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(self), Velocity(self), ChildOf(self, _)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  trivpop     {0,1}"
+    LINE " 2. [ 1,  3]  andany      $[this]           (ChildOf, $_'1)"
+    LINE " 3. [ 2,  4]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_1_trivial_component_w_none(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity(world, { .name = "p" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "[none] Position(self)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  andid       $[this]           (Position)"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_2_trivial_component_w_none(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity(world, { .name = "p" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "[none] Position(self), [none] Velocity(self)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  triv        {0,1}"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_2_trivial_plan_w_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self), ChildOf(self, *)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setids      " 
+    LINE " 1. [ 0,  2]  trivwc      {0,1}"
+    LINE " 2. [ 1,  3]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_this_before_fixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, Bar(e)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Bar)"
+    LINE " 3. [ 2,  4]  selfupid    $[this]           (Foo)"
+    LINE " 4. [ 3,  5]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_fixed_src_before_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Bar(e), Foo"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Bar)"
+    LINE " 3. [ 2,  4]  selfupid    $[this]           (Foo)"
+    LINE " 4. [ 3,  5]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_var_before_fixed_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($var), Bar(e)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Bar)"
+    LINE " 3. [ 2,  4]  selfupid    $[var]            (Foo)"
+    LINE " 4. [ 3,  5]  each        $var              ($[var])"
+    LINE " 5. [ 4,  6]  setvars     "
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_fixed_src_before_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Bar(e), Foo($var)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Bar)"
+    LINE " 3. [ 2,  4]  selfupid    $[var]            (Foo)"
+    LINE " 4. [ 3,  5]  each        $var              ($[var])"
+    LINE " 5. [ 4,  6]  setvars     "
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_this_before_fixed_src_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, !Bar(e)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  4]  not         "
+    LINE " 3. [ 2,  4]   selfupid   e                 (Bar)"
+    LINE " 4. [ 2,  5]  end         e                 (Bar)"
+    LINE " 5. [ 4,  6]  selfupid    $[this]           (Foo)"
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_this_before_fixed_src_w_first_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, $this(e)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfup      e                 ($this)"
+    LINE " 3. [ 2,  4]  selfupid    $this             (Foo)"
+    LINE " 4. [ 3,  5]  setthis                       ($this)"
+    LINE " 5. [ 4,  6]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_this_before_fixed_src_w_first_var_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, !$this(e)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    $[this]           (Foo)"
+    LINE " 3. [ 2,  4]  each        $this             ($[this])"
+    LINE " 4. [ 3,  6]  not         "
+    LINE " 5. [ 4,  6]   selfup     e                 ($this)"
+    LINE " 6. [ 4,  7]  end         e                 ($this)"
+    LINE " 7. [ 6,  8]  setthis                       ($this)"
+    LINE " 8. [ 7,  9]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_this_before_fixed_src_w_second_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, Bar(e, $this)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfup      e                 (Bar, $this)"
+    LINE " 3. [ 2,  4]  selfupid    $this             (Foo)"
+    LINE " 4. [ 3,  5]  setthis                       ($this)"
+    LINE " 5. [ 4,  6]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_this_before_fixed_src_w_second_var_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo, !Bar(e, $this)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    $[this]           (Foo)"
+    LINE " 3. [ 2,  4]  each        $this             ($[this])"
+    LINE " 4. [ 3,  6]  not         "
+    LINE " 5. [ 4,  6]   selfup     e                 (Bar, $this)"
+    LINE " 6. [ 4,  7]  end         e                 (Bar, $this)"
+    LINE " 7. [ 6,  8]  setthis                       ($this)"
+    LINE " 8. [ 7,  9]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_1_fixed(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  pop         {0}"
+    LINE " 4. [ 3,  5]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(e)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,1}"
+    LINE " 5. [ 4,  6]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_1_fixed_1_this_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(self)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  pop         {0}"
+    LINE " 4. [ 3,  5]  andid       $[this]           (Velocity)"
+    LINE " 5. [ 4,  6]  popself     {1}"
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_this_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(e), Mass(self), Rotation(self)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,1}"
+    LINE " 5. [ 4,  6]  trivpop     {2,3}"
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_this_self_interleaved(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Mass(self), Velocity(e), Rotation(self)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,2}"
+    LINE " 5. [ 4,  6]  trivpop     {1,3}"
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_this_self_2_fixed(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Mass(self), Rotation(self), Position(e), Velocity(e)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {2,3}"
+    LINE " 5. [ 4,  6]  trivpop     {0,1}"
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_1_fixed_1_this_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(up)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  pop         {0}"
+    LINE " 4. [ 3,  5]  upid        $[this]           (Velocity)"
+    LINE " 5. [ 4,  6]  pop         {1}"
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_this_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(e), Mass(up), Rotation(up)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,1}"
+    LINE " 5. [ 4,  6]  upid        $[this]           (Mass)"
+    LINE " 6. [ 5,  7]  upid        $[this]           (Rotation)"
+    LINE " 7. [ 6,  8]  pop         {2,3}"
+    LINE " 8. [ 7,  9]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_this_up_interleaved(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Mass(up), Velocity(e), Rotation(up)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,2}"
+    LINE " 5. [ 4,  6]  upid        $[this]           (Mass)"
+    LINE " 6. [ 5,  7]  upid        $[this]           (Rotation)"
+    LINE " 7. [ 6,  8]  pop         {1,3}"
+    LINE " 8. [ 7,  9]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_this_up_2_fixed(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Mass(up), Rotation(up), Position(e), Velocity(e)"
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {2,3}"
+    LINE " 5. [ 4,  6]  upid        $[this]           (Mass)"
+    LINE " 6. [ 5,  7]  upid        $[this]           (Rotation)"
+    LINE " 7. [ 6,  8]  pop         {0,1}"
+    LINE " 8. [ 7,  9]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_1_fixed_1_this_self_cached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(self)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  pop         {0}"
+    LINE " 4. [ 3,  5]  cachepop    "
+    LINE " 5. [ 4,  6]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_this_self_cached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(e), Mass(self), Rotation(self)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,1}"
+    LINE " 5. [ 4,  6]  cachepop    "
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_this_self_interleaved_cached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Mass(self), Velocity(e), Rotation(self)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,2}"
+    LINE " 5. [ 4,  6]  cachepop    "
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_this_self_2_fixed_cached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Mass(self), Rotation(self), Position(e), Velocity(e)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {2,3}"
+    LINE " 5. [ 4,  6]  cachepop    "
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_1_fixed_1_this_up_cached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  pop         {0}"
+    LINE " 4. [ 3,  5]  cachepop    "
+    LINE " 5. [ 4,  6]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_this_up_cached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(e), Mass(up), Rotation(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,1}"
+    LINE " 5. [ 4,  6]  cachepop    "
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_this_up_interleaved_cached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Mass(up), Velocity(e), Rotation(up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,2}"
+    LINE " 5. [ 4,  6]  cachepop    "
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_this_up_2_fixed_cached(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Mass(up), Rotation(up), Position(e), Velocity(e)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {2,3}"
+    LINE " 5. [ 4,  6]  cachepop    "
+    LINE " 6. [ 5,  7]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_1_fixed_1_var_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity($var|self)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  pop         {0}"
+    LINE " 4. [ 3,  5]  andid       $[var]            (Velocity)"
+    LINE " 5. [ 4,  6]  each        $var              ($[var])"
+    LINE " 6. [ 5,  7]  setvars     "
+    LINE " 7. [ 6,  8]  pop         {1}"
+    LINE " 8. [ 7,  9]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_var_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(e), Mass($var|self), Rotation($var|self)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,1}"
+    LINE " 5. [ 4,  6]  andid       $[var]            (Mass)"
+    LINE " 6. [ 5,  7]  andid       $[var]            (Rotation)"
+    LINE " 7. [ 6,  8]  each        $var              ($[var])"
+    LINE " 8. [ 7,  9]  setvars     "
+    LINE " 9. [ 8, 10]  pop         {2,3}"
+    LINE "10. [ 9, 11]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_var_self_interleaved(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Mass($var|self), Velocity(e), Rotation($var|self)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,2}"
+    LINE " 5. [ 4,  6]  andid       $[var]            (Mass)"
+    LINE " 6. [ 5,  7]  andid       $[var]            (Rotation)"
+    LINE " 7. [ 6,  8]  each        $var              ($[var])"
+    LINE " 8. [ 7,  9]  setvars     "
+    LINE " 9. [ 8, 10]  pop         {1,3}"
+    LINE "10. [ 9, 11]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_var_self_2_fixed(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Mass($var|self), Rotation($var|self), Position(e), Velocity(e)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {2,3}"
+    LINE " 5. [ 4,  6]  andid       $[var]            (Mass)"
+    LINE " 6. [ 5,  7]  andid       $[var]            (Rotation)"
+    LINE " 7. [ 6,  8]  each        $var              ($[var])"
+    LINE " 8. [ 7,  9]  setvars     "
+    LINE " 9. [ 8, 10]  pop         {0,1}"
+    LINE "10. [ 9, 11]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_1_fixed_1_var_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity($var|up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  pop         {0}"
+    LINE " 4. [ 3,  5]  upid        $[var]            (Velocity)"
+    LINE " 5. [ 4,  6]  each        $var              ($[var])"
+    LINE " 6. [ 5,  7]  setvars     "
+    LINE " 7. [ 6,  8]  pop         {1}"
+    LINE " 8. [ 7,  9]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_var_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Velocity(e), Mass($var|up), Rotation($var|up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,1}"
+    LINE " 5. [ 4,  6]  upid        $[var]            (Mass)"
+    LINE " 6. [ 5,  7]  upid        $[var]            (Rotation)"
+    LINE " 7. [ 6,  8]  each        $var              ($[var])"
+    LINE " 8. [ 7,  9]  setvars     "
+    LINE " 9. [ 8, 10]  pop         {2,3}"
+    LINE "10. [ 9, 11]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_fixed_2_var_up_interleaved(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(e), Mass($var|up), Velocity(e), Rotation($var|up)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {0,2}"
+    LINE " 5. [ 4,  6]  upid        $[var]            (Mass)"
+    LINE " 6. [ 5,  7]  upid        $[var]            (Rotation)"
+    LINE " 7. [ 6,  8]  each        $var              ($[var])"
+    LINE " 8. [ 7,  9]  setvars     "
+    LINE " 9. [ 8, 10]  pop         {1,3}"
+    LINE "10. [ 9, 11]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_populate_2_var_up_2_fixed(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Mass($var|up), Rotation($var|up), Position(e), Velocity(e)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  setfix      "
+    LINE " 1. [ 0,  2]  setids      "
+    LINE " 2. [ 1,  3]  selfupid    e                 (Position)"
+    LINE " 3. [ 2,  4]  selfupid    e                 (Velocity)"
+    LINE " 4. [ 3,  5]  pop         {2,3}"
+    LINE " 5. [ 4,  6]  upid        $[var]            (Mass)"
+    LINE " 6. [ 5,  7]  upid        $[var]            (Rotation)"
+    LINE " 7. [ 6,  8]  each        $var              ($[var])"
+    LINE " 8. [ 7,  9]  setvars     "
+    LINE " 9. [ 8, 10]  pop         {0,1}"
+    LINE "10. [ 9, 11]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_cache_2_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position || Velocity",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  xcache      "
+    LINE " 1. [ 0,  2]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_cache_2_or_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position || Velocity, !Mass",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  xcache      "
+    LINE " 1. [ 0,  2]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_1_plan_any_src(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "RelA(_)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  ids         $[_'1]            (RelA)"
+    LINE " 1. [ 0,  2]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+    ecs_query_fini(r);
+    ecs_fini(world);
+}
+
+void Plan_1_plan_not_any_src(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "!RelA(_)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  2]  not         "
+    LINE " 1. [ 0,  2]   ids        $[_'1]            (RelA)"
+    LINE " 2. [ 0,  3]  end         $[_'1]            (RelA)"
+    LINE " 3. [ 2,  4]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+    
+    ecs_fini(world);
+}
+
+void Plan_1_plan_optional_any_src(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "?RelA(_)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  2]  option      "
+    LINE " 1. [ 0,  2]   ids        $[_'1]            (RelA)"
+    LINE " 2. [ 0,  3]  end         $[_'1]            (RelA)"
+    LINE " 3. [ 2,  4]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_pair_first_wildcard(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "(*, Tgt)",
+        .cache_kind = EcsQueryCacheDefault
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  selfup      $[this]           ($*'1, Tgt)"
+    LINE " 1. [ 0,  2]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_pair_first_wildcard_cached(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "(*, Tgt)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  xcache      "
+    LINE " 1. [ 0,  2]  yield       "
+    LINE "";    
+    char *plan = ecs_query_plan(r);
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_pair_second_wildcard(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "(Rel, *)",
+        .cache_kind = EcsQueryCacheDefault
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  selfup      $[this]           (Rel, $*'1)"
+    LINE " 1. [ 0,  2]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Plan_pair_second_wildcard_cached(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "(Rel, *)",
+        .cache_kind = EcsQueryCacheAuto
+    });
+
+    test_assert(r != NULL);
+
+    ecs_log_enable_colors(false);
+
+    const char *expect = 
+    HEAD " 0. [-1,  1]  xcache      "
+    LINE " 1. [ 0,  2]  yield       "
+    LINE "";
+    char *plan = ecs_query_plan(r);
+
+    test_str(expect, plan);
+    ecs_os_free(plan);
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/QueryStr.c b/test/query/src/QueryStr.c
new file mode 100644
index 000000000..de8af3ba3
--- /dev/null
+++ b/test/query/src/QueryStr.c
@@ -0,0 +1,598 @@
+#include <query.h>
+
+void QueryStr_one_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ TagA }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "TagA");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_inout(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA, .inout = EcsIn }
+        }
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "[in] TagA");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_two_terms(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA },
+            { TagB }
+        }
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "TagA, TagB");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_two_terms_w_inout(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA },
+            { TagB, .inout = EcsIn }
+        }
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "TagA, [in] TagB");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_three_terms_w_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA },
+            { TagB, .oper = EcsOr },
+            { TagC }
+        }
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "TagA, TagB || TagC");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_three_terms_w_or_inout(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA },
+            { TagB, .oper = EcsOr, .inout = EcsIn },
+            { TagC, .inout = EcsIn }
+        }
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "TagA, [in] TagB || TagC");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_four_terms_three_w_or_inout(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, TagD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA },
+            { TagB, .oper = EcsOr, .inout = EcsIn },
+            { TagC, .inout = EcsIn },
+            { TagD, .inout = EcsIn }
+        }
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "TagA, [in] TagB || TagC, [in] TagD");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = ecs_pair(Rel, Tgt) }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "(Rel,Tgt)");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_pair_entity_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Src);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = ecs_pair(Rel, Tgt), .src.id = Src }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "Rel(Src,Tgt)");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = Foo, .src.id = EcsSelf }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "Foo(self)");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = Foo, .src.id = EcsUp }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_0(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = Foo, .src.id = EcsIsEntity }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "Foo()");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_singleton(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = Foo, .src.id = Foo }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "Foo($)");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_final_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Foo, Final);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = Foo }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "Foo");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_final_dont_inherit_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Foo, Final, DontInherit);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = Foo }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "Foo");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_src_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ Tag, .src.id = EcsIsVariable, .src.name = "Var" }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "Tag($Var)");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_first_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = EcsIsVariable, .first.name = "Var" }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "[none] $Var");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_second_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = Rel, .second.id = EcsIsVariable, .second.name = "Var" }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "(Rel,$Var)");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_first_var_entity_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Src);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = EcsIsVariable, .first.name = "Var", .src.id = Src }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "[none] $Var(Src)");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_one_term_w_pair_w_0_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = Rel, .second.id = Tgt, .src = {
+                .id = EcsIsEntity
+            } }
+        }
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "Rel(0,Tgt)");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_not_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ TagA, .oper = EcsNot }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "!TagA");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_wildcard_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ EcsWildcard }}
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "[none] *");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_scopes(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, {TagB, {TagC}}"
+    });
+    test_assert(q != NULL);
+
+    char *str = ecs_query_str(q);
+    test_str(str, "TagA, {TagB, {TagC}}");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+
+void QueryStr_pred_eq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == TagA"
+    });
+
+    char *str = ecs_query_str(q);
+    test_str(str, "$this == TagA");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_pred_neq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this != TagA"
+    });
+
+    char *str = ecs_query_str(q);
+    test_str(str, "$this != TagA");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_pred_eq_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == \"TagA\""
+    });
+
+    char *str = ecs_query_str(q);
+    test_str(str, "$this == \"TagA\"");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_pred_neq_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this != \"TagA\""
+    });
+
+    char *str = ecs_query_str(q);
+    test_str(str, "$this != \"TagA\"");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_pred_eq_m(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this ~= \"TagA\""
+    });
+
+    char *str = ecs_query_str(q);
+    test_str(str, "$this ~= \"TagA\"");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void QueryStr_pred_neq_m(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this ~= \"!TagA\""
+    });
+
+    char *str = ecs_query_str(q);
+    test_str(str, "$this ~= \"!TagA\"");
+    ecs_os_free(str);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
diff --git a/test/query/src/Recycled.c b/test/query/src/Recycled.c
new file mode 100644
index 000000000..42a9635c3
--- /dev/null
+++ b/test/query/src/Recycled.c
@@ -0,0 +1,300 @@
+#include <query.h>
+
+static ecs_query_cache_kind_t cache_kind = EcsQueryCacheDefault;
+
+void Recycled_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = EcsQueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+static ecs_entity_t recycled_id(ecs_world_t *world, const char *name) {
+    ecs_entity_t result = ecs_new(world);
+    ecs_delete(world, result);
+    ecs_entity_t result_2 = ecs_new(world);
+    test_assert(result_2 != (uint32_t)result);
+    ecs_set_name(world, result_2, name);
+    return result_2;
+}
+
+void Recycled_recycled_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    
+    ecs_entity_t src = recycled_id(world, "src");
+    ecs_entity_t rel = recycled_id(world, "rel");
+    ecs_add(world, src, Tag);
+    ecs_add_id(world, src, rel);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$x($y), Tag($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int32_t x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+    int32_t y_var = ecs_query_find_var(r, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_uint(0, it.count);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 1));
+    test_uint(src, ecs_field_src(&it, 0));
+    test_uint(src, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_iter_get_var(&it, x_var));
+    test_uint(src, ecs_iter_get_var(&it, y_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_uint(0, it.count);
+    test_uint(rel, ecs_field_id(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 1));
+    test_uint(src, ecs_field_src(&it, 0));
+    test_uint(src, ecs_field_src(&it, 1));
+    test_uint(rel, ecs_iter_get_var(&it, x_var));
+    test_uint(src, ecs_iter_get_var(&it, y_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Recycled_recycled_pair_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    
+    ecs_entity_t src = recycled_id(world, "src");
+    ecs_entity_t rel = recycled_id(world, "rel");
+    ecs_entity_t tgt = recycled_id(world, "tgt");
+    ecs_add(world, src, Tag);
+    ecs_add_pair(world, src, rel, tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$x($y, $z), Tag($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int32_t x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+    int32_t y_var = ecs_query_find_var(r, "y");
+    test_assert(y_var != -1);
+    int32_t z_var = ecs_query_find_var(r, "z");
+    test_assert(z_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_uint(0, it.count);
+    test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 1));
+    test_uint(src, ecs_field_src(&it, 0));
+    test_uint(src, ecs_field_src(&it, 1));
+    test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
+    test_uint(src, ecs_iter_get_var(&it, y_var));
+    test_uint(EcsName, ecs_iter_get_var(&it, z_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_uint(0, it.count);
+    test_uint(ecs_pair(rel, tgt), ecs_field_id(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 1));
+    test_uint(src, ecs_field_src(&it, 0));
+    test_uint(src, ecs_field_src(&it, 1));
+    test_uint(rel, ecs_iter_get_var(&it, x_var));
+    test_uint(src, ecs_iter_get_var(&it, y_var));
+    test_uint(tgt, ecs_iter_get_var(&it, z_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Recycled_recycled_this_ent_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    
+    ecs_entity_t src = recycled_id(world, "src");
+    ecs_entity_t rel = recycled_id(world, "rel");
+    ecs_entity_t tgt = recycled_id(world, "tgt");
+    ecs_add(world, src, Tag);
+    ecs_add_pair(world, src, rel, tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$x($y, $this), Tag($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int32_t x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+    int32_t y_var = ecs_query_find_var(r, "y");
+    test_assert(y_var != -1);
+    int32_t this_var = ecs_query_find_var(r, "this");
+    test_assert(this_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_uint(1, it.count);
+    test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 1));
+    test_uint(src, ecs_field_src(&it, 0));
+    test_uint(src, ecs_field_src(&it, 1));
+    test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
+    test_uint(src, ecs_iter_get_var(&it, y_var));
+    test_uint(EcsName, ecs_iter_get_var(&it, this_var));
+    test_uint(EcsName, it.entities[0]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_uint(1, it.count);
+    test_uint(ecs_pair(rel, tgt), ecs_field_id(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 1));
+    test_uint(src, ecs_field_src(&it, 0));
+    test_uint(src, ecs_field_src(&it, 1));
+    test_uint(rel, ecs_iter_get_var(&it, x_var));
+    test_uint(src, ecs_iter_get_var(&it, y_var));
+    test_uint(tgt, ecs_iter_get_var(&it, this_var));
+    test_uint(tgt, it.entities[0]);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Recycled_has_recycled_id_from_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    
+    ecs_entity_t src = recycled_id(world, "src");
+    ecs_entity_t rel = recycled_id(world, "rel");
+    ecs_entity_t tgt = recycled_id(world, "tgt");
+    ecs_add_pair(world, src, rel, tgt);
+    ecs_add_id(world, src, tgt);
+    ecs_add(world, src, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$x($y, $z), $z($y), Tag($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int32_t x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+    int32_t y_var = ecs_query_find_var(r, "y");
+    test_assert(y_var != -1);
+    int32_t z_var = ecs_query_find_var(r, "z");
+    test_assert(z_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_uint(0, it.count);
+    test_uint(ecs_pair(rel, tgt), ecs_field_id(&it, 0));
+    test_uint(tgt, ecs_field_id(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 2));
+    test_uint(src, ecs_field_src(&it, 0));
+    test_uint(src, ecs_field_src(&it, 1));
+    test_uint(src, ecs_field_src(&it, 2));
+    test_uint(rel, ecs_iter_get_var(&it, x_var));
+    test_uint(src, ecs_iter_get_var(&it, y_var));
+    test_uint(tgt, ecs_iter_get_var(&it, z_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Recycled_recycled_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t rel = ecs_entity(world, { .name = "Rel" });
+    ecs_entity_t tgt = ecs_entity(world, { .name = "Tgt" });
+    ecs_delete(world, rel);
+    ecs_delete(world, tgt);
+    rel = ecs_entity(world, { .name = "Rel" });
+    tgt = ecs_entity(world, { .name = "Tgt" });
+
+    ecs_entity_t e = ecs_new_w_pair(world, rel, tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = {
+            .first.id = rel,
+            .second.id = tgt
+        },
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e);
+    test_uint(ecs_field_id(&it, 0), ecs_pair(rel, tgt));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Recycled_recycled_component_id(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    for (int i = 0; i < FLECS_HI_COMPONENT_ID; i ++) {
+        ecs_new_low_id(ecs);
+    }
+
+    ecs_entity_t e = ecs_new(ecs);
+    ecs_delete(ecs, e);
+
+    ECS_COMPONENT(ecs, Position);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position) }
+        },
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {20, 30}));
+
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_uint(it.entities[0], e1);
+    test_uint(it.entities[1], e2);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+    test_int(p[1].x, 20);
+    test_int(p[1].y, 30);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
diff --git a/test/query/src/Scopes.c b/test/query/src/Scopes.c
new file mode 100644
index 000000000..10d99f842
--- /dev/null
+++ b/test/query/src/Scopes.c
@@ -0,0 +1,423 @@
+#include <query.h>
+
+static ecs_query_cache_kind_t cache_kind = EcsQueryCacheDefault;
+
+void Scopes_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = EcsQueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+void Scopes_term_w_not_scope_1_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t parent_1 = ecs_new_w(world, Root);
+    ecs_add(world, parent_1, TagA);
+
+    ecs_entity_t parent_2 = ecs_new_w(world, Root);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ TagA }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(parent_2, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Scopes_term_w_not_scope_2_terms(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t parent_1 = ecs_new_w(world, Root);
+    ecs_add(world, parent_1, TagA);
+
+    ecs_entity_t parent_2 = ecs_new_w(world, Root);
+    ecs_add(world, parent_2, TagB);
+
+    ecs_entity_t parent_3 = ecs_new_w(world, Root);
+    ecs_add(world, parent_3, TagA);
+    ecs_add(world, parent_3, TagB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ TagA, TagB }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(parent_1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(parent_2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Scopes_term_w_not_scope_1_term_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t parent_1 = ecs_new_w(world, Root);
+    ecs_add(world, parent_1, TagA);
+
+    ecs_new_w(world, Root);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ !TagA }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(parent_1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Scopes_term_w_not_scope_2_terms_w_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t parent_1 = ecs_new_w(world, Root);
+    ecs_add(world, parent_1, TagA);
+
+    ecs_entity_t parent_2 = ecs_new_w(world, Root);
+    ecs_add(world, parent_2, TagB);
+
+    ecs_entity_t parent_3 = ecs_new_w(world, Root);
+    ecs_add(world, parent_3, TagA);
+    ecs_add(world, parent_3, TagB);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ TagA, !TagB }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(parent_2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(parent_3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Scopes_term_w_not_scope_1_term_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+
+    ecs_entity_t parent_1 = ecs_new_w(world, Root);
+    ecs_new_w_pair(world, EcsChildOf, parent_1);
+    ecs_new_w_pair(world, EcsChildOf, parent_1);
+
+    ecs_entity_t parent_2 = ecs_new_w(world, Root);
+    ecs_new_w_pair(world, EcsChildOf, parent_2);
+
+    ecs_entity_t parent_3 = ecs_new_w(world, Root);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ ChildOf($child, $this) }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(parent_3, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Scopes_term_w_not_scope_2_terms_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t parent_0 = ecs_new_w(world, Root);
+    {
+        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_0);
+        ecs_set(world, child_1, Position, {10, 20});
+        ecs_entity_t child_2 = ecs_new_w_pair(world, EcsChildOf, parent_0);
+        ecs_set(world, child_2, Position, {10, 20});
+    }
+
+    ecs_entity_t parent_1 = ecs_new_w(world, Root);
+    {
+        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_1);
+        ecs_set(world, child_1, Position, {10, 20});
+        ecs_new_w_pair(world, EcsChildOf, parent_1);
+    }
+
+    ecs_entity_t parent_2 = ecs_new_w(world, Root);
+    {
+        ecs_new_w_pair(world, EcsChildOf, parent_2);
+        ecs_new_w_pair(world, EcsChildOf, parent_2);
+    }
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ ChildOf($child, $this), Position($child) }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(parent_2, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Scopes_term_w_not_scope_1_term_w_not_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+
+    ecs_entity_t parent_0 = ecs_new_w(world, Root);
+    {
+        ecs_new_w_pair(world, EcsChildOf, parent_0);
+        ecs_new_w_pair(world, EcsChildOf, parent_0);
+    }
+
+    ecs_new_w(world, Root);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ !ChildOf($child, $this) }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Scopes_term_w_not_scope_2_terms_w_not_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent_0 = ecs_new_w(world, Root);
+    {
+        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_0);
+        ecs_set(world, child_1, Position, {10, 20});
+        ecs_entity_t child_2 = ecs_new_w_pair(world, EcsChildOf, parent_0);
+        ecs_set(world, child_2, Position, {10, 20});
+        ecs_entity_t child_3 = ecs_new_w_pair(world, EcsChildOf, parent_0);
+        ecs_set(world, child_3, Position, {10, 20});
+        ecs_add(world, child_3, Foo);
+    }
+
+    ecs_entity_t parent_1 = ecs_new_w(world, Root);
+    {
+        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_1);
+        ecs_set(world, child_1, Position, {10, 20});
+        ecs_new_w_pair(world, EcsChildOf, parent_1);
+    }
+
+    ecs_entity_t parent_2 = ecs_new_w(world, Root);
+    {
+        ecs_entity_t child_1 = ecs_new_w_pair(world, EcsChildOf, parent_2);
+        ecs_add(world, child_1, Foo);
+        ecs_new_w_pair(world, EcsChildOf, parent_2);
+    }
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ ChildOf($child, $this), !Position($child) }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(parent_0, it.entities[0]);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Scopes_term_w_not_scope_2_terms_w_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, Root);
+    ecs_add(world, e1, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, Root);
+    ecs_add(world, e2, TagB);
+    ecs_entity_t e3 = ecs_new_w(world, Root);
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e3, TagB);
+    ecs_entity_t e4 = ecs_new_w(world, Root);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ TagA || TagB }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e4, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Scopes_term_w_not_scope_3_terms_w_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Root);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, Root);
+    ecs_add(world, e1, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, Root);
+    ecs_add(world, e2, TagB);
+    ecs_entity_t e3 = ecs_new_w(world, Root);
+    ecs_add(world, e3, TagA);
+    ecs_add(world, e3, TagB);
+    ecs_entity_t e4 = ecs_new_w(world, Root);
+    ecs_add(world, e4, TagC);
+    ecs_entity_t e5 = ecs_new_w(world, Root);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Root, !{ TagA || TagB || TagC }",
+        .cache_kind = cache_kind
+    });
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Root, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e5, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/Toggle.c b/test/query/src/Toggle.c
new file mode 100644
index 000000000..d1abf8c62
--- /dev/null
+++ b/test/query/src/Toggle.c
@@ -0,0 +1,6097 @@
+#include <query.h>
+#include <stdlib.h>
+
+static ecs_query_cache_kind_t cache_kind = EcsQueryCacheDefault;
+
+void Toggle_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = EcsQueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+void Toggle_fixed_src_1_tag_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_add_id(world, Foo, EcsCanToggle);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(e)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e, Foo, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e, Foo, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_fixed_src_1_component_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(e)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, e, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, e, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, e, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_fixed_src_2_tag_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_add_id(world, Foo, EcsCanToggle);
+    ecs_add_id(world, Bar, EcsCanToggle);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(e), Bar(e)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, Foo);
+    ecs_add(world, e, Bar);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(e, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e, Foo, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e, Foo, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(e, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e, Bar, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e, Bar, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(e, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e, Foo, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_fixed_src_2_component_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    ecs_entity_t e = ecs_entity(world, { .name = "e" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(e), Velocity(e)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, e, Position, {10, 20});
+    ecs_set(world, e, Velocity, {1, 2});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(e, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 2);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, e, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, e, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(e, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 2);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, e, Velocity, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, e, Velocity, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(e, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 2);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, e, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_fixed_2_src_w_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_add_id(world, Foo, EcsCanToggle);
+    ecs_add_id(world, Bar, EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(e1), Bar(e2)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Bar);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e1, Foo, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e1, Foo, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e2, Bar, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e2, Bar, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e1, Foo, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_w_fixed_src_w_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_add_id(world, Foo, EcsCanToggle);
+    ecs_add_id(world, Bar, EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), Bar(e2)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Bar);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e1, Foo, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e1, Foo, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e2, Bar, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e2, Bar, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e1, Foo, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_fixed_src_w_this_w_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_add_id(world, Foo, EcsCanToggle);
+    ecs_add_id(world, Bar, EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(e1), Bar($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, Foo);
+    ecs_add(world, e2, Bar);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e1, Foo, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e1, Foo, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e2, Bar, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e2, Bar, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e2, it.entities[0]);
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_id(world, e1, Foo, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_from_nothing(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {TagA},
+            {TagB, .src.id = EcsIsEntity}
+        },
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_new_w_id(world, TagA);
+    ecs_add(world, e1, TagB);
+    ecs_add_id(world, e1, ECS_TOGGLE | TagB);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    test_uint(ecs_field_id(&it, 0), TagA);
+    test_uint(ecs_field_id(&it, 1), TagB);
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_enable_component(world, e1, Position, true);
+    ecs_enable_component(world, e2, Position, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+
+    int32_t table_count = 0, count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e2);
+            test_assert(it.entities[i] == e1 || it.entities[i] == e3);
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+        }
+        count += it.count;
+        table_count ++;
+    }
+
+    test_int(count, 2);
+    test_int(table_count, 2);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Tgt);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
+    ecs_entity_t e2 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
+    ecs_entity_t e3 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
+
+    ecs_enable_pair(world, e1, Position, Tgt, true);
+    ecs_enable_pair(world, e2, Position, Tgt, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Position, Tgt)",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t table_count = 0, count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e2);
+            test_assert(it.entities[i] == e1 || it.entities[i] == e3);
+            test_assert(ecs_is_enabled_pair(world, it.entities[i], Position, Tgt));
+        }
+        count += it.count;
+        table_count ++;
+    }
+
+    test_int(count, 2);
+    test_int(table_count, 2);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_skip_initial(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_enable_component(world, e1, Position, false);
+    ecs_enable_component(world, e2, Position, true);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e1);
+            test_assert(it.entities[i] == e2 || it.entities[i] == e3);
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+        }
+        count += it.count;
+    }
+
+    test_int(count, 2);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_pair_skip_initial(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Tgt);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
+    ecs_entity_t e2 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
+    ecs_entity_t e3 = ecs_new_w_pair(world, ecs_id(Position), Tgt);
+
+    ecs_enable_pair(world, e1, Position, Tgt, false);
+    ecs_enable_pair(world, e2, Position, Tgt, true);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Position, Tgt)",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e1);
+            test_assert(it.entities[i] == e2 || it.entities[i] == e3);
+            test_assert(ecs_is_enabled_pair(world, it.entities[i], Position, Tgt));
+        }
+        count += it.count;
+    }
+
+    test_int(count, 2);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_add_id(world, Foo, EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+
+    ecs_enable_id(world, e1, Foo, true);
+    ecs_enable_id(world, e2, Foo, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo",
+        .cache_kind = cache_kind
+    });
+
+    int32_t table_count = 0, count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e2);
+            test_assert(it.entities[i] == e1 || it.entities[i] == e3);
+            test_assert(ecs_is_enabled_id(world, it.entities[i], Foo));
+        }
+        count += it.count;
+        table_count ++;
+    }
+
+    test_int(count, 2);
+    test_int(table_count, 2);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_tag_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_add_id(world, Rel, EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, Tgt);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, Tgt);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, Tgt);
+
+    ecs_enable_pair(world, e1, Rel, Tgt, true);
+    ecs_enable_pair(world, e2, Rel, Tgt, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    int32_t table_count = 0, count = 0;
+    ecs_iter_t it = ecs_query_iter(world, q);
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] != e2);
+            test_assert(it.entities[i] == e1 || it.entities[i] == e3);
+            test_assert(ecs_is_enabled_pair(world, it.entities[i], Rel, Tgt));
+        }
+        count += it.count;
+        table_count ++;
+    }
+
+    test_int(count, 2);
+    test_int(table_count, 2);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_tag_pair_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_add_id(world, Rel, EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, Rel, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, Rel, TgtA);
+
+    ecs_entity_t e4 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e5 = ecs_new_w_pair(world, Rel, TgtB);
+    ecs_entity_t e6 = ecs_new_w_pair(world, Rel, TgtB);
+
+    ecs_enable_pair(world, e1, Rel, TgtA, true);
+    ecs_enable_pair(world, e2, Rel, TgtA, false);
+    ecs_enable_pair(world, e3, Rel, TgtA, true);
+
+    ecs_enable_pair(world, e4, Rel, TgtB, false);
+    ecs_enable_pair(world, e5, Rel, TgtB, true);
+    ecs_enable_pair(world, e6, Rel, TgtB, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, *)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_uint(e3, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_uint(e5, it.entities[0]);
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_self_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self|up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(p, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(cache_kind == EcsQueryCacheDefault ? p : e, it.entities[0]);
+        test_uint(cache_kind == EcsQueryCacheDefault ? 0 : p, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(cache_kind == EcsQueryCacheDefault ? e : p, it.entities[0]);
+        test_uint(cache_kind == EcsQueryCacheDefault ? p : 0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(p, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(p, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_self_up_w_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self|up ChildOf), Velocity",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+    ecs_set(world, p, Velocity, {1, 2});
+    ecs_set(world, e, Velocity, {2, 4});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 2);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(p, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(cache_kind == EcsQueryCacheDefault ? p : e, it.entities[0]);
+        test_uint(cache_kind == EcsQueryCacheDefault ? 0 : p, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(cache_kind == EcsQueryCacheDefault ? 1 : 2, v->x);
+            test_int(cache_kind == EcsQueryCacheDefault ? 2 : 4, v->y);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(cache_kind == EcsQueryCacheDefault ? e : p, it.entities[0]);
+        test_uint(cache_kind == EcsQueryCacheDefault ? p : 0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(cache_kind == EcsQueryCacheDefault ? 2 : 1, v->x);
+            test_int(cache_kind == EcsQueryCacheDefault ? 4 : 2, v->y);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_up_w_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up ChildOf), Velocity",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+    ecs_set(world, p, Velocity, {1, 2});
+    ecs_set(world, e, Velocity, {2, 4});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(p, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(p, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_self_up_w_self_reverse(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Velocity, Position(self|up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+    ecs_set(world, p, Velocity, {1, 2});
+    ecs_set(world, e, Velocity, {2, 4});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 2);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 2);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_up_w_self_reverse(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Velocity, Position(up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+    ecs_set(world, p, Velocity, {1, 2});
+    ecs_set(world, e, Velocity, {2, 4});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_self_up_w_self_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self|up ChildOf), Velocity",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+    ecs_set(world, p, Velocity, {1, 2});
+    ecs_set(world, e, Velocity, {2, 4});
+
+    ecs_enable_component(world, p, Velocity, true);
+    ecs_enable_component(world, e, Velocity, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 2);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(p, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(cache_kind == EcsQueryCacheDefault ? p : e, it.entities[0]);
+        test_uint(cache_kind == EcsQueryCacheDefault ? 0 : p, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(cache_kind == EcsQueryCacheDefault ? 1 : 2, v->x);
+            test_int(cache_kind == EcsQueryCacheDefault ? 2 : 4, v->y);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(cache_kind == EcsQueryCacheDefault ? e : p, it.entities[0]);
+        test_uint(cache_kind == EcsQueryCacheDefault ? p : 0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(cache_kind == EcsQueryCacheDefault ? 2 : 1, v->x);
+            test_int(cache_kind == EcsQueryCacheDefault ? 4 : 2, v->y);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_up_w_self_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up ChildOf), Velocity",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+    ecs_set(world, p, Velocity, {1, 2});
+    ecs_set(world, e, Velocity, {2, 4});
+
+    ecs_enable_component(world, p, Velocity, true);
+    ecs_enable_component(world, e, Velocity, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(p, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(p, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        {
+            const Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_self_up_w_self_toggle_reverse(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Velocity, Position(self|up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+    ecs_set(world, p, Velocity, {1, 2});
+    ecs_set(world, e, Velocity, {2, 4});
+
+    ecs_enable_component(world, p, Velocity, true);
+    ecs_enable_component(world, e, Velocity, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 2);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 2);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_shared_up_w_self_toggle_reverse(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Velocity, Position(up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+    ecs_set(world, p, Velocity, {1, 2});
+    ecs_set(world, e, Velocity, {2, 4});
+
+    ecs_enable_component(world, p, Velocity, true);
+    ecs_enable_component(world, e, Velocity, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        {
+            const Velocity *v = ecs_field(&it, Velocity, 0);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 4);
+        }
+        {
+            const Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 10);
+            test_int(p->y, 20);
+        }
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_not_shared_self_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, p, Foo);
+    ecs_add(world, e, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, !Position(self|up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_not_shared_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, p, Foo);
+    ecs_add(world, e, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, !Position(up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_optional_shared_self_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, p, Foo);
+    ecs_add(world, e, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, ?Position(self|up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_toggle_optional_shared_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, p, Foo);
+    ecs_add(world, e, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, ?Position(up ChildOf)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_set(world, p, Position, {10, 20});
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, false);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_enable_component(world, p, Position, true);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(p, ecs_field_src(&it, 1));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(p, it.entities[0]);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+static
+void test_disable_toggle_mod(int32_t total, int32_t mod) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    int32_t i, total_count = 0, total_toggle_count = 0;
+    for (i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+
+        if (!(e % mod)) {
+            ecs_enable_component(world, e, Position, false);
+        } else {
+            ecs_enable_component(world, e, Position, true);
+            total_count ++;
+            total_toggle_count ++;
+        }
+    }
+
+    for (i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+        total_count ++;
+    }
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0, toggle_count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            if (ecs_table_has_id(world, it.table, ECS_TOGGLE | ecs_id(Position))) {
+                test_assert(it.entities[i] % mod);
+                toggle_count ++;
+            }
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_int(p[i].x, it.entities[i]);
+            test_int(p[i].y, it.entities[i]);
+        }
+        count += it.count;
+    }
+
+    test_int(toggle_count, total_toggle_count);
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+static
+void test_enable_toggle_mod(int32_t total, int32_t mod) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    int32_t i, total_count = 0, total_toggle_count = 0;
+    for (i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+        if (e % mod) {
+            ecs_enable_component(world, e, Position, false);
+        } else {
+            ecs_enable_component(world, e, Position, true);
+            total_count ++;
+            total_toggle_count ++;
+        }
+    }
+
+    for (i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+        total_count ++;
+    }
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0, toggle_count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            if (ecs_table_has_id(world, it.table, ECS_TOGGLE | ecs_id(Position))) {
+                test_assert(!(it.entities[i] % mod));
+                toggle_count ++;
+            }
+
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_int(p[i].x, it.entities[i]);
+            test_int(p[i].y, it.entities[i]);
+        }
+        count += it.count;
+    }
+
+    test_int(toggle_count, total_toggle_count);
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_64_mod_1(void) {
+    test_disable_toggle_mod(64, 1);
+}
+
+void Toggle_this_64_mod_2(void) {
+    test_disable_toggle_mod(64, 2);
+}
+
+void Toggle_this_64_mod_3(void) {
+    test_disable_toggle_mod(64, 3);
+}
+
+void Toggle_this_64_mod_7(void) {
+    test_disable_toggle_mod(64, 7);
+}
+
+void Toggle_this_64_mod_8(void) {
+    test_disable_toggle_mod(64, 8);
+}
+
+void Toggle_this_64_mod_10(void) {
+    test_disable_toggle_mod(64, 10);
+}
+
+void Toggle_this_64_mod_64(void) {
+    test_disable_toggle_mod(64, 64);
+}
+
+void Toggle_this_64_mod_256(void) {
+    test_disable_toggle_mod(64, 256);
+}
+
+void Toggle_this_64_mod_1024(void) {
+    test_disable_toggle_mod(64, 1024);
+}
+
+void Toggle_this_100_mod_1(void) {
+    test_disable_toggle_mod(100, 1);
+}
+
+void Toggle_this_100_mod_2(void) {
+    test_disable_toggle_mod(100, 2);
+}
+
+void Toggle_this_100_mod_3(void) {
+    test_disable_toggle_mod(100, 3);
+}
+
+void Toggle_this_100_mod_7(void) {
+    test_disable_toggle_mod(100, 7);
+}
+
+void Toggle_this_100_mod_8(void) {
+    test_disable_toggle_mod(100, 8);
+}
+
+void Toggle_this_100_mod_10(void) {
+    test_disable_toggle_mod(100, 10);
+}
+
+void Toggle_this_100_mod_64(void) {
+    test_disable_toggle_mod(100, 64);
+}
+
+void Toggle_this_100_mod_256(void) {
+    test_disable_toggle_mod(100, 256);
+}
+
+void Toggle_this_100_mod_1024(void) {
+    test_disable_toggle_mod(100, 1024);
+}
+
+void Toggle_this_128_mod_1(void) {
+    test_disable_toggle_mod(128, 1);
+}
+
+void Toggle_this_128_mod_2(void) {
+    test_disable_toggle_mod(128, 2);
+}
+
+void Toggle_this_128_mod_3(void) {
+    test_disable_toggle_mod(128, 3);
+}
+
+void Toggle_this_128_mod_7(void) {
+    test_disable_toggle_mod(128, 7);
+}
+
+void Toggle_this_128_mod_8(void) {
+    test_disable_toggle_mod(128, 8);
+}
+
+void Toggle_this_128_mod_10(void) {
+    test_disable_toggle_mod(128, 10);
+}
+
+void Toggle_this_128_mod_64(void) {
+    test_disable_toggle_mod(128, 64);
+}
+
+void Toggle_this_128_mod_256(void) {
+    test_disable_toggle_mod(128, 256);
+}
+
+void Toggle_this_128_mod_1024(void) {
+    test_disable_toggle_mod(128, 1024);
+}
+
+void Toggle_this_200_mod_1(void) {
+    test_disable_toggle_mod(200, 1);
+}
+
+void Toggle_this_200_mod_2(void) {
+    test_disable_toggle_mod(200, 2);
+}
+
+void Toggle_this_200_mod_3(void) {
+    test_disable_toggle_mod(200, 3);
+}
+
+void Toggle_this_200_mod_7(void) {
+    test_disable_toggle_mod(200, 7);
+}
+
+void Toggle_this_200_mod_8(void) {
+    test_disable_toggle_mod(200, 8);
+}
+
+void Toggle_this_200_mod_10(void) {
+    test_disable_toggle_mod(200, 10);
+}
+
+void Toggle_this_200_mod_64(void) {
+    test_disable_toggle_mod(200, 64);
+}
+
+void Toggle_this_200_mod_256(void) {
+    test_disable_toggle_mod(200, 256);
+}
+
+void Toggle_this_200_mod_1024(void) {
+    test_disable_toggle_mod(200, 1024);
+}
+
+void Toggle_this_1024_mod_1(void) {
+    test_disable_toggle_mod(1024, 1);
+}
+
+void Toggle_this_1024_mod_2(void) {
+    test_disable_toggle_mod(1024, 2);
+}
+
+void Toggle_this_1024_mod_3(void) {
+    test_disable_toggle_mod(1024, 3);
+}
+
+void Toggle_this_1024_mod_7(void) {
+    test_disable_toggle_mod(1024, 7);
+}
+
+void Toggle_this_1024_mod_8(void) {
+    test_disable_toggle_mod(1024, 8);
+}
+
+void Toggle_this_1024_mod_10(void) {
+    test_disable_toggle_mod(1024, 10);
+}
+
+void Toggle_this_1024_mod_64(void) {
+    test_disable_toggle_mod(1024, 64);
+}
+
+void Toggle_this_1024_mod_256(void) {
+    test_disable_toggle_mod(1024, 256);
+}
+
+void Toggle_this_1024_mod_1024(void) {
+    test_disable_toggle_mod(1024, 1024);
+}
+
+void Toggle_this_enabled_64_mod_1(void) {
+    test_enable_toggle_mod(64, 1);
+}
+
+void Toggle_this_enabled_64_mod_2(void) {
+    test_enable_toggle_mod(64, 2);
+}
+
+void Toggle_this_enabled_64_mod_3(void) {
+    test_enable_toggle_mod(64, 3);
+}
+
+void Toggle_this_enabled_64_mod_7(void) {
+    test_enable_toggle_mod(64, 7);
+}
+
+void Toggle_this_enabled_64_mod_8(void) {
+    test_enable_toggle_mod(64, 8);
+}
+
+void Toggle_this_enabled_64_mod_10(void) {
+    test_enable_toggle_mod(64, 10);
+}
+
+void Toggle_this_enabled_64_mod_64(void) {
+    test_enable_toggle_mod(64, 64);
+}
+
+void Toggle_this_enabled_64_mod_256(void) {
+    test_enable_toggle_mod(64, 256);
+}
+
+void Toggle_this_enabled_64_mod_1024(void) {
+    test_enable_toggle_mod(64, 1024);
+}
+
+void Toggle_this_enabled_100_mod_1(void) {
+    test_enable_toggle_mod(100, 1);
+}
+
+void Toggle_this_enabled_100_mod_2(void) {
+    test_enable_toggle_mod(100, 2);
+}
+
+void Toggle_this_enabled_100_mod_3(void) {
+    test_enable_toggle_mod(100, 3);
+}
+
+void Toggle_this_enabled_100_mod_7(void) {
+    test_enable_toggle_mod(100, 7);
+}
+
+void Toggle_this_enabled_100_mod_8(void) {
+    test_enable_toggle_mod(100, 8);
+}
+
+void Toggle_this_enabled_100_mod_10(void) {
+    test_enable_toggle_mod(100, 10);
+}
+
+void Toggle_this_enabled_100_mod_64(void) {
+    test_enable_toggle_mod(100, 64);
+}
+
+void Toggle_this_enabled_100_mod_256(void) {
+    test_enable_toggle_mod(100, 256);
+}
+
+void Toggle_this_enabled_100_mod_1024(void) {
+    test_enable_toggle_mod(100, 1024);
+}
+
+void Toggle_this_enabled_128_mod_1(void) {
+    test_enable_toggle_mod(128, 1);
+}
+
+void Toggle_this_enabled_128_mod_2(void) {
+    test_enable_toggle_mod(128, 2);
+}
+
+void Toggle_this_enabled_128_mod_3(void) {
+    test_enable_toggle_mod(128, 3);
+}
+
+void Toggle_this_enabled_128_mod_7(void) {
+    test_enable_toggle_mod(128, 7);
+}
+
+void Toggle_this_enabled_128_mod_8(void) {
+    test_enable_toggle_mod(128, 8);
+}
+
+void Toggle_this_enabled_128_mod_10(void) {
+    test_enable_toggle_mod(128, 10);
+}
+
+void Toggle_this_enabled_128_mod_64(void) {
+    test_enable_toggle_mod(128, 64);
+}
+
+void Toggle_this_enabled_128_mod_256(void) {
+    test_enable_toggle_mod(128, 256);
+}
+
+void Toggle_this_enabled_128_mod_1024(void) {
+    test_enable_toggle_mod(128, 1024);
+}
+
+void Toggle_this_enabled_200_mod_1(void) {
+    test_enable_toggle_mod(200, 1);
+}
+
+void Toggle_this_enabled_200_mod_2(void) {
+    test_enable_toggle_mod(200, 2);
+}
+
+void Toggle_this_enabled_200_mod_3(void) {
+    test_enable_toggle_mod(200, 3);
+}
+
+void Toggle_this_enabled_200_mod_7(void) {
+    test_enable_toggle_mod(200, 7);
+}
+
+void Toggle_this_enabled_200_mod_8(void) {
+    test_enable_toggle_mod(200, 8);
+}
+
+void Toggle_this_enabled_200_mod_10(void) {
+    test_enable_toggle_mod(200, 10);
+}
+
+void Toggle_this_enabled_200_mod_64(void) {
+    test_enable_toggle_mod(200, 64);
+}
+
+void Toggle_this_enabled_200_mod_256(void) {
+    test_enable_toggle_mod(200, 256);
+}
+
+void Toggle_this_enabled_200_mod_1024(void) {
+    test_enable_toggle_mod(200, 1024);
+}
+
+void Toggle_this_enabled_1024_mod_1(void) {
+    test_enable_toggle_mod(1024, 1);
+}
+
+void Toggle_this_enabled_1024_mod_2(void) {
+    test_enable_toggle_mod(1024, 2);
+}
+
+void Toggle_this_enabled_1024_mod_3(void) {
+    test_enable_toggle_mod(1024, 3);
+}
+
+void Toggle_this_enabled_1024_mod_7(void) {
+    test_enable_toggle_mod(1024, 7);
+}
+
+void Toggle_this_enabled_1024_mod_8(void) {
+    test_enable_toggle_mod(1024, 8);
+}
+
+void Toggle_this_enabled_1024_mod_10(void) {
+    test_enable_toggle_mod(1024, 10);
+}
+
+void Toggle_this_enabled_1024_mod_64(void) {
+    test_enable_toggle_mod(1024, 64);
+}
+
+void Toggle_this_enabled_1024_mod_256(void) {
+    test_enable_toggle_mod(1024, 256);
+}
+
+void Toggle_this_enabled_1024_mod_1024(void) {
+    test_enable_toggle_mod(1024, 1024);
+}
+
+void Toggle_this_mod_2_2_bitsets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 65536; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_add(world, e, Velocity);
+        if (!(e % 2)) {
+            ecs_enable_component(world, e, Position, true);
+        } else {
+            ecs_enable_component(world, e, Position, false);
+        }
+        
+        if (!(e % 3)) {
+            ecs_enable_component(world, e, Velocity, true);
+        } else {
+            ecs_enable_component(world, e, Velocity, false);
+        }        
+
+        if (!(e % 2) && !(e % 3)) {
+            total_count ++;
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_assert(ecs_is_enabled(world, it.entities[i], Velocity));
+            test_assert(!(it.entities[i] % 2) && !(it.entities[i] % 3));
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_mod_8_2_bitsets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 65536; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_add(world, e, Velocity);
+        if (!(e % 8)) {
+            ecs_enable_component(world, e, Position, true);
+        } else {
+            ecs_enable_component(world, e, Position, false);
+        }
+        
+        if (!(e % 4)) {
+            ecs_enable_component(world, e, Velocity, true);
+        } else {
+            ecs_enable_component(world, e, Velocity, false);
+        }        
+
+        if (!(e % 8) && !(e % 4)) {
+            total_count ++;
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_assert(ecs_is_enabled(world, it.entities[i], Velocity));
+            test_assert(!(it.entities[i] % 8) && !(it.entities[i] % 4));
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_mod_64_2_bitsets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 65536; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_add(world, e, Velocity);
+        if (!(e % 64)) {
+            ecs_enable_component(world, e, Position, true);
+        } else {
+            ecs_enable_component(world, e, Position, false);
+        }
+        
+        if (!(e % 16)) {
+            ecs_enable_component(world, e, Velocity, true);
+        } else {
+            ecs_enable_component(world, e, Velocity, false);
+        }        
+
+        if (!(e % 64) && !(e % 16)) {
+            total_count ++;
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_assert(ecs_is_enabled(world, it.entities[i], Velocity));
+            test_assert(!(it.entities[i] % 64) && !(it.entities[i] % 16));
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_mod_256_2_bitsets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 65536; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_add(world, e, Velocity);
+        if (!(e % 256)) {
+            ecs_enable_component(world, e, Position, true);
+        } else {
+            ecs_enable_component(world, e, Position, false);
+        }
+        
+        if (!(e % 64)) {
+            ecs_enable_component(world, e, Velocity, true);
+        } else {
+            ecs_enable_component(world, e, Velocity, false);
+        }        
+
+        if (!(e % 256) && !(e % 64)) {
+            total_count ++;
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_assert(ecs_is_enabled(world, it.entities[i], Velocity));
+            test_assert(!(it.entities[i] % 256) && !(it.entities[i] % 64));
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_mod_1024_2_bitsets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 65536; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_add(world, e, Velocity);
+        if (!(e % 1024)) {
+            ecs_enable_component(world, e, Position, true);
+        } else {
+            ecs_enable_component(world, e, Position, false);
+        }
+        
+        if (!(e % 128)) {
+            ecs_enable_component(world, e, Velocity, true);
+        } else {
+            ecs_enable_component(world, e, Velocity, false);
+        }        
+
+        if (!(e % 1024) && !(e % 128)) {
+            total_count ++;
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_assert(ecs_is_enabled(world, it.entities[i], Velocity));
+            test_assert(!(it.entities[i] % 1024) && !(it.entities[i] % 128));
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_randomized_2_bitsets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 65536; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_add(world, e, Velocity);
+
+        bool enable_1 = rand() % 2;
+        ecs_enable_component(world, e, Position, enable_1);
+        bool enable_2 = rand() % 2;
+        ecs_enable_component(world, e, Velocity, enable_2);
+        
+        if (enable_1 && enable_2) {
+            total_count ++;
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    for (i = 0; i < 65536; i ++) {
+        ecs_new_w(world, Position); // no match
+        ecs_new_w(world, Velocity); // no match
+
+        { // match
+            ecs_entity_t e = ecs_new_w(world, Position);
+            ecs_add(world, e, Velocity);
+            total_count ++;
+        }
+    }
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_assert(ecs_is_enabled(world, it.entities[i], Velocity));
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_randomized_3_bitsets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Mass), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 65536; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_add(world, e, Velocity);
+        ecs_add(world, e, Mass);
+
+        bool enable_1 = rand() % 2;
+        ecs_enable_component(world, e, Position, enable_1);
+        bool enable_2 = rand() % 2;
+        ecs_enable_component(world, e, Velocity, enable_2);
+        bool enable_3 = rand() % 2;
+        ecs_enable_component(world, e, Mass, enable_3);        
+
+        if (enable_1 && enable_2 && enable_3) {
+            total_count ++;
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    for (i = 0; i < 65536; i ++) {
+        ecs_new_w(world, Position); // no match
+        ecs_new_w(world, Velocity); // no match
+        ecs_new_w(world, Mass); // no match
+
+        { // match
+            ecs_entity_t e = ecs_new_w(world, Position);
+            ecs_add(world, e, Velocity);
+            ecs_add(world, e, Mass);
+            total_count ++;
+        }
+    }
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity, Mass",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_assert(ecs_is_enabled(world, it.entities[i], Velocity));
+            test_assert(ecs_is_enabled(world, it.entities[i], Mass));
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_randomized_4_bitsets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_COMPONENT(world, Rotation);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Mass), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Rotation), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 65536; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_add(world, e, Velocity);
+        ecs_add(world, e, Mass);
+        ecs_add(world, e, Rotation);
+
+        bool enable_1 = rand() % 2;
+        ecs_enable_component(world, e, Position, enable_1);
+        bool enable_2 = rand() % 2;
+        ecs_enable_component(world, e, Velocity, enable_2);
+        bool enable_3 = rand() % 2;
+        ecs_enable_component(world, e, Mass, enable_3);        
+        bool enable_4 = rand() % 2;
+        ecs_enable_component(world, e, Rotation, enable_4); 
+
+        if (enable_1 && enable_2 && enable_3 && enable_4) {
+            total_count ++;
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    for (i = 0; i < 65536; i ++) {
+        ecs_new_w(world, Position); // no match
+        ecs_new_w(world, Velocity); // no match
+        ecs_new_w(world, Mass); // no match
+        ecs_new_w(world, Rotation); // no match
+
+        { // match
+            ecs_entity_t e = ecs_new_w(world, Position);
+            ecs_add(world, e, Velocity);
+            ecs_add(world, e, Mass);
+            ecs_add(world, e, Rotation);
+            total_count ++;
+        }
+    }
+
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity, Mass, Rotation",
+        .cache_kind = cache_kind
+    });
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_assert(ecs_is_enabled(world, it.entities[i], Velocity));
+            test_assert(ecs_is_enabled(world, it.entities[i], Mass));
+            test_assert(ecs_is_enabled(world, it.entities[i], Rotation));
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_w_other_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 1024; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+
+        if (!(e % 3)) {
+            ecs_enable_component(world, e, Position, false);
+            if (!(e % 5)) {
+                ecs_add(world, e, Tag);
+            }
+        } else {
+            ecs_enable_component(world, e, Position, true);
+            if (!(e % 5)) {
+                ecs_add(world, e, Tag);
+                total_count ++;
+            }
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Tag",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] % 3);
+            test_assert(!(it.entities[i] % 5));
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_int(p[i].x, it.entities[i]);
+            test_int(p[i].y, it.entities[i]);
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_w_other_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    int32_t i, total_count = 0;
+    for (i = 0; i < 1024; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+
+        if (!(e % 3)) {
+            ecs_enable_component(world, e, Position, false);
+            if (!(e % 5)) {
+                ecs_set(world, e, Velocity, {e * 2, e * 2});
+            }
+        } else {
+            ecs_enable_component(world, e, Position, true);
+            if (!(e % 5)) {
+                ecs_set(world, e, Velocity, {e * 2, e * 2});
+                total_count ++;
+            }
+        }
+    }
+
+    test_assert(total_count != 0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, Velocity",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            test_assert(it.entities[i] % 3);
+            test_assert(!(it.entities[i] % 5));
+            test_assert(ecs_is_enabled(world, it.entities[i], Position));
+            test_int(p[i].x, it.entities[i]);
+            test_int(p[i].y, it.entities[i]);
+            test_int(v[i].x, it.entities[i] * 2);
+            test_int(v[i].y, it.entities[i] * 2);
+        }
+        count += it.count;
+    }
+
+    test_int(count, total_count);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    for (int i = 0; i < 1024; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+
+        if (!(e % 3)) {
+            ecs_enable_component(world, e, Position, false);
+        } else {
+            ecs_enable_component(world, e, Position, true);
+        }
+    }
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "!Position",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0, pos_count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 0));
+
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            if (ecs_has(world, it.entities[i], Position)) {
+                pos_count ++;
+            }
+
+            test_assert(!ecs_is_enabled(
+                world, it.entities[i], Position));
+        }
+
+        count += it.count;
+    }
+
+    test_assert(count != 0);
+    test_assert(pos_count != 0);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+static
+void this_written_not(int total, int mod) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    int i, total_without_pos = 0;
+    for (i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+
+        if (!(e % mod)) {
+            ecs_enable_component(world, e, Position, false);
+            total_without_pos ++;
+        } else {
+            ecs_enable_component(world, e, Position, true);
+        }
+
+        ecs_add(world, e, Tag);
+    }
+
+    for (int i = 0; i < total; i ++) {
+        ecs_new_w(world, Tag);
+        total_without_pos ++;
+    }
+
+    for (int i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+        ecs_add(world, e, Tag);
+    }
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, !Position",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0, pos_count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+
+        int32_t i;
+        for (i = 0; i < it.count; i ++) {
+            if (ecs_has(world, it.entities[i], Position)) {
+                pos_count ++;
+                test_assert(!(it.entities[i] % mod));
+            }
+
+            test_assert(!ecs_is_enabled(
+                world, it.entities[i], Position));
+        }
+
+        count += it.count;
+    }
+
+    test_assert(count != 0);
+    test_assert(pos_count != 0);
+    test_int(count, total_without_pos);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_not_1024_mod_2(void) {
+    this_written_not(1024, 2);
+}
+
+void Toggle_this_written_not_1024_mod_3(void) {
+    this_written_not(1024, 3);
+}
+
+void Toggle_this_written_not_1024_mod_7(void) {
+    this_written_not(1024, 7);
+}
+
+void Toggle_this_written_not_1024_mod_8(void) {
+    this_written_not(1024, 8);
+}
+
+void Toggle_this_written_not_1024_mod_10(void) {
+    this_written_not(1024, 10);
+}
+
+void Toggle_this_written_not_1024_mod_64(void) {
+    this_written_not(1024, 64);
+}
+
+void Toggle_this_written_not_1024_mod_256(void) {
+    this_written_not(1024, 256);
+}
+
+void Toggle_this_written_not_1024_mod_1024(void) {
+    this_written_not(1024, 1024);
+}
+
+static
+void this_optional(int total, int mod) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    int i, total_with_pos = 0;
+    for (i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+
+        if (!(e % mod)) {
+            ecs_enable_component(world, e, Position, true);
+            total_with_pos ++;
+        } else {
+            ecs_enable_component(world, e, Position, false);
+        }
+    }
+
+    for (int i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+        total_with_pos ++;
+    }
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?Position",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0, with_pos_count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        Position *ptr = ecs_field(&it, Position, 0);
+
+        if (ecs_table_has_id(world, it.table, ECS_TOGGLE | ecs_id(Position))) {
+            for (int32_t i = 0; i < it.count; i ++) {
+                if (ecs_is_enabled(world, it.entities[i], Position)) {
+                    test_bool(true, ecs_field_is_set(&it, 0));
+                    test_assert(ptr != NULL);
+                    test_assert(ptr[i].x == it.entities[i]);
+                    test_assert(ptr[i].y == it.entities[i]);
+                    with_pos_count ++;
+                } else {
+                    test_bool(false, ecs_field_is_set(&it, 0));
+                }
+            }
+        } else {
+            if (ecs_table_has_id(world, it.table, ecs_id(Position))) {
+                test_bool(true, ecs_field_is_set(&it, 0));
+                test_assert(ptr != NULL);
+                for (int32_t i = 0; i < it.count; i ++) {
+                    test_assert(ecs_is_enabled(world, it.entities[i], Position));
+                    test_assert(ptr[i].x == it.entities[i]);
+                    test_assert(ptr[i].y == it.entities[i]);
+                    with_pos_count ++;
+                }
+            } else {
+                test_bool(false, ecs_field_is_set(&it, 0));
+                for (int32_t i = 0; i < it.count; i ++) {
+                    test_assert(!ecs_is_enabled(world, it.entities[i], Position));
+                }
+            }
+        }
+
+        count += it.count;
+    }
+
+    test_assert(count != 0);
+    test_int(with_pos_count, total_with_pos);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+static
+void this_written_optional(int total, int mod) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    int i, total_with_pos = 0, total_without_pos = 0;
+    for (i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+
+        if (!(e % mod)) {
+            ecs_enable_component(world, e, Position, true);
+            total_with_pos ++;
+        } else {
+            ecs_enable_component(world, e, Position, false);
+            total_without_pos ++;
+        }
+
+        ecs_add(world, e, Tag);
+    }
+
+    for (int i = 0; i < total; i ++) {
+        ecs_new_w(world, Tag);
+        total_without_pos ++;
+    }
+
+    for (int i = 0; i < total; i ++) {
+        ecs_entity_t e = ecs_new_w(world, Position);
+        ecs_set(world, e, Position, {e, e});
+        ecs_add(world, e, Tag);
+        total_with_pos ++;
+    }
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, ?Position",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0, with_pos_count = 0, without_pos_count = 0;
+
+    while (ecs_query_next(&it)) {
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        Position *ptr = ecs_field(&it, Position, 1);
+
+        if (ecs_table_has_id(world, it.table, ECS_TOGGLE | ecs_id(Position))) {
+            for (int32_t i = 0; i < it.count; i ++) {
+                if (ecs_is_enabled(world, it.entities[i], Position)) {
+                    test_bool(true, ecs_field_is_set(&it, 1));
+                    test_assert(ptr != NULL);
+                    test_assert(ptr[i].x == it.entities[i]);
+                    test_assert(ptr[i].y == it.entities[i]);
+                    with_pos_count ++;
+                } else {
+                    test_bool(false, ecs_field_is_set(&it, 1));
+                    without_pos_count ++;
+                }
+            }
+        } else {
+            if (ecs_table_has_id(world, it.table, ecs_id(Position))) {
+                test_bool(true, ecs_field_is_set(&it, 1));
+                test_assert(ptr != NULL);
+                for (int32_t i = 0; i < it.count; i ++) {
+                    test_assert(ecs_is_enabled(world, it.entities[i], Position));
+                    test_assert(ptr[i].x == it.entities[i]);
+                    test_assert(ptr[i].y == it.entities[i]);
+                    with_pos_count ++;
+                }
+            } else {
+                test_bool(false, ecs_field_is_set(&it, 1));
+                for (int32_t i = 0; i < it.count; i ++) {
+                    test_assert(!ecs_is_enabled(world, it.entities[i], Position));
+                    without_pos_count ++;
+                }
+            }
+        }
+
+        count += it.count;
+    }
+
+    test_assert(count != 0);
+    test_int(count, (with_pos_count + without_pos_count));
+    test_int(with_pos_count, total_with_pos);
+    test_int(without_pos_count, total_without_pos);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_optional(void) {
+    this_optional(1024, 2);
+}
+
+void Toggle_this_written_optional_1024_mod_2(void) {
+    this_written_optional(1024, 2);
+}
+
+void Toggle_this_written_optional_1024_mod_3(void) {
+    this_written_optional(1024, 3);
+}
+
+void Toggle_this_written_optional_1024_mod_7(void) {
+    this_written_optional(1024, 7);
+}
+
+void Toggle_this_written_optional_1024_mod_8(void) {
+    this_written_optional(1024, 8);
+}
+
+void Toggle_this_written_optional_1024_mod_10(void) {
+    this_written_optional(1024, 10);
+}
+
+void Toggle_this_written_optional_1024_mod_64(void) {
+    this_written_optional(1024, 64);
+}
+
+void Toggle_this_written_optional_1024_mod_256(void) {
+    this_written_optional(1024, 256);
+}
+
+void Toggle_this_written_optional_1024_mod_1024(void) {
+    this_written_optional(1024, 1024);
+}
+
+static
+int compare_position(ecs_entity_t e1, const void *ptr1, ecs_entity_t e2, const void *ptr2) {
+    const Position *p1 = ptr1;
+    const Position *p2 = ptr2;
+    return (p1->x > p2->x) - (p1->x < p2->x);
+}
+
+void Toggle_this_sort(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {3, 2}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {2, 2}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {1, 2}));
+    ecs_entity_t e4 = ecs_insert(world, ecs_value(Position, {0, 2}));
+
+    ecs_enable_component(world, e1, Position, true);
+    ecs_enable_component(world, e2, Position, true);
+    ecs_enable_component(world, e3, Position, false);
+    ecs_enable_component(world, e4, Position, false);
+
+    test_bool(ecs_is_enabled(world, e1, Position), true);
+    test_bool(ecs_is_enabled(world, e2, Position), true);
+    test_bool(ecs_is_enabled(world, e3, Position), false);
+    test_bool(ecs_is_enabled(world, e4, Position), false);
+    
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position",
+        .order_by = ecs_id(Position),
+        .order_by_callback = compare_position,
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_assert(it.entities[0] == e2);
+    test_assert(it.entities[1] == e1);
+    test_assert(!ecs_query_next(&it));
+
+    /* Entities will have shuffled around, ensure bits got shuffled too */
+    test_bool(ecs_is_enabled(world, e1, Position), true);
+    test_bool(ecs_is_enabled(world, e2, Position), true);
+    test_bool(ecs_is_enabled(world, e3, Position), false);
+    test_bool(ecs_is_enabled(world, e4, Position), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_table_move_2_from_3(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+
+    ecs_query_t *q = ecs_query(world, { 
+        .expr = "Position",
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+
+    ecs_enable_component(world, e1, Position, true);
+    ecs_enable_component(world, e2, Position, false);
+    ecs_enable_component(world, e3, Position, true);
+
+    test_bool(ecs_is_enabled(world, e1, Position), true);
+    test_bool(ecs_is_enabled(world, e2, Position), false);
+    test_bool(ecs_is_enabled(world, e3, Position), true);
+
+    ecs_add(world, e3, Tag);
+    ecs_add(world, e2, Tag);
+    
+    test_bool(ecs_is_enabled(world, e1, Position), true);
+    test_bool(ecs_is_enabled(world, e2, Position), false);
+    test_bool(ecs_is_enabled(world, e3, Position), true);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e1, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 10); test_int(p->y, 20);
+    }
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(1, it.count);
+        test_uint(e3, it.entities[0]);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p->x, 30); test_int(p->y, 40);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_toggle_w_not_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+
+    /* Toggle Velocity == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+
+    /* Toggle Position == true, Velocity == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+
+    /* Toggle Position == true, Velocity == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+
+    /* Toggle Position == false, Velocity == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+
+    /* Toggle Position == false, Velocity == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, Position, !Velocity"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e9, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_not_toggle_w_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+
+    /* Toggle Velocity == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+
+    /* Toggle Position == true, Velocity == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+
+    /* Toggle Position == true, Velocity == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+
+    /* Toggle Position == false, Velocity == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+
+    /* Toggle Position == false, Velocity == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, !Velocity, Position"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e9, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_toggle_w_optional_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+
+    /* Toggle Velocity == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+
+    /* Toggle Position == true, Velocity == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+
+    /* Toggle Position == true, Velocity == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+
+    /* Toggle Position == false, Velocity == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+
+    /* Toggle Position == false, Velocity == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, Position, ?Velocity"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e8, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e9, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_optional_toggle_w_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+
+    /* Toggle Velocity == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+
+    /* Toggle Position == true, Velocity == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+
+    /* Toggle Position == true, Velocity == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+
+    /* Toggle Position == false, Velocity == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+
+    /* Toggle Position == false, Velocity == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, ?Velocity, Position"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e8, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e9, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_not_w_optional_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+
+    /* Toggle Velocity == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+
+    /* Toggle Position == true, Velocity == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+
+    /* Toggle Position == true, Velocity == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+
+    /* Toggle Position == false, Velocity == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+
+    /* Toggle Position == false, Velocity == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, !Velocity, ?Position"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e9, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e11, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_optional_w_not_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+
+    /* Toggle Velocity == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+
+    /* Toggle Position == true, Velocity == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+
+    /* Toggle Position == true, Velocity == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+
+    /* Toggle Position == false, Velocity == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+
+    /* Toggle Position == false, Velocity == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, ?Position, !Velocity"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e9, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e11, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_2_not_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+
+    /* Toggle Velocity == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+
+    /* Toggle Position == true, Velocity == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+
+    /* Toggle Position == true, Velocity == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+
+    /* Toggle Position == false, Velocity == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+
+    /* Toggle Position == false, Velocity == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, !Position, !Velocity"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e11, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_2_optional_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+
+    /* Toggle Velocity == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+
+    /* Toggle Position == true, Velocity == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+
+    /* Toggle Position == true, Velocity == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+
+    /* Toggle Position == false, Velocity == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+
+    /* Toggle Position == false, Velocity == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, ?Position, ?Velocity"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e8, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e9, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e10, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e11, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(false, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_toggle_w_2_not_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Mass), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+    ecs_add(world, e3, Mass);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true, Mass = true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+    ecs_add(world, e6, Mass);
+    ecs_enable_component(world, e6, Mass, true);
+
+    /* Toggle Velocity == false, Mass == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+    ecs_add(world, e7, Mass);
+    ecs_enable_component(world, e7, Mass, false);
+
+    /* Toggle Position == true, Velocity == true, Mass == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_add(world, e8, Mass);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+    ecs_enable_component(world, e8, Mass, true);
+
+    /* Toggle Position == true, Velocity == false, Mass == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_add(world, e9, Mass);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+    ecs_enable_component(world, e9, Mass, false);
+
+    /* Toggle Position == false, Velocity == true, Mass == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_add(world, e10, Mass);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+    ecs_enable_component(world, e10, Mass, true);
+
+    /* Toggle Position == false, Velocity == false, Mass == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_add(world, e11, Mass);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+    ecs_enable_component(world, e11, Mass, false);
+
+    /* Toggle Position == true, Velocity == true, Mass == true */
+    ecs_entity_t e12 = ecs_new_w(world, Tag);
+    ecs_add(world, e12, Position);
+    ecs_add(world, e12, Velocity);
+    ecs_add(world, e12, Mass);
+    ecs_enable_component(world, e12, Position, true);
+    ecs_enable_component(world, e12, Velocity, true);
+    ecs_enable_component(world, e12, Mass, false);
+
+    /* Toggle Position == true, Velocity == false, Mass == true */
+    ecs_entity_t e13 = ecs_new_w(world, Tag);
+    ecs_add(world, e13, Position);
+    ecs_add(world, e13, Velocity);
+    ecs_add(world, e13, Mass);
+    ecs_enable_component(world, e13, Position, true);
+    ecs_enable_component(world, e13, Velocity, false);
+    ecs_enable_component(world, e13, Mass, true);
+
+    /* Toggle Position == false, Velocity == true, Mass == false */
+    ecs_entity_t e14 = ecs_new_w(world, Tag);
+    ecs_add(world, e14, Position);
+    ecs_add(world, e14, Velocity);
+    ecs_add(world, e14, Mass);
+    ecs_enable_component(world, e14, Position, false);
+    ecs_enable_component(world, e14, Velocity, true);
+    ecs_enable_component(world, e14, Mass, false);
+
+    /* Toggle Position == false, Velocity == false, Mass == true */
+    ecs_entity_t e15 = ecs_new_w(world, Tag);
+    ecs_add(world, e15, Position);
+    ecs_add(world, e15, Velocity);
+    ecs_add(world, e15, Mass);
+    ecs_enable_component(world, e15, Position, false);
+    ecs_enable_component(world, e15, Velocity, false);
+    ecs_enable_component(world, e15, Mass, true);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, Position, !Velocity, !Mass"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e9, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_toggle_w_2_optional_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Mass), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+    ecs_add(world, e3, Mass);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true, Mass = true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+    ecs_add(world, e6, Mass);
+    ecs_enable_component(world, e6, Mass, true);
+
+    /* Toggle Velocity == false, Mass == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+    ecs_add(world, e7, Mass);
+    ecs_enable_component(world, e7, Mass, false);
+
+    /* Toggle Position == true, Velocity == true, Mass == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_add(world, e8, Mass);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+    ecs_enable_component(world, e8, Mass, true);
+
+    /* Toggle Position == true, Velocity == false, Mass == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_add(world, e9, Mass);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+    ecs_enable_component(world, e9, Mass, false);
+
+    /* Toggle Position == false, Velocity == true, Mass == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_add(world, e10, Mass);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+    ecs_enable_component(world, e10, Mass, true);
+
+    /* Toggle Position == false, Velocity == false, Mass == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_add(world, e11, Mass);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+    ecs_enable_component(world, e11, Mass, false);
+
+    /* Toggle Position == true, Velocity == true, Mass == true */
+    ecs_entity_t e12 = ecs_new_w(world, Tag);
+    ecs_add(world, e12, Position);
+    ecs_add(world, e12, Velocity);
+    ecs_add(world, e12, Mass);
+    ecs_enable_component(world, e12, Position, true);
+    ecs_enable_component(world, e12, Velocity, true);
+    ecs_enable_component(world, e12, Mass, false);
+
+    /* Toggle Position == true, Velocity == false, Mass == true */
+    ecs_entity_t e13 = ecs_new_w(world, Tag);
+    ecs_add(world, e13, Position);
+    ecs_add(world, e13, Velocity);
+    ecs_add(world, e13, Mass);
+    ecs_enable_component(world, e13, Position, true);
+    ecs_enable_component(world, e13, Velocity, false);
+    ecs_enable_component(world, e13, Mass, true);
+
+    /* Toggle Position == false, Velocity == true, Mass == false */
+    ecs_entity_t e14 = ecs_new_w(world, Tag);
+    ecs_add(world, e14, Position);
+    ecs_add(world, e14, Velocity);
+    ecs_add(world, e14, Mass);
+    ecs_enable_component(world, e14, Position, false);
+    ecs_enable_component(world, e14, Velocity, true);
+    ecs_enable_component(world, e14, Mass, false);
+
+    /* Toggle Position == false, Velocity == false, Mass == true */
+    ecs_entity_t e15 = ecs_new_w(world, Tag);
+    ecs_add(world, e15, Position);
+    ecs_add(world, e15, Velocity);
+    ecs_add(world, e15, Mass);
+    ecs_enable_component(world, e15, Position, false);
+    ecs_enable_component(world, e15, Velocity, false);
+    ecs_enable_component(world, e15, Mass, true);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, Position, ?Velocity, ?Mass"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e8, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e9, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e12, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e13, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(false, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_2_toggle_w_not_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Mass), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+    ecs_add(world, e3, Mass);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true, Mass = true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+    ecs_add(world, e6, Mass);
+    ecs_enable_component(world, e6, Mass, true);
+
+    /* Toggle Velocity == false, Mass == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+    ecs_add(world, e7, Mass);
+    ecs_enable_component(world, e7, Mass, false);
+
+    /* Toggle Position == true, Velocity == true, Mass == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_add(world, e8, Mass);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+    ecs_enable_component(world, e8, Mass, true);
+
+    /* Toggle Position == true, Velocity == false, Mass == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_add(world, e9, Mass);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+    ecs_enable_component(world, e9, Mass, false);
+
+    /* Toggle Position == false, Velocity == true, Mass == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_add(world, e10, Mass);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+    ecs_enable_component(world, e10, Mass, true);
+
+    /* Toggle Position == false, Velocity == false, Mass == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_add(world, e11, Mass);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+    ecs_enable_component(world, e11, Mass, false);
+
+    /* Toggle Position == true, Velocity == true, Mass == true */
+    ecs_entity_t e12 = ecs_new_w(world, Tag);
+    ecs_add(world, e12, Position);
+    ecs_add(world, e12, Velocity);
+    ecs_add(world, e12, Mass);
+    ecs_enable_component(world, e12, Position, true);
+    ecs_enable_component(world, e12, Velocity, true);
+    ecs_enable_component(world, e12, Mass, false);
+
+    /* Toggle Position == true, Velocity == false, Mass == true */
+    ecs_entity_t e13 = ecs_new_w(world, Tag);
+    ecs_add(world, e13, Position);
+    ecs_add(world, e13, Velocity);
+    ecs_add(world, e13, Mass);
+    ecs_enable_component(world, e13, Position, true);
+    ecs_enable_component(world, e13, Velocity, false);
+    ecs_enable_component(world, e13, Mass, true);
+
+    /* Toggle Position == false, Velocity == true, Mass == false */
+    ecs_entity_t e14 = ecs_new_w(world, Tag);
+    ecs_add(world, e14, Position);
+    ecs_add(world, e14, Velocity);
+    ecs_add(world, e14, Mass);
+    ecs_enable_component(world, e14, Position, false);
+    ecs_enable_component(world, e14, Velocity, true);
+    ecs_enable_component(world, e14, Mass, false);
+
+    /* Toggle Position == false, Velocity == false, Mass == true */
+    ecs_entity_t e15 = ecs_new_w(world, Tag);
+    ecs_add(world, e15, Position);
+    ecs_add(world, e15, Velocity);
+    ecs_add(world, e15, Mass);
+    ecs_enable_component(world, e15, Position, false);
+    ecs_enable_component(world, e15, Velocity, false);
+    ecs_enable_component(world, e15, Mass, true);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, Position, Velocity, !Mass"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e12, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Toggle_this_written_2_toggle_w_optional_toggle(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+    ECS_TAG(world, Tag);
+
+    ecs_add_id(world, ecs_id(Position), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Velocity), EcsCanToggle);
+    ecs_add_id(world, ecs_id(Mass), EcsCanToggle);
+
+    /* No toggles */
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_add(world, e1, Position);
+
+    /* No components */
+    /* ecs_entity_t e2 = */ ecs_new_w(world, Tag);
+
+    /* Components, No toggles */
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_add(world, e3, Position);
+    ecs_add(world, e3, Velocity);
+    ecs_add(world, e3, Mass);
+
+    /* Toggle Position == true */
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_add(world, e4, Position);
+    ecs_enable_component(world, e4, Position, true);
+
+    /* Toggle Position == false */
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_add(world, e5, Position);
+    ecs_enable_component(world, e5, Position, false);
+
+    /* Toggle Velocity == true, Mass = true */
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_add(world, e6, Position);
+    ecs_add(world, e6, Velocity);
+    ecs_enable_component(world, e6, Velocity, true);
+    ecs_add(world, e6, Mass);
+    ecs_enable_component(world, e6, Mass, true);
+
+    /* Toggle Velocity == false, Mass == false */
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_add(world, e7, Position);
+    ecs_add(world, e7, Velocity);
+    ecs_enable_component(world, e7, Velocity, false);
+    ecs_add(world, e7, Mass);
+    ecs_enable_component(world, e7, Mass, false);
+
+    /* Toggle Position == true, Velocity == true, Mass == true */
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
+    ecs_add(world, e8, Position);
+    ecs_add(world, e8, Velocity);
+    ecs_add(world, e8, Mass);
+    ecs_enable_component(world, e8, Position, true);
+    ecs_enable_component(world, e8, Velocity, true);
+    ecs_enable_component(world, e8, Mass, true);
+
+    /* Toggle Position == true, Velocity == false, Mass == false */
+    ecs_entity_t e9 = ecs_new_w(world, Tag);
+    ecs_add(world, e9, Position);
+    ecs_add(world, e9, Velocity);
+    ecs_add(world, e9, Mass);
+    ecs_enable_component(world, e9, Position, true);
+    ecs_enable_component(world, e9, Velocity, false);
+    ecs_enable_component(world, e9, Mass, false);
+
+    /* Toggle Position == false, Velocity == true, Mass == true */
+    ecs_entity_t e10 = ecs_new_w(world, Tag);
+    ecs_add(world, e10, Position);
+    ecs_add(world, e10, Velocity);
+    ecs_add(world, e10, Mass);
+    ecs_enable_component(world, e10, Position, false);
+    ecs_enable_component(world, e10, Velocity, true);
+    ecs_enable_component(world, e10, Mass, true);
+
+    /* Toggle Position == false, Velocity == false, Mass == false */
+    ecs_entity_t e11 = ecs_new_w(world, Tag);
+    ecs_add(world, e11, Position);
+    ecs_add(world, e11, Velocity);
+    ecs_add(world, e11, Mass);
+    ecs_enable_component(world, e11, Position, false);
+    ecs_enable_component(world, e11, Velocity, false);
+    ecs_enable_component(world, e11, Mass, false);
+
+    /* Toggle Position == true, Velocity == true, Mass == true */
+    ecs_entity_t e12 = ecs_new_w(world, Tag);
+    ecs_add(world, e12, Position);
+    ecs_add(world, e12, Velocity);
+    ecs_add(world, e12, Mass);
+    ecs_enable_component(world, e12, Position, true);
+    ecs_enable_component(world, e12, Velocity, true);
+    ecs_enable_component(world, e12, Mass, false);
+
+    /* Toggle Position == true, Velocity == false, Mass == true */
+    ecs_entity_t e13 = ecs_new_w(world, Tag);
+    ecs_add(world, e13, Position);
+    ecs_add(world, e13, Velocity);
+    ecs_add(world, e13, Mass);
+    ecs_enable_component(world, e13, Position, true);
+    ecs_enable_component(world, e13, Velocity, false);
+    ecs_enable_component(world, e13, Mass, true);
+
+    /* Toggle Position == false, Velocity == true, Mass == false */
+    ecs_entity_t e14 = ecs_new_w(world, Tag);
+    ecs_add(world, e14, Position);
+    ecs_add(world, e14, Velocity);
+    ecs_add(world, e14, Mass);
+    ecs_enable_component(world, e14, Position, false);
+    ecs_enable_component(world, e14, Velocity, true);
+    ecs_enable_component(world, e14, Mass, false);
+
+    /* Toggle Position == false, Velocity == false, Mass == true */
+    ecs_entity_t e15 = ecs_new_w(world, Tag);
+    ecs_add(world, e15, Position);
+    ecs_add(world, e15, Velocity);
+    ecs_add(world, e15, Mass);
+    ecs_enable_component(world, e15, Position, false);
+    ecs_enable_component(world, e15, Velocity, false);
+    ecs_enable_component(world, e15, Mass, true);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag, Position, Velocity, ?Mass"
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e8, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(true, ecs_field_is_set(&it, 3));
+
+    test_bool(true, ecs_iter_next(&it));
+    test_int(1, it.count);
+    test_uint(e12, it.entities[0]);
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 3));
+    test_bool(true, ecs_field_is_set(&it, 0));
+    test_bool(true, ecs_field_is_set(&it, 1));
+    test_bool(true, ecs_field_is_set(&it, 2));
+    test_bool(false, ecs_field_is_set(&it, 3));
+
+    test_bool(false, ecs_iter_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
diff --git a/test/addons/src/RulesTransitive.c b/test/query/src/Transitive.c
similarity index 57%
rename from test/addons/src/RulesTransitive.c
rename to test/query/src/Transitive.c
index 1e1de8281..f2365b93b 100644
--- a/test/addons/src/RulesTransitive.c
+++ b/test/query/src/Transitive.c
@@ -1,4 +1,4 @@
-#include <addons.h>
+#include <query.h>
 
 ECS_ENTITY_DECLARE(LocatedIn);
 ECS_TAG_DECLARE(Earth);
@@ -29,268 +29,323 @@ void populate_facts(ecs_world_t *world) {
     ECS_ENTITY_DEFINE(world, Amsterdam, Location, (LocatedIn, NoordHolland));
 }
 
-void RulesTransitive_1_fact_0_lvl_true(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_fact_0_lvl_true(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, SanFrancisco)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_fact_1_lvl_true(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_fact_1_lvl_true(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, California)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_fact_2_lvl_true(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_fact_2_lvl_true(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, UnitedStates)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_fact_0_lvl_false(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_fact_0_lvl_false(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, Seattle)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_fact_1_lvl_false(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_fact_1_lvl_false(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, Washington)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_fact_2_lvl_false(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_fact_2_lvl_false(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, Netherlands)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_fact_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_fact_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ecs_add_id(world, LocatedIn, EcsReflexive);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, e1)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, e1), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, e1), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, e1), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, e1), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Transitive_1_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, BaseA, 0);
+    ECS_ENTITY(world, BaseB, 0);
+    ECS_ENTITY(world, e1, (IsA, BaseB));
+    ECS_ENTITY(world, e2, (IsA, BaseA));
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(IsA, BaseA)"
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(BaseA, it.entities[0]);
+    test_uint(ecs_isa(BaseA), ecs_field_id(&it, 0));
+    test_uint(0, ecs_field_src(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_isa(BaseA), ecs_field_id(&it, 0));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Transitive_1_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, BaseA, 0);
+    ECS_ENTITY(world, BaseB, 0);
+    ECS_ENTITY(world, e1, (ChildOf, BaseB));
+    ECS_ENTITY(world, e2, (ChildOf, BaseA));
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(ChildOf, BaseA)"
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ecs_childof(BaseA), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_written_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_written_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Tag($this), LocatedIn($this, SanFrancisco)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -300,46 +355,46 @@ void RulesTransitive_1_this_src_written_0_lvl(void) {
     ecs_add_pair(world, e5, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
         test_uint(e1, it.entities[0]);
         test_uint(e5, it.entities[1]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_written_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_written_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Tag($this), LocatedIn($this, California)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -349,54 +404,54 @@ void RulesTransitive_1_this_src_written_1_lvl(void) {
     ecs_add_pair(world, e5, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
         test_uint(e1, it.entities[0]);
         test_uint(e5, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
         test_uint(e2, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_written_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_written_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Tag($this), LocatedIn($this, UnitedStates)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -406,42 +461,42 @@ void RulesTransitive_1_this_src_written_2_lvl(void) {
     ecs_add_pair(world, e5, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
         test_uint(e1, it.entities[0]);
         test_uint(e5, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
         test_uint(e2, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
         test_uint(e3, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_written_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_written_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
@@ -449,36 +504,36 @@ void RulesTransitive_1_this_src_written_reflexive(void) {
 
     ecs_add_id(world, LocatedIn, EcsReflexive);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-    ecs_entity_t e8 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
 
     ecs_set_name(world, e1, "e1");
     ecs_set_name(world, e2, "e2");
     ecs_set_name(world, e3, "e3");
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Tag($this), LocatedIn($this, e2)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
         test_uint(e2, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -491,55 +546,55 @@ void RulesTransitive_1_this_src_written_reflexive(void) {
     ecs_add_pair(world, e8, LocatedIn, e2);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
         test_uint(e2, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
         test_uint(e7, it.entities[0]);
         test_uint(e8, it.entities[1]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-    ecs_entity_t e5 = ecs_new_id(world);
-    ecs_entity_t e6 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+    ecs_entity_t e5 = ecs_new(world);
+    ecs_entity_t e6 = ecs_new(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, SanFrancisco)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -552,43 +607,43 @@ void RulesTransitive_1_this_src_0_lvl(void) {
     ecs_add(world, e2, Tag);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e1, it.entities[0]);
         test_uint(e6, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e2, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-    ecs_entity_t e5 = ecs_new_id(world);
-    ecs_entity_t e6 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+    ecs_entity_t e5 = ecs_new(world);
+    ecs_entity_t e6 = ecs_new(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, California)"
     });
 
@@ -604,56 +659,56 @@ void RulesTransitive_1_this_src_1_lvl(void) {
     ecs_add(world, e2, Tag);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e1, it.entities[0]);
         test_uint(e6, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e2, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e3, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-    ecs_entity_t e5 = ecs_new_id(world);
-    ecs_entity_t e6 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+    ecs_entity_t e5 = ecs_new(world);
+    ecs_entity_t e6 = ecs_new(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, UnitedStates)"
     });
 
@@ -669,62 +724,62 @@ void RulesTransitive_1_this_src_2_lvl(void) {
     ecs_add(world, e2, Tag);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e1, it.entities[0]);
         test_uint(e6, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e2, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e4, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
@@ -732,14 +787,14 @@ void RulesTransitive_1_this_src_reflexive(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-    ecs_entity_t e5 = ecs_new_id(world);
-    ecs_entity_t e6 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+    ecs_entity_t e5 = ecs_new(world);
+    ecs_entity_t e6 = ecs_new(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, California)"
     });
 
@@ -755,208 +810,208 @@ void RulesTransitive_1_this_src_reflexive(void) {
     ecs_add(world, e2, Tag);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e1, it.entities[0]);
         test_uint(e6, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e2, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(e3, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_ent_src_tgt_var_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_ent_src_tgt_var_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, UnitedStates);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_ent_src_tgt_var_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_ent_src_tgt_var_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, California);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_ent_src_tgt_var_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_ent_src_tgt_var_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_ent_src_tgt_var_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_ent_src_tgt_var_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
@@ -964,191 +1019,191 @@ void RulesTransitive_1_ent_src_tgt_var_reflexive(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, e1), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, e1), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(UnitedStates, it.entities[0]);
         test_uint(Netherlands, it.entities[1]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_this_src_tgt_var_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_this_src_tgt_var_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
@@ -1156,218 +1211,218 @@ void RulesTransitive_1_this_src_tgt_var_reflexive(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
+        ecs_iter_t it = ecs_query_iter(world, r);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Amsterdam, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Seattle, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(LosAngeles, ecs_iter_get_var(&it, x_var));
         test_uint(LosAngeles, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(Washington, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(Netherlands, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(UnitedStates, it.entities[0]);
         test_uint(Netherlands, it.entities[1]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_written_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_written_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Tag($r), LocatedIn($r, SanFrancisco)"
     });
 
     test_assert(r != NULL);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -1377,56 +1432,56 @@ void RulesTransitive_1_var_src_written_0_lvl(void) {
     ecs_add_pair(world, e5, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
         test_uint(e1, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
+        test_uint(e5, ecs_field_src(&it, 0));
         test_uint(e5, ecs_field_src(&it, 1));
-        test_uint(e5, ecs_field_src(&it, 2));
         test_uint(e5, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_written_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_written_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Tag($r), LocatedIn($r, California)"
     });
 
     test_assert(r != NULL);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -1436,64 +1491,64 @@ void RulesTransitive_1_var_src_written_1_lvl(void) {
     ecs_add_pair(world, e5, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
         test_uint(e1, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(e5, ecs_field_src(&it, 0));
         test_uint(e5, ecs_field_src(&it, 1));
-        test_uint(e5, ecs_field_src(&it, 2));
         test_uint(e5, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
         test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
         test_uint(e2, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_written_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_written_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     populate_facts(world);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Tag($r), LocatedIn($r, UnitedStates)"
     });
 
     test_assert(r != NULL);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -1503,49 +1558,49 @@ void RulesTransitive_1_var_src_written_2_lvl(void) {
     ecs_add_pair(world, e5, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
         test_uint(e1, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(e5, ecs_field_src(&it, 0));
         test_uint(e5, ecs_field_src(&it, 1));
-        test_uint(e5, ecs_field_src(&it, 2));
         test_uint(e5, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
         test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
         test_uint(e2, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
         test_uint(e3, ecs_field_src(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 2));
         test_uint(e3, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_written_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_written_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
@@ -1553,39 +1608,39 @@ void RulesTransitive_1_var_src_written_reflexive(void) {
 
     ecs_add_id(world, LocatedIn, EcsReflexive);
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
-    ecs_entity_t e5 = ecs_new(world, Tag);
-    ecs_entity_t e6 = ecs_new(world, Tag);
-    ecs_entity_t e7 = ecs_new(world, Tag);
-    ecs_entity_t e8 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
+    ecs_entity_t e5 = ecs_new_w(world, Tag);
+    ecs_entity_t e6 = ecs_new_w(world, Tag);
+    ecs_entity_t e7 = ecs_new_w(world, Tag);
+    ecs_entity_t e8 = ecs_new_w(world, Tag);
 
     ecs_set_name(world, e1, "e1");
     ecs_set_name(world, e2, "e2");
     ecs_set_name(world, e3, "e3");
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Tag($r), LocatedIn($r, e2)"
     });
 
     test_assert(r != NULL);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
         test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
         test_uint(e2, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -1598,65 +1653,65 @@ void RulesTransitive_1_var_src_written_reflexive(void) {
     ecs_add_pair(world, e8, LocatedIn, e2);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
         test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
         test_uint(e2, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 1));
+        test_uint(e7, ecs_field_src(&it, 0));
         test_uint(e7, ecs_field_src(&it, 1));
-        test_uint(e7, ecs_field_src(&it, 2));
         test_uint(e7, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, e2), ecs_field_id(&it, 1));
+        test_uint(e8, ecs_field_src(&it, 0));
         test_uint(e8, ecs_field_src(&it, 1));
-        test_uint(e8, ecs_field_src(&it, 2));
         test_uint(e8, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-    ecs_entity_t e5 = ecs_new_id(world);
-    ecs_entity_t e6 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+    ecs_entity_t e5 = ecs_new(world);
+    ecs_entity_t e6 = ecs_new(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($r, SanFrancisco)"
     });
 
     test_assert(r != NULL);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -1669,54 +1724,54 @@ void RulesTransitive_1_var_src_0_lvl(void) {
     ecs_add(world, e2, Tag);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e6, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e6, ecs_field_src(&it, 0));
         test_uint(e6, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 0));
         test_uint(e2, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-    ecs_entity_t e5 = ecs_new_id(world);
-    ecs_entity_t e6 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+    ecs_entity_t e5 = ecs_new(world);
+    ecs_entity_t e6 = ecs_new(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($r, California)"
     });
 
     test_assert(r != NULL);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -1729,72 +1784,72 @@ void RulesTransitive_1_var_src_1_lvl(void) {
     ecs_add(world, e2, Tag);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e6, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e6, ecs_field_src(&it, 0));
         test_uint(e6, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 0));
         test_uint(e2, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 0));
         test_uint(e3, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-    ecs_entity_t e5 = ecs_new_id(world);
-    ecs_entity_t e6 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+    ecs_entity_t e5 = ecs_new(world);
+    ecs_entity_t e6 = ecs_new(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($r, UnitedStates)"
     });
 
     test_assert(r != NULL);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -1807,77 +1862,77 @@ void RulesTransitive_1_var_src_2_lvl(void) {
     ecs_add(world, e2, Tag);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e6, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e6, ecs_field_src(&it, 0));
         test_uint(e6, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 0));
         test_uint(e2, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 0));
         test_uint(e3, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 1));
-        test_uint(e4, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 0));
+        test_uint(e4, ecs_field_src(&it, 0));
         test_uint(e4, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
@@ -1885,20 +1940,20 @@ void RulesTransitive_1_var_src_reflexive(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_id(world);
-    ecs_entity_t e2 = ecs_new_id(world);
-    ecs_entity_t e3 = ecs_new_id(world);
-    ecs_entity_t e4 = ecs_new_id(world);
-    ecs_entity_t e5 = ecs_new_id(world);
-    ecs_entity_t e6 = ecs_new_id(world);
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+    ecs_entity_t e4 = ecs_new(world);
+    ecs_entity_t e5 = ecs_new(world);
+    ecs_entity_t e6 = ecs_new(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($r, California)"
     });
 
     test_assert(r != NULL);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
@@ -1911,228 +1966,228 @@ void RulesTransitive_1_var_src_reflexive(void) {
     ecs_add(world, e2, Tag);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e6, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e6, ecs_field_src(&it, 0));
         test_uint(e6, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 0));
         test_uint(e2, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 0));
         test_uint(e3, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($r, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(UnitedStates, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Netherlands, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_tgt_var_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_tgt_var_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
@@ -2140,405 +2195,405 @@ void RulesTransitive_1_var_src_tgt_var_reflexive(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($r, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
+        ecs_iter_t it = ecs_query_iter(world, r);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Amsterdam, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Seattle, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(LosAngeles, ecs_iter_get_var(&it, x_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(UnitedStates, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(Netherlands, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(UnitedStates, ecs_iter_get_var(&it, r_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(Netherlands, ecs_iter_get_var(&it, r_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_ent_src_tgt_this_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_ent_src_tgt_this_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $this)"
     });
 
     test_assert(r != NULL);
 
-    int this_var = ecs_rule_find_var(r, "This");
+    int this_var = ecs_query_find_var(r, "this");
     test_assert(this_var != -1);
     test_assert(this_var != 0);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, UnitedStates);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_ent_src_tgt_this_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_ent_src_tgt_this_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $this)"
     });
 
     test_assert(r != NULL);
 
-    int this_var = ecs_rule_find_var(r, "This");
+    int this_var = ecs_query_find_var(r, "this");
     test_assert(this_var != -1);
     test_assert(this_var != 0);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, California);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, this_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_ent_src_tgt_this_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_ent_src_tgt_this_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $this)"
     });
 
     test_assert(r != NULL);
 
-    int this_var = ecs_rule_find_var(r, "This");
+    int this_var = ecs_query_find_var(r, "this");
     test_assert(this_var != -1);
     test_assert(this_var != 0);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, this_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_ent_src_tgt_this_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_ent_src_tgt_this_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
@@ -2546,257 +2601,257 @@ void RulesTransitive_1_ent_src_tgt_this_reflexive(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $this)"
     });
 
     test_assert(r != NULL);
 
-    int this_var = ecs_rule_find_var(r, "This");
+    int this_var = ecs_query_find_var(r, "this");
     test_assert(this_var != -1);
     test_assert(this_var != 0);
 
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, e1), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, e1), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_iter_get_var(&it, this_var));
         test_uint(e1, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, this_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_tgt_this(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_tgt_this(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($r, $this)"
     });
 
     test_assert(r != NULL);
 
-    int this_var = ecs_rule_find_var(r, "This");
+    int this_var = ecs_query_find_var(r, "this");
     test_assert(this_var != -1);
     test_assert(this_var != 0);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, this_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, this_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
         test_uint(Netherlands, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, this_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
         test_uint(Netherlands, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, this_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
         test_uint(Washington, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, this_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(UnitedStates, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Netherlands, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_var_src_tgt_this_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_var_src_tgt_this_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
@@ -2804,263 +2859,263 @@ void RulesTransitive_1_var_src_tgt_this_reflexive(void) {
 
     ECS_TAG(world, Tag);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($r, $this)"
     });
 
     test_assert(r != NULL);
 
-    int this_var = ecs_rule_find_var(r, "This");
+    int this_var = ecs_query_find_var(r, "this");
     test_assert(this_var != -1);
 
-    int r_var = ecs_rule_find_var(r, "r");
+    int r_var = ecs_query_find_var(r, "r");
     test_assert(r_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
+        ecs_iter_t it = ecs_query_iter(world, r);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Amsterdam, ecs_iter_get_var(&it, this_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, this_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, this_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
         test_uint(Netherlands, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Amsterdam, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, this_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, this_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
         test_uint(Netherlands, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(NoordHolland, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Seattle, ecs_iter_get_var(&it, this_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, this_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
         test_uint(Washington, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Seattle, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
         test_uint(SanFrancisco, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(LosAngeles, ecs_iter_get_var(&it, this_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
         test_uint(LosAngeles, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, this_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(LosAngeles, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, this_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, this_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
         test_uint(Washington, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(California, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Washington, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(UnitedStates, ecs_iter_get_var(&it, r_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, this_var));
         test_uint(Netherlands, ecs_iter_get_var(&it, r_var));
         test_uint(Netherlands, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(UnitedStates, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, this_var));
         test_uint(Netherlands, ecs_iter_get_var(&it, r_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_ent_src_constrain_tgt_var_before_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_ent_src_constrain_tgt_var_before_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, City);
 
@@ -3071,42 +3126,42 @@ void RulesTransitive_2_ent_src_constrain_tgt_var_before_0_lvl(void) {
     ecs_add(world, Seattle, City);
     ecs_add(world, Amsterdam, City);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "City($x), LocatedIn(e1, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(City, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
+        test_uint(City, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_ent_src_constrain_tgt_var_before_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_ent_src_constrain_tgt_var_before_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, State);
 
@@ -3116,42 +3171,42 @@ void RulesTransitive_2_ent_src_constrain_tgt_var_before_1_lvl(void) {
     ecs_add(world, Washington, State);
     ecs_add(world, NoordHolland, State);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "State($x), LocatedIn(e1, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(State, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
-        test_uint(California, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
+        test_uint(State, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(California, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
         test_uint(California, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_ent_src_constrain_tgt_var_before_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_ent_src_constrain_tgt_var_before_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Country);
 
@@ -3160,42 +3215,42 @@ void RulesTransitive_2_ent_src_constrain_tgt_var_before_2_lvl(void) {
     ecs_add(world, UnitedStates, Country);
     ecs_add(world, Netherlands, Country);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, Amsterdam);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Country($x), LocatedIn(e1, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(Country, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
+        test_uint(Country, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_ent_src_constrain_tgt_var_after_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_ent_src_constrain_tgt_var_after_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, City);
 
@@ -3206,42 +3261,42 @@ void RulesTransitive_2_ent_src_constrain_tgt_var_after_0_lvl(void) {
     ecs_add(world, Seattle, City);
     ecs_add(world, Amsterdam, City);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $x), City($x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(City, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(City, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 1));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_ent_src_constrain_tgt_var_after_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_ent_src_constrain_tgt_var_after_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, State);
 
@@ -3251,42 +3306,42 @@ void RulesTransitive_2_ent_src_constrain_tgt_var_after_1_lvl(void) {
     ecs_add(world, Washington, State);
     ecs_add(world, NoordHolland, State);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $x), State($x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(State, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(California, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(State, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(California, ecs_field_src(&it, 1));
         test_uint(California, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_ent_src_constrain_tgt_var_after_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_ent_src_constrain_tgt_var_after_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Country);
 
@@ -3295,42 +3350,42 @@ void RulesTransitive_2_ent_src_constrain_tgt_var_after_2_lvl(void) {
     ecs_add(world, UnitedStates, Country);
     ecs_add(world, Netherlands, Country);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, Amsterdam);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(e1, $x), Country($x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Country, ecs_field_id(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Country, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_this_src_constrain_tgt_var_before_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_this_src_constrain_tgt_var_before_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, City);
 
@@ -3341,64 +3396,64 @@ void RulesTransitive_2_this_src_constrain_tgt_var_before_0_lvl(void) {
     ecs_add(world, Seattle, City);
     ecs_add(world, Amsterdam, City);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-    ecs_entity_t e4 = ecs_new_entity(world, "e4");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+    ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
     ecs_add_pair(world, e4, LocatedIn, Amsterdam);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "City($x), LocatedIn($this, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(City, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(City, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
         test_uint(e1, it.entities[0]);
         test_uint(e2, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(City, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 2));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(City, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(LosAngeles, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(City, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 2));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(City, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 1));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(Amsterdam, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_this_src_constrain_tgt_var_before_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_this_src_constrain_tgt_var_before_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, State);
 
@@ -3408,92 +3463,92 @@ void RulesTransitive_2_this_src_constrain_tgt_var_before_1_lvl(void) {
     ecs_add(world, Washington, State);
     ecs_add(world, NoordHolland, State);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-    ecs_entity_t e4 = ecs_new_entity(world, "e4");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+    ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
     ecs_add_pair(world, e4, LocatedIn, Amsterdam);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "State($x), LocatedIn($this, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(State, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
-        test_uint(California, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(State, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(California, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(State, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
-        test_uint(California, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(State, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
+        test_uint(California, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(e1, it.entities[0]);
         test_uint(e2, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(State, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 2));
-        test_uint(California, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(State, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
+        test_uint(California, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(State, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 2));
-        test_uint(Washington, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(State, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
+        test_uint(Washington, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(State, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 2));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(State, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(State, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 2));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(State, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 1));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_this_src_constrain_tgt_var_before_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_this_src_constrain_tgt_var_before_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Country);
 
@@ -3502,111 +3557,111 @@ void RulesTransitive_2_this_src_constrain_tgt_var_before_2_lvl(void) {
     ecs_add(world, UnitedStates, Country);
     ecs_add(world, Netherlands, Country);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-    ecs_entity_t e4 = ecs_new_entity(world, "e4");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+    ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
     ecs_add_pair(world, e4, LocatedIn, Amsterdam);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Country($x), LocatedIn($this, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Country, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(Country, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Country, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(Country, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Country, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(Country, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(e1, it.entities[0]);
         test_uint(e2, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Country, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 2));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(Country, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Country, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 2));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(Country, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Country, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 2));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(Country, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Country, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 2));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(Country, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Country, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 2));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(Country, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 1));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_this_src_constrain_tgt_var_after_0_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_this_src_constrain_tgt_var_after_0_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, City);
 
@@ -3617,64 +3672,64 @@ void RulesTransitive_2_this_src_constrain_tgt_var_after_0_lvl(void) {
     ecs_add(world, Seattle, City);
     ecs_add(world, Amsterdam, City);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-    ecs_entity_t e4 = ecs_new_entity(world, "e4");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+    ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
     ecs_add_pair(world, e4, LocatedIn, Amsterdam);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, $x), City($x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 1));
-        test_uint(City, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 0));
+        test_uint(City, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 1));
         test_uint(Amsterdam, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(City, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(City, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 1));
         test_uint(LosAngeles, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(City, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(City, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 1));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
         test_uint(e1, it.entities[0]);
         test_uint(e2, it.entities[1]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_this_src_constrain_tgt_var_after_1_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_this_src_constrain_tgt_var_after_1_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, State);
 
@@ -3684,92 +3739,92 @@ void RulesTransitive_2_this_src_constrain_tgt_var_after_1_lvl(void) {
     ecs_add(world, Washington, State);
     ecs_add(world, NoordHolland, State);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-    ecs_entity_t e4 = ecs_new_entity(world, "e4");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+    ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
     ecs_add_pair(world, e4, LocatedIn, Amsterdam);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, $x), State($x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(State, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(State, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 1));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(State, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(California, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(State, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(California, ecs_field_src(&it, 1));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(State, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(California, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(State, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(California, ecs_field_src(&it, 1));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(e1, it.entities[0]);
         test_uint(e2, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(State, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(State, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 1));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(State, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(State, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 1));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(State, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(California, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(State, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(California, ecs_field_src(&it, 1));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_this_src_constrain_tgt_var_after_2_lvl(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_this_src_constrain_tgt_var_after_2_lvl(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Country);
 
@@ -3778,117 +3833,117 @@ void RulesTransitive_2_this_src_constrain_tgt_var_after_2_lvl(void) {
     ecs_add(world, UnitedStates, Country);
     ecs_add(world, Netherlands, Country);
 
-    ecs_entity_t e1 = ecs_new_entity(world, "e1");
-    ecs_entity_t e2 = ecs_new_entity(world, "e2");
-    ecs_entity_t e3 = ecs_new_entity(world, "e3");
-    ecs_entity_t e4 = ecs_new_entity(world, "e4");
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+    ecs_entity_t e4 = ecs_entity(world, { .name = "e4" });
     ecs_add_pair(world, e1, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e2, LocatedIn, SanFrancisco);
     ecs_add_pair(world, e3, LocatedIn, LosAngeles);
     ecs_add_pair(world, e4, LocatedIn, Amsterdam);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, $x), Country($x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Country, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Country, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 1));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Country, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Country, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Country, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Country, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(e1, it.entities[0]);
         test_uint(e2, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Country, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Country, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 1));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Country, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Country, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 1));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Country, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Country, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Country, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Country, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Country, ecs_field_id(&it, 2));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Country, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 1));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_src_tgt_same_var(void) {
+void Transitive_1_src_tgt_same_var(void) {
     ecs_log_set_level(-4);
 
-    ecs_world_t *world = ecs_init();
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($x, $x)"
     });
 
@@ -3897,549 +3952,549 @@ void RulesTransitive_1_src_tgt_same_var(void) {
     ecs_fini(world);
 }
 
-void RulesTransitive_1_src_tgt_same_var_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_src_tgt_same_var_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ecs_add_id(world, LocatedIn, EcsReflexive);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($x, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 1));
-        test_uint(Amsterdam, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 0));
+        test_uint(Amsterdam, ecs_field_src(&it, 0));
         test_uint(Amsterdam, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(NoordHolland, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(NoordHolland, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 1));
-        test_uint(Seattle, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 0));
+        test_uint(Seattle, ecs_field_src(&it, 0));
         test_uint(Seattle, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(SanFrancisco, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(SanFrancisco, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(LosAngeles, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(LosAngeles, ecs_field_src(&it, 0));
         test_uint(LosAngeles, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(California, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(California, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(Washington, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(Washington, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(UnitedStates, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(UnitedStates, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Netherlands, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Netherlands, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_src_tgt_same_this_var_reflexive(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_src_tgt_same_this_var_reflexive(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
     ecs_add_id(world, LocatedIn, EcsReflexive);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, $this)"
     });
 
     test_assert(r != NULL);
 
-    int this_var = ecs_rule_find_var(r, "This");
+    int this_var = ecs_query_find_var(r, "this");
     test_assert(this_var != -1);
     test_assert(this_var != 0);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Amsterdam), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Amsterdam, ecs_iter_get_var(&it, this_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, this_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Seattle), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Seattle, ecs_iter_get_var(&it, this_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, this_var));
         test_uint(SanFrancisco, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, LosAngeles), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(LosAngeles, ecs_iter_get_var(&it, this_var));
         test_uint(LosAngeles, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, this_var));
         test_uint(California, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, this_var));
         test_uint(Washington, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, this_var));
         test_uint(UnitedStates, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, this_var));
         test_uint(Netherlands, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_1_any_src_tgt_var(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_1_any_src_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn(_, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(EcsWildcard, ecs_field_src(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(EcsWildcard, ecs_field_src(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_not_transitive_ent_tgt(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_not_transitive_ent_tgt(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "!LocatedIn($this, UnitedStates), Location($this)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(UnitedStates, it.entities[0]);
         test_uint(Netherlands, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_not_transitive_var_tgt(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_not_transitive_var_tgt(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "!LocatedIn($this, $x), Location($this)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_not_transitive_ent_tgt_written(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_not_transitive_ent_tgt_written(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Location($this), !LocatedIn($this, UnitedStates)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(UnitedStates, it.entities[0]);
         test_uint(Netherlands, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_not_transitive_var_tgt_written(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_not_transitive_var_tgt_written(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Location($this), !LocatedIn($this, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_optional_transitive_ent_tgt(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_optional_transitive_ent_tgt(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "?LocatedIn($this, UnitedStates), Location($this)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(UnitedStates, it.entities[0]);
         test_uint(Netherlands, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Location, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Location, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_optional_transitive_var_tgt(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_optional_transitive_var_tgt(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "?LocatedIn($this, $x), Tag($this)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
 
     ecs_add_pair(world, e2, LocatedIn, Earth);
     ecs_add_pair(world, e3, LocatedIn, SanFrancisco);
@@ -4447,267 +4502,267 @@ void RulesTransitive_optional_transitive_var_tgt(void) {
     ecs_add_pair(world, e4, LocatedIn, NoordHolland);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
 
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(false, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
+        test_bool(false, ecs_field_is_set(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 1));
         test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
         test_uint(e1, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(e2, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(Tag, ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(Tag, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_optional_transitive_ent_tgt_written(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_optional_transitive_ent_tgt_written(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Location($this), ?LocatedIn($this, UnitedStates)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(Earth, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(UnitedStates, it.entities[0]);
         test_uint(Netherlands, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Location, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Location, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_optional_transitive_var_tgt_written(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_optional_transitive_var_tgt_written(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "Tag($this), ?LocatedIn($this, $x)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_entity_t e1 = ecs_new(world, Tag);
-    ecs_entity_t e2 = ecs_new(world, Tag);
-    ecs_entity_t e3 = ecs_new(world, Tag);
-    ecs_entity_t e4 = ecs_new(world, Tag);
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+    ecs_entity_t e4 = ecs_new_w(world, Tag);
 
     ecs_add_pair(world, e2, LocatedIn, Earth);
     ecs_add_pair(world, e3, LocatedIn, SanFrancisco);
@@ -4715,168 +4770,168 @@ void RulesTransitive_optional_transitive_var_tgt_written(void) {
     ecs_add_pair(world, e4, LocatedIn, NoordHolland);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
-        test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(false, ecs_field_is_set(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
         test_uint(EcsWildcard, ecs_iter_get_var(&it, x_var));
         test_uint(e1, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(e2, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(SanFrancisco, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(e3, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(Tag, ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
         test_uint(0, ecs_field_src(&it, 1));
-        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(e4, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_2_var_src_w_same_tgt_ent(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_2_var_src_w_same_tgt_ent(void) {
+    ecs_world_t *world = ecs_mini();
 
     ECS_TAG(world, Tag);
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($x, California), LocatedIn($y, California), Tag($x), Tag($y)"
     });
 
     test_assert(r != NULL);
     
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
-    int y_var = ecs_rule_find_var(r, "y");
+    int y_var = ecs_query_find_var(r, "y");
     test_assert(y_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(false, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
     }
 
     ecs_entity_t e1 = ecs_new_w_pair(world, LocatedIn, SanFrancisco);
@@ -4890,212 +4945,384 @@ void RulesTransitive_2_var_src_w_same_tgt_ent(void) {
     ecs_add(world, e4, Tag);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
         test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 2));
         test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(Tag, ecs_field_id(&it, 4));
+        test_uint(e2, ecs_field_src(&it, 0));
         test_uint(e2, ecs_field_src(&it, 1));
         test_uint(e2, ecs_field_src(&it, 2));
         test_uint(e2, ecs_field_src(&it, 3));
-        test_uint(e2, ecs_field_src(&it, 4));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(e2, ecs_iter_get_var(&it, x_var));
         test_uint(e2, ecs_iter_get_var(&it, y_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
         test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(Tag, ecs_field_id(&it, 4));
-        test_uint(e2, ecs_field_src(&it, 1));
-        test_uint(e1, ecs_field_src(&it, 2));
-        test_uint(e2, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_field_src(&it, 4));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_field_src(&it, 3));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(e2, ecs_iter_get_var(&it, x_var));
         test_uint(e1, ecs_iter_get_var(&it, y_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 2));
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 2));
         test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(Tag, ecs_field_id(&it, 4));
-        test_uint(e1, ecs_field_src(&it, 1));
-        test_uint(e2, ecs_field_src(&it, 2));
-        test_uint(e1, ecs_field_src(&it, 3));
-        test_uint(e2, ecs_field_src(&it, 4));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 2));
+        test_uint(e2, ecs_field_src(&it, 3));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(e1, ecs_iter_get_var(&it, x_var));
         test_uint(e2, ecs_iter_get_var(&it, y_var));
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(0, it.count);
+        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 0));
         test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 1));
-        test_uint(ecs_pair(LocatedIn, SanFrancisco), ecs_field_id(&it, 2));
+        test_uint(Tag, ecs_field_id(&it, 2));
         test_uint(Tag, ecs_field_id(&it, 3));
-        test_uint(Tag, ecs_field_id(&it, 4));
+        test_uint(e1, ecs_field_src(&it, 0));
         test_uint(e1, ecs_field_src(&it, 1));
         test_uint(e1, ecs_field_src(&it, 2));
         test_uint(e1, ecs_field_src(&it, 3));
-        test_uint(e1, ecs_field_src(&it, 4));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_bool(true, ecs_field_is_set(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 2));
         test_uint(e1, ecs_iter_get_var(&it, x_var));
         test_uint(e1, ecs_iter_get_var(&it, y_var));
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_self_target(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_self_target(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
-        .expr = "LocatedIn($this, $x:self)"
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "LocatedIn($this, $x|self)"
     });
 
     test_assert(r != NULL);
 
-    int x_var = ecs_rule_find_var(r, "x");
+    int x_var = ecs_query_find_var(r, "x");
     test_assert(x_var != -1);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Earth), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(Earth, ecs_iter_get_var(&it, x_var));
         test_uint(UnitedStates, it.entities[0]);
         test_uint(Netherlands, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, UnitedStates), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(UnitedStates, ecs_iter_get_var(&it, x_var));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, California), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(California, ecs_iter_get_var(&it, x_var));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Washington), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(Washington, ecs_iter_get_var(&it, x_var));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, Netherlands), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(Netherlands, ecs_iter_get_var(&it, x_var));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, NoordHolland), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(NoordHolland, ecs_iter_get_var(&it, x_var));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
 
     ecs_fini(world);
 }
 
-void RulesTransitive_any_target(void) {
-    ecs_world_t *world = ecs_init();
+void Transitive_any_target(void) {
+    ecs_world_t *world = ecs_mini();
 
     populate_facts(world);
 
-    ecs_rule_t *r = ecs_rule(world, {
+    ecs_query_t *r = ecs_query(world, {
         .expr = "LocatedIn($this, _)"
     });
 
     test_assert(r != NULL);
 
     {
-        ecs_iter_t it = ecs_rule_iter(world, r);
-        test_bool(true, ecs_rule_next(&it));
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(UnitedStates, it.entities[0]);
         test_uint(Netherlands, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(California, it.entities[0]);
         test_uint(Washington, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(2, it.count);
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(SanFrancisco, it.entities[0]);
         test_uint(LosAngeles, it.entities[1]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(Seattle, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(NoordHolland, it.entities[0]);
 
-        test_bool(true, ecs_rule_next(&it));
+        test_bool(true, ecs_query_next(&it));
         test_uint(1, it.count);
-        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 1));
-        test_uint(0, ecs_field_src(&it, 1));
-        test_bool(true, ecs_field_is_set(&it, 1));
+        test_uint(ecs_pair(LocatedIn, EcsWildcard), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
         test_uint(Amsterdam, it.entities[0]);
 
-        test_bool(false, ecs_rule_next(&it));
+        test_bool(false, ecs_query_next(&it));
     }
 
-    ecs_rule_fini(r);
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Transitive_isa_prefab(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t prefab = ecs_new_w_id(world, EcsPrefab);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, prefab);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms =  {{ ecs_pair(EcsIsA, prefab) }}
+    });
+    
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Transitive_isa_disabled(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t prefab = ecs_new_w_id(world, EcsDisabled);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, prefab);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms =  {{ ecs_pair(EcsIsA, prefab) }}
+    });
+    
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Transitive_isa_prefab_match_prefab_flag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t prefab = ecs_new_w_id(world, EcsPrefab);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, prefab);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms =  {{ ecs_pair(EcsIsA, prefab) }},
+        .flags = EcsQueryMatchPrefab
+    });
+    
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(prefab, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Transitive_isa_prefab_match_prefab_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t prefab = ecs_new_w_id(world, EcsPrefab);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, prefab);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms =  {
+            { ecs_pair(EcsIsA, prefab) },
+            { EcsPrefab, .oper = EcsOptional }
+        }
+    });
+    
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(prefab, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Transitive_isa_disabled_match_disabled_flag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t prefab = ecs_new_w_id(world, EcsDisabled);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, prefab);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms =  {{ ecs_pair(EcsIsA, prefab) }},
+        .flags = EcsQueryMatchDisabled
+    });
+    
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(prefab, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Transitive_isa_disabled_match_disabled_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t prefab = ecs_new_w_id(world, EcsDisabled);
+    ecs_entity_t inst = ecs_new_w_pair(world, EcsIsA, prefab);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms =  {
+            { ecs_pair(EcsIsA, prefab) },
+            { EcsDisabled, .oper = EcsOptional }
+        }
+    });
+    
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(prefab, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(ecs_pair(EcsIsA, prefab), ecs_field_id(&it, 0));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
 
     ecs_fini(world);
 }
diff --git a/test/query/src/Traversal.c b/test/query/src/Traversal.c
new file mode 100644
index 000000000..dad4be494
--- /dev/null
+++ b/test/query/src/Traversal.c
@@ -0,0 +1,8195 @@
+#include <query.h>
+
+static ecs_query_cache_kind_t cache_kind = EcsQueryCacheDefault;
+
+void Traversal_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = EcsQueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+void Traversal_this_self_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_self_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($x|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($x|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_written_self_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x|self), Foo($x|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(p1, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(p2, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(p3, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e1, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e2, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e3, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e4, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e5, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e6, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e7, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_written_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x|self), Foo($x|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e1, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e2, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e3, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e4, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e5, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e6, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e7, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_set_var_self_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity(world, { .parent = p3 });
+
+    ecs_entity_t e8 = ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($x|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, p2);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(p2, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(p2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(p1, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e3);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(p2, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e5);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(p1, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e8);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_set_var_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity(world, { .parent = p3 });
+
+    ecs_entity_t e8 = ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($x|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, p2);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(p1, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e3);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(p2, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e5);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(p1, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e8);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_set_var_written_self_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity(world, { .parent = p3 });
+
+    ecs_entity_t e8 = ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x|self), Foo($x|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, p2);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(p2, ecs_field_src(&it, 0));
+        test_uint(p2, ecs_field_src(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(p2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(p1, ecs_field_src(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e3);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(p2, ecs_field_src(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e5);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_field_src(&it, 0));
+        test_uint(p1, ecs_field_src(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e8);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_set_var_written_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x|self), Foo($x|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity(world, { .parent = p3 });
+
+    ecs_entity_t e8 = ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, p2);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(p1, ecs_field_src(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e3);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(p2, ecs_field_src(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e5);
+
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e5, ecs_field_src(&it, 0));
+        test_uint(p1, ecs_field_src(&it, 1));
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 1));
+        test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        ecs_iter_set_var(&it, x_var, e8);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_ent_self_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(ent|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e, Foo);
+    ecs_add_pair(world, e, EcsChildOf, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, parent, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(parent, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_ent_up_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(ent|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e, EcsChildOf, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, parent, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(parent, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_implicit_this_self_up_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p2)) });
+    ecs_entity_t e4 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p2)) });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e2)) });
+    ecs_entity_t e6 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e2)) });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p3)) });
+
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(p0)) });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_implicit_this_up_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p2)) });
+    ecs_entity_t e4 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p2)) });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e2)) });
+    ecs_entity_t e6 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e2)) });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p3)) });
+
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(p0)) });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_implicit_var_self_up_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p2)) });
+    ecs_entity_t e4 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p2)) });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e2)) });
+    ecs_entity_t e6 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e2)) });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p3)) });
+
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(p0)) });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(p1, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(p2, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(p3, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_implicit_var_up_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($x|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p2)) });
+    ecs_entity_t e4 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p2)) });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e2)) });
+    ecs_entity_t e6 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e2)) });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p3)) });
+
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(p0)) });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_implicit_ent_self_up_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(ent|self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(e, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_remove(world, e, Foo);
+    ecs_add_pair(world, e, EcsIsA, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, parent, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(parent, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_implicit_ent_up_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(ent|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e, EcsIsA, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, parent, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(parent, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_self_up_2_targets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t parent_a = ecs_new(world);
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, e_1, EcsIsA, parent_b);
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_4 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_add_pair(world, e_4, EcsIsA, parent_c);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(parent_b, it.entities[0]);
+    test_uint(parent_c, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(parent_b, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(parent_b, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_4, it.entities[0]);
+    test_uint(parent_b, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_up_2_targets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t parent_a = ecs_new(world);
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, e_1, EcsIsA, parent_b);
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_4 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_add_pair(world, e_4, EcsIsA, parent_c);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(parent_b, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(parent_b, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_4, it.entities[0]);
+    test_uint(parent_b, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_self_up_2_targets_diamond(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent_root = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent_a = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
+
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity_t e_3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_c)) });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_root, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(parent_b, it.entities[1]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_c, it.entities[0]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_3, it.entities[0]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_up_2_targets_diamond(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent_root = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent_a = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
+
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity_t e_3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_c)) });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(parent_b, it.entities[1]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_c, it.entities[0]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_3, it.entities[0]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_written_self_up_2_targets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+    
+    ecs_set_with(world, Tag);
+    ecs_entity_t parent_a = ecs_new(world);
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, e_1, EcsIsA, parent_b);
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_4 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_add_pair(world, e_4, EcsIsA, parent_c);
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(parent_b, it.entities[0]);
+    test_uint(parent_c, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_written_up_2_targets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+    
+    ecs_set_with(world, Tag);
+    ecs_entity_t parent_a = ecs_new(world);
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, e_1, EcsIsA, parent_b);
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_4 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_add_pair(world, e_4, EcsIsA, parent_c);
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_written_self_up_2_targets_diamond(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t parent_root = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent_a = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
+
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity_t e_3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_c)) });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_root, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(parent_b, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_c, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_written_up_2_targets_diamond(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t parent_root = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent_a = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
+
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity_t e_3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_c)) });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(parent_b, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_c, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_root, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_2_self_up_terms(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t parent_a = ecs_new(world);
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity_t e_3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e_2)) });
+    ecs_set_with(world, 0);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag, Foo(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_b, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_2_self_up_terms_2_targets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t parent_a = ecs_new(world);
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, e_1, EcsIsA, parent_b);
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_4 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_add_pair(world, e_4, EcsIsA, parent_c);
+    ecs_set_with(world, 0);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag, Foo(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(parent_b, it.entities[0]);
+    test_uint(parent_c, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(parent_b, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_self_up_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+    
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e1)) });
+    ecs_delete(world, e2);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_up_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+    
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(e1)) });
+    ecs_delete(world, e2);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_self_up_all_owned(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t parent_root = ecs_entity(world, {0});
+    ecs_entity_t parent_a = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
+
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity_t e_3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_c)) });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_root, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(parent_b, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_c, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_up_all_owned(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t parent_root = ecs_entity(world, {0});
+    ecs_entity_t parent_a = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_b = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_root)) });
+    ecs_entity_t parent_c = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_add_pair(world, parent_c, EcsIsA, parent_b);
+
+    ecs_entity_t e_1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_a)) });
+    ecs_entity_t e_2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_b)) });
+    ecs_entity_t e_3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(parent_c)) });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(parent_b, it.entities[1]);
+    test_uint(parent_root, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_1, it.entities[0]);
+    test_uint(parent_a, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_c, it.entities[0]);
+    test_uint(parent_a, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_2, it.entities[0]);
+    test_uint(parent_b, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e_3, it.entities[0]);
+    test_uint(parent_c, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(base, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(base, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(base, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    ecs_set_with(world, 0);
+    
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(base, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(base, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    ecs_set_with(world, 0);
+    
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(child, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(base, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_self_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($x|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(base, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(base, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(base, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(child, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo($x|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(base, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(child, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_written_self_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x|self), Foo($x|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    ecs_set_with(world, 0);
+    
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(base, ecs_field_src(&it, 0));
+    test_uint(base, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(base, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(child, ecs_field_src(&it, 0));
+    test_uint(base, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(child, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_written_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x|self), Foo($x|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    ecs_set_with(world, 0);
+    
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(child, ecs_field_src(&it, 0));
+    test_uint(base, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+    test_uint(child, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_ent_self_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    ecs_set_name(world, parent, "parent");
+    ecs_set_name(world, child, "child");
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(parent.child|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+    
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(base, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, child, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(child, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_ent_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    ecs_set_name(world, parent, "parent");
+    ecs_set_name(world, child, "child");
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(parent.child|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+    
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(base, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, child, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(base, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_ent_written_self_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    ecs_set_name(world, parent, "parent");
+    ecs_set_name(world, child, "child");
+    ecs_set_with(world, 0);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(parent.child|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+    
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(base, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, child, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(child, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_ent_written_up_childof_inherited(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tag);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t base = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_entity_t parent = ecs_entity(world, { .add = ecs_ids(ecs_isa(base)) });
+    ecs_entity_t child = ecs_entity(world, { .parent = parent });
+    ecs_set_name(world, parent, "parent");
+    ecs_set_name(world, child, "child");
+    ecs_set_with(world, 0);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(parent.child|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+    
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(base, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, child, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(true, ecs_query_next(&it));
+        test_int(0, it.count);
+        test_uint(base, ecs_field_src(&it, 0));
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t p2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t p3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+        test_int(p[1].x, 20);
+        test_int(p[1].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_up_childof_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t p2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t p3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Position(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_insert(world, {Tag}, ecs_value(Position, {10, 20}));
+    ecs_entity_t p2 = ecs_insert(world, {Tag}, ecs_value(Position, {20, 30}));
+    ecs_entity_t p3 = ecs_insert(world, {Tag}, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+        test_int(p[1].x, 20);
+        test_int(p[1].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_up_childof_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Position(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_insert(world, {Tag}, ecs_value(Position, {10, 20}));
+    ecs_entity_t p2 = ecs_insert(world, {Tag}, ecs_value(Position, {20, 30}));
+    ecs_entity_t p3 = ecs_insert(world, {Tag}, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_self_up_childof_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($x|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t p2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t p3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(p3, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_up_childof_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position($x|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t p2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_entity_t p3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_written_self_up_childof_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x|self), Position($x|self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_insert(world, {Tag}, ecs_value(Position, {10, 20}));
+    ecs_entity_t p2 = ecs_insert(world, {Tag}, ecs_value(Position, {20, 30}));
+    ecs_entity_t p3 = ecs_insert(world, {Tag}, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(p1, ecs_iter_get_var(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(p2, ecs_iter_get_var(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(p3, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e1, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e2, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e3, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e4, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e5, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e6, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e7, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_var_written_up_childof_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag($x|self), Position($x|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_insert(world, {Tag}, ecs_value(Position, {10, 20}));
+    ecs_entity_t p2 = ecs_insert(world, {Tag}, ecs_value(Position, {20, 30}));
+    ecs_entity_t p3 = ecs_insert(world, {Tag}, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e1, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e1, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e2, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e2, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e3, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e3, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e4, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e4, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e5, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e5, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e6, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e6, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_uint(e7, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(e7, ecs_iter_get_var(&it, x_var));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_recycled_parent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    test_assert((uint32_t)p0 != p0);
+    test_assert((uint32_t)p1 != p1);
+    test_assert((uint32_t)p2 != p2);
+    test_assert((uint32_t)p3 != p3);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_up_childof_recycled_parent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    test_assert((uint32_t)p0 != p0);
+    test_assert((uint32_t)p1 != p1);
+    test_assert((uint32_t)p2 != p2);
+    test_assert((uint32_t)p3 != p3);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_recycled_parent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    test_assert((uint32_t)p0 != p0);
+    test_assert((uint32_t)p1 != p1);
+    test_assert((uint32_t)p2 != p2);
+    test_assert((uint32_t)p3 != p3);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_up_childof_recycled_parent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Foo(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids(Foo) });
+    ecs_add(world, p3, Bar);
+
+    test_assert((uint32_t)p0 != p0);
+    test_assert((uint32_t)p1 != p1);
+    test_assert((uint32_t)p2 != p2);
+    test_assert((uint32_t)p3 != p3);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(Foo, ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_recycled_parent_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    test_assert((uint32_t)p0 != p0);
+    test_assert((uint32_t)p1 != p1);
+    test_assert((uint32_t)p2 != p2);
+    test_assert((uint32_t)p3 != p3);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+        test_int(p[1].x, 20);
+        test_int(p[1].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_up_childof_recycled_parent_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    test_assert((uint32_t)p0 != p0);
+    test_assert((uint32_t)p1 != p1);
+    test_assert((uint32_t)p2 != p2);
+    test_assert((uint32_t)p3 != p3);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_recycled_parent_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Position(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p1 = ecs_insert(world, {Tag}, ecs_value(Position, {10, 20}));
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p2 = ecs_insert(world, {Tag}, ecs_value(Position, {20, 30}));
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p3 = ecs_insert(world, {Tag}, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    test_assert((uint32_t)p0 != p0);
+    test_assert((uint32_t)p1 != p1);
+    test_assert((uint32_t)p2 != p2);
+    test_assert((uint32_t)p3 != p3);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+        test_int(p[1].x, 20);
+        test_int(p[1].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_up_childof_recycled_parent_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Position(up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p1 = ecs_insert(world, {Tag}, ecs_value(Position, {10, 20}));
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p2 = ecs_insert(world, {Tag}, ecs_value(Position, {20, 30}));
+    ecs_delete(world, ecs_new(world));
+    ecs_entity_t p3 = ecs_insert(world, {Tag}, ecs_value(Position, {30, 40}));
+    ecs_add(world, p3, Bar);
+
+    test_assert((uint32_t)p0 != p0);
+    test_assert((uint32_t)p1 != p1);
+    test_assert((uint32_t)p2 != p2);
+    test_assert((uint32_t)p3 != p3);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 10);
+        test_int(p[0].y, 20);
+    }
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p[0].x, 30);
+        test_int(p[0].y, 40);
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(self|up, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_up_childof_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(up, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Rel(self|up, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(2, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(p2, it.entities[1]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_up_childof_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Rel(up, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, Tgt) ) });
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, Tgt), ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_pair_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtA) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtB) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtC) ) });
+    ecs_add_pair(world, p3, EcsChildOf, p2);
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(self|up, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_up_childof_pair_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtA) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtB) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtC) ) });
+    ecs_add_pair(world, p3, EcsChildOf, p2);
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(up, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_pair_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Rel(self|up, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtA) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtB) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtC) ) });
+    ecs_add(world, p3, Bar);
+    ecs_add_pair(world, p3, EcsChildOf, p2);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_up_childof_pair_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Rel(up, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtA) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtB) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtC) ) });
+    ecs_add(world, p3, Bar);
+    ecs_add_pair(world, p3, EcsChildOf, p2);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(self|up, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtA) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtB) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtC) ) });
+    ecs_add_pair(world, p3, EcsChildOf, p2);
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 0));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 0));
+    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+    test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 0));
+    test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), Rel(self|up, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtA) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtB) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TgtC) ) });
+    ecs_add(world, p3, Bar);
+    ecs_add_pair(world, p3, EcsChildOf, p2);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
+    test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtB), ecs_field_id(&it, 1));
+    test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtA), ecs_field_id(&it, 1));
+    test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, TgtC), ecs_field_id(&it, 1));
+    test_uint(TgtC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "$x(self|up, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(RelA, Tgt) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(RelB, Tgt) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(RelC, Tgt) ) });
+    ecs_add_pair(world, p3, EcsChildOf, p2);
+    ecs_add(world, p3, Bar);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(p1, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(p2, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(p3, ecs_field_src(&it, 0));
+    test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 0));
+    test_uint(RelC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, Tgt);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Tag(self), $x(self|up, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_set_with(world, Tag);
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_entity(world, { .add = ecs_ids( ecs_pair(RelA, Tgt) ) });
+    ecs_entity_t p2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(RelB, Tgt) ) });
+    ecs_entity_t p3 = ecs_entity(world, { .add = ecs_ids( ecs_pair(RelC, Tgt) ) });
+    ecs_add(world, p3, Bar);
+    ecs_add_pair(world, p3, EcsChildOf, p2);
+
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p1 });
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p2 });
+    ecs_entity_t e4 = ecs_entity(world, { .parent = p2 });
+    ecs_add(world, e4, Bar);
+
+    ecs_entity_t e5 = ecs_entity(world, { .parent = e2 });
+    ecs_entity_t e6 = ecs_entity(world, { .parent = e2 });
+    ecs_add(world, e6, Bar);
+
+    ecs_entity_t e7 = ecs_entity(world, { .parent = p3 });
+
+    ecs_entity(world, { .parent = p0 });
+    ecs_set_with(world, 0);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelB, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e5, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e6, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelA, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e7, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(Tag, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(RelC, Tgt), ecs_field_id(&it, 1));
+    test_uint(RelC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_pair_for_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ECS_ENTITY(world, ent, (Rel, TagA), (Rel, TagB), (Rel, TagC));
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(ent, $x), $x(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p1 = ecs_new_w(world, TagA);
+    ecs_entity_t p2 = ecs_new_w(world, TagB);
+    ecs_entity_t p3 = ecs_new_w(world, TagC);
+
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_add_pair(world, e1, EcsIsA, p2);
+    ecs_add_pair(world, e1, EcsIsA, p3);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p2, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 0));
+    test_uint(TagB, ecs_field_id(&it, 1));
+    test_uint(TagB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 0));
+    test_uint(TagB, ecs_field_id(&it, 1));
+    test_uint(TagB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p3, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 0));
+    test_uint(TagC, ecs_field_id(&it, 1));
+    test_uint(TagC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 0));
+    test_uint(TagC, ecs_field_id(&it, 1));
+    test_uint(TagC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_up_childof_pair_for_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ECS_ENTITY(world, ent, (Rel, TagA), (Rel, TagB), (Rel, TagC));
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(ent, $x), $x(up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p1 = ecs_new_w(world, TagA);
+    ecs_entity_t p2 = ecs_new_w(world, TagB);
+    ecs_entity_t p3 = ecs_new_w(world, TagC);
+
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_add_pair(world, e1, EcsIsA, p2);
+    ecs_add_pair(world, e1, EcsIsA, p3);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 0));
+    test_uint(TagB, ecs_field_id(&it, 1));
+    test_uint(TagB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 0));
+    test_uint(TagC, ecs_field_id(&it, 1));
+    test_uint(TagC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_pair_for_var_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(self, $x), $x(self|up)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_new_w(world, TagA);
+    ecs_entity_t p2 = ecs_new_w(world, TagB);
+    ecs_entity_t p3 = ecs_new_w(world, TagC);
+
+    ecs_entity_t e0 = ecs_entity(world, { .parent = p0 });
+    ecs_add_pair(world, e0, Rel, TagA);
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p1 });
+    ecs_add_pair(world, e1, Rel, TagA);
+    ecs_entity_t e2 = ecs_entity(world, { .parent = p2 });
+    ecs_add_pair(world, e2, Rel, TagB);
+    ecs_entity_t e3 = ecs_entity(world, { .parent = p3 });
+    ecs_add_pair(world, e3, Rel, TagC);
+
+    ecs_entity_t e4 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TagA) ) });
+    ecs_add(world, e4, TagA);
+    ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TagB) ) });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 0));
+    test_uint(TagB, ecs_field_id(&it, 1));
+    test_uint(TagB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 0));
+    test_uint(TagC, ecs_field_id(&it, 1));
+    test_uint(TagC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_self_up_childof_pair_for_var_written_n_targets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ECS_ENTITY(world, ent, (Rel, TagA), (Rel, TagB), (Rel, TagC));
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(ent, $x), $x(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p0_a = ecs_new_w(world, TagA);
+    ecs_entity_t p0_b = ecs_new_w(world, TagB);
+    ecs_add(world, p0_b, Foo);
+    ecs_entity_t p0_c = ecs_new_w(world, TagC);
+    ecs_add(world, p0_c, Foo);
+    ecs_add(world, p0_c, Bar);
+    ecs_entity_t p1 = ecs_new(world);
+    ecs_add_pair(world, p1, EcsIsA, p0_a);
+    ecs_add_pair(world, p1, EcsIsA, p0_b);
+    ecs_add_pair(world, p1, EcsIsA, p0_c);
+
+    ecs_entity(world, { .add = ecs_ids(ecs_isa(p0)) });
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TagA) ) });
+    ecs_add(world, e2, TagA);
+    ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TagB) ) });
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p0_a, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p0_a, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p0_a, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p0_b, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 0));
+    test_uint(TagB, ecs_field_id(&it, 1));
+    test_uint(TagB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p0_b, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 0));
+    test_uint(TagB, ecs_field_id(&it, 1));
+    test_uint(TagB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p0_b, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 0));
+    test_uint(TagB, ecs_field_id(&it, 1));
+    test_uint(TagB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p0_c, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 0));
+    test_uint(TagC, ecs_field_id(&it, 1));
+    test_uint(TagC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(p1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p0_c, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 0));
+    test_uint(TagC, ecs_field_id(&it, 1));
+    test_uint(TagC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(ent, ecs_field_src(&it, 0));
+    test_uint(p0_c, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 0));
+    test_uint(TagC, ecs_field_id(&it, 1));
+    test_uint(TagC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_self_up_childof_pair_for_var_written_n_targets(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Rel(self, $x), $x(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    ecs_entity_t p0 = ecs_entity(world, {0});
+    ecs_entity_t p1 = ecs_new_w(world, TagA);
+    ecs_entity_t p2 = ecs_new_w(world, TagB);
+    ecs_entity_t p3 = ecs_new_w(world, TagC);
+
+    ecs_entity_t e0 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p0)) });
+    ecs_add_pair(world, e0, Rel, TagA);
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_add_pair(world, e1, EcsIsA, p2);
+    ecs_add_pair(world, e1, EcsIsA, p3);
+    ecs_add_pair(world, e1, Rel, TagA);
+    ecs_entity_t e2 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_add_pair(world, e2, EcsIsA, p2);
+    ecs_add_pair(world, e2, EcsIsA, p3);
+    ecs_add_pair(world, e2, Rel, TagB);
+    ecs_entity_t e3 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p1)) });
+    ecs_add_pair(world, e3, EcsIsA, p2);
+    ecs_add_pair(world, e3, EcsIsA, p3);
+    ecs_add_pair(world, e3, Rel, TagC);
+
+    ecs_entity_t e4 = ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TagA) ) });
+    ecs_add(world, e4, TagA);
+    ecs_entity(world, { .add = ecs_ids( ecs_pair(Rel, TagB) ) });
+
+    int x_var = ecs_query_find_var(r, "x");
+    test_assert(x_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, r);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p1, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p2, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagB), ecs_field_id(&it, 0));
+    test_uint(TagB, ecs_field_id(&it, 1));
+    test_uint(TagB, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e3, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p3, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagC), ecs_field_id(&it, 0));
+    test_uint(TagC, ecs_field_id(&it, 1));
+    test_uint(TagC, ecs_iter_get_var(&it, x_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e4, it.entities[0]);
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(0, ecs_field_src(&it, 1));
+    test_uint(ecs_pair(Rel, TagA), ecs_field_id(&it, 0));
+    test_uint(TagA, ecs_field_id(&it, 1));
+    test_uint(TagA, ecs_iter_get_var(&it, x_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_self_up_2_levels(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t base = ecs_new_w_id(world, EcsPrefab);
+    ecs_set(world, base, Position, {10, 20});
+
+    ecs_entity_t base_2 = ecs_new_w_id(world, EcsPrefab);
+    ecs_add_pair(world, base_2, EcsIsA, base);
+
+    ecs_entity_t inst = ecs_entity(world, { .add = ecs_ids(ecs_isa(base_2)) });
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms[0] = { .id = ecs_id(Position) }
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(inst, it.entities[0]);
+    test_uint(base, it.sources[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    Position *p = ecs_field(&it, Position, 0);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Traversal_not_up_disabled(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {
+            { TagA },
+            { .id = EcsDisabled, .src.id = EcsUp, .oper = EcsNot }
+        }
+    });
+    test_assert(f != NULL);
+
+    ecs_entity_t parent = ecs_new_w_id(world, EcsDisabled);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e2, EcsDisabled);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, EcsChildOf, parent);
+    
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, it.ids[0]);
+    test_uint(0, it.sources[0]);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+    
+    ecs_fini(world);
+}
+
+void Traversal_up_2_rel_instances(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, Rel);
+
+    ecs_add_id(world, Rel, EcsTraversable);
+
+    ecs_entity_t b1 = ecs_new_w(world, TagA);
+    ecs_entity_t b2 = ecs_new_w(world, TagA);
+    ecs_add(world, b1, TagB);
+    ecs_add(world, b2, TagB);
+    ecs_add(world, b1, TagC);
+    ecs_add(world, b2, TagC);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add_pair(world, e, Rel, b1);
+    ecs_add_pair(world, e, Rel, b2);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {
+            {TagC, .src.id = EcsUp, .trav = Rel }
+        }
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e);
+    test_uint(it.sources[0], b1);
+    test_uint(it.ids[0], TagC);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Traversal_up_2_rel_instances_match_2nd(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, Rel);
+
+    ecs_add_id(world, Rel, EcsTraversable);
+
+    ecs_entity_t b1 = ecs_new_w(world, TagA);
+    ecs_entity_t b2 = ecs_new_w(world, TagA);
+    ecs_add(world, b1, TagB);
+    ecs_add(world, b2, TagB);
+    ecs_add(world, b2, TagC);
+
+    ecs_entity_t e = ecs_new(world);
+    ecs_add_pair(world, e, Rel, b1);
+    ecs_add_pair(world, e, Rel, b2);
+
+    ecs_query_t *f = ecs_query(world, {
+        .terms = {
+            { TagC, .src.id = EcsUp, .trav = Rel }
+        }
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e);
+    test_uint(it.sources[0], b2);
+    test_uint(it.ids[0], TagC);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Traversal_up_only_w_owned(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, R, Traversable);
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e_0 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e_1 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_entity_t e_2 = ecs_insert(world, ecs_value(Position, {50, 60}));
+    ecs_entity_t e_3 = ecs_insert(world, ecs_value(Position, {70, 80}));
+
+    ecs_add_pair(world, e_3, R, e_2);
+    ecs_add_pair(world, e_2, R, e_1);
+    ecs_add_pair(world, e_1, R, e_0);
+
+    ecs_query_t *f = ecs_query(world, {
+        .expr = "Position(up R)",
+        .cache_kind = cache_kind
+    });
+
+    ecs_iter_t it = ecs_query_iter(world, f);
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_1);
+    test_uint(it.sources[0], e_0);
+    Position *p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 10);
+    test_int(p[0].y, 20);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_3);
+    test_uint(it.sources[0], e_2);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 50);
+    test_int(p[0].y, 60);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e_2);
+    test_uint(it.sources[0], e_1);
+    p = ecs_field(&it, Position, 0);
+    test_int(p[0].x, 30);
+    test_int(p[0].y, 40);
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(f);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_up_trav_unused_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_ENTITY(world, Rel, Traversable);
+
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "Foo(up Rel)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(r != NULL);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_entity(world, { .add = ecs_ids(Foo) });
+    
+    {
+        ecs_iter_t it = ecs_query_iter(world, r);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(r);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_optional_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base = ecs_new_w(world, Velocity);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add_pair(world, e1, EcsIsA, base);
+
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, Velocity);
+
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?Velocity(self), Position",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        Velocity *v = ecs_field(&it, Velocity, 0);
+        Position *p = ecs_field(&it, Position, 1);
+        
+        test_int(it.count, 1);
+        test_assert(p != NULL);
+
+        if (it.entities[0] == e1) {
+            test_bool(ecs_field_is_set(&it, 0), false); 
+            test_bool(ecs_field_is_set(&it, 1), true);
+        } else if (it.entities[0] == e2) {
+            test_bool(ecs_field_is_set(&it, 0), true); 
+            test_bool(ecs_field_is_set(&it, 1), true);
+            test_assert(v != NULL);
+        } else if (it.entities[0] == e3) {
+            test_bool(ecs_field_is_set(&it, 0), false);
+            test_bool(ecs_field_is_set(&it, 1), true);
+        }
+
+        count ++;
+    }
+
+    test_int(count, 3);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_optional_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base = ecs_new_w(world, Velocity);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add_pair(world, e1, EcsIsA, base);
+
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, Velocity);
+
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?Velocity(up IsA), Position",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    
+    while (ecs_query_next(&it)) {
+        Velocity *v = ecs_field(&it, Velocity, 0);
+        Position *p = ecs_field(&it, Position, 1);
+        
+        test_int(it.count, 1);
+        test_assert(p != NULL);
+        
+        if (it.entities[0] == e1) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true);
+            test_assert(v != NULL);
+        } else if (it.entities[0] == e2) {
+            test_bool(ecs_field_is_set(&it, 0), false);            
+            test_bool(ecs_field_is_set(&it, 1), true);
+        } else if (it.entities[0] == e3) {
+            test_bool(ecs_field_is_set(&it, 0), false); 
+            test_bool(ecs_field_is_set(&it, 1), true);
+        }
+
+        count ++;
+    }
+
+    test_int(count, 3);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_optional_self_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base = ecs_new_w(world, Velocity);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add_pair(world, e1, EcsIsA, base);
+
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, Velocity);
+
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "?Velocity(self|up IsA), Position",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    
+    while (ecs_query_next(&it)) {
+        Velocity *v = ecs_field(&it, Velocity, 0);
+        Position *p = ecs_field(&it, Position, 1);
+        
+        test_int(it.count, 1);
+        test_assert(p != NULL);
+        
+        if (it.entities[0] == e1) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true);
+            test_assert(v != NULL);
+        } else if (it.entities[0] == e2) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true);            
+            test_assert(v != NULL);
+        } else if (it.entities[0] == e3) {
+            test_bool(ecs_field_is_set(&it, 0), false); 
+            test_bool(ecs_field_is_set(&it, 1), true);
+        }
+
+        count ++;
+    }
+
+    test_int(count, 3);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_optional_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base = ecs_new_w(world, Velocity);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add_pair(world, e1, EcsIsA, base);
+
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, Velocity);
+
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, ?Velocity(self)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+
+    while (ecs_query_next(&it)) {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        
+        test_int(it.count, 1);
+        test_assert(p != NULL);
+
+        if (it.entities[0] == e1) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), false); 
+            test_assert(v == NULL);
+        } else if (it.entities[0] == e2) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true); 
+            test_assert(v != NULL);
+        } else if (it.entities[0] == e3) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), false);
+            test_assert(v == NULL);
+        }
+
+        count ++;
+    }
+
+    test_int(count, 3);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_optional_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base = ecs_new_w(world, Velocity);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add_pair(world, e1, EcsIsA, base);
+
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, Velocity);
+
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, ?Velocity(up IsA)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    
+    while (ecs_query_next(&it)) {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        
+        test_int(it.count, 1);
+        test_assert(p != NULL);
+        
+        if (it.entities[0] == e1) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true);
+            test_assert(v != NULL);
+        } else if (it.entities[0] == e2) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), false);            
+        } else if (it.entities[0] == e3) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), false); 
+        }
+
+        count ++;
+    }
+
+    test_int(count, 3);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_this_written_optional_self_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_entity_t base = ecs_new_w(world, Velocity);
+    
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add_pair(world, e1, EcsIsA, base);
+
+    ecs_entity_t e2 = ecs_new_w(world, Position);
+    ecs_add(world, e2, Velocity);
+
+    ecs_entity_t e3 = ecs_new_w(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position, ?Velocity(self|up IsA)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    int32_t count = 0;
+    
+    while (ecs_query_next(&it)) {
+        Position *p = ecs_field(&it, Position, 0);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        
+        test_int(it.count, 1);
+        test_assert(p != NULL);
+        
+        if (it.entities[0] == e1) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true);
+            test_assert(v != NULL);
+        } else if (it.entities[0] == e2) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), true);            
+            test_assert(v != NULL);
+        } else if (it.entities[0] == e3) {
+            test_bool(ecs_field_is_set(&it, 0), true);
+            test_bool(ecs_field_is_set(&it, 1), false); 
+        }
+
+        count ++;
+    }
+
+    test_int(count, 3);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_fixed_src_w_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+
+    ecs_entity_t Game = ecs_entity(world, { .name = "Game" });
+    ecs_set(world, Game, Position, {10, 20});
+    ecs_set(world, Game, Velocity, {1, 2});
+
+    ecs_entity_t p = ecs_new_w_id(world, EcsPrefab);
+    ecs_set(world, p, Mass, {30});
+    ecs_entity_t e = ecs_entity(world, { .add = ecs_ids(ecs_isa(p)) });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Velocity(Game), Mass(up IsA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Mass), ecs_field_id(&it, 1));
+    test_uint(Game, ecs_field_src(&it, 0));
+    test_uint(p, ecs_field_src(&it, 1));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_match_empty_table_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = cache_kind,
+        .flags =  EcsQueryMatchEmptyTables
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p });
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+
+    ecs_add(world, e1, TagA); // (ChildOf, p) is empty
+    ecs_table_t *t2 = ecs_get_table(world, e1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_assert(it.table == t1);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(p, ecs_field_src(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_assert(it.table == t2);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(p, ecs_field_src(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_match_empty_table_up_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagB, Position(up)",
+        .cache_kind = cache_kind,
+        .flags =  EcsQueryMatchEmptyTables
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p });
+    ecs_add(world, e1, TagB);
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+
+    ecs_add(world, e1, TagA); // TagB, (ChildOf, p) is empty
+    ecs_table_t *t2 = ecs_get_table(world, e1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_assert(it.table == t1);
+    test_uint(TagB, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p, ecs_field_src(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_assert(it.table == t2);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagB, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p, ecs_field_src(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_match_empty_table_up_implicit_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up)",
+        .cache_kind = cache_kind,
+        .flags =  EcsQueryMatchEmptyTables
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t b = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t p = ecs_entity(world, { .add = ecs_ids(ecs_isa(b)) });
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p });
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+
+    ecs_add(world, e1, TagA); // (ChildOf, p) is empty
+    ecs_table_t *t2 = ecs_get_table(world, e1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_assert(it.table == t1);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(b, ecs_field_src(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_assert(it.table == t2);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(b, ecs_field_src(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_match_empty_table_up_written_implicit_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagB, Position(up)",
+        .cache_kind = cache_kind,
+        .flags =  EcsQueryMatchEmptyTables
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t b = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t p = ecs_entity(world, { .add = ecs_ids(ecs_isa(b)) });
+    ecs_entity_t e1 = ecs_entity(world, { .parent = p });
+    ecs_add(world, e1, TagB);
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+
+    ecs_add(world, e1, TagA); // TagB, (ChildOf, p) is empty
+    ecs_table_t *t2 = ecs_get_table(world, e1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_assert(it.table == t1);
+    test_uint(TagB, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(b, ecs_field_src(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_assert(it.table == t2);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagB, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(b, ecs_field_src(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_match_empty_table_up_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(up IsA)",
+        .cache_kind = cache_kind,
+        .flags =  EcsQueryMatchEmptyTables
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p)) });
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+
+    ecs_add(world, e1, TagA); // (ChildOf, p) is empty
+    ecs_table_t *t2 = ecs_get_table(world, e1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_assert(it.table == t1);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(p, ecs_field_src(&it, 0));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_assert(it.table == t2);
+    test_uint(e1, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(p, ecs_field_src(&it, 0));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Traversal_match_empty_table_up_written_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagB, Position(up IsA)",
+        .cache_kind = cache_kind,
+        .flags =  EcsQueryMatchEmptyTables
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e1 = ecs_entity(world, { .add = ecs_ids(ecs_isa(p)) });
+    ecs_add(world, e1, TagB);
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+
+    ecs_add(world, e1, TagA); // TagB, (ChildOf, p) is empty
+    ecs_table_t *t2 = ecs_get_table(world, e1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(0, it.count);
+    test_assert(it.table == t1);
+    test_uint(TagB, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p, ecs_field_src(&it, 1));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_assert(it.table == t2);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagB, ecs_field_id(&it, 0));
+    test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(p, ecs_field_src(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 1);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/Validator.c b/test/query/src/Validator.c
new file mode 100644
index 000000000..94621170b
--- /dev/null
+++ b/test/query/src/Validator.c
@@ -0,0 +1,2343 @@
+#include <query.h>
+
+void Validator_validate_1_term(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{TagA}}
+    });
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].inout, EcsInOutDefault);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, TagA|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Position) }}
+    });
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_id(Position));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].inout, EcsInOutDefault);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, ecs_id(Position)|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_2_terms(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{TagA}, {TagB}}
+    });
+
+    test_int(q->term_count, 2);
+    test_int(q->field_count, 2);
+
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, TagA|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    test_uint(q->terms[1].id, TagB);
+    test_int(q->terms[1].oper, EcsAnd);
+    test_int(q->terms[1].field_index, 1);
+    test_uint(q->terms[1].first.id, TagB|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[1].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[1].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_3_terms(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{TagA}, {TagB}, {TagC}}
+    });
+
+    test_int(q->term_count, 3);
+    test_int(q->field_count, 3);
+
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, TagA|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    test_uint(q->terms[1].id, TagB);
+    test_int(q->terms[1].oper, EcsAnd);
+    test_int(q->terms[1].field_index, 1);
+    test_uint(q->terms[1].first.id, TagB|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[1].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[1].trav, EcsIsA);
+
+    test_int(q->terms[2].id, TagC);
+    test_int(q->terms[2].oper, EcsAnd);
+    test_int(q->terms[2].field_index, 2);
+    test_int(q->terms[2].first.id, TagC|EcsSelf|EcsIsEntity);
+    test_int(q->terms[2].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q->terms[2].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_3_terms_w_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{TagA}, {TagB, .oper = EcsOr}, {TagC }}
+    });
+
+    test_int(q->term_count, 3);
+    test_int(q->field_count, 2);
+
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, TagA|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    test_uint(q->terms[1].id, TagB);
+    test_int(q->terms[1].oper, EcsOr);
+    test_int(q->terms[1].field_index, 1);
+    test_uint(q->terms[1].first.id, TagB|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[1].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[1].trav, EcsIsA);
+
+    test_int(q->terms[2].id, TagC);
+    test_int(q->terms[2].oper, EcsAnd);
+    test_int(q->terms[2].field_index, 1);
+    test_int(q->terms[2].first.id, TagC|EcsSelf|EcsIsEntity);
+    test_int(q->terms[2].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q->terms[2].trav, EcsIsA);
+    
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_4_terms_w_or_at_1(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+    ECS_TAG(world, TagD);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{TagA}, {TagB, .oper = EcsOr}, {TagC}, {TagD}}
+    });
+
+    test_int(q->term_count, 4);
+    test_int(q->field_count, 3);
+
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, TagA|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    test_uint(q->terms[1].id, TagB);
+    test_int(q->terms[1].oper, EcsOr);
+    test_int(q->terms[1].field_index, 1);
+    test_uint(q->terms[1].first.id, TagB|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[1].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[1].trav, EcsIsA);
+
+    test_int(q->terms[2].id, TagC);
+    test_int(q->terms[2].oper, EcsAnd);
+    test_int(q->terms[2].field_index, 1);
+    test_int(q->terms[2].first.id, TagC|EcsSelf|EcsIsEntity);
+    test_int(q->terms[2].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q->terms[2].trav, EcsIsA);
+
+    test_int(q->terms[3].id, TagD);
+    test_int(q->terms[3].oper, EcsAnd);
+    test_int(q->terms[3].field_index, 2);
+    test_int(q->terms[3].first.id, TagD|EcsSelf|EcsIsEntity);
+    test_int(q->terms[3].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q->terms[3].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ EcsWildcard }}
+    });
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, EcsWildcard);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, EcsWildcard|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_uint(q->terms[0].second.id, 0);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ EcsAny }}
+    });
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, EcsAny);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, EcsAny|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_uint(q->terms[0].second.id, 0);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_same_subj_obj(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = Rel, .src.name = "Foo", .second.name = "Foo" }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(Rel, Foo));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Rel|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, Foo|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_uint(q->terms[0].second.id, Foo|EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_acyclic_same_subj_obj(void) {
+    ecs_log_set_level(-4);
+
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Rel, Traversable);
+    ECS_TAG(world, Foo);
+
+    test_assert(NULL == ecs_query(world, {
+        .terms = {{ .first.id = Rel, .src.name = "Foo", .second.name = "Foo" }}
+    }));
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_acyclic_reflexive_same_subj_obj(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Rel, Traversable, Reflexive);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = Rel, .src.name = "Foo", .second.name = "Foo" }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(Rel, Foo));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Rel|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, Foo|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_uint(q->terms[0].second.id, Foo|EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_same_subj_obj_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.id = Rel, 
+            .src = { .name = "X", .id = EcsIsVariable },
+            .second = { .name = "X", .id = EcsIsVariable }
+        }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(Rel, EcsWildcard));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Rel|EcsSelf|EcsIsEntity);
+    test_str(q->terms[0].src.name, "X");
+    test_uint(q->terms[0].src.id, EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_str(q->terms[0].second.name, "X");
+    test_uint(q->terms[0].second.id, EcsSelf|EcsIsVariable);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_acyclic_same_subj_obj_var(void) {
+    ecs_log_set_level(-4);
+
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Rel, Traversable);
+
+    test_assert(NULL == ecs_query(world, {
+        .terms = {{ 
+            .first.id = Rel, 
+            .src = { .name = "X", .id = EcsIsVariable },
+            .second = { .name = "X", .id = EcsIsVariable }
+        }}
+    }));
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_acyclic_reflexive_same_subj_obj_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Rel, Traversable, Reflexive);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.id = Rel, 
+            .src = { .name = "X", .id = EcsIsVariable },
+            .second = { .name = "X", .id = EcsIsVariable }
+        }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(Rel, EcsWildcard));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Rel|EcsSelf|EcsIsEntity);
+    test_str(q->terms[0].src.name, "X");
+    test_uint(q->terms[0].src.id, EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_str(q->terms[0].second.name, "X");
+    test_uint(q->terms[0].second.id, EcsSelf|EcsIsVariable);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_non_acyclic_superset(void) {
+    ecs_log_set_level(-4);
+
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Rel);
+
+    test_assert(NULL == ecs_query(world, {
+        .terms = {{ 
+            .id = Tag, 
+            .src.id = EcsUp,
+            .trav = Rel
+        }}
+    })); /* cyclic superset is invalid  */
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_dont_inherit_default_set(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Tag, DontInherit);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = Tag }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, Tag);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[0].trav, 0);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_dont_inherit_pair_default_set(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Rel, DontInherit);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = ecs_pair(Rel, EcsWildcard) }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(Rel, EcsWildcard));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Rel|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[0].trav, 0);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_cascade_implicit_trav(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .id = Tag, .src.id = EcsCascade }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, Tag);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsUp|EcsCascade|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsChildOf);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_cascade_isa(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .id = Tag, 
+            .trav = EcsIsA, .src.id = EcsCascade
+        }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, Tag);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsUp|EcsCascade|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_cascade_childof(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .id = Tag, 
+            .trav = EcsChildOf, .src.id = EcsCascade
+        }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, Tag);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsUp|EcsCascade|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsChildOf);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_cascade_down(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .id = Tag, 
+            .trav = EcsChildOf, .src.id = EcsCascade
+        }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, Tag);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsUp|EcsCascade|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsChildOf);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_optional_only(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .id = Tag, 
+            .oper = EcsOptional
+        }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, Tag);
+    test_int(q->terms[0].oper, EcsOptional);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_term_transitive_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Rel, Transitive);
+    ECS_TAG(world, Tgt);
+    
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .id = ecs_pair(Rel, Tgt)
+        }}
+    });
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(Rel, Tgt));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Rel|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_uint(q->terms[0].second.id, Tgt|EcsSelf|EcsIsEntity);
+    test_assert(q->terms[0].flags_ & EcsTermTransitive);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_variable_as_pred_only(void) {
+    ecs_log_set_level(-4);
+
+    ecs_world_t *world = ecs_mini();
+
+    test_assert(NULL == ecs_query(world, {
+        .terms = {{ .id = EcsVariable }}
+    }));
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_variable_as_pred_w_subj(void) {
+    ecs_log_set_level(-4);
+
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Src);
+
+    test_assert(NULL == ecs_query(world, {
+        .terms = {{ .id = EcsVariable, .src.id = Src }}
+    }));
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_variable_as_pred_w_pair(void) {
+    ecs_log_set_level(-4);
+
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Src);
+    ECS_TAG(world, Tgt);
+
+    test_assert(NULL == ecs_query(world, {
+        .terms = {{ 
+            .first.id = EcsVariable, 
+            .src.id = Src, 
+            .second.id = Tgt 
+        }}
+    }));
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_variable_as_subj(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.id = Foo, 
+            .src.id = EcsVariable|EcsIsVariable
+        }}
+    });
+    
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, Foo);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, Foo|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_src_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.id = Foo, 
+            .src.id = EcsIsVariable,
+            .src.name = "Var"
+        }}
+    });
+    
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, Foo);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_str(q->terms[0].src.name, "Var");
+    test_uint(q->terms[0].src.id, EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_first_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.id = EcsIsVariable,
+            .first.name = "Var"
+        }}
+    });
+    
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, EcsWildcard);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_str(q->terms[0].first.name, "Var");
+    test_uint(q->terms[0].first.id, EcsSelf|EcsIsVariable);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_second_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.id = Foo,
+            .second.id = EcsIsVariable,
+            .second.name = "Var"
+        }}
+    });
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(Foo, EcsWildcard));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_str(q->terms[0].second.name, "Var");
+    test_uint(q->terms[0].second.id, EcsSelf|EcsIsVariable);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_src_var_from_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.id = Foo, 
+            .src.name = "$Var"
+        }}
+    });
+    
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_assert(q->terms != NULL);
+    test_int(q->terms[0].id, Foo);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_int(q->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_str(q->terms[0].src.name, "Var");
+    test_int(q->terms[0].src.id, EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_first_first_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.name = "$Var"
+        }}
+    });
+
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_assert(q->terms != NULL);
+    test_int(q->terms[0].id, EcsWildcard);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_str(q->terms[0].first.name, "Var");
+    test_int(q->terms[0].first.id, EcsSelf|EcsIsVariable);
+    test_int(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_second_second_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.id = Foo,
+            .second.name = "$Var"
+        }}
+    });
+
+    test_assert(q != NULL);
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_assert(q->terms != NULL);
+    test_int(q->terms[0].id, ecs_pair(Foo, EcsWildcard));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_int(q->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_int(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q->terms[0].trav, EcsIsA);
+    test_str(q->terms[0].second.name, "Var");
+    test_int(q->terms[0].second.id, EcsSelf|EcsIsVariable);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_variable_as_obj(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ 
+            .first.id = Foo, 
+            .second.id = EcsVariable|EcsIsVariable
+        }}
+    });
+    
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(Foo, Foo));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_uint(q->terms[0].second.id, Foo|EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_2_terms_or_w_dontinherit(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_add_id(world, TagB, EcsDontInherit);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ TagA, .oper = EcsOr }, { TagB }}
+    });
+
+    test_int(q->term_count, 2);
+    test_int(q->field_count, 1);
+
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsOr);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, TagA|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    test_uint(q->terms[1].id, TagB);
+    test_int(q->terms[1].oper, EcsAnd);
+    test_int(q->terms[1].field_index, 0);
+    test_uint(q->terms[1].first.id, TagB|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[1].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[1].trav, 0);
+    
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_2_terms_or_w_both_dontinherit(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_add_id(world, TagA, EcsDontInherit);
+    ecs_add_id(world, TagB, EcsDontInherit);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ TagA, .oper = EcsOr }, { TagB }}
+    });
+
+    test_int(q->term_count, 2);
+    test_int(q->field_count, 1);
+
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsOr);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, TagA|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[0].trav, 0);
+
+    test_uint(q->terms[1].id, TagB);
+    test_int(q->terms[1].oper, EcsAnd);
+    test_int(q->terms[1].field_index, 0);
+    test_uint(q->terms[1].first.id, TagB|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[1].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[1].trav, 0);
+    
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_pair_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_id_t pair = ecs_pair(Rel, Tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{pair}}
+    });
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, pair);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Rel|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_uint(q->terms[0].second.id, Tgt|EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_pred_obj(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+
+    ecs_id_t pair = ecs_pair(Rel, Tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{.first.id = Rel, .second.id = Tgt}}
+    });
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, pair);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Rel|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].second.id, Tgt|EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_pair_id_and_subj(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
+    ECS_TAG(world, Src);
+
+    ecs_id_t pair = ecs_pair(Rel, Tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{.id = pair, .src.id = Src}}
+    });
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, pair);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, Rel|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, Src|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[0].second.id, Tgt|EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_w_pred_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.name = "Tag"
+    });
+
+    test_int(q->terms[0].id, Tag);
+    test_assert(q->terms[0].first.name ==  NULL);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_w_final_pred_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, Tag, Final);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.name = "Tag"
+    });
+
+    test_int(q->terms[0].id, Tag);
+    test_assert(q->terms[0].first.name ==  NULL);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_w_subj_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Src);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = Tag,
+        .terms[0].src.name = "Src"
+    });
+
+    test_int(q->terms[0].id, Tag);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_assert(q->terms[0].src.name ==  NULL);
+    test_uint(q->terms[0].src.id, Src|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_1_w_obj_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+    ECS_TAG(world, Tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = Tag,
+        .terms[0].second.name = "Tgt"
+    });
+
+    test_int(q->terms[0].id, ecs_pair(Tag, Tgt));
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_assert(q->terms[0].second.name ==  NULL);
+    test_int(q->terms[0].second.id, Tgt|EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_this_implicit_variable(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = Tag,
+        .terms[0].src.id = EcsThis
+    });
+
+    test_int(q->terms[0].id, Tag);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_this_explicit_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = Tag,
+        .terms[0].src.id = EcsThis|EcsIsEntity,
+    });
+
+    test_int(q->terms[0].id, Tag);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[0].trav, EcsIsA);
+    
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_first_this_implicit_variable(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Src);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = EcsThis,
+        .terms[0].src.id = Src
+    });
+
+    test_int(q->terms[0].id, EcsWildcard);
+    test_uint(q->terms[0].first.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[0].src.id, Src|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_first_this_explicit_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Src);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = EcsThis|EcsIsEntity,
+        .terms[0].src.id = Src
+    });
+
+    test_int(q->terms[0].id, EcsThis);
+    test_uint(q->terms[0].first.id, EcsThis|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, Src|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_second_this_implicit_variable(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = Tag,
+        .terms[0].second.id = EcsThis
+    });
+
+    test_int(q->terms[0].id, ecs_pair(Tag, EcsWildcard));
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_int(q->terms[0].second.id, EcsThis|EcsSelf|EcsIsVariable);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_second_this_explicit_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = Tag,
+        .terms[0].second.id = EcsThis|EcsIsEntity,
+    });
+
+    test_int(q->terms[0].id, ecs_pair(Tag, EcsThis));
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_int(q->terms[0].second.id, EcsThis|EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_this_variable_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = Tag,
+        .terms[0].src.name = "this",
+        .terms[0].src.id = EcsIsVariable
+    });
+
+    test_int(q->terms[0].id, Tag);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+    test_assert(q->terms[0].src.name == NULL);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_0_source(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = Tag,
+        .terms[0].src.id = EcsIsEntity
+    });
+
+    test_int(q->terms[0].id, Tag);
+    test_uint(q->terms[0].first.id, Tag|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsIsEntity);
+    test_uint(q->terms[0].trav, 0);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_0_target(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].first.id = EcsChildOf,
+        .terms[0].second.id = EcsIsEntity
+    });
+
+    test_uint(q->terms[0].id, ecs_pair(EcsChildOf, 0));
+    test_uint(q->terms[0].first.id, EcsChildOf|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[0].trav, 0);
+    test_uint(q->terms[0].second.id, EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_2_terms_w_or(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{TagA, .oper = EcsOr}, {TagB }}
+    });
+
+    test_int(q->terms[0].oper, EcsOr);
+    test_uint(q->terms[0].id, TagA);
+    test_uint(q->terms[0].first.id, TagA|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    test_int(q->terms[1].oper, EcsAnd);
+    test_uint(q->terms[1].id, TagB);
+    test_uint(q->terms[1].first.id, TagB|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[1].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_uint(q->terms[1].trav, EcsIsA);
+    
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_2_terms_w_or_mixed_src_flags(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {TagA, .oper = EcsOr}, 
+            {TagB, .oper = EcsAnd, .src.id = EcsUp, .trav = EcsIsA },
+        }
+    });
+
+    ecs_entity_t base = ecs_new_w(world, TagB);
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, EcsIsA, base);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e1, it.entities[0]);
+    test_uint(TagA, it.ids[0]);
+    test_uint(0, it.sources[0]);
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e2, it.entities[0]);
+    test_uint(TagB, it.ids[0]);
+    test_uint(base, it.sources[0]);
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_2_terms_w_or_mixed_src_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ECS_TAG(world, SrcA);
+    ECS_TAG(world, SrcB);
+
+    ecs_log_set_level(-4);
+
+    test_assert(NULL == ecs_query(world, {
+        .terms = {
+            {TagA, .oper = EcsOr, .src.id = SrcA}, 
+            {TagB, .oper = EcsOr, .src.id = SrcB}
+        }
+    }));
+
+    ecs_fini(world);
+}
+
+void Validator_validate_2_terms_w_or_mixed_src_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ECS_TAG(world, SrcA);
+    ECS_TAG(world, SrcB);
+
+    ecs_log_set_level(-4);
+
+    test_assert(NULL == ecs_query(world, {
+        .terms = {
+            {TagA, .oper = EcsOr, .src.name = "SrcA"}, 
+            {TagB, .oper = EcsOr, .src.name = "SrcB"}
+        }
+    }));
+
+    ecs_fini(world);
+}
+
+void Validator_validate_2_terms_w_or_same_src_w_id_and_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ECS_TAG(world, SrcA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {TagA, .oper = EcsOr, .src.name = "SrcA"}, 
+            {TagB, .src.id = SrcA}
+        }
+    });
+
+    test_int(q->terms[0].oper, EcsOr);
+    test_uint(q->terms[0].id, TagA);
+    test_uint(q->terms[0].first.id, TagA|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, SrcA|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[0].trav, EcsIsA);
+
+    test_int(q->terms[1].oper, EcsAnd);
+    test_uint(q->terms[1].id, TagB);
+    test_uint(q->terms[1].first.id, TagB|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[1].src.id, SrcA|EcsSelf|EcsUp|EcsIsEntity);
+    test_uint(q->terms[1].trav, EcsIsA);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_and_flag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA, .oper = EcsAndFrom }
+        }
+    });
+
+    test_int(q->term_count, 1);
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsAndFrom);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_or_flag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA, .oper = EcsOrFrom }
+        }
+    });
+
+    test_int(q->term_count, 1);
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsOrFrom);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_not_flag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { TagA, .oper = EcsNotFrom }
+        }
+    });
+
+    test_int(q->term_count, 1);
+    test_assert(q->terms != NULL);
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsNotFrom);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_filter(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {TagA}
+        },
+        .flags = EcsQueryNoData
+    });
+
+    test_int(q->term_count, 1);
+    test_uint(q->terms[0].id, TagA);
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].inout, EcsInOutNone);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_double_init(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q_1 = ecs_query(world, {
+        .terms = {{ Foo }}
+    });
+    test_assert(q_1 != NULL);
+
+    test_int(q_1->term_count, 1);
+    test_int(q_1->terms[0].id, Foo);
+    test_int(q_1->terms[0].oper, EcsAnd);
+    test_int(q_1->terms[0].field_index, 0);
+    test_int(q_1->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_int(q_1->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q_1->terms[0].trav, EcsIsA);
+
+    ecs_query_desc_t desc = {0};
+    ecs_os_memcpy_n(desc.terms, q_1->terms, ecs_term_t, FLECS_TERM_COUNT_MAX);
+    ecs_query_t *q_2 = ecs_query_init(world, &desc);
+    test_assert(q_2 != NULL);
+
+    test_int(q_2->term_count, 1);
+    test_int(q_2->terms[0].id, Foo);
+    test_int(q_2->terms[0].oper, EcsAnd);
+    test_int(q_2->terms[0].field_index, 0);
+    test_int(q_2->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_int(q_2->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q_2->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q_1);
+    ecs_query_fini(q_2);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_double_init_w_expr(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q_1 = ecs_query(world, {
+        .expr = "Foo"
+    });
+    test_assert(q_1 != NULL);
+
+    test_int(q_1->term_count, 1);
+    test_int(q_1->terms[0].id, Foo);
+    test_int(q_1->terms[0].oper, EcsAnd);
+    test_int(q_1->terms[0].field_index, 0);
+    test_int(q_1->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_int(q_1->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q_1->terms[0].trav, EcsIsA);
+
+    ecs_query_desc_t desc = {0};
+    ecs_os_memcpy_n(desc.terms, q_1->terms, ecs_term_t, FLECS_TERM_COUNT_MAX);
+    ecs_query_t *q_2 = ecs_query_init(world, &desc);
+    test_assert(q_2 != NULL);
+
+    test_int(q_2->term_count, 1);
+    test_int(q_2->terms[0].id, Foo);
+    test_int(q_2->terms[0].oper, EcsAnd);
+    test_int(q_2->terms[0].field_index, 0);
+    test_int(q_2->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_int(q_2->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q_2->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q_1);
+    ecs_query_fini(q_2);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_double_init_w_expr_optional(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q_1 = ecs_query(world, {
+        .expr = "?Foo"
+    });
+    test_assert(q_1 != NULL);
+
+    test_int(q_1->term_count, 1);
+    test_int(q_1->terms[0].id, Foo);
+    test_int(q_1->terms[0].oper, EcsOptional);
+    test_int(q_1->terms[0].field_index, 0);
+    test_int(q_1->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_int(q_1->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q_1->terms[0].trav, EcsIsA);
+
+    ecs_query_desc_t desc = {0};
+    ecs_os_memcpy_n(desc.terms, q_1->terms, ecs_term_t, FLECS_TERM_COUNT_MAX);
+    ecs_query_t *q_2 = ecs_query_init(world, &desc);
+    test_assert(q_2 != NULL);
+
+    test_int(q_2->term_count, 1);
+    test_int(q_2->terms[0].id, Foo);
+    test_int(q_2->terms[0].oper, EcsOptional);
+    test_int(q_2->terms[0].field_index, 0);
+    test_int(q_2->terms[0].first.id, Foo|EcsSelf|EcsIsEntity);
+    test_int(q_2->terms[0].src.id, EcsThis|EcsSelf|EcsUp|EcsIsVariable);
+    test_int(q_2->terms[0].trav, EcsIsA);
+
+    ecs_query_fini(q_1);
+    ecs_query_fini(q_2);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_tag_term_is_no_data(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ Foo }}
+    });
+
+    test_assert(q->flags & EcsQueryNoData);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(it.flags & EcsIterNoData);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);   
+}
+
+void Validator_validate_w_inout_none_term_is_no_data(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Position), .inout = EcsInOutNone }}
+    });
+
+    test_assert(q->flags & EcsQueryNoData);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(it.flags & EcsIterNoData);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);  
+}
+
+void Validator_validate_w_tag_and_inout_none_term_is_no_data(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_id(Position), .inout = EcsInOutNone },
+            { Foo }
+        }
+    });
+
+    test_assert(q->flags & EcsQueryNoData);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(it.flags & EcsIterNoData);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_not_term_is_no_data(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { ecs_id(Position), .oper = EcsNot }
+        }
+    });
+
+    test_assert(q->flags & EcsQueryNoData);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(it.flags & EcsIterNoData);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_no_transitive_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, LocatedIn);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = LocatedIn, .second.id = EcsWildcard }
+        }
+    });
+
+    test_assert(!(q->terms[0].flags_ & EcsTermTransitive));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_transitive_pair_any_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, LocatedIn, Transitive);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {
+                .first.id = LocatedIn, 
+                .second.id = EcsWildcard,
+                .src.id = EcsAny
+            }
+        }
+    });
+
+    test_assert(!(q->terms[0].flags_ & EcsTermTransitive));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_transitive_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, LocatedIn, Transitive);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = LocatedIn, .second.id = EcsWildcard }
+        }
+    });
+
+    test_assert(q->terms[0].flags_ & EcsTermTransitive);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_transitive_tag_no_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, LocatedIn, Transitive);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = LocatedIn }
+        }
+    });
+
+    test_assert(!(q->terms[0].flags_ & EcsTermTransitive));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_transitive_tag_self_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, LocatedIn, Transitive);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = LocatedIn, .second.id = EcsWildcard|EcsSelf }
+        }
+    });
+
+    test_assert(!(q->terms[0].flags_ & EcsTermTransitive));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_transitive_tag_any_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_ENTITY(world, LocatedIn, Transitive);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = LocatedIn, .second.id = EcsAny }
+        }
+    });
+
+    test_assert(!(q->terms[0].flags_ & EcsTermTransitive));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_pair_same_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {
+                .first.id = Rel, 
+                .src.name = "a",
+                .src.id = EcsIsVariable,
+                .second.name = "a",
+                .second.id = EcsIsVariable,
+            }
+        }
+    });
+
+    test_assert(q->terms[0].src.id & EcsIsVariable);
+    test_assert(q->terms[0].second.id & EcsIsVariable);
+    test_str(q->terms[0].src.name, "a");
+    test_str(q->terms[0].second.name, "a");
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_pair_not_same_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {
+                .first.id = Rel, 
+                .src.name = "a",
+                .src.id = EcsIsVariable,
+                .second.name = "b",
+                .second.id = EcsIsVariable,
+            }
+        }
+    });
+
+    test_assert(q->terms[0].src.id & EcsIsVariable);
+    test_assert(q->terms[0].second.id & EcsIsVariable);
+    test_str(q->terms[0].src.name, "a");
+    test_str(q->terms[0].second.name, "b");
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_pair_no_vars_not_same_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, A);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {
+                .first.id = Rel, 
+                .src.id = A,
+                .second.id = A
+            }
+        }
+    });
+
+    test_uint(q->terms[0].src.id, A|EcsIsEntity|EcsSelf|EcsUp);
+    test_uint(q->terms[0].second.id, A|EcsIsEntity|EcsSelf);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_pair_wildcard_not_same_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {
+                .first.id = Rel, 
+                .src.id = EcsWildcard,
+                .second.id = EcsWildcard
+            }
+        }
+    });
+
+    test_uint(q->terms[0].src.id, EcsWildcard|EcsIsVariable|EcsSelf|EcsUp);
+    test_uint(q->terms[0].second.id, EcsWildcard|EcsIsVariable|EcsSelf);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_pair_any_not_same_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {
+                .first.id = Rel, 
+                .src.id = EcsAny,
+                .second.id = EcsAny
+            }
+        }
+    });
+
+    test_uint(q->terms[0].src.id, EcsAny|EcsIsVariable|EcsSelf|EcsUp);
+    test_uint(q->terms[0].second.id, EcsAny|EcsIsVariable|EcsSelf);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_no_pair_not_same_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {
+                .first.id = Rel, 
+                .src.name = "a",
+                .src.id = EcsIsVariable
+            }
+        }
+    });
+
+    test_assert(q->terms[0].src.id & EcsIsVariable);
+    test_assert(!(q->terms[0].second.id & EcsIsVariable));
+    test_str(q->terms[0].src.name, "a");
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_not_childof_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {
+                .first.id = EcsChildOf, 
+                .second.id = EcsAny,
+                .oper = EcsNot
+            }
+        }
+    });
+
+    test_int(q->term_count, 1);
+    test_int(q->field_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(EcsChildOf, 0));
+    test_int(q->terms[0].oper, EcsAnd);
+    test_int(q->terms[0].inout, EcsInOutDefault);
+    test_int(q->terms[0].field_index, 0);
+    test_uint(q->terms[0].first.id, EcsChildOf|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].src.id, EcsThis|EcsSelf|EcsIsVariable);
+    test_uint(q->terms[0].second.id, EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_inherited_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Unit);
+    ECS_ENTITY(world, MeleeUnit, (IsA, Unit));
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = Unit }
+        }
+    });
+
+    test_assert(q->terms[0].flags_ & EcsTermIdInherited);
+    test_uint(q->terms[0].first.id, Unit|EcsIsEntity|EcsSelf);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_inherited_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Unit);
+    ECS_ENTITY(world, MeleeUnit, (IsA, Unit));
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = Unit, .second.id = EcsWildcard }
+        }
+    });
+
+    test_assert(q->terms[0].flags_ & EcsTermIdInherited);
+    test_uint(q->terms[0].first.id, Unit|EcsIsEntity|EcsSelf);
+    test_uint(q->terms[0].second.id, EcsWildcard|EcsIsVariable|EcsSelf);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_non_inherited_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Unit);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = Unit }
+        }
+    });
+
+    test_assert(!(q->terms[0].flags_ & EcsTermIdInherited));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world); 
+}
+
+void Validator_validate_w_non_inherited_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Unit);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = Unit, .second.id = EcsWildcard }
+        }
+    });
+
+    test_assert(!(q->terms[0].flags_ & EcsTermIdInherited));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_first_wildcard_inout_none(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = EcsWildcard }
+        }
+    });
+
+    test_int(q->terms[0].inout, EcsInOutNone);
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_first_var_inout_none(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.name = "var", .first.id = EcsIsVariable }
+        }
+    });
+
+    test_int(q->terms[0].inout, EcsInOutNone);
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_pair_wildcard_inout_none(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = EcsWildcard, .second.id = EcsWildcard }
+        }
+    });
+
+    test_int(q->terms[0].inout, EcsInOutNone);
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_pair_var_inout_none(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            {
+                .first.name = "x", .first.id = EcsIsVariable,
+                .second.name = "y", .second.id = EcsIsVariable,
+            }
+        }
+    });
+
+    test_int(q->terms[0].inout, EcsInOutNone);
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_unresolved_by_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_log_set_level(-4);
+    test_assert(NULL == ecs_query(world, {
+        .terms = { { .first.name = "Foo" } },
+        .flags = EcsQueryAllowUnresolvedByName
+    }));
+
+    ecs_fini(world);
+}
+
+void Validator_validate_w_unresolved_by_name_eq(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this == Foo",
+        .flags = EcsQueryAllowUnresolvedByName
+    });
+
+    test_assert(q->terms[0].second.id & EcsIsName);
+    test_str(q->terms[0].second.name, "Foo");
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_childof_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = { { .first.id = EcsChildOf, .second.id = EcsThis } }
+    });
+
+    test_uint(q->terms[0].id, ecs_pair(EcsChildOf, EcsWildcard));
+    test_uint(q->terms[0].first.id, EcsChildOf|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].second.id, EcsThis|EcsSelf|EcsIsVariable);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_childof_this_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = { { .first.id = EcsChildOf, .second.id = EcsThis|EcsIsEntity } }
+    });
+
+    test_uint(q->terms[0].id, ecs_pair(EcsChildOf, EcsThis));
+    test_uint(q->terms[0].first.id, EcsChildOf|EcsSelf|EcsIsEntity);
+    test_uint(q->terms[0].second.id, EcsThis|EcsSelf|EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_childof_this_by_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    
+    ecs_log_set_level(-4);
+    test_assert(NULL == ecs_query(world, {
+        .terms = { { .id = ecs_pair(EcsChildOf, EcsThis) } }
+    }));
+
+    ecs_fini(world);
+}
+
+void Validator_validate_filter_flag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .inout = EcsInOutFilter, .id = ecs_id(Position) }
+        }
+    });
+
+    test_assert(q != NULL);
+    
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_first_0_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.name = "0" }}
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_src_0_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = Tag, .src.name = "0" }}
+    });
+
+    test_assert(q != NULL);
+    test_int(q->term_count, 1);
+    test_uint(q->terms[0].id, Tag);
+    test_uint(q->terms[0].first.id, Tag|EcsIsEntity|EcsSelf);
+    test_uint(q->terms[0].src.id, EcsIsEntity);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_second_0_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = Tag, .second.name = "0" }}
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_singleton_src_w_first_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = Tag, .src.id = EcsVariable }}
+    });
+
+    test_assert(q != NULL);
+    test_int(q->term_count, 1);
+    test_uint(q->terms[0].id, Tag);
+    test_uint(q->terms[0].first.id, Tag|EcsIsEntity|EcsSelf);
+    test_uint(q->terms[0].src.id, Tag|EcsIsEntity|EcsSelf|EcsUp);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Validator_validate_singleton_second_w_first_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ .first.id = Tag, .second.id = EcsVariable }}
+    });
+
+    test_assert(q != NULL);
+    test_int(q->term_count, 1);
+    test_uint(q->terms[0].id, ecs_pair(Tag, Tag));
+    test_uint(q->terms[0].first.id, Tag|EcsIsEntity|EcsSelf);
+    test_uint(q->terms[0].src.id, EcsThis|EcsIsVariable|EcsSelf|EcsUp);
+    test_uint(q->terms[0].second.id, Tag|EcsIsEntity|EcsSelf);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/Variables.c b/test/query/src/Variables.c
new file mode 100644
index 000000000..733b5a6f7
--- /dev/null
+++ b/test/query/src/Variables.c
@@ -0,0 +1,11409 @@
+#include <query.h>
+
+static ecs_query_cache_kind_t cache_kind = EcsQueryCacheDefault;
+
+void Variables_setup(void) {
+    const char *cache_param = test_param("cache_kind");
+    if (cache_param) {
+        if (!strcmp(cache_param, "default")) {
+            // already set to default
+        } else if (!strcmp(cache_param, "auto")) {
+            cache_kind = EcsQueryCacheAuto;
+        } else {
+            printf("unexpected value for cache_param '%s'\n", cache_param);
+        }
+    }
+}
+
+void Variables_1_ent_src_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_w_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_w_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA(ent, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_w_pair_rel_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x(ent, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
+        test_uint(EcsName, ecs_iter_get_var(&it, y_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
+        test_uint(EcsName, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
+        test_uint(EcsName, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(ecs_id(EcsIdentifier), EcsName), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(ecs_id(EcsIdentifier), ecs_iter_get_var(&it, x_var));
+        test_uint(EcsName, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_w_pair_rel_tgt_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x(ent, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, TgtA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, TgtB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_w_pair_rel_tgt_same_var_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x(ent), $x(ent, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, TgtA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TgtA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, TgtB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TgtA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TgtA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TgtB, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 1));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this), $x($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(3, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e2, RelB);
+    ecs_add(world, e3, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtB);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtB);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(3, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelB, TgtA);
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelB, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(3, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, TgtB);
+    ecs_add_pair(world, e3, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_pair_rel_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, Tag);
+
+    ecs_entity_t e1 = ecs_new_w(world, Tag);
+    ecs_entity_t e2 = ecs_new_w(world, Tag);
+    ecs_entity_t e3 = ecs_new_w(world, Tag);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Tag($this), $x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int32_t y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(3, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, TgtB);
+    ecs_add_pair(world, e3, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtB, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(Tag, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(TgtA, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_pair_rel_tgt_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelB, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, TgtA, TgtA);
+    ecs_add_pair(world, e2, TgtA, TgtA);
+    ecs_add_pair(world, e3, TgtA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(3, it.count);
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, TgtB, TgtB);
+    ecs_add_pair(world, e3, TgtB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_pair_rel_tgt_same_var_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelB, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this), $x($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, TgtA);
+    ecs_add_pair(world, e2, RelA, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, TgtA, TgtA);
+    ecs_add_pair(world, e2, TgtA, TgtA);
+    ecs_add_pair(world, e3, TgtA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, TgtA);
+    ecs_add(world, e2, TgtA);
+    ecs_add(world, e3, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(3, it.count);
+        test_uint(TgtA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+        test_uint(e2, it.entities[1]);
+        test_uint(e3, it.entities[2]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, TgtB, TgtB);
+    ecs_add_pair(world, e3, TgtB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TgtA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(TgtA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e2, TgtB);
+    ecs_add(world, e3, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TgtA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(TgtA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(TgtB, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_id_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e3, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($x), TagA($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(e1, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(e1, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(e2, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_first_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, e1, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($x, TgtA), TagA($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e2, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_second_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, RelA, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x, $x), TagA($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_first_and_second_same_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, e1, e1);
+    ecs_entity_t e4 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e4, e4, e1);
+    ecs_entity_t e5 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e5, e1, e5);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($x, $x), TagA($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e2, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_id_same_var_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e3, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($x), $x($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_first_same_var_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, e1, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($x), $x($x, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e2, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_second_same_var_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, RelA, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($x), RelA($x, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_first_and_second_same_var_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, e1, e1);
+    ecs_entity_t e4 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e4, e4, e1);
+    ecs_entity_t e5 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e5, e1, e5);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($x), $x($x, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e2, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_first_same_var_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e3, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this($this), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_second_same_var_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, e1, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this($this, TgtA), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e2, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+
+}
+
+void Variables_1_src_pair_first_and_second_same_var_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, RelA, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $this), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_id_same_var_this_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_id(world, e3, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($this), $this($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_first_same_var_this_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, e1, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($this), $this($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e2, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_second_same_var_this_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, RelA, e1);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($this), RelA($this, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_pair_first_and_second_same_var_this_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e3, e1, e1);
+    ecs_entity_t e4 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e4, e4, e1);
+    ecs_entity_t e5 = ecs_new_w(world, TagA);
+    ecs_add_pair(world, e5, e1, e5);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($this), $this($this, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, RelA, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e2, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_w_this_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, RelA);
+    ecs_add(world, ent, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, this_var));
+        test_uint(RelA, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, this_var));
+        test_uint(RelB, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_w_pair_this_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TgtA);
+    ecs_add(world, ent, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelB, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, this_var));
+        test_uint(RelA, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, this_var));
+        test_uint(RelB, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_w_pair_this_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA(ent, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TgtA);
+    ecs_add(world, ent, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, this_var));
+        test_uint(TgtA, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, this_var));
+        test_uint(TgtB, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_w_pair_this_rel_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this(ent, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TgtA);
+    ecs_add(world, ent, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelA, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, TgtA, TgtA);
+    ecs_add_pair(world, ent, TgtB, TgtB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(TgtA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, this_var));
+        test_uint(TgtA, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(TgtB, TgtB), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, this_var));
+        test_uint(TgtB, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t ent = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this($this), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+    
+    ecs_add_id(world, ent, ent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ent, ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ent, ecs_iter_get_var(&it, this_var));
+        test_uint(ent, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_pair_this_rel_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t ent = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this($this, $this), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+    
+    ecs_add_id(world, ent, ent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, ent, ent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(ent, ent), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ent, ecs_iter_get_var(&it, this_var));
+        test_uint(ent, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_this_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t ent = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($this), $this($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+    
+    ecs_add_id(world, ent, ent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ent, ecs_iter_get_var(&it, this_var));
+        test_uint(ent, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_this_src_w_pair_this_rel_tgt_after_write(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t ent = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($this), $this($this, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, ent, TagB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+    
+    ecs_add_id(world, ent, ent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, ent, ent, ent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(ent, ent), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ent, ecs_iter_get_var(&it, this_var));
+        test_uint(ent, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_src_from_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), RelB($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e1, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add(world, e2, RelB);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_rel_from_src_w_ent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x(e2)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_rel_from_src_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_rel_from_src_w_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_pair_rel_from_src_w_ent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x(e2, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_pair_rel_from_src_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x($y, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_pair_rel_from_src_w_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, e1, TgtA);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_pair_tgt_from_src_w_ent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), RelA(e2, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_pair_tgt_from_src_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), RelA($y, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_pair_tgt_from_src_w_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), RelA($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_pair_rel_tgt_from_src_w_ent(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x(e2, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_pair_rel_tgt_from_src_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x($y, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, RelA, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_constrain_pair_rel_tgt_from_src_w_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x), $x($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e3, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e3, e1, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(2, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, it.entities[0]);
+        test_uint(e3, it.entities[1]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_set_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+    ecs_add(world, ent, RelA);
+    ecs_add(world, ent, RelB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x(ent)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, RelA);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_set_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelB, TgtA);
+    ecs_add_pair(world, ent, RelC, TgtB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x(ent, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, RelA);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, RelB);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, RelC);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_ent_src_set_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_entity_t ent = ecs_entity(world, { .name = "ent" });
+    ecs_add_pair(world, ent, RelA, TgtA);
+    ecs_add_pair(world, ent, RelA, TgtB);
+    ecs_add_pair(world, ent, RelB, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA(ent, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, TgtA);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, TgtB);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(ent, ecs_field_src(&it, 0));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, TgtC);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelB);
+    ecs_entity_t e3 = ecs_new_w(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_var_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelC, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_var_w_pair_set_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, e1, TgtA);
+    ecs_add_pair(world, e2, e2, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($x, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e2);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_var_w_pair_set_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, RelA, e1);
+    ecs_add_pair(world, e2, RelA, e2);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($x, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e2);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_var_w_pair_set_rel_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, e1, e1);
+    ecs_add_pair(world, e2, e2, e2);
+    ecs_add_pair(world, e3, RelA, e3);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($x, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e2);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, x_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_entity_t e2 = ecs_new_w(world, RelB);
+    ecs_entity_t e3 = ecs_new_w(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var == 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelC, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e2);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_w_pair_set_rel(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, e1, TgtA);
+    ecs_add_pair(world, e2, e2, TgtA);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this($this, TgtA)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e2);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e2, TgtA), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_w_pair_set_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, RelA, e1);
+    ecs_add_pair(world, e2, RelA, e2);
+    ecs_add_pair(world, e3, RelA, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, e1), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e2);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, e2), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_w_pair_set_rel_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new(world);
+    ecs_entity_t e2 = ecs_new(world);
+    ecs_entity_t e3 = ecs_new(world);
+
+    ecs_add_pair(world, e1, e1, e1);
+    ecs_add_pair(world, e2, e2, e2);
+    ecs_add_pair(world, e3, RelA, e3);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this($this, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e1);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, e1), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e2);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e2, e2), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, this_var, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_to_empty_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_add(world, e1, TagB);
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    ecs_remove(world, e1, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ TagA }}
+    });
+
+    int this_var_id = ecs_query_find_var(q, "this");
+    test_assert(this_var_id != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_set_var_as_table(&it, this_var_id, t1);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 0);
+    test_assert(it.table == t1);
+    test_uint(ecs_field_id(&it, 0), TagA);
+    test_uint(ecs_field_size(&it, 0), 0);
+    ecs_table_t* this_var = ecs_iter_get_var_as_table(&it, this_var_id);
+    test_assert(this_var != NULL);
+    test_assert(this_var == t1);
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_to_empty_table_w_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add(world, e1, TagA);
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    ecs_remove(world, e1, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Position) }}
+    });
+
+    int this_var_id = ecs_query_find_var(q, "this");
+    test_assert(this_var_id != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_set_var_as_table(&it, this_var_id, t1);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 0);
+    test_assert(it.table == t1);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_assert(ecs_field(&it, Position, 0) == NULL);
+    ecs_table_t* this_var = ecs_iter_get_var_as_table(&it, this_var_id);
+    test_assert(this_var != NULL);
+    test_assert(this_var == t1);
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_to_empty_table_w_component_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, Position);
+    ecs_add(world, e1, TagA);
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    ecs_remove(world, e1, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ ecs_id(Position), .src.id = EcsSelf }},
+        .cache_kind = cache_kind
+    });
+
+    int this_var_id = ecs_query_find_var(q, "this");
+    test_assert(this_var_id != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_iter_set_var_as_table(&it, this_var_id, t1);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 0);
+    test_assert(it.table == t1);
+    test_uint(ecs_field_id(&it, 0), ecs_id(Position));
+    test_uint(ecs_field_size(&it, 0), sizeof(Position));
+    test_assert(ecs_field(&it, Position, 0) == NULL);
+    ecs_table_t* this_var = ecs_iter_get_var_as_table(&it, this_var_id);
+    test_assert(this_var != NULL);
+    test_assert(this_var == t1);
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_to_entiy_in_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0].id = ecs_id(Position),
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_to_entiy_in_table_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = ecs_id(Position), .src.id = EcsSelf },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = Foo },
+        .terms[1] = { .id = Bar },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_new_w(world, Bar);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_add(world, e1, Bar);
+
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_add_pair(world, e3, EcsIsA, prefab);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(prefab, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_self(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = Foo, .src.id = EcsSelf },
+        .terms[1] = { .id = Bar, .src.id = EcsSelf },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_new_w(world, Bar);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_add(world, e1, Bar);
+
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_add(world, e2, Bar);
+
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_add_pair(world, e3, EcsIsA, prefab);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = ecs_id(Position) },
+        .terms[1] = { .id = ecs_id(Velocity) },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_insert(world, ecs_value(Velocity, {3, 4}));
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_set(world, e1, Velocity, {1, 2});
+
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_set(world, e2, Velocity, {2, 3});
+
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add_pair(world, e3, EcsIsA, prefab);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 2);
+        test_int(v->y, 3);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 30);
+        test_int(p->y, 40);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 3);
+        test_int(v->y, 4);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(prefab, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_self_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = ecs_id(Position), .src.id = EcsSelf },
+        .terms[1] = { .id = ecs_id(Velocity), .src.id = EcsSelf },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_insert(world, ecs_value(Velocity, {4, 5}));
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_set(world, e1, Velocity, {1, 2});
+
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_set(world, e2, Velocity, {2, 3});
+
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {40, 50}));
+    ecs_add_pair(world, e3, EcsIsA, prefab);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 2);
+        test_int(v->y, 3);
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_w_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Hello);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = Foo },
+        .terms[1] = { .id = Bar },
+        .terms[2] = { .id = Hello, .src.id = EcsUp, .trav = EcsChildOf },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_new_w(world, Bar);
+    ecs_entity_t parent = ecs_new_w(world, Hello);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_add(world, e1, Bar);
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_add(world, e2, Bar);
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_add_pair(world, e3, EcsIsA, prefab);
+    ecs_add_pair(world, e3, EcsChildOf, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(Hello, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(Hello, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(Hello, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(prefab, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_self_w_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Hello);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = Foo, .src.id = EcsSelf },
+        .terms[1] = { .id = Bar, .src.id = EcsSelf },
+        .terms[2] = { .id = Hello, .src.id = EcsUp, .trav = EcsChildOf },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_new_w(world, Bar);
+    ecs_entity_t parent = ecs_new_w(world, Hello);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_add(world, e1, Bar);
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_add(world, e2, Bar);
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_add_pair(world, e3, EcsIsA, prefab);
+    ecs_add_pair(world, e3, EcsChildOf, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(Hello, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(Hello, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_component_w_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = ecs_id(Position) },
+        .terms[1] = { .id = ecs_id(Velocity) },
+        .terms[2] = { .id = ecs_id(Mass), .src.id = EcsUp, .trav = EcsChildOf },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_insert(world, ecs_value(Velocity, {3, 4}));
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Mass, {60}));
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_set(world, e1, Velocity, {1, 2});
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_set(world, e2, Velocity, {2, 3});
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add_pair(world, e3, EcsIsA, prefab);
+    ecs_add_pair(world, e3, EcsChildOf, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        Mass *m = ecs_field(&it, Mass, 2);
+        test_assert(m != NULL);
+        test_int(m[0], 60);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 2);
+        test_int(v->y, 3);
+        Mass *m = ecs_field(&it, Mass, 2);
+        test_assert(m != NULL);
+        test_int(m[0], 60);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 30);
+        test_int(p->y, 40);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 3);
+        test_int(v->y, 4);
+        Mass *m = ecs_field(&it, Mass, 2);
+        test_assert(m != NULL);
+        test_int(m[0], 60);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(prefab, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_self_component_w_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+    ECS_COMPONENT(world, Mass);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = ecs_id(Position), .src.id = EcsSelf },
+        .terms[1] = { .id = ecs_id(Velocity), .src.id = EcsSelf },
+        .terms[2] = { .id = ecs_id(Mass), .src.id = EcsUp, .trav = EcsChildOf },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_insert(world, ecs_value(Velocity, {3, 4}));
+    ecs_entity_t parent = ecs_insert(world, ecs_value(Mass, {60}));
+
+    ecs_entity_t e1 = ecs_insert(world, ecs_value(Position, {10, 20}));
+    ecs_set(world, e1, Velocity, {1, 2});
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_insert(world, ecs_value(Position, {20, 30}));
+    ecs_set(world, e2, Velocity, {2, 3});
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_entity_t e3 = ecs_insert(world, ecs_value(Position, {30, 40}));
+    ecs_add_pair(world, e3, EcsIsA, prefab);
+    ecs_add_pair(world, e3, EcsChildOf, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+        Mass *m = ecs_field(&it, Mass, 2);
+        test_assert(m != NULL);
+        test_int(m[0], 60);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 2);
+        test_int(v->y, 3);
+        Mass *m = ecs_field(&it, Mass, 2);
+        test_assert(m != NULL);
+        test_int(m[0], 60);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Mass), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(parent, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_w_exclusive_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Hello);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = Foo },
+        .terms[1] = { .id = Bar },
+        .terms[2] = { .id = ecs_pair(EcsChildOf, EcsWildcard) },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_new_w(world, Bar);
+    ecs_entity_t parent = ecs_new_w(world, Hello);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_add(world, e1, Bar);
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_add(world, e2, Bar);
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_add_pair(world, e3, EcsIsA, prefab);
+    ecs_add_pair(world, e3, EcsChildOf, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(Bar, ecs_field_id(&it, 1));
+        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(prefab, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_self_w_exclusive_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Hello);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = Foo, .src.id = EcsSelf },
+        .terms[1] = { .id = ecs_pair(EcsChildOf, EcsWildcard) },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t parent_1 = ecs_new_w(world, Hello);
+    ecs_entity_t parent_2 = ecs_new_w(world, Hello);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_add_pair(world, e1, EcsChildOf, parent_1);
+
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_add_pair(world, e2, EcsChildOf, parent_2);
+
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, parent_1), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, parent_2), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_set_src_this_self_w_exclusive_wildcard_w_up(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+    ECS_TAG(world, Hello);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms[0] = { .id = Foo, .src.id = EcsSelf },
+        .terms[1] = { .id = ecs_pair(EcsChildOf, EcsWildcard), .src.id = EcsSelf },
+        .terms[2] = { .id = Bar, .src.id = EcsUp, .trav = EcsIsA },
+        .cache_kind = cache_kind
+    });
+
+    ecs_entity_t prefab = ecs_new_w(world, Bar);
+    ecs_entity_t parent = ecs_new_w(world, Hello);
+
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_add_pair(world, e1, EcsIsA, prefab);
+    ecs_add_pair(world, e1, EcsChildOf, parent);
+
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
+    ecs_add_pair(world, e2, EcsIsA, prefab);
+    ecs_add_pair(world, e2, EcsChildOf, parent);
+
+    ecs_entity_t e3 = ecs_new_w(world, Foo);
+    ecs_add(world, e3, Bar);
+    ecs_add_pair(world, e3, EcsChildOf, parent);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 1));
+        test_uint(Bar, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(prefab, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(Foo, ecs_field_id(&it, 0));
+        test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 1));
+        test_uint(Bar, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(prefab, ecs_field_src(&it, 2));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_set_src_this_is_true(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position) }
+        },
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    /* ecs_entity_t e1 = */ ecs_insert(ecs, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {20, 30}));
+    /* ecs_entity_t e3 = */ ecs_insert(ecs, ecs_value(Position, {30, 40}));
+    ecs_entity_t e4 = ecs_insert(ecs, ecs_value(Velocity, {20, 30}));
+
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    ecs_iter_set_var(&it, 0, e2);
+    test_bool(true, ecs_iter_is_true(&it));
+
+    it = ecs_query_iter(ecs, q);
+    ecs_iter_set_var(&it, 0, e4);
+    test_bool(false, ecs_iter_is_true(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_2_set_src_this_w_wildcard(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_TAG(ecs, Likes);
+    ECS_TAG(ecs, Apples);
+    ECS_TAG(ecs, Pears);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .id = ecs_id(Position) },
+            { .id = ecs_pair(Likes, EcsWildcard) }
+        },
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {10, 20}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {20, 30}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {30, 40}));
+
+    ecs_add_pair(ecs, e1, Likes, Apples);
+    ecs_add_pair(ecs, e2, Likes, Apples);
+    ecs_add_pair(ecs, e3, Likes, Apples);
+
+    ecs_add_pair(ecs, e1, Likes, Pears);
+    ecs_add_pair(ecs, e2, Likes, Pears);
+    ecs_add_pair(ecs, e3, Likes, Pears);
+
+    ecs_iter_t it = ecs_query_iter(ecs, q);
+    ecs_iter_set_var(&it, 0, e2);
+
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+        test_uint(ecs_pair(Likes, Apples), ecs_field_id(&it, 1));
+    }
+    {
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        Position *p = ecs_field(&it, Position, 0);
+        test_int(p[0].x, 20);
+        test_int(p[0].y, 30);
+        test_uint(ecs_pair(Likes, Pears), ecs_field_id(&it, 1));
+    }
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_uncacheable_tag_tag_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_TAG(ecs, TagA);
+    ECS_TAG(ecs, TagB);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e2 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e3 = ecs_new_w(ecs, TagA);
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_add_pair(ecs, e1, EcsChildOf, p1);
+    ecs_add_pair(ecs, e2, EcsChildOf, p1);
+    ecs_add_pair(ecs, e3, EcsChildOf, p2);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .first.id = EcsChildOf, .second.name = "$parent" },
+            { TagA },
+            { TagB }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_childof(p2), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_uncacheable_tag_component_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_TAG(ecs, TagB);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_add_pair(ecs, e1, EcsChildOf, p1);
+    ecs_add_pair(ecs, e2, EcsChildOf, p1);
+    ecs_add_pair(ecs, e3, EcsChildOf, p2);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .first.id = EcsChildOf, .second.name = "$parent" },
+            { ecs_id(Position) },
+            { TagB }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_childof(p2), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_uncacheable_tag_component_component(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_set(ecs, e1, Velocity, {1, 1});
+    ecs_set(ecs, e2, Velocity, {2, 2});
+    ecs_set(ecs, e3, Velocity, {3, 3});
+    ecs_add_pair(ecs, e1, EcsChildOf, p1);
+    ecs_add_pair(ecs, e2, EcsChildOf, p1);
+    ecs_add_pair(ecs, e3, EcsChildOf, p2);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .first.id = EcsChildOf, .second.name = "$parent" },
+            { ecs_id(Position) },
+            { ecs_id(Velocity) }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 1);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 2);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_childof(p2), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 3);
+            test_int(v->y, 3);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_tag_uncacheable_tag_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_TAG(ecs, TagA);
+    ECS_TAG(ecs, TagB);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e2 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e3 = ecs_new_w(ecs, TagA);
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_add_pair(ecs, e1, EcsChildOf, p1);
+    ecs_add_pair(ecs, e2, EcsChildOf, p1);
+    ecs_add_pair(ecs, e3, EcsChildOf, p2);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { TagA },
+            { .first.id = EcsChildOf, .second.name = "$parent" },
+            { TagB }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_childof(p2), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_component_uncacheable_tag_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_TAG(ecs, TagB);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_add_pair(ecs, e1, EcsChildOf, p1);
+    ecs_add_pair(ecs, e2, EcsChildOf, p1);
+    ecs_add_pair(ecs, e3, EcsChildOf, p2);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { ecs_id(Position) },
+            { .first.id = EcsChildOf, .second.name = "$parent" },
+            { TagB }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_childof(p2), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_component_uncacheable_tag_component(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_set(ecs, e1, Velocity, {1, 1});
+    ecs_set(ecs, e2, Velocity, {2, 2});
+    ecs_set(ecs, e3, Velocity, {3, 3});
+    ecs_add_pair(ecs, e1, EcsChildOf, p1);
+    ecs_add_pair(ecs, e2, EcsChildOf, p1);
+    ecs_add_pair(ecs, e3, EcsChildOf, p2);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { ecs_id(Position) },
+            { .first.id = EcsChildOf, .second.name = "$parent" },
+            { ecs_id(Velocity) }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 1);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 2);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_childof(p2), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 3);
+            test_int(v->y, 3);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_tag_tag_uncacheable_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_TAG(ecs, TagA);
+    ECS_TAG(ecs, TagB);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e2 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e3 = ecs_new_w(ecs, TagA);
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_add_pair(ecs, e1, EcsChildOf, p1);
+    ecs_add_pair(ecs, e2, EcsChildOf, p1);
+    ecs_add_pair(ecs, e3, EcsChildOf, p2);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { TagA },
+            { TagB },
+            { .first.id = EcsChildOf, .second.name = "$parent" }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_childof(p2), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_component_tag_uncacheable_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_TAG(ecs, TagB);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_add_pair(ecs, e1, EcsChildOf, p1);
+    ecs_add_pair(ecs, e2, EcsChildOf, p1);
+    ecs_add_pair(ecs, e3, EcsChildOf, p2);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { ecs_id(Position) },
+            { TagB },
+            { .first.id = EcsChildOf, .second.name = "$parent" }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_childof(p2), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_component_component_uncacheable_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_set(ecs, e1, Velocity, {1, 1});
+    ecs_set(ecs, e2, Velocity, {2, 2});
+    ecs_set(ecs, e3, Velocity, {3, 3});
+    ecs_add_pair(ecs, e1, EcsChildOf, p1);
+    ecs_add_pair(ecs, e2, EcsChildOf, p1);
+    ecs_add_pair(ecs, e3, EcsChildOf, p2);
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { ecs_id(Position) },
+            { ecs_id(Velocity) },
+            { .first.id = EcsChildOf, .second.name = "$parent" }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 1);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_childof(p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 2);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_childof(p2), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 3);
+            test_int(v->y, 3);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_uncacheable_component_tag_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_TAG(ecs, TagA);
+    ECS_TAG(ecs, TagB);
+    ECS_COMPONENT(ecs, Mass);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e2 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e3 = ecs_new_w(ecs, TagA);
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_set_pair(ecs, e1, Mass, p1, {100});
+    ecs_set_pair(ecs, e2, Mass, p1, {200});
+    ecs_set_pair(ecs, e3, Mass, p2, {300});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .first.id = ecs_id(Mass), .second.name = "$parent" },
+            { TagA },
+            { TagB }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 0);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 0);
+            test_assert(m != NULL);
+            test_int(*m, 200);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_pair_t(Mass, p2), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 0);
+            test_assert(m != NULL);
+            test_int(*m, 300);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_uncacheable_component_component_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Mass);
+    ECS_COMPONENT(ecs, Position);
+    ECS_TAG(ecs, TagB);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_set_pair(ecs, e1, Mass, p1, {100});
+    ecs_set_pair(ecs, e2, Mass, p1, {200});
+    ecs_set_pair(ecs, e3, Mass, p2, {300});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .first.id = ecs_id(Mass), .second.name = "$parent" },
+            { ecs_id(Position) },
+            { TagB }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 0);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 0);
+            test_assert(m != NULL);
+            test_int(*m, 200);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_pair_t(Mass, p2), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 0);
+            test_assert(m != NULL);
+            test_int(*m, 300);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_uncacheable_component_component_component(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Mass);
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_set(ecs, e1, Velocity, {1, 1});
+    ecs_set(ecs, e2, Velocity, {2, 2});
+    ecs_set(ecs, e3, Velocity, {3, 3});
+    ecs_set_pair(ecs, e1, Mass, p1, {100});
+    ecs_set_pair(ecs, e2, Mass, p1, {200});
+    ecs_set_pair(ecs, e3, Mass, p2, {300});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { .first.id = ecs_id(Mass), .second.name = "$parent" },
+            { ecs_id(Position) },
+            { ecs_id(Velocity) }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 0);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 1);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 0);
+            test_assert(m != NULL);
+            test_int(*m, 200);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 2);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_pair_t(Mass, p2), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 0);
+            test_assert(m != NULL);
+            test_int(*m, 300);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 1);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 3);
+            test_int(v->y, 3);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_tag_uncacheable_component_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_TAG(ecs, TagA);
+    ECS_TAG(ecs, TagB);
+    ECS_COMPONENT(ecs, Mass);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e2 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e3 = ecs_new_w(ecs, TagA);
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_set_pair(ecs, e1, Mass, p1, {100});
+    ecs_set_pair(ecs, e2, Mass, p1, {200});
+    ecs_set_pair(ecs, e3, Mass, p2, {300});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { TagA },
+            { .first.id = ecs_id(Mass), .second.name = "$parent" },
+            { TagB }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 1);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 1);
+            test_assert(m != NULL);
+            test_int(*m, 200);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(ecs_pair_t(Mass, p2), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 1);
+            test_assert(m != NULL);
+            test_int(*m, 300);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_component_uncacheable_component_tag(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Mass);
+    ECS_COMPONENT(ecs, Position);
+    ECS_TAG(ecs, TagB);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_set_pair(ecs, e1, Mass, p1, {100});
+    ecs_set_pair(ecs, e2, Mass, p1, {200});
+    ecs_set_pair(ecs, e3, Mass, p2, {300});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { ecs_id(Position) },
+            { .first.id = ecs_id(Mass), .second.name = "$parent" },
+            { TagB }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 1);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 1);
+            test_assert(m != NULL);
+            test_int(*m, 200);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_pair_t(Mass, p2), ecs_field_id(&it, 1));
+        test_uint(TagB, ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 1);
+            test_assert(m != NULL);
+            test_int(*m, 300);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_component_uncacheable_component_component(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Mass);
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_set(ecs, e1, Velocity, {1, 1});
+    ecs_set(ecs, e2, Velocity, {2, 2});
+    ecs_set(ecs, e3, Velocity, {3, 3});
+    ecs_set_pair(ecs, e1, Mass, p1, {100});
+    ecs_set_pair(ecs, e2, Mass, p1, {200});
+    ecs_set_pair(ecs, e3, Mass, p2, {300});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { ecs_id(Position) },
+            { .first.id = ecs_id(Mass), .second.name = "$parent" },
+            { ecs_id(Velocity) }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 1);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 1);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 1);
+            test_assert(m != NULL);
+            test_int(*m, 200);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 2);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_pair_t(Mass, p2), ecs_field_id(&it, 1));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 1);
+            test_assert(m != NULL);
+            test_int(*m, 300);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 2);
+            test_assert(v != NULL);
+            test_int(v->x, 3);
+            test_int(v->y, 3);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_tag_tag_uncacheable_component(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_TAG(ecs, TagA);
+    ECS_TAG(ecs, TagB);
+    ECS_COMPONENT(ecs, Mass);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e2 = ecs_new_w(ecs, TagA);
+    ecs_entity_t e3 = ecs_new_w(ecs, TagA);
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_set_pair(ecs, e1, Mass, p1, {100});
+    ecs_set_pair(ecs, e2, Mass, p1, {200});
+    ecs_set_pair(ecs, e3, Mass, p2, {300});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { TagA },
+            { TagB },
+            { .first.id = ecs_id(Mass), .second.name = "$parent" }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 200);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_pair_t(Mass, p2), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 300);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_component_tag_uncacheable_component(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Mass);
+    ECS_COMPONENT(ecs, Position);
+    ECS_TAG(ecs, TagB);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_add(ecs, e1, TagB);
+    ecs_add(ecs, e2, TagB);
+    ecs_add(ecs, e3, TagB);
+    ecs_set_pair(ecs, e1, Mass, p1, {100});
+    ecs_set_pair(ecs, e2, Mass, p1, {200});
+    ecs_set_pair(ecs, e3, Mass, p2, {300});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { ecs_id(Position) },
+            { TagB },
+            { .first.id = ecs_id(Mass), .second.name = "$parent" }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 200);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(ecs_pair_t(Mass, p2), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 300);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_3_set_src_this_w_component_component_uncacheable_component(void) {
+    ecs_world_t* ecs = ecs_mini();
+
+    ECS_COMPONENT(ecs, Mass);
+    ECS_COMPONENT(ecs, Position);
+    ECS_COMPONENT(ecs, Velocity);
+
+    ecs_entity_t p1 = ecs_new(ecs);
+    ecs_entity_t p2 = ecs_new(ecs);
+    ecs_entity_t e1 = ecs_insert(ecs, ecs_value(Position, {11, 21}));
+    ecs_entity_t e2 = ecs_insert(ecs, ecs_value(Position, {12, 22}));
+    ecs_entity_t e3 = ecs_insert(ecs, ecs_value(Position, {13, 23}));
+    ecs_set(ecs, e1, Velocity, {1, 1});
+    ecs_set(ecs, e2, Velocity, {2, 2});
+    ecs_set(ecs, e3, Velocity, {3, 3});
+    ecs_set_pair(ecs, e1, Mass, p1, {100});
+    ecs_set_pair(ecs, e2, Mass, p1, {200});
+    ecs_set_pair(ecs, e3, Mass, p2, {300});
+
+    ecs_query_t *q = ecs_query(ecs, {
+        .terms = {
+            { ecs_id(Position) },
+            { ecs_id(Velocity) },
+            { .first.id = ecs_id(Mass), .second.name = "$parent" }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t parent_var = ecs_query_find_var(q, "parent");
+    test_assert(parent_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e1);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e1);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 100);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 11);
+            test_int(p->y, 21);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 1);
+            test_int(v->y, 1);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e2);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e2);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_pair_t(Mass, p1), ecs_field_id(&it, 2));
+        test_uint(p1, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 200);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 12);
+            test_int(p->y, 22);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 2);
+            test_int(v->y, 2);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(ecs, q);
+        ecs_iter_set_var(&it, 0, e3);
+        test_bool(true, ecs_query_next(&it));
+        test_int(it.count, 1);
+        test_uint(it.entities[0], e3);
+        test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+        test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+        test_uint(ecs_pair_t(Mass, p2), ecs_field_id(&it, 2));
+        test_uint(p2, ecs_iter_get_var(&it, parent_var));
+        {
+            Mass *m = ecs_field(&it, Mass, 2);
+            test_assert(m != NULL);
+            test_int(*m, 300);
+        }
+        {
+            Position *p = ecs_field(&it, Position, 0);
+            test_assert(p != NULL);
+            test_int(p->x, 13);
+            test_int(p->y, 23);
+        }
+        {
+            Velocity *v = ecs_field(&it, Velocity, 1);
+            test_assert(v != NULL);
+            test_int(v->x, 3);
+            test_int(v->y, 3);
+        }
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(ecs);
+}
+
+void Variables_1_src_this_var_as_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_entity_t e4 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e3, TagC);
+    ecs_add(world, e4, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ TagA }},
+        .cache_kind = cache_kind
+    });
+
+    int this_var_id = ecs_query_find_var(q, "this");
+    test_assert(this_var_id != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    ecs_entity_t this_var = ecs_iter_get_var(&it, this_var_id);
+    test_assert(this_var != 0);
+    test_assert(this_var == e1);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    this_var = ecs_iter_get_var(&it, this_var_id);
+    test_assert(this_var != 0);
+    test_assert(this_var == e2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_uint(it.entities[0], e3);
+    test_uint(it.entities[1], e4);
+    this_var = ecs_iter_get_var(&it, this_var_id);
+    test_assert(this_var == 0); /* more than one entity matches */
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_this_var_as_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_entity_t e4 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e3, TagC);
+    ecs_add(world, e4, TagC);
+
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    test_assert(t1 != NULL);
+
+    ecs_table_t *t2 = ecs_get_table(world, e2);
+    test_assert(t2 != NULL);
+    test_assert(t2 != t1);
+
+    ecs_table_t *t3 = ecs_get_table(world, e3);
+    test_assert(t3 != NULL);
+    test_assert(t3 != t1);
+    test_assert(t3 != t2);
+    test_assert(t3 == ecs_get_table(world, e4));
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ TagA }},
+        .cache_kind = cache_kind
+    });
+
+    int this_var_id = ecs_query_find_var(q, "this");
+    test_assert(this_var_id != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    ecs_table_t *this_var = ecs_iter_get_var_as_table(&it, this_var_id);
+    test_assert(this_var != NULL);
+    test_assert(this_var == t1);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    this_var = ecs_iter_get_var_as_table(&it, this_var_id);
+    test_assert(this_var != NULL);
+    test_assert(this_var == t2);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_uint(it.entities[0], e3);
+    test_uint(it.entities[1], e4);
+    this_var = ecs_iter_get_var_as_table(&it, this_var_id);
+    test_assert(this_var != NULL);
+    test_assert(this_var == t3);
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_src_this_var_as_table_range(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+    ecs_entity_t e4 = ecs_new_w(world, TagA);
+    ecs_add(world, e2, TagB);
+    ecs_add(world, e3, TagC);
+    ecs_add(world, e4, TagC);
+
+    ecs_table_t *t1 = ecs_get_table(world, e1);
+    test_assert(t1 != NULL);
+
+    ecs_table_t *t2 = ecs_get_table(world, e2);
+    test_assert(t2 != NULL);
+    test_assert(t2 != t1);
+
+    ecs_table_t *t3 = ecs_get_table(world, e3);
+    test_assert(t3 != NULL);
+    test_assert(t3 != t1);
+    test_assert(t3 != t2);
+    test_assert(t3 == ecs_get_table(world, e4));
+
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {{ TagA }},
+        .cache_kind = cache_kind
+    });
+
+    int this_var_id = ecs_query_find_var(q, "this");
+    test_assert(this_var_id != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e1);
+    ecs_table_range_t this_var = ecs_iter_get_var_as_range(&it, this_var_id);
+    test_assert(this_var.table != NULL);
+    test_assert(this_var.table == t1);
+    test_assert(this_var.offset == 0);
+    test_assert(this_var.count == 1);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 1);
+    test_uint(it.entities[0], e2);
+    this_var = ecs_iter_get_var_as_range(&it, this_var_id);
+    test_assert(this_var.table != NULL);
+    test_assert(this_var.table == t2);
+    test_assert(this_var.offset == 0);
+    test_assert(this_var.count == 1);
+
+    test_assert(ecs_query_next(&it));
+    test_int(it.count, 2);
+    test_uint(it.entities[0], e3);
+    test_uint(it.entities[1], e4);
+    this_var = ecs_iter_get_var_as_range(&it, this_var_id);
+    test_assert(this_var.table != NULL);
+    test_assert(this_var.table == t3);
+    test_assert(this_var.offset == 0);
+    test_assert(this_var.count == 2);
+
+    test_assert(!ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_join_by_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+
+    ecs_entity_t e1 = ecs_new_w(world, RelA);
+    ecs_add(world, e1, RelB);
+    ecs_add_pair(world, e1, TagA, TagB);
+
+    ecs_entity_t e2 = ecs_new_w(world, RelA);
+    ecs_entity_t e3 = ecs_new_w(world, RelB);
+    ecs_new_w(world, RelC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this), $x($y), TagA($this, TagB)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TagA, TagB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelA, ecs_field_id(&it, 0));
+        test_uint(RelA, ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TagA, TagB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TagA, TagB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(RelB, ecs_field_id(&it, 0));
+        test_uint(RelB, ecs_field_id(&it, 1));
+        test_uint(ecs_pair(TagA, TagB), ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_join_by_pair_rel_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, RelB);
+    ECS_TAG(world, RelC);
+    ECS_TAG(world, TgtA);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_add_pair(world, e1, RelB, TgtA);
+    ecs_add(world, e1, TagA);
+
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelB, TgtA);
+    ecs_new_w_pair(world, RelC, TgtA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, TgtA), $x($y, TgtA), TagA",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(RelA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelB, TgtA), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(RelB, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_join_by_pair_tgt_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, RelA);
+    ECS_TAG(world, TgtA);
+    ECS_TAG(world, TgtB);
+    ECS_TAG(world, TgtC);
+
+    ecs_entity_t e1 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_add_pair(world, e1, RelA, TgtB);
+    ecs_add(world, e1, TagA);
+
+    ecs_entity_t e2 = ecs_new_w_pair(world, RelA, TgtA);
+    ecs_entity_t e3 = ecs_new_w_pair(world, RelA, TgtB);
+    ecs_new_w_pair(world, RelA, TgtC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "RelA($this, $x), RelA($y, $x), TagA",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtA), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(TgtA, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(RelA, TgtB), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(TgtB, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($y), $y($x), TagA($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e2);
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(e2, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 2));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(e1, ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_w_this_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this($y), $y($this), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    if (cache_kind == EcsQueryCacheDefault) {
+        ecs_add_id(world, e1, e2);
+        ecs_add_id(world, e2, e1);
+    } else {
+        /* Cached query reverses the result */
+        ecs_add_id(world, e2, e1);
+        ecs_add_id(world, e1, e2);
+    }
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_w_var_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this), $this($x), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_id(world, e1, e2);
+    ecs_add_id(world, e2, e1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e2, ecs_field_id(&it, 0));
+        test_uint(e1, ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(e1, ecs_field_id(&it, 0));
+        test_uint(e2, ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_pair_w_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($y, $z), $x($z, $y), TagA($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    int z_var = ecs_query_find_var(q, "z");
+    test_assert(z_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, e3);
+    ecs_add_pair(world, e3, e1, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, ecs_iter_get_var(&it, z_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, ecs_iter_get_var(&it, z_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_pair_w_this_var_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$this($y, $z), $this($z, $y), TagA($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    int z_var = ecs_query_find_var(q, "z");
+    test_assert(z_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, e3);
+    ecs_add_pair(world, e3, e1, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, ecs_iter_get_var(&it, z_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, ecs_iter_get_var(&it, z_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_pair_w_var_this_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $z), $x($z, $this), TagA($this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    int z_var = ecs_query_find_var(q, "z");
+    test_assert(z_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, e3);
+    ecs_add_pair(world, e3, e1, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e3, ecs_iter_get_var(&it, z_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(0, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, ecs_iter_get_var(&it, z_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_pair_w_var_var_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e1 = ecs_new_w(world, TagA);
+    ecs_entity_t e2 = ecs_new_w(world, TagA);
+    ecs_entity_t e3 = ecs_new_w(world, TagA);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($y, $this), $x($this, $y), TagA($y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e2, e1, e3);
+    ecs_add_pair(world, e3, e1, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, ecs_iter_get_var(&it, this_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(e1, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(e1, e3), ecs_field_id(&it, 1));
+        test_uint(TagA, ecs_field_id(&it, 2));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 2));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_pair_ent_var_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Likes);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Likes($x, $y), Likes($y, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, Likes, e2);
+    ecs_add_pair(world, e1, Likes, e1);
+    ecs_add_pair(world, e2, Likes, e1);
+    ecs_add_pair(world, e2, Likes, e3);
+    ecs_add_pair(world, e3, Likes, e1);
+    ecs_add_pair(world, e3, Likes, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_pair_ent_this_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Likes);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Likes($this, $y), Likes($y, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, Likes, e2);
+    ecs_add_pair(world, e1, Likes, e1);
+    ecs_add_pair(world, e2, Likes, e1);
+    ecs_add_pair(world, e2, Likes, e3);
+    ecs_add_pair(world, e3, Likes, e1);
+    ecs_add_pair(world, e3, Likes, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e2, ecs_field_src(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, ecs_iter_get_var(&it, y_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e1, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(e3, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e3, ecs_iter_get_var(&it, y_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_cycle_pair_ent_var_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Likes);
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+    ecs_entity_t e3 = ecs_entity(world, { .name = "e3" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Likes($x, $this), Likes($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_assert(this_var != 0);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_add_pair(world, e1, Likes, e2);
+    ecs_add_pair(world, e1, Likes, e1);
+    ecs_add_pair(world, e2, Likes, e1);
+    ecs_add_pair(world, e2, Likes, e3);
+    ecs_add_pair(world, e3, Likes, e1);
+    ecs_add_pair(world, e3, Likes, e2);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 1));
+        test_uint(e1, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e1, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 1));
+        test_uint(e3, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e3, ecs_iter_get_var(&it, x_var));
+        test_uint(e2, ecs_iter_get_var(&it, this_var));
+        test_uint(e2, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e1), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(e1, ecs_iter_get_var(&it, this_var));
+        test_uint(e1, it.entities[0]);
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(ecs_pair(Likes, e3), ecs_field_id(&it, 0));
+        test_uint(ecs_pair(Likes, e2), ecs_field_id(&it, 1));
+        test_uint(e2, ecs_field_src(&it, 0));
+        test_uint(0, ecs_field_src(&it, 1));
+        test_uint(e2, ecs_iter_get_var(&it, x_var));
+        test_uint(e3, ecs_iter_get_var(&it, this_var));
+        test_uint(e3, it.entities[0]);
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_0_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, ""));
+    test_uint(it.variables[x_var].entity, EcsWildcard);
+    test_uint(it.variables[y_var].entity, EcsWildcard);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_1_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, "x:e1"));
+    test_uint(it.variables[x_var].entity, e1);
+    test_uint(it.variables[y_var].entity, EcsWildcard);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_2_vars(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, "x:e1,y:e2"));
+    test_uint(it.variables[x_var].entity, e1);
+    test_uint(it.variables[y_var].entity, e2);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_0_var_paren(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, "()"));
+    test_uint(it.variables[x_var].entity, EcsWildcard);
+    test_uint(it.variables[y_var].entity, EcsWildcard);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_1_var_paren(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, "(x:e1)"));
+    test_uint(it.variables[x_var].entity, e1);
+    test_uint(it.variables[y_var].entity, EcsWildcard);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_2_vars_paren(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, "(x:e1,y:e2)"));
+    test_uint(it.variables[x_var].entity, e1);
+    test_uint(it.variables[y_var].entity, e2);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_1_vars_w_path(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "parent.e1" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, "x:parent.e1"));
+    test_uint(it.variables[x_var].entity, e1);
+    test_uint(it.variables[y_var].entity, EcsWildcard);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_missing_close_paren(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_log_set_level(-4);
+    test_str(NULL, ecs_query_args_parse(q, &it, "(x:e1"));
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_missing_open_paren(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_log_set_level(-4);
+    test_str(NULL, ecs_query_args_parse(q, &it, "x:e1)"));
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_missing_value(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    ecs_log_set_level(-4);
+    test_str(NULL, ecs_query_args_parse(q, &it, "x:"));
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_0_var_w_spaces(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, "  "));
+    test_uint(it.variables[x_var].entity, EcsWildcard);
+    test_uint(it.variables[y_var].entity, EcsWildcard);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_1_var_w_spaces(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, "  x  :  e1  "));
+    test_uint(it.variables[x_var].entity, e1);
+    test_uint(it.variables[y_var].entity, EcsWildcard);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_2_vars_w_spaces(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("", ecs_query_args_parse(q, &it, "  x  :  e1  ,  y  :  e2  "));
+    test_uint(it.variables[x_var].entity, e1);
+    test_uint(it.variables[y_var].entity, e2);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_0_var_paren_w_spaces(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("  ", ecs_query_args_parse(q, &it, "  (  )  "));
+    test_uint(it.variables[x_var].entity, EcsWildcard);
+    test_uint(it.variables[y_var].entity, EcsWildcard);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_1_var_paren_w_spaces(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("  ", ecs_query_args_parse(q, &it, "  (  x  :  e1  )  "));
+    test_uint(it.variables[x_var].entity, e1);
+    test_uint(it.variables[y_var].entity, EcsWildcard);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_parse_2_vars_paren_w_spaces(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_entity_t e1 = ecs_entity(world, { .name = "e1" });
+    ecs_entity_t e2 = ecs_entity(world, { .name = "e2" });
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_str("  ", ecs_query_args_parse(q, &it, "  (  x  :  e1  ,  y  :  e2  )  "));
+    test_uint(it.variables[x_var].entity, e1);
+    test_uint(it.variables[y_var].entity, e2);
+    ecs_iter_fini(&it);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_var_count(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y), $x($this), $y($this)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    test_int(ecs_query_var_count(q), 3);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_var_name(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y), $x($this), $y($this)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    test_str(ecs_query_var_name(q, x_var), "x");
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+    test_str(ecs_query_var_name(q, y_var), "y");
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_str(ecs_query_var_name(q, this_var), "this");
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_var_is_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "$x($this, $y), $x($this), $y($this)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    test_bool(ecs_query_var_is_entity(q, x_var), true);
+
+    int y_var = ecs_query_find_var(q, "y");
+    test_assert(y_var != -1);
+    test_bool(ecs_query_var_is_entity(q, y_var), true);
+
+    int this_var = ecs_query_find_var(q, "this");
+    test_assert(this_var != -1);
+    test_bool(ecs_query_var_is_entity(q, this_var), false);
+    
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_no_this_anonymous_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t e = ecs_new_w_id(world, TagA);
+    test_assert(e != 0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($_x)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_no_this_anonymous_src_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_id(world, TagA);
+    test_assert(e != 0);
+    ecs_add_pair(world, e, EcsChildOf, parent);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($_x), ChildOf($_x, $Parent)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    int parent_var = ecs_query_find_var(q, "Parent");
+    test_assert(parent_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_uint(0, it.count);
+    test_uint(TagA, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, parent), ecs_field_id(&it, 1));
+    test_uint(parent, ecs_iter_get_var(&it, parent_var));
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_no_this_anonymous_component_src(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t e = ecs_new_w(world, Position);
+    test_assert(e != 0);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position($x)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q != NULL);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(ecs_query_next(&it), true);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_bool(ecs_query_next(&it), false);
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_no_this_anonymous_component_src_w_pair(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e = ecs_new_w(world, Position);
+    test_assert(e != 0);
+    ecs_add_pair(world, e, EcsChildOf, parent);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position($_x), ChildOf($_x, $Parent)",
+        .cache_kind = cache_kind
+    });
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_table_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t p1 = ecs_new_w(world, TagA);
+    ecs_new_w(world, TagA);
+    ecs_entity_t p3 = ecs_new_w(world, TagA);
+    ecs_entity_t p4 = ecs_new_w(world, TagA);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, p1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, p3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, p4);
+    ecs_add(world, child_1, TagB);
+    ecs_add(world, child_4, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, TagB($this.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t child_var = ecs_query_find_var(q, "this.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p4, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(child_4, ecs_field_src(&it, 1));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_entity_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new(world);
+    ecs_entity_t t3 = ecs_new(world);
+    ecs_entity_t t4 = ecs_new(world);
+
+    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
+    ecs_new_w_pair(world, Rel, t2);
+    ecs_new_w_pair(world, Rel, t3);
+    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, t1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, t3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, t4);
+    ecs_add(world, child_1, TagB);
+    ecs_add(world, child_4, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Rel($x, $this), TagB($this.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "this.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(t1, it.entities[0]);
+        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 0));
+        test_uint(p1, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(p1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(t4, it.entities[0]);
+        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 0));
+        test_uint(p4, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(child_4, ecs_field_src(&it, 1));
+        test_uint(p4, ecs_iter_get_var(&it, x_var));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_table(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t p1 = ecs_new_w(world, TagA);
+    ecs_new_w(world, TagA);
+    ecs_entity_t p3 = ecs_new_w(world, TagA);
+    ecs_entity_t p4 = ecs_new_w(world, TagA);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, p1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, p3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, p4);
+    ecs_add(world, child_1, TagB);
+    ecs_add(world, child_4, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($x), TagB($x.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "x.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(p1, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(p1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(p4, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(p4, ecs_iter_get_var(&it, x_var));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_entity(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new(world);
+    ecs_entity_t t3 = ecs_new(world);
+    ecs_entity_t t4 = ecs_new(world);
+
+    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
+    ecs_new_w_pair(world, Rel, t2);
+    ecs_new_w_pair(world, Rel, t3);
+    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, t1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, t3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, t4);
+    ecs_add(world, child_1, TagB);
+    ecs_add(world, child_4, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, $x), TagB($x.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "x.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p1, it.entities[0]);
+        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(t1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p4, it.entities[0]);
+        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(child_4, ecs_field_src(&it, 1));
+        test_uint(t4, ecs_iter_get_var(&it, x_var));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_not_written(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+
+    ecs_log_set_level(-4);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($this.foo)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_table_this_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t p1 = ecs_new_w(world, TagA);
+    ecs_new_w(world, TagA);
+    ecs_entity_t p3 = ecs_new_w(world, TagA);
+    ecs_entity_t p4 = ecs_new_w(world, TagA);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, p1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, p3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, p4);
+    ecs_set(world, child_1, Position, {10, 20});
+    ecs_set(world, child_4, Position, {11, 22});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, Position($this.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t child_var = ecs_query_find_var(q, "this.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+        {
+            Position *ptr = ecs_field(&it, Position, 1);
+            test_assert(ptr != NULL);
+            test_int(ptr->x, 10);
+            test_int(ptr->y, 20);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p4, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(child_4, ecs_field_src(&it, 1));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+        {
+            Position *ptr = ecs_field(&it, Position, 1);
+            test_assert(ptr != NULL);
+            test_int(ptr->x, 11);
+            test_int(ptr->y, 22);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_entity_this_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new(world);
+    ecs_entity_t t3 = ecs_new(world);
+    ecs_entity_t t4 = ecs_new(world);
+
+    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
+    ecs_new_w_pair(world, Rel, t2);
+    ecs_new_w_pair(world, Rel, t3);
+    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, t1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, t3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, t4);
+    ecs_set(world, child_1, Position, {10, 20});
+    ecs_set(world, child_4, Position, {11, 22});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Rel($x, $this), Position($this.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "this.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(t1, it.entities[0]);
+        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 0));
+        test_uint(p1, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(p1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+        {
+            Position *ptr = ecs_field(&it, Position, 1);
+            test_assert(ptr != NULL);
+            test_int(ptr->x, 10);
+            test_int(ptr->y, 20);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(t4, it.entities[0]);
+        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 0));
+        test_uint(p4, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(child_4, ecs_field_src(&it, 1));
+        test_uint(p4, ecs_iter_get_var(&it, x_var));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+        {
+            Position *ptr = ecs_field(&it, Position, 1);
+            test_assert(ptr != NULL);
+            test_int(ptr->x, 11);
+            test_int(ptr->y, 22);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_table_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t p1 = ecs_new_w(world, TagA);
+    ecs_new_w(world, TagA);
+    ecs_entity_t p3 = ecs_new_w(world, TagA);
+    ecs_entity_t p4 = ecs_new_w(world, TagA);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, p1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, p3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, p4);
+    ecs_set(world, child_1, Position, {10, 20});
+    ecs_set(world, child_4, Position, {11, 22});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($x), Position($x.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "x.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(p1, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(p1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+        {
+            Position *ptr = ecs_field(&it, Position, 1);
+            test_assert(ptr != NULL);
+            test_int(ptr->x, 10);
+            test_int(ptr->y, 20);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(p4, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(p4, ecs_iter_get_var(&it, x_var));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+        {
+            Position *ptr = ecs_field(&it, Position, 1);
+            test_assert(ptr != NULL);
+            test_int(ptr->x, 11);
+            test_int(ptr->y, 22);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_entity_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_COMPONENT(world, Position);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new(world);
+    ecs_entity_t t3 = ecs_new(world);
+    ecs_entity_t t4 = ecs_new(world);
+
+    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
+    ecs_new_w_pair(world, Rel, t2);
+    ecs_new_w_pair(world, Rel, t3);
+    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, t1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, t3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, t4);
+    ecs_set(world, child_1, Position, {10, 20});
+    ecs_set(world, child_4, Position, {11, 22});
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, $x), Position($x.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "x.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p1, it.entities[0]);
+        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(t1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+        {
+            Position *ptr = ecs_field(&it, Position, 1);
+            test_assert(ptr != NULL);
+            test_int(ptr->x, 10);
+            test_int(ptr->y, 20);
+        }
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p4, it.entities[0]);
+        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(ecs_id(Position), ecs_field_id(&it, 1));
+        test_uint(child_4, ecs_field_src(&it, 1));
+        test_uint(t4, ecs_iter_get_var(&it, x_var));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+        {
+            Position *ptr = ecs_field(&it, Position, 1);
+            test_assert(ptr != NULL);
+            test_int(ptr->x, 11);
+            test_int(ptr->y, 22);
+        }
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_table_two_children(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t p1 = ecs_entity(world, { .name = "p1" }); ecs_add(world, p1, TagA);
+    ecs_new_w(world, TagA);
+    ecs_entity_t p3 = ecs_entity(world, { .name = "p3" }); ecs_add(world, p3, TagA);
+    ecs_entity_t p4 = ecs_entity(world, { .name = "p4" }); ecs_add(world, p4, TagA);
+
+    ecs_entity_t child_a_1 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_1, EcsChildOf, p1);
+    ecs_entity_t child_a_3 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_3, EcsChildOf, p3);
+    ecs_entity_t child_a_4 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_4, EcsChildOf, p4);
+    ecs_add(world, child_a_1, TagB);
+    ecs_add(world, child_a_4, TagB);
+
+    ecs_entity_t child_b_1 = ecs_entity(world, { .name = "child_b" });
+    ecs_add_pair(world, child_b_1, EcsChildOf, p1);
+    ecs_entity_t child_b_3 = ecs_entity(world, { .name = "child_b" });
+    ecs_add_pair(world, child_b_3, EcsChildOf, p3);
+    ecs_entity_t child_b_4 = ecs_entity(world, { .name = "child_b" });
+    ecs_add_pair(world, child_b_4, EcsChildOf, p4);
+    ecs_add(world, child_b_1, TagC);
+    ecs_add(world, child_b_3, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, TagB($this.child_a), TagC($this.child_b)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t child_a_var = ecs_query_find_var(q, "this.child_a");
+    test_assert(child_a_var != -1);
+    int32_t child_b_var = ecs_query_find_var(q, "this.child_b");
+    test_assert(child_b_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(child_a_1, ecs_field_src(&it, 1));
+        test_uint(child_b_1, ecs_field_src(&it, 2));
+        test_uint(child_a_1, ecs_iter_get_var(&it, child_a_var));
+        test_uint(child_b_1, ecs_iter_get_var(&it, child_b_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_entity_two_children(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new(world);
+    ecs_entity_t t3 = ecs_new(world);
+    ecs_entity_t t4 = ecs_new(world);
+
+    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
+    ecs_new_w_pair(world, Rel, t2);
+    ecs_new_w_pair(world, Rel, t3);
+    ecs_new_w_pair(world, Rel, t4);
+
+    ecs_entity_t child_a_1 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_1, EcsChildOf, t1);
+    ecs_entity_t child_a_3 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_3, EcsChildOf, t3);
+    ecs_entity_t child_a_4 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_4, EcsChildOf, t4);
+    ecs_add(world, child_a_1, TagB);
+    ecs_add(world, child_a_4, TagB);
+
+    ecs_entity_t child_b_1 = ecs_entity(world, { .name = "child_b" });
+    ecs_add_pair(world, child_b_1, EcsChildOf, t1);
+    ecs_entity_t child_b_3 = ecs_entity(world, { .name = "child_b" });
+    ecs_add_pair(world, child_b_3, EcsChildOf, t3);
+    ecs_entity_t child_b_4 = ecs_entity(world, { .name = "child_b" });
+    ecs_add_pair(world, child_b_4, EcsChildOf, t4);
+    ecs_add(world, child_b_1, TagC);
+    ecs_add(world, child_b_3, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, $x), TagB($x.child_a), TagC($x.child_b)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_a_var = ecs_query_find_var(q, "x.child_a");
+    test_assert(child_a_var != -1);
+    int32_t child_b_var = ecs_query_find_var(q, "x.child_b");
+    test_assert(child_b_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p1, it.entities[0]);
+        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(child_a_1, ecs_field_src(&it, 1));
+        test_uint(child_b_1, ecs_field_src(&it, 2));
+        test_uint(t1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_a_1, ecs_iter_get_var(&it, child_a_var));
+        test_uint(child_b_1, ecs_iter_get_var(&it, child_b_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_table_same_child_twice(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t p1 = ecs_entity(world, { .name = "p1" }); ecs_add(world, p1, TagA);
+    ecs_new_w(world, TagA);
+    ecs_entity_t p3 = ecs_entity(world, { .name = "p3" }); ecs_add(world, p3, TagA);
+    ecs_entity_t p4 = ecs_entity(world, { .name = "p4" }); ecs_add(world, p4, TagA);
+
+    ecs_entity_t child_a_1 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_1, EcsChildOf, p1);
+    ecs_entity_t child_a_3 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_3, EcsChildOf, p3);
+    ecs_entity_t child_a_4 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_4, EcsChildOf, p4);
+    ecs_add(world, child_a_1, TagB);
+    ecs_add(world, child_a_4, TagB);
+    ecs_add(world, child_a_1, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA, TagB($this.child_a), TagC($this.child_a)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t child_a_var = ecs_query_find_var(q, "this.child_a");
+    test_assert(child_a_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p1, it.entities[0]);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(child_a_1, ecs_field_src(&it, 1));
+        test_uint(child_a_1, ecs_field_src(&it, 2));
+        test_uint(child_a_1, ecs_iter_get_var(&it, child_a_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_entity_same_child_twice(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new(world);
+    ecs_entity_t t3 = ecs_new(world);
+    ecs_entity_t t4 = ecs_new(world);
+
+    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
+    ecs_new_w_pair(world, Rel, t2);
+    ecs_new_w_pair(world, Rel, t3);
+    ecs_new_w_pair(world, Rel, t4);
+
+    ecs_entity_t child_a_1 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_1, EcsChildOf, t1);
+    ecs_entity_t child_a_3 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_3, EcsChildOf, t3);
+    ecs_entity_t child_a_4 = ecs_entity(world, { .name = "child_a" });
+    ecs_add_pair(world, child_a_4, EcsChildOf, t4);
+    ecs_add(world, child_a_1, TagB);
+    ecs_add(world, child_a_4, TagB);
+    ecs_add(world, child_a_1, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, $x), TagB($x.child_a), TagC($x.child_a)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_a_var = ecs_query_find_var(q, "x.child_a");
+    test_assert(child_a_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p1, it.entities[0]);
+        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(TagC, ecs_field_id(&it, 2));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(child_a_1, ecs_field_src(&it, 1));
+        test_uint(child_a_1, ecs_field_src(&it, 2));
+        test_uint(t1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_a_1, ecs_iter_get_var(&it, child_a_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_table_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t p1 = ecs_new_w(world, TagA); ecs_set_name(world, p1, "p1");
+    ecs_entity_t p2 = ecs_new_w(world, TagA); ecs_set_name(world, p2, "p2");
+    ecs_entity_t p3 = ecs_new_w(world, TagA); ecs_set_name(world, p3, "p3");
+    ecs_entity_t p4 = ecs_new_w(world, TagA); ecs_set_name(world, p4, "p4");
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, p1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, p3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, p4);
+    ecs_add(world, child_1, TagB);
+    ecs_add(world, child_4, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($x), !TagB($x.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "x.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(p2, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(p2, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, child_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_uint(p3, ecs_field_src(&it, 0));
+        test_bool(true, ecs_field_is_set(&it, 0));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(p3, ecs_iter_get_var(&it, x_var));
+        test_uint(child_3, ecs_iter_get_var(&it, child_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_entity_not(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new(world);
+    ecs_entity_t t3 = ecs_new(world);
+    ecs_entity_t t4 = ecs_new(world);
+
+    ecs_new_w_pair(world, Rel, t1);
+    ecs_entity_t p2 = ecs_new_w_pair(world, Rel, t2);
+    ecs_entity_t p3 = ecs_new_w_pair(world, Rel, t3);
+    ecs_new_w_pair(world, Rel, t4);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, t1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, t3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, t4);
+    ecs_add(world, child_1, TagB);
+    ecs_add(world, child_4, TagB);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, $x), !TagB($x.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "x.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p2, it.entities[0]);
+        test_uint(ecs_pair(Rel, t2), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(t2, ecs_iter_get_var(&it, x_var));
+        test_uint(EcsWildcard, ecs_iter_get_var(&it, child_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p3, it.entities[0]);
+        test_uint(ecs_pair(Rel, t3), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(TagB, ecs_field_id(&it, 1));
+        test_bool(false, ecs_field_is_set(&it, 1));
+        test_uint(t3, ecs_iter_get_var(&it, x_var));
+        test_uint(child_3, ecs_iter_get_var(&it, child_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_table_w_any_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t p1 = ecs_new_w(world, TagA);
+    ecs_new_w(world, TagA);
+    ecs_entity_t p3 = ecs_new_w(world, TagA);
+    ecs_entity_t p4 = ecs_new_w(world, TagA);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, p1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, p3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, p4);
+    ecs_add(world, child_1, TagB);
+    ecs_add(world, child_4, TagB);
+    ecs_add(world, child_4, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "TagA($x), _($x.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "x.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(p1, ecs_field_src(&it, 0));
+        test_uint(EcsWildcard, ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(p1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(0, it.count);
+        test_uint(TagA, ecs_field_id(&it, 0));
+        test_uint(p4, ecs_field_src(&it, 0));
+        test_uint(EcsWildcard, ecs_field_id(&it, 1));
+        test_uint(p4, ecs_iter_get_var(&it, x_var));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_from_entity_w_any_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, TagA);
+    ECS_TAG(world, TagB);
+    ECS_TAG(world, TagC);
+
+    ecs_entity_t t1 = ecs_new(world);
+    ecs_entity_t t2 = ecs_new(world);
+    ecs_entity_t t3 = ecs_new(world);
+    ecs_entity_t t4 = ecs_new(world);
+
+    ecs_entity_t p1 = ecs_new_w_pair(world, Rel, t1);
+    ecs_new_w_pair(world, Rel, t2);
+    ecs_new_w_pair(world, Rel, t3);
+    ecs_entity_t p4 = ecs_new_w_pair(world, Rel, t4);
+
+    ecs_entity_t child_1 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_1, EcsChildOf, t1);
+    ecs_entity_t child_3 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_3, EcsChildOf, t3);
+    ecs_entity_t child_4 = ecs_entity(world, { .name = "child" });
+    ecs_add_pair(world, child_4, EcsChildOf, t4);
+    ecs_add(world, child_1, TagB);
+    ecs_add(world, child_4, TagB);
+    ecs_add(world, child_4, TagC);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "(Rel, $x), _($x.child)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int32_t x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int32_t child_var = ecs_query_find_var(q, "x.child");
+    test_assert(child_var != -1);
+
+    {
+        ecs_iter_t it = ecs_query_iter(world, q);
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p1, it.entities[0]);
+        test_uint(ecs_pair(Rel, t1), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(EcsWildcard, ecs_field_id(&it, 1));
+        test_uint(child_1, ecs_field_src(&it, 1));
+        test_uint(t1, ecs_iter_get_var(&it, x_var));
+        test_uint(child_1, ecs_iter_get_var(&it, child_var));
+
+        test_bool(true, ecs_query_next(&it));
+        test_uint(1, it.count);
+        test_uint(p4, it.entities[0]);
+        test_uint(ecs_pair(Rel, t4), ecs_field_id(&it, 0));
+        test_uint(0, ecs_field_src(&it, 0));
+        test_uint(EcsWildcard, ecs_field_id(&it, 1));
+        test_uint(child_4, ecs_field_src(&it, 1));
+        test_uint(t4, ecs_iter_get_var(&it, x_var));
+        test_uint(child_4, ecs_iter_get_var(&it, child_var));
+
+        test_bool(false, ecs_query_next(&it));
+    }
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_as_tag(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent_a = ecs_new_w(world, Foo);
+    ecs_entity_t parent_b = ecs_new_w(world, Foo);
+    ecs_entity_t parent_c = ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    ecs_entity_t tag_a = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_a, EcsChildOf, parent_a);
+
+    ecs_entity_t tag_b = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_b, EcsChildOf, parent_b);
+
+    ecs_entity_t tag_c = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_c, EcsChildOf, parent_c);
+
+    ecs_entity_t a = ecs_new_w_id(world, tag_a);
+    ecs_entity_t c = ecs_new_w_id(world, tag_c);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, $this.Tag($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int tag_var = ecs_query_find_var(q, "this.Tag");
+    test_assert(tag_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(tag_a, ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(a, ecs_field_src(&it, 1));
+    test_uint(a, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_a, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_c, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(tag_c, ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(c, ecs_field_src(&it, 1));
+    test_uint(c, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_c, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_as_relationship(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Tgt);
+
+    ecs_entity_t parent_a = ecs_new_w(world, Foo);
+    ecs_entity_t parent_b = ecs_new_w(world, Foo);
+    ecs_entity_t parent_c = ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    ecs_entity_t tag_a = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_a, EcsChildOf, parent_a);
+
+    ecs_entity_t tag_b = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_b, EcsChildOf, parent_b);
+
+    ecs_entity_t tag_c = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_c, EcsChildOf, parent_c);
+
+    ecs_entity_t a = ecs_new_w_pair(world, tag_a, Tgt);
+    ecs_entity_t c = ecs_new_w_pair(world, tag_c, Tgt);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, $this.Tag($x, Tgt)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int tag_var = ecs_query_find_var(q, "this.Tag");
+    test_assert(tag_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(tag_a, Tgt), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(a, ecs_field_src(&it, 1));
+    test_uint(a, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_a, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_c, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(tag_c, Tgt), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(c, ecs_field_src(&it, 1));
+    test_uint(c, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_c, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_as_target(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent_a = ecs_new_w(world, Foo);
+    ecs_entity_t parent_b = ecs_new_w(world, Foo);
+    ecs_entity_t parent_c = ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    ecs_entity_t tag_a = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_a, EcsChildOf, parent_a);
+
+    ecs_entity_t tag_b = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_b, EcsChildOf, parent_b);
+
+    ecs_entity_t tag_c = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_c, EcsChildOf, parent_c);
+
+    ecs_entity_t a = ecs_new_w_pair(world, Rel, tag_a);
+    ecs_entity_t c = ecs_new_w_pair(world, Rel, tag_c);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, Rel($x, $this.Tag)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int tag_var = ecs_query_find_var(q, "this.Tag");
+    test_assert(tag_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, tag_a), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(a, ecs_field_src(&it, 1));
+    test_uint(a, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_a, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_c, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(Rel, tag_c), ecs_field_id(&it, 1));
+    test_uint(0, ecs_field_src(&it, 0));
+    test_uint(c, ecs_field_src(&it, 1));
+    test_uint(c, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_c, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_assign_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent_a = ecs_new_w(world, Foo);
+    ecs_entity_t parent_b = ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    ecs_entity_t tag_a = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_a, EcsChildOf, parent_a);
+
+    ecs_entity_t tag_b = ecs_entity(world, { .name = "Tag" });
+    ecs_add_pair(world, tag_b, EcsChildOf, parent_b);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, $x == $this.Tag",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int tag_var = ecs_query_find_var(q, "this.Tag");
+    test_assert(tag_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(tag_a, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_a, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_b, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(tag_b, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_b, ecs_iter_get_var(&it, tag_var));
+    
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_eq_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent_a = ecs_new_w(world, Foo);
+    ecs_entity_t parent_b = ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    ecs_entity_t tag_ax = ecs_entity(world, { .name = "TagX" });
+    ecs_add_pair(world, tag_ax, EcsChildOf, parent_a);
+    ecs_entity_t tag_ay = ecs_entity(world, { .name = "TagY" });
+    ecs_add_pair(world, tag_ay, EcsChildOf, parent_a);
+    ecs_entity_t tag_az = ecs_entity(world, { .name = "TagZ" });
+    ecs_add_pair(world, tag_az, EcsChildOf, parent_a);
+
+    ecs_entity_t tag_bx = ecs_entity(world, { .name = "TagX" });
+    ecs_add_pair(world, tag_bx, EcsChildOf, parent_b);
+    ecs_entity_t tag_by = ecs_entity(world, { .name = "TagY" });
+    ecs_add_pair(world, tag_by, EcsChildOf, parent_b);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, ChildOf($x, $this), $x == $this.TagY",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int tag_var = ecs_query_find_var(q, "this.TagY");
+    test_assert(tag_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_childof(parent_a), ecs_field_id(&it, 1));
+    test_uint(tag_ay, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_ay, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_b, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_childof(parent_b), ecs_field_id(&it, 1));
+    test_uint(tag_by, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_by, ecs_iter_get_var(&it, tag_var));
+    
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_neq_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Foo);
+
+    ecs_entity_t parent_a = ecs_new_w(world, Foo);
+    ecs_entity_t parent_b = ecs_new_w(world, Foo);
+    ecs_new_w(world, Foo);
+
+    ecs_entity_t tag_ax = ecs_entity(world, { .name = "TagX" });
+    ecs_add_pair(world, tag_ax, EcsChildOf, parent_a);
+    ecs_entity_t tag_ay = ecs_entity(world, { .name = "TagY" });
+    ecs_add_pair(world, tag_ay, EcsChildOf, parent_a);
+    ecs_entity_t tag_az = ecs_entity(world, { .name = "TagZ" });
+    ecs_add_pair(world, tag_az, EcsChildOf, parent_a);
+
+    ecs_entity_t tag_bx = ecs_entity(world, { .name = "TagX" });
+    ecs_add_pair(world, tag_bx, EcsChildOf, parent_b);
+    ecs_entity_t tag_by = ecs_entity(world, { .name = "TagY" });
+    ecs_add_pair(world, tag_by, EcsChildOf, parent_b);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo, ChildOf($x, $this), $x != $this.TagY",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+    int tag_var = ecs_query_find_var(q, "this.TagY");
+    test_assert(tag_var != -1);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_childof(parent_a), ecs_field_id(&it, 1));
+    test_uint(tag_ax, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_ay, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_a, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_childof(parent_a), ecs_field_id(&it, 1));
+    test_uint(tag_az, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_ay, ecs_iter_get_var(&it, tag_var));
+
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(parent_b, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_childof(parent_b), ecs_field_id(&it, 1));
+    test_uint(tag_bx, ecs_iter_get_var(&it, x_var));
+    test_uint(tag_by, ecs_iter_get_var(&it, tag_var));
+    
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_lookup_unresolved_dependent(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_log_set_level(-4);
+    ecs_query_t *r = ecs_query(world, {
+        .expr = "(ChildOf, $_tgt), ChildOf(flecs, $tgt.child)"
+    });
+
+    test_assert(r == NULL);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_this(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(1, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(2, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+    test_str("x", ecs_query_var_name(q, 1));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "*",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(1, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "_",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(1, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_var_as_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), ChildOf($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(2, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+    test_str("x", ecs_query_var_name(q, 1));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_this_as_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), ChildOf($x, $this)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(3, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0)); // table
+    test_str("x", ecs_query_var_name(q, 1));
+    test_str("this", ecs_query_var_name(q, 2)); // entity
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_this_w_lookup_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), ChildOf($x, $this.var)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(4, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+    test_str("x", ecs_query_var_name(q, 1));
+    test_str("this.var", ecs_query_var_name(q, 2));
+    test_str("this", ecs_query_var_name(q, 3));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_var_w_lookup_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($y), ChildOf($x, $y.var)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(4, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+    test_str("y", ecs_query_var_name(q, 1));
+    test_str("x", ecs_query_var_name(q, 2));
+    test_str("y.var", ecs_query_var_name(q, 3));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_anonymous_var_as_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), ChildOf($this, $_x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(2, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+    test_str("_x", ecs_query_var_name(q, 1));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_wildcard_as_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), ChildOf($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(1, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_check_vars_any_as_tgt(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo($this), ChildOf($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+    test_int(1, ecs_query_var_count(q));
+    test_str("this", ecs_query_var_name(q, 0));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_trivial_1_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(self), ChildOf($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, e, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 1));
+    test_uint(p, ecs_iter_get_var(&it, x_var));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_trivial_1_var(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(self), Bar(self), ChildOf($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, e, Foo);
+    ecs_add(world, e, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(Bar, ecs_field_id(&it, 1));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 2));
+    test_uint(p, ecs_iter_get_var(&it, x_var));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_trivial_1_var_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self), ChildOf($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_set(world, e, Position, {10, 20});
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_uint(p, ecs_iter_get_var(&it, x_var));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_trivial_1_var_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self), Velocity(self), ChildOf($this, $x)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    int x_var = ecs_query_find_var(q, "x");
+    test_assert(x_var != -1);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_set(world, e, Position, {10, 20});
+    ecs_set(world, e, Velocity, {1, 2});
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 2));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_assert(ecs_field(&it, Velocity, 1) != NULL);
+    {
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+    test_uint(p, ecs_iter_get_var(&it, x_var));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_trivial_1_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(self), ChildOf($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, e, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 1));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_trivial_1_wildcard(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(self), Bar(self), ChildOf($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, e, Foo);
+    ecs_add(world, e, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(Bar, ecs_field_id(&it, 1));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 2));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_trivial_1_wildcard_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self), ChildOf($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_set(world, e, Position, {10, 20});
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_trivial_1_wildcard_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self), Velocity(self), ChildOf($this, *)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_set(world, e, Position, {10, 20});
+    ecs_set(world, e, Velocity, {1, 2});
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_pair(EcsChildOf, p), ecs_field_id(&it, 2));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_assert(ecs_field(&it, Velocity, 1) != NULL);
+    {
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_trivial_1_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(self), ChildOf($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, e, Foo);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 1));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_trivial_1_any(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Foo);
+    ECS_TAG(world, Bar);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Foo(self), Bar(self), ChildOf($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_add(world, e, Foo);
+    ecs_add(world, e, Bar);
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(Foo, ecs_field_id(&it, 0));
+    test_uint(Bar, ecs_field_id(&it, 1));
+    test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 2));
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_1_trivial_1_any_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self), ChildOf($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_set(world, e, Position, {10, 20});
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 1));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_2_trivial_1_any_component(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_query_t *q = ecs_query(world, {
+        .expr = "Position(self), Velocity(self), ChildOf($this, _)",
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q != NULL);
+
+    ecs_entity_t p = ecs_new(world);
+    ecs_entity_t e = ecs_new_w_pair(world, EcsChildOf, p);
+    ecs_set(world, e, Position, {10, 20});
+    ecs_set(world, e, Velocity, {1, 2});
+
+    ecs_iter_t it = ecs_query_iter(world, q);
+    test_bool(true, ecs_query_next(&it));
+    test_int(1, it.count);
+    test_uint(e, it.entities[0]);
+    test_uint(ecs_id(Position), ecs_field_id(&it, 0));
+    test_uint(ecs_id(Velocity), ecs_field_id(&it, 1));
+    test_uint(ecs_pair(EcsChildOf, EcsWildcard), ecs_field_id(&it, 2));
+    {
+        Position *p = ecs_field(&it, Position, 0);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+    test_assert(ecs_field(&it, Velocity, 1) != NULL);
+    {
+        Velocity *v = ecs_field(&it, Velocity, 1);
+        test_assert(v != NULL);
+        test_int(v->x, 1);
+        test_int(v->y, 2);
+    }
+    test_bool(false, ecs_query_next(&it));
+
+    ecs_query_fini(q);
+
+    ecs_fini(world);
+}
+
+void Variables_first_invalid_var_name_and_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = Tag, .first.name = "$this" }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void Variables_src_invalid_var_name_and_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = Tag, .src.id = Tag, .src.name = "$this" }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
+
+void Variables_second_invalid_var_name_and_id(void) {
+    ecs_world_t *world = ecs_mini();
+
+    ECS_TAG(world, Tag);
+
+    ecs_log_set_level(-4);
+    ecs_query_t *q = ecs_query(world, {
+        .terms = {
+            { .first.id = Tag, .second.id = Tag, .second.name = "$this" }
+        },
+        .cache_kind = cache_kind
+    });
+
+    test_assert(q == NULL);
+
+    ecs_fini(world);
+}
diff --git a/test/query/src/main.c b/test/query/src/main.c
new file mode 100644
index 000000000..2b12dd363
--- /dev/null
+++ b/test/query/src/main.c
@@ -0,0 +1,9037 @@
+
+/* A friendly warning from bake.test
+ * ----------------------------------------------------------------------------
+ * This file is generated. To add/remove testcases modify the 'project.json' of
+ * the test project. ANY CHANGE TO THIS FILE IS LOST AFTER (RE)BUILDING!
+ * ----------------------------------------------------------------------------
+ */
+
+#include <query.h>
+
+// Testsuite 'Validator'
+void Validator_validate_1_term(void);
+void Validator_validate_1_term_component(void);
+void Validator_validate_2_terms(void);
+void Validator_validate_3_terms(void);
+void Validator_validate_3_terms_w_or(void);
+void Validator_validate_4_terms_w_or_at_1(void);
+void Validator_validate_1_term_wildcard(void);
+void Validator_validate_1_term_any(void);
+void Validator_validate_1_term_same_subj_obj(void);
+void Validator_validate_1_term_acyclic_same_subj_obj(void);
+void Validator_validate_1_term_acyclic_reflexive_same_subj_obj(void);
+void Validator_validate_1_term_same_subj_obj_var(void);
+void Validator_validate_1_term_acyclic_same_subj_obj_var(void);
+void Validator_validate_1_term_acyclic_reflexive_same_subj_obj_var(void);
+void Validator_validate_1_term_non_acyclic_superset(void);
+void Validator_validate_1_term_dont_inherit_default_set(void);
+void Validator_validate_1_term_dont_inherit_pair_default_set(void);
+void Validator_validate_1_term_cascade_implicit_trav(void);
+void Validator_validate_1_term_cascade_isa(void);
+void Validator_validate_1_term_cascade_childof(void);
+void Validator_validate_1_term_cascade_down(void);
+void Validator_validate_1_term_optional_only(void);
+void Validator_validate_1_term_transitive_pair(void);
+void Validator_validate_1_variable_as_pred_only(void);
+void Validator_validate_1_variable_as_pred_w_subj(void);
+void Validator_validate_1_variable_as_pred_w_pair(void);
+void Validator_validate_1_variable_as_subj(void);
+void Validator_validate_1_variable_as_obj(void);
+void Validator_validate_2_terms_or_w_dontinherit(void);
+void Validator_validate_2_terms_or_w_both_dontinherit(void);
+void Validator_validate_w_pair_id(void);
+void Validator_validate_w_pred_obj(void);
+void Validator_validate_w_pair_id_and_subj(void);
+void Validator_validate_1_w_pred_name(void);
+void Validator_validate_1_w_final_pred_name(void);
+void Validator_validate_1_w_subj_name(void);
+void Validator_validate_1_w_obj_name(void);
+void Validator_validate_w_this_implicit_variable(void);
+void Validator_validate_w_this_explicit_entity(void);
+void Validator_validate_w_first_this_implicit_variable(void);
+void Validator_validate_w_first_this_explicit_entity(void);
+void Validator_validate_w_second_this_implicit_variable(void);
+void Validator_validate_w_second_this_explicit_entity(void);
+void Validator_validate_w_this_variable_name(void);
+void Validator_validate_w_src_var(void);
+void Validator_validate_w_first_var(void);
+void Validator_validate_w_second_var(void);
+void Validator_validate_w_src_var_from_name(void);
+void Validator_validate_w_first_first_var(void);
+void Validator_validate_w_second_second_var(void);
+void Validator_validate_w_0_source(void);
+void Validator_validate_w_0_target(void);
+void Validator_validate_2_terms_w_or(void);
+void Validator_validate_2_terms_w_or_mixed_src_flags(void);
+void Validator_validate_2_terms_w_or_mixed_src_id(void);
+void Validator_validate_2_terms_w_or_mixed_src_name(void);
+void Validator_validate_2_terms_w_or_same_src_w_id_and_name(void);
+void Validator_validate_w_and_flag(void);
+void Validator_validate_w_or_flag(void);
+void Validator_validate_w_not_flag(void);
+void Validator_validate_filter(void);
+void Validator_validate_double_init(void);
+void Validator_validate_double_init_w_expr(void);
+void Validator_validate_double_init_w_expr_optional(void);
+void Validator_validate_w_tag_term_is_no_data(void);
+void Validator_validate_w_inout_none_term_is_no_data(void);
+void Validator_validate_w_tag_and_inout_none_term_is_no_data(void);
+void Validator_validate_w_not_term_is_no_data(void);
+void Validator_validate_w_no_transitive_pair(void);
+void Validator_validate_w_transitive_pair_any_src(void);
+void Validator_validate_w_transitive_pair(void);
+void Validator_validate_w_transitive_tag_no_pair(void);
+void Validator_validate_w_transitive_tag_self_tgt(void);
+void Validator_validate_w_transitive_tag_any_tgt(void);
+void Validator_validate_w_pair_same_vars(void);
+void Validator_validate_w_pair_not_same_vars(void);
+void Validator_validate_w_pair_no_vars_not_same_vars(void);
+void Validator_validate_w_pair_wildcard_not_same_vars(void);
+void Validator_validate_w_pair_any_not_same_vars(void);
+void Validator_validate_w_no_pair_not_same_vars(void);
+void Validator_validate_not_childof_any(void);
+void Validator_validate_w_inherited_id(void);
+void Validator_validate_w_inherited_pair(void);
+void Validator_validate_w_non_inherited_id(void);
+void Validator_validate_w_non_inherited_pair(void);
+void Validator_validate_w_first_wildcard_inout_none(void);
+void Validator_validate_w_first_var_inout_none(void);
+void Validator_validate_w_pair_wildcard_inout_none(void);
+void Validator_validate_w_pair_var_inout_none(void);
+void Validator_validate_w_unresolved_by_name(void);
+void Validator_validate_w_unresolved_by_name_eq(void);
+void Validator_validate_childof_this(void);
+void Validator_validate_childof_this_entity(void);
+void Validator_validate_childof_this_by_id(void);
+void Validator_validate_filter_flag(void);
+void Validator_validate_first_0_name(void);
+void Validator_validate_src_0_name(void);
+void Validator_validate_second_0_name(void);
+void Validator_validate_singleton_src_w_first_name(void);
+void Validator_validate_singleton_second_w_first_name(void);
+
+// Testsuite 'Parser'
+void Parser_resolve_this(void);
+void Parser_resolve_wildcard(void);
+void Parser_resolve_any(void);
+void Parser_resolve_is_a(void);
+void Parser_0(void);
+void Parser_component_implicit_subject(void);
+void Parser_component_explicit_subject(void);
+void Parser_component_explicit_subject_this(void);
+void Parser_component_explicit_subject_this_by_name(void);
+void Parser_component_explicit_subject_this_by_var_name(void);
+void Parser_component_explicit_subject_wildcard(void);
+void Parser_component_explicit_subject_any(void);
+void Parser_component_explicit_subject_0(void);
+void Parser_this_as_predicate(void);
+void Parser_this_var_as_predicate(void);
+void Parser_this_lowercase_var_as_predicate(void);
+void Parser_this_as_object(void);
+void Parser_this_var_as_object(void);
+void Parser_pair_implicit_subject(void);
+void Parser_pair_implicit_subject_wildcard_pred(void);
+void Parser_pair_implicit_subject_wildcard_obj(void);
+void Parser_pair_implicit_subject_any_pred(void);
+void Parser_pair_implicit_subject_any_obj(void);
+void Parser_pair_implicit_subject_this_pred(void);
+void Parser_pair_implicit_subject_this_obj(void);
+void Parser_pair_implicit_subject_pred_w_self(void);
+void Parser_pair_implicit_subject_obj_w_self(void);
+void Parser_pair_implicit_subject_pred_w_up(void);
+void Parser_pair_implicit_subject_obj_w_up(void);
+void Parser_pair_implicit_subject_pred_w_self_up(void);
+void Parser_pair_implicit_subject_obj_w_self_up(void);
+void Parser_pair_implicit_subject_pred_w_invalid_flags(void);
+void Parser_pair_implicit_subject_obj_w_invalid_flags(void);
+void Parser_pair_explicit_subject(void);
+void Parser_pair_explicit_subject_this(void);
+void Parser_pair_explicit_subject_this_by_name(void);
+void Parser_pair_explicit_subject_this_by_var_name(void);
+void Parser_pair_explicit_subject_wildcard_pred(void);
+void Parser_pair_explicit_subject_wildcard_subj(void);
+void Parser_pair_explicit_subject_wildcard_obj(void);
+void Parser_pair_implicit_subject_0_object(void);
+void Parser_pair_explicit_subject_0_object(void);
+void Parser_pair_explicit_subject_0(void);
+void Parser_in_component_implicit_subject(void);
+void Parser_in_component_explicit_subject(void);
+void Parser_in_pair_implicit_subject(void);
+void Parser_in_pair_explicit_subject(void);
+void Parser_inout_component_implicit_subject(void);
+void Parser_inout_component_explicit_subject(void);
+void Parser_inout_pair_implicit_subject(void);
+void Parser_inout_pair_explicit_subject(void);
+void Parser_out_component_implicit_subject(void);
+void Parser_out_component_explicit_subject(void);
+void Parser_out_pair_implicit_subject(void);
+void Parser_out_pair_explicit_subject(void);
+void Parser_inout_filter_component(void);
+void Parser_inout_w_not_operator(void);
+void Parser_inout_w_optional_operator(void);
+void Parser_component_singleton(void);
+void Parser_this_singleton(void);
+void Parser_component_implicit_no_subject(void);
+void Parser_component_explicit_no_subject(void);
+void Parser_pair_no_subject(void);
+void Parser_variable_single_char(void);
+void Parser_variable_multi_char(void);
+void Parser_variable_multi_char_w_underscore(void);
+void Parser_variable_multi_char_w_number(void);
+void Parser_variable_multi_char_not_allcaps(void);
+void Parser_pred_var(void);
+void Parser_obj_var(void);
+void Parser_component_not(void);
+void Parser_pair_implicit_subject_not(void);
+void Parser_pair_explicit_subject_not(void);
+void Parser_2_component_not(void);
+void Parser_2_component_not_no_space(void);
+void Parser_component_optional(void);
+void Parser_2_component_optional(void);
+void Parser_2_component_optional_no_space(void);
+void Parser_from_and(void);
+void Parser_from_or(void);
+void Parser_from_not(void);
+void Parser_pair_implicit_subject_optional(void);
+void Parser_pair_explicit_subject_optional(void);
+void Parser_pred_implicit_subject_w_role(void);
+void Parser_pred_explicit_subject_w_role(void);
+void Parser_pred_no_subject_w_role(void);
+void Parser_pair_implicit_subject_w_role(void);
+void Parser_pair_explicit_subject_w_role(void);
+void Parser_inout_role_pred_implicit_subject(void);
+void Parser_inout_role_pred_no_subject(void);
+void Parser_inout_role_pred_explicit_subject(void);
+void Parser_inout_role_pair_implicit_subject(void);
+void Parser_inout_role_pair_explicit_subject(void);
+void Parser_2_pred_implicit_subject(void);
+void Parser_2_pred_no_subject(void);
+void Parser_2_pred_explicit_subject(void);
+void Parser_2_pair_implicit_subject(void);
+void Parser_2_pair_explicit_subject(void);
+void Parser_2_pred_role(void);
+void Parser_2_pair_implicit_subj_role(void);
+void Parser_2_pair_explicit_subj_role(void);
+void Parser_2_or_pred_implicit_subj(void);
+void Parser_2_or_pred_explicit_subj(void);
+void Parser_2_or_pair_implicit_subj(void);
+void Parser_2_or_pair_explicit_subj(void);
+void Parser_2_or_pred_inout(void);
+void Parser_2_or_no_space(void);
+void Parser_2_or_w_not_1st_arg(void);
+void Parser_2_or_w_not_2nd_arg(void);
+void Parser_2_or_w_optional_1st_arg(void);
+void Parser_2_or_w_optional_2nd_arg(void);
+void Parser_1_digit_pred_implicit_subj(void);
+void Parser_1_digit_pred_no_subj(void);
+void Parser_1_digit_pred_explicit_subj(void);
+void Parser_1_digit_pair_implicit_subj(void);
+void Parser_1_digit_pair_explicit_subj(void);
+void Parser_pred_implicit_subject_self(void);
+void Parser_pred_implicit_subject_superset(void);
+void Parser_pred_implicit_subject_superset_inclusive(void);
+void Parser_pred_implicit_subject_superset_cascade(void);
+void Parser_pred_implicit_subject_superset_inclusive_cascade(void);
+void Parser_pred_implicit_subject_implicit_superset_cascade(void);
+void Parser_pred_implicit_subject_implicit_superset_inclusive_cascade(void);
+void Parser_pred_implicit_subject_implicit_superset_cascade_w_rel(void);
+void Parser_pred_implicit_subject_implicit_superset_inclusive_cascade_w_rel(void);
+void Parser_pred_implicit_subject_superset_childof(void);
+void Parser_pred_implicit_subject_cascade_superset_childof(void);
+void Parser_pred_implicit_subject_superset_cascade_childof(void);
+void Parser_pred_implicit_subject_superset_cascade_childof_optional(void);
+void Parser_expr_w_symbol(void);
+void Parser_expr_w_newline(void);
+void Parser_subj_entity_w_explicit_self(void);
+void Parser_subj_entity_w_explicit_self_superset(void);
+void Parser_subj_entity_w_explicit_superset_relation(void);
+void Parser_subj_entity_w_explicit_self_superset_relation(void);
+void Parser_obj_entity_w_explicit_self(void);
+void Parser_obj_entity_w_explicit_self_superset(void);
+void Parser_obj_entity_w_explicit_superset_relation(void);
+void Parser_obj_entity_w_explicit_self_superset_relation(void);
+void Parser_pred_entity_w_explicit_self(void);
+void Parser_pred_entity_w_explicit_self_superset(void);
+void Parser_pred_entity_no_args_w_explicit_self(void);
+void Parser_pred_entity_no_args_w_explicit_self_superset(void);
+void Parser_pred_entity_no_args_2_terms_w_explicit_self(void);
+void Parser_pred_entity_no_args_2_terms_w_explicit_self_superset(void);
+void Parser_newline(void);
+void Parser_2_newlines(void);
+void Parser_3_newlines(void);
+void Parser_space(void);
+void Parser_2_spaces(void);
+void Parser_trailing_newline(void);
+void Parser_2_trailing_newlines(void);
+void Parser_trailing_space(void);
+void Parser_2_trailing_spaces(void);
+void Parser_template_type(void);
+void Parser_template_type_nested(void);
+void Parser_template_type_multiple_args(void);
+void Parser_template_type_multiple_args_nested(void);
+void Parser_template_type_unbalanced_open(void);
+void Parser_template_type_unbalanced_close(void);
+void Parser_predicate_w_parens(void);
+void Parser_not_alive_pred(void);
+void Parser_not_alive_subj(void);
+void Parser_not_alive_obj(void);
+void Parser_this_subj_var_kind(void);
+void Parser_this_obj_var_kind(void);
+void Parser_this_subj_obj_var_kind(void);
+void Parser_var_w_name(void);
+void Parser_entity_pred_no_name(void);
+void Parser_entity_subj_no_name(void);
+void Parser_entity_obj_no_name(void);
+void Parser_this_pred_no_name(void);
+void Parser_this_subj_no_name(void);
+void Parser_this_obj_no_name(void);
+void Parser_invalid_variable_only(void);
+void Parser_oneof_self_pred_w_relative_obj(void);
+void Parser_oneof_other_pred_w_relative_obj(void);
+void Parser_oneof_self_pred_w_invalid_obj(void);
+void Parser_oneof_other_pred_w_invalid_obj(void);
+void Parser_oneof_w_other_entity_w_same_name(void);
+void Parser_oneof_w_other_entity_w_same_name_w_set_scope(void);
+void Parser_oneof_w_wildcard(void);
+void Parser_oneof_w_any(void);
+void Parser_oneof_w_fullpath(void);
+void Parser_pair_implicit_src_missing_rel(void);
+void Parser_pair_implicit_src_missing_obj(void);
+void Parser_pair_explicit_src_missing_src(void);
+void Parser_pair_explicit_src_missing_obj(void);
+void Parser_eq_id(void);
+void Parser_eq_id_var(void);
+void Parser_eq_var_id(void);
+void Parser_eq_var_table(void);
+void Parser_eq_var(void);
+void Parser_neq_id(void);
+void Parser_neq_id_var(void);
+void Parser_neq_var_id(void);
+void Parser_neq_var_table(void);
+void Parser_neq_var(void);
+void Parser_eq_name(void);
+void Parser_eq_name_var(void);
+void Parser_eq_var_name(void);
+void Parser_neq_name(void);
+void Parser_neq_name_var(void);
+void Parser_neq_var_name(void);
+void Parser_match_name(void);
+void Parser_match_name_var(void);
+void Parser_match_var_name(void);
+void Parser_match_var(void);
+void Parser_nmatch_name(void);
+void Parser_nmatch_name_var(void);
+void Parser_nmatch_var_name(void);
+void Parser_eq_same_var(void);
+void Parser_neq_same_var(void);
+void Parser_eq_same_var_this(void);
+void Parser_neq_same_var_this(void);
+void Parser_eq_w_not(void);
+void Parser_neq_w_not(void);
+void Parser_match_w_not(void);
+void Parser_eq_w_optional(void);
+void Parser_neq_w_optional(void);
+void Parser_match_w_optional(void);
+void Parser_eq_0(void);
+void Parser_neq_0(void);
+void Parser_eq_wildcard(void);
+void Parser_neq_wildcard(void);
+void Parser_eq_any(void);
+void Parser_neq_any(void);
+void Parser_query_scope_1_term(void);
+void Parser_query_scope_1_term_spaces(void);
+void Parser_query_scope_2_terms(void);
+void Parser_query_nested_scope(void);
+void Parser_query_nested_scope_spaces(void);
+void Parser_query_scope_unbalanced(void);
+void Parser_query_not_scope(void);
+void Parser_query_empty_scope(void);
+void Parser_query_scope_newline_after_open(void);
+void Parser_query_scope_newline_after_close(void);
+void Parser_query_term_after_scope(void);
+void Parser_override_tag(void);
+void Parser_override_pair(void);
+void Parser_pair_3_args(void);
+void Parser_pair_3_args_implicit_this(void);
+void Parser_pair_4_args(void);
+void Parser_pair_4_args_implicit_this(void);
+void Parser_pair_3_args_2_terms(void);
+void Parser_pair_3_args_this_tgt(void);
+void Parser_pair_3_args_2_terms_this_tgt(void);
+void Parser_pair_3_args_2_terms_this_tgt_implicit_this(void);
+void Parser_pair_3_or_args(void);
+void Parser_pair_3_or_args_implicit_this(void);
+void Parser_pair_4_or_args(void);
+void Parser_pair_4_or_args_implicit_this(void);
+void Parser_pair_3_args_w_vars(void);
+void Parser_pair_4_args_w_vars(void);
+void Parser_pair_3_args_w_vars_w_term_after(void);
+void Parser_pair_4_args_w_vars_w_term_after(void);
+void Parser_pair_or_before_and_oper(void);
+void Parser_pair_and_before_or_oper(void);
+void Parser_cascade_desc(void);
+void Parser_newline_after_inout(void);
+void Parser_newline_after_term_open(void);
+void Parser_newline_after_term_src(void);
+void Parser_newline_after_term_src_pair(void);
+void Parser_newline_after_term_pair_comma(void);
+void Parser_newline_after_term_pair_second(void);
+void Parser_tag_w_space_implicit_this(void);
+void Parser_tag_w_space(void);
+void Parser_pair_first_w_space_implicit_this(void);
+void Parser_pair_first_w_space(void);
+void Parser_pair_second_w_space_implicit_this(void);
+void Parser_pair_second_w_space(void);
+void Parser_pair_src_w_space(void);
+void Parser_empty_term(void);
+void Parser_empty_term_w_space(void);
+void Parser_empty_term_w_newline(void);
+void Parser_mixed_1_desc_and_1_expr(void);
+void Parser_mixed_2_desc_and_1_expr(void);
+void Parser_mixed_1_desc_and_2_expr(void);
+
+// Testsuite 'Basic'
+void Basic_setup(void);
+void Basic_0_query(void);
+void Basic_1_fact_w_tag(void);
+void Basic_1_fact_w_component(void);
+void Basic_1_fact_w_tag_pair(void);
+void Basic_1_fact_w_component_pair(void);
+void Basic_2_facts_same_src_w_tag(void);
+void Basic_2_facts_same_src_w_component(void);
+void Basic_2_facts_same_src_w_tag_pair(void);
+void Basic_2_facts_same_src_w_component_pair(void);
+void Basic_2_facts_other_src_w_tag(void);
+void Basic_2_facts_other_src_w_component(void);
+void Basic_2_facts_other_src_w_tag_pair(void);
+void Basic_2_facts_other_src_w_component_pair(void);
+void Basic_1_fact_w_any(void);
+void Basic_1_fact_w_pair_any_tgt(void);
+void Basic_1_fact_w_pair_any_rel(void);
+void Basic_1_fact_w_pair_any_rel_tgt(void);
+void Basic_2_facts_same_src_w_any(void);
+void Basic_2_facts_same_src_w_pair_any_tgt(void);
+void Basic_2_facts_same_src_w_pair_any_rel(void);
+void Basic_2_facts_same_src_w_pair_any_rel_tgt(void);
+void Basic_2_facts_other_src_w_any(void);
+void Basic_2_facts_other_src_w_pair_any_tgt(void);
+void Basic_2_facts_other_src_w_pair_any_rel(void);
+void Basic_2_facts_other_src_w_pair_any_rel_tgt(void);
+void Basic_1_this_src_w_tag(void);
+void Basic_1_this_src_w_component(void);
+void Basic_1_this_src_w_tag_pair(void);
+void Basic_1_this_src_w_component_pair(void);
+void Basic_1_this_src_w_tag_2_tables(void);
+void Basic_1_this_src_w_component_2_tables(void);
+void Basic_1_this_src_w_tag_pair_2_tables(void);
+void Basic_1_this_src_w_component_pair_2_tables(void);
+void Basic_2_this_src_w_tag(void);
+void Basic_2_this_src_w_component(void);
+void Basic_2_this_src_ent_src_w_tag(void);
+void Basic_2_this_src_ent_src_w_component(void);
+void Basic_2_ent_src_this_src_w_tag(void);
+void Basic_2_ent_src_this_src_w_component(void);
+void Basic_recycled_tag(void);
+void Basic_recycled_src(void);
+void Basic_recycled_pair_rel(void);
+void Basic_recycled_pair_tgt(void);
+void Basic_this_src_w_wildcard(void);
+void Basic_this_src_w_pair_rel_wildcard(void);
+void Basic_this_src_w_pair_tgt_wildcard(void);
+void Basic_this_src_w_pair_rel_tgt_wildcard(void);
+void Basic_this_src_w_any(void);
+void Basic_this_src_w_any_written(void);
+void Basic_this_src_w_pair_rel_any(void);
+void Basic_this_src_w_pair_tgt_any(void);
+void Basic_this_src_w_pair_rel_tgt_any(void);
+void Basic_ent_src_w_wildcard(void);
+void Basic_ent_src_w_pair_rel_wildcard(void);
+void Basic_ent_src_w_pair_tgt_wildcard(void);
+void Basic_ent_src_w_pair_rel_tgt_wildcard(void);
+void Basic_1_wildcard_src(void);
+void Basic_1_wildcard_src_w_pair(void);
+void Basic_2_wildcard_src(void);
+void Basic_2_wildcard_src_w_pair(void);
+void Basic_1_wildcard_src_w_pair_tgt_var(void);
+void Basic_1_wildcard_src_w_pair_rel_var(void);
+void Basic_1_wildcard_src_w_pair_tgt_this(void);
+void Basic_1_wildcard_src_w_pair_rel_this(void);
+void Basic_1_any_src(void);
+void Basic_1_any_src_w_pair(void);
+void Basic_2_any_src(void);
+void Basic_2_any_src_w_pair(void);
+void Basic_1_any_src_w_pair_tgt_var(void);
+void Basic_1_any_src_w_pair_rel_var(void);
+void Basic_1_any_src_w_pair_tgt_this(void);
+void Basic_1_any_src_w_pair_rel_this(void);
+void Basic_not_any(void);
+void Basic_rule_w_iter_next(void);
+void Basic_empty_rule(void);
+void Basic_invalid_rule(void);
+void Basic_not_instanced_table_src(void);
+void Basic_not_instanced_entity_src(void);
+void Basic_not_instanced_mixed_src(void);
+void Basic_not_instanced_inherited(void);
+void Basic_instanced_table_src(void);
+void Basic_instanced_entity_src(void);
+void Basic_instanced_mixed_src(void);
+void Basic_instanced_inherited(void);
+void Basic_in_term(void);
+void Basic_out_term(void);
+void Basic_inout_term(void);
+void Basic_nodata_term(void);
+void Basic_find_this_lowercase(void);
+void Basic_find_this_uppercase(void);
+void Basic_find_this_tgt_lowercase(void);
+void Basic_find_this_tgt_uppercase(void);
+void Basic_get_filter(void);
+void Basic_iter_empty_source(void);
+void Basic_iter_empty_source_2_terms(void);
+void Basic_iter_empty_source_wildcard(void);
+void Basic_iter_empty_source_pair(void);
+void Basic_iter_empty_source_pair_wildcard(void);
+void Basic_iter_empty_source_2_terms_pair(void);
+void Basic_iter_empty_source_2_terms_mixed(void);
+void Basic_iter_empty_source_2_terms_mixed_pair(void);
+void Basic_iter_empty_source_2_terms_mixed_pair_wildcard(void);
+void Basic_this_var_w_empty_entity(void);
+void Basic_match_disabled(void);
+void Basic_match_prefab(void);
+void Basic_match_disabled_prefab(void);
+void Basic_match_disabled_this_tgt(void);
+void Basic_match_prefab_this_tgt(void);
+void Basic_match_disabled_prefab_this_tgt(void);
+void Basic_match_self_disabled(void);
+void Basic_match_self_prefab(void);
+void Basic_match_self_disabled_prefab(void);
+void Basic_match_optional_disabled(void);
+void Basic_match_optional_prefab(void);
+void Basic_match_optional_disabled_prefab(void);
+void Basic_match_optional_disabled_this_tgt(void);
+void Basic_match_optional_prefab_this_tgt(void);
+void Basic_match_optional_disabled_prefab_this_tgt(void);
+void Basic_match_optional_self_disabled(void);
+void Basic_match_optional_self_prefab(void);
+void Basic_match_optional_self_disabled_prefab(void);
+void Basic_inout_none_first_term(void);
+void Basic_inout_none_second_term(void);
+void Basic_inout_none_singleton(void);
+void Basic_inout_none_singleton_w_or(void);
+void Basic_inout_none_component_w_or(void);
+void Basic_no_data_rule(void);
+void Basic_frame_offset(void);
+void Basic_frame_offset_no_data(void);
+void Basic_match_empty_tables(void);
+void Basic_match_empty_tables_no_data(void);
+void Basic_match_empty_tables_w_not(void);
+void Basic_match_empty_tables_w_wildcard(void);
+void Basic_match_empty_tables_w_no_empty_tables(void);
+void Basic_match_empty_tables_trivial(void);
+void Basic_oneof_wildcard(void);
+void Basic_oneof_any(void);
+void Basic_instanced_w_singleton(void);
+void Basic_instanced_w_base(void);
+void Basic_not_instanced_w_singleton(void);
+void Basic_not_instanced_w_base(void);
+void Basic_unknown_before_known(void);
+void Basic_unknown_before_known_after_or(void);
+void Basic_unknown_before_known_after_not(void);
+void Basic_unknown_before_known_after_optional(void);
+void Basic_unknown_before_known_after_scope(void);
+void Basic_2_trivial_mixed_2_tables(void);
+void Basic_2_trivial_mixed_2_tables_component(void);
+void Basic_2_trivial_mixed_2_tables_wildcard(void);
+void Basic_2_trivial_1_unused_id(void);
+void Basic_2_trivial_one_regular(void);
+void Basic_1_trivial_one_regular_one_trivial(void);
+void Basic_one_regular_2_trivial(void);
+void Basic_2_trivial_w_prefab(void);
+void Basic_3_trivial_w_prefab(void);
+void Basic_2_trivial_w_disabled(void);
+void Basic_3_trivial_w_disabled(void);
+void Basic_2_this_w_fixed_src(void);
+void Basic_2_fixed_src_w_this(void);
+void Basic_2_this_w_fixed_src_no_match_fixed(void);
+void Basic_2_fixed_src_w_this_no_match_fixed(void);
+void Basic_2_this_w_fixed_src_no_match_this(void);
+void Basic_2_fixed_src_w_this_no_match_this(void);
+void Basic_query_count_results(void);
+void Basic_query_count_entities(void);
+void Basic_query_is_true(void);
+void Basic_implicit_cleanup_1_term(void);
+void Basic_implicit_cleanup_2_terms(void);
+void Basic_implicit_cleanup_1_term_w_up(void);
+void Basic_implicit_cleanup_2_terms_w_up(void);
+void Basic_implicit_cleanup_2_queries(void);
+void Basic_implicit_cleanup_2_queries_1_cleanup(void);
+void Basic_iter_valid(void);
+void Basic_iter_frame_offset(void);
+void Basic_iter_nested_1(void);
+void Basic_iter_nested_2(void);
+void Basic_iter_interleaved(void);
+void Basic_set_get_context(void);
+void Basic_set_get_binding_context(void);
+void Basic_set_get_context_w_free(void);
+void Basic_set_get_binding_context_w_free(void);
+void Basic_create_query_w_existing_entity(void);
+void Basic_create_query_w_existing_entity_different_term_count(void);
+void Basic_create_multi_component_query_w_existing_entity(void);
+void Basic_delete_query_by_entity(void);
+void Basic_eval_count(void);
+void Basic_no_results_after_delete_tree(void);
+void Basic_no_results_after_delete_tree_deferred(void);
+void Basic_add_on_self_ref(void);
+void Basic_add_on_self_ref_by_name(void);
+void Basic_delete_id_after_delete_query(void);
+void Basic_pair_sweep_tag(void);
+void Basic_pair_sweep_wildcard_first(void);
+void Basic_pair_sweep_wildcard_second(void);
+
+// Testsuite 'Plan'
+void Plan_reordered_plan_1(void);
+void Plan_reordered_plan_2(void);
+void Plan_1_trivial_plan(void);
+void Plan_2_trivial_plan(void);
+void Plan_1_trivial_plan_component(void);
+void Plan_2_trivial_plan_component(void);
+void Plan_3_trivial_plan_w_pair(void);
+void Plan_3_trivial_plan_w_wildcard(void);
+void Plan_3_trivial_plan_w_any(void);
+void Plan_3_trivial_plan_w_pair_component(void);
+void Plan_3_trivial_plan_w_wildcard_component(void);
+void Plan_3_trivial_plan_w_any_component(void);
+void Plan_1_trivial_component_w_none(void);
+void Plan_2_trivial_component_w_none(void);
+void Plan_2_trivial_plan_w_wildcard(void);
+void Plan_this_before_fixed_src(void);
+void Plan_fixed_src_before_this(void);
+void Plan_var_before_fixed_src(void);
+void Plan_fixed_src_before_var(void);
+void Plan_this_before_fixed_src_w_not(void);
+void Plan_this_before_fixed_src_w_first_var(void);
+void Plan_this_before_fixed_src_w_first_var_w_not(void);
+void Plan_this_before_fixed_src_w_second_var(void);
+void Plan_this_before_fixed_src_w_second_var_w_not(void);
+void Plan_populate_1_fixed(void);
+void Plan_populate_2_fixed(void);
+void Plan_populate_1_fixed_1_this_self(void);
+void Plan_populate_2_fixed_2_this_self(void);
+void Plan_populate_2_fixed_2_this_self_interleaved(void);
+void Plan_populate_2_this_self_2_fixed(void);
+void Plan_populate_1_fixed_1_this_up(void);
+void Plan_populate_2_fixed_2_this_up(void);
+void Plan_populate_2_fixed_2_this_up_interleaved(void);
+void Plan_populate_2_this_up_2_fixed(void);
+void Plan_populate_1_fixed_1_this_self_cached(void);
+void Plan_populate_2_fixed_2_this_self_cached(void);
+void Plan_populate_2_fixed_2_this_self_interleaved_cached(void);
+void Plan_populate_2_this_self_2_fixed_cached(void);
+void Plan_populate_1_fixed_1_this_up_cached(void);
+void Plan_populate_2_fixed_2_this_up_cached(void);
+void Plan_populate_2_fixed_2_this_up_interleaved_cached(void);
+void Plan_populate_2_this_up_2_fixed_cached(void);
+void Plan_populate_1_fixed_1_var_self(void);
+void Plan_populate_2_fixed_2_var_self(void);
+void Plan_populate_2_fixed_2_var_self_interleaved(void);
+void Plan_populate_2_var_self_2_fixed(void);
+void Plan_populate_1_fixed_1_var_up(void);
+void Plan_populate_2_fixed_2_var_up(void);
+void Plan_populate_2_fixed_2_var_up_interleaved(void);
+void Plan_populate_2_var_up_2_fixed(void);
+void Plan_cache_2_or(void);
+void Plan_cache_2_or_w_not(void);
+void Plan_1_plan_any_src(void);
+void Plan_1_plan_not_any_src(void);
+void Plan_1_plan_optional_any_src(void);
+void Plan_pair_first_wildcard(void);
+void Plan_pair_first_wildcard_cached(void);
+void Plan_pair_second_wildcard(void);
+void Plan_pair_second_wildcard_cached(void);
+
+// Testsuite 'Variables'
+void Variables_setup(void);
+void Variables_1_ent_src_w_var(void);
+void Variables_1_ent_src_w_pair_rel_var(void);
+void Variables_1_ent_src_w_pair_tgt_var(void);
+void Variables_1_ent_src_w_pair_rel_tgt_var(void);
+void Variables_1_ent_src_w_pair_rel_tgt_same_var(void);
+void Variables_1_ent_src_w_pair_rel_tgt_same_var_after_write(void);
+void Variables_1_this_src_w_var(void);
+void Variables_1_this_src_w_pair_rel_var(void);
+void Variables_1_this_src_w_pair_tgt_var(void);
+void Variables_1_this_src_w_pair_rel_tgt_var(void);
+void Variables_1_this_src_w_pair_rel_tgt_same_var(void);
+void Variables_1_this_src_w_pair_rel_tgt_same_var_after_write(void);
+void Variables_1_src_id_same_var(void);
+void Variables_1_src_pair_first_same_var(void);
+void Variables_1_src_pair_second_same_var(void);
+void Variables_1_src_pair_first_and_second_same_var(void);
+void Variables_1_src_id_same_var_after_write(void);
+void Variables_1_src_pair_first_same_var_after_write(void);
+void Variables_1_src_pair_second_same_var_after_write(void);
+void Variables_1_src_pair_first_and_second_same_var_after_write(void);
+void Variables_1_src_pair_first_same_var_this(void);
+void Variables_1_src_pair_second_same_var_this(void);
+void Variables_1_src_pair_first_and_second_same_var_this(void);
+void Variables_1_src_id_same_var_this_after_write(void);
+void Variables_1_src_pair_first_same_var_this_after_write(void);
+void Variables_1_src_pair_second_same_var_this_after_write(void);
+void Variables_1_src_pair_first_and_second_same_var_this_after_write(void);
+void Variables_1_ent_src_w_this_var(void);
+void Variables_1_ent_src_w_pair_this_rel(void);
+void Variables_1_ent_src_w_pair_this_tgt(void);
+void Variables_1_ent_src_w_pair_this_rel_tgt(void);
+void Variables_1_this_src_w_this(void);
+void Variables_1_this_src_w_pair_this_rel_tgt(void);
+void Variables_1_this_src_w_this_after_write(void);
+void Variables_1_this_src_w_pair_this_rel_tgt_after_write(void);
+void Variables_2_constrain_src_from_src(void);
+void Variables_2_constrain_rel_from_src_w_ent(void);
+void Variables_2_constrain_rel_from_src_w_var(void);
+void Variables_2_constrain_rel_from_src_w_this(void);
+void Variables_2_constrain_pair_rel_from_src_w_ent(void);
+void Variables_2_constrain_pair_rel_from_src_w_var(void);
+void Variables_2_constrain_pair_rel_from_src_w_this(void);
+void Variables_2_constrain_pair_tgt_from_src_w_ent(void);
+void Variables_2_constrain_pair_tgt_from_src_w_var(void);
+void Variables_2_constrain_pair_tgt_from_src_w_this(void);
+void Variables_2_constrain_pair_rel_tgt_from_src_w_ent(void);
+void Variables_2_constrain_pair_rel_tgt_from_src_w_var(void);
+void Variables_2_constrain_pair_rel_tgt_from_src_w_this(void);
+void Variables_1_ent_src_set_rel_var(void);
+void Variables_1_ent_src_set_pair_rel_var(void);
+void Variables_1_ent_src_set_pair_tgt_var(void);
+void Variables_1_set_src_var(void);
+void Variables_1_set_src_var_w_pair(void);
+void Variables_1_set_src_var_w_pair_set_rel(void);
+void Variables_1_set_src_var_w_pair_set_tgt(void);
+void Variables_1_set_src_var_w_pair_set_rel_tgt(void);
+void Variables_1_set_src_this(void);
+void Variables_1_set_src_this_w_pair(void);
+void Variables_1_set_src_this_w_pair_set_rel(void);
+void Variables_1_set_src_this_w_pair_set_tgt(void);
+void Variables_1_set_src_this_w_pair_set_rel_tgt(void);
+void Variables_1_set_src_this_to_empty_table(void);
+void Variables_1_set_src_this_to_empty_table_w_component(void);
+void Variables_1_set_src_this_to_empty_table_w_component_self(void);
+void Variables_1_set_src_this_to_entiy_in_table(void);
+void Variables_1_set_src_this_to_entiy_in_table_self(void);
+void Variables_2_set_src_this(void);
+void Variables_2_set_src_this_self(void);
+void Variables_2_set_src_this_component(void);
+void Variables_2_set_src_this_self_component(void);
+void Variables_2_set_src_this_w_up(void);
+void Variables_2_set_src_this_self_w_up(void);
+void Variables_2_set_src_this_component_w_up(void);
+void Variables_2_set_src_this_self_component_w_up(void);
+void Variables_2_set_src_this_w_exclusive_wildcard(void);
+void Variables_2_set_src_this_self_w_exclusive_wildcard(void);
+void Variables_2_set_src_this_self_w_exclusive_wildcard_w_up(void);
+void Variables_1_set_src_this_is_true(void);
+void Variables_3_set_src_this_w_uncacheable_tag_tag_tag(void);
+void Variables_3_set_src_this_w_uncacheable_tag_component_tag(void);
+void Variables_3_set_src_this_w_uncacheable_tag_component_component(void);
+void Variables_3_set_src_this_w_tag_uncacheable_tag_tag(void);
+void Variables_3_set_src_this_w_component_uncacheable_tag_tag(void);
+void Variables_3_set_src_this_w_component_uncacheable_tag_component(void);
+void Variables_3_set_src_this_w_tag_tag_uncacheable_tag(void);
+void Variables_3_set_src_this_w_component_tag_uncacheable_tag(void);
+void Variables_3_set_src_this_w_component_component_uncacheable_tag(void);
+void Variables_3_set_src_this_w_uncacheable_component_tag_tag(void);
+void Variables_3_set_src_this_w_uncacheable_component_component_tag(void);
+void Variables_3_set_src_this_w_uncacheable_component_component_component(void);
+void Variables_3_set_src_this_w_tag_uncacheable_component_tag(void);
+void Variables_3_set_src_this_w_component_uncacheable_component_tag(void);
+void Variables_3_set_src_this_w_component_uncacheable_component_component(void);
+void Variables_3_set_src_this_w_tag_tag_uncacheable_component(void);
+void Variables_3_set_src_this_w_component_tag_uncacheable_component(void);
+void Variables_3_set_src_this_w_component_component_uncacheable_component(void);
+void Variables_2_set_src_this_w_wildcard(void);
+void Variables_1_src_this_var_as_entity(void);
+void Variables_1_src_this_var_as_table(void);
+void Variables_1_src_this_var_as_table_range(void);
+void Variables_2_join_by_rel_var(void);
+void Variables_2_join_by_pair_rel_var(void);
+void Variables_2_join_by_pair_tgt_var(void);
+void Variables_2_cycle_w_var(void);
+void Variables_2_cycle_w_this_var(void);
+void Variables_2_cycle_w_var_this(void);
+void Variables_2_cycle_pair_w_var(void);
+void Variables_2_cycle_pair_w_this_var_var(void);
+void Variables_2_cycle_pair_w_var_this_var(void);
+void Variables_2_cycle_pair_w_var_var_this(void);
+void Variables_2_cycle_pair_ent_var_var(void);
+void Variables_2_cycle_pair_ent_this_var(void);
+void Variables_2_cycle_pair_ent_var_this(void);
+void Variables_parse_0_var(void);
+void Variables_parse_1_var(void);
+void Variables_parse_2_vars(void);
+void Variables_parse_0_var_paren(void);
+void Variables_parse_1_var_paren(void);
+void Variables_parse_2_vars_paren(void);
+void Variables_parse_1_vars_w_path(void);
+void Variables_parse_missing_close_paren(void);
+void Variables_parse_missing_open_paren(void);
+void Variables_parse_missing_value(void);
+void Variables_parse_0_var_w_spaces(void);
+void Variables_parse_1_var_w_spaces(void);
+void Variables_parse_2_vars_w_spaces(void);
+void Variables_parse_0_var_paren_w_spaces(void);
+void Variables_parse_1_var_paren_w_spaces(void);
+void Variables_parse_2_vars_paren_w_spaces(void);
+void Variables_var_count(void);
+void Variables_var_name(void);
+void Variables_var_is_entity(void);
+void Variables_no_this_anonymous_src(void);
+void Variables_no_this_anonymous_src_w_pair(void);
+void Variables_no_this_anonymous_component_src(void);
+void Variables_no_this_anonymous_component_src_w_pair(void);
+void Variables_lookup_from_table_this(void);
+void Variables_lookup_from_entity_this(void);
+void Variables_lookup_from_table(void);
+void Variables_lookup_from_entity(void);
+void Variables_lookup_from_not_written(void);
+void Variables_lookup_from_table_this_component(void);
+void Variables_lookup_from_entity_this_component(void);
+void Variables_lookup_from_table_component(void);
+void Variables_lookup_from_entity_component(void);
+void Variables_lookup_from_table_two_children(void);
+void Variables_lookup_from_entity_two_children(void);
+void Variables_lookup_from_table_same_child_twice(void);
+void Variables_lookup_from_entity_same_child_twice(void);
+void Variables_lookup_from_table_not(void);
+void Variables_lookup_from_entity_not(void);
+void Variables_lookup_from_table_w_any_component(void);
+void Variables_lookup_from_entity_w_any_component(void);
+void Variables_lookup_as_tag(void);
+void Variables_lookup_as_relationship(void);
+void Variables_lookup_as_target(void);
+void Variables_lookup_assign_var(void);
+void Variables_lookup_eq_var(void);
+void Variables_lookup_neq_var(void);
+void Variables_lookup_unresolved_dependent(void);
+void Variables_check_vars_this(void);
+void Variables_check_vars_var(void);
+void Variables_check_vars_wildcard(void);
+void Variables_check_vars_any(void);
+void Variables_check_vars_var_as_tgt(void);
+void Variables_check_vars_this_as_tgt(void);
+void Variables_check_vars_anonymous_var_as_tgt(void);
+void Variables_check_vars_wildcard_as_tgt(void);
+void Variables_check_vars_any_as_tgt(void);
+void Variables_check_vars_this_w_lookup_var(void);
+void Variables_check_vars_var_w_lookup_var(void);
+void Variables_1_trivial_1_var(void);
+void Variables_2_trivial_1_var(void);
+void Variables_1_trivial_1_var_component(void);
+void Variables_2_trivial_1_var_component(void);
+void Variables_1_trivial_1_wildcard(void);
+void Variables_2_trivial_1_wildcard(void);
+void Variables_1_trivial_1_wildcard_component(void);
+void Variables_2_trivial_1_wildcard_component(void);
+void Variables_1_trivial_1_any(void);
+void Variables_2_trivial_1_any(void);
+void Variables_1_trivial_1_any_component(void);
+void Variables_2_trivial_1_any_component(void);
+void Variables_first_invalid_var_name_and_id(void);
+void Variables_src_invalid_var_name_and_id(void);
+void Variables_second_invalid_var_name_and_id(void);
+
+// Testsuite 'Operators'
+void Operators_setup(void);
+void Operators_2_and_not(void);
+void Operators_2_and_not_component(void);
+void Operators_2_and_out_not(void);
+void Operators_2_and_out_not_component(void);
+void Operators_3_and_not_not(void);
+void Operators_2_and_not_pair_rel_wildcard(void);
+void Operators_2_and_not_pair_tgt_wildcard(void);
+void Operators_2_and_not_pair_rel_tgt_wildcard(void);
+void Operators_2_and_not_pair_rel_var(void);
+void Operators_2_and_not_pair_tgt_var(void);
+void Operators_2_and_not_pair_rel_tgt_var(void);
+void Operators_2_and_not_pair_rel_tgt_same_var(void);
+void Operators_2_and_not_pair_rel_var_written(void);
+void Operators_2_and_not_pair_tgt_var_written(void);
+void Operators_2_and_not_pair_rel_tgt_var_written(void);
+void Operators_2_and_not_pair_rel_tgt_same_var_written(void);
+void Operators_2_and_not_pair_rel_src_tgt_same_var_written(void);
+void Operators_2_and_not_pair_any_rel(void);
+void Operators_2_and_not_pair_any_tgt(void);
+void Operators_2_and_not_pair_any_src(void);
+void Operators_1_not_any_src_fixed_first(void);
+void Operators_1_not_any_src_any_tgt_fixed_first(void);
+void Operators_1_not_any_src_any_first_fixed_tgt(void);
+void Operators_1_not_any_src_any_childof_pair_any_tgt(void);
+void Operators_1_not_any_src_any_isa_pair_any_tgt(void);
+void Operators_2_and_optional(void);
+void Operators_3_and_optional_optional(void);
+void Operators_2_and_optional_pair_rel_wildcard(void);
+void Operators_2_and_optional_pair_tgt_wildcard(void);
+void Operators_2_and_optional_pair_rel_var(void);
+void Operators_2_and_optional_pair_tgt_var(void);
+void Operators_2_and_optional_pair_rel_tgt_var(void);
+void Operators_2_and_optional_pair_rel_tgt_same_var(void);
+void Operators_2_and_optional_pair_rel_var_written(void);
+void Operators_2_and_optional_pair_tgt_var_written(void);
+void Operators_2_and_optional_pair_rel_tgt_var_written(void);
+void Operators_2_and_optional_pair_rel_tgt_same_var_written(void);
+void Operators_2_and_optional_pair_rel_src_tgt_same_var_written(void);
+void Operators_3_and_optional_optional_pair_w_var(void);
+void Operators_2_and_optional_pair_any_rel(void);
+void Operators_2_and_optional_pair_any_tgt(void);
+void Operators_2_and_optional_pair_any_src(void);
+void Operators_3_and_optional_dependent_and_pair_rel(void);
+void Operators_3_and_optional_dependent_and_pair_tgt(void);
+void Operators_3_and_optional_dependent_and_pair_rel_tgt(void);
+void Operators_3_and_optional_dependent_and_pair_rel_tgt_same_var(void);
+void Operators_3_and_optional_dependent_and_pair_rel_tgt_same_other_var(void);
+void Operators_3_and_optional_dependent_and_pair_src(void);
+void Operators_3_and_optional_dependent_optional_pair_rel(void);
+void Operators_3_and_optional_dependent_optional_pair_tgt(void);
+void Operators_3_and_optional_dependent_optional_pair_src(void);
+void Operators_3_and_optional_dependent_not_pair_rel(void);
+void Operators_3_and_optional_dependent_not_pair_tgt(void);
+void Operators_3_and_optional_dependent_not_pair_src(void);
+void Operators_1_optional_any_src_fixed_first(void);
+void Operators_1_optional_any_src_any_tgt_fixed_first(void);
+void Operators_1_optional_any_src_any_first_fixed_tgt(void);
+void Operators_1_optional_any_src_any_childof_pair_any_tgt(void);
+void Operators_1_optional_any_src_any_isa_pair_any_tgt(void);
+void Operators_2_or(void);
+void Operators_3_or(void);
+void Operators_2_or_w_and(void);
+void Operators_3_or_w_and(void);
+void Operators_2_or_written(void);
+void Operators_3_or_written(void);
+void Operators_2_or_written_w_rel_var(void);
+void Operators_3_or_written_w_rel_var(void);
+void Operators_2_or_written_w_tgt_var(void);
+void Operators_2_or_written_w_rel_tgt_var(void);
+void Operators_2_or_written_w_rel_tgt_same_var(void);
+void Operators_3_or_written_w_tgt_var(void);
+void Operators_2_or_chains(void);
+void Operators_2_or_chains_written(void);
+void Operators_2_or_dependent(void);
+void Operators_2_or_dependent_reverse(void);
+void Operators_2_or_dependent_2_vars(void);
+void Operators_2_or_written_dependent(void);
+void Operators_2_or_written_dependent_2_vars(void);
+void Operators_2_or_w_dependent(void);
+void Operators_2_or_w_both(void);
+void Operators_3_or_w_both(void);
+void Operators_2_or_w_not(void);
+void Operators_2_or_w_not_component(void);
+void Operators_2_or_w_not_out_component(void);
+void Operators_2_or_w_not_out_all_components(void);
+void Operators_2_not_first(void);
+void Operators_2_optional_first(void);
+void Operators_only_not(void);
+void Operators_only_not_component(void);
+void Operators_only_not_out_component(void);
+void Operators_only_optional(void);
+void Operators_only_optional_component(void);
+void Operators_not_after_fixed_src(void);
+void Operators_optional_after_fixed_src(void);
+void Operators_root_entities_empty(void);
+void Operators_root_entities(void);
+void Operators_root_entities_w_children(void);
+void Operators_root_entities_w_optional_children(void);
+void Operators_core_entities_w_optional_children(void);
+void Operators_root_entities_w_not_children(void);
+void Operators_core_entities_w_not_children(void);
+void Operators_1_ent_src_not(void);
+void Operators_1_ent_src_not_pair(void);
+void Operators_1_ent_src_not_pair_rel_wildcard(void);
+void Operators_1_ent_src_not_pair_tgt_wildcard(void);
+void Operators_1_ent_src_not_pair_rel_tgt_wildcard(void);
+void Operators_1_ent_src_not_pair_rel_any(void);
+void Operators_1_ent_src_not_pair_tgt_any(void);
+void Operators_1_ent_src_not_pair_rel_tgt_any(void);
+void Operators_1_ent_src_not_pair_rel_var(void);
+void Operators_1_ent_src_not_pair_tgt_var(void);
+void Operators_1_ent_src_not_pair_rel_tgt_var(void);
+void Operators_1_ent_src_not_pair_rel_tgt_same_var(void);
+void Operators_1_this_src_not_pair_rel_var(void);
+void Operators_1_this_src_not_pair_tgt_var(void);
+void Operators_1_this_src_not_pair_rel_tgt_var(void);
+void Operators_1_this_src_not_pair_rel_tgt_same_var(void);
+void Operators_1_ent_src_not_pair_rel_var_written(void);
+void Operators_1_ent_src_not_pair_tgt_var_written(void);
+void Operators_1_ent_src_not_pair_rel_tgt_var_written(void);
+void Operators_1_ent_src_not_pair_rel_tgt_same_var_written(void);
+void Operators_and_from_fixed_src(void);
+void Operators_not_from_fixed_src(void);
+void Operators_or_from_fixed_src(void);
+void Operators_and_from_this(void);
+void Operators_not_from_this(void);
+void Operators_or_from_this(void);
+void Operators_and_from_this_written(void);
+void Operators_not_from_this_written(void);
+void Operators_or_from_this_written(void);
+void Operators_and_from_empty(void);
+void Operators_not_from_empty(void);
+void Operators_or_from_empty(void);
+void Operators_and_from_empty_w_tag(void);
+void Operators_not_from_empty_w_tag(void);
+void Operators_or_from_empty_w_tag(void);
+void Operators_or_w_wildcard(void);
+void Operators_or_w_component_and_tag(void);
+void Operators_or_w_tag_and_component(void);
+
+// Testsuite 'Transitive'
+void Transitive_1_fact_0_lvl_true(void);
+void Transitive_1_fact_1_lvl_true(void);
+void Transitive_1_fact_2_lvl_true(void);
+void Transitive_1_fact_0_lvl_false(void);
+void Transitive_1_fact_1_lvl_false(void);
+void Transitive_1_fact_2_lvl_false(void);
+void Transitive_1_fact_reflexive(void);
+void Transitive_1_isa(void);
+void Transitive_1_childof(void);
+void Transitive_1_this_src_written_0_lvl(void);
+void Transitive_1_this_src_written_1_lvl(void);
+void Transitive_1_this_src_written_2_lvl(void);
+void Transitive_1_this_src_written_reflexive(void);
+void Transitive_1_this_src_0_lvl(void);
+void Transitive_1_this_src_1_lvl(void);
+void Transitive_1_this_src_2_lvl(void);
+void Transitive_1_this_src_reflexive(void);
+void Transitive_1_ent_src_tgt_var_0_lvl(void);
+void Transitive_1_ent_src_tgt_var_1_lvl(void);
+void Transitive_1_ent_src_tgt_var_2_lvl(void);
+void Transitive_1_ent_src_tgt_var_reflexive(void);
+void Transitive_1_this_src_tgt_var(void);
+void Transitive_1_this_src_tgt_var_reflexive(void);
+void Transitive_1_var_src_written_0_lvl(void);
+void Transitive_1_var_src_written_1_lvl(void);
+void Transitive_1_var_src_written_2_lvl(void);
+void Transitive_1_var_src_written_reflexive(void);
+void Transitive_1_var_src_0_lvl(void);
+void Transitive_1_var_src_1_lvl(void);
+void Transitive_1_var_src_2_lvl(void);
+void Transitive_1_var_src_reflexive(void);
+void Transitive_1_var_src_tgt_var(void);
+void Transitive_1_var_src_tgt_var_reflexive(void);
+void Transitive_1_ent_src_tgt_this_0_lvl(void);
+void Transitive_1_ent_src_tgt_this_1_lvl(void);
+void Transitive_1_ent_src_tgt_this_2_lvl(void);
+void Transitive_1_ent_src_tgt_this_reflexive(void);
+void Transitive_1_var_src_tgt_this(void);
+void Transitive_1_var_src_tgt_this_reflexive(void);
+void Transitive_2_ent_src_constrain_tgt_var_before_0_lvl(void);
+void Transitive_2_ent_src_constrain_tgt_var_before_1_lvl(void);
+void Transitive_2_ent_src_constrain_tgt_var_before_2_lvl(void);
+void Transitive_2_ent_src_constrain_tgt_var_after_0_lvl(void);
+void Transitive_2_ent_src_constrain_tgt_var_after_1_lvl(void);
+void Transitive_2_ent_src_constrain_tgt_var_after_2_lvl(void);
+void Transitive_2_this_src_constrain_tgt_var_before_0_lvl(void);
+void Transitive_2_this_src_constrain_tgt_var_before_1_lvl(void);
+void Transitive_2_this_src_constrain_tgt_var_before_2_lvl(void);
+void Transitive_2_this_src_constrain_tgt_var_after_0_lvl(void);
+void Transitive_2_this_src_constrain_tgt_var_after_1_lvl(void);
+void Transitive_2_this_src_constrain_tgt_var_after_2_lvl(void);
+void Transitive_1_src_tgt_same_var(void);
+void Transitive_1_src_tgt_same_var_reflexive(void);
+void Transitive_1_src_tgt_same_this_var_reflexive(void);
+void Transitive_1_any_src_tgt_var(void);
+void Transitive_not_transitive_ent_tgt(void);
+void Transitive_not_transitive_var_tgt(void);
+void Transitive_not_transitive_ent_tgt_written(void);
+void Transitive_not_transitive_var_tgt_written(void);
+void Transitive_optional_transitive_ent_tgt(void);
+void Transitive_optional_transitive_var_tgt(void);
+void Transitive_optional_transitive_ent_tgt_written(void);
+void Transitive_optional_transitive_var_tgt_written(void);
+void Transitive_2_var_src_w_same_tgt_ent(void);
+void Transitive_self_target(void);
+void Transitive_any_target(void);
+void Transitive_isa_prefab(void);
+void Transitive_isa_disabled(void);
+void Transitive_isa_prefab_match_prefab_flag(void);
+void Transitive_isa_prefab_match_prefab_term(void);
+void Transitive_isa_disabled_match_disabled_flag(void);
+void Transitive_isa_disabled_match_disabled_term(void);
+
+// Testsuite 'ComponentInheritance'
+void ComponentInheritance_1_ent_0_lvl(void);
+void ComponentInheritance_1_ent_1_lvl(void);
+void ComponentInheritance_1_ent_2_lvl(void);
+void ComponentInheritance_1_ent_3_lvl(void);
+void ComponentInheritance_1_this_0_lvl(void);
+void ComponentInheritance_1_this_1_lvl(void);
+void ComponentInheritance_1_this_2_lvl(void);
+void ComponentInheritance_1_this_3_lvl(void);
+void ComponentInheritance_1_this_0_lvl_written(void);
+void ComponentInheritance_1_this_1_lvl_written(void);
+void ComponentInheritance_1_this_2_lvl_written(void);
+void ComponentInheritance_1_this_3_lvl_written(void);
+void ComponentInheritance_1_var_0_lvl(void);
+void ComponentInheritance_1_var_1_lvl(void);
+void ComponentInheritance_1_var_2_lvl(void);
+void ComponentInheritance_1_var_3_lvl(void);
+void ComponentInheritance_1_var_0_lvl_written(void);
+void ComponentInheritance_1_var_1_lvl_written(void);
+void ComponentInheritance_1_var_2_lvl_written(void);
+void ComponentInheritance_1_var_3_lvl_written(void);
+void ComponentInheritance_1_ent_1_lvl_self(void);
+void ComponentInheritance_1_this_1_lvl_self(void);
+void ComponentInheritance_1_this_1_lvl_written_self(void);
+void ComponentInheritance_1_var_1_lvl_self(void);
+void ComponentInheritance_1_var_1_lvl_written_self(void);
+void ComponentInheritance_1_ent_src_not(void);
+void ComponentInheritance_1_this_src_not(void);
+void ComponentInheritance_1_var_src_not(void);
+void ComponentInheritance_1_this_src_not_written(void);
+void ComponentInheritance_1_var_src_not_written(void);
+void ComponentInheritance_first_self(void);
+
+// Testsuite 'Recycled'
+void Recycled_setup(void);
+void Recycled_recycled_vars(void);
+void Recycled_recycled_pair_vars(void);
+void Recycled_recycled_this_ent_var(void);
+void Recycled_has_recycled_id_from_pair(void);
+void Recycled_recycled_pair(void);
+void Recycled_recycled_component_id(void);
+
+// Testsuite 'BuiltinPredicates'
+void BuiltinPredicates_setup(void);
+void BuiltinPredicates_this_eq_id(void);
+void BuiltinPredicates_this_eq_name(void);
+void BuiltinPredicates_this_eq_var(void);
+void BuiltinPredicates_this_eq_id_written(void);
+void BuiltinPredicates_this_eq_id_written_no_match(void);
+void BuiltinPredicates_this_eq_name_written(void);
+void BuiltinPredicates_this_eq_name_written_no_match(void);
+void BuiltinPredicates_this_eq_var_written(void);
+void BuiltinPredicates_var_eq_id(void);
+void BuiltinPredicates_var_eq_name(void);
+void BuiltinPredicates_var_eq_var(void);
+void BuiltinPredicates_var_eq_id_written(void);
+void BuiltinPredicates_var_eq_id_written_no_match(void);
+void BuiltinPredicates_var_eq_name_written(void);
+void BuiltinPredicates_var_eq_name_written_no_match(void);
+void BuiltinPredicates_var_eq_var_written(void);
+void BuiltinPredicates_var_eq_this(void);
+void BuiltinPredicates_this_neq_id(void);
+void BuiltinPredicates_this_neq_name(void);
+void BuiltinPredicates_this_neq_var(void);
+void BuiltinPredicates_this_neq_id_written(void);
+void BuiltinPredicates_this_neq_id_written_no_match(void);
+void BuiltinPredicates_this_neq_name_written(void);
+void BuiltinPredicates_this_neq_name_written_no_match(void);
+void BuiltinPredicates_this_neq_var_written(void);
+void BuiltinPredicates_var_neq_id(void);
+void BuiltinPredicates_var_neq_name(void);
+void BuiltinPredicates_var_neq_var(void);
+void BuiltinPredicates_var_neq_id_written(void);
+void BuiltinPredicates_var_neq_id_written_no_match(void);
+void BuiltinPredicates_var_neq_name_written(void);
+void BuiltinPredicates_var_neq_name_written_no_match(void);
+void BuiltinPredicates_var_neq_var_written(void);
+void BuiltinPredicates_var_neq_this(void);
+void BuiltinPredicates_this_2_neq_id(void);
+void BuiltinPredicates_this_2_neq_name(void);
+void BuiltinPredicates_var_2_neq_id(void);
+void BuiltinPredicates_var_2_neq_name(void);
+void BuiltinPredicates_this_2_neq_id_written(void);
+void BuiltinPredicates_this_2_neq_name_written(void);
+void BuiltinPredicates_var_2_neq_id_written(void);
+void BuiltinPredicates_var_2_neq_name_written(void);
+void BuiltinPredicates_this_2_or_id(void);
+void BuiltinPredicates_this_3_or_id(void);
+void BuiltinPredicates_this_2_or_name(void);
+void BuiltinPredicates_this_3_or_name(void);
+void BuiltinPredicates_this_2_or_match(void);
+void BuiltinPredicates_this_3_or_match(void);
+void BuiltinPredicates_var_2_or_id(void);
+void BuiltinPredicates_var_2_or_name(void);
+void BuiltinPredicates_this_2_or_id_written(void);
+void BuiltinPredicates_this_3_or_id_written(void);
+void BuiltinPredicates_this_2_or_name_written(void);
+void BuiltinPredicates_var_2_or_id_written(void);
+void BuiltinPredicates_var_2_or_name_written(void);
+void BuiltinPredicates_this_match_eq(void);
+void BuiltinPredicates_var_match_eq(void);
+void BuiltinPredicates_this_match_eq_written(void);
+void BuiltinPredicates_this_match_eq_written_self(void);
+void BuiltinPredicates_var_match_eq_written(void);
+void BuiltinPredicates_this_match_neq(void);
+void BuiltinPredicates_var_match_neq(void);
+void BuiltinPredicates_this_match_neq_written(void);
+void BuiltinPredicates_var_match_neq_written(void);
+void BuiltinPredicates_this_match_2_neq(void);
+void BuiltinPredicates_var_match_2_neq(void);
+void BuiltinPredicates_this_match_2_neq_written(void);
+void BuiltinPredicates_var_match_2_neq_written(void);
+void BuiltinPredicates_this_match_2_or(void);
+void BuiltinPredicates_this_match_2_or_written(void);
+void BuiltinPredicates_this_match_3_or(void);
+void BuiltinPredicates_this_match_3_or_written(void);
+void BuiltinPredicates_unresolved_by_name(void);
+void BuiltinPredicates_var_eq_wildcard(void);
+void BuiltinPredicates_var_eq_any(void);
+void BuiltinPredicates_var_eq_wildcard_after_write(void);
+void BuiltinPredicates_var_eq_any_after_write(void);
+void BuiltinPredicates_var_eq_after_var_0_src(void);
+void BuiltinPredicates_2_or_w_eq_this(void);
+void BuiltinPredicates_2_or_w_eq_lookup_var(void);
+void BuiltinPredicates_3_or_w_eq_lookup_var(void);
+
+// Testsuite 'Scopes'
+void Scopes_setup(void);
+void Scopes_term_w_not_scope_1_term(void);
+void Scopes_term_w_not_scope_2_terms(void);
+void Scopes_term_w_not_scope_1_term_w_not(void);
+void Scopes_term_w_not_scope_2_terms_w_not(void);
+void Scopes_term_w_not_scope_1_term_w_var(void);
+void Scopes_term_w_not_scope_2_terms_w_var(void);
+void Scopes_term_w_not_scope_1_term_w_not_w_var(void);
+void Scopes_term_w_not_scope_2_terms_w_not_w_var(void);
+void Scopes_term_w_not_scope_2_terms_w_or(void);
+void Scopes_term_w_not_scope_3_terms_w_or(void);
+
+// Testsuite 'Traversal'
+void Traversal_setup(void);
+void Traversal_this_self_up_childof(void);
+void Traversal_this_up_childof(void);
+void Traversal_this_written_self_up_childof(void);
+void Traversal_this_written_up_childof(void);
+void Traversal_var_self_up_childof(void);
+void Traversal_var_up_childof(void);
+void Traversal_var_written_self_up_childof(void);
+void Traversal_var_written_up_childof(void);
+void Traversal_set_var_self_up_childof(void);
+void Traversal_set_var_up_childof(void);
+void Traversal_set_var_written_self_up_childof(void);
+void Traversal_set_var_written_up_childof(void);
+void Traversal_ent_self_up_childof(void);
+void Traversal_ent_up_childof(void);
+void Traversal_implicit_this_self_up_isa(void);
+void Traversal_implicit_this_up_isa(void);
+void Traversal_implicit_var_self_up_isa(void);
+void Traversal_implicit_var_up_isa(void);
+void Traversal_implicit_ent_self_up_isa(void);
+void Traversal_implicit_ent_up_isa(void);
+void Traversal_self_up_2_targets(void);
+void Traversal_up_2_targets(void);
+void Traversal_self_up_2_targets_diamond(void);
+void Traversal_up_2_targets_diamond(void);
+void Traversal_written_self_up_2_targets(void);
+void Traversal_written_up_2_targets(void);
+void Traversal_written_self_up_2_targets_diamond(void);
+void Traversal_written_up_2_targets_diamond(void);
+void Traversal_2_self_up_terms(void);
+void Traversal_2_self_up_terms_2_targets(void);
+void Traversal_self_up_empty_table(void);
+void Traversal_up_empty_table(void);
+void Traversal_self_up_all_owned(void);
+void Traversal_up_all_owned(void);
+void Traversal_this_self_up_childof_inherited(void);
+void Traversal_this_up_childof_inherited(void);
+void Traversal_this_written_self_up_childof_inherited(void);
+void Traversal_this_written_up_childof_inherited(void);
+void Traversal_var_self_up_childof_inherited(void);
+void Traversal_var_up_childof_inherited(void);
+void Traversal_var_written_self_up_childof_inherited(void);
+void Traversal_var_written_up_childof_inherited(void);
+void Traversal_ent_self_up_childof_inherited(void);
+void Traversal_ent_up_childof_inherited(void);
+void Traversal_ent_written_self_up_childof_inherited(void);
+void Traversal_ent_written_up_childof_inherited(void);
+void Traversal_this_self_up_childof_component(void);
+void Traversal_this_up_childof_component(void);
+void Traversal_this_written_self_up_childof_component(void);
+void Traversal_this_written_up_childof_component(void);
+void Traversal_var_self_up_childof_component(void);
+void Traversal_var_up_childof_component(void);
+void Traversal_var_written_self_up_childof_component(void);
+void Traversal_var_written_up_childof_component(void);
+void Traversal_this_self_up_childof_recycled_parent(void);
+void Traversal_this_up_childof_recycled_parent(void);
+void Traversal_this_written_self_up_childof_recycled_parent(void);
+void Traversal_this_written_up_childof_recycled_parent(void);
+void Traversal_this_self_up_childof_recycled_parent_component(void);
+void Traversal_this_up_childof_recycled_parent_component(void);
+void Traversal_this_written_self_up_childof_recycled_parent_component(void);
+void Traversal_this_written_up_childof_recycled_parent_component(void);
+void Traversal_this_self_up_childof_pair(void);
+void Traversal_this_up_childof_pair(void);
+void Traversal_this_written_self_up_childof_pair(void);
+void Traversal_this_written_up_childof_pair(void);
+void Traversal_this_self_up_childof_pair_wildcard(void);
+void Traversal_this_up_childof_pair_wildcard(void);
+void Traversal_this_written_self_up_childof_pair_wildcard(void);
+void Traversal_this_written_up_childof_pair_wildcard(void);
+void Traversal_this_self_up_childof_pair_tgt_var(void);
+void Traversal_this_written_self_up_childof_pair_tgt_var(void);
+void Traversal_this_self_up_childof_pair_rel_var(void);
+void Traversal_this_written_self_up_childof_pair_rel_var(void);
+void Traversal_this_self_up_childof_pair_for_var_written(void);
+void Traversal_this_up_childof_pair_for_var_written(void);
+void Traversal_this_written_self_up_childof_pair_for_var_written(void);
+void Traversal_this_self_up_childof_pair_for_var_written_n_targets(void);
+void Traversal_this_written_self_up_childof_pair_for_var_written_n_targets(void);
+void Traversal_self_up_2_levels(void);
+void Traversal_not_up_disabled(void);
+void Traversal_up_2_rel_instances(void);
+void Traversal_up_2_rel_instances_match_2nd(void);
+void Traversal_up_only_w_owned(void);
+void Traversal_this_up_trav_unused_rel(void);
+void Traversal_this_optional_self(void);
+void Traversal_this_optional_up(void);
+void Traversal_this_optional_self_up(void);
+void Traversal_this_written_optional_self(void);
+void Traversal_this_written_optional_up(void);
+void Traversal_this_written_optional_self_up(void);
+void Traversal_fixed_src_w_up(void);
+void Traversal_match_empty_table_up(void);
+void Traversal_match_empty_table_up_written(void);
+void Traversal_match_empty_table_up_implicit_isa(void);
+void Traversal_match_empty_table_up_written_implicit_isa(void);
+void Traversal_match_empty_table_up_isa(void);
+void Traversal_match_empty_table_up_written_isa(void);
+
+// Testsuite 'Cascade'
+void Cascade_this_self_cascade_childof_uncached(void);
+void Cascade_this_cascade_childof_uncached(void);
+void Cascade_this_written_self_cascade_childof_uncached(void);
+void Cascade_this_written_cascade_childof_uncached(void);
+void Cascade_this_self_cascade_childof_w_parent_flag_uncached(void);
+void Cascade_this_cascade_childof_w_parent_flag_uncached(void);
+void Cascade_this_written_self_cascade_childof_w_parent_flag_uncached(void);
+void Cascade_this_written_cascade_childof_w_parent_flag_uncached(void);
+void Cascade_parent_cascade(void);
+void Cascade_existing_custom_rel_cascade(void);
+void Cascade_new_custom_rel_cascade(void);
+void Cascade_cascade_w_2_depths(void);
+void Cascade_cascade_w_3_depths(void);
+void Cascade_cascade_w_2_depths_desc(void);
+void Cascade_cascade_w_3_depths_desc(void);
+void Cascade_existing_isa_cascade(void);
+void Cascade_new_isa_cascade(void);
+void Cascade_childof_cascade(void);
+void Cascade_cascade_rematch_2_lvls(void);
+void Cascade_cascade_rematch_2_lvls_2_relations(void);
+void Cascade_cascade_topological(void);
+void Cascade_cascade_desc_rematch_2_lvls(void);
+void Cascade_cascade_desc_rematch_2_lvls_2_relations(void);
+void Cascade_cascade_desc_topological(void);
+void Cascade_cascade_after_recycled_parent_change(void);
+
+// Testsuite 'Cached'
+void Cached_simple_query_existing_table(void);
+void Cached_simple_query_2_existing_tables(void);
+void Cached_simple_query_new_table(void);
+void Cached_simple_query_2_new_tables(void);
+void Cached_simple_query_existing_and_new_table(void);
+void Cached_wildcard_query_existing_table(void);
+void Cached_wildcard_query_new_table(void);
+void Cached_wildcard_query_existing_table_2_results_p_table(void);
+void Cached_wildcard_query_new_table_2_results_p_table(void);
+void Cached_wildcard_query_2nd_term(void);
+void Cached_wildcard_query_2nd_term_self(void);
+void Cached_simple_query_existing_empty_table(void);
+void Cached_simple_query_existing_empty_type(void);
+void Cached_simple_query_new_empty_table(void);
+void Cached_component_query_existing_table(void);
+void Cached_component_query_new_table(void);
+void Cached_component_query_existing_empty_table(void);
+void Cached_2_component_query_existing_empty_table(void);
+void Cached_2_component_query_existing_empty_type(void);
+void Cached_only_optional(void);
+void Cached_only_optional_new_empty_table(void);
+void Cached_only_optional_new_empty_non_empty_table(void);
+void Cached_only_optional_new_unset_tables(void);
+void Cached_singleton_w_optional_new_empty_table(void);
+void Cached_singleton_w_optional_new_empty_non_empty_table(void);
+void Cached_singleton_w_optional_new_unset_tables(void);
+void Cached_query_w_from_entity_match_after(void);
+void Cached_query_w_from_singleton_match_after(void);
+void Cached_query_rematch_optional_after_add(void);
+void Cached_get_owned_tag(void);
+void Cached_get_shared_tag(void);
+void Cached_explicit_delete(void);
+void Cached_get_column_size(void);
+void Cached_stresstest_query_free(void);
+void Cached_query_optional_tag(void);
+void Cached_query_optional_shared_tag(void);
+void Cached_query_iter_10_tags(void);
+void Cached_query_iter_10_components(void);
+void Cached_iter_type_set(void);
+void Cached_filter_term(void);
+void Cached_2_terms_1_filter(void);
+void Cached_3_terms_2_filter(void);
+void Cached_no_instancing_w_singleton(void);
+void Cached_add_singleton_after_query(void);
+void Cached_query_w_component_from_parent_from_non_this(void);
+void Cached_create_query_while_pending(void);
+void Cached_empty_query(void);
+void Cached_not_pair_relation_wildcard(void);
+void Cached_not_pair_object_wildcard(void);
+void Cached_two_pair_wildcards_one_not(void);
+void Cached_two_pair_wildcards_one_not_any(void);
+void Cached_implicit_existing_isa_superset(void);
+void Cached_implicit_new_isa_superset(void);
+void Cached_isa_superset(void);
+void Cached_isa_superset_2_lvls(void);
+void Cached_isa_superset_3_lvls(void);
+void Cached_isa_superset_2_lvls_owned(void);
+void Cached_isa_superset_3_lvls_owned(void);
+void Cached_isa_superset_owned_empty_table_after_match(void);
+void Cached_isa_self_superset(void);
+void Cached_childof_superset(void);
+void Cached_superset_2_targets(void);
+void Cached_superset_2_relations(void);
+void Cached_superset_2_relations_instanced(void);
+void Cached_superset_2_relations_w_component(void);
+void Cached_superset_2_relations_instanced_w_component(void);
+void Cached_parent(void);
+void Cached_isa_rematch(void);
+void Cached_childof_rematch(void);
+void Cached_isa_unmatch(void);
+void Cached_childof_unmatch(void);
+void Cached_isa_rematch_2_lvls(void);
+void Cached_childof_rematch_2_lvls(void);
+void Cached_childof_rematch_from_isa(void);
+void Cached_rematch_optional_ref(void);
+void Cached_rematch_optional_ref_w_2_refs(void);
+void Cached_rematch_optional_ref_tag_w_ref_component(void);
+void Cached_rematch_after_add_to_recycled_parent(void);
+void Cached_match_query_expr_from_scope(void);
+void Cached_query_long_or_w_ref(void);
+void Cached_query_w_pair_id_and_subj(void);
+void Cached_rematch_after_delete_inherited_tag(void);
+void Cached_rematch_after_delete_rel_of_inherited_pair(void);
+void Cached_rematch_after_delete_obj_of_inherited_pair(void);
+void Cached_rematch_empty_table_w_superset(void);
+void Cached_2_self_up_terms_new_tables(void);
+void Cached_this_self_up_childof_pair_new_tables(void);
+
+// Testsuite 'ChangeDetection'
+void ChangeDetection_query_changed_after_new(void);
+void ChangeDetection_query_changed_after_delete(void);
+void ChangeDetection_query_changed_after_add(void);
+void ChangeDetection_query_changed_after_remove(void);
+void ChangeDetection_query_changed_after_set(void);
+void ChangeDetection_query_change_after_modified(void);
+void ChangeDetection_query_change_after_out_system(void);
+void ChangeDetection_query_change_after_in_system(void);
+void ChangeDetection_query_change_after_modified_out_term(void);
+void ChangeDetection_query_change_check_iter(void);
+void ChangeDetection_query_change_check_iter_after_skip_read(void);
+void ChangeDetection_query_change_check_iter_after_skip_write(void);
+void ChangeDetection_query_change_parent_term(void);
+void ChangeDetection_query_change_prefab_term(void);
+void ChangeDetection_query_change_parent_term_w_tag(void);
+void ChangeDetection_query_change_prefab_term_w_tag(void);
+void ChangeDetection_query_change_skip_non_instanced(void);
+void ChangeDetection_query_changed_w_or(void);
+void ChangeDetection_query_changed_or(void);
+void ChangeDetection_query_changed_w_singleton(void);
+void ChangeDetection_query_changed_w_only_singleton(void);
+void ChangeDetection_query_changed_w_only_singleton_after_set(void);
+void ChangeDetection_query_changed_w_only_singleton_after_out_term(void);
+void ChangeDetection_query_changed_w_only_singleton_after_singleton_out_term(void);
+void ChangeDetection_query_changed_w_only_parent(void);
+void ChangeDetection_query_changed_w_only_parent_after_set(void);
+void ChangeDetection_query_changed_w_only_parent_after_out_term(void);
+void ChangeDetection_query_changed_w_only_parent_after_parent_out_term(void);
+void ChangeDetection_query_changed_tag(void);
+void ChangeDetection_query_changed_no_source(void);
+void ChangeDetection_query_changed_no_source_component(void);
+void ChangeDetection_query_changed_w_not_out(void);
+
+// Testsuite 'GroupBy'
+void GroupBy_group_by(void);
+void GroupBy_group_by_w_ctx(void);
+void GroupBy_group_by_w_sort_reverse_group_creation(void);
+void GroupBy_group_by_iter_one(void);
+void GroupBy_group_by_iter_one_all_groups(void);
+void GroupBy_group_by_iter_one_empty(void);
+void GroupBy_group_by_iter_one_empty_query(void);
+void GroupBy_group_by_iter_one_empty_table(void);
+void GroupBy_group_by_w_deleted_group_id(void);
+void GroupBy_group_by_callbacks(void);
+void GroupBy_group_by_default_action(void);
+void GroupBy_group_table_count(void);
+
+// Testsuite 'MemberTarget'
+void MemberTarget_setup(void);
+void MemberTarget_this_member_eq_1(void);
+void MemberTarget_this_member_eq_2(void);
+void MemberTarget_this_member_eq_no_matches(void);
+void MemberTarget_this_member_eq_all_matches(void);
+void MemberTarget_this_member_wildcard(void);
+void MemberTarget_this_member_var(void);
+void MemberTarget_this_member_var_written(void);
+void MemberTarget_this_member_var_read(void);
+void MemberTarget_this_member_eq_1_2nd_member(void);
+void MemberTarget_this_member_eq_2_2nd_member(void);
+void MemberTarget_this_member_var_same_1(void);
+void MemberTarget_this_member_var_same_2(void);
+void MemberTarget_this_written_member_eq_1(void);
+void MemberTarget_this_written_member_eq_2(void);
+void MemberTarget_this_written_member_wildcard(void);
+void MemberTarget_this_written_member_var(void);
+void MemberTarget_this_member_neq_1(void);
+void MemberTarget_this_member_neq_2(void);
+void MemberTarget_this_member_neq_no_matches(void);
+void MemberTarget_this_member_neq_all_matches(void);
+void MemberTarget_this_member_neq_wildcard(void);
+void MemberTarget_this_written_member_neq_1(void);
+void MemberTarget_this_written_member_neq_2(void);
+void MemberTarget_this_written_member_neq_no_matches(void);
+void MemberTarget_this_written_member_neq_all_matches(void);
+void MemberTarget_this_written_member_neq_wildcard(void);
+void MemberTarget_this_member_eq_optional(void);
+void MemberTarget_this_member_eq_optional_wildcard(void);
+void MemberTarget_this_written_member_eq_optional(void);
+void MemberTarget_this_written_member_eq_optional_wildcard(void);
+void MemberTarget_this_member_eq_w_other_tag(void);
+void MemberTarget_this_member_eq_w_other_component(void);
+void MemberTarget_this_written_member_eq_w_other_tag(void);
+void MemberTarget_this_written_member_eq_w_other_component(void);
+void MemberTarget_this_2_or(void);
+void MemberTarget_this_3_or(void);
+void MemberTarget_this_written_2_or(void);
+void MemberTarget_this_written_3_or(void);
+void MemberTarget_var_2_or(void);
+void MemberTarget_var_3_or(void);
+void MemberTarget_this_2_or_w_2_members(void);
+void MemberTarget_this_2_or_w_2_types(void);
+void MemberTarget_this_written_2_or_w_2_members(void);
+void MemberTarget_this_written_2_or_w_2_types(void);
+void MemberTarget_this_2_or_2_types_wildcard(void);
+void MemberTarget_this_2_or_2_types_dep_var(void);
+void MemberTarget_var_written_2_or(void);
+void MemberTarget_var_written_3_or(void);
+void MemberTarget_var_member_eq(void);
+void MemberTarget_var_member_eq_no_matches(void);
+void MemberTarget_var_member_eq_all_matches(void);
+void MemberTarget_var_member_wildcard(void);
+void MemberTarget_var_member_neq(void);
+void MemberTarget_var_member_neq_no_matches(void);
+void MemberTarget_var_member_neq_all_matches(void);
+void MemberTarget_var_written_member_eq(void);
+void MemberTarget_var_written_member_eq_no_matches(void);
+void MemberTarget_var_written_member_eq_all_matches(void);
+void MemberTarget_var_written_member_wildcard(void);
+void MemberTarget_var_written_member_neq(void);
+void MemberTarget_var_written_member_neq_no_matches(void);
+void MemberTarget_var_written_member_neq_all_matches(void);
+
+// Testsuite 'Toggle'
+void Toggle_setup(void);
+void Toggle_fixed_src_1_tag_toggle(void);
+void Toggle_fixed_src_1_component_toggle(void);
+void Toggle_fixed_src_2_tag_toggle(void);
+void Toggle_fixed_src_2_component_toggle(void);
+void Toggle_fixed_2_src_w_toggle(void);
+void Toggle_this_w_fixed_src_w_toggle(void);
+void Toggle_fixed_src_w_this_w_toggle(void);
+void Toggle_this_from_nothing(void);
+void Toggle_this(void);
+void Toggle_this_skip_initial(void);
+void Toggle_this_pair(void);
+void Toggle_this_pair_skip_initial(void);
+void Toggle_this_tag(void);
+void Toggle_this_tag_pair(void);
+void Toggle_this_tag_pair_wildcard(void);
+void Toggle_this_toggle_shared_self_up(void);
+void Toggle_this_toggle_shared_up(void);
+void Toggle_this_toggle_shared_self_up_w_self(void);
+void Toggle_this_toggle_shared_up_w_self(void);
+void Toggle_this_toggle_shared_self_up_w_self_reverse(void);
+void Toggle_this_toggle_shared_up_w_self_reverse(void);
+void Toggle_this_toggle_shared_self_up_w_self_toggle(void);
+void Toggle_this_toggle_shared_up_w_self_toggle(void);
+void Toggle_this_toggle_shared_self_up_w_self_toggle_reverse(void);
+void Toggle_this_toggle_shared_up_w_self_toggle_reverse(void);
+void Toggle_this_toggle_not_shared_self_up(void);
+void Toggle_this_toggle_not_shared_up(void);
+void Toggle_this_toggle_optional_shared_self_up(void);
+void Toggle_this_toggle_optional_shared_up(void);
+void Toggle_this_64_mod_1(void);
+void Toggle_this_64_mod_2(void);
+void Toggle_this_64_mod_3(void);
+void Toggle_this_64_mod_7(void);
+void Toggle_this_64_mod_8(void);
+void Toggle_this_64_mod_10(void);
+void Toggle_this_64_mod_64(void);
+void Toggle_this_64_mod_256(void);
+void Toggle_this_64_mod_1024(void);
+void Toggle_this_100_mod_1(void);
+void Toggle_this_100_mod_2(void);
+void Toggle_this_100_mod_3(void);
+void Toggle_this_100_mod_7(void);
+void Toggle_this_100_mod_8(void);
+void Toggle_this_100_mod_10(void);
+void Toggle_this_100_mod_64(void);
+void Toggle_this_100_mod_256(void);
+void Toggle_this_100_mod_1024(void);
+void Toggle_this_128_mod_1(void);
+void Toggle_this_128_mod_2(void);
+void Toggle_this_128_mod_3(void);
+void Toggle_this_128_mod_7(void);
+void Toggle_this_128_mod_8(void);
+void Toggle_this_128_mod_10(void);
+void Toggle_this_128_mod_64(void);
+void Toggle_this_128_mod_256(void);
+void Toggle_this_128_mod_1024(void);
+void Toggle_this_200_mod_1(void);
+void Toggle_this_200_mod_2(void);
+void Toggle_this_200_mod_3(void);
+void Toggle_this_200_mod_7(void);
+void Toggle_this_200_mod_8(void);
+void Toggle_this_200_mod_10(void);
+void Toggle_this_200_mod_64(void);
+void Toggle_this_200_mod_256(void);
+void Toggle_this_200_mod_1024(void);
+void Toggle_this_1024_mod_1(void);
+void Toggle_this_1024_mod_2(void);
+void Toggle_this_1024_mod_3(void);
+void Toggle_this_1024_mod_7(void);
+void Toggle_this_1024_mod_8(void);
+void Toggle_this_1024_mod_10(void);
+void Toggle_this_1024_mod_64(void);
+void Toggle_this_1024_mod_256(void);
+void Toggle_this_1024_mod_1024(void);
+void Toggle_this_enabled_64_mod_1(void);
+void Toggle_this_enabled_64_mod_2(void);
+void Toggle_this_enabled_64_mod_3(void);
+void Toggle_this_enabled_64_mod_7(void);
+void Toggle_this_enabled_64_mod_8(void);
+void Toggle_this_enabled_64_mod_10(void);
+void Toggle_this_enabled_64_mod_64(void);
+void Toggle_this_enabled_64_mod_256(void);
+void Toggle_this_enabled_64_mod_1024(void);
+void Toggle_this_enabled_100_mod_1(void);
+void Toggle_this_enabled_100_mod_2(void);
+void Toggle_this_enabled_100_mod_3(void);
+void Toggle_this_enabled_100_mod_7(void);
+void Toggle_this_enabled_100_mod_8(void);
+void Toggle_this_enabled_100_mod_10(void);
+void Toggle_this_enabled_100_mod_64(void);
+void Toggle_this_enabled_100_mod_256(void);
+void Toggle_this_enabled_100_mod_1024(void);
+void Toggle_this_enabled_128_mod_1(void);
+void Toggle_this_enabled_128_mod_2(void);
+void Toggle_this_enabled_128_mod_3(void);
+void Toggle_this_enabled_128_mod_7(void);
+void Toggle_this_enabled_128_mod_8(void);
+void Toggle_this_enabled_128_mod_10(void);
+void Toggle_this_enabled_128_mod_64(void);
+void Toggle_this_enabled_128_mod_256(void);
+void Toggle_this_enabled_128_mod_1024(void);
+void Toggle_this_enabled_200_mod_1(void);
+void Toggle_this_enabled_200_mod_2(void);
+void Toggle_this_enabled_200_mod_3(void);
+void Toggle_this_enabled_200_mod_7(void);
+void Toggle_this_enabled_200_mod_8(void);
+void Toggle_this_enabled_200_mod_10(void);
+void Toggle_this_enabled_200_mod_64(void);
+void Toggle_this_enabled_200_mod_256(void);
+void Toggle_this_enabled_200_mod_1024(void);
+void Toggle_this_enabled_1024_mod_1(void);
+void Toggle_this_enabled_1024_mod_2(void);
+void Toggle_this_enabled_1024_mod_3(void);
+void Toggle_this_enabled_1024_mod_7(void);
+void Toggle_this_enabled_1024_mod_8(void);
+void Toggle_this_enabled_1024_mod_10(void);
+void Toggle_this_enabled_1024_mod_64(void);
+void Toggle_this_enabled_1024_mod_256(void);
+void Toggle_this_enabled_1024_mod_1024(void);
+void Toggle_this_mod_2_2_bitsets(void);
+void Toggle_this_mod_8_2_bitsets(void);
+void Toggle_this_mod_64_2_bitsets(void);
+void Toggle_this_mod_256_2_bitsets(void);
+void Toggle_this_mod_1024_2_bitsets(void);
+void Toggle_this_randomized_2_bitsets(void);
+void Toggle_this_randomized_3_bitsets(void);
+void Toggle_this_randomized_4_bitsets(void);
+void Toggle_this_w_other_tag(void);
+void Toggle_this_w_other_component(void);
+void Toggle_this_not(void);
+void Toggle_this_written_not_1024_mod_2(void);
+void Toggle_this_written_not_1024_mod_3(void);
+void Toggle_this_written_not_1024_mod_7(void);
+void Toggle_this_written_not_1024_mod_8(void);
+void Toggle_this_written_not_1024_mod_10(void);
+void Toggle_this_written_not_1024_mod_64(void);
+void Toggle_this_written_not_1024_mod_256(void);
+void Toggle_this_written_not_1024_mod_1024(void);
+void Toggle_this_optional(void);
+void Toggle_this_written_optional_1024_mod_2(void);
+void Toggle_this_written_optional_1024_mod_3(void);
+void Toggle_this_written_optional_1024_mod_7(void);
+void Toggle_this_written_optional_1024_mod_8(void);
+void Toggle_this_written_optional_1024_mod_10(void);
+void Toggle_this_written_optional_1024_mod_64(void);
+void Toggle_this_written_optional_1024_mod_256(void);
+void Toggle_this_written_optional_1024_mod_1024(void);
+void Toggle_this_written_toggle_w_not_toggle(void);
+void Toggle_this_written_not_toggle_w_toggle(void);
+void Toggle_this_written_toggle_w_optional_toggle(void);
+void Toggle_this_written_optional_toggle_w_toggle(void);
+void Toggle_this_written_not_w_optional_toggle(void);
+void Toggle_this_written_optional_w_not_toggle(void);
+void Toggle_this_written_2_not_toggle(void);
+void Toggle_this_written_2_optional_toggle(void);
+void Toggle_this_written_toggle_w_2_not_toggle(void);
+void Toggle_this_written_toggle_w_2_optional_toggle(void);
+void Toggle_this_written_2_toggle_w_not_toggle(void);
+void Toggle_this_written_2_toggle_w_optional_toggle(void);
+void Toggle_this_sort(void);
+void Toggle_this_table_move_2_from_3(void);
+
+// Testsuite 'OrderBy'
+void OrderBy_sort_by_component(void);
+void OrderBy_sort_by_component_2_tables(void);
+void OrderBy_sort_by_component_3_tables(void);
+void OrderBy_sort_by_entity(void);
+void OrderBy_sort_after_add(void);
+void OrderBy_sort_after_remove(void);
+void OrderBy_sort_after_delete(void);
+void OrderBy_sort_after_set(void);
+void OrderBy_sort_after_system(void);
+void OrderBy_sort_after_query(void);
+void OrderBy_sort_by_component_same_value_1(void);
+void OrderBy_sort_by_component_same_value_2(void);
+void OrderBy_sort_by_component_move_pivot(void);
+void OrderBy_sort_1000_entities(void);
+void OrderBy_sort_1000_entities_w_duplicates(void);
+void OrderBy_sort_1000_entities_again(void);
+void OrderBy_sort_1000_entities_2_types(void);
+void OrderBy_sort_1500_entities_3_types(void);
+void OrderBy_sort_2000_entities_4_types(void);
+void OrderBy_sort_2_entities_2_types(void);
+void OrderBy_sort_3_entities_3_types(void);
+void OrderBy_sort_3_entities_3_types_2(void);
+void OrderBy_sort_4_entities_4_types(void);
+void OrderBy_sort_1000_entities_2_types_again(void);
+void OrderBy_sort_1000_entities_add_type_after_sort(void);
+void OrderBy_sort_shared_component(void);
+void OrderBy_sort_shared_component_childof(void);
+void OrderBy_sort_w_tags_only(void);
+void OrderBy_sort_childof_marked(void);
+void OrderBy_sort_isa_marked(void);
+void OrderBy_sort_relation_marked(void);
+void OrderBy_dont_resort_after_set_unsorted_component(void);
+void OrderBy_dont_resort_after_set_unsorted_component_w_tag(void);
+void OrderBy_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void);
+void OrderBy_sort_component_not_queried_for(void);
+void OrderBy_sort_by_wildcard(void);
+void OrderBy_sort_shared_w_delete(void);
+void OrderBy_sort_w_nontrivial_component(void);
+void OrderBy_sort_by_wildcard(void);
+void OrderBy_sort_not_term(void);
+void OrderBy_sort_or_term(void);
+void OrderBy_sort_optional_term(void);
+
+// Testsuite 'OrderByEntireTable'
+void OrderByEntireTable_sort_by_component(void);
+void OrderByEntireTable_sort_by_component_2_tables(void);
+void OrderByEntireTable_sort_by_component_3_tables(void);
+void OrderByEntireTable_sort_by_entity(void);
+void OrderByEntireTable_sort_after_add(void);
+void OrderByEntireTable_sort_after_remove(void);
+void OrderByEntireTable_sort_after_delete(void);
+void OrderByEntireTable_sort_after_set(void);
+void OrderByEntireTable_sort_after_system(void);
+void OrderByEntireTable_sort_after_query(void);
+void OrderByEntireTable_sort_by_component_same_value_1(void);
+void OrderByEntireTable_sort_by_component_same_value_2(void);
+void OrderByEntireTable_sort_by_component_move_pivot(void);
+void OrderByEntireTable_sort_1000_entities(void);
+void OrderByEntireTable_sort_1000_entities_w_duplicates(void);
+void OrderByEntireTable_sort_1000_entities_again(void);
+void OrderByEntireTable_sort_1000_entities_2_types(void);
+void OrderByEntireTable_sort_1500_entities_3_types(void);
+void OrderByEntireTable_sort_2000_entities_4_types(void);
+void OrderByEntireTable_sort_2_entities_2_types(void);
+void OrderByEntireTable_sort_3_entities_3_types(void);
+void OrderByEntireTable_sort_3_entities_3_types_2(void);
+void OrderByEntireTable_sort_4_entities_4_types(void);
+void OrderByEntireTable_sort_1000_entities_2_types_again(void);
+void OrderByEntireTable_sort_1000_entities_add_type_after_sort(void);
+void OrderByEntireTable_sort_shared_component(void);
+void OrderByEntireTable_sort_w_tags_only(void);
+void OrderByEntireTable_sort_childof_marked(void);
+void OrderByEntireTable_sort_isa_marked(void);
+void OrderByEntireTable_sort_relation_marked(void);
+void OrderByEntireTable_dont_resort_after_set_unsorted_component(void);
+void OrderByEntireTable_dont_resort_after_set_unsorted_component_w_tag(void);
+void OrderByEntireTable_dont_resort_after_set_unsorted_component_w_tag_w_out_term(void);
+void OrderByEntireTable_sort_shared_w_delete(void);
+void OrderByEntireTable_sort_not_term(void);
+void OrderByEntireTable_sort_or_term(void);
+void OrderByEntireTable_sort_optional_term(void);
+
+// Testsuite 'QueryStr'
+void QueryStr_one_term(void);
+void QueryStr_one_term_w_inout(void);
+void QueryStr_two_terms(void);
+void QueryStr_two_terms_w_inout(void);
+void QueryStr_three_terms_w_or(void);
+void QueryStr_three_terms_w_or_inout(void);
+void QueryStr_four_terms_three_w_or_inout(void);
+void QueryStr_one_term_w_pair(void);
+void QueryStr_one_term_w_pair_entity_src(void);
+void QueryStr_one_term_w_self(void);
+void QueryStr_one_term_w_up(void);
+void QueryStr_one_term_w_0(void);
+void QueryStr_one_term_w_singleton(void);
+void QueryStr_one_term_w_final_pair(void);
+void QueryStr_one_term_w_final_dont_inherit_pair(void);
+void QueryStr_one_term_w_src_var(void);
+void QueryStr_one_term_w_first_var(void);
+void QueryStr_one_term_w_second_var(void);
+void QueryStr_one_term_w_first_var_entity_src(void);
+void QueryStr_one_term_w_pair_w_0_entity(void);
+void QueryStr_not_term(void);
+void QueryStr_wildcard_term(void);
+void QueryStr_scopes(void);
+void QueryStr_pred_eq(void);
+void QueryStr_pred_neq(void);
+void QueryStr_pred_eq_name(void);
+void QueryStr_pred_neq_name(void);
+void QueryStr_pred_eq_m(void);
+void QueryStr_pred_neq_m(void);
+
+bake_test_case Validator_testcases[] = {
+    {
+        "validate_1_term",
+        Validator_validate_1_term
+    },
+    {
+        "validate_1_term_component",
+        Validator_validate_1_term_component
+    },
+    {
+        "validate_2_terms",
+        Validator_validate_2_terms
+    },
+    {
+        "validate_3_terms",
+        Validator_validate_3_terms
+    },
+    {
+        "validate_3_terms_w_or",
+        Validator_validate_3_terms_w_or
+    },
+    {
+        "validate_4_terms_w_or_at_1",
+        Validator_validate_4_terms_w_or_at_1
+    },
+    {
+        "validate_1_term_wildcard",
+        Validator_validate_1_term_wildcard
+    },
+    {
+        "validate_1_term_any",
+        Validator_validate_1_term_any
+    },
+    {
+        "validate_1_term_same_subj_obj",
+        Validator_validate_1_term_same_subj_obj
+    },
+    {
+        "validate_1_term_acyclic_same_subj_obj",
+        Validator_validate_1_term_acyclic_same_subj_obj
+    },
+    {
+        "validate_1_term_acyclic_reflexive_same_subj_obj",
+        Validator_validate_1_term_acyclic_reflexive_same_subj_obj
+    },
+    {
+        "validate_1_term_same_subj_obj_var",
+        Validator_validate_1_term_same_subj_obj_var
+    },
+    {
+        "validate_1_term_acyclic_same_subj_obj_var",
+        Validator_validate_1_term_acyclic_same_subj_obj_var
+    },
+    {
+        "validate_1_term_acyclic_reflexive_same_subj_obj_var",
+        Validator_validate_1_term_acyclic_reflexive_same_subj_obj_var
+    },
+    {
+        "validate_1_term_non_acyclic_superset",
+        Validator_validate_1_term_non_acyclic_superset
+    },
+    {
+        "validate_1_term_dont_inherit_default_set",
+        Validator_validate_1_term_dont_inherit_default_set
+    },
+    {
+        "validate_1_term_dont_inherit_pair_default_set",
+        Validator_validate_1_term_dont_inherit_pair_default_set
+    },
+    {
+        "validate_1_term_cascade_implicit_trav",
+        Validator_validate_1_term_cascade_implicit_trav
+    },
+    {
+        "validate_1_term_cascade_isa",
+        Validator_validate_1_term_cascade_isa
+    },
+    {
+        "validate_1_term_cascade_childof",
+        Validator_validate_1_term_cascade_childof
+    },
+    {
+        "validate_1_term_cascade_down",
+        Validator_validate_1_term_cascade_down
+    },
+    {
+        "validate_1_term_optional_only",
+        Validator_validate_1_term_optional_only
+    },
+    {
+        "validate_1_term_transitive_pair",
+        Validator_validate_1_term_transitive_pair
+    },
+    {
+        "validate_1_variable_as_pred_only",
+        Validator_validate_1_variable_as_pred_only
+    },
+    {
+        "validate_1_variable_as_pred_w_subj",
+        Validator_validate_1_variable_as_pred_w_subj
+    },
+    {
+        "validate_1_variable_as_pred_w_pair",
+        Validator_validate_1_variable_as_pred_w_pair
+    },
+    {
+        "validate_1_variable_as_subj",
+        Validator_validate_1_variable_as_subj
+    },
+    {
+        "validate_1_variable_as_obj",
+        Validator_validate_1_variable_as_obj
+    },
+    {
+        "validate_2_terms_or_w_dontinherit",
+        Validator_validate_2_terms_or_w_dontinherit
+    },
+    {
+        "validate_2_terms_or_w_both_dontinherit",
+        Validator_validate_2_terms_or_w_both_dontinherit
+    },
+    {
+        "validate_w_pair_id",
+        Validator_validate_w_pair_id
+    },
+    {
+        "validate_w_pred_obj",
+        Validator_validate_w_pred_obj
+    },
+    {
+        "validate_w_pair_id_and_subj",
+        Validator_validate_w_pair_id_and_subj
+    },
+    {
+        "validate_1_w_pred_name",
+        Validator_validate_1_w_pred_name
+    },
+    {
+        "validate_1_w_final_pred_name",
+        Validator_validate_1_w_final_pred_name
+    },
+    {
+        "validate_1_w_subj_name",
+        Validator_validate_1_w_subj_name
+    },
+    {
+        "validate_1_w_obj_name",
+        Validator_validate_1_w_obj_name
+    },
+    {
+        "validate_w_this_implicit_variable",
+        Validator_validate_w_this_implicit_variable
+    },
+    {
+        "validate_w_this_explicit_entity",
+        Validator_validate_w_this_explicit_entity
+    },
+    {
+        "validate_w_first_this_implicit_variable",
+        Validator_validate_w_first_this_implicit_variable
+    },
+    {
+        "validate_w_first_this_explicit_entity",
+        Validator_validate_w_first_this_explicit_entity
+    },
+    {
+        "validate_w_second_this_implicit_variable",
+        Validator_validate_w_second_this_implicit_variable
+    },
+    {
+        "validate_w_second_this_explicit_entity",
+        Validator_validate_w_second_this_explicit_entity
+    },
+    {
+        "validate_w_this_variable_name",
+        Validator_validate_w_this_variable_name
+    },
+    {
+        "validate_w_src_var",
+        Validator_validate_w_src_var
+    },
+    {
+        "validate_w_first_var",
+        Validator_validate_w_first_var
+    },
+    {
+        "validate_w_second_var",
+        Validator_validate_w_second_var
+    },
+    {
+        "validate_w_src_var_from_name",
+        Validator_validate_w_src_var_from_name
+    },
+    {
+        "validate_w_first_first_var",
+        Validator_validate_w_first_first_var
+    },
+    {
+        "validate_w_second_second_var",
+        Validator_validate_w_second_second_var
+    },
+    {
+        "validate_w_0_source",
+        Validator_validate_w_0_source
+    },
+    {
+        "validate_w_0_target",
+        Validator_validate_w_0_target
+    },
+    {
+        "validate_2_terms_w_or",
+        Validator_validate_2_terms_w_or
+    },
+    {
+        "validate_2_terms_w_or_mixed_src_flags",
+        Validator_validate_2_terms_w_or_mixed_src_flags
+    },
+    {
+        "validate_2_terms_w_or_mixed_src_id",
+        Validator_validate_2_terms_w_or_mixed_src_id
+    },
+    {
+        "validate_2_terms_w_or_mixed_src_name",
+        Validator_validate_2_terms_w_or_mixed_src_name
+    },
+    {
+        "validate_2_terms_w_or_same_src_w_id_and_name",
+        Validator_validate_2_terms_w_or_same_src_w_id_and_name
+    },
+    {
+        "validate_w_and_flag",
+        Validator_validate_w_and_flag
+    },
+    {
+        "validate_w_or_flag",
+        Validator_validate_w_or_flag
+    },
+    {
+        "validate_w_not_flag",
+        Validator_validate_w_not_flag
+    },
+    {
+        "validate_filter",
+        Validator_validate_filter
+    },
+    {
+        "validate_double_init",
+        Validator_validate_double_init
+    },
+    {
+        "validate_double_init_w_expr",
+        Validator_validate_double_init_w_expr
+    },
+    {
+        "validate_double_init_w_expr_optional",
+        Validator_validate_double_init_w_expr_optional
+    },
+    {
+        "validate_w_tag_term_is_no_data",
+        Validator_validate_w_tag_term_is_no_data
+    },
+    {
+        "validate_w_inout_none_term_is_no_data",
+        Validator_validate_w_inout_none_term_is_no_data
+    },
+    {
+        "validate_w_tag_and_inout_none_term_is_no_data",
+        Validator_validate_w_tag_and_inout_none_term_is_no_data
+    },
+    {
+        "validate_w_not_term_is_no_data",
+        Validator_validate_w_not_term_is_no_data
+    },
+    {
+        "validate_w_no_transitive_pair",
+        Validator_validate_w_no_transitive_pair
+    },
+    {
+        "validate_w_transitive_pair_any_src",
+        Validator_validate_w_transitive_pair_any_src
+    },
+    {
+        "validate_w_transitive_pair",
+        Validator_validate_w_transitive_pair
+    },
+    {
+        "validate_w_transitive_tag_no_pair",
+        Validator_validate_w_transitive_tag_no_pair
+    },
+    {
+        "validate_w_transitive_tag_self_tgt",
+        Validator_validate_w_transitive_tag_self_tgt
+    },
+    {
+        "validate_w_transitive_tag_any_tgt",
+        Validator_validate_w_transitive_tag_any_tgt
+    },
+    {
+        "validate_w_pair_same_vars",
+        Validator_validate_w_pair_same_vars
+    },
+    {
+        "validate_w_pair_not_same_vars",
+        Validator_validate_w_pair_not_same_vars
+    },
+    {
+        "validate_w_pair_no_vars_not_same_vars",
+        Validator_validate_w_pair_no_vars_not_same_vars
+    },
+    {
+        "validate_w_pair_wildcard_not_same_vars",
+        Validator_validate_w_pair_wildcard_not_same_vars
+    },
+    {
+        "validate_w_pair_any_not_same_vars",
+        Validator_validate_w_pair_any_not_same_vars
+    },
+    {
+        "validate_w_no_pair_not_same_vars",
+        Validator_validate_w_no_pair_not_same_vars
+    },
+    {
+        "validate_not_childof_any",
+        Validator_validate_not_childof_any
+    },
+    {
+        "validate_w_inherited_id",
+        Validator_validate_w_inherited_id
+    },
+    {
+        "validate_w_inherited_pair",
+        Validator_validate_w_inherited_pair
+    },
+    {
+        "validate_w_non_inherited_id",
+        Validator_validate_w_non_inherited_id
+    },
+    {
+        "validate_w_non_inherited_pair",
+        Validator_validate_w_non_inherited_pair
+    },
+    {
+        "validate_w_first_wildcard_inout_none",
+        Validator_validate_w_first_wildcard_inout_none
+    },
+    {
+        "validate_w_first_var_inout_none",
+        Validator_validate_w_first_var_inout_none
+    },
+    {
+        "validate_w_pair_wildcard_inout_none",
+        Validator_validate_w_pair_wildcard_inout_none
+    },
+    {
+        "validate_w_pair_var_inout_none",
+        Validator_validate_w_pair_var_inout_none
+    },
+    {
+        "validate_w_unresolved_by_name",
+        Validator_validate_w_unresolved_by_name
+    },
+    {
+        "validate_w_unresolved_by_name_eq",
+        Validator_validate_w_unresolved_by_name_eq
+    },
+    {
+        "validate_childof_this",
+        Validator_validate_childof_this
+    },
+    {
+        "validate_childof_this_entity",
+        Validator_validate_childof_this_entity
+    },
+    {
+        "validate_childof_this_by_id",
+        Validator_validate_childof_this_by_id
+    },
+    {
+        "validate_filter_flag",
+        Validator_validate_filter_flag
+    },
+    {
+        "validate_first_0_name",
+        Validator_validate_first_0_name
+    },
+    {
+        "validate_src_0_name",
+        Validator_validate_src_0_name
+    },
+    {
+        "validate_second_0_name",
+        Validator_validate_second_0_name
+    },
+    {
+        "validate_singleton_src_w_first_name",
+        Validator_validate_singleton_src_w_first_name
+    },
+    {
+        "validate_singleton_second_w_first_name",
+        Validator_validate_singleton_second_w_first_name
+    }
+};
+
+bake_test_case Parser_testcases[] = {
+    {
+        "resolve_this",
+        Parser_resolve_this
+    },
+    {
+        "resolve_wildcard",
+        Parser_resolve_wildcard
+    },
+    {
+        "resolve_any",
+        Parser_resolve_any
+    },
+    {
+        "resolve_is_a",
+        Parser_resolve_is_a
+    },
+    {
+        "0",
+        Parser_0
+    },
+    {
+        "component_implicit_subject",
+        Parser_component_implicit_subject
+    },
+    {
+        "component_explicit_subject",
+        Parser_component_explicit_subject
+    },
+    {
+        "component_explicit_subject_this",
+        Parser_component_explicit_subject_this
+    },
+    {
+        "component_explicit_subject_this_by_name",
+        Parser_component_explicit_subject_this_by_name
+    },
+    {
+        "component_explicit_subject_this_by_var_name",
+        Parser_component_explicit_subject_this_by_var_name
+    },
+    {
+        "component_explicit_subject_wildcard",
+        Parser_component_explicit_subject_wildcard
+    },
+    {
+        "component_explicit_subject_any",
+        Parser_component_explicit_subject_any
+    },
+    {
+        "component_explicit_subject_0",
+        Parser_component_explicit_subject_0
+    },
+    {
+        "this_as_predicate",
+        Parser_this_as_predicate
+    },
+    {
+        "this_var_as_predicate",
+        Parser_this_var_as_predicate
+    },
+    {
+        "this_lowercase_var_as_predicate",
+        Parser_this_lowercase_var_as_predicate
+    },
+    {
+        "this_as_object",
+        Parser_this_as_object
+    },
+    {
+        "this_var_as_object",
+        Parser_this_var_as_object
+    },
+    {
+        "pair_implicit_subject",
+        Parser_pair_implicit_subject
+    },
+    {
+        "pair_implicit_subject_wildcard_pred",
+        Parser_pair_implicit_subject_wildcard_pred
+    },
+    {
+        "pair_implicit_subject_wildcard_obj",
+        Parser_pair_implicit_subject_wildcard_obj
+    },
+    {
+        "pair_implicit_subject_any_pred",
+        Parser_pair_implicit_subject_any_pred
+    },
+    {
+        "pair_implicit_subject_any_obj",
+        Parser_pair_implicit_subject_any_obj
+    },
+    {
+        "pair_implicit_subject_this_pred",
+        Parser_pair_implicit_subject_this_pred
+    },
+    {
+        "pair_implicit_subject_this_obj",
+        Parser_pair_implicit_subject_this_obj
+    },
+    {
+        "pair_implicit_subject_pred_w_self",
+        Parser_pair_implicit_subject_pred_w_self
+    },
+    {
+        "pair_implicit_subject_obj_w_self",
+        Parser_pair_implicit_subject_obj_w_self
+    },
+    {
+        "pair_implicit_subject_pred_w_up",
+        Parser_pair_implicit_subject_pred_w_up
+    },
+    {
+        "pair_implicit_subject_obj_w_up",
+        Parser_pair_implicit_subject_obj_w_up
+    },
+    {
+        "pair_implicit_subject_pred_w_self_up",
+        Parser_pair_implicit_subject_pred_w_self_up
+    },
+    {
+        "pair_implicit_subject_obj_w_self_up",
+        Parser_pair_implicit_subject_obj_w_self_up
+    },
+    {
+        "pair_implicit_subject_pred_w_invalid_flags",
+        Parser_pair_implicit_subject_pred_w_invalid_flags
+    },
+    {
+        "pair_implicit_subject_obj_w_invalid_flags",
+        Parser_pair_implicit_subject_obj_w_invalid_flags
+    },
+    {
+        "pair_explicit_subject",
+        Parser_pair_explicit_subject
+    },
+    {
+        "pair_explicit_subject_this",
+        Parser_pair_explicit_subject_this
+    },
+    {
+        "pair_explicit_subject_this_by_name",
+        Parser_pair_explicit_subject_this_by_name
+    },
+    {
+        "pair_explicit_subject_this_by_var_name",
+        Parser_pair_explicit_subject_this_by_var_name
+    },
+    {
+        "pair_explicit_subject_wildcard_pred",
+        Parser_pair_explicit_subject_wildcard_pred
+    },
+    {
+        "pair_explicit_subject_wildcard_subj",
+        Parser_pair_explicit_subject_wildcard_subj
+    },
+    {
+        "pair_explicit_subject_wildcard_obj",
+        Parser_pair_explicit_subject_wildcard_obj
+    },
+    {
+        "pair_implicit_subject_0_object",
+        Parser_pair_implicit_subject_0_object
+    },
+    {
+        "pair_explicit_subject_0_object",
+        Parser_pair_explicit_subject_0_object
+    },
+    {
+        "pair_explicit_subject_0",
+        Parser_pair_explicit_subject_0
+    },
+    {
+        "in_component_implicit_subject",
+        Parser_in_component_implicit_subject
+    },
+    {
+        "in_component_explicit_subject",
+        Parser_in_component_explicit_subject
+    },
+    {
+        "in_pair_implicit_subject",
+        Parser_in_pair_implicit_subject
+    },
+    {
+        "in_pair_explicit_subject",
+        Parser_in_pair_explicit_subject
+    },
+    {
+        "inout_component_implicit_subject",
+        Parser_inout_component_implicit_subject
+    },
+    {
+        "inout_component_explicit_subject",
+        Parser_inout_component_explicit_subject
+    },
+    {
+        "inout_pair_implicit_subject",
+        Parser_inout_pair_implicit_subject
+    },
+    {
+        "inout_pair_explicit_subject",
+        Parser_inout_pair_explicit_subject
+    },
+    {
+        "out_component_implicit_subject",
+        Parser_out_component_implicit_subject
+    },
+    {
+        "out_component_explicit_subject",
+        Parser_out_component_explicit_subject
+    },
+    {
+        "out_pair_implicit_subject",
+        Parser_out_pair_implicit_subject
+    },
+    {
+        "out_pair_explicit_subject",
+        Parser_out_pair_explicit_subject
+    },
+    {
+        "inout_filter_component",
+        Parser_inout_filter_component
+    },
+    {
+        "inout_w_not_operator",
+        Parser_inout_w_not_operator
+    },
+    {
+        "inout_w_optional_operator",
+        Parser_inout_w_optional_operator
+    },
+    {
+        "component_singleton",
+        Parser_component_singleton
+    },
+    {
+        "this_singleton",
+        Parser_this_singleton
+    },
+    {
+        "component_implicit_no_subject",
+        Parser_component_implicit_no_subject
+    },
+    {
+        "component_explicit_no_subject",
+        Parser_component_explicit_no_subject
+    },
+    {
+        "pair_no_subject",
+        Parser_pair_no_subject
+    },
+    {
+        "variable_single_char",
+        Parser_variable_single_char
+    },
+    {
+        "variable_multi_char",
+        Parser_variable_multi_char
+    },
+    {
+        "variable_multi_char_w_underscore",
+        Parser_variable_multi_char_w_underscore
+    },
+    {
+        "variable_multi_char_w_number",
+        Parser_variable_multi_char_w_number
+    },
+    {
+        "variable_multi_char_not_allcaps",
+        Parser_variable_multi_char_not_allcaps
+    },
+    {
+        "pred_var",
+        Parser_pred_var
+    },
+    {
+        "obj_var",
+        Parser_obj_var
+    },
+    {
+        "component_not",
+        Parser_component_not
+    },
+    {
+        "pair_implicit_subject_not",
+        Parser_pair_implicit_subject_not
+    },
+    {
+        "pair_explicit_subject_not",
+        Parser_pair_explicit_subject_not
+    },
+    {
+        "2_component_not",
+        Parser_2_component_not
+    },
+    {
+        "2_component_not_no_space",
+        Parser_2_component_not_no_space
+    },
+    {
+        "component_optional",
+        Parser_component_optional
+    },
+    {
+        "2_component_optional",
+        Parser_2_component_optional
+    },
+    {
+        "2_component_optional_no_space",
+        Parser_2_component_optional_no_space
+    },
+    {
+        "from_and",
+        Parser_from_and
+    },
+    {
+        "from_or",
+        Parser_from_or
+    },
+    {
+        "from_not",
+        Parser_from_not
+    },
+    {
+        "pair_implicit_subject_optional",
+        Parser_pair_implicit_subject_optional
+    },
+    {
+        "pair_explicit_subject_optional",
+        Parser_pair_explicit_subject_optional
+    },
+    {
+        "pred_implicit_subject_w_role",
+        Parser_pred_implicit_subject_w_role
+    },
+    {
+        "pred_explicit_subject_w_role",
+        Parser_pred_explicit_subject_w_role
+    },
+    {
+        "pred_no_subject_w_role",
+        Parser_pred_no_subject_w_role
+    },
+    {
+        "pair_implicit_subject_w_role",
+        Parser_pair_implicit_subject_w_role
+    },
+    {
+        "pair_explicit_subject_w_role",
+        Parser_pair_explicit_subject_w_role
+    },
+    {
+        "inout_role_pred_implicit_subject",
+        Parser_inout_role_pred_implicit_subject
+    },
+    {
+        "inout_role_pred_no_subject",
+        Parser_inout_role_pred_no_subject
+    },
+    {
+        "inout_role_pred_explicit_subject",
+        Parser_inout_role_pred_explicit_subject
+    },
+    {
+        "inout_role_pair_implicit_subject",
+        Parser_inout_role_pair_implicit_subject
+    },
+    {
+        "inout_role_pair_explicit_subject",
+        Parser_inout_role_pair_explicit_subject
+    },
+    {
+        "2_pred_implicit_subject",
+        Parser_2_pred_implicit_subject
+    },
+    {
+        "2_pred_no_subject",
+        Parser_2_pred_no_subject
+    },
+    {
+        "2_pred_explicit_subject",
+        Parser_2_pred_explicit_subject
+    },
+    {
+        "2_pair_implicit_subject",
+        Parser_2_pair_implicit_subject
+    },
+    {
+        "2_pair_explicit_subject",
+        Parser_2_pair_explicit_subject
+    },
+    {
+        "2_pred_role",
+        Parser_2_pred_role
+    },
+    {
+        "2_pair_implicit_subj_role",
+        Parser_2_pair_implicit_subj_role
+    },
+    {
+        "2_pair_explicit_subj_role",
+        Parser_2_pair_explicit_subj_role
+    },
+    {
+        "2_or_pred_implicit_subj",
+        Parser_2_or_pred_implicit_subj
+    },
+    {
+        "2_or_pred_explicit_subj",
+        Parser_2_or_pred_explicit_subj
+    },
+    {
+        "2_or_pair_implicit_subj",
+        Parser_2_or_pair_implicit_subj
+    },
+    {
+        "2_or_pair_explicit_subj",
+        Parser_2_or_pair_explicit_subj
+    },
+    {
+        "2_or_pred_inout",
+        Parser_2_or_pred_inout
+    },
+    {
+        "2_or_no_space",
+        Parser_2_or_no_space
+    },
+    {
+        "2_or_w_not_1st_arg",
+        Parser_2_or_w_not_1st_arg
+    },
+    {
+        "2_or_w_not_2nd_arg",
+        Parser_2_or_w_not_2nd_arg
+    },
+    {
+        "2_or_w_optional_1st_arg",
+        Parser_2_or_w_optional_1st_arg
+    },
+    {
+        "2_or_w_optional_2nd_arg",
+        Parser_2_or_w_optional_2nd_arg
+    },
+    {
+        "1_digit_pred_implicit_subj",
+        Parser_1_digit_pred_implicit_subj
+    },
+    {
+        "1_digit_pred_no_subj",
+        Parser_1_digit_pred_no_subj
+    },
+    {
+        "1_digit_pred_explicit_subj",
+        Parser_1_digit_pred_explicit_subj
+    },
+    {
+        "1_digit_pair_implicit_subj",
+        Parser_1_digit_pair_implicit_subj
+    },
+    {
+        "1_digit_pair_explicit_subj",
+        Parser_1_digit_pair_explicit_subj
+    },
+    {
+        "pred_implicit_subject_self",
+        Parser_pred_implicit_subject_self
+    },
+    {
+        "pred_implicit_subject_superset",
+        Parser_pred_implicit_subject_superset
+    },
+    {
+        "pred_implicit_subject_superset_inclusive",
+        Parser_pred_implicit_subject_superset_inclusive
+    },
+    {
+        "pred_implicit_subject_superset_cascade",
+        Parser_pred_implicit_subject_superset_cascade
+    },
+    {
+        "pred_implicit_subject_superset_inclusive_cascade",
+        Parser_pred_implicit_subject_superset_inclusive_cascade
+    },
+    {
+        "pred_implicit_subject_implicit_superset_cascade",
+        Parser_pred_implicit_subject_implicit_superset_cascade
+    },
+    {
+        "pred_implicit_subject_implicit_superset_inclusive_cascade",
+        Parser_pred_implicit_subject_implicit_superset_inclusive_cascade
+    },
+    {
+        "pred_implicit_subject_implicit_superset_cascade_w_rel",
+        Parser_pred_implicit_subject_implicit_superset_cascade_w_rel
+    },
+    {
+        "pred_implicit_subject_implicit_superset_inclusive_cascade_w_rel",
+        Parser_pred_implicit_subject_implicit_superset_inclusive_cascade_w_rel
+    },
+    {
+        "pred_implicit_subject_superset_childof",
+        Parser_pred_implicit_subject_superset_childof
+    },
+    {
+        "pred_implicit_subject_cascade_superset_childof",
+        Parser_pred_implicit_subject_cascade_superset_childof
+    },
+    {
+        "pred_implicit_subject_superset_cascade_childof",
+        Parser_pred_implicit_subject_superset_cascade_childof
+    },
+    {
+        "pred_implicit_subject_superset_cascade_childof_optional",
+        Parser_pred_implicit_subject_superset_cascade_childof_optional
+    },
+    {
+        "expr_w_symbol",
+        Parser_expr_w_symbol
+    },
+    {
+        "expr_w_newline",
+        Parser_expr_w_newline
+    },
+    {
+        "subj_entity_w_explicit_self",
+        Parser_subj_entity_w_explicit_self
+    },
+    {
+        "subj_entity_w_explicit_self_superset",
+        Parser_subj_entity_w_explicit_self_superset
+    },
+    {
+        "subj_entity_w_explicit_superset_relation",
+        Parser_subj_entity_w_explicit_superset_relation
+    },
+    {
+        "subj_entity_w_explicit_self_superset_relation",
+        Parser_subj_entity_w_explicit_self_superset_relation
+    },
+    {
+        "obj_entity_w_explicit_self",
+        Parser_obj_entity_w_explicit_self
+    },
+    {
+        "obj_entity_w_explicit_self_superset",
+        Parser_obj_entity_w_explicit_self_superset
+    },
+    {
+        "obj_entity_w_explicit_superset_relation",
+        Parser_obj_entity_w_explicit_superset_relation
+    },
+    {
+        "obj_entity_w_explicit_self_superset_relation",
+        Parser_obj_entity_w_explicit_self_superset_relation
+    },
+    {
+        "pred_entity_w_explicit_self",
+        Parser_pred_entity_w_explicit_self
+    },
+    {
+        "pred_entity_w_explicit_self_superset",
+        Parser_pred_entity_w_explicit_self_superset
+    },
+    {
+        "pred_entity_no_args_w_explicit_self",
+        Parser_pred_entity_no_args_w_explicit_self
+    },
+    {
+        "pred_entity_no_args_w_explicit_self_superset",
+        Parser_pred_entity_no_args_w_explicit_self_superset
+    },
+    {
+        "pred_entity_no_args_2_terms_w_explicit_self",
+        Parser_pred_entity_no_args_2_terms_w_explicit_self
+    },
+    {
+        "pred_entity_no_args_2_terms_w_explicit_self_superset",
+        Parser_pred_entity_no_args_2_terms_w_explicit_self_superset
+    },
+    {
+        "newline",
+        Parser_newline
+    },
+    {
+        "2_newlines",
+        Parser_2_newlines
+    },
+    {
+        "3_newlines",
+        Parser_3_newlines
+    },
+    {
+        "space",
+        Parser_space
+    },
+    {
+        "2_spaces",
+        Parser_2_spaces
+    },
+    {
+        "trailing_newline",
+        Parser_trailing_newline
+    },
+    {
+        "2_trailing_newlines",
+        Parser_2_trailing_newlines
+    },
+    {
+        "trailing_space",
+        Parser_trailing_space
+    },
+    {
+        "2_trailing_spaces",
+        Parser_2_trailing_spaces
+    },
+    {
+        "template_type",
+        Parser_template_type
+    },
+    {
+        "template_type_nested",
+        Parser_template_type_nested
+    },
+    {
+        "template_type_multiple_args",
+        Parser_template_type_multiple_args
+    },
+    {
+        "template_type_multiple_args_nested",
+        Parser_template_type_multiple_args_nested
+    },
+    {
+        "template_type_unbalanced_open",
+        Parser_template_type_unbalanced_open
+    },
+    {
+        "template_type_unbalanced_close",
+        Parser_template_type_unbalanced_close
+    },
+    {
+        "predicate_w_parens",
+        Parser_predicate_w_parens
+    },
+    {
+        "not_alive_pred",
+        Parser_not_alive_pred
+    },
+    {
+        "not_alive_subj",
+        Parser_not_alive_subj
+    },
+    {
+        "not_alive_obj",
+        Parser_not_alive_obj
+    },
+    {
+        "this_subj_var_kind",
+        Parser_this_subj_var_kind
+    },
+    {
+        "this_obj_var_kind",
+        Parser_this_obj_var_kind
+    },
+    {
+        "this_subj_obj_var_kind",
+        Parser_this_subj_obj_var_kind
+    },
+    {
+        "var_w_name",
+        Parser_var_w_name
+    },
+    {
+        "entity_pred_no_name",
+        Parser_entity_pred_no_name
+    },
+    {
+        "entity_subj_no_name",
+        Parser_entity_subj_no_name
+    },
+    {
+        "entity_obj_no_name",
+        Parser_entity_obj_no_name
+    },
+    {
+        "this_pred_no_name",
+        Parser_this_pred_no_name
+    },
+    {
+        "this_subj_no_name",
+        Parser_this_subj_no_name
+    },
+    {
+        "this_obj_no_name",
+        Parser_this_obj_no_name
+    },
+    {
+        "invalid_variable_only",
+        Parser_invalid_variable_only
+    },
+    {
+        "oneof_self_pred_w_relative_obj",
+        Parser_oneof_self_pred_w_relative_obj
+    },
+    {
+        "oneof_other_pred_w_relative_obj",
+        Parser_oneof_other_pred_w_relative_obj
+    },
+    {
+        "oneof_self_pred_w_invalid_obj",
+        Parser_oneof_self_pred_w_invalid_obj
+    },
+    {
+        "oneof_other_pred_w_invalid_obj",
+        Parser_oneof_other_pred_w_invalid_obj
+    },
+    {
+        "oneof_w_other_entity_w_same_name",
+        Parser_oneof_w_other_entity_w_same_name
+    },
+    {
+        "oneof_w_other_entity_w_same_name_w_set_scope",
+        Parser_oneof_w_other_entity_w_same_name_w_set_scope
+    },
+    {
+        "oneof_w_wildcard",
+        Parser_oneof_w_wildcard
+    },
+    {
+        "oneof_w_any",
+        Parser_oneof_w_any
+    },
+    {
+        "oneof_w_fullpath",
+        Parser_oneof_w_fullpath
+    },
+    {
+        "pair_implicit_src_missing_rel",
+        Parser_pair_implicit_src_missing_rel
+    },
+    {
+        "pair_implicit_src_missing_obj",
+        Parser_pair_implicit_src_missing_obj
+    },
+    {
+        "pair_explicit_src_missing_src",
+        Parser_pair_explicit_src_missing_src
+    },
+    {
+        "pair_explicit_src_missing_obj",
+        Parser_pair_explicit_src_missing_obj
+    },
+    {
+        "eq_id",
+        Parser_eq_id
+    },
+    {
+        "eq_id_var",
+        Parser_eq_id_var
+    },
+    {
+        "eq_var_id",
+        Parser_eq_var_id
+    },
+    {
+        "eq_var_table",
+        Parser_eq_var_table
+    },
+    {
+        "eq_var",
+        Parser_eq_var
+    },
+    {
+        "neq_id",
+        Parser_neq_id
+    },
+    {
+        "neq_id_var",
+        Parser_neq_id_var
+    },
+    {
+        "neq_var_id",
+        Parser_neq_var_id
+    },
+    {
+        "neq_var_table",
+        Parser_neq_var_table
+    },
+    {
+        "neq_var",
+        Parser_neq_var
+    },
+    {
+        "eq_name",
+        Parser_eq_name
+    },
+    {
+        "eq_name_var",
+        Parser_eq_name_var
+    },
+    {
+        "eq_var_name",
+        Parser_eq_var_name
+    },
+    {
+        "neq_name",
+        Parser_neq_name
+    },
+    {
+        "neq_name_var",
+        Parser_neq_name_var
+    },
+    {
+        "neq_var_name",
+        Parser_neq_var_name
+    },
+    {
+        "match_name",
+        Parser_match_name
+    },
+    {
+        "match_name_var",
+        Parser_match_name_var
+    },
+    {
+        "match_var_name",
+        Parser_match_var_name
+    },
+    {
+        "match_var",
+        Parser_match_var
+    },
+    {
+        "nmatch_name",
+        Parser_nmatch_name
+    },
+    {
+        "nmatch_name_var",
+        Parser_nmatch_name_var
+    },
+    {
+        "nmatch_var_name",
+        Parser_nmatch_var_name
+    },
+    {
+        "eq_same_var",
+        Parser_eq_same_var
+    },
+    {
+        "neq_same_var",
+        Parser_neq_same_var
+    },
+    {
+        "eq_same_var_this",
+        Parser_eq_same_var_this
+    },
+    {
+        "neq_same_var_this",
+        Parser_neq_same_var_this
+    },
+    {
+        "eq_w_not",
+        Parser_eq_w_not
+    },
+    {
+        "neq_w_not",
+        Parser_neq_w_not
+    },
+    {
+        "match_w_not",
+        Parser_match_w_not
+    },
+    {
+        "eq_w_optional",
+        Parser_eq_w_optional
+    },
+    {
+        "neq_w_optional",
+        Parser_neq_w_optional
+    },
+    {
+        "match_w_optional",
+        Parser_match_w_optional
+    },
+    {
+        "eq_0",
+        Parser_eq_0
+    },
+    {
+        "neq_0",
+        Parser_neq_0
+    },
+    {
+        "eq_wildcard",
+        Parser_eq_wildcard
+    },
+    {
+        "neq_wildcard",
+        Parser_neq_wildcard
+    },
+    {
+        "eq_any",
+        Parser_eq_any
+    },
+    {
+        "neq_any",
+        Parser_neq_any
+    },
+    {
+        "query_scope_1_term",
+        Parser_query_scope_1_term
+    },
+    {
+        "query_scope_1_term_spaces",
+        Parser_query_scope_1_term_spaces
+    },
+    {
+        "query_scope_2_terms",
+        Parser_query_scope_2_terms
+    },
+    {
+        "query_nested_scope",
+        Parser_query_nested_scope
+    },
+    {
+        "query_nested_scope_spaces",
+        Parser_query_nested_scope_spaces
+    },
+    {
+        "query_scope_unbalanced",
+        Parser_query_scope_unbalanced
+    },
+    {
+        "query_not_scope",
+        Parser_query_not_scope
+    },
+    {
+        "query_empty_scope",
+        Parser_query_empty_scope
+    },
+    {
+        "query_scope_newline_after_open",
+        Parser_query_scope_newline_after_open
+    },
+    {
+        "query_scope_newline_after_close",
+        Parser_query_scope_newline_after_close
+    },
+    {
+        "query_term_after_scope",
+        Parser_query_term_after_scope
+    },
+    {
+        "override_tag",
+        Parser_override_tag
+    },
+    {
+        "override_pair",
+        Parser_override_pair
+    },
+    {
+        "pair_3_args",
+        Parser_pair_3_args
+    },
+    {
+        "pair_3_args_implicit_this",
+        Parser_pair_3_args_implicit_this
+    },
+    {
+        "pair_4_args",
+        Parser_pair_4_args
+    },
+    {
+        "pair_4_args_implicit_this",
+        Parser_pair_4_args_implicit_this
+    },
+    {
+        "pair_3_args_2_terms",
+        Parser_pair_3_args_2_terms
+    },
+    {
+        "pair_3_args_this_tgt",
+        Parser_pair_3_args_this_tgt
+    },
+    {
+        "pair_3_args_2_terms_this_tgt",
+        Parser_pair_3_args_2_terms_this_tgt
+    },
+    {
+        "pair_3_args_2_terms_this_tgt_implicit_this",
+        Parser_pair_3_args_2_terms_this_tgt_implicit_this
+    },
+    {
+        "pair_3_or_args",
+        Parser_pair_3_or_args
+    },
+    {
+        "pair_3_or_args_implicit_this",
+        Parser_pair_3_or_args_implicit_this
+    },
+    {
+        "pair_4_or_args",
+        Parser_pair_4_or_args
+    },
+    {
+        "pair_4_or_args_implicit_this",
+        Parser_pair_4_or_args_implicit_this
+    },
+    {
+        "pair_3_args_w_vars",
+        Parser_pair_3_args_w_vars
+    },
+    {
+        "pair_4_args_w_vars",
+        Parser_pair_4_args_w_vars
+    },
+    {
+        "pair_3_args_w_vars_w_term_after",
+        Parser_pair_3_args_w_vars_w_term_after
+    },
+    {
+        "pair_4_args_w_vars_w_term_after",
+        Parser_pair_4_args_w_vars_w_term_after
+    },
+    {
+        "pair_or_before_and_oper",
+        Parser_pair_or_before_and_oper
+    },
+    {
+        "pair_and_before_or_oper",
+        Parser_pair_and_before_or_oper
+    },
+    {
+        "cascade_desc",
+        Parser_cascade_desc
+    },
+    {
+        "newline_after_inout",
+        Parser_newline_after_inout
+    },
+    {
+        "newline_after_term_open",
+        Parser_newline_after_term_open
+    },
+    {
+        "newline_after_term_src",
+        Parser_newline_after_term_src
+    },
+    {
+        "newline_after_term_src_pair",
+        Parser_newline_after_term_src_pair
+    },
+    {
+        "newline_after_term_pair_comma",
+        Parser_newline_after_term_pair_comma
+    },
+    {
+        "newline_after_term_pair_second",
+        Parser_newline_after_term_pair_second
+    },
+    {
+        "tag_w_space_implicit_this",
+        Parser_tag_w_space_implicit_this
+    },
+    {
+        "tag_w_space",
+        Parser_tag_w_space
+    },
+    {
+        "pair_first_w_space_implicit_this",
+        Parser_pair_first_w_space_implicit_this
+    },
+    {
+        "pair_first_w_space",
+        Parser_pair_first_w_space
+    },
+    {
+        "pair_second_w_space_implicit_this",
+        Parser_pair_second_w_space_implicit_this
+    },
+    {
+        "pair_second_w_space",
+        Parser_pair_second_w_space
+    },
+    {
+        "pair_src_w_space",
+        Parser_pair_src_w_space
+    },
+    {
+        "empty_term",
+        Parser_empty_term
+    },
+    {
+        "empty_term_w_space",
+        Parser_empty_term_w_space
+    },
+    {
+        "empty_term_w_newline",
+        Parser_empty_term_w_newline
+    },
+    {
+        "mixed_1_desc_and_1_expr",
+        Parser_mixed_1_desc_and_1_expr
+    },
+    {
+        "mixed_2_desc_and_1_expr",
+        Parser_mixed_2_desc_and_1_expr
+    },
+    {
+        "mixed_1_desc_and_2_expr",
+        Parser_mixed_1_desc_and_2_expr
+    }
+};
+
+bake_test_case Basic_testcases[] = {
+    {
+        "0_query",
+        Basic_0_query
+    },
+    {
+        "1_fact_w_tag",
+        Basic_1_fact_w_tag
+    },
+    {
+        "1_fact_w_component",
+        Basic_1_fact_w_component
+    },
+    {
+        "1_fact_w_tag_pair",
+        Basic_1_fact_w_tag_pair
+    },
+    {
+        "1_fact_w_component_pair",
+        Basic_1_fact_w_component_pair
+    },
+    {
+        "2_facts_same_src_w_tag",
+        Basic_2_facts_same_src_w_tag
+    },
+    {
+        "2_facts_same_src_w_component",
+        Basic_2_facts_same_src_w_component
+    },
+    {
+        "2_facts_same_src_w_tag_pair",
+        Basic_2_facts_same_src_w_tag_pair
+    },
+    {
+        "2_facts_same_src_w_component_pair",
+        Basic_2_facts_same_src_w_component_pair
+    },
+    {
+        "2_facts_other_src_w_tag",
+        Basic_2_facts_other_src_w_tag
+    },
+    {
+        "2_facts_other_src_w_component",
+        Basic_2_facts_other_src_w_component
+    },
+    {
+        "2_facts_other_src_w_tag_pair",
+        Basic_2_facts_other_src_w_tag_pair
+    },
+    {
+        "2_facts_other_src_w_component_pair",
+        Basic_2_facts_other_src_w_component_pair
+    },
+    {
+        "1_fact_w_any",
+        Basic_1_fact_w_any
+    },
+    {
+        "1_fact_w_pair_any_tgt",
+        Basic_1_fact_w_pair_any_tgt
+    },
+    {
+        "1_fact_w_pair_any_rel",
+        Basic_1_fact_w_pair_any_rel
+    },
+    {
+        "1_fact_w_pair_any_rel_tgt",
+        Basic_1_fact_w_pair_any_rel_tgt
+    },
+    {
+        "2_facts_same_src_w_any",
+        Basic_2_facts_same_src_w_any
+    },
+    {
+        "2_facts_same_src_w_pair_any_tgt",
+        Basic_2_facts_same_src_w_pair_any_tgt
+    },
+    {
+        "2_facts_same_src_w_pair_any_rel",
+        Basic_2_facts_same_src_w_pair_any_rel
+    },
+    {
+        "2_facts_same_src_w_pair_any_rel_tgt",
+        Basic_2_facts_same_src_w_pair_any_rel_tgt
+    },
+    {
+        "2_facts_other_src_w_any",
+        Basic_2_facts_other_src_w_any
+    },
+    {
+        "2_facts_other_src_w_pair_any_tgt",
+        Basic_2_facts_other_src_w_pair_any_tgt
+    },
+    {
+        "2_facts_other_src_w_pair_any_rel",
+        Basic_2_facts_other_src_w_pair_any_rel
+    },
+    {
+        "2_facts_other_src_w_pair_any_rel_tgt",
+        Basic_2_facts_other_src_w_pair_any_rel_tgt
+    },
+    {
+        "1_this_src_w_tag",
+        Basic_1_this_src_w_tag
+    },
+    {
+        "1_this_src_w_component",
+        Basic_1_this_src_w_component
+    },
+    {
+        "1_this_src_w_tag_pair",
+        Basic_1_this_src_w_tag_pair
+    },
+    {
+        "1_this_src_w_component_pair",
+        Basic_1_this_src_w_component_pair
+    },
+    {
+        "1_this_src_w_tag_2_tables",
+        Basic_1_this_src_w_tag_2_tables
+    },
+    {
+        "1_this_src_w_component_2_tables",
+        Basic_1_this_src_w_component_2_tables
+    },
+    {
+        "1_this_src_w_tag_pair_2_tables",
+        Basic_1_this_src_w_tag_pair_2_tables
+    },
+    {
+        "1_this_src_w_component_pair_2_tables",
+        Basic_1_this_src_w_component_pair_2_tables
+    },
+    {
+        "2_this_src_w_tag",
+        Basic_2_this_src_w_tag
+    },
+    {
+        "2_this_src_w_component",
+        Basic_2_this_src_w_component
+    },
+    {
+        "2_this_src_ent_src_w_tag",
+        Basic_2_this_src_ent_src_w_tag
+    },
+    {
+        "2_this_src_ent_src_w_component",
+        Basic_2_this_src_ent_src_w_component
+    },
+    {
+        "2_ent_src_this_src_w_tag",
+        Basic_2_ent_src_this_src_w_tag
+    },
+    {
+        "2_ent_src_this_src_w_component",
+        Basic_2_ent_src_this_src_w_component
+    },
+    {
+        "recycled_tag",
+        Basic_recycled_tag
+    },
+    {
+        "recycled_src",
+        Basic_recycled_src
+    },
+    {
+        "recycled_pair_rel",
+        Basic_recycled_pair_rel
+    },
+    {
+        "recycled_pair_tgt",
+        Basic_recycled_pair_tgt
+    },
+    {
+        "this_src_w_wildcard",
+        Basic_this_src_w_wildcard
+    },
+    {
+        "this_src_w_pair_rel_wildcard",
+        Basic_this_src_w_pair_rel_wildcard
+    },
+    {
+        "this_src_w_pair_tgt_wildcard",
+        Basic_this_src_w_pair_tgt_wildcard
+    },
+    {
+        "this_src_w_pair_rel_tgt_wildcard",
+        Basic_this_src_w_pair_rel_tgt_wildcard
+    },
+    {
+        "this_src_w_any",
+        Basic_this_src_w_any
+    },
+    {
+        "this_src_w_any_written",
+        Basic_this_src_w_any_written
+    },
+    {
+        "this_src_w_pair_rel_any",
+        Basic_this_src_w_pair_rel_any
+    },
+    {
+        "this_src_w_pair_tgt_any",
+        Basic_this_src_w_pair_tgt_any
+    },
+    {
+        "this_src_w_pair_rel_tgt_any",
+        Basic_this_src_w_pair_rel_tgt_any
+    },
+    {
+        "ent_src_w_wildcard",
+        Basic_ent_src_w_wildcard
+    },
+    {
+        "ent_src_w_pair_rel_wildcard",
+        Basic_ent_src_w_pair_rel_wildcard
+    },
+    {
+        "ent_src_w_pair_tgt_wildcard",
+        Basic_ent_src_w_pair_tgt_wildcard
+    },
+    {
+        "ent_src_w_pair_rel_tgt_wildcard",
+        Basic_ent_src_w_pair_rel_tgt_wildcard
+    },
+    {
+        "1_wildcard_src",
+        Basic_1_wildcard_src
+    },
+    {
+        "1_wildcard_src_w_pair",
+        Basic_1_wildcard_src_w_pair
+    },
+    {
+        "2_wildcard_src",
+        Basic_2_wildcard_src
+    },
+    {
+        "2_wildcard_src_w_pair",
+        Basic_2_wildcard_src_w_pair
+    },
+    {
+        "1_wildcard_src_w_pair_tgt_var",
+        Basic_1_wildcard_src_w_pair_tgt_var
+    },
+    {
+        "1_wildcard_src_w_pair_rel_var",
+        Basic_1_wildcard_src_w_pair_rel_var
+    },
+    {
+        "1_wildcard_src_w_pair_tgt_this",
+        Basic_1_wildcard_src_w_pair_tgt_this
+    },
+    {
+        "1_wildcard_src_w_pair_rel_this",
+        Basic_1_wildcard_src_w_pair_rel_this
+    },
+    {
+        "1_any_src",
+        Basic_1_any_src
+    },
+    {
+        "1_any_src_w_pair",
+        Basic_1_any_src_w_pair
+    },
+    {
+        "2_any_src",
+        Basic_2_any_src
+    },
+    {
+        "2_any_src_w_pair",
+        Basic_2_any_src_w_pair
+    },
+    {
+        "1_any_src_w_pair_tgt_var",
+        Basic_1_any_src_w_pair_tgt_var
+    },
+    {
+        "1_any_src_w_pair_rel_var",
+        Basic_1_any_src_w_pair_rel_var
+    },
+    {
+        "1_any_src_w_pair_tgt_this",
+        Basic_1_any_src_w_pair_tgt_this
+    },
+    {
+        "1_any_src_w_pair_rel_this",
+        Basic_1_any_src_w_pair_rel_this
+    },
+    {
+        "not_any",
+        Basic_not_any
+    },
+    {
+        "rule_w_iter_next",
+        Basic_rule_w_iter_next
+    },
+    {
+        "empty_rule",
+        Basic_empty_rule
+    },
+    {
+        "invalid_rule",
+        Basic_invalid_rule
+    },
+    {
+        "not_instanced_table_src",
+        Basic_not_instanced_table_src
+    },
+    {
+        "not_instanced_entity_src",
+        Basic_not_instanced_entity_src
+    },
+    {
+        "not_instanced_mixed_src",
+        Basic_not_instanced_mixed_src
+    },
+    {
+        "not_instanced_inherited",
+        Basic_not_instanced_inherited
+    },
+    {
+        "instanced_table_src",
+        Basic_instanced_table_src
+    },
+    {
+        "instanced_entity_src",
+        Basic_instanced_entity_src
+    },
+    {
+        "instanced_mixed_src",
+        Basic_instanced_mixed_src
+    },
+    {
+        "instanced_inherited",
+        Basic_instanced_inherited
+    },
+    {
+        "in_term",
+        Basic_in_term
+    },
+    {
+        "out_term",
+        Basic_out_term
+    },
+    {
+        "inout_term",
+        Basic_inout_term
+    },
+    {
+        "nodata_term",
+        Basic_nodata_term
+    },
+    {
+        "find_this_lowercase",
+        Basic_find_this_lowercase
+    },
+    {
+        "find_this_uppercase",
+        Basic_find_this_uppercase
+    },
+    {
+        "find_this_tgt_lowercase",
+        Basic_find_this_tgt_lowercase
+    },
+    {
+        "find_this_tgt_uppercase",
+        Basic_find_this_tgt_uppercase
+    },
+    {
+        "get_filter",
+        Basic_get_filter
+    },
+    {
+        "iter_empty_source",
+        Basic_iter_empty_source
+    },
+    {
+        "iter_empty_source_2_terms",
+        Basic_iter_empty_source_2_terms
+    },
+    {
+        "iter_empty_source_wildcard",
+        Basic_iter_empty_source_wildcard
+    },
+    {
+        "iter_empty_source_pair",
+        Basic_iter_empty_source_pair
+    },
+    {
+        "iter_empty_source_pair_wildcard",
+        Basic_iter_empty_source_pair_wildcard
+    },
+    {
+        "iter_empty_source_2_terms_pair",
+        Basic_iter_empty_source_2_terms_pair
+    },
+    {
+        "iter_empty_source_2_terms_mixed",
+        Basic_iter_empty_source_2_terms_mixed
+    },
+    {
+        "iter_empty_source_2_terms_mixed_pair",
+        Basic_iter_empty_source_2_terms_mixed_pair
+    },
+    {
+        "iter_empty_source_2_terms_mixed_pair_wildcard",
+        Basic_iter_empty_source_2_terms_mixed_pair_wildcard
+    },
+    {
+        "this_var_w_empty_entity",
+        Basic_this_var_w_empty_entity
+    },
+    {
+        "match_disabled",
+        Basic_match_disabled
+    },
+    {
+        "match_prefab",
+        Basic_match_prefab
+    },
+    {
+        "match_disabled_prefab",
+        Basic_match_disabled_prefab
+    },
+    {
+        "match_disabled_this_tgt",
+        Basic_match_disabled_this_tgt
+    },
+    {
+        "match_prefab_this_tgt",
+        Basic_match_prefab_this_tgt
+    },
+    {
+        "match_disabled_prefab_this_tgt",
+        Basic_match_disabled_prefab_this_tgt
+    },
+    {
+        "match_self_disabled",
+        Basic_match_self_disabled
+    },
+    {
+        "match_self_prefab",
+        Basic_match_self_prefab
+    },
+    {
+        "match_self_disabled_prefab",
+        Basic_match_self_disabled_prefab
+    },
+    {
+        "match_optional_disabled",
+        Basic_match_optional_disabled
+    },
+    {
+        "match_optional_prefab",
+        Basic_match_optional_prefab
+    },
+    {
+        "match_optional_disabled_prefab",
+        Basic_match_optional_disabled_prefab
+    },
+    {
+        "match_optional_disabled_this_tgt",
+        Basic_match_optional_disabled_this_tgt
+    },
+    {
+        "match_optional_prefab_this_tgt",
+        Basic_match_optional_prefab_this_tgt
+    },
+    {
+        "match_optional_disabled_prefab_this_tgt",
+        Basic_match_optional_disabled_prefab_this_tgt
+    },
+    {
+        "match_optional_self_disabled",
+        Basic_match_optional_self_disabled
+    },
+    {
+        "match_optional_self_prefab",
+        Basic_match_optional_self_prefab
+    },
+    {
+        "match_optional_self_disabled_prefab",
+        Basic_match_optional_self_disabled_prefab
+    },
+    {
+        "inout_none_first_term",
+        Basic_inout_none_first_term
+    },
+    {
+        "inout_none_second_term",
+        Basic_inout_none_second_term
+    },
+    {
+        "inout_none_singleton",
+        Basic_inout_none_singleton
+    },
+    {
+        "inout_none_singleton_w_or",
+        Basic_inout_none_singleton_w_or
+    },
+    {
+        "inout_none_component_w_or",
+        Basic_inout_none_component_w_or
+    },
+    {
+        "no_data_rule",
+        Basic_no_data_rule
+    },
+    {
+        "frame_offset",
+        Basic_frame_offset
+    },
+    {
+        "frame_offset_no_data",
+        Basic_frame_offset_no_data
+    },
+    {
+        "match_empty_tables",
+        Basic_match_empty_tables
+    },
+    {
+        "match_empty_tables_no_data",
+        Basic_match_empty_tables_no_data
+    },
+    {
+        "match_empty_tables_w_not",
+        Basic_match_empty_tables_w_not
+    },
+    {
+        "match_empty_tables_w_wildcard",
+        Basic_match_empty_tables_w_wildcard
+    },
+    {
+        "match_empty_tables_w_no_empty_tables",
+        Basic_match_empty_tables_w_no_empty_tables
+    },
+    {
+        "match_empty_tables_trivial",
+        Basic_match_empty_tables_trivial
+    },
+    {
+        "oneof_wildcard",
+        Basic_oneof_wildcard
+    },
+    {
+        "oneof_any",
+        Basic_oneof_any
+    },
+    {
+        "instanced_w_singleton",
+        Basic_instanced_w_singleton
+    },
+    {
+        "instanced_w_base",
+        Basic_instanced_w_base
+    },
+    {
+        "not_instanced_w_singleton",
+        Basic_not_instanced_w_singleton
+    },
+    {
+        "not_instanced_w_base",
+        Basic_not_instanced_w_base
+    },
+    {
+        "unknown_before_known",
+        Basic_unknown_before_known
+    },
+    {
+        "unknown_before_known_after_or",
+        Basic_unknown_before_known_after_or
+    },
+    {
+        "unknown_before_known_after_not",
+        Basic_unknown_before_known_after_not
+    },
+    {
+        "unknown_before_known_after_optional",
+        Basic_unknown_before_known_after_optional
+    },
+    {
+        "unknown_before_known_after_scope",
+        Basic_unknown_before_known_after_scope
+    },
+    {
+        "2_trivial_mixed_2_tables",
+        Basic_2_trivial_mixed_2_tables
+    },
+    {
+        "2_trivial_mixed_2_tables_component",
+        Basic_2_trivial_mixed_2_tables_component
+    },
+    {
+        "2_trivial_mixed_2_tables_wildcard",
+        Basic_2_trivial_mixed_2_tables_wildcard
+    },
+    {
+        "2_trivial_1_unused_id",
+        Basic_2_trivial_1_unused_id
+    },
+    {
+        "2_trivial_one_regular",
+        Basic_2_trivial_one_regular
+    },
+    {
+        "1_trivial_one_regular_one_trivial",
+        Basic_1_trivial_one_regular_one_trivial
+    },
+    {
+        "one_regular_2_trivial",
+        Basic_one_regular_2_trivial
+    },
+    {
+        "2_trivial_w_prefab",
+        Basic_2_trivial_w_prefab
+    },
+    {
+        "3_trivial_w_prefab",
+        Basic_3_trivial_w_prefab
+    },
+    {
+        "2_trivial_w_disabled",
+        Basic_2_trivial_w_disabled
+    },
+    {
+        "3_trivial_w_disabled",
+        Basic_3_trivial_w_disabled
+    },
+    {
+        "2_this_w_fixed_src",
+        Basic_2_this_w_fixed_src
+    },
+    {
+        "2_fixed_src_w_this",
+        Basic_2_fixed_src_w_this
+    },
+    {
+        "2_this_w_fixed_src_no_match_fixed",
+        Basic_2_this_w_fixed_src_no_match_fixed
+    },
+    {
+        "2_fixed_src_w_this_no_match_fixed",
+        Basic_2_fixed_src_w_this_no_match_fixed
+    },
+    {
+        "2_this_w_fixed_src_no_match_this",
+        Basic_2_this_w_fixed_src_no_match_this
+    },
+    {
+        "2_fixed_src_w_this_no_match_this",
+        Basic_2_fixed_src_w_this_no_match_this
+    },
+    {
+        "query_count_results",
+        Basic_query_count_results
+    },
+    {
+        "query_count_entities",
+        Basic_query_count_entities
+    },
+    {
+        "query_is_true",
+        Basic_query_is_true
+    },
+    {
+        "implicit_cleanup_1_term",
+        Basic_implicit_cleanup_1_term
+    },
+    {
+        "implicit_cleanup_2_terms",
+        Basic_implicit_cleanup_2_terms
+    },
+    {
+        "implicit_cleanup_1_term_w_up",
+        Basic_implicit_cleanup_1_term_w_up
+    },
+    {
+        "implicit_cleanup_2_terms_w_up",
+        Basic_implicit_cleanup_2_terms_w_up
+    },
+    {
+        "implicit_cleanup_2_queries",
+        Basic_implicit_cleanup_2_queries
+    },
+    {
+        "implicit_cleanup_2_queries_1_cleanup",
+        Basic_implicit_cleanup_2_queries_1_cleanup
+    },
+    {
+        "iter_valid",
+        Basic_iter_valid
+    },
+    {
+        "iter_frame_offset",
+        Basic_iter_frame_offset
+    },
+    {
+        "iter_nested_1",
+        Basic_iter_nested_1
+    },
+    {
+        "iter_nested_2",
+        Basic_iter_nested_2
+    },
+    {
+        "iter_interleaved",
+        Basic_iter_interleaved
+    },
+    {
+        "set_get_context",
+        Basic_set_get_context
+    },
+    {
+        "set_get_binding_context",
+        Basic_set_get_binding_context
+    },
+    {
+        "set_get_context_w_free",
+        Basic_set_get_context_w_free
+    },
+    {
+        "set_get_binding_context_w_free",
+        Basic_set_get_binding_context_w_free
+    },
+    {
+        "create_query_w_existing_entity",
+        Basic_create_query_w_existing_entity
+    },
+    {
+        "create_query_w_existing_entity_different_term_count",
+        Basic_create_query_w_existing_entity_different_term_count
+    },
+    {
+        "create_multi_component_query_w_existing_entity",
+        Basic_create_multi_component_query_w_existing_entity
+    },
+    {
+        "delete_query_by_entity",
+        Basic_delete_query_by_entity
+    },
+    {
+        "eval_count",
+        Basic_eval_count
+    },
+    {
+        "no_results_after_delete_tree",
+        Basic_no_results_after_delete_tree
+    },
+    {
+        "no_results_after_delete_tree_deferred",
+        Basic_no_results_after_delete_tree_deferred
+    },
+    {
+        "add_on_self_ref",
+        Basic_add_on_self_ref
+    },
+    {
+        "add_on_self_ref_by_name",
+        Basic_add_on_self_ref_by_name
+    },
+    {
+        "delete_id_after_delete_query",
+        Basic_delete_id_after_delete_query
+    },
+    {
+        "pair_sweep_tag",
+        Basic_pair_sweep_tag
+    },
+    {
+        "pair_sweep_wildcard_first",
+        Basic_pair_sweep_wildcard_first
+    },
+    {
+        "pair_sweep_wildcard_second",
+        Basic_pair_sweep_wildcard_second
+    }
+};
+
+bake_test_case Plan_testcases[] = {
+    {
+        "reordered_plan_1",
+        Plan_reordered_plan_1
+    },
+    {
+        "reordered_plan_2",
+        Plan_reordered_plan_2
+    },
+    {
+        "1_trivial_plan",
+        Plan_1_trivial_plan
+    },
+    {
+        "2_trivial_plan",
+        Plan_2_trivial_plan
+    },
+    {
+        "1_trivial_plan_component",
+        Plan_1_trivial_plan_component
+    },
+    {
+        "2_trivial_plan_component",
+        Plan_2_trivial_plan_component
+    },
+    {
+        "3_trivial_plan_w_pair",
+        Plan_3_trivial_plan_w_pair
+    },
+    {
+        "3_trivial_plan_w_wildcard",
+        Plan_3_trivial_plan_w_wildcard
+    },
+    {
+        "3_trivial_plan_w_any",
+        Plan_3_trivial_plan_w_any
+    },
+    {
+        "3_trivial_plan_w_pair_component",
+        Plan_3_trivial_plan_w_pair_component
+    },
+    {
+        "3_trivial_plan_w_wildcard_component",
+        Plan_3_trivial_plan_w_wildcard_component
+    },
+    {
+        "3_trivial_plan_w_any_component",
+        Plan_3_trivial_plan_w_any_component
+    },
+    {
+        "1_trivial_component_w_none",
+        Plan_1_trivial_component_w_none
+    },
+    {
+        "2_trivial_component_w_none",
+        Plan_2_trivial_component_w_none
+    },
+    {
+        "2_trivial_plan_w_wildcard",
+        Plan_2_trivial_plan_w_wildcard
+    },
+    {
+        "this_before_fixed_src",
+        Plan_this_before_fixed_src
+    },
+    {
+        "fixed_src_before_this",
+        Plan_fixed_src_before_this
+    },
+    {
+        "var_before_fixed_src",
+        Plan_var_before_fixed_src
+    },
+    {
+        "fixed_src_before_var",
+        Plan_fixed_src_before_var
+    },
+    {
+        "this_before_fixed_src_w_not",
+        Plan_this_before_fixed_src_w_not
+    },
+    {
+        "this_before_fixed_src_w_first_var",
+        Plan_this_before_fixed_src_w_first_var
+    },
+    {
+        "this_before_fixed_src_w_first_var_w_not",
+        Plan_this_before_fixed_src_w_first_var_w_not
+    },
+    {
+        "this_before_fixed_src_w_second_var",
+        Plan_this_before_fixed_src_w_second_var
+    },
+    {
+        "this_before_fixed_src_w_second_var_w_not",
+        Plan_this_before_fixed_src_w_second_var_w_not
+    },
+    {
+        "populate_1_fixed",
+        Plan_populate_1_fixed
+    },
+    {
+        "populate_2_fixed",
+        Plan_populate_2_fixed
+    },
+    {
+        "populate_1_fixed_1_this_self",
+        Plan_populate_1_fixed_1_this_self
+    },
+    {
+        "populate_2_fixed_2_this_self",
+        Plan_populate_2_fixed_2_this_self
+    },
+    {
+        "populate_2_fixed_2_this_self_interleaved",
+        Plan_populate_2_fixed_2_this_self_interleaved
+    },
+    {
+        "populate_2_this_self_2_fixed",
+        Plan_populate_2_this_self_2_fixed
+    },
+    {
+        "populate_1_fixed_1_this_up",
+        Plan_populate_1_fixed_1_this_up
+    },
+    {
+        "populate_2_fixed_2_this_up",
+        Plan_populate_2_fixed_2_this_up
+    },
+    {
+        "populate_2_fixed_2_this_up_interleaved",
+        Plan_populate_2_fixed_2_this_up_interleaved
+    },
+    {
+        "populate_2_this_up_2_fixed",
+        Plan_populate_2_this_up_2_fixed
+    },
+    {
+        "populate_1_fixed_1_this_self_cached",
+        Plan_populate_1_fixed_1_this_self_cached
+    },
+    {
+        "populate_2_fixed_2_this_self_cached",
+        Plan_populate_2_fixed_2_this_self_cached
+    },
+    {
+        "populate_2_fixed_2_this_self_interleaved_cached",
+        Plan_populate_2_fixed_2_this_self_interleaved_cached
+    },
+    {
+        "populate_2_this_self_2_fixed_cached",
+        Plan_populate_2_this_self_2_fixed_cached
+    },
+    {
+        "populate_1_fixed_1_this_up_cached",
+        Plan_populate_1_fixed_1_this_up_cached
+    },
+    {
+        "populate_2_fixed_2_this_up_cached",
+        Plan_populate_2_fixed_2_this_up_cached
+    },
+    {
+        "populate_2_fixed_2_this_up_interleaved_cached",
+        Plan_populate_2_fixed_2_this_up_interleaved_cached
+    },
+    {
+        "populate_2_this_up_2_fixed_cached",
+        Plan_populate_2_this_up_2_fixed_cached
+    },
+    {
+        "populate_1_fixed_1_var_self",
+        Plan_populate_1_fixed_1_var_self
+    },
+    {
+        "populate_2_fixed_2_var_self",
+        Plan_populate_2_fixed_2_var_self
+    },
+    {
+        "populate_2_fixed_2_var_self_interleaved",
+        Plan_populate_2_fixed_2_var_self_interleaved
+    },
+    {
+        "populate_2_var_self_2_fixed",
+        Plan_populate_2_var_self_2_fixed
+    },
+    {
+        "populate_1_fixed_1_var_up",
+        Plan_populate_1_fixed_1_var_up
+    },
+    {
+        "populate_2_fixed_2_var_up",
+        Plan_populate_2_fixed_2_var_up
+    },
+    {
+        "populate_2_fixed_2_var_up_interleaved",
+        Plan_populate_2_fixed_2_var_up_interleaved
+    },
+    {
+        "populate_2_var_up_2_fixed",
+        Plan_populate_2_var_up_2_fixed
+    },
+    {
+        "cache_2_or",
+        Plan_cache_2_or
+    },
+    {
+        "cache_2_or_w_not",
+        Plan_cache_2_or_w_not
+    },
+    {
+        "1_plan_any_src",
+        Plan_1_plan_any_src
+    },
+    {
+        "1_plan_not_any_src",
+        Plan_1_plan_not_any_src
+    },
+    {
+        "1_plan_optional_any_src",
+        Plan_1_plan_optional_any_src
+    },
+    {
+        "pair_first_wildcard",
+        Plan_pair_first_wildcard
+    },
+    {
+        "pair_first_wildcard_cached",
+        Plan_pair_first_wildcard_cached
+    },
+    {
+        "pair_second_wildcard",
+        Plan_pair_second_wildcard
+    },
+    {
+        "pair_second_wildcard_cached",
+        Plan_pair_second_wildcard_cached
+    }
+};
+
+bake_test_case Variables_testcases[] = {
+    {
+        "1_ent_src_w_var",
+        Variables_1_ent_src_w_var
+    },
+    {
+        "1_ent_src_w_pair_rel_var",
+        Variables_1_ent_src_w_pair_rel_var
+    },
+    {
+        "1_ent_src_w_pair_tgt_var",
+        Variables_1_ent_src_w_pair_tgt_var
+    },
+    {
+        "1_ent_src_w_pair_rel_tgt_var",
+        Variables_1_ent_src_w_pair_rel_tgt_var
+    },
+    {
+        "1_ent_src_w_pair_rel_tgt_same_var",
+        Variables_1_ent_src_w_pair_rel_tgt_same_var
+    },
+    {
+        "1_ent_src_w_pair_rel_tgt_same_var_after_write",
+        Variables_1_ent_src_w_pair_rel_tgt_same_var_after_write
+    },
+    {
+        "1_this_src_w_var",
+        Variables_1_this_src_w_var
+    },
+    {
+        "1_this_src_w_pair_rel_var",
+        Variables_1_this_src_w_pair_rel_var
+    },
+    {
+        "1_this_src_w_pair_tgt_var",
+        Variables_1_this_src_w_pair_tgt_var
+    },
+    {
+        "1_this_src_w_pair_rel_tgt_var",
+        Variables_1_this_src_w_pair_rel_tgt_var
+    },
+    {
+        "1_this_src_w_pair_rel_tgt_same_var",
+        Variables_1_this_src_w_pair_rel_tgt_same_var
+    },
+    {
+        "1_this_src_w_pair_rel_tgt_same_var_after_write",
+        Variables_1_this_src_w_pair_rel_tgt_same_var_after_write
+    },
+    {
+        "1_src_id_same_var",
+        Variables_1_src_id_same_var
+    },
+    {
+        "1_src_pair_first_same_var",
+        Variables_1_src_pair_first_same_var
+    },
+    {
+        "1_src_pair_second_same_var",
+        Variables_1_src_pair_second_same_var
+    },
+    {
+        "1_src_pair_first_and_second_same_var",
+        Variables_1_src_pair_first_and_second_same_var
+    },
+    {
+        "1_src_id_same_var_after_write",
+        Variables_1_src_id_same_var_after_write
+    },
+    {
+        "1_src_pair_first_same_var_after_write",
+        Variables_1_src_pair_first_same_var_after_write
+    },
+    {
+        "1_src_pair_second_same_var_after_write",
+        Variables_1_src_pair_second_same_var_after_write
+    },
+    {
+        "1_src_pair_first_and_second_same_var_after_write",
+        Variables_1_src_pair_first_and_second_same_var_after_write
+    },
+    {
+        "1_src_pair_first_same_var_this",
+        Variables_1_src_pair_first_same_var_this
+    },
+    {
+        "1_src_pair_second_same_var_this",
+        Variables_1_src_pair_second_same_var_this
+    },
+    {
+        "1_src_pair_first_and_second_same_var_this",
+        Variables_1_src_pair_first_and_second_same_var_this
+    },
+    {
+        "1_src_id_same_var_this_after_write",
+        Variables_1_src_id_same_var_this_after_write
+    },
+    {
+        "1_src_pair_first_same_var_this_after_write",
+        Variables_1_src_pair_first_same_var_this_after_write
+    },
+    {
+        "1_src_pair_second_same_var_this_after_write",
+        Variables_1_src_pair_second_same_var_this_after_write
+    },
+    {
+        "1_src_pair_first_and_second_same_var_this_after_write",
+        Variables_1_src_pair_first_and_second_same_var_this_after_write
+    },
+    {
+        "1_ent_src_w_this_var",
+        Variables_1_ent_src_w_this_var
+    },
+    {
+        "1_ent_src_w_pair_this_rel",
+        Variables_1_ent_src_w_pair_this_rel
+    },
+    {
+        "1_ent_src_w_pair_this_tgt",
+        Variables_1_ent_src_w_pair_this_tgt
+    },
+    {
+        "1_ent_src_w_pair_this_rel_tgt",
+        Variables_1_ent_src_w_pair_this_rel_tgt
+    },
+    {
+        "1_this_src_w_this",
+        Variables_1_this_src_w_this
+    },
+    {
+        "1_this_src_w_pair_this_rel_tgt",
+        Variables_1_this_src_w_pair_this_rel_tgt
+    },
+    {
+        "1_this_src_w_this_after_write",
+        Variables_1_this_src_w_this_after_write
+    },
+    {
+        "1_this_src_w_pair_this_rel_tgt_after_write",
+        Variables_1_this_src_w_pair_this_rel_tgt_after_write
+    },
+    {
+        "2_constrain_src_from_src",
+        Variables_2_constrain_src_from_src
+    },
+    {
+        "2_constrain_rel_from_src_w_ent",
+        Variables_2_constrain_rel_from_src_w_ent
+    },
+    {
+        "2_constrain_rel_from_src_w_var",
+        Variables_2_constrain_rel_from_src_w_var
+    },
+    {
+        "2_constrain_rel_from_src_w_this",
+        Variables_2_constrain_rel_from_src_w_this
+    },
+    {
+        "2_constrain_pair_rel_from_src_w_ent",
+        Variables_2_constrain_pair_rel_from_src_w_ent
+    },
+    {
+        "2_constrain_pair_rel_from_src_w_var",
+        Variables_2_constrain_pair_rel_from_src_w_var
+    },
+    {
+        "2_constrain_pair_rel_from_src_w_this",
+        Variables_2_constrain_pair_rel_from_src_w_this
+    },
+    {
+        "2_constrain_pair_tgt_from_src_w_ent",
+        Variables_2_constrain_pair_tgt_from_src_w_ent
+    },
+    {
+        "2_constrain_pair_tgt_from_src_w_var",
+        Variables_2_constrain_pair_tgt_from_src_w_var
+    },
+    {
+        "2_constrain_pair_tgt_from_src_w_this",
+        Variables_2_constrain_pair_tgt_from_src_w_this
+    },
+    {
+        "2_constrain_pair_rel_tgt_from_src_w_ent",
+        Variables_2_constrain_pair_rel_tgt_from_src_w_ent
+    },
+    {
+        "2_constrain_pair_rel_tgt_from_src_w_var",
+        Variables_2_constrain_pair_rel_tgt_from_src_w_var
+    },
+    {
+        "2_constrain_pair_rel_tgt_from_src_w_this",
+        Variables_2_constrain_pair_rel_tgt_from_src_w_this
+    },
+    {
+        "1_ent_src_set_rel_var",
+        Variables_1_ent_src_set_rel_var
+    },
+    {
+        "1_ent_src_set_pair_rel_var",
+        Variables_1_ent_src_set_pair_rel_var
+    },
+    {
+        "1_ent_src_set_pair_tgt_var",
+        Variables_1_ent_src_set_pair_tgt_var
+    },
+    {
+        "1_set_src_var",
+        Variables_1_set_src_var
+    },
+    {
+        "1_set_src_var_w_pair",
+        Variables_1_set_src_var_w_pair
+    },
+    {
+        "1_set_src_var_w_pair_set_rel",
+        Variables_1_set_src_var_w_pair_set_rel
+    },
+    {
+        "1_set_src_var_w_pair_set_tgt",
+        Variables_1_set_src_var_w_pair_set_tgt
+    },
+    {
+        "1_set_src_var_w_pair_set_rel_tgt",
+        Variables_1_set_src_var_w_pair_set_rel_tgt
+    },
+    {
+        "1_set_src_this",
+        Variables_1_set_src_this
+    },
+    {
+        "1_set_src_this_w_pair",
+        Variables_1_set_src_this_w_pair
+    },
+    {
+        "1_set_src_this_w_pair_set_rel",
+        Variables_1_set_src_this_w_pair_set_rel
+    },
+    {
+        "1_set_src_this_w_pair_set_tgt",
+        Variables_1_set_src_this_w_pair_set_tgt
+    },
+    {
+        "1_set_src_this_w_pair_set_rel_tgt",
+        Variables_1_set_src_this_w_pair_set_rel_tgt
+    },
+    {
+        "1_set_src_this_to_empty_table",
+        Variables_1_set_src_this_to_empty_table
+    },
+    {
+        "1_set_src_this_to_empty_table_w_component",
+        Variables_1_set_src_this_to_empty_table_w_component
+    },
+    {
+        "1_set_src_this_to_empty_table_w_component_self",
+        Variables_1_set_src_this_to_empty_table_w_component_self
+    },
+    {
+        "1_set_src_this_to_entiy_in_table",
+        Variables_1_set_src_this_to_entiy_in_table
+    },
+    {
+        "1_set_src_this_to_entiy_in_table_self",
+        Variables_1_set_src_this_to_entiy_in_table_self
+    },
+    {
+        "2_set_src_this",
+        Variables_2_set_src_this
+    },
+    {
+        "2_set_src_this_self",
+        Variables_2_set_src_this_self
+    },
+    {
+        "2_set_src_this_component",
+        Variables_2_set_src_this_component
+    },
+    {
+        "2_set_src_this_self_component",
+        Variables_2_set_src_this_self_component
+    },
+    {
+        "2_set_src_this_w_up",
+        Variables_2_set_src_this_w_up
+    },
+    {
+        "2_set_src_this_self_w_up",
+        Variables_2_set_src_this_self_w_up
+    },
+    {
+        "2_set_src_this_component_w_up",
+        Variables_2_set_src_this_component_w_up
+    },
+    {
+        "2_set_src_this_self_component_w_up",
+        Variables_2_set_src_this_self_component_w_up
+    },
+    {
+        "2_set_src_this_w_exclusive_wildcard",
+        Variables_2_set_src_this_w_exclusive_wildcard
+    },
+    {
+        "2_set_src_this_self_w_exclusive_wildcard",
+        Variables_2_set_src_this_self_w_exclusive_wildcard
+    },
+    {
+        "2_set_src_this_self_w_exclusive_wildcard_w_up",
+        Variables_2_set_src_this_self_w_exclusive_wildcard_w_up
+    },
+    {
+        "1_set_src_this_is_true",
+        Variables_1_set_src_this_is_true
+    },
+    {
+        "3_set_src_this_w_uncacheable_tag_tag_tag",
+        Variables_3_set_src_this_w_uncacheable_tag_tag_tag
+    },
+    {
+        "3_set_src_this_w_uncacheable_tag_component_tag",
+        Variables_3_set_src_this_w_uncacheable_tag_component_tag
+    },
+    {
+        "3_set_src_this_w_uncacheable_tag_component_component",
+        Variables_3_set_src_this_w_uncacheable_tag_component_component
+    },
+    {
+        "3_set_src_this_w_tag_uncacheable_tag_tag",
+        Variables_3_set_src_this_w_tag_uncacheable_tag_tag
+    },
+    {
+        "3_set_src_this_w_component_uncacheable_tag_tag",
+        Variables_3_set_src_this_w_component_uncacheable_tag_tag
+    },
+    {
+        "3_set_src_this_w_component_uncacheable_tag_component",
+        Variables_3_set_src_this_w_component_uncacheable_tag_component
+    },
+    {
+        "3_set_src_this_w_tag_tag_uncacheable_tag",
+        Variables_3_set_src_this_w_tag_tag_uncacheable_tag
+    },
+    {
+        "3_set_src_this_w_component_tag_uncacheable_tag",
+        Variables_3_set_src_this_w_component_tag_uncacheable_tag
+    },
+    {
+        "3_set_src_this_w_component_component_uncacheable_tag",
+        Variables_3_set_src_this_w_component_component_uncacheable_tag
+    },
+    {
+        "3_set_src_this_w_uncacheable_component_tag_tag",
+        Variables_3_set_src_this_w_uncacheable_component_tag_tag
+    },
+    {
+        "3_set_src_this_w_uncacheable_component_component_tag",
+        Variables_3_set_src_this_w_uncacheable_component_component_tag
+    },
+    {
+        "3_set_src_this_w_uncacheable_component_component_component",
+        Variables_3_set_src_this_w_uncacheable_component_component_component
+    },
+    {
+        "3_set_src_this_w_tag_uncacheable_component_tag",
+        Variables_3_set_src_this_w_tag_uncacheable_component_tag
+    },
+    {
+        "3_set_src_this_w_component_uncacheable_component_tag",
+        Variables_3_set_src_this_w_component_uncacheable_component_tag
+    },
+    {
+        "3_set_src_this_w_component_uncacheable_component_component",
+        Variables_3_set_src_this_w_component_uncacheable_component_component
+    },
+    {
+        "3_set_src_this_w_tag_tag_uncacheable_component",
+        Variables_3_set_src_this_w_tag_tag_uncacheable_component
+    },
+    {
+        "3_set_src_this_w_component_tag_uncacheable_component",
+        Variables_3_set_src_this_w_component_tag_uncacheable_component
+    },
+    {
+        "3_set_src_this_w_component_component_uncacheable_component",
+        Variables_3_set_src_this_w_component_component_uncacheable_component
+    },
+    {
+        "2_set_src_this_w_wildcard",
+        Variables_2_set_src_this_w_wildcard
+    },
+    {
+        "1_src_this_var_as_entity",
+        Variables_1_src_this_var_as_entity
+    },
+    {
+        "1_src_this_var_as_table",
+        Variables_1_src_this_var_as_table
+    },
+    {
+        "1_src_this_var_as_table_range",
+        Variables_1_src_this_var_as_table_range
+    },
+    {
+        "2_join_by_rel_var",
+        Variables_2_join_by_rel_var
+    },
+    {
+        "2_join_by_pair_rel_var",
+        Variables_2_join_by_pair_rel_var
+    },
+    {
+        "2_join_by_pair_tgt_var",
+        Variables_2_join_by_pair_tgt_var
+    },
+    {
+        "2_cycle_w_var",
+        Variables_2_cycle_w_var
+    },
+    {
+        "2_cycle_w_this_var",
+        Variables_2_cycle_w_this_var
+    },
+    {
+        "2_cycle_w_var_this",
+        Variables_2_cycle_w_var_this
+    },
+    {
+        "2_cycle_pair_w_var",
+        Variables_2_cycle_pair_w_var
+    },
+    {
+        "2_cycle_pair_w_this_var_var",
+        Variables_2_cycle_pair_w_this_var_var
+    },
+    {
+        "2_cycle_pair_w_var_this_var",
+        Variables_2_cycle_pair_w_var_this_var
+    },
+    {
+        "2_cycle_pair_w_var_var_this",
+        Variables_2_cycle_pair_w_var_var_this
+    },
+    {
+        "2_cycle_pair_ent_var_var",
+        Variables_2_cycle_pair_ent_var_var
+    },
+    {
+        "2_cycle_pair_ent_this_var",
+        Variables_2_cycle_pair_ent_this_var
+    },
+    {
+        "2_cycle_pair_ent_var_this",
+        Variables_2_cycle_pair_ent_var_this
+    },
+    {
+        "parse_0_var",
+        Variables_parse_0_var
+    },
+    {
+        "parse_1_var",
+        Variables_parse_1_var
+    },
+    {
+        "parse_2_vars",
+        Variables_parse_2_vars
+    },
+    {
+        "parse_0_var_paren",
+        Variables_parse_0_var_paren
+    },
+    {
+        "parse_1_var_paren",
+        Variables_parse_1_var_paren
+    },
+    {
+        "parse_2_vars_paren",
+        Variables_parse_2_vars_paren
+    },
+    {
+        "parse_1_vars_w_path",
+        Variables_parse_1_vars_w_path
+    },
+    {
+        "parse_missing_close_paren",
+        Variables_parse_missing_close_paren
+    },
+    {
+        "parse_missing_open_paren",
+        Variables_parse_missing_open_paren
+    },
+    {
+        "parse_missing_value",
+        Variables_parse_missing_value
+    },
+    {
+        "parse_0_var_w_spaces",
+        Variables_parse_0_var_w_spaces
+    },
+    {
+        "parse_1_var_w_spaces",
+        Variables_parse_1_var_w_spaces
+    },
+    {
+        "parse_2_vars_w_spaces",
+        Variables_parse_2_vars_w_spaces
+    },
+    {
+        "parse_0_var_paren_w_spaces",
+        Variables_parse_0_var_paren_w_spaces
+    },
+    {
+        "parse_1_var_paren_w_spaces",
+        Variables_parse_1_var_paren_w_spaces
+    },
+    {
+        "parse_2_vars_paren_w_spaces",
+        Variables_parse_2_vars_paren_w_spaces
+    },
+    {
+        "var_count",
+        Variables_var_count
+    },
+    {
+        "var_name",
+        Variables_var_name
+    },
+    {
+        "var_is_entity",
+        Variables_var_is_entity
+    },
+    {
+        "no_this_anonymous_src",
+        Variables_no_this_anonymous_src
+    },
+    {
+        "no_this_anonymous_src_w_pair",
+        Variables_no_this_anonymous_src_w_pair
+    },
+    {
+        "no_this_anonymous_component_src",
+        Variables_no_this_anonymous_component_src
+    },
+    {
+        "no_this_anonymous_component_src_w_pair",
+        Variables_no_this_anonymous_component_src_w_pair
+    },
+    {
+        "lookup_from_table_this",
+        Variables_lookup_from_table_this
+    },
+    {
+        "lookup_from_entity_this",
+        Variables_lookup_from_entity_this
+    },
+    {
+        "lookup_from_table",
+        Variables_lookup_from_table
+    },
+    {
+        "lookup_from_entity",
+        Variables_lookup_from_entity
+    },
+    {
+        "lookup_from_not_written",
+        Variables_lookup_from_not_written
+    },
+    {
+        "lookup_from_table_this_component",
+        Variables_lookup_from_table_this_component
+    },
+    {
+        "lookup_from_entity_this_component",
+        Variables_lookup_from_entity_this_component
+    },
+    {
+        "lookup_from_table_component",
+        Variables_lookup_from_table_component
+    },
+    {
+        "lookup_from_entity_component",
+        Variables_lookup_from_entity_component
+    },
+    {
+        "lookup_from_table_two_children",
+        Variables_lookup_from_table_two_children
+    },
+    {
+        "lookup_from_entity_two_children",
+        Variables_lookup_from_entity_two_children
+    },
+    {
+        "lookup_from_table_same_child_twice",
+        Variables_lookup_from_table_same_child_twice
+    },
+    {
+        "lookup_from_entity_same_child_twice",
+        Variables_lookup_from_entity_same_child_twice
+    },
+    {
+        "lookup_from_table_not",
+        Variables_lookup_from_table_not
+    },
+    {
+        "lookup_from_entity_not",
+        Variables_lookup_from_entity_not
+    },
+    {
+        "lookup_from_table_w_any_component",
+        Variables_lookup_from_table_w_any_component
+    },
+    {
+        "lookup_from_entity_w_any_component",
+        Variables_lookup_from_entity_w_any_component
+    },
+    {
+        "lookup_as_tag",
+        Variables_lookup_as_tag
+    },
+    {
+        "lookup_as_relationship",
+        Variables_lookup_as_relationship
+    },
+    {
+        "lookup_as_target",
+        Variables_lookup_as_target
+    },
+    {
+        "lookup_assign_var",
+        Variables_lookup_assign_var
+    },
+    {
+        "lookup_eq_var",
+        Variables_lookup_eq_var
+    },
+    {
+        "lookup_neq_var",
+        Variables_lookup_neq_var
+    },
+    {
+        "lookup_unresolved_dependent",
+        Variables_lookup_unresolved_dependent
+    },
+    {
+        "check_vars_this",
+        Variables_check_vars_this
+    },
+    {
+        "check_vars_var",
+        Variables_check_vars_var
+    },
+    {
+        "check_vars_wildcard",
+        Variables_check_vars_wildcard
+    },
+    {
+        "check_vars_any",
+        Variables_check_vars_any
+    },
+    {
+        "check_vars_var_as_tgt",
+        Variables_check_vars_var_as_tgt
+    },
+    {
+        "check_vars_this_as_tgt",
+        Variables_check_vars_this_as_tgt
+    },
+    {
+        "check_vars_anonymous_var_as_tgt",
+        Variables_check_vars_anonymous_var_as_tgt
+    },
+    {
+        "check_vars_wildcard_as_tgt",
+        Variables_check_vars_wildcard_as_tgt
+    },
+    {
+        "check_vars_any_as_tgt",
+        Variables_check_vars_any_as_tgt
+    },
+    {
+        "check_vars_this_w_lookup_var",
+        Variables_check_vars_this_w_lookup_var
+    },
+    {
+        "check_vars_var_w_lookup_var",
+        Variables_check_vars_var_w_lookup_var
+    },
+    {
+        "1_trivial_1_var",
+        Variables_1_trivial_1_var
+    },
+    {
+        "2_trivial_1_var",
+        Variables_2_trivial_1_var
+    },
+    {
+        "1_trivial_1_var_component",
+        Variables_1_trivial_1_var_component
+    },
+    {
+        "2_trivial_1_var_component",
+        Variables_2_trivial_1_var_component
+    },
+    {
+        "1_trivial_1_wildcard",
+        Variables_1_trivial_1_wildcard
+    },
+    {
+        "2_trivial_1_wildcard",
+        Variables_2_trivial_1_wildcard
+    },
+    {
+        "1_trivial_1_wildcard_component",
+        Variables_1_trivial_1_wildcard_component
+    },
+    {
+        "2_trivial_1_wildcard_component",
+        Variables_2_trivial_1_wildcard_component
+    },
+    {
+        "1_trivial_1_any",
+        Variables_1_trivial_1_any
+    },
+    {
+        "2_trivial_1_any",
+        Variables_2_trivial_1_any
+    },
+    {
+        "1_trivial_1_any_component",
+        Variables_1_trivial_1_any_component
+    },
+    {
+        "2_trivial_1_any_component",
+        Variables_2_trivial_1_any_component
+    },
+    {
+        "first_invalid_var_name_and_id",
+        Variables_first_invalid_var_name_and_id
+    },
+    {
+        "src_invalid_var_name_and_id",
+        Variables_src_invalid_var_name_and_id
+    },
+    {
+        "second_invalid_var_name_and_id",
+        Variables_second_invalid_var_name_and_id
+    }
+};
+
+bake_test_case Operators_testcases[] = {
+    {
+        "2_and_not",
+        Operators_2_and_not
+    },
+    {
+        "2_and_not_component",
+        Operators_2_and_not_component
+    },
+    {
+        "2_and_out_not",
+        Operators_2_and_out_not
+    },
+    {
+        "2_and_out_not_component",
+        Operators_2_and_out_not_component
+    },
+    {
+        "3_and_not_not",
+        Operators_3_and_not_not
+    },
+    {
+        "2_and_not_pair_rel_wildcard",
+        Operators_2_and_not_pair_rel_wildcard
+    },
+    {
+        "2_and_not_pair_tgt_wildcard",
+        Operators_2_and_not_pair_tgt_wildcard
+    },
+    {
+        "2_and_not_pair_rel_tgt_wildcard",
+        Operators_2_and_not_pair_rel_tgt_wildcard
+    },
+    {
+        "2_and_not_pair_rel_var",
+        Operators_2_and_not_pair_rel_var
+    },
+    {
+        "2_and_not_pair_tgt_var",
+        Operators_2_and_not_pair_tgt_var
+    },
+    {
+        "2_and_not_pair_rel_tgt_var",
+        Operators_2_and_not_pair_rel_tgt_var
+    },
+    {
+        "2_and_not_pair_rel_tgt_same_var",
+        Operators_2_and_not_pair_rel_tgt_same_var
+    },
+    {
+        "2_and_not_pair_rel_var_written",
+        Operators_2_and_not_pair_rel_var_written
+    },
+    {
+        "2_and_not_pair_tgt_var_written",
+        Operators_2_and_not_pair_tgt_var_written
+    },
+    {
+        "2_and_not_pair_rel_tgt_var_written",
+        Operators_2_and_not_pair_rel_tgt_var_written
+    },
+    {
+        "2_and_not_pair_rel_tgt_same_var_written",
+        Operators_2_and_not_pair_rel_tgt_same_var_written
+    },
+    {
+        "2_and_not_pair_rel_src_tgt_same_var_written",
+        Operators_2_and_not_pair_rel_src_tgt_same_var_written
+    },
+    {
+        "2_and_not_pair_any_rel",
+        Operators_2_and_not_pair_any_rel
+    },
+    {
+        "2_and_not_pair_any_tgt",
+        Operators_2_and_not_pair_any_tgt
+    },
+    {
+        "2_and_not_pair_any_src",
+        Operators_2_and_not_pair_any_src
+    },
+    {
+        "1_not_any_src_fixed_first",
+        Operators_1_not_any_src_fixed_first
+    },
+    {
+        "1_not_any_src_any_tgt_fixed_first",
+        Operators_1_not_any_src_any_tgt_fixed_first
+    },
+    {
+        "1_not_any_src_any_first_fixed_tgt",
+        Operators_1_not_any_src_any_first_fixed_tgt
+    },
+    {
+        "1_not_any_src_any_childof_pair_any_tgt",
+        Operators_1_not_any_src_any_childof_pair_any_tgt
+    },
+    {
+        "1_not_any_src_any_isa_pair_any_tgt",
+        Operators_1_not_any_src_any_isa_pair_any_tgt
+    },
+    {
+        "2_and_optional",
+        Operators_2_and_optional
+    },
+    {
+        "3_and_optional_optional",
+        Operators_3_and_optional_optional
+    },
+    {
+        "2_and_optional_pair_rel_wildcard",
+        Operators_2_and_optional_pair_rel_wildcard
+    },
+    {
+        "2_and_optional_pair_tgt_wildcard",
+        Operators_2_and_optional_pair_tgt_wildcard
+    },
+    {
+        "2_and_optional_pair_rel_var",
+        Operators_2_and_optional_pair_rel_var
+    },
+    {
+        "2_and_optional_pair_tgt_var",
+        Operators_2_and_optional_pair_tgt_var
+    },
+    {
+        "2_and_optional_pair_rel_tgt_var",
+        Operators_2_and_optional_pair_rel_tgt_var
+    },
+    {
+        "2_and_optional_pair_rel_tgt_same_var",
+        Operators_2_and_optional_pair_rel_tgt_same_var
+    },
+    {
+        "2_and_optional_pair_rel_var_written",
+        Operators_2_and_optional_pair_rel_var_written
+    },
+    {
+        "2_and_optional_pair_tgt_var_written",
+        Operators_2_and_optional_pair_tgt_var_written
+    },
+    {
+        "2_and_optional_pair_rel_tgt_var_written",
+        Operators_2_and_optional_pair_rel_tgt_var_written
+    },
+    {
+        "2_and_optional_pair_rel_tgt_same_var_written",
+        Operators_2_and_optional_pair_rel_tgt_same_var_written
+    },
+    {
+        "2_and_optional_pair_rel_src_tgt_same_var_written",
+        Operators_2_and_optional_pair_rel_src_tgt_same_var_written
+    },
+    {
+        "3_and_optional_optional_pair_w_var",
+        Operators_3_and_optional_optional_pair_w_var
+    },
+    {
+        "2_and_optional_pair_any_rel",
+        Operators_2_and_optional_pair_any_rel
+    },
+    {
+        "2_and_optional_pair_any_tgt",
+        Operators_2_and_optional_pair_any_tgt
+    },
+    {
+        "2_and_optional_pair_any_src",
+        Operators_2_and_optional_pair_any_src
+    },
+    {
+        "3_and_optional_dependent_and_pair_rel",
+        Operators_3_and_optional_dependent_and_pair_rel
+    },
+    {
+        "3_and_optional_dependent_and_pair_tgt",
+        Operators_3_and_optional_dependent_and_pair_tgt
+    },
+    {
+        "3_and_optional_dependent_and_pair_rel_tgt",
+        Operators_3_and_optional_dependent_and_pair_rel_tgt
+    },
+    {
+        "3_and_optional_dependent_and_pair_rel_tgt_same_var",
+        Operators_3_and_optional_dependent_and_pair_rel_tgt_same_var
+    },
+    {
+        "3_and_optional_dependent_and_pair_rel_tgt_same_other_var",
+        Operators_3_and_optional_dependent_and_pair_rel_tgt_same_other_var
+    },
+    {
+        "3_and_optional_dependent_and_pair_src",
+        Operators_3_and_optional_dependent_and_pair_src
+    },
+    {
+        "3_and_optional_dependent_optional_pair_rel",
+        Operators_3_and_optional_dependent_optional_pair_rel
+    },
+    {
+        "3_and_optional_dependent_optional_pair_tgt",
+        Operators_3_and_optional_dependent_optional_pair_tgt
+    },
+    {
+        "3_and_optional_dependent_optional_pair_src",
+        Operators_3_and_optional_dependent_optional_pair_src
+    },
+    {
+        "3_and_optional_dependent_not_pair_rel",
+        Operators_3_and_optional_dependent_not_pair_rel
+    },
+    {
+        "3_and_optional_dependent_not_pair_tgt",
+        Operators_3_and_optional_dependent_not_pair_tgt
+    },
+    {
+        "3_and_optional_dependent_not_pair_src",
+        Operators_3_and_optional_dependent_not_pair_src
+    },
+    {
+        "1_optional_any_src_fixed_first",
+        Operators_1_optional_any_src_fixed_first
+    },
+    {
+        "1_optional_any_src_any_tgt_fixed_first",
+        Operators_1_optional_any_src_any_tgt_fixed_first
+    },
+    {
+        "1_optional_any_src_any_first_fixed_tgt",
+        Operators_1_optional_any_src_any_first_fixed_tgt
+    },
+    {
+        "1_optional_any_src_any_childof_pair_any_tgt",
+        Operators_1_optional_any_src_any_childof_pair_any_tgt
+    },
+    {
+        "1_optional_any_src_any_isa_pair_any_tgt",
+        Operators_1_optional_any_src_any_isa_pair_any_tgt
+    },
+    {
+        "2_or",
+        Operators_2_or
+    },
+    {
+        "3_or",
+        Operators_3_or
+    },
+    {
+        "2_or_w_and",
+        Operators_2_or_w_and
+    },
+    {
+        "3_or_w_and",
+        Operators_3_or_w_and
+    },
+    {
+        "2_or_written",
+        Operators_2_or_written
+    },
+    {
+        "3_or_written",
+        Operators_3_or_written
+    },
+    {
+        "2_or_written_w_rel_var",
+        Operators_2_or_written_w_rel_var
+    },
+    {
+        "3_or_written_w_rel_var",
+        Operators_3_or_written_w_rel_var
+    },
+    {
+        "2_or_written_w_tgt_var",
+        Operators_2_or_written_w_tgt_var
+    },
+    {
+        "2_or_written_w_rel_tgt_var",
+        Operators_2_or_written_w_rel_tgt_var
+    },
+    {
+        "2_or_written_w_rel_tgt_same_var",
+        Operators_2_or_written_w_rel_tgt_same_var
+    },
+    {
+        "3_or_written_w_tgt_var",
+        Operators_3_or_written_w_tgt_var
+    },
+    {
+        "2_or_chains",
+        Operators_2_or_chains
+    },
+    {
+        "2_or_chains_written",
+        Operators_2_or_chains_written
+    },
+    {
+        "2_or_dependent",
+        Operators_2_or_dependent
+    },
+    {
+        "2_or_dependent_reverse",
+        Operators_2_or_dependent_reverse
+    },
+    {
+        "2_or_dependent_2_vars",
+        Operators_2_or_dependent_2_vars
+    },
+    {
+        "2_or_written_dependent",
+        Operators_2_or_written_dependent
+    },
+    {
+        "2_or_written_dependent_2_vars",
+        Operators_2_or_written_dependent_2_vars
+    },
+    {
+        "2_or_w_dependent",
+        Operators_2_or_w_dependent
+    },
+    {
+        "2_or_w_both",
+        Operators_2_or_w_both
+    },
+    {
+        "3_or_w_both",
+        Operators_3_or_w_both
+    },
+    {
+        "2_or_w_not",
+        Operators_2_or_w_not
+    },
+    {
+        "2_or_w_not_component",
+        Operators_2_or_w_not_component
+    },
+    {
+        "2_or_w_not_out_component",
+        Operators_2_or_w_not_out_component
+    },
+    {
+        "2_or_w_not_out_all_components",
+        Operators_2_or_w_not_out_all_components
+    },
+    {
+        "2_not_first",
+        Operators_2_not_first
+    },
+    {
+        "2_optional_first",
+        Operators_2_optional_first
+    },
+    {
+        "only_not",
+        Operators_only_not
+    },
+    {
+        "only_not_component",
+        Operators_only_not_component
+    },
+    {
+        "only_not_out_component",
+        Operators_only_not_out_component
+    },
+    {
+        "only_optional",
+        Operators_only_optional
+    },
+    {
+        "only_optional_component",
+        Operators_only_optional_component
+    },
+    {
+        "not_after_fixed_src",
+        Operators_not_after_fixed_src
+    },
+    {
+        "optional_after_fixed_src",
+        Operators_optional_after_fixed_src
+    },
+    {
+        "root_entities_empty",
+        Operators_root_entities_empty
+    },
+    {
+        "root_entities",
+        Operators_root_entities
+    },
+    {
+        "root_entities_w_children",
+        Operators_root_entities_w_children
+    },
+    {
+        "root_entities_w_optional_children",
+        Operators_root_entities_w_optional_children
+    },
+    {
+        "core_entities_w_optional_children",
+        Operators_core_entities_w_optional_children
+    },
+    {
+        "root_entities_w_not_children",
+        Operators_root_entities_w_not_children
+    },
+    {
+        "core_entities_w_not_children",
+        Operators_core_entities_w_not_children
+    },
+    {
+        "1_ent_src_not",
+        Operators_1_ent_src_not
+    },
+    {
+        "1_ent_src_not_pair",
+        Operators_1_ent_src_not_pair
+    },
+    {
+        "1_ent_src_not_pair_rel_wildcard",
+        Operators_1_ent_src_not_pair_rel_wildcard
+    },
+    {
+        "1_ent_src_not_pair_tgt_wildcard",
+        Operators_1_ent_src_not_pair_tgt_wildcard
+    },
+    {
+        "1_ent_src_not_pair_rel_tgt_wildcard",
+        Operators_1_ent_src_not_pair_rel_tgt_wildcard
+    },
+    {
+        "1_ent_src_not_pair_rel_any",
+        Operators_1_ent_src_not_pair_rel_any
+    },
+    {
+        "1_ent_src_not_pair_tgt_any",
+        Operators_1_ent_src_not_pair_tgt_any
+    },
+    {
+        "1_ent_src_not_pair_rel_tgt_any",
+        Operators_1_ent_src_not_pair_rel_tgt_any
+    },
+    {
+        "1_ent_src_not_pair_rel_var",
+        Operators_1_ent_src_not_pair_rel_var
+    },
+    {
+        "1_ent_src_not_pair_tgt_var",
+        Operators_1_ent_src_not_pair_tgt_var
+    },
+    {
+        "1_ent_src_not_pair_rel_tgt_var",
+        Operators_1_ent_src_not_pair_rel_tgt_var
+    },
+    {
+        "1_ent_src_not_pair_rel_tgt_same_var",
+        Operators_1_ent_src_not_pair_rel_tgt_same_var
+    },
+    {
+        "1_this_src_not_pair_rel_var",
+        Operators_1_this_src_not_pair_rel_var
+    },
+    {
+        "1_this_src_not_pair_tgt_var",
+        Operators_1_this_src_not_pair_tgt_var
+    },
+    {
+        "1_this_src_not_pair_rel_tgt_var",
+        Operators_1_this_src_not_pair_rel_tgt_var
+    },
+    {
+        "1_this_src_not_pair_rel_tgt_same_var",
+        Operators_1_this_src_not_pair_rel_tgt_same_var
+    },
+    {
+        "1_ent_src_not_pair_rel_var_written",
+        Operators_1_ent_src_not_pair_rel_var_written
+    },
+    {
+        "1_ent_src_not_pair_tgt_var_written",
+        Operators_1_ent_src_not_pair_tgt_var_written
+    },
+    {
+        "1_ent_src_not_pair_rel_tgt_var_written",
+        Operators_1_ent_src_not_pair_rel_tgt_var_written
+    },
+    {
+        "1_ent_src_not_pair_rel_tgt_same_var_written",
+        Operators_1_ent_src_not_pair_rel_tgt_same_var_written
+    },
+    {
+        "and_from_fixed_src",
+        Operators_and_from_fixed_src
+    },
+    {
+        "not_from_fixed_src",
+        Operators_not_from_fixed_src
+    },
+    {
+        "or_from_fixed_src",
+        Operators_or_from_fixed_src
+    },
+    {
+        "and_from_this",
+        Operators_and_from_this
+    },
+    {
+        "not_from_this",
+        Operators_not_from_this
+    },
+    {
+        "or_from_this",
+        Operators_or_from_this
+    },
+    {
+        "and_from_this_written",
+        Operators_and_from_this_written
+    },
+    {
+        "not_from_this_written",
+        Operators_not_from_this_written
+    },
+    {
+        "or_from_this_written",
+        Operators_or_from_this_written
+    },
+    {
+        "and_from_empty",
+        Operators_and_from_empty
+    },
+    {
+        "not_from_empty",
+        Operators_not_from_empty
+    },
+    {
+        "or_from_empty",
+        Operators_or_from_empty
+    },
+    {
+        "and_from_empty_w_tag",
+        Operators_and_from_empty_w_tag
+    },
+    {
+        "not_from_empty_w_tag",
+        Operators_not_from_empty_w_tag
+    },
+    {
+        "or_from_empty_w_tag",
+        Operators_or_from_empty_w_tag
+    },
+    {
+        "or_w_wildcard",
+        Operators_or_w_wildcard
+    },
+    {
+        "or_w_component_and_tag",
+        Operators_or_w_component_and_tag
+    },
+    {
+        "or_w_tag_and_component",
+        Operators_or_w_tag_and_component
+    }
+};
+
+bake_test_case Transitive_testcases[] = {
+    {
+        "1_fact_0_lvl_true",
+        Transitive_1_fact_0_lvl_true
+    },
+    {
+        "1_fact_1_lvl_true",
+        Transitive_1_fact_1_lvl_true
+    },
+    {
+        "1_fact_2_lvl_true",
+        Transitive_1_fact_2_lvl_true
+    },
+    {
+        "1_fact_0_lvl_false",
+        Transitive_1_fact_0_lvl_false
+    },
+    {
+        "1_fact_1_lvl_false",
+        Transitive_1_fact_1_lvl_false
+    },
+    {
+        "1_fact_2_lvl_false",
+        Transitive_1_fact_2_lvl_false
+    },
+    {
+        "1_fact_reflexive",
+        Transitive_1_fact_reflexive
+    },
+    {
+        "1_isa",
+        Transitive_1_isa
+    },
+    {
+        "1_childof",
+        Transitive_1_childof
+    },
+    {
+        "1_this_src_written_0_lvl",
+        Transitive_1_this_src_written_0_lvl
+    },
+    {
+        "1_this_src_written_1_lvl",
+        Transitive_1_this_src_written_1_lvl
+    },
+    {
+        "1_this_src_written_2_lvl",
+        Transitive_1_this_src_written_2_lvl
+    },
+    {
+        "1_this_src_written_reflexive",
+        Transitive_1_this_src_written_reflexive
+    },
+    {
+        "1_this_src_0_lvl",
+        Transitive_1_this_src_0_lvl
+    },
+    {
+        "1_this_src_1_lvl",
+        Transitive_1_this_src_1_lvl
+    },
+    {
+        "1_this_src_2_lvl",
+        Transitive_1_this_src_2_lvl
+    },
+    {
+        "1_this_src_reflexive",
+        Transitive_1_this_src_reflexive
+    },
+    {
+        "1_ent_src_tgt_var_0_lvl",
+        Transitive_1_ent_src_tgt_var_0_lvl
+    },
+    {
+        "1_ent_src_tgt_var_1_lvl",
+        Transitive_1_ent_src_tgt_var_1_lvl
+    },
+    {
+        "1_ent_src_tgt_var_2_lvl",
+        Transitive_1_ent_src_tgt_var_2_lvl
+    },
+    {
+        "1_ent_src_tgt_var_reflexive",
+        Transitive_1_ent_src_tgt_var_reflexive
+    },
+    {
+        "1_this_src_tgt_var",
+        Transitive_1_this_src_tgt_var
+    },
+    {
+        "1_this_src_tgt_var_reflexive",
+        Transitive_1_this_src_tgt_var_reflexive
+    },
+    {
+        "1_var_src_written_0_lvl",
+        Transitive_1_var_src_written_0_lvl
+    },
+    {
+        "1_var_src_written_1_lvl",
+        Transitive_1_var_src_written_1_lvl
+    },
+    {
+        "1_var_src_written_2_lvl",
+        Transitive_1_var_src_written_2_lvl
+    },
+    {
+        "1_var_src_written_reflexive",
+        Transitive_1_var_src_written_reflexive
+    },
+    {
+        "1_var_src_0_lvl",
+        Transitive_1_var_src_0_lvl
+    },
+    {
+        "1_var_src_1_lvl",
+        Transitive_1_var_src_1_lvl
+    },
+    {
+        "1_var_src_2_lvl",
+        Transitive_1_var_src_2_lvl
+    },
+    {
+        "1_var_src_reflexive",
+        Transitive_1_var_src_reflexive
+    },
+    {
+        "1_var_src_tgt_var",
+        Transitive_1_var_src_tgt_var
+    },
+    {
+        "1_var_src_tgt_var_reflexive",
+        Transitive_1_var_src_tgt_var_reflexive
+    },
+    {
+        "1_ent_src_tgt_this_0_lvl",
+        Transitive_1_ent_src_tgt_this_0_lvl
+    },
+    {
+        "1_ent_src_tgt_this_1_lvl",
+        Transitive_1_ent_src_tgt_this_1_lvl
+    },
+    {
+        "1_ent_src_tgt_this_2_lvl",
+        Transitive_1_ent_src_tgt_this_2_lvl
+    },
+    {
+        "1_ent_src_tgt_this_reflexive",
+        Transitive_1_ent_src_tgt_this_reflexive
+    },
+    {
+        "1_var_src_tgt_this",
+        Transitive_1_var_src_tgt_this
+    },
+    {
+        "1_var_src_tgt_this_reflexive",
+        Transitive_1_var_src_tgt_this_reflexive
+    },
+    {
+        "2_ent_src_constrain_tgt_var_before_0_lvl",
+        Transitive_2_ent_src_constrain_tgt_var_before_0_lvl
+    },
+    {
+        "2_ent_src_constrain_tgt_var_before_1_lvl",
+        Transitive_2_ent_src_constrain_tgt_var_before_1_lvl
+    },
+    {
+        "2_ent_src_constrain_tgt_var_before_2_lvl",
+        Transitive_2_ent_src_constrain_tgt_var_before_2_lvl
+    },
+    {
+        "2_ent_src_constrain_tgt_var_after_0_lvl",
+        Transitive_2_ent_src_constrain_tgt_var_after_0_lvl
+    },
+    {
+        "2_ent_src_constrain_tgt_var_after_1_lvl",
+        Transitive_2_ent_src_constrain_tgt_var_after_1_lvl
+    },
+    {
+        "2_ent_src_constrain_tgt_var_after_2_lvl",
+        Transitive_2_ent_src_constrain_tgt_var_after_2_lvl
+    },
+    {
+        "2_this_src_constrain_tgt_var_before_0_lvl",
+        Transitive_2_this_src_constrain_tgt_var_before_0_lvl
+    },
+    {
+        "2_this_src_constrain_tgt_var_before_1_lvl",
+        Transitive_2_this_src_constrain_tgt_var_before_1_lvl
+    },
+    {
+        "2_this_src_constrain_tgt_var_before_2_lvl",
+        Transitive_2_this_src_constrain_tgt_var_before_2_lvl
+    },
+    {
+        "2_this_src_constrain_tgt_var_after_0_lvl",
+        Transitive_2_this_src_constrain_tgt_var_after_0_lvl
+    },
+    {
+        "2_this_src_constrain_tgt_var_after_1_lvl",
+        Transitive_2_this_src_constrain_tgt_var_after_1_lvl
+    },
+    {
+        "2_this_src_constrain_tgt_var_after_2_lvl",
+        Transitive_2_this_src_constrain_tgt_var_after_2_lvl
+    },
+    {
+        "1_src_tgt_same_var",
+        Transitive_1_src_tgt_same_var
+    },
+    {
+        "1_src_tgt_same_var_reflexive",
+        Transitive_1_src_tgt_same_var_reflexive
+    },
+    {
+        "1_src_tgt_same_this_var_reflexive",
+        Transitive_1_src_tgt_same_this_var_reflexive
+    },
+    {
+        "1_any_src_tgt_var",
+        Transitive_1_any_src_tgt_var
+    },
+    {
+        "not_transitive_ent_tgt",
+        Transitive_not_transitive_ent_tgt
+    },
+    {
+        "not_transitive_var_tgt",
+        Transitive_not_transitive_var_tgt
+    },
+    {
+        "not_transitive_ent_tgt_written",
+        Transitive_not_transitive_ent_tgt_written
+    },
+    {
+        "not_transitive_var_tgt_written",
+        Transitive_not_transitive_var_tgt_written
+    },
+    {
+        "optional_transitive_ent_tgt",
+        Transitive_optional_transitive_ent_tgt
+    },
+    {
+        "optional_transitive_var_tgt",
+        Transitive_optional_transitive_var_tgt
+    },
+    {
+        "optional_transitive_ent_tgt_written",
+        Transitive_optional_transitive_ent_tgt_written
+    },
+    {
+        "optional_transitive_var_tgt_written",
+        Transitive_optional_transitive_var_tgt_written
+    },
+    {
+        "2_var_src_w_same_tgt_ent",
+        Transitive_2_var_src_w_same_tgt_ent
+    },
+    {
+        "self_target",
+        Transitive_self_target
+    },
+    {
+        "any_target",
+        Transitive_any_target
+    },
+    {
+        "isa_prefab",
+        Transitive_isa_prefab
+    },
+    {
+        "isa_disabled",
+        Transitive_isa_disabled
+    },
+    {
+        "isa_prefab_match_prefab_flag",
+        Transitive_isa_prefab_match_prefab_flag
+    },
+    {
+        "isa_prefab_match_prefab_term",
+        Transitive_isa_prefab_match_prefab_term
+    },
+    {
+        "isa_disabled_match_disabled_flag",
+        Transitive_isa_disabled_match_disabled_flag
+    },
+    {
+        "isa_disabled_match_disabled_term",
+        Transitive_isa_disabled_match_disabled_term
+    }
+};
+
+bake_test_case ComponentInheritance_testcases[] = {
+    {
+        "1_ent_0_lvl",
+        ComponentInheritance_1_ent_0_lvl
+    },
+    {
+        "1_ent_1_lvl",
+        ComponentInheritance_1_ent_1_lvl
+    },
+    {
+        "1_ent_2_lvl",
+        ComponentInheritance_1_ent_2_lvl
+    },
+    {
+        "1_ent_3_lvl",
+        ComponentInheritance_1_ent_3_lvl
+    },
+    {
+        "1_this_0_lvl",
+        ComponentInheritance_1_this_0_lvl
+    },
+    {
+        "1_this_1_lvl",
+        ComponentInheritance_1_this_1_lvl
+    },
+    {
+        "1_this_2_lvl",
+        ComponentInheritance_1_this_2_lvl
+    },
+    {
+        "1_this_3_lvl",
+        ComponentInheritance_1_this_3_lvl
+    },
+    {
+        "1_this_0_lvl_written",
+        ComponentInheritance_1_this_0_lvl_written
+    },
+    {
+        "1_this_1_lvl_written",
+        ComponentInheritance_1_this_1_lvl_written
+    },
+    {
+        "1_this_2_lvl_written",
+        ComponentInheritance_1_this_2_lvl_written
+    },
+    {
+        "1_this_3_lvl_written",
+        ComponentInheritance_1_this_3_lvl_written
+    },
+    {
+        "1_var_0_lvl",
+        ComponentInheritance_1_var_0_lvl
+    },
+    {
+        "1_var_1_lvl",
+        ComponentInheritance_1_var_1_lvl
+    },
+    {
+        "1_var_2_lvl",
+        ComponentInheritance_1_var_2_lvl
+    },
+    {
+        "1_var_3_lvl",
+        ComponentInheritance_1_var_3_lvl
+    },
+    {
+        "1_var_0_lvl_written",
+        ComponentInheritance_1_var_0_lvl_written
+    },
+    {
+        "1_var_1_lvl_written",
+        ComponentInheritance_1_var_1_lvl_written
+    },
+    {
+        "1_var_2_lvl_written",
+        ComponentInheritance_1_var_2_lvl_written
+    },
+    {
+        "1_var_3_lvl_written",
+        ComponentInheritance_1_var_3_lvl_written
+    },
+    {
+        "1_ent_1_lvl_self",
+        ComponentInheritance_1_ent_1_lvl_self
+    },
+    {
+        "1_this_1_lvl_self",
+        ComponentInheritance_1_this_1_lvl_self
+    },
+    {
+        "1_this_1_lvl_written_self",
+        ComponentInheritance_1_this_1_lvl_written_self
+    },
+    {
+        "1_var_1_lvl_self",
+        ComponentInheritance_1_var_1_lvl_self
+    },
+    {
+        "1_var_1_lvl_written_self",
+        ComponentInheritance_1_var_1_lvl_written_self
+    },
+    {
+        "1_ent_src_not",
+        ComponentInheritance_1_ent_src_not
+    },
+    {
+        "1_this_src_not",
+        ComponentInheritance_1_this_src_not
+    },
+    {
+        "1_var_src_not",
+        ComponentInheritance_1_var_src_not
+    },
+    {
+        "1_this_src_not_written",
+        ComponentInheritance_1_this_src_not_written
+    },
+    {
+        "1_var_src_not_written",
+        ComponentInheritance_1_var_src_not_written
+    },
+    {
+        "first_self",
+        ComponentInheritance_first_self
+    }
+};
+
+bake_test_case Recycled_testcases[] = {
+    {
+        "recycled_vars",
+        Recycled_recycled_vars
+    },
+    {
+        "recycled_pair_vars",
+        Recycled_recycled_pair_vars
+    },
+    {
+        "recycled_this_ent_var",
+        Recycled_recycled_this_ent_var
+    },
+    {
+        "has_recycled_id_from_pair",
+        Recycled_has_recycled_id_from_pair
+    },
+    {
+        "recycled_pair",
+        Recycled_recycled_pair
+    },
+    {
+        "recycled_component_id",
+        Recycled_recycled_component_id
+    }
+};
+
+bake_test_case BuiltinPredicates_testcases[] = {
+    {
+        "this_eq_id",
+        BuiltinPredicates_this_eq_id
+    },
+    {
+        "this_eq_name",
+        BuiltinPredicates_this_eq_name
+    },
+    {
+        "this_eq_var",
+        BuiltinPredicates_this_eq_var
+    },
+    {
+        "this_eq_id_written",
+        BuiltinPredicates_this_eq_id_written
+    },
+    {
+        "this_eq_id_written_no_match",
+        BuiltinPredicates_this_eq_id_written_no_match
+    },
+    {
+        "this_eq_name_written",
+        BuiltinPredicates_this_eq_name_written
+    },
+    {
+        "this_eq_name_written_no_match",
+        BuiltinPredicates_this_eq_name_written_no_match
+    },
+    {
+        "this_eq_var_written",
+        BuiltinPredicates_this_eq_var_written
+    },
+    {
+        "var_eq_id",
+        BuiltinPredicates_var_eq_id
+    },
+    {
+        "var_eq_name",
+        BuiltinPredicates_var_eq_name
+    },
+    {
+        "var_eq_var",
+        BuiltinPredicates_var_eq_var
+    },
+    {
+        "var_eq_id_written",
+        BuiltinPredicates_var_eq_id_written
+    },
+    {
+        "var_eq_id_written_no_match",
+        BuiltinPredicates_var_eq_id_written_no_match
+    },
+    {
+        "var_eq_name_written",
+        BuiltinPredicates_var_eq_name_written
+    },
+    {
+        "var_eq_name_written_no_match",
+        BuiltinPredicates_var_eq_name_written_no_match
+    },
+    {
+        "var_eq_var_written",
+        BuiltinPredicates_var_eq_var_written
+    },
+    {
+        "var_eq_this",
+        BuiltinPredicates_var_eq_this
+    },
+    {
+        "this_neq_id",
+        BuiltinPredicates_this_neq_id
+    },
+    {
+        "this_neq_name",
+        BuiltinPredicates_this_neq_name
+    },
+    {
+        "this_neq_var",
+        BuiltinPredicates_this_neq_var
+    },
+    {
+        "this_neq_id_written",
+        BuiltinPredicates_this_neq_id_written
+    },
+    {
+        "this_neq_id_written_no_match",
+        BuiltinPredicates_this_neq_id_written_no_match
+    },
+    {
+        "this_neq_name_written",
+        BuiltinPredicates_this_neq_name_written
+    },
+    {
+        "this_neq_name_written_no_match",
+        BuiltinPredicates_this_neq_name_written_no_match
+    },
+    {
+        "this_neq_var_written",
+        BuiltinPredicates_this_neq_var_written
+    },
+    {
+        "var_neq_id",
+        BuiltinPredicates_var_neq_id
+    },
+    {
+        "var_neq_name",
+        BuiltinPredicates_var_neq_name
+    },
+    {
+        "var_neq_var",
+        BuiltinPredicates_var_neq_var
+    },
+    {
+        "var_neq_id_written",
+        BuiltinPredicates_var_neq_id_written
+    },
+    {
+        "var_neq_id_written_no_match",
+        BuiltinPredicates_var_neq_id_written_no_match
+    },
+    {
+        "var_neq_name_written",
+        BuiltinPredicates_var_neq_name_written
+    },
+    {
+        "var_neq_name_written_no_match",
+        BuiltinPredicates_var_neq_name_written_no_match
+    },
+    {
+        "var_neq_var_written",
+        BuiltinPredicates_var_neq_var_written
+    },
+    {
+        "var_neq_this",
+        BuiltinPredicates_var_neq_this
+    },
+    {
+        "this_2_neq_id",
+        BuiltinPredicates_this_2_neq_id
+    },
+    {
+        "this_2_neq_name",
+        BuiltinPredicates_this_2_neq_name
+    },
+    {
+        "var_2_neq_id",
+        BuiltinPredicates_var_2_neq_id
+    },
+    {
+        "var_2_neq_name",
+        BuiltinPredicates_var_2_neq_name
+    },
+    {
+        "this_2_neq_id_written",
+        BuiltinPredicates_this_2_neq_id_written
+    },
+    {
+        "this_2_neq_name_written",
+        BuiltinPredicates_this_2_neq_name_written
+    },
+    {
+        "var_2_neq_id_written",
+        BuiltinPredicates_var_2_neq_id_written
+    },
+    {
+        "var_2_neq_name_written",
+        BuiltinPredicates_var_2_neq_name_written
+    },
+    {
+        "this_2_or_id",
+        BuiltinPredicates_this_2_or_id
+    },
+    {
+        "this_3_or_id",
+        BuiltinPredicates_this_3_or_id
+    },
+    {
+        "this_2_or_name",
+        BuiltinPredicates_this_2_or_name
+    },
+    {
+        "this_3_or_name",
+        BuiltinPredicates_this_3_or_name
+    },
+    {
+        "this_2_or_match",
+        BuiltinPredicates_this_2_or_match
+    },
+    {
+        "this_3_or_match",
+        BuiltinPredicates_this_3_or_match
+    },
+    {
+        "var_2_or_id",
+        BuiltinPredicates_var_2_or_id
+    },
+    {
+        "var_2_or_name",
+        BuiltinPredicates_var_2_or_name
+    },
+    {
+        "this_2_or_id_written",
+        BuiltinPredicates_this_2_or_id_written
+    },
+    {
+        "this_3_or_id_written",
+        BuiltinPredicates_this_3_or_id_written
+    },
+    {
+        "this_2_or_name_written",
+        BuiltinPredicates_this_2_or_name_written
+    },
+    {
+        "var_2_or_id_written",
+        BuiltinPredicates_var_2_or_id_written
+    },
+    {
+        "var_2_or_name_written",
+        BuiltinPredicates_var_2_or_name_written
+    },
+    {
+        "this_match_eq",
+        BuiltinPredicates_this_match_eq
+    },
+    {
+        "var_match_eq",
+        BuiltinPredicates_var_match_eq
+    },
+    {
+        "this_match_eq_written",
+        BuiltinPredicates_this_match_eq_written
+    },
+    {
+        "this_match_eq_written_self",
+        BuiltinPredicates_this_match_eq_written_self
+    },
+    {
+        "var_match_eq_written",
+        BuiltinPredicates_var_match_eq_written
+    },
+    {
+        "this_match_neq",
+        BuiltinPredicates_this_match_neq
+    },
+    {
+        "var_match_neq",
+        BuiltinPredicates_var_match_neq
+    },
+    {
+        "this_match_neq_written",
+        BuiltinPredicates_this_match_neq_written
+    },
+    {
+        "var_match_neq_written",
+        BuiltinPredicates_var_match_neq_written
+    },
+    {
+        "this_match_2_neq",
+        BuiltinPredicates_this_match_2_neq
+    },
+    {
+        "var_match_2_neq",
+        BuiltinPredicates_var_match_2_neq
+    },
+    {
+        "this_match_2_neq_written",
+        BuiltinPredicates_this_match_2_neq_written
+    },
+    {
+        "var_match_2_neq_written",
+        BuiltinPredicates_var_match_2_neq_written
+    },
+    {
+        "this_match_2_or",
+        BuiltinPredicates_this_match_2_or
+    },
+    {
+        "this_match_2_or_written",
+        BuiltinPredicates_this_match_2_or_written
+    },
+    {
+        "this_match_3_or",
+        BuiltinPredicates_this_match_3_or
+    },
+    {
+        "this_match_3_or_written",
+        BuiltinPredicates_this_match_3_or_written
+    },
+    {
+        "unresolved_by_name",
+        BuiltinPredicates_unresolved_by_name
+    },
+    {
+        "var_eq_wildcard",
+        BuiltinPredicates_var_eq_wildcard
+    },
+    {
+        "var_eq_any",
+        BuiltinPredicates_var_eq_any
+    },
+    {
+        "var_eq_wildcard_after_write",
+        BuiltinPredicates_var_eq_wildcard_after_write
+    },
+    {
+        "var_eq_any_after_write",
+        BuiltinPredicates_var_eq_any_after_write
+    },
+    {
+        "var_eq_after_var_0_src",
+        BuiltinPredicates_var_eq_after_var_0_src
+    },
+    {
+        "2_or_w_eq_this",
+        BuiltinPredicates_2_or_w_eq_this
+    },
+    {
+        "2_or_w_eq_lookup_var",
+        BuiltinPredicates_2_or_w_eq_lookup_var
+    },
+    {
+        "3_or_w_eq_lookup_var",
+        BuiltinPredicates_3_or_w_eq_lookup_var
+    }
+};
+
+bake_test_case Scopes_testcases[] = {
+    {
+        "term_w_not_scope_1_term",
+        Scopes_term_w_not_scope_1_term
+    },
+    {
+        "term_w_not_scope_2_terms",
+        Scopes_term_w_not_scope_2_terms
+    },
+    {
+        "term_w_not_scope_1_term_w_not",
+        Scopes_term_w_not_scope_1_term_w_not
+    },
+    {
+        "term_w_not_scope_2_terms_w_not",
+        Scopes_term_w_not_scope_2_terms_w_not
+    },
+    {
+        "term_w_not_scope_1_term_w_var",
+        Scopes_term_w_not_scope_1_term_w_var
+    },
+    {
+        "term_w_not_scope_2_terms_w_var",
+        Scopes_term_w_not_scope_2_terms_w_var
+    },
+    {
+        "term_w_not_scope_1_term_w_not_w_var",
+        Scopes_term_w_not_scope_1_term_w_not_w_var
+    },
+    {
+        "term_w_not_scope_2_terms_w_not_w_var",
+        Scopes_term_w_not_scope_2_terms_w_not_w_var
+    },
+    {
+        "term_w_not_scope_2_terms_w_or",
+        Scopes_term_w_not_scope_2_terms_w_or
+    },
+    {
+        "term_w_not_scope_3_terms_w_or",
+        Scopes_term_w_not_scope_3_terms_w_or
+    }
+};
+
+bake_test_case Traversal_testcases[] = {
+    {
+        "this_self_up_childof",
+        Traversal_this_self_up_childof
+    },
+    {
+        "this_up_childof",
+        Traversal_this_up_childof
+    },
+    {
+        "this_written_self_up_childof",
+        Traversal_this_written_self_up_childof
+    },
+    {
+        "this_written_up_childof",
+        Traversal_this_written_up_childof
+    },
+    {
+        "var_self_up_childof",
+        Traversal_var_self_up_childof
+    },
+    {
+        "var_up_childof",
+        Traversal_var_up_childof
+    },
+    {
+        "var_written_self_up_childof",
+        Traversal_var_written_self_up_childof
+    },
+    {
+        "var_written_up_childof",
+        Traversal_var_written_up_childof
+    },
+    {
+        "set_var_self_up_childof",
+        Traversal_set_var_self_up_childof
+    },
+    {
+        "set_var_up_childof",
+        Traversal_set_var_up_childof
+    },
+    {
+        "set_var_written_self_up_childof",
+        Traversal_set_var_written_self_up_childof
+    },
+    {
+        "set_var_written_up_childof",
+        Traversal_set_var_written_up_childof
+    },
+    {
+        "ent_self_up_childof",
+        Traversal_ent_self_up_childof
+    },
+    {
+        "ent_up_childof",
+        Traversal_ent_up_childof
+    },
+    {
+        "implicit_this_self_up_isa",
+        Traversal_implicit_this_self_up_isa
+    },
+    {
+        "implicit_this_up_isa",
+        Traversal_implicit_this_up_isa
+    },
+    {
+        "implicit_var_self_up_isa",
+        Traversal_implicit_var_self_up_isa
+    },
+    {
+        "implicit_var_up_isa",
+        Traversal_implicit_var_up_isa
+    },
+    {
+        "implicit_ent_self_up_isa",
+        Traversal_implicit_ent_self_up_isa
+    },
+    {
+        "implicit_ent_up_isa",
+        Traversal_implicit_ent_up_isa
+    },
+    {
+        "self_up_2_targets",
+        Traversal_self_up_2_targets
+    },
+    {
+        "up_2_targets",
+        Traversal_up_2_targets
+    },
+    {
+        "self_up_2_targets_diamond",
+        Traversal_self_up_2_targets_diamond
+    },
+    {
+        "up_2_targets_diamond",
+        Traversal_up_2_targets_diamond
+    },
+    {
+        "written_self_up_2_targets",
+        Traversal_written_self_up_2_targets
+    },
+    {
+        "written_up_2_targets",
+        Traversal_written_up_2_targets
+    },
+    {
+        "written_self_up_2_targets_diamond",
+        Traversal_written_self_up_2_targets_diamond
+    },
+    {
+        "written_up_2_targets_diamond",
+        Traversal_written_up_2_targets_diamond
+    },
+    {
+        "2_self_up_terms",
+        Traversal_2_self_up_terms
+    },
+    {
+        "2_self_up_terms_2_targets",
+        Traversal_2_self_up_terms_2_targets
+    },
+    {
+        "self_up_empty_table",
+        Traversal_self_up_empty_table
+    },
+    {
+        "up_empty_table",
+        Traversal_up_empty_table
+    },
+    {
+        "self_up_all_owned",
+        Traversal_self_up_all_owned
+    },
+    {
+        "up_all_owned",
+        Traversal_up_all_owned
+    },
+    {
+        "this_self_up_childof_inherited",
+        Traversal_this_self_up_childof_inherited
+    },
+    {
+        "this_up_childof_inherited",
+        Traversal_this_up_childof_inherited
+    },
+    {
+        "this_written_self_up_childof_inherited",
+        Traversal_this_written_self_up_childof_inherited
+    },
+    {
+        "this_written_up_childof_inherited",
+        Traversal_this_written_up_childof_inherited
+    },
+    {
+        "var_self_up_childof_inherited",
+        Traversal_var_self_up_childof_inherited
+    },
+    {
+        "var_up_childof_inherited",
+        Traversal_var_up_childof_inherited
+    },
+    {
+        "var_written_self_up_childof_inherited",
+        Traversal_var_written_self_up_childof_inherited
+    },
+    {
+        "var_written_up_childof_inherited",
+        Traversal_var_written_up_childof_inherited
+    },
+    {
+        "ent_self_up_childof_inherited",
+        Traversal_ent_self_up_childof_inherited
+    },
+    {
+        "ent_up_childof_inherited",
+        Traversal_ent_up_childof_inherited
+    },
+    {
+        "ent_written_self_up_childof_inherited",
+        Traversal_ent_written_self_up_childof_inherited
+    },
+    {
+        "ent_written_up_childof_inherited",
+        Traversal_ent_written_up_childof_inherited
+    },
+    {
+        "this_self_up_childof_component",
+        Traversal_this_self_up_childof_component
+    },
+    {
+        "this_up_childof_component",
+        Traversal_this_up_childof_component
+    },
+    {
+        "this_written_self_up_childof_component",
+        Traversal_this_written_self_up_childof_component
+    },
+    {
+        "this_written_up_childof_component",
+        Traversal_this_written_up_childof_component
+    },
+    {
+        "var_self_up_childof_component",
+        Traversal_var_self_up_childof_component
+    },
+    {
+        "var_up_childof_component",
+        Traversal_var_up_childof_component
+    },
+    {
+        "var_written_self_up_childof_component",
+        Traversal_var_written_self_up_childof_component
+    },
+    {
+        "var_written_up_childof_component",
+        Traversal_var_written_up_childof_component
+    },
+    {
+        "this_self_up_childof_recycled_parent",
+        Traversal_this_self_up_childof_recycled_parent
+    },
+    {
+        "this_up_childof_recycled_parent",
+        Traversal_this_up_childof_recycled_parent
+    },
+    {
+        "this_written_self_up_childof_recycled_parent",
+        Traversal_this_written_self_up_childof_recycled_parent
+    },
+    {
+        "this_written_up_childof_recycled_parent",
+        Traversal_this_written_up_childof_recycled_parent
+    },
+    {
+        "this_self_up_childof_recycled_parent_component",
+        Traversal_this_self_up_childof_recycled_parent_component
+    },
+    {
+        "this_up_childof_recycled_parent_component",
+        Traversal_this_up_childof_recycled_parent_component
+    },
+    {
+        "this_written_self_up_childof_recycled_parent_component",
+        Traversal_this_written_self_up_childof_recycled_parent_component
+    },
+    {
+        "this_written_up_childof_recycled_parent_component",
+        Traversal_this_written_up_childof_recycled_parent_component
+    },
+    {
+        "this_self_up_childof_pair",
+        Traversal_this_self_up_childof_pair
+    },
+    {
+        "this_up_childof_pair",
+        Traversal_this_up_childof_pair
+    },
+    {
+        "this_written_self_up_childof_pair",
+        Traversal_this_written_self_up_childof_pair
+    },
+    {
+        "this_written_up_childof_pair",
+        Traversal_this_written_up_childof_pair
+    },
+    {
+        "this_self_up_childof_pair_wildcard",
+        Traversal_this_self_up_childof_pair_wildcard
+    },
+    {
+        "this_up_childof_pair_wildcard",
+        Traversal_this_up_childof_pair_wildcard
+    },
+    {
+        "this_written_self_up_childof_pair_wildcard",
+        Traversal_this_written_self_up_childof_pair_wildcard
+    },
+    {
+        "this_written_up_childof_pair_wildcard",
+        Traversal_this_written_up_childof_pair_wildcard
+    },
+    {
+        "this_self_up_childof_pair_tgt_var",
+        Traversal_this_self_up_childof_pair_tgt_var
+    },
+    {
+        "this_written_self_up_childof_pair_tgt_var",
+        Traversal_this_written_self_up_childof_pair_tgt_var
+    },
+    {
+        "this_self_up_childof_pair_rel_var",
+        Traversal_this_self_up_childof_pair_rel_var
+    },
+    {
+        "this_written_self_up_childof_pair_rel_var",
+        Traversal_this_written_self_up_childof_pair_rel_var
+    },
+    {
+        "this_self_up_childof_pair_for_var_written",
+        Traversal_this_self_up_childof_pair_for_var_written
+    },
+    {
+        "this_up_childof_pair_for_var_written",
+        Traversal_this_up_childof_pair_for_var_written
+    },
+    {
+        "this_written_self_up_childof_pair_for_var_written",
+        Traversal_this_written_self_up_childof_pair_for_var_written
+    },
+    {
+        "this_self_up_childof_pair_for_var_written_n_targets",
+        Traversal_this_self_up_childof_pair_for_var_written_n_targets
+    },
+    {
+        "this_written_self_up_childof_pair_for_var_written_n_targets",
+        Traversal_this_written_self_up_childof_pair_for_var_written_n_targets
+    },
+    {
+        "self_up_2_levels",
+        Traversal_self_up_2_levels
+    },
+    {
+        "not_up_disabled",
+        Traversal_not_up_disabled
+    },
+    {
+        "up_2_rel_instances",
+        Traversal_up_2_rel_instances
+    },
+    {
+        "up_2_rel_instances_match_2nd",
+        Traversal_up_2_rel_instances_match_2nd
+    },
+    {
+        "up_only_w_owned",
+        Traversal_up_only_w_owned
+    },
+    {
+        "this_up_trav_unused_rel",
+        Traversal_this_up_trav_unused_rel
+    },
+    {
+        "this_optional_self",
+        Traversal_this_optional_self
+    },
+    {
+        "this_optional_up",
+        Traversal_this_optional_up
+    },
+    {
+        "this_optional_self_up",
+        Traversal_this_optional_self_up
+    },
+    {
+        "this_written_optional_self",
+        Traversal_this_written_optional_self
+    },
+    {
+        "this_written_optional_up",
+        Traversal_this_written_optional_up
+    },
+    {
+        "this_written_optional_self_up",
+        Traversal_this_written_optional_self_up
+    },
+    {
+        "fixed_src_w_up",
+        Traversal_fixed_src_w_up
+    },
+    {
+        "match_empty_table_up",
+        Traversal_match_empty_table_up
+    },
+    {
+        "match_empty_table_up_written",
+        Traversal_match_empty_table_up_written
+    },
+    {
+        "match_empty_table_up_implicit_isa",
+        Traversal_match_empty_table_up_implicit_isa
+    },
+    {
+        "match_empty_table_up_written_implicit_isa",
+        Traversal_match_empty_table_up_written_implicit_isa
+    },
+    {
+        "match_empty_table_up_isa",
+        Traversal_match_empty_table_up_isa
+    },
+    {
+        "match_empty_table_up_written_isa",
+        Traversal_match_empty_table_up_written_isa
+    }
+};
+
+bake_test_case Cascade_testcases[] = {
+    {
+        "this_self_cascade_childof_uncached",
+        Cascade_this_self_cascade_childof_uncached
+    },
+    {
+        "this_cascade_childof_uncached",
+        Cascade_this_cascade_childof_uncached
+    },
+    {
+        "this_written_self_cascade_childof_uncached",
+        Cascade_this_written_self_cascade_childof_uncached
+    },
+    {
+        "this_written_cascade_childof_uncached",
+        Cascade_this_written_cascade_childof_uncached
+    },
+    {
+        "this_self_cascade_childof_w_parent_flag_uncached",
+        Cascade_this_self_cascade_childof_w_parent_flag_uncached
+    },
+    {
+        "this_cascade_childof_w_parent_flag_uncached",
+        Cascade_this_cascade_childof_w_parent_flag_uncached
+    },
+    {
+        "this_written_self_cascade_childof_w_parent_flag_uncached",
+        Cascade_this_written_self_cascade_childof_w_parent_flag_uncached
+    },
+    {
+        "this_written_cascade_childof_w_parent_flag_uncached",
+        Cascade_this_written_cascade_childof_w_parent_flag_uncached
+    },
+    {
+        "parent_cascade",
+        Cascade_parent_cascade
+    },
+    {
+        "existing_custom_rel_cascade",
+        Cascade_existing_custom_rel_cascade
+    },
+    {
+        "new_custom_rel_cascade",
+        Cascade_new_custom_rel_cascade
+    },
+    {
+        "cascade_w_2_depths",
+        Cascade_cascade_w_2_depths
+    },
+    {
+        "cascade_w_3_depths",
+        Cascade_cascade_w_3_depths
+    },
+    {
+        "cascade_w_2_depths_desc",
+        Cascade_cascade_w_2_depths_desc
+    },
+    {
+        "cascade_w_3_depths_desc",
+        Cascade_cascade_w_3_depths_desc
+    },
+    {
+        "existing_isa_cascade",
+        Cascade_existing_isa_cascade
+    },
+    {
+        "new_isa_cascade",
+        Cascade_new_isa_cascade
+    },
+    {
+        "childof_cascade",
+        Cascade_childof_cascade
+    },
+    {
+        "cascade_rematch_2_lvls",
+        Cascade_cascade_rematch_2_lvls
+    },
+    {
+        "cascade_rematch_2_lvls_2_relations",
+        Cascade_cascade_rematch_2_lvls_2_relations
+    },
+    {
+        "cascade_topological",
+        Cascade_cascade_topological
+    },
+    {
+        "cascade_desc_rematch_2_lvls",
+        Cascade_cascade_desc_rematch_2_lvls
+    },
+    {
+        "cascade_desc_rematch_2_lvls_2_relations",
+        Cascade_cascade_desc_rematch_2_lvls_2_relations
+    },
+    {
+        "cascade_desc_topological",
+        Cascade_cascade_desc_topological
+    },
+    {
+        "cascade_after_recycled_parent_change",
+        Cascade_cascade_after_recycled_parent_change
+    }
+};
+
+bake_test_case Cached_testcases[] = {
+    {
+        "simple_query_existing_table",
+        Cached_simple_query_existing_table
+    },
+    {
+        "simple_query_2_existing_tables",
+        Cached_simple_query_2_existing_tables
+    },
+    {
+        "simple_query_new_table",
+        Cached_simple_query_new_table
+    },
+    {
+        "simple_query_2_new_tables",
+        Cached_simple_query_2_new_tables
+    },
+    {
+        "simple_query_existing_and_new_table",
+        Cached_simple_query_existing_and_new_table
+    },
+    {
+        "wildcard_query_existing_table",
+        Cached_wildcard_query_existing_table
+    },
+    {
+        "wildcard_query_new_table",
+        Cached_wildcard_query_new_table
+    },
+    {
+        "wildcard_query_existing_table_2_results_p_table",
+        Cached_wildcard_query_existing_table_2_results_p_table
+    },
+    {
+        "wildcard_query_new_table_2_results_p_table",
+        Cached_wildcard_query_new_table_2_results_p_table
+    },
+    {
+        "wildcard_query_2nd_term",
+        Cached_wildcard_query_2nd_term
+    },
+    {
+        "wildcard_query_2nd_term_self",
+        Cached_wildcard_query_2nd_term_self
+    },
+    {
+        "simple_query_existing_empty_table",
+        Cached_simple_query_existing_empty_table
+    },
+    {
+        "simple_query_existing_empty_type",
+        Cached_simple_query_existing_empty_type
+    },
+    {
+        "simple_query_new_empty_table",
+        Cached_simple_query_new_empty_table
+    },
+    {
+        "component_query_existing_table",
+        Cached_component_query_existing_table
+    },
+    {
+        "component_query_new_table",
+        Cached_component_query_new_table
+    },
+    {
+        "component_query_existing_empty_table",
+        Cached_component_query_existing_empty_table
+    },
+    {
+        "2_component_query_existing_empty_table",
+        Cached_2_component_query_existing_empty_table
+    },
+    {
+        "2_component_query_existing_empty_type",
+        Cached_2_component_query_existing_empty_type
+    },
+    {
+        "only_optional",
+        Cached_only_optional
+    },
+    {
+        "only_optional_new_empty_table",
+        Cached_only_optional_new_empty_table
+    },
+    {
+        "only_optional_new_empty_non_empty_table",
+        Cached_only_optional_new_empty_non_empty_table
+    },
+    {
+        "only_optional_new_unset_tables",
+        Cached_only_optional_new_unset_tables
+    },
+    {
+        "singleton_w_optional_new_empty_table",
+        Cached_singleton_w_optional_new_empty_table
+    },
+    {
+        "singleton_w_optional_new_empty_non_empty_table",
+        Cached_singleton_w_optional_new_empty_non_empty_table
+    },
+    {
+        "singleton_w_optional_new_unset_tables",
+        Cached_singleton_w_optional_new_unset_tables
+    },
+    {
+        "query_w_from_entity_match_after",
+        Cached_query_w_from_entity_match_after
+    },
+    {
+        "query_w_from_singleton_match_after",
+        Cached_query_w_from_singleton_match_after
+    },
+    {
+        "query_rematch_optional_after_add",
+        Cached_query_rematch_optional_after_add
+    },
+    {
+        "get_owned_tag",
+        Cached_get_owned_tag
+    },
+    {
+        "get_shared_tag",
+        Cached_get_shared_tag
+    },
+    {
+        "explicit_delete",
+        Cached_explicit_delete
+    },
+    {
+        "get_column_size",
+        Cached_get_column_size
+    },
+    {
+        "stresstest_query_free",
+        Cached_stresstest_query_free
+    },
+    {
+        "query_optional_tag",
+        Cached_query_optional_tag
+    },
+    {
+        "query_optional_shared_tag",
+        Cached_query_optional_shared_tag
+    },
+    {
+        "query_iter_10_tags",
+        Cached_query_iter_10_tags
+    },
+    {
+        "query_iter_10_components",
+        Cached_query_iter_10_components
+    },
+    {
+        "iter_type_set",
+        Cached_iter_type_set
+    },
+    {
+        "filter_term",
+        Cached_filter_term
+    },
+    {
+        "2_terms_1_filter",
+        Cached_2_terms_1_filter
+    },
+    {
+        "3_terms_2_filter",
+        Cached_3_terms_2_filter
+    },
+    {
+        "no_instancing_w_singleton",
+        Cached_no_instancing_w_singleton
+    },
+    {
+        "add_singleton_after_query",
+        Cached_add_singleton_after_query
+    },
+    {
+        "query_w_component_from_parent_from_non_this",
+        Cached_query_w_component_from_parent_from_non_this
+    },
+    {
+        "create_query_while_pending",
+        Cached_create_query_while_pending
+    },
+    {
+        "empty_query",
+        Cached_empty_query
+    },
+    {
+        "not_pair_relation_wildcard",
+        Cached_not_pair_relation_wildcard
+    },
+    {
+        "not_pair_object_wildcard",
+        Cached_not_pair_object_wildcard
+    },
+    {
+        "two_pair_wildcards_one_not",
+        Cached_two_pair_wildcards_one_not
+    },
+    {
+        "two_pair_wildcards_one_not_any",
+        Cached_two_pair_wildcards_one_not_any
+    },
+    {
+        "implicit_existing_isa_superset",
+        Cached_implicit_existing_isa_superset
+    },
+    {
+        "implicit_new_isa_superset",
+        Cached_implicit_new_isa_superset
+    },
+    {
+        "isa_superset",
+        Cached_isa_superset
+    },
+    {
+        "isa_superset_2_lvls",
+        Cached_isa_superset_2_lvls
+    },
+    {
+        "isa_superset_3_lvls",
+        Cached_isa_superset_3_lvls
+    },
+    {
+        "isa_superset_2_lvls_owned",
+        Cached_isa_superset_2_lvls_owned
+    },
+    {
+        "isa_superset_3_lvls_owned",
+        Cached_isa_superset_3_lvls_owned
+    },
+    {
+        "isa_superset_owned_empty_table_after_match",
+        Cached_isa_superset_owned_empty_table_after_match
+    },
+    {
+        "isa_self_superset",
+        Cached_isa_self_superset
+    },
+    {
+        "childof_superset",
+        Cached_childof_superset
+    },
+    {
+        "superset_2_targets",
+        Cached_superset_2_targets
+    },
+    {
+        "superset_2_relations",
+        Cached_superset_2_relations
+    },
+    {
+        "superset_2_relations_instanced",
+        Cached_superset_2_relations_instanced
+    },
+    {
+        "superset_2_relations_w_component",
+        Cached_superset_2_relations_w_component
+    },
+    {
+        "superset_2_relations_instanced_w_component",
+        Cached_superset_2_relations_instanced_w_component
+    },
+    {
+        "parent",
+        Cached_parent
+    },
+    {
+        "isa_rematch",
+        Cached_isa_rematch
+    },
+    {
+        "childof_rematch",
+        Cached_childof_rematch
+    },
+    {
+        "isa_unmatch",
+        Cached_isa_unmatch
+    },
+    {
+        "childof_unmatch",
+        Cached_childof_unmatch
+    },
+    {
+        "isa_rematch_2_lvls",
+        Cached_isa_rematch_2_lvls
+    },
+    {
+        "childof_rematch_2_lvls",
+        Cached_childof_rematch_2_lvls
+    },
+    {
+        "childof_rematch_from_isa",
+        Cached_childof_rematch_from_isa
+    },
+    {
+        "rematch_optional_ref",
+        Cached_rematch_optional_ref
+    },
+    {
+        "rematch_optional_ref_w_2_refs",
+        Cached_rematch_optional_ref_w_2_refs
+    },
+    {
+        "rematch_optional_ref_tag_w_ref_component",
+        Cached_rematch_optional_ref_tag_w_ref_component
+    },
+    {
+        "rematch_after_add_to_recycled_parent",
+        Cached_rematch_after_add_to_recycled_parent
+    },
+    {
+        "match_query_expr_from_scope",
+        Cached_match_query_expr_from_scope
+    },
+    {
+        "query_long_or_w_ref",
+        Cached_query_long_or_w_ref
+    },
+    {
+        "query_w_pair_id_and_subj",
+        Cached_query_w_pair_id_and_subj
+    },
+    {
+        "rematch_after_delete_inherited_tag",
+        Cached_rematch_after_delete_inherited_tag
+    },
+    {
+        "rematch_after_delete_rel_of_inherited_pair",
+        Cached_rematch_after_delete_rel_of_inherited_pair
+    },
+    {
+        "rematch_after_delete_obj_of_inherited_pair",
+        Cached_rematch_after_delete_obj_of_inherited_pair
+    },
+    {
+        "rematch_empty_table_w_superset",
+        Cached_rematch_empty_table_w_superset
+    },
+    {
+        "2_self_up_terms_new_tables",
+        Cached_2_self_up_terms_new_tables
+    },
+    {
+        "this_self_up_childof_pair_new_tables",
+        Cached_this_self_up_childof_pair_new_tables
+    }
+};
+
+bake_test_case ChangeDetection_testcases[] = {
+    {
+        "query_changed_after_new",
+        ChangeDetection_query_changed_after_new
+    },
+    {
+        "query_changed_after_delete",
+        ChangeDetection_query_changed_after_delete
+    },
+    {
+        "query_changed_after_add",
+        ChangeDetection_query_changed_after_add
+    },
+    {
+        "query_changed_after_remove",
+        ChangeDetection_query_changed_after_remove
+    },
+    {
+        "query_changed_after_set",
+        ChangeDetection_query_changed_after_set
+    },
+    {
+        "query_change_after_modified",
+        ChangeDetection_query_change_after_modified
+    },
+    {
+        "query_change_after_out_system",
+        ChangeDetection_query_change_after_out_system
+    },
+    {
+        "query_change_after_in_system",
+        ChangeDetection_query_change_after_in_system
+    },
+    {
+        "query_change_after_modified_out_term",
+        ChangeDetection_query_change_after_modified_out_term
+    },
+    {
+        "query_change_check_iter",
+        ChangeDetection_query_change_check_iter
+    },
+    {
+        "query_change_check_iter_after_skip_read",
+        ChangeDetection_query_change_check_iter_after_skip_read
+    },
+    {
+        "query_change_check_iter_after_skip_write",
+        ChangeDetection_query_change_check_iter_after_skip_write
+    },
+    {
+        "query_change_parent_term",
+        ChangeDetection_query_change_parent_term
+    },
+    {
+        "query_change_prefab_term",
+        ChangeDetection_query_change_prefab_term
+    },
+    {
+        "query_change_parent_term_w_tag",
+        ChangeDetection_query_change_parent_term_w_tag
+    },
+    {
+        "query_change_prefab_term_w_tag",
+        ChangeDetection_query_change_prefab_term_w_tag
+    },
+    {
+        "query_change_skip_non_instanced",
+        ChangeDetection_query_change_skip_non_instanced
+    },
+    {
+        "query_changed_w_or",
+        ChangeDetection_query_changed_w_or
+    },
+    {
+        "query_changed_or",
+        ChangeDetection_query_changed_or
+    },
+    {
+        "query_changed_w_singleton",
+        ChangeDetection_query_changed_w_singleton
+    },
+    {
+        "query_changed_w_only_singleton",
+        ChangeDetection_query_changed_w_only_singleton
+    },
+    {
+        "query_changed_w_only_singleton_after_set",
+        ChangeDetection_query_changed_w_only_singleton_after_set
+    },
+    {
+        "query_changed_w_only_singleton_after_out_term",
+        ChangeDetection_query_changed_w_only_singleton_after_out_term
+    },
+    {
+        "query_changed_w_only_singleton_after_singleton_out_term",
+        ChangeDetection_query_changed_w_only_singleton_after_singleton_out_term
+    },
+    {
+        "query_changed_w_only_parent",
+        ChangeDetection_query_changed_w_only_parent
+    },
+    {
+        "query_changed_w_only_parent_after_set",
+        ChangeDetection_query_changed_w_only_parent_after_set
+    },
+    {
+        "query_changed_w_only_parent_after_out_term",
+        ChangeDetection_query_changed_w_only_parent_after_out_term
+    },
+    {
+        "query_changed_w_only_parent_after_parent_out_term",
+        ChangeDetection_query_changed_w_only_parent_after_parent_out_term
+    },
+    {
+        "query_changed_tag",
+        ChangeDetection_query_changed_tag
+    },
+    {
+        "query_changed_no_source",
+        ChangeDetection_query_changed_no_source
+    },
+    {
+        "query_changed_no_source_component",
+        ChangeDetection_query_changed_no_source_component
+    },
+    {
+        "query_changed_w_not_out",
+        ChangeDetection_query_changed_w_not_out
+    }
+};
+
+bake_test_case GroupBy_testcases[] = {
+    {
+        "group_by",
+        GroupBy_group_by
+    },
+    {
+        "group_by_w_ctx",
+        GroupBy_group_by_w_ctx
+    },
+    {
+        "group_by_w_sort_reverse_group_creation",
+        GroupBy_group_by_w_sort_reverse_group_creation
+    },
+    {
+        "group_by_iter_one",
+        GroupBy_group_by_iter_one
+    },
+    {
+        "group_by_iter_one_all_groups",
+        GroupBy_group_by_iter_one_all_groups
+    },
+    {
+        "group_by_iter_one_empty",
+        GroupBy_group_by_iter_one_empty
+    },
+    {
+        "group_by_iter_one_empty_query",
+        GroupBy_group_by_iter_one_empty_query
+    },
+    {
+        "group_by_iter_one_empty_table",
+        GroupBy_group_by_iter_one_empty_table
+    },
+    {
+        "group_by_w_deleted_group_id",
+        GroupBy_group_by_w_deleted_group_id
+    },
+    {
+        "group_by_callbacks",
+        GroupBy_group_by_callbacks
+    },
+    {
+        "group_by_default_action",
+        GroupBy_group_by_default_action
+    },
+    {
+        "group_table_count",
+        GroupBy_group_table_count
+    }
+};
+
+bake_test_case MemberTarget_testcases[] = {
+    {
+        "this_member_eq_1",
+        MemberTarget_this_member_eq_1
+    },
+    {
+        "this_member_eq_2",
+        MemberTarget_this_member_eq_2
+    },
+    {
+        "this_member_eq_no_matches",
+        MemberTarget_this_member_eq_no_matches
+    },
+    {
+        "this_member_eq_all_matches",
+        MemberTarget_this_member_eq_all_matches
+    },
+    {
+        "this_member_wildcard",
+        MemberTarget_this_member_wildcard
+    },
+    {
+        "this_member_var",
+        MemberTarget_this_member_var
+    },
+    {
+        "this_member_var_written",
+        MemberTarget_this_member_var_written
+    },
+    {
+        "this_member_var_read",
+        MemberTarget_this_member_var_read
+    },
+    {
+        "this_member_eq_1_2nd_member",
+        MemberTarget_this_member_eq_1_2nd_member
+    },
+    {
+        "this_member_eq_2_2nd_member",
+        MemberTarget_this_member_eq_2_2nd_member
+    },
+    {
+        "this_member_var_same_1",
+        MemberTarget_this_member_var_same_1
+    },
+    {
+        "this_member_var_same_2",
+        MemberTarget_this_member_var_same_2
+    },
+    {
+        "this_written_member_eq_1",
+        MemberTarget_this_written_member_eq_1
+    },
+    {
+        "this_written_member_eq_2",
+        MemberTarget_this_written_member_eq_2
+    },
+    {
+        "this_written_member_wildcard",
+        MemberTarget_this_written_member_wildcard
+    },
+    {
+        "this_written_member_var",
+        MemberTarget_this_written_member_var
+    },
+    {
+        "this_member_neq_1",
+        MemberTarget_this_member_neq_1
+    },
+    {
+        "this_member_neq_2",
+        MemberTarget_this_member_neq_2
+    },
+    {
+        "this_member_neq_no_matches",
+        MemberTarget_this_member_neq_no_matches
+    },
+    {
+        "this_member_neq_all_matches",
+        MemberTarget_this_member_neq_all_matches
+    },
+    {
+        "this_member_neq_wildcard",
+        MemberTarget_this_member_neq_wildcard
+    },
+    {
+        "this_written_member_neq_1",
+        MemberTarget_this_written_member_neq_1
+    },
+    {
+        "this_written_member_neq_2",
+        MemberTarget_this_written_member_neq_2
+    },
+    {
+        "this_written_member_neq_no_matches",
+        MemberTarget_this_written_member_neq_no_matches
+    },
+    {
+        "this_written_member_neq_all_matches",
+        MemberTarget_this_written_member_neq_all_matches
+    },
+    {
+        "this_written_member_neq_wildcard",
+        MemberTarget_this_written_member_neq_wildcard
+    },
+    {
+        "this_member_eq_optional",
+        MemberTarget_this_member_eq_optional
+    },
+    {
+        "this_member_eq_optional_wildcard",
+        MemberTarget_this_member_eq_optional_wildcard
+    },
+    {
+        "this_written_member_eq_optional",
+        MemberTarget_this_written_member_eq_optional
+    },
+    {
+        "this_written_member_eq_optional_wildcard",
+        MemberTarget_this_written_member_eq_optional_wildcard
+    },
+    {
+        "this_member_eq_w_other_tag",
+        MemberTarget_this_member_eq_w_other_tag
+    },
+    {
+        "this_member_eq_w_other_component",
+        MemberTarget_this_member_eq_w_other_component
+    },
+    {
+        "this_written_member_eq_w_other_tag",
+        MemberTarget_this_written_member_eq_w_other_tag
+    },
+    {
+        "this_written_member_eq_w_other_component",
+        MemberTarget_this_written_member_eq_w_other_component
+    },
+    {
+        "this_2_or",
+        MemberTarget_this_2_or
+    },
+    {
+        "this_3_or",
+        MemberTarget_this_3_or
+    },
+    {
+        "this_written_2_or",
+        MemberTarget_this_written_2_or
+    },
+    {
+        "this_written_3_or",
+        MemberTarget_this_written_3_or
+    },
+    {
+        "var_2_or",
+        MemberTarget_var_2_or
+    },
+    {
+        "var_3_or",
+        MemberTarget_var_3_or
+    },
+    {
+        "this_2_or_w_2_members",
+        MemberTarget_this_2_or_w_2_members
+    },
+    {
+        "this_2_or_w_2_types",
+        MemberTarget_this_2_or_w_2_types
+    },
+    {
+        "this_written_2_or_w_2_members",
+        MemberTarget_this_written_2_or_w_2_members
+    },
+    {
+        "this_written_2_or_w_2_types",
+        MemberTarget_this_written_2_or_w_2_types
+    },
+    {
+        "this_2_or_2_types_wildcard",
+        MemberTarget_this_2_or_2_types_wildcard
+    },
+    {
+        "this_2_or_2_types_dep_var",
+        MemberTarget_this_2_or_2_types_dep_var
+    },
+    {
+        "var_written_2_or",
+        MemberTarget_var_written_2_or
+    },
+    {
+        "var_written_3_or",
+        MemberTarget_var_written_3_or
+    },
+    {
+        "var_member_eq",
+        MemberTarget_var_member_eq
+    },
+    {
+        "var_member_eq_no_matches",
+        MemberTarget_var_member_eq_no_matches
+    },
+    {
+        "var_member_eq_all_matches",
+        MemberTarget_var_member_eq_all_matches
+    },
+    {
+        "var_member_wildcard",
+        MemberTarget_var_member_wildcard
+    },
+    {
+        "var_member_neq",
+        MemberTarget_var_member_neq
+    },
+    {
+        "var_member_neq_no_matches",
+        MemberTarget_var_member_neq_no_matches
+    },
+    {
+        "var_member_neq_all_matches",
+        MemberTarget_var_member_neq_all_matches
+    },
+    {
+        "var_written_member_eq",
+        MemberTarget_var_written_member_eq
+    },
+    {
+        "var_written_member_eq_no_matches",
+        MemberTarget_var_written_member_eq_no_matches
+    },
+    {
+        "var_written_member_eq_all_matches",
+        MemberTarget_var_written_member_eq_all_matches
+    },
+    {
+        "var_written_member_wildcard",
+        MemberTarget_var_written_member_wildcard
+    },
+    {
+        "var_written_member_neq",
+        MemberTarget_var_written_member_neq
+    },
+    {
+        "var_written_member_neq_no_matches",
+        MemberTarget_var_written_member_neq_no_matches
+    },
+    {
+        "var_written_member_neq_all_matches",
+        MemberTarget_var_written_member_neq_all_matches
+    }
+};
+
+bake_test_case Toggle_testcases[] = {
+    {
+        "fixed_src_1_tag_toggle",
+        Toggle_fixed_src_1_tag_toggle
+    },
+    {
+        "fixed_src_1_component_toggle",
+        Toggle_fixed_src_1_component_toggle
+    },
+    {
+        "fixed_src_2_tag_toggle",
+        Toggle_fixed_src_2_tag_toggle
+    },
+    {
+        "fixed_src_2_component_toggle",
+        Toggle_fixed_src_2_component_toggle
+    },
+    {
+        "fixed_2_src_w_toggle",
+        Toggle_fixed_2_src_w_toggle
+    },
+    {
+        "this_w_fixed_src_w_toggle",
+        Toggle_this_w_fixed_src_w_toggle
+    },
+    {
+        "fixed_src_w_this_w_toggle",
+        Toggle_fixed_src_w_this_w_toggle
+    },
+    {
+        "this_from_nothing",
+        Toggle_this_from_nothing
+    },
+    {
+        "this",
+        Toggle_this
+    },
+    {
+        "this_skip_initial",
+        Toggle_this_skip_initial
+    },
+    {
+        "this_pair",
+        Toggle_this_pair
+    },
+    {
+        "this_pair_skip_initial",
+        Toggle_this_pair_skip_initial
+    },
+    {
+        "this_tag",
+        Toggle_this_tag
+    },
+    {
+        "this_tag_pair",
+        Toggle_this_tag_pair
+    },
+    {
+        "this_tag_pair_wildcard",
+        Toggle_this_tag_pair_wildcard
+    },
+    {
+        "this_toggle_shared_self_up",
+        Toggle_this_toggle_shared_self_up
+    },
+    {
+        "this_toggle_shared_up",
+        Toggle_this_toggle_shared_up
+    },
+    {
+        "this_toggle_shared_self_up_w_self",
+        Toggle_this_toggle_shared_self_up_w_self
+    },
+    {
+        "this_toggle_shared_up_w_self",
+        Toggle_this_toggle_shared_up_w_self
+    },
+    {
+        "this_toggle_shared_self_up_w_self_reverse",
+        Toggle_this_toggle_shared_self_up_w_self_reverse
+    },
+    {
+        "this_toggle_shared_up_w_self_reverse",
+        Toggle_this_toggle_shared_up_w_self_reverse
+    },
+    {
+        "this_toggle_shared_self_up_w_self_toggle",
+        Toggle_this_toggle_shared_self_up_w_self_toggle
+    },
+    {
+        "this_toggle_shared_up_w_self_toggle",
+        Toggle_this_toggle_shared_up_w_self_toggle
+    },
+    {
+        "this_toggle_shared_self_up_w_self_toggle_reverse",
+        Toggle_this_toggle_shared_self_up_w_self_toggle_reverse
+    },
+    {
+        "this_toggle_shared_up_w_self_toggle_reverse",
+        Toggle_this_toggle_shared_up_w_self_toggle_reverse
+    },
+    {
+        "this_toggle_not_shared_self_up",
+        Toggle_this_toggle_not_shared_self_up
+    },
+    {
+        "this_toggle_not_shared_up",
+        Toggle_this_toggle_not_shared_up
+    },
+    {
+        "this_toggle_optional_shared_self_up",
+        Toggle_this_toggle_optional_shared_self_up
+    },
+    {
+        "this_toggle_optional_shared_up",
+        Toggle_this_toggle_optional_shared_up
+    },
+    {
+        "this_64_mod_1",
+        Toggle_this_64_mod_1
+    },
+    {
+        "this_64_mod_2",
+        Toggle_this_64_mod_2
+    },
+    {
+        "this_64_mod_3",
+        Toggle_this_64_mod_3
+    },
+    {
+        "this_64_mod_7",
+        Toggle_this_64_mod_7
+    },
+    {
+        "this_64_mod_8",
+        Toggle_this_64_mod_8
+    },
+    {
+        "this_64_mod_10",
+        Toggle_this_64_mod_10
+    },
+    {
+        "this_64_mod_64",
+        Toggle_this_64_mod_64
+    },
+    {
+        "this_64_mod_256",
+        Toggle_this_64_mod_256
+    },
+    {
+        "this_64_mod_1024",
+        Toggle_this_64_mod_1024
+    },
+    {
+        "this_100_mod_1",
+        Toggle_this_100_mod_1
+    },
+    {
+        "this_100_mod_2",
+        Toggle_this_100_mod_2
+    },
+    {
+        "this_100_mod_3",
+        Toggle_this_100_mod_3
+    },
+    {
+        "this_100_mod_7",
+        Toggle_this_100_mod_7
+    },
+    {
+        "this_100_mod_8",
+        Toggle_this_100_mod_8
+    },
+    {
+        "this_100_mod_10",
+        Toggle_this_100_mod_10
+    },
+    {
+        "this_100_mod_64",
+        Toggle_this_100_mod_64
+    },
+    {
+        "this_100_mod_256",
+        Toggle_this_100_mod_256
+    },
+    {
+        "this_100_mod_1024",
+        Toggle_this_100_mod_1024
+    },
+    {
+        "this_128_mod_1",
+        Toggle_this_128_mod_1
+    },
+    {
+        "this_128_mod_2",
+        Toggle_this_128_mod_2
+    },
+    {
+        "this_128_mod_3",
+        Toggle_this_128_mod_3
+    },
+    {
+        "this_128_mod_7",
+        Toggle_this_128_mod_7
+    },
+    {
+        "this_128_mod_8",
+        Toggle_this_128_mod_8
+    },
+    {
+        "this_128_mod_10",
+        Toggle_this_128_mod_10
+    },
+    {
+        "this_128_mod_64",
+        Toggle_this_128_mod_64
+    },
+    {
+        "this_128_mod_256",
+        Toggle_this_128_mod_256
+    },
+    {
+        "this_128_mod_1024",
+        Toggle_this_128_mod_1024
+    },
+    {
+        "this_200_mod_1",
+        Toggle_this_200_mod_1
+    },
+    {
+        "this_200_mod_2",
+        Toggle_this_200_mod_2
+    },
+    {
+        "this_200_mod_3",
+        Toggle_this_200_mod_3
+    },
+    {
+        "this_200_mod_7",
+        Toggle_this_200_mod_7
+    },
+    {
+        "this_200_mod_8",
+        Toggle_this_200_mod_8
+    },
+    {
+        "this_200_mod_10",
+        Toggle_this_200_mod_10
+    },
+    {
+        "this_200_mod_64",
+        Toggle_this_200_mod_64
+    },
+    {
+        "this_200_mod_256",
+        Toggle_this_200_mod_256
+    },
+    {
+        "this_200_mod_1024",
+        Toggle_this_200_mod_1024
+    },
+    {
+        "this_1024_mod_1",
+        Toggle_this_1024_mod_1
+    },
+    {
+        "this_1024_mod_2",
+        Toggle_this_1024_mod_2
+    },
+    {
+        "this_1024_mod_3",
+        Toggle_this_1024_mod_3
+    },
+    {
+        "this_1024_mod_7",
+        Toggle_this_1024_mod_7
+    },
+    {
+        "this_1024_mod_8",
+        Toggle_this_1024_mod_8
+    },
+    {
+        "this_1024_mod_10",
+        Toggle_this_1024_mod_10
+    },
+    {
+        "this_1024_mod_64",
+        Toggle_this_1024_mod_64
+    },
+    {
+        "this_1024_mod_256",
+        Toggle_this_1024_mod_256
+    },
+    {
+        "this_1024_mod_1024",
+        Toggle_this_1024_mod_1024
+    },
+    {
+        "this_enabled_64_mod_1",
+        Toggle_this_enabled_64_mod_1
+    },
+    {
+        "this_enabled_64_mod_2",
+        Toggle_this_enabled_64_mod_2
+    },
+    {
+        "this_enabled_64_mod_3",
+        Toggle_this_enabled_64_mod_3
+    },
+    {
+        "this_enabled_64_mod_7",
+        Toggle_this_enabled_64_mod_7
+    },
+    {
+        "this_enabled_64_mod_8",
+        Toggle_this_enabled_64_mod_8
+    },
+    {
+        "this_enabled_64_mod_10",
+        Toggle_this_enabled_64_mod_10
+    },
+    {
+        "this_enabled_64_mod_64",
+        Toggle_this_enabled_64_mod_64
+    },
+    {
+        "this_enabled_64_mod_256",
+        Toggle_this_enabled_64_mod_256
+    },
+    {
+        "this_enabled_64_mod_1024",
+        Toggle_this_enabled_64_mod_1024
+    },
+    {
+        "this_enabled_100_mod_1",
+        Toggle_this_enabled_100_mod_1
+    },
+    {
+        "this_enabled_100_mod_2",
+        Toggle_this_enabled_100_mod_2
+    },
+    {
+        "this_enabled_100_mod_3",
+        Toggle_this_enabled_100_mod_3
+    },
+    {
+        "this_enabled_100_mod_7",
+        Toggle_this_enabled_100_mod_7
+    },
+    {
+        "this_enabled_100_mod_8",
+        Toggle_this_enabled_100_mod_8
+    },
+    {
+        "this_enabled_100_mod_10",
+        Toggle_this_enabled_100_mod_10
+    },
+    {
+        "this_enabled_100_mod_64",
+        Toggle_this_enabled_100_mod_64
+    },
+    {
+        "this_enabled_100_mod_256",
+        Toggle_this_enabled_100_mod_256
+    },
+    {
+        "this_enabled_100_mod_1024",
+        Toggle_this_enabled_100_mod_1024
+    },
+    {
+        "this_enabled_128_mod_1",
+        Toggle_this_enabled_128_mod_1
+    },
+    {
+        "this_enabled_128_mod_2",
+        Toggle_this_enabled_128_mod_2
+    },
+    {
+        "this_enabled_128_mod_3",
+        Toggle_this_enabled_128_mod_3
+    },
+    {
+        "this_enabled_128_mod_7",
+        Toggle_this_enabled_128_mod_7
+    },
+    {
+        "this_enabled_128_mod_8",
+        Toggle_this_enabled_128_mod_8
+    },
+    {
+        "this_enabled_128_mod_10",
+        Toggle_this_enabled_128_mod_10
+    },
+    {
+        "this_enabled_128_mod_64",
+        Toggle_this_enabled_128_mod_64
+    },
+    {
+        "this_enabled_128_mod_256",
+        Toggle_this_enabled_128_mod_256
+    },
+    {
+        "this_enabled_128_mod_1024",
+        Toggle_this_enabled_128_mod_1024
+    },
+    {
+        "this_enabled_200_mod_1",
+        Toggle_this_enabled_200_mod_1
+    },
+    {
+        "this_enabled_200_mod_2",
+        Toggle_this_enabled_200_mod_2
+    },
+    {
+        "this_enabled_200_mod_3",
+        Toggle_this_enabled_200_mod_3
+    },
+    {
+        "this_enabled_200_mod_7",
+        Toggle_this_enabled_200_mod_7
+    },
+    {
+        "this_enabled_200_mod_8",
+        Toggle_this_enabled_200_mod_8
+    },
+    {
+        "this_enabled_200_mod_10",
+        Toggle_this_enabled_200_mod_10
+    },
+    {
+        "this_enabled_200_mod_64",
+        Toggle_this_enabled_200_mod_64
+    },
+    {
+        "this_enabled_200_mod_256",
+        Toggle_this_enabled_200_mod_256
+    },
+    {
+        "this_enabled_200_mod_1024",
+        Toggle_this_enabled_200_mod_1024
+    },
+    {
+        "this_enabled_1024_mod_1",
+        Toggle_this_enabled_1024_mod_1
+    },
+    {
+        "this_enabled_1024_mod_2",
+        Toggle_this_enabled_1024_mod_2
+    },
+    {
+        "this_enabled_1024_mod_3",
+        Toggle_this_enabled_1024_mod_3
+    },
+    {
+        "this_enabled_1024_mod_7",
+        Toggle_this_enabled_1024_mod_7
+    },
+    {
+        "this_enabled_1024_mod_8",
+        Toggle_this_enabled_1024_mod_8
+    },
+    {
+        "this_enabled_1024_mod_10",
+        Toggle_this_enabled_1024_mod_10
+    },
+    {
+        "this_enabled_1024_mod_64",
+        Toggle_this_enabled_1024_mod_64
+    },
+    {
+        "this_enabled_1024_mod_256",
+        Toggle_this_enabled_1024_mod_256
+    },
+    {
+        "this_enabled_1024_mod_1024",
+        Toggle_this_enabled_1024_mod_1024
+    },
+    {
+        "this_mod_2_2_bitsets",
+        Toggle_this_mod_2_2_bitsets
+    },
+    {
+        "this_mod_8_2_bitsets",
+        Toggle_this_mod_8_2_bitsets
+    },
+    {
+        "this_mod_64_2_bitsets",
+        Toggle_this_mod_64_2_bitsets
+    },
+    {
+        "this_mod_256_2_bitsets",
+        Toggle_this_mod_256_2_bitsets
+    },
+    {
+        "this_mod_1024_2_bitsets",
+        Toggle_this_mod_1024_2_bitsets
+    },
+    {
+        "this_randomized_2_bitsets",
+        Toggle_this_randomized_2_bitsets
+    },
+    {
+        "this_randomized_3_bitsets",
+        Toggle_this_randomized_3_bitsets
+    },
+    {
+        "this_randomized_4_bitsets",
+        Toggle_this_randomized_4_bitsets
+    },
+    {
+        "this_w_other_tag",
+        Toggle_this_w_other_tag
+    },
+    {
+        "this_w_other_component",
+        Toggle_this_w_other_component
+    },
+    {
+        "this_not",
+        Toggle_this_not
+    },
+    {
+        "this_written_not_1024_mod_2",
+        Toggle_this_written_not_1024_mod_2
+    },
+    {
+        "this_written_not_1024_mod_3",
+        Toggle_this_written_not_1024_mod_3
+    },
+    {
+        "this_written_not_1024_mod_7",
+        Toggle_this_written_not_1024_mod_7
+    },
+    {
+        "this_written_not_1024_mod_8",
+        Toggle_this_written_not_1024_mod_8
+    },
+    {
+        "this_written_not_1024_mod_10",
+        Toggle_this_written_not_1024_mod_10
+    },
+    {
+        "this_written_not_1024_mod_64",
+        Toggle_this_written_not_1024_mod_64
+    },
+    {
+        "this_written_not_1024_mod_256",
+        Toggle_this_written_not_1024_mod_256
+    },
+    {
+        "this_written_not_1024_mod_1024",
+        Toggle_this_written_not_1024_mod_1024
+    },
+    {
+        "this_optional",
+        Toggle_this_optional
+    },
+    {
+        "this_written_optional_1024_mod_2",
+        Toggle_this_written_optional_1024_mod_2
+    },
+    {
+        "this_written_optional_1024_mod_3",
+        Toggle_this_written_optional_1024_mod_3
+    },
+    {
+        "this_written_optional_1024_mod_7",
+        Toggle_this_written_optional_1024_mod_7
+    },
+    {
+        "this_written_optional_1024_mod_8",
+        Toggle_this_written_optional_1024_mod_8
+    },
+    {
+        "this_written_optional_1024_mod_10",
+        Toggle_this_written_optional_1024_mod_10
+    },
+    {
+        "this_written_optional_1024_mod_64",
+        Toggle_this_written_optional_1024_mod_64
+    },
+    {
+        "this_written_optional_1024_mod_256",
+        Toggle_this_written_optional_1024_mod_256
+    },
+    {
+        "this_written_optional_1024_mod_1024",
+        Toggle_this_written_optional_1024_mod_1024
+    },
+    {
+        "this_written_toggle_w_not_toggle",
+        Toggle_this_written_toggle_w_not_toggle
+    },
+    {
+        "this_written_not_toggle_w_toggle",
+        Toggle_this_written_not_toggle_w_toggle
+    },
+    {
+        "this_written_toggle_w_optional_toggle",
+        Toggle_this_written_toggle_w_optional_toggle
+    },
+    {
+        "this_written_optional_toggle_w_toggle",
+        Toggle_this_written_optional_toggle_w_toggle
+    },
+    {
+        "this_written_not_w_optional_toggle",
+        Toggle_this_written_not_w_optional_toggle
+    },
+    {
+        "this_written_optional_w_not_toggle",
+        Toggle_this_written_optional_w_not_toggle
+    },
+    {
+        "this_written_2_not_toggle",
+        Toggle_this_written_2_not_toggle
+    },
+    {
+        "this_written_2_optional_toggle",
+        Toggle_this_written_2_optional_toggle
+    },
+    {
+        "this_written_toggle_w_2_not_toggle",
+        Toggle_this_written_toggle_w_2_not_toggle
+    },
+    {
+        "this_written_toggle_w_2_optional_toggle",
+        Toggle_this_written_toggle_w_2_optional_toggle
+    },
+    {
+        "this_written_2_toggle_w_not_toggle",
+        Toggle_this_written_2_toggle_w_not_toggle
+    },
+    {
+        "this_written_2_toggle_w_optional_toggle",
+        Toggle_this_written_2_toggle_w_optional_toggle
+    },
+    {
+        "this_sort",
+        Toggle_this_sort
+    },
+    {
+        "this_table_move_2_from_3",
+        Toggle_this_table_move_2_from_3
+    }
+};
+
+bake_test_case OrderBy_testcases[] = {
+    {
+        "sort_by_component",
+        OrderBy_sort_by_component
+    },
+    {
+        "sort_by_component_2_tables",
+        OrderBy_sort_by_component_2_tables
+    },
+    {
+        "sort_by_component_3_tables",
+        OrderBy_sort_by_component_3_tables
+    },
+    {
+        "sort_by_entity",
+        OrderBy_sort_by_entity
+    },
+    {
+        "sort_after_add",
+        OrderBy_sort_after_add
+    },
+    {
+        "sort_after_remove",
+        OrderBy_sort_after_remove
+    },
+    {
+        "sort_after_delete",
+        OrderBy_sort_after_delete
+    },
+    {
+        "sort_after_set",
+        OrderBy_sort_after_set
+    },
+    {
+        "sort_after_system",
+        OrderBy_sort_after_system
+    },
+    {
+        "sort_after_query",
+        OrderBy_sort_after_query
+    },
+    {
+        "sort_by_component_same_value_1",
+        OrderBy_sort_by_component_same_value_1
+    },
+    {
+        "sort_by_component_same_value_2",
+        OrderBy_sort_by_component_same_value_2
+    },
+    {
+        "sort_by_component_move_pivot",
+        OrderBy_sort_by_component_move_pivot
+    },
+    {
+        "sort_1000_entities",
+        OrderBy_sort_1000_entities
+    },
+    {
+        "sort_1000_entities_w_duplicates",
+        OrderBy_sort_1000_entities_w_duplicates
+    },
+    {
+        "sort_1000_entities_again",
+        OrderBy_sort_1000_entities_again
+    },
+    {
+        "sort_1000_entities_2_types",
+        OrderBy_sort_1000_entities_2_types
+    },
+    {
+        "sort_1500_entities_3_types",
+        OrderBy_sort_1500_entities_3_types
+    },
+    {
+        "sort_2000_entities_4_types",
+        OrderBy_sort_2000_entities_4_types
+    },
+    {
+        "sort_2_entities_2_types",
+        OrderBy_sort_2_entities_2_types
+    },
+    {
+        "sort_3_entities_3_types",
+        OrderBy_sort_3_entities_3_types
+    },
+    {
+        "sort_3_entities_3_types_2",
+        OrderBy_sort_3_entities_3_types_2
+    },
+    {
+        "sort_4_entities_4_types",
+        OrderBy_sort_4_entities_4_types
+    },
+    {
+        "sort_1000_entities_2_types_again",
+        OrderBy_sort_1000_entities_2_types_again
+    },
+    {
+        "sort_1000_entities_add_type_after_sort",
+        OrderBy_sort_1000_entities_add_type_after_sort
+    },
+    {
+        "sort_shared_component",
+        OrderBy_sort_shared_component
+    },
+    {
+        "sort_shared_component_childof",
+        OrderBy_sort_shared_component_childof
+    },
+    {
+        "sort_w_tags_only",
+        OrderBy_sort_w_tags_only
+    },
+    {
+        "sort_childof_marked",
+        OrderBy_sort_childof_marked
+    },
+    {
+        "sort_isa_marked",
+        OrderBy_sort_isa_marked
+    },
+    {
+        "sort_relation_marked",
+        OrderBy_sort_relation_marked
+    },
+    {
+        "dont_resort_after_set_unsorted_component",
+        OrderBy_dont_resort_after_set_unsorted_component
+    },
+    {
+        "dont_resort_after_set_unsorted_component_w_tag",
+        OrderBy_dont_resort_after_set_unsorted_component_w_tag
+    },
+    {
+        "dont_resort_after_set_unsorted_component_w_tag_w_out_term",
+        OrderBy_dont_resort_after_set_unsorted_component_w_tag_w_out_term
+    },
+    {
+        "sort_component_not_queried_for",
+        OrderBy_sort_component_not_queried_for
+    },
+    {
+        "sort_by_wildcard",
+        OrderBy_sort_by_wildcard
+    },
+    {
+        "sort_shared_w_delete",
+        OrderBy_sort_shared_w_delete
+    },
+    {
+        "sort_w_nontrivial_component",
+        OrderBy_sort_w_nontrivial_component
+    },
+    {
+        "sort_by_wildcard",
+        OrderBy_sort_by_wildcard
+    },
+    {
+        "sort_not_term",
+        OrderBy_sort_not_term
+    },
+    {
+        "sort_or_term",
+        OrderBy_sort_or_term
+    },
+    {
+        "sort_optional_term",
+        OrderBy_sort_optional_term
+    }
+};
+
+bake_test_case OrderByEntireTable_testcases[] = {
+    {
+        "sort_by_component",
+        OrderByEntireTable_sort_by_component
+    },
+    {
+        "sort_by_component_2_tables",
+        OrderByEntireTable_sort_by_component_2_tables
+    },
+    {
+        "sort_by_component_3_tables",
+        OrderByEntireTable_sort_by_component_3_tables
+    },
+    {
+        "sort_by_entity",
+        OrderByEntireTable_sort_by_entity
+    },
+    {
+        "sort_after_add",
+        OrderByEntireTable_sort_after_add
+    },
+    {
+        "sort_after_remove",
+        OrderByEntireTable_sort_after_remove
+    },
+    {
+        "sort_after_delete",
+        OrderByEntireTable_sort_after_delete
+    },
+    {
+        "sort_after_set",
+        OrderByEntireTable_sort_after_set
+    },
+    {
+        "sort_after_system",
+        OrderByEntireTable_sort_after_system
+    },
+    {
+        "sort_after_query",
+        OrderByEntireTable_sort_after_query
+    },
+    {
+        "sort_by_component_same_value_1",
+        OrderByEntireTable_sort_by_component_same_value_1
+    },
+    {
+        "sort_by_component_same_value_2",
+        OrderByEntireTable_sort_by_component_same_value_2
+    },
+    {
+        "sort_by_component_move_pivot",
+        OrderByEntireTable_sort_by_component_move_pivot
+    },
+    {
+        "sort_1000_entities",
+        OrderByEntireTable_sort_1000_entities
+    },
+    {
+        "sort_1000_entities_w_duplicates",
+        OrderByEntireTable_sort_1000_entities_w_duplicates
+    },
+    {
+        "sort_1000_entities_again",
+        OrderByEntireTable_sort_1000_entities_again
+    },
+    {
+        "sort_1000_entities_2_types",
+        OrderByEntireTable_sort_1000_entities_2_types
+    },
+    {
+        "sort_1500_entities_3_types",
+        OrderByEntireTable_sort_1500_entities_3_types
+    },
+    {
+        "sort_2000_entities_4_types",
+        OrderByEntireTable_sort_2000_entities_4_types
+    },
+    {
+        "sort_2_entities_2_types",
+        OrderByEntireTable_sort_2_entities_2_types
+    },
+    {
+        "sort_3_entities_3_types",
+        OrderByEntireTable_sort_3_entities_3_types
+    },
+    {
+        "sort_3_entities_3_types_2",
+        OrderByEntireTable_sort_3_entities_3_types_2
+    },
+    {
+        "sort_4_entities_4_types",
+        OrderByEntireTable_sort_4_entities_4_types
+    },
+    {
+        "sort_1000_entities_2_types_again",
+        OrderByEntireTable_sort_1000_entities_2_types_again
+    },
+    {
+        "sort_1000_entities_add_type_after_sort",
+        OrderByEntireTable_sort_1000_entities_add_type_after_sort
+    },
+    {
+        "sort_shared_component",
+        OrderByEntireTable_sort_shared_component
+    },
+    {
+        "sort_w_tags_only",
+        OrderByEntireTable_sort_w_tags_only
+    },
+    {
+        "sort_childof_marked",
+        OrderByEntireTable_sort_childof_marked
+    },
+    {
+        "sort_isa_marked",
+        OrderByEntireTable_sort_isa_marked
+    },
+    {
+        "sort_relation_marked",
+        OrderByEntireTable_sort_relation_marked
+    },
+    {
+        "dont_resort_after_set_unsorted_component",
+        OrderByEntireTable_dont_resort_after_set_unsorted_component
+    },
+    {
+        "dont_resort_after_set_unsorted_component_w_tag",
+        OrderByEntireTable_dont_resort_after_set_unsorted_component_w_tag
+    },
+    {
+        "dont_resort_after_set_unsorted_component_w_tag_w_out_term",
+        OrderByEntireTable_dont_resort_after_set_unsorted_component_w_tag_w_out_term
+    },
+    {
+        "sort_shared_w_delete",
+        OrderByEntireTable_sort_shared_w_delete
+    },
+    {
+        "sort_not_term",
+        OrderByEntireTable_sort_not_term
+    },
+    {
+        "sort_or_term",
+        OrderByEntireTable_sort_or_term
+    },
+    {
+        "sort_optional_term",
+        OrderByEntireTable_sort_optional_term
+    }
+};
+
+bake_test_case QueryStr_testcases[] = {
+    {
+        "one_term",
+        QueryStr_one_term
+    },
+    {
+        "one_term_w_inout",
+        QueryStr_one_term_w_inout
+    },
+    {
+        "two_terms",
+        QueryStr_two_terms
+    },
+    {
+        "two_terms_w_inout",
+        QueryStr_two_terms_w_inout
+    },
+    {
+        "three_terms_w_or",
+        QueryStr_three_terms_w_or
+    },
+    {
+        "three_terms_w_or_inout",
+        QueryStr_three_terms_w_or_inout
+    },
+    {
+        "four_terms_three_w_or_inout",
+        QueryStr_four_terms_three_w_or_inout
+    },
+    {
+        "one_term_w_pair",
+        QueryStr_one_term_w_pair
+    },
+    {
+        "one_term_w_pair_entity_src",
+        QueryStr_one_term_w_pair_entity_src
+    },
+    {
+        "one_term_w_self",
+        QueryStr_one_term_w_self
+    },
+    {
+        "one_term_w_up",
+        QueryStr_one_term_w_up
+    },
+    {
+        "one_term_w_0",
+        QueryStr_one_term_w_0
+    },
+    {
+        "one_term_w_singleton",
+        QueryStr_one_term_w_singleton
+    },
+    {
+        "one_term_w_final_pair",
+        QueryStr_one_term_w_final_pair
+    },
+    {
+        "one_term_w_final_dont_inherit_pair",
+        QueryStr_one_term_w_final_dont_inherit_pair
+    },
+    {
+        "one_term_w_src_var",
+        QueryStr_one_term_w_src_var
+    },
+    {
+        "one_term_w_first_var",
+        QueryStr_one_term_w_first_var
+    },
+    {
+        "one_term_w_second_var",
+        QueryStr_one_term_w_second_var
+    },
+    {
+        "one_term_w_first_var_entity_src",
+        QueryStr_one_term_w_first_var_entity_src
+    },
+    {
+        "one_term_w_pair_w_0_entity",
+        QueryStr_one_term_w_pair_w_0_entity
+    },
+    {
+        "not_term",
+        QueryStr_not_term
+    },
+    {
+        "wildcard_term",
+        QueryStr_wildcard_term
+    },
+    {
+        "scopes",
+        QueryStr_scopes
+    },
+    {
+        "pred_eq",
+        QueryStr_pred_eq
+    },
+    {
+        "pred_neq",
+        QueryStr_pred_neq
+    },
+    {
+        "pred_eq_name",
+        QueryStr_pred_eq_name
+    },
+    {
+        "pred_neq_name",
+        QueryStr_pred_neq_name
+    },
+    {
+        "pred_eq_m",
+        QueryStr_pred_eq_m
+    },
+    {
+        "pred_neq_m",
+        QueryStr_pred_neq_m
+    }
+};
+
+const char* Basic_cache_kind_param[] = {"default", "auto"};
+bake_test_param Basic_params[] = {
+    {"cache_kind", (char**)Basic_cache_kind_param, 2}
+};
+const char* Variables_cache_kind_param[] = {"default", "auto"};
+bake_test_param Variables_params[] = {
+    {"cache_kind", (char**)Variables_cache_kind_param, 2}
+};
+const char* Operators_cache_kind_param[] = {"default", "auto"};
+bake_test_param Operators_params[] = {
+    {"cache_kind", (char**)Operators_cache_kind_param, 2}
+};
+const char* Recycled_cache_kind_param[] = {"default", "auto"};
+bake_test_param Recycled_params[] = {
+    {"cache_kind", (char**)Recycled_cache_kind_param, 2}
+};
+const char* BuiltinPredicates_cache_kind_param[] = {"default", "auto"};
+bake_test_param BuiltinPredicates_params[] = {
+    {"cache_kind", (char**)BuiltinPredicates_cache_kind_param, 2}
+};
+const char* Scopes_cache_kind_param[] = {"default", "auto"};
+bake_test_param Scopes_params[] = {
+    {"cache_kind", (char**)Scopes_cache_kind_param, 2}
+};
+const char* Traversal_cache_kind_param[] = {"default", "auto"};
+bake_test_param Traversal_params[] = {
+    {"cache_kind", (char**)Traversal_cache_kind_param, 2}
+};
+const char* MemberTarget_cache_kind_param[] = {"default", "auto"};
+bake_test_param MemberTarget_params[] = {
+    {"cache_kind", (char**)MemberTarget_cache_kind_param, 2}
+};
+const char* Toggle_cache_kind_param[] = {"default", "auto"};
+bake_test_param Toggle_params[] = {
+    {"cache_kind", (char**)Toggle_cache_kind_param, 2}
+};
+
+static bake_test_suite suites[] = {
+    {
+        "Validator",
+        NULL,
+        NULL,
+        100,
+        Validator_testcases
+    },
+    {
+        "Parser",
+        NULL,
+        NULL,
+        278,
+        Parser_testcases
+    },
+    {
+        "Basic",
+        Basic_setup,
+        NULL,
+        194,
+        Basic_testcases,
+        1,
+        Basic_params
+    },
+    {
+        "Plan",
+        NULL,
+        NULL,
+        59,
+        Plan_testcases
+    },
+    {
+        "Variables",
+        Variables_setup,
+        NULL,
+        186,
+        Variables_testcases,
+        1,
+        Variables_params
+    },
+    {
+        "Operators",
+        Operators_setup,
+        NULL,
+        139,
+        Operators_testcases,
+        1,
+        Operators_params
+    },
+    {
+        "Transitive",
+        NULL,
+        NULL,
+        72,
+        Transitive_testcases
+    },
+    {
+        "ComponentInheritance",
+        NULL,
+        NULL,
+        31,
+        ComponentInheritance_testcases
+    },
+    {
+        "Recycled",
+        Recycled_setup,
+        NULL,
+        6,
+        Recycled_testcases,
+        1,
+        Recycled_params
+    },
+    {
+        "BuiltinPredicates",
+        BuiltinPredicates_setup,
+        NULL,
+        81,
+        BuiltinPredicates_testcases,
+        1,
+        BuiltinPredicates_params
+    },
+    {
+        "Scopes",
+        Scopes_setup,
+        NULL,
+        10,
+        Scopes_testcases,
+        1,
+        Scopes_params
+    },
+    {
+        "Traversal",
+        Traversal_setup,
+        NULL,
+        98,
+        Traversal_testcases,
+        1,
+        Traversal_params
+    },
+    {
+        "Cascade",
+        NULL,
+        NULL,
+        25,
+        Cascade_testcases
+    },
+    {
+        "Cached",
+        NULL,
+        NULL,
+        87,
+        Cached_testcases
+    },
+    {
+        "ChangeDetection",
+        NULL,
+        NULL,
+        32,
+        ChangeDetection_testcases
+    },
+    {
+        "GroupBy",
+        NULL,
+        NULL,
+        12,
+        GroupBy_testcases
+    },
+    {
+        "MemberTarget",
+        MemberTarget_setup,
+        NULL,
+        62,
+        MemberTarget_testcases,
+        1,
+        MemberTarget_params
+    },
+    {
+        "Toggle",
+        Toggle_setup,
+        NULL,
+        161,
+        Toggle_testcases,
+        1,
+        Toggle_params
+    },
+    {
+        "OrderBy",
+        NULL,
+        NULL,
+        42,
+        OrderBy_testcases
+    },
+    {
+        "OrderByEntireTable",
+        NULL,
+        NULL,
+        37,
+        OrderByEntireTable_testcases
+    },
+    {
+        "QueryStr",
+        NULL,
+        NULL,
+        29,
+        QueryStr_testcases
+    }
+};
+
+int main(int argc, char *argv[]) {
+    return bake_test_run("query", argc, argv, suites, 21);
+}
diff --git a/test/query/src/util.c b/test/query/src/util.c
new file mode 100644
index 000000000..2878e490d
--- /dev/null
+++ b/test/query/src/util.c
@@ -0,0 +1,69 @@
+#include <query.h>
+#include <stdio.h>
+
+void probe_system_w_ctx(
+    ecs_iter_t *it,
+    Probe *ctx) 
+{
+    if (!ctx) {
+        return;
+    }
+
+    ctx->param = it->param;
+    ctx->system = it->system;
+    ctx->event = it->event;
+    ctx->event_id = it->event_id;
+    ctx->offset = 0;
+    ctx->term_count = it->field_count;
+    ctx->term_index = it->term_index;
+
+    int i;
+    for (i = 0; i < ctx->term_count; i ++) {
+        ctx->c[ctx->invoked][i] = it->ids[i];
+        ctx->s[ctx->invoked][i] = ecs_field_src(it, i);
+
+        ecs_id_t e = ecs_field_id(it, i);
+        test_assert(e != 0);
+    }
+
+    for (i = 0; i < it->count; i ++) {
+        if (i + ctx->count < 256) {
+            ctx->e[i + ctx->count] = it->entities[i];
+        } else {
+            /* can't store more than that, tests shouldn't rely on
+                * getting back more than 256 results */
+        }
+    }
+    ctx->count += it->count;
+
+    ctx->invoked ++;
+}
+
+void probe_iter(
+    ecs_iter_t *it) 
+{
+    Probe *ctx = ecs_get_ctx(it->world);
+    if (!ctx) {
+        ctx = it->ctx;
+    }
+    probe_system_w_ctx(it, ctx);
+}
+
+void probe_has_entity(Probe *probe, ecs_entity_t e) {
+    int i;
+    for (i = 0; i < probe->count; i ++) {
+        if (probe->e[i] == e) {
+            break;
+        }
+    }
+
+    test_assert(i != probe->count);
+}
+
+void install_test_abort(void) {
+    ecs_os_set_api_defaults();
+    ecs_os_api_t os_api = ecs_os_api;
+    os_api.abort_ = test_abort;
+    ecs_os_set_api(&os_api);
+    ecs_log_set_level(-5);
+}
diff --git a/test/script/include/script.h b/test/script/include/script.h
new file mode 100644
index 000000000..dc5ab3510
--- /dev/null
+++ b/test/script/include/script.h
@@ -0,0 +1,75 @@
+#ifndef SCRIPT_H
+#define SCRIPT_H
+
+/* This generated file contains includes for project dependencies */
+#include "script/bake_config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Multiline strings */
+#define HEAD
+#define LINE "\n"
+
+#define MAX_SYS_COLUMNS (20)
+#define MAX_ENTITIES (256)
+#define MAX_INVOCATIONS (1024)
+
+typedef struct Probe {
+    ecs_entity_t system;
+    ecs_entity_t event;
+    ecs_id_t event_id;
+    int32_t offset;
+    int32_t count;
+    int32_t invoked;
+    int32_t term_count;
+    int32_t term_index;
+    ecs_entity_t e[MAX_ENTITIES];
+    ecs_entity_t c[MAX_INVOCATIONS][MAX_SYS_COLUMNS];
+    ecs_entity_t s[MAX_INVOCATIONS][MAX_SYS_COLUMNS];
+    void *param;
+} Probe;
+
+typedef struct IterData {
+    ecs_entity_t component;
+    ecs_entity_t component_2;
+    ecs_entity_t component_3;
+    ecs_entity_t new_entities[MAX_ENTITIES];
+    int32_t entity_count;
+} IterData;
+
+typedef struct {
+    float x, y;
+} Position, Velocity;
+
+typedef struct {
+    int32_t x, y;
+} PositionI;
+
+typedef struct {
+    float value;
+} Mass;
+
+typedef struct {
+    float x, y;
+} Point;
+
+typedef struct {
+    Point start, stop;
+} Line;
+
+typedef struct {
+    PositionI start, stop;
+} LineI;
+
+typedef struct {
+    float x, y, z;
+} Vec3;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/test/script/include/script/bake_config.h b/test/script/include/script/bake_config.h
new file mode 100644
index 000000000..172fcc1dd
--- /dev/null
+++ b/test/script/include/script/bake_config.h
@@ -0,0 +1,25 @@
+/*
+                                   )
+                                  (.)
+                                  .|.
+                                  | |
+                              _.--| |--._
+                           .-';  ;`-'& ; `&.
+                          \   &  ;    &   &_/
+                           |"""---...---"""|
+                           \ | | | | | | | /
+                            `---.|.|.|.---'
+
+ * This file is generated by bake.lang.c for your convenience. Headers of
+ * dependencies will automatically show up in this file. Include bake_config.h
+ * in your main project file. Do not edit! */
+
+#ifndef SCRIPT_BAKE_CONFIG_H
+#define SCRIPT_BAKE_CONFIG_H
+
+/* Headers of public dependencies */
+#include <flecs.h>
+#include <bake_test.h>
+
+#endif
+
diff --git a/test/script/project.json b/test/script/project.json
new file mode 100644
index 000000000..7e519a9b9
--- /dev/null
+++ b/test/script/project.json
@@ -0,0 +1,579 @@
+{
+    "id": "script",
+    "type": "application",
+    "value": {
+        "author": "Sander Mertens",
+        "description": "Test project for flecs script",
+        "public": false,
+        "use": [
+            "flecs"
+        ]
+    },
+    "test": {
+        "testsuites": [{
+            "id": "Eval",
+            "testcases": [
+                "null",
+                "empty",
+                "space",
+                "space_newline",
+                "two_empty_newlines",
+                "three_empty_newlines",
+                "newline_trailing_space",
+                "newline_trailing_spaces",
+                "multiple_trailing_newlines",
+                "entity",
+                "entity_w_core_name",
+                "2_entities",
+                "line_comment",
+                "line_comment_before_stmt",
+                "line_comment_after_stmt",
+                "line_comment_between_stmt",
+                "multiple_line_comment",
+                "multiple_line_comment_w_newlines",
+                "line_comment_after_stmt_same_line",
+                "line_comment_before_scope_open",
+                "line_comment_after_newline_before_scope_open",
+                "line_comment_after_newline_before_newline_scope_open",
+                "multi_line_comment",
+                "multi_line_comment_before_stmt",
+                "multi_line_comment_after_stmt",
+                "multi_line_comment_between_stmt",
+                "multiple_multi_line_comment",
+                "multiple_multi_line_comment_w_newlines",
+                "multi_line_comment_after_stmt_same_line",
+                "multi_line_comment_before_scope_open",
+                "multi_line_comment_after_newline_before_scope_open",
+                "multi_line_comment_after_newline_before_newline_scope_open",
+                "multi_line_comment_multiple_lines",
+                "hierarchy_1_child",
+                "hierarchy_2_children",
+                "hierarchy_1_child_same_line",
+                "hierarchy_2_children_same_line",
+                "hierarchy_2_children_same_line_no_trailing_comma",
+                "entity_after_hierarchy",
+                "newline_before_scope_open",
+                "newline_w_whitespace_before_scope_open",
+                "2_newline_before_scope_open",
+                "2_newline_w_whitespace_before_scope_open",
+                "hierarchy_2_levels",
+                "hierarchy_2_levels_2_subtrees",
+                "missing_end_of_scope",
+                "create_in_scope",
+                "hierarchy_w_pred_subj",
+                "hierarchy_custom_relation",
+                "hierarchy_custom_relation_2_levels",
+                "hierarchy_custom_relation_apply_to_object",
+                "hierarchy_custom_relation_apply_to_object_2_levels",
+                "entity_after_hierarchy_custom_relation",
+                "entity_after_hierarchy_custom_relation_2_levels",
+                "with_tag",
+                "with_tag_2_entities",
+                "with_tag_same_line",
+                "with_tag_2_entities_same_line",
+                "with_tag_2_entities_same_line_no_trailing_comma",
+                "with_tag_2_levels",
+                "with_tag_2_levels_2_subtrees",
+                "with_n_tags",
+                "with_n_tags_2_levels",
+                "with_n_tags_2_levels_invalid_tag",
+                "with_after_scope",
+                "with_after_with",
+                "scope_inside_with_inside_scope",
+                "with_inside_scope",
+                "with_tag_core_name",
+                "inherit",
+                "inherit_newline",
+                "inherit_w_colon",
+                "inherit_w_colon_w_scope",
+                "assign_component_w_value",
+                "assign_tag_in_assign_scope",
+                "assign_tag_in_assign_scope_same_line",
+                "assign_tag_in_assign_scope_core_name",
+                "assign_component_value_in_assign_scope",
+                "assign_2_component_values_in_assign_scope",
+                "type_and_assign_in_plecs",
+                "type_and_assign_in_plecs_w_2_members",
+                "type_and_assign_in_plecs_w_3_members",
+                "type_and_assign_in_plecs_w_enum",
+                "type_and_assign_in_plecs_w_enum_using_meta",
+                "type_and_assign_in_plecs_w_enum_primitive_using_meta",
+                "type_and_assign_in_plecs_w_enum_primitive_and_struct",
+                "type_and_assign_in_plecs_nested_member",
+                "dot_assign_nested_member",
+                "dot_assign_binary_expr",
+                "open_scope_no_parent",
+                "create_subject_in_root_scope_w_resolvable_id",
+                "create_subject_in_scope_w_resolvable_id",
+                "create_subject_in_scope_w_resolvable_id_using",
+                "using_scope",
+                "using_nested_scope",
+                "using_nested_in_scope",
+                "using_with_scope",
+                "using_w_entity_ref_in_value_2_members",
+                "using_w_entity_ref_in_value_3_members",
+                "2_using_scope",
+                "2_using_in_different_scope",
+                "empty_scope_after_using",
+                "assignment_to_non_component",
+                "struct_w_member_w_assignment_to_nothing",
+                "struct_w_member_w_assignment_to_empty_scope",
+                "scope_after_assign",
+                "assign_after_inherit",
+                "multiple_tags_single_line",
+                "multiple_pairs_single_line",
+                "multiple_vars_single_line",
+                "multiple_assignments_single_line",
+                "2_stmts_in_scope_w_no_parent",
+                "invalid_nested_assignment",
+                "invalid_partial_pair_assignment",
+                "empty_assignment",
+                "assign_tag_to_parent",
+                "assign_component_to_parent",
+                "empty_assignment_before_end_of_scope",
+                "assign_to_parent_pair_w_new_entities_in_scope",
+                "assign_to_parent_pair_w_existing_entities_in_scope",
+                "default_child_component",
+                "default_child_component_w_assign",
+                "struct_type_w_default_child_component",
+                "struct_type_w_default_child_component_nested_member",
+                "enum_type_w_default_child_component",
+                "default_type_from_with",
+                "default_type_from_nested_with",
+                "default_type_with_tag",
+                "default_type_from_with_in_entity_scope_w_default_type",
+                "default_type_from_entity_scope_in_with",
+                "scope_w_1_subj_and_2_pairs",
+                "inherit_from_multiple",
+                "assign_pair_component",
+                "assign_pair_component_in_scope",
+                "assign_pair_component_in_script",
+                "assign_pair_component_in_script_update",
+                "set_entity_names",
+                "oneof",
+                "invalid_oneof",
+                "brief_annotation",
+                "name_annotation",
+                "link_annotation",
+                "color_annotation",
+                "multiple_annotations",
+                "annotation_w_trailing_space",
+                "multiline_string",
+                "unterminated_multiline_string",
+                "declaration_w_underscore_name",
+                "annotate_declaration",
+                "anonymous_entity",
+                "anonymous_entity_in_scope",
+                "anonymous_declaration",
+                "const_var_int",
+                "const_var_float",
+                "const_var_bool",
+                "const_var_string",
+                "const_var_struct",
+                "const_var_redeclare",
+                "const_var_scoped",
+                "assign_component_from_var",
+                "assign_component_from_var_in_scope",
+                "scope_w_component_after_const_var",
+                "component_after_const_paren_expr",
+                "component_after_const_add_expr",
+                "component_after_const_sub_expr",
+                "component_after_const_mul_expr",
+                "component_after_const_div_expr",
+                "parse_with",
+                "parse_with_w_with",
+                "parse_with_w_tag",
+                "parse_with_value",
+                "parse_with_2_values",
+                "parse_with_2_nested_values",
+                "parse_with_var",
+                "parse_with_2_vars",
+                "parse_with_2_nested_vars",
+                "parse_with_var_in_scope",
+                "assign_const_w_expr",
+                "const_w_type",
+                "typed_const_w_composite_type_invalid_assignment",
+                "typed_const_w_composite_type",
+                "assign_var_to_typed_const_w_composite_type",
+                "typed_const_w_composite_type_invalid_assignment",
+                "using_wildcard",
+                "single_line_comment_in_value",
+                "single_line_comment_in_value_after_scope",
+                "multi_line_comment_in_value",
+                "multi_line_comment_in_value_after_scope",
+                "unterminated_multi_line_comment_in_value",
+                "module_stmt",
+                "nested_module_stmt",
+                "module_stmt_w_scope",
+                "module_stmt_w_nested_scope",
+                "assign_singleton_tag",
+                "assign_singleton_component",
+                "assign_singleton_tag_w_scope",
+                "assign_singleton_2_tags_w_scope",
+                "assign_singleton_component_w_scope",
+                "assign_singleton_2_components_w_scope",
+                "with_pair_in_scope",
+                "with_pair_component_in_scope",
+                "pair_w_rel_var",
+                "pair_w_tgt_var",
+                "pair_w_rel_var_invalid_type",
+                "pair_w_tgt_var_invalid_type",
+                "with_value_not_a_component",
+                "component_in_with_scope",
+                "component_in_with_scope_nested",
+                "component_in_with_scope_in_scope",
+                "assign_after_with_in_scope",
+                "array_component",
+                "not_an_array_component",
+                "array_component_w_curly_brackets",
+                "unknown_identifier",
+                "unknown_identifier_for_int_field",
+                "on_set_w_kind_paren_no_reflection",
+                "on_set_w_kind_paren",
+                "on_set_w_kind_no_paren_no_reflection",
+                "on_set_w_kind_no_paren",
+                "on_set_w_single_assign",
+                "on_set_w_single_assign_scoped_w_value",
+                "on_set_w_single_assign_scoped_no_value",
+                "if_true",
+                "if_true_no_else",
+                "if_false",
+                "if_true_var",
+                "if_false_var",
+                "if_10",
+                "if_0",
+                "if_true_in_scope",
+                "if_false_in_scope"
+            ]
+        }, {
+            "id": "Assembly",
+            "testcases": [
+                "assembly_no_scope",
+                "assembly_empty",
+                "assembly_unresolved_tag",
+                "assembly_unresolved_component",
+                "assembly_unresolved_pair_relationship",
+                "assembly_unresolved_pair_target",
+                "assembly_unresolved_with_tag",
+                "assembly_unresolved_with_component",
+                "assembly_unresolved_with_pair_relationship",
+                "assembly_unresolved_with_pair_target",
+                "assembly_no_props",
+                "assembly_prop_no_type",
+                "assembly_prop_no_default",
+                "assembly_prop",
+                "assembly_prop_space_colon",
+                "assembly_2_props",
+                "assembly_w_using",
+                "assembly_instance_w_default_values",
+                "assembly_instance_w_assign_default_values",
+                "assembly_instance_w_overridden_values",
+                "assembly_w_child",
+                "assembly_w_child_parse_script",
+                "assembly_w_child_parse_script_twice",
+                "assembly_w_child_update_after_parse",
+                "assembly_w_nested_child",
+                "assembly_w_prefab",
+                "assembly_w_prefab_tree",
+                "assembly_w_nested_assembly",
+                "instantiate_prefab_w_assembly",
+                "assembly_w_prefab_w_assembly",
+                "3_assemblies",
+                "assembly_nested_w_default_var",
+                "assembly_w_anonymous",
+                "assembly_w_anonymous_parse_again",
+                "assembly_redeclare_prop_as_const",
+                "assembly_redeclare_prop_as_prop",
+                "assembly_redeclare_const_as_const",
+                "assembly_w_composite_prop_invalid_assignment",
+                "assembly_w_composite_prop",
+                "assembly_with_with",
+                "module_w_assembly",
+                "module_w_nested_assembly",
+                "assembly_w_pair_w_this_var",
+                "run_assembly_after_error",
+                "update_assembly_after_error"
+            ]
+        }, {
+            "id": "Expr",
+            "testcases": [
+                "add_2_int_literals",
+                "add_2_int_literals_twice",
+                "sub_2_int_literals",
+                "mul_2_int_literals",
+                "div_2_int_literals",
+                "add_3_int_literals",
+                "add_3_int_literals_twice",
+                "sub_3_int_literals",
+                "mul_3_int_literals",
+                "div_3_int_literals",
+                "int_to_bool",
+                "bool_to_int",
+                "bool_to_uint",
+                "add_mul_3_int_literals",
+                "sub_mul_3_int_literals",
+                "div_mul_3_int_literals",
+                "add_div_3_int_literals",
+                "sub_div_3_int_literals",
+                "mul_div_3_int_literals",
+                "mul_add_mul_add_int_literals",
+                "mul_sub_mul_sub_int_literals",
+                "mul_div_mul_div_int_literals",
+                "div_add_div_add_int_literals",
+                "div_sub_div_sub_int_literals",
+                "div_sub_div_mul_int_literals",
+                "div_mul_div_mul_int_literals",
+                "add_2_flt_literals",
+                "sub_2_flt_literals",
+                "mul_2_flt_literals",
+                "div_2_flt_literals",
+                "add_2_int_neg_literals",
+                "sub_2_int_neg_literals",
+                "mul_2_int_neg_literals",
+                "div_2_int_neg_literals",
+                "mul_lparen_add_add_rparen_int_literals",
+                "mul_lparen_add_add_add_rparen_int_literals",
+                "mul_lparen_add_add_rparen_add_int_literals",
+                "lparen_add_add_rparen_mul_int_literals",
+                "lparen_add_add_add_rparen_mul_int_literals",
+                "double_paren_add_add",
+                "double_paren_literal",
+                "lparen_add_add_rparen_mul_lparen_add_add_rparen",
+                "float_result_add_2_int_literals",
+                "struct_result_add_2_int_literals",
+                "struct_result_add_2_2_fields_int_literals",
+                "struct_result_add_3_int_literals",
+                "struct_result_lparen_int_rparen",
+                "add_to_var",
+                "add_var_to",
+                "var_member",
+                "bool_cond_and_bool",
+                "bool_cond_or_bool",
+                "int_cond_and_int",
+                "int_cond_or_int",
+                "bool_cond_and_int",
+                "int_cond_and_bool",
+                "bool_cond_or_int",
+                "int_cond_or_bool",
+                "cond_eq_bool",
+                "cond_eq_int",
+                "cond_neq_bool",
+                "cond_neq_int",
+                "cond_eq_bool_int",
+                "cond_eq_int_flt",
+                "cond_eq_cond_and",
+                "cond_eq_cond_or",
+                "cond_gt_bool",
+                "cond_gt_int",
+                "cond_gt_flt",
+                "cond_gteq_bool",
+                "cond_gteq_int",
+                "cond_gteq_flt",
+                "cond_lt_bool",
+                "cond_lt_int",
+                "cond_lt_flt",
+                "cond_lteq_bool",
+                "cond_lteq_int",
+                "cond_lteq_flt",
+                "min_lparen_int_rparen",
+                "min_lparen_int_add_int_rparen",
+                "min_var",
+                "min_lparen_int_rparen_to_i64",
+                "min_lparen_int_rparen_to_i32",
+                "struct_w_min_var",
+                "struct_w_min_lparen_int_rparen",
+                "struct_w_min_lparen_var_rparen",
+                "shift_left_int",
+                "shift_right_int",
+                "shift_left_int_add_int",
+                "shift_left_int_mul_int",
+                "add_int_shift_left_int",
+                "mul_int_shift_left_int",
+                "add_int_shift_left_int_add_int",
+                "mul_int_shift_left_int_mul_int",
+                "entity_expr",
+                "entity_path_expr",
+                "entity_parent_func",
+                "entity_name_func",
+                "entity_doc_name_func",
+                "entity_chain_func",
+                "var_parent_func",
+                "var_name_func",
+                "var_doc_name_func",
+                "var_chain_func",
+                "interpolate_string_w_i32_var",
+                "interpolate_string_w_string_var",
+                "interpolate_string_w_entity_var",
+                "interpolate_string_w_id_var",
+                "interpolate_string_w_var_not_found",
+                "interpolate_string_w_entity_var_0",
+                "interpolate_string_w_var_special_chars",
+                "interpolate_string_w_var_before_after_text",
+                "interpolate_string_w_curly_brackets_var",
+                "interpolate_string_w_curly_brackets_expr",
+                "interpolate_string_w_curly_brackets_expr_w_var",
+                "interpolate_string_w_curly_brackets_expr_w_composite_var",
+                "interpolate_string_w_escape_var_operator",
+                "interpolate_string_w_escape_curly_brackets",
+                "interpolate_string_w_func",
+                "interpolate_string_w_func_chain",
+                "iter_to_vars_no_data",
+                "iter_to_vars_1_comp",
+                "iter_to_vars_2_comps",
+                "iter_to_vars_1_comp_1_tag",
+                "iter_to_vars_w_1_query_var",
+                "iter_to_vars_w_2_query_vars"
+            ]
+        }, {
+            "id": "Vars",
+            "testcases": [
+                "declare_1_var",
+                "declare_2_vars",
+                "declare_vars_nested_scope",
+                "declare_vars_2_scopes",
+                "redeclare_var",
+                "i32_expr_w_i32_var",
+                "i32_expr_w_f32_var",
+                "i32_expr_w_string_var",
+                "string_expr_w_string_var",
+                "struct_expr_w_i32_vars",
+                "struct_expr_w_struct_var",
+                "nested_struct_expr_w_struct_var",
+                "redeclare_in_scope",
+                "init_fini_vars"
+            ]
+        }, {
+            "id": "Serialize",
+            "testcases": [
+                "bool",
+                "byte",
+                "char",
+                "i8",
+                "i16",
+                "i32",
+                "i64",
+                "iptr",
+                "u8",
+                "u16",
+                "u32",
+                "u64",
+                "uptr",
+                "float",
+                "double",
+                "string",
+                "entity",
+                "entity_10k",
+                "id",
+                "enum",
+                "bitmask",
+                "float_nan",
+                "float_inf",
+                "double_nan",
+                "double_inf",
+                "struct_enum",
+                "struct_bitmask",
+                "struct_i32",
+                "struct_i32_i32",
+                "struct_entity",
+                "struct_id",
+                "array_i32_3",
+                "array_struct_i32_i32",
+                "array_array_i32_3",
+                "vector_i32_3",
+                "vector_struct_i32_i32",
+                "vector_array_i32_3",
+                "entity_entity_after_float",
+                "struct_nested_i32",
+                "struct_nested_i32_i32",
+                "struct_2_nested_i32_i32",
+                "struct_i32_array_3",
+                "struct_struct_i32_array_3",
+                "struct_struct_i32_i32_array_3",
+                "struct_w_array_type_i32_i32",
+                "struct_w_array_type_struct",
+                "struct_w_2_array_type_i32_i32",
+                "struct_w_2_array_type_struct",
+                "struct_partial",
+                "escape_simple_string",
+                "escape_newline",
+                "escape_2_newlines",
+                "escape_string_w_trailing_newline",
+                "escape_string_w_2_trailing_newlines",
+                "escape_string_w_delim"
+            ]
+        }, {
+            "id": "Deserialize",
+            "testcases": [
+                "bool",
+                "byte",
+                "char",
+                "char_literal",
+                "i8",
+                "i16",
+                "i32",
+                "i64",
+                "iptr",
+                "u8",
+                "u16",
+                "u32",
+                "u64",
+                "uptr",
+                "float",
+                "double",
+                "negative_int",
+                "negative_float",
+                "invalid_i8",
+                "invalid_i16",
+                "invalid_i32",
+                "invalid_i64",
+                "invalid_iptr",
+                "invalid_u8",
+                "invalid_u16",
+                "invalid_u32",
+                "invalid_u64",
+                "invalid_uptr",
+                "invalid_float",
+                "invalid_double",
+                "string",
+                "entity",
+                "id",
+                "enum",
+                "bitmask",
+                "struct_enum",
+                "struct_bitmask",
+                "struct_i32",
+                "struct_i32_neg",
+                "struct_i32_i32",
+                "struct_entity",
+                "struct_id",
+                "struct_nested_i32",
+                "struct_nested_i32_i32",
+                "struct_2_nested_i32_i32",
+                "struct_member_i32",
+                "struct_member_i32_neg",
+                "struct_member_i32_i32",
+                "struct_member_nested_i32",
+                "struct_member_nested_i32_i32",
+                "struct_member_2_nested_i32_i32",
+                "struct_member_2_nested_i32_i32_reverse",
+                "struct_i32_array_3",
+                "struct_struct_i32_array_3",
+                "struct_struct_i32_i32_array_3",
+                "struct_w_array_type_i32_i32",
+                "struct_w_array_type_struct",
+                "struct_w_2_array_type_i32_i32",
+                "struct_w_2_array_type_struct",
+                "discover_type_int",
+                "discover_type_negative_int",
+                "discover_type_float",
+                "discover_type_negative_float",
+                "discover_type_string",
+                "discover_type_multiline_string",
+                "discover_type_entity",
+                "discover_type_bool",
+                "discover_type_unknown",
+                "discover_type_invalid"
+            ]
+        }]
+    }
+}
diff --git a/test/script/src/Assembly.c b/test/script/src/Assembly.c
new file mode 100644
index 000000000..04c0e2bf8
--- /dev/null
+++ b/test/script/src/Assembly.c
@@ -0,0 +1,2072 @@
+#include <script.h>
+
+void Assembly_assembly_no_scope(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_empty(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "}";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_unresolved_tag(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  Foo"
+    LINE "}"
+    LINE "Tree ent()";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_unresolved_component(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "using flecs.meta"
+    LINE "assembly Tree {"
+    LINE "  struct Position {"
+    LINE "    x = f32"
+    LINE "  }"
+    LINE ""
+    LINE "  Position: {10, 20}"
+    LINE "}";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_unresolved_pair_relationship(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Bar {}"
+    LINE "assembly Tree {"
+    LINE "  (Foo, Bar)"
+    LINE "}"
+    LINE "Tree ent()";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_unresolved_pair_target(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Foo {}"
+    LINE "assembly Tree {"
+    LINE "  (Foo, Bar)"
+    LINE "}"
+    LINE "Tree ent()";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_unresolved_with_tag(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  with Foo {"
+    LINE "  }"
+    LINE "}"
+    LINE "Tree ent()";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_unresolved_with_component(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "using flecs.meta"
+    LINE "assembly Tree {"
+    LINE "  struct Position {"
+    LINE "    x = f32"
+    LINE "  }"
+    LINE ""
+    LINE "  with Position(10, 20) {"
+    LINE "  }"
+    LINE "}";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_unresolved_with_pair_relationship(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Bar {}"
+    LINE "assembly Tree {"
+    LINE "  with (Foo, Bar) {"
+    LINE "  }"
+    LINE "}"
+    LINE "Tree ent()";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_unresolved_with_pair_target(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Foo {}"
+    LINE "assembly Tree {"
+    LINE "  with (Foo, Bar) {"
+    LINE "  }"
+    LINE "}"
+    LINE "Tree ent()";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_no_props(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    const char *expr =
+    HEAD "Foo {}"
+    LINE "assembly Tree {"
+    LINE "  Foo"
+    LINE "}"
+    LINE "Tree ent()";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    test_assert(foo != 0);
+
+    ecs_entity_t ent = ecs_lookup(world, "ent");
+    test_assert(ent != 0);
+    test_assert(ecs_has_id(world, ent, foo));
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_prop_no_type(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop height"
+    LINE "}";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_prop_no_default(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop height: flecs.meta.f32"
+    LINE "}";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_prop(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 1);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_prop_space_colon(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 1);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_2_props(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.i32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_i32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_using(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    HEAD "using flecs.meta"
+    LINE "Foo {}"
+    LINE "assembly Tree {"
+    LINE "  prop width = i32: 10"
+    LINE "  prop height = f32: 20"
+    LINE "  Foo"
+    LINE "}"
+    LINE "Tree ent()";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    test_assert(foo != 0);
+
+    ecs_entity_t ent = ecs_lookup(world, "ent");
+    test_assert(ent != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_i32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, ent, tree));
+    test_assert(ecs_has_id(world, ent, foo));
+
+    const void *ptr = ecs_get_id(world, ent, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 10, height: 20}");
+    ecs_os_free(str);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_instance_w_default_values(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 10"
+    LINE "  prop height = flecs.meta.f32: 20"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree }"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 10, height: 20}");
+    ecs_os_free(str);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_instance_w_assign_default_values(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 10"
+    LINE "  prop height = flecs.meta.f32: 20"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree: {} }"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 10, height: 20}");
+    ecs_os_free(str);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_instance_w_overridden_values(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 10"
+    LINE "  prop height = flecs.meta.f32: 20"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree: {width: 30, height: 40} }"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 30, height: 40}");
+    ecs_os_free(str);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_child(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  child { Position: {$width * 10 + 1, $height * 20 + 2} }"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree: {width: 1, height: 2} }"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    ecs_entity_t root_child = ecs_lookup(world, "child");
+    test_assert(root_child == 0);
+
+    ecs_entity_t child = ecs_lookup(world, "e.child");
+    test_assert(child != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 1, height: 2}");
+    ecs_os_free(str);
+
+    const Position *p = ecs_get(world, child, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 11);
+    test_int(p->y, 42);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_child_parse_script(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  child { Position: {$width * 10 + 1, $height * 20 + 2} }"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree: {width: 1, height: 2} }"
+    LINE "";
+
+    test_assert(ecs_script(world, {
+        .entity = ecs_entity(world, { .name = "main" }),
+        .code = expr
+    }) != 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    ecs_entity_t child = ecs_lookup(world, "e.child");
+    test_assert(child != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 1, height: 2}");
+    ecs_os_free(str);
+
+    const Position *p = ecs_get(world, child, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 11);
+    test_int(p->y, 42);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_child_parse_script_twice(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  child { Position: {$width * 10 + 1, $height * 20 + 2} }"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree: {width: 1, height: 2} }"
+    LINE "";
+
+    test_assert(ecs_script(world, {
+        .entity = ecs_entity(world, { .name = "main" }),
+        .code = expr
+    }) != 0);
+
+    test_assert(ecs_script(world, {
+        .entity = ecs_entity(world, { .name = "main" }),
+        .code = expr
+    }) != 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    ecs_entity_t child = ecs_lookup(world, "e.child");
+    test_assert(child != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 1, height: 2}");
+    ecs_os_free(str);
+
+    const Position *p = ecs_get(world, child, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 11);
+    test_int(p->y, 42);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_child_update_after_parse(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  child { Position: {$width * 10 + 1, $height * 20 + 2} }"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree: {width: 1, height: 2} }"
+    LINE "";
+
+    test_assert(ecs_script(world, {
+        .entity = ecs_entity(world, { .name = "main" }),
+        .code = expr
+    }) != 0);
+
+    {
+        ecs_entity_t tree = ecs_lookup(world, "Tree");
+        test_assert(tree != 0);
+
+        ecs_entity_t e = ecs_lookup(world, "e");
+        test_assert(e != 0);
+
+        ecs_entity_t child = ecs_lookup(world, "e.child");
+        test_assert(child != 0);
+    }
+
+    test_assert(!ecs_is_deferred(world));
+
+    const char *expr_update =
+    LINE "e { Tree: {width: 3, height: 4} }"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr_update) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    ecs_entity_t child = ecs_lookup(world, "e.child");
+    test_assert(child != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 3, height: 4}");
+    ecs_os_free(str);
+
+    const Position *p = ecs_get(world, child, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 31);
+    test_int(p->y, 82);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_nested_child(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  child {"
+    LINE "    Position: {$width, $height}"
+    LINE "    grand_child { Position: {$height, $width} }"
+    LINE "  }"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree: {width: 1, height: 2} }"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    ecs_entity_t child = ecs_lookup(world, "e.child");
+    test_assert(child != 0);
+
+    ecs_entity_t grand_child = ecs_lookup(world, "e.child.grand_child");
+    test_assert(grand_child != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 1, height: 2}");
+    ecs_os_free(str);
+
+    {
+        const Position *p = ecs_get(world, child, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+    }
+
+    {
+        const Position *p = ecs_get(world, grand_child, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 2);
+        test_int(p->y, 1);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_prefab(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    ecs_struct(world, {
+        .entity = ecs_id(Velocity),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  Prefab base {"
+    LINE "    Velocity: {$width * 2, $height * 3}"
+    LINE "  }"
+    LINE "  child : base {"
+    LINE "    Position: {$width, $height}"
+    LINE "  }"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree: {width: 1, height: 2} }"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    ecs_entity_t child = ecs_lookup(world, "e.child");
+    test_assert(child != 0);
+
+    ecs_entity_t base = ecs_lookup(world, "e.base");
+    test_assert(base != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 1, height: 2}");
+    ecs_os_free(str);
+
+    test_assert(ecs_has_pair(world, child, EcsIsA, base));
+
+    {
+        const Position *p = ecs_get(world, child, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+    }
+
+    {
+        const Velocity *v = ecs_get(world, child, Velocity);
+        test_assert(v != NULL);
+        test_int(v->x, 2);
+        test_int(v->y, 6);
+    }
+
+    {
+        const Velocity *v = ecs_get(world, base, Velocity);
+        test_assert(v != NULL);
+        test_int(v->x, 2);
+        test_int(v->y, 6);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_prefab_tree(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    ecs_struct(world, {
+        .entity = ecs_id(Velocity),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  Prefab base {"
+    LINE "    Velocity: {$width * 2, $height * 3}"
+    LINE "    Prefab child {"
+    LINE "      Velocity: {$height * 3, $width * 2}"
+    LINE "    }"
+    LINE "  }"
+    LINE "  child : base {"
+    LINE "    Position: {$width, $height}"
+    LINE "  }"
+    LINE "}"
+    LINE ""
+    LINE "e { Tree: {width: 1, height: 2} }"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    ecs_entity_t child = ecs_lookup(world, "e.child");
+    test_assert(child != 0);
+
+    ecs_entity_t base = ecs_lookup(world, "e.base");
+    test_assert(base != 0);
+
+    ecs_entity_t base_child = ecs_lookup(world, "e.base.child");
+    test_assert(base_child != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    test_assert(ecs_has_id(world, e, tree));
+    const void *ptr = ecs_get_id(world, e, tree);
+    test_assert(ptr != NULL);
+    char *str = ecs_ptr_to_expr(world, tree, ptr);
+    test_assert(str != NULL);
+    test_str(str, "{width: 1, height: 2}");
+    ecs_os_free(str);
+
+    test_assert(ecs_has_pair(world, child, EcsIsA, base));
+
+    {
+        const Position *p = ecs_get(world, child, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 1);
+        test_int(p->y, 2);
+    }
+
+    {
+        const Velocity *v = ecs_get(world, child, Velocity);
+        test_assert(v != NULL);
+        test_int(v->x, 2);
+        test_int(v->y, 6);
+    }
+
+    {
+        const Velocity *v = ecs_get(world, base, Velocity);
+        test_assert(v != NULL);
+        test_int(v->x, 2);
+        test_int(v->y, 6);
+    }
+
+    {
+        const Velocity *v = ecs_get(world, base_child, Velocity);
+        test_assert(v != NULL);
+        test_int(v->x, 6);
+        test_int(v->y, 2);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_nested_assembly(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  child {"
+    LINE "    Position: {$width, $height}"
+    LINE "  }"
+    LINE "}"
+    LINE ""
+    LINE "assembly Forest {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  tree_1 { Tree: {-$width, -$height} }"
+    LINE "  tree_2 { Tree: {$width + 1, $height + 1} }"
+    LINE "}"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+    ecs_entity_t forest = ecs_lookup(world, "Forest");
+    test_assert(forest != 0);
+
+    test_assert(ecs_lookup(world, "tree_1") == 0);
+    test_assert(ecs_lookup(world, "tree_2") == 0);
+    test_assert(ecs_lookup(world, "Forest.tree_1.child") == 0);
+    test_assert(ecs_lookup(world, "Forest.tree_2.child") == 0);
+
+    {
+        const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+        test_assert(st != NULL);
+        test_int(st->members.count, 2);
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+    }
+
+    {
+        const EcsStruct *st = ecs_get(world, forest, EcsStruct);
+        test_assert(st != NULL);
+        test_int(st->members.count, 2);
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+    }
+
+    test_assert(!ecs_is_deferred(world));
+
+    const char *expr_instance =
+    LINE "f { Forest: {10, 20} }"
+    LINE "";
+    test_assert(ecs_script_run(world, NULL, expr_instance) == 0);
+
+    ecs_entity_t f = ecs_lookup(world, "f");
+    test_assert(f != 0);
+    ecs_entity_t f_tree_1 = ecs_lookup(world, "f.tree_1");
+    test_assert(f_tree_1 != 0);
+    ecs_entity_t f_tree_2 = ecs_lookup(world, "f.tree_2");
+    test_assert(f_tree_2 != 0);
+    ecs_entity_t f_tree_1_child = ecs_lookup(world, "f.tree_1.child");
+    test_assert(f_tree_1_child != 0);
+    ecs_entity_t f_tree_2_child = ecs_lookup(world, "f.tree_2.child");
+    test_assert(f_tree_2_child != 0);
+
+    {
+        const void *ptr = ecs_get_id(world, f, forest);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, forest, ptr);
+        test_str(str, "{width: 10, height: 20}");
+        ecs_os_free(str);
+    }
+    {
+        const void *ptr = ecs_get_id(world, f_tree_1, tree);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, tree, ptr);
+        test_str(str, "{width: -10, height: -20}");
+        ecs_os_free(str);
+    }
+    {
+        const void *ptr = ecs_get_id(world, f_tree_2, tree);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, tree, ptr);
+        test_str(str, "{width: 11, height: 21}");
+        ecs_os_free(str);
+    }
+
+    {
+        const Position *p = ecs_get(world, f_tree_1_child, Position);
+        test_assert(p != NULL);
+        test_int(p->x, -10);
+        test_int(p->y, -20);
+    }
+    {
+        const Position *p = ecs_get(world, f_tree_2_child, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 11);
+        test_int(p->y, 21);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_instantiate_prefab_w_assembly(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop width = flecs.meta.f32: 0"
+    LINE "  prop height = flecs.meta.f32: 0"
+    LINE "  child { Position: {$width, $height} }"
+    LINE "}"
+    LINE ""
+    LINE "Prefab p { Tree: {width: 10, height: 20} }"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+    ecs_entity_t p = ecs_lookup(world, "p");
+    test_assert(p != 0);
+    test_assert(ecs_lookup(world, "p.child") == 0);
+    test_assert(ecs_lookup(world, "child") == 0);
+
+    const char *expr_instance =
+    LINE "e : p"
+    LINE "";
+    test_assert(ecs_script_run(world, NULL, expr_instance) == 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+    ecs_entity_t child = ecs_lookup(world, "e.child");
+    test_assert(child != 0);
+
+    test_assert(ecs_lookup(world, "e.child") != 0);
+
+    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+    test_assert(st != NULL);
+    test_int(st->members.count, 2);
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
+    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+
+    {
+        const void *ptr = ecs_get_id(world, p, tree);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, tree, ptr);
+        test_str(str, "{width: 10, height: 20}");
+        ecs_os_free(str);
+    }
+
+    test_assert(ecs_has_pair(world, e, EcsIsA, p));
+
+    {
+        const Position *p = ecs_get(world, child, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_prefab_w_assembly(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop count = flecs.meta.f32: 0"
+    LINE "}"
+    LINE ""
+    LINE "assembly Forest {"
+    LINE "  prop count = flecs.meta.f32: 0"
+    LINE ""
+    LINE "  Prefab TreePrefab {"
+    LINE "    Tree: {count: $count}"
+    LINE "  }"
+    LINE ""
+    LINE "  child : TreePrefab"
+    LINE "}"
+    LINE "f { Forest: {10} }";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+    ecs_entity_t forest = ecs_lookup(world, "Forest");
+    test_assert(forest != 0);
+
+    ecs_entity_t f = ecs_lookup(world, "f");
+    test_assert(f != 0);
+    ecs_entity_t child = ecs_lookup(world, "f.child");
+    test_assert(child != 0);
+
+    {
+        const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+        test_assert(st != NULL);
+        test_int(st->members.count, 1);
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "count");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    }
+    
+    {
+        const EcsStruct *st = ecs_get(world, forest, EcsStruct);
+        test_assert(st != NULL);
+        test_int(st->members.count, 1);
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "count");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    }
+    
+    {
+        const void *ptr = ecs_get_id(world, f, forest);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, forest, ptr);
+        test_str(str, "{count: 10}");
+        ecs_os_free(str);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_3_assemblies(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop t = flecs.meta.f32: 10"
+    LINE "}"
+    LINE ""
+    LINE "assembly Forest {"
+    LINE "  prop f = flecs.meta.f32: 20"
+    LINE "}"
+    LINE ""
+    LINE "assembly Park {"
+    LINE "  prop p = flecs.meta.f32: 30"
+    LINE "}"
+    LINE ""
+    LINE "Tree a()"
+    LINE "Forest b()"
+    LINE "Park c()"
+    LINE "";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+    ecs_entity_t forest = ecs_lookup(world, "Forest");
+    test_assert(forest != 0);
+    ecs_entity_t park = ecs_lookup(world, "Park");
+    test_assert(park != 0);
+    
+    ecs_entity_t a = ecs_lookup(world, "a");
+    test_assert(a != 0);
+    ecs_entity_t b = ecs_lookup(world, "b");
+    test_assert(b != 0);
+    ecs_entity_t c = ecs_lookup(world, "c");
+    test_assert(c != 0);
+
+    {
+        const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+        test_assert(st != NULL);
+        test_int(st->members.count, 1);
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "t");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    }  
+    {
+        const EcsStruct *st = ecs_get(world, forest, EcsStruct);
+        test_assert(st != NULL);
+        test_int(st->members.count, 1);
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "f");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    }
+    {
+        const EcsStruct *st = ecs_get(world, park, EcsStruct);
+        test_assert(st != NULL);
+        test_int(st->members.count, 1);
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "p");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    }
+    
+    {
+        const void *ptr = ecs_get_id(world, a, tree);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, tree, ptr);
+        test_str(str, "{t: 10}");
+        ecs_os_free(str);
+    }
+    {
+        const void *ptr = ecs_get_id(world, b, forest);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, forest, ptr);
+        test_str(str, "{f: 20}");
+        ecs_os_free(str);
+    }
+    {
+        const void *ptr = ecs_get_id(world, c, park);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, park, ptr);
+        test_str(str, "{p: 30}");
+        ecs_os_free(str);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_nested_w_default_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop count = flecs.meta.f32: 0"
+    LINE "  trunk { Position: {$count, $count * 2} }"
+    LINE "}"
+    LINE ""
+    LINE "assembly Forest {"
+    LINE "  prop count = flecs.meta.f32: 0"
+    LINE "  child { Tree: {count:$} }"
+    LINE "}"
+    LINE "f { Forest: {10} }";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+    ecs_entity_t forest = ecs_lookup(world, "Forest");
+    test_assert(forest != 0);
+
+    ecs_entity_t f = ecs_lookup(world, "f");
+    test_assert(f != 0);
+    ecs_entity_t child = ecs_lookup(world, "f.child");
+    test_assert(child != 0);
+    ecs_entity_t trunk = ecs_lookup(world, "f.child.trunk");
+    test_assert(trunk != 0);
+
+    {
+        const EcsStruct *st = ecs_get(world, tree, EcsStruct);
+        test_assert(st != NULL);
+        test_int(st->members.count, 1);
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "count");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    }
+    
+    {
+        const EcsStruct *st = ecs_get(world, forest, EcsStruct);
+        test_assert(st != NULL);
+        test_int(st->members.count, 1);
+        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "count");
+        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    }
+
+    {
+        const void *ptr = ecs_get_id(world, f, forest);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, forest, ptr);
+        test_str(str, "{count: 10}");
+        ecs_os_free(str);
+    }
+    {
+        const void *ptr = ecs_get_id(world, child, tree);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, tree, ptr);
+        test_str(str, "{count: 10}");
+        ecs_os_free(str);
+    }
+
+    {
+        const Position *p = ecs_get(world, trunk, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_anonymous(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop count = flecs.meta.i32: 0"
+    LINE "  _ { Position: {$count, $count * 2} }"
+    LINE "  _ { Position: {$count, $count * 2} }"
+    LINE "}"
+    LINE ""
+    LINE "t { Tree: {10} }";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+    ecs_entity_t t = ecs_lookup(world, "t");
+    test_assert(t != 0);
+
+    {
+        ecs_query_t *f = ecs_query(world, {
+            .terms = {
+                { .id = ecs_childof(t) },
+                { .id = ecs_id(Position) },
+            }
+        });
+
+        ecs_iter_t it = ecs_query_iter(world, f);
+        test_int(2, ecs_iter_count(&it));
+        ecs_query_fini(f);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_anonymous_parse_again(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop count = flecs.meta.i32: 0"
+    LINE "  _ { Position: {$count, $count * 2} }"
+    LINE "  _ { Position: {$count, $count * 2} }"
+    LINE "}"
+    LINE ""
+    LINE "t { Tree: {10} }";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    {
+        ecs_entity_t tree = ecs_lookup(world, "Tree");
+        test_assert(tree != 0);
+        ecs_entity_t t = ecs_lookup(world, "t");
+        test_assert(t != 0);
+
+        {
+            ecs_query_t *f = ecs_query(world, {
+                .terms = {
+                    { .id = ecs_childof(t) },
+                    { .id = ecs_id(Position) },
+                }
+            });
+
+            ecs_iter_t it = ecs_query_iter(world, f);
+            test_bool(true, ecs_query_next(&it));
+            test_int(2, it.count);
+            test_assert(ecs_get_name(world, it.entities[0]) == NULL);
+            Position *p = ecs_field(&it, Position, 1);
+            test_int(p[0].x, 10); test_int(p[0].y, 20);
+            test_int(p[1].x, 10); test_int(p[1].y, 20);
+            test_bool(false, ecs_query_next(&it));
+            ecs_query_fini(f);
+        }
+    }
+
+    const char *expr_again =
+    LINE "t { Tree: {10} }";
+    test_assert(ecs_script_run(world, NULL, expr_again) == 0);
+
+    {
+        ecs_entity_t tree = ecs_lookup(world, "Tree");
+        test_assert(tree != 0);
+        ecs_entity_t t = ecs_lookup(world, "t");
+        test_assert(t != 0);
+
+        {
+            ecs_query_t *f = ecs_query(world, {
+                .terms = {
+                    { .id = ecs_childof(t) },
+                    { .id = ecs_id(Position) },
+                }
+            });
+
+            ecs_iter_t it = ecs_query_iter(world, f);
+            test_bool(true, ecs_query_next(&it));
+            test_int(2, it.count);
+            test_assert(ecs_get_name(world, it.entities[0]) == NULL);
+            Position *p = ecs_field(&it, Position, 1);
+            test_int(p[0].x, 10); test_int(p[0].y, 20);
+            test_int(p[1].x, 10); test_int(p[1].y, 20);
+            test_bool(false, ecs_query_next(&it));
+            ecs_query_fini(f);
+        }
+    }
+
+    ecs_fini(world);
+}
+
+
+void Assembly_assembly_w_composite_prop_invalid_assignment(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop pos = Position: Position{10, 20}"
+    LINE "  child { $pos }"
+    LINE "}"
+    LINE ""
+    LINE "t { Tree: {pos: {20, 30}} }";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_composite_prop(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "assembly Tree {"
+    LINE "  prop pos = Position: {10, 20}"
+    LINE "  child { $pos }"
+    LINE "}"
+    LINE "t { Tree: {pos: {20, 30}} }"
+    LINE "";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+    ecs_entity_t t = ecs_lookup(world, "t");
+    test_assert(t != 0);
+    ecs_entity_t t_child = ecs_lookup(world, "t.child");
+    test_assert(t_child != 0);
+
+    {
+        const void *ptr = ecs_get_id(world, t, tree);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, tree, ptr);
+        test_str(str, "{pos: {x: 20, y: 30}}");
+        ecs_os_free(str);
+    }
+
+    {
+        const Position *p = ecs_get(world, t_child, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 20);
+        test_int(p->y, 30);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_with_with(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    HEAD "Foo {}"
+    LINE "assembly Tree {"
+    LINE "  prop count = flecs.meta.i32: 0"
+    LINE "  with Foo {"
+    LINE "    child { Position: {$count, $count * 2} }"
+    LINE "  }"
+    LINE "}"
+    LINE "t { Tree: {count: 10} }"
+    LINE "";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "Tree");
+    test_assert(tree != 0);
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    test_assert(foo != 0);
+    ecs_entity_t t = ecs_lookup(world, "t");
+    test_assert(t != 0);
+    ecs_entity_t t_child = ecs_lookup(world, "t.child");
+    test_assert(t_child != 0);
+
+    {
+        const void *ptr = ecs_get_id(world, t, tree);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, tree, ptr);
+        test_str(str, "{count: 10}");
+        ecs_os_free(str);
+    }
+
+    {
+        const Position *p = ecs_get(world, t_child, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_module_w_assembly(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "module hello.world\n"
+    LINE "assembly Tree {\n"
+    LINE "  prop count = flecs.meta.i32: 0\n"
+    LINE "  child { Position: {$count, $count * 2} }\n"
+    LINE "}\n"
+    LINE "";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    const char *expr_inst =
+    LINE "t = hello.world.Tree: {10}\n";
+    test_assert(ecs_script_run(world, NULL, expr_inst) == 0);
+
+    ecs_entity_t tree = ecs_lookup(world, "hello.world.Tree");
+    test_assert(tree != 0);
+    ecs_entity_t t = ecs_lookup(world, "t");
+    test_assert(t != 0);
+    ecs_entity_t child = ecs_lookup(world, "t.child");
+    test_assert(child != 0);
+
+    {
+        const void *ptr = ecs_get_id(world, t, tree);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, tree, ptr);
+        test_str(str, "{count: 10}");
+        ecs_os_free(str);
+    }
+
+    test_assert(ecs_has(world, child, Position));
+
+    {
+        const Position *ptr = ecs_get(world, child, Position);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 10);
+        test_int(ptr->y, 20);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_module_w_nested_assembly(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_COMPONENT(world, Position);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    const char *expr =
+    LINE "module hello.world"
+    LINE "assembly Tree {"
+    LINE "  prop count = flecs.meta.i32: 0"
+    LINE "  child { Position: {$count, $count * 2} }"
+    LINE "}"
+    LINE "assembly Forest {"
+    LINE "  prop count = flecs.meta.i32: 0"
+    LINE "  t { Tree: {count:$} }"
+    LINE "}"
+    LINE "";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    const char *expr_inst =
+    LINE "f = hello.world.Forest: {10}\n";
+    test_assert(ecs_script_run(world, NULL, expr_inst) == 0);
+
+    ecs_entity_t forest = ecs_lookup(world, "hello.world.Forest");
+    test_assert(forest != 0);
+    ecs_entity_t tree = ecs_lookup(world, "hello.world.Tree");
+    test_assert(tree != 0);
+    ecs_entity_t f = ecs_lookup(world, "f");
+    test_assert(f != 0);
+    ecs_entity_t t = ecs_lookup(world, "f.t");
+    test_assert(t != 0);
+    ecs_entity_t child = ecs_lookup(world, "f.t.child");
+    test_assert(child != 0);
+
+    {
+        const void *ptr = ecs_get_id(world, f, forest);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, forest, ptr);
+        test_str(str, "{count: 10}");
+        ecs_os_free(str);
+    }
+    {
+        const void *ptr = ecs_get_id(world, t, tree);
+        test_assert(ptr != NULL);
+        char *str = ecs_ptr_to_expr(world, tree, ptr);
+        test_str(str, "{count: 10}");
+        ecs_os_free(str);
+    }
+
+    test_assert(ecs_has(world, child, Position));
+
+    {
+        const Position *ptr = ecs_get(world, child, Position);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 10);
+        test_int(ptr->y, 20);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_redeclare_prop_as_const(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    LINE "assembly Foo {\n"
+    LINE "  prop x = flecs.meta.f32: 10\n"
+    LINE "  prop y = flecs.meta.f32: 10\n"
+    LINE "  const y = flecs.meta.f32: 20\n"
+    LINE "}"
+    LINE "ent { Foo: {} }\n"
+    LINE "\n";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_redeclare_prop_as_prop(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    LINE "assembly Foo {\n"
+    LINE "  prop x = flecs.meta.f32: 10\n"
+    LINE "  prop y = flecs.meta.f32: 10\n"
+    LINE "  prop y = flecs.meta.f32: 20\n"
+    LINE "}"
+    LINE "ent { Foo: {} }\n"
+    LINE "\n";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_redeclare_const_as_const(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    LINE "assembly Foo {\n"
+    LINE "  prop x = flecs.meta.f32: 10\n"
+    LINE "  const y = flecs.meta.f32: 10\n"
+    LINE "  const y = flecs.meta.f32: 20\n"
+    LINE "}"
+    LINE "ent { Foo: {} }\n"
+    LINE "\n";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Assembly_assembly_w_pair_w_this_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ECS_TAG(world, Rel);
+
+    const char *expr =
+    LINE "assembly Foo {\n"
+    LINE "  prop x = flecs.meta.f32: 10\n" // dummy prop
+    LINE "  (Rel, $this)\n"
+    LINE "}\n"
+    LINE "ent { Foo: {} }\n"
+    LINE "\n";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t ent = ecs_lookup(world, "ent");
+
+    test_assert(ecs_has_id(world, ent, foo));
+    test_assert(ecs_has_pair(world, ent, Rel, ent));
+
+    ecs_fini(world);
+}
+
+void Assembly_run_assembly_after_error(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Foo {}"
+    LINE "assembly Tree {"
+    LINE "  Foo"
+    LINE "}";
+
+    const char *expr_err =
+    HEAD "Foo {}"
+    LINE "assembly Tree {"
+    LINE "  Fo"
+    LINE "}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    {
+        ecs_entity_t tree = ecs_lookup(world, "Tree");
+        test_assert(tree != 0);
+
+        ecs_entity_t foo = ecs_lookup(world, "Foo");
+        test_assert(foo != 0);
+    }
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr_err) != 0);
+    ecs_log_set_level(-1);
+
+    /* Because script is not managed, entiites created by script aren't deleted */
+
+    {
+        ecs_entity_t tree = ecs_lookup(world, "Tree");
+        test_assert(tree != 0);
+
+        ecs_entity_t foo = ecs_lookup(world, "Foo");
+        test_assert(foo != 0);
+    }
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    {
+        ecs_entity_t tree = ecs_lookup(world, "Tree");
+        test_assert(tree != 0);
+
+        ecs_entity_t foo = ecs_lookup(world, "Foo");
+        test_assert(foo != 0);
+    }
+
+    ecs_fini(world);
+}
+
+void Assembly_update_assembly_after_error(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Foo {}"
+    LINE "assembly Tree {"
+    LINE "  Foo"
+    LINE "}";
+
+    const char *expr_err =
+    HEAD "Foo {}"
+    LINE "assembly Tree {"
+    LINE "  Fo"
+    LINE "}";
+
+    ecs_entity_t s = ecs_script(world, { .code = expr });
+    test_assert(s != 0);
+
+    {
+        ecs_entity_t tree = ecs_lookup(world, "Tree");
+        test_assert(tree != 0);
+
+        ecs_entity_t foo = ecs_lookup(world, "Foo");
+        test_assert(foo != 0);
+    }
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_update(world, s, 0, expr_err) != 0);
+    ecs_log_set_level(-1);
+
+    {
+        ecs_entity_t tree = ecs_lookup(world, "Tree");
+        test_assert(tree == 0);
+
+        ecs_entity_t foo = ecs_lookup(world, "Foo");
+        test_assert(foo == 0);
+    }
+
+    test_assert(ecs_script_update(world, s, 0, expr) == 0);
+
+    {
+        ecs_entity_t tree = ecs_lookup(world, "Tree");
+        test_assert(tree != 0);
+
+        ecs_entity_t foo = ecs_lookup(world, "Foo");
+        test_assert(foo != 0);
+    }
+
+    ecs_fini(world);
+}
diff --git a/test/meta/src/DeserializeFromExpr.c b/test/script/src/Deserialize.c
similarity index 66%
rename from test/meta/src/DeserializeFromExpr.c
rename to test/script/src/Deserialize.c
index 8c0d9315a..9e37a67f8 100644
--- a/test/meta/src/DeserializeFromExpr.c
+++ b/test/script/src/Deserialize.c
@@ -1,11 +1,11 @@
-#include <meta.h>
+#include <script.h>
 
-void DeserializeFromExpr_bool(void) {
+void Deserialize_bool(void) {
     ecs_world_t *world = ecs_init();
 
     bool value = false;
 
-    const char *ptr = ecs_parse_expr(world, "true", &ecs_value(ecs_bool_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "true", &ecs_value_ptr(ecs_bool_t, &value), NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');        
 
@@ -14,12 +14,12 @@ void DeserializeFromExpr_bool(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_byte(void) {
+void Deserialize_byte(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_byte_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_byte_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_byte_t, &value), NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');        
 
@@ -28,12 +28,12 @@ void DeserializeFromExpr_byte(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_char(void) {
+void Deserialize_char(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_char_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_char_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_char_t, &value), NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');        
 
@@ -42,12 +42,12 @@ void DeserializeFromExpr_char(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_char_literal(void) {
+void Deserialize_char_literal(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_char_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "\"a\"", &ecs_value(ecs_char_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "\"a\"", &ecs_value_ptr(ecs_char_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 'a');
@@ -55,12 +55,12 @@ void DeserializeFromExpr_char_literal(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_i8(void) {
+void Deserialize_i8(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_i8_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_i8_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_i8_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 10);
@@ -68,12 +68,12 @@ void DeserializeFromExpr_i8(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_i16(void) {
+void Deserialize_i16(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_i16_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_i16_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_i16_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 10);
@@ -81,12 +81,12 @@ void DeserializeFromExpr_i16(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_i32(void) {
+void Deserialize_i32(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_i32_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_i32_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_i32_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 10);
@@ -94,12 +94,12 @@ void DeserializeFromExpr_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_i64(void) {
+void Deserialize_i64(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_i64_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_i64_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_i64_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 10);
@@ -107,12 +107,12 @@ void DeserializeFromExpr_i64(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_iptr(void) {
+void Deserialize_iptr(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_iptr_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_iptr_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_iptr_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 10);
@@ -120,12 +120,12 @@ void DeserializeFromExpr_iptr(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_u8(void) {
+void Deserialize_u8(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_u8_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_u8_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_u8_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 10);
@@ -133,12 +133,12 @@ void DeserializeFromExpr_u8(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_u16(void) {
+void Deserialize_u16(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_u16_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_u16_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_u16_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 10);
@@ -146,12 +146,12 @@ void DeserializeFromExpr_u16(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_u32(void) {
+void Deserialize_u32(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_u32_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_u32_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_u32_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 10);
@@ -159,29 +159,29 @@ void DeserializeFromExpr_u32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_u64(void) {
+void Deserialize_u64(void) {
     ecs_world_t *world = ecs_init();
 
     {
         ecs_u64_t value = 0;
-        const char *ptr = ecs_parse_expr(
-            world, "0", &ecs_value(ecs_u64_t, &value), NULL);
+        const char *ptr = ecs_script_expr_run(
+            world, "0", &ecs_value_ptr(ecs_u64_t, &value), NULL);
         test_assert(ptr != NULL);
         test_int(value, 0);
     }
 
     {
         ecs_u64_t value = 0;
-        const char *ptr = ecs_parse_expr(
-            world, "10", &ecs_value(ecs_u64_t, &value), NULL);
+        const char *ptr = ecs_script_expr_run(
+            world, "10", &ecs_value_ptr(ecs_u64_t, &value), NULL);
         test_assert(ptr != NULL);
         test_int(value, 10);
     }
 
     {
         ecs_u64_t value = 0;
-        const char *ptr = ecs_parse_expr(
-            world, "2366700781656087864", &ecs_value(ecs_u64_t, &value), NULL);
+        const char *ptr = ecs_script_expr_run(
+            world, "2366700781656087864", &ecs_value_ptr(ecs_u64_t, &value), NULL);
         test_assert(ptr != NULL);
         test_int(value, 2366700781656087864);
     }
@@ -189,12 +189,12 @@ void DeserializeFromExpr_u64(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_uptr(void) {
+void Deserialize_uptr(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_uptr_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10", &ecs_value(ecs_uptr_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10", &ecs_value_ptr(ecs_uptr_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, 10);
@@ -202,12 +202,12 @@ void DeserializeFromExpr_uptr(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_float(void) {
+void Deserialize_float(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_f32_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10.5", &ecs_value(ecs_f32_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10.5", &ecs_value_ptr(ecs_f32_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_flt(value, 10.5);
@@ -215,12 +215,12 @@ void DeserializeFromExpr_float(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_double(void) {
+void Deserialize_double(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_f64_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "10.5", &ecs_value(ecs_f64_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "10.5", &ecs_value_ptr(ecs_f64_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_flt(value, 10.5);
@@ -228,12 +228,12 @@ void DeserializeFromExpr_double(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_negative_int(void) {
+void Deserialize_negative_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_i8_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "-10", &ecs_value(ecs_i8_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "-10", &ecs_value_ptr(ecs_i8_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_int(value, -10);
@@ -241,12 +241,12 @@ void DeserializeFromExpr_negative_int(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_negative_float(void) {
+void Deserialize_negative_float(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_f32_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "-10.5", &ecs_value(ecs_f32_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "-10.5", &ecs_value_ptr(ecs_f32_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_flt(value, -10.5);
@@ -254,12 +254,168 @@ void DeserializeFromExpr_negative_float(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_string(void) {
+void Deserialize_invalid_i8(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_i8_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_i16(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_i16_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_i32(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_i32_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_i64(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_i64_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_iptr(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_iptr_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_u8(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_u8_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_u16(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_u16_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_u32(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_u32_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_u64(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_u64_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_uptr(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_uptr_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_float(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_f32_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_invalid_double(void) {
+    ecs_world_t *world = ecs_init();
+
+    uint64_t value = 0;
+
+    ecs_log_set_level(-4);
+    const char *ptr = ecs_script_expr_run(
+        world, "a", &ecs_value_ptr(ecs_f64_t, &value), NULL);
+    test_assert(ptr == NULL);
+
+    ecs_fini(world);
+}
+
+void Deserialize_string(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_string_t value = 0;
 
-    const char *ptr = ecs_parse_expr(world, "\"Hello World\"", &ecs_value(ecs_string_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "\"Hello World\"", &ecs_value_ptr(ecs_string_t, &value), NULL);
     test_assert(ptr != NULL);
 
     test_str(value, "Hello World");
@@ -269,37 +425,37 @@ void DeserializeFromExpr_string(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_entity(void) {
+void Deserialize_entity(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t value = 0;
-    const char *ptr = ecs_parse_expr(world, "flecs.core", &ecs_value(ecs_entity_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "flecs.core", &ecs_value_ptr(ecs_entity_t, &value), NULL);
     test_assert(ptr != NULL);
     test_uint(value, EcsFlecsCore);
 
-    ptr = ecs_parse_expr(world, "0", &ecs_value(ecs_entity_t, &value), NULL);
+    ptr = ecs_script_expr_run(world, "0", &ecs_value_ptr(ecs_entity_t, &value), NULL);
     test_assert(ptr != NULL);
     test_uint(value, 0);
 
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_id(void) {
+void Deserialize_id(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_id_t value = 0;
-    const char *ptr = ecs_parse_expr(world, "flecs.core", &ecs_value(ecs_id_t, &value), NULL);
+    const char *ptr = ecs_script_expr_run(world, "flecs.core", &ecs_value_ptr(ecs_id_t, &value), NULL);
     test_assert(ptr != NULL);
     test_uint(value, EcsFlecsCore);
 
-    ptr = ecs_parse_expr(world, "0", &ecs_value(ecs_id_t, &value), NULL);
+    ptr = ecs_script_expr_run(world, "0", &ecs_value_ptr(ecs_id_t, &value), NULL);
     test_assert(ptr != NULL);
     test_uint(value, 0);
 
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_enum(void) {
+void Deserialize_enum(void) {
     typedef enum {
         Red, Blue, Green
     } T;
@@ -316,21 +472,21 @@ void DeserializeFromExpr_enum(void) {
 
     {
     T value = 0;
-    const char *ptr = ecs_parse_expr(world, "Red", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "Red", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_int(value, Red);
     }
 
     {
     T value = 0;
-    const char *ptr = ecs_parse_expr(world, "Blue", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "Blue", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_int(value, Blue);
     }
 
     {
     T value = 0;
-    const char *ptr = ecs_parse_expr(world, "Green", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "Green", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_int(value, Green);
     }
@@ -338,14 +494,14 @@ void DeserializeFromExpr_enum(void) {
     {
     ecs_log_set_level(-4);
     T value = 0;
-    const char *ptr = ecs_parse_expr(world, "Black", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "Black", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr == NULL);
     }
 
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_bitmask(void) {
+void Deserialize_bitmask(void) {
     uint32_t Lettuce = 0x1;
     uint32_t Bacon =   0x1 << 1;
     uint32_t Tomato =  0x1 << 2;
@@ -361,42 +517,42 @@ void DeserializeFromExpr_bitmask(void) {
 
     {
     uint32_t value = 0;
-    const char *ptr = ecs_parse_expr(world, "Lettuce", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "Lettuce", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value, Lettuce);
     }
 
     {
     uint32_t value = 0;
-    const char *ptr = ecs_parse_expr(world, "Lettuce|Bacon", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "Lettuce|Bacon", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value, Lettuce|Bacon);
     }
 
     {
     uint32_t value = 0;
-    const char *ptr = ecs_parse_expr(world, "Lettuce|Bacon|Tomato|Cheese", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "Lettuce|Bacon|Tomato|Cheese", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value, Lettuce|Bacon|Tomato|Cheese);
     }
 
     {
     uint32_t value = 0;
-    const char *ptr = ecs_parse_expr(world, "Lettuce | Bacon | Tomato | Cheese", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "Lettuce | Bacon | Tomato | Cheese", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value, Lettuce|Bacon|Tomato|Cheese);
     }
 
     {
     uint32_t value = 0;
-    const char *ptr = ecs_parse_expr(world, "BLT", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "BLT", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value, Lettuce|Bacon|Tomato);
     }
 
     {
     uint32_t value = 0;
-    const char *ptr = ecs_parse_expr(world, "0", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "0", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value, 0);
     }
@@ -404,14 +560,14 @@ void DeserializeFromExpr_bitmask(void) {
     {
     ecs_log_set_level(-4);
     uint32_t value = 0;
-    const char *ptr = ecs_parse_expr(world, "Foo", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "Foo", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr == NULL);
     }
 
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_enum(void) {
+void Deserialize_struct_enum(void) {
     typedef enum {
         Red, Blue, Green
     } E;
@@ -441,21 +597,21 @@ void DeserializeFromExpr_struct_enum(void) {
 
     {
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v: Red}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v: Red}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_int(value.v, Red);
     }
 
     {
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v: Blue}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v: Blue}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_int(value.v, Blue);
     }
 
     {
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v: Green}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v: Green}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_int(value.v, Green);
     }
@@ -463,14 +619,14 @@ void DeserializeFromExpr_struct_enum(void) {
     {
     ecs_log_set_level(-4);
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v: Black}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v: Black}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr == NULL);
     }
 
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_bitmask(void) {
+void Deserialize_struct_bitmask(void) {
     uint32_t Lettuce = 0x1;
     uint32_t Bacon =   0x1 << 1;
     uint32_t Tomato =  0x1 << 2;
@@ -501,35 +657,35 @@ void DeserializeFromExpr_struct_bitmask(void) {
 
     {
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v:Lettuce}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v:Lettuce}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value.v, Lettuce);
     }
 
     {
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v:Lettuce|Bacon}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v:Lettuce|Bacon}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value.v, Lettuce|Bacon);
     }
 
     {
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v:Lettuce|Bacon|Tomato|Cheese}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v:Lettuce|Bacon|Tomato|Cheese}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value.v, Lettuce|Bacon|Tomato|Cheese);
     }
 
     {
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v:BLT}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v:BLT}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value.v, Lettuce|Bacon|Tomato);
     }
 
     {
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v:0}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v:0}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_uint(value.v, 0);
     }
@@ -537,14 +693,14 @@ void DeserializeFromExpr_struct_bitmask(void) {
     {
     ecs_log_set_level(-4);
     T value = {0};
-    const char *ptr = ecs_parse_expr(world, "{v:Foo\"}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{v:Foo\"}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr == NULL);
     }
 
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_i32(void) {
+void Deserialize_struct_i32(void) {
     typedef struct {
         int32_t x;
     } T;
@@ -560,7 +716,7 @@ void DeserializeFromExpr_struct_i32(void) {
 
     T value = {0};
 
-    const char *ptr = ecs_parse_expr(world, "{10}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{10}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -569,7 +725,7 @@ void DeserializeFromExpr_struct_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_i32_neg(void) {
+void Deserialize_struct_i32_neg(void) {
     typedef struct {
         int32_t x;
     } T;
@@ -585,7 +741,7 @@ void DeserializeFromExpr_struct_i32_neg(void) {
 
     T value = {0};
 
-    const char *ptr = ecs_parse_expr(world, "{-10}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{-10}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -594,7 +750,7 @@ void DeserializeFromExpr_struct_i32_neg(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_i32_i32(void) {
+void Deserialize_struct_i32_i32(void) {
     typedef struct {
         int32_t x;
         int32_t y;
@@ -612,7 +768,7 @@ void DeserializeFromExpr_struct_i32_i32(void) {
 
     T value = {0, 0};
 
-    const char *ptr = ecs_parse_expr(world, "{10, 20}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{10, 20}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -622,7 +778,7 @@ void DeserializeFromExpr_struct_i32_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_entity(void) {
+void Deserialize_struct_entity(void) {
     typedef struct {
         ecs_entity_t entity;
     } T;
@@ -638,7 +794,7 @@ void DeserializeFromExpr_struct_entity(void) {
 
     T value = {0};
 
-    const char *ptr = ecs_parse_expr(world, "{flecs.core}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{flecs.core}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -647,7 +803,7 @@ void DeserializeFromExpr_struct_entity(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_id(void) {
+void Deserialize_struct_id(void) {
     typedef struct {
         ecs_id_t entity;
     } T;
@@ -663,7 +819,7 @@ void DeserializeFromExpr_struct_id(void) {
 
     T value = {0};
 
-    const char *ptr = ecs_parse_expr(world, "{flecs.core}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{flecs.core}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -672,7 +828,7 @@ void DeserializeFromExpr_struct_id(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_nested_i32(void) {
+void Deserialize_struct_nested_i32(void) {
     typedef struct {
         ecs_i32_t x;
     } N1;
@@ -699,7 +855,7 @@ void DeserializeFromExpr_struct_nested_i32(void) {
 
     T value = {{0}};
 
-    const char *ptr = ecs_parse_expr(world, "{{10}}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{{10}}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -708,7 +864,7 @@ void DeserializeFromExpr_struct_nested_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_nested_i32_i32(void) {
+void Deserialize_struct_nested_i32_i32(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -737,7 +893,7 @@ void DeserializeFromExpr_struct_nested_i32_i32(void) {
 
     T value = {{0}};
 
-    const char *ptr = ecs_parse_expr(world, "{{10, 20}}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{{10, 20}}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -747,7 +903,7 @@ void DeserializeFromExpr_struct_nested_i32_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_2_nested_i32_i32(void) {
+void Deserialize_struct_2_nested_i32_i32(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -778,7 +934,7 @@ void DeserializeFromExpr_struct_2_nested_i32_i32(void) {
 
     T value = {{0}};
 
-    const char *ptr = ecs_parse_expr(world, "{{10, 20}, {30, 40}}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{{10, 20}, {30, 40}}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -790,7 +946,7 @@ void DeserializeFromExpr_struct_2_nested_i32_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_member_i32(void) {
+void Deserialize_struct_member_i32(void) {
     typedef struct {
         int32_t x;
     } T;
@@ -806,7 +962,7 @@ void DeserializeFromExpr_struct_member_i32(void) {
 
     T value = {0};
 
-    const char *ptr = ecs_parse_expr(world, "{x: 10}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{x: 10}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -815,7 +971,7 @@ void DeserializeFromExpr_struct_member_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_member_i32_neg(void) {
+void Deserialize_struct_member_i32_neg(void) {
     typedef struct {
         int32_t x;
     } T;
@@ -831,7 +987,7 @@ void DeserializeFromExpr_struct_member_i32_neg(void) {
 
     T value = {0};
 
-    const char *ptr = ecs_parse_expr(world, "{x: -10}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{x: -10}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -840,7 +996,7 @@ void DeserializeFromExpr_struct_member_i32_neg(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_member_i32_i32(void) {
+void Deserialize_struct_member_i32_i32(void) {
     typedef struct {
         int32_t x;
         int32_t y;
@@ -858,7 +1014,7 @@ void DeserializeFromExpr_struct_member_i32_i32(void) {
 
     T value = {0};
 
-    const char *ptr = ecs_parse_expr(world, "{x: 10, y: 20}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{x: 10, y: 20}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -868,7 +1024,7 @@ void DeserializeFromExpr_struct_member_i32_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_member_nested_i32(void) {
+void Deserialize_struct_member_nested_i32(void) {
     typedef struct {
         ecs_i32_t x;
     } N1;
@@ -895,7 +1051,7 @@ void DeserializeFromExpr_struct_member_nested_i32(void) {
 
     T value = {{0}};
 
-    const char *ptr = ecs_parse_expr(world, "{n_1: {x: 10}}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{n_1: {x: 10}}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -904,7 +1060,7 @@ void DeserializeFromExpr_struct_member_nested_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_member_nested_i32_i32(void) {
+void Deserialize_struct_member_nested_i32_i32(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -933,7 +1089,7 @@ void DeserializeFromExpr_struct_member_nested_i32_i32(void) {
 
     T value = {{0}};
 
-    const char *ptr = ecs_parse_expr(world, "{n_1: {x: 10, y: 20}}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{n_1: {x: 10, y: 20}}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -943,7 +1099,7 @@ void DeserializeFromExpr_struct_member_nested_i32_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_member_2_nested_i32_i32(void) {
+void Deserialize_struct_member_2_nested_i32_i32(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -980,7 +1136,7 @@ void DeserializeFromExpr_struct_member_2_nested_i32_i32(void) {
     LINE " n_2: {x: 30, y: 40}"
     LINE "}";
 
-    const char *ptr = ecs_parse_expr(world, expr, &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, expr, &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -992,7 +1148,7 @@ void DeserializeFromExpr_struct_member_2_nested_i32_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_member_2_nested_i32_i32_reverse(void) {
+void Deserialize_struct_member_2_nested_i32_i32_reverse(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -1029,7 +1185,7 @@ void DeserializeFromExpr_struct_member_2_nested_i32_i32_reverse(void) {
     LINE " n_1: {x: 10, y: 20}"
     LINE "}";
 
-    const char *ptr = ecs_parse_expr(world, expr, &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, expr, &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -1041,7 +1197,7 @@ void DeserializeFromExpr_struct_member_2_nested_i32_i32_reverse(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_i32_array_3(void) {
+void Deserialize_struct_i32_array_3(void) {
     typedef struct {
         int32_t x[3];
     } T;
@@ -1057,7 +1213,7 @@ void DeserializeFromExpr_struct_i32_array_3(void) {
 
     T value = {0};
 
-    const char *ptr = ecs_parse_expr(world, "{x: [10, 20, 30]}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{x: [10, 20, 30]}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -1068,7 +1224,7 @@ void DeserializeFromExpr_struct_i32_array_3(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_struct_i32_array_3(void) {
+void Deserialize_struct_struct_i32_array_3(void) {
     typedef struct {
         ecs_i32_t x;
     } N1;
@@ -1095,7 +1251,7 @@ void DeserializeFromExpr_struct_struct_i32_array_3(void) {
 
     T value = {{{0}}};
 
-    const char *ptr = ecs_parse_expr(world, "{n_1: [{x: 10}, {x: 20}, {x: 30}]}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{n_1: [{x: 10}, {x: 20}, {x: 30}]}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -1106,7 +1262,7 @@ void DeserializeFromExpr_struct_struct_i32_array_3(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_struct_i32_i32_array_3(void) {
+void Deserialize_struct_struct_i32_i32_array_3(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -1135,7 +1291,7 @@ void DeserializeFromExpr_struct_struct_i32_i32_array_3(void) {
 
     T value = {{{0}}};
 
-    const char *ptr = ecs_parse_expr(world, "{n_1: [{x: 10, y: 20}, {x: 30, y: 40}, {x: 50, y: 60}]}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{n_1: [{x: 10, y: 20}, {x: 30, y: 40}, {x: 50, y: 60}]}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -1149,7 +1305,7 @@ void DeserializeFromExpr_struct_struct_i32_i32_array_3(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_w_array_type_i32_i32(void) {
+void Deserialize_struct_w_array_type_i32_i32(void) {
     typedef int32_t N1[2];
 
     typedef struct {
@@ -1173,7 +1329,7 @@ void DeserializeFromExpr_struct_w_array_type_i32_i32(void) {
 
     T value = {{ 0 }};
 
-    const char *ptr = ecs_parse_expr(world, "{n_1: [10, 20]}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{n_1: [10, 20]}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -1183,7 +1339,7 @@ void DeserializeFromExpr_struct_w_array_type_i32_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_w_2_array_type_i32_i32(void) {
+void Deserialize_struct_w_2_array_type_i32_i32(void) {
     typedef int32_t N1[2];
 
     typedef struct {
@@ -1209,7 +1365,7 @@ void DeserializeFromExpr_struct_w_2_array_type_i32_i32(void) {
 
     T value = {{ 0 }};
 
-    const char *ptr = ecs_parse_expr(world, "{n_1: [10, 20], n_2: [30, 40]}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{n_1: [10, 20], n_2: [30, 40]}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -1221,7 +1377,7 @@ void DeserializeFromExpr_struct_w_2_array_type_i32_i32(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_w_array_type_struct(void) {
+void Deserialize_struct_w_array_type_struct(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -1264,7 +1420,7 @@ void DeserializeFromExpr_struct_w_array_type_struct(void) {
 
     T value;
 
-    const char *ptr = ecs_parse_expr(world, "{n_1: [{x: 10, y: 20}, {x: 30, y: 40}]}", &(ecs_value_t){t, &value}, NULL);
+    const char *ptr = ecs_script_expr_run(world, "{n_1: [{x: 10, y: 20}, {x: 30, y: 40}]}", &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
     test_assert(ptr[0] == '\0');
 
@@ -1276,7 +1432,7 @@ void DeserializeFromExpr_struct_w_array_type_struct(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_struct_w_2_array_type_struct(void) {
+void Deserialize_struct_w_2_array_type_struct(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -1321,7 +1477,7 @@ void DeserializeFromExpr_struct_w_2_array_type_struct(void) {
 
     T value;
 
-    const char *ptr = ecs_parse_expr(world, 
+    const char *ptr = ecs_script_expr_run(world, 
         "{n_1: [{x: 10, y: 20}, {x: 30, y: 40}], n_2: [{x: 50, y: 60}, {x: 70, y: 80}]}", 
         &(ecs_value_t){t, &value}, NULL);
     test_assert(ptr != NULL);
@@ -1340,11 +1496,11 @@ void DeserializeFromExpr_struct_w_2_array_type_struct(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_int(void) {
+void Deserialize_discover_type_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10", &v, NULL) != NULL);
     test_uint(v.type, ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_int(*(uint64_t*)v.ptr, 10);
@@ -1353,11 +1509,11 @@ void DeserializeFromExpr_discover_type_int(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_negative_int(void) {
+void Deserialize_discover_type_negative_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "-10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-10", &v, NULL) != NULL);
     test_uint(v.type, ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(int64_t*)v.ptr, -10);
@@ -1366,11 +1522,11 @@ void DeserializeFromExpr_discover_type_negative_int(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_float(void) {
+void Deserialize_discover_type_float(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5", &v, NULL) != NULL);
     test_uint(v.type, ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 10.5);
@@ -1379,11 +1535,11 @@ void DeserializeFromExpr_discover_type_float(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_negative_float(void) {
+void Deserialize_discover_type_negative_float(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "-10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-10.5", &v, NULL) != NULL);
     test_uint(v.type, ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, -10.5);
@@ -1392,11 +1548,11 @@ void DeserializeFromExpr_discover_type_negative_float(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_string(void) {
+void Deserialize_discover_type_string(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "\"foo\"", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "\"foo\"", &v, NULL) != NULL);
     test_uint(v.type, ecs_id(ecs_string_t));
     test_assert(v.ptr != NULL);
     test_str(*(ecs_string_t*)v.ptr, "foo");
@@ -1405,11 +1561,11 @@ void DeserializeFromExpr_discover_type_string(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_multiline_string(void) {
+void Deserialize_discover_type_multiline_string(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "`foo\nbar`", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "`foo\nbar`", &v, NULL) != NULL);
     test_uint(v.type, ecs_id(ecs_string_t));
     test_assert(v.ptr != NULL);
     test_str(*(ecs_string_t*)v.ptr, "foo\nbar");
@@ -1418,13 +1574,13 @@ void DeserializeFromExpr_discover_type_multiline_string(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_entity(void) {
+void Deserialize_discover_type_entity(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t foo = ecs_new_entity(world, "foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "foo" });
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "foo", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "foo", &v, NULL) != NULL);
     test_uint(v.type, ecs_id(ecs_entity_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_entity_t*)v.ptr, foo);
@@ -1433,18 +1589,18 @@ void DeserializeFromExpr_discover_type_entity(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_bool(void) {
+void Deserialize_discover_type_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true", &v, NULL) != NULL);
     test_uint(v.type, ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(ecs_bool_t*)v.ptr, true);
     ecs_value_free(world, v.type, v.ptr);
 
     ecs_os_zeromem(&v);
-    test_assert(ecs_parse_expr(world, "false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false", &v, NULL) != NULL);
     test_uint(v.type, ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(ecs_bool_t*)v.ptr, false);
@@ -1453,25 +1609,25 @@ void DeserializeFromExpr_discover_type_bool(void) {
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_unknown(void) {
+void Deserialize_discover_type_unknown(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
 
     ecs_log_set_level(-4);
-    test_assert(ecs_parse_expr(world, "{10}", &v, NULL) == NULL);
-    test_assert(ecs_parse_expr(world, "[10]", &v, NULL) == NULL);
+    test_assert(ecs_script_expr_run(world, "{10}", &v, NULL) == NULL);
+    test_assert(ecs_script_expr_run(world, "[10]", &v, NULL) == NULL);
 
     ecs_fini(world);
 }
 
-void DeserializeFromExpr_discover_type_invalid(void) {
+void Deserialize_discover_type_invalid(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
 
     ecs_log_set_level(-4);
-    test_assert(ecs_parse_expr(world, "-", &v, NULL) == NULL);
+    test_assert(ecs_script_expr_run(world, "-", &v, NULL) == NULL);
 
     ecs_fini(world);
 }
diff --git a/test/addons/src/Plecs.c b/test/script/src/Eval.c
similarity index 58%
rename from test/addons/src/Plecs.c
rename to test/script/src/Eval.c
index d8688426a..aecfe1c56 100644
--- a/test/addons/src/Plecs.c
+++ b/test/script/src/Eval.c
@@ -1,76 +1,73 @@
-#include <addons.h>
+#include <script.h>
 
-#define HEAD
-#define LINE "\n"
-
-void Plecs_null(void) {
+void Eval_null(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, NULL) == 0);
+    test_assert(ecs_script_run(world, NULL, NULL) == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_empty(void) {
+void Eval_empty(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "") == 0);
+    test_assert(ecs_script_run(world, NULL, "") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_space(void) {
+void Eval_space(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, " ") == 0);
+    test_assert(ecs_script_run(world, NULL, " ") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_space_newline(void) {
+void Eval_space_newline(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, " \n \n") == 0);
+    test_assert(ecs_script_run(world, NULL, " \n \n") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_two_empty_newlines(void) {
+void Eval_two_empty_newlines(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "\n\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "\n\n") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_three_empty_newlines(void) {
+void Eval_three_empty_newlines(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "\n\n\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "\n\n\n") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_newline_trailing_space(void) {
+void Eval_newline_trailing_space(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "\n ") == 0);
+    test_assert(ecs_script_run(world, NULL, "\n ") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_newline_trailing_spaces(void) {
+void Eval_newline_trailing_spaces(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "\n   ") == 0);
+    test_assert(ecs_script_run(world, NULL, "\n   ") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_multiple_trailing_newlines(void) {
+void Eval_multiple_trailing_newlines(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo\n\n\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "Foo{}\n\n\n") == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -80,10 +77,10 @@ void Plecs_multiple_trailing_newlines(void) {
     ecs_fini(world);
 }
 
-void Plecs_entity(void) {
+void Eval_entity(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo") == 0);
+    test_assert(ecs_script_run(world, NULL, "Foo{}") == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -93,310 +90,388 @@ void Plecs_entity(void) {
     ecs_fini(world);
 }
 
-void Plecs_entity_w_entity(void) {
+void Eval_entity_w_core_name(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo(Subj)") == 0);
+    test_assert(ecs_script_run(world, NULL, "World{}") == 0);
 
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t foo = ecs_lookup_child(world, 0, "World");
     test_assert(foo != 0);
-    test_str(ecs_get_name(world, foo), "Foo");
+    test_assert(foo != EcsWorld);
+    test_str(ecs_get_name(world, foo), "World");
+    test_int(ecs_get_type(world, foo)->count, 1);
+
+    ecs_fini(world);
+}
+
+void Eval_2_entities(void) {
+    ecs_world_t *world = ecs_init();
 
-    ecs_entity_t subj = ecs_lookup(world, "Subj");
-    test_assert(subj != 0);
-    test_str(ecs_get_name(world, subj), "Subj");
+    test_assert(ecs_script_run(world, NULL, "Foo{}\nBar{}\n") == 0);
 
-    test_assert(ecs_has_id(world, subj, foo));
+    ecs_entity_t e = ecs_lookup(world, "Foo");
+    test_assert(e != 0);
+    test_str(ecs_get_name(world, e), "Foo");
 
     ecs_fini(world);
 }
 
-void Plecs_entity_w_pair(void) {
+void Eval_line_comment(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Rel(Subj, Obj)") == 0);
+    test_assert(ecs_script_run(world, NULL, "// Foo{}\n") == 0);
 
-    ecs_entity_t rel = ecs_lookup(world, "Rel");
-    test_assert(rel != 0);
-    test_str(ecs_get_name(world, rel), "Rel");
+    test_assert(ecs_lookup(world, "Foo") == 0);
 
-    ecs_entity_t obj = ecs_lookup(world, "Obj");
-    test_assert(obj != 0);
-    test_str(ecs_get_name(world, obj), "Obj");
+    ecs_fini(world);
+}
+
+void Eval_line_comment_before_stmt(void) {
+    ecs_world_t *world = ecs_init();
 
-    ecs_entity_t subj = ecs_lookup(world, "Subj");
-    test_assert(subj != 0);
-    test_str(ecs_get_name(world, subj), "Subj");
+    test_assert(ecs_script_run(world, NULL, "// Hello\nFoo {}\n") == 0);
 
-    test_assert(ecs_has_pair(world, subj, rel, obj));
+    test_assert(ecs_lookup(world, "Hello") == 0);
+    test_assert(ecs_lookup(world, "Foo") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_2_entities(void) {
+void Eval_line_comment_after_stmt(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo\nBar\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "Foo{}\n// Hello\n") == 0);
 
-    ecs_entity_t e = ecs_lookup(world, "Foo");
-    test_assert(e != 0);
-    test_str(ecs_get_name(world, e), "Foo");
+    test_assert(ecs_lookup(world, "Hello") == 0);
+    test_assert(ecs_lookup(world, "Foo") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_2_entities_w_entities(void) {
+void Eval_line_comment_between_stmt(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo(Subj_1)\nBar(Subj_2)\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "Foo{}\n// Hello\nBar{}\n") == 0);
 
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    test_assert(foo != 0);
-    test_str(ecs_get_name(world, foo), "Foo");
+    test_assert(ecs_lookup(world, "Hello") == 0);
+    test_assert(ecs_lookup(world, "Foo") != 0);
+    test_assert(ecs_lookup(world, "Bar") != 0);
 
-    ecs_entity_t bar = ecs_lookup(world, "Bar");
-    test_assert(bar != 0);
-    test_str(ecs_get_name(world, bar), "Bar");
+    ecs_fini(world);
+}
+
+void Eval_multiple_line_comment(void) {
+    ecs_world_t *world = ecs_init();
+
+    test_assert(ecs_script_run(world, NULL, "// Hello\n// World\nFoo{}") == 0);
+
+    test_assert(ecs_lookup(world, "Hello") == 0);
+    test_assert(ecs_lookup_child(world, 0, "World") == 0);
+    test_assert(ecs_lookup(world, "Foo") != 0);
+
+    ecs_fini(world);
+}
+
+void Eval_multiple_line_comment_w_newlines(void) {
+    ecs_world_t *world = ecs_init();
+
+    test_assert(ecs_script_run(world, NULL, "// Hello\n\n// World\n\nFoo{}") == 0);
+
+    test_assert(ecs_lookup(world, "Hello") == 0);
+    test_assert(ecs_lookup_child(world, 0, "World") == 0);
+    test_assert(ecs_lookup(world, "Foo") != 0);
+
+    ecs_fini(world);
+}
+
+void Eval_line_comment_after_stmt_same_line(void) {
+    ecs_world_t *world = ecs_init();
+
+    test_assert(ecs_script_run(world, NULL, "Foo{} // Hello\nBar{}\n") == 0);
+
+    test_assert(ecs_lookup(world, "Hello") == 0);
+    test_assert(ecs_lookup(world, "Foo") != 0);
+    test_assert(ecs_lookup(world, "Bar") != 0);
+
+    ecs_fini(world);
+}
+
+void Eval_line_comment_before_scope_open(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Parent // Some Comment()"
+    LINE "{"
+    LINE " Child{}"
+    LINE "}"
+    LINE "Foo{}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    test_assert(ecs_lookup(world, "Child") == 0);
+
+    test_assert(ecs_lookup(world, "Some") == 0);
+    test_assert(ecs_lookup(world, "Comment") == 0);
 
-    ecs_entity_t subj_1 = ecs_lookup(world, "Subj_1");
-    test_assert(subj_1 != 0);
-    test_str(ecs_get_name(world, subj_1), "Subj_1");
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t child = ecs_lookup(world, "Parent.Child");
 
-    ecs_entity_t subj_2 = ecs_lookup(world, "Subj_2");
-    test_assert(subj_2 != 0);
-    test_str(ecs_get_name(world, subj_2), "Subj_2");
+    test_assert(parent != 0);
+    test_assert(child != 0);
 
-    test_assert(ecs_has_id(world, subj_1, foo));
-    test_assert(ecs_has_id(world, subj_2, bar));
+    test_assert(ecs_has_pair(world, child, EcsChildOf, parent));
 
     ecs_fini(world);
 }
 
-void Plecs_3_entities_w_pairs(void) {
+void Eval_line_comment_after_newline_before_scope_open(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, 
-        "Rel_1(Subj_1, Obj_1)\n"
-        "Rel_1(Subj_2, Obj_2)\n"
-        "Rel_2(Subj_3, Obj_2)\n") == 0);
+    const char *expr =
+    HEAD "Parent"
+    LINE "// Some Comment()"
+    LINE "{"
+    LINE " Child{}"
+    LINE "}"
+    LINE "Foo{}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    test_assert(ecs_lookup(world, "Child") == 0);
+
+    test_assert(ecs_lookup(world, "Some") == 0);
+    test_assert(ecs_lookup(world, "Comment") == 0);
+
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t child = ecs_lookup(world, "Parent.Child");
+
+    test_assert(parent != 0);
+    test_assert(child != 0);
+
+    test_assert(ecs_has_pair(world, child, EcsChildOf, parent));
+
+    ecs_fini(world);
+}
 
-    ecs_entity_t rel_1 = ecs_lookup(world, "Rel_1");
-    test_assert(rel_1 != 0);
-    test_str(ecs_get_name(world, rel_1), "Rel_1");
+void Eval_line_comment_after_newline_before_newline_scope_open(void) {
+    ecs_world_t *world = ecs_init();
 
-    ecs_entity_t rel_2 = ecs_lookup(world, "Rel_2");
-    test_assert(rel_2 != 0);
-    test_str(ecs_get_name(world, rel_2), "Rel_2");
+    const char *expr =
+    HEAD "Parent"
+    LINE "// Some Comment()"
+    LINE ""
+    LINE "{"
+    LINE " Child{}"
+    LINE "}"
+    LINE "Foo{}";
 
-    ecs_entity_t obj_1 = ecs_lookup(world, "Obj_1");
-    test_assert(obj_1 != 0);
-    test_str(ecs_get_name(world, obj_1), "Obj_1");
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t obj_2 = ecs_lookup(world, "Obj_2");
-    test_assert(obj_2 != 0);
-    test_str(ecs_get_name(world, obj_2), "Obj_2");
+    test_assert(ecs_lookup(world, "Child") == 0);
 
-    ecs_entity_t subj_1 = ecs_lookup(world, "Subj_1");
-    test_assert(subj_1 != 0);
-    test_str(ecs_get_name(world, subj_1), "Subj_1");
+    test_assert(ecs_lookup(world, "Some") == 0);
+    test_assert(ecs_lookup(world, "Comment") == 0);
 
-    ecs_entity_t subj_2 = ecs_lookup(world, "Subj_2");
-    test_assert(subj_2 != 0);
-    test_str(ecs_get_name(world, subj_2), "Subj_2");
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t child = ecs_lookup(world, "Parent.Child");
 
-    ecs_entity_t subj_3 = ecs_lookup(world, "Subj_3");
-    test_assert(subj_3 != 0);
-    test_str(ecs_get_name(world, subj_3), "Subj_3");  
+    test_assert(parent != 0);
+    test_assert(child != 0);
 
-    test_assert(ecs_has_pair(world, subj_1, rel_1, obj_1));
-    test_assert(ecs_has_pair(world, subj_2, rel_1, obj_2));
-    test_assert(ecs_has_pair(world, subj_3, rel_2, obj_2));
+    test_assert(ecs_has_pair(world, child, EcsChildOf, parent));
 
     ecs_fini(world);
 }
 
-void Plecs_line_comment(void) {
+void Eval_multi_line_comment(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "// Foo(Bar)\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "/* Foo{} */") == 0);
 
     test_assert(ecs_lookup(world, "Foo") == 0);
-    test_assert(ecs_lookup(world, "Bar") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_line_comment_before_stmt(void) {
+void Eval_multi_line_comment_before_stmt(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "// Hello(World)\nFoo\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "/* Hello */\nFoo {}") == 0);
 
     test_assert(ecs_lookup(world, "Hello") == 0);
-    test_assert(ecs_lookup_child(world, 0, "World") == 0);
     test_assert(ecs_lookup(world, "Foo") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_line_comment_after_stmt(void) {
+void Eval_multi_line_comment_after_stmt(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo\n// Hello(World)\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "Foo{}\n/* Hello */") == 0);
 
     test_assert(ecs_lookup(world, "Hello") == 0);
-    test_assert(ecs_lookup_child(world, 0, "World") == 0);
     test_assert(ecs_lookup(world, "Foo") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_line_comment_between_stmt(void) {
+void Eval_multi_line_comment_between_stmt(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo\n// Hello(World)\nBar\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "Foo{}\n /* Hello */ Bar{}\n") == 0);
 
     test_assert(ecs_lookup(world, "Hello") == 0);
-    test_assert(ecs_lookup_child(world, 0, "World") == 0);
     test_assert(ecs_lookup(world, "Foo") != 0);
     test_assert(ecs_lookup(world, "Bar") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_multiple_line_comment(void) {
+void Eval_multiple_multi_line_comment(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "// Hello(World)\n// Boo(Baz)\nFoo") == 0);
+    test_assert(ecs_script_run(world, NULL, "/* Hello *//* World*/ Foo{}") == 0);
 
     test_assert(ecs_lookup(world, "Hello") == 0);
     test_assert(ecs_lookup_child(world, 0, "World") == 0);
-    test_assert(ecs_lookup(world, "Boo") == 0);
-    test_assert(ecs_lookup(world, "Baz") == 0);
     test_assert(ecs_lookup(world, "Foo") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_line_comment_after_stmt_same_line(void) {
+void Eval_multiple_multi_line_comment_w_newlines(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo // Hello(World)\nBar\n") == 0);
+    test_assert(ecs_script_run(world, NULL, "/* Hello */\n/* World */ Foo{}") == 0);
 
     test_assert(ecs_lookup(world, "Hello") == 0);
     test_assert(ecs_lookup_child(world, 0, "World") == 0);
     test_assert(ecs_lookup(world, "Foo") != 0);
-    test_assert(ecs_lookup(world, "Bar") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_comma_separated_pred(void) {
+void Eval_multi_line_comment_after_stmt_same_line(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo,Bar,Hello,Worlds") == 0);
+    test_assert(ecs_script_run(world, NULL, "Foo{} /* Hello */\nBar{}\n") == 0);
 
-    test_assert(ecs_lookup(world, "Hello") != 0);
-    test_assert(ecs_lookup(world, "Worlds") != 0);
+    test_assert(ecs_lookup(world, "Hello") == 0);
     test_assert(ecs_lookup(world, "Foo") != 0);
     test_assert(ecs_lookup(world, "Bar") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_comma_separated_pred_w_subj(void) {
+void Eval_multi_line_comment_before_scope_open(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo(Bar),Hello(Worlds)") == 0);
+    const char *expr =
+    HEAD "Parent /* Some Comment() */"
+    LINE "{"
+    LINE " Child{}"
+    LINE "}"
+    LINE "Foo{}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t bar = ecs_lookup(world, "Bar");
-    ecs_entity_t hello = ecs_lookup(world, "Hello");
-    ecs_entity_t _world = ecs_lookup(world, "Worlds");
+    test_assert(ecs_lookup(world, "Child") == 0);
 
-    test_assert(foo != 0);
-    test_assert(bar != 0);
-    test_assert(hello != 0);
-    test_assert(_world != 0);
+    test_assert(ecs_lookup(world, "Some") == 0);
+    test_assert(ecs_lookup(world, "Comment") == 0);
 
-    test_assert(ecs_has_id(world, bar, foo));
-    test_assert(ecs_has_id(world, _world, hello));
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t child = ecs_lookup(world, "Parent.Child");
+
+    test_assert(parent != 0);
+    test_assert(child != 0);
+
+    test_assert(ecs_has_pair(world, child, EcsChildOf, parent));
 
     ecs_fini(world);
 }
 
-void Plecs_comma_separated_pred_w_subj_obj(void) {
+void Eval_multi_line_comment_after_newline_before_scope_open(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo(Bar, Obj1),Hello(Worlds, Obj2)") == 0);
-
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t bar = ecs_lookup(world, "Bar");
-    ecs_entity_t hello = ecs_lookup(world, "Hello");
-    ecs_entity_t _world = ecs_lookup(world, "Worlds");
-    ecs_entity_t obj1 = ecs_lookup(world, "Obj1");
-    ecs_entity_t obj2 = ecs_lookup(world, "Obj2");
+    const char *expr =
+    HEAD "Parent"
+    LINE "/* Some Comment() */"
+    LINE "{"
+    LINE " Child{}"
+    LINE "}"
+    LINE "Foo{}";
 
-    test_assert(foo != 0);
-    test_assert(bar != 0);
-    test_assert(hello != 0);
-    test_assert(_world != 0);
-    test_assert(obj1 != 0);
-    test_assert(obj2 != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_has_pair(world, bar, foo, obj1));
-    test_assert(ecs_has_pair(world, _world, hello, obj2));
+    test_assert(ecs_lookup(world, "Child") == 0);
 
-    ecs_fini(world);
-}
+    test_assert(ecs_lookup(world, "Some") == 0);
+    test_assert(ecs_lookup(world, "Comment") == 0);
 
-void Plecs_comma_separated_pred_trailing_comma(void) {
-    ecs_world_t *world = ecs_init();
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t child = ecs_lookup(world, "Parent.Child");
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo,Bar,Hello,Worlds,") == 0);
+    test_assert(parent != 0);
+    test_assert(child != 0);
 
-    test_assert(ecs_lookup(world, "Hello") != 0);
-    test_assert(ecs_lookup(world, "Worlds") != 0);
-    test_assert(ecs_lookup(world, "Foo") != 0);
-    test_assert(ecs_lookup(world, "Bar") != 0);
+    test_assert(ecs_has_pair(world, child, EcsChildOf, parent));
 
     ecs_fini(world);
 }
 
-void Plecs_comma_separated_pred_trailing_comma_newline(void) {
+void Eval_multi_line_comment_after_newline_before_newline_scope_open(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo,Bar,Hello,Worlds,\n") == 0);
+    const char *expr =
+    HEAD "Parent"
+    LINE "/* Some Comment() */"
+    LINE ""
+    LINE "{"
+    LINE " Child{}"
+    LINE "}"
+    LINE "Foo{}";
 
-    test_assert(ecs_lookup(world, "Hello") != 0);
-    test_assert(ecs_lookup(world, "Worlds") != 0);
-    test_assert(ecs_lookup(world, "Foo") != 0);
-    test_assert(ecs_lookup(world, "Bar") != 0);
+    ecs_log_set_level(-4); /* Newline after multiline comment is not ignored */
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_comma_separated_pred_trailing_comma_newline_multiline(void) {
+void Eval_multi_line_comment_multiple_lines(void) {
     ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_plecs_from_str(world, NULL, "Foo,Bar,\nHello,Worlds,") == 0);
+    const char *expr =
+    HEAD "Foo {}"
+    LINE "/* Some{}"
+    LINE " * Multi Line{}"
+    LINE " * Comment{}"
+    LINE " */"
+    LINE ""
+    LINE "Bar {}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_lookup(world, "Hello") != 0);
-    test_assert(ecs_lookup(world, "Worlds") != 0);
     test_assert(ecs_lookup(world, "Foo") != 0);
     test_assert(ecs_lookup(world, "Bar") != 0);
 
+    test_assert(ecs_lookup(world, "Some") == 0);
+    test_assert(ecs_lookup(world, "Multi") == 0);
+    test_assert(ecs_lookup(world, "Line") == 0);
+    test_assert(ecs_lookup(world, "Comment") == 0);
+
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_1_child(void) {
+void Eval_hierarchy_1_child(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent {"
-    LINE " Child"
+    LINE " Child {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "Child") == 0);
 
@@ -411,16 +486,16 @@ void Plecs_hierarchy_1_child(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_2_children(void) {
+void Eval_hierarchy_2_children(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent {"
-    LINE " ChildA"
-    LINE " ChildB"
+    LINE " ChildA{}"
+    LINE " ChildB{}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "ChildA") == 0);
     test_assert(ecs_lookup(world, "ChildB") == 0);
@@ -439,13 +514,13 @@ void Plecs_hierarchy_2_children(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_1_child_same_line(void) {
+void Eval_hierarchy_1_child_same_line(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Parent { Child }";
+    HEAD "Parent { Child{} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "Child") == 0);
 
@@ -460,13 +535,38 @@ void Plecs_hierarchy_1_child_same_line(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_2_children_same_line(void) {
+void Eval_hierarchy_2_children_same_line(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Parent { ChildA, ChildB, }";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    test_assert(ecs_lookup(world, "ChildA") == 0);
+    test_assert(ecs_lookup(world, "ChildB") == 0);
+
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t child_a = ecs_lookup(world, "Parent.ChildA");
+    ecs_entity_t child_b = ecs_lookup(world, "Parent.ChildB");
+
+    test_assert(parent != 0);
+    test_assert(child_a != 0);
+    test_assert(child_b != 0);
+
+    test_assert(ecs_has_pair(world, child_a, EcsChildOf, parent));
+    test_assert(ecs_has_pair(world, child_b, EcsChildOf, parent));
+
+    ecs_fini(world);
+}
+
+void Eval_hierarchy_2_children_same_line_no_trailing_comma(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent { ChildA, ChildB }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "ChildA") == 0);
     test_assert(ecs_lookup(world, "ChildB") == 0);
@@ -485,16 +585,16 @@ void Plecs_hierarchy_2_children_same_line(void) {
     ecs_fini(world);
 }
 
-void Plecs_entity_after_hierarchy(void) {
+void Eval_entity_after_hierarchy(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent {"
-    LINE " Child"
+    LINE " Child{}"
     LINE "}"
-    LINE "Foo";
+    LINE "Foo{}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "Child") == 0);
 
@@ -513,17 +613,17 @@ void Plecs_entity_after_hierarchy(void) {
     ecs_fini(world);
 }
 
-void Plecs_newline_before_scope_open(void) {
+void Eval_newline_before_scope_open(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent"
     LINE "{"
-    LINE " Child"
+    LINE " Child{}"
     LINE "}"
-    LINE "Foo";
+    LINE "Foo{}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "Child") == 0);
 
@@ -538,23 +638,20 @@ void Plecs_newline_before_scope_open(void) {
     ecs_fini(world);
 }
 
-void Plecs_comment_before_scope_open(void) {
+void Eval_newline_w_whitespace_before_scope_open(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Parent // Some(Comment)"
-    LINE "{"
-    LINE " Child"
+    HEAD "Parent"
+    LINE "  {"
+    LINE " Child{}"
     LINE "}"
-    LINE "Foo";
+    LINE "Foo{}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "Child") == 0);
 
-    test_assert(ecs_lookup(world, "Some") == 0);
-    test_assert(ecs_lookup(world, "Comment") == 0);
-
     ecs_entity_t parent = ecs_lookup(world, "Parent");
     ecs_entity_t child = ecs_lookup(world, "Parent.Child");
 
@@ -566,23 +663,46 @@ void Plecs_comment_before_scope_open(void) {
     ecs_fini(world);
 }
 
-void Plecs_comment_after_newline_before_scope_open(void) {
+void Eval_2_newline_before_scope_open(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent"
-    LINE "// Some(Comment)"
+    LINE ""
     LINE "{"
-    LINE " Child"
+    LINE " Child{}"
     LINE "}"
-    LINE "Foo";
+    LINE "Foo{}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "Child") == 0);
 
-    test_assert(ecs_lookup(world, "Some") == 0);
-    test_assert(ecs_lookup(world, "Comment") == 0);
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t child = ecs_lookup(world, "Parent.Child");
+
+    test_assert(parent != 0);
+    test_assert(child != 0);
+
+    test_assert(ecs_has_pair(world, child, EcsChildOf, parent));
+
+    ecs_fini(world);
+}
+
+void Eval_2_newline_w_whitespace_before_scope_open(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Parent"
+    LINE "  "
+    LINE " {"
+    LINE " Child{}"
+    LINE "}"
+    LINE "Foo{}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    test_assert(ecs_lookup(world, "Child") == 0);
 
     ecs_entity_t parent = ecs_lookup(world, "Parent");
     ecs_entity_t child = ecs_lookup(world, "Parent.Child");
@@ -595,17 +715,17 @@ void Plecs_comment_after_newline_before_scope_open(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_2_levels(void) {
+void Eval_hierarchy_2_levels(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent {"
     LINE " Child {"
-    LINE "  GrandChild"
+    LINE "  GrandChild {}"
     LINE " }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "Child") == 0);
     test_assert(ecs_lookup(world, "GrandChild") == 0);
@@ -624,20 +744,20 @@ void Plecs_hierarchy_2_levels(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_2_levels_2_subtrees(void) {
+void Eval_hierarchy_2_levels_2_subtrees(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent {"
     LINE " ChildA {"
-    LINE "  GrandChild"
+    LINE "  GrandChild {}"
     LINE " }"
     LINE " ChildB {"
-    LINE "  GrandChild"
+    LINE "  GrandChild {}"
     LINE " }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "ChildA") == 0);
     test_assert(ecs_lookup(world, "ChildB") == 0);
@@ -665,31 +785,15 @@ void Plecs_hierarchy_2_levels_2_subtrees(void) {
     ecs_fini(world);
 }
 
-void Plecs_missing_end_of_scope(void) {
+void Eval_missing_end_of_scope(void) {
     ecs_log_set_level(-4);
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent {"
-    LINE " Child";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
-
-    test_assert(ecs_get_scope(world) == 0);
-    test_assert(ecs_get_with(world) == 0);
-
-    ecs_fini(world);
-}
-
-void Plecs_missing_end_of_predicate_scope(void) {
-    ecs_log_set_level(-4);
-    ecs_world_t *world = ecs_init();
-
-    const char *expr =
-    HEAD "Parent() {"
-    LINE " Child";
+    LINE " Child {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     test_assert(ecs_get_scope(world) == 0);
     test_assert(ecs_get_with(world) == 0);
@@ -697,7 +801,7 @@ void Plecs_missing_end_of_predicate_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_create_in_scope(void) {
+void Eval_create_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_TAG(world, Root);
@@ -705,9 +809,9 @@ void Plecs_create_in_scope(void) {
     ecs_set_scope(world, Root);
 
     const char *expr =
-    HEAD "Parent { Child }";
+    HEAD "Parent { Child{} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_get_scope(world) == Root);
 
@@ -727,15 +831,15 @@ void Plecs_create_in_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_w_pred_subj(void) {
+void Eval_hierarchy_w_pred_subj(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Foo(Bar) {"
-    LINE " Child"
+    HEAD "Foo Bar {"
+    LINE " Child{}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     test_assert(ecs_lookup(world, "Child") == 0);
 
@@ -753,15 +857,15 @@ void Plecs_hierarchy_w_pred_subj(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_custom_relation(void) {
+void Eval_hierarchy_custom_relation(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "(Foo, Bar) {"
-    LINE " Child"
+    LINE " Child{}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -780,22 +884,22 @@ void Plecs_hierarchy_custom_relation(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_custom_relation_2_levels(void) {
+void Eval_hierarchy_custom_relation_2_levels(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "(Foo, Bar) {"
     LINE "  (Rel, ObjA) {"
-    LINE "    Child"
-    LINE "    ChildA"
+    LINE "    Child{}"
+    LINE "    ChildA{}"
     LINE "  }"
     LINE "  (Rel, ObjB) {"
-    LINE "    Child"
-    LINE "    ChildB"
+    LINE "    Child{}"
+    LINE "    ChildB{}"
     LINE "  }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -836,16 +940,16 @@ void Plecs_hierarchy_custom_relation_2_levels(void) {
     ecs_fini(world);
 }
 
-void Plecs_entity_after_hierarchy_custom_relation(void) {
+void Eval_entity_after_hierarchy_custom_relation(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "(Foo, Bar) {"
-    LINE " Child"
+    LINE " Child{}"
     LINE "}"
-    LINE "Hello";
+    LINE "Hello{}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -867,24 +971,24 @@ void Plecs_entity_after_hierarchy_custom_relation(void) {
     ecs_fini(world);
 }
 
-void Plecs_entity_after_hierarchy_custom_relation_2_levels(void) {
+void Eval_entity_after_hierarchy_custom_relation_2_levels(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "(Foo, Bar) {"
     LINE "  (Rel, ObjA) {"
-    LINE "    Child"
-    LINE "    ChildA"
+    LINE "    Child{}"
+    LINE "    ChildA{}"
     LINE "  }"
-    LINE "  TestA"
+    LINE "  TestA {}"
     LINE "  (Rel, ObjB) {"
-    LINE "    Child"
-    LINE "    ChildB"
+    LINE "    Child{}"
+    LINE "    ChildB{}"
     LINE "  }"
     LINE "}"
-    LINE "TestB";
+    LINE "TestB{}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -937,17 +1041,17 @@ void Plecs_entity_after_hierarchy_custom_relation_2_levels(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_custom_relation_apply_to_object(void) {
+void Eval_hierarchy_custom_relation_apply_to_object(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "(Rel, ObjA) {"
     LINE " (Rel, ObjB) {"
-    LINE "   ObjC"
+    LINE "   ObjC{}"
     LINE " }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t rel = ecs_lookup(world, "Rel");
     ecs_entity_t obj_a = ecs_lookup(world, "ObjA");
@@ -966,19 +1070,19 @@ void Plecs_hierarchy_custom_relation_apply_to_object(void) {
     ecs_fini(world);
 }
 
-void Plecs_hierarchy_custom_relation_apply_to_object_2_levels(void) {
+void Eval_hierarchy_custom_relation_apply_to_object_2_levels(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "(Rel, ObjA) {"
     LINE " (Rel, ObjB) {"
     LINE "   (Rel, ObjC) {"
-    LINE "     ObjD"
+    LINE "     ObjD{}"
     LINE "   }"
     LINE " }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t rel = ecs_lookup(world, "Rel");
     ecs_entity_t obj_a = ecs_lookup(world, "ObjA");
@@ -1002,127 +1106,59 @@ void Plecs_hierarchy_custom_relation_apply_to_object_2_levels(void) {
     ecs_fini(world);
 }
 
-void Plecs_pred_scope(void) {
+void Eval_with_tag(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Foo() {"
-    LINE " Hello"
+    HEAD "with Tag {"
+    LINE "  Foo{}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t hello = ecs_lookup(world, "Foo.Hello");
+    ecs_entity_t tag = ecs_lookup(world, "Tag");
 
     test_assert(foo != 0);
-    test_assert(hello != 0);
+    test_assert(tag != 0);
 
-    test_assert(ecs_has_pair(world, hello, EcsChildOf, foo));
-    test_assert(!ecs_has_id(world, hello, foo));
+    test_assert(ecs_has_id(world, foo, tag));
 
     ecs_fini(world);
 }
 
-void Plecs_pred_scope_2_levels(void) {
+void Eval_with_tag_2_entities(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Foo() {"
-    LINE "  Bar() {"
-    LINE "    Hello"
-    LINE "  }"
+    HEAD "with Tag {"
+    LINE "  Foo{}"
+    LINE "  Bar{}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
-    ecs_entity_t hello = ecs_lookup(world, "Bar.Hello");
-
-    test_assert(foo != 0);
-    test_assert(bar != 0);
-    test_assert(hello != 0);
-
-    test_assert(!ecs_has_pair(world, hello, EcsChildOf, foo));
-    test_assert(ecs_has_pair(world, hello, EcsChildOf, bar));
-    test_assert(!ecs_has_id(world, hello, foo));
-    test_assert(!ecs_has_id(world, hello, bar));
-
-    test_assert(!ecs_has_pair(world, bar, EcsChildOf, foo));
-    test_assert(!ecs_has_id(world, bar, foo));
-
-    ecs_fini(world);
-}
-
-void Plecs_pred_scope_inside_with(void) {
-    ecs_world_t *world = ecs_init();
-
-    const char *expr =
-    HEAD "with Tag {"
-    HEAD " Foo() {"
-    LINE "  Hello"
-    LINE " }"
-    LINE "}";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
     ecs_entity_t tag = ecs_lookup(world, "Tag");
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t hello = ecs_lookup(world, "Foo.Hello");
 
     test_assert(foo != 0);
-    test_assert(hello != 0);
+    test_assert(bar != 0);
     test_assert(tag != 0);
 
-    test_assert(ecs_has_pair(world, hello, EcsChildOf, foo));
-    test_assert(!ecs_has_id(world, hello, foo));
-    test_assert(ecs_has_id(world, hello, tag));
-
-    test_assert(!ecs_has_id(world, foo, tag));
-
-    ecs_fini(world);
-}
-
-void Plecs_pred_scope_nested_w_subj_scope(void) {
-    ecs_world_t *world = ecs_init();
-
-    const char *expr =
-    HEAD "Parent {"
-    HEAD " Foo() {"
-    LINE "  Hello"
-    LINE " }"
-    LINE "}";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t parent = ecs_lookup(world, "Parent");
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t hello = ecs_lookup(world, "Foo.Hello");
-
-    test_assert(parent != 0);
-    test_assert(foo != 0);
-    test_assert(hello != 0);
-
-    test_assert(!ecs_has_pair(world, hello, EcsChildOf, parent));
-    test_assert(ecs_has_pair(world, hello, EcsChildOf, foo));
-    test_assert(!ecs_has_id(world, hello, foo));
-
-    test_assert(!ecs_has_pair(world, foo, EcsChildOf, parent));
+    test_assert(ecs_has_id(world, foo, tag));
+    test_assert(ecs_has_id(world, bar, tag));
 
     ecs_fini(world);
 }
 
-
-void Plecs_with_tag(void) {
+void Eval_with_tag_same_line(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "with Tag {"
-    LINE "  Foo"
-    LINE "}";
+    HEAD "with Tag { Foo{} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t tag = ecs_lookup(world, "Tag");
@@ -1135,16 +1171,13 @@ void Plecs_with_tag(void) {
     ecs_fini(world);
 }
 
-void Plecs_with_tag_2_entities(void) {
+void Eval_with_tag_2_entities_same_line(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "with Tag {"
-    LINE "  Foo"
-    LINE "  Bar"
-    LINE "}";
+    HEAD "with Tag { Foo, Bar, }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -1160,32 +1193,13 @@ void Plecs_with_tag_2_entities(void) {
     ecs_fini(world);
 }
 
-void Plecs_with_tag_same_line(void) {
-    ecs_world_t *world = ecs_init();
-
-    const char *expr =
-    HEAD "with Tag { Foo }";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t tag = ecs_lookup(world, "Tag");
-
-    test_assert(foo != 0);
-    test_assert(tag != 0);
-
-    test_assert(ecs_has_id(world, foo, tag));
-
-    ecs_fini(world);
-}
-
-void Plecs_with_tag_2_entities_same_line(void) {
+void Eval_with_tag_2_entities_same_line_no_trailing_comma(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "with Tag { Foo, Bar }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -1201,17 +1215,17 @@ void Plecs_with_tag_2_entities_same_line(void) {
     ecs_fini(world);
 }
 
-void Plecs_with_tag_2_levels(void) {
+void Eval_with_tag_2_levels(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "with TagA {"
     HEAD " with TagB {"
-    LINE "  Foo"
+    LINE "  Foo {}"
     LINE " }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t tag_a = ecs_lookup(world, "TagA");
@@ -1227,22 +1241,22 @@ void Plecs_with_tag_2_levels(void) {
     ecs_fini(world);
 }
 
-void Plecs_with_tag_2_levels_2_subtrees(void) {
+void Eval_with_tag_2_levels_2_subtrees(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "with TagA {"
     HEAD " with TagB {"
-    LINE "  Foo"
-    LINE "  BarA"
+    LINE "  Foo {}"
+    LINE "  BarA {}"
     LINE " }"
     HEAD " with TagC {"
-    LINE "  Foo"
-    LINE "  BarB"
+    LINE "  Foo {}"
+    LINE "  BarB {}"
     LINE " }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t tag_a = ecs_lookup(world, "TagA");
@@ -1273,16 +1287,16 @@ void Plecs_with_tag_2_levels_2_subtrees(void) {
     ecs_fini(world);
 }
 
-void Plecs_with_n_tags(void) {
+void Eval_with_n_tags(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "with TagA, TagB {"
-    LINE " Foo"
-    LINE " Bar"
+    LINE " Foo {}"
+    LINE " Bar {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -1303,23 +1317,23 @@ void Plecs_with_n_tags(void) {
     ecs_fini(world);
 }
 
-void Plecs_with_n_tags_2_levels(void) {
+void Eval_with_n_tags_2_levels(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "with TagA, TagB {"
     LINE " with TagC, TagD, TagE {"
-    LINE "  Foo"
+    LINE "  Foo {}"
     LINE " }"
-    LINE " HelloA"
+    LINE " HelloA {}"
     LINE " with TagF, TagG, TagH {"
-    LINE "  Bar"
+    LINE "  Bar {}"
     LINE " }"
-    LINE " HelloB"
+    LINE " HelloB {}"
     LINE "}"
-    LINE "HelloC";
+    LINE "HelloC {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t tag_a = ecs_lookup(world, "TagA");
     ecs_entity_t tag_b = ecs_lookup(world, "TagB");
@@ -1399,17 +1413,39 @@ void Plecs_with_n_tags_2_levels(void) {
     ecs_fini(world);
 }
 
-void Plecs_with_after_scope(void) {
+void Eval_with_n_tags_2_levels_invalid_tag(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "with TagA, TagB {"
+    LINE " with TagC, TagD, TagE {"
+    LINE "  Foo {}"
+    LINE " }"
+    LINE " HelloA"
+    LINE " with TagF, TagG, TagH {"
+    LINE "  Bar {}"
+    LINE " }"
+    LINE " HelloB {}"
+    LINE "}"
+    LINE "HelloC {}";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
+
+    ecs_fini(world);
+}
+
+void Eval_with_after_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "E1 { }"
     HEAD "with E2 {"
-    LINE "  E3() { }"
+    LINE "  E3 _ { }"
     LINE "  E4 { }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e1 = ecs_lookup(world, "E1");
     ecs_entity_t e2 = ecs_lookup(world, "E2");
@@ -1431,17 +1467,17 @@ void Plecs_with_after_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_with_after_with(void) {
+void Eval_with_after_with(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "with E1 { }"
     HEAD "with E2 {"
-    LINE "  E3() { }"
+    LINE "  E3 _ { }"
     LINE "  E4 { }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e1 = ecs_lookup(world, "E1");
     ecs_entity_t e2 = ecs_lookup(world, "E2");
@@ -1463,20 +1499,20 @@ void Plecs_with_after_with(void) {
     ecs_fini(world);
 }
 
-void Plecs_scope_inside_with_inside_scope(void) {
+void Eval_scope_inside_with_inside_scope(void) {
     ecs_world_t *world = ecs_init();
     
     const char *expr =
     HEAD "Sun {"
     LINE "  with Planet {"
     LINE "    Earth {"
-    LINE "      Moon"
+    LINE "      Moon {}"
     LINE "    }"
-    LINE "    Mars"
+    LINE "    Mars {}"
     LINE "  }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t sun = ecs_lookup(world, "Sun");
     ecs_entity_t planet = ecs_lookup(world, "Planet");
@@ -1507,18 +1543,35 @@ void Plecs_scope_inside_with_inside_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_with_inside_scope(void) {
+void Eval_with_tag_core_name(void) {
+    ecs_world_t *world = ecs_init();
+    
+    const char *expr =
+    HEAD "with World {"
+    LINE "  Hello {}"
+    LINE "}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t hello = ecs_lookup(world, "Hello");
+    test_assert(hello != 0);
+    test_assert(ecs_has_id(world, hello, EcsWorld));
+
+    ecs_fini(world);
+}
+
+void Eval_with_inside_scope(void) {
     ecs_world_t *world = ecs_init();
     
     const char *expr =
     HEAD "Earth {"
     LINE "  with Continent {"
-    LINE "    Europe"
+    LINE "    Europe {}"
     LINE "  }"
-    LINE "  Europe"
+    LINE "  Europe {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t earth = ecs_lookup(world, "Earth");
     ecs_entity_t continent = ecs_lookup(world, "Continent");
@@ -1536,102 +1589,32 @@ void Plecs_with_inside_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_assignment_w_1(void) {
-    ecs_world_t *world = ecs_init();
-    
-    const char *expr =
-    HEAD "Earth :- Planet";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t earth = ecs_lookup(world, "Earth");
-    ecs_entity_t planet = ecs_lookup(world, "Planet");
-
-    test_assert(earth != 0);
-    test_assert(planet != 0);
-
-    test_assert( ecs_has_id(world, earth, planet));
-
-    ecs_fini(world);
-}
-
-void Plecs_assignment_w_2(void) {
-    ecs_world_t *world = ecs_init();
-    
-    const char *expr =
-    HEAD "Earth :- Planet, Habitable";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t earth = ecs_lookup(world, "Earth");
-    ecs_entity_t planet = ecs_lookup(world, "Planet");
-    ecs_entity_t habitable = ecs_lookup(world, "Habitable");
-
-    test_assert(earth != 0);
-    test_assert(planet != 0);
-    test_assert(habitable != 0);
-
-    test_assert( ecs_has_id(world, earth, planet));
-    test_assert( ecs_has_id(world, earth, habitable));
-
-    ecs_fini(world);
-}
-
-void Plecs_assignment_w_pair(void) {
-    ecs_world_t *world = ecs_init();
-    
-    const char *expr =
-    HEAD "Earth :- Planet, (ChildOf, Sun)";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t earth = ecs_lookup(world, "Sun.Earth");
-    ecs_entity_t planet = ecs_lookup(world, "Planet");
-    ecs_entity_t sun = ecs_lookup(world, "Sun");
-
-    test_assert(earth != 0);
-    test_assert(planet != 0);
-    test_assert(sun != 0);
-
-    test_assert( ecs_has_id(world, earth, planet));
-    test_assert( ecs_has_pair(world, earth, EcsChildOf, sun));
-
-    ecs_fini(world);
-}
-
-void Plecs_assignment_w_invalid_subject(void) {
-    ecs_log_set_level(-4);
-
+void Eval_inherit(void) {    
     ecs_world_t *world = ecs_init();
     
     const char *expr =
-    HEAD "Earth :- Planet(Mars)";
+    HEAD "Foo : Bar";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_fini(world);
-}
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
 
-void Plecs_assignment_w_invalid_with(void) {
-    ecs_log_set_level(-4);
-    
-    ecs_world_t *world = ecs_init();
-    
-    const char *expr =
-    HEAD "Earth :- with Planet { Mars }";
+    test_assert(foo != 0);
+    test_assert(bar != 0);
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_has_pair(world, foo, EcsIsA, bar));
 
     ecs_fini(world);
 }
 
-void Plecs_inherit_w_colon(void) {    
+void Eval_inherit_newline(void) {    
     ecs_world_t *world = ecs_init();
     
     const char *expr =
-    HEAD "Foo : Bar";
+    HEAD "Foo : Bar\n";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -1644,49 +1627,48 @@ void Plecs_inherit_w_colon(void) {
     ecs_fini(world);
 }
 
-void Plecs_inherit_w_colon_w_scope(void) {
+void Eval_inherit_w_colon(void) {    
     ecs_world_t *world = ecs_init();
     
     const char *expr =
-    HEAD "Foo : Bar { Child }";
+    HEAD "Foo : Bar {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
-    ecs_entity_t child = ecs_lookup(world, "Foo.Child");
 
     test_assert(foo != 0);
     test_assert(bar != 0);
 
     test_assert(ecs_has_pair(world, foo, EcsIsA, bar));
-    test_assert(ecs_has_pair(world, child, EcsChildOf, foo));
 
     ecs_fini(world);
 }
 
-void Plecs_inherit_w_colon_w_assign(void) {
+void Eval_inherit_w_colon_w_scope(void) {
     ecs_world_t *world = ecs_init();
     
     const char *expr =
-    HEAD "Foo : Bar :- Comp";
+    HEAD "Foo : Bar { Child{} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
-    ecs_entity_t comp = ecs_lookup(world, "Comp");
+    ecs_entity_t child = ecs_lookup(world, "Foo.Child");
 
     test_assert(foo != 0);
     test_assert(bar != 0);
+    test_assert(child != 0);
 
     test_assert(ecs_has_pair(world, foo, EcsIsA, bar));
-    test_assert(ecs_has_id(world, foo, comp));
+    test_assert(ecs_has_pair(world, child, EcsChildOf, foo));
 
     ecs_fini(world);
 }
 
-void Plecs_assign_component_value(void) {
+void Eval_assign_component_w_value(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
@@ -1698,9 +1680,9 @@ void Plecs_assign_component_value(void) {
     });
 
     const char *expr =
-    HEAD "Foo :- Position{10, 20}";
+    HEAD "Foo = Position: {10, 20}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
     test_assert(foo != 0);
@@ -1709,61 +1691,67 @@ void Plecs_assign_component_value(void) {
 
     const Position *ptr = ecs_get(world, foo, Position);
     test_assert(ptr != NULL);
+
     test_int(ptr->x, 10);
     test_int(ptr->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_assign_2_component_values(void) {
+void Eval_assign_tag_in_assign_scope(void) {
     ecs_world_t *world = ecs_init();
+    
+    const char *expr =
+    HEAD "Foo {"
+    LINE "  Bar"
+    LINE "}";
 
-    ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
-        .entity = ecs_entity(world, {.name = "Position"}),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t ecs_id(Velocity) = ecs_struct_init(world, &(ecs_struct_desc_t){
-        .entity = ecs_entity(world, {.name = "Velocity"}),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    test_assert(foo != 0);
+    test_assert(bar != 0);
+    test_assert(ecs_has_id(world, foo, bar));
+
+    ecs_fini(world);
+}
 
+void Eval_assign_tag_in_assign_scope_same_line(void) {
+    ecs_world_t *world = ecs_init();
+    
     const char *expr =
-    HEAD "Foo :- Position{10, 20}"
-    LINE "Foo :- Velocity {1, 2}";
+    HEAD "Foo { Bar }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
     test_assert(foo != 0);
+    test_assert(bar != 0);
+    test_assert(ecs_has_id(world, foo, bar));
 
-    test_assert(ecs_has(world, foo, Position));
-    test_assert(ecs_has(world, foo, Velocity));
+    ecs_fini(world);
+}
 
-    {
-    const Position *ptr = ecs_get(world, foo, Position);
-    test_assert(ptr != NULL);
-    test_int(ptr->x, 10);
-    test_int(ptr->y, 20);
-    }
+void Eval_assign_tag_in_assign_scope_core_name(void) {
+    ecs_world_t *world = ecs_init();
+    
+    const char *expr =
+    HEAD "Hello {"
+    LINE "  World"
+    LINE "}";
 
-    {
-    const Velocity *ptr = ecs_get(world, foo, Velocity);
-    test_assert(ptr != NULL);
-    test_int(ptr->x, 1);
-    test_int(ptr->y, 2);
-    }
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t hello = ecs_lookup(world, "Hello");
+    test_assert(hello != 0);
+    test_assert(ecs_has_id(world, hello, EcsWorld));
 
     ecs_fini(world);
 }
 
-void Plecs_assign_component_value_in_assign_scope(void) {
+void Eval_assign_component_value_in_assign_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
@@ -1776,10 +1764,10 @@ void Plecs_assign_component_value_in_assign_scope(void) {
 
     const char *expr =
     HEAD "Foo {"
-    LINE " - Position {10, 20}"
+    LINE "  Position: {10, 20}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
     test_assert(foo != 0);
@@ -1795,7 +1783,7 @@ void Plecs_assign_component_value_in_assign_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_assign_2_component_values_in_assign_scope(void) {
+void Eval_assign_2_component_values_in_assign_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
@@ -1816,11 +1804,11 @@ void Plecs_assign_2_component_values_in_assign_scope(void) {
 
     const char *expr =
     HEAD "Foo {"
-    LINE " - Position{10, 20}"
-    LINE " -Velocity {1, 2}"
+    LINE " Position: {10, 20}"
+    LINE " Velocity:{1, 2}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
     test_assert(foo != 0);
@@ -1845,18 +1833,20 @@ void Plecs_assign_2_component_values_in_assign_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_type_and_assign_in_plecs(void) {
+void Eval_type_and_assign_in_plecs(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "flecs.meta.Struct Position {"
-    LINE "  x :- flecs.meta.Member{flecs.meta.f32}"
-    LINE "  y :- flecs.meta.Member{flecs.meta.f32}"
+    HEAD "flecs.meta.struct Position {"
+    LINE "  x { flecs.meta.member: {flecs.meta.f32} }"
+    LINE "  y { flecs.meta.member: {flecs.meta.f32} }"
     LINE "}"
-    LINE
-    LINE "Foo :- Position{10, 20}";
+    LINE ""
+    LINE "Foo {"
+    LINE "  Position: {10, 20}"
+    LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Position) = ecs_lookup(world, "Position");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
@@ -1875,18 +1865,20 @@ void Plecs_type_and_assign_in_plecs(void) {
     ecs_fini(world);
 }
 
-void Plecs_type_and_assign_in_plecs_w_2_members(void) {
+void Eval_type_and_assign_in_plecs_w_2_members(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "flecs.meta.Struct Position {"
-    LINE "  x :- flecs.meta.Member{flecs.meta.f32}"
-    LINE "  y :- flecs.meta.Member{flecs.meta.f32}"
+    HEAD "flecs.meta.struct Position {"
+    LINE "  x { flecs.meta.member: {flecs.meta.f32} }"
+    LINE "  y { flecs.meta.member: {flecs.meta.f32} }"
     LINE "}"
     LINE ""
-    LINE "Foo :- Position{x: 10, y: 20}";
+    LINE "Foo {"
+    LINE "  Position: {x: 10, y: 20}"
+    LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Position) = ecs_lookup(world, "Position");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
@@ -1905,7 +1897,7 @@ void Plecs_type_and_assign_in_plecs_w_2_members(void) {
     ecs_fini(world);
 }
 
-void Plecs_type_and_assign_in_plecs_w_3_members(void) {
+void Eval_type_and_assign_in_plecs_w_3_members(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -1915,15 +1907,17 @@ void Plecs_type_and_assign_in_plecs_w_3_members(void) {
     } Position3D;
 
     const char *expr =
-    HEAD "flecs.meta.Struct Position {"
-    LINE "  x :- flecs.meta.Member{flecs.meta.f32}"
-    LINE "  y :- flecs.meta.Member{flecs.meta.f32}"
-    LINE "  z :- flecs.meta.Member{flecs.meta.f32}"
+    HEAD "flecs.meta.struct Position {"
+    LINE "  x { flecs.meta.member: {flecs.meta.f32} }"
+    LINE "  y { flecs.meta.member: {flecs.meta.f32} }"
+    LINE "  z { flecs.meta.member: {flecs.meta.f32} }"
     LINE "}"
     LINE ""
-    LINE "Foo :- Position{x: 10, y: 20, z: 30}";
+    LINE "Foo {"
+    LINE "  Position: {x: 10, y: 20, z: 30}"
+    LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Position3D) = ecs_lookup(world, "Position");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
@@ -1943,7 +1937,7 @@ void Plecs_type_and_assign_in_plecs_w_3_members(void) {
     ecs_fini(world);
 }
 
-void Plecs_type_and_assign_in_plecs_w_enum(void) {
+void Eval_type_and_assign_in_plecs_w_enum(void) {
     ecs_world_t *world = ecs_init();
 
     typedef enum {
@@ -1955,19 +1949,21 @@ void Plecs_type_and_assign_in_plecs_w_enum(void) {
     } SomeType;
 
     const char *expr =
-    HEAD "flecs.meta.Enum Color {"
-    LINE "  flecs.meta.Constant Red"
-    LINE "  flecs.meta.Constant Green"
-    LINE "  flecs.meta.Constant Blue"
+    HEAD "flecs.meta.enum Color {"
+    LINE "  flecs.meta.constant Red"
+    LINE "  flecs.meta.constant Green"
+    LINE "  flecs.meta.constant Blue"
     LINE "}"
     LINE ""
-    LINE "flecs.meta.Struct SomeType {"
-    LINE "  value :- flecs.meta.Member{Color}"
+    LINE "flecs.meta.struct SomeType {"
+    LINE "  value { flecs.meta.member: {Color} }"
     LINE "}"
     LINE ""
-    LINE "Foo :- SomeType{value: Blue}";
+    LINE "Foo {"
+    LINE "  SomeType: {value: Blue}"
+    LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(SomeType) = ecs_lookup(world, "SomeType");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
@@ -1985,7 +1981,7 @@ void Plecs_type_and_assign_in_plecs_w_enum(void) {
     ecs_fini(world);
 }
 
-void Plecs_type_and_assign_in_plecs_w_enum_using_meta(void) {
+void Eval_type_and_assign_in_plecs_w_enum_using_meta(void) {
     ecs_world_t *world = ecs_init();
 
     typedef enum {
@@ -1999,19 +1995,19 @@ void Plecs_type_and_assign_in_plecs_w_enum_using_meta(void) {
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Enum Color {"
-    LINE "  Constant Red"
-    LINE "  Constant Green"
-    LINE "  Constant Blue"
+    LINE "enum Color {"
+    LINE "  constant Red"
+    LINE "  constant Green"
+    LINE "  constant Blue"
     LINE "}"
     LINE
-    LINE "Struct SomeType {"
-    LINE "  value :- Member{Color}"
+    LINE "struct SomeType {"
+    LINE "  value { member: {Color} }"
     LINE "}"
     LINE
-    LINE "Foo :- SomeType{value: Blue}";
+    LINE "Foo { SomeType: {value: Blue} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(SomeType) = ecs_lookup(world, "SomeType");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
@@ -2037,7 +2033,7 @@ void Plecs_type_and_assign_in_plecs_w_enum_using_meta(void) {
     ecs_fini(world);
 }
 
-void Plecs_type_and_assign_in_plecs_w_enum_primitive_using_meta(void) {
+void Eval_type_and_assign_in_plecs_w_enum_primitive_using_meta(void) {
     ecs_world_t *world = ecs_init();
 
     typedef enum {
@@ -2046,15 +2042,15 @@ void Plecs_type_and_assign_in_plecs_w_enum_primitive_using_meta(void) {
 
     const char *expr =
     HEAD "using flecs.meta"
-    LINE "Enum Color {"
-    LINE "  Constant Red"
-    LINE "  Constant Green"
-    LINE "  Constant Blue"
+    LINE "enum Color {"
+    LINE "  constant Red"
+    LINE "  constant Green"
+    LINE "  constant Blue"
     LINE "}"
     LINE ""
-    LINE "Foo :- Color{Blue}";
+    LINE "Foo { Color: {Blue} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Color) = ecs_lookup(world, "Color");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
@@ -2080,8 +2076,7 @@ void Plecs_type_and_assign_in_plecs_w_enum_primitive_using_meta(void) {
     ecs_fini(world);
 }
 
-
-void Plecs_type_and_assign_in_plecs_w_enum_primitive_and_struct(void) {
+void Eval_type_and_assign_in_plecs_w_enum_primitive_and_struct(void) {
     ecs_world_t *world = ecs_init();
 
     typedef enum {
@@ -2091,23 +2086,23 @@ void Plecs_type_and_assign_in_plecs_w_enum_primitive_and_struct(void) {
     const char *expr =
     HEAD "using flecs.meta"
     LINE 
-    LINE "Struct Position {"
-    LINE "  x :- Member{f32}"
-    LINE "  y :- Member{f32}"
+    LINE "struct Position {"
+    LINE "  x { member: {f32} }"
+    LINE "  y { member: {f32} }"
     LINE "}"
     LINE 
-    LINE "Enum Color {"
-    LINE "  Constant Red"
-    LINE "  Constant Green"
-    LINE "  Constant Blue"
+    LINE "enum Color {"
+    LINE "  constant Red"
+    LINE "  constant Green"
+    LINE "  constant Blue"
     LINE "}"
     LINE 
     LINE "Foo {"
-    LINE "  - Position {x: 10, y: 20}"
-    LINE "  - Color {Green}"
+    LINE "  Position: {x: 10, y: 20}"
+    LINE "  Color: {Green}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Position) = ecs_lookup(world, "Position");
     ecs_entity_t ecs_id(Color) = ecs_lookup(world, "Color");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
@@ -2143,7 +2138,7 @@ void Plecs_type_and_assign_in_plecs_w_enum_primitive_and_struct(void) {
     ecs_fini(world);
 }
 
-void Plecs_type_and_assign_in_plecs_nested_member(void) {
+void Eval_type_and_assign_in_plecs_nested_member(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -2161,20 +2156,20 @@ void Plecs_type_and_assign_in_plecs_nested_member(void) {
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Struct Line {"
-    LINE "  Member start {"
-    LINE "    x :- Member{f32}"
-    LINE "    y :- Member{f32}"
+    LINE "struct Line {"
+    LINE "  member start {"
+    LINE "    x { member: {f32} }"
+    LINE "    y { member: {f32} }"
     LINE "  }"
-    LINE "  Member stop {"
-    LINE "    x :- Member{f32}"
-    LINE "    y :- Member{f32}"
+    LINE "  member stop {"
+    LINE "    x { member: {f32} }"
+    LINE "    y { member: {f32} }"
     LINE "  }"
     LINE "}"
     LINE
-    LINE "l :- Line{start: {x: 10, y: 20}, stop: {x: 30, y: 40}}";
+    LINE "l { Line: {start: {x: 10, y: 20}, stop: {x: 30, y: 40}} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Line) = ecs_lookup(world, "Line");
     ecs_entity_t l = ecs_lookup(world, "l");
 
@@ -2196,7 +2191,7 @@ void Plecs_type_and_assign_in_plecs_nested_member(void) {
     ecs_fini(world);
 }
 
-void Plecs_dot_assign_nested_member(void) {
+void Eval_dot_assign_nested_member(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -2214,20 +2209,20 @@ void Plecs_dot_assign_nested_member(void) {
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Struct Line {"
-    LINE "  Member start {"
-    LINE "    x :- Member{f32}"
-    LINE "    y :- Member{f32}"
+    LINE "struct Line {"
+    LINE "  member start {"
+    LINE "    x { member: {f32} }"
+    LINE "    y { member: {f32} }"
     LINE "  }"
-    LINE "  Member stop {"
-    LINE "    x :- Member{f32}"
-    LINE "    y :- Member{f32}"
+    LINE "  member stop {"
+    LINE "    x { member: {f32} }"
+    LINE "    y { member: {f32} }"
     LINE "  }"
     LINE "}"
     LINE
-    LINE "l :- Line{start.x: 10, start.y: 20, stop.x: 30, stop.y: 40}";
+    LINE "l { Line: {start.x: 10, start.y: 20, stop.x: 30, stop.y: 40} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Line) = ecs_lookup(world, "Line");
     ecs_entity_t l = ecs_lookup(world, "l");
 
@@ -2245,11 +2240,10 @@ void Plecs_dot_assign_nested_member(void) {
     test_int(ptr->stop.x, 30);
     test_int(ptr->stop.y, 40);
     
-    
     ecs_fini(world);
 }
 
-void Plecs_dot_assign_binary_expr(void) {
+void Eval_dot_assign_binary_expr(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -2267,20 +2261,20 @@ void Plecs_dot_assign_binary_expr(void) {
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Struct Line {"
-    LINE "  Member start {"
-    LINE "    x :- Member{f32}"
-    LINE "    y :- Member{f32}"
+    LINE "struct Line {"
+    LINE "  member start {"
+    LINE "    x { member: {f32} }"
+    LINE "    y { member: {f32} }"
     LINE "  }"
-    LINE "  Member stop {"
-    LINE "    x :- Member{f32}"
-    LINE "    y :- Member{f32}"
+    LINE "  member stop {"
+    LINE "    x { member: {f32} }"
+    LINE "    y { member: {f32} }"
     LINE "  }"
     LINE "}"
     LINE
-    LINE "l :- Line{start.x: 2 + 8, start.y: 5 + 15, stop.x: 10 + 20, stop.y: 15 + 25}";
+    LINE "l { Line: {start.x: 2 + 8, start.y: 5 + 15, stop.x: 10 + 20, stop.y: 15 + 25} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Line) = ecs_lookup(world, "Line");
     ecs_entity_t l = ecs_lookup(world, "l");
 
@@ -2302,19 +2296,19 @@ void Plecs_dot_assign_binary_expr(void) {
     ecs_fini(world);
 }
 
-void Plecs_open_scope_no_parent(void) {
+void Eval_open_scope_no_parent(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo {"
-    LINE "  Bar"
+    LINE "  Bar {}"
     LINE "}"
     LINE "{"
-    LINE "  Zoo"
+    LINE "  Zoo {}"
     LINE "}"
-    LINE "Hello";
+    LINE "Hello {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Foo.Bar");
     ecs_entity_t zoo = ecs_lookup(world, "Zoo");
@@ -2332,54 +2326,54 @@ void Plecs_open_scope_no_parent(void) {
     ecs_fini(world);
 }
 
-void Plecs_create_subject_in_root_scope_w_resolvable_id(void) {
+void Eval_create_subject_in_root_scope_w_resolvable_id(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Tag";
+    HEAD "Tag {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t tag = ecs_lookup_child(world, 0, "Tag");
     test_assert(tag != 0);
-    test_assert(tag != EcsTag);
+    test_assert(tag != EcsPairIsTag);
 
     ecs_fini(world);
 }
 
-void Plecs_create_subject_in_scope_w_resolvable_id(void) {
+void Eval_create_subject_in_scope_w_resolvable_id(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo {"
-    LINE "  Tag"
+    LINE "  Tag {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
 
     ecs_entity_t tag = ecs_lookup(world, "Foo.Tag");
     test_assert(tag != 0);
-    test_assert(tag != EcsTag);
+    test_assert(tag != EcsPairIsTag);
 
     test_assert(ecs_has_pair(world, tag, EcsChildOf, foo));
 
     ecs_fini(world);
 }
 
-void Plecs_create_subject_in_scope_w_resolvable_id_using(void) {
+void Eval_create_subject_in_scope_w_resolvable_id_using(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo {"
-    LINE "  Bar"
+    LINE "  Bar {}"
     LINE "}"
     LINE
     LINE "using Foo"
     LINE
-    LINE "Hello(Bar)";
+    LINE "Hello Bar {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Foo.Bar");
     ecs_entity_t root_bar = ecs_lookup(world, "Bar");
@@ -2398,24 +2392,24 @@ void Plecs_create_subject_in_scope_w_resolvable_id_using(void) {
     ecs_fini(world);
 }
 
-void Plecs_using_scope(void) {
+void Eval_using_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo {"
-    LINE "  Bar"
+    LINE "  Bar {}"
     LINE "}"
     LINE ""
     LINE "using Foo"
-    LINE "Bar(Hello)"
-    LINE "Foo.Bar(World)";
+    LINE "Bar Hello {}"
+    LINE "Foo.Bar World {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Foo.Bar");
     ecs_entity_t not_bar = ecs_lookup(world, "Bar");
     ecs_entity_t hello = ecs_lookup(world, "Hello");
-    ecs_entity_t _world = ecs_lookup(world, "World");
+    ecs_entity_t _world = ecs_lookup_child(world, 0, "World");
 
     test_assert(foo != 0);
     test_assert(bar != 0);
@@ -2432,28 +2426,28 @@ void Plecs_using_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_using_nested_scope(void) {
+void Eval_using_nested_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo {"
     LINE "  Bar {"
-    LINE "    Zoo"
+    LINE "    Zoo {}"
     LINE "  }"
     LINE "}"
     LINE ""
     LINE "using Foo.Bar"
-    LINE "Zoo(Hello)"
-    LINE "Foo.Bar.Zoo(World)";
+    LINE "Zoo Hello {}"
+    LINE "Foo.Bar.Zoo World {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Foo.Bar");
     ecs_entity_t zoo = ecs_lookup(world, "Foo.Bar.Zoo");
     ecs_entity_t not_bar = ecs_lookup(world, "Bar");
     ecs_entity_t not_zoo = ecs_lookup(world, "Zoo");
     ecs_entity_t hello = ecs_lookup(world, "Hello");
-    ecs_entity_t _world = ecs_lookup(world, "World");
+    ecs_entity_t _world = ecs_lookup_child(world, 0, "World");
 
     test_assert(foo != 0);
     test_assert(bar != 0);
@@ -2471,29 +2465,29 @@ void Plecs_using_nested_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_using_nested_in_scope(void) {
+void Eval_using_nested_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo {"
     LINE "  Bar {"
-    LINE "    Zoo"
+    LINE "    Zoo {}"
     LINE "  }"
     LINE "}"
     LINE "{"
     LINE "  using Foo.Bar"
-    LINE "  Zoo(Hello)"
+    LINE "  Zoo Hello {}"
     LINE "}"
-    LINE "Zoo(World)";
+    LINE "Zoo World {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Foo.Bar");
     ecs_entity_t zoo = ecs_lookup(world, "Foo.Bar.Zoo");
     ecs_entity_t not_bar = ecs_lookup(world, "Bar");
     ecs_entity_t zoo_root = ecs_lookup(world, "Zoo");
     ecs_entity_t hello = ecs_lookup(world, "Hello");
-    ecs_entity_t _world = ecs_lookup(world, "World");
+    ecs_entity_t _world = ecs_lookup_child(world, 0, "World");
 
     test_assert(foo != 0);
     test_assert(bar != 0);
@@ -2511,7 +2505,7 @@ void Plecs_using_nested_in_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_using_with_scope(void) {
+void Eval_using_with_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
@@ -2521,13 +2515,13 @@ void Plecs_using_with_scope(void) {
     LINE ""
     LINE "Foo {}"
     LINE ""
-    LINE "Struct Bar {"
-    LINE "  x :- Member{f32}"
+    LINE "struct Bar {"
+    LINE "  x { member: {f32} }"
     LINE "}"
     LINE ""
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t scope = ecs_lookup(world, "Scope");
     ecs_entity_t foo = ecs_lookup(world, "Scope.Foo");
     ecs_entity_t bar = ecs_lookup(world, "Scope.Bar");
@@ -2551,20 +2545,20 @@ void Plecs_using_with_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_using_w_entity_ref_in_value_2_members(void) {
+void Eval_using_w_entity_ref_in_value_2_members(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Struct Position {"
-    LINE "  x :- Member{f32}" // member type is looked up in flecs.meta
-    LINE "  y :- Member{f32}"
+    LINE "struct Position {"
+    LINE "  x { member: {f32} }" // member type is looked up in flecs.meta
+    LINE "  y { member: {f32} }"
     LINE "}"
     LINE ""
-    LINE "Foo :- Position{x: 10, y: 20}";
+    LINE "Foo { Position: {x: 10, y: 20} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Position) = ecs_lookup(world, "Position");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
@@ -2583,7 +2577,7 @@ void Plecs_using_w_entity_ref_in_value_2_members(void) {
     ecs_fini(world);
 }
 
-void Plecs_using_w_entity_ref_in_value_3_members(void) {
+void Eval_using_w_entity_ref_in_value_3_members(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -2595,15 +2589,15 @@ void Plecs_using_w_entity_ref_in_value_3_members(void) {
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Struct Position {"
-    LINE "  x :- Member{f32}" // member type is looked up in flecs.meta
-    LINE "  y :- Member{f32}"
-    LINE "  z :- Member{f32}"
+    LINE "struct Position {"
+    LINE "  x { member: {f32} }" // member type is looked up in flecs.meta
+    LINE "  y { member: {f32} }"
+    LINE "  z { member: {f32} }"
     LINE "}"
     LINE
-    LINE "Foo :- Position{x: 10, y: 20, z: 30}";
+    LINE "Foo { Position: {x: 10, y: 20, z: 30} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t ecs_id(Position3D) = ecs_lookup(world, "Position");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
 
@@ -2623,7 +2617,7 @@ void Plecs_using_w_entity_ref_in_value_3_members(void) {
     ecs_fini(world);
 }
 
-void Plecs_2_using_scope(void) {
+void Eval_2_using_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
@@ -2631,17 +2625,17 @@ void Plecs_2_using_scope(void) {
     LINE "using Bar"
     LINE
     LINE "Foo {"
-    LINE "  Hello"
+    LINE "  Hello {}"
     LINE "}"
     LINE
     LINE "Bar {"
-    LINE "  TheWorld"
+    LINE "  TheWorld {}"
     LINE "}"
     LINE
-    LINE "Hello(E1)"
-    LINE "TheWorld(E2)";
+    LINE "Hello E1 {}"
+    LINE "TheWorld E2 {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t hello = ecs_lookup(world, "Foo.Hello");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -2668,37 +2662,37 @@ void Plecs_2_using_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_2_using_in_different_scope(void) {
+void Eval_2_using_in_different_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     LINE "Foo {"
-    LINE "  Hello"
+    LINE "  Hello {}"
     LINE "}"
     LINE
     LINE "Bar {"
-    LINE "  TheWorld"
+    LINE "  TheWorld {}"
     LINE "}"
     LINE
     LINE "E1 {"
     LINE "  using Foo"
     LINE
-    LINE "  Hello(Child)"
-    LINE "  TheWorld(Child)"
+    LINE "  Hello Child {}"
+    LINE "  TheWorld Child {}"
     LINE "}"
     LINE
     LINE "E2 {"
     LINE "  using Bar"
     LINE
-    LINE "  Hello(Child)"
-    LINE "  TheWorld(Child)"
+    LINE "  Hello Child {}"
+    LINE "  TheWorld Child {}"
     LINE "}"
     LINE
-    LINE "Hello(RootChild)"
-    LINE "TheWorld(RootChild)"
+    LINE "Hello RootChild {}"
+    LINE "TheWorld RootChild {}"
     LINE;
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t hello = ecs_lookup(world, "Foo.Hello");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -2744,50 +2738,50 @@ void Plecs_2_using_in_different_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_assignment_to_non_component(void) {
+void Eval_assignment_to_non_component(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Foo :- Position{x: 10, y: 20}";
+    HEAD "Foo { Position: {x: 10, y: 20} }";
 
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_struct_w_member_w_assignment_to_nothing(void) {
+void Eval_struct_w_member_w_assignment_to_nothing(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "flecs.meta.Struct Position {"
-    LINE "  flecs.meta.Member(x) = "
+    HEAD "flecs.meta.struct Position {"
+    LINE "  x { flecs.meta.Member: }"
     LINE "}";
 
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_struct_w_member_w_assignment_to_empty_scope(void) {
+void Eval_struct_w_member_w_assignment_to_empty_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "flecs.meta.Struct Position {"
-    LINE "  x :- flecs.meta.Member{"
+    HEAD "flecs.meta.struct Position {"
+    LINE "  x { flecs.meta.member: { }"
     LINE "}";
 
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_scope_after_assign(void) {
+void Eval_scope_after_assign(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_struct_init(world, &(ecs_struct_desc_t){
+    ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
         .entity = ecs_entity(world, {.name = "Position"}),
         .members = {
             {"x", ecs_id(ecs_f32_t)},
@@ -2796,20 +2790,31 @@ void Plecs_scope_after_assign(void) {
     });
 
     const char *expr =
-    HEAD "Foo :- Position{10, 20} {"
-    LINE "  Bar"
+    HEAD "Position Foo(10, 20) {"
+    LINE "  Bar {}"
     LINE "}";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_fini(world);
-}
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Foo.Bar");
 
-void Plecs_assign_after_inherit(void) {
-    ecs_world_t *world = ecs_init();
+    test_assert(ecs_has_pair(world, bar, EcsChildOf, foo));
 
-    ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
+    {
+        const Position *p = ecs_get(world, foo, Position);
+        test_assert(p != NULL);
+        test_int(p->x, 10);
+        test_int(p->y, 20);
+    }
+
+    ecs_fini(world);
+}
+
+void Eval_assign_after_inherit(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
         .entity = ecs_entity(world, {.name = "Position"}),
         .members = {
             {"x", ecs_id(ecs_f32_t)},
@@ -2818,10 +2823,10 @@ void Plecs_assign_after_inherit(void) {
     });
 
     const char *expr =
-    HEAD "Foo : Position"
-    LINE "Bar :- Position{10, 20}";
+    HEAD "Foo : Position {}"
+    LINE "Bar { Position: {10, 20} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -2843,7 +2848,56 @@ void Plecs_assign_after_inherit(void) {
     ecs_fini(world);
 }
 
-void Plecs_multiple_assignments_single_line(void) {
+void Eval_multiple_tags_single_line(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Foo { Hello; Bar }";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    test_assert(foo != 0);
+
+    ecs_entity_t hello = ecs_lookup(world, "Hello");
+    test_assert(hello != 0);
+
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    test_assert(bar != 0);
+
+    test_assert( ecs_has_id(world, foo, hello));
+    test_assert( ecs_has_id(world, foo, bar));
+
+    ecs_fini(world);
+}
+
+void Eval_multiple_pairs_single_line(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Foo { (Rel, Hello); (Rel, Bar) }";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    test_assert(foo != 0);
+
+    ecs_entity_t rel = ecs_lookup(world, "Rel");
+    test_assert(rel != 0);
+
+    ecs_entity_t hello = ecs_lookup(world, "Hello");
+    test_assert(hello != 0);
+
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    test_assert(bar != 0);
+
+    test_assert( ecs_has_pair(world, foo, rel, hello));
+    test_assert( ecs_has_pair(world, foo, rel, bar));
+
+    ecs_fini(world);
+}
+
+void Eval_multiple_assignments_single_line(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
@@ -2863,9 +2917,9 @@ void Plecs_multiple_assignments_single_line(void) {
     });
 
     const char *expr =
-    HEAD "Foo :- Position{10, 20}, Velocity{1, 2}";
+    HEAD "Foo { Position: {10, 20}; Velocity: {1, 2} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -2887,70 +2941,88 @@ void Plecs_multiple_assignments_single_line(void) {
     ecs_fini(world);
 }
 
-void Plecs_2_stmts_in_scope_w_no_parent(void) {
+void Eval_multiple_vars_single_line(void) {
     ecs_world_t *world = ecs_init();
 
+    ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .entity = ecs_entity(world, {.name = "Position"}),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    ecs_entity_t ecs_id(Velocity) = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .entity = ecs_entity(world, {.name = "Velocity"}),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
     const char *expr =
-    HEAD "{"
-    LINE "Bar { }"
-    LINE "Foo"
-    LINE "}";
+    HEAD "const pos = Position: {10, 20}"
+    LINE "const vel = Velocity: {1, 2}"
+    LINE "Foo { $pos; $vel }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t bar = ecs_lookup(world, "Bar");
-
     test_assert(foo != 0);
-    test_assert(bar != 0);
 
-    test_assert( !ecs_has_id(world, foo, bar));
-    test_assert( !ecs_has_pair(world, foo, EcsChildOf, bar));
+    {
+    const Position *ptr = ecs_get(world, foo, Position);
+    test_assert(ptr != NULL);
+    test_int(ptr->x, 10);
+    test_int(ptr->y, 20);
+    }
 
-    test_assert( !ecs_has_id(world, bar, foo));
-    test_assert( !ecs_has_pair(world, bar, EcsChildOf, foo));
+    {
+    const Velocity *ptr = ecs_get(world, foo, Velocity);
+    test_assert(ptr != NULL);
+    test_int(ptr->x, 1);
+    test_int(ptr->y, 2);
+    }
 
     ecs_fini(world);
 }
 
-void Plecs_scope_after_assign_1_tag(void) {
+void Eval_2_stmts_in_scope_w_no_parent(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Foo :- TagA {"
-    LINE "  Bar"
+    HEAD "{"
+    LINE "Bar { }"
+    LINE "Foo { }"
     LINE "}";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_fini(world);
-}
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
 
-void Plecs_scope_after_assign_2_tags(void) {
-    ecs_world_t *world = ecs_init();
+    test_assert(foo != 0);
+    test_assert(bar != 0);
 
-    const char *expr =
-    HEAD "Foo :- TagA, TagB {"
-    LINE "  Bar"
-    LINE "}";
+    test_assert( !ecs_has_id(world, foo, bar));
+    test_assert( !ecs_has_pair(world, foo, EcsChildOf, bar));
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert( !ecs_has_id(world, bar, foo));
+    test_assert( !ecs_has_pair(world, bar, EcsChildOf, foo));
 
     ecs_fini(world);
 }
 
-void Plecs_empty_scope_after_using(void) {
+void Eval_empty_scope_after_using(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "using flecs.meta"
     LINE "{"
-    LINE "  Foo"
+    LINE "  Foo {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert( foo != 0);
@@ -2959,65 +3031,65 @@ void Plecs_empty_scope_after_using(void) {
     ecs_fini(world);
 }
 
-void Plecs_invalid_nested_assignment(void) {
+void Eval_invalid_nested_assignment(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Foo :-"
-    LINE "Bar :- Hello";
+    HEAD "Foo {"
+    LINE "Bar { Hello }";
 
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_invalid_partial_pair_assignment(void) {
+void Eval_invalid_partial_pair_assignment(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Foo :- (Hello, ";
+    HEAD "Foo { (Hello, }";
 
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_empty_assignment(void) {
+void Eval_empty_assignment(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Foo :-";
+    HEAD "Foo {";
 
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_empty_assignment_before_end_of_scope(void) {
+void Eval_empty_assignment_before_end_of_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "{Foo :-}";
+    HEAD "{Foo {}";
 
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_assign_tag_to_parent(void) {
+void Eval_assign_tag_to_parent(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo {"
-    LINE "  - Bar"
-    LINE "  Child"
+    LINE "  Bar"
+    LINE "  Child {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -3035,7 +3107,7 @@ void Plecs_assign_tag_to_parent(void) {
     ecs_fini(world);
 }
 
-void Plecs_assign_component_to_parent(void) {
+void Eval_assign_component_to_parent(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
@@ -3048,11 +3120,11 @@ void Plecs_assign_component_to_parent(void) {
 
     const char *expr =
     HEAD "Foo {"
-    LINE "  - Position {10, 20}"
-    LINE "  Child"
+    LINE "  Position: {10, 20}"
+    LINE "  Child {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t child = ecs_lookup(world, "Foo.Child");
@@ -3073,15 +3145,15 @@ void Plecs_assign_component_to_parent(void) {
     ecs_fini(world);
 }
 
-void Plecs_assign_to_parent_pair_w_new_entities_in_scope(void) {
+void Eval_assign_to_parent_pair_w_new_entities_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo {"
-    LINE "  - (Rel, Obj)"
+    LINE "  (Rel, Obj)"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t rel = ecs_lookup(world, "Rel");
@@ -3098,16 +3170,16 @@ void Plecs_assign_to_parent_pair_w_new_entities_in_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_assign_to_parent_pair_w_existing_entities_in_scope(void) {
+void Eval_assign_to_parent_pair_w_existing_entities_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Rel, Obj"
     LINE "Foo {"
-    LINE "  - (Rel, Obj)"
+    LINE "  (Rel, Obj)"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t rel = ecs_lookup(world, "Rel");
@@ -3124,17 +3196,18 @@ void Plecs_assign_to_parent_pair_w_existing_entities_in_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_default_child_component(void) {
+void Eval_default_child_component(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "DefaultChildComponent(Foo, Bar)"
-    LINE "Foo(Parent) {"
-    LINE "  ChildA"
+    HEAD "Bar {}"
+    LINE "DefaultChildComponent Foo(Bar)"
+    LINE "Foo Parent {"
+    LINE "  ChildA,"
     LINE "  ChildB"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -3149,7 +3222,11 @@ void Plecs_default_child_component(void) {
     test_assert(child_a != 0);
     test_assert(child_b != 0);
 
-    test_assert( ecs_has_pair(world, foo, EcsDefaultChildComponent, bar));
+    const EcsDefaultChildComponent *dcc = 
+        ecs_get(world, foo, EcsDefaultChildComponent);
+    test_assert(dcc != NULL);
+    test_uint(dcc->component, bar);
+
     test_assert( ecs_has_id(world, parent, foo));
     test_assert( ecs_has_pair(world, child_a, EcsChildOf, parent));
     test_assert( ecs_has_pair(world, child_b, EcsChildOf, parent));
@@ -3160,7 +3237,7 @@ void Plecs_default_child_component(void) {
     ecs_fini(world);
 }
 
-void Plecs_default_child_component_w_assign(void) {
+void Eval_default_child_component_w_assign(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
@@ -3172,13 +3249,13 @@ void Plecs_default_child_component_w_assign(void) {
     });
 
     const char *expr =
-    HEAD "DefaultChildComponent(Foo, Position)"
-    LINE "Foo(Parent) {"
-    LINE "  ChildA :- {10, 20}"
-    LINE "  ChildB :- {10, 20}"
+    HEAD "DefaultChildComponent Foo(Position)"
+    LINE "Foo Parent {"
+    LINE "  ChildA = 10, 20"
+    LINE "  ChildB = 10, 20"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     
@@ -3190,8 +3267,12 @@ void Plecs_default_child_component_w_assign(void) {
     test_assert(parent != 0);
     test_assert(child_a != 0);
     test_assert(child_b != 0);
+    
+    const EcsDefaultChildComponent *dcc = 
+        ecs_get(world, foo, EcsDefaultChildComponent);
+    test_assert(dcc != NULL);
+    test_uint(dcc->component, ecs_id(Position));
 
-    test_assert( ecs_has_pair(world, foo, EcsDefaultChildComponent, ecs_id(Position)));
     test_assert( ecs_has_id(world, parent, foo));
     test_assert( ecs_has_pair(world, child_a, EcsChildOf, parent));
     test_assert( ecs_has_pair(world, child_b, EcsChildOf, parent));
@@ -3202,26 +3283,35 @@ void Plecs_default_child_component_w_assign(void) {
     ecs_fini(world);
 }
 
-void Plecs_struct_type_w_default_child_component(void) {
+void Eval_struct_type_w_default_child_component(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Struct(Position) {"
-    LINE "  x :- {f32}"
-    LINE "  y :- {f32}"
+    LINE "struct Position {"
+    LINE "  x = f32"
+    LINE "  y = f32"
     LINE "}"
-    LINE
-    LINE "Foo :- Position{x: 10, y: 20}";
+    LINE "Foo { Position: {x: 10, y: 20} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t ecs_id(Position) = ecs_lookup(world, "Position");
+    ecs_entity_t x = ecs_lookup(world, "Position.x");
+    ecs_entity_t y = ecs_lookup(world, "Position.y");
 
     test_assert(foo != 0);
     test_assert(ecs_id(Position) != 0);
+    test_assert(x != 0);
+    test_assert(y != 0);
+
+    test_assert( ecs_has(world, ecs_id(Position), EcsStruct));
+    test_assert( ecs_has(world, x, EcsMember));
+    test_assert( ecs_has(world, y, EcsMember));
+    test_assert( !ecs_has_pair(world, x, EcsIsA, ecs_id(ecs_f32_t)));
+    test_assert( !ecs_has_pair(world, y, EcsIsA, ecs_id(ecs_f32_t)));
 
     test_assert( ecs_has(world, foo, Position));
 
@@ -3233,7 +3323,7 @@ void Plecs_struct_type_w_default_child_component(void) {
     ecs_fini(world);
 }
 
-void Plecs_struct_type_w_default_child_component_nested_member(void) {
+void Eval_struct_type_w_default_child_component_nested_member(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -3251,20 +3341,20 @@ void Plecs_struct_type_w_default_child_component_nested_member(void) {
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Struct(Line) {"
+    LINE "struct Line {"
     LINE "  start {"
-    LINE "    x :- {f32}"
-    LINE "    y :- {f32}"
+    LINE "    x = f32"
+    LINE "    y = f32"
     LINE "  }"
     LINE "  stop {"
-    LINE "    x :- {f32}"
-    LINE "    y :- {f32}"
+    LINE "    x = f32"
+    LINE "    y = f32"
     LINE "  }"
     LINE "}"
     LINE
-    LINE "Foo :- Line{start: {10, 20}, stop: {30, 40}}";
+    LINE "Foo { Line: {start: {10, 20}, stop: {30, 40}} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t ecs_id(Line) = ecs_lookup(world, "Line");
@@ -3284,7 +3374,7 @@ void Plecs_struct_type_w_default_child_component_nested_member(void) {
     ecs_fini(world);
 }
 
-void Plecs_enum_type_w_default_child_component(void) {
+void Eval_enum_type_w_default_child_component(void) {
     ecs_world_t *world = ecs_init();
 
     typedef enum {
@@ -3294,13 +3384,13 @@ void Plecs_enum_type_w_default_child_component(void) {
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Enum Color {"
+    LINE "enum Color {"
     LINE "  Red, Green, Blue"
     LINE "}"
     LINE
-    LINE "Foo :- Color{Green}";
+    LINE "Foo { Color: {Green} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t ecs_id(Color) = ecs_lookup(world, "Color");
@@ -3317,7 +3407,7 @@ void Plecs_enum_type_w_default_child_component(void) {
     ecs_fini(world);
 }
 
-void Plecs_default_type_from_with(void) {
+void Eval_default_type_from_with(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
@@ -3330,11 +3420,11 @@ void Plecs_default_type_from_with(void) {
 
     const char *expr =
     HEAD "with Position {"
-    LINE "  e1 :- {10, 20}"
-    LINE "  e2 :- {30, 40}"
+    LINE "  e1 = 10, 20"
+    LINE "  e2 = 30, 40"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e1 = ecs_lookup(world, "e1");
     ecs_entity_t e2 = ecs_lookup(world, "e2");
@@ -3355,124 +3445,324 @@ void Plecs_default_type_from_with(void) {
     ecs_fini(world);
 }
 
-void Plecs_scope_w_1_subj_and_2_pairs(void) {
+void Eval_default_type_from_nested_with(void) {
     ecs_world_t *world = ecs_init();
 
+    ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .entity = ecs_entity(world, {.name = "Position"}),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    ecs_entity_t ecs_id(Velocity) = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .entity = ecs_entity(world, {.name = "Velocity"}),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
     const char *expr =
-    HEAD "Parent {"
-    LINE " RelA(Foo, Bar)"
-    LINE " RelB(Foo, Bar)"
+    HEAD "with Velocity {"
+    LINE "  e1 = 1, 2"
+    LINE "  with Position {"
+    LINE "    e2 = 10, 20"
+    LINE "    e3 = 30, 40"
+    LINE "  }"
+    LINE "  e4 = 3, 4"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t parent = ecs_lookup(world, "Parent");
-    ecs_entity_t rel_a = ecs_lookup(world, "RelA");
-    ecs_entity_t rel_b = ecs_lookup(world, "RelB");
-    ecs_entity_t foo = ecs_lookup(world, "Parent.Foo");
-    ecs_entity_t bar = ecs_lookup(world, "Parent.Bar");
+    ecs_entity_t e1 = ecs_lookup(world, "e1");
+    ecs_entity_t e2 = ecs_lookup(world, "e2");
+    ecs_entity_t e3 = ecs_lookup(world, "e3");
+    ecs_entity_t e4 = ecs_lookup(world, "e4");
 
-    test_assert(parent != 0);
-    test_assert(rel_a != 0);
-    test_assert(rel_b != 0);
-    test_assert(foo != 0);
-    test_assert(bar != 0);
+    test_assert(e1 != 0);
+    test_assert(e2 != 0);
+    test_assert(e3 != 0);
+    test_assert(e4 != 0);
 
-    test_assert( ecs_has_pair(world, foo, rel_a, bar));
-    test_assert( ecs_has_pair(world, foo, rel_b, bar));
+    const Position *p = ecs_get(world, e2, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    p = ecs_get(world, e3, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 30);
+    test_int(p->y, 40);
+
+    const Velocity *v = ecs_get(world, e1, Velocity);
+    test_assert(v != NULL);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    v = ecs_get(world, e4, Velocity);
+    test_assert(v != NULL);
+    test_int(v->x, 3);
+    test_int(v->y, 4);
 
     ecs_fini(world);
 }
 
-void Plecs_inherit_from_multiple(void) {
+void Eval_default_type_with_tag(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Inst : Foo, Bar";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t inst = ecs_lookup(world, "Inst");
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t bar = ecs_lookup(world, "Bar");
-
-    test_assert(inst != 0);
-    test_assert(foo != 0);
-    test_assert(bar != 0);
+    HEAD "with Foo {"
+    LINE "  e1 = 10, 20"
+    LINE "  e2 = 30, 40"
+    LINE "}";
 
-    test_assert(ecs_has_pair(world, inst, EcsIsA, foo));
-    test_assert(ecs_has_pair(world, inst, EcsIsA, bar));
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-// using flecs.meta
-// Struct(Position) {
-//   x :- {f32}
-//   y :- {f32}
-// }
-// Foo :- (Position, Bar){x: 10, y: 20}
-
-void Plecs_assign_pair_component(void) {
+void Eval_default_type_from_with_in_entity_scope_w_default_type(void) {
     ecs_world_t *world = ecs_init();
 
+    ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .entity = ecs_entity(world, {.name = "Position"}),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
+    ecs_entity_t ecs_id(Velocity) = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .entity = ecs_entity(world, {.name = "Velocity"}),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
     const char *expr =
-    HEAD "using flecs.meta"
-    LINE
-    LINE "Struct(Position) {"
-    LINE "  x :- {f32}"
-    LINE "  y :- {f32}"
-    LINE "}"
-    LINE
-    LINE "Foo :- (Position, Bar){x: 10, y: 20}";
+    HEAD "Foo = DefaultChildComponent: {Velocity}"
+    LINE "Foo Bar {"
+    LINE "  e3 = 1, 2"
+    LINE "  with Position {"
+    LINE "    e1 = 10, 20"
+    LINE "    e2 = 30, 40"
+    LINE "  }"
+    LINE "  e4 = 2, 3"
+    LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t bar = ecs_lookup(world, "Bar");
-    ecs_entity_t ecs_id(Position) = ecs_lookup(world, "Position");
+    ecs_entity_t e1 = ecs_lookup(world, "Bar.e1");
+    ecs_entity_t e2 = ecs_lookup(world, "Bar.e2");
+    ecs_entity_t e3 = ecs_lookup(world, "Bar.e3");
+    ecs_entity_t e4 = ecs_lookup(world, "Bar.e4");
 
-    test_assert(foo != 0);
-    test_assert(bar != 0);
-    test_assert(ecs_id(Position) != 0);
+    test_assert(ecs_has(world, e1, Position));
+    test_assert(ecs_has(world, e2, Position));
+    test_assert(!ecs_has(world, e3, Position));
+    test_assert(!ecs_has(world, e4, Position));
 
-    test_assert( ecs_has_pair(world, foo, ecs_id(Position), bar));
+    test_assert(!ecs_has(world, e1, Velocity));
+    test_assert(!ecs_has(world, e2, Velocity));
+    test_assert(ecs_has(world, e3, Velocity));
+    test_assert(ecs_has(world, e4, Velocity));
 
-    const Position *ptr = ecs_get_pair(world, foo, Position, bar);
-    test_assert(ptr != NULL);
-    test_int(ptr->x, 10);
-    test_int(ptr->y, 20);
+    test_assert(e1 != 0);
+    test_assert(e2 != 0);
+    test_assert(e3 != 0);
+    test_assert(e4 != 0);
+
+    const Position *p = ecs_get(world, e1, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    p = ecs_get(world, e2, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 30);
+    test_int(p->y, 40);
+
+    const Velocity *v = ecs_get(world, e3, Velocity);
+    test_assert(v != NULL);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    v = ecs_get(world, e4, Velocity);
+    test_assert(v != NULL);
+    test_int(v->x, 2);
+    test_int(v->y, 3);
 
     ecs_fini(world);
 }
 
-void Plecs_assign_pair_component_in_scope(void) {
+void Eval_default_type_from_entity_scope_in_with(void) {
     ecs_world_t *world = ecs_init();
 
+    ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .entity = ecs_entity(world, {.name = "Position"}),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
     const char *expr =
     HEAD "using flecs.meta"
-    LINE
-    LINE "Struct(Position) {"
-    LINE "  x :- {f32}"
-    LINE "  y :- {f32}"
+    LINE "with Position {"
+    LINE "  e1 = 10, 20"
+    LINE "  struct Velocity {"
+    LINE "    x = f32"
+    LINE "    y = f32"
+    LINE "  }"
+    LINE "  e2 = 30, 40"
     LINE "}"
-    LINE
-    LINE "Parent {"
-    LINE "  - (Position, Foo) {x: 10, y: 20}"
-    LINE "  - (Position, Bar) {x: 20, y: 30}"
-    LINE "}";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    LINE "e3 = Velocity: {1, 2}";
 
-    ecs_entity_t parent = ecs_lookup(world, "Parent");
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t bar = ecs_lookup(world, "Bar");
-    ecs_entity_t ecs_id(Position) = ecs_lookup(world, "Position");
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(parent != 0);
-    test_assert(foo != 0);
-    test_assert(bar != 0);
-    test_assert(ecs_id(Position) != 0);
+    ecs_entity_t e1 = ecs_lookup(world, "e1");
+    ecs_entity_t e2 = ecs_lookup(world, "e2");
+    ecs_entity_t e3 = ecs_lookup(world, "e3");
+    ecs_entity_t ecs_id(Velocity) = ecs_lookup(world, "Velocity");
+
+    test_assert(e1 != 0);
+    test_assert(e2 != 0);
+    test_assert(e3 != 0);
+    test_assert(ecs_id(Velocity) != 0);
+
+    const Position *p = ecs_get(world, e1, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
+
+    p = ecs_get(world, e2, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 30);
+    test_int(p->y, 40);
+
+    const Velocity *v = ecs_get(world, e3, Velocity);
+    test_assert(v != NULL);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
+
+    ecs_fini(world);
+}
+
+void Eval_scope_w_1_subj_and_2_pairs(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Parent {"
+    LINE " Foo { (RelA, Bar) }"
+    LINE " Foo { (RelB, Bar) }"
+    LINE "}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t rel_a = ecs_lookup(world, "RelA");
+    ecs_entity_t rel_b = ecs_lookup(world, "RelB");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    ecs_entity_t foo = ecs_lookup(world, "Parent.Foo");
+
+    test_assert(parent != 0);
+    test_assert(rel_a != 0);
+    test_assert(rel_b != 0);
+    test_assert(foo != 0);
+    test_assert(bar != 0);
+
+    test_assert( ecs_has_pair(world, foo, rel_a, bar));
+    test_assert( ecs_has_pair(world, foo, rel_b, bar));
+
+    ecs_fini(world);
+}
+
+void Eval_inherit_from_multiple(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "Inst : Foo, Bar {}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t inst = ecs_lookup(world, "Inst");
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+
+    test_assert(inst != 0);
+    test_assert(foo != 0);
+    test_assert(bar != 0);
+
+    test_assert(ecs_has_pair(world, inst, EcsIsA, foo));
+    test_assert(ecs_has_pair(world, inst, EcsIsA, bar));
+
+    ecs_fini(world);
+}
+
+void Eval_assign_pair_component(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "using flecs.meta"
+    LINE
+    LINE "struct Position {"
+    LINE "  x = f32"
+    LINE "  y = f32"
+    LINE "}"
+    LINE
+    LINE "Foo { (Position, Bar): {x: 10, y: 20} }";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    ecs_entity_t ecs_id(Position) = ecs_lookup(world, "Position");
+
+    test_assert(foo != 0);
+    test_assert(bar != 0);
+    test_assert(ecs_id(Position) != 0);
+
+    test_assert( ecs_has_pair(world, foo, ecs_id(Position), bar));
+
+    const Position *ptr = ecs_get_pair(world, foo, Position, bar);
+    test_assert(ptr != NULL);
+    test_int(ptr->x, 10);
+    test_int(ptr->y, 20);
+
+    ecs_fini(world);
+}
+
+void Eval_assign_pair_component_in_scope(void) {
+    ecs_world_t *world = ecs_init();
+
+    const char *expr =
+    HEAD "using flecs.meta"
+    LINE
+    LINE "struct Position {"
+    LINE "  x = f32"
+    LINE "  y = f32"
+    LINE "}"
+    LINE
+    LINE "Parent {"
+    LINE "  (Position, Foo): {x: 10, y: 20}"
+    LINE "  (Position, Bar): {x: 20, y: 30}"
+    LINE "}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    ecs_entity_t ecs_id(Position) = ecs_lookup(world, "Position");
+
+    test_assert(parent != 0);
+    test_assert(foo != 0);
+    test_assert(bar != 0);
+    test_assert(ecs_id(Position) != 0);
 
     test_assert( ecs_has_pair(world, parent, ecs_id(Position), foo));
     test_assert( ecs_has_pair(world, parent, ecs_id(Position), bar));
@@ -3491,22 +3781,22 @@ void Plecs_assign_pair_component_in_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_assign_pair_component_in_script(void) {
+void Eval_assign_pair_component_in_script(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Struct(Position) {"
-    LINE "  x :- {f32}"
-    LINE "  y :- {f32}"
+    LINE "struct Position {"
+    LINE "  x = f32"
+    LINE "  y = f32"
     LINE "}"
     LINE
-    LINE "Foo :- (Position, Bar){x: 10, y: 20}";
+    LINE "Foo { (Position, Bar): {x: 10, y: 20} }";
 
     ecs_entity_t s = ecs_script(world, {
         .entity = ecs_entity(world, { .name = "main" }),
-        .str = expr
+        .code = expr
     });
     test_assert(s != 0);
 
@@ -3528,26 +3818,26 @@ void Plecs_assign_pair_component_in_script(void) {
     ecs_fini(world);
 }
 
-void Plecs_assign_pair_component_in_script_update(void) {
+void Eval_assign_pair_component_in_script_update(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "using flecs.meta"
     LINE
-    LINE "Struct(Position) {"
-    LINE "  x :- {f32}"
-    LINE "  y :- {f32}"
+    LINE "struct Position {"
+    LINE "  x = f32"
+    LINE "  y = f32"
     LINE "}"
     LINE
-    LINE "Foo :- (Position, Bar){x: 10, y: 20}";
+    LINE "Foo { (Position, Bar): {x: 10, y: 20} }";
 
     ecs_entity_t s = ecs_script(world, {
         .entity = ecs_entity(world, { .name = "main" }),
-        .str = expr
+        .code = expr
     });
     test_assert(s != 0);
 
-    test_assert(ecs_script_update(world, s, 0, expr, NULL) == 0);
+    test_assert(ecs_script_update(world, s, 0, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -3567,17 +3857,17 @@ void Plecs_assign_pair_component_in_script_update(void) {
     ecs_fini(world);
 }
 
-void Plecs_set_entity_names(void) {
+void Eval_set_entity_names(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "foo(self)"
-    LINE "foo(parent)"
-    LINE "foo(cascade)"
-    LINE "foo(down)"
-    LINE "foo(up)";
+    HEAD "foo self {}"
+    LINE "foo parent {}"
+    LINE "foo cascade {}"
+    LINE "foo down {}"
+    LINE "foo up {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "foo");
     ecs_entity_t self = ecs_lookup(world, "self");
@@ -3602,18 +3892,18 @@ void Plecs_set_entity_names(void) {
     ecs_fini(world);
 }
 
-void Plecs_oneof(void) {
+void Eval_oneof(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "flecs.meta.Enum(Color) {"
-    LINE "  flecs.meta.Constant(Red)"
-    LINE "  flecs.meta.Constant(Green)"
-    LINE "  flecs.meta.Constant(Blue)"
+    HEAD "flecs.meta.enum Color {"
+    LINE "  flecs.meta.constant Red"
+    LINE "  flecs.meta.constant Green"
+    LINE "  flecs.meta.constant Blue"
     LINE "}"
-    LINE "e :- (Color, Green)";
+    LINE "e { (Color, Green) }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t color = ecs_lookup(world, "Color");
     ecs_entity_t green = ecs_lookup(world, "Color.Green");
@@ -3631,20 +3921,20 @@ void Plecs_oneof(void) {
     ecs_fini(world);
 }
 
-void Plecs_invalid_oneof(void) {
+void Eval_invalid_oneof(void) {
     ecs_log_set_level(-4);
     
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "flecs.meta.Enum(Color) {"
-    LINE "  flecs.meta.Constant(Red)"
-    LINE "  flecs.meta.Constant(Green)"
-    LINE "  flecs.meta.Constant(Blue)"
+    HEAD "flecs.meta.enum Color {"
+    LINE "  flecs.meta.constant Red"
+    LINE "  flecs.meta.constant Green"
+    LINE "  flecs.meta.constant Blue"
     LINE "}"
-    LINE "e :- (Color, Foo)";
+    LINE "e { (Color, Foo) }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_entity_t color = ecs_lookup(world, "Color");
     ecs_entity_t foo = ecs_lookup(world, "Foo");
@@ -3659,18 +3949,18 @@ void Plecs_invalid_oneof(void) {
     ecs_fini(world);
 }
 
-void Plecs_brief_annotation(void) {
+void Eval_brief_annotation(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "@brief A description"
-    LINE "Foo"
-    LINE "Bar"
+    LINE "Foo {}"
+    LINE "Bar {}"
     LINE ""
     LINE "@brief Another description"
-    LINE "Baz";
+    LINE "Baz {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -3687,18 +3977,18 @@ void Plecs_brief_annotation(void) {
     ecs_fini(world);
 }
 
-void Plecs_name_annotation(void) {
+void Eval_name_annotation(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "@name A name"
-    LINE "Foo"
-    LINE "Bar"
+    LINE "Foo {}"
+    LINE "Bar {}"
     LINE ""
     LINE "@name Another name"
-    LINE "Baz";
+    LINE "Baz {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -3715,18 +4005,18 @@ void Plecs_name_annotation(void) {
     ecs_fini(world);
 }
 
-void Plecs_link_annotation(void) {
+void Eval_link_annotation(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "@link A link"
-    LINE "Foo"
-    LINE "Bar"
+    LINE "Foo {}"
+    LINE "Bar {}"
     LINE ""
     LINE "@link Another link"
-    LINE "Baz";
+    LINE "Baz {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -3743,18 +4033,18 @@ void Plecs_link_annotation(void) {
     ecs_fini(world);
 }
 
-void Plecs_color_annotation(void) {
+void Eval_color_annotation(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "@color #554433"
-    LINE "Foo"
-    LINE "Bar"
+    LINE "Foo {}"
+    LINE "Bar {}"
     LINE ""
     LINE "@color rgb(10, 20, 30, 1.0)"
-    LINE "Baz";
+    LINE "Baz {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -3771,7 +4061,7 @@ void Plecs_color_annotation(void) {
     ecs_fini(world);
 }
 
-void Plecs_multiple_annotations(void) {
+void Eval_multiple_annotations(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
@@ -3779,14 +4069,14 @@ void Plecs_multiple_annotations(void) {
     LINE "@name A name"
     LINE "@link A link"
     LINE "@color #554433"
-    LINE "Foo"
-    LINE "Bar"
+    LINE "Foo {}"
+    LINE "Bar {}"
     LINE ""
     LINE "@brief Another description"
     LINE "@name Another name"
-    LINE "Baz";
+    LINE "Baz {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -3807,14 +4097,14 @@ void Plecs_multiple_annotations(void) {
     ecs_fini(world);
 }
 
-void Plecs_annotation_w_trailing_space(void) {
+void Eval_annotation_w_trailing_space(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "@brief   A description  "
-    LINE "Foo";
+    LINE "Foo {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -3828,7 +4118,7 @@ typedef struct String {
     char *value;
 } String;
 
-void Plecs_multiline_string(void) {
+void Eval_multiline_string(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(String) = ecs_struct_init(world, &(ecs_struct_desc_t){
@@ -3839,13 +4129,13 @@ void Plecs_multiline_string(void) {
     });
 
     const char *expr =
-    HEAD "Foo :- String{value: `start"
+    HEAD "Foo { String: {value: `start"
     LINE "Hello World"
     LINE "Foo Bar"
     LINE "Special characters }{\"\"'',"
-    LINE "`}";
+    LINE "`}}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -3866,7 +4156,7 @@ void Plecs_multiline_string(void) {
     ecs_fini(world);
 }
 
-void Plecs_unterminated_multiline_string(void) {
+void Eval_unterminated_multiline_string(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_struct_init(world, &(ecs_struct_desc_t){
@@ -3877,26 +4167,26 @@ void Plecs_unterminated_multiline_string(void) {
     });
 
     const char *expr =
-    HEAD "Foo :- String{value: `start"
+    HEAD "Foo { String: {value: `start"
     LINE "Hello World"
     LINE "Foo Bar"
     LINE "Special characters }{\"\"'',"
-    LINE "}";
+    LINE "}}";
 
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_annotate_declaration(void) {
+void Eval_annotate_declaration(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "@brief A brief description"
     LINE "Foo Bar";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -3913,13 +4203,13 @@ void Plecs_annotate_declaration(void) {
     ecs_fini(world);
 }
 
-void Plecs_declaration_w_underscore_name(void) {
+void Eval_declaration_w_underscore_name(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo _Bar";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -3933,78 +4223,78 @@ void Plecs_declaration_w_underscore_name(void) {
     ecs_fini(world);
 }
 
-void Plecs_anonymous_entity(void) {
+void Eval_anonymous_entity(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "_ :- Foo";
+    HEAD "_ { Foo }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ foo });
-    test_assert(ecs_term_next(&it));
+    ecs_iter_t it = ecs_each_id(world, foo );
+    test_assert(ecs_each_next(&it));
     test_int(it.count, 1);
     ecs_entity_t e = it.entities[0];
     test_assert(e != 0);
     test_str(ecs_get_name(world, e), NULL);
-    test_assert(!ecs_term_next(&it));
+    test_assert(!ecs_each_next(&it));
 
     ecs_fini(world);
 }
 
-void Plecs_anonymous_entity_in_scope(void) {
+void Eval_anonymous_entity_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Parent {"
-    LINE "  _ :- Foo"
+    LINE "  _ { Foo }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
     ecs_entity_t parent = ecs_lookup(world, "Parent");
     test_assert(parent != 0);
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ foo });
-    test_assert(ecs_term_next(&it));
+    ecs_iter_t it = ecs_each_id(world, foo );
+    test_assert(ecs_each_next(&it));
     test_int(it.count, 1);
     ecs_entity_t e = it.entities[0];
     test_assert(e != 0);
     test_str(ecs_get_name(world, e), NULL);
     test_assert(ecs_has_pair(world, e, EcsChildOf, parent));
-    test_assert(!ecs_term_next(&it));
+    test_assert(!ecs_each_next(&it));
 
     ecs_fini(world);
 }
 
-void Plecs_anonymous_declaration(void) {
+void Eval_anonymous_declaration(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
     HEAD "Foo _";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
 
-    ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t){ foo });
-    test_assert(ecs_term_next(&it));
+    ecs_iter_t it = ecs_each_id(world, foo );
+    test_assert(ecs_each_next(&it));
     test_int(it.count, 1);
     ecs_entity_t e = it.entities[0];
     test_assert(e != 0);
     test_str(ecs_get_name(world, e), NULL);
-    test_assert(!ecs_term_next(&it));
+    test_assert(!ecs_each_next(&it));
 
     ecs_fini(world);
 }
 
-void Plecs_const_var_int(void) {
+void Eval_const_var_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4019,9 +4309,9 @@ void Plecs_const_var_int(void) {
     HEAD "const var_x = 10"
     LINE "const var_y = 20"
     LINE ""
-    LINE "e :- Position{$var_x, $var_y}";
+    LINE "e { Position: {$var_x, $var_y} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
@@ -4035,7 +4325,7 @@ void Plecs_const_var_int(void) {
     ecs_fini(world);
 }
 
-void Plecs_const_var_float(void) {
+void Eval_const_var_float(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4050,9 +4340,9 @@ void Plecs_const_var_float(void) {
     HEAD "const var_x = 10.5"
     LINE "const var_y = 20.5"
     LINE ""
-    LINE "e :- Position{$var_x, $var_y}";
+    LINE "e { Position: {$var_x, $var_y} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
@@ -4066,7 +4356,7 @@ void Plecs_const_var_float(void) {
     ecs_fini(world);
 }
 
-void Plecs_const_var_bool(void) {
+void Eval_const_var_bool(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct Bools {
@@ -4086,9 +4376,9 @@ void Plecs_const_var_bool(void) {
     HEAD "const var_x = true"
     LINE "const var_y = false"
     LINE ""
-    LINE "e :- Bools{$var_x, $var_y}";
+    LINE "e { Bools: {$var_x, $var_y} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
@@ -4102,7 +4392,7 @@ void Plecs_const_var_bool(void) {
     ecs_fini(world);
 }
 
-void Plecs_const_var_string(void) {
+void Eval_const_var_string(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4117,9 +4407,9 @@ void Plecs_const_var_string(void) {
     HEAD "const var_x = \"10.5\""
     LINE "const var_y = \"20.5\""
     LINE ""
-    LINE "e :- Position{$var_x, $var_y}";
+    LINE "e { Position: {$var_x, $var_y} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
@@ -4133,16 +4423,11 @@ void Plecs_const_var_string(void) {
     ecs_fini(world);
 }
 
-typedef struct Line {
-    Position start;
-    Position stop;
-} Line;
-
-void Plecs_const_var_struct(void) {
+void Eval_const_var_struct(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t ecs_id(Position) = ecs_struct(world, {
-        .entity = ecs_entity(world, {.name = "Position"}),
+    ecs_entity_t ecs_id(Point) = ecs_struct(world, {
+        .entity = ecs_entity(world, {.name = "Point"}),
         .members = {
             {"x", ecs_id(ecs_f32_t)},
             {"y", ecs_id(ecs_f32_t)}
@@ -4152,18 +4437,18 @@ void Plecs_const_var_struct(void) {
     ecs_entity_t ecs_id(Line) = ecs_struct(world, {
         .entity = ecs_entity(world, {.name = "Line"}),
         .members = {
-            {"start", ecs_id(Position)},
-            {"stop", ecs_id(Position)}
+            {"start", ecs_id(Point)},
+            {"stop", ecs_id(Point)}
         }
     });
 
     const char *expr =
-    HEAD "const var_start = Position{10.5, 20.5}"
-    LINE "const var_stop = Position{30.5, 40.5}"
+    HEAD "const var_start = Point: {10.5, 20.5}"
+    LINE "const var_stop = Point: {30.5, 40.5}"
     LINE ""
-    LINE "e :- Line{start: $var_start, stop: $var_stop}";
+    LINE "e { Line: {start: $var_start, stop: $var_stop} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
@@ -4179,7 +4464,7 @@ void Plecs_const_var_struct(void) {
     ecs_fini(world);
 }
 
-void Plecs_const_var_redeclare(void) {
+void Eval_const_var_redeclare(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
@@ -4187,12 +4472,12 @@ void Plecs_const_var_redeclare(void) {
     LINE "const var_x = 20";
 
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_const_var_scoped(void) {
+void Eval_const_var_scoped(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4205,18 +4490,18 @@ void Plecs_const_var_scoped(void) {
 
     const char *expr =
     HEAD "const var_x = 10"
-    LINE "a :- Position{$var_x, $var_x}"
+    LINE "a { Position: {$var_x, $var_x} }"
     LINE "a {"
     LINE "  const var_x = 20"
     LINE "  const var_y = 30"
-    LINE "  b :- Position{$var_x, $var_y}"
+    LINE "  b { Position: {$var_x, $var_y} }"
     LINE "}"
     LINE "a {"
     LINE "  const var_y = 20"
-    LINE "  c :- Position{$var_x, $var_y}"
+    LINE "  c { Position: {$var_x, $var_y} }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t a = ecs_lookup(world, "a");
     test_assert(a != 0);
@@ -4248,7 +4533,7 @@ void Plecs_const_var_scoped(void) {
     ecs_fini(world);
 }
 
-void Plecs_assign_component_from_var(void) {
+void Eval_assign_component_from_var(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4260,11 +4545,11 @@ void Plecs_assign_component_from_var(void) {
     });
 
     const char *expr =
-    HEAD "const var_pos = Position{10, 20}"
-    LINE "a :- $var_pos"
+    HEAD "const var_pos = Position: {10, 20}"
+    LINE "a { $var_pos }"
     LINE "";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t var = ecs_lookup(world, "var_pos");
     test_assert(var == 0);
@@ -4280,7 +4565,7 @@ void Plecs_assign_component_from_var(void) {
     ecs_fini(world);
 }
 
-void Plecs_assign_component_from_var_in_scope(void) {
+void Eval_assign_component_from_var_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4292,13 +4577,13 @@ void Plecs_assign_component_from_var_in_scope(void) {
     });
 
     const char *expr =
-    HEAD "const var_pos = Position{10, 20}"
+    HEAD "const var_pos = Position: {10, 20}"
     LINE "a {"
-    LINE " - $var_pos"
+    LINE "  $var_pos"
     LINE "}"
     LINE "";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t var = ecs_lookup(world, "var_pos");
     test_assert(var == 0);
@@ -4314,7 +4599,7 @@ void Plecs_assign_component_from_var_in_scope(void) {
     ecs_fini(world);
 }
 
-void Plecs_scope_w_component_after_const_var(void) {
+void Eval_scope_w_component_after_const_var(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4328,10 +4613,10 @@ void Plecs_scope_w_component_after_const_var(void) {
     const char *expr =
     HEAD "Foo {"
     LINE "  const var = 5"
-    LINE "  - Position{x: 10, y: $var}"
+    LINE "  Position: {x: 10, y: $var}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -4345,7 +4630,7 @@ void Plecs_scope_w_component_after_const_var(void) {
     ecs_fini(world);
 }
 
-void Plecs_component_after_const_add_expr(void) {
+void Eval_component_after_const_add_expr(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4359,10 +4644,10 @@ void Plecs_component_after_const_add_expr(void) {
     const char *expr =
     HEAD "Foo {"
     LINE "  const var = 5 + 15"
-    LINE "  - Position{x: 10, y: $var}"
+    LINE "  Position: {x: 10, y: $var}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -4376,7 +4661,7 @@ void Plecs_component_after_const_add_expr(void) {
     ecs_fini(world);
 }
 
-void Plecs_component_after_const_sub_expr(void) {
+void Eval_component_after_const_sub_expr(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4390,10 +4675,10 @@ void Plecs_component_after_const_sub_expr(void) {
     const char *expr =
     HEAD "Foo {"
     LINE "  const var = 25 - 5"
-    LINE "  - Position{x: 10, y: $var}"
+    LINE "  Position: {x: 10, y: $var}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -4407,7 +4692,7 @@ void Plecs_component_after_const_sub_expr(void) {
     ecs_fini(world);
 }
 
-void Plecs_component_after_const_mul_expr(void) {
+void Eval_component_after_const_mul_expr(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4421,10 +4706,10 @@ void Plecs_component_after_const_mul_expr(void) {
     const char *expr =
     HEAD "Foo {"
     LINE "  const var = 2 * 10"
-    LINE "  - Position{x: 10, y: $var}"
+    LINE "  Position: {x: 10, y: $var}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -4438,7 +4723,7 @@ void Plecs_component_after_const_mul_expr(void) {
     ecs_fini(world);
 }
 
-void Plecs_component_after_const_div_expr(void) {
+void Eval_component_after_const_div_expr(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -4452,10 +4737,10 @@ void Plecs_component_after_const_div_expr(void) {
     const char *expr =
     HEAD "Foo {"
     LINE "  const var = 40 / 2"
-    LINE "  - Position{x: 10, y: $var}"
+    LINE "  Position: {x: 10, y: $var}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     test_assert(foo != 0);
@@ -4469,7 +4754,7 @@ void Plecs_component_after_const_div_expr(void) {
     ecs_fini(world);
 }
 
-void Plecs_component_after_const_paren_expr(void) {
+void Eval_component_after_const_paren_expr(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -4485,10 +4770,10 @@ void Plecs_component_after_const_paren_expr(void) {
     const char *expr =
     LINE "e {"
     LINE "  const val = (10 + 20)"
-    LINE "  - Position{$val, $val * 2}"
+    LINE "  Position: {$val, $val * 2}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
@@ -4502,19 +4787,19 @@ void Plecs_component_after_const_paren_expr(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with(void) {
+void Eval_parse_with(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    HEAD "Foo"
+    HEAD "Foo {}"
     LINE "Bar {"
-    LINE "  Hello"
+    LINE "  Hello {}"
     LINE "}";
 
     ECS_TAG(world, Tag);
 
     ecs_set_with(world, Tag);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_set_with(world, 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
@@ -4532,22 +4817,22 @@ void Plecs_parse_with(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with_w_with(void) {
+void Eval_parse_with_w_with(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
     const char *expr =
-    HEAD "Foo"
+    HEAD "Foo {}"
     LINE "with TagB {"
     LINE "  Bar {"
-    LINE "    Hello"
+    LINE "    Hello {}"
     LINE "  }"
     LINE "}";
 
     ecs_set_with(world, TagA);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_set_with(world, 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
@@ -4570,22 +4855,22 @@ void Plecs_parse_with_w_with(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with_w_tag(void) {
+void Eval_parse_with_w_tag(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_TAG(world, TagA);
     ECS_TAG(world, TagB);
 
     const char *expr =
-    HEAD "Foo"
+    HEAD "Foo {}"
     LINE "with TagB {"
     LINE "  Bar {"
-    LINE "    - Hello"
+    LINE "    Hello"
     LINE "  }"
     LINE "}";
 
     ecs_set_with(world, TagA);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
     ecs_set_with(world, 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
@@ -4609,7 +4894,7 @@ void Plecs_parse_with_w_tag(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with_value(void) {
+void Eval_parse_with_value(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -4623,12 +4908,12 @@ void Plecs_parse_with_value(void) {
     });
 
     const char *expr =
-    LINE "with Position{10, 20} {"
-    LINE "  Foo"
-    LINE "  Bar"
+    LINE "with Position(10, 20) {"
+    LINE "  Foo {}"
+    LINE "  Bar {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -4653,7 +4938,7 @@ void Plecs_parse_with_value(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with_2_values(void) {
+void Eval_parse_with_2_values(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -4676,12 +4961,12 @@ void Plecs_parse_with_2_values(void) {
     });
 
     const char *expr =
-    LINE "with Position{10, 20}, Velocity{1, 2} {"
-    LINE "  Foo"
-    LINE "  Bar"
+    LINE "with Position(10, 20), Velocity(1, 2) {"
+    LINE "  Foo {}"
+    LINE "  Bar {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -4718,7 +5003,7 @@ void Plecs_parse_with_2_values(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with_2_nested_values(void) {
+void Eval_parse_with_2_nested_values(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -4741,14 +5026,14 @@ void Plecs_parse_with_2_nested_values(void) {
     });
 
     const char *expr =
-    LINE "with Position{10, 20} {"
-    LINE "  with Velocity{1, 2} {"
-    LINE "    Foo"
-    LINE "    Bar"
+    LINE "with Position(10, 20) {"
+    LINE "  with Velocity(1, 2) {"
+    LINE "    Foo {}"
+    LINE "    Bar {}"
     LINE "  }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -4785,7 +5070,7 @@ void Plecs_parse_with_2_nested_values(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with_var(void) {
+void Eval_parse_with_var(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -4799,13 +5084,13 @@ void Plecs_parse_with_var(void) {
     });
 
     const char *expr =
-    LINE "const pos : Position = {10, 20}"
+    LINE "const pos = Position: {10, 20}"
     LINE "with $pos {"
-    LINE "  Foo"
-    LINE "  Bar"
+    LINE "  Foo {}"
+    LINE "  Bar {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -4829,7 +5114,7 @@ void Plecs_parse_with_var(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with_2_vars(void) {
+void Eval_parse_with_2_vars(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -4852,14 +5137,14 @@ void Plecs_parse_with_2_vars(void) {
     });
 
     const char *expr =
-    LINE "const pos : Position = {10, 20}"
-    LINE "const vel : Velocity = {1, 2}"
+    LINE "const pos = Position: {10, 20}"
+    LINE "const vel = Velocity: {1, 2}"
     LINE "with $pos, $vel {"
-    LINE "  Foo"
-    LINE "  Bar"
+    LINE "  Foo {}"
+    LINE "  Bar {}"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -4896,7 +5181,7 @@ void Plecs_parse_with_2_vars(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with_2_nested_vars(void) {
+void Eval_parse_with_2_nested_vars(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -4919,16 +5204,16 @@ void Plecs_parse_with_2_nested_vars(void) {
     });
 
     const char *expr =
-    LINE "const pos : Position = {10, 20}"
-    LINE "const vel : Velocity = {1, 2}"
+    LINE "const pos = Position: {10, 20}"
+    LINE "const vel = Velocity: {1, 2}"
     LINE "with $pos, $vel {"
     LINE "  with $vel {"
-    LINE "    Foo"
-    LINE "    Bar"
+    LINE "    Foo {}"
+    LINE "    Bar {}"
     LINE "  }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t foo = ecs_lookup(world, "Foo");
     ecs_entity_t bar = ecs_lookup(world, "Bar");
@@ -4965,7 +5250,7 @@ void Plecs_parse_with_2_nested_vars(void) {
     ecs_fini(world);
 }
 
-void Plecs_parse_with_var_in_scope(void) {
+void Eval_parse_with_var_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -4980,14 +5265,14 @@ void Plecs_parse_with_var_in_scope(void) {
 
     const char *expr =
     LINE "Parent {"
-    LINE "  const pos : Position = {10, 20}"
+    LINE "  const pos = Position: {10, 20}"
     LINE "  with $pos { "
-    LINE "    Foo"
-    LINE "    Bar"
+    LINE "    Foo {}"
+    LINE "    Bar {}"
     LINE "  }"
     LINE "}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t parent = ecs_lookup(world, "Parent");
     ecs_entity_t foo = ecs_lookup(world, "Parent.Foo");
@@ -5014,7 +5299,7 @@ void Plecs_parse_with_var_in_scope(void) {
 }
 
 
-void Plecs_assign_const_w_expr(void) {
+void Eval_assign_const_w_expr(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -5027,9 +5312,9 @@ void Plecs_assign_const_w_expr(void) {
 
     const char *expr =
     LINE "const var = 5 + 1"
-    LINE "e :- Position{x: $var, y: $var * 2}";
+    LINE "e { Position: {x: $var, y: $var * 2} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
@@ -5043,7 +5328,7 @@ void Plecs_assign_const_w_expr(void) {
     ecs_fini(world);
 }
 
-void Plecs_const_w_type(void) {
+void Eval_const_w_type(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t ecs_id(Position) = ecs_struct(world, {
@@ -5055,10 +5340,10 @@ void Plecs_const_w_type(void) {
     });
 
     const char *expr =
-    LINE "const var : flecs.meta.i32 = 5 / 2"
-    LINE "e :- Position{x: $var, y: $var * 3}";
+    LINE "const var = flecs.meta.i32: 5 / 2"
+    LINE "e { Position: {x: $var, y: $var * 3} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
@@ -5072,13 +5357,11 @@ void Plecs_const_w_type(void) {
     ecs_fini(world);
 }
 
-void Plecs_assembly_no_scope(void) {
+void Eval_typed_const_w_composite_type_invalid_assignment(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
     ecs_struct(world, {
-        .entity = ecs_id(Position),
+        .entity = ecs_entity(world, {.name = "Position"}),
         .members = {
             {"x", ecs_id(ecs_f32_t)},
             {"y", ecs_id(ecs_f32_t)}
@@ -5086,23 +5369,21 @@ void Plecs_assembly_no_scope(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    HEAD "const var_pos = Position: Position{10, 20}"
+    LINE "a { $var_pos }"
+    LINE "";
 
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_empty(void) {
+void Eval_typed_const_w_composite_type(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
+    ecs_entity_t ecs_id(Position) = ecs_struct(world, {
+        .entity = ecs_entity(world, {.name = "Position"}),
         .members = {
             {"x", ecs_id(ecs_f32_t)},
             {"y", ecs_id(ecs_f32_t)}
@@ -5110,22 +5391,31 @@ void Plecs_assembly_empty(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "}";
+    HEAD "const var_pos = Position: {10, 20}"
+    LINE "a { $var_pos }"
+    LINE "";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t var = ecs_lookup(world, "var_pos");
+    test_assert(var == 0);
+
+    ecs_entity_t a = ecs_lookup(world, "a");
+    test_assert(a != 0);
+
+    const Position *p = ecs_get(world, a, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_no_props(void) {
+void Eval_assign_var_to_typed_const_w_composite_type(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
+    ecs_entity_t ecs_id(Position) = ecs_struct(world, {
+        .entity = ecs_entity(world, {.name = "Position"}),
         .members = {
             {"x", ecs_id(ecs_f32_t)},
             {"y", ecs_id(ecs_f32_t)}
@@ -5133,19 +5423,34 @@ void Plecs_assembly_no_props(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  - Foo"
-    LINE "}";
+    HEAD "const var_pos_a = Position: {10, 20}"
+    HEAD "const var_pos_b = $var_pos_a"
+    LINE "a { $var_pos_b }"
+    LINE "";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t var = ecs_lookup(world, "var_pos");
+    test_assert(var == 0);
+
+    ecs_entity_t a = ecs_lookup(world, "a");
+    test_assert(a != 0);
+
+    const Position *p = ecs_get(world, a, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_prop_no_type(void) {
+void Eval_using_wildcard(void) {
     ecs_world_t *world = ecs_init();
 
+    ecs_entity_t p1 = ecs_entity(world, { .name = "foo.p1" });
+    ecs_entity_t p2 = ecs_entity(world, { .name = "foo.p2" });
+
+    ecs_set_scope(world, p1);
     ECS_COMPONENT(world, Position);
 
     ecs_struct(world, {
@@ -5156,42 +5461,52 @@ void Plecs_assembly_prop_no_type(void) {
         }
     });
 
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop height"
-    LINE "}";
-
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_prop_no_default(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
+    ecs_set_scope(world, p2);
+    ECS_COMPONENT(world, Velocity);
 
     ecs_struct(world, {
-        .entity = ecs_id(Position),
+        .entity = ecs_id(Velocity),
         .members = {
             {"x", ecs_id(ecs_f32_t)},
             {"y", ecs_id(ecs_f32_t)}
         }
     });
 
+    ecs_set_scope(world, 0);
+
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop height: flecs.meta.f32"
-    LINE "}";
+    LINE "using foo.*\n"
+    LINE "e { Position: {10, 20} }\n"
+    LINE "e { Velocity: {1, 2} }\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    ecs_entity_t pos = ecs_lookup(world, "foo.p1.Position");
+    test_assert(pos == ecs_id(Position));
+    ecs_entity_t vel = ecs_lookup(world, "foo.p2.Velocity");
+    test_assert(vel == ecs_id(Velocity));
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has(world, e, Velocity));
+
+    {
+        const Position *ptr = ecs_get(world, e, Position);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 10);
+        test_int(ptr->y, 20);
+    }
+    {
+        const Velocity *ptr = ecs_get(world, e, Velocity);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 1);
+        test_int(ptr->y, 2);
+    }
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_prop(void) {
+void Eval_single_line_comment_in_value(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5205,25 +5520,27 @@ void Plecs_assembly_prop(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop height: flecs.meta.f32 = 0"
-    LINE "}";
+    LINE "e {Position: {\n"
+    LINE "  x: 10\n"
+    LINE "  //foo\n"
+    LINE "  y: 20\n"
+    LINE "}}";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
 
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    test_assert(ecs_has(world, e, Position));
 
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 1);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    const Position *ptr = ecs_get(world, e, Position);
+    test_assert(ptr != NULL);
+    test_int(ptr->x, 10);
+    test_int(ptr->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_prop_space_colon(void) {
+void Eval_single_line_comment_in_value_after_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5237,25 +5554,27 @@ void Plecs_assembly_prop_space_colon(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "}";
+    LINE "e {Position:{\n"
+    LINE "  // foo\n"
+    LINE "  x: 10\n"
+    LINE "  y: 20\n"
+    LINE "}}";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
 
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    test_assert(ecs_has(world, e, Position));
 
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 1);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
+    const Position *ptr = ecs_get(world, e, Position);
+    test_assert(ptr != NULL);
+    test_int(ptr->x, 10);
+    test_int(ptr->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_2_props(void) {
+void Eval_multi_line_comment_in_value(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5269,28 +5588,29 @@ void Plecs_assembly_2_props(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.i32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "}";
+    LINE "e {Position: {\n"
+    LINE "  x: 10\n"
+    LINE "  /*\n"
+    LINE "   * foo\n"
+    LINE "   */\n"
+    LINE "  y: 20\n"
+    LINE "}}";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
 
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    test_assert(ecs_has(world, e, Position));
 
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_i32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+    const Position *ptr = ecs_get(world, e, Position);
+    test_assert(ptr != NULL);
+    test_int(ptr->x, 10);
+    test_int(ptr->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_instance_w_default_values(void) {
+void Eval_multi_line_comment_in_value_after_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5304,42 +5624,29 @@ void Plecs_assembly_instance_w_default_values(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 10"
-    LINE "  prop height : flecs.meta.f32 = 20"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    LINE "e {Position: {\n"
+    LINE "  /*\n"
+    LINE "   * foo\n"
+    LINE "   */\n"
+    LINE "  x: 10\n"
+    LINE "  y: 20\n"
+    LINE "}}";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
     ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
 
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+    test_assert(ecs_has(world, e, Position));
 
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
+    const Position *ptr = ecs_get(world, e, Position);
     test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 10, height: 20}");
-    ecs_os_free(str);
+    test_int(ptr->x, 10);
+    test_int(ptr->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_instance_w_assign_default_values(void) {
+void Eval_unterminated_multi_line_comment_in_value(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5353,42 +5660,19 @@ void Plecs_assembly_instance_w_assign_default_values(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 10"
-    LINE "  prop height : flecs.meta.f32 = 20"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree{}"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
-
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
-
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
-    test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 10, height: 20}");
-    ecs_os_free(str);
+    LINE "e {Position: {\n"
+    LINE "  x: 10\n"
+    LINE "  /*\n"
+    LINE "   * foo\n"
+    LINE "  y: 20\n"
+    LINE "}}";
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_instance_w_overridden_values(void) {
+void Eval_module_stmt(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5402,42 +5686,35 @@ void Plecs_assembly_instance_w_overridden_values(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 10"
-    LINE "  prop height : flecs.meta.f32 = 20"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree{width: 30, height: 40}"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    LINE "module hello\n"
+    LINE "e { Position: {10, 20} }\n"
+    LINE "e { Foo }\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+    test_assert(ecs_get_scope(world) == 0);
 
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    ecs_entity_t hello = ecs_lookup(world, "hello");
+    test_assert(hello != 0);
+    test_assert(ecs_has_id(world, hello, EcsModule));
 
-    ecs_entity_t e = ecs_lookup(world, "e");
+    ecs_entity_t e = ecs_lookup(world, "hello.e");
     test_assert(e != 0);
+    ecs_entity_t foo = ecs_lookup(world, "hello.Foo");
+    test_assert(foo != 0);
 
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has_id(world, e, foo));
 
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
-    test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 30, height: 40}");
-    ecs_os_free(str);
+    {
+        const Position *ptr = ecs_get(world, e, Position);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 10);
+        test_int(ptr->y, 20);
+    }
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_w_child(void) {
+void Eval_nested_module_stmt(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5451,51 +5728,37 @@ void Plecs_assembly_w_child(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  child :- Position{$width * 10 + 1, $height * 20 + 2}"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree{width: 1, height: 2}"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    LINE "module hello.world\n"
+    LINE "e { Position: {10, 20} }\n"
+    LINE "e { Foo }\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    ecs_entity_t hello = ecs_lookup(world, "hello");
+    test_assert(hello != 0);
+    test_assert(ecs_has_id(world, hello, EcsModule));
+    ecs_entity_t hello_world = ecs_lookup(world, "hello.world");
+    test_assert(hello_world != 0);
+    test_assert(ecs_has_id(world, hello_world, EcsModule));
 
-    ecs_entity_t e = ecs_lookup(world, "e");
+    ecs_entity_t e = ecs_lookup(world, "hello.world.e");
     test_assert(e != 0);
+    ecs_entity_t foo = ecs_lookup(world, "hello.world.Foo");
+    test_assert(foo != 0);
 
-    ecs_entity_t child = ecs_lookup(world, "e.child");
-    test_assert(child != 0);
-
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
-
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
-    test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 1, height: 2}");
-    ecs_os_free(str);
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has_id(world, e, foo));
 
-    const Position *p = ecs_get(world, child, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 11);
-    test_int(p->y, 42);
+    {
+        const Position *ptr = ecs_get(world, e, Position);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 10);
+        test_int(ptr->y, 20);
+    }
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_w_child_parse_script(void) {
+void Eval_module_stmt_w_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5509,54 +5772,54 @@ void Plecs_assembly_w_child_parse_script(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  child :- Position{$width * 10 + 1, $height * 20 + 2}"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree{width: 1, height: 2}"
+    LINE "module hello.world\n"
+    LINE "parent {\n"
+    LINE "  e { Position: {10, 20} }\n"
+    LINE "  e { Foo }\n"
+    LINE "}\n"
+    LINE "f { Position: {30, 40} }\n"
+    LINE "f { Foo }\n"
     LINE "";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_script(world, {
-        .entity = ecs_entity(world, { .name = "main" }),
-        .str = expr
-    }) != 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    ecs_entity_t hello = ecs_lookup(world, "hello");
+    test_assert(hello != 0);
+    test_assert(ecs_has_id(world, hello, EcsModule));
+    ecs_entity_t hello_world = ecs_lookup(world, "hello.world");
+    test_assert(hello_world != 0);
+    test_assert(ecs_has_id(world, hello_world, EcsModule));
 
-    ecs_entity_t e = ecs_lookup(world, "e");
+    ecs_entity_t parent = ecs_lookup(world, "hello.world.parent");
+    test_assert(parent != 0);
+    ecs_entity_t e = ecs_lookup(world, "hello.world.parent.e");
     test_assert(e != 0);
+    ecs_entity_t f = ecs_lookup(world, "hello.world.f");
+    test_assert(f != 0);
+    ecs_entity_t foo = ecs_lookup(world, "hello.world.Foo");
+    test_assert(foo != 0);
 
-    ecs_entity_t child = ecs_lookup(world, "e.child");
-    test_assert(child != 0);
-
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
-
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
-    test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 1, height: 2}");
-    ecs_os_free(str);
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has_id(world, e, foo));
+    test_assert(ecs_has(world, f, Position));
+    test_assert(ecs_has_id(world, f, foo));
 
-    const Position *p = ecs_get(world, child, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 11);
-    test_int(p->y, 42);
+    {
+        const Position *ptr = ecs_get(world, e, Position);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 10);
+        test_int(ptr->y, 20);
+    }
+    {
+        const Position *ptr = ecs_get(world, f, Position);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 30);
+        test_int(ptr->y, 40);
+    }
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_w_child_parse_script_twice(void) {
+void Eval_module_stmt_w_nested_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5570,59 +5833,73 @@ void Plecs_assembly_w_child_parse_script_twice(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  child :- Position{$width * 10 + 1, $height * 20 + 2}"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree{width: 1, height: 2}"
+    LINE "module hello.world\n"
+    LINE "parent {\n"
+    LINE "  child {\n"
+    LINE "    e { Position: {10, 20} }\n"
+    LINE "    e { Foo }\n"
+    LINE "  }\n"
+    LINE "}\n"
+    LINE "f { Position: {30, 40} }\n"
+    LINE "f { Foo }\n"
     LINE "";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_script(world, {
-        .entity = ecs_entity(world, { .name = "main" }),
-        .str = expr
-    }) != 0);
+    ecs_entity_t hello = ecs_lookup(world, "hello");
+    test_assert(hello != 0);
+    test_assert(ecs_has_id(world, hello, EcsModule));
+    ecs_entity_t hello_world = ecs_lookup(world, "hello.world");
+    test_assert(hello_world != 0);
+    test_assert(ecs_has_id(world, hello_world, EcsModule));
 
-    test_assert(ecs_script(world, {
-        .entity = ecs_entity(world, { .name = "main" }),
-        .str = expr
-    }) != 0);
+    ecs_entity_t parent = ecs_lookup(world, "hello.world.parent");
+    test_assert(parent != 0);
+    ecs_entity_t child = ecs_lookup(world, "hello.world.parent.child");
+    test_assert(child != 0);
+    ecs_entity_t e = ecs_lookup(world, "hello.world.parent.child.e");
+    test_assert(e != 0);
+    ecs_entity_t f = ecs_lookup(world, "hello.world.f");
+    test_assert(f != 0);
+    ecs_entity_t foo = ecs_lookup(world, "hello.world.Foo");
+    test_assert(foo != 0);
 
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    test_assert(ecs_has(world, e, Position));
+    test_assert(ecs_has_id(world, e, foo));
+    test_assert(ecs_has(world, f, Position));
+    test_assert(ecs_has_id(world, f, foo));
 
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
+    {
+        const Position *ptr = ecs_get(world, e, Position);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 10);
+        test_int(ptr->y, 20);
+    }
+    {
+        const Position *ptr = ecs_get(world, f, Position);
+        test_assert(ptr != NULL);
+        test_int(ptr->x, 30);
+        test_int(ptr->y, 40);
+    }
 
-    ecs_entity_t child = ecs_lookup(world, "e.child");
-    test_assert(child != 0);
+    ecs_fini(world);
+}
 
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+void Eval_assign_singleton_tag(void) {
+    ecs_world_t *world = ecs_init();
 
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
-    test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 1, height: 2}");
-    ecs_os_free(str);
+    const char *expr =
+    LINE "$ { Foo }\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    const Position *p = ecs_get(world, child, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 11);
-    test_int(p->y, 42);
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    test_assert(foo != 0);
+
+    test_assert(ecs_has_id(world, foo, foo));
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_w_child_update_after_parse(void) {
+void Eval_assign_singleton_component(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5636,73 +5913,58 @@ void Plecs_assembly_w_child_update_after_parse(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  child :- Position{$width * 10 + 1, $height * 20 + 2}"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree{width: 1, height: 2}"
-    LINE "";
+    LINE "$ = Position: {10, 20}\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_script(world, {
-        .entity = ecs_entity(world, { .name = "main" }),
-        .str = expr
-    }) != 0);
-
-    {
-        ecs_entity_t tree = ecs_lookup(world, "Tree");
-        test_assert(tree != 0);
+    test_assert(ecs_has(world, ecs_id(Position), Position));
 
-        ecs_entity_t e = ecs_lookup(world, "e");
-        test_assert(e != 0);
+    const Position *p = ecs_get(world, ecs_id(Position), Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
 
-        ecs_entity_t child = ecs_lookup(world, "e.child");
-        test_assert(child != 0);
-    }
+    ecs_fini(world);
+}
 
-    test_assert(!ecs_is_deferred(world));
+void Eval_assign_singleton_tag_w_scope(void) {
+    ecs_world_t *world = ecs_init();
 
-    const char *expr_update =
-    LINE "e :- Tree{width: 3, height: 4}"
-    LINE "";
+    const char *expr =
+    LINE "$ {\n"
+    LINE "  Foo\n"
+    LINE "}\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr_update) == 0);
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    test_assert(foo != 0);
 
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
+    test_assert(ecs_has_id(world, foo, foo));
 
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
+    ecs_fini(world);
+}
 
-    ecs_entity_t child = ecs_lookup(world, "e.child");
-    test_assert(child != 0);
+void Eval_assign_singleton_2_tags_w_scope(void) {
+    ecs_world_t *world = ecs_init();
 
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
+    const char *expr =
+    LINE "$ {\n"
+    LINE "  Foo\n"
+    LINE "  Bar\n"
+    LINE "}\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
-    test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 3, height: 4}");
-    ecs_os_free(str);
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    test_assert(foo != 0);
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    test_assert(bar != 0);
 
-    const Position *p = ecs_get(world, child, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 31);
-    test_int(p->y, 82);
+    test_assert(ecs_has_id(world, foo, foo));
+    test_assert(ecs_has_id(world, bar, bar));
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_w_nested_child(void) {
+void Eval_assign_singleton_component_w_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5716,66 +5978,22 @@ void Plecs_assembly_w_nested_child(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  child {"
-    LINE "    - Position{$width, $height}"
-    LINE "    grand_child :- Position{$height, $width}"
-    LINE "  }"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree{width: 1, height: 2}"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
-
-    ecs_entity_t child = ecs_lookup(world, "e.child");
-    test_assert(child != 0);
-
-    ecs_entity_t grand_child = ecs_lookup(world, "e.child.grand_child");
-    test_assert(grand_child != 0);
-
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
-
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
-    test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 1, height: 2}");
-    ecs_os_free(str);
+    LINE "$ {\n"
+    LINE "  Position: {10, 20}\n"
+    LINE "}\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    {
-        const Position *p = ecs_get(world, child, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-    }
+    test_assert(ecs_has(world, ecs_id(Position), Position));
 
-    {
-        const Position *p = ecs_get(world, grand_child, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 2);
-        test_int(p->y, 1);
-    }
+    const Position *p = ecs_get(world, ecs_id(Position), Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_w_prefab(void) {
+void Eval_assign_singleton_2_components_w_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -5798,1042 +6016,63 @@ void Plecs_assembly_w_prefab(void) {
     });
 
     const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  Prefab base {"
-    LINE "    - Velocity{$width * 2, $height * 3}"
-    LINE "  }"
-    LINE "  child : base {"
-    LINE "    - Position{$width, $height}"
-    LINE "  }"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree{width: 1, height: 2}"
-    LINE "";
+    LINE "$ {\n"
+    LINE "  Position: {10, 20}\n"
+    LINE "  Velocity: {1, 2}\n"
+    LINE "}\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    const Position *p = ecs_get(world, ecs_id(Position), Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
 
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
-
-    ecs_entity_t child = ecs_lookup(world, "e.child");
-    test_assert(child != 0);
-
-    ecs_entity_t base = ecs_lookup(world, "e.base");
-    test_assert(base != 0);
-
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
-
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
-    test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 1, height: 2}");
-    ecs_os_free(str);
-
-    test_assert(ecs_has_pair(world, child, EcsIsA, base));
-
-    {
-        const Position *p = ecs_get(world, child, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-    }
-
-    {
-        const Velocity *v = ecs_get(world, child, Velocity);
-        test_assert(v != NULL);
-        test_int(v->x, 2);
-        test_int(v->y, 6);
-    }
-
-    {
-        const Velocity *v = ecs_get(world, base, Velocity);
-        test_assert(v != NULL);
-        test_int(v->x, 2);
-        test_int(v->y, 6);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_w_prefab_tree(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    ecs_struct(world, {
-        .entity = ecs_id(Velocity),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  Prefab base {"
-    LINE "    - Velocity{$width * 2, $height * 3}"
-    LINE "    Prefab child {"
-    LINE "      - Velocity{$height * 3, $width * 2}"
-    LINE "    }"
-    LINE "  }"
-    LINE "  child : base {"
-    LINE "    - Position{$width, $height}"
-    LINE "  }"
-    LINE "}"
-    LINE ""
-    LINE "e :- Tree{width: 1, height: 2}"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
-
-    ecs_entity_t child = ecs_lookup(world, "e.child");
-    test_assert(child != 0);
-
-    ecs_entity_t base = ecs_lookup(world, "e.base");
-    test_assert(base != 0);
-
-    ecs_entity_t base_child = ecs_lookup(world, "e.base.child");
-    test_assert(base_child != 0);
-
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
-
-    test_assert(ecs_has_id(world, e, tree));
-    const void *ptr = ecs_get_id(world, e, tree);
-    test_assert(ptr != NULL);
-    char *str = ecs_ptr_to_expr(world, tree, ptr);
-    test_assert(str != NULL);
-    test_str(str, "{width: 1, height: 2}");
-    ecs_os_free(str);
-
-    test_assert(ecs_has_pair(world, child, EcsIsA, base));
-
-    {
-        const Position *p = ecs_get(world, child, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 1);
-        test_int(p->y, 2);
-    }
-
-    {
-        const Velocity *v = ecs_get(world, child, Velocity);
-        test_assert(v != NULL);
-        test_int(v->x, 2);
-        test_int(v->y, 6);
-    }
-
-    {
-        const Velocity *v = ecs_get(world, base, Velocity);
-        test_assert(v != NULL);
-        test_int(v->x, 2);
-        test_int(v->y, 6);
-    }
-
-    {
-        const Velocity *v = ecs_get(world, base_child, Velocity);
-        test_assert(v != NULL);
-        test_int(v->x, 6);
-        test_int(v->y, 2);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_w_nested_assembly(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  child {"
-    LINE "    - Position{$width, $height}"
-    LINE "  }"
-    LINE "}"
-    LINE ""
-    LINE "assembly Forest {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  tree_1 :- Tree{-$width, -$height}"
-    LINE "  tree_2 :- Tree{$width + 1, $height + 1}"
-    LINE "}"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-    ecs_entity_t forest = ecs_lookup(world, "Forest");
-    test_assert(forest != 0);
-    test_assert(ecs_lookup(world, "Forest.tree_1") != 0);
-    test_assert(ecs_lookup(world, "Forest.tree_2") != 0);
-    test_assert(ecs_lookup(world, "Forest.tree_1.child") == 0);
-    test_assert(ecs_lookup(world, "Forest.tree_2.child") == 0);
-    test_assert(ecs_lookup(world, "tree_1") == 0);
-    test_assert(ecs_lookup(world, "tree_2") == 0);
-
-    {
-        const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-        test_assert(st != NULL);
-        test_int(st->members.count, 2);
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
-    }
-
-    {
-        const EcsStruct *st = ecs_get(world, forest, EcsStruct);
-        test_assert(st != NULL);
-        test_int(st->members.count, 2);
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
-    }
-
-    test_assert(!ecs_is_deferred(world));
-
-    const char *expr_instance =
-    LINE "f :- Forest{10, 20}"
-    LINE "";
-    test_assert(ecs_plecs_from_str(world, NULL, expr_instance) == 0);
-
-    ecs_entity_t f = ecs_lookup(world, "f");
-    test_assert(f != 0);
-    ecs_entity_t f_tree_1 = ecs_lookup(world, "f.tree_1");
-    test_assert(f_tree_1 != 0);
-    ecs_entity_t f_tree_2 = ecs_lookup(world, "f.tree_2");
-    test_assert(f_tree_2 != 0);
-    ecs_entity_t f_tree_1_child = ecs_lookup(world, "f.tree_1.child");
-    test_assert(f_tree_1_child != 0);
-    ecs_entity_t f_tree_2_child = ecs_lookup(world, "f.tree_2.child");
-    test_assert(f_tree_2_child != 0);
-
-    {
-        const void *ptr = ecs_get_id(world, f, forest);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, forest, ptr);
-        test_str(str, "{width: 10, height: 20}");
-        ecs_os_free(str);
-    }
-    {
-        const void *ptr = ecs_get_id(world, f_tree_1, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{width: -10, height: -20}");
-        ecs_os_free(str);
-    }
-    {
-        const void *ptr = ecs_get_id(world, f_tree_2, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{width: 11, height: 21}");
-        ecs_os_free(str);
-    }
-
-    {
-        const Position *p = ecs_get(world, f_tree_1_child, Position);
-        test_assert(p != NULL);
-        test_int(p->x, -10);
-        test_int(p->y, -20);
-    }
-    {
-        const Position *p = ecs_get(world, f_tree_2_child, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 11);
-        test_int(p->y, 21);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_instantiate_prefab_w_assembly(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop width : flecs.meta.f32 = 0"
-    LINE "  prop height : flecs.meta.f32 = 0"
-    LINE "  child :- Position{$width, $height}"
-    LINE "}"
-    LINE ""
-    LINE "Prefab p :- Tree{width: 10, height: 20}"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-    ecs_entity_t p = ecs_lookup(world, "p");
-    test_assert(p != 0);
-    test_assert(ecs_lookup(world, "p.child") == 0);
-    test_assert(ecs_lookup(world, "child") == 0);
-    
-    const char *expr_instance =
-    LINE "e : p"
-    LINE "";
-    test_assert(ecs_plecs_from_str(world, NULL, expr_instance) == 0);
-
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
-    ecs_entity_t child = ecs_lookup(world, "e.child");
-    test_assert(child != 0);
-
-    test_assert(ecs_lookup(world, "e.child") != 0);
-
-    const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-    test_assert(st != NULL);
-    test_int(st->members.count, 2);
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "width");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    test_str(ecs_vec_get_t(&st->members, ecs_member_t, 1)->name, "height");
-    test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 1)->type, ecs_id(ecs_f32_t));
-
-    {
-        const void *ptr = ecs_get_id(world, p, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{width: 10, height: 20}");
-        ecs_os_free(str);
-    }
-
-    test_assert(ecs_has_pair(world, e, EcsIsA, p));
-
-    {
-        const Position *p = ecs_get(world, child, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_w_prefab_w_assembly(void) {
-    ecs_world_t *world = ecs_init();
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop count: flecs.meta.f32 = 0"
-    LINE "}"
-    LINE ""
-    LINE "assembly Forest {"
-    LINE "  prop count: flecs.meta.f32 = 0"
-    LINE ""
-    LINE "  Prefab TreePrefab {"
-    LINE "    - Tree{count: $count}"
-    LINE "  }"
-    LINE ""
-    LINE "  child : TreePrefab"
-    LINE "}"
-    LINE "f :- Forest{10}";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-    ecs_entity_t forest = ecs_lookup(world, "Forest");
-    test_assert(forest != 0);
-    ecs_entity_t tree_prefab = ecs_lookup(world, "Forest.TreePrefab");
-    test_assert(tree_prefab != 0);
-
-    ecs_entity_t f = ecs_lookup(world, "f");
-    test_assert(f != 0);
-    ecs_entity_t child = ecs_lookup(world, "f.child");
-    test_assert(child != 0);
-
-    {
-        const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-        test_assert(st != NULL);
-        test_int(st->members.count, 1);
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "count");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    }
-    
-    {
-        const EcsStruct *st = ecs_get(world, forest, EcsStruct);
-        test_assert(st != NULL);
-        test_int(st->members.count, 1);
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "count");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    }
-    
-    {
-        const void *ptr = ecs_get_id(world, f, forest);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, forest, ptr);
-        test_str(str, "{count: 10}");
-        ecs_os_free(str);
-    }
-
-    {
-        const void *ptr = ecs_get_id(world, tree_prefab, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{count: 0}");
-        ecs_os_free(str);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_3_assemblies(void) {
-    ecs_world_t *world = ecs_init();
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop t: flecs.meta.f32 = 10"
-    LINE "}"
-    LINE ""
-    LINE "assembly Forest {"
-    LINE "  prop f: flecs.meta.f32 = 20"
-    LINE "}"
-    LINE ""
-    LINE "assembly Park {"
-    LINE "  prop p: flecs.meta.f32 = 30"
-    LINE "}"
-    LINE ""
-    LINE "a :- Tree{}"
-    LINE "b :- Forest{}"
-    LINE "c :- Park{}"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-    ecs_entity_t forest = ecs_lookup(world, "Forest");
-    test_assert(forest != 0);
-    ecs_entity_t park = ecs_lookup(world, "Park");
-    test_assert(park != 0);
-    
-    ecs_entity_t a = ecs_lookup(world, "a");
-    test_assert(a != 0);
-    ecs_entity_t b = ecs_lookup(world, "b");
-    test_assert(b != 0);
-    ecs_entity_t c = ecs_lookup(world, "c");
-    test_assert(c != 0);
-
-    {
-        const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-        test_assert(st != NULL);
-        test_int(st->members.count, 1);
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "t");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    }  
-    {
-        const EcsStruct *st = ecs_get(world, forest, EcsStruct);
-        test_assert(st != NULL);
-        test_int(st->members.count, 1);
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "f");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    }
-    {
-        const EcsStruct *st = ecs_get(world, park, EcsStruct);
-        test_assert(st != NULL);
-        test_int(st->members.count, 1);
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "p");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    }
-    
-    {
-        const void *ptr = ecs_get_id(world, a, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{t: 10}");
-        ecs_os_free(str);
-    }
-    {
-        const void *ptr = ecs_get_id(world, b, forest);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, forest, ptr);
-        test_str(str, "{f: 20}");
-        ecs_os_free(str);
-    }
-    {
-        const void *ptr = ecs_get_id(world, c, park);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, park, ptr);
-        test_str(str, "{p: 30}");
-        ecs_os_free(str);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_nested_w_default_var(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop count: flecs.meta.f32 = 0"
-    LINE "  trunk :- Position{$count, $count * 2}"
-    LINE "}"
-    LINE ""
-    LINE "assembly Forest {"
-    LINE "  prop count: flecs.meta.f32 = 0"
-    LINE "  child :- Tree{count:$}"
-    LINE "}"
-    LINE "f :- Forest{10}";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-    ecs_entity_t forest = ecs_lookup(world, "Forest");
-    test_assert(forest != 0);
-
-    ecs_entity_t f = ecs_lookup(world, "f");
-    test_assert(f != 0);
-    ecs_entity_t child = ecs_lookup(world, "f.child");
-    test_assert(child != 0);
-    ecs_entity_t trunk = ecs_lookup(world, "f.child.trunk");
-    test_assert(trunk != 0);
-
-    {
-        const EcsStruct *st = ecs_get(world, tree, EcsStruct);
-        test_assert(st != NULL);
-        test_int(st->members.count, 1);
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "count");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    }
-    
-    {
-        const EcsStruct *st = ecs_get(world, forest, EcsStruct);
-        test_assert(st != NULL);
-        test_int(st->members.count, 1);
-        test_str(ecs_vec_get_t(&st->members, ecs_member_t, 0)->name, "count");
-        test_uint(ecs_vec_get_t(&st->members, ecs_member_t, 0)->type, ecs_id(ecs_f32_t));
-    }
-
-    {
-        const void *ptr = ecs_get_id(world, f, forest);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, forest, ptr);
-        test_str(str, "{count: 10}");
-        ecs_os_free(str);
-    }
-    {
-        const void *ptr = ecs_get_id(world, child, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{count: 10}");
-        ecs_os_free(str);
-    }
-
-    {
-        const Position *p = ecs_get(world, trunk, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_w_anonymous(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop count: flecs.meta.i32 = 0"
-    LINE "  _ :- Position{$count, $count * 2}"
-    LINE "  _ :- Position{$count, $count * 2}"
-    LINE "}"
-    LINE ""
-    LINE "t :- Tree{10}";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-    ecs_entity_t t = ecs_lookup(world, "t");
-    test_assert(t != 0);
-
-    {
-        ecs_filter_t *f = ecs_filter(world, {
-            .terms = {
-                { .id = ecs_childof(tree) },
-                { .id = ecs_id(Position) },
-                { .id = EcsPrefab },
-            }
-        });
-
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_int(2, ecs_iter_count(&it));
-        ecs_filter_fini(f);
-    }
-
-    {
-        ecs_filter_t *f = ecs_filter(world, {
-            .terms = {
-                { .id = ecs_childof(t) },
-                { .id = ecs_id(Position) },
-            }
-        });
-
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_int(2, ecs_iter_count(&it));
-        ecs_filter_fini(f);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_w_anonymous_parse_again(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop count: flecs.meta.i32 = 0"
-    LINE "  _ :- Position{$count, $count * 2}"
-    LINE "  _ :- Position{$count, $count * 2}"
-    LINE "}"
-    LINE ""
-    LINE "t :- Tree{10}";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    const char *expr_again =
-    LINE "t :- Tree{10}";
-    test_assert(ecs_plecs_from_str(world, NULL, expr_again) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-    ecs_entity_t t = ecs_lookup(world, "t");
-    test_assert(t != 0);
-
-    {
-        ecs_filter_t *f = ecs_filter(world, {
-            .terms = {
-                { .id = ecs_childof(tree) },
-                { .id = ecs_id(Position) },
-                { .id = EcsPrefab },
-            }
-        });
-
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_int(2, ecs_iter_count(&it));
-        ecs_filter_fini(f);
-    }
-
-    {
-        ecs_filter_t *f = ecs_filter(world, {
-            .terms = {
-                { .id = ecs_childof(t) },
-                { .id = ecs_id(Position) },
-            }
-        });
-
-        ecs_iter_t it = ecs_filter_iter(world, f);
-        test_int(2, ecs_iter_count(&it));
-        ecs_filter_fini(f);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_typed_const_w_composite_type_invalid_assignment(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_struct(world, {
-        .entity = ecs_entity(world, {.name = "Position"}),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    HEAD "const var_pos : Position = Position{10, 20}"
-    LINE "a :- $var_pos"
-    LINE "";
-
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
-
-    ecs_fini(world);
-}
-
-void Plecs_typed_const_w_composite_type(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t ecs_id(Position) = ecs_struct(world, {
-        .entity = ecs_entity(world, {.name = "Position"}),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    HEAD "const var_pos : Position = {10, 20}"
-    LINE "a :- $var_pos"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t var = ecs_lookup(world, "var_pos");
-    test_assert(var == 0);
-
-    ecs_entity_t a = ecs_lookup(world, "a");
-    test_assert(a != 0);
-
-    const Position *p = ecs_get(world, a, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    ecs_fini(world);
-}
-
-void Plecs_assign_var_to_typed_const_w_composite_type(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t ecs_id(Position) = ecs_struct(world, {
-        .entity = ecs_entity(world, {.name = "Position"}),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    HEAD "const var_pos_a : Position = {10, 20}"
-    HEAD "const var_pos_b = $var_pos_a"
-    LINE "a :- $var_pos_b"
-    LINE "";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t var = ecs_lookup(world, "var_pos");
-    test_assert(var == 0);
-
-    ecs_entity_t a = ecs_lookup(world, "a");
-    test_assert(a != 0);
-
-    const Position *p = ecs_get(world, a, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_w_composite_prop_invalid_assignment(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop pos: Position = Position{10, 20}"
-    LINE "  child :- $pos"
-    LINE "}"
-    LINE ""
-    LINE "t :- Tree{pos: {20, 30}}";
-
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_w_composite_prop(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop pos: Position = {10, 20}"
-    LINE "  child :- $pos"
-    LINE "}"
-    LINE "t :- Tree{pos: {20, 30}}"
-    LINE "";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-    ecs_entity_t t = ecs_lookup(world, "t");
-    test_assert(t != 0);
-    ecs_entity_t t_child = ecs_lookup(world, "t.child");
-    test_assert(t_child != 0);
-
-    {
-        const void *ptr = ecs_get_id(world, t, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{pos: {x: 20, y: 30}}");
-        ecs_os_free(str);
-    }
-
-    {
-        const Position *p = ecs_get(world, t_child, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 20);
-        test_int(p->y, 30);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_assembly_with_with(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    const char *expr =
-    LINE "assembly Tree {"
-    LINE "  prop count: flecs.meta.i32 = 0"
-    LINE "  with Foo {"
-    LINE "    child :- Position{$count, $count * 2}"
-    LINE "  }"
-    LINE "}"
-    LINE "t :- Tree{count: 10}"
-    LINE "";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t tree = ecs_lookup(world, "Tree");
-    test_assert(tree != 0);
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    test_assert(foo != 0);
-    ecs_entity_t t = ecs_lookup(world, "t");
-    test_assert(t != 0);
-    ecs_entity_t t_child = ecs_lookup(world, "t.child");
-    test_assert(t_child != 0);
-
-    {
-        const void *ptr = ecs_get_id(world, t, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{count: 10}");
-        ecs_os_free(str);
-    }
-
-    {
-        const Position *p = ecs_get(world, t_child, Position);
-        test_assert(p != NULL);
-        test_int(p->x, 10);
-        test_int(p->y, 20);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_using_wildcard(void) {
-    ecs_world_t *world = ecs_init();
-
-    ecs_entity_t p1 = ecs_new_entity(world, "foo.p1");
-    ecs_entity_t p2 = ecs_new_entity(world, "foo.p2");
-
-    ecs_set_scope(world, p1);
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    ecs_set_scope(world, p2);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Velocity),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    ecs_set_scope(world, 0);
-
-    const char *expr =
-    LINE "using foo.*\n"
-    LINE "e :- Position{10, 20}\n"
-    LINE "e :- Velocity{1, 2}\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t pos = ecs_lookup(world, "foo.p1.Position");
-    test_assert(pos == ecs_id(Position));
-    ecs_entity_t vel = ecs_lookup(world, "foo.p2.Velocity");
-    test_assert(vel == ecs_id(Velocity));
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
-
-    test_assert(ecs_has(world, e, Position));
-    test_assert(ecs_has(world, e, Velocity));
-
-    {
-        const Position *ptr = ecs_get(world, e, Position);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 10);
-        test_int(ptr->y, 20);
-    }
-    {
-        const Velocity *ptr = ecs_get(world, e, Velocity);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 1);
-        test_int(ptr->y, 2);
-    }
-
-    ecs_fini(world);
-}
-
-void Plecs_single_line_comment_in_value(void) {
-    ecs_world_t *world = ecs_init();
-
-    ECS_COMPONENT(world, Position);
+    const Velocity *v = ecs_get(world, ecs_id(Velocity), Velocity);
+    test_assert(v != NULL);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
 
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
+    ecs_fini(world);
+}
+
+void Eval_with_pair_in_scope(void) {
+    ecs_world_t *world = ecs_init();
 
     const char *expr =
-    LINE "e :- Position{\n"
-    LINE "  x: 10\n"
-    LINE "  //foo\n"
-    LINE "  y: 20\n"
-    LINE "}";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    LINE "Tgt {}\n"
+    LINE "Rel {}\n"
+    LINE "\n"
+    LINE "Parent {\n"
+    LINE "  with (Rel, Tgt) {\n"
+    LINE "    Child {}\n"
+    LINE "  }\n"
+    LINE "}\n";
 
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_has(world, e, Position));
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t child = ecs_lookup(world, "Parent.Child");
+    ecs_entity_t rel = ecs_lookup(world, "Rel");
+    ecs_entity_t tgt = ecs_lookup(world, "Tgt");
 
-    const Position *ptr = ecs_get(world, e, Position);
-    test_assert(ptr != NULL);
-    test_int(ptr->x, 10);
-    test_int(ptr->y, 20);
+    test_assert(!ecs_lookup(world, "Parent.Rel"));
+    test_assert(!ecs_lookup(world, "Parent.Tgt"));
+
+    test_assert(parent != 0);
+    test_assert(child != 0);
+    test_assert(rel != 0);
+    test_assert(tgt != 0);
+
+    test_assert(ecs_has_pair(world, child, rel, tgt));
 
     ecs_fini(world);
 }
 
-void Plecs_single_line_comment_in_value_after_scope(void) {
+void Eval_with_pair_component_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
+    ecs_entity_t ecs_id(Position) = ecs_struct(world, {
+        .entity = ecs_entity(world, { .name = "Position" }),
         .members = {
             {"x", ecs_id(ecs_f32_t)},
             {"y", ecs_id(ecs_f32_t)}
@@ -6841,210 +6080,135 @@ void Plecs_single_line_comment_in_value_after_scope(void) {
     });
 
     const char *expr =
-    LINE "e :- Position{\n"
-    LINE "  // foo\n"
-    LINE "  x: 10\n"
-    LINE "  y: 20\n"
-    LINE "}";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    LINE "Tgt {}\n"
+    LINE "\n"
+    LINE "Parent {\n"
+    LINE "  with (Position, Tgt)(10, 20) {\n"
+    LINE "    Child {}\n"
+    LINE "  }\n"
+    LINE "}\n";
 
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_has(world, e, Position));
+    ecs_entity_t parent = ecs_lookup(world, "Parent");
+    ecs_entity_t child = ecs_lookup(world, "Parent.Child");
+    ecs_entity_t tgt = ecs_lookup(world, "Tgt");
 
-    const Position *ptr = ecs_get(world, e, Position);
-    test_assert(ptr != NULL);
-    test_int(ptr->x, 10);
-    test_int(ptr->y, 20);
+    test_assert(!ecs_lookup(world, "Parent.Rel"));
+    test_assert(!ecs_lookup(world, "Parent.Tgt"));
+
+    test_assert(parent != 0);
+    test_assert(child != 0);
+    test_assert(tgt != 0);
+
+    test_assert(ecs_has_pair(world, child, ecs_id(Position), tgt));
+
+    const Position *pos = ecs_get_pair(world, child, Position, tgt);
+    test_assert(pos != NULL);
+    test_int(pos->x, 10);
+    test_int(pos->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_multi_line_comment_in_value(void) {
+void Eval_pair_w_rel_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
 
     const char *expr =
-    LINE "e :- Position{\n"
-    LINE "  x: 10\n"
-    LINE "  /*\n"
-    LINE "   * foo\n"
-    LINE "   */\n"
-    LINE "  y: 20\n"
-    LINE "}";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    LINE "const rel = Rel\n"
+    LINE "ent {\n"
+    LINE "  ($rel, Tgt)\n"
+    LINE "}\n"
+    LINE "\n";
 
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_has(world, e, Position));
+    ecs_entity_t ent = ecs_lookup(world, "ent");
 
-    const Position *ptr = ecs_get(world, e, Position);
-    test_assert(ptr != NULL);
-    test_int(ptr->x, 10);
-    test_int(ptr->y, 20);
+    test_assert(ecs_has_pair(world, ent, Rel, Tgt));
 
     ecs_fini(world);
 }
 
-void Plecs_multi_line_comment_in_value_after_scope(void) {
+void Eval_pair_w_tgt_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
 
     const char *expr =
-    LINE "e :- Position{\n"
-    LINE "  /*\n"
-    LINE "   * foo\n"
-    LINE "   */\n"
-    LINE "  x: 10\n"
-    LINE "  y: 20\n"
-    LINE "}";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    LINE "const tgt = Tgt\n"
+    LINE "ent {\n"
+    LINE "  (Rel, $tgt)\n"
+    LINE "}\n"
+    LINE "\n";
 
-    ecs_entity_t e = ecs_lookup(world, "e");
-    test_assert(e != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    test_assert(ecs_has(world, e, Position));
+    ecs_entity_t ent = ecs_lookup(world, "ent");
 
-    const Position *ptr = ecs_get(world, e, Position);
-    test_assert(ptr != NULL);
-    test_int(ptr->x, 10);
-    test_int(ptr->y, 20);
+    test_assert(ecs_has_pair(world, ent, Rel, Tgt));
 
     ecs_fini(world);
 }
 
-void Plecs_unterminated_multi_line_comment_in_value(void) {
+void Eval_pair_w_rel_var_invalid_type(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
 
     const char *expr =
-    LINE "e :- Position{\n"
-    LINE "  x: 10\n"
-    LINE "  /*\n"
-    LINE "   * foo\n"
-    LINE "  y: 20\n"
-    LINE "}";
+    LINE "const rel = 10\n"
+    LINE "ent {\n"
+    LINE "  ($rel, Tgt)\n"
+    LINE "}\n"
+    LINE "\n";
+
     ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_module_stmt(void) {
+void Eval_pair_w_tgt_var_invalid_type(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
+    ECS_TAG(world, Rel);
+    ECS_TAG(world, Tgt);
 
     const char *expr =
-    LINE "module hello\n"
-    LINE "e :- Position{10, 20}\n"
-    LINE "e :- Foo\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t hello = ecs_lookup(world, "hello");
-    test_assert(hello != 0);
-    test_assert(ecs_has_id(world, hello, EcsModule));
-
-    ecs_entity_t e = ecs_lookup(world, "hello.e");
-    test_assert(e != 0);
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    test_assert(foo != 0);
-
-    test_assert(ecs_has(world, e, Position));
-    test_assert(ecs_has_id(world, e, foo));
+    LINE "const tgt = 10\n"
+    LINE "ent {\n"
+    LINE "  (Rel, $tgt)\n"
+    LINE "}\n"
+    LINE "\n";
 
-    {
-        const Position *ptr = ecs_get(world, e, Position);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 10);
-        test_int(ptr->y, 20);
-    }
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_nested_module_stmt(void) {
+void Eval_with_value_not_a_component(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
     const char *expr =
-    LINE "module hello.world\n"
-    LINE "e :- Position{10, 20}\n"
-    LINE "e :- Foo\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t hello = ecs_lookup(world, "hello");
-    test_assert(hello != 0);
-    test_assert(ecs_has_id(world, hello, EcsModule));
-    ecs_entity_t hello_world = ecs_lookup(world, "hello.world");
-    test_assert(hello_world != 0);
-    test_assert(ecs_has_id(world, hello_world, EcsModule));
-
-    ecs_entity_t e = ecs_lookup(world, "hello.world.e");
-    test_assert(e != 0);
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    test_assert(foo != 0);
-
-    test_assert(ecs_has(world, e, Position));
-    test_assert(ecs_has_id(world, e, foo));
+    LINE "with Foo(10) {\n"
+    LINE "  Bar {}\n"
+    LINE "}\n"
+    LINE "\n";
 
-    {
-        const Position *ptr = ecs_get(world, e, Position);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 10);
-        test_int(ptr->y, 20);
-    }
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_module_stmt_w_scope(void) {
+void Eval_component_in_with_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -7058,60 +6222,33 @@ void Plecs_module_stmt_w_scope(void) {
     });
 
     const char *expr =
-    LINE "module hello.world\n"
-    LINE "parent {\n"
-    LINE "  e :- Position{10, 20}\n"
-    LINE "  e :- Foo\n"
+    LINE "with Position(10, 20) {\n"
+    LINE "  Bar\n"
     LINE "}\n"
-    LINE "f :- Position{30, 40}\n"
-    LINE "f :- Foo\n"
-    LINE "";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t hello = ecs_lookup(world, "hello");
-    test_assert(hello != 0);
-    test_assert(ecs_has_id(world, hello, EcsModule));
-    ecs_entity_t hello_world = ecs_lookup(world, "hello.world");
-    test_assert(hello_world != 0);
-    test_assert(ecs_has_id(world, hello_world, EcsModule));
-
-    ecs_entity_t parent = ecs_lookup(world, "hello.world.parent");
-    test_assert(parent != 0);
-    ecs_entity_t e = ecs_lookup(world, "hello.world.parent.e");
-    test_assert(e != 0);
-    ecs_entity_t f = ecs_lookup(world, "hello.world.f");
-    test_assert(f != 0);
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    test_assert(foo != 0);
-
-    test_assert(ecs_has(world, e, Position));
-    test_assert(ecs_has_id(world, e, foo));
-    test_assert(ecs_has(world, f, Position));
-    test_assert(ecs_has_id(world, f, foo));
+    LINE "\n";
 
-    {
-        const Position *ptr = ecs_get(world, e, Position);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 10);
-        test_int(ptr->y, 20);
-    }
-    {
-        const Position *ptr = ecs_get(world, f, Position);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 30);
-        test_int(ptr->y, 40);
-    }
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_module_stmt_w_nested_scope(void) {
+void Eval_component_in_with_scope_nested(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
 
     ecs_struct(world, {
-        .entity = ecs_id(Position),
+        .entity = ecs_id(Velocity),
         .members = {
             {"x", ecs_id(ecs_f32_t)},
             {"y", ecs_id(ecs_f32_t)}
@@ -7119,58 +6256,20 @@ void Plecs_module_stmt_w_nested_scope(void) {
     });
 
     const char *expr =
-    LINE "module hello.world\n"
-    LINE "parent {\n"
-    LINE "  child {\n"
-    LINE "    e :- Position{10, 20}\n"
-    LINE "    e :- Foo\n"
+    LINE "with Position(10, 20) {\n"
+    LINE "  with Velocity(10, 20) {\n"
+    LINE "    Bar\n"
     LINE "  }\n"
     LINE "}\n"
-    LINE "f :- Position{30, 40}\n"
-    LINE "f :- Foo\n"
-    LINE "";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t hello = ecs_lookup(world, "hello");
-    test_assert(hello != 0);
-    test_assert(ecs_has_id(world, hello, EcsModule));
-    ecs_entity_t hello_world = ecs_lookup(world, "hello.world");
-    test_assert(hello_world != 0);
-    test_assert(ecs_has_id(world, hello_world, EcsModule));
-
-    ecs_entity_t parent = ecs_lookup(world, "hello.world.parent");
-    test_assert(parent != 0);
-    ecs_entity_t child = ecs_lookup(world, "hello.world.parent.child");
-    test_assert(child != 0);
-    ecs_entity_t e = ecs_lookup(world, "hello.world.parent.child.e");
-    test_assert(e != 0);
-    ecs_entity_t f = ecs_lookup(world, "hello.world.f");
-    test_assert(f != 0);
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    test_assert(foo != 0);
-
-    test_assert(ecs_has(world, e, Position));
-    test_assert(ecs_has_id(world, e, foo));
-    test_assert(ecs_has(world, f, Position));
-    test_assert(ecs_has_id(world, f, foo));
+    LINE "\n";
 
-    {
-        const Position *ptr = ecs_get(world, e, Position);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 10);
-        test_int(ptr->y, 20);
-    }
-    {
-        const Position *ptr = ecs_get(world, f, Position);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 30);
-        test_int(ptr->y, 40);
-    }
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_module_w_assembly(void) {
+void Eval_component_in_with_scope_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -7184,49 +6283,37 @@ void Plecs_module_w_assembly(void) {
     });
 
     const char *expr =
-    LINE "module hello.world\n"
-    LINE "assembly Tree {\n"
-    LINE "  prop count: flecs.meta.i32 = 0\n"
-    LINE "  child :- Position{$count, $count * 2}\n"
-    LINE "}\n"
-    LINE "";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    const char *expr_inst =
-    LINE "t :- hello.world.Tree{10}\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr_inst) == 0);
+    LINE "foo {\n"
+    LINE "  Position: {10, 20}\n"
+    LINE "  with Position(30, 40) {\n"
+    LINE "    Bar\n"
+    LINE "  }\n"
+    LINE "}\n";
 
-    ecs_entity_t tree = ecs_lookup(world, "hello.world.Tree");
-    test_assert(tree != 0);
-    ecs_entity_t t = ecs_lookup(world, "t");
-    test_assert(t != 0);
-    ecs_entity_t child = ecs_lookup(world, "t.child");
-    test_assert(child != 0);
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    {
-        const void *ptr = ecs_get_id(world, t, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{count: 10}");
-        ecs_os_free(str);
-    }
+    ecs_entity_t foo = ecs_lookup(world, "foo");
+    test_assert(foo != 0);
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    test_assert(bar != 0);
 
-    test_assert(ecs_has(world, child, Position));
+    test_assert(ecs_has(world, foo, Position));
+    test_assert(ecs_has_id(world, foo, bar));
 
-    {
-        const Position *ptr = ecs_get(world, child, Position);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 10);
-        test_int(ptr->y, 20);
-    }
+    const Position *p = ecs_get(world, foo, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_module_w_nested_assembly(void) {
+void Eval_assign_after_with_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, Velocity);
 
     ecs_struct(world, {
         .entity = ecs_id(Position),
@@ -7236,77 +6323,73 @@ void Plecs_module_w_nested_assembly(void) {
         }
     });
 
+    ecs_struct(world, {
+        .entity = ecs_id(Velocity),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
     const char *expr =
-    LINE "module hello.world\n"
-    LINE "assembly Tree {\n"
-    LINE "  prop count: flecs.meta.i32 = 0\n"
-    LINE "  child :- Position{$count, $count * 2}\n"
-    LINE "}\n"
-    LINE "assembly Forest {\n"
-    LINE "  prop count: flecs.meta.i32 = 0\n"
-    LINE "  t :- Tree{count:$}\n"
-    LINE "}\n"
-    LINE "";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    LINE "foo {\n"
+    LINE "  Position: {10, 20}\n"
+    LINE "  with Position(30, 40) {\n"
+    LINE "  }\n"
+    LINE "  Velocity: {1, 2}\n"
+    LINE "}\n";
 
-    const char *expr_inst =
-    LINE "f :- hello.world.Forest{10}\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr_inst) == 0);
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t forest = ecs_lookup(world, "hello.world.Forest");
-    test_assert(forest != 0);
-    ecs_entity_t tree = ecs_lookup(world, "hello.world.Tree");
-    test_assert(tree != 0);
-    ecs_entity_t f = ecs_lookup(world, "f");
-    test_assert(f != 0);
-    ecs_entity_t t = ecs_lookup(world, "f.t");
-    test_assert(t != 0);
-    ecs_entity_t child = ecs_lookup(world, "f.t.child");
-    test_assert(child != 0);
+    ecs_entity_t foo = ecs_lookup(world, "foo");
+    test_assert(foo != 0);
 
-    {
-        const void *ptr = ecs_get_id(world, f, forest);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, forest, ptr);
-        test_str(str, "{count: 10}");
-        ecs_os_free(str);
-    }
-    {
-        const void *ptr = ecs_get_id(world, t, tree);
-        test_assert(ptr != NULL);
-        char *str = ecs_ptr_to_expr(world, tree, ptr);
-        test_str(str, "{count: 10}");
-        ecs_os_free(str);
-    }
+    test_assert(ecs_has(world, foo, Position));
+    test_assert(ecs_has(world, foo, Velocity));
 
-    test_assert(ecs_has(world, child, Position));
+    const Position *p = ecs_get(world, foo, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
 
-    {
-        const Position *ptr = ecs_get(world, child, Position);
-        test_assert(ptr != NULL);
-        test_int(ptr->x, 10);
-        test_int(ptr->y, 20);
-    }
+    const Velocity *v = ecs_get(world, foo, Velocity);
+    test_assert(v != NULL);
+    test_int(v->x, 1);
+    test_int(v->y, 2);
 
     ecs_fini(world);
 }
 
-void Plecs_assign_singleton_tag(void) {
+void Eval_array_component(void) {
     ecs_world_t *world = ecs_init();
 
+    ECS_COMPONENT(world, Position);
+
+    ecs_array(world, {
+        .entity = ecs_id(Position),
+        .type = ecs_id(ecs_f32_t),
+        .count = 2
+    });
+
     const char *expr =
-    LINE "$ :- Foo\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    LINE "foo { Position: [10, 20] }\n";
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t foo = ecs_lookup(world, "foo");
     test_assert(foo != 0);
 
-    test_assert(ecs_has_id(world, foo, foo));
+    test_assert(ecs_has(world, foo, Position));
+
+    const Position *p = ecs_get(world, foo, Position);
+    test_assert(p != NULL);
+    test_int(p->x, 10);
+    test_int(p->y, 20);
 
     ecs_fini(world);
 }
 
-void Plecs_assign_singleton_component(void) {
+void Eval_not_an_array_component(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
@@ -7320,568 +6403,485 @@ void Plecs_assign_singleton_component(void) {
     });
 
     const char *expr =
-    LINE "$ :- Position{10, 20}\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    test_assert(ecs_has(world, ecs_id(Position), Position));
+    LINE "foo { Position: [10, 20] }\n";
 
-    const Position *p = ecs_get(world, ecs_id(Position), Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_assign_singleton_tag_w_scope(void) {
+
+void Eval_array_component_w_curly_brackets(void) {
     ecs_world_t *world = ecs_init();
 
-    const char *expr =
-    LINE "$ {\n"
-    LINE "  - Foo\n"
-    LINE "}\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    ECS_COMPONENT(world, Position);
 
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    test_assert(foo != 0);
+    ecs_array(world, {
+        .entity = ecs_id(Position),
+        .type = ecs_id(ecs_f32_t),
+        .count = 2
+    });
 
-    test_assert(ecs_has_id(world, foo, foo));
+    const char *expr =
+    LINE "foo { Position: {10, 20} }\n";
+
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_assign_singleton_2_tags_w_scope(void) {
+void Eval_unknown_identifier(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    LINE "$ {\n"
-    LINE "  - Foo\n"
-    LINE "  - Bar\n"
-    LINE "}\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    test_assert(foo != 0);
-    ecs_entity_t bar = ecs_lookup(world, "Bar");
-    test_assert(bar != 0);
+    HEAD "using flecs.meta"
+    LINE
+    LINE "struct Comp {"
+    LINE "  value = entity"
+    LINE "}"
+    LINE
+    LINE "Foo { Comp: {A} }";
 
-    test_assert(ecs_has_id(world, foo, foo));
-    test_assert(ecs_has_id(world, bar, bar));
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_assign_singleton_component_w_scope(void) {
+void Eval_unknown_identifier_for_int_field(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    const char *expr =
+    HEAD "using flecs.meta"
+    LINE
+    LINE "struct Comp {"
+    LINE "  value = i32"
+    LINE "}"
+    LINE
+    LINE "Foo { Comp: {A} }";
 
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
+    ecs_log_set_level(-4);
+    test_assert(ecs_script_run(world, NULL, expr) != 0);
 
-    const char *expr =
-    LINE "$ {\n"
-    LINE "  - Position{10, 20}\n"
-    LINE "}\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    ecs_fini(world);
+}
 
-    test_assert(ecs_has(world, ecs_id(Position), Position));
+ECS_CTOR(Position, ptr, {
+    ptr->x = 100;
+    ptr->y = 200;
+})
 
-    const Position *p = ecs_get(world, ecs_id(Position), Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
+static int on_set_position_invoked = 0;
 
-    ecs_fini(world);
+static void on_set_position(ecs_iter_t *it) {
+    on_set_position_invoked ++;
+
+    Position *p = ecs_field(it, Position, 0);
+    test_assert(p != NULL);
 }
 
-void Plecs_assign_singleton_2_components_w_scope(void) {
+void Eval_on_set_w_kind_paren_no_reflection(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
 
-    ecs_struct(world, {
-        .entity = ecs_id(Velocity),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
+    ecs_set_hooks(world, Position, {
+        .ctor = ecs_ctor(Position),
+        .on_set = on_set_position
     });
 
     const char *expr =
-    LINE "$ {\n"
-    LINE "  - Position{10, 20}\n"
-    LINE "  - Velocity{1, 2}\n"
-    LINE "}\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    HEAD "Position e()";
 
-    const Position *p = ecs_get(world, ecs_id(Position), Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
+    test_int(on_set_position_invoked, 0);
 
-    const Velocity *v = ecs_get(world, ecs_id(Velocity), Velocity);
-    test_assert(v != NULL);
-    test_int(v->x, 1);
-    test_int(v->y, 2);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
+
+    test_int(on_set_position_invoked, 1);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 100);
+    test_int(p->y, 200);
 
     ecs_fini(world);
 }
 
-void Plecs_with_pair_in_scope(void) {
+void Eval_on_set_w_kind_paren(void) {
     ecs_world_t *world = ecs_init();
 
-    const char *expr =
-    LINE "Tgt\n"
-    LINE "Rel\n"
-    LINE "\n"
-    LINE "Parent {\n"
-    LINE "  with (Rel, Tgt) {\n"
-    LINE "    Child\n"
-    LINE "  }\n"
-    LINE "}\n";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t parent = ecs_lookup(world, "Parent");
-    ecs_entity_t child = ecs_lookup(world, "Parent.Child");
-    ecs_entity_t rel = ecs_lookup(world, "Rel");
-    ecs_entity_t tgt = ecs_lookup(world, "Tgt");
+    ECS_COMPONENT(world, Position);
 
-    test_assert(!ecs_lookup(world, "Parent.Rel"));
-    test_assert(!ecs_lookup(world, "Parent.Tgt"));
+    ecs_set_hooks(world, Position, {
+        .ctor = ecs_ctor(Position),
+        .on_set = on_set_position
+    });
 
-    test_assert(parent != 0);
-    test_assert(child != 0);
-    test_assert(rel != 0);
-    test_assert(tgt != 0);
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
 
-    test_assert(ecs_has_pair(world, child, rel, tgt));
+    const char *expr =
+    HEAD "Position e()";
 
-    ecs_fini(world);
-}
+    test_int(on_set_position_invoked, 0);
 
-void Plecs_assembly_redeclare_prop_as_const(void) {
-    ecs_world_t *world = ecs_init();
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    const char *expr =
-    LINE "assembly Foo {\n"
-    LINE "  prop x : flecs.meta.f32 = 10\n"
-    LINE "  prop y : flecs.meta.f32 = 10\n"
-    LINE "  const y : flecs.meta.f32 = 20\n"
-    LINE "}"
-    LINE "ent :- Foo{}\n"
-    LINE "\n";
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_int(on_set_position_invoked, 1);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 100);
+    test_int(p->y, 200);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_redeclare_prop_as_prop(void) {
+void Eval_on_set_w_kind_no_paren(void) {
     ecs_world_t *world = ecs_init();
 
+    ECS_COMPONENT(world, Position);
+
+    ecs_set_hooks(world, Position, {
+        .ctor = ecs_ctor(Position),
+        .on_set = on_set_position
+    });
+
+    ecs_struct(world, {
+        .entity = ecs_id(Position),
+        .members = {
+            {"x", ecs_id(ecs_f32_t)},
+            {"y", ecs_id(ecs_f32_t)}
+        }
+    });
+
     const char *expr =
-    LINE "assembly Foo {\n"
-    LINE "  prop x : flecs.meta.f32 = 10\n"
-    LINE "  prop y : flecs.meta.f32 = 10\n"
-    LINE "  prop y : flecs.meta.f32 = 20\n"
-    LINE "}"
-    LINE "ent :- Foo{}\n"
-    LINE "\n";
+    HEAD "Position e()";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_int(on_set_position_invoked, 0);
 
-    ecs_fini(world);
-}
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-void Plecs_assembly_redeclare_const_as_const(void) {
-    ecs_world_t *world = ecs_init();
+    ecs_entity_t e = ecs_lookup(world, "e");
+    test_assert(e != 0);
 
-    const char *expr =
-    LINE "assembly Foo {\n"
-    LINE "  prop x : flecs.meta.f32 = 10\n"
-    LINE "  const y : flecs.meta.f32 = 10\n"
-    LINE "  const y : flecs.meta.f32 = 20\n"
-    LINE "}"
-    LINE "ent :- Foo{}\n"
-    LINE "\n";
+    test_int(on_set_position_invoked, 1);
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 100);
+    test_int(p->y, 200);
 
     ecs_fini(world);
 }
 
-void Plecs_add_auto_override(void) {
+void Eval_on_set_w_kind_no_paren_no_reflection(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_TAG(world, Tag);
+    ECS_COMPONENT(world, Position);
+
+    ecs_set_hooks(world, Position, {
+        .ctor = ecs_ctor(Position),
+        .on_set = on_set_position
+    });
 
     const char *expr =
-    LINE "p :- OVERRIDE|Tag"
-    LINE "\n";
+    HEAD "Position e";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_int(on_set_position_invoked, 0);
 
-    ecs_entity_t p = ecs_lookup(world, "p");
-    test_assert(p != 0);
-    test_assert(ecs_has_id(world, p, ECS_OVERRIDE | Tag));
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, p);
+    ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
-    test_assert(ecs_has(world, e, Tag));
+
+    test_int(on_set_position_invoked, 1);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 100);
+    test_int(p->y, 200);
 
     ecs_fini(world);
 }
 
-void Plecs_add_auto_override_pair(void) {
+void Eval_on_set_w_single_assign(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
+    ECS_COMPONENT(world, Position);
+
+    ecs_set_hooks(world, Position, {
+        .ctor = ecs_ctor(Position),
+        .on_set = on_set_position
+    });
 
     const char *expr =
-    LINE "p :- OVERRIDE|(Rel, Tgt)"
-    LINE "\n";
+    HEAD "e = Position: {}";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_int(on_set_position_invoked, 0);
 
-    ecs_entity_t p = ecs_lookup(world, "p");
-    test_assert(p != 0);
-    test_assert(ecs_has_id(world, p, ECS_OVERRIDE | ecs_pair(Rel, Tgt)));
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, p);
+    ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
-    test_assert(ecs_has_pair(world, e, Rel, Tgt));
+
+    test_int(on_set_position_invoked, 1);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 100);
+    test_int(p->y, 200);
 
     ecs_fini(world);
 }
 
-void Plecs_scope_w_auto_override(void) {
+void Eval_on_set_w_single_assign_scoped_w_value(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_TAG(world, Tag);
+    ECS_COMPONENT(world, Position);
+
+    ecs_set_hooks(world, Position, {
+        .ctor = ecs_ctor(Position),
+        .on_set = on_set_position
+    });
 
     const char *expr =
-    LINE "p {"
-    LINE " - OVERRIDE|Tag"
-    LINE "}"
-    LINE "\n";
+    HEAD "e { Position: {} }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_int(on_set_position_invoked, 0);
 
-    ecs_entity_t p = ecs_lookup(world, "p");
-    test_assert(p != 0);
-    test_assert(ecs_has_id(world, p, ECS_OVERRIDE | Tag));
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, p);
+    ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
-    test_assert(ecs_has(world, e, Tag));
+
+    test_int(on_set_position_invoked, 1);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 100);
+    test_int(p->y, 200);
 
     ecs_fini(world);
 }
 
-void Plecs_scope_w_auto_override_pair(void) {
+void Eval_on_set_w_single_assign_scoped_no_value(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
+    ECS_COMPONENT(world, Position);
+
+    ecs_set_hooks(world, Position, {
+        .ctor = ecs_ctor(Position),
+        .on_set = on_set_position
+    });
 
     const char *expr =
-    LINE "p {"
-    LINE " - OVERRIDE|(Rel, Tgt)"
-    LINE "}"
-    LINE "\n";
+    HEAD "e { Position }";
 
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_int(on_set_position_invoked, 0);
 
-    ecs_entity_t p = ecs_lookup(world, "p");
-    test_assert(p != 0);
-    test_assert(ecs_has_id(world, p, ECS_OVERRIDE | ecs_pair(Rel, Tgt)));
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t e = ecs_new_w_pair(world, EcsIsA, p);
+    ecs_entity_t e = ecs_lookup(world, "e");
     test_assert(e != 0);
-    test_assert(ecs_has_pair(world, e, Rel, Tgt));
+
+    test_int(on_set_position_invoked, 0);
+
+    const Position *p = ecs_get(world, e, Position);
+    test_int(p->x, 100);
+    test_int(p->y, 200);
 
     ecs_fini(world);
 }
 
-void Plecs_pair_w_rel_var(void) {
+void Eval_if_true(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
-
     const char *expr =
-    LINE "const rel = Rel\n"
-    LINE "ent {\n"
-    LINE " - ($rel, Tgt)\n"
-    LINE "}\n"
-    LINE "\n";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t ent = ecs_lookup(world, "ent");
+    HEAD "if true {"
+    LINE "  a{}"
+    LINE "} else {"
+    LINE "  b{}"
+    LINE "}";
 
-    test_assert(ecs_has_pair(world, ent, Rel, Tgt));
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+    test_assert(ecs_lookup(world, "a") != 0);
+    test_assert(ecs_lookup(world, "b") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_pair_w_tgt_var(void) {
+void Eval_if_true_no_else(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_TAG(world, Rel);
-    ECS_TAG(world, Tgt);
-
     const char *expr =
-    LINE "const tgt = Tgt\n"
-    LINE "ent {\n"
-    LINE " - (Rel, $tgt)\n"
-    LINE "}\n"
-    LINE "\n";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t ent = ecs_lookup(world, "ent");
+    HEAD "if true {"
+    LINE "  a{}"
+    LINE "}";
 
-    test_assert(ecs_has_pair(world, ent, Rel, Tgt));
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+    test_assert(ecs_lookup(world, "a") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_assembly_w_pair_w_this_var(void) {
+void Eval_if_false(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_TAG(world, Rel);
-
     const char *expr =
-    LINE "assembly Foo {\n"
-    LINE "  prop x : flecs.meta.f32 = 10\n" // dummy prop
-    LINE " - (Rel, $this)\n"
-    LINE "}\n"
-    LINE "ent :- Foo{}\n"
-    LINE "\n";
-
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t foo = ecs_lookup(world, "Foo");
-    ecs_entity_t ent = ecs_lookup(world, "ent");
+    HEAD "if false {"
+    LINE "  a{}"
+    LINE "} else {"
+    LINE "  b{}"
+    LINE "}";
 
-    test_assert(ecs_has_id(world, ent, foo));
-    test_assert(ecs_has_pair(world, ent, Rel, ent));
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+    test_assert(ecs_lookup(world, "a") == 0);
+    test_assert(ecs_lookup(world, "b") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_with_value_not_a_component(void) {
+void Eval_if_10(void) {
     ecs_world_t *world = ecs_init();
 
     const char *expr =
-    LINE "with Foo{10} {\n"
-    LINE "  Bar\n"
-    LINE "}\n"
-    LINE "\n";
+    HEAD "if 10 {"
+    LINE "  a{}"
+    LINE "} else {"
+    LINE "  b{}"
+    LINE "}";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+    test_assert(ecs_lookup(world, "a") != 0);
+    test_assert(ecs_lookup(world, "b") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_component_in_with_scope(void) {
+void Eval_if_256(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
     const char *expr =
-    LINE "with Position{10, 20} {\n"
-    LINE "  - Bar\n"
-    LINE "}\n"
-    LINE "\n";
+    HEAD "if 256 {"
+    LINE "  a{}"
+    LINE "} else {"
+    LINE "  b{}"
+    LINE "}";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+    test_assert(ecs_lookup(world, "a") != 0);
+    test_assert(ecs_lookup(world, "b") == 0);
 
     ecs_fini(world);
 }
 
-void Plecs_component_in_with_scope_nested(void) {
+void Eval_if_0(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
-    ecs_struct(world, {
-        .entity = ecs_id(Velocity),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
     const char *expr =
-    LINE "with Position{10, 20} {\n"
-    LINE "  with Velocity{10, 20} {\n"
-    LINE "    - Bar\n"
-    LINE "  }\n"
-    LINE "}\n"
-    LINE "\n";
+    HEAD "if 0 {"
+    LINE "  a{}"
+    LINE "} else {"
+    LINE "  b{}"
+    LINE "}";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) != 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+    test_assert(ecs_lookup(world, "a") == 0);
+    test_assert(ecs_lookup(world, "b") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_component_in_with_scope_in_scope(void) {
+void Eval_if_true_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
     const char *expr =
-    LINE "foo {\n"
-    LINE "  - Position{10, 20}\n"
-    LINE "  with Position{30, 40} {\n"
-    LINE "    - Bar\n"
-    LINE "  }\n"
-    LINE "}\n";
+    HEAD "const v = true"
+    LINE "if $v {"
+    LINE "  a{}"
+    LINE "} else {"
+    LINE "  b{}"
+    LINE "}";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+    test_assert(ecs_lookup(world, "a") != 0);
+    test_assert(ecs_lookup(world, "b") == 0);
 
-    ecs_entity_t foo = ecs_lookup(world, "foo");
-    test_assert(foo != 0);
-    ecs_entity_t bar = ecs_lookup(world, "Bar");
-    test_assert(bar != 0);
+    ecs_fini(world);
+}
 
-    test_assert(ecs_has(world, foo, Position));
-    test_assert(ecs_has_id(world, foo, bar));
+void Eval_if_false_var(void) {
+    ecs_world_t *world = ecs_init();
 
-    const Position *p = ecs_get(world, foo, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
+    const char *expr =
+    HEAD "const v = false"
+    LINE "if $v {"
+    LINE "  a{}"
+    LINE "} else {"
+    LINE "  b{}"
+    LINE "}";
+
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
+    test_assert(ecs_lookup(world, "a") == 0);
+    test_assert(ecs_lookup(world, "b") != 0);
 
     ecs_fini(world);
 }
 
-void Plecs_assign_after_with_in_scope(void) {
+void Eval_if_true_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-    ECS_COMPONENT(world, Velocity);
-
-    ecs_struct(world, {
-        .entity = ecs_id(Position),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-    ecs_struct(world, {
-        .entity = ecs_id(Velocity),
-        .members = {
-            {"x", ecs_id(ecs_f32_t)},
-            {"y", ecs_id(ecs_f32_t)}
-        }
-    });
-
     const char *expr =
-    LINE "foo {\n"
-    LINE "  - Position{10, 20}\n"
-    LINE "  with Position{30, 40} {\n"
-    LINE "  }\n"
-    LINE "  - Velocity{1, 2}\n"
-    LINE "}\n";
+    HEAD "e {"
+    LINE "  if true {"
+    LINE "    Foo"
+    LINE "  } else {"
+    LINE "    Bar"
+    LINE "  }"
+    LINE "}";
 
-    ecs_log_set_level(-4);
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    ecs_entity_t foo = ecs_lookup(world, "foo");
+    ecs_entity_t e = ecs_lookup(world, "e");
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    test_assert(e != 0);
     test_assert(foo != 0);
-
-    test_assert(ecs_has(world, foo, Position));
-    test_assert(ecs_has(world, foo, Velocity));
-
-    const Position *p = ecs_get(world, foo, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
-
-    const Velocity *v = ecs_get(world, foo, Velocity);
-    test_assert(v != NULL);
-    test_int(v->x, 1);
-    test_int(v->y, 2);
+    test_assert(bar == 0);
+    test_assert(ecs_has_id(world, e, foo));
 
     ecs_fini(world);
 }
 
-void Plecs_array_component(void) {
+void Eval_if_false_in_scope(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
-
-    ecs_array(world, {
-        .entity = ecs_id(Position),
-        .type = ecs_id(ecs_f32_t),
-        .count = 2
-    });
-
     const char *expr =
-    LINE "foo :- Position[10, 20]\n";
-    test_assert(ecs_plecs_from_str(world, NULL, expr) == 0);
-
-    ecs_entity_t foo = ecs_lookup(world, "foo");
-    test_assert(foo != 0);
+    HEAD "e {"
+    LINE "  if false {"
+    LINE "    Foo"
+    LINE "  } else {"
+    LINE "    Bar"
+    LINE "  }"
+    LINE "}";
 
-    test_assert(ecs_has(world, foo, Position));
+    test_assert(ecs_script_run(world, NULL, expr) == 0);
 
-    const Position *p = ecs_get(world, foo, Position);
-    test_assert(p != NULL);
-    test_int(p->x, 10);
-    test_int(p->y, 20);
+    ecs_entity_t e = ecs_lookup(world, "e");
+    ecs_entity_t foo = ecs_lookup(world, "Foo");
+    ecs_entity_t bar = ecs_lookup(world, "Bar");
+    test_assert(e != 0);
+    test_assert(foo == 0);
+    test_assert(bar != 0);
+    test_assert(ecs_has_id(world, e, bar));
 
     ecs_fini(world);
 }
diff --git a/test/meta/src/DeserExprOperators.c b/test/script/src/Expr.c
similarity index 59%
rename from test/meta/src/DeserExprOperators.c
rename to test/script/src/Expr.c
index d24bc51f8..49f68c0f5 100644
--- a/test/meta/src/DeserExprOperators.c
+++ b/test/script/src/Expr.c
@@ -1,10 +1,10 @@
-#include <meta.h>
+#include <script.h>
 
-void DeserExprOperators_add_2_int_literals(void) {
+void Expr_add_2_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 + 20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 10 + 20);
@@ -13,16 +13,16 @@ void DeserExprOperators_add_2_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_2_int_literals_twice(void) {
+void Expr_add_2_int_literals_twice(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 + 20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 10 + 20);
 
-    test_assert(ecs_parse_expr(world, "10 + 20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 10 + 20);
@@ -31,11 +31,11 @@ void DeserExprOperators_add_2_int_literals_twice(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_sub_2_int_literals(void) {
+void Expr_sub_2_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "20 - 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "20 - 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(int64_t*)v.ptr, 20 - 10);
@@ -44,11 +44,11 @@ void DeserExprOperators_sub_2_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_2_int_literals(void) {
+void Expr_mul_2_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "20 * 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "20 * 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, 20 * 10);
@@ -57,11 +57,11 @@ void DeserExprOperators_mul_2_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_div_2_int_literals(void) {
+void Expr_div_2_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 / 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 / 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 10 / 2);
@@ -70,11 +70,11 @@ void DeserExprOperators_div_2_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_3_int_literals(void) {
+void Expr_add_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 + 20 + 30", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 20 + 30", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 10 + 20 + 30);
@@ -83,16 +83,16 @@ void DeserExprOperators_add_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_3_int_literals_twice(void) {
+void Expr_add_3_int_literals_twice(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 + 20 + 30", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 20 + 30", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 10 + 20 + 30);
 
-    test_assert(ecs_parse_expr(world, "10 + 20 + 30", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 20 + 30", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 10 + 20 + 30);
@@ -101,11 +101,11 @@ void DeserExprOperators_add_3_int_literals_twice(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_sub_3_int_literals(void) {
+void Expr_sub_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "30 - 10 - 5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "30 - 10 - 5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(ecs_i64_t*)v.ptr, 30 - 10 - 5);
@@ -114,11 +114,11 @@ void DeserExprOperators_sub_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_3_int_literals(void) {
+void Expr_mul_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "2 * 5 * 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "2 * 5 * 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, 2 * 5 * 10);
@@ -127,11 +127,11 @@ void DeserExprOperators_mul_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_div_3_int_literals(void) {
+void Expr_div_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "40 / 5 / 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "40 / 5 / 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 40 / 5 / 2);
@@ -140,23 +140,23 @@ void DeserExprOperators_div_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_int_to_bool(void) {
+void Expr_int_to_bool(void) {
     ecs_world_t *world = ecs_init();
 
     bool b = false;
     ecs_value_t v = { .type = ecs_id(ecs_bool_t), .ptr = &b };
 
-    test_assert(ecs_parse_expr(world, "10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_bool_t*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_bool_t*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "256", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "256", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_bool_t*)v.ptr, true);
@@ -164,18 +164,18 @@ void DeserExprOperators_int_to_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_bool_to_int(void) {
+void Expr_bool_to_int(void) {
     ecs_world_t *world = ecs_init();
 
     int32_t i = 0;
     ecs_value_t v = { .type = ecs_id(ecs_i32_t), .ptr = &i };
 
-    test_assert(ecs_parse_expr(world, "true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i32_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_i32_t*)v.ptr, 1);
 
-    test_assert(ecs_parse_expr(world, "false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i32_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_i32_t*)v.ptr, 0);
@@ -183,18 +183,18 @@ void DeserExprOperators_bool_to_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_bool_to_uint(void) {
+void Expr_bool_to_uint(void) {
     ecs_world_t *world = ecs_init();
 
     uint32_t i = 0;
     ecs_value_t v = { .type = ecs_id(ecs_u32_t), .ptr = &i };
 
-    test_assert(ecs_parse_expr(world, "true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u32_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_u32_t*)v.ptr, 1);
 
-    test_assert(ecs_parse_expr(world, "false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u32_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_u32_t*)v.ptr, 0);
@@ -202,11 +202,11 @@ void DeserExprOperators_bool_to_uint(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_mul_3_int_literals(void) {
+void Expr_add_mul_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 + 20 * 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 20 * 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 10 + 20 * 2);
@@ -215,11 +215,11 @@ void DeserExprOperators_add_mul_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_sub_mul_3_int_literals(void) {
+void Expr_sub_mul_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "50 - 10 * 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "50 - 10 * 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(int64_t*)v.ptr, 50 - 10 * 2);
@@ -228,11 +228,11 @@ void DeserExprOperators_sub_mul_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_div_mul_3_int_literals(void) {
+void Expr_div_mul_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 / 5 * 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 / 5 * 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 10 / 5 * 2);
@@ -241,11 +241,11 @@ void DeserExprOperators_div_mul_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_div_3_int_literals(void) {
+void Expr_add_div_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 + 30 / 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 30 / 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_f64_t*)v.ptr, 10 + 30 / 2);
@@ -254,11 +254,11 @@ void DeserExprOperators_add_div_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_sub_div_3_int_literals(void) {
+void Expr_sub_div_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "30 - 10 / 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "30 - 10 / 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_f64_t*)v.ptr, 30 - 10 / 2);
@@ -267,11 +267,11 @@ void DeserExprOperators_sub_div_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_div_3_int_literals(void) {
+void Expr_mul_div_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "20 * 10 / 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "20 * 10 / 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_f64_t*)v.ptr, 20 * 10 / 2);
@@ -280,11 +280,11 @@ void DeserExprOperators_mul_div_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_add_mul_add_int_literals(void) {
+void Expr_mul_add_mul_add_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "2 * 4 + 6 * 8 + 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "2 * 4 + 6 * 8 + 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, 2 * 4 + 6 * 8 + 10);
@@ -293,11 +293,11 @@ void DeserExprOperators_mul_add_mul_add_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_sub_mul_sub_int_literals(void) {
+void Expr_mul_sub_mul_sub_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "2 * 4 - 6 * 8 - 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "2 * 4 - 6 * 8 - 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(ecs_i64_t*)v.ptr, 2 * 4 - 6 * 8 - 10);
@@ -306,11 +306,11 @@ void DeserExprOperators_mul_sub_mul_sub_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_div_mul_div_int_literals(void) {
+void Expr_mul_div_mul_div_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "2 * 4 / 6 * 8 / 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "2 * 4 / 6 * 8 / 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 2.0 * 4.0 / 6.0 * 8.0 / 10.0);
@@ -319,11 +319,11 @@ void DeserExprOperators_mul_div_mul_div_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_div_add_div_add_int_literals(void) {
+void Expr_div_add_div_add_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "2 / 4 + 6 / 8 + 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "2 / 4 + 6 / 8 + 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 2.0 / 4.0 + 6.0 / 8.0 + 10.0);
@@ -332,11 +332,11 @@ void DeserExprOperators_div_add_div_add_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_div_sub_div_sub_int_literals(void) {
+void Expr_div_sub_div_sub_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "2 / 4 - 6 / 8 - 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "2 / 4 - 6 / 8 - 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 2.0 / 4.0 - 6.0 / 8.0 - 10.0);
@@ -345,11 +345,11 @@ void DeserExprOperators_div_sub_div_sub_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_div_mul_div_mul_int_literals(void) {
+void Expr_div_mul_div_mul_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "2 / 4 * 6 / 8 * 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "2 / 4 * 6 / 8 * 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 2.0 / 4.0 * 6.0 / 8.0 * 10.0);
@@ -358,11 +358,11 @@ void DeserExprOperators_div_mul_div_mul_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_div_sub_div_mul_int_literals(void) {
+void Expr_div_sub_div_mul_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "2 / 4 - 6 / 8 * 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "2 / 4 - 6 / 8 * 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 2.0 / 4.0 - 6.0 / 8.0 * 10.0);
@@ -371,11 +371,11 @@ void DeserExprOperators_div_sub_div_mul_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_2_flt_literals(void) {
+void Expr_add_2_flt_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10.5 + 20.0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 + 20.0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 10.5 + 20.0);
@@ -384,11 +384,11 @@ void DeserExprOperators_add_2_flt_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_sub_2_flt_literals(void) {
+void Expr_sub_2_flt_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "20.5 - 10.0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "20.5 - 10.0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 20.5 - 10.0);
@@ -397,11 +397,11 @@ void DeserExprOperators_sub_2_flt_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_2_flt_literals(void) {
+void Expr_mul_2_flt_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "20.5 * 10.0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "20.5 * 10.0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 20.5 * 10.0);
@@ -410,11 +410,11 @@ void DeserExprOperators_mul_2_flt_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_div_2_flt_literals(void) {
+void Expr_div_2_flt_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10.5 / 2.0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 / 2.0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, 10.5 / 2.0);
@@ -423,11 +423,11 @@ void DeserExprOperators_div_2_flt_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_2_int_neg_literals(void) {
+void Expr_add_2_int_neg_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "-10 + -20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-10 + -20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(ecs_i64_t*)v.ptr, -10 + -20);
@@ -436,11 +436,11 @@ void DeserExprOperators_add_2_int_neg_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_sub_2_int_neg_literals(void) {
+void Expr_sub_2_int_neg_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "-10 - -20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-10 - -20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(ecs_i64_t*)v.ptr, -10 - -20);
@@ -449,11 +449,11 @@ void DeserExprOperators_sub_2_int_neg_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_2_int_neg_literals(void) {
+void Expr_mul_2_int_neg_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "-10 * -20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-10 * -20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(ecs_i64_t*)v.ptr, -10 * -20);
@@ -462,11 +462,11 @@ void DeserExprOperators_mul_2_int_neg_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_div_2_int_neg_literals(void) {
+void Expr_div_2_int_neg_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "-10 / -20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-10 / -20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f64_t));
     test_assert(v.ptr != NULL);
     test_flt(*(ecs_f64_t*)v.ptr, -10.0 / -20.0);
@@ -475,11 +475,11 @@ void DeserExprOperators_div_2_int_neg_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_lparen_add_add_rparen_int_literals(void) {
+void Expr_mul_lparen_add_add_rparen_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 * (20 + 30)", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 * (20 + 30)", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, 10 * (20 + 30));
@@ -488,11 +488,11 @@ void DeserExprOperators_mul_lparen_add_add_rparen_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_lparen_add_add_add_rparen_int_literals(void) {
+void Expr_mul_lparen_add_add_add_rparen_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 * (20 + 30 + 40)", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 * (20 + 30 + 40)", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, 10 * (20 + 30 + 40));
@@ -501,11 +501,11 @@ void DeserExprOperators_mul_lparen_add_add_add_rparen_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_lparen_add_add_rparen_add_int_literals(void) {
+void Expr_mul_lparen_add_add_rparen_add_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 * (20 + 30) + 40", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 * (20 + 30) + 40", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, 10 * (20 + 30) + 40);
@@ -514,11 +514,11 @@ void DeserExprOperators_mul_lparen_add_add_rparen_add_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_lparen_add_add_rparen_mul_int_literals(void) {
+void Expr_lparen_add_add_rparen_mul_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "(20 + 30) * 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "(20 + 30) * 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, (20 + 30) * 10);
@@ -527,11 +527,11 @@ void DeserExprOperators_lparen_add_add_rparen_mul_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_lparen_add_add_add_rparen_mul_int_literals(void) {
+void Expr_lparen_add_add_add_rparen_mul_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "(20 + 30 + 40) * 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "(20 + 30 + 40) * 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, (20 + 30 + 40) * 10);
@@ -540,11 +540,11 @@ void DeserExprOperators_lparen_add_add_add_rparen_mul_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_double_paren_add_add(void) {
+void Expr_double_paren_add_add(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "((20 + 30))", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "((20 + 30))", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, ((20 + 30)));
@@ -553,11 +553,11 @@ void DeserExprOperators_double_paren_add_add(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_double_paren_literal(void) {
+void Expr_double_paren_literal(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "((20))", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "((20))", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, ((20)));
@@ -566,11 +566,11 @@ void DeserExprOperators_double_paren_literal(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_lparen_add_add_rparen_mul_lparen_add_add_rparen(void) {
+void Expr_lparen_add_add_rparen_mul_lparen_add_add_rparen(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "(10 + 20) * (20 + 30)", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "(10 + 20) * (20 + 30)", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_u64_t*)v.ptr, (10 + 20) * (20 + 30));
@@ -579,7 +579,7 @@ void DeserExprOperators_lparen_add_add_rparen_mul_lparen_add_add_rparen(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_float_result_add_2_int_literals(void) {
+void Expr_float_result_add_2_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     float value = 0;
@@ -587,7 +587,7 @@ void DeserExprOperators_float_result_add_2_int_literals(void) {
         .type = ecs_id(ecs_f32_t),
         .ptr = &value
     };
-    test_assert(ecs_parse_expr(world, "10 + 20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_f32_t));
     test_assert(v.ptr != NULL);
     test_flt(value, 10 + 20);
@@ -595,7 +595,7 @@ void DeserExprOperators_float_result_add_2_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_struct_result_add_2_int_literals(void) {
+void Expr_struct_result_add_2_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -609,7 +609,7 @@ void DeserExprOperators_struct_result_add_2_int_literals(void) {
     });
 
     Mass v = {0};
-    const char *ptr = ecs_parse_expr(world, "{10 + 20}", &(ecs_value_t){
+    const char *ptr = ecs_script_expr_run(world, "{10 + 20}", &(ecs_value_t){
         .type = t, .ptr = &v
     }, NULL);
     test_assert(ptr != NULL);
@@ -620,7 +620,7 @@ void DeserExprOperators_struct_result_add_2_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_struct_result_add_2_2_fields_int_literals(void) {
+void Expr_struct_result_add_2_2_fields_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -636,7 +636,7 @@ void DeserExprOperators_struct_result_add_2_2_fields_int_literals(void) {
     });
 
     Mass v = {0};
-    const char *ptr = ecs_parse_expr(world, "{10 + 20, 20 + 30}", &(ecs_value_t){
+    const char *ptr = ecs_script_expr_run(world, "{10 + 20, 20 + 30}", &(ecs_value_t){
         .type = t, .ptr = &v
     }, NULL);
     test_assert(ptr != NULL);
@@ -648,7 +648,7 @@ void DeserExprOperators_struct_result_add_2_2_fields_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_struct_result_add_3_int_literals(void) {
+void Expr_struct_result_add_3_int_literals(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -662,7 +662,7 @@ void DeserExprOperators_struct_result_add_3_int_literals(void) {
     });
 
     Mass v = {0};
-    const char *ptr = ecs_parse_expr(world, "{10 + 20 + 30}", &(ecs_value_t){
+    const char *ptr = ecs_script_expr_run(world, "{10 + 20 + 30}", &(ecs_value_t){
         .type = t, .ptr = &v
     }, NULL);
     test_assert(ptr != NULL);
@@ -673,7 +673,7 @@ void DeserExprOperators_struct_result_add_3_int_literals(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_struct_result_lparen_int_rparen(void) {
+void Expr_struct_result_lparen_int_rparen(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -687,7 +687,7 @@ void DeserExprOperators_struct_result_lparen_int_rparen(void) {
     });
 
     Mass v = {0};
-    const char *ptr = ecs_parse_expr(world, "{(10)}", &(ecs_value_t){
+    const char *ptr = ecs_script_expr_run(world, "{(10)}", &(ecs_value_t){
         .type = t, .ptr = &v
     }, NULL);
     test_assert(ptr != NULL);
@@ -698,73 +698,71 @@ void DeserExprOperators_struct_result_lparen_int_rparen(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_to_var(void) {
+void Expr_add_to_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
     *(int32_t*)var->value.ptr = 10;
 
     ecs_value_t v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(world, "$foo + 20", &v, &desc);
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(world, "$foo + 20", &v, &desc);
     test_assert(ptr != NULL);
     test_assert(!ptr[0]);
     test_int(*(int32_t*)v.ptr, 10 + 20);
     ecs_value_free(world, v.type, v.ptr);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_var_to(void) {
+void Expr_add_var_to(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
     *(int32_t*)var->value.ptr = 10;
 
     ecs_value_t v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(world, "20 + $foo", &v, &desc);
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(world, "20 + $foo", &v, &desc);
     test_assert(ptr != NULL);
     test_assert(!ptr[0]);
     test_int(*(int32_t*)v.ptr, 20 + 10);
     ecs_value_free(world, v.type, v.ptr);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
     ecs_fini(world);
 }
 
-void DeserExprOperators_var_member(void) {
+void Expr_var_member(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
 
     ecs_struct(world, {
-        .entity = ecs_id(Position),
+        .entity = ecs_id(PositionI),
         .members = {
             { .name = "x", .type = ecs_id(ecs_i32_t) },
             { .name = "y", .type = ecs_id(ecs_i32_t) }
         }
     });
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(&vars, "foo", ecs_id(Position));
-    *(Position*)var->value.ptr = (Position){10, 20};
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", PositionI);
+    *(PositionI*)var->value.ptr = (PositionI){10, 20};
 
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
     {
         ecs_value_t v = {0};
-        const char *ptr = ecs_parse_expr(world, "$foo.x", &v, &desc);
+        const char *ptr = ecs_script_expr_run(world, "$foo.x", &v, &desc);
         test_assert(ptr != NULL);
         test_assert(!ptr[0]);
         test_uint(v.type, ecs_id(ecs_i32_t));
@@ -773,7 +771,7 @@ void DeserExprOperators_var_member(void) {
     }
     {
         ecs_value_t v = {0};
-        const char *ptr = ecs_parse_expr(world, "$foo.y", &v, &desc);
+        const char *ptr = ecs_script_expr_run(world, "$foo.y", &v, &desc);
         test_assert(ptr != NULL);
         test_assert(!ptr[0]);
         test_uint(v.type, ecs_id(ecs_i32_t));
@@ -781,30 +779,30 @@ void DeserExprOperators_var_member(void) {
         ecs_value_free(world, v.type, v.ptr);
     }
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
     ecs_fini(world);
 }
 
-void DeserExprOperators_bool_cond_and_bool(void) {
+void Expr_bool_cond_and_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true && true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true && true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "true && false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true && false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false && true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false && true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false && false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false && false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -813,26 +811,26 @@ void DeserExprOperators_bool_cond_and_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_bool_cond_or_bool(void) {
+void Expr_bool_cond_or_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true || true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true || true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "true || false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true || false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false || true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false || true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false || false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false || false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -841,26 +839,26 @@ void DeserExprOperators_bool_cond_or_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_int_cond_and_int(void) {
+void Expr_int_cond_and_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 && 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 && 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10 && 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 && 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "0 && 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 && 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "0 && 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 && 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -869,26 +867,26 @@ void DeserExprOperators_int_cond_and_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_int_cond_or_int(void) {
+void Expr_int_cond_or_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 || 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 || 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10 || 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 || 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "0 || 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 || 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "0 || 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 || 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -897,26 +895,26 @@ void DeserExprOperators_int_cond_or_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_bool_cond_and_int(void) {
+void Expr_bool_cond_and_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true && 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true && 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "true && 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true && 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false && 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false && 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false && 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false && 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -925,26 +923,26 @@ void DeserExprOperators_bool_cond_and_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_int_cond_and_bool(void) {
+void Expr_int_cond_and_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 && true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 && true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10 && false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 && false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "0 && true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 && true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "0 && false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 && false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -953,26 +951,26 @@ void DeserExprOperators_int_cond_and_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_bool_cond_or_int(void) {
+void Expr_bool_cond_or_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true || 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true || 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "true || 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true || 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false || 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false || 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false || 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false || 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -981,26 +979,26 @@ void DeserExprOperators_bool_cond_or_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_int_cond_or_bool(void) {
+void Expr_int_cond_or_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 || true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 || true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10 || false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 || false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "0 || true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 || true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "0 || false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 || false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -1009,26 +1007,26 @@ void DeserExprOperators_int_cond_or_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_eq_bool(void) {
+void Expr_cond_eq_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true == true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true == true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "true == false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true == false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false == true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false == true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false == false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false == false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
@@ -1037,26 +1035,26 @@ void DeserExprOperators_cond_eq_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_eq_int(void) {
+void Expr_cond_eq_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 == 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 == 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10 == 20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 == 20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "10 == 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 == 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "0 == 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 == 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
@@ -1065,26 +1063,26 @@ void DeserExprOperators_cond_eq_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_neq_bool(void) {
+void Expr_cond_neq_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true != true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true != true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "true != false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true != false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false != true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false != true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false != false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false != false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -1093,26 +1091,26 @@ void DeserExprOperators_cond_neq_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_neq_int(void) {
+void Expr_cond_neq_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 != 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 != 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "10 != 20", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 != 20", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10 != 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 != 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "0 != 0", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "0 != 0", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -1121,47 +1119,47 @@ void DeserExprOperators_cond_neq_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_eq_bool_int(void) {
+void Expr_cond_eq_bool_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
 
     ecs_log_set_level(-4);
-    test_assert(ecs_parse_expr(world, "true == 1", &v, NULL) == NULL);
-    test_assert(ecs_parse_expr(world, "true == 0", &v, NULL) == NULL);
-    test_assert(ecs_parse_expr(world, "false == 0", &v, NULL) == NULL);
+    test_assert(ecs_script_expr_run(world, "true == 1", &v, NULL) == NULL);
+    test_assert(ecs_script_expr_run(world, "true == 0", &v, NULL) == NULL);
+    test_assert(ecs_script_expr_run(world, "false == 0", &v, NULL) == NULL);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_eq_int_flt(void) {
+void Expr_cond_eq_int_flt(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
 
     ecs_log_set_level(-4);
-    test_assert(ecs_parse_expr(world, "1 == 1.0", &v, NULL) == NULL);
-    test_assert(ecs_parse_expr(world, "1 == 0.0", &v, NULL) == NULL);
-    test_assert(ecs_parse_expr(world, "0 == 0.0", &v, NULL) == NULL);
+    test_assert(ecs_script_expr_run(world, "1 == 1.0", &v, NULL) == NULL);
+    test_assert(ecs_script_expr_run(world, "1 == 0.0", &v, NULL) == NULL);
+    test_assert(ecs_script_expr_run(world, "0 == 0.0", &v, NULL) == NULL);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_eq_cond_and(void) {
+void Expr_cond_eq_cond_and(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true == true && false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true == true && false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true == true && false);
 
-    test_assert(ecs_parse_expr(world, "true && false == false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true && false == false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true && false == false);
 
-    test_assert(ecs_parse_expr(world, "true && true == true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true && true == true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true && true == true);
@@ -1170,16 +1168,16 @@ void DeserExprOperators_cond_eq_cond_and(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_eq_cond_or(void) {
+void Expr_cond_eq_cond_or(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true == true || false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true == true || false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true == true || false);
 
-    test_assert(ecs_parse_expr(world, "true || false == false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true || false == false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true || false == false);
@@ -1188,26 +1186,26 @@ void DeserExprOperators_cond_eq_cond_or(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_gt_bool(void) {
+void Expr_cond_gt_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true > false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true > false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "true > true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true > true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false > true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false > true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false > false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false > false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -1216,26 +1214,26 @@ void DeserExprOperators_cond_gt_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_gt_int(void) {
+void Expr_cond_gt_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 > 5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 > 5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10 > 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 > 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "5 > 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5 > 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "5 > 5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5 > 5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -1244,26 +1242,26 @@ void DeserExprOperators_cond_gt_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_gt_flt(void) {
+void Expr_cond_gt_flt(void) {
         ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10.5 > 5.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 > 5.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10.5 > 10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 > 10.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "5.5 > 10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5.5 > 10.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "5.5 > 5.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5.5 > 5.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -1272,26 +1270,26 @@ void DeserExprOperators_cond_gt_flt(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_gteq_bool(void) {
+void Expr_cond_gteq_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true >= false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true >= false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "true >= true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true >= true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false >= true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false >= true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false >= false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false >= false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
@@ -1300,26 +1298,26 @@ void DeserExprOperators_cond_gteq_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_gteq_int(void) {
+void Expr_cond_gteq_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 >= 5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 >= 5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10 >= 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 >= 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "5 >= 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5 >= 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "5 >= 5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5 >= 5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
@@ -1328,26 +1326,26 @@ void DeserExprOperators_cond_gteq_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_gteq_flt(void) {
+void Expr_cond_gteq_flt(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10.5 >= 5.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 >= 5.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "10.5 >= 10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 >= 10.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "5.5 >= 10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5.5 >= 10.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "5.5 >= 5.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5.5 >= 5.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
@@ -1356,26 +1354,26 @@ void DeserExprOperators_cond_gteq_flt(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_lt_bool(void) {
+void Expr_cond_lt_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true < false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true < false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "true < true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true < true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "false < true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false < true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false < false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false < false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -1384,26 +1382,26 @@ void DeserExprOperators_cond_lt_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_lt_int(void) {
+void Expr_cond_lt_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 < 5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 < 5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "10 < 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 < 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "5 < 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5 < 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "5 < 5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5 < 5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -1412,26 +1410,26 @@ void DeserExprOperators_cond_lt_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_lt_flt(void) {
+void Expr_cond_lt_flt(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10.5 < 5.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 < 5.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "10.5 < 10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 < 10.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "5.5 < 10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5.5 < 10.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "5.5 < 5.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5.5 < 5.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
@@ -1440,26 +1438,26 @@ void DeserExprOperators_cond_lt_flt(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_lteq_bool(void) {
+void Expr_cond_lteq_bool(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "true <= false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true <= false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "true <= true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "true <= true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false <= true", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false <= true", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "false <= false", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "false <= false", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
@@ -1468,26 +1466,26 @@ void DeserExprOperators_cond_lteq_bool(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_lteq_int(void) {
+void Expr_cond_lteq_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 <= 5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 <= 5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "10 <= 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 <= 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "5 <= 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5 <= 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "5 <= 5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5 <= 5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
@@ -1496,26 +1494,26 @@ void DeserExprOperators_cond_lteq_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_cond_lteq_flt(void) {
+void Expr_cond_lteq_flt(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10.5 <= 5.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 <= 5.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, false);
 
-    test_assert(ecs_parse_expr(world, "10.5 <= 10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10.5 <= 10.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "5.5 <= 10.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5.5 <= 10.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
 
-    test_assert(ecs_parse_expr(world, "5.5 <= 5.5", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "5.5 <= 5.5", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_bool_t));
     test_assert(v.ptr != NULL);
     test_bool(*(bool*)v.ptr, true);
@@ -1524,11 +1522,11 @@ void DeserExprOperators_cond_lteq_flt(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_min_lparen_int_rparen(void) {
+void Expr_min_lparen_int_rparen(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "-(10)", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-(10)", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(ecs_i64_t*)v.ptr, -10);
@@ -1537,11 +1535,11 @@ void DeserExprOperators_min_lparen_int_rparen(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_min_lparen_int_add_int_rparen(void) {
+void Expr_min_lparen_int_add_int_rparen(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "-(10 + 20)", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-(10 + 20)", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(ecs_i64_t*)v.ptr, -30);
@@ -1550,35 +1548,34 @@ void DeserExprOperators_min_lparen_int_add_int_rparen(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_min_var(void) {
+void Expr_min_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_u64_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_u64_t);
     *(ecs_u64_t*)var->value.ptr = 10;
 
     ecs_value_t v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    test_assert(ecs_parse_expr(world, "-$foo", &v, &desc) != NULL);
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    test_assert(ecs_script_expr_run(world, "-$foo", &v, &desc) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(*(ecs_i64_t*)v.ptr, -10);
     ecs_value_free(world, v.type, v.ptr);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_min_lparen_int_rparen_to_i64(void) {
+void Expr_min_lparen_int_rparen_to_i64(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_i64_t vi = 0;
     ecs_value_t v = { .type = ecs_id(ecs_i64_t), .ptr = &vi };
-    test_assert(ecs_parse_expr(world, "-(10)", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-(10)", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i64_t));
     test_assert(v.ptr != NULL);
     test_int(vi, -10);
@@ -1586,12 +1583,12 @@ void DeserExprOperators_min_lparen_int_rparen_to_i64(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_min_lparen_int_rparen_to_i32(void) {
+void Expr_min_lparen_int_rparen_to_i32(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_i32_t vi = 0;
     ecs_value_t v = { .type = ecs_id(ecs_i32_t), .ptr = &vi };
-    test_assert(ecs_parse_expr(world, "-(10)", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "-(10)", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_i32_t));
     test_assert(v.ptr != NULL);
     test_int(vi, -10);
@@ -1599,7 +1596,7 @@ void DeserExprOperators_min_lparen_int_rparen_to_i32(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_struct_w_min_var(void) {
+void Expr_struct_w_min_var(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -1612,28 +1609,27 @@ void DeserExprOperators_struct_w_min_var(void) {
         }
     });
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_u64_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_u64_t);
     *(ecs_u64_t*)var->value.ptr = 10;
 
     Mass v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(world, "{-$foo}", &(ecs_value_t){
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(world, "{-$foo}", &(ecs_value_t){
         .type = t, .ptr = &v
     }, &desc);
     test_assert(ptr != NULL);
     test_assert(!ptr[0]);
 
     test_uint(v.value, -10);
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_struct_w_min_lparen_int_rparen(void) {
+void Expr_struct_w_min_lparen_int_rparen(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -1647,7 +1643,7 @@ void DeserExprOperators_struct_w_min_lparen_int_rparen(void) {
     });
 
     Mass v = {0};
-    const char *ptr = ecs_parse_expr(world, "{-(10)}", &(ecs_value_t){
+    const char *ptr = ecs_script_expr_run(world, "{-(10)}", &(ecs_value_t){
         .type = t, .ptr = &v
     }, NULL);
     test_assert(ptr != NULL);
@@ -1658,7 +1654,7 @@ void DeserExprOperators_struct_w_min_lparen_int_rparen(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_struct_w_min_lparen_var_rparen(void) {
+void Expr_struct_w_min_lparen_var_rparen(void) {
     ecs_world_t *world = ecs_init();
 
     typedef struct {
@@ -1671,32 +1667,31 @@ void DeserExprOperators_struct_w_min_lparen_var_rparen(void) {
         }
     });
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_u64_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_u64_t);
     *(ecs_u64_t*)var->value.ptr = 10;
 
     Mass v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    const char *ptr = ecs_parse_expr(world, "{-($foo)}", &(ecs_value_t){
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(world, "{-($foo)}", &(ecs_value_t){
         .type = t, .ptr = &v
     }, &desc);
     test_assert(ptr != NULL);
     test_assert(!ptr[0]);
 
     test_uint(v.value, -10);
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_shift_left_int(void) {
+void Expr_shift_left_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "1 << 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "1 << 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 1 << 2);
@@ -1705,11 +1700,11 @@ void DeserExprOperators_shift_left_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_shift_right_int(void) {
+void Expr_shift_right_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "4 >> 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "4 >> 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 4 >> 2);
@@ -1718,11 +1713,11 @@ void DeserExprOperators_shift_right_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_shift_left_int_add_int(void) {
+void Expr_shift_left_int_add_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "1 << 2 + 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "1 << 2 + 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 1 << (2 + 10));
@@ -1731,11 +1726,11 @@ void DeserExprOperators_shift_left_int_add_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_shift_left_int_mul_int(void) {
+void Expr_shift_left_int_mul_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "1 << 2 * 10", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "1 << 2 * 10", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 1 << 2 * 10);
@@ -1744,11 +1739,11 @@ void DeserExprOperators_shift_left_int_mul_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_int_shift_left_int(void) {
+void Expr_add_int_shift_left_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 + 1 << 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 1 << 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, (10 + 1) << 2);
@@ -1757,11 +1752,11 @@ void DeserExprOperators_add_int_shift_left_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_int_shift_left_int(void) {
+void Expr_mul_int_shift_left_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 * 1 << 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 * 1 << 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 10 * 1 << 2);
@@ -1770,11 +1765,11 @@ void DeserExprOperators_mul_int_shift_left_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_add_int_shift_left_int_add_int(void) {
+void Expr_add_int_shift_left_int_add_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 + 1 << 2 + 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 + 1 << 2 + 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, (10 + 1) << (2 + 2));
@@ -1783,11 +1778,11 @@ void DeserExprOperators_add_int_shift_left_int_add_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_mul_int_shift_left_int_mul_int(void) {
+void Expr_mul_int_shift_left_int_mul_int(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "10 * 1 << 2 * 2", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "10 * 1 << 2 * 2", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_u64_t));
     test_assert(v.ptr != NULL);
     test_uint(*(uint64_t*)v.ptr, 10 * 1 << 2 * 2);
@@ -1796,14 +1791,14 @@ void DeserExprOperators_mul_int_shift_left_int_mul_int(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_entity_expr(void) {
+void Expr_entity_expr(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t foo = ecs_new_entity(world, "foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "foo" });
     test_assert(foo != 0);
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "foo", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "foo", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_entity_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_entity_t*)v.ptr, foo);
@@ -1812,17 +1807,17 @@ void DeserExprOperators_entity_expr(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_entity_path_expr(void) {
+void Expr_entity_path_expr(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t foo = ecs_new_entity(world, "parent.foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "parent.foo" });
     test_assert(foo != 0);
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "parent.foo", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "parent.foo", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_entity_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_entity_t*)v.ptr, foo);
@@ -1831,17 +1826,17 @@ void DeserExprOperators_entity_path_expr(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_entity_parent_func(void) {
+void Expr_entity_parent_func(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t foo = ecs_new_entity(world, "parent.foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "parent.foo" });
     test_assert(foo != 0);
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "parent.foo.parent()", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "parent.foo.parent()", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_entity_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_entity_t*)v.ptr, parent);
@@ -1850,17 +1845,17 @@ void DeserExprOperators_entity_parent_func(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_entity_name_func(void) {
+void Expr_entity_name_func(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t foo = ecs_new_entity(world, "parent.foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "parent.foo" });
     test_assert(foo != 0);
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "parent.foo.name()", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "parent.foo.name()", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_string_t));
     test_assert(v.ptr != NULL);
     test_str(*(char**)v.ptr, "foo");
@@ -1869,18 +1864,18 @@ void DeserExprOperators_entity_name_func(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_entity_doc_name_func(void) {
+void Expr_entity_doc_name_func(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t foo = ecs_new_entity(world, "parent.foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "parent.foo" });
     test_assert(foo != 0);
     ecs_doc_set_name(world, foo, "FooDoc");
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "parent.foo.doc_name()", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "parent.foo.doc_name()", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_string_t));
     test_assert(v.ptr != NULL);
     test_str(*(char**)v.ptr, "FooDoc");
@@ -1889,17 +1884,17 @@ void DeserExprOperators_entity_doc_name_func(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_entity_chain_func(void) {
+void Expr_entity_chain_func(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t foo = ecs_new_entity(world, "parent.foo");
+    ecs_entity_t foo = ecs_entity(world, { .name = "parent.foo" });
     test_assert(foo != 0);
 
     ecs_value_t v = {0};
-    test_assert(ecs_parse_expr(world, "parent.foo.parent().name()", &v, NULL) != NULL);
+    test_assert(ecs_script_expr_run(world, "parent.foo.parent().name()", &v, NULL) != NULL);
     test_assert(v.type == ecs_id(ecs_string_t));
     test_assert(v.ptr != NULL);
     test_str(*(char**)v.ptr, "parent");
@@ -1908,310 +1903,301 @@ void DeserExprOperators_entity_chain_func(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_var_parent_func(void) {
+void Expr_var_parent_func(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t child = ecs_new_entity(world, "parent.child");
+    ecs_entity_t child = ecs_entity(world, { .name = "parent.child" });
     test_assert(child != 0);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(&vars, "foo", ecs_id(ecs_entity_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_entity_t);
     test_assert(var != NULL);
     *(ecs_entity_t*)var->value.ptr = child;
 
     ecs_value_t v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    test_assert(ecs_parse_expr(world, "$foo.parent()", &v, &desc) != NULL);
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    test_assert(ecs_script_expr_run(world, "$foo.parent()", &v, &desc) != NULL);
     test_assert(v.type == ecs_id(ecs_entity_t));
     test_assert(v.ptr != NULL);
     test_uint(*(ecs_entity_t*)v.ptr, parent);
     ecs_value_free(world, v.type, v.ptr);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_var_name_func(void) {
+void Expr_var_name_func(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t child = ecs_new_entity(world, "parent.child");
+    ecs_entity_t child = ecs_entity(world, { .name = "parent.child" });
     test_assert(child != 0);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(&vars, "foo", ecs_id(ecs_entity_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_entity_t);
     test_assert(var != NULL);
     *(ecs_entity_t*)var->value.ptr = child;
 
     ecs_value_t v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    test_assert(ecs_parse_expr(world, "$foo.name()", &v, &desc) != NULL);
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    test_assert(ecs_script_expr_run(world, "$foo.name()", &v, &desc) != NULL);
     test_assert(v.type == ecs_id(ecs_string_t));
     test_assert(v.ptr != NULL);
     test_str(*(char**)v.ptr, "child");
     ecs_value_free(world, v.type, v.ptr);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_var_doc_name_func(void) {
+void Expr_var_doc_name_func(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t child = ecs_new_entity(world, "parent.child");
+    ecs_entity_t child = ecs_entity(world, { .name = "parent.child" });
     test_assert(child != 0);
     ecs_doc_set_name(world, child, "ChildDoc");
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(&vars, "foo", ecs_id(ecs_entity_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_entity_t);
     test_assert(var != NULL);
     *(ecs_entity_t*)var->value.ptr = child;
 
     ecs_value_t v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    test_assert(ecs_parse_expr(world, "$foo.doc_name()", &v, &desc) != NULL);
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    test_assert(ecs_script_expr_run(world, "$foo.doc_name()", &v, &desc) != NULL);
     test_assert(v.type == ecs_id(ecs_string_t));
     test_assert(v.ptr != NULL);
     test_str(*(char**)v.ptr, "ChildDoc");
     ecs_value_free(world, v.type, v.ptr);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_var_chain_func(void) {
+void Expr_var_chain_func(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t child = ecs_new_entity(world, "parent.child");
+    ecs_entity_t child = ecs_entity(world, { .name = "parent.child" });
     test_assert(child != 0);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(&vars, "foo", ecs_id(ecs_entity_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_entity_t);
     test_assert(var != NULL);
     *(ecs_entity_t*)var->value.ptr = child;
 
     ecs_value_t v = {0};
-    ecs_parse_expr_desc_t desc = { .vars = &vars };
-    test_assert(ecs_parse_expr(world, "$foo.parent().name()", &v, &desc) != NULL);
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    test_assert(ecs_script_expr_run(world, "$foo.parent().name()", &v, &desc) != NULL);
     test_assert(v.type == ecs_id(ecs_string_t));
     test_assert(v.ptr != NULL);
     test_str(*(char**)v.ptr, "parent");
     ecs_value_free(world, v.type, v.ptr);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_i32_var(void) {
+void Expr_interpolate_string_w_i32_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
     test_assert(v != NULL);
     *(int32_t*)v->value.ptr = 10;
 
-    char *result = ecs_interpolate_string(world, "$foo", &vars);
+    char *result = ecs_script_string_interpolate(world, "$foo", vars);
     test_assert(result != NULL);
     test_str(result, "10");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_string_var(void) {
+void Expr_interpolate_string_w_string_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_string_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_string_t);
     test_assert(v != NULL);
     *(ecs_string_t*)v->value.ptr = ecs_os_strdup("Hello World");
 
-    char *result = ecs_interpolate_string(world, "$foo", &vars);
+    char *result = ecs_script_string_interpolate(world, "$foo", vars);
     test_assert(result != NULL);
     test_str(result, "Hello World");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_entity_var(void) {
+void Expr_interpolate_string_w_entity_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_entity_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_entity_t);
     test_assert(v != NULL);
     *(ecs_entity_t*)v->value.ptr = ecs_id(ecs_i32_t);
 
-    char *result = ecs_interpolate_string(world, "$foo", &vars);
+    char *result = ecs_script_string_interpolate(world, "$foo", vars);
     test_assert(result != NULL);
     test_str(result, "flecs.meta.i32");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_id_var(void) {
+void Expr_interpolate_string_w_id_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_id_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_id_t);
     test_assert(v != NULL);
     *(ecs_id_t*)v->value.ptr = ecs_id(ecs_i32_t);
 
-    char *result = ecs_interpolate_string(world, "$foo", &vars);
+    char *result = ecs_script_string_interpolate(world, "$foo", vars);
     test_assert(result != NULL);
     test_str(result, "flecs.meta.i32");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_var_not_found(void) {
+void Expr_interpolate_string_w_var_not_found(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
     ecs_log_set_level(-4);
-    char *result = ecs_interpolate_string(world, "$foo", &vars);
+    char *result = ecs_script_string_interpolate(world, "$foo", vars);
     test_assert(result == NULL);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_entity_var_0(void) {
+void Expr_interpolate_string_w_entity_var_0(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_entity_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_entity_t);
     test_assert(v != NULL);
     *(ecs_entity_t*)v->value.ptr = 0;
 
-    char *result = ecs_interpolate_string(world, "$foo", &vars);
+    char *result = ecs_script_string_interpolate(world, "$foo", vars);
     test_assert(result != NULL);
     test_str(result, "0");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_var_special_chars(void) {
+void Expr_interpolate_string_w_var_special_chars(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "_foo_bar_10", ecs_id(ecs_i32_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "_foo_bar_10", ecs_i32_t);
     test_assert(v != NULL);
     *(int32_t*)v->value.ptr = 10;
 
-    char *result = ecs_interpolate_string(world, "$_foo_bar_10", &vars);
+    char *result = ecs_script_string_interpolate(world, "$_foo_bar_10", vars);
     test_assert(result != NULL);
     test_str(result, "10");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_var_before_after_text(void) {
+void Expr_interpolate_string_w_var_before_after_text(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
     test_assert(v != NULL);
     *(int32_t*)v->value.ptr = 10;
 
-    char *result = ecs_interpolate_string(world, "Hello $foo World", &vars);
+    char *result = ecs_script_string_interpolate(world, "Hello $foo World", vars);
     test_assert(result != NULL);
     test_str(result, "Hello 10 World");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_curly_brackets_var(void) {
+void Expr_interpolate_string_w_curly_brackets_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
     test_assert(v != NULL);
     *(int32_t*)v->value.ptr = 10;
 
-    char *result = ecs_interpolate_string(world, "Hello {$foo}World", &vars);
+    char *result = ecs_script_string_interpolate(world, "Hello {$foo}World", vars);
     test_assert(result != NULL);
     test_str(result, "Hello 10World");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_curly_brackets_expr(void) {
+void Expr_interpolate_string_w_curly_brackets_expr(void) {
     ecs_world_t *world = ecs_init();
 
-    char *result = ecs_interpolate_string(world, "Hello {10 + 20}World", NULL);
+    char *result = ecs_script_string_interpolate(world, "Hello {10 + 20}World", NULL);
     test_assert(result != NULL);
     test_str(result, "Hello 30World");
     ecs_os_free(result);
@@ -2219,83 +2205,81 @@ void DeserExprOperators_interpolate_string_w_curly_brackets_expr(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_curly_brackets_expr_w_var(void) {
+void Expr_interpolate_string_w_curly_brackets_expr_w_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
     test_assert(v != NULL);
     *(int32_t*)v->value.ptr = 10;
 
-    char *result = ecs_interpolate_string(world, "Hello {$foo + 5}World", &vars);
+    char *result = ecs_script_string_interpolate(world, "Hello {$foo + 5}World", vars);
     test_assert(result != NULL);
     test_str(result, "Hello 15World");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_curly_brackets_expr_w_composite_var(void) {
+void Expr_interpolate_string_w_curly_brackets_expr_w_composite_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
 
     ecs_struct(world, {
-        .entity = ecs_id(Position),
+        .entity = ecs_id(PositionI),
         .members = {
             { .name = "x", .type = ecs_id(ecs_i32_t) },
             { .name = "y", .type = ecs_id(ecs_i32_t) }
         }
     });
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(Position));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", PositionI);
     test_assert(v != NULL);
-    *(Position*)v->value.ptr = (Position){10, 20};
+    *(PositionI*)v->value.ptr = (PositionI){10, 20};
 
-    char *result = ecs_interpolate_string(world, "Hello {$foo.x + $foo.y}World", &vars);
+    char *result = ecs_script_string_interpolate(
+        world, "Hello {$foo.x + $foo.y}World", vars);
     test_assert(result != NULL);
     test_str(result, "Hello 30World");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_escape_var_operator(void) {
+void Expr_interpolate_string_w_escape_var_operator(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *v = ecs_vars_declare(
-        &vars, "foo", ecs_id(ecs_i32_t));
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
     test_assert(v != NULL);
     *(int32_t*)v->value.ptr = 10;
 
-    char *result = ecs_interpolate_string(world, "Hello \\$foo World", &vars);
+    char *result = ecs_script_string_interpolate(world, "Hello \\$foo World", vars);
     test_assert(result != NULL);
     test_str(result, "Hello $foo World");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_escape_curly_brackets(void) {
+void Expr_interpolate_string_w_escape_curly_brackets(void) {
     ecs_world_t *world = ecs_init();
 
-    char *result = ecs_interpolate_string(world, "Hello \\{10 + 20}World", NULL);
+    char *result = ecs_script_string_interpolate(world, "Hello \\{10 + 20}World", NULL);
     test_assert(result != NULL);
     test_str(result, "Hello {10 + 20}World");
     ecs_os_free(result);
@@ -2303,463 +2287,459 @@ void DeserExprOperators_interpolate_string_w_escape_curly_brackets(void) {
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_func(void) {
+void Expr_interpolate_string_w_func(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
 
-    ecs_entity_t child = ecs_new_entity(world, "parent.child");
+    ecs_entity_t child = ecs_entity(world, { .name = "parent.child" });
     test_assert(child != 0);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(&vars, "foo", ecs_id(ecs_entity_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_entity_t);
     test_assert(var != NULL);
     *(ecs_entity_t*)var->value.ptr = child;
 
-    char *result = ecs_interpolate_string(world, "Hello {$foo.name()} World", &vars);
+    char *result = ecs_script_string_interpolate(
+        world, "Hello {$foo.name()} World", vars);
     test_assert(result != NULL);
     test_str(result, "Hello child World");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_interpolate_string_w_func_chain(void) {
+void Expr_interpolate_string_w_func_chain(void) {
     ecs_world_t *world = ecs_init();
 
-    ecs_entity_t parent = ecs_new_entity(world, "parent");
+    ecs_entity_t parent = ecs_entity(world, { .name = "parent" });
     test_assert(parent != 0);
     ecs_doc_set_name(world, parent, "Parent");
 
-    ecs_entity_t child = ecs_new_entity(world, "parent.child");
+    ecs_entity_t child = ecs_entity(world, { .name = "parent.child" });
     test_assert(child != 0);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_expr_var_t *var = ecs_vars_declare(&vars, "foo", ecs_id(ecs_entity_t));
+    ecs_script_var_t *var = ecs_script_vars_define(
+        vars, "foo", ecs_entity_t);
     test_assert(var != NULL);
     *(ecs_entity_t*)var->value.ptr = child;
 
-    char *result = ecs_interpolate_string(world, "Hello {$foo.parent().doc_name()} World", &vars);
+    char *result = ecs_script_string_interpolate(
+        world, "Hello {$foo.parent().doc_name()} World", vars);
     test_assert(result != NULL);
     test_str(result, "Hello Parent World");
     ecs_os_free(result);
 
-    ecs_vars_fini(&vars);
+    ecs_script_vars_fini(vars);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_iter_to_vars_no_data(void) {
+void Expr_iter_to_vars_no_data(void) {
     ecs_world_t *world = ecs_init();
 
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *rule = ecs_rule(world, { .expr = "Foo" });
-    test_assert(rule != NULL);
+    ecs_query_t *query = ecs_query(world, { .expr = "Foo" });
+    test_assert(query != NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Foo);
-    ecs_entity_t e2 = ecs_new(world, Foo);
+    ecs_entity_t e1 = ecs_new_w(world, Foo);
+    ecs_entity_t e2 = ecs_new_w(world, Foo);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_iter_t it = ecs_rule_iter(world, rule);
-    test_bool(ecs_rule_next(&it), true);
+    ecs_iter_t it = ecs_query_iter(world, query);
+    test_bool(ecs_query_next(&it), true);
     test_int(it.count, 2);
     test_uint(it.entities[0], e1);
     test_uint(it.entities[1], e2);
 
-    ecs_iter_to_vars(&it, &vars, 0);
+    ecs_script_vars_from_iter(&it, vars, 0);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "this");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "this");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_uint(*(ecs_entity_t*)v->value.ptr, e1);
     }
 
-    ecs_iter_to_vars(&it, &vars, 1);
+    ecs_script_vars_from_iter(&it, vars, 1);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "this");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "this");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_uint(*(ecs_entity_t*)v->value.ptr, e2);
     }
 
-    test_bool(ecs_rule_next(&it), false);
+    test_bool(ecs_query_next(&it), false);
 
-    ecs_vars_fini(&vars);
-    ecs_rule_fini(rule);
+    ecs_script_vars_fini(vars);
+    ecs_query_fini(query);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_iter_to_vars_1_comp(void) {
+void Expr_iter_to_vars_1_comp(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
 
-    ecs_rule_t *rule = ecs_rule(world, { .expr = "Position" });
-    test_assert(rule != NULL);
+    ecs_query_t *query = ecs_query(world, { .expr = "PositionI" });
+    test_assert(query != NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, PositionI);
+    ecs_entity_t e2 = ecs_new_w(world, PositionI);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_iter_t it = ecs_rule_iter(world, rule);
-    test_bool(ecs_rule_next(&it), true);
+    ecs_iter_t it = ecs_query_iter(world, query);
+    test_bool(ecs_query_next(&it), true);
     test_int(it.count, 2);
     test_uint(it.entities[0], e1);
     test_uint(it.entities[1], e2);
 
-    ecs_iter_to_vars(&it, &vars, 0);
+    ecs_script_vars_from_iter(&it, vars, 0);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "this");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "this");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_uint(*(ecs_entity_t*)v->value.ptr, e1);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e1, Position));
+        test_assert(v->value.ptr == ecs_get(world, e1, PositionI));
     }
 
-    ecs_iter_to_vars(&it, &vars, 1);
+    ecs_script_vars_from_iter(&it, vars, 1);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "this");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "this");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_uint(*(ecs_entity_t*)v->value.ptr, e2);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e2, Position));
+        test_assert(v->value.ptr == ecs_get(world, e2, PositionI));
     }
 
-    test_bool(ecs_rule_next(&it), false);
+    test_bool(ecs_query_next(&it), false);
 
-    ecs_vars_fini(&vars);
-    ecs_rule_fini(rule);
+    ecs_script_vars_fini(vars);
+    ecs_query_fini(query);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_iter_to_vars_2_comps(void) {
+void Expr_iter_to_vars_2_comps(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
     ECS_COMPONENT(world, Velocity);
 
-    ecs_rule_t *rule = ecs_rule(world, { .expr = "Position, Velocity" });
-    test_assert(rule != NULL);
+    ecs_query_t *query = ecs_query(world, { .expr = "PositionI, Velocity" });
+    test_assert(query != NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, PositionI);
+    ecs_entity_t e2 = ecs_new_w(world, PositionI);
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_iter_t it = ecs_rule_iter(world, rule);
-    test_bool(ecs_rule_next(&it), true);
+    ecs_iter_t it = ecs_query_iter(world, query);
+    test_bool(ecs_query_next(&it), true);
     test_int(it.count, 2);
     test_uint(it.entities[0], e1);
     test_uint(it.entities[1], e2);
 
-    ecs_iter_to_vars(&it, &vars, 0);
+    ecs_script_vars_from_iter(&it, vars, 0);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "this");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "this");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_uint(*(ecs_entity_t*)v->value.ptr, e1);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e1, Position));
+        test_assert(v->value.ptr == ecs_get(world, e1, PositionI));
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "2");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "1");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(Velocity));
         test_assert(v->value.ptr != NULL);
         test_assert(v->value.ptr == ecs_get(world, e1, Velocity));
     }
 
-    ecs_iter_to_vars(&it, &vars, 1);
+    ecs_script_vars_from_iter(&it, vars, 1);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "this");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "this");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_uint(*(ecs_entity_t*)v->value.ptr, e2);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e2, Position));
+        test_assert(v->value.ptr == ecs_get(world, e2, PositionI));
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "2");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "1");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(Velocity));
         test_assert(v->value.ptr != NULL);
         test_assert(v->value.ptr == ecs_get(world, e2, Velocity));
     }
 
-    test_bool(ecs_rule_next(&it), false);
+    test_bool(ecs_query_next(&it), false);
 
-    ecs_vars_fini(&vars);
-    ecs_rule_fini(rule);
+    ecs_script_vars_fini(vars);
+    ecs_query_fini(query);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_iter_to_vars_1_comp_1_tag(void) {
+void Expr_iter_to_vars_1_comp_1_tag(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
     ECS_COMPONENT(world, Velocity);
     ECS_TAG(world, Foo);
 
-    ecs_rule_t *rule = ecs_rule(world, { .expr = "Position, Foo, Velocity" });
-    test_assert(rule != NULL);
+    ecs_query_t *query = ecs_query(world, { .expr = "PositionI, Foo, Velocity" });
+    test_assert(query != NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, PositionI);
+    ecs_entity_t e2 = ecs_new_w(world, PositionI);
     ecs_add(world, e1, Velocity);
     ecs_add(world, e2, Velocity);
     ecs_add(world, e1, Foo);
     ecs_add(world, e2, Foo);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_iter_t it = ecs_rule_iter(world, rule);
-    test_bool(ecs_rule_next(&it), true);
+    ecs_iter_t it = ecs_query_iter(world, query);
+    test_bool(ecs_query_next(&it), true);
     test_int(it.count, 2);
     test_uint(it.entities[0], e1);
     test_uint(it.entities[1], e2);
 
-    ecs_iter_to_vars(&it, &vars, 0);
+    ecs_script_vars_from_iter(&it, vars, 0);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "this");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "this");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_uint(*(ecs_entity_t*)v->value.ptr, e1);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e1, Position));
+        test_assert(v->value.ptr == ecs_get(world, e1, PositionI));
     }
-    test_assert(ecs_vars_lookup(&vars, "2") == NULL);
+    test_assert(ecs_script_vars_lookup(vars, "1") == NULL);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "3");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "2");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(Velocity));
         test_assert(v->value.ptr != NULL);
         test_assert(v->value.ptr == ecs_get(world, e1, Velocity));
     }
 
-    ecs_iter_to_vars(&it, &vars, 1);
+    ecs_script_vars_from_iter(&it, vars, 1);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "this");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "this");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_uint(*(ecs_entity_t*)v->value.ptr, e2);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e2, Position));
+        test_assert(v->value.ptr == ecs_get(world, e2, PositionI));
     }
-    test_assert(ecs_vars_lookup(&vars, "2") == NULL);
+    test_assert(ecs_script_vars_lookup(vars, "1") == NULL);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "3");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "2");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(Velocity));
         test_assert(v->value.ptr != NULL);
         test_assert(v->value.ptr == ecs_get(world, e2, Velocity));
     }
 
-    test_bool(ecs_rule_next(&it), false);
+    test_bool(ecs_query_next(&it), false);
 
-    ecs_vars_fini(&vars);
-    ecs_rule_fini(rule);
+    ecs_script_vars_fini(vars);
+    ecs_query_fini(query);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_iter_to_vars_w_1_query_var(void) {
+void Expr_iter_to_vars_w_1_query_var(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
 
-    ecs_rule_t *rule = ecs_rule(world, { .expr = "Position($x)" });
-    test_assert(rule != NULL);
+    ecs_query_t *query = ecs_query(world, { .expr = "PositionI($x)" });
+    test_assert(query != NULL);
 
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t e1 = ecs_new_w(world, PositionI);
+    ecs_entity_t e2 = ecs_new_w(world, PositionI);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_iter_t it = ecs_rule_iter(world, rule);
-    test_bool(ecs_rule_next(&it), true);
+    ecs_iter_t it = ecs_query_iter(world, query);
+    test_bool(ecs_query_next(&it), true);
     test_int(it.count, 0);
 
-    ecs_iter_to_vars(&it, &vars, 0);
-    test_assert(ecs_vars_lookup(&vars, "this") == NULL);
+    ecs_script_vars_from_iter(&it, vars, 0);
+    test_assert(ecs_script_vars_lookup(vars, "this") == NULL);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "x");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "x");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_assert(*(ecs_entity_t*)v->value.ptr == e1);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e1, Position));
+        test_assert(v->value.ptr == ecs_get(world, e1, PositionI));
     }
 
-    test_bool(ecs_rule_next(&it), true);
+    test_bool(ecs_query_next(&it), true);
     test_int(it.count, 0);
 
-    ecs_iter_to_vars(&it, &vars, 0);
-    test_assert(ecs_vars_lookup(&vars, "this") == NULL);
+    ecs_script_vars_from_iter(&it, vars, 0);
+    test_assert(ecs_script_vars_lookup(vars, "this") == NULL);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "x");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "x");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_assert(*(ecs_entity_t*)v->value.ptr == e2);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e2, Position));
+        test_assert(v->value.ptr == ecs_get(world, e2, PositionI));
     }
 
-    test_bool(ecs_rule_next(&it), false);
+    test_bool(ecs_query_next(&it), false);
 
-    ecs_vars_fini(&vars);
-    ecs_rule_fini(rule);
+    ecs_script_vars_fini(vars);
+    ecs_query_fini(query);
 
     ecs_fini(world);
 }
 
-void DeserExprOperators_iter_to_vars_w_2_query_vars(void) {
+void Expr_iter_to_vars_w_2_query_vars(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
 
-    ecs_rule_t *rule = ecs_rule(world, { .expr = "Position($x), ChildOf($x, $y)" });
-    test_assert(rule != NULL);
+    ecs_query_t *query = ecs_query(world, { .expr = "PositionI($x), ChildOf($x, $y)" });
+    test_assert(query != NULL);
 
-    ecs_entity_t parent = ecs_new_id(world);
-    ecs_entity_t e1 = ecs_new(world, Position);
-    ecs_entity_t e2 = ecs_new(world, Position);
+    ecs_entity_t parent = ecs_new(world);
+    ecs_entity_t e1 = ecs_new_w(world, PositionI);
+    ecs_entity_t e2 = ecs_new_w(world, PositionI);
     ecs_add_pair(world, e1, EcsChildOf, parent);
     ecs_add_pair(world, e2, EcsChildOf, parent);
 
-    ecs_vars_t vars = {0};
-    ecs_vars_init(world, &vars);
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
 
-    ecs_iter_t it = ecs_rule_iter(world, rule);
-    test_bool(ecs_rule_next(&it), true);
+    ecs_iter_t it = ecs_query_iter(world, query);
+    test_bool(ecs_query_next(&it), true);
     test_int(it.count, 0);
 
-    ecs_iter_to_vars(&it, &vars, 0);
-    test_assert(ecs_vars_lookup(&vars, "this") == NULL);
+    ecs_script_vars_from_iter(&it, vars, 0);
+    test_assert(ecs_script_vars_lookup(vars, "this") == NULL);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "x");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "x");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_assert(*(ecs_entity_t*)v->value.ptr == e1);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "y");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "y");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_assert(*(ecs_entity_t*)v->value.ptr == parent);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e1, Position));
+        test_assert(v->value.ptr == ecs_get(world, e1, PositionI));
     }
 
-    test_bool(ecs_rule_next(&it), true);
+    test_bool(ecs_query_next(&it), true);
     test_int(it.count, 0);
 
-    ecs_iter_to_vars(&it, &vars, 0);
-    test_assert(ecs_vars_lookup(&vars, "this") == NULL);
+    ecs_script_vars_from_iter(&it, vars, 0);
+    test_assert(ecs_script_vars_lookup(vars, "this") == NULL);
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "x");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "x");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_assert(*(ecs_entity_t*)v->value.ptr == e2);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "y");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "y");
         test_assert(v != NULL);
         test_assert(v->value.type == ecs_id(ecs_entity_t));
         test_assert(v->value.ptr != NULL);
         test_assert(*(ecs_entity_t*)v->value.ptr == parent);
     }
     {
-        ecs_expr_var_t *v = ecs_vars_lookup(&vars, "1");
+        ecs_script_var_t *v = ecs_script_vars_lookup(vars, "0");
         test_assert(v != NULL);
-        test_assert(v->value.type == ecs_id(Position));
+        test_assert(v->value.type == ecs_id(PositionI));
         test_assert(v->value.ptr != NULL);
-        test_assert(v->value.ptr == ecs_get(world, e2, Position));
+        test_assert(v->value.ptr == ecs_get(world, e2, PositionI));
     }
 
-    test_bool(ecs_rule_next(&it), false);
+    test_bool(ecs_query_next(&it), false);
 
-    ecs_vars_fini(&vars);
-    ecs_rule_fini(rule);
+    ecs_script_vars_fini(vars);
+    ecs_query_fini(query);
 
     ecs_fini(world);
 }
diff --git a/test/meta/src/SerializeToExpr.c b/test/script/src/Serialize.c
similarity index 90%
rename from test/meta/src/SerializeToExpr.c
rename to test/script/src/Serialize.c
index 46996391c..2f6abf6d9 100644
--- a/test/meta/src/SerializeToExpr.c
+++ b/test/script/src/Serialize.c
@@ -1,7 +1,7 @@
-#include <meta.h>
+#include <script.h>
 #include <math.h>
 
-void SerializeToExpr_bool(void) {
+void Serialize_bool(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -23,7 +23,7 @@ void SerializeToExpr_bool(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_byte(void) {
+void Serialize_byte(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -53,7 +53,7 @@ void SerializeToExpr_byte(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_char(void) {
+void Serialize_char(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -91,7 +91,7 @@ void SerializeToExpr_char(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_i8(void) {
+void Serialize_i8(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -121,7 +121,7 @@ void SerializeToExpr_i8(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_i16(void) {
+void Serialize_i16(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -151,7 +151,7 @@ void SerializeToExpr_i16(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_i32(void) {
+void Serialize_i32(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -181,7 +181,7 @@ void SerializeToExpr_i32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_i64(void) {
+void Serialize_i64(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -211,7 +211,7 @@ void SerializeToExpr_i64(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_iptr(void) {
+void Serialize_iptr(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -241,7 +241,7 @@ void SerializeToExpr_iptr(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_u8(void) {
+void Serialize_u8(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -263,7 +263,7 @@ void SerializeToExpr_u8(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_u16(void) {
+void Serialize_u16(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -285,7 +285,7 @@ void SerializeToExpr_u16(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_u32(void) {
+void Serialize_u32(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -307,7 +307,7 @@ void SerializeToExpr_u32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_u64(void) {
+void Serialize_u64(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -337,7 +337,7 @@ void SerializeToExpr_u64(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_uptr(void) {
+void Serialize_uptr(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -359,7 +359,7 @@ void SerializeToExpr_uptr(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_float(void) {
+void Serialize_float(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -389,7 +389,7 @@ void SerializeToExpr_float(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_double(void) {
+void Serialize_double(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -419,7 +419,7 @@ void SerializeToExpr_double(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_float_nan(void) {
+void Serialize_float_nan(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -433,7 +433,7 @@ void SerializeToExpr_float_nan(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_float_inf(void) {
+void Serialize_float_inf(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -455,7 +455,7 @@ void SerializeToExpr_float_inf(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_double_nan(void) {
+void Serialize_double_nan(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -469,7 +469,7 @@ void SerializeToExpr_double_nan(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_double_inf(void) {
+void Serialize_double_inf(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -491,7 +491,7 @@ void SerializeToExpr_double_inf(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_string(void) {
+void Serialize_string(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -529,7 +529,7 @@ void SerializeToExpr_string(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_entity(void) {
+void Serialize_entity(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -551,7 +551,7 @@ void SerializeToExpr_entity(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_entity_10k(void) {
+void Serialize_entity_10k(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -565,7 +565,7 @@ void SerializeToExpr_entity_10k(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_id(void) {
+void Serialize_id(void) {
     ecs_world_t *world = ecs_init();
 
     {
@@ -595,7 +595,7 @@ void SerializeToExpr_id(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_enum(void) {
+void Serialize_enum(void) {
     typedef enum {
         Red, Blue, Green
     } T;
@@ -644,7 +644,7 @@ void SerializeToExpr_enum(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_bitmask(void) {
+void Serialize_bitmask(void) {
     uint32_t Lettuce = 0x1;
     uint32_t Bacon =   0x1 << 1;
     uint32_t Tomato =  0x1 << 2;
@@ -710,7 +710,7 @@ void SerializeToExpr_bitmask(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_enum(void) {
+void Serialize_struct_enum(void) {
     typedef enum {
         Red, Blue, Green
     } E;
@@ -772,7 +772,7 @@ void SerializeToExpr_struct_enum(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_bitmask(void) {
+void Serialize_struct_bitmask(void) {
     typedef struct {
         uint32_t x;
     } T;
@@ -851,7 +851,7 @@ void SerializeToExpr_struct_bitmask(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_i32(void) {
+void Serialize_struct_i32(void) {
     typedef struct {
         int32_t x;
     } T;
@@ -874,7 +874,7 @@ void SerializeToExpr_struct_i32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_i32_i32(void) {
+void Serialize_struct_i32_i32(void) {
     typedef struct {
         int32_t x;
         int32_t y;
@@ -899,7 +899,7 @@ void SerializeToExpr_struct_i32_i32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_entity(void) {
+void Serialize_struct_entity(void) {
     typedef struct {
         ecs_entity_t e;
     } T;
@@ -922,7 +922,7 @@ void SerializeToExpr_struct_entity(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_id(void) {
+void Serialize_struct_id(void) {
     typedef struct {
         ecs_id_t e;
     } T;
@@ -945,7 +945,7 @@ void SerializeToExpr_struct_id(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_entity_entity_after_float(void) {
+void Serialize_entity_entity_after_float(void) {
     typedef struct {
         int32_t v;
         ecs_entity_t e;
@@ -970,7 +970,7 @@ void SerializeToExpr_entity_entity_after_float(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_nested_i32(void) {
+void Serialize_struct_nested_i32(void) {
     typedef struct {
         ecs_i32_t x;
     } N1;
@@ -1004,7 +1004,7 @@ void SerializeToExpr_struct_nested_i32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_nested_i32_i32(void) {
+void Serialize_struct_nested_i32_i32(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -1040,7 +1040,7 @@ void SerializeToExpr_struct_nested_i32_i32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_2_nested_i32_i32(void) {
+void Serialize_struct_2_nested_i32_i32(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -1078,7 +1078,7 @@ void SerializeToExpr_struct_2_nested_i32_i32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_i32_array_3(void) {
+void Serialize_struct_i32_array_3(void) {
     typedef struct {
         int32_t x[3];
     } T;
@@ -1101,7 +1101,7 @@ void SerializeToExpr_struct_i32_array_3(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_struct_i32_array_3(void) {
+void Serialize_struct_struct_i32_array_3(void) {
     typedef struct {
         ecs_i32_t x;
     } N1;
@@ -1135,7 +1135,7 @@ void SerializeToExpr_struct_struct_i32_array_3(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_struct_i32_i32_array_3(void) {
+void Serialize_struct_struct_i32_i32_array_3(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -1171,7 +1171,7 @@ void SerializeToExpr_struct_struct_i32_i32_array_3(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_w_array_type_i32_i32(void) {
+void Serialize_struct_w_array_type_i32_i32(void) {
     typedef int32_t N1[2];
 
     typedef struct {
@@ -1202,7 +1202,7 @@ void SerializeToExpr_struct_w_array_type_i32_i32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_w_2_array_type_i32_i32(void) {
+void Serialize_struct_w_2_array_type_i32_i32(void) {
     typedef int32_t N1[2];
 
     typedef struct {
@@ -1235,7 +1235,7 @@ void SerializeToExpr_struct_w_2_array_type_i32_i32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_w_array_type_struct(void) {
+void Serialize_struct_w_array_type_struct(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -1285,7 +1285,7 @@ void SerializeToExpr_struct_w_array_type_struct(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_w_2_array_type_struct(void) {
+void Serialize_struct_w_2_array_type_struct(void) {
     typedef struct {
         ecs_i32_t x;
         ecs_i32_t y;
@@ -1341,19 +1341,19 @@ void SerializeToExpr_struct_w_2_array_type_struct(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_struct_partial(void) {
+void Serialize_struct_partial(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
 
     ecs_entity_t t = ecs_struct_init(world, &(ecs_struct_desc_t){
-        .entity = ecs_id(Position),
+        .entity = ecs_id(PositionI),
         .members = {
-            {"y", ecs_id(ecs_i32_t), .offset = offsetof(Position, y)}
+            {"y", ecs_id(ecs_i32_t), .offset = offsetof(PositionI, y)}
         }
     });
 
-    Position value = {10, 20};
+    PositionI value = {10, 20};
     char *expr = ecs_ptr_to_expr(world, t, &value);
     test_assert(expr != NULL);
     test_str(expr, "{y: 20}");
@@ -1362,7 +1362,7 @@ void SerializeToExpr_struct_partial(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_array_i32_3(void) {
+void Serialize_array_i32_3(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t t = ecs_array_init(world, &(ecs_array_desc_t){
@@ -1379,13 +1379,13 @@ void SerializeToExpr_array_i32_3(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_array_struct_i32_i32(void) {
+void Serialize_array_struct_i32_i32(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
 
     ecs_struct_init(world, &(ecs_struct_desc_t){
-        .entity = ecs_id(Position),
+        .entity = ecs_id(PositionI),
         .members = {
             {"x", ecs_id(ecs_i32_t)},
             {"y", ecs_id(ecs_i32_t)}
@@ -1393,11 +1393,11 @@ void SerializeToExpr_array_struct_i32_i32(void) {
     });
 
     ecs_entity_t t = ecs_array_init(world, &(ecs_array_desc_t){
-        .type = ecs_id(Position),
+        .type = ecs_id(PositionI),
         .count = 3
     });
 
-    Position value[] = {{10, 20}, {30, 40}, {50, 60}};
+    PositionI value[] = {{10, 20}, {30, 40}, {50, 60}};
     char *expr = ecs_ptr_to_expr(world, t, value);
     test_assert(expr != NULL);
     test_str(expr, "[{x: 10, y: 20}, {x: 30, y: 40}, {x: 50, y: 60}]");
@@ -1406,7 +1406,7 @@ void SerializeToExpr_array_struct_i32_i32(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_array_array_i32_3(void) {
+void Serialize_array_array_i32_3(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t a = ecs_array_init(world, &(ecs_array_desc_t){
@@ -1430,7 +1430,7 @@ void SerializeToExpr_array_array_i32_3(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_vector_i32_3(void) {
+void Serialize_vector_i32_3(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t t = ecs_vector_init(world, &(ecs_vector_desc_t){
@@ -1453,13 +1453,13 @@ void SerializeToExpr_vector_i32_3(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_vector_struct_i32_i32(void) {
+void Serialize_vector_struct_i32_i32(void) {
     ecs_world_t *world = ecs_init();
 
-    ECS_COMPONENT(world, Position);
+    ECS_COMPONENT(world, PositionI);
 
     ecs_struct_init(world, &(ecs_struct_desc_t){
-        .entity = ecs_id(Position),
+        .entity = ecs_id(PositionI),
         .members = {
             {"x", ecs_id(ecs_i32_t)},
             {"y", ecs_id(ecs_i32_t)}
@@ -1467,26 +1467,26 @@ void SerializeToExpr_vector_struct_i32_i32(void) {
     });
 
     ecs_entity_t t = ecs_vector_init(world, &(ecs_vector_desc_t){
-        .type = ecs_id(Position)
+        .type = ecs_id(PositionI)
     });
 
     ecs_vec_t v;
-    ecs_vec_init_t(NULL, &v, Position, 3);
-    ecs_vec_append_t(NULL, &v, Position)[0] = (Position){10, 20};
-    ecs_vec_append_t(NULL, &v, Position)[0] = (Position){30, 40};
-    ecs_vec_append_t(NULL, &v, Position)[0] = (Position){50, 60};
+    ecs_vec_init_t(NULL, &v, PositionI, 3);
+    ecs_vec_append_t(NULL, &v, PositionI)[0] = (PositionI){10, 20};
+    ecs_vec_append_t(NULL, &v, PositionI)[0] = (PositionI){30, 40};
+    ecs_vec_append_t(NULL, &v, PositionI)[0] = (PositionI){50, 60};
 
     char *expr = ecs_ptr_to_expr(world, t, &v);
     test_assert(expr != NULL);
     test_str(expr, "[{x: 10, y: 20}, {x: 30, y: 40}, {x: 50, y: 60}]");
     ecs_os_free(expr);
 
-    ecs_vec_fini_t(NULL, &v, Position);
+    ecs_vec_fini_t(NULL, &v, PositionI);
 
     ecs_fini(world);
 }
 
-void SerializeToExpr_vector_array_i32_3(void) {
+void Serialize_vector_array_i32_3(void) {
     ecs_world_t *world = ecs_init();
 
     ecs_entity_t a = ecs_array_init(world, &(ecs_array_desc_t){
@@ -1528,60 +1528,60 @@ void SerializeToExpr_vector_array_i32_3(void) {
     ecs_fini(world);
 }
 
-void SerializeToExpr_escape_simple_string(void) {
+void Serialize_escape_simple_string(void) {
     ecs_world_t *world = ecs_init();
 
-    char *str = ecs_astresc('"', "Hello World");
+    char *str = flecs_astresc('"', "Hello World");
     test_str(str, "Hello World");
     ecs_os_free(str);
 
     ecs_fini(world);
 }
 
-void SerializeToExpr_escape_newline(void) {
+void Serialize_escape_newline(void) {
     ecs_world_t *world = ecs_init();
 
-    char *str = ecs_astresc('"', "\n");
+    char *str = flecs_astresc('"', "\n");
     test_str(str, "\\n");
     ecs_os_free(str);
 
     ecs_fini(world);
 }
 
-void SerializeToExpr_escape_2_newlines(void) {
+void Serialize_escape_2_newlines(void) {
     ecs_world_t *world = ecs_init();
 
-    char *str = ecs_astresc('"', "\n\n");
+    char *str = flecs_astresc('"', "\n\n");
     test_str(str, "\\n\\n");
     ecs_os_free(str);
 
     ecs_fini(world);
 }
 
-void SerializeToExpr_escape_string_w_trailing_newline(void) {
+void Serialize_escape_string_w_trailing_newline(void) {
     ecs_world_t *world = ecs_init();
 
-    char *str = ecs_astresc('"', "Hello World\n");
+    char *str = flecs_astresc('"', "Hello World\n");
     test_str(str, "Hello World\\n");
     ecs_os_free(str);
 
     ecs_fini(world);
 }
 
-void SerializeToExpr_escape_string_w_2_trailing_newlines(void) {
+void Serialize_escape_string_w_2_trailing_newlines(void) {
     ecs_world_t *world = ecs_init();
 
-    char *str = ecs_astresc('"', "Hello World\n\n");
+    char *str = flecs_astresc('"', "Hello World\n\n");
     test_str(str, "Hello World\\n\\n");
     ecs_os_free(str);
 
     ecs_fini(world);
 }
 
-void SerializeToExpr_escape_string_w_delim(void) {
+void Serialize_escape_string_w_delim(void) {
     ecs_world_t *world = ecs_init();
 
-    char *str = ecs_astresc('"', "\"Hello World\"");
+    char *str = flecs_astresc('"', "\"Hello World\"");
     test_str(str, "\\\"Hello World\\\"");
     ecs_os_free(str);
 
diff --git a/test/script/src/Vars.c b/test/script/src/Vars.c
new file mode 100644
index 000000000..a1e7c6934
--- /dev/null
+++ b/test/script/src/Vars.c
@@ -0,0 +1,364 @@
+#include <script.h>
+
+void Vars_declare_1_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *v = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
+    test_assert(v != NULL);
+    test_assert(v->value.ptr != NULL);
+    test_assert(v->value.type != 0);
+    test_uint(v->value.type, ecs_id(ecs_i32_t));
+    test_int(*(int32_t*)v->value.ptr, 0);
+
+    const ecs_script_var_t *v2 = ecs_script_vars_lookup(vars, "foo");
+    test_assert(v2 != NULL);
+    test_assert(v == v2);
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_declare_2_vars(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
+    test_assert(foo != NULL);
+    test_assert(foo->value.ptr != NULL);
+    test_assert(foo->value.type != 0);
+    test_uint(foo->value.type, ecs_id(ecs_i32_t));
+    test_int(*(int32_t*)foo->value.ptr, 0);
+
+    ecs_script_var_t *bar = ecs_script_vars_define(
+        vars, "bar", ecs_u32_t);
+    test_assert(bar != NULL);
+    test_assert(bar->value.ptr != NULL);
+    test_assert(bar->value.type != 0);
+    test_uint(bar->value.type, ecs_id(ecs_u32_t));
+    test_uint(*(ecs_u32_t*)bar->value.ptr, 0);
+
+    test_assert(foo == ecs_script_vars_lookup(vars, "foo"));
+    test_assert(bar == ecs_script_vars_lookup(vars, "bar"));
+    test_assert(foo != bar);
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_declare_vars_nested_scope(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+    ecs_script_vars_t *root_vars = vars;
+
+    vars = ecs_script_vars_push(vars);
+
+    ecs_script_var_t *foo = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
+    test_assert(foo != NULL);
+    test_assert(foo->value.ptr != NULL);
+    test_assert(foo->value.type != 0);
+    test_uint(foo->value.type, ecs_id(ecs_i32_t));
+    test_int(*(int32_t*)foo->value.ptr, 0);
+    test_assert(foo == ecs_script_vars_lookup(vars, "foo"));
+
+    vars = ecs_script_vars_pop(vars);
+    test_assert(vars != NULL);
+    test_assert(vars == root_vars);
+
+    test_assert(NULL == ecs_script_vars_lookup(vars, "foo"));
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_declare_vars_2_scopes(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
+    test_assert(foo != NULL);
+    test_assert(foo->value.ptr != NULL);
+    test_assert(foo->value.type != 0);
+    test_uint(foo->value.type, ecs_id(ecs_i32_t));
+    test_int(*(int32_t*)foo->value.ptr, 0);
+    test_assert(foo == ecs_script_vars_lookup(vars, "foo"));
+
+    vars = ecs_script_vars_push(vars);
+
+    ecs_script_var_t *bar = ecs_script_vars_define(
+        vars, "bar", ecs_u32_t);
+    test_assert(bar != NULL);
+    test_assert(bar->value.ptr != NULL);
+    test_assert(bar->value.type != 0);
+    test_uint(bar->value.type, ecs_id(ecs_u32_t));
+    test_uint(*(ecs_u32_t*)bar->value.ptr, 0);
+
+    test_assert(foo == ecs_script_vars_lookup(vars, "foo"));
+    test_assert(bar == ecs_script_vars_lookup(vars, "bar"));
+    test_assert(foo != bar);
+
+    vars = ecs_script_vars_pop(vars);
+
+    test_assert(foo == ecs_script_vars_lookup(vars, "foo"));
+    test_assert(NULL == ecs_script_vars_lookup(vars, "bar"));
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_redeclare_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
+    test_assert(foo != NULL);
+    test_assert(foo->value.ptr != NULL);
+    test_assert(foo->value.type != 0);
+    test_uint(foo->value.type, ecs_id(ecs_i32_t));
+    test_int(*(int32_t*)foo->value.ptr, 0);
+    test_assert(foo == ecs_script_vars_lookup(vars, "foo"));
+
+    ecs_log_set_level(-4);
+    ecs_script_var_t *foo_2 = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
+    test_assert(foo_2 == NULL);
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_i32_expr_w_i32_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define(
+        vars, "foo", ecs_i32_t);
+    *(int32_t*)foo->value.ptr = 10;
+
+    int32_t v = 0;
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(
+        world, "$foo", &ecs_value_ptr(ecs_i32_t, &v), &desc);
+    test_assert(ptr != NULL);
+    test_assert(ptr[0] == 0);
+    test_int(v, 10);
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_i32_expr_w_f32_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define(
+        vars, "foo", ecs_f32_t);
+    *(float*)foo->value.ptr = 10.5;
+
+    int32_t v = 0;
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(
+        world, "$foo", &ecs_value_ptr(ecs_i32_t, &v), &desc);
+    test_assert(ptr != NULL);
+    test_assert(ptr[0] == 0);
+    test_int(v, 10);
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_i32_expr_w_string_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define(vars, "foo", ecs_string_t);
+    *(char**)foo->value.ptr = "10";
+
+    int32_t v = 0;
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(
+        world, "$foo", &ecs_value_ptr(ecs_i32_t, &v), &desc);
+    test_assert(ptr != NULL);
+    test_assert(ptr[0] == 0);
+    test_int(v, 10);
+
+    *(char**)foo->value.ptr = NULL;
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_string_expr_w_string_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define(vars, "foo", ecs_string_t);
+    *(char**)foo->value.ptr = "Hello World";
+
+    char* v = NULL;
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(
+        world, "$foo", &ecs_value_ptr(ecs_string_t, &v), &desc);
+    test_assert(ptr != NULL);
+    test_assert(ptr[0] == 0);
+    test_str(v, "Hello World");
+    
+    ecs_os_free(v);
+
+    *(char**)foo->value.ptr = NULL;
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_struct_expr_w_i32_vars(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_entity_t point = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .members = {
+            {"x", ecs_id(ecs_i32_t)},
+            {"y", ecs_id(ecs_i32_t)}
+        }
+    });
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define(vars, "foo", ecs_i32_t);
+    *(int32_t*)foo->value.ptr = 10;
+    ecs_script_var_t *bar = ecs_script_vars_define(vars, "bar", ecs_i32_t);
+    *(int32_t*)bar->value.ptr = 20;
+
+    PositionI v = {0};
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(world, "{$foo, $bar}", &(ecs_value_t){point, &v}, &desc);
+    test_assert(ptr != NULL);
+    test_assert(ptr[0] == 0);
+
+    test_int(v.x, 10);
+    test_int(v.y, 20);
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_struct_expr_w_struct_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_entity_t point = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .members = {
+            {"x", ecs_id(ecs_i32_t)},
+            {"y", ecs_id(ecs_i32_t)}
+        }
+    });
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define_id(vars, "foo", point);
+    *(PositionI*)foo->value.ptr = (PositionI){10, 20};
+
+    PositionI v = {0};
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(world, "$foo", &(ecs_value_t){point, &v}, &desc);
+    test_assert(ptr != NULL);
+    test_assert(ptr[0] == 0);
+
+    test_int(v.x, 10);
+    test_int(v.y, 20);
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_nested_struct_expr_w_struct_var(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_entity_t point = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .members = {
+            {"x", ecs_id(ecs_i32_t)},
+            {"y", ecs_id(ecs_i32_t)}
+        }
+    });
+
+    ecs_entity_t line = ecs_struct_init(world, &(ecs_struct_desc_t){
+        .members = {
+            {"start", point},
+            {"stop", point}
+        }
+    });
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *foo = ecs_script_vars_define_id(vars, "foo", point);
+    *(PositionI*)foo->value.ptr = (PositionI){10, 20};
+    ecs_script_var_t *bar = ecs_script_vars_define_id(vars, "bar", point);
+    *(PositionI*)bar->value.ptr = (PositionI){30, 40};
+
+    LineI v = {0};
+    ecs_script_expr_run_desc_t desc = { .vars = vars };
+    const char *ptr = ecs_script_expr_run(world, 
+        "{start: $foo, stop: $bar}", &(ecs_value_t){line, &v}, &desc);
+    test_assert(ptr != NULL);
+    test_assert(ptr[0] == 0);
+
+    test_int(v.start.x, 10);
+    test_int(v.start.y, 20);
+    test_int(v.stop.x, 30);
+    test_int(v.stop.y, 40);
+
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_redeclare_in_scope(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_var_t *v1 = ecs_script_vars_define(vars, "foo", ecs_i32_t);
+    test_assert(v1 != NULL);
+    vars = ecs_script_vars_push(vars);
+    ecs_script_var_t *v2 = ecs_script_vars_define(vars, "foo", ecs_i32_t);
+    test_assert(v2 != NULL);
+    test_assert(v1 != v2);
+    test_assert(ecs_script_vars_lookup(vars, "foo") == v2);
+    vars = ecs_script_vars_pop(vars);
+    test_assert(ecs_script_vars_lookup(vars, "foo") == v1);
+    ecs_script_vars_fini(vars);
+
+    ecs_fini(world);
+}
+
+void Vars_init_fini_vars(void) {
+    ecs_world_t *world = ecs_init();
+
+    ecs_script_vars_t *vars = ecs_script_vars_init(world);
+
+    ecs_script_vars_fini(vars);
+    ecs_fini(world);
+
+    test_assert(true);
+}
diff --git a/test/script/src/main.c b/test/script/src/main.c
new file mode 100644
index 000000000..e0bcb4cc2
--- /dev/null
+++ b/test/script/src/main.c
@@ -0,0 +1,2789 @@
+
+/* A friendly warning from bake.test
+ * ----------------------------------------------------------------------------
+ * This file is generated. To add/remove testcases modify the 'project.json' of
+ * the test project. ANY CHANGE TO THIS FILE IS LOST AFTER (RE)BUILDING!
+ * ----------------------------------------------------------------------------
+ */
+
+#include <script.h>
+
+// Testsuite 'Eval'
+void Eval_null(void);
+void Eval_empty(void);
+void Eval_space(void);
+void Eval_space_newline(void);
+void Eval_two_empty_newlines(void);
+void Eval_three_empty_newlines(void);
+void Eval_newline_trailing_space(void);
+void Eval_newline_trailing_spaces(void);
+void Eval_multiple_trailing_newlines(void);
+void Eval_entity(void);
+void Eval_entity_w_core_name(void);
+void Eval_2_entities(void);
+void Eval_line_comment(void);
+void Eval_line_comment_before_stmt(void);
+void Eval_line_comment_after_stmt(void);
+void Eval_line_comment_between_stmt(void);
+void Eval_multiple_line_comment(void);
+void Eval_multiple_line_comment_w_newlines(void);
+void Eval_line_comment_after_stmt_same_line(void);
+void Eval_line_comment_before_scope_open(void);
+void Eval_line_comment_after_newline_before_scope_open(void);
+void Eval_line_comment_after_newline_before_newline_scope_open(void);
+void Eval_multi_line_comment(void);
+void Eval_multi_line_comment_before_stmt(void);
+void Eval_multi_line_comment_after_stmt(void);
+void Eval_multi_line_comment_between_stmt(void);
+void Eval_multiple_multi_line_comment(void);
+void Eval_multiple_multi_line_comment_w_newlines(void);
+void Eval_multi_line_comment_after_stmt_same_line(void);
+void Eval_multi_line_comment_before_scope_open(void);
+void Eval_multi_line_comment_after_newline_before_scope_open(void);
+void Eval_multi_line_comment_after_newline_before_newline_scope_open(void);
+void Eval_multi_line_comment_multiple_lines(void);
+void Eval_hierarchy_1_child(void);
+void Eval_hierarchy_2_children(void);
+void Eval_hierarchy_1_child_same_line(void);
+void Eval_hierarchy_2_children_same_line(void);
+void Eval_hierarchy_2_children_same_line_no_trailing_comma(void);
+void Eval_entity_after_hierarchy(void);
+void Eval_newline_before_scope_open(void);
+void Eval_newline_w_whitespace_before_scope_open(void);
+void Eval_2_newline_before_scope_open(void);
+void Eval_2_newline_w_whitespace_before_scope_open(void);
+void Eval_hierarchy_2_levels(void);
+void Eval_hierarchy_2_levels_2_subtrees(void);
+void Eval_missing_end_of_scope(void);
+void Eval_create_in_scope(void);
+void Eval_hierarchy_w_pred_subj(void);
+void Eval_hierarchy_custom_relation(void);
+void Eval_hierarchy_custom_relation_2_levels(void);
+void Eval_hierarchy_custom_relation_apply_to_object(void);
+void Eval_hierarchy_custom_relation_apply_to_object_2_levels(void);
+void Eval_entity_after_hierarchy_custom_relation(void);
+void Eval_entity_after_hierarchy_custom_relation_2_levels(void);
+void Eval_with_tag(void);
+void Eval_with_tag_2_entities(void);
+void Eval_with_tag_same_line(void);
+void Eval_with_tag_2_entities_same_line(void);
+void Eval_with_tag_2_entities_same_line_no_trailing_comma(void);
+void Eval_with_tag_2_levels(void);
+void Eval_with_tag_2_levels_2_subtrees(void);
+void Eval_with_n_tags(void);
+void Eval_with_n_tags_2_levels(void);
+void Eval_with_n_tags_2_levels_invalid_tag(void);
+void Eval_with_after_scope(void);
+void Eval_with_after_with(void);
+void Eval_scope_inside_with_inside_scope(void);
+void Eval_with_inside_scope(void);
+void Eval_with_tag_core_name(void);
+void Eval_inherit(void);
+void Eval_inherit_newline(void);
+void Eval_inherit_w_colon(void);
+void Eval_inherit_w_colon_w_scope(void);
+void Eval_assign_component_w_value(void);
+void Eval_assign_tag_in_assign_scope(void);
+void Eval_assign_tag_in_assign_scope_same_line(void);
+void Eval_assign_tag_in_assign_scope_core_name(void);
+void Eval_assign_component_value_in_assign_scope(void);
+void Eval_assign_2_component_values_in_assign_scope(void);
+void Eval_type_and_assign_in_plecs(void);
+void Eval_type_and_assign_in_plecs_w_2_members(void);
+void Eval_type_and_assign_in_plecs_w_3_members(void);
+void Eval_type_and_assign_in_plecs_w_enum(void);
+void Eval_type_and_assign_in_plecs_w_enum_using_meta(void);
+void Eval_type_and_assign_in_plecs_w_enum_primitive_using_meta(void);
+void Eval_type_and_assign_in_plecs_w_enum_primitive_and_struct(void);
+void Eval_type_and_assign_in_plecs_nested_member(void);
+void Eval_dot_assign_nested_member(void);
+void Eval_dot_assign_binary_expr(void);
+void Eval_open_scope_no_parent(void);
+void Eval_create_subject_in_root_scope_w_resolvable_id(void);
+void Eval_create_subject_in_scope_w_resolvable_id(void);
+void Eval_create_subject_in_scope_w_resolvable_id_using(void);
+void Eval_using_scope(void);
+void Eval_using_nested_scope(void);
+void Eval_using_nested_in_scope(void);
+void Eval_using_with_scope(void);
+void Eval_using_w_entity_ref_in_value_2_members(void);
+void Eval_using_w_entity_ref_in_value_3_members(void);
+void Eval_2_using_scope(void);
+void Eval_2_using_in_different_scope(void);
+void Eval_empty_scope_after_using(void);
+void Eval_assignment_to_non_component(void);
+void Eval_struct_w_member_w_assignment_to_nothing(void);
+void Eval_struct_w_member_w_assignment_to_empty_scope(void);
+void Eval_scope_after_assign(void);
+void Eval_assign_after_inherit(void);
+void Eval_multiple_tags_single_line(void);
+void Eval_multiple_pairs_single_line(void);
+void Eval_multiple_vars_single_line(void);
+void Eval_multiple_assignments_single_line(void);
+void Eval_2_stmts_in_scope_w_no_parent(void);
+void Eval_invalid_nested_assignment(void);
+void Eval_invalid_partial_pair_assignment(void);
+void Eval_empty_assignment(void);
+void Eval_assign_tag_to_parent(void);
+void Eval_assign_component_to_parent(void);
+void Eval_empty_assignment_before_end_of_scope(void);
+void Eval_assign_to_parent_pair_w_new_entities_in_scope(void);
+void Eval_assign_to_parent_pair_w_existing_entities_in_scope(void);
+void Eval_default_child_component(void);
+void Eval_default_child_component_w_assign(void);
+void Eval_struct_type_w_default_child_component(void);
+void Eval_struct_type_w_default_child_component_nested_member(void);
+void Eval_enum_type_w_default_child_component(void);
+void Eval_default_type_from_with(void);
+void Eval_default_type_from_nested_with(void);
+void Eval_default_type_with_tag(void);
+void Eval_default_type_from_with_in_entity_scope_w_default_type(void);
+void Eval_default_type_from_entity_scope_in_with(void);
+void Eval_scope_w_1_subj_and_2_pairs(void);
+void Eval_inherit_from_multiple(void);
+void Eval_assign_pair_component(void);
+void Eval_assign_pair_component_in_scope(void);
+void Eval_assign_pair_component_in_script(void);
+void Eval_assign_pair_component_in_script_update(void);
+void Eval_set_entity_names(void);
+void Eval_oneof(void);
+void Eval_invalid_oneof(void);
+void Eval_brief_annotation(void);
+void Eval_name_annotation(void);
+void Eval_link_annotation(void);
+void Eval_color_annotation(void);
+void Eval_multiple_annotations(void);
+void Eval_annotation_w_trailing_space(void);
+void Eval_multiline_string(void);
+void Eval_unterminated_multiline_string(void);
+void Eval_declaration_w_underscore_name(void);
+void Eval_annotate_declaration(void);
+void Eval_anonymous_entity(void);
+void Eval_anonymous_entity_in_scope(void);
+void Eval_anonymous_declaration(void);
+void Eval_const_var_int(void);
+void Eval_const_var_float(void);
+void Eval_const_var_bool(void);
+void Eval_const_var_string(void);
+void Eval_const_var_struct(void);
+void Eval_const_var_redeclare(void);
+void Eval_const_var_scoped(void);
+void Eval_assign_component_from_var(void);
+void Eval_assign_component_from_var_in_scope(void);
+void Eval_scope_w_component_after_const_var(void);
+void Eval_component_after_const_paren_expr(void);
+void Eval_component_after_const_add_expr(void);
+void Eval_component_after_const_sub_expr(void);
+void Eval_component_after_const_mul_expr(void);
+void Eval_component_after_const_div_expr(void);
+void Eval_parse_with(void);
+void Eval_parse_with_w_with(void);
+void Eval_parse_with_w_tag(void);
+void Eval_parse_with_value(void);
+void Eval_parse_with_2_values(void);
+void Eval_parse_with_2_nested_values(void);
+void Eval_parse_with_var(void);
+void Eval_parse_with_2_vars(void);
+void Eval_parse_with_2_nested_vars(void);
+void Eval_parse_with_var_in_scope(void);
+void Eval_assign_const_w_expr(void);
+void Eval_const_w_type(void);
+void Eval_typed_const_w_composite_type_invalid_assignment(void);
+void Eval_typed_const_w_composite_type(void);
+void Eval_assign_var_to_typed_const_w_composite_type(void);
+void Eval_typed_const_w_composite_type_invalid_assignment(void);
+void Eval_using_wildcard(void);
+void Eval_single_line_comment_in_value(void);
+void Eval_single_line_comment_in_value_after_scope(void);
+void Eval_multi_line_comment_in_value(void);
+void Eval_multi_line_comment_in_value_after_scope(void);
+void Eval_unterminated_multi_line_comment_in_value(void);
+void Eval_module_stmt(void);
+void Eval_nested_module_stmt(void);
+void Eval_module_stmt_w_scope(void);
+void Eval_module_stmt_w_nested_scope(void);
+void Eval_assign_singleton_tag(void);
+void Eval_assign_singleton_component(void);
+void Eval_assign_singleton_tag_w_scope(void);
+void Eval_assign_singleton_2_tags_w_scope(void);
+void Eval_assign_singleton_component_w_scope(void);
+void Eval_assign_singleton_2_components_w_scope(void);
+void Eval_with_pair_in_scope(void);
+void Eval_with_pair_component_in_scope(void);
+void Eval_pair_w_rel_var(void);
+void Eval_pair_w_tgt_var(void);
+void Eval_pair_w_rel_var_invalid_type(void);
+void Eval_pair_w_tgt_var_invalid_type(void);
+void Eval_with_value_not_a_component(void);
+void Eval_component_in_with_scope(void);
+void Eval_component_in_with_scope_nested(void);
+void Eval_component_in_with_scope_in_scope(void);
+void Eval_assign_after_with_in_scope(void);
+void Eval_array_component(void);
+void Eval_not_an_array_component(void);
+void Eval_array_component_w_curly_brackets(void);
+void Eval_unknown_identifier(void);
+void Eval_unknown_identifier_for_int_field(void);
+void Eval_on_set_w_kind_paren_no_reflection(void);
+void Eval_on_set_w_kind_paren(void);
+void Eval_on_set_w_kind_no_paren_no_reflection(void);
+void Eval_on_set_w_kind_no_paren(void);
+void Eval_on_set_w_single_assign(void);
+void Eval_on_set_w_single_assign_scoped_w_value(void);
+void Eval_on_set_w_single_assign_scoped_no_value(void);
+void Eval_if_true(void);
+void Eval_if_true_no_else(void);
+void Eval_if_false(void);
+void Eval_if_true_var(void);
+void Eval_if_false_var(void);
+void Eval_if_10(void);
+void Eval_if_0(void);
+void Eval_if_true_in_scope(void);
+void Eval_if_false_in_scope(void);
+
+// Testsuite 'Assembly'
+void Assembly_assembly_no_scope(void);
+void Assembly_assembly_empty(void);
+void Assembly_assembly_unresolved_tag(void);
+void Assembly_assembly_unresolved_component(void);
+void Assembly_assembly_unresolved_pair_relationship(void);
+void Assembly_assembly_unresolved_pair_target(void);
+void Assembly_assembly_unresolved_with_tag(void);
+void Assembly_assembly_unresolved_with_component(void);
+void Assembly_assembly_unresolved_with_pair_relationship(void);
+void Assembly_assembly_unresolved_with_pair_target(void);
+void Assembly_assembly_no_props(void);
+void Assembly_assembly_prop_no_type(void);
+void Assembly_assembly_prop_no_default(void);
+void Assembly_assembly_prop(void);
+void Assembly_assembly_prop_space_colon(void);
+void Assembly_assembly_2_props(void);
+void Assembly_assembly_w_using(void);
+void Assembly_assembly_instance_w_default_values(void);
+void Assembly_assembly_instance_w_assign_default_values(void);
+void Assembly_assembly_instance_w_overridden_values(void);
+void Assembly_assembly_w_child(void);
+void Assembly_assembly_w_child_parse_script(void);
+void Assembly_assembly_w_child_parse_script_twice(void);
+void Assembly_assembly_w_child_update_after_parse(void);
+void Assembly_assembly_w_nested_child(void);
+void Assembly_assembly_w_prefab(void);
+void Assembly_assembly_w_prefab_tree(void);
+void Assembly_assembly_w_nested_assembly(void);
+void Assembly_instantiate_prefab_w_assembly(void);
+void Assembly_assembly_w_prefab_w_assembly(void);
+void Assembly_3_assemblies(void);
+void Assembly_assembly_nested_w_default_var(void);
+void Assembly_assembly_w_anonymous(void);
+void Assembly_assembly_w_anonymous_parse_again(void);
+void Assembly_assembly_redeclare_prop_as_const(void);
+void Assembly_assembly_redeclare_prop_as_prop(void);
+void Assembly_assembly_redeclare_const_as_const(void);
+void Assembly_assembly_w_composite_prop_invalid_assignment(void);
+void Assembly_assembly_w_composite_prop(void);
+void Assembly_assembly_with_with(void);
+void Assembly_module_w_assembly(void);
+void Assembly_module_w_nested_assembly(void);
+void Assembly_assembly_w_pair_w_this_var(void);
+void Assembly_run_assembly_after_error(void);
+void Assembly_update_assembly_after_error(void);
+
+// Testsuite 'Expr'
+void Expr_add_2_int_literals(void);
+void Expr_add_2_int_literals_twice(void);
+void Expr_sub_2_int_literals(void);
+void Expr_mul_2_int_literals(void);
+void Expr_div_2_int_literals(void);
+void Expr_add_3_int_literals(void);
+void Expr_add_3_int_literals_twice(void);
+void Expr_sub_3_int_literals(void);
+void Expr_mul_3_int_literals(void);
+void Expr_div_3_int_literals(void);
+void Expr_int_to_bool(void);
+void Expr_bool_to_int(void);
+void Expr_bool_to_uint(void);
+void Expr_add_mul_3_int_literals(void);
+void Expr_sub_mul_3_int_literals(void);
+void Expr_div_mul_3_int_literals(void);
+void Expr_add_div_3_int_literals(void);
+void Expr_sub_div_3_int_literals(void);
+void Expr_mul_div_3_int_literals(void);
+void Expr_mul_add_mul_add_int_literals(void);
+void Expr_mul_sub_mul_sub_int_literals(void);
+void Expr_mul_div_mul_div_int_literals(void);
+void Expr_div_add_div_add_int_literals(void);
+void Expr_div_sub_div_sub_int_literals(void);
+void Expr_div_sub_div_mul_int_literals(void);
+void Expr_div_mul_div_mul_int_literals(void);
+void Expr_add_2_flt_literals(void);
+void Expr_sub_2_flt_literals(void);
+void Expr_mul_2_flt_literals(void);
+void Expr_div_2_flt_literals(void);
+void Expr_add_2_int_neg_literals(void);
+void Expr_sub_2_int_neg_literals(void);
+void Expr_mul_2_int_neg_literals(void);
+void Expr_div_2_int_neg_literals(void);
+void Expr_mul_lparen_add_add_rparen_int_literals(void);
+void Expr_mul_lparen_add_add_add_rparen_int_literals(void);
+void Expr_mul_lparen_add_add_rparen_add_int_literals(void);
+void Expr_lparen_add_add_rparen_mul_int_literals(void);
+void Expr_lparen_add_add_add_rparen_mul_int_literals(void);
+void Expr_double_paren_add_add(void);
+void Expr_double_paren_literal(void);
+void Expr_lparen_add_add_rparen_mul_lparen_add_add_rparen(void);
+void Expr_float_result_add_2_int_literals(void);
+void Expr_struct_result_add_2_int_literals(void);
+void Expr_struct_result_add_2_2_fields_int_literals(void);
+void Expr_struct_result_add_3_int_literals(void);
+void Expr_struct_result_lparen_int_rparen(void);
+void Expr_add_to_var(void);
+void Expr_add_var_to(void);
+void Expr_var_member(void);
+void Expr_bool_cond_and_bool(void);
+void Expr_bool_cond_or_bool(void);
+void Expr_int_cond_and_int(void);
+void Expr_int_cond_or_int(void);
+void Expr_bool_cond_and_int(void);
+void Expr_int_cond_and_bool(void);
+void Expr_bool_cond_or_int(void);
+void Expr_int_cond_or_bool(void);
+void Expr_cond_eq_bool(void);
+void Expr_cond_eq_int(void);
+void Expr_cond_neq_bool(void);
+void Expr_cond_neq_int(void);
+void Expr_cond_eq_bool_int(void);
+void Expr_cond_eq_int_flt(void);
+void Expr_cond_eq_cond_and(void);
+void Expr_cond_eq_cond_or(void);
+void Expr_cond_gt_bool(void);
+void Expr_cond_gt_int(void);
+void Expr_cond_gt_flt(void);
+void Expr_cond_gteq_bool(void);
+void Expr_cond_gteq_int(void);
+void Expr_cond_gteq_flt(void);
+void Expr_cond_lt_bool(void);
+void Expr_cond_lt_int(void);
+void Expr_cond_lt_flt(void);
+void Expr_cond_lteq_bool(void);
+void Expr_cond_lteq_int(void);
+void Expr_cond_lteq_flt(void);
+void Expr_min_lparen_int_rparen(void);
+void Expr_min_lparen_int_add_int_rparen(void);
+void Expr_min_var(void);
+void Expr_min_lparen_int_rparen_to_i64(void);
+void Expr_min_lparen_int_rparen_to_i32(void);
+void Expr_struct_w_min_var(void);
+void Expr_struct_w_min_lparen_int_rparen(void);
+void Expr_struct_w_min_lparen_var_rparen(void);
+void Expr_shift_left_int(void);
+void Expr_shift_right_int(void);
+void Expr_shift_left_int_add_int(void);
+void Expr_shift_left_int_mul_int(void);
+void Expr_add_int_shift_left_int(void);
+void Expr_mul_int_shift_left_int(void);
+void Expr_add_int_shift_left_int_add_int(void);
+void Expr_mul_int_shift_left_int_mul_int(void);
+void Expr_entity_expr(void);
+void Expr_entity_path_expr(void);
+void Expr_entity_parent_func(void);
+void Expr_entity_name_func(void);
+void Expr_entity_doc_name_func(void);
+void Expr_entity_chain_func(void);
+void Expr_var_parent_func(void);
+void Expr_var_name_func(void);
+void Expr_var_doc_name_func(void);
+void Expr_var_chain_func(void);
+void Expr_interpolate_string_w_i32_var(void);
+void Expr_interpolate_string_w_string_var(void);
+void Expr_interpolate_string_w_entity_var(void);
+void Expr_interpolate_string_w_id_var(void);
+void Expr_interpolate_string_w_var_not_found(void);
+void Expr_interpolate_string_w_entity_var_0(void);
+void Expr_interpolate_string_w_var_special_chars(void);
+void Expr_interpolate_string_w_var_before_after_text(void);
+void Expr_interpolate_string_w_curly_brackets_var(void);
+void Expr_interpolate_string_w_curly_brackets_expr(void);
+void Expr_interpolate_string_w_curly_brackets_expr_w_var(void);
+void Expr_interpolate_string_w_curly_brackets_expr_w_composite_var(void);
+void Expr_interpolate_string_w_escape_var_operator(void);
+void Expr_interpolate_string_w_escape_curly_brackets(void);
+void Expr_interpolate_string_w_func(void);
+void Expr_interpolate_string_w_func_chain(void);
+void Expr_iter_to_vars_no_data(void);
+void Expr_iter_to_vars_1_comp(void);
+void Expr_iter_to_vars_2_comps(void);
+void Expr_iter_to_vars_1_comp_1_tag(void);
+void Expr_iter_to_vars_w_1_query_var(void);
+void Expr_iter_to_vars_w_2_query_vars(void);
+
+// Testsuite 'Vars'
+void Vars_declare_1_var(void);
+void Vars_declare_2_vars(void);
+void Vars_declare_vars_nested_scope(void);
+void Vars_declare_vars_2_scopes(void);
+void Vars_redeclare_var(void);
+void Vars_i32_expr_w_i32_var(void);
+void Vars_i32_expr_w_f32_var(void);
+void Vars_i32_expr_w_string_var(void);
+void Vars_string_expr_w_string_var(void);
+void Vars_struct_expr_w_i32_vars(void);
+void Vars_struct_expr_w_struct_var(void);
+void Vars_nested_struct_expr_w_struct_var(void);
+void Vars_redeclare_in_scope(void);
+void Vars_init_fini_vars(void);
+
+// Testsuite 'Serialize'
+void Serialize_bool(void);
+void Serialize_byte(void);
+void Serialize_char(void);
+void Serialize_i8(void);
+void Serialize_i16(void);
+void Serialize_i32(void);
+void Serialize_i64(void);
+void Serialize_iptr(void);
+void Serialize_u8(void);
+void Serialize_u16(void);
+void Serialize_u32(void);
+void Serialize_u64(void);
+void Serialize_uptr(void);
+void Serialize_float(void);
+void Serialize_double(void);
+void Serialize_string(void);
+void Serialize_entity(void);
+void Serialize_entity_10k(void);
+void Serialize_id(void);
+void Serialize_enum(void);
+void Serialize_bitmask(void);
+void Serialize_float_nan(void);
+void Serialize_float_inf(void);
+void Serialize_double_nan(void);
+void Serialize_double_inf(void);
+void Serialize_struct_enum(void);
+void Serialize_struct_bitmask(void);
+void Serialize_struct_i32(void);
+void Serialize_struct_i32_i32(void);
+void Serialize_struct_entity(void);
+void Serialize_struct_id(void);
+void Serialize_array_i32_3(void);
+void Serialize_array_struct_i32_i32(void);
+void Serialize_array_array_i32_3(void);
+void Serialize_vector_i32_3(void);
+void Serialize_vector_struct_i32_i32(void);
+void Serialize_vector_array_i32_3(void);
+void Serialize_entity_entity_after_float(void);
+void Serialize_struct_nested_i32(void);
+void Serialize_struct_nested_i32_i32(void);
+void Serialize_struct_2_nested_i32_i32(void);
+void Serialize_struct_i32_array_3(void);
+void Serialize_struct_struct_i32_array_3(void);
+void Serialize_struct_struct_i32_i32_array_3(void);
+void Serialize_struct_w_array_type_i32_i32(void);
+void Serialize_struct_w_array_type_struct(void);
+void Serialize_struct_w_2_array_type_i32_i32(void);
+void Serialize_struct_w_2_array_type_struct(void);
+void Serialize_struct_partial(void);
+void Serialize_escape_simple_string(void);
+void Serialize_escape_newline(void);
+void Serialize_escape_2_newlines(void);
+void Serialize_escape_string_w_trailing_newline(void);
+void Serialize_escape_string_w_2_trailing_newlines(void);
+void Serialize_escape_string_w_delim(void);
+
+// Testsuite 'Deserialize'
+void Deserialize_bool(void);
+void Deserialize_byte(void);
+void Deserialize_char(void);
+void Deserialize_char_literal(void);
+void Deserialize_i8(void);
+void Deserialize_i16(void);
+void Deserialize_i32(void);
+void Deserialize_i64(void);
+void Deserialize_iptr(void);
+void Deserialize_u8(void);
+void Deserialize_u16(void);
+void Deserialize_u32(void);
+void Deserialize_u64(void);
+void Deserialize_uptr(void);
+void Deserialize_float(void);
+void Deserialize_double(void);
+void Deserialize_negative_int(void);
+void Deserialize_negative_float(void);
+void Deserialize_invalid_i8(void);
+void Deserialize_invalid_i16(void);
+void Deserialize_invalid_i32(void);
+void Deserialize_invalid_i64(void);
+void Deserialize_invalid_iptr(void);
+void Deserialize_invalid_u8(void);
+void Deserialize_invalid_u16(void);
+void Deserialize_invalid_u32(void);
+void Deserialize_invalid_u64(void);
+void Deserialize_invalid_uptr(void);
+void Deserialize_invalid_float(void);
+void Deserialize_invalid_double(void);
+void Deserialize_string(void);
+void Deserialize_entity(void);
+void Deserialize_id(void);
+void Deserialize_enum(void);
+void Deserialize_bitmask(void);
+void Deserialize_struct_enum(void);
+void Deserialize_struct_bitmask(void);
+void Deserialize_struct_i32(void);
+void Deserialize_struct_i32_neg(void);
+void Deserialize_struct_i32_i32(void);
+void Deserialize_struct_entity(void);
+void Deserialize_struct_id(void);
+void Deserialize_struct_nested_i32(void);
+void Deserialize_struct_nested_i32_i32(void);
+void Deserialize_struct_2_nested_i32_i32(void);
+void Deserialize_struct_member_i32(void);
+void Deserialize_struct_member_i32_neg(void);
+void Deserialize_struct_member_i32_i32(void);
+void Deserialize_struct_member_nested_i32(void);
+void Deserialize_struct_member_nested_i32_i32(void);
+void Deserialize_struct_member_2_nested_i32_i32(void);
+void Deserialize_struct_member_2_nested_i32_i32_reverse(void);
+void Deserialize_struct_i32_array_3(void);
+void Deserialize_struct_struct_i32_array_3(void);
+void Deserialize_struct_struct_i32_i32_array_3(void);
+void Deserialize_struct_w_array_type_i32_i32(void);
+void Deserialize_struct_w_array_type_struct(void);
+void Deserialize_struct_w_2_array_type_i32_i32(void);
+void Deserialize_struct_w_2_array_type_struct(void);
+void Deserialize_discover_type_int(void);
+void Deserialize_discover_type_negative_int(void);
+void Deserialize_discover_type_float(void);
+void Deserialize_discover_type_negative_float(void);
+void Deserialize_discover_type_string(void);
+void Deserialize_discover_type_multiline_string(void);
+void Deserialize_discover_type_entity(void);
+void Deserialize_discover_type_bool(void);
+void Deserialize_discover_type_unknown(void);
+void Deserialize_discover_type_invalid(void);
+
+bake_test_case Eval_testcases[] = {
+    {
+        "null",
+        Eval_null
+    },
+    {
+        "empty",
+        Eval_empty
+    },
+    {
+        "space",
+        Eval_space
+    },
+    {
+        "space_newline",
+        Eval_space_newline
+    },
+    {
+        "two_empty_newlines",
+        Eval_two_empty_newlines
+    },
+    {
+        "three_empty_newlines",
+        Eval_three_empty_newlines
+    },
+    {
+        "newline_trailing_space",
+        Eval_newline_trailing_space
+    },
+    {
+        "newline_trailing_spaces",
+        Eval_newline_trailing_spaces
+    },
+    {
+        "multiple_trailing_newlines",
+        Eval_multiple_trailing_newlines
+    },
+    {
+        "entity",
+        Eval_entity
+    },
+    {
+        "entity_w_core_name",
+        Eval_entity_w_core_name
+    },
+    {
+        "2_entities",
+        Eval_2_entities
+    },
+    {
+        "line_comment",
+        Eval_line_comment
+    },
+    {
+        "line_comment_before_stmt",
+        Eval_line_comment_before_stmt
+    },
+    {
+        "line_comment_after_stmt",
+        Eval_line_comment_after_stmt
+    },
+    {
+        "line_comment_between_stmt",
+        Eval_line_comment_between_stmt
+    },
+    {
+        "multiple_line_comment",
+        Eval_multiple_line_comment
+    },
+    {
+        "multiple_line_comment_w_newlines",
+        Eval_multiple_line_comment_w_newlines
+    },
+    {
+        "line_comment_after_stmt_same_line",
+        Eval_line_comment_after_stmt_same_line
+    },
+    {
+        "line_comment_before_scope_open",
+        Eval_line_comment_before_scope_open
+    },
+    {
+        "line_comment_after_newline_before_scope_open",
+        Eval_line_comment_after_newline_before_scope_open
+    },
+    {
+        "line_comment_after_newline_before_newline_scope_open",
+        Eval_line_comment_after_newline_before_newline_scope_open
+    },
+    {
+        "multi_line_comment",
+        Eval_multi_line_comment
+    },
+    {
+        "multi_line_comment_before_stmt",
+        Eval_multi_line_comment_before_stmt
+    },
+    {
+        "multi_line_comment_after_stmt",
+        Eval_multi_line_comment_after_stmt
+    },
+    {
+        "multi_line_comment_between_stmt",
+        Eval_multi_line_comment_between_stmt
+    },
+    {
+        "multiple_multi_line_comment",
+        Eval_multiple_multi_line_comment
+    },
+    {
+        "multiple_multi_line_comment_w_newlines",
+        Eval_multiple_multi_line_comment_w_newlines
+    },
+    {
+        "multi_line_comment_after_stmt_same_line",
+        Eval_multi_line_comment_after_stmt_same_line
+    },
+    {
+        "multi_line_comment_before_scope_open",
+        Eval_multi_line_comment_before_scope_open
+    },
+    {
+        "multi_line_comment_after_newline_before_scope_open",
+        Eval_multi_line_comment_after_newline_before_scope_open
+    },
+    {
+        "multi_line_comment_after_newline_before_newline_scope_open",
+        Eval_multi_line_comment_after_newline_before_newline_scope_open
+    },
+    {
+        "multi_line_comment_multiple_lines",
+        Eval_multi_line_comment_multiple_lines
+    },
+    {
+        "hierarchy_1_child",
+        Eval_hierarchy_1_child
+    },
+    {
+        "hierarchy_2_children",
+        Eval_hierarchy_2_children
+    },
+    {
+        "hierarchy_1_child_same_line",
+        Eval_hierarchy_1_child_same_line
+    },
+    {
+        "hierarchy_2_children_same_line",
+        Eval_hierarchy_2_children_same_line
+    },
+    {
+        "hierarchy_2_children_same_line_no_trailing_comma",
+        Eval_hierarchy_2_children_same_line_no_trailing_comma
+    },
+    {
+        "entity_after_hierarchy",
+        Eval_entity_after_hierarchy
+    },
+    {
+        "newline_before_scope_open",
+        Eval_newline_before_scope_open
+    },
+    {
+        "newline_w_whitespace_before_scope_open",
+        Eval_newline_w_whitespace_before_scope_open
+    },
+    {
+        "2_newline_before_scope_open",
+        Eval_2_newline_before_scope_open
+    },
+    {
+        "2_newline_w_whitespace_before_scope_open",
+        Eval_2_newline_w_whitespace_before_scope_open
+    },
+    {
+        "hierarchy_2_levels",
+        Eval_hierarchy_2_levels
+    },
+    {
+        "hierarchy_2_levels_2_subtrees",
+        Eval_hierarchy_2_levels_2_subtrees
+    },
+    {
+        "missing_end_of_scope",
+        Eval_missing_end_of_scope
+    },
+    {
+        "create_in_scope",
+        Eval_create_in_scope
+    },
+    {
+        "hierarchy_w_pred_subj",
+        Eval_hierarchy_w_pred_subj
+    },
+    {
+        "hierarchy_custom_relation",
+        Eval_hierarchy_custom_relation
+    },
+    {
+        "hierarchy_custom_relation_2_levels",
+        Eval_hierarchy_custom_relation_2_levels
+    },
+    {
+        "hierarchy_custom_relation_apply_to_object",
+        Eval_hierarchy_custom_relation_apply_to_object
+    },
+    {
+        "hierarchy_custom_relation_apply_to_object_2_levels",
+        Eval_hierarchy_custom_relation_apply_to_object_2_levels
+    },
+    {
+        "entity_after_hierarchy_custom_relation",
+        Eval_entity_after_hierarchy_custom_relation
+    },
+    {
+        "entity_after_hierarchy_custom_relation_2_levels",
+        Eval_entity_after_hierarchy_custom_relation_2_levels
+    },
+    {
+        "with_tag",
+        Eval_with_tag
+    },
+    {
+        "with_tag_2_entities",
+        Eval_with_tag_2_entities
+    },
+    {
+        "with_tag_same_line",
+        Eval_with_tag_same_line
+    },
+    {
+        "with_tag_2_entities_same_line",
+        Eval_with_tag_2_entities_same_line
+    },
+    {
+        "with_tag_2_entities_same_line_no_trailing_comma",
+        Eval_with_tag_2_entities_same_line_no_trailing_comma
+    },
+    {
+        "with_tag_2_levels",
+        Eval_with_tag_2_levels
+    },
+    {
+        "with_tag_2_levels_2_subtrees",
+        Eval_with_tag_2_levels_2_subtrees
+    },
+    {
+        "with_n_tags",
+        Eval_with_n_tags
+    },
+    {
+        "with_n_tags_2_levels",
+        Eval_with_n_tags_2_levels
+    },
+    {
+        "with_n_tags_2_levels_invalid_tag",
+        Eval_with_n_tags_2_levels_invalid_tag
+    },
+    {
+        "with_after_scope",
+        Eval_with_after_scope
+    },
+    {
+        "with_after_with",
+        Eval_with_after_with
+    },
+    {
+        "scope_inside_with_inside_scope",
+        Eval_scope_inside_with_inside_scope
+    },
+    {
+        "with_inside_scope",
+        Eval_with_inside_scope
+    },
+    {
+        "with_tag_core_name",
+        Eval_with_tag_core_name
+    },
+    {
+        "inherit",
+        Eval_inherit
+    },
+    {
+        "inherit_newline",
+        Eval_inherit_newline
+    },
+    {
+        "inherit_w_colon",
+        Eval_inherit_w_colon
+    },
+    {
+        "inherit_w_colon_w_scope",
+        Eval_inherit_w_colon_w_scope
+    },
+    {
+        "assign_component_w_value",
+        Eval_assign_component_w_value
+    },
+    {
+        "assign_tag_in_assign_scope",
+        Eval_assign_tag_in_assign_scope
+    },
+    {
+        "assign_tag_in_assign_scope_same_line",
+        Eval_assign_tag_in_assign_scope_same_line
+    },
+    {
+        "assign_tag_in_assign_scope_core_name",
+        Eval_assign_tag_in_assign_scope_core_name
+    },
+    {
+        "assign_component_value_in_assign_scope",
+        Eval_assign_component_value_in_assign_scope
+    },
+    {
+        "assign_2_component_values_in_assign_scope",
+        Eval_assign_2_component_values_in_assign_scope
+    },
+    {
+        "type_and_assign_in_plecs",
+        Eval_type_and_assign_in_plecs
+    },
+    {
+        "type_and_assign_in_plecs_w_2_members",
+        Eval_type_and_assign_in_plecs_w_2_members
+    },
+    {
+        "type_and_assign_in_plecs_w_3_members",
+        Eval_type_and_assign_in_plecs_w_3_members
+    },
+    {
+        "type_and_assign_in_plecs_w_enum",
+        Eval_type_and_assign_in_plecs_w_enum
+    },
+    {
+        "type_and_assign_in_plecs_w_enum_using_meta",
+        Eval_type_and_assign_in_plecs_w_enum_using_meta
+    },
+    {
+        "type_and_assign_in_plecs_w_enum_primitive_using_meta",
+        Eval_type_and_assign_in_plecs_w_enum_primitive_using_meta
+    },
+    {
+        "type_and_assign_in_plecs_w_enum_primitive_and_struct",
+        Eval_type_and_assign_in_plecs_w_enum_primitive_and_struct
+    },
+    {
+        "type_and_assign_in_plecs_nested_member",
+        Eval_type_and_assign_in_plecs_nested_member
+    },
+    {
+        "dot_assign_nested_member",
+        Eval_dot_assign_nested_member
+    },
+    {
+        "dot_assign_binary_expr",
+        Eval_dot_assign_binary_expr
+    },
+    {
+        "open_scope_no_parent",
+        Eval_open_scope_no_parent
+    },
+    {
+        "create_subject_in_root_scope_w_resolvable_id",
+        Eval_create_subject_in_root_scope_w_resolvable_id
+    },
+    {
+        "create_subject_in_scope_w_resolvable_id",
+        Eval_create_subject_in_scope_w_resolvable_id
+    },
+    {
+        "create_subject_in_scope_w_resolvable_id_using",
+        Eval_create_subject_in_scope_w_resolvable_id_using
+    },
+    {
+        "using_scope",
+        Eval_using_scope
+    },
+    {
+        "using_nested_scope",
+        Eval_using_nested_scope
+    },
+    {
+        "using_nested_in_scope",
+        Eval_using_nested_in_scope
+    },
+    {
+        "using_with_scope",
+        Eval_using_with_scope
+    },
+    {
+        "using_w_entity_ref_in_value_2_members",
+        Eval_using_w_entity_ref_in_value_2_members
+    },
+    {
+        "using_w_entity_ref_in_value_3_members",
+        Eval_using_w_entity_ref_in_value_3_members
+    },
+    {
+        "2_using_scope",
+        Eval_2_using_scope
+    },
+    {
+        "2_using_in_different_scope",
+        Eval_2_using_in_different_scope
+    },
+    {
+        "empty_scope_after_using",
+        Eval_empty_scope_after_using
+    },
+    {
+        "assignment_to_non_component",
+        Eval_assignment_to_non_component
+    },
+    {
+        "struct_w_member_w_assignment_to_nothing",
+        Eval_struct_w_member_w_assignment_to_nothing
+    },
+    {
+        "struct_w_member_w_assignment_to_empty_scope",
+        Eval_struct_w_member_w_assignment_to_empty_scope
+    },
+    {
+        "scope_after_assign",
+        Eval_scope_after_assign
+    },
+    {
+        "assign_after_inherit",
+        Eval_assign_after_inherit
+    },
+    {
+        "multiple_tags_single_line",
+        Eval_multiple_tags_single_line
+    },
+    {
+        "multiple_pairs_single_line",
+        Eval_multiple_pairs_single_line
+    },
+    {
+        "multiple_vars_single_line",
+        Eval_multiple_vars_single_line
+    },
+    {
+        "multiple_assignments_single_line",
+        Eval_multiple_assignments_single_line
+    },
+    {
+        "2_stmts_in_scope_w_no_parent",
+        Eval_2_stmts_in_scope_w_no_parent
+    },
+    {
+        "invalid_nested_assignment",
+        Eval_invalid_nested_assignment
+    },
+    {
+        "invalid_partial_pair_assignment",
+        Eval_invalid_partial_pair_assignment
+    },
+    {
+        "empty_assignment",
+        Eval_empty_assignment
+    },
+    {
+        "assign_tag_to_parent",
+        Eval_assign_tag_to_parent
+    },
+    {
+        "assign_component_to_parent",
+        Eval_assign_component_to_parent
+    },
+    {
+        "empty_assignment_before_end_of_scope",
+        Eval_empty_assignment_before_end_of_scope
+    },
+    {
+        "assign_to_parent_pair_w_new_entities_in_scope",
+        Eval_assign_to_parent_pair_w_new_entities_in_scope
+    },
+    {
+        "assign_to_parent_pair_w_existing_entities_in_scope",
+        Eval_assign_to_parent_pair_w_existing_entities_in_scope
+    },
+    {
+        "default_child_component",
+        Eval_default_child_component
+    },
+    {
+        "default_child_component_w_assign",
+        Eval_default_child_component_w_assign
+    },
+    {
+        "struct_type_w_default_child_component",
+        Eval_struct_type_w_default_child_component
+    },
+    {
+        "struct_type_w_default_child_component_nested_member",
+        Eval_struct_type_w_default_child_component_nested_member
+    },
+    {
+        "enum_type_w_default_child_component",
+        Eval_enum_type_w_default_child_component
+    },
+    {
+        "default_type_from_with",
+        Eval_default_type_from_with
+    },
+    {
+        "default_type_from_nested_with",
+        Eval_default_type_from_nested_with
+    },
+    {
+        "default_type_with_tag",
+        Eval_default_type_with_tag
+    },
+    {
+        "default_type_from_with_in_entity_scope_w_default_type",
+        Eval_default_type_from_with_in_entity_scope_w_default_type
+    },
+    {
+        "default_type_from_entity_scope_in_with",
+        Eval_default_type_from_entity_scope_in_with
+    },
+    {
+        "scope_w_1_subj_and_2_pairs",
+        Eval_scope_w_1_subj_and_2_pairs
+    },
+    {
+        "inherit_from_multiple",
+        Eval_inherit_from_multiple
+    },
+    {
+        "assign_pair_component",
+        Eval_assign_pair_component
+    },
+    {
+        "assign_pair_component_in_scope",
+        Eval_assign_pair_component_in_scope
+    },
+    {
+        "assign_pair_component_in_script",
+        Eval_assign_pair_component_in_script
+    },
+    {
+        "assign_pair_component_in_script_update",
+        Eval_assign_pair_component_in_script_update
+    },
+    {
+        "set_entity_names",
+        Eval_set_entity_names
+    },
+    {
+        "oneof",
+        Eval_oneof
+    },
+    {
+        "invalid_oneof",
+        Eval_invalid_oneof
+    },
+    {
+        "brief_annotation",
+        Eval_brief_annotation
+    },
+    {
+        "name_annotation",
+        Eval_name_annotation
+    },
+    {
+        "link_annotation",
+        Eval_link_annotation
+    },
+    {
+        "color_annotation",
+        Eval_color_annotation
+    },
+    {
+        "multiple_annotations",
+        Eval_multiple_annotations
+    },
+    {
+        "annotation_w_trailing_space",
+        Eval_annotation_w_trailing_space
+    },
+    {
+        "multiline_string",
+        Eval_multiline_string
+    },
+    {
+        "unterminated_multiline_string",
+        Eval_unterminated_multiline_string
+    },
+    {
+        "declaration_w_underscore_name",
+        Eval_declaration_w_underscore_name
+    },
+    {
+        "annotate_declaration",
+        Eval_annotate_declaration
+    },
+    {
+        "anonymous_entity",
+        Eval_anonymous_entity
+    },
+    {
+        "anonymous_entity_in_scope",
+        Eval_anonymous_entity_in_scope
+    },
+    {
+        "anonymous_declaration",
+        Eval_anonymous_declaration
+    },
+    {
+        "const_var_int",
+        Eval_const_var_int
+    },
+    {
+        "const_var_float",
+        Eval_const_var_float
+    },
+    {
+        "const_var_bool",
+        Eval_const_var_bool
+    },
+    {
+        "const_var_string",
+        Eval_const_var_string
+    },
+    {
+        "const_var_struct",
+        Eval_const_var_struct
+    },
+    {
+        "const_var_redeclare",
+        Eval_const_var_redeclare
+    },
+    {
+        "const_var_scoped",
+        Eval_const_var_scoped
+    },
+    {
+        "assign_component_from_var",
+        Eval_assign_component_from_var
+    },
+    {
+        "assign_component_from_var_in_scope",
+        Eval_assign_component_from_var_in_scope
+    },
+    {
+        "scope_w_component_after_const_var",
+        Eval_scope_w_component_after_const_var
+    },
+    {
+        "component_after_const_paren_expr",
+        Eval_component_after_const_paren_expr
+    },
+    {
+        "component_after_const_add_expr",
+        Eval_component_after_const_add_expr
+    },
+    {
+        "component_after_const_sub_expr",
+        Eval_component_after_const_sub_expr
+    },
+    {
+        "component_after_const_mul_expr",
+        Eval_component_after_const_mul_expr
+    },
+    {
+        "component_after_const_div_expr",
+        Eval_component_after_const_div_expr
+    },
+    {
+        "parse_with",
+        Eval_parse_with
+    },
+    {
+        "parse_with_w_with",
+        Eval_parse_with_w_with
+    },
+    {
+        "parse_with_w_tag",
+        Eval_parse_with_w_tag
+    },
+    {
+        "parse_with_value",
+        Eval_parse_with_value
+    },
+    {
+        "parse_with_2_values",
+        Eval_parse_with_2_values
+    },
+    {
+        "parse_with_2_nested_values",
+        Eval_parse_with_2_nested_values
+    },
+    {
+        "parse_with_var",
+        Eval_parse_with_var
+    },
+    {
+        "parse_with_2_vars",
+        Eval_parse_with_2_vars
+    },
+    {
+        "parse_with_2_nested_vars",
+        Eval_parse_with_2_nested_vars
+    },
+    {
+        "parse_with_var_in_scope",
+        Eval_parse_with_var_in_scope
+    },
+    {
+        "assign_const_w_expr",
+        Eval_assign_const_w_expr
+    },
+    {
+        "const_w_type",
+        Eval_const_w_type
+    },
+    {
+        "typed_const_w_composite_type_invalid_assignment",
+        Eval_typed_const_w_composite_type_invalid_assignment
+    },
+    {
+        "typed_const_w_composite_type",
+        Eval_typed_const_w_composite_type
+    },
+    {
+        "assign_var_to_typed_const_w_composite_type",
+        Eval_assign_var_to_typed_const_w_composite_type
+    },
+    {
+        "typed_const_w_composite_type_invalid_assignment",
+        Eval_typed_const_w_composite_type_invalid_assignment
+    },
+    {
+        "using_wildcard",
+        Eval_using_wildcard
+    },
+    {
+        "single_line_comment_in_value",
+        Eval_single_line_comment_in_value
+    },
+    {
+        "single_line_comment_in_value_after_scope",
+        Eval_single_line_comment_in_value_after_scope
+    },
+    {
+        "multi_line_comment_in_value",
+        Eval_multi_line_comment_in_value
+    },
+    {
+        "multi_line_comment_in_value_after_scope",
+        Eval_multi_line_comment_in_value_after_scope
+    },
+    {
+        "unterminated_multi_line_comment_in_value",
+        Eval_unterminated_multi_line_comment_in_value
+    },
+    {
+        "module_stmt",
+        Eval_module_stmt
+    },
+    {
+        "nested_module_stmt",
+        Eval_nested_module_stmt
+    },
+    {
+        "module_stmt_w_scope",
+        Eval_module_stmt_w_scope
+    },
+    {
+        "module_stmt_w_nested_scope",
+        Eval_module_stmt_w_nested_scope
+    },
+    {
+        "assign_singleton_tag",
+        Eval_assign_singleton_tag
+    },
+    {
+        "assign_singleton_component",
+        Eval_assign_singleton_component
+    },
+    {
+        "assign_singleton_tag_w_scope",
+        Eval_assign_singleton_tag_w_scope
+    },
+    {
+        "assign_singleton_2_tags_w_scope",
+        Eval_assign_singleton_2_tags_w_scope
+    },
+    {
+        "assign_singleton_component_w_scope",
+        Eval_assign_singleton_component_w_scope
+    },
+    {
+        "assign_singleton_2_components_w_scope",
+        Eval_assign_singleton_2_components_w_scope
+    },
+    {
+        "with_pair_in_scope",
+        Eval_with_pair_in_scope
+    },
+    {
+        "with_pair_component_in_scope",
+        Eval_with_pair_component_in_scope
+    },
+    {
+        "pair_w_rel_var",
+        Eval_pair_w_rel_var
+    },
+    {
+        "pair_w_tgt_var",
+        Eval_pair_w_tgt_var
+    },
+    {
+        "pair_w_rel_var_invalid_type",
+        Eval_pair_w_rel_var_invalid_type
+    },
+    {
+        "pair_w_tgt_var_invalid_type",
+        Eval_pair_w_tgt_var_invalid_type
+    },
+    {
+        "with_value_not_a_component",
+        Eval_with_value_not_a_component
+    },
+    {
+        "component_in_with_scope",
+        Eval_component_in_with_scope
+    },
+    {
+        "component_in_with_scope_nested",
+        Eval_component_in_with_scope_nested
+    },
+    {
+        "component_in_with_scope_in_scope",
+        Eval_component_in_with_scope_in_scope
+    },
+    {
+        "assign_after_with_in_scope",
+        Eval_assign_after_with_in_scope
+    },
+    {
+        "array_component",
+        Eval_array_component
+    },
+    {
+        "not_an_array_component",
+        Eval_not_an_array_component
+    },
+    {
+        "array_component_w_curly_brackets",
+        Eval_array_component_w_curly_brackets
+    },
+    {
+        "unknown_identifier",
+        Eval_unknown_identifier
+    },
+    {
+        "unknown_identifier_for_int_field",
+        Eval_unknown_identifier_for_int_field
+    },
+    {
+        "on_set_w_kind_paren_no_reflection",
+        Eval_on_set_w_kind_paren_no_reflection
+    },
+    {
+        "on_set_w_kind_paren",
+        Eval_on_set_w_kind_paren
+    },
+    {
+        "on_set_w_kind_no_paren_no_reflection",
+        Eval_on_set_w_kind_no_paren_no_reflection
+    },
+    {
+        "on_set_w_kind_no_paren",
+        Eval_on_set_w_kind_no_paren
+    },
+    {
+        "on_set_w_single_assign",
+        Eval_on_set_w_single_assign
+    },
+    {
+        "on_set_w_single_assign_scoped_w_value",
+        Eval_on_set_w_single_assign_scoped_w_value
+    },
+    {
+        "on_set_w_single_assign_scoped_no_value",
+        Eval_on_set_w_single_assign_scoped_no_value
+    },
+    {
+        "if_true",
+        Eval_if_true
+    },
+    {
+        "if_true_no_else",
+        Eval_if_true_no_else
+    },
+    {
+        "if_false",
+        Eval_if_false
+    },
+    {
+        "if_true_var",
+        Eval_if_true_var
+    },
+    {
+        "if_false_var",
+        Eval_if_false_var
+    },
+    {
+        "if_10",
+        Eval_if_10
+    },
+    {
+        "if_0",
+        Eval_if_0
+    },
+    {
+        "if_true_in_scope",
+        Eval_if_true_in_scope
+    },
+    {
+        "if_false_in_scope",
+        Eval_if_false_in_scope
+    }
+};
+
+bake_test_case Assembly_testcases[] = {
+    {
+        "assembly_no_scope",
+        Assembly_assembly_no_scope
+    },
+    {
+        "assembly_empty",
+        Assembly_assembly_empty
+    },
+    {
+        "assembly_unresolved_tag",
+        Assembly_assembly_unresolved_tag
+    },
+    {
+        "assembly_unresolved_component",
+        Assembly_assembly_unresolved_component
+    },
+    {
+        "assembly_unresolved_pair_relationship",
+        Assembly_assembly_unresolved_pair_relationship
+    },
+    {
+        "assembly_unresolved_pair_target",
+        Assembly_assembly_unresolved_pair_target
+    },
+    {
+        "assembly_unresolved_with_tag",
+        Assembly_assembly_unresolved_with_tag
+    },
+    {
+        "assembly_unresolved_with_component",
+        Assembly_assembly_unresolved_with_component
+    },
+    {
+        "assembly_unresolved_with_pair_relationship",
+        Assembly_assembly_unresolved_with_pair_relationship
+    },
+    {
+        "assembly_unresolved_with_pair_target",
+        Assembly_assembly_unresolved_with_pair_target
+    },
+    {
+        "assembly_no_props",
+        Assembly_assembly_no_props
+    },
+    {
+        "assembly_prop_no_type",
+        Assembly_assembly_prop_no_type
+    },
+    {
+        "assembly_prop_no_default",
+        Assembly_assembly_prop_no_default
+    },
+    {
+        "assembly_prop",
+        Assembly_assembly_prop
+    },
+    {
+        "assembly_prop_space_colon",
+        Assembly_assembly_prop_space_colon
+    },
+    {
+        "assembly_2_props",
+        Assembly_assembly_2_props
+    },
+    {
+        "assembly_w_using",
+        Assembly_assembly_w_using
+    },
+    {
+        "assembly_instance_w_default_values",
+        Assembly_assembly_instance_w_default_values
+    },
+    {
+        "assembly_instance_w_assign_default_values",
+        Assembly_assembly_instance_w_assign_default_values
+    },
+    {
+        "assembly_instance_w_overridden_values",
+        Assembly_assembly_instance_w_overridden_values
+    },
+    {
+        "assembly_w_child",
+        Assembly_assembly_w_child
+    },
+    {
+        "assembly_w_child_parse_script",
+        Assembly_assembly_w_child_parse_script
+    },
+    {
+        "assembly_w_child_parse_script_twice",
+        Assembly_assembly_w_child_parse_script_twice
+    },
+    {
+        "assembly_w_child_update_after_parse",
+        Assembly_assembly_w_child_update_after_parse
+    },
+    {
+        "assembly_w_nested_child",
+        Assembly_assembly_w_nested_child
+    },
+    {
+        "assembly_w_prefab",
+        Assembly_assembly_w_prefab
+    },
+    {
+        "assembly_w_prefab_tree",
+        Assembly_assembly_w_prefab_tree
+    },
+    {
+        "assembly_w_nested_assembly",
+        Assembly_assembly_w_nested_assembly
+    },
+    {
+        "instantiate_prefab_w_assembly",
+        Assembly_instantiate_prefab_w_assembly
+    },
+    {
+        "assembly_w_prefab_w_assembly",
+        Assembly_assembly_w_prefab_w_assembly
+    },
+    {
+        "3_assemblies",
+        Assembly_3_assemblies
+    },
+    {
+        "assembly_nested_w_default_var",
+        Assembly_assembly_nested_w_default_var
+    },
+    {
+        "assembly_w_anonymous",
+        Assembly_assembly_w_anonymous
+    },
+    {
+        "assembly_w_anonymous_parse_again",
+        Assembly_assembly_w_anonymous_parse_again
+    },
+    {
+        "assembly_redeclare_prop_as_const",
+        Assembly_assembly_redeclare_prop_as_const
+    },
+    {
+        "assembly_redeclare_prop_as_prop",
+        Assembly_assembly_redeclare_prop_as_prop
+    },
+    {
+        "assembly_redeclare_const_as_const",
+        Assembly_assembly_redeclare_const_as_const
+    },
+    {
+        "assembly_w_composite_prop_invalid_assignment",
+        Assembly_assembly_w_composite_prop_invalid_assignment
+    },
+    {
+        "assembly_w_composite_prop",
+        Assembly_assembly_w_composite_prop
+    },
+    {
+        "assembly_with_with",
+        Assembly_assembly_with_with
+    },
+    {
+        "module_w_assembly",
+        Assembly_module_w_assembly
+    },
+    {
+        "module_w_nested_assembly",
+        Assembly_module_w_nested_assembly
+    },
+    {
+        "assembly_w_pair_w_this_var",
+        Assembly_assembly_w_pair_w_this_var
+    },
+    {
+        "run_assembly_after_error",
+        Assembly_run_assembly_after_error
+    },
+    {
+        "update_assembly_after_error",
+        Assembly_update_assembly_after_error
+    }
+};
+
+bake_test_case Expr_testcases[] = {
+    {
+        "add_2_int_literals",
+        Expr_add_2_int_literals
+    },
+    {
+        "add_2_int_literals_twice",
+        Expr_add_2_int_literals_twice
+    },
+    {
+        "sub_2_int_literals",
+        Expr_sub_2_int_literals
+    },
+    {
+        "mul_2_int_literals",
+        Expr_mul_2_int_literals
+    },
+    {
+        "div_2_int_literals",
+        Expr_div_2_int_literals
+    },
+    {
+        "add_3_int_literals",
+        Expr_add_3_int_literals
+    },
+    {
+        "add_3_int_literals_twice",
+        Expr_add_3_int_literals_twice
+    },
+    {
+        "sub_3_int_literals",
+        Expr_sub_3_int_literals
+    },
+    {
+        "mul_3_int_literals",
+        Expr_mul_3_int_literals
+    },
+    {
+        "div_3_int_literals",
+        Expr_div_3_int_literals
+    },
+    {
+        "int_to_bool",
+        Expr_int_to_bool
+    },
+    {
+        "bool_to_int",
+        Expr_bool_to_int
+    },
+    {
+        "bool_to_uint",
+        Expr_bool_to_uint
+    },
+    {
+        "add_mul_3_int_literals",
+        Expr_add_mul_3_int_literals
+    },
+    {
+        "sub_mul_3_int_literals",
+        Expr_sub_mul_3_int_literals
+    },
+    {
+        "div_mul_3_int_literals",
+        Expr_div_mul_3_int_literals
+    },
+    {
+        "add_div_3_int_literals",
+        Expr_add_div_3_int_literals
+    },
+    {
+        "sub_div_3_int_literals",
+        Expr_sub_div_3_int_literals
+    },
+    {
+        "mul_div_3_int_literals",
+        Expr_mul_div_3_int_literals
+    },
+    {
+        "mul_add_mul_add_int_literals",
+        Expr_mul_add_mul_add_int_literals
+    },
+    {
+        "mul_sub_mul_sub_int_literals",
+        Expr_mul_sub_mul_sub_int_literals
+    },
+    {
+        "mul_div_mul_div_int_literals",
+        Expr_mul_div_mul_div_int_literals
+    },
+    {
+        "div_add_div_add_int_literals",
+        Expr_div_add_div_add_int_literals
+    },
+    {
+        "div_sub_div_sub_int_literals",
+        Expr_div_sub_div_sub_int_literals
+    },
+    {
+        "div_sub_div_mul_int_literals",
+        Expr_div_sub_div_mul_int_literals
+    },
+    {
+        "div_mul_div_mul_int_literals",
+        Expr_div_mul_div_mul_int_literals
+    },
+    {
+        "add_2_flt_literals",
+        Expr_add_2_flt_literals
+    },
+    {
+        "sub_2_flt_literals",
+        Expr_sub_2_flt_literals
+    },
+    {
+        "mul_2_flt_literals",
+        Expr_mul_2_flt_literals
+    },
+    {
+        "div_2_flt_literals",
+        Expr_div_2_flt_literals
+    },
+    {
+        "add_2_int_neg_literals",
+        Expr_add_2_int_neg_literals
+    },
+    {
+        "sub_2_int_neg_literals",
+        Expr_sub_2_int_neg_literals
+    },
+    {
+        "mul_2_int_neg_literals",
+        Expr_mul_2_int_neg_literals
+    },
+    {
+        "div_2_int_neg_literals",
+        Expr_div_2_int_neg_literals
+    },
+    {
+        "mul_lparen_add_add_rparen_int_literals",
+        Expr_mul_lparen_add_add_rparen_int_literals
+    },
+    {
+        "mul_lparen_add_add_add_rparen_int_literals",
+        Expr_mul_lparen_add_add_add_rparen_int_literals
+    },
+    {
+        "mul_lparen_add_add_rparen_add_int_literals",
+        Expr_mul_lparen_add_add_rparen_add_int_literals
+    },
+    {
+        "lparen_add_add_rparen_mul_int_literals",
+        Expr_lparen_add_add_rparen_mul_int_literals
+    },
+    {
+        "lparen_add_add_add_rparen_mul_int_literals",
+        Expr_lparen_add_add_add_rparen_mul_int_literals
+    },
+    {
+        "double_paren_add_add",
+        Expr_double_paren_add_add
+    },
+    {
+        "double_paren_literal",
+        Expr_double_paren_literal
+    },
+    {
+        "lparen_add_add_rparen_mul_lparen_add_add_rparen",
+        Expr_lparen_add_add_rparen_mul_lparen_add_add_rparen
+    },
+    {
+        "float_result_add_2_int_literals",
+        Expr_float_result_add_2_int_literals
+    },
+    {
+        "struct_result_add_2_int_literals",
+        Expr_struct_result_add_2_int_literals
+    },
+    {
+        "struct_result_add_2_2_fields_int_literals",
+        Expr_struct_result_add_2_2_fields_int_literals
+    },
+    {
+        "struct_result_add_3_int_literals",
+        Expr_struct_result_add_3_int_literals
+    },
+    {
+        "struct_result_lparen_int_rparen",
+        Expr_struct_result_lparen_int_rparen
+    },
+    {
+        "add_to_var",
+        Expr_add_to_var
+    },
+    {
+        "add_var_to",
+        Expr_add_var_to
+    },
+    {
+        "var_member",
+        Expr_var_member
+    },
+    {
+        "bool_cond_and_bool",
+        Expr_bool_cond_and_bool
+    },
+    {
+        "bool_cond_or_bool",
+        Expr_bool_cond_or_bool
+    },
+    {
+        "int_cond_and_int",
+        Expr_int_cond_and_int
+    },
+    {
+        "int_cond_or_int",
+        Expr_int_cond_or_int
+    },
+    {
+        "bool_cond_and_int",
+        Expr_bool_cond_and_int
+    },
+    {
+        "int_cond_and_bool",
+        Expr_int_cond_and_bool
+    },
+    {
+        "bool_cond_or_int",
+        Expr_bool_cond_or_int
+    },
+    {
+        "int_cond_or_bool",
+        Expr_int_cond_or_bool
+    },
+    {
+        "cond_eq_bool",
+        Expr_cond_eq_bool
+    },
+    {
+        "cond_eq_int",
+        Expr_cond_eq_int
+    },
+    {
+        "cond_neq_bool",
+        Expr_cond_neq_bool
+    },
+    {
+        "cond_neq_int",
+        Expr_cond_neq_int
+    },
+    {
+        "cond_eq_bool_int",
+        Expr_cond_eq_bool_int
+    },
+    {
+        "cond_eq_int_flt",
+        Expr_cond_eq_int_flt
+    },
+    {
+        "cond_eq_cond_and",
+        Expr_cond_eq_cond_and
+    },
+    {
+        "cond_eq_cond_or",
+        Expr_cond_eq_cond_or
+    },
+    {
+        "cond_gt_bool",
+        Expr_cond_gt_bool
+    },
+    {
+        "cond_gt_int",
+        Expr_cond_gt_int
+    },
+    {
+        "cond_gt_flt",
+        Expr_cond_gt_flt
+    },
+    {
+        "cond_gteq_bool",
+        Expr_cond_gteq_bool
+    },
+    {
+        "cond_gteq_int",
+        Expr_cond_gteq_int
+    },
+    {
+        "cond_gteq_flt",
+        Expr_cond_gteq_flt
+    },
+    {
+        "cond_lt_bool",
+        Expr_cond_lt_bool
+    },
+    {
+        "cond_lt_int",
+        Expr_cond_lt_int
+    },
+    {
+        "cond_lt_flt",
+        Expr_cond_lt_flt
+    },
+    {
+        "cond_lteq_bool",
+        Expr_cond_lteq_bool
+    },
+    {
+        "cond_lteq_int",
+        Expr_cond_lteq_int
+    },
+    {
+        "cond_lteq_flt",
+        Expr_cond_lteq_flt
+    },
+    {
+        "min_lparen_int_rparen",
+        Expr_min_lparen_int_rparen
+    },
+    {
+        "min_lparen_int_add_int_rparen",
+        Expr_min_lparen_int_add_int_rparen
+    },
+    {
+        "min_var",
+        Expr_min_var
+    },
+    {
+        "min_lparen_int_rparen_to_i64",
+        Expr_min_lparen_int_rparen_to_i64
+    },
+    {
+        "min_lparen_int_rparen_to_i32",
+        Expr_min_lparen_int_rparen_to_i32
+    },
+    {
+        "struct_w_min_var",
+        Expr_struct_w_min_var
+    },
+    {
+        "struct_w_min_lparen_int_rparen",
+        Expr_struct_w_min_lparen_int_rparen
+    },
+    {
+        "struct_w_min_lparen_var_rparen",
+        Expr_struct_w_min_lparen_var_rparen
+    },
+    {
+        "shift_left_int",
+        Expr_shift_left_int
+    },
+    {
+        "shift_right_int",
+        Expr_shift_right_int
+    },
+    {
+        "shift_left_int_add_int",
+        Expr_shift_left_int_add_int
+    },
+    {
+        "shift_left_int_mul_int",
+        Expr_shift_left_int_mul_int
+    },
+    {
+        "add_int_shift_left_int",
+        Expr_add_int_shift_left_int
+    },
+    {
+        "mul_int_shift_left_int",
+        Expr_mul_int_shift_left_int
+    },
+    {
+        "add_int_shift_left_int_add_int",
+        Expr_add_int_shift_left_int_add_int
+    },
+    {
+        "mul_int_shift_left_int_mul_int",
+        Expr_mul_int_shift_left_int_mul_int
+    },
+    {
+        "entity_expr",
+        Expr_entity_expr
+    },
+    {
+        "entity_path_expr",
+        Expr_entity_path_expr
+    },
+    {
+        "entity_parent_func",
+        Expr_entity_parent_func
+    },
+    {
+        "entity_name_func",
+        Expr_entity_name_func
+    },
+    {
+        "entity_doc_name_func",
+        Expr_entity_doc_name_func
+    },
+    {
+        "entity_chain_func",
+        Expr_entity_chain_func
+    },
+    {
+        "var_parent_func",
+        Expr_var_parent_func
+    },
+    {
+        "var_name_func",
+        Expr_var_name_func
+    },
+    {
+        "var_doc_name_func",
+        Expr_var_doc_name_func
+    },
+    {
+        "var_chain_func",
+        Expr_var_chain_func
+    },
+    {
+        "interpolate_string_w_i32_var",
+        Expr_interpolate_string_w_i32_var
+    },
+    {
+        "interpolate_string_w_string_var",
+        Expr_interpolate_string_w_string_var
+    },
+    {
+        "interpolate_string_w_entity_var",
+        Expr_interpolate_string_w_entity_var
+    },
+    {
+        "interpolate_string_w_id_var",
+        Expr_interpolate_string_w_id_var
+    },
+    {
+        "interpolate_string_w_var_not_found",
+        Expr_interpolate_string_w_var_not_found
+    },
+    {
+        "interpolate_string_w_entity_var_0",
+        Expr_interpolate_string_w_entity_var_0
+    },
+    {
+        "interpolate_string_w_var_special_chars",
+        Expr_interpolate_string_w_var_special_chars
+    },
+    {
+        "interpolate_string_w_var_before_after_text",
+        Expr_interpolate_string_w_var_before_after_text
+    },
+    {
+        "interpolate_string_w_curly_brackets_var",
+        Expr_interpolate_string_w_curly_brackets_var
+    },
+    {
+        "interpolate_string_w_curly_brackets_expr",
+        Expr_interpolate_string_w_curly_brackets_expr
+    },
+    {
+        "interpolate_string_w_curly_brackets_expr_w_var",
+        Expr_interpolate_string_w_curly_brackets_expr_w_var
+    },
+    {
+        "interpolate_string_w_curly_brackets_expr_w_composite_var",
+        Expr_interpolate_string_w_curly_brackets_expr_w_composite_var
+    },
+    {
+        "interpolate_string_w_escape_var_operator",
+        Expr_interpolate_string_w_escape_var_operator
+    },
+    {
+        "interpolate_string_w_escape_curly_brackets",
+        Expr_interpolate_string_w_escape_curly_brackets
+    },
+    {
+        "interpolate_string_w_func",
+        Expr_interpolate_string_w_func
+    },
+    {
+        "interpolate_string_w_func_chain",
+        Expr_interpolate_string_w_func_chain
+    },
+    {
+        "iter_to_vars_no_data",
+        Expr_iter_to_vars_no_data
+    },
+    {
+        "iter_to_vars_1_comp",
+        Expr_iter_to_vars_1_comp
+    },
+    {
+        "iter_to_vars_2_comps",
+        Expr_iter_to_vars_2_comps
+    },
+    {
+        "iter_to_vars_1_comp_1_tag",
+        Expr_iter_to_vars_1_comp_1_tag
+    },
+    {
+        "iter_to_vars_w_1_query_var",
+        Expr_iter_to_vars_w_1_query_var
+    },
+    {
+        "iter_to_vars_w_2_query_vars",
+        Expr_iter_to_vars_w_2_query_vars
+    }
+};
+
+bake_test_case Vars_testcases[] = {
+    {
+        "declare_1_var",
+        Vars_declare_1_var
+    },
+    {
+        "declare_2_vars",
+        Vars_declare_2_vars
+    },
+    {
+        "declare_vars_nested_scope",
+        Vars_declare_vars_nested_scope
+    },
+    {
+        "declare_vars_2_scopes",
+        Vars_declare_vars_2_scopes
+    },
+    {
+        "redeclare_var",
+        Vars_redeclare_var
+    },
+    {
+        "i32_expr_w_i32_var",
+        Vars_i32_expr_w_i32_var
+    },
+    {
+        "i32_expr_w_f32_var",
+        Vars_i32_expr_w_f32_var
+    },
+    {
+        "i32_expr_w_string_var",
+        Vars_i32_expr_w_string_var
+    },
+    {
+        "string_expr_w_string_var",
+        Vars_string_expr_w_string_var
+    },
+    {
+        "struct_expr_w_i32_vars",
+        Vars_struct_expr_w_i32_vars
+    },
+    {
+        "struct_expr_w_struct_var",
+        Vars_struct_expr_w_struct_var
+    },
+    {
+        "nested_struct_expr_w_struct_var",
+        Vars_nested_struct_expr_w_struct_var
+    },
+    {
+        "redeclare_in_scope",
+        Vars_redeclare_in_scope
+    },
+    {
+        "init_fini_vars",
+        Vars_init_fini_vars
+    }
+};
+
+bake_test_case Serialize_testcases[] = {
+    {
+        "bool",
+        Serialize_bool
+    },
+    {
+        "byte",
+        Serialize_byte
+    },
+    {
+        "char",
+        Serialize_char
+    },
+    {
+        "i8",
+        Serialize_i8
+    },
+    {
+        "i16",
+        Serialize_i16
+    },
+    {
+        "i32",
+        Serialize_i32
+    },
+    {
+        "i64",
+        Serialize_i64
+    },
+    {
+        "iptr",
+        Serialize_iptr
+    },
+    {
+        "u8",
+        Serialize_u8
+    },
+    {
+        "u16",
+        Serialize_u16
+    },
+    {
+        "u32",
+        Serialize_u32
+    },
+    {
+        "u64",
+        Serialize_u64
+    },
+    {
+        "uptr",
+        Serialize_uptr
+    },
+    {
+        "float",
+        Serialize_float
+    },
+    {
+        "double",
+        Serialize_double
+    },
+    {
+        "string",
+        Serialize_string
+    },
+    {
+        "entity",
+        Serialize_entity
+    },
+    {
+        "entity_10k",
+        Serialize_entity_10k
+    },
+    {
+        "id",
+        Serialize_id
+    },
+    {
+        "enum",
+        Serialize_enum
+    },
+    {
+        "bitmask",
+        Serialize_bitmask
+    },
+    {
+        "float_nan",
+        Serialize_float_nan
+    },
+    {
+        "float_inf",
+        Serialize_float_inf
+    },
+    {
+        "double_nan",
+        Serialize_double_nan
+    },
+    {
+        "double_inf",
+        Serialize_double_inf
+    },
+    {
+        "struct_enum",
+        Serialize_struct_enum
+    },
+    {
+        "struct_bitmask",
+        Serialize_struct_bitmask
+    },
+    {
+        "struct_i32",
+        Serialize_struct_i32
+    },
+    {
+        "struct_i32_i32",
+        Serialize_struct_i32_i32
+    },
+    {
+        "struct_entity",
+        Serialize_struct_entity
+    },
+    {
+        "struct_id",
+        Serialize_struct_id
+    },
+    {
+        "array_i32_3",
+        Serialize_array_i32_3
+    },
+    {
+        "array_struct_i32_i32",
+        Serialize_array_struct_i32_i32
+    },
+    {
+        "array_array_i32_3",
+        Serialize_array_array_i32_3
+    },
+    {
+        "vector_i32_3",
+        Serialize_vector_i32_3
+    },
+    {
+        "vector_struct_i32_i32",
+        Serialize_vector_struct_i32_i32
+    },
+    {
+        "vector_array_i32_3",
+        Serialize_vector_array_i32_3
+    },
+    {
+        "entity_entity_after_float",
+        Serialize_entity_entity_after_float
+    },
+    {
+        "struct_nested_i32",
+        Serialize_struct_nested_i32
+    },
+    {
+        "struct_nested_i32_i32",
+        Serialize_struct_nested_i32_i32
+    },
+    {
+        "struct_2_nested_i32_i32",
+        Serialize_struct_2_nested_i32_i32
+    },
+    {
+        "struct_i32_array_3",
+        Serialize_struct_i32_array_3
+    },
+    {
+        "struct_struct_i32_array_3",
+        Serialize_struct_struct_i32_array_3
+    },
+    {
+        "struct_struct_i32_i32_array_3",
+        Serialize_struct_struct_i32_i32_array_3
+    },
+    {
+        "struct_w_array_type_i32_i32",
+        Serialize_struct_w_array_type_i32_i32
+    },
+    {
+        "struct_w_array_type_struct",
+        Serialize_struct_w_array_type_struct
+    },
+    {
+        "struct_w_2_array_type_i32_i32",
+        Serialize_struct_w_2_array_type_i32_i32
+    },
+    {
+        "struct_w_2_array_type_struct",
+        Serialize_struct_w_2_array_type_struct
+    },
+    {
+        "struct_partial",
+        Serialize_struct_partial
+    },
+    {
+        "escape_simple_string",
+        Serialize_escape_simple_string
+    },
+    {
+        "escape_newline",
+        Serialize_escape_newline
+    },
+    {
+        "escape_2_newlines",
+        Serialize_escape_2_newlines
+    },
+    {
+        "escape_string_w_trailing_newline",
+        Serialize_escape_string_w_trailing_newline
+    },
+    {
+        "escape_string_w_2_trailing_newlines",
+        Serialize_escape_string_w_2_trailing_newlines
+    },
+    {
+        "escape_string_w_delim",
+        Serialize_escape_string_w_delim
+    }
+};
+
+bake_test_case Deserialize_testcases[] = {
+    {
+        "bool",
+        Deserialize_bool
+    },
+    {
+        "byte",
+        Deserialize_byte
+    },
+    {
+        "char",
+        Deserialize_char
+    },
+    {
+        "char_literal",
+        Deserialize_char_literal
+    },
+    {
+        "i8",
+        Deserialize_i8
+    },
+    {
+        "i16",
+        Deserialize_i16
+    },
+    {
+        "i32",
+        Deserialize_i32
+    },
+    {
+        "i64",
+        Deserialize_i64
+    },
+    {
+        "iptr",
+        Deserialize_iptr
+    },
+    {
+        "u8",
+        Deserialize_u8
+    },
+    {
+        "u16",
+        Deserialize_u16
+    },
+    {
+        "u32",
+        Deserialize_u32
+    },
+    {
+        "u64",
+        Deserialize_u64
+    },
+    {
+        "uptr",
+        Deserialize_uptr
+    },
+    {
+        "float",
+        Deserialize_float
+    },
+    {
+        "double",
+        Deserialize_double
+    },
+    {
+        "negative_int",
+        Deserialize_negative_int
+    },
+    {
+        "negative_float",
+        Deserialize_negative_float
+    },
+    {
+        "invalid_i8",
+        Deserialize_invalid_i8
+    },
+    {
+        "invalid_i16",
+        Deserialize_invalid_i16
+    },
+    {
+        "invalid_i32",
+        Deserialize_invalid_i32
+    },
+    {
+        "invalid_i64",
+        Deserialize_invalid_i64
+    },
+    {
+        "invalid_iptr",
+        Deserialize_invalid_iptr
+    },
+    {
+        "invalid_u8",
+        Deserialize_invalid_u8
+    },
+    {
+        "invalid_u16",
+        Deserialize_invalid_u16
+    },
+    {
+        "invalid_u32",
+        Deserialize_invalid_u32
+    },
+    {
+        "invalid_u64",
+        Deserialize_invalid_u64
+    },
+    {
+        "invalid_uptr",
+        Deserialize_invalid_uptr
+    },
+    {
+        "invalid_float",
+        Deserialize_invalid_float
+    },
+    {
+        "invalid_double",
+        Deserialize_invalid_double
+    },
+    {
+        "string",
+        Deserialize_string
+    },
+    {
+        "entity",
+        Deserialize_entity
+    },
+    {
+        "id",
+        Deserialize_id
+    },
+    {
+        "enum",
+        Deserialize_enum
+    },
+    {
+        "bitmask",
+        Deserialize_bitmask
+    },
+    {
+        "struct_enum",
+        Deserialize_struct_enum
+    },
+    {
+        "struct_bitmask",
+        Deserialize_struct_bitmask
+    },
+    {
+        "struct_i32",
+        Deserialize_struct_i32
+    },
+    {
+        "struct_i32_neg",
+        Deserialize_struct_i32_neg
+    },
+    {
+        "struct_i32_i32",
+        Deserialize_struct_i32_i32
+    },
+    {
+        "struct_entity",
+        Deserialize_struct_entity
+    },
+    {
+        "struct_id",
+        Deserialize_struct_id
+    },
+    {
+        "struct_nested_i32",
+        Deserialize_struct_nested_i32
+    },
+    {
+        "struct_nested_i32_i32",
+        Deserialize_struct_nested_i32_i32
+    },
+    {
+        "struct_2_nested_i32_i32",
+        Deserialize_struct_2_nested_i32_i32
+    },
+    {
+        "struct_member_i32",
+        Deserialize_struct_member_i32
+    },
+    {
+        "struct_member_i32_neg",
+        Deserialize_struct_member_i32_neg
+    },
+    {
+        "struct_member_i32_i32",
+        Deserialize_struct_member_i32_i32
+    },
+    {
+        "struct_member_nested_i32",
+        Deserialize_struct_member_nested_i32
+    },
+    {
+        "struct_member_nested_i32_i32",
+        Deserialize_struct_member_nested_i32_i32
+    },
+    {
+        "struct_member_2_nested_i32_i32",
+        Deserialize_struct_member_2_nested_i32_i32
+    },
+    {
+        "struct_member_2_nested_i32_i32_reverse",
+        Deserialize_struct_member_2_nested_i32_i32_reverse
+    },
+    {
+        "struct_i32_array_3",
+        Deserialize_struct_i32_array_3
+    },
+    {
+        "struct_struct_i32_array_3",
+        Deserialize_struct_struct_i32_array_3
+    },
+    {
+        "struct_struct_i32_i32_array_3",
+        Deserialize_struct_struct_i32_i32_array_3
+    },
+    {
+        "struct_w_array_type_i32_i32",
+        Deserialize_struct_w_array_type_i32_i32
+    },
+    {
+        "struct_w_array_type_struct",
+        Deserialize_struct_w_array_type_struct
+    },
+    {
+        "struct_w_2_array_type_i32_i32",
+        Deserialize_struct_w_2_array_type_i32_i32
+    },
+    {
+        "struct_w_2_array_type_struct",
+        Deserialize_struct_w_2_array_type_struct
+    },
+    {
+        "discover_type_int",
+        Deserialize_discover_type_int
+    },
+    {
+        "discover_type_negative_int",
+        Deserialize_discover_type_negative_int
+    },
+    {
+        "discover_type_float",
+        Deserialize_discover_type_float
+    },
+    {
+        "discover_type_negative_float",
+        Deserialize_discover_type_negative_float
+    },
+    {
+        "discover_type_string",
+        Deserialize_discover_type_string
+    },
+    {
+        "discover_type_multiline_string",
+        Deserialize_discover_type_multiline_string
+    },
+    {
+        "discover_type_entity",
+        Deserialize_discover_type_entity
+    },
+    {
+        "discover_type_bool",
+        Deserialize_discover_type_bool
+    },
+    {
+        "discover_type_unknown",
+        Deserialize_discover_type_unknown
+    },
+    {
+        "discover_type_invalid",
+        Deserialize_discover_type_invalid
+    }
+};
+
+
+static bake_test_suite suites[] = {
+    {
+        "Eval",
+        NULL,
+        NULL,
+        231,
+        Eval_testcases
+    },
+    {
+        "Assembly",
+        NULL,
+        NULL,
+        45,
+        Assembly_testcases
+    },
+    {
+        "Expr",
+        NULL,
+        NULL,
+        126,
+        Expr_testcases
+    },
+    {
+        "Vars",
+        NULL,
+        NULL,
+        14,
+        Vars_testcases
+    },
+    {
+        "Serialize",
+        NULL,
+        NULL,
+        55,
+        Serialize_testcases
+    },
+    {
+        "Deserialize",
+        NULL,
+        NULL,
+        69,
+        Deserialize_testcases
+    }
+};
+
+int main(int argc, char *argv[]) {
+    return bake_test_run("script", argc, argv, suites, 6);
+}
diff --git a/test/script/src/util.c b/test/script/src/util.c
new file mode 100644
index 000000000..ec6041fb6
--- /dev/null
+++ b/test/script/src/util.c
@@ -0,0 +1,93 @@
+#include <script.h>
+#include <stdio.h>
+
+void probe_system_w_ctx(
+    ecs_iter_t *it,
+    Probe *ctx) 
+{
+    if (!ctx) {
+        return;
+    }
+
+    ctx->param = it->param;
+    ctx->system = it->system;
+    ctx->event = it->event;
+    ctx->event_id = it->event_id;
+    ctx->offset = 0;
+    ctx->term_count = it->field_count;
+    ctx->term_index = it->term_index;
+
+    int i;
+    for (i = 0; i < ctx->term_count; i ++) {
+        ctx->c[ctx->invoked][i] = it->ids[i];
+        ctx->s[ctx->invoked][i] = ecs_field_src(it, i);
+
+        ecs_id_t e = ecs_field_id(it, i);
+        test_assert(e != 0);
+    }
+
+    for (i = 0; i < it->count; i ++) {
+        if (i + ctx->count < 256) {
+            ctx->e[i + ctx->count] = it->entities[i];
+        } else {
+            /* can't store more than that, tests shouldn't rely on
+                * getting back more than 256 results */
+        }
+    }
+    ctx->count += it->count;
+
+    ctx->invoked ++;
+}
+
+void probe_iter(
+    ecs_iter_t *it) 
+{
+    Probe *ctx = ecs_get_ctx(it->world);
+    if (!ctx) {
+        ctx = it->ctx;
+    }
+    probe_system_w_ctx(it, ctx);
+}
+
+void probe_has_entity(Probe *probe, ecs_entity_t e) {
+    int i;
+    for (i = 0; i < probe->count; i ++) {
+        if (probe->e[i] == e) {
+            break;
+        }
+    }
+
+    test_assert(i != probe->count);
+}
+
+void install_test_abort(void) {
+    ecs_os_set_api_defaults();
+    ecs_os_api_t os_api = ecs_os_api;
+    os_api.abort_ = test_abort;
+    ecs_os_set_api(&os_api);
+    ecs_log_set_level(-5);
+}
+
+const ecs_entity_t* bulk_new_w_type(
+    ecs_world_t *world, ecs_entity_t type_ent, int32_t count) 
+{
+    const ecs_type_t *type = ecs_get_type(world, type_ent);
+    test_assert(type != NULL);
+
+    ecs_id_t *ids = type->array;
+    int i = 0;
+    while ((ecs_id_get_flags(world, ids[i]) & EcsIdDontInherit)) {
+        i ++;
+    }
+    const ecs_entity_t *result = ecs_bulk_new_w_id(world, ids[i], count);
+    for (; i < type->count; i ++) {
+        for (int e = 0; e < count; e ++) {
+            if (ecs_id_get_flags(world, ids[i]) & EcsIdDontInherit) {
+                continue;
+            }
+            ecs_add_id(world, result[e], ids[i]);
+        }
+    }
+    
+    return result;
+}